glossarist 2.12.1 → 2.13.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4fafa61aa5261ca29216b423006cd0764470a9f8bf59733449ba3b501a63413b
-  data.tar.gz: b7c5f6148a76feca5dcbe8321e1a49bed99772a415168ddb977786d214c50110
+  metadata.gz: '0898c5d75bdeac6ca104c401a0492061a765079c601cd87c1fa9c134651b52d0'
+  data.tar.gz: 3c2cf3896eab10345fea5374ccca555193c31f9ee7773fc4e03ca1f5ea3b6af3
 SHA512:
-  metadata.gz: 163a2b94ff599127f8997de745f05ebec13ab19095790bf91ca832e7ea2c79525c65ca93a4e1cbd45ba4fcd9c4f1d4db9cb564bf370497d1e22fd5aa3e28ec73
-  data.tar.gz: 43be5caab946b3202614ec38db165f6ce72b56137ca1daa87fa0e9c12a853b3c878541c8b8a9b23589719d4239a566ddb621ddee2552e7c284ab435232c03cd1
+  metadata.gz: 2eac98effdcbc12e9934df41d9c6c01c19a5c5f6388497be63039a3b50bd6fba5e289ad3eb573c18c4f7740f34d8711f002285f8fb614aef60c2352b90698670
+  data.tar.gz: be3178b14bb2a16894e8af117b08f5a34a2910a27a6d289a3298db37647cb8c4cdad4acc78674b6189a4cd3a9d265625dbfc54d3e2ac084447ac875c9ec84749

data/CLAUDE.md

@@ -47,23 +47,36 @@ 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 ISO 704:2022 notation metadata:
+  - `multiplicity` — one of `compulsory` (1 solid line, default), `optional` (1 dashed line), `compulsory_multiple` (2 solid lines), `optional_multiple` (2 dashed lines), `at_least_one` (1 solid + 1 dashed line)
+  - `is_delimiting` — boolean (default false). A delimiting part behaves like a delimiting characteristic: it distinguishes the comprehensive from coordinate concepts. Rendered as a bold 3x-width line in the diagram. Orthogonal to multiplicity.
+- `completeness` — `complete` (default; the encoded partitives constitute the whole) or `partial` (others exist beyond those encoded). ISO 704 rake backline notation.
+- `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 `MULTIPLICITY_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, 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, non-default multiplicity 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`. 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/multiplicity/delimiting/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,32 @@ 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.
+multiplicity:
+  # ISO 704:2022 partitive member multiplicity. Encodes the diagram
+  # line notation as structured data:
+  #   compulsory          — 1 solid line (must exist in every instance)
+  #   optional            — 1 dashed line (exists in some instances only)
+  #   compulsory_multiple — 2 solid lines (multiple must exist)
+  #   optional_multiple   — 2 dashed lines (multiple may exist)
+  #   at_least_one        — 1 solid + 1 dashed line (at least one must exist)
+  # Default: compulsory.
   value:
-    - double   # close-set double line at receiver; several parts involved
-    - dashed   # broken/dashed line; plurality is uncertain
+    - compulsory
+    - optional
+    - compulsory_multiple
+    - optional_multiple
+    - at_least_one

data/lib/glossarist/glossary_definition.rb

@@ -34,10 +34,9 @@ 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).
+    COMPLETENESS_VALUES = config.dig("completeness", "value").freeze
 
-    PLURALITY_MARKER_VALUES =
-      config.dig("plurality_marker", "value").freeze
+    MULTIPLICITY_VALUES = config.dig("multiplicity", "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,37 @@
+# frozen_string_literal: true
+
+require "lutaml/model"
+
+module Glossarist
+  module Rdf
+    # RDF view for V3::PartitiveMember. Emits a
+    # gloss:PartitiveMember subject with ref, multiplicity, and
+    # is_delimiting properties.
+    class GlossPartitiveMember < Lutaml::Model::Serializable
+      attribute :ref_id, :string
+      attribute :ref_source, :string
+      attribute :ref_text, :string
+      attribute :multiplicity, :string
+      attribute :is_delimiting, :boolean
+
+      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 :multiplicity, namespace: Namespaces::GlossaristNamespace,
+                                 to: :multiplicity
+        predicate :isDelimiting, namespace: Namespaces::GlossaristNamespace,
+                                 to: :is_delimiting
+      end
+    end
+  end
+end

data/lib/glossarist/rdf/gloss_partitive_relation.rb

@@ -0,0 +1,35 @@
+# 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, 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 :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
+        predicate :criterion, namespace: Namespaces::GlossaristNamespace,
+                              to: :criterion
+      end
+    end
+  end
+end

data/lib/glossarist/rdf/v3.rb

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

data/lib/glossarist/rdf.rb

@@ -42,7 +42,8 @@ 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 :V3,                     "#{__dir__}/rdf/v3"
   end
 end

data/lib/glossarist/transforms/concept_to_gloss_transform.rb

@@ -130,42 +130,53 @@ 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,
+            criterion: rel.criterion,
           )
         end
       end
 
-      def hyperedge_concept_uri(ref)
+      def partitive_concept_uri(ref)
         return nil unless ref.is_a?(Glossarist::ConceptRef)
 
         Glossarist::Rdf::Namespaces::GlossaristNamespace.uri +
-          "concept/#{ref.id}"
+          "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 || 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,82 @@
+# frozen_string_literal: true
+
+module Glossarist
+  module V3
+    # PartitiveMember — one member of a PartitiveRelation, carrying
+    # a ConceptRef to the partitive concept plus ISO 704:2022
+    # multiplicity and delimiting metadata.
+    #
+    # ISO 704:2022 partitive member notation:
+    #
+    #   multiplicity (diagram line notation):
+    #     compulsory          — 1 solid line (must exist in every instance)
+    #     optional            — 1 dashed line (exists in some instances only)
+    #     compulsory_multiple — 2 solid lines (multiple must exist)
+    #     optional_multiple   — 2 dashed lines (multiple may exist)
+    #     at_least_one        — 1 solid + 1 dashed line (≥1 must exist)
+    #
+    #   is_delimiting (orthogonal, bold 3x-width line in diagram):
+    #     A delimiting part behaves like a delimiting characteristic:
+    #     it distinguishes the comprehensive from coordinate concepts.
+    #     Example (ISO 704 §5.5.4.2.2): for "optomechanical mouse",
+    #     the delimiting parts are mouse ball, x/y-axis rollers,
+    #     infrared emitter/sensor — they distinguish it from
+    #     "mechanical mouse" and "optical mouse". Mouse button is
+    #     NOT delimiting (all computer mice have buttons).
+    class PartitiveMember < Lutaml::Model::Serializable
+      DEFAULT_MULTIPLICITY = "compulsory"
+
+      attribute :ref, ConceptRef
+      attribute :multiplicity, :string,
+                values: Glossarist::GlossaryDefinition::MULTIPLICITY_VALUES,
+                default: -> { DEFAULT_MULTIPLICITY }
+      attribute :is_delimiting, :boolean, default: -> { false }
+
+      key_value do
+        map :ref, to: :ref
+        map :multiplicity, to: :multiplicity
+        map :is_delimiting, to: :is_delimiting
+      end
+
+      def validate!
+        validate_ref!
+        validate_multiplicity!
+        self
+      end
+
+      def compulsory?
+        multiplicity == "compulsory"
+      end
+
+      def optional?
+        multiplicity == "optional"
+      end
+
+      def delimiting?
+        is_delimiting == true
+      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_multiplicity!
+        return if multiplicity.nil?
+
+        unless Glossarist::GlossaryDefinition::MULTIPLICITY_VALUES
+                 .include?(multiplicity)
+          raise ArgumentError,
+                "PartitiveMember#multiplicity has invalid value " \
+                "#{multiplicity.inspect}; must be one of " \
+                "#{GlossaryDefinition::MULTIPLICITY_VALUES.join(', ')}"
+        end
+      end
+    end
+  end
+end

data/lib/glossarist/v3/partitive_relation.rb

@@ -0,0 +1,115 @@
+# 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.
+    #
+    # Per-partitive metadata (ISO 704:2022):
+    #   - multiplicity (compulsory, optional, compulsory_multiple,
+    #     optional_multiple, at_least_one) — encodes the diagram
+    #     line notation as data
+    #   - is_delimiting — orthogonal flag; a delimiting part behaves
+    #     like a delimiting characteristic (distinguishes the
+    #     comprehensive from coordinate concepts)
+    #
+    # 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 :criterion, :hash
+
+      key_value do
+        map :comprehensive, to: :comprehensive
+        map :partitives, to: :partitives
+        map :completeness, to: :completeness
+        map :criterion, to: :criterion
+      end
+
+      def validate!
+        validate_comprehensive!
+        validate_partitives!
+        validate_self_loop!
+        validate_completeness!
+        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
+    end
+  end
+end

data/lib/glossarist/v3.rb

@@ -9,7 +9,8 @@ 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 :ConceptData, "glossarist/v3/concept_data"
     autoload :LocalizedConcept, "glossarist/v3/localized_concept"
     autoload :ManagedConceptData, "glossarist/v3/managed_concept_data"
@@ -24,7 +25,8 @@ 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(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,161 @@
+# 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)
+      #   - warning when multiplicity is not the default compulsory
+      #     (encourages explicit statement of optional/multiple)
+      #   - 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_member_multiplicity(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_member_multiplicity(rel, idx, fname, issues)
+          rel.partitives.each_with_index do |member, mi|
+            unless member.compulsory?
+              issues << issue(
+                "partitive_relation #{idx + 1}.partitives[#{mi}] has " \
+                "non-default multiplicity '#{member.multiplicity}'; " \
+                "ISO 704 diagram uses dashed/multiple-line notation for " \
+                "this — confirm the optionality is intentional",
+                severity: "warning",
+                location: fname,
+              )
+            end
+
+            next unless member.delimiting?
+
+            issues << issue(
+              "partitive_relation #{idx + 1}.partitives[#{mi}] is marked " \
+              "delimiting (ISO 704 bold 3x-width line); behaves like a " \
+              "delimiting characteristic distinguishing the comprehensive " \
+              "from coordinate concepts",
+              severity: "info",
+              location: fname,
+            )
+          end
+        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.1"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: glossarist
 version: !ruby/object:Gem::Version
-  version: 2.12.1
+  version: 2.13.1
 platform: ruby
 authors:
 - Ribose
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-07-23 00:00:00.000000000 Z
+date: 2026-07-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: lutaml-model
@@ -307,10 +307,11 @@ 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
@@ -395,7 +396,8 @@ 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/validation.rb
 - lib/glossarist/validation/asset_index.rb
@@ -438,7 +440,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