Petri graph neural networks: a unified framework for higher-order multimodal learning

The Petri Graph Neural Network (PGNN) architecture addresses the limitations of existing networks by implementing a unified place-to-transition-to-place computational primitive with separate pre-/post-incidence relationships, enabling efficient and effective structured-data processing through sparse incidence pathways.

WO2026239353A1PCT designated stage Publication Date: 2026-11-19ADEMOVIC-TAHIROVIC ALMA
View PDF 0 Cites 0 Cited by

Patent Information

Application Number
PCT/IB2026/054862
Authority / Receiving Office
WO · WO
Patent Type
Applications
Current Assignee / Owner
Priority Date
2025-05-14
Filing Date
2026-05-15
Publication Date
2026-11-19

AI Technical Summary

Technical Problem

Existing graph neural networks and message-passing neural networks fail to effectively represent complex processes using higher-order or typed relationships, lacking a unified place-to-transition-to-place computational primitive that integrates multi-input/multi-output transition computations with separate pre-/post-incidence relationships and conservation-aware constraints.

Method used

A Petri Graph Neural Network (PGNN) architecture that implements a place-to-transition-to-place neural computation using incidence-mediated bipartite representations, with separate pre- and post-incidence relationships for input and output couplings, enabling multi-input/multi-output transition computations and conservation-aware constraints.

Benefits of technology

The PGNN architecture facilitates efficient and effective structured-data processing by replacing pairwise edge expansion and dense attention operations, supporting higher-order relational inference and multimodal transformations with sparse incidence pathways.

✦ Generated by Eureka AI based on patent content.

Smart Images

  • Figure IB2026054862_19112026_PF_FP_ABST
    Figure IB2026054862_19112026_PF_FP_ABST
Patent Text Reader

Abstract

A computer-implemented machine-learning architecture processes structured input data using an incidence-driven Petri message-passing layer. The layer represents the data using a bipartite computational representation comprising place nodes, transition nodes, pre-incidence relationships coupling input place nodes to transition nodes, and post-incidence relationships coupling transition nodes to output place nodes. In operation, input place-node states are coupled to transition-node computations according to pre-incidence relationships, transition-node messages are computed by one or more transition processors, and the transition-node messages are routed to output place nodes according to post-incidence relationships to update place-node state representations. The architecture may use learned, stored, sparse, parameterized, generated, implicit, attention-derived, or other incidence relationships, including multi-head transition relationships, and may enforce conservation, flow-balance, semantic-conversion, sparsity, invariant, or other constraints. The architecture supports directional, pairwise, higher-order, multimodal, temporal, heterogeneous, concurrent, attention-based, flow-constrained, or other structured-data processing implementations.
Need to check novelty before this filing date? Find Prior Art

Description

[0001] Petri Graph Neural Networks: A Unified Framework for Higher-Order Multimodal Learning

[0002] Applicant / Inventor: Alma Ademovic-Tahirovic

[0003] Priority Claim. This application claims the benefit of and priority to U. S. Provisional Patent Application No. 63 / 805,717, filed May 14, 2025, entitled “Petri Graph Neural Networks: A Unified Framework for Higher-Order Multimodal Learning,” the entire contents of which are incorporated herein by reference to the extent permitted by applicable law.

[0004] 1 Technical Field

[0005] The present disclosure relates to machine learning, artificial intelligence, neural- network architectures, and computer-implemented structured-data processing. More particularly, the disclosure relates to systems and methods for representation learning and relational computation using bipartite place-transition representations with pre-incidence and postincidence relationships. Certain embodiments relate to Petri-net-based message-passing architectures, training methods, data structures, transformer- or attention-compatible variants, and reusable message-passing blocks for graph, hypergraph, heterogeneous, multimodal, temporal, higher-order, concurrent, or flow-constrained data.

[0006] 2 Background

[0007] Computer-implemented machine-learning systems frequently operate on relational or structured data, including graphs, hypergraphs, heterogeneous graphs, multilayer networks, temporal networks, event logs, knowledge representations, token sequences, flow networks, sensor streams, and multimodal records. Existing graph neural networks and messagepassing neural networks typically exchange messages over pairwise edges between nodes. Hypergraph and heterogeneous graph models extend that representation to certain higher-order or typed relationships, and transformer-based models compute attention- weighted interactions among tokens or graph elements. These approaches are useful, but they often represent complex processes using pairwise edges, hyperedges, tokenization, or dense attention scores rather than a unified place-to-transition-to-place computational primitive.

[0008] Background technologies useful for understanding the present disclosure include messagepassing neural networks, graph networks or relational-computation blocks, hypergraph neural networks, graph attention networks, transformer-based neural networks, Petri-net models, and heterogeneous-network-flow representations. Such technologies provide useful context for structured-data learning and flow-based modeling, but they do not disclose the incidence-mediated place-to-transition-to-place neural computation architecture described herein, including learnable transition process nodes with separately represented pre-incidence input participation and post-incidence output routing.

[0009] Many structured-data domains involve relationships that are more naturally described as processes or transformations. A process may receive state information from multiple entities, transform that information, and output a message or state update to one or more other entities. Such processes may be directional, typed, weighted, concurrent, multimodal, or subject to conservation, balance, semantic-conversion, or invariant constraints. Conventional graph, hypergraph, and attention architectures do not generally provide a single differentiable architecture integrating multi-input / multi-output transition computations, separate pre- / post-incidence relationships, neural message generation, aggregation, update, readout, directionality, conservation-aware constraints, and structure learning.

[0010] Petri nets provide a formal structure for representing places, transitions, incidence relationships, causality, concurrency, and flow. Conventional Petri-net systems, however, are not generally configured as trainable neural-network layers for representation learning, prediction, classification, forecasting, control, or other machine-learning tasks. There remains a need for computer-implemented systems, methods, storage media, data structures, and reusable neural-network blocks that combine Petri-net-style incidence structure with differentiable message passing and task-specific learning.

[0011] 3 Summary

[0012] The disclosed embodiments provide computer-implemented systems, methods, non-transitory computer-readable media, neural- network components, and data structures implementing a Petri Graph Neural Network (PGNN) architecture for processing structured input data using an incidence- driven Petri-net-based bipartite computational representation. The representation comprises place nodes, transition nodes, pre-incidence relationships defining input-side couplings from place nodes to respective transition nodes, and postincidence relationships defining output-side couplings from respective transition nodes to place nodes. In operation, neural messages are computed at transition nodes from input place-node states and propagated to output place nodes according to the incidence relationships. As used herein, a Petri transition layer or Petri message-passing layer denotes an incidence-mediated place-to-transition-to-place neural computation in which selected place-node states are processed at fixed or learnable transition process nodes and routed to output place nodes through post-incidence relationships.

[0013] The embodiments described herein are unified by a common technical architecture: an incidence-mediated neural computation framework in which place-node state representations are selected or weighted by fixed or learnable pre-incidence relationships, processed by fixed or learnable transition-node computations, and routed by fixed or learnable postincidence relationships to update place-node state representations or generate outputs. System, method, computer-readable medium, component, data-structure, graph-compatible, hypergraph-compatible, transformer-compatible, sparse-routing, learned-incidence, multihead, and constraint-aware embodiments are implementations, restricted configurations, or operational variants of the same place-to-transition-to-place computational primitive.

[0014] A canonical Petri message-passing primitive may be stated as follows: a neural layer selects input place-node states according to pre-incidence relationships, computes transitionnode messages at transition nodes, and routes the transition-node messages to output place nodes according to post-incidence relationships. In this manner, the primitive defines a reusable place-to-transition-to-place neural computation for structured flow, relational inference, and higher-order message passing.

[0015] In one aspect, the disclosed architecture provides a reusable Petri message-passing layer, also referred to as a place-transition-place block, P-T-P block, or Petri transition attention block. The layer includes an incidence selector, a transition processor, an incidence router, and a place updater. The incidence selector selects or weights input place-node states according to pre-incidence relationships. The transition processor applies a fixed or learnable function to compute transition- node messages or transition-node states. The incidence router routes the transition-node messages according to post-incidence relationships. The place updater aggregates routed transition messages and updates place-node state representations.

[0016] A compact form of the layer is expressed by computing transition states from selectedplace states and routing those transition states back to places. In representative tensor form, HT= Φ(ATpreWEHP) and HP' = Ψ(HP, ApostHT), where Hp denotes place-node states, WE denotes a place-to-place adjacency, flow-rate, or message-weight operator, Apredenotes a pre-incidence selector, $ denotes a transition processor, HTdenotes transition-node states or messages, Apostdenotes a post-incidence router, and T denotes a place updater. The operators WE, Apre, and Apostmay be independently fixed, learned, regularized, constrained, sparse, dense, or parameterized. This tensor expression is one representative instantiation of the incidence-mediated P-T-P primitive, and other embodiments may apply pre-incidence selection, transition-message computation, post-incidence routing, aggregation, update, constraint enforcement, or readout in different orders or parameterizations while retaining the same place-to-transition-to-place computational structure.

[0017] The disclosed architecture is not limited to transformer or attention-based implementations. The P-T-P block may operate independently for structured-flow computation and may replace, augment, or interface with graph neural-network messagepassing layers, hypergraph convolution layers, factor-graph update layers, transformer attention heads, multimodal fusion layers, temporal message-passing layers, or other structured-data processing blocks. Unlike pairwise edge message passing or dense tokenpair attention, the layer separates input participation from output propagation through pre-incidence and post-incidence relationships, enabling multi-input / multi-output transition computation without reducing each relationship to pairwise edges or dense all-pairs scores. As consequences of the same primitive, higher-order algebraic-topology structures, including directed or multimodal hypergraph, simplicial, cellular, or chain-complex relationships, may be mapped into a sparse bipartite place-transition form supporting directional flow, semantic conversion, n-ary regulation, and resource-aware execution.

[0018] In some embodiments, the Petri message-passing layer comprises multiple transition heads. Each transition head may have a respective pre-incidence representation, postincidence representation, transition processor, transition type, semantic type, mask, or parameter set. Outputs of the transition heads may be concatenated, summed, averaged, gated, normalized, pooled, projected, or otherwise combined to update place-node state representations. Multi-head transition processing allows different relationship types, semantic channels, modalities, time scales, or attention patterns to be learned within a common place-to-transition-to-place layer.

[0019] In some embodiments, pre-incidence and / or post-incidence relationships are learned, stored, inferred, attention-derived, normalized, sparse, dense, implicit, parameterized, or otherwise derived. Learnable incidence-attention weights may be generated from placetransition compatibility scores based on place-node and transition-node representations and may be normalized, selected, or otherwise processed using softmax, sparsemax, sigmoid gating, top-k selection, masking, differentiable sampling, other normalization or selection operations, or any combination thereof. In some embodiments, token, node, edge, query, key, or value representations may be represented as place-node state representations, with transition nodes computing attention-mediated messages.

[0020] The disclosed PGNN architecture also provides a generalized incidence-mediated relational computation model. The architecture is not defined as an improvement to a transformer, a graph neural network, a hypergraph neural network, or a graphnetwork relational block. Instead, in some embodiments, operations corresponding to graph-network relational blocks, graph neural-network message passing, hypergraph neuraloperations, or transformer attention mechanisms may be represented, augmented, or implemented as restricted configurations of the same incidence-driven place-to-transition-to-place computation. In one representational interpretation, transformer attention may be viewed as a restricted dense token-pair incidence configuration; graph-network relational blocks may be viewed as restricted edge-node-global transition-routing configurations; graph neural-network message passing may be viewed as a restricted adjacency-driven transition configuration; and hypergraph neural operations may be viewed as restricted participationset transition configurations. The disclosed PGNN architecture provides a more general process-node, incidence-mediated, constraint-aware computation model. This interpretation illustrates representational relationships and does not limit PGNN to transformer, graphnetwork, graph-neural-network, or hypergraph-neural-network implementations.

[0021] In optional transformer-compatible embodiments, the Petri message-passing layer may represent, augment, or implement certain attention-based neural computations as restricted or specialized instances of the same incidence- driven place-to-transition-to-place computation. Rather than defining the invention by reference to transformers, these embodiments use the disclosed Petri-net-based structure in which one or more transition nodes receive selected input place-node states according to pre-incidence relationships, compute transition- node messages using learned transition processors, and route the transition-node messages to output place nodes according to post-incidence relationships. The pre-incidence relationships, post-incidence relationships, or both may be learned, stored, sparse, masked, attention-derived, or generated from compatibility scores. Accordingly, a transformer attention head, graph-attention operation, token-interaction operation, or other attention-based computation may be represented, augmented, or implemented without limiting the disclosed architecture to transformer or attention-based implementations.

[0022] In various embodiments, learned incidence routing, attention-style incidence weighting, multi-head transition processing, sparse routing, top-k selection, tensor-based layer implementations, benchmarking outputs, and implementation artifacts are implementations, evaluation forms, or supporting forms of the same incidence- driven place-to-transition-to-place computation and need not alter the underlying Petri-net-based representation. These variations share a common structure: place-node state representations, transition-node computations, pre-incidence relationships identifying or weighting input place nodes for transition nodes, post-incidence relationships identifying or weighting output place nodes for transition nodes, and propagation of transition-derived messages from input place nodes through transition nodes to output place nodes.

[0023] In some embodiments, the system enforces, approximates, evaluates, or regularizes conservation, flow-balance, mass-balance, information-balance, semantic-conversion, semantic-consistency, sparsity, P-invariant, T-invariant, or other algebraic- invariant constraints using loss penalties, projections, normalization, constrained optimization, Lagrange multipliers, masks, residual corrections, invariant-preserving parameterizations, post-update balancing, or combinations thereof.

[0024] The disclosed architecture improves structured-data processing by replacing or reducing reliance on pairwise edge expansion, repeated dense token-pair attention operations, or separate domain-specific encodings. In some embodiments, computation is implemented over selected nonzero place-to-transition-to-place incidence pathways using sparse incidence matrices, sparse tensors, incidence lists, learned incidence functions, batched transition-node computation, or parallel scheduling of independent transition nodes.

[0025] In some embodiments, the system is implemented as a reusable software or hardware-accelerated layer with defined inputs, outputs, parameters, traces, and evaluation outputs. The layer may receive place-state tensors, pre- / post-incidence representations, transition parameters, masks, semantic-type indicators, and optional constraint specifications, and may output updated place states, transition states, learned incidence weights, constraintviolation, sparsity, runtime, memory-use, or prediction measures, or other evaluation artifacts. Such artifacts may compare the disclosed layer with graph neural-network, hypergraph neural-network, graph-network, dense-attention, factor-graph, ablated, or other structured-data processing layers.

[0026] The same technical structure may be embodied as a system, method, computer-readable medium, reusable neural-network component, computer-readable data structure, structure-learning mechanism, benchmarked layer, reference implementation, graph-network-compatible implementation, attention-compatible implementation, or other implementation form, while retaining incidence-driven place-to-transition-to-place neural computation. Transformer-compatible, graph-network-compatible, graph-neural-network-compatible, and hypergraph-compatible embodiments are examples of this broader Petri-net-based computation and do not limit the independent scope of the PGNN architecture.

[0027] 4 Brief Description of the Drawings

[0028] The accompanying drawings, which may be appended as separate drawing sheets, illustrate representative embodiments and do not limit the claims.

[0029] Figure 1 illustrates a representative Petri transition layer implementing incidence-mediated place-to-transition-to-place neural computation.

[0030] Figure 2 illustrates multi-head Petri transition attention in which transition heads operate in parallel and are combined to update place-node states.

[0031] Figure 3 illustrates learned incidence routing using compatibility scores between placenode and transition-node representations.

[0032] Figure 4 compares pairwise graph neural- network message passing, hypergraph message passing, dense transformer attention, and Petri message passing.

[0033] Figure 5 illustrates representative graph, hypergraph, and Petri-net-based bipartite computational representations.

[0034] Figure 6 illustrates restricted configurations of the disclosed P-T-P computation for transformer attention, graph- network relational blocks, graph neural-network message passing, and hypergraph neural operations.

[0035] Figure 7 illustrates (c)-(f) heterogeneous flow network representation and transformation into (b) Petri-net formalism, including (a) multilayer network, and (g)-(h) cross-domain relationships, such as triadic network correspondence.

[0036] Figure 8 illustrates the PGNN operational pipeline, including (a)-(b) PGNN algorithm, multimodal message passing, aggregation, update, and readout, (c) graph, (d)-(e) PGNN, and (f) graph transformer correspondence.

[0037] Figure 9 illustrates stock-market opening / closing price prediction results using GNN and PGNN models, including performance metrics.

[0038] Figure 10 illustrates an example of PGNN-based encoding of triadic neuronal-glial interactions in functional brain networks.

[0039] 5 Detailed Description

[0040] The following description provides representative embodiments of the disclosed technology. The embodiments are illustrative and do not limit the scope of the claims. The disclosed architecture may be implemented in software, firmware, hardware, cloud systems, edge systems, accelerator hardware, other computing environments, or combinations thereof.

[0041] 5.1 Petri-net-based bipartite representation

[0042] The disclosed system receives input data representing a structured relationship domain. The input data may include entities, features, tokens, events, time series, sensor streams, graph structures, hypergraph structures, multimodal records, temporal records, or other structured information. The system generates, accesses, determines, or otherwise obtains, a Petri-netbased bipartite computational representation comprising place nodes and transition nodes.

[0043] Place nodes may represent states, entities, features, variables, resources, tokens, measurements, regions, observations, semantic objects, or other state-bearing elements. Transition nodes may represent interactions, transformations, processes, relation instances, flow conversions, attention-mediated computations, events, or other message-generating operations. A transition node may be connected to one input place node, multiple input place nodes, one output place node, multiple output place nodes, or combinations thereof, thereby supporting pairwise, higher-order, multi-input, and multi-output relationships.

[0044] In some embodiments, higher-order algebraic-topology structures, including simplicial complexes, cell complexes, chain complexes, directed hypergraphs, multilayer complexes, or other higher-order structures, are mapped into the same sparse bipartite place-transition representation. In this manner, higher-order relational or algebraic-topology objects may be re-expressed as sparse incidence-mediated place-to-transition-to-place pathways, facilitating tensor, sparse-matrix, batched, or parallel computation without reducing each relationship to pairwise edges or dense all-pairs attention. A simplex, cell, hyperedge, boundary or coboundary relation, or higher-order interaction may be represented by one or more transition nodes coupled to participating place nodes through pre-incidence and postincidence relationships. This representation preserves directionality, multimodal typing, semantic conversion, and multi-body participation, while treating triadic regulation as a special case of n-ary regulatory, catalytic, modulatory, control, or other interaction forms. Incidence relationships, transition processors, routing operators, firing gates, or transition schedules may be selected, learned, pruned, quantized, constrained, or executed according to memory, latency, energy, bandwidth, processor availability, or accuracy criteria. These higher-order, beyond-triadic, and resource-aware capabilities arise as consequences of the common incidence-mediated P-T-P architecture rather than separate architectural requirements.

[0045] The incidence relationships may be represented as matrices, tensors, masks, functions, learned parameters, normalized weights, sparse data structures, incidence lists, relational tables, parameterized mappings, or other incidence representations. Unless otherwise indicated, Pre(p,t) indicates whether and how a place node p contributes to a transition node t, and Post(p, t) indicates whether and how a transition message from transition node t contributes to a place node p; equivalently, implementations may store the postincidence relationship as

[0046]

[0047] or as a transposed matrix representation. The preincidence relationships and post-incidence relationships are directional structures: preincidence relationships identify input-side participation of place-node states in transition-node computations, whereas post-incidence relationships identify output-side routing of transition-derived messages to place-node states. The disclosed Petri message-passing layer is not limited to symmetric, undirected, or pairwise adjacency-based propagation.

[0048] The same incidence-driven message-passing structure may be embodied as a complete learning system, a method, a computer-readable medium storing executable instructions, a reusable neural-network component, a stored data structure, or another implementation form. In each case, the operative computation uses pre-incidence relationships to select or weight input place-node states, transition-node functions to compute messages, and postincidence relationships to route messages to output place-node states.

[0049] The embodiments described herein, including learned incidence routing, attentionbased incidence weighting, multi-head transition processing, sparse or top-k incidence selection, tensor-based layer implementations, benchmarking outputs, implementation traces, reference-implementation artifacts, evaluation artifacts, and other implementation or evaluation forms, are alternative or additional implementations, configurations, or outputs of the same underlying Petri-net-based place-to-transition-to-place neural message-passing architecture. Unless expressly stated otherwise, such embodiments share a common technical structure comprising place-node state representations, transition-node computations, preincidence relationships identifying or weighting input place nodes for transition nodes, postincidence relationships identifying or weighting output place nodes for transition nodes, and propagation of transition-derived messages from input place nodes through transition nodes to output place nodes. Accordingly, such embodiments are not separate technical concepts, but different ways of implementing, parameterizing, accelerating, evaluating, or training the same incidence- driven bipartite computational architecture.

[0050] 5.2 Petri message- passing layer

[0051] As used herein, a Petri transition layer, Petri message-passing layer, place-transition-place block, P-T-P block, or Petri transition attention block refers to an incidence-mediated place-to-transition-to-place neural computation that selects input place-node state representations according to fixed or learnable pre-incidence relationships, computes transition-node messages at fixed or learnable transition process nodes, and routes the transition-node messages to output place nodes according to fixed or learnable post-incidence relationships. The same core primitive may be embodied or exposed as a neural-network layer, softwarelibrary operator, graph-processing kernel, sparse-tensor operation, accelerator-executable kernel, routing mechanism, relational-computation block, attention-augmentation module, multimodal-fusion block, constraint-enforcement component, structured-data processing component, or another implementation form.

[0052] A representative embodiment is a reusable Petri message-passing layer, also referred to as a place-transition-place block or P-T-P block. The P-T-P block includes four functional parts: an incidence selector, a transition processor, an incidence router, and a place updater. The incidence selector selects or weights input place-node states according to pre-incidence relationships. The transition processor computes transition-node messages using one or more fixed or learnable functions, optionally including a transition-message or flow-rate operator. The incidence router routes transition-node messages to output place nodes according to post-incidence relationships. The place updater aggregates routed messages and updates place-node state representations.

[0053] In a compact reference implementation, the layer may be expressed without loss ofgenerality as:

[0054] Input: H_P, W_E, A_pre, A_post

[0055] X_P = W_E H_P

[0056] X_T = A_pre~T X_P

[0057] H_T = Transitionprocessor (X_T)

[0058] M_P = A_post H_T

[0059] H_P’ = PlaceUpdater (H_P, M_P)

[0060] Output: H_P ’

[0061] Here, HPdenotes place-node state representations, W denotes a place-to-place adjacency, flow-rate, or message-weight operator, Apredenotes a pre-incidence selector, Apostdenotes a post-incidence router, HTdenotes transition-node states or messages, and Hp' denotes updated place-node states. This reference form is illustrative; the message-weight operator, selector, processor, router, or updater may be sparse, dense, learned, masked, typed, normalized, gated, constrained, batched, accelerator-executed, or otherwise configured.

[0062] In one representative instantiation, the layer may be illustrated as:

[0063]

[0064] The illustrated ordering is non-limiting; other embodiments may combine, reorder, omit, or separately parameterize the message-weight operator, pre-incidence selector, transition processor, post-incidence router, aggregation, or place updater while retaining the same incidence-mediated P-T-P structure. The layer provides a neural-network primitive for transition-mediated relational computation. The layer computes transition-node states from selected input place states and routes them to output place states. In some embodiments, the primitive is referred to as Petri transition attention because learned incidence relationships determine input participation and output routing.

[0065] The layer may operate standalone or be stacked with other neural-network layers. Its independent operation is the incidence- driven place-to-transition-to-place computation described herein. In optional integrations, the layer may replace, augment, or interface with a graph neural-network layer, graph-network block, hypergraph convolution layer, transformer attention head, multimodal fusion layer, factor-graph update layer, recurrent layer, readout layer, graph-library operator, model-serving API, accelerator kernel, sparse-tensor operator, or other component or implementation form. One representative software interface is:

[0066] H_out = PetriLayer(H_place, W_E, A_pre, A_post,

[0067] transition_fn, update_fn,

[0068] constraint_fn=None, heads=K, sparse=True)

[0069] where H_place denotes place-node states, W_E denotes place-to-place adjacency, flow-rate, or message-weight relationships, A pre and A post denote incidence relationships, transition_fn and update_fn denote transition and place-update functions, constraint_fn denotes conservation, flow-balance, regularization, or other constraint logic, heads denotes transition-head groups, and sparse denotes sparse or implicit execution.5.3 Incidence-driven message passing

[0070] In a representative message-passing iteration, the system performs place-to-transition propagation, transition-node computation, transition-to-place propagation, aggregation, update, and readout operations. State information associated with input place nodes is collected according to the pre-incidence relationships. A transition message is computed at a transition node using a learnable transformation. The transition message is propagated to output place nodes according to the post-incidence relationships. Each output place node aggregates received transition messages and updates its place-node state representation.

[0071] The canonical operation may be summarized as

[0072]

[0073] where HPis a place-node state matrix, WEis a place-to-place adjacency, flow-rate, or message-weight operator, Apreis a pre-incidence selector or weighting representation, Φ is a transition processor, HTis a transition-node state or message matrix, Apostis a post-incidence router, and T is a place updater. The operators WE, Apre, and Apostmay be independently fixed, learned, regularized, constrained, sparse, dense, or parameterized. This expression is representative; transition processing may condition on post-incidence or outputside context, and embodiments may apply operations in different orders or parameterizations while retaining the P-T-P structure.

[0074] In a linear sum-aggregation special case,

[0075] M = ApTreWEHP, HP’ = CPM, Y = RVHP', CP= Apost- Apre, (3) where M denotes transition or flow messages, CPa Petri-net conversion / coupling operator, and Ry a readout map. A compatible WM may implement ApreWEor another place-to-transition-message map. This collapsed form may be used when linear transition computation and sum aggregation suffice; other embodiments may apply Apre, WE, Apost, aggregation, update, or readout separately.

[0076] In another non-limiting node-wise form,

[0077]

[0078] where hpand h̃pdenote place-node and message-weighted place representations, H̃Pre(t)and HPost(t)denote input-side and optional output-side context, zta transition-node state or message, mt→pa routed transition-to-place message, Φta transition function,

[0079]

[0080] an update function, and ρ a readout function. These functions may be neural- network layers, multilayer perceptrons, attention mechanisms, recurrent or gated units, transformer blocks, convolutional operators, normalization layers, or combinations thereof.

[0081] The following pseudocode illustrates one possible message-passing iteration:

[0082] Input: H_P, W_E, transitions T, pre-incidence Pre, post-incidence Post H_weighted <- W_E H_P

[0083] For each t in T:

[0084] X_t <- collect H_weighted [p] where Pre [p,t] indicates participation

[0085] z_t <- Phi_t(X_t, Pre[:,t], W_E, theta_t)

[0086] For each p in P:

[0087] M_p <- aggregate { Post [p,t] * z_t: Post [p,t] indicates routing } H’_P[p] <- Psi_p(H_P [p], M_p)

[0088] Output: y <- rho({H’ _P [p] })

[0089] The system may execute transitions sequentially, concurrently, asynchronously, or in batches. Independent transition-node computations may be scheduled in parallel because transition messages are computed locally according to incidence relationships.

[0090] 5.4 Tensor and sparse-matrix implementation

[0091] In some embodiments, the P-T-P block is a tensor layer. Let HP(ℓ)denote layer-ℓ place states, WE(ℓ)a place-to-place adjacency, flow-rate, or message-weight operator, Apre(ℓ)a pre-incidence matrix or tensor, and Apost(ℓ)a post-incidence matrix or tensor. One implementation is

[0092]

[0093] where Ep denotes optional transition features, type / time / relation embeddings, capacity values, firing gates, learned transition parameters, or other transition-side information. The message-weight and incidence operators may be dense, sparse, block-sparse, learned, masked, generated on demand, implicit, parameterized, or otherwise derived. This form supports batched accelerator execution and can avoid dense all-pairs attention or pairwise edge expansion where sparse incidence relationships suffice.

[0094] Representative tensor shapes include HP∈ ℝN×dfor NPplace nodes and feature dimension d, WE∈ ℝN×Nor a place-message operator, Apre∈ ℝN×Nfor NTtransition nodes, HT∈ ℝN×d', and Apost∈ ℝN×Nor a transposed representation, depending on convention. Sparse implementations may use coordinate lists, compressed sparse row / column structures, edge-index tensors, learned generators, or masked attention-score tensors.

[0095] In sparse embodiments, the disclosed pre-incidence and post-incidence representations permit message computation over selected place-to-transition-to-place pathways rather than over all dense pairwise token-to-token or node-to-node interactions. For a structured domain having NPplace nodes and NTtransition nodes, computation may be scheduled according to nonzero entries of Apreand Apost, or according to generated incidence entries, rather than according to all NP2pairwise interactions. This may reduce memory use, enable sparse tensor execution, improve batching of transition-node computations, and permit independent transition processors to be evaluated concurrently or in parallel.

[0096] 5.5 Restricted configurations of existing relational-computation layers

[0097] The disclosed PGNN architecture is independently defined by the incidence-driven place-to-transition-to-place structure described above. It is not defined as an improvement of a transformer, graph neural network, hypergraph neural network, or graph-network relational block. Rather, in some embodiments, operations corresponding to those architectures may be represented, augmented, or implemented as restricted configurations when their state representations, relation computations, and routing operations are expressed using place-node states, transition-node computations, pre- incidence relationships, and post-incidence relationships. In one representational interpretation, transformer attention may be viewed as a restricted dense token-pair incidence configuration; graphnetwork relational blocks may be viewed as restricted edge-node-global transition-routing configurations; graph neural-network message passing may be viewed as a restricted adjacency-driven transition configuration; and hypergraph neural operations may be viewed as restricted participation-set transition configurations. PGNN provides the more general process-node, incidence-mediated, constraint- aware computation model. This interpretation illustrates representational relationships and does not limit the disclosed PGNN architecture to transformer, graph-network, graph-neural-network, or hypergraph-neural-network implementations.

[0098] For example, in a restricted graph-network configuration, place-node states may represent node, edge, relation, or global states; transition nodes may represent edge, relation, or graphblock computations; pre-incidence relationships may identify source, receiver, edge, relation, or global inputs; and post-incidence relationships may route transition-derived messages to update targets. In a restricted graph neural-network configuration, transition nodes may correspond to pairwise source-target relations and incidence relationships may correspond to adjacency, edge-index, neighborhood, or message-passing connectivity. In a restricted hypergraph configuration, transition nodes may correspond to hyperedges or higher-order participation sets while retaining separate input-side and output-side incidence relationships.

[0099] In a restricted transformer-attention configuration, token-associated representations may be represented as place-node states; transition nodes may represent interaction computations, attention heads, or token-interaction slots; pre-incidence relationships may be generated from query-key compatibility scores, attention masks, learned incidence-attention weights, or other compatibility functions; transition messages may be generated based at least in part on value-vector or transformed-value representations; and post-incidence relationships may route transition-derived messages to token-associated place nodes.

[0100] The general PGNN configuration is broader than these restricted configurations. A transition node need not correspond to a graph edge, hyperedge, or token-pair attention interaction, and may instead operate as a learnable process-computation site having independently defined pre-incidence and post-incidence structures, multi-input and multioutput routing, typed or semantic conversion, constraint regularization, sparse or learned incidence, and concurrent transition execution. Figure 6 illustrates representative restricted configurations sharing the disclosed P-T-P incidence structure. The restricted configurations are illustrative and do not limit the independent PGNN architecture.

[0101] 5.6 Incidence-derived attention and transformer-compatible embodiments

[0102] The disclosed PGNN architecture is independently defined by the Petri-net-based P-T-P structure described above; transformer-compatible embodiments are optional embodimentsthereof. In some embodiments, the Petri message-passing layer implements incidence-derived attention. Figures 2-4 and 6 illustrate restricted- configuration embodiments, including multi-head transition processing, learned incidence routing, comparison with dense transformer attention, and mappings in which graph-network or transformer operations are expressed through the P-T-P incidence structure. Input place-node states may correspond to token, node, modality, region, memory, or other feature-bearing states. A transition node may operate as an interaction slot, transition head, attention-derived computation site, or process node. Pre-incidence relationships may select, weight, gate, or identify input placenode states participating in a transition-node computation. Post-incidence relationships may identify output place nodes receiving transition- derived messages.

[0103] In one technical interpretation, an attention layer provides a reusable primitive for sequence or token interaction, whereas the disclosed Petri message-passing layer provides a reusable primitive for structured-flow interaction. This interpretation is explanatory and does not require a transformer implementation. The disclosed layer may therefore be used independently in settings where relational computation is more naturally expressed as selected input place-node participation, transition-node process computation, and routed output place-node update. In attention-compatible embodiments, the same structure permits attention-like routing to be applied to structured domains involving directed processes, higher-order interactions, multimodal transformations, conservation constraints, semantic-conversion constraints, or flow-balance constraints.

[0104] In some embodiments, pre- / post-incidence relationships are learned as attention- like routing coefficients. A pre-incidence weight may encode compatibility between a transition query and source place state, and a post-incidence weight may encode routing strength from a transition message to an output place state. Such weights may be normalized, selected, or otherwise processed using softmax, sparsemax, sigmoid gating, top-k selection, masking, differentiable sampling, other normalization or selection operators, or combinations thereof.

[0105] In representative learned-incidence embodiments,

[0106] Apre= sparse_top_k(softmax(QTKPT)), (14) Apost= sparse_top_k(softmax(QPKTT)), (15) where QT, Kp, Qp, KTdenote transition-query, place-key, place-query, and transition-key representations. Compatibility functions may use bilinear forms, multilayer perceptrons, kernels, distances, learned masks, semantic-type embeddings, positional or temporal encodings, rule constraints, other compatibility functions, or combinations thereof. Normalization or selection may use softmax, sparsemax, entmax, sigmoid gating, hard or soft top-k selection, masked normalization, differentiable sampling, straight-through estimation, other normalization or selection operators, or combinations thereof.

[0107] In optional attention-compatible embodiments, an attention-based neural computation may be implemented using the same Petri message-passing layer. Token, node, edge, query, key, or value representations may be represented as place-node states. Transition nodes may represent attention-mediated interactions. Pre-incidence weights may be based on query- key similarity scores, learned attention weights, or attention masks. Transition messages may be based on value vectors, transformed value vectors, or aggregated token representations. Post-incidence relationships may route transition messages to output place nodes. These embodiments are illustrative integrations of the broader PGNN architecture rather thanlimitations on the independent Petri-net-based scope.

[0108] A conventional attention operation may be represented as a restricted case in which placenode states are token representations, transition-node computations are attention-derived interactions, and post-incidence routing returns transition messages to token-associated output places. More general embodiments permit transition nodes to represent directed, higher-order, typed, sparse, constrained, multimodal, or semantically converting interactions beyond dense pairwise token-to-token attention. Thus, transformer-compatible embodiments are restricted configurations within the independent structured-flow architecture.

[0109] A non-limiting attention analogy may be summarized as follows:

[0110] Attention Petri message- passing analog

[0111] Token state Place-node state

[0112] Attention head Transition head

[0113] Query / key score Place-transition incidence compatibility

[0114] Attention weight Pre- / post-incidence weight

[0115] Value mixing Transition-message routing

[0116] Multi-head attention Multi-head transition processing

[0117] Dense token pairs Sparse or learned P-T-P routing

[0118] The analogy is illustrative and does not require transformer implementation. The layer may implement attention-like routing while retaining transition-node computation over selected place- node states and pre- / post-incidence routing to output place-node states.

[0119] 5.7 Multi-head Petri transition attention

[0120] In some embodiments, a Petri message-passing layer comprises multiple transition heads. Each transition head may include a respective pre-incidence representation, post-incidence representation, transition processor, transition-feature representation, mask, semantic type, or parameter set. For head k, the computation may be expressed as

[0121]

[0122] where k indexes a transition head and K is the number of heads. The combine operation may concatenate, sum, average, gate, normalize, pool, project, or attend over head outputs. Different transition heads may specialize to different relationship types, modalities, directions, temporal ranges, flow types, attention masks, invariant constraints, or learned structural motifs. This provides a multi-head alternative or complement to attention heads while preserving pre-incidence input selection and post-incidence output routing.

[0123] 5.8 Constraint enforcement and flow semantics

[0124] In some embodiments, the architecture enforces, approximates, evaluates, or regularizes incidence constraints, including conservation, flow-balance, mass-balance, informationbalance, semantic-consistency, semantic-conversion, capacity, P-invariant, T-invariant, or other algebraic-invariant relationships. A training objective may include

[0125] ℒ = ℒtask+ λ1ℒincidence+ λ2ℒconstraint, (19)

[0126] where Ctask is a supervised, self-supervised, reinforcement- learning, reconstruction, forecasting, classification, regression, or other task loss, ^incidence regularizes sparsity, capacity, entropy, topology, masks, or learned structure, and Constraint penalizes or measures conservation, flow-balance, semantic-conversion, or invariant violations.

[0127] Constraint mechanisms may include loss penalties, projection operations, normalization operations, constrained optimization steps, Lagrange multipliers, masks, residual corrections, post-update balancing operations, invariant-preserving parameterizations, or combinations thereof. These mechanisms may be applied to incidence weights, transition messages, placenode states, transition-node states, update functions, readout values, or training objectives.

[0128] 5.9 Special cases and distinctions

[0129] The disclosed representation may implement or interface with existing operations while preserving the P-T-P structure. Pairwise-constrained transition nodes may correspond to graph neural networks; source / receiver / edge / global-state transition constraints may correspond to graph-network relational blocks; transitions connecting multiple place nodes may implement higher-order or hypergraph message passing; attention-derived incidence weights over token-associated place nodes may implement transformer-compatible attention; and typed or layered place and transition nodes may implement heterogeneous, multilayer, temporal, or multimodal message passing.

[0130] The above configurations are restricted examples rather than definitions of the independent PGNN architecture. A graph-network block may update edge, node, or global states according to relation functions; in a restricted PGNN configuration, those relation functions may be implemented as transition-node processors and routing to update targets may be expressed using pre- / post-incidence relationships. A transformer attention head may compute token-pair compatibility and value mixing; in a restricted PGNN configuration, those compatibility scores may form incidence-derived input participation or routing weights and the value-derived computation may be represented at transition nodes. Such restricted configurations do not limit the PGNN architecture to graph-network, graph-neural-network, hypergraph-neural-network, or transformer implementations.

[0131] A hypergraph neural-network layer may represent a hyperedge connecting multiple nodes. In embodiments of the disclosed architecture, a transition node is a computational unit that receives inputs through pre-incidence relationships, performs a learnable transition computation, and routes outputs through post-incidence relationships. The pre- / post-incidence relationships may be directed, weighted, typed, constrained, or separately learned, enabling process-oriented message passing, semantic conversion, conservation-aware updates, and multi-output propagation that need not be symmetric or undirected.

[0132] Although a transition node may, in some embodiments, connect multiple place nodes, the transition node is not merely a graph edge, relation label, hyperedge, or token-pair attention score. Rather, the transition node may operate as a learnable process-computation site having distinct input-side pre-incidence relationships and output-side post-incidence relationships. In representative embodiments, the same layer further includes two or more of multi-input transition computation, multi-output routing, non-identical pre / post incidence, semantic conversion, constraint or invariant enforcement, sparse or learned incidence routing, and concurrent transition execution. This permits directed, typed, constrained, transition-mediated, and concurrently executable computation beyond pairwise graph message passing, graph-network relational blocks, hypergraph aggregation, or dense transformer attention.5.10 Training and structure learning

[0133] The system may be trained end-to-end using gradient-based or other optimization. Trainable parameters may include transition-function, transition-message, flow-rate, aggregation, update-function, readout, incidence, mask, gating, firing, flow, capacity, or structure-learning parameters, other trainable quantities, or combinations thereof. Training may be supervised, semi-supervised, self-supervised, unsupervised, reinforcement-based, contrastive, transferbased, otherwise trained, or combinations thereof.

[0134] In one embodiment, a representative training loop may be expressed as:

[0135] Input: H_P, W_E, A_pre, A_post, parameters theta

[0136] X_P <- W_E H_P

[0137] X_T <- A_pre~T X_P

[0138] H_T <- Phi_theta(X_T)

[0139] M_P <- A_post H_T

[0140] H_P’ <- Psi_theta(H_P, M_P)

[0141] y_hat <- Readout (H_P;)

[0142] Loss <- L_task(y_hat) + lambda * L_constraint

[0143] Update theta, W_E, and incidence parameters when learnable

[0144] The loop is illustrative. Message- weight / incidence representations may be fixed, learned, sparse, masked, attention-derived, implicit, or otherwise configured; constraints may include conservation, flow-balance, semantic-conversion, sparsity, or invariant terms.

[0145] In some embodiments, the system learns part or all of the Petri-net-based relational structure. A structure-learning module may infer latent transition nodes, pre- / post-incidence relationships, incidence weights, or transition types from observed data using statistical dependency, similarity, attention, temporal co-occurrence, causal evidence, physical adjacency, ontological relationships, domain priors, differentiable sampling, sparsity regularization, reconstruction objectives, or other structure-learning criteria.

[0146] 5.11 Implementation mechanisms

[0147] The disclosed architecture may be implemented using sparse or dense matrices, tensors, incidence lists, sparse formats, graph objects, relational tables, serialized data structures, parameterized incidence functions, generated operators, or other data representations. Incidence relationships may be stored explicitly or generated, accessed, maintained, or computed implicitly during execution.

[0148] The system may execute message propagation on graphics processing units, tensor processing units, neural processing units, field-programmable gate arrays, applicationspecific integrated circuits, distributed computing systems, edge devices, high-performance computing systems, neuromorphic systems, or other computing resources. Implementation mechanisms may include batching, parallel transition scheduling, mixed precision, graphexecution kernels, just-in-time compilation, cached messages or incidence relationships, streaming inference, partial updates, memory / layout optimization, operator fusion, pruning, quantization, or other execution optimizations.

[0149] 5.12 Reference implementation interface

[0150] In representative software embodiments, the disclosed Petri message-passing layer may be exposed as a reusable neural-network layer or application programming interface. For example, a layer call may receive a place-state tensor, a place-to-place message-weightrepresentation, a pre-incidence representation, a post-incidence representation, one or more transition functions, one or more update functions, optional transition-head parameters, and optional constraint functions, and may return updated place-node states and optional auxiliary outputs. A representative interface may be expressed as:

[0151] H_out, aux = PetriLayer(H_place, W_E, A_pre, A_post,

[0152] transi ion_fn, update_fn,

[0153] constraint_fn=None, heads=K,

[0154] sparse=True, return_traces=True)

[0155] where H_place denotes place-node states, W_E place-to-place adjacency, flow-rate, or message-weight relationships, A_pre and A_post pre- and post-incidence relationships, transition_fn and update_fn transition and update functions, and aux transition states, messages, incidence weights, masks, constraint residuals, head outputs, sparsity, runtime, memory-use, or other implementation / evaluation data. The interface is illustrative and does not require a programming language, library, tensor shape, or hardware platform.

[0156] Representative shapes include Npxdp place states, NpxNp or equivalent message- weight representations, Np x dp transition states, and Np x NTpre- / post-incidence representations, with transposed post-incidence storage permitted. Here, Np and Np denote numbers of place and transition nodes, dp and dp denote feature dimensions, and additional head dimension K, semantic-type, time, batch, modality, or implementation dimensions may be used. Sparse embodiments may store only nonzero incidence entries using coordinate arrays, edge-index tensors, compressed sparse matrices, block-sparse tensors, masked attention-score tensors, generated incidence functions, or combinations thereof.

[0157] 5.13 Benchmarking and empirical-support embodiments

[0158] In some embodiments, the system produces outputs for empirical evaluation of the Petri message-passing layer. The system may record prediction outputs, loss values, transition states, transition messages, incidence weights, sparsity, constraint / conservation / flow-balance / semantic-conversion residuals, training or inference time, memory usage, accelerator utilization, convergence statistics, ablation outputs, or other evaluation outputs or metrics. Such values may be produced during training, validation, testing, simulation, deployment, benchmarking, or combinations thereof.

[0159] In sparse embodiments, pre- / post-incidence representations may reduce memory use or computation relative to dense pairwise mechanisms by limiting computation to selected nonzero P-T-P incidence pathways. For a structured domain with N place nodes and M transition nodes, execution may be scheduled over nonzero incidence entries rather than all N2pairwise interactions, supporting sparse tensor execution, batching, and parallel evaluation of independent transition processors. In constrained embodiments, conservation, flow-balance, semantic-conversion, sparsity, capacity, or invariant constraints may reduce invalid transitions, stabilize routing, or improve interpretability. These technical effects arise from the incidence-driven computation and do not require a particular application domain.

[0160] Representative comparisons may include pairwise graph neural-network layers, graphnetwork blocks, hypergraph neural-network layers, dense or sparse attention layers, factor-graph message-passing layers, multilayer or temporal relational models, ablated Petri message-passing layers, or other structured-data baselines. Ablations may remove or vary transition nodes, pre- / post-incidence relationships, learned incidence attention,transition heads, sparse routing, semantic typing, constraint losses, invariant-preserving parameterizations, parallel transition scheduling, or other model components.

[0161] Representative evaluation metrics may include classification, regression, calibration, likelihood, convergence, parameter-count, floating-point-operation, memory, latency, throughput, sparse-density, transition- utilization, constraint- violation, or interpretability metrics, including metrics based on transition-message traces or incidence weights. The metrics are task-dependent and non-limiting.

[0162] These implementation, logging, and benchmarking mechanisms support empirical comparison while relying on the same technical structure: place nodes, transition nodes, pre- / post- incidence relationships, transition-node message computation, post-incidence routing, place-state updating, optional learned incidence attention, transition heads, constraints, sparse execution, or parallel execution.

[0163] 5.14 Variations, extensions, and integrations

[0164] The disclosed embodiments are not limited to the particular implementations expressly described herein. The disclosure contemplates variations, modifications, substitutions, combinations, extensions, and later-developed implementations or embodiments of the disclosed architecture to the extent that such implementations or embodiments include, are based on, or otherwise employ one or more computer-implemented, neural, differentiable, trainable, trained, inference-stage, or learning-based Petri-net message-passing components disclosed herein, including, without limitation, one or more of place nodes, transition nodes, pre-incidence relationships, post-incidence relationships, directional flow relationships, flowbased transition functions, aggregation functions, update functions, readout functions, conservation constraints, balance constraints, semantic-conversion constraints, invariantpreserving constraints, or combinations thereof.

[0165] In some embodiments, one or more components of the disclosed PGNN architecture may be varied, modified, substituted, combined, extended, or augmented while retaining an incidence-driven place-to-transition-to-place message-passing structure. Such components may include, without limitation, semantic-conversion mechanisms, invariant-preserving mechanisms, transition-activation mechanisms, learned-incidence mechanisms, attention-derived incidence mechanisms, structure-learning mechanisms, sparse-routing mechanisms, hardware-execution mechanisms, or combinations thereof.

[0166] A PGNN component may be integrated into another machine- learning architecture as a module, layer, block, kernel, routing mechanism, relational-computation component, attention augmentation, constraint-enforcement component, structured-data processing component, another implementation form, or combinations thereof. Conversely, known neural-network components may be integrated into a PGNN implementation as transition functions, aggregation functions, update functions, encoders, decoders, readout functions, gates, normalization functions, regularizers, other functional components, or combinations thereof. Such integrations remain examples of the disclosed architecture when they retain the disclosed Petri-net-based place-to-transition-to-place message-passing structure.

[0167] 5.15 Representative applications

[0168] The disclosed embodiments may be applied, without limitation, to structured-data tasks in which entities, features, states, tokens, events, processes, resources, observations, measurements, or other feature-bearing objects are represented using place nodes, transition nodes, and incidence relationships. Tasks may include classification,

[0169] regression, forecasting, anomaly detection, ranking, retrieval, recommendation, control, relational inference, representation learning, simulation, optimization, decision support, generation, or other structured-data processing tasks. Domains may include financial, biological, neurological, molecular, reaction, energy, communication, logistics, infrastructure, cyber-physical, knowledge-graph, multi-agent, feedback-control, dynamical, oscillator, synchronization, neuroscience, neuromodulation, acoustics, music-information, auditory-stimulation, rhythmic or phase-based signal-processing, neuromorphic-computing, oscillatorcomputing, robotics, power-system, or other domains.

[0170] Place nodes may represent feature-bearing objects, and transition nodes may represent interactions, coupling processes, control transformations, synchronization processes, multimodal stimulation effects, acoustic or rhythmic transformations, or other processcomputation sites. A PGNN layer may be used as a structured-data processing, stateestimation, prediction, surrogate-modeling, controller-support, decision-support, or other component in systems processing measurements, estimated states, coupling information, phase relationships, stimulation features, multimodal observations, or combinations thereof. These examples are illustrative and do not limit PGNN to a domain or form.

[0171] The disclosed embodiments are not limited to a domain, data type, network size, neural- network layer, loss function, hardware platform, or implementation form. Variations may include global-context states, transition-node states, recurrent iterations, residual connections, normalization, attention modules, probabilistic transitions, continuoustime dynamics, discrete-time dynamics, hybrid symbolic-neural components, or other architectural variations, provided the implementation uses or is based on the disclosed incidence-driven P-T-P message-passing structure.

[0172] 6 Examples

[0173] The following examples illustrate representative uses of the disclosed architecture. They are non-limiting and are not required by all embodiments.

[0174] 6.1 Reusable structured-data layer

[0175] In one example, a Petri message-passing layer is inserted into a neural network in place of a pairwise message-passing layer. Input feature tensors are treated as place-node states, a learned or stored pre-incidence structure selects participating place states for each transition node, a transition processor computes transition states, and a learned or stored postincidence structure routes transition states back to place nodes. The same layer may be used for graph-like data, hypergraph-like data, token data, event data, or multimodal data by changing the incidence relationships rather than redesigning the neural architecture.

[0176] 6.2 Higher-order multimodal interaction

[0177] In another example, input data includes entities from two semantic layers, such as financial variables and product-flow variables. Place nodes represent layer-specific states. Transition nodes represent processes that receive one or more input states from one layer and output transformed messages to one or more states in another layer. Pre-incidence and post-incidence relationships encode the direction, weight, and semantic meaning of each transformation. A transition function learns how the input states influence the output states, while a constraint loss regularizes flow balance or semantic conversion across the layers.6.3 Attention-mediated computation

[0178] In another example, token representations are encoded as place-node states. Transition nodes represent attention-mediated interactions. Pre-incidence weights are learned from query-key compatibility, masked attention patterns, or top-k routing. Transition messages are computed from value representations and routed to output token places through postincidence weights. The resulting computation provides an incidence-based attention layer in which dense all-pairs token attention may be replaced or augmented by sparse, learned, directed, or constrained incidence relationships.

[0179] 6.4 Minimal transition-slot example

[0180] In another example, input places are tokens or graph nodes and transition nodes are learned interaction slots. Each transition slot selects a sparse set of input places using learned preincidence weights, computes a transition message using a shared or head-specific transition processor, and routes the message to one or more output places using learned post-incidence weights. A first transition slot may learn a local syntactic interaction, a second transition slot may learn a long-range dependency, and a third transition slot may learn a typed or constrained relation. The output place states are updated from transition messages. This example illustrates how the same P-T-P block can operate as a structured substitute for dense token-pair attention while retaining transition-level interpretability.

[0181] 6.5 Transact ion- like process example

[0182] In another example, place nodes represent a buyer, seller, asset, account, or risk state, and a transition node represents a transaction. Pre-incidence relationships select the buyer, seller, and asset states as inputs to the transition processor. The transition processor computes a transaction message representing transfer, valuation, ownership, or risk information. Post-incidence relationships route resulting messages to output place nodes representing updated accounts, ownership states, or risk states. Conservation, balance, or semantic-conversion losses may regularize the transaction message so that value, ownership, or capacity relationships remain consistent.

[0183] 6.6 Biological or neurological network analysis

[0184] In another example, place nodes represent biological regions, cells, genes, proteins, measured signals, or physiological states. Transition nodes represent regulatory motifs, reaction-like processes, glial-neuronal interactions, signaling transformations, or multimodal couplings. Higher-order transition nodes may model triadic regulation in which one entity modulates a relationship between two or more other entities. A task-specific readout may classify subject state, predict disease stage, identify abnormal connectivity, or produce an interpretable structured representation.

[0185] 6.7 Feedback-control, oscillator, acoustic, and neuromorphic contexts

[0186] In another example, the disclosed architecture is used in feedback-control, coupled-oscillator, synchronization, neuromodulation, acoustic, music-related, neuromorphic, robotics, powersystem, or other applications. Place nodes may represent measured or estimated states, oscillator states, phase variables, phase-difference variables, sensor signals, stimulation features, control targets, or multimodal observations. Transition nodes may represent coupling processes, synchronization interactions, control transformations, acoustic or rhythmic transformations, stimulation effects, or learned surrogate dynamics. A readout may generate state estimates, predictions, control-support quantities, decision-support outputs,phase-relationship representations, learned coupling representations, or other task-specific outputs for a controller, estimator, planner, supervisory module, stimulation module, or downstream system.

[0187] 6.8 Reference implementation and benchmark protocol

[0188] In another example, an implementation instantiates a Petri message-passing layer with a place-state tensor, a sparse pre-incidence tensor, a sparse post-incidence tensor, a transition processor, a place updater, and a constraint function. The layer is evaluated against a graph neural-network layer, a graph-network block, a hypergraph neural- network layer, a dense attention layer, and an ablated Petri layer lacking one or more of learned incidence attention, transition heads, sparse routing, or constraint regularization. The implementation records task metrics, memory consumption, runtime, convergence behavior, learned incidence weights, transition-message traces, and constraint residuals. Such outputs may be used to demonstrate technical effects including reduced pairwise edge expansion, reduced dense attention computation, improved transition-level interpretability, improved constraint satisfaction, or improved performance on higher-order or flow-constrained data.

[0189] 7 Advantages and Technical Effects

[0190] The disclosed architecture provides a mechanism for structured-data processing based on incidence-driven place-to-transition-to-place message passing. By computing messages at transition nodes according to pre-incidence relationships and propagating transition-derived messages according to post-incidence relationships, the system may represent multi-input and multi-output transformations without requiring relationships to be reduced to pairwise edges, hyperedge-only abstractions, or dense token-pair attention operations.

[0191] The disclosed P-T-P block may replace, augment, interface with, or be combined with other structured-data processing blocks. Pairwise transition nodes may implement graph neural-network edge updates; higher-order nodes may implement hypergraph or higher-order message passing; learned incidence-attention routing may implement attention-compatible computation; typed place nodes, transition nodes, or semantic-conversion constraints may implement multimodal fusion; and transition processors with directed pre- / post-incidence routing may implement factor-graph, relational, temporal, or flow-based updates.

[0192] In benchmark or deployment settings, the architecture may be compared with pairwise GNN layers, graph-network blocks, hypergraph neural-network layers, dense or sparse attention layers, factor-graph message passing, ablated Petri message-passing layers, or other structured-data baselines. Measurable effects may include reduced memory use when sparse incidence replaces dense all-pairs interactions, reduced edge expansion for higher-order relationships, improved transition-level interpretability, improved constraint satisfaction or training stability, and improved parallel execution through transition scheduling.

[0193] In some embodiments, the architecture improves computational efficiency through sparse, implicit, generated, or learned incidence representations, independent-transition scheduling, batched execution, mixed-precision execution, or accelerator-parallel execution. In some embodiments, the architecture improves interpretability, robustness, or constraint compliance by associating learned neural messages with flow, semantic conversion, conservation, balance, capacity, sparsity, or invariant relationships.

Claims

Claims1. A computer- implemented machine-learning system comprising one or more processors and one or more non-transitory computer-readable storage media storing instructions that, when executed by the one or more processors, cause the system to:receive input data representing a structured relationship domain;generate, access, or determine a Petri-net-based bipartite computational representation comprising place nodes, transition nodes, separately represented pre-incidence relationships coupling input place nodes to respective transition nodes, and separately represented post-incidence relationships coupling respective transition nodes to output place nodes;compute, at a transition node, a transition message by applying a learnable transformation to state information of one or more input place nodes coupled to the transition node by a corresponding pre-incidence relationship;propagate the transition message to one or more output place nodes coupled to the transition node by a corresponding post-incidence relationship;aggregate transition messages received at the one or more output place nodes; update place-node state representations based on the aggregated transition messages; and generate a task-specific output from one or more updated place-node state representations.

2. The system of claim 1, wherein at least one transition node is configured as a learnable process-computation site distinct from a graph edge, relation label, hyperedge, or token-pair attention score, the transition node having separate pre-incidence relationships for selecting or weighting input place-node state representations and postincidence relationships for routing transition-derived messages to output place-node state representations.

3. The system of claim 1 or 2, wherein at least one transition node is configured as a learnable process-computation site having a separately represented input-side preincidence relationship coupling one or more input place nodes to the at least one transition node and a separately represented output-side post-incidence relationship coupling the at least one transition node to one or more output place nodes, and wherein the Petri-netbased bipartite computational representation implements, for the at least one transition node or for a plurality of transition nodes in a common message-passing iteration, at least one differentiating feature selected from: (i) separately representing and independently determining the input-side pre-incidence relationship and the output-side post-incidence relationship, including when the at least one transition node is coupled to a single input place node and a single output place node, (ii) receiving multiple input place-node state representations at a transition node, (iii) routing transition-derived state information from a transition node to multiple output place nodes, (iv) using a pre-incidence relationship that is non-identical to, differently parameterized from, or separately determined from a post-incidence relationship, (v) applying a semantic-conversion or typespecific transformation at a transition node, (vi) enforcing, approximating, evaluating, or regularizing a conservation, flow-balance, semantic-consistency, sparsity, invariant, or other constraint, or any combination thereof, (vii) executing independent transition- node computations concurrently or in parallel, (viii) using sparse, learned, gated, generated, attention-derived, implicit, or other incidence routing, or any combination thereof, and (ix) using directional pre-incidence and post-incidence relationships to represent directedflow of transition-derived state information; thereby implementing an incidence-driven place-to-transition-to-place relational computation layer not limited to pairwise edge message passing or dense token-pair attention.

4. The system of claim 1, wherein the place nodes represent states, entities, features, tokens, variables, regions, assets, resources, observations, measurements, semantic objects, other feature-bearing objects, or combinations thereof, and wherein the transition nodes represent interactions, transformations, processes, events, computations, relation instances, attention-mediated interactions, flow conversions, other process-computation sites, or combinations thereof.

5. The system of claim 1, wherein the instructions implement a Petri message-passing layer comprising an incidence selector configured to select input place-node states according to the pre-incidence relationships, a transition processor configured to compute the transition message at the transition node, an incidence router configured to route the transition message according to the post-incidence relationships, and a place updater configured to update the output place-node state representations.

6. The system of claim 5, wherein the Petri message-passing layer is implemented as tensor operations comprising applying a place-to-place adjacency, flow-rate, or message-weight operator to a place-state matrix, applying a pre-incidence matrix or tensor to form transition inputs, applying a transition neural function to form transition states or messages, and applying a post-incidence matrix or tensor to form place-node messages or updated place-node states.

7. The system of claim 1, wherein at least one transition node is associated with a plurality of input place nodes, a plurality of output place nodes, or both, thereby representing a higher-order, n-ary, multi-input, or multi-output relationship.

8. The system of claim 1, wherein the pre-incidence relationships and the post-incidence relationships comprise functions, mappings, matrices, tensors, lists, weights, masks, sparse or dense data structures, generated, implicit, parameterized, or other incidence representations, or combinations thereof, defining magnitudes, directions, types, semantic meanings, or other flow attributes between place nodes and transition nodes.

9. The system of claim 1, wherein at least one pre-incidence relationship or post-incidence relationship comprises a fixed, learned, accessed, domain-specified, normalized, attention- derived, masked, trainable, or other incidence value, or combinations thereof.

10. The system of claim 1, wherein the learnable transformation comprises a neural- network layer, multilayer perceptron, attention mechanism, recurrent or gated update function, convolutional operator, transformer block, differentiable message-passing operator, other learnable operator, or combinations thereof.

11. The system of claim 1, wherein the system is configured to enforce, approximate, evaluate, regularize, preserve, or penalize violation of a conservation, flow-balance, mass-balance, information-balance, semantic-conversion, semantic-consistency, or sparsity constraint, a P-invariant, T-invariant, algebraic invariant associated with the Petri-net-based bipartite computational representation, other constraint or invariant, or combinations thereof.

12. The system of claim 11, wherein the constraint is imposed using a loss penalty, projection, normalization, constrained optimization, Lagrange multiplier, mask, residual correction, invariant-preserving parameterization, post-update balancing, otherconstraint-enforcement operation, or combinations thereof.

13. The system of claim 1, wherein at least one transition node has a pre-incidence relationship that is non-identical to, differently parameterized from, or separately determined from a post-incidence relationship, the transition node is configured as a learnable processcomputation site, and the system further performs conservation regularization, flowbalance regularization, semantic-conversion processing, invariant preservation, sparse or implicit incidence routing, concurrent transition-node execution, another differentiating operation, or combinations thereof.

14. The system of claim 1, wherein the input data comprises a source structure selected from a graph, hypergraph, heterogeneous graph, multilayer network, temporal network, knowledge graph, simplicial complex, cell complex, flow network, event log, sensor stream, time series, multimodal record, transformer-token representation, database record, higher- order relational structure, other source structure, or combinations thereof, and wherein the Petri-net-based bipartite computational representation represents, is generated from, or encodes the source structure.

15. The system of claim 1, wherein operations corresponding to a graph-network relational block are represented, augmented, or implemented as a restricted configuration in which transition nodes correspond to edge, relation, node-update, edge-update, global-update, graph-block, or other relational computations, the pre-incidence relationships couple source-node, receiver-node, edge-state, global-state, relation-state, or other inputs to transition nodes, and the post-incidence relationships route transition-node messages to receiver-node, edge-state, global-state, relation-state, or other update targets.

16. The system of claim 1, wherein operations corresponding to a graph neural network, message-passing neural network, graph-network block, hypergraph neural network, heterogeneous, multilayer, temporal, factor-graph, relational, attention-based graph, or other structured-relational network are represented, augmented, or implemented as restricted configurations in which transition nodes correspond to pairwise relationships, adjacency-indexed relations, edge-indexed relations, relation instances, factor nodes, hyperedges, higher-order participation sets, temporal couplings, cross-layer couplings, or other participation structures while using the pre-incidence relationships to define inputside participation and the post-incidence relationships to define output-side propagation.

17. The system of claim 1, wherein, in an attention-compatible restricted configuration, an attention-based neural computation is implemented by representing token, node, edge, query, key, value, modality, or other feature representations as place-node state representations, defining one or more transition nodes that perform attention-derived interaction computations, selecting or weighting input-side participation according to learned, stored, computed, attention-derived, or other pre-incidence relationships, and routing transition-derived messages to output place-node state representations according to learned, stored, computed, attention-derived, or other post-incidence relationships.

18. The system of claim 17, wherein the attention-compatible restricted configuration represents, augments, or implements a transformer attention head, attention layer, graph-attention operation, token-interaction operation, attention-based computation, or combinations thereof as a specialized instance of the Petri-net-based place-to-transition- to-place computation, wherein one or more pre-incidence weights are derived from querykey similarity scores, attention logits, learned compatibility scores, masks, compatibilityfunctions, or other attention criteria, and one or more transition messages are generated based at least in part on value vectors, transformed-value representations, place-node state representations, or combinations thereof associated with place nodes.

19. The system of claim 1, wherein at least one of the pre-incidence relationships or the post-incidence relationships comprises a learnable incidence-attention weight normalized, selected, gated, sampled, masked, or otherwise processed using softmax, sparsemax, entmax, sigmoid gating, top-k selection, masking, differentiable sampling, straight- through estimation, another normalization or selection operation, or combinations thereof.

20. The system of claim 1, wherein the pre-incidence relationships or post-incidence relationships are generated, inferred, accessed, or selected from learned compatibility scores between place-node representations and transition-node representations, other structure-learning criteria, or combinations thereof.

21. The system of claim 1, wherein the transition nodes are partitioned into a plurality of transition heads, each transition head having a pre-incidence representation, postincidence representation, transition-node processor, transition-feature representation, mask, semantic type, parameter set, other head-specific configuration, or combinations thereof, and wherein outputs of the plurality of transition heads are concatenated, summed, averaged, gated, normalized, pooled, projected, attended over, or otherwise combined to update one or more place-node state representations.

22. The system of claim 1, wherein the aggregation comprises summation, averaging, pooling, attention-based, normalized, incidence-weighted, semantic-weighted, learned, or other aggregation operations, or combinations thereof.

23. The system of claim 1, wherein the system is configured to learn at least one transition node, incidence relationship, incidence weight, flow weight, mask, firing gate, transition type, capacity value, other structure parameter, or combinations thereof from data.

24. The system of claim 1, wherein at least a portion of the message computation or propagation is executed on a graphics processing unit, tensor processing unit, neural processing unit, field-programmable gate array, application-specific integrated circuit, distributed computing system, edge-computing device, high-performance system, neuromorphic computing system, other computing resource, or combinations thereof.

25. The system of claim 5, wherein the Petri message-passing layer is configured to replace, augment, interface with, or be combined with a transformer attention layer, graphattention layer, graph-network relational block, graph neural- network layer, hypergraph convolution layer, multimodal fusion layer, temporal relational layer, factor-graph layer, other structured-data processing component, or combinations thereof.

26. The system of any preceding claim, wherein, using the Petri-net-based bipartite computational representation, the structured relationship domain comprises a higher- order algebraic-topology structure selected from a simplicial complex, cell complex, chain complex, directed hypergraph, multilayer complex, or other higher-order structure, and wherein the incidence-mediated place-to-transition-to-place representation supports n- ary regulatory, catalytic, modulatory, control, or combined interactions, with triadic regulation represented as a special case thereof.

27. The system of any preceding claim, wherein, using the incidence-mediated place-to- transition-to-place relational computation layer, the system selects, sparsifies, prunes,schedules, quantizes, gates, or otherwise configures one or more incidence relationships or transition-node computations according to memory usage, latency, energy consumption, bandwidth, processor availability, another execution criterion, or combinations thereof.

28. A computer-implemented method comprising:receiving input data representing a structured relationship domain;generating, determining, or accessing a Petri-net-based bipartite computational representation comprising place nodes, transition nodes, separately represented preincidence relationships, and separately represented post-incidence relationships; determining, accessing, defining, or inferring, for a transition node, a pre-incidence relationship coupling one or more input place nodes to the transition node and a postincidence relationship coupling the transition node to one or more output place nodes; computing, at the transition node, a transition message using a learnable transformation applied to state information from the one or more input place nodes;propagating the transition message to the one or more output place nodes coupled to the transition node according to the post-incidence relationship;aggregating transition messages at the one or more output place nodes;updating place-node state representations based on aggregated transition messages; and generating a task-specific output from the updated place-node state representations.

29. The method of claim 28, further comprising training the learnable transformation, an aggregation function, an update function, a readout function, an incidence relationship, a flow-weighting function, a structure-learning module, other trainable component, or combinations thereof using supervised learning, semi-supervised learning, self-supervised learning, unsupervised learning, reinforcement learning, contrastive learning, transfer learning, another training procedure, or combinations thereof.

30. The method of claim 28, further comprising computing a loss comprising a task loss, an incidence regularization term, a constraint term associated with conservation of flow, balance of flow, semantic consistency, semantic conversion, concurrency consistency, P-invariant preservation, T-invariant preservation, sparsity, structural reconstruction, another loss or constraint term, or combinations thereof.

31. The method of claim 28, further comprising inferring, using a structure-learning model, one or more latent transition nodes, pre-incidence relationships, post-incidence relationships, incidence weights, other relational structure parameters, or combinations thereof from observed data.

32. The method of claim 28, further comprising representing a graph-network relational block, graph neural-network message-passing operation, hypergraph neural operation, transformer attention head, other structured-data operation, or combinations thereof as a restricted configuration of the incidence-driven place-to-transition-to-place computation by mapping corresponding state representations to place-node states, corresponding relation or attention computations to transition- node computations, and corresponding routing or aggregation operations to pre-incidence and post-incidence relationships.

33. The method of claim 28, wherein the input data comprises streaming data, and wherein the method further comprises partially updating a subset of place-node states, transitionnode states, pre-incidence relationships, post-incidence relationships, other representation components, or combinations thereof in response to a newly received data item.

34. One or more non-transitory computer-readable media storing instructions that, whenexecuted by one or more processors, cause the one or more processors to perform the method of any one of claims 28 to 33.

35. The one or more non-transitory computer-readable media of claim 34, wherein the instructions further cause the one or more processors to impose, evaluate, regularize, monitor, preserve, or penalize violation of a conservation, flow-balance, semantic- conversion, sparsity, invariant, other constraint or invariant, or combinations thereof during message passing or training.

36. A computer-implemented Petri message-passing component implemented by one or more processors executing instructions for use in a neural network, the component comprising: one or more data structures storing, maintaining, generating, or accessing place-node state representations;one or more data structures storing, maintaining, generating, or accessing transition-node state representations;a pre-incidence data structure, parameterized representation, or other incidence representation specifying directed relationships from place nodes to transition nodes; a post-incidence data structure, parameterized representation, or other incidence representation specifying directed relationships from transition nodes to place nodes; a transition processor configured to compute transition messages from place-node state representations according to the pre-incidence data structure, parameterized representation, or other incidence representation; anda place updater configured to update place-node state representations using transition messages routed according to the post-incidence data structure, parameterized representation, or other incidence representation.

37. The component of claim 36, wherein the component is differentiable and trainable end- to-end with one or more additional neural-network layers and is configured to preserve or regularize a conservation law, flow-balance rule, semantic-conversion rule, sparsity rule, invariant relationship, other constraint or invariant, or combinations thereof.

38. The component of claim 36, wherein the component comprises a plurality of transition heads and is configured as a reusable incidence-mediated relational computation block configured to replace, augment, interface with, or represent, as a restricted configuration, a graph-network relational block, graph neural-network message-passing operation, hypergraph convolution operation, transformer attention head, multimodal fusion layer, temporal relational layer, factor-graph update layer, other structured-data processing component, or combinations thereof.

39. One or more non-transitory computer-readable storage media storing a data structure for machine learning over structured data, the data structure comprising place-node identifiers, transition-node identifiers, pre-incidence relationships coupling selected placenode identifiers to transition-node identifiers, post-incidence relationships coupling selected transition-node identifiers to selected place-node identifiers, and features, weights, labels, transition-head identifiers, masks, constraint values, other data, or combinations thereof, wherein the data structure is accessible by one or more processors executing neural-network instructions during Petri-net-based message passing.

40. The storage media of claim 39, wherein the data structure comprises sparse, implicit, learned, multi-head, attention-derived, or other incidence representations, or combinations thereof, configured to control place-to-transition-to-place message passing.