167: Chapter 167 The Framework is Set, Insurmountable Boundaries

September 6th, 7:58 PM.

When Jiang Lin sat down in front of his computer, a pop-up notice for a 15-minute closed-door meeting appeared in a fixed window.

[Meeting Notice]

Subject: A-1 / BB5 / Boundary Calibration After Withdrawal of Unified Draft

Agenda 1: Scope of Retained Existing Work

Agenda 2: Backward Reasoning Reproduction Plan

Agenda 3: Next Version Architecture of Shared Trusted Core

On his desktop, last night's confirmation email had already been processed.

In that email, the counterexample at step 193 was successfully reproduced, officially declaring the old unified draft obsolete.

The four-state Turing machine had left its mark on the endless blank tape.

The three types of original deciders and existing classification results of the project would be retained.

Tonight, there was no need to discuss why that four-state machine halted at step 193.

In the court of mathematics and logic, once a counterexample is established, debate ceases.

What truly needed to be determined was to which layer the halted draft should be dismantled, and what could be salvaged from the ruins after this massive deconstruction.

...

In fact, half an hour before the meeting connected, in the Tsinghua University project team's office, Zhou Shu was still frantically modifying the draft for the third proposal.

Over the past twenty-four hours, he had barely slept.

He had tried seventeen different interface refactorings, attempting to compress Backward Reasoning's massive search tree into a single standard format.

But every single time, as long as he didn't include that bloated search algorithm, the verifier couldn't confirm the result.

"It simply can't be dismantled," Zhou Shu said, rubbing his temples in frustration to Ye Ning beside him. "To prove to an entirely unintelligent program that there's no path backward, you'd have to make it search the paths itself all over again. The reason our previous design required the certificate to self-declare was that engineering-wise, it's impossible to pass the search process to the verifier for validation—it would blow up the verifier."

With this profound sense of helplessness, feeling that this was an engineering dead end, Zhou Shu entered the 8:00 PM meeting.

...

8:00 PM on the dot.

The countdown on the screen reached zero, and the call connected right on time.

The screen was divided into five windows of varying sizes; including Jiang Lin, five people were in different physical spaces, yet tied together by the exact same chain of logic.

Presiding over the meeting was Professor Qiao Wenduo in the top center window.

The bookshelf behind him was packed with heavy theoretical computer science texts and archived case files from past projects.

As a professor and doctoral advisor in Tsinghua University's Department of Computer Science, as well as the architecture lead for this BB5 project, Professor Qiao Wenduo had over a decade of experience in program semantics and formal verification, having led trusted core audits for verified compilers and safety-critical software.

In his research group, there was a near-cruel consensus: a green result run by the author's own hands could, at best, only be counted as an internal lab log.

Only when a different group of people, using a completely different language implementation, independently arrived at the same conclusion relying solely on public specification documents, did the result qualify to be written into the formal proof chain.

Professor Qiao Wenduo was someone who rarely used emotional adjectives in technical comments.

Yet, in last night's disposition minutes, he had written the word "severe" twice in a row.

For formal verification, a verifier that could be bypassed was far more dangerous than one that didn't work at all.

The left window was Ye Ning, an assistant researcher in the group.

She was responsible for decider result reproduction and dedicated verification for Translated Cycler, possessing a steadiness earned from years of wrestling with low-level code.

She could read high-level theoretical computer science proofs as well as dive all the way down to the simulator's lowest-level single-step transition function.

Early in the project, she had used a different implementation to independently replay the classification process of millions of machines.

The few subtle boundary discrepancies between the original tool and the reproduction results were all manually and programmatically tracked down by her, cell by cell, from vast amounts of tape snapshots.

Last night, after the step 193 counterexample arrived, she was also the one who led two graduate students to rerun the entire trajectory from a blank tape, confirming that the issue was indeed confined to the acceptance layer of the unified draft and had not crossed the boundaries of the original decider.

In the bottom-right window, Zhou Shu, a young researcher wearing black-rimmed glasses, looked somewhat haggard.

A top student who directly entered the Ph.D. program after graduating from the Yao Class, his research direction was precisely proof-carrying code and the minimal Trusted Computing Base (TCB).

The old unified draft that had been declared obsolete was authored primarily by him.

Over the past three months, twenty-seven modules, over four hundred interface tests, and two rounds of complex certificate format migrations had mostly passed through his hands.

His original intention in designing this draft was entirely correct: to compress the code that ultimately needed to be trusted down as much as possible.

However, the problem lay precisely in this over-compression: a proof obligation that should have been performed by the verifier itself was reduced, for the sake of a unified interface, to a simple boolean True filled in by the certificate generator.

The last window didn't have a camera turned on; that was the technical liaison from the Research Support Unit.

Responsible for real-time meeting transcription, version locking, and material isolation, they never participated in any proof judgments.

Faint rustling sounds of turning paper came through his microphone. Spread before him was a printout, with a glaring red stamp already pressed on the top right corner of the first page: [WITHDRAWN].

No one exchanged pleasantries.

The moment the call connected, Zhou Shu directly shared the emergency audit table from the past twenty-four hours.

The data expanded across the screen, precise and clear.

[Retain as-is]: 19 items (including basic state definitions, tape head logic, etc.)

[Split back into dedicated rules]: 5 items

[Involves unverified trust claims, directly voided]: 3 items

At the bottom of the page were listed three alternative proposals derived after a full day of debate.

[Proposal 1: Shared core callbacks to original dedicated deciders]

Pros: Fastest recovery, minimal code changes.

Cons: Search programs re-enter the trusted boundary.

[Proposal 2: Incorporate all three deciders into the trusted core]

Pros: Minimal external interfaces.

Cons: The trusted core bloats into the sum of three deciders, losing its virtue of being small and auditable.

[Proposal 3: Share machine semantics, separate three sets of verification rules]

Pros: Clear trusted boundary, each rule set only verifies finite witnesses.

Cons: Requires redesigning witness structures, Backward Reasoning is particularly difficult.

Ye Ning broke the silence first. Her voice sounded slightly distorted over the network connection, but her logic remained sharp: "Proposal 1 restores progress the fastest, but it means the referee has to trust the search program looking for evidence all over again. Proposal 2 minimizes interfaces, but the size of the trusted core bloats to the sum of the three deciders. This violates our original goal of establishing a Trusted Computing Base."

"After internal discussion, our group leans toward Proposal 3," Zhou Shu picked up, his voice raspy, clearly having stayed up all night. "However, Proposal 3 still has an issue. Once the three rule sets enter the trusted core, how do we guarantee that we're merely splitting proof obligations rather than just rebuilding three deciders under a different name?"

He zoomed in on the architecture diagram on the screen, red highlights circling several key modules.

The reason a decider was difficult to formally trust was precisely because its essence was exploration.

It used heuristic algorithms to search and guess unknown states.

For efficiency, it performed aggressive pruning, merged state spaces, and utilized various optimization strategies.

If the so-called separated rules still performed all these exploratory tasks at the low level, then the trusted boundary wasn't reduced at all—it merely turned from one giant black box into three slightly smaller black boxes.

Jiang Lin moved his cursor, opened a hand-drawn architectural sketch he had archived last night, and switched screen sharing to his end.

Between the search program and the verification rules on the diagram, a red line marked an unsurpassable chasm.

"The decider is responsible for finding evidence in the dark, while the verification rules are only responsible for checking evidence under the light."

Jiang Lin's voice was calm, yet carried undeniable certainty.

"The search side can extend a vast number of local configurations, repeatedly generating predecessors, deduplicating, and pruning; the verification side only checks the finite objects submitted in the certificate. It doesn't search for new nodes, nor does it rely on any heuristic optimizations that determine conclusions."

Jiang Lin stopped the cursor on that red line.

"It only answers two of the simplest questions: First, can the facts listed in the certificate be recalculated from the machine's lowest-level transition table? Second, does the proof obligation claimed to be covered by the certificate have any logical gaps mathematically?"

Zhou Shu stared at the crystal-clear line on the screen, his eyes slightly narrowing behind his lenses. After a few seconds of silence, he said, "In other words, the search side can stay smart, cunning, or even aggressive, but the referee side must be sufficiently dumb."

"The dumber, the better," Jiang Lin answered without hesitation. "So dumb that any single line of code can be read and understood by a human at a glance."

Ye Ning moved Proposal 3 to the top of the page, quickly evaluated its feasibility, and said, "We can do this on the Translated Cycler side. The dedicated decider continues outside to find translated segments, while the rule layer is only responsible for replaying this finite execution trace, and then checking the maximum backtrack limit. All search and detection strategies stay outside the boundary."

Zhou Shu rubbed his temples and raised the thorniest issue: "Ordinary Exact Cycle loops can also be split directly. What's really holding us up is Backward Reasoning. If the result it submits is still an entire massive backward search tree, the small verifier will still have to traverse it all over again. That circles right back to where we started."

Jiang Lin switched terminal tabs, tapped the keyboard a few times, and pulled up a brand-new directory.

[Backward_Reasoning_Reproduction / PENDING]

"So, the third type of program cannot be connected directly just yet. I'll handle reproduction and refactoring tonight. What it ultimately needs to deliver should be a 'finite map' that has already exhausted all possibilities, rather than a lengthy search process."

Professor Qiao Wenduo, who had been listening quietly, finally spoke up: "How can a map prove to an entirely unintelligent verifier that it hasn't missed any paths, without relying on external search?"

"Have the verifier derive the valid predecessors of every node on the map itself, based on the machine's single-step transition table," Jiang Lin gave his answer. "The verifier performs zero outward exploration. It does only one thing: check whether all valid predecessors calculated according to the rules already exist within the boundaries of this map."

Professor Qiao Wenduo looked deeply at Jiang Lin on the screen, then turned to Zhou Shu.

"Write what Jiang Lin just said into the design constraints of Proposal 3, word for word."

Zhou Shu's fingers flew across the keyboard, and a bold red line immediately appeared in the minutes system:

[Iron Rule of System Design: Search and reasoning capabilities must not enter the trusted core; the trusted core only verifies finite witnesses and their logical closure obligations.]

Zhou Shu then picked up the printout stamped with the withdrawal mark, flipped past the first page, revealing dense low-level code beneath.

"If Backward Reasoning can also be cleanly split along this boundary, then over the past three months of work, only the top three catch-all interfaces were actually scrapped," Zhou Shu let out a long sigh. "Once the new specification is out, I'll write one of the independent implementations."

At 8:15 PM, the fifteen-minute agenda concluded, and the meeting line disconnected.

Jiang Lin returned to his isolated workstation interface.

The first two reproduction directories, [Cyclers_Reproduction] and [Translated_Cyclers_Reproduction], remained encrypted and sealed.

He moved his mouse and double-clicked open only the third directory.

[Backward_Reasoning_Reproduction]

This directory had previously been just an empty shell with a few basic documents; even the reproduction environment had not been set up yet.

Jiang Lin cloned a new system snapshot from an absolutely clean baseline virtual machine saved on September 1st.

Next, strictly following the project's dependency manifest, he loaded the compiler, dependency libraries, and basic runtime environment one by one.

He then forcibly set the source code directory permissions to read-only.

All test materials utilized the public hashed versions revised in June, while old Git commit logs and former output logs were packaged and isolated in a separate history directory, ensuring they would never interfere with this round of reproduction results.

8:31 PM.

All preparations were complete.

The commit hash, dependency versions, and test suite hashes were all locked down.

The Backward Reasoning program officially launched within this isolated, air-gapped environment.

Entirely contrary to the former two methods that attempted to predict the future, Backward Reasoning's operational logic was counterintuitive.

[part:gemini-3.5-flash-lite]

It does not follow the read-write head of the Turing machine from the starting state of the blank tape, step by step asking what will happen in the future.

It chooses to stand at the terminal station where the Turing machine halts, turn around, and look back.

To visualize this process in the mind, one can imagine a supercity with intricate roads, so vast that its boundaries cannot be seen.

This Turing machine is simply a robot wandering through the city.

The robot sets off from an all-white initial room, and halting is a terminal door bearing the sign "Off Work".

Traditional forward simulation is equivalent to a person following behind the robot, watching it turn left today and right tomorrow, quietly recording, and waiting for it to happen to walk up to that door one day by chance.

If this robot falls into some kind of infinite loop, or wanders aimlessly in the endless wilderness in a direction away from the door, the person following behind can only wait endlessly in despair until the heat death of the universe.

Backward reasoning, on the other hand, adopts a completely different philosophy.

It first sends someone to stand directly in front of that off-work door, without asking about the origin, to first find all positions that can step into the door in one step.

Assuming there are three such positions, they are marked as one step away from the end.

Next, it continues to search backward from these three positions, marking all positions that can reach the door in two steps, followed by three steps, four steps, and more steps.

If, after a period of frantic expansion, the process of searching for predecessors suddenly stops and no new positions are added,

ultimately, the backward reasoning program draws a finite map with clear boundaries.

This means that all roads theoretically leading to the terminal door, even if circuitous, have all been enclosed within this map.

At the edge of the map, no more secret entrances into the interior can be found.

At this point, one only needs to check the final thing: Is the all-white room where the robot was originally located on the map?

If it is not, the conclusion is beyond doubt.

Because the roads leading to the end have been exhausted, and the starting point is not on these roads, the robot can never walk to the end.

This is the core mathematical idea of Backward Reasoning proving that a Turing machine does not halt.

However, the enormous trouble of this set of ideas in engineering implementation is deeply hidden within the words "exhausting all roads" and "without any omissions".

A massive search program can confidently print out a line of log, claiming that it has finished searching the roads.

But the final trusted verifier must never stamp and let it pass based on this baseless declaration.

The fatal counterexample of step 193 has just proved with bloody facts that leaving the critical closed-loop conclusion to the certificate generator to speak for itself will only cause the trusted kernel to grow the exact same ulcer again.

Jiang Lin hit enter and ran the first set of public test cases.

The terminal quickly gave the results.

[ Backward_Depth: 300 ]

[ Decision: NON_HALTING ]

Left behind along with the conclusion were a massive number of records for node expansion, predecessor generation, and duplicate configuration merging.

These records could explain how the original decider got the answer, but they could not become a lightweight piece of evidence.

For another program to confirm the conclusion along the log is almost equivalent to re-executing a backward search.

As a result, the complex search program still remained within the trusted boundary.

Jiang Lin closed the log window expressionlessly.

He did not need these lengthy proof processes, nor did he need to know how the program groped in the dark.

Therefore, he only extracted the resulting map left behind at the end.

Every node on the map represents a local snapshot that the Turing machine might be in at a certain moment: the current internal state, the symbol under the read-write head, and a small segment of already determined tape content around the read-write head.

Most crucially, the area outside the window is not defaulted to all 0s, but is explicitly marked as unknown.

Therefore, a node represents not a specific complete tape, but a set—the sum of countless tape scenarios that could possibly extend outward from this locally known pattern.

Jiang Lin began to refactor the code.

He violently compressed what the small verifier needed to do into three absolutely objective checks.

First verification: Check whether all tape entrances that can directly trigger the halting state are included word-for-word in this map.

Second verification: For every known node in the map, according to the rules of the Turing machine, retroactively deduce all its legal previous steps one by one. Check whether these predecessors necessarily fall within the existing set of nodes of the map. There must never be a single legal path quietly leaking in from the nihilistic edge of the map.

Third verification: Check that the initial state snapshot on the all-white tape must absolutely not appear in this map. Any deception method attempting to hide the starting point through coordinate system translation or local window cropping must be identified.

As long as these three checks pass, regardless of whether the original search process was clever or foolish, taking one second or one year, it can honorably retire from the referee's podium.

The certificate is only responsible for submitting this finite static map. The compact verifier is responsible for checking whether the boundaries of the map are completely closed.

Nine forty-one.

The first backward unreachability witness complying with the new specification was generated at the fingertips of Jiang Lin.

He unhesitatingly terminated the original decider process, cleared the temporary files it left behind, and only kept the machine description and witness files.

Then he started the newly compiled independent verifier.

The screen did not re-render hundreds of layers of the backward search tree.

Like a completely emotionless gear, the verifier read the map nodes one by one, rigidly recalculating all predecessors according to the single-step transition table of the machine.

Four seconds later, the screen refreshed, and four lines of green characters representing success leaped out in sequence.

[ HALTING_ENTRANCES / COVERED ]

[ PREDECESSOR_SET / CLOSED ]

[ BLANK_INITIAL_CONFIGURATION / ABSENT ]

[ WITNESS / VALID ]

A complex conclusion that originally relied on the program swearing it would not halt turned, at this moment for the first time, into a finite roadmap that could completely detach from the original program and be independently accepted by any third-party tool.

Jiang Lin did not stop in front of this string of reassuring green results.

For a security architecture aiming to be flawless, being able to verify correct results is merely passing, but being able to defend against meticulously constructed malicious deception is the core.

He copied the valid witness file from just now, opened a hex editor, and began manually fabricating three malicious samples for attack.

First attack sample: In the middle of the map, he artificially deleted a legal predecessor node. This was equivalent to forcibly smashing a gap in the originally closed city wall, erasing an actually existing access route, and attempting to deceive the verifier into thinking the map was closed.

Run the verifier.

[ REJECT / MISSING_PREDECESSOR ]

The red light lit up.

During backward deduction, the verifier discovered that a calculated predecessor was not on the list and rejected it on the spot.

Second attack sample: Without altering the map structure, he quietly moved the coordinate origin parameters of the local window, attempting to disguise the initial state on the all-white tape as another irrelevant edge position through a coordinate system offset, thereby bypassing the start check.

Run the verifier.

[ REJECT / BLANK_START_HIDDEN_BY_TRANSLATION ]

The red light lit up again.

The strict coordinate alignment logic saw through the disguise.

Third attack sample: He retained all the true nodes, but forcibly labeled several edge nodes that were clearly not yet converged and could continue to be deduced outward as closed.

Run the verifier.

The verifier ignored the labels; it performed a retroactive deduction on the spot based on the transition table, accurately finding a legal previous step that was not listed in the certificate.

[ REJECT / FALSE_CLOSURE ]

Three red lights lit up on the screen in sequence, resembling three indestructible iron gates.

Each one stopped precisely at the first scene where the forgery occurred.

Throughout the entire rejection process, the verifier did not call the original Backward Reasoning decider even once, nor did it believe the false checked statement in the certificate.

Jiang Lin encapsulated one valid witness, three forged witnesses, the source code of the independent verifier, and an extremely concise plain-language documentation page into the same compressed directory.

[ Backward_Unreachability_Witness_v0.1 ]

[ Backward_Rule_Checker_v0.1 ]

[ Adversarial_Cases / 3 ]

Afterward, he concatenated the common parts agreed upon by all parties to retain in the meeting tonight, just like splicing together the base of a precision instrument.

Machine description hash value.

Blank tape initial condition definition.

Single-step transition semantic engine.

Certificate type routing label.

Tracker for failure locations.

The responsibilities of the common layer stopped abruptly right here.

Below the routing label, the three verification paths began to go their own ways without interfering with each other.

The first two paths continued to use the dedicated proof obligations already confirmed to be correct.

Meanwhile, the newly integrated backward unreachability rule tonight was only responsible for checking whether the finite map leading to the off-work door missed any roads, and whether the starting point was safely excluded.

At ten fifty-two, Jiang Lin clicked send.

The reproduction package completed version verification and forwarding through the Research Support Unit.

The email subject retained the original tracking number, adding only a state description at the end.

[ A-1 / BB5 / Backward Reasoning / Independent Witness Ready ]

At this time, eight minutes remained before the closing time of the technical window.

Jiang Lin methodically exported the execution logs, archived the current virtual machine snapshot, and finally shut down the isolated workstation.

The buzzing sound of the chassis fan gradually subsided. Jiang Lin stood up and stretched his aching cervical spine.

Half a box of grapes left over from the night before was still in the refrigerator. The two sheets of paper on the desk printed with the counterexample trajectory of step 193 had already been neatly filed away by him into a black folder on the side.

That four-state machine which had caused a sensation had already completed its task as a touchstone.

What would next undergo the rigorous examination of the entire team was this map unfolding backward from the end.

September 7th, seven-twelve in the morning.

The morning mist of Beijing had not yet dispersed.

Zhou Shu was already sitting in the spacious office of the project team, with a cup of espresso that had long since gone cold at his side.

Bearing heavy dark circles under his eyes, he first verified the hash value of the reproduction package sent by Jiang Lin, ensuring the file had not been tampered with during transmission.

Then he completely removed the massive and complex original Backward Reasoning program, along with all its dependency libraries, from the execution path.

In the current test environment, only the machine description file, a few compact finite witnesses, and the newly born verifier remained.

The enter key was pressed.

The valid witness passed smoothly.

The three public adversarial forged witnesses included with the package from Jiang Lin were ruthlessly rejected at the expected positions one by one.

But Zhou Shu did not stop here.

As the lead author who had once stepped on landmines, his suspicion had been stimulated to the highest point.

He turned around and pulled out a real Turing machine description from the internal highly confidential result database—one that Jiang Lin had never seen before.

He called Ye Ning, who had just entered the office, and asked her to export their own backward search results into a finite map format using another set of tools according to the new specifications from last night.

The new verifier did not need to know who generated this map at all, nor did it care how it was found.

Like a machine blindly feeling an elephant, it simply followed the machine transition table to check predecessors node by node.

Looking at the green lights lighting up continuously on the screen, years of low-level debugging experience instinctively gave Ye Ning a stubborn streak of refusing to admit defeat.

"He only spent one night, I do not believe this defense network does not have a single crack." Ye Ning pushed her coffee cup aside, the speed of her hands hitting the keyboard suddenly accelerating. "Zhou Shu, I do not see any problems with the mathematical closure for now, so let me test the certificate structure first."

She copied that valid witness, changed the predecessor number recorded in one of the nodes to a value outside the range of the node table, and regenerated the outer file verification.

Formally, this certificate could still be read, but internally it pointed to a completely non-existent node.

If the verifier did not check the reference range first, the subsequent closure judgment might read the wrong object or even exit with an exception directly.

Ye Ning submitted the modified witness.

The verifier completed file parsing, but did not enter machine semantics and backward closure checks.

[ REJECT / OUT_OF_RANGE_NODE_REFERENCE ]

The log gave the specific location at the same time.

[ NODE: 184 ]

[ PREDECESSOR_REF: OUT_OF_RANGE ]

When Ye Ning brought up the processing flow of the input layer,

before touching any mathematical rules, the verifier had checked the node count, ID uniqueness, reference range, and machine binding in order.

Unexpectedly, the deformed certificate didn't even have the qualification to enter the proof verification stage.

"The structural layer rejects bad certificates first, and then the proof layer judges the mathematics." Zhou Shu looked at the line of red text and gave a bitter smile. "There is no need to waste effort; he has separated these two layers as well."

Ye Ning pressed her lips together, decided to turn to the more covert machine-binding problem, and launched her final attack.

She took back the valid witness, replaced a transition rule in the machine description file with a text editor, and tried to substitute one thing for another, making a real map make a not-guilty plea for a completely different machine.

This time, the program didn't even run to the step of reverse rule checking.

When reading the configuration, the public layer intercepted it as if it had been electrocuted.

[REJECT / MACHINE_WITNESS_MISMATCH]

Seeing this, Zhou Shu sighed, shook his head, and finished tracing the final call path of the verifier.

The conclusion was irrefutable: it would not expand the search depth, it would not guess new local configurations at runtime, and it didn't even read any cache fragments left by the original decider.

However many nodes the certificate gave, it meticulously verified that many nodes.

Even if the certificate handed in one less legal predecessor, it would mercilessly stop before the gap and report an error.

Zhou Shu projected the complex call graph of the original decider and the streamlined call graph of the new verifier side by side onto the white wall of the office.

The graph on the left was stacked layer upon layer, like a lush primeval forest, filled with search, heuristic pruning, and state-merging uncertainties.

The graph on the right, however, was like a straight javelin: it only had machine single-step semantics, predecessor generation, set inclusion and closure checks, and initial state exclusion.

Ye Ning held her water cup and watched for a moment, then slowly uttered the second half of Jiang Lin's sentence from last night.

"The search program can continue to be smart, while the referee has finally become stupid enough to be trustworthy."

At eleven o'clock, Professor Qiao Wenduo pushed open the door and walked into the office.

He did not look at the complicated code, but instead carefully reviewed the logs that fended off the fourth attack, then looked at the two call graphs on the wall with their sharp contrast, and finally turned to the page of extremely concise plain-language explanation written by Jiang Lin.

"The counterexample at step 193 proves that he has the ability to find our mistakes." Professor Qiao Wenduo gently tapped his fingers on the tabletop, his voice carrying rare praise. "And today's witness shows that not only can he break it, but he also knows what materials the correct trusted boundary should use and what coordinates it should be built on."

He pushed the thick reproduction report back to Zhou Shu.

"This afternoon, completely finalize the personnel lists and test isolation plans for the two implementations. The framework has been established, and it's time for us to work."

At the same time, on the playground at the other end of the campus, military training continued as usual.

The sun on September 7th was even more scorching than the previous few days. The plastic runway emitted a pungent rubber smell, and the green phalanx moved across the vast field.

"Right—face!"

"Forward—march!"

"Halt!"

The formation turned, marched in step, and stopped amidst the instructor's hoarse commands.

Jiang Lin was expressionless, sweat sliding down his cheeks and hitting the collar of his camouflage uniform.

Like several thousand other freshmen, he mechanically completed every movement according to the collective rhythm.

The sunlight was so glaring that people could hardly keep their eyes open.

Not a single bit of the high-level discussion about Turing machines and computing boundaries that took place in the office entered his daytime.

His world at this moment only consisted of the sweltering breeze, sore calves, and the aroma of food drifting from the distant cafeteria.

The two worlds folded in real physical space, completely unrelated to each other.

At 7:53 in the evening, night fell.

Jiang Lin had just finished taking a shower when the technical liaison of the Research Support Unit forwarded the afternoon's reproduction results and a temporary meeting request.

[Reproduction Evaluation Report]

Valid Witness: Passed

Three Public Confrontation Witnesses: All rejected at expected positions

Team Additional Attack: MACHINE_WITNESS_MISMATCH / Rejected

Verification Process: Original Backward Reasoning decider not called throughout the entire lifecycle

Reproduction Conclusion: The proof rules already possess the ability to run independently from the search program. Architectural separation is feasible.

At 8:00 sharp, the five-person meeting from the previous night came back online.

Sweeping away the gloom of last night, Zhou Shu appeared exceptionally excited.

He held up the printout of the old draft in front of the camera.

The huge box writing unified certificates that was still on it yesterday had been cut out entirely by him with scissors, leaving a regular square hole.

Below the hole, the nineteen retained machine semantics, test cases, and failure traces were redrawn with a marker into a smaller, more compact public framework.

Beneath the public framework, three clear red lines connected to three independent verification rules respectively.

"That soul-searching question from last night—I re-verified it during the day today." Zhou Shu's voice carried a sense of relief. "Most of the hard work from the past three months is still there. What we removed was merely the arrogant requirement of forcing three completely different kinds of evidence to speak the same standard language."

He put down the mutilated printout in his hand.

"The closed-loop of the Backward witness has been completed. During the day, our team added an unseen machine-binding attack sample of our own, and it was also accurately blocked by the public layer. Your defense line is very solid."

Ye Ning immediately shared the latest task list.

The two implementation groups had already completed isolation.

Code repositories, compilation environments, and internal communication channels were all separated.

One team continued to use the project's existing language, while the other adopted a different language, rewriting from scratch solely based on the frozen specification.

Both parties had to independently complete the three sets of verification rules. Before the blind test ended, neither party could see the other's code.

"We are responsible for the specific implementation, and the hidden test sets are handed over to a third party," Ye Ning said. "You are only responsible for freezing specifications and public test vectors."

Professor Qiao Wenduo projected a brand-new system architecture diagram directly into the center of the shared screen.

[Shared Machine Semantics (Public Machine Semantics Layer)]

├── [Exact Cycle Rule (Exact Cycle Rule) / READY]

├── [Translated Cycle Rule (Translated Cycle Rule) / READY]

└── [Backward Unreachability Rule (Backward Unreachability Rule) / READY]

Below the three rules flashing with green READY indicators was a line of gray text, quietly waiting to be lit up.

[Independent Blind Replay (Independent Blind Replay) / PENDING]

"Starting tomorrow, the two implementation teams will not exchange any code with each other; this is our internal isolation plan on this side."

Professor Qiao Wenduo looked toward the window where Jiang Lin was, his tone carrying clear consultation.

This tackling of the BB5 project was inherently a cooperative request actively initiated by their team.

"All real certificates, forged certificates, and hidden samples with traps will be uniformly handed over to a third-party security team for packaging and obfuscation."

Professor Qiao Wenduo explained the upcoming arrangements, and then made a suggestion in a consultative tone.

"Jiang Lin, do you think this arrangement is appropriate for the upcoming blind test stage: we won't trouble you to personally review the blind test set; leave the specific language implementation and code bugs for those two teams to worry about themselves. You only need to control the specifications and not waste energy on these underlying engineering issues, which can also maximize the objectivity of the final review. What do you think of this process?"

Afterwards, Professor Qiao Wenduo made a permission change on the project's collaboration architecture table, setting up a new node in the highest-permission column and filling in Jiang Lin's name.

[Trusted Kernel Architecture and Proof Boundary Review: Jiang Lin]

In the first few rows of the collaboration table were written the project's overall lead Professor Qiao Wenduo, rule head Ye Ning, and implementation group lead writer Zhou Shu.

And Jiang Lin's position was independent of all engineering implementation modules, hanging high above the top of the entire trusted kernel architecture like the Sword of Damocles, holding absolute veto power.

Even though in the system identity column next to his name, there was still a line of text that was overly simple.

[Tsinghua University Qiuzhen College / Class of 2022 Undergraduate]

But this was long no longer a label that needed to be reviewed by the team.

As early as when solving Jiangs Brick and the PFR Conjecture, the gold content of this name in the theoretical circle had already become famous throughout academia.

Today, that 193rd-step halting trajectory that tore apart the old draft, as well as tonight's indestructible reverse deduction map, made several top scholars on this side of the screen convinced with admiration.

They were very clear that they were relying on this genius brain to backstop the BB5 project, rather than assigning tasks to him.

From the very second this permission took effect, any changes involving the BB5 project's common machine semantics and certificate-binding logic had to pass Jiang Lin's hurdle first.

The two highly educated implementation teams would perform coding work like blind men touching an elephant entirely under his architectural blueprints.

This was a trust entrusted based on absolute intelligence.

Zhou Shu picked up the electronic pen and unhesitatingly signed his confirmation name on the collaboration table.

"I agree." Zhou Shu looked at the camera, his tone not only sincere but even carrying a trace of instructive respect. "To be able to precisely dismantle three load-bearing walls of a dilapidated building I spent three months building, retain nineteen good pillars, and then give a rock-solid new blueprint—being able to invite the God Jiang to act as the supreme judge of this system is this project's luck."

Regarding Professor Qiao Wenduo's proposal and the team's statement, Jiang Lin did not show any redundant emotional fluctuations.

For him, truth was supposed to operate in this manner anyway.

Since the architectural right to speak and isolation mechanism had been established, he naturally didn't need to care about those underlying mason jobs anymore.

"Okay," Jiang Lin replied briefly.

Afterwards, he moved his mouse, clicked on the version control option in the background management interface, and pressed the button symbolizing specification locking.

[Shared_Verification_Kernel_Spec_v0.1-rc1/FROZEN]

At the very bottom of the meeting minutes, Zhou Shu used a piece of emotional text as a summary.

[What is unified is the door frame and keyhole, but the three categories of proof evidence each retain their own keys.]

Seeing this line of words, Jiang Lin's fingertips paused briefly on the keyboard. Afterward, beneath Zhou Shu's sentence, he typed a supplementary line.

[Three keys, three sets of tooth patterns, none can replace another. If someone wants to use one key to open all doors, the security system must sound an alarm.]

The clock pointed to 8:15, and the state of the project master control panel automatically refreshed again.

All preliminary reviews turned green across the board.

The door to entering the blind test stage officially opened.

The meeting ended, and the channel connection was cut off.

Zhou Shu leaned back in his chair, looking at the line of green characters on the screen representing the candidate specification freeze.

"How old is he this year?" Ye Ning suddenly spoke up to break the silence, her tone carrying a bit of depressed complexity. "Not even twenty years old yet."

"Don't use age to measure that kind of monster; it will make people depressed." Zhou Shu took off his black-rimmed glasses and pinched the bridge of his nose.

As a Yao Class graduate, Zhou Shu had seen too many so-called geniuses.

But those geniuses often indulged in the clever tricks of algorithms or the running efficiency of code.

Yet the young man across the screen just now possessed an admirable calmness and thoroughness.

"I spent three months and wrote tens of thousands of lines of code, trying to make all machines understand the same language." Zhou Shu pointed to the call graph on the white wall. "I thought that was a great piece of engineering, but he only took one glance and told me with the most basic mathematical common sense: machine semantics must be unified, but the three types of proof structures cannot be forcibly unified."

Zhou Shu put his glasses back on, and the trace of exhaustion from staying up for two consecutive nights at the bottom of his eyes was swept away instead.

"Being an underlying mason for such a person is not shameful. Ye Ning, get ready to continue working."

From then on, every piece of evidence attempting to claim that a certain Turing machine would never halt could no longer hide behind the huge and complex decider.

They had to strip away all algorithm disguises and walk step by step, before the insurmountable boundary delineated by Jiang Lin, completing the rigorous path to the adjudication seat.