Adger (2025): Mereological Syntax: Phrase Structure, Cyclicity, and Islands #
Adger replaces set-theoretic Merge by Subjoin, which makes one syntactic object a proper part
of another in one of two dimensions: the first subjunction to an object yields its 1-part, the
extended-projection complement, the second its 2-part, the specifier (Parthood). Parthood is
transitive within a dimension only, and Angular Locality lets a part subjoin to a target only
through a single angle: it must be an n-part of some 1-part of the target (CanSubjoin). A
derivation is a sequence of subjunctions licensed by Dimensionality, Angular Locality and
Mereological Extension (Derives).
The book's list of consequences is verified on its own structures. The complement of a head
cannot resubjoin to it (antilocality), and subjunction to an unattached object, to a specifier,
or downward fails because the target must contain the mover, in lowering and sideward
configurations in every derivation (parallel_blocked, sideward_blocked, lowering_blocked).
A 2-part of a 2-part of an object in the target's extended projection subjoins, while a 1-part of
that 2-part does not (angle_turns_once), so that a subjunction blocked from inside a specifier
becomes possible once the mover has subjoined to that specifier (escape_hatch): of the objects
inside a specifier, exactly its own 2-parts reach above it (edge). This is successive
cyclicity without phases: who reaches the matrix C of guess who you said fell only after
subjoining to the embedded C, and in every derivation it leaves the embedded clause only from its
edge (said_fell, said_successive_cyclic).
Islands follow from the same mechanism with Dimensionality: a 2-part whose own 2-part slot is
filled is an island in every derivation. In what you asked who bought, the embedded C has who
as its 2-part, and what never reaches the matrix C (wh_island). Extraction from a nominal runs
through D, so it needs D's 2-part: an indefinite leaves it free and who did you buy a statue of
derives (statue_indefinite), while a definite fills it with Det and the wh-expression is
trapped (statue_definite). Subjects are not islands as such: under T[uD] the wh-expression
subjoins to D and on to C (subject_thetic). T[uFam] is checked by a [Fam]-bearing 2-part of T,
which in English only a Det, Dem or possessor in D's 2-part supplies, so a topic subject traps
the wh-expression, and once the wh-expression holds D's 2-part the subject can never be a topic
(subject_topic, thetic_not_topic). These predictions match the judgments of the book's rows
on extraction from clauses, nominals and subjects (clause_rows, nominal_rows). Wh-island
violations, the WIRE effect, adjunct islands, *-linearization, and the cross-linguistic feature
settings of chapters 5–7 are not formalized.
Implementation notes #
- Each structure is the book's tree cut down to the objects its claim needs: the movement of the subject to T in (44) and (3), and the article inside the relational nominal of (32), are left out, and a filler of D is a single object. Every object with a 2-part keeps its 1-part, as Dimensionality requires.
- A row's structure is read off its own columns: the type of nominal fixes the 2-part of D, by D-Interpretation for definites and by the subjunction of Dem or the possessor, and pied-piping makes P the mover. The wh-in-situ rows of (41)–(44) are read as covert subjunction to C, and the echo-only reading of (42b) is set aside.
- The prediction of a row is
Reaches: some licensed derivation makes the mover a part of C.
References #
Consequences of Angular Locality #
Equations
- Adger2025.instDecidableEqObj x✝ y✝ = if h : x✝.ctorIdx = y✝.ctorIdx then isTrue ⋯ else isFalse ⋯
Equations
- Adger2025.instFintypeObj = { elems := { val := ↑Adger2025.Obj.enumList, nodup := Adger2025.Obj.enumList_nodup }, complete := Adger2025.instFintypeObj._proof_1 }
Equations
- Adger2025.instReprObj = { reprPrec := Adger2025.instReprObj.repr }
Equations
- Adger2025.instReprObj.repr Adger2025.Obj.a prec✝ = Repr.addAppParen (Std.Format.nest (if prec✝ ≥ 1024 then 1 else 2) (Std.Format.text "Adger2025.Obj.a")).group prec✝
- Adger2025.instReprObj.repr Adger2025.Obj.b prec✝ = Repr.addAppParen (Std.Format.nest (if prec✝ ≥ 1024 then 1 else 2) (Std.Format.text "Adger2025.Obj.b")).group prec✝
- Adger2025.instReprObj.repr Adger2025.Obj.c prec✝ = Repr.addAppParen (Std.Format.nest (if prec✝ ≥ 1024 then 1 else 2) (Std.Format.text "Adger2025.Obj.c")).group prec✝
- Adger2025.instReprObj.repr Adger2025.Obj.d prec✝ = Repr.addAppParen (Std.Format.nest (if prec✝ ≥ 1024 then 1 else 2) (Std.Format.text "Adger2025.Obj.d")).group prec✝
- Adger2025.instReprObj.repr Adger2025.Obj.e prec✝ = Repr.addAppParen (Std.Format.nest (if prec✝ ≥ 1024 then 1 else 2) (Std.Format.text "Adger2025.Obj.e")).group prec✝
- Adger2025.instReprObj.repr Adger2025.Obj.f prec✝ = Repr.addAppParen (Std.Format.nest (if prec✝ ≥ 1024 then 1 else 2) (Std.Format.text "Adger2025.Obj.f")).group prec✝
- Adger2025.instReprObj.repr Adger2025.Obj.g prec✝ = Repr.addAppParen (Std.Format.nest (if prec✝ ≥ 1024 then 1 else 2) (Std.Format.text "Adger2025.Obj.g")).group prec✝
- Adger2025.instReprObj.repr Adger2025.Obj.u prec✝ = Repr.addAppParen (Std.Format.nest (if prec✝ ≥ 1024 then 1 else 2) (Std.Format.text "Adger2025.Obj.u")).group prec✝
- Adger2025.instReprObj.repr Adger2025.Obj.w prec✝ = Repr.addAppParen (Std.Format.nest (if prec✝ ≥ 1024 then 1 else 2) (Std.Format.text "Adger2025.Obj.w")).group prec✝
- Adger2025.instReprObj.repr Adger2025.Obj.x prec✝ = Repr.addAppParen (Std.Format.nest (if prec✝ ≥ 1024 then 1 else 2) (Std.Format.text "Adger2025.Obj.x")).group prec✝
- Adger2025.instReprObj.repr Adger2025.Obj.y prec✝ = Repr.addAppParen (Std.Format.nest (if prec✝ ≥ 1024 then 1 else 2) (Std.Format.text "Adger2025.Obj.y")).group prec✝
- Adger2025.instReprObj.repr Adger2025.Obj.z prec✝ = Repr.addAppParen (Std.Format.nest (if prec✝ ≥ 1024 then 1 else 2) (Std.Format.text "Adger2025.Obj.z")).group prec✝
Instances For
Equations
- One or more equations did not get rendered due to their size.
Instances For
Neither part of c ever subjoins to the other.
Clausal derivations and wh-islands #
The categories of the clausal and nominal structures; primes mark the embedded clause and the wh-phrase inside a nominal.
- C : Node
- T : Node
- v : Node
- O : Node
- V : Node
- Appl : Node
- C' : Node
- T' : Node
- v' : Node
- O' : Node
- V' : Node
- who : Node
- what : Node
- you : Node
- D : Node
- D' : Node
- Det : Node
- Dem : Node
- Poss : Node
- rel : Node
- rel' : Node
- P : Node
- N : Node
- N' : Node
Instances For
Equations
- Adger2025.instDecidableEqNode x✝ y✝ = if h : x✝.ctorIdx = y✝.ctorIdx then isTrue ⋯ else isFalse ⋯
Equations
- Adger2025.instFintypeNode = { elems := { val := ↑Adger2025.Node.enumList, nodup := Adger2025.Node.enumList_nodup }, complete := Adger2025.instFintypeNode._proof_1 }
Equations
- Adger2025.instReprNode = { reprPrec := Adger2025.instReprNode.repr }
Equations
- Adger2025.instReprNode.repr Adger2025.Node.C prec✝ = Repr.addAppParen (Std.Format.nest (if prec✝ ≥ 1024 then 1 else 2) (Std.Format.text "Adger2025.Node.C")).group prec✝
- Adger2025.instReprNode.repr Adger2025.Node.T prec✝ = Repr.addAppParen (Std.Format.nest (if prec✝ ≥ 1024 then 1 else 2) (Std.Format.text "Adger2025.Node.T")).group prec✝
- Adger2025.instReprNode.repr Adger2025.Node.v prec✝ = Repr.addAppParen (Std.Format.nest (if prec✝ ≥ 1024 then 1 else 2) (Std.Format.text "Adger2025.Node.v")).group prec✝
- Adger2025.instReprNode.repr Adger2025.Node.O prec✝ = Repr.addAppParen (Std.Format.nest (if prec✝ ≥ 1024 then 1 else 2) (Std.Format.text "Adger2025.Node.O")).group prec✝
- Adger2025.instReprNode.repr Adger2025.Node.V prec✝ = Repr.addAppParen (Std.Format.nest (if prec✝ ≥ 1024 then 1 else 2) (Std.Format.text "Adger2025.Node.V")).group prec✝
- Adger2025.instReprNode.repr Adger2025.Node.Appl prec✝ = Repr.addAppParen (Std.Format.nest (if prec✝ ≥ 1024 then 1 else 2) (Std.Format.text "Adger2025.Node.Appl")).group prec✝
- Adger2025.instReprNode.repr Adger2025.Node.C' prec✝ = Repr.addAppParen (Std.Format.nest (if prec✝ ≥ 1024 then 1 else 2) (Std.Format.text "Adger2025.Node.C'")).group prec✝
- Adger2025.instReprNode.repr Adger2025.Node.T' prec✝ = Repr.addAppParen (Std.Format.nest (if prec✝ ≥ 1024 then 1 else 2) (Std.Format.text "Adger2025.Node.T'")).group prec✝
- Adger2025.instReprNode.repr Adger2025.Node.v' prec✝ = Repr.addAppParen (Std.Format.nest (if prec✝ ≥ 1024 then 1 else 2) (Std.Format.text "Adger2025.Node.v'")).group prec✝
- Adger2025.instReprNode.repr Adger2025.Node.O' prec✝ = Repr.addAppParen (Std.Format.nest (if prec✝ ≥ 1024 then 1 else 2) (Std.Format.text "Adger2025.Node.O'")).group prec✝
- Adger2025.instReprNode.repr Adger2025.Node.V' prec✝ = Repr.addAppParen (Std.Format.nest (if prec✝ ≥ 1024 then 1 else 2) (Std.Format.text "Adger2025.Node.V'")).group prec✝
- Adger2025.instReprNode.repr Adger2025.Node.who prec✝ = Repr.addAppParen (Std.Format.nest (if prec✝ ≥ 1024 then 1 else 2) (Std.Format.text "Adger2025.Node.who")).group prec✝
- Adger2025.instReprNode.repr Adger2025.Node.what prec✝ = Repr.addAppParen (Std.Format.nest (if prec✝ ≥ 1024 then 1 else 2) (Std.Format.text "Adger2025.Node.what")).group prec✝
- Adger2025.instReprNode.repr Adger2025.Node.you prec✝ = Repr.addAppParen (Std.Format.nest (if prec✝ ≥ 1024 then 1 else 2) (Std.Format.text "Adger2025.Node.you")).group prec✝
- Adger2025.instReprNode.repr Adger2025.Node.D prec✝ = Repr.addAppParen (Std.Format.nest (if prec✝ ≥ 1024 then 1 else 2) (Std.Format.text "Adger2025.Node.D")).group prec✝
- Adger2025.instReprNode.repr Adger2025.Node.D' prec✝ = Repr.addAppParen (Std.Format.nest (if prec✝ ≥ 1024 then 1 else 2) (Std.Format.text "Adger2025.Node.D'")).group prec✝
- Adger2025.instReprNode.repr Adger2025.Node.Det prec✝ = Repr.addAppParen (Std.Format.nest (if prec✝ ≥ 1024 then 1 else 2) (Std.Format.text "Adger2025.Node.Det")).group prec✝
- Adger2025.instReprNode.repr Adger2025.Node.Dem prec✝ = Repr.addAppParen (Std.Format.nest (if prec✝ ≥ 1024 then 1 else 2) (Std.Format.text "Adger2025.Node.Dem")).group prec✝
- Adger2025.instReprNode.repr Adger2025.Node.Poss prec✝ = Repr.addAppParen (Std.Format.nest (if prec✝ ≥ 1024 then 1 else 2) (Std.Format.text "Adger2025.Node.Poss")).group prec✝
- Adger2025.instReprNode.repr Adger2025.Node.rel prec✝ = Repr.addAppParen (Std.Format.nest (if prec✝ ≥ 1024 then 1 else 2) (Std.Format.text "Adger2025.Node.rel")).group prec✝
- Adger2025.instReprNode.repr Adger2025.Node.rel' prec✝ = Repr.addAppParen (Std.Format.nest (if prec✝ ≥ 1024 then 1 else 2) (Std.Format.text "Adger2025.Node.rel'")).group prec✝
- Adger2025.instReprNode.repr Adger2025.Node.P prec✝ = Repr.addAppParen (Std.Format.nest (if prec✝ ≥ 1024 then 1 else 2) (Std.Format.text "Adger2025.Node.P")).group prec✝
- Adger2025.instReprNode.repr Adger2025.Node.N prec✝ = Repr.addAppParen (Std.Format.nest (if prec✝ ≥ 1024 then 1 else 2) (Std.Format.text "Adger2025.Node.N")).group prec✝
- Adger2025.instReprNode.repr Adger2025.Node.N' prec✝ = Repr.addAppParen (Std.Format.nest (if prec✝ ≥ 1024 then 1 else 2) (Std.Format.text "Adger2025.Node.N'")).group prec✝
Instances For
who cannot reach the matrix C directly; it subjoins to the embedded C', and from there
subjoins to C.
The embedded clause of (44).
Equations
Instances For
In every derivation, who leaves the embedded clause only as a 2-part of its C', which is
successive cyclicity.
Nominal islands #
In Who did you buy a statue of, (32), the object D is the 2-part of O; its 1-part is the
relational rel, with 2-part P and 1-part N. The 1-part of P is the wh-phrase D', whose
relational rel' has who as its 2-part, and who has subjoined to P.
Equations
- One or more equations did not get rendered due to their size.
Instances For
who is a 2-part of rel and cannot reach C from there, but it subjoins to the indefinite
D, becoming a 2-part of O, and then subjoins to C.
Subject islands #
The categories that bear [Fam] in English: Det[uD, Fam], Dem and the possessor, but not D.
Equations
- Adger2025.Fam x = (x = Adger2025.Node.Det ∨ x = Adger2025.Node.Dem ∨ x = Adger2025.Node.Poss)
Instances For
Equations
- Adger2025.instDecidablePredNodeFam x✝ = { decide := decide (x✝ = Adger2025.Node.Det) || decide (x✝ = Adger2025.Node.Dem ∨ x✝ = Adger2025.Node.Poss), reflects_decide := ⋯ }
T[uFam] is checked when, by Transitivity, a [Fam]-bearer is a 2-part of T.
Equations
- Adger2025.FamChecked P = ∃ (y : Adger2025.Node), P.NPart MereologicalSyntax.Parthood.Dim.two y Adger2025.Node.T ∧ Adger2025.Fam y
Instances For
Equations
- One or more equations did not get rendered due to their size.
Once who holds the 2-part of D, no derivation checks T[uFam]: the only path from a
[Fam]-bearer to T would run through who, which has no parts.
Well-formedness #
Every structure is one Subjoin could build: nothing is a part of itself, and only an object with a 1-part has a 2-part.
The data #
Extraction from a clausal complement, (43), is acceptable and derived; downward subjunction, (33), and extraction from a wh-island, (1b) of chapter 5, are not.
The structure of a row on extraction from a nominal or a subject: D's 2-part is free, or filled as the type of nominal requires.
Equations
- One or more equations did not get rendered due to their size.
Instances For
The mover of a row is P under pied-piping and who otherwise.
Equations
- Adger2025.moverOf e = if (e.feature? "pied-piping").isSome = true then Adger2025.Node.P else Adger2025.Node.who
Instances For
The structures and movers of the rows.
Equations
- One or more equations did not get rendered due to their size.
Instances For
The rows on extraction from nominals and subjects, (31)–(44) of chapter 6 and (59) of
chapter 7: the mover reaches C exactly in the acceptable ones.