*keeps repeating unless aborted*
Line 03: simulated DD() invokes simulated HHH(DD) that simulates DD()
*Simulation invariant*
DD correctly simulated by HHH cannot possibly reach its
simulated final state.
Your own answer to A or B:
On 10/9/2026 6:53 AM, Python wrote:
You have established that correct application of the C operational
semantics within HHH produces the recursively simulated sequence:
-a-a-a HHH simulates DD
-a-a-a-a-a-a-a -> DD calls HHH(DD)
-a-a-a-a-a-a-a-a-a-a-a -> HHH simulates DD
-a-a-a-a-a-a-a-a-a-a-a-a-a-a-a -> ...
Agreed.
Peter, I understand perfectly well what I agreed to.
I agreed that IF HHH keeps recursively simulating the HHH call
encountered at DD line 03, then we obtain:
-a-a HHH -> DD -> HHH -> DD -> ...
and that recursive simulation does not naturally return.
I have agreed to that approximately seventeen fucking times now.
What I did NOT agree to is your next inference:
-a-a therefore the finite source-code DD specifies
-a-a a computation that does not halt.
Those are not the same proposition.
And your own words expose the exact problem:
keeps repeating unless aborted
UNLESS ABORTED.
There it is.
That is the entire fucking issue.
You claim that HHH detects this recursion, ABORTS the simulation, and returns 0.
Fine.
Then tell me what happens to the HHH call at line 03 of the DD being simulated.
There are only two possibilities.--
FIRST:
The simulated call
-a-a HHH(DD)
at DD line 03 returns the 0 that you claim HHH returns.
Then the C operational semantics are embarrassingly simple:
-a-a 03-a-a int Halt_Status = HHH(DD);
gives:
-a-a Halt_Status = 0
then:
-a-a 04-a-a if (Halt_Status)
is false, so line 05 is skipped, and:
-a-a 06-a-a return Halt_Status;
is reached.
DD HALTS.
SECOND:
The simulated call to HHH at line 03 does NOT return 0 because you
continue recursively simulating:
-a-a HHH -> DD -> HHH -> DD -> ...
Fine.
Then your simulation never produces the alleged 0 for that call.
In that case you have not shown that HHH returns 0 there.
You have shown that YOUR METHOD FOR COMPUTING HHH'S ANSWER DOES NOT TERMINATE.
That is the dilemma you have been running away from for weeks.
And no, my October 9 statement does not answer it for you.
Read it:
correct application of the C operational
semantics within HHH produces the recursively simulated sequence
Yes.
THE RECURSIVELY SIMULATED SEQUENCE.
I agreed about the behavior of your recursive simulation.
I did NOT say:
-a-a therefore DD does not halt.
In fact, a few days ago when I explicitly pointed this out, you answered:
Of course it does not say this.
Remember?
So please stop pretending that my October 9 statement contains words
that YOU HAVE ALREADY ADMITTED IT DOES NOT CONTAIN.
Your latest post actually makes the defect beautifully explicit:
-a-a "keeps repeating unless aborted"
If it is NOT aborted:
-a-a HHH does not finish deciding DD.
If it IS aborted and 0 is returned to the simulated DD:
-a-a DD reaches line 06 and halts.
Pick your poison.
You do not get a magical third option in which:
-a-a HHH aborts and returns 0
but simultaneously:
-a-a the DD waiting for that return at line 03
-a-a never receives the 0
while you still call the whole thing a correct simulation according to
the C operational semantics.
That is not C semantics.
That is sleight of hand.
You are using the non-return of HHH to prove that DD cannot get past
line 03, while simultaneously using the return of HHH to claim that HHH
is a terminating decider.
You need HHH NOT TO RETURN to prove your conclusion about DD.
You need HHH TO RETURN to call HHH a decider.
You cannot have both.
And THAT -- not some "mental block" of mine -- is the contradiction you
keep hiding behind the word "aborted."
| Sysop: | Amessyroom |
|---|---|
| Location: | Fayetteville, NC |
| Users: | 76 |
| Nodes: | 6 (0 / 6) |
| Uptime: | 54:21:25 |
| Calls: | 1,265 |
| Calls today: | 1 |
| Files: | 1,362 |
| D/L today: |
3 files (2,684K bytes) |
| Messages: | 285,563 |