Make no particle chain in a part that holds no name word (#636) (#639)

A part past the second comma, after either comma, reads wholly as
suffixes with its title words as titles (C2), but group still ran the
particle chain over it, building a name unit no reading uses: `John
Smith, Jr., van der Berg Prof.` read suffix 'Jr., van der Berg Prof.'
where `John Smith, Jr., Prof.` reads title 'Prof.'. Group now makes no
chain there and asks no bound for one, so C2 reads every title word in
the part, bare or mid-part. Decided (Derek): this, rather than #623's
trailing-title bound the issue proposed. The part after a suffix comma
had reached no chain since #613; the tail half of group's report
handoff, dead with no chain there, is removed.

Measured against 3b2b6f0: 18,318 parses on 6,106 texts of #624's
comma-tail grid move, 15,330 a title word into the title field and
2,988 a particle back out of a title the chain had joined; no corpus
name, case text or other grid moves. Five gates exit 0. Tail parts cost
fewer frames. Rows pin the suffix-comma, family-comma and empty-head
tails. Follow-ups: #640, #641.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

Author: derek73

AGENTS.md

@@ -2080,15 +2080,18 @@ C2. Rationale: text beyond the recognized comma parts should be
     about reading a word of it as a name, whether it is the part
     after a suffix comma (C1) or a part beyond the second: nothing
     in it is read as one, a maiden marker there being an ordinary
-    word (M2), so a particle chain run over it (P2) reports neither a
-    particle chained onto a name word nor an acronym taken into the
-    name. What such a part reports is its own — C1's flip and this
-    rule's flag.
+    word (M2), and no particle chain (P2) is made in it, so a title
+    word behind a particle run there is a title like any other, and
+    the part reports neither a particle chained onto a name word nor
+    an acronym taken into the name. What such a part reports is its
+    own — C1's flip and this rule's flag.
       "John Smith, MD, Bart"      →  suffix="MD, Bart"
       "Eric H. Holder, Jr., Attorney General"  →  title="Attorney General"
       "Eric H. Holder, Jr., Attorney General"  →  ambiguities=()
       "Eric H. Holder, Jr., Secretary of State"  →  ambiguities=("comma-structure",)  · boundary
       "Smith, John, Prof."        →  title="Prof."
+      "John Smith, Jr., van der Berg Prof."  →  title="Prof."
+      "John Smith, Jr., van der Berg Prof."  →  suffix="Jr., van der Berg"
       "John Smith, Jr., Lt.Gov."  →  ambiguities=()
       "John Smith, MD, Ms"        →  suffix="MD, Ms"  · boundary
       "John Smith, MD,, Jr."      →  suffix="MD, Jr."  · boundary
@@ -2099,10 +2102,12 @@ C2. Rationale: text beyond the recognized comma parts should be
       "Steven Hardman, MD, DO, DDS"  →  ambiguities=()
       "STEVEN HARDMAN, MD, DO, DDS"  →  ambiguities=("comma-structure",)  · boundary
       "John Smith, MD, XYZ"  unlisted_caps_suffixes-everywhere  →  ambiguities=("comma-structure",)
-    Accepted: the no-name-reading clause carries no example line of
-    its own. What it moves is a report with no field beside it, and
-    an example line would enter the rules corpus for that report
-    alone; its executable witnesses are the case rows
+    Accepted: the no-name-reading clause's REPORT half carries no
+    example line of its own. What it moves is a report with no field
+    beside it, and an example line would enter the rules corpus for
+    that report alone; its title half is witnessed by the two `John
+    Smith, Jr., van der Berg Prof.` lines above, and its report half's
+    executable witnesses are the case rows
     a_credential_run_after_the_comma_reports_no_chain_fork and
     a_part_past_the_second_reports_no_particle_fork in
     tests/v2/cases.py, read beside the two rows the chain still

docs/design/decisions.md

@@ -44,7 +44,7 @@ Release Log
 
     - **Fix a comma part read as credentials being taken apart again by a later join.** ``HumanName("John Smith, Ph. D. and Mary Jones")`` gives first ``John``, last ``Smith``, suffix ``Ph. D. and Mary Jones``, where 2.3.0 gave first ``Ph. D. and Mary``, middle ``Jones``, last ``John Smith``, and ``parse()`` reports each name word the part took: the parser now decides once, after every word is recognized, whether the part after a comma holds the credentials, and nothing joins across that decision afterwards. Titles joined by ``and`` stay one title (``John Smith, Mr. and Mrs.`` keeps title ``Mr. and Mrs.``). A surname joined by ``y`` counts as its words, as #575 already counted it in front of a credential: ``Ortega y Gasset, Dr.`` gives title ``Dr.``, first ``Ortega``, middle ``y``, last ``Gasset``, where 2.3.0 gave last ``Ortega y Gasset``. And a surname with a suffix in it before the comma is the surname, as ``Smith Jr., John`` always read it: ``Smith Jr., Esq.`` gives last ``Smith``, suffix ``Jr., Esq.``, where 2.3.0 gave first ``Smith``, and ``Smith Jr., V`` gives first ``V``, last ``Smith``, suffix ``Jr.``, where 2.3.0 gave first ``Smith``, suffix ``Jr., V``. See the #613 entry under ``C1`` in ``docs/design/decisions.md`` (closes #613)
 
-    - **Change a title word in a part after a second comma to read as a title.** ``HumanName("Eric H. Holder, Jr., Attorney General")`` gives title ``Attorney General``, suffix ``Jr.``, where 1.4.0 through 2.3.0 gave suffix ``Jr., Attorney General``, and the part no longer reports ``comma-structure``. A word that is also a suffix stays a suffix (``John Smith, MD, Ms``). A title joined by a connective is read as a title, but its part keeps the report (``Secretary of State``). Since the part's words can land in two fields, the report no longer names one: ``parse("John Smith, Jr., Dr. Bart")`` reports its last part as "beyond the recognized comma structures; read best-effort", where 2.3.0 said "consumed as suffix best-effort". (#603, closes #629)
+    - **Change a title word in a part after a second comma to read as a title.** ``HumanName("Eric H. Holder, Jr., Attorney General")`` gives title ``Attorney General``, suffix ``Jr.``, where 1.4.0 through 2.3.0 gave suffix ``Jr., Attorney General``, and the part no longer reports ``comma-structure``. A word that is also a suffix stays a suffix (``John Smith, MD, Ms``). A title joined by a connective is read as a title, but its part keeps the report (``Secretary of State``). Since the part's words can land in two fields, the report no longer names one: ``parse("John Smith, Jr., Dr. Bart")`` reports its last part as "beyond the recognized comma structures; read best-effort", where 2.3.0 said "consumed as suffix best-effort". A title word behind a surname particle run there reads as a title too: ``HumanName("John Smith, Jr., van der Berg Prof.")`` gives title ``Prof.``, suffix ``Jr., van der Berg``, where 1.4.0 through 2.3.0 gave suffix ``Jr., van der Berg Prof.``. (#603, closes #629, #636)
 
     - **Add the Catalan and Polish surname link.** ``parse("Josep Carod i Rovira")`` gives family ``Carod i Rovira``, where every release from 1.4.0 through 2.3.0 gave middle ``Carod i`` with family ``Rovira``; ``Josep Lluis Carod i Rovira`` gives middle ``Lluis`` with that same family; and ``Carod i Rovira, Josep`` gives it too, where they read family ``Carod Rovira`` and took the link into ``suffix`` as a generation marker. ``i`` is connective vocabulary now, the way ``y`` already was, and a connective counts as a name word wherever the three-word carve-out counts them -- whatever else the vocabulary says the word is, which matters here because ``i`` is also the roman numeral. A connective that is also generational vocabulary joins only where a name word stands on each side of it, so ``John Quincy Smith i`` keeps suffix ``i``, ``Josep Lluis Carod i III`` keeps suffix ``i III``, and the two-word ``Carod i`` keeps its generation reading. Written wholly in one case the letter reads as an initial and says so: ``JOSEP CAROD I ROVIRA`` and ``josep carod i rovira`` keep the fields they had and gain a ``conjunction-or-initial`` report, which a one-case name gains wherever a bare ``i`` or ``I`` stands among the name's own words -- a letter inside a maiden clause is read by the clause's rules and stays silent, as ``e`` already was -- and in an all-lower name that reading can move a field, each such name now reading as its all-caps twin already did (``parse("john smith i jr")`` gives middle ``smith``, family ``i`` and suffix ``jr`` where it gave family ``smith`` and suffix ``i jr``). Case repair follows the reading: a lower-case ``i`` the parse read as the generation is still title-cased by ``capitalize(force=True)`` (``Carod i`` gives ``Carod I``, as every release did), while one standing among the name words keeps its lower case as ``y`` always has (``Carod i Rovira`` gives ``Carod i Rovira``, where ``Carod I Rovira`` was the pre-2.4 answer). A link inside a maiden clause stays in the birth name, which no release read that way: ``HumanName("Jane Doe nee Puig i Soler")`` gives maiden ``Puig i Soler`` with last ``Doe``, where 2.0 through 2.3 ended the birth name at the link and gave maiden ``Puig`` with middle ``Doe i``, last ``Soler`` -- and the same words would have joined into last ``Doe i Soler`` under the change above, carrying a word of the birth name into the current surname. ``Jane Doe née Kowalska i Nowak`` moves with it, as does the all-lower ``jane doe nee puig i soler``; the ``y`` spelling always read this way and is untouched. The link still has to be joining: ``Jane Doe nee Puig i`` keeps maiden ``Puig`` with suffix ``i``, and ``Jane Doe nee Puig i III`` suffix ``i III``. A caller with Catalan or Polish data removes the entry from ``conjunctions_ambiguous`` and gets the join in the one-case names too; a caller who wants none of this removes ``i`` from ``conjunctions``, which restores every prior FIELD and every prior report, with two readings it does not restore and cannot: a letter the two vocabularies disagree about being an initial reads as one here and as the generation there, and case repair leaves a connective the parse placed among the NAME words in lower case where the off switch title-cases it -- ``parse("Dr. John i Smith").capitalized(force=True)`` keeps ``i`` where the off switch gives ``Dr. John I Smith``, and ``Carod i Rovira`` and ``Josep i Rovira`` are the same shape. Those two are the whole of what the switch does not undo, and ``tests/v2/test_properties.py`` states them as its invariants' only exemptions. A delimiter the caller declares through ``Policy(extra_suffix_delimiters=...)`` parts a trailing suffix part as a comma does (see the suffix-delimiter entry below), so no link joins across one: under ``(" - ",)``, ``Smith, John, PhD - i Soler`` keeps suffix ``PhD, i Soler``, as 2.3.0 read it. The default policy declares no such delimiter. See the ``P3`` and ``M2`` entries of ``docs/design/decisions.md`` (closes #397, closes #538)
 

docs/design/rules.md

@@ -917,8 +917,16 @@ def _group_segment(seg: tuple[int, ...], additional: int,
         # #623). The bound matters only where a particle stands past the
         # chain's lead, so it is not asked otherwise: the chain then
         # merges nothing (the test is `is_prefix_piece`'s, inline).
+        # rules.md#C2: "a part past the second comma holds no name word"
+        # -- assign reads such a part wholly as suffixes and its title
+        # words as titles, so the chain builds no name unit there and is
+        # not run, and a title word behind a particle run stays a word
+        # C2 can read ('John Smith, Jr., van der Berg Prof.', #636). The
+        # part after a suffix comma reaches no chain either: `_comma.
+        # decide` binds it and empties its segment before any join
+        # (#613).
         chains = False
-        if read is None:
+        if read is None and site is not ClauseSite.TAIL:
             for k in range(leading + 1, len(pieces)):
                 if ("prefix" in ptags[k]
                         or len(pieces[k]) == 1
@@ -1107,8 +1115,9 @@ def chain(tail: int) -> None:
         # `tail` is 0, so none of what follows runs, as it does not
         # where no particle stands past the lead (#623); it is the path
         # for the segments that read no run above -- a family comma's
-        # parts, a part past the second comma, a run with a name piece
-        # inside it -- and the given part reaches it still
+        # two name parts and a run with a name piece inside it (a part past the
+        # second comma makes no chain, #636) -- and the given part
+        # reaches it still
         # ('Smith, Freiherr van Berg X.Y.Z.', the row that holds it).
         #
         # The peel was read over the pieces as they stand, and the
@@ -1141,7 +1150,7 @@ def chain(tail: int) -> None:
                 pieces[:], ptags[:] = kept[0], kept[1]
                 del ambiguities[kept[2]:]
                 chain(left)
-        else:
+        elif site is not ClauseSite.TAIL:
             chain(0)
             if read is not None and took:
                 # built, not `_replace`d: two frames a call
@@ -1320,16 +1329,12 @@ def group(state: ParseState) -> ParseState:
             bound_join = BoundJoin.STRICT
         # Suppressed after a family comma for the same reason _assign
         # suppresses it there: the family name is already fixed, so
-        # there is no fork left to report. Suppressed in a tail segment
-        # as well, after either comma: assign reads that segment as
-        # suffixes and its title words as titles (#603), never as a
-        # name, a marker standing in it being an ordinary word
-        # (rules.md#M2, #601), so a
-        # chain report there -- a particle
-        # chained onto a name piece, or an acronym taken into the name
-        # -- names a reading the parse never takes. rules.md#C2: "a part
-        # the parse consumes wholly as suffixes raises no report about
-        # reading a word of it as a name"
+        # there is no fork left to report. A tail segment needs no
+        # suppression: group makes no particle chain there (#636) and
+        # takes no maiden clause (rules.md#M2, #601), so nothing in group
+        # reports in one. rules.md#C2: "a part the parse consumes wholly
+        # as suffixes raises no report about reading a word of it as a
+        # name"
         tail = tail_start is not None and seg_idx >= tail_start
         # #601: where a maiden clause would stand, off the three facts
         # already in hand here -- which decides whether a marker counts
@@ -1382,7 +1387,7 @@ def group(state: ParseState) -> ParseState:
         for part in parts:
             part_pieces, part_ptags, taken = _group_segment(
                 part, additional, tokens, bound_join,
-                None if (family_comma or tail) else ambiguities,
+                None if family_comma else ambiguities,
                 state.lexicon.given_name_titles,
                 opens_the_name=(seg_idx == 0 and not family_comma),
                 one_case=state.one_case,

docs/release_log.rst

@@ -2109,10 +2109,11 @@ def _check_cjk_shape_purity(self) -> None:
          ambiguities=("comma-structure",),
          notes="the row above as a part past the second comma, which "
                "is consumed as suffixes but for its title words (C2): "
-               "'von' still chains in group, but it ends a suffix, so "
-               "the particle-or-given report that 'von' was chained "
-               "onto a name piece named a reading the parse never "
-               "makes. Every 2.x release through 2.3.0 carried it; the "
+               "'von' ends a suffix, so the particle-or-given report "
+               "that 'von' was chained onto a name piece named a "
+               "reading the parse never makes, and since #636 group "
+               "makes no chain in the part at all. Every 2.x release "
+               "through 2.3.0 carried the report; the "
                "comma-structure flag is the part's own report. Since "
                "#603 'Freiherr', a title word, reads as the title it "
                "is there; until then the part read wholly as suffix "
@@ -3030,16 +3031,49 @@ def _check_cjk_shape_purity(self) -> None:
                "and the emitter's `j > k + 1` floor is what both have "
                "to clear",
          shape=1),
+    Case("a_title_behind_a_particle_run_past_the_second_comma",
+         "John Smith, Jr., van der Berg Prof.",
+         {"title": "Prof.", "given": "John", "family": "Smith",
+          "suffix": "Jr., van der Berg"},
+         ambiguities=("comma-structure",),
+         classification="fix(#636)",
+         notes="a part past the second comma holds no name word "
+               "(rules.md#C2), so group makes no particle chain in it "
+               "and the title word behind 'van der' is a title as in "
+               "'John Smith, Jr., Prof.'; the chain from 'der' had "
+               "taken it into the suffix (1.4.0 and 2.3.0 read suffix "
+               "'Jr., van der Berg Prof.')"),
+    Case("a_title_behind_a_particle_run_after_a_family_comma_tail",
+         "Smith, John, van der Berg Prof.",
+         {"title": "Prof.", "given": "John", "family": "Smith",
+          "suffix": "van der Berg"},
+         ambiguities=("comma-structure",),
+         classification="fix(#636)",
+         notes="the row above after a FAMILY comma: the part past the "
+               "second comma holds no name word there either (rules.md#C2) "
+               "and makes no chain (#636's review: a chain kept after a "
+               "family comma alone passed every other test); 1.4.0 and "
+               "2.3.0 read suffix 'van der Berg Prof.'"),
+    Case("a_title_behind_a_particle_run_after_an_empty_head_tail",
+         ",, van der Berg Prof.",
+         {"title": "Prof.", "suffix": "van der Berg"},
+         ambiguities=("comma-structure",),
+         classification="fix(#636)",
+         notes="the empty head (AGENTS.md's comma sweep): the part past "
+               "the second comma makes no chain, so the title word is a "
+               "title (rules.md#C2, #636); 1.4.0 and 2.3.0 read suffix "
+               "'van der Berg Prof.'"),
     Case("a_credential_run_after_the_comma_reports_no_chain_fork",
          "John Smith, PhD Do Ma",
          {"given": "John", "family": "Smith", "suffix": "PhD Do Ma"},
          ambiguities=("suffix-or-name",),
          notes="the row above behind a suffix comma: the part after it "
                "is the credential run C1 flips to, and assign reads a "
                "tail segment wholly as suffixes, so 'Ma' ends a suffix. "
-               "The chain still runs there ('Do' takes 'Ma') but may "
-               "not report taking it into the name, a reading the "
-               "parse never makes (rules.md#C2); the one report is "
+               "The chain may not report taking it into the name, a "
+               "reading the parse never makes (rules.md#C2), and since "
+               "#613 it is not run in the part at all, decide binding the "
+               "part before any join; the one report is "
                "C1's flip over the whole part. Carried a second, "
                "contradicting suffix-or-name on 'Ma' until 2026-09-28. "
                "1.4.0 read the same fields; 2.3.0 read given 'PhD', "