166: Chapter 166, Step 193: Collapse

September 1st, 8:06 PM.

When Jiang Lin finished military training, took a shower, and returned to Room 402, the materials forwarded by the Research Support Unit were already sitting in the fixed window queue.

The email subject had been re-numbered.

[A-1 / BB5 / First Round Replication Materials / For Local Review Only]

The attachments did not go directly into the computer.

The attachments contained external code.

Even if the code was public, it might access files it shouldn't, or occupy the processor and memory for a long time under abnormal inputs, so it had to be reproduced in an isolated environment with disconnected networks and restricted permissions.

Jiang Lin first checked the source, file list, commit records of the public decider repository, and the version list of the internal certificate drafts.

After confirming that the hash verification was correct, he downloaded the archive into a physical medium specifically responsible for external code review.

The network cable of the connected computer was immediately unplugged, the wireless module was physically powered down, and the medium was plugged into the neighboring isolated workstation.

The workstation screen lit up, revealing the true appearance of the core materials.

Three decider codes from the public repository.

Three test suites containing thousands of edge cases.

Three unpublished certificate drafts compiled by the Tsinghua University team based on the existing decider output format.

And twenty-seven edge cases that had been verified by the original tools but exposed field conflicts, false rejections, or compatibility issues in the unified draft.

The directories corresponded one-to-one with the three empty projects created last night.

[Cyclers_Reproduction]

[Translated_Cyclers_Reproduction]

[Backward_Reasoning_Reproduction]

Jiang Lin did not run the one-click script provided by the author.

Running automated scripts in an untrusted environment was equivalent to handing over the underlying control of the system.

He created a new virtual machine snapshot, fixed the compiler version, underlying runtime libraries, and all third-party dependencies, completely cut off the network permissions of the three projects at the kernel level, and set up read-only mounts for the original code directories.

The intermediate files, standard output, and abnormal exit records generated by each compilation were directed and written into a separate replication logging system.

The first round of replication failed quickly.

The program could complete compilation normally, but the hash of the first certificate could not align with the original record.

The Cycler project referenced a serialization library used for certificate persistence. The original author's environment retained an old version, but the local build script did not specify a dependency upper limit. The new version interface changed the default encoding order of fields, and after writing the same certificate object to disk, the byte representation was no longer consistent with the original environment.

Jiang Lin did not modify the source code, nor did he forcibly make the new encoding compatible; instead, he rolled back the dependency version according to the commit date and recorded the environmental differences in the replication log.

At 8:43 PM, the first set of samples completed replication.

The first set of machine IDs and running records appeared on the screen.

[Machine_ID: CY-RP-017]

[State_Count: 5]

[Symbol_Count: 2]

[t1: 186]

[t2: 254]

[Configuration_Hash_Match: TRUE]

Jiang Lin did not easily accept the result just because of the last green TRUE line.

He re-executed the transition function from a blank tape, exported the complete finite support, read/write head position, and internal states at step 186 and step 254 respectively, and then compared them item by item.

The two configurations were completely identical.

Starting from step 186, the machine fell into an inescapable trap.

The subsequent sixty-eight steps formed a closed topological loop.

The Turing machine returned once more to a configuration indistinguishable from the starting point, and all its future evolution could only mechanically repeat this trajectory like Sisyphus pushing a rock, until the end of time.

The witness objects required for the Cycler certificate were very clear.

A deterministic machine transition table containing all branches.

Two distinct integer time points.

Two calculated machine configurations that must be completely identical.

And a deterministic execution segment from the first configuration to the second, which could be rechecked by an independent program.

Jiang Lin ran all 427 regular Cycler samples provided by the author through his own simulator once again.

All 427 tests passed successfully.

Subsequently, he began conducting destructive testing.

He wrote a simple mutation script to randomly tamper with the time points in the certificate, offset the read/write head position by one grid, expand the tape validation boundaries, or even simply flip a single symbol in an inactive interval, thereby generating a large batch of artificially manufactured forged certificates.

The verifier acted like a ruthless guillotine, rejecting these forgeries one by one without a single missed judgment.

At 10:51 PM, the first replication record was completed.

[Cyclers_Reproduction / PASS]

[Certificate Semantics: Exact Configuration Replication]

[Trusted Premise: The verifier independently executes all transitions between t1 and t2]

[Anomaly Testing: No false acceptance vulnerabilities found]

Jiang Lin saved the virtual machine snapshot and physically cut off the power to the isolated workstation.

That day's fixed technical window thus came to an end.

The next morning, he went to the playground as usual.

Military posture, formations, goose-stepping, breaks, hydration.

The September sunlight carried residual summer heat, steaming across the plastic running track.

Daytime training did not change at all because of those complex topological structures in the hard drive last night.

The multidimensional state space of the Turing machine and the boundaries between halting and non-halting were all tightly suppressed in the background of his consciousness, until the evening window reopened.

September 2nd, 8:09 PM.

Jiang Lin began replicating Translated Cyclers.

The previous night when reviewing the project initiation abstract, to help the technical liaison understand quickly, Jiang Lin used a popular metaphor summarizing the Translated Cycler as a seal rolling continuously into the distance.

Every time the seal rolled a full circle, it left an identical pattern on the tape, just positioned further to the right.

Since it was forever pioneering new unvisited regions to the right, naturally it would never halt.

But now entering code-level replication, what he needed to check was precisely the auxiliary condition in that popular science explanation that was most easily glossed over.

The seal could indeed roll continuously to the right.

But those old traces left behind in the past, those sporadic symbols forgotten at distant coordinates on the left, would they really never like ghosts block its forward path again during some unknown backtracking?

The specialized decider provided by the author was extremely cautious.

It would not rashly judge by casually picking two locally similar patterns on the tape.

It only left a record when the read/write head reached a new position it had never been to before, waited for the machine to carve out new cells in the same direction again, and then aligned the read/write head positions of the two records.

Between the two records, however many cells the read/write head retreated backward at most, the comparison window needed to cover at least that many cells.

Only when the machine states were identical, the patterns within the window could overlap through translation, and the old traces outside the window would not block the path again, could it be listed as a Translated Cycler candidate.

The first twenty-seven basic samples all passed smoothly.

But Jiang Lin did not continue writing scripts to expand the test quantity.

Twenty-seven green passing records could only prove that the local replication environment achieved consistency with the original author's development environment in dependencies and compiler behavior, but could not prove that the universal certificate rules attempted to be drafted by the Tsinghua University team were reliable in mathematical logic.

He cast his gaze toward those tricky edge data.

However, instead of first processing those samples rejected by the unified draft, he pulled out a machine located near the boundary of the tape from the samples accepted simultaneously by the specialized verifier and the unified verifier.

This machine, numbered TC-EDGE-09, exhibited two local tape patterns with completely identical shapes at step 912 and step 1074.

The internal states were consistent, the relative offsets of the read/write head were consistent, and the second pattern was shifted globally to the right by eleven cells.

The original Translated Cycler judgment program judged it as non-halting.

The specialized verifier written by the Tsinghua University team for such certificates accepted it.

The unified verifier attempting to integrate all rules also returned a pass.

Everything looked very smooth.

Jiang Lin tapped the keyboard, called up the visualization tool, and expanded the two machine configurations directly from local windows to the global view of the entire tape.

At step 912, to the left of the window marked as valid, at a distance of thirty-seven cells, quietly lay an isolated number 1.

That was the waste left behind when the machine wandered disorderly to the left during its very early operational phase.

In the more than seven hundred steps thereafter, the read/write head sprinted all the way to the right and never looked back to visit this coordinate again.

By step 1074, that isolated 1 still remained at its original absolute coordinate. The main pattern shifted to the right by eleven cells, the 0s and 1s inside the window were completely identical, but the entire tape did not undergo a strict global translation.

This machine could still be correctly judged as a Translated Cycler.

The original specialized decider did not need to predict the infinite future of the machine. It only left a record when the read/write head reached the rightmost position never visited before, and then waited for the machine to carve out new cells to the right again.

Between the two records, however many cells the read/write head retreated backward at most, the specialized decider expanded the comparison window to the left by at least that many cells. Subsequently, it aligned the read/write head positions of the two records, checking whether the machine states were identical and whether the patterns within the window could completely overlap after translation.

If all these conditions were met, the deterministic transition rules would cause the next running segment to globally shift to the right in the same manner. Repeatedly applying this conclusion could prove that the machine would only continue to open up new cells and would not retreat back into isolated symbols outside the window.

The reason the specialized verifier accepted this machine was because it would independently replay the execution segment between the two records, recalculate the maximum rollback distance, and check whether the comparison window truly covered all content that might re-participate in evolution.

However, in the unified verifier code attempting to pursue generality, Jiang Lin did not find this defensive checking logic.

To allow ordinary Cyclers and complex Translated Cyclers to share the same streamlined data structure, the designers of the draft made a bold architectural compromise.

They forcibly compressed the extremely complex dynamic verification process—that old traces outside the window would never re-participate in evolution in the future—into a boolean field filled out by the certificate generation end itself.

[Isolated_Window: TRUE]

For the TC-EDGE-09 machine in front of him, this boolean value happened to be true in physical reality.

It truly did not turn back.

Although the unified verifier gave up personal verification, because it happened to read an honest declaration, it happened to obtain the correct result.

Jiang Lin's gaze turned cold.

A verification system designed to make final formalized judgments cannot have its authority built on the fragile foundation of the certificate generation end happening to tell the truth.

If in a courtroom, a judge simply dropped the gavel based solely on a declaration of innocence issued by the suspect themselves, then that judicial system itself was the greatest security vulnerability.

At the top of the replication log, Jiang Lin typed out the first red-highlighted blocking item declaration.

[Blocker-01: Translated Cycler certificate lacks independently verifiable window isolation witness.]

[Technical Details: The specialized verifier independently replays the execution segment between the two records and verifies the maximum rollback range; the unified verifier only reads the Isolated_Window field.]

[Conclusion: Although the current edge case is judged correctly, there is a fundamental logical fracture in this process, making it impossible to prove that the unified verification system possesses anti-forgery capabilities.]

After finishing the blocking item, he then copied that edge case, preparing to carry out an operation highly aggressive in the field of system verification—constructing a malicious logic bomb.

The original Turing machine rules, original generated certificates, and original passing judgments were all retained as a baseline control group for comparison.

In the newly copied sandbox, Jiang Lin acted like a precise surgeon, dismantling the machine's transition function table.

He rewrote one of the rarely triggered branch rules and forcibly modified the direction of the read/write head.

This modified machine would still abandon a 1 dozens of cells outside the valid window during early operation, and would still obediently complete two local pattern translations separated by hundreds of steps, generating a seemingly impregnable translation proof.

However, after these two translations were completed and fooled the comparison logic, the back door implanted by Jiang Lin was triggered.

The machine's state fell into a lengthy turnaround loop, and the read/write head began slowly and resolutely retreating to the left.

The corresponding malicious certificate still submitted only that well-behaved local snapshot, and grandly filled in the truth value representing safety within the isolation declaration field.

[Isolated_Window: TRUE]

The machine's static description hash, runtime trajectory tracking inside the window, and local configuration snapshot hash all smoothly passed the multiple recalculations of the unified verifier.

The only thing that was not verified by the verifier's independent sandbox was still that same problem.

Could the symbols outside the window re-invade the path of the read/write head after all?

The original specialized verifier re-executed the running segment corresponding to the certificate and found that the maximum rollback range of the read/write head exceeded the isolation boundary declared by the certificate, thus rejecting this certificate.

However, the existing unified verifier pushed by the Tsinghua University team unguardedly read that false boolean value and skipped the boundary check.

On the screen, a line of glaring green characters popped out.

[Certificate Valid]

Jiang Lin stared at this jarring green font for a moment, called up the underlying simulator he wrote himself, placed this tampered machine on a blank tape, and let it evolve naturally without environmental intervention.

Time passed.

The step counter on the terminal beat wildly.

At step 6841, the read/write head turning back to the left crossed the boundary that the certificate claimed would not be revisited, and hit that isolated 1 outside the window.

The local translation structure was immediately destroyed. The machine continued execution along the newly triggered transition and entered a halting state.

And just a few minutes ago, the unified verifier representing the highest review standards had just solemnly accepted a legal certificate proving that this machine would never halt.

Expressionless, Jiang Lin hit Enter, completely reset the test environment, cleared all caches, and ran the entire process again.

The result did not change at all.

The valid green declaration formed an extremely ironic contrast with the final halting fact.

In this vulnerability, the error lay neither in the original decider that mined this machine nor in the dedicated Translated Cycler verifier that diligently performed boundary checks.

It existed entirely and solely within that ambitious unified draft that attempted to accommodate three types of complex mathematical proofs with a concise structure.

The isolation declaration in the original sample was indeed true, but the same declaration in the forged certificate was an utter lie.

The unified verifier read this life-or-death field, yet actively severed the nerve that distinguished truth from falsehood.

A system that attempted to use formal tools to narrow the trusted boundary and eliminate human intervention, at its lowest-level architectural design, instead handed the most core judgment right back to the completely untrusted certificate generation end.

At 10:56 PM.

Jiang Lin did not continue to modify the validation code of the draft.

After confirming the logical fracture in the architecture, patching a few lines of code was completely meaningless.

He saved the maliciously forged failed certificate, the complete execution trajectory of up to 6,841 steps, the acceptance log of the unified verifier after being deceived, as well as the final halting configuration, complete tape snapshot, and execution trajectory, generating an independent isolated reproduction package.

[TC_False_Accept_Case_01]

But this was still far from being an elegant minimal counterexample.

The current test object still retained too many complex transition structures of the original machine, requiring a full six thousand-plus steps to run and a state space expanding to the point of being untraceable by the naked eye before exposing the core conflict.

For researchers who needed to conduct manual logical reviews, such a massive and chaotic test case was no different from searching for clues in a garbage dump, greatly discounting its persuasiveness.

Jiang Lin moved the mouse and changed the status on the task board from [Vulnerability Confirmed] to [Counterexample Compression].

At 11:00, the fixed window closed.

Jiang Lin saved all progress and quietly closed his computer.

On the third night, Jiang Lin still did not touch the third project, Backward Reasoning.

He brought up the incorrectly accepted test object from last night and began the boring yet logically intuitive pruning work.

He needed to delete the machine's redundant state nodes and transition paths one by one without destroying the underlying vulnerability logic.

First, he attempted to compress the five state nodes into four.

He deleted an auxiliary jump state and rerouted the related transition instructions.

Rerunning the unified verifier, it was still deceptively accepted.

Running the simulator, the machine still halted after thousands of steps.

The error path survived.

Next, he targeted a redundant branch in the transition table that would only be triggered during the few dozen steps when the machine had just started and wandered to the left.

With a swift strike, he flattened the branch.

Retesting, the error still existed.

Subsequently, he began to challenge the limits of physical space.

That machine threw the bomb symbol thirty-seven cells away from the main pattern.

This was too far.

Jiang Lin adjusted the writing logic, letting the machine walk just nine cells out, leave that 1 in place, and then immediately turn around to start constructing the forged translation structure.

The unified verifier still turned a blind eye to the hidden dangers beyond nine cells and blindly accepted it.

Meanwhile, the conflict that was originally supposed to wait until the 6,841st step to be exposed was greatly advanced to the 193rd step due to the shortened physical distance.

Jiang Lin looked at the transition table, attempting a final extreme compression.

He tried to delete another state node to turn the machine into a three-state one.

But this time, the rigidity of mathematics manifested.

In the current construction, deleting one more state would make it impossible to simultaneously preserve local translation and delayed revisitation.

Jiang Lin unhesitatingly undid the change and reverted to the previous four-state version.

The compressed sample retained only four states, seven valid transitions, a symbol located nine cells outside the window, and two pseudo-translation configurations separated by 26 steps.

The unified verifier accepted the certificate in less than a second. When the complete simulation ran to the 193rd step, the read-write head touched the symbol outside the window again, and the machine halted immediately.

When placed into the underlying simulator, just as it ran to the 193rd step, the read-write head hit that leftover symbol, and the machine announced a halt.

[TC_False_Accept_Case_01 / COMPRESSED]

[Verifier_Result: ACCEPT]

[Ground_Truth: HALT_AT_193]

[Root_Cause: Unverified_Isolation_Claim (Unverified Isolation Claim)]

Jiang Lin connected the small printer in the dormitory, and accompanied by a slight mechanical whirring sound, printed this complete counterexample that condensed the entire verification vulnerability onto two sheets of A4 paper.

The first sheet was a clean-cut four-state transition table and keyframe diagrams of the tape evolution for the first two hundred steps.

The second sheet was the underlying system call path of the unified verifier, running all the way from reading the malicious certificate and skipping boundary checks to returning the acceptance result.

That night, Jiang Lin did not rush to send out this counterexample, which was sufficient to overturn the existing draft.

He needed to ensure absolute clarity in communication.

Therefore, he condensed the transition table, the error acceptance path, and the root cause explanation based on underlying logic into a single-page review summary containing only core facts using concise language.

On September 4th, at 7:46 PM.

A casual knock came from outside the door.

Jiang Lin glanced at the time, pressed a shortcut key, and the internal certificate draft, reproduction report, and directories with project identifiers were locked simultaneously.

Left on the isolated workstation were only the public decider code, the four-state test machine he had constructed himself, and a set of running results that stripped away all source environment information and purely demonstrated the underlying deduction.

After confirming that there was no longer any sensitive information on the screen, Jiang Lin got up and opened the door.

Zhao Chengyu stood at the very front, carrying cold noodles and crispy pork strips in his hand.

Gu Mingche stood slightly behind, holding a bag of purplish-black grapes with unevaporated water droplets.

Lin Yizhou was holding a box of sliced iced watermelon.

Zhao Chengyu lifted the plastic bag in his hand slightly: "We bumped into each other at Zijinyuan just now, and figured we'd drop by on the way to see if you were around."

This was the first time the three of them had truly stepped into Room 402 since the start of the semester.

Jiang Lin did not say much, turned around to take out three pairs of unopened plastic slippers from the shoe cabinet, tore open the packaging, and then bent over to pull out the folding stools and the cushion on the edge of the bed, clearing enough space to sit down.

Zhao Chengyu quickly occupied the edge of the bed.

Gu Mingche sat on the relatively upright folding stool and placed the grapes in the middle of the table.

Lin Yizhou dragged over another backrest chair, and when he sat down, his position involuntarily moved a little closer to Jiang Lin's glowing workstation.

The rich sauce aroma of the cold noodles and the fried fragrance of the crispy pork strips quickly mixed with the cool sweetness of the watermelon, filled with a lively atmosphere of everyday life.

For the first ten-odd minutes, the few of them ate and chatted, and the topic naturally revolved around the boring military training of the day.

Which instructor timed things exceptionally strictly, which company sang two extra songs during break, whether it would rain tomorrow, and whether the beef noodles on the third floor of Zijinyuan were truly worth lining up for.

Jiang Lin sat back down in front of the workbench, and while listening to them talk, re-ran the four-state test machine.

The materials with internal identifiers were still locked, and what was displayed on the screen were only the public principles and an artificial counterexample that did not correspond to any real undecided machine.

At 7:59, Lin Yizhou was the first to notice the three directories in the terminal.

[Cyclers_Reproduction]

[Translated_Cyclers_Reproduction]

[Backward_Reasoning_Reproduction]

"Busy Beaver problem?" Lin Yizhou pushed his glasses up, a hint of surprise in his voice.

"Mm." Jiang Lin acknowledged.

Lin Yizhou, having received a definite reply, slowed his action of picking up the watermelon by half a beat.

The National Training Team for Informatics Olympiad would not require contestants to find BB(5)—that was unrealistic—but it was enough for him to know the weight of this name.

That was one of the most famous difficult problems on the boundary of computation theory.

Because there did not exist a universal method capable of determining whether all programs halted, researchers could only divide five-state machines into category after category, and then find verifiable exclusion evidence for each category.

The three Reproduction directories on the screen thus no longer looked like test files of ordinary open-source projects.

What Jiang Lin was checking was why millions of decision results deserved to be believed by humans.

Gu Mingche followed Lin Yizhou's gaze and noticed the continuously scrolling tape execution trajectory on the right side of the terminal.

"Are you determining whether this small program will halt?"

"To be more precise, I am reviewing a logical certificate attempting to prove that it will never halt," Jiang Lin explained.

Zhao Chengyu raised his head from the box of cold noodles, glanced from afar at the full screen of 0s, 1s, Ls, and Rs, and said speechlessly, "Can you speak human language? What on earth are this bunch of zeros and ones doing?"

Jiang Lin reached out and pointed to the process on the left side of the screen that was parsing the configuration file.

"Someone submitted a formal proof claiming that this machine will, like a rolling seal, endlessly copy the same pattern to the right on the tape and will never touch the halting state."

Then, his finger moved horizontally, pointing to the complete simulation interface on the right that was crazily increasing its step count.

"The isolated small program on the left is responsible for using a set of established rules to review whether this proof is valid. Meanwhile, the right side starts from an absolutely blank tape, without adding any assumptions, letting this machine truly run step by step."

"So, theoretically, the two sides should arrive at the exact same conclusion?" Zhao Chengyu swallowed his food, grasping the core logic.

"Right." Jiang Lin's answer was crisp and neat.

Explaining to this depth was already sufficient for non-professional listeners.

Zhao Chengyu continued eating his cold noodles, Gu Mingche flipped through the notices just issued by the residential college, and Lin Yizhou occasionally looked up at the machine's continuously climbing running steps on the right side of the screen.

Lin Yizhou was a freshman in the Yao Class this year, and also came from the National Training Team for the Informatics Olympiad.

His knowledge reserve was sufficient for him to understand the structure of the transition table and the current testing framework at a glance.

In his years of informatics competition career, he had also racked his brains countless times to construct various extreme boundary data in order to eliminate algorithms written incorrectly by others.

But cutting-edge theories like Translated Cycler, which involved post-translation configuration repetition and window isolation condition proofs, required what kind of rigorous formal boundary conditions to be established was already beyond the scope of what he could directly judge by intuition.

The only thing he could confirm was that on that terminal interface, every minor change to the test machine, or even just modifying the branch direction of a state, was rigorously marked with an independent version number.

The hash value of the machine description, the memory snapshot of the execution trajectory, the binary comparison results of local patterns, and even the internal status, read-write head position, and tape contents at the exact moment of final halting were all categorized and saved.

This meant that any seemingly accidental result could be re-deduced without the slightest error at any time from that blank tape representing the starting point.

This was standard, defensive engineering verification-level development.

At 8:07.

On the left side of the quietly running screen, the review process finished first, lighting up an eye-catching green result.

[Certificate Valid]

However, the complete simulation on the right side of the screen did not stop because of this, and stubbornly continued to push forward.

Step 190, step 191, step 192, step 193.

The terminal on the right suddenly lagged for a moment, and then popped up a bright red prompt.

[HALT]

Zhao Chengyu abruptly stopped the chopsticks that were about to pick up the last piece of crispy pork strip above the takeout box, his gaze switching back and forth between the left and right windows.

"Wait, didn't the left side just say that the proof is valid and this machine won't halt? How come the right side halted directly?"

"Because this certificate omitted a fatal prerequisite." Jiang Lin's voice lacked the slightest fluctuation, sounding like reading out observation data from a Physics experiment, "It only showed the verifier that neatly translated pattern near the read-write head, but could not logically prove that those old traces it abandoned outside the window would never block its way again in the future."

Gu Mingche put down his phone, looked at the two terminal interfaces that stopped side by side with completely opposite conclusions, and said thoughtfully, "You mean this machine backtracked later?"

"To be precise, at the 193rd step." Jiang Lin brought up the tape snapshot of that moment, "It crossed the physical boundary that the certificate solemnly claimed it would never revisit, and hit a landmine intentionally left outside during early runtime—an isolated number 1, causing the entire translation structure to instantly collapse."

"Was it that the original determination program was written incorrectly?" Gu Mingche pursued.

"The original dedicated decider replays the finite running segment and rechecks the maximum rollback range."

Jiang Lin's fingertips glided across the keyboard, magnifying the two running results and tape snapshots stripped of source information side by side.

"What lacked this security condition was a unified certificate draft that someone later tried to forcibly knead together. This machine should have been rejected, but the new draft opened a backdoor for compatibility, and was fooled by the data I constructed. The original mathematical classification proofs are temporarily unaffected by this counterexample."

Lin Yizhou did not participate in the discussion, his gaze fixed on the version evolution summary in the corner of the screen.

[Initial_Case: 5 States / Halt at 6841]

[Compressed_Case: 4 States / Halt at 193]

"The vulnerability model you originally found had to run all the way to 6,841 steps before exposing the error?" Lin Yizhou spoke suddenly, his voice somewhat low.

"Right."

"And you compressed this counterexample so that it could be exposed in just 193 steps?"

"Only by compressing the states down to four states can two sheets of A4 paper list the complete transition table, key tape snapshots, and error acceptance path." Jiang Lin glanced at those two sheets of paper on the desktop, "Eliminating all interference items, others won't be distracted by redundant logical branches when doing manual reviews."

Lin Yizhou glanced at the four-state transition table printed beside the table.

In informatics competitions, finding a set of data that makes a program answer incorrectly is not the end.

A counterexample that can truly directly pierce the underlying logic should delete all irrelevant structures and let the error point to only one clear boundary condition.

And the machine crafted by Jiang Lin's own hands before him had to meet theoretical requirements far harsher than those in competitions.

It had to exhibit a perfect local pattern translation within an extremely tiny state space, successfully pass the machine hash and execution segment verification through the checker's review, and finally, follow the path missed by the checker with extreme precision, re-encountering the old symbol outside the window at the 193rd step, and entering the halted state along the newly triggered transition.

In this cramped four-state space, if Jiang Lin were to delete even a single extra transition rule, the counterexample would vanish into thin air.

If he deleted one less, the amount of code for manual review would increase exponentially.

To precisely find this breathlessly narrow gap along the deterministic execution trajectory of a Turing machine, while consistently maintaining the disguise of local translation...

This required not only a profound mathematical foundation, but even more so, an emotionless engineering intuition.

Lin Yizhou did not ask any further questions about the details of Translated Cycler.

Because he knew that this cold four-state machine before him was itself the most efficient and oppressive answer.

Gu Mingche looked at Jiang Lin's back and asked, "So, you've been doing this these past few days?"

Jiang Lin nodded. "The first type of cycle has already been reproduced, the unified certificate layer of the second type is stuck in its workflow because of this counterexample, and as for the third type of backward reasoning, the environment hasn't been set up yet and we haven't started."

The technical details Gu Mingche could understand were limited, but he understood the weight between the three states.

One had completed independent reproduction, one was blocked by Jiang Lin with a counterexample, and the remaining one was still awaiting processing.

To them, the Busy Beaver was still a distant and famous problem in computational theory; in Jiang Lin's hands, it had been broken down into specific work items that could be numbered, reproduced, vetoed, and pushed forward.

What concerned Gu Mingche even more was that when Jiang Lin talked about that erroneous certificate, there was no excitement in his tone after finding a major loophole.

First, he drew a clear line that the original decider was unaffected, and then explained that it was only the unified certificate layer that had a problem.

Being able to suppress the boundaries of the conclusion after finding the error was, in itself, harder than the [ HALT ] on the screen.

Zhao Chengyu lowered his head to look at the half-box of roasted cold noodles in front of him, then looked up again at the glaring [ HALT ] on the expensive workstation screen.

A subtle sense of absurdity surged into his heart.

The three of them had only come over to visit tonight because they were utterly bored after just going through grueling military training, bringing fruit and late-night snacks, chatting about trivial gossip like which instructor was stricter or whose auntie at the cafeteria window had a less shaky hand.

However, less than two meters away from the cheap plastic takeout box in his hand, a cutting-edge technological roadmap attempting to unify three types of complex non-halting proofs in the mathematical world had been abruptly halted mid-air by the crude little program on the screen that had just run 193 steps.

Anyone could understand the contradictory results representing validity and halting on the screen.

But as to why this contradiction held true in deeper formal proofs, how far the impact scope of this vulnerability should be drawn, and how Tsinghua University's team should reconstruct their next-generation system verification architecture, these were still not questions that the three of them, who had just put on camouflage uniforms as freshmen, could take over and discuss.

At seven minutes past nine, a few of them began to pack up the table with dwindling interest.

The emptied paper boxes were neatly packed back into plastic bags and tied with dead knots, the remaining grapes and watermelon were recovered with plastic wrap and put into the refrigerator, and the emptied drink bottles were placed together in the trash can behind the door.

When Zhao Chengyu was changing back into his shoes, he couldn't help turning back to glance at the black-and-white terminal screen once more: "Seriously, I originally just planned to drop by for a visit and chat. How did I manage to run into the halting problem just in the span of eating a meal of roasted cold noodles?"

"It's the safety verification problem for non-halting proofs." Lin Yizhou rigorously corrected his phrasing from the side.

Zhao Chengyu waved his hand and pushed open the door: "Fine, fine. He's already created Jiangs Brick and solved the PFR Conjecture this year; solving another safety verification problem for non-halting proofs is also entirely logical."

The three of them filed out and left 402.

The door clicked shut.

Silence returned to the dorm, with only the greasy smell of crispy pork and the sweet aroma of watermelon lingering in the air, proving that a few young people carrying the vibrant breath of college students had just been here.

Jiang Lin sat back down at the workstation and pressed the unlock shortcut key.

The internal certificate draft and the multi-page complete reproduction report unfolded across the screen once more.

The small talk was over.

Now, the technical boundaries that truly needed to be written in black and white into the formal report were ruthlessly spread out again under the shadowless lamp.

The proof logic of Cycler was extremely simple, submitting only two identical global machine configurations and a deterministic forward execution segment connecting these two configurations.

The logic of Translated Cycler experienced a leap; in addition to proving that local patterns translated, it also had to use a robust logical shell to prove that unknown content outside the window would never re-enter the evolutionary region like a ghost.

As for Backward Reasoning, which had not yet begun reproduction, its mathematical logic was even more obscure.

What it submitted was no longer forward evolution, but rather, through backtracking, proving that a specific set of states was an unreachable backward island, or providing a finite witness capable of proving that this island was completely closed.

The three types of evidence could share the machine description, blank tape initial conditions, and single-step transition semantics, or be packed into the same outer certificate container.

What truly could not be forcibly merged were their respective unique witness structures and verification rules.

Cycler needed to replay the execution segment between complete configurations; Translated Cycler needed to additionally check the translation window and maximum rollback range; Backward Reasoning needed to verify the closure conditions of the backward unreachable set.

The problem with the current draft was precisely that it compressed these different proof obligations into several boolean fields filled out by the certificate generator itself.

Jiang Lin crossed out the original target at the top of the interface draft.

[ Objective: Unify the data structures of the three types of non-halting certificates. ]

Changed to—

[ Objective: Unify machine semantics and trusted kernel boundaries; allow different proof rules to submit their respective witness structures. ]

The common parts were temporarily kept as five items.

[ Machine Description Hash ]

[ Blank Tape Initial Conditions ]

[ Single-Step Transition Semantics ]

[ Certificate Type Tag and Verification Rule Dispatch ]

[ Verification Results, Failure Steps, and Reproduction Trajectory ]

This adjustment did not negate the feasibility of a shared verification kernel.

What needed to be stopped was the route of letting the current unified certificate draft directly shoulder the final adjudication.

If the old draft continued to be used, even if all subsequent test cases showed green, it could not be ruled out that the checker simply trusted the erroneous claims filled out by the certificate generator itself.

At ten-twenty-four, Jiang Lin typed the final period on his keyboard, completing the first formal return material targeting the draft.

The attachment files were very restrained, consisting of only four pages.

[ Page 1: The extremely reduced four-state counterexample transition table ]

[ Page 2: Raw data of the pseudo-translation certificate generated using the vulnerability ]

[ Page 3: Underlying call path tracing of erroneous acceptance by the unified checker due to failure to execute direction checks ]

[ Page 4: Underlying architecture modification suggestions and system security impact boundaries ]

The part regarding the impact boundaries was separately highlighted by him in bold text.

[ This counterexample only targets the architectural security of the unified draft. It does not affect the judgment results of machines already independently completed by the original dedicated deciders of normal Cycler, Translated Cycler, and Backward Reasoning. ]

[ This counterexample only targets the unified certificate draft and does not affect the three types of original dedicated deciders and their existing classification results. ]

[ Before window isolation witnesses, complete mathematical support, or logically equivalent alternative conditions are formally written into the trusted kernel code, the use of this draft to generate any binding formal conclusions is strictly prohibited. ]

Jiang Lin did not attach a seemingly complete and flawless brand-new scheme at the end of the email.

Because he was a pure technical realist.

The backward unreachability logic of the third item, Backward Reasoning, had not yet begun reproduction. Whether this reconstructed unified trusted kernel could safely accommodate that bizarre backward proof structure had not yet undergone any real-world testing with dirty data.

If at this moment, lacking a verification closed-loop, one rashly submitted a so-called new architecture designed purely based on imagination, it would simply be replacing one bottom-broken black box with another unverified black box.

On the very last page of the document, he only drew a crude yet clearly bounded next-stage topology sketch using a code block.

[ Shared Kernel ]

[ ── Machine Semantics ]

[ ── Exact Cycle Rule ]

[ ── Translated Cycle Rule - Requires additional isolation verification ]

[ ── Backward Unreachability Rule - Pending ]

[ ── Failure Trace ]

At ten-thirty-one, this email containing the counterexample was formally forwarded back to Tsinghua University via the Research Support Unit.

On September 5th at 9:17 AM, the opposing team completed the independent reproduction of this four-state counterexample on their servers.

The reply still entered the Research Support Unit on the third floor first.

The technical liaison quickly checked the attachments and the four pages of glaring impact notes, immediately marked the email's priority as red, labeled it with [ A-1 / Direct Feedback on Original Issue ], and quietly placed it into Jiang Lin's mailbox, waiting for tonight's window period to open.

At 8:00 PM, Jiang Lin, who had just returned from the playground carrying a body full of exhaustion, clicked open the reply.

...

[ The counterexample has been successfully reproduced by our independent sandbox. ]

[ Test records show that the unified checker experienced a severe erroneous acceptance on this malicious sample, and the complete simulation test halted at the 193rd step. ]

[ Root cause fully confirmed: The underlying architecture of the unified draft has a trust vulnerability, erroneously trusting the unprotected Isolated_Window field. The core directional boundary checking algorithm in the original dedicated Translated Cycler decider was not effectively migrated during the integration process. ]

[ Disposal plan: The current version of the unified draft has been urgently withdrawn from the internal repository. The operation of the three types of original deciders is not affected, and the existing Turing machine classification results remain safe. ]

Following the rigorous technical confirmation, a carefully worded new request appeared at the end of the email.

[ After urgent discussion within the group, if you successfully complete the reproduction and stress testing of Backward Reasoning in your subsequent schedule, we hope to invite you to continue deeply participating in and reviewing the new trusted kernel scheme—which reconstructs shared machine semantics and separates proof rules based on your suggestions. ]

...

After reading it, Jiang Lin archived this confirmation email into the local project log of BB(5).

The status dashboard on the right subsequently underwent a major change.

[ Cyclers_Reproduction / PASS ]

[ Translated_Cyclers_Reproduction / CERTIFICATE_LAYER_BLOCKED ]

[ Backward_Reasoning_Reproduction / PENDING ]

[ Unified_Certificate_Schema / WITHDRAWN ]

[ Shared_Verification_Kernel / FEASIBILITY_RETAINED ]

In the upper right corner of the screen, the total value representing the exploration progress of BB(5) did not change.

Nor was there an extra reclassified machine in the database.

But in the Busy Beaver problem, progress never meant simply eliminating one more machine.

The final answer was built upon a long chain of elimination.

Every machine judged to never halt had to have reasons that could withstand independent review.

As long as any checker erroneously accepted a certificate once, it lost the qualification to continue guaranteeing other conclusions. Every result cleared by it thereafter had to be re-examined.

The four-state counterexample constructed by Jiang Lin took less than a second to run the first time.

It did not change the resolved quantity of BB(5), but it turned a unified draft preparing to shoulder the ultimate verification responsibility from [ Candidate ] to [ Withdrawn ].

The other party had to stop the original route, re-divide the trusted kernel, and truly write the obligations that window isolation, maximum rollback range, and different proof rules needed to shoulder into code that could be independently inspected.

If this vulnerability had been discovered later, the formal results generated through the unified draft in the future might all have been built upon an unverified statement that the window had been isolated.

By then, what needed to be overthrown and re-checked would no longer be a four-page report, but potentially an entire proof chain that had already extended outward.

From this night onward, anyone wanting to send a machine into the set proven never to halt could no longer hand over a mere statement.

He had to bring evidence.

It could be said that although Jiang Lin did not add a resolved machine for BB(5), he guarded the door for that final answer—the door requiring that it must be true.