@@ -19,6 +19,19 @@ All notable changes to this project will be documented in this file.
   has uniform relative defect `eta=0`, and preserves the class under REMESH.
   Signed-zero bits, schedules, repeated event execution and future runtime
   behavior remain outside this certificate.
+- Added the first useful uniform represented class with `0<alpha<1`. On
+  ordered P2 support, any fixed positive diagonal metric, fixed delays,
+  `alpha=0.5`, a symmetric hard interval `[-B,B]` with
+  `B>=4*2^-1074`, and sufficient antisymmetric history rows `(a,-a)`, the
+  production REMESH map preserves the class and has sharp uniform relative
+  defect `eta*=135/124`. The proof combines an analytic IEEE error bound for
+  `sqrt(D)>=11*2^-1074` with exact enumeration of 6,615 integer-core candidates,
+  3,890 of them admissible; `(-3,-2,-3)*2^-1074` attains equality. Robust
+  composition is strict for `q<124/259`: `q=4/9` gives `q_eff=259/279` and
+  margin `20/279`, while equality at `q=124/259` has zero margin and `q=9/16`
+  is rejected. REMESH-only forward invariance does not extend to arbitrary
+  metric-centered rows, unrestricted fixed lattices, graph execution or future
+  complete-runtime behavior.
 - Added the restricted global binary64 P2 half-Reception composition. With two
   mutual singleton neighbors, an immutable all-target EPI snapshot, the exact
   configured mix `0.5` and one common hard clamp, both proposals are
@@ -51,12 +64,14 @@ All notable changes to this project will be documented in this file.
   occur inside one outer graph transaction, so a zero pair or any other failure
   restores graph-owned state. Success certifies only that invocation; future,
   unobserved-repetition and auxiliary-state claims remain false.
-- Added examples 173–177, including
+- Added examples 173–178, including
   `176_runtime_p2_reception_remesh_sequence.py`, exact public stubs, facade
   exports and adversarial tests covering normal/subnormal extremes, signed
   zero, inactive and active clipping, hostile inputs, private reseals and the
   exact energy-gain-four witness for the canonical default EN factor. Example
-  177 demonstrates two independently revalidated policy invocations.
+  177 demonstrates two independently revalidated policy invocations. Example
+  178 records the sharp half-alpha class, exact proof partition, robust gain
+  boundaries and the metric-centering and fixed-lattice falsifiers.
 
 ### Added — 2026-09-11 Relative-defect REMESH/schedule stability
 
 
@@ -693,6 +693,29 @@ execution and future runtime behavior remain outside the certificate. Example
 [`173_binary64_remesh_relative_defect.py`](examples/02_physics_regimes/173_binary64_remesh_relative_defect.py)
 shows both the obstruction and this boundary class.
 
+[`certify_half_alpha_antisymmetric_hard_clip_remesh_class(...)`](src/tnfr/physics/binary64_remesh_relative_defect.py)
+closes the first useful represented subclass with `0<alpha<1`. It fixes an
+ordered two-node support, any positive diagonal metric, positive delays,
+`alpha=0.5`, a symmetric hard interval `[-B,B]` with
+`B>=4*2**-1074`, and sufficient histories whose rows are `(a,-a)`. Binary64
+round-to-nearest-even and the symmetric clamp preserve numeric antisymmetry,
+so this class is forward invariant under the REMESH map alone. Writing
+`s=2**-1074`, `u=2**-53`, `D=c**2+l**2+2*g**2` and `x=sqrt(D)`, the exact IEEE
+error proof gives `|r-y|<=A*x+C*s`, where
+`A=3*u/2+u**2/2` and `C=9/4+9*u/4+u**2/2`. For `x>=11*s`, its analytic tail is
+strictly below `135/124`. For `x<11*s`, exact integer enumeration checks 6,615
+candidates, of which 3,890 satisfy `0<D<121*s**2`, and attains
+`eta*=135/124` at `(c,l,g)=(-3,-2,-3)*s`. The robust composition is strict
+exactly for `q<124/259`: `q=4/9` gives `q_eff=259/279` and margin `20/279`,
+whereas `q=124/259` gives only nonincrease with zero margin and `q=9/16` is
+rejected. General positive-metric centering and fixed lattices are outside the
+class: represented rounding can move the former's center, and `(h,0,0)` maps
+to `h/4`. Schedule verification, graph/event execution, repeated complete
+runtime behavior and future stability remain unproved. Example
+[`178_half_alpha_antisymmetric_remesh_class.py`](examples/02_physics_regimes/178_half_alpha_antisymmetric_remesh_class.py)
+records the sharp witness, both composition boundaries and both excluded
+generalizations.
+
 [`certify_p2_half_reception_remesh_stability(...)`](src/tnfr/physics/binary64_p2_reception_stability.py)
 closes a restricted global numeric EPI-kernel composition. On two mutual singleton
 neighbors, an immutable all-target EPI snapshot, the exact configured
 
@@ -786,6 +786,35 @@ preserves the class. Equality does not promise preservation of the signed-zero
 bit. Schedule, repeated event execution, future-runtime, solver and full-TNFR
 properties are explicitly false.
 
+[`certify_half_alpha_antisymmetric_hard_clip_remesh_class`](../src/tnfr/physics/binary64_remesh_relative_defect.py)
+accepts exactly two ordered nodes, an optional positive diagonal metric,
+positive local/global delays and a positive represented radius
+`epi_bound>=4*2**-1074`. It fixes `alpha=0.5` and the symmetric hard interval
+`[-epi_bound,epi_bound]`. A represented history belongs only when its length is
+between `max(tau_local,tau_global)+1` and `history_maxlen` and every row is a
+finite in-interval binary64 pair `(a,-a)`. The production nested recurrence and
+symmetric clamp preserve numeric antisymmetry and the interval.
+
+The certificate stores the sharp bound `eta*=135/124`. Its executable proof
+splits at `x=sqrt(D)=11*s`, where `s=2**-1074` and
+`D=c**2+l**2+2*g**2`. For the large-norm tail, it stores the exact constants
+`A=3*u/2+u**2/2` and `C=9/4+9*u/4+u**2/2`, with `u=2**-53`, in
+`|r-y|<=A*x+C*s`; the resulting tail ratio is strictly below `eta*`. For
+`x<11*s`, it exactly enumerates 6,615 bounded integer triples, retains the
+3,890 with `0<D/s**2<121`, and finds the maximum at `(-3,-2,-3)`. The stored
+subnormal witness has ideal amplitude `-11*s/4`, runtime amplitude `-4*s`, and
+relative defect `135/124`.
+
+`certify_schedule_relative_defect_stability(q)` composes that `eta*` through
+the existing robust theorem. Its strict threshold is `q<124/259`; `q=4/9`
+produces `q_eff=259/279` and normalized block margin `20/279`, equality at
+`q=124/259` produces nonincrease with zero margin, and `q=9/16` is rejected.
+This method certifies the conditional exact schedule theorem, not a verified
+runtime schedule family. The class is REMESH-forward-invariant only. It does
+not include arbitrary positive-metric-centered histories or unrestricted fixed
+lattices, and it leaves graph/event binding, repeated complete-runtime
+execution, solver and full-TNFR properties false.
+
 [`certify_p2_half_reception_remesh_stability`](../src/tnfr/physics/binary64_p2_reception_stability.py)
 requires an intact two-node `alpha=1` class certificate. It fixes mutual
 singleton neighbor indices, the exact binary64 configured factor `0.5`, a
@@ -1020,6 +1049,14 @@ re-exported from `tnfr.physics`.
   verifies that the planner and observer share the production scalar kernel;
   [`test_binary64_remesh_relative_defect_example.py`](../tests/physics/test_binary64_remesh_relative_defect_example.py)
   checks the public facade and example 173.
+- [`test_half_alpha_antisymmetric_remesh_class.py`](../tests/physics/test_half_alpha_antisymmetric_remesh_class.py)
+  verifies the sharp `eta=135/124` class, exact analytic-tail constants,
+  exhaustive 6,615/3,890 finite core, subnormal maximizer, strict/equality/
+  rejection gain boundaries, history membership, forward invariance, excluded
+  centered and lattice generalizations, public types and fail-closed seals;
+  [`test_half_alpha_antisymmetric_remesh_class_example.py`](../tests/physics/test_half_alpha_antisymmetric_remesh_class_example.py)
+  checks the public facade and example
+  [`178_half_alpha_antisymmetric_remesh_class.py`](../examples/02_physics_regimes/178_half_alpha_antisymmetric_remesh_class.py).
 - [`test_binary64_p2_reception_stability.py`](../tests/physics/test_binary64_p2_reception_stability.py)
   verifies global numeric consensus and `q=0` for the exact-half P2 kernel,
   its `eta=q_eff=0` composition and finite extinction horizon, extremes,
 
@@ -0,0 +1,225 @@
+"""Certify a useful binary64 REMESH class at ``alpha=1/2``.
+
+On a two-node antisymmetric history ``(a, -a)``, binary64 division by two,
+addition, and a symmetric hard clamp preserve oddness.  The class is therefore
+REMESH-forward-invariant and has the sharp uniform relative-defect bound
+``eta=135/124`` once the represented radius contains ``4*2**-1074``.
+
+Composing this bound with a schedule disagreement gain ``q`` gives
+``q_eff=q*(1+eta)``.  The example uses ``q=4/9``, for which
+``q_eff=259/279<1`` and the normalized block margin is ``20/279``.  It also
+shows the zero-margin boundary and two excluded generalizations: arbitrary
+metric-centered rows and an unrestricted fixed lattice.
+"""
+
+from __future__ import annotations
+
+from fractions import Fraction
+import json
+import math
+from typing import Any
+
+from tnfr.physics import (
+    certify_half_alpha_antisymmetric_hard_clip_remesh_class,
+    observe_binary64_remesh_pair_relative_defect,
+)
+
+
+def _weighted_center(pair: tuple[float, float]) -> Fraction:
+    left, right = (Fraction.from_float(value) for value in pair)
+    return (left + 3 * right) / 4
+
+
+def _fraction_text(value: Fraction) -> str:
+    return f"{value.numerator}/{value.denominator}"
+
+
+def run_protocol() -> dict[str, Any]:
+    """Build the class, its schedule compositions, and scope falsifiers."""
+
+    certificate = certify_half_alpha_antisymmetric_hard_clip_remesh_class(
+        ("left", "right"),
+        (1.0, 3.0),
+        tau_local=2,
+        tau_global=3,
+        epi_bound=1.0,
+    )
+    strict_policy = certificate.certify_schedule_relative_defect_stability(
+        Fraction(4, 9)
+    )
+    boundary_policy = certificate.certify_schedule_relative_defect_stability(
+        Fraction(124, 259)
+    )
+
+    smallest = math.ulp(0.0)
+    sharpness_witness = observe_binary64_remesh_pair_relative_defect(
+        (-3 * smallest, 3 * smallest),
+        (-2 * smallest, 2 * smallest),
+        (-3 * smallest, 3 * smallest),
+        alpha=0.5,
+        epi_min=-4 * smallest,
+        epi_max=4 * smallest,
+        clip_mode="hard",
+    )
+
+    amplitudes = (
+        float.fromhex("0x1.37b40d1c51f86p-29"),
+        float.fromhex("0x1.2be8875fa6dd8p-29"),
+        float.fromhex("-0x1.0994982458cc8p-28"),
+    )
+    centered_inputs = tuple((3 * value, -value) for value in amplitudes)
+    centered_falsifier = observe_binary64_remesh_pair_relative_defect(
+        *centered_inputs,
+        alpha=0.5,
+        epi_min=-1.0,
+        epi_max=1.0,
+        clip_mode="hard",
+    )
+    lattice_falsifier = observe_binary64_remesh_pair_relative_defect(
+        (1.0, -1.0),
+        (0.0, -0.0),
+        (0.0, -0.0),
+        alpha=0.5,
+        epi_min=-1.0,
+        epi_max=1.0,
+        clip_mode="hard",
+    )
+    return {
+        "certificate": certificate,
+        "strict_policy": strict_policy,
+        "boundary_policy": boundary_policy,
+        "sharpness_witness": sharpness_witness,
+        "centered_inputs": centered_inputs,
+        "centered_falsifier": centered_falsifier,
+        "lattice_falsifier": lattice_falsifier,
+    }
+
+
+def build_report(protocol: dict[str, Any]) -> dict[str, Any]:
+    """Return the exact class result and its explicit boundaries."""
+
+    certificate = protocol["certificate"]
+    strict = protocol["strict_policy"]
+    boundary = protocol["boundary_policy"]
+    sharp = protocol["sharpness_witness"]
+    centered_inputs = protocol["centered_inputs"]
+    centered = protocol["centered_falsifier"]
+    lattice = protocol["lattice_falsifier"]
+    return {
+        "claim": (
+            "the alpha=1/2 antisymmetric P2 hard-clip REMESH class has a "
+            "sharp uniform binary64 relative-defect bound"
+        ),
+        "class": {
+            "certificate_valid": (
+                certificate
+                .half_alpha_antisymmetric_hard_clip_class_certificate_certified
+            ),
+            "alpha": _fraction_text(certificate.alpha),
+            "interval": [
+                _fraction_text(certificate.epi_min),
+                _fraction_text(certificate.epi_max),
+            ],
+            "metric": [
+                _fraction_text(value)
+                for value in certificate.exact_normalized_metric
+            ],
+            "uniform_eta": _fraction_text(
+                certificate.exact_uniform_relative_defect_upper_bound
+            ),
+            "strict_q_threshold": _fraction_text(
+                certificate.exact_strict_schedule_gain_threshold
+            ),
+            "global_bound_proof": {
+                "large_norm_tail_bound": _fraction_text(
+                    certificate.exact_tail_relative_defect_upper_bound
+                ),
+                "large_norm_tail_is_strict": (
+                    certificate.exact_tail_relative_defect_upper_bound
+                    < certificate.exact_uniform_relative_defect_upper_bound
+                ),
+                "finite_core_candidates": (
+                    certificate.finite_core_candidate_count
+                ),
+                "finite_core_admissible": (
+                    certificate.finite_core_admissible_count
+                ),
+                "finite_core_maximizer": list(
+                    certificate.finite_core_maximizer_amplitudes
+                ),
+            },
+            "antisymmetry_preserved": (
+                certificate.binary64_antisymmetry_preserved_certified
+            ),
+            "remesh_forward_invariant": (
+                certificate.remesh_class_forward_invariant_certified
+            ),
+            "repeated_binary64_runtime": (
+                certificate.repeated_binary64_stability_certified
+            ),
+            "future_execution": (
+                certificate.future_binary64_execution_certified
+            ),
+            "full_tnfr_stability": certificate.full_tnfr_stability_certified,
+        },
+        "strict_schedule_composition": {
+            "q": _fraction_text(strict.schedule_energy_gain_upper_bound),
+            "q_effective": _fraction_text(
+                strict.exact_effective_head_energy_gain_upper_bound
+            ),
+            "normalized_block_margin": _fraction_text(
+                strict.exact_uniform_normalized_block_margin_lower_bound
+            ),
+            "geometric_spatial_disagreement_convergence": (
+                strict.geometric_spatial_disagreement_convergence_certified
+            ),
+        },
+        "threshold_boundary": {
+            "q": _fraction_text(boundary.schedule_energy_gain_upper_bound),
+            "q_effective": _fraction_text(
+                boundary.exact_effective_head_energy_gain_upper_bound
+            ),
+            "normalized_block_margin": _fraction_text(
+                boundary.exact_uniform_normalized_block_margin_lower_bound
+            ),
+            "geometric_spatial_disagreement_convergence": (
+                boundary.geometric_spatial_disagreement_convergence_certified
+            ),
+        },
+        "sharp_subnormal_witness": {
+            "current_in_smallest_subnormal_units": [-3, 3],
+            "local_in_smallest_subnormal_units": [-2, 2],
+            "global_in_smallest_subnormal_units": [-3, 3],
+            "ideal_left_in_smallest_subnormal_units": "-11/4",
+            "runtime_hex": [value.hex() for value in sharp.runtime_bounded_pair],
+            "observed_eta": _fraction_text(
+                sharp.exact_minimum_nonnegative_relative_defect_bound
+            ),
+            "attains_uniform_bound": (
+                sharp.exact_minimum_nonnegative_relative_defect_bound
+                == certificate.exact_uniform_relative_defect_upper_bound
+            ),
+        },
+        "excluded_generalizations": {
+            "general_metric_centered_input_centers": [
+                _fraction_text(_weighted_center(pair))
+                for pair in centered_inputs
+            ],
+            "general_metric_centered_output_center": _fraction_text(
+                _weighted_center(centered.runtime_bounded_pair)
+            ),
+            "general_metric_centering_forward_invariant": False,
+            "unit_lattice_runtime_output": [
+                value.hex() for value in lattice.runtime_bounded_pair
+            ],
+            "unit_lattice_forward_invariant": False,
+        },
+    }
+
+
+def main() -> None:
+    print(json.dumps(build_report(run_protocol()), indent=2, allow_nan=False))
+
+
+if __name__ == "__main__":
+    main()
@@ -151,3 +151,15 @@ and finite post-certification share one outer graph transaction. The two returne
 certificates have independent finite provenance;
 neither certifies a later invocation, auxiliary-state stability, solver behavior
 or full TNFR stability.
+
+`178_half_alpha_antisymmetric_remesh_class.py` certifies the first useful
+represented REMESH subclass with `0<alpha<1`. On ordered P2 support, fixed
+positive metric and delays, `alpha=1/2`, a symmetric hard interval containing
+`4*2^-1074`, and sufficient antisymmetric rows `(a,-a)`, the production map is
+forward invariant and has sharp uniform `eta=135/124`. The report exposes the
+analytic `sqrt(D)>=11*2^-1074` tail and the exact 6,615-candidate/3,890-admissible
+finite core, whose maximizer is `(-3,-2,-3)`. It then composes `q=4/9` into
+`q_eff=259/279` with margin `20/279`, records the zero-margin boundary
+`q=124/259`, and shows why general metric-centered rows and a fixed unit lattice
+are outside the class. It does not certify a schedule implementation, graph or
+event execution, repeated complete-runtime behavior or future stability.
@@ -84,6 +84,7 @@
 binary64_remesh_relative_defect : Exact runtime-rounding boundary
     - Replays one production pair and exposes its signed relative defect
     - Certifies the alpha=1 bounded hard-clip REMESH-only class with eta=0
+    - Certifies the sharp alpha=1/2 antisymmetric P2 class with eta=135/124
     - Excludes schedule families, repeated execution and future behavior
 binary64_p2_reception_stability : Global restricted P2 kernel composition
     - Half-Reception sends every finite represented pair in its interval to consensus
@@ -545,7 +546,9 @@
 from .binary64_remesh_relative_defect import (
     Binary64RemeshPairRelativeDefectObservation,
     UniformAlphaOneHardClipRemeshClassCertificate,
+    UniformHalfAlphaAntisymmetricHardClipRemeshClassCertificate,
     certify_alpha_one_hard_clip_remesh_class,
+    certify_half_alpha_antisymmetric_hard_clip_remesh_class,
     observe_binary64_remesh_pair_relative_defect,
 )
 from .binary64_p2_reception_stability import (
@@ -905,7 +908,9 @@
     # --- Exact binary64 REMESH relative-defect boundary ---
     "Binary64RemeshPairRelativeDefectObservation",
     "UniformAlphaOneHardClipRemeshClassCertificate",
+    "UniformHalfAlphaAntisymmetricHardClipRemeshClassCertificate",
     "certify_alpha_one_hard_clip_remesh_class",
+    "certify_half_alpha_antisymmetric_hard_clip_remesh_class",
     "observe_binary64_remesh_pair_relative_defect",
     # --- Global binary64 P2 half-Reception/REMESH kernel family ---
     "P2HalfReceptionRemeshStabilityCertificate",