1.

Syntax Analysis:

Syntax analysis in natural language processing (NLP) refers to the process of

identifying the structure of a sentence and its component parts, such as phrases and

clauses, based on the rules of the language's syntax.

There are several approaches to syntax analysis in NLP, including:

1. Part-of-speech (POS) tagging: This involves identifying the syntactic category

of each word in a sentence, such as noun, verb, adjective, etc. This can be

done using machine learning algorithms trained on annotated corpora of text.

2. Dependency parsing: This involves identifying the relationships between

words in a sentence, such as subject-verb or object-verb relationships. This

can be done using a dependency parser, which generates a parse tree that

represents the relationships between words.

3. Constituency parsing: This involves identifying the constituent parts of a

sentence, such as phrases and clauses. This can be done using a

phrase-structure parser, which generates a parse tree that represents the

structure of the sentence.

Syntax analysis is important for many NLP tasks, such as named entity recognition,

sentiment analysis, and machine translation. By understanding the syntactic

structure of a sentence, NLP systems can better identify the relationships between

words and the overall structure of the text.

2. ✅ Brief Explanation of Parsing in Natural Language Processing (10

Marks Answer)

Parsing, or syntax analysis, is a fundamental process in Natural Language Processing (NLP)

that involves analyzing the grammatical structure of a sentence. It identifies how words in a
sentence relate to each other and form meaningful structures, such as phrases and clauses.

Key Steps in Syntax Analysis:

 1. Tokenization:
The sentence is broken into individual words or tokens.
Example: "The cat sat on the mat." → "The", "cat", "sat", "on", "the",
"mat", "."
2. Part-of-Speech (POS) Tagging:
Each token is labeled with its grammatical role, like noun, verb, determiner, etc.
Example: "The" (determiner), "cat" (noun), "sat" (verb)
3. Dependency Parsing / Parse Tree Generation:
The sentence is converted into a tree-like structure that shows relationships
(dependencies) between words.
For instance, "cat" is the subject of "sat", and "mat" is the object of the preposition
"on".

sat

/\

cat on

/\|

The mat the

🔸 Types of Parsing:

• Rule-based Parsing: Uses predefined grammatical rules to determine structure.

• Statistical Parsing: Uses machine learning and large corpora to learn common
patterns and generate parse trees probabilistically.

🔹 Importance of Syntax Analysis:

Parsing plays a vital role in many advanced NLP tasks like:

• Machine translation (understanding sentence structure for accurate translation),

• Text-to-speech conversion (identifying sentence flow and emphasis),
• Sentiment analysis (understanding context and subject-object relationships).
 3. Brief Explanation of Treebanks in NLP (10 Marks Answer)

Treebanks are a crucial resource in Natural Language Processing (NLP) used for syntax
analysis. They consist of a large collection of sentences, each annotated with a parse tree that
shows the syntactic structure of the sentence. These manually created trees serve as training
data for building statistical parsers.

🔹 Key Concepts:

1. Parse Tree:
A hierarchical tree structure that represents the grammatical structure of a sentence.
o Nodes: Represent constituents like noun phrases (NP), verb phrases (VP),
etc.
o Edges: Show relationships like subject-verb or verb-object.
2. Example:
For the sentence “The cat sat on the mat”, the parse tree breaks it down into parts:
o Noun Phrase (NP): "The cat" → [Determiner "The", Noun "cat"]
o Verb Phrase (VP): "sat on the mat"
o Prepositional Phrase (PP): "on the mat" → [Preposition "on", NP "the mat"]
3. Statistical Parsers:
o Learn patterns from treebanks (like "noun phrase usually followed by verb
phrase")
o Use these patterns to predict the structure of new, unseen sentences
automatically.

sat(V)

/\

cat(N) on(PREP)

/\/\

The(D) mat(N) the(D)

🔸 Importance of Treebanks:

• Training data for statistical and machine learning-based parsers

 • Support syntactic analysis in tasks like machine translation, information
extraction, and question answering
• Improve accuracy in parsing by providing real, annotated sentence structures

🔹 Well-Known Treebanks:

• Penn Treebank – One of the most widely used for English

• Universal Dependencies (UD) – Covers many languages and supports cross-
linguistic research

✅ Summary:

Treebanks are manually annotated collections of syntactically parsed sentences used to train
statistical parsers. These parsers can then generate parse trees for new sentences, helping
machines understand grammar and sentence structure. Treebanks play a vital role in improving
the syntactic understanding of language in NLP applications.

4. Representation of Syntactic Structure in NLP (10 Marks)

In Natural Language Processing (NLP), syntactic structure representation refers to how the
grammatical structure of a sentence is encoded so that machines can understand and analyze it.
Two primary models used are Constituency-Based and Dependency-Based representations.

1. Constituency-Based Representation (Phrase Structure Trees)

Also called parse trees, they depict the hierarchical structure of phrases in a sentence.

Each node represents a constituent, like noun phrases (NP), verb phrases (VP), etc.

Example:

(S

(NP (DT The) (NN cat))

(VP (VBD sat)

(PP (IN on)

(NP (DT the) (NN mat)))))

This tree shows how the sentence “The cat sat on the mat” breaks into NP and VP, and further
into determiners, nouns, verbs, etc.

2. Dependency-Based Representation

Represents syntactic structure as a graph, where words are nodes and grammatical relations are
directed edges.

Focuses on binary relations between words (e.g., subject, object, modifier).

Example:

sat → cat (subject)

sat → on → mat (prepositional object)

More compact and suitable for statistical models, especially in morphologically rich languages.

sat-V

cat-N

on-PREP

mat-N

3. Comparison and Applications

Constituency trees are better for rule-based syntactic analysis.

Dependency structures are more efficient in computation and widely used in machine translation,
relation extraction, and question answering.

Both are used in tasks like parsing, sentiment analysis, information extraction, etc.

4. Tools and Resources

Treebanks like the Penn Treebank provide large corpora annotated with syntactic trees.
Parsing tools use these for training and syntactic analysis.

---

✅ Brief Explanation of Syntax Analysis Using Dependency Graphs (10 Marks

Answer)

Syntax analysis using dependency graphs is a widely used method in Natural Language
Processing (NLP) to represent the grammatical structure of sentences. Instead of using
traditional phrase structure trees, this method uses a directed graph, where:

• Each word in the sentence is a node

• Edges represent grammatical relationships between the words (e.g., subject,
object, modifier)

🔹 Key Features:

1. Nodes = Words:
Each word is treated as a node labeled with its part of speech (POS), such as noun, verb,
etc.
2. Edges = Dependencies:
Directed edges connect words to show who depends on whom.
Example: In "The cat sat on the mat",
o "cat" → subject of "sat"
o "mat" → object of preposition "on"
3. Grammatical Relations:
Edge labels like nsubj (nominal subject), prep (preposition), pobj (object of
preposition) define how words relate grammatically.

📘 Example:

Sentence: "I saw the man with the telescope"

• "I" → subject of "saw"

• "man" → object of "saw"
• "with the telescope" → prepositional phrase modifying "man"

This shows how dependency graphs can handle complex relationships efficiently.
► sat

┌───┐ │ │

│ The │ │ ├─► on

└───┘ │ │ │

└────► cat ──► mat

🔸 Advantages of Dependency Graphs:

Benefit Explanation

Efficient More compact and faster than phrase structure trees

Flexible Handles non-projective and complex structures

Useful for NLP tasks

Syntax Analysis Using Phrase Structure Tree – 10 Marks Answer

Syntax analysis using Phrase Structure Trees (also called Constituency Parsing) is a
fundamental approach in Natural Language Processing (NLP) to represent the grammatical
structure of sentences. A phrase structure tree (or parse tree) shows how a sentence is
hierarchically organized into phrases and subphrases according to a formal grammar.

Key Concepts:

1. Phrase Structure Tree Definition:

A hierarchical tree representation of a sentence's syntax.

Each node represents a phrase or grammatical category (like NP, VP, PP).

The leaves are the words (tokens) in the sentence.

2. Example Sentence:

"The cat sat on the mat."

3. Corresponding Phrase Structure Tree:

S

/\

NP VP

/\ /\

Det N V PP | | | /

The cat sat P NP /

Det N | | the mat

- S → Sentence

- NP → Noun Phrase

- VP → Verb Phrase

- PP → Prepositional Phrase

- Det → Determiner, N → Noun, V → Verb, P → Preposition

### **Steps in Phrase Structure Syntax Analysis:**

1. **Tokenization**: Break the sentence into individual words.

2. **POS Tagging**: Assign parts of speech to each token (e.g., The/Det, cat/N).

3. **Apply Grammar Rules**: Combine words and phrases according to grammar (CFG
rules like S → NP VP).

4. **Construct Tree**: Build the hierarchical tree from the rules.

### **Advantages:**

- Clearly represents phrase-level relationships.

- Useful in languages with rigid word order.

 5. Parsing Algorithms in Natural Language Processing

Parsing is a fundamental component of syntax analysis in Natural Language Processing (NLP). It

refers to the process of analyzing the grammatical structure of a sentence to determine its
syntactic structure, typically in the form of a parse tree. Several algorithms are used in NLP for
parsing:

1. Recursive Descent Parsing (Top-Down Parsing)

• This algorithm starts from the top-level symbol (usually the sentence) and
recursively breaks it into subcomponents using grammar rules.
• It is simple and works well for grammars without left recursion.
• Example: For arithmetic expressions using rules like E → E + T | T, the parser
recursively matches the input with grammar productions.

E -> E + T | E - T | T

T -> T * F | T / F | F

F -> ( E ) | num

2. Shift-Reduce Parsing (Bottom-Up Parsing)

• This method uses a stack and input buffer. It shifts tokens from input to stack and
applies grammar rules (reductions) to group them.
• It’s commonly used in practical NLP systems.
• Example: Parsing the sentence "the man saw a woman with a ball" involves reducing
sequences like Det + N → NP and NP + VP → S

S -> NP VP

NP -> Det N | NP PP

VP -> V NP | VP PP

PP -> P NP

Det -> the | a

N -> man | ball | woman

V -> saw | liked

P -> with | in

3. Earley Parsing

• A dynamic programming algorithm that works with all context-free grammars.

• It maintains a chart of partial parses and combines them efficiently.
• Useful for ambiguous and complex grammatical structures.

4. Chart Parsing with Hypergraphs

• Uses a chart (table) to store partial results and a hypergraph to represent multiple
parsing paths.
• Efficient and supports ambiguous grammars.
• Especially effective in representing shared structures in sentences.

S -> NP VP

NP -> Det N

VP -> V NP

Det -> the

N -> cat | mouse

V -> chased

1. Initialization: We sta

Applications of Parsing Algorithms

• Parsing is used in machine translation, question answering, text-to-speech

systems, and sentiment analysis.
• It helps in understanding sentence structure, relationships between words, and
extracting meaning.
Minimum Spanning Tree (MST) in NLP

In NLP, Minimum Spanning Trees are often used in dependency parsing, where the goal is to
construct a syntactic structure that connects all words in a sentence based on their grammatical
relationships.

• Definition: A Minimum Spanning Tree is a subset of edges in a connected, weighted

graph that connects all the nodes with the minimum total edge weight and without
forming any cycles.
• Application in NLP:
o Each word in a sentence is considered a node.
o Possible syntactic relations between words are edges, weighted by scores
from a statistical or neural model.
o MST algorithms like Chu-Liu/Edmonds’ algorithm are used to find the most
probable tree representing dependencies.
• Why MST:
o Ensures a tree structure (acyclic, connected) with optimal grammatical
relationships.
o Used in non-projective dependency parsing (important for free-word-order
languages).

Dependency Parsing
Dependency parsing is a technique to analyze the grammatical structure of a
sentence by establishing relationships between "head" words and words that
modify them.

• Concept:
o The sentence is converted into a dependency tree, where:
▪ Each word is a node.
▪ Directed edges represent dependencies (e.g., subject of, object of).
• Advantages:
o Simpler and more flexible than phrase structure parsing.
o Directly maps to grammatical relations useful for semantic analysis.
• Example:
o Sentence: The cat sat on the mat.
o Dependency tree shows:
▪ sat is the root verb.
▪ cat is subject of sat.
▪ mat is object of the preposition on which modifies sat.
• Techniques:
 o Rule-based and data-driven parsers (e.g., using treebanks).
o MST-based parsers use graph algorithms to find optimal dependency trees.

Conclusion

Both MST and dependency parsing are foundational in modern NLP systems. While dependency
parsing provides a way to extract grammatical structures, MST ensures that the selected
structures are optimal and valid in a graph-theoretic sense. Together, they enhance the syntactic
understanding of language, which is crucial for applications like machine translation,
information extraction, and question answering.