Semantic Analysis

Semantic analysis in Natural Language Processing (NLP) aims to extract the meaning of
sentences or texts by understanding the relationships between words, phrases, and their
context. It bridges syntax and logic, allowing computers to "understand" the meaning of
text.

Why Represent Sentence Meaning?

1. Machine Understanding: Enables systems to "understand" natural language for

tasks like question answering, summarization, and translation.

2. Ambiguity Resolution: Helps disambiguate different possible meanings of a

sentence.

3. Reasoning: Facilitates logical inference and decision-making.

Representation of Sentence Meaning:

To understand a sentence, it must be transformed into a representation that captures its
semantic content. There are several methods to represent sentence meaning, focusing on
expressiveness and computational tractability.

Key Methods for Sentence Representation

The goal is to balance expressiveness and computational efficiency. Here are some
commonly used methods:

1. Logical Representations

Logical representations use formal languages like First-Order Logic (FOL) to express
meaning. These representations are compact and suitable for reasoning tasks.

Example 1: "Ravi loves music."

• Natural Language: Ravi loves music.

• FOL Representation: loves(Ravi, Music)

• This means that there exists a relationship "loves" between Ravi and Music.

Example 2: "Every student studies hard."

• Natural Language: Every student studies hard.

• FOL Representation: ∀x(Student(x) ⟹ StudiesHard(x))

• This means that for all x, if x is a student, then x studies hard.

2. Predicate-Argument Structures

Predicate-argument structures decompose sentences into predicates (verbs) and their

arguments (subjects, objects, etc.).

Example: "Priya bought a book."

• Predicate: Buy

• Arguments:

o Agent (who did it): Priya

o Object (what was bought): Book

Representation:

Buy (Agent=Priya, Object=Book)

3. Semantic Roles

Semantic roles assign labels to the functions of entities in a sentence. These roles include:

• Agent: The doer of the action.

• Patient: The receiver of the action.

• Instrument: The means by which the action is performed.

Example: "Anil sent a message via email."

• Agent: Anil

• Patient: Message

• Instrument: email

Representation:

Send (Agent=Anil, Patient=Message, Instrument=Email)

4. Frame Semantics

Frame semantics represents meaning using frames (describes a situation or event and
includes roles or slots that need to be filled with specific entities), which are conceptual
structures associated with specific words.

Example: "Mita opened the door with a key."

• Frame: "Opening"
 • Roles:

o Agent: Mita

o Instrument: Key

o Object: Door

• Representation:
Open (Agent=Mita, Instrument= Key, Object= Door)

5. Distributional Representations (Word Embeddings)

Words and sentences are represented as dense vectors in a high-dimensional space. These
vectors capture semantic similarity based on context.

Example:

• Sentences: "Ravi is reading a book" and "Ravi is studying a novel."

• Distributional vectors for "book" and "novel" will be closed in the vector space
because they often appear in similar contexts.

Example Representation

Sentences:

1. "Ravi is reading a book."

2. "Ravi is studying a novel."

• Word Embedding Representation:

o "Ravi": [0.45,0.32,−0.12,…,0.22]

o "reading": [0.18,0.67,−0.45,…,0.11]

o "book": [0.91,0.44,−0.33,…,0.09]

o "studying": [0.21,0.66,−0.47,…,0.12]

o "novel": [0.92,0.46,−0.34,…,0.08]In this space:

• The vectors for "book" and "novel" are close to each other, reflecting their semantic
similarity. (The values of word vectors in embeddings (like [0.45, 0.32, -0.12, ...]) are
learned from large text corpora during the training process of word embedding
models like Word2Vec)

• Extra (for understanding only):

 • 1. "Ravi":

• [0.45,0.32,−0.12,…,0.22] The positive value 0.45 in one dimension might represent

"proper noun-ness." The negative value −0.12 in another dimension might represent
"non-generic" usage.

6. Event and State Representations

Events represent actions, while states represent properties.

Example: "Ravi is teaching."

• Event: Teaching

• Participant: Ravi

Representation:

• Event: Teach([Agent=Ravi])

Example: "The room is clean."

• State: Clean

• Entity: Room

Representation:

• State: Clean([Entity=Room])

Example: "Reena booked a cab to the airport."

• Event: "book"

• Agent: "Reena"

• Theme: "cab"

• Destination: "airport"

Representation:

• Event: Book ([Agent= "Reena", Theme: "cab", Destination: "airport"])

Example: "Kavita attended a meeting in the conference room."

• Event: "attend"

• Agent: "Kavita"

• Theme: "meeting"
 • Location: "conference room"

Representation:

• Event: Attend ([Agent= "Kavita", Theme: "meeting", Location: " conference room "])

7. Graph-Based Representations

Semantic graphs represent entities as nodes and their relationships as edges.

Example: "Ramesh traveled to Delhi."

• Nodes:

o Ramesh

o Delhi

• Edge: Traveled (relationship between Ramesh and Delhi)

Graph:

Ramesh --(traveled to)--> Delhi

Computational Desiderata (things we want) for

Representations
For representing the meaning of sentences in computers, we need the representation to
meet certain requirements. These requirements are known as computational desiderata
(fancy term for "things we want") like the representation should be expressive,
Computationally Feasible, Support Ambiguity Resolution, and Interpretable.

Expressive

The representation should be detailed enough to capture the full meaning of a sentence,
including complex concepts like negation, relationships, or quantifiers.

Example

• Sentence: "All students in the class are present."

• Representation: We need something that says:

o There are "students."

o They belong to a "class."

o They are "present."

 • A formal representation like First-Order Logic -FOL) (Logical expression) can
express this: ∀x(Student(x)∧InClass(x) ⟹ Present(x))

This level of detail ensures that nothing is left ambiguous or missing.

Computationally Feasible

The representation should not just be detailed but also easy to process on a computer.
Complex representations that are slow or impossible to compute are not practical.

Example

• Sentence: "Ravi visits Mumbai."

• A simple computational model might represent this as: Visits (Ravi, Mumbai)

This is both expressive (captures "who" and "where") and computationally feasible
(simple enough to store and process efficiently).

Support Ambiguity Resolution

Sometimes, sentences have multiple possible meanings. The representation should allow
the system to handle such ambiguity.

Example

• Sentence: "The bank is crowded."

• Ambiguity: Does "bank" refer to a financial institution or a riverbank?

• Representation: Bank: Financial Institution or Bank: Riverbank

The system can keep both options until context clarifies which one is correct.

Interpretable

The representation should be understandable by both machines and humans. If a system

outputs a representation, it should make sense to a human.

Example

Sentence: "Amit gave a book to Ramesh."

• Event: Giving

• Agent: Amit

• Object: Book

• Recipient: Ramesh
 • Representation:

Event: Give (Agent=Amit Object=Book Recipient=Ramesh)

This representation is clear for a human and can be easily processed by a machine.

Theoretic Semantics Model

The theoretic semantics model ensures that sentences "make sense" within a given
context or structure. It has the following components:

Model

• A model represents a world or domain where sentences can be evaluated as true or

false.

• It consists of:

o Domain (D): The set of objects/entities in the model.

o Interpretation Function (I): A mapping of words to objects, properties, or

relationships in the domain.

Truth Conditions

• The meaning of a sentence is defined as the conditions under which it is true in the
model.

Formal Language

• Uses logic-based notations like First-Order Logic (FOL) or Description Logics to

represent sentences.

Example: A Simple Model

Sentence: "Ravi loves tea."

• Domain (D): {Ravi, Tea}

• Interpretation Function (I):

o "Ravi" → Ravi

o "Tea" → Tea

o "Loves" → {(Ravi, Tea)}

• Truth Evaluation:

o Sentence: "Ravi loves tea."

 o Logical Representation: Loves (Ravi, Tea)

o Check if (Ravi, Tea) exists in the interpretation of "Loves."

o Result: True (because (Ravi,Tea) is in the "Loves" relation).

Multiple Sentences Example

Sentences:

1. "Ravi drinks coffee."

2. "Priya drinks tea."

• Domain (D): {Ravi, Priya, Coffee, Tea}

• Interpretation Function (I):

o "Ravi" → Ravi

o "Priya" → Priya

o "Drinks" → {(Ravi,Coffee),(Priya,Tea)}

Representations:

1. "Ravi drinks coffee": Drinks(Ravi,Coffee) → True

2. "Priya drinks tea": Drinks(Priya,Tea) → True

3. "Ravi drinks tea": Drinks(Ravi,Tea)→ False

Applications of Model-Theoretic Semantics

1. Question Answering Systems

o Example: "Who loves tea?" → Query the model to find all pairs matching
Loves(∗,Tea).

2. Reasoning Systems

o Example: Deduce if "Ravi drinks something" is true, based on the model.

First-Order Logic (FOL) in NLP

First-Order Logic (FOL) is a formal representation system used in NLP to model the
meaning of natural language sentences.
It provides a way to express relationships between objects, properties of objects,
and quantifiers like "all" or "some."

Key Components of FOL

1. Constants: Represent specific entities or objects.

o Example: "Ravi", "Priya", "book".

2. Variables: Represent general placeholders.

o Example: x, y, z

3. Predicates: Represent relationships or properties.

o Example: Likes (Ravi, Book): Ravi likes a book.

4. Functions: Map objects to other objects.

o Example: Mother (Ravi): Ravi's mother.

5. Logical Connectives:

o AND (^): Both statements must be true.

o OR (v): At least one statement must be true.

o NOT (¬): Negates a statement.

o IMPLIES (→): If one statement is true, the other must be true.

6. Quantifiers:

o Universal (∀): Applies to all entities.

Example: "Everyone likes books." →

∀x (Person(x) → Likes (x, Book)).

o Existential (∃): Applies to at least one entity.

Example: "Someone likes books." →

∃x(Person(x) ∧ Likes (x, Book)).

Examples of FOL Representations

1. Simple Statement:

o Natural Language: "Ravi likes books."

o FOL: Likes (Ravi, Books).

2. Universal Quantification:

o Natural Language: "Every student reads books."

o FOL: ∀x(Student(x)→Reads(x,Books)).

3. Existential Quantification:

o Natural Language: "Some students read novels."

o FOL: ∃x(Student(x)∧Reads(x,Novels)).

4. Negation:

o Natural Language: "Ravi does not like novels."

o FOL: ¬Likes(Ravi,Novels).

5. Compound Statements:

o Natural Language: "If Ravi is a student, he likes books."

o FOL: Student(Ravi)→Likes(Ravi,Books).

Applications of FOL in NLP

1. Semantic Parsing: Converting natural language to logical forms.

o Example: "Who wrote Hamlet?" → ∃x(Wrote(x,Hamlet)).

2. Question Answering: Using FOL to model and reason about questions.

o Query: "Is Ravi a student?" → Student(Ravi).

3. Knowledge Representation: Representing facts and rules in a knowledge

base.

o Fact: "Priya is a teacher." → Teacher(Priya).

 o Rule: "All teachers educate students." →
∀x(Teacher(x)→Educates(x,Students)).

4. Reasoning and Inference: Drawing conclusions from logical rules.

o Rule: ∀x(Student(x)→Reads(x,Books)).

o Fact: Student(Ravi).

o Inference: Reads(Ravi,Books).

Description Logics (DLs):

Description Logics (DLs) are used to model relationships between concepts,
making them foundational for applications like semantic web technologies.

Key Components of Description Logics

1. Concepts: Represent classes or sets of entities.

o Example: Teacher, Student.

2. Roles: Represent relationships between entities.

o Example: Teaches(x, y): A teacher x teaches a subject y.

3. Individuals: Represent specific entities in the domain.

o Example: Ravi, Mathematics.

Syntax of Description Logics

1. Atomic Concepts:

o A: A basic class

o Person: Represents the class of all persons.

o Teacher: Represents the class of teachers.

o Student: Represents the class of students.

o Book: Represents the class of books.

o City: Represents the class of cities.

 2. Atomic Roles:

o R: A basic relationship.

o hasChild: Relationship between a parent and a child.

o teaches: Relationship between a teacher and a subject or student.

o livesIn: Relationship between a person and a city.

o Owns: Relationship between a person and an object (e.g., book, car).

o isFriendOf: Relationship between two people.

3. Complex Concepts:

o Combine atomic concepts and roles using logical operators.

o These are built by combining atomic concepts and roles using logical
operators like intersection (⊓), union (⊔), negation (¬), existential
quantification (∃), and universal quantification (∀).

Constructs in DL

1. Intersection (⊓): Represents AND.

o Example: Person ⊓ Teacher: A person who is also a teacher.

2. Union (⊔): Represents OR.

o Example: Student ⊔ Teacher: A person who is either a student or a

teacher.

3. Negation (¬): Represents NOT.

o Example: ¬Student: A person who is not a student.

4. Existential Quantification(∃R.C): At least one relationship.

o Example: ∃hasChild.Person: Someone who has a child that is a person.

5. Universal Quantification (∀R.C): All relationships satisfy a condition.

o Example: ∀teaches.Subject: A teacher teaches only subjects.

Examples of DL Representations

1. Concepts:

o "A teacher is a person who teaches students."

▪ Teacher ≡ Person ⊓ ∃teaches.Student.

2. Role Restrictions:

o "Every parent has at least one child."

▪ Parent ≡ Person ⊓ ∃hasChild.Person.

3. Hierarchical Relationships:

o "All professors are teachers."

▪ Professor ⊑ Teacher.

4. Disjointness:

o "A student cannot be a teacher."

▪ Student ⊓ Teacher=∅.

Applications of Description Logics

1. Semantic Web:

o Facilitating reasoning over linked data.

o Example: Infer new facts from a knowledge graph.

2. Knowledge Representation:

o Representing structured domain knowledge.

o Example: Representing relationships in an education system.

3. Reasoning:

o Ensuring consistency and inferring new knowledge.

o Example: Inferring that "Ravi is a student" if "Ravi attends a course."

Semantic roles
Semantic roles describe the relationship between a verb and the entities involved in
the action or state expressed by the verb.

They capture the function or "role" that each entity plays in the event.

Semantic roles are critical in understanding the meaning of a sentence beyond its
syntactic structure.

Common Semantic Roles Here are some commonly used semantic roles with
examples:

Role Description Example

Agent The doer of the action Jeet baked a cake. (Jeet is the agent)

Jeet baked a cake. (Cake is the

Patient The entity affected by the action
patient)

The entity undergoing an action The book was placed on the table.
Theme
or being described (The book)

The tool or means used to He cut the paper with scissors.

Instrument
perform an action (Scissors)

The entity experiencing a state or Anna felt happy. (Anna is the

Experiencer
feeling experiencer)

He lives in Paris. (Paris is the

Location The place where the action occurs
location)

She went to the park. (Park is the

Goal The endpoint of an action
goal)

He came from London. (London is the

Source The starting point of an action
source)

The entity for whose benefit the He made a cake for her. (Her is the
Beneficiary
action is performed beneficiary)
Semantic role labeling (SRL)
Semantic role labeling (SRL) is the process of identifying semantic roles for the
words in a sentence and assigning labels to them. It helps machines understand who
did what to whom, when, where, and why.

Example of Semantic Role Labeling

Consider the sentence:

• "Ravi sent a parcel through a courier."

The semantic roles for this sentence are:

• Agent (who performed the action): Ravi

• Theme (what was affected): a parcel

• Instrument (means of performing the action): a courier

How SRL Works

SRL typically involves the following steps:

1. Identify the predicate (main verb): The verb that governs the action, e.g.,
"sent."

2. Determine arguments (entities related to the predicate): Extract all

entities related to the action, e.g., Ravi (Agent), parcel (Theme).

3. Assign semantic roles: Map each argument to its corresponding role.

Applications of SRL

1. Question Answering:

o Question: "Who sent the parcel?"

o Answer: "Ravi"

2. Machine Translation:

o Accurate translations based on understanding the roles in a sentence.

3. Text Summarization:

o Condensing content while preserving meaning.

4. Information Extraction:

o Extracting structured data from unstructured text.