Core: ввести точные family-множества

.cargo/mutants.toml

@@ -6,13 +6,17 @@
 #
 # Список является явным выбранным срезом, а не «полным workspace». Расширение
 # скоупа меняет discovered-population digest и потому не может пройти незаметно.
+# Exact family certificate/membership входит в тот же выбранный correctness-срез;
+# это не отдельный запуск и не обещание покрытия всего workspace.
 examine_globs = [
     "crates/labcolors-core/src/alpha.rs",
     "crates/labcolors-core/src/analog.rs",
     "crates/labcolors-core/src/appearance.rs",
     "crates/labcolors-core/src/composition.rs",
     "crates/labcolors-core/src/constraints/mod.rs",
     "crates/labcolors-core/src/constraints/exact.rs",
+    "crates/labcolors-core/src/constraints/family.rs",
+    "crates/labcolors-core/src/family.rs",
     "crates/labcolors-core/src/glow.rs",
     "crates/labcolors-core/src/material.rs",
     "crates/labcolors-core/src/numerical_plan.rs",

.github/workflows/ci.yml

@@ -219,6 +219,11 @@ jobs:
         run: python3 scripts/test_mutation.py
       - name: cargo test
         run: cargo test --workspace --locked
+      - name: exhaustive 24-bit family membership oracle
+        run: >-
+          cargo test -p labcolors-core
+          family_tests::axis_membership_matches_the_full_srgb8_cube_oracle
+          --locked -- --ignored --exact
       - name: prove core capability projection boundary
         shell: bash
         run: |

crates/labcolors-core/contracts/clean-set-srgb8-v1/receipt-v1.json

@@ -48,11 +48,11 @@
       "sha256": "8bf5d5a1c0f00ce245a1ecb18b923aa1631483345962d72b633e466c242a8a1d"
     },
     {
-      "bytes": 13746,
+      "bytes": 13830,
       "license": "MIT",
       "path": "crates/labcolors-core/src/lib.rs",
       "role": "module_registration_source",
-      "sha256": "84d7ce86895355a572254846d38c3766d9007bf21f0ed81e3334196cbc964165"
+      "sha256": "1fdb8645a1f05c61232e362b89ef583198c131c493c3fab20c5ec545d02c6539"
     },
     {
       "bytes": 39439,
@@ -90,32 +90,32 @@
       "sha256": "ac8c390a74c8aaea9e04d1006f3604d72f94a980ce26645d08593f025c4fc011"
     },
     {
-      "bytes": 186280,
+      "bytes": 195880,
       "license": "MIT",
       "path": "crates/labcolors-core/src/program.rs",
       "role": "program_facade_source",
-      "sha256": "706bb420b7359bc02bce92763fb3c5acd01ae4428e74d10781ce9f019c020948"
+      "sha256": "86e372337ad2f21779596c8e608c6c18465577d336a2fc0a5dfcff0aaead5ec7"
     },
     {
-      "bytes": 79583,
+      "bytes": 82393,
       "license": "MIT",
       "path": "crates/labcolors-core/src/program_identity.rs",
       "role": "program_identity_source",
-      "sha256": "0cef3e938c5511fdae96a022cd8c3771cd8e2cc00aab64f0cc7c7f3788985251"
+      "sha256": "c6ae7d7e24240aa4249df1bf74f0e95711b6b889bd3650acdf11e1dd82f34123"
     },
     {
-      "bytes": 215114,
+      "bytes": 220403,
       "license": "MIT",
       "path": "crates/labcolors-core/src/program_session.rs",
       "role": "program_source",
-      "sha256": "c5438be8ce85b40e77b9bde66c8a05277ed7d2244c34c34031d4e59599e64c9b"
+      "sha256": "db522c68cc992d71f806997123ead19fe5d7064d13b47580ea3fc33f95f02d00"
     },
     {
       "bytes": 21872,
       "license": "MIT",
       "path": "crates/labcolors-core/src/program_clean_set_tests.rs",
       "role": "program_tests",
-      "sha256": "3ab731c8ba05a673d35427867f18c906b458a93613bffdb41ce98802212cbd4c"
+      "sha256": "3fe1cc66f9154d37b5c9704b8d48c0710b9046cf792b756cd9f8d71bf9ba9e6e"
     },
     {
       "bytes": 11370,

crates/labcolors-core/contracts/clean-set-srgb8-v1/receipt-v1.sha256

@@ -1 +1 @@
-943c48063baac082a12b795f2bc9dda1ca7be875cd1403a6eae89339a18da0f9  receipt-v1.json
+682da61a4becf096e83fef3052e12ee247b0a12359f4583ddf8a2ed04178175d  receipt-v1.json

crates/labcolors-core/src/constraints/family.rs

@@ -0,0 +1,52 @@
+//! Метаданные code-owned evaluator-а принадлежности точному образу family.
+
+use crate::family::{
+    AdmittedFamilySetV1, FamilyMembershipMeasurementV1, FamilyMembershipPassV1,
+    FamilyMembershipViolationV1,
+};
+use crate::lcs_occurrence::ColorSignal;
+
+use super::HardDecision;
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub(crate) enum FamilyMembershipIdentityV1 {
+    ExactImageMembershipV1,
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub(crate) enum FamilyMembershipReleaseV1 {
+    V1,
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub(crate) enum FamilyMembershipCapabilityV1 {
+    Iec61966Srgb8D65V1,
+}
+
+#[derive(Debug, Clone, Copy, Default, PartialEq, Eq)]
+pub(crate) struct FamilyMembershipV1;
+
+impl FamilyMembershipV1 {
+    pub(crate) const fn identity(self) -> FamilyMembershipIdentityV1 {
+        FamilyMembershipIdentityV1::ExactImageMembershipV1
+    }
+
+    pub(crate) const fn release(self) -> FamilyMembershipReleaseV1 {
+        FamilyMembershipReleaseV1::V1
+    }
+
+    pub(crate) const fn capability(self) -> FamilyMembershipCapabilityV1 {
+        FamilyMembershipCapabilityV1::Iec61966Srgb8D65V1
+    }
+
+    pub(crate) fn assess(
+        self,
+        family: &AdmittedFamilySetV1,
+        signal: ColorSignal,
+    ) -> (
+        FamilyMembershipMeasurementV1,
+        HardDecision<FamilyMembershipPassV1, FamilyMembershipViolationV1>,
+    ) {
+        family.assess(signal)
+    }
+}

crates/labcolors-core/src/constraints/mod.rs

@@ -20,14 +20,21 @@ pub(crate) use exact::{
     ExactPassEvidenceV1, ExactSrgb8IdentityV1, ExactViolationEvidenceV1,
 };
 
+mod family;
+pub(crate) use family::{
+    FamilyMembershipCapabilityV1, FamilyMembershipIdentityV1, FamilyMembershipReleaseV1,
+    FamilyMembershipV1,
+};
+
 #[cfg(test)]
 pub(crate) use exact::ExactIdentityPassV1;
 
 mod relation;
 pub(crate) use relation::{
-    CoreIntrinsicUnaryInvocationV1, CoreIntrinsicUnaryMeasurementV1, CoreIntrinsicUnaryPassV1,
-    CoreIntrinsicUnaryViolationV1, CoreRelationInvocationV1, CoreRelationMeasurementV1,
-    CoreRelationPassV1, CoreRelationViolationV1, ExactSrgb8IntrinsicUnaryCapabilityV1,
+    CompiledCoreIntrinsicUnaryInvocationV1, CoreIntrinsicUnaryInvocationV1,
+    CoreIntrinsicUnaryMeasurementV1, CoreIntrinsicUnaryPassV1, CoreIntrinsicUnaryViolationV1,
+    CoreRelationInvocationV1, CoreRelationMeasurementV1, CoreRelationPassV1,
+    CoreRelationViolationV1, ExactSrgb8IntrinsicUnaryCapabilityV1,
     ExactSrgb8IntrinsicUnaryIdentityV1, ExactSrgb8IntrinsicUnaryReleaseV1,
     ExactSrgb8RelationCapabilityV1, ExactSrgb8RelationIdentityV1, ExactSrgb8RelationReleaseV1,
 };
@@ -511,6 +518,11 @@ pub(crate) enum ProgramConstraintContentV1 {
         capability: ExactSrgb8IntrinsicUnaryCapabilityV1,
         expected: Srgb8,
     },
+    FamilyMembership {
+        identity: FamilyMembershipIdentityV1,
+        release: FamilyMembershipReleaseV1,
+        capability: FamilyMembershipCapabilityV1,
+    },
     ExactSrgb8Relation {
         identity: ExactSrgb8RelationIdentityV1,
         release: ExactSrgb8RelationReleaseV1,

crates/labcolors-core/src/constraints/relation.rs

@@ -1,5 +1,10 @@
 use crate::Srgb8;
-use crate::constraints::{HardDecision, ProgramConstraintContentV1};
+use crate::constraints::{FamilyMembershipV1, HardDecision, ProgramConstraintContentV1};
+use crate::family::{
+    FamilyDeclarationV1, FamilyId, FamilyMembershipMeasurementV1, FamilyMembershipPassV1,
+    FamilyMembershipViolationV1,
+};
+use crate::lcs_occurrence::ColorSignal;
 
 fn exact_srgb8_equal(left: Srgb8, right: Srgb8) -> bool {
     left.bytes() == right.bytes()
@@ -164,28 +169,50 @@ impl ExactSrgb8IntrinsicUnaryV1 {
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub(crate) enum CoreIntrinsicUnaryInvocationV1 {
     ExactSrgb8 { expected: Srgb8 },
+    FamilyMembership { family: FamilyId },
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub(crate) enum CompiledCoreIntrinsicUnaryInvocationV1 {
+    ExactSrgb8 {
+        expected: Srgb8,
+    },
+    FamilyMembership {
+        family: FamilyId,
+        family_index: usize,
+    },
 }
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub(crate) enum CoreIntrinsicUnaryMeasurementV1 {
     ExactSrgb8(ExactSrgb8IntrinsicUnaryMeasurementV1),
+    FamilyMembership {
+        family: FamilyId,
+        measurement: FamilyMembershipMeasurementV1,
+    },
 }
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub(crate) enum CoreIntrinsicUnaryPassV1 {
     ExactSrgb8(ExactSrgb8IntrinsicUnaryPassV1),
+    FamilyMembership(FamilyMembershipPassV1),
 }
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub(crate) enum CoreIntrinsicUnaryViolationV1 {
     ExactSrgb8(ExactSrgb8IntrinsicUnaryViolationV1),
+    FamilyMembership(FamilyMembershipViolationV1),
 }
 
 impl CoreIntrinsicUnaryInvocationV1 {
     pub(crate) const fn exact_srgb8(expected: Srgb8) -> Self {
         Self::ExactSrgb8 { expected }
     }
 
+    pub(crate) const fn family_membership(family: FamilyId) -> Self {
+        Self::FamilyMembership { family }
+    }
+
     pub(crate) const fn content(self) -> ProgramConstraintContentV1 {
         match self {
             Self::ExactSrgb8 { expected } => {
@@ -197,16 +224,27 @@ impl CoreIntrinsicUnaryInvocationV1 {
                     expected,
                 }
             }
+            Self::FamilyMembership { .. } => {
+                let profile = FamilyMembershipV1;
+                ProgramConstraintContentV1::FamilyMembership {
+                    identity: profile.identity(),
+                    release: profile.release(),
+                    capability: profile.capability(),
+                }
+            }
         }
     }
+}
 
+impl CompiledCoreIntrinsicUnaryInvocationV1 {
     pub(crate) fn assess(
         self,
         actual: Srgb8,
-    ) -> (
+        families: &[FamilyDeclarationV1],
+    ) -> Option<(
         CoreIntrinsicUnaryMeasurementV1,
         HardDecision<CoreIntrinsicUnaryPassV1, CoreIntrinsicUnaryViolationV1>,
-    ) {
+    )> {
         match self {
             Self::ExactSrgb8 { expected } => {
                 let (measurement, decision) = ExactSrgb8IntrinsicUnaryV1.assess(expected, actual);
@@ -218,10 +256,40 @@ impl CoreIntrinsicUnaryInvocationV1 {
                         HardDecision::Violation(CoreIntrinsicUnaryViolationV1::ExactSrgb8(proof))
                     }
                 };
-                (
+                Some((
                     CoreIntrinsicUnaryMeasurementV1::ExactSrgb8(measurement),
                     decision,
-                )
+                ))
+            }
+            Self::FamilyMembership {
+                family,
+                family_index,
+            } => {
+                // Compile-time связывает индекс с этим exact FamilyId; `None`
+                // здесь означает порчу compiled graph, а не штатное отсутствие
+                // evidence, и вызывающий слой переводит его в InternalInvariant.
+                let declaration = families.get(family_index)?;
+                if declaration.id() != family {
+                    return None;
+                }
+                let set = declaration.set();
+                let (measurement, decision) =
+                    FamilyMembershipV1.assess(set, ColorSignal::from_srgb8(actual));
+                let decision = match decision {
+                    HardDecision::Pass(proof) => {
+                        HardDecision::Pass(CoreIntrinsicUnaryPassV1::FamilyMembership(proof))
+                    }
+                    HardDecision::Violation(proof) => HardDecision::Violation(
+                        CoreIntrinsicUnaryViolationV1::FamilyMembership(proof),
+                    ),
+                };
+                Some((
+                    CoreIntrinsicUnaryMeasurementV1::FamilyMembership {
+                        family,
+                        measurement,
+                    },
+                    decision,
+                ))
             }
         }
     }