Syntax from Rules to Merge

 

Deep Syntax from Rules to Merge: The Minimalist Revolution

Intro

Welcome back.

We are now at a turning point in syntactic theory.

Up to this stage, we have treated grammar as a system of rules, phrase structure rules, transformations, constraints, refinements, categories, and feature systems.

But a deeper question now emerges:

What if all of this machinery is unnecessary?

What if the complexity of syntactic theory is not a reflection of language itself, but of the way we have been describing it?

This is where modern generative grammar undergoes its most radical simplification.

We move from:

a system of rules

to

a single computational operation

And syntax becomes something far more minimal and far more elegant.

Syntax Before Minimalism — The Last Stage of Rule-Based Grammar

Before the Minimalist Program, syntax looked like this:

Phrase structure rules generate trees
Transformations move elements
Constraints filter derivations
Feature systems enforce agreement
Lexical rules specify category behavior

This architecture worked, but it carried a hidden assumption:

that grammar is a collection of interacting subsystems

Each doing part of the work.

But this creates redundancy:

Why multiple operations?
Why separate generation and transformation?
Why distinct modules if output is one system?

Minimalism begins with a suspicion:

Nature does not overcomplicate computation.

So perhaps grammar is not a toolbox.

Perhaps it is a single operation expressed repeatedly.

The Minimalist Hypothesis — Reduce Everything

The Minimalist Program proposes a radical shift:

Language is an optimal solution to interface conditions.

In simpler terms:

Grammar is not designed to be descriptive.

It is designed to be efficient.

And efficiency leads to a startling conclusion:

Most syntactic machinery is not primitive; it is derived.

So instead of:

phrase structure rules
movement rules
transformations

we ask:

What is the smallest possible operation that can generate hierarchical structure?

The answer is surprisingly simple:

Merge — The Single Operation Under Everything

At the core of Minimalist syntax is one operation:

Merge

Merge takes two syntactic objects and combines them into a single unit.

That’s it.

Formally:

Merge(A, B) → {A, B}

But this simple operation produces something profound:

hierarchy
structure
recursion
embedding
syntactic trees

Everything we previously built with rules now emerges from this single combinatorial function.

The Deep Idea — Syntax as Pure Combination

Consider what Merge replaces:

Instead of rules like:

S → NP VP
VP → V NP
NP → Det N

we now say:

elements are selected from the lexicon and merged iteratively

So a sentence is not generated by rules.

It is:

recursively built by combining elements pairwise

This changes everything.

Because now syntax is not:

a derivation system

but:

a combinatorial system

A system where structure emerges from repeated binary operations.

First Merge — Building the Minimal Structure

Take lexical items:

eat
apples

First Merge:

Merge(eat, apples)

→ {eat, apples}

This creates a verb phrase-like structure.

But nothing in the system labels it yet.

There are no categories in the primitive sense.

Only relations.

So structure is not predefined.

It is constructed.

Second Merge — Recursion Appears Naturally

Now introduce another element:

John

Merge(John, {eat, apples})

→ {John, {eat, apples}}

Now we see something crucial:

hierarchical embedding arises automatically

No extra rule is needed for recursion.

Recursion is not a property added to grammar.

It is:

the inevitable consequence of repeated Merge

This is the deepest insight of modern syntax:

Infinite structure from finite operation.

Labels — Where Categories Come From

A problem appears:

If Merge only produces sets, how do we know what the structure is?

Where do labels like NP or VP come from?

Minimalism answers cautiously:

Labels are not primitive—they are derived.

One proposal is:

the head projects its properties
or labeling emerges from feature sharing

So instead of rules defining categories:

categories emerge from structural dominance and feature configurations

This removes another layer of theoretical machinery.

Feature Checking — Syntax Becomes a Computation System

We previously used features like:

[±plural]
[±tense]
φ-features

In Minimalism, features are not descriptive—they are computational triggers.

They determine:

whether Merge can occur

whether structure is licensed

whether derivation converges or crashes

So grammar becomes:

a system of feature satisfaction under computation

If features match → derivation continues
If not → crash at interface

This introduces a key idea:

Syntax is not just generation; it is controlled failure prevention.

Movement Reinterpreted — Internal Merge

What we previously called “movement” is reinterpreted:

Instead of moving elements, we now say:

Internal Merge = re-Merge of an existing element

Example:

“What did John eat?”

The object “what” is merged twice:

once in object position
once in sentence-initial position

So movement is not displacement.

It is:

reapplication of the same operation

This removes another transformation rule from the system.

Everything is still Merge.

Phases — Local Windows of Computation

Minimalism introduces another constraint:

computation proceeds in phases

A phase is a chunk of structure that gets sent to interpretation systems:

semantic interface (meaning)
phonological interface (sound)

Once a phase is complete:

it is no longer fully accessible

This explains:

locality constraints
island effects
bounded dependencies

Not by stipulation, but by computational architecture.

Syntax becomes:

cyclic, memory-limited computation

The Big Reduction — Everything Becomes One System

Now we can summarize the entire shift:

Before Minimalism:

rules generate structure
transformations modify structure
constraints filter structure
lexicon feeds structure

After Minimalism:

Everything is Merge operating under feature-driven constraints and phase-based computation.

That is the entire system.

No separate modules of grammar are needed in the same way.

The Hidden Simplicity — Why This Matters

The elegance of this model is not just technical.

It is conceptual.

Because it suggests:

language is not stored as rules
language is not retrieved as templates
language is computed in real time

And more radically:

syntax may reflect a general property of human cognition: minimal combinatorial recursion under constraints.

This aligns syntax with:

mathematics (set formation)
computation (recursive functions)
cognition (structured thought assembly)

Insight — Language as a Single Recursive Function

We can now compress the entire theory into one idea:

Human syntax is a recursive combinatorial system operating over discrete elements via a single operation: Merge.

Everything else:

phrase structure
movement
agreement
embedding
hierarchy

emerges from this single operation interacting with:

features
interfaces
computational phases

So what looked like a complex architecture of grammar turns out to be:

a minimal computational engine expressing infinite structure from finite means.

If earlier theories showed us that language is structured,

Minimalism shows something more radical:

structure itself may be an inevitable consequence of how cognition combines elements.

Not grammar as a set of rules.

Not syntax as a descriptive system.

But syntax as:

the most minimal possible system capable of generating human thought in linguistic form.

Introduction to Linguistics: Syntax 4