P25 — AIEP — Deterministic Cross-Domain Evidence Stitching System
Publication Date: 2026-02-26 Status: Open Source Prior Art Disclosure Licence: Apache License 2.0 Author/Organisation: Phatfella Ltd Schema: AIEP_OS_SPEC_TEMPLATE v1.0.1 — https://aiep.dev/schemas/aiep-os-spec-template/v1.0.1
Field of the Invention
[0001] The disclosure relates to multi-domain admissible determination systems within computing environments.
[0002] More particularly, the disclosure concerns a deterministic cross-domain evidence stitching system for use within an Architected Instruction and Evidence Protocol (AIEP) framework, enabling evidence artefacts spanning multiple domains to be combined into a single admissibility determination without heuristic reconciliation or semantic inference.
Framework Context
[0003] This invention operates within an Architected Instruction and Evidence Protocol (AIEP) environment as defined in United Kingdom patent application number GB2519711.2, filed 20 November 2025, the entire contents of which are incorporated herein by reference.
[0004] The present invention extends deterministic canonicalisation, governance, and execution integrity mechanisms defined in the AIEP environment while remaining independently implementable as described herein.
Background
[0005] Evidence relevant to a single admissibility determination may span multiple domains including financial records, regulatory filings, scientific datasets, identity records, and operational telemetry.
[0006] Existing systems merge cross-domain evidence using heuristic mapping, semantic inference, manual interpretation, and adaptive reconciliation logic. These approaches introduce non-reproducible stitching outcomes, hidden prioritisation rules, ambiguous cross-domain compatibility determinations, and discretionary override behaviour.
[0007] Non-deterministic cross-domain stitching prevents consistent cryptographic binding of composite evidence, breaks audit trails, and produces divergent admissibility outcomes across distributed nodes operating on identical evidence sets.
[0008] Existing systems do not provide:
(a) per-domain canonicalisation of evidence artefacts under domain-specific deterministic rules prior to stitching; (b) version-bound retrieval of stitching rules from an immutable registry without fallback; (c) deterministic compatibility evaluation using explicit field mapping rules and constraint alignment requirements; (d) cryptographic binding of the stitched composite to the stitching rule versions applied; or (e) fail-closed non-admissibility when cross-domain artefacts cannot be aligned deterministically.
[0009] There exists a need for a deterministic cross-domain stitching mechanism that canonicalises artefacts per domain, retrieves versioned stitching rules, evaluates compatibility deterministically, and produces cryptographically bound composite evidence records without heuristic reconciliation.
Summary of the Disclosure
[0011] A computer-implemented deterministic cross-domain evidence stitching method is executed by one or more processors.
[0012] Each evidence artefact is first canonicalised using its respective domain-specific extension framework to produce a DomainCanonicalForm, comprising deterministic field ordering, explicit type normalisation, and registry-bound validation.
[0013] A version-bound StitchingRuleSet is retrieved from an immutable StitchingRegistry using explicit domain identifiers and version references. No alternative rule set is attempted.
[0014] The StitchingRuleSet defines permitted cross-domain linkages, field equivalence mappings, constraint compatibility rules, and required co-attestation conditions.
[0015] Cross-domain compatibility is evaluated deterministically using explicit field mapping rules, deterministic equivalence checks, and defined constraint alignment requirements. Heuristic reconciliation is prohibited.
[0016] A StitchedCompositeHash is computed as:
StitchedCompositeHash = H(DomainCanonicalForm_A || DomainCanonicalForm_B || ... || StitchingRuleSetVersionId || StitchingRegistryVersionId)
[0017] A StitchingRecord is generated binding all DomainIdentifiers, StitchingRuleSetVersionId, StitchingRegistryVersionId, StitchedCompositeHash, compatibility outcome, and a timestamp recorded as data, and appended to an immutable store.
[0018] If artefacts cannot be aligned deterministically, contain incompatible constraints, or violate registry-defined stitching rules, the admissibility state is set to non-admissible and execution is suppressed in a fail-closed manner. No partial stitching is permitted.
[0019] The technical effect is modification of computing system behaviour by enforcing deterministic cross-domain evidence composition without heuristic reconciliation, enabling reproducible composite admissibility determination across distributed nodes.
Brief Description of the Drawings
[0020] Figure 1 illustrates the per-domain canonicalisation pipeline showing independent domain artefact processing prior to stitching.
[0021] Figure 2 illustrates the deterministic stitching invocation pipeline from StitchingRegistry retrieval through compatibility evaluation and fail-closed outcome determination.
[0022] Figure 3 illustrates the StitchingRecord hash binding architecture showing the cryptographic relationship between domain canonical forms, StitchingRuleSetVersionId, and StitchingRegistryVersionId.
[0023] Figure 4 illustrates deterministic replay equivalence across distributed nodes operating under identical domain canonical forms and stitching registry versions.
ASCII Drawings
Figure 1 — Per-Domain Canonicalisation Pipeline
Domain A Artefact Domain B Artefact
+------------------+ +------------------+
| Raw Evidence | | Raw Evidence |
+--------+---------+ +--------+---------+
| |
v v
+--------+---------+ +--------+---------+
| Domain-Specific | | Domain-Specific |
| Extension | | Extension |
| Framework (P24) | | Framework (P24) |
+--------+---------+ +--------+---------+
| |
v v
+--------+---------+ +--------+---------+
| DomainCanonical | | DomainCanonical |
| Form_A | | Form_B |
| - Det. field ord.| | - Det. field ord.|
| - Type normalised| | - Type normalised|
| - Registry valid.| | - Registry valid.|
+--------+---------+ +--------+---------+
| |
+------------+-------------+
|
v
+--------+---------+
| Cross-Domain |
| Stitching |
+------------------+
Figure 2 — Deterministic Stitching Invocation Pipeline
+---------------------------+
| StitchingRegistry |
| Lookup |
| (Domain IDs + |
| Version References) |
+------------+--------------+
|
+------+------+
Found Not Found
| |
v v
+------------------+ +-----------+
| Retrieve | | SUPPRESS |
| StitchingRuleSet | | Execution |
| (Version-Bound) | | Fail- |
+--------+---------+ | Closed |
| +-----------+
v
+--------+---------+
| Compatibility |
| Evaluation |
| - Field mapping |
| - Equivalence |
| checks |
| - Constraint |
| alignment |
| No heuristics |
+--------+---------+
|
+------+------+
Compatible Incompatible
| |
v v
+----------+ +-----------+
| Produce | | NON- |
| Stitched | | ADMISSIBLE|
| Composite| | Fail- |
| Record | | Closed |
+----------+ | No partial|
| stitching |
+-----------+
Figure 3 — StitchingRecord Hash Binding Architecture
DomainCanonicalForm_A ----+
DomainCanonicalForm_B ----+
DomainCanonicalForm_N ----+--> H(Form_A || Form_B || ... ||
/ StitchingRuleSetVersionId ||
StitchingRuleSetVersionId--+ StitchingRegistryVersionId)
StitchingRegistryVersionId-+ |
v
+------------------------------------+
| StitchingRecord |
|------------------------------------|
| DomainIdentifiers (all) |
| StitchingRuleSetVersionId |
| StitchingRegistryVersionId |
| StitchedCompositeHash |
| Compatibility outcome |
| Timestamp (stored data) |
+------------------------------------+
|
v
+------------------------------------+
| Append-Only Immutable Store |
+------------------------------------+
Figure 4 — Deterministic Replay Across Distributed Nodes
Node A Node B
+--------------------+ +--------------------+
| DomainCanonical | | DomainCanonical |
| Forms (identical) | | Forms (identical) |
+---------+----------+ +---------+----------+
| |
v v
+---------+----------+ +---------+----------+
| StitchingRegistry | | StitchingRegistry |
| (identical version)| | (identical version)|
+---------+----------+ +---------+----------+
| |
v v
+---------+----------+ +---------+----------+
| StitchedComposite | | StitchedComposite |
| Hash | | Hash |
+---------+----------+ +---------+----------+
| |
+------------------+----------------+
|
v
+------------------------+
| Hash Equivalence |
| Verification |
| (stored timestamps |
| used — does not |
| depend on current |
| system time) |
+------------------------+
Detailed Description
1. Per-Domain Canonicalisation
[0024] Each evidence artefact is processed independently using its respective domain-specific extension framework as described in P24 — AIEP — Domain-Specific Evidence Extension Framework.
[0025] Canonicalisation produces a DomainCanonicalForm for each artefact, comprising:
(a) deterministic field ordering under domain-specific rules; (b) explicit type normalisation; and (c) registry-bound validation confirming artefact structural integrity.
[0026] DomainCanonicalForm outputs are deterministic and version-bound. Identical artefacts processed under identical domain extension versions produce identical DomainCanonicalForm outputs across distributed nodes.
2. Versioned StitchingRegistry
[0027] A StitchingRegistry defines for each permitted cross-domain combination:
(a) permitted cross-domain linkages between named domain pairs; (b) field equivalence mappings defining which fields across domains are semantically equivalent for stitching purposes; (c) constraint compatibility rules governing which domain constraints must be mutually consistent; and (d) required co-attestation conditions specifying which domain artefacts must be jointly present for admissibility.
[0028] StitchingRegistry entries are versioned and immutable once published. New stitching requirements are addressed by publishing new registry versions.
3. Deterministic Stitching Invocation
[0029] The system retrieves the applicable StitchingRuleSet from the StitchingRegistry using explicit domain identifiers and version references.
[0030] No alternative rule set, fallback stitching logic, or approximate matching is attempted.
[0031] If the required StitchingRuleSet is not available in the registry, processing is denied in a fail-closed manner.
4. Compatibility Evaluation
[0032] Cross-domain compatibility is evaluated by applying the retrieved StitchingRuleSet to the set of DomainCanonicalForms.
[0033] Evaluation applies:
(a) explicit field mapping rules to verify that declared equivalent fields hold consistent values; (b) deterministic equivalence checks confirming structural alignment; and (c) defined constraint alignment requirements confirming that domain-specific constraints are mutually compatible.
[0034] Heuristic reconciliation, semantic inference, and discretionary override are prohibited at all stages of compatibility evaluation.
5. Hash Binding and StitchingRecord Generation
[0035] A StitchedCompositeHash is computed as:
StitchedCompositeHash = H(DomainCanonicalForm_A || DomainCanonicalForm_B || ... || StitchingRuleSetVersionId || StitchingRegistryVersionId)
[0036] Inclusion of all DomainCanonicalForms and both version identifiers ensures that the composite hash is uniquely bound to the specific artefacts and stitching rules applied.
[0037] A StitchingRecord is generated comprising:
(a) all DomainIdentifiers included in the stitching operation; (b) StitchingRuleSetVersionId; (c) StitchingRegistryVersionId; (d) StitchedCompositeHash; (e) compatibility outcome; and (f) timestamp recorded as a data field.
[0038] The StitchingRecord is appended to an append-only immutable store.
6. Fail-Closed Admissibility Enforcement
[0039] If artefacts cannot be aligned deterministically, contain incompatible constraints, or violate registry-defined stitching rules, the admissibility state is set to non-admissible.
[0040] Execution of any downstream operation dependent on the stitched composite is suppressed in a fail-closed manner.
[0041] No partial stitching is permitted. A stitching operation either succeeds completely under declared rules or results in non-admissibility.
[0042] A deterministic rejection record is appended identifying the incompatible constraint, the StitchingRuleSetVersionId, and the domain pair at which failure occurred.
7. Deterministic Replay
[0043] Replay is performed using stored DomainCanonicalForms, StitchingRuleSetVersionId, and StitchingRegistryVersionId.
[0044] Replay recomputes StitchedCompositeHash using stored fields and does not depend on current system time.
[0045] Distributed nodes operating with identical DomainCanonicalForms and identical StitchingRegistry versions produce identical compatibility outcomes and identical StitchedCompositeHash values.
Claims
-
A computer-implemented method for deterministic cross-domain evidence stitching, the method comprising: (a) canonicalising each evidence artefact using its respective domain-specific extension framework to produce a DomainCanonicalForm, comprising deterministic field ordering, explicit type normalisation, and registry-bound validation; (b) retrieving a version-bound StitchingRuleSet from an immutable StitchingRegistry using explicit domain identifiers and version references, without fallback or alternative rule set; (c) evaluating cross-domain compatibility by applying the StitchingRuleSet to the set of DomainCanonicalForms using explicit field mapping rules, deterministic equivalence checks, and constraint alignment requirements, without heuristic reconciliation or semantic inference; (d) computing a StitchedCompositeHash as H(DomainCanonicalForm_A || DomainCanonicalForm_B || … || StitchingRuleSetVersionId || StitchingRegistryVersionId); (e) generating a StitchingRecord binding all DomainIdentifiers, StitchingRuleSetVersionId, StitchingRegistryVersionId, StitchedCompositeHash, compatibility outcome, and a timestamp recorded as data, and appending it to an immutable store; and (f) upon detection that artefacts cannot be aligned deterministically, contain incompatible constraints, or violate registry-defined stitching rules, setting admissibility state to non-admissible and suppressing execution in a fail-closed manner without partial stitching.
-
The method of claim 1 wherein StitchingRegistry entries are versioned and immutable once published.
-
The method of claim 1 wherein required co-attestation conditions defined in the StitchingRuleSet must be satisfied for admissibility.
-
The method of claim 1 wherein a deterministic rejection record identifying the incompatible constraint, StitchingRuleSetVersionId, and failing domain pair is appended to the immutable store upon admissibility failure.
-
The method of claim 1 wherein replay recomputes StitchedCompositeHash using stored fields and does not depend on current system time.
-
The method of claim 1 wherein distributed nodes operating with identical DomainCanonicalForms and identical StitchingRegistry versions produce identical compatibility outcomes and identical StitchedCompositeHash values.
-
A computing system comprising one or more processors and memory storing instructions which, when executed, cause the processors to perform the method of any of claims 1 to 6.
-
A non-transitory computer-readable medium storing instructions which, when executed, cause one or more processors to perform the method of any of claims 1 to 6.
Licence
Any person is granted a perpetual, irrevocable, worldwide, royalty-free licence to make, use, implement, modify, or distribute any system or method described in this disclosure for any purpose, without restriction, under the Apache License 2.0.
A copy of the Apache License 2.0 is available at https://www.apache.org/licenses/LICENSE-2.0
Abstract
A deterministic cross-domain evidence stitching system is disclosed. Evidence artefacts are independently canonicalised per domain using domain-specific extension frameworks to produce DomainCanonicalForms. A version-bound StitchingRuleSet is retrieved from an immutable StitchingRegistry without fallback. Cross-domain compatibility is evaluated using explicit field mapping rules, deterministic equivalence checks, and constraint alignment requirements without heuristic reconciliation. A StitchedCompositeHash is computed as H(DomainCanonicalForm_A || DomainCanonicalForm_B || … || StitchingRuleSetVersionId || StitchingRegistryVersionId) and a StitchingRecord is appended to an immutable store. If artefacts cannot be aligned deterministically or violate stitching rules, admissibility is set to non-admissible and execution is suppressed in a fail-closed manner without partial stitching. Replay uses stored fields and does not depend on current system time.