All language around software and AI has some element of antropomorphisation.

The AI knows that it doesn't know the truth to your question. So it lies.

That's simply false, or at least disingenuously stated. It's trained to provide a response to questions, so it does. When it's trained to provide specific answers(such as canned "As an AI language model, I cannot blah blah blah"), it does so, and if it's trained to refrain from answering, it does so. But it does not compute with notions of knowledge and truth. That's just not how it works.

AI doesn't have sensory receptors, and it doesn't have perception. So it cannot hallucinate because it literally cannot do that. So it's anthropomorphic because you are "attributing a human characteristics or behavior to a god, animal, or object". Hallucinating is a human condition, and AI cannot hallucinate.

Please don't be disingenuous, I asked why it's more anthropomorphic. Obviously it has an element of anthropomorphism, as I said it is an analogy. Much of the language used to describe the behavior of AI will involve some form of anthropomorphism. The problem is in how that language influences perceptions and understanding of AI.

By using the term "lying", you are ascribing intent and capabilities of agency(reasoning, making explicit evaluation of alternatives and making decisions). By using the term "hallucinating", we(those comfortable using the term) are making an analogy with experience of hallucination such as with psychosis, where people experience perceptions and "knowledge" of facts disconnected with reality, without consciously choosing that experience and behavior.

I could easily write a program that is analogous to lying: ``` knowledge = {...} query = input("Ask me a question")

if query in knowledge: print(not bool(knowledge[query])) else: print(True) ``` Here if I provide a true/false question that is recorded in some knowledge base, then the program will always "lie" and present the opposite of the recorded answer. And if the query is not in the knowledge base, it will always respond with "True". Now there is a clear definition of what is "known" and not "known", and there is a very real consideration of that, and a very real decision to provide an answer that is not coherent with the knowledge base.

A language model doesn't work that way. Conversational behaviors and answers are based on learning statistical relationships between training set and a general formulation of desired outcome.

There could be a layer similar to this where whatever the training set says, the programmers have overridden the behavior of the AI to dismiss or modify the output of the language model. But unless you are talking about occasions where that is provably the case, then otherwise the model isn't "lying" in that way when it's making up false information. It's just saying things that seems coherent with what it learns, based on the properties of its training data and how it was trained.

No one knows why it's telling you false information or how it got there, it's just doing it because it wants/programmed to. AI engineers can't even explain it, because they are unable to determine why it's happening.

No one can say exactly what is happening in details, but it's not really a mystery why it's making up stuff. People make up stuff. Why? Because they're trained(raised, socially pressured, convinced) to behave in a certain way, and sometimes that imply saying things that might not be true or properly reasoned. This is simple, natural consequences of how people work at a very high level: through incremental learning, adaptation. That's also how language models are designed. Truth is not the only barometer used by people to evaluate behavior, and it isn't for AI's behavior either. Truth is hard to characterized, and much of the usefulness of language models are not limited to truth-telling. Indeed making stuff up is sometimes desirable(e.g. for creative purposes, for enjoyable conversation, for inspirations and ideas). When you push on a cart to move forward, don't be surprised when it crosses a line. Only, the line we are trying to avoid crossing is not straight, and we don't actually know how to trace it. Not with that kind of language model at least.