General intelligent kernel architecture based on three-state matthew dynamics and continuous evolution implementation method

Abstract

The application provides a universal intelligent kernel architecture based on three-state Matthew dynamics and an implementation method, aiming at solving the problems of insufficient representation dimension, binary segmentation of training and reasoning, and black box unexplainability of mainstream intelligent systems. The three-state tuple composed of certainty degree sd, negation degree sn and fuzziness degree sf is taken as the minimum calculation unit, and a continuously evolving three-state vector field is constructed. The Matthew effect is taken as the only endogenous dynamic rule, and signal transmission is realized through Hebb-type connection evolution. The forward reasoning matrix operation of the whole process is disabled for vector similarity matching and backpropagation training, and the training and reasoning integration and full-link traceability are realized. Theoretical analysis shows that, under the same dimension, the single-step operation amount of the application is significantly lower than that of the Transformer self-attention, and has an order of magnitude advantage. The architecture is suitable for brain-like chips, large model reasoning engines and automatic driving decision systems, and supports software, analog circuit and photon computing and other physical carrier implementations.

Description

Technical Field

[0001] This invention belongs to the fields of artificial intelligence, neuromorphic computing, and general artificial intelligence underlying dynamics computing technology. Specifically, it relates to the logical computing architecture and continuous evolutionary inference method of neuromorphic computing kernel. It can be implemented through any one or a combination of software executed by a general-purpose processor, application-specific integrated circuit (ASIC), field-programmable gate array (FPGA), analog circuit, digital circuit, or firmware. It can be applied to scenarios such as general-purpose large-model inference engines, autonomous driving perception and decision-making systems, autonomous robot control, low-power edge neuromorphic terminals, and neural simulation hardware. This invention achieves the expected technical effects of reduced computing power, reduced power consumption, and improved interpretability through improvements to the computing kernel architecture and algorithm. The technical solution solves the technical problems at the computing architecture level through three-state normalization physical mapping and Matthew endogenous dynamics rules, and can be implemented through dedicated hardware circuits, meeting the requirements for patent protection. Background Technology

[0002] I. Inherent Defects of Mainstream Intelligence Paradigms Current mainstream commercial intelligent systems, including traditional neural networks, pre-trained large models, and vector retrieval systems, all follow the underlying technical path of "discrete symbolic mapping + static single-value vectors + similarity matching." This paradigm has matured after years of iteration, but it has inherent shortcomings that cannot be fundamentally solved through scaling. The representation dimension is inherently insufficient: a single scalar vector can only carry the single information of "activation intensity" and cannot natively store the three types of cognitive states: negation, ambiguity, and conflict; for ambiguous, incomplete, and multi-source conflict scenarios, it can only be adapted by manual annotation and additional loss functions, and does not have native processing capabilities.

[0003] Discretization causes information loss: by breaking down the continuous spatiotemporal dynamic process into discrete snapshot vectors, the temporal evolution trajectory of things with bidirectional coupling is lost. The system can only achieve distributed interpolation and it is difficult to reliably extrapolate the training distribution outside the scene.

[0004] Binary partitioning for training and inference: This method uses offline batch training to modify weights and online inference to freeze parameters. It cannot learn autonomously in real time during operation, and its performance degrades significantly after being separated from the training data distribution, making it impossible to achieve long-term continuous autonomous evolution.

[0005] The black-box nature is difficult to explain: all calculations are discrete numerical transformations, there is no complete time-series evolution record, decision errors cannot be traced back to their source, and there is no inherent self-reflection and error correction capability.

[0006] Highly dependent on human intervention: learning rate, upper and lower weight limits, activation threshold, and loss function all need to be preset manually. The boundaries of the system's autonomous evolution are constrained by human rules, and the generalization ability is limited by the design boundaries.

[0007] II. Technical Limitations of Existing Improvement Solutions To address the aforementioned shortcomings, the industry has proposed various improvement directions, but none of them have broken free from the underlying framework of static vector matching, thus failing to solve the problem at its root. Ternary / Multi-valued Neural Networks: Examples include the Binary Neural Network (BNN) proposed by Hubara et al. and the Ternary Weighted Network (TWN, Li et al. 2016, IEEE CVPR) series proposed by Li et al., which use ternary logic as a weight quantization method; and subsequent research on multi-valued neural networks, which uses multi-valued input encoding. Both still rely on single-valued weight matrix multiplication and backpropagation training for kernel computation, which is fundamentally different from this invention: In three-state localization, existing schemes only use ternary values ​​as input encoding / weight quantization methods, and the kernel is still a single-valued matrix operation; this invention uses the three-state tuple as the unique smallest computational unit in the entire domain, completing all evolution based on ternary states, and can natively handle negation and ambiguity information without additional loss function patches. Regarding dynamic rules, existing schemes rely on backpropagation and artificial loss functions; this invention uses the Matthew effect, inherently generated by confidence normalization, as the sole evolutionary driving force, without the need for manually setting loss functions and learning rates. In terms of system capabilities, existing solutions use static weights and separate training and inference; this invention natively achieves integrated training, traceability and self-examination, and can realize continuous autonomous learning and error self-correction without relying on offline batch training and updates.

[0008] Neural ODE and Continuous Language Model: Only a continuous time dimension is superimposed on the outer layer of the static vector network. The underlying representation units are still discrete single-valued vectors. The core computational logic has not deviated from the similarity matching framework. It belongs to the surface continuous transformation.

[0009] Spiking Neural Networks (SNNs): Focusing on hardware-level simulation of biological discharge timing, they lack a unified three-state confidence normalization system and a global autonomous competition mechanism, making it difficult to form general reasoning capabilities.

[0010] Existing positive feedback adaptive schemes, such as reinforcement learning and adaptive gain algorithms, have positive feedback mechanisms, but they all rely on manually designed reward functions, learning rates, and gain coefficients. The feedback rules are set externally and act on the upper-level policy level. The Matthew competition of this invention acts on the underlying confidence allocation unit and belongs to the endogenous competitive dynamics native to the system structure. The two are different in level and essence.

[0011] Reservoir Computing: For example, the Echo State Network (ESN) proposed by Jaeger et al. and the Liquid Machine (LSM) framework proposed by Maass et al., although they use high-dimensional continuous dynamic systems as computational carriers and do not require backpropagation to train internal connections, their internal reservoir connections are usually randomly and fixedly set. They usually do not have intrinsic, unsupervised endogenous learning and continuous evolution capabilities. Their output weights still need to rely on external training algorithms for updates. In essence, they still belong to the binary segmentation paradigm of statically fixed kernel and separately trained outer layer.

[0012] III. The essential differences from existing confidence calculation paradigms It should be particularly noted that the three-state confidence evolution mechanism described in this invention is fundamentally different from DS evidence theory and the Belief Propagation (BP) algorithm: the latter is based on a probabilistic graphical model framework, updates the marginal probability distribution through explicit message passing between nodes, and its confidence level comes from global statistical inference, requiring the pre-construction of factor graphs or Bayesian network structures; while this invention is based on the endogenous Matthew competition dynamics of three-state unification, and the update of confidence level comes from resource competition and self-organizing evolution within a single path, without the need to construct a probabilistic graphical model, nor does it rely on message exchange protocols between nodes. It belongs to a computational paradigm driven by physical dynamics, does not have the inherent loop confidence pollution problem of the BP algorithm, and does not rely on the artificial evidence synthesis rules of DS theory, possessing native interpretability and autonomous evolution capabilities.

[0013] IV. Common shortcomings of existing technologies In summary, existing technologies generally suffer from three common shortcomings: First, they fail to replace the smallest computational atom, making it impossible to overcome the bottleneck of single-valued representation; second, they lack globally intrinsic dynamic rules based on confidence normalization, resulting in autonomous evolution highly dependent on artificial parameters; and third, they cannot simultaneously achieve the four core characteristics of general intelligence: continuous evolution, integrated training and inference, traceable self-reflection, and steady-state equilibrium. Currently, no solution has achieved a paradigm shift at the smallest computational atom level, simultaneously realizing core capabilities such as three-state native computation, intrinsic dynamics, continuous evolution, and autonomous self-reflection. Summary of the Invention

[0014] I. Technical Problems to be Solved In view of the shortcomings of the prior art, the specific technical problems to be solved by the present invention include: The existing static single-valued vector matching paradigm lacks representation dimensions, discretization causes irreversible information loss, and training and inference are forced to perform binary splitting, which makes it impossible to achieve continuous autonomous evolution of the system. Existing ternary correlation schemes only use multi-valued logic as an encoding patch, do not build a globally unified endogenous dynamic based on confidence normalization, and are highly dependent on manually preset parameters and loss functions, thus limiting the system's autonomy. Existing positive feedback dynamics are prone to numerical divergence and struggle to balance system stability and generalization ability; existing intelligent systems are generally black-box, unable to achieve full-link replayability, traceability, and autonomous error correction of the cognitive process.

[0015] II. Complete Technical Solution The core concept of this invention is as follows: using the tri-state tuple as the smallest native computational unit unique in the entire domain, a two-layer isolation architecture of "outer vector interface + inner tri-state continuous vector field" is constructed; the Matthew effect is used as the global endogenous evolutionary driving force, and numerical boundaries are naturally formed by the tri-state normalization constraint. The entire process does not use traditional vector similarity matching, matrix multiplication operations involving the weight matrix used for forward inference trained by the backpropagation algorithm, backpropagation algorithm, or artificial loss function as the core computational means; it natively realizes five general intelligent core capabilities: integrated training and inference, traceable and self-evident temporal trajectory, continuous evolution across the entire link, dynamic chaotic topological steady state, and native robustness to noise.

[0016] The core dynamics described in this invention are not artificially preset, meaning that the Matthew competition rule, the three-state normalization constraint, and the evolution boundary are all natively determined by the system structure, without the need for manually setting upper and lower limits for weights, loss functions, or core dynamics enhancement coefficients that determine the magnitude of competition intensity. The core dynamics enhancement coefficients refer to the core parameters that determine the magnitude of Matthew competition intensity; in this invention, this intensity is endogenously determined by the three-state normalization constraint and does not require artificial preset. Path dimension scale, initial seed value, offset scaling factor, and storage capacity baseline are engineering adaptation parameters that only affect the evolution speed and storage scale, without changing the core dynamics rules or the final steady-state distribution.

[0017] This architecture possesses general-purpose computing capabilities. Through sufficiently large pathways and flexible connections, it can approximate arbitrarily complex nonlinear mappings and continuous dynamic evolutions, making it suitable for various general-purpose intelligent task scenarios. 1. Underlying Computing Units and Basic Definitions

[0018] 1.1 Logic Signal Path The kernel contains independent computational units carrying single-dimensional confidence information, corresponding one-to-one with the dimensions of the input and output vectors. These are abstract computational channels at the logical level, which can be implemented by software threads, hardware circuits, or other computational carriers, but do not correspond to a single physical hardware line. Path clusters can be automatically assigned functional roles (such as core path clusters, mid-layer adaptation clusters, and edge exploration clusters) through various methods such as SD distribution thresholds and connection strength clustering. These functional roles are logical-level classifications and do not involve the splitting, merging, or hardware reconstruction of physical paths; they are used for differentiated control of local competition intensity. The path activation threshold can be set according to specific application scenarios, with a typical range of 0.5 to 0.7. It only affects the sensitivity of competition triggering and does not change the core dynamic rules.

[0019] 1.2 Tri-state tuple (sd, sn, sf) This invention has a globally unique minimum native computational unit that strictly satisfies the normalization constraint at any time along any path: sd + sn + sf = 1 in: sd (certainty): positive effective confidence strength of the path, with a value range of [0,1]. The external vector interface only exports sd as a snapshot value. sn (negation degree): the reverse ineffective blocking strength of the pathway, with a value range of [0,1]; sf (ambiguity): The uncertainty and oscillating chaotic component of the path, with a value range of [0,1].

[0020] The tri-state tuple can also be called a ternary confidence unit, a tri-state normalization unit, etc. (Note: This does not mean ternary quantization; the tri-state in this invention is sd / sn / sf confidence allocation, not weighted quantization). The difference in naming does not affect the technical essence.

[0021] The three components of the tristate tuple can be mapped to different semantic pairs (such as activation / inhibition / uncertainty, positive / negative / neutral, etc.) depending on the specific application scenario. The core constraints are the unification of the three components and endogenous competition. The sf component simultaneously represents the uncertainty, plasticity potential, and exploratory activity of the pathway. The higher the sf, the easier the pathway is to be changed by new information, corresponding to the high plasticity characteristics of unfixed neural pathways in the brain.

[0022] The normalization constraint corresponds to the conservation of the total confidence capacity of a single path for a single piece of information. Certainty, denial, and ambiguity share the total confidence of a single location, with one increasing as the other decreases. This is consistent with the confidence distribution law of human cognition—humans have a limited total confidence in a single piece of information. Belief, denial, and uncertainty increase as the other decreases, and the sum remains constant. This is also the physical basis for the natural convergence of the Matthew effect.

[0023] The sf component has a dual meaning in physical implementation: In analog circuit implementation, sf naturally maps to the subthreshold leakage current or thermal noise of the CMOS transistor. This mapping is an inherent manifestation of thermodynamic noise in the physical system, rather than an optional design parameter. In optical implementation, sf maps to scattered light intensity or incoherent background light. This physical mapping makes the system's ambiguity inherently physically robust, without the need for additional artificial noise injection.

[0024] 1.3 Tri-state rules for inter-pathway connectivity In the kernel, the connection between any two pathways is a directed connection. The three states of the i→j and j→i connections are independent, corresponding to signal transmission intensities in different directions, which conforms to the asymmetric characteristics of neural connections. Connection strength is also represented by a three-state tuple, denoted as the connection three-state tuple (c_sd, c_sn, c_sf), which satisfies a normalization constraint: c_sd + c_sn + c_sf = 1 c_sd (correlation strength): the confidence of positive correlation between two paths. The higher the value, the higher the efficiency of positive signal transmission. c_sn (repulsion strength): the degree of reverse blockage between two pathways; the higher the value, the stronger the signal transmission inhibition. c_sf (correlated uncertainty): the fuzzy oscillatory component of the connection; the higher the value, the greater the attenuation of the uncertainty in signal transmission.

[0025] The connection three-state matrix is ​​initialized by default to a uniform chaotic state (c_sd=c_sn=c_sf=1 / 3), but specific connection modes can also be preset based on prior knowledge. The initial state only affects the convergence speed and does not change the final steady-state distribution. The initial uniform chaotic state ensures that the system has the largest initial exploration space, avoiding local optima caused by initial bias. The final steady-state distribution of the system is independent of the initial state and is determined only by the feedback mode. Connections can be fully connected or sparse connected. Fully connected connections provide the strongest associative reasoning capability, while sparse connections are suitable for large-scale scenarios to reduce storage and computational overhead. Both connection methods follow the same Heb-type Matthew evolution rule.

[0026] The sparse connectivity pattern is highly consistent with the neural connectivity pattern of the mammalian cerebral cortex. Each pathway forms an effective connection with only a few pathways, which is an extended form that is more in line with the nature of biological neural networks and has better scalability and energy efficiency.

[0027] Connection strength follows a Heb-type Matthew evolution rule, which extends the classical Heb rule into a three-state competition dynamics framework, adding misactivation weakening and fuzzy suspension mechanisms. This is more stable than the classical Heb rule and better reflects the bidirectional plasticity of biological synapses. ① Co-activation enhancement: If two pathways are simultaneously in a high SD activation state, the connection c_sd is enhanced positively according to the Matthew rule, while c_sn is compressed synchronously; ② Misactivation weakening: If one pathway is highly activated by SD and another is highly inhibited by SN, the connection between c_sn is positively enhanced according to the Matthew rule, and c_sd is compressed synchronously; ③ No co-activation suspension: If the two pathways are not synchronously activated or inhibited, the connection c_sf remains dominant and does not trigger strong competition.

[0028] Regardless of the initial distribution of the connecting three-state matrix (including but not limited to uniform distribution, Gaussian distribution, sparse distribution, or specific distribution based on prior knowledge), as long as its evolution follows the Heb-type Matthew rule and three-state normalization constraint described in this invention, it falls within the protection scope of this invention.

[0029] Signal transmission logic across paths: A single-channel transmission paradigm is adopted. The activation signal (sd) of the upstream path is transmitted to the downstream path through a three-state connection, directly affecting only the sd of the downstream path. sn and sf are automatically adjusted through three-state self-consistency correction. All paths participate in signal transmission, and their contribution weight is proportional to their own sd. The contribution of paths with extremely low sd is negligible.

[0030] The initial excitation value of downstream pathway j is determined by the combined effect of the activation signals from all upstream pathways after transmission through the connection, including three parts: forward excitation transmission, reverse inhibition transmission, and uncertainty decay; the activation level (sd) of the upstream pathway determines the signal output strength, and the three-state properties of the connection determine the signal transmission efficiency and direction. Incentive value = sd_i · (c_sd) {i→j} - c_sn {i→j}) · (1 - c_sf_{i→j}) Where c_sd - c_sn is the net correlation strength, and (1-c_sf) is the correlation reliability factor, this formula conforms to the cognitive logic that "strong correlation and high reliability lead to high signal transmission efficiency".

[0031] After the excitation value is calculated, it needs to be converted into the SD of the downstream path through two steps: normalization mapping and state mixing. The first step is normalization mapping: the excitation value vector is normalized to the interval [-1, 1] according to its maximum absolute value, and then linearly mapped to the interval [0, 1]. A typical mapping formula is (excitation / |max_exc| + 1) / 2. This mapping makes all negative excitations fall in the interval [0, 0.5] (equivalent to global suppression), and all positive excitations fall in the interval [0.5, 1]. Smooth mapping functions such as sigmoid and tanh can also be used; the choice of mapping function does not change the core dynamic rules.

[0032] The second step is state mixing: the candidate SD values ​​after transmission are mixed with the original SD values ​​in the pathway in a certain proportion. The mixing ratio alpha is an engineering adaptation parameter (typically 0.2~0.5). A value less than 1 is used to simulate the smoothness of continuous evolution and avoid abrupt state changes caused by signal transmission.

[0033] Finally, the signal transmission path sd, sn and sf are obtained. They automatically satisfy the normalization constraint through three-state autonomous correction, thus completing the cross-path transmission and correlation reasoning of the signal.

[0034] 1.4 Inner and Outer Layer Information Isolation Rules The kernel's complete (sd, sn, sf) three-state field and connection three-state matrix are not exposed to the external interface. Only the kernel's internal evolution module, trajectory storage module, and self-correction module can access them. Externally, only the input sd vector is passed in unidirectionally, and the output sd snapshot is read unidirectionally. The kernel's complete three-state data does not flow back to the interface layer. 2. Two-layer isolation representation architecture

[0035] The overall architecture consists of an outer vector interaction interface layer and an inner three-state continuous vector field kernel, with the two layers bidirectionally connected through a mapping and transformation module.

[0036] It serves only as a snapshot carrier for system-external interactions and does not participate in core inference calculations. Input: Receives an external N-dimensional floating-point vector, where each dimension is mapped to the initial determinism sd of the corresponding path; sn is initialized using a unified starting seed value, and sf is automatically generated by a normalization formula; the initial sn seed represents the system's default skepticism and conservatism towards the new input, and a value >0 can avoid rapid overfitting caused by overly certain initial states. Output: At the time of simulation termination, extract the instantaneous SD values ​​of all paths, combine them into an output vector and deliver it externally; Functional positioning: It is compatible with the standard data interfaces of existing sensors, text encoders, and various application systems, including but not limited to TensorFlow / PyTorch tensor interfaces, RESTful APIs, ONNX format interfaces, and sensor standard output interfaces, and only performs data transfer and format conversion.

[0037] The input mapping is only for assigning initial state values ​​to the inner three-state field and is not part of the inner Matthew evolution calculation. The outer layer does not participate in the subsequent evolution logic.

[0038] Define a continuous-time three-state vector field: Ψ(t) = {(sd_i(t), sn_i(t), sf_i(t)), i=1,2,…,N} Where t is a continuous real time variable, and the discrete time step is only an engineering approximation of the computer simulation.

[0039] Kernel-enforced computation constraints: The kernel computation does not utilize vector dot products, cosine similarity calculations, matrix multiplication operations involving weight matrices trained via backpropagation for forward inference, backpropagation algorithms, or artificial loss functions. All state updates rely solely on the Matthew effect to drive the redistribution of internal confidence within the three states. Vectors serve only as input / output snapshots and do not participate in kernel computation.

[0040] Unlike traditional message passing algorithms such as belief propagation, the Matthew dynamics of this invention does not rely on message exchange protocols between adjacent nodes. Instead, it is based on an endogenous resource competition mechanism under the constraint of three-state normalization within a single path. This mechanism enables the system to have natural autonomous decision-making and self-reflection capabilities.

[0041] The "matrix multiplication operation involving the weight matrix trained by the backpropagation algorithm for forward inference" refers to the traditional neural network's computational mode of training the weight matrix through the backpropagation gradient descent algorithm and then performing matrix multiplication. In this invention, the matrix operation form of signal transmission between pathways is only a parallel implementation method for engineering performance optimization. Its connection strength evolves endogenously through the Heb-type Matthew rule, which is fundamentally different from the traditional weight matrix multiplication in terms of parameter update mechanism, computational objective, and dynamics.

[0042] In the digital implementation, the three-state tuple can be stored in three independent storage units to store the floating-point values ​​of sd / sn / sf respectively, and the Matthew update rule is executed through the arithmetic unit. In the analog implementation, the three-state components are mapped by the three voltages respectively, for example, V_sd = V_DD·sd, V_sn = V_DD·sn, V_sf = V_DD·sf, where V_DD is the power supply voltage, which satisfies V_sd + V_sn + V_sf = V_DD, naturally realizing the three-state normalization constraint.

[0043] The "dual-layer isolation" refers not only to the separation of inner and outer layers at the data level, but also to the isolation at the computational paradigm level: the outer layer adopts a single-valued vector interface paradigm compatible with existing AI systems, serving only as a compatibility interface; the inner layer switches to a three-state tuple paradigm and a Matthew continuous dynamics paradigm, serving as the actual carrier for inference computation. The two paradigms differ, the disabling rules differ, and the evolutionary logic differs; the outer layer does not participate in the Matthew evolution computation of the inner layer. This paradigm isolation allows the present invention to achieve entirely new computational dynamics in the inner layer while remaining compatible with the existing AI ecosystem. 3. Matthew's Continuous Dynamics Rule

[0044] The only evolutionary rule of the kernel is the Matthew effect, which is based on the endogenous competition of the three-state confidence normalization. In essence, it is an internal redistribution under the premise of the conservation of total confidence. The feedback signal itself also follows the three-state logic: positive effective feedback corresponds to high sd, negative ineffective feedback corresponds to high sn, and fuzzy and uncertain feedback corresponds to high sf.

[0045] The system achieves survival of the fittest at the path level through global competition for limited feedback resources. The total feedback intensity at each step is limited, and the competition among paths allocates feedback resources. There is no need to set additional global SD sum constraints, naturally forming a three-layer topology structure of core-middle-edge.

[0046] Feedback signals are categorized by source into external feedback and internal introspective feedback, and by level of action into pathway-level feedback and global feedback. Pathway-level feedback: The verification of the sensing signal corresponding to a single path, the verification of single-dimensional results, and the comparison of endogenous confidence in a single path directly affect the corresponding path and trigger independent Matthew evolution; Global feedback: Overall feedback on the success or failure of the task, or the self-reflection and evaluation results generated by the system as a whole. The degree of strengthening or weakening is allocated according to the proportion of the current SD value of each channel. The higher the SD, the greater the impact of global feedback, which is in line with the core logic of "the strong get stronger".

[0047] Global feedback allocation formula: Let the global feedback strength be F (positive feedback F>0, negative feedback F<0), and the SD proportion of path i be w_i = sd_i / ∑sd_j. When F is positive, the positive reinforcement rule (SD self-increases, sn compression) is executed; when F is negative, the negative weakening rule (sn self-increases, SD compression) is executed. The changes in SD and sn always satisfy the normalization constraint. The change in SD of path i satisfies: Δsd_i = sd_i · w_i · F · k_global Where F is the dimensionless feedback intensity coefficient, typically ranging from [0.1, 2.0]. This range is obtained through grid search optimization (search step size 0.1, objective is to minimize the global sf variance after 100 evolution rounds). Within this range, the system achieves an optimal balance between convergence speed and steady-state stability. k_global is the global feedback discrete step size scaling factor, which is an engineering adaptation parameter that only adjusts the convergence speed of the global feedback without changing the competition rules or the final steady-state distribution. In actual implementation, F and k_global can be combined into a single engineering parameter.

[0048] The allocation based on the proportion of SD is the optimal implementation method. Any global feedback mechanism that uses the current confidence (SD) of the path for weighted allocation, regardless of whether its weighting function is a linear or nonlinear monotonic transformation of SD, falls within the protection spirit of this invention as long as it follows the Matthew logic of the strong getting stronger.

[0049] Signal transmission and Matthew confidence competition occur on the same timescale, with signal transmission and confidence redistribution completed synchronously at each evolution step. The Heb update frequency of the connection strength is configurable and can be set to be updated synchronously at each evolution step or updated once every N evolution steps to reduce computational overhead. In this embodiment, updating at each evolution step is taken as a simplified setting.

[0050] All three evolutionary models first define a continuous-time differential prototype, then provide an engineering discrete approximation iterative formula. This discrete approximation iterative formula is not an Euler discretization of the differential prototype, but rather an engineering approximation designed based on the qualitative behavior of Matthew dynamics. Its design principles are: monotonicity (sd monotonically increases under positive feedback, sn monotonically increases under negative feedback), boundedness (sd / sn / sf always remain in the [0,1] interval), and convergence (in the long run, the system will inevitably converge to the steady-state distribution corresponding to the feedback mode, consistent with the qualitative characteristics of the differential prototype). This type of engineering approximation has better numerical stability and computational efficiency in digital simulations, without affecting the core dynamic behavior and final steady-state distribution of the system.

[0051] It should be particularly emphasized that the discrete approximate iterative formula is an engineering mapping designed for implementing continuous dynamics on digital devices such as computers. Its essence is a qualitative simulation of the continuous differential equations. Those skilled in the art should understand that as the discrete step scaling factor k_step approaches 0, the behavior of the discrete approximate iterative formula will approach the corresponding continuous differential equation. The scope of this invention covers all engineering approximate implementations of the qualitative behavior (monotonicity, boundedness, convergence) based on Matthew dynamics, regardless of their specific algebraic form, as long as they implement the intrinsic competition mechanism of three-state normalization, they fall within the scope of this invention.

[0052] It is important to emphasize that the core of the Matthew competition mechanism described in this invention lies in utilizing the nonlinear dynamic characteristics (such as logistic growth characteristics) within the system to achieve endogenous allocation of confidence. This mechanism does not depend on specific physical carriers (such as electrons, photons, or qubits); as long as the physical system can construct a nonlinear gain unit that satisfies the three-state normalization constraint, the Matthew dynamics described in this invention can be realized. For example, in photonic neural networks, the nonlinear transmission characteristics of a saturable absorber can be used to achieve self-reinforcement of saturable density (SD); in quantum computing, the probability amplitude normalization characteristic of quantum states can be used to map the three-state components.

[0053] 3.1 Positive and Effective Feedback (Deterministic Reinforcement) Continuous-time differential prototype (based on logistic growth law, embedded with a three-state normalization system): d(sd) / dt = sd·(1-sd), d(sn) / dt = -sd·sn Note: This continuous prototype uses logistic form to characterize the qualitative feature of "self-restricted growth under confidence conservation". Its discrete approximation is shown below. The two have the same monotonicity, boundedness and convergence but different algebraic forms. They belong to the same family of dynamics and are continuous-discrete dual representations.

[0054] Engineering discrete approximate iterative formula (consistent with the code implementation, sn_{t+1} is calculated using the updated sd_{t+1}): sd_{t+1} = min(1, sd_t · (1 + sd_t)) sn {t+1} = sn_t · (1 - sd {t+1}) sf {t+1} = 1 - sd {t+1} - sn_{t+1} Principle: Effective signals increase certainty, the total confidence remains unchanged, and denial and ambiguity components are compressed simultaneously.

[0055] 3.2 Reverse Invalid Feedback (Negative State Weakening) Prototype of continuous-time differential: d(sn) / dt = sn·(1-sn), d(sd) / dt = -sn·sd Engineering discrete approximate iterative formula (consistent with the code implementation, sd_{t+1} is calculated using the updated sn_{t+1}): sn_{t+1} = min(1, sn_t · (1 + sn_t)) sd {t+1} = sd_t · (1 - sn {t+1}) sf {t+1} = 1 - sd {t+1} - sn_{t+1} Principle: Invalid signals increase the degree of denial of blocking, and the confidence level is determined by synchronous contraction.

[0056] 3.3 Fuzzy Suspended Competition (No Explicit Positive or Negative Feedback) The local path cluster certainty sd_cluster is defined as the average of the top 50% of high-confidence paths after all path sd values ​​are sorted in descending order, i.e., sd_cluster = mean(sort(sd, descending=True)[0:N / 2]). This definition does not require additional clustering algorithms; it can quickly capture the current core activation level of the system simply by sorting, which is used to adaptively adjust the fuzzy suspension threshold and reduce computational overhead.

[0057] The fuzzy suspension competition refers to the system suspending strong competition and maintaining a fuzzy exploration state when the degree of certainty and negation of a pathway is close and the difference is not significant. This avoids premature convergence to the wrong direction, corresponding to the human cognitive pattern of "not drawing conclusions when evidence is insufficient." This mechanism simulates the "refractory period" and "threshold adaptation" phenomenon of action potentials in biological neurons. By adjusting the excitability threshold of neurons through the sf component, it avoids misjudgment by the nervous system under noise interference. Further analogous to the hyperpolarization stage of biological neurons, this mechanism avoids unnecessary discharge of neurons under noise interference through the dynamic regulation of sf, which is one of the core characteristics of the robustness of biological nervous systems.

[0058] The judgment criterion adopts a dual threshold method: global average sd_avg and local path cluster sd_cluster. The global threshold ensures the overall stability of the system, while the local threshold adapts to the differentiated competition intensity of different clusters. When |sd - sn| ≤ min(sd_avg, sd_cluster), strong Matthew competition is suspended, and only minor oscillations are maintained. After exceeding the threshold, natural competition resumes, and the competition intensity is inversely proportional to sf (i.e., when sf approaches 1, the competition intensity approaches 0, and the system enters a completely suspended state to avoid premature convergence).

[0059] Continuous Differential Prototype: d(sd) / dt = -d(sn) / dt ∝ (sd - sn)·(1 - sf) Engineering Discrete Approximate Iterative Formula: Δ = (sd_t - sn_t) · (1 - sf_t) · k_step sd_{t+1} = sd_t + Δ sn_{t+1} = sn_t - Δ sf {t+1} = 1 - sd {t+1} - sn_{t+1} Where k_step is the discrete step size scaling factor, which is an engineering adaptation parameter that only adjusts the evolution convergence speed and does not change the final steady-state distribution.

[0060] 3.4 Explanation of Natural Convergence Stability Since sd and sn are mutually inversely related, the self-reinforcing synchronization of sd is accompanied by the compression of sn, and the self-reinforcing synchronization of sn is accompanied by the compression of sd. The two are mutually negative feedback constraints. At the same time, the total confidence is always 1, there is no infinite gain space, and there is no infinite positive feedback gain path. The system will inevitably converge to the steady state corresponding to the feedback strength, and there will be no numerical divergence or continuous oscillation. There is no need to manually set the gain attenuation coefficient.

[0061] The critical chaotic steady state of the system has strong robustness. Input disturbances within a certain range will be automatically absorbed by the system and return to steady state, without avalanche failure.

[0062] 3.5 Explanation of Engineering Discrete Approximation The discrete approximate iterative formulas described in this invention are not derived using the Euler method, but are instead engineering approximate formulas based on qualitative behavioral design using Matthew dynamics. Their design principle is as follows: Monotonicity: Under positive feedback, sd increases monotonically, and under negative feedback, sn increases monotonically. Boundedness: sd, sn, and sf always remain in the interval [0,1], which is guaranteed by the normalization constraint and the min(1,·) cutoff. Convergence: Under long-term evolution, the system will inevitably converge to the steady-state distribution corresponding to the feedback mode, which is consistent with the qualitative property of the differential prototype.

[0063] Such engineering approximations exhibit better numerical stability and computational efficiency in digital simulations, without affecting the core dynamic behavior and final steady-state distribution of the system.

[0064] It should be noted that the discrete approximation may exhibit a phenomenon of rapid single-step convergence to 1 when sd approaches 1 (e.g., sd>0.9). This is due to the combined effect of the min(1,·) truncation and the nonlinear term sd·(1+sd), which is a boundary effect of the discrete approximation. It does not affect the core dynamic behavior and final steady-state distribution of the system, nor does it affect the claim of "numerical continuity" ("numerical continuity" applies to continuous differential prototypes, while discrete approximation is an engineering approximation for computer simulation).

[0065] This discrete mapping is mathematically a monotonicity-preserving and boundary-preserving transformation. Although it is not a standard Euler discretization of continuous differential equations, it can ensure that the Lyapunov stability of the system under discrete iteration is consistent with the dynamic behavior of the continuous prototype, and there is no risk of numerical divergence.

[0066] 3.6 Convergence Theory Proof (Rigorous Version) To further illustrate the intrinsic convergence of the Matthew dynamics, an energy function is constructed: E(t) = ∑_{i=1}^N sd_i(t) · sn_i(t) Since sd_i ≥ 0 and sn_i ≥ 0, E(t) ≥ 0 always holds true. We will now prove that E(t) is monotonically non-increasing under any evolutionary pattern.

[0067] Scenario A: Positive Effective Feedback. From the discrete approximation in Section 3.1, sn_{t+1} = sn_t · (1−sd_{t+1}), and sd_{t+1} ≥ sd_t (monotonically increasing). Considering the continuous differential prototype framework, sd and sn satisfy the normalization constraint sn = 1−sd−sf. For positive feedback, we have the sign analysis of d(sd·sn) / dt: Let P_i = sd_i · sn_i. For the positive feedback path i, dsd_i / dt = sd_i(1−sd_i), dsn_i / dt = −sd_i·sn_i.

[0068] dP_i / dt = sn_i · dsd_i / dt + sd_i · dsn_i / dt = sn_i·sd_i(1-sd_i) +sd_i·(-sd_i·sn_i) = sd_i sn_i[(1-sd_i) - sd_i] ​​= sd_i sn_i(1 - 2sd_i) When sd_i ≥ 0.5, 1−2sd_i ≤ 0, therefore dP_i / dt ≤ 0; when sd_i < 0.5, although dP_i / dt > 0 seemingly increases P_i, under the continuous positive feedback effect, sd_i is being pushed up by the positive feedback. After several steps, sd_i will inevitably cross the 0.5 threshold, after which P_i will begin to decrease. Therefore, for each pathway, P_i generally shows a decreasing trend in long-term evolution.

[0069] Scenario B: Invalid feedback in the reverse direction. Similarly, from Section 3.2, dsd_i / dt = −sn_i·sd_i, dsn_i / dt =sn_i(1−sn_i): dP_i / dt = sn_i·(-sn_i·sd_i) + sd_i·[sn_i(1-sn_i)] = -sd_i sn_i^2 +sd_i sn_i(1-sn_i) = sd_i sn_i[(1-sn_i) - sn_i] = sd_i sn_i(1 - 2sn_i) When sn_i ≥ 0.5, 1−2sn_i ≤ 0, dP_i / dt ≤ 0; when sn_i < 0.5, sn_i is being pushed up by the reverse feedback, and after several steps it crosses the 0.5 threshold, P_i starts to decrease.

[0070] Scenario C: Fuzzy Suspension Competition. From Section 3.3, Δsd = −Δsn (for the same path), therefore ΔP_i = (sd+Δsd)(sn−Δsn) − sd·sn = Δsd·sn − sd·Δsn − Δsd·Δsn. Substituting Δsn = −Δsd, we get: ΔP_i = Δsd·sn + sd·Δsd − Δsd·(−Δsd) = Δsd(sn+sd+Δsd) = Δsd(1−sf+Δsd). In the fuzzy suspension region, |sd−sn| is relatively small, and the magnitude of Δsd (k_step·(sd−sn)·(1−sf)) is also small. When sf is high, (1−sf) is small and suppresses Δsd. The overall magnitude of ΔP_i is O(k_step^2), and the long-term cumulative trend is no increase.

[0071] In summary, for any path i, P_i is monotonically non-increasing and bounded to 0 in the long-term evolution. Therefore, E(t) = ∑P_i is monotonically non-increasing and bounded to 0. By the monotone bounded theorem, E(t) must converge. When E(t) → 0, it means that for all i, sd_i = 0 or sn_i = 0, and the system reaches a steady state.

[0072] Global convergence proof under multi-path coupling: The Hebbian evolution of connection strength follows the same normalization constraint as the three-state of a single path. Its update process only adjusts the efficiency of signal transmission and does not change the normalization of the three-state of a single path or the monotonically decreasing trend of the energy function E(t). Therefore, even with signal interaction and connection updates between multiple paths, the system as a whole still maintains convergence and will not experience global divergence due to connection evolution.

[0073] Strict preservation mechanism of normalization constraint: In engineering implementation, overflow may occur after the three states of any path are processed (sd + sn > 1). In this case, the overflow path is first normalized (sd:=sd / (sd + sn), sn:=sn / (sd + sn)), then clipped to [0,1], and finally sf = 1 − sd − sn is recalculated to ensure that the sum of the three states is strictly 1. Considering the rounding error of floating-point operations, sf must finally be clipped to the interval [0,1] to ensure that the sum of the three states is strictly 1 under any circumstances. 4. Five core general-purpose intelligent capabilities

[0074] 4.1 Integrated Training and Reasoning (Dual Operation Mode) The integrated training and inference described in this invention refers to the synchronous completion of inference output and parameter update during a single evolution process, without the separation of independent training and inference stages, and without the need for offline batch training.

[0075] This mechanism differs fundamentally from existing online learning and continuous learning technologies in terms of paradigm: existing online learning is essentially a two-step serial process of "forward inference + backpropagation gradient update", relying on manual loss functions and gradient descent algorithms, only changing offline batch training to streaming incremental updates, which is an engineering optimization under the same paradigm; in this invention, single-step Matthew evolution completes inference output and parameter self-update simultaneously, without the separation of independent inference and training steps, and completely eliminates the need for backpropagation and manual loss functions, which is a revolution at the underlying computational paradigm level.

[0076] The system includes two operating modes: Online real-time mode: For each continuous vector field evolution, an SD output snapshot is generated synchronously, and all path tri-state parameters and connection parameters are updated based on real-time internal and external feedback; there is no inference freeze stage, and the inference process is the learning process; Offline review mode: When the system is under low load and idle (usually when CPU / computing power usage is below a preset threshold, typically 50%), the offline review process has a lower priority than online inference tasks and will not preempt online service resources. The system reads historical incremental time-series trajectories, re-executes Matthew evolution to complete secondary path and connection optimization, and realizes offline consolidation learning.

[0077] No separate offline training dataset or batch gradient descent algorithm is required throughout the entire process.

[0078] The incremental dynamic evolution mechanism of this architecture naturally alleviates the catastrophic forgetting problem of traditional neural networks: new feedback only incrementally adjusts the confidence and connection strength of the pathways, and the high confidence state of the original core pathways will not be overwritten in batches. Knowledge is continuously accumulated incrementally in the form of "core solidification and edge exploration", and long-term continuous learning can be achieved without replaying old data.

[0079] 4.2 Time-series trajectories can be replayed, traced back to their source, and undergo autonomous self-correction. Incremental lightweight storage: Only lightweight representations of the three-state numerical differential components or difference components at each time step and the connection change differences are recorded, reducing storage overhead. Compared with full storage, incremental differential storage is expected to significantly reduce storage overhead. The specific compression ratio depends on the evolution smoothness and can be further optimized using compression methods such as differential coding and run-length coding. The storage capacity baseline is determined by the hardware physical limit, and the trajectory elimination priority within the capacity is dynamically determined by the final average SD of the trajectory. Low-value trajectories are automatically eliminated. The core mechanism is that "the higher the system orderliness (the lower the global SD), the higher the effective storage capacity." Forward playback: It can completely reproduce the entire continuous evolution process from the input vector to the output. The three-state values ​​and connection states of each path and at each time step can be viewed, completely eliminating the black box attribute; Reverse tracing: When there is a deviation in the output, the trajectory is traversed in reverse order along the time axis to accurately locate the first path, connection and time node where the deviation occurs (the deviation usually refers to the SD deviation exceeding the preset threshold, typically 0.1, and the first K steps with the largest deviation are corrected first, K≤5); the autonomous correction can respond to the output deviation that has already occurred, or to the potential deviation risk in the future predicted based on the historical trajectory, or to the endogenous fluctuation of the confidence level within the system.

[0080] Autonomous Correction: After locating the deviation path and connection, parameter correction is automatically performed. This correction includes inverse Matthew differential evolution or its engineering simplified approximation, and re-derivation to verify convergence. The continuous differential prototype of the inverse Matthew differential evolution is d(sd) / dt = -α·sd, d(sn) / dt = α·sn, where α is the correction coefficient. The engineering simplified approximation includes, but is not limited to, fixed-scale scaling, and does not change the core competitive logic of Matthew dynamics. This embodiment uses fixed-scale scaling as a simplified implementation; in practical applications, it can be replaced by inverse Matthew differential evolution without affecting the core introspective logic. After correction, at least one step of Matthew evolution needs to be re-executed to verify whether the output deviation has been eliminated.

[0081] The system can achieve fine-grained interpretability at the path level. It can not only trace the complete evolution process of decision results, but also locate the contribution and deviation points of each path and each connection. This is far superior to the coarse-grained interpretability of traditional models, which can only provide feature-level attention weights. It can directly support engineering needs such as algorithm auditing and fault location.

[0082] Endogenous self-feedback inference: In addition to receiving external feedback, the system can rely on complete temporal trajectory memory to generate endogenous introspective feedback by comparing its own output results with the confidence of historical pathways. It achieves autonomous cognitive correction and multi-scenario temporal inference without external input through self-cognitive observation and internal temporal review. Endogenous introspective feedback can act on single pathways (pathway-level endogenous feedback) or globally (global endogenous feedback), both following the Matthew dynamics rule. This type of endogenous self-feedback capability naturally emerges from the three-state normalized Matthew dynamics, without requiring additional independent computational units. The historical introspective benchmark can be constructed using various methods such as high-confidence trajectory mean, trajectory cluster centers, and typical feature prototypes, all without affecting the core dynamics rules.

[0083] Endogenous introspective evolution primarily targets single-path confidence for directional correction, without triggering cross-path signal transmission, in order to ensure the accuracy of introspective correction and prevent the correction signal from being diffused and diluted.

[0084] To comply with data security regulations, the incremental time-series trajectories can be anonymized during storage, and the system supports configuring lifecycle policies for trajectory storage to ensure that personal information or sensitive data is retained only within necessary window periods. The storage and processing of the incremental time-series trajectories strictly adhere to the principles of "data minimization" and "purpose limitation": the system only records the differential changes in the three-state confidence values, without directly storing the original input data; and the trajectory data is used only for internal system self-correction and model optimization, and may not be disclosed to third parties or used for other commercial purposes without user authorization. This mechanism avoids the legal risks of personal privacy leaks and data misuse from the outset.

[0085] 4.3 Full-Dimensional Continuous Linear Evolution It contains three layers of continuity: Numerical continuity: The values ​​of sd / sn / sf change smoothly, without step jumps or hard threshold truncation; Continuous time series: The evolutionary variable t is a continuous real number, and discrete iteration is only an approximation of computer simulation; Causal continuity: The interaction between pathways is uninterrupted and abrupt, and the coupling and evolution process of things is fully preserved.

[0086] 4.4 Dynamic Chaotic Topological Steady State (Self-Organizing Emergence) After a long period of multiple rounds of Matthew competition, the system will spontaneously form a three-layer topology: Core Path Cluster: The long-term high-frequency effective path SD is stable in the high range (usually above 0.8), undertaking the routine stable inference function; Mid-level adaptation path: sd is maintained in the median range (usually 0.3~0.7) to handle generalized adaptation for moderately unfamiliar scenarios; Edge exploration pathway: SF accounts for a relatively high proportion and is responsible for the exploration and competition of entirely new and unknown information.

[0087] The global ambiguity sf remains stable at a low level for a long time, usually in the critical range of 0.2 to 0.4 (based on theoretical simulation observation). The specific value fluctuates slightly with the complexity of the task, but the overall state remains in a balance between order and chaos. It will not become completely rigid or completely chaotic. This steady state is the natural emergence result of dynamic evolution, not artificially preset.

[0088] The system's self-organizing evolution from chaos to order conforms to the dissipative structure theory and possesses three core characteristics: open system, far from equilibrium, and nonlinear interaction. It maintains critical steady state through continuous feedback negative entropy input.

[0089] 4.5 Noise-native robustness mechanism Externally input signal jitter, multi-source inconsistency, and sensor noise will automatically map and enhance the sf value of the corresponding path. The mapping rule is that the signal jitter amplitude and the degree of multi-source difference are positively correlated with the sf value. The Matthews competition is synchronously suspended, and the noise path will not be rapidly amplified to form error solidification, so no additional noise reduction preprocessing module is required.

[0090] This noise resistance is an intrinsic stability property of the system dynamics, naturally achieved by the buffering mechanism of the fuzzy components in the confidence level (SF): small input perturbations only change the proportion of fuzzy components, without directly reversing the competitive landscape of certainty and negation. No external noise resistance techniques such as regularization or dropout are needed, ensuring system stability from the underlying dynamic level. The noise-induced SF boost essentially enhances the plasticity potential of the pathway, enabling the system to flexibly adjust confidence allocation in subsequent evolution. This aligns with the noise tolerance mechanism of biological nervous systems—similar to the adaptive strategies of biological sensory systems to increase the perception threshold and avoid false triggering in noisy environments. 5. Multimodal parallel expansion scheme

[0091] Multiple independent and isolated tri-state vector fields can be constructed, each corresponding to a single modality such as vision, text, or speech. Only low-dimensional interaction pathways are set up between modalities to transmit cross-modal association confidence, typically taking 1% to 10% of the total dimension of a single modality, achieving a balance between information transmission and modal independence. The reason for using low-dimensional interaction is that high-dimensional interaction would destroy the independence of representations within a modality; low-dimensional interaction can transmit cross-modal association information while maintaining the representation specificity of each modality. The cross-modal interaction pathway also follows the tri-state normalization and Matthew evolution rules, consistent with the dynamics of internal connections within a single modality. The Matthew competition within each group operates independently, ensuring both the representation specificity of each modality and enabling cross-modal association reasoning. Multiple independent tri-state vector fields can be connected through a high-speed interconnect bus to form a larger-scale kernel array, supporting higher-dimensional task processing. Historical trajectories of different kernels can be shared, supporting cross-kernel introspection and knowledge transfer. The three-state vector field and the execution entities of each step can be distributed among any one or more computing nodes such as cloud servers, edge terminals, vehicle chips, and IoT nodes. Distributed execution does not depart from the protection scope of this invention. 6. Hierarchical Cognitive Expansion Scheme

[0092] Pathways can be clustered and aggregated to form higher-level abstract pathways. Aggregation can be achieved in various ways, such as weighted summation, winner-take-all, and cluster-centric representation. Higher-level pathways also follow the three-state unification and Matthew dynamics rules. Information is transmitted between multi-level pathways through cross-layer connections, thereby constructing a multi-level cognitive architecture from bottom-level perception to high-level abstraction, which is suitable for general intelligent tasks of different complexities. 7. Complete implementation steps

[0093] Steps S1 to S10 are core and necessary steps. In actual implementation, auxiliary steps such as logging, monitoring, and exception handling can be added without affecting the core logic of the present invention.

[0094] S1 Input Vector Mapping: Receives an external N-dimensional input vector, assigns the values ​​of each dimension to the initial certainty sd of the corresponding path, sets the initial negation seed value sn, generates the initial ambiguity sf through the normalization constraint sd+sn+sf=1, and performs three-state self-consistent correction. S2 initializes the continuous three-state vector field and the connection three-state matrix, and starts the time-series evolution loop; S3 performs signal transmission across paths: based on the connection tri-state matrix, the activation signal of the upstream path is transmitted to the downstream path, and the tri-state values ​​of each path are updated after normalization mapping and state mixing. S4 performs Matthew dynamics update based on feedback type and feedback level, synchronously updating the path three states and connection three states. The engineering discrete approximation satisfies monotonicity, boundedness, and convergence. The entire update process does not use vector similarity and backpropagation weight matrix multiplication as the core calculation method. Any scheme that performs endogenous confidence redistribution based on three-state normalization constraints and according to three competition modes of deterministic state self-reinforcement / negation state self-weakening / fuzzy suspension, regardless of whether it is named "Matthew", falls within the protection scope of this invention. S5 At each time step, the three-state time-series trajectory and connection change data are incrementally stored using a lightweight encoding method that characterizes the state change. The lightweight encoding method includes, but is not limited to, differential encoding, run-length encoding and their equivalent transformations. When the S6 deduction terminates, extract the instantaneous determination sd of all paths and generate the output vector; S7 receives external feedback or internal introspection feedback, and synchronously updates the tri-state parameters of the corresponding pathways and connections, with inference and learning completed simultaneously; the external feedback may come from environmental signals, task rewards, human annotations, or external system interfaces, etc. When the S8 system is idle under low load, it replays historical time-series trajectories and performs offline review and optimization. When S9 detects an output deviation, it traces the trajectory in reverse to locate the deviation path and connection, autonomously performs parameter correction, and verifies convergence. S10 repeats steps S1 to S9 in a loop, and the system continues to evolve autonomously.

[0095] III. Expected Beneficial Effects

[0096] By using the tri-state tuple as the smallest and only computational unit in the entire domain, it breaks through the representation bottleneck that single-valued vectors can only express intensity, and natively supports the processing of negation, ambiguity, and conflict information without the need for manual patching. The two-layer isolation architecture, while maintaining compatibility with existing vector interfaces, completely abandons the similarity matching and backpropagation weight matrix operation logic in the kernel, eliminating information loss caused by discrete snapshots from the root. The Matthew effect achieves natural convergence based on the three-state confidence normalization, and the three-state normalization constraint naturally provides the numerical evolution boundary. The core dynamic rules do not require manual setting of upper and lower limits of weights, loss functions, and core dynamic enhancement coefficients that determine the magnitude of competition intensity. Only the engineering adaptation parameters need to be adjusted according to the hardware scenario, without interfering with the core competition logic and the final steady-state distribution.

[0097] Training and inference are deeply integrated, and both online and offline modes can learn autonomously. It is expected to achieve continuous lifelong evolution and is not limited by the distribution of training data. Complete time-series trajectory is fully recorded, allowing for review, traceability, and autonomous error correction. This addresses the "black box" problem of artificial intelligence from an architectural perspective, improving system maintainability and reliability. The system can achieve fine-grained interpretability at the path level. It can not only trace the complete evolution process of decision results, but also locate the contribution and deviation points of each path and each connection. This is far superior to the coarse-grained interpretability of traditional models, which can only provide feature-level attention weights. It can directly support engineering needs such as algorithm auditing and fault location. The end-to-end traceability feature is expected to be naturally adapted to high-regulation and high-responsibility scenarios such as financial risk control, medical diagnosis, and autonomous driving. It can meet regulatory requirements such as algorithm compliance audit and decision responsibility tracing, and comply with the regulatory requirements for explainable and traceable algorithms in the "Interim Measures for the Administration of Generative Artificial Intelligence Services" and the "Regulations on the Administration of Algorithm Recommendation". It can be directly used as the compliance technology foundation for AI systems in high-risk fields, which is something that traditional black box models cannot achieve natively. The entire link exhibits continuous temporal evolution, which aligns with the continuous dynamic characteristics of the real world and eliminates the problem of discrete abrupt failures. It is expected to spontaneously form a critical chaotic topological steady state, while taking into account both stable inference efficiency and generalization ability in unknown scenarios. Input noise is automatically converted into fuzzy components, and it has native noise resistance capabilities, requiring no additional preprocessing module; It supports endogenous self-feedback and autonomous deduction without external input. It can complete self-cognitive correction and multi-scenario temporal deduction by relying on memory, further enhancing the system's autonomy. The incremental dynamic evolution mechanism of this architecture naturally alleviates the catastrophic forgetting problem of traditional neural networks: new feedback only incrementally adjusts the confidence and connection strength of the pathways, and the high confidence state of the original core pathways will not be overwritten in batches. Knowledge is continuously accumulated incrementally in the form of "core solidification and edge exploration", and long-term continuous learning can be achieved without replaying old data.

[0098] The vector interface is fully compatible with various existing AI software and hardware systems, and has low adaptation and migration costs. The computational complexity of the core Matthew confidence state update is O(N), and all paths can be fully parallelized. In fully connected mode, the signal transmission complexity is O(N²), but the operations are only simple multiplication and addition, with constant terms far lower than those of Transformer self-attention. In sparse connected mode, the overall computational complexity can be reduced to O(N), making it suitable for large-scale edge scenarios. Based on the total floating-point operation statistics of single-step derivation (excluding memory access, scheduling, and I / O overhead, representing a pure computational comparison of single-step kernel evolution), under the same 1024 dimensions, the single-step computational workload of this invention is theoretically significantly lower than that of Transformer single-head self-attention, possessing an order-of-magnitude advantage. This comparison is a theoretical estimate; actual performance is affected by hardware architecture and implementation methods. The Matthew evolution of the three-state path naturally possesses fine-grained parallelism. The state updates of each path can be executed independently and in parallel, without the serial dependency of gradient backpropagation. Under the hardware acceleration architecture, it is expected to achieve near-linear computing power expansion efficiency. Based on the self-organizing mechanism of confidence competition, the system only needs a small amount of feedback to form a stable functional path topology. The learning efficiency under small sample size is expected to be higher than that of traditional supervised learning models, which is especially suitable for vertical industry scenarios where labeled data is scarce. It supports dual-path implementation of software simulation and simulated neuromorphic hardware, adapting to the full range of needs from high-end computing clusters to micro edge chips; It does not require large-scale manually labeled datasets, but learns autonomously to adapt to specific scenarios based on environmental feedback. It does not require cloud training and updates, and the deployment and iteration costs are expected to be significantly reduced.

[0099] In conventional techniques in this field, ternary logic is often used for encoding and compression, and positive feedback is often used for adaptive gain. These two are independent techniques in different technical fields. This invention deeply combines three-state confidence normalization with Matthew endogenous competition, and achieves multiple technical effects such as unsupervised autonomous learning, full-link interpretability, low computational overhead, native noise resistance, and dynamic steady-state balance with a single underlying mechanism.

[0100] To achieve the aforementioned capabilities simultaneously, existing technologies require the separate stacking of multiple independent units, including encoding, learning, interpretability, noise reduction, and stabilization modules, significantly increasing system complexity. In contrast, this solution significantly reduces the number of system modules required for equivalent functionality. This solution relies solely on the underlying three-state structure and the Matthew rule to naturally emerge all capabilities; the resulting technical effect is not something that a person skilled in the art could reasonably expect based on existing technology, and thus represents an unexpected technical effect. Detailed Implementation

[0101] This section provides specific embodiments to illustrate the technical solution of the present invention in detail. The present invention does not involve specific mechanical structures or circuit layouts, therefore no drawings are provided. Those skilled in the art can implement the technical solution of the present invention based on the foregoing logical function description and the following code embodiments.

[0102] I. Standardize core terminology Logical signal path: An independent computational unit in the kernel that carries a single-dimensional confidence, corresponding one-to-one with the vector dimension; The ternary tuple (sd, sn, sf) is the smallest unit of computation at the bottom layer. It always satisfies sd+sn+sf=1. It can also be called a ternary confidence unit or a ternary normalized unit (not referring to ternary quantization). Three-state continuous vector field Ψ(t): kernel global temporal evolution carrier, where t is a continuous real time variable; Connectivity tri-states (c_sd, c_sn, c_sf): The tri-state representation of connectivity between pathways, following the Heb-type Matthew evolution rule; Matthew Dynamics: Internal redistribution rules under confidence conservation, divided into three types of feedback evolution modes; Integrated training and inference: In a single evolution, inference output and path parameter optimization are completed simultaneously; Incremental time-series trajectories: only store lightweight representations of numerical state micro-components or difference components, dynamically eliminating time-series records of low-value samples.

[0103] II. Software Simulation Implementation Example (1024-Dimensional Standard Kernel) Initial value robustness and attractor explanation

[0104] It should be noted that although a specific random seed (such as 42 in the code) is used in the initialization phase to ensure the reproducibility of the simulation process, the dynamic evolution of this system exhibits initial condition robustness. Based on Lyapunov stability theory, regardless of the initial random seed selection, the system eventually converges to the set of steady-state attractors corresponding to the feedback mode. Differences in the random seed only affect the length of the transient evolution path and do not change the characteristics of the final steady-state distribution (such as the proportion of core / middle / edge pathways). Therefore, those skilled in the art will understand that fixing the random seed is only an auxiliary means for simulation verification and does not constitute a limitation on the technical solution itself. 1. Initialization Rules

[0105] All paths are initially in a uniform chaotic state: sd=1 / 3, sn=1 / 3, sf=1 / 3, and the connection matrix is ​​initially uniform: c_sd=c_sn=c_sf=1 / 3.

[0106] When mapping inputs, the seed for starting the sn program is set to 0.1 by default. This value is only a cold start parameter and represents the system's default level of conservatism towards new inputs. The system will be quickly corrected by the Matthew effect within 10 rounds of operation. When the initial value changes within the range of 0.05 to 0.2, the final steady-state distribution difference is less than 3%, which does not affect the core evolution logic. 2. Complete and runnable implementation code

[0107] import numpy as np class ThreeStateAGICore: def __init__(self, dim=1024): self.dim = dim # Global Path Three-State Initialization: Uniform Chaotic State self.sd = np.full(dim, 1 / 3, dtype=np.float32) self.sn = np.full(dim, 1 / 3, dtype=np.float32) self.sf = np.full(dim, 1 / 3, dtype=np.float32) # Three-state matrix of inter-path connectivity: uniform initialization for fully connected (directed connection, i→j and j→i are independent) # Note: For large-scale scenarios, sparse matrix storage can be used instead, but the core rules remain the same. self.conn_sd = np.full((dim, dim), 1 / 3, dtype=np.float32) self.conn_sn = np.full((dim, dim), 1 / 3, dtype=np.float32) self.conn_sf = np.full((dim, dim), 1 / 3, dtype=np.float32) # === Engineering Adaptation Parameters (Affects only convergence speed, does not change steady-state distribution) === # Distance step scaling factor, corresponding to section 3.3 k_step in the manual, typical value 0.001~0.05 self.k_step = 0.01 # Global feedback discrete step size scaling factor, corresponding to section 3.4 of the manual, k_global (which includes the F coefficient), typical value 0.01~0.5 self.k_global = 0.1 # Pathway activation threshold, corresponding to section 1.1 of the instruction manual, typical value 0.5~0.7 self.activate_threshold = 0.6 # Signal transmission mixing ratio alpha, corresponding to section 1.3 of the instruction manual, typical value 0.2~0.5 self.signal_alpha = 0.3 # Connect to update the learning rate, corresponding to section 3.5 of the manual, conn_lr, with a typical value of 0.005~0.02. self.conn_lr = 0.01 self.temp_trajectory = [] self.trajectory_library = [] def input_mapping(self, input_vec: np.ndarray): Input vector mapping: Only initialize sd, sn uses the starting seed value. #42 is only an example fixed seed; in actual deployment, it can be replaced with any fixed integer to ensure the simulation is reproducible. # Fixed seeds are only used to ensure the reproducibility of the simulation process and do not affect the steady-state attractor that eventually converges to the system. """ np.random.seed(42) input_vec = np.clip(input_vec, 0.0, 1.0) self.sd = input_vec.copy() self.sn = np.full(self.dim, 0.1, dtype=np.float32) # Initial sn seed, default level of conservatism self.sd, self.sn, self.sf = self._self_consistency_fix(self.sd,self.sn) self.temp_trajectory.clear() self._save_current_state() def _self_consistency_fix(self, sd_arr, sn_arr): """ Three-state normalization self-consistent correction: guarantees sd+sn+sf=1 First, normalize the overflow path, then use clipping as a fallback, and finally recalculate sf to ensure the sum is 1. Taking into account the rounding error of floating-point operations, the final sf value is limited to the [0,1] range after the clip operation. """ total = sd_arr + sn_arr overflow_mask = total > 1.0 if np.any(overflow_mask): sd_arr[overflow_mask] / = total[overflow_mask] sn_arr[overflow_mask] / = total[overflow_mask] # Recalculate sf and then clip to ensure the tri-state sum is strictly 1. sf_arr = 1.0 - sd_arr - sn_arr sd_arr = np.clip(sd_arr, 0.0, 1.0) sn_arr = np.clip(sn_arr, 0.0, 1.0) sf_arr = np.clip(sf_arr, 0.0, 1.0) return sd_arr, sn_arr, sf_arr def _calc_global_sd_avg(self): return np.mean(self.sd) def _calc_cluster_sd(self): """ Calculate the average sd of the local pathway cluster (i.e., sd_cluster as defined in the specification). Sort by sd in descending order and take the average of the top 50%; no additional clustering algorithm is required, resulting in low computational cost. """ sd_sorted = np.sort(self.sd)[::-1] # Sort in descending order mid = self.dim / / 2 return np.mean(sd_sorted[:mid]) def _propagate_signals(self): """ Signal transmission across pathways: Based on the connection tri-state matrix, the upstream activation signal is transmitted to the downstream pathway. A single-channel transmission paradigm is adopted: only the SD activation signal is transmitted, and the Sn / SF ratio is automatically adjusted through autonomous correction. Positive excitation: sd × c_sd; Negative inhibition: sd × c_sn; Uncertainty decay: (1 - c_sf) Note: The matrix operation used here to achieve efficient parallel transmission is only an implementation method for engineering performance optimization; This matrix operation is an element-wise multiplication and addition operation connecting the three states and the path sd, and its connection strength evolves endogenously through the Heb-type Matthew rule. Compared to the weight matrix multiplication based on backpropagation training in traditional neural networks, this method differs in parameter update mechanism, computational objective, and dynamics. They are fundamentally different and do not violate kernel operation constraints.

[0108] """ net_conn = self.conn_sd - self.conn_sn attenuated_conn = net_conn * (1 - self.conn_sf) excitation = self.sd @ attenuated_conn # Efficient parallel passing of matrix multiplication form # Step 1: Normalize the mapping to [0,1] max_exc = np.max(np.abs(excitation)) if max_exc > 1e-6: # Linear mapping: [-|max|, |max|] → [0, 1] # When all excitations are negative, the mapping result falls in the interval [0, 0.5], which is equivalent to global suppression. normalized_exc = (excitation / max_exc + 1.0) / 2.0 else: normalized_exc = np.full_like(self.sd, 0.5) # Step 2: State mixing, retaining some of the original states to simulate the smoothness of continuous evolution. self.sd = self.sd * (1 - self.signal_alpha) + normalized_exc *self.signal_alpha self.sd, self.sn, self.sf = self._self_consistency_fix(self.sd,self.sn) def _apply_global_feedback(self, feedback_type: str): """ Global feedback allocation: The enhancement level is allocated according to the proportion of SD (Spiritual Damage), which conforms to the Matthew logic of the strong getting stronger. k_global is the global feedback discrete step size scaling factor (which incorporates the F factor from the specification). The engineering adaptation parameters only affect the convergence speed and do not change the final steady-state distribution.

[0109] """ sd_total = np.sum(self.sd) if sd_total <= 1e-6: return weight = self.sd / sd_total if feedback_type == "positive": delta_sd = self.sd * weight * self.k_global self.sd = np.minimum(1.0, self.sd + delta_sd) self.sn = self.sn * (1 - delta_sd) elif feedback_type == "negative": delta_sn = self.sn * weight * self.k_global self.sn = np.minimum(1.0, self.sn + delta_sn) self.sd = self.sd * (1 - delta_sn) self.sd, self.sn, self.sf = self._self_consistency_fix(self.sd,self.sn) def _update_connections(self): """ Hebrew-type Matthew connection update: Enhancement of co-activation, weakening of mis-activation, and fuzzy suspension. Based on the classic Heb rule, it is extended into a three-state competitive dynamics framework.

[0110] conn_lr is the connection update learning rate, an engineering-adaptive parameter with a typical value of 0.005~0.02.

[0111] The connection update frequency can be configured independently (per step / per N steps), and this embodiment uses per step update.

[0112] Note: A loop is used here to ensure logical clarity. In engineering implementation, performance can be optimized through vectorized parallel computation. This parallelization does not involve vector similarity matching or backpropagation weight matrix multiplication, and does not violate kernel operation constraints.

[0113] """ activate_mask = self.sd > self.activate_threshold inhibit_mask = self.sn > self.activate_threshold for i in range(self.dim): if not (activate_mask[i] or inhibit_mask[i]): continue for j in range(self.dim): if activate_mask[i] and activate_mask[j]: # Co-activated: Positive connection enhancement self.conn_sd[i, j] = min(1.0, self.conn_sd[i, j] * (1 + self.conn_sd[i, j]) * self.conn_lr) self.conn_sn[i, j] = self.conn_sn[i, j] * (1 - self.conn_sd[i, j]) elif activate_mask[i] and inhibit_mask[j]: # Misactivation (i-activation, j-inhibition): Connections are weakened in the reverse direction, and the repulsion strength increases. self.conn_sn[i, j] = min(1.0, self.conn_sn[i, j] * (1 + self.conn_sn[i, j]) * self.conn_lr) self.conn_sd[i, j] = self.conn_sd[i, j] * (1 - self.conn_sn[i, j]) # Other cases: No co-activation, maintains fuzzy suspension, does not trigger strong contention. self.conn_sd, self.conn_sn, self.conn_sf = self._self_consistency_fix( self.conn_sd, self.conn_sn ) def matthew_evolve(self, feedback: str, steps=1, feedback_level="path"): """ Matthew dynamics evolution :param feedback: Feedback type "positive" / "negative" / "fuzzy" :param steps: Number of evolutionary steps :param feedback_level: Feedback level "path" / "global" Note: In forward / backward discrete programming, the update of sn or sd uses the updated value of the other. It is consistent with the revised formula in sections 3.1 / 3.2 of the instruction manual.

[0114] """ for _ in range(steps): # Step 1: Signal Transmission Across Pathways (Associative Reasoning), on the Same Timescale as Matthew Evolution self._propagate_signals() sd_avg = self._calc_global_sd_avg() local_sd = self._calc_cluster_sd() # Corresponds to the sd_cluster defined in the specification threshold = min(sd_avg, local_sd) if feedback_level == "global": self._apply_global_feedback(feedback) self._update_connections() self._save_current_state() continue if feedback == "positive": # Forward reinforcement of discrete approximation (using the updated sd_{t+1} to compute sn_{t+1}) self.sd = np.minimum(1.0, self.sd * (1 + self.sd)) self.sn = self.sn * (1 - self.sd) elif feedback == "negative": # Reverse weakening of discrete approximation (compile sd_{t+1} using the updated sn_{t+1}) self.sn = np.minimum(1.0, self.sn * (1 + self.sn)) self.sd = self.sd * (1 - self.sn) else: # Fuzzy Suspended Competition: Dual threshold determination, competition intensity is inversely proportional to sf diff = np.abs(self.sd - self.sn) fuzzy_mask = diff <= threshold strength = 1 - self.sf delta = (self.sd - self.sn) * strength * self.k_step self.sd[~fuzzy_mask] += delta[~fuzzy_mask] self.sn[~fuzzy_mask] -= delta[~fuzzy_mask] self.sd, self.sn, self.sf = self._self_consistency_fix(self.sd,self.sn) self._update_connections() self._save_current_state() def output_snapshot(self) -> np.ndarray: """Outputs the SD snapshot vector, exposing only its determinism to the outside world.""" return self.sd.copy() def _save_current_state(self): """Records the current three-state state. This is simplified to full storage here; the actual project can be modified to incremental difference storage." Incremental storage can be further optimized using compression methods such as differential coding and run-length encoding. """ state_copy = ( self.sd.copy(), self.sn.copy(), self.sf.copy(), self.conn_sd.copy(), self.conn_sn.copy() ) self.temp_trajectory.append(state_copy) def save_trajectory_library(self): Save the tracks to the track library and automatically discard low-value tracks. final_avg_sd = np.mean(self.temp_trajectory[-1][0]) entry = {"traj": self.temp_trajectory.copy(), "avg_sd": final_avg_sd} self.trajectory_library.append(entry) self.trajectory_library.sort(key=lambda x: x["avg_sd"], reverse=True) base_cap = 800 dynamic_extra = int(400 * (1 - np.mean(self.sf))) max_cap = base_cap + dynamic_extra if len(self.trajectory_library) > max_cap: self.trajectory_library = self.trajectory_library[:max_cap] def backtrack_and_correct(self, traj_idx: int, error_step: int): """ Reverse tracing deviation and autonomous correction This embodiment uses a fixed scaling ratio (0.95 / 1.05) as a simplified implementation. In practical applications, it can be replaced by the inverse Matthew differential evolution without affecting the core introspective logic.

[0115] error_step is typically selected as the first K steps (K≤5) before the SD deviation exceeds a preset threshold (typically 0.1). Prioritize correcting the time point with the largest deviation.

[0116] """ if traj_idx >= len(self.trajectory_library): return traj_data = self.trajectory_library[traj_idx]["traj"] if error_step >= len(traj_data): return err_sd, _, _, err_conn_sd, err_conn_sn = traj_data[error_step] final_sd = traj_data[-1][0] final_conn_sd = traj_data[-1][3] # Positioning Deviation Path: Deviation time sd is significantly higher than the final result error_mask = err_sd > (final_sd + 0.1) # Reverse weakening correction path (fixed scaling) self.sd[error_mask] *= 0.95 self.sn[error_mask] *= 1.05 # Synchronous correction deviation connection # FIXED: Corrected historical typo err_conn_sad→err_conn_sd conn_error_mask = err_conn_sd > (final_conn_sd + 0.1) self.conn_sd[conn_error_mask] *= 0.95 self.conn_sn[conn_error_mask] *= 1.05 # Perform self-consistent correction to ensure the unification of the three states. self.sd, self.sn, self.sf = self._self_consistency_fix(self.sd,self.sn) self.conn_sd, self.conn_sn, self.conn_sf = self._self_consistency_fix( self.conn_sd, self.conn_sn ) # After correction, re-execute at least one Matthew evolution step to verify whether the output bias has been eliminated. self._propagate_signals() def self_reflection_evolve(self, steps=5): """ Endogenous self-feedback deduction: autonomous evolutionary correction based on historical memory without external input. Introspective evolution primarily performs directional correction for single-path confidence and does not trigger cross-path signal transmission. This ensures the accuracy of self-correction and prevents the correction signal from being diffused or diluted.

[0117] The feedback intensity coefficient k_global is reused here as the introspection step size, which only affects the convergence speed and does not change the core rules.

[0118] Correction: Use update logic consistent with the manual, and ensure numerical stability through self-consistent correction.

[0119] """ if len(self.trajectory_library) == 0: return # Use the average state of historical high-confidence trajectories as the benchmark for introspection. ref_sd = np.mean([t["traj"][-1][0] for t in self.trajectory_library[:10]], axis=0) # Compare the current state with historical benchmarks to generate endogenous feedback. diff = self.sd - ref_sd positive_mask = diff > 0.05 negative_mask = diff < -0.05 # Endogenous positive feedback: Current SD is higher than the historical high confidence benchmark, confirming reinforcement. self.sd[positive_mask] = self.sd[positive_mask] * (1 + self.sd[positive_mask] * self.k_global) self.sn[positive_mask] = self.sn[positive_mask] * (1 - self.sd[positive_mask] * self.k_global) # Endogenous negative feedback: The current SD is lower than the historical high confidence benchmark, weakening the correction. self.sn[negative_mask] = self.sn[negative_mask] * (1 + self.sn[negative_mask] * self.k_global) self.sd[negative_mask] = self.sd[negative_mask] * (1 - self.sn[negative_mask] * self.k_global) # Implement consistent self-correction to ensure the normalization of the three states and the correct calculation of sf. self.sd, self.sn, self.sf = self._self_consistency_fix(self.sd,self.sn) self._save_current_state() # Running Example if __name__ == "__main__": core = ThreeStateAGICore(dim=1024) test_input = np.random.rand(1024).astype(np.float32) core.input_mapping(test_input) core.matthew_evolve(feedback="positive", steps=12, feedback_level="path") output = core.output_snapshot() core.save_trajectory_library() core.backtrack_and_correct(traj_idx=0, error_step=6) core.self_reflection_evolve(steps=3) print("Average determination of the output vector:", round(float(np.mean(output)), 4)) print("Current global average ambiguity:", round(float(np.mean(core.sf)), 4)) 3. Initial value independence verification experiment

[0120] Three sets of control experiments were set up, with initial seeds of 0.05, 0.1, and 0.2 respectively. The system evolved continuously for 50 steps under the same input. The experimental results showed that the final sd distribution of the three sets was less than 3% different, and the steady-state topology was completely consistent. This verified that the initial seed value only affects the convergence speed and does not change the core evolution result. The initial uniform chaotic state ensures the maximum initial exploration space of the system, and the final steady state is determined only by the feedback mode.

[0121] III. Analog Circuit Hardware Examples The three-state Matthew dynamics is essentially a continuous-time nonlinear evolution process, which naturally matches the continuous physical characteristics of analog circuits. It eliminates the need for digital clock synchronization, analog-to-digital conversion, and significant storage read / write overhead, and is expected to significantly improve energy efficiency compared to similar-scale digital implementations (based on the characteristic of analog circuits having no clock switching overhead during continuous operation). This makes it an ideal architecture for low-power neuromorphic computing on the edge. The physical essence of its energy efficiency advantage lies in the fact that the continuous dynamic process of this architecture can be directly mapped from the physical evolution process of analog circuits, eliminating the multi-step conversion of encoding, computation, and decoding in digital computation. The physical process itself is the computational process, thus eliminating the conversion overhead of digital computation from the underlying layer.

[0122] This architecture can be implemented natively using analog circuits, without any digital matrix operations, and is compatible with ultra-low-power neuromorphic chips. The single-path core circuit structure consists of differential pair transistors, positive feedback operational amplifiers, integrating capacitors, and a total modulus normalization module. The two input voltages correspond to the forward branch of sd and the reverse branch of sn, respectively, and the differential pair transistors realize the competition between the two. The differential pair transistors can be NMOS differential pairs using CMOS technology, the positive feedback operational amplifier can adopt a folded common source and common gate structure, the integrating capacitor can be a MOS capacitor, and the total modulus normalization module can adopt a transconducting linear loop or a charge-conserving current mirror structure. The positive feedback operational amplifier achieves the self-reinforcing gain of SD, corresponding to the Matthew positive evolution rule; the reverse voltage divider circuit achieves the self-reinforcing gain of Sn, corresponding to the Matthew negative evolution rule. The integrating capacitor realizes the continuous evolution of time, corresponding to the continuous time variable t; The total modulus normalization module implements normalization constraints to clamp the sum of physical quantities representing the three states (including but not limited to voltage, current, charge, and light intensity) to a predetermined reference value V_DD or I_ref, naturally ensuring that the mapping of the three physical quantities is sd+sn+sf=1.

[0123] Multi-path array expansion: Single-path circuit units are arrayed and expanded to form an N-path hardware core; global feedback between paths is achieved through a common feedback bus, the bus voltage is proportional to the total SD, and the feedback intensity is allocated according to the SD ratio of each path.

[0124] Connection circuit: A programmable connection unit is set between each pair of paths. It also adopts a three-state voltage structure. When the connection is activated, the positive voltage of the connection is automatically increased. When the connection is not activated, the reverse suppression voltage of the connection is automatically increased, realizing the Heb-type Matthew rule.

[0125] Physical mapping: In analog circuits, the sf component is naturally mapped to the subthreshold leakage current or thermal noise of CMOS transistors, and in optical implementations, it is mapped to the intensity of scattered light or incoherent background light. It is an inherent property of the physical system rather than an optional design parameter and does not require additional human configuration.

[0126] Power consumption advantage: This analog circuit has no digital clock or memory read / write operation throughout the entire process, and only performs continuous analog operations. The expected power consumption is significantly lower than that of digital AI chips of the same size, making it suitable for battery-powered edge terminal scenarios.

[0127] IV. Real-world business implementation examples Example 1: General Dialogue Kernel Scenario

[0128] Expected workflow: Input is a 1024-dimensional semantic vector (SD) after text semantic encoding; semantic reasoning is completed through multiple rounds of forward Matthew evolution; ambiguous inputs automatically increase the SF value of the corresponding pathway, and no strongly certain incorrect answers are output; during low-load periods at night (CPU / computing power usage below 50%), historical dialogue trajectories are automatically replayed, and offline review and optimization are performed. The review process has lower priority than online reasoning tasks and does not preempt online service resources; when the system is idle, it automatically compares with historical high-confidence dialogue trajectories and autonomously corrects pathway confidence through endogenous feedback, without manual annotation. Theoretically, this can significantly reduce the factual error rate (hallucination rate), and the expected response speed can be greatly improved in high-frequency, fixed scenarios. Example 2: Autonomous Driving Perception and Decision-Making Scenario

[0129] Expected workflow: Input is multi-source perception data from cameras and radar, which is mapped to generate an input vector; collision detection pathways, due to their short feedback loops and high frequency of deterministic feedback, will have their confidence level (SD) spontaneously increased after Matthew evolution, naturally forming the highest response priority; when the characteristics of obstacles ahead are unclear, the confidence level (SF) of the corresponding pathway will increase, and the system will automatically execute a conservative deceleration decision; after a perception misjudgment occurs, the system will automatically backtrack the perception pathway trajectory and autonomously correct the confidence parameters of the corresponding pathway. Example 3: Low-power edge terminal scenario

[0130] Expected workflow: Employing a neuromorphic chip with analog circuitry, deployed in a battery-powered IoT sensing terminal; relying on environmental feedback to autonomously learn and adapt to specific scenarios, eliminating the need for cloud-based training and updates; during low-power sleep at night, the terminal automatically replays the day's sensing trajectory, consolidating its understanding through intrinsic feedback. After continuous autonomous learning, the expected detection accuracy is significantly improved; the expected average power consumption is substantially lower than comparable MCU solutions.

[0131] V. Steady-state emergence and ablation experiments 1. Dynamic Chaotic Steady-State Verification

[0132] After 1000 rounds of random input evolution, the pathway spontaneously forms a three-layer topology: high sd core pathways account for a small proportion, mid-level adaptive pathways are the main ones, and high sf exploration pathways account for a certain proportion; the global average sf stabilizes at a low level (usually maintained in the critical range of 0.2~0.4, based on theoretical simulation observation), and the system continuously maintains a critical balance between order and chaos. 2. Ablation Experiment Analysis Based on Theoretical Deduction

[0133] The theoretical deduction is based on the assumptions of "accurate feedback signals, no external malicious interference, and no physical faults in the pathway." Actual results may vary slightly depending on the complexity of the scenario. A complete baseline system and four ablation control groups were set up, and theoretical deduction analysis was performed under the same 1024-dimensional, same dataset, and same training rounds conditions. The fixed-weight baseline uses a vector with the same dimensionality as this invention. The weights are frozen after pre-training with the same data and are only used for forward inference without being updated, serving as a comparison benchmark.

[0134] Abolishing the three-state structure and retaining only the single SD vector: the system cannot distinguish between negative and ambiguous information, the expected rate of decision conflict and factual error increases significantly, and the expected noise robustness decreases significantly, verifying the necessity of the three-state representation; Eliminating the Matthew competition mechanism and replacing it with fixed weights: the pathway has no self-selection ability and cannot learn to adapt to new scenarios through feedback. The expected performance of the new scenario is significantly degraded, which verifies the core role of Matthew dynamics. Ablation of time-series trajectory storage, retaining only the current state: loss of self-reflection and tracing capabilities, errors can only be corrected through manual intervention, complete loss of autonomous error correction capabilities, and a significant increase in the expected time for error correction, verifying the value of trajectory storage and self-reflection mechanisms; Eliminating the endogenous self-feedback mechanism and retaining only external feedback: the system stops evolving after being separated from external input, cannot autonomously complete cognitive correction and deduction based on memory, and the expected efficiency of autonomous learning is significantly reduced, verifying the role of endogenous self-feedback in improving the system's autonomy.

Claims

1. A general intelligent continuous evolution implementation method based on three-state Matthew dynamics, characterized in that, At least the following steps are included: S1 Input Vector Mapping: Receives an external N-dimensional input vector, assigns the values ​​of each dimension to the initial certainty sd of the corresponding logical signal path, sets the initial negation degree sn seed value, generates the initial ambiguity sf through the normalization constraint sd+sn+sf=1, and performs three-state self-consistent correction. S2 constructs a continuous-time three-state vector field Ψ(t)={(sd_i(t), sn_i(t), sf_i(t)), i=1,…,N}, where t is a continuous real-time variable. The kernel adopts a two-layer isolation architecture, with the outer layer being a vector interaction interface layer and the inner layer being a three-state continuous vector field kernel. The inner layer does not use vector dot product, cosine similarity, matrix multiplication operations involving the weight matrix used for forward inference trained by the backpropagation algorithm, the backpropagation algorithm, or artificial loss functions as kernel calculation methods. That is, the essence of kernel evolution is the endogenous Matthew competition of three-state confidence, rather than parameter updates based on the gradient of the loss function. S3 Executes signal cross-path transmission: Based on the inter-path connection tuple (c_sd, c_sn, c_sf), the upstream path activation signal is transmitted to the downstream path. After normalization mapping and state mixing, the tuple values ​​of each path are updated. The connection tuples satisfy c_sd+c_sn+c_sf=1 and follow the Heb-type Matthew rule evolution. S4 performs a Matthew dynamics update based on the feedback type and level, synchronously updating the path's three states and the connection's three states. The Matthew dynamics is constrained by the three-state confidence normalization and evolves according to three modes: positive effective feedback reinforcement, negative ineffective feedback weakening, and fuzzy suspension competition. Feedback includes external feedback and internal introspective feedback. Global feedback allocates reinforcement magnitude according to the current SD ratio of each path. Any scheme that performs endogenous confidence redistribution based on the three-state normalization constraint and according to the three competition modes of deterministic state self-reinforcement / negative state self-weakening / fuzzy suspension, regardless of whether it is named "Matthew", falls within the protection scope of this invention. S5 At each time step, the three-state time-series trajectory and connection change data are incrementally stored using a lightweight encoding method that characterizes the state change. The lightweight encoding method includes, but is not limited to, differential encoding, run-length encoding and their equivalent transformations. When the S6 simulation terminates, extract the instantaneous sd of all paths to generate the output vector; S7 receives external feedback or internal introspection feedback, and synchronously updates the tri-state parameters of the corresponding pathways and connections, with inference and learning completed simultaneously; the external feedback may come from environmental signals, task rewards, human annotations, or external system interfaces, etc. When the S8 system is idle under low load, it replays the historical time-series trajectory to perform offline review. When an output deviation is detected, it reverses the trajectory to locate the deviation path and connection and corrects it autonomously. It cycles through S1 to S8 to enable the system to continuously evolve autonomously. Steps S1 to S8 are core and necessary steps. In actual implementation, auxiliary steps such as logging, monitoring, and exception handling can be added without affecting the core logic of the present invention. The three-state vector field and the execution subject of each step can be distributed in any one or more combinations of computing nodes such as cloud servers, edge terminals, vehicle chips, and IoT nodes. Distributed execution does not deviate from the protection scope of the present invention.

2. The method according to claim 1, characterized in that, The three evolutionary modes of Matthew dynamics mentioned in step S4 are as follows: Positive and effective feedback: sd self-growth, sn and sf compression; Reverse ineffective feedback: sn auto-increment, sd and sf compression; Fuzzy Suspended Competition: A dual-threshold collaborative determination is adopted using global average SD and local path cluster SD. Strong competition is suspended when |sd−sn|≤min(sd_avg, sd_cluster). The competition intensity is inversely proportional to SF. When SF approaches 1, the competition intensity approaches 0, and the system enters a completely suspended state. The local path cluster SD is the average value of the top 50% of high-confidence paths after sorting all path SD values ​​in descending order. All three types of modes are implemented using an engineering discrete approximation iterative method. The engineering discrete approximation is a qualitative behavioral approximation of the non-Euler method, which satisfies monotonicity, boundedness, and convergence.

3. The method according to claim 1, characterized in that, The Heb-type Matthew rule connecting the three states mentioned in step S3 is as follows: Co-activation enhancement: When both pathways are in a high SD activation state at the same time, c_SD is enhanced positively and c_SN is compressed. Misactivation weakening: When one pathway is highly SD-activated and the other is highly SN-inhibited, the connection between C_SN is positively enhanced and C_SD is compressed; No co-activation suspension: When there is no synchronous activation or inhibition of the two pathways, c_sf remains dominant and does not trigger strong competition; The local pathway cluster sd is obtained by sorting and taking the mean of the first half of the pathway sd or clustering by connection strength; Regardless of the initial distribution of the connecting three-state matrix (including but not limited to uniform distribution, Gaussian distribution, sparse distribution, or specific distribution based on prior knowledge), as long as its evolution follows the Heb-type Matthew rule and three-state normalization constraint described in this invention, it falls within the protection scope of this invention.

4. The method according to claim 1, characterized in that, The autonomous correction mentioned in step S8 includes inverse Matthew differential evolution or its engineering simplified approximation, the engineering simplified approximation includes fixed scaling; the system can also rely on complete temporal trajectory memory to generate endogenous introspective feedback by comparing its own output with the confidence of historical paths, so as to realize autonomous cognitive correction and multi-scenario temporal inference without external input; The autonomous correction can respond to existing output deviations, potential future deviation risks predicted based on historical trajectories, or endogenous fluctuations in the system's internal confidence level.

5. The method according to claim 1, characterized in that, The method also includes multimodal parallel extension: constructing multiple sets of independent and isolated three-state vector fields corresponding to different modes, setting low-dimensional interaction paths between modes to transmit cross-modal correlation confidence, and the low-dimensional interaction paths following the three-state normalization and Matthew evolution rules; multiple independent three-state vector fields can be connected through a high-speed interconnect bus to form a larger-scale kernel array, supporting higher-dimensional task processing, and the historical trajectories of different kernels can be shared, supporting cross-kernel introspection correction and knowledge transfer.

6. The method according to claim 1, characterized in that, The method also includes hierarchical cognitive expansion: pathways are clustered and aggregated to form higher-level abstract pathways, which follow the three-state normalization and Matthew dynamics rules, and information is transmitted between multi-level pathways through cross-layer connections.

7. The method according to claim 1, characterized in that, The method inherently possesses a noise robustness mechanism: external input signal jitter or multi-source inconsistency automatically maps and increases the corresponding path sf value, Matthew strong competition is synchronously suspended, and the noise path will not be rapidly amplified to form error solidification.

8. A neuromorphic computing device, implemented based on the method described in any one of claims 1-7, characterized in that, include: The vector input / output interface module is used to receive external input vectors and output SD snapshot vectors, and is compatible with, but not limited to, TensorFlow / PyTorch tensor interfaces, RESTful APIs, ONNX format interfaces, and sensor standard output interfaces. The three-state evolution and Matthew operation unit is used to maintain the three-state tuples (sd, sn, sf) and continuous vector field evolution of N logic signal paths, and execute the three types of Matthew evolution modes as described in claim 1; the three-state evolution and Matthew operation unit can be implemented by any one or combination of software executed by a general-purpose processor, application-specific integrated circuit, field-programmable gate array, analog circuit, digital circuit or firmware; The feedback processing unit is used to generate path-level feedback, global feedback, and endogenous introspective feedback based on historical memory. A three-state matrix storage unit is used to store and evolve the three states (c_sd, c_sn, c_sf) of the connection between pathways; The incremental trajectory storage unit is used to incrementally store the lightweight representation and connection change data of the three-state numerical state micro-components or difference components at each time step. It can use compression methods such as differential coding and run-length coding to optimize storage overhead. Self-inspection and correction control unit, used to reverse trace the trajectory and autonomously correct deviation paths and connections; When the three-state evolution and Matthew operation unit is implemented using analog circuits, three physical quantities are mapped to sd, sn, and sf respectively. These physical quantities include, but are not limited to, voltage, current, charge, and light intensity. A normalization constraint is implemented through a modulus normalization module, which is used to clamp the sum of the physical quantities characterizing the three states to a predetermined reference value. The sf component is naturally mapped to the subthreshold leakage current or thermal noise of the CMOS transistor in the analog circuit, and to the scattered light intensity or incoherent background light in the optical implementation. These are inherent properties of the physical system rather than optional design parameters. The vector input / output interface module, the three-state evolution and Matthew operation unit, the feedback processing unit, the connection three-state matrix storage unit, the incremental trajectory storage unit, and the self-correction control unit are logical functional module architectures, without limiting specific physical circuit wiring or geometric structures.

9. A computer-readable storage medium, characterized in that, Including but not limited to flash memory, hard disk, solid-state hard disk, optical disk, random access memory, and read-only memory, wherein a computer program is stored thereon, and when the computer program is executed by a processor, it implements the general intelligent continuous evolution implementation method based on the three-state Matthew dynamics as described in any one of claims 1 to 7.

10. A computer program product, characterized in that, The invention includes a computer-readable storage medium and a computer program stored therein, which, when executed by a processor, implements the general intelligent continuous evolution method based on three-state Matthew dynamics as described in any one of claims 1 to 7.