{"barriers":{"algebrization":{"applies_to_this_object":"no","reason":"Algebrization concerns proof techniques that survive algebraic oracles. The repo defines no algebraic extension of the evaluator: there is no polynomial encoding of signal logic and no arithmetization of evaluate_logic anywhere in the files read, so there is nothing in this object to algebrize.","what_it_blocks":"It blocks nothing in the object as it stands. If someone arithmetizes the tri-state evaluator to argue about P versus NP, that argument must beat the algebrization barrier by using a property of the specific arithmetization that fails for algebraic oracles. Until such an arithmetization exists, the barrier has no grip here."},"natural_proofs":{"applies_to_this_object":"yes","reason":"The natural route to a lower bound for the composition search function is a circuit lower bound, and the matching predicate is exactly the kind of property Razborov and Rudich defined as natural: it is constructive (the linear-time evaluator decides it) and it is dense at low clause counts (measured match fractions of 0.115 at p=0.5 with 3 required clauses and 0.52 at p=0.5 with 1 required clause). A proof that composition search needs superpolynomial circuits, if it proceeds through such a constructive dense property, is what the natural proofs barrier blocks, assuming strong pseudorandom functions exist.","what_it_blocks":"It blocks circuit lower bounds for the composition search function proved through a natural property. It does not block non-natural arguments, uniform lower bounds, direct combinatorial arguments about the defeater rule, or any of the finite measurements in this file."},"relativization":{"applies_to_this_object":"no","reason":"Relativization constrains proof techniques for the general P versus NP question: a technique that works relative to any oracle cannot settle it, because oracles exist that make P equal NP and oracles exist that separate them. This object is a concrete finite problem with a fixed evaluator and no oracle parameter, so the barrier does not attach to the object itself.","what_it_blocks":"It blocks lifting any finding on this object to a claim about P versus NP by a relativizing argument. If the defeater non-monotonicity or any other property of this evaluator is ever used in a separation argument, that argument must be shown to fail in the presence of an arbitrary oracle; otherwise relativization kills it."}},"complexity_class_membership":{"in_np":"RECIPE-COMPOSITION-SEARCH is in NP: a witness is a composed LogicNode tree, and evaluate_logic checks it in time linear in its leaf count, which is polynomial in the witness size. RECIPE-SEARCH is in NP trivially because it is in P.","in_p":"RECIPE-SEARCH over the fixed registry is in P: it is a finite problem (558 recipes), decided by a linear scan that was measured at 0.0718 seconds for a full-evidence subject. Bounded-clause composition search is in P for fixed k: the number of required sets of size at most k is O(S^k) in the signal count S, each checked in O(k) clause evaluations; measured k<=3 gives 5309433 candidates over S=317.","unknown":"Whether unbounded RECIPE-COMPOSITION-SEARCH is in P is unknown: no polynomial-time algorithm for finding a matching composed recipe is exhibited in the repo, and no proof rules one out. Whether the composition decision problem is NP-complete is unknown: no reduction from a known NP-complete problem is given, and none is claimed here. Whether the defeater-free monotone fragment admits polynomial-time search is unknown and is the open attack surface left by the hunt."},"date":"2026-11-20","decision_problem":"RECIPE-COMPOSITION-SEARCH: given a subject timeline T over the signal vocabulary of lead-recipe-os, does there exist a composed recipe, a LogicNode tree over registered signals satisfying the composer validity rules in lead_recipe_os/composer/compose.py and lead_recipe_os/composer/validate.py, whose membership evaluation by lead_recipe_os/signals/graph.py evaluate_logic against T returns SATISFIED? The registry version, RECIPE-SEARCH, asks the same question with the recipe ranging over the 558 registered recipes instead of over composed trees. This file is a formalization and audit, not a proof attempt. It claims neither that P equals NP nor that P does not equal NP.","hunt_findings":[{"claim":"Registry search is trivially in P by measurement, not by argument: 558 recipes verify in 0.0718 seconds.","evidence":"Ran lead_recipe_os/registry/store.py load_default() and lead_recipe_os/signals/graph.py evaluate_logic over all 558 recipes against one subject. Empty timeline sweep: 0.0093 seconds, 557 UNKNOWN, 1 SATISFIED (the META recipe with no logic). Full-evidence timeline (every signal PRESENT at HIGH confidence, VERIFIED basis): 0.0718 seconds, 140 SATISFIED, 11 CONTRADICTED, 407 UNKNOWN. Membership logic leaf counts: min 0, median 2, mean 2.09, max 8, total 1167 leaves. Largest recipe res_transition_cluster_two, 8 leaves.","numbers":{"contradicted_full_evidence":11,"ingredients":107,"max_leaves":8,"median_leaves":2,"recipes":558,"satisfied_full_evidence":140,"signals":317,"sources":154,"sweep_seconds_empty_timeline":0.0093,"sweep_seconds_full_evidence":0.0718,"territories":3293,"total_membership_leaves":1167,"unknown_full_evidence":407}},{"claim":"The NP shape lives in composition, not in registry lookup: the composition space is 2^317 required-signal subsets while any single verification is linear.","evidence":"Exact binomial counts over the measured signal vocabulary S=317: C(317,3) is 5259030, C(317,5) is 25843399323, and the cumulative count for required sets of at most 3 clauses is 5309433. Each candidate verifies in O(k) clause evaluations. The count covers required subsets only; any_of groups, negative and absent clauses, temporal windows, sequence, recurrence, and relations multiply the space further.","numbers":{"C317_3":5259030,"C317_5":25843399323,"bounded_k_le_3":5309433,"bounded_k_le_5":26261542611,"signals":317,"subsets_2_pow_317_digits":96}},{"claim":"Membership is NOT monotone in evidence: a recipe can match on less evidence and unmatch on more, because of the defeater rule.","evidence":"Ran evaluate_logic on NOT(leaf('ownership.government', defeater=True)) using the real evaluator. Empty timeline: SATISFIED with reason 'defeater unresolved: only a resolved contradiction defeats'. Same logic after adding a PRESENT instance of ownership.government: CONTRADICTED. The code path is lead_recipe_os/signals/graph.py, NOT branch with child_clause.defeater. By contrast, a plain 3-clause ALL recipe progressed UNKNOWN, UNKNOWN, UNKNOWN, SATISFIED as its three signals were added one at a time, so the non-monotonicity is specific to the defeater/NOT path, not to ALL.","numbers":{"all_outcome_sequence":["UNKNOWN","UNKNOWN","UNKNOWN","SATISFIED"],"defeater_outcome_no_evidence":"SATISFIED","defeater_outcome_signal_present":"CONTRADICTED"}},{"claim":"Random composed recipes show a sharp phase transition in clause count: match probability tracks p^r, so matches vanish exponentially fast as required clauses grow.","evidence":"200 random trials per cell. Random ALL recipes of r required clauses drawn from the 317 signals, evaluated against a timeline where each chosen signal is PRESENT independently with probability p. Measured satisfied fractions: p=0.5 gives 0.52 at r=1, 0.235 at r=2, 0.115 at r=3, 0.02 at r=5, 0.01 at r=8, 0.0 at r=12 and r=20. p=0.25 gives 0.335 at r=1, 0.085 at r=2, 0.01 at r=3, 0.0 from r=5 on. p=0.75 gives 0.74 at r=1, 0.47 at r=3, 0.255 at r=5, 0.1 at r=8, 0.035 at r=12, 0.0 at r=20. Predicted p^r values: p=0.5 gives 0.5, 0.25, 0.125, 0.0312, 0.0039, 0.0002. The p=0.25 r=1 cell ran high (0.335 measured vs 0.25 predicted) on 200 trials; reported as measured, not smoothed.","numbers":{"p0.25_r1":0.335,"p0.25_r5":0.0,"p0.5_r1":0.52,"p0.5_r12":0.0,"p0.5_r3":0.115,"p0.5_r5":0.02,"p0.5_r8":0.01,"p0.75_r12":0.035,"p0.75_r20":0.0,"trials_per_cell":200}},{"claim":"Full evidence does not decide most recipes: 407 of 558 stay UNKNOWN even with every signal PRESENT.","evidence":"Full-evidence sweep outcome counts: 140 SATISFIED, 11 CONTRADICTED, 407 UNKNOWN. Presence alone is not enough because many clauses need values, dates, or relations: comparison clauses with no comparable value return UNKNOWN, temporal ops need event dates, and NEAR/ADJACENT need a resolved RelationContext. Verification stays linear, but decidability is limited by evidence quality, not by clause count.","numbers":{"contradicted":11,"satisfied":140,"total":558,"unknown":407}},{"claim":"The registry has grown past its own ADR: ADR-0004 (2026-09-22) states 30 canonical plus 23 DeedSonar-derived plus 500 curated recipes, 310 signals, 101 ingredients, 134 sources; the loaded registry measures 58 canonical library and 500 curated recipes, 317 signals, 107 ingredients, 154 sources, 3293 territories.","evidence":"Counts measured by running load_default() on repo main (repo updated 2026-10-03). Lifecycle split measured: PROPOSED 262, QUALIFIED 283, SHADOW 11, PRODUCTION 2. Only 244 of 317 signals appear in any recipe membership logic; 73 signals are never used there.","numbers":{"lifecycle_production":2,"lifecycle_proposed":262,"lifecycle_qualified":283,"lifecycle_shadow":11,"recipes_canonical_library":58,"recipes_curated_library":500,"signals":317,"signals_never_used_in_membership_logic":73,"signals_used_in_membership_logic":244}}],"hunt_verdict":"The hunt found the sharp edge of this object, and it is not where the registry is. Registry search is settled: 558 recipes, 1167 clause evaluations, 0.0718 seconds, in P by measurement. The live question is composition search, where the candidate space is 2^317 required-signal subsets and verification of any one candidate is linear. Two structural facts point at the attack surface. First, bounded-clause composition is polynomial for fixed k (5,309,433 candidates at k<=3), so any hardness must live at unbounded clause counts, and the measured phase transition says matches there are exponentially rare, which cuts both ways: rare matches make search hard to do by sampling and make the decision problem easy to answer no on random instances. Second, the defeater rule breaks monotonicity of membership in evidence: a recipe matches with the defeater unresolved and unmatches once it resolves. That removes the monotone-fragment toolkit from the full logic and marks the defeater-free fragment as the place to test whether polynomial search exists. No finding here separates or collapses P and NP, and none is claimed: the object is a concrete complexity object with measured numbers, the barriers map the dead ends, and the open move is to test the defeater-free fragment for a polynomial search algorithm or a hardness reduction.","search_cost":"Registry search costs one linear scan: 558 recipes times an average of 2.09 clause evaluations, 1167 clause evaluations total, measured at 0.0718 seconds for a full-evidence subject. Composition search by enumeration costs one verification per candidate: 2^317 verifications unbounded, or 5309433 verifications for required sets of at most 3 clauses. The gap between search cost and verification cost is the whole object: verification is linear and measured in milliseconds, exhaustive composition search is exponential in the signal count.","search_space":"Two spaces, very different sizes. Registry space: the 558 recipes in the loaded registry (58 canonical library, 500 curated library), measured by running lead_recipe_os/registry/store.py load_default() on repo main. Composition space: all LogicNode trees the composer can build over the 317 registered signals. Counting required-signal subsets alone, the space has 2^317 members, a 96-digit number (266998379490113760299377713271194014325338065294581596243380200977777465722580068752870260867072). Bounded by at most k required clauses, the count is polynomial in 317 for fixed k: k<=1 gives 317, k<=2 gives 50403, k<=3 gives 5309433, k<=4 gives 418143288, k<=5 gives 26261542611. The count covers required subsets only; the composer also varies any_of groups, negative and absent clauses, boost and qualifying clauses, temporal windows, sequence, recurrence, near and adjacent relations, sources, states, and weights, which multiply the space further.","sources":["NeuruhAI/lead-recipe-os README.md","NeuruhAI/lead-recipe-os docs/adr/0001-constitutional-ruling.md","NeuruhAI/lead-recipe-os docs/adr/0004-lead-gen-god-core.md","NeuruhAI/lead-recipe-os contracts/core/recipe-def.v1.schema.json","NeuruhAI/lead-recipe-os contracts/core/signal-def.v1.schema.json","NeuruhAI/lead-recipe-os contracts/core/query-spec.v1.schema.json","NeuruhAI/lead-recipe-os lead_recipe_os/factory/ranking.py","NeuruhAI/lead-recipe-os lead_recipe_os/opportunity/evaluate.py","NeuruhAI/lead-recipe-os lead_recipe_os/composer/compose.py","NeuruhAI/lead-recipe-os lead_recipe_os/composer/validate.py","NeuruhAI/lead-recipe-os lead_recipe_os/signals/graph.py","NeuruhAI/lead-recipe-os lead_recipe_os/signals/model.py","NeuruhAI/lead-recipe-os lead_recipe_os/registry/contracts.py","NeuruhAI/lead-recipe-os lead_recipe_os/registry/store.py","NeuruhAI/lead-recipe-os lead_recipe_os/registry/seed/recipes_canonical.py","NeuruhAI/lead-recipe-os lead_recipe_os/registry/seed/recipes_curated.py","NeuruhAI/lead-recipe-os lead_recipe_os/registry/seed/signals.py","NeuruhAI/lead-recipe-os lead_recipe_os/registry/seed/ingredients.py","NeuruhAI/lead-recipe-os lead_recipe_os/registry/seed/sources.py","NeuruhAI/lead-recipe-os lead_recipe_os/registry/seed/territories.py","NeuruhAI/lead-recipe-os lead_recipe_os/registries/data/national_county_fips.json"],"verification":"Verification is evaluate_logic in lead_recipe_os/signals/graph.py: a recursive walk of the recipe LogicNode tree. Each leaf costs one evaluate_clause call, which is one SignalTimeline.best lookup plus at most one comparison. The evaluator visits every leaf exactly once (children are evaluated eagerly, with no short-circuit), so verification cost is linear in the number of leaves. Measured on the real registry: membership logic has min 0, median 2, mean 2.09, max 8 leaves per recipe, 1167 leaves total across all 558 recipes. The largest recipe is res_transition_cluster_two with 8 leaves. Verifying all 558 recipes against one subject took 0.0093 seconds with an empty timeline and 0.0718 seconds with every signal PRESENT. A certificate for a composed recipe is the LogicNode tree plus its evaluation trace, and checking it costs linear time in the leaf count."}