On 8/18/21 9:57 AM, olcott wrote:
> On 8/18/2021 5:26 AM, Richard Damon wrote:
>> On 8/18/21 12:09 AM, olcott wrote:
>>> On 8/17/2021 10:37 PM, Richard Damon wrote:
>>>> On 8/17/21 11:17 PM, olcott wrote:
>>>>> On 8/17/2021 10:10 PM, Richard Damon wrote:
>>>>>> On 8/17/21 10:50 PM, olcott wrote:
>>>>>>> On 8/17/2021 9:36 PM, Richard Damon wrote:
>>>>>>>> On 8/17/21 10:04 PM, olcott wrote:
>>>>>>>>> On 8/17/2021 8:49 PM, Richard Damon wrote:
>>>>>>>>>> On 8/17/21 9:40 PM, olcott wrote:
>>>>>>>>>>> On 8/17/2021 8:35 PM, Richard Damon wrote:
>>>>>>>>>>>> On 8/17/21 9:24 PM, olcott wrote:
>>>>>>>>>>>>> On 8/17/2021 8:17 PM, Richard Damon wrote:
>>>>>>>>>>>>>>>>> That you keep erasing these words rather than carefully
>>>>>>>>>>>>>>>>> critqueing
>>>>>>>>>>>>>>>>> each
>>>>>>>>>>>>>>>>> one of them sufficiently proves that you are dishonest:
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>> --Because H only acts as a pure simulator of its input
>>>>>>>>>>>>>>>>> --until after its halt status decision has been made it
>>>>>>>>>>>>>>>>> --has no behavior that can possibly effect the behavior
>>>>>>>>>>>>>>>>> --of its input. Because of this H screens out its own
>>>>>>>>>>>>>>>>> --address range in every execution trace that it examines.
>>>>>>>>>>>>>>>>> --This is why we never see any instructions of H in any
>>>>>>>>>>>>>>>>> --execution trace after an input calls H.
>>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>> Pure simulator *until*, Then it isn't because it
>>>>>>>>>>>>>>>> terminates its
>>>>>>>>>>>>>>>> simulation.
>>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>> It is this key fact that allows it to ignore its own code
>>>>>>>>>>>>>>> while
>>>>>>>>>>>>>>> it is
>>>>>>>>>>>>>>> making its halt status decision. The entire time that it is
>>>>>>>>>>>>>>> making its
>>>>>>>>>>>>>>> halt status decision <it is> a pure simulator.
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>>
>>>>>>>>>>>>>>
>>>>>>>>>>>>>> But then it isn't, so the copy that it was simulating wasn't
>>>>>>>>>>>>>> either.
>>>>>>>>>>>>>>
>>>>>>>>>>>>> It <is> a pure simulator until after it makes its halt status
>>>>>>>>>>>>> decision
>>>>>>>>>>>>> therefore it <can> ignore its own code <while> it is making
>>>>>>>>>>>>> this
>>>>>>>>>>>>> halt
>>>>>>>>>>>>> status decision.
>>>>>>>>>>>>
>>>>>>>>>>>>
>>>>>>>>>>>> And then it isn't, and so it NEVER was. UNSOUND LOGIC.
>>>>>>>>>>>
>>>>>>>>>>> X = "H is a pure simulator while it is making its halt status
>>>>>>>>>>> decision"
>>>>>>>>>>>
>>>>>>>>>>> You are concluding that X is not true on the basis that X is
>>>>>>>>>>> true?
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> I am says that the assertion that "H IS a pure simulator" is not
>>>>>>>>>> true.
>>>>>>>>>
>>>>>>>>> I am saying that H is a pure simulator some of the time and you
>>>>>>>>> are
>>>>>>>>> saying no I am wrong because H is not a pure simulator all of the
>>>>>>>>> time
>>>>>>>>> then it is not a pure simulator some of the time.
>>>>>>>>
>>>>>>>> Something can't really be a pure simulator part of the time.
>>>>>>>
>>>>>>> Sure it can and in fact H is a pure simulator for the entire time
>>>>>>> that
>>>>>>> it could otherwise possibly effect the behavior of its input. This
>>>>>>> seems
>>>>>>> to be beyond your capacity to understand.
>>>>>>>
>>>>>>
>>>>>> No, It can't. PERIOD.
>>>>>>
>>>>>> H can act like a pure simulator for the part of the trace that it
>>>>>> runs,
>>>>>> but H is NOT a pure simulator, at least as far as transformation
>>>>>> rules
>>>>>> for copies of it in the simulation.
>>>>>>
>>>>>
>>>>> Every recursive invocation of H continues to act like a pure simulator
>>>>> until after H makes it halt status decision.
>>>>
>>>> UNSOUND.
>>>>
>>>> Since H at some point will STOP being a pure simulator, its affect on
>>>> the machine CALLING it is NOT the same as a Pure Simulator.
>>>>
>>>
>>> While H does nothing to change the behavior of its input
>>> H does do something that changes the behavior of its input.
>>
>> Not what I said.
>>
>
> It is what you implied.
>
>> H does affect the machine that uses it.
>>
>
> H has no effect on the machine that it simulates until after its halt
> status decision has been made. This conclusively proves that H can
> ignore its in execution trace during its halt status analysis.

No, that is NOT a proof. What establish axiom or theorem are you basing
this 'proof' on.

FAIL

UNSOUND.

>
> Anyone disagreeing with this is either not intelligent or knowledgeable
> enough to understand it, or a liar.
>

Anyone making such a statement is proving that they are an ignoramous.

> That H does effect the behavior or its input at some other point is
> utterly irrelevant to this analysis. We are only answering the single
> question: Is it correct for H to ignore its own execution trace during
> its halt status analysis?

Which you have NOT established. Since any copy of your H, if run long
enopugh WILL abort its simulation (or it is the Hn that doesn't answer
so starts off wrong). It is UNSOUND logic for H to presume that the H is
is simulating will not abort its simulation.

Remember, YOU have established that the act of aborting the simulation
doesn't actually change the behavior of the machine it is simulating,
therefore it is valid to take that exact same input and run it with a
truely pure simulator, i.e. a REAL UTM, and when we do, we see that in
that case, the input will proceed to the point where its H will decide
to abort is simulation, return the non-halting result, and that machine
will then Halt.

Since the simulating machine aborting hasn't changed the 'real' behavior
of the machine, only how much we have seen, it is thus clear that <H^>
applied to <H^> is actually a halting computation, and H was WRONG in
deciding elsewise, BECAUSE it used the UNSOUND logic of assuming that
the simulated H would never abort its simulation.

FFFFFFFFFF AA IIIIIIIIII LL
FF AA AA II LL
FF AA AA II LL
FFFFFF AAAAAAAAAA II LL
FF AA AA II LL
FF AA AA II LL
FF AA AA IIIIIIIIII LLLLLLLLLL

>
>> H0 does not affect the behavior of the machine that is represented by
>> its input, P1.
>>
>> H1, which is used by P1, does affect the behavior of P1.
>>
>> If you want to try some stained logic to claim that No H affects the
>> behavior of any P because an instance of P is used as an instance of H
>> then you are using Unsound Logic.
>>
>> By the method of construction, the behavior of P is directly controlled
>> by the behavior of H.
>>
>> To deny that is to say you are not following the pattern.
>>
>> FFFFFFFFFF       AA      IIIIIIIIII  LL
>> FF             AA  AA        II      LL
>> FF           AA      AA      II      LL
>> FFFFFF       AAAAAAAAAA      II      LL
>> FF           AA      AA      II      LL
>> FF           AA      AA      II      LL
>> FF           AA      AA  IIIIIIIIII  LLLLLLLLLL
>>
>>>
>>> By this same reasoning all black cats are white.
>>
>> Nope. Strawman.
>>
>> UNSOUND LOGIC.
>>
>> Please try to actually PROVE something, you are just using rhetorical
>> arguments that aren't actually very good.
>>
>>>
>>>> You have a false premise in your logic so you have an UNSOUND argument.
>>>>
>>>>>
>>>>> This allows Every recursive invocation of H to totally ignore its own
>>>>> execution in every halt status analysis execution trace.
>>>>
>>>> FALSE. Prove your claim. Really, Try to.
>>>>
>>>> UNSOUND.
>>>>
>>>> H may be able to ignore the affect of its own aborting on the behavior
>>>> of the machine it is simulating, but it MUST take into account that
>>>> same
>>>> aborting behavior in the invocation of the copies of it the machine it
>>>> is simulating, as that activity DOES affect those machines.
>>>>
>>>> Remember, The fact that H0 is aborting the simulation of P1 doesn't
>>>> affect the real behavior of P1, thus we do need to look at what P1
>>>> would
>>>> do if H0 didn't abort it, and from your run of P0, we know that after
>>>> just a little bit more, H1 will also decide to abort its simulation of
>>>> P2, and then return to P1 and then P1 will Halt.
>>>>
>>>> Thus, since the decision of H0 to abort doesn't affect the behavior of
>>>> the machine that is its input, we see that P1 is STILL a Halting
>>>> Computation, and that H1 will FAIL to be a Pure Simulation, so H0 is in
>>>> error for treating it as one.
>>>>
>>>>>
>>>>>> You confuse its affect on the input, which is a representation of a
>>>>>> machine, which you are right it can't affect (not if it is an
>>>>>> accurate
>>>>>> simulator) for it having an affect on the machine it is imbedded in.
>>>>>>
>>>>>> If H is a pure simulator, the it CAN'T return an answer to the
>>>>>> machine
>>>>>> that 'called' it until the machine it is simulating has finished.
>>>>>> Since
>>>>>> it doesn't do that, it isn't a pure simulator, and thus the
>>>>>> transformation of tracing the simulation of the simulator to the
>>>>>> traceing of the machine it is simulationg isn't valid, as they are
>>>>>> NOT
>>>>>> equivalent.
>>>>>>
>>>>>> The problem isn't the consideration of H0, the outer simulator
>>>>>> (possibly
>>>>>> being called by P0) but how you have to treat H1. Since the
>>>>>> behavior of
>>>>>> H1, even after it would have made its decision will affect the
>>>>>> execution
>>>>>> of P1, it can NOT be treated as a UTM, as it doesn't act like one.
>>>>>>
>>>>>> You logic is UNSOUND and FALSE. FAIL.
>>>>>>
>>>>>> H1's aborting affects P1's behavior (since that is its caller, not
>>>>>> its
>>>>>> input) so this means that even though H0's decision to abort can't
>>>>>> affect P1's behavior, it does need to consider H1's behavior as not a
>>>>>> pure simulatior.
>>>>>>
>>>>>> In fact, your claimed rule, if you want to hold to it, means that
>>>>>> switching H0 to a real UTM can't affect the behavior of P1, and we
>>>>>> know
>>>>>> that P(P) is halting, and thus UTM(P,P) is halting, so UTM(P1,P2) is
>>>>>> halting (since all levels of P are the same), the we can show that
>>>>>> the
>>>>>> 'input' to H0 is a halting computation, it is just a fact that H0
>>>>>> doesn't simulate it far enough to see that.
>>>>>>
>>>>>
>>>>>
>>>>
>>>
>>>
>>
>
>