Morphological Models

This model analyzes word structure by searching for words in a database (dictionary).

Process:
To analyze a word, it must first be converted into its base form or canonical form (e.g., "beauty" is the base form for "beautiful").
Once in base form, the system searches the dictionary to retrieve information like the part of speech, word structure, or meaning.

Limitations: If no matches are found, or if multiple matches exist, the dictionary lookup model is typically combined with other models to perform a more accurate analysis.

Finite-State Morphology is a morphological model used in NLP to analyze the grammatical and structural composition of a word.
Instead of just storing words like a standard dictionary, it utilizes finite automata and formal language theory to handle both generation and recognition tasks.

Basics of Formal Language Theory

The system is built using standard components of formal language theory.
States: Represented by circles. The starting state is a single circle, while the ending (final) state is represented by a double circle, indicating the path cannot go any further.
Transitions: Represented by arrows (or self-loops), which denote moving from one state to another when given a specific input.
Null Value (Epsilon): Used to indicate a blank or transition that requires no characters.

Finite-State Transducers (FSTs) & Word Structures

The actual process of mapping word parts is done through Finite-State Transducers.
Let's see how a single FST can fit variations of a base stem word, using "Grace" as an example:
Base Word (Stem): Moving directly through the stem transition outputs the word "Grace".
With Prefix: Transitioning through a prefix state (dis-) before the stem produces "disgrace".
With Suffix: Moving through the stem and then a suffix state (-ful) produces "graceful".
With Prefix and Suffix: Pathing through the prefix, stem, and suffix together produces "disgraceful".

By utilizing an initial (epsilon) path for words without prefixes and multiple final states, all four structural variations are successfully navigated using just one overarching finite automaton machine.

Finite-State Morphology excels at two distinct functions:

Generation: Taking a base stem word as an input and generating entirely new morphological word forms by appending the correct prefixes or suffixes (e.g., inputting "Grace" to output "disgraceful").
Recognition: Taking a complex or altered word as an input and working backward to identify and strip down to its core base word or root lemma (e.g., inputting "disgrace" and recognizing the base word is "Grace").

Unification-based morphology is a way for computers to understand how words are built by combining pieces of information called features.
Each part of a word (like a root or ending) has certain features. For example, “cat” is a noun, and “-s” means plural.

How it works?
Every word part is described using a feature structure — basically a list of properties.
When you join parts together, the computer checks if their features match.
If they fit (like noun + plural), they combine successfully.
If they don’t fit (like verb + plural noun ending), the combination fails.

Example:
Root: cat → {type: noun}
Suffix: -s → {number: plural}
When unified, they become {type: noun, number: plural} → cats

In short, unification-based morphology is like matching puzzle pieces of word information, only the ones that fit together make a correct word.

Functional morphology is a way of modeling how words are formed using ideas from functional programming, a style of computer programming that treats operations as mathematical functions.

Example:
You have a function that takes a root word (e.g., “walk”) and a parameter (e.g., “past tense”).
The function outputs the correct form: “walked”

In short, Functional morphology treats word formation like math, you give it inputs (word + grammar info), and it returns the right word form.

Morphological induction is about learning how words are formed automatically, instead of manually writing rules or listing all word forms, the computer figures out patterns by looking at examples.

How it works?
The system is given many examples of words and their parts (like roots and endings).
It looks for regular patterns, for instance, noticing that adding “-ed” makes verbs past tense.
From these examples, it induces (learns) general rules that can apply to new words.
This process helps build models that can guess or generate word forms even if they haven’t been seen before.

Example:
If the computer sees:
walk → walked
jump → jumped
play → played
It can learn the rule: “Add -ed to make past tense.”
Then it can apply that rule to new verbs like “talk → talked.”