On 3/19/2024 4:37 AM, Mikko wrote:
> On 2024-03-18 23:05:33 +0000, olcott said:
>
>> On 3/18/2024 6:43 AM, Mikko wrote:
>>> On 2024-03-17 23:47:01 +0000, olcott said:
>>>
>>>> On 3/17/2024 2:45 PM, Richard Damon wrote:
>>>>> On 3/17/24 9:31 AM, olcott wrote:
>>>>>> On 3/17/2024 11:13 AM, Mikko wrote:
>>>>>>> On 2024-03-17 13:52:31 +0000, olcott said:
>>>>>>>
>>>>>>>> On 3/17/2024 8:46 AM, Mikko wrote:
>>>>>>>>> On 2024-03-16 15:18:33 +0000, olcott said:
>>>>>>>>>
>>>>>>>>>> On 3/16/2024 3:19 AM, Mikko wrote:
>>>>>>>>>>> On 2024-03-15 16:20:35 +0000, olcott said:
>>>>>>>>>>>
>>>>>>>>>>>> Best selling author of Theory of Computation textbooks:
>>>>>>>>>>>> *Introduction To The Theory Of Computation 3RD, by sipser*
>>>>>>>>>>>> https://www.amazon.com/Introduction-Theory-Computation-Sipser/dp/8131525295/
>>>>>>>>>>>>
>>>>>>>>>>>> Date 10/13/2022 11:29:23 AM
>>>>>>>>>>>> *MIT Professor Michael Sipser agreed this verbatim paragraph
>>>>>>>>>>>> is correct*
>>>>>>>>>>>> (He has neither reviewed nor agreed to anything else in this
>>>>>>>>>>>> paper)
>>>>>>>>>>>> (a) 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
>>>>>>>>>>>> (b) H can abort its simulation of D and correctly report
>>>>>>>>>>>> that D specifies a non-halting sequence of configurations.
>>>>>>>>>>>>
>>>>>>>>>>>> *When we apply the abort criteria* (elaborated above)
>>>>>>>>>>>> Will you halt if you never abort your simulation?
>>>>>>>>>>>> *Then H(D,D) is proven to meet this criteria*
>>>>>>>>>>>>
>>>>>>>>>>>> *Proof that H(D,D) meets its abort criteria*
>>>>>>>>>>>>
>>>>>>>>>>>> int D(int (*x)())
>>>>>>>>>>>> {
>>>>>>>>>>>>    int Halt_Status = H(x, x);
>>>>>>>>>>>>    if (Halt_Status)
>>>>>>>>>>>>      HERE: goto HERE;
>>>>>>>>>>>>    return Halt_Status;
>>>>>>>>>>>> }
>>>>>>>>>>>>
>>>>>>>>>>>> int main()
>>>>>>>>>>>> {
>>>>>>>>>>>>    Output("Input_Halts = ", H(D,D));
>>>>>>>>>>>> }
>>>>>>>>>>>>
>>>>>>>>>>>>   machine   stack     stack     machine    assembly
>>>>>>>>>>>>   address   address   data      code       language
>>>>>>>>>>>>   ========  ========  ========  =========  =============
>>>>>>>>>>>> [00001d22][00102fc9][00000000] 55         push ebp      ;
>>>>>>>>>>>> begin main()
>>>>>>>>>>>> [00001d23][00102fc9][00000000] 8bec       mov ebp,esp
>>>>>>>>>>>> [00001d25][00102fc5][00001cf2] 68f21c0000 push 00001cf2 ;
>>>>>>>>>>>> push DD
>>>>>>>>>>>> [00001d2a][00102fc1][00001cf2] 68f21c0000 push 00001cf2 ;
>>>>>>>>>>>> push D
>>>>>>>>>>>> [00001d2f][00102fbd][00001d34] e8eef7ffff call 00001522 ;
>>>>>>>>>>>> call H(D,D)
>>>>>>>>>>>>
>>>>>>>>>>>> H: Begin Simulation   Execution Trace Stored at:113075
>>>>>>>>>>>> Address_of_H:1522
>>>>>>>>>>>> [00001cf2][00113061][00113065] 55         push ebp       ;
>>>>>>>>>>>> enter D(D)
>>>>>>>>>>>> [00001cf3][00113061][00113065] 8bec       mov ebp,esp
>>>>>>>>>>>> [00001cf5][0011305d][00103031] 51         push ecx
>>>>>>>>>>>> [00001cf6][0011305d][00103031] 8b4508     mov eax,[ebp+08]
>>>>>>>>>>>> [00001cf9][00113059][00001cf2] 50         push eax       ;
>>>>>>>>>>>> push D
>>>>>>>>>>>> [00001cfa][00113059][00001cf2] 8b4d08     mov ecx,[ebp+08]
>>>>>>>>>>>> [00001cfd][00113055][00001cf2] 51         push ecx       ;
>>>>>>>>>>>> push D
>>>>>>>>>>>> [00001cfe][00113051][00001d03] e81ff8ffff call 00001522  ;
>>>>>>>>>>>> call H(D,D)
>>>>>>>>>>>> H: Recursive Simulation Detected Simulation Stopped
>>>>>>>>>>>>                            H(D,D) returns 0 to main()
>>>>>>>>>>>>
>>>>>>>>>>>> *That was proof that H(D,D) meets its abort criteria*
>>>>>>>>>>>> H(D,D) correctly determines that itself is being called with
>>>>>>>>>>>> its same inputs and there are no conditional branch
>>>>>>>>>>>> instructions between the invocation of D(D) and its call to
>>>>>>>>>>>> H(D,D).
>>>>>>>>>>>
>>>>>>>>>>> This proof is not simpler or more convinceing than earlier
>>>>>>>>>>> proofs of
>>>>>>>>>>> the same.
>>>>>>>>>>>
>>>>>>>>>>> It is also as uninteresting as the proved claim. As long as H
>>>>>>>>>>> does
>>>>>>>>>>> not meet the specification of halting decider it does not matter
>>>>>>>>>>> what it meets instead.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> The original halt status criteria has the impossible requirement
>>>>>>>>>> that H(D,D) must report on behavior that it does not actually
>>>>>>>>>> see.
>>>>>>>>>
>>>>>>>>> The requirement is not specifically about behaviour that the
>>>>>>>>> decider
>>>>>>>>> does not actually see but requires reporting anyway, whether the
>>>>>>>>> decider sees or not. So it turns out that it is not possible to
>>>>>>>>> meet the specification in all cases.
>>>>>>>>>
>>>>>>>> I think that the decider can meet its abort criteria in all cases.
>>>>>>>
>>>>>>> But cannot meet its specification.
>>>>>>>
>>>>>>
>>>>>> First we must come to mutual agreement that H(D,D) is correct
>>>>>> to abort its simulation.
>>>>>
>>>>> Which means we need to first come to an aggreement of what that means.
>>>>>
>>>>> You DID agree earlier to this:
>>>>>
>>>>> On 3/17/24 6:11 AM, olcott wrote:
>>>>>> On 3/17/2024 12:22 AM, Richard Damon wrote:
>>>>>>> To me, for H to NEED to abort its simulation, that means that when
>>>>>>> giving the input to a correct simulator, that simulator will not
>>>>>>> halt.
>>>>>>>
>>>>>> Yes that is correct.
>>>>>>
>>>>>
>>>>
>>>> For every possible way that H can be encoded and D(D)
>>>> calls H(D,D) either H(D,D) aborts its simulation or D(D)
>>>> never stops running.
>>>
>>> That is ambiguous: does D(D) call H(D,D) if H is encoded in another way
>>> than the one that D(D) calls?
>>>
>>
>> I have no idea what you are meaning.
>> It is assumed that H and D are C functions.
>
> What exacly you don't understand? Do you understand the following
> phrases:
>
> - "every possibe way that H can be encoded" ?
>
> - "D(D) calls H(D,D)" ?
>
> - "the H(D,D) that D(D) calls" ?
>
> - "H(D,D) aborts its simulation"
>
> Unless you can answer I can only assume that you are too stupid
> for this discussion.
>

On 3/19/2024 4:24 AM, Mikko wrote:
> On 2024-03-19 04:37:02 +0000, olcott said:
>
>> On 3/18/2024 11:23 PM, Richard Damon wrote:
>>> On 3/18/24 8:53 PM, olcott wrote:
>>>> On 3/18/2024 9:44 PM, Richard Damon wrote:
>>>>> On 3/18/24 2:48 PM, olcott wrote:
>>>>>> On 3/18/2024 4:38 PM, Fred. Zwarts wrote:
>>>>>>> Op 18.mrt.2024 om 22:18 schreef olcott:
>>>>>>>> On 3/18/2024 4:11 PM, Fred. Zwarts wrote:
>>>>>>>>> Op 18.mrt.2024 om 21:40 schreef olcott:
>>>>>>>>>> On 3/18/2024 3:30 PM, immibis wrote:
>>>>>>>>>>> On 18/03/24 21:20, olcott wrote:
>>>>>>>>>>>> On 3/18/2024 2:44 PM, Fred. Zwarts wrote:
>>>>>>>>>>>>> Op 18.mrt.2024 om 18:43 schreef olcott:
>>>>>>>>>>>>>> On 3/18/2024 10:11 AM, Fred. Zwarts wrote:
>>>>>>>>>>>>>>> Op 18.mrt.2024 om 15:44 schreef olcott:
>>>>>>>>>>>>>>>> On 3/18/2024 1:04 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>> On 3/17/24 10:22 PM, olcott wrote:
>>>>>>>>>>>>>>>>>> On 3/18/2024 12:11 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>> On 3/17/24 9:42 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>> On 3/17/2024 11:39 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>> On 3/17/24 9:00 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>> On 3/17/2024 10:32 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>> On 3/17/24 8:14 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>> On 3/17/2024 9:35 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>> On 3/17/24 4:27 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/17/2024 12:37 PM, immibis wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>> On 17/03/24 14:11, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/17/2024 12:22 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/16/24 10:04 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/17/2024 12:00 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/16/24 9:42 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/16/2024 11:28 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/16/24 9:13 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/16/2024 10:57 PM, Richard Damon
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/16/24 7:52 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/16/2024 9:43 PM, Richard Damon
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/16/24 5:50 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/16/2024 7:21 PM, Richard
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/16/24 8:29 AM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/15/2024 11:29 PM, Richard
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/15/24 8:45 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H(D,D) fails to make the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> required mistake of reporting
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> on what it does not see.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> But it DOES make a mistake,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> because it does answer the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> question correctly.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> You are just PROVING you think
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> lying is ok.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> You TOTALLY don't understand
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the meaning of truth.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> You are REALLY just a
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Pathological Liar, as you have
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> no concept of real truth,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> The original halt status
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> criteria has the impossible
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> requirement
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that H(D,D) must report on
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> behavior that it does not
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> actually see.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Requiring H to be clairvoyant is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> an unreasonable requirement.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> *The criteria shown below
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> eliminate the requirement of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> clairvoyance*
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (a) 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 correctly simulates its input
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> D until*
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Means H does a correct partial
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation of D until H correctly
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> matches the recursive simulation
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> non-halting behavior pattern.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> But turning out to be impposible,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> doesn't make it incorrect or
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> invalid.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> *You seems to be ridiculously
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> disingenuous about the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> self-evident truth*
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> For every possible way that H can
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> be encoded and D(D) calls H(D,D)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> either H(D,D) aborts its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation or D(D) never stops
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> running.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> And you are incredably stupid to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> not see this doesn't prove what you
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> need it to.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Yes, if you define H to not abort,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the we get a non-haltig D(D), but H
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> doesn't answwer.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> But, if you define H to abort, then,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> We see that you changed the subject
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> away from:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [Proof that H(D,D) meets its abort
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> criteria]
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Nope.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H is an algorithm that simulates its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> input and correctly
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> determines whether or not it needs to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> abort this simulation.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> That is all that this thread's H does.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> And what defines "Need"?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> It is the set of every implementation of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> its spec:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (a) H(D,D) Simulate input.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (b) Determine if it needs to stop
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulating its input to prevent
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the simulated D(D) from never halting.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> And thus not a specific algorithm?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Again, HOW do you determine NEED?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> That is not an algorithmic step.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> We can only verify that in retrospect.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Do you fully understand the spec?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Yes, but I think not the way you do.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> To me, for H to NEED to abort its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation, that means that when giving the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> input to a correct simulator, that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulator will not halt.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> Yes that is correct.
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> You have just proven that H doesn't need
>>>>>>>>>>>>>>>>>>>>>>>>>>> abort its simulation and the abort decision
>>>>>>>>>>>>>>>>>>>>>>>>>>> is incorrect.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> The head games of a Troll.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> For every possible way that H can be encoded
>>>>>>>>>>>>>>>>>>>>>>>>>> and D(D)
>>>>>>>>>>>>>>>>>>>>>>>>>> calls H(D,D) either H(D,D) aborts its
>>>>>>>>>>>>>>>>>>>>>>>>>> simulation or D(D)
>>>>>>>>>>>>>>>>>>>>>>>>>> never stops running.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> Which prove NOTHING, as D varies with H, so no
>>>>>>>>>>>>>>>>>>>>>>>>> D that was built with an H that aborts its
>>>>>>>>>>>>>>>>>>>>>>>>> simulation has had its actual halting status
>>>>>>>>>>>>>>>>>>>>>>>>> tested.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> *That merely changes the wording of the same
>>>>>>>>>>>>>>>>>>>>>>>> truism*
>>>>>>>>>>>>>>>>>>>>>>>> ∀H ∈ TM ∀D ∈ TMD such that
>>>>>>>>>>>>>>>>>>>>>>>> H(D,D) simulates its input and
>>>>>>>>>>>>>>>>>>>>>>>> D calls H(D,D) and
>>>>>>>>>>>>>>>>>>>>>>>> H(D,D) does not abort its simulation
>>>>>>>>>>>>>>>>>>>>>>>> necessitates simulated D(D) never stops running.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> Third times and still not a charm.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> All those D still use an H that doesn't abort
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> *You keep talking in circles, there are only two
>>>>>>>>>>>>>>>>>>>>>> sets*
>>>>>>>>>>>>>>>>>>>>>> ∀H ∈ TM ∀D ∈ TMD | (H(D,D) simulates its input and
>>>>>>>>>>>>>>>>>>>>>> D calls H(D,D))
>>>>>>>>>>>>>>>>>>>>>> (1) H(D,D) does not abort its simulation then
>>>>>>>>>>>>>>>>>>>>>> simulated D(D) never stops running.
>>>>>>>>>>>>>>>>>>>>>> (2) H(D,D) aborts its simulation then simulated
>>>>>>>>>>>>>>>>>>>>>> D(D) stops running.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> And your top line says NOTHING about the Ds in set
>>>>>>>>>>>>>>>>>>>>> (2), since nothing showed them not to run
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> but your (2) admitts that D(D) will stop running,
>>>>>>>>>>>>>>>>>>>>> and thus the top level H didn't need to abort its
>>>>>>>>>>>>>>>>>>>>> simulation.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> Do you understand that each H(D,D) must either abort
>>>>>>>>>>>>>>>>>>>> or fail to abort?
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> And do you understand
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Yes that is what I am asking. It seems that you don't
>>>>>>>>>>>>>>>>>> understand
>>>>>>>>>>>>>>>>>> the difference between X being a member of a set and X
>>>>>>>>>>>>>>>>>> not being
>>>>>>>>>>>>>>>>>> a member of a set. Very elemental set theory.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> And you seem to be trying to convientely forget that
>>>>>>>>>>>>>>>>> each D that you talk about is DIFFERENT, base on the H
>>>>>>>>>>>>>>>>> that it was designed to confound.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> *You keep talking in circles, there are only two sets*
>>>>>>>>>>>>>>>> ∀H ∈ TM ∀D ∈ TMD | (H(D,D) simulates its input and D
>>>>>>>>>>>>>>>> calls H(D,D))
>>>>>>>>>>>>>>>> (1) H(D,D) does not abort its simulation then simulated
>>>>>>>>>>>>>>>> D(D) never stops running.
>>>>>>>>>>>>>>>> (2) H(D,D) aborts its simulation then simulated D(D)
>>>>>>>>>>>>>>>> stops running.
>>>>>>>>>>>>>>>> *By whatever means H(D,D) places itself in (2) then
>>>>>>>>>>>>>>>> H(D,D) is correct*
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> By repeating yourself, you run in circles.
>>>>>>>>>>>>>>> There are three possible categories of H functions:
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> 1. Hah, It aborts and reports halting.
>>>>>>>>>>>>>>> 2. Han, It aborts and repeats non halting.
>>>>>>>>>>>>>>> 3. Hss does not abort, but simply simulates.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> What H(D,D) reports is off-topic for this post.
>>>>>>>>>>>>>> *We are only looking at this*
>>>>>>>>>>>>>> [Proof that H(D,D) meets its abort criteria --self-evident
>>>>>>>>>>>>>> truth--]
>>>>>>>>>>>>>> *Thus H(D,D) aborts or H(D,D) fails to abort*
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> Be clear in the naming. Is it Dan that is considered, or
>>>>>>>>>>>>> Dss? Dss must be aborted, because is does not halt, but Dan
>>>>>>>>>>>>> does halt and does not need to be aborted.
>>>>>>>>>>>>
>>>>>>>>>>>> *There are only two sets*
>>>>>>>>>>>> ∀H ∈ TM ∀D ∈ TMD | (H(D,D) simulates its input and D calls
>>>>>>>>>>>> H(D,D))
>>>>>>>>>>>> (1) H(D,D) does not abort its simulation then simulated D(D)
>>>>>>>>>>>> never stops running.
>>>>>>>>>>>> (2) H(D,D) aborts its simulation then simulated D(D) stops
>>>>>>>>>>>> running.
>>>>>>>>>>>>
>>>>>>>>>>>> (a) If simulating abort decider H correctly simulates its
>>>>>>>>>>>> input D until H correctly determines that its simulated D
>>>>>>>>>>>> would never stop running unless aborted...
>>>>>>>>>>>>
>>>>>>>>>>>> *Therefore*
>>>>>>>>>>>> *Every element of (1) is incorrect and every element of (2)
>>>>>>>>>>>> is correct*
>>>>>>>>>>>> *Pathological thinking to make them both seem incorrect is
>>>>>>>>>>>> incorrect*
>>>>>>>>>>>>
>>>>>>>>>>>>> So, Hss(Dss,Dss) should abort, but it does not.
>>>>>>>>>>>>> and Han(Dan,Dan) should not abort, but it does.
>>>>>>>>>>>>> The Hss that meets the abort criteria does not abort and
>>>>>>>>>>>>> the Han that does not meet its abort criteria does abort.
>>>>>>>>>>>>> So, both are wrong.
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> Is it Dan that is considered, or Dss? Dss must be aborted,
>>>>>>>>>>> because is does not halt, but Dan does halt and does not need
>>>>>>>>>>> to be aborted.
>>>>>>>>>>
>>>>>>>>>> *This is what those naming conventions derive*
>>>>>>>>>> Everyone is saying that because H(D,D) did need to abort its
>>>>>>>>>> simulation
>>>>>>>>>> to prevent D(D) from infinite execution that this proves that
>>>>>>>>>> it never
>>>>>>>>>> needed to abort its simulation because it can rely on the fact
>>>>>>>>>> that it
>>>>>>>>>> already aborted its simulation thus never needed to abort it.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> You are almost there. If you stop naming all different H which
>>>>>>>>> the same name and all different D with the same name, your
>>>>>>>>> confusion may disappear.
>>>>>>>>
>>>>>>>> ∀H ∈ TM ∀D ∈ TMD | (H(D,D) simulates its input and D calls H(D,D))
>>>>>>>> Every H in the above set must abort its simulated D(D).
>>>>>>>>
>>>>>>>>> Hss(Dss,Dss) should abort, but it does not.
>>>>>>>>> and Han(Dan,Dan) should not abort, but it does.
>>>>>>>>> The Hss that meets the abort criteria does not abort and the Han
>>>>>>>>> that does not meet its abort criteria does abort. So, both are
>>>>>>>>> wrong.
>>>>>>>>>
>>>>>>>
>>>>>>> Olcott does not understand that if the H in the simulated D
>>>>>>> aborts, then the simulating H should not abort
>>>>>>
>>>>>> *You are confused*
>>>>>> If the H in the simulated D aborts then the directly executed H did
>>>>>> not abort. Since the directly executed H sees one more execution
>>>>>> trace then the simulated H then the H in the simulated D never
>>>>>> aborts.
>>>>>
>>>>> Nope, YOU are confused If the H in the simulated D aborts,
>>>>
>>>> Then a dozen square circles are on sale at Walmart right now for $10.99
>>>
>>> Interesting, that you retort was to just blantently lie?
>>>
>>> When presented with FACTS, you respond with LIES.
>>>
>>> That just shows who you are.
>>>
>>>>
>>>>> then the directly executed D MUST abort, or you are agreeing that
>>>>> H's simulation is not correct.
>>>>>
>>>>
>>>> In other words after we have been over this hundreds and hundreds of
>>>> times it is still waaaayyy over your head that the executed H always
>>>> sees exactly one more execution trace than the executed H?
>>>
>>> Do you really read your nonsense?
>>>
>>> How does x, "the executed H" see one more execution trace than x?
>>>
>>> That means you think that 1 + 1 = 1
>>>
>>>>
>>>>> And no, the directed executed vesion of D see no more information
>>>>> then the machine the simulated D represents,
>>>>
>>>> The simulated H can not see its own behavior where as its simulator
>>>> can thus proving the simulator sees one more execution trace that
>>>> its simulation.
>>>
>>> Nope, it may see one more then at the point the simulation reaches,
>>
>> Yes, finally. Thus the executed H(D,D) sees its abort criteria before
>> any of the simulated ones ever would.
>>
>>> but the actual machine that is now being simulated did EVERYTHING
>>> that it will do as soon as it was created,
>>>
>> No it is not true that x86 machines are oracle machines.
>> https://en.wikipedia.org/wiki/Oracle_machine
>>
>>> You keep on makeing that mistake, confusing the simulation with what
>>> actually happens.
>>>
>>>>
>>>>> if H aborts the simulation before then, then H just doesn't get to
>>>>> know what happens after that.
>>>>>
>>>>> I will point out, you almost NEVER actually look at the direct
>>>>> execution of D(D), because it just proves that H isn't a correct
>>>>> Halt Decider.
>>>>>
>>>>
>>>> H(D,D) cannot rely on the behavior of D(D) after it has already aborted
>>>> its simulation or it would never abort its simulation and D(D) would
>>>> never stop running. This means that the executed H(D,D) see non halting
>>>> behavior.
>>>>
>>>
>>> Right, H is in a no-win pickle. (or its programmer is).
>>
>> Not at all. The requirement for clairvoyance is an incorrect
>> requirement. H(D,D) cannot be correctly required to report on
>> what it cannot see.
>>
>>> If we wait, we run into the issue that we may never answer. If we
>>> abort, we don't know what answer to give.
>>
>> An abort decider would report on whether it aborted or not.
>>
>>> That is why the Halting Mapping turns out to be uncomputable.
>>>
>>
>> *H(D,D) cannot be correctly required to report on what it cannot see*
>
> A requirement is correct if it is possible to determine
> whether the requirement is satisfied in a particular case.
>

Op 19.mrt.2024 om 15:35 schreef olcott:
> On 3/19/2024 4:37 AM, Mikko wrote:
>> On 2024-03-18 23:05:33 +0000, olcott said:
>>
>>> On 3/18/2024 6:43 AM, Mikko wrote:
>>>> On 2024-03-17 23:47:01 +0000, olcott said:
>>>>
>>>>> On 3/17/2024 2:45 PM, Richard Damon wrote:
>>>>>> On 3/17/24 9:31 AM, olcott wrote:
>>>>>>> On 3/17/2024 11:13 AM, Mikko wrote:
>>>>>>>> On 2024-03-17 13:52:31 +0000, olcott said:
>>>>>>>>
>>>>>>>>> On 3/17/2024 8:46 AM, Mikko wrote:
>>>>>>>>>> On 2024-03-16 15:18:33 +0000, olcott said:
>>>>>>>>>>
>>>>>>>>>>> On 3/16/2024 3:19 AM, Mikko wrote:
>>>>>>>>>>>> On 2024-03-15 16:20:35 +0000, olcott said:
>>>>>>>>>>>>
>>>>>>>>>>>>> Best selling author of Theory of Computation textbooks:
>>>>>>>>>>>>> *Introduction To The Theory Of Computation 3RD, by sipser*
>>>>>>>>>>>>> https://www.amazon.com/Introduction-Theory-Computation-Sipser/dp/8131525295/
>>>>>>>>>>>>>
>>>>>>>>>>>>> Date 10/13/2022 11:29:23 AM
>>>>>>>>>>>>> *MIT Professor Michael Sipser agreed this verbatim
>>>>>>>>>>>>> paragraph is correct*
>>>>>>>>>>>>> (He has neither reviewed nor agreed to anything else in
>>>>>>>>>>>>> this paper)
>>>>>>>>>>>>> (a) 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
>>>>>>>>>>>>> (b) H can abort its simulation of D and correctly report
>>>>>>>>>>>>> that D specifies a non-halting sequence of configurations.
>>>>>>>>>>>>>
>>>>>>>>>>>>> *When we apply the abort criteria* (elaborated above)
>>>>>>>>>>>>> Will you halt if you never abort your simulation?
>>>>>>>>>>>>> *Then H(D,D) is proven to meet this criteria*
>>>>>>>>>>>>>
>>>>>>>>>>>>> *Proof that H(D,D) meets its abort criteria*
>>>>>>>>>>>>>
>>>>>>>>>>>>> int D(int (*x)())
>>>>>>>>>>>>> {
>>>>>>>>>>>>>    int Halt_Status = H(x, x);
>>>>>>>>>>>>>    if (Halt_Status)
>>>>>>>>>>>>>      HERE: goto HERE;
>>>>>>>>>>>>>    return Halt_Status;
>>>>>>>>>>>>> }
>>>>>>>>>>>>>
>>>>>>>>>>>>> int main()
>>>>>>>>>>>>> {
>>>>>>>>>>>>>    Output("Input_Halts = ", H(D,D));
>>>>>>>>>>>>> }
>>>>>>>>>>>>>
>>>>>>>>>>>>>   machine   stack     stack     machine    assembly
>>>>>>>>>>>>>   address   address   data      code       language
>>>>>>>>>>>>>   ========  ========  ========  =========  =============
>>>>>>>>>>>>> [00001d22][00102fc9][00000000] 55         push ebp      ;
>>>>>>>>>>>>> begin main()
>>>>>>>>>>>>> [00001d23][00102fc9][00000000] 8bec       mov ebp,esp
>>>>>>>>>>>>> [00001d25][00102fc5][00001cf2] 68f21c0000 push 00001cf2 ;
>>>>>>>>>>>>> push DD
>>>>>>>>>>>>> [00001d2a][00102fc1][00001cf2] 68f21c0000 push 00001cf2 ;
>>>>>>>>>>>>> push D
>>>>>>>>>>>>> [00001d2f][00102fbd][00001d34] e8eef7ffff call 00001522 ;
>>>>>>>>>>>>> call H(D,D)
>>>>>>>>>>>>>
>>>>>>>>>>>>> H: Begin Simulation   Execution Trace Stored at:113075
>>>>>>>>>>>>> Address_of_H:1522
>>>>>>>>>>>>> [00001cf2][00113061][00113065] 55         push ebp       ;
>>>>>>>>>>>>> enter D(D)
>>>>>>>>>>>>> [00001cf3][00113061][00113065] 8bec       mov ebp,esp
>>>>>>>>>>>>> [00001cf5][0011305d][00103031] 51         push ecx
>>>>>>>>>>>>> [00001cf6][0011305d][00103031] 8b4508     mov eax,[ebp+08]
>>>>>>>>>>>>> [00001cf9][00113059][00001cf2] 50         push eax       ;
>>>>>>>>>>>>> push D
>>>>>>>>>>>>> [00001cfa][00113059][00001cf2] 8b4d08     mov ecx,[ebp+08]
>>>>>>>>>>>>> [00001cfd][00113055][00001cf2] 51         push ecx       ;
>>>>>>>>>>>>> push D
>>>>>>>>>>>>> [00001cfe][00113051][00001d03] e81ff8ffff call 00001522  ;
>>>>>>>>>>>>> call H(D,D)
>>>>>>>>>>>>> H: Recursive Simulation Detected Simulation Stopped
>>>>>>>>>>>>>                            H(D,D) returns 0 to main()
>>>>>>>>>>>>>
>>>>>>>>>>>>> *That was proof that H(D,D) meets its abort criteria*
>>>>>>>>>>>>> H(D,D) correctly determines that itself is being called
>>>>>>>>>>>>> with its same inputs and there are no conditional branch
>>>>>>>>>>>>> instructions between the invocation of D(D) and its call to
>>>>>>>>>>>>> H(D,D).
>>>>>>>>>>>>
>>>>>>>>>>>> This proof is not simpler or more convinceing than earlier
>>>>>>>>>>>> proofs of
>>>>>>>>>>>> the same.
>>>>>>>>>>>>
>>>>>>>>>>>> It is also as uninteresting as the proved claim. As long as
>>>>>>>>>>>> H does
>>>>>>>>>>>> not meet the specification of halting decider it does not
>>>>>>>>>>>> matter
>>>>>>>>>>>> what it meets instead.
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> The original halt status criteria has the impossible requirement
>>>>>>>>>>> that H(D,D) must report on behavior that it does not actually
>>>>>>>>>>> see.
>>>>>>>>>>
>>>>>>>>>> The requirement is not specifically about behaviour that the
>>>>>>>>>> decider
>>>>>>>>>> does not actually see but requires reporting anyway, whether the
>>>>>>>>>> decider sees or not. So it turns out that it is not possible to
>>>>>>>>>> meet the specification in all cases.
>>>>>>>>>>
>>>>>>>>> I think that the decider can meet its abort criteria in all cases.
>>>>>>>>
>>>>>>>> But cannot meet its specification.
>>>>>>>>
>>>>>>>
>>>>>>> First we must come to mutual agreement that H(D,D) is correct
>>>>>>> to abort its simulation.
>>>>>>
>>>>>> Which means we need to first come to an aggreement of what that
>>>>>> means.
>>>>>>
>>>>>> You DID agree earlier to this:
>>>>>>
>>>>>> On 3/17/24 6:11 AM, olcott wrote:
>>>>>>> On 3/17/2024 12:22 AM, Richard Damon wrote:
>>>>>>>> To me, for H to NEED to abort its simulation, that means that when
>>>>>>>> giving the input to a correct simulator, that simulator will not
>>>>>>>> halt.
>>>>>>>>
>>>>>>> Yes that is correct.
>>>>>>>
>>>>>>
>>>>>
>>>>> For every possible way that H can be encoded and D(D)
>>>>> calls H(D,D) either H(D,D) aborts its simulation or D(D)
>>>>> never stops running.
>>>>
>>>> That is ambiguous: does D(D) call H(D,D) if H is encoded in another way
>>>> than the one that D(D) calls?
>>>>
>>>
>>> I have no idea what you are meaning.
>>> It is assumed that H and D are C functions.
>>
>> What exacly you don't understand? Do you understand the following
>> phrases:
>>
>> - "every possibe way that H can be encoded" ?
>>
>> - "D(D) calls H(D,D)" ?
>>
>> - "the H(D,D) that D(D) calls" ?
>>
>> - "H(D,D) aborts its simulation"
>>
>> Unless you can answer I can only assume that you are too stupid
>> for this discussion.
>>
>
> ∀H ∈ TM ∀D ∈ TMD | (H(D,D) simulates its input and D calls H(D,D))
> (1) H(D,D) does not abort its simulation then simulated D(D) never stops
> running.
> (2) H(D,D) aborts its simulation then simulated D(D) stops running.

On 3/19/2024 4:05 AM, Fred. Zwarts wrote:
> Op 19.mrt.2024 om 05:37 schreef olcott:
>> On 3/18/2024 11:23 PM, Richard Damon wrote:
>>> On 3/18/24 8:53 PM, olcott wrote:
>>>> On 3/18/2024 9:44 PM, Richard Damon wrote:
>>>>> On 3/18/24 2:48 PM, olcott wrote:
>>>>>> On 3/18/2024 4:38 PM, Fred. Zwarts wrote:
>>>>>>> Op 18.mrt.2024 om 22:18 schreef olcott:
>>>>>>>> On 3/18/2024 4:11 PM, Fred. Zwarts wrote:
>>>>>>>>> Op 18.mrt.2024 om 21:40 schreef olcott:
>>>>>>>>>> On 3/18/2024 3:30 PM, immibis wrote:
>>>>>>>>>>> On 18/03/24 21:20, olcott wrote:
>>>>>>>>>>>> On 3/18/2024 2:44 PM, Fred. Zwarts wrote:
>>>>>>>>>>>>> Op 18.mrt.2024 om 18:43 schreef olcott:
>>>>>>>>>>>>>> On 3/18/2024 10:11 AM, Fred. Zwarts wrote:
>>>>>>>>>>>>>>> Op 18.mrt.2024 om 15:44 schreef olcott:
>>>>>>>>>>>>>>>> On 3/18/2024 1:04 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>> On 3/17/24 10:22 PM, olcott wrote:
>>>>>>>>>>>>>>>>>> On 3/18/2024 12:11 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>> On 3/17/24 9:42 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>> On 3/17/2024 11:39 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>> On 3/17/24 9:00 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>> On 3/17/2024 10:32 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>> On 3/17/24 8:14 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>> On 3/17/2024 9:35 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>> On 3/17/24 4:27 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/17/2024 12:37 PM, immibis wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>> On 17/03/24 14:11, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/17/2024 12:22 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/16/24 10:04 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/17/2024 12:00 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/16/24 9:42 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/16/2024 11:28 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/16/24 9:13 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/16/2024 10:57 PM, Richard Damon
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/16/24 7:52 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/16/2024 9:43 PM, Richard Damon
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/16/24 5:50 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/16/2024 7:21 PM, Richard
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/16/24 8:29 AM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/15/2024 11:29 PM, Richard
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/15/24 8:45 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H(D,D) fails to make the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> required mistake of reporting
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> on what it does not see.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> But it DOES make a mistake,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> because it does answer the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> question correctly.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> You are just PROVING you think
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> lying is ok.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> You TOTALLY don't understand
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the meaning of truth.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> You are REALLY just a
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Pathological Liar, as you have
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> no concept of real truth,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> The original halt status
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> criteria has the impossible
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> requirement
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that H(D,D) must report on
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> behavior that it does not
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> actually see.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Requiring H to be clairvoyant is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> an unreasonable requirement.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> *The criteria shown below
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> eliminate the requirement of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> clairvoyance*
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (a) 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 correctly simulates its input
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> D until*
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Means H does a correct partial
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation of D until H correctly
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> matches the recursive simulation
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> non-halting behavior pattern.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> But turning out to be impposible,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> doesn't make it incorrect or
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> invalid.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> *You seems to be ridiculously
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> disingenuous about the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> self-evident truth*
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> For every possible way that H can
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> be encoded and D(D) calls H(D,D)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> either H(D,D) aborts its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation or D(D) never stops
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> running.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> And you are incredably stupid to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> not see this doesn't prove what you
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> need it to.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Yes, if you define H to not abort,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the we get a non-haltig D(D), but H
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> doesn't answwer.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> But, if you define H to abort, then,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> We see that you changed the subject
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> away from:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [Proof that H(D,D) meets its abort
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> criteria]
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Nope.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H is an algorithm that simulates its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> input and correctly
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> determines whether or not it needs to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> abort this simulation.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> That is all that this thread's H does.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> And what defines "Need"?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> It is the set of every implementation of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> its spec:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (a) H(D,D) Simulate input.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (b) Determine if it needs to stop
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulating its input to prevent
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the simulated D(D) from never halting.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> And thus not a specific algorithm?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Again, HOW do you determine NEED?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> That is not an algorithmic step.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> We can only verify that in retrospect.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Do you fully understand the spec?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Yes, but I think not the way you do.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> To me, for H to NEED to abort its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation, that means that when giving the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> input to a correct simulator, that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulator will not halt.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> Yes that is correct.
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> You have just proven that H doesn't need
>>>>>>>>>>>>>>>>>>>>>>>>>>> abort its simulation and the abort decision
>>>>>>>>>>>>>>>>>>>>>>>>>>> is incorrect.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> The head games of a Troll.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> For every possible way that H can be encoded
>>>>>>>>>>>>>>>>>>>>>>>>>> and D(D)
>>>>>>>>>>>>>>>>>>>>>>>>>> calls H(D,D) either H(D,D) aborts its
>>>>>>>>>>>>>>>>>>>>>>>>>> simulation or D(D)
>>>>>>>>>>>>>>>>>>>>>>>>>> never stops running.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> Which prove NOTHING, as D varies with H, so no
>>>>>>>>>>>>>>>>>>>>>>>>> D that was built with an H that aborts its
>>>>>>>>>>>>>>>>>>>>>>>>> simulation has had its actual halting status
>>>>>>>>>>>>>>>>>>>>>>>>> tested.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> *That merely changes the wording of the same
>>>>>>>>>>>>>>>>>>>>>>>> truism*
>>>>>>>>>>>>>>>>>>>>>>>> ∀H ∈ TM ∀D ∈ TMD such that
>>>>>>>>>>>>>>>>>>>>>>>> H(D,D) simulates its input and
>>>>>>>>>>>>>>>>>>>>>>>> D calls H(D,D) and
>>>>>>>>>>>>>>>>>>>>>>>> H(D,D) does not abort its simulation
>>>>>>>>>>>>>>>>>>>>>>>> necessitates simulated D(D) never stops running.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> Third times and still not a charm.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> All those D still use an H that doesn't abort
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> *You keep talking in circles, there are only two
>>>>>>>>>>>>>>>>>>>>>> sets*
>>>>>>>>>>>>>>>>>>>>>> ∀H ∈ TM ∀D ∈ TMD | (H(D,D) simulates its input and
>>>>>>>>>>>>>>>>>>>>>> D calls H(D,D))
>>>>>>>>>>>>>>>>>>>>>> (1) H(D,D) does not abort its simulation then
>>>>>>>>>>>>>>>>>>>>>> simulated D(D) never stops running.
>>>>>>>>>>>>>>>>>>>>>> (2) H(D,D) aborts its simulation then simulated
>>>>>>>>>>>>>>>>>>>>>> D(D) stops running.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> And your top line says NOTHING about the Ds in set
>>>>>>>>>>>>>>>>>>>>> (2), since nothing showed them not to run
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> but your (2) admitts that D(D) will stop running,
>>>>>>>>>>>>>>>>>>>>> and thus the top level H didn't need to abort its
>>>>>>>>>>>>>>>>>>>>> simulation.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> Do you understand that each H(D,D) must either abort
>>>>>>>>>>>>>>>>>>>> or fail to abort?
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> And do you understand
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Yes that is what I am asking. It seems that you don't
>>>>>>>>>>>>>>>>>> understand
>>>>>>>>>>>>>>>>>> the difference between X being a member of a set and X
>>>>>>>>>>>>>>>>>> not being
>>>>>>>>>>>>>>>>>> a member of a set. Very elemental set theory.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> And you seem to be trying to convientely forget that
>>>>>>>>>>>>>>>>> each D that you talk about is DIFFERENT, base on the H
>>>>>>>>>>>>>>>>> that it was designed to confound.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> *You keep talking in circles, there are only two sets*
>>>>>>>>>>>>>>>> ∀H ∈ TM ∀D ∈ TMD | (H(D,D) simulates its input and D
>>>>>>>>>>>>>>>> calls H(D,D))
>>>>>>>>>>>>>>>> (1) H(D,D) does not abort its simulation then simulated
>>>>>>>>>>>>>>>> D(D) never stops running.
>>>>>>>>>>>>>>>> (2) H(D,D) aborts its simulation then simulated D(D)
>>>>>>>>>>>>>>>> stops running.
>>>>>>>>>>>>>>>> *By whatever means H(D,D) places itself in (2) then
>>>>>>>>>>>>>>>> H(D,D) is correct*
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> By repeating yourself, you run in circles.
>>>>>>>>>>>>>>> There are three possible categories of H functions:
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> 1. Hah, It aborts and reports halting.
>>>>>>>>>>>>>>> 2. Han, It aborts and repeats non halting.
>>>>>>>>>>>>>>> 3. Hss does not abort, but simply simulates.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> What H(D,D) reports is off-topic for this post.
>>>>>>>>>>>>>> *We are only looking at this*
>>>>>>>>>>>>>> [Proof that H(D,D) meets its abort criteria --self-evident
>>>>>>>>>>>>>> truth--]
>>>>>>>>>>>>>> *Thus H(D,D) aborts or H(D,D) fails to abort*
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> Be clear in the naming. Is it Dan that is considered, or
>>>>>>>>>>>>> Dss? Dss must be aborted, because is does not halt, but Dan
>>>>>>>>>>>>> does halt and does not need to be aborted.
>>>>>>>>>>>>
>>>>>>>>>>>> *There are only two sets*
>>>>>>>>>>>> ∀H ∈ TM ∀D ∈ TMD | (H(D,D) simulates its input and D calls
>>>>>>>>>>>> H(D,D))
>>>>>>>>>>>> (1) H(D,D) does not abort its simulation then simulated D(D)
>>>>>>>>>>>> never stops running.
>>>>>>>>>>>> (2) H(D,D) aborts its simulation then simulated D(D) stops
>>>>>>>>>>>> running.
>>>>>>>>>>>>
>>>>>>>>>>>> (a) If simulating abort decider H correctly simulates its
>>>>>>>>>>>> input D until H correctly determines that its simulated D
>>>>>>>>>>>> would never stop running unless aborted...
>>>>>>>>>>>>
>>>>>>>>>>>> *Therefore*
>>>>>>>>>>>> *Every element of (1) is incorrect and every element of (2)
>>>>>>>>>>>> is correct*
>>>>>>>>>>>> *Pathological thinking to make them both seem incorrect is
>>>>>>>>>>>> incorrect*
>>>>>>>>>>>>
>>>>>>>>>>>>> So, Hss(Dss,Dss) should abort, but it does not.
>>>>>>>>>>>>> and Han(Dan,Dan) should not abort, but it does.
>>>>>>>>>>>>> The Hss that meets the abort criteria does not abort and
>>>>>>>>>>>>> the Han that does not meet its abort criteria does abort.
>>>>>>>>>>>>> So, both are wrong.
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> Is it Dan that is considered, or Dss? Dss must be aborted,
>>>>>>>>>>> because is does not halt, but Dan does halt and does not need
>>>>>>>>>>> to be aborted.
>>>>>>>>>>
>>>>>>>>>> *This is what those naming conventions derive*
>>>>>>>>>> Everyone is saying that because H(D,D) did need to abort its
>>>>>>>>>> simulation
>>>>>>>>>> to prevent D(D) from infinite execution that this proves that
>>>>>>>>>> it never
>>>>>>>>>> needed to abort its simulation because it can rely on the fact
>>>>>>>>>> that it
>>>>>>>>>> already aborted its simulation thus never needed to abort it.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> You are almost there. If you stop naming all different H which
>>>>>>>>> the same name and all different D with the same name, your
>>>>>>>>> confusion may disappear.
>>>>>>>>
>>>>>>>> ∀H ∈ TM ∀D ∈ TMD | (H(D,D) simulates its input and D calls H(D,D))
>>>>>>>> Every H in the above set must abort its simulated D(D).
>>>>>>>>
>>>>>>>>> Hss(Dss,Dss) should abort, but it does not.
>>>>>>>>> and Han(Dan,Dan) should not abort, but it does.
>>>>>>>>> The Hss that meets the abort criteria does not abort and the Han
>>>>>>>>> that does not meet its abort criteria does abort. So, both are
>>>>>>>>> wrong.
>>>>>>>>>
>>>>>>>
>>>>>>> Olcott does not understand that if the H in the simulated D
>>>>>>> aborts, then the simulating H should not abort
>>>>>>
>>>>>> *You are confused*
>>>>>> If the H in the simulated D aborts then the directly executed H did
>>>>>> not abort. Since the directly executed H sees one more execution
>>>>>> trace then the simulated H then the H in the simulated D never
>>>>>> aborts.
>>>>>
>>>>> Nope, YOU are confused If the H in the simulated D aborts,
>>>>
>>>> Then a dozen square circles are on sale at Walmart right now for $10.99
>>>
>>> Interesting, that you retort was to just blantently lie?
>>>
>>> When presented with FACTS, you respond with LIES.
>>>
>>> That just shows who you are.
>>>
>>>>
>>>>> then the directly executed D MUST abort, or you are agreeing that
>>>>> H's simulation is not correct.
>>>>>
>>>>
>>>> In other words after we have been over this hundreds and hundreds of
>>>> times it is still waaaayyy over your head that the executed H always
>>>> sees exactly one more execution trace than the executed H?
>>>
>>> Do you really read your nonsense?
>>>
>>> How does x, "the executed H" see one more execution trace than x?
>>>
>>> That means you think that 1 + 1 = 1
>>>
>>>>
>>>>> And no, the directed executed vesion of D see no more information
>>>>> then the machine the simulated D represents,
>>>>
>>>> The simulated H can not see its own behavior where as its simulator
>>>> can thus proving the simulator sees one more execution trace that
>>>> its simulation.
>>>
>>> Nope, it may see one more then at the point the simulation reaches,
>>
>> Yes, finally. Thus the executed H(D,D) sees its abort criteria before
>> any of the simulated ones ever would.
>>
>>> but the actual machine that is now being simulated did EVERYTHING
>>> that it will do as soon as it was created,
>>>
>> No it is not true that x86 machines are oracle machines.
>> https://en.wikipedia.org/wiki/Oracle_machine
>>
>>> You keep on makeing that mistake, confusing the simulation with what
>>> actually happens.
>>>
>>>>
>>>>> if H aborts the simulation before then, then H just doesn't get to
>>>>> know what happens after that.
>>>>>
>>>>> I will point out, you almost NEVER actually look at the direct
>>>>> execution of D(D), because it just proves that H isn't a correct
>>>>> Halt Decider.
>>>>>
>>>>
>>>> H(D,D) cannot rely on the behavior of D(D) after it has already aborted
>>>> its simulation or it would never abort its simulation and D(D) would
>>>> never stop running. This means that the executed H(D,D) see non halting
>>>> behavior.
>>>>
>>>
>>> Right, H is in a no-win pickle. (or its programmer is).
>>
>> Not at all. The requirement for clairvoyance is an incorrect
>> requirement. H(D,D) cannot be correctly required to report on
>> what it cannot see.
>>
>>> If we wait, we run into the issue that we may never answer. If we
>>> abort, we don't know what answer to give.
>>
>> An abort decider would report on whether it aborted or not.
>>
>>> That is why the Halting Mapping turns out to be uncomputable.
>>>
>>
>> *H(D,D) cannot be correctly required to report on what it cannot see*
>>
>
> But H(D,D) cannot be allowed to choose what it want to see and what it
> does not want to see. By aborting, it chooses to close it eyes and
> therefore it does not see that D calls H, which aborts and returns. It
> is not a matter of 'cannot see', but 'chooses to be blind for the facts'.
>

On 3/19/2024 4:05 AM, Mikko wrote:
> On 2024-03-18 21:16:42 +0000, olcott said:
>
>> On 3/18/2024 3:56 PM, Richard Damon wrote:
>>> On 3/18/24 1:41 PM, olcott wrote:
>>>> On 3/18/2024 3:33 PM, Richard Damon wrote:
>>>>> On 3/18/24 12:39 PM, olcott wrote:
>>>>>> On 3/18/2024 1:06 PM, Richard Damon wrote:
>>>>>>> On 3/18/24 10:45 AM, olcott wrote:
>>>>>>>> What H(D,D) reports is off-topic for this post.
>>>>>>>> *We are only looking at this*
>>>>>>>> [Proof that H(D,D) meets its abort criteria --self-evident truth--]
>>>>>>>> *Thus H(D,D) aborts or H(D,D) fails to abort*
>>>>>>>>
>>>>>>>> (a) If *simulating abort decider H* correctly simulates its
>>>>>>>> input D until H correctly determines that its simulated D would
>>>>>>>> never stop running unless aborted then
>>>>>>>
>>>>>>> So, it needs to simulate UNTIL it ACTUALLY CORRECTLY DETERMINES
>>>>>>> that its D will never stop running, unless THIS H aborts it.
>>>>>>>
>>>>>>
>>>>>> You never seemed to get the idea that X is a member of set Y
>>>>>> otherwise X is not a member of set Y.
>>>>>>
>>>>>
>>>>> And what are you defining X and set Y to be?
>>>>>
>>>>> That seems to be your problem, you are listing TWO distinct sets,
>>>>> which hae two distinct set of Deciders and two distince to of inputs.
>>>>>
>>>>> You can't argue about an input built on a different decider tells
>>>>> you anything about the input built on THIS decider.
>>>>
>>>> *This is what those naming conventions derive*
>>>> Everyone is saying that because H(D,D) did need to abort its simulation
>>>> to prevent D(D) from infinite execution that this proves that it never
>>>> needed to abort its simulation because it can rely on the fact that it
>>>> already aborted its simulation thus never needed to abort it.
>>>>
>>>
>>> So, you can't define what you SET is defined as?
>>>
>>
>> ∀H ∈ TM ∀D ∈ TMD | (H(D,D) simulates its input and D calls H(D,D))
>
> Use of double quantifiers may be a little confusing as each D calls
> only one H.
>

*Counter factual*
My syntax is intended to specify the universe of H/D pairs such that
(H(D,D) simulates its input and D calls H(D,D))

That there can be multiple H for every unique D and multiple D for
every unique H becomes more obvious when understand that we can pad
either H or D with an arbitrary number of NOP opcodes.
https://en.wikipedia.org/wiki/NOP_(code)

--
Copyright 2024 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer

On 3/19/2024 4:00 AM, Mikko wrote:
> On 2024-03-18 20:56:38 +0000, Richard Damon said:
>
>> On 3/18/24 1:41 PM, olcott wrote:
>>> On 3/18/2024 3:33 PM, Richard Damon wrote:
>>>> On 3/18/24 12:39 PM, olcott wrote:
>>>>> On 3/18/2024 1:06 PM, Richard Damon wrote:
>>>>>> On 3/18/24 10:45 AM, olcott wrote:
>>>>>>> What H(D,D) reports is off-topic for this post.
>>>>>>> *We are only looking at this*
>>>>>>> [Proof that H(D,D) meets its abort criteria --self-evident truth--]
>>>>>>> *Thus H(D,D) aborts or H(D,D) fails to abort*
>>>>>>>
>>>>>>> (a) If *simulating abort decider H* correctly simulates its input
>>>>>>> D until H correctly determines that its simulated D would never
>>>>>>> stop running unless aborted then
>>>>>>
>>>>>> So, it needs to simulate UNTIL it ACTUALLY CORRECTLY DETERMINES
>>>>>> that its D will never stop running, unless THIS H aborts it.
>>>>>>
>>>>>
>>>>> You never seemed to get the idea that X is a member of set Y
>>>>> otherwise X is not a member of set Y.
>>>>>
>>>>
>>>> And what are you defining X and set Y to be?
>>>>
>>>> That seems to be your problem, you are listing TWO distinct sets,
>>>> which hae two distinct set of Deciders and two distince to of inputs.
>>>>
>>>> You can't argue about an input built on a different decider tells
>>>> you anything about the input built on THIS decider.
>>>
>>> *This is what those naming conventions derive*
>>> Everyone is saying that because H(D,D) did need to abort its simulation
>>> to prevent D(D) from infinite execution that this proves that it never
>>> needed to abort its simulation because it can rely on the fact that it
>>> already aborted its simulation thus never needed to abort it.
>>>
>>
>> So, you can't define what you SET is defined as?
>>
>> If not, then how can you complain that I don't get the members right?
>>
>> That is just part of your deception.
>>
>> And, you seem to have a confusion about identities.
>>
>> The calling of H by D is a distinct computation from the H called by
>> main that is trying to simulate the input given to it
>>
>> After all D(D) is DEFINED to be a seperate Computation that H is
>> supposed to decide on.
>>
>> Seperate things are separate things,
>>
>>
>> THIS H didn't "already abort it", it was THAT OTHER H that did,
>>
>> Somethibg distinct from it.
>>
>> At a different level of "Simulation"
>>
>> You don't seem to understand that each level of simulation is
>> something distinct.
>>
>> Otherwise, when H abort, it would be aborting "itself" and thus stop
>> running.
>
> Actually, the criterion discussed here only aborts H called by D. Another
> criterion is needed if the loop at the end of D needs be aborted.
>

*Counter-factual*
the criterion discussed here only aborts D that calls H(D,D)

--
Copyright 2024 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer

On 3/19/24 8:06 AM, olcott wrote:
> On 3/19/2024 4:05 AM, Mikko wrote:
>> On 2024-03-18 21:16:42 +0000, olcott said:
>>
>>> On 3/18/2024 3:56 PM, Richard Damon wrote:
>>>> On 3/18/24 1:41 PM, olcott wrote:
>>>>> On 3/18/2024 3:33 PM, Richard Damon wrote:
>>>>>> On 3/18/24 12:39 PM, olcott wrote:
>>>>>>> On 3/18/2024 1:06 PM, Richard Damon wrote:
>>>>>>>> On 3/18/24 10:45 AM, olcott wrote:
>>>>>>>>> What H(D,D) reports is off-topic for this post.
>>>>>>>>> *We are only looking at this*
>>>>>>>>> [Proof that H(D,D) meets its abort criteria --self-evident
>>>>>>>>> truth--]
>>>>>>>>> *Thus H(D,D) aborts or H(D,D) fails to abort*
>>>>>>>>>
>>>>>>>>> (a) If *simulating abort decider H* correctly simulates its
>>>>>>>>> input D until H correctly determines that its simulated D would
>>>>>>>>> never stop running unless aborted then
>>>>>>>>
>>>>>>>> So, it needs to simulate UNTIL it ACTUALLY CORRECTLY DETERMINES
>>>>>>>> that its D will never stop running, unless THIS H aborts it.
>>>>>>>>
>>>>>>>
>>>>>>> You never seemed to get the idea that X is a member of set Y
>>>>>>> otherwise X is not a member of set Y.
>>>>>>>
>>>>>>
>>>>>> And what are you defining X and set Y to be?
>>>>>>
>>>>>> That seems to be your problem, you are listing TWO distinct sets,
>>>>>> which hae two distinct set of Deciders and two distince to of inputs.
>>>>>>
>>>>>> You can't argue about an input built on a different decider tells
>>>>>> you anything about the input built on THIS decider.
>>>>>
>>>>> *This is what those naming conventions derive*
>>>>> Everyone is saying that because H(D,D) did need to abort its
>>>>> simulation
>>>>> to prevent D(D) from infinite execution that this proves that it never
>>>>> needed to abort its simulation because it can rely on the fact that it
>>>>> already aborted its simulation thus never needed to abort it.
>>>>>
>>>>
>>>> So, you can't define what you SET is defined as?
>>>>
>>>
>>> ∀H ∈ TM ∀D ∈ TMD | (H(D,D) simulates its input and D calls H(D,D))
>>
>> Use of double quantifiers may be a little confusing as each D calls
>> only one H.
>>
>
> *Counter factual*
> My syntax is intended to specify the universe of H/D pairs such that
> (H(D,D) simulates its input and D calls H(D,D))
>
> That there can be multiple H for every unique D and multiple D for
> every unique H becomes more obvious when understand that we can pad
> either H or D with an arbitrary number of NOP opcodes.
> https://en.wikipedia.org/wiki/NOP_(code)

HOW can there be multiple Hs for any unique D if D is qualified to call
the H it is paired with.

Since a given instance of D can ony use ONE version of H to build its
TMD, every D is paired with only on verions of H in your sets.

You don't seem to know how Turing Machine are define.

Please TRY to show how you would code a single TMD for D that could
possibly call more than one version of H????

You are just showing your total ignorance of what you are trying to talk
about.

On 3/18/24 10:57 PM, olcott wrote:
> On 3/19/2024 12:23 AM, Richard Damon wrote:
>> On 3/18/24 9:37 PM, olcott wrote:
>>> On 3/18/2024 11:23 PM, Richard Damon wrote:
>>>> On 3/18/24 8:53 PM, olcott wrote:
>>>>> On 3/18/2024 9:44 PM, Richard Damon wrote:
>>>>>> On 3/18/24 2:48 PM, olcott wrote:
>>>>>>> On 3/18/2024 4:38 PM, Fred. Zwarts wrote:
>>>>>>>> Op 18.mrt.2024 om 22:18 schreef olcott:
>>>>>>>>> On 3/18/2024 4:11 PM, Fred. Zwarts wrote:
>>>>>>>>>> Op 18.mrt.2024 om 21:40 schreef olcott:
>>>>>>>>>>> On 3/18/2024 3:30 PM, immibis wrote:
>>>>>>>>>>>> On 18/03/24 21:20, olcott wrote:
>>>>>>>>>>>>> On 3/18/2024 2:44 PM, Fred. Zwarts wrote:
>>>>>>>>>>>>>> Op 18.mrt.2024 om 18:43 schreef olcott:
>>>>>>>>>>>>>>> On 3/18/2024 10:11 AM, Fred. Zwarts wrote:
>>>>>>>>>>>>>>>> Op 18.mrt.2024 om 15:44 schreef olcott:
>>>>>>>>>>>>>>>>> On 3/18/2024 1:04 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>> On 3/17/24 10:22 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>> On 3/18/2024 12:11 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>> On 3/17/24 9:42 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>> On 3/17/2024 11:39 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>> On 3/17/24 9:00 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>> On 3/17/2024 10:32 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>> On 3/17/24 8:14 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>> On 3/17/2024 9:35 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/17/24 4:27 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/17/2024 12:37 PM, immibis wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 17/03/24 14:11, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/17/2024 12:22 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/16/24 10:04 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/17/2024 12:00 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/16/24 9:42 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/16/2024 11:28 PM, Richard Damon
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/16/24 9:13 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/16/2024 10:57 PM, Richard Damon
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/16/24 7:52 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/16/2024 9:43 PM, Richard Damon
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/16/24 5:50 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/16/2024 7:21 PM, Richard
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/16/24 8:29 AM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/15/2024 11:29 PM, Richard
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/15/24 8:45 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H(D,D) fails to make the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> required mistake of reporting
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> on what it does not see.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> But it DOES make a mistake,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> because it does answer the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> question correctly.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> You are just PROVING you think
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> lying is ok.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> You TOTALLY don't understand
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the meaning of truth.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> You are REALLY just a
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Pathological Liar, as you have
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> no concept of real truth,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> The original halt status
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> criteria has the impossible
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> requirement
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that H(D,D) must report on
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> behavior that it does not
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> actually see.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Requiring H to be clairvoyant
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> is an unreasonable requirement.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> *The criteria shown below
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> eliminate the requirement of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> clairvoyance*
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (a) 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 correctly simulates its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> input D until*
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Means H does a correct partial
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation of D until H correctly
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> matches the recursive
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation non-halting behavior
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> pattern.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> But turning out to be
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> impposible, doesn't make it
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> incorrect or invalid.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> *You seems to be ridiculously
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> disingenuous about the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> self-evident truth*
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> For every possible way that H can
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> be encoded and D(D) calls H(D,D)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> either H(D,D) aborts its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation or D(D) never stops
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> running.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> And you are incredably stupid to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> not see this doesn't prove what
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> you need it to.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Yes, if you define H to not abort,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the we get a non-haltig D(D), but
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H doesn't answwer.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> But, if you define H to abort, then,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> We see that you changed the subject
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> away from:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [Proof that H(D,D) meets its abort
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> criteria]
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Nope.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H is an algorithm that simulates its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> input and correctly
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> determines whether or not it needs to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> abort this simulation.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> That is all that this thread's H does.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> And what defines "Need"?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> It is the set of every implementation
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> of its spec:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (a) H(D,D) Simulate input.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (b) Determine if it needs to stop
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulating its input to prevent
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the simulated D(D) from never halting.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> And thus not a specific algorithm?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Again, HOW do you determine NEED?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> That is not an algorithmic step.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> We can only verify that in retrospect.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Do you fully understand the spec?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Yes, but I think not the way you do.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> To me, for H to NEED to abort its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation, that means that when giving
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the input to a correct simulator, that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulator will not halt.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Yes that is correct.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> You have just proven that H doesn't need
>>>>>>>>>>>>>>>>>>>>>>>>>>>> abort its simulation and the abort decision
>>>>>>>>>>>>>>>>>>>>>>>>>>>> is incorrect.
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> The head games of a Troll.
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> For every possible way that H can be encoded
>>>>>>>>>>>>>>>>>>>>>>>>>>> and D(D)
>>>>>>>>>>>>>>>>>>>>>>>>>>> calls H(D,D) either H(D,D) aborts its
>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation or D(D)
>>>>>>>>>>>>>>>>>>>>>>>>>>> never stops running.
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> Which prove NOTHING, as D varies with H, so no
>>>>>>>>>>>>>>>>>>>>>>>>>> D that was built with an H that aborts its
>>>>>>>>>>>>>>>>>>>>>>>>>> simulation has had its actual halting status
>>>>>>>>>>>>>>>>>>>>>>>>>> tested.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> *That merely changes the wording of the same
>>>>>>>>>>>>>>>>>>>>>>>>> truism*
>>>>>>>>>>>>>>>>>>>>>>>>> ∀H ∈ TM ∀D ∈ TMD such that
>>>>>>>>>>>>>>>>>>>>>>>>> H(D,D) simulates its input and
>>>>>>>>>>>>>>>>>>>>>>>>> D calls H(D,D) and
>>>>>>>>>>>>>>>>>>>>>>>>> H(D,D) does not abort its simulation
>>>>>>>>>>>>>>>>>>>>>>>>> necessitates simulated D(D) never stops running.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> Third times and still not a charm.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> All those D still use an H that doesn't abort
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> *You keep talking in circles, there are only two
>>>>>>>>>>>>>>>>>>>>>>> sets*
>>>>>>>>>>>>>>>>>>>>>>> ∀H ∈ TM ∀D ∈ TMD | (H(D,D) simulates its input
>>>>>>>>>>>>>>>>>>>>>>> and D calls H(D,D))
>>>>>>>>>>>>>>>>>>>>>>> (1) H(D,D) does not abort its simulation then
>>>>>>>>>>>>>>>>>>>>>>> simulated D(D) never stops running.
>>>>>>>>>>>>>>>>>>>>>>> (2) H(D,D) aborts its simulation then simulated
>>>>>>>>>>>>>>>>>>>>>>> D(D) stops running.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> And your top line says NOTHING about the Ds in set
>>>>>>>>>>>>>>>>>>>>>> (2), since nothing showed them not to run
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> but your (2) admitts that D(D) will stop running,
>>>>>>>>>>>>>>>>>>>>>> and thus the top level H didn't need to abort its
>>>>>>>>>>>>>>>>>>>>>> simulation.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> Do you understand that each H(D,D) must either
>>>>>>>>>>>>>>>>>>>>> abort or fail to abort?
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> And do you understand
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> Yes that is what I am asking. It seems that you don't
>>>>>>>>>>>>>>>>>>> understand
>>>>>>>>>>>>>>>>>>> the difference between X being a member of a set and
>>>>>>>>>>>>>>>>>>> X not being
>>>>>>>>>>>>>>>>>>> a member of a set. Very elemental set theory.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> And you seem to be trying to convientely forget that
>>>>>>>>>>>>>>>>>> each D that you talk about is DIFFERENT, base on the H
>>>>>>>>>>>>>>>>>> that it was designed to confound.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> *You keep talking in circles, there are only two sets*
>>>>>>>>>>>>>>>>> ∀H ∈ TM ∀D ∈ TMD | (H(D,D) simulates its input and D
>>>>>>>>>>>>>>>>> calls H(D,D))
>>>>>>>>>>>>>>>>> (1) H(D,D) does not abort its simulation then simulated
>>>>>>>>>>>>>>>>> D(D) never stops running.
>>>>>>>>>>>>>>>>> (2) H(D,D) aborts its simulation then simulated D(D)
>>>>>>>>>>>>>>>>> stops running.
>>>>>>>>>>>>>>>>> *By whatever means H(D,D) places itself in (2) then
>>>>>>>>>>>>>>>>> H(D,D) is correct*
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> By repeating yourself, you run in circles.
>>>>>>>>>>>>>>>> There are three possible categories of H functions:
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> 1. Hah, It aborts and reports halting.
>>>>>>>>>>>>>>>> 2. Han, It aborts and repeats non halting.
>>>>>>>>>>>>>>>> 3. Hss does not abort, but simply simulates.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> What H(D,D) reports is off-topic for this post.
>>>>>>>>>>>>>>> *We are only looking at this*
>>>>>>>>>>>>>>> [Proof that H(D,D) meets its abort criteria
>>>>>>>>>>>>>>> --self-evident truth--]
>>>>>>>>>>>>>>> *Thus H(D,D) aborts or H(D,D) fails to abort*
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Be clear in the naming. Is it Dan that is considered, or
>>>>>>>>>>>>>> Dss? Dss must be aborted, because is does not halt, but
>>>>>>>>>>>>>> Dan does halt and does not need to be aborted.
>>>>>>>>>>>>>
>>>>>>>>>>>>> *There are only two sets*
>>>>>>>>>>>>> ∀H ∈ TM ∀D ∈ TMD | (H(D,D) simulates its input and D calls
>>>>>>>>>>>>> H(D,D))
>>>>>>>>>>>>> (1) H(D,D) does not abort its simulation then simulated
>>>>>>>>>>>>> D(D) never stops running.
>>>>>>>>>>>>> (2) H(D,D) aborts its simulation then simulated D(D) stops
>>>>>>>>>>>>> running.
>>>>>>>>>>>>>
>>>>>>>>>>>>> (a) If simulating abort decider H correctly simulates its
>>>>>>>>>>>>> input D until H correctly determines that its simulated D
>>>>>>>>>>>>> would never stop running unless aborted...
>>>>>>>>>>>>>
>>>>>>>>>>>>> *Therefore*
>>>>>>>>>>>>> *Every element of (1) is incorrect and every element of (2)
>>>>>>>>>>>>> is correct*
>>>>>>>>>>>>> *Pathological thinking to make them both seem incorrect is
>>>>>>>>>>>>> incorrect*
>>>>>>>>>>>>>
>>>>>>>>>>>>>> So, Hss(Dss,Dss) should abort, but it does not.
>>>>>>>>>>>>>> and Han(Dan,Dan) should not abort, but it does.
>>>>>>>>>>>>>> The Hss that meets the abort criteria does not abort and
>>>>>>>>>>>>>> the Han that does not meet its abort criteria does abort.
>>>>>>>>>>>>>> So, both are wrong.
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> Is it Dan that is considered, or Dss? Dss must be aborted,
>>>>>>>>>>>> because is does not halt, but Dan does halt and does not
>>>>>>>>>>>> need to be aborted.
>>>>>>>>>>>
>>>>>>>>>>> *This is what those naming conventions derive*
>>>>>>>>>>> Everyone is saying that because H(D,D) did need to abort its
>>>>>>>>>>> simulation
>>>>>>>>>>> to prevent D(D) from infinite execution that this proves that
>>>>>>>>>>> it never
>>>>>>>>>>> needed to abort its simulation because it can rely on the
>>>>>>>>>>> fact that it
>>>>>>>>>>> already aborted its simulation thus never needed to abort it.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> You are almost there. If you stop naming all different H which
>>>>>>>>>> the same name and all different D with the same name, your
>>>>>>>>>> confusion may disappear.
>>>>>>>>>
>>>>>>>>> ∀H ∈ TM ∀D ∈ TMD | (H(D,D) simulates its input and D calls H(D,D))
>>>>>>>>> Every H in the above set must abort its simulated D(D).
>>>>>>>>>
>>>>>>>>>> Hss(Dss,Dss) should abort, but it does not.
>>>>>>>>>> and Han(Dan,Dan) should not abort, but it does.
>>>>>>>>>> The Hss that meets the abort criteria does not abort and the Han
>>>>>>>>>> that does not meet its abort criteria does abort. So, both are
>>>>>>>>>> wrong.
>>>>>>>>>>
>>>>>>>>
>>>>>>>> Olcott does not understand that if the H in the simulated D
>>>>>>>> aborts, then the simulating H should not abort
>>>>>>>
>>>>>>> *You are confused*
>>>>>>> If the H in the simulated D aborts then the directly executed H did
>>>>>>> not abort. Since the directly executed H sees one more execution
>>>>>>> trace then the simulated H then the H in the simulated D never
>>>>>>> aborts.
>>>>>>
>>>>>> Nope, YOU are confused If the H in the simulated D aborts,
>>>>>
>>>>> Then a dozen square circles are on sale at Walmart right now for
>>>>> $10.99
>>>>
>>>> Interesting, that you retort was to just blantently lie?
>>>>
>>>> When presented with FACTS, you respond with LIES.
>>>>
>>>> That just shows who you are.
>>>>
>>>>>
>>>>>> then the directly executed D MUST abort, or you are agreeing that
>>>>>> H's simulation is not correct.
>>>>>>
>>>>>
>>>>> In other words after we have been over this hundreds and hundreds
>>>>> of times it is still waaaayyy over your head that the executed H
>>>>> always
>>>>> sees exactly one more execution trace than the executed H?
>>>>
>>>> Do you really read your nonsense?
>>>>
>>>> How does x, "the executed H" see one more execution trace than x?
>>>>
>>>> That means you think that 1 + 1 = 1
>>>>
>>>>>
>>>>>> And no, the directed executed vesion of D see no more information
>>>>>> then the machine the simulated D represents,
>>>>>
>>>>> The simulated H can not see its own behavior where as its simulator
>>>>> can thus proving the simulator sees one more execution trace that
>>>>> its simulation.
>>>>
>>>> Nope, it may see one more then at the point the simulation reaches,
>>>
>>> Yes, finally. Thus the executed H(D,D) sees its abort criteria before
>>> any of the simulated ones ever would.
>>
>> Before the SIMULATION of the SIMULATED one does.
>>
>> The actual machine has finished before the simulation ever started
>> (since it halts)
> *H sees that D would keep repeating at machine address* [00001cfe]

On 3/19/2024 3:54 AM, Fred. Zwarts wrote:
> Op 18.mrt.2024 om 23:49 schreef olcott:
>> On 3/18/2024 5:37 PM, Fred. Zwarts wrote:
>>> Op 18.mrt.2024 om 23:25 schreef olcott:
>>>> On 3/18/2024 4:56 PM, Fred. Zwarts wrote:
>>>>> Op 18.mrt.2024 om 22:48 schreef olcott:
>>>>>> On 3/18/2024 4:38 PM, Fred. Zwarts wrote:
>>>>>>> Op 18.mrt.2024 om 22:18 schreef olcott:
>>>>>>>> On 3/18/2024 4:11 PM, Fred. Zwarts wrote:
>>>>>>>>> Op 18.mrt.2024 om 21:40 schreef olcott:
>>>>>>>>>> On 3/18/2024 3:30 PM, immibis wrote:
>>>>>>>>>>> On 18/03/24 21:20, olcott wrote:
>>>>>>>>>>>> On 3/18/2024 2:44 PM, Fred. Zwarts wrote:
>>>>>>>>>>>>> Op 18.mrt.2024 om 18:43 schreef olcott:
>>>>>>>>>>>>>> On 3/18/2024 10:11 AM, Fred. Zwarts wrote:
>>>>>>>>>>>>>>> Op 18.mrt.2024 om 15:44 schreef olcott:
>>>>>>>>>>>>>>>> On 3/18/2024 1:04 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>> On 3/17/24 10:22 PM, olcott wrote:
>>>>>>>>>>>>>>>>>> On 3/18/2024 12:11 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>> On 3/17/24 9:42 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>> On 3/17/2024 11:39 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>> On 3/17/24 9:00 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>> On 3/17/2024 10:32 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>> On 3/17/24 8:14 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>> On 3/17/2024 9:35 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>> On 3/17/24 4:27 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/17/2024 12:37 PM, immibis wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>> On 17/03/24 14:11, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/17/2024 12:22 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/16/24 10:04 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/17/2024 12:00 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/16/24 9:42 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/16/2024 11:28 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/16/24 9:13 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/16/2024 10:57 PM, Richard Damon
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/16/24 7:52 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/16/2024 9:43 PM, Richard Damon
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/16/24 5:50 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/16/2024 7:21 PM, Richard
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/16/24 8:29 AM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/15/2024 11:29 PM, Richard
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/15/24 8:45 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H(D,D) fails to make the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> required mistake of reporting
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> on what it does not see.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> But it DOES make a mistake,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> because it does answer the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> question correctly.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> You are just PROVING you think
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> lying is ok.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> You TOTALLY don't understand
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the meaning of truth.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> You are REALLY just a
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Pathological Liar, as you have
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> no concept of real truth,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> The original halt status
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> criteria has the impossible
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> requirement
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that H(D,D) must report on
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> behavior that it does not
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> actually see.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Requiring H to be clairvoyant is
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> an unreasonable requirement.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> *The criteria shown below
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> eliminate the requirement of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> clairvoyance*
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (a) 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 correctly simulates its input
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> D until*
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Means H does a correct partial
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation of D until H correctly
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> matches the recursive simulation
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> non-halting behavior pattern.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> But turning out to be impposible,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> doesn't make it incorrect or
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> invalid.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> *You seems to be ridiculously
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> disingenuous about the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> self-evident truth*
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> For every possible way that H can
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> be encoded and D(D) calls H(D,D)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> either H(D,D) aborts its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation or D(D) never stops
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> running.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> And you are incredably stupid to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> not see this doesn't prove what you
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> need it to.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Yes, if you define H to not abort,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the we get a non-haltig D(D), but H
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> doesn't answwer.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> But, if you define H to abort, then,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> We see that you changed the subject
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> away from:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [Proof that H(D,D) meets its abort
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> criteria]
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Nope.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H is an algorithm that simulates its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> input and correctly
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> determines whether or not it needs to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> abort this simulation.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> That is all that this thread's H does.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> And what defines "Need"?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> It is the set of every implementation of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> its spec:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (a) H(D,D) Simulate input.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (b) Determine if it needs to stop
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulating its input to prevent
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the simulated D(D) from never halting.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> And thus not a specific algorithm?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Again, HOW do you determine NEED?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> That is not an algorithmic step.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> We can only verify that in retrospect.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Do you fully understand the spec?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Yes, but I think not the way you do.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> To me, for H to NEED to abort its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation, that means that when giving the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> input to a correct simulator, that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulator will not halt.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> Yes that is correct.
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> You have just proven that H doesn't need
>>>>>>>>>>>>>>>>>>>>>>>>>>> abort its simulation and the abort decision
>>>>>>>>>>>>>>>>>>>>>>>>>>> is incorrect.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> The head games of a Troll.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> For every possible way that H can be encoded
>>>>>>>>>>>>>>>>>>>>>>>>>> and D(D)
>>>>>>>>>>>>>>>>>>>>>>>>>> calls H(D,D) either H(D,D) aborts its
>>>>>>>>>>>>>>>>>>>>>>>>>> simulation or D(D)
>>>>>>>>>>>>>>>>>>>>>>>>>> never stops running.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> Which prove NOTHING, as D varies with H, so no
>>>>>>>>>>>>>>>>>>>>>>>>> D that was built with an H that aborts its
>>>>>>>>>>>>>>>>>>>>>>>>> simulation has had its actual halting status
>>>>>>>>>>>>>>>>>>>>>>>>> tested.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> *That merely changes the wording of the same
>>>>>>>>>>>>>>>>>>>>>>>> truism*
>>>>>>>>>>>>>>>>>>>>>>>> ∀H ∈ TM ∀D ∈ TMD such that
>>>>>>>>>>>>>>>>>>>>>>>> H(D,D) simulates its input and
>>>>>>>>>>>>>>>>>>>>>>>> D calls H(D,D) and
>>>>>>>>>>>>>>>>>>>>>>>> H(D,D) does not abort its simulation
>>>>>>>>>>>>>>>>>>>>>>>> necessitates simulated D(D) never stops running.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> Third times and still not a charm.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> All those D still use an H that doesn't abort
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> *You keep talking in circles, there are only two
>>>>>>>>>>>>>>>>>>>>>> sets*
>>>>>>>>>>>>>>>>>>>>>> ∀H ∈ TM ∀D ∈ TMD | (H(D,D) simulates its input and
>>>>>>>>>>>>>>>>>>>>>> D calls H(D,D))
>>>>>>>>>>>>>>>>>>>>>> (1) H(D,D) does not abort its simulation then
>>>>>>>>>>>>>>>>>>>>>> simulated D(D) never stops running.
>>>>>>>>>>>>>>>>>>>>>> (2) H(D,D) aborts its simulation then simulated
>>>>>>>>>>>>>>>>>>>>>> D(D) stops running.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> And your top line says NOTHING about the Ds in set
>>>>>>>>>>>>>>>>>>>>> (2), since nothing showed them not to run
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> but your (2) admitts that D(D) will stop running,
>>>>>>>>>>>>>>>>>>>>> and thus the top level H didn't need to abort its
>>>>>>>>>>>>>>>>>>>>> simulation.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> Do you understand that each H(D,D) must either abort
>>>>>>>>>>>>>>>>>>>> or fail to abort?
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> And do you understand
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Yes that is what I am asking. It seems that you don't
>>>>>>>>>>>>>>>>>> understand
>>>>>>>>>>>>>>>>>> the difference between X being a member of a set and X
>>>>>>>>>>>>>>>>>> not being
>>>>>>>>>>>>>>>>>> a member of a set. Very elemental set theory.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> And you seem to be trying to convientely forget that
>>>>>>>>>>>>>>>>> each D that you talk about is DIFFERENT, base on the H
>>>>>>>>>>>>>>>>> that it was designed to confound.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> *You keep talking in circles, there are only two sets*
>>>>>>>>>>>>>>>> ∀H ∈ TM ∀D ∈ TMD | (H(D,D) simulates its input and D
>>>>>>>>>>>>>>>> calls H(D,D))
>>>>>>>>>>>>>>>> (1) H(D,D) does not abort its simulation then simulated
>>>>>>>>>>>>>>>> D(D) never stops running.
>>>>>>>>>>>>>>>> (2) H(D,D) aborts its simulation then simulated D(D)
>>>>>>>>>>>>>>>> stops running.
>>>>>>>>>>>>>>>> *By whatever means H(D,D) places itself in (2) then
>>>>>>>>>>>>>>>> H(D,D) is correct*
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> By repeating yourself, you run in circles.
>>>>>>>>>>>>>>> There are three possible categories of H functions:
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> 1. Hah, It aborts and reports halting.
>>>>>>>>>>>>>>> 2. Han, It aborts and repeats non halting.
>>>>>>>>>>>>>>> 3. Hss does not abort, but simply simulates.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> What H(D,D) reports is off-topic for this post.
>>>>>>>>>>>>>> *We are only looking at this*
>>>>>>>>>>>>>> [Proof that H(D,D) meets its abort criteria --self-evident
>>>>>>>>>>>>>> truth--]
>>>>>>>>>>>>>> *Thus H(D,D) aborts or H(D,D) fails to abort*
>>>>>>>>>>>>>>
>>>>>>>>>>>>>
>>>>>>>>>>>>> Be clear in the naming. Is it Dan that is considered, or
>>>>>>>>>>>>> Dss? Dss must be aborted, because is does not halt, but Dan
>>>>>>>>>>>>> does halt and does not need to be aborted.
>>>>>>>>>>>>
>>>>>>>>>>>> *There are only two sets*
>>>>>>>>>>>> ∀H ∈ TM ∀D ∈ TMD | (H(D,D) simulates its input and D calls
>>>>>>>>>>>> H(D,D))
>>>>>>>>>>>> (1) H(D,D) does not abort its simulation then simulated D(D)
>>>>>>>>>>>> never stops running.
>>>>>>>>>>>> (2) H(D,D) aborts its simulation then simulated D(D) stops
>>>>>>>>>>>> running.
>>>>>>>>>>>>
>>>>>>>>>>>> (a) If simulating abort decider H correctly simulates its
>>>>>>>>>>>> input D until H correctly determines that its simulated D
>>>>>>>>>>>> would never stop running unless aborted...
>>>>>>>>>>>>
>>>>>>>>>>>> *Therefore*
>>>>>>>>>>>> *Every element of (1) is incorrect and every element of (2)
>>>>>>>>>>>> is correct*
>>>>>>>>>>>> *Pathological thinking to make them both seem incorrect is
>>>>>>>>>>>> incorrect*
>>>>>>>>>>>>
>>>>>>>>>>>>> So, Hss(Dss,Dss) should abort, but it does not.
>>>>>>>>>>>>> and Han(Dan,Dan) should not abort, but it does.
>>>>>>>>>>>>> The Hss that meets the abort criteria does not abort and
>>>>>>>>>>>>> the Han that does not meet its abort criteria does abort.
>>>>>>>>>>>>> So, both are wrong.
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> Is it Dan that is considered, or Dss? Dss must be aborted,
>>>>>>>>>>> because is does not halt, but Dan does halt and does not need
>>>>>>>>>>> to be aborted.
>>>>>>>>>>
>>>>>>>>>> *This is what those naming conventions derive*
>>>>>>>>>> Everyone is saying that because H(D,D) did need to abort its
>>>>>>>>>> simulation
>>>>>>>>>> to prevent D(D) from infinite execution that this proves that
>>>>>>>>>> it never
>>>>>>>>>> needed to abort its simulation because it can rely on the fact
>>>>>>>>>> that it
>>>>>>>>>> already aborted its simulation thus never needed to abort it.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> You are almost there. If you stop naming all different H which
>>>>>>>>> the same name and all different D with the same name, your
>>>>>>>>> confusion may disappear.
>>>>>>>>
>>>>>>>> ∀H ∈ TM ∀D ∈ TMD | (H(D,D) simulates its input and D calls H(D,D))
>>>>>>>> Every H in the above set must abort its simulated D(D).
>>>>>>>>
>>>>>>>>> Hss(Dss,Dss) should abort, but it does not.
>>>>>>>>> and Han(Dan,Dan) should not abort, but it does.
>>>>>>>>> The Hss that meets the abort criteria does not abort and the Han
>>>>>>>>> that does not meet its abort criteria does abort. So, both are
>>>>>>>>> wrong.
>>>>>>>>>
>>>>>>>
>>>>>>> Olcott does not understand that if the H in the simulated D
>>>>>>> aborts, then the simulating H should not abort
>>>>>>
>>>>>> *You are confused*
>>>>>> If the H in the simulated D aborts then the directly executed H did
>>>>>> not abort. Since the directly executed H sees one more execution
>>>>>> trace then the simulated H then the H in the simulated D never
>>>>>> aborts.
>>>>>>
>>>>>
>>>>> No, Olcott told us that the simulating H aborts before it sees that
>>>>> the simulated D halts. It only sees that D calls H, but it does not
>>>>> see that the called H aborts, because the simulation stops at the
>>>>> call, which is too early.
>>>>>
>>>>
>>>> DD correctly simulated by HH cannot possibly reach past its
>>>> own first line, thus cannot possibly halt.
>>>
>>> Olcott does not understand that if the call to HH were correctly
>>> simulated, then this HH would abort its simulation and return and
>>> therefore DD would continue
>>
>> *When HH aborts its simulation DD immediately becomes 100%
>> totally dead along with the entire simulation chain. I don't
>> think that Richard understands this either.
>>
>
> Olcott does not understand that we are talking about a DD that contains
> a HH that aborts. He is constructing a problem, that does not exists,

On 3/19/24 7:56 AM, olcott wrote:
> On 3/19/2024 4:05 AM, Fred. Zwarts wrote:
>> Op 19.mrt.2024 om 05:37 schreef olcott:
>>> On 3/18/2024 11:23 PM, Richard Damon wrote:
>>>> On 3/18/24 8:53 PM, olcott wrote:
>>>>> On 3/18/2024 9:44 PM, Richard Damon wrote:
>>>>>> On 3/18/24 2:48 PM, olcott wrote:
>>>>>>> On 3/18/2024 4:38 PM, Fred. Zwarts wrote:
>>>>>>>> Op 18.mrt.2024 om 22:18 schreef olcott:
>>>>>>>>> On 3/18/2024 4:11 PM, Fred. Zwarts wrote:
>>>>>>>>>> Op 18.mrt.2024 om 21:40 schreef olcott:
>>>>>>>>>>> On 3/18/2024 3:30 PM, immibis wrote:
>>>>>>>>>>>> On 18/03/24 21:20, olcott wrote:
>>>>>>>>>>>>> On 3/18/2024 2:44 PM, Fred. Zwarts wrote:
>>>>>>>>>>>>>> Op 18.mrt.2024 om 18:43 schreef olcott:
>>>>>>>>>>>>>>> On 3/18/2024 10:11 AM, Fred. Zwarts wrote:
>>>>>>>>>>>>>>>> Op 18.mrt.2024 om 15:44 schreef olcott:
>>>>>>>>>>>>>>>>> On 3/18/2024 1:04 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>> On 3/17/24 10:22 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>> On 3/18/2024 12:11 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>> On 3/17/24 9:42 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>> On 3/17/2024 11:39 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>> On 3/17/24 9:00 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>> On 3/17/2024 10:32 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>> On 3/17/24 8:14 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>> On 3/17/2024 9:35 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/17/24 4:27 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/17/2024 12:37 PM, immibis wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 17/03/24 14:11, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/17/2024 12:22 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/16/24 10:04 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/17/2024 12:00 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/16/24 9:42 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/16/2024 11:28 PM, Richard Damon
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/16/24 9:13 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/16/2024 10:57 PM, Richard Damon
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/16/24 7:52 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/16/2024 9:43 PM, Richard Damon
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/16/24 5:50 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/16/2024 7:21 PM, Richard
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/16/24 8:29 AM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/15/2024 11:29 PM, Richard
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/15/24 8:45 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H(D,D) fails to make the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> required mistake of reporting
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> on what it does not see.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> But it DOES make a mistake,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> because it does answer the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> question correctly.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> You are just PROVING you think
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> lying is ok.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> You TOTALLY don't understand
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the meaning of truth.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> You are REALLY just a
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Pathological Liar, as you have
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> no concept of real truth,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> The original halt status
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> criteria has the impossible
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> requirement
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that H(D,D) must report on
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> behavior that it does not
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> actually see.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Requiring H to be clairvoyant
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> is an unreasonable requirement.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> *The criteria shown below
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> eliminate the requirement of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> clairvoyance*
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (a) 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 correctly simulates its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> input D until*
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Means H does a correct partial
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation of D until H correctly
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> matches the recursive
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation non-halting behavior
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> pattern.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> But turning out to be
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> impposible, doesn't make it
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> incorrect or invalid.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> *You seems to be ridiculously
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> disingenuous about the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> self-evident truth*
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> For every possible way that H can
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> be encoded and D(D) calls H(D,D)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> either H(D,D) aborts its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation or D(D) never stops
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> running.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> And you are incredably stupid to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> not see this doesn't prove what
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> you need it to.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Yes, if you define H to not abort,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the we get a non-haltig D(D), but
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H doesn't answwer.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> But, if you define H to abort, then,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> We see that you changed the subject
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> away from:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [Proof that H(D,D) meets its abort
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> criteria]
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Nope.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H is an algorithm that simulates its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> input and correctly
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> determines whether or not it needs to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> abort this simulation.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> That is all that this thread's H does.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> And what defines "Need"?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> It is the set of every implementation
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> of its spec:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (a) H(D,D) Simulate input.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (b) Determine if it needs to stop
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulating its input to prevent
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the simulated D(D) from never halting.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> And thus not a specific algorithm?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Again, HOW do you determine NEED?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> That is not an algorithmic step.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> We can only verify that in retrospect.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Do you fully understand the spec?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Yes, but I think not the way you do.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> To me, for H to NEED to abort its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation, that means that when giving
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the input to a correct simulator, that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulator will not halt.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Yes that is correct.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> You have just proven that H doesn't need
>>>>>>>>>>>>>>>>>>>>>>>>>>>> abort its simulation and the abort decision
>>>>>>>>>>>>>>>>>>>>>>>>>>>> is incorrect.
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> The head games of a Troll.
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> For every possible way that H can be encoded
>>>>>>>>>>>>>>>>>>>>>>>>>>> and D(D)
>>>>>>>>>>>>>>>>>>>>>>>>>>> calls H(D,D) either H(D,D) aborts its
>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation or D(D)
>>>>>>>>>>>>>>>>>>>>>>>>>>> never stops running.
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> Which prove NOTHING, as D varies with H, so no
>>>>>>>>>>>>>>>>>>>>>>>>>> D that was built with an H that aborts its
>>>>>>>>>>>>>>>>>>>>>>>>>> simulation has had its actual halting status
>>>>>>>>>>>>>>>>>>>>>>>>>> tested.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> *That merely changes the wording of the same
>>>>>>>>>>>>>>>>>>>>>>>>> truism*
>>>>>>>>>>>>>>>>>>>>>>>>> ∀H ∈ TM ∀D ∈ TMD such that
>>>>>>>>>>>>>>>>>>>>>>>>> H(D,D) simulates its input and
>>>>>>>>>>>>>>>>>>>>>>>>> D calls H(D,D) and
>>>>>>>>>>>>>>>>>>>>>>>>> H(D,D) does not abort its simulation
>>>>>>>>>>>>>>>>>>>>>>>>> necessitates simulated D(D) never stops running.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> Third times and still not a charm.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> All those D still use an H that doesn't abort
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> *You keep talking in circles, there are only two
>>>>>>>>>>>>>>>>>>>>>>> sets*
>>>>>>>>>>>>>>>>>>>>>>> ∀H ∈ TM ∀D ∈ TMD | (H(D,D) simulates its input
>>>>>>>>>>>>>>>>>>>>>>> and D calls H(D,D))
>>>>>>>>>>>>>>>>>>>>>>> (1) H(D,D) does not abort its simulation then
>>>>>>>>>>>>>>>>>>>>>>> simulated D(D) never stops running.
>>>>>>>>>>>>>>>>>>>>>>> (2) H(D,D) aborts its simulation then simulated
>>>>>>>>>>>>>>>>>>>>>>> D(D) stops running.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> And your top line says NOTHING about the Ds in set
>>>>>>>>>>>>>>>>>>>>>> (2), since nothing showed them not to run
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> but your (2) admitts that D(D) will stop running,
>>>>>>>>>>>>>>>>>>>>>> and thus the top level H didn't need to abort its
>>>>>>>>>>>>>>>>>>>>>> simulation.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> Do you understand that each H(D,D) must either
>>>>>>>>>>>>>>>>>>>>> abort or fail to abort?
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> And do you understand
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> Yes that is what I am asking. It seems that you don't
>>>>>>>>>>>>>>>>>>> understand
>>>>>>>>>>>>>>>>>>> the difference between X being a member of a set and
>>>>>>>>>>>>>>>>>>> X not being
>>>>>>>>>>>>>>>>>>> a member of a set. Very elemental set theory.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> And you seem to be trying to convientely forget that
>>>>>>>>>>>>>>>>>> each D that you talk about is DIFFERENT, base on the H
>>>>>>>>>>>>>>>>>> that it was designed to confound.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> *You keep talking in circles, there are only two sets*
>>>>>>>>>>>>>>>>> ∀H ∈ TM ∀D ∈ TMD | (H(D,D) simulates its input and D
>>>>>>>>>>>>>>>>> calls H(D,D))
>>>>>>>>>>>>>>>>> (1) H(D,D) does not abort its simulation then simulated
>>>>>>>>>>>>>>>>> D(D) never stops running.
>>>>>>>>>>>>>>>>> (2) H(D,D) aborts its simulation then simulated D(D)
>>>>>>>>>>>>>>>>> stops running.
>>>>>>>>>>>>>>>>> *By whatever means H(D,D) places itself in (2) then
>>>>>>>>>>>>>>>>> H(D,D) is correct*
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> By repeating yourself, you run in circles.
>>>>>>>>>>>>>>>> There are three possible categories of H functions:
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> 1. Hah, It aborts and reports halting.
>>>>>>>>>>>>>>>> 2. Han, It aborts and repeats non halting.
>>>>>>>>>>>>>>>> 3. Hss does not abort, but simply simulates.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> What H(D,D) reports is off-topic for this post.
>>>>>>>>>>>>>>> *We are only looking at this*
>>>>>>>>>>>>>>> [Proof that H(D,D) meets its abort criteria
>>>>>>>>>>>>>>> --self-evident truth--]
>>>>>>>>>>>>>>> *Thus H(D,D) aborts or H(D,D) fails to abort*
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Be clear in the naming. Is it Dan that is considered, or
>>>>>>>>>>>>>> Dss? Dss must be aborted, because is does not halt, but
>>>>>>>>>>>>>> Dan does halt and does not need to be aborted.
>>>>>>>>>>>>>
>>>>>>>>>>>>> *There are only two sets*
>>>>>>>>>>>>> ∀H ∈ TM ∀D ∈ TMD | (H(D,D) simulates its input and D calls
>>>>>>>>>>>>> H(D,D))
>>>>>>>>>>>>> (1) H(D,D) does not abort its simulation then simulated
>>>>>>>>>>>>> D(D) never stops running.
>>>>>>>>>>>>> (2) H(D,D) aborts its simulation then simulated D(D) stops
>>>>>>>>>>>>> running.
>>>>>>>>>>>>>
>>>>>>>>>>>>> (a) If simulating abort decider H correctly simulates its
>>>>>>>>>>>>> input D until H correctly determines that its simulated D
>>>>>>>>>>>>> would never stop running unless aborted...
>>>>>>>>>>>>>
>>>>>>>>>>>>> *Therefore*
>>>>>>>>>>>>> *Every element of (1) is incorrect and every element of (2)
>>>>>>>>>>>>> is correct*
>>>>>>>>>>>>> *Pathological thinking to make them both seem incorrect is
>>>>>>>>>>>>> incorrect*
>>>>>>>>>>>>>
>>>>>>>>>>>>>> So, Hss(Dss,Dss) should abort, but it does not.
>>>>>>>>>>>>>> and Han(Dan,Dan) should not abort, but it does.
>>>>>>>>>>>>>> The Hss that meets the abort criteria does not abort and
>>>>>>>>>>>>>> the Han that does not meet its abort criteria does abort.
>>>>>>>>>>>>>> So, both are wrong.
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> Is it Dan that is considered, or Dss? Dss must be aborted,
>>>>>>>>>>>> because is does not halt, but Dan does halt and does not
>>>>>>>>>>>> need to be aborted.
>>>>>>>>>>>
>>>>>>>>>>> *This is what those naming conventions derive*
>>>>>>>>>>> Everyone is saying that because H(D,D) did need to abort its
>>>>>>>>>>> simulation
>>>>>>>>>>> to prevent D(D) from infinite execution that this proves that
>>>>>>>>>>> it never
>>>>>>>>>>> needed to abort its simulation because it can rely on the
>>>>>>>>>>> fact that it
>>>>>>>>>>> already aborted its simulation thus never needed to abort it.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> You are almost there. If you stop naming all different H which
>>>>>>>>>> the same name and all different D with the same name, your
>>>>>>>>>> confusion may disappear.
>>>>>>>>>
>>>>>>>>> ∀H ∈ TM ∀D ∈ TMD | (H(D,D) simulates its input and D calls H(D,D))
>>>>>>>>> Every H in the above set must abort its simulated D(D).
>>>>>>>>>
>>>>>>>>>> Hss(Dss,Dss) should abort, but it does not.
>>>>>>>>>> and Han(Dan,Dan) should not abort, but it does.
>>>>>>>>>> The Hss that meets the abort criteria does not abort and the Han
>>>>>>>>>> that does not meet its abort criteria does abort. So, both are
>>>>>>>>>> wrong.
>>>>>>>>>>
>>>>>>>>
>>>>>>>> Olcott does not understand that if the H in the simulated D
>>>>>>>> aborts, then the simulating H should not abort
>>>>>>>
>>>>>>> *You are confused*
>>>>>>> If the H in the simulated D aborts then the directly executed H did
>>>>>>> not abort. Since the directly executed H sees one more execution
>>>>>>> trace then the simulated H then the H in the simulated D never
>>>>>>> aborts.
>>>>>>
>>>>>> Nope, YOU are confused If the H in the simulated D aborts,
>>>>>
>>>>> Then a dozen square circles are on sale at Walmart right now for
>>>>> $10.99
>>>>
>>>> Interesting, that you retort was to just blantently lie?
>>>>
>>>> When presented with FACTS, you respond with LIES.
>>>>
>>>> That just shows who you are.
>>>>
>>>>>
>>>>>> then the directly executed D MUST abort, or you are agreeing that
>>>>>> H's simulation is not correct.
>>>>>>
>>>>>
>>>>> In other words after we have been over this hundreds and hundreds
>>>>> of times it is still waaaayyy over your head that the executed H
>>>>> always
>>>>> sees exactly one more execution trace than the executed H?
>>>>
>>>> Do you really read your nonsense?
>>>>
>>>> How does x, "the executed H" see one more execution trace than x?
>>>>
>>>> That means you think that 1 + 1 = 1
>>>>
>>>>>
>>>>>> And no, the directed executed vesion of D see no more information
>>>>>> then the machine the simulated D represents,
>>>>>
>>>>> The simulated H can not see its own behavior where as its simulator
>>>>> can thus proving the simulator sees one more execution trace that
>>>>> its simulation.
>>>>
>>>> Nope, it may see one more then at the point the simulation reaches,
>>>
>>> Yes, finally. Thus the executed H(D,D) sees its abort criteria before
>>> any of the simulated ones ever would.
>>>
>>>> but the actual machine that is now being simulated did EVERYTHING
>>>> that it will do as soon as it was created,
>>>>
>>> No it is not true that x86 machines are oracle machines.
>>> https://en.wikipedia.org/wiki/Oracle_machine
>>>
>>>> You keep on makeing that mistake, confusing the simulation with what
>>>> actually happens.
>>>>
>>>>>
>>>>>> if H aborts the simulation before then, then H just doesn't get to
>>>>>> know what happens after that.
>>>>>>
>>>>>> I will point out, you almost NEVER actually look at the direct
>>>>>> execution of D(D), because it just proves that H isn't a correct
>>>>>> Halt Decider.
>>>>>>
>>>>>
>>>>> H(D,D) cannot rely on the behavior of D(D) after it has already
>>>>> aborted
>>>>> its simulation or it would never abort its simulation and D(D) would
>>>>> never stop running. This means that the executed H(D,D) see non
>>>>> halting
>>>>> behavior.
>>>>>
>>>>
>>>> Right, H is in a no-win pickle. (or its programmer is).
>>>
>>> Not at all. The requirement for clairvoyance is an incorrect
>>> requirement. H(D,D) cannot be correctly required to report on
>>> what it cannot see.
>>>
>>>> If we wait, we run into the issue that we may never answer. If we
>>>> abort, we don't know what answer to give.
>>>
>>> An abort decider would report on whether it aborted or not.
>>>
>>>> That is why the Halting Mapping turns out to be uncomputable.
>>>>
>>>
>>> *H(D,D) cannot be correctly required to report on what it cannot see*
>>>
>>
>> But H(D,D) cannot be allowed to choose what it want to see and what it
>> does not want to see. By aborting, it chooses to close it eyes and
>> therefore it does not see that D calls H, which aborts and returns. It
>> is not a matter of 'cannot see', but 'chooses to be blind for the facts'.
>>
>
> Can D correctly simulated by H terminate normally?

On 3/19/2024 3:49 AM, Mikko wrote:
> On 2024-03-18 14:44:22 +0000, olcott said:
>
>> On 3/18/2024 1:04 AM, Richard Damon wrote:
>>> On 3/17/24 10:22 PM, olcott wrote:
>>>> On 3/18/2024 12:11 AM, Richard Damon wrote:
>>>>> On 3/17/24 9:42 PM, olcott wrote:
>>>>>> On 3/17/2024 11:39 PM, Richard Damon wrote:
>>>>>>> On 3/17/24 9:00 PM, olcott wrote:
>>>>>>>> On 3/17/2024 10:32 PM, Richard Damon wrote:
>>>>>>>>> On 3/17/24 8:14 PM, olcott wrote:
>>>>>>>>>> On 3/17/2024 9:35 PM, Richard Damon wrote:
>>>>>>>>>>> On 3/17/24 4:27 PM, olcott wrote:
>>>>>>>>>>>> On 3/17/2024 12:37 PM, immibis wrote:
>>>>>>>>>>>>> On 17/03/24 14:11, olcott wrote:
>>>>>>>>>>>>>> On 3/17/2024 12:22 AM, Richard Damon wrote:
>>>>>>>>>>>>>>> On 3/16/24 10:04 PM, olcott wrote:
>>>>>>>>>>>>>>>> On 3/17/2024 12:00 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>> On 3/16/24 9:42 PM, olcott wrote:
>>>>>>>>>>>>>>>>>> On 3/16/2024 11:28 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>> On 3/16/24 9:13 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>> On 3/16/2024 10:57 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>> On 3/16/24 7:52 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>> On 3/16/2024 9:43 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>> On 3/16/24 5:50 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>> On 3/16/2024 7:21 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>> On 3/16/24 8:29 AM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/15/2024 11:29 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/15/24 8:45 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>> H(D,D) fails to make the required mistake of
>>>>>>>>>>>>>>>>>>>>>>>>>>>> reporting on what it does not see.
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> But it DOES make a mistake, because it does
>>>>>>>>>>>>>>>>>>>>>>>>>>> answer the question correctly.
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> You are just PROVING you think lying is ok.
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> You TOTALLY don't understand the meaning of
>>>>>>>>>>>>>>>>>>>>>>>>>>> truth.
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> You are REALLY just a Pathological Liar, as
>>>>>>>>>>>>>>>>>>>>>>>>>>> you have no concept of real truth,
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> The original halt status criteria has the
>>>>>>>>>>>>>>>>>>>>>>>>>> impossible requirement
>>>>>>>>>>>>>>>>>>>>>>>>>> that H(D,D) must report on behavior that it
>>>>>>>>>>>>>>>>>>>>>>>>>> does not actually see.
>>>>>>>>>>>>>>>>>>>>>>>>>> Requiring H to be clairvoyant is an
>>>>>>>>>>>>>>>>>>>>>>>>>> unreasonable requirement.
>>>>>>>>>>>>>>>>>>>>>>>>>> *The criteria shown below eliminate the
>>>>>>>>>>>>>>>>>>>>>>>>>> requirement of clairvoyance*
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> (a) 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 correctly simulates its input D until*
>>>>>>>>>>>>>>>>>>>>>>>>>> Means H does a correct partial simulation of D
>>>>>>>>>>>>>>>>>>>>>>>>>> until H correctly
>>>>>>>>>>>>>>>>>>>>>>>>>> matches the recursive simulation non-halting
>>>>>>>>>>>>>>>>>>>>>>>>>> behavior pattern.
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> But turning out to be impposible, doesn't make
>>>>>>>>>>>>>>>>>>>>>>>>> it incorrect or invalid.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> *You seems to be ridiculously disingenuous about
>>>>>>>>>>>>>>>>>>>>>>>> the self-evident truth*
>>>>>>>>>>>>>>>>>>>>>>>> For every possible way that H can be encoded and
>>>>>>>>>>>>>>>>>>>>>>>> D(D) calls H(D,D) either H(D,D) aborts its
>>>>>>>>>>>>>>>>>>>>>>>> simulation or D(D) never stops running.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> And you are incredably stupid to not see this
>>>>>>>>>>>>>>>>>>>>>>> doesn't prove what you need it to.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> Yes, if you define H to not abort, the we get a
>>>>>>>>>>>>>>>>>>>>>>> non-haltig D(D), but H doesn't answwer.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> But, if you define H to abort, then,
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> We see that you changed the subject away from:
>>>>>>>>>>>>>>>>>>>>>> [Proof that H(D,D) meets its abort criteria]
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> Nope.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> H is an algorithm that simulates its input and
>>>>>>>>>>>>>>>>>>>> correctly
>>>>>>>>>>>>>>>>>>>> determines whether or not it needs to abort this
>>>>>>>>>>>>>>>>>>>> simulation.
>>>>>>>>>>>>>>>>>>>> That is all that this thread's H does.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> And what defines "Need"?
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> It is the set of every implementation of its spec:
>>>>>>>>>>>>>>>>>> (a) H(D,D) Simulate input.
>>>>>>>>>>>>>>>>>> (b) Determine if it needs to stop simulating its input
>>>>>>>>>>>>>>>>>> to prevent
>>>>>>>>>>>>>>>>>> the simulated D(D) from never halting.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> And thus not a specific algorithm?
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Again, HOW do you determine NEED?
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> That is not an algorithmic step.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> We can only verify that in retrospect.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Do you fully understand the spec?
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Yes, but I think not the way you do.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> To me, for H to NEED to abort its simulation, that means
>>>>>>>>>>>>>>> that when giving the input to a correct simulator, that
>>>>>>>>>>>>>>> simulator will not halt.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Yes that is correct.
>>>>>>>>>>>>>
>>>>>>>>>>>>> You have just proven that H doesn't need abort its
>>>>>>>>>>>>> simulation and the abort decision is incorrect.
>>>>>>>>>>>>
>>>>>>>>>>>> The head games of a Troll.
>>>>>>>>>>>>
>>>>>>>>>>>> For every possible way that H can be encoded and D(D)
>>>>>>>>>>>> calls H(D,D) either H(D,D) aborts its simulation or D(D)
>>>>>>>>>>>> never stops running.
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> Which prove NOTHING, as D varies with H, so no D that was
>>>>>>>>>>> built with an H that aborts its simulation has had its actual
>>>>>>>>>>> halting status tested.
>>>>>>>>>>
>>>>>>>>>> *That merely changes the wording of the same truism*
>>>>>>>>>> ∀H ∈ TM ∀D ∈ TMD such that
>>>>>>>>>> H(D,D) simulates its input and
>>>>>>>>>> D calls H(D,D) and
>>>>>>>>>> H(D,D) does not abort its simulation
>>>>>>>>>> necessitates simulated D(D) never stops running.
>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> Third times and still not a charm.
>>>>>>>>>
>>>>>>>>> All those D still use an H that doesn't abort
>>>>>>>>
>>>>>>>> *You keep talking in circles, there are only two sets*
>>>>>>>> ∀H ∈ TM ∀D ∈ TMD | (H(D,D) simulates its input and D calls H(D,D))
>>>>>>>> (1) H(D,D) does not abort its simulation then simulated D(D)
>>>>>>>> never stops running.
>>>>>>>> (2) H(D,D) aborts its simulation then simulated D(D) stops running.
>>>>>>>>
>>>>>>>>
>>>>>>>
>>>>>>> And your top line says NOTHING about the Ds in set (2), since
>>>>>>> nothing showed them not to run
>>>>>>>
>>>>>>> but your (2) admitts that D(D) will stop running, and thus the
>>>>>>> top level H didn't need to abort its simulation.
>>>>>>>
>>>>>>
>>>>>> Do you understand that each H(D,D) must either abort or fail to
>>>>>> abort?
>>>>>>
>>>>>>
>>>>>
>>>>> And do you understand
>>>>
>>>> Yes that is what I am asking. It seems that you don't understand
>>>> the difference between X being a member of a set and X not being
>>>> a member of a set. Very elemental set theory.
>>>
>>> And you seem to be trying to convientely forget that each D that you
>>> talk about is DIFFERENT, base on the H that it was designed to confound.
>>
>> *You keep talking in circles, there are only two sets*
>> ∀H ∈ TM ∀D ∈ TMD | (H(D,D) simulates its input and D calls H(D,D))
>> (1) H(D,D) does not abort its simulation then simulated D(D) never
>> stops running.
>> (2) H(D,D) aborts its simulation then simulated D(D) stops running.
>> *By whatever means H(D,D) places itself in (2) then H(D,D) is correct*
>
> It may be correct about aborting. That does not make it correct
> about anything else.
>

On 3/19/24 7:37 AM, olcott wrote:
> On 3/19/2024 4:24 AM, Mikko wrote:
>> On 2024-03-19 04:37:02 +0000, olcott said:
>> A requirement is correct if it is possible to determine
>> whether the requirement is satisfied in a particular case.
>>
>
> Any requirement that ever requires the logically impossible is never
> correct in these cases where it requires the logically impossible.
>

Source, or it isn't true.

Remember, If H(D,D) returns false, then it is verified TRUE that D(D)
Halts, so there WAS an answer to the actual question.

The question, "Does the Computation described by the input Halt?" makes
no presumption or requirement that the decider it is being given to can
or will actually give the right answer.

So, the requirements of the question are NOT "logically impossible".

Yes, if you CHANGE the question, to a different question, like you want
to, to add that requirement, you do get an invalid question, but that is
just a STRAWMAN ARGUMENT.

That you do it, just shows your ignorance about how to do correct logic.

On 3/19/2024 3:45 AM, Mikko wrote:
> On 2024-03-19 02:46:27 +0000, olcott said:
>
>> On 3/18/2024 8:45 PM, immibis wrote:
>>> On 19/03/24 00:43, olcott wrote:
>>>> On 3/18/2024 6:34 PM, immibis wrote:
>>>>> On 19/03/24 00:13, olcott wrote:
>>>>>> On 3/18/2024 11:18 AM, immibis wrote:
>>>>>>> On 18/03/24 06:25, olcott wrote:
>>>>>>>> On 3/17/2024 11:50 PM, immibis wrote:
>>>>>>>>> On 18/03/24 05:42, olcott wrote:
>>>>>>>>>> Do you understand that each H(D,D) must either abort or fail
>>>>>>>>>> to abort?
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> Do you understand that D(D) halts?
>>>>>>>>
>>>>>>>> *We are talking about the abort criteria*
>>>>>>>
>>>>>>> Strawman deception. H is a halt decider if it tells whether the
>>>>>>> direct execution of its input would halt.
>>>>>>
>>>>>> If you can't even understand that H is a correct abort decider then
>>>>>> you can't understand anything else that requires the prerequisite
>>>>>> knowledge that H is a correct abort decider.
>>>>>>
>>>>>
>>>>> Strawman deception. It is the halting problem, not the Olcott abort
>>>>> problem.
>>>>
>>>> You can learn calculus without the basis of algebra. You can't learn
>>>> simulating halt deciders without the basis of simulating abort
>>>> deciders.
>>>
>>> When are you going to extend this theory of simulating abort deciders
>>> so that it solves the halting problem instead of merely solving the
>>> Olcott abort problem?
>>
>> *Here are the two key steps to that*
>> (1) Abort deciders correctly decide to abort.
>> (2) The halting problem requires the correct answer to an incorrect
>> question thus must be redefined.
>
> If a problem is redefined it must also be renamed. The original name
> is already reserved.
>

OK then when H(D,D) reports on the actual behavior of its actual
input this is called the corrected halting problem. The original
halting problem is now called the erroneous halting problem.
We can call it the Naive halting problem like ZFC did to set theory.

Alternatively H(D,D) can reject inputs that must be aborted because
these inputs specify a pathological relationship to their decider.

--
Copyright 2024 Olcott "Talent hits a target no one else can hit; Genius
hits a target no one else can see." Arthur Schopenhauer

Op 19.mrt.2024 om 15:56 schreef olcott:
> On 3/19/2024 4:05 AM, Fred. Zwarts wrote:
>> Op 19.mrt.2024 om 05:37 schreef olcott:
>>> On 3/18/2024 11:23 PM, Richard Damon wrote:
>>>> On 3/18/24 8:53 PM, olcott wrote:
>>>>> On 3/18/2024 9:44 PM, Richard Damon wrote:
>>>>>> On 3/18/24 2:48 PM, olcott wrote:
>>>>>>> On 3/18/2024 4:38 PM, Fred. Zwarts wrote:
>>>>>>>> Op 18.mrt.2024 om 22:18 schreef olcott:
>>>>>>>>> On 3/18/2024 4:11 PM, Fred. Zwarts wrote:
>>>>>>>>>> Op 18.mrt.2024 om 21:40 schreef olcott:
>>>>>>>>>>> On 3/18/2024 3:30 PM, immibis wrote:
>>>>>>>>>>>> On 18/03/24 21:20, olcott wrote:
>>>>>>>>>>>>> On 3/18/2024 2:44 PM, Fred. Zwarts wrote:
>>>>>>>>>>>>>> Op 18.mrt.2024 om 18:43 schreef olcott:
>>>>>>>>>>>>>>> On 3/18/2024 10:11 AM, Fred. Zwarts wrote:
>>>>>>>>>>>>>>>> Op 18.mrt.2024 om 15:44 schreef olcott:
>>>>>>>>>>>>>>>>> On 3/18/2024 1:04 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>> On 3/17/24 10:22 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>> On 3/18/2024 12:11 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>> On 3/17/24 9:42 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>> On 3/17/2024 11:39 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>> On 3/17/24 9:00 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>> On 3/17/2024 10:32 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>> On 3/17/24 8:14 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>> On 3/17/2024 9:35 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/17/24 4:27 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/17/2024 12:37 PM, immibis wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 17/03/24 14:11, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/17/2024 12:22 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/16/24 10:04 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/17/2024 12:00 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/16/24 9:42 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/16/2024 11:28 PM, Richard Damon
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/16/24 9:13 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/16/2024 10:57 PM, Richard Damon
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/16/24 7:52 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/16/2024 9:43 PM, Richard Damon
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/16/24 5:50 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/16/2024 7:21 PM, Richard
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/16/24 8:29 AM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/15/2024 11:29 PM, Richard
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/15/24 8:45 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H(D,D) fails to make the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> required mistake of reporting
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> on what it does not see.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> But it DOES make a mistake,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> because it does answer the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> question correctly.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> You are just PROVING you think
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> lying is ok.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> You TOTALLY don't understand
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the meaning of truth.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> You are REALLY just a
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Pathological Liar, as you have
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> no concept of real truth,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> The original halt status
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> criteria has the impossible
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> requirement
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that H(D,D) must report on
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> behavior that it does not
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> actually see.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Requiring H to be clairvoyant
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> is an unreasonable requirement.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> *The criteria shown below
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> eliminate the requirement of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> clairvoyance*
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (a) 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 correctly simulates its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> input D until*
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Means H does a correct partial
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation of D until H correctly
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> matches the recursive
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation non-halting behavior
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> pattern.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> But turning out to be
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> impposible, doesn't make it
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> incorrect or invalid.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> *You seems to be ridiculously
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> disingenuous about the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> self-evident truth*
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> For every possible way that H can
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> be encoded and D(D) calls H(D,D)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> either H(D,D) aborts its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation or D(D) never stops
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> running.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> And you are incredably stupid to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> not see this doesn't prove what
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> you need it to.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Yes, if you define H to not abort,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the we get a non-haltig D(D), but
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H doesn't answwer.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> But, if you define H to abort, then,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> We see that you changed the subject
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> away from:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [Proof that H(D,D) meets its abort
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> criteria]
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Nope.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H is an algorithm that simulates its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> input and correctly
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> determines whether or not it needs to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> abort this simulation.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> That is all that this thread's H does.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> And what defines "Need"?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> It is the set of every implementation
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> of its spec:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (a) H(D,D) Simulate input.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (b) Determine if it needs to stop
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulating its input to prevent
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the simulated D(D) from never halting.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> And thus not a specific algorithm?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Again, HOW do you determine NEED?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> That is not an algorithmic step.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> We can only verify that in retrospect.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Do you fully understand the spec?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Yes, but I think not the way you do.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> To me, for H to NEED to abort its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation, that means that when giving
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the input to a correct simulator, that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulator will not halt.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Yes that is correct.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> You have just proven that H doesn't need
>>>>>>>>>>>>>>>>>>>>>>>>>>>> abort its simulation and the abort decision
>>>>>>>>>>>>>>>>>>>>>>>>>>>> is incorrect.
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> The head games of a Troll.
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> For every possible way that H can be encoded
>>>>>>>>>>>>>>>>>>>>>>>>>>> and D(D)
>>>>>>>>>>>>>>>>>>>>>>>>>>> calls H(D,D) either H(D,D) aborts its
>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation or D(D)
>>>>>>>>>>>>>>>>>>>>>>>>>>> never stops running.
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> Which prove NOTHING, as D varies with H, so no
>>>>>>>>>>>>>>>>>>>>>>>>>> D that was built with an H that aborts its
>>>>>>>>>>>>>>>>>>>>>>>>>> simulation has had its actual halting status
>>>>>>>>>>>>>>>>>>>>>>>>>> tested.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> *That merely changes the wording of the same
>>>>>>>>>>>>>>>>>>>>>>>>> truism*
>>>>>>>>>>>>>>>>>>>>>>>>> ∀H ∈ TM ∀D ∈ TMD such that
>>>>>>>>>>>>>>>>>>>>>>>>> H(D,D) simulates its input and
>>>>>>>>>>>>>>>>>>>>>>>>> D calls H(D,D) and
>>>>>>>>>>>>>>>>>>>>>>>>> H(D,D) does not abort its simulation
>>>>>>>>>>>>>>>>>>>>>>>>> necessitates simulated D(D) never stops running.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> Third times and still not a charm.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> All those D still use an H that doesn't abort
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> *You keep talking in circles, there are only two
>>>>>>>>>>>>>>>>>>>>>>> sets*
>>>>>>>>>>>>>>>>>>>>>>> ∀H ∈ TM ∀D ∈ TMD | (H(D,D) simulates its input
>>>>>>>>>>>>>>>>>>>>>>> and D calls H(D,D))
>>>>>>>>>>>>>>>>>>>>>>> (1) H(D,D) does not abort its simulation then
>>>>>>>>>>>>>>>>>>>>>>> simulated D(D) never stops running.
>>>>>>>>>>>>>>>>>>>>>>> (2) H(D,D) aborts its simulation then simulated
>>>>>>>>>>>>>>>>>>>>>>> D(D) stops running.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> And your top line says NOTHING about the Ds in set
>>>>>>>>>>>>>>>>>>>>>> (2), since nothing showed them not to run
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> but your (2) admitts that D(D) will stop running,
>>>>>>>>>>>>>>>>>>>>>> and thus the top level H didn't need to abort its
>>>>>>>>>>>>>>>>>>>>>> simulation.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> Do you understand that each H(D,D) must either
>>>>>>>>>>>>>>>>>>>>> abort or fail to abort?
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> And do you understand
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> Yes that is what I am asking. It seems that you don't
>>>>>>>>>>>>>>>>>>> understand
>>>>>>>>>>>>>>>>>>> the difference between X being a member of a set and
>>>>>>>>>>>>>>>>>>> X not being
>>>>>>>>>>>>>>>>>>> a member of a set. Very elemental set theory.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> And you seem to be trying to convientely forget that
>>>>>>>>>>>>>>>>>> each D that you talk about is DIFFERENT, base on the H
>>>>>>>>>>>>>>>>>> that it was designed to confound.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> *You keep talking in circles, there are only two sets*
>>>>>>>>>>>>>>>>> ∀H ∈ TM ∀D ∈ TMD | (H(D,D) simulates its input and D
>>>>>>>>>>>>>>>>> calls H(D,D))
>>>>>>>>>>>>>>>>> (1) H(D,D) does not abort its simulation then simulated
>>>>>>>>>>>>>>>>> D(D) never stops running.
>>>>>>>>>>>>>>>>> (2) H(D,D) aborts its simulation then simulated D(D)
>>>>>>>>>>>>>>>>> stops running.
>>>>>>>>>>>>>>>>> *By whatever means H(D,D) places itself in (2) then
>>>>>>>>>>>>>>>>> H(D,D) is correct*
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> By repeating yourself, you run in circles.
>>>>>>>>>>>>>>>> There are three possible categories of H functions:
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> 1. Hah, It aborts and reports halting.
>>>>>>>>>>>>>>>> 2. Han, It aborts and repeats non halting.
>>>>>>>>>>>>>>>> 3. Hss does not abort, but simply simulates.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> What H(D,D) reports is off-topic for this post.
>>>>>>>>>>>>>>> *We are only looking at this*
>>>>>>>>>>>>>>> [Proof that H(D,D) meets its abort criteria
>>>>>>>>>>>>>>> --self-evident truth--]
>>>>>>>>>>>>>>> *Thus H(D,D) aborts or H(D,D) fails to abort*
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Be clear in the naming. Is it Dan that is considered, or
>>>>>>>>>>>>>> Dss? Dss must be aborted, because is does not halt, but
>>>>>>>>>>>>>> Dan does halt and does not need to be aborted.
>>>>>>>>>>>>>
>>>>>>>>>>>>> *There are only two sets*
>>>>>>>>>>>>> ∀H ∈ TM ∀D ∈ TMD | (H(D,D) simulates its input and D calls
>>>>>>>>>>>>> H(D,D))
>>>>>>>>>>>>> (1) H(D,D) does not abort its simulation then simulated
>>>>>>>>>>>>> D(D) never stops running.
>>>>>>>>>>>>> (2) H(D,D) aborts its simulation then simulated D(D) stops
>>>>>>>>>>>>> running.
>>>>>>>>>>>>>
>>>>>>>>>>>>> (a) If simulating abort decider H correctly simulates its
>>>>>>>>>>>>> input D until H correctly determines that its simulated D
>>>>>>>>>>>>> would never stop running unless aborted...
>>>>>>>>>>>>>
>>>>>>>>>>>>> *Therefore*
>>>>>>>>>>>>> *Every element of (1) is incorrect and every element of (2)
>>>>>>>>>>>>> is correct*
>>>>>>>>>>>>> *Pathological thinking to make them both seem incorrect is
>>>>>>>>>>>>> incorrect*
>>>>>>>>>>>>>
>>>>>>>>>>>>>> So, Hss(Dss,Dss) should abort, but it does not.
>>>>>>>>>>>>>> and Han(Dan,Dan) should not abort, but it does.
>>>>>>>>>>>>>> The Hss that meets the abort criteria does not abort and
>>>>>>>>>>>>>> the Han that does not meet its abort criteria does abort.
>>>>>>>>>>>>>> So, both are wrong.
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> Is it Dan that is considered, or Dss? Dss must be aborted,
>>>>>>>>>>>> because is does not halt, but Dan does halt and does not
>>>>>>>>>>>> need to be aborted.
>>>>>>>>>>>
>>>>>>>>>>> *This is what those naming conventions derive*
>>>>>>>>>>> Everyone is saying that because H(D,D) did need to abort its
>>>>>>>>>>> simulation
>>>>>>>>>>> to prevent D(D) from infinite execution that this proves that
>>>>>>>>>>> it never
>>>>>>>>>>> needed to abort its simulation because it can rely on the
>>>>>>>>>>> fact that it
>>>>>>>>>>> already aborted its simulation thus never needed to abort it.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> You are almost there. If you stop naming all different H which
>>>>>>>>>> the same name and all different D with the same name, your
>>>>>>>>>> confusion may disappear.
>>>>>>>>>
>>>>>>>>> ∀H ∈ TM ∀D ∈ TMD | (H(D,D) simulates its input and D calls H(D,D))
>>>>>>>>> Every H in the above set must abort its simulated D(D).
>>>>>>>>>
>>>>>>>>>> Hss(Dss,Dss) should abort, but it does not.
>>>>>>>>>> and Han(Dan,Dan) should not abort, but it does.
>>>>>>>>>> The Hss that meets the abort criteria does not abort and the Han
>>>>>>>>>> that does not meet its abort criteria does abort. So, both are
>>>>>>>>>> wrong.
>>>>>>>>>>
>>>>>>>>
>>>>>>>> Olcott does not understand that if the H in the simulated D
>>>>>>>> aborts, then the simulating H should not abort
>>>>>>>
>>>>>>> *You are confused*
>>>>>>> If the H in the simulated D aborts then the directly executed H did
>>>>>>> not abort. Since the directly executed H sees one more execution
>>>>>>> trace then the simulated H then the H in the simulated D never
>>>>>>> aborts.
>>>>>>
>>>>>> Nope, YOU are confused If the H in the simulated D aborts,
>>>>>
>>>>> Then a dozen square circles are on sale at Walmart right now for
>>>>> $10.99
>>>>
>>>> Interesting, that you retort was to just blantently lie?
>>>>
>>>> When presented with FACTS, you respond with LIES.
>>>>
>>>> That just shows who you are.
>>>>
>>>>>
>>>>>> then the directly executed D MUST abort, or you are agreeing that
>>>>>> H's simulation is not correct.
>>>>>>
>>>>>
>>>>> In other words after we have been over this hundreds and hundreds
>>>>> of times it is still waaaayyy over your head that the executed H
>>>>> always
>>>>> sees exactly one more execution trace than the executed H?
>>>>
>>>> Do you really read your nonsense?
>>>>
>>>> How does x, "the executed H" see one more execution trace than x?
>>>>
>>>> That means you think that 1 + 1 = 1
>>>>
>>>>>
>>>>>> And no, the directed executed vesion of D see no more information
>>>>>> then the machine the simulated D represents,
>>>>>
>>>>> The simulated H can not see its own behavior where as its simulator
>>>>> can thus proving the simulator sees one more execution trace that
>>>>> its simulation.
>>>>
>>>> Nope, it may see one more then at the point the simulation reaches,
>>>
>>> Yes, finally. Thus the executed H(D,D) sees its abort criteria before
>>> any of the simulated ones ever would.
>>>
>>>> but the actual machine that is now being simulated did EVERYTHING
>>>> that it will do as soon as it was created,
>>>>
>>> No it is not true that x86 machines are oracle machines.
>>> https://en.wikipedia.org/wiki/Oracle_machine
>>>
>>>> You keep on makeing that mistake, confusing the simulation with what
>>>> actually happens.
>>>>
>>>>>
>>>>>> if H aborts the simulation before then, then H just doesn't get to
>>>>>> know what happens after that.
>>>>>>
>>>>>> I will point out, you almost NEVER actually look at the direct
>>>>>> execution of D(D), because it just proves that H isn't a correct
>>>>>> Halt Decider.
>>>>>>
>>>>>
>>>>> H(D,D) cannot rely on the behavior of D(D) after it has already
>>>>> aborted
>>>>> its simulation or it would never abort its simulation and D(D) would
>>>>> never stop running. This means that the executed H(D,D) see non
>>>>> halting
>>>>> behavior.
>>>>>
>>>>
>>>> Right, H is in a no-win pickle. (or its programmer is).
>>>
>>> Not at all. The requirement for clairvoyance is an incorrect
>>> requirement. H(D,D) cannot be correctly required to report on
>>> what it cannot see.
>>>
>>>> If we wait, we run into the issue that we may never answer. If we
>>>> abort, we don't know what answer to give.
>>>
>>> An abort decider would report on whether it aborted or not.
>>>
>>>> That is why the Halting Mapping turns out to be uncomputable.
>>>>
>>>
>>> *H(D,D) cannot be correctly required to report on what it cannot see*
>>>
>>
>> But H(D,D) cannot be allowed to choose what it want to see and what it
>> does not want to see. By aborting, it chooses to close it eyes and
>> therefore it does not see that D calls H, which aborts and returns. It
>> is not a matter of 'cannot see', but 'chooses to be blind for the facts'.
>>
>
> Can D correctly simulated by H terminate normally?
> 01 int D(ptr x)  // ptr is pointer to int function
> 02 {
> 03   int Halt_Status = H(x, x);
> 04   if (Halt_Status)
> 05     HERE: goto HERE;
> 06   return Halt_Status;
> 07 }
> 08
> 09 void main()
> 10 {
> 11   H(D,D);
> 12 }
>
> *Execution Trace*
> Line 11: main() invokes H(D,D);
>
> *keeps repeating* (unless aborted)
> Line 03: simulated D(D) invokes simulated H(D,D) that simulates D(D)
>
> *Simulation invariant*
> D correctly simulated by H cannot possibly reach past its own line 03.
>
> H: Begin Simulation   Execution Trace Stored at:113075
> Address_of_H:1522
>
>  machine   stack     stack     machine    assembly
>  address   address   data      code       language
>  ========  ========  ========  =========  =============
> [00001cf2][00113061][00113065] 55         push ebp       ; enter D(D)
> [00001cf3][00113061][00113065] 8bec       mov ebp,esp
> [00001cf5][0011305d][00103031] 51         push ecx
> [00001cf6][0011305d][00103031] 8b4508     mov eax,[ebp+08]
> [00001cf9][00113059][00001cf2] 50         push eax       ; push D
> [00001cfa][00113059][00001cf2] 8b4d08     mov ecx,[ebp+08]
> [00001cfd][00113055][00001cf2] 51         push ecx       ; push D
> [00001cfe][00113051][00001d03] e81ff8ffff call 00001522  ; call H(D,D)
> H: Recursive Simulation Detected Simulation Stopped
>                           H(D,D) returns 0 to main()
>
> It is the case that the simulated D(D) can't possibly reach its
> final instruction and terminate normally, thus can't possibly halt.
>
> Unless H(D,D) sees that its input can't possibly halt and aborts
> its simulation on that basis then the executed D(D) also never halts.
>

On 3/19/24 8:27 AM, olcott wrote:
> On 3/19/2024 3:49 AM, Mikko wrote:
>> On 2024-03-18 14:44:22 +0000, olcott said:
>>
>>> On 3/18/2024 1:04 AM, Richard Damon wrote:
>>>> On 3/17/24 10:22 PM, olcott wrote:
>>>>> On 3/18/2024 12:11 AM, Richard Damon wrote:
>>>>>> On 3/17/24 9:42 PM, olcott wrote:
>>>>>>> On 3/17/2024 11:39 PM, Richard Damon wrote:
>>>>>>>> On 3/17/24 9:00 PM, olcott wrote:
>>>>>>>>> On 3/17/2024 10:32 PM, Richard Damon wrote:
>>>>>>>>>> On 3/17/24 8:14 PM, olcott wrote:
>>>>>>>>>>> On 3/17/2024 9:35 PM, Richard Damon wrote:
>>>>>>>>>>>> On 3/17/24 4:27 PM, olcott wrote:
>>>>>>>>>>>>> On 3/17/2024 12:37 PM, immibis wrote:
>>>>>>>>>>>>>> On 17/03/24 14:11, olcott wrote:
>>>>>>>>>>>>>>> On 3/17/2024 12:22 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>> On 3/16/24 10:04 PM, olcott wrote:
>>>>>>>>>>>>>>>>> On 3/17/2024 12:00 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>> On 3/16/24 9:42 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>> On 3/16/2024 11:28 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>> On 3/16/24 9:13 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>> On 3/16/2024 10:57 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>> On 3/16/24 7:52 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>> On 3/16/2024 9:43 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>> On 3/16/24 5:50 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>> On 3/16/2024 7:21 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/16/24 8:29 AM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/15/2024 11:29 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/15/24 8:45 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H(D,D) fails to make the required mistake
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> of reporting on what it does not see.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> But it DOES make a mistake, because it does
>>>>>>>>>>>>>>>>>>>>>>>>>>>> answer the question correctly.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> You are just PROVING you think lying is ok.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> You TOTALLY don't understand the meaning of
>>>>>>>>>>>>>>>>>>>>>>>>>>>> truth.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> You are REALLY just a Pathological Liar, as
>>>>>>>>>>>>>>>>>>>>>>>>>>>> you have no concept of real truth,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> The original halt status criteria has the
>>>>>>>>>>>>>>>>>>>>>>>>>>> impossible requirement
>>>>>>>>>>>>>>>>>>>>>>>>>>> that H(D,D) must report on behavior that it
>>>>>>>>>>>>>>>>>>>>>>>>>>> does not actually see.
>>>>>>>>>>>>>>>>>>>>>>>>>>> Requiring H to be clairvoyant is an
>>>>>>>>>>>>>>>>>>>>>>>>>>> unreasonable requirement.
>>>>>>>>>>>>>>>>>>>>>>>>>>> *The criteria shown below eliminate the
>>>>>>>>>>>>>>>>>>>>>>>>>>> requirement of clairvoyance*
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> (a) 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 correctly simulates its input D until*
>>>>>>>>>>>>>>>>>>>>>>>>>>> Means H does a correct partial simulation of
>>>>>>>>>>>>>>>>>>>>>>>>>>> D until H correctly
>>>>>>>>>>>>>>>>>>>>>>>>>>> matches the recursive simulation non-halting
>>>>>>>>>>>>>>>>>>>>>>>>>>> behavior pattern.
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> But turning out to be impposible, doesn't make
>>>>>>>>>>>>>>>>>>>>>>>>>> it incorrect or invalid.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> *You seems to be ridiculously disingenuous
>>>>>>>>>>>>>>>>>>>>>>>>> about the self-evident truth*
>>>>>>>>>>>>>>>>>>>>>>>>> For every possible way that H can be encoded
>>>>>>>>>>>>>>>>>>>>>>>>> and D(D) calls H(D,D) either H(D,D) aborts its
>>>>>>>>>>>>>>>>>>>>>>>>> simulation or D(D) never stops running.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> And you are incredably stupid to not see this
>>>>>>>>>>>>>>>>>>>>>>>> doesn't prove what you need it to.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> Yes, if you define H to not abort, the we get a
>>>>>>>>>>>>>>>>>>>>>>>> non-haltig D(D), but H doesn't answwer.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> But, if you define H to abort, then,
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> We see that you changed the subject away from:
>>>>>>>>>>>>>>>>>>>>>>> [Proof that H(D,D) meets its abort criteria]
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> Nope.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> H is an algorithm that simulates its input and
>>>>>>>>>>>>>>>>>>>>> correctly
>>>>>>>>>>>>>>>>>>>>> determines whether or not it needs to abort this
>>>>>>>>>>>>>>>>>>>>> simulation.
>>>>>>>>>>>>>>>>>>>>> That is all that this thread's H does.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> And what defines "Need"?
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> It is the set of every implementation of its spec:
>>>>>>>>>>>>>>>>>>> (a) H(D,D) Simulate input.
>>>>>>>>>>>>>>>>>>> (b) Determine if it needs to stop simulating its
>>>>>>>>>>>>>>>>>>> input to prevent
>>>>>>>>>>>>>>>>>>> the simulated D(D) from never halting.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> And thus not a specific algorithm?
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Again, HOW do you determine NEED?
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> That is not an algorithmic step.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> We can only verify that in retrospect.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Do you fully understand the spec?
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Yes, but I think not the way you do.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> To me, for H to NEED to abort its simulation, that means
>>>>>>>>>>>>>>>> that when giving the input to a correct simulator, that
>>>>>>>>>>>>>>>> simulator will not halt.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Yes that is correct.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> You have just proven that H doesn't need abort its
>>>>>>>>>>>>>> simulation and the abort decision is incorrect.
>>>>>>>>>>>>>
>>>>>>>>>>>>> The head games of a Troll.
>>>>>>>>>>>>>
>>>>>>>>>>>>> For every possible way that H can be encoded and D(D)
>>>>>>>>>>>>> calls H(D,D) either H(D,D) aborts its simulation or D(D)
>>>>>>>>>>>>> never stops running.
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> Which prove NOTHING, as D varies with H, so no D that was
>>>>>>>>>>>> built with an H that aborts its simulation has had its
>>>>>>>>>>>> actual halting status tested.
>>>>>>>>>>>
>>>>>>>>>>> *That merely changes the wording of the same truism*
>>>>>>>>>>> ∀H ∈ TM ∀D ∈ TMD such that
>>>>>>>>>>> H(D,D) simulates its input and
>>>>>>>>>>> D calls H(D,D) and
>>>>>>>>>>> H(D,D) does not abort its simulation
>>>>>>>>>>> necessitates simulated D(D) never stops running.
>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> Third times and still not a charm.
>>>>>>>>>>
>>>>>>>>>> All those D still use an H that doesn't abort
>>>>>>>>>
>>>>>>>>> *You keep talking in circles, there are only two sets*
>>>>>>>>> ∀H ∈ TM ∀D ∈ TMD | (H(D,D) simulates its input and D calls H(D,D))
>>>>>>>>> (1) H(D,D) does not abort its simulation then simulated D(D)
>>>>>>>>> never stops running.
>>>>>>>>> (2) H(D,D) aborts its simulation then simulated D(D) stops
>>>>>>>>> running.
>>>>>>>>>
>>>>>>>>>
>>>>>>>>
>>>>>>>> And your top line says NOTHING about the Ds in set (2), since
>>>>>>>> nothing showed them not to run
>>>>>>>>
>>>>>>>> but your (2) admitts that D(D) will stop running, and thus the
>>>>>>>> top level H didn't need to abort its simulation.
>>>>>>>>
>>>>>>>
>>>>>>> Do you understand that each H(D,D) must either abort or fail to
>>>>>>> abort?
>>>>>>>
>>>>>>>
>>>>>>
>>>>>> And do you understand
>>>>>
>>>>> Yes that is what I am asking. It seems that you don't understand
>>>>> the difference between X being a member of a set and X not being
>>>>> a member of a set. Very elemental set theory.
>>>>
>>>> And you seem to be trying to convientely forget that each D that you
>>>> talk about is DIFFERENT, base on the H that it was designed to
>>>> confound.
>>>
>>> *You keep talking in circles, there are only two sets*
>>> ∀H ∈ TM ∀D ∈ TMD | (H(D,D) simulates its input and D calls H(D,D))
>>> (1) H(D,D) does not abort its simulation then simulated D(D) never
>>> stops running.
>>> (2) H(D,D) aborts its simulation then simulated D(D) stops running.
>>> *By whatever means H(D,D) places itself in (2) then H(D,D) is correct*
>>
>> It may be correct about aborting. That does not make it correct
>> about anything else.
>>
>
> When H(D,D) is correct about aborting this proves that H(D,D)
> was correct that its input specified non-terminating behavior
> otherwise H(D,D) could not possibly be correct about aborting.
>
>

On 3/19/2024 3:39 AM, Mikko wrote:
> On 2024-03-18 23:02:18 +0000, olcott said:
>
>> On 3/18/2024 6:26 AM, Mikko wrote:
>>> On 2024-03-18 03:07:18 +0000, olcott said:
>>>
>>>> On 3/17/2024 9:35 PM, Richard Damon wrote:
>>>>> On 3/17/24 4:27 PM, olcott wrote:
>>>>>> On 3/17/2024 12:37 PM, immibis wrote:
>>>>>>> On 17/03/24 14:11, olcott wrote:
>>>>>>>> On 3/17/2024 12:22 AM, Richard Damon wrote:
>>>>>>>>> On 3/16/24 10:04 PM, olcott wrote:
>>>>>>>>>> On 3/17/2024 12:00 AM, Richard Damon wrote:
>>>>>>>>>>> On 3/16/24 9:42 PM, olcott wrote:
>>>>>>>>>>>> On 3/16/2024 11:28 PM, Richard Damon wrote:
>>>>>>>>>>>>> On 3/16/24 9:13 PM, olcott wrote:
>>>>>>>>>>>>>> On 3/16/2024 10:57 PM, Richard Damon wrote:
>>>>>>>>>>>>>>> On 3/16/24 7:52 PM, olcott wrote:
>>>>>>>>>>>>>>>> On 3/16/2024 9:43 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>> On 3/16/24 5:50 PM, olcott wrote:
>>>>>>>>>>>>>>>>>> On 3/16/2024 7:21 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>> On 3/16/24 8:29 AM, olcott wrote:
>>>>>>>>>>>>>>>>>>>> On 3/15/2024 11:29 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>> On 3/15/24 8:45 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>> H(D,D) fails to make the required mistake of
>>>>>>>>>>>>>>>>>>>>>> reporting on what it does not see.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> But it DOES make a mistake, because it does answer
>>>>>>>>>>>>>>>>>>>>> the question correctly.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> You are just PROVING you think lying is ok.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> You TOTALLY don't understand the meaning of truth.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> You are REALLY just a Pathological Liar, as you
>>>>>>>>>>>>>>>>>>>>> have no concept of real truth,
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> The original halt status criteria has the impossible
>>>>>>>>>>>>>>>>>>>> requirement
>>>>>>>>>>>>>>>>>>>> that H(D,D) must report on behavior that it does not
>>>>>>>>>>>>>>>>>>>> actually see.
>>>>>>>>>>>>>>>>>>>> Requiring H to be clairvoyant is an unreasonable
>>>>>>>>>>>>>>>>>>>> requirement.
>>>>>>>>>>>>>>>>>>>> *The criteria shown below eliminate the requirement
>>>>>>>>>>>>>>>>>>>> of clairvoyance*
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> (a) 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 correctly simulates its input D until*
>>>>>>>>>>>>>>>>>>>> Means H does a correct partial simulation of D until
>>>>>>>>>>>>>>>>>>>> H correctly
>>>>>>>>>>>>>>>>>>>> matches the recursive simulation non-halting
>>>>>>>>>>>>>>>>>>>> behavior pattern.
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> But turning out to be impposible, doesn't make it
>>>>>>>>>>>>>>>>>>> incorrect or invalid.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> *You seems to be ridiculously disingenuous about the
>>>>>>>>>>>>>>>>>> self-evident truth*
>>>>>>>>>>>>>>>>>> For every possible way that H can be encoded and D(D)
>>>>>>>>>>>>>>>>>> calls H(D,D) either H(D,D) aborts its simulation or
>>>>>>>>>>>>>>>>>> D(D) never stops running.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> And you are incredably stupid to not see this doesn't
>>>>>>>>>>>>>>>>> prove what you need it to.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> Yes, if you define H to not abort, the we get a
>>>>>>>>>>>>>>>>> non-haltig D(D), but H doesn't answwer.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> But, if you define H to abort, then,
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> We see that you changed the subject away from:
>>>>>>>>>>>>>>>> [Proof that H(D,D) meets its abort criteria]
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> Nope.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> H is an algorithm that simulates its input and correctly
>>>>>>>>>>>>>> determines whether or not it needs to abort this simulation.
>>>>>>>>>>>>>> That is all that this thread's H does.
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>> And what defines "Need"?
>>>>>>>>>>>>>
>>>>>>>>>>>> It is the set of every implementation of its spec:
>>>>>>>>>>>> (a) H(D,D) Simulate input.
>>>>>>>>>>>> (b) Determine if it needs to stop simulating its input to
>>>>>>>>>>>> prevent
>>>>>>>>>>>> the simulated D(D) from never halting.
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> And thus not a specific algorithm?
>>>>>>>>>>>
>>>>>>>>>>> Again, HOW do you determine NEED?
>>>>>>>>>>>
>>>>>>>>>>> That is not an algorithmic step.
>>>>>>>>>>>
>>>>>>>>>>> We can only verify that in retrospect.
>>>>>>>>>>
>>>>>>>>>> Do you fully understand the spec?
>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> Yes, but I think not the way you do.
>>>>>>>>>
>>>>>>>>> To me, for H to NEED to abort its simulation, that means that
>>>>>>>>> when giving the input to a correct simulator, that simulator
>>>>>>>>> will not halt.
>>>>>>>>>
>>>>>>>> Yes that is correct.
>>>>>>>
>>>>>>> You have just proven that H doesn't need abort its simulation and
>>>>>>> the abort decision is incorrect.
>>>>>>
>>>>>> The head games of a Troll.
>>>>>>
>>>>>> For every possible way that H can be encoded and D(D)
>>>>>> calls H(D,D) either H(D,D) aborts its simulation or D(D)
>>>>>> never stops running.
>>>>>>
>>>>>
>>>>> Which prove NOTHING, as D varies with H, so no D that was built
>>>>> with an H that aborts its simulation has had its actual halting
>>>>> status tested.
>>>>>
>>>>
>>>> *That merely changes the wording of the same truism*
>>>> ∀H ∀D such that H(D,D) simulates its input and D calls H(D,D)
>>>> H(D,D) does not abort its simulation necessitates simulated D(D)
>>>> never stops running.
>>>
>>> You should restrict your H so that any H that simulates D(D) forever
>>> is excluded, as simulating forver makes it a non-decider.
>>>
>>
>> I do yet so far everyone says that they believe this is impossible
>> so I have to go back a few steps and prove that it is possible.
>
> In logic any well defined expressible condition is allowed, even
> one that is impossible to evaluate.
>

On 3/19/24 8:34 AM, olcott wrote:
> On 3/19/2024 3:45 AM, Mikko wrote:
>> On 2024-03-19 02:46:27 +0000, olcott said:
>>
>>> On 3/18/2024 8:45 PM, immibis wrote:
>>>> On 19/03/24 00:43, olcott wrote:
>>>>> On 3/18/2024 6:34 PM, immibis wrote:
>>>>>> On 19/03/24 00:13, olcott wrote:
>>>>>>> On 3/18/2024 11:18 AM, immibis wrote:
>>>>>>>> On 18/03/24 06:25, olcott wrote:
>>>>>>>>> On 3/17/2024 11:50 PM, immibis wrote:
>>>>>>>>>> On 18/03/24 05:42, olcott wrote:
>>>>>>>>>>> Do you understand that each H(D,D) must either abort or fail
>>>>>>>>>>> to abort?
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> Do you understand that D(D) halts?
>>>>>>>>>
>>>>>>>>> *We are talking about the abort criteria*
>>>>>>>>
>>>>>>>> Strawman deception. H is a halt decider if it tells whether the
>>>>>>>> direct execution of its input would halt.
>>>>>>>
>>>>>>> If you can't even understand that H is a correct abort decider then
>>>>>>> you can't understand anything else that requires the prerequisite
>>>>>>> knowledge that H is a correct abort decider.
>>>>>>>
>>>>>>
>>>>>> Strawman deception. It is the halting problem, not the Olcott
>>>>>> abort problem.
>>>>>
>>>>> You can learn calculus without the basis of algebra. You can't learn
>>>>> simulating halt deciders without the basis of simulating abort
>>>>> deciders.
>>>>
>>>> When are you going to extend this theory of simulating abort
>>>> deciders so that it solves the halting problem instead of merely
>>>> solving the Olcott abort problem?
>>>
>>> *Here are the two key steps to that*
>>> (1) Abort deciders correctly decide to abort.
>>> (2) The halting problem requires the correct answer to an incorrect
>>> question thus must be redefined.
>>
>> If a problem is redefined it must also be renamed. The original name
>> is already reserved.
>>
>
> OK then when H(D,D) reports on the actual behavior of its actual
> input this is called the corrected halting problem. The original
> halting problem is now called the erroneous halting problem.
> We can call it the Naive halting problem like ZFC did to set theory.
>
> Alternatively H(D,D) can reject inputs that must be aborted because
> these inputs specify a pathological relationship to their decider.
>

Except that your H doesn't report on the ACTUAL BEHAVIOR of its input,
because that behavior is what the computation described by the input does.

The behaviour you are trying to look at is the ERRONEOUS one, as it
looks at the behavior of a computation that isn't the actual computation
described to the decider, but one altered to use a different sub-machine.

And, the inputs do NOT present a pathological relationship to the
decider they are given to, they a designed, VALIDLY, to contradict one
specific decide, not one the "own" (but maybe you could say the pwn it)

So, your definitions are just proved to b illogical and worthless.

And your "Correct Reasoning" to be based on truly INCORRECT reasoning,
because you have shown yourself to not understand a bit about how logic
works.

On 3/19/24 8:23 AM, olcott wrote:
> On 3/19/2024 3:54 AM, Fred. Zwarts wrote:
>> Op 18.mrt.2024 om 23:49 schreef olcott:
>>> On 3/18/2024 5:37 PM, Fred. Zwarts wrote:
>>>> Op 18.mrt.2024 om 23:25 schreef olcott:
>>>>> On 3/18/2024 4:56 PM, Fred. Zwarts wrote:
>>>>>> Op 18.mrt.2024 om 22:48 schreef olcott:
>>>>>>> On 3/18/2024 4:38 PM, Fred. Zwarts wrote:
>>>>>>>> Op 18.mrt.2024 om 22:18 schreef olcott:
>>>>>>>>> On 3/18/2024 4:11 PM, Fred. Zwarts wrote:
>>>>>>>>>> Op 18.mrt.2024 om 21:40 schreef olcott:
>>>>>>>>>>> On 3/18/2024 3:30 PM, immibis wrote:
>>>>>>>>>>>> On 18/03/24 21:20, olcott wrote:
>>>>>>>>>>>>> On 3/18/2024 2:44 PM, Fred. Zwarts wrote:
>>>>>>>>>>>>>> Op 18.mrt.2024 om 18:43 schreef olcott:
>>>>>>>>>>>>>>> On 3/18/2024 10:11 AM, Fred. Zwarts wrote:
>>>>>>>>>>>>>>>> Op 18.mrt.2024 om 15:44 schreef olcott:
>>>>>>>>>>>>>>>>> On 3/18/2024 1:04 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>> On 3/17/24 10:22 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>> On 3/18/2024 12:11 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>> On 3/17/24 9:42 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>> On 3/17/2024 11:39 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>> On 3/17/24 9:00 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>> On 3/17/2024 10:32 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>> On 3/17/24 8:14 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>> On 3/17/2024 9:35 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/17/24 4:27 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/17/2024 12:37 PM, immibis wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 17/03/24 14:11, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/17/2024 12:22 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/16/24 10:04 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/17/2024 12:00 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/16/24 9:42 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/16/2024 11:28 PM, Richard Damon
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/16/24 9:13 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/16/2024 10:57 PM, Richard Damon
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/16/24 7:52 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/16/2024 9:43 PM, Richard Damon
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/16/24 5:50 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/16/2024 7:21 PM, Richard
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/16/24 8:29 AM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/15/2024 11:29 PM, Richard
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/15/24 8:45 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H(D,D) fails to make the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> required mistake of reporting
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> on what it does not see.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> But it DOES make a mistake,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> because it does answer the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> question correctly.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> You are just PROVING you think
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> lying is ok.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> You TOTALLY don't understand
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the meaning of truth.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> You are REALLY just a
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Pathological Liar, as you have
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> no concept of real truth,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> The original halt status
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> criteria has the impossible
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> requirement
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that H(D,D) must report on
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> behavior that it does not
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> actually see.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Requiring H to be clairvoyant
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> is an unreasonable requirement.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> *The criteria shown below
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> eliminate the requirement of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> clairvoyance*
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (a) 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 correctly simulates its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> input D until*
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Means H does a correct partial
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation of D until H correctly
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> matches the recursive
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation non-halting behavior
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> pattern.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> But turning out to be
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> impposible, doesn't make it
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> incorrect or invalid.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> *You seems to be ridiculously
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> disingenuous about the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> self-evident truth*
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> For every possible way that H can
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> be encoded and D(D) calls H(D,D)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> either H(D,D) aborts its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation or D(D) never stops
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> running.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> And you are incredably stupid to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> not see this doesn't prove what
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> you need it to.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Yes, if you define H to not abort,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the we get a non-haltig D(D), but
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H doesn't answwer.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> But, if you define H to abort, then,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> We see that you changed the subject
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> away from:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [Proof that H(D,D) meets its abort
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> criteria]
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Nope.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H is an algorithm that simulates its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> input and correctly
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> determines whether or not it needs to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> abort this simulation.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> That is all that this thread's H does.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> And what defines "Need"?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> It is the set of every implementation
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> of its spec:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (a) H(D,D) Simulate input.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (b) Determine if it needs to stop
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulating its input to prevent
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the simulated D(D) from never halting.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> And thus not a specific algorithm?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Again, HOW do you determine NEED?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> That is not an algorithmic step.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> We can only verify that in retrospect.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Do you fully understand the spec?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Yes, but I think not the way you do.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> To me, for H to NEED to abort its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation, that means that when giving
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the input to a correct simulator, that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulator will not halt.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Yes that is correct.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> You have just proven that H doesn't need
>>>>>>>>>>>>>>>>>>>>>>>>>>>> abort its simulation and the abort decision
>>>>>>>>>>>>>>>>>>>>>>>>>>>> is incorrect.
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> The head games of a Troll.
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> For every possible way that H can be encoded
>>>>>>>>>>>>>>>>>>>>>>>>>>> and D(D)
>>>>>>>>>>>>>>>>>>>>>>>>>>> calls H(D,D) either H(D,D) aborts its
>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation or D(D)
>>>>>>>>>>>>>>>>>>>>>>>>>>> never stops running.
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> Which prove NOTHING, as D varies with H, so no
>>>>>>>>>>>>>>>>>>>>>>>>>> D that was built with an H that aborts its
>>>>>>>>>>>>>>>>>>>>>>>>>> simulation has had its actual halting status
>>>>>>>>>>>>>>>>>>>>>>>>>> tested.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> *That merely changes the wording of the same
>>>>>>>>>>>>>>>>>>>>>>>>> truism*
>>>>>>>>>>>>>>>>>>>>>>>>> ∀H ∈ TM ∀D ∈ TMD such that
>>>>>>>>>>>>>>>>>>>>>>>>> H(D,D) simulates its input and
>>>>>>>>>>>>>>>>>>>>>>>>> D calls H(D,D) and
>>>>>>>>>>>>>>>>>>>>>>>>> H(D,D) does not abort its simulation
>>>>>>>>>>>>>>>>>>>>>>>>> necessitates simulated D(D) never stops running.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> Third times and still not a charm.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> All those D still use an H that doesn't abort
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> *You keep talking in circles, there are only two
>>>>>>>>>>>>>>>>>>>>>>> sets*
>>>>>>>>>>>>>>>>>>>>>>> ∀H ∈ TM ∀D ∈ TMD | (H(D,D) simulates its input
>>>>>>>>>>>>>>>>>>>>>>> and D calls H(D,D))
>>>>>>>>>>>>>>>>>>>>>>> (1) H(D,D) does not abort its simulation then
>>>>>>>>>>>>>>>>>>>>>>> simulated D(D) never stops running.
>>>>>>>>>>>>>>>>>>>>>>> (2) H(D,D) aborts its simulation then simulated
>>>>>>>>>>>>>>>>>>>>>>> D(D) stops running.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> And your top line says NOTHING about the Ds in set
>>>>>>>>>>>>>>>>>>>>>> (2), since nothing showed them not to run
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> but your (2) admitts that D(D) will stop running,
>>>>>>>>>>>>>>>>>>>>>> and thus the top level H didn't need to abort its
>>>>>>>>>>>>>>>>>>>>>> simulation.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> Do you understand that each H(D,D) must either
>>>>>>>>>>>>>>>>>>>>> abort or fail to abort?
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> And do you understand
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> Yes that is what I am asking. It seems that you don't
>>>>>>>>>>>>>>>>>>> understand
>>>>>>>>>>>>>>>>>>> the difference between X being a member of a set and
>>>>>>>>>>>>>>>>>>> X not being
>>>>>>>>>>>>>>>>>>> a member of a set. Very elemental set theory.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> And you seem to be trying to convientely forget that
>>>>>>>>>>>>>>>>>> each D that you talk about is DIFFERENT, base on the H
>>>>>>>>>>>>>>>>>> that it was designed to confound.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> *You keep talking in circles, there are only two sets*
>>>>>>>>>>>>>>>>> ∀H ∈ TM ∀D ∈ TMD | (H(D,D) simulates its input and D
>>>>>>>>>>>>>>>>> calls H(D,D))
>>>>>>>>>>>>>>>>> (1) H(D,D) does not abort its simulation then simulated
>>>>>>>>>>>>>>>>> D(D) never stops running.
>>>>>>>>>>>>>>>>> (2) H(D,D) aborts its simulation then simulated D(D)
>>>>>>>>>>>>>>>>> stops running.
>>>>>>>>>>>>>>>>> *By whatever means H(D,D) places itself in (2) then
>>>>>>>>>>>>>>>>> H(D,D) is correct*
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> By repeating yourself, you run in circles.
>>>>>>>>>>>>>>>> There are three possible categories of H functions:
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> 1. Hah, It aborts and reports halting.
>>>>>>>>>>>>>>>> 2. Han, It aborts and repeats non halting.
>>>>>>>>>>>>>>>> 3. Hss does not abort, but simply simulates.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> What H(D,D) reports is off-topic for this post.
>>>>>>>>>>>>>>> *We are only looking at this*
>>>>>>>>>>>>>>> [Proof that H(D,D) meets its abort criteria
>>>>>>>>>>>>>>> --self-evident truth--]
>>>>>>>>>>>>>>> *Thus H(D,D) aborts or H(D,D) fails to abort*
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Be clear in the naming. Is it Dan that is considered, or
>>>>>>>>>>>>>> Dss? Dss must be aborted, because is does not halt, but
>>>>>>>>>>>>>> Dan does halt and does not need to be aborted.
>>>>>>>>>>>>>
>>>>>>>>>>>>> *There are only two sets*
>>>>>>>>>>>>> ∀H ∈ TM ∀D ∈ TMD | (H(D,D) simulates its input and D calls
>>>>>>>>>>>>> H(D,D))
>>>>>>>>>>>>> (1) H(D,D) does not abort its simulation then simulated
>>>>>>>>>>>>> D(D) never stops running.
>>>>>>>>>>>>> (2) H(D,D) aborts its simulation then simulated D(D) stops
>>>>>>>>>>>>> running.
>>>>>>>>>>>>>
>>>>>>>>>>>>> (a) If simulating abort decider H correctly simulates its
>>>>>>>>>>>>> input D until H correctly determines that its simulated D
>>>>>>>>>>>>> would never stop running unless aborted...
>>>>>>>>>>>>>
>>>>>>>>>>>>> *Therefore*
>>>>>>>>>>>>> *Every element of (1) is incorrect and every element of (2)
>>>>>>>>>>>>> is correct*
>>>>>>>>>>>>> *Pathological thinking to make them both seem incorrect is
>>>>>>>>>>>>> incorrect*
>>>>>>>>>>>>>
>>>>>>>>>>>>>> So, Hss(Dss,Dss) should abort, but it does not.
>>>>>>>>>>>>>> and Han(Dan,Dan) should not abort, but it does.
>>>>>>>>>>>>>> The Hss that meets the abort criteria does not abort and
>>>>>>>>>>>>>> the Han that does not meet its abort criteria does abort.
>>>>>>>>>>>>>> So, both are wrong.
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> Is it Dan that is considered, or Dss? Dss must be aborted,
>>>>>>>>>>>> because is does not halt, but Dan does halt and does not
>>>>>>>>>>>> need to be aborted.
>>>>>>>>>>>
>>>>>>>>>>> *This is what those naming conventions derive*
>>>>>>>>>>> Everyone is saying that because H(D,D) did need to abort its
>>>>>>>>>>> simulation
>>>>>>>>>>> to prevent D(D) from infinite execution that this proves that
>>>>>>>>>>> it never
>>>>>>>>>>> needed to abort its simulation because it can rely on the
>>>>>>>>>>> fact that it
>>>>>>>>>>> already aborted its simulation thus never needed to abort it.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> You are almost there. If you stop naming all different H which
>>>>>>>>>> the same name and all different D with the same name, your
>>>>>>>>>> confusion may disappear.
>>>>>>>>>
>>>>>>>>> ∀H ∈ TM ∀D ∈ TMD | (H(D,D) simulates its input and D calls H(D,D))
>>>>>>>>> Every H in the above set must abort its simulated D(D).
>>>>>>>>>
>>>>>>>>>> Hss(Dss,Dss) should abort, but it does not.
>>>>>>>>>> and Han(Dan,Dan) should not abort, but it does.
>>>>>>>>>> The Hss that meets the abort criteria does not abort and the Han
>>>>>>>>>> that does not meet its abort criteria does abort. So, both are
>>>>>>>>>> wrong.
>>>>>>>>>>
>>>>>>>>
>>>>>>>> Olcott does not understand that if the H in the simulated D
>>>>>>>> aborts, then the simulating H should not abort
>>>>>>>
>>>>>>> *You are confused*
>>>>>>> If the H in the simulated D aborts then the directly executed H did
>>>>>>> not abort. Since the directly executed H sees one more execution
>>>>>>> trace then the simulated H then the H in the simulated D never
>>>>>>> aborts.
>>>>>>>
>>>>>>
>>>>>> No, Olcott told us that the simulating H aborts before it sees
>>>>>> that the simulated D halts. It only sees that D calls H, but it
>>>>>> does not see that the called H aborts, because the simulation
>>>>>> stops at the call, which is too early.
>>>>>>
>>>>>
>>>>> DD correctly simulated by HH cannot possibly reach past its
>>>>> own first line, thus cannot possibly halt.
>>>>
>>>> Olcott does not understand that if the call to HH were correctly
>>>> simulated, then this HH would abort its simulation and return and
>>>> therefore DD would continue
>>>
>>> *When HH aborts its simulation DD immediately becomes 100%
>>> totally dead along with the entire simulation chain. I don't
>>> think that Richard understands this either.
>>>
>>
>> Olcott does not understand that we are talking about a DD that
>> contains a HH that aborts. He is constructing a problem, that does not
>> exists,
>
> It is fully operational code, thus physically exists.

On 2024-03-18 22:50:54 +0000, olcott said:

> On 3/18/2024 5:49 AM, Mikko wrote:
>> On 2024-03-17 16:35:32 +0000, olcott said:
>>
>>> On 3/17/2024 11:09 AM, Mikko wrote:
>>>> On 2024-03-17 13:53:03 +0000, olcott said:
>>>>
>>>>> On 3/17/2024 8:49 AM, Mikko wrote:
>>>>>> On 2024-03-17 13:04:19 +0000, olcott said:
>>>>>>
>>>>>>> On 3/17/2024 4:14 AM, Mikko wrote:
>>>>>>>> On 2024-03-16 14:48:51 +0000, olcott said:
>>>>>>>>
>>>>>>>>> On 3/16/2024 3:58 AM, Mikko wrote:
>>>>>>>>>> On 2024-03-15 19:40:08 +0000, olcott said:
>>>>>>>>>>
>>>>>>>>>>> On 3/15/2024 2:28 PM, Richard Damon wrote:
>>>>>>>>>>>> On 3/15/24 12:03 PM, olcott wrote:
>>>>>>>>>>>>> On 3/15/2024 1:45 PM, immibis wrote:
>>>>>>>>>>>>>> On 15/03/24 19:39, olcott wrote:
>>>>>>>>>>>>>>> On 3/15/2024 1:38 PM, immibis wrote:
>>>>>>>>>>>>>>>> On 15/03/24 18:52, olcott wrote:
>>>>>>>>>>>>>>>>> On 3/15/2024 12:36 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>> On 3/15/24 9:20 AM, olcott wrote:
>>>>>>>>>>>>>>>>>>> Best selling author of Theory of Computation textbooks:
>>>>>>>>>>>>>>>>>>> *Introduction To The Theory Of Computation 3RD, by sipser*
>>>>>>>>>>>>>>>>>>> https://www.amazon.com/Introduction-Theory-Computation-Sipser/dp/8131525295/
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> Date 10/13/2022 11:29:23 AM
>>>>>>>>>>>>>>>>>>> *MIT Professor Michael Sipser agreed this verbatim paragraph is correct*
>>>>>>>>>>>>>>>>>>> (He has neither reviewed nor agreed to anything else in this paper)
>>>>>>>>>>>>>>>>>>> (a) 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
>>>>>>>>>>>>>>>>>>> (b) H can abort its simulation of D and correctly report that D
>>>>>>>>>>>>>>>>>>> specifies a non-halting sequence of configurations.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> *When we apply the abort criteria* (elaborated above)
>>>>>>>>>>>>>>>>>>> Will you halt if you never abort your simulation?
>>>>>>>>>>>>>>>>>>> *Then H(D,D) is proven to meet this criteria*
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> *Proof that H(D,D) meets its abort criteria*
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> int D(int (*x)())
>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>    int Halt_Status = H(x, x);
>>>>>>>>>>>>>>>>>>>    if (Halt_Status)
>>>>>>>>>>>>>>>>>>>      HERE: goto HERE;
>>>>>>>>>>>>>>>>>>>    return Halt_Status;
>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> int main()
>>>>>>>>>>>>>>>>>>> {
>>>>>>>>>>>>>>>>>>>    Output("Input_Halts = ", H(D,D));
>>>>>>>>>>>>>>>>>>> }
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>   machine   stack     stack     machine    assembly
>>>>>>>>>>>>>>>>>>>   address   address   data      code       language
>>>>>>>>>>>>>>>>>>>   ========  ========  ========  =========  =============
>>>>>>>>>>>>>>>>>>> [00001d22][00102fc9][00000000] 55         push ebp      ; begin main()
>>>>>>>>>>>>>>>>>>> [00001d23][00102fc9][00000000] 8bec       mov ebp,esp
>>>>>>>>>>>>>>>>>>> [00001d25][00102fc5][00001cf2] 68f21c0000 push 00001cf2 ; push DD
>>>>>>>>>>>>>>>>>>> [00001d2a][00102fc1][00001cf2] 68f21c0000 push 00001cf2 ; push D
>>>>>>>>>>>>>>>>>>> [00001d2f][00102fbd][00001d34] e8eef7ffff call 00001522 ; call H(D,D)
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> H: Begin Simulation   Execution Trace Stored at:113075
>>>>>>>>>>>>>>>>>>> Address_of_H:1522
>>>>>>>>>>>>>>>>>>> [00001cf2][00113061][00113065] 55         push ebp       ; enter D(D)
>>>>>>>>>>>>>>>>>>> [00001cf3][00113061][00113065] 8bec       mov ebp,esp
>>>>>>>>>>>>>>>>>>> [00001cf5][0011305d][00103031] 51         push ecx
>>>>>>>>>>>>>>>>>>> [00001cf6][0011305d][00103031] 8b4508     mov eax,[ebp+08]
>>>>>>>>>>>>>>>>>>> [00001cf9][00113059][00001cf2] 50         push eax       ; push D
>>>>>>>>>>>>>>>>>>> [00001cfa][00113059][00001cf2] 8b4d08     mov ecx,[ebp+08]
>>>>>>>>>>>>>>>>>>> [00001cfd][00113055][00001cf2] 51         push ecx       ; push D
>>>>>>>>>>>>>>>>>>> [00001cfe][00113051][00001d03] e81ff8ffff call 00001522  ; call H(D,D)
>>>>>>>>>>>>>>>>>>> H: Recursive Simulation Detected Simulation Stopped
>>>>>>>>>>>>>>>>>>>                            H(D,D) returns 0 to main()
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> *That was proof that H(D,D) meets its abort criteria*
>>>>>>>>>>>>>>>>>>> H(D,D) correctly determines that itself is being called with its same
>>>>>>>>>>>>>>>>>>> inputs and there are no conditional branch instructions between the
>>>>>>>>>>>>>>>>>>> invocation of D(D) and its call to H(D,D).
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Except that D calling H(D,D) does NOT prove the required (a), since the
>>>>>>>>>>>>>>>>>> simulated D WILL stop running because *ITS* H will abort *ITS*
>>>>>>>>>>>>>>>>>> simulation and returm 0 so that simulated D will halt.
>>>>>>>>>>>>>>>>> You keep saying that H(D,D) never really needs to abort the
>>>>>>>>>>>>>>>>> simulation of its input because after H(D,D) has aborted the
>>>>>>>>>>>>>>>>> simulation of this input it no longer needs to be aborted.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> You keep thinking there is more than one H(D,D) and then when it's
>>>>>>>>>>>>>>>> convenient for you you think there is only one H(D,D). Why is that?
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> The first H(D,D) to see that the abort criteria has been met
>>>>>>>>>>>>>>> (the outermost one) must abort the simulation of its input or
>>>>>>>>>>>>>>> none of them ever abort.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> that's wrong. They all abort,
>>>>>>>>>>>>>
>>>>>>>>>>>>> I was baffled by this for three days when I first investigated this.
>>>>>>>>>>>>> Because every H has the exact same code, if the first one to see that
>>>>>>>>>>>>> the abort criteria has been met does not abort then none of them abort.
>>>>>>>>>>>>
>>>>>>>>>>>> And thus you look at a strawman. A case where H isn't the H that we
>>>>>>>>>>>> started with.
>>>>>>>>>>>>
>>>>>>>>>>>> If you change the H used by D, you change the quesition being asked.
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> We cannot reference the behavior of what D(D) does after H(D,D)
>>>>>>>>>>> has already aborted the simulation of its input at the point
>>>>>>>>>>> in time before H(D,D) aborts its input as any criterion measure
>>>>>>>>>>> for this H(D,D).
>>>>>>>>>>
>>>>>>>>>> Then you cannot prove that H is a halting decider, as that is what
>>>>>>>>>> you need to reference in the proof.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> I am saying that H(D,D)==0 is correct in that H(D,D)==0 means
>>>>>>>>> that H correctly determined that it had to abort the simulation
>>>>>>>>> of its input to prevent the infinite execution of this input.
>>>>>>>>>
>>>>>>>>> There cannot possibly exist any H(D,D) that is called by
>>>>>>>>> D where H(D,D) simulates its input and D(D) stops running
>>>>>>>>> and H never aborts its simulation.
>>>>>>>>
>>>>>>>> The set from wich such H could be chosen is so small that
>>>>>>>> it is no surprise that any H that simulates D(D) to its
>>>>>>>> termination is not in that set.
>>>>>>>>
>>>>>>>
>>>>>>> As soon as we hit complete proof of this we can move on
>>>>>>> to another point.
>>>>>>
>>>>>> A complete proof of what?
>>>>>>
>>>>> [Proof that H(D,D) meets its abort criteria]
>>>>
>>>> It is possible that you don't find such proof.
>>>>
>>>
>>> Been there done that many times.
>>
>> You have presented nothing that even looks like proof, let alone is.
>>
>
> That you don't understand that this is proof does not
> entail that it is not proof.

On 2024-03-19 15:47:14 +0000, olcott said:

> On 3/19/2024 3:39 AM, Mikko wrote:
>> On 2024-03-18 23:02:18 +0000, olcott said:
>>
>>> On 3/18/2024 6:26 AM, Mikko wrote:
>>>> On 2024-03-18 03:07:18 +0000, olcott said:
>>>>
>>>>> On 3/17/2024 9:35 PM, Richard Damon wrote:
>>>>>> On 3/17/24 4:27 PM, olcott wrote:
>>>>>>> On 3/17/2024 12:37 PM, immibis wrote:
>>>>>>>> On 17/03/24 14:11, olcott wrote:
>>>>>>>>> On 3/17/2024 12:22 AM, Richard Damon wrote:
>>>>>>>>>> On 3/16/24 10:04 PM, olcott wrote:
>>>>>>>>>>> On 3/17/2024 12:00 AM, Richard Damon wrote:
>>>>>>>>>>>> On 3/16/24 9:42 PM, olcott wrote:
>>>>>>>>>>>>> On 3/16/2024 11:28 PM, Richard Damon wrote:
>>>>>>>>>>>>>> On 3/16/24 9:13 PM, olcott wrote:
>>>>>>>>>>>>>>> On 3/16/2024 10:57 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>> On 3/16/24 7:52 PM, olcott wrote:
>>>>>>>>>>>>>>>>> On 3/16/2024 9:43 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>> On 3/16/24 5:50 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>> On 3/16/2024 7:21 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>> On 3/16/24 8:29 AM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>> On 3/15/2024 11:29 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>> On 3/15/24 8:45 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>> H(D,D) fails to make the required mistake of reporting on what it does not see.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> But it DOES make a mistake, because it does answer the question correctly.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> You are just PROVING you think lying is ok.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> You TOTALLY don't understand the meaning of truth.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> You are REALLY just a Pathological Liar, as you have no concept of real truth,
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> The original halt status criteria has the impossible requirement
>>>>>>>>>>>>>>>>>>>>> that H(D,D) must report on behavior that it does not actually see.
>>>>>>>>>>>>>>>>>>>>> Requiring H to be clairvoyant is an unreasonable requirement.
>>>>>>>>>>>>>>>>>>>>> *The criteria shown below eliminate the requirement of clairvoyance*
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> (a) 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 correctly simulates its input D until*
>>>>>>>>>>>>>>>>>>>>> Means H does a correct partial simulation of D until H correctly
>>>>>>>>>>>>>>>>>>>>> matches the recursive simulation non-halting behavior pattern.
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> But turning out to be impposible, doesn't make it incorrect or invalid.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> *You seems to be ridiculously disingenuous about the self-evident truth*
>>>>>>>>>>>>>>>>>>> For every possible way that H can be encoded and D(D) calls H(D,D)
>>>>>>>>>>>>>>>>>>> either H(D,D) aborts its simulation or D(D) never stops running.
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> And you are incredably stupid to not see this doesn't prove what you
>>>>>>>>>>>>>>>>>> need it to.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> Yes, if you define H to not abort, the we get a non-haltig D(D), but H
>>>>>>>>>>>>>>>>>> doesn't answwer.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> But, if you define H to abort, then,
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> We see that you changed the subject away from:
>>>>>>>>>>>>>>>>> [Proof that H(D,D) meets its abort criteria]
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Nope.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> H is an algorithm that simulates its input and correctly
>>>>>>>>>>>>>>> determines whether or not it needs to abort this simulation.
>>>>>>>>>>>>>>> That is all that this thread's H does.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>> And what defines "Need"?
>>>>>>>>>>>>>>
>>>>>>>>>>>>> It is the set of every implementation of its spec:
>>>>>>>>>>>>> (a) H(D,D) Simulate input.
>>>>>>>>>>>>> (b) Determine if it needs to stop simulating its input to prevent
>>>>>>>>>>>>> the simulated D(D) from never halting.
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> And thus not a specific algorithm?
>>>>>>>>>>>>
>>>>>>>>>>>> Again, HOW do you determine NEED?
>>>>>>>>>>>>
>>>>>>>>>>>> That is not an algorithmic step.
>>>>>>>>>>>>
>>>>>>>>>>>> We can only verify that in retrospect.
>>>>>>>>>>>
>>>>>>>>>>> Do you fully understand the spec?
>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> Yes, but I think not the way you do.
>>>>>>>>>>
>>>>>>>>>> To me, for H to NEED to abort its simulation, that means that when
>>>>>>>>>> giving the input to a correct simulator, that simulator will not halt.
>>>>>>>>>>
>>>>>>>>> Yes that is correct.
>>>>>>>>
>>>>>>>> You have just proven that H doesn't need abort its simulation and the
>>>>>>>> abort decision is incorrect.
>>>>>>>
>>>>>>> The head games of a Troll.
>>>>>>>
>>>>>>> For every possible way that H can be encoded and D(D)
>>>>>>> calls H(D,D) either H(D,D) aborts its simulation or D(D)
>>>>>>> never stops running.
>>>>>>>
>>>>>>
>>>>>> Which prove NOTHING, as D varies with H, so no D that was built with an
>>>>>> H that aborts its simulation has had its actual halting status tested.
>>>>>>
>>>>>
>>>>> *That merely changes the wording of the same truism*
>>>>> ∀H ∀D such that H(D,D) simulates its input and D calls H(D,D)
>>>>> H(D,D) does not abort its simulation necessitates simulated D(D)
>>>>> never stops running.
>>>>
>>>> You should restrict your H so that any H that simulates D(D) forever
>>>> is excluded, as simulating forver makes it a non-decider.
>>>>
>>>
>>> I do yet so far everyone says that they believe this is impossible
>>> so I have to go back a few steps and prove that it is possible.
>>
>> In logic any well defined expressible condition is allowed, even
>> one that is impossible to evaluate.
>>
>
> That seems to be a mistake otherwise geometry without square circles is
> incomplete.

On 2024-03-19 15:34:53 +0000, olcott said:

> On 3/19/2024 3:45 AM, Mikko wrote:
>> On 2024-03-19 02:46:27 +0000, olcott said:
>>
>>> On 3/18/2024 8:45 PM, immibis wrote:
>>>> On 19/03/24 00:43, olcott wrote:
>>>>> On 3/18/2024 6:34 PM, immibis wrote:
>>>>>> On 19/03/24 00:13, olcott wrote:
>>>>>>> On 3/18/2024 11:18 AM, immibis wrote:
>>>>>>>> On 18/03/24 06:25, olcott wrote:
>>>>>>>>> On 3/17/2024 11:50 PM, immibis wrote:
>>>>>>>>>> On 18/03/24 05:42, olcott wrote:
>>>>>>>>>>> Do you understand that each H(D,D) must either abort or fail to abort?
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> Do you understand that D(D) halts?
>>>>>>>>>
>>>>>>>>> *We are talking about the abort criteria*
>>>>>>>>
>>>>>>>> Strawman deception. H is a halt decider if it tells whether the direct
>>>>>>>> execution of its input would halt.
>>>>>>>
>>>>>>> If you can't even understand that H is a correct abort decider then
>>>>>>> you can't understand anything else that requires the prerequisite
>>>>>>> knowledge that H is a correct abort decider.
>>>>>>>
>>>>>>
>>>>>> Strawman deception. It is the halting problem, not the Olcott abort problem.
>>>>>
>>>>> You can learn calculus without the basis of algebra. You can't learn
>>>>> simulating halt deciders without the basis of simulating abort deciders.
>>>>
>>>> When are you going to extend this theory of simulating abort deciders
>>>> so that it solves the halting problem instead of merely solving the
>>>> Olcott abort problem?
>>>
>>> *Here are the two key steps to that*
>>> (1) Abort deciders correctly decide to abort.
>>> (2) The halting problem requires the correct answer to an incorrect
>>> question thus must be redefined.
>>
>> If a problem is redefined it must also be renamed. The original name
>> is already reserved.
>>
>
> OK then when H(D,D) reports on the actual behavior of its actual
> input this is called the corrected halting problem. The original
> halting problem is now called the erroneous halting problem.

A new name for an old concept is not needed. Newspeak was designed
to prevent rational thinking.

> We can call it the Naive halting problem like ZFC did to set theory.

ZFC doesn't call anything Naive.

> Alternatively H(D,D) can reject inputs that must be aborted because
> these inputs specify a pathological relationship to their decider.

--
Mikko

On 2024-03-19 15:06:05 +0000, olcott said:

> On 3/19/2024 4:05 AM, Mikko wrote:
>> On 2024-03-18 21:16:42 +0000, olcott said:
>>
>>> On 3/18/2024 3:56 PM, Richard Damon wrote:
>>>> On 3/18/24 1:41 PM, olcott wrote:
>>>>> On 3/18/2024 3:33 PM, Richard Damon wrote:
>>>>>> On 3/18/24 12:39 PM, olcott wrote:
>>>>>>> On 3/18/2024 1:06 PM, Richard Damon wrote:
>>>>>>>> On 3/18/24 10:45 AM, olcott wrote:
>>>>>>>>> What H(D,D) reports is off-topic for this post.
>>>>>>>>> *We are only looking at this*
>>>>>>>>> [Proof that H(D,D) meets its abort criteria --self-evident truth--]
>>>>>>>>> *Thus H(D,D) aborts or H(D,D) fails to abort*
>>>>>>>>>
>>>>>>>>> (a) If *simulating abort decider H* correctly simulates its input D
>>>>>>>>> until H correctly determines that its simulated D would never stop
>>>>>>>>> running unless aborted then
>>>>>>>>
>>>>>>>> So, it needs to simulate UNTIL it ACTUALLY CORRECTLY DETERMINES that
>>>>>>>> its D will never stop running, unless THIS H aborts it.
>>>>>>>>
>>>>>>>
>>>>>>> You never seemed to get the idea that X is a member of set Y
>>>>>>> otherwise X is not a member of set Y.
>>>>>>>
>>>>>>
>>>>>> And what are you defining X and set Y to be?
>>>>>>
>>>>>> That seems to be your problem, you are listing TWO distinct sets, which
>>>>>> hae two distinct set of Deciders and two distince to of inputs.
>>>>>>
>>>>>> You can't argue about an input built on a different decider tells you
>>>>>> anything about the input built on THIS decider.
>>>>>
>>>>> *This is what those naming conventions derive*
>>>>> Everyone is saying that because H(D,D) did need to abort its simulation
>>>>> to prevent D(D) from infinite execution that this proves that it never
>>>>> needed to abort its simulation because it can rely on the fact that it
>>>>> already aborted its simulation thus never needed to abort it.
>>>>>
>>>>
>>>> So, you can't define what you SET is defined as?
>>>>
>>>
>>> ∀H ∈ TM ∀D ∈ TMD | (H(D,D) simulates its input and D calls H(D,D))
>>
>> Use of double quantifiers may be a little confusing as each D calls
>> only one H.
>>
>
> *Counter factual*
> My syntax is intended to specify the universe of H/D pairs such that
> (H(D,D) simulates its input and D calls H(D,D))

Then you should quantify over those pairs with a simgle quantifier.

Anyway, every pair has a different D.

> That there can be multiple H for every unique D and multiple D for
> every unique H becomes more obvious when understand that we can pad
> either H or D with an arbitrary number of NOP opcodes.
> https://en.wikipedia.org/wiki/NOP_(code)

--
Mikko

On 2024-03-19 15:08:36 +0000, olcott said:

> On 3/19/2024 4:00 AM, Mikko wrote:
>> On 2024-03-18 20:56:38 +0000, Richard Damon said:
>>
>>> On 3/18/24 1:41 PM, olcott wrote:
>>>> On 3/18/2024 3:33 PM, Richard Damon wrote:
>>>>> On 3/18/24 12:39 PM, olcott wrote:
>>>>>> On 3/18/2024 1:06 PM, Richard Damon wrote:
>>>>>>> On 3/18/24 10:45 AM, olcott wrote:
>>>>>>>> What H(D,D) reports is off-topic for this post.
>>>>>>>> *We are only looking at this*
>>>>>>>> [Proof that H(D,D) meets its abort criteria --self-evident truth--]
>>>>>>>> *Thus H(D,D) aborts or H(D,D) fails to abort*
>>>>>>>>
>>>>>>>> (a) If *simulating abort decider H* correctly simulates its input D
>>>>>>>> until H correctly determines that its simulated D would never stop
>>>>>>>> running unless aborted then
>>>>>>>
>>>>>>> So, it needs to simulate UNTIL it ACTUALLY CORRECTLY DETERMINES that
>>>>>>> its D will never stop running, unless THIS H aborts it.
>>>>>>>
>>>>>>
>>>>>> You never seemed to get the idea that X is a member of set Y
>>>>>> otherwise X is not a member of set Y.
>>>>>>
>>>>>
>>>>> And what are you defining X and set Y to be?
>>>>>
>>>>> That seems to be your problem, you are listing TWO distinct sets, which
>>>>> hae two distinct set of Deciders and two distince to of inputs.
>>>>>
>>>>> You can't argue about an input built on a different decider tells you
>>>>> anything about the input built on THIS decider.
>>>>
>>>> *This is what those naming conventions derive*
>>>> Everyone is saying that because H(D,D) did need to abort its simulation
>>>> to prevent D(D) from infinite execution that this proves that it never
>>>> needed to abort its simulation because it can rely on the fact that it
>>>> already aborted its simulation thus never needed to abort it.
>>>>
>>>
>>> So, you can't define what you SET is defined as?
>>>
>>> If not, then how can you complain that I don't get the members right?
>>>
>>> That is just part of your deception.
>>>
>>> And, you seem to have a confusion about identities.
>>>
>>> The calling of H by D is a distinct computation from the H called by
>>> main that is trying to simulate the input given to it
>>>
>>> After all D(D) is DEFINED to be a seperate Computation that H is
>>> supposed to decide on.
>>>
>>> Seperate things are separate things,
>>>
>>>
>>> THIS H didn't "already abort it", it was THAT OTHER H that did,
>>>
>>> Somethibg distinct from it.
>>>
>>> At a different level of "Simulation"
>>>
>>> You don't seem to understand that each level of simulation is something
>>> distinct.
>>>
>>> Otherwise, when H abort, it would be aborting "itself" and thus stop running.
>>
>> Actually, the criterion discussed here only aborts H called by D. Another
>> criterion is needed if the loop at the end of D needs be aborted.
>>
>
> *Counter-factual*
> the criterion discussed here only aborts D that calls H(D,D)

Only at the time when H is called.

--
Mikko

On 2024-03-19 14:35:03 +0000, olcott said:

> On 3/19/2024 4:37 AM, Mikko wrote:
>> On 2024-03-18 23:05:33 +0000, olcott said:
>>
>>> On 3/18/2024 6:43 AM, Mikko wrote:
>>>> On 2024-03-17 23:47:01 +0000, olcott said:
>>>>
>>>>> On 3/17/2024 2:45 PM, Richard Damon wrote:
>>>>>> On 3/17/24 9:31 AM, olcott wrote:
>>>>>>> On 3/17/2024 11:13 AM, Mikko wrote:
>>>>>>>> On 2024-03-17 13:52:31 +0000, olcott said:
>>>>>>>>
>>>>>>>>> On 3/17/2024 8:46 AM, Mikko wrote:
>>>>>>>>>> On 2024-03-16 15:18:33 +0000, olcott said:
>>>>>>>>>>
>>>>>>>>>>> On 3/16/2024 3:19 AM, Mikko wrote:
>>>>>>>>>>>> On 2024-03-15 16:20:35 +0000, olcott said:
>>>>>>>>>>>>
>>>>>>>>>>>>> Best selling author of Theory of Computation textbooks:
>>>>>>>>>>>>> *Introduction To The Theory Of Computation 3RD, by sipser*
>>>>>>>>>>>>> https://www.amazon.com/Introduction-Theory-Computation-Sipser/dp/8131525295/
>>>>>>>>>>>>>
>>>>>>>>>>>>> Date 10/13/2022 11:29:23 AM
>>>>>>>>>>>>> *MIT Professor Michael Sipser agreed this verbatim paragraph is correct*
>>>>>>>>>>>>> (He has neither reviewed nor agreed to anything else in this paper)
>>>>>>>>>>>>> (a) 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
>>>>>>>>>>>>> (b) H can abort its simulation of D and correctly report that D
>>>>>>>>>>>>> specifies a non-halting sequence of configurations.
>>>>>>>>>>>>>
>>>>>>>>>>>>> *When we apply the abort criteria* (elaborated above)
>>>>>>>>>>>>> Will you halt if you never abort your simulation?
>>>>>>>>>>>>> *Then H(D,D) is proven to meet this criteria*
>>>>>>>>>>>>>
>>>>>>>>>>>>> *Proof that H(D,D) meets its abort criteria*
>>>>>>>>>>>>>
>>>>>>>>>>>>> int D(int (*x)())
>>>>>>>>>>>>> {
>>>>>>>>>>>>>    int Halt_Status = H(x, x);
>>>>>>>>>>>>>    if (Halt_Status)
>>>>>>>>>>>>>      HERE: goto HERE;
>>>>>>>>>>>>>    return Halt_Status;
>>>>>>>>>>>>> }
>>>>>>>>>>>>>
>>>>>>>>>>>>> int main()
>>>>>>>>>>>>> {
>>>>>>>>>>>>>    Output("Input_Halts = ", H(D,D));
>>>>>>>>>>>>> }
>>>>>>>>>>>>>
>>>>>>>>>>>>>   machine   stack     stack     machine    assembly
>>>>>>>>>>>>>   address   address   data      code       language
>>>>>>>>>>>>>   ========  ========  ========  =========  =============
>>>>>>>>>>>>> [00001d22][00102fc9][00000000] 55         push ebp      ; begin main()
>>>>>>>>>>>>> [00001d23][00102fc9][00000000] 8bec       mov ebp,esp
>>>>>>>>>>>>> [00001d25][00102fc5][00001cf2] 68f21c0000 push 00001cf2 ; push DD
>>>>>>>>>>>>> [00001d2a][00102fc1][00001cf2] 68f21c0000 push 00001cf2 ; push D
>>>>>>>>>>>>> [00001d2f][00102fbd][00001d34] e8eef7ffff call 00001522 ; call H(D,D)
>>>>>>>>>>>>>
>>>>>>>>>>>>> H: Begin Simulation   Execution Trace Stored at:113075
>>>>>>>>>>>>> Address_of_H:1522
>>>>>>>>>>>>> [00001cf2][00113061][00113065] 55         push ebp       ; enter D(D)
>>>>>>>>>>>>> [00001cf3][00113061][00113065] 8bec       mov ebp,esp
>>>>>>>>>>>>> [00001cf5][0011305d][00103031] 51         push ecx
>>>>>>>>>>>>> [00001cf6][0011305d][00103031] 8b4508     mov eax,[ebp+08]
>>>>>>>>>>>>> [00001cf9][00113059][00001cf2] 50         push eax       ; push D
>>>>>>>>>>>>> [00001cfa][00113059][00001cf2] 8b4d08     mov ecx,[ebp+08]
>>>>>>>>>>>>> [00001cfd][00113055][00001cf2] 51         push ecx       ; push D
>>>>>>>>>>>>> [00001cfe][00113051][00001d03] e81ff8ffff call 00001522  ; call H(D,D)
>>>>>>>>>>>>> H: Recursive Simulation Detected Simulation Stopped
>>>>>>>>>>>>>                            H(D,D) returns 0 to main()
>>>>>>>>>>>>>
>>>>>>>>>>>>> *That was proof that H(D,D) meets its abort criteria*
>>>>>>>>>>>>> H(D,D) correctly determines that itself is being called with its same
>>>>>>>>>>>>> inputs and there are no conditional branch instructions between the
>>>>>>>>>>>>> invocation of D(D) and its call to H(D,D).
>>>>>>>>>>>>
>>>>>>>>>>>> This proof is not simpler or more convinceing than earlier proofs of
>>>>>>>>>>>> the same.
>>>>>>>>>>>>
>>>>>>>>>>>> It is also as uninteresting as the proved claim. As long as H does
>>>>>>>>>>>> not meet the specification of halting decider it does not matter
>>>>>>>>>>>> what it meets instead.
>>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>> The original halt status criteria has the impossible requirement
>>>>>>>>>>> that H(D,D) must report on behavior that it does not actually see.
>>>>>>>>>>
>>>>>>>>>> The requirement is not specifically about behaviour that the decider
>>>>>>>>>> does not actually see but requires reporting anyway, whether the
>>>>>>>>>> decider sees or not. So it turns out that it is not possible to
>>>>>>>>>> meet the specification in all cases.
>>>>>>>>>>
>>>>>>>>> I think that the decider can meet its abort criteria in all cases.
>>>>>>>>
>>>>>>>> But cannot meet its specification.
>>>>>>>>
>>>>>>>
>>>>>>> First we must come to mutual agreement that H(D,D) is correct
>>>>>>> to abort its simulation.
>>>>>>
>>>>>> Which means we need to first come to an aggreement of what that means.
>>>>>>
>>>>>> You DID agree earlier to this:
>>>>>>
>>>>>> On 3/17/24 6:11 AM, olcott wrote:
>>>>>>> On 3/17/2024 12:22 AM, Richard Damon wrote:
>>>>>>>> To me, for H to NEED to abort its simulation, that means that when
>>>>>>>> giving the input to a correct simulator, that simulator will not halt.
>>>>>>>>
>>>>>>> Yes that is correct.
>>>>>>>
>>>>>>
>>>>>
>>>>> For every possible way that H can be encoded and D(D)
>>>>> calls H(D,D) either H(D,D) aborts its simulation or D(D)
>>>>> never stops running.
>>>>
>>>> That is ambiguous: does D(D) call H(D,D) if H is encoded in another way
>>>> than the one that D(D) calls?
>>>>
>>>
>>> I have no idea what you are meaning.
>>> It is assumed that H and D are C functions.
>>
>> What exacly you don't understand? Do you understand the following
>> phrases:
>>
>> - "every possibe way that H can be encoded" ?
>>
>> - "D(D) calls H(D,D)" ?
>>
>> - "the H(D,D) that D(D) calls" ?
>>
>> - "H(D,D) aborts its simulation"
>>
>> Unless you can answer I can only assume that you are too stupid
>> for this discussion.
>>
>
> ∀H ∈ TM ∀D ∈ TMD | (H(D,D) simulates its input and D calls H(D,D))
> (1) H(D,D) does not abort its simulation then simulated D(D) never
> stops running.
> (2) H(D,D) aborts its simulation then simulated D(D) stops running.

On 3/19/24 7:56 AM, olcott wrote:
> On 3/19/2024 4:05 AM, Fred. Zwarts wrote:
>> Op 19.mrt.2024 om 05:37 schreef olcott:
>>> On 3/18/2024 11:23 PM, Richard Damon wrote:
>>>> On 3/18/24 8:53 PM, olcott wrote:
>>>>> On 3/18/2024 9:44 PM, Richard Damon wrote:
>>>>>> On 3/18/24 2:48 PM, olcott wrote:
>>>>>>> On 3/18/2024 4:38 PM, Fred. Zwarts wrote:
>>>>>>>> Op 18.mrt.2024 om 22:18 schreef olcott:
>>>>>>>>> On 3/18/2024 4:11 PM, Fred. Zwarts wrote:
>>>>>>>>>> Op 18.mrt.2024 om 21:40 schreef olcott:
>>>>>>>>>>> On 3/18/2024 3:30 PM, immibis wrote:
>>>>>>>>>>>> On 18/03/24 21:20, olcott wrote:
>>>>>>>>>>>>> On 3/18/2024 2:44 PM, Fred. Zwarts wrote:
>>>>>>>>>>>>>> Op 18.mrt.2024 om 18:43 schreef olcott:
>>>>>>>>>>>>>>> On 3/18/2024 10:11 AM, Fred. Zwarts wrote:
>>>>>>>>>>>>>>>> Op 18.mrt.2024 om 15:44 schreef olcott:
>>>>>>>>>>>>>>>>> On 3/18/2024 1:04 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>> On 3/17/24 10:22 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>> On 3/18/2024 12:11 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>> On 3/17/24 9:42 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>> On 3/17/2024 11:39 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>> On 3/17/24 9:00 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>> On 3/17/2024 10:32 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>> On 3/17/24 8:14 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>> On 3/17/2024 9:35 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/17/24 4:27 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/17/2024 12:37 PM, immibis wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 17/03/24 14:11, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/17/2024 12:22 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/16/24 10:04 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/17/2024 12:00 AM, Richard Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/16/24 9:42 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/16/2024 11:28 PM, Richard Damon
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/16/24 9:13 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/16/2024 10:57 PM, Richard Damon
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/16/24 7:52 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/16/2024 9:43 PM, Richard Damon
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/16/24 5:50 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/16/2024 7:21 PM, Richard
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/16/24 8:29 AM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/15/2024 11:29 PM, Richard
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Damon wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/15/24 8:45 PM, olcott wrote:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H(D,D) fails to make the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> required mistake of reporting
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> on what it does not see.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> But it DOES make a mistake,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> because it does answer the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> question correctly.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> You are just PROVING you think
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> lying is ok.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> You TOTALLY don't understand
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the meaning of truth.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> You are REALLY just a
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Pathological Liar, as you have
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> no concept of real truth,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> The original halt status
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> criteria has the impossible
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> requirement
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> that H(D,D) must report on
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> behavior that it does not
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> actually see.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Requiring H to be clairvoyant
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> is an unreasonable requirement.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> *The criteria shown below
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> eliminate the requirement of
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> clairvoyance*
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (a) 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 correctly simulates its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> input D until*
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Means H does a correct partial
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation of D until H correctly
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> matches the recursive
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation non-halting behavior
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> pattern.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> But turning out to be
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> impposible, doesn't make it
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> incorrect or invalid.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> *You seems to be ridiculously
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> disingenuous about the
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> self-evident truth*
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> For every possible way that H can
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> be encoded and D(D) calls H(D,D)
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> either H(D,D) aborts its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation or D(D) never stops
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> running.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> And you are incredably stupid to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> not see this doesn't prove what
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> you need it to.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Yes, if you define H to not abort,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the we get a non-haltig D(D), but
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H doesn't answwer.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> But, if you define H to abort, then,
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> We see that you changed the subject
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> away from:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> [Proof that H(D,D) meets its abort
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> criteria]
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Nope.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> H is an algorithm that simulates its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> input and correctly
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> determines whether or not it needs to
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> abort this simulation.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> That is all that this thread's H does.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> And what defines "Need"?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> It is the set of every implementation
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> of its spec:
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (a) H(D,D) Simulate input.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (b) Determine if it needs to stop
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulating its input to prevent
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the simulated D(D) from never halting.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> And thus not a specific algorithm?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Again, HOW do you determine NEED?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> That is not an algorithmic step.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> We can only verify that in retrospect.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Do you fully understand the spec?
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Yes, but I think not the way you do.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> To me, for H to NEED to abort its
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation, that means that when giving
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> the input to a correct simulator, that
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> simulator will not halt.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Yes that is correct.
>>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>>> You have just proven that H doesn't need
>>>>>>>>>>>>>>>>>>>>>>>>>>>> abort its simulation and the abort decision
>>>>>>>>>>>>>>>>>>>>>>>>>>>> is incorrect.
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> The head games of a Troll.
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>> For every possible way that H can be encoded
>>>>>>>>>>>>>>>>>>>>>>>>>>> and D(D)
>>>>>>>>>>>>>>>>>>>>>>>>>>> calls H(D,D) either H(D,D) aborts its
>>>>>>>>>>>>>>>>>>>>>>>>>>> simulation or D(D)
>>>>>>>>>>>>>>>>>>>>>>>>>>> never stops running.
>>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>> Which prove NOTHING, as D varies with H, so no
>>>>>>>>>>>>>>>>>>>>>>>>>> D that was built with an H that aborts its
>>>>>>>>>>>>>>>>>>>>>>>>>> simulation has had its actual halting status
>>>>>>>>>>>>>>>>>>>>>>>>>> tested.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>> *That merely changes the wording of the same
>>>>>>>>>>>>>>>>>>>>>>>>> truism*
>>>>>>>>>>>>>>>>>>>>>>>>> ∀H ∈ TM ∀D ∈ TMD such that
>>>>>>>>>>>>>>>>>>>>>>>>> H(D,D) simulates its input and
>>>>>>>>>>>>>>>>>>>>>>>>> D calls H(D,D) and
>>>>>>>>>>>>>>>>>>>>>>>>> H(D,D) does not abort its simulation
>>>>>>>>>>>>>>>>>>>>>>>>> necessitates simulated D(D) never stops running.
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> Third times and still not a charm.
>>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>> All those D still use an H that doesn't abort
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>> *You keep talking in circles, there are only two
>>>>>>>>>>>>>>>>>>>>>>> sets*
>>>>>>>>>>>>>>>>>>>>>>> ∀H ∈ TM ∀D ∈ TMD | (H(D,D) simulates its input
>>>>>>>>>>>>>>>>>>>>>>> and D calls H(D,D))
>>>>>>>>>>>>>>>>>>>>>>> (1) H(D,D) does not abort its simulation then
>>>>>>>>>>>>>>>>>>>>>>> simulated D(D) never stops running.
>>>>>>>>>>>>>>>>>>>>>>> (2) H(D,D) aborts its simulation then simulated
>>>>>>>>>>>>>>>>>>>>>>> D(D) stops running.
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> And your top line says NOTHING about the Ds in set
>>>>>>>>>>>>>>>>>>>>>> (2), since nothing showed them not to run
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>> but your (2) admitts that D(D) will stop running,
>>>>>>>>>>>>>>>>>>>>>> and thus the top level H didn't need to abort its
>>>>>>>>>>>>>>>>>>>>>> simulation.
>>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>> Do you understand that each H(D,D) must either
>>>>>>>>>>>>>>>>>>>>> abort or fail to abort?
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>>> And do you understand
>>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>>> Yes that is what I am asking. It seems that you don't
>>>>>>>>>>>>>>>>>>> understand
>>>>>>>>>>>>>>>>>>> the difference between X being a member of a set and
>>>>>>>>>>>>>>>>>>> X not being
>>>>>>>>>>>>>>>>>>> a member of a set. Very elemental set theory.
>>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>>> And you seem to be trying to convientely forget that
>>>>>>>>>>>>>>>>>> each D that you talk about is DIFFERENT, base on the H
>>>>>>>>>>>>>>>>>> that it was designed to confound.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> *You keep talking in circles, there are only two sets*
>>>>>>>>>>>>>>>>> ∀H ∈ TM ∀D ∈ TMD | (H(D,D) simulates its input and D
>>>>>>>>>>>>>>>>> calls H(D,D))
>>>>>>>>>>>>>>>>> (1) H(D,D) does not abort its simulation then simulated
>>>>>>>>>>>>>>>>> D(D) never stops running.
>>>>>>>>>>>>>>>>> (2) H(D,D) aborts its simulation then simulated D(D)
>>>>>>>>>>>>>>>>> stops running.
>>>>>>>>>>>>>>>>> *By whatever means H(D,D) places itself in (2) then
>>>>>>>>>>>>>>>>> H(D,D) is correct*
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> By repeating yourself, you run in circles.
>>>>>>>>>>>>>>>> There are three possible categories of H functions:
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> 1. Hah, It aborts and reports halting.
>>>>>>>>>>>>>>>> 2. Han, It aborts and repeats non halting.
>>>>>>>>>>>>>>>> 3. Hss does not abort, but simply simulates.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> What H(D,D) reports is off-topic for this post.
>>>>>>>>>>>>>>> *We are only looking at this*
>>>>>>>>>>>>>>> [Proof that H(D,D) meets its abort criteria
>>>>>>>>>>>>>>> --self-evident truth--]
>>>>>>>>>>>>>>> *Thus H(D,D) aborts or H(D,D) fails to abort*
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> Be clear in the naming. Is it Dan that is considered, or
>>>>>>>>>>>>>> Dss? Dss must be aborted, because is does not halt, but
>>>>>>>>>>>>>> Dan does halt and does not need to be aborted.
>>>>>>>>>>>>>
>>>>>>>>>>>>> *There are only two sets*
>>>>>>>>>>>>> ∀H ∈ TM ∀D ∈ TMD | (H(D,D) simulates its input and D calls
>>>>>>>>>>>>> H(D,D))
>>>>>>>>>>>>> (1) H(D,D) does not abort its simulation then simulated
>>>>>>>>>>>>> D(D) never stops running.
>>>>>>>>>>>>> (2) H(D,D) aborts its simulation then simulated D(D) stops
>>>>>>>>>>>>> running.
>>>>>>>>>>>>>
>>>>>>>>>>>>> (a) If simulating abort decider H correctly simulates its
>>>>>>>>>>>>> input D until H correctly determines that its simulated D
>>>>>>>>>>>>> would never stop running unless aborted...
>>>>>>>>>>>>>
>>>>>>>>>>>>> *Therefore*
>>>>>>>>>>>>> *Every element of (1) is incorrect and every element of (2)
>>>>>>>>>>>>> is correct*
>>>>>>>>>>>>> *Pathological thinking to make them both seem incorrect is
>>>>>>>>>>>>> incorrect*
>>>>>>>>>>>>>
>>>>>>>>>>>>>> So, Hss(Dss,Dss) should abort, but it does not.
>>>>>>>>>>>>>> and Han(Dan,Dan) should not abort, but it does.
>>>>>>>>>>>>>> The Hss that meets the abort criteria does not abort and
>>>>>>>>>>>>>> the Han that does not meet its abort criteria does abort.
>>>>>>>>>>>>>> So, both are wrong.
>>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> Is it Dan that is considered, or Dss? Dss must be aborted,
>>>>>>>>>>>> because is does not halt, but Dan does halt and does not
>>>>>>>>>>>> need to be aborted.
>>>>>>>>>>>
>>>>>>>>>>> *This is what those naming conventions derive*
>>>>>>>>>>> Everyone is saying that because H(D,D) did need to abort its
>>>>>>>>>>> simulation
>>>>>>>>>>> to prevent D(D) from infinite execution that this proves that
>>>>>>>>>>> it never
>>>>>>>>>>> needed to abort its simulation because it can rely on the
>>>>>>>>>>> fact that it
>>>>>>>>>>> already aborted its simulation thus never needed to abort it.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> You are almost there. If you stop naming all different H which
>>>>>>>>>> the same name and all different D with the same name, your
>>>>>>>>>> confusion may disappear.
>>>>>>>>>
>>>>>>>>> ∀H ∈ TM ∀D ∈ TMD | (H(D,D) simulates its input and D calls H(D,D))
>>>>>>>>> Every H in the above set must abort its simulated D(D).
>>>>>>>>>
>>>>>>>>>> Hss(Dss,Dss) should abort, but it does not.
>>>>>>>>>> and Han(Dan,Dan) should not abort, but it does.
>>>>>>>>>> The Hss that meets the abort criteria does not abort and the Han
>>>>>>>>>> that does not meet its abort criteria does abort. So, both are
>>>>>>>>>> wrong.
>>>>>>>>>>
>>>>>>>>
>>>>>>>> Olcott does not understand that if the H in the simulated D
>>>>>>>> aborts, then the simulating H should not abort
>>>>>>>
>>>>>>> *You are confused*
>>>>>>> If the H in the simulated D aborts then the directly executed H did
>>>>>>> not abort. Since the directly executed H sees one more execution
>>>>>>> trace then the simulated H then the H in the simulated D never
>>>>>>> aborts.
>>>>>>
>>>>>> Nope, YOU are confused If the H in the simulated D aborts,
>>>>>
>>>>> Then a dozen square circles are on sale at Walmart right now for
>>>>> $10.99
>>>>
>>>> Interesting, that you retort was to just blantently lie?
>>>>
>>>> When presented with FACTS, you respond with LIES.
>>>>
>>>> That just shows who you are.
>>>>
>>>>>
>>>>>> then the directly executed D MUST abort, or you are agreeing that
>>>>>> H's simulation is not correct.
>>>>>>
>>>>>
>>>>> In other words after we have been over this hundreds and hundreds
>>>>> of times it is still waaaayyy over your head that the executed H
>>>>> always
>>>>> sees exactly one more execution trace than the executed H?
>>>>
>>>> Do you really read your nonsense?
>>>>
>>>> How does x, "the executed H" see one more execution trace than x?
>>>>
>>>> That means you think that 1 + 1 = 1
>>>>
>>>>>
>>>>>> And no, the directed executed vesion of D see no more information
>>>>>> then the machine the simulated D represents,
>>>>>
>>>>> The simulated H can not see its own behavior where as its simulator
>>>>> can thus proving the simulator sees one more execution trace that
>>>>> its simulation.
>>>>
>>>> Nope, it may see one more then at the point the simulation reaches,
>>>
>>> Yes, finally. Thus the executed H(D,D) sees its abort criteria before
>>> any of the simulated ones ever would.
>>>
>>>> but the actual machine that is now being simulated did EVERYTHING
>>>> that it will do as soon as it was created,
>>>>
>>> No it is not true that x86 machines are oracle machines.
>>> https://en.wikipedia.org/wiki/Oracle_machine
>>>
>>>> You keep on makeing that mistake, confusing the simulation with what
>>>> actually happens.
>>>>
>>>>>
>>>>>> if H aborts the simulation before then, then H just doesn't get to
>>>>>> know what happens after that.
>>>>>>
>>>>>> I will point out, you almost NEVER actually look at the direct
>>>>>> execution of D(D), because it just proves that H isn't a correct
>>>>>> Halt Decider.
>>>>>>
>>>>>
>>>>> H(D,D) cannot rely on the behavior of D(D) after it has already
>>>>> aborted
>>>>> its simulation or it would never abort its simulation and D(D) would
>>>>> never stop running. This means that the executed H(D,D) see non
>>>>> halting
>>>>> behavior.
>>>>>
>>>>
>>>> Right, H is in a no-win pickle. (or its programmer is).
>>>
>>> Not at all. The requirement for clairvoyance is an incorrect
>>> requirement. H(D,D) cannot be correctly required to report on
>>> what it cannot see.
>>>
>>>> If we wait, we run into the issue that we may never answer. If we
>>>> abort, we don't know what answer to give.
>>>
>>> An abort decider would report on whether it aborted or not.
>>>
>>>> That is why the Halting Mapping turns out to be uncomputable.
>>>>
>>>
>>> *H(D,D) cannot be correctly required to report on what it cannot see*
>>>
>>
>> But H(D,D) cannot be allowed to choose what it want to see and what it
>> does not want to see. By aborting, it chooses to close it eyes and
>> therefore it does not see that D calls H, which aborts and returns. It
>> is not a matter of 'cannot see', but 'chooses to be blind for the facts'.
>>
>
> Can D correctly simulated by H terminate normally?
> 01 int D(ptr x)  // ptr is pointer to int function
> 02 {
> 03   int Halt_Status = H(x, x);
> 04   if (Halt_Status)
> 05     HERE: goto HERE;
> 06   return Halt_Status;
> 07 }
> 08
> 09 void main()
> 10 {
> 11   H(D,D);
> 12 }
>
> *Execution Trace*
> Line 11: main() invokes H(D,D);
>
> *keeps repeating* (unless aborted)