Can an abort decider be defined that cannot be fooled by any
pathological input?
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 }
Of all of the elements of the set of H(D,D) where H simulates its
input there are matched pairs of otherwise identical elements that
only differ by whether they abort their simulation or not.
The half of these that don't abort are incorrect because all deciders
must halt. This makes the other half correct about the abort/no abort decision.
I don't think an abort decider can be fooled by a pathological input.
Can an abort decider be defined that cannot be fooled by any
pathological input?
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 }
Of all of the elements of the set of H(D,D) where H simulates its
input there are matched pairs of otherwise identical elements that
only differ by whether they abort their simulation or not.
The half of these that don't abort are incorrect because all deciders
must halt. This makes the other half correct about the abort/no abort decision.
I don't think an abort decider can be fooled by a pathological input.
Can an abort decider be defined that cannot be fooled by any
pathological input?
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 }
Of all of the elements of the set of H(D,D) where H simulates its
input there are matched pairs of otherwise identical elements that
only differ by whether they abort their simulation or not.
The half of these that don't abort are incorrect because all deciders
must halt. This makes the other half correct about the abort/no abort decision.
I don't think an abort decider can be fooled by a pathological input.
On 3/24/2024 3:51 AM, Fred. Zwarts wrote:
Op 24.mrt.2024 om 05:55 schreef olcott:
Can an abort decider be defined that cannot be fooled by any
pathological input?
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 }
Of all of the elements of the set of H(D,D) where H simulates its
input there are matched pairs of otherwise identical elements that
only differ by whether they abort their simulation or not.
The half of these that don't abort are incorrect because all deciders
must halt. This makes the other half correct about the abort/no abort
decision.
No. The other, aborting, half is just wrong, because it aborts when it
is not needed. So, the half that aborts is wrong and it may be argued
that it is better to not abort something that halts on its own and that
At least two software engineers with masters degrees in computer science disagree.
Exactly what are you software engineering skills?
I have been a professional C++ software engineer since Y2K.
therefore not responding is better than responding with a wrong
answer. So, both halves are wrong, but the half that aborts is more
wrong. It gives the wrong answer. The other half is also wrong, but it
does not give a wrong answer, but does not respond.
I am very sorry to hear that.
I don't think an abort decider can be fooled by a pathological input.
On 3/25/2024 10:48 AM, Fred. Zwarts wrote:
Op 25.mrt.2024 om 16:17 schreef olcott:
On 3/24/2024 3:51 AM, Fred. Zwarts wrote:
Op 24.mrt.2024 om 05:55 schreef olcott:
Can an abort decider be defined that cannot be fooled by any
pathological input?
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 }
Of all of the elements of the set of H(D,D) where H simulates its
input there are matched pairs of otherwise identical elements that
only differ by whether they abort their simulation or not.
The half of these that don't abort are incorrect because all deciders >>>>> must halt. This makes the other half correct about the abort/no abort >>>>> decision.
No. The other, aborting, half is just wrong, because it aborts when
it is not needed. So, the half that aborts is wrong and it may be
argued that it is better to not abort something that halts on its
own and that
At least two software engineers with masters degrees in computer science >>> disagree.
Two is not many, considering that with Google for any invalid idea it
is easy to find a several people with a master degree supporting it.
Exactly what are you software engineering skills?
I have been professionally programming since 1986 in several
languages. (Non professionally I started programming in 1975). Since
about 1990 I programmed in C and since about 2000 in C++.
I have been a professional C++ software engineer since Y2K.
I'm sorry to hear that olcott has been so smart, but now he does not
even sees what even a beginner sees.
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.
*The subject matter is THE D simulated by any H as specified above*
*Try and point put any mistake without using the strawman deception*
On 3/24/2024 12:22 PM, Mikko wrote:
On 2024-03-23 16:45:54 +0000, olcott said:
On 3/23/2024 11:15 AM, Mikko wrote:
On 2024-03-23 14:25:20 +0000, olcott said:
On 3/23/2024 6:14 AM, Mikko wrote:
On 2024-03-22 18:43:39 +0000, olcott said:
On 3/22/2024 1:30 PM, Mikko wrote:
On 2024-03-22 15:44:35 +0000, olcott said:
On 3/22/2024 2:54 AM, Mikko wrote:
On 2024-03-21 18:26:44 +0000, olcott said:
On 3/21/2024 12:31 PM, immibis wrote:
On 21/03/24 05:37, olcott wrote:
On 3/20/2024 11:19 PM, immibis wrote:
On 21/03/24 04:59, olcott wrote:
On 3/20/2024 10:55 PM, immibis wrote:
On 21/03/24 03:50, olcott wrote:Yes I said this. They all simulate their input.
On 3/20/2024 9:41 PM, Richard Damon wrote:
On 3/20/24 10:18 PM, olcott wrote:
On 3/20/2024 9:13 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>> On 3/20/24 7:38 PM, olcott wrote:
On 3/20/2024 6:34 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>> On 3/20/24 6:52 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>> On 3/20/2024 5:47 PM, immibis wrote: >>>>>>>>>>>>>>>>>>>>>>>> On 20/03/24 23:01, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>> On 3/20/2024 4:51 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>> On 3/20/24 3:07 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/20/2024 1:49 PM, Fred. Zwarts wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>> Op 20.mrt.2024 om 17:11 schreef olcott: >>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/20/2024 10:50 AM, Mikko wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2024-03-20 13:20:51 +0000, olcott said: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
I am specifying a single D and an infinite set of implementations of H.Can D correctly simulated by H terminate normally? >>>>>>>>>>>>>>>>>>>>>>>>>>> 01 int D(ptr x) // ptr is pointer to int function >>>>>>>>>>>>>>>>>>>>>>>>>>> 02 {No. The H that answers 'yes' is a different H. >>>>>>>>>>>>>>>>>>>>>>>>>>>On 3/20/2024 3:24 AM, Mikko wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 2024-03-19 18:15:42 +0000, olcott said: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>Therefore the correct answer H(D,D) should give is "yes".
On 3/19/2024 12:41 PM, immibis wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 19/03/24 05:11, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/18/2024 10:11 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> On 3/18/24 7:46 PM, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 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:
*Here are the two key steps to that* >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> (1) Abort deciders correctly decide to abort.you can't understand anything else that requires the prerequisiteexecution of its input would halt. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> If you can't even understand that H is a correct abort decider thenOn 18/03/24 05:42, olcott wrote: >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Do you understand that each H(D,D) must either abort or fail to abort?
Strawman deception. H is a halt decider if it tells whether the directDo you understand that D(D) halts? >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> *We are talking about the abort criteria*
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? >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
(2) The halting problem requires the correct answer to an incorrect
question thus must be redefined. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
But (2) is a LIE. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
There is nothing "Incorrect" about the Halting Question.
Every yes/no question: Does Ĥ ⟨Ĥ⟩ halt?
such that YES is a correct answer from one entity
and YES is an incorrect answer from another entity
is an incorrect question when posed to this second entity.
If Ĥ is your x86utm function D, then "yes" is the correct answer to all
entities.
*counter factual* >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> That is contradicted for H(D,D) and Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩
What is true is true even when contradicted by a liar.
D(D) and Ĥ ⟨Ĥ⟩ only halt because H(D,D) and Ĥ.H ⟨Ĥ⟩ ⟨Ĥ⟩ <are>
correctly reporting on what they actually see. >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
*That would cause D(D) to loop, thus wrong answer*
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 }
Every H(D,D) that does not abort its simulation input never
stops running.
It would be correct for this D. We can build another D, based on the
new H, but then the question changes, because the input changes. The
new H does not give the correct answer for the new D.
*That would cause D(D) to loop, thus wrong answer*No. The H that answers 'yes' is a different H. It would be correct for
this D. We can build another D, based on the new H, but then the
question changes, because the input changes. The new H does not give
the correct answer for the new D. >>>>>>>>>>>>>>>>>>>>>>>>>>>>> *That would cause D(D) to loop, thus wrong answer*
No. The H that answers 'yes' is a different H. It would be correct for
this D. We can build another D, based on the new H, but then the
question changes, because the input changes. The new H does not give
the correct answer for the new D. >>>>>>>>>>>>>>>>>>>>>>>>>>>>
Both questions have a correct answer, but the corresponding H failed to
give it. It seems Olcott is again confused, because he uses the same
names for different things. >>>>>>>>>>>>>>>>>>>>>>>>>>>>
Every H(D,D) that does not abort its simulation input never
stops running.
Trying to refer to a different H than every H is a very lame
attempt to get away with the strawman deception. >>>>>>>>>>>>>>>>>>>>>>>>>>>
Referring to a different D then the one you were given is a very lame
attempt to get away with a strawman deception. >>>>>>>>>>>>>>>>>>>>>>>>>
If you are still talking about the Linz proof instead of some bullshit,
every D is based on exactly one H. If you change H but don't change D,
the D is still based on the old H and the correct answer to the
question "Does D(D) halt?" does not change. >>>>>>>>>>>>>>>>>>>>>>>>
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 }
If you want to construe this as an infinite set of H/D pairs where you
are construing that each D is somehow different this makes no difference
at all.
Every H(D,D) that doesn't abort its simulated input never stops running.
Every H(D,D) that doesn't abort its simulated input never stops running.
Every H(D,D) that doesn't abort its simulated input never stops running.
Which STILL doesn't say what happens to the D's built on the Hs that DO Abort.
*All of them are on the correct side of the abort/no abort decision*
Then why do they get the wrong answer?
Are you trying to get away with contradicting yourself? >>>>>>>>>>>>>>>>>>>
On 3/20/2024 6:02 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>> > On 3/20/24 6:01 PM, olcott wrote:
Every H(D,D) that doesn't abort its simulated input >>>>>>>>>>>>>>>>>>> >> never stops running.;
Yep, shows that H's that don't abort the D built on >>>>>>>>>>>>>>>>>>> > them won't be deciders...
Nothing contradictory about that.
You have two distinct classes of H, that make DIFFERENT errors due to
different behaviors they create.
Those whose programming make them never abort create a D that will
never halt, because its H get stuck in an infinite simulation loop, the
the top level H also gets stuck in. It NEEDS to abort, but doesn't
Then you have those H whose programming makes themselves abort, that
create a D that calls an H that also aborts its simulation and returns
causse that D to Halt. Thus this H, will it aborts its simulation,
didn't NEED to abort it.
So you don't understand that when the executed H does not abort that
none of them do because they are all the exact same code? >>>>>>>>>>>>>>>>>
Didn't you say H was an infinite set of different programs? >>>>>>>>>>>>>>>
So you don't understand that different programs are not all the exact
same code.
All of the simulated H(D,D) operate exactly the way that the >>>>>>>>>>>>> executed one does because it is the exact same code. >>>>>>>>>>>>>
So if we skip the abort instruction of the outer H in a debugger then
none of them will abort?
If we ever skip the abort instruction we must do it in every H or >>>>>>>>>>> we are cheating. Mike was probably not aware that he was cheating >>>>>>>>>>> when he suggested skipping the outer one of them.
We can cheat when we use a debugger.
Yes and you understand that is cheating, good for you.
It is a debugging trick that can be used to determine whether a particular
correction might fix the bug. Usually other methods are better but in >>>>>>>> debugging one must be creative.
But the interesting question is what happens if you do as immibis >>>>>>>> proposed.
That same "debugging trick" causes the halting problem proofs
to fail because it causes H(D,D) == Halts(D,D).
"Cause" only in the same sense magic words cause a rabit to
come out of the magician's empty hat.
"Cause" in the sense of semantically entails.
When you knock over a bucket of oat this causes
the bucket of oats to be knocked over.
When the executed H is allowed to have different behavior
than its simulated version then the halting problem would
be solved by this cheat.
It is not actually solved because it is a cheat.
So far the nearest you have come to a solution is a halt decider
that sheats but still fails.
I have come up with a decidability decider that refutes Rice and
everyone uses a deceptive ruse to avoid even talking about this:
It does not refute anything unless you prove that it does. You
can't prove because you don't know what proof must look like.
When a counter-example showing that an abort decider can be fooled
is categorically proven to not exist then this is conclusive proof
that a universal abort decider exists.
In the mean time the fact that no counter-example has been provided
makes the claim that a universal abort decider exists unrefuted.
On 3/24/2024 3:51 AM, Fred. Zwarts wrote:
Op 24.mrt.2024 om 05:55 schreef olcott:
Can an abort decider be defined that cannot be fooled by any
pathological input?
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 }
Of all of the elements of the set of H(D,D) where H simulates its
input there are matched pairs of otherwise identical elements that
only differ by whether they abort their simulation or not.
The half of these that don't abort are incorrect because all deciders
must halt. This makes the other half correct about the abort/no abort
decision.
No. The other, aborting, half is just wrong, because it aborts when it
is not needed. So, the half that aborts is wrong and it may be argued
that it is better to not abort something that halts on its own and that
At least two software engineers with masters degrees in computer science disagree. Exactly what are you software engineering skills? I have been
a professional C++ software engineer since Y2K.
therefore not responding is better than responding with a wrong
answer. So, both halves are wrong, but the half that aborts is more
wrong. It gives the wrong answer. The other half is also wrong, but it
does not give a wrong answer, but does not respond.
I am very sorry to hear that.
I don't think an abort decider can be fooled by a pathological input.
On 3/25/2024 11:16 AM, Fred. Zwarts wrote:
Op 25.mrt.2024 om 17:04 schreef olcott:
On 3/25/2024 10:48 AM, Fred. Zwarts wrote:
Op 25.mrt.2024 om 16:17 schreef olcott:
On 3/24/2024 3:51 AM, Fred. Zwarts wrote:
Op 24.mrt.2024 om 05:55 schreef olcott:
Can an abort decider be defined that cannot be fooled by any
pathological input?
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 }
Of all of the elements of the set of H(D,D) where H simulates its >>>>>>> input there are matched pairs of otherwise identical elements that >>>>>>> only differ by whether they abort their simulation or not.
The half of these that don't abort are incorrect because all
deciders
must halt. This makes the other half correct about the abort/no
abort
decision.
No. The other, aborting, half is just wrong, because it aborts
when it is not needed. So, the half that aborts is wrong and it
may be argued that it is better to not abort something that halts
on its own and that
At least two software engineers with masters degrees in computer
science
disagree.
Two is not many, considering that with Google for any invalid idea
it is easy to find a several people with a master degree supporting it. >>>>
Exactly what are you software engineering skills?
I have been professionally programming since 1986 in several
languages. (Non professionally I started programming in 1975). Since
about 1990 I programmed in C and since about 2000 in C++.
I have been a professional C++ software engineer since Y2K.
I'm sorry to hear that olcott has been so smart, but now he does not
even sees what even a beginner sees.
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)
Even a beginner sees that, if the H that aborts is chosen, simulated
H(D,D) aborts and returns false (unless aborted). So simulated D halts
(unless aborted).
I am estimating that you must be fibbing about your programming skill.
The D simulated by any implementation of H (that aborts or does not
abort its simulation) shown above cannot possibly reach its own line 04
also shown above.
On 3/25/2024 6:47 PM, Richard Damon wrote:
On 3/25/24 1:33 PM, olcott wrote:
On 3/25/2024 11:16 AM, Fred. Zwarts wrote:
Op 25.mrt.2024 om 17:04 schreef olcott:
On 3/25/2024 10:48 AM, Fred. Zwarts wrote:
Op 25.mrt.2024 om 16:17 schreef olcott:
On 3/24/2024 3:51 AM, Fred. Zwarts wrote:
Op 24.mrt.2024 om 05:55 schreef olcott:
Can an abort decider be defined that cannot be fooled by any >>>>>>>>> pathological input?
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 }
Of all of the elements of the set of H(D,D) where H simulates its >>>>>>>>> input there are matched pairs of otherwise identical elements that >>>>>>>>> only differ by whether they abort their simulation or not.
The half of these that don't abort are incorrect because all >>>>>>>>> deciders
must halt. This makes the other half correct about the abort/no >>>>>>>>> abort
decision.
No. The other, aborting, half is just wrong, because it aborts >>>>>>>> when it is not needed. So, the half that aborts is wrong and it >>>>>>>> may be argued that it is better to not abort something that
halts on its own and that
At least two software engineers with masters degrees in computer >>>>>>> science
disagree.
Two is not many, considering that with Google for any invalid idea >>>>>> it is easy to find a several people with a master degree
supporting it.
Exactly what are you software engineering skills?
I have been professionally programming since 1986 in several
languages. (Non professionally I started programming in 1975).
Since about 1990 I programmed in C and since about 2000 in C++.
I have been a professional C++ software engineer since Y2K.
I'm sorry to hear that olcott has been so smart, but now he does
not even sees what even a beginner sees.
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)
Even a beginner sees that, if the H that aborts is chosen, simulated
H(D,D) aborts and returns false (unless aborted). So simulated D
halts (unless aborted).
I am estimating that you must be fibbing about your programming skill.
The D simulated by any implementation of H (that aborts or does not
abort its simulation) shown above cannot possibly reach its own line 04
also shown above.
But that isn't the question.
*That <is> the abort decision question*
The question is does that machine described by the input Halt when
run, or, alternatively, does its correct simulation (not just by H)
run forever (and thus needs to be aborted)?
Since you know that H(D,D) must abort its simulation to prevent its
own infinite execution I don't understand why you would lie about it.
I really want to get on to the next step and see if any input can
fool an abort decider into making the wrong abort decision.
Perhaps you already know that you are not up to this challenge?
Correct simulation refering to a simulation of the EXACT input given
to H, that calls the H that you claim to be giving the correct answer
(and not the "correct simulator")
On 3/25/2024 7:22 PM, Richard Damon wrote:
On 3/25/24 8:11 PM, olcott wrote:
On 3/25/2024 6:47 PM, Richard Damon wrote:
On 3/25/24 1:33 PM, olcott wrote:
On 3/25/2024 11:16 AM, Fred. Zwarts wrote:
Op 25.mrt.2024 om 17:04 schreef olcott:
On 3/25/2024 10:48 AM, Fred. Zwarts wrote:Even a beginner sees that, if the H that aborts is chosen,
Op 25.mrt.2024 om 16:17 schreef olcott:
On 3/24/2024 3:51 AM, Fred. Zwarts wrote:
Op 24.mrt.2024 om 05:55 schreef olcott:
Can an abort decider be defined that cannot be fooled by any >>>>>>>>>>> pathological input?
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 }
Of all of the elements of the set of H(D,D) where H simulates >>>>>>>>>>> its
input there are matched pairs of otherwise identical elements >>>>>>>>>>> that
only differ by whether they abort their simulation or not. >>>>>>>>>>>
The half of these that don't abort are incorrect because all >>>>>>>>>>> deciders
must halt. This makes the other half correct about the
abort/no abort
decision.
No. The other, aborting, half is just wrong, because it aborts >>>>>>>>>> when it is not needed. So, the half that aborts is wrong and >>>>>>>>>> it may be argued that it is better to not abort something that >>>>>>>>>> halts on its own and that
At least two software engineers with masters degrees in
computer science
disagree.
Two is not many, considering that with Google for any invalid
idea it is easy to find a several people with a master degree
supporting it.
Exactly what are you software engineering skills?
I have been professionally programming since 1986 in several
languages. (Non professionally I started programming in 1975). >>>>>>>> Since about 1990 I programmed in C and since about 2000 in C++. >>>>>>>>
I have been a professional C++ software engineer since Y2K.
I'm sorry to hear that olcott has been so smart, but now he does >>>>>>>> not even sees what even a beginner sees.
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) >>>>>>
simulated H(D,D) aborts and returns false (unless aborted). So
simulated D halts (unless aborted).
I am estimating that you must be fibbing about your programming skill. >>>>> The D simulated by any implementation of H (that aborts or does not
abort its simulation) shown above cannot possibly reach its own
line 04
also shown above.
But that isn't the question.
*That <is> the abort decision question*
But you agreed that a correct abort decider oly NEEDS to abort its
simulation if the correct simulation by a pure correct simulator of
the input given to H (which doesn't change, so for this case, still
calls that original H) will never reach a final state.
The question is does that machine described by the input Halt when
run, or, alternatively, does its correct simulation (not just by H)
run forever (and thus needs to be aborted)?
Since you know that H(D,D) must abort its simulation to prevent its
own infinite execution I don't understand why you would lie about it.
But an H that doesn't abort and an H that does abort are looking at
different inputs "D", since you agree that the behavior of D changes
based on the H that it is using.
Not at all. Of the infinite set of every possible implementation of
H where H(D,D) simulates its input everyone that chose to abort is necessarily correct.
I don't understand why you persist in lying about this.
I really want to get on to the next step and see if any input can
fool an abort decider into making the wrong abort decision.
But you need to get this step right first.
Perhaps you already know that you are not up to this challenge?
No, it seems that YOU are not up to it, as you can't seem to
understand the error that you are making.
You keep on lying to yourself about what your requirements are.
I am not the one that keeps using the strawman deception to change
the subject away from H(D,D) an abort decider for the above D.
Correct simulation refering to a simulation of the EXACT input given
to H, that calls the H that you claim to be giving the correct
answer (and not the "correct simulator")
On 3/25/2024 7:47 PM, Richard Damon wrote:
On 3/25/24 8:37 PM, olcott wrote:
On 3/25/2024 7:22 PM, Richard Damon wrote:
On 3/25/24 8:11 PM, olcott wrote:
On 3/25/2024 6:47 PM, Richard Damon wrote:
On 3/25/24 1:33 PM, olcott wrote:
On 3/25/2024 11:16 AM, Fred. Zwarts wrote:
Op 25.mrt.2024 om 17:04 schreef olcott:
On 3/25/2024 10:48 AM, Fred. Zwarts wrote:
Op 25.mrt.2024 om 16:17 schreef olcott:
On 3/24/2024 3:51 AM, Fred. Zwarts wrote:
Op 24.mrt.2024 om 05:55 schreef olcott:
Can an abort decider be defined that cannot be fooled by >>>>>>>>>>>>> any pathological input?
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 }
Of all of the elements of the set of H(D,D) where H
simulates its
input there are matched pairs of otherwise identical >>>>>>>>>>>>> elements that
only differ by whether they abort their simulation or not. >>>>>>>>>>>>>
The half of these that don't abort are incorrect because >>>>>>>>>>>>> all deciders
must halt. This makes the other half correct about the >>>>>>>>>>>>> abort/no abort
decision.
No. The other, aborting, half is just wrong, because it >>>>>>>>>>>> aborts when it is not needed. So, the half that aborts is >>>>>>>>>>>> wrong and it may be argued that it is better to not abort >>>>>>>>>>>> something that halts on its own and that
At least two software engineers with masters degrees in
computer science
disagree.
Two is not many, considering that with Google for any invalid >>>>>>>>>> idea it is easy to find a several people with a master degree >>>>>>>>>> supporting it.
Exactly what are you software engineering skills?
I have been professionally programming since 1986 in several >>>>>>>>>> languages. (Non professionally I started programming in 1975). >>>>>>>>>> Since about 1990 I programmed in C and since about 2000 in C++. >>>>>>>>>>
I have been a professional C++ software engineer since Y2K. >>>>>>>>>>I'm sorry to hear that olcott has been so smart, but now he >>>>>>>>>> does not even sees what even a beginner sees.
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)
Even a beginner sees that, if the H that aborts is chosen,
simulated H(D,D) aborts and returns false (unless aborted). So >>>>>>>> simulated D halts (unless aborted).
I am estimating that you must be fibbing about your programming
skill.
The D simulated by any implementation of H (that aborts or does not >>>>>>> abort its simulation) shown above cannot possibly reach its own
line 04
also shown above.
But that isn't the question.
*That <is> the abort decision question*
But you agreed that a correct abort decider oly NEEDS to abort its
simulation if the correct simulation by a pure correct simulator of
the input given to H (which doesn't change, so for this case, still
calls that original H) will never reach a final state.
But an H that doesn't abort and an H that does abort are looking at
The question is does that machine described by the input Halt when >>>>>> run, or, alternatively, does its correct simulation (not just by
H) run forever (and thus needs to be aborted)?
Since you know that H(D,D) must abort its simulation to prevent its
own infinite execution I don't understand why you would lie about it. >>>>
different inputs "D", since you agree that the behavior of D changes
based on the H that it is using.
Not at all. Of the infinite set of every possible implementation of
H where H(D,D) simulates its input everyone that chose to abort is
necessarily correct.
I don't understand why you persist in lying about this.
I really want to get on to the next step and see if any input can
fool an abort decider into making the wrong abort decision.
But you need to get this step right first.
Perhaps you already know that you are not up to this challenge?
No, it seems that YOU are not up to it, as you can't seem to
understand the error that you are making.
You keep on lying to yourself about what your requirements are.
I am not the one that keeps using the strawman deception to change
the subject away from H(D,D) an abort decider for the above D.
Neither am I.
YOU agreed that the criteria for an abort decider is only CORRECT if a
CORRECT simulation of the exact input given to H(D,D) (i.e UTM(D,D) )
does not halt, where D still calls that H(D,D)
I never agreed to that.
On 3/17/2024 12:22 AM, Richard Damon wrote:giving the input to a correct simulator, that simulator will not halt.
To me, for H to NEED to abort its simulation, that means that when
Yes that is correct.
Correct simulation refering to a simulation of the EXACT input
given to H, that calls the H that you claim to be giving the
correct answer (and not the "correct simulator")
On 3/25/2024 8:30 PM, Richard Damon wrote:
On 3/25/24 9:12 PM, olcott wrote:
On 3/25/2024 7:47 PM, Richard Damon wrote:
On 3/25/24 8:37 PM, olcott wrote:
On 3/25/2024 7:22 PM, Richard Damon wrote:
On 3/25/24 8:11 PM, olcott wrote:
On 3/25/2024 6:47 PM, Richard Damon wrote:
On 3/25/24 1:33 PM, olcott wrote:
On 3/25/2024 11:16 AM, Fred. Zwarts wrote:
Op 25.mrt.2024 om 17:04 schreef olcott:
On 3/25/2024 10:48 AM, Fred. Zwarts wrote:
Op 25.mrt.2024 om 16:17 schreef olcott:
On 3/24/2024 3:51 AM, Fred. Zwarts wrote:
Op 24.mrt.2024 om 05:55 schreef olcott:
Can an abort decider be defined that cannot be fooled by >>>>>>>>>>>>>>> any pathological input?
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 }
Of all of the elements of the set of H(D,D) where H >>>>>>>>>>>>>>> simulates its
input there are matched pairs of otherwise identical >>>>>>>>>>>>>>> elements that
only differ by whether they abort their simulation or not. >>>>>>>>>>>>>>>
The half of these that don't abort are incorrect because >>>>>>>>>>>>>>> all deciders
must halt. This makes the other half correct about the >>>>>>>>>>>>>>> abort/no abort
decision.
No. The other, aborting, half is just wrong, because it >>>>>>>>>>>>>> aborts when it is not needed. So, the half that aborts is >>>>>>>>>>>>>> wrong and it may be argued that it is better to not abort >>>>>>>>>>>>>> something that halts on its own and that
At least two software engineers with masters degrees in >>>>>>>>>>>>> computer science
disagree.
Two is not many, considering that with Google for any
invalid idea it is easy to find a several people with a >>>>>>>>>>>> master degree supporting it.
Exactly what are you software engineering skills?
I have been professionally programming since 1986 in several >>>>>>>>>>>> languages. (Non professionally I started programming in >>>>>>>>>>>> 1975). Since about 1990 I programmed in C and since about >>>>>>>>>>>> 2000 in C++.
I have been a professional C++ software engineer since Y2K. >>>>>>>>>>>>I'm sorry to hear that olcott has been so smart, but now he >>>>>>>>>>>> does not even sees what even a beginner sees.
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)
Even a beginner sees that, if the H that aborts is chosen, >>>>>>>>>> simulated H(D,D) aborts and returns false (unless aborted). So >>>>>>>>>> simulated D halts (unless aborted).
I am estimating that you must be fibbing about your programming >>>>>>>>> skill.
The D simulated by any implementation of H (that aborts or does >>>>>>>>> not
abort its simulation) shown above cannot possibly reach its own >>>>>>>>> line 04
also shown above.
But that isn't the question.
*That <is> the abort decision question*
But you agreed that a correct abort decider oly NEEDS to abort its >>>>>> simulation if the correct simulation by a pure correct simulator
of the input given to H (which doesn't change, so for this case,
still calls that original H) will never reach a final state.
The question is does that machine described by the input Halt
when run, or, alternatively, does its correct simulation (not
just by H) run forever (and thus needs to be aborted)?
Since you know that H(D,D) must abort its simulation to prevent its >>>>>>> own infinite execution I don't understand why you would lie about >>>>>>> it.
But an H that doesn't abort and an H that does abort are looking
at different inputs "D", since you agree that the behavior of D
changes based on the H that it is using.
Not at all. Of the infinite set of every possible implementation of
H where H(D,D) simulates its input everyone that chose to abort is
necessarily correct.
I don't understand why you persist in lying about this.
I really want to get on to the next step and see if any input can >>>>>>> fool an abort decider into making the wrong abort decision.
But you need to get this step right first.
Perhaps you already know that you are not up to this challenge?
No, it seems that YOU are not up to it, as you can't seem to
understand the error that you are making.
You keep on lying to yourself about what your requirements are.
I am not the one that keeps using the strawman deception to change
the subject away from H(D,D) an abort decider for the above D.
Neither am I.
YOU agreed that the criteria for an abort decider is only CORRECT if
a CORRECT simulation of the exact input given to H(D,D) (i.e
UTM(D,D) ) does not halt, where D still calls that H(D,D)
I never agreed to that.
Yes you did:
On 3/17/24 6:11 AM, olcott wrote:
On 3/17/2024 12:22 AM, Richard Damon wrote:giving the input to a correct simulator, that simulator will not halt.
To me, for H to NEED to abort its simulation, that means that when
;Yes that is correct.
;
Since the ONLY definition of a "Correct Simulator" is a simulator that
never aborts, you did..
Because we have been over this hundreds of times you know that I mean
that a correct simulator means that every step that H simulates was
correctly simulated, so why are you lying about this now?
Are you trying to run out the clock on my rebuttals?
On 3/25/2024 9:08 PM, Richard Damon wrote:
On 3/25/24 9:35 PM, olcott wrote:
On 3/25/2024 8:30 PM, Richard Damon wrote:
On 3/25/24 9:12 PM, olcott wrote:
On 3/25/2024 7:47 PM, Richard Damon wrote:
On 3/25/24 8:37 PM, olcott wrote:
On 3/25/2024 7:22 PM, Richard Damon wrote:
On 3/25/24 8:11 PM, olcott wrote:
On 3/25/2024 6:47 PM, Richard Damon wrote:
On 3/25/24 1:33 PM, olcott wrote:
On 3/25/2024 11:16 AM, Fred. Zwarts wrote:
Op 25.mrt.2024 om 17:04 schreef olcott:
On 3/25/2024 10:48 AM, Fred. Zwarts wrote:
Op 25.mrt.2024 om 16:17 schreef olcott:
On 3/24/2024 3:51 AM, Fred. Zwarts wrote:
Op 24.mrt.2024 om 05:55 schreef olcott:
Can an abort decider be defined that cannot be fooled >>>>>>>>>>>>>>>>> by any pathological input?
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 }
Of all of the elements of the set of H(D,D) where H >>>>>>>>>>>>>>>>> simulates its
input there are matched pairs of otherwise identical >>>>>>>>>>>>>>>>> elements that
only differ by whether they abort their simulation or not. >>>>>>>>>>>>>>>>>
The half of these that don't abort are incorrect >>>>>>>>>>>>>>>>> because all deciders
must halt. This makes the other half correct about the >>>>>>>>>>>>>>>>> abort/no abort
decision.
No. The other, aborting, half is just wrong, because it >>>>>>>>>>>>>>>> aborts when it is not needed. So, the half that aborts >>>>>>>>>>>>>>>> is wrong and it may be argued that it is better to not >>>>>>>>>>>>>>>> abort something that halts on its own and that
At least two software engineers with masters degrees in >>>>>>>>>>>>>>> computer science
disagree.
Two is not many, considering that with Google for any >>>>>>>>>>>>>> invalid idea it is easy to find a several people with a >>>>>>>>>>>>>> master degree supporting it.
Exactly what are you software engineering skills? >>>>>>>>>>>>>>I have been professionally programming since 1986 in >>>>>>>>>>>>>> several languages. (Non professionally I started
programming in 1975). Since about 1990 I programmed in C >>>>>>>>>>>>>> and since about 2000 in C++.
I have been a professional C++ software engineer since Y2K. >>>>>>>>>>>>>>I'm sorry to hear that olcott has been so smart, but now >>>>>>>>>>>>>> he does not even sees what even a beginner sees.
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)
Even a beginner sees that, if the H that aborts is chosen, >>>>>>>>>>>> simulated H(D,D) aborts and returns false (unless aborted). >>>>>>>>>>>> So simulated D halts (unless aborted).
I am estimating that you must be fibbing about your
programming skill.
The D simulated by any implementation of H (that aborts or >>>>>>>>>>> does not
abort its simulation) shown above cannot possibly reach its >>>>>>>>>>> own line 04
also shown above.
But that isn't the question.
*That <is> the abort decision question*
But you agreed that a correct abort decider oly NEEDS to abort >>>>>>>> its simulation if the correct simulation by a pure correct
simulator of the input given to H (which doesn't change, so for >>>>>>>> this case, still calls that original H) will never reach a final >>>>>>>> state.
The question is does that machine described by the input Halt >>>>>>>>>> when run, or, alternatively, does its correct simulation (not >>>>>>>>>> just by H) run forever (and thus needs to be aborted)?
Since you know that H(D,D) must abort its simulation to prevent >>>>>>>>> its
own infinite execution I don't understand why you would lie
about it.
But an H that doesn't abort and an H that does abort are looking >>>>>>>> at different inputs "D", since you agree that the behavior of D >>>>>>>> changes based on the H that it is using.
Not at all. Of the infinite set of every possible implementation of >>>>>>> H where H(D,D) simulates its input everyone that chose to abort is >>>>>>> necessarily correct.
I don't understand why you persist in lying about this.
I really want to get on to the next step and see if any input can >>>>>>>>> fool an abort decider into making the wrong abort decision.
But you need to get this step right first.
No, it seems that YOU are not up to it, as you can't seem to
Perhaps you already know that you are not up to this challenge? >>>>>>>>
understand the error that you are making.
You keep on lying to yourself about what your requirements are. >>>>>>>>
I am not the one that keeps using the strawman deception to change >>>>>>> the subject away from H(D,D) an abort decider for the above D.
Neither am I.
YOU agreed that the criteria for an abort decider is only CORRECT
if a CORRECT simulation of the exact input given to H(D,D) (i.e
UTM(D,D) ) does not halt, where D still calls that H(D,D)
I never agreed to that.
Yes you did:
*You just admitted to lying abut this* (see below).
On 3/17/24 6:11 AM, olcott wrote:
On 3/17/2024 12:22 AM, Richard Damon wrote:when giving the input to a correct simulator, that simulator will
To me, for H to NEED to abort its simulation, that means that
not halt.
;Yes that is correct.
;
Since the ONLY definition of a "Correct Simulator" is a simulator
that never aborts, you did..
Because we have been over this hundreds of times you know that I mean
that a correct simulator means that every step that H simulates was
correctly simulated, so why are you lying about this now?
Are you trying to run out the clock on my rebuttals?
And YOU know that when *I* say "Correct Simulation", I mean per the
definition of a UTM that exactly duplicates the full behavior of the
input machine, and you agreed to ME.
Then you are admitting that you lied when you claimed that
I believed that.
YOU definition is just illogical as it means that the behavior of a
machine is determined by the behavior of a machine that is not it.
Because deciders must always halt every H that never halts has incorrect halting behavior and every H that halts has correct halting behavior.
You are just PROVING that you have absolutely ZERO idea about what a
"Computation" means or what a "Program" is in this context.
You are just too stupid to be able to understand it, a stupidity that
appears to be self-inflicted.
On 3/25/2024 11:16 AM, Fred. Zwarts wrote:
Op 25.mrt.2024 om 17:04 schreef olcott:
On 3/25/2024 10:48 AM, Fred. Zwarts wrote:
Op 25.mrt.2024 om 16:17 schreef olcott:
On 3/24/2024 3:51 AM, Fred. Zwarts wrote:
Op 24.mrt.2024 om 05:55 schreef olcott:
Can an abort decider be defined that cannot be fooled by any
pathological input?
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 }
Of all of the elements of the set of H(D,D) where H simulates its >>>>>>> input there are matched pairs of otherwise identical elements that >>>>>>> only differ by whether they abort their simulation or not.
The half of these that don't abort are incorrect because all
deciders
must halt. This makes the other half correct about the abort/no
abort
decision.
No. The other, aborting, half is just wrong, because it aborts
when it is not needed. So, the half that aborts is wrong and it
may be argued that it is better to not abort something that halts
on its own and that
At least two software engineers with masters degrees in computer
science
disagree.
Two is not many, considering that with Google for any invalid idea
it is easy to find a several people with a master degree supporting it. >>>>
Exactly what are you software engineering skills?
I have been professionally programming since 1986 in several
languages. (Non professionally I started programming in 1975). Since
about 1990 I programmed in C and since about 2000 in C++.
I have been a professional C++ software engineer since Y2K.
I'm sorry to hear that olcott has been so smart, but now he does not
even sees what even a beginner sees.
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)
Even a beginner sees that, if the H that aborts is chosen, simulated
H(D,D) aborts and returns false (unless aborted). So simulated D halts
(unless aborted).
I am estimating that you must be fibbing about your programming skill.
The D simulated by any implementation of H (that aborts or does not
abort its simulation) shown above cannot possibly reach its own line 04
also shown above.
On 3/25/2024 10:01 PM, Richard Damon wrote:
On 3/25/24 10:53 PM, olcott wrote:
On 3/25/2024 9:08 PM, Richard Damon wrote:
On 3/25/24 9:35 PM, olcott wrote:
On 3/25/2024 8:30 PM, Richard Damon wrote:
On 3/25/24 9:12 PM, olcott wrote:
On 3/25/2024 7:47 PM, Richard Damon wrote:
On 3/25/24 8:37 PM, olcott wrote:
On 3/25/2024 7:22 PM, Richard Damon wrote:Neither am I.
On 3/25/24 8:11 PM, olcott wrote:
On 3/25/2024 6:47 PM, Richard Damon wrote:
On 3/25/24 1:33 PM, olcott wrote:
On 3/25/2024 11:16 AM, Fred. Zwarts wrote:
Op 25.mrt.2024 om 17:04 schreef olcott:
On 3/25/2024 10:48 AM, Fred. Zwarts wrote:
Op 25.mrt.2024 om 16:17 schreef olcott:Can D correctly simulated by H terminate normally? >>>>>>>>>>>>>>> 01 int D(ptr x) // ptr is pointer to int function >>>>>>>>>>>>>>> 02 {
On 3/24/2024 3:51 AM, Fred. Zwarts wrote:
Op 24.mrt.2024 om 05:55 schreef olcott:At least two software engineers with masters degrees in >>>>>>>>>>>>>>>>> computer science
Can an abort decider be defined that cannot be fooled >>>>>>>>>>>>>>>>>>> by any pathological input?
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 }
Of all of the elements of the set of H(D,D) where H >>>>>>>>>>>>>>>>>>> simulates its
input there are matched pairs of otherwise identical >>>>>>>>>>>>>>>>>>> elements that
only differ by whether they abort their simulation or >>>>>>>>>>>>>>>>>>> not.
The half of these that don't abort are incorrect >>>>>>>>>>>>>>>>>>> because all deciders
must halt. This makes the other half correct about >>>>>>>>>>>>>>>>>>> the abort/no abort
decision.
No. The other, aborting, half is just wrong, because >>>>>>>>>>>>>>>>>> it aborts when it is not needed. So, the half that >>>>>>>>>>>>>>>>>> aborts is wrong and it may be argued that it is better >>>>>>>>>>>>>>>>>> to not abort something that halts on its own and that >>>>>>>>>>>>>>>>>
disagree.
Two is not many, considering that with Google for any >>>>>>>>>>>>>>>> invalid idea it is easy to find a several people with a >>>>>>>>>>>>>>>> master degree supporting it.
Exactly what are you software engineering skills? >>>>>>>>>>>>>>>>I have been professionally programming since 1986 in >>>>>>>>>>>>>>>> several languages. (Non professionally I started >>>>>>>>>>>>>>>> programming in 1975). Since about 1990 I programmed in C >>>>>>>>>>>>>>>> and since about 2000 in C++.
I have been a professional C++ software engineer since >>>>>>>>>>>>>>>>> Y2K.
I'm sorry to hear that olcott has been so smart, but now >>>>>>>>>>>>>>>> he does not even sees what even a beginner sees. >>>>>>>>>>>>>>>
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)
Even a beginner sees that, if the H that aborts is chosen, >>>>>>>>>>>>>> simulated H(D,D) aborts and returns false (unless
aborted). So simulated D halts (unless aborted).
I am estimating that you must be fibbing about your
programming skill.
The D simulated by any implementation of H (that aborts or >>>>>>>>>>>>> does not
abort its simulation) shown above cannot possibly reach its >>>>>>>>>>>>> own line 04
also shown above.
But that isn't the question.
*That <is> the abort decision question*
But you agreed that a correct abort decider oly NEEDS to abort >>>>>>>>>> its simulation if the correct simulation by a pure correct >>>>>>>>>> simulator of the input given to H (which doesn't change, so >>>>>>>>>> for this case, still calls that original H) will never reach a >>>>>>>>>> final state.
The question is does that machine described by the input >>>>>>>>>>>> Halt when run, or, alternatively, does its correct
simulation (not just by H) run forever (and thus needs to be >>>>>>>>>>>> aborted)?
Since you know that H(D,D) must abort its simulation to
prevent its
own infinite execution I don't understand why you would lie >>>>>>>>>>> about it.
But an H that doesn't abort and an H that does abort are
looking at different inputs "D", since you agree that the
behavior of D changes based on the H that it is using.
Not at all. Of the infinite set of every possible
implementation of
H where H(D,D) simulates its input everyone that chose to abort is >>>>>>>>> necessarily correct.
I don't understand why you persist in lying about this.
But you need to get this step right first.
I really want to get on to the next step and see if any input >>>>>>>>>>> can
fool an abort decider into making the wrong abort decision. >>>>>>>>>>
No, it seems that YOU are not up to it, as you can't seem to >>>>>>>>>> understand the error that you are making.
Perhaps you already know that you are not up to this challenge? >>>>>>>>>>
You keep on lying to yourself about what your requirements are. >>>>>>>>>>
I am not the one that keeps using the strawman deception to change >>>>>>>>> the subject away from H(D,D) an abort decider for the above D. >>>>>>>>
YOU agreed that the criteria for an abort decider is only
CORRECT if a CORRECT simulation of the exact input given to
H(D,D) (i.e UTM(D,D) ) does not halt, where D still calls that >>>>>>>> H(D,D)
I never agreed to that.
Yes you did:
*You just admitted to lying abut this* (see below).
Nope, see below.
On 3/17/24 6:11 AM, olcott wrote:
On 3/17/2024 12:22 AM, Richard Damon wrote:not halt.
To me, for H to NEED to abort its simulation, that means that >>>>>> when giving the input to a correct simulator, that simulator will
;Yes that is correct.
;
Since the ONLY definition of a "Correct Simulator" is a simulator
that never aborts, you did..
Because we have been over this hundreds of times you know that I mean >>>>> that a correct simulator means that every step that H simulates was
correctly simulated, so why are you lying about this now?
Are you trying to run out the clock on my rebuttals?
And YOU know that when *I* say "Correct Simulation", I mean per the
definition of a UTM that exactly duplicates the full behavior of the
input machine, and you agreed to ME.
Then you are admitting that you lied when you claimed that
I believed that.
YOU agreed with what *I* said. When I speak, words mean what *I* hold
them to beleive.
Are you really willing to bet your soul on that?
Thus, YOU AGREED to MY definition, since you agrees with NO
qualifications of your statement.
YOU definition is just illogical as it means that the behavior of a
machine is determined by the behavior of a machine that is not it.
Because deciders must always halt every H that never halts has incorrect >>> halting behavior and every H that halts has correct halting behavior.
That isn't what a "Halt Decider" means, and you are just proving you
are just STUPID.
So now you are disagreeing that ALL deciders must always halt?
You are acting SO dumb, it seems it MUST be an act, that or you are
just a TOTAL MORON.
Either way, You are KILLING any chance that any of your idea might be
considered in the future by eople reading these words.
You are LITERALLY destroying you own ability to acheive your goals,
and have turned your life into a TOTAL WASTE.
You are just PROVING that you have absolutely ZERO idea about what a
"Computation" means or what a "Program" is in this context.
You are just too stupid to be able to understand it, a stupidity
that appears to be self-inflicted.
On 3/26/2024 6:43 AM, Richard Damon wrote:
On 3/25/24 11:29 PM, olcott wrote:Seems foolish to me. I never bet what I cannot afford to lose.
On 3/25/2024 10:01 PM, Richard Damon wrote:
On 3/25/24 10:53 PM, olcott wrote:
On 3/25/2024 9:08 PM, Richard Damon wrote:
On 3/25/24 9:35 PM, olcott wrote:
On 3/25/2024 8:30 PM, Richard Damon wrote:
On 3/25/24 9:12 PM, olcott wrote:
On 3/25/2024 7:47 PM, Richard Damon wrote:
On 3/25/24 8:37 PM, olcott wrote:
On 3/25/2024 7:22 PM, Richard Damon wrote:Neither am I.
On 3/25/24 8:11 PM, olcott wrote:
On 3/25/2024 6:47 PM, Richard Damon wrote:
On 3/25/24 1:33 PM, olcott wrote:
On 3/25/2024 11:16 AM, Fred. Zwarts wrote:
Op 25.mrt.2024 om 17:04 schreef olcott:
On 3/25/2024 10:48 AM, Fred. Zwarts wrote:
Op 25.mrt.2024 om 16:17 schreef olcott:Can D correctly simulated by H terminate normally? >>>>>>>>>>>>>>>>> 01 int D(ptr x) // ptr is pointer to int function >>>>>>>>>>>>>>>>> 02 {
On 3/24/2024 3:51 AM, Fred. Zwarts wrote: >>>>>>>>>>>>>>>>>>>> Op 24.mrt.2024 om 05:55 schreef olcott: >>>>>>>>>>>>>>>>>>>>> Can an abort decider be defined that cannot be >>>>>>>>>>>>>>>>>>>>> fooled by any pathological input?
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 }
Of all of the elements of the set of H(D,D) where H >>>>>>>>>>>>>>>>>>>>> simulates its
input there are matched pairs of otherwise >>>>>>>>>>>>>>>>>>>>> identical elements that
only differ by whether they abort their simulation >>>>>>>>>>>>>>>>>>>>> or not.
The half of these that don't abort are incorrect >>>>>>>>>>>>>>>>>>>>> because all deciders
must halt. This makes the other half correct about >>>>>>>>>>>>>>>>>>>>> the abort/no abort
decision.
No. The other, aborting, half is just wrong, because >>>>>>>>>>>>>>>>>>>> it aborts when it is not needed. So, the half that >>>>>>>>>>>>>>>>>>>> aborts is wrong and it may be argued that it is >>>>>>>>>>>>>>>>>>>> better to not abort something that halts on its own >>>>>>>>>>>>>>>>>>>> and that
At least two software engineers with masters degrees >>>>>>>>>>>>>>>>>>> in computer science
disagree.
Two is not many, considering that with Google for any >>>>>>>>>>>>>>>>>> invalid idea it is easy to find a several people with >>>>>>>>>>>>>>>>>> a master degree supporting it.
Exactly what are you software engineering skills? >>>>>>>>>>>>>>>>>>I have been professionally programming since 1986 in >>>>>>>>>>>>>>>>>> several languages. (Non professionally I started >>>>>>>>>>>>>>>>>> programming in 1975). Since about 1990 I programmed in >>>>>>>>>>>>>>>>>> C and since about 2000 in C++.
I have been a professional C++ software engineer >>>>>>>>>>>>>>>>>>> since Y2K.
I'm sorry to hear that olcott has been so smart, but >>>>>>>>>>>>>>>>>> now he does not even sees what even a beginner sees. >>>>>>>>>>>>>>>>>
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)
Even a beginner sees that, if the H that aborts is >>>>>>>>>>>>>>>> chosen, simulated H(D,D) aborts and returns false >>>>>>>>>>>>>>>> (unless aborted). So simulated D halts (unless aborted). >>>>>>>>>>>>>>>>
I am estimating that you must be fibbing about your >>>>>>>>>>>>>>> programming skill.
The D simulated by any implementation of H (that aborts >>>>>>>>>>>>>>> or does not
abort its simulation) shown above cannot possibly reach >>>>>>>>>>>>>>> its own line 04
also shown above.
But that isn't the question.
*That <is> the abort decision question*
But you agreed that a correct abort decider oly NEEDS to >>>>>>>>>>>> abort its simulation if the correct simulation by a pure >>>>>>>>>>>> correct simulator of the input given to H (which doesn't >>>>>>>>>>>> change, so for this case, still calls that original H) will >>>>>>>>>>>> never reach a final state.
The question is does that machine described by the input >>>>>>>>>>>>>> Halt when run, or, alternatively, does its correct >>>>>>>>>>>>>> simulation (not just by H) run forever (and thus needs to >>>>>>>>>>>>>> be aborted)?
Since you know that H(D,D) must abort its simulation to >>>>>>>>>>>>> prevent its
own infinite execution I don't understand why you would lie >>>>>>>>>>>>> about it.
But an H that doesn't abort and an H that does abort are >>>>>>>>>>>> looking at different inputs "D", since you agree that the >>>>>>>>>>>> behavior of D changes based on the H that it is using. >>>>>>>>>>>>
Not at all. Of the infinite set of every possible
implementation of
H where H(D,D) simulates its input everyone that chose to >>>>>>>>>>> abort is
necessarily correct.
I don't understand why you persist in lying about this.
But you need to get this step right first.
I really want to get on to the next step and see if any >>>>>>>>>>>>> input can
fool an abort decider into making the wrong abort decision. >>>>>>>>>>>>
Perhaps you already know that you are not up to this >>>>>>>>>>>>> challenge?
No, it seems that YOU are not up to it, as you can't seem to >>>>>>>>>>>> understand the error that you are making.
You keep on lying to yourself about what your requirements are. >>>>>>>>>>>>
I am not the one that keeps using the strawman deception to >>>>>>>>>>> change
the subject away from H(D,D) an abort decider for the above D. >>>>>>>>>>
YOU agreed that the criteria for an abort decider is only
CORRECT if a CORRECT simulation of the exact input given to >>>>>>>>>> H(D,D) (i.e UTM(D,D) ) does not halt, where D still calls that >>>>>>>>>> H(D,D)
I never agreed to that.
Yes you did:
*You just admitted to lying abut this* (see below).
Nope, see below.
On 3/17/24 6:11 AM, olcott wrote:
On 3/17/2024 12:22 AM, Richard Damon wrote:that when giving the input to a correct simulator, that
To me, for H to NEED to abort its simulation, that means
simulator will not halt.
;Yes that is correct.
;
Since the ONLY definition of a "Correct Simulator" is a
simulator that never aborts, you did..
Because we have been over this hundreds of times you know that I >>>>>>> mean
that a correct simulator means that every step that H simulates was >>>>>>> correctly simulated, so why are you lying about this now?
Are you trying to run out the clock on my rebuttals?
And YOU know that when *I* say "Correct Simulation", I mean per
the definition of a UTM that exactly duplicates the full behavior
of the input machine, and you agreed to ME.
Then you are admitting that you lied when you claimed that
I believed that.
YOU agreed with what *I* said. When I speak, words mean what *I*
hold them to beleive.
Are you really willing to bet your soul on that?
As I said, YES, but are you?
Maybe you should ask the leadership of your church about this.
Or does the fact that you already lost it mean it doesn't matter to you.That is not what scripture says.
Sure I can certainly agree with that.
Thus, YOU AGREED to MY definition, since you agrees with NO
qualifications of your statement.
That isn't what a "Halt Decider" means, and you are just proving you
YOU definition is just illogical as it means that the behavior of
a machine is determined by the behavior of a machine that is not it. >>>>>>
Because deciders must always halt every H that never halts has
incorrect
halting behavior and every H that halts has correct halting behavior. >>>>
are just STUPID.
So now you are disagreeing that ALL deciders must always halt?
Nope, but Halting isn't enough to make a foo decider a foo decider.
You are just playing with words again.I will agree that is the common understanding.
To be a Halt Decider, the output needs to match the Halting Function.
The is no preexisting common understanding of a simulating abort
decider because (to the best of my knowledge) no one every thought
of this before.
When-so-ever a simulating abort decider correctly determines in N
steps of correct simulation that the behavior of its input matches
a correct predefined non-halting behavior pattern the abort decider
is always correct to abort the simulation of this input.
To be an Abort Decider, the output needs to match the correctSomething like that. Would simulated D stop running on its own without
definition of an Abort Decider, namely would the correct simulation of
the input halt in a finite number of steps, or does the correct
simulation need to be aborted to come to an end,
ever having its simulation aborted?
Because you continue to lie about H(D,D) needing to abort its simulation
we are not getting to the point where we can see if any input could fool
an abort decider into getting the wrong abort decision answer.
On 3/26/2024 9:18 PM, Richard Damon wrote:
On 3/26/24 11:33 AM, olcott wrote:
On 3/26/2024 6:43 AM, Richard Damon wrote:
On 3/25/24 11:29 PM, olcott wrote:Seems foolish to me. I never bet what I cannot afford to lose.
On 3/25/2024 10:01 PM, Richard Damon wrote:
On 3/25/24 10:53 PM, olcott wrote:
On 3/25/2024 9:08 PM, Richard Damon wrote:
On 3/25/24 9:35 PM, olcott wrote:
On 3/25/2024 8:30 PM, Richard Damon wrote:
On 3/25/24 9:12 PM, olcott wrote:
On 3/25/2024 7:47 PM, Richard Damon wrote:
On 3/25/24 8:37 PM, olcott wrote:
On 3/25/2024 7:22 PM, Richard Damon wrote:Neither am I.
On 3/25/24 8:11 PM, olcott wrote:
On 3/25/2024 6:47 PM, Richard Damon wrote:
On 3/25/24 1:33 PM, olcott wrote:
On 3/25/2024 11:16 AM, Fred. Zwarts wrote:
Op 25.mrt.2024 om 17:04 schreef olcott:
On 3/25/2024 10:48 AM, Fred. Zwarts wrote: >>>>>>>>>>>>>>>>>>>> Op 25.mrt.2024 om 16:17 schreef olcott: >>>>>>>>>>>>>>>>>>>>> On 3/24/2024 3:51 AM, Fred. Zwarts wrote: >>>>>>>>>>>>>>>>>>>>>> Op 24.mrt.2024 om 05:55 schreef olcott: >>>>>>>>>>>>>>>>>>>>>>> Can an abort decider be defined that cannot be >>>>>>>>>>>>>>>>>>>>>>> fooled by any pathological input? >>>>>>>>>>>>>>>>>>>>>>>
Can D correctly simulated by H terminate normally? >>>>>>>>>>>>>>>>>>> 01 int D(ptr x) // ptr is pointer to int function >>>>>>>>>>>>>>>>>>> 02 {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 }
Of all of the elements of the set of H(D,D) where >>>>>>>>>>>>>>>>>>>>>>> H simulates its
input there are matched pairs of otherwise >>>>>>>>>>>>>>>>>>>>>>> identical elements that
only differ by whether they abort their >>>>>>>>>>>>>>>>>>>>>>> simulation or not.
The half of these that don't abort are incorrect >>>>>>>>>>>>>>>>>>>>>>> because all deciders
must halt. This makes the other half correct >>>>>>>>>>>>>>>>>>>>>>> about the abort/no abort
decision.
No. The other, aborting, half is just wrong, >>>>>>>>>>>>>>>>>>>>>> because it aborts when it is not needed. So, the >>>>>>>>>>>>>>>>>>>>>> half that aborts is wrong and it may be argued >>>>>>>>>>>>>>>>>>>>>> that it is better to not abort something that >>>>>>>>>>>>>>>>>>>>>> halts on its own and that
At least two software engineers with masters >>>>>>>>>>>>>>>>>>>>> degrees in computer science
disagree.
Two is not many, considering that with Google for >>>>>>>>>>>>>>>>>>>> any invalid idea it is easy to find a several people >>>>>>>>>>>>>>>>>>>> with a master degree supporting it.
Exactly what are you software engineering skills? >>>>>>>>>>>>>>>>>>>>I have been professionally programming since 1986 in >>>>>>>>>>>>>>>>>>>> several languages. (Non professionally I started >>>>>>>>>>>>>>>>>>>> programming in 1975). Since about 1990 I programmed >>>>>>>>>>>>>>>>>>>> in C and since about 2000 in C++.
I have been a professional C++ software engineer >>>>>>>>>>>>>>>>>>>>> since Y2K.
I'm sorry to hear that olcott has been so smart, but >>>>>>>>>>>>>>>>>>>> now he does not even sees what even a beginner sees. >>>>>>>>>>>>>>>>>>>
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)
Even a beginner sees that, if the H that aborts is >>>>>>>>>>>>>>>>>> chosen, simulated H(D,D) aborts and returns false >>>>>>>>>>>>>>>>>> (unless aborted). So simulated D halts (unless aborted). >>>>>>>>>>>>>>>>>>
I am estimating that you must be fibbing about your >>>>>>>>>>>>>>>>> programming skill.
The D simulated by any implementation of H (that aborts >>>>>>>>>>>>>>>>> or does not
abort its simulation) shown above cannot possibly reach >>>>>>>>>>>>>>>>> its own line 04
also shown above.
But that isn't the question.
*That <is> the abort decision question*
But you agreed that a correct abort decider oly NEEDS to >>>>>>>>>>>>>> abort its simulation if the correct simulation by a pure >>>>>>>>>>>>>> correct simulator of the input given to H (which doesn't >>>>>>>>>>>>>> change, so for this case, still calls that original H) >>>>>>>>>>>>>> will never reach a final state.
The question is does that machine described by the input >>>>>>>>>>>>>>>> Halt when run, or, alternatively, does its correct >>>>>>>>>>>>>>>> simulation (not just by H) run forever (and thus needs >>>>>>>>>>>>>>>> to be aborted)?
Since you know that H(D,D) must abort its simulation to >>>>>>>>>>>>>>> prevent its
own infinite execution I don't understand why you would >>>>>>>>>>>>>>> lie about it.
But an H that doesn't abort and an H that does abort are >>>>>>>>>>>>>> looking at different inputs "D", since you agree that the >>>>>>>>>>>>>> behavior of D changes based on the H that it is using. >>>>>>>>>>>>>>
Not at all. Of the infinite set of every possible
implementation of
H where H(D,D) simulates its input everyone that chose to >>>>>>>>>>>>> abort is
necessarily correct.
I don't understand why you persist in lying about this. >>>>>>>>>>>>>
But you need to get this step right first.
I really want to get on to the next step and see if any >>>>>>>>>>>>>>> input can
fool an abort decider into making the wrong abort decision. >>>>>>>>>>>>>>
Perhaps you already know that you are not up to this >>>>>>>>>>>>>>> challenge?
No, it seems that YOU are not up to it, as you can't seem >>>>>>>>>>>>>> to understand the error that you are making.
You keep on lying to yourself about what your requirements >>>>>>>>>>>>>> are.
I am not the one that keeps using the strawman deception to >>>>>>>>>>>>> change
the subject away from H(D,D) an abort decider for the above D. >>>>>>>>>>>>
YOU agreed that the criteria for an abort decider is only >>>>>>>>>>>> CORRECT if a CORRECT simulation of the exact input given to >>>>>>>>>>>> H(D,D) (i.e UTM(D,D) ) does not halt, where D still calls >>>>>>>>>>>> that H(D,D)
I never agreed to that.
Yes you did:
*You just admitted to lying abut this* (see below).
Nope, see below.
On 3/17/24 6:11 AM, olcott wrote:
On 3/17/2024 12:22 AM, Richard Damon wrote:simulator will not halt.
To me, for H to NEED to abort its simulation, that means >>>>>>>>>> that when giving the input to a correct simulator, that
;Yes that is correct.
;
Since the ONLY definition of a "Correct Simulator" is a
simulator that never aborts, you did..
Because we have been over this hundreds of times you know that >>>>>>>>> I mean
that a correct simulator means that every step that H simulates >>>>>>>>> was
correctly simulated, so why are you lying about this now?
Are you trying to run out the clock on my rebuttals?
And YOU know that when *I* say "Correct Simulation", I mean per >>>>>>>> the definition of a UTM that exactly duplicates the full
behavior of the input machine, and you agreed to ME.
Then you are admitting that you lied when you claimed that
I believed that.
YOU agreed with what *I* said. When I speak, words mean what *I*
hold them to beleive.
Are you really willing to bet your soul on that?
As I said, YES, but are you?
Maybe you should ask the leadership of your church about this.
But I know I can't lose, because I know of the promise of God and that
he has written my name in his Book of Life.
Or does the fact that you already lost it mean it doesn't matter toThat is not what scripture says.
you.
It does, but you do not understand it.
You seem to have reached the point where God has turned you over to
your own desires, giving you the taste of eternal hell here, to see if
you will repent.
If you do, you can claim your soul back, but for now, YOU have given
it to the devil.
Galatians 5:14 NRSV
For the whole law is summed up in a single commandment,
“You shall love your neighbor as yourself.”
Isaiah 45:6
That they may know from the rising of the sun, and from
the west, that there is none beside me. I am the Lord, and
there is none else.
When one takes the above two verses 100% literally as if
they were a mathematical specification one gets an entirely
different meaning than everyone else gets.
I checked the last very with two Hebrew bible scholars and
they both agree that it says nothing besides God actually
exists.
All those lead by the Holy Spirit are on the right path. I
am doing what I can for additional spiritual confirmation.
Sure I can certainly agree with that.
Thus, YOU AGREED to MY definition, since you agrees with NO
qualifications of your statement.
YOU definition is just illogical as it means that the behavior >>>>>>>> of a machine is determined by the behavior of a machine that is >>>>>>>> not it.
Because deciders must always halt every H that never halts has
incorrect
halting behavior and every H that halts has correct halting
behavior.
That isn't what a "Halt Decider" means, and you are just proving
you are just STUPID.
So now you are disagreeing that ALL deciders must always halt?
Nope, but Halting isn't enough to make a foo decider a foo decider.
So, the fact that you deciders just Halt, doesn't make the correct
Halt Deciders, they are only that if their answer to H(M,d) matchs
Halts(M,d) for all M and d, or for this particular case H(D,D) must
match Halts(D,D), which is doesn't, so they are not correct halt
deciders.
// A is an abort decider
01 void B(ptr x) // ptr is pointer to void function
02 {
03 A(x, x);
04 return;
05 }
06
07 void main()
08 {
09 A(B,B);
10 }
*Execution Trace*
Line 09: main() invokes A(B,B);
*keeps repeating* (unless aborted)
Line 03: simulated B(B) invokes simulated A(B,B) that simulates B(B)
*Simulation invariant*
B correctly simulated by A cannot possibly reach past its own line 03.
When-so-ever a simulating abort decider correctly determines in N
steps of correct simulation that the behavior of its input matches
a correct predefined non-halting behavior pattern the abort decider
is always correct to abort the simulation of this input.
You are just playing with words again.I will agree that is the common understanding.
To be a Halt Decider, the output needs to match the Halting Function.
The is no preexisting common understanding of a simulating abort
decider because (to the best of my knowledge) no one every thought
of this before.
And either it is equivalent, or it isn't. If it isn't, then it says
nothing about the Halting Problem.
It is too disingenuous to say that it say nothing about the halting
problem. It as much as solves a different version of the halting
problem.
If the original version is incoherent the same sort of way that Naive
set theory allowed Russell's Paradox then an abort decider corrects
the erroneous halting problem that same way that ZFC corrected Naive
set theory.
Since the only rational definition of "Needs to Abort its simulation",
is that a correct simulation of the input would not halt, then your
"abort deciders" turn out to need to be actually Halt Decider.
An abort decider <is> a halt decider from its own point of view.
It is not and cannot be a halt decider from any other POV.
The logic of looking at what would happen if H was a different machine
ib a way that actually changed the behavior of the input (because you
either make the input not a computation, or re-write the input) is ust
invalid.
The whole class of every H(D,D) that simulates its input
is divided into two sub-classes:
(a) H(D,D) that DOES NOT abort its simulation is incorrect
(ABOUT THIS ABORT DECISION)
because it would never halt and all deciders must always halt.
(b) H(D,D) that DOES abort its simulation is correct
(ABOUT THIS ABORT DECISION)
because it would halt and all deciders must always halt.
Fred is seeming to understand this now.
On 3/26/2024 6:23 AM, Fred. Zwarts wrote:
Maybe there is some progress, now that even olcott uses names.
According olcott the whole set of H can be split in set(a) and set(b).
All H in set(a) are wrong, therefore all H is set(b) must be correct.
When-so-ever a simulating abort decider correctly determines in N
steps of correct simulation that the behavior of its input matches
a correct predefined non-halting behavior pattern the abort decider
is always correct to abort the simulation of this input.
Except there is no "correct predefined non-halting behavior pattern"
that exists in the simulation of this D(D), since that input WILL HALT
if the H that it is built on tries to take ANY of the patterns that
are reached in the simulation, to abort and return 0.
This was proven a couple of YEARS ago, and you ignored it, because it
was just an inconvienent truth.
Your logic is based on ASSUME SOMETHING TO EXIST, even if you can not
prove that it does. That is just UNSOUND logic, showing that you have
an UNSOUND logic system.
To be an Abort Decider, the output needs to match the correctSomething like that. Would simulated D stop running on its own
definition of an Abort Decider, namely would the correct simulation
of the input halt in a finite number of steps, or does the correct
simulation need to be aborted to come to an end,
without ever having its simulation aborted?
Right, but the D MUST be based on the ACTUAL H that you claim gives
the right answer. If that does abort, then you MUST give the input to
a DIFFERENT simulator, while keeping its pairing to that H.
Because you continue to lie about H(D,D) needing to abort its simulation >>> we are not getting to the point where we can see if any input could fool >>> an abort decider into getting the wrong abort decision answer.
But I have shown that the H(D,D) that aborts and returns 0, does not
need to actually abort its simulation.
*I really can't see how that is not simply a lie*
*I really can't see how that is not simply a lie*
*I really can't see how that is not simply a lie*
On 3/27/2024 7:48 PM, Richard Damon wrote:
On 3/26/24 11:10 PM, olcott wrote:
On 3/26/2024 9:18 PM, Richard Damon wrote:
On 3/26/24 11:33 AM, olcott wrote:
On 3/26/2024 6:43 AM, Richard Damon wrote:
On 3/25/24 11:29 PM, olcott wrote:Seems foolish to me. I never bet what I cannot afford to lose.
On 3/25/2024 10:01 PM, Richard Damon wrote:
On 3/25/24 10:53 PM, olcott wrote:
On 3/25/2024 9:08 PM, Richard Damon wrote:
On 3/25/24 9:35 PM, olcott wrote:
On 3/25/2024 8:30 PM, Richard Damon wrote:
On 3/25/24 9:12 PM, olcott wrote:
On 3/25/2024 7:47 PM, Richard Damon wrote:
On 3/25/24 8:37 PM, olcott wrote:
On 3/25/2024 7:22 PM, Richard Damon wrote:
On 3/25/24 8:11 PM, olcott wrote:
On 3/25/2024 6:47 PM, Richard Damon wrote:
On 3/25/24 1:33 PM, olcott wrote:
On 3/25/2024 11:16 AM, Fred. Zwarts wrote: >>>>>>>>>>>>>>>>>>>> Op 25.mrt.2024 om 17:04 schreef olcott: >>>>>>>>>>>>>>>>>>>>> On 3/25/2024 10:48 AM, Fred. Zwarts wrote: >>>>>>>>>>>>>>>>>>>>>> Op 25.mrt.2024 om 16:17 schreef olcott: >>>>>>>>>>>>>>>>>>>>>>> On 3/24/2024 3:51 AM, Fred. Zwarts wrote: >>>>>>>>>>>>>>>>>>>>>>>> Op 24.mrt.2024 om 05:55 schreef olcott: >>>>>>>>>>>>>>>>>>>>>>>>> Can an abort decider be defined that cannot be >>>>>>>>>>>>>>>>>>>>>>>>> fooled by any pathological input? >>>>>>>>>>>>>>>>>>>>>>>>>
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 }
Of all of the elements of the set of H(D,D) >>>>>>>>>>>>>>>>>>>>>>>>> where H simulates its
input there are matched pairs of otherwise >>>>>>>>>>>>>>>>>>>>>>>>> identical elements that
only differ by whether they abort their >>>>>>>>>>>>>>>>>>>>>>>>> simulation or not.
The half of these that don't abort are >>>>>>>>>>>>>>>>>>>>>>>>> incorrect because all deciders >>>>>>>>>>>>>>>>>>>>>>>>> must halt. This makes the other half correct >>>>>>>>>>>>>>>>>>>>>>>>> about the abort/no abort
decision.
No. The other, aborting, half is just wrong, >>>>>>>>>>>>>>>>>>>>>>>> because it aborts when it is not needed. So, the >>>>>>>>>>>>>>>>>>>>>>>> half that aborts is wrong and it may be argued >>>>>>>>>>>>>>>>>>>>>>>> that it is better to not abort something that >>>>>>>>>>>>>>>>>>>>>>>> halts on its own and that
At least two software engineers with masters >>>>>>>>>>>>>>>>>>>>>>> degrees in computer science
disagree.
Two is not many, considering that with Google for >>>>>>>>>>>>>>>>>>>>>> any invalid idea it is easy to find a several >>>>>>>>>>>>>>>>>>>>>> people with a master degree supporting it. >>>>>>>>>>>>>>>>>>>>>>
Exactly what are you software engineering skills? >>>>>>>>>>>>>>>>>>>>>>I have been professionally programming since 1986 >>>>>>>>>>>>>>>>>>>>>> in several languages. (Non professionally I >>>>>>>>>>>>>>>>>>>>>> started programming in 1975). Since about 1990 I >>>>>>>>>>>>>>>>>>>>>> programmed in C and since about 2000 in C++. >>>>>>>>>>>>>>>>>>>>>>
I have been a professional C++ software engineer >>>>>>>>>>>>>>>>>>>>>>> since Y2K.
I'm sorry to hear that olcott has been so smart, >>>>>>>>>>>>>>>>>>>>>> but now he does not even sees what even a beginner >>>>>>>>>>>>>>>>>>>>>> sees.
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)
Even a beginner sees that, if the H that aborts is >>>>>>>>>>>>>>>>>>>> chosen, simulated H(D,D) aborts and returns false >>>>>>>>>>>>>>>>>>>> (unless aborted). So simulated D halts (unless >>>>>>>>>>>>>>>>>>>> aborted).
I am estimating that you must be fibbing about your >>>>>>>>>>>>>>>>>>> programming skill.
The D simulated by any implementation of H (that >>>>>>>>>>>>>>>>>>> aborts or does not
abort its simulation) shown above cannot possibly >>>>>>>>>>>>>>>>>>> reach its own line 04
also shown above.
But that isn't the question.
*That <is> the abort decision question*
But you agreed that a correct abort decider oly NEEDS to >>>>>>>>>>>>>>>> abort its simulation if the correct simulation by a pure >>>>>>>>>>>>>>>> correct simulator of the input given to H (which doesn't >>>>>>>>>>>>>>>> change, so for this case, still calls that original H) >>>>>>>>>>>>>>>> will never reach a final state.
The question is does that machine described by the >>>>>>>>>>>>>>>>>> input Halt when run, or, alternatively, does its >>>>>>>>>>>>>>>>>> correct simulation (not just by H) run forever (and >>>>>>>>>>>>>>>>>> thus needs to be aborted)?
Since you know that H(D,D) must abort its simulation to >>>>>>>>>>>>>>>>> prevent its
own infinite execution I don't understand why you would >>>>>>>>>>>>>>>>> lie about it.
But an H that doesn't abort and an H that does abort are >>>>>>>>>>>>>>>> looking at different inputs "D", since you agree that >>>>>>>>>>>>>>>> the behavior of D changes based on the H that it is using. >>>>>>>>>>>>>>>>
Not at all. Of the infinite set of every possible >>>>>>>>>>>>>>> implementation of
H where H(D,D) simulates its input everyone that chose to >>>>>>>>>>>>>>> abort is
necessarily correct.
I don't understand why you persist in lying about this. >>>>>>>>>>>>>>>
I really want to get on to the next step and see if any >>>>>>>>>>>>>>>>> input can
fool an abort decider into making the wrong abort >>>>>>>>>>>>>>>>> decision.
But you need to get this step right first.
Perhaps you already know that you are not up to this >>>>>>>>>>>>>>>>> challenge?
No, it seems that YOU are not up to it, as you can't >>>>>>>>>>>>>>>> seem to understand the error that you are making. >>>>>>>>>>>>>>>>
You keep on lying to yourself about what your
requirements are.
I am not the one that keeps using the strawman deception >>>>>>>>>>>>>>> to change
the subject away from H(D,D) an abort decider for the >>>>>>>>>>>>>>> above D.
Neither am I.
YOU agreed that the criteria for an abort decider is only >>>>>>>>>>>>>> CORRECT if a CORRECT simulation of the exact input given >>>>>>>>>>>>>> to H(D,D) (i.e UTM(D,D) ) does not halt, where D still >>>>>>>>>>>>>> calls that H(D,D)
I never agreed to that.
Yes you did:
*You just admitted to lying abut this* (see below).
Nope, see below.
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.
;
;
Since the ONLY definition of a "Correct Simulator" is a >>>>>>>>>>>> simulator that never aborts, you did..
Because we have been over this hundreds of times you know >>>>>>>>>>> that I mean
that a correct simulator means that every step that H
simulates was
correctly simulated, so why are you lying about this now? >>>>>>>>>>>
Are you trying to run out the clock on my rebuttals?
And YOU know that when *I* say "Correct Simulation", I mean >>>>>>>>>> per the definition of a UTM that exactly duplicates the full >>>>>>>>>> behavior of the input machine, and you agreed to ME.
Then you are admitting that you lied when you claimed that
I believed that.
YOU agreed with what *I* said. When I speak, words mean what *I* >>>>>>>> hold them to beleive.
Are you really willing to bet your soul on that?
As I said, YES, but are you?
Maybe you should ask the leadership of your church about this.
But I know I can't lose, because I know of the promise of God and
that he has written my name in his Book of Life.
Or does the fact that you already lost it mean it doesn't matterThat is not what scripture says.
to you.
It does, but you do not understand it.
You seem to have reached the point where God has turned you over to
your own desires, giving you the taste of eternal hell here, to see
if you will repent.
If you do, you can claim your soul back, but for now, YOU have given
it to the devil.
So, you now go and show that you will also LIE about the meaning of
verses in the Bible.
You are going to show that just as you try to misinterprete the works
of the great logicitians that have proved things you don't like, you
are also going to misinterpete the Bible to try to juistify your own
ideas.
You are just Proof-Texting and doing Eisogesis on the text, instead of
Exegesis to discover the actual meaning.
Galatians 5:14 NRSV
For the whole law is summed up in a single commandment,
“You shall love your neighbor as yourself.”
Remember, Galatians was written to a CHURCH of BELIEVERS, who were
suffering some persecution. There was a movement to try to push them
back to "Old Testament Judiasm", which was a Key part of Paul's
discourse. Being Beleivers, talking about the need to love God, wasn't
an issue, but pointing out that the ceremonial law and animal
sacrifice system was no longer applicable, because it had been
fulfilled. The MORAL law, which is the part that derives from the
"Second Greatest Commandment"
From Matthew 22:37 Jesus replied: “ ‘Love the Lord your God with all >> your heart and with all your soul and with all your mind.’ 38 This is
the first and greatest commandment. And the second is like it: ‘Love
your neighbor as yourself.’ All the Law and the Prophets hang on these
two commandments.”
Paul can help interprete Jesus, but can not change his meaning.
Isaiah 45:6
That they may know from the rising of the sun, and from
the west, that there is none beside me. I am the Lord, and
there is none else.
When one takes the above two verses 100% literally as if
they were a mathematical specification one gets an entirely
different meaning than everyone else gets.
But 100% literal is NOT how you need to take the verses of the Bible.
I checked the last very with two Hebrew bible scholars and
they both agree that it says nothing besides God actually
exists.
So? Interpreting a verse out of context is just a pretext.
All those lead by the Holy Spirit are on the right path. I
am doing what I can for additional spiritual confirmation.
I seriously doubt you are being lead by the HOLY Spirit, as he can not
stand to be with a liar.
OR someone who blasphemes God by claiming to be comparable.
It is likely some other "spirit" guiding you to that lake of fire.
Sure I can certainly agree with that.
Thus, YOU AGREED to MY definition, since you agrees with NO
qualifications of your statement.
YOU definition is just illogical as it means that the behavior >>>>>>>>>> of a machine is determined by the behavior of a machine that >>>>>>>>>> is not it.
Because deciders must always halt every H that never halts has >>>>>>>>> incorrect
halting behavior and every H that halts has correct halting
behavior.
That isn't what a "Halt Decider" means, and you are just proving >>>>>>>> you are just STUPID.
So now you are disagreeing that ALL deciders must always halt?
Nope, but Halting isn't enough to make a foo decider a foo decider. >>>>>>
So, the fact that you deciders just Halt, doesn't make the correct
Halt Deciders, they are only that if their answer to H(M,d) matchs
Halts(M,d) for all M and d, or for this particular case H(D,D) must
match Halts(D,D), which is doesn't, so they are not correct halt
deciders.
// A is an abort decider
01 void B(ptr x) // ptr is pointer to void function
02 {
03 A(x, x);
04 return;
05 }
06
07 void main()
08 {
09 A(B,B);
10 }
*Execution Trace*
Line 09: main() invokes A(B,B);
*keeps repeating* (unless aborted)
Line 03: simulated B(B) invokes simulated A(B,B) that simulates B(B)
*Simulation invariant*
B correctly simulated by A cannot possibly reach past its own line 03.
When-so-ever a simulating abort decider correctly determines in N
steps of correct simulation that the behavior of its input matches
a correct predefined non-halting behavior pattern the abort decider
is always correct to abort the simulation of this input.
So, does A have a SPECIFIC set of code that it is running?
If not, your whole arguement is just a LIE.
If it does, how can it determine what it would do if it doesn't do
what it does, that would be something else, not it.
And, since you are defining "B" to use what ever A happens to exist at
the moment. B isn't a computation or even a program by the normal
definition of one.
In this case, I would say you are correct to say that THIS problem is
"invalid", due to the automagically changing input as you change the
decider looking at it.
Of course, since the REAL Haltng problem doesn't do that, it is still
valid.
You are just playing with words again.I will agree that is the common understanding.
To be a Halt Decider, the output needs to match the Halting Function. >>>>>>
The is no preexisting common understanding of a simulating abort
decider because (to the best of my knowledge) no one every thought
of this before.
And either it is equivalent, or it isn't. If it isn't, then it says
nothing about the Halting Problem.
It is too disingenuous to say that it say nothing about the halting
problem. It as much as solves a different version of the halting
problem.
Which isn't the Halting Problem. Something that isn't the Halting
Problem doesn't say much about the actual Halting Problem.
Now, if you want to try to actually formally define your differences,
and some how show that they are actually minor and insignificant, you
might be able to do something, but when you throw out fundamental
principles. liek a program is what the program is, you are just lying
about what you are doing.
If the original version is incoherent the same sort of way that Naive
set theory allowed Russell's Paradox then an abort decider corrects
the erroneous halting problem that same way that ZFC corrected Naive
set theory.
Since the only rational definition of "Needs to Abort its
simulation", is that a correct simulation of the input would not
halt, then your "abort deciders" turn out to need to be actually
Halt Decider.
An abort decider <is> a halt decider from its own point of view.
It is not and cannot be a halt decider from any other POV.
Only by lying to itself.
Since Halt Deciding is a OBJECTIVE criteria, it can't be equivalent,
or even very similar to your SUBJECTIVE new criteria, which you can't
even properly define, since you keep on with your using of
non-algorithmic terms to describe what it is to do.
The logic of looking at what would happen if H was a different
machine ib a way that actually changed the behavior of the input
(because you either make the input not a computation, or re-write
the input) is ust invalid.
The whole class of every H(D,D) that simulates its input
is divided into two sub-classes:
(a) H(D,D) that DOES NOT abort its simulation is incorrect
(ABOUT THIS ABORT DECISION)
because it would never halt and all deciders must always halt.
(b) H(D,D) that DOES abort its simulation is correct
(ABOUT THIS ABORT DECISION)
because it would halt and all deciders must always halt.
So, it is a DECIDER, but you haven't proven it is a CORRECT decider
about any defined mapping (other than the trivial problem of it maps
what it generates).
I haven't bothered to repeat this again because you far too consistently
deny easily verified facts. By whatever process that you can tell that
every member of (a) is incorrect and every member of (b) is correct is
the same one that H uses.
It took you far too long to acknowledge what you did and I am concerned
for your soul. Getting caught up in childish head games may be quite fun
yet not at the expense of your soul.
Your logic ignores that D changes its behavior based on the H that it
uses,
*I have known this for two years and you have denied this for two years*
so the fact that a D in group a, and thus using a group a H is not
halting says nothing about a a in group b,
Every element of (a) is incorrect thus making every element of (b)
correct about the abort decision.
and thus using a group b H. It can be shown that all these D are
HALTING, and thus there decider does NOT need to abort its simulation,
even though it DOES.
Fred is seeming to understand this now.
On 3/26/2024 6:23 AM, Fred. Zwarts wrote:
Maybe there is some progress, now that even olcott uses names.set(b).
According olcott the whole set of H can be split in set(a) and
All H in set(a) are wrong, therefore all H is set(b) must be correct. >>>
When-so-ever a simulating abort decider correctly determines in N
steps of correct simulation that the behavior of its input matches
a correct predefined non-halting behavior pattern the abort decider
is always correct to abort the simulation of this input.
Except there is no "correct predefined non-halting behavior pattern"
that exists in the simulation of this D(D), since that input WILL
HALT if the H that it is built on tries to take ANY of the patterns
that are reached in the simulation, to abort and return 0.
This was proven a couple of YEARS ago, and you ignored it, because
it was just an inconvienent truth.
Your logic is based on ASSUME SOMETHING TO EXIST, even if you can
not prove that it does. That is just UNSOUND logic, showing that you
have an UNSOUND logic system.
To be an Abort Decider, the output needs to match the correctSomething like that. Would simulated D stop running on its own
definition of an Abort Decider, namely would the correct
simulation of the input halt in a finite number of steps, or does
the correct simulation need to be aborted to come to an end,
without ever having its simulation aborted?
Right, but the D MUST be based on the ACTUAL H that you claim gives
the right answer. If that does abort, then you MUST give the input
to a DIFFERENT simulator, while keeping its pairing to that H.
Because you continue to lie about H(D,D) needing to abort its
simulation
we are not getting to the point where we can see if any input could
fool
an abort decider into getting the wrong abort decision answer.
But I have shown that the H(D,D) that aborts and returns 0, does not
need to actually abort its simulation.
*I really can't see how that is not simply a lie*
*I really can't see how that is not simply a lie*
*I really can't see how that is not simply a lie*
Yes, you can't, because you lie to yourself about the meaning of the
words.
I simply take key verses 100% literally as if God would always
say 100% exactly what he means and always means exactly 100% of
what he says. I am not aware of anyone else that does this.
If one does not do this then the bible can be taken in too many
different ways.
All of the different denominations having their differing views
proves that (at least) to the extent that they differ they are
incorrect.
Your mind is clouded by your own life of lies and deceit and your fear
to face the actual truth about the world, because it shows what is
going to happen to you.
On 3/27/2024 9:34 PM, Richard Damon wrote:
On 3/27/24 10:07 PM, olcott wrote:
On 3/27/2024 7:48 PM, Richard Damon wrote:
On 3/26/24 11:10 PM, olcott wrote:
On 3/26/2024 9:18 PM, Richard Damon wrote:
On 3/26/24 11:33 AM, olcott wrote:
On 3/26/2024 6:43 AM, Richard Damon wrote:
On 3/25/24 11:29 PM, olcott wrote:Seems foolish to me. I never bet what I cannot afford to lose.
On 3/25/2024 10:01 PM, Richard Damon wrote:
On 3/25/24 10:53 PM, olcott wrote:
On 3/25/2024 9:08 PM, Richard Damon wrote:
On 3/25/24 9:35 PM, olcott wrote:
On 3/25/2024 8:30 PM, Richard Damon wrote:
On 3/25/24 9:12 PM, olcott wrote:
On 3/25/2024 7:47 PM, Richard Damon wrote:
On 3/25/24 8:37 PM, olcott wrote:
On 3/25/2024 7:22 PM, Richard Damon wrote:
On 3/25/24 8:11 PM, olcott wrote:
On 3/25/2024 6:47 PM, Richard Damon wrote: >>>>>>>>>>>>>>>>>>>> On 3/25/24 1:33 PM, olcott wrote:
On 3/25/2024 11:16 AM, Fred. Zwarts wrote: >>>>>>>>>>>>>>>>>>>>>> Op 25.mrt.2024 om 17:04 schreef olcott: >>>>>>>>>>>>>>>>>>>>>>> On 3/25/2024 10:48 AM, Fred. Zwarts wrote: >>>>>>>>>>>>>>>>>>>>>>>> Op 25.mrt.2024 om 16:17 schreef olcott: >>>>>>>>>>>>>>>>>>>>>>>>> On 3/24/2024 3:51 AM, Fred. Zwarts wrote: >>>>>>>>>>>>>>>>>>>>>>>>>> Op 24.mrt.2024 om 05:55 schreef olcott: >>>>>>>>>>>>>>>>>>>>>>>>>>> Can an abort decider be defined that cannot >>>>>>>>>>>>>>>>>>>>>>>>>>> be fooled by any pathological input? >>>>>>>>>>>>>>>>>>>>>>>>>>>
At least two software engineers with masters >>>>>>>>>>>>>>>>>>>>>>>>> degrees in computer science01 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 }
Of all of the elements of the set of H(D,D) >>>>>>>>>>>>>>>>>>>>>>>>>>> where H simulates its
input there are matched pairs of otherwise >>>>>>>>>>>>>>>>>>>>>>>>>>> identical elements that
only differ by whether they abort their >>>>>>>>>>>>>>>>>>>>>>>>>>> simulation or not.
The half of these that don't abort are >>>>>>>>>>>>>>>>>>>>>>>>>>> incorrect because all deciders >>>>>>>>>>>>>>>>>>>>>>>>>>> must halt. This makes the other half correct >>>>>>>>>>>>>>>>>>>>>>>>>>> about the abort/no abort >>>>>>>>>>>>>>>>>>>>>>>>>>> decision.
No. The other, aborting, half is just wrong, >>>>>>>>>>>>>>>>>>>>>>>>>> because it aborts when it is not needed. So, >>>>>>>>>>>>>>>>>>>>>>>>>> the half that aborts is wrong and it may be >>>>>>>>>>>>>>>>>>>>>>>>>> argued that it is better to not abort >>>>>>>>>>>>>>>>>>>>>>>>>> something that halts on its own and that >>>>>>>>>>>>>>>>>>>>>>>>>
disagree.
Two is not many, considering that with Google >>>>>>>>>>>>>>>>>>>>>>>> for any invalid idea it is easy to find a >>>>>>>>>>>>>>>>>>>>>>>> several people with a master degree supporting it. >>>>>>>>>>>>>>>>>>>>>>>>
Exactly what are you software engineering skills? >>>>>>>>>>>>>>>>>>>>>>>>I have been professionally programming since >>>>>>>>>>>>>>>>>>>>>>>> 1986 in several languages. (Non professionally I >>>>>>>>>>>>>>>>>>>>>>>> started programming in 1975). Since about 1990 I >>>>>>>>>>>>>>>>>>>>>>>> programmed in C and since about 2000 in C++. >>>>>>>>>>>>>>>>>>>>>>>>
I have been a professional C++ software >>>>>>>>>>>>>>>>>>>>>>>>> engineer since Y2K.
I'm sorry to hear that olcott has been so smart, >>>>>>>>>>>>>>>>>>>>>>>> but now he does not even sees what even a >>>>>>>>>>>>>>>>>>>>>>>> beginner sees.
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)
Even a beginner sees that, if the H that aborts is >>>>>>>>>>>>>>>>>>>>>> chosen, simulated H(D,D) aborts and returns false >>>>>>>>>>>>>>>>>>>>>> (unless aborted). So simulated D halts (unless >>>>>>>>>>>>>>>>>>>>>> aborted).
I am estimating that you must be fibbing about your >>>>>>>>>>>>>>>>>>>>> programming skill.
The D simulated by any implementation of H (that >>>>>>>>>>>>>>>>>>>>> aborts or does not
abort its simulation) shown above cannot possibly >>>>>>>>>>>>>>>>>>>>> reach its own line 04
also shown above.
But that isn't the question.
*That <is> the abort decision question*
But you agreed that a correct abort decider oly NEEDS >>>>>>>>>>>>>>>>>> to abort its simulation if the correct simulation by a >>>>>>>>>>>>>>>>>> pure correct simulator of the input given to H (which >>>>>>>>>>>>>>>>>> doesn't change, so for this case, still calls that >>>>>>>>>>>>>>>>>> original H) will never reach a final state. >>>>>>>>>>>>>>>>>>
The question is does that machine described by the >>>>>>>>>>>>>>>>>>>> input Halt when run, or, alternatively, does its >>>>>>>>>>>>>>>>>>>> correct simulation (not just by H) run forever (and >>>>>>>>>>>>>>>>>>>> thus needs to be aborted)?
Since you know that H(D,D) must abort its simulation >>>>>>>>>>>>>>>>>>> to prevent its
own infinite execution I don't understand why you >>>>>>>>>>>>>>>>>>> would lie about it.
But an H that doesn't abort and an H that does abort >>>>>>>>>>>>>>>>>> are looking at different inputs "D", since you agree >>>>>>>>>>>>>>>>>> that the behavior of D changes based on the H that it >>>>>>>>>>>>>>>>>> is using.
Not at all. Of the infinite set of every possible >>>>>>>>>>>>>>>>> implementation of
H where H(D,D) simulates its input everyone that chose >>>>>>>>>>>>>>>>> to abort is
necessarily correct.
I don't understand why you persist in lying about this. >>>>>>>>>>>>>>>>>
I really want to get on to the next step and see if >>>>>>>>>>>>>>>>>>> any input can
fool an abort decider into making the wrong abort >>>>>>>>>>>>>>>>>>> decision.
But you need to get this step right first. >>>>>>>>>>>>>>>>>>
Perhaps you already know that you are not up to this >>>>>>>>>>>>>>>>>>> challenge?
No, it seems that YOU are not up to it, as you can't >>>>>>>>>>>>>>>>>> seem to understand the error that you are making. >>>>>>>>>>>>>>>>>>
You keep on lying to yourself about what your >>>>>>>>>>>>>>>>>> requirements are.
I am not the one that keeps using the strawman >>>>>>>>>>>>>>>>> deception to change
the subject away from H(D,D) an abort decider for the >>>>>>>>>>>>>>>>> above D.
Neither am I.
YOU agreed that the criteria for an abort decider is >>>>>>>>>>>>>>>> only CORRECT if a CORRECT simulation of the exact input >>>>>>>>>>>>>>>> given to H(D,D) (i.e UTM(D,D) ) does not halt, where D >>>>>>>>>>>>>>>> still calls that H(D,D)
I never agreed to that.
Yes you did:
*You just admitted to lying abut this* (see below).
Nope, see below.
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.
;
;
Since the ONLY definition of a "Correct Simulator" is a >>>>>>>>>>>>>> simulator that never aborts, you did..
Because we have been over this hundreds of times you know >>>>>>>>>>>>> that I mean
that a correct simulator means that every step that H >>>>>>>>>>>>> simulates was
correctly simulated, so why are you lying about this now? >>>>>>>>>>>>>
Are you trying to run out the clock on my rebuttals? >>>>>>>>>>>>>
And YOU know that when *I* say "Correct Simulation", I mean >>>>>>>>>>>> per the definition of a UTM that exactly duplicates the full >>>>>>>>>>>> behavior of the input machine, and you agreed to ME.
Then you are admitting that you lied when you claimed that >>>>>>>>>>> I believed that.
YOU agreed with what *I* said. When I speak, words mean what >>>>>>>>>> *I* hold them to beleive.
Are you really willing to bet your soul on that?
As I said, YES, but are you?
Maybe you should ask the leadership of your church about this.
But I know I can't lose, because I know of the promise of God and
that he has written my name in his Book of Life.
Or does the fact that you already lost it mean it doesn't matter >>>>>>>> to you.That is not what scripture says.
It does, but you do not understand it.
You seem to have reached the point where God has turned you over
to your own desires, giving you the taste of eternal hell here, to >>>>>> see if you will repent.
If you do, you can claim your soul back, but for now, YOU have
given it to the devil.
So, you now go and show that you will also LIE about the meaning of
verses in the Bible.
You are going to show that just as you try to misinterprete the
works of the great logicitians that have proved things you don't
like, you are also going to misinterpete the Bible to try to
juistify your own ideas.
You are just Proof-Texting and doing Eisogesis on the text, instead
of Exegesis to discover the actual meaning.
Galatians 5:14 NRSV
For the whole law is summed up in a single commandment,
“You shall love your neighbor as yourself.”
Remember, Galatians was written to a CHURCH of BELIEVERS, who were
suffering some persecution. There was a movement to try to push them
back to "Old Testament Judiasm", which was a Key part of Paul's
discourse. Being Beleivers, talking about the need to love God,
wasn't an issue, but pointing out that the ceremonial law and animal
sacrifice system was no longer applicable, because it had been
fulfilled. The MORAL law, which is the part that derives from the
"Second Greatest Commandment"
From Matthew 22:37 Jesus replied: “ ‘Love the Lord your God with >>>> all your heart and with all your soul and with all your mind.’ 38
This is the first and greatest commandment. And the second is like
it: ‘Love your neighbor as yourself.’ All the Law and the Prophets >>>> hang on these two commandments.”
Paul can help interprete Jesus, but can not change his meaning.
Isaiah 45:6
That they may know from the rising of the sun, and from
the west, that there is none beside me. I am the Lord, and
there is none else.
When one takes the above two verses 100% literally as if
they were a mathematical specification one gets an entirely
different meaning than everyone else gets.
But 100% literal is NOT how you need to take the verses of the Bible.
I checked the last very with two Hebrew bible scholars and
they both agree that it says nothing besides God actually
exists.
So? Interpreting a verse out of context is just a pretext.
All those lead by the Holy Spirit are on the right path. I
am doing what I can for additional spiritual confirmation.
I seriously doubt you are being lead by the HOLY Spirit, as he can
not stand to be with a liar.
OR someone who blasphemes God by claiming to be comparable.
It is likely some other "spirit" guiding you to that lake of fire.
Sure I can certainly agree with that.Nope, but Halting isn't enough to make a foo decider a foo decider. >>>>>>>>
Thus, YOU AGREED to MY definition, since you agrees with NO >>>>>>>>>> qualifications of your statement.
YOU definition is just illogical as it means that the
behavior of a machine is determined by the behavior of a >>>>>>>>>>>> machine that is not it.
Because deciders must always halt every H that never halts >>>>>>>>>>> has incorrect
halting behavior and every H that halts has correct halting >>>>>>>>>>> behavior.
That isn't what a "Halt Decider" means, and you are just
proving you are just STUPID.
So now you are disagreeing that ALL deciders must always halt? >>>>>>>>
So, the fact that you deciders just Halt, doesn't make the correct >>>>>> Halt Deciders, they are only that if their answer to H(M,d) matchs >>>>>> Halts(M,d) for all M and d, or for this particular case H(D,D)
must match Halts(D,D), which is doesn't, so they are not correct
halt deciders.
// A is an abort decider
01 void B(ptr x) // ptr is pointer to void function
02 {
03 A(x, x);
04 return;
05 }
06
07 void main()
08 {
09 A(B,B);
10 }
*Execution Trace*
Line 09: main() invokes A(B,B);
*keeps repeating* (unless aborted)
Line 03: simulated B(B) invokes simulated A(B,B) that simulates B(B) >>>>>
*Simulation invariant*
B correctly simulated by A cannot possibly reach past its own line 03. >>>>>
When-so-ever a simulating abort decider correctly determines in N
steps of correct simulation that the behavior of its input matches
a correct predefined non-halting behavior pattern the abort decider
is always correct to abort the simulation of this input.
So, does A have a SPECIFIC set of code that it is running?
If not, your whole arguement is just a LIE.
If it does, how can it determine what it would do if it doesn't do
what it does, that would be something else, not it.
And, since you are defining "B" to use what ever A happens to exist
at the moment. B isn't a computation or even a program by the normal
definition of one.
In this case, I would say you are correct to say that THIS problem
is "invalid", due to the automagically changing input as you change
the decider looking at it.
Of course, since the REAL Haltng problem doesn't do that, it is
still valid.
You are just playing with words again.I will agree that is the common understanding.
To be a Halt Decider, the output needs to match the Halting
Function.
The is no preexisting common understanding of a simulating abort >>>>>>> decider because (to the best of my knowledge) no one every thought >>>>>>> of this before.
And either it is equivalent, or it isn't. If it isn't, then it
says nothing about the Halting Problem.
It is too disingenuous to say that it say nothing about the halting
problem. It as much as solves a different version of the halting
problem.
Which isn't the Halting Problem. Something that isn't the Halting
Problem doesn't say much about the actual Halting Problem.
Now, if you want to try to actually formally define your
differences, and some how show that they are actually minor and
insignificant, you might be able to do something, but when you throw
out fundamental principles. liek a program is what the program is,
you are just lying about what you are doing.
If the original version is incoherent the same sort of way that Naive >>>>> set theory allowed Russell's Paradox then an abort decider corrects
the erroneous halting problem that same way that ZFC corrected Naive >>>>> set theory.
Since the only rational definition of "Needs to Abort its
simulation", is that a correct simulation of the input would not
halt, then your "abort deciders" turn out to need to be actually
Halt Decider.
An abort decider <is> a halt decider from its own point of view.
It is not and cannot be a halt decider from any other POV.
Only by lying to itself.
Since Halt Deciding is a OBJECTIVE criteria, it can't be equivalent,
or even very similar to your SUBJECTIVE new criteria, which you
can't even properly define, since you keep on with your using of
non-algorithmic terms to describe what it is to do.
The logic of looking at what would happen if H was a different
machine ib a way that actually changed the behavior of the input
(because you either make the input not a computation, or re-write
the input) is ust invalid.
The whole class of every H(D,D) that simulates its input
is divided into two sub-classes:
(a) H(D,D) that DOES NOT abort its simulation is incorrect
(ABOUT THIS ABORT DECISION)
because it would never halt and all deciders must always halt. >>>>>
(b) H(D,D) that DOES abort its simulation is correct
(ABOUT THIS ABORT DECISION)
because it would halt and all deciders must always halt.
So, it is a DECIDER, but you haven't proven it is a CORRECT decider
about any defined mapping (other than the trivial problem of it maps
what it generates).
I haven't bothered to repeat this again because you far too consistently >>> deny easily verified facts. By whatever process that you can tell that
every member of (a) is incorrect and every member of (b) is correct is
the same one that H uses.
Nope. JUST MORE LIES showing your utter stupidity.
It took you far too long to acknowledge what you did and I am concerned
for your soul. Getting caught up in childish head games may be quite fun >>> yet not at the expense of your soul.
I am concerned for YOUR soul, but fear you may be too far gone, since
you have clearly fallen for the devils lies.
Your logic ignores that D changes its behavior based on the H that
it uses,
*I have known this for two years and you have denied this for two years*
But if D changes its behavior based on the H it calls, then looking at
it with ANY H other than the one that is the one that you claim to
give the right answer is just a LIE.
And That H does what it DOES, and doesn't "Correctly Simulate" the
input to the point that shows that the input is non-halting, and every
logic you have shown is based on LYING that the H that you are working
with, which is actually a different H than you final H, is somehow
"the same" even though it uses a different one.
So, your arguement is just filled with LIES.
so the fact that a D in group a, and thus using a group a H is not
halting says nothing about a a in group b,
Every element of (a) is incorrect thus making every element of (b)
correct about the abort decision.
NOPE. JUST MORE LIES.
Proving you are totally STUPID.
and thus using a group b H. It can be shown that all these D are
HALTING, and thus there decider does NOT need to abort its
simulation, even though it DOES.
Fred is seeming to understand this now.
On 3/26/2024 6:23 AM, Fred. Zwarts wrote:
Maybe there is some progress, now that even olcott uses names.set(b).
According olcott the whole set of H can be split in set(a) and
All H in set(a) are wrong, therefore all H is set(b) must becorrect.
When-so-ever a simulating abort decider correctly determines in N >>>>>>> steps of correct simulation that the behavior of its input matches >>>>>>> a correct predefined non-halting behavior pattern the abort decider >>>>>>> is always correct to abort the simulation of this input.
Except there is no "correct predefined non-halting behavior
pattern" that exists in the simulation of this D(D), since that
input WILL HALT if the H that it is built on tries to take ANY of
the patterns that are reached in the simulation, to abort and
return 0.
This was proven a couple of YEARS ago, and you ignored it, because >>>>>> it was just an inconvienent truth.
Your logic is based on ASSUME SOMETHING TO EXIST, even if you can
not prove that it does. That is just UNSOUND logic, showing that
you have an UNSOUND logic system.
To be an Abort Decider, the output needs to match the correctSomething like that. Would simulated D stop running on its own
definition of an Abort Decider, namely would the correct
simulation of the input halt in a finite number of steps, or
does the correct simulation need to be aborted to come to an end, >>>>>>>>
without ever having its simulation aborted?
Right, but the D MUST be based on the ACTUAL H that you claim
gives the right answer. If that does abort, then you MUST give the >>>>>> input to a DIFFERENT simulator, while keeping its pairing to that H. >>>>>>
Because you continue to lie about H(D,D) needing to abort its
simulation
we are not getting to the point where we can see if any input
could fool
an abort decider into getting the wrong abort decision answer.
But I have shown that the H(D,D) that aborts and returns 0, does
not need to actually abort its simulation.
*I really can't see how that is not simply a lie*
*I really can't see how that is not simply a lie*
*I really can't see how that is not simply a lie*
Yes, you can't, because you lie to yourself about the meaning of the
words.
I simply take key verses 100% literally as if God would always
say 100% exactly what he means and always means exactly 100% of
what he says. I am not aware of anyone else that does this.
Which is the DEVIL'S way to read the Bible.
Look at his example of Tempting Jesus in the desert. Quoting
scriptures out of context, and trying to offer a LITERAL meaning that
differed from the actual meaning, that Jesus pointed out by his reply.
If one does not do this then the bible can be taken in too many
different ways.
Nope.
YOUR way allows all the variation,
All of the different denominations having their differing views
proves that (at least) to the extent that they differ they are
incorrect.
And the key is to actually STUDY to see what is the REAL truth behind
all the variations, and what differences are important, and what are
actually insubstantial.
When you actually KNOW what the Bible says, and talk to others who
also KNOW what the Bible says, you can discuss things with people even
from very dofferent backgrounds, and find agreement.
You get the big disagreements from people who don't actually know the
Bible, but just the "Dogma" of their religious community. These are
not really beleivers or possibly not even really "Christians" that
Christ will take in the last day.
It seems to me that all those things that do not pertain to
righteousness can be ignored.
Things such as this:
Is the Godhead three different beings or one being taking three forms?
On 3/28/2024 6:59 AM, Richard Damon wrote:
On 3/27/24 11:58 PM, olcott wrote:Many churches differ on the trinity.
On 3/27/2024 9:34 PM, Richard Damon wrote:
On 3/27/24 10:07 PM, olcott wrote:
All of the different denominations having their differing views
proves that (at least) to the extent that they differ they are
incorrect.
And the key is to actually STUDY to see what is the REAL truth
behind all the variations, and what differences are important, and
what are actually insubstantial.
When you actually KNOW what the Bible says, and talk to others who
also KNOW what the Bible says, you can discuss things with people
even from very dofferent backgrounds, and find agreement.
You get the big disagreements from people who don't actually know
the Bible, but just the "Dogma" of their religious community. These
are not really beleivers or possibly not even really "Christians"
that Christ will take in the last day.
It seems to me that all those things that do not pertain to
righteousness can be ignored.
Righteousness is having a Right Relationship to God. Ignoring who he
is makes that impossible.
Things such as this:
Is the Godhead three different beings or one being taking three forms?
But not correctly understanding who he is makes it impossible to have
a right relationship to him.
Yes, there are details that we do not need to (or in fact can not)
understand.
But God expects us to do all that we have the power to do, then he can
do the rest.
Intentionally neglecting what he says, puts you outside his Grace.
On 3/28/2024 7:07 PM, Richard Damon wrote:
On 3/28/24 10:53 AM, olcott wrote:
On 3/28/2024 6:59 AM, Richard Damon wrote:
On 3/27/24 11:58 PM, olcott wrote:Many churches differ on the trinity.
On 3/27/2024 9:34 PM, Richard Damon wrote:
On 3/27/24 10:07 PM, olcott wrote:
All of the different denominations having their differing views
proves that (at least) to the extent that they differ they are
incorrect.
And the key is to actually STUDY to see what is the REAL truth
behind all the variations, and what differences are important, and >>>>>> what are actually insubstantial.
When you actually KNOW what the Bible says, and talk to others who >>>>>> also KNOW what the Bible says, you can discuss things with people
even from very dofferent backgrounds, and find agreement.
You get the big disagreements from people who don't actually know
the Bible, but just the "Dogma" of their religious community.
These are not really beleivers or possibly not even really
"Christians" that Christ will take in the last day.
It seems to me that all those things that do not pertain to
righteousness can be ignored.
Righteousness is having a Right Relationship to God. Ignoring who he
is makes that impossible.
Things such as this:
Is the Godhead three different beings or one being taking three forms? >>>>>
But not correctly understanding who he is makes it impossible to
have a right relationship to him.
Right, and just like you point out that many people may claim to be
"Christians" but are not living a "Christian Life", many churches have
also formed based on wrong ideas about the Bible.
One of Satan's best methods is to get people to think they are "sage"
in a Church, even thought ath Church isn't actually teaching them the
truth.
What is the infallible process to distinguish the difference?
There are also a number of things that don't have a "single"
interpretation that must be followed, but different people can
legitimately worship God acceptably in different ways.
Yes, there are details that we do not need to (or in fact can not)
understand.
But God expects us to do all that we have the power to do, then he
can do the rest.
Intentionally neglecting what he says, puts you outside his Grace.
On 3/28/2024 9:49 PM, Richard Damon wrote:
On 3/28/24 9:42 PM, olcott wrote:
On 3/28/2024 7:07 PM, Richard Damon wrote:
On 3/28/24 10:53 AM, olcott wrote:
On 3/28/2024 6:59 AM, Richard Damon wrote:
On 3/27/24 11:58 PM, olcott wrote:Many churches differ on the trinity.
On 3/27/2024 9:34 PM, Richard Damon wrote:
On 3/27/24 10:07 PM, olcott wrote:
All of the different denominations having their differing views >>>>>>>>> proves that (at least) to the extent that they differ they are >>>>>>>>> incorrect.
And the key is to actually STUDY to see what is the REAL truth >>>>>>>> behind all the variations, and what differences are important, >>>>>>>> and what are actually insubstantial.
When you actually KNOW what the Bible says, and talk to others >>>>>>>> who also KNOW what the Bible says, you can discuss things with >>>>>>>> people even from very dofferent backgrounds, and find agreement. >>>>>>>>
You get the big disagreements from people who don't actually
know the Bible, but just the "Dogma" of their religious
community. These are not really beleivers or possibly not even >>>>>>>> really "Christians" that Christ will take in the last day.
It seems to me that all those things that do not pertain to
righteousness can be ignored.
Righteousness is having a Right Relationship to God. Ignoring who
he is makes that impossible.
Things such as this:
Is the Godhead three different beings or one being taking three
forms?
But not correctly understanding who he is makes it impossible to
have a right relationship to him.
Right, and just like you point out that many people may claim to be
"Christians" but are not living a "Christian Life", many churches
have also formed based on wrong ideas about the Bible.
One of Satan's best methods is to get people to think they are
"sage" in a Church, even thought ath Church isn't actually teaching
them the truth.
What is the infallible process to distinguish the difference?
Testing the spirit against an honest interpretation of the Word.
How to you know the exactly correct figurative degree of interpretation?
Of course, if you get sucked into the false beliefs, you might not be
able to do that. You need to know God and trust him for him to start
to help you.
Remember, the biblical order is:
Hear the Word,
Trust and Obey the Word,
and THEN God will prove himself to you.
On 3/29/2024 8:13 AM, Richard Damon wrote:
On 3/28/24 11:03 PM, olcott wrote:
On 3/28/2024 9:49 PM, Richard Damon wrote:
On 3/28/24 9:42 PM, olcott wrote:
On 3/28/2024 7:07 PM, Richard Damon wrote:
On 3/28/24 10:53 AM, olcott wrote:
On 3/28/2024 6:59 AM, Richard Damon wrote:
On 3/27/24 11:58 PM, olcott wrote:Many churches differ on the trinity.
On 3/27/2024 9:34 PM, Richard Damon wrote:
On 3/27/24 10:07 PM, olcott wrote:
All of the different denominations having their differing views >>>>>>>>>>> proves that (at least) to the extent that they differ they are >>>>>>>>>>> incorrect.
And the key is to actually STUDY to see what is the REAL truth >>>>>>>>>> behind all the variations, and what differences are important, >>>>>>>>>> and what are actually insubstantial.
When you actually KNOW what the Bible says, and talk to others >>>>>>>>>> who also KNOW what the Bible says, you can discuss things with >>>>>>>>>> people even from very dofferent backgrounds, and find agreement. >>>>>>>>>>
You get the big disagreements from people who don't actually >>>>>>>>>> know the Bible, but just the "Dogma" of their religious
community. These are not really beleivers or possibly not even >>>>>>>>>> really "Christians" that Christ will take in the last day. >>>>>>>>>>
It seems to me that all those things that do not pertain to
righteousness can be ignored.
Righteousness is having a Right Relationship to God. Ignoring
who he is makes that impossible.
Things such as this:
Is the Godhead three different beings or one being taking three >>>>>>>>> forms?
But not correctly understanding who he is makes it impossible to >>>>>>>> have a right relationship to him.
Right, and just like you point out that many people may claim to
be "Christians" but are not living a "Christian Life", many
churches have also formed based on wrong ideas about the Bible.
One of Satan's best methods is to get people to think they are
"sage" in a Church, even thought ath Church isn't actually
teaching them the truth.
What is the infallible process to distinguish the difference?
Testing the spirit against an honest interpretation of the Word.
How to you know the exactly correct figurative degree of interpretation?
I trust God to let me know.
When you let the TRUE God guide you, he will lead you into truth.
Of course, the hard part is initially finding the right path to be on.
He leaves enough hints to find it if you are willing to honestly look,
but leaves open the option to not see if you don't want.
Christ said know them by their fruits. https://ethicsunwrapped.utexas.edu/glossary/consequentialism
I have been a consequentialist (like Christ) since I first
studied the truth behind religion in 1992. I did not know its
name until 2016 when a Muslim friend of mine that I prayed
with told me about this from a college course he was taking.
I have always rejected the "do as you are told" form of morality
that told Abraham to kill is son Isaac. My measure has always
been benevolent outcomes are on the correct side of righteousness
and malevolent outcomes are on the wrong side.
Of course, if you get sucked into the false beliefs, you might not
be able to do that. You need to know God and trust him for him to
start to help you.
Remember, the biblical order is:
Hear the Word,
Trust and Obey the Word,
and THEN God will prove himself to you.
| Sysop: | Keyop |
|---|---|
| Location: | Huddersfield, West Yorkshire, UK |
| Users: | 300 |
| Nodes: | 16 (0 / 16) |
| Uptime: | 120:04:35 |
| Calls: | 6,704 |
| Calls today: | 4 |
| Files: | 12,235 |
| Messages: | 5,349,614 |