Convolutive Kernel-Guarded Spiking Neural P Systems for Local Feature Computation

Abstract

Spiking Neural P systems provide a rule-based model of distributed computation inspired by membrane computing, while kernel P systems use guarded transformations and structured control of rule applicability. This paper introduces Convolutive Kernel-Guarded Spiking Neural P systems ($\mathrm{CK}-\mathrm{SN}\mathrm{P}$ systems), a formal and trainable framework in which spike-rule applicability may depend on local kernel responses computed over ordered neighborhoods of spike multiplicities. The proposed model provides a general mechanism for local feature computation, combining explicit operational semantics with kernel-based predicates that can be fixed, selected, or embedded in trainable realizations. We define the syntax and transition semantics of the model, relate the construction to delay-free extended Spiking Neural P systems and kernel P systems under stated assumptions, and present a reproducible instantiation for electrocardiographic beat classification under a patient-independent protocol. The empirical study illustrates how CK–SN P local responses can be combined with RR, Gaussian, and Fourier descriptors and evaluated with classical and neural classifiers. Overall, the study clarifies both the formal role of guarded local computation and its practical use as an interpretable feature-generation mechanism.

1. Introduction

Membrane computing studies computational models inspired by the organization and functioning of living cells. Its models, usually called P systems, describe computation through multisets of objects, compartments, evolution rules, communication mechanisms, and parallel rule application. The foundations of this area were established through the original membrane-computing model, the introductory monograph, and later handbook-level syntheses [1,2,3]. Spiking Neural P systems ($\mathrm{SN}\mathrm{P}$ systems) form a neural-like family of P systems in which information is represented by spikes and rule firing is controlled by spike multiplicities, regular expressions, delays, and communication along synapse-like connections [4,5,6]. Kernel P systems ($\mathrm{kP}$ systems) provide a more general membrane-computing framework based on compartments, typed objects, guarded rules, links, and execution strategies, and they have also been investigated from verification and testing perspectives [7,8]. Recent work on $\mathrm{SN}\mathrm{P}$ systems and broader surveys of membrane computing show that rule-based membrane models remain relevant for formal computation, modeling, and algorithmic design [9,10]. In parallel, modern machine learning has shown the practical value of local feature extraction and trainable architectures. Convolutional models introduced local kernels as a central mechanism for extracting neighborhood-level patterns, while later deep architectures extended this idea through depth, residual connections, and attention-based representations [11,12,13,14]. Spiking neural networks have also developed as a trainable computational paradigm through surrogate-gradient learning, spike-based software frameworks, and links to neuromorphic computation [15,16,17,18]. These lines of work motivate the question addressed in this paper: whether local kernel-based feature computation can be integrated into the rule semantics of $\mathrm{SN}\mathrm{P}$ systems while preserving a precise operational interpretation. This study brings together membrane computing, spiking neural P systems, local kernel-based computation, and reproducible biomedical signal classification. These areas are complementary: membrane computing provides explicit rule systems and formal transition semantics; $\mathrm{SN}\mathrm{P}$ systems represent information through spikes and rule firing; local kernels capture neighborhood-level patterns in signals, images, and time series; and ECG beat classification offers a concrete setting in which local morphology, class imbalance, and patient-independent testing are critical. The proposed model connects these elements through a rule-level mechanism in which a local kernel response can influence the applicability of a spike rule.

We introduce $\mathrm{CK}-\mathrm{SN}\mathrm{P}$ systems as a formal model that connects spiking membrane computation, kernel-P-style guarded rules, and local convolutional feature processing. In a classical $\mathrm{SN}\mathrm{P}$ system, the applicability of a rule in a neuron depends mainly on the number of spikes available in that neuron and on the regular-expression condition associated with the rule. In a $\mathrm{CK}-\mathrm{SN}\mathrm{P}$ system, the applicability of a rule may also depend on a local weighted pattern of spike multiplicities observed in an ordered neighborhood. This pattern is evaluated through a finite kernel, and the resulting response may enter the local guard of a spike rule. The objective is not to replace convolutional neural networks, recurrent neural networks, transformers, or existing biomedical classifiers, but to provide a rule-level formalism in which local filtering is expressed as an explicit predicate inside a spiking membrane-computing transition. In this setting, the neighborhood, the kernel, the threshold relation, the scenario label, and the spike rule remain visible in the model description. The motivation for this model is both formal and practical. Formally, $\mathrm{SN}\mathrm{P}$ systems offer a compact rule-based semantics for spike evolution, while $\mathrm{kP}$ systems show how guarded rules and execution strategies can be used in a broader membrane-computing setting. A CK–SN P rule preserves the symbolic spike-rule structure and extends its applicability condition with a local kernel response. Practically, many classifiers for signals, images, and time series rely on local filters because discriminative information is often expressed in short-range patterns. The proposed model follows this observation while placing local feature computation inside a transparent rule mechanism rather than treating it only as a hidden numerical layer. This perspective supports a formal definition of the model, a differentiable training route, and a reproducible biomedical classification protocol. The empirical context considered in this work is ECG beat classification. The MIT-BIH Arrhythmia Database and PhysioNet are widely used resources for arrhythmia analysis and reproducible physiological signal research [19,20]. The evaluation follows an AAMI-style three-class setting with normal beats ($\mathrm{N}$), supraventricular ectopic beats ($\mathrm{S}$), and ventricular ectopic beats ($\mathrm{V}$), where patient-independent reporting is important because random beat-level splits may mix beats from the same patient across training and testing partitions [21,22,23]. The $\mathrm{S}$ class is relevant because it has a smaller representation in the evaluation data and may share morphological characteristics with normal beats. For this reason, the evaluation cannot rely only on accuracy. It must also include macro-averaged and class-wise metrics. This evaluation choice is consistent with prior ECG classification work, including survey-level analyses, convolutional and transferable deep representations, ambulatory ECG classification, and time-series architectures used as comparison points [24,25,26,27,28]. The implementation and reproducibility layer uses standard machine-learning tools and stochastic optimization procedures, including scikit-learn and gradient-based training [29,30].

The manuscript separates formal definitions, implementation choices, and empirical observations. Definitions are stated independently of the training procedure, algorithms are given in editable pseudocode, and empirical statements are tied to a patient-independent protocol, fixed preprocessing, declared random seeds, and class-wise metrics. Numerical results are computed under the declared full-mode experimental settings and are summarized in the corresponding tables. The complete-data experiment uses the DS1/DS2 protocol with two random seeds, while the reduced-data full-mode setting is reported separately as a complementary analysis. This structure supports a transparent distinction between the formal contribution, the implementation choices, and the reported empirical evidence.

The main contributions are as follows:

–

Formal CK–SN P model. We define $\mathrm{CK}-\mathrm{SN}\mathrm{P}$ systems by adding ordered neighborhoods, finite kernels, local guards, convolutive guards, and scenario-controlled rule families to a spiking membrane-computing setting.

–

Operational semantics. We specify rule applicability and transition behavior for delay-free and delayed variants, making explicit how local convolutive responses enter spike-rule activation.

–

Relation to existing membrane models. We show that standard delay-free extended $\mathrm{SN}\mathrm{P}$ systems can be recovered as a special case and that finite delay-free CK–SN P systems can be represented through $\mathrm{kP}$ guards when the corresponding convolutive predicates are expressible in the guard language.

–

Trainable realization. We provide a differentiable implementation of convolutional spike rules using surrogate activations, together with a discrete inference mode that preserves the connection with the symbolic rule interpretation.

–

Reproducible ECG protocol. We provide a patient-independent MIT-BIH evaluation protocol with classical baselines, neural baselines, CK–SN P variants, ablation studies, class-imbalance-aware metrics, declared random seeds, full-mode settings, and implementation details summarized in the experimental tables.

The manuscript is organized to keep the formal construction, the trainable realization, and the empirical evaluation in the same reproducible account. This structure reflects the dual role of the proposed model: a rule-level formalism and a source of inspectable local descriptors for downstream classification.

The study is organized around four research questions. The first asks whether local convolutive predicates can be integrated into $\mathrm{SN}\mathrm{P}$ systems without losing a precise operational semantics. The second asks whether the resulting model can be related to $\mathrm{kP}$ systems under explicit guard-expressibility assumptions. The third asks whether the formal rule structure can be implemented as a trainable architecture while retaining a hard-rule interpretation at inference time. The fourth asks which implementation components influence minority-class detection and macro-averaged performance under a patient-independent ECG protocol. These questions delimit the scope of the paper and restrict empirical conclusions to the reported data, splits, metrics, baselines, and seeds. The contribution is not stated as a claim of increased computational power over existing spiking P-system variants. Rather, it is a structural and semantic contribution: local weighted responses are introduced as explicit, finite, inspectable predicates inside spike-rule applicability. This makes the local feature-computation mechanism part of the formal rule system instead of treating it as an external preprocessing step or as an opaque numerical layer. Under sufficiently expressive guard languages, some such predicates may be encoded indirectly in existing formalisms; the role of the CK–SN P formulation is to provide a direct operational semantics, a bounded guard structure, and a reproducible route from formal rule applicability to empirical local-feature descriptors. In summary, this study presents CK–SN P systems as a formal and trainable framework for integrating local kernel responses into spiking membrane-computing rules. The proposed model makes local feature computation explicit at the rule level while retaining a route to trainable implementation and reproducible empirical evaluation. The resulting contribution connects membrane-computing semantics, spike-based rule systems, local convolutive feature computation, and ECG classification under a reproducible full-mode experimental protocol.

The remainder of this paper is structured as follows. Section 2 discusses related work at the intersection of membrane computing, spiking neural computation, local feature extraction, and ECG classification. Section 3 introduces the notation, spike-rule conventions, local-kernel notation, ECG class mapping, patient-independent split, and evaluation measures used throughout the manuscript. Section 4 defines the proposed $\mathrm{CK}-\mathrm{SN}\mathrm{P}$ model, including ordered neighborhoods, kernel responses, model components, rule applicability, operational semantics, and illustrative method figures. Section 5 presents finite-branching, determinism, boundedness, conservativity with respect to extended $\mathrm{SN}\mathrm{P}$ systems, and behavior-preserving representation as $\mathrm{kP}$ systems under explicit guard-expressibility assumptions. Section 6 describes the differentiable realization, the audit map connecting formal and empirical claims, dataset preprocessing, patient-independent DS1/DS2 protocol, compared methods, ablation variants, metrics, training procedure, and table-regeneration workflow. Section 7 reports the full-mode experimental results, the complementary reduced-data analysis, component ablation results, computational cost and reproducibility considerations, applicability and practical scope, limitations, and threats to validity. Section 8 concludes the paper and outlines future work.

2. Related Work

This study relates to four research directions: spiking neural P systems and membrane-computing models, spiking neural computation, local kernel-based feature extraction, and reproducible biomedical signal classification. These directions are usually studied with different objectives. Membrane-computing models emphasize explicit rules and formal transition semantics. Spiking neural models emphasize event-based information processing and trainable spike dynamics. Kernel and convolutional methods emphasize local neighborhood responses. ECG beat classification provides a biomedical evaluation setting where local morphology, class imbalance, and patient-independent reporting must be handled carefully. The proposed CK–SN P model is positioned between these directions by introducing local kernel responses into the applicability predicates of spiking membrane-computing rules.

$\mathrm{SN}\mathrm{P}$ systems belong to the family of neural-like membrane systems. In these systems, identical objects called spikes are placed in neurons and evolve by means of firing and forgetting rules. A firing rule is usually written as $E/a^c\to a^p;d$, where E is a regular expression over the spike alphabet, c spikes are consumed, p spikes are emitted, and d is a delay. This representation is useful because the computation is described through explicit symbolic conditions rather than only through numerical transformations. The proposed model keeps this rule-level interpretation and extends it with local predicates computed from ordered neighborhoods of spike multiplicities. This preserves the formal readability of $\mathrm{SN}\mathrm{P}$ systems while allowing local feature tests that are common in signal and image processing. The broader literature on spiking neural networks provides an additional context for spike-based computation. Maass introduced networks of spiking neurons as a computational model in which temporal spike events play a central role in information processing [31]. Gerstner et al. later developed a systematic account of neuronal dynamics, threshold mechanisms, synaptic interactions, and temporal coding [32]. More recent surveys discuss spiking neural networks as a connection between biologically inspired computation, neuromorphic hardware, and machine learning [33,34]. These studies motivate the use of spike-based representations, but they do not formulate local feature extraction through membrane-computing rule semantics. CK–SN P systems address a different level of description: the spike mechanism remains rule-based, while local kernel responses are introduced as explicit conditions for rule applicability. Neuromorphic research also motivates the study of sparse and event-based computation. The Loihi processor illustrates how programmable spiking processors can support event-driven neural computation [35], while mixed-signal neuromorphic circuits show that memory and information processing can be considered in hardware systems designed around spike-based principles [36]. This paper does not propose a neuromorphic hardware implementation; its contribution is at the modeling and algorithmic level. The relevance of these works is that they show why sparse, local, and event-based computation remains an active research topic, while CK–SN P systems provide a formal-neural construction in which such local responses can be inspected through spike rules and guards.

$\mathrm{kP}$ systems provide a relevant formal comparison framework for the proposed construction. They define a flexible P-system setting based on compartments, types, guarded rules, links, and execution strategies. This connection is relevant because a local convolutive condition can be interpreted as a guard whenever the kernel response and the threshold relation are expressible in the selected guard language. For this reason, the relation between CK–SN P systems and $\mathrm{kP}$ systems is stated under explicit guard-expressibility assumptions, rather than as an unrestricted equivalence. The model can therefore be understood as a rule-based extension in which spike-rule applicability depends not only on the spike multiplicity of one neuron, but also on a local weighted response computed over an ordered neighborhood. Convolutional and local feature-processing methods have become central tools in modern signal and image analysis. Local kernels are useful because relevant structures are often expressed through short-range neighborhood patterns. The study does not aim to replace convolutional neural networks. Instead, it introduces a formal setting in which local weighted responses are attached to spike-rule applicability. The benefit is that the local activation condition remains explicit: the neighborhood, the kernel, the threshold relation, and the scenario label can be inspected as part of the rule mechanism. This differs from ordinary convolutional layers, where the numerical operation is effective but the link with a symbolic rule system is usually not part of the model definition.

In one-dimensional biomedical signals, local morphology is especially important. ECG beat classification depends on waveform structure around the QRS complex, pre-QRS information, and post-QRS behavior. For this reason, local temporal filters have been used in ECG classification. Kiranyaz et al. proposed one-dimensional convolutional neural networks for patient-specific ECG classification, showing the usefulness of temporal filters for arrhythmia recognition [37]. Ince et al. used morphological and temporal descriptors for ECG beat classification, further supporting the role of local waveform information [38]. Strodthoff et al. provided benchmark evidence and methodological insights for deep learning-based ECG analysis on the PTB-XL dataset [39]. These studies motivate trainable ECG modeling, but they do not express local ECG feature extraction in terms of guarded spike rules or membrane-computing semantics.

The MIT-BIH Arrhythmia Database is a common benchmark for ECG beat classification. Patient-independent evaluation is important because random beat-level splitting may place beats from the same patient in both training and testing partitions. In the AAMI setting considered in this paper, the classes are normal beats ($\mathrm{N}$), supraventricular ectopic beats ($\mathrm{S}$), and ventricular ectopic beats ($\mathrm{V}$). The $\mathrm{S}$ class requires explicit reporting because it has a smaller representation in the evaluation data and may share morphological characteristics with normal beats. For this reason, evaluation based only on accuracy is not sufficient. The experimental protocol therefore reports balanced accuracy, macro-F1, per-class F1, MCC, Cohen’s kappa, confusion-matrix summaries, and ablation results under the declared experimental settings. This reporting strategy makes the empirical behavior visible at the class level, especially for the supraventricular class.

Interpretability is also relevant for biomedical classification. Rudin argued that interpretable models should be preferred in high-stakes domains when their use is feasible [40]. The proposed model follows this principle at the level of formal design. CK–SN P systems expose the local response, the guard condition, and the spike-rule activation mechanism instead of treating the local transformation only as a hidden numerical operation. The study is therefore positioned as an interdisciplinary contribution between membrane computing, spiking neural P systems, local kernel-based feature computation, and reproducible ECG classification. Its role is not to claim a universal replacement for existing neural architectures, but to provide a rule-level framework in which local feature computation can be defined, trained, inspected, and evaluated under an auditable experimental protocol.

3. Preliminaries and Problem Setting

This section introduces the notation used in the formal definition and in the experimental part of the paper. It separates general notation, spike-rule notation, local-kernel notation, and the ECG classification setting before the proposed $\mathrm{CK}-\mathrm{SN}\mathrm{P}$ model is introduced.

Table 1. Main notation used in the CK–SN P formal model and in the experimental protocol.

Symbol	Meaning
$V=\{1,\dots ,m\}$	finite set of neurons or compartments
$E_G\subseteq V\times V$	directed synaptic graph; the subscript avoids confusion with regular expressions
$X=(x_1,\dots ,x_m)$	spike configuration; $x_i$ is the number of spikes in neuron i
$R_i$	finite rule set associated with neuron i
$E/a^c\to a^p;d$	spike rule with regular expression E, consumption c, production p, and delay d
$N\left(i\right)=(j_1,\dots ,j_{q_i})$	ordered neighborhood of neuron i
$K_i=({\kappa }_{i,1},\dots ,{\kappa }_{i,q_i})$	finite kernel associated with $N\left(i\right)$
${conv}_{K_i}\left(X\right)$	local kernel response computed from X and $K_i$
$\bowtie \in \{<,\le ,=,\ne ,\ge ,>\}$	comparison relation used in local kernel predicates
$\Sigma$	finite set of scenario labels
$\mathsf{S}\left(t\right)\subseteq \Sigma$	set of scenario labels active at time t
$\mathcal{Y}=\{\mathrm{N},\mathrm{S},\mathrm{V}\}$	ECG beat-class set used in the experiments

is used only as a notation guide. It does not define the CK–SN P system tuple; the formal model components are introduced later in Definition 4. This organization clarifies which elements are inherited from standard $\mathrm{SN}\mathrm{P}$ systems and which elements are extended in Section 4.

Let A be a finite alphabet. The set of all finite strings over A is denoted by $A^{*}$, and the empty string is denoted by $\lambda$. A multiset over A is a function

$$M:A\to \mathbb{N}.$$

(1)

For an object $a\in A$, the value $M\left(a\right)$ denotes the multiplicity of a in M. When the alphabet is unary, $A=\left\{a\right\}$, the multiset containing n copies of a is denoted by $a^n$. In the spiking setting considered in this paper, the object a is interpreted as a spike, and the exponent n denotes the number of spikes available in a neuron or compartment.

A regular expression E over the unary alphabet a defines a language $L\left(E\right)\subseteq a^{*}$. In a standard $\mathrm{SN}\mathrm{P}$ rule, a regular-expression condition tests whether the current number of spikes belongs to the language defined by E. A firing rule is written as $E/a^c\to a^p;d$, where $c\ge 1$ is the number of consumed spikes, $p\ge 0$ is the number of emitted spikes, and $d\ge 0$ is a delay. Such a rule is applicable in a neuron containing x spikes when $x\ge c$ and $a^x\in L\left(E\right)$. If $p=0$, the rule is interpreted as a forgetting rule. In the proposed model, this standard applicability condition is preserved and extended by local and convolutive guards.

The structural support of a spike system is represented by a finite directed graph $G=(V,E_G)$, where $V=1,\dots ,m$ is the set of neurons or compartments and $E_G\subseteq V\times V$ is the set of directed synaptic links. The symbol $E_G$ is used for graph edges to avoid confusion with the regular expression E in spike rules. A spike configuration is written as $X=(x_1,\dots ,x_m)\in {\mathbb{N}}^m$, where $x_i$ is the number of spikes in neuron i. When delays are considered, a configuration also stores the remaining closing time of each neuron, while the delay-free case is represented by the spike vector alone.

The extension studied in this paper uses ordered local neighborhoods. For a neuron $i\in V$, an ordered neighborhood is written as $N\left(i\right)=(j_1,\dots ,j_{q_i})$, with $j_{\ell }\in V$. The order is part of the notation because different positions may receive different weights, which is relevant for local contrast, temporal asymmetry, or oriented neighborhood tests. A finite kernel associated with $N\left(i\right)$ is written as $K_i=({\kappa }_{i,1},\dots ,{\kappa }_{i,q_i})\in {\mathbb{Q}}^{q_i}$. Given a configuration X, the corresponding local response is denoted by ${conv}_{K_i}\left(X\right)$ and is computed as the weighted sum of the spike multiplicities in the ordered neighborhood.

A local kernel predicate is a Boolean condition built from comparisons between a local response and a threshold, for example ${conv}_{K_i}\left(X\right)\bowtie \theta$, where $\bowtie \in <,\le ,=,\ne ,\ge ,>$ and $\theta \in \mathbb{Q}$. Finite Boolean combinations of such atomic predicates can express local contrast, local dominance, burst-like activity, or neighborhood imbalance. The proposed model uses these predicates as guards for spike rules. This choice keeps the rule mechanism explicit because the neighborhood, the kernel weights, the threshold, and the affected rule are all specified as part of the model.

We also use scenario labels to separate rule families by computation stage. Let

$$\Sigma =\{s_1,\dots ,s_h\}$$

(2)

be a finite set of labels. A scenario-control function has the form

$$\mathsf{S}:\mathbb{N}\to 2^{\Sigma },$$

(3)

where $\mathsf{S}\left(t\right)$ denotes the set of rule families active at time t. For example, an implementation may use labels such as $s_{\mathrm{pre}}$, $s_{\mathrm{local}}$, $s_{\mathrm{temporal}}$, and $s_{\mathrm{decision}}$ to distinguish preprocessing-like spike normalization, local kernel activation, temporal aggregation, and output selection. Scenario labels are not introduced as an additional claim of computational power. They make rule families explicit and support ablation studies in which one stage can be removed or modified. For instance, a finite execution schedule may activate different rule families at different time steps:

$$\mathsf{S}\left(0\right)=\left\{s_{\mathrm{pre}}\right\},\mathsf{S}\left(1\right)=\mathsf{S}\left(2\right)=\left\{s_{\mathrm{local}}\right\},\mathsf{S}\left(3\right)=\left\{s_{\mathrm{temporal}}\right\},\mathsf{S}\left(4\right)=\left\{s_{\mathrm{decision}}\right\}.$$

Under this schedule, only rules carrying the active scenario labels are considered at each step. The same spike configuration and the same local guards may therefore lead to different enabled rule sets when the scenario-control function changes. In the empirical implementation, this mechanism is used as an explicit organizational device for rule families rather than as a separate source of experimental claims.

The experimental problem considered in this paper is patient-independent ECG beat classification on the MIT-BIH Arrhythmia Database. Each beat is represented by a one-dimensional window around an annotated R peak. The class set is

$$\mathcal{Y}=\{\mathrm{N},\mathrm{S},\mathrm{V}\},$$

(4)

where $\mathrm{N}$ denotes normal and bundle branch block beats, $\mathrm{S}$ denotes supraventricular ectopic beats, and $\mathrm{V}$ denotes ventricular ectopic beats. The AAMI-style mapping used in the experiments is

$$\mathrm{N}=\{N,L,R,e,j\},\mathrm{S}=\{A,a,J,S\},\mathrm{V}=\{V,E\}.$$

(5)

Fusion beats and unknown or unclassifiable beats are excluded from training, validation, testing, confusion matrices, and metric computation. This restriction is made explicit so that all compared models use the same label space.

The evaluation setting is patient-independent. Let $D_{DS1}$ denote the set of beats extracted from the training records and $D_{DS2}$ the set of beats extracted from the held-out test records. The training and validation partitions are derived only from $D_{DS1}$, while $D_{DS2}$ is used only for final testing:

$$D_{DS1}=D_{\mathrm{train}}\cup D_{\mathrm{val}},D_{\mathrm{train}}\cap D_{\mathrm{val}}=⌀,D_{DS2}=D_{\mathrm{test}}.$$

(6)

This split reduces patient leakage, since beats from the same patient should not appear simultaneously in training and testing partitions. The full-mode evaluation reported in Section 7 uses this same DS1/DS2 protocol, with DS1 used for training and validation and DS2 used only for final testing.

Class imbalance is part of the problem setting. The class $\mathrm{S}$ is usually less frequent and may be morphologically close to $\mathrm{N}$. Therefore, the main empirical analysis cannot rely only on accuracy. For a confusion matrix $C=\left(c_{ij}\right)$, with true class i and predicted class j, the class-wise quantities are

$$\begin{array}{cccc}\hfill T{P}_i=c_{ii},& \hfill F{P}_i=\sum _{j\ne i}{c}_{ji},& \hfill F{N}_i=\sum _{j\ne i}{c}_{ij},& \hfill T{N}_i=\sum _{p\ne i}\sum _{q\ne i}{c}_{pq}.\end{array}$$

(7)

The corresponding sensitivity, precision, specificity, and F1-score are

$$\begin{array}{cc}\hfill {Sens}_i={\displaystyle \frac{T{P}_i}{T{P}_i+F{N}_i}}, & \hfill {Prec}_i={\displaystyle \frac{T{P}_i}{T{P}_i+F{P}_i}},\end{array}$$

(8)

$$\begin{array}{cc}\hfill {Spec}_i={\displaystyle \frac{T{N}_i}{T{N}_i+F{P}_i}}, & \hfill F{1}_i={\displaystyle \frac{2{Prec}_i{Sens}_i}{{Prec}_i+{Sens}_i}}.\end{array}$$

(9)

The macro-F1 score and balanced accuracy used throughout the experimental section are

$$\mathrm{MacroF}1={\displaystyle \frac{1}{\left|\mathcal{Y}\right|}}\sum _{i\in \mathcal{Y}}F{1}_i,BAcc={\displaystyle \frac{1}{\left|\mathcal{Y}\right|}}\sum _{i\in \mathcal{Y}}{Sens}_i.$$

(10)

Additional agreement-oriented metrics, such as Matthews correlation coefficient and Cohen’s kappa, are reported in the experimental section when generated by the evaluation script. The problem addressed by the paper can now be stated as follows. Given a spike configuration derived from a local signal window, an ordered neighborhood system, a finite family of kernels, and a set of guarded spike rules, the goal is to define and evaluate a model whose rule applicability can depend both on standard spike conditions and on local kernel responses. Formally, the next section defines this model as a $\mathrm{CK}-\mathrm{SN}\mathrm{P}$ system. Empirically, Section 6 defines the trainable realization and the patient-independent ECG protocol, while Section 7 reports the full-mode results, the complementary reduced-data analysis, ablation results, computational considerations, and validity limitations.

4. Convolutive Kernel-Guarded Spiking Neural P Systems

This section defines the proposed $\mathrm{CK}‒\mathrm{SN}\mathrm{P}$ model. The construction extends the rule applicability mechanism of $\mathrm{SN}\mathrm{P}$ systems by adding ordered neighborhoods, finite kernels, local guards, convolutive guards, and scenario labels. This design keeps the spike-rule semantics explicit while allowing local kernel responses to influence rule firing. The definitions below are stated at the formal level; the differentiable implementation used in the ECG experiments is described later in Section 6.

4.1. Ordered Spike Neighborhoods and Convolutive Kernel Responses

Let $G=(V,E_G)$ be a finite directed graph, where $V=\{1,\dots ,m\}$ is the set of neurons or compartments and $E_G\subseteq V\times V$ is the set of directed synaptic links. A spike configuration is a vector

$$X=(x_1,\dots ,x_m)\in {\mathbb{N}}^m,$$

(11)

where $x_i$ denotes the number of spikes in neuron i. The proposed model associates selected neurons with ordered neighborhoods. The order is part of the model because the same multiset of neighbors may produce different responses when kernel weights are assigned to different positions.

Definition 1

(Ordered neighborhood). For each neuron $i\in V$, an ordered neighborhood is a tuple

$$N\left(i\right)=(j_1,\dots ,j_{q_i}),j_{\ell }\in V.$$

(12)

The length $q_i$ may depend on i. Neighbors may represent spatial positions, temporal positions, graph-adjacent neurons, or implementation-specific local contexts.

Definition 2

(Convolutive kernel). A convolutive kernel associated with neuron i is a vector

$$K_i=({\kappa }_{i,1},\dots ,{\kappa }_{i,q_i})\in {\mathbb{Q}}^{q_i}.$$

(13)

Given a configuration $X=(x_1,\dots ,x_m)$, the local kernel response is

$${conv}_{K_i}\left(X\right)={\displaystyle \sum _{\ell =1}^{q_i}}{\kappa }_{i,\ell }{x}_{j_{\ell }}.$$

(14)

Since the ordered neighborhood is finite, the computation of one local response ${conv}_{K_i}\left(X\right)$ requires $O\left(q_i\right)$ arithmetic operations for a fixed kernel representation. This cost is local to the rule-applicability test and does not change the finite-rule structure of the transition system. If several kernels are attached to neuron i, their set is denoted by

$${\mathcal{K}}_i=\{K_{i,1},\dots ,K_{i,s_i}\}.$$

(15)

The response in Equation (14) is a local weighted sum over spike multiplicities. It can encode contrast, local dominance, burst-like activity, temporal asymmetry, or neighborhood imbalance, depending on the selected neighborhood and kernel. The response is not itself a firing rule. It becomes operational only when it is used inside a guard.

Definition 3

(Convolutive predicate). A convolutive predicate in neuron i is a finite Boolean formula built from atomic comparisons of the form

$${conv}_K\left(X\right)\bowtie \theta ,K\in {\mathcal{K}}_i,\bowtie \in \{<,\le ,=,\ne ,\ge ,>\},\theta \in \mathbb{Q}.$$

(16)

The set of convolutive predicates available in neuron i is denoted by ${\mathcal{G}}_i^{conv}$.

This definition is deliberately finite and inspectable. The neighborhood, the kernel weights, the threshold relation, and the rule affected by the predicate are explicit components of the model. This is the main distinction between a CK–SN P guard and an ordinary hidden convolutional activation. The expressivity of a convolutive predicate is bounded by the selected neighborhoods, the finite kernel bank, the rational weights, the threshold relations, and the Boolean combinations allowed in the guard language. Such predicates can express finite local tests such as weighted dominance, local contrast, thresholded neighborhood activity, and combinations of these tests. They do not, by themselves, define arbitrary global properties of a configuration unless those properties are encoded through additional rule layers, additional neighborhoods, or scenario-controlled rule families. This bounded expressivity keeps local feature computation explicit and inspectable inside spike-rule applicability, rather than replacing the rule system with an unrestricted numerical layer.

Proposition 1

(Local dependence of finite convolutive guards). Let $g^{conv}$ be a Boolean combination of atomic predicates of the form ${conv}_K\left(X\right)\bowtie \theta ,$ where each kernel K is defined on a finite ordered neighborhood, $\bowtie \in \{<,\le ,=,\ne ,\ge ,>\}$, and $\theta \in \mathbb{Q}$. Then there exists a finite set of neuron indices $U\left(g^{conv}\right)\subseteq V$ such that, for any two configurations X and Y, if $x_j=y_j$ for all $j\in U\left(g^{conv}\right)$, then $g^{conv}\left(X\right)=g^{conv}\left(Y\right)$.

Proof. 

Each atomic predicate ${conv}_K\left(X\right)\bowtie \theta$ depends only on the spike counts appearing in the finite ordered neighborhood on which K is defined. Let $U\left(g^{conv}\right)$ be the union of all neighborhood positions over all atomic predicates occurring in $g^{conv}$. This union is finite because the guard contains finitely many atomic predicates and each neighborhood is finite.

If two configurations X and Y agree on all indices in $U\left(g^{conv}\right)$, then every kernel response appearing in the guard has the same value in both configurations. Hence every atomic predicate has the same truth value in X and Y, and the Boolean combination $g^{conv}$ also has the same truth value. Therefore, $g^{conv}\left(X\right)=g^{conv}\left(Y\right)$.    □

The boundedness and finiteness assumptions apply at the level of the CK–SN P guard language. A convolutive guard is finite because it is built from finitely many atomic comparisons, each atomic comparison uses a finite ordered neighborhood, and each kernel has finitely many rational coefficients. This gives an explicit and inspectable local predicate. It does not imply that the same predicate is automatically representable as a single ordinary SN P regular-expression condition, because ordinary spike-rule applicability is local to the spike multiplicity of the neuron applying the rule. Any indirect encoding in a different formalism must specify how neighborhood information is communicated or represented.

4.2. Formal Definition of the CK–SN P Model

A $\mathrm{CK}‒\mathrm{SN}\mathrm{P}$ system combines the spike alphabet, the membrane or synaptic graph, the neuron rule sets, the ordered neighborhoods, the kernels, the scenario-control function, and the output neuron.

Definition 4

(Convolutive Kernel-Guarded Spiking Neural P system). A $\mathrm{CK}‒\mathrm{SN}\mathrm{P}$ system of degree m is a tuple

$${\Pi }_{CK}=(O,\Sigma ,\mu ,{\sigma }_1,\dots ,{\sigma }_m,syn,\mathcal{N},\mathcal{K},\mathsf{S},i_{out}),$$

(17)

where:

(a) 

$O=\left\{a\right\}$ is the spike alphabet;

(b) 

Σ is a finite set of scenario labels;

(c) 

$\mu =(V,E_G)$ is a finite directed graph with $V=\{1,\dots ,m\}$;

(d) 

${\sigma }_i=(n_i,R_i)$ is neuron i, where $n_i\in \mathbb{N}$ is the initial spike count and $R_i$ is a finite rule set;

(e) 

$syn\subseteq E_G$ is the operational synapse relation used for spike transmission; when no distinction is needed, $syn=E_G$;

(f) 

$\mathcal{N}=\left\{N\right(i)\mid i\in V\}$ is the family of ordered neighborhoods;

(g) 

$\mathcal{K}=\{{\mathcal{K}}_i\mid i\in V\}$ is the family of kernel sets, where every $K\in {\mathcal{K}}_i$ has length $q_i$ and is evaluated on $N\left(i\right)$;

(h) 

$\mathsf{S}:\mathbb{N}\to 2^{\Sigma }$ is the scenario-control function, assigning to each time $t\in \mathbb{N}$ the set of scenario labels active at that time;

(i) 

$i_{out}\in V$ is the output neuron.

The scenario-control function indicates which rule families are active at a given computation time. For example, an ECG-oriented implementation may use

$$\Sigma =\{s_{\mathrm{pre}},s_{\mathrm{local}},s_{\mathrm{temporal}},s_{\mathrm{decision}}\},$$

(18)

where $s_{\mathrm{pre}}$ denotes preprocessing-like spike normalization, $s_{\mathrm{local}}$ denotes local kernel activation, $s_{\mathrm{temporal}}$ denotes short-range temporal aggregation, and $s_{\mathrm{decision}}$ denotes class-output rules. These labels are not required for every application. They are included to make rule families explicit and to support ablation studies. If scenario control is not used, one may take a single default label $\Sigma =\left\{s_0\right\}$ and set $\mathsf{S}\left(t\right)=\left\{s_0\right\}$ for all $t\in \mathbb{N}$. Thus, the scenario mechanism is optional in the sense that it can be made trivial without changing the standard rule-applicability behavior. Since $\mathsf{S}\left(t\right)\subseteq \Sigma$, the active scenario set may also be empty; in that case, no rule whose only scenario label is inactive can be selected at that time.

Definition 5

($\mathrm{CK}‒\mathrm{SN}\mathrm{P}$ rule). A rule in neuron i has the form

$$r:(E/a^c\to a^p;d)[g^{loc},g^{conv},s],$$

(19)

where E is a regular expression over $\left\{a\right\}$, $c\ge 1$ is the number of consumed spikes, $p\ge 0$ is the number of emitted spikes, $d\ge 0$ is the delay, $g^{loc}:\mathbb{N}\to \{\mathrm{true},\mathrm{false}\}$ is a local guard over the spike count of neuron i, $g^{conv}\in {\mathcal{G}}_i^{conv}$ is a convolutive predicate, and $s\in \Sigma$ is a scenario label. If $p=0$, the rule is interpreted as a forgetting rule.

The rule in Equation (19) extends the standard $\mathrm{SN}\mathrm{P}$ rule by adding two explicit applicability components: a local guard and a convolutive guard. The local guard can express conditions such as $x_i\ge c$, while the convolutive guard can express a local response condition such as ${conv}_{K_i}\left(X\right)\ge \theta$.

4.3. Rule Applicability and Transition Semantics

A configuration must store both spike counts and, when delays are used, the remaining closing time of each neuron.

Definition 6

(Configuration). A configuration of ${\Pi }_{CK}$ at time t is

$$C_t=(x_1\left(t\right),\dots ,x_m\left(t\right),{\tau }_1\left(t\right),\dots ,{\tau }_m\left(t\right),{\rho }_1\left(t\right),\dots ,{\rho }_m\left(t\right)),$$

(20)

where $x_i\left(t\right)\in \mathbb{N}$ is the number of spikes in neuron i, ${\tau }_i\left(t\right)\in \mathbb{N}$ is its remaining closing time, and ${\rho }_i\left(t\right)\in \mathbb{N}$ is the number of spikes scheduled to be emitted by neuron i when the current closing interval expires. If no delayed rule is pending in neuron i, then ${\tau }_i\left(t\right)=0$ and ${\rho }_i\left(t\right)=0$. In delay-free systems, ${\tau }_i\left(t\right)={\rho }_i\left(t\right)=0$ for all i, and the configuration is identified with

$$X_t=(x_1\left(t\right),\dots ,x_m\left(t\right)).$$

(21)

Definition 7

(Rule applicability). Let $r\in R_i$ be a CK–SN P rule written according to the CK–SN P rule form (19). The rule r is applicable in neuron i at time t, denoted by $App(r,i,t)$, if and only if

$$\begin{array}{cc}\hfill App(r,i,t)⟺& {\tau }_i\left(t\right)=0\wedge x_i\left(t\right)\ge c\wedge a^{x_i\left(t\right)}\in L\left(E\right)\hfill \\ & \wedge g^{loc}\left(x_i\left(t\right)\right)=\mathrm{true}\wedge g^{conv}\left(X_t\right)=\mathrm{true}\wedge s\in \mathsf{S}\left(t\right).\hfill \end{array}$$

(22)

Equation (22) is the central operational condition of the model. It shows where the proposed extension enters the standard spike-rule mechanism: the regular-expression test and spike consumption requirement are preserved, while the local and convolutive guards add explicit tests over the current configuration. At each global step, every open neuron forms its set of applicable rules and then applies the local execution strategy. In deterministic settings, this strategy selects the unique applicable rule whenever such a rule exists; otherwise, the neuron remains idle. In the general case, if several rules are applicable in the same neuron, the local execution strategy resolves the local choice by selecting zero or one of them. This convention gives a slightly more general local-selection interface than the standard SN P convention, in which an enabled neuron typically applies one rule. When CK–SN P systems are compared with standard or extended SN P systems, the same local rule-selection policy is used on both sides, so that the comparison is made between matched transition systems. The strategy may be nondeterministic, priority-based, or fixed by an implementation policy. The transition relation of the formal model therefore contains all successor configurations induced by the allowed local selections. The deterministic case used in the decidability statement is the restricted case in which each reachable neuron-time pair has at most one applicable rule and the execution strategy selects it whenever it exists.

Table 2. Evaluation order in one delay-free global CK–SN P step.

Step	Operation	Role in the Transition
1	Read $X_t$ and $\mathsf{S}\left(t\right)$	Fix spike counts and active scenario labels
2	Check scenario labels	Identify rules whose labels are active at time t
3	Evaluate standard rule tests	Check $a^{x_i\left(t\right)}\in L\left(E\right)$ and $x_i\left(t\right)\ge c$
4	Evaluate local and convolutive guards	Check $g^{loc}$ and $g^{conv}$ on the current configuration
5	Apply local execution strategy	Select zero or one applicable rule per neuron
6	Update spike counts	Apply consumption and synaptic transmission in parallel

summarizes the expository evaluation order used to describe one delay-free global CK–SN P step.

This order is expository. Rule applicability is defined by the conjunction of the regular-expression test, the consumption condition, the local guard, the convolutive guard, and the active scenario condition. Therefore, changing the order in which these Boolean tests are checked does not change the set of applicable rules. In the delay-free case, if the selected rule in neuron i consumes $c_i$ spikes and emits $p_i$ spikes, the next spike count of neuron j is

$$x_j(t+1)=x_j\left(t\right)-c_j\left(t\right)+\sum _{i:(i,j)\in syn}{p}_i\left(t\right),$$

(23)

where $c_j\left(t\right)=0$ and $p_j\left(t\right)=0$ if no rule is selected in neuron j. Algorithm 1 gives the corresponding global-transition procedure. The algorithm is included as editable text so that the formal transition can be inspected and reproduced.

The delayed case follows the usual interpretation of closing times. If a rule with delay $d>0$ is selected in neuron i, then the neuron consumes the required spikes at the selection time, sets ${\tau }_i$ to the closing interval, and stores the pending emission amount in ${\rho }_i$. While ${\tau }_i>0$, the neuron is closed and cannot select a new rule. When the closing interval expires, ${\rho }_i$ spikes are transmitted to the synaptic targets and the pending amount is reset to zero. The main formal comparisons and the trainable ECG implementation use the delay-free case, while the general definition records how delayed variants can be represented.

Algorithm 1 One global transition of a delay-free $\mathrm{CK}‒\mathrm{SN}\mathrm{P}$ system

Require:  Configuration $X_t=(x_1\left(t\right),\dots ,x_m\left(t\right))$, rule sets $R_i$, synapses syn, active scenarios $\mathsf{S}\left(t\right)$ Ensure:  Next configuration $X_{t+1}$   1: for $i=1$ to m do   2:    Compute all responses ${conv}_K\left(X_t\right)$ for $K\in {\mathcal{K}}_i$   3:    $A_i\left(t\right)\leftarrow \{r\in R_i\mid App(r,i,t)=\mathrm{true}\}$   4:    Select zero or one rule $r_i\in A_i\left(t\right)$ according to the local execution strategy   5: end for   6: for $j=1$ to m do   7:    $x_j(t+1)\leftarrow x_j\left(t\right)$   8: end for   9: for each selected delay-free rule $r_i:E_i/a^{c_i}\to a^{p_i};0$ in neuron i do 10:    $x_i(t+1)\leftarrow x_i(t+1)-c_i$ 11:    for each j such that $(i,j)\in syn$ do 12:      $x_j(t+1)\leftarrow x_j(t+1)+p_i$ 13:    end for 14: end for 15: return  $X_{t+1}$

4.4. Illustrative Example and Conceptual Overview

The following example illustrates how a local kernel can act as an explicit contrast test inside a spike rule.

Example 1

(Local contrast rule). Consider three neurons arranged linearly and let

$$N\left(2\right)=(1,2,3),K_2=(-1,2,-1).$$

(24)

For a configuration $X=(x_1,x_2,x_3)$, the local response is

$${conv}_{K_2}\left(X\right)=-x_1+2x_2-x_3.$$

(25)

The rule

$$r:(a/a\to a;0)[\top ,{conv}_{K_2}\left(X\right)\ge 1,s_{\mathrm{local}}]$$

(26)

fires only when the central neuron has a sufficiently larger spike count than its two neighbors. The rule can therefore be read as a discrete local contrast detector expressed in spike-rule form.

Figure 1 summarizes the proposed processing flow. The input window is encoded as spike multiplicities, ordered neighborhoods define local contexts, kernels compute local responses, and guarded spike rules use these responses under scenario control.

Figure 2 details the local-kernel interface between neighborhood spike counts and rule applicability. It shows how contrast and context triplets can be transformed into a response used by local and convolutive guards.

5. Formal Properties and Connections with P-System Models

This section establishes basic formal properties of $\mathrm{CK}‒\mathrm{SN}\mathrm{P}$ systems and clarifies their relation to two established membrane-computing models: extended $\mathrm{SN}\mathrm{P}$ systems and kernel P systems. Rather than giving an exhaustive complexity analysis, it states the minimal properties needed to delimit the proposed model. The results below record that the introduction of ordered neighborhoods, kernels, guards, and scenario labels preserves the finite-step operational character of the system. They also establish that the proposed construction extends standard delay-free $\mathrm{SN}\mathrm{P}$ systems and can be represented in a $\mathrm{kP}$ framework when the required guards are expressible. Unless stated otherwise, the formal results in this section are formulated for the delay-free fragment of the model. The general configuration definition records how delayed rules can be represented through closing times and pending emissions, but the conservativity result, the bounded-reachability statement, and the kernel-P representation are stated for delay-free systems. This convention matches the trainable realization and the ECG experiments reported later in the paper. Throughout this section, each formal statement is read under the hypotheses explicitly stated in its formulation. In particular, the conservativity result concerns finite delay-free systems and matching local rule-selection policies; the bounded-reachability statement assumes bounded spike counts and finite-state scenario control; and the $\mathrm{kP}$ representation result is conditional on the expressibility of the required regular-expression, local, scenario, and convolutive guards in the selected $\mathrm{kP}$ formalism. These assumptions are part of the formal scope of the results and delimit the transition behavior that is compared or represented.

5.1. Finite Branching, Determinism, and Boundedness

The first property concerns finite branching. Since each neuron has a finite rule set and each global transition is obtained by selecting at most one applicable rule per neuron, the set of possible successors of a configuration is finite. Scenario labels do not add new choices; they only restrict the set of rules that can be selected at a given time.

Proposition 2

(Scenario restriction preserves finite branching). Let ${\Pi }_{CK}$ be a $\mathrm{CK}‒\mathrm{SN}\mathrm{P}$ system with finitely many neurons and finite rule sets. For every configuration $C_t$, the set of successor configurations reachable from $C_t$ in one global step is finite.

Proof. 

For each neuron i, the rule set $R_i$ is finite. At time t, the set of applicable rules is $A_i\left(t\right)=\{r\in R_i\mid App(r,i,t)=\mathrm{true}\}.$ Since $A_i\left(t\right)\subseteq R_i$, the set $A_i\left(t\right)$ is finite. Scenario control can only remove rules whose labels are not active in $\mathsf{S}\left(t\right)$; it does not create additional rules. Hence the set of local choices for neuron i is finite. If no rule is selected in neuron i, this can be represented by an additional null choice ⊥, so the local choice set is $A_i\left(t\right)\cup \{\perp \}$. Because the number of neurons is finite, the set of global selections is contained in the finite product ${\prod }_{i=1}^m(A_i\left(t\right)\cup \{\perp \}).$ For a fixed global selection, the spike consumption and spike transmission effects are determined by the transition semantics. Therefore, each global selection determines at most one successor configuration. A finite set of global selections can generate only finitely many successor configurations. Hence the one-step successor set of $C_t$ is finite.    □

Determinism can be obtained by imposing mutual exclusiveness of rule-applicability predicates inside each neuron. This is a sufficient condition, not a necessary one. This condition is useful because it can be checked at the level of rule guards, regular-expression tests, local spike conditions, scenario labels, and convolutive predicates.

Definition 8

(Determinism). A $\mathrm{CK}‒\mathrm{SN}\mathrm{P}$ system is deterministic if, for every neuron i, every time t, and every reachable configuration $C_t$, at most one rule in $R_i$ is applicable, and the local execution strategy is fixed so that the unique applicable rule is selected whenever it exists. If no rule is applicable, the neuron remains idle.

Proposition 3

(Sufficient condition for determinism). Assume that the local execution strategy selects the unique applicable rule whenever it exists. If, for every neuron i and every pair of distinct rules $r_1,r_2\in R_i$, the predicates $App(r_1,i,t)$ and $App(r_2,i,t)$ are mutually exclusive for all configurations and times, then the system is deterministic.

Proof. 

By Equation (22), a rule can be selected only when its applicability predicate is true. If no two distinct rules in the same neuron can be applicable in the same configuration at the same time, then each neuron has at most one applicable rule. Together with the assumed local execution strategy, the unique applicable rule is selected whenever it exists, and the neuron remains idle otherwise. This is exactly the stated notion of determinism.    □

Boundedness is useful when reachability or exhaustive state-space exploration is considered. The next statements are standard finite-state arguments, but they are included to clarify the role of kernel guards. Convolutive predicates restrict applicability; they do not by themselves create infinitely many spike counts in one transition. If the reachable spike counts are bounded, the reachable state space is finite.

Definition 9

(Bounded system). A $\mathrm{CK}‒\mathrm{SN}\mathrm{P}$ system is B-bounded if there exists $B\in \mathbb{N}$ such that, for every reachable configuration and every neuron i, the spike count satisfies

$$x_i\left(t\right)\le B.$$

(27)

Proposition 4

(Finite state space under boundedness). If a delay-free $\mathrm{CK}‒\mathrm{SN}\mathrm{P}$ system with m neurons is B-bounded, then it has at most ${(B+1)}^m$ spike configurations.

Proof. 

In a B-bounded system, each spike count $x_i$ can take only values in the finite set $\{0,1,\dots ,B\}$. Since there are m neurons, the set of possible delay-free spike configurations satisfies $|{\mathcal{C}}_B{|\le (B+1)}^m.$ Thus, the reachable delay-free state space is a subset of a finite set.    □

For reachability questions, the scenario-control mechanism is assumed to be finite-state. That is, there exists a finite set of control states $Q_{\mathsf{S}}$, an initial control state $q_0$, and a transition function on control states such that the active scenario set $\mathsf{S}\left(t\right)$ is determined by the current control state. Constant and periodic scenario schedules are special cases of this assumption. Under this convention, the explored state contains both the spike vector and the finite scenario-control state.

Corollary 1

(Bounded reachability). Reachability is decidable for bounded deterministic delay-free $\mathrm{CK}‒\mathrm{SN}\mathrm{P}$ systems with finite-state scenario control.

Proof. 

By Proposition 4, the number of possible spike configurations is finite and bounded by ${(B+1)}^m$. Since the scenario-control mechanism is finite-state, there is also a finite set $Q_{\mathsf{S}}$ of scenario-control states. The combined state space is therefore bounded by ${(B+1)}^m\left|Q_{\mathsf{S}}\right|.$ Starting from the initial combined state, one can iteratively compute the unique successor, when it exists, and store every visited combined state. If the target spike configuration is reached, the procedure returns a positive answer. If a combined state with no successor is reached, or if a previously visited combined state is encountered again, then no new combined states can be generated beyond those already examined. Since the combined state space is finite, this procedure terminates. Therefore, reachability is decidable.    □

5.2. Extended SN P Systems as a Special Case

The next result records that the proposed model is conservative with respect to delay-free extended $\mathrm{SN}\mathrm{P}$ systems. In other words, adding ordered neighborhoods, kernels, convolutive guards, and scenario labels does not prevent the model from reproducing ordinary delay-free spike-rule computations when these additional components are chosen trivially. The construction uses a trivial neighborhood, a trivial kernel predicate, and a single scenario label that is always active. The comparison is made under the same local rule-selection policy in both systems. Thus, if the source $\mathrm{SN}\mathrm{P}$ system uses nondeterministic selection with at most one applicable rule per neuron, the constructed $\mathrm{CK}‒\mathrm{SN}\mathrm{P}$ system uses the corresponding nondeterministic selection. If a fixed priority or deterministic policy is used, the same policy is transferred to the corresponding CK–SN P rules. This convention ensures that the comparison is between transition systems with matched local choices.

Theorem 1

(Delay-free extended $\mathrm{SN}\mathrm{P}$ systems are a special case). For every finite delay-free extended $\mathrm{SN}\mathrm{P}$ system Π and for every fixed local rule-selection policy, there exists a finite $\mathrm{CK}‒\mathrm{SN}\mathrm{P}$ system ${\Pi }_{CK}$ such that the computations of Π and ${\Pi }_{CK}$ are in one-to-one correspondence under the corresponding local rule-selection choices, and the output behavior is preserved.

Proof. 

Let $\Pi$ be a delay-free extended $\mathrm{SN}\mathrm{P}$ system with neuron set $V=\{1,\dots ,m\}$, synapse relation $syn\subseteq V\times V$, initial spike vector $X_0$, output neuron $i_{out}$, and finite rule sets $R_i$. Each rule in $R_i$ has either the firing form $E/a^c\to a^p;0,$ where E is a regular expression over $\left\{a\right\}$, $c\ge 1$ is the number of consumed spikes, and $p\ge 1$ is the number of emitted spikes, or the forgetting form $a^s\to \lambda ,$ where $s\ge 1$. In the latter case, the forgetting rule is represented in the unified notation as a rule with $p=0$ and with the corresponding exact spike-count condition encoded in the regular-expression component, for instance by using $E=a^s$ and $c=s$.

We construct a $\mathrm{CK}‒\mathrm{SN}\mathrm{P}$ system ${\Pi }_{CK}$ with the same neuron set, the same synapse relation, the same initial spike vector, and the same output neuron. Let the scenario set be $\Sigma =\left\{s_0\right\}$ and define $\mathsf{S}\left(t\right)=\left\{s_0\right\}$ for every $t\in \mathbb{N}$. For each neuron i, choose the ordered neighborhood $N\left(i\right)=\left(i\right)$ and a trivial kernel $K_i=\left(1\right)$. The corresponding local response is ${conv}_{K_i}\left(X\right)=x_i$, but this response is not used to restrict rule applicability in the construction.

For every firing rule $r:E/a^c\to a^p;0$ in $R_i$, introduce in the CK–SN P rule set $R_i^{CK}$ the rule $\tilde{r}:(E/a^c\to a^p;0)[\top ,\top ,s_0].$ For every forgetting rule $r:a^s\to \lambda$ in $R_i$, introduce in $R_i^{CK}$ the rule $\tilde{r}:(a^s/a^s\to a^0;0)[\top ,\top ,s_0].$ Thus, classical forgetting rules are represented as the case $p=0$, with the exact spike-count condition encoded by the regular-expression component. Equivalently, each translated rule has the CK–SN P components $d=0$, $g^{loc}=\top$, $g^{conv}=\top$, and scenario label $s_0$, with $\mathsf{S}\left(t\right)=\left\{s_0\right\}$ for every $t\in \mathbb{N}$. The local guard ⊤ and the convolutive guard ⊤ are true for every configuration, and the scenario label $s_0$ is active at every time step.

We next compare rule applicability. In the delay-free extended $\mathrm{SN}\mathrm{P}$ system, a firing rule $r:E/a^c\to a^p;0$ is applicable in neuron i at configuration $X_t$ if and only if $x_i\left(t\right)\ge c\mathrm{and}{a}^{x_i\left(t\right)}\in L\left(E\right).$ In the constructed $\mathrm{CK}‒\mathrm{SN}\mathrm{P}$ system, the translated rule $\tilde{r}$ is applicable if and only if the same consumption and regular-expression conditions hold, and the two guards and the scenario condition are satisfied. By construction, the guards are always true and $s_0\in \mathsf{S}\left(t\right)$ for all t. Therefore, every firing rule is applicable in $\Pi$ if and only if its translated CK–SN P rule is applicable in ${\Pi }_{CK}$.

For a forgetting rule $r:a^s\to \lambda$, the rule is applicable in the source $\mathrm{SN}\mathrm{P}$ system exactly when the neuron contains s spikes. In the translated CK–SN P rule $\tilde{r}:(a^s/a^s\to a^0;0)[\top ,\top ,s_0],$ applicability requires $x_i\left(t\right)\ge s$ and $a^{x_i\left(t\right)}\in L\left(a^s\right)$, which is equivalent to $x_i\left(t\right)=s$. Hence, the translated forgetting rule is applicable exactly in the same configurations as the original forgetting rule. Since $p=0$, no spikes are emitted, and the consumption of s spikes has the same effect as the forgetting rule $a^s\to \lambda$. Consequently, for every neuron, every time step, and every configuration, each rule in $\Pi$ is applicable if and only if its translated rule is applicable in ${\Pi }_{CK}$. Consider now any global rule selection in $\Pi$, containing at most one selected applicable rule per neuron according to the fixed local rule-selection policy. By the applicability equivalence above, the corresponding set of translated rules is a valid global selection in ${\Pi }_{CK}$. Conversely, every global selection in ${\Pi }_{CK}$ corresponds to a global selection in $\Pi$. The two systems use the same local rule-selection policy, so the correspondence is between matched local choices.

For corresponding selections, the consumed spike numbers, emitted spike numbers, and synaptic targets are identical. Hence, for each neuron j, the next spike count is computed in both systems by the delay-free transition update (23), with $c_j\left(t\right)=0$ and $p_j\left(t\right)=0$ when no rule is selected in neuron j, and with $p_i\left(t\right)=0$ for translated forgetting rules. By induction on t, the two systems generate the same spike configuration after every finite number of steps under corresponding local selections. The base case holds because both systems have the same initial vector $X_0$. The induction step follows from the equality of applicable rule sets and from the shared delay-free transition update (23). Since the output neuron is also the same, the output behavior is preserved.    □

Remark 1

(Direction of the conservativity statement). The previous theorem is a one-directional embedding result: every delay-free extended $\mathrm{SN}\mathrm{P}$ system can be represented as a CK–SN P system by choosing trivial local guards, trivial convolutive guards, and a scenario label that is always active. The theorem does not assert that every CK–SN P system can be simulated step-by-step by a standard extended $\mathrm{SN}\mathrm{P}$ system without additional assumptions. Non-trivial CK–SN P guards may depend on ordered neighborhoods and finite kernel responses involving several neurons. Encoding such guards inside a standard extended $\mathrm{SN}\mathrm{P}$ formalism may require bounded-state assumptions, auxiliary control components, or an extended guard language. This distinction aligns with the role of CK–SN P systems as an explicit formalization of local guarded feature computation.

Remark 2

(Scope of the extension). The conservativity result shows that delay-free extended $\mathrm{SN}\mathrm{P}$ systems are contained in the CK–SN P framework when the local and convolutive guards are trivial. Conversely, finite local tests induced by CK–SN P kernels may be encoded indirectly in sufficiently expressive guarded variants of P systems, provided that the corresponding threshold and neighborhood conditions are available in the guard language or are represented by auxiliary objects and rules. The distinction is therefore not stated as an unconditional increase in computational power. Rather, the distinction lies in the modeling level: CK–SN P systems make the local weighted response an explicit component of rule applicability, whereas an indirect simulation may distribute the same condition across auxiliary encodings. This distinction is relevant for inspection, descriptional size, and reproducible feature extraction.

This result identifies the proposed construction as an extension rather than a replacement of the classical delay-free rule mechanism. The additional components become active only when non-trivial neighborhoods, kernels, guards, or scenarios are selected. Consequently, formal properties that depend only on the embedded delay-free transition structure are inherited by the trivial-guard subclass of CK–SN P systems.

5.3. Representation Within Kernel P Systems

The relation with kernel P systems is stated under explicit guard-expressibility assumptions. The representation result below is conditional on the ability of the selected $\mathrm{kP}$ formalism to express the required regular-expression, local, scenario, and convolutive guards. The statement does not claim that every possible numerical guard can be represented in every $\mathrm{kP}$ variant. When scenario labels vary with time, the active scenario set is treated as part of the encoded control state or is generated by a finite scenario-control mechanism. The term behavior-preserving is used in an operational sense: the translated $\mathrm{kP}$ system preserves the encoded spike configurations and the output behavior of the original delay-free CK–SN P system under the same initial configuration and corresponding rule-selection choices.

Definition 10

($\mathrm{kP}$-guard-expressible predicate). A predicate g over encoded spike configurations is $\mathrm{kP}$-guard-expressible if there exists a $\mathrm{kP}$ guard $g^{kP}$ such that, for every encoded configuration C,

$$g\left(C\right)=\mathrm{true}⟺g^{kP}\left(C\right)=\mathrm{true}.$$

(28)

Finite Boolean combinations of inequalities over spike multiplicities and finite weighted sums are directly expressible when arithmetic guards are available. If the target $\mathrm{kP}$ variant allows only simpler guards, auxiliary objects and compartments may be used to represent intermediate weighted sums. Predicates involving non-linear real-valued transformations, externally learned functions, or numerical procedures not encoded by finite guards are outside the direct $\mathrm{kP}$-guard-expressible fragment unless an explicit discretization or auxiliary encoding is provided.

Theorem 2

(Behavior-preserving $\mathrm{kP}$ representation). Let ${\Pi }_{CK}$ be a finite delay-free $\mathrm{CK}‒\mathrm{SN}\mathrm{P}$ system such that every regular-expression condition, local guard, scenario guard, and convolutive predicate used in ${\Pi }_{CK}$ is $\mathrm{kP}$-guard-expressible. Then there exists a kernel P system $k{\Pi }_{CK}$ that preserves the encoded spike configurations and the output behavior of ${\Pi }_{CK}$ under corresponding rule-selection choices.

Proof. 

For each neuron ${\sigma }_i=(n_i,R_i)$ of ${\Pi }_{CK}$, create a $\mathrm{kP}$ compartment $C_i$ whose initial multiset is $a^{n_i}$. The spike count of neuron i is therefore represented by the multiplicity of a in compartment $C_i$. For each delay-free $\mathrm{CK}‒\mathrm{SN}\mathrm{P}$ rule

$$r:(E/a^c\to a^p;0)[g^{loc},g^{conv},s]\in R_i,$$

(29)

create a corresponding $\mathrm{kP}$ rule in compartment $C_i$ with guard

$$g_r=g_E\wedge g_c\wedge g^{loc}\wedge g^{conv}\wedge g_s.$$

(30)

Here, $g_E$ encodes the regular-expression condition $a^{x_i}\in L\left(E\right)$, $g_c$ encodes the consumption condition $x_i\ge c$, and $g_s$ encodes the scenario condition $s\in \mathsf{S}\left(t\right)$ using the encoded scenario-control state. By assumption, the regular-expression condition, the local guard, the scenario guard, and the convolutive predicate are $\mathrm{kP}$-guard-expressible; the finite consumption condition is also expressible as a multiplicity guard. The translated rule consumes $a^c$ from $C_i$. For each synaptic target j such that $(i,j)\in syn$, the rule produces $a^p$ in the compartment $C_j$, using the communication mechanism of the selected $\mathrm{kP}$ formalism. If the formalism represents target-specific outputs by auxiliary rules or objects, these are introduced as part of the same finite rule-level encoding. For any configuration of ${\Pi }_{CK}$, encode the spike vector as the corresponding multiset configuration of the $\mathrm{kP}$ system. A $\mathrm{CK}‒\mathrm{SN}\mathrm{P}$ rule is applicable exactly when the corresponding $\mathrm{kP}$ guard $g_r$ is satisfied. Hence every global delay-free step of ${\Pi }_{CK}$ has a matching $\mathrm{kP}$ step with the same consumption and transmission effects. Conversely, every enabled translated $\mathrm{kP}$ rule satisfies the same regular-expression, consumption, local, convolutive, and scenario conditions, and therefore corresponds to an applicable $\mathrm{CK}‒\mathrm{SN}\mathrm{P}$ rule. Thus, corresponding rule selections generate corresponding successor configurations. By induction over computation length, the translated $\mathrm{kP}$ system preserves the sequence of encoded spike configurations and the output behavior of ${\Pi }_{CK}$.    □

Example 2

(Three-neuron translation into a guarded $\mathrm{kP}$ rule). Consider a delay-free $\mathrm{CK}‒\mathrm{SN}\mathrm{P}$ system with three neurons $V=\{1,2,3\}$ and one synapse $(1,2)\in syn$. Let the spike configuration be $X=(x_1,x_2,x_3)\in {\mathbb{N}}^3.$ For neuron 1, consider the ordered neighborhood $N\left(1\right)=(1,2,3)$ and the finite kernel $K_1=(1,-1,0).$ The associated local response is ${conv}_{K_1}\left(X\right)=1·x_1+(-1)·x_2+0·x_3=x_1-x_2.$ Thus, the convolutive predicate ${conv}_{K_1}\left(X\right)\ge 0$ is equivalent to the finite local comparison $x_1\ge x_2$.

Assume that neuron 1 contains the delay-free rule $r:E/a^2\to a;0[\top ,{conv}_{K_1}\left(X\right)\ge 0,s_{\mathrm{local}}],$ where E is a regular expression over $\left\{a\right\}$. This rule is applicable at time t when $x_1\left(t\right)\ge 2,a^{x_1\left(t\right)}\in L\left(E\right),x_1\left(t\right)\ge x_2\left(t\right),s_{\mathrm{local}}\in \mathsf{S}\left(t\right).$

We now construct the corresponding guarded $\mathrm{kP}$ representation under the assumption that the selected $\mathrm{kP}$ variant can compare finite linear expressions over object multiplicities. Let $C_1,C_2,C_3$be the compartments corresponding to neurons $1,2,3$, and let ${\#}_a\left(C_i\right)$ denote the number of objects a in compartment $C_i$. The encoded configuration satisfies ${\#}_a\left(C_i\right)=x_i,i=1,2,3.$ The translated $\mathrm{kP}$ rule is placed in compartment $C_1$. It consumes two copies of a from $C_1$ and sends one copy of a to $C_2$, with guard $g_r^{\mathrm{kP}}=g_E\wedge ({\#}_a\left(C_1\right)\ge 2)\wedge ({\#}_a\left(C_1\right)-{\#}_a\left(C_2\right)\ge 0)\wedge (s_{\mathrm{local}}\in \mathsf{S}\left(t\right)).$ Here, $g_E$ encodes the regular-expression condition $a^{{\#}_a\left(C_1\right)}\in L\left(E\right)$, the second conjunct encodes the consumption condition, the third conjunct encodes the convolutive predicate ${conv}_{K_1}\left(X\right)\ge 0$, and the last conjunct encodes the active scenario label. For any encoded configuration, the CK–SN P rule r is applicable if and only if the $\mathrm{kP}$ guard $g_r^{\mathrm{kP}}$ is true. When the rule is applied, both systems perform the same local update: $(x_1,x_2,x_3)⟼(x_1-2,x_2+1,x_3).$ For example, if $X=(3,2,0)$, $s_{\mathrm{local}}\in \mathsf{S}\left(t\right)$, and $a^3\in L\left(E\right)$, then ${conv}_{K_1}\left(X\right)=3-2=1\ge 0,$ so the CK–SN P rule is applicable. In the $\mathrm{kP}$ representation, the same local condition is captured by ${\#}_a\left(C_1\right)-{\#}_a\left(C_2\right)=1\ge 0.$ Thus, in this example, the finite convolutive predicate is represented as an explicit conjunct of the $\mathrm{kP}$ guard, while the spike consumption and synaptic transmission are represented by the corresponding $\mathrm{kP}$ rule action.

The example illustrates the rule-level mechanism of the translation. The general statement remains conditional on the guard-expressibility assumption: a CK–SN P convolutive predicate can be represented in the selected $\mathrm{kP}$ formalism only when the corresponding finite Boolean combination of linear multiplicity tests is available in, or encoded by, the target guard language. Thus, the theorem is a conditional representation result. When the guard language is sufficiently expressive, the CK–SN P transition can be mirrored at the rule level. When the guard language is not sufficiently expressive, an auxiliary encoding or a restricted predicate fragment must be specified before the representation can be applied.

Proposition 5

(Descriptional size of the direct representation). Let

$$R={\displaystyle \sum _{i=1}^m}|R_i|,q=\underset{i}{max}\left|N\left(i\right)\right|,\ell =\underset{r}{max}|\mathrm{Atoms}\left(g_r^{conv}\right)|,\Delta =\underset{i}{max}\left|\{j\in V\mid (i,j)\in syn\}\right|.$$

(31)

Here, $\mathrm{Atoms}\left(g_r^{conv}\right)$ denotes the set of atomic convolutive comparisons occurring in the guard of rule r. If convolutive predicates are encoded directly as guards, the representation introduces one $\mathrm{kP}$ rule for each $\mathrm{CK}‒\mathrm{SN}\mathrm{P}$ rule, together with target information for the outgoing spike transmissions. If auxiliary objects or compartments are required to represent weighted sums, a direct non-optimized expansion of all atomic kernel terms and outgoing transmissions has size $O\left(R\right(q\ell +\Delta \left)\right)$.

Proof. 

The rule-level translation maps each $\mathrm{CK}‒\mathrm{SN}\mathrm{P}$ rule to one guarded $\mathrm{kP}$ rule, so the number of primary translated rules is R. For a rule r, the convolutive guard contains at most ℓ atomic comparisons. Each atomic comparison refers to a finite kernel response over at most q ordered neighborhood positions. A direct explicit representation of all atomic kernel terms therefore requires at most a constant number of auxiliary elements per kernel position and per atomic comparison. This gives a contribution of order $O(Rq\ell )$. This bound refers to the direct non-optimized encoding in which each atomic comparison is expanded independently. In addition, the translated rule must represent the outgoing spike transmissions to the synaptic targets of the source neuron. The number of such targets is at most $\Delta$ for each rule, giving an additional contribution of order $O(R\Delta )$ when target-specific outputs are counted explicitly. Combining the two contributions gives $O\left(R\right(q\ell +\Delta \left)\right)$.    □

The formal results in this section clarify the scope of the model. Finite branching follows from finite rule sets and finite scenario-controlled selection. Determinism can be obtained by mutually exclusive applicability predicates. Bounded systems have finite reachable state spaces. Delay-free extended $\mathrm{SN}\mathrm{P}$ systems are recovered as a special case. Finally, finite delay-free $\mathrm{CK}‒\mathrm{SN}\mathrm{P}$ systems can be represented through $\mathrm{kP}$ guards when the required predicates are expressible. These statements provide a formal basis for the differentiable realization and the experimental protocol introduced in the next section.

6. Materials and Methods: Trainable Realization and Reproducible Experimental Protocol

This section describes the trainable realization of the proposed $\mathrm{CK}‒\mathrm{SN}\mathrm{P}$ model and the experimental protocol used for ECG beat classification. The implementation remains close to the formal model while supporting a reproducible empirical comparison. The formal system is discrete, whereas supervised learning requires differentiable operations during optimization. For this reason, the implementation uses soft surrogate predicates during training and hard predicates during inference or ablation. The protocol records the dataset split, preprocessing, compared methods, ablation variants, metrics, checkpoint selection, and table-regeneration procedure. Figure 3 summarizes how the formal and empirical parts of the paper are connected. The diagram separates the support for formal claims from the support for empirical claims: formal claims are based on definitions and representation results, whereas empirical claims are tied to fixed splits, declared metrics, and documented experimental settings.

6.1. Differentiable Realization of CK–SN P Rules

Let X denote the spike-like representation of an input window. For a kernel K and threshold $\theta$, the margin of a local convolutive predicate is written as

$$z_K\left(X\right)={conv}_K\left(X\right)-\theta .$$

(32)

During training, the hard predicate $z_K\left(X\right)\ge 0$ is replaced by a differentiable surrogate spike

$$\tilde{s}\left(z_K\right)=\sigma \left(\beta z_K\right)={\displaystyle \frac{1}{1+exp(-\beta z_K)}},$$

(33)

where $\beta >0$ controls the slope. A smaller value of $\beta$ gives a smoother predicate and may support optimization, while a larger value approaches a crisp threshold. During hard-rule inference, the surrogate is replaced by

$$HardSpike\left(z_K\right)=\left\{\begin{array}{cc}1,\hfill & z_K\ge 0,\hfill \\ 0,\hfill & z_K<0.\hfill \end{array}\right.$$

(34)

The surrogate form is used only during optimization, where a differentiable approximation is needed for gradient-based training. During validation and final testing, the saved model is evaluated through the declared inference mode. In hard-rule mode, the guard output is binarized and the rule applicability condition is evaluated as a Boolean predicate, matching the formal interpretation of guarded spike-rule activation. The surrogate slope and threshold parameters therefore affect the optimization trajectory, but the reported hard-rule predictions are generated from the corresponding discrete decision rule. Thus, the soft-to-hard transition is treated as a change in evaluation mode rather than as a change in the formal rule.

In this implementation, the trainable layer is a parameterized realization of the CK–SN P rule family. During optimization, surrogate gates provide differentiable approximations of the local and convolutive predicates. During hard-rule inference, the learned or selected local responses are evaluated through the declared threshold relations, and the resulting Boolean conditions determine rule activation in the sense of the formal CK–SN P applicability definition. The empirical architecture therefore instantiates the finite guarded-rule mechanism described in the formal model, while the downstream classifier operates on the descriptors generated by this mechanism. The differentiable realization also makes the sensitivity of kernel-based guards explicit.

A small perturbation of a kernel weight may change the value of the local kernel response (14), and may therefore change the truth value of a threshold predicate when the response is close to its threshold. In the surrogate training phase, this effect is smoothed by the differentiable approximation of the guard. In the hard-rule inference mode, the same effect becomes discrete because the predicate is evaluated as a Boolean condition. For this reason, validation-based checkpoint selection and fixed saved predictions are used in the empirical reporting. A dedicated perturbation analysis of learned or selected kernels is left as a separate robustness study. In the ECG implementation, each beat is represented as a one-dimensional signal window. The trainable CK–SN P realization uses four stages. First, the beat is normalized and encoded into spike-like local features. Second, multi-scale one-dimensional kernels compute local responses over short temporal neighborhoods. Third, soft local predicates activate rule-like features under scenario control. Fourth, a compact classifier head maps the resulting representation to the three AAMI classes $\mathrm{N}$, $\mathrm{S}$, and $\mathrm{V}$. The trainable realization is intentionally compact so that the effect of local kernels, guards, scenario control, and hard inference can be examined through ablations.

Figure 4 summarizes the empirical CK–SN P ECG classification architecture, showing how local descriptors, kernel responses, guard evaluation, and downstream classification are combined in the implemented pipeline.

The main neural CK–SN P variants used in the current implementation are defined by the following design dimensions:

$$\mathcal{D}=\{\mathrm{kernel}\mathrm{type},\mathrm{guard}\mathrm{type},\mathrm{scenario}\mathrm{control},\mathrm{auxiliary}S\mathrm{head},\mathrm{inference}\mathrm{mode}\}.$$

(35)

The kernel type may be fixed, contrast-initialized, or learned. The guard type may be soft, hard, or removed. Scenario control may be active or ablated. The auxiliary $\mathrm{S}$ head is used only during training to support minority-class recognition. The inference mode can use soft surrogate outputs or crisp predicates. These dimensions define the ablation variants reported in Section 7.

The training objective combines a class-imbalance-aware classification loss with regularization terms that discourage degenerate predictions. Let $f_{\theta }\left(x_b\right)$ be the logits produced for beat $x_b$ and let $y_b\in \{\mathrm{N},\mathrm{S},\mathrm{V}\}$ be the class label. The balanced empirical loss used during training has the form

$$\mathcal{L}\left(\theta \right)={\displaystyle \frac{1}{B}}{\displaystyle \sum _{b=1}^B}{w}_{y_b}\ell (f_{\theta }\left(x_b\right),y_b)+{\lambda }_{\mathrm{aux}}{\mathcal{L}}_{\mathrm{S}}+{\lambda }_{\mathrm{reg}}{\mathcal{R}}_{\mathrm{spike}},$$

(36)

where B is the mini-batch size, $w_{y_b}$ is the class weight, ℓ is the classification loss, ${\mathcal{L}}_{\mathrm{S}}$ is an auxiliary loss for $\mathrm{S}$ versus non-$\mathrm{S}$ detection when enabled, and ${\mathcal{R}}_{\mathrm{spike}}$ is a spike or activation regularization term. The coefficients ${\lambda }_{\mathrm{aux}}$ and ${\lambda }_{\mathrm{reg}}$ are stored in the configuration files. The auxiliary term is not used as a separate test-time classifier unless explicitly stated; its role is to guide representation learning during training. Algorithm 2 gives the training and evaluation sequence. The same procedure is used for the proposed models and for their ablation variants, with the appropriate configuration fields changed. The selected checkpoint is evaluated once on the held-out test partition.

Training stability is assessed through the validation-based checkpointing procedure rather than through a formal convergence guarantee. During training, each epoch updates the surrogate-guard realization on $D_{\mathrm{train}}$ and evaluates the current checkpoint on $D_{\mathrm{val}}$. The stored checkpoint is the one selected by validation macro-F1, balanced accuracy, and class-wise stability criteria. This procedure is used to reduce the influence of transient optimization states on the final DS2 report. Since the model combines surrogate guards, class-imbalance-aware loss terms, and downstream classifier components, the reported experiment documents empirical training stability under the declared seeds and settings, but does not claim theoretical convergence of the non-convex training objective.

Algorithm 2 Training and hard-rule evaluation of a differentiable $\mathrm{CK}‒\mathrm{SN}\mathrm{P}$ classifier

Require:  Training set $D_{\mathrm{train}}$, validation set $D_{\mathrm{val}}$, test set $D_{\mathrm{test}}$, kernels K, thresholds $\theta$, slope $\beta$, model configuration $\mathsf{\Omega }$ Ensure:  Test-set outputs, metrics, confusion-matrix summary, and run metadata   1: Initialize kernels, thresholds, classifier weights, scenario parameters, and regularization coefficients from $\mathsf{\Omega }$   2: for epoch $=1$ to E do   3:    for mini-batch $B\subset D_{\mathrm{train}}$ do   4:      Encode each beat as spike-like local features   5:      Compute local responses ${conv}_K\left(X\right)$ for all active kernels   6:      Compute soft predicates using Equation (33)   7:      Propagate through scenario-controlled rule layers   8:      Compute the training loss in Equation (36)   9:      Update trainable parameters by backpropagation 10:    end for 11:    Evaluate the checkpoint on $D_{\mathrm{val}}$ 12:    Store the checkpoint selected by validation macro-F1, balanced accuracy, and class-wise stability criteria 13: end for 14: Evaluate the selected checkpoint on $D_{\mathrm{test}}$ 15: If hard inference is enabled, replace soft predicates by Equation (34) 16: Compute test-set outputs, confusion-matrix summary, class-wise metrics, runtime information, and configuration metadata 17: return Reported metrics and run metadata for tabular summary

6.2. Dataset, Preprocessing, and Patient-Independent Evaluation Setting

The empirical component uses the MIT-BIH Arrhythmia Database under a patient-independent DS1/DS2 protocol. The classification problem follows the three-class AAMI setting introduced in Section 3. The ECG class set is defined by the ECG class set (4), and the beat-symbol grouping is defined by the AAMI-style beat-symbol mapping (5). This grouping follows the common AAMI-oriented evaluation practice in arrhythmia beat classification, where beat annotations are consolidated into clinically meaningful groups to reduce annotation granularity and to support patient-independent comparison. The mapping is used only for evaluation consistency and does not imply that all subclasses inside a group have identical morphology. Fusion beats and unknown or unclassifiable beats are excluded from training, validation, testing, confusion matrices, and metric computation. The dataset partition follows the patient-independent DS1/DS2 split (6). DS1 is used for training and validation, while DS2 is reserved for testing. The record lists are

$$\begin{array}{cc}\hfill DS1=& \{101,106,108,109,112,114,115,116,118,119,122,124,\hfill \\ & 201,203,205,207,208,209,215,220,223,230\},\hfill \end{array}$$

(37)

$$\begin{array}{cc}\hfill DS2=& \{100,103,105,111,113,117,121,123,200,202,210,212,\hfill \\ & 213,214,219,221,222,228,231,232,233,234\}.\hfill \end{array}$$

(38)

The final reported setting is the full-mode experiment. In this configuration, the training and validation subsets are derived from DS1, and the complete DS2 subset is used for patient-independent testing.

Table 3. Full-mode MIT-BIH DS1/DS2 distribution used in the main experiment.

Split	$\mathbf{N}$	$\mathbf{S}$	$\mathbf{V}$	Total
Training DS1	36,681	755	3030	40,466
Validation DS1	9170	189	758	10,117
Test DS2	44,242	1837	3220	49,299

reports the corresponding class distribution.

The DS1/DS2 split is record-based and patient-independent, not a random proportional beat-level split. Consequently, the number of beats in the held-out DS2 partition can be larger than the number of beats used for training. This distribution is kept intentionally because the evaluation prioritizes separation between training and test records over equal split sizes, thereby reducing patient leakage.

Each beat is represented by a fixed-length local waveform window together with RR-derived information. The CK–SN P representation used in the full-mode run contains 409 features after combining kernel-response descriptors with RR, Gaussian, and Fourier components. This configuration is used for the main experimental reporting.

A second full-mode configuration is included as a complementary reduced-data analysis. It uses $50\%$ sampling for the majority-class components while preserving the supraventricular class through stratified S-safe sampling. The resulting reduced-data distribution is reported in

Table 4. Reduced-data 50% full-mode distribution used for complementary analysis.

Split	$\mathbf{N}$	$\mathbf{S}$	$\mathbf{V}$	Total
Training DS1	18,341	755	1515	20,611
Validation DS1	4585	189	379	5153
Test DS2	22,121	1837	1610	25,568

. This setting is not used as a replacement for the complete-data experiment or as a substitute for cross-validation. It is reported to describe the behavior of the same modeling pipeline under a controlled change in the class distribution. A standard beat-level 5-fold split is not used as the main protocol because such a split could weaken the patient-independent DS1/DS2 separation if beats from the same records were distributed across folds.

The distinction between the complete-data experiment and the reduced-data analysis is maintained throughout the reporting. The complete DS1/DS2 run is the main evaluation setting, while the 50% setting serves only as an additional view of the representation under a controlled change in the class distribution.

6.3. Compared Baselines and Ablation Variants

The comparison is organized into three groups. The first group contains raw RR baselines. These methods operate on the beat and RR representation without the proposed CK–SN P kernel-response descriptors. They include Logistic Regression, calibrated Linear SVM, k-Nearest Neighbors, Random Forest, and Extra Trees. The second group contains CK–SN P feature pipelines combined with classical classifiers. These models use the proposed local kernel-bank representation together with RR, Gaussian, and Fourier descriptors. The resulting features are evaluated with Logistic Regression, Random Forest, Extra Trees, and Histogram-based Gradient Boosting. These rows are denoted by CKSNP_RR_GaussFourier_*. The third group contains neural and S-aware CK–SN P variants. This group also includes a lightweight one-dimensional convolutional baseline, reported as Light_1D_CNN_RR_SAwareLoss. This model is evaluated under the same patient-independent DS1/DS2 protocol and the same two-seed reporting scheme as the other full-mode methods. Its role is to provide a direct lightweight 1D-CNN comparison within the declared experimental protocol, while broader comparisons with recent deep sequence architectures are left for future work. The remaining S-aware rows are retained for component analysis. They examine the contribution of RR information, Gaussian/Fourier descriptors, hard-slope variants, and S-aware loss shaping within the proposed representation. These rows are interpreted as component-level analyses of the implemented feature pipeline and classifier interaction, not as isolated causal estimates of each formal component. This organization separates the formal contribution from the downstream classifier choice. The CK–SN P model defines the local feature-computation mechanism, while the classifier placed on top of the extracted representation determines one possible empirical realization of that mechanism.

6.4. Evaluation Metrics, Training Procedure, and Reproducible Reporting

The evaluation reports accuracy, balanced accuracy, macro-F1, per-class F1 scores, sensitivity for the supraventricular class when available, Matthews correlation coefficient (MCC), Cohen’s kappa, and runtime. Macro-F1 and balanced accuracy are reported together with accuracy because the three-class ECG problem is imbalanced and because the $\mathrm{S}$ class contains fewer samples than the $\mathrm{N}$ class. Accuracy describes the global rate of correct predictions, while macro-F1, balanced accuracy, and per-class scores provide additional information about class-level behavior. For a given random seed, the selected checkpoint is chosen using validation metrics. In the CK–SN P implementation, the checkpoint criterion combines macro-F1, balanced accuracy, and class-wise information. This choice avoids reporting a model only through a single aggregate metric. The final test metrics are computed on DS2 after checkpoint selection. The final tables report mean values across seeds 2026 and 3170. The main experiment is executed in full mode with FAST_MODE=False and FULL_DATA_PERCENT=100.0. The complementary reduced-data setting is also executed in full mode, with FULL_DATA_PERCENT=50.0 and stratified_s_safe sampling. Bootstrap confidence intervals are reported for the selected full-mode artifacts when available.

The experiments were executed in Python 3.12.7 on Microsoft Windows 11 in CPU mode. The implementation uses NumPy and pandas for numerical and tabular processing, WFDB for access to the MIT-BIH records when available, scikit-learn for preprocessing, classical classifiers, and metric computation, and PyTorch 2.10.0+cpu for the S-aware neural components when enabled. The hardware platform was a workstation equipped with an AMD Ryzen 7 PRO 8700 G processor with 8 cores and 16 threads, integrated AMD Radeon 780 M graphics, 32 GB RAM, and a 512 GB SSD. The reported experiments are documented through the declared random seeds, command-line parameters, configuration fields, dataset distributions, kernel-bank description, feature-name information, runtime summaries, and the numerical tables included in the manuscript. The reporting keeps formal claims and empirical observations separated. The formal sections define the CK–SN P model and its semantics. The empirical sections describe how the resulting local responses behave under the specified DS1/DS2 protocol and under the reduced-data complementary setting. The numerical outcomes obtained under these settings are reported and discussed in Section 7, where the complete-data full-mode experiment and the complementary reduced-data analysis are presented separately.

7. Results and Discussion

This section reports the full-mode experimental results obtained under the patient-independent MIT-BIH DS1/DS2 protocol. The complete-data setting serves as the main evaluation. The 50% full-mode setting is reported separately as a complementary reduced-data analysis. All aggregate values are means across seeds 2026 and 3170 unless otherwise specified. The reported tables summarize the metrics, confusion-matrix information, runtime records, and configuration settings for the declared experimental runs. The empirical objective is to evaluate whether CK–SN P local responses can serve as structured, finite, and reproducible descriptors under the declared ECG protocol. The experiments are not intended as a complete benchmark against all contemporary ECG architectures; rather, they assess how the proposed formal feature mechanism behaves when combined with tabular classifiers and S-aware neural variants.

7.1. Full-Mode Results on the Complete DS2 Test Set

Table 5. Full-mode comparison on the complete DS2 test set. Values are means across seeds 2026 and 3170.

Model	Seeds	Acc.	BAcc	Macro-F1	$\mathit{F}{1}_{\mathbf{N}}$	$\mathit{F}{1}_{\mathbf{S}}$	$\mathit{F}{1}_{\mathbf{V}}$	MCC	Kappa
CKSNP_RR_GaussFourier_HGB	2	0.9418	0.6714	0.6829	0.9683	0.1498	0.9305	0.6694	0.6657
CKSNP_RR_GaussFourier_RF	2	0.9214	0.6455	0.6603	0.9566	0.1106	0.9136	0.5757	0.5754
CKSNP_RR_GaussFourier_ExtraTrees	2	0.9208	0.6484	0.6590	0.9563	0.1106	0.9102	0.5761	0.5760
RandomForest_raw_RR	2	0.9483	0.6026	0.6252	0.9724	0.0350	0.8682	0.6892	0.6509
ExtraTrees_raw_RR	2	0.9450	0.6026	0.6056	0.9744	0.0457	0.7968	0.6709	0.6498
CKSNP_SAware_RR_noFourier	2	0.8452	0.6965	0.6050	0.9112	0.1382	0.7654	0.4699	0.4370
CKSNP_SAware_RR_GaussFourier_hardSlope	2	0.8603	0.6801	0.6037	0.9208	0.1251	0.7652	0.4767	0.4535
CKSNP_RR_GaussFourier_LogReg	2	0.8056	0.7019	0.5868	0.8843	0.1476	0.7284	0.4192	0.3715
LinearSVM_calibrated_raw_RR	2	0.9262	0.6065	0.5844	0.9636	0.0672	0.7225	0.5844	0.5802
Light_1D_CNN_RR_SAwareLoss	2	0.8738	0.6643	0.5810	0.9328	0.1416	0.6686	0.5222	0.4992
CKSNP_SAware_RR_GaussFourier	2	0.8065	0.6692	0.5734	0.8855	0.1061	0.7287	0.4054	0.3620
kNN_raw_RR	2	0.9058	0.6234	0.5704	0.9571	0.0925	0.6615	0.5534	0.5484

reports the complete-data full-mode comparison on DS2. Under macro-F1 as the primary summary metric, CKSNP_RR_GaussFourier_HGB is the reference row for this table, with accuracy $0.9418$, balanced accuracy $0.6714$, macro-F1 $0.6829$, $F{1}_{\mathrm{N}}=0.9683$, $F{1}_{\mathrm{S}}=0.1498$, and $F{1}_{\mathrm{V}}=0.9305$. The bootstrap 95% confidence interval for macro-F1, computed under the corresponding full-mode setting, is $[0.6771,0.6903]$.

The row Light_1D_CNN_RR_SAwareLoss gives the direct lightweight 1D-CNN baseline under the same DS2 test protocol. It provides a neural reference point for the proposed feature-based pipeline. The comparison should be read together with the class-wise metrics, since the methods differ in their accuracy, balanced-accuracy, macro-F1, and minority-class behavior.

The table shows several metric-dependent trade-offs. The raw tree baselines obtain higher accuracy values, whereas the CK–SN P Gaussian/Fourier rows highlight different behavior in macro-F1, balanced accuracy, and per-class F1 scores. Since macro-F1 is the primary summary metric in this study, the HGB row using CK–SN P RR Gaussian/Fourier features serves as the reference row for the complete-data experiment. The class-level values are relevant for interpretation. Several rows obtain higher F1 values for normal and ventricular beats. Supraventricular beats require explicit class-level reporting in the patient-independent evaluation. This observation is compatible with the class distribution and with the overlap that may occur between minority supraventricular patterns and other ECG morphologies in inter-patient evaluation. For this reason, the table reports $F{1}_{\mathrm{S}}$ explicitly instead of relying only on accuracy or macro-F1. From the perspective of the proposed representation, the $\mathrm{S}$ class is relevant because its distinction from normal beats may depend on local waveform morphology together with RR context. The CK–SN P local responses expose finite neighborhood-level contrasts as explicit descriptors, while RR, Gaussian, and Fourier components provide complementary temporal and shape information. The reported $\mathrm{S}$-class values should therefore be read as part of the class-level profile of the combined representation. They also indicate that supraventricular beat recognition remains a difficult component of the patient-independent setting and should not be interpreted as a standalone clinical assessment. The logistic-regression CK–SN P row has a higher balanced-accuracy value than the other rows in Table 5. This indicates that different classifier choices lead to different metric profiles. For this reason, balanced accuracy and per-class scores are reported together with macro-F1 rather than treated as secondary observations.

The comparison with raw-RR baselines provides quantitative context for the added descriptor set. For example, the CK–SN P RR Gaussian/Fourier HGB row has a higher macro-F1 than the raw-RR tree baselines under the same complete DS2 protocol. This difference is interpreted as evidence for the usefulness of the combined descriptor representation in the declared setting, rather than as an isolated attribution to a single component.

7.2. Complementary 50% Full-Mode Analysis

Table 6. Reduced-data 50% full-mode analysis. Values are means across seeds 2026 and 3170.

Model	Seeds	Acc.	BAcc	Macro-F1	$\mathit{F}{1}_{\mathbf{N}}$	$\mathit{F}{1}_{\mathbf{S}}$	$\mathit{F}{1}_{\mathbf{V}}$	Sens.S	MCC
CKSNP_RR_GaussFourier_HGB	2	0.8994	0.6760	0.6850	0.9435	0.1850	0.9265	0.1462	0.5443
CKSNP_RR_GaussFourier_ExtraTrees	2	0.8915	0.6506	0.6676	0.9387	0.1588	0.9053	0.1279	0.5042
CKSNP_RR_GaussFourier_RF	2	0.8907	0.6396	0.6643	0.9383	0.1588	0.8958	0.1279	0.4949
RandomForest_raw_RR	2	0.9125	0.5990	0.6157	0.9535	0.0564	0.8372	0.0299	0.5752
Light_1D_CNN_RR_SAwareLoss	2	0.8730	0.6719	0.6134	0.9287	0.1912	0.7203	0.1353	0.4894
CKSNP_RR_GaussFourier_LogReg	2	0.7829	0.7019	0.6121	0.8675	0.2209	0.7479	0.3571	0.3855
CKSNP_SAware_RR_noFourier	2	0.7969	0.6800	0.6113	0.8795	0.1652	0.7894	0.2431	0.3837
CKSNP_SAware_RR_GaussFourier_hardSlope	2	0.8151	0.6968	0.6050	0.8898	0.2256	0.6996	0.2673	0.4152

reports the reduced-data full-mode analysis. This setting preserves the supraventricular class and samples the remaining classes with a stratified S-safe strategy. It examines the same modelling choices under a modified class distribution.

The 50% analysis does not replace the complete-data evaluation. It provides an additional view of the same feature-generation pipeline under a sampling regime that preserves the minority class while reducing the number of majority-class samples. The numerical ordering in this table is close to that of the complete-data setting for the CK–SN P Gaussian/Fourier rows, but the interpretation remains tied to the modified distribution. Therefore, these results are reported as a complementary analysis rather than as the main experimental conclusion.

7.3. Ablation Study of CK–SN P Components

Table 7. Full-mode ablation of S-aware CK–SN P neural variants on the complete DS2 test set.

Model	Seeds	Acc.	BAcc	Macro-F1	$\mathit{F}{1}_{\mathbf{S}}$	Sens.S	MCC	Runtime(s)
CKSNP_SAware_RR_noFourier	2	0.8452	0.6965	0.6050	0.1382	0.2591	0.4699	6464.5223
CKSNP_SAware_RR_GaussFourier_hardSlope	2	0.8603	0.6801	0.6037	0.1251	0.2003	0.4767	6632.6485
CKSNP_SAware_RR_GaussFourier	2	0.8065	0.6692	0.5734	0.1061	0.2265	0.4054	5477.9934
CKSNP_SAware_noRR_GaussFourier	2	0.6817	0.6004	0.4874	0.0452	0.1557	0.2780	6481.9518

reports the full-mode ablation of S-aware CK–SN P neural variants. This table examines how RR information, Gaussian/Fourier descriptors, and S-aware training affect the learned representation. The rows should therefore be read as component analyses rather than as a direct replacement for the classical-classifier comparison in Table 5.

The ablation results should be interpreted as component-level evidence rather than as causal proof. In this patient-independent setting, RR information changes both aggregate metrics and $\mathrm{S}$-class values, supporting the expected role of temporal context in beat-class separability. The comparison between Gaussian/Fourier and no-Fourier variants indicates that the effect of these descriptors depends on the classifier and training formulation. These rows therefore describe how the implemented representation changes when RR information, Gaussian/Fourier descriptors, hard-slope variants, or S-aware loss shaping are modified under the same evaluation protocol. They are not intended to isolate the independent causal effect of each formal component. For this reason, both the classical CK–SN P feature pipeline and the S-aware neural variants are reported, as they address related but not identical modeling questions.

7.4. Computational Cost and Reproducibility

For the complete-data setting, we report the result tables, the CK kernel-bank description, feature-name information, and runtime summaries. The CK–SN P feature representation contains 409 features in this setting. The HGB row in the compact full-mode table has an average runtime of approximately $203.7$ s, while the neural S-aware ablation rows require longer training times. These values should be interpreted in relation to the different roles of the models: the classical classifiers evaluate the CK–SN P feature representation as tabular descriptors, whereas the neural variants examine differentiable training and class-aware objectives. From a computational perspective, the feature-extraction cost is governed by the number of beats, the number of kernels, and the maximum neighborhood length. For a fixed kernel bank and fixed beat-window length, the CK–SN P feature computation scales linearly with the number of evaluated beats.

Compared with a conventional delay-free SN P rule whose applicability depends only on the spike count of the current neuron and on the regular-expression condition, a CK–SN P rule adds the evaluation of a finite number of local kernel responses and Boolean guard tests. For a fixed finite kernel bank, this adds a bounded local arithmetic cost to rule applicability, while preserving the finite rule-set structure and the finite-branching transition relation.

The downstream classifier adds the remaining training or inference cost, depending on its model family. The reproducible reporting separates three elements: the formal CK–SN P model, the feature-extraction pipeline, and the classifier used on top of the extracted representation. This separation allows the formal contribution to be assessed independently of the empirical classifier choice.

7.5. Applicability and Practical Scope

The choice of kernels determines which local spike-count contrasts are exposed to the downstream classifier. Difference-like kernels emphasize local changes and neighborhood imbalance, smoothing-like kernels summarize short-range activity, and asymmetric kernels may capture direction-dependent temporal patterns. In the empirical realization, the finite kernel bank is kept fixed so that the extracted responses remain reproducible and inspectable. The reported results therefore evaluate one declared kernel-response design rather than an unrestricted search over possible kernel families.

The proposed CK–SN P construction is suitable for tasks in which local structure, explicit guard predicates, and inspectable feature computation are important. ECG beat classification is one such application, because local waveform morphology, RR context, and class imbalance interact in the prediction task. Accordingly, this implementation should be viewed as a reproducible research instantiation of the proposed formal model; clinical use would require additional validation and domain-specific assessment. The main practical value of the proposed framework lies not in replacing existing classifiers, but in providing a formal and reproducible mechanism for generating finite local descriptors. These descriptors can be combined with classical classifiers or neural components, allowing the local rule-based structure of CK–SN P systems to complement downstream learning models. The experimental results indicate that CK–SN P local responses can be used as structured descriptors for patient-independent ECG classification. Further work is required to assess how these descriptors behave across databases, acquisition settings, annotation conventions, and alternative class groupings. The interpretability analysis in this study is limited to structural inspectability. The kernel weights, ordered neighborhood positions, threshold relations, active scenario labels, and generated feature names are explicit components of the pipeline. As a result, a rule or feature response can be traced back to a finite local waveform neighborhood and to a declared guard condition. This study does not include a clinician-facing interpretability evaluation, visual case studies of selected errors, or a comparison with post hoc explanation methods. These elements are therefore left for future work and are not presented as completed empirical claims.

7.6. Limitations and Threats to Validity

Several limitations qualify the present findings. First, the empirical evaluation is based on MIT-BIH and on a three-class grouping of beats. Although the DS1/DS2 protocol is patient-independent, additional external validation is required before broader claims can be made. Second, the supraventricular class requires explicit class-level reporting because of its smaller representation and morphology-related overlap with other beat categories. The reported $\mathrm{S}$-class metrics are therefore included explicitly, so that the analysis does not depend only on aggregate accuracy. Third, the reference row under macro-F1 uses CK–SN P features combined with a classical HGB classifier. This choice supports the assessment of the feature representation and clarifies that the final predictive pipeline includes both formal CK–SN P computation and a downstream tabular classifier. The formal and empirical scopes are also intentionally bounded. The kernel guards used in the model are finite and inspection-oriented, and the main formal comparisons are stated for the delay-free fragment. The ECG implementation follows this delay-free setting and uses a fixed finite kernel bank. These choices make the reported pipeline reproducible and auditable, while leaving adaptive kernel selection, delayed-rule dynamics, and broader scenario-control variants for further study. Several analyses remain open for future work. First, because the final tables report two random seeds, formal paired significance testing would have limited interpretive value in the current setting; additional seeds would be needed before non-parametric paired tests could be reported in a stable manner. Second, the $\mathrm{S}$-class metrics are reported explicitly, but a dedicated error analysis with beat-level visual inspection is not included in the present version. Third, the ablation study evaluates RR information and Gaussian/Fourier components, while a separate ablation of the scenario-control function $\mathsf{S}\left(t\right)$ is not reported. These analyses extend naturally from the present full-mode evaluation.

The experimental scope is also limited by the use of a single ECG database and by the absence of external validation on additional databases such as INCART or PTB. The present results therefore support conclusions only for the declared MIT-BIH DS1/DS2 protocol. Broader claims about generalization across acquisition settings, patient populations, annotation conventions, and clinical environments would require multi-database evaluation, additional patient-independent splits, and a larger number of random seeds. The study also does not provide a complete benchmark against recent transformer-based ECG classifiers or a clinician-facing evaluation of interpretability. These elements are left for future work together with paired statistical testing over additional runs, visual error analysis for difficult beat classes, and possible extensions toward multimodal healthcare data. These limitations define the empirical scope of the study and identify directions for further evaluation of the model.

8. Conclusions

This paper has introduced $\mathrm{CK}‒\mathrm{SN}\mathrm{P}$ systems as a formal and trainable framework for local feature computation in rule-based membrane-computing models. The proposed construction extends the operational view of Spiking Neural P systems by allowing spike-rule applicability to depend on kernel responses computed over ordered neighborhoods of spike multiplicities. In this way, the model combines guarded rule activation, local convolutive predicates, and an explicit transition semantics. The theoretical part of the paper defined the syntax and semantics of the model and related the construction to delay-free extended Spiking Neural P systems and kernel P systems under stated assumptions. The formal results are deliberately bounded: the conservativity result concerns the delay-free extended SN P fragment embedded through trivial guards, kernels, and scenarios, while the kernel-P representation is conditional on the expressibility of the required guards in the selected $\mathrm{kP}$ formalism. This delimitation keeps the formal contribution tied to finite, inspectable local predicates rather than to a claim of increased computational power. The empirical study instantiated the model for ECG beat classification under a patient-independent MIT-BIH DS1/DS2 protocol. The full-mode results indicate that CK–SN P local responses can be used as structured descriptors when combined with RR, Gaussian, and Fourier information. In the reported complete-data setting, the CK–SN P RR Gaussian/Fourier representation coupled with histogram-based gradient boosting serves as the reference row when macro-F1 is used as the primary summary metric. The neural S-aware variants provide a complementary view of component behavior and class-aware training.

The study positions CK–SN P systems as a structured mechanism for local feature computation. At the same time, the experimental findings should be interpreted within the limits of the present protocol, dataset, class grouping, finite kernel bank, and delay-free empirical realization. Future work should examine external ECG databases, adaptive or learned kernel-selection strategies, dynamic scenario-control mechanisms, delayed-rule variants, additional patient-independent splits, and closer integration between the formal guarded-rule model and trainable classifier architectures.