Path: ...!weretis.net!feeder9.news.weretis.net!i2pn.org!i2pn2.org!.POSTED!not-for-mail
From: Richard Damon <richard@damon-family.org>
Newsgroups: comp.theory
Subject: Re: Foundation of formal logic systems --- finite string
 transformation rules applied to finite strings.
Date: Sat, 26 Oct 2024 11:35:41 -0400
Organization: i2pn2 (i2pn.org)
Message-ID: <vfj28e$3j3qf$2@i2pn2.org>
References: <vf3eu5$fbb3$2@dont-email.me> <vf74oh$1a8oo$1@dont-email.me>
 <525ed75662589a150afa1ea268b199a166a7b98b@i2pn2.org>
 <vf8ads$1gkf5$1@dont-email.me>
 <13583474d25855e665daa98d91605e958f5cf472@i2pn2.org>
 <vf8i1g$1h5mj$4@dont-email.me>
 <45ea7a6da46453c9da62c1149fa1cf7739218c5f@i2pn2.org>
 <vf9qai$1scol$1@dont-email.me>
 <2a210ab064b3a8c3397600b4fe87aa390868bb12@i2pn2.org>
 <vf9sk6$1sfva$2@dont-email.me>
 <4c67570b4898e14665bde2dfdf473130b89b7dd4@i2pn2.org>
 <vfaqe7$21k64$1@dont-email.me>
 <f789d3ef27e3000f04feb3df4fc561c5da02381f@i2pn2.org>
 <vfc96p$2b6h0$1@dont-email.me>
 <74edcca800e7af74169cea47cb8f1715d3a5145f@i2pn2.org>
 <vfdihe$2kvn4$2@dont-email.me>
 <4abd6615b2730699ecc474d01b97163917e0b01d@i2pn2.org>
 <vfeqbs$2rugm$1@dont-email.me>
 <d7e366b37fa336944a72bb41a0e655076b6b335f@i2pn2.org>
 <vfg82q$36im7$4@dont-email.me>
 <0911038494da3f0613bcc3f31271820baa79a0b2@i2pn2.org>
 <vfh522$3bkkv$3@dont-email.me>
 <dd74abb909f08d16e7707ecbdc52acd9d5a5a575@i2pn2.org>
 <vfiqf7$3ner2$4@dont-email.me>
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8; format=flowed
Content-Transfer-Encoding: 8bit
Injection-Date: Sat, 26 Oct 2024 15:35:42 -0000 (UTC)
Injection-Info: i2pn2.org;
	logging-data="3772239"; mail-complaints-to="usenet@i2pn2.org"
User-Agent: Mozilla Thunderbird
Content-Language: en-US
In-Reply-To: <vfiqf7$3ner2$4@dont-email.me>
Bytes: 7073
Lines: 131

On 10/26/24 9:22 AM, olcott wrote:
> On 10/25/2024 11:07 PM, Richard Damon wrote:
>> On 10/25/24 6:11 PM, olcott wrote:
>>> On 10/25/2024 10:45 AM, Richard Damon wrote:
>>>> On 10/25/24 9:56 AM, olcott wrote:
>>>>> On 10/25/2024 7:27 AM, Richard Damon wrote:
>>>>>> On 10/24/24 8:56 PM, olcott wrote:
>>>>>>> On 10/24/2024 6:23 PM, Richard Damon wrote:
>>>>>>>> On 10/24/24 9:36 AM, olcott wrote:
>>>>>>>>> On 10/23/2024 9:48 PM, Richard Damon wrote:
>>>>>>>>>> On 10/23/24 9:51 PM, olcott wrote:
>>>>>>>>>>> ChatGPT does completely understand this.
>>>>>>>>>>>
>>>>>>>>>>
>>>>>>>>>> But, it is just a stupid idiot that has been taught to repeat 
>>>>>>>>>> what it has been told.
>>>>>>>>>>
>>>>>>>>>
>>>>>>>>> It is a brilliant genius that seems to infallibly deduce all
>>>>>>>>> of the subtle nuances of each of the consequences on the basis
>>>>>>>>> of a set of premises.
>>>>>>>>
>>>>>>>> I guess you don't undetstand how "Large Language Models work, do 
>>>>>>>> you.
>>>>>>>>
>>>>>>>> It has NO actual intelegence, or ability to "deduce" nuances, it 
>>>>>>>> is just a massive pattern matching system.
>>>>>>>>
>>>>>>>> All you are doing is proving how little you understand about 
>>>>>>>> what you are talking about,
>>>>>>>>
>>>>>>>> Remember, at the bottom of the page is a WARNING that it can 
>>>>>>>> make mistakes. And feeding it LIES, like you do is one easy way 
>>>>>>>> to do that.
>>>>>>>>
>>>>>>>
>>>>>>> There is much more to this than your superficial
>>>>>>> understanding.  Here is a glimpse:
>>>>>>> https://www.technologyreview.com/2024/03/04/1089403/large- 
>>>>>>> language- models-amazing-but-nobody-knows-why/
>>>>>>>
>>>>>>> The bottom line is that ChatGPT made no error in its
>>>>>>> evaluation of my work when this evaluation is based on
>>>>>>> pure reasoning. It is only when my work is measured
>>>>>>> against arbitrary dogma that cannot be justified with
>>>>>>> pure reasoning that makes me and ChatGPT seem incorrect.
>>>>>>>
>>>>>>> If use your same approach to these things we could say that
>>>>>>> ZFC stupidly fails to have a glimmering of understanding of
>>>>>>> Naive set theory. From your perspective ZFC is a damned liar.
>>>>>>>
>>>>>>
>>>>>> The articles says no such thing.
>>>>>>
>>>>>
>>>>> *large-language-models-amazing-but-nobody-knows-why*
>>>>> They are much smarter and can figure out all kinds of
>>>>> things. Their original designers have no idea how they
>>>>> do this.
>>>>>
>>>>>> In fact, it comments about the problem of "overfitting" where the 
>>>>>> processing get the wrong answers because it over generalizes.
>>>>>>
>>>>>> This is because the modeling process has no concept of actual 
>>>>>> meaning, and thus of truth, only the patterns that it has seen.
>>>>>>
>>>>>> AI's don't "Reason", they patern match and compare.
>>>>>>
>>>>>> Note, that "arbitrary dogma" that you try to reject, are the RULES 
>>>>>> and DEFINITONS of the system that you claim to be working in.
>>>>>>
>>>>>
>>>>> How about we stipulate that the system that I am
>>>>> working in is termination analysis for the x86 language.
>>>>> as my system software says in its own name: x86utm.
>>>>
>>>> But it doesn;t actually know
>>>>
>>>
>>> I said the the underlying formal mathematical system
>>> of DDD/HHH <is> the x86 language.
>>
>> Can't be.
>>
>> That isn't a formal logic system.
>>
> 
> Sure it is. A formal logic system is any system
> tat applies finite string transformation rules
> to finite strings.

Whch the x86 language is not.

The x86 language doesn't produce "strings" it produces "behavior"

And it doesn't take in "strings" it takes is bit combinations, that 
represent the entire state of the system, and produces a resultant 
system state. No where does it talk about "strings".

Yes, it defines a set of "transformation rules" but they are not on 
"strings" but on system memory state.

Yes, in Computation Theory you can express such state as a "string", but 
the x86 langugage doesn't have that concept.

You are just showing you don't understand what you are talking about, 
and you don't know what you are actually using.

> 
> The simplest concrete example of such a system
> transforms pairs of ASCII digits into their sum.
> 

Which isn't what the x86 language does.

There is an instruction (or a set of them) that take the contents of two 
data source and produce as an output a data sink with the results 
determined to be the sum of the those inputs, when expressed as two's 
complement numbers.

Nothing there talked about "ASCII", and no 86 languge element does that 
as a single defined step.

Yes, you can write a program with a sequence of steps that performs that 
action, but in the definition of the x86 langugage, there never was an 
"ASCII String" with the input, just bytes of memory with specific values 
and the output is not an "ASCII string", it is also just a series of 
bytes with specific values.

You need to invoke computation theory to convert the code part of that 
x86 program into an algorithm, and the data part of that program to be 
an interpretation of those strings to get your results.