On 8/18/2021 6:43 PM, Richard Damon wrote:
> 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.
>

That you fail to comprehend what I say counts as less than no rebuttal
at all. A rebuttal requires a sequence of valid deductive logical
inference beginning with premises that can be verified as true.

The meaning of my above words prove that they are true.

> 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.
>>>>>>>
>>>>>>
>>>>>>
>>>>>
>>>>
>>>>
>>>
>>
>>
>

--
Copyright 2021 Pete Olcott

"Great spirits have always encountered violent opposition from mediocre
minds." Einstein