Re: How the requirements that Professor Sipser agreed to are exactly met --- WDH

On 5/13/25 9:27 PM, olcott wrote:

On 5/13/2025 8:07 PM, dbush wrote:

On 5/13/2025 5:30 PM, olcott wrote:

On 5/13/2025 6:43 AM, Richard Damon wrote:

On 5/13/25 12:52 AM, olcott wrote:

On 5/12/2025 11:05 PM, Richard Damon wrote:

On 5/12/25 10:53 PM, olcott wrote:

On 5/12/2025 8:27 PM, Richard Damon wrote:

On 5/12/25 2:17 PM, olcott wrote:

Introduction to the Theory of Computation 3rd Edition
by Michael Sipser (Author)
4.4 out of 5 stars    568 rating
>
https://www.amazon.com/Introduction-Theory-Computation-Michael- Sipser/ dp/113318779X
>
int DD()
  {
   int Halt_Status = HHH(DD);
   if (Halt_Status)
     HERE: goto HERE;
   return Halt_Status;
  }
>
DD correctly simulated by any pure simulator
named HHH cannot possibly terminate thus proving
that this criteria has been met:
>
<MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>
     If simulating halt decider H correctly simulates its
     input D until H correctly determines that its simulated D
     would never stop running unless aborted then
>
     H can abort its simulation of D and correctly report that D
     specifies a non-halting sequence of configurations.
  </MIT Professor Sipser agreed to ONLY these verbatim words 10/13/2022>
>

>
Which your H doesn't do, as it can not correctly determine what doesn't happen.
>

>
Any C programmer can correctly tell what doesn't happen.
What doesn't happen is DD reaching its "return" statement
final halt state.
>

>
Sure they can, since that is the truth, as explained.
>
Since your "logic" is based on lies and equivocation,

>
If my logic was based on lies and equivocation
then you could provide actual reasoning that
corrects my errors.

>
I hae.
>

>
It is truism that simulating termination analyzers
must report on the behavior of their input as if
they themselves never aborted this simulation:

>
Right, of the input actually given to them, which must include all their code, and that code is what is actually there, not created by this imaginary operation.
>

>
In other words every single byte of HHH and DD are
100% totally identical except the hypothetical HHH
has its abort code commented out.

>
In other words you changed the input.
>
Changing the input is not allowed.
>

  

>

Thus, a HHH that aborts to return an answer, when looking at the DDD that calls it, must look at the unaborted emulation of THAT DDD, that calls the HHH that DOES abort and return an answer, as that is what the PROGRAM DDD is, If you can not create the HHH that does that without changing that input, that is a flaw in your system, not the problem.
>

>
*simulated D would never stop running unless aborted*
or they themselves could become non-terminating.

>
But you aren't simulating the same PROGRAM D that the original was given.
>

>
It is not supposed to be the same program.

>
So you *explicitly* admit to changing the input.
>

 The finite string of DD is specific sequence bytes.
The finite string of HHH is specific sequence bytes.

Neither of which are a "Program" per your stipulation.

 The hypothetical HHH that does not abort its input
cannot have input that has changed because it never
comes into actual existence.

And thus can't actually DO anything. This seems par for your logic, you talk about things that aren't (and can't be) as if they are.

 *simulated D would never stop running unless aborted*

It can't start running, as it isn't a program. You are just making a category error.

 

This proves your work has nothing to do with the halting problem.
>

 When ZFC over-ruled naive set theory this caused
Russell's Paradox to cease to exist.

It did no such thing. Naive Set Theory still exists, as some people still (try) to use it. It just breaks their logic.
If you want to define a new POOPS system, go ahead and try, and see if people prefer yours to the standard. The problem will be since there isn't actually anything wrong with the standard system, you need to show some great advantage in yours.

 

If you were just honest about the fact that you're not actually working on the halting problem, no one would be giving you any trouble.

 Equally we could say that ZFC was not working
on the actual Russell's Paradox.

Of course they weren't, they were developing a Set Theory that couldn't sucomb to a problem like that.

 What I am doing is the same thing that ZFC did.

No, you are not, as you haven't laid out an actual new system.

 ZFC did not figure out how to correctly define
a set of all sets that do not contain themselves.

Right, becuase they created a system where the question wasn't able to be formed.

 Instead ZFC rejected the foundation upon which
RP was built. That is what I am doing.
 

No, because you are not creating a new foudation like ZFC did.
Note, they didn't just say that in Naive Set Theory you just can't do this one operation, which was fundamental to how the system was designed, they built a TOTALLY NEW system from the ground up, based on a precise set of axioms, that built a NEW system which did everything that people normally wanted, but in which you couldn't form the set that the Russell's paradox.
For you to do something like that, you need to start at a new axiomization of computing, to define how you build "programs" in your POOPS, that is both powerful enough to be interesting, but also doesn't allow the formation of the problem you want to solve.
The issue is that because of its nature, your system is going to need to not be Turing Complete, and thus significantly weaker than the current Theory, and thus you will need to show some very significant advantage over classical thoery.
The ability to define uncomputable Functions, or the inability to know if a given program / input will halt is NOT that big of a disadvante to most people.