Data processing method, system, device, and storage medium

Abstract

This application discloses a data processing method, system, device, and storage medium, relating to the field of data processing technology. The method includes: after receiving a trigger command from a client, the server generates a decimal sequence of pi using a π clock module, extracts the target decimal string and converts it into color features, combines it with a local non-iterated hash value to generate a salted hash value, and distributes it to the client for consistency verification and pixel reconstruction; after the client sends back the iterative hash value, the server verifies it and triggers the next round of π bit-order advancement hash generation. This mechanism uses the mathematical constant π as a deterministic but unpredictable temporal driving source, deeply coupling content with the hash chain to achieve integrated rendering and verification, improving stability and traceability; multi-level iterative hashing and closed-loop verification effectively prevent forgery and skipping steps, enhancing security; the protocol does not rely on external random sources or device states, possessing cross-platform consistency and significantly improving versatility and deployment adaptability.

Description

Technical Field

[0001] This application relates to the field of data processing technology, and in particular to data processing methods, systems, devices, and storage media. Background Technology

[0002] With the continuous development of deep learning, data security, and cross-media convergence technologies, traditional data processing architectures face the following bottlenecks: First, the existing system processes text, images, videos, and structured data in a fragmented manner and lacks a unified multimodal feature framework, resulting in a large amount of redundancy in model interaction, system integration, and computing power optimization.

[0003] Second, different media (especially CMYK images, RGB videos, structural vectors, etc.) have non-linear differences in color space and feature space. Traditional methods cannot unify the mapping path, which can easily lead to deviations and loss of accuracy.

[0004] Third, when data is transmitted across terminals, devices, or the cloud, traditional encryption methods can provide basic security, but they lack a structured verification mechanism that is highly verifiable, difficult to forge, and difficult to bypass.

[0005] Fourth, there is currently a lack of a unified infrastructure that can simultaneously satisfy the requirements of universality, multimodality, verifiability, and scalability.

[0006] In this technological context, there is an urgent need for a solution to improve the stability, security, and versatility of data processing.

[0007] The above content is only used to help understand the technical solution of this application and does not represent an admission that the above content is prior art. Summary of the Invention

[0008] The main objective of this application is to provide a data processing method, system, device, and storage medium, aiming to solve the technical problem of how to improve the stability, security, and versatility of data processing.

[0009] To achieve the above objectives, this application proposes a data processing method applied to a server and specifically to image processing. The server includes a π clock module, and the method includes: After receiving the trigger command sent by the client, the π clock module generates a fractional digit sequence of π, and extracts the target fractional digit string after the target start position from the fractional digit sequence of π. Convert the target small number string into color features; Based on the color features, the target small number string, and the local uniterated hash value, a salted hash value is generated; Distribute the local uniterated hash value and / or the salted hash value to the client for the client to perform consistency verification and pixel content reconstruction; The system receives the iterative hash value generated based on pixel content reconstruction returned by the client, and performs consistency verification based on the iterative hash value to trigger the next round of hash value generation and distribution based on π bit order.

[0010] In one embodiment, the color feature includes at least one of RGB values, CMYK values, or a high-dimensional feature vector; The high-dimensional feature vector is generated by performing complex plane mapping, frequency domain transformation, or Riemannian geometric processing on RGB or CMYK values.

[0011] In one embodiment, the step of generating a salted hash value based on the color feature, the target small number string, and the local uniterated hash value includes: The color features and the target small number string are respectively mapped to feature vectors of the same dimension, and together with the local non-iterated hash value, they form a multimodal input tensor; The multimodal input tensor is fused and encoded to obtain a joint representation vector; The salted hash value is generated based on the joint representation vector.

[0012] In one embodiment, the step of performing consistency verification based on the iterative hash value to trigger the next round of hash value generation and distribution based on π bit order includes: The iterative hash value is cross-modal registered with the expected feature vector of the current π-position context. The cross-modal registration includes at least one operation among alignment, mapping, resampling and dimension normalization. Based on the registration results, multiple rounds of high-level feature inference are performed. The high-level feature inference includes at least one of high-dimensional geometric transformation, weight reconstruction, or interpretability enhancement to generate a joint representation. The joint representation is verified by a π clock verification layer to perform structural consistency verification, data non-repudiation verification, and feature link non-jump verification. If the verification passes, a new target small number string is generated based on the π decimal sequence segment corresponding to the next time slice, and the generation and distribution of the next round of salted hash value and un-iterated hash value are triggered.

[0013] Furthermore, to achieve the above objectives, this application also proposes a data processing method, which is applied to a client and specifically to image processing, the method comprising: When a display content update event is detected, a trigger command is sent to the server so that the server generates a π decimal sequence based on the π clock module and extracts the target small number string to generate a salted hash value. Receive local uniterated hash values ​​and / or salted hash values ​​distributed by the server; Consistency verification is performed based on the uniterated hash value and the salted hash value; After the consistency check passes, the salted hash value is parsed and the pixel content is reconstructed to generate an iterative hash value; The iterative hash value is sent back to the server for the next round of consistency verification and hash chain iteration.

[0014] In one embodiment, the step of parsing the salted hash value and reconstructing the pixel content to generate an iterative hash value includes: Based on the color features corresponding to the salted hash value and the target small number string, and combined with the preset structure parsing rules, a structure sequence is generated. The structure sequence includes at least one of semantic structure, image composition structure, temporal structure, dependency graph structure or geometric mapping structure. Based on the structural sequence and the color features, the spatial distribution and color attributes of the pixels are reconstructed to rebuild the image content; The iterative hash value is generated based on the reconstructed image content.

[0015] In one embodiment, the step of reconstructing the spatial distribution and color attributes of pixels based on the structural sequence and the color features to reconstruct the image content includes: The pixels are managed using a pixel feature-based hash clustering storage structure, wherein pixel IDs with the same color features are attached to the same feature hash linked list. When the color feature of any pixel changes, the pixel ID is migrated from the original feature hash list to the corresponding new feature hash list. When the screen content changes, the invalid color feature hash list is cleared to release the cache.

[0016] In addition, to achieve the above objectives, this application also proposes a data processing system, which includes a server and a client. The server includes: The π sequence generation module generates a fractional digit sequence of π using the π clock module, and extracts a target fractional digit string after the target starting position from the fractional digit sequence of π. The color mapping module is used to convert the target small number string into color features; A hash construction module is used to generate a salted hash value based on the color feature, the target small number string, and the local uniterated hash value; The distribution module is used to distribute the local uniterated hash value and / or the salted hash value to the client for the client to perform consistency verification and pixel content reconstruction. The verification and iteration module is used to receive the iterative hash value generated based on pixel content reconstruction returned by the client, and to perform consistency verification based on the iterative hash value to trigger the next round of hash value generation and distribution based on π bit order. The client includes: A receiving module is used to receive local uniterated hash values ​​and / or salted hash values ​​distributed by the server, wherein the salted hash value is generated by the server based on color features, a target small number string extracted from the π decimal sequence, and the local uniterated hash value; The verification module is used to perform consistency verification based on the un-iterated hash value and the salted hash value; The reconstruction and hash generation module is used to parse the salted hash value and reconstruct the pixel content after the consistency check passes, and generate an iterative hash value. The backhaul module is used to send the iterative hash value back to the server for the next round of consistency verification and hash chain iteration.

[0017] In addition, to achieve the above objectives, this application also proposes a data processing apparatus, the apparatus comprising: a memory, a processor, and a computer program stored in the memory and executable on the processor, the computer program being configured to implement the steps of the data processing method described above.

[0018] In addition, to achieve the above objectives, this application also proposes a storage medium, which is a computer-readable storage medium, on which a computer program is stored, and which, when executed by a processor, implements the steps of the data processing method described above.

[0019] In addition, to achieve the above objectives, this application also provides a computer program product, which includes a computer program that, when executed by a processor, implements the steps of the data processing method described above.

[0020] This application proposes a data processing method, system, device, and storage medium. The method includes: after receiving a trigger command sent by a client, the server generates a π decimal sequence of pi using a π clock module, and extracts a target small number string after the target start position from the π decimal sequence; converts the target small number string into a color feature; generates a salted hash value based on the color feature, the target small number string, and a local uniterated hash value; distributes the local uniterated hash value and / or the salted hash value to the client for the client to perform consistency verification and pixel content reconstruction; receives the iterative hash value generated based on pixel content reconstruction returned by the client, and performs consistency verification based on the iterative hash value to trigger the next round of hash value generation and distribution based on the π bit order. This solution introduces a deterministic yet unpredictable time-driven mechanism based on the mathematical constant π, deeply coupling data content with the hash chain. This achieves integrated generation of rendered content and verification credentials, significantly improving the stability and traceability of the data processing process. Simultaneously, multi-level iterative hashing and server-side verification mechanisms effectively prevent client-side cheating or forgery of rendered data, thereby enhancing data processing security. Furthermore, since the hash generation and verification process is uniquely driven by the π bit sequence and does not depend on external random sources or specific device states, the entire interaction protocol possesses determinism, reproducibility, and cross-platform consistency. It can implement unified security verification logic on different client devices, thus improving the solution's versatility and deployment adaptability. Attached Figure Description

[0021] The accompanying drawings, which are incorporated in and form part of this specification, illustrate embodiments consistent with this application and, together with the description, serve to explain the principles of this application.

[0022] To more clearly illustrate the technical solutions in the embodiments of this application or the prior art, the drawings used in the description of the embodiments or the prior art will be briefly introduced below. Obviously, for those skilled in the art, other drawings can be obtained based on these drawings without creative effort.

[0023] Figure 1 This is a flowchart illustrating an embodiment of the data processing method of this application. Figure 2 This is a flowchart illustrating Embodiment 2 of the data processing method of this application; Figure 3 This is a schematic diagram of the module structure of the data processing system according to an embodiment of this application; Figure 4 This is a schematic diagram of the device structure of the hardware operating environment involved in the data processing method in the embodiments of this application.

[0024] The purpose, features, and advantages of this application will be further explained in conjunction with the embodiments and with reference to the accompanying drawings. Detailed Implementation

[0025] It should be understood that the specific embodiments described herein are merely illustrative of the technical solutions of this application and are not intended to limit this application.

[0026] To better understand the technical solution of this application, a detailed description will be provided below in conjunction with the accompanying drawings and specific implementation methods.

[0027] The main solution of this application embodiment is as follows: After receiving the trigger command sent by the client, the server generates a π decimal sequence through the π clock module, and extracts the target small number string after the target start position from the π decimal sequence; converts the target small number string into a color feature; generates a salted hash value based on the color feature, the target small number string, and the local uniterated hash value; distributes the local uniterated hash value and / or the salted hash value to the client for the client to perform consistency verification and pixel content reconstruction; receives the iterative hash value generated based on pixel content reconstruction returned by the client, and performs consistency verification based on the iterative hash value to trigger the next round of hash value generation and distribution based on π bit order.

[0028] In this embodiment, for ease of description, the following description will focus on the data processing system as the execution subject.

[0029] The lack of a unified data processing infrastructure in existing technologies leads to significant bottlenecks in multimodal fusion, cross-dimensional feature mapping, and structural security verification. On the one hand, text, images, videos, and structured data typically employ fragmented processing paths, making it difficult to construct a shared feature matrix, resulting in complex model interactions, difficulties in system integration, and waste of computing resources. On the other hand, different media types (such as CMYK printed images, RGB screen videos, and structured vectors) exhibit nonlinear differences between color spaces and feature spaces, and traditional mapping methods lack consistency guarantees, easily introducing biases and accuracy losses. Furthermore, existing security mechanisms largely rely on traditional encryption methods, making it difficult to provide strong verifiability, unforgeable, and unskippable structural integrity guarantees in cross-terminal or cloud transmission scenarios.

[0030] This application provides a solution that enables a data processing system to organically integrate multimodal compatibility, stable cross-space mapping, and a chain-based verifiable security mechanism within a unified architecture. Specifically, this application introduces a decimal sequence of pi (π) as a deterministic but unpredictable global temporal anchor, deeply coupling heterogeneous data content (including but not limited to color features and structural information) with a hash verification chain. The system generates color features derived from the pi bit sequence on the server side and constructs a salted hash value based on the local hash state, distributing it to the client for consistency verification and content reconstruction. After the client returns the iterative hash, the server performs closed-loop verification based on the pi bit sequence advancement mechanism, forming a non-skipping and non-forgeable chain-based secure process. This solution not only achieves integrated generation of data representation and verification credentials, improving processing stability and traceability, but also supports unified deployment in different terminal environments through the mathematical determinism and device independence of the protocol itself, effectively addressing the core deficiencies of existing technologies in terms of universality, security, and multimodal collaboration.

[0031] It should be noted that the executing entity in this embodiment can be a computing service device with data processing, network communication, and program execution functions, such as a tablet computer, personal computer, or mobile phone, or an electronic device capable of performing the above functions. The following description uses a personal computer as an example to illustrate this embodiment and the subsequent embodiments.

[0032] Based on this, embodiments of this application provide a data processing method, referring to... Figure 1 , Figure 1 This is a flowchart illustrating the first embodiment of the data processing method of this application.

[0033] In this embodiment, the data processing method is applied to the server and specifically to image processing. The method includes steps S10-S50: Step S10: After receiving the trigger command sent by the client, the π clock module generates a π decimal sequence and extracts the target decimal string after the target start position from the π decimal sequence. It should be noted that the Pi Clock Module is a deterministic timing-driven unit built on the mathematical constant pi (π), used to generate a digital stream of the fractional part of pi at a preset rhythm (continuous or random intervals). This module is built into the server and serves as the global timing anchor point for the entire verification and data generation process, as well as a dynamic seed source in the security protocol.

[0034] In a preferred embodiment, the π clock module is the core component of the enhanced π clock system, and its operation follows a complete closed-loop process to ensure absolute reliability of global timing. This process includes the following key stages: Phase 1: System Startup and Initialization. After the server powers on, a one-time physical anchoring is performed first. The rubidium atomic clock in the central time synchronization node and the BeiDou time synchronization module perform self-testing and fusion calibration to generate a high-precision, tamper-proof initial physical time anchor point. This anchor point It is the physical foundation for all subsequent timing calculations in the entire system.

[0035] Phase Two: Global Distribution and Local Deployment. The server will contain the initial anchor point. A lightweight timing package containing atomic clock timing parameters and π clock mapping rules is distributed to all relevant nodes (including the server itself). Each node then rebuilds its π clock calculation capabilities locally based on this package.

[0036] Phase Three: Daily Steady-State Cycle. The system enters a 24 / 7 core operation state. At this time, the π clock module in this embodiment does not operate independently, but relies on an established physical reference. It is based on the initial anchor point. Using the reference frequency provided by the atomic clock, the current π sequence index N(t) is calculated locally and independently in real time. In the application scenario of this embodiment, the π sequence index N(t) directly determines the target starting position P1 for truncating the π decimal sequence. Since all nodes share the same physical anchor point and mathematical rules, the calculated P1 is naturally aligned, eliminating the need for frequent network synchronization.

[0037] Phase Four: Periodic Calibration Cycle. To prevent minor drift from the atomic clock during long-term operation, the system automatically triggers a calibration at a fixed period (default 24 hours). The central node re-integrates the atomic clock and BeiDou signals, updates the physical reference, and silently sends fine-tuning parameters to each node. Each node then corrects its local π clock mapping parameters accordingly, ensuring long-term deviation-free operation. This process guarantees that the advancement of P1 in this embodiment remains accurate and reliable.

[0038] Phase 5: Abnormal Self-Healing Cycle. When encountering BeiDou signal loss, network interruption, or single point of failure, the system can automatically switch to atomic clock timekeeping mode (which can last for 72 hours), or predict timing through the mathematical laws of π clocks to maintain business continuity, and automatically calibrate and align after the network is restored.

[0039] The π decimal sequence is an infinite sequence of digits starting from the first decimal place in the decimal representation of π. To achieve efficient access to any position in the π decimal sequence, the π clock module employs a hexadecimal π digit extraction algorithm based on the BBP formula.

[0040] The BBP formula is:

[0041] Where k is the summation index variable, representing a non-integer starting from 0.

[0042] The target start position is a specified starting position index from the π decimal sequence, used to identify the starting point of the truncation operation. In this embodiment, the target start position is denoted as P1 (for example, P1=1000 means truncation starts from the 1000th decimal place). P1 can be determined by time-driven, random number-driven, or access volume, and is jointly driven by a multi-source π cluster.

[0043] The target small number string refers to a string consisting of N consecutive decimal digits extracted starting from the target starting position P1. In this embodiment, the target small number string is denoted as pi1, and the length N can be dynamically configured according to the security strength or data granularity requirements (e.g., N = 64, 128 or 256 bits), where pi1 = π[P1, P1+N].

[0044] In this embodiment, when step S10 is executed, the system not only generates the target string, but also simultaneously creates a mathematical timestamp. This is used to uniquely identify the timing context of this operation. The mathematical timestamp is defined as a triple:

[0045] Among them, the This is the starting position index of the currently extracted π decimal place sequence, i.e., the target starting position; A is the algorithm identifier provided by the π bits used; This is the high-precision physical reference time obtained by the π clock system during this operation.

[0046] Specifically, when determining the target starting position P1 and the subsequent N digits, the system first converts the index P1 into its corresponding hexadecimal position. Then, using the BBP formula, the N hexadecimal digits starting from position P1 can be directly obtained through only a finite number of iterations. These hexadecimal digits are then converted into a decimal string, yielding the desired target small number string pi1.

[0047] Finally, the target small number string pi1 and its corresponding digital event stamp are... The pi1 is output together as the original input for subsequent color feature generation and hash construction.

[0048] Step S20: Convert the target small number string into color features; In this embodiment, the system converts the target small number string pi1 into a color feature C1, wherein the color feature includes at least one of CMYK value, RGB value or high-dimensional feature vector.

[0049] It should be noted that the CMYK values ​​refer to the color model components for color printing, consisting of four channels: Cyan (C), Magenta (M), Yellow (Y), and Key / Black (K). The value range for each channel is typically 0% to 100% (or normalized to 0.0 to 1.0). In this embodiment, pi1 can be divided into four numerical substrings according to a fixed rule, and mapped to the C, M, Y, and K components respectively, thereby generating a color representation that conforms to the printing color space.

[0050] The RGB values ​​refer to the color model components used in electronic display devices, which consist of three channels: red (R), green (G), and blue (B). The typical value range for each channel is 0 to 255 (or normalized to 0.0 to 1.0).

[0051] The high-dimensional feature vector refers to... The feature representation obtained by mapping to a real vector space with a dimension greater than 3 can have its dimension set according to the requirements of downstream tasks (such as 64-dimensional, 128-dimensional, or 512-dimensional).

[0052] Furthermore, in this embodiment, in order to improve the visual rendering quality, the generated color feature C1 can be enhanced, for example by using methods such as complex plane mapping, frequency domain analysis or Riemann geometric embedding, to convert it into high-quality RGB output, thereby optimizing the color performance and detail reproduction capability of the final image while preserving the mathematical consistency of the π sequence.

[0053] Through the above conversion mechanism, this embodiment realizes a flexible mapping from a pure digital sequence pi1 to multiple color representation forms, which is compatible with traditional display and printing systems and supports high-dimensional semantic interfaces for AI models, providing a unified and scalable feature foundation for subsequent salted hash construction and pixel content reconstruction.

[0054] Step S30: Generate a salted hash value based on the color feature, the target small number string, and the local uniterated hash value; It should be noted that the local uniterated hash value H0 refers to the initial hash state held by the client before the start of the current verification round. It is typically distributed by the server in the previous round or generated during system initialization and serves as the seed for the hash calculation in this round. In this embodiment, the H0 layer is responsible for receiving arbitrary data input, including text, images, audio, video, dependency graphs, structured data, etc., and performing preprocessing, including normalization, noise filtering, preliminary format cropping, and optional CMYK to RGB color space conversion, to provide standardized input for subsequent unified feature extraction.

[0055] Understandably, since existing hashing mechanisms typically use static or random salt values, it is difficult to link them with content semantics and global temporal state. Therefore, in step S30, when generating salted hash values, color features driven by the π clock and a number string are introduced as dynamic salt sources and historical hash states are integrated. This avoids the problems of verification credentials being disconnected from content and being easily forged or replayed in traditional schemes, and realizes a secure verification mechanism that is parsable, traceable in state, and has a non-jumpable link.

[0056] In one feasible embodiment, step S30 may include steps S31 to S33: Step S31: Map the color features and the target small number string to feature vectors of the same dimension, and form a multimodal input tensor with the local non-iterated hash value; In this embodiment, the above operations are performed by the H1 layer (feature vectorization layer) in the system architecture. Specifically, the color features are mapped to n-dimensional real vectors, for example, by converting RGB values ​​into complex coordinates through complex plane embedding and then expanding them into real vectors; the target small number string is regarded as a string or certificate sequence, and projected into the same n-dimensional space after token embedding or numerical encoding; the local non-iterative hash value is converted into an n-dimensional vector in the form of a byte sequence through linear projection or hash embedding. Finally, the three are concatenated along the feature dimension or sequence dimension to form a structured multimodal input tensor.

[0057] Step S32: Perform fusion encoding on the multimodal input tensor to obtain a joint representation vector; In this embodiment, the fusion encoding can employ a lightweight multi-head attention mechanism and a cross-modal cross-network security connection fusion module to capture the deep correlation between color semantics, π sequence content, and historical states. This process is a crucial step in the transition from the H1 layer to higher layers. The output joint representation vector retains the original information of each modality while also reflecting its interactive semantics. Its dimension is typically n or m (m≤n), exhibiting good compactness and discriminability.

[0058] Step S33: Generate the salted hash value based on the joint representation vector.

[0059] In this embodiment, the joint representation vector is input into a cryptographically secure hash function (such as SHA-3, BLAKE3, or Argon2) to generate a fixed-length salted hash value H1. Since the "salt" component of this hash value comes from the dynamic content in the unified vector space of the H1 layer, rather than static random numbers, H1 not only has strong collision resistance and anti-forgery capabilities, but also implicitly contains reversible visual and structural information, which can be used for subsequent pixel content reconstruction and consistency verification by the client.

[0060] Through the feature vectorization and fusion mechanism driven by the H1 layer, this embodiment realizes the alignment and integration of heterogeneous inputs in a unified semantic space, making the salted hash generation process secure, semantically rich and cross-modal compatible, laying the core foundation for building a verifiable and scalable π architecture.

[0061] Step S40: Distribute the local uniterated hash value and / or the salted hash value to the client for the client to perform consistency verification and pixel content reconstruction; In this embodiment, the server sends the local uniterated hash value H0 and / or the salted hash value H1 to the client through a secure communication channel (such as a TLS encrypted connection, WebSocket, or a dedicated API interface). The client then performs a consistency check based on the local uniterated hash value H0 and / or the salted hash value H1, parses H1 to reconstruct the pixel content, and generates an iterative hash. Send back to the server.

[0062] The specific distribution strategy can be flexibly configured according to the application scenario: In the security verification mode, H0 and H1 are distributed simultaneously, enabling the client to perform hash consistency verification independently. In lightweight mode, only H1 is distributed, while H0 is maintained locally by the client based on the previous round's state to reduce bandwidth overhead. During the initialization phase, if there is no historical state, H0 can be set to a preset system-known initial value and sent along with the first frame H1.

[0063] It is worth noting that the distributed H1 not only serves as a verification credential but also implicitly contains parsable visual semantic information: the client can regenerate pi1 based on the same π starting bit P1, thereby restoring color features and ultimately reconstructing pixel content consistent with the client's. This mechanism ensures the homogeneity between the rendering result and the verification credential, fundamentally preventing the possibility of the client forging the image and deceiving the server through false hashes.

[0064] In addition, to improve transmission efficiency, H0 and H1 can be encoded in binary compactly, and metadata can be added when necessary to assist the client in accurately executing the subsequent parsing and reconstruction process.

[0065] Step S50: Receive the iterative hash value generated based on pixel content reconstruction returned by the client, and perform consistency verification based on the iterative hash value to trigger the next round of hash value generation and distribution based on π bit order.

[0066] Understandably, if only one-way distribution is relied upon without client state feedback, the server cannot confirm whether the client has actually performed content reconstruction, whether there is screen forgery, or whether intermediate verification rounds have been skipped. Therefore, step S50 is executed to introduce the iterative hash value returned by the client and perform bidirectional consistency verification. This avoids the security flaw of "blindly trusting the client output" in the traditional one-way verification mechanism, thereby realizing closed-loop verification of chained states and non-jumpable temporal progression, ensuring that the entire data processing flow has strong traceability, anti-forgery, and structural integrity.

[0067] In one feasible embodiment, step S50 may include steps S51 to S54: Step S51: Perform cross-modal registration between the iterative hash value and the expected feature vector of the current π-position context. The cross-modal registration includes at least one operation among alignment, mapping, resampling, and dimension normalization. In this embodiment, the above operations are performed in the H3 layer (multimodal fusion layer), where structural sequences from different modalities are configured across modalities. For example, Step S52: Based on the registration results, perform multiple rounds of high-level feature inference, wherein the high-level feature inference includes at least one of high-dimensional geometric transformation, weight reconstruction or interpretability enhancement, to generate a joint representation; In this embodiment, the above operations are performed in the H4 layer (high-level feature inference layer). The H4 layer performs deep semantic extraction on the registered multimodal features, for example, by capturing nonlinear structural relationships through high-dimensional geometric transformations on the Riemannian manifold, or by dynamically reconstructing the feature importance distribution using attention weights, thereby outputting a highly discriminative joint representation vector to accurately characterize the system state of the current verification round.

[0068] Step S54: If the verification is successful, a new target small number string is generated based on the π decimal sequence segment corresponding to the next time slice, and the generation and distribution of the next round of salted hash value and un-iterated hash value are triggered.

[0069] In this embodiment, the π clock verification layer serves as the core security module, performing triple verification: Structural consistency verification: Confirm whether the joint representation conforms to predefined multimodal structural constraints (such as pixel layout and semantic label matching); Data non-repudiation verification: ensures that the iterative hash value is indeed generated by a legitimate client based on real reconstructed content and cannot be forged by a third party; Feature link non-jump verification: Verify the current π start bit Whether it is strictly equal to the previous round's termination bit is used to prevent the client from skipping intermediate states and directly generating subsequent hash values.

[0070] After completing the above triple verification and all results are passed, the π clock verification layer further performs a final digital signature on the verification result (e.g., using the server's private key). The system uses P1, timestamps, and verification logs to sign the data, and then securely archives the signed verification record to a trusted log system or blockchain evidence storage platform. This archived data can be used for subsequent audits, dispute resolution, or compliance verification, ensuring that the entire interaction process has verifiable, traceable, and non-repudiable security attributes.

[0071] The system then advances the π clock pointer to the next time slice position (e.g., from the current starting position). Advance to = +N, where N is the length of the target small number string extracted in the previous round), and based on the new π decimal place sequence segment. Generate corresponding color features Furthermore, this is combined with the iterative hash value returned and verified by the client in the previous round. As the new local non-iterative hash value, construct the next round of salted hash value. and distribute to clients and The client then performs a new round of consistency checks and pixel content reconstruction, and sends back the new iterative hash value. This continuously forms a chain-like security verification process that is unforgeable, unskippable, and traceable, driven by the π bit sequence and linked by the hash chain.

[0072] Through the methods described above, after receiving the trigger command sent by the client, the server generates a fractional sequence of pi (π) using the π clock module, and extracts a target small number string after the target starting position from the π fractional sequence. This utilizes π, a public, deterministic but unpredictable mathematical constant, as a global temporal anchor point, providing a dynamic seed with infinite non-cyclic characteristics that requires no external random source for the entire verification and rendering process, thus ensuring the uniqueness and reproducibility of the system state evolution. Converting the target small number string into color features allows for the carrying of rich image information with extremely low data volume, laying the content foundation for subsequent pixel reconstruction. Based on the color features, the target small number string, and the local un-iterated hash value, a salted hash value is generated, which deeply integrates content semantics, temporal context, and historical state, constructing a hash value that combines cryptographic security and resolvability. Dynamic credentials effectively prevent security blind spots caused by static salt values; distributing local non-iterated hash values ​​and / or the salted hash values ​​to the client for consistency verification and pixel content reconstruction, enabling the client to autonomously complete the entire frame while transmitting only tens to hundreds of bytes of hash values ​​and a small number of meta-parameters, significantly reducing network bandwidth requirements; receiving the iterative hash values ​​generated based on pixel content reconstruction returned by the client, and performing consistency verification based on the iterative hash values ​​to trigger the next round of hash value generation and distribution based on π bit order, enabling the construction of an end-to-end closed-loop chain verification mechanism. Through strong binding of multi-level hashes and π bit order, it ensures that each frame is strictly dependent on the previous state for generation, effectively preventing client forgery, skipping steps, or intermediate state tampering, achieving high security consistency, and supporting flexible deployment from lightweight terminals to distributed AI rendering clusters.

[0073] In summary, this invention, through mathematically driven content generation and a chain-based verifiable architecture, achieves ultra-low bandwidth consumption, strong scalability, and cross-scenario adaptability while ensuring extremely high security. It provides a safe, efficient, and mathematically verifiable new technical framework for applications such as cloud rendering, multiplayer game synchronization, remote sensing image distribution, deep space communication, and distributed intelligent graphics systems.

[0074] Based on the first embodiment of this application, in the second embodiment of this application, the content that is the same as or similar to that in the first embodiment described above can be referred to the above description, and will not be repeated hereafter. Based on this, please refer to... Figure 2 , Figure 2 This is a flowchart illustrating the second embodiment of the data processing method of this application.

[0075] In this embodiment, the data processing method is applied to a client and specifically to image processing. The method includes steps S60-S100: Step S60: When a display content update event is detected, a trigger command is sent to the server so that the server generates a π decimal sequence based on the π clock module and extracts the target small number string to generate a salted hash value. In this embodiment, the "display content update event" includes, but is not limited to: user interaction operations (such as clicking, swiping, and perspective switching), application state changes (such as game scene transitions and data refreshes), timed rendering requests, or system frame synchronization signals. Upon detecting any such event, the client immediately sends a lightweight trigger command to the server (e.g., an HTTP / HTTPS request or WebSocket message containing a timestamp, device identifier, and optional context parameters). This trigger command does not carry screen data; it serves only as a synchronization start signal to notify the server to advance the π clock pointer to the beginning of the current cycle and generate the corresponding color feature and salted hash value based on the newly extracted target small number string.

[0076] Through this mechanism, the client actively drives the server to generate verification credentials and content seeds on demand, realizing event-driven on-demand synchronization, avoiding resource waste caused by invalid polling or fixed frame rates, and ensuring that all rendered content is strictly aligned with user intent or system state.

[0077] Step S70: Receive the local un-iterated hash value and / or salted hash value distributed by the server; In this embodiment, the client receives data packets from the server through a secure communication channel. These data packets contain at least a salted hash value H1 and optionally a local, un-iterated hash value H0 and auxiliary metadata (such as the π start bit P1, the string length N, and color space identifiers). If the system is in a continuous verification cycle, H0 can also be maintained locally by the client based on the state after the previous successful verification, eliminating the need for repeated transmission and further reducing bandwidth overhead. After receiving the data, the client temporarily stores it in a local secure cache to prepare for subsequent consistency checks and content reconstruction.

[0078] Step S80: Perform consistency verification based on the un-iterated hash value and the salted hash value; In this embodiment, the client first calls the locally built-in π clock module to regenerate the same target small number string pi1 based on the received P1 and N parameters; then, following the same mapping rules as the server (such as RGB three-channel partitioning, complex plane embedding, etc.), pi1 is converted into color feature C1; next, the same hash algorithm is used to fuse H0, C1, and pi1 to generate a local verification hash value. Finally, The data is compared bit by bit with the H1 distributed by the server. If the two are completely identical, it is determined that the distributed data has not been tampered with and the server status is trustworthy, and the verification passes; otherwise, it is determined that there is a man-in-the-middle attack, data corruption, or server abnormality, the current process is terminated, and a security alarm is triggered.

[0079] Through the above mechanism, the client can verify the authenticity and integrity of the content distributed by the server without relying on additional keys or complex encryption protocols, using only publicly computable π sequences and standard hash functions, thus providing a reliable trust foundation for subsequent pixel reconstruction.

[0080] Step S90: After the consistency check passes, the salted hash value is parsed and the pixel content is reconstructed to generate an iterative hash value; Understandably, if only hash verification is completed without content reconstruction and feedback, the server cannot confirm whether the client truly has rendering capabilities or whether there is an intermediate attack where "verification passes but the image is forged". Therefore, step S80 is executed to avoid the security vulnerability of "verification and content being disconnected" in traditional solutions. This achieves a trusted closed-loop mechanism of verification as rendering and rendering as proof, ensuring that the client not only "knows the correct answer" but also "can truly generate the corresponding image".

[0081] In one feasible embodiment, step S90 may include steps S91 to S93: Step S91: Based on the color features corresponding to the salted hash value and the target small number string, and combined with the preset structure parsing rules, a structure sequence is generated. The structure sequence includes at least one of semantic structure, image composition structure, temporal structure, dependency graph structure or geometric mapping structure. In this embodiment, after the consistency check passes, the client, knowing the starting position P1 and length N of π in the current round, can regenerate the target small number string pi1 and restore the color feature C1. Based on this, the system calls the H2 layer (structure parsing layer) to parse pi1 into a structured instruction sequence. Specifically, the H2 layer has multiple built-in preset parsing rules, which can parse different fields of pi1 into: semantic structure (such as object category, text label, or scene description), image composition structure (such as layer division, focus area, or layout template), temporal structure (such as inter-frame motion vectors, animation keyframes, or playback rhythm), and dependency graph structure (such as parent-child relationships between elements, rendering order, or data flow topology). Geometric mapping structures (such as projection parameters, surface coordinates, or spatial transformation matrices).

[0082] In lightweight deployment mode, the system only needs to execute up to the H2 layer to complete the parsing from the digital string to the structural sequence, and directly use it for subsequent pixel reconstruction. There is no need to call the H3 layer (multimodal fusion) or the H4 layer (advanced feature inference), which significantly reduces computational overhead and memory usage, making it suitable for resource-constrained terminal devices (such as IoT devices, mobile terminals or embedded systems).

[0083] Step S92: Based on the structural sequence and the color features, reconstruct the spatial distribution and color attributes of the pixels to reconstruct the image content; In this embodiment, the client uses the structural sequence as the "skeleton" and the color feature C1 as the "texture" to synthesize a complete image in the local rendering engine. For example, the image composition structure specifies the foreground / background regions, the geometric mapping structure defines the surface projection, and the temporal structure controls the inter-frame difference—all elements originate from the same π substring, ensuring content consistency. This process can be performed up to the H2 layer to complete the basic reconstruction on lightweight devices, or further integrated with H3 / H4 layers to enhance details on high-performance terminals.

[0084] Furthermore, step S92 may also include sub-steps A1~A2: Step A1: The pixels are managed using a hash clustering storage structure based on pixel features, wherein pixel IDs with the same color features are attached to the same feature hash chain. Specifically, in this embodiment, the system dynamically creates a feature hash linked list for each unique color feature (such as identical RGB values, CMYK combinations, or high-dimensional color vectors). This linked list uses the hash value of the color feature as the key, and each node stores the unique location identifier of the corresponding pixel in the image (i.e., pixel ID, such as coordinates (x, y) or a global index). Through this structure, all pixels with consistent color attributes are efficiently clustered, facilitating batch operations (such as uniform coloring, transparency adjustment, or region cropping), significantly improving rendering and update efficiency.

[0085] Step A2: When the color feature of any pixel changes, the pixel ID is migrated from the original feature hash list to the corresponding new feature hash list. When the screen content is switched, the invalid color feature hash list is cleared to release the cache.

[0086] Specifically, in this embodiment, if the color feature of a pixel changes due to structural sequence updates, animation interpolation, or user interaction... Change to The system first starts from Remove the ID of that point from the corresponding linked list and then insert it. In the corresponding linked list, the migration operation has a constant time complexity, ensuring real-time performance in high-frequency update scenarios. Furthermore, when the screen switches to a new frame or scene, the system traverses all existing linked lists, automatically identifying and releasing "empty linked lists" (i.e., invalid linked lists) that no longer contain any valid point IDs. This effectively controls memory usage and avoids cache bloat, making it particularly suitable for long-running or resource-constrained terminal environments.

[0087] Step S93: Generate the iterative hash value based on the reconstructed image content.

[0088] In this embodiment, the client performs the same hash generation process as the server on the reconstructed image: extracting pixel data, structural context, and current state, and then calculating the iterative hash value after feature vectorization (H1 layer), optional multimodal fusion (H3 layer), and advanced inference (H4 layer). .Should It not only reflects the content of the screen, but also implies the processing path information, serving as cryptographic proof that the client has "truly performed the reconstruction", and is sent back to the server to participate in the next round of chain verification.

[0089] Through the above steps, this embodiment realizes a reversible mapping from abstract hash credentials to concrete visual content, and by generating iterative hash values ​​with semantic depth, it makes client behavior verifiable, auditable, and non-repudiable, providing key technical support for building a highly reliable distributed graphics system.

[0090] Step S100: The iterative hash value is sent back to the server for the next round of consistency verification and hash chain iteration.

[0091] In this embodiment, the client completes pixel content reconstruction and generates iterative hash values. Then, through a secure communication channel established with the server, the iterative hash value is... The cryptographic proof, representing the result of this round of processing, is sent back to the server.

[0092] It is worth noting that the above It is not a simple content summary, but a high-order semantic hash generated after H2 layer structural parsing or H3 / H4 layer multimodal fusion and advanced inference (enhanced mode). Its computation path is completely consistent with the server's expectations. Therefore, the server can generate a reference hash by reproducing the same process locally. The system compares the two data points to verify whether the client has actually executed the complete chain from pixel reconstruction to feature deduction.

[0093] Through this feedback mechanism, the system achieves bidirectional synchronization between client behavior and the hash chain: the server is based on... The verification results determine whether to advance the π clock pointer and generate the next round. and The client then relies on the newly distributed hash value to start the next cycle. Thus, the entire architecture forms a closed-loop, unforgeable, and non-skipping chain-like security verification process driven by the mathematical constant π, linked by multi-level hashing, and guaranteed by structural consistency.

[0094] In the above-described embodiments, the client receives a local non-iterated hash value and / or a salted hash value distributed by the server. The salted hash value is generated by the server based on color features, a target small number string extracted from the π decimal sequence, and the local non-iterated hash value. Consistency verification is performed based on the non-iterated hash value and the salted hash value. After the consistency verification passes, the salted hash value is parsed and the pixel content is reconstructed to generate an iterative hash value. The iterative hash value is sent back to the server for the next round of consistency verification and hash chain iteration. This solution constructs a two-way verification closed loop driven by a π clock and linked by multi-level hashing. This allows the client to securely reconstruct the complete image with only a minimal amount of data and provide verifiable behavioral proof to the server. Simultaneously, by deeply coupling color features, structural sequences, and π bit order, it ensures that each frame's content strictly depends on the preceding state for generation, effectively preventing forged rendering, state skipping, or man-in-the-middle tampering. Furthermore, since reconstruction and verification only need to be completed up to the H2 layer in lightweight mode, while H3 / H4 layers can be enabled to enhance semantic expression in high-performance scenarios, the system maintains ultra-low bandwidth consumption while possessing high security, strong scalability, and cross-platform compatibility. It is suitable for diverse application scenarios such as cloud rendering, multi-user collaboration, satellite image transmission, and distributed AI.

[0095] The methods of this application will now be explained in detail using specific implementation scenarios: Example 1: Lightweight version (suitable for mobile terminals and low-power devices) In smartwatches or IoT sensor terminals, the system only uses a three-layer architecture: H0→H1→H2. The server sends the π start bit P1 and the salted hash value H1. The client reconstructs pi1 using a local π generator, maps it to RGB color features via H1, and then the H2 layer parses out a simple image composition structure to directly render the status interface. Since there is no need to perform multimodal fusion or geometric deduction at the H3 / H4 layers, CPU usage is less than 5%, peak memory usage is less than 2MB, and each interaction only transmits 64 bytes of hash and 16 bytes of metadata, resulting in bandwidth savings of over 95%. This makes it particularly suitable for edge devices with limited batteries and unstable networks.

[0096] Example 2: Standard version (H0–H4 fully enabled, suitable for cloud gaming and distributed AI) In large-scale multiplayer online game scenarios, the server dynamically generates [data] based on the player's field of view. H1 converts the data into a high-dimensional color vector; H2 generates a 3D scene dependency graph and a temporal animation structure; H3 integrates voice commands; and H4 performs viewpoint correction and lighting deduction on the Riemannian manifold, ultimately outputting the final result. Client-side return Afterwards, the server verifies whether it matches the expected geometric-semantic joint representation. This process ensures that each frame is unforgeable and cannot be skipped, effectively preventing external cheats from tampering with textures or coordinates. At the same time, because only hash chains are transmitted instead of complete texture packets, network throughput is improved by more than 10 times.

[0097] Example 3: Security Enhanced Version (for Government-Grade Trusted Rendering) In financial regulatory sandboxes or government digital human systems, in addition to standard procedures, four additional types of summaries are generated: CMYK printing gamut mapping summaries, video frame-to-frame geometric manifold summaries, structural dependency graph topological summaries, and eigenvector distribution histograms. These summaries are then compared with... Together, they undergo SM2 signature verification to form an auditable and secure signature chain. Any attempt to forge AI-generated reports or tamper with visualization results can be instantly identified through π clock backtracking and multidimensional digest comparison.

[0098] Example 4: Complex Plane / Riemannian Geometric Mapping of Image CMYK to RGB In the cross-media publishing process, the H0 layer receives the CMYK print file, maps its four-channel values ​​to the complex plane, then parameterizes the color surface using Riemannian metrics, and finally projects it to the sRGB target space. This process completes high-dimensional vectorization in the H1 layer, preserving color gamut boundary information, avoiding color shift caused by traditional linear transformations, and ensuring color accuracy is maintained and stability across color spaces.

[0099] Example 5: Geometric Sequencerization of Video Input In the AR remote collaboration system, after the video stream is segmented into frames, each frame's pixels are mapped to the complex plane, and adjacent frames form a temporal trajectory on a Riemannian manifold. The H2 layer extracts motion vectors and occlusion relationships, while the H3 layer integrates speech annotations to generate semantic anchors. Finally, a π clock verifier ensures that the frame order cannot be rearranged and the content cannot be replaced. Even with a 30% packet loss due to network jitter, the client can still reconstruct the missing frame structure through π bit ordering, ensuring the continuity of the immersive experience.

[0100] In summary, this invention, through a verifiable hash reconstruction mechanism driven by a π clock, and supported by four core technologies—extremely low bandwidth (<5% of the original data volume), strong anti-cheating, adaptive load (dynamic P adjustment), and self-cleaning storage (automatic cleanup of failed linked lists)—builds a unified verifiable rendering framework covering lightweight terminals to high-security systems. This provides a next-generation infrastructure that combines security, efficiency, and mathematical rigor for cutting-edge fields such as cloud gaming, digital twins, interplanetary communication, and trusted AI output.

[0101] It should be noted that the above examples are only for understanding this application and do not constitute a limitation on the data processing method of this application. Any simple modifications based on this technical concept are within the protection scope of this application.

[0102] This application also provides a data processing system, please refer to... Figure 3 The data processing system includes a server and a client. The server includes: The π sequence generation module 10 is used to generate a π decimal sequence of pi through the π clock module after receiving a trigger command sent by the client, and to extract a target decimal string after the target start position from the π decimal sequence. Color mapping module 20 is used to convert the target small number string into color features; Hash construction module 30 is used to generate a salted hash value based on the color feature, the target small number string, and the local uniterated hash value; The distribution module 40 is used to distribute the local uniterated hash value and / or the salted hash value to the client for the client to perform consistency verification and pixel content reconstruction. The verification and iteration module 50 is used to receive the iterative hash value generated based on pixel content reconstruction returned by the client, and to perform consistency verification based on the iterative hash value to trigger the next round of hash value generation and distribution based on π bit order. The client includes: The sending module 60 is used to send a trigger command to the server when a display content update event is detected, so that the server generates a π decimal sequence based on the π clock module and extracts the target small number string to generate a salted hash value. The receiving module 70 is used to receive local uniterated hash values ​​and / or salted hash values ​​distributed by the server, wherein the salted hash value is generated by the server based on color features, a target small number string extracted from the π decimal sequence, and the local uniterated hash value; Verification module 80 is used to perform consistency verification based on the un-iterated hash value and the salted hash value; The reconstruction and hash generation module 90 is used to parse the salted hash value and reconstruct the pixel content after the consistency check passes, and generate an iterative hash value. The return module 100 is used to return the iterative hash value to the server for the next round of consistency verification and hash chain iteration.

[0103] The data processing system provided in this application, employing the data processing methods described in the above embodiments, can solve the technical problem of how to improve the stability, security, and versatility of data processing. Compared with the prior art, the beneficial effects of the data processing system provided in this application are the same as those of the data processing methods provided in the above embodiments, and other technical features of the data processing system are the same as those disclosed in the methods of the above embodiments, and will not be repeated here.

[0104] This application provides a data processing apparatus, which includes: at least one processor; and a memory communicatively connected to the at least one processor; wherein the memory stores instructions executable by the at least one processor, and the instructions are executed by the at least one processor to enable the at least one processor to perform the data processing method in Embodiment 1 above.

[0105] The following is for reference. Figure 4 The diagram illustrates a structural schematic of a data processing device suitable for implementing embodiments of this application. The data processing device in the embodiments of this application may include, but is not limited to, mobile terminals such as mobile phones, laptops, digital broadcast receivers, PDAs (Personal Digital Assistants), PADs (Portable Application Description), PMPs (Portable Media Players), etc., and fixed terminals such as digital TVs, desktop computers, etc. Figure 4 The data processing device shown is merely an example and should not impose any limitations on the functionality and scope of use of the embodiments of this application.

[0106] like Figure 4As shown, the data processing device may include a processing unit 1001 (e.g., a central processing unit, a graphics processing unit, etc.), which can perform various appropriate actions and processes according to a program stored in a read-only memory (ROM) 1002 or a program loaded from a storage device 1003 into a random access memory (RAM) 1004. The RAM 1004 also stores various programs and data required for the operation of the data processing device. The processing unit 1001, ROM 1002, and RAM 1004 are interconnected via a bus 1005. An input / output (I / O) interface 1006 is also connected to the bus. Typically, the following systems can be connected to the I / O interface 1006: input devices 1007 including, for example, a touchscreen, touchpad, keyboard, mouse, image sensor, microphone, accelerometer, gyroscope, etc.; output devices 1008 including, for example, a liquid crystal display (LCD), speaker, vibrator, etc.; storage devices 1003 including, for example, magnetic tape, hard disk, etc.; and communication devices 1009. Communication device 1009 allows the data processing device to communicate wirelessly or wiredly with other devices to exchange data. Although the figures show data processing devices with various systems, it should be understood that it is not required to implement or possess all of the systems shown. More or fewer systems may be implemented alternatively.

[0107] Specifically, according to the embodiments disclosed in this application, the processes described above with reference to the flowcharts can be implemented as computer software programs. For example, embodiments disclosed in this application include a computer program product comprising a computer program carried on a computer-readable medium, the computer program containing program code for performing the methods shown in the flowcharts. In such embodiments, the computer program can be downloaded and installed from a network via a communication device, or installed from storage device 1003, or installed from ROM 1002. When the computer program is executed by processing device 1001, it performs the functions defined in the methods of the embodiments disclosed in this application.

[0108] The data processing device provided in this application, employing the data processing method described in the above embodiments, can solve the technical problem of how to improve the stability, security, and versatility of data processing. Compared with the prior art, the beneficial effects of the data processing device provided in this application are the same as those of the data processing method provided in the above embodiments, and other technical features of this data processing device are the same as those disclosed in the previous embodiment method, and will not be repeated here.

[0109] It should be understood that the various parts disclosed in this application can be implemented using hardware, software, firmware, or a combination thereof. In the description of the above embodiments, specific features, structures, materials, or characteristics can be combined in any suitable manner in one or more embodiments or examples.

[0110] The above description is merely a specific embodiment of this application, but the scope of protection of this application is not limited thereto. Any variations or substitutions that can be easily conceived by those skilled in the art within the scope of the technology disclosed in this application should be included within the scope of protection of this application. Therefore, the scope of protection of this application should be determined by the scope of the claims.

[0111] This application provides a computer-readable storage medium having computer-readable program instructions (i.e., a computer program) stored thereon, the computer-readable program instructions being used to execute the data processing method described in the above embodiments.

[0112] The computer-readable storage medium provided in this application may be, for example, a USB flash drive, but is not limited to, electrical, magnetic, optical, electromagnetic, infrared, or semiconductor systems or devices, or any combination thereof. More specific examples of computer-readable storage media may include, but are not limited to: electrical connections having one or more wires, portable computer disks, hard disks, random access memory (RAM), read-only memory (ROM), erasable programmable read-only memory (EPROM or flash memory), optical fiber, portable compact disk read-only memory (CD-ROM), optical storage devices, magnetic storage devices, or any suitable combination thereof. In this embodiment, the computer-readable storage medium may be any tangible medium containing or storing a program that can be used by or in conjunction with an instruction execution system or device. The program code contained on the computer-readable storage medium may be transmitted using any suitable medium, including but not limited to: wires, optical cables, RF (Radio Frequency), etc., or any suitable combination thereof.

[0113] The aforementioned computer-readable storage medium may be included in a data processing device or may exist independently without being assembled into a data processing device.

[0114] The aforementioned computer-readable storage medium carries one or more programs. When these programs are executed by a data processing device, the data processing device performs the following actions: Upon receiving a trigger command from a client, the server generates a π decimal sequence using a π clock module and extracts a target small number string after the target start position from the π decimal sequence; converts the target small number string into a color feature; generates a salted hash value based on the color feature, the target small number string, and a local non-iterated hash value; distributes the local non-iterated hash value and / or the salted hash value to the client for consistency verification and pixel content reconstruction; receives the iterative hash value generated based on pixel content reconstruction returned by the client, and performs consistency verification based on the iterative hash value to trigger the next round of hash value generation and distribution based on the π bit order.

[0115] Computer program code for performing the operations of this application can be written in one or more programming languages ​​or a combination thereof, including object-oriented programming languages ​​such as Java, Smalltalk, and C++, and conventional procedural programming languages ​​such as the "C" language or similar programming languages. The program code can be executed entirely on the user's computer, partially on the user's computer, as a standalone software package, partially on the user's computer and partially on a remote computer, or entirely on a remote computer or server. In cases involving remote computers, the remote computer can be connected to the user's computer via any type of network—including a Local Area Network (LAN) or a Wide Area Network (WAN)—or can be connected to an external computer (e.g., via the Internet using an Internet service provider).

[0116] The flowcharts and block diagrams in the accompanying drawings illustrate the architecture, functionality, and operation of possible implementations of systems, methods, and computer program products according to various embodiments of this application. In this regard, each block in a flowchart or block diagram may represent a module, segment, or portion of code containing one or more executable instructions for implementing a specified logical function. It should also be noted that in some alternative implementations, the functions indicated in the blocks may occur in a different order than those indicated in the drawings. For example, two consecutively indicated blocks may actually be executed substantially in parallel, and they may sometimes be executed in reverse order, depending on the functions involved. It should also be noted that each block in the block diagrams and / or flowcharts, and combinations of blocks in the block diagrams and / or flowcharts, can be implemented using a dedicated hardware-based system that performs the specified function or operation, or using a combination of dedicated hardware and computer instructions.

[0117] The modules described in the embodiments of this application can be implemented in software or hardware. The names of the modules do not necessarily limit the functionality of the unit itself.

[0118] The readable storage medium provided in this application is a computer-readable storage medium that stores computer-readable program instructions (i.e., a computer program) for executing the above-described data processing method, and can solve the technical problem of how to improve the stability, security, and versatility of data processing. Compared with the prior art, the beneficial effects of the computer-readable storage medium provided in this application are the same as the beneficial effects of the data processing method provided in the above embodiments, and will not be repeated here.

[0119] This application also provides a computer program product, including a computer program that, when executed by a processor, implements the steps of the data processing method described above.

[0120] The computer program product provided in this application can solve the technical problem of how to improve the stability, security, and versatility of data processing. Compared with the prior art, the beneficial effects of the computer program product provided in this application are the same as the beneficial effects of the data processing method provided in the above embodiments, and will not be repeated here.

[0121] The above description is only a part of the embodiments of this application and does not limit the patent scope of this application. All equivalent structural transformations made under the technical concept of this application and using the contents of the specification and drawings of this application, or direct / indirect applications in other related technical fields, are included in the patent protection scope of this application.

Claims

1. A data processing method, characterized by, The data processing method is applied to a server and specifically to image processing. The server includes a π clock module, and the method includes: After receiving the trigger command sent by the client, the π clock module generates a fractional digit sequence of π, and extracts the target fractional digit string after the target start position from the fractional digit sequence of π. Convert the target small number string into color features; Based on the color features, the target small number string, and the local uniterated hash value, a salted hash value is generated; Distribute the local uniterated hash value and / or the salted hash value to the client for the client to perform consistency verification and pixel content reconstruction; The system receives the iterative hash value generated based on pixel content reconstruction returned by the client, and performs consistency verification based on the iterative hash value to trigger the next round of hash value generation and distribution based on π bit order.

2. The data processing method as described in claim 1, characterized in that, The color features include at least one of RGB values, CMYK values, or high-dimensional feature vectors.

3. The data processing method as described in claim 1, characterized in that, The step of generating a salted hash value based on the color feature, the target small number string, and the local uniterated hash value includes: The color features and the target small number string are respectively mapped to feature vectors of the same dimension, and together with the local non-iterated hash value, they form a multimodal input tensor; The multimodal input tensor is fused and encoded to obtain a joint representation vector; The salted hash value is generated based on the joint representation vector.

4. The data processing method as described in claim 1, characterized in that, The step of performing consistency verification based on the iterative hash value to trigger the next round of hash value generation and distribution based on π bit order includes: The iterative hash value is cross-modal registered with the expected feature vector of the current π-order context. The cross-modal registration includes at least one operation among alignment, mapping, resampling and dimension normalization. Based on the registration results, multiple rounds of high-level feature inference are performed. The high-level feature inference includes at least one of high-dimensional geometric transformation, weight reconstruction, or interpretability enhancement to generate a joint representation. The joint representation is verified by a π clock verification layer to perform structural consistency verification, data non-repudiation verification, and feature link non-jump verification. If the verification passes, a new target small number string is generated based on the π decimal sequence segment corresponding to the next time slice, and the generation and distribution of the next round of salted hash value and un-iterated hash value are triggered.

5. A data processing method, characterized in that, The method is applied to a client and to image processing, and the method includes: When a display content update event is detected, a trigger command is sent to the server so that the server generates a π decimal sequence based on the π clock module and extracts the target small number string to generate a salted hash value. Receive local uniterated hash values ​​and / or salted hash values ​​distributed by the server; Consistency verification is performed based on the uniterated hash value and the salted hash value; After the consistency check passes, the salted hash value is parsed and the pixel content is reconstructed to generate an iterative hash value; The iterative hash value is sent back to the server for the next round of consistency verification and hash chain iteration.

6. The data processing method as described in claim 5, characterized in that, The steps of parsing the salted hash value and reconstructing the pixel content to generate iterative hash values ​​include: Based on the color features corresponding to the salted hash value and the target small number string, and combined with the preset structure parsing rules, a structure sequence is generated. The structure sequence includes at least one of semantic structure, image composition structure, temporal structure, dependency graph structure or geometric mapping structure. Based on the structural sequence and the color features, the spatial distribution and color attributes of the pixels are reconstructed to rebuild the image content; The iterative hash value is generated based on the reconstructed image content.

7. The data processing method as described in claim 6, characterized in that, The step of reconstructing the spatial distribution and color attributes of pixels based on the structural sequence and the color features to reconstruct the image content includes: The pixels are managed using a pixel feature-based hash clustering storage structure, wherein pixel IDs with the same color features are attached to the same feature hash linked list. When the color feature of any pixel changes, the pixel ID is migrated from the original feature hash list to the corresponding new feature hash list. When the screen content changes, the invalid color feature hash list is cleared to release the cache.

8. A data processing system, characterized in that, The data processing system includes a server and a client; The server includes: The π sequence generation module is used to generate a fractional digit sequence of π using the π clock module after receiving a trigger command from the client, and to extract a target fractional digit string after the target start position from the fractional digit sequence of π. The color mapping module is used to convert the target small number string into color features; A hash construction module is used to generate a salted hash value based on the color feature, the target small number string, and the local uniterated hash value; The distribution module is used to distribute the local uniterated hash value and / or the salted hash value to the client for the client to perform consistency verification and pixel content reconstruction. The verification and iteration module is used to receive the iterative hash value generated based on pixel content reconstruction returned by the client, and to perform consistency verification based on the iterative hash value to trigger the next round of hash value generation and distribution based on π bit order. The client includes: The sending module is used to send a trigger command to the server when a display content update event is detected, so that the server generates a π decimal sequence based on the π clock module and extracts the target small number string to generate a salted hash value; The receiving module is used to receive local uniterated hash values ​​and / or salted hash values ​​distributed by the server; The verification module is used to perform consistency verification based on the un-iterated hash value and the salted hash value; The reconstruction and hash generation module is used to parse the salted hash value and reconstruct the pixel content after the consistency check passes, and generate an iterative hash value. The backhaul module is used to send the iterative hash value back to the server for the next round of consistency verification and hash chain iteration.

9. A data processing device, characterized in that, The device includes: a memory, a processor, and a computer program stored in the memory and executable on the processor, the computer program being configured to implement the steps of the data processing method as described in any one of claims 1 to 7.

10. A storage medium, characterized in that, The storage medium is a computer-readable storage medium, and a computer program is stored on the storage medium. When the computer program is executed by a processor, it implements the steps of the data processing method as described in any one of claims 1 to 7.

Images