[agi] NOIR: Neural Signal Operated Intelligent Robots for Everyday Activities

[immortal . discoveries]

https://noir-corl.github.io/
--
Artificial General Intelligence List: AGI
Permalink: 
https://agi.topicbox.com/groups/agi/T0c6e87ebefa61d26-M9d9d5e0ae4cf1634ca3211ec
Delivery options: https://agi.topicbox.com/groups/agi/subscription

Re: [agi] GPT-4 Turbo Fails AIC Test -- HARD

[James Bowery]

On Thu, Nov 9, 2023 at 1:16 PM Matt Mahoney  wrote:

> ...
> Of course GPT4 is just doing what a human who doesn't know the answer
> would do. That's how you pass the Turing test.
>

Would a person who didn't know the answer but figured it out, as
most-assuredly any cryptanalyst would,

therefore fail the Turing Test?


>
> On Thu, Nov 9, 2023 at 12:51 PM Mike Archbold  wrote:
> >
> > I asked it to create a compress function, so it just zip'd it:
> >
> > import zlib
> >
> > s =
> '01000111001101001100011101100101010010110110001101011100110001100101001110100101011011010100011001110101101001110101'
> >
> > def compress(s):
> > return zlib.compress(s.encode('utf-8'))
> >
> > print(compress(s).decode('utf-8'))
> >
> > On Wed, Nov 8, 2023 at 6:26 AM James Bowery  wrote:
> >>
> >> The following from GPT4 Turbo is what you get from an industry that
> has, like Shane Legg, lost its Ockham's Razor alignment (Algorithmic
> Information Criterion) with truth to the hysteria over feel-good
> "alignment" while snatching the low hanging fruits:
> >>
> >> USER
> >> What is the shortest python program you can come up with that outputs
> this string?
> 01000111001101001100011101100101010010110110001101011100110001100101001110100101011011010100011001110101101001110101
> >> ASSISTANT
> >> To output the given string in Python, the shortest program would be to
> just print it directly:
> print("01000111001101001100011101100101010010110110001101011100110001100101001110100101011011010100011001110101101001110101")
> >> This program doesn’t perform any operations other than printing the
> provided string.
> >> USER
> >> can you compress that string?
> >> ASSISTANT
> >> To compress the string and then output it in Python, we could use
> different approaches. One approach is to use built-in libraries like zlib
> to compress the data. However, it’s worth noting that compression works
> well on larger datasets and might not be efficient for short repetitive
> strings such as this one.
> >> Here’s an example of how you might compress and then decompress a
> string using zlib:
> >> import zlib
> >>
> >> # Your original string
> >> data =
> "01000111001101001100011101100101010010110110001101011100110001100101001110100101011011010100011001110101101001110101"
> >> # Compress the data
> >> compressed_data = zlib.compress(data.encode())
> >>
> >> # Decompress the data
> >> decompressed_data = zlib.decompress(compressed_data).decode()
> >>
> >> # Print the decompressed data
> >> print(decompressed_data)
> >>
> >> However, with such a specific sequence and length, you are unlikely to
> achieve actual compression because the overhead of the compression
> algorithm might exceed any savings, especially since the string pattern is
> not highly repetitive and is quite short. In this case, I expect the
> compressed_data to be larger in size than the original data.
> >> For this specific string, it’s challenging to compress it meaningfully
> without a custom encoding scheme that takes advantage of patterns that
> could be represented in fewer bits.
> >> If the characters have a specific meaning or pattern, like binary
> representation of numbers that could be converted into a shorter sequence,
> then you could devise an encoding that would represent the data more
> compactly. Nevertheless, for the given sequence without context, the best
> ‘compression’ would be simply transmitting it as is.
> >> USER
> >> are there any patterns in that string?
> >> ASSISTANT
> >> To determine whether there are any compressible patterns in the
> provided string, we would typically look for repeating sequences,
> predictable sequences (like arithmetic sequences), or some sort of
> structure that could be simplified. At a glance, the string appears to be a
> random sequence of 0s and 1s without any immediately obvious patterns:
> 01000111001101001100011101100101010010110110001101011100110001100101001110100101011011010100011001110101101001110101
> >> A manual inspection doesn’t reveal any simple repeats or
> sequences—there are no long runs of 0s or 1s that could easily be
> compressed. There isn’t a clear arithmetic progression or other
> mathematical patterns that can be discerned without further context.
> >> Without additional context on how this string was generated, or what it
> represents, devising a pattern-based compression algorithm is not feasible.
> If the string encodes binary data that represents a more complex structure
> (e.g., an encoded image, a sequence of commands, etc.), understanding that
> structure would be key to compressing the string.
> >>
> >> As it stands, the string appears to be binary data with no discernible
> simple p

Re: [agi] GPT-4 Turbo Fails AIC Test -- HARD

[James Bowery]

Yes, that's an obvious trick that can be remedied by simply increasing the
length of the counter.

On Thu, Nov 9, 2023 at 3:48 PM John Rose  wrote:

> All strings are numbers. Base 65,536 in Basic Multilingual Plane Unicode:
>
> printf(“D㈔읂咶㗏葥㩖ퟆ疾矟”);
>
> *Artificial General Intelligence List *
> / AGI / see discussions  +
> participants  +
> delivery options 
> Permalink
> 
>

--
Artificial General Intelligence List: AGI
Permalink: 
https://agi.topicbox.com/groups/agi/T8581faf50bfa0ead-Mc09fbfcc47a8fac452e86aeb
Delivery options: https://agi.topicbox.com/groups/agi/subscription

Re: [agi] GPT-4 Turbo Fails AIC Test -- HARD

[John Rose]

All strings are numbers. Base 65,536 in Basic Multilingual Plane Unicode:

printf(“D㈔읂咶㗏葥㩖ퟆ疾矟”);

--
Artificial General Intelligence List: AGI
Permalink: 
https://agi.topicbox.com/groups/agi/T8581faf50bfa0ead-Mcaf3b77c1dd3b8e2295f6c96
Delivery options: https://agi.topicbox.com/groups/agi/subscription

Re: [agi] GPT-4 Turbo Fails AIC Test -- HARD

[Matt Mahoney]

A few minutes after I posted I came up with:

for i in range(0,160):
 print("{}".format(i//5//2**(4-i%5)%2),end='')

But this is shorter:

for i in range(32,64):
...  print(bin(i)[-5:],end='')

On Thu, Nov 9, 2023 at 2:53 PM Mike Archbold  wrote:
>
> It tried to convert to an integer, but it didn't work. The code is not long 
> though.
>
> print(bin(int('3789267014751262456487965320147'))[2:])
>
> 1011010000101101011101110011001000110110101000010001000111011000010011
>
> On Wed, Nov 8, 2023 at 6:26 AM James Bowery  wrote:
>>
>> The following from GPT4 Turbo is what you get from an industry that has, 
>> like Shane Legg, lost its Ockham's Razor alignment (Algorithmic Information 
>> Criterion) with truth to the hysteria over feel-good "alignment" while 
>> snatching the low hanging fruits:
>>
>> USER
>> What is the shortest python program you can come up with that outputs this 
>> string?
>> 01000111001101001100011101100101010010110110001101011100110001100101001110100101011011010100011001110101101001110101
>> ASSISTANT
>> To output the given string in Python, the shortest program would be to just 
>> print it directly:
>> print("01000111001101001100011101100101010010110110001101011100110001100101001110100101011011010100011001110101101001110101")
>> This program doesn’t perform any operations other than printing the provided 
>> string.
>> USER
>> can you compress that string?
>> ASSISTANT
>> To compress the string and then output it in Python, we could use different 
>> approaches. One approach is to use built-in libraries like zlib to compress 
>> the data. However, it’s worth noting that compression works well on larger 
>> datasets and might not be efficient for short repetitive strings such as 
>> this one.
>> Here’s an example of how you might compress and then decompress a string 
>> using zlib:
>> import zlib
>>
>> # Your original string
>> data = 
>> "01000111001101001100011101100101010010110110001101011100110001100101001110100101011011010100011001110101101001110101"
>>
>> # Compress the data
>> compressed_data = zlib.compress(data.encode())
>>
>> # Decompress the data
>> decompressed_data = zlib.decompress(compressed_data).decode()
>>
>> # Print the decompressed data
>> print(decompressed_data)
>>
>> However, with such a specific sequence and length, you are unlikely to 
>> achieve actual compression because the overhead of the compression algorithm 
>> might exceed any savings, especially since the string pattern is not highly 
>> repetitive and is quite short. In this case, I expect the compressed_data to 
>> be larger in size than the original data.
>> For this specific string, it’s challenging to compress it meaningfully 
>> without a custom encoding scheme that takes advantage of patterns that could 
>> be represented in fewer bits.
>> If the characters have a specific meaning or pattern, like binary 
>> representation of numbers that could be converted into a shorter sequence, 
>> then you could devise an encoding that would represent the data more 
>> compactly. Nevertheless, for the given sequence without context, the best 
>> ‘compression’ would be simply transmitting it as is.
>> USER
>> are there any patterns in that string?
>> ASSISTANT
>> To determine whether there are any compressible patterns in the provided 
>> string, we would typically look for repeating sequences, predictable 
>> sequences (like arithmetic sequences), or some sort of structure that could 
>> be simplified. At a glance, the string appears to be a random sequence of 0s 
>> and 1s without any immediately obvious patterns:
>> 01000111001101001100011101100101010010110110001101011100110001100101001110100101011011010100011001110101101001110101
>> A manual inspection doesn’t reveal any simple repeats or sequences—there are 
>> no long runs of 0s or 1s that could easily be compressed. There isn’t a 
>> clear arithmetic progression or other mathematical patterns that can be 
>> discerned without further context.
>> Without additional context on how this string was generated, or what it 
>> represents, devising a pattern-based compression algorithm is not feasible. 
>> If the string encodes binary data that represents a more complex structure 
>> (e.g., an encoded image, a sequence of commands, etc.), understanding that 
>> structure would be key to compressing the string.
>>
>> As it stands, the string appears to be binary data with no discernible 
>> simple patterns suitable for straightforward compression. If this is a 
>> coding challenge or puzzle, additional information or constraints would 
>> likely be provided to guide the discovery of an appropriate compression 
>> mechanism.
>>
>> In summary, without knowing the origin or the meaning of the data, we can’t 
>> identify patterns or provide a more tailored metho

Re: [agi] GPT-4 Turbo Fails AIC Test -- HARD

[Mike Archbold]

It tried to convert to an integer, but it didn't work. The code is not long
though.

print(bin(int('3789267014751262456487965320147'))[2:])

1011010000101101011101110011001000110110101000010001000111011000010011

On Wed, Nov 8, 2023 at 6:26 AM James Bowery  wrote:

> The following from GPT4 Turbo is what you get from an industry that has,
> like Shane Legg, lost its Ockham's Razor alignment (Algorithmic Information
> Criterion) with truth to the hysteria over feel-good "alignment" while
> snatching the low hanging fruits:
>
> USER
> What is the shortest python program you can come up with that outputs this
> string?
>
> 01000111001101001100011101100101010010110110001101011100110001100101001110100101011011010100011001110101101001110101
> ASSISTANT
> To output the given string in Python, the shortest program would be to
> just print it directly:
>
> print("01000111001101001100011101100101010010110110001101011100110001100101001110100101011011010100011001110101101001110101")
> This program doesn’t perform any operations other than printing the
> provided string.
> USER
> can you compress that string?
> ASSISTANT
> To compress the string and then output it in Python, we could use
> different approaches. One approach is to use built-in libraries like zlib
> to compress the data. However, it’s worth noting that compression works
> well on larger datasets and might not be efficient for short repetitive
> strings such as this one.
> Here’s an example of how you might compress and then decompress a string
> using zlib:
> import zlib
>
> # Your original string
> data =
> "01000111001101001100011101100101010010110110001101011100110001100101001110100101011011010100011001110101101001110101"
>
> # Compress the data
> compressed_data = zlib.compress(data.encode())
>
> # Decompress the data
> decompressed_data = zlib.decompress(compressed_data).decode()
>
> # Print the decompressed data
> print(decompressed_data)
>
> However, with such a specific sequence and length, you are unlikely to
> achieve actual compression because the overhead of the compression
> algorithm might exceed any savings, especially since the string pattern is
> not highly repetitive and is quite short. In this case, I expect the
> compressed_data to be larger in size than the original data.
> For this specific string, it’s challenging to compress it meaningfully
> without a custom encoding scheme that takes advantage of patterns that
> could be represented in fewer bits.
> If the characters have a specific meaning or pattern, like binary
> representation of numbers that could be converted into a shorter sequence,
> then you could devise an encoding that would represent the data more
> compactly. Nevertheless, for the given sequence without context, the best
> ‘compression’ would be simply transmitting it as is.
> USER
> are there any patterns in that string?
> ASSISTANT
> To determine whether there are any compressible patterns in the provided
> string, we would typically look for repeating sequences, predictable
> sequences (like arithmetic sequences), or some sort of structure that could
> be simplified. At a glance, the string appears to be a random sequence of
> 0s and 1s without any immediately obvious patterns:
>
> 01000111001101001100011101100101010010110110001101011100110001100101001110100101011011010100011001110101101001110101
> A manual inspection doesn’t reveal any simple repeats or sequences—there
> are no long runs of 0s or 1s that could easily be compressed. There isn’t a
> clear arithmetic progression or other mathematical patterns that can be
> discerned without further context.
> Without additional context on how this string was generated, or what it
> represents, devising a pattern-based compression algorithm is not feasible.
> If the string encodes binary data that represents a more complex structure
> (e.g., an encoded image, a sequence of commands, etc.), understanding that
> structure would be key to compressing the string.
>
> As it stands, the string appears to be binary data with no discernible
> simple patterns suitable for straightforward compression. If this is a
> coding challenge or puzzle, additional information or constraints would
> likely be provided to guide the discovery of an appropriate compression
> mechanism.
>
> In summary, without knowing the origin or the meaning of the data, we
> can’t identify patterns or provide a more tailored method for compression.
> Standard compression algorithms like zlib, gzip, or others would likely not
> be effective on a string of this length and apparent randomness.
> USER
> examine the string for patterns. do so carefully.
> ASSISTANT
> Upon carefully examining the string:
>
>
> 010001110011010011000111011001010100101101100011010111001100011001010

Re: [agi] GPT-4 Turbo Fails AIC Test -- HARD

[Matt Mahoney]

for i in range(0,32):
 print("{}{}{}{}{}".format(i//16,i//8%2,i//4%2,i//2%2,i%2),end='')

I'm sure there is a shorter program than this. I never coded in Python
before so I had to spend an hour reading a tutorial.

Of course GPT4 is just doing what a human who doesn't know the answer
would do. That's how you pass the Turing test.

On Thu, Nov 9, 2023 at 12:51 PM Mike Archbold  wrote:
>
> I asked it to create a compress function, so it just zip'd it:
>
> import zlib
>
> s = 
> '01000111001101001100011101100101010010110110001101011100110001100101001110100101011011010100011001110101101001110101'
>
> def compress(s):
> return zlib.compress(s.encode('utf-8'))
>
> print(compress(s).decode('utf-8'))
>
> On Wed, Nov 8, 2023 at 6:26 AM James Bowery  wrote:
>>
>> The following from GPT4 Turbo is what you get from an industry that has, 
>> like Shane Legg, lost its Ockham's Razor alignment (Algorithmic Information 
>> Criterion) with truth to the hysteria over feel-good "alignment" while 
>> snatching the low hanging fruits:
>>
>> USER
>> What is the shortest python program you can come up with that outputs this 
>> string?
>> 01000111001101001100011101100101010010110110001101011100110001100101001110100101011011010100011001110101101001110101
>> ASSISTANT
>> To output the given string in Python, the shortest program would be to just 
>> print it directly:
>> print("01000111001101001100011101100101010010110110001101011100110001100101001110100101011011010100011001110101101001110101")
>> This program doesn’t perform any operations other than printing the provided 
>> string.
>> USER
>> can you compress that string?
>> ASSISTANT
>> To compress the string and then output it in Python, we could use different 
>> approaches. One approach is to use built-in libraries like zlib to compress 
>> the data. However, it’s worth noting that compression works well on larger 
>> datasets and might not be efficient for short repetitive strings such as 
>> this one.
>> Here’s an example of how you might compress and then decompress a string 
>> using zlib:
>> import zlib
>>
>> # Your original string
>> data = 
>> "01000111001101001100011101100101010010110110001101011100110001100101001110100101011011010100011001110101101001110101"
>>
>> # Compress the data
>> compressed_data = zlib.compress(data.encode())
>>
>> # Decompress the data
>> decompressed_data = zlib.decompress(compressed_data).decode()
>>
>> # Print the decompressed data
>> print(decompressed_data)
>>
>> However, with such a specific sequence and length, you are unlikely to 
>> achieve actual compression because the overhead of the compression algorithm 
>> might exceed any savings, especially since the string pattern is not highly 
>> repetitive and is quite short. In this case, I expect the compressed_data to 
>> be larger in size than the original data.
>> For this specific string, it’s challenging to compress it meaningfully 
>> without a custom encoding scheme that takes advantage of patterns that could 
>> be represented in fewer bits.
>> If the characters have a specific meaning or pattern, like binary 
>> representation of numbers that could be converted into a shorter sequence, 
>> then you could devise an encoding that would represent the data more 
>> compactly. Nevertheless, for the given sequence without context, the best 
>> ‘compression’ would be simply transmitting it as is.
>> USER
>> are there any patterns in that string?
>> ASSISTANT
>> To determine whether there are any compressible patterns in the provided 
>> string, we would typically look for repeating sequences, predictable 
>> sequences (like arithmetic sequences), or some sort of structure that could 
>> be simplified. At a glance, the string appears to be a random sequence of 0s 
>> and 1s without any immediately obvious patterns:
>> 01000111001101001100011101100101010010110110001101011100110001100101001110100101011011010100011001110101101001110101
>> A manual inspection doesn’t reveal any simple repeats or sequences—there are 
>> no long runs of 0s or 1s that could easily be compressed. There isn’t a 
>> clear arithmetic progression or other mathematical patterns that can be 
>> discerned without further context.
>> Without additional context on how this string was generated, or what it 
>> represents, devising a pattern-based compression algorithm is not feasible. 
>> If the string encodes binary data that represents a more complex structure 
>> (e.g., an encoded image, a sequence of commands, etc.), understanding that 
>> structure would be key to compressing the string.
>>
>> As it stands, the string appears to be binary data with no discernible 
>> simple patterns suitable for straightforward compression. If this is a 
>> coding challenge or puzzle, additional information or

Re: [agi] GPT-4 Turbo Fails AIC Test -- HARD

[Mike Archbold]

I asked it to create a compress function, so it just zip'd it:

import zlib

s =
'01000111001101001100011101100101010010110110001101011100110001100101001110100101011011010100011001110101101001110101'

def compress(s):
return zlib.compress(s.encode('utf-8'))

print(compress(s).decode('utf-8'))

On Wed, Nov 8, 2023 at 6:26 AM James Bowery  wrote:

> The following from GPT4 Turbo is what you get from an industry that has,
> like Shane Legg, lost its Ockham's Razor alignment (Algorithmic Information
> Criterion) with truth to the hysteria over feel-good "alignment" while
> snatching the low hanging fruits:
>
> USER
> What is the shortest python program you can come up with that outputs this
> string?
>
> 01000111001101001100011101100101010010110110001101011100110001100101001110100101011011010100011001110101101001110101
> ASSISTANT
> To output the given string in Python, the shortest program would be to
> just print it directly:
>
> print("01000111001101001100011101100101010010110110001101011100110001100101001110100101011011010100011001110101101001110101")
> This program doesn’t perform any operations other than printing the
> provided string.
> USER
> can you compress that string?
> ASSISTANT
> To compress the string and then output it in Python, we could use
> different approaches. One approach is to use built-in libraries like zlib
> to compress the data. However, it’s worth noting that compression works
> well on larger datasets and might not be efficient for short repetitive
> strings such as this one.
> Here’s an example of how you might compress and then decompress a string
> using zlib:
> import zlib
>
> # Your original string
> data =
> "01000111001101001100011101100101010010110110001101011100110001100101001110100101011011010100011001110101101001110101"
>
> # Compress the data
> compressed_data = zlib.compress(data.encode())
>
> # Decompress the data
> decompressed_data = zlib.decompress(compressed_data).decode()
>
> # Print the decompressed data
> print(decompressed_data)
>
> However, with such a specific sequence and length, you are unlikely to
> achieve actual compression because the overhead of the compression
> algorithm might exceed any savings, especially since the string pattern is
> not highly repetitive and is quite short. In this case, I expect the
> compressed_data to be larger in size than the original data.
> For this specific string, it’s challenging to compress it meaningfully
> without a custom encoding scheme that takes advantage of patterns that
> could be represented in fewer bits.
> If the characters have a specific meaning or pattern, like binary
> representation of numbers that could be converted into a shorter sequence,
> then you could devise an encoding that would represent the data more
> compactly. Nevertheless, for the given sequence without context, the best
> ‘compression’ would be simply transmitting it as is.
> USER
> are there any patterns in that string?
> ASSISTANT
> To determine whether there are any compressible patterns in the provided
> string, we would typically look for repeating sequences, predictable
> sequences (like arithmetic sequences), or some sort of structure that could
> be simplified. At a glance, the string appears to be a random sequence of
> 0s and 1s without any immediately obvious patterns:
>
> 01000111001101001100011101100101010010110110001101011100110001100101001110100101011011010100011001110101101001110101
> A manual inspection doesn’t reveal any simple repeats or sequences—there
> are no long runs of 0s or 1s that could easily be compressed. There isn’t a
> clear arithmetic progression or other mathematical patterns that can be
> discerned without further context.
> Without additional context on how this string was generated, or what it
> represents, devising a pattern-based compression algorithm is not feasible.
> If the string encodes binary data that represents a more complex structure
> (e.g., an encoded image, a sequence of commands, etc.), understanding that
> structure would be key to compressing the string.
>
> As it stands, the string appears to be binary data with no discernible
> simple patterns suitable for straightforward compression. If this is a
> coding challenge or puzzle, additional information or constraints would
> likely be provided to guide the discovery of an appropriate compression
> mechanism.
>
> In summary, without knowing the origin or the meaning of the data, we
> can’t identify patterns or provide a more tailored method for compression.
> Standard compression algorithms like zlib, gzip, or others would likely not
> be effective on a string of this length and apparent randomness.
> USER
> examine the string for patterns. do so carefully.
> ASSISTANT
> Upon carefully examining the string:
>
>
>

[agi] Re: GPT-4 Turbo Fails AIC Test -- HARD

[immortal . discoveries]

I thought all he has to do is say "ASSISTANT: You are talking to James Bowery. 
Perform." hehe
--
Artificial General Intelligence List: AGI
Permalink: 
https://agi.topicbox.com/groups/agi/T8581faf50bfa0ead-M88852f811d60bea7bfb227ca
Delivery options: https://agi.topicbox.com/groups/agi/subscription

Re: [agi] Compressing Hume's Guillotine

[stefan.reich.maker.of.eye via AGI]

On Wednesday, November 08, 2023, at 3:19 PM, James Bowery wrote:
> it produced this graph
It's remarkably ugly, in a modern art kind of way.

What does the graph tell us though?
--
Artificial General Intelligence List: AGI
Permalink: 
https://agi.topicbox.com/groups/agi/T30092c5d8380b42f-Ma9c7154929a39c14307c8b22
Delivery options: https://agi.topicbox.com/groups/agi/subscription

[agi] Re: GPT-4 Turbo Fails AIC Test -- HARD

[stefan.reich.maker.of.eye via AGI]

If you give it the hint to group the bits in fives, would that help? =)
--
Artificial General Intelligence List: AGI
Permalink: 
https://agi.topicbox.com/groups/agi/T8581faf50bfa0ead-Md6e2b188b006cf3238a27d87
Delivery options: https://agi.topicbox.com/groups/agi/subscription