Continuous-discrete dual mode runtime translation method and system based on z_7 discrete encoding

Abstract

This invention discloses a continuous-discrete dual-mode runtime translation method and system based on Z_7 discrete encoding, belonging to the field of computer system software. Existing computer architectures, based on binary continuous logic, suffer from systemic security vulnerabilities such as null pointer exceptions, division by zero errors, and memory out-of-bounds access. This invention maps continuous domain program input to the Z_7 discrete encoding space, optimizes the computation path using structural reducibility determination, employs a hook proof method for bidirectional anchoring verification of causal consistency, and handles abnormal states through a boundary return correction mechanism. This allows upper-level C language code to run on the Z_7 discrete architecture without modifying the source code, while simultaneously eliminating systemic security vulnerabilities. This invention, together with the applicant's 57 submitted patents, forms a complete technical system, covering the entire stack from the mathematical root node to the hardware layer, operating system layer, network layer, value layer, and runtime translation layer.

Description

Technical Field

[0001] This invention belongs to the field of computer system software, specifically relating to a runtime translation method and system, and more particularly to a method for mapping C language program code written based on binary continuous logic to Z_7 discrete coding space and running it securely. Background Technology

[0002] Current global computer architectures are generally based on binary sequential logic, using 0s and 1s to represent logical states, managing memory with contiguous address spaces, and performing mathematical operations using IEEE 754 standard floating-point numbers. This architecture has been used for nearly eighty years since the Turing machine model and the von Neumann architecture were established, achieving great success in the field of general-purpose computing. However, as high-reliability scenarios such as artificial intelligence, the Internet of Things, financial payments, and national defense security place higher demands on computing systems, existing technologies have exposed the following systemic defects:

[0003] First, the existence of the value zero makes it impossible to completely eliminate null pointer exceptions and division by zero errors.

[0004] In C and its derivative languages, a null pointer (NULL) is defined as the address of the value zero. When a program accesses memory through a null pointer, performs division by zero, or accesses an array using a zero index, the hardware cannot automatically intercept this; the exception can only be caught by post-processing checks at the software level. This post-processing mechanism poses a fatal risk in latency-sensitive scenarios such as real-time systems, autonomous driving, and financial transactions. Statistics show that null pointer exceptions and division by zero errors account for over 30% of software failures in industrial applications, and these are difficult to completely eliminate through routine code reviews.

[0005] Second, the continuous approximation characteristic of floating-point operations leads to the accumulation of precision errors.

[0006] The IEEE 754 standard floating-point numbers use binary fractions to approximate real numbers, resulting in persistent precision accumulation errors after multiple addition, subtraction, multiplication, and division operations. In scenarios with extremely high precision requirements, such as scientific computing, navigation and positioning, and financial settlement, these accumulated errors can cause results to deviate from the true value, and the error propagation path is difficult to trace. Existing technologies alleviate the problem by increasing the number of floating-point bits (double precision, quad precision), but cannot fundamentally eliminate the inherent defects of approximate representation.

[0007] Third, memory management in contiguous address spaces makes it difficult to automatically detect out-of-bounds accesses at the hardware level.

[0008] Current memory management is based on a contiguous linear address space starting from zero, using software boundary markers (such as array length fields and memory allocation header information) to prevent out-of-bounds access. However, these boundary markers reside in the same address space as the data, and malicious code or program errors can directly tamper with these markers, allowing out-of-bounds access to bypass the checks. Hardware-level memory protection units (MPUs) are coarse-grained (based on pages, typically four thousand bytes), failing to protect small objects within a page and creating security blind spots.

[0009] Fourth, the lack of causal verification mechanism in the program control flow and arbitrary function pointer jumps lead to security vulnerabilities.

[0010] The C programming language supports function pointers and the `goto` statement, allowing programs to jump to arbitrary addresses at runtime. While this flexibility improves programming efficiency, it also introduces the risk of control flow hijacking. Attackers can use buffer overflows to tamper with function pointers, directing the program towards malicious code; or they can use the `goto` statement to bypass security checks. Existing technologies mitigate this risk through mechanisms such as Address Space Layout Randomization (ASLR) and Data Execution Prevention (DEP), but these are all post-hoc protections and cannot verify the causal legitimacy before the jump occurs.

[0011] To address the aforementioned shortcomings, existing technologies have proposed several partial solutions: Rust prevents null pointer exceptions and out-of-bounds access through ownership mechanisms, but this changes the programming paradigm and is incompatible with existing C code; range arithmetic controls floating-point errors through upper and lower bound tracking, but it incurs high computational overhead and cannot handle all operations; hardware boundary checks detect out-of-bounds access through dedicated instructions, but this requires modifications to the instruction set architecture and has poor compatibility; control flow integrity (CFI) restricts function pointers by pre-computing a set of valid jump targets, but the set maintenance is costly and prone to false alarms. These solutions are all partial fixes and do not address the fundamental defects of binary continuous logic.

[0012] The applicant had previously constructed the "Orange Skeleton" technology system, submitting 57 patent applications covering the complete technology stack from the mathematical root node, operation layer, protocol layer, operating system layer, network layer, value layer to the hardware layer. However, the global stock of C language code amounts to tens of billions of lines, making it impossible to rewrite overnight. Therefore, a runtime translation layer is urgently needed to enable continuous-domain programs to run securely on the Z_7 discrete architecture without modifying the C language source code, achieving gradual replacement rather than a complete overhaul. Summary of the Invention

[0013] The purpose of this invention is to provide a continuous-discrete dual-mode runtime translation method and system based on Z_7 discrete encoding, which enables the upper-level C language code to run on the Z_7 discrete architecture without modifying the source code, while eliminating the systemic security vulnerabilities of the existing binary continuous logic system.

[0014] To achieve the above objectives, the present invention adopts the following technical solution:

[0015] A continuous-discrete dual-mode runtime translation method based on Z_7 discrete coding includes the following steps:

[0016] Step 1: Receive continuous-domain program input. This continuous-domain program input includes, but is not limited to, C language integers, floating-point numbers, null pointers (NULL), and memory allocation requests. This step receives input through the standard C language interface and does not change the original function calling method.

[0017] Step 2: Map the continuous-domain program input to the Z_7 discrete coding space. The Z_7 discrete coding space has no zero values. The minimum flag state 1_PCU is equivalent to the value zero in the continuous domain but does not participate in arithmetic operations; it is only used as a boundary return signal. The integer mapping rules are: non-positive integers are mapped to 1_PCU; positive integers are modulo 7, and if the remainder is 0, they are mapped to 7; otherwise, they are mapped to the remainder. The floating-point mapping rules are: non-positive floating-point numbers are mapped to 1_PCU; positive floating-point numbers are rounded to the nearest integer and then mapped according to the integer rules. The null pointer NULL is mapped to 1_PCU. The size parameter of the memory allocation request is mapped according to the integer rules.

[0018] Step 3: Optimize the computation path based on structural reducibility determination. The structural reducibility has the form 2^k multiplied by m, where k is an integer greater than or equal to 1, and m is an odd number or the origin marker. Values ​​of 1 and purely odd numbers are not involved in the computation, only serving as boundary return signals. Memory allocation requests are filtered based on structural reducibility determination, allowing only memory block allocation requests of reducible size to pass, and rejecting allocation requests of purely odd size, value 1, and value 0. This filtering is completed during the allocation phase and does not require runtime checking.

[0019] Step 4: Verify the causal consistency of each transformation step using the hook proof method with bidirectional anchoring. The hook proof method includes three sub-steps: the lower hook operation locks the necessary condition of the conclusion at the function entry point; if the input parameters do not meet the necessary condition, it returns a 1_PCU boundary marker to prevent illegal input from entering the operation; the upper hook operation verifies the sufficient condition of the axiom at the function exit point; if the output result does not meet the sufficient condition, it terminates the program and returns an error code to prevent erroneous results from propagating outward; the intermediate operation process converges to the theorem, ensuring that each derivation step can be backtracked for verification, forming a complete causal evidence chain.

[0020] Step 5: Handle abnormal states through a boundary return correction mechanism. When the calculation result touches the 1_PCU boundary, the boundary return correction mechanism automatically returns to the boundary marker and terminates the current calculation path. Specific activation scenarios include: the subtraction result is a non-positive number, the addition result exceeds 7, the divisor is 1_PCU, and the multiplication result modulo 7 is 0. This mechanism can be mapped to a conditional jump instruction at the hardware level, with a latency of less than five clock cycles.

[0021] Step 6: Translate the discrete-domain operation results back to the continuous-domain interface. The translation rules are: 1_PCU maps to the continuous-domain value 0 or null pointer NULL; values ​​2 to 7 are mapped to their corresponding continuous-domain integer values. Floating-point results are translated according to integer rules, and the caller decides whether to convert them to floating-point representation. This allows the upper-level C language code to run on the Z_7 discrete architecture without modifying the source code.

[0022] A continuous-discrete dual-mode runtime translation system based on Z_7 discrete coding includes the following modules:

[0023] The continuous-discrete translation module is used to map C language integers, floating-point numbers, and null pointers to the Z_7 discrete encoding space;

[0024] The structural reducibility determination module is used to optimize the computation path and filter memory allocation requests;

[0025] The hook proof verification module is used to verify the causal consistency of each step of the transformation through bidirectional anchoring.

[0026] The boundary touch correction module is used to automatically return the boundary marker when the calculation result touches the boundary;

[0027] The discrete-to-continuous back-translation module is used to output the results of Z_7 discrete domain operations to the C language continuous domain interface.

[0028] Beneficial effects

[0029] Compared with the prior art, the present invention has the following beneficial effects:

[0030] First, it fundamentally eliminates null pointer exceptions and division by zero errors. Since the Z_7 discrete coding space has no zero values, the concept of a null pointer is replaced by a 1_PCU boundary marker. Any illegal arithmetic operation on a 1_PCU triggers boundary revert correction, intercepting the operation before it occurs, rather than checking it afterward. This mechanism transforms null pointer exceptions and division by zero errors from "runtime exceptions" into "compile-time verifiable illegal states," allowing them to be completely eliminated through static analysis before software release.

[0031] Second, floating-point operations are discretized to eliminate accumulated precision errors. Floating-point numbers are mapped to the Z_7 discrete scale through rounding, and the operation process is performed entirely in the integer space, resulting in accurate and reproducible results. For scenarios requiring higher precision, the resolution can be improved by extending the Z_7 period (such as Z_49, Z_343) instead of relying on approximate representations.

[0032] Third, memory allocation is managed according to a reducible structure, and out-of-bounds requests are prevented during the allocation phase. The size of the memory block must be a reducible number of the structure; requests for non-reducible numbers are rejected during the allocation phase, eliminating the need for runtime boundary checks. Since reducible numbers have the form 2^k multiplied by m, memory alignment naturally satisfies hardware cache line requirements, improving access efficiency.

[0033] Fourth, the upper-level C code runs without modification, achieving gradual replacement. Existing C language code does not require modification of the source code; it only needs to link the runtime translation layer of this invention at compile time to run on the Z_7 discrete architecture. This gradual replacement strategy protects billions of lines of existing code investment and reduces system migration costs. Attached Figure Description

[0034] Figure 1 This is a schematic diagram of the continuous-discrete dual-mode runtime architecture of the present invention, showing a three-layer architecture consisting of a continuous domain input layer, a Z_7 discrete domain operation layer, and a continuous domain output layer, as well as the data flow and transformation relationships between each layer.

[0035] Figure 2 This is a schematic diagram of the Z_7 encoding mapping of the present invention, showing the correspondence between continuous field integers and Z_7 discrete codes, including the rules of mapping non-positive numbers to 1_PCU, positive numbers modulo 7 normalized, and remainder 0 to 7, as well as mapping examples of typical values.

[0036] Figure 3 This is a flowchart of the two-way anchoring process of the hook proof method of the present invention, which shows the logical relationship of the hooking operation, the hooking operation and the intermediate convergence, as well as the failure branch handling when the conditions are not met.

[0037] Figure 4 The flowchart of the boundary touch-back correction mechanism of the present invention shows the processing flow of the operation node, the boundary judgment diamond, the normal output branch, and the boundary touch-back branch. Detailed Implementation

[0038] To make the objectives, technical solutions, and advantages of the present invention clearer, the present invention will be further described in detail below with reference to specific embodiments and accompanying drawings.

[0039] Example 1: Integer Translation

[0040] Assume the continuous domain input is the integer 23. According to the mapping rules in step 2, 23 is a positive integer, and taking the modulo 7 gives a remainder of 2, so it is mapped to 2_PCU. If the continuous domain input is the integer 0, it is mapped to 1_PCU. If the continuous domain input is the integer 8, taking the modulo 7 gives a remainder of 1, so it is mapped to 1_PCU. If the continuous domain input is the integer 14, taking the modulo 7 gives a remainder of 0, so it is mapped to 7_PCU. If the continuous domain input is the integer 15, taking the modulo 7 gives a remainder of 1, so it is mapped to 1_PCU. The above mapping is performed by the continuous-discrete translation module, and the mapping result is passed to the Z_7 discrete domain operation layer.

[0041] Example 2: Floating-point translation

[0042] Assume the continuous domain input is the floating-point number 3.7. According to the mapping rules in step 2, 3.7 is a positive floating-point number, rounded to the nearest integer, which is 4. Taking the remainder 4 modulo 7, it is mapped to 4_PCU. If the continuous domain input is the floating-point number 0.0, it is mapped to 1_PCU. If the continuous domain input is the floating-point number 7.4, rounded to the nearest integer, which is 7. Taking the remainder 0 modulo 7, it is mapped to 7_PCU. Floating-point translation preserves the numerical order of the continuous domain, that is, the larger positive number in the continuous domain is mapped to the larger code in Z_7 (modulo 7).

[0043] Example 3: Addition Operation

[0044] Assume the discrete-domain operands are 2_PCU and 3_PCU. According to the Z_7 addition rule, 2 plus 3 equals 5, which does not exceed 7, so the result remains 5_PCU. Assume the discrete-domain operands are 3_PCU and 5_PCU, 3 plus 5 equals 8, which exceeds 7, triggering boundary correction and returning 1_PCU. Assume the discrete-domain operands are 7_PCU and 7_PCU, 7 plus 7 equals 14, and 14 modulo 7 equals 0, which maps to 7_PCU, so no boundary correction is triggered. Assume the discrete-domain operands are 1_PCU and 2_PCU, where 1_PCU is the boundary marker; the addition operation directly returns 1_PCU without performing any actual computation.

[0045] Example 4: Subtraction Operation

[0046] Assume the discrete-domain operands are 5_PCU and 2_PCU. According to the Z_7 subtraction rule, 5 minus 2 equals 3, which is positive and remains 3_PCU. Assume the discrete-domain operands are 2_PCU and 5_PCU, 2 minus 5 equals -3, which is non-positive, triggering boundary correction and returning 1_PCU. Assume the discrete-domain operands are 7_PCU and 7_PCU, 7 minus 7 equals 0, which is non-positive, triggering boundary correction and returning 1_PCU. Assume the discrete-domain operands are 1_PCU and 2_PCU, where 1_PCU is the boundary marker, and the subtraction operation directly returns 1_PCU.

[0047] Example 5: Memory Allocation

[0048] Assume a memory allocation request of 6 bytes. According to the structural reducibility determination in step 3, 6 equals 2 multiplied by 3, where 2 is 2 to the power of 1 and 3 is an odd number, satisfying the definition of structural reducibility, therefore allocation is allowed. After allocation, the memory block size 6 is recorded as the checksum Z_7 6_PCU. Assume a memory allocation request of 7 bytes. 7 is a purely odd number, not satisfying the definition of structural reducibility, therefore allocation is rejected, and a null pointer NULL is returned. Assume a memory allocation request of 8 bytes. 8 equals 2 to the power of 3 multiplied by 1, satisfying the definition of structural reducibility, therefore allocation is allowed. Assume a memory allocation request of 0 bytes. 0 does not satisfy the definition of structural reducibility, therefore allocation is rejected.

[0049] Example 6: Hook Verification

[0050] Assume the function entry point receives a parameter of 2_PCU. According to the hooking operation in step 4, verifying that 2 is greater than or equal to 2 satisfies the necessary condition, the hook is engaged, and execution of the function body continues. Assume the function entry point receives a parameter of 1_PCU. Verifying that 1 is greater than or equal to 2 does not satisfy the condition, the hook is not engaged, and the function directly returns a 1_PCU boundary marker; the function body is not executed. Assume the function exit point outputs a result of 5_PCU. According to the hooking operation, verifying that 5 is less than or equal to 7 satisfies the sufficient condition, the result is valid, and the function is returned to the caller. Assume the function exit point outputs a result of 8_PCU. Verifying that 8 is less than or equal to 7 does not satisfy the condition, the hooking operation fails, the program terminates, and an error code is returned.

[0051] [Attached image for supplementary explanation]

[0052] This supplementary instruction is attached to the instruction manual. Figure 1 To be continued Figure 4 A detailed explanation is provided to understand the correspondence and technical meaning of the technical elements in each diagram.

[0053] Appendix Figure 1 [Continuous-Discrete Dual-Mode Runtime Architecture Diagram]

[0054] Figure 1 The three-layer architecture of the "continuous-discrete dual-mode operation" of the present invention is shown.

[0055] Upper layer (light blue background): Continuous field input layer. Represents the runtime environment of the existing C program, accepting four types of input: C language integers, floating-point numbers, null pointers (NULL), and memory allocation requests. Technical meaning: The upper-level code does not need to be modified, maintaining the original C language syntax.

[0056] Middle layer (orange background): Z_7 discrete domain computation layer. This is the core computation space of this invention; the space has no zeros, and the minimum marked state is 1_PCU. The four small white rectangles inside, from left to right, are:

[0057] - "Z_7 encoding mapping": This corresponds to step 2 in the instruction manual, mapping the continuous domain input to the Z_7 discrete encoding space.

[0058] - "Structure divisibility determination": This corresponds to step 3 in the instruction manual, optimizing the computation path and filtering memory allocation.

[0059] - "Hook proof method verification": corresponds to step 4 in the instruction manual, two-way anchoring verification of causal consistency.

[0060] - "Boundary Touchback Correction": This corresponds to step 5 in the instruction manual and handles abnormal states.

[0061] Lower layer (green background): Continuous domain output layer. It translates the discrete domain operation results back to the C language interface; the upper-level code requires no modification.

[0062] Blue down arrow (labeled "translation"): Data is translated from the continuous domain to the discrete domain.

[0063] Orange down arrow (labeled "backtranslation"): Data is backtranslated from the discrete domain to the continuous domain.

[0064] Appendix Figure 2 [Z_7 encoding mapping diagram]

[0065] Figure 2 The mapping rules from continuous field integers to the Z_7 discrete coding space are shown.

[0066] The blue box on the left, "Continuous Domain," represents the original space of the input values. In the horizontal numerical sequence, the red background values ​​(0, 1, 8, 15) are mapped to 1_PCU, and the green background values ​​(7, 14) are mapped to 7_PCU.

[0067] The orange box on the right, "Z_7 Discrete Domain": the target coding space. The mapping table from top to bottom is as follows:

[0068] -Non-positive numbers, 1, 8, 15 → 1_PCU (red background, boundary marker)

[0069] -2→2_PCU (green background, minimum number of operands)

[0070] -3, 4, 5, 6 → correspond to _PCU (green background)

[0071] -7, 14 → 7_PCU (green background, full cycle)

[0072] The yellow box at the bottom summarizes the mapping rules: Non-positive numbers → 1_PCU | Positive numbers modulo 7 are normalized | Remainder 0 → 7 | 8 is a carry marker and does not exist in the current position.

[0073] Appendix Figure 3 [Flowchart of the hook proof method for bidirectional anchoring]

[0074] Figure 3 The bidirectional anchoring logic of the hook proof method is shown.

[0075] The blue box at the top left, labeled "Hook Operation," verifies the necessary conditions at the function entry point. If the input does not meet the necessary conditions, the hook is not engaged, and the function directly returns the 1_PCU boundary marker.

[0076] The green box at the top right, labeled "Hook Operation," verifies the sufficient condition at the function's exit point. If the output does not meet the sufficient condition, the hook operation fails, the program terminates, and an error code is returned.

[0077] The orange box in the middle, "Middle Convergence," indicates the computation process; each step can be backtracked for verification.

[0078] Blue arrow (downward hook → middle): Marks "necessary condition met".

[0079] Green arrow (middle → hook): Marks "Calculation completed".

[0080] Green down arrow (middle → bottom): Outputs the result after all calculations pass verification.

[0081] Red left-pointing arrow (hook → left side): Marked "not satisfied", hook failed, returning 1PCU.

[0082] Red right arrow (checkmark → right side): Marked "not satisfied", checkmark failed, error message terminated.

[0083] The green box at the bottom, "Theorem Holds | Output Results", indicates that the result is valid after both the lower and upper hooks pass.

[0084] Appendix Figure 4 [Flowchart of Boundary Touchback Correction Mechanism]

[0085] Figure 4 The processing flow of the boundary touch correction mechanism is shown.

[0086] The blue box at the top, "Start Calculation," indicates the starting point of the calculation process.

[0087] The orange box "Z_7 Operations | Addition / Subtraction / Multiplication / Division": the four arithmetic operation nodes.

[0088] The yellow diamond "Did the result touch the boundary?": Boundary check node. Connect the four sides as follows: top (operation input), left (yes branch), and right (no branch).

[0089] No branch (green right arrow): The result did not reach the boundary and enters the green box "Normal output | Valid result".

[0090] Branch (red left arrow): The result touches the boundary and enters the red box "Boundary Touch Return | Return 1_PCU".

[0091] The yellow box at the bottom lists four activation scenarios: subtraction result is not positive | addition result > 7 | divisor is 1 (PCU) | multiplication result modulo 7 = 0.

[0092] [Correspondence between drawing numbers and instruction manuals]

[0093] Appendix Figure 1 →The "Summary of Invention" section of the specification shows the three-layer architecture and module composition.

[0094] Appendix Figure 2 →The instruction manual's "Step 2" section shows the Z_7 encoding mapping rules.

[0095] Appendix Figure 3 →The instruction manual’s “Step 4” section shows the two-way anchoring process of the hook proof method.

[0096] Appendix Figure 4 →The “Step 5” section of the instruction manual shows the boundary touch correction mechanism process.

Claims

1. A continuous-discrete dual-mode runtime translation method based on Z_7 discrete coding, characterized in that, Includes the following steps: Step 1: Receive continuous field program input, which includes C language integers, floating-point numbers, null pointers (NULL), and memory allocation requests; Step 2: Map the continuous domain program input to the Z_7 discrete coding space, where the Z_7 discrete coding space has no zero value, and the minimum flag state 1_PCU is equivalent to the numerical value zero in the continuous domain but does not participate in arithmetic operations, and is only used as a boundary return signal; Step 3: Optimize the computation path based on structural reducibility, wherein the structural reducibility has the form of 2 to the power of k multiplied by m, where k is an integer greater than or equal to 1, m is an odd number or the origin marker, and the value 1 and the state marked by pure odd numbers do not participate in the computation. Step 4: Use the hook proof method to verify the causal consistency of each step of the transformation through bidirectional anchoring. The hook proof method includes: hooking down to lock the necessary condition of the conclusion, hooking up to verify the sufficient condition of the axiom, and convergence to the theorem in the middle. Step 5: Handle abnormal states through the boundary touch-back correction mechanism. When the calculation result touches the 1_PCU boundary, automatically return to the boundary marker and terminate the current calculation path; Step 6: Translate the discrete domain operation results back to the continuous domain interface, enabling the upper-level C language code to run on the Z_7 discrete architecture without modifying the source code.

2. The method according to claim 1, characterized in that, In the Z_7 discrete coding space, the largest unit number is 7, and the value 8, as a carry marker, only exists in the high-order carry and not in the current-order operation space.

3. The method according to claim 1, characterized in that, The integer mapping method in step 2 is as follows: non-positive integers are mapped to 1_PCU, positive integers are modulo 7 to obtain the remainder, if the remainder is 0, they are mapped to 7, otherwise they are mapped to the remainder.

4. The method according to claim 1, characterized in that, In step 3, memory allocation requests are filtered by structural reducibility determination. Only memory block allocation requests of reducible size are allowed to pass, while allocation requests of purely odd size, size of 1, and size of 0 are rejected.

5. The method according to claim 1, characterized in that, The hooking operation in step 4 of the hook proof method verifies whether the input parameters meet the necessary conditions at the function entry point. If they do not meet the conditions, it returns the 1_PCU boundary marker.

6. The method according to claim 1, characterized in that, The hook operation in step 4 of the hook proof method verifies whether the output result meets the sufficient condition at the function exit. If it does not meet the condition, the program terminates and returns an error code.

7. The method according to claim 1, characterized in that, The boundary touch correction mechanism in step 5 is activated in any of the following scenarios: the result of the subtraction operation is a non-positive number, the result of the addition operation exceeds 7, the divisor is 1_PCU, and the result of the multiplication operation is 0 modulo 7.

8. The method according to claim 1, characterized in that, The back-translation rule for the discrete domain result in step 6 is as follows: 1_PCU is mapped to the value 0 or null pointer NULL in the continuous domain, and the values ​​2 to 7 are mapped to the corresponding integer values ​​in the continuous domain.

9. A continuous-discrete dual-mode runtime translation system based on Z_7 discrete coding, characterized in that, Includes the following modules: The continuous-discrete translation module is used to map C language integers, floating-point numbers, and null pointers to the Z_7 discrete encoding space; The structural reducibility determination module is used to optimize the computation path and filter memory allocation requests; The hook proof verification module is used to verify the causal consistency of each step of the transformation through bidirectional anchoring. The boundary touch correction module is used to automatically return the boundary marker when the calculation result touches the boundary; The discrete-to-continuous back-translation module is used to output the results of Z_7 discrete domain operations to the C language continuous domain interface.

10. The system according to claim 9, characterized in that, The system, together with the following patents already filed by the applicant, forms a complete technical system: a digital identity gene encoding method based on projection constants, as the root node patent; The hardware architecture and implementation method of the PCU-B7 septonic arithmetic unit are patented as the arithmetic layer; the multi-agent dynamic routing and immune fusion method and system based on Z_7 structure reducibility and hook proof are patented as the network layer. The Web 4.0 AIAgent universe model basic protocol and holographic causal operating system based on digital holographic unified causality are patented as operating system layer patents; the cross-protocol payment and settlement meta-method and system based on energy-information-value triad coupling are patented as value layer patents.

Images