fix(dpmodel): reject an intensive/extensive composition at construction

get_intensive aggregated with all(), so a composition mixing an intensive
with an extensive child quietly reported False -- the same
plausible-default failure mode as the capability gaps fixed alongside it.

Such a sum is not physically meaningful, so the composition must not exist
at all: LinearAtomicModel.__init__ now validates that every child agrees,
next to the existing mixed-type check, and raises naming the offenders.
The accessor is then a plain read of an invariant rather than a vote.

Regression asserts CONSTRUCTION raises, with an anti-vacuity check that
agreeing children still compose and report their value.

Author: Han Wang

deepmd/dpmodel/atomic_model/linear_atomic_model.py

@@ -84,6 +84,16 @@ def __init__(
                 f"LinearAtomicModel only supports AtomicModel of mixed type, the following models are not mixed type: {model_mixed_type}."
             )
 
+        # Fail fast: a sum mixing an intensive with an extensive term is not
+        # physically meaningful, so such a composition must not exist.
+        intensive_flags = {m.get_intensive() for m in models}
+        if len(intensive_flags) > 1:
+            raise ValueError(
+                "LinearAtomicModel cannot combine intensive and extensive "
+                "sub-models: "
+                + ", ".join(f"{type(m).__name__}={m.get_intensive()}" for m in models)
+            )
+
         self.models = models
         self.type_map = type_map
         self._rebuild_mapping_state()
@@ -613,10 +623,11 @@ def has_chg_spin_ebd(self) -> bool:
         return any(model.has_chg_spin_ebd() for model in self.models)
 
     def get_intensive(self) -> bool:
-        """Intensive iff EVERY child is: a sum cannot be intensive while one
-        child scales with system size.
+        """Whether the composed property is intensive.
+
+        All children agree by construction (validated in ``__init__``).
         """
-        return all(model.get_intensive() for model in self.models)
+        return self.models[0].get_intensive() if self.models else False
 
     def get_compute_stats_distinguish_types(self) -> bool:
         """Needed if ANY child needs them; the stricter rule is safe for

source/tests/common/dpmodel/test_zbl_bridging.py

@@ -499,6 +499,28 @@ class TestCompositionForwardsStatCapabilities:
     charge-spin and pair-exclusion accessors.
     """
 
+    def test_intensive_mixture_is_rejected_at_construction(self) -> None:
+        """An intensive/extensive mixture must not be CONSTRUCTIBLE.
+
+        Rejected in ``__init__`` rather than at query time: such a
+        composition is not physically meaningful, so it should never exist
+        rather than exist and answer a plausible-looking default.
+        """
+        zbl_a = InterPotentialAtomicModel(type_map=["Ni", "O"], rcut=4.0, sel=[8])
+        zbl_b = InterPotentialAtomicModel(type_map=["Ni", "O"], rcut=4.0, sel=[8])
+        # anti-vacuity: matching children compose fine and report their value
+        assert zbl_a.get_intensive() is False
+        assert (
+            LinearEnergyAtomicModel(
+                [zbl_a, zbl_b], type_map=["Ni", "O"], weights="sum"
+            ).get_intensive()
+            is False
+        )
+
+        zbl_b.get_intensive = lambda: True  # type: ignore[method-assign]
+        with pytest.raises(ValueError, match="intensive and extensive"):
+            LinearEnergyAtomicModel([zbl_a, zbl_b], type_map=["Ni", "O"], weights="sum")
+
     def test_forwarded_from_children(self) -> None:
         bridged = get_model(copy.deepcopy(ZBL_CONFIG))
         children = bridged.atomic_model.models