All types of ambiguities in NLP

Natural language can be open to multiple interpretations, creating challenges for computers trying to understand human input. Ambiguities arise when sentences can be interpreted in different ways due to context, grammar, or word meanings.

In this article, we will explore the different types of ambiguities commonly found in Natural Language Processing (NLP).

Part of Speech (POS) Tagging Ambiguity

POS tagging classifies words as nouns, verbs, adjectives, etc. The same word can have multiple parts of speech depending on sentence context ?

import nltk
from nltk import word_tokenize, pos_tag

# Download required NLTK data (run once)
# nltk.download('punkt')
# nltk.download('averaged_perceptron_tagger')

sentences = [
    "I need to mail my friend the files.",  # mail as verb
    "I need to find the mail that was sent to me."  # mail as noun
]

for sentence in sentences:
    tokens = word_tokenize(sentence)
    pos_tags = pos_tag(tokens)
    
    for word, tag in pos_tags:
        if word.lower() == "mail":
            print(f"'{word}' is tagged as: {tag}")

'mail' is tagged as: VB
'mail' is tagged as: NN

Structural Ambiguity

Structural ambiguity occurs when the same sentence can be parsed differently, leading to multiple interpretations ?

Scope Ambiguity

Scope ambiguity occurs with quantifiers like "all", "every", "some", where the scope of quantification is unclear ?

sentence = "All students learn a programming language"

interpretations = {
    "Interpretation 1": "All students learn the SAME programming language (e.g., Python)",
    "Interpretation 2": "Each student learns SOME programming language (could be different)"
}

print("Sentence:", sentence)
print("\nPossible meanings:")
for key, value in interpretations.items():
    print(f"{key}: {value}")

Sentence: All students learn a programming language

Possible meanings:
Interpretation 1: All students learn the SAME programming language (e.g., Python)
Interpretation 2: Each student learns SOME programming language (could be different)

Lexical Ambiguity

Lexical ambiguity occurs when words have multiple meanings. There are two main types:

Polysemy

Related meanings of the same word ?

polysemy_examples = {
    "bank": ["financial institution", "river edge"],
    "foot": ["body part", "base of mountain"],
    "head": ["body part", "leader", "top of page"]
}

print("Polysemy Examples (related meanings):")
for word, meanings in polysemy_examples.items():
    print(f"'{word}': {', '.join(meanings)}")

Polysemy Examples (related meanings):
'bank': financial institution, river edge
'foot': body part, base of mountain
'head': body part, leader, top of page

Homonymy

Unrelated meanings with same spelling/pronunciation ?

homonymy_examples = {
    "bass": ["musical instrument", "type of fish"],
    "bark": ["dog sound", "tree covering"],
    "bat": ["flying animal", "sports equipment"]
}

print("Homonymy Examples (unrelated meanings):")
for word, meanings in homonymy_examples.items():
    print(f"'{word}': {', '.join(meanings)}")
    
print("\nPronunciation-based homonyms:")
pronunciation_pairs = [
    ("horse", "hoarse"),
    ("there", "their"),
    ("to", "too", "two")
]

for pair in pronunciation_pairs:
    print(f"{' / '.join(pair)} - same sound, different meanings")

Homonymy Examples (unrelated meanings):
'bass': musical instrument, type of fish
'bark': dog sound, tree covering
'bat': flying animal, sports equipment

Pronunciation-based homonyms:
horse / hoarse - same sound, different meanings
there / their - same sound, different meanings
to / too / two - same sound, different meanings

Semantic Ambiguity

Semantic ambiguity occurs when sentences can have multiple meanings based on context or grouping ?

sentence = "He ate the burnt lasagna and pie"

interpretations = [
    "Only the lasagna was burnt (burnt modifies lasagna only)",
    "Both lasagna and pie were burnt (burnt modifies both items)"
]

print("Ambiguous sentence:", sentence)
print("\nPossible interpretations:")
for i, interpretation in enumerate(interpretations, 1):
    print(f"{i}. {interpretation}")

Ambiguous sentence: He ate the burnt lasagna and pie

Possible interpretations:
1. Only the lasagna was burnt (burnt modifies lasagna only)
2. Both lasagna and pie were burnt (burnt modifies both items)

Referential Ambiguity

Referential ambiguity occurs when it's unclear which object a phrase refers to ?

sentence = "I looked at Michelle with the telescope"

possible_meanings = {
    "Michelle has telescope": "Michelle was holding/carrying the telescope",
    "Speaker has telescope": "I used a telescope to look at Michelle"
}

print("Ambiguous sentence:", sentence)
print("\nWho has the telescope?")
for scenario, meaning in possible_meanings.items():
    print(f"? {scenario}: {meaning}")

Ambiguous sentence: I looked at Michelle with the telescope

Who has the telescope?
? Michelle has telescope: Michelle was holding/carrying the telescope
? Speaker has telescope: I used a telescope to look at Michelle

Anaphoric Ambiguity

Anaphoric ambiguity occurs when pronouns could refer to multiple possible antecedents ?

sentence = "Michelle told Romany that she ate the cake"

pronoun_referents = {
    "she": ["Michelle", "Romany"],
    "ambiguity": "Who ate the cake is unclear from the sentence alone"
}

print("Ambiguous sentence:", sentence)
print(f"\nPronoun 'she' could refer to:")
for person in pronoun_referents["she"]:
    print(f"? {person}")
print(f"\nProblem: {pronoun_referents['ambiguity']}")

Ambiguous sentence: Michelle told Romany that she ate the cake

Pronoun 'she' could refer to:
? Michelle
? Romany

Problem: Who ate the cake is unclear from the sentence alone

Summary of Ambiguity Types

Conclusion

Understanding linguistic ambiguities is crucial for NLP systems. These ambiguities present challenges that require context, semantic analysis, and advanced algorithms to resolve correctly in automated language processing.