Groups | Search | Server Info | Keyboard shortcuts | Login | Register [http] [https] [nntp] [nntps]

Groups > comp.lang.c > #161419 > unrolled thread

A possible solution to the halting problem.

Back to article view | Back to comp.lang.c

Contents

  A possible solution to the halting problem. Skybuck Flying <skybuck2000@hotmail.com> - 2021-06-13 16:22 +0200
    Re: A possible solution to the halting problem. Skybuck Flying <skybuck2000@hotmail.com> - 2021-06-13 17:15 +0200
    Re: A possible solution to the halting problem. Jens Schweikhardt <usenet@schweikhardt.net> - 2021-06-14 06:24 +0000
      Re: A possible solution to the halting problem. olcott <NoOne@NoWhere.com> - 2021-06-14 11:38 -0500

#161419 — A possible solution to the halting problem.

Now that I have a free newsprogram and a free news server I can post
this to comp.lang.c as well which I also posted to other newsgroups,
the funny thing is though that currently there is some debat about this
issue in this newsgroup which is amazing !

Anyway here is my take on this halting problem, what the issue is and
how to maybe even solve it ! Inspired by this video, well worth a watch:

https://www.youtube.com/watch?v=HeQX2HjkcNo

Then later this video inspired me to offer a possible solution path,
read below if interested in the halting problem and a possible solution:

After watching this video the conclusion may be the following:

1. Contradictions are a problem in math.

2. These contradictions seemed to be caused by "self-references".

A possible solution to these problems are to:

3. Detect self-references.

4. Illiminate the self-references or break/solve the self-references.

So for example if the H machine is capable of reducing H+ such that H
can detect itself inside H+ then this means:

1. Self reference detected.
2. Possibly contradiction detected.

Now H can try and work out a solution to this problem/contradiction.

3. Basically this could allow H to detect H+ enters an infiniteloop,
because H has detected itself inside H+, H knows the real answer to the
halting question.

So the output of H+ is no longer relevant ! And can be dismissed as a
joke/trojan/thruth manipulator.

H detected the real thruth by detecting itself ! HAHA.

So if H can detect halt or infinity then it will no longer be tricked
by any machine H+ incorporating itself H.

So this reduces the halting problem/question to:

Can H detect itself given any program/version of itself ! ;)

A reduction problem it seems.

Goodbye for now,
Skybuck.

[toc] | [next] | [standalone]

#161420

Perhaps such a machine that can detect itself also has a link to
self-awareness.

Perhaps the halting problem "=?self-referencing" problem and "self
awareness" are related to each other ! ;)

Thus a machine that can detect "self referencing" might become
self-aware !

A bit freightening thought if you have seen THE TERMINATORRRRRRRR ! =D

Bye,
  Skybuck.

[toc] | [prev] | [next] | [standalone]

#161428

Skybuck Flying <skybuck2000@hotmail.com> wrote
	in <20210613162233.000073bc@hotmail.com>:
# Now that I have a free newsprogram and a free news server I can post
# this to comp.lang.c as well which I also posted to other newsgroups,
# the funny thing is though that currently there is some debat about this
# issue in this newsgroup which is amazing!
# 
# Anyway here is my take on this halting problem, what the issue is and
# how to maybe even solve it! Inspired by this video, well worth a watch:
# 
# https://www.youtube.com/watch?v=HeQX2HjkcNo
# 
# Then later this video inspired me to offer a possible solution path,
# read below if interested in the halting problem and a possible solution:
# 
# After watching this video the conclusion may be the following:
# 
# 1. Contradictions are a problem in math.
# 
# 2. These contradictions seemed to be caused by "self-references".
# 
# A possible solution to these problems are to:
# 
# 3. Detect self-references.
# 
# 4. Illiminate the self-references or break/solve the self-references.

For any record player there is a record that when played will destroy
it. Your step 3 cannot reliably perform for arbitrary input. Why?
Read "Gödel, Escher, Bach" which gives you a more digestible answer
than any usenet article by some jrandom ever will.


Regards,

	Jens
-- 
Jens Schweikhardt http://www.schweikhardt.net/
SIGSIG -- signature too long (core dumped)

[toc] | [prev] | [next] | [standalone]

#161436

On 6/14/2021 1:24 AM, Jens Schweikhardt wrote:
> Skybuck Flying <skybuck2000@hotmail.com> wrote
> 	in <20210613162233.000073bc@hotmail.com>:
> # Now that I have a free newsprogram and a free news server I can post
> # this to comp.lang.c as well which I also posted to other newsgroups,
> # the funny thing is though that currently there is some debat about this
> # issue in this newsgroup which is amazing!
> #
> # Anyway here is my take on this halting problem, what the issue is and
> # how to maybe even solve it! Inspired by this video, well worth a watch:
> #
> # https://www.youtube.com/watch?v=HeQX2HjkcNo
> #
> # Then later this video inspired me to offer a possible solution path,
> # read below if interested in the halting problem and a possible solution:
> #
> # After watching this video the conclusion may be the following:
> #
> # 1. Contradictions are a problem in math.
> #
> # 2. These contradictions seemed to be caused by "self-references".
> #
> # A possible solution to these problems are to:
> #
> # 3. Detect self-references.
> #
> # 4. Illiminate the self-references or break/solve the self-references.
> 
> For any record player there is a record that when played will destroy
> it. Your step 3 cannot reliably perform for arbitrary input. Why?
> Read "Gödel, Escher, Bach" which gives you a more digestible answer
> than any usenet article by some jrandom ever will.
> 
> 
> Regards,
> 
> 	Jens
> 

A simulating halt decider H is not confounded by an input P that does 
the opposite of whatever this halt decider decides. H simply recognizes 
that P is calling H in infinite recursion. On this basis H stops 
simulating P before ever returning any value to P. This make it 
impossible for P to be an input that H cannot correctly decide.

// Simplified Linz Ĥ (Linz:1990:319)
void P(u32 x)
{
   u32 Input_Halts = H(x, x);
   if (Input_Halts)
     HERE: goto HERE;
}

int main()
{
   H((u32)P, (u32)P);
}

Halting problem undecidability and infinitely nested simulation

https://www.researchgate.net/publication/351947980_Halting_problem_undecidability_and_infinitely_nested_simulation

-- 
Copyright 2021 Pete Olcott

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

[toc] | [prev] | [standalone]

Back to top | Article view | comp.lang.c

csiph-web