glossarist 2.12.1 → 2.13.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4fafa61aa5261ca29216b423006cd0764470a9f8bf59733449ba3b501a63413b
-  data.tar.gz: b7c5f6148a76feca5dcbe8321e1a49bed99772a415168ddb977786d214c50110
+  metadata.gz: 85ff1a35136e9b7ff920830b2bf9a2e4b477bffed405c2386e33739ed6560a45
+  data.tar.gz: f7ef8fb96a58eb21a71534fcc8afc1cf7f26053379cfb00e5ec98098620ca6a6
 SHA512:
-  metadata.gz: 163a2b94ff599127f8997de745f05ebec13ab19095790bf91ca832e7ea2c79525c65ca93a4e1cbd45ba4fcd9c4f1d4db9cb564bf370497d1e22fd5aa3e28ec73
-  data.tar.gz: 43be5caab946b3202614ec38db165f6ce72b56137ca1daa87fa0e9c12a853b3c878541c8b8a9b23589719d4239a566ddb621ddee2552e7c284ab435232c03cd1
+  metadata.gz: beeecf5f816d5ec10741375d357a1b3602e7d415ebedfc71eff52d414f1d623ed119c7995355231c147020f54b814dc8306d37acdc6eecacdf8ca72ec6ddd65f
+  data.tar.gz: 0a7de5bd20f0f7c58c1c08066983b5c490999570249b686f84f60bd87df9b5e436913db66e43b5d1003805bfa33a6613d67bbd8c49373d21a03815dde83a8e42

data/CLAUDE.md

@@ -47,23 +47,35 @@ This consolidation closes the legacy trap where writing to
 `data.related` bypassed `ManagedConcept.detect_schema_version` (which
 keys off `concept.related`).
 
-### PartitiveHyperedge (V3 only)
+### PartitiveRelation (V3 only)
 
-`PartitiveHyperedge` (`v3/partitive_hyperedge.rb`) — a one-to-many partitive decomposition. One comprehensive concept is related to one or more parts as a SINGLE relationship. Captures invariants that binary `RelatedConcept` edges cannot:
+`PartitiveRelation` (`v3/partitive_relation.rb`) — an ISO 704 / ISO 1087-1 / ISO 12620 partitive relation. One comprehensive concept (superordinate concept partitive) is connected to two or more partitive concepts (subordinate concepts partitive) which fitted together constitute the comprehensive.
 
-- which comprehensive owns which parts (set membership)
-- diagram notation flags (`PluralityMarker`: `double`, `dashed`)
-- enumeration completeness (`PartitiveEnumeration`: `closed`, `open`)
+Each PartitiveRelation carries:
 
-Wired into `V3::ManagedConcept#partitive_hyperedges`. NOT on `ManagedConceptData` (relationships live at the concept level for MECE consistency with `related`).
+- `comprehensive` — ConceptRef to the superordinate concept partitive (the whole)
+- `partitives` — `PartitiveMember [2..*]` (ISO 704 "two or more"); each member wraps a ConceptRef plus optional `MemberCertainty` (`confirmed` default, `possible`)
+- `completeness` — `complete` (default; the encoded partitives constitute the whole) or `partial` (others exist beyond those encoded). ISO 704 rake backline notation.
+- `plurality` — optional `TypeSharedPlurality` block (ISO 704 close-set double line promoted to data: `is_shared`, `is_uncertain`, `shared_type`). Replaces the prior opaque `markers` field.
+- `criterion` — optional localized string hash (`{ "eng" => "physical structure" }`). ISO 12620 coordinate-concept coherence: partitives within one relation share the comprehensive AND the criterion.
 
-Enum values are SSOT-loaded from `config.yml` via `GlossaryDefinition::PARTITIVE_ENUMERATION_VALUES` and `PLURALITY_MARKER_VALUES`. The `values:` option on each attribute documents the enum; the model's `initialize` override enforces them at construction (lutaml-model 0.8.17 does not enforce `values:` on assignment). Construction also rejects empty comprehensive, empty parts, self-loops, and duplicate marker values.
+Wired into `V3::ManagedConcept#partitive_relations`. NOT on `ManagedConceptData` (relationships live at the concept level for MECE consistency with `related`).
 
-Semantic checks (defaulted-enumeration warning, defensive walk) live in `Validation::Rules::PartitiveHyperedgeRule` (auto-registered by `Validation::Rules`).
+Enum values are SSOT-loaded from `config.yml` via `GlossaryDefinition::COMPLETENESS_VALUES` and `MEMBER_CERTAINTY_VALUES`. The `values:` option on each attribute documents the enum; the model's `validate!` method enforces structural invariants after construction (empty comprehensive, <2 partitives, self-loops, incoherent plurality, invalid enum values).
 
-RDF emission: `Rdf::GlossHyperedge` view class (per-hyperedge `gloss:PartitiveHyperedge` subject with `gloss:comprehensive`, `gloss:part+`, `gloss:enumeration`, `gloss:hasPluralityMarker*`, `gloss:hyperedgeContent?`), wired into `Transforms::ConceptToGlossTransform` and emitted as `gloss:hasHyperedge` link from `GlossConcept`.
+Semantic checks (≥2 partitives cardinality, duplicate comprehensive+criterion detection, criterion-absent warning, ExternalConcept shape) live in `Validation::Rules::PartitiveRelationRule` (auto-registered by `Validation::Rules`, code GLS-221).
 
-Binary `broader_partitive`/`narrower_partitive` `RelatedConcept` edges and `PartitiveHyperedge` coexist — no automatic consolidation. See `concept-model/TODO.hyperedge/00-design-overview.md`.
+RDF emission: `Rdf::GlossPartitiveRelation` view class with companion `GlossPartitiveMember` and `GlossTypeSharedPlurality`. Wired into `Transforms::ConceptToGlossTransform` and emitted as `gloss:hasPartitiveRelation` link from `GlossConcept`.
+
+Binary `broader_partitive`/`narrower_partitive`/`has_part`/`is_part_of` `RelatedConcept` edges and `PartitiveRelation` coexist — no automatic consolidation. Use a binary edge for pairwise relationships; use a PartitiveRelation when membership is jointly significant (≥2 partitives + completeness/plurality/criterion metadata).
+
+#### ExternalConcept
+
+`status: external` is a value of `ConceptStatus` (not a separate class). A concept with `status: external` is referenced from this dataset but defined elsewhere — ISO 704 "parenthetic term" semantic role. Required fields (definition, sources) are relaxed; at least one designation is still required. Resolves to another dataset's concept via `provided_by` when a defining dataset is loaded.
+
+#### Relationship type extensions
+
+Two new values in `RelatedConceptType`: `provides` (real concept → external concept) and `provided_by` (external concept → real concept). Inverse pair, established at the collection level.
 
 ### Reference Resolution
 

data/config.yml

@@ -101,6 +101,12 @@ related_concept:
     - version_of
     - current_version
     - current_version_of
+    # ExternalConcept resolution (Glossarist extension)
+    # Real concept `provides` substance for an external concept;
+    # external concept `provided_by` real concept. Inverse pair.
+    # Established at the collection level when both datasets are loaded.
+    - provides
+    - provided_by
 
 iso12620:
   term_type:
@@ -178,6 +184,10 @@ concept:
     - valid
     - superseded
     - retired
+    # Glossarist extension: concept referenced from this dataset but
+    # defined elsewhere. Resolves via `provided_by` when a defining
+    # dataset is loaded. ISO 704 "parenthetic term" semantic role.
+    - external
 
 concept_date:
   type:
@@ -187,17 +197,23 @@ concept_date:
     - review
     - review_decision
 
-partitive_enumeration:
-  # Whether a PartitiveHyperedge's parts array constitutes the complete
-  # decomposition of the comprehensive (closed) or only a partial one
-  # (open). Default: closed.
+# PartitiveRelation redesign (TODO.partitive-relation-v2)
+# Replaces partitive_enumeration + plurality_marker.
+
+completeness:
+  # Whether the encoded partitives fitted together constitute the
+  # whole comprehensive concept (complete) or only some of it
+  # (partial — other partitives exist but are not encoded).
+  # ISO 704: rake backline ending with a tooth = complete;
+  # backline continuing without a tooth = partial.
+  # Default: complete.
   value:
-    - closed
-    - open
+    - complete
+    - partial
 
-plurality_marker:
-  # Diagram notation flags from VIM concept-relationship diagrams.
-  # Orthogonal to enumeration — both may be set on the same hyperedge.
+member_certainty:
+  # Per-partitive certainty. Glossarist extension beyond ISO 704
+  # notation. Defaults to confirmed when omitted.
   value:
-    - double   # close-set double line at receiver; several parts involved
-    - dashed   # broken/dashed line; plurality is uncertain
+    - confirmed
+    - possible

data/lib/glossarist/glossary_definition.rb

@@ -34,10 +34,10 @@ module Glossarist
 
     ISO12620_TERM_TYPES = config.dig("iso12620", "term_type").freeze
 
-    PARTITIVE_ENUMERATION_VALUES =
-      config.dig("partitive_enumeration", "value").freeze
+    # PartitiveRelation redesign (TODO.partitive-relation-v2).
+    # Replaces PARTITIVE_ENUMERATION_VALUES + PLURALITY_MARKER_VALUES.
+    COMPLETENESS_VALUES = config.dig("completeness", "value").freeze
 
-    PLURALITY_MARKER_VALUES =
-      config.dig("plurality_marker", "value").freeze
+    MEMBER_CERTAINTY_VALUES = config.dig("member_certainty", "value").freeze
   end
 end

data/lib/glossarist/managed_concept.rb

@@ -175,7 +175,7 @@ module Glossarist
       return "3" if concept.sources&.any?
       return "3" if concept.data&.domains&.any?
       return "3" if concept.is_a?(V3::ManagedConcept) &&
-                     concept.partitive_hyperedges&.any?
+                     concept.partitive_relations&.any?
       return "3" if localization_has_references?(concept)
 
       "2"

data/lib/glossarist/rdf/gloss_concept.rb

@@ -11,7 +11,7 @@ module Glossarist
       attribute :sources, GlossConceptSource, collection: true
       attribute :domains, GlossConceptReference, collection: true
       attribute :dates, GlossConceptDate, collection: true
-      attribute :hyperedges, GlossHyperedge, collection: true
+      attribute :partitive_relations, GlossPartitiveRelation, collection: true
 
       RelationshipPredicates::CONCEPT_REL_PREDICATES.each_key do |type|
         attribute :"#{type}_targets", :string, collection: true
@@ -42,8 +42,8 @@ module Glossarist
                 link: "gloss:hasDomain"
         members :dates,
                 link: "gloss:hasDate"
-        members :hyperedges,
-                link: "gloss:hasPartitiveHyperedge"
+        members :partitive_relations,
+                link: "gloss:hasPartitiveRelation"
 
         RelationshipPredicates::CONCEPT_REL_PREDICATES.each do |type, (ns, name)|
           predicate name, namespace: ns, to: :"#{type}_targets",

data/lib/glossarist/rdf/gloss_partitive_member.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require "lutaml/model"
+
+module Glossarist
+  module Rdf
+    # RDF view for V3::PartitiveMember. Emits a
+    # gloss:PartitiveMember subject with ref + certainty properties.
+    class GlossPartitiveMember < Lutaml::Model::Serializable
+      attribute :ref_id, :string
+      attribute :ref_source, :string
+      attribute :ref_text, :string
+      attribute :certainty, :string
+
+      rdf do
+        namespace Namespaces::GlossaristNamespace
+
+        subject { |m| "partitiveMember/#{m.ref_source}:#{m.ref_id}" }
+
+        types "gloss:PartitiveMember"
+
+        predicate :refSource, namespace: Namespaces::GlossaristNamespace,
+                              to: :ref_source
+        predicate :refId, namespace: Namespaces::GlossaristNamespace,
+                          to: :ref_id
+        predicate :refText, namespace: Namespaces::GlossaristNamespace,
+                            to: :ref_text
+        predicate :certainty, namespace: Namespaces::GlossaristNamespace,
+                              to: :certainty
+      end
+    end
+  end
+end

data/lib/glossarist/rdf/gloss_partitive_relation.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require "lutaml/model"
+
+module Glossarist
+  module Rdf
+    # RDF view for V3::PartitiveRelation. Emits a
+    # gloss:PartitiveRelation subject with comprehensive, hasPartitive,
+    # completeness, hasPlurality, criterion properties.
+    class GlossPartitiveRelation < Lutaml::Model::Serializable
+      attribute :identifier, :string
+      attribute :comprehensive_uri, :string
+      attribute :partitive_member_ids, :string, collection: true
+      attribute :completeness, :string
+      attribute :has_plurality, GlossTypeSharedPlurality
+      attribute :criterion, :hash
+
+      rdf do
+        namespace Namespaces::GlossaristNamespace
+
+        subject { |r| "partitiveRelation/#{r.identifier}/#{r.object_id}" }
+
+        types "gloss:PartitiveRelation"
+
+        predicate :comprehensive, namespace: Namespaces::GlossaristNamespace,
+                                  to: :comprehensive_uri, uri_reference: true
+        predicate :hasPartitive, namespace: Namespaces::GlossaristNamespace,
+                                 to: :partitive_member_ids, uri_reference: true
+        predicate :completeness, namespace: Namespaces::GlossaristNamespace,
+                                 to: :completeness, uri_reference: true
+        members :has_plurality,
+                link: "gloss:hasPlurality"
+        predicate :criterion, namespace: Namespaces::GlossaristNamespace,
+                              to: :criterion
+      end
+    end
+  end
+end

data/lib/glossarist/rdf/gloss_type_shared_plurality.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require "lutaml/model"
+
+module Glossarist
+  module Rdf
+    # RDF view for V3::TypeSharedPlurality. Emits a
+    # gloss:TypeSharedPlurality subject with is_shared, is_uncertain,
+    # shared_type properties.
+    class GlossTypeSharedPlurality < Lutaml::Model::Serializable
+      attribute :is_shared, :boolean
+      attribute :is_uncertain, :boolean
+      attribute :shared_type_uri, :string
+
+      rdf do
+        namespace Namespaces::GlossaristNamespace
+
+        subject { |p| "plurality/#{p.object_id}" }
+
+        types "gloss:TypeSharedPlurality"
+
+        predicate :isShared, namespace: Namespaces::GlossaristNamespace,
+                             to: :is_shared
+        predicate :isUncertain, namespace: Namespaces::GlossaristNamespace,
+                                to: :is_uncertain
+        predicate :sharedType, namespace: Namespaces::GlossaristNamespace,
+                               to: :shared_type_uri, uri_reference: true
+      end
+    end
+  end
+end

data/lib/glossarist/rdf/v3.rb

@@ -29,7 +29,9 @@ module Glossarist
         GlossFigureImage
         GlossTable
         GlossFormula
-        GlossHyperedge
+        GlossPartitiveRelation
+        GlossPartitiveMember
+        GlossTypeSharedPlurality
       ].freeze
 
       VIEW_CLASS_NAMES.each do |name|

data/lib/glossarist/rdf.rb

@@ -42,7 +42,10 @@ module Glossarist
     autoload :GlossFigureImage,       "#{__dir__}/rdf/gloss_figure_image"
     autoload :GlossTable,             "#{__dir__}/rdf/gloss_table"
     autoload :GlossFormula,           "#{__dir__}/rdf/gloss_formula"
-    autoload :GlossHyperedge,         "#{__dir__}/rdf/gloss_hyperedge"
+    autoload :GlossPartitiveRelation, "#{__dir__}/rdf/gloss_partitive_relation"
+    autoload :GlossPartitiveMember,   "#{__dir__}/rdf/gloss_partitive_member"
+    autoload :GlossTypeSharedPlurality,
+             "#{__dir__}/rdf/gloss_type_shared_plurality"
     autoload :V3,                     "#{__dir__}/rdf/v3"
   end
 end

data/lib/glossarist/transforms/concept_to_gloss_transform.rb

@@ -130,42 +130,64 @@ module Glossarist
           domains: build_gloss_domains(managed_concept.data&.domains,
                                        identifier),
           dates: build_gloss_dates(managed_concept.dates, identifier),
-          hyperedges: build_gloss_hyperedges(v3_hyperedges(managed_concept),
-                                             identifier),
+          partitive_relations: build_gloss_partitive_relations(
+            v3_partitive_relations(managed_concept), identifier,
+          ),
           **rel_targets,
         )
       end
 
-      # Hyperedges are a V3-only attribute. The transform accepts both
-      # V1/V2 and V3 concepts; for V1/V2 concepts the hyperedge list
-      # is always empty.
-      def v3_hyperedges(managed_concept)
+      # PartitiveRelations are a V3-only attribute. The transform
+      # accepts both V1/V2 and V3 concepts; for V1/V2 concepts the
+      # relation list is always empty.
+      def v3_partitive_relations(managed_concept)
         return [] unless managed_concept.is_a?(V3::ManagedConcept)
 
-        managed_concept.partitive_hyperedges
+        managed_concept.partitive_relations
       end
 
-      def build_gloss_hyperedges(hyperedges, identifier)
-        return [] unless hyperedges
+      def build_gloss_partitive_relations(relations, identifier)
+        return [] unless relations
 
-        Array(hyperedges).map do |he|
-          Rdf::GlossHyperedge.new(
+        Array(relations).map do |rel|
+          Rdf::GlossPartitiveRelation.new(
             identifier: identifier.to_s,
-            comprehensive_id: he.comprehensive.id.to_s,
-            comprehensive_uri: hyperedge_concept_uri(he.comprehensive),
-            part_uris: Array(he.parts).map { |p| hyperedge_concept_uri(p) },
-            enumeration: he.enumeration,
-            markers: Array(he.markers),
-            content: he.content,
+            comprehensive_uri: partitive_concept_uri(rel.comprehensive),
+            partitive_member_ids: Array(rel.partitives).map do |m|
+              partitive_member_uri(m)
+            end,
+            completeness: rel.completeness,
+            has_plurality: build_gloss_plurality(rel.plurality),
+            criterion: rel.criterion,
           )
         end
       end
 
-      def hyperedge_concept_uri(ref)
+      def build_gloss_plurality(plurality)
+        return nil unless plurality
+
+        Rdf::GlossTypeSharedPlurality.new(
+          is_shared: plurality.is_shared,
+          is_uncertain: plurality.is_uncertain,
+          shared_type_uri: partitive_concept_uri(plurality.shared_type),
+        )
+      end
+
+      def partitive_concept_uri(ref)
+        return nil unless ref.is_a?(Glossarist::ConceptRef)
+
+        Glossarist::Rdf::Namespaces::GlossaristNamespace.uri +
+          "concept/#{ref.id || ref.text}"
+      end
+
+      def partitive_member_uri(member)
+        return nil unless member.is_a?(V3::PartitiveMember)
+
+        ref = member.ref
         return nil unless ref.is_a?(Glossarist::ConceptRef)
 
         Glossarist::Rdf::Namespaces::GlossaristNamespace.uri +
-          "concept/#{ref.id}"
+          "concept/#{ref.id || ref.text}"
       end
 
       def build_gloss_localized_concept(l10n, concept_id)

data/lib/glossarist/v3/managed_concept.rb

@@ -5,7 +5,7 @@ module Glossarist
     class ManagedConcept < Glossarist::ManagedConcept
       attribute :data, V3::ManagedConceptData, default: -> { V3::ManagedConceptData.new }
       attribute :related, V3::RelatedConcept, collection: true
-      attribute :partitive_hyperedges, V3::PartitiveHyperedge, collection: true
+      attribute :partitive_relations, V3::PartitiveRelation, collection: true
       attribute :dates, V3::ConceptDate, collection: true
       attribute :date_accepted, V3::ConceptDate
       attribute :sources, V3::ConceptSource, collection: true
@@ -13,7 +13,7 @@ module Glossarist
       key_value do
         map :data, to: :data
         map :related, to: :related
-        map :partitive_hyperedges, to: :partitive_hyperedges
+        map :partitive_relations, to: :partitive_relations
         map :dates, to: :dates
         map %i[date_accepted dateAccepted],
             with: { from: :date_accepted_from_yaml, to: :date_accepted_to_yaml }

data/lib/glossarist/v3/partitive_member.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module Glossarist
+  module V3
+    # PartitiveMember — one member of a PartitiveRelation, carrying
+    # a ConceptRef to the partitive concept plus optional certainty
+    # metadata (Glossarist extension beyond ISO 704 notation).
+    #
+    # A PartitiveMember with no certainty field is implicitly
+    # confirmed.
+    class PartitiveMember < Lutaml::Model::Serializable
+      DEFAULT_CERTAINTY = "confirmed"
+
+      attribute :ref, ConceptRef
+      attribute :certainty, :string,
+                values: Glossarist::GlossaryDefinition::MEMBER_CERTAINTY_VALUES,
+                default: -> { DEFAULT_CERTAINTY }
+
+      key_value do
+        map :ref, to: :ref
+        map :certainty, to: :certainty
+      end
+
+      def validate!
+        validate_ref!
+        validate_certainty!
+        self
+      end
+
+      def confirmed?
+        certainty == DEFAULT_CERTAINTY
+      end
+
+      def possible?
+        certainty == "possible"
+      end
+
+      private
+
+      def validate_ref!
+        return if ref.is_a?(ConceptRef) && (ref.source || ref.id || ref.text)
+
+        raise ArgumentError,
+              "PartitiveMember#ref must be a non-empty ConceptRef " \
+              "(source, id, or text required)"
+      end
+
+      def validate_certainty!
+        return if certainty.nil?
+
+        unless Glossarist::GlossaryDefinition::MEMBER_CERTAINTY_VALUES
+                 .include?(certainty)
+          raise ArgumentError,
+                "PartitiveMember#certainty has invalid value " \
+                "#{certainty.inspect}; must be one of " \
+                "#{GlossaryDefinition::MEMBER_CERTAINTY_VALUES.join(', ')}"
+        end
+      end
+    end
+  end
+end

data/lib/glossarist/v3/partitive_relation.rb

@@ -0,0 +1,119 @@
+# frozen_string_literal: true
+
+module Glossarist
+  module V3
+    # PartitiveRelation — an ISO 704 / ISO 1087-1 / ISO 12620
+    # partitive relation connecting a comprehensive concept
+    # (superordinate concept partitive) to two or more partitive
+    # concepts (subordinate concepts partitive) which fitted together
+    # constitute the comprehensive.
+    #
+    # Shown as a rake or bracket in source diagrams. All partitives
+    # within one relation are coordinate concepts: they share the
+    # comprehensive AND share the criterion of subdivision.
+    #
+    # Glossarist extensions beyond ISO notation:
+    #   - Per-partitive certainty (MemberCertainty)
+    #   - plurality.shared_type (the type the partitives share)
+    #   - criterion as a structured field (not just diagrammatic)
+    #
+    # Replaces the prior PartitiveHyperedge class. The "hyperedge"
+    # framing was graph-theoretic; ISO calls this a *relation*.
+    class PartitiveRelation < Lutaml::Model::Serializable
+      DEFAULT_COMPLETENESS = "complete"
+
+      attribute :comprehensive, ConceptRef
+      attribute :partitives, PartitiveMember, collection: true
+      attribute :completeness, :string,
+                values: Glossarist::GlossaryDefinition::COMPLETENESS_VALUES,
+                default: -> { DEFAULT_COMPLETENESS }
+      attribute :plurality, TypeSharedPlurality
+      attribute :criterion, :hash
+
+      key_value do
+        map :comprehensive, to: :comprehensive
+        map :partitives, to: :partitives
+        map :completeness, to: :completeness
+        map :plurality, to: :plurality
+        map :criterion, to: :criterion
+      end
+
+      def validate!
+        validate_comprehensive!
+        validate_partitives!
+        validate_self_loop!
+        validate_completeness!
+        validate_plurality!
+        self
+      end
+
+      def complete?
+        completeness == "complete"
+      end
+
+      def partial?
+        completeness == "partial"
+      end
+
+      # ISO 704: a partitive relation connects to two or more
+      # partitives. A single binary has_part edge is not a
+      # PartitiveRelation.
+      def coordinate?
+        partitives.length >= 2
+      end
+
+      private
+
+      def validate_comprehensive!
+        return if comprehensive.is_a?(ConceptRef) &&
+                  (comprehensive.source || comprehensive.id || comprehensive.text)
+
+        raise ArgumentError,
+              "PartitiveRelation#comprehensive must be a non-empty " \
+              "ConceptRef (source, id, or text required)"
+      end
+
+      def validate_partitives!
+        if partitives.empty?
+          raise ArgumentError, "PartitiveRelation requires at least one partitive"
+        end
+        unless coordinate?
+          raise ArgumentError,
+                "PartitiveRelation requires ≥2 partitives (ISO 704); a single " \
+                "binary has_part edge should be used instead"
+        end
+
+        partitives.each(&:validate!)
+      end
+
+      def validate_self_loop!
+        return unless comprehensive.is_a?(ConceptRef)
+
+        comp_key = [comprehensive.source, comprehensive.id]
+        partitives.each do |member|
+          next unless member.ref.is_a?(ConceptRef)
+          next unless [member.ref.source, member.ref.id] == comp_key
+
+          raise ArgumentError,
+                "PartitiveRelation#partitives cannot include the comprehensive"
+        end
+      end
+
+      def validate_completeness!
+        return if completeness.nil?
+
+        unless Glossarist::GlossaryDefinition::COMPLETENESS_VALUES
+                 .include?(completeness)
+          raise ArgumentError,
+                "PartitiveRelation#completeness has invalid value " \
+                "#{completeness.inspect}; must be one of " \
+                "#{GlossaryDefinition::COMPLETENESS_VALUES.join(', ')}"
+        end
+      end
+
+      def validate_plurality!
+        plurality&.validate!
+      end
+    end
+  end
+end

data/lib/glossarist/v3/type_shared_plurality.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Glossarist
+  module V3
+    # TypeSharedPlurality — semantic claims encoded by ISO 704's
+    # close-set double line and broken line notation, promoted from
+    # diagram-notation flags to structured data so tools can reason
+    # about plurality directly.
+    #
+    # A PartitiveRelation has at most one TypeSharedPlurality block.
+    # Absent means: no type-shared plurality claim is being made.
+    #
+    # Replaces the prior `markers` field (which encoded the same
+    # information as opaque strings like "double" and "dashed").
+    class TypeSharedPlurality < Lutaml::Model::Serializable
+      attribute :is_shared, :boolean
+      attribute :is_uncertain, :boolean, default: -> { false }
+      attribute :shared_type, ConceptRef
+
+      key_value do
+        map :is_shared, to: :is_shared
+        map :is_uncertain, to: :is_uncertain
+        map :shared_type, to: :shared_type
+      end
+
+      def validate!
+        unless is_shared.is_a?(TrueClass) || is_shared.is_a?(FalseClass)
+          raise ArgumentError,
+                "TypeSharedPlurality#is_shared is required (boolean)"
+        end
+
+        if is_uncertain == true && is_shared == false
+          raise ArgumentError,
+                "TypeSharedPlurality#is_uncertain requires is_shared: true " \
+                "(ISO 704 broken line qualifies the close-set double line claim)"
+        end
+
+        self
+      end
+    end
+  end
+end

data/lib/glossarist/v3.rb

@@ -9,7 +9,9 @@ module Glossarist
     autoload :DetailedDefinition, "glossarist/v3/detailed_definition"
     autoload :ConceptRef, "glossarist/v3/concept_ref"
     autoload :RelatedConcept, "glossarist/v3/related_concept"
-    autoload :PartitiveHyperedge, "glossarist/v3/partitive_hyperedge"
+    autoload :PartitiveRelation, "glossarist/v3/partitive_relation"
+    autoload :PartitiveMember, "glossarist/v3/partitive_member"
+    autoload :TypeSharedPlurality, "glossarist/v3/type_shared_plurality"
     autoload :ConceptData, "glossarist/v3/concept_data"
     autoload :LocalizedConcept, "glossarist/v3/localized_concept"
     autoload :ManagedConceptData, "glossarist/v3/managed_concept_data"
@@ -24,7 +26,9 @@ module Glossarist
     Configuration.register_model(LocalizedConcept, id: :localized_concept)
     Configuration.register_model(ConceptRef, id: :concept_ref)
     Configuration.register_model(RelatedConcept, id: :related_concept)
-    Configuration.register_model(PartitiveHyperedge, id: :partitive_hyperedge)
+    Configuration.register_model(PartitiveRelation, id: :partitive_relation)
+    Configuration.register_model(PartitiveMember, id: :partitive_member)
+    Configuration.register_model(TypeSharedPlurality, id: :type_shared_plurality)
     Configuration.register_model(ManagedConceptData, id: :managed_concept_data)
     Configuration.register_model(ManagedConcept, id: :managed_concept)
     Configuration.register_model(ConceptDocument, id: :concept_document)

data/lib/glossarist/validation/rules/partitive_relation_rule.rb

@@ -0,0 +1,150 @@
+# frozen_string_literal: true
+
+module Glossarist
+  module Validation
+    module Rules
+      # Validates semantic invariants of PartitiveRelation entries
+      # that the model constructor does NOT enforce. Specifically:
+      #
+      #   - error when a relation has fewer than 2 partitives
+      #     (ISO 704: "two or more"; single binary should use
+      #     has_part edge instead)
+      #   - error when two relations share the same comprehensive
+      #     AND the same non-nil criterion (duplicate decomposition;
+      #     ISO 12620 coordinate-concept coherence)
+      #   - warning when a relation has no criterion (cannot
+      #     distinguish from siblings sharing the comprehensive)
+      #   - error when plurality.is_uncertain is set without
+      #     plurality.is_shared: true (broken-line qualifies
+      #     close-set double line)
+      #   - error when ExternalConcept (status: external) lacks
+      #     at least one designation
+      #
+      # The model constructor already rejects empty comprehensive,
+      # empty partitives list, self-loops, invalid enum values.
+      class PartitiveRelationRule < Base
+        def code = "GLS-221"
+        def category = :schema
+        def severity = "error"
+        def scope = :concept
+
+        def applicable?(context)
+          concept = context.concept
+          return false unless concept.is_a?(V3::ManagedConcept)
+
+          concept.partitive_relations&.any? || external?(concept)
+        end
+
+        def check(context)
+          concept = context.concept
+          fname = context.file_name
+          issues = []
+
+          return issues unless concept.is_a?(V3::ManagedConcept)
+
+          relations = Array(concept.partitive_relations)
+
+          relations.each_with_index do |rel, idx|
+            check_cardinality(rel, idx, fname, issues)
+            check_criterion_present(rel, idx, fname, issues)
+            check_plurality_coherence(rel, idx, fname, issues)
+          end
+
+          check_duplicate_decomposition(relations, fname, issues)
+          check_external_concept(concept, fname, issues)
+
+          issues
+        end
+
+        private
+
+        def external?(concept)
+          concept.status == "external"
+        end
+
+        def check_cardinality(rel, idx, fname, issues)
+          return if rel.partitives.length >= 2
+
+          issues << issue(
+            "partitive_relation #{idx + 1} has fewer than 2 partitives " \
+            "(ISO 704 requires two or more); a single binary has_part edge " \
+            "should be used instead",
+            location: fname,
+          )
+        end
+
+        def check_criterion_present(rel, idx, fname, issues)
+          return if rel.criterion && !rel.criterion.empty?
+
+          issues << issue(
+            "partitive_relation #{idx + 1} has no criterion; cannot verify " \
+            "distinctness from sibling relations sharing the comprehensive " \
+            "(ISO 12620 coordinate-concept coherence)",
+            severity: "warning",
+            location: fname,
+            suggestion: "Add a criterion: { eng: '...' } field",
+          )
+        end
+
+        def check_plurality_coherence(rel, idx, fname, issues)
+          plural = rel.plurality
+          return unless plural
+          return unless plural.is_uncertain
+          return if plural.is_shared
+
+          issues << issue(
+            "partitive_relation #{idx + 1}.plurality: is_uncertain requires " \
+            "is_shared: true (ISO 704 broken line qualifies the close-set " \
+            "double line claim)",
+            location: fname,
+          )
+        end
+
+        def check_duplicate_decomposition(relations, fname, issues)
+          grouped = {}
+          relations.each_with_index do |rel, idx|
+            next unless rel.criterion && !rel.criterion.empty?
+
+            key = criterion_key(rel)
+            (grouped[key] ||= []) << idx
+          end
+
+          grouped.each do |key, idxs|
+            next if idxs.length == 1
+
+            issues << issue(
+              "duplicate PartitiveRelation for comprehensive " \
+              "#{key.first.inspect} with criterion #{key.last.inspect} " \
+              "(relations ##{idxs.map { |i| i + 1 }.join(', ')}); " \
+              "two relations sharing comprehensive AND criterion are the " \
+              "same decomposition",
+              location: fname,
+            )
+          end
+        end
+
+        def criterion_key(rel)
+          comp = rel.comprehensive
+          comp_id = comp.is_a?(ConceptRef) ? [comp.source, comp.id] : nil
+          [comp_id, rel.criterion]
+        end
+
+        def check_external_concept(concept, fname, issues)
+          return unless external?(concept)
+
+          has_designation = concept.localizations.any? do |_, lc|
+            lc.is_a?(LocalizedConcept) && lc.terms&.any?
+          end
+
+          return if has_designation
+
+          issues << issue(
+            "ExternalConcept (status: external) must have at least one " \
+            "designation — even external concepts have a name",
+            location: fname,
+          )
+        end
+      end
+    end
+  end
+end

data/lib/glossarist/version.rb

@@ -4,5 +4,5 @@
 #
 
 module Glossarist
-  VERSION = "2.12.1"
+  VERSION = "2.13.0"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: glossarist
 version: !ruby/object:Gem::Version
-  version: 2.12.1
+  version: 2.13.0
 platform: ruby
 authors:
 - Ribose
@@ -307,13 +307,15 @@ files:
 - lib/glossarist/rdf/gloss_figure_image.rb
 - lib/glossarist/rdf/gloss_formula.rb
 - lib/glossarist/rdf/gloss_grammar_info.rb
-- lib/glossarist/rdf/gloss_hyperedge.rb
 - lib/glossarist/rdf/gloss_locality.rb
 - lib/glossarist/rdf/gloss_localized_concept.rb
 - lib/glossarist/rdf/gloss_non_verbal_rep.rb
+- lib/glossarist/rdf/gloss_partitive_member.rb
+- lib/glossarist/rdf/gloss_partitive_relation.rb
 - lib/glossarist/rdf/gloss_pronunciation.rb
 - lib/glossarist/rdf/gloss_reference.rb
 - lib/glossarist/rdf/gloss_table.rb
+- lib/glossarist/rdf/gloss_type_shared_plurality.rb
 - lib/glossarist/rdf/localized_literal.rb
 - lib/glossarist/rdf/lutaml_ext.rb
 - lib/glossarist/rdf/namespaces.rb
@@ -395,8 +397,10 @@ files:
 - lib/glossarist/v3/localized_concept.rb
 - lib/glossarist/v3/managed_concept.rb
 - lib/glossarist/v3/managed_concept_data.rb
-- lib/glossarist/v3/partitive_hyperedge.rb
+- lib/glossarist/v3/partitive_member.rb
+- lib/glossarist/v3/partitive_relation.rb
 - lib/glossarist/v3/related_concept.rb
+- lib/glossarist/v3/type_shared_plurality.rb
 - lib/glossarist/validation.rb
 - lib/glossarist/validation/asset_index.rb
 - lib/glossarist/validation/bibliography_index.rb
@@ -438,7 +442,7 @@ files:
 - lib/glossarist/validation/rules/orphaned_bibliography_rule.rb
 - lib/glossarist/validation/rules/orphaned_images_rule.rb
 - lib/glossarist/validation/rules/orphaned_l10n_files_rule.rb
-- lib/glossarist/validation/rules/partitive_hyperedge_rule.rb
+- lib/glossarist/validation/rules/partitive_relation_rule.rb
 - lib/glossarist/validation/rules/preferred_term_rule.rb
 - lib/glossarist/validation/rules/ref_shape_rule.rb
 - lib/glossarist/validation/rules/registry.rb

data/lib/glossarist/rdf/gloss_hyperedge.rb

@@ -1,53 +0,0 @@
-# frozen_string_literal: true
-
-require "lutaml/model"
-
-module Glossarist
-  module Rdf
-    # RDF view for a PartitiveHyperedge (concept-model v3.1.0).
-    #
-    # Emits one `gloss:PartitiveHyperedge` subject per hyperedge with:
-    #
-    #   - gloss:comprehensive — IRI of the comprehensive concept
-    #   - gloss:part          — IRI of each part concept (zero or more)
-    #   - gloss:enumeration   — xsd:string ("closed" | "open")
-    #   - gloss:hasPluralityMarker — xsd:string per marker ("double" |
-    #                                "dashed"). One triple per marker.
-    #   - gloss:hyperedgeContent   — xsd:string (omitted if absent)
-    #
-    # The hyperedge is anchored to the concept that carries it via
-    # `gloss:hasHyperedge` (an inverse of `gloss:comprehensive`). The
-    # subject URI is derived from the carrying concept's identifier
-    # and the comprehensive's id, so it is stable across builds.
-    class GlossHyperedge < Lutaml::Model::Serializable
-      attribute :identifier, :string
-      attribute :comprehensive_id, :string
-      attribute :comprehensive_uri, :string
-      attribute :part_uris, :string, collection: true
-      attribute :enumeration, :string
-      attribute :markers, :string, collection: true
-      attribute :content, :hash
-
-      rdf do
-        namespace Namespaces::GlossaristNamespace
-
-        subject { |h| "hyperedge/#{h.identifier}/#{h.comprehensive_id}" }
-
-        types "gloss:PartitiveHyperedge"
-
-        predicate :comprehensive, namespace: Namespaces::GlossaristNamespace,
-                                   to: :comprehensive_uri
-        predicate :part, namespace: Namespaces::GlossaristNamespace,
-                          to: :part_uris
-        predicate :enumeration, namespace: Namespaces::GlossaristNamespace,
-                                to: :enumeration
-        predicate :hasPluralityMarker,
-                  namespace: Namespaces::GlossaristNamespace,
-                  to: :markers
-        predicate :hyperedgeContent,
-                  namespace: Namespaces::GlossaristNamespace,
-                  to: :content
-      end
-    end
-  end
-end

data/lib/glossarist/v3/partitive_hyperedge.rb

@@ -1,132 +0,0 @@
-# frozen_string_literal: true
-
-module Glossarist
-  module V3
-    # PartitiveHyperedge — a one-to-many partitive decomposition.
-    #
-    # One comprehensive concept (the whole) is related to one or more
-    # parts as a SINGLE relationship. Captures invariants that binary
-    # RelatedConcept edges cannot:
-    #
-    #   - which comprehensive owns which parts (set membership)
-    #   - plurality markers from the source diagram (double / dashed)
-    #   - enumeration completeness (closed: all parts listed; open:
-    #     other parts may exist)
-    #
-    # Enum values are SSOT-loaded from `config.yml` via
-    # `GlossaryDefinition`. The `values:` option on each attribute
-    # documents the enum for schema generation. lutaml-model 0.8.x
-    # does NOT enforce `values:` on assignment — semantic checks live
-    # in `Validation::Rules::PartitiveHyperedgeRule` (auto-registered
-    # via `Validation::Rules`). The model's `validate!` method covers
-    # type-shape invariants that fail loudly at construction (empty
-    # comprehensive, empty parts, self-loop, invalid enum values).
-    #
-    # Note on duplicates: lutaml-model's enum-collection setter
-    # dedupes silently via the getter, so duplicate markers at
-    # construction time are silently coerced to a unique set. We do
-    # not attempt to override this; the framework's Set semantics are
-    # the data contract.
-    #
-    # `content` is a localized string hash `{ "eng" => "...", "fra" => "..." }`
-    # keyed by ISO 639 language code. All free-form text fields in
-    # Glossarist MUST be localized — the project is multi-language by
-    # domain. Read values via the `LocalizedString` helper module:
-    #
-    #   Glossarist::LocalizedString.fetch(he.content, "eng")
-    #
-    # Matches the pattern used by `Section#names`, `DatasetRegister#description`,
-    # `Formula#expression`, `Table#content`. The concept-model schema and
-    # `RelatedConcept#content` still declare `type: string` today — those
-    # are bugs to fix, not patterns to copy.
-    class PartitiveHyperedge < Lutaml::Model::Serializable
-      DEFAULT_ENUMERATION = "closed"
-
-      attribute :comprehensive, ConceptRef
-      attribute :parts, ConceptRef, collection: true
-      attribute :enumeration, :string,
-                values: Glossarist::GlossaryDefinition::PARTITIVE_ENUMERATION_VALUES,
-                default: -> { DEFAULT_ENUMERATION }
-      attribute :markers, :string,
-                values: Glossarist::GlossaryDefinition::PLURALITY_MARKER_VALUES,
-                collection: true
-      attribute :content, :hash
-
-      key_value do
-        map :comprehensive, to: :comprehensive
-        map :parts, to: :parts
-        map :enumeration, to: :enumeration
-        map :markers, to: :markers
-        map :content, to: :content
-      end
-
-      # Type-shape validators — invoke via `validate!` after
-      # construction. We do NOT call these from `initialize` because
-      # lutaml-model deserializes attributes AFTER `new` returns (see
-      # `Lutaml::KeyValue::Transform#data_to_model`); validating in
-      # `initialize` sees a half-built instance and raises spuriously.
-
-      def validate!
-        validate_comprehensive!
-        validate_parts!
-        validate_self_loop!
-        validate_markers!
-        validate_enumeration!
-        self
-      end
-
-      private
-
-      def validate_comprehensive!
-        return if comprehensive.is_a?(ConceptRef) &&
-                  (comprehensive.source || comprehensive.id)
-
-        raise ArgumentError,
-              "PartitiveHyperedge#comprehensive must be a non-empty " \
-              "ConceptRef (source or id required)"
-      end
-
-      def validate_parts!
-        return if Array(parts).any?
-
-        raise ArgumentError, "PartitiveHyperedge requires at least one part"
-      end
-
-      def validate_self_loop!
-        return unless comprehensive.is_a?(ConceptRef)
-
-        comp_key = [comprehensive.source, comprehensive.id]
-        parts.each do |p|
-          next unless p.is_a?(ConceptRef)
-          next unless [p.source, p.id] == comp_key
-
-          raise ArgumentError,
-                "PartitiveHyperedge#parts cannot include the comprehensive"
-        end
-      end
-
-      def validate_markers!
-        Array(markers).each do |m|
-          unless Glossarist::GlossaryDefinition::PLURALITY_MARKER_VALUES.include?(m)
-            raise ArgumentError,
-                  "PartitiveHyperedge#markers contains invalid value #{m.inspect}; " \
-                  "must be one of " \
-                  "#{GlossaryDefinition::PLURALITY_MARKER_VALUES.join(', ')}"
-          end
-        end
-      end
-
-      def validate_enumeration!
-        return if enumeration.nil?
-
-        unless Glossarist::GlossaryDefinition::PARTITIVE_ENUMERATION_VALUES
-                 .include?(enumeration)
-          raise ArgumentError,
-                "PartitiveHyperedge#enumeration has invalid value " \
-                "#{enumeration.inspect}; must be one of " \
-                "#{GlossaryDefinition::PARTITIVE_ENUMERATION_VALUES.join(', ')}"
-        end
-      end
-    end
-  end
-end

data/lib/glossarist/validation/rules/partitive_hyperedge_rule.rb

@@ -1,112 +0,0 @@
-# frozen_string_literal: true
-
-module Glossarist
-  module Validation
-    module Rules
-      # Validates semantic invariants of PartitiveHyperedge entries that
-      # the model constructor does NOT enforce. Specifically:
-      #
-      #   - warning when `enumeration` was filled by lutaml-model's
-      #     default proc (i.e. the source YAML omitted it) — author is
-      #     *encouraged* to set explicitly per the design doc
-      #   - error when markers contain values not in
-      #     PLURALITY_MARKER_VALUES
-      #
-      # The model constructor already rejects empty comprehensive,
-      # empty parts, self-loops, and (lutaml-model auto-dedupes
-      # duplicate markers on enum-collection assignment, so no
-      # explicit check is needed).
-      class PartitiveHyperedgeRule < Base
-        def code = "GLS-220"
-        def category = :schema
-        def severity = "error"
-        def scope = :concept
-
-        def applicable?(context)
-          concept = context.concept
-          return false unless concept.is_a?(V3::ManagedConcept)
-
-          concept.partitive_hyperedges&.any?
-        end
-
-        def check(context)
-          concept = context.concept
-          fname = context.file_name
-          issues = []
-
-          return issues unless concept.is_a?(V3::ManagedConcept)
-
-          concept.partitive_hyperedges.each_with_index do |he, idx|
-            check_comprehensive(he, idx, fname, issues)
-            check_parts(he, idx, fname, issues)
-            check_markers(he, idx, fname, issues)
-            check_enumeration_explicit(he, idx, fname, issues)
-          end
-
-          issues
-        end
-
-        private
-
-        def check_comprehensive(he, idx, fname, issues)
-          ref = he.comprehensive
-          return if ref.is_a?(Glossarist::ConceptRef) && (ref.source || ref.id)
-
-          issues << issue(
-            "partitive_hyperedge #{idx + 1} has empty comprehensive",
-            location: fname,
-          )
-        end
-
-        def check_parts(he, idx, fname, issues)
-          parts = Array(he.parts)
-          if parts.empty?
-            issues << issue(
-              "partitive_hyperedge #{idx + 1} has no parts",
-              location: fname,
-            )
-            return
-          end
-
-          parts.each_with_index do |part, pi|
-            next if part.is_a?(Glossarist::ConceptRef) && (part.source || part.id)
-
-            issues << issue(
-              "partitive_hyperedge #{idx + 1} part #{pi + 1} has empty ref",
-              location: fname,
-            )
-          end
-        end
-
-        def check_markers(he, idx, fname, issues)
-          # `using_default?` reports whether an attribute was set by
-          # the user (false) or filled by the default proc (true).
-          # `markers` has no default, so absence yields nil/[] and
-          # `using_default?(:markers)` is true. We still walk for
-          # invalid values because `values:` is informational.
-          Array(he.markers).each_with_index do |m, mi|
-            unless Glossarist::GlossaryDefinition::PLURALITY_MARKER_VALUES.include?(m)
-              issues << issue(
-                "partitive_hyperedge #{idx + 1} marker #{mi + 1} has invalid value #{m.inspect}",
-                location: fname,
-              )
-            end
-          end
-        end
-
-        def check_enumeration_explicit(he, idx, fname, issues)
-          # `using_default?(:enumeration)` is true iff the value was
-          # NOT explicitly set by the caller (filled by default proc).
-          return unless he.using_default?(:enumeration)
-
-          issues << issue(
-            "partitive_hyperedge #{idx + 1} has implicit enumeration (default '#{Glossarist::V3::PartitiveHyperedge::DEFAULT_ENUMERATION}')",
-            severity: "warning",
-            location: fname,
-            suggestion: "Set 'enumeration: closed' or 'enumeration: open' explicitly",
-          )
-        end
-      end
-    end
-  end
-end