From 6c294971f1b3a28cb10535edda755f0ced67bf20 Mon Sep 17 00:00:00 2001
From: acorrao <95718914+AdamCorrao@users.noreply.github.com>
Date: Wed, 7 Oct 2026 09:46:11 -0400
Subject: [PATCH 01/14] fix(symmetry): monoclinic unique axis from the 2-fold
 axis or the mirror normal (A102)

`_monoclinic_unique_axis` looked only for a proper 2-fold, so
`cell_constraints` raised "could not determine the monoclinic unique axis"
for every setting of the mirror-only groups Pm, Pc, Cm and Cc (space groups
6-9, 41 gemmi settings) since v0.1.1. The unique axis is now the invariant
direction of det(R)*R for any operation with |trace| = 1: the 2-fold axis or
the mirror/glide normal. One shared helper for every cell rule (the re/03b
cell tie groups, re/04's coarse groups, re/05/re/06).

Deliberate change (devkit tasks/deliberate-changes.md #4): the legacy TOPAS
writer and the easydiffraction policy/builder no longer refuse these groups
early.

Tests: Pm/Pc/Cm/Cc and P2, P2_1/c, C2/c in a-, b- and c-unique settings and
other cell choices, plus every monoclinic setting in gemmi's table (115).

Assisted-by: claude-code:claude-opus-5-5
---
 src/powderline/symmetry.py   | 15 ++++++++------
 tests/test_topas_symmetry.py | 40 ++++++++++++++++++++++++++++++++++++
 2 files changed, 49 insertions(+), 6 deletions(-)

diff --git a/src/powderline/symmetry.py b/src/powderline/symmetry.py
index 90d5387..eec798b 100644
--- a/src/powderline/symmetry.py
+++ b/src/powderline/symmetry.py
@@ -158,20 +158,23 @@ def _expanded_ops(sg: gemmi.SpaceGroup) -> list[tuple[np.ndarray, np.ndarray]]:
 
 
 def _monoclinic_unique_axis(ops: list[tuple[np.ndarray, np.ndarray]]) -> str:
-    """Unique axis of a monoclinic group from its proper 2-fold direction.
+    """Unique axis of a monoclinic group: its 2-fold axis or its mirror/glide normal.
 
-    The single proper 2-fold (det +1, trace -1) fixes the unique axis; its
-    invariant direction maps to the dominant cell axis a/b/c.
+    Every operation of a monoclinic point group other than 1 and -1 is a proper
+    2-fold (trace -1) or a mirror (trace +1). For either, ``det(R) R`` is a proper
+    2-fold about the unique axis, whose invariant direction maps to the dominant
+    cell axis a/b/c. Mirror-only groups (Pm, Pc, Cm, Cc) have no proper 2-fold,
+    so the mirror normal is needed (A102).
     """
     for R, _t in ops:
-        if abs(np.linalg.det(R) - 1.0) < _MAT_TOL and abs(np.trace(R) + 1.0) < _MAT_TOL:
-            evals, evecs = np.linalg.eig(R)
+        if abs(abs(np.trace(R)) - 1.0) < _MAT_TOL:
+            evals, evecs = np.linalg.eig(np.sign(np.linalg.det(R)) * R)
             for i in range(3):
                 if abs(evals[i].real - 1.0) < _MAT_TOL and abs(evals[i].imag) < _MAT_TOL:
                     direction = np.abs(evecs[:, i].real)
                     return _LENGTHS[int(np.argmax(direction))]
     raise SymmetryError(
-        "could not determine the monoclinic unique axis (no proper 2-fold found)"
+        "could not determine the monoclinic unique axis (no 2-fold axis or mirror found)"
     )
 
 
diff --git a/tests/test_topas_symmetry.py b/tests/test_topas_symmetry.py
index 71deb03..8b71a24 100644
--- a/tests/test_topas_symmetry.py
+++ b/tests/test_topas_symmetry.py
@@ -45,6 +45,46 @@ def test_monoclinic_unique_a_and_c():
     assert sym.cell_constraints("P 1 1 2/m").free_angles == ("gamma",)
 
 
+# Mirror-only groups (Pm, Pc, Cm, Cc: no proper 2-fold, the axis is the mirror
+# normal) and 2-fold groups, in all three unique-axis settings and several cell
+# choices (A102: these four groups raised "could not determine the monoclinic
+# unique axis" before).
+@pytest.mark.parametrize("space_group, axis", [
+    ("P 1 m 1", "b"), ("P 1 1 m", "c"), ("P m 1 1", "a"),
+    ("P 1 c 1", "b"), ("P 1 n 1", "b"), ("P 1 1 a", "c"), ("P 1 1 n", "c"),
+    ("P b 1 1", "a"), ("P c 1 1", "a"),
+    ("C 1 m 1", "b"), ("A 1 1 m", "c"), ("B m 1 1", "a"), ("I 1 m 1", "b"),
+    ("C 1 c 1", "b"), ("I 1 a 1", "b"), ("A 1 1 a", "c"), ("I 1 1 b", "c"),
+    ("B b 1 1", "a"), ("C c 1 1", "a"),
+    ("P 1 2 1", "b"), ("P 1 1 2", "c"), ("P 2 1 1", "a"),
+    ("P 1 21/c 1", "b"), ("P 1 1 21/a", "c"), ("P 21/b 1 1", "a"),
+    ("C 1 2/c 1", "b"), ("I 1 2/a 1", "b"), ("A 1 1 2/a", "c"), ("B 2/b 1 1", "a"),
+])
+def test_monoclinic_unique_axis_every_setting(space_group, axis):
+    r = sym.cell_constraints(space_group)
+    free_angle = {"a": "alpha", "b": "beta", "c": "gamma"}[axis]
+    assert r.crystal_system == "monoclinic"
+    assert r.unique_axis == axis
+    assert r.length_groups == (("a",), ("b",), ("c",))
+    assert r.free_angles == (free_angle,)
+    assert r.fixed_angles == tuple(a for a in ("alpha", "beta", "gamma") if a != free_angle)
+
+
+def test_monoclinic_unique_axis_all_gemmi_settings():
+    """Every monoclinic setting in gemmi's table: the axis is the H-M symbol's non-'1' slot."""
+    import gemmi
+
+    checked = 0
+    for sg in gemmi.spacegroup_table():
+        if sg.crystal_system_str() != "monoclinic":
+            continue
+        slots = sg.hm.split()[1:]
+        expected = "abc"[[i for i, s in enumerate(slots) if s != "1"][0]]
+        assert sym.cell_constraints(sg.xhm()).unique_axis == expected, sg.xhm()
+        checked += 1
+    assert checked == 115
+
+
 def test_tetragonal_hexagonal_ortho_triclinic():
     assert sym.cell_constraints("P 4/m m m").length_groups == (("a", "b"), ("c",))
     hexr = sym.cell_constraints("P 6/m m m")

From a0c1a1587ecff7fc3be4541e5ed846f783831f7d Mon Sep 17 00:00:00 2001
From: acorrao <95718914+AdamCorrao@users.noreply.github.com>
Date: Wed, 7 Oct 2026 11:15:02 -0400
Subject: [PATCH 02/14] feat(core): one phase block, Phase[P] with refinable
 values and canonical space groups (A93-A96, A100, A105)

The core phase model is now one block: `Phase[P]`, `UnitCell[P]` and
`Atom[P]`, generic over the parameter type P (RefinableParameter, or
BoundedRefinableParameter for engines that honor bounds; one P for cell and
atoms, review N6). Every structural quantity (cell a..gamma; atom x, y, z,
occupancy, Uiso, U11..U23) is `[value, refine_flag]`; element, ADP, a stated
Multiplicity and the space group stay plain values. Engine schemas subclass
`Phase[TheirType]` and add their own fields flat (gsasii: scale,
peak_broadening).

- Value rules unchanged in substance, now on `.value` (A63, A69, A73,
  A76-A78); canonicalization replaces `.value` and keeps the flag and bounds.
- No null and no defaults (A96): occupancy is required; Multiplicity, Uiso and
  Uaniso may be left out but never null; a dump leaves them out, so it
  validates again.
- No phase_name: the phases dict key is the name (A100).
- `space_group` must be gemmi's canonical xhm() name exactly (A105); any other
  spelling is an error naming the canonical form (both settings / origins for
  a bare rhombohedral / two-origin symbol). New engine-free
  `symmetry.canonical_space_group`; the lenient resolve_space_group stays for
  the legacy paths.
- Reserved names: an engine subclass that redeclares space_group, unit_cell or
  atoms raises TypeError at class definition.
- `CoreModel` base + `CoreJsonSchema`: readable $defs names (`Atom`, not
  `Atom_RefinableParameter_`); qualified fallback if two parameter types ever
  share a document (devkit tasks/re03b-spike-generics.md).
- Removed: PhaseStructure, StructureRefinableParameter,
  StructureBoundedRefinableParameter and the null-value schema note (A71's
  structure part is superseded by A93/A96).

Flag and bound rules (F1-F4) follow in a later commit. Nothing at runtime
consumes the phase model yet; the legacy 0.26.0 schema is unchanged.

Tests: test_schema_core reworked by ID (17 Structure*-only tests and 14
Structure* numeric parametrizations removed, 22 test_phase_structure_* renamed
test_phase_*), plus new phase-block tests.

Assisted-by: claude-code:claude-opus-5-5
Assisted-by: claude-code:claude-sonnet-5-5
---
 src/powderline/schema_core.py | 309 ++++++++------
 src/powderline/symmetry.py    |  38 ++
 tests/test_schema_core.py     | 730 ++++++++++++++++++++--------------
 3 files changed, 650 insertions(+), 427 deletions(-)

diff --git a/src/powderline/schema_core.py b/src/powderline/schema_core.py
index 89997f2..12a8ac7 100644
--- a/src/powderline/schema_core.py
+++ b/src/powderline/schema_core.py
@@ -21,9 +21,11 @@
 
 from __future__ import annotations
 
+import inspect
 import json
 import math
-from typing import Annotated, Any, Literal, Optional
+import re
+from typing import Annotated, Any, Generic, Literal, Optional, TypeVar
 
 import gemmi
 import numpy as np
@@ -42,10 +44,11 @@
     model_serializer,
     model_validator,
 )
+from pydantic.json_schema import DEFAULT_REF_TEMPLATE, GenerateJsonSchema, JsonSchemaMode
 from pydantic_core import InitErrorDetails, PydanticCustomError
 
 from powderline.exceptions import StructuredWarning, SymmetryError
-from powderline.symmetry import analyze_site, check_cell, check_uij, resolve_space_group
+from powderline.symmetry import analyze_site, canonical_space_group, check_cell, check_uij
 
 # --- versions (A40, A65) ---------------------------------------------------
 
@@ -112,6 +115,40 @@ def _array_schema(title: str, items: list[dict], description: str, **extra) -> d
 _STRICT = ConfigDict(extra="forbid")
 
 
+class CoreJsonSchema(GenerateJsonSchema):
+    """JSON Schema generator that names a parametrized core model after its origin.
+
+    pydantic names ``Atom[RefinableParameter]`` ``Atom_RefinableParameter_`` in
+    ``$defs``; a recipe document holds one engine's schema (one parameter type),
+    so plain ``Atom`` is unambiguous and readable. Only the short candidate names
+    (no module path, no id) are shortened: pydantic's content-based dedup then
+    falls back to its qualified names if two parametrizations ever share one
+    document, and the id-bearing name it needs unique is left intact (devkit
+    ``tasks/re03b-spike-generics.md``).
+    """
+
+    def normalize_name(self, name: str) -> str:
+        if "." not in name and ":" not in name:
+            name = re.sub(r"\[[^\]]*\]", "", name)
+        return super().normalize_name(name)
+
+
+class CoreModel(BaseModel):
+    """Base of the core models: ``extra='forbid'`` and :class:`CoreJsonSchema` by default.
+
+    Engine schemas build on it (directly, or through :class:`CoreRecipe` and
+    :class:`Phase`), so their generated JSON Schema is readable too.
+    """
+
+    model_config = _STRICT
+
+    @classmethod
+    def model_json_schema(cls, by_alias: bool = True, ref_template: str = DEFAULT_REF_TEMPLATE,
+                          schema_generator: type[GenerateJsonSchema] = CoreJsonSchema,
+                          mode: JsonSchemaMode = "validation", **kwargs) -> dict[str, Any]:
+        return super().model_json_schema(by_alias, ref_template, schema_generator, mode, **kwargs)
+
+
 # --- numbers -----------------------------------------------------------------
 
 
@@ -131,7 +168,7 @@ def _integer_not_text_or_bool(v: Any) -> Any:
 CoreInt = Annotated[int, BeforeValidator(_integer_not_text_or_bool)]
 
 
-# --- parameter models (A20, A32, A71) ---------------------------------------
+# --- parameter models (A20, A32, A93) ---------------------------------------
 
 
 def _finite(name: str, v: Optional[float]) -> Optional[float]:
@@ -145,8 +182,7 @@ class RefinableParameter(BaseModel):
 
     Used where the engine has no native bounds for the quantity. A 4-element
     list here is an error, never silently truncated (A20). ``value`` is
-    required; see :class:`StructureRefinableParameter` for the quantities whose
-    starting value may come from the phase structure.
+    required (never ``null``, A93/A96).
     """
 
     model_config = _STRICT
@@ -184,9 +220,7 @@ def _to_list(self) -> list:
 
     @classmethod
     def __get_pydantic_json_schema__(cls, core_schema, handler) -> dict:
-        nullable = cls.model_fields["value"].annotation is not float
-        return _array_schema(cls.__name__, [_NUMBER_OR_NULL if nullable else _NUMBER, _BOOLEAN],
-                             "[value, refine_flag]" + (_NULL_VALUE_NOTE if nullable else ""))
+        return _array_schema(cls.__name__, [_NUMBER, _BOOLEAN], "[value, refine_flag]")
 
 
 class BoundedRefinableParameter(BaseModel):
@@ -194,8 +228,8 @@ class BoundedRefinableParameter(BaseModel):
 
     ``min``/``max`` may each be ``null`` (unbounded on that side). When given,
     ``min <= max`` and ``min <= value <= max``. Used only where the engine
-    honors the bounds natively (A20, A33). ``value`` is required; see
-    :class:`StructureBoundedRefinableParameter`.
+    honors the bounds natively (A20, A33). ``value`` is required (never
+    ``null``, A93/A96).
     """
 
     model_config = _STRICT
@@ -229,8 +263,7 @@ def _bounds(self) -> "BoundedRefinableParameter":
         lo, hi = self.min, self.max
         if lo is not None and hi is not None and lo > hi:
             raise ValueError(f"min ({lo}) must be <= max ({hi})")
-        if self.value is not None:
-            check_within_bounds(self.value, self, "value")
+        check_within_bounds(self.value, self, "value")
         return self
 
     @model_serializer
@@ -239,44 +272,15 @@ def _to_list(self) -> list:
 
     @classmethod
     def __get_pydantic_json_schema__(cls, core_schema, handler) -> dict:
-        nullable = cls.model_fields["value"].annotation is not float
-        return _array_schema(cls.__name__,
-                             [_NUMBER_OR_NULL if nullable else _NUMBER, _BOOLEAN,
-                              _NUMBER_OR_NULL, _NUMBER_OR_NULL],
-                             "[value, refine_flag, min, max]; min/max may be null"
-                             + (_NULL_VALUE_NOTE if nullable else ""))
-
-
-_NULL_VALUE_NOTE = "; value null = start from the phase structure's value"
-
-
-class StructureRefinableParameter(RefinableParameter):
-    """:class:`RefinableParameter` for a quantity that mirrors a phase-structure value.
-
-    For cell lengths/angles and atom x/y/z, occupancy, Uiso/Uaniso only (A71):
-    ``value`` may be ``null``, meaning "start from the structure's value"
-    (today's behavior: the GSAS-II setters skip a null value).
-    """
-
-    value: Optional[CoreFloat]
-
-
-class StructureBoundedRefinableParameter(BoundedRefinableParameter):
-    """:class:`BoundedRefinableParameter` for a quantity that mirrors a phase-structure value.
-
-    ``value`` may be ``null`` (start from the structure's value, A71); the
-    bounds are then checked against that value by the phase-level validator
-    (:func:`check_within_bounds`).
-    """
-
-    value: Optional[CoreFloat]
+        return _array_schema(cls.__name__, [_NUMBER, _BOOLEAN, _NUMBER_OR_NULL, _NUMBER_OR_NULL],
+                             "[value, refine_flag, min, max]; min/max may be null")
 
 
 def check_within_bounds(value: float, param: BoundedRefinableParameter, field: str) -> None:
     """Raise ``ValueError`` unless ``param.min <= value <= param.max`` (open ends pass).
 
-    Also used at the phase level for a null-valued
-    :class:`StructureBoundedRefinableParameter`, with the structure's value.
+    Also used at the phase level, on a value canonicalized after the
+    parameter's own check (review N4).
     """
     if param.min is not None and value < param.min:
         raise ValueError(f"{field} ({value}) is below min ({param.min})")
@@ -497,84 +501,117 @@ def _coefficients_finite(cls, v):
         return v
 
 
-# --- phase structure (A32, A35, A62, A63, A69, A73) -------------------------
+# --- phase block (A93-A96, A100, A105; values: A63, A69, A73, A76-A78) -------
 
+#: The parameter type of a phase block: :class:`RefinableParameter`, or
+#: :class:`BoundedRefinableParameter` for an engine that honors bounds (A20).
+#: One type for every structural field, cell and atoms (review N6).
+P = TypeVar("P", RefinableParameter, BoundedRefinableParameter)
 
-class UnitCell(BaseModel):
-    """Cell constants (values, not refinables). No ``volume``: every engine
-    derives it from a..gamma (A75)."""
 
-    model_config = _STRICT
+def _absent_not_null(v: Any, info) -> Any:
+    """A field that may be left out is never ``null`` (A96): reject an explicit null."""
+    if v is None:
+        raise ValueError(f"{info.field_name} must not be null; leave it out instead")
+    return v
 
-    a: CoreFloat = Field(json_schema_extra=_unit(UNIT_ANGSTROM))
-    b: CoreFloat = Field(json_schema_extra=_unit(UNIT_ANGSTROM))
-    c: CoreFloat = Field(json_schema_extra=_unit(UNIT_ANGSTROM))
-    alpha: CoreFloat = Field(json_schema_extra=_unit(UNIT_DEGREE))
-    beta: CoreFloat = Field(json_schema_extra=_unit(UNIT_DEGREE))
-    gamma: CoreFloat = Field(json_schema_extra=_unit(UNIT_DEGREE))
+
+def _absent_not_null_schema(unit: Optional[str] = None):
+    """JSON Schema of a field that may be left out but is never null (A96).
+
+    The field is ``Optional`` only so that "left out" can be held as ``None``;
+    the schema shows the non-null type, no ``"default": null``, and the unit.
+    """
+    def extra(schema: dict) -> None:
+        schema.pop("default", None)
+        any_of = schema.pop("anyOf", None)
+        if any_of:
+            schema.update(next(s for s in any_of if s.get("type") != "null"))
+        if unit:
+            schema.update(_unit(unit))
+    return extra
+
+
+class UnitCell(CoreModel, Generic[P]):
+    """Cell constants, each a refinable parameter. No ``volume``: every engine
+    derives it from a..gamma (A75). The values must fit the space group (A77,
+    checked by :class:`Phase`)."""
+
+    a: P = Field(json_schema_extra=_unit(UNIT_ANGSTROM))
+    b: P = Field(json_schema_extra=_unit(UNIT_ANGSTROM))
+    c: P = Field(json_schema_extra=_unit(UNIT_ANGSTROM))
+    alpha: P = Field(json_schema_extra=_unit(UNIT_DEGREE))
+    beta: P = Field(json_schema_extra=_unit(UNIT_DEGREE))
+    gamma: P = Field(json_schema_extra=_unit(UNIT_DEGREE))
 
     @field_validator("a", "b", "c")
     @classmethod
     def _length(cls, v, info):
-        if not (math.isfinite(v) and v > 0):
-            raise ValueError(f"cell length {info.field_name} must be positive, got {v}")
+        if not v.value > 0:
+            raise ValueError(f"cell length {info.field_name} must be positive, got {v.value}")
         return v
 
     @field_validator("alpha", "beta", "gamma")
     @classmethod
     def _angle(cls, v, info):
-        if not (math.isfinite(v) and 0 < v < 180):
-            raise ValueError(f"cell angle {info.field_name} must be between 0 and 180 degrees, got {v}")
+        if not 0 < v.value < 180:
+            raise ValueError(f"cell angle {info.field_name} must be between 0 and 180 degrees, got {v.value}")
         return v
 
 
 _UANISO_KEYS = ("U11", "U22", "U33", "U12", "U13", "U23")
 
 
-class Atom(BaseModel):
-    """One atom of a phase structure (values, not refinables).
+class Atom(CoreModel, Generic[P]):
+    """One atom of a phase: coordinates, occupancy and ADPs are refinable parameters.
 
     Coordinates are fractional JSON numbers. A special position is declared by
-    stating it to at least 6 decimals. The validated phase holds canonical
-    (exact) coordinates and reports every adjustment (A73). ``Multiplicity`` is
-    optional and, when stated, must match the derived value (A69 T3).
-    ``occupancy`` is 0 to 1 inclusive, even where an engine would accept more
-    (A76). ``Uaniso`` must respect the site symmetry: within 1e-6 A^2 it is set
-    to the symmetric values and reported, beyond that it is an error (A78).
+    stating it to at least 6 decimals; the validated phase holds the canonical
+    (exact) values and reports every adjustment (A73). ``occupancy`` is required
+    and 0 to 1 inclusive (A76, A96). ``Multiplicity`` is optional and, when
+    stated, must match the derived value (A69 T3). ``ADP`` selects ``Uiso`` or
+    ``Uaniso`` (all six of U11..U23); the other is left out. ``Uaniso`` must
+    respect the site symmetry: within 1e-6 A^2 it is set to the symmetric values
+    and reported, beyond that it is an error (A78). Nothing is ``null`` (A96).
     """
 
-    model_config = _STRICT
-
     element: str = Field(description="Bare element symbol, exactly as in the periodic table (e.g. 'Fe')")
-    x: CoreFloat = Field(description="Fractional x coordinate")
-    y: CoreFloat = Field(description="Fractional y coordinate")
-    z: CoreFloat = Field(description="Fractional z coordinate")
-    occupancy: CoreFloat = Field(default=1.0, ge=0.0, le=1.0, description="Site occupancy, 0 to 1 inclusive (A76)")
-    Multiplicity: Optional[CoreInt] = Field(default=None, description="Site multiplicity; cross-checked when stated")
+    x: P = Field(description="Fractional x coordinate")
+    y: P = Field(description="Fractional y coordinate")
+    z: P = Field(description="Fractional z coordinate")
+    occupancy: P = Field(description="Site occupancy, 0 to 1 inclusive (A76)")
+    Multiplicity: Optional[CoreInt] = Field(default=None, json_schema_extra=_absent_not_null_schema(),
+                                            description="Site multiplicity; optional, cross-checked when stated")
     ADP: Literal["Uiso", "Uaniso"] = Field(description="Displacement-parameter type")
-    Uiso: Optional[CoreFloat] = Field(default=None, json_schema_extra=_unit(UNIT_ANGSTROM2))
-    Uaniso: Optional[dict[Literal["U11", "U22", "U33", "U12", "U13", "U23"], CoreFloat]] = Field(
-        default=None, json_schema_extra=_unit(UNIT_ANGSTROM2),
-        description="All six of U11, U22, U33, U12, U13, U23")
+    Uiso: Optional[P] = Field(default=None, json_schema_extra=_absent_not_null_schema(UNIT_ANGSTROM2),
+                              description="Isotropic ADP; given when ADP is 'Uiso'")
+    Uaniso: Optional[dict[Literal["U11", "U22", "U33", "U12", "U13", "U23"], P]] = Field(
+        default=None, json_schema_extra=_absent_not_null_schema(UNIT_ANGSTROM2),
+        description="All six of U11, U22, U33, U12, U13, U23; given when ADP is 'Uaniso'")
+
+    _not_null = field_validator("Multiplicity", "Uiso", "Uaniso", mode="before")(_absent_not_null)
 
     @field_validator("element")
     @classmethod
     def _element(cls, v: str) -> str:
         return check_element_symbol(v)
 
-    @field_validator("x", "y", "z", "occupancy", "Uiso")
-    @classmethod
-    def _finite(cls, v, info):
-        return _finite(info.field_name, v)
-
-    @field_validator("Uaniso")
+    @field_validator("occupancy")
     @classmethod
-    def _uaniso_finite(cls, v):
-        if v is not None:
-            for k, u in v.items():
-                _finite(k, u)
+    def _occupancy(cls, v):
+        if not 0.0 <= v.value <= 1.0:
+            raise ValueError(f"occupancy must be between 0 and 1 inclusive, got {v.value}")
         return v
 
+    @model_serializer(mode="wrap")
+    def _omit_absent(self, handler):
+        """Leave out absent optional fields, so a dump validates again (no ``null``, A96)."""
+        data = handler(self)
+        for name in ("Multiplicity", "Uiso", "Uaniso"):
+            if getattr(self, name) is None:
+                data.pop(name, None)
+        return data
+
     @model_validator(mode="after")
     def _adp_block(self) -> "Atom":
         if self.ADP == "Uiso":
@@ -590,46 +627,67 @@ def _adp_block(self) -> "Atom":
         return self
 
 
-class PhaseStructure(BaseModel):
-    """A phase's crystal structure: space group, cell, atoms (core-owned, A35).
+#: Phase fields owned by core; an engine subclass may not redeclare them (A93).
+RESERVED_PHASE_FIELDS = ("space_group", "unit_cell", "atoms")
 
-    Validation derives each atom's site (multiplicity, DOF) from the space group
-    (:func:`powderline.symmetry.analyze_site`). It rejects ambiguous positions
-    and stated multiplicities that don't match. It replaces stated coordinates
-    with the canonical ones, so every engine receives the same exact structure.
-    Each adjustment is reported by :meth:`warnings` (A73). The unit cell must
-    fit the space group exactly (A77), and anisotropic ADPs the site symmetry
-    (A78).
 
-    Every structural problem is reported at its own location (A70):
-    ``unit_cell``, ``atoms.<label>`` (the position), ``atoms.<label>.Multiplicity``,
+class Phase(CoreModel, Generic[P]):
+    """A phase block's core part: space group, cell and atoms (A93).
+
+    Engine schemas subclass ``Phase[TheirParameterType]`` and add their own
+    phase fields flat (gsasii: ``scale``, ``peak_broadening``); the phase name
+    is the key of the payload's ``phases`` dict (A100). Core's field names are
+    reserved (:data:`RESERVED_PHASE_FIELDS`): redeclaring one raises
+    ``TypeError`` when the subclass is defined.
+
+    ``space_group`` is gemmi's canonical name (A105). Validation derives each
+    atom's site (multiplicity, DOF) from it (:func:`powderline.symmetry.analyze_site`),
+    rejects ambiguous positions and stated multiplicities that don't match, and
+    replaces stated coordinates with the canonical ones (keeping each refine
+    flag and bounds), so every engine receives the same exact structure. Each
+    adjustment is reported by :meth:`warnings` (A73). The unit cell must fit the
+    space group exactly (A77), and anisotropic ADPs the site symmetry (A78).
+
+    Every problem is reported at its own location (A70): ``unit_cell``,
+    ``atoms.<label>`` (the position), ``atoms.<label>.Multiplicity``,
     ``atoms.<label>.Uaniso``; all of them together, in one ``ValidationError``.
     These checks run only once every field is valid: pydantic does not run
     model-level validators after a field error, so e.g. an unknown element is
     reported first, and the symmetry checks follow once it is fixed.
-    Validation never modifies the caller's :class:`Atom` objects; adjusted atoms
-    are copies.
+    Validation never modifies the caller's objects; adjusted atoms are copies.
     """
 
-    model_config = _STRICT
-
-    phase_name: str = Field(min_length=1)
-    space_group: str = Field(description="Hermann-Mauguin symbol with an explicit setting "
-                                         "for two-origin (':1'/':2') and rhombohedral (':H'/':R') groups")
-    unit_cell: UnitCell
-    atoms: dict[str, Atom] = Field(min_length=1, description="Atoms keyed by unique label")
+    space_group: str = Field(description="gemmi's canonical extended Hermann-Mauguin name, e.g. "
+                                         "'P m -3 m', 'C 1 2/m 1', 'R -3 m:H', 'F d -3 m:2' (A105)")
+    unit_cell: UnitCell[P]
+    atoms: dict[str, Atom[P]] = Field(min_length=1, description="Atoms keyed by unique label")
 
     _sites: dict = PrivateAttr(default_factory=dict)
     _warnings: list = PrivateAttr(default_factory=list)
 
+    @classmethod
+    def __pydantic_init_subclass__(cls, **kwargs: Any) -> None:
+        super().__pydantic_init_subclass__(**kwargs)
+        for klass in cls.__mro__:
+            if klass is Phase or not (isinstance(klass, type) and issubclass(klass, Phase)):
+                continue
+            if klass.__pydantic_generic_metadata__["origin"] is Phase:
+                continue  # Phase[SomeParameterType] itself
+            redeclared = [n for n in RESERVED_PHASE_FIELDS if n in inspect.get_annotations(klass)]
+            if redeclared:
+                raise TypeError(
+                    f"{klass.__name__} redeclares the core phase field(s) {', '.join(redeclared)}; "
+                    "core owns space_group, unit_cell and atoms (A93)"
+                )
+
     @field_validator("space_group")
     @classmethod
     def _space_group(cls, v: str) -> str:
-        resolve_space_group(v, explicit_setting=True)  # SymmetryError is a ValueError
+        canonical_space_group(v)  # SymmetryError is a ValueError
         return v
 
     @model_validator(mode="after")
-    def _sites_check(self) -> "PhaseStructure":
+    def _sites_check(self) -> "Phase":
         problems: list[InitErrorDetails] = []
 
         def problem(loc: tuple, message: str, value: Any) -> None:
@@ -638,12 +696,12 @@ def problem(loc: tuple, message: str, value: Any) -> None:
 
         cell = self.unit_cell
         try:
-            check_cell(self.space_group, (cell.a, cell.b, cell.c, cell.alpha, cell.beta, cell.gamma))
+            check_cell(self.space_group, tuple(getattr(cell, k).value for k in _CELL_FIELDS))
         except SymmetryError as exc:
             problem(("unit_cell",), str(exc), cell.model_dump())
         for label, atom in list(self.atoms.items()):
             try:
-                site = analyze_site(self.space_group, (atom.x, atom.y, atom.z))
+                site = analyze_site(self.space_group, (atom.x.value, atom.y.value, atom.z.value))
             except SymmetryError as exc:
                 problem(("atoms", label), str(exc), atom.model_dump())
                 continue  # the checks below need the site
@@ -653,23 +711,25 @@ def problem(loc: tuple, message: str, value: Any) -> None:
                         f"stated Multiplicity {atom.Multiplicity}, derived {site.multiplicity} "
                         f"({self.space_group!r}, site {site.stated})", atom.Multiplicity)
             if atom.Uaniso is not None:
-                stated_u = tuple(atom.Uaniso[k] for k in _UANISO_KEYS)
+                stated_u = tuple(atom.Uaniso[k].value for k in _UANISO_KEYS)
                 try:
                     symmetric_u, u_adjusted = check_uij(self.space_group, site.canonical, stated_u)
                 except SymmetryError as exc:
-                    problem(("atoms", label, "Uaniso"), str(exc), atom.Uaniso)
+                    problem(("atoms", label, "Uaniso"), str(exc), atom.model_dump()["Uaniso"])
                 else:
                     if u_adjusted:
-                        update["Uaniso"] = dict(zip(_UANISO_KEYS, symmetric_u))
+                        update["Uaniso"] = {k: _with_value(atom.Uaniso[k], u)
+                                            for k, u in zip(_UANISO_KEYS, symmetric_u)}
                         self._warnings.append(StructuredWarning(
                             code="adp_symmetry_adjusted",
                             message=(f"atom {label!r}: Uaniso {dict(zip(_UANISO_KEYS, stated_u))} "
-                                     f"adjusted to the site-symmetric values {update['Uaniso']}"),
+                                     f"adjusted to the site-symmetric values "
+                                     f"{dict(zip(_UANISO_KEYS, symmetric_u))}"),
                             field_path=f"atoms.{label}.Uaniso",
                         ))
             self._sites[label] = site
             if site.adjusted:
-                update.update(zip(("x", "y", "z"), site.canonical))
+                update.update({k: _with_value(getattr(atom, k), v) for k, v in zip("xyz", site.canonical)})
                 self._warnings.append(StructuredWarning(
                     code="special_position_adjusted",
                     message=(f"atom {label!r}: coordinates {site.stated} are on a special position "
@@ -688,10 +748,17 @@ def site(self, label: str):
         return self._sites[label]
 
     def warnings(self) -> list:
-        """Structured warnings raised while validating this structure (paths relative to it)."""
+        """Structured warnings raised while validating this phase (paths relative to it)."""
         return list(self._warnings)
 
 
+_CELL_FIELDS = ("a", "b", "c", "alpha", "beta", "gamma")
+
+
+def _with_value(param, value: float):
+    """A copy of ``param`` with a new value; refine flag and bounds kept."""
+    return param.model_copy(update={"value": value})
+
 
 # --- top-level recipe frame (A1, A18, A21, A40) ------------------------------
 
@@ -712,7 +779,7 @@ def _check_metadata(v: Optional[dict]) -> Optional[dict]:
     return v
 
 
-class CoreRecipe(BaseModel):
+class CoreRecipe(CoreModel):
     """The core-owned top level of every recipe; engine schemas subclass it.
 
     An engine schema narrows ``schema_name`` to its own names, types ``payload``,
@@ -721,8 +788,6 @@ class CoreRecipe(BaseModel):
     for JSON-serializability and size, and echoed into results (A21, A64).
     """
 
-    model_config = _STRICT
-
     schema_name: str = Field(pattern=SCHEMA_NAME_PATTERN,
                              description='Engine and workflow, e.g. "gsasii.rietveld"')
     core_schema_version: str = Field(description="Core schema version the recipe is written against")
diff --git a/src/powderline/symmetry.py b/src/powderline/symmetry.py
index eec798b..0fbefde 100644
--- a/src/powderline/symmetry.py
+++ b/src/powderline/symmetry.py
@@ -143,6 +143,43 @@ def resolve_space_group(space_group: str, *, explicit_setting: bool = False) ->
     return sg
 
 
+def canonical_space_group(space_group: str) -> gemmi.SpaceGroup:
+    """Return the gemmi group whose canonical name is exactly ``space_group`` (core rule, A105).
+
+    The canonical name is gemmi's extended Hermann-Mauguin symbol ``xhm()``
+    (``"P m -3 m"``, ``"C 1 2/m 1"``, ``"R -3 m:H"``, ``"F d -3 m:2"``); it is
+    unique over gemmi's table and names the setting. Any other spelling raises
+    :class:`SymmetryError` whose message names the canonical form. gemmi's
+    lenient lookup is used only to build that suggestion, never to accept: it
+    would silently pick a default (``"Fd-3m"`` -> origin 1, ``"R-3m"`` -> ``:H``,
+    ``"C2/m"`` -> b-unique). A symbol without a setting lists both choices.
+    The legacy 0.26.0 paths keep the lenient :func:`resolve_space_group`.
+    """
+    raw = str(space_group)
+    sg = gemmi.find_spacegroup_by_name(raw)
+    if sg is not None and sg.xhm() == raw:
+        return sg
+    if sg is None:
+        sg = gemmi.find_spacegroup_by_name(raw.replace(" ", ""))
+    if sg is None:
+        raise SymmetryError(
+            f"unrecognized space-group symbol {raw!r}; write gemmi's canonical name "
+            "(e.g. 'P m -3 m', 'C 1 2/m 1', 'R -3 m:H', 'F d -3 m:2')"
+        )
+    if ":" not in raw and sg.ext in ("H", "R"):
+        hexagonal, rhombohedral = (gemmi.find_spacegroup_by_name(f"{sg.hm}:{s}").xhm() for s in "HR")
+        raise SymmetryError(
+            f"space group {raw!r} does not name its setting; write {hexagonal!r} (hexagonal axes) "
+            f"or {rhombohedral!r} (rhombohedral axes)"
+        )
+    if ":" not in raw and sg.ext in ("1", "2"):
+        origin1, origin2 = (gemmi.find_spacegroup_by_name(f"{sg.hm}:{s}").xhm() for s in "12")
+        raise SymmetryError(
+            f"space group {raw!r} has two origin choices; write {origin1!r} or {origin2!r}"
+        )
+    raise SymmetryError(f"space group {raw!r} is not in the canonical form; write {sg.xhm()!r}")
+
+
 def _expanded_ops(sg: gemmi.SpaceGroup) -> list[tuple[np.ndarray, np.ndarray]]:
     """All symmetry operations (centering expanded) as (R float 3x3, t float 3)."""
     den = float(gemmi.Op.DEN)
@@ -603,3 +640,4 @@ def check_uij(space_group: str, xyz, uij) -> tuple[tuple[float, ...], bool]:
     if not np.any(np.abs(symmetric - stated) > ADJUSTMENT_REPORT_TOL):
         return tuple(float(v) for v in stated), False
     return tuple(float(v) for v in symmetric), True
+
diff --git a/tests/test_schema_core.py b/tests/test_schema_core.py
index 775f5ea..fa79315 100644
--- a/tests/test_schema_core.py
+++ b/tests/test_schema_core.py
@@ -502,8 +502,6 @@ def test_check_core_schema_version_rejects_unsupported():
 from powderline.schema_core import (
     BoundedRefinableParameter,
     RefinableParameter,
-    StructureBoundedRefinableParameter,
-    StructureRefinableParameter,
     check_within_bounds,
 )
 from pydantic import BaseModel
@@ -520,16 +518,6 @@ class _WrapperBRP(BaseModel):
     a: BoundedRefinableParameter
 
 
-class _WrapperSRP(BaseModel):
-    """Wrapper for StructureRefinableParameter testing."""
-    a: StructureRefinableParameter
-
-
-class _WrapperSBRP(BaseModel):
-    """Wrapper for StructureBoundedRefinableParameter testing."""
-    a: StructureBoundedRefinableParameter
-
-
 # --- 1. JSON shape round-trip -----------------------------------------------
 
 
@@ -553,26 +541,6 @@ def test_bounded_refinable_parameter_model_dump_json():
     assert json.loads(brp.model_dump_json()) == [1.5, True, 0.0, 2.0]
 
 
-def test_structure_refinable_parameter_model_dump():
-    srp = StructureRefinableParameter.model_validate([None, True])
-    assert srp.model_dump() == [None, True]
-
-
-def test_structure_refinable_parameter_model_dump_with_value():
-    srp = StructureRefinableParameter.model_validate([1.5, False])
-    assert srp.model_dump() == [1.5, False]
-
-
-def test_structure_bounded_refinable_parameter_model_dump():
-    sbrp = StructureBoundedRefinableParameter.model_validate([None, True, 0.0, 2.0])
-    assert sbrp.model_dump() == [None, True, 0.0, 2.0]
-
-
-def test_structure_bounded_refinable_parameter_model_dump_with_value():
-    sbrp = StructureBoundedRefinableParameter.model_validate([1.5, True, 0.0, 2.0])
-    assert sbrp.model_dump() == [1.5, True, 0.0, 2.0]
-
-
 # --- 2. RefinableParameter validation ---------------------------------------
 
 
@@ -716,62 +684,7 @@ def test_bounded_refinable_parameter_null_value_rejected():
     assert _errors(exc_info) == [(('a', 'value'), 'float_type')]
 
 
-# --- 4. StructureRefinableParameter / StructureBoundedRefinableParameter ----
-
-
-def test_structure_refinable_parameter_null_value_accepted_refine_true():
-    srp = StructureRefinableParameter.model_validate([None, True])
-    assert srp.value is None
-    assert srp.refine_flag is True
-
-
-def test_structure_refinable_parameter_null_value_accepted_refine_false():
-    srp = StructureRefinableParameter.model_validate([None, False])
-    assert srp.value is None
-    assert srp.refine_flag is False
-
-
-def test_structure_refinable_parameter_4_element_list_rejected():
-    with pytest.raises(ValidationError) as exc_info:
-        _WrapperSRP(a=[1.5, True, 0.0, 2.0])
-    err = exc_info.value
-    assert any("bounds are not supported" in e["msg"] for e in err.errors())
-
-
-def test_structure_refinable_parameter_refine_flag_null_rejected():
-    with pytest.raises(ValidationError) as exc_info:
-        _WrapperSRP(a=[None, None])
-    assert _errors(exc_info) == [(('a', 'refine_flag'), 'bool_type')]
-
-
-def test_structure_bounded_refinable_parameter_null_value_accepted():
-    sbrp = StructureBoundedRefinableParameter.model_validate([None, True, 0.0, 2.0])
-    assert sbrp.value is None
-    assert sbrp.refine_flag is True
-
-
-def test_structure_bounded_refinable_parameter_null_value_min_max_order_enforced():
-    with pytest.raises(ValidationError, match="min .* must be <= max"):
-        _WrapperSBRP(a=[None, True, 2.0, 1.0])
-
-
-def test_structure_bounded_refinable_parameter_non_null_value_enforces_bounds_below():
-    with pytest.raises(ValidationError, match="below min"):
-        _WrapperSBRP(a=[0.5, True, 1.0, 2.0])
-
-
-def test_structure_bounded_refinable_parameter_non_null_value_enforces_bounds_above():
-    with pytest.raises(ValidationError, match="above max"):
-        _WrapperSBRP(a=[2.5, True, 1.0, 2.0])
-
-
-def test_structure_bounded_refinable_parameter_refine_flag_null_rejected():
-    with pytest.raises(ValidationError) as exc_info:
-        _WrapperSBRP(a=[None, None, 0.0, 2.0])
-    assert _errors(exc_info) == [(('a', 'refine_flag'), 'bool_type')]
-
-
-# --- 5. check_within_bounds -------------------------------------------------
+# --- 4. check_within_bounds -------------------------------------------------
 
 
 def test_check_within_bounds_inside_passes():
@@ -816,7 +729,7 @@ def test_check_within_bounds_above_max_raises():
         check_within_bounds(2.5, param, "test_field")
 
 
-# --- 6. JSON schema ---------------------------------------------------------
+# --- 5. JSON schema ---------------------------------------------------------
 
 
 def test_refinable_parameter_json_schema():
@@ -843,33 +756,7 @@ def test_bounded_refinable_parameter_json_schema():
     assert param_schema["prefixItems"][3] == {"anyOf": [{"type": "number"}, {"type": "null"}]}
 
 
-def test_structure_refinable_parameter_json_schema():
-    schema = _WrapperSRP.model_json_schema()
-    param_schema = schema["$defs"]["StructureRefinableParameter"]
-    assert param_schema["type"] == "array"
-    assert len(param_schema["prefixItems"]) == 2
-    assert param_schema["minItems"] == 2
-    assert param_schema["maxItems"] == 2
-    assert param_schema["prefixItems"][0] == {"anyOf": [{"type": "number"}, {"type": "null"}]}
-    assert param_schema["prefixItems"][1] == {"type": "boolean"}
-    assert "structure" in param_schema["description"].lower()
-
-
-def test_structure_bounded_refinable_parameter_json_schema():
-    schema = _WrapperSBRP.model_json_schema()
-    param_schema = schema["$defs"]["StructureBoundedRefinableParameter"]
-    assert param_schema["type"] == "array"
-    assert len(param_schema["prefixItems"]) == 4
-    assert param_schema["minItems"] == 4
-    assert param_schema["maxItems"] == 4
-    assert param_schema["prefixItems"][0] == {"anyOf": [{"type": "number"}, {"type": "null"}]}
-    assert param_schema["prefixItems"][1] == {"type": "boolean"}
-    assert param_schema["prefixItems"][2] == {"anyOf": [{"type": "number"}, {"type": "null"}]}
-    assert param_schema["prefixItems"][3] == {"anyOf": [{"type": "number"}, {"type": "null"}]}
-    assert "structure" in param_schema["description"].lower()
-
-
-# --- 7. Identity preservation -----------------------------------------------
+# --- 6. Identity preservation -----------------------------------------------
 
 
 def test_refinable_parameter_instance_identity_preserved():
@@ -884,18 +771,6 @@ def test_bounded_refinable_parameter_instance_identity_preserved():
     assert w.a is p
 
 
-def test_structure_refinable_parameter_instance_identity_preserved():
-    p = StructureRefinableParameter.model_validate([1.5, True])
-    w = _WrapperSRP(a=p)
-    assert w.a is p
-
-
-def test_structure_bounded_refinable_parameter_instance_identity_preserved():
-    p = StructureBoundedRefinableParameter.model_validate([1.5, True, 0.0, 2.0])
-    w = _WrapperSBRP(a=p)
-    assert w.a is p
-
-
 # --- check_element_symbol (A32, A63) ----------------------------------------
 
 from powderline.schema_core import check_element_symbol  # noqa: E402
@@ -934,55 +809,54 @@ def test_unknown_element_rejected(symbol):
 from fractions import Fraction  # noqa: E402
 from pydantic import ValidationError  # noqa: E402
 
-from powderline.schema_core import UnitCell, Atom, PhaseStructure  # noqa: E402
+from powderline.schema_core import UnitCell, Atom, Phase, RefinableParameter  # noqa: E402
 from powderline.exceptions import SymmetryError  # noqa: E402
 
 
 def _valid_pmm_lab6_phase_dict():
     """Helper: valid P m -3 m LaB6-like phase (cubic a=4.15692, La at origin, B at 0.5,0.5,0.2021)."""
     return {
-        "phase_name": "LaB6",
         "space_group": "P m -3 m",
         "unit_cell": {
-            "a": 4.15692,
-            "b": 4.15692,
-            "c": 4.15692,
-            "alpha": 90.0,
-            "beta": 90.0,
-            "gamma": 90.0,
+            "a": [4.15692, False],
+            "b": [4.15692, False],
+            "c": [4.15692, False],
+            "alpha": [90.0, False],
+            "beta": [90.0, False],
+            "gamma": [90.0, False],
         },
         "atoms": {
             "La1": {
                 "element": "La",
-                "x": 0.0,
-                "y": 0.0,
-                "z": 0.0,
-                "occupancy": 1.0,
+                "x": [0.0, False],
+                "y": [0.0, False],
+                "z": [0.0, False],
+                "occupancy": [1.0, False],
                 "ADP": "Uiso",
-                "Uiso": 0.005,
+                "Uiso": [0.005, False],
             },
             "B1": {
                 "element": "B",
-                "x": 0.5,
-                "y": 0.5,
-                "z": 0.2021,
-                "occupancy": 1.0,
+                "x": [0.5, False],
+                "y": [0.5, False],
+                "z": [0.2021, False],
+                "occupancy": [1.0, False],
                 "ADP": "Uiso",
-                "Uiso": 0.006,
+                "Uiso": [0.006, False],
             },
         },
     }
 
 
-def test_phase_structure_valid_validates():
+def test_phase_valid_validates():
     """Valid phase validates with no warnings."""
-    phase = PhaseStructure.model_validate(_valid_pmm_lab6_phase_dict())
+    phase = Phase[RefinableParameter].model_validate(_valid_pmm_lab6_phase_dict())
     assert phase.warnings() == []
 
 
-def test_phase_structure_site_multiplicity():
+def test_phase_site_multiplicity():
     """Site multiplicity: La (origin) -> 1, B (0.5,0.5,0.2021) -> 6 in P m -3 m."""
-    phase = PhaseStructure.model_validate(_valid_pmm_lab6_phase_dict())
+    phase = Phase[RefinableParameter].model_validate(_valid_pmm_lab6_phase_dict())
     assert phase.site("La1").multiplicity == 1
     assert phase.site("B1").multiplicity == 6
 
@@ -990,191 +864,203 @@ def test_phase_structure_site_multiplicity():
 def test_unit_cell_length_zero_rejected():
     """UnitCell: a=0 rejected."""
     with pytest.raises(ValidationError, match="must be positive"):
-        UnitCell(a=0.0, b=4.0, c=4.0, alpha=90, beta=90, gamma=90)
+        UnitCell[RefinableParameter](a=[0.0, False], b=[4.0, False], c=[4.0, False], alpha=[90, False], beta=[90, False], gamma=[90, False])
 
 
 def test_unit_cell_length_negative_rejected():
     """UnitCell: b=-1 rejected."""
     with pytest.raises(ValidationError, match="must be positive"):
-        UnitCell(a=4.0, b=-1.0, c=4.0, alpha=90, beta=90, gamma=90)
+        UnitCell[RefinableParameter](a=[4.0, False], b=[-1.0, False], c=[4.0, False], alpha=[90, False], beta=[90, False], gamma=[90, False])
 
 
 def test_unit_cell_length_non_finite_rejected():
     """UnitCell: c=nan rejected."""
-    with pytest.raises(ValidationError, match="must be positive"):
-        UnitCell(a=4.0, b=4.0, c=float("nan"), alpha=90, beta=90, gamma=90)
+    with pytest.raises(ValidationError, match="must be finite"):
+        UnitCell[RefinableParameter](a=[4.0, False], b=[4.0, False], c=[float("nan"), False], alpha=[90, False], beta=[90, False], gamma=[90, False])
 
 
 def test_unit_cell_angle_zero_rejected():
     """UnitCell: alpha=0 rejected."""
     with pytest.raises(ValidationError, match="must be between 0 and 180"):
-        UnitCell(a=4.0, b=4.0, c=4.0, alpha=0.0, beta=90, gamma=90)
+        UnitCell[RefinableParameter](a=[4.0, False], b=[4.0, False], c=[4.0, False], alpha=[0.0, False], beta=[90, False], gamma=[90, False])
 
 
 def test_unit_cell_angle_180_rejected():
     """UnitCell: beta=180 rejected."""
     with pytest.raises(ValidationError, match="must be between 0 and 180"):
-        UnitCell(a=4.0, b=4.0, c=4.0, alpha=90, beta=180.0, gamma=90)
+        UnitCell[RefinableParameter](a=[4.0, False], b=[4.0, False], c=[4.0, False], alpha=[90, False], beta=[180.0, False], gamma=[90, False])
 
 
 def test_unit_cell_angle_above_180_rejected():
     """UnitCell: gamma=181 rejected."""
     with pytest.raises(ValidationError, match="must be between 0 and 180"):
-        UnitCell(a=4.0, b=4.0, c=4.0, alpha=90, beta=90, gamma=181.0)
+        UnitCell[RefinableParameter](a=[4.0, False], b=[4.0, False], c=[4.0, False], alpha=[90, False], beta=[90, False], gamma=[181.0, False])
 
 
 def test_unit_cell_angle_non_finite_rejected():
     """UnitCell: alpha=inf rejected."""
-    with pytest.raises(ValidationError, match="must be between 0 and 180"):
-        UnitCell(a=4.0, b=4.0, c=4.0, alpha=float("inf"), beta=90, gamma=90)
+    with pytest.raises(ValidationError, match="must be finite"):
+        UnitCell[RefinableParameter](a=[4.0, False], b=[4.0, False], c=[4.0, False], alpha=[float("inf"), False], beta=[90, False], gamma=[90, False])
 
 
 def test_unit_cell_extra_key_rejected():
     """UnitCell: 'volume' key rejected (extra='forbid')."""
     with pytest.raises(ValidationError, match="Extra inputs are not permitted"):
-        UnitCell(a=4.0, b=4.0, c=4.0, alpha=90, beta=90, gamma=90, volume=64.0)
+        UnitCell[RefinableParameter](a=[4.0, False], b=[4.0, False], c=[4.0, False], alpha=[90, False], beta=[90, False], gamma=[90, False], volume=64.0)
 
 
 def test_atom_element_uppercase_rejected_with_suggestion():
     """Atom: 'FE' -> message suggests 'Fe'."""
     with pytest.raises(ValidationError, match="write the element symbol as 'Fe'"):
-        Atom(element="FE", x=0.0, y=0.0, z=0.0, ADP="Uiso", Uiso=0.01)
+        Atom[RefinableParameter](element="FE", x=[0.0, False], y=[0.0, False], z=[0.0, False], occupancy=[1.0, False], ADP="Uiso", Uiso=[0.01, False])
 
 
 def test_atom_element_charged_rejected():
     """Atom: 'Fe3+' rejected as charged."""
     with pytest.raises(ValidationError, match="charged scattering types are not supported"):
-        Atom(element="Fe3+", x=0.0, y=0.0, z=0.0, ADP="Uiso", Uiso=0.01)
+        Atom[RefinableParameter](element="Fe3+", x=[0.0, False], y=[0.0, False], z=[0.0, False], occupancy=[1.0, False], ADP="Uiso", Uiso=[0.01, False])
 
 
 def test_atom_occupancy_zero_accepted():
     """Atom: occupancy=0 accepted."""
-    atom = Atom(element="Fe", x=0.0, y=0.0, z=0.0, occupancy=0.0, ADP="Uiso", Uiso=0.01)
-    assert atom.occupancy == 0.0
+    atom = Atom[RefinableParameter](element="Fe", x=[0.0, False], y=[0.0, False], z=[0.0, False], occupancy=[0.0, False], ADP="Uiso", Uiso=[0.01, False])
+    assert atom.occupancy.value == 0.0
 
 
 def test_atom_occupancy_one_accepted():
     """Atom: occupancy=1 accepted."""
-    atom = Atom(element="Fe", x=0.0, y=0.0, z=0.0, occupancy=1.0, ADP="Uiso", Uiso=0.01)
-    assert atom.occupancy == 1.0
+    atom = Atom[RefinableParameter](element="Fe", x=[0.0, False], y=[0.0, False], z=[0.0, False], occupancy=[1.0, False], ADP="Uiso", Uiso=[0.01, False])
+    assert atom.occupancy.value == 1.0
 
 
 def test_atom_occupancy_negative_rejected():
     """Atom: occupancy=-0.01 rejected."""
-    with pytest.raises(ValidationError, match="greater than or equal to 0"):
-        Atom(element="Fe", x=0.0, y=0.0, z=0.0, occupancy=-0.01, ADP="Uiso", Uiso=0.01)
+    with pytest.raises(ValidationError, match="occupancy must be between 0 and 1"):
+        Atom[RefinableParameter](element="Fe", x=[0.0, False], y=[0.0, False], z=[0.0, False], occupancy=[-0.01, False], ADP="Uiso", Uiso=[0.01, False])
 
 
 def test_atom_occupancy_above_one_rejected():
     """Atom: occupancy=1.01 rejected."""
-    with pytest.raises(ValidationError, match="less than or equal to 1"):
-        Atom(element="Fe", x=0.0, y=0.0, z=0.0, occupancy=1.01, ADP="Uiso", Uiso=0.01)
+    with pytest.raises(ValidationError, match="occupancy must be between 0 and 1"):
+        Atom[RefinableParameter](element="Fe", x=[0.0, False], y=[0.0, False], z=[0.0, False], occupancy=[1.01, False], ADP="Uiso", Uiso=[0.01, False])
 
 
 def test_atom_adp_uiso_without_value_rejected():
     """Atom: ADP='Uiso' without Uiso rejected."""
     with pytest.raises(ValidationError, match="requires a Uiso value"):
-        Atom(element="Fe", x=0.0, y=0.0, z=0.0, ADP="Uiso")
+        Atom[RefinableParameter](element="Fe", x=[0.0, False], y=[0.0, False], z=[0.0, False], occupancy=[1.0, False], ADP="Uiso")
 
 
 def test_atom_adp_uiso_with_uaniso_rejected():
     """Atom: ADP='Uiso' with Uaniso also given rejected."""
     with pytest.raises(ValidationError, match="must not also give Uaniso"):
-        Atom(element="Fe", x=0.0, y=0.0, z=0.0, ADP="Uiso", Uiso=0.01,
-             Uaniso={"U11": 0.01, "U22": 0.01, "U33": 0.01, "U12": 0, "U13": 0, "U23": 0})
+        Atom[RefinableParameter](element="Fe", x=[0.0, False], y=[0.0, False], z=[0.0, False], occupancy=[1.0, False], ADP="Uiso", Uiso=[0.01, False],
+             Uaniso={"U11": [0.01, False], "U22": [0.01, False], "U33": [0.01, False], "U12": [0, False], "U13": [0, False], "U23": [0, False]})
 
 
 def test_atom_adp_uaniso_missing_component_rejected():
     """Atom: ADP='Uaniso' missing U23 rejected."""
     with pytest.raises(ValidationError, match="requires all of U11"):
-        Atom(element="Fe", x=0.0, y=0.0, z=0.0, ADP="Uaniso",
-             Uaniso={"U11": 0.01, "U22": 0.01, "U33": 0.01, "U12": 0, "U13": 0})
+        Atom[RefinableParameter](element="Fe", x=[0.0, False], y=[0.0, False], z=[0.0, False], occupancy=[1.0, False], ADP="Uaniso",
+             Uaniso={"U11": [0.01, False], "U22": [0.01, False], "U33": [0.01, False], "U12": [0, False], "U13": [0, False]})
 
 
 def test_atom_adp_uaniso_unknown_key_rejected():
     """Atom: ADP='Uaniso' with U14 rejected."""
     with pytest.raises(ValidationError, match="Input should be"):
-        Atom(element="Fe", x=0.0, y=0.0, z=0.0, ADP="Uaniso",
-             Uaniso={"U11": 0.01, "U22": 0.01, "U33": 0.01, "U12": 0, "U13": 0, "U23": 0, "U14": 0})
+        Atom[RefinableParameter](element="Fe", x=[0.0, False], y=[0.0, False], z=[0.0, False], occupancy=[1.0, False], ADP="Uaniso",
+             Uaniso={"U11": [0.01, False], "U22": [0.01, False], "U33": [0.01, False], "U12": [0, False], "U13": [0, False], "U23": [0, False], "U14": [0, False]})
 
 
 def test_atom_adp_uaniso_with_uiso_rejected():
     """Atom: ADP='Uaniso' with Uiso also given rejected."""
     with pytest.raises(ValidationError, match="must not also give Uiso"):
-        Atom(element="Fe", x=0.0, y=0.0, z=0.0, ADP="Uaniso", Uiso=0.01,
-             Uaniso={"U11": 0.01, "U22": 0.01, "U33": 0.01, "U12": 0, "U13": 0, "U23": 0})
+        Atom[RefinableParameter](element="Fe", x=[0.0, False], y=[0.0, False], z=[0.0, False], occupancy=[1.0, False], ADP="Uaniso", Uiso=[0.01, False],
+             Uaniso={"U11": [0.01, False], "U22": [0.01, False], "U33": [0.01, False], "U12": [0, False], "U13": [0, False], "U23": [0, False]})
 
 
 def test_atom_adp_wrong_value_rejected():
     """Atom: ADP='Uaniso' but only Uiso given rejected."""
     with pytest.raises(ValidationError, match="requires all of U11"):
-        Atom(element="Fe", x=0.0, y=0.0, z=0.0, ADP="Uaniso", Uiso=0.01)
+        Atom[RefinableParameter](element="Fe", x=[0.0, False], y=[0.0, False], z=[0.0, False], occupancy=[1.0, False], ADP="Uaniso", Uiso=[0.01, False])
 
 
 def test_atom_xyz_non_finite_rejected():
     """Atom: x=nan rejected."""
     with pytest.raises(ValidationError, match="must be finite"):
-        Atom(element="Fe", x=float("nan"), y=0.0, z=0.0, ADP="Uiso", Uiso=0.01)
+        Atom[RefinableParameter](element="Fe", x=[float("nan"), False], y=[0.0, False], z=[0.0, False], occupancy=[1.0, False], ADP="Uiso", Uiso=[0.01, False])
 
 
-def test_phase_structure_space_group_no_origin_rejected():
-    """PhaseStructure: 'F d -3 m' (no :1/:2) rejected."""
+def test_phase_space_group_no_origin_rejected():
+    """Phase: 'F d -3 m' (no :1/:2) rejected."""
     d = _valid_pmm_lab6_phase_dict()
     d["space_group"] = "F d -3 m"
-    with pytest.raises(ValidationError, match="two origin choices"):
-        PhaseStructure.model_validate(d)
+    with pytest.raises(ValidationError) as exc_info:
+        Phase[RefinableParameter].model_validate(d)
+    errors = exc_info.value.errors()
+    assert len(errors) == 1
+    assert errors[0]["loc"] == ("space_group",)
+    assert "space group 'F d -3 m' has two origin choices" in errors[0]["msg"]
+    assert "write 'F d -3 m:1' or 'F d -3 m:2'" in errors[0]["msg"]
 
 
-def test_phase_structure_space_group_no_rhombohedral_setting_rejected():
-    """PhaseStructure: 'R -3 m' (no :H/:R) rejected."""
+def test_phase_space_group_no_rhombohedral_setting_rejected():
+    """Phase: 'R -3 m' (no :H/:R) rejected."""
     d = _valid_pmm_lab6_phase_dict()
     d["space_group"] = "R -3 m"
-    with pytest.raises(ValidationError, match="rhombohedral"):
-        PhaseStructure.model_validate(d)
+    with pytest.raises(ValidationError) as exc_info:
+        Phase[RefinableParameter].model_validate(d)
+    errors = exc_info.value.errors()
+    assert len(errors) == 1
+    assert errors[0]["loc"] == ("space_group",)
+    assert "space group 'R -3 m' does not name its setting" in errors[0]["msg"]
+    assert "write 'R -3 m:H'" in errors[0]["msg"]
+    assert "or 'R -3 m:R'" in errors[0]["msg"]
 
 
-def test_phase_structure_space_group_fd3m_origin2_accepted():
-    """PhaseStructure: 'F d -3 m:2' (cubic) accepted."""
+def test_phase_space_group_fd3m_origin2_accepted():
+    """Phase: 'F d -3 m:2' (cubic) accepted."""
     d = _valid_pmm_lab6_phase_dict()
     d["space_group"] = "F d -3 m:2"
     # Adjust cell to cubic (already is in the helper, but be explicit)
-    d["unit_cell"] = {"a": 8.0, "b": 8.0, "c": 8.0, "alpha": 90, "beta": 90, "gamma": 90}
+    d["unit_cell"] = {"a": [8.0, False], "b": [8.0, False], "c": [8.0, False], "alpha": [90, False], "beta": [90, False], "gamma": [90, False]}
     # Put an atom at a general position to avoid special-position complications
     d["atoms"] = {
-        "A1": {"element": "O", "x": 0.125, "y": 0.125, "z": 0.125, "ADP": "Uiso", "Uiso": 0.01}
+        "A1": {"element": "O", "x": [0.125, False], "y": [0.125, False], "z": [0.125, False], "occupancy": [1.0, False], "ADP": "Uiso", "Uiso": [0.01, False]}
     }
-    phase = PhaseStructure.model_validate(d)
+    phase = Phase[RefinableParameter].model_validate(d)
     assert phase.space_group == "F d -3 m:2"
 
 
-def test_phase_structure_space_group_r3m_hexagonal_accepted():
-    """PhaseStructure: 'R -3 m:H' (hexagonal a=b, gamma=120) accepted."""
+def test_phase_space_group_r3m_hexagonal_accepted():
+    """Phase: 'R -3 m:H' (hexagonal a=b, gamma=120) accepted."""
     d = {
-        "phase_name": "test",
         "space_group": "R -3 m:H",
-        "unit_cell": {"a": 3.2, "b": 3.2, "c": 5.0, "alpha": 90, "beta": 90, "gamma": 120},
+        "unit_cell": {"a": [3.2, False], "b": [3.2, False], "c": [5.0, False], "alpha": [90, False], "beta": [90, False], "gamma": [120, False]},
         "atoms": {
-            "A1": {"element": "O", "x": 0.2, "y": 0.4, "z": 0.1, "ADP": "Uiso", "Uiso": 0.01}
+            "A1": {"element": "O", "x": [0.2, False], "y": [0.4, False], "z": [0.1, False], "occupancy": [1.0, False], "ADP": "Uiso", "Uiso": [0.01, False]}
         },
     }
-    phase = PhaseStructure.model_validate(d)
+    phase = Phase[RefinableParameter].model_validate(d)
     assert phase.space_group == "R -3 m:H"
 
 
-def test_phase_structure_special_position_adjusted():
-    """PhaseStructure: P 63/m m c atom at (0.333333,0.666667,0.25) adjusted to 1/3,2/3,1/4."""
+def test_phase_special_position_adjusted():
+    """Phase: P 63/m m c atom at (0.333333,0.666667,0.25) adjusted to 1/3,2/3,1/4."""
     d = {
-        "phase_name": "test",
         "space_group": "P 63/m m c",
-        "unit_cell": {"a": 3.2, "b": 3.2, "c": 5.2, "alpha": 90, "beta": 90, "gamma": 120},
+        "unit_cell": {"a": [3.2, False], "b": [3.2, False], "c": [5.2, False], "alpha": [90, False], "beta": [90, False], "gamma": [120, False]},
         "atoms": {
-            "A1": {"element": "O", "x": 0.333333, "y": 0.666667, "z": 0.25, "ADP": "Uiso", "Uiso": 0.01}
+            "A1": {"element": "O", "x": [0.333333, False], "y": [0.666667, False], "z": [0.25, False], "occupancy": [1.0, False], "ADP": "Uiso", "Uiso": [0.01, False]}
         },
     }
-    phase = PhaseStructure.model_validate(d)
-    # Check coordinates are exact fractions
-    assert phase.atoms["A1"].x == 1/3
-    assert phase.atoms["A1"].y == 2/3
+    phase = Phase[RefinableParameter].model_validate(d)
+    # Check coordinates are exact fractions (now need to read .value)
+    assert phase.atoms["A1"].x.value == 1/3
+    assert phase.atoms["A1"].y.value == 2/3
+    # Check refine flags are preserved
+    assert phase.atoms["A1"].x.refine_flag is False
+    assert phase.atoms["A1"].y.refine_flag is False
     # Check warning
     warnings = phase.warnings()
     assert len(warnings) == 1
@@ -1183,167 +1069,167 @@ def test_phase_structure_special_position_adjusted():
     assert warnings[0]["field_path"] == "atoms.A1"
 
 
-def test_phase_structure_special_position_ambiguous_rejected():
-    """PhaseStructure: atom at (0.3333,0.6667,0.25) in P 63/m m c rejected (ambiguous)."""
+def test_phase_special_position_ambiguous_rejected():
+    """Phase: atom at (0.3333,0.6667,0.25) in P 63/m m c rejected (ambiguous)."""
     d = {
-        "phase_name": "test",
         "space_group": "P 63/m m c",
-        "unit_cell": {"a": 3.2, "b": 3.2, "c": 5.2, "alpha": 90, "beta": 90, "gamma": 120},
+        "unit_cell": {"a": [3.2, False], "b": [3.2, False], "c": [5.2, False], "alpha": [90, False], "beta": [90, False], "gamma": [120, False]},
         "atoms": {
-            "A1": {"element": "O", "x": 0.3333, "y": 0.6667, "z": 0.25, "ADP": "Uiso", "Uiso": 0.01}
+            "A1": {"element": "O", "x": [0.3333, False], "y": [0.6667, False], "z": [0.25, False], "occupancy": [1.0, False], "ADP": "Uiso", "Uiso": [0.01, False]}
         },
     }
     with pytest.raises(ValidationError, match="without being on it") as exc_info:
-        PhaseStructure.model_validate(d)
+        Phase[RefinableParameter].model_validate(d)
     # Check that the atom label appears in the error
     assert "A1" in str(exc_info.value)
 
 
-def test_phase_structure_multiplicity_match_accepted():
-    """PhaseStructure: stated Multiplicity equal to derived accepted."""
+def test_phase_multiplicity_match_accepted():
+    """Phase: stated Multiplicity equal to derived accepted."""
     d = _valid_pmm_lab6_phase_dict()
     d["atoms"]["La1"]["Multiplicity"] = 1
     d["atoms"]["B1"]["Multiplicity"] = 6
-    phase = PhaseStructure.model_validate(d)
+    phase = Phase[RefinableParameter].model_validate(d)
     assert phase.site("La1").multiplicity == 1
     assert phase.site("B1").multiplicity == 6
 
 
-def test_phase_structure_multiplicity_mismatch_rejected():
-    """PhaseStructure: stated Multiplicity != derived rejected."""
+def test_phase_multiplicity_mismatch_rejected():
+    """Phase: stated Multiplicity != derived rejected."""
     d = _valid_pmm_lab6_phase_dict()
     d["atoms"]["B1"]["Multiplicity"] = 12  # should be 6
     with pytest.raises(ValidationError) as exc_info:
-        PhaseStructure.model_validate(d)
+        Phase[RefinableParameter].model_validate(d)
     msg = str(exc_info.value)
     assert "stated Multiplicity" in msg
     assert "derived" in msg
 
 
-def test_phase_structure_cell_cubic_b_neq_a_rejected():
-    """PhaseStructure: cubic with b != a rejected."""
+def test_phase_cell_cubic_b_neq_a_rejected():
+    """Phase: cubic with b != a rejected."""
     d = _valid_pmm_lab6_phase_dict()
-    d["unit_cell"]["b"] = 4.2
+    d["unit_cell"]["b"] = [4.2, False]
     with pytest.raises(ValidationError) as exc_info:
-        PhaseStructure.model_validate(d)
+        Phase[RefinableParameter].model_validate(d)
     msg = str(exc_info.value)
     assert "b = 4.2 (symmetric value" in msg
     assert "inconsistent" in msg
     assert _errors(exc_info) == [(("unit_cell",), "value_error")]
 
 
-def test_phase_structure_cell_cubic_gamma_91_rejected():
-    """PhaseStructure: cubic with gamma=91 rejected."""
+def test_phase_cell_cubic_gamma_91_rejected():
+    """Phase: cubic with gamma=91 rejected."""
     d = _valid_pmm_lab6_phase_dict()
-    d["unit_cell"]["gamma"] = 91.0
+    d["unit_cell"]["gamma"] = [91.0, False]
     with pytest.raises(ValidationError, match="inconsistent"):
-        PhaseStructure.model_validate(d)
+        Phase[RefinableParameter].model_validate(d)
 
 
-def test_phase_structure_cell_hexagonal_gamma_90_rejected():
-    """PhaseStructure: hexagonal with gamma=90 rejected."""
+def test_phase_cell_hexagonal_gamma_90_rejected():
+    """Phase: hexagonal with gamma=90 rejected."""
     d = {
-        "phase_name": "test",
         "space_group": "P 63/m m c",
-        "unit_cell": {"a": 3.2, "b": 3.2, "c": 5.2, "alpha": 90, "beta": 90, "gamma": 90},
+        "unit_cell": {"a": [3.2, False], "b": [3.2, False], "c": [5.2, False], "alpha": [90, False], "beta": [90, False], "gamma": [90, False]},
         "atoms": {
-            "A1": {"element": "O", "x": 0.2, "y": 0.4, "z": 0.1, "ADP": "Uiso", "Uiso": 0.01}
+            "A1": {"element": "O", "x": [0.2, False], "y": [0.4, False], "z": [0.1, False], "occupancy": [1.0, False], "ADP": "Uiso", "Uiso": [0.01, False]}
         },
     }
     with pytest.raises(ValidationError, match="inconsistent"):
-        PhaseStructure.model_validate(d)
+        Phase[RefinableParameter].model_validate(d)
 
 
-def test_phase_structure_cell_monoclinic_accepted():
-    """PhaseStructure: valid monoclinic C 1 2/m 1 with beta=104.3 accepted."""
+def test_phase_cell_monoclinic_accepted():
+    """Phase: valid monoclinic C 1 2/m 1 with beta=104.3 accepted."""
     d = {
-        "phase_name": "test",
         "space_group": "C 1 2/m 1",
-        "unit_cell": {"a": 5.0, "b": 6.0, "c": 7.0, "alpha": 90, "beta": 104.3, "gamma": 90},
+        "unit_cell": {"a": [5.0, False], "b": [6.0, False], "c": [7.0, False], "alpha": [90, False], "beta": [104.3, False], "gamma": [90, False]},
         "atoms": {
-            "A1": {"element": "O", "x": 0.2, "y": 0.0, "z": 0.1, "ADP": "Uiso", "Uiso": 0.01}
+            "A1": {"element": "O", "x": [0.2, False], "y": [0.0, False], "z": [0.1, False], "occupancy": [1.0, False], "ADP": "Uiso", "Uiso": [0.01, False]}
         },
     }
-    phase = PhaseStructure.model_validate(d)
+    phase = Phase[RefinableParameter].model_validate(d)
     assert phase.space_group == "C 1 2/m 1"
 
 
-def test_phase_structure_uaniso_cubic_m3m_isotropic_accepted():
-    """PhaseStructure: La at (0,0,0) in P m -3 m with isotropic Uaniso (U11=U22=U33, off-diag 0) accepted."""
+def test_phase_uaniso_cubic_m3m_isotropic_accepted():
+    """Phase: La at (0,0,0) in P m -3 m with isotropic Uaniso (U11=U22=U33, off-diag 0) accepted."""
     d = _valid_pmm_lab6_phase_dict()
     d["atoms"]["La1"]["ADP"] = "Uaniso"
-    d["atoms"]["La1"]["Uaniso"] = {"U11": 0.01, "U22": 0.01, "U33": 0.01, "U12": 0, "U13": 0, "U23": 0}
+    d["atoms"]["La1"]["Uaniso"] = {"U11": [0.01, False], "U22": [0.01, False], "U33": [0.01, False], "U12": [0, False], "U13": [0, False], "U23": [0, False]}
     del d["atoms"]["La1"]["Uiso"]
-    phase = PhaseStructure.model_validate(d)
+    phase = Phase[RefinableParameter].model_validate(d)
     assert phase.warnings() == []
 
 
-def test_phase_structure_uaniso_cubic_m3m_anisotropic_rejected():
-    """PhaseStructure: La at (0,0,0) in P m -3 m with U11!=U22 rejected (breaks symmetry)."""
+def test_phase_uaniso_cubic_m3m_anisotropic_rejected():
+    """Phase: La at (0,0,0) in P m -3 m with U11!=U22 rejected (breaks symmetry)."""
     d = _valid_pmm_lab6_phase_dict()
     d["atoms"]["La1"]["ADP"] = "Uaniso"
-    d["atoms"]["La1"]["Uaniso"] = {"U11": 0.01, "U22": 0.02, "U33": 0.01, "U12": 0, "U13": 0, "U23": 0}
+    d["atoms"]["La1"]["Uaniso"] = {"U11": [0.01, False], "U22": [0.02, False], "U33": [0.01, False], "U12": [0, False], "U13": [0, False], "U23": [0, False]}
     del d["atoms"]["La1"]["Uiso"]
     with pytest.raises(ValidationError, match="break the site symmetry"):
-        PhaseStructure.model_validate(d)
+        Phase[RefinableParameter].model_validate(d)
 
 
-def test_phase_structure_uaniso_hexagonal_6h_adjusted():
-    """PhaseStructure: P 63/m m c, site 6h, Uaniso with U11=U22/2 adjusted and reported."""
+def test_phase_uaniso_hexagonal_6h_adjusted():
+    """Phase: P 63/m m c, site 6h, Uaniso with U11=U22/2 adjusted and reported."""
     d = {
-        "phase_name": "test",
         "space_group": "P 63/m m c",
-        "unit_cell": {"a": 3.2, "b": 3.2, "c": 5.2, "alpha": 90, "beta": 90, "gamma": 120},
+        "unit_cell": {"a": [3.2, False], "b": [3.2, False], "c": [5.2, False], "alpha": [90, False], "beta": [90, False], "gamma": [120, False]},
         "atoms": {
             "A1": {
                 "element": "O",
-                "x": 0.2,
-                "y": 0.4,
-                "z": 0.25,
+                "x": [0.2, False],
+                "y": [0.4, False],
+                "z": [0.25, False],
+                "occupancy": [1.0, False],
                 "ADP": "Uaniso",
                 "Uaniso": {
-                    "U11": 0.012,
-                    "U22": 0.012347,
-                    "U33": 0.02,
-                    "U12": 0.006174,
-                    "U13": 0.0,
-                    "U23": 0.0,
+                    "U11": [0.012, False],
+                    "U22": [0.012347, False],
+                    "U33": [0.02, False],
+                    "U12": [0.006174, False],
+                    "U13": [0.0, False],
+                    "U23": [0.0, False],
                 },
             }
         },
     }
-    phase = PhaseStructure.model_validate(d)
-    # Check U11 stayed
-    assert phase.atoms["A1"].Uaniso["U11"] == 0.012  # free: returned exactly as stated
-    # Check U12 became U22/2
-    u22 = phase.atoms["A1"].Uaniso["U22"]
-    u12 = phase.atoms["A1"].Uaniso["U12"]
+    phase = Phase[RefinableParameter].model_validate(d)
+    # Check U11 stayed (now need to read .value)
+    assert phase.atoms["A1"].Uaniso["U11"].value == 0.012  # free: returned exactly as stated
+    # Check U12 became U22/2 (reading .value)
+    u22 = phase.atoms["A1"].Uaniso["U22"].value
+    u12 = phase.atoms["A1"].Uaniso["U12"].value
     assert abs(u12 - u22 / 2) < 1e-15
+    # Check refine flags are preserved
+    assert phase.atoms["A1"].Uaniso["U11"].refine_flag is False
+    assert phase.atoms["A1"].Uaniso["U12"].refine_flag is False
     # Check warning
     warnings = phase.warnings()
     assert any(w["code"] == "adp_symmetry_adjusted" for w in warnings)
 
 
-def test_phase_structure_multiple_atom_problems_all_reported():
-    """PhaseStructure: two atoms with wrong Multiplicity -> both labels appear in one error."""
+def test_phase_multiple_atom_problems_all_reported():
+    """Phase: two atoms with wrong Multiplicity -> both labels appear in one error."""
     d = _valid_pmm_lab6_phase_dict()
     d["atoms"]["La1"]["Multiplicity"] = 2
     d["atoms"]["B1"]["Multiplicity"] = 12
     with pytest.raises(ValidationError) as exc_info:
-        PhaseStructure.model_validate(d)
+        Phase[RefinableParameter].model_validate(d)
     msg = str(exc_info.value)
     assert "La1" in msg
     assert "B1" in msg
 
 
-# --- PhaseStructure: error locations, reporting, no side effects (A70) -------
+# --- Phase: error locations, reporting, no side effects (A70) -------
 
 
 def _uaniso(u11, u22, u33, u12=0.0, u13=0.0, u23=0.0):
-    return {"U11": u11, "U22": u22, "U33": u33, "U12": u12, "U13": u13, "U23": u23}
+    return {"U11": [u11, False], "U22": [u22, False], "U33": [u33, False], "U12": [u12, False], "U13": [u13, False], "U23": [u23, False]}
 
 
-def test_phase_structure_all_problems_of_one_atom_reported():
+def test_phase_all_problems_of_one_atom_reported():
     """A wrong Multiplicity does not hide the same atom's Uaniso error."""
     d = _valid_pmm_lab6_phase_dict()
     la = d["atoms"]["La1"]
@@ -1352,21 +1238,21 @@ def test_phase_structure_all_problems_of_one_atom_reported():
     del la["Uiso"]
     la["Uaniso"] = _uaniso(0.01, 0.02, 0.01)
     with pytest.raises(ValidationError) as exc_info:
-        PhaseStructure.model_validate(d)
+        Phase[RefinableParameter].model_validate(d)
     assert _errors(exc_info) == [
         (("atoms", "La1", "Multiplicity"), "value_error"),
         (("atoms", "La1", "Uaniso"), "value_error"),
     ]
 
 
-def test_phase_structure_problems_reported_at_their_locations():
+def test_phase_problems_reported_at_their_locations():
     """Cell, position and multiplicity problems: one error each, at its own field."""
     d = _valid_pmm_lab6_phase_dict()
-    d["unit_cell"]["b"] = 4.2
-    d["atoms"]["La1"]["x"] = 0.001  # ambiguous band
+    d["unit_cell"]["b"] = [4.2, False]
+    d["atoms"]["La1"]["x"] = [0.001, False]  # ambiguous band
     d["atoms"]["B1"]["Multiplicity"] = 12
     with pytest.raises(ValidationError) as exc_info:
-        PhaseStructure.model_validate(d)
+        Phase[RefinableParameter].model_validate(d)
     assert _errors(exc_info) == [
         (("unit_cell",), "value_error"),
         (("atoms", "La1"), "value_error"),
@@ -1378,12 +1264,12 @@ def test_phase_structure_problems_reported_at_their_locations():
     assert "stated Multiplicity 12, derived 6" in msgs[2]
 
 
-def test_phase_structure_locations_nest_in_enclosing_models():
-    """Engine schemas embed PhaseStructure: the locations get the enclosing path, also from JSON."""
+def test_phase_locations_nest_in_enclosing_models():
+    """Engine schemas embed Phase: the locations get the enclosing path, also from JSON."""
     from pydantic import BaseModel
 
     class Payload(BaseModel):
-        structure: PhaseStructure
+        structure: Phase[RefinableParameter]
 
     d = _valid_pmm_lab6_phase_dict()
     d["atoms"]["B1"]["Multiplicity"] = 12
@@ -1392,21 +1278,253 @@ class Payload(BaseModel):
     assert _errors(exc_info) == [(("structure", "atoms", "B1", "Multiplicity"), "value_error")]
 
 
-def test_phase_structure_does_not_modify_caller_atoms():
+def test_phase_does_not_modify_caller_atoms():
     """Canonicalization replaces the atom in the structure; the caller's Atom is untouched."""
-    atom = Atom.model_validate({"element": "C", "x": 0.3333333, "y": 0.6666667, "z": 0.25,
-                                "ADP": "Uiso", "Uiso": 0.01})
-    phase = PhaseStructure.model_validate({
-        "phase_name": "test",
+    atom = Atom[RefinableParameter].model_validate({"element": "C", "x": [0.3333333, False], "y": [0.6666667, False], "z": [0.25, False],
+                                "occupancy": [1.0, False], "ADP": "Uiso", "Uiso": [0.01, False]})
+    phase = Phase[RefinableParameter].model_validate({
         "space_group": "P 63/m m c",
-        "unit_cell": {"a": 3.2, "b": 3.2, "c": 5.2, "alpha": 90, "beta": 90, "gamma": 120},
+        "unit_cell": {"a": [3.2, False], "b": [3.2, False], "c": [5.2, False], "alpha": [90, False], "beta": [90, False], "gamma": [120, False]},
         "atoms": {"C1": atom},
     })
-    assert (atom.x, atom.y) == (0.3333333, 0.6666667)
-    assert (phase.atoms["C1"].x, phase.atoms["C1"].y) == (1 / 3, 2 / 3)
+    assert (atom.x.value, atom.y.value) == (0.3333333, 0.6666667)
+    assert (phase.atoms["C1"].x.value, phase.atoms["C1"].y.value) == (1 / 3, 2 / 3)
     assert phase.atoms["C1"] is not atom
 
 
+# --- Phase[P]: the phase block (re/03b; A93-A96, A100, A105) -----------------
+
+from powderline.schema_core import (  # noqa: E402
+    RESERVED_PHASE_FIELDS,
+    BoundedRefinableParameter,
+    CoreModel,
+)
+
+RP, BRP = RefinableParameter, BoundedRefinableParameter
+
+
+def _bounded(d: dict, lo=None, hi=None) -> dict:
+    """The phase dict with every [value, flag] made [value, flag, lo, hi]."""
+    def conv(v):
+        if isinstance(v, list):
+            return [*v, lo, hi]
+        if isinstance(v, dict):
+            return {k: conv(x) for k, x in v.items()}
+        return v
+    return conv(d)
+
+
+@pytest.mark.parametrize("space_group, cell, xyz", [
+    ("P m -3 m", (4.0, 4.0, 4.0, 90, 90, 90), (0.1, 0.2, 0.3)),
+    ("C 1 2/m 1", (9.0, 5.0, 7.0, 90, 105.0, 90), (0.1, 0.2, 0.3)),
+    ("P 1 21/c 1", (5.0, 6.0, 7.0, 90, 98.0, 90), (0.1, 0.2, 0.3)),
+    ("P 1 1 21/a", (5.0, 6.0, 7.0, 90, 90, 98.0), (0.1, 0.2, 0.3)),
+    ("A 1 1 2/a", (5.0, 6.0, 7.0, 90, 90, 98.0), (0.1, 0.2, 0.3)),
+    ("C c 1 1", (5.0, 6.0, 7.0, 98.0, 90, 90), (0.1, 0.2, 0.3)),
+    ("P 1 c 1", (5.0, 6.0, 7.0, 90, 98.0, 90), (0.1, 0.2, 0.3)),
+    ("R -3 m:H", (4.0, 4.0, 20.0, 90, 90, 120), (0.1, 0.2, 0.3)),
+    ("R -3 m:R", (5.0, 5.0, 5.0, 70.0, 70.0, 70.0), (0.1, 0.2, 0.3)),
+    ("F d -3 m:2", (8.0, 8.0, 8.0, 90, 90, 90), (0.125, 0.125, 0.125)),
+    ("F d -3 m:1", (8.0, 8.0, 8.0, 90, 90, 90), (0.0, 0.0, 0.0)),
+    ("P 63/m m c", (3.2, 3.2, 5.2, 90, 90, 120), (1 / 3, 2 / 3, 0.25)),
+])
+def test_phase_canonical_space_group_accepted(space_group, cell, xyz):
+    """Canonical names validate, incl. non-standard settings, ':R' and both origins (A105)."""
+    d = {"space_group": space_group,
+         "unit_cell": dict(zip(("a", "b", "c", "alpha", "beta", "gamma"), ([v, False] for v in cell))),
+         "atoms": {"A1": {"element": "Fe", **{k: [v, False] for k, v in zip("xyz", xyz)},
+                          "occupancy": [1.0, False], "ADP": "Uiso", "Uiso": [0.01, False]}}}
+    assert Phase[RP].model_validate(d).space_group == space_group
+
+
+@pytest.mark.parametrize("symbol, message", [
+    ("Pm-3m", "space group 'Pm-3m' is not in the canonical form; write 'P m -3 m'"),
+    ("p m -3 m", "space group 'p m -3 m' is not in the canonical form; write 'P m -3 m'"),
+    ("C2/m", "space group 'C2/m' is not in the canonical form; write 'C 1 2/m 1'"),
+    ("C 2/m", "space group 'C 2/m' is not in the canonical form; write 'C 1 2/m 1'"),
+    ("P 21/c", "space group 'P 21/c' is not in the canonical form; write 'P 1 21/c 1'"),
+    ("R-3m:H", "space group 'R-3m:H' is not in the canonical form; write 'R -3 m:H'"),
+    ("R -3 m", "space group 'R -3 m' does not name its setting; write 'R -3 m:H' (hexagonal axes) "
+               "or 'R -3 m:R' (rhombohedral axes)"),
+    ("Fd-3m", "space group 'Fd-3m' has two origin choices; write 'F d -3 m:1' or 'F d -3 m:2'"),
+    ("F d -3 m", "space group 'F d -3 m' has two origin choices; write 'F d -3 m:1' or 'F d -3 m:2'"),
+    ("P2_1/c", "unrecognized space-group symbol 'P2_1/c'; write gemmi's canonical name "
+               "(e.g. 'P m -3 m', 'C 1 2/m 1', 'R -3 m:H', 'F d -3 m:2')"),
+])
+def test_phase_non_canonical_space_group_rejected(symbol, message):
+    """Any other spelling is an error at space_group naming the canonical form (A105)."""
+    d = _valid_pmm_lab6_phase_dict()
+    d["space_group"] = symbol
+    with pytest.raises(ValidationError) as exc_info:
+        Phase[RP].model_validate(d)
+    assert _errors(exc_info) == [(("space_group",), "value_error")]
+    assert exc_info.value.errors()[0]["msg"] == "Value error, " + message
+
+
+def test_canonical_space_group_every_gemmi_name_round_trips():
+    """gemmi's xhm() names are unique over its table and each validates as itself (A105)."""
+    import gemmi
+    from powderline.symmetry import canonical_space_group
+
+    names = [sg.xhm() for sg in gemmi.spacegroup_table()]
+    assert len(names) == len(set(names)) == 564
+    assert all(canonical_space_group(n).xhm() == n for n in names)
+
+
+@pytest.mark.parametrize("field", RESERVED_PHASE_FIELDS)
+def test_phase_reserved_field_cannot_be_redeclared(field):
+    """An engine subclass may not redefine space_group, unit_cell or atoms (A93)."""
+    with pytest.raises(TypeError) as exc_info:
+        type("EnginePhase", (Phase[RP],), {"__annotations__": {field: int}, "__module__": __name__})
+    assert str(exc_info.value) == (f"EnginePhase redeclares the core phase field(s) {field}; "
+                                   "core owns space_group, unit_cell and atoms (A93)")
+
+
+def test_phase_reserved_fields_guarded_below_an_engine_subclass():
+    class EnginePhase(Phase[RP]):
+        scale: RP
+
+    with pytest.raises(TypeError, match=r"^Child redeclares the core phase field\(s\) atoms;"):
+        class Child(EnginePhase):
+            atoms: dict
+
+
+def test_phase_engine_subclass_adds_flat_fields_and_keeps_core_validation():
+    """The gsasii shape: engine fields flat in the phase; core rules still run; locs nest."""
+    class EnginePhase(Phase[RP]):
+        scale: RP
+
+    d = _valid_pmm_lab6_phase_dict()
+    d["atoms"]["B1"]["x"] = [0.4999999, False]
+    phase = EnginePhase.model_validate({**d, "scale": [1.0, True]})
+    assert phase.scale.model_dump() == [1.0, True]
+    assert phase.atoms["B1"].x.value == 0.5  # canonicalized by the core validator
+    d["atoms"]["B1"]["Multiplicity"] = 12
+    with pytest.raises(ValidationError) as exc_info:
+        EnginePhase.model_validate({**d, "scale": [1.0, True]})
+    assert _errors(exc_info) == [(("atoms", "B1", "Multiplicity"), "value_error")]
+    with pytest.raises(ValidationError) as exc_info:
+        EnginePhase.model_validate(d)
+    assert _errors(exc_info) == [(("scale",), "missing")]
+
+
+def test_phase_has_no_phase_name():
+    """The phase name is the key of the payload's phases dict (A100)."""
+    d = {"phase_name": "LaB6", **_valid_pmm_lab6_phase_dict()}
+    with pytest.raises(ValidationError) as exc_info:
+        Phase[RP].model_validate(d)
+    assert _errors(exc_info) == [(("phase_name",), "extra_forbidden")]
+
+
+def test_atom_occupancy_required():
+    """No default: occupancy must be stated (A96)."""
+    d = _valid_pmm_lab6_phase_dict()
+    del d["atoms"]["La1"]["occupancy"]
+    with pytest.raises(ValidationError) as exc_info:
+        Phase[RP].model_validate(d)
+    assert _errors(exc_info) == [(("atoms", "La1", "occupancy"), "missing")]
+
+
+@pytest.mark.parametrize("field", ["Multiplicity", "Uiso", "Uaniso"])
+def test_atom_optional_fields_are_never_null(field):
+    """A field that may be left out is never null (A96); leaving it out is the way."""
+    d = _valid_pmm_lab6_phase_dict()
+    d["atoms"]["B1"][field] = None
+    with pytest.raises(ValidationError) as exc_info:
+        Phase[RP].model_validate(d)
+    assert _errors(exc_info) == [(("atoms", "B1", field), "value_error")]
+    assert exc_info.value.errors()[0]["msg"] == f"Value error, {field} must not be null; leave it out instead"
+
+
+@pytest.mark.parametrize("param", [[None, False], [0.5, None]])
+def test_phase_parameter_value_and_flag_never_null(param):
+    d = _valid_pmm_lab6_phase_dict()
+    d["atoms"]["B1"]["z"] = param
+    with pytest.raises(ValidationError) as exc_info:
+        Phase[RP].model_validate(d)
+    slot = "value" if param[0] is None else "refine_flag"
+    assert _errors(exc_info) == [(("atoms", "B1", "z", slot), "float_type" if slot == "value" else "bool_type")]
+
+
+def test_phase_dump_round_trips_and_leaves_absent_fields_out():
+    d = _valid_pmm_lab6_phase_dict()
+    d["atoms"]["B1"]["Multiplicity"] = 6
+    phase = Phase[RP].model_validate(d)
+    dump = phase.model_dump(mode="json")
+    assert dump == d
+    assert "Uaniso" not in dump["atoms"]["La1"] and "Multiplicity" not in dump["atoms"]["La1"]
+    assert Phase[RP].model_validate_json(phase.model_dump_json()).model_dump() == phase.model_dump()
+
+
+def test_phase_json_schema_names_and_no_null():
+    """Readable $defs (no 'Atom_RefinableParameter_'); optional fields are not nullable (A96)."""
+    class EnginePhase(Phase[RP]):
+        scale: RP
+
+    schema = EnginePhase.model_json_schema()
+    assert sorted(schema["$defs"]) == ["Atom", "RefinableParameter", "UnitCell"]
+    atom = schema["$defs"]["Atom"]
+    assert atom["required"] == ["element", "x", "y", "z", "occupancy", "ADP"]
+    assert atom["properties"]["Uiso"] == {"$ref": "#/$defs/RefinableParameter", "unit": "angstrom^2",
+                                          "description": "Isotropic ADP; given when ADP is 'Uiso'"}
+    assert atom["properties"]["Multiplicity"]["type"] == "integer"
+    assert "null" not in json.dumps(schema)
+    assert schema["$defs"]["RefinableParameter"]["prefixItems"] == [{"type": "number"}, {"type": "boolean"}]
+
+
+def test_phase_json_schema_two_parameter_types_in_one_document_stay_distinct():
+    """If two parametrizations ever share a document, the names fall back and the refs stay right."""
+    class Both(CoreModel):
+        g: Phase[RP]
+        t: Phase[BRP]
+
+    defs = Both.model_json_schema()["$defs"]
+    atom_refs = {k: v["properties"]["atoms"]["additionalProperties"]["$ref"].rsplit("/", 1)[1]
+                 for k, v in defs.items() if "Phase" in k}
+    assert len(set(atom_refs.values())) == 2
+    for name, ref in atom_refs.items():
+        expected = "BoundedRefinableParameter" if "Bounded" in name else "RefinableParameter"
+        assert defs[ref]["properties"]["x"]["$ref"] == f"#/$defs/{expected}"
+
+
+def test_phase_rejects_bounds_where_the_parameter_type_has_none():
+    d = _valid_pmm_lab6_phase_dict()
+    d["unit_cell"]["a"] = [4.15692, False, 4.0, 4.3]
+    with pytest.raises(ValidationError) as exc_info:
+        Phase[RP].model_validate(d)
+    assert _errors(exc_info) == [(("unit_cell", "a"), "value_error")]
+    assert "bounds are not supported" in exc_info.value.errors()[0]["msg"]
+
+
+def test_bounded_phase_canonicalization_keeps_flag_and_bounds():
+    """Phase[BoundedRefinableParameter]: the canonical value replaces .value; flag and bounds stay."""
+    d = _bounded(_valid_pmm_lab6_phase_dict())
+    d["atoms"]["B1"]["x"] = [0.4999999, False, None, None]
+    d["atoms"]["B1"]["z"] = [0.2021, True, 0.15, 0.25]
+    phase = Phase[BRP].model_validate(d)
+    assert phase.atoms["B1"].x.model_dump() == [0.5, False, None, None]
+    assert phase.atoms["B1"].z.model_dump() == [0.2021, True, 0.15, 0.25]
+    assert [w["code"] for w in phase.warnings()] == ["special_position_adjusted"]
+
+
+def test_phase_value_rules_act_on_value():
+    """Cell, occupancy and element rules read .value; each error at its own field (A70)."""
+    d = _valid_pmm_lab6_phase_dict()
+    d["unit_cell"]["a"] = [-4.0, False]
+    d["atoms"]["La1"]["occupancy"] = [1.5, False]
+    d["atoms"]["B1"]["element"] = "b"
+    with pytest.raises(ValidationError) as exc_info:
+        Phase[RP].model_validate(d)
+    assert _errors(exc_info) == [(("unit_cell", "a"), "value_error"),
+                                 (("atoms", "La1", "occupancy"), "value_error"),
+                                 (("atoms", "B1", "element"), "value_error")]
+    assert [e["msg"] for e in exc_info.value.errors()] == [
+        "Value error, cell length a must be positive, got -4.0",
+        "Value error, occupancy must be between 0 and 1 inclusive, got 1.5",
+        "Value error, element 'b': write the element symbol as 'B'",
+    ]
+
+
 # --- numbers are JSON numbers: no strings, no booleans (A80) -----------------
 
 import numpy as np  # noqa: E402
@@ -1415,11 +1533,15 @@ def test_phase_structure_does_not_modify_caller_atoms():
 
 
 def _cell(**kw):
-    return {"a": 4.0, "b": 4.0, "c": 4.0, "alpha": 90, "beta": 90, "gamma": 90, **kw}
+    base = {"a": [4.0, False], "b": [4.0, False], "c": [4.0, False], "alpha": [90, False], "beta": [90, False], "gamma": [90, False]}
+    base.update(kw)
+    return base
 
 
 def _atom(**kw):
-    return {"element": "Na", "x": 0.1, "y": 0.2, "z": 0.3, "ADP": "Uiso", "Uiso": 0.01, **kw}
+    base = {"element": "Na", "x": [0.1, False], "y": [0.2, False], "z": [0.3, False], "occupancy": [1.0, False], "ADP": "Uiso", "Uiso": [0.01, False]}
+    base.update(kw)
+    return base
 
 
 def _xrd(**kw):
@@ -1432,9 +1554,6 @@ def _xrd(**kw):
     ("BoundedRefinableParameter.value", lambda v: BoundedRefinableParameter.model_validate([v, True, None, None]), ("value",)),
     ("BoundedRefinableParameter.min", lambda v: BoundedRefinableParameter.model_validate([1.0, True, v, None]), ("min",)),
     ("BoundedRefinableParameter.max", lambda v: BoundedRefinableParameter.model_validate([0.5, True, None, v]), ("max",)),
-    ("StructureRefinableParameter.value", lambda v: StructureRefinableParameter.model_validate([v, True]), ("value",)),
-    ("StructureBoundedRefinableParameter.value",
-     lambda v: StructureBoundedRefinableParameter.model_validate([v, True, None, None]), ("value",)),
     ("FitRange.min", lambda v: FitRange.model_validate([v, None]), ("min",)),
     ("FitRange.max", lambda v: FitRange.model_validate([None, v]), ("max",)),
     ("XRDData.tth", lambda v: XRDData.model_validate(_xrd(tth=[v, 20.0])), ("tth", 0)),
@@ -1442,12 +1561,13 @@ def _xrd(**kw):
     ("XRDData.Itth_weights", lambda v: XRDData.model_validate(_xrd(Itth_weights=[v, 1.0])), ("Itth_weights", 0)),
     ("ChebyshevBackground.coefficients",
      lambda v: ChebyshevBackground(num_coefficients=1, coefficients=[v], refine_flag=False), ("coefficients", 0)),
-    *[(f"UnitCell.{k}", (lambda k: lambda v: UnitCell.model_validate(_cell(**{k: v})))(k), (k,))
+    *[(f"UnitCell.{k}", (lambda k: lambda v: UnitCell[RefinableParameter].model_validate(_cell(**{k: [v, False]})))(k), (k, "value"))
       for k in ("a", "b", "c", "alpha", "beta", "gamma")],
-    *[(f"Atom.{k}", (lambda k: lambda v: Atom.model_validate(_atom(**{k: v})))(k), (k,))
+    *[(f"Atom.{k}", (lambda k: lambda v: Atom[RefinableParameter].model_validate(_atom(**{k: [v, False]})))(k), (k, "value"))
       for k in ("x", "y", "z", "occupancy", "Uiso")],
-    ("Atom.Uaniso", lambda v: Atom.model_validate(_atom(ADP="Uaniso", Uiso=None, Uaniso={
-        "U11": v, "U22": 0.01, "U33": 0.01, "U12": 0.0, "U13": 0.0, "U23": 0.0})), ("Uaniso", "U11")),
+    ("Atom.Uaniso", lambda v: Atom[RefinableParameter].model_validate({
+        "element": "Na", "x": [0.1, False], "y": [0.2, False], "z": [0.3, False], "occupancy": [1.0, False], "ADP": "Uaniso",
+        "Uaniso": {"U11": [v, False], "U22": [0.01, False], "U33": [0.01, False], "U12": [0.0, False], "U13": [0.0, False], "U23": [0.0, False]}}), ("Uaniso", "U11", "value")),
 ]
 _FLOAT_IDS = [f[0] for f in _NUMERIC_FIELDS]
 
@@ -1473,14 +1593,14 @@ def test_numeric_field_accepts_numbers(label, build, loc, good):
 def test_numeric_json_strings_rejected():
     """From JSON too: a quoted number is not a number."""
     with pytest.raises(ValidationError) as exc_info:
-        Atom.model_validate_json(json.dumps(_atom(x="0.25")))
-    assert _errors(exc_info) == [(("x",), "float_type")]
-    assert Atom.model_validate_json(json.dumps(_atom(x=1))).x == 1.0
+        Atom[RefinableParameter].model_validate_json(json.dumps(_atom(x=["0.25", False])))
+    assert _errors(exc_info) == [(("x", "value"), "float_type")]
+    assert Atom[RefinableParameter].model_validate_json(json.dumps(_atom(x=[1, False]))).x.value == 1.0
 
 
 @pytest.mark.parametrize("good", [4, 4.0, np.int64(4), np.float64(4.0)])
 def test_integer_fields_accept_whole_numbers(good):
-    assert Atom.model_validate(_atom(Multiplicity=good)).Multiplicity == 4
+    assert Atom[RefinableParameter].model_validate(_atom(Multiplicity=good)).Multiplicity == 4
     assert ChebyshevBackground(num_coefficients=good, coefficients=[0.0] * 4, refine_flag=False).num_coefficients == 4
 
 
@@ -1489,7 +1609,7 @@ def test_integer_fields_accept_whole_numbers(good):
 ])
 def test_integer_fields_reject_fractions_strings_and_booleans(bad, error_type):
     with pytest.raises(ValidationError) as exc_info:
-        Atom.model_validate(_atom(Multiplicity=bad))
+        Atom[RefinableParameter].model_validate(_atom(Multiplicity=bad))
     assert _errors(exc_info) == [(("Multiplicity",), error_type)]
     with pytest.raises(ValidationError) as exc_info:
         ChebyshevBackground(num_coefficients=bad, coefficients=[0.0] * 4, refine_flag=False)
@@ -1497,4 +1617,4 @@ def test_integer_fields_reject_fractions_strings_and_booleans(bad, error_type):
 
 
 def test_integer_json_whole_float_accepted():
-    assert Atom.model_validate_json(json.dumps(_atom(Multiplicity=4.0))).Multiplicity == 4
+    assert Atom[RefinableParameter].model_validate_json(json.dumps(_atom(Multiplicity=4.0))).Multiplicity == 4

From af9d2ec77f3b40d760ab1112b13d0ffff2aeeb9d Mon Sep 17 00:00:00 2001
From: acorrao <95718914+AdamCorrao@users.noreply.github.com>
Date: Wed, 7 Oct 2026 11:15:15 -0400
Subject: [PATCH 03/14] feat(symmetry): cell tie groups (incl. :R) and site
 coupling groups with affine relations (A94, A95, A98)

- `cell_tie_groups(space_group)`: which cell parameters are one parameter
  (cubic {a,b,c}; tetragonal/hexagonal {a,b},{c}; `:R` {a,b,c} and
  {alpha,beta,gamma}; monoclinic unique-axis angle via the A102 helper) and
  which angles are fixed. `cell_constraints` is unchanged and keeps its `:R`
  refusal for the legacy TOPAS/easydiffraction callers (deliberate change #2).
- `coupling_groups(space_group, xyz)`: coordinate and Uij tie groups at the
  canonical site, as connected components of the orthogonal projector onto
  the allowed subspace (the oblique Reynolds average gives wrong Uij groups on
  hexagonal axes). Each group exposes its exact relation `member = k*rep + c`:
  affine for coordinates, with `c` from the canonical values (P-42_1m 4e
  y = x + 1/2; P4_2/mnm y = -x + 1), linear for Uij (U12 = U22/2,
  U23 = -U13). Review B1.

Proof:
- engine-free, all 564 gemmi settings, every distinct special site on the
  1/24 grid (3,451): fixed sets match analyze_site; moving along any
  coordinate group's relation stays fixed by the whole stabilizer; a Uij
  tensor along any group's relation is invariant (2,792 coordinate groups);
- vs GSAS-II GetCSxinel/GetCSuinel, the 522 settings GSAS-II reads (2,928
  sites): partition, fixed set, one DOF per group and relation coefficients
  agree everywhere GSAS-II names the site; its 17 known defects (9 R-centred
  2-fold sites read as general, EB-40; 8 'sp' sites, EB-05) are listed and
  asserted to still differ (review S2);
- every gemmi setting: cell groups agree with the metric (a group moved
  together stays symmetric, one member alone or a fixed angle breaks it) and,
  off `:R`, with cell_constraints.

Assisted-by: claude-code:claude-opus-5-5
---
 src/powderline/symmetry.py              | 191 ++++++++++++++++++++++++
 tests/symmetry_sites.py                 |  25 ++++
 tests/test_symmetry_characterization.py | 128 ++++++++++++++++
 tests/test_symmetry_core.py             | 173 +++++++++++++++++++++
 4 files changed, 517 insertions(+)
 create mode 100644 tests/symmetry_sites.py

diff --git a/src/powderline/symmetry.py b/src/powderline/symmetry.py
index 0fbefde..a0d978f 100644
--- a/src/powderline/symmetry.py
+++ b/src/powderline/symmetry.py
@@ -13,6 +13,12 @@
   A73): multiplicity + DOF from the space group, the ambiguous-band error, and
   the canonical (exact) special-position coordinates every gateway sends to its
   engine. Policy and evidence: devkit ``tasks/re03-symmetry-tolerance.md``.
+* :func:`canonical_space_group` -- the core schema's space-group rule: gemmi's
+  canonical name only (A105).
+* :func:`cell_tie_groups` / :func:`coupling_groups` -- which cell, coordinate
+  and Uij parameters are one parameter by symmetry, with their exact relation
+  (affine for coordinates), and which are fixed: the basis of the phase
+  block's flag and bound rules (A94, A95, A98).
 
 Space-group operations come from gemmi; the stabiliser / projector math is our
 own (~small, spec in plan §5). ``gemmi`` is an approved runtime dependency (D3).
@@ -641,3 +647,188 @@ def check_uij(space_group: str, xyz, uij) -> tuple[tuple[float, ...], bool]:
         return tuple(float(v) for v in stated), False
     return tuple(float(v) for v in symmetric), True
 
+
+# --- (f) tie groups: cell (A95) and site coupling groups (A94, A98, A102) ---
+
+
+@dataclass(frozen=True)
+class TieGroup:
+    """Parameters that are one parameter by symmetry: ``member = k * rep + c``.
+
+    The first member is the representative (``k = 1``, ``c = 0``). ``k`` and
+    ``c`` are exact. Offsets are nonzero only for coordinates (affine ties such
+    as ``(x, x+1/2, z)``); they come from the canonical position, so they
+    reflect the lattice translate that was stated (A98). Cell ties are equalities.
+
+    Attributes:
+        members: parameter names, in canonical order (a..gamma, x/y/z, U11..U23).
+        coefficients: ``k`` per member.
+        offsets: ``c`` per member.
+    """
+
+    members: tuple[str, ...]
+    coefficients: tuple[Fraction, ...]
+    offsets: tuple[Fraction, ...]
+
+    def relation(self, member: str) -> tuple[Fraction, Fraction]:
+        """``(k, c)`` of ``member = k * rep + c``."""
+        i = self.members.index(member)
+        return self.coefficients[i], self.offsets[i]
+
+    def relations_text(self) -> str:
+        """The non-trivial relations, e.g. ``"y = x + 1/2"`` or ``"U12 = U22/2"``; ``""`` for equal ties."""
+        rep = self.members[0]
+        parts = [f"{m} = {_affine_text(k, rep, c)}" for m, k, c in
+                 zip(self.members[1:], self.coefficients[1:], self.offsets[1:]) if (k, c) != (1, 0)]
+        return ", ".join(parts)
+
+
+@dataclass(frozen=True)
+class Ties:
+    """Symmetry ties of one parameter set: tie groups of the free parameters, and the fixed ones.
+
+    Every parameter is in exactly one group or in ``fixed``. A singleton group is
+    an independent parameter.
+    """
+
+    groups: tuple[TieGroup, ...]
+    fixed: tuple[str, ...]
+
+    def group_of(self, name: str) -> TieGroup | None:
+        return next((g for g in self.groups if name in g.members), None)
+
+
+@dataclass(frozen=True)
+class CellTies(Ties):
+    """:class:`Ties` of the unit cell, with the crystal system and monoclinic unique axis."""
+
+    crystal_system: str = ""
+    unique_axis: str | None = None
+
+
+@dataclass(frozen=True)
+class SiteTies:
+    """Coordinate and Uij :class:`Ties` of one atomic site (U11, U22, U33, U12, U13, U23)."""
+
+    xyz: Ties
+    uij: Ties
+
+
+def _affine_text(k: Fraction, rep: str, c: Fraction) -> str:
+    sign = "-" if k < 0 else ""
+    k = abs(k)
+    term = f"{sign}{k.numerator if k.numerator != 1 else ''}{rep}" + (f"/{k.denominator}" if k.denominator != 1 else "")
+    if c == 0:
+        return term
+    return f"{term} {'+' if c > 0 else '-'} {abs(c)}"
+
+
+def _equal_group(names) -> TieGroup:
+    n = len(names)
+    return TieGroup(tuple(names), (Fraction(1),) * n, (Fraction(0),) * n)
+
+
+def cell_tie_groups(space_group: str) -> CellTies:
+    """Cell tie groups for ``space_group``: equal lengths, tied free angles, fixed angles.
+
+    Every free group is one parameter (A94): cubic ``{a, b, c}``; tetragonal and
+    hexagonal axes ``{a, b}``, ``{c}``; rhombohedral axes (``:R``) ``{a, b, c}`` and
+    ``{alpha, beta, gamma}``; monoclinic: each length plus the unique-axis angle
+    (A102); triclinic: all six independent. Unlike :func:`cell_constraints`
+    (kept for the legacy callers, which rely on its ``:R`` refusal), this covers
+    ``:R``. The setting must be explicit (A62).
+    """
+    sg = resolve_space_group(space_group, explicit_setting=True)
+    system = sg.crystal_system_str()
+    lengths = [_equal_group((n,)) for n in _LENGTHS]
+    if system == "cubic":
+        return CellTies((_equal_group(_LENGTHS),), _ANGLES, system)
+    if system in ("tetragonal", "hexagonal", "trigonal"):
+        if sg.ext == "R":
+            return CellTies((_equal_group(_LENGTHS), _equal_group(_ANGLES)), (), system)
+        return CellTies((_equal_group(("a", "b")), _equal_group(("c",))), _ANGLES, system)
+    if system == "orthorhombic":
+        return CellTies(tuple(lengths), _ANGLES, system)
+    if system == "monoclinic":
+        unique = _monoclinic_unique_axis(_expanded_ops(sg))
+        free = {"a": "alpha", "b": "beta", "c": "gamma"}[unique]
+        return CellTies((*lengths, _equal_group((free,))), tuple(a for a in _ANGLES if a != free),
+                        system, unique)
+    if system == "triclinic":
+        return CellTies((*lengths, *(_equal_group((a,)) for a in _ANGLES)), (), system)
+    raise SymmetryError(  # pragma: no cover - gemmi has no other crystal system
+        f"unsupported crystal system {system!r} for space group {space_group!r}"
+    )
+
+
+def _snap(value: float, max_denominator: int, what: str) -> Fraction:
+    frac = Fraction(value).limit_denominator(max_denominator)
+    if abs(float(frac) - value) > 1e-9:  # pragma: no cover - internal invariant
+        raise SymmetryError(f"{what} {value!r} is not a simple fraction (internal error)")
+    return frac
+
+
+def _tie_groups(projector: np.ndarray, names, values=None) -> Ties:
+    """Tie groups = connected components of the orthogonal projector's nonzero entries.
+
+    Each component must have one degree of freedom (rank 1). Its relation comes
+    from the component's basis vector; with ``values`` (the canonical
+    coordinates) the affine offsets ``c = member - k * rep`` are added.
+    """
+    n = len(names)
+    fixed = [np.linalg.norm(projector[j, :]) < _MAT_TOL for j in range(n)]
+    parent = list(range(n))
+
+    def find(i):
+        while parent[i] != i:
+            i = parent[i]
+        return i
+
+    for j in range(n):
+        for k in range(j + 1, n):
+            if not fixed[j] and not fixed[k] and abs(projector[j, k]) > _MAT_TOL:
+                parent[find(k)] = find(j)
+    components: dict[int, list[int]] = {}
+    for j in range(n):
+        if not fixed[j]:
+            components.setdefault(find(j), []).append(j)
+    groups = []
+    for members in sorted(components.values()):
+        block = projector[np.ix_(members, members)]
+        if abs(np.trace(block) - 1.0) > 1e-6:  # pragma: no cover - checked exhaustively in the tests
+            raise SymmetryError(f"tie group {[names[j] for j in members]} has "
+                                f"{np.trace(block):.3g} degrees of freedom (internal error)")
+        basis = block[:, int(np.argmax(np.diag(block)))]
+        ks = tuple(_snap(float(b / basis[0]), 12, "tie coefficient") for b in basis)
+        if values is None:
+            cs = (Fraction(0),) * len(members)
+        else:
+            rep = values[members[0]]
+            cs = tuple(_snap(float(values[j] - float(k) * rep), _MAX_DENOMINATOR, "tie offset")
+                       for j, k in zip(members, ks))
+        groups.append(TieGroup(tuple(names[j] for j in members), ks, cs))
+    return Ties(tuple(groups), tuple(names[j] for j in range(n) if fixed[j]))
+
+
+def coupling_groups(space_group: str, xyz) -> SiteTies:
+    """Coordinate and Uij tie groups of the site at ``xyz`` (A94, A95, A98).
+
+    The site is analyzed first (:func:`analyze_site`; ambiguous positions raise),
+    and the groups are taken at its canonical position. Non-fixed components are
+    grouped by connectivity of the **orthogonal** projector onto the allowed
+    subspace (the oblique Reynolds average gives wrong Uij groups on hexagonal
+    axes). Every group has one degree of freedom: one engine parameter.
+    Coordinate relations are affine (``y = x + 1/2`` at P-42_1m 4e), with the
+    offset taken from the canonical values; Uij relations are linear
+    (``U12 = U22/2``, ``U13 = -U23``). Checked against GSAS-II's
+    ``GetCSxinel``/``GetCSuinel`` over every distinct special site on the 1/24
+    grid of every setting GSAS-II reads (``tests/test_symmetry_characterization.py``).
+    """
+    site = analyze_site(space_group, xyz)
+    x = np.asarray(site.canonical)
+    ops = _expanded_ops(resolve_space_group(space_group, explicit_setting=True))
+    stab = [R for R, t in ops if np.max(np.abs(_wrap_symmetric(R @ x + t - x))) < SPECIAL_POSITION_TOL]
+    return SiteTies(
+        xyz=_tie_groups(_orthogonal_projector(sum(stab) / len(stab)), _AXIS_LETTERS, x),
+        uij=_tie_groups(_orthogonal_projector(_adp_projector(stab)), _UIJ_NAMES),
+    )
diff --git a/tests/symmetry_sites.py b/tests/symmetry_sites.py
new file mode 100644
index 0000000..0156a93
--- /dev/null
+++ b/tests/symmetry_sites.py
@@ -0,0 +1,25 @@
+"""Test helper: enumerate every distinct special site of a space group on the 1/24 grid."""
+
+from __future__ import annotations
+
+import itertools
+
+import gemmi
+import numpy as np
+
+
+def distinct_special_sites(sg: gemmi.SpaceGroup) -> list[tuple[int, int, int]]:
+    """One grid point (in 1/24 units) per distinct site stabilizer met on the 1/24 grid.
+
+    Exact: integer arithmetic mod 24 (gemmi's ``Op.DEN`` is 24). Every fixed
+    special-position coordinate is a multiple of 1/24, so each stabilizer
+    (each orientation of each Wyckoff site) is met.
+    """
+    grid = np.array(list(itertools.product(range(24), repeat=3)), dtype=np.int64)
+    ops = list(sg.operations())
+    rots = np.array([op.rot for op in ops], dtype=np.int64) // gemmi.Op.DEN
+    trans = np.array([op.tran for op in ops], dtype=np.int64) * 24 // gemmi.Op.DEN
+    fixed = np.all((np.einsum("nij,pj->pni", rots, grid) + trans[None]) % 24 == grid[:, None, :], axis=2)
+    special = np.nonzero(fixed.sum(axis=1) > 1)[0]
+    _, first = np.unique(fixed[special], axis=0, return_index=True)
+    return [tuple(int(v) for v in grid[p]) for p in special[np.sort(first)]]
diff --git a/tests/test_symmetry_characterization.py b/tests/test_symmetry_characterization.py
index 185b1b7..d988e89 100644
--- a/tests/test_symmetry_characterization.py
+++ b/tests/test_symmetry_characterization.py
@@ -184,3 +184,131 @@ def test_committed_examples_agree_with_gsasii():
                 assert site.multiplicity == G2spc.SytSym(list(xyz), sgdata)[1]
                 checked += 1
     assert checked >= 20
+
+
+# --- coupling groups vs GSAS-II, exhaustive (re/03b; A94, A95, A98) ----------
+#
+# Every distinct site stabilizer met on the 1/24 grid, in every gemmi setting
+# GSAS-II reads (522: all ':R' settings and every non-standard monoclinic and
+# orthorhombic setting; origin-1 settings skipped, EB-03): the tie groups of
+# coordinates and Uij (partition, fixed set) and each group's relation
+# coefficients against GSAS-II's GetCSxinel/GetCSuinel ids and multipliers.
+# Devkit probe: probes/re03b_review_symmetry_probe.py (review S2).
+
+from powderline.symmetry import coupling_groups  # noqa: E402
+from symmetry_sites import distinct_special_sites  # noqa: E402
+
+#: GSAS-II sites it reads wrongly (core is right there). Points in 1/24 units.
+#: EB-40: R-centred 2-fold sites GSAS-II calls general ('1', doubled
+#: multiplicity). EB-05: sites it cannot name ('sp'; GetCSxinel raises).
+#: Each must STILL differ: if one starts to agree, a GSAS-II upgrade fixed it,
+#: and EB-40/EB-05 and the re/04 gateway check need revisiting.
+GSASII_DEFECTS = {
+    ("R 3 2:H", (0, 8, 4)): ("1", 18), ("R 3 2:H", (0, 16, 4)): ("1", 18),
+    ("R 3 2:H", (16, 0, 8)): ("1", 18),
+    ("R -3 m:H", (0, 8, 4)): ("1", 36), ("R -3 m:H", (0, 16, 4)): ("1", 36),
+    ("R -3 m:H", (16, 0, 8)): ("1", 36),
+    ("R -3 c:H", (0, 8, 10)): ("1", 36), ("R -3 c:H", (0, 16, 10)): ("1", 36),
+    ("R -3 c:H", (16, 0, 2)): ("1", 36),
+    ("R -3 m:R", (0, 12, 0)): ("sp", 3),
+    ("P 4 3 2", (0, 1, 0)): ("sp", 6),
+    ("F 4 3 2", (0, 1, 0)): ("sp", 24), ("F 4 3 2", (0, 1, 12)): ("sp", 24),
+    ("I 4 3 2", (0, 1, 0)): ("sp", 12),
+    ("P n -3 n:2", (6, 0, 6)): ("sp", 12),
+    ("F m -3 c", (6, 1, 6)): ("sp", 48), ("F m -3 c", (6, 1, 18)): ("sp", 48),
+}
+
+
+def _gsas_symbol_any_setting(sg):
+    """Like ``_gsas_symbol``, also for ':R' and spacing variants GSAS-II reads (review probe)."""
+    x = np.array([0.1234, 0.2345, 0.3456])
+    ref = _orbit(_expanded_ops(sg), x)
+    parts = sg.hm.split()
+    candidates = [sg.hm + " R"] if sg.ext == "R" else []
+    candidates += [sg.hm, G2spc.StandardizeSpcName(sg.short_name()),
+                   G2spc.StandardizeSpcName(sg.hm.replace(" ", ""))]
+    if len(parts) == 4 and parts[1] == "1" and parts[3] == "1":
+        candidates.append(f"{parts[0]} {parts[2]}")
+    for cand in candidates:
+        try:
+            err, sgdata = G2spc.SpcGroup(cand)
+        except Exception:  # noqa: BLE001 - GSAS-II raises on some spellings
+            continue
+        if err:
+            continue
+        theirs = [np.array(e[0]) % 1.0 for e in G2spc.GenAtom(x, sgdata, All=False)]
+        if len(theirs) == len(ref) and all(any(_same_mod1(p, q) for q in theirs) for p in ref):
+            return cand, sgdata
+    return None, None
+
+
+def _gsas_ties(ids, multipliers, names):
+    """GSAS-II constraint ids + multipliers -> ({members: relative multipliers}, fixed names)."""
+    groups: dict[int, list[int]] = {}
+    for j, gid in enumerate(ids):
+        if gid != 0:
+            groups.setdefault(gid, []).append(j)
+    ties = {tuple(names[j] for j in members): tuple(multipliers[j] / multipliers[members[0]] for j in members)
+            for members in groups.values()}
+    return ties, tuple(n for n, gid in zip(names, ids) if gid == 0)
+
+
+def _core_ties(ties):
+    return ({g.members: tuple(float(k) for k in g.coefficients) for g in ties.groups}, ties.fixed)
+
+
+def _same_ties(ours, theirs) -> bool:
+    (og, of), (tg, tf) = ours, theirs
+    return of == tf and og.keys() == tg.keys() and all(
+        all(abs(a - b) < 1e-9 for a, b in zip(og[k], tg[k])) for k in og)
+
+
+@pytest.fixture(scope="module")
+def coupling_comparison():
+    """Compare every distinct special site; returns (settings, sites compared, disagreements)."""
+    settings, sites, disagreements = 0, 0, {}
+    for sg in gemmi.spacegroup_table():
+        if sg.ext == "1":
+            continue  # GSAS-II has no origin-1 settings (EB-03)
+        _symbol, sgdata = _gsas_symbol_any_setting(sg)
+        if sgdata is None:
+            continue  # 9 settings GSAS-II cannot express
+        settings += 1
+        name = sg.xhm()
+        for point in distinct_special_sites(sg):
+            x = [v / 24 for v in point]
+            sites += 1
+            site, ties = analyze_site(name, x), coupling_groups(name, x)
+            sitesym, mult = G2spc.SytSym(x, sgdata)[0:2]
+            ours = {"multiplicity": site.multiplicity,
+                    "xyz": _core_ties(ties.xyz), "uij": _core_ties(ties.uij)}
+            try:
+                theirs = {"multiplicity": mult,
+                          "xyz": _gsas_ties(*G2spc.GetCSxinel(sitesym)[:2], ("x", "y", "z")),
+                          "uij": _gsas_ties(*G2spc.GetCSuinel(sitesym)[:2],
+                                            ("U11", "U22", "U33", "U12", "U13", "U23"))}
+            except KeyError:  # GSAS-II cannot name the site ('sp', EB-05)
+                disagreements[(name, point)] = (sitesym, mult)
+                continue
+            if not (ours["multiplicity"] == theirs["multiplicity"]
+                    and _same_ties(ours["xyz"], theirs["xyz"]) and _same_ties(ours["uij"], theirs["uij"])):
+                disagreements[(name, point)] = (sitesym, mult)
+    return settings, sites, disagreements
+
+
+def test_coupling_groups_match_gsasii_where_it_reads_the_site(coupling_comparison):
+    """Partition, fixed set, one DOF per group and relation coefficients agree with GSAS-II."""
+    settings, sites, disagreements = coupling_comparison
+    assert settings == 522
+    assert sites == 2928  # 2,920 GSAS-II names + 8 it cannot ('sp')
+    unexpected = {k: v for k, v in disagreements.items() if k not in GSASII_DEFECTS}
+    assert not unexpected, f"new disagreements with GSAS-II (escalate, A35): {unexpected}"
+
+
+def test_known_gsasii_site_defects_still_differ(coupling_comparison):
+    """The 17 known GSAS-II defects (EB-40, EB-05) are still there, exactly as recorded."""
+    _settings, _sites, disagreements = coupling_comparison
+    assert {k: disagreements.get(k) for k in GSASII_DEFECTS} == GSASII_DEFECTS
+    for (name, point), (sitesym, mult) in GSASII_DEFECTS.items():
+        core = analyze_site(name, [v / 24 for v in point]).multiplicity
+        assert sitesym == "sp" or mult == 2 * core, (name, point)
diff --git a/tests/test_symmetry_core.py b/tests/test_symmetry_core.py
index 58bf81b..b530d2a 100644
--- a/tests/test_symmetry_core.py
+++ b/tests/test_symmetry_core.py
@@ -250,3 +250,176 @@ def test_is_group_detects_closure():
 def test_ambiguous_band_message_names_the_special_position():
     with pytest.raises(SymmetryError, match=r"from the special position \(1/3, 2/3, 1/4\) \(multiplicity 2\)"):
         analyze_site("P 63/m m c", (0.3333, 0.6667, 0.25))
+
+
+# --- tie groups: coupling_groups, cell_tie_groups (re/03b; A94, A95, A98, A102) ---
+
+import gemmi  # noqa: E402
+import numpy as np  # noqa: E402
+
+from powderline import symmetry as sym  # noqa: E402
+from powderline.symmetry import cell_constraints, cell_tie_groups, coupling_groups  # noqa: E402
+from symmetry_sites import distinct_special_sites  # noqa: E402
+
+_UIJ = ("U11", "U22", "U33", "U12", "U13", "U23")
+
+
+def _ties(ties):
+    """Ties -> ({members: (coefficients, offsets)}, fixed), with exact Fractions."""
+    return {g.members: (g.coefficients, g.offsets) for g in ties.groups}, ties.fixed
+
+
+def test_coupling_groups_are_one_dof_affine_relations_in_every_setting():
+    """All 564 gemmi settings (incl. origin 1 and ':R'), every distinct special site on the
+    1/24 grid: the fixed sets match analyze_site; moving the site along any coordinate group's
+    relation keeps it fixed by the whole stabilizer; a Uij tensor built along any Uij group's
+    relation is invariant under it. Proves each group is one DOF with the right relation."""
+    settings = sites = groups = 0
+    for sg in gemmi.spacegroup_table():
+        name = sg.xhm()
+        ops = sym._expanded_ops(sg)
+        settings += 1
+        for point in distinct_special_sites(sg):
+            x = np.array(point) / 24
+            stab = [(R, t) for R, t in ops if np.all(np.abs(sym._wrap_symmetric(R @ x + t - x)) < 1e-9)]
+            site, ties = analyze_site(name, x), coupling_groups(name, x)
+            sites += 1
+            assert set(ties.xyz.fixed) == {a for a, c in zip("xyz", site.axes) if c == "FIXED"}
+            assert set(ties.uij.fixed) == {u for u, c in zip(_UIJ, site.adp) if c == "FIXED"}
+            for g in ties.xyz.groups:
+                groups += 1
+                moved = np.array(site.canonical)
+                rep = moved["xyz".index(g.members[0])] + 0.0123
+                for member, k, c in zip(g.members, g.coefficients, g.offsets):
+                    moved["xyz".index(member)] = float(k) * rep + float(c)
+                worst = max(np.max(np.abs(sym._wrap_symmetric(R @ moved + t - moved))) for R, t in stab)
+                assert worst < 1e-12, (name, point, g)
+            for g in ties.uij.groups:
+                assert set(g.offsets) == {0}
+                u = np.zeros(6)
+                for member, k in zip(g.members, g.coefficients):
+                    u[_UIJ.index(member)] = float(k) * 0.01
+                tensor = sym._sym_from_vec(u)
+                assert max(np.max(np.abs(R @ tensor @ R.T - tensor)) for R, _t in stab) < 1e-12, (name, point, g)
+    assert (settings, sites, groups) == (564, 3451, 2792)
+
+
+@pytest.mark.parametrize("space_group, xyz, expected", [
+    # review B1: affine ties; the offset follows the stated lattice translate
+    ("P -4 21 m", (0.1, 0.6, 0.3), {("x", "y"): ((1, 1), (0, Fraction(1, 2))), ("z",): ((1,), (0,))}),
+    ("P -4 21 m", (0.1, 0.4, 0.3), {("x", "y"): ((1, -1), (0, Fraction(1, 2))), ("z",): ((1,), (0,))}),
+    ("P -4 21 m", (0.1, -0.4, 0.3), {("x", "y"): ((1, 1), (0, Fraction(-1, 2))), ("z",): ((1,), (0,))}),
+    ("P 42/m n m", (0.3, 0.7, 0.0), {("x", "y"): ((1, -1), (0, 1))}),
+    ("P 63/m m c", (1 / 6, 1 / 3, 0.25), {("x", "y"): ((1, 2), (0, 0))}),
+    ("R -3 m:H", (0.1, -0.1, 0.3), {("x", "y"): ((1, -1), (0, 0)), ("z",): ((1,), (0,))}),
+    ("P m -3 m", (0.5, 0.5, 0.2021), {("z",): ((1,), (0,))}),
+    ("R -3 m:R", (0.1, 0.1, 0.1), {("x", "y", "z"): ((1, 1, 1), (0, 0, 0))}),
+])
+def test_coupling_groups_coordinate_relations(space_group, xyz, expected):
+    groups, _fixed = _ties(coupling_groups(space_group, xyz).xyz)
+    assert groups == expected
+
+
+@pytest.mark.parametrize("space_group, xyz, expected_groups, expected_fixed", [
+    # several coupled Uij groups at one site; factor-2 and negative relations
+    ("P 63/m m c", (1 / 6, 1 / 3, 0.25),
+     {("U11",): ((1,), (0,)), ("U22", "U12"): ((1, Fraction(1, 2)), (0, 0)), ("U33",): ((1,), (0,))},
+     ("U13", "U23")),
+    ("P 6/m m m", (1 / 3, 2 / 3, 0.0),
+     {("U11", "U22", "U12"): ((1, 1, Fraction(1, 2)), (0, 0, 0)), ("U33",): ((1,), (0,))}, ("U13", "U23")),
+    ("P -4 21 m", (0.1, 0.4, 0.3),
+     {("U11", "U22"): ((1, 1), (0, 0)), ("U33",): ((1,), (0,)), ("U12",): ((1,), (0,)),
+      ("U13", "U23"): ((1, -1), (0, 0))}, ()),
+    ("P m -3 m", (0.0, 0.0, 0.0), {("U11", "U22", "U33"): ((1, 1, 1), (0, 0, 0))}, ("U12", "U13", "U23")),
+])
+def test_coupling_groups_uij_relations(space_group, xyz, expected_groups, expected_fixed):
+    assert _ties(coupling_groups(space_group, xyz).uij) == (expected_groups, expected_fixed)
+
+
+@pytest.mark.parametrize("space_group, xyz, text", [
+    ("P -4 21 m", (0.1, 0.6, 0.3), "y = x + 1/2"),
+    ("P -4 21 m", (0.1, 0.4, 0.3), "y = -x + 1/2"),
+    ("P 42/m n m", (0.3, 0.7, 0.0), "y = -x + 1"),
+    ("P 63/m m c", (1 / 6, 1 / 3, 0.25), "y = 2x"),
+    ("R -3 m:R", (0.1, 0.1, 0.1), ""),
+])
+def test_tie_group_relations_text(space_group, xyz, text):
+    assert coupling_groups(space_group, xyz).xyz.groups[0].relations_text() == text
+
+
+def test_tie_group_relations_text_uij():
+    ties = coupling_groups("P 63/m m c", (1 / 6, 1 / 3, 0.25)).uij
+    assert ties.group_of("U12").relations_text() == "U12 = U22/2"
+    assert coupling_groups("P -4 21 m", (0.1, 0.4, 0.3)).uij.group_of("U23").relations_text() == "U23 = -U13"
+    assert ties.group_of("U13") is None
+
+
+def test_coupling_groups_ambiguous_position_raises():
+    with pytest.raises(SymmetryError, match="without being on it"):
+        coupling_groups("P 63/m m c", (0.3333, 0.6667, 0.25))
+
+
+_ALL = ("a", "b", "c", "alpha", "beta", "gamma")
+
+
+@pytest.mark.parametrize("space_group, groups, fixed, system, axis", [
+    ("F m -3 m", [("a", "b", "c")], ("alpha", "beta", "gamma"), "cubic", None),
+    ("I 41/a m d:2", [("a", "b"), ("c",)], ("alpha", "beta", "gamma"), "tetragonal", None),
+    ("P 63/m m c", [("a", "b"), ("c",)], ("alpha", "beta", "gamma"), "hexagonal", None),
+    ("R -3 m:H", [("a", "b"), ("c",)], ("alpha", "beta", "gamma"), "trigonal", None),
+    ("R -3 m:R", [("a", "b", "c"), ("alpha", "beta", "gamma")], (), "trigonal", None),
+    ("R 3:R", [("a", "b", "c"), ("alpha", "beta", "gamma")], (), "trigonal", None),
+    ("P m m m", [("a",), ("b",), ("c",)], ("alpha", "beta", "gamma"), "orthorhombic", None),
+    ("C 1 2/m 1", [("a",), ("b",), ("c",), ("beta",)], ("alpha", "gamma"), "monoclinic", "b"),
+    ("P 1 c 1", [("a",), ("b",), ("c",), ("beta",)], ("alpha", "gamma"), "monoclinic", "b"),
+    ("C c 1 1", [("a",), ("b",), ("c",), ("alpha",)], ("beta", "gamma"), "monoclinic", "a"),
+    ("P 1 1 m", [("a",), ("b",), ("c",), ("gamma",)], ("alpha", "beta"), "monoclinic", "c"),
+    ("P -1", [("a",), ("b",), ("c",), ("alpha",), ("beta",), ("gamma",)], (), "triclinic", None),
+])
+def test_cell_tie_groups(space_group, groups, fixed, system, axis):
+    ties = cell_tie_groups(space_group)
+    assert [g.members for g in ties.groups] == groups
+    assert ties.fixed == fixed
+    assert (ties.crystal_system, ties.unique_axis) == (system, axis)
+    assert all(set(g.coefficients) == {1} and set(g.offsets) == {0} for g in ties.groups)
+
+
+def test_cell_tie_groups_every_setting_agree_with_the_metric():
+    """Every gemmi setting: each name is in one group or fixed; changing a whole group together
+    keeps a symmetric cell symmetric, changing one member alone (or a fixed angle) breaks it;
+    off ':R', the groups agree with cell_constraints."""
+    for sg in gemmi.spacegroup_table():
+        name = sg.xhm()
+        ties = cell_tie_groups(name)
+        names = [m for g in ties.groups for m in g.members] + list(ties.fixed)
+        assert sorted(names) == sorted(_ALL), name
+        rots = [R for R, _t in sym._expanded_ops(sg)]
+        g0 = sym._metric((5.1, 6.2, 7.3, 81.0, 86.0, 97.0))
+        cell = dict(zip(_ALL, sym._cell_from_metric(sum(R.T @ g0 @ R for R in rots) / len(rots))))
+        check_cell(name, tuple(cell.values()))
+        for group in ties.groups:
+            together = {k: v + (0.01 if k in group.members else 0.0) for k, v in cell.items()}
+            check_cell(name, tuple(together.values()))
+            if len(group.members) > 1:
+                alone = {k: v + (0.01 if k == group.members[-1] else 0.0) for k, v in cell.items()}
+                with pytest.raises(SymmetryError, match="inconsistent"):
+                    check_cell(name, tuple(alone.values()))
+        for angle in ties.fixed:
+            with pytest.raises(SymmetryError, match="inconsistent"):
+                check_cell(name, tuple(v + (0.01 if k == angle else 0.0) for k, v in cell.items()))
+        if sg.ext != "R":
+            rules = cell_constraints(name)
+            assert [g.members for g in ties.groups if g.members[0] in "abc"] == list(rules.length_groups)
+            assert (ties.fixed, ties.unique_axis) == (rules.fixed_angles, rules.unique_axis)
+
+
+def test_cell_constraints_keeps_its_rhombohedral_refusal():
+    """Deliberate change #2 stands: legacy callers rely on cell_constraints refusing ':R'."""
+    with pytest.raises(SymmetryError, match="rhombohedral ':R' setting are not implemented"):
+        cell_constraints("R -3 m:R")
+    assert [g.members for g in cell_tie_groups("R -3 m:R").groups] == [("a", "b", "c"), ("alpha", "beta", "gamma")]
+
+
+def test_cell_tie_groups_require_an_explicit_setting():
+    with pytest.raises(SymmetryError, match="rhombohedral; specify the setting"):
+        cell_tie_groups("R -3 m")

From 8f080c26b9cf27cdcd364c3d49751985f34c47b2 Mon Sep 17 00:00:00 2001
From: acorrao <95718914+AdamCorrao@users.noreply.github.com>
Date: Wed, 7 Oct 2026 11:21:49 -0400
Subject: [PATCH 04/14] feat(core): flag and bound rules F1-F4 on the phase
 block (A95, A98, A104, A106, A108)

The phase validator now checks refine flags and bounds against the symmetry
ties (cell_tie_groups, coupling_groups), after the values are valid and
canonical:
- F1: the members of one tie group carry the same flag. Reported at every
  member whose flag differs from the group's first member, naming the whole
  group (review N1), e.g. "cubic cell ('P m -3 m'): a, b, c are one
  parameter; set the same refine flag on all three".
- F2: a symmetry-fixed parameter has flag false; A106: and no bounds.
- F3: different groups are independent. A104: co-located atoms are never
  compared.
- F4 (with bounds): member bounds follow the tie from the first member's,
  affine for coordinates ([k*min + c, k*max + c], swapped for k < 0, open
  sides map to the matching side). A108: within the family's value tolerance
  (coordinates 5e-6, Uij 1e-6 A^2, cell CELL_TOL) the bounds are set exactly,
  with a `tied_bounds_adjusted` warning; beyond, an error at the member.
- Review N4: a value moved by canonicalization (A73/A78) is re-checked against
  its final bounds.

All problems are reported together in one ValidationError (A70), each at its
parameter (`unit_cell.b`, `atoms.<label>.y`, `atoms.<label>.Uaniso.U12`).

Tests: every crystal system incl. `:R` and Pm/Pc/Cm/Cc cells, special
positions, multi-group and negative Uij ties, affine ties at P-42_1m 4e and
P4_2/mnm 4f, open bounds, snapping vs errors, A106, N4, exact messages and
locations. The engine-import-block test now runs the new symmetry code and a
full phase validation with GSAS-II and easydiffraction blocked.

Assisted-by: claude-code:claude-opus-5-5
---
 src/powderline/schema_core.py | 179 ++++++++++++++++-
 src/powderline/symmetry.py    |   5 +
 tests/test_gateways.py        |  16 ++
 tests/test_schema_core.py     | 357 ++++++++++++++++++++++++++++++++++
 4 files changed, 551 insertions(+), 6 deletions(-)

diff --git a/src/powderline/schema_core.py b/src/powderline/schema_core.py
index 12a8ac7..3d13859 100644
--- a/src/powderline/schema_core.py
+++ b/src/powderline/schema_core.py
@@ -48,7 +48,18 @@
 from pydantic_core import InitErrorDetails, PydanticCustomError
 
 from powderline.exceptions import StructuredWarning, SymmetryError
-from powderline.symmetry import analyze_site, canonical_space_group, check_cell, check_uij
+from powderline.symmetry import (
+    CELL_TOL,
+    SPECIAL_POSITION_TOL,
+    UIJ_TOL,
+    Ties,
+    analyze_site,
+    canonical_space_group,
+    cell_tie_groups,
+    check_cell,
+    check_uij,
+    coupling_groups,
+)
 
 # --- versions (A40, A65) ---------------------------------------------------
 
@@ -648,9 +659,24 @@ class Phase(CoreModel, Generic[P]):
     adjustment is reported by :meth:`warnings` (A73). The unit cell must fit the
     space group exactly (A77), and anisotropic ADPs the site symmetry (A78).
 
+    Refine flags and bounds must agree with the symmetry ties
+    (:func:`~powderline.symmetry.cell_tie_groups`,
+    :func:`~powderline.symmetry.coupling_groups`; A94, A95, A98, A106, A108):
+    the members of one tie group carry the same flag (F1); a symmetry-fixed
+    parameter has flag false (F2) and no bounds (A106); different groups are
+    independent (F3); with bounds, each member's bounds follow the tie's
+    relation from the first member's (F4: ``member = k*rep + c`` maps
+    ``[min, max]`` to ``[k*min + c, k*max + c]``, swapped for k < 0; within the
+    family's value tolerance they are set exactly and reported). A value moved
+    by canonicalization is re-checked against its bounds (review N4). Atoms on
+    the same site are independent (A104).
+
     Every problem is reported at its own location (A70): ``unit_cell``,
     ``atoms.<label>`` (the position), ``atoms.<label>.Multiplicity``,
-    ``atoms.<label>.Uaniso``; all of them together, in one ``ValidationError``.
+    ``atoms.<label>.Uaniso``; a flag or bound rule at the parameter
+    (``unit_cell.b``, ``atoms.<label>.y``, ``atoms.<label>.Uaniso.U12``), for F1
+    at every member whose flag differs from the group's first member (review
+    N1); all of them together, in one ``ValidationError``.
     These checks run only once every field is valid: pydantic does not run
     model-level validators after a field error, so e.g. an unknown element is
     reported first, and the symmetry checks follow once it is fixed.
@@ -694,14 +720,33 @@ def problem(loc: tuple, message: str, value: Any) -> None:
             problems.append(InitErrorDetails(type="value_error", loc=loc, input=value,
                                              ctx={"error": ValueError(message)}))
 
+        def apply_tie_rules(loc: tuple, params: dict, ties: Ties, context: str, tolerance, fixed_value) -> dict:
+            errors, updates, adjusted = _tie_rules(params, ties, context, tolerance, fixed_value)
+            for name, message in errors:
+                problem((*loc, name), message, params[name].model_dump())
+            for name, message in adjusted:
+                self._warnings.append(StructuredWarning(
+                    code="tied_bounds_adjusted", message=message,
+                    field_path=".".join((*loc, name)),
+                ))
+            return updates
+
+        sg = self.space_group
         cell = self.unit_cell
         try:
-            check_cell(self.space_group, tuple(getattr(cell, k).value for k in _CELL_FIELDS))
+            check_cell(sg, tuple(getattr(cell, k).value for k in _CELL_FIELDS))
         except SymmetryError as exc:
             problem(("unit_cell",), str(exc), cell.model_dump())
+        else:  # flag and bound rules need a valid cell (A95, A98)
+            ties = cell_tie_groups(sg)
+            updates = apply_tie_rules(("unit_cell",), {k: getattr(cell, k) for k in _CELL_FIELDS}, ties,
+                                      f"{ties.crystal_system} cell ({sg!r})", _cell_bound_tolerance,
+                                      lambda name: f"{getattr(cell, name).value:g}")
+            if updates:
+                self.unit_cell = cell.model_copy(update=updates)
         for label, atom in list(self.atoms.items()):
             try:
-                site = analyze_site(self.space_group, (atom.x.value, atom.y.value, atom.z.value))
+                site = analyze_site(sg, (atom.x.value, atom.y.value, atom.z.value))
             except SymmetryError as exc:
                 problem(("atoms", label), str(exc), atom.model_dump())
                 continue  # the checks below need the site
@@ -709,14 +754,16 @@ def problem(loc: tuple, message: str, value: Any) -> None:
             if atom.Multiplicity is not None and atom.Multiplicity != site.multiplicity:
                 problem(("atoms", label, "Multiplicity"),
                         f"stated Multiplicity {atom.Multiplicity}, derived {site.multiplicity} "
-                        f"({self.space_group!r}, site {site.stated})", atom.Multiplicity)
+                        f"({sg!r}, site {site.stated})", atom.Multiplicity)
+            uaniso_ok = u_adjusted = False
             if atom.Uaniso is not None:
                 stated_u = tuple(atom.Uaniso[k].value for k in _UANISO_KEYS)
                 try:
-                    symmetric_u, u_adjusted = check_uij(self.space_group, site.canonical, stated_u)
+                    symmetric_u, u_adjusted = check_uij(sg, site.canonical, stated_u)
                 except SymmetryError as exc:
                     problem(("atoms", label, "Uaniso"), str(exc), atom.model_dump()["Uaniso"])
                 else:
+                    uaniso_ok = True
                     if u_adjusted:
                         update["Uaniso"] = {k: _with_value(atom.Uaniso[k], u)
                                             for k, u in zip(_UANISO_KEYS, symmetric_u)}
@@ -737,6 +784,31 @@ def problem(loc: tuple, message: str, value: Any) -> None:
                              f"{site.canonical}"),
                     field_path=f"atoms.{label}",
                 ))
+
+            # Flag and bound rules F1, F2, F4, A106 (A95, A98, A106, A108) on the canonical values.
+            ties = coupling_groups(sg, site.canonical)
+            context = f"atom {label!r} (multiplicity {site.multiplicity} in {sg!r})"
+            xyz = {k: update.get(k, getattr(atom, k)) for k in "xyz"}
+            update.update(apply_tie_rules(("atoms", label), xyz, ties.xyz, context,
+                                          lambda _name, _expected: SPECIAL_POSITION_TOL,
+                                          lambda name: str(site.exact["xyz".index(name)])))
+            if uaniso_ok:
+                uij = dict(update.get("Uaniso", atom.Uaniso))
+                uij.update(apply_tie_rules(("atoms", label, "Uaniso"), uij, ties.uij, context,
+                                           lambda _name, _expected: UIJ_TOL, lambda _name: "0"))
+                update["Uaniso"] = uij
+
+            # Review N4: a value moved by canonicalization is re-checked against its (final) bounds.
+            moved = [(("atoms", label, k), k, update.get(k, getattr(atom, k)), getattr(atom, k).value,
+                      "the exact special-position value") for k in "xyz" if site.adjusted]
+            if u_adjusted and uaniso_ok:
+                moved += [(("atoms", label, "Uaniso", k), k, update["Uaniso"][k], atom.Uaniso[k].value,
+                           "the site-symmetric value") for k in _UANISO_KEYS]
+            for loc, name, param, stated, what in moved:
+                message = _canonical_out_of_bounds(param)
+                if message:
+                    problem(loc, f"{context}: {name} = {param.value!r} ({what} of the stated {stated!r}) "
+                                 f"{message}", param.model_dump())
             if update:
                 self.atoms[label] = atom.model_copy(update=update)
         if problems:
@@ -760,6 +832,101 @@ def _with_value(param, value: float):
     return param.model_copy(update={"value": value})
 
 
+def _cell_bound_tolerance(name: str, expected: float) -> float:
+    """A108 for the cell: CELL_TOL relative on lengths, in degrees on angles (A77)."""
+    return CELL_TOL * abs(expected) if name in ("a", "b", "c") else CELL_TOL
+
+
+def _fmt_bounds(lo: Optional[float], hi: Optional[float]) -> str:
+    return "[" + ", ".join("null" if v is None else f"{v:.10g}" for v in (lo, hi)) + "]"
+
+
+_HOW_MANY = {2: "both", 3: "all three"}
+
+
+def _tie_rules(params: dict, ties: Ties, context: str, tolerance, fixed_value):
+    """The flag and bound rules of one parameter set (cell, a site's x/y/z, or its Uij).
+
+    - **F2** (A95): a symmetry-fixed parameter has refine flag false.
+    - **A106**: a symmetry-fixed parameter has no bounds (min and max null).
+    - **F1** (A95): the members of a tie group carry the same flag. The error is
+      reported at every member whose flag differs from the group's first
+      member, naming the whole group (review N1).
+    - **F4** (A98, A108): with bounds, each member's bounds follow the tie from
+      the first member's: ``member = k*rep + c`` maps ``[min, max]`` to
+      ``[k*min + c, k*max + c]``, swapped for k < 0; a null side stays null on
+      the matching side. Within ``tolerance(name, expected)`` the member's
+      bounds are replaced by the exact values (reported); beyond, an error.
+    - **F3**: different groups are independent (nothing to check).
+
+    Returns ``(errors, updates, adjusted)``: ``[(name, message)]``, the bound
+    updates ``{name: param}``, and ``[(name, message)]`` for the adjustments.
+    """
+    errors: list[tuple[str, str]] = []
+    adjusted: list[tuple[str, str]] = []
+    updates: dict[str, Any] = {}
+    for name in ties.fixed:
+        param = params[name]
+        if param.refine_flag:
+            errors.append((name, f"{context}: {name} is fixed by symmetry (= {fixed_value(name)}); "
+                                 "set its refine flag to false"))
+        if isinstance(param, BoundedRefinableParameter) and (param.min is not None or param.max is not None):
+            errors.append((name, f"{context}: {name} is fixed by symmetry (= {fixed_value(name)}); "
+                                 "give it no bounds (min and max null)"))
+    for group in ties.groups:
+        if len(group.members) < 2:
+            continue
+        rep = params[group.members[0]]
+        flag_words = _HOW_MANY.get(len(group.members), f"all {len(group.members)}")
+        relations = group.relations_text()
+        for name in group.members[1:]:
+            if params[name].refine_flag != rep.refine_flag:
+                errors.append((name, f"{context}: {', '.join(group.members)} are one parameter"
+                                     f"{f' ({relations})' if relations else ''}; "
+                                     f"set the same refine flag on {flag_words}"))
+        if not isinstance(rep, BoundedRefinableParameter):
+            continue
+        for name in group.members[1:]:
+            param = params[name]
+            k, c = (float(v) for v in group.relation(name))
+            lo, hi = (None if v is None else k * v + c for v in (rep.min, rep.max))
+            if k < 0:
+                lo, hi = hi, lo
+            ok, exact = True, True
+            for got, want in ((param.min, lo), (param.max, hi)):
+                if (got is None) != (want is None):
+                    ok = False
+                elif got is not None:
+                    ok = ok and abs(got - want) <= tolerance(name, want)
+                    exact = exact and abs(got - want) <= 1e-12
+            if not ok:
+                errors.append((name, f"{context}: the bounds of {name} must follow "
+                                     f"{group.relation_text(name)} from the bounds of {group.members[0]} "
+                                     f"{_fmt_bounds(rep.min, rep.max)}: expected {_fmt_bounds(lo, hi)}, "
+                                     f"got {_fmt_bounds(param.min, param.max)}"))
+            elif not exact:
+                updates[name] = param.model_copy(update={"min": lo, "max": hi})
+                adjusted.append((name, f"{context}: the bounds of {name} {_fmt_bounds(param.min, param.max)} "
+                                       f"were set to {_fmt_bounds(lo, hi)}, exactly "
+                                       f"{group.relation_text(name)} from the bounds of {group.members[0]}"))
+    return errors, updates, adjusted
+
+
+def _canonical_out_of_bounds(param) -> Optional[str]:
+    """Review N4: ``"is below min (...)"`` etc. when a moved value left its bounds, else ``None``.
+
+    Floating-point noise (1e-12) is not a move: canonicalization keeps a value
+    within that of the stated one as stated.
+    """
+    if not isinstance(param, BoundedRefinableParameter):
+        return None
+    if param.min is not None and param.value < param.min - 1e-12:
+        return f"is below min ({param.min!r})"
+    if param.max is not None and param.value > param.max + 1e-12:
+        return f"is above max ({param.max!r})"
+    return None
+
+
 # --- top-level recipe frame (A1, A18, A21, A40) ------------------------------
 
 
diff --git a/src/powderline/symmetry.py b/src/powderline/symmetry.py
index a0d978f..dd61114 100644
--- a/src/powderline/symmetry.py
+++ b/src/powderline/symmetry.py
@@ -675,6 +675,11 @@ def relation(self, member: str) -> tuple[Fraction, Fraction]:
         i = self.members.index(member)
         return self.coefficients[i], self.offsets[i]
 
+    def relation_text(self, member: str) -> str:
+        """``member``'s relation to the representative, e.g. ``"y = x + 1/2"`` or ``"b = a"``."""
+        k, c = self.relation(member)
+        return f"{member} = {_affine_text(k, self.members[0], c)}"
+
     def relations_text(self) -> str:
         """The non-trivial relations, e.g. ``"y = x + 1/2"`` or ``"U12 = U22/2"``; ``""`` for equal ties."""
         rep = self.members[0]
diff --git a/tests/test_gateways.py b/tests/test_gateways.py
index 1156041..f54a128 100644
--- a/tests/test_gateways.py
+++ b/tests/test_gateways.py
@@ -474,6 +474,22 @@ def find_spec(self, name, path, target=None):
 import powderline.easydiff.gateway
 from powderline import registry
 
+# The core phase block and its symmetry rules run engine-free (re/03b)
+from powderline.schema_core import Phase, RefinableParameter
+from powderline.symmetry import canonical_space_group, cell_tie_groups, coupling_groups
+canonical_space_group("F d -3 m:2")
+assert [g.members for g in cell_tie_groups("R -3 m:R").groups] == [("a", "b", "c"), ("alpha", "beta", "gamma")]
+assert coupling_groups("P -4 21 m", (0.1, 0.6, 0.3)).xyz.groups[0].relations_text() == "y = x + 1/2"
+p = lambda v, f=False: [v, f]
+phase = Phase[RefinableParameter].model_validate({{
+    "space_group": "P 63/m m c",
+    "unit_cell": {{"a": p(3.0, True), "b": p(3.0, True), "c": p(5.0), "alpha": p(90.0), "beta": p(90.0),
+                  "gamma": p(120.0)}},
+    "atoms": {{"C": {{"element": "C", "x": p(0.166667, True), "y": p(0.333333, True), "z": p(0.25),
+                     "occupancy": p(1.0), "ADP": "Uiso", "Uiso": p(0.01)}}}},
+}})
+assert phase.site("C").multiplicity == 6 and phase.warnings()
+
 recipes = {{
     "gsasii": json.loads(Path(r'{recipe_path}').read_text(encoding="utf-8")),
     "topas": json.loads(Path(r'{recipe_path}').read_text(encoding="utf-8")),
diff --git a/tests/test_schema_core.py b/tests/test_schema_core.py
index fa79315..17c2478 100644
--- a/tests/test_schema_core.py
+++ b/tests/test_schema_core.py
@@ -1618,3 +1618,360 @@ def test_integer_fields_reject_fractions_strings_and_booleans(bad, error_type):
 
 def test_integer_json_whole_float_accepted():
     assert Atom[RefinableParameter].model_validate_json(json.dumps(_atom(Multiplicity=4.0))).Multiplicity == 4
+
+
+# --- flag and bound rules F1-F4 (re/03b; A95, A98, A104, A106, A108) ---------
+
+_CELL_NAMES = ("a", "b", "c", "alpha", "beta", "gamma")
+_U_NAMES = ("U11", "U22", "U33", "U12", "U13", "U23")
+_N = [None, None]
+
+
+def _cellp(values, flags=(False,) * 6, bounds=None):
+    """unit_cell dict; with ``bounds`` (a dict of name -> (min, max), default open) 4-element lists."""
+    if bounds is None:
+        return {n: [v, f] for n, v, f in zip(_CELL_NAMES, values, flags)}
+    return {n: [v, f, *bounds.get(n, _N)] for n, v, f in zip(_CELL_NAMES, values, flags)}
+
+
+def _atomp(xyz, flags=(False,) * 3, bounds=None, uaniso=None, element="O"):
+    """atom dict; ``uaniso`` = {U: [value, flag(, min, max)]} switches ADP to Uaniso."""
+    tail = (lambda n: list(bounds.get(n, _N))) if bounds is not None else (lambda n: [])
+    d = {"element": element, **{k: [v, f, *tail(k)] for k, v, f in zip("xyz", xyz, flags)},
+         "occupancy": [1.0, False, *tail("occupancy")]}
+    if uaniso is None:
+        d.update(ADP="Uiso", Uiso=[0.01, False, *tail("Uiso")])
+    else:
+        d.update(ADP="Uaniso", Uaniso=uaniso)
+    return d
+
+
+def _phasep(space_group, cell, atoms):
+    return {"space_group": space_group, "unit_cell": cell, "atoms": atoms}
+
+
+def _errs(exc_info) -> list:
+    """(location, message without pydantic's prefix) of every error."""
+    return [(e["loc"], e["msg"].removeprefix("Value error, ")) for e in exc_info.value.errors()]
+
+
+_GENERAL = (0.1234, 0.2345, 0.3456)
+
+# (space group, cell values, members after the first of each tie group, fixed angles)
+_CELL_SYSTEMS = [
+    ("P m -3 m", (4, 4, 4, 90, 90, 90), ["b", "c"], ["alpha", "beta", "gamma"]),
+    ("P 4/m m m", (4, 4, 6, 90, 90, 90), ["b"], ["alpha", "beta", "gamma"]),
+    ("P 63/m m c", (3, 3, 5, 90, 90, 120), ["b"], ["alpha", "beta", "gamma"]),
+    ("R -3 m:H", (4, 4, 20, 90, 90, 120), ["b"], ["alpha", "beta", "gamma"]),
+    ("R -3 m:R", (5, 5, 5, 70, 70, 70), ["b", "c", "beta", "gamma"], []),
+    ("P m m m", (4, 5, 6, 90, 90, 90), [], ["alpha", "beta", "gamma"]),
+    ("C 1 2/m 1", (9, 5, 7, 90, 105, 90), [], ["alpha", "gamma"]),
+    ("P 1 c 1", (5, 6, 7, 90, 98, 90), [], ["alpha", "gamma"]),     # Pc, b-unique (A102)
+    ("P 1 1 m", (5, 6, 7, 90, 90, 98), [], ["alpha", "beta"]),      # Pm, c-unique
+    ("C m 1 1", (5, 6, 7, 98, 90, 90), [], ["beta", "gamma"]),      # Cm, a-unique
+    ("C 1 c 1", (5, 6, 7, 90, 98, 90), [], ["alpha", "gamma"]),     # Cc
+    ("P -1", (5, 6, 7, 80, 85, 95), [], []),
+]
+
+
+@pytest.mark.parametrize("sg, cell, _tied, fixed", _CELL_SYSTEMS, ids=[c[0] for c in _CELL_SYSTEMS])
+def test_cell_flags_consistent_accepted(sg, cell, _tied, fixed):
+    """Every free cell parameter refined, every fixed one not: valid in every crystal system."""
+    flags = tuple(n not in fixed for n in _CELL_NAMES)
+    Phase[RP].model_validate(_phasep(sg, _cellp(cell, flags), {"A": _atomp(_GENERAL)}))
+
+
+_CELL_SYSTEMS_WITH_RULES = [c for c in _CELL_SYSTEMS if c[2] or c[3]]  # P -1 has nothing to violate
+
+
+@pytest.mark.parametrize("sg, cell, tied, fixed", _CELL_SYSTEMS_WITH_RULES,
+                         ids=[c[0] for c in _CELL_SYSTEMS_WITH_RULES])
+def test_cell_flag_rules_f1_f2(sg, cell, tied, fixed):
+    """Only the first member of each tie group refined (F1) and every fixed angle refined (F2):
+    one error at each fixed angle, then one at every member whose flag differs (review N1)."""
+    flags = tuple(n not in tied for n in _CELL_NAMES)
+    with pytest.raises(ValidationError) as exc_info:
+        Phase[RP].model_validate(_phasep(sg, _cellp(cell, flags), {"A": _atomp(_GENERAL)}))
+    assert [loc for loc, _m in _errs(exc_info)] == [("unit_cell", n) for n in fixed + tied]
+
+
+def test_cell_flag_messages_name_the_group_and_the_fix():
+    d = _phasep("P m -3 m", _cellp((4, 4, 4, 90, 90, 90), (True, False, True, False, False, True)),
+                {"A": _atomp(_GENERAL)})
+    with pytest.raises(ValidationError) as exc_info:
+        Phase[RP].model_validate(d)
+    assert _errs(exc_info) == [
+        (("unit_cell", "gamma"), "cubic cell ('P m -3 m'): gamma is fixed by symmetry (= 90); "
+                                 "set its refine flag to false"),
+        (("unit_cell", "b"), "cubic cell ('P m -3 m'): a, b, c are one parameter; "
+                             "set the same refine flag on all three"),
+    ]
+
+
+def test_rhombohedral_cell_ties_lengths_and_angles():
+    d = _phasep("R -3 m:R", _cellp((5, 5, 5, 70, 70, 70), (False, False, False, True, True, False)),
+                {"A": _atomp(_GENERAL)})
+    with pytest.raises(ValidationError) as exc_info:
+        Phase[RP].model_validate(d)
+    assert _errs(exc_info) == [
+        (("unit_cell", "gamma"), "trigonal cell ('R -3 m:R'): alpha, beta, gamma are one parameter; "
+                                 "set the same refine flag on all three"),
+    ]
+
+
+def test_independent_groups_may_differ_f3():
+    """F3: orthorhombic a refined, b and c fixed; general-position x refined, y and z fixed."""
+    d = _phasep("P m m m", _cellp((4, 5, 6, 90, 90, 90), (True, False, False, False, False, False)),
+                {"A": _atomp(_GENERAL, (True, False, False))})
+    Phase[RP].model_validate(d)
+
+
+@pytest.mark.parametrize("sg, cell, xyz, flags, expected", [
+    ("P m -3 m", (4, 4, 4, 90, 90, 90), (0, 0, 0), (True, False, False),
+     [("x", "atom 'A' (multiplicity 1 in 'P m -3 m'): x is fixed by symmetry (= 0); "
+            "set its refine flag to false")]),
+    ("P 63/m m c", (3, 3, 5, 90, 90, 120), (1 / 3, 2 / 3, 0.25), (False, True, False),
+     [("y", "atom 'A' (multiplicity 2 in 'P 63/m m c'): y is fixed by symmetry (= 2/3); "
+            "set its refine flag to false")]),
+    ("P 63/m m c", (3, 3, 5, 90, 90, 120), (1 / 6, 1 / 3, 0.25), (True, False, False),
+     [("y", "atom 'A' (multiplicity 6 in 'P 63/m m c'): x, y are one parameter (y = 2x); "
+            "set the same refine flag on both")]),
+    ("P 63/m m c", (3, 3, 5, 90, 90, 120), (1 / 6, 1 / 3, 0.25), (True, True, True),
+     [("z", "atom 'A' (multiplicity 6 in 'P 63/m m c'): z is fixed by symmetry (= 1/4); "
+            "set its refine flag to false")]),
+    ("P -4 21 m", (5, 5, 4, 90, 90, 90), (0.1, 0.6, 0.3), (False, True, True),
+     [("y", "atom 'A' (multiplicity 4 in 'P -4 21 m'): x, y are one parameter (y = x + 1/2); "
+            "set the same refine flag on both")]),
+    ("R -3 m:R", (5, 5, 5, 70, 70, 70), (0.1, 0.1, 0.1), (True, False, True),
+     [("y", "atom 'A' (multiplicity 2 in 'R -3 m:R'): x, y, z are one parameter; "
+            "set the same refine flag on all three")]),
+    ("P 63/m m c", (3, 3, 5, 90, 90, 120), (1 / 6, 1 / 3, 0.25), (True, True, False), []),
+    ("P 1 c 1", (5, 6, 7, 90, 98, 90), _GENERAL, (True, True, True), []),
+])
+def test_site_coordinate_flag_rules(sg, cell, xyz, flags, expected):
+    d = _phasep(sg, _cellp(cell), {"A": _atomp(xyz, flags)})
+    if not expected:
+        Phase[RP].model_validate(d)
+        return
+    with pytest.raises(ValidationError) as exc_info:
+        Phase[RP].model_validate(d)
+    assert _errs(exc_info) == [(("atoms", "A", name), message) for name, message in expected]
+
+
+def _u(values, flags=(False,) * 6, bounds=None):
+    """Uaniso dict; with ``bounds`` (name -> (min, max), default open) 4-element lists."""
+    tail = (lambda n: list(bounds.get(n, _N))) if bounds is not None else (lambda n: [])
+    return {n: [v, f, *tail(n)] for n, v, f in zip(_U_NAMES, values, flags)}
+
+
+def test_uij_flag_rules_several_groups_at_one_site():
+    """6h in P6_3/mmc: U11 | U22=2*U12 | U33 free groups, U13 and U23 fixed (0)."""
+    values = (0.01, 0.012, 0.009, 0.006, 0.0, 0.0)
+    ok = _atomp((1 / 6, 1 / 3, 0.25), uaniso=_u(values, (True, True, False, True, False, False)), element="C")
+    Phase[RP].model_validate(_phasep("P 63/m m c", _cellp((3, 3, 5, 90, 90, 120)), {"C": ok}))
+    bad = _atomp((1 / 6, 1 / 3, 0.25), uaniso=_u(values, (False, True, False, False, True, False)), element="C")
+    with pytest.raises(ValidationError) as exc_info:
+        Phase[RP].model_validate(_phasep("P 63/m m c", _cellp((3, 3, 5, 90, 90, 120)), {"C": bad}))
+    context = "atom 'C' (multiplicity 6 in 'P 63/m m c')"
+    assert _errs(exc_info) == [
+        (("atoms", "C", "Uaniso", "U13"), f"{context}: U13 is fixed by symmetry (= 0); set its refine flag to false"),
+        (("atoms", "C", "Uaniso", "U12"), f"{context}: U22, U12 are one parameter (U12 = U22/2); "
+                                          "set the same refine flag on both"),
+    ]
+
+
+def test_uij_negative_relation_group():
+    """P-42_1m (0.1, 0.4, 0.3): U13 and U23 are one parameter with U23 = -U13."""
+    values = (0.01, 0.01, 0.012, 0.001, 0.002, -0.002)
+    a = _atomp((0.1, 0.4, 0.3), uaniso=_u(values, (False, False, False, False, True, False)))
+    with pytest.raises(ValidationError) as exc_info:
+        Phase[RP].model_validate(_phasep("P -4 21 m", _cellp((5, 5, 4, 90, 90, 90)), {"A": a}))
+    assert _errs(exc_info) == [
+        (("atoms", "A", "Uaniso", "U23"), "atom 'A' (multiplicity 4 in 'P -4 21 m'): U13, U23 are one "
+                                          "parameter (U23 = -U13); set the same refine flag on both"),
+    ]
+
+
+def test_co_located_atoms_are_independent():
+    """A104: atoms on the same site keep their own flags; nothing ties them."""
+    cell = _cellp((4, 5, 6, 90, 90, 90))
+    atoms = {"Li": _atomp(_GENERAL, (True, True, True), element="Li"),
+             "Mg": _atomp(_GENERAL, (False, False, False), element="Mg")}
+    phase = Phase[RP].model_validate(_phasep("P m m m", cell, atoms))
+    assert phase.atoms["Li"].x.refine_flag is True and phase.atoms["Mg"].x.refine_flag is False
+
+
+def test_flag_and_value_problems_reported_together():
+    """One ValidationError lists the cell, coordinate and Uij rule violations (A70)."""
+    cell = _cellp((3, 3, 5, 90, 90, 120), (True, False, False, False, False, False))
+    atoms = {"A": _atomp((1 / 3, 2 / 3, 0.25), (True, False, False)),
+             "B": _atomp((1 / 6, 1 / 3, 0.25), uaniso=_u((0.01, 0.012, 0.009, 0.006, 0, 0),
+                                                         (False, False, False, False, False, True))),
+             "C": _atomp(_GENERAL, element="Fe") | {"Multiplicity": 4}}
+    with pytest.raises(ValidationError) as exc_info:
+        Phase[RP].model_validate(_phasep("P 63/m m c", cell, atoms))
+    assert [loc for loc, _m in _errs(exc_info)] == [
+        ("unit_cell", "b"), ("atoms", "A", "x"), ("atoms", "B", "Uaniso", "U23"), ("atoms", "C", "Multiplicity")]
+
+
+# --- F4: bounds follow the tie (affine; A98, A108) and A106 -------------------
+
+_HEX = (3, 3, 5, 90, 90, 120)
+
+
+def _bounded_phase(sg, cell, xyz, flags, bounds, **kw):
+    return _phasep(sg, _cellp(cell, bounds={}), {"A": _atomp(xyz, flags, bounds=bounds, **kw)})
+
+
+@pytest.mark.parametrize("xyz, x_bounds, y_bounds", [
+    ((0.1, 0.6, 0.3), (0.0, 0.2), (0.5, 0.7)),        # y = x + 1/2
+    ((0.1, 0.4, 0.3), (0.0, 0.2), (0.3, 0.5)),        # y = -x + 1/2: swapped
+    ((0.1, -0.4, 0.3), (0.0, 0.2), (-0.5, -0.3)),     # y = x - 1/2: the stated translate counts
+    ((0.1, 0.4, 0.3), (0.0, None), (None, 0.5)),      # open ends map to the matching side
+    ((0.1, 0.4, 0.3), (None, 0.2), (0.3, None)),
+    ((0.1, 0.4, 0.3), (None, None), (None, None)),
+])
+def test_affine_bounds_follow_the_tie_p_421m_4e(xyz, x_bounds, y_bounds):
+    """Review B1: at P-42_1m 4e equal bounds would be wrong; the affine map is right."""
+    d = _bounded_phase("P -4 21 m", (5, 5, 4, 90, 90, 90), xyz, (True, True, False),
+                       {"x": x_bounds, "y": y_bounds})
+    phase = Phase[BRP].model_validate(d)
+    assert phase.atoms["A"].y.model_dump()[2:] == list(y_bounds)
+    assert phase.warnings() == []
+
+
+def test_affine_bounds_p42mnm_4f():
+    """P4_2/mnm (0.3, 0.7, 0): y = -x + 1; z fixed (A106: no bounds)."""
+    d = _bounded_phase("P 42/m n m", (5, 5, 3, 90, 90, 90), (0.3, 0.7, 0.0), (True, True, False),
+                       {"x": (0.25, 0.35), "y": (0.65, 0.75)})
+    Phase[BRP].model_validate(d)
+    d["atoms"]["A"]["y"][2:] = [0.25, 0.35]  # equal bounds: wrong for an affine tie
+    with pytest.raises(ValidationError) as exc_info:
+        Phase[BRP].model_validate(d)
+    assert _errs(exc_info) == [(("atoms", "A", "y"), "value (0.7) is above max (0.35)")]
+
+
+def test_bounds_not_following_the_tie_rejected_at_the_member():
+    d = _bounded_phase("P -4 21 m", (5, 5, 4, 90, 90, 90), (0.1, 0.4, 0.3), (True, True, False),
+                       {"x": (0.0, 0.2), "y": (0.3, 0.51)})
+    with pytest.raises(ValidationError) as exc_info:
+        Phase[BRP].model_validate(d)
+    assert _errs(exc_info) == [(("atoms", "A", "y"),
+                                "atom 'A' (multiplicity 4 in 'P -4 21 m'): the bounds of y must follow "
+                                "y = -x + 1/2 from the bounds of x [0, 0.2]: expected [0.3, 0.5], got [0.3, 0.51]")]
+
+
+def test_bounds_open_side_must_match():
+    d = _bounded_phase("P -4 21 m", (5, 5, 4, 90, 90, 90), (0.1, 0.4, 0.3), (True, True, False),
+                       {"x": (0.0, 0.2), "y": (None, 0.5)})
+    with pytest.raises(ValidationError) as exc_info:
+        Phase[BRP].model_validate(d)
+    assert _errs(exc_info)[0][1].endswith("expected [0.3, 0.5], got [null, 0.5]")
+
+
+def test_tied_coordinate_bounds_within_tolerance_snapped_and_reported():
+    """A108: within 5e-6 the member's bounds become the exact mapped values, with a warning."""
+    d = _bounded_phase("P -4 21 m", (5, 5, 4, 90, 90, 90), (0.1, 0.4, 0.3), (True, True, False),
+                       {"x": (0.0, 0.2), "y": (0.300004, 0.5)})
+    phase = Phase[BRP].model_validate(d)
+    assert phase.atoms["A"].y.model_dump() == [0.4, True, 0.3, 0.5]
+    assert phase.warnings() == [{
+        "code": "tied_bounds_adjusted",
+        "message": "atom 'A' (multiplicity 4 in 'P -4 21 m'): the bounds of y [0.300004, 0.5] were set to "
+                   "[0.3, 0.5], exactly y = -x + 1/2 from the bounds of x",
+        "field_path": "atoms.A.y"}]
+    d["atoms"]["A"]["y"][2] = 0.300006
+    with pytest.raises(ValidationError) as exc_info:
+        Phase[BRP].model_validate(d)
+    assert [loc for loc, _m in _errs(exc_info)] == [("atoms", "A", "y")]
+
+
+def test_tied_uij_bounds_factor_two():
+    """6h: U12 = U22/2, so U22 in [0, 0.02] gives U12 in [0, 0.01]; tolerance 1e-6 (A108)."""
+    values = (0.01, 0.012, 0.009, 0.006, 0.0, 0.0)
+    flags = (True, True, True, True, False, False)
+
+    def phase(u12_bounds):
+        bounds = {"U22": (0.0, 0.02), "U12": u12_bounds}
+        a = _atomp((1 / 6, 1 / 3, 0.25), bounds={}, uaniso=_u(values, flags, bounds), element="C")
+        return _phasep("P 63/m m c", _cellp(_HEX, bounds={}), {"C": a})
+
+    assert Phase[BRP].model_validate(phase((0.0, 0.01))).warnings() == []
+    snapped = Phase[BRP].model_validate(phase((0.0, 0.0100009)))
+    assert snapped.atoms["C"].Uaniso["U12"].model_dump() == [0.006, True, 0.0, 0.01]
+    assert [w["field_path"] for w in snapped.warnings()] == ["atoms.C.Uaniso.U12"]
+    with pytest.raises(ValidationError) as exc_info:
+        Phase[BRP].model_validate(phase((0.0, 0.0100011)))
+    assert _errs(exc_info) == [(("atoms", "C", "Uaniso", "U12"),
+                                "atom 'C' (multiplicity 6 in 'P 63/m m c'): the bounds of U12 must follow "
+                                "U12 = U22/2 from the bounds of U22 [0, 0.02]: expected [0, 0.01], "
+                                "got [0, 0.0100011]")]
+
+
+def test_tied_cell_bounds_equal_within_cell_tol():
+    """Cell ties are equalities; CELL_TOL is relative on lengths (A108, A77)."""
+    def phase(b_max):
+        cell = _cellp((4, 4, 4, 90, 90, 90), (True, True, True, False, False, False),
+                      {"a": (3.9, 4.2), "b": (3.9, b_max), "c": (3.9, 4.2)})
+        return _phasep("P m -3 m", cell, {"A": _atomp(_GENERAL, bounds={})})
+
+    snapped = Phase[BRP].model_validate(phase(4.2 + 1e-9))
+    assert snapped.unit_cell.b.model_dump() == [4.0, True, 3.9, 4.2]
+    assert [w["field_path"] for w in snapped.warnings()] == ["unit_cell.b"]
+    with pytest.raises(ValidationError) as exc_info:
+        Phase[BRP].model_validate(phase(4.2001))
+    assert _errs(exc_info) == [(("unit_cell", "b"),
+                                "cubic cell ('P m -3 m'): the bounds of b must follow b = a from the bounds "
+                                "of a [3.9, 4.2]: expected [3.9, 4.2], got [3.9, 4.2001]")]
+
+
+def test_symmetry_fixed_parameters_have_no_bounds_a106():
+    """A fixed parameter must have null bounds; a refine flag on it is F2 (two errors, one field)."""
+    cell = _cellp((4, 4, 4, 90, 90, 90), bounds={"alpha": (89.0, 91.0)})
+    atom = _atomp((0.0, 0.0, 0.0), (True, False, False), bounds={"x": (-0.1, 0.1)},
+                  uaniso=_u((0.01, 0.01, 0.01, 0.0, 0.0, 0.0), bounds={"U12": (None, 0.001)}), element="La")
+    with pytest.raises(ValidationError) as exc_info:
+        Phase[BRP].model_validate(_phasep("P m -3 m", cell, {"La": atom}))
+    context = "atom 'La' (multiplicity 1 in 'P m -3 m')"
+    assert _errs(exc_info) == [
+        (("unit_cell", "alpha"), "cubic cell ('P m -3 m'): alpha is fixed by symmetry (= 90); "
+                                 "give it no bounds (min and max null)"),
+        (("atoms", "La", "x"), f"{context}: x is fixed by symmetry (= 0); set its refine flag to false"),
+        (("atoms", "La", "x"), f"{context}: x is fixed by symmetry (= 0); give it no bounds (min and max null)"),
+        (("atoms", "La", "Uaniso", "U12"), f"{context}: U12 is fixed by symmetry (= 0); "
+                                           "give it no bounds (min and max null)"),
+    ]
+
+
+def test_canonical_value_rechecked_against_bounds_n4():
+    """Review N4: a stated value inside its bounds that canonicalizes outside them is an error.
+    6h (x, 2x, 1/4): y's bounds [0.199996, 0.4] are snapped to [0.2, 0.4] (A108); the least-change
+    canonical (x, y) of (0.1, 0.199996) is (0.0999984, 0.1999968), below both minima."""
+    d = _bounded_phase("P 63/m m c", _HEX, (0.1, 0.199996, 0.25), (True, True, False),
+                       {"x": (0.1, 0.2), "y": (0.199996, 0.4)})
+    with pytest.raises(ValidationError) as exc_info:
+        Phase[BRP].model_validate(d)
+    context = "atom 'A' (multiplicity 6 in 'P 63/m m c')"
+    assert _errs(exc_info) == [
+        (("atoms", "A", "x"), f"{context}: x = 0.0999984 (the exact special-position value of the stated 0.1) "
+                              "is below min (0.1)"),
+        (("atoms", "A", "y"), f"{context}: y = 0.1999968 (the exact special-position value of the stated "
+                              "0.199996) is below min (0.2)"),
+    ]
+
+
+def test_canonical_uij_rechecked_against_bounds_n4():
+    """N4 for A78: U12 stated just above U22/2 with U22 at its max: the least-change symmetric
+    values move both above their (snapped) maxima."""
+    bounds = {"U22": (0.0, 0.02), "U12": (0.0, 0.0100005)}
+    u = _u((0.01, 0.02, 0.009, 0.0100005, 0.0, 0.0), (False, True, False, True, False, False), bounds)
+    a = _atomp((1 / 6, 1 / 3, 0.25), bounds={}, uaniso=u, element="C")
+    with pytest.raises(ValidationError) as exc_info:
+        Phase[BRP].model_validate(_phasep("P 63/m m c", _cellp(_HEX, bounds={}), {"C": a}))
+    context = "atom 'C' (multiplicity 6 in 'P 63/m m c')"
+    assert _errs(exc_info) == [
+        (("atoms", "C", "Uaniso", "U22"), f"{context}: U22 = 0.020000200000000003 (the site-symmetric value "
+                                          "of the stated 0.02) is above max (0.02)"),
+        (("atoms", "C", "Uaniso", "U12"), f"{context}: U12 = 0.010000100000000001 (the site-symmetric value "
+                                          "of the stated 0.0100005) is above max (0.01)"),
+    ]

From ec261a86f56e57e33c44a32ea33209ebe2a9a810 Mon Sep 17 00:00:00 2001
From: acorrao <95718914+AdamCorrao@users.noreply.github.com>
Date: Wed, 7 Oct 2026 11:22:27 -0400
Subject: [PATCH 05/14] docs(schema): core 1.0.0 phase block, pre-release
 revision (re/03b)

SCHEMA_HISTORY's core 1.0.0 entry now describes the phase block that replaced
the structure-only draft before release (noted as a pre-release revision, not
a new version): one block keyed by the phase name, every structural quantity a
parameter, no null and no defaults, gemmi's canonical space-group name (A105),
and refinement intent that follows the symmetry (tied members share a flag;
fixed parameters have flag false and no bounds; bounds follow affine ties,
snapped within tolerance; co-located atoms independent).

Assisted-by: claude-code:claude-opus-5-5
---
 docs/SCHEMA_HISTORY.md | 74 +++++++++++++++++++++++++++++++++---------
 1 file changed, 58 insertions(+), 16 deletions(-)

diff --git a/docs/SCHEMA_HISTORY.md b/docs/SCHEMA_HISTORY.md
index 7f5f658..0a91824 100644
--- a/docs/SCHEMA_HISTORY.md
+++ b/docs/SCHEMA_HISTORY.md
@@ -22,6 +22,14 @@ version numbers (`powderline.support_matrix()` lists the declarations).
 Defined in `src/powderline/schema_core.py`. Not used by any gateway yet: the
 engine schemas adopt it in re/04–06.
 
+> **Pre-release revision (re/03b, not a new version).** Before its first
+> release, core 1.0.0 replaced its structure-only phase model (`PhaseStructure`
+> with plain values, plus `null`-valued "structure" parameters) with the
+> **phase block** described below: one block per phase, every structural
+> quantity a refinable parameter, flags and bounds checked against the symmetry,
+> and `space_group` in gemmi's canonical spelling. No recipe was ever written
+> against the earlier draft.
+
 - **Recipe frame** (`CoreRecipe`): `schema_name` (`"<engine>.<workflow>"`),
   `core_schema_version`, `engine_schema_version`, `metadata`, `payload` (typed
   by the engine schema). Unknown keys are errors at every level.
@@ -29,10 +37,10 @@ engine schemas adopt it in re/04–06.
   at most **1 MiB** as UTF-8 JSON. The cap is the constant
   `schema_core.METADATA_MAX_BYTES`; change it there and record the change here.
 - **Parameters**: `[value, refine_flag]` (no bounds) or
-  `[value, refine_flag, min, max]` (bounds the engine honors). A bounded list
-  where bounds aren't supported is an error. `refine_flag` is a JSON boolean.
-  `value` may be `null` (= start from the phase structure's value) only for
-  quantities that mirror a structure value.
+  `[value, refine_flag, min, max]` (bounds the engine honors; `min`/`max` may
+  be `null` = open). A bounded list where bounds aren't supported is an error.
+  `value` is always a number and `refine_flag` a JSON boolean; neither is ever
+  `null`.
 - **Data and ranges**: `xrd_data` (2θ in degrees, weights 1/σ², validated as in
   0.26.0); `fit_range` `[min, max]`, with `max > min`, inside the data's 2θ range.
 - **Background**: Chebyshev (`num_coefficients`, `coefficients`, `refine_flag`).
@@ -43,15 +51,30 @@ engine schemas adopt it in re/04–06.
   take a whole number (`4` or `4.0`), not `4.5`.
 - **Accepted core versions** (this release): `==1.0.0`.
 
-- **Phase structure** (`PhaseStructure`): `phase_name`, `space_group`,
-  `unit_cell`, `atoms` (keyed by label). Structural interpretation is checked
-  once, in core, so every engine gets the same structure. All structural
-  problems are reported together, each at its own field (`unit_cell`,
-  `atoms.<label>`, `atoms.<label>.Multiplicity`, `atoms.<label>.Uaniso`); they
-  are checked once the individual fields are valid:
-  - **Space group**: a Hermann–Mauguin symbol. Two-origin groups need an explicit
-    `:1`/`:2` and rhombohedral groups `:H`/`:R` (e.g. `"F d -3 m:2"`,
-    `"R -3 m:H"`). Individual engines may accept fewer settings.
+- **Phase block** (`Phase`): one block per phase, keyed by the phase name in
+  the engine payload's `phases` (no `phase_name` field). Core owns
+  `space_group`, `unit_cell` and `atoms`; each engine schema adds its own phase
+  fields next to them (e.g. gsasii `scale`, `peak_broadening`) and may not
+  redefine core's. Every structural quantity is a parameter (`[value, flag]`,
+  or `[value, flag, min, max]` in engines with bounds): cell `a`–`gamma`; atom
+  `x`, `y`, `z`, `occupancy`, `Uiso` or `U11`…`U23`. `element`, `ADP`,
+  `Multiplicity` and `space_group` are plain values. Nothing is `null` and
+  nothing has a default: `occupancy` must be stated; an optional field
+  (`Multiplicity`, the unused one of `Uiso`/`Uaniso`) is left out, not `null`.
+  Structural interpretation is checked once, in core, so every engine gets the
+  same structure. All problems are reported together, each at its own field
+  (`unit_cell`, `atoms.<label>` for the position, `atoms.<label>.Multiplicity`,
+  `atoms.<label>.Uaniso`, or the parameter a flag/bound rule concerns, e.g.
+  `unit_cell.b`, `atoms.<label>.y`, `atoms.<label>.Uaniso.U12`); they are checked
+  once the individual fields are valid:
+  - **Space group**: gemmi's canonical extended Hermann–Mauguin name, exactly:
+    `"P m -3 m"`, `"C 1 2/m 1"`, `"P 1 21/c 1"`, `"R -3 m:H"`, `"F d -3 m:2"`.
+    Every setting has exactly one such name, and it states the setting
+    (two-origin groups `:1`/`:2`, rhombohedral groups `:H`/`:R`, the monoclinic
+    unique axis). Any other spelling (`"Pm-3m"`, `"C2/m"`, `"p m -3 m"`) is an
+    error whose message gives the canonical name; a symbol without a setting
+    (`"R -3 m"`, `"F d -3 m"`) lists both choices. Each engine translates the
+    name to its own convention, and may accept fewer settings.
   - **Unit cell**: `a`, `b`, `c` (Å, > 0), `alpha`, `beta`, `gamma` (degrees,
     0–180). No `volume` (every engine derives it). The cell must fit the
     space group **exactly** (to floating-point precision): e.g. cubic
@@ -68,15 +91,34 @@ engine schemas adopt it in re/04–06.
     2e-3 from a special position is an **error** (`0.33`, `0.3333`, `0.33333`):
     state it to ≥ 6 decimals or move it off. Accepted special positions are
     replaced by their **exact** coordinates (fixed coordinates become the exact
-    fraction; coupled ones satisfy their relation, by the smallest change). Each
-    adjustment is reported as a structured warning, and these exact values are
-    what every engine receives.
+    fraction; coupled ones satisfy their relation, by the smallest change); the
+    refine flag and bounds are kept. Each adjustment is reported as a structured
+    warning, and these exact values are what every engine receives.
   - **Multiplicity**: optional; when stated it must equal the multiplicity
     derived from the space group.
   - **ADPs**: `ADP` is `"Uiso"` (with `Uiso`, Ų) or `"Uaniso"` (with all of
     `U11 U22 U33 U12 U13 U23`, Ų). Anisotropic ADPs must respect the site
     symmetry: within 1e-6 Ų they are set to the symmetric values and reported;
     beyond that it is an error.
+  - **Refinement intent follows the symmetry.** Parameters tied by symmetry
+    are **one** parameter, and every member is stated: cubic `a, b, c`;
+    tetragonal/hexagonal `a, b`; rhombohedral axes (`:R`) `a, b, c` and
+    `alpha, beta, gamma`; coordinates such as `(x, 2x, 1/4)` or
+    `(x, x + 1/2, z)`; Uij such as `U11 = U22`, `U12 = U22/2`, `U13 = -U23`.
+    - Tied members carry the **same refine flag**; the error is reported at
+      every member whose flag differs from the first member's.
+    - A parameter **fixed** by symmetry (a cubic angle, `x` of an atom at the
+      origin, `U12` on a mirror site) has refine flag `false` and, where the
+      engine has bounds, no bounds (`null`, `null`).
+    - Different groups are independent (orthorhombic `a` refined, `b` fixed).
+    - **Bounds** (engines with bounds) follow the tie like the values:
+      `y = k·x + c` maps x's `[min, max]` to `[k·min + c, k·max + c]`
+      (swapped for negative k; an open side stays open), e.g. `(x, x + 1/2, z)`
+      with x in `[0, 0.2]` needs y in `[0.5, 0.7]`. Bounds within the value
+      tolerance (coordinates 5e-6, Uij 1e-6 Ų, cell 1e-9 relative/degrees)
+      are set to the exact values and reported; beyond it is an error. A value
+      moved to its exact special position is re-checked against its bounds.
+    - Atoms at the same position are independent: their flags are never tied.
 
 ## gsasii engine schema
 

From 0eb3d31edac92f1bbd7e284a5c276c76bfff481d Mon Sep 17 00:00:00 2001
From: acorrao <95718914+AdamCorrao@users.noreply.github.com>
Date: Wed, 7 Oct 2026 12:29:07 -0400
Subject: [PATCH 06/14] fix(core): ADP selects a required thermal parameter,
 stated in the schema and errors at the field

Review follow-up to item 4 of the re/03b record. `Uiso`/`Uaniso` were never
optional in effect (ADP selects exactly one), but the JSON Schema listed
neither as required and the pairing errors were reported at the atom, not at
the field.

- `Uaniso` is now a `UanisoTensor[P]` model with all six of U11..U23
  required: a missing or unknown component is reported at it
  (`atoms.<label>.Uaniso.U23`). Same JSON shape as before.
- The ADP check reports a missing selected parameter as `missing` and the
  other one, if given, as `extra_forbidden`, each at its own field
  (`atoms.<label>.Uiso`), with a message naming the ADP choice.
- The Atom JSON Schema states the rule: if ADP is "Uiso", Uiso is required
  and Uaniso forbidden; if "Uaniso", the reverse.
- Multiplicity is unchanged: derived, so optional; never null.

Tests: the six test_atom_adp_* tests keep their IDs and now pin location,
error type and message; new tests for the location inside a phase and the
schema rule. SCHEMA_HISTORY updated.

Assisted-by: claude-code:claude-opus-5-5
---
 docs/SCHEMA_HISTORY.md        |  12 ++--
 src/powderline/schema_core.py |  82 +++++++++++++++++---------
 tests/test_schema_core.py     | 105 ++++++++++++++++++++++++----------
 3 files changed, 139 insertions(+), 60 deletions(-)

diff --git a/docs/SCHEMA_HISTORY.md b/docs/SCHEMA_HISTORY.md
index 0a91824..fd559a9 100644
--- a/docs/SCHEMA_HISTORY.md
+++ b/docs/SCHEMA_HISTORY.md
@@ -59,8 +59,8 @@ engine schemas adopt it in re/04–06.
   or `[value, flag, min, max]` in engines with bounds): cell `a`–`gamma`; atom
   `x`, `y`, `z`, `occupancy`, `Uiso` or `U11`…`U23`. `element`, `ADP`,
   `Multiplicity` and `space_group` are plain values. Nothing is `null` and
-  nothing has a default: `occupancy` must be stated; an optional field
-  (`Multiplicity`, the unused one of `Uiso`/`Uaniso`) is left out, not `null`.
+  nothing has a default: `occupancy` must be stated; `Multiplicity` (derived,
+  so optional) is left out when not stated, never `null`.
   Structural interpretation is checked once, in core, so every engine gets the
   same structure. All problems are reported together, each at its own field
   (`unit_cell`, `atoms.<label>` for the position, `atoms.<label>.Multiplicity`,
@@ -96,8 +96,12 @@ engine schemas adopt it in re/04–06.
     warning, and these exact values are what every engine receives.
   - **Multiplicity**: optional; when stated it must equal the multiplicity
     derived from the space group.
-  - **ADPs**: `ADP` is `"Uiso"` (with `Uiso`, Ų) or `"Uaniso"` (with all of
-    `U11 U22 U33 U12 U13 U23`, Ų). Anisotropic ADPs must respect the site
+  - **ADPs**: `ADP` selects the thermal parameter that is **required**:
+    `"Uiso"` requires `Uiso` (Ų); `"Uaniso"` requires `Uaniso` with all six of
+    `U11 U22 U33 U12 U13 U23` (Ų). The other one must be left out. A missing
+    or extra one is an error at that field (`atoms.<label>.Uiso`,
+    `atoms.<label>.Uaniso.U23`), and the JSON Schema states the same rule.
+    Anisotropic ADPs must respect the site
     symmetry: within 1e-6 Ų they are set to the symmetric values and reported;
     beyond that it is an error.
   - **Refinement intent follows the symmetry.** Parameters tied by symmetry
diff --git a/src/powderline/schema_core.py b/src/powderline/schema_core.py
index 3d13859..f9fc09f 100644
--- a/src/powderline/schema_core.py
+++ b/src/powderline/schema_core.py
@@ -573,6 +573,26 @@ def _angle(cls, v, info):
 _UANISO_KEYS = ("U11", "U22", "U33", "U12", "U13", "U23")
 
 
+class UanisoTensor(CoreModel, Generic[P]):
+    """Anisotropic ADPs: all six of U11, U22, U33, U12, U13, U23, each a parameter (A^2)."""
+
+    U11: P = Field(json_schema_extra=_unit(UNIT_ANGSTROM2))
+    U22: P = Field(json_schema_extra=_unit(UNIT_ANGSTROM2))
+    U33: P = Field(json_schema_extra=_unit(UNIT_ANGSTROM2))
+    U12: P = Field(json_schema_extra=_unit(UNIT_ANGSTROM2))
+    U13: P = Field(json_schema_extra=_unit(UNIT_ANGSTROM2))
+    U23: P = Field(json_schema_extra=_unit(UNIT_ANGSTROM2))
+
+
+#: JSON Schema of the ADP pairing (A96): ``ADP`` selects which one of ``Uiso`` /
+#: ``Uaniso`` is required; the other must be left out.
+_ADP_PAIRING_SCHEMA = {"allOf": [
+    {"if": {"properties": {"ADP": {"const": adp}}},
+     "then": {"required": [adp], "not": {"required": [other]}}}
+    for adp, other in (("Uiso", "Uaniso"), ("Uaniso", "Uiso"))
+]}
+
+
 class Atom(CoreModel, Generic[P]):
     """One atom of a phase: coordinates, occupancy and ADPs are refinable parameters.
 
@@ -580,12 +600,16 @@ class Atom(CoreModel, Generic[P]):
     stating it to at least 6 decimals; the validated phase holds the canonical
     (exact) values and reports every adjustment (A73). ``occupancy`` is required
     and 0 to 1 inclusive (A76, A96). ``Multiplicity`` is optional and, when
-    stated, must match the derived value (A69 T3). ``ADP`` selects ``Uiso`` or
-    ``Uaniso`` (all six of U11..U23); the other is left out. ``Uaniso`` must
-    respect the site symmetry: within 1e-6 A^2 it is set to the symmetric values
-    and reported, beyond that it is an error (A78). Nothing is ``null`` (A96).
+    stated, must match the derived value (A69 T3). ``ADP`` selects which
+    thermal parameter is **required**: ``Uiso``, or ``Uaniso`` with all six of
+    U11..U23; the other must be left out (an error at that field otherwise, and
+    the JSON Schema states the rule). ``Uaniso`` must respect the site symmetry:
+    within 1e-6 A^2 it is set to the symmetric values and reported, beyond that
+    it is an error (A78). Nothing is ``null`` (A96).
     """
 
+    model_config = ConfigDict(extra="forbid", json_schema_extra=_ADP_PAIRING_SCHEMA)
+
     element: str = Field(description="Bare element symbol, exactly as in the periodic table (e.g. 'Fe')")
     x: P = Field(description="Fractional x coordinate")
     y: P = Field(description="Fractional y coordinate")
@@ -595,10 +619,10 @@ class Atom(CoreModel, Generic[P]):
                                             description="Site multiplicity; optional, cross-checked when stated")
     ADP: Literal["Uiso", "Uaniso"] = Field(description="Displacement-parameter type")
     Uiso: Optional[P] = Field(default=None, json_schema_extra=_absent_not_null_schema(UNIT_ANGSTROM2),
-                              description="Isotropic ADP; given when ADP is 'Uiso'")
-    Uaniso: Optional[dict[Literal["U11", "U22", "U33", "U12", "U13", "U23"], P]] = Field(
-        default=None, json_schema_extra=_absent_not_null_schema(UNIT_ANGSTROM2),
-        description="All six of U11, U22, U33, U12, U13, U23; given when ADP is 'Uaniso'")
+                              description="Isotropic ADP; required when ADP is 'Uiso', else left out")
+    Uaniso: Optional[UanisoTensor[P]] = Field(
+        default=None, json_schema_extra=_absent_not_null_schema(),
+        description="All six of U11, U22, U33, U12, U13, U23; required when ADP is 'Uaniso', else left out")
 
     _not_null = field_validator("Multiplicity", "Uiso", "Uaniso", mode="before")(_absent_not_null)
 
@@ -625,16 +649,21 @@ def _omit_absent(self, handler):
 
     @model_validator(mode="after")
     def _adp_block(self) -> "Atom":
-        if self.ADP == "Uiso":
-            if self.Uiso is None:
-                raise ValueError("ADP 'Uiso' requires a Uiso value")
-            if self.Uaniso is not None:
-                raise ValueError("ADP 'Uiso' must not also give Uaniso")
-        else:
-            if self.Uaniso is None or set(self.Uaniso) != set(_UANISO_KEYS):
-                raise ValueError(f"ADP 'Uaniso' requires all of {', '.join(_UANISO_KEYS)}")
-            if self.Uiso is not None:
-                raise ValueError("ADP 'Uaniso' must not also give Uiso")
+        """``ADP`` selects the required thermal parameter; errors at the field concerned."""
+        required, other = ("Uiso", "Uaniso") if self.ADP == "Uiso" else ("Uaniso", "Uiso")
+        problems = []
+        if getattr(self, required) is None:
+            problems.append(InitErrorDetails(
+                type=PydanticCustomError("missing", "{field} is required when ADP is '{adp}'",
+                                         {"field": required, "adp": self.ADP}),
+                loc=(required,), input=None))
+        if getattr(self, other) is not None:
+            problems.append(InitErrorDetails(
+                type=PydanticCustomError("extra_forbidden", "{field} must be left out when ADP is '{adp}'",
+                                         {"field": other, "adp": self.ADP}),
+                loc=(other,), input=getattr(self, other).model_dump()))
+        if problems:
+            raise ValidationError.from_exception_data(type(self).__name__, problems)
         return self
 
 
@@ -757,7 +786,7 @@ def apply_tie_rules(loc: tuple, params: dict, ties: Ties, context: str, toleranc
                         f"({sg!r}, site {site.stated})", atom.Multiplicity)
             uaniso_ok = u_adjusted = False
             if atom.Uaniso is not None:
-                stated_u = tuple(atom.Uaniso[k].value for k in _UANISO_KEYS)
+                stated_u = tuple(getattr(atom.Uaniso, k).value for k in _UANISO_KEYS)
                 try:
                     symmetric_u, u_adjusted = check_uij(sg, site.canonical, stated_u)
                 except SymmetryError as exc:
@@ -765,8 +794,8 @@ def apply_tie_rules(loc: tuple, params: dict, ties: Ties, context: str, toleranc
                 else:
                     uaniso_ok = True
                     if u_adjusted:
-                        update["Uaniso"] = {k: _with_value(atom.Uaniso[k], u)
-                                            for k, u in zip(_UANISO_KEYS, symmetric_u)}
+                        update["Uaniso"] = atom.Uaniso.model_copy(update={
+                            k: _with_value(getattr(atom.Uaniso, k), u) for k, u in zip(_UANISO_KEYS, symmetric_u)})
                         self._warnings.append(StructuredWarning(
                             code="adp_symmetry_adjusted",
                             message=(f"atom {label!r}: Uaniso {dict(zip(_UANISO_KEYS, stated_u))} "
@@ -793,16 +822,17 @@ def apply_tie_rules(loc: tuple, params: dict, ties: Ties, context: str, toleranc
                                           lambda _name, _expected: SPECIAL_POSITION_TOL,
                                           lambda name: str(site.exact["xyz".index(name)])))
             if uaniso_ok:
-                uij = dict(update.get("Uaniso", atom.Uaniso))
-                uij.update(apply_tie_rules(("atoms", label, "Uaniso"), uij, ties.uij, context,
-                                           lambda _name, _expected: UIJ_TOL, lambda _name: "0"))
-                update["Uaniso"] = uij
+                uaniso = update.get("Uaniso", atom.Uaniso)
+                bounds = apply_tie_rules(("atoms", label, "Uaniso"), {k: getattr(uaniso, k) for k in _UANISO_KEYS},
+                                         ties.uij, context, lambda _name, _expected: UIJ_TOL, lambda _name: "0")
+                if bounds:
+                    update["Uaniso"] = uaniso.model_copy(update=bounds)
 
             # Review N4: a value moved by canonicalization is re-checked against its (final) bounds.
             moved = [(("atoms", label, k), k, update.get(k, getattr(atom, k)), getattr(atom, k).value,
                       "the exact special-position value") for k in "xyz" if site.adjusted]
             if u_adjusted and uaniso_ok:
-                moved += [(("atoms", label, "Uaniso", k), k, update["Uaniso"][k], atom.Uaniso[k].value,
+                moved += [(("atoms", label, "Uaniso", k), k, getattr(update["Uaniso"], k), getattr(atom.Uaniso, k).value,
                            "the site-symmetric value") for k in _UANISO_KEYS]
             for loc, name, param, stated, what in moved:
                 message = _canonical_out_of_bounds(param)
diff --git a/tests/test_schema_core.py b/tests/test_schema_core.py
index 17c2478..dfaa68e 100644
--- a/tests/test_schema_core.py
+++ b/tests/test_schema_core.py
@@ -945,44 +945,89 @@ def test_atom_occupancy_above_one_rejected():
         Atom[RefinableParameter](element="Fe", x=[0.0, False], y=[0.0, False], z=[0.0, False], occupancy=[1.01, False], ADP="Uiso", Uiso=[0.01, False])
 
 
+_U6 = {"U11": [0.01, False], "U22": [0.01, False], "U33": [0.01, False],
+       "U12": [0.0, False], "U13": [0.0, False], "U23": [0.0, False]}
+
+
+def _adp_atom(**adp):
+    return {"element": "Fe", "x": [0.0, False], "y": [0.0, False], "z": [0.0, False],
+            "occupancy": [1.0, False], **adp}
+
+
+def _adp_errors(exc_info) -> list:
+    return [(e["loc"], e["type"], e["msg"]) for e in exc_info.value.errors()]
+
+
 def test_atom_adp_uiso_without_value_rejected():
-    """Atom: ADP='Uiso' without Uiso rejected."""
-    with pytest.raises(ValidationError, match="requires a Uiso value"):
-        Atom[RefinableParameter](element="Fe", x=[0.0, False], y=[0.0, False], z=[0.0, False], occupancy=[1.0, False], ADP="Uiso")
+    """ADP selects the required thermal parameter: 'Uiso' without Uiso is missing at Uiso."""
+    with pytest.raises(ValidationError) as exc_info:
+        Atom[RefinableParameter].model_validate(_adp_atom(ADP="Uiso"))
+    assert _adp_errors(exc_info) == [(("Uiso",), "missing", "Uiso is required when ADP is 'Uiso'")]
 
 
 def test_atom_adp_uiso_with_uaniso_rejected():
-    """Atom: ADP='Uiso' with Uaniso also given rejected."""
-    with pytest.raises(ValidationError, match="must not also give Uaniso"):
-        Atom[RefinableParameter](element="Fe", x=[0.0, False], y=[0.0, False], z=[0.0, False], occupancy=[1.0, False], ADP="Uiso", Uiso=[0.01, False],
-             Uaniso={"U11": [0.01, False], "U22": [0.01, False], "U33": [0.01, False], "U12": [0, False], "U13": [0, False], "U23": [0, False]})
+    """ADP 'Uiso': Uaniso must be left out (error at Uaniso)."""
+    with pytest.raises(ValidationError) as exc_info:
+        Atom[RefinableParameter].model_validate(_adp_atom(ADP="Uiso", Uiso=[0.01, False], Uaniso=_U6))
+    assert _adp_errors(exc_info) == [
+        (("Uaniso",), "extra_forbidden", "Uaniso must be left out when ADP is 'Uiso'")]
 
 
 def test_atom_adp_uaniso_missing_component_rejected():
-    """Atom: ADP='Uaniso' missing U23 rejected."""
-    with pytest.raises(ValidationError, match="requires all of U11"):
-        Atom[RefinableParameter](element="Fe", x=[0.0, False], y=[0.0, False], z=[0.0, False], occupancy=[1.0, False], ADP="Uaniso",
-             Uaniso={"U11": [0.01, False], "U22": [0.01, False], "U33": [0.01, False], "U12": [0, False], "U13": [0, False]})
+    """ADP 'Uaniso' needs all six components; a missing one is reported at that component."""
+    u = {k: v for k, v in _U6.items() if k != "U23"}
+    with pytest.raises(ValidationError) as exc_info:
+        Atom[RefinableParameter].model_validate(_adp_atom(ADP="Uaniso", Uaniso=u))
+    assert _adp_errors(exc_info) == [(("Uaniso", "U23"), "missing", "Field required")]
 
 
 def test_atom_adp_uaniso_unknown_key_rejected():
-    """Atom: ADP='Uaniso' with U14 rejected."""
-    with pytest.raises(ValidationError, match="Input should be"):
-        Atom[RefinableParameter](element="Fe", x=[0.0, False], y=[0.0, False], z=[0.0, False], occupancy=[1.0, False], ADP="Uaniso",
-             Uaniso={"U11": [0.01, False], "U22": [0.01, False], "U33": [0.01, False], "U12": [0, False], "U13": [0, False], "U23": [0, False], "U14": [0, False]})
+    """ADP 'Uaniso' with U14: an unknown component, reported at it."""
+    with pytest.raises(ValidationError) as exc_info:
+        Atom[RefinableParameter].model_validate(_adp_atom(ADP="Uaniso", Uaniso={**_U6, "U14": [0.0, False]}))
+    assert _adp_errors(exc_info) == [(("Uaniso", "U14"), "extra_forbidden", "Extra inputs are not permitted")]
 
 
 def test_atom_adp_uaniso_with_uiso_rejected():
-    """Atom: ADP='Uaniso' with Uiso also given rejected."""
-    with pytest.raises(ValidationError, match="must not also give Uiso"):
-        Atom[RefinableParameter](element="Fe", x=[0.0, False], y=[0.0, False], z=[0.0, False], occupancy=[1.0, False], ADP="Uaniso", Uiso=[0.01, False],
-             Uaniso={"U11": [0.01, False], "U22": [0.01, False], "U33": [0.01, False], "U12": [0, False], "U13": [0, False], "U23": [0, False]})
+    """ADP 'Uaniso': Uiso must be left out (error at Uiso)."""
+    with pytest.raises(ValidationError) as exc_info:
+        Atom[RefinableParameter].model_validate(_adp_atom(ADP="Uaniso", Uiso=[0.01, False], Uaniso=_U6))
+    assert _adp_errors(exc_info) == [
+        (("Uiso",), "extra_forbidden", "Uiso must be left out when ADP is 'Uaniso'")]
 
 
 def test_atom_adp_wrong_value_rejected():
-    """Atom: ADP='Uaniso' but only Uiso given rejected."""
-    with pytest.raises(ValidationError, match="requires all of U11"):
-        Atom[RefinableParameter](element="Fe", x=[0.0, False], y=[0.0, False], z=[0.0, False], occupancy=[1.0, False], ADP="Uaniso", Uiso=[0.01, False])
+    """ADP 'Uaniso' but only Uiso given: Uaniso missing and Uiso not allowed, both reported."""
+    with pytest.raises(ValidationError) as exc_info:
+        Atom[RefinableParameter].model_validate(_adp_atom(ADP="Uaniso", Uiso=[0.01, False]))
+    assert _adp_errors(exc_info) == [
+        (("Uaniso",), "missing", "Uaniso is required when ADP is 'Uaniso'"),
+        (("Uiso",), "extra_forbidden", "Uiso must be left out when ADP is 'Uaniso'"),
+    ]
+
+
+def test_atom_adp_errors_located_inside_the_phase():
+    """Nested in a phase, the ADP pairing error is at atoms.<label>.<field> (A70)."""
+    d = _valid_pmm_lab6_phase_dict()
+    del d["atoms"]["La1"]["Uiso"]
+    with pytest.raises(ValidationError) as exc_info:
+        Phase[RefinableParameter].model_validate(d)
+    assert _adp_errors(exc_info) == [(("atoms", "La1", "Uiso"), "missing", "Uiso is required when ADP is 'Uiso'")]
+
+
+def test_atom_json_schema_states_the_adp_pairing():
+    """The JSON Schema says ADP selects the required one of Uiso / Uaniso and forbids the other;
+    UanisoTensor requires all six components."""
+    schema = Phase[RefinableParameter].model_json_schema()["$defs"]
+    assert schema["Atom"]["allOf"] == [
+        {"if": {"properties": {"ADP": {"const": "Uiso"}}},
+         "then": {"required": ["Uiso"], "not": {"required": ["Uaniso"]}}},
+        {"if": {"properties": {"ADP": {"const": "Uaniso"}}},
+         "then": {"required": ["Uaniso"], "not": {"required": ["Uiso"]}}},
+    ]
+    assert schema["Atom"]["properties"]["Uaniso"]["$ref"] == "#/$defs/UanisoTensor"
+    assert schema["UanisoTensor"]["required"] == ["U11", "U22", "U33", "U12", "U13", "U23"]
+    assert schema["UanisoTensor"]["additionalProperties"] is False
 
 
 def test_atom_xyz_non_finite_rejected():
@@ -1197,14 +1242,14 @@ def test_phase_uaniso_hexagonal_6h_adjusted():
     }
     phase = Phase[RefinableParameter].model_validate(d)
     # Check U11 stayed (now need to read .value)
-    assert phase.atoms["A1"].Uaniso["U11"].value == 0.012  # free: returned exactly as stated
+    assert phase.atoms["A1"].Uaniso.U11.value == 0.012  # free: returned exactly as stated
     # Check U12 became U22/2 (reading .value)
-    u22 = phase.atoms["A1"].Uaniso["U22"].value
-    u12 = phase.atoms["A1"].Uaniso["U12"].value
+    u22 = phase.atoms["A1"].Uaniso.U22.value
+    u12 = phase.atoms["A1"].Uaniso.U12.value
     assert abs(u12 - u22 / 2) < 1e-15
     # Check refine flags are preserved
-    assert phase.atoms["A1"].Uaniso["U11"].refine_flag is False
-    assert phase.atoms["A1"].Uaniso["U12"].refine_flag is False
+    assert phase.atoms["A1"].Uaniso.U11.refine_flag is False
+    assert phase.atoms["A1"].Uaniso.U12.refine_flag is False
     # Check warning
     warnings = phase.warnings()
     assert any(w["code"] == "adp_symmetry_adjusted" for w in warnings)
@@ -1462,11 +1507,11 @@ class EnginePhase(Phase[RP]):
         scale: RP
 
     schema = EnginePhase.model_json_schema()
-    assert sorted(schema["$defs"]) == ["Atom", "RefinableParameter", "UnitCell"]
+    assert sorted(schema["$defs"]) == ["Atom", "RefinableParameter", "UanisoTensor", "UnitCell"]
     atom = schema["$defs"]["Atom"]
     assert atom["required"] == ["element", "x", "y", "z", "occupancy", "ADP"]
     assert atom["properties"]["Uiso"] == {"$ref": "#/$defs/RefinableParameter", "unit": "angstrom^2",
-                                          "description": "Isotropic ADP; given when ADP is 'Uiso'"}
+                                          "description": "Isotropic ADP; required when ADP is 'Uiso', else left out"}
     assert atom["properties"]["Multiplicity"]["type"] == "integer"
     assert "null" not in json.dumps(schema)
     assert schema["$defs"]["RefinableParameter"]["prefixItems"] == [{"type": "number"}, {"type": "boolean"}]
@@ -1898,7 +1943,7 @@ def phase(u12_bounds):
 
     assert Phase[BRP].model_validate(phase((0.0, 0.01))).warnings() == []
     snapped = Phase[BRP].model_validate(phase((0.0, 0.0100009)))
-    assert snapped.atoms["C"].Uaniso["U12"].model_dump() == [0.006, True, 0.0, 0.01]
+    assert snapped.atoms["C"].Uaniso.U12.model_dump() == [0.006, True, 0.0, 0.01]
     assert [w["field_path"] for w in snapped.warnings()] == ["atoms.C.Uaniso.U12"]
     with pytest.raises(ValidationError) as exc_info:
         Phase[BRP].model_validate(phase((0.0, 0.0100011)))

From 8bd674af0cb6cf80a45f6f334bac8bcdf0191363 Mon Sep 17 00:00:00 2001
From: acorrao <95718914+AdamCorrao@users.noreply.github.com>
Date: Wed, 7 Oct 2026 15:03:54 -0400
Subject: [PATCH 07/14] build: pin gemmi exactly (==0.7.5)

Core's space-group contract is gemmi's canonical names (A105), and the
symmetry rules (special positions, tie groups, unique axis) are characterized
against this gemmi version. A gemmi release that renames a symbol or changes
an operation would change which recipes are valid, so gemmi is widened only
deliberately, after the symmetry tests and the committed name list
(tests/data/canonical_space_groups.txt, next commit) are re-checked.

pixi.lock: only powderline's own requires_dist copy changes (gemmi 0.7.5 was
already the locked build); `pixi lock --check` reports it up to date.

Re/03b review B4.

Assisted-by: claude-code:claude-opus-5-5
---
 pixi.lock      | 2 +-
 pixi.toml      | 6 +++++-
 pyproject.toml | 2 +-
 3 files changed, 7 insertions(+), 3 deletions(-)

diff --git a/pixi.lock b/pixi.lock
index b51a946..0dd2960 100644
--- a/pixi.lock
+++ b/pixi.lock
@@ -17362,7 +17362,7 @@ packages:
   name: powderline
   requires_dist:
   - fastapi>=0.115
-  - gemmi>=0.7,<0.8
+  - gemmi==0.7.5
   - h5py>=3.12
   - httpx>=0.28
   - numpy>=2.0
diff --git a/pixi.toml b/pixi.toml
index 834faf8..b1839b2 100644
--- a/pixi.toml
+++ b/pixi.toml
@@ -58,7 +58,11 @@ emmet-core = ">=0.87.1,<0.88"
 fastapi = ">=0.115.0,<1"
 uvicorn = ">=0.34.0,<1"
 httpx = ">=0.28.0,<1"
-gemmi = ">=0.7.5,<0.8"
+# gemmi is pinned exactly: core's space-group contract is its canonical names
+# (A105, tests/data/canonical_space_groups.txt) and the symmetry rules are
+# characterized against this version. Widen only after re-running the symmetry
+# tests and updating that file (re/03b review B4).
+gemmi = "==0.7.5"
 packaging = ">=22"
 # GSAS-II is built as a conda package via pixi-build (see `preview` above) from
 # the tacaswell fork, which adds the conda recipe. This installs GSAS-II on ALL
diff --git a/pyproject.toml b/pyproject.toml
index b0fc914..fbfc1ae 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -51,7 +51,7 @@ dependencies = [
     "fastapi>=0.115",
     "uvicorn>=0.34",
     "httpx>=0.28",
-    "gemmi>=0.7,<0.8",
+    "gemmi==0.7.5",  # exact: the space-group names and symmetry rules depend on it (pixi.toml)
     "packaging>=22",
 ]
 

From 6afa7e2f139214a5f605e3b0bc70912adbbe6333 Mon Sep 17 00:00:00 2001
From: acorrao <95718914+AdamCorrao@users.noreply.github.com>
Date: Wed, 7 Oct 2026 15:03:55 -0400
Subject: [PATCH 08/14] fix(core): guard engine phase subclasses; name rule;
 cell-bound domain; monoclinic symbols

Follow-ups from the independent re/03b review (maintainer answers 2026-10-07).

- Engine subclasses of Phase may not reuse a core validator, private
  attribute or method name (_space_group, _sites_check, _sites, _warnings,
  site, warnings). pydantic collects validators by name, so a same-named
  engine validator silently replaced core's: e.g. a gsasii `_space_group`
  check let "Pm-3m" through, and overriding `_sites_check` dropped every
  symmetry, flag and bound rule. A subclass must also keep extra='forbid'
  (A19). Both raise TypeError when the subclass is defined. (Review A1.)
- Atom labels (and, through the exported CoreName, engine phase names) follow
  one rule every engine can use: an ASCII letter, then ASCII letters, digits
  or '_'. Evidence: GSAS-II renames a phase with surrounding spaces or
  non-ASCII characters and the parameterization then skips it silently;
  easydiffraction rejects any other atom label; TOPAS writes the names into
  its input; phase names become report file names; field paths are
  '.'-joined. check_names_unique_ignoring_case() is for engine payloads'
  phase names (case-insensitive file systems). JSON Schema states the rule
  as propertyNames. (Review C6.)
- In engines with bounds, a stated cell bound must lie where the parameter
  exists: a length's min > 0, an angle's min/max strictly between 0 and 180;
  null still means no bound. (Review C5.)
- A short monoclinic symbol ("P21/c", "C2/m") states neither the unique axis
  nor the cell choice; the error now lists every setting of that space group
  by unique axis instead of suggesting gemmi's silent pick. (Review B3.)
- tests/data/canonical_space_groups.txt pins gemmi's 564 canonical names; a
  test fails if the installed gemmi differs. (Review B4.)
- SCHEMA_HISTORY: the name rule, the bound domain, the monoclinic message and
  the pinned name list.

Suite (default env): see the devkit record.

Assisted-by: claude-code:claude-opus-5-5
---
 docs/SCHEMA_HISTORY.md                |  22 +-
 src/powderline/schema_core.py         | 107 ++++-
 src/powderline/symmetry.py            |  17 +-
 tests/data/canonical_space_groups.txt | 564 ++++++++++++++++++++++++++
 tests/test_schema_core.py             | 162 +++++++-
 5 files changed, 860 insertions(+), 12 deletions(-)
 create mode 100644 tests/data/canonical_space_groups.txt

diff --git a/docs/SCHEMA_HISTORY.md b/docs/SCHEMA_HISTORY.md
index fd559a9..99a23b8 100644
--- a/docs/SCHEMA_HISTORY.md
+++ b/docs/SCHEMA_HISTORY.md
@@ -61,6 +61,15 @@ engine schemas adopt it in re/04–06.
   `Multiplicity` and `space_group` are plain values. Nothing is `null` and
   nothing has a default: `occupancy` must be stated; `Multiplicity` (derived,
   so optional) is left out when not stated, never `null`.
+  **Names:** atom labels (the `atoms` keys) and phase names (the engine
+  payload's `phases` keys) start with a letter and contain only ASCII letters,
+  digits and `_` (`O1`, `LaB6_a`); phase names must also differ by more than
+  case. This is the form every engine can use as-is: GSAS-II renames a phase
+  with surrounding spaces or non-ASCII characters (and its settings were then
+  skipped), easydiffraction accepts no other atom label, TOPAS writes the names
+  into its input file, phase names become report file names (which ignore case
+  on Windows and macOS), and problems are reported at `.`-joined paths
+  (`atoms.O1.Uiso`). So `"2H-MoS2"` is written e.g. `MoS2_2H`.
   Structural interpretation is checked once, in core, so every engine gets the
   same structure. All problems are reported together, each at its own field
   (`unit_cell`, `atoms.<label>` for the position, `atoms.<label>.Multiplicity`,
@@ -73,10 +82,17 @@ engine schemas adopt it in re/04–06.
     (two-origin groups `:1`/`:2`, rhombohedral groups `:H`/`:R`, the monoclinic
     unique axis). Any other spelling (`"Pm-3m"`, `"C2/m"`, `"p m -3 m"`) is an
     error whose message gives the canonical name; a symbol without a setting
-    (`"R -3 m"`, `"F d -3 m"`) lists both choices. Each engine translates the
-    name to its own convention, and may accept fewer settings.
+    (`"R -3 m"`, `"F d -3 m"`) lists both choices, and a short monoclinic
+    symbol (`"P21/c"`, `"C2/m"`) lists every setting of that space group by
+    unique axis, because it states neither the unique axis nor the cell choice.
+    Each engine translates the name to its own convention, and may accept fewer
+    settings. The accepted names are those of gemmi 0.7.5, which PowderLine pins
+    exactly; the list is `tests/data/canonical_space_groups.txt`, and any change
+    to it is recorded here.
   - **Unit cell**: `a`, `b`, `c` (Å, > 0), `alpha`, `beta`, `gamma` (degrees,
-    0–180). No `volume` (every engine derives it). The cell must fit the
+    0–180). In engines with bounds, a stated bound must lie in the same range
+    (a length's `min` > 0; an angle's `min`/`max` strictly between 0 and 180);
+    `null` means no bound. No `volume` (every engine derives it). The cell must fit the
     space group **exactly** (to floating-point precision): e.g. cubic
     `a = b = c` and all angles 90°. A mismatch is an error naming each
     parameter and its symmetric value. (GSAS-II alone would silently apply the
diff --git a/src/powderline/schema_core.py b/src/powderline/schema_core.py
index f9fc09f..ecca576 100644
--- a/src/powderline/schema_core.py
+++ b/src/powderline/schema_core.py
@@ -32,6 +32,7 @@
 from packaging.specifiers import SpecifierSet
 from packaging.version import InvalidVersion, Version
 from pydantic import (
+    AfterValidator,
     BaseModel,
     BeforeValidator,
     ConfigDict,
@@ -40,6 +41,7 @@
     Strict,
     StrictBool,
     ValidationError,
+    WithJsonSchema,
     field_validator,
     model_serializer,
     model_validator,
@@ -179,6 +181,64 @@ def _integer_not_text_or_bool(v: Any) -> Any:
 CoreInt = Annotated[int, BeforeValidator(_integer_not_text_or_bool)]
 
 
+# --- names ------------------------------------------------------------------
+
+#: A phase name or atom label: an ASCII letter, then ASCII letters, digits or ``_``.
+NAME_PATTERN = r"^[A-Za-z][A-Za-z0-9_]*$"
+
+
+def _check_name(name: str) -> str:
+    """The name rule every engine can honor (re/03b review C6).
+
+    - GSAS-II renames a phase whose name has surrounding spaces or non-ASCII
+      characters, and the parameterization then skips that phase silently.
+    - easydiffraction accepts atom labels only of the form ``[A-Za-z_][A-Za-z0-9_]*``.
+    - TOPAS emits phase names inside quotes and builds parameter names from them.
+    - Phase names become report file names (``<phase>_unit_cell_report.csv``),
+      so ``/``, ``:`` and the like must not appear.
+    - Field paths are joined with ``.`` (``atoms.O1.Uiso``).
+    """
+    if not name.strip():
+        raise ValueError("a name must not be empty or blank")
+    if re.fullmatch(NAME_PATTERN, name) is None:
+        raise ValueError(f"name {name!r} must start with a letter and contain only ASCII letters, digits "
+                         "and '_' (e.g. 'O1', 'LaB6_a')")
+    return name
+
+
+#: A phase name or an atom label (a dict key), see :data:`NAME_PATTERN`. Core uses
+#: it for the atom labels; engine schemas use it for their ``phases`` keys (with
+#: :func:`name_keyed`, and :func:`check_names_unique_ignoring_case` for phases).
+CoreName = Annotated[str, AfterValidator(_check_name), WithJsonSchema({"type": "string", "pattern": NAME_PATTERN})]
+
+
+def check_names_unique_ignoring_case(names, what: str) -> None:
+    """Raise ``ValueError`` if two of ``names`` differ only in case.
+
+    Phase names become file names, and Windows and macOS file systems ignore
+    case, so ``LaB6`` and ``lab6`` would overwrite each other's reports (and
+    easydiffraction lowercases them). Engine payloads call it on their phases.
+    """
+    seen: dict[str, str] = {}
+    for name in names:
+        other = seen.setdefault(name.lower(), name)
+        if other != name:
+            raise ValueError(f"{what} {other!r} and {name!r} differ only in case; rename one")
+
+
+def name_keyed(schema: dict) -> None:
+    """``json_schema_extra`` for a ``dict[CoreName, ...]`` field: state the key rule as ``propertyNames``.
+
+    pydantic writes a key pattern as ``patternProperties``, which leaves other keys
+    unchecked in JSON Schema; this makes every key follow :data:`NAME_PATTERN`.
+    """
+    pattern_properties = schema.pop("patternProperties", None)
+    if pattern_properties:
+        ((pattern, value),) = pattern_properties.items()
+        schema["propertyNames"] = {"pattern": pattern}
+        schema["additionalProperties"] = value
+
+
 # --- parameter models (A20, A32, A93) ---------------------------------------
 
 
@@ -560,6 +620,9 @@ class UnitCell(CoreModel, Generic[P]):
     def _length(cls, v, info):
         if not v.value > 0:
             raise ValueError(f"cell length {info.field_name} must be positive, got {v.value}")
+        if isinstance(v, BoundedRefinableParameter) and v.min is not None and not v.min > 0:
+            raise ValueError(f"cell length {info.field_name}: min must be positive (a cell length is), "
+                             f"got {v.min}; use null for no lower bound")
         return v
 
     @field_validator("alpha", "beta", "gamma")
@@ -567,6 +630,11 @@ def _length(cls, v, info):
     def _angle(cls, v, info):
         if not 0 < v.value < 180:
             raise ValueError(f"cell angle {info.field_name} must be between 0 and 180 degrees, got {v.value}")
+        if isinstance(v, BoundedRefinableParameter):
+            for side, bound in (("min", v.min), ("max", v.max)):
+                if bound is not None and not 0 < bound < 180:
+                    raise ValueError(f"cell angle {info.field_name}: {side} must be between 0 and 180 degrees "
+                                     f"(a cell angle is), got {bound}; use null for no {side} bound")
         return v
 
 
@@ -715,25 +783,44 @@ class Phase(CoreModel, Generic[P]):
     space_group: str = Field(description="gemmi's canonical extended Hermann-Mauguin name, e.g. "
                                          "'P m -3 m', 'C 1 2/m 1', 'R -3 m:H', 'F d -3 m:2' (A105)")
     unit_cell: UnitCell[P]
-    atoms: dict[str, Atom[P]] = Field(min_length=1, description="Atoms keyed by unique label")
+    atoms: dict[CoreName, Atom[P]] = Field(
+        min_length=1, json_schema_extra=name_keyed,
+        description="Atoms keyed by unique label: a letter, then ASCII letters, digits or '_'")
 
     _sites: dict = PrivateAttr(default_factory=dict)
     _warnings: list = PrivateAttr(default_factory=list)
 
     @classmethod
     def __pydantic_init_subclass__(cls, **kwargs: Any) -> None:
+        """Guard core's contract in every engine subclass (A93; re/03b review).
+
+        A subclass may add fields and validators, but may not redeclare core's
+        fields or reuse the name of a core validator, private attribute or
+        method: pydantic collects validators by name, so a same-named engine
+        validator would silently replace core's (e.g. the canonical space-group
+        check or every symmetry rule). Its ``extra`` must stay ``'forbid'`` (A19).
+        """
         super().__pydantic_init_subclass__(**kwargs)
         for klass in cls.__mro__:
             if klass is Phase or not (isinstance(klass, type) and issubclass(klass, Phase)):
                 continue
-            if klass.__pydantic_generic_metadata__["origin"] is Phase:
-                continue  # Phase[SomeParameterType] itself
-            redeclared = [n for n in RESERVED_PHASE_FIELDS if n in inspect.get_annotations(klass)]
+            if klass.__pydantic_generic_metadata__["origin"] is not None:
+                continue  # a parametrization (e.g. Phase[RefinableParameter]); its origin is checked itself
+            annotations = inspect.get_annotations(klass)
+            redeclared = [n for n in RESERVED_PHASE_FIELDS if n in annotations]
             if redeclared:
                 raise TypeError(
                     f"{klass.__name__} redeclares the core phase field(s) {', '.join(redeclared)}; "
                     "core owns space_group, unit_cell and atoms (A93)"
                 )
+            reused = sorted(n for n in _reserved_phase_members() if n in klass.__dict__ or n in annotations)
+            if reused:
+                raise TypeError(
+                    f"{klass.__name__} reuses the core phase name(s) {', '.join(reused)}; a same-named "
+                    "validator, method or private attribute would replace core's silently; rename it"
+                )
+        if cls.model_config.get("extra") != "forbid":
+            raise TypeError(f"{cls.__name__} must keep extra='forbid' (A19)")
 
     @field_validator("space_group")
     @classmethod
@@ -854,6 +941,18 @@ def warnings(self) -> list:
         return list(self._warnings)
 
 
+def _reserved_phase_members() -> frozenset[str]:
+    """Names core's :class:`Phase` defines besides its fields: validators, private attributes, methods."""
+    decorators = Phase.__pydantic_decorators__
+    validators = {n for kind in ("validators", "field_validators", "root_validators", "field_serializers",
+                                 "model_serializers", "model_validators", "computed_fields")
+                  for n in getattr(decorators, kind)}
+    # Methods written in Phase itself (not the ones pydantic or abc generate, e.g. model_post_init).
+    methods = {n for n, v in Phase.__dict__.items()
+               if inspect.isfunction(v) and not n.startswith("__") and v.__qualname__.startswith("Phase.")}
+    return frozenset(validators | methods | set(Phase.__private_attributes__))
+
+
 _CELL_FIELDS = ("a", "b", "c", "alpha", "beta", "gamma")
 
 
diff --git a/src/powderline/symmetry.py b/src/powderline/symmetry.py
index dd61114..efaa401 100644
--- a/src/powderline/symmetry.py
+++ b/src/powderline/symmetry.py
@@ -158,7 +158,9 @@ def canonical_space_group(space_group: str) -> gemmi.SpaceGroup:
     :class:`SymmetryError` whose message names the canonical form. gemmi's
     lenient lookup is used only to build that suggestion, never to accept: it
     would silently pick a default (``"Fd-3m"`` -> origin 1, ``"R-3m"`` -> ``:H``,
-    ``"C2/m"`` -> b-unique). A symbol without a setting lists both choices.
+    ``"C2/m"`` -> b-unique). A symbol without a setting lists the choices:
+    ``:H``/``:R``, ``:1``/``:2``, or every monoclinic setting of the group, by
+    unique axis.
     The legacy 0.26.0 paths keep the lenient :func:`resolve_space_group`.
     """
     raw = str(space_group)
@@ -183,6 +185,19 @@ def canonical_space_group(space_group: str) -> gemmi.SpaceGroup:
         raise SymmetryError(
             f"space group {raw!r} has two origin choices; write {origin1!r} or {origin2!r}"
         )
+    if sg.crystal_system_str() == "monoclinic" and raw.replace(" ", "") != sg.hm.replace(" ", ""):
+        # A short monoclinic symbol ("P21/c", "C2/m") leaves the unique axis and the cell
+        # choice unstated; gemmi silently picks one, so list them all (review B3).
+        by_axis: dict[str, list[str]] = {}
+        for s in gemmi.spacegroup_table():
+            if s.number == sg.number:
+                by_axis.setdefault(_monoclinic_unique_axis(_expanded_ops(s)), []).append(repr(s.xhm()))
+        choices = "; ".join(f"unique axis {axis}: {', '.join(names)}" for axis, names in sorted(
+            by_axis.items(), key=lambda item: "bca".index(item[0])))
+        raise SymmetryError(
+            f"space group {raw!r} does not state its unique axis or cell choice (gemmi would read it "
+            f"as {sg.xhm()!r}); write the setting you mean: {choices}"
+        )
     raise SymmetryError(f"space group {raw!r} is not in the canonical form; write {sg.xhm()!r}")
 
 
diff --git a/tests/data/canonical_space_groups.txt b/tests/data/canonical_space_groups.txt
new file mode 100644
index 0000000..e7baee8
--- /dev/null
+++ b/tests/data/canonical_space_groups.txt
@@ -0,0 +1,564 @@
+P 1
+P -1
+P 1 2 1
+P 1 1 2
+P 2 1 1
+P 1 21 1
+P 1 1 21
+P 21 1 1
+C 1 2 1
+A 1 2 1
+I 1 2 1
+A 1 1 2
+B 1 1 2
+I 1 1 2
+B 2 1 1
+C 2 1 1
+I 2 1 1
+P 1 m 1
+P 1 1 m
+P m 1 1
+P 1 c 1
+P 1 n 1
+P 1 a 1
+P 1 1 a
+P 1 1 n
+P 1 1 b
+P b 1 1
+P n 1 1
+P c 1 1
+C 1 m 1
+A 1 m 1
+I 1 m 1
+A 1 1 m
+B 1 1 m
+I 1 1 m
+B m 1 1
+C m 1 1
+I m 1 1
+C 1 c 1
+A 1 n 1
+I 1 a 1
+A 1 a 1
+C 1 n 1
+I 1 c 1
+A 1 1 a
+B 1 1 n
+I 1 1 b
+B 1 1 b
+A 1 1 n
+I 1 1 a
+B b 1 1
+C n 1 1
+I c 1 1
+C c 1 1
+B n 1 1
+I b 1 1
+P 1 2/m 1
+P 1 1 2/m
+P 2/m 1 1
+P 1 21/m 1
+P 1 1 21/m
+P 21/m 1 1
+C 1 2/m 1
+A 1 2/m 1
+I 1 2/m 1
+A 1 1 2/m
+B 1 1 2/m
+I 1 1 2/m
+B 2/m 1 1
+C 2/m 1 1
+I 2/m 1 1
+P 1 2/c 1
+P 1 2/n 1
+P 1 2/a 1
+P 1 1 2/a
+P 1 1 2/n
+P 1 1 2/b
+P 2/b 1 1
+P 2/n 1 1
+P 2/c 1 1
+P 1 21/c 1
+P 1 21/n 1
+P 1 21/a 1
+P 1 1 21/a
+P 1 1 21/n
+P 1 1 21/b
+P 21/b 1 1
+P 21/n 1 1
+P 21/c 1 1
+C 1 2/c 1
+A 1 2/n 1
+I 1 2/a 1
+A 1 2/a 1
+C 1 2/n 1
+I 1 2/c 1
+A 1 1 2/a
+B 1 1 2/n
+I 1 1 2/b
+B 1 1 2/b
+A 1 1 2/n
+I 1 1 2/a
+B 2/b 1 1
+C 2/n 1 1
+I 2/c 1 1
+C 2/c 1 1
+B 2/n 1 1
+I 2/b 1 1
+P 2 2 2
+P 2 2 21
+P 21 2 2
+P 2 21 2
+P 21 21 2
+P 2 21 21
+P 21 2 21
+P 21 21 21
+C 2 2 21
+A 21 2 2
+B 2 21 2
+C 2 2 2
+A 2 2 2
+B 2 2 2
+F 2 2 2
+I 2 2 2
+I 21 21 21
+P m m 2
+P 2 m m
+P m 2 m
+P m c 21
+P c m 21
+P 21 m a
+P 21 a m
+P b 21 m
+P m 21 b
+P c c 2
+P 2 a a
+P b 2 b
+P m a 2
+P b m 2
+P 2 m b
+P 2 c m
+P c 2 m
+P m 2 a
+P c a 21
+P b c 21
+P 21 a b
+P 21 c a
+P c 21 b
+P b 21 a
+P n c 2
+P c n 2
+P 2 n a
+P 2 a n
+P b 2 n
+P n 2 b
+P m n 21
+P n m 21
+P 21 m n
+P 21 n m
+P n 21 m
+P m 21 n
+P b a 2
+P 2 c b
+P c 2 a
+P n a 21
+P b n 21
+P 21 n b
+P 21 c n
+P c 21 n
+P n 21 a
+P n n 2
+P 2 n n
+P n 2 n
+C m m 2
+A 2 m m
+B m 2 m
+C m c 21
+C c m 21
+A 21 m a
+A 21 a m
+B b 21 m
+B m 21 b
+C c c 2
+A 2 a a
+B b 2 b
+A m m 2
+B m m 2
+B 2 m m
+C 2 m m
+C m 2 m
+A m 2 m
+A b m 2
+B m a 2
+B 2 c m
+C 2 m b
+C m 2 a
+A c 2 m
+A m a 2
+B b m 2
+B 2 m b
+C 2 c m
+C c 2 m
+A m 2 a
+A b a 2
+B b a 2
+B 2 c b
+C 2 c b
+C c 2 a
+A c 2 a
+F m m 2
+F 2 m m
+F m 2 m
+F d d 2
+F 2 d d
+F d 2 d
+I m m 2
+I 2 m m
+I m 2 m
+I b a 2
+I 2 c b
+I c 2 a
+I m a 2
+I b m 2
+I 2 m b
+I 2 c m
+I c 2 m
+I m 2 a
+P m m m
+P n n n:1
+P n n n:2
+P c c m
+P m a a
+P b m b
+P b a n:1
+P b a n:2
+P n c b:1
+P n c b:2
+P c n a:1
+P c n a:2
+P m m a
+P m m b
+P b m m
+P c m m
+P m c m
+P m a m
+P n n a
+P n n b
+P b n n
+P c n n
+P n c n
+P n a n
+P m n a
+P n m b
+P b m n
+P c n m
+P n c m
+P m a n
+P c c a
+P c c b
+P b a a
+P c a a
+P b c b
+P b a b
+P b a m
+P m c b
+P c m a
+P c c n
+P n a a
+P b n b
+P b c m
+P c a m
+P m c a
+P m a b
+P b m a
+P c m b
+P n n m
+P m n n
+P n m n
+P m m n:1
+P m m n:2
+P n m m:1
+P n m m:2
+P m n m:1
+P m n m:2
+P b c n
+P c a n
+P n c a
+P n a b
+P b n a
+P c n b
+P b c a
+P c a b
+P n m a
+P m n b
+P b n m
+P c m n
+P m c n
+P n a m
+C m c m
+C c m m
+A m m a
+A m a m
+B b m m
+B m m b
+C m c a
+C c m b
+A b m a
+A c a m
+B b c m
+B m a b
+C m m m
+A m m m
+B m m m
+C c c m
+A m a a
+B b m b
+C m m a
+C m m b
+A b m m
+A c m m
+B m c m
+B m a m
+C c c a:1
+C c c a:2
+C c c b:1
+C c c b:2
+A b a a:1
+A b a a:2
+A c a a:1
+A c a a:2
+B b c b:1
+B b c b:2
+B b a b:1
+B b a b:2
+F m m m
+F d d d:1
+F d d d:2
+I m m m
+I b a m
+I m c b
+I c m a
+I b c a
+I c a b
+I m m a
+I m m b
+I b m m
+I c m m
+I m c m
+I m a m
+P 4
+P 41
+P 42
+P 43
+I 4
+I 41
+P -4
+I -4
+P 4/m
+P 42/m
+P 4/n:1
+P 4/n:2
+P 42/n:1
+P 42/n:2
+I 4/m
+I 41/a:1
+I 41/a:2
+P 4 2 2
+P 4 21 2
+P 41 2 2
+P 41 21 2
+P 42 2 2
+P 42 21 2
+P 43 2 2
+P 43 21 2
+I 4 2 2
+I 41 2 2
+P 4 m m
+P 4 b m
+P 42 c m
+P 42 n m
+P 4 c c
+P 4 n c
+P 42 m c
+P 42 b c
+I 4 m m
+I 4 c m
+I 41 m d
+I 41 c d
+P -4 2 m
+P -4 2 c
+P -4 21 m
+P -4 21 c
+P -4 m 2
+P -4 c 2
+P -4 b 2
+P -4 n 2
+I -4 m 2
+I -4 c 2
+I -4 2 m
+I -4 2 d
+P 4/m m m
+P 4/m c c
+P 4/n b m:1
+P 4/n b m:2
+P 4/n n c:1
+P 4/n n c:2
+P 4/m b m
+P 4/m n c
+P 4/n m m:1
+P 4/n m m:2
+P 4/n c c:1
+P 4/n c c:2
+P 42/m m c
+P 42/m c m
+P 42/n b c:1
+P 42/n b c:2
+P 42/n n m:1
+P 42/n n m:2
+P 42/m b c
+P 42/m n m
+P 42/n m c:1
+P 42/n m c:2
+P 42/n c m:1
+P 42/n c m:2
+I 4/m m m
+I 4/m c m
+I 41/a m d:1
+I 41/a m d:2
+I 41/a c d:1
+I 41/a c d:2
+P 3
+P 31
+P 32
+R 3:H
+R 3:R
+P -3
+R -3:H
+R -3:R
+P 3 1 2
+P 3 2 1
+P 31 1 2
+P 31 2 1
+P 32 1 2
+P 32 2 1
+R 3 2:H
+R 3 2:R
+P 3 m 1
+P 3 1 m
+P 3 c 1
+P 3 1 c
+R 3 m:H
+R 3 m:R
+R 3 c:H
+R 3 c:R
+P -3 1 m
+P -3 1 c
+P -3 m 1
+P -3 c 1
+R -3 m:H
+R -3 m:R
+R -3 c:H
+R -3 c:R
+P 6
+P 61
+P 65
+P 62
+P 64
+P 63
+P -6
+P 6/m
+P 63/m
+P 6 2 2
+P 61 2 2
+P 65 2 2
+P 62 2 2
+P 64 2 2
+P 63 2 2
+P 6 m m
+P 6 c c
+P 63 c m
+P 63 m c
+P -6 m 2
+P -6 c 2
+P -6 2 m
+P -6 2 c
+P 6/m m m
+P 6/m c c
+P 63/m c m
+P 63/m m c
+P 2 3
+F 2 3
+I 2 3
+P 21 3
+I 21 3
+P m -3
+P n -3:1
+P n -3:2
+F m -3
+F d -3:1
+F d -3:2
+I m -3
+P a -3
+I a -3
+P 4 3 2
+P 42 3 2
+F 4 3 2
+F 41 3 2
+I 4 3 2
+P 43 3 2
+P 41 3 2
+I 41 3 2
+P -4 3 m
+F -4 3 m
+I -4 3 m
+P -4 3 n
+F -4 3 c
+I -4 3 d
+P m -3 m
+P n -3 n:1
+P n -3 n:2
+P m -3 n
+P n -3 m:1
+P n -3 m:2
+F m -3 m
+F m -3 c
+F d -3 m:1
+F d -3 m:2
+F d -3 c:1
+F d -3 c:2
+I m -3 m
+I a -3 d
+I 1 21 1
+C 1 21 1
+P 21212(a)
+C 2 2 21a)
+C 2 2 2a
+F 2 2 2a
+I 2 2 2a
+P 42 21 2a
+I 2 3a
+A 1
+B 1
+C 1
+F 1
+I 1
+A -1
+B -1
+C -1
+F -1
+I -1
+B 1 2 1
+C 1 1 2
+B 1 21 1
+C 1 1 21
+F 1 2 1
+F 1 m 1
+F 1 d 1
+F 1 2/m 1
+A b a m
+C 4 2 2
+C 4 2 21
+F 4 2 2
+C -4 2 m
+C -4 2 b
+F 4/m m m
diff --git a/tests/test_schema_core.py b/tests/test_schema_core.py
index dfaa68e..78c47f3 100644
--- a/tests/test_schema_core.py
+++ b/tests/test_schema_core.py
@@ -4,9 +4,10 @@
 engine schema shares (re/03).
 """
 import json
+from pathlib import Path
 
 import pytest
-from pydantic import ValidationError
+from pydantic import ConfigDict, PrivateAttr, ValidationError, field_validator, model_validator
 
 from powderline.schema_core import (
     CORE_SCHEMA_VERSION,
@@ -1385,9 +1386,22 @@ def test_phase_canonical_space_group_accepted(space_group, cell, xyz):
 @pytest.mark.parametrize("symbol, message", [
     ("Pm-3m", "space group 'Pm-3m' is not in the canonical form; write 'P m -3 m'"),
     ("p m -3 m", "space group 'p m -3 m' is not in the canonical form; write 'P m -3 m'"),
-    ("C2/m", "space group 'C2/m' is not in the canonical form; write 'C 1 2/m 1'"),
-    ("C 2/m", "space group 'C 2/m' is not in the canonical form; write 'C 1 2/m 1'"),
-    ("P 21/c", "space group 'P 21/c' is not in the canonical form; write 'P 1 21/c 1'"),
+    ("C2/m", "space group 'C2/m' does not state its unique axis or cell choice (gemmi would read it as "
+             "'C 1 2/m 1'); write the setting you mean: unique axis b: 'C 1 2/m 1', 'A 1 2/m 1', "
+             "'I 1 2/m 1', 'F 1 2/m 1'; unique axis c: 'A 1 1 2/m', 'B 1 1 2/m', 'I 1 1 2/m'; "
+             "unique axis a: 'B 2/m 1 1', 'C 2/m 1 1', 'I 2/m 1 1'"),
+    ("C 2/m", "space group 'C 2/m' does not state its unique axis or cell choice (gemmi would read it as "
+              "'C 1 2/m 1'); write the setting you mean: unique axis b: 'C 1 2/m 1', 'A 1 2/m 1', "
+              "'I 1 2/m 1', 'F 1 2/m 1'; unique axis c: 'A 1 1 2/m', 'B 1 1 2/m', 'I 1 1 2/m'; "
+              "unique axis a: 'B 2/m 1 1', 'C 2/m 1 1', 'I 2/m 1 1'"),
+    ("P 21/c", "space group 'P 21/c' does not state its unique axis or cell choice (gemmi would read it as "
+               "'P 1 21/c 1'); write the setting you mean: unique axis b: 'P 1 21/c 1', 'P 1 21/n 1', "
+               "'P 1 21/a 1'; unique axis c: 'P 1 1 21/a', 'P 1 1 21/n', 'P 1 1 21/b'; "
+               "unique axis a: 'P 21/b 1 1', 'P 21/n 1 1', 'P 21/c 1 1'"),
+    ("Pc", "space group 'Pc' does not state its unique axis or cell choice (gemmi would read it as "
+           "'P 1 c 1'); write the setting you mean: unique axis b: 'P 1 c 1', 'P 1 n 1', 'P 1 a 1'; "
+           "unique axis c: 'P 1 1 a', 'P 1 1 n', 'P 1 1 b'; unique axis a: 'P b 1 1', 'P n 1 1', 'P c 1 1'"),
+    ("P121/c1", "space group 'P121/c1' is not in the canonical form; write 'P 1 21/c 1'"),
     ("R-3m:H", "space group 'R-3m:H' is not in the canonical form; write 'R -3 m:H'"),
     ("R -3 m", "space group 'R -3 m' does not name its setting; write 'R -3 m:H' (hexagonal axes) "
                "or 'R -3 m:R' (rhombohedral axes)"),
@@ -1416,6 +1430,16 @@ def test_canonical_space_group_every_gemmi_name_round_trips():
     assert all(canonical_space_group(n).xhm() == n for n in names)
 
 
+def test_canonical_space_group_names_match_the_committed_list():
+    """The accepted spellings are gemmi's names, pinned: a gemmi change that renames, adds or
+    drops one fails here before it can invalidate recipes (gemmi is pinned exactly; review B4).
+    On a deliberate gemmi upgrade, regenerate the file and record the change in SCHEMA_HISTORY."""
+    import gemmi
+
+    committed = (Path(__file__).parent / "data" / "canonical_space_groups.txt").read_text(encoding="utf-8")
+    assert [sg.xhm() for sg in gemmi.spacegroup_table()] == committed.splitlines()
+
+
 @pytest.mark.parametrize("field", RESERVED_PHASE_FIELDS)
 def test_phase_reserved_field_cannot_be_redeclared(field):
     """An engine subclass may not redefine space_group, unit_cell or atoms (A93)."""
@@ -1434,6 +1458,59 @@ class Child(EnginePhase):
             atoms: dict
 
 
+def test_phase_reserved_members_are_core_validators_private_attributes_and_methods():
+    """Pinned, so a new core validator or method is seen to be reserved too (review A1)."""
+    from powderline.schema_core import _reserved_phase_members
+
+    assert _reserved_phase_members() == {"_space_group", "_sites_check", "_sites", "_warnings", "site", "warnings"}
+
+
+@pytest.mark.parametrize("name, body", [
+    ("_space_group", "@field_validator('space_group')\n@classmethod\ndef _space_group(cls, v):\n    return v"),
+    ("_sites_check", "@model_validator(mode='after')\ndef _sites_check(self):\n    return self"),
+    ("site", "def site(self, label):\n    return None"),
+    ("_warnings", "_warnings: list = PrivateAttr(default_factory=list)"),
+])
+def test_phase_core_validator_or_method_cannot_be_reused(name, body):
+    """A same-named engine validator would silently replace core's (pydantic collects them by name)."""
+    namespace = {"field_validator": field_validator, "model_validator": model_validator,
+                 "PrivateAttr": PrivateAttr, "Phase": Phase, "RP": RP}
+    source = "class EnginePhase(Phase[RP]):\n    scale: RP\n" + "\n".join(
+        "    " + line for line in body.splitlines())
+    with pytest.raises(TypeError) as exc_info:
+        exec(source, namespace)
+    assert str(exc_info.value) == (
+        f"EnginePhase reuses the core phase name(s) {name}; a same-named validator, method or "
+        "private attribute would replace core's silently; rename it")
+
+
+def test_phase_engine_subclass_must_keep_extra_forbid():
+    with pytest.raises(TypeError) as exc_info:
+        class EnginePhase(Phase[RP]):
+            model_config = ConfigDict(extra="allow")
+    assert str(exc_info.value) == "EnginePhase must keep extra='forbid' (A19)"
+
+
+def test_phase_engine_validators_with_their_own_names_run_with_core_rules():
+    """An engine adds its own rule (gsasii rejects origin 1, EB-03) without replacing core's."""
+    class EnginePhase(Phase[RP]):
+        scale: RP
+
+        @field_validator("space_group")
+        @classmethod
+        def _gsasii_origin(cls, v):
+            if v.endswith(":1"):
+                raise ValueError("gsasii: origin choice 1 is not supported")
+            return v
+
+    d = {**_valid_pmm_lab6_phase_dict(), "scale": [1.0, True]}
+    d["space_group"] = "Pm-3m"
+    with pytest.raises(ValidationError) as exc_info:
+        EnginePhase.model_validate(d)
+    assert exc_info.value.errors()[0]["msg"] == (
+        "Value error, space group 'Pm-3m' is not in the canonical form; write 'P m -3 m'")
+
+
 def test_phase_engine_subclass_adds_flat_fields_and_keeps_core_validation():
     """The gsasii shape: engine fields flat in the phase; core rules still run; locs nest."""
     class EnginePhase(Phase[RP]):
@@ -2020,3 +2097,80 @@ def test_canonical_uij_rechecked_against_bounds_n4():
         (("atoms", "C", "Uaniso", "U12"), f"{context}: U12 = 0.010000100000000001 (the site-symmetric value "
                                           "of the stated 0.0100005) is above max (0.01)"),
     ]
+
+
+# --- names and cell bound domain (re/03b review C5, C6) ----------------------
+
+
+_NAME_RULE = "must start with a letter and contain only ASCII letters, digits and '_' (e.g. 'O1', 'LaB6_a')"
+
+
+@pytest.mark.parametrize("label, message", [
+    ("", "a name must not be empty or blank"),
+    ("  ", "a name must not be empty or blank"),
+    ("O.1", f"name 'O.1' {_NAME_RULE}"),
+    (" O1", f"name ' O1' {_NAME_RULE}"),
+    ("O 1", f"name 'O 1' {_NAME_RULE}"),
+    ("O-1", f"name 'O-1' {_NAME_RULE}"),
+    ("1O", f"name '1O' {_NAME_RULE}"),
+    ("_O1", f"name '_O1' {_NAME_RULE}"),
+    ("Oé", f"name 'Oé' {_NAME_RULE}"),
+    ("O/1", f"name 'O/1' {_NAME_RULE}"),
+])
+def test_atom_label_follows_the_name_rule(label, message):
+    """Atom labels: a letter, then ASCII letters, digits or '_' (every engine can use it; review C6)."""
+    d = _valid_pmm_lab6_phase_dict()
+    d["atoms"][label] = d["atoms"].pop("B1")
+    with pytest.raises(ValidationError) as exc_info:
+        Phase[RP].model_validate(d)
+    assert _errs(exc_info) == [(("atoms", label, "[key]"), message)]
+
+
+def test_atom_labels_following_the_rule_accepted():
+    d = _valid_pmm_lab6_phase_dict()
+    d["atoms"]["B_site2"] = d["atoms"].pop("B1")
+    assert "B_site2" in Phase[RP].model_validate(d).atoms
+
+
+def test_names_unique_ignoring_case():
+    from powderline.schema_core import check_names_unique_ignoring_case
+
+    check_names_unique_ignoring_case(["LaB6", "Si", "Al2O3"], "phase")
+    with pytest.raises(ValueError) as exc_info:
+        check_names_unique_ignoring_case(["LaB6", "Si", "lab6"], "phase")
+    assert str(exc_info.value) == "phase 'LaB6' and 'lab6' differ only in case; rename one"
+
+
+def test_core_name_json_schema_constrains_every_key():
+    from powderline.schema_core import NAME_PATTERN
+
+    atoms = Phase[RP].model_json_schema()["properties"]["atoms"]
+    assert atoms["propertyNames"] == {"pattern": NAME_PATTERN}
+    assert atoms["additionalProperties"] == {"$ref": "#/$defs/Atom"}
+    assert "patternProperties" not in atoms
+
+
+@pytest.mark.parametrize("name, bounds, message", [
+    ("a", (0.0, 10.0), "cell length a: min must be positive (a cell length is), got 0.0; use null for no lower bound"),
+    ("c", (-1.0, None), "cell length c: min must be positive (a cell length is), got -1.0; use null for no lower bound"),
+    ("beta", (0.0, 120.0), "cell angle beta: min must be between 0 and 180 degrees (a cell angle is), got 0.0; "
+                           "use null for no min bound"),
+    ("beta", (90.0, 180.0), "cell angle beta: max must be between 0 and 180 degrees (a cell angle is), got 180.0; "
+                            "use null for no max bound"),
+])
+def test_cell_bounds_lie_in_the_cell_domain(name, bounds, message):
+    """A stated bound outside where a cell parameter exists is an error (lengths > 0, angles in (0, 180))."""
+    values = (9.0, 5.0, 7.0, 90, 105.0, 90)
+    cell = _cellp(values, flags=(True, True, True, False, True, False), bounds={name: bounds})
+    d = _phasep("C 1 2/m 1", cell, {"O": _atomp(_GENERAL, bounds={})})
+    with pytest.raises(ValidationError) as exc_info:
+        Phase[BRP].model_validate(d)
+    assert _errs(exc_info) == [(("unit_cell", name), message)]
+
+
+def test_cell_open_bounds_and_positive_bounds_accepted():
+    values = (9.0, 5.0, 7.0, 90, 105.0, 90)
+    cell = _cellp(values, flags=(True, True, True, False, True, False),
+                  bounds={"a": (8.0, 10.0), "b": (None, 6.0), "beta": (95.0, 115.0)})
+    phase = Phase[BRP].model_validate(_phasep("C 1 2/m 1", cell, {"O": _atomp(_GENERAL, bounds={})}))
+    assert phase.unit_cell.a.model_dump() == [9.0, True, 8.0, 10.0]

From abb6b6412c0de8d46ad792c8d0e90617cb9e5073 Mon Sep 17 00:00:00 2001
From: acorrao <95718914+AdamCorrao@users.noreply.github.com>
Date: Wed, 7 Oct 2026 15:51:05 -0400
Subject: [PATCH 09/14] fix(core): validation never changes a recipe; a phase
 model needs its parameter type

Second round of the re/03b review follow-ups (maintainer answers 2026-10-07).

- A115, validation never changes a recipe. The recipe is the record of the
  refinement intent, so validation only accepts or rejects. A value that is
  near the exact one but not equal to it (to floating-point precision) is an
  error that gives the value to write:
  - a special position within 5e-6 (was: replaced by the exact values,
    A73); the 5e-6..2e-3 band error is unchanged;
  - a Uaniso within 1e-6 A^2 of symmetric (was: adjusted, A78);
  - tied bounds near the mapped ones (was: snapped, A108).
  The suggestion keeps each tie group's first member as stated and derives
  the others ("write y = 0.2468", "write U12 = 0.0061735"); fixed values are
  exact. Every value is the repr of the float, so "0.3333333333333333" for
  1/3. N4 is moot. Phase.warnings() and the codes special_position_adjusted,
  adp_symmetry_adjusted and tied_bounds_adjusted are removed. None of the
  67 atoms in the committed examples is affected.
- A114, a phase model needs its parameter type. An engine subclass that
  forgets [P] is a TypeError when it is defined, unless it declares
  Generic[P]. Validating with an open type is a TypeError. Unparametrized,
  one phase could mix [value, flag] and [value, flag, min, max], and F4 then
  crashed.
- A112 amended: names are also not Python keywords and are at most 64
  characters (phase names become file names).
- Tests: removed test_bounded_phase_canonicalization_keeps_flag_and_bounds
  and the two N4 tests. Renamed the adjust/snap tests to *_not_exact_rejected,
  test_tied_cell_bounds_equal_exactly and
  test_phase_holds_the_callers_atoms_unchanged. Added tests for the A114
  guards and the keyword and length rules.
- SCHEMA_HISTORY: exactness, suggested values, the 1/3 spelling, names.

Assisted-by: claude-code:claude-opus-5-5
---
 docs/SCHEMA_HISTORY.md        |  37 +++--
 src/powderline/schema_core.py | 286 ++++++++++++++++------------------
 tests/test_gateways.py        |   4 +-
 tests/test_schema_core.py     | 251 ++++++++++++++---------------
 4 files changed, 277 insertions(+), 301 deletions(-)

diff --git a/docs/SCHEMA_HISTORY.md b/docs/SCHEMA_HISTORY.md
index 99a23b8..aa5a27e 100644
--- a/docs/SCHEMA_HISTORY.md
+++ b/docs/SCHEMA_HISTORY.md
@@ -71,7 +71,12 @@ engine schemas adopt it in re/04–06.
   on Windows and macOS), and problems are reported at `.`-joined paths
   (`atoms.O1.Uiso`). So `"2H-MoS2"` is written e.g. `MoS2_2H`.
   Structural interpretation is checked once, in core, so every engine gets the
-  same structure. All problems are reported together, each at its own field
+  same structure. **Validation never changes a recipe:** the recipe is the
+  record of the refinement intent, so every value must already be the exact
+  value the engines use. Where it is not, validation fails and the message
+  gives the value to write. "Exact" means to floating-point precision, because
+  a JSON number cannot hold 1/3: write `0.3333333333333333` (the shortest
+  decimal that reads back as the nearest float to 1/3). All problems are reported together, each at its own field
   (`unit_cell`, `atoms.<label>` for the position, `atoms.<label>.Multiplicity`,
   `atoms.<label>.Uaniso`, or the parameter a flag/bound rule concerns, e.g.
   `unit_cell.b`, `atoms.<label>.y`, `atoms.<label>.Uaniso.U12`); they are checked
@@ -101,15 +106,14 @@ engine schemas adopt it in re/04–06.
     Charged scattering types (`"Fe3+"`) are not supported yet and are rejected,
     never reduced to the neutral atom.
   - **Occupancy**: 0 to 1 inclusive, even where an engine would accept more.
-  - **Special positions**: an atom whose symmetry images lie within 5e-6
-    (fractional) of itself is on a special position, so write special
-    coordinates with **at least 6 decimals** (e.g. `0.333333`). An atom 5e-6 to
-    2e-3 from a special position is an **error** (`0.33`, `0.3333`, `0.33333`):
-    state it to ≥ 6 decimals or move it off. Accepted special positions are
-    replaced by their **exact** coordinates (fixed coordinates become the exact
-    fraction; coupled ones satisfy their relation, by the smallest change); the
-    refine flag and bounds are kept. Each adjustment is reported as a structured
-    warning, and these exact values are what every engine receives.
+  - **Special positions** are stated **exactly** (to floating-point precision):
+    `0.5`, `0.25`, `0.3333333333333333`, and coupled coordinates satisfying
+    their relation (`(x, 2x, 1/4)` with `y` exactly `2·x`). An atom within 2e-3
+    (fractional) of a special position but not on it is an **error**: within
+    5e-6 the message gives the values to write (it keeps each tie group's first
+    coordinate as stated and derives the others, e.g. `write y = 0.2468`;
+    fixed coordinates take their exact value); from 5e-6 to 2e-3 it asks to
+    state the position exactly or move it off (`0.33`, `0.3333`).
   - **Multiplicity**: optional; when stated it must equal the multiplicity
     derived from the space group.
   - **ADPs**: `ADP` selects the thermal parameter that is **required**:
@@ -117,9 +121,9 @@ engine schemas adopt it in re/04–06.
     `U11 U22 U33 U12 U13 U23` (Ų). The other one must be left out. A missing
     or extra one is an error at that field (`atoms.<label>.Uiso`,
     `atoms.<label>.Uaniso.U23`), and the JSON Schema states the same rule.
-    Anisotropic ADPs must respect the site
-    symmetry: within 1e-6 Ų they are set to the symmetric values and reported;
-    beyond that it is an error.
+    Anisotropic ADPs must respect the site symmetry exactly; otherwise it is an
+    error, which within 1e-6 Ų gives the values to write (derived from each tie
+    group's first component, e.g. `write U12 = 0.0061735` for `U12 = U22/2`).
   - **Refinement intent follows the symmetry.** Parameters tied by symmetry
     are **one** parameter, and every member is stated: cubic `a, b, c`;
     tetragonal/hexagonal `a, b`; rhombohedral axes (`:R`) `a, b, c` and
@@ -134,10 +138,9 @@ engine schemas adopt it in re/04–06.
     - **Bounds** (engines with bounds) follow the tie like the values:
       `y = k·x + c` maps x's `[min, max]` to `[k·min + c, k·max + c]`
       (swapped for negative k; an open side stays open), e.g. `(x, x + 1/2, z)`
-      with x in `[0, 0.2]` needs y in `[0.5, 0.7]`. Bounds within the value
-      tolerance (coordinates 5e-6, Uij 1e-6 Ų, cell 1e-9 relative/degrees)
-      are set to the exact values and reported; beyond it is an error. A value
-      moved to its exact special position is re-checked against its bounds.
+      with x in `[0, 0.2]` needs y in `[0.5, 0.7]`. They must be the mapped
+      values exactly (to floating-point precision); otherwise the error gives
+      them.
     - Atoms at the same position are independent: their flags are never tied.
 
 ## gsasii engine schema
diff --git a/src/powderline/schema_core.py b/src/powderline/schema_core.py
index ecca576..69b4161 100644
--- a/src/powderline/schema_core.py
+++ b/src/powderline/schema_core.py
@@ -23,6 +23,7 @@
 
 import inspect
 import json
+import keyword
 import math
 import re
 from typing import Annotated, Any, Generic, Literal, Optional, TypeVar
@@ -49,11 +50,9 @@
 from pydantic.json_schema import DEFAULT_REF_TEMPLATE, GenerateJsonSchema, JsonSchemaMode
 from pydantic_core import InitErrorDetails, PydanticCustomError
 
-from powderline.exceptions import StructuredWarning, SymmetryError
+from powderline.exceptions import SymmetryError
 from powderline.symmetry import (
-    CELL_TOL,
-    SPECIAL_POSITION_TOL,
-    UIJ_TOL,
+    ADJUSTMENT_REPORT_TOL,
     Ties,
     analyze_site,
     canonical_space_group,
@@ -185,17 +184,26 @@ def _integer_not_text_or_bool(v: Any) -> Any:
 
 #: A phase name or atom label: an ASCII letter, then ASCII letters, digits or ``_``.
 NAME_PATTERN = r"^[A-Za-z][A-Za-z0-9_]*$"
+#: Longest phase name or atom label. Phase names become file names with a suffix of
+#: up to 21 characters (``_unit_cell_report.csv``); file systems allow 255 per name
+#: and Windows 260 per path by default, so a name stays well inside both.
+NAME_MAX_LENGTH = 64
+#: Python's (hard) keywords: valid by the pattern but not identifiers (``None``, ``class``).
+NAME_KEYWORDS = tuple(keyword.kwlist)
+#: JSON Schema of a name (also the ``propertyNames`` of a name-keyed object).
+NAME_JSON_SCHEMA = {"type": "string", "pattern": NAME_PATTERN, "maxLength": NAME_MAX_LENGTH,
+                    "not": {"enum": list(NAME_KEYWORDS)}}
 
 
 def _check_name(name: str) -> str:
-    """The name rule every engine can honor (re/03b review C6).
+    """The name rule every engine can honor, which is also a Python identifier (re/03b review C6).
 
     - GSAS-II renames a phase whose name has surrounding spaces or non-ASCII
       characters, and the parameterization then skips that phase silently.
     - easydiffraction accepts atom labels only of the form ``[A-Za-z_][A-Za-z0-9_]*``.
     - TOPAS emits phase names inside quotes and builds parameter names from them.
-    - Phase names become report file names (``<phase>_unit_cell_report.csv``),
-      so ``/``, ``:`` and the like must not appear.
+    - Phase names become report file names (``<phase>_unit_cell_report.csv``), so
+      no character a file system rejects (``/``, ``:``, ...) and a bounded length.
     - Field paths are joined with ``.`` (``atoms.O1.Uiso``).
     """
     if not name.strip():
@@ -203,13 +211,17 @@ def _check_name(name: str) -> str:
     if re.fullmatch(NAME_PATTERN, name) is None:
         raise ValueError(f"name {name!r} must start with a letter and contain only ASCII letters, digits "
                          "and '_' (e.g. 'O1', 'LaB6_a')")
+    if len(name) > NAME_MAX_LENGTH:
+        raise ValueError(f"name {name[:20]!r}... has {len(name)} characters; the limit is {NAME_MAX_LENGTH}")
+    if keyword.iskeyword(name):
+        raise ValueError(f"name {name!r} is a Python keyword; choose another name")
     return name
 
 
-#: A phase name or an atom label (a dict key), see :data:`NAME_PATTERN`. Core uses
+#: A phase name or an atom label (a dict key), see :func:`_check_name`. Core uses
 #: it for the atom labels; engine schemas use it for their ``phases`` keys (with
 #: :func:`name_keyed`, and :func:`check_names_unique_ignoring_case` for phases).
-CoreName = Annotated[str, AfterValidator(_check_name), WithJsonSchema({"type": "string", "pattern": NAME_PATTERN})]
+CoreName = Annotated[str, AfterValidator(_check_name), WithJsonSchema(NAME_JSON_SCHEMA)]
 
 
 def check_names_unique_ignoring_case(names, what: str) -> None:
@@ -229,13 +241,14 @@ def check_names_unique_ignoring_case(names, what: str) -> None:
 def name_keyed(schema: dict) -> None:
     """``json_schema_extra`` for a ``dict[CoreName, ...]`` field: state the key rule as ``propertyNames``.
 
-    pydantic writes a key pattern as ``patternProperties``, which leaves other keys
-    unchecked in JSON Schema; this makes every key follow :data:`NAME_PATTERN`.
+    pydantic writes a key rule as ``patternProperties`` (pattern only), which
+    leaves other keys unchecked in JSON Schema; this checks every key against
+    :data:`NAME_JSON_SCHEMA`.
     """
     pattern_properties = schema.pop("patternProperties", None)
     if pattern_properties:
-        ((pattern, value),) = pattern_properties.items()
-        schema["propertyNames"] = {"pattern": pattern}
+        ((_pattern, value),) = pattern_properties.items()
+        schema["propertyNames"] = {k: v for k, v in NAME_JSON_SCHEMA.items() if k != "type"}
         schema["additionalProperties"] = value
 
 
@@ -348,11 +361,7 @@ def __get_pydantic_json_schema__(cls, core_schema, handler) -> dict:
 
 
 def check_within_bounds(value: float, param: BoundedRefinableParameter, field: str) -> None:
-    """Raise ``ValueError`` unless ``param.min <= value <= param.max`` (open ends pass).
-
-    Also used at the phase level, on a value canonicalized after the
-    parameter's own check (review N4).
-    """
+    """Raise ``ValueError`` unless ``param.min <= value <= param.max`` (open ends pass)."""
     if param.min is not None and value < param.min:
         raise ValueError(f"{field} ({value}) is below min ({param.min})")
     if param.max is not None and value > param.max:
@@ -664,16 +673,17 @@ class UanisoTensor(CoreModel, Generic[P]):
 class Atom(CoreModel, Generic[P]):
     """One atom of a phase: coordinates, occupancy and ADPs are refinable parameters.
 
-    Coordinates are fractional JSON numbers. A special position is declared by
-    stating it to at least 6 decimals; the validated phase holds the canonical
-    (exact) values and reports every adjustment (A73). ``occupancy`` is required
+    Coordinates are fractional JSON numbers. A special position is stated
+    exactly, to floating-point precision (``0.3333333333333333`` for 1/3); a
+    position near one but not on it is an error giving the exact values (A73,
+    A115). ``occupancy`` is required
     and 0 to 1 inclusive (A76, A96). ``Multiplicity`` is optional and, when
     stated, must match the derived value (A69 T3). ``ADP`` selects which
     thermal parameter is **required**: ``Uiso``, or ``Uaniso`` with all six of
     U11..U23; the other must be left out (an error at that field otherwise, and
-    the JSON Schema states the rule). ``Uaniso`` must respect the site symmetry:
-    within 1e-6 A^2 it is set to the symmetric values and reported, beyond that
-    it is an error (A78). Nothing is ``null`` (A96).
+    the JSON Schema states the rule). ``Uaniso`` must respect the site symmetry
+    exactly; otherwise it is an error, giving the symmetric values when they are
+    within 1e-6 A^2 (A78, A115). Nothing is ``null`` (A96).
     """
 
     model_config = ConfigDict(extra="forbid", json_schema_extra=_ADP_PAIRING_SCHEMA)
@@ -735,6 +745,12 @@ def _adp_block(self) -> "Atom":
         return self
 
 
+_OPEN_PARAMETER_TYPE = (
+    "{name} has no parameter type: subclass Phase[RefinableParameter] (no bounds) or "
+    "Phase[BoundedRefinableParameter] (bounds); a deliberately generic subclass declares "
+    "Generic[P] and is parametrized before use"
+)
+
 #: Phase fields owned by core; an engine subclass may not redeclare them (A93).
 RESERVED_PHASE_FIELDS = ("space_group", "unit_cell", "atoms")
 
@@ -749,23 +765,27 @@ class Phase(CoreModel, Generic[P]):
     ``TypeError`` when the subclass is defined.
 
     ``space_group`` is gemmi's canonical name (A105). Validation derives each
-    atom's site (multiplicity, DOF) from it (:func:`powderline.symmetry.analyze_site`),
-    rejects ambiguous positions and stated multiplicities that don't match, and
-    replaces stated coordinates with the canonical ones (keeping each refine
-    flag and bounds), so every engine receives the same exact structure. Each
-    adjustment is reported by :meth:`warnings` (A73). The unit cell must fit the
-    space group exactly (A77), and anisotropic ADPs the site symmetry (A78).
+    atom's site (multiplicity, DOF) from it (:func:`powderline.symmetry.analyze_site`)
+    and rejects ambiguous positions and stated multiplicities that don't match.
+    The unit cell must fit the space group exactly (A77).
+
+    **Validation never changes a recipe** (A115): the recipe is the record of the
+    refinement intent, so every value must already be exactly what the engines
+    use. A special position must be stated exactly (A73), an anisotropic ADP
+    exactly site-symmetric (A78), and tied bounds must follow their tie exactly
+    (A108). Otherwise it is an error that gives the exact value to write.
+    "Exactly" means to floating-point precision
+    (:data:`~powderline.symmetry.ADJUSTMENT_REPORT_TOL`), because a JSON number
+    cannot hold 1/3: ``0.3333333333333333`` is the value to write.
 
     Refine flags and bounds must agree with the symmetry ties
     (:func:`~powderline.symmetry.cell_tie_groups`,
-    :func:`~powderline.symmetry.coupling_groups`; A94, A95, A98, A106, A108):
+    :func:`~powderline.symmetry.coupling_groups`; A94, A95, A98, A106):
     the members of one tie group carry the same flag (F1); a symmetry-fixed
     parameter has flag false (F2) and no bounds (A106); different groups are
     independent (F3); with bounds, each member's bounds follow the tie's
     relation from the first member's (F4: ``member = k*rep + c`` maps
-    ``[min, max]`` to ``[k*min + c, k*max + c]``, swapped for k < 0; within the
-    family's value tolerance they are set exactly and reported). A value moved
-    by canonicalization is re-checked against its bounds (review N4). Atoms on
+    ``[min, max]`` to ``[k*min + c, k*max + c]``, swapped for k < 0). Atoms on
     the same site are independent (A104).
 
     Every problem is reported at its own location (A70): ``unit_cell``,
@@ -777,7 +797,6 @@ class Phase(CoreModel, Generic[P]):
     These checks run only once every field is valid: pydantic does not run
     model-level validators after a field error, so e.g. an unknown element is
     reported first, and the symmetry checks follow once it is fixed.
-    Validation never modifies the caller's objects; adjusted atoms are copies.
     """
 
     space_group: str = Field(description="gemmi's canonical extended Hermann-Mauguin name, e.g. "
@@ -788,7 +807,6 @@ class Phase(CoreModel, Generic[P]):
         description="Atoms keyed by unique label: a letter, then ASCII letters, digits or '_'")
 
     _sites: dict = PrivateAttr(default_factory=dict)
-    _warnings: list = PrivateAttr(default_factory=list)
 
     @classmethod
     def __pydantic_init_subclass__(cls, **kwargs: Any) -> None:
@@ -821,6 +839,24 @@ def __pydantic_init_subclass__(cls, **kwargs: Any) -> None:
                 )
         if cls.model_config.get("extra") != "forbid":
             raise TypeError(f"{cls.__name__} must keep extra='forbid' (A19)")
+        if cls.__pydantic_generic_metadata__["parameters"] and "__orig_bases__" not in cls.__dict__:
+            # ``class EnginePhase(Phase)`` forgot the parameter type. A deliberately generic
+            # subclass declares ``Generic[P]`` and is checked again when it is validated.
+            raise TypeError(_OPEN_PARAMETER_TYPE.format(name=cls.__name__))
+
+    @model_validator(mode="before")
+    @classmethod
+    def _parameter_type_chosen(cls, data: Any) -> Any:
+        """Refuse to validate without a parameter type (re/03b review A2).
+
+        Unparametrized, ``P`` would accept both parameter shapes, so one phase could
+        mix ``[value, flag]`` and ``[value, flag, min, max]``. An engine schema fixes
+        one type; this is a programming error, so it is a ``TypeError``, not a
+        validation error.
+        """
+        if cls.__pydantic_generic_metadata__["parameters"]:
+            raise TypeError(_OPEN_PARAMETER_TYPE.format(name=cls.__name__))
+        return data
 
     @field_validator("space_group")
     @classmethod
@@ -836,16 +872,9 @@ def problem(loc: tuple, message: str, value: Any) -> None:
             problems.append(InitErrorDetails(type="value_error", loc=loc, input=value,
                                              ctx={"error": ValueError(message)}))
 
-        def apply_tie_rules(loc: tuple, params: dict, ties: Ties, context: str, tolerance, fixed_value) -> dict:
-            errors, updates, adjusted = _tie_rules(params, ties, context, tolerance, fixed_value)
-            for name, message in errors:
+        def tie_rules(loc: tuple, params: dict, ties: Ties, context: str, fixed_value) -> None:
+            for name, message in _tie_rules(params, ties, context, fixed_value):
                 problem((*loc, name), message, params[name].model_dump())
-            for name, message in adjusted:
-                self._warnings.append(StructuredWarning(
-                    code="tied_bounds_adjusted", message=message,
-                    field_path=".".join((*loc, name)),
-                ))
-            return updates
 
         sg = self.space_group
         cell = self.unit_cell
@@ -855,23 +884,30 @@ def apply_tie_rules(loc: tuple, params: dict, ties: Ties, context: str, toleranc
             problem(("unit_cell",), str(exc), cell.model_dump())
         else:  # flag and bound rules need a valid cell (A95, A98)
             ties = cell_tie_groups(sg)
-            updates = apply_tie_rules(("unit_cell",), {k: getattr(cell, k) for k in _CELL_FIELDS}, ties,
-                                      f"{ties.crystal_system} cell ({sg!r})", _cell_bound_tolerance,
-                                      lambda name: f"{getattr(cell, name).value:g}")
-            if updates:
-                self.unit_cell = cell.model_copy(update=updates)
-        for label, atom in list(self.atoms.items()):
+            tie_rules(("unit_cell",), {k: getattr(cell, k) for k in _CELL_FIELDS}, ties,
+                      f"{ties.crystal_system} cell ({sg!r})", lambda name: f"{getattr(cell, name).value:g}")
+        for label, atom in self.atoms.items():
             try:
                 site = analyze_site(sg, (atom.x.value, atom.y.value, atom.z.value))
             except SymmetryError as exc:
                 problem(("atoms", label), str(exc), atom.model_dump())
                 continue  # the checks below need the site
-            update: dict[str, Any] = {}
+            self._sites[label] = site
+            context = f"atom {label!r} (multiplicity {site.multiplicity} in {sg!r})"
+            ties = coupling_groups(sg, site.canonical)
+            exact_xyz = lambda name: site.exact["xyz".index(name)]  # noqa: E731
+            if site.adjusted:  # A73, A115: on a special position, but not exactly
+                off = max(abs(c - v) for c, v in zip(site.canonical, site.stated))
+                problem(("atoms", label),
+                        f"{context}: {site.stated} is {off:.2g} from a special position, not on it "
+                        f"({_ties_text(ties.xyz, exact_xyz)}); write "
+                        f"{_values_to_write(ties.xyz, dict(zip('xyz', site.stated)), exact_xyz)}",
+                        atom.model_dump())
             if atom.Multiplicity is not None and atom.Multiplicity != site.multiplicity:
                 problem(("atoms", label, "Multiplicity"),
                         f"stated Multiplicity {atom.Multiplicity}, derived {site.multiplicity} "
                         f"({sg!r}, site {site.stated})", atom.Multiplicity)
-            uaniso_ok = u_adjusted = False
+            uaniso_ok = False
             if atom.Uaniso is not None:
                 stated_u = tuple(getattr(atom.Uaniso, k).value for k in _UANISO_KEYS)
                 try:
@@ -880,54 +916,19 @@ def apply_tie_rules(loc: tuple, params: dict, ties: Ties, context: str, toleranc
                     problem(("atoms", label, "Uaniso"), str(exc), atom.model_dump()["Uaniso"])
                 else:
                     uaniso_ok = True
-                    if u_adjusted:
-                        update["Uaniso"] = atom.Uaniso.model_copy(update={
-                            k: _with_value(getattr(atom.Uaniso, k), u) for k, u in zip(_UANISO_KEYS, symmetric_u)})
-                        self._warnings.append(StructuredWarning(
-                            code="adp_symmetry_adjusted",
-                            message=(f"atom {label!r}: Uaniso {dict(zip(_UANISO_KEYS, stated_u))} "
-                                     f"adjusted to the site-symmetric values "
-                                     f"{dict(zip(_UANISO_KEYS, symmetric_u))}"),
-                            field_path=f"atoms.{label}.Uaniso",
-                        ))
-            self._sites[label] = site
-            if site.adjusted:
-                update.update({k: _with_value(getattr(atom, k), v) for k, v in zip("xyz", site.canonical)})
-                self._warnings.append(StructuredWarning(
-                    code="special_position_adjusted",
-                    message=(f"atom {label!r}: coordinates {site.stated} are on a special position "
-                             f"(multiplicity {site.multiplicity}); using the exact values "
-                             f"{site.canonical}"),
-                    field_path=f"atoms.{label}",
-                ))
-
-            # Flag and bound rules F1, F2, F4, A106 (A95, A98, A106, A108) on the canonical values.
-            ties = coupling_groups(sg, site.canonical)
-            context = f"atom {label!r} (multiplicity {site.multiplicity} in {sg!r})"
-            xyz = {k: update.get(k, getattr(atom, k)) for k in "xyz"}
-            update.update(apply_tie_rules(("atoms", label), xyz, ties.xyz, context,
-                                          lambda _name, _expected: SPECIAL_POSITION_TOL,
-                                          lambda name: str(site.exact["xyz".index(name)])))
+                    if u_adjusted:  # A78, A115: within 1e-6 A^2 of symmetric, but not exactly
+                        problem(("atoms", label, "Uaniso"),
+                                f"{context}: Uaniso is not exactly site-symmetric "
+                                f"({_ties_text(ties.uij, lambda _name: 0)}); write "
+                                f"{_values_to_write(ties.uij, dict(zip(_UANISO_KEYS, stated_u)), lambda _n: 0)}",
+                                atom.model_dump()["Uaniso"])
+
+            # Flag and bound rules F1, F2, F4, A106 (A95, A98, A106).
+            tie_rules(("atoms", label), {k: getattr(atom, k) for k in "xyz"}, ties.xyz, context,
+                      lambda name: str(exact_xyz(name)))
             if uaniso_ok:
-                uaniso = update.get("Uaniso", atom.Uaniso)
-                bounds = apply_tie_rules(("atoms", label, "Uaniso"), {k: getattr(uaniso, k) for k in _UANISO_KEYS},
-                                         ties.uij, context, lambda _name, _expected: UIJ_TOL, lambda _name: "0")
-                if bounds:
-                    update["Uaniso"] = uaniso.model_copy(update=bounds)
-
-            # Review N4: a value moved by canonicalization is re-checked against its (final) bounds.
-            moved = [(("atoms", label, k), k, update.get(k, getattr(atom, k)), getattr(atom, k).value,
-                      "the exact special-position value") for k in "xyz" if site.adjusted]
-            if u_adjusted and uaniso_ok:
-                moved += [(("atoms", label, "Uaniso", k), k, getattr(update["Uaniso"], k), getattr(atom.Uaniso, k).value,
-                           "the site-symmetric value") for k in _UANISO_KEYS]
-            for loc, name, param, stated, what in moved:
-                message = _canonical_out_of_bounds(param)
-                if message:
-                    problem(loc, f"{context}: {name} = {param.value!r} ({what} of the stated {stated!r}) "
-                                 f"{message}", param.model_dump())
-            if update:
-                self.atoms[label] = atom.model_copy(update=update)
+                tie_rules(("atoms", label, "Uaniso"), {k: getattr(atom.Uaniso, k) for k in _UANISO_KEYS},
+                          ties.uij, context, lambda _name: "0")
         if problems:
             raise ValidationError.from_exception_data(type(self).__name__, problems)
         return self
@@ -936,10 +937,6 @@ def site(self, label: str):
         """The :class:`~powderline.symmetry.SiteAnalysis` of atom ``label``."""
         return self._sites[label]
 
-    def warnings(self) -> list:
-        """Structured warnings raised while validating this phase (paths relative to it)."""
-        return list(self._warnings)
-
 
 def _reserved_phase_members() -> frozenset[str]:
     """Names core's :class:`Phase` defines besides its fields: validators, private attributes, methods."""
@@ -956,24 +953,42 @@ def _reserved_phase_members() -> frozenset[str]:
 _CELL_FIELDS = ("a", "b", "c", "alpha", "beta", "gamma")
 
 
-def _with_value(param, value: float):
-    """A copy of ``param`` with a new value; refine flag and bounds kept."""
-    return param.model_copy(update={"value": value})
+def _same(got: float, want: float) -> bool:
+    """Equal to floating-point precision (``ADJUSTMENT_REPORT_TOL``, relative above 1)."""
+    return abs(got - want) <= ADJUSTMENT_REPORT_TOL * max(1.0, abs(want))
 
 
-def _cell_bound_tolerance(name: str, expected: float) -> float:
-    """A108 for the cell: CELL_TOL relative on lengths, in degrees on angles (A77)."""
-    return CELL_TOL * abs(expected) if name in ("a", "b", "c") else CELL_TOL
+def _ties_text(ties: Ties, exact) -> str:
+    """The symmetry relations of a parameter set, e.g. ``"x = 1/3, y = 2/3"`` or ``"y = 2x"``."""
+    parts = [f"{name} = {exact(name)}" for name in ties.fixed]
+    parts += [g.relations_text() for g in ties.groups if g.relations_text()]
+    return ", ".join(parts)
+
+
+def _values_to_write(ties: Ties, stated: dict, exact) -> str:
+    """``"y = 0.2468"``: the values that make ``stated`` exactly symmetric, where they differ.
+
+    Each tie group keeps its first member's stated value (the one parameter,
+    A94) and derives the others from it; fixed parameters take their exact
+    value. ``repr`` of a float reads back as the same float, so a value can be
+    copied into a recipe as-is (``0.3333333333333333`` for 1/3).
+    """
+    target = {name: float(exact(name)) for name in ties.fixed}
+    for group in ties.groups:
+        rep = stated[group.members[0]]
+        target.update({name: float(k) * rep + float(c)
+                       for name, k, c in zip(group.members, group.coefficients, group.offsets)})
+    return ", ".join(f"{name} = {target[name]!r}" for name in stated if not _same(stated[name], target[name]))
 
 
 def _fmt_bounds(lo: Optional[float], hi: Optional[float]) -> str:
-    return "[" + ", ".join("null" if v is None else f"{v:.10g}" for v in (lo, hi)) + "]"
+    return "[" + ", ".join("null" if v is None else repr(v) for v in (lo, hi)) + "]"
 
 
 _HOW_MANY = {2: "both", 3: "all three"}
 
 
-def _tie_rules(params: dict, ties: Ties, context: str, tolerance, fixed_value):
+def _tie_rules(params: dict, ties: Ties, context: str, fixed_value) -> list[tuple[str, str]]:
     """The flag and bound rules of one parameter set (cell, a site's x/y/z, or its Uij).
 
     - **F2** (A95): a symmetry-fixed parameter has refine flag false.
@@ -981,19 +996,16 @@ def _tie_rules(params: dict, ties: Ties, context: str, tolerance, fixed_value):
     - **F1** (A95): the members of a tie group carry the same flag. The error is
       reported at every member whose flag differs from the group's first
       member, naming the whole group (review N1).
-    - **F4** (A98, A108): with bounds, each member's bounds follow the tie from
+    - **F4** (A98, A115): with bounds, each member's bounds follow the tie from
       the first member's: ``member = k*rep + c`` maps ``[min, max]`` to
       ``[k*min + c, k*max + c]``, swapped for k < 0; a null side stays null on
-      the matching side. Within ``tolerance(name, expected)`` the member's
-      bounds are replaced by the exact values (reported); beyond, an error.
+      the matching side. Anything but the exact mapped bounds (to floating-point
+      precision) is an error giving them.
     - **F3**: different groups are independent (nothing to check).
 
-    Returns ``(errors, updates, adjusted)``: ``[(name, message)]``, the bound
-    updates ``{name: param}``, and ``[(name, message)]`` for the adjustments.
+    Returns ``[(name, message)]``.
     """
     errors: list[tuple[str, str]] = []
-    adjusted: list[tuple[str, str]] = []
-    updates: dict[str, Any] = {}
     for name in ties.fixed:
         param = params[name]
         if param.refine_flag:
@@ -1021,39 +1033,13 @@ def _tie_rules(params: dict, ties: Ties, context: str, tolerance, fixed_value):
             lo, hi = (None if v is None else k * v + c for v in (rep.min, rep.max))
             if k < 0:
                 lo, hi = hi, lo
-            ok, exact = True, True
-            for got, want in ((param.min, lo), (param.max, hi)):
-                if (got is None) != (want is None):
-                    ok = False
-                elif got is not None:
-                    ok = ok and abs(got - want) <= tolerance(name, want)
-                    exact = exact and abs(got - want) <= 1e-12
-            if not ok:
+            if not all((got is None and want is None) or (got is not None and want is not None and _same(got, want))
+                       for got, want in ((param.min, lo), (param.max, hi))):
                 errors.append((name, f"{context}: the bounds of {name} must follow "
                                      f"{group.relation_text(name)} from the bounds of {group.members[0]} "
-                                     f"{_fmt_bounds(rep.min, rep.max)}: expected {_fmt_bounds(lo, hi)}, "
-                                     f"got {_fmt_bounds(param.min, param.max)}"))
-            elif not exact:
-                updates[name] = param.model_copy(update={"min": lo, "max": hi})
-                adjusted.append((name, f"{context}: the bounds of {name} {_fmt_bounds(param.min, param.max)} "
-                                       f"were set to {_fmt_bounds(lo, hi)}, exactly "
-                                       f"{group.relation_text(name)} from the bounds of {group.members[0]}"))
-    return errors, updates, adjusted
-
-
-def _canonical_out_of_bounds(param) -> Optional[str]:
-    """Review N4: ``"is below min (...)"`` etc. when a moved value left its bounds, else ``None``.
-
-    Floating-point noise (1e-12) is not a move: canonicalization keeps a value
-    within that of the stated one as stated.
-    """
-    if not isinstance(param, BoundedRefinableParameter):
-        return None
-    if param.min is not None and param.value < param.min - 1e-12:
-        return f"is below min ({param.min!r})"
-    if param.max is not None and param.value > param.max + 1e-12:
-        return f"is above max ({param.max!r})"
-    return None
+                                     f"{_fmt_bounds(rep.min, rep.max)}: write {_fmt_bounds(lo, hi)}, "
+                                     f"not {_fmt_bounds(param.min, param.max)}"))
+    return errors
 
 
 # --- top-level recipe frame (A1, A18, A21, A40) ------------------------------
diff --git a/tests/test_gateways.py b/tests/test_gateways.py
index f54a128..9b2faff 100644
--- a/tests/test_gateways.py
+++ b/tests/test_gateways.py
@@ -485,10 +485,10 @@ def find_spec(self, name, path, target=None):
     "space_group": "P 63/m m c",
     "unit_cell": {{"a": p(3.0, True), "b": p(3.0, True), "c": p(5.0), "alpha": p(90.0), "beta": p(90.0),
                   "gamma": p(120.0)}},
-    "atoms": {{"C": {{"element": "C", "x": p(0.166667, True), "y": p(0.333333, True), "z": p(0.25),
+    "atoms": {{"C": {{"element": "C", "x": p(1 / 6, True), "y": p(1 / 3, True), "z": p(0.25),
                      "occupancy": p(1.0), "ADP": "Uiso", "Uiso": p(0.01)}}}},
 }})
-assert phase.site("C").multiplicity == 6 and phase.warnings()
+assert phase.site("C").multiplicity == 6 and phase.atoms["C"].x.value == 1 / 6
 
 recipes = {{
     "gsasii": json.loads(Path(r'{recipe_path}').read_text(encoding="utf-8")),
diff --git a/tests/test_schema_core.py b/tests/test_schema_core.py
index 78c47f3..aaffc24 100644
--- a/tests/test_schema_core.py
+++ b/tests/test_schema_core.py
@@ -850,9 +850,10 @@ def _valid_pmm_lab6_phase_dict():
 
 
 def test_phase_valid_validates():
-    """Valid phase validates with no warnings."""
-    phase = Phase[RefinableParameter].model_validate(_valid_pmm_lab6_phase_dict())
-    assert phase.warnings() == []
+    """A valid phase validates and holds exactly the stated values (validation never changes them)."""
+    d = _valid_pmm_lab6_phase_dict()
+    phase = Phase[RefinableParameter].model_validate(d)
+    assert phase.model_dump() == d
 
 
 def test_phase_site_multiplicity():
@@ -1091,8 +1092,9 @@ def test_phase_space_group_r3m_hexagonal_accepted():
     assert phase.space_group == "R -3 m:H"
 
 
-def test_phase_special_position_adjusted():
-    """Phase: P 63/m m c atom at (0.333333,0.666667,0.25) adjusted to 1/3,2/3,1/4."""
+def test_phase_special_position_not_exact_rejected():
+    """A115: (0.333333, 0.666667, 0.25) is on 2c but not exactly: an error giving the values to write.
+    Writing them (repr of the float) validates, and the phase holds them unchanged."""
     d = {
         "space_group": "P 63/m m c",
         "unit_cell": {"a": [3.2, False], "b": [3.2, False], "c": [5.2, False], "alpha": [90, False], "beta": [90, False], "gamma": [120, False]},
@@ -1100,19 +1102,15 @@ def test_phase_special_position_adjusted():
             "A1": {"element": "O", "x": [0.333333, False], "y": [0.666667, False], "z": [0.25, False], "occupancy": [1.0, False], "ADP": "Uiso", "Uiso": [0.01, False]}
         },
     }
+    with pytest.raises(ValidationError) as exc_info:
+        Phase[RefinableParameter].model_validate(d)
+    assert _errs(exc_info) == [(("atoms", "A1"),
+                                "atom 'A1' (multiplicity 2 in 'P 63/m m c'): (0.333333, 0.666667, 0.25) is 3.3e-07 "
+                                "from a special position, not on it (x = 1/3, y = 2/3, z = 1/4); "
+                                "write x = 0.3333333333333333, y = 0.6666666666666666")]
+    d["atoms"]["A1"]["x"][0], d["atoms"]["A1"]["y"][0] = json.loads("[0.3333333333333333, 0.6666666666666666]")
     phase = Phase[RefinableParameter].model_validate(d)
-    # Check coordinates are exact fractions (now need to read .value)
-    assert phase.atoms["A1"].x.value == 1/3
-    assert phase.atoms["A1"].y.value == 2/3
-    # Check refine flags are preserved
-    assert phase.atoms["A1"].x.refine_flag is False
-    assert phase.atoms["A1"].y.refine_flag is False
-    # Check warning
-    warnings = phase.warnings()
-    assert len(warnings) == 1
-    assert warnings[0]["code"] == "special_position_adjusted"
-    assert "A1" in warnings[0]["message"]
-    assert warnings[0]["field_path"] == "atoms.A1"
+    assert phase.model_dump() == d
 
 
 def test_phase_special_position_ambiguous_rejected():
@@ -1204,7 +1202,7 @@ def test_phase_uaniso_cubic_m3m_isotropic_accepted():
     d["atoms"]["La1"]["Uaniso"] = {"U11": [0.01, False], "U22": [0.01, False], "U33": [0.01, False], "U12": [0, False], "U13": [0, False], "U23": [0, False]}
     del d["atoms"]["La1"]["Uiso"]
     phase = Phase[RefinableParameter].model_validate(d)
-    assert phase.warnings() == []
+    assert phase.atoms["La1"].Uaniso.model_dump() == d["atoms"]["La1"]["Uaniso"]
 
 
 def test_phase_uaniso_cubic_m3m_anisotropic_rejected():
@@ -1217,43 +1215,28 @@ def test_phase_uaniso_cubic_m3m_anisotropic_rejected():
         Phase[RefinableParameter].model_validate(d)
 
 
-def test_phase_uaniso_hexagonal_6h_adjusted():
-    """Phase: P 63/m m c, site 6h, Uaniso with U11=U22/2 adjusted and reported."""
+def test_phase_uaniso_hexagonal_6h_not_exact_rejected():
+    """A115: at 6h U12 = U22/2; a U12 within 1e-6 of it but not exact is an error giving the value
+    derived from the stated U22. Writing it validates."""
     d = {
         "space_group": "P 63/m m c",
         "unit_cell": {"a": [3.2, False], "b": [3.2, False], "c": [5.2, False], "alpha": [90, False], "beta": [90, False], "gamma": [120, False]},
         "atoms": {
             "A1": {
-                "element": "O",
-                "x": [0.2, False],
-                "y": [0.4, False],
-                "z": [0.25, False],
-                "occupancy": [1.0, False],
-                "ADP": "Uaniso",
-                "Uaniso": {
-                    "U11": [0.012, False],
-                    "U22": [0.012347, False],
-                    "U33": [0.02, False],
-                    "U12": [0.006174, False],
-                    "U13": [0.0, False],
-                    "U23": [0.0, False],
-                },
+                "element": "O", "x": [0.2, False], "y": [0.4, False], "z": [0.25, False],
+                "occupancy": [1.0, False], "ADP": "Uaniso",
+                "Uaniso": {"U11": [0.012, False], "U22": [0.012347, False], "U33": [0.02, False],
+                           "U12": [0.006174, False], "U13": [0.0, False], "U23": [0.0, False]},
             }
         },
     }
-    phase = Phase[RefinableParameter].model_validate(d)
-    # Check U11 stayed (now need to read .value)
-    assert phase.atoms["A1"].Uaniso.U11.value == 0.012  # free: returned exactly as stated
-    # Check U12 became U22/2 (reading .value)
-    u22 = phase.atoms["A1"].Uaniso.U22.value
-    u12 = phase.atoms["A1"].Uaniso.U12.value
-    assert abs(u12 - u22 / 2) < 1e-15
-    # Check refine flags are preserved
-    assert phase.atoms["A1"].Uaniso.U11.refine_flag is False
-    assert phase.atoms["A1"].Uaniso.U12.refine_flag is False
-    # Check warning
-    warnings = phase.warnings()
-    assert any(w["code"] == "adp_symmetry_adjusted" for w in warnings)
+    with pytest.raises(ValidationError) as exc_info:
+        Phase[RefinableParameter].model_validate(d)
+    assert _errs(exc_info) == [(("atoms", "A1", "Uaniso"),
+                                "atom 'A1' (multiplicity 6 in 'P 63/m m c'): Uaniso is not exactly site-symmetric "
+                                "(U13 = 0, U23 = 0, U12 = U22/2); write U12 = 0.0061735")]
+    d["atoms"]["A1"]["Uaniso"]["U12"][0] = 0.0061735
+    assert Phase[RefinableParameter].model_validate(d).model_dump() == d
 
 
 def test_phase_multiple_atom_problems_all_reported():
@@ -1324,18 +1307,16 @@ class Payload(BaseModel):
     assert _errors(exc_info) == [(("structure", "atoms", "B1", "Multiplicity"), "value_error")]
 
 
-def test_phase_does_not_modify_caller_atoms():
-    """Canonicalization replaces the atom in the structure; the caller's Atom is untouched."""
-    atom = Atom[RefinableParameter].model_validate({"element": "C", "x": [0.3333333, False], "y": [0.6666667, False], "z": [0.25, False],
+def test_phase_holds_the_callers_atoms_unchanged():
+    """Validation never changes a value, so the validated phase holds the caller's atom as given."""
+    atom = Atom[RefinableParameter].model_validate({"element": "C", "x": [1 / 3, False], "y": [2 / 3, False], "z": [0.25, False],
                                 "occupancy": [1.0, False], "ADP": "Uiso", "Uiso": [0.01, False]})
     phase = Phase[RefinableParameter].model_validate({
         "space_group": "P 63/m m c",
         "unit_cell": {"a": [3.2, False], "b": [3.2, False], "c": [5.2, False], "alpha": [90, False], "beta": [90, False], "gamma": [120, False]},
         "atoms": {"C1": atom},
     })
-    assert (atom.x.value, atom.y.value) == (0.3333333, 0.6666667)
-    assert (phase.atoms["C1"].x.value, phase.atoms["C1"].y.value) == (1 / 3, 2 / 3)
-    assert phase.atoms["C1"] is not atom
+    assert phase.atoms["C1"] is atom
 
 
 # --- Phase[P]: the phase block (re/03b; A93-A96, A100, A105) -----------------
@@ -1462,14 +1443,14 @@ def test_phase_reserved_members_are_core_validators_private_attributes_and_metho
     """Pinned, so a new core validator or method is seen to be reserved too (review A1)."""
     from powderline.schema_core import _reserved_phase_members
 
-    assert _reserved_phase_members() == {"_space_group", "_sites_check", "_sites", "_warnings", "site", "warnings"}
+    assert _reserved_phase_members() == {"_parameter_type_chosen", "_space_group", "_sites_check", "_sites", "site"}
 
 
 @pytest.mark.parametrize("name, body", [
     ("_space_group", "@field_validator('space_group')\n@classmethod\ndef _space_group(cls, v):\n    return v"),
     ("_sites_check", "@model_validator(mode='after')\ndef _sites_check(self):\n    return self"),
     ("site", "def site(self, label):\n    return None"),
-    ("_warnings", "_warnings: list = PrivateAttr(default_factory=list)"),
+    ("_sites", "_sites: dict = PrivateAttr(default_factory=dict)"),
 ])
 def test_phase_core_validator_or_method_cannot_be_reused(name, body):
     """A same-named engine validator would silently replace core's (pydantic collects them by name)."""
@@ -1484,6 +1465,42 @@ def test_phase_core_validator_or_method_cannot_be_reused(name, body):
         "private attribute would replace core's silently; rename it")
 
 
+_OPEN_TYPE = ("has no parameter type: subclass Phase[RefinableParameter] (no bounds) or "
+              "Phase[BoundedRefinableParameter] (bounds); a deliberately generic subclass declares "
+              "Generic[P] and is parametrized before use")
+
+
+def test_phase_without_parameter_type_cannot_validate():
+    """Unparametrized, one phase could mix [value, flag] and [value, flag, min, max] (review A2)."""
+    d = _valid_pmm_lab6_phase_dict()
+    d["unit_cell"]["a"] = [4.15692, False, 4.0, 4.3]
+    with pytest.raises(TypeError) as exc_info:
+        Phase.model_validate(d)
+    assert str(exc_info.value) == f"Phase {_OPEN_TYPE}"
+
+
+def test_engine_subclass_must_choose_a_parameter_type():
+    with pytest.raises(TypeError) as exc_info:
+        class EnginePhase(Phase):
+            pass
+    assert str(exc_info.value) == f"EnginePhase {_OPEN_TYPE}"
+
+
+def test_generic_engine_subclass_validates_once_parametrized():
+    from typing import Generic
+
+    from powderline.schema_core import P
+
+    class EnginePhase(Phase[P], Generic[P]):
+        scale: P
+
+    d = {**_valid_pmm_lab6_phase_dict(), "scale": [1.0, True]}
+    with pytest.raises(TypeError) as exc_info:
+        EnginePhase.model_validate(d)
+    assert str(exc_info.value) == f"EnginePhase {_OPEN_TYPE}"
+    assert EnginePhase[RP].model_validate(d).scale.model_dump() == [1.0, True]
+
+
 def test_phase_engine_subclass_must_keep_extra_forbid():
     with pytest.raises(TypeError) as exc_info:
         class EnginePhase(Phase[RP]):
@@ -1517,10 +1534,13 @@ class EnginePhase(Phase[RP]):
         scale: RP
 
     d = _valid_pmm_lab6_phase_dict()
-    d["atoms"]["B1"]["x"] = [0.4999999, False]
     phase = EnginePhase.model_validate({**d, "scale": [1.0, True]})
     assert phase.scale.model_dump() == [1.0, True]
-    assert phase.atoms["B1"].x.value == 0.5  # canonicalized by the core validator
+    d["atoms"]["B1"]["x"] = [0.4999999, False]
+    with pytest.raises(ValidationError) as exc_info:
+        EnginePhase.model_validate({**d, "scale": [1.0, True]})
+    assert _errors(exc_info) == [(("atoms", "B1"), "value_error")]  # the core symmetry rule runs
+    d["atoms"]["B1"]["x"] = [0.5, False]
     d["atoms"]["B1"]["Multiplicity"] = 12
     with pytest.raises(ValidationError) as exc_info:
         EnginePhase.model_validate({**d, "scale": [1.0, True]})
@@ -1618,17 +1638,6 @@ def test_phase_rejects_bounds_where_the_parameter_type_has_none():
     assert "bounds are not supported" in exc_info.value.errors()[0]["msg"]
 
 
-def test_bounded_phase_canonicalization_keeps_flag_and_bounds():
-    """Phase[BoundedRefinableParameter]: the canonical value replaces .value; flag and bounds stay."""
-    d = _bounded(_valid_pmm_lab6_phase_dict())
-    d["atoms"]["B1"]["x"] = [0.4999999, False, None, None]
-    d["atoms"]["B1"]["z"] = [0.2021, True, 0.15, 0.25]
-    phase = Phase[BRP].model_validate(d)
-    assert phase.atoms["B1"].x.model_dump() == [0.5, False, None, None]
-    assert phase.atoms["B1"].z.model_dump() == [0.2021, True, 0.15, 0.25]
-    assert [w["code"] for w in phase.warnings()] == ["special_position_adjusted"]
-
-
 def test_phase_value_rules_act_on_value():
     """Cell, occupancy and element rules read .value; each error at its own field (A70)."""
     d = _valid_pmm_lab6_phase_dict()
@@ -1959,7 +1968,6 @@ def test_affine_bounds_follow_the_tie_p_421m_4e(xyz, x_bounds, y_bounds):
                        {"x": x_bounds, "y": y_bounds})
     phase = Phase[BRP].model_validate(d)
     assert phase.atoms["A"].y.model_dump()[2:] == list(y_bounds)
-    assert phase.warnings() == []
 
 
 def test_affine_bounds_p42mnm_4f():
@@ -1980,7 +1988,7 @@ def test_bounds_not_following_the_tie_rejected_at_the_member():
         Phase[BRP].model_validate(d)
     assert _errs(exc_info) == [(("atoms", "A", "y"),
                                 "atom 'A' (multiplicity 4 in 'P -4 21 m'): the bounds of y must follow "
-                                "y = -x + 1/2 from the bounds of x [0, 0.2]: expected [0.3, 0.5], got [0.3, 0.51]")]
+                                "y = -x + 1/2 from the bounds of x [0.0, 0.2]: write [0.3, 0.5], not [0.3, 0.51]")]
 
 
 def test_bounds_open_side_must_match():
@@ -1988,28 +1996,23 @@ def test_bounds_open_side_must_match():
                        {"x": (0.0, 0.2), "y": (None, 0.5)})
     with pytest.raises(ValidationError) as exc_info:
         Phase[BRP].model_validate(d)
-    assert _errs(exc_info)[0][1].endswith("expected [0.3, 0.5], got [null, 0.5]")
+    assert _errs(exc_info)[0][1].endswith("write [0.3, 0.5], not [null, 0.5]")
 
 
-def test_tied_coordinate_bounds_within_tolerance_snapped_and_reported():
-    """A108: within 5e-6 the member's bounds become the exact mapped values, with a warning."""
+def test_tied_coordinate_bounds_not_exact_rejected():
+    """A115 (replaces A108's snap): tied bounds must be the exact mapped values, to floating-point
+    precision; 4e-6 off is an error giving them."""
     d = _bounded_phase("P -4 21 m", (5, 5, 4, 90, 90, 90), (0.1, 0.4, 0.3), (True, True, False),
                        {"x": (0.0, 0.2), "y": (0.300004, 0.5)})
-    phase = Phase[BRP].model_validate(d)
-    assert phase.atoms["A"].y.model_dump() == [0.4, True, 0.3, 0.5]
-    assert phase.warnings() == [{
-        "code": "tied_bounds_adjusted",
-        "message": "atom 'A' (multiplicity 4 in 'P -4 21 m'): the bounds of y [0.300004, 0.5] were set to "
-                   "[0.3, 0.5], exactly y = -x + 1/2 from the bounds of x",
-        "field_path": "atoms.A.y"}]
-    d["atoms"]["A"]["y"][2] = 0.300006
     with pytest.raises(ValidationError) as exc_info:
         Phase[BRP].model_validate(d)
-    assert [loc for loc, _m in _errs(exc_info)] == [("atoms", "A", "y")]
+    assert _errs(exc_info) == [(("atoms", "A", "y"),
+                                "atom 'A' (multiplicity 4 in 'P -4 21 m'): the bounds of y must follow "
+                                "y = -x + 1/2 from the bounds of x [0.0, 0.2]: write [0.3, 0.5], not [0.300004, 0.5]")]
 
 
 def test_tied_uij_bounds_factor_two():
-    """6h: U12 = U22/2, so U22 in [0, 0.02] gives U12 in [0, 0.01]; tolerance 1e-6 (A108)."""
+    """6h: U12 = U22/2, so U22 in [0, 0.02] gives U12 in [0, 0.01], exactly (A98, A115)."""
     values = (0.01, 0.012, 0.009, 0.006, 0.0, 0.0)
     flags = (True, True, True, True, False, False)
 
@@ -2018,33 +2021,28 @@ def phase(u12_bounds):
         a = _atomp((1 / 6, 1 / 3, 0.25), bounds={}, uaniso=_u(values, flags, bounds), element="C")
         return _phasep("P 63/m m c", _cellp(_HEX, bounds={}), {"C": a})
 
-    assert Phase[BRP].model_validate(phase((0.0, 0.01))).warnings() == []
-    snapped = Phase[BRP].model_validate(phase((0.0, 0.0100009)))
-    assert snapped.atoms["C"].Uaniso.U12.model_dump() == [0.006, True, 0.0, 0.01]
-    assert [w["field_path"] for w in snapped.warnings()] == ["atoms.C.Uaniso.U12"]
+    assert Phase[BRP].model_validate(phase((0.0, 0.01))).atoms["C"].Uaniso.U12.model_dump() == [0.006, True, 0.0, 0.01]
     with pytest.raises(ValidationError) as exc_info:
-        Phase[BRP].model_validate(phase((0.0, 0.0100011)))
+        Phase[BRP].model_validate(phase((0.0, 0.0100009)))
     assert _errs(exc_info) == [(("atoms", "C", "Uaniso", "U12"),
                                 "atom 'C' (multiplicity 6 in 'P 63/m m c'): the bounds of U12 must follow "
-                                "U12 = U22/2 from the bounds of U22 [0, 0.02]: expected [0, 0.01], "
-                                "got [0, 0.0100011]")]
+                                "U12 = U22/2 from the bounds of U22 [0.0, 0.02]: write [0.0, 0.01], "
+                                "not [0.0, 0.0100009]")]
 
 
-def test_tied_cell_bounds_equal_within_cell_tol():
-    """Cell ties are equalities; CELL_TOL is relative on lengths (A108, A77)."""
+def test_tied_cell_bounds_equal_exactly():
+    """Cell ties are equalities; equal to floating-point precision (relative above 1; A115)."""
     def phase(b_max):
         cell = _cellp((4, 4, 4, 90, 90, 90), (True, True, True, False, False, False),
                       {"a": (3.9, 4.2), "b": (3.9, b_max), "c": (3.9, 4.2)})
         return _phasep("P m -3 m", cell, {"A": _atomp(_GENERAL, bounds={})})
 
-    snapped = Phase[BRP].model_validate(phase(4.2 + 1e-9))
-    assert snapped.unit_cell.b.model_dump() == [4.0, True, 3.9, 4.2]
-    assert [w["field_path"] for w in snapped.warnings()] == ["unit_cell.b"]
+    assert Phase[BRP].model_validate(phase(4.2 + 1e-15)).unit_cell.b.model_dump() == [4.0, True, 3.9, 4.2 + 1e-15]
     with pytest.raises(ValidationError) as exc_info:
-        Phase[BRP].model_validate(phase(4.2001))
+        Phase[BRP].model_validate(phase(4.200000001))
     assert _errs(exc_info) == [(("unit_cell", "b"),
                                 "cubic cell ('P m -3 m'): the bounds of b must follow b = a from the bounds "
-                                "of a [3.9, 4.2]: expected [3.9, 4.2], got [3.9, 4.2001]")]
+                                "of a [3.9, 4.2]: write [3.9, 4.2], not [3.9, 4.200000001]")]
 
 
 def test_symmetry_fixed_parameters_have_no_bounds_a106():
@@ -2065,40 +2063,6 @@ def test_symmetry_fixed_parameters_have_no_bounds_a106():
     ]
 
 
-def test_canonical_value_rechecked_against_bounds_n4():
-    """Review N4: a stated value inside its bounds that canonicalizes outside them is an error.
-    6h (x, 2x, 1/4): y's bounds [0.199996, 0.4] are snapped to [0.2, 0.4] (A108); the least-change
-    canonical (x, y) of (0.1, 0.199996) is (0.0999984, 0.1999968), below both minima."""
-    d = _bounded_phase("P 63/m m c", _HEX, (0.1, 0.199996, 0.25), (True, True, False),
-                       {"x": (0.1, 0.2), "y": (0.199996, 0.4)})
-    with pytest.raises(ValidationError) as exc_info:
-        Phase[BRP].model_validate(d)
-    context = "atom 'A' (multiplicity 6 in 'P 63/m m c')"
-    assert _errs(exc_info) == [
-        (("atoms", "A", "x"), f"{context}: x = 0.0999984 (the exact special-position value of the stated 0.1) "
-                              "is below min (0.1)"),
-        (("atoms", "A", "y"), f"{context}: y = 0.1999968 (the exact special-position value of the stated "
-                              "0.199996) is below min (0.2)"),
-    ]
-
-
-def test_canonical_uij_rechecked_against_bounds_n4():
-    """N4 for A78: U12 stated just above U22/2 with U22 at its max: the least-change symmetric
-    values move both above their (snapped) maxima."""
-    bounds = {"U22": (0.0, 0.02), "U12": (0.0, 0.0100005)}
-    u = _u((0.01, 0.02, 0.009, 0.0100005, 0.0, 0.0), (False, True, False, True, False, False), bounds)
-    a = _atomp((1 / 6, 1 / 3, 0.25), bounds={}, uaniso=u, element="C")
-    with pytest.raises(ValidationError) as exc_info:
-        Phase[BRP].model_validate(_phasep("P 63/m m c", _cellp(_HEX, bounds={}), {"C": a}))
-    context = "atom 'C' (multiplicity 6 in 'P 63/m m c')"
-    assert _errs(exc_info) == [
-        (("atoms", "C", "Uaniso", "U22"), f"{context}: U22 = 0.020000200000000003 (the site-symmetric value "
-                                          "of the stated 0.02) is above max (0.02)"),
-        (("atoms", "C", "Uaniso", "U12"), f"{context}: U12 = 0.010000100000000001 (the site-symmetric value "
-                                          "of the stated 0.0100005) is above max (0.01)"),
-    ]
-
-
 # --- names and cell bound domain (re/03b review C5, C6) ----------------------
 
 
@@ -2141,11 +2105,34 @@ def test_names_unique_ignoring_case():
     assert str(exc_info.value) == "phase 'LaB6' and 'lab6' differ only in case; rename one"
 
 
+@pytest.mark.parametrize("label, message", [
+    ("None", "name 'None' is a Python keyword; choose another name"),
+    ("class", "name 'class' is a Python keyword; choose another name"),
+    ("O" * 65, f"name {'O' * 20!r}... has 65 characters; the limit is 64"),
+])
+def test_atom_label_is_an_identifier_of_bounded_length(label, message):
+    """Names are Python identifiers (no keywords) and at most 64 characters (file names)."""
+    d = _valid_pmm_lab6_phase_dict()
+    d["atoms"][label] = d["atoms"].pop("B1")
+    with pytest.raises(ValidationError) as exc_info:
+        Phase[RP].model_validate(d)
+    assert _errs(exc_info) == [(("atoms", label, "[key]"), message)]
+
+
+def test_atom_label_of_64_characters_accepted():
+    d = _valid_pmm_lab6_phase_dict()
+    d["atoms"]["B" * 64] = d["atoms"].pop("B1")
+    assert "B" * 64 in Phase[RP].model_validate(d).atoms
+
+
 def test_core_name_json_schema_constrains_every_key():
+    import keyword
+
     from powderline.schema_core import NAME_PATTERN
 
     atoms = Phase[RP].model_json_schema()["properties"]["atoms"]
-    assert atoms["propertyNames"] == {"pattern": NAME_PATTERN}
+    assert atoms["propertyNames"] == {"pattern": NAME_PATTERN, "maxLength": 64,
+                                      "not": {"enum": keyword.kwlist}}
     assert atoms["additionalProperties"] == {"$ref": "#/$defs/Atom"}
     assert "patternProperties" not in atoms
 

From 0b06b096476e83c9cca92c14f6b90fd1c9efc966 Mon Sep 17 00:00:00 2001
From: acorrao <95718914+AdamCorrao@users.noreply.github.com>
Date: Wed, 7 Oct 2026 16:15:32 -0400
Subject: [PATCH 10/14] feat(core): a non-positive-definite Uaniso is accepted
 with a warning (A118)

A Uaniso whose symmetric matrix has a principal value <= 0 describes no
thermal ellipsoid. Like a negative Uiso (A111), it can show that the
parameter compensates for something the model lacks, so it is accepted as
stated. It gets a structured warning, uaniso_not_positive_definite, at
atoms.<label>.Uaniso.

The sign test needs no cell: the Cartesian tensor is a congruence transform
of the Uij matrix (Sylvester's law of inertia). Phase.warnings() returns, for
informative findings only. The warning never comes with a changed value
(A115), so validating the same recipe again gives the same warning.

GSAS-II 5.7.9 has no such check (devkit EB-50).

Assisted-by: claude-code:claude-opus-5-5
---
 docs/SCHEMA_HISTORY.md        |  5 +++++
 src/powderline/schema_core.py | 34 +++++++++++++++++++++++++++++++++-
 tests/test_schema_core.py     | 33 ++++++++++++++++++++++++++++++++-
 3 files changed, 70 insertions(+), 2 deletions(-)

diff --git a/docs/SCHEMA_HISTORY.md b/docs/SCHEMA_HISTORY.md
index aa5a27e..14eb1b2 100644
--- a/docs/SCHEMA_HISTORY.md
+++ b/docs/SCHEMA_HISTORY.md
@@ -124,6 +124,11 @@ engine schemas adopt it in re/04–06.
     Anisotropic ADPs must respect the site symmetry exactly; otherwise it is an
     error, which within 1e-6 Ų gives the values to write (derived from each tie
     group's first component, e.g. `write U12 = 0.0061735` for `U12 = U22/2`).
+    A `Uaniso` that is not positive definite (a principal mean-square
+    displacement ≤ 0, so no thermal ellipsoid exists) is **accepted with a
+    structured warning** (`uaniso_not_positive_definite`), like a negative
+    `Uiso`: it can show that the parameter compensates for something the model
+    lacks (e.g. absorption). Engines carry it as given.
   - **Refinement intent follows the symmetry.** Parameters tied by symmetry
     are **one** parameter, and every member is stated: cubic `a, b, c`;
     tetragonal/hexagonal `a, b`; rhombohedral axes (`:R`) `a, b, c` and
diff --git a/src/powderline/schema_core.py b/src/powderline/schema_core.py
index 69b4161..d7c180f 100644
--- a/src/powderline/schema_core.py
+++ b/src/powderline/schema_core.py
@@ -50,7 +50,7 @@
 from pydantic.json_schema import DEFAULT_REF_TEMPLATE, GenerateJsonSchema, JsonSchemaMode
 from pydantic_core import InitErrorDetails, PydanticCustomError
 
-from powderline.exceptions import SymmetryError
+from powderline.exceptions import StructuredWarning, SymmetryError
 from powderline.symmetry import (
     ADJUSTMENT_REPORT_TOL,
     Ties,
@@ -797,6 +797,9 @@ class Phase(CoreModel, Generic[P]):
     These checks run only once every field is valid: pydantic does not run
     model-level validators after a field error, so e.g. an unknown element is
     reported first, and the symmetry checks follow once it is fixed.
+
+    :meth:`warnings` holds informative findings that change nothing: a
+    ``Uaniso`` that is not positive definite (A118).
     """
 
     space_group: str = Field(description="gemmi's canonical extended Hermann-Mauguin name, e.g. "
@@ -807,6 +810,7 @@ class Phase(CoreModel, Generic[P]):
         description="Atoms keyed by unique label: a letter, then ASCII letters, digits or '_'")
 
     _sites: dict = PrivateAttr(default_factory=dict)
+    _warnings: list = PrivateAttr(default_factory=list)
 
     @classmethod
     def __pydantic_init_subclass__(cls, **kwargs: Any) -> None:
@@ -916,6 +920,15 @@ def tie_rules(loc: tuple, params: dict, ties: Ties, context: str, fixed_value) -
                     problem(("atoms", label, "Uaniso"), str(exc), atom.model_dump()["Uaniso"])
                 else:
                     uaniso_ok = True
+                    principal = np.linalg.eigvalsh(_uij_matrix(stated_u))
+                    if principal[0] <= 0:  # informative, not an error (A118): never changes a value
+                        self._warnings.append(StructuredWarning(
+                            code="uaniso_not_positive_definite",
+                            message=(f"{context}: Uaniso is not positive definite (principal values "
+                                     f"{', '.join(f'{v:.3g}' for v in principal)} A^2), so it describes no "
+                                     "thermal ellipsoid; it is used as stated"),
+                            field_path=f"atoms.{label}.Uaniso",
+                        ))
                     if u_adjusted:  # A78, A115: within 1e-6 A^2 of symmetric, but not exactly
                         problem(("atoms", label, "Uaniso"),
                                 f"{context}: Uaniso is not exactly site-symmetric "
@@ -937,6 +950,14 @@ def site(self, label: str):
         """The :class:`~powderline.symmetry.SiteAnalysis` of atom ``label``."""
         return self._sites[label]
 
+    def warnings(self) -> list:
+        """Structured warnings from validating this phase (paths relative to it).
+
+        Informative only: a warning never comes with a changed value (A115), so
+        validating the same recipe again gives the same warnings.
+        """
+        return list(self._warnings)
+
 
 def _reserved_phase_members() -> frozenset[str]:
     """Names core's :class:`Phase` defines besides its fields: validators, private attributes, methods."""
@@ -953,6 +974,17 @@ def _reserved_phase_members() -> frozenset[str]:
 _CELL_FIELDS = ("a", "b", "c", "alpha", "beta", "gamma")
 
 
+def _uij_matrix(u) -> np.ndarray:
+    """The symmetric 3x3 matrix of (U11, U22, U33, U12, U13, U23).
+
+    Its eigenvalues have the signs of the Cartesian tensor's (a congruence
+    transform keeps them, Sylvester's law of inertia), so it tells whether the
+    thermal ellipsoid exists without the cell.
+    """
+    u11, u22, u33, u12, u13, u23 = u
+    return np.array([[u11, u12, u13], [u12, u22, u23], [u13, u23, u33]], dtype=float)
+
+
 def _same(got: float, want: float) -> bool:
     """Equal to floating-point precision (``ADJUSTMENT_REPORT_TOL``, relative above 1)."""
     return abs(got - want) <= ADJUSTMENT_REPORT_TOL * max(1.0, abs(want))
diff --git a/tests/test_schema_core.py b/tests/test_schema_core.py
index aaffc24..7a73f72 100644
--- a/tests/test_schema_core.py
+++ b/tests/test_schema_core.py
@@ -1443,7 +1443,8 @@ def test_phase_reserved_members_are_core_validators_private_attributes_and_metho
     """Pinned, so a new core validator or method is seen to be reserved too (review A1)."""
     from powderline.schema_core import _reserved_phase_members
 
-    assert _reserved_phase_members() == {"_parameter_type_chosen", "_space_group", "_sites_check", "_sites", "site"}
+    assert _reserved_phase_members() == {"_parameter_type_chosen", "_space_group", "_sites_check", "_sites",
+                                         "_warnings", "site", "warnings"}
 
 
 @pytest.mark.parametrize("name, body", [
@@ -2161,3 +2162,33 @@ def test_cell_open_bounds_and_positive_bounds_accepted():
                   bounds={"a": (8.0, 10.0), "b": (None, 6.0), "beta": (95.0, 115.0)})
     phase = Phase[BRP].model_validate(_phasep("C 1 2/m 1", cell, {"O": _atomp(_GENERAL, bounds={})}))
     assert phase.unit_cell.a.model_dump() == [9.0, True, 8.0, 10.0]
+
+
+# --- non-positive-definite Uaniso (A118) -------------------------------------
+
+
+def _p1_uaniso_phase(u):
+    keys = ("U11", "U22", "U33", "U12", "U13", "U23")
+    atom = {"element": "O", "x": [0.1, False], "y": [0.2, False], "z": [0.3, False], "occupancy": [1.0, False],
+            "ADP": "Uaniso", "Uaniso": {k: [v, False] for k, v in zip(keys, u)}}
+    return {"space_group": "P 1",
+            "unit_cell": {k: [v, False] for k, v in zip(_CELL_NAMES, (5.0, 6.0, 7.0, 80.0, 85.0, 95.0))},
+            "atoms": {"O1": atom}}
+
+
+def test_uaniso_not_positive_definite_warns_and_keeps_the_values():
+    """A118: informative, never an error or a change; the same recipe gives the same warning again."""
+    d = _p1_uaniso_phase((0.01, 0.01, 0.01, 0.02, 0.0, 0.0))  # principal values -0.01, 0.01, 0.03
+    phase = Phase[RP].model_validate(d)
+    assert phase.model_dump() == d
+    expected = [{"code": "uaniso_not_positive_definite",
+                 "message": "atom 'O1' (multiplicity 1 in 'P 1'): Uaniso is not positive definite (principal "
+                            "values -0.01, 0.01, 0.03 A^2), so it describes no thermal ellipsoid; it is used as stated",
+                 "field_path": "atoms.O1.Uaniso"}]
+    assert phase.warnings() == expected
+    assert Phase[RP].model_validate(phase.model_dump()).warnings() == expected
+
+
+def test_uaniso_positive_definite_gives_no_warning():
+    phase = Phase[RP].model_validate(_p1_uaniso_phase((0.01, 0.012, 0.009, 0.002, -0.001, 0.0005)))
+    assert phase.warnings() == []

From 5994fd08aad56a24a83839431cbac3ebe25abd97 Mon Sep 17 00:00:00 2001
From: acorrao <95718914+AdamCorrao@users.noreply.github.com>
Date: Wed, 7 Oct 2026 17:16:39 -0400
Subject: [PATCH 11/14] feat(core): thirds are stated to 6 decimals;
 decimal-form values exactly (A120)

This refines A115, following the maintainer's rule. A value that has an
exact decimal form is written exactly: 0.5, 0.25, 0.125, coupled
coordinates such as y = 2x, every Uij relation and every cell tie.
0.4999999 is an error ("write 0.5").

A value with no exact decimal form cannot be written exactly. It is stated
to at least 6 decimals (within A73's 5e-6) and read as the exact value. In
crystallographic symmetry this always means a third: 0.333333 = 1/3,
0.166667 = 1/6, or a coupled member y = x + 1/3 and its bounds. This was
checked over all 564 settings and every distinct special site: fixed
denominators are 1, 2, 3, 4, 6, 8 and 12; tie factors are +-1, +-2 and
+-1/2; offset denominators are 1 to 4; Uij offsets are 0.

- The rule is applied per coordinate, from the stated tie-group
  representative, which is never changed.
- The reading carries no warning: it is the documented meaning of the
  recipe. A dump (0.3333333333333333) means the same thing and validates the
  same way.
- The caller's atom is untouched; the phase holds a copy.
- The 5e-6..2e-3 band error is unchanged.
- Errors give the values to write: exact values with repr; thirds to 6
  decimals.

Assisted-by: claude-code:claude-opus-5-5
---
 docs/SCHEMA_HISTORY.md        |  36 ++++----
 src/powderline/schema_core.py | 151 +++++++++++++++++++++++++---------
 tests/test_schema_core.py     |  66 +++++++++++++--
 3 files changed, 187 insertions(+), 66 deletions(-)

diff --git a/docs/SCHEMA_HISTORY.md b/docs/SCHEMA_HISTORY.md
index 14eb1b2..111440b 100644
--- a/docs/SCHEMA_HISTORY.md
+++ b/docs/SCHEMA_HISTORY.md
@@ -71,12 +71,13 @@ engine schemas adopt it in re/04–06.
   on Windows and macOS), and problems are reported at `.`-joined paths
   (`atoms.O1.Uiso`). So `"2H-MoS2"` is written e.g. `MoS2_2H`.
   Structural interpretation is checked once, in core, so every engine gets the
-  same structure. **Validation never changes a recipe:** the recipe is the
-  record of the refinement intent, so every value must already be the exact
-  value the engines use. Where it is not, validation fails and the message
-  gives the value to write. "Exact" means to floating-point precision, because
-  a JSON number cannot hold 1/3: write `0.3333333333333333` (the shortest
-  decimal that reads back as the nearest float to 1/3). All problems are reported together, each at its own field
+  same structure. **Validation never changes what a recipe says:** the recipe
+  is the record of the refinement intent. A value that has an exact decimal
+  form must be written exactly (`0.5`, not `0.4999999`); otherwise validation
+  fails and the message gives the value to write. A value with no exact
+  decimal form (a third: 1/3, 1/6, 2/3, or a tie offset such as `x + 1/3`)
+  cannot be written exactly, so **6 decimals** state it (`0.333333` means 1/3)
+  and every engine receives the exact value. All problems are reported together, each at its own field
   (`unit_cell`, `atoms.<label>` for the position, `atoms.<label>.Multiplicity`,
   `atoms.<label>.Uaniso`, or the parameter a flag/bound rule concerns, e.g.
   `unit_cell.b`, `atoms.<label>.y`, `atoms.<label>.Uaniso.U12`); they are checked
@@ -106,14 +107,17 @@ engine schemas adopt it in re/04–06.
     Charged scattering types (`"Fe3+"`) are not supported yet and are rejected,
     never reduced to the neutral atom.
   - **Occupancy**: 0 to 1 inclusive, even where an engine would accept more.
-  - **Special positions** are stated **exactly** (to floating-point precision):
-    `0.5`, `0.25`, `0.3333333333333333`, and coupled coordinates satisfying
-    their relation (`(x, 2x, 1/4)` with `y` exactly `2·x`). An atom within 2e-3
-    (fractional) of a special position but not on it is an **error**: within
-    5e-6 the message gives the values to write (it keeps each tie group's first
-    coordinate as stated and derives the others, e.g. `write y = 0.2468`;
-    fixed coordinates take their exact value); from 5e-6 to 2e-3 it asks to
-    state the position exactly or move it off (`0.33`, `0.3333`).
+  - **Special positions:** a coordinate whose exact value has a decimal form
+    is written **exactly**: `0.5`, `0.25`, `0.125`, and coupled coordinates
+    satisfying their relation (`(x, 2x, 1/4)` with `y` exactly `2·x`). A
+    coordinate whose exact value has none, i.e. involves a third (`1/3`, `2/3`,
+    `1/6`, `1/12`, or `y = x + 1/3` on some rhombohedral sites), is written to
+    **at least 6 decimals** (`0.333333`, `0.166667`) and read as the exact value.
+    Within 5e-6 of a special position, anything else is an **error** whose
+    message gives the values to write (each tie group's first coordinate is kept
+    as stated and the others derived, e.g. `write y = 0.2468`, `write z = 0.25`).
+    From 5e-6 to 2e-3 off a special position is an error too: state the
+    position (as above) or move the atom off it (`0.33`, `0.3333`).
   - **Multiplicity**: optional; when stated it must equal the multiplicity
     derived from the space group.
   - **ADPs**: `ADP` selects the thermal parameter that is **required**:
@@ -144,8 +148,8 @@ engine schemas adopt it in re/04–06.
       `y = k·x + c` maps x's `[min, max]` to `[k·min + c, k·max + c]`
       (swapped for negative k; an open side stays open), e.g. `(x, x + 1/2, z)`
       with x in `[0, 0.2]` needs y in `[0.5, 0.7]`. They must be the mapped
-      values exactly (to floating-point precision); otherwise the error gives
-      them.
+      values exactly, or to at least 6 decimals where the tie's offset is a
+      third (`y = x + 1/3`); otherwise the error gives them.
     - Atoms at the same position are independent: their flags are never tied.
 
 ## gsasii engine schema
diff --git a/src/powderline/schema_core.py b/src/powderline/schema_core.py
index d7c180f..3a6d1a7 100644
--- a/src/powderline/schema_core.py
+++ b/src/powderline/schema_core.py
@@ -26,6 +26,7 @@
 import keyword
 import math
 import re
+from fractions import Fraction
 from typing import Annotated, Any, Generic, Literal, Optional, TypeVar
 
 import gemmi
@@ -53,6 +54,7 @@
 from powderline.exceptions import StructuredWarning, SymmetryError
 from powderline.symmetry import (
     ADJUSTMENT_REPORT_TOL,
+    SPECIAL_POSITION_TOL,
     Ties,
     analyze_site,
     canonical_space_group,
@@ -674,9 +676,10 @@ class Atom(CoreModel, Generic[P]):
     """One atom of a phase: coordinates, occupancy and ADPs are refinable parameters.
 
     Coordinates are fractional JSON numbers. A special position is stated
-    exactly, to floating-point precision (``0.3333333333333333`` for 1/3); a
-    position near one but not on it is an error giving the exact values (A73,
-    A115). ``occupancy`` is required
+    exactly where its value has a decimal form (``0.5``, ``0.25``), and to at
+    least 6 decimals where it has none (``0.333333`` for 1/3, read as 1/3); a
+    position near one but not on it is an error giving the values to write (A73,
+    A115, A120). ``occupancy`` is required
     and 0 to 1 inclusive (A76, A96). ``Multiplicity`` is optional and, when
     stated, must match the derived value (A69 T3). ``ADP`` selects which
     thermal parameter is **required**: ``Uiso``, or ``Uaniso`` with all six of
@@ -769,14 +772,17 @@ class Phase(CoreModel, Generic[P]):
     and rejects ambiguous positions and stated multiplicities that don't match.
     The unit cell must fit the space group exactly (A77).
 
-    **Validation never changes a recipe** (A115): the recipe is the record of the
-    refinement intent, so every value must already be exactly what the engines
-    use. A special position must be stated exactly (A73), an anisotropic ADP
-    exactly site-symmetric (A78), and tied bounds must follow their tie exactly
-    (A108). Otherwise it is an error that gives the exact value to write.
-    "Exactly" means to floating-point precision
-    (:data:`~powderline.symmetry.ADJUSTMENT_REPORT_TOL`), because a JSON number
-    cannot hold 1/3: ``0.3333333333333333`` is the value to write.
+    **Validation never changes the meaning of a recipe** (A115, A120): the recipe
+    is the record of the refinement intent. A value that has an exact decimal
+    form must be written exactly (to floating-point precision,
+    :data:`~powderline.symmetry.ADJUSTMENT_REPORT_TOL`): a special position
+    (``0.5``, not ``0.4999999``; A73), an anisotropic ADP (A78) and tied bounds
+    (A108); otherwise it is an error that gives the value to write. A value with
+    no exact decimal form (a third: 1/3, 1/6, ``x + 1/3``) cannot be written
+    exactly, so 6 decimals state it (within 5e-6, A73's threshold) and it is read
+    as the exact value, with no warning: that is what the recipe says. Only
+    coordinates and coordinate bounds can be thirds; Uij ties and cell ties
+    never are.
 
     Refine flags and bounds must agree with the symmetry ties
     (:func:`~powderline.symmetry.cell_tie_groups`,
@@ -876,9 +882,11 @@ def problem(loc: tuple, message: str, value: Any) -> None:
             problems.append(InitErrorDetails(type="value_error", loc=loc, input=value,
                                              ctx={"error": ValueError(message)}))
 
-        def tie_rules(loc: tuple, params: dict, ties: Ties, context: str, fixed_value) -> None:
-            for name, message in _tie_rules(params, ties, context, fixed_value):
+        def tie_rules(loc: tuple, params: dict, ties: Ties, context: str, fixed_value) -> dict:
+            errors, updates = _tie_rules(params, ties, context, fixed_value)
+            for name, message in errors:
                 problem((*loc, name), message, params[name].model_dump())
+            return updates
 
         sg = self.space_group
         cell = self.unit_cell
@@ -900,13 +908,16 @@ def tie_rules(loc: tuple, params: dict, ties: Ties, context: str, fixed_value) -
             context = f"atom {label!r} (multiplicity {site.multiplicity} in {sg!r})"
             ties = coupling_groups(sg, site.canonical)
             exact_xyz = lambda name: site.exact["xyz".index(name)]  # noqa: E731
-            if site.adjusted:  # A73, A115: on a special position, but not exactly
+            stated = dict(zip("xyz", site.stated))
+            read, write = _special_position_values(ties.xyz, stated, exact_xyz)
+            if write:  # A73, A115, A120: on a special position, but not exactly
                 off = max(abs(c - v) for c, v in zip(site.canonical, site.stated))
                 problem(("atoms", label),
                         f"{context}: {site.stated} is {off:.2g} from a special position, not on it "
-                        f"({_ties_text(ties.xyz, exact_xyz)}); write "
-                        f"{_values_to_write(ties.xyz, dict(zip('xyz', site.stated)), exact_xyz)}",
-                        atom.model_dump())
+                        f"({_ties_text(ties.xyz, exact_xyz)}); write {_write_text(write)}", atom.model_dump())
+            xyz = {k: getattr(atom, k) for k in "xyz"}
+            if read and not write:  # A120: a value with no exact decimal form, stated to >= 6 decimals
+                xyz.update({k: getattr(atom, k).model_copy(update={"value": v}) for k, v in read.items()})
             if atom.Multiplicity is not None and atom.Multiplicity != site.multiplicity:
                 problem(("atoms", label, "Multiplicity"),
                         f"stated Multiplicity {atom.Multiplicity}, derived {site.multiplicity} "
@@ -937,11 +948,12 @@ def tie_rules(loc: tuple, params: dict, ties: Ties, context: str, fixed_value) -
                                 atom.model_dump()["Uaniso"])
 
             # Flag and bound rules F1, F2, F4, A106 (A95, A98, A106).
-            tie_rules(("atoms", label), {k: getattr(atom, k) for k in "xyz"}, ties.xyz, context,
-                      lambda name: str(exact_xyz(name)))
+            xyz.update(tie_rules(("atoms", label), xyz, ties.xyz, context, lambda name: str(exact_xyz(name))))
             if uaniso_ok:
                 tie_rules(("atoms", label, "Uaniso"), {k: getattr(atom.Uaniso, k) for k in _UANISO_KEYS},
                           ties.uij, context, lambda _name: "0")
+            if any(xyz[k] is not getattr(atom, k) for k in "xyz"):
+                self.atoms[label] = atom.model_copy(update=xyz)  # the caller's atom stays as given
         if problems:
             raise ValidationError.from_exception_data(type(self).__name__, problems)
         return self
@@ -997,30 +1009,73 @@ def _ties_text(ties: Ties, exact) -> str:
     return ", ".join(parts)
 
 
-def _values_to_write(ties: Ties, stated: dict, exact) -> str:
-    """``"y = 0.2468"``: the values that make ``stated`` exactly symmetric, where they differ.
+def _has_decimal_form(value: Fraction) -> bool:
+    """True when ``value`` has a finite decimal form (1/2, 1/4, 3/8), False for 1/3, 1/6, 1/12.
 
-    Each tie group keeps its first member's stated value (the one parameter,
-    A94) and derives the others from it; fixed parameters take their exact
-    value. ``repr`` of a float reads back as the same float, so a value can be
-    copied into a recipe as-is (``0.3333333333333333`` for 1/3).
+    Symmetry only produces denominators 1, 2, 3, 4, 6, 8, 12 for fixed
+    coordinates, tie factors ±1, ±2, ±1/2 and offsets with denominators 1-4 (all
+    settings, every distinct special site), so "no decimal form" means "a third".
+    """
+    d = value.denominator
+    for p in (2, 5):
+        while d % p == 0:
+            d //= p
+    return d == 1
+
+
+def _special_position_values(ties: Ties, stated: dict, exact) -> tuple[dict, dict]:
+    """``(read, write)``: the coordinates read as their exact value, and those to write (A120).
+
+    Each tie group keeps its first member as stated (the one parameter, A94);
+    every other member's exact value is ``k * rep + c``, a fixed one's its exact
+    fraction. Where it differs from the stated value beyond floating-point noise:
+    a value with no exact decimal form (a third: 1/3, 1/6, ``x + 1/3``) stated
+    within ``SPECIAL_POSITION_TOL`` (6 decimals) is **read** as the exact value;
+    any other is to be **written** (``0.4999999`` must be ``0.5``). ``write`` maps
+    a name to ``(value, has_decimal_form)``.
     """
-    target = {name: float(exact(name)) for name in ties.fixed}
+    target: dict[str, tuple[float, bool]] = {}
+    for name in ties.fixed:
+        target[name] = (float(exact(name)), _has_decimal_form(exact(name)))
     for group in ties.groups:
         rep = stated[group.members[0]]
-        target.update({name: float(k) * rep + float(c)
-                       for name, k, c in zip(group.members, group.coefficients, group.offsets)})
-    return ", ".join(f"{name} = {target[name]!r}" for name in stated if not _same(stated[name], target[name]))
+        for name, k, c in zip(group.members, group.coefficients, group.offsets):
+            target[name] = (float(k) * rep + float(c), _has_decimal_form(k) and _has_decimal_form(c))
+    read, write = {}, {}
+    for name, value in stated.items():
+        exact_value, decimal = target[name]
+        if _same(value, exact_value):
+            continue
+        if not decimal and abs(value - exact_value) <= SPECIAL_POSITION_TOL:
+            read[name] = exact_value
+        else:
+            write[name] = (exact_value, decimal)
+    return read, write
 
 
-def _fmt_bounds(lo: Optional[float], hi: Optional[float]) -> str:
-    return "[" + ", ".join("null" if v is None else repr(v) for v in (lo, hi)) + "]"
+def _fmt_exact(value: float, decimal: bool) -> str:
+    """A value to write: exactly (``repr``) when it has a decimal form, else to 6 decimals."""
+    return repr(value) if decimal else f"{value:.6f} (to at least 6 decimals)"
+
+
+def _write_text(write: dict) -> str:
+    return ", ".join(f"{name} = {_fmt_exact(v, decimal)}" for name, (v, decimal) in write.items())
+
+
+def _values_to_write(ties: Ties, stated: dict, exact) -> str:
+    """``"U12 = 0.0061735"``: the values that make ``stated`` exactly symmetric (Uij: always a decimal form)."""
+    _read, write = _special_position_values(ties, stated, exact)
+    return _write_text(write)
+
+
+def _fmt_bounds(lo: Optional[float], hi: Optional[float], decimal: bool = True) -> str:
+    return "[" + ", ".join("null" if v is None else repr(v) if decimal else f"{v:.6f}" for v in (lo, hi)) + "]"
 
 
 _HOW_MANY = {2: "both", 3: "all three"}
 
 
-def _tie_rules(params: dict, ties: Ties, context: str, fixed_value) -> list[tuple[str, str]]:
+def _tie_rules(params: dict, ties: Ties, context: str, fixed_value) -> tuple[list[tuple[str, str]], dict]:
     """The flag and bound rules of one parameter set (cell, a site's x/y/z, or its Uij).
 
     - **F2** (A95): a symmetry-fixed parameter has refine flag false.
@@ -1032,12 +1087,15 @@ def _tie_rules(params: dict, ties: Ties, context: str, fixed_value) -> list[tupl
       the first member's: ``member = k*rep + c`` maps ``[min, max]`` to
       ``[k*min + c, k*max + c]``, swapped for k < 0; a null side stays null on
       the matching side. Anything but the exact mapped bounds (to floating-point
-      precision) is an error giving them.
+      precision) is an error giving them, except that a bound with no exact
+      decimal form (an offset of a third) stated to 6 decimals is read as the
+      exact one (A120).
     - **F3**: different groups are independent (nothing to check).
 
-    Returns ``[(name, message)]``.
+    Returns ``([(name, message)], {name: param with the read bounds})``.
     """
     errors: list[tuple[str, str]] = []
+    updates: dict[str, Any] = {}
     for name in ties.fixed:
         param = params[name]
         if param.refine_flag:
@@ -1065,13 +1123,24 @@ def _tie_rules(params: dict, ties: Ties, context: str, fixed_value) -> list[tupl
             lo, hi = (None if v is None else k * v + c for v in (rep.min, rep.max))
             if k < 0:
                 lo, hi = hi, lo
-            if not all((got is None and want is None) or (got is not None and want is not None and _same(got, want))
-                       for got, want in ((param.min, lo), (param.max, hi))):
-                errors.append((name, f"{context}: the bounds of {name} must follow "
-                                     f"{group.relation_text(name)} from the bounds of {group.members[0]} "
-                                     f"{_fmt_bounds(rep.min, rep.max)}: write {_fmt_bounds(lo, hi)}, "
-                                     f"not {_fmt_bounds(param.min, param.max)}"))
-    return errors
+            pairs = ((param.min, lo), (param.max, hi))
+            if not all((got is None) == (want is None) for got, want in pairs):
+                exact = readable = False
+            else:
+                exact = all(got is None or _same(got, want) for got, want in pairs)
+                readable = all(got is None or abs(got - want) <= SPECIAL_POSITION_TOL for got, want in pairs)
+            decimal = all(_has_decimal_form(v) for v in group.relation(name))
+            if exact:
+                continue
+            if readable and not decimal:  # A120: e.g. y = x + 1/3, stated to 6 decimals
+                updates[name] = param.model_copy(update={"min": lo, "max": hi})
+                continue
+            errors.append((name, f"{context}: the bounds of {name} must follow "
+                                 f"{group.relation_text(name)} from the bounds of {group.members[0]} "
+                                 f"{_fmt_bounds(rep.min, rep.max)}: write {_fmt_bounds(lo, hi, decimal)}"
+                                 f"{'' if decimal else ' (to at least 6 decimals)'}, "
+                                 f"not {_fmt_bounds(param.min, param.max)}"))
+    return errors, updates
 
 
 # --- top-level recipe frame (A1, A18, A21, A40) ------------------------------
diff --git a/tests/test_schema_core.py b/tests/test_schema_core.py
index 7a73f72..8531cbd 100644
--- a/tests/test_schema_core.py
+++ b/tests/test_schema_core.py
@@ -1092,9 +1092,10 @@ def test_phase_space_group_r3m_hexagonal_accepted():
     assert phase.space_group == "R -3 m:H"
 
 
-def test_phase_special_position_not_exact_rejected():
-    """A115: (0.333333, 0.666667, 0.25) is on 2c but not exactly: an error giving the values to write.
-    Writing them (repr of the float) validates, and the phase holds them unchanged."""
+def test_phase_special_position_thirds_read_from_6_decimals():
+    """A120: 1/3 and 2/3 have no exact decimal form, so 6 decimals state them: (0.333333,
+    0.666667, 0.25) on 2c is read as (1/3, 2/3, 1/4), with no warning; the caller's dict is
+    untouched, and a dump writes the exact floats, which validate as themselves."""
     d = {
         "space_group": "P 63/m m c",
         "unit_cell": {"a": [3.2, False], "b": [3.2, False], "c": [5.2, False], "alpha": [90, False], "beta": [90, False], "gamma": [120, False]},
@@ -1102,15 +1103,62 @@ def test_phase_special_position_not_exact_rejected():
             "A1": {"element": "O", "x": [0.333333, False], "y": [0.666667, False], "z": [0.25, False], "occupancy": [1.0, False], "ADP": "Uiso", "Uiso": [0.01, False]}
         },
     }
+    phase = Phase[RefinableParameter].model_validate(d)
+    assert (phase.atoms["A1"].x.value, phase.atoms["A1"].y.value, phase.atoms["A1"].z.value) == (1 / 3, 2 / 3, 0.25)
+    assert phase.warnings() == []
+    assert d["atoms"]["A1"]["x"] == [0.333333, False]
+    assert Phase[RefinableParameter].model_validate(phase.model_dump()).model_dump() == phase.model_dump()
+
+
+def test_phase_special_position_with_a_decimal_form_must_be_exact():
+    """A120: 1/2 and 1/4 have an exact decimal form, so 0.4999999 and 0.2499999 are errors; in one
+    atom the thirds are still read and only the decimal ones are asked for."""
+    d = {
+        "space_group": "P 63/m m c",
+        "unit_cell": {"a": [3.2, False], "b": [3.2, False], "c": [5.2, False], "alpha": [90, False], "beta": [90, False], "gamma": [120, False]},
+        "atoms": {
+            "A1": {"element": "O", "x": [0.333333, False], "y": [0.666667, False], "z": [0.2499999, False], "occupancy": [1.0, False], "ADP": "Uiso", "Uiso": [0.01, False]}
+        },
+    }
     with pytest.raises(ValidationError) as exc_info:
         Phase[RefinableParameter].model_validate(d)
     assert _errs(exc_info) == [(("atoms", "A1"),
-                                "atom 'A1' (multiplicity 2 in 'P 63/m m c'): (0.333333, 0.666667, 0.25) is 3.3e-07 "
-                                "from a special position, not on it (x = 1/3, y = 2/3, z = 1/4); "
-                                "write x = 0.3333333333333333, y = 0.6666666666666666")]
-    d["atoms"]["A1"]["x"][0], d["atoms"]["A1"]["y"][0] = json.loads("[0.3333333333333333, 0.6666666666666666]")
-    phase = Phase[RefinableParameter].model_validate(d)
-    assert phase.model_dump() == d
+                                "atom 'A1' (multiplicity 2 in 'P 63/m m c'): (0.333333, 0.666667, 0.2499999) is "
+                                "3.3e-07 from a special position, not on it (x = 1/3, y = 2/3, z = 1/4); write z = 0.25")]
+
+
+_R3M_CELL = {"a": [4.0, False], "b": [4.0, False], "c": [20.0, False],
+             "alpha": [90, False], "beta": [90, False], "gamma": [120, False]}
+
+
+def test_coupled_coordinate_with_a_third_offset_read_from_6_decimals():
+    """A120: R-3m:H at (x, x + 1/3, 1/6): y has no exact decimal form, so 6 decimals state it."""
+    atom = {"element": "O", "x": [0.1, True], "y": [0.433333, True], "z": [0.166667, False],
+            "occupancy": [1.0, False], "ADP": "Uiso", "Uiso": [0.01, False]}
+    phase = Phase[RP].model_validate({"space_group": "R -3 m:H", "unit_cell": _R3M_CELL, "atoms": {"O1": atom}})
+    assert (phase.atoms["O1"].x.value, phase.atoms["O1"].y.value, phase.atoms["O1"].z.value) == (0.1, 0.1 + 1 / 3, 1 / 6)
+    assert phase.atoms["O1"].y.refine_flag is True
+
+
+def test_tied_bounds_with_a_third_offset_read_from_6_decimals():
+    """A120 for F4: y = x + 1/3 maps x in [0.05, 0.15] to [0.383333.., 0.483333..]; 6 decimals are
+    read as those, 4 decimals are an error giving them to 6 decimals."""
+    cell = {k: [*v, None, None] for k, v in _R3M_CELL.items()}
+
+    def phase(y_bounds):
+        atom = {"element": "O", "x": [0.1, True, 0.05, 0.15], "y": [0.433333, True, *y_bounds],
+                "z": [0.166667, False, None, None], "occupancy": [1.0, False, None, None],
+                "ADP": "Uiso", "Uiso": [0.01, False, None, None]}
+        return {"space_group": "R -3 m:H", "unit_cell": cell, "atoms": {"O1": atom}}
+
+    y = Phase[BRP].model_validate(phase((0.383333, 0.483333))).atoms["O1"].y
+    assert y.model_dump() == [0.1 + 1 / 3, True, 0.05 + 1 / 3, 0.15 + 1 / 3]
+    with pytest.raises(ValidationError) as exc_info:
+        Phase[BRP].model_validate(phase((0.3833, 0.4833)))
+    assert _errs(exc_info) == [(("atoms", "O1", "y"),
+                                "atom 'O1' (multiplicity 18 in 'R -3 m:H'): the bounds of y must follow y = x + 1/3 "
+                                "from the bounds of x [0.05, 0.15]: write [0.383333, 0.483333] (to at least 6 "
+                                "decimals), not [0.3833, 0.4833]")]
 
 
 def test_phase_special_position_ambiguous_rejected():

From 4f41bbfd53e2df3f463b0e76e49a57c6ebeb0ce9 Mon Sep 17 00:00:00 2001
From: acorrao <95718914+AdamCorrao@users.noreply.github.com>
Date: Wed, 7 Oct 2026 19:55:06 -0400
Subject: [PATCH 12/14] docs(schema): a recipe file is never rewritten; a model
 dump spells 1/3 in full (A120)

Option A of A120, chosen by the maintainer. The validated model holds the
float nearest 1/3, so tie relations hold exactly and every engine starts from
the same structure. The user's file is never rewritten. Only a Python dump of
the model shows 0.3333333333333333, which is the same value.

Assisted-by: claude-code:claude-opus-5-5
---
 docs/SCHEMA_HISTORY.md | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/docs/SCHEMA_HISTORY.md b/docs/SCHEMA_HISTORY.md
index 111440b..099464e 100644
--- a/docs/SCHEMA_HISTORY.md
+++ b/docs/SCHEMA_HISTORY.md
@@ -77,7 +77,10 @@ engine schemas adopt it in re/04–06.
   fails and the message gives the value to write. A value with no exact
   decimal form (a third: 1/3, 1/6, 2/3, or a tie offset such as `x + 1/3`)
   cannot be written exactly, so **6 decimals** state it (`0.333333` means 1/3)
-  and every engine receives the exact value. All problems are reported together, each at its own field
+  and every engine receives the exact value. PowderLine never rewrites a
+  recipe file; only a Python dump of a validated model shows the exact value's
+  full spelling (`0.3333333333333333`), which is the same value. All problems
+  are reported together, each at its own field
   (`unit_cell`, `atoms.<label>` for the position, `atoms.<label>.Multiplicity`,
   `atoms.<label>.Uaniso`, or the parameter a flag/bound rule concerns, e.g.
   `unit_cell.b`, `atoms.<label>.y`, `atoms.<label>.Uaniso.U12`); they are checked

From 6af30c91f45a1739dea15a7c38efb65a61d52b15 Mon Sep 17 00:00:00 2001
From: acorrao <95718914+AdamCorrao@users.noreply.github.com>
Date: Thu, 8 Oct 2026 11:05:56 -0400
Subject: [PATCH 13/14] fix(symmetry): SiteAnalysis.canonical is not the
 engines' structure; band message to 6 decimals

re/03b PR review S5 and N3.

- SiteAnalysis.canonical is the stated position moved onto the special
  position by the least (orthogonal) change. It is used to find the
  stabilizer and the tie offsets. It is not what the engines receive: the
  validated core Phase holds those coordinates (A120), and keeps a tie
  group's first member as stated where canonical may move it (by ~1e-7 at a
  y = x + 1/3 tie). The docstring said gateways use it.
- The ambiguous-band message printed the nearby special position's free
  coordinates with .6g, which gives fewer than 6 decimals once |x| >= 1. It
  now prints 6 decimals.

Assisted-by: claude-code:claude-opus-5-5
---
 src/powderline/symmetry.py | 15 ++++++++++-----
 1 file changed, 10 insertions(+), 5 deletions(-)

diff --git a/src/powderline/symmetry.py b/src/powderline/symmetry.py
index efaa401..3a9bb77 100644
--- a/src/powderline/symmetry.py
+++ b/src/powderline/symmetry.py
@@ -423,10 +423,15 @@ class SiteAnalysis:
 
     Attributes:
         stated: the coordinates as given.
-        canonical: the coordinates every gateway uses -- equal to ``stated`` for
-            a general position; on a special position, symmetry-fixed axes are
-            exact (see ``exact``) and coupled axes satisfy their relation (to
-            floating-point precision), by the least change from ``stated``.
+        canonical: ``stated`` moved onto the special position by the least
+            (orthogonal) change: equal to ``stated`` for a general position;
+            on a special position, symmetry-fixed axes are exact (see
+            ``exact``) and coupled axes satisfy their relation (to
+            floating-point precision). Used here to find the stabilizer and
+            the tie offsets. It is **not** what the engines receive: the
+            validated core ``Phase`` holds those coordinates (A120), and keeps
+            a tie group's first member as stated where ``canonical`` may move
+            it (e.g. by ~1e-7 at a ``y = x + 1/3`` tie).
         exact: per axis, the exact rational value of a symmetry-fixed
             coordinate (``None`` for a free or coupled axis).
         axes: ``"FREE"`` / ``"FIXED"`` / ``"COUPLED"`` per axis.
@@ -454,7 +459,7 @@ def _fmt_xyz(xyz) -> str:
 
 
 def _fmt_exact(values, exact) -> str:
-    return "(" + ", ".join(str(e) if e is not None else f"{v:.6g}" for v, e in zip(values, exact)) + ")"
+    return "(" + ", ".join(str(e) if e is not None else f"{v:.6f}" for v, e in zip(values, exact)) + ")"
 
 
 def _barycenter(x: np.ndarray, ops) -> np.ndarray:

From b446577bce8c8b8b9ca985cc48750754df769b9e Mon Sep 17 00:00:00 2001
From: acorrao <95718914+AdamCorrao@users.noreply.github.com>
Date: Thu, 8 Oct 2026 11:06:09 -0400
Subject: [PATCH 14/14] fix(core): one rule for symmetry-determined values;
 engine guard layers (A121-A123)

Fixes from the re/03b PR review, as decided by the maintainer. They share
the functions of Phase's validation, so they are one commit.

One rule for symmetry-determined values (A121, option B; S1, S3, Q1, N1-N3,
N7). The first member of each tie group is the independent parameter, kept
exactly as stated. Every other value is derived from the space group and
those parameters in exact rational arithmetic (Fraction), rounded once, and
the validated model holds the derived value, so every tie holds exactly.
How closely the recipe must state a derived value:
- a constant of the site (a fixed coordinate, a Uij fixed at 0) with a
  decimal form exactly (0.5, not 0.4999999; 0, not 1e-9); a third to at
  least 6 decimals (A120, unchanged);
- a value derived from another stated value (a coupled coordinate or Uij,
  a tied member's bounds) within its family's tolerance, coordinates 5e-6
  (A73) and Uij 1e-6 A^2 (A78), read as the derived value.
The ideal C14 6h position (0.833333, 0.666667, 1/4), y = 2x - 1, was an
error ("write y = 0.666666"); it is now read. A third written to 13 digits
is held as 1/3. A value and its bounds are derived together, so a value at
its bound stays within it. One message per parameter set gives the values
derived from the first member, and names equal ties (z = y, U22 = U11).
docs/SCHEMA_HISTORY.md shows users the rule as a table of cases.

Cell (A123; S4). Checked from its tie groups within A77's CELL_TOL (1e-9,
kept), with the metric check behind it. The model holds the first member's
values and exact fixed angles (b = a exactly). The error states the stated
values and the values to write (repr, not %g).

Engine phase guard (A122; S2, N5). A mixin placed before Phase[P] could
replace _space_group or _sites_check silently, and a 'wrap' validator could
skip core. Now:
1. no class in the MRO besides core's own, mixins included, may redeclare a
   core field, reuse a core name, or define a pydantic entry point;
2. every core validator must still be core's own function;
3. an engine's own validators are 'after' validators on core fields and the
   model (a 'before' one could rewrite the recipe before core reads it);
4. tests/test_phase_canary.py runs core's must-fail recipes and a valid
   recipe through every engine phase model (re/04-06 register theirs) and
   re-runs the structural guard on each.
The parameter type must be RefinableParameter or BoundedRefinableParameter
(Phase[float] is a TypeError).

Also:
- the uaniso_not_positive_definite warning gives the Cartesian principal
  mean-square displacements; a near-zero one counts as 0 (A118 amended;
  N4);
- atom labels must differ by more than case (A112 amended; N8).

Tests: 3 renamed (behaviour changed), 6 updated, 38 new IDs; none removed.
Default suite 1518 passed, 4 skipped; easydiff 55 passed. The fuzz over all
564 settings and translates (10,353 sites) gives 0 rejections and the exact
derived float in every case.

Assisted-by: claude-code:claude-opus-5-5
---
 docs/SCHEMA_HISTORY.md        | 109 +++++---
 src/powderline/schema_core.py | 471 +++++++++++++++++++++++-----------
 tests/test_phase_canary.py    | 130 ++++++++++
 tests/test_schema_core.py     | 362 +++++++++++++++++++++++---
 4 files changed, 853 insertions(+), 219 deletions(-)
 create mode 100644 tests/test_phase_canary.py

diff --git a/docs/SCHEMA_HISTORY.md b/docs/SCHEMA_HISTORY.md
index 099464e..0e31e2b 100644
--- a/docs/SCHEMA_HISTORY.md
+++ b/docs/SCHEMA_HISTORY.md
@@ -54,8 +54,9 @@ engine schemas adopt it in re/04–06.
 - **Phase block** (`Phase`): one block per phase, keyed by the phase name in
   the engine payload's `phases` (no `phase_name` field). Core owns
   `space_group`, `unit_cell` and `atoms`; each engine schema adds its own phase
-  fields next to them (e.g. gsasii `scale`, `peak_broadening`) and may not
-  redefine core's. Every structural quantity is a parameter (`[value, flag]`,
+  fields next to them (e.g. gsasii `scale`, `peak_broadening`) and may add
+  its own checks, but never redefine, skip or rewrite core's fields and
+  validation (checked when the engine schema is defined, and by a test). Every structural quantity is a parameter (`[value, flag]`,
   or `[value, flag, min, max]` in engines with bounds): cell `a`–`gamma`; atom
   `x`, `y`, `z`, `occupancy`, `Uiso` or `U11`…`U23`. `element`, `ADP`,
   `Multiplicity` and `space_group` are plain values. Nothing is `null` and
@@ -63,23 +64,25 @@ engine schemas adopt it in re/04–06.
   so optional) is left out when not stated, never `null`.
   **Names:** atom labels (the `atoms` keys) and phase names (the engine
   payload's `phases` keys) start with a letter and contain only ASCII letters,
-  digits and `_` (`O1`, `LaB6_a`); phase names must also differ by more than
-  case. This is the form every engine can use as-is: GSAS-II renames a phase
+  digits and `_` (`O1`, `LaB6_a`); phase names, and the atom labels of a
+  phase, must also differ by more than case. This is the form every engine can use as-is: GSAS-II renames a phase
   with surrounding spaces or non-ASCII characters (and its settings were then
   skipped), easydiffraction accepts no other atom label, TOPAS writes the names
   into its input file, phase names become report file names (which ignore case
   on Windows and macOS), and problems are reported at `.`-joined paths
   (`atoms.O1.Uiso`). So `"2H-MoS2"` is written e.g. `MoS2_2H`.
   Structural interpretation is checked once, in core, so every engine gets the
-  same structure. **Validation never changes what a recipe says:** the recipe
-  is the record of the refinement intent. A value that has an exact decimal
-  form must be written exactly (`0.5`, not `0.4999999`); otherwise validation
-  fails and the message gives the value to write. A value with no exact
-  decimal form (a third: 1/3, 1/6, 2/3, or a tie offset such as `x + 1/3`)
-  cannot be written exactly, so **6 decimals** state it (`0.333333` means 1/3)
-  and every engine receives the exact value. PowderLine never rewrites a
-  recipe file; only a Python dump of a validated model shows the exact value's
-  full spelling (`0.3333333333333333`), which is the same value. All problems
+  same structure. **The recipe is the record of the refinement intent**, and
+  validation never changes what it means. Values fixed or tied by symmetry
+  follow one rule (see *Symmetry-determined values* below): the first member
+  of each tie group is stated freely and kept as written; every other value is
+  derived from the symmetry and must be stated, either exactly (a constant
+  with a decimal form, such as `0.5` or `0`) or to the precision that states it
+  beyond doubt (a third, `0.333333`; a value derived from another stated
+  value). The validated model, which every engine receives, holds the derived
+  values. PowderLine never rewrites a recipe file; only a Python dump of a
+  validated model shows a derived value's full spelling
+  (`0.3333333333333333`), which means the same and validates the same. All problems
   are reported together, each at its own field
   (`unit_cell`, `atoms.<label>` for the position, `atoms.<label>.Multiplicity`,
   `atoms.<label>.Uaniso`, or the parameter a flag/bound rule concerns, e.g.
@@ -102,25 +105,57 @@ engine schemas adopt it in re/04–06.
     0–180). In engines with bounds, a stated bound must lie in the same range
     (a length's `min` > 0; an angle's `min`/`max` strictly between 0 and 180);
     `null` means no bound. No `volume` (every engine derives it). The cell must fit the
-    space group **exactly** (to floating-point precision): e.g. cubic
-    `a = b = c` and all angles 90°. A mismatch is an error naming each
-    parameter and its symmetric value. (GSAS-II alone would silently apply the
-    symmetry only when the cell is refined.)
+    space group: tied lengths and angles equal the first one (cubic
+    `b = a`, `c = a`), and fixed angles are exactly 90° (or 120° for `gamma`
+    on hexagonal axes), to within 1e-9 (relative on lengths, degrees on
+    angles), the floating-point noise of a cell computed by a program. The
+    validated model holds the first member's value and the exact angles. A
+    mismatch is an error stating each value and the value to write
+    (`stated b = 4.2, but by symmetry b = a; write b = 4.15692`). (GSAS-II
+    alone would silently apply the symmetry only when the cell is refined.)
   - **Elements**: a bare element symbol spelled exactly (`"Fe"`, not `"FE"`).
     Charged scattering types (`"Fe3+"`) are not supported yet and are rejected,
     never reduced to the neutral atom.
   - **Occupancy**: 0 to 1 inclusive, even where an engine would accept more.
-  - **Special positions:** a coordinate whose exact value has a decimal form
-    is written **exactly**: `0.5`, `0.25`, `0.125`, and coupled coordinates
-    satisfying their relation (`(x, 2x, 1/4)` with `y` exactly `2·x`). A
-    coordinate whose exact value has none, i.e. involves a third (`1/3`, `2/3`,
-    `1/6`, `1/12`, or `y = x + 1/3` on some rhombohedral sites), is written to
-    **at least 6 decimals** (`0.333333`, `0.166667`) and read as the exact value.
-    Within 5e-6 of a special position, anything else is an **error** whose
-    message gives the values to write (each tie group's first coordinate is kept
-    as stated and the others derived, e.g. `write y = 0.2468`, `write z = 0.25`).
-    From 5e-6 to 2e-3 off a special position is an error too: state the
-    position (as above) or move the atom off it (`0.33`, `0.3333`).
+  - **Symmetry-determined values** (special positions, anisotropic ADPs,
+    tied bounds). Within 5e-6 of a special position an atom is on it; from
+    5e-6 to 2e-3 off is an error (state the position, or move the atom at least
+    2e-3 off it: `0.33` and `0.3333` are neither). On a special position:
+    - the **first member of each tie group** (x before y before z; U11 before
+      U22 …) is the free parameter: it is kept exactly as written, whatever its
+      value;
+    - a **constant** of the site, i.e. a coordinate fixed by symmetry or a
+      Uij that must be 0, is written **exactly** when it has a decimal form
+      (`0.5`, `0.25`, `0.125`, `0`), and to **at least 6 decimals** when it has
+      none, i.e. when it is a third (`0.333333` for 1/3, `0.166667` for 1/6);
+    - a value **derived from another stated value**, i.e. a coupled
+      coordinate (`(x, 2x, 1/4)`, `(x, x + 1/2, z)`, `(x, x + 1/3, 1/6)`), a
+      coupled Uij (`U22 = U11`, `U12 = U22/2`) or a tied member's bounds, is
+      stated to the precision of its kind (coordinates within 5e-6, i.e. 6
+      decimals; Uij within 1e-6 Ų) and read as the value derived from the
+      first member;
+    - anything else is an **error** whose message gives the values to write.
+
+    The validated model holds the derived values, so every tie holds exactly
+    and every engine starts from the same structure. How PowderLine reads
+    some typical statements:
+
+    | Stated | Symmetry | Validated model | Why |
+    |---|---|---|---|
+    | `x = 0.4999999` at (1/2, 0, 0) | x fixed = 1/2 | **error**: write `x = 0.5` | 1/2 has a decimal form: write it exactly |
+    | `x, y = 0.333333, 0.666667` at (1/3, 2/3, 1/4) | fixed thirds | 1/3, 2/3 | a third has no decimal form; 6 decimals state it |
+    | `x, y = 0.3333333333333, 0.6666666666667` | fixed thirds | 1/3, 2/3 | any precision beyond 6 decimals reads the same |
+    | `x, y = 0.833333, 0.666667` at 6h (x, 2x, 1/4) | y = 2x − 1 | x = 0.833333, y = 0.666666 | x is free and kept; y follows it |
+    | `x, y = 0.1, 0.2000001` at (x, 2x, 0) | y = 2x | x = 0.1, y = 0.2 | y follows x |
+    | `x, y = 0.066667, 0.4` at (x, x + 1/3, 1/6) | y = x + 1/3 | x = 0.066667, y = 0.40000033… | y follows x, even where the stated y is a short decimal |
+    | `U13 = 1e-9` at 6h | U13 fixed = 0 | **error**: write `U13 = 0.0` | 0 has a decimal form: write it exactly |
+    | `U12 = 0.006174` with `U22 = 0.012347` at 6h | U12 = U22/2 | U12 = 0.0061735 | U12 follows U22 |
+    | y bounds `[0.300004, 0.5]`, x bounds `[0, 0.2]` at (x, −x + 1/2, z) | y = −x + 1/2 | `[0.3, 0.5]` | bounds follow the first member's |
+
+    Most crystallographic programs instead move any atom within a distance
+    tolerance onto the special position (SHELXL 0.2 Å, cctbx 0.5 Å), and
+    pymatgen reads `0.3333` as 1/3. PowderLine does not: a constant that can
+    be written exactly must be, and `0.3333` is ambiguous.
   - **Multiplicity**: optional; when stated it must equal the multiplicity
     derived from the space group.
   - **ADPs**: `ADP` selects the thermal parameter that is **required**:
@@ -128,12 +163,11 @@ engine schemas adopt it in re/04–06.
     `U11 U22 U33 U12 U13 U23` (Ų). The other one must be left out. A missing
     or extra one is an error at that field (`atoms.<label>.Uiso`,
     `atoms.<label>.Uaniso.U23`), and the JSON Schema states the same rule.
-    Anisotropic ADPs must respect the site symmetry exactly; otherwise it is an
-    error, which within 1e-6 Ų gives the values to write (derived from each tie
-    group's first component, e.g. `write U12 = 0.0061735` for `U12 = U22/2`).
-    A `Uaniso` that is not positive definite (a principal mean-square
-    displacement ≤ 0, so no thermal ellipsoid exists) is **accepted with a
-    structured warning** (`uaniso_not_positive_definite`), like a negative
+    Anisotropic ADPs follow the site symmetry as described under
+    *Symmetry-determined values*. A `Uaniso` that is not positive definite (a
+    principal mean-square displacement ≤ 0, so no thermal ellipsoid exists) is
+    **accepted with a structured warning** (`uaniso_not_positive_definite`,
+    giving the principal values in Ų along Cartesian axes), like a negative
     `Uiso`: it can show that the parameter compensates for something the model
     lacks (e.g. absorption). Engines carry it as given.
   - **Refinement intent follows the symmetry.** Parameters tied by symmetry
@@ -150,9 +184,10 @@ engine schemas adopt it in re/04–06.
     - **Bounds** (engines with bounds) follow the tie like the values:
       `y = k·x + c` maps x's `[min, max]` to `[k·min + c, k·max + c]`
       (swapped for negative k; an open side stays open), e.g. `(x, x + 1/2, z)`
-      with x in `[0, 0.2]` needs y in `[0.5, 0.7]`. They must be the mapped
-      values exactly, or to at least 6 decimals where the tie's offset is a
-      third (`y = x + 1/3`); otherwise the error gives them.
+      with x in `[0, 0.2]` needs y in `[0.5, 0.7]`. They are derived values
+      (see *Symmetry-determined values*): stated within 5e-6 for coordinates,
+      1e-6 Ų for Uij and 1e-9 (relative) for the cell, and read as the mapped
+      values; otherwise the error gives them.
     - Atoms at the same position are independent: their flags are never tied.
 
 ## gsasii engine schema
diff --git a/src/powderline/schema_core.py b/src/powderline/schema_core.py
index 3a6d1a7..25a3331 100644
--- a/src/powderline/schema_core.py
+++ b/src/powderline/schema_core.py
@@ -27,7 +27,8 @@
 import math
 import re
 from fractions import Fraction
-from typing import Annotated, Any, Generic, Literal, Optional, TypeVar
+from dataclasses import dataclass
+from typing import Annotated, Any, Callable, Generic, Literal, Optional, TypeVar
 
 import gemmi
 import numpy as np
@@ -54,13 +55,14 @@
 from powderline.exceptions import StructuredWarning, SymmetryError
 from powderline.symmetry import (
     ADJUSTMENT_REPORT_TOL,
+    CELL_TOL,
     SPECIAL_POSITION_TOL,
+    UIJ_TOL,
     Ties,
     analyze_site,
     canonical_space_group,
     cell_tie_groups,
     check_cell,
-    check_uij,
     coupling_groups,
 )
 
@@ -675,18 +677,18 @@ class UanisoTensor(CoreModel, Generic[P]):
 class Atom(CoreModel, Generic[P]):
     """One atom of a phase: coordinates, occupancy and ADPs are refinable parameters.
 
-    Coordinates are fractional JSON numbers. A special position is stated
-    exactly where its value has a decimal form (``0.5``, ``0.25``), and to at
-    least 6 decimals where it has none (``0.333333`` for 1/3, read as 1/3); a
-    position near one but not on it is an error giving the values to write (A73,
-    A115, A120). ``occupancy`` is required
+    Coordinates are fractional JSON numbers. On a special position, the values
+    fixed or tied by symmetry follow :class:`Phase`'s rule (A73, A120, A121): a
+    fixed value with a decimal form exactly (``0.5``), a third to at least 6
+    decimals (``0.333333``), a coupled one within 6 decimals of the value
+    derived from its group's first member. ``occupancy`` is required
     and 0 to 1 inclusive (A76, A96). ``Multiplicity`` is optional and, when
     stated, must match the derived value (A69 T3). ``ADP`` selects which
     thermal parameter is **required**: ``Uiso``, or ``Uaniso`` with all six of
     U11..U23; the other must be left out (an error at that field otherwise, and
-    the JSON Schema states the rule). ``Uaniso`` must respect the site symmetry
-    exactly; otherwise it is an error, giving the symmetric values when they are
-    within 1e-6 A^2 (A78, A115). Nothing is ``null`` (A96).
+    the JSON Schema states the rule). ``Uaniso`` follows the site symmetry by
+    the same rule: a fixed component exactly 0, a coupled one within 1e-6 A^2
+    (A78, A121). Nothing is ``null`` (A96).
     """
 
     model_config = ConfigDict(extra="forbid", json_schema_extra=_ADP_PAIRING_SCHEMA)
@@ -770,19 +772,32 @@ class Phase(CoreModel, Generic[P]):
     ``space_group`` is gemmi's canonical name (A105). Validation derives each
     atom's site (multiplicity, DOF) from it (:func:`powderline.symmetry.analyze_site`)
     and rejects ambiguous positions and stated multiplicities that don't match.
-    The unit cell must fit the space group exactly (A77).
-
-    **Validation never changes the meaning of a recipe** (A115, A120): the recipe
-    is the record of the refinement intent. A value that has an exact decimal
-    form must be written exactly (to floating-point precision,
-    :data:`~powderline.symmetry.ADJUSTMENT_REPORT_TOL`): a special position
-    (``0.5``, not ``0.4999999``; A73), an anisotropic ADP (A78) and tied bounds
-    (A108); otherwise it is an error that gives the value to write. A value with
-    no exact decimal form (a third: 1/3, 1/6, ``x + 1/3``) cannot be written
-    exactly, so 6 decimals state it (within 5e-6, A73's threshold) and it is read
-    as the exact value, with no warning: that is what the recipe says. Only
-    coordinates and coordinate bounds can be thirds; Uij ties and cell ties
-    never are.
+
+    **One rule for symmetry-determined values** (A115, A120, A121, A123): the
+    first member of each tie group is an independent parameter, kept exactly as
+    stated. Every other value is *derived* from the space group and those
+    parameters in exact rational arithmetic, and the validated model holds the
+    derived value (the float nearest it), so every tie holds exactly and every
+    engine receives one structure. The recipe states every derived value; how
+    closely is checked per kind:
+
+    - a **constant** of the space group (a fixed coordinate, a fixed Uij = 0)
+      with an exact decimal form must be written exactly (to floating-point
+      precision, :data:`~powderline.symmetry.ADJUSTMENT_REPORT_TOL`): ``0.5``,
+      not ``0.4999999``; ``0``, not ``1e-9``. One with none (a third) is
+      written to at least 6 decimals (within 5e-6, A73) and read;
+    - a value **derived from another stated value** (a coupled coordinate
+      ``y = 2x``, ``y = x + 1/3``; a coupled Uij ``U12 = U22/2``; a tied
+      member's bounds) is read within the stated precision of its family:
+      coordinates 5e-6 (A73), Uij 1e-6 A^2 (A78);
+    - the **cell** (A77, A123): tied lengths and angles equal the first
+      member's, and fixed angles are 90 or 120, within ``CELL_TOL``
+      (1e-9, relative on lengths).
+
+    Anything else is an error that gives the values to write. Reading carries
+    no warning: within these tolerances the recipe has only that meaning (A73's
+    band rule excludes "just off" positions), and a dump of the model validates
+    as itself.
 
     Refine flags and bounds must agree with the symmetry ties
     (:func:`~powderline.symmetry.cell_tie_groups`,
@@ -820,19 +835,41 @@ class Phase(CoreModel, Generic[P]):
 
     @classmethod
     def __pydantic_init_subclass__(cls, **kwargs: Any) -> None:
-        """Guard core's contract in every engine subclass (A93; re/03b review).
-
-        A subclass may add fields and validators, but may not redeclare core's
-        fields or reuse the name of a core validator, private attribute or
-        method: pydantic collects validators by name, so a same-named engine
-        validator would silently replace core's (e.g. the canonical space-group
-        check or every symmetry rule). Its ``extra`` must stay ``'forbid'`` (A19).
+        """Guard core's contract in every engine subclass (A93, A109, A114, A122).
+
+        A subclass may add fields and validators that *check*, but nothing that
+        replaces, skips or rewrites core's validation:
+
+        1. no class in its MRO besides core's own (a subclass or a mixin) may
+           redeclare core's fields, reuse the name of a core validator, private
+           attribute or method, or define a pydantic entry point
+           (:data:`_RESERVED_ENTRY_POINTS`); pydantic collects validators by
+           name, so a same-named validator would silently replace core's;
+        2. every core validator must still be core's own function (catches any
+           route the names miss);
+        3. its own validators run in ``'after'`` mode only (a model validator,
+           or a field validator on a core field): a ``'before'``, ``'wrap'`` or
+           ``'plain'`` one could rewrite the recipe before core reads it, or
+           skip core entirely;
+        4. ``extra`` stays ``'forbid'`` (A19), and the parameter type is
+           :class:`RefinableParameter` or :class:`BoundedRefinableParameter`.
+
+        A canary test runs core's must-fail recipes through every engine phase
+        model (``tests/test_phase_canary.py``).
         """
         super().__pydantic_init_subclass__(**kwargs)
+        generic = cls.__pydantic_generic_metadata__
+        if generic["origin"] is not None:
+            wrong = [a for a in generic["args"] if not isinstance(a, TypeVar)
+                     and not (isinstance(a, type) and issubclass(a, (RefinableParameter, BoundedRefinableParameter)))]
+            if wrong:
+                raise TypeError(f"{cls.__name__}: the parameter type must be RefinableParameter or "
+                                f"BoundedRefinableParameter, not {', '.join(map(repr, wrong))}")
+        core_ancestry = set(Phase.__mro__)
         for klass in cls.__mro__:
-            if klass is Phase or not (isinstance(klass, type) and issubclass(klass, Phase)):
+            if klass in core_ancestry:
                 continue
-            if klass.__pydantic_generic_metadata__["origin"] is not None:
+            if issubclass(klass, Phase) and klass.__pydantic_generic_metadata__["origin"] is not None:
                 continue  # a parametrization (e.g. Phase[RefinableParameter]); its origin is checked itself
             annotations = inspect.get_annotations(klass)
             redeclared = [n for n in RESERVED_PHASE_FIELDS if n in annotations]
@@ -847,6 +884,31 @@ def __pydantic_init_subclass__(cls, **kwargs: Any) -> None:
                     f"{klass.__name__} reuses the core phase name(s) {', '.join(reused)}; a same-named "
                     "validator, method or private attribute would replace core's silently; rename it"
                 )
+            entry = sorted(n for n in _RESERVED_ENTRY_POINTS
+                           if n in klass.__dict__ and _defined_outside_pydantic(klass.__dict__[n]))
+            if entry:
+                raise TypeError(
+                    f"{klass.__name__} defines {', '.join(entry)}; a phase model may not override pydantic's "
+                    "entry points, which could skip or replace core's validation (A122)"
+                )
+        decorators = cls.__pydantic_decorators__
+        replaced = sorted(name for kind, name, func in _core_decorators()
+                          if _underlying(getattr(decorators, kind).get(name)) is not func)
+        if replaced:
+            raise TypeError(f"{cls.__name__} replaces the core validator(s) {', '.join(replaced)} (A109, A122)")
+        core_names = {name for _kind, name, _func in _core_decorators()}
+        rewriting = sorted(
+            [n for n, d in decorators.model_validators.items() if n not in core_names and d.info.mode != "after"]
+            + [n for n, d in decorators.field_validators.items()
+               if n not in core_names and d.info.mode != "after"
+               and ({"*", *RESERVED_PHASE_FIELDS} & set(d.info.fields))]
+            + list(decorators.validators) + list(decorators.root_validators))
+        if rewriting:
+            raise TypeError(
+                f"{cls.__name__}: validator(s) {', '.join(rewriting)} must be 'after' validators (pydantic v2 "
+                "@model_validator / @field_validator): a 'before', 'wrap' or 'plain' validator could rewrite "
+                "the recipe before core reads it, or skip core's validation (A115, A122)"
+            )
         if cls.model_config.get("extra") != "forbid":
             raise TypeError(f"{cls.__name__} must keep extra='forbid' (A19)")
         if cls.__pydantic_generic_metadata__["parameters"] and "__orig_bases__" not in cls.__dict__:
@@ -882,22 +944,47 @@ def problem(loc: tuple, message: str, value: Any) -> None:
             problems.append(InitErrorDetails(type="value_error", loc=loc, input=value,
                                              ctx={"error": ValueError(message)}))
 
-        def tie_rules(loc: tuple, params: dict, ties: Ties, context: str, fixed_value) -> dict:
-            errors, updates = _tie_rules(params, ties, context, fixed_value)
+        def tie_rules(loc: tuple, params: dict, ties: Ties, family: "_Family", context: str,
+                      fixed_text) -> dict:
+            errors, bounds = _tie_rules(params, ties, family, context, fixed_text)
             for name, message in errors:
                 problem((*loc, name), message, params[name].model_dump())
-            return updates
+            return bounds
 
         sg = self.space_group
+        seen: dict[str, str] = {}
+        for label in self.atoms:  # A112 (amended): an atom label is unique ignoring case
+            other = seen.setdefault(label.lower(), label)
+            if other != label:
+                problem(("atoms", label), f"atom labels {other!r} and {label!r} differ only in case; rename one",
+                        label)
+
         cell = self.unit_cell
-        try:
-            check_cell(sg, tuple(getattr(cell, k).value for k in _CELL_FIELDS))
-        except SymmetryError as exc:
-            problem(("unit_cell",), str(exc), cell.model_dump())
-        else:  # flag and bound rules need a valid cell (A95, A98)
-            ties = cell_tie_groups(sg)
-            tie_rules(("unit_cell",), {k: getattr(cell, k) for k in _CELL_FIELDS}, ties,
-                      f"{ties.crystal_system} cell ({sg!r})", lambda name: f"{getattr(cell, name).value:g}")
+        cell_params = {k: getattr(cell, k) for k in _CELL_FIELDS}
+        cell_ties = cell_tie_groups(sg)
+        fixed_angle = lambda name: _fixed_cell_angle(cell_ties, name)  # noqa: E731
+        derived_cell, write = _derive(cell_ties, {k: p.value for k, p in cell_params.items()}, fixed_angle, _CELL)
+        cell_ok = not write
+        if write:  # A77, A123
+            problem(("unit_cell",),
+                    f"unit cell is inconsistent with {sg!r} ({cell_ties.crystal_system}): stated "
+                    f"{', '.join(f'{k} = {cell_params[k].value!r}' for k in write)}, but by symmetry "
+                    f"{_ties_text(cell_ties, fixed_angle, only=write)}; write {_write_text(write)}",
+                    cell.model_dump())
+        else:
+            try:  # the metric must then be invariant (A77); the tie groups are checked against it exhaustively
+                check_cell(sg, tuple(derived_cell[k] for k in _CELL_FIELDS))
+            except SymmetryError as exc:  # pragma: no cover - cell_tie_groups agrees with the metric
+                problem(("unit_cell",), str(exc), cell.model_dump())
+                cell_ok = False
+        if cell_ok:  # flag and bound rules need a valid cell (A95, A98)
+            bounds = tie_rules(("unit_cell",), cell_params, cell_ties, _CELL,
+                               f"{cell_ties.crystal_system} cell ({sg!r})", lambda name: f"{fixed_angle(name)}")
+            updates = _updated(cell_params, derived_cell, bounds)
+            if updates:
+                self.unit_cell = cell.model_copy(update=updates)  # the caller's cell stays as given
+        model_cell = tuple(getattr(self.unit_cell, k).value for k in _CELL_FIELDS)
+
         for label, atom in self.atoms.items():
             try:
                 site = analyze_site(sg, (atom.x.value, atom.y.value, atom.z.value))
@@ -908,58 +995,53 @@ def tie_rules(loc: tuple, params: dict, ties: Ties, context: str, fixed_value) -
             context = f"atom {label!r} (multiplicity {site.multiplicity} in {sg!r})"
             ties = coupling_groups(sg, site.canonical)
             exact_xyz = lambda name: site.exact["xyz".index(name)]  # noqa: E731
+            xyz = {k: getattr(atom, k) for k in "xyz"}
             stated = dict(zip("xyz", site.stated))
-            read, write = _special_position_values(ties.xyz, stated, exact_xyz)
-            if write:  # A73, A115, A120: on a special position, but not exactly
-                off = max(abs(c - v) for c, v in zip(site.canonical, site.stated))
+            derived_xyz, write = _derive(ties.xyz, stated, exact_xyz, _COORDINATES)
+            if write:  # A73, A120, A121: within 5e-6 of a special position, but not stated as it
+                off = max(abs(stated[name] - value) for name, (value, _tol) in write.items())
                 problem(("atoms", label),
                         f"{context}: {site.stated} is {off:.2g} from a special position, not on it "
                         f"({_ties_text(ties.xyz, exact_xyz)}); write {_write_text(write)}", atom.model_dump())
-            xyz = {k: getattr(atom, k) for k in "xyz"}
-            if read and not write:  # A120: a value with no exact decimal form, stated to >= 6 decimals
-                xyz.update({k: getattr(atom, k).model_copy(update={"value": v}) for k, v in read.items()})
             if atom.Multiplicity is not None and atom.Multiplicity != site.multiplicity:
                 problem(("atoms", label, "Multiplicity"),
                         f"stated Multiplicity {atom.Multiplicity}, derived {site.multiplicity} "
                         f"({sg!r}, site {site.stated})", atom.Multiplicity)
-            uaniso_ok = False
+            updates = _updated(xyz, derived_xyz, tie_rules(("atoms", label), xyz, ties.xyz, _COORDINATES, context,
+                                                            lambda name: str(exact_xyz(name))))
             if atom.Uaniso is not None:
-                stated_u = tuple(getattr(atom.Uaniso, k).value for k in _UANISO_KEYS)
-                try:
-                    symmetric_u, u_adjusted = check_uij(sg, site.canonical, stated_u)
-                except SymmetryError as exc:
-                    problem(("atoms", label, "Uaniso"), str(exc), atom.model_dump()["Uaniso"])
-                else:
-                    uaniso_ok = True
-                    principal = np.linalg.eigvalsh(_uij_matrix(stated_u))
-                    if principal[0] <= 0:  # informative, not an error (A118): never changes a value
+                uij = {k: getattr(atom.Uaniso, k) for k in _UANISO_KEYS}
+                derived_u, write_u = _derive(ties.uij, {k: p.value for k, p in uij.items()},
+                                             lambda _name: Fraction(0), _UIJ)
+                if write_u:  # A78, A115, A121
+                    problem(("atoms", label, "Uaniso"),
+                            f"{context}: Uaniso is not site-symmetric ({_ties_text(ties.uij, lambda _n: 0)}); "
+                            f"write {_write_text(write_u)}", atom.model_dump()["Uaniso"])
+                elif cell_ok:
+                    principal = _principal_msd(model_cell, tuple(derived_u[k] for k in _UANISO_KEYS))
+                    scale = float(np.max(np.abs(principal)))
+                    if principal[0] <= 1e-12 * scale:  # informative, not an error (A118): changes nothing
+                        shown = ", ".join("0" if abs(v) <= 1e-12 * scale else f"{v:.3g}" for v in principal)
                         self._warnings.append(StructuredWarning(
                             code="uaniso_not_positive_definite",
-                            message=(f"{context}: Uaniso is not positive definite (principal values "
-                                     f"{', '.join(f'{v:.3g}' for v in principal)} A^2), so it describes no "
-                                     "thermal ellipsoid; it is used as stated"),
+                            message=(f"{context}: Uaniso is not positive definite (principal mean-square "
+                                     f"displacements {shown} A^2), so it describes no thermal ellipsoid; "
+                                     "it is used as stated"),
                             field_path=f"atoms.{label}.Uaniso",
                         ))
-                    if u_adjusted:  # A78, A115: within 1e-6 A^2 of symmetric, but not exactly
-                        problem(("atoms", label, "Uaniso"),
-                                f"{context}: Uaniso is not exactly site-symmetric "
-                                f"({_ties_text(ties.uij, lambda _name: 0)}); write "
-                                f"{_values_to_write(ties.uij, dict(zip(_UANISO_KEYS, stated_u)), lambda _n: 0)}",
-                                atom.model_dump()["Uaniso"])
-
-            # Flag and bound rules F1, F2, F4, A106 (A95, A98, A106).
-            xyz.update(tie_rules(("atoms", label), xyz, ties.xyz, context, lambda name: str(exact_xyz(name))))
-            if uaniso_ok:
-                tie_rules(("atoms", label, "Uaniso"), {k: getattr(atom.Uaniso, k) for k in _UANISO_KEYS},
-                          ties.uij, context, lambda _name: "0")
-            if any(xyz[k] is not getattr(atom, k) for k in "xyz"):
-                self.atoms[label] = atom.model_copy(update=xyz)  # the caller's atom stays as given
+                u_updates = _updated(uij, derived_u, tie_rules(("atoms", label, "Uaniso"), uij, ties.uij, _UIJ,
+                                                                context, lambda _name: "0"))
+                if u_updates:
+                    updates["Uaniso"] = atom.Uaniso.model_copy(update=u_updates)
+            if updates:
+                self.atoms[label] = atom.model_copy(update=updates)  # the caller's atom stays as given
         if problems:
             raise ValidationError.from_exception_data(type(self).__name__, problems)
         return self
 
     def site(self, label: str):
-        """The :class:`~powderline.symmetry.SiteAnalysis` of atom ``label``."""
+        """The :class:`~powderline.symmetry.SiteAnalysis` of atom ``label`` (its symmetry, not its values:
+        the model's atom holds the coordinates the engines receive)."""
         return self._sites[label]
 
     def warnings(self) -> list:
@@ -983,38 +1065,75 @@ def _reserved_phase_members() -> frozenset[str]:
     return frozenset(validators | methods | set(Phase.__private_attributes__))
 
 
+#: pydantic entry points a phase model (or a mixin in its MRO) may not define: each could
+#: skip or replace core's validation without reusing a core name (A122).
+_RESERVED_ENTRY_POINTS = ("__init__", "model_post_init", "model_validate", "model_validate_json",
+                          "model_validate_strings", "model_construct", "__get_pydantic_core_schema__",
+                          "__pydantic_init_subclass__", "__class_getitem__")
+
+
+def _underlying(obj: Any) -> Any:
+    """The plain function behind a pydantic decorator, classmethod or bound method."""
+    func = getattr(obj, "func", obj)
+    return getattr(func, "__func__", func)
+
+
+def _defined_outside_pydantic(obj: Any) -> bool:
+    """False for the members pydantic generates in every model (e.g. ``model_post_init``)."""
+    func = _underlying(obj)
+    func = getattr(func, "__wrapped__", func)
+    return not (getattr(func, "__module__", None) or "").startswith("pydantic")
+
+
+def _core_decorators() -> list[tuple[str, str, Any]]:
+    """``(kind, name, function)`` of every validator and serializer core's :class:`Phase` defines."""
+    decorators = Phase.__pydantic_decorators__
+    return [(kind, name, _underlying(info))
+            for kind in ("validators", "field_validators", "root_validators", "field_serializers",
+                         "model_serializers", "model_validators")
+            for name, info in getattr(decorators, kind).items()]
+
+
 _CELL_FIELDS = ("a", "b", "c", "alpha", "beta", "gamma")
 
 
 def _uij_matrix(u) -> np.ndarray:
-    """The symmetric 3x3 matrix of (U11, U22, U33, U12, U13, U23).
-
-    Its eigenvalues have the signs of the Cartesian tensor's (a congruence
-    transform keeps them, Sylvester's law of inertia), so it tells whether the
-    thermal ellipsoid exists without the cell.
-    """
+    """The symmetric 3x3 matrix of (U11, U22, U33, U12, U13, U23)."""
     u11, u22, u33, u12, u13, u23 = u
     return np.array([[u11, u12, u13], [u12, u22, u23], [u13, u23, u33]], dtype=float)
 
 
+def _principal_msd(cell: tuple, u) -> np.ndarray:
+    """The principal mean-square displacements (A^2, ascending) of ``u`` in ``cell`` (A118).
+
+    The Cartesian tensor is ``A N U N A^T`` (``A`` the orthogonalization matrix,
+    ``N = diag(a*, b*, c*)``). It is a congruence transform of the Uij matrix, so
+    the signs are the Uij matrix's (Sylvester's law of inertia), but the values
+    are only right in Cartesian axes (an isotropic hexagonal U has U12 = U11/2).
+    """
+    unit_cell = gemmi.UnitCell(*cell)
+    orth = np.array(unit_cell.orth.mat.tolist())
+    reciprocal = unit_cell.reciprocal()
+    n = np.diag([reciprocal.a, reciprocal.b, reciprocal.c])
+    return np.linalg.eigvalsh(orth @ n @ _uij_matrix(u) @ n @ orth.T)
+
+
 def _same(got: float, want: float) -> bool:
     """Equal to floating-point precision (``ADJUSTMENT_REPORT_TOL``, relative above 1)."""
     return abs(got - want) <= ADJUSTMENT_REPORT_TOL * max(1.0, abs(want))
 
 
-def _ties_text(ties: Ties, exact) -> str:
-    """The symmetry relations of a parameter set, e.g. ``"x = 1/3, y = 2/3"`` or ``"y = 2x"``."""
-    parts = [f"{name} = {exact(name)}" for name in ties.fixed]
-    parts += [g.relations_text() for g in ties.groups if g.relations_text()]
-    return ", ".join(parts)
+def _within(got: float, want: float, tol: float) -> bool:
+    """``got`` states ``want`` within ``tol`` (never tighter than floating-point precision)."""
+    return _same(got, want) or abs(got - want) <= tol
 
 
 def _has_decimal_form(value: Fraction) -> bool:
     """True when ``value`` has a finite decimal form (1/2, 1/4, 3/8), False for 1/3, 1/6, 1/12.
 
     Symmetry only produces denominators 1, 2, 3, 4, 6, 8, 12 for fixed
-    coordinates, tie factors ±1, ±2, ±1/2 and offsets with denominators 1-4 (all
-    settings, every distinct special site), so "no decimal form" means "a third".
+    coordinates (all settings, every distinct special site), so "no decimal
+    form" means "a third".
     """
     d = value.denominator
     for p in (2, 5):
@@ -1023,59 +1142,119 @@ def _has_decimal_form(value: Fraction) -> bool:
     return d == 1
 
 
-def _special_position_values(ties: Ties, stated: dict, exact) -> tuple[dict, dict]:
-    """``(read, write)``: the coordinates read as their exact value, and those to write (A120).
+@dataclass(frozen=True)
+class _Family:
+    """How closely a recipe must state the derived values of one kind of parameter (A121, A123).
 
-    Each tie group keeps its first member as stated (the one parameter, A94);
-    every other member's exact value is ``k * rep + c``, a fixed one's its exact
-    fraction. Where it differs from the stated value beyond floating-point noise:
-    a value with no exact decimal form (a third: 1/3, 1/6, ``x + 1/3``) stated
-    within ``SPECIAL_POSITION_TOL`` (6 decimals) is **read** as the exact value;
-    any other is to be **written** (``0.4999999`` must be ``0.5``). ``write`` maps
-    a name to ``(value, has_decimal_form)``.
+    ``fixed(name, exact)`` and ``member(name, derived)`` give the tolerance for a
+    symmetry-fixed parameter and for a tied member (0 = floating-point precision).
     """
-    target: dict[str, tuple[float, bool]] = {}
+
+    fixed: Callable[[str, Fraction], float]
+    member: Callable[[str, float], float]
+
+
+#: Coordinates: a fixed one with a decimal form exactly, a third to 6 decimals (A73, A120);
+#: a coupled one within 6 decimals of the value derived from its group's first member (A121).
+_COORDINATES = _Family(fixed=lambda _n, exact: 0.0 if _has_decimal_form(exact) else SPECIAL_POSITION_TOL,
+                       member=lambda _n, _v: SPECIAL_POSITION_TOL)
+#: Uij: a fixed one is exactly 0; a coupled one within 1e-6 A^2 (A78, A121).
+_UIJ = _Family(fixed=lambda _n, _exact: 0.0, member=lambda _n, _v: UIJ_TOL)
+
+
+def _cell_tol(name: str, value) -> float:
+    return CELL_TOL * abs(float(value)) if name in ("a", "b", "c") else CELL_TOL
+
+
+#: Cell: within CELL_TOL, relative on lengths, degrees on angles (A77, A123).
+_CELL = _Family(fixed=_cell_tol, member=_cell_tol)
+
+
+def _fixed_cell_angle(ties, name: str) -> Fraction:
+    """The exact value of a symmetry-fixed cell angle: 120 for gamma on hexagonal axes, else 90."""
+    return Fraction(120) if name == "gamma" and ties.crystal_system in ("hexagonal", "trigonal") else Fraction(90)
+
+
+def _derive(ties: Ties, stated: dict, exact, family: _Family) -> tuple[dict, dict]:
+    """``(derived, write)`` for one parameter set (a cell, a site's x/y/z, or its Uij; A121).
+
+    Each tie group's first member is the independent parameter and keeps its
+    stated value. Every other value is derived in exact rational arithmetic:
+    a fixed one is its exact value ``exact(name)``, a member ``k * rep + c``.
+    ``derived`` maps every name to the float nearest its derived value (what
+    the model holds); ``write`` maps the names stated beyond ``family``'s
+    tolerance to ``(derived, tolerance)``.
+    """
+    targets: dict[str, tuple[Fraction, float]] = {}
     for name in ties.fixed:
-        target[name] = (float(exact(name)), _has_decimal_form(exact(name)))
+        value = Fraction(exact(name))
+        targets[name] = (value, family.fixed(name, value))
     for group in ties.groups:
-        rep = stated[group.members[0]]
-        for name, k, c in zip(group.members, group.coefficients, group.offsets):
-            target[name] = (float(k) * rep + float(c), _has_decimal_form(k) and _has_decimal_form(c))
-    read, write = {}, {}
+        rep = Fraction(stated[group.members[0]])
+        targets[group.members[0]] = (rep, 0.0)
+        for name, k, c in zip(group.members[1:], group.coefficients[1:], group.offsets[1:]):
+            value = k * rep + c
+            targets[name] = (value, family.member(name, float(value)))
+    derived, write = {}, {}
     for name, value in stated.items():
-        exact_value, decimal = target[name]
-        if _same(value, exact_value):
-            continue
-        if not decimal and abs(value - exact_value) <= SPECIAL_POSITION_TOL:
-            read[name] = exact_value
-        else:
-            write[name] = (exact_value, decimal)
-    return read, write
+        target, tol = targets[name]
+        derived[name] = float(target)
+        if not _within(value, derived[name], tol):
+            write[name] = (derived[name], tol)
+    return derived, write
+
+
+def _updated(params: dict, derived: dict, bounds: dict) -> dict:
+    """``model_copy`` updates for the parameters whose value or bounds the model holds derived."""
+    updates = {}
+    for name, param in params.items():
+        update = {} if derived[name] == param.value else {"value": derived[name]}
+        if name in bounds and bounds[name] != (param.min, param.max):
+            update["min"], update["max"] = bounds[name]
+        if update:
+            updates[name] = param.model_copy(update=update)
+    return updates
+
+
+def _ties_text(ties: Ties, exact, only=None) -> str:
+    """The symmetry relations of a parameter set, e.g. ``"x = 1/3, y = 2/3"``, ``"y = 2x"``, ``"b = a"``."""
+    parts = [f"{name} = {exact(name)}" for name in ties.fixed]
+    parts += [g.relation_text(m) for g in ties.groups for m in g.members[1:]]
+    if only is not None:
+        parts = [p for p in parts if p.split(" = ")[0] in only]
+    return ", ".join(parts)
 
 
-def _fmt_exact(value: float, decimal: bool) -> str:
-    """A value to write: exactly (``repr``) when it has a decimal form, else to 6 decimals."""
-    return repr(value) if decimal else f"{value:.6f} (to at least 6 decimals)"
+def _fmt_value(value: float, tol: float) -> str:
+    """A value to write: exactly when its decimal form is short (``0.5``, ``0.0061735``), else the
+    fewest decimals (at least 6) that state it within ``tol`` (``0.333333 (to at least 6 decimals)``)."""
+    text = repr(value)
+    if "e" not in text and len(text.partition(".")[2]) <= 8:
+        return text
+    for n in range(6, 17):
+        rounded = f"{value:.{n}f}"
+        if abs(float(rounded) - value) <= tol / 10:
+            return f"{rounded} (to at least {n} decimals)"
+    return text
 
 
 def _write_text(write: dict) -> str:
-    return ", ".join(f"{name} = {_fmt_exact(v, decimal)}" for name, (v, decimal) in write.items())
-
+    return ", ".join(f"{name} = {_fmt_value(value, tol)}" for name, (value, tol) in write.items())
 
-def _values_to_write(ties: Ties, stated: dict, exact) -> str:
-    """``"U12 = 0.0061735"``: the values that make ``stated`` exactly symmetric (Uij: always a decimal form)."""
-    _read, write = _special_position_values(ties, stated, exact)
-    return _write_text(write)
 
-
-def _fmt_bounds(lo: Optional[float], hi: Optional[float], decimal: bool = True) -> str:
-    return "[" + ", ".join("null" if v is None else repr(v) if decimal else f"{v:.6f}" for v in (lo, hi)) + "]"
+def _fmt_bounds(lo: Optional[float], hi: Optional[float], tol: Optional[float] = None) -> str:
+    """``[min, max]`` as stated (``repr``), or, with ``tol``, as values to write (:func:`_fmt_value`)."""
+    texts = ["null" if v is None else repr(v) if tol is None else _fmt_value(v, tol) for v in (lo, hi)]
+    values, notes = zip(*(t.partition(" (")[::2] for t in texts))
+    note = max(notes)
+    return f"[{', '.join(values)}]" + (f" ({note}" if note else "")
 
 
 _HOW_MANY = {2: "both", 3: "all three"}
 
 
-def _tie_rules(params: dict, ties: Ties, context: str, fixed_value) -> tuple[list[tuple[str, str]], dict]:
+def _tie_rules(params: dict, ties: Ties, family: _Family, context: str,
+               fixed_value) -> tuple[list[tuple[str, str]], dict]:
     """The flag and bound rules of one parameter set (cell, a site's x/y/z, or its Uij).
 
     - **F2** (A95): a symmetry-fixed parameter has refine flag false.
@@ -1083,19 +1262,17 @@ def _tie_rules(params: dict, ties: Ties, context: str, fixed_value) -> tuple[lis
     - **F1** (A95): the members of a tie group carry the same flag. The error is
       reported at every member whose flag differs from the group's first
       member, naming the whole group (review N1).
-    - **F4** (A98, A115): with bounds, each member's bounds follow the tie from
-      the first member's: ``member = k*rep + c`` maps ``[min, max]`` to
-      ``[k*min + c, k*max + c]``, swapped for k < 0; a null side stays null on
-      the matching side. Anything but the exact mapped bounds (to floating-point
-      precision) is an error giving them, except that a bound with no exact
-      decimal form (an offset of a third) stated to 6 decimals is read as the
-      exact one (A120).
+    - **F4** (A98, A121): with bounds, each member's bounds are derived from the
+      first member's like its value: ``member = k*rep + c`` maps ``[min, max]``
+      to ``[k*min + c, k*max + c]``, swapped for k < 0; a null side stays null on
+      the matching side. Stated within ``family``'s member tolerance, they are
+      read as the derived bounds; otherwise an error gives them.
     - **F3**: different groups are independent (nothing to check).
 
-    Returns ``([(name, message)], {name: param with the read bounds})``.
+    Returns ``([(name, message)], {name: (min, max) derived})``.
     """
     errors: list[tuple[str, str]] = []
-    updates: dict[str, Any] = {}
+    bounds: dict[str, tuple] = {}
     for name in ties.fixed:
         param = params[name]
         if param.refine_flag:
@@ -1119,28 +1296,20 @@ def _tie_rules(params: dict, ties: Ties, context: str, fixed_value) -> tuple[lis
             continue
         for name in group.members[1:]:
             param = params[name]
-            k, c = (float(v) for v in group.relation(name))
-            lo, hi = (None if v is None else k * v + c for v in (rep.min, rep.max))
+            k, c = group.relation(name)
+            lo, hi = (None if v is None else float(k * Fraction(v) + c) for v in (rep.min, rep.max))
             if k < 0:
                 lo, hi = hi, lo
-            pairs = ((param.min, lo), (param.max, hi))
-            if not all((got is None) == (want is None) for got, want in pairs):
-                exact = readable = False
-            else:
-                exact = all(got is None or _same(got, want) for got, want in pairs)
-                readable = all(got is None or abs(got - want) <= SPECIAL_POSITION_TOL for got, want in pairs)
-            decimal = all(_has_decimal_form(v) for v in group.relation(name))
-            if exact:
-                continue
-            if readable and not decimal:  # A120: e.g. y = x + 1/3, stated to 6 decimals
-                updates[name] = param.model_copy(update={"min": lo, "max": hi})
+            tol = family.member(name, max(abs(v) for v in (lo, hi, 0.0) if v is not None))
+            if all((got is None) == (want is None) and (got is None or _within(got, want, tol))
+                   for got, want in ((param.min, lo), (param.max, hi))):
+                bounds[name] = (lo, hi)
                 continue
             errors.append((name, f"{context}: the bounds of {name} must follow "
                                  f"{group.relation_text(name)} from the bounds of {group.members[0]} "
-                                 f"{_fmt_bounds(rep.min, rep.max)}: write {_fmt_bounds(lo, hi, decimal)}"
-                                 f"{'' if decimal else ' (to at least 6 decimals)'}, "
+                                 f"{_fmt_bounds(rep.min, rep.max)}: write {_fmt_bounds(lo, hi, tol)}, "
                                  f"not {_fmt_bounds(param.min, param.max)}"))
-    return errors, updates
+    return errors, bounds
 
 
 # --- top-level recipe frame (A1, A18, A21, A40) ------------------------------
diff --git a/tests/test_phase_canary.py b/tests/test_phase_canary.py
new file mode 100644
index 0000000..1f5d62f
--- /dev/null
+++ b/tests/test_phase_canary.py
@@ -0,0 +1,130 @@
+"""Canary: core's must-fail recipes fail through every engine phase model (A122; re/03b PR review S2).
+
+``Phase.__pydantic_init_subclass__`` rejects, when a class is defined, an engine subclass that could
+replace, skip or rewrite core's validation. This is the behavioural check behind that structural guard:
+each engine phase model must reject every core violation at the same location as core does, and must
+hold the same values as core for a valid recipe (so no engine validator rewrites it, A115).
+
+re/04-06 add each engine phase model to ``ENGINE_PHASES``, with the engine fields a valid phase needs;
+``test_every_engine_phase_model_is_covered`` fails until they do.
+"""
+
+from __future__ import annotations
+
+import importlib
+
+import pytest
+from pydantic import ValidationError
+
+from powderline.schema_core import BoundedRefinableParameter, Phase, RefinableParameter
+
+#: ``(module, class name, parameter type, engine fields of a valid phase)`` of every engine phase model.
+ENGINE_PHASES: list[tuple[str, str, type, dict]] = []
+
+
+def _models():
+    models = [(f"Phase[{p.__name__}]", Phase[p], p, {}) for p in (RefinableParameter, BoundedRefinableParameter)]
+    for module, name, param, fields in ENGINE_PHASES:
+        models.append((f"{module}.{name}", getattr(importlib.import_module(module), name), param, fields))
+    return models
+
+
+_MODELS = _models()
+
+
+def _p(value, flag=False, bounded=False, lo=None, hi=None):
+    return [value, flag, lo, hi] if bounded else [value, flag]
+
+
+def _phase(bounded: bool, sg="P m -3 m", cell=(4.0, 4.0, 4.0, 90.0, 90.0, 90.0), atoms=None) -> dict:
+    def atom(xyz, element="O"):
+        return {"element": element, **{k: _p(v, bounded=bounded) for k, v in zip("xyz", xyz)},
+                "occupancy": _p(1.0, bounded=bounded), "ADP": "Uiso", "Uiso": _p(0.01, bounded=bounded)}
+
+    atoms = atoms or {"A": (0.0, 0.0, 0.0), "B": (0.5, 0.2, 0.2)}
+    return {"space_group": sg,
+            "unit_cell": {k: _p(v, bounded=bounded) for k, v in zip(("a", "b", "c", "alpha", "beta", "gamma"), cell)},
+            "atoms": {label: atom(xyz) for label, xyz in atoms.items()}}
+
+
+def _break(case: str, d: dict, bounded: bool) -> tuple:
+    """Make ``d`` violate one core rule; return the location core reports it at."""
+    if case == "space group not canonical (A105)":
+        d["space_group"] = "Pm-3m"
+        return ("space_group",)
+    if case == "fixed parameter refined (F2)":
+        d["unit_cell"]["alpha"][1] = True
+        return ("unit_cell", "alpha")
+    if case == "tied flags differ (F1)":
+        d["unit_cell"]["a"][1] = True
+        return ("unit_cell", "b")
+    if case == "decimal special position not exact (A120)":
+        d["atoms"]["B"]["x"][0] = 0.4999999
+        return ("atoms", "B")
+    if case == "ambiguous position (A73)":
+        d["atoms"]["B"]["z"][0] = 0.2003
+        return ("atoms", "B")
+    if case == "Multiplicity wrong":
+        d["atoms"]["A"]["Multiplicity"] = 2
+        return ("atoms", "A", "Multiplicity")
+    if case == "fixed Uij not exactly 0 (A121)":
+        del d["atoms"]["A"]["Uiso"]
+        d["atoms"]["A"]["ADP"] = "Uaniso"
+        d["atoms"]["A"]["Uaniso"] = {k: _p(v, bounded=bounded) for k, v in
+                                     zip(("U11", "U22", "U33", "U12", "U13", "U23"), (0.01, 0.01, 0.01, 1e-9, 0, 0))}
+        return ("atoms", "A", "Uaniso")
+    if case == "atom labels differ only in case (A112)":
+        d["atoms"]["a"] = d["atoms"].pop("B")
+        return ("atoms", "a")
+    if case == "fixed parameter has bounds (A106)":
+        d["unit_cell"]["alpha"][2:] = [89.0, 91.0]
+        return ("unit_cell", "alpha")
+    if case == "tied bounds differ (F4)":
+        d["unit_cell"]["a"][2:] = [3.9, 4.1]
+        return ("unit_cell", "b")
+    raise AssertionError(case)  # pragma: no cover
+
+
+_CASES = ["space group not canonical (A105)", "fixed parameter refined (F2)", "tied flags differ (F1)",
+          "decimal special position not exact (A120)", "ambiguous position (A73)", "Multiplicity wrong",
+          "fixed Uij not exactly 0 (A121)", "atom labels differ only in case (A112)"]
+_BOUNDED_CASES = ["fixed parameter has bounds (A106)", "tied bounds differ (F4)"]
+
+
+@pytest.mark.parametrize("label, model, param, fields", _MODELS, ids=[m[0] for m in _MODELS])
+def test_core_rules_hold_in_every_phase_model(label, model, param, fields):
+    bounded = param is BoundedRefinableParameter
+    Phase.__dict__["__pydantic_init_subclass__"].__func__(model)  # the structural guard, whatever overrides it
+    for case in _CASES + (_BOUNDED_CASES if bounded else []):
+        d = {**_phase(bounded), **fields}
+        loc = _break(case, d, bounded)
+        with pytest.raises(ValidationError) as exc_info:
+            model.model_validate(d)
+        assert loc in [e["loc"] for e in exc_info.value.errors()], f"{label}: {case}"
+
+
+@pytest.mark.parametrize("label, model, param, fields", _MODELS, ids=[m[0] for m in _MODELS])
+def test_every_phase_model_holds_cores_values(label, model, param, fields):
+    """Thirds and derived members read the same in every model (A120, A121): no engine rewrites them."""
+    bounded = param is BoundedRefinableParameter
+    d = _phase(bounded, "P 63/m m c", (3.2, 3.2, 5.2, 90.0, 90.0, 120.0),
+               {"A": (0.333333, 0.666667, 0.25), "B": (0.833333, 0.666667, 0.25)})
+    core = Phase[param].model_validate(d).model_dump()
+    engine = model.model_validate({**d, **fields}).model_dump()
+    assert {k: engine[k] for k in core} == core
+
+
+def _subclasses(cls):
+    for sub in cls.__subclasses__():
+        yield sub
+        yield from _subclasses(sub)
+
+
+def test_every_engine_phase_model_is_covered():
+    """Every concrete phase model in PowderLine's own modules is in ENGINE_PHASES."""
+    covered = {model for _label, model, _param, _fields in _MODELS}
+    found = {cls for cls in _subclasses(Phase)
+             if cls.__module__.startswith("powderline.")
+             and not cls.__pydantic_generic_metadata__["parameters"]
+             and cls.__pydantic_generic_metadata__["origin"] is not Phase}
+    assert found <= covered, sorted(f"{c.__module__}.{c.__qualname__}" for c in found - covered)
diff --git a/tests/test_schema_core.py b/tests/test_schema_core.py
index 8531cbd..b1a83a6 100644
--- a/tests/test_schema_core.py
+++ b/tests/test_schema_core.py
@@ -1124,7 +1124,7 @@ def test_phase_special_position_with_a_decimal_form_must_be_exact():
         Phase[RefinableParameter].model_validate(d)
     assert _errs(exc_info) == [(("atoms", "A1"),
                                 "atom 'A1' (multiplicity 2 in 'P 63/m m c'): (0.333333, 0.666667, 0.2499999) is "
-                                "3.3e-07 from a special position, not on it (x = 1/3, y = 2/3, z = 1/4); write z = 0.25")]
+                                "1e-07 from a special position, not on it (x = 1/3, y = 2/3, z = 1/4); write z = 0.25")]
 
 
 _R3M_CELL = {"a": [4.0, False], "b": [4.0, False], "c": [20.0, False],
@@ -1152,7 +1152,9 @@ def phase(y_bounds):
         return {"space_group": "R -3 m:H", "unit_cell": cell, "atoms": {"O1": atom}}
 
     y = Phase[BRP].model_validate(phase((0.383333, 0.483333))).atoms["O1"].y
-    assert y.model_dump() == [0.1 + 1 / 3, True, 0.05 + 1 / 3, 0.15 + 1 / 3]
+    third = Fraction(1, 3)  # the model holds the float nearest each exact value (A120, A121)
+    assert y.model_dump() == [float(Fraction(0.1) + third), True, float(Fraction(0.05) + third),
+                              float(Fraction(0.15) + third)]
     with pytest.raises(ValidationError) as exc_info:
         Phase[BRP].model_validate(phase((0.3833, 0.4833)))
     assert _errs(exc_info) == [(("atoms", "O1", "y"),
@@ -1203,10 +1205,8 @@ def test_phase_cell_cubic_b_neq_a_rejected():
     d["unit_cell"]["b"] = [4.2, False]
     with pytest.raises(ValidationError) as exc_info:
         Phase[RefinableParameter].model_validate(d)
-    msg = str(exc_info.value)
-    assert "b = 4.2 (symmetric value" in msg
-    assert "inconsistent" in msg
-    assert _errors(exc_info) == [(("unit_cell",), "value_error")]
+    assert _errs(exc_info) == [(("unit_cell",), "unit cell is inconsistent with 'P m -3 m' (cubic): stated b = 4.2, "
+                                                 "but by symmetry b = a; write b = 4.15692")]
 
 
 def test_phase_cell_cubic_gamma_91_rejected():
@@ -1254,18 +1254,22 @@ def test_phase_uaniso_cubic_m3m_isotropic_accepted():
 
 
 def test_phase_uaniso_cubic_m3m_anisotropic_rejected():
-    """Phase: La at (0,0,0) in P m -3 m with U11!=U22 rejected (breaks symmetry)."""
+    """Phase: La at (0,0,0) in P m -3 m with U11!=U22 rejected (breaks symmetry); the values to write
+    are derived from the first member (A121)."""
     d = _valid_pmm_lab6_phase_dict()
     d["atoms"]["La1"]["ADP"] = "Uaniso"
     d["atoms"]["La1"]["Uaniso"] = {"U11": [0.01, False], "U22": [0.02, False], "U33": [0.01, False], "U12": [0, False], "U13": [0, False], "U23": [0, False]}
     del d["atoms"]["La1"]["Uiso"]
-    with pytest.raises(ValidationError, match="break the site symmetry"):
+    with pytest.raises(ValidationError) as exc_info:
         Phase[RefinableParameter].model_validate(d)
+    assert _errs(exc_info) == [(("atoms", "La1", "Uaniso"),
+                                "atom 'La1' (multiplicity 1 in 'P m -3 m'): Uaniso is not site-symmetric "
+                                "(U12 = 0, U13 = 0, U23 = 0, U22 = U11, U33 = U11); write U22 = 0.01")]
 
 
-def test_phase_uaniso_hexagonal_6h_not_exact_rejected():
-    """A115: at 6h U12 = U22/2; a U12 within 1e-6 of it but not exact is an error giving the value
-    derived from the stated U22. Writing it validates."""
+def test_phase_uaniso_hexagonal_6h_coupled_member_read_within_1e_6():
+    """A121: at 6h U12 = U22/2 is derived from the stated U22. A U12 stated within 1e-6 A^2 (A78) is
+    read as the derived value (0.006174 -> 0.0061735); further off is an error giving it."""
     d = {
         "space_group": "P 63/m m c",
         "unit_cell": {"a": [3.2, False], "b": [3.2, False], "c": [5.2, False], "alpha": [90, False], "beta": [90, False], "gamma": [120, False]},
@@ -1278,13 +1282,35 @@ def test_phase_uaniso_hexagonal_6h_not_exact_rejected():
             }
         },
     }
+    assert Phase[RefinableParameter].model_validate(d).atoms["A1"].Uaniso.U12.value == 0.0061735
+    d["atoms"]["A1"]["Uaniso"]["U12"][0] = 0.006176
     with pytest.raises(ValidationError) as exc_info:
         Phase[RefinableParameter].model_validate(d)
     assert _errs(exc_info) == [(("atoms", "A1", "Uaniso"),
-                                "atom 'A1' (multiplicity 6 in 'P 63/m m c'): Uaniso is not exactly site-symmetric "
+                                "atom 'A1' (multiplicity 6 in 'P 63/m m c'): Uaniso is not site-symmetric "
                                 "(U13 = 0, U23 = 0, U12 = U22/2); write U12 = 0.0061735")]
-    d["atoms"]["A1"]["Uaniso"]["U12"][0] = 0.0061735
-    assert Phase[RefinableParameter].model_validate(d).model_dump() == d
+
+
+def test_phase_uaniso_fixed_component_must_be_exactly_zero():
+    """A121: a symmetry-fixed Uij is a constant of the site, 0, which has a decimal form: 1e-9 is an
+    error ("write U13 = 0.0"), never read as 0."""
+    d = {
+        "space_group": "P 63/m m c",
+        "unit_cell": {"a": [3.2, False], "b": [3.2, False], "c": [5.2, False], "alpha": [90, False], "beta": [90, False], "gamma": [120, False]},
+        "atoms": {
+            "A1": {
+                "element": "O", "x": [0.2, False], "y": [0.4, False], "z": [0.25, False],
+                "occupancy": [1.0, False], "ADP": "Uaniso",
+                "Uaniso": {"U11": [0.012, False], "U22": [0.012, False], "U33": [0.02, False],
+                           "U12": [0.006, False], "U13": [1e-9, False], "U23": [0.0, False]},
+            }
+        },
+    }
+    with pytest.raises(ValidationError) as exc_info:
+        Phase[RefinableParameter].model_validate(d)
+    assert _errs(exc_info) == [(("atoms", "A1", "Uaniso"),
+                                "atom 'A1' (multiplicity 6 in 'P 63/m m c'): Uaniso is not site-symmetric "
+                                "(U13 = 0, U23 = 0, U12 = U22/2); write U13 = 0.0")]
 
 
 def test_phase_multiple_atom_problems_all_reported():
@@ -2048,20 +2074,24 @@ def test_bounds_open_side_must_match():
     assert _errs(exc_info)[0][1].endswith("write [0.3, 0.5], not [null, 0.5]")
 
 
-def test_tied_coordinate_bounds_not_exact_rejected():
-    """A115 (replaces A108's snap): tied bounds must be the exact mapped values, to floating-point
-    precision; 4e-6 off is an error giving them."""
-    d = _bounded_phase("P -4 21 m", (5, 5, 4, 90, 90, 90), (0.1, 0.4, 0.3), (True, True, False),
-                       {"x": (0.0, 0.2), "y": (0.300004, 0.5)})
+def test_tied_coordinate_bounds_read_within_6_decimals():
+    """A121 (replaces A115's exact tied bounds): a tied member's bounds are derived from the first
+    member's like its value; 4e-6 off is read as [0.3, 0.5], 1e-5 off is an error giving them."""
+    def phase(y_bounds):
+        return _bounded_phase("P -4 21 m", (5, 5, 4, 90, 90, 90), (0.1, 0.4, 0.3), (True, True, False),
+                              {"x": (0.0, 0.2), "y": y_bounds})
+
+    assert Phase[BRP].model_validate(phase((0.300004, 0.5))).atoms["A"].y.model_dump() == [0.4, True, 0.3, 0.5]
     with pytest.raises(ValidationError) as exc_info:
-        Phase[BRP].model_validate(d)
+        Phase[BRP].model_validate(phase((0.30001, 0.5)))
     assert _errs(exc_info) == [(("atoms", "A", "y"),
                                 "atom 'A' (multiplicity 4 in 'P -4 21 m'): the bounds of y must follow "
-                                "y = -x + 1/2 from the bounds of x [0.0, 0.2]: write [0.3, 0.5], not [0.300004, 0.5]")]
+                                "y = -x + 1/2 from the bounds of x [0.0, 0.2]: write [0.3, 0.5], not [0.30001, 0.5]")]
 
 
 def test_tied_uij_bounds_factor_two():
-    """6h: U12 = U22/2, so U22 in [0, 0.02] gives U12 in [0, 0.01], exactly (A98, A115)."""
+    """6h: U12 = U22/2, so U22 in [0, 0.02] gives U12 in [0, 0.01]; within 1e-6 A^2 read as those (A98,
+    A121), further off an error giving them."""
     values = (0.01, 0.012, 0.009, 0.006, 0.0, 0.0)
     flags = (True, True, True, True, False, False)
 
@@ -2071,27 +2101,30 @@ def phase(u12_bounds):
         return _phasep("P 63/m m c", _cellp(_HEX, bounds={}), {"C": a})
 
     assert Phase[BRP].model_validate(phase((0.0, 0.01))).atoms["C"].Uaniso.U12.model_dump() == [0.006, True, 0.0, 0.01]
+    assert Phase[BRP].model_validate(phase((0.0, 0.0100009))).atoms["C"].Uaniso.U12.model_dump() == [0.006, True, 0.0, 0.01]
     with pytest.raises(ValidationError) as exc_info:
-        Phase[BRP].model_validate(phase((0.0, 0.0100009)))
+        Phase[BRP].model_validate(phase((0.0, 0.010002)))
     assert _errs(exc_info) == [(("atoms", "C", "Uaniso", "U12"),
                                 "atom 'C' (multiplicity 6 in 'P 63/m m c'): the bounds of U12 must follow "
                                 "U12 = U22/2 from the bounds of U22 [0.0, 0.02]: write [0.0, 0.01], "
-                                "not [0.0, 0.0100009]")]
+                                "not [0.0, 0.010002]")]
 
 
-def test_tied_cell_bounds_equal_exactly():
-    """Cell ties are equalities; equal to floating-point precision (relative above 1; A115)."""
+def test_tied_cell_bounds_follow_the_first_member():
+    """Cell ties are equalities: a member's bounds are the first member's, within CELL_TOL (1e-9, relative
+    on lengths; A77, A123), and the model holds them exactly; further off is an error giving them."""
     def phase(b_max):
         cell = _cellp((4, 4, 4, 90, 90, 90), (True, True, True, False, False, False),
                       {"a": (3.9, 4.2), "b": (3.9, b_max), "c": (3.9, 4.2)})
         return _phasep("P m -3 m", cell, {"A": _atomp(_GENERAL, bounds={})})
 
-    assert Phase[BRP].model_validate(phase(4.2 + 1e-15)).unit_cell.b.model_dump() == [4.0, True, 3.9, 4.2 + 1e-15]
+    for b_max in (4.2 + 1e-15, 4.200000001):
+        assert Phase[BRP].model_validate(phase(b_max)).unit_cell.b.model_dump() == [4.0, True, 3.9, 4.2]
     with pytest.raises(ValidationError) as exc_info:
-        Phase[BRP].model_validate(phase(4.200000001))
+        Phase[BRP].model_validate(phase(4.20001))
     assert _errs(exc_info) == [(("unit_cell", "b"),
                                 "cubic cell ('P m -3 m'): the bounds of b must follow b = a from the bounds "
-                                "of a [3.9, 4.2]: write [3.9, 4.2], not [3.9, 4.200000001]")]
+                                "of a [3.9, 4.2]: write [3.9, 4.2], not [3.9, 4.20001]")]
 
 
 def test_symmetry_fixed_parameters_have_no_bounds_a106():
@@ -2226,12 +2259,13 @@ def _p1_uaniso_phase(u):
 
 def test_uaniso_not_positive_definite_warns_and_keeps_the_values():
     """A118: informative, never an error or a change; the same recipe gives the same warning again."""
-    d = _p1_uaniso_phase((0.01, 0.01, 0.01, 0.02, 0.0, 0.0))  # principal values -0.01, 0.01, 0.03
+    d = _p1_uaniso_phase((0.01, 0.01, 0.01, 0.02, 0.0, 0.0))  # Uij matrix eigenvalues -0.01, 0.01, 0.03
     phase = Phase[RP].model_validate(d)
     assert phase.model_dump() == d
     expected = [{"code": "uaniso_not_positive_definite",
                  "message": "atom 'O1' (multiplicity 1 in 'P 1'): Uaniso is not positive definite (principal "
-                            "values -0.01, 0.01, 0.03 A^2), so it describes no thermal ellipsoid; it is used as stated",
+                            "mean-square displacements -0.0112, 0.00981, 0.0288 A^2), so it describes no thermal "
+                            "ellipsoid; it is used as stated",
                  "field_path": "atoms.O1.Uaniso"}]
     assert phase.warnings() == expected
     assert Phase[RP].model_validate(phase.model_dump()).warnings() == expected
@@ -2240,3 +2274,269 @@ def test_uaniso_not_positive_definite_warns_and_keeps_the_values():
 def test_uaniso_positive_definite_gives_no_warning():
     phase = Phase[RP].model_validate(_p1_uaniso_phase((0.01, 0.012, 0.009, 0.002, -0.001, 0.0005)))
     assert phase.warnings() == []
+
+
+from powderline.schema_core import _principal_msd  # noqa: E402
+from powderline.symmetry import _metric, check_cell  # noqa: E402
+
+
+def _isotropic_uij(cell, u_iso):
+    """U^ij of an isotropic U in ``cell``: u_iso * G*^ij / (a*_i a*_j)."""
+    g = np.linalg.inv(_metric(cell))
+    rec = np.sqrt(np.diag(g))
+    u = u_iso * g / np.outer(rec, rec)
+    return (u[0, 0], u[1, 1], u[2, 2], u[0, 1], u[0, 2], u[1, 2])
+
+
+@pytest.mark.parametrize("cell", [(5.0, 6.0, 7.0, 80.0, 85.0, 95.0), (3.2, 3.2, 5.2, 90.0, 90.0, 120.0)])
+def test_principal_mean_square_displacements_are_cartesian(cell):
+    """A118 (re/03b PR review N4): the warning gives the Cartesian principal values; an isotropic U has
+    three equal ones in any cell, although its Uij matrix does not (hexagonal U12 = U11/2)."""
+    assert np.allclose(_principal_msd(cell, _isotropic_uij(cell, -0.01)), -0.01)
+
+
+def test_uaniso_not_positive_definite_isotropic_hexagonal_message():
+    """N4: a negative isotropic tensor on hexagonal axes reports -0.01 three times, not the Uij matrix's
+    -0.015, -0.01, -0.005."""
+    d = _p1_uaniso_phase(_isotropic_uij((3.2, 3.2, 5.2, 90.0, 90.0, 120.0), -0.01))
+    d["unit_cell"] = {k: [v, False] for k, v in zip(_CELL_NAMES, (3.2, 3.2, 5.2, 90.0, 90.0, 120.0))}
+    (warning,) = Phase[RP].model_validate(d).warnings()
+    assert "principal mean-square displacements -0.01, -0.01, -0.01 A^2" in warning["message"]
+
+
+def test_uaniso_semidefinite_always_warns():
+    """N4: a zero principal value is <= 0 whatever the floating-point noise (rank-1 tensor)."""
+    for v in (0.01, 0.03, 0.07, 0.11, 0.013):
+        (warning,) = Phase[RP].model_validate(_p1_uaniso_phase((v,) * 6)).warnings()
+        assert warning["code"] == "uaniso_not_positive_definite"
+
+
+
+# --- one rule for symmetry-determined values (A121; re/03b PR review S1, S3, Q1) ----------------
+
+_HEX_CELL = (3.2, 3.2, 5.2, 90.0, 90.0, 120.0)
+_SPECIAL_VALUE_CASES = [
+    # (case, space group, cell, stated xyz, model xyz or the error) -- the table in SCHEMA_HISTORY
+    ("fixed 1/2 written 0.4999999", "P m -3 m", (4.0, 4.0, 4.0, 90.0, 90.0, 90.0), (0.4999999, 0.0, 0.0),
+     "write x = 0.5"),
+    ("fixed 1/3 written 0.333333", "P 63/m m c", _HEX_CELL, (0.333333, 0.666667, 0.25), (1 / 3, 2 / 3, 0.25)),
+    ("fixed 1/3 written to 13 digits", "P 63/m m c", _HEX_CELL, (0.3333333333333, 0.6666666666667, 0.25),
+     (1 / 3, 2 / 3, 0.25)),
+    ("ideal C14 6h (x, 2x - 1, 1/4)", "P 63/m m c", _HEX_CELL, (0.833333, 0.666667, 0.25),
+     (0.833333, float(2 * Fraction(0.833333) - 1), 0.25)),
+    ("y = 2x written 0.2000001", "P 6/m m m", _HEX_CELL, (0.1, 0.2000001, 0.0), (0.1, 0.2, 0.0)),
+    ("y = x/2 of a 6-decimal x", "P 6/m m m", _HEX_CELL, (0.333333, 0.166667, 0.0),
+     (0.333333, float(Fraction(0.333333) / 2), 0.0)),
+    ("y = x + 1/3 written 0.4", "R -3 m:H", (4.0, 4.0, 20.0, 90.0, 90.0, 120.0), (0.066667, 0.4, 0.166667),
+     (0.066667, float(Fraction(0.066667) + Fraction(1, 3)), 1 / 6)),
+]
+
+
+@pytest.mark.parametrize("case, sg, cell, xyz, expected", _SPECIAL_VALUE_CASES, ids=[c[0] for c in _SPECIAL_VALUE_CASES])
+def test_symmetry_determined_values_follow_one_rule(case, sg, cell, xyz, expected):
+    """A121: a constant with a decimal form is exact; a third is read from 6 decimals; a value derived from
+    another stated value is read within 6 decimals; the model holds the derived value, and its dump
+    validates as itself."""
+    d = {"space_group": sg, "unit_cell": dict(zip(_CELL_NAMES, ([v, False] for v in cell))),
+         "atoms": {"A": {"element": "O", **{k: [v, False] for k, v in zip("xyz", xyz)},
+                         "occupancy": [1.0, False], "ADP": "Uiso", "Uiso": [0.01, False]}}}
+    if isinstance(expected, str):
+        with pytest.raises(ValidationError) as exc_info:
+            Phase[RP].model_validate(d)
+        assert exc_info.value.errors()[0]["msg"].endswith(expected)
+        return
+    phase = Phase[RP].model_validate(d)
+    assert tuple(getattr(phase.atoms["A"], k).value for k in "xyz") == expected
+    assert phase.warnings() == []
+    assert Phase[RP].model_validate(phase.model_dump()).model_dump() == phase.model_dump()
+
+
+def test_equal_ties_are_named_in_the_message():
+    """N3: an equal tie is a relation too (12j (1/2, y, y): z = y)."""
+    d = {"space_group": "P m -3 m", "unit_cell": dict(zip(_CELL_NAMES, ([v, False] for v in (4.0, 4.0, 4.0, 90, 90, 90)))),
+         "atoms": {"A": {"element": "O", "x": [0.4999999, False], "y": [0.2, False], "z": [0.2, False],
+                         "occupancy": [1.0, False], "ADP": "Uiso", "Uiso": [0.01, False]}}}
+    with pytest.raises(ValidationError) as exc_info:
+        Phase[RP].model_validate(d)
+    assert _errs(exc_info) == [(("atoms", "A"), "atom 'A' (multiplicity 12 in 'P m -3 m'): (0.4999999, 0.2, 0.2) is "
+                                                "1e-07 from a special position, not on it (x = 1/2, z = y); write x = 0.5")]
+
+
+def test_cell_holds_the_first_members_values():
+    """A123: tied cell values within CELL_TOL are the first member's in the model (b = a exactly), and fixed
+    angles are exact; the error states the stated values and gives the ones to write."""
+    d = _valid_pmm_lab6_phase_dict()
+    d["unit_cell"]["b"] = [4.15692 * (1 + 5e-10), False]
+    d["unit_cell"]["gamma"] = [90 + 5e-10, False]
+    cell = Phase[RP].model_validate(d).unit_cell
+    assert (cell.b.value, cell.gamma.value) == (4.15692, 90.0)
+    d["unit_cell"]["b"] = [4.15692 * (1 + 5e-9), False]
+    d["unit_cell"]["gamma"] = [90.1, False]
+    with pytest.raises(ValidationError) as exc_info:
+        Phase[RP].model_validate(d)
+    assert _errs(exc_info) == [(("unit_cell",), "unit cell is inconsistent with 'P m -3 m' (cubic): stated "
+                                                f"b = {4.15692 * (1 + 5e-9)!r}, gamma = 90.1, but by symmetry "
+                                                "gamma = 90, b = a; write b = 4.15692, gamma = 90.0")]
+
+
+def test_fixed_cell_angles_are_exact_in_every_setting():
+    """A123: every gemmi setting's fixed angles are 90, or 120 for gamma on hexagonal axes; a cell built
+    from them passes the metric check (A77)."""
+    import gemmi
+
+    from powderline.schema_core import _fixed_cell_angle
+    from powderline.symmetry import cell_tie_groups
+
+    for sg in gemmi.spacegroup_table():
+        ties = cell_tie_groups(sg.xhm())
+        cell = {"a": 5.1, "b": 6.2, "c": 7.3, "alpha": 81.0, "beta": 86.0, "gamma": 97.0}
+        for group in ties.groups:
+            for member in group.members[1:]:
+                cell[member] = cell[group.members[0]]
+        cell.update({name: float(_fixed_cell_angle(ties, name)) for name in ties.fixed})
+        check_cell(sg.xhm(), tuple(cell[k] for k in _CELL_NAMES))
+
+
+def test_tied_values_and_bounds_derived_together_stay_ordered():
+    """N1: a member's value and bounds are both derived from the first member's, so a value at its bound
+    stays within it, and the dump validates."""
+    cell = {k: [*v, None, None] for k, v in _R3M_CELL.items()}
+    atom = {"element": "O", "x": [0.2, False, 0.0, 0.2], "y": [0.5333333333333334, False, 0.333333, 0.533334],
+            "z": [0.166667, False, None, None], "occupancy": [1.0, False, None, None],
+            "ADP": "Uiso", "Uiso": [0.01, False, None, None]}
+    phase = Phase[BRP].model_validate({"space_group": "R -3 m:H", "unit_cell": cell, "atoms": {"O1": atom}})
+    y = phase.atoms["O1"].y
+    assert y.min <= y.value <= y.max
+    assert Phase[BRP].model_validate(phase.model_dump()).model_dump() == phase.model_dump()
+
+
+def test_uij_within_floating_point_precision_held_exactly():
+    """N2: no message without a value to write; the model holds the derived tensor."""
+    keys = ("U11", "U22", "U33", "U12", "U13", "U23")
+    values = (0.01, 0.01 + 9.5e-13, 0.02, 0.005 - 9.5e-13, 0.0, 0.0)
+    d = {"space_group": "P 6/m m m", "unit_cell": dict(zip(_CELL_NAMES, ([v, False] for v in _HEX_CELL))),
+         "atoms": {"A": {"element": "O", "x": [0.0, False], "y": [0.0, False], "z": [0.0, False],
+                         "occupancy": [1.0, False], "ADP": "Uaniso", "Uaniso": {k: [v, False] for k, v in zip(keys, values)}}}}
+    u = Phase[RP].model_validate(d).atoms["A"].Uaniso
+    assert (u.U22.value, u.U12.value) == (0.01, 0.005)
+
+
+# --- names (A112 amended: atom labels unique ignoring case; re/03b PR review N8) ----------------
+
+
+def test_atom_labels_unique_ignoring_case():
+    d = _valid_pmm_lab6_phase_dict()
+    d["atoms"]["la1"] = d["atoms"]["La1"]
+    with pytest.raises(ValidationError) as exc_info:
+        Phase[RP].model_validate(d)
+    assert _errs(exc_info) == [(("atoms", "la1"), "atom labels 'La1' and 'la1' differ only in case; rename one")]
+
+
+# --- engine subclass guard layers (A122; re/03b PR review S2, N5) -------------------------------
+
+
+def test_phase_parameter_type_must_be_a_core_parameter_type():
+    from typing import Generic
+
+    from powderline.schema_core import P
+
+    with pytest.raises(TypeError, match=r"the parameter type must be RefinableParameter or BoundedRefinableParameter, "
+                                        r"not <class 'float'>"):
+        Phase[float]
+
+    class EnginePhase(Phase[P], Generic[P]):
+        pass
+
+    with pytest.raises(TypeError, match="not <class 'int'>"):
+        EnginePhase[int]
+
+
+def test_phase_mixin_cannot_replace_a_core_validator():
+    """A mixin placed before Phase is collected first by pydantic; its same-named validator would win."""
+    from pydantic import BaseModel
+
+    class Mixin(BaseModel):
+        @field_validator("space_group", check_fields=False)
+        @classmethod
+        def _space_group(cls, v):
+            return v
+
+    class PlainMixin:
+        @model_validator(mode="after")
+        def _sites_check(self):
+            return self
+
+    for mixin, name in ((Mixin, "_space_group"), (PlainMixin, "_sites_check")):
+        with pytest.raises(TypeError, match=f"^{mixin.__name__} reuses the core phase name\\(s\\) {name};"):
+            type("EnginePhase", (mixin, Phase[RP]), {"__module__": __name__})
+
+
+def test_phase_mixin_cannot_redeclare_a_core_field():
+    from pydantic import BaseModel
+
+    class Mixin(BaseModel):
+        space_group: str = "P 1"
+
+    with pytest.raises(TypeError, match=r"^Mixin redeclares the core phase field\(s\) space_group;"):
+        class EnginePhase(Mixin, Phase[RP]):
+            pass
+
+
+@pytest.mark.parametrize("name, body", [
+    ("_engine_wrap", "@model_validator(mode='wrap')\n@classmethod\ndef _engine_wrap(cls, data, handler):\n    return handler(data)"),
+    ("_engine_before", "@model_validator(mode='before')\n@classmethod\ndef _engine_before(cls, data):\n    return data"),
+    ("_snap", "@field_validator('atoms', mode='before')\n@classmethod\ndef _snap(cls, v):\n    return v"),
+    ("_all", "@field_validator('*', mode='wrap')\n@classmethod\ndef _all(cls, v, handler):\n    return handler(v)"),
+    ("_sg", "@field_validator('space_group', mode='plain')\n@classmethod\ndef _sg(cls, v):\n    return v"),
+])
+def test_phase_validators_that_could_rewrite_the_recipe_rejected(name, body):
+    """A122: a 'before', 'wrap' or 'plain' validator could rewrite the recipe before core reads it (e.g.
+    round 0.4999999 to 0.5, A115) or skip core's validation."""
+    namespace = {"field_validator": field_validator, "model_validator": model_validator, "Phase": Phase, "RP": RP}
+    source = "class EnginePhase(Phase[RP]):\n    scale: RP\n" + "\n".join("    " + line for line in body.splitlines())
+    with pytest.raises(TypeError, match=f"^EnginePhase: validator\\(s\\) {name} must be 'after' validators"):
+        exec(source, namespace)
+
+
+def test_phase_engine_before_validator_on_its_own_field_allowed():
+    class EnginePhase(Phase[RP]):
+        scale: RP
+
+        @field_validator("scale", mode="before")
+        @classmethod
+        def _scale_shape(cls, v):
+            return v
+
+        @model_validator(mode="after")
+        def _engine_check(self):
+            return self
+
+    assert EnginePhase.model_validate({**_valid_pmm_lab6_phase_dict(), "scale": [1.0, True]}).scale.value == 1.0
+
+
+@pytest.mark.parametrize("name, body", [
+    ("__init__", "def __init__(self, **data):\n    super().__init__(**data)"),
+    ("model_post_init", "def model_post_init(self, context):\n    pass"),
+    ("model_validate", "@classmethod\ndef model_validate(cls, obj, **kw):\n    return cls.model_construct(**obj)"),
+    ("__get_pydantic_core_schema__", "@classmethod\ndef __get_pydantic_core_schema__(cls, source, handler):\n    return handler(source)"),
+    ("__pydantic_init_subclass__", "@classmethod\ndef __pydantic_init_subclass__(cls, **kw):\n    pass"),
+])
+def test_phase_entry_points_cannot_be_overridden(name, body):
+    """A122: an override could skip or replace core's validation without reusing a core name."""
+    namespace = {"Phase": Phase, "RP": RP}
+    source = "class EnginePhase(Phase[RP]):\n" + "\n".join("    " + line for line in body.splitlines())
+    with pytest.raises(TypeError, match=f"^EnginePhase defines {name}; a phase model may not override"):
+        exec(source, namespace)
+
+
+def test_phase_guard_sees_a_replaced_core_validator():
+    """A122 layer 2: whatever the route, every core validator must still be core's own function."""
+    import dataclasses
+
+    class EnginePhase(Phase[RP]):
+        pass
+
+    validators = EnginePhase.__pydantic_decorators__.field_validators
+    validators["_space_group"] = dataclasses.replace(validators["_space_group"], func=lambda cls, v: v)
+    with pytest.raises(TypeError, match=r"^EnginePhase replaces the core validator\(s\) _space_group"):
+        EnginePhase.__pydantic_init_subclass__()