# Finite lineage challenge — preparation draft

**Status: PREPARATION ONLY.** This is a working design note following D-0021. It does not open Cycle 03, create a package or Test, commit resources, freeze source or inputs, or authorize execution. The eight structural templates and the proposed state-equality sensitivity set below remain design proposals; no machine-readable candidate corpus has been generated and no candidate query outcomes have been computed. A separate synthetic software-only probe is recorded below; its answer outputs were not retained or inspected.

## Proposed question and boundary

For the two registered RP006 inquiry families, do the same eight whole-field masks over state (`S`), complete direct-parent sets (`P`), and birth operation (`K`) remain sufficient when the comparison corpus contains newly authored, valid lineage logs with four and five entities and both repeated and distinct state payloads?

This is a finite challenge to the transfer of RP006's classifications from six disclosed three-entity constructions to a separately specified corpus. A same-projection/different-answer pair falsifies sufficiency for any declared corpus containing that pair. No conflicts would establish only the finite classification of the reviewed corpus and mask/query class; it would not establish universal, probabilistic, natural-population, or bit-optimal sufficiency.

The registered queries remain unchanged: `same_state`, strict `ancestor`, `shared_root`, `parents`, `birth_kind`, and `alive` for `FULL`; the first four for `TOPOLOGY_STATE`. The eight masks remain `000` through `111` with the existing field meanings. Entity IDs are public and aligned within each stratum, as in RP006. Compare cases only within a stratum; four- and five-entity query universes are not pairwise aligned with one another.

### Decision value of the two inquiry families

The intended representation decision is conditional on two distinct uses. `FULL` represents an archive or audit view that must reproduce all six registered answers, including `birth_kind` and `alive`; any conflict rejects that mask for this use on the declared corpus. `TOPOLOGY_STATE` represents a narrower analysis that consumes only `same_state`, strict `ancestor`, `shared_root`, and `parents`; its value is to determine whether that use permits a smaller retained-field mask than the full audit use. A conflict rejects the mask for that narrower use, while no conflict supports only its finite classification on the declared cases. Because `TOPOLOGY_STATE` is a subset of `FULL`, retain both only if both uses are real and the narrower profile can change a field-retention decision. The entry reviewer must accept or remove this distinction before inputs or query outcomes exist; outcomes cannot select the query family set.

## Candidate finite scope

The proposed design has two entity-count strata (4 and 5) and four fixed structural templates in each. These eight templates form a purposive finite stress grid, not a sample or a minimal cover of either stratum. Their intended contrasts are: continuation beside a disconnected root; a branch following continuation; copy followed by a merge with an independent root; asymmetric development from two roots; unequal branch depth; a merge that leaves a branch sibling live; distinct state changes across independently rooted lines before merging; and a continuing line with a retained copy that merges with an independent root. These motifs target distinctions queried by `ancestor`, `shared_root`, `parents`, `birth_kind`, and `alive`; they do not establish that all relevant motifs are covered. The state-equality variants separately probe `same_state` and its interaction with masks. The templates must be checked against the six RP004 fixtures so overlap and any reused motifs are explicit. This is a proposed design, not an authored case inventory.

### Proposed template grid for structural review

The following event notation omits states: `root(x)`, `continue(x→y)`, `copy(x→y)`, `fork(x→y,z)`, and `merge(x,y→z)`. IDs are the public aligned IDs within each stratum. The sequences are proposals, not frozen event-log inputs. Their intended order is part of each template.

| Slot | Entities | Ordered event structure | Motif |
| --- | ---: | --- | --- |
| F4-01 | 4 | `root(a); copy(a→b); continue(b→c); root(d)` | A copied lineage continues; a separate root supplies an unrelated component. |
| F4-02 | 4 | `root(a); continue(a→b); fork(b→c,d)` | A continued entity branches into two live leaves. |
| F4-03 | 4 | `root(a); copy(a→b); root(c); merge(b,c→d)` | A copy-derived entity merges with an independently rooted entity. |
| F4-04 | 4 | `root(a); root(b); copy(b→c); continue(a→d)` | Two roots develop differently, with a copy on one side and a continuation on the other. |
| F5-01 | 5 | `root(a); continue(a→b); fork(b→c,d); continue(c→e)` | A nested branch has unequal descendant depth. |
| F5-02 | 5 | `root(a); root(b); fork(a→c,d); merge(b,c→e)` | A branch is partly merged with an independent root; its other branch remains live. |
| F5-03 | 5 | `root(a); copy(a→b); root(c); continue(c→d); merge(b,d→e)` | Two independently rooted lines, with different operations, meet in a merge. |
| F5-04 | 5 | `root(a); root(b); continue(b→c); copy(c→d); merge(a,d→e)` | A two-step line meets a separate root, with a retained copy on the line. |

For a first legality pass, state vectors are listed in ID order and use opaque labels `A`, `B`, and `C`. These are proposed controls, not outcome-derived assignments. They obey the existing rule that `copy` and both `fork` outputs preserve the relevant parent's state; `continue` and `merge` may emit another opaque value.

| Slot | Proposed state vector (`a,b,c,d[,e]`) | Coverage role |
| --- | --- | --- |
| F4-01 | `(A,A,B,A)` | Repetition, a changed continuation, and equal values on unrelated roots. |
| F4-02 | `(A,B,B,B)` | A changed continuation followed by state-preserving fork outputs. |
| F4-03 | `(A,A,B,B)` | Distinct values, with a merge output sharing the independent root's value. |
| F4-04 | `(A,A,A,A)` | Repeated values across unrelated roots. |
| F5-01 | `(A,B,B,B,C)` | A changed continuation and unequal branch depth, with fork state preserved. |
| F5-02 | `(A,B,A,A,B)` | Distinct values across roots, with the fork preserving `a` and the merge output assigned `B`. |
| F5-03 | `(A,A,B,C,A)` | Copy preservation and a changed continuation across distinct payloads, using at most three labels. |
| F5-04 | `(A,B,C,C,A)` | A changed continuation, copy preservation, and a merge output sharing `a`'s value. |

An in-memory, schema-only check using the existing RP004 construction grammar accepted all eight proposed event logs and their copy/fork state constraints. A separate ID-permutation comparison found no duplicate full event structures within either count stratum. The earlier prefix-only comparison was too narrow: candidates contain several parent-closed three-entity RP004 motifs, but parent closure alone does not make a fork-containing subset a replayable operation-closed sublog. The preliminary overlap audit below separates those criteria. Before entry, an independent reviewer should repeat the structural check and decide which overlap criterion is relevant to the transfer question.

The vectors above are illustrative members of the proposed state-equality sets, not the complete inputs. They give examples of repeated and distinct payloads, equal labels on unrelated roots, and changed values along connected lineages. They do not establish motif coverage or show that either inquiry family is sufficient for the research decision.

State assignment is a separate, predeclared factor. A global bijective renaming of opaque values cannot change equality-based `same_state` answers, so the sensitivity set varies equality partitions rather than label spellings. The proposed design enumerates every admissible partition using at most three opaque values for each fixed topology, subject to `copy` and `fork` preserving the parent's state. This produces 17 F4 and 38 F5 case variants. It is an exhaustive finite sensitivity set over these eight topologies and this three-value bound; it is not exhaustive over state spaces, lineage constructions, or natural populations. No variant may be selected or removed after outcomes are seen. Values may not encode a case, event position, answer, or intended conflict.

The deterministic enumeration rule is: form the forced-equality components induced by `copy` and `fork`; enumerate set partitions of those components into one, two, or three blocks; order blocks by first occurrence in entity-ID order; and enumerate the resulting restricted-growth strings lexicographically. Assign the canonical values `A`, `B`, and `C` to those ordered blocks, consistently across every case in both strata. The same symbol therefore denotes the same opaque value in all cases; no case may receive a separate arbitrary bijective relabeling before projection comparison. This is a fixed cross-case alignment convention, not a sensitivity analysis over all possible cross-case alignments. Case IDs combine the fixed topology slot with that stable partition ordinal. Producer inputs contain only the case ID and the event log with its assigned state payloads; topology/motif explanations and partition labels remain in review material, not as producer-side metadata. The independent reviewer must reproduce the enumeration and counts without computing query answers.

For the proposed sensitivity set, the eight topologies yield 17 admissible F4 cases and 38 admissible F5 cases (55 total). The expected work from the query inventory alone is 4,440 `FULL` truth rows, 440 projections (8 masks × 55 cases), 6,712 within-stratum case-pair/mask comparisons, and 32 family/mask certificates (2 query families × 8 masks × 2 strata). `TOPOLOGY_STATE` reuses the relevant subset of each case's truth rows. These are protocol arithmetic for a proposed design, not measured runtime, a resource commitment, or a run plan.

A second, locally written enumeration on 2026-10-14 independently generated restricted-growth strings over the entity positions (up to three blocks) and filtered only the copy/fork equality constraints. It reproduced per-slot counts `5, 2, 5, 5` and `5, 5, 14, 14`, then recomputed 55 cases, 4,440 `FULL` rows, 440 projections, 6,712 pair/mask comparisons, and 32 certificates. It did not construct event inputs, calculate answers, or inspect sufficiency/conflict outcomes. This is an internal cross-check using a different enumeration route, not the independent review required before entry; the external reviewer must still reproduce it.

## Construction and independence controls

- Reuse only the existing event grammar (`root`, `continue`, `copy`, `fork`, `merge`) if the entry review confirms that this is the intended domain. Every input must be a live prior entity; entity IDs must be fresh; operation arities and consumption rules must hold; the acyclic history is the ordered event log.
- Store only case identifiers and event logs in the candidate source. Do not store expected answers, mask verdicts, conflict labels, or per-case descriptive labels in producer input.
- Fix the structural slot definitions and state-payload assignment rule before materializing cases or inspecting their query outcomes. If generation uses a seed, commit the seed policy and generator before generating the final corpus; otherwise specify the deterministic enumeration and selection rule.
- Reconstruct truth directly from the event log in a verifier that does not import producer/query-generation/projection code. Independently enumerate the complete query inventory and check types as well as values.
- Preserve the equality-gated criterion: compare full answers only when canonical projections are exactly equal; record every differing aligned answer as a conflict witness. Retain all no-conflict, conflict, and incomparable minimal-mask outcomes.
- Include validation controls for invalid parent availability, duplicate/future parents, invalid event arity, copy/fork state violations, and an entity count outside the declared strata. Controls test implementation behavior; they do not become additional research cases.
- Compare the final candidate inventory structurally and by hash against the six old fixtures. Report overlap and the rule used to exclude simple extensions before entry review.

## Candidate input, verifier, and evidence contract

This section specifies a review target only. It does not create the candidate inputs, freeze a schema, or authorize a producer run.

### Input boundary

Use two separate future input documents: one for 17 four-entity cases and one for 38 five-entity cases. Each document should contain only a case identifier and its ordered event log, with state payloads attached to the corresponding event output under the accepted RP004 grammar. The public entity universe is `a`–`d` or `a`–`e`, respectively, and must be common to all cases in that document. Keeping strata as separate inputs makes cross-size comparison impossible by construction; a later evidence manifest may label the stratum but must not merge their comparison universes. Do not put expected query answers, mask results, conflict expectations, motif/coverage labels, or prose explanations in producer input. The illustrative vectors and all 55 variants remain review material until a separate input-freeze decision.

Before any future run, validate exact keys and types, unique case IDs, exact entity coverage, ordered event legality, and the copy/fork state-preservation rule. Reject unknown fields and malformed values rather than silently normalizing them. Hash the exact input bytes. Candidate identity and case ordering must be fixed before answer inspection; deterministic ordering should be by case ID, query family, mask, and canonical query key. The exact JSON canonicalization and byte-level serialization rules must be declared and versioned before freeze.

### Independent verifier boundary

The proposed verifier may rely on the accepted event semantics and replay domain, but it must independently reconstruct the entity facts and enumerate the registered query inventory. It must not import or call the future producer, its query enumerator, projection builder, conflict scanner, or certificate builder; it must not consume producer-generated truth rows as ground truth. The verifier should independently check input validity, truth rows, projected retained fields, all within-stratum pair/mask equality decisions, every equality-gated answer comparison, every conflict witness, certificate partitions and minimality claims, summary counts, and hashes. Producer and verifier should be authored and source-hashed separately, preferably by different people. They must not share a parser, domain-semantics implementation, query enumerator, projection builder, truth cache, conflict scanner or certificate logic. Use separate parsing and data reconstruction paths. If generic third-party runtime or serialization libraries are common to both, disclose them and verify that they contain no shared RP004/RP006 semantics. A disagreement is a failed verification, preserved with both outputs for diagnosis; it must not be resolved by editing expected answers or dropping a case after observing outcomes.

### Coverage arithmetic and edge handling

For the proposed 55-case inventory, the exact structural workload is:

| Stratum | FULL truth rows | Projections | Pair/mask comparisons | Family/mask certificates |
| --- | ---: | ---: | ---: | ---: |
| 4 entities × 17 cases | 1,020 | 136 | 1,088 | 16 |
| 5 entities × 38 cases | 3,420 | 304 | 5,624 | 16 |
| Total | 4,440 | 440 | 6,712 | 32 |

The per-case `FULL` query count is `3n² + 3n` (ordered pairs for the three pairwise families and one row per entity for the three unary families). `TOPOLOGY_STATE` reuses the truth rows for its registered first-four-family subset. The 1,088 and 5,624 comparison records are present even when projections differ; for each pair/mask record, projection equality is shared, but answer-comparison status and conflict/no-conflict findings are recorded separately for each inquiry family. Answer checks are performed only for equal projections, and their number is outcome-dependent. Pairs sharing one structural topology but differing in state partition remain valid within-stratum pairs and must be tagged as such in verifier-side summaries, not used to inflate the count of distinct topologies. No cross-stratum pairs are valid. These counts are protocol arithmetic, not query outcomes or measured work.

Each equal-projection comparison must retain all differing query answers, not just the first witness. An equal projection with no differing answer is recorded as an observed no-conflict pair; a non-equal projection is recorded as not answer-compared. Certificates must preserve the full equivalence partition for each mask/family, mark a partition's common answer vector only when all members agree, and record an explicit conflict state otherwise. Compute sufficiency and inclusion-minimality over all eight masks, retaining incomparable minimal masks. The protocol must not assume in advance that a conflict exists or that any particular mask is sufficient.

Coverage checks should independently assert: all 17 F4 and 38 F5 case IDs appear exactly once; every topology has exactly its full admissible equality-partition set; all eight masks occur per case; each expected family/query row occurs exactly once; every unordered pair in a stratum appears for every mask; all 32 certificate family/mask/stratum combinations exist; and the verifier rejects each invalid-input control listed above. Invalid-input controls are kept outside the research corpus and never counted in the table. Missing rows, duplicate rows, mismatched hashes, an omitted or duplicate partition, or a comparison across different strata invalidates the evidence package.

### Future evidence inventory

If a later decision authorizes execution, the reviewed output contract should include:

- a manifest with protocol/schema versions, stratum, case/entity counts, exact input and source hashes, query/mask configuration, and deterministic ordering rules;
- complete truth rows, with query family/key and typed answer;
- all case/mask projections in canonical form;
- a record for every within-stratum unordered pair and mask, including projection equality and, for each inquiry family, conflict count plus the first witness ordinal; every full witness remains in the conflict file and is keyed by mask, family, pair, and query;
- all conflict witnesses, including the differing query key and both typed answers;
- family/mask certificates with equivalence classes, common answer vectors or explicit conflict markers, sufficiency, and compact proper-submask evidence (sufficiency, conflict count, and first witness ordinal) for inclusion minimality;
- a summary derived from those records, plus an independent verification receipt containing pass/fail, validated inventory counts, and hashes of the exact evidence and verifier source.

The verifier receipt is not itself proof of correctness; the verifier source and reproducible evidence remain part of the reviewable package. A future evidence contract must specify whether outputs are JSON or JSONL, canonical byte encoding, numeric/boolean typing, and stable row ordering before freeze. The manifest lists each finalized input and evidence file with its byte length and hash, explicitly excluding both the manifest itself and the later verifier receipt. Once the manifest is finalized, a separate receipt records its byte length and hash, hashes the exact evidence and verifier-source bytes, and binds the receipt to the source commit and input hashes. The receipt remains outside the manifest inventory, so the two hashes cannot form a cycle. At present none of these output files exists for this challenge, and no candidate answers have been generated. The separate, non-research software feasibility probe below does not populate this evidence inventory.

**Serialization recommendation for entry review (not frozen):** use one UTF-8 `manifest.json`; JSONL files for truth, projection, pair comparison, and conflict witnesses; and JSON files for certificates, summary, and verifier receipt. Pair rows store a per-family conflict count and first witness ordinal rather than an unbounded ordinal array; certificate proper-submask evidence uses the same compact count/first-witness index. The conflict JSONL remains the complete source for every differing query and typed answer. This avoids repeating each witness ordinal up to 19 times across strict supermask certificates, while retaining a deterministic pointer to a witness. The 448-byte row limit applies only to the four JSONL files; `certificates.json` and every other non-row artifact count against the separate 64 MiB reserve. Require no BOM, LF line endings, a final LF, compact JSON, lexicographically sorted object keys, and no floating-point values. Preserve event order in inputs; sort case IDs and unordered pair endpoints lexicographically; order masks as `000`–`111`, query families by the registered family order, and query keys by their canonical typed JSON bytes. Encode answers with native JSON types (`true`/`false`, `null`, strings, and arrays of strings); never stringify booleans or nulls. Hash each exact input/evidence file byte sequence with lowercase SHA-256 hex and list its path, byte length, and hash in the manifest; explicitly omit `manifest.json` and the later verifier receipt. After finalizing the manifest, the external receipt hashes the manifest and evidence files and records the verifier-source hash and source/input identity. The entry reviewer should accept or amend this format before any input/source freeze; this proposal does not itself freeze serialization or create files.

### Answer-free output/resource sizing proposal

From the fixed query inventories, an inventory-derived upper bound on conflict-witness count is 1,077,936 rows if every eligible pair/mask comparison has equal projections and conflicts on every query in both inquiry families: `1,088 × (60 + 52) + 5,624 × (90 + 80)`. The proposed hard ceilings are 448 UTF-8 bytes per JSONL row, 640 MiB for the conflict-witness file, 640 MiB for all evidence files together, and at least 2 GiB of free space before starting. The complete-package upper bound is 555,217,408 bytes: 1,089,528 JSONL rows at the 448-byte ceiling (1,077,936 conflict witnesses; 4,440 truth rows; 440 projections; and 6,712 pair/mask rows), plus a 64 MiB reserve for the two input documents, 32 full certificates, manifests, receipts, timing, summaries, and all other non-row artifacts. Certificates and inputs are not charged as single 448-byte rows because their full records can exceed that size; the 64 MiB reserve is an explicit cap proposal and must be enforced by the eventual writer. This leaves the calculated package below the 640 MiB total evidence ceiling. Stop before writing a row or artifact that would breach any ceiling; keep partial files with an `INCOMPLETE` manifest and failure record, and do not retry, delete, or promote partial output automatically. These ceilings remain proposals until a separate entry decision.

**Answer-free memory and bounded-stream findings (2026-10-16).** A synthetic list-of-dictionaries handoff containing 1,077,936 placeholder witness rows measured 900,333,568 bytes peak RSS initially and 882,343,936 bytes on repeat, exceeding the inherited 128 MiB (`134,217,728` byte) worker-tree ceiling. A new opt-in producer mode streams each conflict witness through a capped, fsynced sink and retains compact per-pair/per-mask-family counts and first ordinals; a separately implemented verifier independently reconstructs and compares witnesses row by row, and the package writer checks its time/RSS guard while writing. The toy end-to-end integration (`scripts/check-finite-lineage-bounded-pipeline.py`) passed on two synthetic three-entity cases with 12 witness rows; combined bounded-worker peak RSS was about 15 MB and temporary files were removed. A separate capped placeholder stream wrote the full inventory-derived maximum of 1,077,936 answer-free rows (451,622,010 bytes) at 14,516,224 bytes worker peak RSS under the 128 MiB ceiling (`scripts/check-finite-lineage-streaming-memory.py`). A schema-shaped placeholder check allocated all declared non-witness inventories—55 placeholder cases, 4,440 truth rows, 440 projections, 6,712 compact pair rows and 32 certificate structures—and measured 26,116,096 bytes peak RSS (`scripts/check-finite-lineage-bounded-memory-shape.py`). Its event/query/result fields contain only explicit non-answer placeholders; it does not execute the producer or verifier. These checks read no candidate inputs and generated no candidate answers. They support bounded storage feasibility but do not measure the complete 55-case producer/verifier/writer implementation, exact certificate values, or parent/process-tree peak on a semantically valid input. The bounded producer, independent verifier, and writer now require an explicit stratum and independently enforce the declared F4 (17 cases × 4 entities) or F5 (38 cases × 5 entities) inventory before accepting a research package; a rejected writer input preserves an `INCOMPLETE` receipt. The historical in-memory `produce()` default still retains all witnesses; a later authorized path must explicitly use bounded mode, enforce the caps and guards end to end, and receive independent review before entry. No revised ceiling is selected.

An answer-free synthetic resource check wrote 1,077,936 placeholder conflict rows (420 bytes each; 452,733,120 bytes total) under `/private/tmp`, streamed and reread the SHA-256, and removed its temporary files. It read no candidate input and generated no candidate answer. Reproduction source: `scripts/check-finite-lineage-resource-shape.py`; the first recorded run and helper hash are preserved in `FINITE_LINEAGE_AI_REVIEW_002_2026-10-16.md`. The updated 2026-10-16 helper SHA-256 `7ca9c957ac9c069a24f76de52b83675d7b31abd47f36677a728f9897d3adc7d9` passed under Python 3.12.13 in 14.990 seconds with synthetic file SHA-256 `ed69ae4b52da22cb932595d79af11a2ba2e2bcb4e61591610a4143deba450fad`. In addition to the prior row/count/file/total caps and 2 GiB boundary checks, it enforces the 64 MiB non-row reserve for streamed artifacts and preserves an `INCOMPLETE` partial on reserve overflow. The host had 244,384,272,384 free bytes before the run. A subsequent answer-free integration control preallocates and fsyncs a 16 KiB failure-receipt reserve before launching the synthetic worker; an injected `ENOSPC` after a partial `INCOMPLETE.json.partial` exists removes that file, releases and directory-syncs the reserve, and then records the terminal failure without rerunning or promoting the worker. Only `ENOSPC` triggers this retry; an injected `EACCES` is not retried. The reserve uses nonzero bytes and verifies allocated blocks where reported. This is synthetic fallback-path evidence only: it does not establish behavior under a genuinely full filesystem, metadata exhaustion, power loss, or integration into a future final challenge writer.

### Answer-free synthetic process-supervisor controls (2026-10-16)

The helper `scripts/check-finite-lineage-execution-guard.py` (current SHA-256 `b664e9d5700011b447b877edeb13191bb6f0fe63641d1bd4d32def608907da87`) passed on macOS with Python 3.12.13. It reads no candidate inputs and generates no candidate answers. Synthetic controls confirmed rejection of a civil/monotonic clock gap and clock regression, expiry on either elapsed-clock deadline, termination of a worker process group including a descendant, reaping of the group leader, preservation of a worker's partial artifact after nonzero exit, and an `INCOMPLETE` receipt with no automatic retry or promotion. The composed answer-free boundary harness injects a partial-file `ENOSPC` failure during terminal failure-receipt persistence and confirms that the preallocated reserve permits one receipt retry without rerunning or promoting the worker. Directory updates are fsynced for reserve creation/release and receipt replacement; a post-rename directory-sync fault test confirms cleanup leaves no conflicting terminal receipts. Temporary processes and files were removed. These controls do not simulate actual host suspension, genuine filesystem or metadata exhaustion, persistent directory-sync failure, or integration with a final producer/verifier/writer. Those remain review gates before any recorded attempt.

## Prior-art boundary

View determinacy is already a formal information-theoretic property: equality of view outputs must force equality of query answers across the declared database-instance universe. The database-theory literature distinguishes finite-only from unrestricted instance universes, so this note must not use “finite determinacy” as a label for eight hand-selected cases. RP006 and the proposed challenge make finite-corpus comparisons; neither establishes determinacy over all finite databases ([Nash, Segoufin & Vianu, *Views and Queries: Determinacy and Rewriting*](https://dbucsd.github.io/paperpdfs/2010_3.pdf)).

A particularly close preservation result is Fan, Geerts and Zheng's formalization of selected-information preservation through invertibility and query preservation. They show that invertibility relative to a source query coincides with view determinacy, with results quantified over the declared database-instance class ([Fan et al., *View Determinacy for Preserving Selected Information in Data Transformations*, 2012](https://doi.org/10.1016/j.is.2011.09.001); [peer-reviewed author version](https://www.pure.ed.ac.uk/ws/portalfiles/portal/17752772/paper_viewd.pdf)). This makes query-relative preservation an established conceptual frame. The proposed work differs only at the operational level: a fixed finite corpus, fixed answer functions, and a declared whole-field mask class. That difference supports a reproducible finite challenge, not a new determinacy concept or a novelty claim.

The graph-view collision is direct. Work on path-query views studies determinacy over graph databases, and recent work studies regular-path views under walk-based semantics. Those papers vary query languages and quantify over database graphs; they are not this fixed aligned-entity corpus or its eight whole-field masks. They rule out presenting ancestry-query sufficiency as a new general determinacy concept ([Francis, *Asymptotic Determinacy of Path Queries using Union-of-Paths Views*](https://drops.dagstuhl.de/entities/document/10.4230/LIPIcs.ICDT.2015.44); [Francis, *View-Based Query Determinacy for Walk-Based Semantics*](https://drops.dagstuhl.de/entities/document/10.4230/LIPIcs.ICDT.2026.22)).

Following references from the graph-view literature also surfaces foundational overlaps. *Answering Queries Using Views* studies complete and minimal rewritings from materialized views; *Lossless Regular Views* asks when graph/path views preserve enough information to answer a query; and Afrati studies the relationship between determinacy and rewriting for conjunctive-query views. Together these make query-relative preservation and recovery from reduced information an established problem family, even though their language-defined views and database-wide semantics differ from the proposed finite, aligned-case comparison ([Levy et al., PODS 1995](https://doi.org/10.1145/212433.220198); [Calvanese et al., PODS 2002](https://iris.uniroma1.it/handle/11573/252669); [Afrati, *Determinacy and Query Rewriting for Conjunctive Queries and Views*](https://doi.org/10.1016/j.tcs.2010.12.031)).

Provenance work also studies abstraction and information loss. Existing systems summarize why/why-not provenance by grouping derivation patterns; SGProv compresses multiple workflow provenance graphs while retaining selected query answers; and later provenance-graph work segments derivations and summarizes similar paths under provenance constraints. These overlap with the concern that reduced fields may collapse distinctions relevant to answers; they use different representations, query tasks, and summaries ([Lee et al., *Integrating Approximate Summarization with Provenance Capture*](https://www.usenix.org/conference/tapp17/workshop-program/presentation/lee); [El-Jaick et al., *SGProv: Summarization Mechanism for Multiple Provenance Graphs*](https://periodicos.ufmg.br/index.php/jidm/article/view/249); [Miao & Deshpande, *Understanding Data Science Lifecycle Provenance via Graph Segmentation and Summarization*](https://arxiv.org/abs/1810.04599)). Database provenance also has established algebraic lineage models ([Green, Karvounarakis & Tannen, *Provenance Semirings*](https://web.cs.ucdavis.edu/~green/papers/pods07.pdf)), and W3C PROV explicitly models derivation and qualified derivation ([PROV-DM](https://www.w3.org/TR/prov-dm/#term-Derivation), [PROV-O](https://www.w3.org/TR/prov-o/#qualifiedDerivation)).

The additional graph-summarization search found a closer answer-preservation family. Fan et al.'s SIGMOD work compresses a graph relative to a declared class of reachability or graph-pattern queries and preserves their answers through query transformation; Niazmand et al.'s query-based RDF summaries likewise target lossless retrieval and complete SPARQL answers. These are strong adjacent precedents for preserving answers after information reduction. Their objects are compressed/summary graphs and their guarantee is tied to a query class and transformed query execution. This draft instead compares fixed whole-field projections over a predeclared finite, aligned event-log corpus and checks registered answer functions directly; that operational distinction does not establish novelty ([Fan et al., *Query Preserving Graph Compression*, SIGMOD 2012](https://doi.org/10.1145/2213836.2213855); [peer-reviewed author copy](https://www.research.ed.ac.uk/en/publications/query-preserving-graph-compression/); [Niazmand et al., *Efficient Semantic Summary Graphs for Querying Large Knowledge Graphs*, 2022](https://doi.org/10.1016/j.jjimei.2022.100082)). Other graph-summary work explicitly optimizes query-answer accuracy under lossy structural summaries, which is adjacent but uses probabilistic summaries and graph statistics rather than lineage-field masks ([LeFevre & Terzi, *GraSS: Graph Structure Summarization*, SDM 2010](https://doi.org/10.1137/1.9781611972801.40)).

**Bounded prior-art search log (2026-10-14).** I ran targeted indexed searches for “finite determinacy views queries database,” “finite determinacy graph views,” “view determinacy graph databases path queries,” “lineage view determinacy graph database query,” and “lossless regular views graph queries.” I followed the primary records and selected bibliographies across Dagstuhl LIPIcs (ICDT 2015 and ICDT 2026), the PODS 2002 author-hosted paper, the ScienceDirect record and peer-reviewed author version for Fan et al., and the author-hosted Nash–Segoufin–Vianu paper. This is a bounded web-index and selected-reference search, not a reproducible full-text search of ACM DL, DBLP, or every relevant venue; query ranking and indexing may omit work.

**Expanded targeted search round (2026-10-15).** I searched public indexed records with the exact query families “view determinacy graph databases path query,” “graph database lineage provenance view determinacy information preservation,” “lossless regular views graph queries,” “query determinacy graph databases view-based rewriting,” “finite determinacy databases views,” and “determinacy over finite databases.” I restricted several searches to DBLP, Dagstuhl DROPS, ACM DL and arXiv domains, then followed references in the primary Dagstuhl records for ICDT 2015, ICDT 2019, ICDT 2020 and ICDT 2026. This surfaced a terminology risk that should be stated explicitly: “conjunctive-query finite determinacy” is an established formal decision problem over all pairs of finite database structures, and Gogacz and Marcinkowski prove that problem undecidable. It is not the same property as agreement or sufficiency classifications on this draft's hand-selected 55-case corpus. The ICDT 2020 invited perspective also emphasizes that determinacy variants depend on the query/view languages and on what “compute” means. Accordingly, use “finite-corpus mask-sufficiency comparison” or “finite stress comparison” for this proposal; do not call it “finite determinacy.” These results reinforce the boundary already stated here, without changing the proposed research question ([Gogacz & Marcinkowski, PODS 2016](https://doi.org/10.1145/2902251.2902288); [author-hosted paper](https://arxiv.org/abs/1512.01681); [Marcinkowski, ICDT 2020 invited perspective](https://drops.dagstuhl.de/entities/document/10.4230/LIPIcs.ICDT.2020.2)).

**Targeted adjacent-literature round (2026-10-15).** I searched “provenance graph summarization preserve query answers,” “graph summarization preserve query answers provenance lineage,” “database provenance compression query answer preservation,” and “query preserving graph compression,” then checked the primary proceedings/publisher records and author-hosted copies. The round surfaced (i) query-class-relative graph compression with transformed queries, (ii) query-based RDF summaries targeting lossless SPARQL answer retrieval, and (iii) lossy graph summaries evaluated by query-answer accuracy. These are classified as strong adjacent work, not exact matches: their summary/compression objects and query-evaluation guarantees differ from direct comparison of whole-field masks over a fixed aligned lineage corpus. The USENIX provenance-summary work already noted above remains relevant to derivation explanation and approximate summarization, but is likewise not the same estimand. Search was a bounded public-index round with selected primary-record verification; it was not a systematic full-text or citation-network review and cannot support a novelty-clearance claim ([Fan et al., SIGMOD 2012](https://doi.org/10.1145/2213836.2213855); [Niazmand et al., 2022](https://doi.org/10.1016/j.jjimei.2022.100082); [LeFevre & Terzi, SDM 2010](https://doi.org/10.1137/1.9781611972801.40)).

**Citation-chain and index follow-up (2026-10-15).** From the SIGMOD graph-compression references and searches for “lossless graph contraction query class synopsis,” “hierarchical graph contraction exact query answers,” “query preserving graph compression citations,” and “query preserving watermarking first-order queries,” I checked the primary VLDB Journal article, ACM proceedings metadata, Dagstuhl proceedings references, and the authors' or venue-hosted copies where available. The lossless-contraction work is a particularly strong adjacent collision: it contracts graph regions but retains query-class synopses and a decontraction path, allowing adapted algorithms to return exact answers. Its 2022 hierarchical follow-up organizes contractions into levels for graph querying. These methods preserve a richer graph representation and query-answering route; they do not test whether the three declared lineage fields, projected as whole-field masks, distinguish the registered answers over a fixed finite aligned case set. This is a design-level difference, not a novelty argument ([Fan et al., *Making Graphs Compact by Lossless Contraction*, VLDB Journal 2023](https://doi.org/10.1007/s00778-022-00731-7); [Fan et al., *A Hierarchical Contraction Scheme for Querying Big Graphs*, SIGMOD 2022](https://doi.org/10.1145/3514221.3517862)). Query-preserving watermarking was screened but excluded from the closest-work set: it embeds marks while preserving a logical query language on restricted structures, rather than evaluating information reduction or lineage-field sufficiency ([Chattopadhyay & Praveen, FSTTCS 2019](https://doi.org/10.4230/LIPIcs.FSTTCS.2019.36)). This was a targeted citation-chain/index follow-up, not an exhaustive review of all graph compression, watermarking, or database-preservation literature.

**Projection-specific follow-up (2026-10-15).** I searched “selection projection views view determinacy,” “selected-information preservation projection transformation views,” “finite test of query determinacy finite corpus views,” and “property graph attribute projection query answers,” and checked the primary Information Systems article and related view-processing records. This makes the closest theoretical predecessor more explicit than the earlier summary did: Fan, Geerts and Zheng study preservation of selected source information under view transformations and specifically analyze conjunctive-query subclasses including `SP` (selection and projection), alongside query-relative preservation and determinacy. Thus, projection-based preservation is an established formal setting. The current proposal's masks are also projections in an operational sense. The distinction is that their formal results concern language-defined transformations and guarantees over a declared class of database instances, whereas this proposal would classify only eight named field subsets against fixed answer functions on one predeclared, finite aligned corpus. That is a bounded instantiation/evaluation of a known preservation question, not a new concept; whether the finite lineage benchmark has sufficient methodological value is for the independent reviewer ([Fan, Geerts & Zheng, *View Determinacy for Preserving Selected Information in Data Transformations*, Information Systems 2012](https://doi.org/10.1016/j.is.2011.09.001); [Fan et al., *View-Based Query Processing: On the Relationship between Rewriting, Answering and Losslessness*](https://www.inf.unibz.it/~dcalvanese/papers-html/TCS-2007.html)). The search did not establish whether another benchmark already uses this exact RP006 query family and case alignment; that narrower bibliographic question remains open and cannot be settled by the absence of a result in indexed search.

The closest conceptual collision is database-wide view determinacy and selected-information preservation. In particular, “Lossless Regular Views” studies whether regular-path-query views preserve enough information to answer a query on semistructured graph databases, while path-view determinacy work quantifies over graph databases; the 2026 ICDT paper studies regular-path queries and views under trail and shortest-walk semantics. These are direct conceptual predecessors for the information-preservation question, although their formal query/view settings and universal database-instance semantics differ from this proposal's fixed, aligned finite cases and whole-field masks ([Calvanese et al., *Lossless Regular Views*, PODS 2002](https://doi.org/10.1145/543613.543646); [Francis, ICDT 2015](https://drops.dagstuhl.de/entities/document/10.4230/LIPIcs.ICDT.2015.44); [Francis, ICDT 2026](https://drops.dagstuhl.de/entities/document/10.4230/LIPIcs.ICDT.2026.22)). The formal projection/selected-information connection is already established by Fan, Geerts and Zheng, so the proposed work should be framed only as a corpus-specific finite evaluation/benchmark of known query-preservation ideas. The targeted searches have not settled whether the exact RP006 query family and aligned lineage-case benchmark already exist; that narrower overlap question remains for a broader independent bibliography review. No absence claim supports novelty.

**Recent targeted adjacent-work check (2026-10-16).** A follow-up for recent work on project/select determinacy and lineage compression checked the author preprint and ACM proceedings record. Zhang et al. study decidability of query determinacy for project-select views and a project-select-join query without self-joins, under a declared class of selection predicates; that strengthens the known projection/determinacy connection, but asks a language-level decision question over database instances rather than classifying eight masks on a fixed lineage corpus ([Zhang et al., *A Decidable Case of Query Determinacy: Project-Select Views*, arXiv:2411.08874](https://arxiv.org/abs/2411.08874)). Han et al. compress fine-grained SQL lineage artifacts for storage and reuse across related analytical queries, with experiments on IDEBench and TPC-H. This is a direct adjacent lineage-compression system, but it reduces SQL provenance artifacts and capture/storage overhead rather than testing which whole fields preserve event-lineage query answers after projection ([Han et al., *Compression for High-Performance Lineage*, ProvenanceWeek 2025](https://doi.org/10.1145/3736229.3736264)). This focused pass surfaced no exact match for the proposed fixed aligned corpus, three whole-field masks and registered event-lineage query families. It is a small targeted update, not systematic coverage or novelty clearance; the entry reviewer should decide whether more bibliography work is worth the cost.

**Exact benchmark-search follow-up (2026-10-16).** Targeted public-index searches for lineage field projection, query-preservation benchmarks, event-history masks and finite lineage answer sufficiency surfaced Kuang, Qiu and Kim's arXiv preprint *Reconstructing Cell Lineage Trees from Phenotypic Features with Metric Learning* (arXiv:2503.13925). It presents a benchmark for reconstructing biological cell-lineage tree topology from phenotypic measurements, including synthetic and lineage-resolved single-cell data. This is adjacent benchmark work, but its target is topology inference from observed features; the proposed challenge evaluates whether fixed whole-field projections of event logs preserve registered query answers on one finite aligned corpus. The narrow searches found no exact match for this proposal's query/mask/corpus combination, but do not establish absence, systematic coverage or novelty clearance. The independent reviewer should assess whether this adjacent benchmark changes the decision or warrants broader citation-chain work ([Kuang, Qiu & Kim, *Reconstructing Cell Lineage Trees from Phenotypic Features with Metric Learning*, arXiv preprint](https://arxiv.org/abs/2503.13925)).

The narrowest defensible possible contribution is therefore an auditable, independently reviewed finite benchmark evaluating known projection/query-preservation ideas on declared lineage masks and answer functions, with explicit state-equality sensitivity. It may provide a bounded transfer check for the RP006 representation decision; the value of that benchmark and the precise novelty of its workload remain for the separate entry reviewer. It is not a new determinacy or information-preservation concept, a systematic literature review, novelty clearance, or a claim of general representation-minimality or universal field-necessity. No theorem or population-level inference follows.

## Non-research software feasibility probe

On 2026-10-13, the existing RP006 producer and separately implemented verifier were exercised on a synthetic in-memory control domain with three toy cases and three entities. This domain was authored only to measure software overhead; it is not one of the proposed F4/F5 cases and is not candidate evidence. Five producer → verifier → canonical serialization rounds all passed. Each round handled 108 truth rows, 24 projections, 24 pair/mask comparisons, and 16 family/mask certificates. Serialized output size was 52,203 bytes per round. Median round time was 0.00717 seconds and maximum was 0.00771 seconds. The process lifetime peak RSS, including imports, was 14,778,368 bytes. No input, answer output, artifact, or report file was written; returned answer-bearing objects remained in memory and were discarded without inspecting individual answers or conflict/sufficiency results.

The probe used the existing engineering guard limits: 60 seconds, 134,217,728 bytes peak process RSS, and no more than a two-second civil/monotonic clock gap. Across the five rounds the guard's total measured interval was 0.03654 seconds with a clock gap below one microsecond. These observations establish only that this tiny local software path completed under those limits on the current host. The proposed 55-case challenge's arithmetic inventory is larger (4,440 truth rows, 440 projections, 6,712 pair/mask comparisons, 32 family/mask certificates across two separate strata); the toy timings and bytes do not establish a scale guarantee or forecast conflict-dependent output size. The probe did not test disk durability, archive packaging, host suspension, child-process policy, or a fresh independent implementation.

For any later recorded attempt, retain the 60-second/128-MiB ceilings only as provisional controls until they are reviewed against the actual challenge and output format. Stop and preserve an incomplete diagnostic if a sampled resource limit is crossed, clocks regress, the civil/monotonic gap exceeds two seconds, validation fails, or producer/verifier results differ. The cooperative guard cannot itself stop a suspended or runaway worker; an external suspension-aware supervisor and child-process policy must be reviewed before a recorded attempt. This probe does not authorize that attempt.

## Internal design review (2026-10-14)

This is an internal preparation critique, not the independent design review required before entry. The proposed question is falsifiable on a fixed corpus: a same-projection/different-answer pair is a counterexample for that family, mask, and corpus. A conflict-free result classifies only the reviewed cases. Neither outcome supports transfer to a population of possible lineages.

The eight cases are a purposive motif grid, not a sample. Four and five entities extend the disclosed three-entity examples, but count alone does not ensure substantive novelty or broad coverage. The stated prefix exclusion is useful but weaker than the required unlabeled-structure and shared-subgraph comparison. Keep the current templates provisional until a reviewer checks coverage, operation semantics, full overlap, and whether the two registered query families still answer the question worth asking.

The strongest defensible outcome is a finite stress test, especially if it yields an auditable conflict that rejects a previously sufficient mask on a new case pair. No conflict would be a bounded consistency result. Given the close view-determinacy and selected-information-preservation literature, a full Cycle 03 entry is worthwhile only if the independent review confirms that this finite challenge has a clear decision value beyond software validation. Otherwise, prioritize primary DAM/DAM X source recovery or choose a separately justified question. No candidate answers, input corpus, or run were produced for this review.

## Independent design-review brief and status

This section records the review request and its status. A review assessment supplied by the user has been retained as AI feedback at the user's direction; it is not evidence of an external human review. The assessment's authoring system and exact reviewed byte revision are unknown. Its findings and response are recorded below. No candidate input corpus, truth answers, projections, conflict outcomes, frozen protocol, or research run exists.

Review the exact proposal in this draft against D-0021, the RP004 operational protocol and frozen six-construction fixture file. Return a short written assessment with evidence and one disposition: (a) proceed to a separate Cycle 03 entry review, (b) revise specified parts and return for review, or (c) defer/decline this direction. Address each item:

1. **Decision value and question.** Is the comparison of the registered FULL and TOPOLOGY_STATE inquiries over two new finite strata capable of changing a concrete representation decision, beyond showing that existing software works? Are both inquiry families still justified? State what each possible finite outcome would and would not support.
2. **Construction semantics and controls.** Replay each proposed event template against RP004's live-input, consumption, parent, output and state rules. Confirm the 4/5 entity counts and whether the collection includes both repeated and distinct state payloads for reasons relevant to the question. Identify ambiguous or invalid templates without calculating query answers.
3. **Structural separation.** Compare the proposed event structures with every RP004/RP006 construction after opaque-ID renaming. Report exact event-labelled isomorphisms, unlabelled parent-DAG isomorphisms, and meaningful shared substructures or append-only extensions. Analyze topology and operation labels separately; analyze payload equality-patterns separately from payload values. State the normalization and overlap criterion, with a table of pairwise findings. A prefix-only exclusion is insufficient.
4. **Prior-art boundary.** Follow relevant citation chains and search suitable primary database/graph-query venues or indexes for the specific combination of declared lineage queries, whole-field masks and finite aligned cases. Separate direct conceptual overlap from merely adjacent work. Do not certify novelty; identify the narrowest defensible contribution and any search limits.
5. **Protocol and feasibility.** Review the proposed input schema, side information, independently reconstructed truth, producer/verifier separation, all denominators, conflict and no-conflict records, certificates, invalid-input controls, output size, and the limits of the non-research software probe. Name any change required before a source freeze.

The review must not create or inspect answer-bearing outputs, tune templates against outcomes, freeze a corpus, authorize a package or Test, or authorize execution. Preserve the written assessment and any dissent with its exact reviewed source revision. Only a later, separate entry decision can authorize Cycle 03 work.

## Independent review findings and response (2026-10-14)

The AI assessment supplied through the user described the preparation draft as methodologically disciplined and broadly coherent, while raising required revisions. This is supplemental AI feedback, not an entry approval, novelty clearance, source freeze, authorization to execute, or independent external review. It discusses the public draft URL. At submission, autorite.net was at Site version 63 with source commit `beea8af8174abd5ad313002ca43404c8a860f05e`; the assessment did not identify its authoring system or exact reviewed bytes. Preserve these provenance limits in any later governance record.

| Review finding | Response and required treatment before source freeze |
| --- | --- |
| The decision value of the two registered inquiry families, and whether both remain justified beyond software validation, needs an explicit disposition. | Not resolved by the assessment supplied. Retain both only as the proposed RP006-comparable analysis: `FULL` tests all registered answers, while `TOPOLOGY_STATE` tests the declared four-query subset. The entry reviewer must state what representation decision could change under each family and may recommend dropping one before freeze. No outcome may decide the family set after execution. |
| Four templates per stratum are sparse relative to the construction space. The draft should justify why these motifs were selected without implying representative or minimal coverage. | Accepted. Treat the eight structural slots as a purposive, finite stress grid, not a sample or a minimal cover. Map each motif to the specific distinction it is meant to expose and explain why that distinction matters to the registered inquiries. Do not claim that the selected topologies exhaust a stratum. |
| State assignments may influence `same_state` answers; sensitivity should be planned before outcomes. | Accepted with a semantic refinement. A global bijective renaming of opaque values leaves equality-based `same_state` answers invariant. The revised proposal therefore includes all 55 admissible equality partitions using at most three opaque values across the fixed topologies, subject to copy/fork constraints. This is a finite exhaustive sensitivity set under an explicit value bound, not a broad-domain claim. The partition-generation rule and updated denominators are specified above; the independent reviewer must reproduce them before any freeze. |
| Producer/verifier independence should extend beyond separate files and source hashes. | Accepted. Require separate parsing and semantic reconstruction, no shared domain-specific parser or producer logic, and preferably separate authors. Disclose any common generic libraries and review them for common-mode semantic errors. Preserve disagreements rather than repairing expected outputs. |
| Hash integrity, deterministic coverage arithmetic and the feasibility probe's separation from candidate outcomes should be explicit. | Largely already specified; retain as entry gates. Independently recalculate the revised 4,440 FULL truth rows, 440 projections, 6,712 within-stratum pair/mask comparisons and 32 certificates from the final frozen inventory, and have the verifier check them independently. Bind exact input and source bytes to hashes before any authorized run. The five-round probe did create and pass answer-bearing objects in memory for a separate three-entity toy domain; individual answers, conflicts and sufficiency outcomes were not inspected, and no proposed F4/F5 inputs or answer outputs were created. Do not describe the probe as output-free. |

The motif rationale to carry into the revised design is: F4-01 tests continuation with a disconnected root; F4-02 tests a branch after continuation; F4-03 tests copy plus a merge with an independent root; F4-04 tests asymmetric development from two roots; F5-01 adds unequal branch depth; F5-02 combines a branch with a merge while a sibling remains; F5-03 combines distinct state changes and independent roots at a merge; and F5-04 combines a continuing line, retained copy and independent-root merge. These are design intentions only; they do not establish coverage, distinctness from the old corpus, or answer outcomes.

### AI design review 001 and response (2026-10-16)

A separate OpenAI GPT-6 Sol review agent examined draft SHA-256 `bdf198bc95ec49dbcd720bfa156cf050c7d3c459484c0ded9cc616cfd3f91136`, a construction-semantics-only excerpt and the payload-free RP004 structure export. Its full report is `research/preparation/FINITE_LINEAGE_AI_REVIEW_001_2026-10-16.md`. This is an AI design review, not a human expert review or entry decision. It recommends **revise and return**. Its report verifies the partition/workload arithmetic and proposed operation legality, identifies fork-sibling omissions in the earlier overlap table, requires the two query families to map to distinct declared uses, and identifies cross-case state-label alignment, family-specific pair outcomes, manifest hash binding and output/resource supervision as remaining protocol details. This draft has been revised in response; the corrected exact bytes must receive a new review before entry. The review did not inspect candidate outputs, execute the challenge, or verify citation claims against the papers.

An initial separate-AI review attempt read control-bearing prose in the RP004 operational protocol and was stopped. It did not read the original fixture or RP006 evidence and its findings were not used. This process deviation is disclosed in the structural audit section; the clean review used only the sanitized construction excerpt and payload-free fixture export.

### Preliminary structural-overlap audit (2026-10-14/16; not independent review)

The preliminary audit compared the eight proposed event structures with the six RP004 event logs. The source fixture file has SHA-256 `ff80fb8bc9e96748c5e672410a7d057d3051771f60845515ff4911ba60919513`. The 2026-10-14 audit did not read fixture controls or compute candidate answers, but its criterion was misnamed: it closed selected node sets under parents, not under all outputs of a fork. A payload-free structure export was later generated from only fixture version, case IDs, event kinds, parent IDs, and output IDs (SHA-256 `b448013d9f849f51af1bf026c9bf7b666bd5110a32aa28315c84c1e2819ff1ea`). No state payloads, controls, or answers are in that export. Nodes may be relabeled; the comparisons below distinguish parent-DAG structure, event labels, fork-sibling completeness, and strict event order.

Use these criteria separately. **D** is a parent-closed three-node parent-DAG match; it ignores birth operations and may omit a fork sibling. **L** additionally matches birth-operation labels and preserves the fork-sibling relation, while treating independent event order as irrelevant. **R** is an L match that also includes every output of each represented operation, so the three-node selection is a replayable event sublog. **O** is a strict ordered event subsequence after ID relabeling; it preserves the logged order but may omit interposed events. A contiguous prefix is stricter than O. A two-parent merge neighborhood is reported separately because it may omit earlier ancestry and therefore fail parent closure. RP006 uses the same six disclosed constructions, so it adds no separate structural inventory here.

**Process deviation (2026-10-15).** During an attempted second structural audit, a diagnostic print included the first RP004 fixture object in full, including its legacy control answers. The printed controls were not used to change templates or overlap findings, and no proposed F4/F5 input, answer, mask verdict, or challenge outcome was created or inspected. Do not treat that attempt as independent structural evidence.

**AI review-process deviation (2026-10-16).** An initial separate-AI review opened the full RP004 operational protocol, whose prose includes legacy control answers. It was stopped immediately; it did not open the fixture file or RP006 code/evidence and generated no challenge inputs or answers. This pass is not control-blind evidence. The subsequent clean AI review used the draft and the payload-free structure export above, plus a sanitized construction-semantics excerpt (SHA-256 `44b22c907990094983f1a11dab7f087524cfc519379f204d91c18a682fc31138`).

| Candidate | D — parent-closed DAG matches | L — event-labelled structural matches | R — replayable event sublogs | O — strict ordered subsequences |
| --- | --- | --- | --- | --- |
| F4-01 | G0 (`a,b,c`); C4 (`a,b,d`) | none | none | none |
| F4-02 | G0 (`a,b,c` and `a,b,d`) | none | none | none |
| F4-03 | C4 (`a,b,c`) | none | none | none |
| F4-04 | C4 (`a,b,c` and `a,b,d`) | C4 (`a,b,d`) | C4 (`a,b,d`) | C4 (`a,b,d`), with an interposed copy event |
| F5-01 | G0 (`a,b,c` and `a,b,d`) | none | none | none |
| F5-02 | G1 (`a,c,d`); G2 (`a,c,d`); C4 (`a,b,c` and `a,b,d`) | G2 (`a,c,d`) | G2 (`a,c,d`) | G2 (`a,c,d`), with an interposed independent root |
| F5-03 | C4 (`a,b,c` and `a,c,d`) | C4 (`a,c,d`) | C4 (`a,c,d`) | none |
| F5-04 | G0 (`b,c,d`); C4 (`a,b,c`) | C4 (`a,b,c`) | C4 (`a,b,c`) | none under strict logged order |

The G0 parent-DAG matches in F4-02 and F5-01, and the C4 parent-DAG matches in F5-02, omit one output of a fork. They are D overlaps only, not valid replayable three-node sublogs. F5-04's `{a,b,c}` matches C4 as an unordered event-labelled structure after swapping the two roots, but that relabeling changes the order of the independent root events; it is not an O match. F4-04 and F5-02 contain the listed C4/G2 motifs as ordered subsequences, not contiguous prefixes. A local merge neighborhood also matches the G4 immediate-parent/merge motif in F4-03 (`b,c,d`), F5-02 (`b,c,e`), F5-03 (`b,d,e`), and F5-04 (`a,d,e`) when ancestry before the merge inputs is ignored; these are not parent-closed triples or replayable fixture sublogs.

No full F4/F5 candidate is isomorphic to a three-node fixture because the entity counts differ. The comparison shows that overlap can mean different things: a graph motif, an event-labelled structure, a replayable sublog, or an ordered prefix. The entry reviewer must choose which overlap definition is relevant to a transfer challenge and state whether reuse of those motifs is acceptable; this audit does not establish novelty. The local relabeling comparison is not a general subgraph-isomorphism certificate. The v2 export excludes state values, so it cannot independently compare old and proposed state-equality patterns; that check must use a separately sanitized equality-pattern inventory if retained as a gate.

A separately written local replay on 2026-10-15 reproduced the earlier parent-closed table, but it used the same inadequate event-closure label. The clean AI review on 2026-10-16 identified the fork-sibling and event-order distinctions above; it did not inspect control data or candidate outcomes. On 2026-10-16, a new answer-free checker, `scripts/check-finite-lineage-design.py` (SHA-256 `b7ec95ff19b93fa17af9f2836f5670a32f7fd609517f15399767e3ec338f0491`), independently re-enumerated the 55 state partitions and compared each proposed template with the payload-free structure export (`FINITE_LINEAGE_RP004_STRUCTURE_EXPORT_V2.json`, SHA-256 `b448013d9f849f51af1bf026c9bf7b666bd5110a32aa28315c84c1e2819ff1ea`). It reproduced the corrected D/L/R/O table, all per-slot partition counts and workload arithmetic; it also checked operation legality and copy/fork equality on the illustrative vectors. The run generated no candidate inputs or answers. This is a second author-side implementation, not an independent reviewer sign-off: the entry reviewer must still assess whether these overlap criteria and motif reuse are acceptable before source freeze.

### State-equality sensitivity design (proposed; not frozen)

Renaming opaque labels bijectively cannot change equality-based `same_state` answers. The relevant sensitivity factor is the equality partition over entities, subject to copy/fork preservation. For the eight fixed topologies, the proposed complete set using at most three opaque values contains 55 admissible partitions: F4-01 through F4-04 have respectively 5, 2, 5 and 5; F5-01 through F5-04 have 5, 5, 14 and 14. These counts enumerate partitions of the copy/fork-forced equality components into at most three blocks; they do not use answers. The currently listed vectors are illustrative members of those sets.

The revised design proposal includes all 55 variants before outcomes: 17 four-entity cases and 38 five-entity cases. Cases on the same fixed topology but with different state partitions are intentionally aligned within their size stratum. This makes payload-equality sensitivity part of the finite comparison set, while the topology count remains eight. The corresponding inventory is 4,440 `FULL` truth rows (17 × 60 + 38 × 90), 440 per-case/mask projections (55 × 8), and 6,712 within-stratum pair/mask comparisons (`C(17,2) × 8 + C(38,2) × 8). These numbers must be independently reproduced from the final inventory and schema before any source freeze. The 55-case design is a proposed response to the review, not a frozen estimand or authorization; no candidate answers have been generated.

**Disposition:** the 2026-10-14 supplied assessment and 2026-10-16 clean AI design re-review do not authorize entry. The user confirmed on 2026-10-16 that the supplied assessment should be retained as an AI evaluation. Its generating system/author and exact reviewed draft revision or SHA-256 are unknown, so it is supplemental feedback and does not count as independent human/external review or as review of these exact bytes. The separate clean AI reviews are recorded in `research/preparation/FINITE_LINEAGE_AI_REVIEW_001_2026-10-16.md` and `research/preparation/FINITE_LINEAGE_AI_REVIEW_002_2026-10-16.md`; they are AI reviews, not human expert review or entry approval. The substantive design and bounded citation check passed within their stated limits. A focused clean review of the updated resource contract and exact draft SHA-256 `745e1573e8fbcc09f41da3c13039638f2f5050372a2d70747b38bcb743f39cca` also passed; its report is appended to `FINITE_LINEAGE_AI_REVIEW_002_2026-10-16.md`. The reviewer confirmed the row/non-row budget separation and package arithmetic, but did not execute the helper. No Test, package commitment, source freeze or research run is authorized.

## Gates before any separate entry decision

Current preparation status: the eight structural templates, 55-partition sensitivity design and workload arithmetic remain proposals; no candidate inputs or challenge answer-bearing outputs have been produced. The schema-only construction and within-stratum checks passed. Five bounded prior-art/index rounds, two separately written partition enumerations, an answer-free corrected D/L/R/O overlap recheck, the proposed input/verifier/evidence contract, and a five-round non-research software probe are recorded. The clean AI design and bounded primary-source citation reviews passed for their explicitly scoped materials; see `research/preparation/FINITE_LINEAGE_AI_REVIEW_002_2026-10-16.md`. The focused review confirmed the 555,217,408-byte package-bound arithmetic and row/non-row separation, but did not execute the helpers. Local answer-free runs passed the row/witness/count/file/total caps, 64 MiB non-row reserve, low-space boundary, clock-gap/regression and deadline controls, process-group termination/reaping, and crash/partial-output receipt checks. On 2026-10-16, `scripts/check-finite-lineage-preparation-integration.py` composed the supervisor, capped writer and terminal receipts using synthetic placeholders only. Its success receipt binds the output bytes by SHA-256; worker failure, cap overflow and injected write errors preserve failure receipts and do not promote or rerun the worker. A focused partial-file `ENOSPC` fallback removes the interrupted temp file, retries only that error once after releasing the reserve, and confirms non-`ENOSPC` errors are not retried. The reserve's size and allocated blocks are checked where supported; reserve, release and receipt directory changes are fsynced. An injected post-rename directory-sync failure confirms cleanup prevents conflicting terminal receipts. The independent AI follow-up is recorded in `research/preparation/FINITE_LINEAGE_FAILURE_CONTROL_REVIEW_2026-10-16.md`. A proposed bounded package writer is now recorded at `research/preparation/finite_lineage_writer.py`. `scripts/check-finite-lineage-writer-integration.py` passed an end-to-end synthetic check using the existing RP006 producer, separately implemented verifier and capped writer: two toy three-entity cases, 108 temporary rows, 106,249 total bytes, manifest/evidence hash checks, and automatic cleanup. It read no candidate input and produced no candidate answer. This validates only a toy producer/verifier/writer path. The producer ran inside the process-group/deadline/log supervisor; the verifier and writer ran in the parent after the child wrote its complete toy bundle. The answer-free placeholder list shape measured 900,333,568 and 882,343,936 bytes for 1,077,936 rows, but a new capped stream wrote 1,077,936 placeholder rows (451,622,010 bytes) at 14,516,224 bytes worker peak RSS. The bounded producer/verifier/writer integration also passed on two toy three-entity cases with 12 witness rows and an approximately 15 MB combined worker peak; the verifier and writer applied a 128 MiB process guard. Neither check exercises the full 55-case proposed inventory or establishes the full process-tree peak, maximum certificate memory, or host-suspension behavior. The historical in-memory producer remains available and still retains the witness set; any later authorized run must explicitly select the bounded mode and receive review of the full end-to-end guard and output/hash boundary. It does not establish host-suspension behavior or recovery under real data-space, metadata-space or persistent sync failures; the small reserve cannot guarantee metadata capacity. The assessment supplied on 2026-10-14 is retained as an AI evaluation at the user's direction, but its author/system and exact reviewed bytes are unknown and it does not satisfy an independent human/external-review gate. Still open before a separate entry decision: an entry reviewer must assess the corrected overlap criteria, whether motif reuse is acceptable, the finite three-value bound and cross-case alignment; decide whether further targeted prior-art coverage is warranted; review the final writer/supervisor integration and failure behavior; obtain any required identifiable external review against a hash-bound draft; then make a separate entry decision. The 2026-10-15 structural-audit control-display deviation and initial AI-review control-bearing-prose deviation remain disclosed and are not treated as control-blind evidence. This selective prior-art work provides no novelty clearance. Cycle 02 is PUBLISHED 9/9; its close receipt versions 72/71 are historical references, while current publication versions remain available in Sites version history.

1. **AI design review:** passed for the substantive design, bounded citations and updated resource contract at draft SHA-256 `745e1573e8fbcc09f41da3c13039638f2f5050372a2d70747b38bcb743f39cca`. The reviewer did not rerun the helper; its local PASS is recorded separately.
2. **Finite-design review:** an answer-free second implementation now reproduces the 55 partitions, workload arithmetic and corrected D/L/R/O overlap table from the sanitized structure export. The entry reviewer must still accept the finite three-value bound, cross-case `A/B/C` alignment, overlap definitions and motif-reuse rule.
3. **Prior art:** the scoped primary-source collision map now also records a 2026-10-16 targeted check of 2024 project-select view determinacy and 2025 SQL lineage compression, alongside earlier projection preservation, query-preserving graph compression, lossless summaries, and synopsis-based lossless contraction. The proposal is a finite-corpus evaluation and must not imply general novelty. Search coverage remains selective; the entry reviewer should decide whether further targeted assessment is worth the cost.
4. **Protocol and controls:** the earlier design review accepted the family-specific use profiles, comparison logic and acyclic manifest/receipt boundary. The standalone resource helper enforces the 64 MiB non-row reserve; synthetic resource and process-supervisor boundary controls pass. The 2026-10-16 answer-free integration harness composes the supervisor, capped writer and terminal receipts, including success, worker crash, cap overflow, injected evidence-write error and partial-temp-file `ENOSPC` fallback using a preallocated 16 KiB reserve. It removes the interrupted temp file before a single retry, refuses to retry other I/O errors, verifies allocated blocks where reported, and fsyncs directory updates for reserve creation/release and receipt replacement. An injected post-rename directory-sync failure verifies cleanup prevents conflicting terminal receipts. A further control confirms concurrent draining of worker `stdout`/`stderr`, bounded diagnostic capture and fail-closed termination when either stream exceeds 64 KiB; this avoids pipe-buffer deadlock while retaining a bounded log prefix. Before any authorized attempt, integrate and review this boundary in the final writer, and assess host suspension and real disk/metadata failure behavior; synthetic fault injection does not establish those environmental properties, and the small reserve cannot guarantee metadata space.
5. **Provenance and entry:** the supplied assessment remains an AI evaluation with unknown authoring system and unknown reviewed-byte hash; it does not count as independent human/external review. If that review gate is required, obtain an identifiable external review against a hash-bound draft. Then commit the reviewed protocol and inputs, bind hashes to that exact source state, perform the actual pre-execution review, and obtain a separate entry decision before any research run.

Until these gates are reviewed, this document remains a preparation draft only. Cycle 02 is PUBLISHED; Cycle 03 remains unopened.
