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

Groups > comp.theory > #118986 > unrolled thread

How to write a self-referencial TM?

Back to article view | Back to comp.theory

Contents

  How to write a self-referencial TM? wij <wyniijj5@gmail.com> - 2025-05-14 13:13 +0800
    Re: How to write a self-referencial TM? Richard Heathfield <rjh@cpax.org.uk> - 2025-05-14 07:02 +0100
    Re: How to write a self-referencial TM? olcott <polcott333@gmail.com> - 2025-05-14 09:51 -0500
      Re: How to write a self-referencial TM? wij <wyniijj5@gmail.com> - 2025-05-15 00:43 +0800
        Re: How to write a self-referencial TM? Richard Heathfield <rjh@cpax.org.uk> - 2025-05-14 18:14 +0100
          Re: How to write a self-referencial TM? wij <wyniijj5@gmail.com> - 2025-05-15 01:33 +0800
            Re: How to write a self-referencial TM? Richard Heathfield <rjh@cpax.org.uk> - 2025-05-14 18:49 +0100
              Re: How to write a self-referencial TM? wij <wyniijj5@gmail.com> - 2025-05-15 02:01 +0800
                Re: How to write a self-referencial TM? Richard Heathfield <rjh@cpax.org.uk> - 2025-05-14 19:38 +0100
                  Re: How to write a self-referencial TM? Keith Thompson <Keith.S.Thompson+u@gmail.com> - 2025-05-14 13:00 -0700
                    Re: How to write a self-referencial TM? olcott <polcott333@gmail.com> - 2025-05-14 15:02 -0500
                      Re: How to write a self-referencial TM? Richard Heathfield <rjh@cpax.org.uk> - 2025-05-14 21:19 +0100
                    Re: How to write a self-referencial TM? Richard Heathfield <rjh@cpax.org.uk> - 2025-05-14 21:16 +0100
                      Re: How to write a self-referencial TM? Keith Thompson <Keith.S.Thompson+u@gmail.com> - 2025-05-14 13:49 -0700
                        Re: How to write a self-referencial TM? Mr Flibble <flibble@red-dwarf.jmc.corp> - 2025-05-14 21:13 +0000
                          Re: How to write a self-referencial TM? Mikko <mikko.levanto@iki.fi> - 2025-05-15 10:24 +0300
                        Re: How to write a self-referencial TM? Richard Heathfield <rjh@cpax.org.uk> - 2025-05-14 22:28 +0100
                          Re: How to write a self-referencial TM? Keith Thompson <Keith.S.Thompson+u@gmail.com> - 2025-05-14 14:40 -0700
                            Re: How to write a self-referencial TM? Richard Heathfield <rjh@cpax.org.uk> - 2025-05-14 23:02 +0100
                      Re: How to write a self-referencial TM? Andy Walker <anw@cuboid.co.uk> - 2025-05-15 01:09 +0100
                        Re: How to write a self-referencial TM? Keith Thompson <Keith.S.Thompson+u@gmail.com> - 2025-05-14 17:19 -0700
                          Re: How to write a self-referencial TM? wij <wyniijj5@gmail.com> - 2025-05-15 09:38 +0800
                            Re: How to write a self-referencial TM? wij <wyniijj5@gmail.com> - 2025-05-15 09:58 +0800
                              Re: How to write a self-referencial TM? wij <wyniijj5@gmail.com> - 2025-05-15 10:11 +0800
                    Re: How to write a self-referencial TM? Ben Bacarisse <ben@bsb.me.uk> - 2025-05-15 00:55 +0100
                    Re: How to write a self-referencial TM? Mikko <mikko.levanto@iki.fi> - 2025-05-15 10:17 +0300
        Re: How to write a self-referencial TM? olcott <polcott333@gmail.com> - 2025-05-14 12:24 -0500
          Re: How to write a self-referencial TM? wij <wyniijj5@gmail.com> - 2025-05-15 01:39 +0800
            Re: How to write a self-referencial TM? olcott <polcott333@gmail.com> - 2025-05-14 12:45 -0500
              Re: How to write a self-referencial TM? wij <wyniijj5@gmail.com> - 2025-05-15 02:13 +0800
          Re: How to write a self-referencial TM? wij <wyniijj5@gmail.com> - 2025-05-15 01:53 +0800
            Re: How to write a self-referencial TM? Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2025-05-15 17:08 +0100
              Re: How to write a self-referencial TM? olcott <polcott333@gmail.com> - 2025-05-15 11:47 -0500
                Re: How to write a self-referencial TM? wij <wyniijj5@gmail.com> - 2025-05-16 03:57 +0800
                  Re: How to write a self-referencial TM? olcott <polcott333@gmail.com> - 2025-05-15 15:50 -0500
                    Re: How to write a self-referencial TM? Mikko <mikko.levanto@iki.fi> - 2025-05-16 10:33 +0300
                      Re: How to write a self-referencial TM? olcott <polcott333@gmail.com> - 2025-05-16 10:43 -0500
                        Re: How to write a self-referencial TM? Richard Damon <richard@damon-family.org> - 2025-05-16 12:10 -0400
                        Re: How to write a self-referencial TM? Mikko <mikko.levanto@iki.fi> - 2025-05-17 11:58 +0300
                Re: How to write a self-referencial TM? Richard Damon <richard@damon-family.org> - 2025-05-15 19:37 -0400
                Re: How to write a self-referencial TM? Mikko <mikko.levanto@iki.fi> - 2025-05-16 10:27 +0300
                  Re: How to write a self-referencial TM? olcott <polcott333@gmail.com> - 2025-05-16 10:40 -0500
                    Re: How to write a self-referencial TM? "Fred. Zwarts" <F.Zwarts@HetNet.nl> - 2025-05-19 10:21 +0200
                    Re: How to write a self-referencial TM? Mikko <mikko.levanto@iki.fi> - 2025-05-19 13:39 +0300
                      Re: How to write a self-referencial TM? olcott <polcott333@gmail.com> - 2025-05-20 23:41 -0500
                        Re: How to write a self-referencial TM? Mikko <mikko.levanto@iki.fi> - 2025-05-21 11:47 +0300
                        Re: How to write a self-referencial TM? Richard Damon <richard@damon-family.org> - 2025-05-21 07:11 -0400
              Re: How to write a self-referencial TM? wij <wyniijj5@gmail.com> - 2025-05-16 02:49 +0800
                Re: How to write a self-referencial TM? olcott <polcott333@gmail.com> - 2025-05-15 14:15 -0500
                  Re: How to write a self-referencial TM? wij <wyniijj5@gmail.com> - 2025-05-16 04:08 +0800
                    Re: How to write a self-referencial TM? Mikko <mikko.levanto@iki.fi> - 2025-05-16 10:45 +0300
                      Re: How to write a self-referencial TM? olcott <polcott333@gmail.com> - 2025-05-16 10:47 -0500
                        Re: How to write a self-referencial TM? "Fred. Zwarts" <F.Zwarts@HetNet.nl> - 2025-05-16 21:34 +0200
                  Re: How to write a self-referencial TM? Mikko <mikko.levanto@iki.fi> - 2025-05-16 10:40 +0300
                    Re: How to write a self-referencial TM? olcott <polcott333@gmail.com> - 2025-05-16 10:44 -0500
                      Re: How to write a self-referencial TM? Mikko <mikko.levanto@iki.fi> - 2025-05-17 12:02 +0300
                Re: How to write a self-referencial TM? Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2025-05-16 01:40 +0100
                  Re: How to write a self-referencial TM? Richard Heathfield <rjh@cpax.org.uk> - 2025-05-16 01:59 +0100
                  Re: How to write a self-referencial TM? wij <wyniijj5@gmail.com> - 2025-05-16 09:47 +0800
                    Re: How to write a self-referencial TM? Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2025-05-16 03:26 +0100
                      Re: How to write a self-referencial TM? wij <wyniijj5@gmail.com> - 2025-05-16 19:40 +0800
                        Re: How to write a self-referencial TM? Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2025-05-16 16:33 +0100
                          Re: How to write a self-referencial TM? wij <wyniijj5@gmail.com> - 2025-05-17 03:35 +0800
                            Re: How to write a self-referencial TM? Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2025-05-16 23:51 +0100
                              Re: How to write a self-referencial TM? wij <wyniijj5@gmail.com> - 2025-05-17 11:01 +0800
                                Re: How to write a self-referencial TM? olcott <polcott333@gmail.com> - 2025-05-16 22:12 -0500
                                  Re: How to write a self-referencial TM? wij <wyniijj5@gmail.com> - 2025-05-17 11:23 +0800
                                    Re: How to write a self-referencial TM? olcott <polcott333@gmail.com> - 2025-05-16 22:40 -0500
                                      Re: How to write a self-referencial TM? wij <wyniijj5@gmail.com> - 2025-05-17 11:49 +0800
                                        Re: How to write a self-referencial TM? olcott <polcott333@gmail.com> - 2025-05-16 22:58 -0500
                                  Re: How to write a self-referencial TM? Richard Damon <richard@damon-family.org> - 2025-05-17 09:02 -0400
                                Re: How to write a self-referencial TM? Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2025-05-17 15:45 +0100
                                  Re: How to write a self-referencial TM? wij <wyniijj5@gmail.com> - 2025-05-18 03:26 +0800
                                    Re: How to write a self-referencial TM? olcott <polcott333@gmail.com> - 2025-05-17 14:39 -0500
                                      Re: How to write a self-referencial TM? Mikko <mikko.levanto@iki.fi> - 2025-05-18 11:20 +0300
                                      Re: How to write a self-referencial TM? wij <wyniijj5@gmail.com> - 2025-05-19 04:35 +0800
                                        Re: How to write a self-referencial TM? olcott <polcott333@gmail.com> - 2025-05-18 15:57 -0500
                                          Re: How to write a self-referencial TM? Richard Damon <richard@damon-family.org> - 2025-05-18 17:45 -0400
                                          Re: How to write a self-referencial TM? wij <wyniijj5@gmail.com> - 2025-05-19 05:46 +0800
                                            Re: How to write a self-referencial TM? olcott <polcott333@gmail.com> - 2025-05-18 17:09 -0500
                                              Re: How to write a self-referencial TM? wij <wyniijj5@gmail.com> - 2025-05-19 06:35 +0800
                                              Re: How to write a self-referencial TM? Richard Damon <richard@damon-family.org> - 2025-05-18 19:09 -0400
                                                Re: How to write a self-referencial TM? wij <wyniijj5@gmail.com> - 2025-05-19 07:54 +0800
                                                  Re: How to write a self-referencial TM? Mikko <mikko.levanto@iki.fi> - 2025-05-19 13:52 +0300
                                              Re: How to write a self-referencial TM? Mikko <mikko.levanto@iki.fi> - 2025-05-19 13:48 +0300
                                                Re: How to write a self-referencial TM? olcott <polcott333@gmail.com> - 2025-05-20 23:36 -0500
                                                  Re: How to write a self-referencial TM? Mikko <mikko.levanto@iki.fi> - 2025-05-21 11:56 +0300
                                          Re: How to write a self-referencial TM? André G. Isaak <agisaak@gm.invalid> - 2025-05-18 15:58 -0600
                                            Re: How to write a self-referencial TM? olcott <polcott333@gmail.com> - 2025-05-18 17:08 -0500
                                              Re: How to write a self-referencial TM? Richard Damon <richard@damon-family.org> - 2025-05-18 19:19 -0400
                                              Re: How to write a self-referencial TM? André G. Isaak <agisaak@gm.invalid> - 2025-05-18 21:21 -0600
                                                Re: How to write a self-referencial TM? olcott <polcott333@gmail.com> - 2025-05-18 23:07 -0500
                                                  Re: How to write a self-referencial TM? "Fred. Zwarts" <F.Zwarts@HetNet.nl> - 2025-05-19 09:54 +0200
                                                  Re: How to write a self-referencial TM? Mikko <mikko.levanto@iki.fi> - 2025-05-19 15:29 +0300
                                                    Re: How to write a self-referencial TM? olcott <polcott333@gmail.com> - 2025-05-20 23:33 -0500
                                                      Re: How to write a self-referencial TM? Mikko <mikko.levanto@iki.fi> - 2025-05-21 12:03 +0300
                                                      Re: How to write a self-referencial TM? Richard Damon <richard@damon-family.org> - 2025-05-21 07:16 -0400
                                                      Re: How to write a self-referencial TM? "Fred. Zwarts" <F.Zwarts@HetNet.nl> - 2025-05-21 21:43 +0200
                                                        Re: How to write a self-referencial TM? olcott <polcott333@gmail.com> - 2025-05-21 14:49 -0500
                                                          Re: How to write a self-referencial TM? "Fred. Zwarts" <F.Zwarts@HetNet.nl> - 2025-05-23 13:03 +0200
                                          Re: How to write a self-referencial TM? Mikko <mikko.levanto@iki.fi> - 2025-05-19 13:44 +0300
                                        Re: How to write a self-referencial TM? Mikko <mikko.levanto@iki.fi> - 2025-05-19 13:41 +0300
                                    Re: How to write a self-referencial TM? Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2025-05-17 20:46 +0100
                                      Re: How to write a self-referencial TM? olcott <polcott333@gmail.com> - 2025-05-17 14:55 -0500
                                        Re: How to write a self-referencial TM? Richard Damon <richard@damon-family.org> - 2025-05-17 16:07 -0400
                  Re: How to write a self-referencial TM? Andy Walker <anw@cuboid.co.uk> - 2025-05-16 12:22 +0100
                    Re: How to write a self-referencial TM? Mike Terry <news.dead.person.stones@darjeeling.plus.com> - 2025-05-16 16:57 +0100
                      Re: How to write a self-referencial TM? Andy Walker <anw@cuboid.co.uk> - 2025-05-16 21:04 +0100
                        Re: How to write a self-referencial TM? olcott <polcott333@gmail.com> - 2025-05-16 15:38 -0500
                          Re: How to write a self-referencial TM? wij <wyniijj5@gmail.com> - 2025-05-17 05:21 +0800
                            Re: How to write a self-referencial TM? olcott <polcott333@gmail.com> - 2025-05-16 16:40 -0500
                              Re: How to write a self-referencial TM? Richard Damon <richard@damon-family.org> - 2025-05-16 20:32 -0400
                          Re: How to write a self-referencial TM? Richard Damon <richard@damon-family.org> - 2025-05-16 17:59 -0400
          Re: How to write a self-referencial TM? Mikko <mikko.levanto@iki.fi> - 2025-05-16 10:24 +0300
            Re: How to write a self-referencial TM? olcott <polcott333@gmail.com> - 2025-05-16 10:37 -0500
    Re: How to write a self-referencial TM? Mikko <mikko.levanto@iki.fi> - 2025-05-15 10:07 +0300

Page 2 of 6 — ← Prev page 1 [2] 3 4 5 6  Next page →

#119141

Andy Walker <anw@cuboid.co.uk> writes:
> On 14/05/2025 21:16, Richard Heathfield wrote:
>> On 14/05/2025 21:00, Keith Thompson wrote:
>>> I presume that one-way and two-way infinite tapes are computationally
>>> equivalent, so the distinction doesn't matter all that much.
>
> 	Indeed, there are lots of computationally equivalent versions:
>
>  -- two or more tapes [indeed, two-dimensional tapes]
>  -- one-way or two-way
>  -- "paper" tapes where you can punch holes to change the content but not
>       stick the chad back in to "unpunch" the holes
>  -- two symbol, three symbol, ...
>  -- move two or more spaces at a time
>  -- others I've forgotten

Not to mention the very common variant where landing on Free Parking
means you get all the money from the center of the board.  Or was that
something else?

[...]

-- 
Keith Thompson (The_Other_Keith) Keith.S.Thompson+u@gmail.com
void Void(void) { Void(); } /* The recursive call of the void */

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

#119154

On Wed, 2025-05-14 at 17:19 -0700, Keith Thompson wrote:
> Andy Walker <anw@cuboid.co.uk> writes:
> > On 14/05/2025 21:16, Richard Heathfield wrote:
> > > On 14/05/2025 21:00, Keith Thompson wrote:
> > > > I presume that one-way and two-way infinite tapes are computationally
> > > > equivalent, so the distinction doesn't matter all that much.
> > 
> > 	Indeed, there are lots of computationally equivalent versions:
> > 
> >  -- two or more tapes [indeed, two-dimensional tapes]
> >  -- one-way or two-way
> >  -- "paper" tapes where you can punch holes to change the content but not
> >       stick the chad back in to "unpunch" the holes
> >  -- two symbol, three symbol, ...
> >  -- move two or more spaces at a time
> >  -- others I've forgotten
> 
> Not to mention the very common variant where landing on Free Parking
> means you get all the money from the center of the board.  Or was that
> something else?
> 
> [...]

// Manpage of class Spu
NAME
       Spu - Class of general purpose Soft-CPU

SYNOPSIS
       Except POD types, C structures, all types are declared in namespace Wy.

       #include <CSCall/Sct.h>

       Spu  (Soft  CPU)  is  a revised model of Turing Machine and a class that
       acts like a general purpose CPU-based computing machine to  provide  se‐
       mantics for computing language and for remote program communication.

       The  main differences of Spu and general purpose CPU (or TM) is that Spu
       has no ´register´ nor ´flag´, Spu has only a tape. The tape is initially
       empty. Every object (referred to as tape variable) in the tape is  allo‐
       cated via instruction Alloc and identified by a continuous index number.
       Tape variable can be any C++ type, including Spu.

       The  instruction  of Spu is application definable. Except necessary few,
       about  >30  instructions  are  defined  for  convenience,  see   manpage
       Wy.Sct(3wy).

       Documentation following omits the scope name Wy::Sct for each occurrence
       of Spu for clearity.

[cut]
----------------------

1. In Spu, objects in the tape are allocated (constructed).
2. Accessing the tape outside range will throw an error.
3. Instructions in Spu are class members. 'instructions' can be considered 
   variable or stateful (useful in developing theory), because data structure 
   related to instruction is considered part of the instruction, simiar to the
   OO concept of C++ class.
4. Multi-tasking can be modeled by multi-instances of Spu (or tape variable
   can be an Spu object)

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

#119161

On Thu, 2025-05-15 at 09:38 +0800, wij wrote:
> On Wed, 2025-05-14 at 17:19 -0700, Keith Thompson wrote:
> > Andy Walker <anw@cuboid.co.uk> writes:
> > > On 14/05/2025 21:16, Richard Heathfield wrote:
> > > > On 14/05/2025 21:00, Keith Thompson wrote:
> > > > > I presume that one-way and two-way infinite tapes are computationally
> > > > > equivalent, so the distinction doesn't matter all that much.
> > > 
> > > 	Indeed, there are lots of computationally equivalent versions:
> > > 
> > >  -- two or more tapes [indeed, two-dimensional tapes]
> > >  -- one-way or two-way
> > >  -- "paper" tapes where you can punch holes to change the content but not
> > >       stick the chad back in to "unpunch" the holes
> > >  -- two symbol, three symbol, ...
> > >  -- move two or more spaces at a time
> > >  -- others I've forgotten
> > 
> > Not to mention the very common variant where landing on Free Parking
> > means you get all the money from the center of the board.  Or was that
> > something else?
> > 
> > [...]
> 
> // Manpage of class Spu
> NAME
>        Spu - Class of general purpose Soft-CPU
> 
> SYNOPSIS
>        Except POD types, C structures, all types are declared in namespace Wy.
> 
>        #include <CSCall/Sct.h>
> 
>        Spu  (Soft  CPU)  is  a revised model of Turing Machine and a class that
>        acts like a general purpose CPU-based computing machine to  provide  se‐
>        mantics for computing language and for remote program communication.
> 
>        The  main differences of Spu and general purpose CPU (or TM) is that Spu
>        has no ´register´ nor ´flag´, Spu has only a tape. The tape is initially
>        empty. Every object (referred to as tape variable) in the tape is  allo‐
>        cated via instruction Alloc and identified by a continuous index number.
>        Tape variable can be any C++ type, including Spu.
> 
>        The  instruction  of Spu is application definable. Except necessary few,
>        about  >30  instructions  are  defined  for  convenience,   see   manpage
>        Wy.Sct(3wy).
> 
>        Documentation following omits the scope name Wy::Sct for each occurrence
>        of Spu for clearity.
> 
> [cut]
> ----------------------
> 
> 1. In Spu, objects in the tape are allocated (constructed).
> 2. Accessing the tape outside range will throw an error.
> 3. Instructions in Spu are class members. 'instructions' can be considered 
>    variable or stateful (useful in developing theory), because data structure 
>    related to instruction is considered part of the instruction, simiar to the
>    OO concept of C++ class.
> 4. Multi-tasking can be modeled by multi-instances of Spu (or tape variable
>    can be an Spu object)
> 

With the issue of TM's tape at least, I think Spu is more *realistic* than TM.

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

#119164

On Thu, 2025-05-15 at 09:58 +0800, wij wrote:
> On Thu, 2025-05-15 at 09:38 +0800, wij wrote:
> > On Wed, 2025-05-14 at 17:19 -0700, Keith Thompson wrote:
> > > Andy Walker <anw@cuboid.co.uk> writes:
> > > > On 14/05/2025 21:16, Richard Heathfield wrote:
> > > > > On 14/05/2025 21:00, Keith Thompson wrote:
> > > > > > I presume that one-way and two-way infinite tapes are computationally
> > > > > > equivalent, so the distinction doesn't matter all that much.
> > > > 
> > > > 	Indeed, there are lots of computationally equivalent versions:
> > > > 
> > > >  -- two or more tapes [indeed, two-dimensional tapes]
> > > >  -- one-way or two-way
> > > >  -- "paper" tapes where you can punch holes to change the content but not
> > > >       stick the chad back in to "unpunch" the holes
> > > >  -- two symbol, three symbol, ...
> > > >  -- move two or more spaces at a time
> > > >  -- others I've forgotten
> > > 
> > > Not to mention the very common variant where landing on Free Parking
> > > means you get all the money from the center of the board.  Or was that
> > > something else?
> > > 
> > > [...]
> > 
> > // Manpage of class Spu
> > NAME
> >        Spu - Class of general purpose Soft-CPU
> > 
> > SYNOPSIS
> >        Except POD types, C structures, all types are declared in namespace Wy.
> > 
> >        #include <CSCall/Sct.h>
> > 
> >        Spu  (Soft  CPU)  is  a revised model of Turing Machine and a class that
> >        acts like a general purpose CPU-based computing machine to  provide  se‐
> >        mantics for computing language and for remote program communication.
> > 
> >        The  main differences of Spu and general purpose CPU (or TM) is that Spu
> >        has no ´register´ nor ´flag´, Spu has only a tape. The tape is initially
> >        empty. Every object (referred to as tape variable) in the tape is  allo‐
> >        cated via instruction Alloc and identified by a continuous index number.
> >        Tape variable can be any C++ type, including Spu.
> > 
> >        The  instruction  of Spu is application definable. Except necessary few,
> >        about  >30  instructions  are  defined  for  convenience,   see   manpage
> >        Wy.Sct(3wy).
> > 
> >        Documentation following omits the scope name Wy::Sct for each occurrence
> >        of Spu for clearity.
> > 
> > [cut]
> > ----------------------
> > 
> > 1. In Spu, objects in the tape are allocated (constructed).
> > 2. Accessing the tape outside range will throw an error.
> > 3. Instructions in Spu are class members. 'instructions' can be considered 
> >    variable or stateful (useful in developing theory), because data structure 
> >    related to instruction is considered part of the instruction, simiar to the
> >    OO concept of C++ class.
> > 4. Multi-tasking can be modeled by multi-instances of Spu (or tape variable
> >    can be an Spu object)
> > 
> 
> With the issue of TM's tape at least, I think Spu is more *realistic* than TM.


/* Copyright is licensed by GNU LGPL, see file COPYING.       by I.J.Wang 2025
 
   Spu program: 'instruction' is a C++ function:
       "Mov a,b" performs the function of the expression "a=b"
       "Add a,b" performs the function of the expression "a+=b"
       "Add a,b,c" performs the function of the expression "c=a+b"
 
   Build: g++ s_tut2.cpp -lwy
*/
#include <Wy.stdio.h>
#include "CSCall/Sct.h"

using namespace Wy;
using namespace Wy::Sct;

void t0() {
 Errno r;
 Spu spu;

// Note: In general, program.reserve(...) is needed if non-memcpy_able variable
//       (String) is used. Because this spu program is simple and no error is 
//       thrown, we save the trouble.
/* 0 */ spu.add_instr( new Alloc<float>());  // 0 (alloc 3 float)
/* 1 */ spu.add_instr( new Alloc<float>());  // 1
/* 2 */ spu.add_instr( new Alloc<float>());  // 2
/* 3 */ spu.add_instr( new Alloc<String>()); // 3 (alloc 3 String)
/* 4 */ spu.add_instr( new Alloc<String>()); // 4
/* 5 */ spu.add_instr( new Alloc<String>()); // 5
/* 6 */ spu.add_instr( new Mov<float,float>(TpVar(0),1.32)); // init. var.
/* 7 */ spu.add_instr( new Mov<float,float>(TpVar(1),3.2));  
/* 8 */ spu.add_instr( new Add<float,float>(TpVar(0),TpVar(1),TpVar(2))); 
/* 9 */ spu.add_instr( new Cout<float>(TpVar(2))); // print resut of v(0)+v(1)
/* 10 */ spu.add_instr( new Cout<char>('\n')); 

/* 11 */ spu.add_instr( new Mov<String,const char*>(TpVar(3),"hello "));
/* 12 */ spu.add_instr( new Mov<String,const char*>(TpVar(4),"world\n"));
/* 13 */ spu.add_instr( new Add<String,String>(TpVar(3),TpVar(4)));
/* 14 */ spu.add_instr( new Cout<String>(TpVar(3))); // print result of v(3)+v(4)
/* 15 */ spu.add_instr( new Free<String>()); // free 3 non-memcpy-able objects
/* 16 */ spu.add_instr( new Free<String>());
/* 17 */ spu.add_instr( new Free<String>());
/* 18 */ spu.add_instr( new Fin(0));

 if((r=spu.run( InstrIdx(0) ))!=Ok) { // run the program from InstrIdx(0)
   WY_THROW(r);
 }
};

int main(int argc, const char* argv[])
try {
 t0();
 cout << "OK" WY_ENDL;
 return 0;
}
catch(const Errno& e) {
 cerr << wrd(e) << WY_ENDL;
 return -1;  // e.c_errno();
}
catch(...) {
 cerr << "main() caught(...)" WY_ENDL;
 throw;
};

------------------
If matured, there can be 'Spu language', everything will be lots more convenient,
including for theory development.

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

#119135

Keith Thompson <Keith.S.Thompson+u@gmail.com> writes:

> Richard Heathfield <rjh@cpax.org.uk> writes:
> [...]
>> See <https://plato.stanford.edu/entries/turing-machine/>
>>
>> where you can read this:
>>
>> "A Turing machine then, or a computing machine as Turing called it, in
>> Turing’s original definition is a machine capable of a finite set of
>> configurations q1,…,qn (the states of the machine, called
>> m-configurations by Turing). It is supplied with a one-way infinite
>> and one-dimensional tape divided into squares each capable of carrying
>> exactly one symbol. At any moment, the machine is scanning the content
>> of one square r which is either blank (symbolized by S0) or contains a
>> symbol S1,…,Sm with S1=0 and S2=1."
>>
>> There's more to TMs than tapes.
> [...]
>
> Interesting.  The phrase "one-way infinite" implies that the tape
> is infinite in only one direction, so the cells can be indexed by
> non-negative integers.  Elsewhere on that web page, it acknowledges
> that there are variations in Turing machines, including one-way
> vs. two-way infinite tapes.  It's implied that Turings original
> concept had a one-way infinite tape.  I wasn't able to confirm or
> deny that in a very quick look through Turings original paper.

I don't think it's explicit, but the paper does refer to input being "on
the beginning" of the tape.

> I've always assumed that a TM tape is two-way infinite.

That is by far the more usual presentation these days.  A lot about
Turing's presentation has been tidied up over the years.

> I presume that one-way and two-way infinite tapes are computationally
> equivalent, so the distinction doesn't matter all that much.

Yes.  That's often presented as an "exercise to the reader".  There are
also multi-tape TMs, non-deterministic TMs and random TMs that can
access a tape of randomly chosen symbols.

> (Though with a one-way tape, I'm not sure what happens if the TM
> runs off the end of the tape.)

The usual presentation just says that TM stops if the action can't be
taken.  It need be no different to what happens if the state transition
function does not include the current state/input pair in its domain.

-- 
Ben.

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

#119183

On 2025-05-14 20:00:13 +0000, Keith Thompson said:

> Richard Heathfield <rjh@cpax.org.uk> writes:
> [...]
>> See <https://plato.stanford.edu/entries/turing-machine/>
>> 
>> where you can read this:
>> 
>> "A Turing machine then, or a computing machine as Turing called it, in
>> Turing’s original definition is a machine capable of a finite set of
>> configurations q1,…,qn (the states of the machine, called
>> m-configurations by Turing). It is supplied with a one-way infinite
>> and one-dimensional tape divided into squares each capable of carrying
>> exactly one symbol. At any moment, the machine is scanning the content
>> of one square r which is either blank (symbolized by S0) or contains a
>> symbol S1,…,Sm with S1=0 and S2=1."
>> 
>> There's more to TMs than tapes.
> [...]
> 
> Interesting.  The phrase "one-way infinite" implies that the tape
> is infinite in only one direction, so the cells can be indexed by
> non-negative integers.  Elsewhere on that web page, it acknowledges
> that there are variations in Turing machines, including one-way
> vs. two-way infinite tapes.  It's implied that Turings original
> concept had a one-way infinite tape.  I wasn't able to confirm or
> deny that in a very quick look through Turings original paper.
> 
> I've always assumed that a TM tape is two-way infinite.

Post found that Turing's original machine could be simplified so that
every computation possible with the original machie is possible with
the simplified machine but reasoning about the simpified macnies is
simpler and easier than about the original machines. One of the
simplifications is that the tape has no beginning.

-- 
Mikko

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

#119043

On 5/14/2025 11:43 AM, wij wrote:
> On Wed, 2025-05-14 at 09:51 -0500, olcott wrote:
>> On 5/14/2025 12:13 AM, wij wrote:
>>> Q: Write a turing machine that performs D function (which calls itself):
>>>
>>> void D() {
>>>    D();
>>> }
>>>
>>> Easy?
>>>
>>>
>>
>> That is not a TM.
> 
> It is a C program that exists. Therefore, there must be a equivalent TM.
> 
>> To make a TM that references itself the closest
>> thing is a UTM that simulates its own TM source-code.
> 
> How does a UTM simulate its own TM source-code?
> 

You run a UTM that has its own source-code on its tape.

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

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

#119047

On Wed, 2025-05-14 at 12:24 -0500, olcott wrote:
> On 5/14/2025 11:43 AM, wij wrote:
> > On Wed, 2025-05-14 at 09:51 -0500, olcott wrote:
> > > On 5/14/2025 12:13 AM, wij wrote:
> > > > Q: Write a turing machine that performs D function (which calls itself):
> > > > 
> > > > void D() {
> > > >    D();
> > > > }
> > > > 
> > > > Easy?
> > > > 
> > > > 
> > > 
> > > That is not a TM.
> > 
> > It is a C program that exists. Therefore, there must be a equivalent TM.
> > 
> > > To make a TM that references itself the closest
> > > thing is a UTM that simulates its own TM source-code.
> > 
> > How does a UTM simulate its own TM source-code?
> > 
> 
> You run a UTM that has its own source-code on its tape.

What is exactly UTM? 
E.g. can the HHH in POOH or x86utm reads its own source-code?

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

#119049

On 5/14/2025 12:39 PM, wij wrote:
> On Wed, 2025-05-14 at 12:24 -0500, olcott wrote:
>> On 5/14/2025 11:43 AM, wij wrote:
>>> On Wed, 2025-05-14 at 09:51 -0500, olcott wrote:
>>>> On 5/14/2025 12:13 AM, wij wrote:
>>>>> Q: Write a turing machine that performs D function (which calls itself):
>>>>>
>>>>> void D() {
>>>>>     D();
>>>>> }
>>>>>
>>>>> Easy?
>>>>>
>>>>>
>>>>
>>>> That is not a TM.
>>>
>>> It is a C program that exists. Therefore, there must be a equivalent TM.
>>>
>>>> To make a TM that references itself the closest
>>>> thing is a UTM that simulates its own TM source-code.
>>>
>>> How does a UTM simulate its own TM source-code?
>>>
>>
>> You run a UTM that has its own source-code on its tape.
> 
> What is exactly UTM?

https://en.wikipedia.org/wiki/Universal_Turing_machine

> E.g. can the HHH in POOH or x86utm reads its own source-code?
> 

As I have said many dozens of times and Mike affirmed
HHH does emulate itself emulating DDD. It does this
through direct access to its own x86 machine language.

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

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

#119057

On Wed, 2025-05-14 at 12:45 -0500, olcott wrote:
> On 5/14/2025 12:39 PM, wij wrote:
> > On Wed, 2025-05-14 at 12:24 -0500, olcott wrote:
> > > On 5/14/2025 11:43 AM, wij wrote:
> > > > On Wed, 2025-05-14 at 09:51 -0500, olcott wrote:
> > > > > On 5/14/2025 12:13 AM, wij wrote:
> > > > > > Q: Write a turing machine that performs D function (which calls itself):
> > > > > > 
> > > > > > void D() {
> > > > > >     D();
> > > > > > }
> > > > > > 
> > > > > > Easy?
> > > > > > 
> > > > > > 
> > > > > 
> > > > > That is not a TM.
> > > > 
> > > > It is a C program that exists. Therefore, there must be a equivalent TM.
> > > > 
> > > > > To make a TM that references itself the closest
> > > > > thing is a UTM that simulates its own TM source-code.
> > > > 
> > > > How does a UTM simulate its own TM source-code?
> > > > 
> > > 
> > > You run a UTM that has its own source-code on its tape.
> > 
> > What is exactly UTM?
> 
> https://en.wikipedia.org/wiki/Universal_Turing_machine

We know you don't have answer

> > E.g. can the HHH in POOH or x86utm reads its own source-code?
> > 
> 
> As I have said many dozens of times and Mike affirmed
> HHH does emulate itself emulating DDD. It does this
> through direct access to its own x86 machine language.

The TM of "HHH(DDD)" is much difficult than the problem of this post.
I think you have no right to say HHH/DDD... are TM, until you write
the sourec-code of HHH/DDD in the tape and show the transition function.

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

#119053

On Wed, 2025-05-14 at 12:24 -0500, olcott wrote:
> On 5/14/2025 11:43 AM, wij wrote:
> > On Wed, 2025-05-14 at 09:51 -0500, olcott wrote:
> > > On 5/14/2025 12:13 AM, wij wrote:
> > > > Q: Write a turing machine that performs D function (which calls itself):
> > > > 
> > > > void D() {
> > > >    D();
> > > > }
> > > > 
> > > > Easy?
> > > > 
> > > > 
> > > 
> > > That is not a TM.
> > 
> > It is a C program that exists. Therefore, there must be a equivalent TM.
> > 
> > > To make a TM that references itself the closest
> > > thing is a UTM that simulates its own TM source-code.
> > 
> > How does a UTM simulate its own TM source-code?
> > 
> 
> You run a UTM that has its own source-code on its tape.

What is exactly the source-code on its tape?

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

#119215

On 14/05/2025 18:53, wij wrote:
> On Wed, 2025-05-14 at 12:24 -0500, olcott wrote:
>> On 5/14/2025 11:43 AM, wij wrote:
>>> On Wed, 2025-05-14 at 09:51 -0500, olcott wrote:
>>>> On 5/14/2025 12:13 AM, wij wrote:
>>>>> Q: Write a turing machine that performs D function (which calls itself):
>>>>>
>>>>> void D() {
>>>>>     D();
>>>>> }
>>>>>
>>>>> Easy?
>>>>>
>>>>>
>>>>
>>>> That is not a TM.
>>>
>>> It is a C program that exists. Therefore, there must be a equivalent TM.
>>>
>>>> To make a TM that references itself the closest
>>>> thing is a UTM that simulates its own TM source-code.
>>>
>>> How does a UTM simulate its own TM source-code?
>>>
>>
>> You run a UTM that has its own source-code on its tape.
> 
> What is exactly the source-code on its tape?
> 

Every UTM has some scheme which can be applied to a (TM & input tape) that is to be simulated.  The 
scheme says how to turn the (TM + input tape) into a string of symbols that represent that 
computation.

So to answer your question, the "source-code on its tape" is the result of applying the UTM's 
particular scheme to the combination (UTM, input tape) that is to be simulated.

If you're looking for the exact string symbols, obviously you would need to specify the exact UTM 
being used, because every UTM will have a different answer to your question.


Mike.

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

#119216

On 5/15/2025 11:08 AM, Mike Terry wrote:
> On 14/05/2025 18:53, wij wrote:
>> On Wed, 2025-05-14 at 12:24 -0500, olcott wrote:
>>> On 5/14/2025 11:43 AM, wij wrote:
>>>> On Wed, 2025-05-14 at 09:51 -0500, olcott wrote:
>>>>> On 5/14/2025 12:13 AM, wij wrote:
>>>>>> Q: Write a turing machine that performs D function (which calls 
>>>>>> itself):
>>>>>>
>>>>>> void D() {
>>>>>>     D();
>>>>>> }
>>>>>>
>>>>>> Easy?
>>>>>>
>>>>>>
>>>>>
>>>>> That is not a TM.
>>>>
>>>> It is a C program that exists. Therefore, there must be a equivalent 
>>>> TM.
>>>>
>>>>> To make a TM that references itself the closest
>>>>> thing is a UTM that simulates its own TM source-code.
>>>>
>>>> How does a UTM simulate its own TM source-code?
>>>>
>>>
>>> You run a UTM that has its own source-code on its tape.
>>
>> What is exactly the source-code on its tape?
>>
> 
> Every UTM has some scheme which can be applied to a (TM & input tape) 
> that is to be simulated.  The scheme says how to turn the (TM + input 
> tape) into a string of symbols that represent that computation.
> 
> So to answer your question, the "source-code on its tape" is the result 
> of applying the UTM's particular scheme to the combination (UTM, input 
> tape) that is to be simulated.
> 
> If you're looking for the exact string symbols, obviously you would need 
> to specify the exact UTM being used, because every UTM will have a 
> different answer to your question.
> 
> 
> Mike.
> 

These things cannot be investigated in great
depth because there is no fully encoded UTM in
any standard language.

If there was such a UTM then examining things
like a termination analyzer would be too difficult
because of the volume of details. Even moving a
single value to a specific memory location can
take many many steps.

A RASP machine
https://en.wikipedia.org/wiki/Random-access_stored-program_machine
is a much better fit for examining the details of any
complex algorithm.

The x86 language is essentially the same thing as a RASP
machine for all computations that can be accomplished
with the amount of memory that is available.

To be a computable function within a model of computation
a sequence of the steps of a specific algorithm must be
applied to (an often finite string) input to derive an output.
https://en.wikipedia.org/wiki/Computable_function

When computing the sum() function the steps of the algorithm
of arithmetic must be applied to the inputs.

*When computing the halt() function steps with a simulating*
*termination analyzer the behavioral steps specified by the*
*input must be simulated according to the computer language*
*of this input*

*I may be wrong yet it seems to me that*
Computer science never knew these things before in that
it never placed any limit on the type of algorithm that
must be performed.

I think that it was Ben that said that one of two
functions that do nothing besides return true or false
is correct on all of the counter-example inputs
to the halting problem.

When we require that a mapping be computed from an
input, then this idea is rejected.

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

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

#119219

On Thu, 2025-05-15 at 11:47 -0500, olcott wrote:
> On 5/15/2025 11:08 AM, Mike Terry wrote:
> > On 14/05/2025 18:53, wij wrote:
> > > On Wed, 2025-05-14 at 12:24 -0500, olcott wrote:
> > > > On 5/14/2025 11:43 AM, wij wrote:
> > > > > On Wed, 2025-05-14 at 09:51 -0500, olcott wrote:
> > > > > > On 5/14/2025 12:13 AM, wij wrote:
> > > > > > > Q: Write a turing machine that performs D function (which calls 
> > > > > > > itself):
> > > > > > > 
> > > > > > > void D() {
> > > > > > >     D();
> > > > > > > }
> > > > > > > 
> > > > > > > Easy?
> > > > > > > 
> > > > > > > 
> > > > > > 
> > > > > > That is not a TM.
> > > > > 
> > > > > It is a C program that exists. Therefore, there must be a equivalent 
> > > > > TM.
> > > > > 
> > > > > > To make a TM that references itself the closest
> > > > > > thing is a UTM that simulates its own TM source-code.
> > > > > 
> > > > > How does a UTM simulate its own TM source-code?
> > > > > 
> > > > 
> > > > You run a UTM that has its own source-code on its tape.
> > > 
> > > What is exactly the source-code on its tape?
> > > 
> > 
> > Every UTM has some scheme which can be applied to a (TM & input tape) 
> > that is to be simulated.  The scheme says how to turn the (TM + input 
> > tape) into a string of symbols that represent that computation.
> > 
> > So to answer your question, the "source-code on its tape" is the result 
> > of applying the UTM's particular scheme to the combination (UTM, input 
> > tape) that is to be simulated.
> > 
> > If you're looking for the exact string symbols, obviously you would need 
> > to specify the exact UTM being used, because every UTM will have a 
> > different answer to your question.
> > 
> > 
> > Mike.
> > 
> 
> These things cannot be investigated in great
> depth because there is no fully encoded UTM in
> any standard language.

Sort of.

> If there was such a UTM then examining things
> like a termination analyzer would be too difficult
> because of the volume of details. Even moving a
> single value to a specific memory location can
> take many many steps.

So, which part of POOH is "fully encoded UTM"

> A RASP machine
> https://en.wikipedia.org/wiki/Random-access_stored-program_machine
> is a much better fit for examining the details of any
> complex algorithm.
> 
> The x86 language is essentially the same thing as a RASP
> machine for all computations that can be accomplished
> with the amount of memory that is available.

Absolutely false. POOH is the example that rejected TM/RASP instead of C.

In trying making P!=NP proof (may have defects, I just leave it there to improve)
https://sourceforge.net/projects/cscall/files/MisFiles/PNP-proof-en.txt/download
I feel TM would be very long and tedious, so I claimed that no *algorithm* can
solve NPC (algorithmic) problems. (thanks to olcott, this proof was inspired in 
refuting POOH.)

See also Spu in my recent post. TM is very low-level to solve many idea of problems.

> To be a computable function within a model of computation
> a sequence of the steps of a specific algorithm must be
> applied to (an often finite string) input to derive an output.
> https://en.wikipedia.org/wiki/Computable_function
> 
> When computing the sum() function the steps of the algorithm
> of arithmetic must be applied to the inputs.
> 
> *When computing the halt() function steps with a simulating*
> *termination analyzer the behavioral steps specified by the*
> *input must be simulated according to the computer language*
> *of this input*
> 
> *I may be wrong yet it seems to me that*
> Computer science never knew these things before in that
> it never placed any limit on the type of algorithm that
> must be performed.
> 
> I think that it was Ben that said that one of two
> functions that do nothing besides return true or false
> is correct on all of the counter-example inputs
> to the halting problem.
> 
> When we require that a mapping be computed from an
> input, then this idea is rejected.
> 

You are excellent in quoting tautology to support your claims.

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

#119222

On 5/15/2025 2:57 PM, wij wrote:
> On Thu, 2025-05-15 at 11:47 -0500, olcott wrote:
>> On 5/15/2025 11:08 AM, Mike Terry wrote:
>>> On 14/05/2025 18:53, wij wrote:
>>>> On Wed, 2025-05-14 at 12:24 -0500, olcott wrote:
>>>>> On 5/14/2025 11:43 AM, wij wrote:
>>>>>> On Wed, 2025-05-14 at 09:51 -0500, olcott wrote:
>>>>>>> On 5/14/2025 12:13 AM, wij wrote:
>>>>>>>> Q: Write a turing machine that performs D function (which calls
>>>>>>>> itself):
>>>>>>>>
>>>>>>>> void D() {
>>>>>>>>      D();
>>>>>>>> }
>>>>>>>>
>>>>>>>> Easy?
>>>>>>>>
>>>>>>>>
>>>>>>>
>>>>>>> That is not a TM.
>>>>>>
>>>>>> It is a C program that exists. Therefore, there must be a equivalent
>>>>>> TM.
>>>>>>
>>>>>>> To make a TM that references itself the closest
>>>>>>> thing is a UTM that simulates its own TM source-code.
>>>>>>
>>>>>> How does a UTM simulate its own TM source-code?
>>>>>>
>>>>>
>>>>> You run a UTM that has its own source-code on its tape.
>>>>
>>>> What is exactly the source-code on its tape?
>>>>
>>>
>>> Every UTM has some scheme which can be applied to a (TM & input tape)
>>> that is to be simulated.  The scheme says how to turn the (TM + input
>>> tape) into a string of symbols that represent that computation.
>>>
>>> So to answer your question, the "source-code on its tape" is the result
>>> of applying the UTM's particular scheme to the combination (UTM, input
>>> tape) that is to be simulated.
>>>
>>> If you're looking for the exact string symbols, obviously you would need
>>> to specify the exact UTM being used, because every UTM will have a
>>> different answer to your question.
>>>
>>>
>>> Mike.
>>>
>>
>> These things cannot be investigated in great
>> depth because there is no fully encoded UTM in
>> any standard language.
> 
> Sort of.
> 
>> If there was such a UTM then examining things
>> like a termination analyzer would be too difficult
>> because of the volume of details. Even moving a
>> single value to a specific memory location can
>> take many many steps.
> 
> So, which part of POOH is "fully encoded UTM"
> 
>> A RASP machine
>> https://en.wikipedia.org/wiki/Random-access_stored-program_machine
>> is a much better fit for examining the details of any
>> complex algorithm.
>>
>> The x86 language is essentially the same thing as a RASP
>> machine for all computations that can be accomplished
>> with the amount of memory that is available.
> 
> Absolutely false. POOH is the example that rejected TM/RASP instead of C.
> 
> In trying making P!=NP proof (may have defects, I just leave it there to improve)
> https://sourceforge.net/projects/cscall/files/MisFiles/PNP-proof-en.txt/download
> I feel TM would be very long and tedious, so I claimed that no *algorithm* can
> solve NPC (algorithmic) problems. (thanks to olcott, this proof was inspired in
> refuting POOH.)
> 
> See also Spu in my recent post. TM is very low-level to solve many idea of problems.
> 
>> To be a computable function within a model of computation
>> a sequence of the steps of a specific algorithm must be
>> applied to (an often finite string) input to derive an output.
>> https://en.wikipedia.org/wiki/Computable_function
>>
>> When computing the sum() function the steps of the algorithm
>> of arithmetic must be applied to the inputs.
>>
>> *When computing the halt() function steps with a simulating*
>> *termination analyzer the behavioral steps specified by the*
>> *input must be simulated according to the computer language*
>> *of this input*
>>
>> *I may be wrong yet it seems to me that*
>> Computer science never knew these things before in that
>> it never placed any limit on the type of algorithm that
>> must be performed.
>>
>> I think that it was Ben that said that one of two
>> functions that do nothing besides return true or false
>> is correct on all of the counter-example inputs
>> to the halting problem.
>>
>> When we require that a mapping be computed from an
>> input, then this idea is rejected.
>>
> 
> You are excellent in quoting tautology to support your claims.
> 

Most people don't know that a mapping must be
computed from the inputs, hence Ben's mistake.

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

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

#119268

On 2025-05-15 20:50:34 +0000, olcott said:

> On 5/15/2025 2:57 PM, wij wrote:
>> On Thu, 2025-05-15 at 11:47 -0500, olcott wrote:
>>> On 5/15/2025 11:08 AM, Mike Terry wrote:
>>>> On 14/05/2025 18:53, wij wrote:
>>>>> On Wed, 2025-05-14 at 12:24 -0500, olcott wrote:
>>>>>> On 5/14/2025 11:43 AM, wij wrote:
>>>>>>> On Wed, 2025-05-14 at 09:51 -0500, olcott wrote:
>>>>>>>> On 5/14/2025 12:13 AM, wij wrote:
>>>>>>>>> Q: Write a turing machine that performs D function (which calls
>>>>>>>>> itself):
>>>>>>>>> 
>>>>>>>>> void D() {
>>>>>>>>>     D();
>>>>>>>>> }
>>>>>>>>> 
>>>>>>>>> Easy?
>>>>>>>>> 
>>>>>>>>> 
>>>>>>>> 
>>>>>>>> That is not a TM.
>>>>>>> 
>>>>>>> It is a C program that exists. Therefore, there must be a equivalent
>>>>>>> TM.
>>>>>>> 
>>>>>>>> To make a TM that references itself the closest
>>>>>>>> thing is a UTM that simulates its own TM source-code.
>>>>>>> 
>>>>>>> How does a UTM simulate its own TM source-code?
>>>>>>> 
>>>>>> 
>>>>>> You run a UTM that has its own source-code on its tape.
>>>>> 
>>>>> What is exactly the source-code on its tape?
>>>>> 
>>>> 
>>>> Every UTM has some scheme which can be applied to a (TM & input tape)
>>>> that is to be simulated.  The scheme says how to turn the (TM + input
>>>> tape) into a string of symbols that represent that computation.
>>>> 
>>>> So to answer your question, the "source-code on its tape" is the result
>>>> of applying the UTM's particular scheme to the combination (UTM, input
>>>> tape) that is to be simulated.
>>>> 
>>>> If you're looking for the exact string symbols, obviously you would need
>>>> to specify the exact UTM being used, because every UTM will have a
>>>> different answer to your question.
>>>> 
>>>> 
>>>> Mike.
>>>> 
>>> 
>>> These things cannot be investigated in great
>>> depth because there is no fully encoded UTM in
>>> any standard language.
>> 
>> Sort of.
>> 
>>> If there was such a UTM then examining things
>>> like a termination analyzer would be too difficult
>>> because of the volume of details. Even moving a
>>> single value to a specific memory location can
>>> take many many steps.
>> 
>> So, which part of POOH is "fully encoded UTM"
>> 
>>> A RASP machine
>>> https://en.wikipedia.org/wiki/Random-access_stored-program_machine
>>> is a much better fit for examining the details of any
>>> complex algorithm.
>>> 
>>> The x86 language is essentially the same thing as a RASP
>>> machine for all computations that can be accomplished
>>> with the amount of memory that is available.
>> 
>> Absolutely false. POOH is the example that rejected TM/RASP instead of C.
>> 
>> In trying making P!=NP proof (may have defects, I just leave it there 
>> to improve)
>> https://sourceforge.net/projects/cscall/files/MisFiles/PNP-proof-en.txt/download 
>> 
>> I feel TM would be very long and tedious, so I claimed that no *algorithm* can
>> solve NPC (algorithmic) problems. (thanks to olcott, this proof was inspired in
>> refuting POOH.)
>> 
>> See also Spu in my recent post. TM is very low-level to solve many idea 
>> of problems.
>> 
>>> To be a computable function within a model of computation
>>> a sequence of the steps of a specific algorithm must be
>>> applied to (an often finite string) input to derive an output.
>>> https://en.wikipedia.org/wiki/Computable_function
>>> 
>>> When computing the sum() function the steps of the algorithm
>>> of arithmetic must be applied to the inputs.
>>> 
>>> *When computing the halt() function steps with a simulating*
>>> *termination analyzer the behavioral steps specified by the*
>>> *input must be simulated according to the computer language*
>>> *of this input*
>>> 
>>> *I may be wrong yet it seems to me that*
>>> Computer science never knew these things before in that
>>> it never placed any limit on the type of algorithm that
>>> must be performed.
>>> 
>>> I think that it was Ben that said that one of two
>>> functions that do nothing besides return true or false
>>> is correct on all of the counter-example inputs
>>> to the halting problem.
>>> 
>>> When we require that a mapping be computed from an
>>> input, then this idea is rejected.
>>> 
>> 
>> You are excellent in quoting tautology to support your claims.
>> 
> 
> Most people don't know that a mapping must be
> computed from the inputs, hence Ben's mistake.

Most people don't even know what mappings are. Most people don't
make mistakes just because they don't know what mappings are.

Ben does not make mistakes just because most people don't know
something that Ben does know.

-- 
Mikko

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

#119308

On 5/16/2025 2:33 AM, Mikko wrote:
> On 2025-05-15 20:50:34 +0000, olcott said:
> 
>> On 5/15/2025 2:57 PM, wij wrote:
>>> On Thu, 2025-05-15 at 11:47 -0500, olcott wrote:
>>>> On 5/15/2025 11:08 AM, Mike Terry wrote:
>>>>> On 14/05/2025 18:53, wij wrote:
>>>>>> On Wed, 2025-05-14 at 12:24 -0500, olcott wrote:
>>>>>>> On 5/14/2025 11:43 AM, wij wrote:
>>>>>>>> On Wed, 2025-05-14 at 09:51 -0500, olcott wrote:
>>>>>>>>> On 5/14/2025 12:13 AM, wij wrote:
>>>>>>>>>> Q: Write a turing machine that performs D function (which calls
>>>>>>>>>> itself):
>>>>>>>>>>
>>>>>>>>>> void D() {
>>>>>>>>>>     D();
>>>>>>>>>> }
>>>>>>>>>>
>>>>>>>>>> Easy?
>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> That is not a TM.
>>>>>>>>
>>>>>>>> It is a C program that exists. Therefore, there must be a 
>>>>>>>> equivalent
>>>>>>>> TM.
>>>>>>>>
>>>>>>>>> To make a TM that references itself the closest
>>>>>>>>> thing is a UTM that simulates its own TM source-code.
>>>>>>>>
>>>>>>>> How does a UTM simulate its own TM source-code?
>>>>>>>>
>>>>>>>
>>>>>>> You run a UTM that has its own source-code on its tape.
>>>>>>
>>>>>> What is exactly the source-code on its tape?
>>>>>>
>>>>>
>>>>> Every UTM has some scheme which can be applied to a (TM & input tape)
>>>>> that is to be simulated.  The scheme says how to turn the (TM + input
>>>>> tape) into a string of symbols that represent that computation.
>>>>>
>>>>> So to answer your question, the "source-code on its tape" is the 
>>>>> result
>>>>> of applying the UTM's particular scheme to the combination (UTM, input
>>>>> tape) that is to be simulated.
>>>>>
>>>>> If you're looking for the exact string symbols, obviously you would 
>>>>> need
>>>>> to specify the exact UTM being used, because every UTM will have a
>>>>> different answer to your question.
>>>>>
>>>>>
>>>>> Mike.
>>>>>
>>>>
>>>> These things cannot be investigated in great
>>>> depth because there is no fully encoded UTM in
>>>> any standard language.
>>>
>>> Sort of.
>>>
>>>> If there was such a UTM then examining things
>>>> like a termination analyzer would be too difficult
>>>> because of the volume of details. Even moving a
>>>> single value to a specific memory location can
>>>> take many many steps.
>>>
>>> So, which part of POOH is "fully encoded UTM"
>>>
>>>> A RASP machine
>>>> https://en.wikipedia.org/wiki/Random-access_stored-program_machine
>>>> is a much better fit for examining the details of any
>>>> complex algorithm.
>>>>
>>>> The x86 language is essentially the same thing as a RASP
>>>> machine for all computations that can be accomplished
>>>> with the amount of memory that is available.
>>>
>>> Absolutely false. POOH is the example that rejected TM/RASP instead 
>>> of C.
>>>
>>> In trying making P!=NP proof (may have defects, I just leave it there 
>>> to improve)
>>> https://sourceforge.net/projects/cscall/files/MisFiles/PNP-proof- 
>>> en.txt/download
>>> I feel TM would be very long and tedious, so I claimed that no 
>>> *algorithm* can
>>> solve NPC (algorithmic) problems. (thanks to olcott, this proof was 
>>> inspired in
>>> refuting POOH.)
>>>
>>> See also Spu in my recent post. TM is very low-level to solve many 
>>> idea of problems.
>>>
>>>> To be a computable function within a model of computation
>>>> a sequence of the steps of a specific algorithm must be
>>>> applied to (an often finite string) input to derive an output.
>>>> https://en.wikipedia.org/wiki/Computable_function
>>>>
>>>> When computing the sum() function the steps of the algorithm
>>>> of arithmetic must be applied to the inputs.
>>>>
>>>> *When computing the halt() function steps with a simulating*
>>>> *termination analyzer the behavioral steps specified by the*
>>>> *input must be simulated according to the computer language*
>>>> *of this input*
>>>>
>>>> *I may be wrong yet it seems to me that*
>>>> Computer science never knew these things before in that
>>>> it never placed any limit on the type of algorithm that
>>>> must be performed.
>>>>
>>>> I think that it was Ben that said that one of two
>>>> functions that do nothing besides return true or false
>>>> is correct on all of the counter-example inputs
>>>> to the halting problem.
>>>>
>>>> When we require that a mapping be computed from an
>>>> input, then this idea is rejected.
>>>>
>>>
>>> You are excellent in quoting tautology to support your claims.
>>>
>>
>> Most people don't know that a mapping must be
>> computed from the inputs, hence Ben's mistake.
> 
> Most people don't even know what mappings are. Most people don't
> make mistakes just because they don't know what mappings are.
> 
> Ben does not make mistakes just because most people don't know
> something that Ben does know.
> 

Ben was wrong when he said that there are a
pair of computable functions such that one
of them always gets the correct halt status
decision. IGNORING THE INPUTS IT NOT ALLOWED

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

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

#119324

On 5/16/25 11:43 AM, olcott wrote:
> On 5/16/2025 2:33 AM, Mikko wrote:
>> On 2025-05-15 20:50:34 +0000, olcott said:
>>
>>> On 5/15/2025 2:57 PM, wij wrote:
>>>> On Thu, 2025-05-15 at 11:47 -0500, olcott wrote:
>>>>> On 5/15/2025 11:08 AM, Mike Terry wrote:
>>>>>> On 14/05/2025 18:53, wij wrote:
>>>>>>> On Wed, 2025-05-14 at 12:24 -0500, olcott wrote:
>>>>>>>> On 5/14/2025 11:43 AM, wij wrote:
>>>>>>>>> On Wed, 2025-05-14 at 09:51 -0500, olcott wrote:
>>>>>>>>>> On 5/14/2025 12:13 AM, wij wrote:
>>>>>>>>>>> Q: Write a turing machine that performs D function (which calls
>>>>>>>>>>> itself):
>>>>>>>>>>>
>>>>>>>>>>> void D() {
>>>>>>>>>>>     D();
>>>>>>>>>>> }
>>>>>>>>>>>
>>>>>>>>>>> Easy?
>>>>>>>>>>>
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> That is not a TM.
>>>>>>>>>
>>>>>>>>> It is a C program that exists. Therefore, there must be a 
>>>>>>>>> equivalent
>>>>>>>>> TM.
>>>>>>>>>
>>>>>>>>>> To make a TM that references itself the closest
>>>>>>>>>> thing is a UTM that simulates its own TM source-code.
>>>>>>>>>
>>>>>>>>> How does a UTM simulate its own TM source-code?
>>>>>>>>>
>>>>>>>>
>>>>>>>> You run a UTM that has its own source-code on its tape.
>>>>>>>
>>>>>>> What is exactly the source-code on its tape?
>>>>>>>
>>>>>>
>>>>>> Every UTM has some scheme which can be applied to a (TM & input tape)
>>>>>> that is to be simulated.  The scheme says how to turn the (TM + input
>>>>>> tape) into a string of symbols that represent that computation.
>>>>>>
>>>>>> So to answer your question, the "source-code on its tape" is the 
>>>>>> result
>>>>>> of applying the UTM's particular scheme to the combination (UTM, 
>>>>>> input
>>>>>> tape) that is to be simulated.
>>>>>>
>>>>>> If you're looking for the exact string symbols, obviously you 
>>>>>> would need
>>>>>> to specify the exact UTM being used, because every UTM will have a
>>>>>> different answer to your question.
>>>>>>
>>>>>>
>>>>>> Mike.
>>>>>>
>>>>>
>>>>> These things cannot be investigated in great
>>>>> depth because there is no fully encoded UTM in
>>>>> any standard language.
>>>>
>>>> Sort of.
>>>>
>>>>> If there was such a UTM then examining things
>>>>> like a termination analyzer would be too difficult
>>>>> because of the volume of details. Even moving a
>>>>> single value to a specific memory location can
>>>>> take many many steps.
>>>>
>>>> So, which part of POOH is "fully encoded UTM"
>>>>
>>>>> A RASP machine
>>>>> https://en.wikipedia.org/wiki/Random-access_stored-program_machine
>>>>> is a much better fit for examining the details of any
>>>>> complex algorithm.
>>>>>
>>>>> The x86 language is essentially the same thing as a RASP
>>>>> machine for all computations that can be accomplished
>>>>> with the amount of memory that is available.
>>>>
>>>> Absolutely false. POOH is the example that rejected TM/RASP instead 
>>>> of C.
>>>>
>>>> In trying making P!=NP proof (may have defects, I just leave it 
>>>> there to improve)
>>>> https://sourceforge.net/projects/cscall/files/MisFiles/PNP-proof- 
>>>> en.txt/download
>>>> I feel TM would be very long and tedious, so I claimed that no 
>>>> *algorithm* can
>>>> solve NPC (algorithmic) problems. (thanks to olcott, this proof was 
>>>> inspired in
>>>> refuting POOH.)
>>>>
>>>> See also Spu in my recent post. TM is very low-level to solve many 
>>>> idea of problems.
>>>>
>>>>> To be a computable function within a model of computation
>>>>> a sequence of the steps of a specific algorithm must be
>>>>> applied to (an often finite string) input to derive an output.
>>>>> https://en.wikipedia.org/wiki/Computable_function
>>>>>
>>>>> When computing the sum() function the steps of the algorithm
>>>>> of arithmetic must be applied to the inputs.
>>>>>
>>>>> *When computing the halt() function steps with a simulating*
>>>>> *termination analyzer the behavioral steps specified by the*
>>>>> *input must be simulated according to the computer language*
>>>>> *of this input*
>>>>>
>>>>> *I may be wrong yet it seems to me that*
>>>>> Computer science never knew these things before in that
>>>>> it never placed any limit on the type of algorithm that
>>>>> must be performed.
>>>>>
>>>>> I think that it was Ben that said that one of two
>>>>> functions that do nothing besides return true or false
>>>>> is correct on all of the counter-example inputs
>>>>> to the halting problem.
>>>>>
>>>>> When we require that a mapping be computed from an
>>>>> input, then this idea is rejected.
>>>>>
>>>>
>>>> You are excellent in quoting tautology to support your claims.
>>>>
>>>
>>> Most people don't know that a mapping must be
>>> computed from the inputs, hence Ben's mistake.
>>
>> Most people don't even know what mappings are. Most people don't
>> make mistakes just because they don't know what mappings are.
>>
>> Ben does not make mistakes just because most people don't know
>> something that Ben does know.
>>
> 
> Ben was wrong when he said that there are a
> pair of computable functions such that one
> of them always gets the correct halt status
> decision. IGNORING THE INPUTS IT NOT ALLOWED
> 

Who says?

suppose I am asked to create a program that computes the difference 
between a natural number and itself.

int selfdiff(int x);

Would it not be correct to just write:

int selfdiff(int  x) { return 0; }

Since the difference between a number and itself is always 0.

Just like a function that given two numbers, compute the sum of 2 + 3

WHCH WAS THE PROBLEM YOU STATED, write a program to compute sum(2, 3)

can be writen as int sum5(int x, int y) { return 5; }, as the input 
values are not needed to compute the result.

The method used to reach the answer is irrelvent in computation theory, 
as long is it is a finite deterministic algorithm working on nothing but 
its defined input. If it can get the right answer ignoring some of its 
inputs, that is fine, and just shows that the mapping it is computing 
wasn't dependent on that input.

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

#119396

On 2025-05-16 15:43:02 +0000, olcott said:

> On 5/16/2025 2:33 AM, Mikko wrote:
>> On 2025-05-15 20:50:34 +0000, olcott said:
>> 
>>> On 5/15/2025 2:57 PM, wij wrote:
>>>> On Thu, 2025-05-15 at 11:47 -0500, olcott wrote:
>>>>> On 5/15/2025 11:08 AM, Mike Terry wrote:
>>>>>> On 14/05/2025 18:53, wij wrote:
>>>>>>> On Wed, 2025-05-14 at 12:24 -0500, olcott wrote:
>>>>>>>> On 5/14/2025 11:43 AM, wij wrote:
>>>>>>>>> On Wed, 2025-05-14 at 09:51 -0500, olcott wrote:
>>>>>>>>>> On 5/14/2025 12:13 AM, wij wrote:
>>>>>>>>>>> Q: Write a turing machine that performs D function (which calls
>>>>>>>>>>> itself):
>>>>>>>>>>> 
>>>>>>>>>>> void D() {
>>>>>>>>>>>     D();
>>>>>>>>>>> }
>>>>>>>>>>> 
>>>>>>>>>>> Easy?
>>>>>>>>>>> 
>>>>>>>>>>> 
>>>>>>>>>> 
>>>>>>>>>> That is not a TM.
>>>>>>>>> 
>>>>>>>>> It is a C program that exists. Therefore, there must be a equivalent
>>>>>>>>> TM.
>>>>>>>>> 
>>>>>>>>>> To make a TM that references itself the closest
>>>>>>>>>> thing is a UTM that simulates its own TM source-code.
>>>>>>>>> 
>>>>>>>>> How does a UTM simulate its own TM source-code?
>>>>>>>>> 
>>>>>>>> 
>>>>>>>> You run a UTM that has its own source-code on its tape.
>>>>>>> 
>>>>>>> What is exactly the source-code on its tape?
>>>>>>> 
>>>>>> 
>>>>>> Every UTM has some scheme which can be applied to a (TM & input tape)
>>>>>> that is to be simulated.  The scheme says how to turn the (TM + input
>>>>>> tape) into a string of symbols that represent that computation.
>>>>>> 
>>>>>> So to answer your question, the "source-code on its tape" is the result
>>>>>> of applying the UTM's particular scheme to the combination (UTM, input
>>>>>> tape) that is to be simulated.
>>>>>> 
>>>>>> If you're looking for the exact string symbols, obviously you would need
>>>>>> to specify the exact UTM being used, because every UTM will have a
>>>>>> different answer to your question.
>>>>>> 
>>>>>> 
>>>>>> Mike.
>>>>>> 
>>>>> 
>>>>> These things cannot be investigated in great
>>>>> depth because there is no fully encoded UTM in
>>>>> any standard language.
>>>> 
>>>> Sort of.
>>>> 
>>>>> If there was such a UTM then examining things
>>>>> like a termination analyzer would be too difficult
>>>>> because of the volume of details. Even moving a
>>>>> single value to a specific memory location can
>>>>> take many many steps.
>>>> 
>>>> So, which part of POOH is "fully encoded UTM"
>>>> 
>>>>> A RASP machine
>>>>> https://en.wikipedia.org/wiki/Random-access_stored-program_machine
>>>>> is a much better fit for examining the details of any
>>>>> complex algorithm.
>>>>> 
>>>>> The x86 language is essentially the same thing as a RASP
>>>>> machine for all computations that can be accomplished
>>>>> with the amount of memory that is available.
>>>> 
>>>> Absolutely false. POOH is the example that rejected TM/RASP instead of C.
>>>> 
>>>> In trying making P!=NP proof (may have defects, I just leave it there 
>>>> to improve)
>>>> https://sourceforge.net/projects/cscall/files/MisFiles/PNP-proof- 
>>>> en.txt/download
>>>> I feel TM would be very long and tedious, so I claimed that no *algorithm* can
>>>> solve NPC (algorithmic) problems. (thanks to olcott, this proof was inspired in
>>>> refuting POOH.)
>>>> 
>>>> See also Spu in my recent post. TM is very low-level to solve many idea 
>>>> of problems.
>>>> 
>>>>> To be a computable function within a model of computation
>>>>> a sequence of the steps of a specific algorithm must be
>>>>> applied to (an often finite string) input to derive an output.
>>>>> https://en.wikipedia.org/wiki/Computable_function
>>>>> 
>>>>> When computing the sum() function the steps of the algorithm
>>>>> of arithmetic must be applied to the inputs.
>>>>> 
>>>>> *When computing the halt() function steps with a simulating*
>>>>> *termination analyzer the behavioral steps specified by the*
>>>>> *input must be simulated according to the computer language*
>>>>> *of this input*
>>>>> 
>>>>> *I may be wrong yet it seems to me that*
>>>>> Computer science never knew these things before in that
>>>>> it never placed any limit on the type of algorithm that
>>>>> must be performed.
>>>>> 
>>>>> I think that it was Ben that said that one of two
>>>>> functions that do nothing besides return true or false
>>>>> is correct on all of the counter-example inputs
>>>>> to the halting problem.
>>>>> 
>>>>> When we require that a mapping be computed from an
>>>>> input, then this idea is rejected.
>>>>> 
>>>> 
>>>> You are excellent in quoting tautology to support your claims.
>>>> 
>>> 
>>> Most people don't know that a mapping must be
>>> computed from the inputs, hence Ben's mistake.
>> 
>> Most people don't even know what mappings are. Most people don't
>> make mistakes just because they don't know what mappings are.
>> 
>> Ben does not make mistakes just because most people don't know
>> something that Ben does know.
> 
> Ben was wrong when he said that there are a
> pair of computable functions such that one
> of them always gets the correct halt status
> decision. IGNORING THE INPUTS IT NOT ALLOWED

No, Ben was not wrong about that. The meaning of the word function
does allow ignoring a part or all of the inputs.

-- 
Mikko

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

#119231

On 5/15/25 12:47 PM, olcott wrote:
> On 5/15/2025 11:08 AM, Mike Terry wrote:
>> On 14/05/2025 18:53, wij wrote:
>>> On Wed, 2025-05-14 at 12:24 -0500, olcott wrote:
>>>> On 5/14/2025 11:43 AM, wij wrote:
>>>>> On Wed, 2025-05-14 at 09:51 -0500, olcott wrote:
>>>>>> On 5/14/2025 12:13 AM, wij wrote:
>>>>>>> Q: Write a turing machine that performs D function (which calls 
>>>>>>> itself):
>>>>>>>
>>>>>>> void D() {
>>>>>>>     D();
>>>>>>> }
>>>>>>>
>>>>>>> Easy?
>>>>>>>
>>>>>>>
>>>>>>
>>>>>> That is not a TM.
>>>>>
>>>>> It is a C program that exists. Therefore, there must be a 
>>>>> equivalent TM.
>>>>>
>>>>>> To make a TM that references itself the closest
>>>>>> thing is a UTM that simulates its own TM source-code.
>>>>>
>>>>> How does a UTM simulate its own TM source-code?
>>>>>
>>>>
>>>> You run a UTM that has its own source-code on its tape.
>>>
>>> What is exactly the source-code on its tape?
>>>
>>
>> Every UTM has some scheme which can be applied to a (TM & input tape) 
>> that is to be simulated.  The scheme says how to turn the (TM + input 
>> tape) into a string of symbols that represent that computation.
>>
>> So to answer your question, the "source-code on its tape" is the 
>> result of applying the UTM's particular scheme to the combination 
>> (UTM, input tape) that is to be simulated.
>>
>> If you're looking for the exact string symbols, obviously you would 
>> need to specify the exact UTM being used, because every UTM will have 
>> a different answer to your question.
>>
>>
>> Mike.
>>
> 
> These things cannot be investigated in great
> depth because there is no fully encoded UTM in
> any standard language.

Sure there are. In fact, a few years ago when you were trying to learn 
about TM's we showed you a PC program that would simulate an arbitrary 
TM. You just didn't like it as its symbol set was too restricted for you 
taste.

> 
> If there was such a UTM then examining things
> like a termination analyzer would be too difficult
> because of the volume of details. Even moving a
> single value to a specific memory location can
> take many many steps.

That is just your own problem. Your problem is you don't know how to 
think it TM operations. Your rarely want to place a specific number at a 
specific place on the tape (the closest thing to a memory location)

> 
> A RASP machine
> https://en.wikipedia.org/wiki/Random-access_stored-program_machine
> is a much better fit for examining the details of any
> complex algorithm.
> 
> The x86 language is essentially the same thing as a RASP
> machine for all computations that can be accomplished
> with the amount of memory that is available.

Nope, quite different. There are a few simularities, but there are also 
major differences. Now, RASP machine do have the same fault as the x86 
that program fragments in them are not necessarily programs/compuations 
anymore. That is the key feature of Turing Machines, ANY Turing Machine 
represent a computation if it halts.

> 
> To be a computable function within a model of computation
> a sequence of the steps of a specific algorithm must be
> applied to (an often finite string) input to derive an output.
> https://en.wikipedia.org/wiki/Computable_function

Right, but not all functions are computable, like the Halting Funciton.

> 
> When computing the sum() function the steps of the algorithm
> of arithmetic must be applied to the inputs.

Right, as that is the mapping defined by itl

> 
> *When computing the halt() function steps with a simulating*
> *termination analyzer the behavioral steps specified by the*
> *input must be simulated according to the computer language*
> *of this input*

Right, but that simulation might be of infinite length, and thus the 
decider can't do that an still answer in finite time.

> 
> *I may be wrong yet it seems to me that*
> Computer science never knew these things before in that
> it never placed any limit on the type of algorithm that
> must be performed.


The problem is you don't understand a few of the basics, like the 
mapping can be based on the infinite processing, but the decider can't

> 
> I think that it was Ben that said that one of two
> functions that do nothing besides return true or false
> is correct on all of the counter-example inputs
> to the halting problem.

That is true. Deciders are rated STRICTLY by comparing the answer they 
give to the required answer. Computability theory does not care about 
the details of how the answer came about, as long is it was built on a 
finite number of deterministic instructions.

Thus one of the two machine

> 
> When we require that a mapping be computed from an
> input, then this idea is rejected.
> 

Nope, as doing x = 1 *IS* a computation.

You just don't knwo what the words you are using mean.

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

Page 2 of 6 — ← Prev page 1 [2] 3 4 5 6  Next page →

Back to top | Article view | comp.theory

csiph-web