Natural Language Processing: Foundations and Applications without Hallucination from Generative AI

Pong Yuen Lam, City University of Hong Kong · Working paper, September 2026 · Cite as: Lam, Pong Yuen (2026), “Natural Language Processing: Foundations and Applications without Hallucination from Generative AI”. Available at SSRN: https://doi.org/10.2139/ssrn.7384558.

Abstract. This research note takes readers on a visual, step-by-step journey into how AI reads the meaning behind words, not just the words themselves. Using algebra and geometry, it builds sentence similarity in five steps: contrasting keyword matching with meaning matching; representing sentences as vectors of numbers; deriving the dot product from the Pythagorean theorem; generalizing to cosine similarity via the Law of Cosines; and extending the idea from two dimensions to the hundreds used by embedding models that power modern semantic search, chatbots, and AI agents.

The note’s central payoff is a chatbot architecture without hallucination from generative AI. Large language models (LLMs) generate text word by word—the mechanism behind their fluent but sometimes fabricated answers. A system built on sentence similarity works differently: it is selective, not generative. It returns only a sentence that already exists in a verified document or says “I don’t know” when no candidate clears a similarity threshold. This differs from retrieval-augmented generation (RAG), which narrows hallucination but does not eliminate it, since the LLM still combines retrieved text with pre-trained knowledge.

By opening this black box with plain English and visuals rather than code, the note equips non-technical readers to engage critically with the AI systems they rely on: what these systems are trained on and why a system that always answers, however unrelated the question, should be treated with caution. In high-stakes fields, the AI systems worth trusting are not the ones that always have an answer, but the ones that know when to say “I don’t know.”

Introduction

“You shall know a word by the company it keeps.”

J. R. Firth, linguist, 1957.1

Have you ever wondered how a chatbot knows that “Which company designs iPhone?” is best answered by “Apple designs iPhone” — and not “I love to eat apple” or “Both Apple and Orange are fruits”? The answer is not magic. This note takes readers on a visual, step-by-step journey to see how AI reads the meaning behind words, not just the words themselves. By the end, readers will understand sentence similarity: the idea that lets us find, from a list of candidate sentences, the one with the meaning that best matches the question being asked — and how this same idea lets us restrict an AI’s response to a sentence from a fixed list, or from a specific document the user provides.2

Because the answer is “selected” from this list of candidate sentences, rather than being “generated” by a large language model (LLM), it removes any chance of hallucination — the tendency of LLMs to produce plausible-sounding but false information that is difficult for a human to verify. As of 2026, there is still “no guarantee that the text produced by an LLM accurately reflected the real world… As a result, when presented with an input prompt, the model might generate text that appeared plausible but was not rooted in reality or factual information.”3

Business leaders increasingly rely on AI tools that seem to understand what they mean, not just the words they type. This note opens that black box, using algebra and geometry so that readers can engage confidently with the systems that power modern search, chatbots, and AI agents — and understand, conceptually, what they are using and what they are getting, before relying on AI’s output to make important decisions. The research note uses plain English and visuals throughout, so no technical or programming background is needed to follow along.

The central insight of this note is that modern AI does not rely on matching words; it relies on matching meaning.4 The phrase “Is this item in stock?” can achieve a high similarity score with “Do you currently have this available?” despite sharing almost no common words. In contrast, “When does the store open?” and “When does the store close?” have a low similarity score, even though four of the five words are the same in both sentences. This capability – representing sentences as a list of numbers (vectors) – is the breakthrough that transformed natural language processing. Meaning, it turns out, has a geometry.

This note builds up the idea of sentence similarity in five steps. We begin by contrasting keyword matching with meaning matching, using simple example sentences to show how a computer can represent a sentence’s words as a list of numbers (a vector). We then develop the mathematics behind comparing two vectors, starting from the dot product and the Pythagorean theorem. Building on this, we derive cosine similarity, a single number that measures how closely two sentences match in meaning. Next, we extend this simple idea from two dimensions to hundreds, showing how it underlies the embedding models that power modern semantic search, chatbots, and AI agents. An embedding turns a word’s meaning into a list of numbers, chosen so that words with similar meanings end up with similar numbers.5 Finally, we show how this same idea can build a chatbot that never hallucinates, and why that matters for high-stakes fields such as medicine, law, and education. “For example, a system that prescribes exactly the right medications 90% of the time but confabulates in one case out of 10 is unacceptably unsafe to be used on its own.”6

For simplicity, this note refers to all such items — words, phrases, and questions alike — as “sentences.”

Foundations

Meaning of a word / sentence

For decades, search engines and early chatbots7 matched queries by looking for overlapping keywords. This approach breaks down exactly where it matters most: when a customer phrases a question in their own words rather than the company’s — as the examples above show, matching words is neither necessary nor sufficient for matching meaning.

Consider two sentences: “I am using Apple iPhone” and “Apple is a healthy fruit.” The same word, “Apple,” carries two different meanings here — a brand in the first sentence and a fruit in the second. If we use only one number in a computer to represent the word “Apple,” the computer can only capture one of its two meanings. So, if a word can have two meanings, we need two numbers to represent that word in a computer. For example, [1,1] might mean Apple as a fruit and [1,2] might mean Apple as a brand. That is, we use a list of two numbers (or two dimensions) to represent one word Apple with two meanings.

One number, one meaning. Two meanings need two numbers — and real language needs hundreds.

Representing a sentence as a list of numbers

Consider two short sentences: “Apple iPhone” and “Apple”. Counting how often each word, “Apple” and “iPhone” appears gives:

SentenceAppleiPhone
Sentence 1: “Apple iPhone”11
Sentence 2: “Apple”10

We can plot each sentence as an arrow from the origin [0, 0]: x-axis for the frequency of “Apple,” y-axis for the frequency of “iPhone” (Exhibit 1). Sentence 1 becomes [0, 0] to [1, 1] and Sentence 2 becomes [0, 0] to [1, 0]. The angle between these two arrows is 45°, and the cosine of 45° is 0.71. This cosine value — cosine similarity — is our measure of how similar two sentences are.8

Exhibit 1 Sentence 1 "Apple iPhone" at [1,1] and Sentence 2 "Apple" at [1,0], plotted as arrows from the origin, 45 degrees apart, cosine similarity 0.71. Frequency of “Apple” → Frequency of “iPhone” 0 1 1 45° Sentence 1: “Apple iPhone” [1, 1] Sentence 2: “Apple” [1, 0] cos(45°) = 0.71
Exhibit 1 — Sentence vectors and cosine similarity. The two arrows are 45° apart, and the cosine of 45° equals 0.71. A single number now stands in for something as slippery as meaning.

Represent sentences from their list of numbers in two dimensions, based on word frequencies

If we add a third sentence, “Apple Apple Apple,” we will have the following table.

SentenceAppleiPhone
Sentence 1: “Apple iPhone”11
Sentence 2: “Apple”10
Sentence 3: “Apple Apple Apple”30

Sentence 3 has the list of numbers (vector) of [3, 0] — three times as long as Sentence 2’s [1, 0], but pointing in exactly the same direction (Exhibit 2).

Similarity between any two sentences depends only on the angle between them in Exhibit 2, not their length: the cosine similarity between Sentence 2 (Apple) and Sentence 3 (Apple Apple Apple) is 1, a perfect match, because repeating the same word three times does not change what a sentence means.

Exhibit 2 Sentence 2 "Apple" [1,0] and Sentence 3 "Apple Apple Apple" [3,0] point in the same direction, so their cosine similarity is 1, even though Sentence 3's arrow is three times as long. Frequency of “Apple” → Frequency of “iPhone” 45° Sentence 1: “Apple iPhone” [1, 1] Sentence 2: “Apple” [1, 0] Sentence 3: “Apple Apple Apple” [3, 0]
Exhibit 2 — Direction, not length. Sentence 2 and Sentence 3 point in exactly the same direction — the angle between them is 0°, and the cosine of 0° equals 1 — even though Sentence 3’s arrow is three times as long as Sentence 2’s. Sentence 1’s arrow, meanwhile, is 45° from both, so its cosine similarity with each of them is 0.71.

Two further cases sit at the extremes. When two sentences are identical, their vectors point in exactly the same direction, the angle between them is 0°, and cosine(0°) = 1 (Exhibit 3). When two sentences share no words at all — for example “Apple” [1, 0] and “iPhone” [0, 1] — their vectors are perpendicular, the angle is 90°, and cosine(90°) = 0: no similarity at all (Exhibit 4). Same meaning, same direction. Nothing in common, no direction in common.

Exhibit 3 Two identical sentences, both "Apple iPhone" at [1,1], point in exactly the same direction. Angle 0 degrees, cosine similarity 1. Angle = 0°, cos(0°) = 1 Sentence 1: “Apple iPhone” [1, 1] Sentence 2 (identical, overlapping)
Exhibit 3 — Identical sentences. The two arrows overlap perfectly (the red arrow is offset slightly here only so both remain visible). This is the highest possible similarity score.
Exhibit 4 Sentence "Apple" [1,0] and sentence "iPhone" [0,1] are perpendicular, 90 degrees apart, cosine similarity 0. cos(90°) = 0: no similarity at all Sentence 1: “Apple” [1, 0] Sentence 2: “iPhone” [0, 1]
Exhibit 4 — No overlap. The two sentences share no words at all and their arrows point in unrelated directions, 90° apart.

Calculate the angle between two sentences (vectors) with the dot product

The dot product is the basic mathematical operation for comparing two vectors: multiply their corresponding entries and add the results. For a vector v = [1, 2], the dot product of v with itself is:

v · v = [1, 2] · [1, 2] = 1×1 + 2×2 = 1 + 4 = 5.9

Same number, two routes. For the vector v = [1, 2], treating 1 and 2 as the two shorter sides of a right triangle gives 1² + 2² = 5 — matching v · v = 5 exactly. This is not a coincidence: the dot product of a vector with itself always equals the square of its length, precisely because of the Pythagorean theorem (Exhibit 5).10

Exhibit 5 A visual proof of the Pythagorean theorem. A 7 by 7 square, side 3 plus 4, is dissected two ways: on the left into a 4 by 4 square, a 3 by 3 square, and four 3-4-5 right triangles; on the right into the same four triangles arranged around one tilted 5 by 5 square. Both large squares have equal area, so 3 squared plus 4 squared equals 5 squared. 4 3 4 3 5 5 3² + 4² + 4(3×4/2) = 5 5² + 4(3×4/2)
Exhibit 5 — The Pythagorean theorem. Two squares of equal size, (3+4)², dissected two different ways. The left square divides into a 4×4 square, a 3×3 square, and four 3-4-5 triangles. The right square divides into a single tilted 5×5 square and the same four triangles. Since both equal (3+4)², the triangle areas cancel, leaving 3² + 4² = 5².

From Dot Product to Cosine Similarity

Unit vectors and rotation

Consider a vector of length 1 that makes an angle θ with the x-axis: u = [cos(θ), sin(θ)]. The dot product of u with itself is cos²(θ) + sin²(θ), which always equals 1 — again by the Pythagorean theorem,11 since cos(θ) and sin(θ) are the two shorter sides of a right triangle with hypotenuse 1.

New to the cosine difference identity? See a plain-English introduction to it before continuing.

Now suppose two unit vectors, u and v, sit at angles β and α respectively, so that the angle between them is θ = β − α (Exhibit 6). Their dot product works out to:

u · v = cos(β)cos(α) + sin(β)sin(α) = cos(β − α) = cos(θ).

This is the cosine difference identity,12 and it confirms that the dot product of two unit vectors equals the cosine of the angle between them.

Exhibit 6 Two unit vectors u and v at angles beta and alpha from the x-axis. The angle between them is theta, equal to beta minus alpha. Their dot product equals cosine of theta. β = α + θ β α θ u = [cos β, sin β] v = [cos α, sin α]
Exhibit 6 — Unit vectors and the cosine difference identity. Because both vectors have length 1, their dot product reduces to cos(β)cos(α) + sin(β)sin(α), which equals cos(θ) — the geometric fact that cosine similarity relies on.

Generalizing beyond unit vectors: the Law of Cosines

New to the Law of Cosines? See a plain-English introduction to it before continuing.

Real sentence vectors are rarely unit length, so we need a general formula. Consider two vectors, b and c, and the vector connecting their tips, a = c − b. The Law of Cosines states that:

|a|² = |b|² + |c|² − 2|b||c|cos(θ)

Expanding |a|² = |c − b|² and cancelling matching terms on both sides leaves 2|b||c|cos(θ) equal to twice the dot product of b and c, so that:

cos(θ) = (b · c) / (|b| × |c|)

This is the cosine similarity formula used throughout modern AI systems: the dot product of two vectors, divided by the product of their lengths.13 It generalizes the simple 45°, 90°, and 0° examples above to any pair of vectors, of any length, in any number of dimensions.

From Two Words to Real Language: Embeddings at Scale

Our examples so far used only two dimensions — the frequency of “Apple” and the frequency of “iPhone.” Two numbers are a toy example. Hundreds are a language. Modern embedding models convert an entire sentence into a vector of several hundred numbers instead of just two or three, trained so that sentences with similar meaning point in similar directions and cosine similarity between them is high, exactly as in our two-dimensional examples.14

This capability comes with two limits. First, an embedding model’s sense of “similar” reflects the data it was trained on; it may perform unevenly on industries or writing styles it has seen less of. Second, unlike our two-number “Apple/iPhone” example, no individual one of a several-hundred-number vector can be inspected and explained on its own — the meaning lives in the pattern across all of them together, not in any single entry.

Avoiding Hallucination: A Practical Payoff

A chatbot that never hallucinates

This mechanism underlies a simple but useful business application: a question-and-answer chatbot. It compares a user’s question to each candidate sentence in a reference list, ranks them by how close they are in meaning, and returns the closest match as the answer — but only if its similarity score clears a preset threshold, for example, 0.5. Asking “Which company designs iPhone?” correctly returns “Apple designs iPhone” as the best match, since its similarity score is higher than the threshold and is the highest among three sentences.

User question: “Which company designs iPhone?”

Candidate sentence in the reference listSimilarity score
1. “I love to eat apple”0.43
2. “Apple designs iPhone”0.85
3. “Both Apple and Orange are fruits”0.45

Asking an unrelated question, such as “Where is Hong Kong?” correctly returns no answer at all, rather than guessing, because no candidate sentence’s score reaches the threshold of 0.5. This same mechanism, applied at far larger scale, is what allows a chatbot or an AI agent to route a query to the right knowledge, retrieve the right document, or recognize that a request falls outside what it can help with.

This threshold is not a minor implementation detail — it is what stands between this approach and a well-known failure mode called hallucination, where an AI system produces a fluent, confident-sounding answer that is nonetheless wrong or entirely invented. A system built on cosine similarity can be made to recognize the limits of its own knowledge: if no candidate sentence clears the similarity threshold, it says so, rather than forcing a plausible-sounding guess. It is a system built to say nothing rather than say something wrong. For business leaders deploying AI tools, this is a practical takeaway: a well-designed system should be able to say “I don’t know” — and a system that always produces an answer, no matter how unrelated the question, is one to be wary of.

Why not just build an FAQ?

Traditionally, a frequently asked questions (FAQ) list pairs each question with a ready-made answer. Applying this to the example above, we would not simply store three plain sentences; instead, someone would need to manually create and check a list of questions and answers to ensure accuracy. For example:

FAQ 1: What do you love to eat?
Answer 1: I love to eat apple.

FAQ 2: Which company designs iPhone?
Answer 2: Apple designs iPhone.

FAQ 3: Are both Apple and Orange fruits?
Answer 3: Both Apple and Orange are fruits.

The author proposes skipping this manual work. Instead, we can go straight to the three plain sentences and calculate their similarity scores against the user’s question to find the most similar sentence — in other words, the best answer to the user’s question. This sentence-similarity approach is very different from how a generative AI system like ChatGPT actually produces an answer, as the next section shows.

How generative AI is different

Generative AI systems such as ChatGPT are trained on large volumes of data and then use a transformer architecture15 to generate text one word at a time, as in the following example. The transformer architecture itself is beyond the scope of this research note and is left for a future note.

I wake
I wake up
I wake up in
I wake up in the
I wake up in the middle
I wake up in the middle of
I wake up in the middle of the
I wake up in the middle of the night

Similarly, if the user enters “What is the capital of China?”, ChatGPT will generate and give:

What is the capital of China? Beijing

This word-by-word process is powerful and flexible, but it also means ChatGPT can generate fluent, confident-sounding text even when it does not actually know the correct answer — which is exactly how hallucination happens. It isn’t retrieving an answer. It’s predicting one, word by word — and it can do that just as confidently when it’s wrong.

Why hallucination happens, and how to avoid it

We saw above that a system built on sentence similarity avoids hallucination simply by refusing to guess when no candidate sentence is similar enough. It is worth understanding why hallucination happens in the first place, so readers can recognize the risk in other AI tools they use.

First, a large language model (LLM) has a training cutoff date, so it cannot know about events or facts after that date. Second, even when an LLM searches the internet for additional information, what it finds may still be incomplete or unreliable. Third, ChatGPT’s underlying approach is fundamentally probabilistic: it generates an answer by predicting the next most likely word, based on a probability distribution shaped by a parameter called temperature, which the user can set. If, instead, a user provides a specific list of sentences — or simply a document for the AI to read and break into sentences — hallucination can be avoided entirely. The sentence-similarity approach described above will only ever return one of the provided sentences, or tell the user that no answer is available if no sentence’s similarity score exceeds a threshold, such as 0.5, set by the user.

When a user provides information for an LLM to read before it generates an answer, this is known as retrieval-augmented generation (RAG).16 The LLM reads the information the user provides and combines it with what it learned during training to produce an answer — there is no guarantee that this answer is correct, and it is not easy for the user to verify its correctness. The answer a user receives from RAG is still “generated” by the LLM. “Certain legal research providers have touted methods such as retrieval-augmented generation (RAG) as ‘eliminating’ or ‘avoid[ing]’ hallucinations, or guaranteeing ‘hallucination-free’ legal citations.”17 Researchers at Stanford found that AI research tools made by LexisNexis (Lexis+ AI) and Thomson Reuters (Westlaw AI-Assisted Research and Ask Practical Law AI) each hallucinated between 17% and 33% of the time.18

Retrieval narrows the guesswork. It does not remove it. For critical applications such as medicine, law, and education, we cannot afford mistakes. In healthcare, for example, side effects are already checked and documented by pharmaceutical companies in verified, approved materials. Doctors and nurses do not need an LLM to “generate” an answer at all — they can simply run any question they have against the sentences in that verified, approved document using sentence similarity. Finally, there is no reason to limit the system to returning only the single most similar sentence; it could instead return, say, the top three most similar sentences. The system could even let users choose how many sentences before or after a match to display, or show the entire paragraph in which that sentence appears.

Conclusion

This note opens with the idea that a word is known by the company it keeps.19 Having worked through vectors, the dot product, the Pythagorean theorem, and cosine similarity, the mechanism behind “AI understanding meaning” looks less like magic and more like geometry. The mechanics are simple. The scale is not.

Three ideas carry this argument. Representing sentences as vectors turns meaning into something that can be computed mathematically. The dot product and the Pythagorean theorem give us the tools to measure the angle and the length of these vectors. Cosine similarity combines them into a single, general-purpose number for comparing any two pieces of text, regardless of length or exact wording.

The same arithmetic that separates “Apple iPhone” from “Apple” at a 45° angle also powers the semantic search, chatbots, and AI agents that businesses increasingly rely on. Understanding this does not require becoming a data scientist. It equips readers, instead, to ask sharper questions about the AI systems they use: what the system was trained on, why it sometimes retrieves a surprising match, and where its judgment about “similar enough” may not match their own. That is the payoff of opening this black box: not technical mastery, but the ability to engage with AI’s capabilities, and its limits, from a position of understanding.

This same geometry also delivers a very practical payoff: a chatbot that never hallucinates — and the reason lies in a distinction worth making explicit. A chatbot built on sentence similarity is selective, not generative: every possible answer must already exist in a document a human has previously written and verified, and the system can only select from that fixed list, never invent new text. The threshold is simply the mechanism that decides whether a candidate from that verified list is close enough to use; if nothing qualifies, the system can say “I don’t know” instead of guessing. A generative AI system, by contrast, has no such list and no equivalent circuit breaker — it produces its answer one word at a time, sampling from a probability distribution over what word is likely to come next, optimized for fluency rather than for truth. It will keep generating confident-sounding words even when it has no reliable basis for them, because fluency and correctness are separate properties, and the model only guarantees the first.

This may be the more important lesson of this note: the systems business leaders can trust are not necessarily the ones that always have an answer, but the ones that know when to say, “I don’t know.” In high-stakes fields such as medicine, being wrong is too high a price to pay. While a human should always have the final say on whether an AI’s answer is reasonable,20 that human judgment only works if the AI does not hallucinate in the first place, confusing the very judgment it is meant to support.

Endnotes

  1. J. R. Firth, “A Synopsis of Linguistic Theory, 1930–1955,” in Studies in Linguistic Analysis (Oxford: Philological Society, 1957), 11. ↩
  2. Patrick Lewis et al., “Retrieval-Augmented Generation for Knowledge-Intensive NLP Tasks,” in Advances in Neural Information Processing Systems 33, ed. H. Larochelle et al. (Red Hook, NY: Curran Associates, 2020), 9459–9474. arxiv.org/abs/2005.11401 ↩
  3. Sampsa Samila and Pascual Berrone, “OpenAI and the Large Language Model Market,” IESE Business School, Product IES941-PDF-ENG (Harvard Business Publishing, May 28, 2023), p.23. ↩
  4. Tomás Mikolov, Ilya Sutskever, Kai Chen, Greg Corrado, and Jeff Dean, “Distributed Representations of Words and Phrases and Their Compositionality,” in Advances in Neural Information Processing Systems 26, ed. C. J. C. Burges et al. (Red Hook, NY: Curran Associates, 2013), 3111–3119. papers.nips.cc ↩
  5. Dan Jurafsky and James H. Martin, “Vector Semantics and Embeddings,” in Speech and Language Processing, 3rd ed. (draft, Stanford University, n.d.), accessed July 4, 2026, web.stanford.edu/~jurafsky/slp3/6.pdf ↩
  6. Andrew McAfee, Daniel Rock, and Erik Brynjolfsson, “How to Capitalize on Generative AI,” Harvard Business Review, November–December 2023, Reprint S23061. ↩
  7. Joseph Weizenbaum, “ELIZA—A Computer Program for the Study of Natural Language Communication Between Man and Machine,” Communications of the ACM 9, no. 1 (January 1966): 36–45, doi.org/10.1145/365153.365168 ↩
  8. Gerard Salton, Andrew K. C. Wong, and Chung-Shu Yang, “A Vector Space Model for Automatic Indexing,” Communications of the ACM 18, no. 11 (November 1975): 613–620, doi.org/10.1145/361219.361220 ↩
  9. Gilbert Strang, Introduction to Linear Algebra, 5th ed. (Wellesley, MA: Wellesley-Cambridge Press; Beijing: Tsinghua University Press, 2019), 13. ↩
  10. Gilbert Strang, Introduction to Linear Algebra, 5th ed. (Wellesley, MA: Wellesley-Cambridge Press; Beijing: Tsinghua University Press, 2019), 13. ↩
  11. Euclid, Elements, Book I, Proposition 47, in Euclid: The Thirteen Books of the Elements, trans. Thomas L. Heath, 2nd ed. (New York: Dover Publications, 1956), 349–350. perseus.tufts.edu ↩
  12. Daniel Zwillinger, ed., CRC Standard Mathematical Tables and Formulas, 33rd ed. (Boca Raton, FL: CRC Press, 2018), s.v. “trigonometric addition formulas.” ↩
  13. Nils Reimers and Iryna Gurevych, “Sentence-BERT: Sentence Embeddings Using Siamese BERT-Networks,” in Proceedings of the 2019 Conference on Empirical Methods in Natural Language Processing and the 9th International Joint Conference on Natural Language Processing (EMNLP-IJCNLP) (Hong Kong: Association for Computational Linguistics, 2019), 3982–3992. ↩
  14. Nils Reimers and Iryna Gurevych, “Sentence-BERT: Sentence Embeddings Using Siamese BERT-Networks,” in Proceedings of the 2019 Conference on Empirical Methods in Natural Language Processing and the 9th International Joint Conference on Natural Language Processing (EMNLP-IJCNLP) (Hong Kong: Association for Computational Linguistics, 2019), 3982–3992. ↩
  15. Ashish Vaswani, Noam Shazeer, Niki Parmar, Jakob Uszkoreit, Llion Jones, Aidan N. Gomez, Łukasz Kaiser, and Illia Polosukhin, “Attention Is All You Need,” in Advances in Neural Information Processing Systems 30, ed. I. Guyon et al. (Red Hook, NY: Curran Associates, 2017), 5998–6008, arxiv.org/abs/1706.03762 ↩
  16. Patrick Lewis et al., “Retrieval-Augmented Generation for Knowledge-Intensive NLP Tasks,” in Advances in Neural Information Processing Systems 33, ed. H. Larochelle et al. (Red Hook, NY: Curran Associates, 2020), 9459–9474. arxiv.org/abs/2005.11401 ↩
  17. Varun Magesh, Faiz Surani, Matthew Dahl, Mirac Suzgun, Christopher D. Manning, and Daniel E. Ho, “Hallucination-Free? Assessing the Reliability of Leading AI Legal Research Tools,” Journal of Empirical Legal Studies (2025), doi.org/10.1111/jels.12413 ↩
  18. Varun Magesh, Faiz Surani, Matthew Dahl, Mirac Suzgun, Christopher D. Manning, and Daniel E. Ho, “Hallucination-Free? Assessing the Reliability of Leading AI Legal Research Tools,” Journal of Empirical Legal Studies (2025), doi.org/10.1111/jels.12413 ↩
  19. J. R. Firth, “A Synopsis of Linguistic Theory, 1930–1955,” in Studies in Linguistic Analysis (Oxford: Philological Society, 1957), 11. ↩
  20. Andrew McAfee, Daniel Rock, and Erik Brynjolfsson, “How to Capitalize on Generative AI,” Harvard Business Review, November–December 2023, Reprint S23061. ↩

← Back to Research