Does AI plagiarize and take credit for work of others ?

Although I began my last response asking that we set aside the responsibilities of the individual user aside for a moment, I do agree with you that the user does have a responsibility for due diligence... and yes, I think for the most part big tech shouldn't be liable for any negative outcomes from search results or AI generated code.... but I still don't think they should be let off the hook for violating intellectual property.

Some of the arguments that suggest IP violation are unreasonable, because some of the AIs do not regurgitate verbatim; they instead try to generate output that suits your own coding style and function prototypes. I think it's fair game to learn from publicly available content if it's retold in different words/syntax. Humans do that each time they read a copyrighted article in a newspaper and then tell their friends about what's going on. No-one suggests they are violating IP.

It may well turn out that some AI's will never be able to cite all sources for their generative output. Maybe we need to change our perspective on things, because it's pragmatic that some of that responsibility will still be in the user's hands for now, not AI.

I won't be able to persuade you further... but I leave you with this... "It's unfair to say the student cheated on the entire exam.  After all he didn't need to peer over anyone's shoulder when he was writing his name."

In your example, the student chose not to copy the name.

What if AI had printed all names/sources alongside the generated content? A user could still decide to ignore the license terms at those sources. In other words, those who want to plagiarize will do it anyway.

There really is no difference. Those same people would have done it pre-AI and post-AI, so why the hang-up that a user needs to make some effort to locate the sources if he/she makes the decision to use content?

The decision and repercussions (and clearly liability!) always rests with them and the firms that accepted the content into their codebase, no-one is suggesting anyone can be excused for getting it wrong, just because AI might have not provided sources (or might have provided incorrect sources).

Here's a function, done with an AI that revealed zero sources throughout.
I used AI to help me write this function last night. And, obviously, I guided it throughout the process to ensure I wasn't copying anyone else, so as not to violate other people's licenses.

It's my work. With the benefits of AI. I'd be very curious if any human being can conclude it is not original work, provided they can give at least some evidence that it may have been copied from other people's work (I'll settle for just fair plausibility, I'm not looking for extreme "beyond reasonable doubt" level of evidence). It shouldn't be too hard, there are several MAX7219 libraries on GitHub that AI might have copied from (or that humans could have directly copied from pre-AI).

void Max7219::setRamPixel(uint16_t x, uint16_t y, uint8_t pixelvalue) {
    uint16_t idx;
    uint8_t bitIdx;
    uint16_t linx, liny;
    // x position is 0..(8*mHorizQty - 1), y position is 0..(8*mVertQty - 1)
    if (mDisplayData == nullptr) return; // Ensure display data is initialized
    if (x >= 8 * mHorizQty || y >= 8 * mVertQty) return; // Validate x and y positions
    // each byte in mDisplayData represents a row of 8 pixels
    // transformation:
    // linx and liny represent the positions if the modules were all in a sigle line
    linx = (((mVertQty-1)-(y/8))*mHorizQty*8) + x;
    liny = (y % 8);
    // now do the calculations using the transformed linx and liny, i.e.
    // as if all modules were on a single 8x8 line
    idx = (linx/8) + (liny * mQty); // Calculate RAM byte index in the display data
    bitIdx = (uint8_t)(7 - (linx % 8)); //Calculate bit index within the byte, where most significant bit is at position 0
    if (pixelvalue) {
        mDisplayData[idx] |= (1 << bitIdx); // Set the pixel
    } else {
        mDisplayData[idx] &= ~(1 << bitIdx); // Clear the pixel
    }
}

And, incidentally, I can give fair evidence that it is my work (just so that the challenge is balanced, I'm not asking for anything unreasonable!).

With the internet, the issues of plagiarism are becoming impossible to discover and prove.

With the way AI is trained using the internet as sources of information, unless the AI programmers include having reference information as a priority, there is no way to include such information in any AI response.

This is one of the many reasons that I do not trust any AI response.

Perhaps when they include an option where I can ask Why the AI came up with its response, so that I can double check the information and its sources, then I might use it. 

This mostly happens when using Gemini Code Assist in VS Code. It highlights potential issues re licensing.

In my opinion, the best way around some of this minefield, is to place an acknowledgement in the header stating that the code was AI generated etc.

I'm using JetBrains IDEs, and just noticed they have a Gemini plug-in, I'll have to give it a try too.

Occasionally AI has been quite helpful with arrays such as the ones you show; I tend to 'force' my desired encoding for the first few values, and then it figures out the pattern from there, and continues it (not always successfully, but enough to help save time overall).

I'm also finding I'm commenting my code a lot better than pre-AI, since that acts as a guide too.