Does this ChatGPT "swap" snippet do anything?

I wanted to know the extent to which ChatGPT could generate assembly language, so I gave it the following prompt:

Write an optimized ARM assembly code that bubble sorts an array.

I will not include the full output as it's rather boring and standard, but I will provide the snippets below. Ellipses indicate lines I've cut out. All comments are mine

.data
array: .word 9, 8, 7, 6, 5, 4, 3, 2, 1, 0
arrayLength = 10
...

outer_loop:
    ...

inner_loop:
    add r3, r0, r2                @@r0=0 and r2=0 on first iteration
    ldr r4, [array, r3, lsl #2]
    add r3, r3, #4
    ldr r5, [array, r3, lsl #2]

    cmp r4, r5                    @@N not set, so bgt branches on first iter
    bgt swap
    ...

swap:
    str r5, [array, r3, lsl #2]
    subs r3, r3, #4
    str r4, [array, r3, lsl #2]
    b inner_loop

...

I am trying to get into MCUs currently and have been working with. This is rather easy to understand, but if we just focus on the first iteration, it seems that we're loading 9 into r4 and 8 into r5, then putting these numbers right back into the same place in the array from which we retrieved them. At length, you can sort of see what happens by the following sequence:

• array + r3 points to the first value in the array.
• r4 holds the value 9.
• r3 increments by 4.
• array + r3 points to the second value in the array.
• r5 holds the value 8.
• branch to swap block
• we store the value in r5, which is 8, in the place array + r3 points, which is the second array slot.
• r3 decrements by 4.
• array + r3 points to the first value in the array.
• we store the value r4, which is 9, in the place array + r3 points, which is the first slot.

So my questions are: am I somehow misunderstanding the opcodes? If so, why does my intuition here fail regarding the sequence I expect to execute? Is the bot just wrong? Also, the subs in the swap block may set a flag if we go negative with our address, but ChatGPT doesn't do anything with this fact. So would a simple sub be better?

I also had a question about the logical left shift. I first assumed this had to be due to endianness but realized that doesn't quite explain it. Why is the array stored at a weird offset like that? I assume I'm missing context where this sort of stuff is normal, but I have yet to encounter this in my experience.

ChatGPT insists this sorts the array, but always with the context of what a bubble sort is. I don't know if it is actually running the code against the actual input data I feed it or else if it is just doing a sort and then telling me it used a bubble sort. For instance, I gave it the following prompt

Imagine you have the array [10,5,4,1] stored in memory and used the above code to sort this array. After running the program, what would the resultant array be?

and received the following explanation

After running the above ARM assembly code on the array [10, 5, 4, 1], the resultant sorted array would be [1, 4, 5, 10].

The bubble sort algorithm works by repeatedly swapping adjacent elements that are in the wrong order until the entire array is sorted in ascending order. In each iteration of the outer loop, the length of the unsorted portion of the array is decremented, and in each iteration of the inner loop, adjacent elements are compared and swapped if necessary. This process continues until the entire array is sorted.

The tense here is important: "the resultant array would be..."