[dmarx]

Closes #371. Decision: ADR-tmpfdvjo, A chain may walk a named path pattern (Proposed).

What it does

A record may declare named path patterns in Cypher's pattern syntax, and a chain may walk one wherever it walks a field:

patterns:
  follows_from: (b:CLAIM)<-[:concludes]-(i:INF)<-[:premise_of]-(a:CLAIM)
chains:
  argument: {scheme: CLAIM, relation: follows_from, output: docs/argument.md}

• Meaning. Node labels are schemes and edge types are reference fields. A hop holds when the relation does, as held/4 reads it (converse side included).
• The subset. One label per node (or a bare back-reference), | between fields, variable length (*, *2.., *..3), property maps, and WHERE NOT followed by a fixed path.
  • MATCH, RETURN, OPTIONAL MATCH, undirected or named edges, shortest paths and writes are refused by name.
• Engine. luria parses patterns with its own lark grammar (luria/patterns.lark) and lowers them to clingo over the record's facts (luria/pattern_rules.py), so the logic core stays the one engine. Every program is stratified, so there is one answer set.
• Load-time checks (consistency.lp):
  • labels are schemes;
  • each hop is declared on the node it leaves and can land on the next label;
  • closures stay within one scheme;
  • properties are fields the scheme can hold;
  • no pattern shares a reference's name;
  • a chain's pattern starts and ends on the chain's scheme and has a hop.
• On the chain page:
  • a step reads like a field: the first node nests under the last;
  • named inner nodes render as "— through INF-004";
  • other parents are named by the pattern ("— also follows from CLAIM-002", via Name a chain step's other parents by the relation that holds them #359);
  • a chain invariant covers pattern steps, and cycles are the existing finding;
  • a partial match is no step, and luria derives nothing from it.

Removed during review: built-in "Open"

An earlier commit listed partial matches that couldn't be completed under Open on each chain page. Tried on dmarx/nucleation, it named six arguments, all of them complete. They rest only on grounds, which nucleation's premises field group allows. Whether a partial match is unfinished depends on the schema, so a record states it as a pattern of its own:

unfinished: (i:INF)<-[:premise_of]-(:CLAIM) WHERE NOT (i)-[:concludes]->(:CLAIM)

Rendering such a pattern as a list of its matches is #373.

Files

• New: luria/patterns.py, luria/patterns.lark, luria/pattern_rules.py, examples/argument-map/.
• Changed:
  • config.py: the patterns family, NamedPattern;
  • consistency.py and .lp;
  • chains.py;
  • invariants.py and .lp;
  • logic/__init__.py: derive(extra=..., families=...) for generated programs;
  • facts.py: pattern/1;
  • config_doc.py;
  • tools/wheel_smoke.py: proves the wheel carries the grammar;
  • pyproject.toml: lark>=1.2,<2.
• Record: ADR-tmpfdvjo, the 2026-10-13 devlog (design path, Cypher→Datalog tool survey, what building and the nucleation trial corrected), a changelog fragment, and a paragraph in docs/project-memory.md.

Verification

• python -m pytest tests -q after merging main (with Name a chain step's other parents by the relation that holds them #359): 1769 passed, 33 skipped.
• luria lint: clean at the root (which includes examples/*) and in examples/argument-map on its own.
• dmarx/nucleation, unchanged: all 625 files luria index writes are byte-identical between main and this branch, and so is luria lint with lint.network: never set in both copies.
• dmarx/nucleation, with a pattern: argued_from: (c:CLAIM)<-[:concludes]-(g:ARG)-[:rests_on]->(p:CLAIM) WHERE NOT (g {status: 'Rejected'}) on its argument chain draws the steps through ARG-006, ARG-007 and ARG-008, each "through" its argument. They were invisible to a chain over rests_on.
• examples/argument-map: steps render "through" their inference, and uncontested.md drops the step OBJ-001 challenges.
• Wheel built and tools/wheel_smoke.py passes; luria/patterns.lark is in the wheel.

Merge with #359

#359 merged first. The conflict in chains._load and _line_block was resolved by keeping both sides: #359's per-edge relation tracking runs beside the pattern-aware _edges, and a step's tail carries "through" before #359's _also. A pattern has no label, so its name reads in that place, and tests/test_pattern_chains.py pins it.

🤖 Generated with Claude Code

https://claude.ai/code/session_016xS6nL8ZZpTh1jMSvaTRks