diff --git a/.claude/board/EPIPHANIES.md b/.claude/board/EPIPHANIES.md index cf2f5ec92..566441a92 100644 --- a/.claude/board/EPIPHANIES.md +++ b/.claude/board/EPIPHANIES.md @@ -1,3 +1,498 @@ +## 2026-08-20 — E-THE-COMPAT-ENUM-WAS-EATING-HALF-THE-REGISTER-1 + +**Status:** FINDING (measured + fixed, PR #971). `CausalEdgeV3::rehydrate` +routed the stored 4-bit signed inference mantissa through +`InferenceType::from_mantissa(...) → pack(...) → to_mantissa()`. That enum is a +**lossy compatibility projection** — 8 mantissa states onto 16 — so the round +trip silently rewrote **8 of the 16 states**: + +| m | old rehydrate gave | m | old rehydrate gave | +|---|---|---|---| +| −8 | +1 | −3 | −1 | +| −7 | +7 | −2 | −1 | +| −5 | +5 | **0** | **+1** | +| −4 | +4 | +3 | +5 | + +`0 → +1` is the one that matters most: **every `pack_v2` edge defaults to +mantissa 0**, so the neutral/identity state was being rewritten to Deduction on +any lift-and-rehydrate. Fixed by carrying the RAW nibble — +`set_inference_mantissa(m)` after `pack`, with the `InferenceType` argument +demoted to a throwaway placeholder. + +**Why it hid, and the reason is the generalisable half.** *Exactly half* the +states survive the projection (−6, −1, +1, +2, +4, +5, +6, +7). A projection +that failed on everything would have been caught by the first test written; one +that is right half the time looks like a working codec until someone sweeps it. +And the sweep that would have caught it was structurally impossible where the +type is actually exercised: the Stage-2.6a planner parity harness only ever +carries `InferenceType::Deduction` (mantissa +1) — **a surviving state** — so a +harness that is correct, green, and genuinely load-bearing was blind to this by +construction. *A parity harness proves the two legs agree; it says nothing about +whether the conversion under them is total.* Conversion correctness needs its +own low-level exhaustive suite, and now has one +(`causal-edge::edge_v3::tests`, 11 tests, 5 disable-runs verified red). + +**Same pass, the other half of the leak: three CE64-v2 fields were being +dropped entirely** — `w_slot` (6 bits), the truth/topology register (2), the +spare/`ReasoningBand` register (3) — all of which became meaningful state with +#970. They now land in V3's dormant reserved bytes (`[8]` = `w_slot(6) | +truth(2)<<6`, `[9]` = `spare(3)`), preserved as **RAW ORDINALS**: copying +ordinal `01` across means "ordinal 01 preserved", never "`IndirectKnown` is now +source-authoritative". Under v2 the 64 bits are fully partitioned, so +`CausalEdge64 → V3 → CausalEdge64` with the same resupplied SPO is now +**bit-identical** — asserted as whole-register equality, which is what catches a +field a future session forgets to enumerate. + +**The two exclusions are principled, not residue.** (1) The 24-bit in-edge SPO +— intentionally deduplicated into the target node's CAM-PQ facet. (2) The +deprecated v2 `temporal` — *not valid CE64-v2 state at all* (bits 52..63 are the +reclaim zone), so it is NOT mapped into V3's TE; TE stays an independent +producer-set signed chain offset. + +**A method note worth keeping.** One of the five disable-runs used a malformed +`sed` pattern that matched nothing, and the resulting green read exactly like +"this carry is not load-bearing." It was re-run with an exact-string edit that +*asserts the anchor exists* before removing it, and went red immediately. This +is `E-ANTI-EIGENVALUE…`'s twin at the tooling layer: **a disable that does not +disable is indistinguishable from a guard that does not guard**, and only the +anchor assertion tells them apart. Cf. tesseract-rs's "turning a knob that does +not bind is not a disable." + +--- + +## 2026-08-20 — E-CAPABILITY-IS-NOT-REACHABILITY-1 + +**Status:** FINDING (measured; codex review on PR #971, third pass). The same +lesson a **third** time, one rung finer each round: + +| round | the predicate that looked right | why it was not | +|---|---|---| +| 1 | *(none — no filter at all)* | context-blind watchers counted as agreement | +| 2 | `maturity().is_production()` | `Operational` is a DISJUNCTION; 31 admitted, only 14 can move `delta_conf` | +| 3 | `moves_confidence()` | capability on SOME input ≠ reachability in THIS dispatched context | + +**The measurement.** `Mcp` (recipe 10) declares `moves_confidence() == true` +and that declaration is *true* — its branch needs +`confidence > 0.7 && free_energy > 0.5`. But `thought_ctx_from` starts at +`ThoughtCtx::new`'s `free_energy = 0.5`, and **exactly one** of the 34 kernels +writes that field at all (`Rte`, id 1), which only decays it. Swept over all +36 styles × 5 rungs: `free_energy` **never exceeds 0.5**, and `Mcp` moves +confidence in **0 of 180** cells. It is admitted by the filter and is +guaranteed silent. + +**Deliberately NOT fixed, and the reason is not laziness.** + +1. **A reachability filter is close to circular for the budget argument.** + Deciding whether watcher `W` can move the answer in context `C` essentially + requires evaluating `W` in `C` — which is what sampling it already does. The + slot is not saved. What a reachability notion would genuinely buy is a + refusal to count a *structural* silence as agreement — which is a change to + what **dissent means**, not a filter tweak. +2. **That is Stage-3's decision**, alongside the other half of the same + question (the 17 Operational-but-mute kernels), and making it here would + move the Stage-2.5 baseline the operator has just frozen as authoritative. + +**What generalises past this instance.** Each round the predicate was a true +statement about the *producer* and a wrong statement about what the *consumer* +observes. That is the same shape as `E-THE-RECIPE-SURFACE-IS-CAUSALLY-BLIND-1` +(substrate the projection does not carry in) and the 17 mute kernels (effects +the projection does not carry out). **Three independent measurements, one +underlying fact: `ThoughtCtx` is a lossy projection and every predicate written +against the producer side will keep being wrong about the consumer side until +that projection is made explicit.** Tracked in +`TD-THOUGHTCTX-IS-A-LOSSY-PROJECTION`. + +**Two comparator hardenings landed in the same pass** (both codex, both real): +the Stage-2.6a resolver now goes through the V3 edge's OWN `target()` instead +of a side channel — a regressed `from_v1`/`target()` would previously have been +invisible because both arms resolved the expected SPO from the spec; and the +corruption falsifier now requires the **weight-side** leg to fail on a +*composition* invariant, because the input-side assertion alone let the weight +rehydration be replaced with the direct edge and bypass V3 unnoticed. +Disable-verified: that bypass now fails, and previously passed. + +--- + +## 2026-08-20 — E-THE-RECIPE-SURFACE-IS-CAUSALLY-BLIND-1 + +**Status:** FINDING (Stage 2.6b — recorded, deliberately NOT patched; operator- +ruled scope). Falsifies the premise of the original Stage-2.6 brief, which +assumed an `CE64 → recipe/runbook/planner` path. + +**That path does not exist.** Three independent checks: + +| check | result | +|---|---| +| `lance-graph-contract` (owns `recipe_kernels`, `recipes`, `recipe_dispatch`, `materialize`) depends on `causal-edge`? | **No dependency.** It cannot name the type; the two textual hits are prose inside doc-comments. | +| `style_strategy` — the Stage-2 planner surface — touches a causal edge? | **None.** Its one `causal_*` import is `causal_witness`, an unrelated contract type. | +| What produces the `ThoughtCtx` the 34 recipes reason over? | `thought_ctx_from(&PlanContext)` — exactly two scalars: `free_will_modifier` → temperature, `features.estimated_complexity` → one candidate. `nars_hint` and `witness` are NOT read by it. | + +So **recipe/runbook reasoning is causally blind with respect to CE64/V3.** + +**Why this is recorded rather than fixed.** A V3 entrance in front of that +surface would rehydrate an edge nothing downstream reads, and the invariance +test would return `discordance = 0` for an entirely trivial reason — a green +result that means nothing. That is the same failure +`E-THE-FILTER-WAS-FILTERING-ON-THE-WRONG-PREDICATE-1` had just corrected, hours +earlier, in the same PR. **This is NOT a V3 migration defect**; it is a Stage-3 +substrate-wiring question, and stuffing CE64 fields into `ThoughtCtx` now would +be adding semantic information the recipes do not have today — which Stage 3 +explicitly reserves. + +**The sharper statement the finding generalises to.** `ThoughtCtx` is not "the +reasoning state"; it is a **lossy projection of the reasoning substrate**, and +two independent measurements this session show the cost of that projection from +opposite sides: + +- **Input side (this entry):** the causal/NARS/witness substrate exists and the + projection does not carry it in. +- **Output side (`E-THE-FILTER-WAS-FILTERING-ON-THE-WRONG-PREDICATE-1`):** 17 of + 34 kernels are `Operational` and confidence-MUTE — they write `candidates` / + `rung` / `temperature` / `beliefs`, and the dissent consumer observes only + `confidence`, so their real effects are invisible to it. + +**The 17 are not stubs, and must not be "fixed" by making them move +confidence.** Their silence means *the consumer projection is narrower than the +producer effects*, and rewriting them to move confidence would destroy exactly +the distinction this audit discovered. Stage 3 decides whether dissent becomes +(A) a multidimensional comparison over declared `writes()`, (B) per-capability +watchers, (C) a projection into a common epistemic space, or a measured +combination. **Not decided here.** + +**Consequence for Stage 3's handoff — two distinct wiring problems, and keeping +them distinct is load-bearing:** + +1. **Edge semantics.** `CausalEdgeV3` (addressed, semantic, durable) + + `CausalEdge64` (hot compact NARS projection); the planner's `nars_engine` + leg is now proven representation-invariant (Stage 2.6a). +2. **Program/recipe semantics.** 34 recipes × 36 styles operate on a narrower + `ThoughtCtx` projection; the 17 mute kernels are the measured cost. How + causal/NARS/V3/witness information enters the program surface **without + turning every effect into confidence** is the open question. + +Cross-ref: `TD-THOUGHTCTX-IS-A-LOSSY-PROJECTION`. + +--- + +## 2026-08-20 — E-V3-IS-REPRESENTATION-INVARIANT-ON-THE-PLANNER-CE64-LEG-1 + +**Status:** FINDING (Stage 2.6a; `cache/stage26_v3_parity.rs`, artifact +`docs/probes/stage26-v3-planner-parity-discordance.csv`). + +The existing compare-thinking work proved V3 thinking-preserving at +`causal-edge`'s own `syllogize` and on `cognitive-shader-driver`'s real emission +path. The **planner's** `CausalEdge64` leg — `cache/nars_engine.rs`: +`SpoHead ↔ CausalEdge64` via `to_causal_edge` / `from_causal_edge`, and +`forward_edge` over the compose tables — was the uncovered third leg. It is now +covered. + +**Result: planner V3 representation discordance = 0**, by exact equality across +13 invariants per leg — the rehydrated `CausalEdge64` itself, SPO after +resolution, NARS frequency/confidence, causal mask, inference class, the +`SpoHead` round-trip, the `forward_edge` conclusion, that conclusion's +`SpoHead`, the `syllogize` conclusion edge, and the derived truth/expectation. +Representation-specific fields (V3 Lokal target, TE, payload width) are +deliberately NOT compared — asserting on those would be asserting that V3 *is* +CE64. + +**One reasoning implementation.** The V3 arm computes nothing: it drops the +in-edge SPO, resolves it back from the target node's facet, rehydrates a +`CausalEdge64`, and hands it to the *same* `NarsEngine` methods. No V3-native +NARS exists. + +**The falsifier is what makes the zero mean anything.** Equivalence is +conditional on `resolved node facet SPO == the original edge's SPO`, so the +harness corrupts ONE facet binding and requires the comparator to go red — +and requires it to stay LOCALISED (fewer than all legs discordant, and the +SPO-shaped invariants specifically the ones that fire). Verified: bypassing +`rehydrate` entirely leaves the primary test green and fails **only** the +falsifier, which is precisely the vacuity the falsifier exists to catch. + +**A disable-run corrected one of my own claims.** The degeneracy guard first +asserted "`forward_edge` changed the edge on some leg", documented as proving +the compose tables are not inert. Measured: making every table the identity +left that assertion **green**, because `forward` also composes the NARS truth. +The discriminating form is SPO-specific (`spo_of(fwd) != spo_of(input)`), which +does fail under that disable. The weak form is kept alongside it, with the +measurement written next to both. + +**JC's role, and where it stops.** Every quantity at this seam is exact — `u8` +palette indices, `u8` truth bytes, a `u64` register — so **there is no naturally +continuous quantity here for a correlation to characterise, and none was +manufactured**. `jc::stats::binary_association` summarises the syllogism-presence +cross-tab: both categories occur across the sweep, so κ is **defined** and equals +1.0 — a real statement rather than the degenerate constant-column case. Exact +discordance remains the contract. + +--- + +## 2026-08-20 — E-THE-FILTER-WAS-FILTERING-ON-THE-WRONG-PREDICATE-1 + +**Status:** FINDING (measured; corrects `E-A-WATCHER-THAT-CANNOT-DISSENT-IS-NOT-A-WATCHER-1` +and **⊘ STORNOES the headline of** `E-THE-COVERAGE-FIX-IS-REAL-AND-ASYMMETRIC-1`, +both written earlier the same day on this branch). Origin: codex review on +PR #971, against the first version of `StyleStrategy::watcher_can_dissent`. + +**The claim that was wrong.** Both entries above reported that the consumer +filter changes which watchers are sampled but changes **no verdict** — 0 of +5,760 paired configurations, on both channels, κ = 1.000000. The measurement +was sound. The predicate it measured was not. + +`watcher_can_dissent` filtered on `maturity().is_production()`. But +`Operational` is a **disjunction** — `maturity_operational_implies_an_effect` +requires *mutates some `ThoughtCtx` field* **OR** *moves confidence* — while +both dissent channels compare exactly one quantity, `tc.confidence`. Measured +over the 34 kernels: + +| | count | +|---|---| +| `Operational` | **31** | +| can move `delta_conf` | **14** | +| declare `ThoughtField::Confidence` in `writes()` | **0** | + +So the filter removed 3 mute watchers and admitted **17 more that were equally +mute** — it *preserved the exact budget loss it was introduced to remove*. The +sharpest cases are `Cas` and `Etd`, both carved to production in this same +arc: both rewrite `candidates`, both return `0.0` forever. + +**The fix, and why it needed a new contract method.** Capability is not +derivable from anything the trait previously exposed: `writes()` is the census +of `&mut ThoughtCtx` mutations, and `delta_conf` is applied by `run()` +*afterwards* — deliberately a separate effect, which is why +`no_kernel_writes_outside_its_declared_mask` calls `apply` directly. So +`Tactic::moves_confidence()` was added: non-defaulted like `requires` and +`maturity`, declared per kernel, and pinned **two-sided** against the probe +matrix (`moves_confidence_matches_observation` — over- and under-declaring both +fail) plus a subsumption pin (`moves_confidence` ⇒ `Operational`, checked +rather than commented, so the consumer can filter on capability alone without a +redundant maturity conjunct). + +**The corrected result inverts the headline.** + +| channel | sample changed | mean Jaccard dist | retention | **verdict change** | κ (fired) | +|---|---|---|---|---|---| +| same-family | 4080/5760 (70.8%) | 0.5306 | 0.4958 | **1098/5760** | 0.6307 | +| cross-family | 4224/5760 (73.3%) | 0.5269 | 0.5681 | **384/5760** | 0.8098 | + +**And it has a direction, which is the part worth keeping.** On the same-family +channel `n10 = 0` **exactly**: no configuration that dissented with the filter +OFF goes silent with it ON. That is the coverage argument turned into a +measurement — removing only structurally-mute watchers cannot remove an +objection, because a mute watcher could not have raised one. Dissent rises +2514 → 3612 (+43.7 %). + +Cross-family is *almost* one-way: 366 gained against **18 lost**, and the 18 +are the SAMPLER, not the filter. `peripheral_sample_where` strides `k` picks +over the eligible list, so shrinking that list changes *which* capable watchers +are picked; a capable dissenter selected under OFF can fall off the stride +under ON. Pinned exactly rather than rounded to "one-way". + +**Three process findings, each independent of the numbers.** + +1. **A green census is not a correct census.** The Stage-2.5 harness measured + the filter faithfully and reported zero — because it was pointed at a + predicate that could not matter. Nothing in the suite could have caught + that; it took a reader who asked what `Operational` actually guarantees. + The census *did* earn its keep the moment the predicate changed: it went red + on the first run and named the number. +2. **The report hardcoded its own conclusion.** `render_report` wrote + `**Verdict change: 0/{n}.**` as a literal in the format string — so it + would have printed zero regardless of what was measured, and did, for one + revision after the correction landed. A report that *states* its result + instead of deriving it is not a measurement. Now computed from + `binary_association`, and the test is what caught it. +3. **A coarse label can certify something it never looked at.** The + cross-family verdict is `(RungLevel, Mechanism)`; the census reduced it to + the rung, so a swap to a different mechanism at the same rung would have + counted as agreement while the report claimed the mechanism agreed exactly. + Both components are now encoded into one nominal label (`cross_label`). + (Also codex, PR #971.) + +**Bound reporting, made reproducible** (CodeRabbit, PR #971). The zero-event +Clopper-Pearson limit `1 − α^(1/n)` is now stated with **α = 0.05 (95 % +one-sided)**, and it is repointed at the surface that IS still zero — the +same-family `n10`. Each rung of the clustering ladder names its independent +unit: one `(style, rung, k, tol)` cell (5760, optimistic); one `(style, rung)` +cell (144, `k`/`tol` as within-cell repeats); one style (36, a 160-cell block +as one observation); one style cluster (6, styles sharing a `Mechanism` — the +most conservative unit the design offers). + +--- + +## 2026-08-20 — E-THE-COVERAGE-FIX-IS-REAL-AND-ASYMMETRIC-1 + +**Status:** ⊘ HEADLINE SUPERSEDED same-day by +`E-THE-FILTER-WAS-FILTERING-ON-THE-WRONG-PREDICATE-1` — the watcher-sample +numbers below stand, the `0/5,760` verdict claim does NOT. FINDING (measured; `strategy/stage25_census.rs`, artifacts at +`docs/probes/stage25-consumer-filter-census.{md,csv}`). Quantifies +`E-A-WATCHER-THAT-CANNOT-DISSENT-IS-NOT-A-WATCHER-1`, which recorded the same +result qualitatively and could not say how large it was. + +The Stage-2 consumer filter was documented as "a coverage fix, not a behaviour +change" on the strength of one sentence — *changes which watchers are sampled, +changed no verdict*. Stage 2.5 measured both halves with `jc::stats` over the +same exhaustive 5,760-cell paired design, and **the two channels are not the +same size of effect**: + +| channel | configs changed | mean Jaccard distance | mean retention | max sym-diff | verdict change | +|---|---|---|---|---|---| +| same-family (`peripheral_dissent`) | 1440/5760 (25.0%) | 0.1265 | 0.9028 | 6 | **0/5760** | +| cross-family (`cross_family_dissent`) | 2400/5760 (41.7%) | 0.2599 | 0.7993 | 12 | **0/5760** | + +**Pooling them was the first thing that had to go.** The pooled mean is 0.1932, +which fell just under a 0.20 cutoff and produced the single word "weakly" for +two channels differing by a factor of two. That is a threshold artifact of the +kind this workspace's own falsifiability rule warns about — the report now +grades per channel against a stated rule (`≥ 0.20` mean Jaccard distance OR +`≥ ⅓` of configurations changed ⇒ *materially*), so the word is checkable +rather than editorial. **Cross-family is material; same-family is weak.** + +**Where the effect lives.** Concentrated exactly where the silent watchers do: +`Surface`/`Shallow` carry all three (`ARE` 19, `ZCF` 24, `HKF` 34), and the +peak cell replaces **more than half** the sample (cross-family +`Surface`/`k=3`: Jaccard distance **0.5667**). It falls to exactly 0.0000 at +`Contextual`/`Analogical` for several budgets. Descriptive η² over the design: +same-family is dominated by **style** (0.2761) then `k` (0.1987); cross-family +by **rung** (0.2543) then `k` (0.1795). Style stayed a stratum even though the +Stage-2 verdict surface is inert to it — and it turned out to be the +*largest* factor on one channel, which is the reason to keep an inert-looking +stratum rather than drop it. + +**The verdict half, exactly rather than smoothed.** 0 discordant of 5,760 on +BOTH channels, on the FINE label (the elevation `RungLevel` — which watcher +objected — not merely fired/not-fired). Cohen's κ = 1.000000 and, importantly, +**defined**: both outcome categories occur (n11=2514/n00=3246 and +n11=4290/n00=1470), so the perfect agreement is a real measurement and not the +degenerate constant-column case `jc::stats::cohen_kappa` refuses to score. +**McNemar is deliberately NOT reported** — it is a test on the discordant +cells and there are none, so the statistic is degenerate, not significant. + +**The bound is a ladder, not a number.** With zero events the exact +one-sided Clopper-Pearson limit is `1 − α^(1/n)`; the 5,760 rows are repeated +measures (one style contributes 160), so quoting `5.2e-4` would assume an +independence the design does not have. Reported at every clustering +assumption — cell `5.2e-4` · style×rung `2.1e-2` · style `8.0e-2` · cluster +`3.9e-1` — with the instruction to quote the one whose independence you are +willing to defend. + +**A methodological note that generalises past this measurement.** No +inferential test is run over the census, and the report says so in its own +header: the enumeration is exhaustive and deterministic, so there is no +sampling distribution for a p-value to describe. `jc`'s `t_test_*` / +`anova_one_way` p-values are therefore not reported; what IS used is +cross-tabulation, variance decomposition, and rank association — the things a +census can honestly support. The one exception is the zero-event bound, which +is a statement about an unobserved population and is exactly where inference +belongs. + +Also recorded: `multiple_r_squared`'s joint figure is **smaller** than the +largest single η² on one channel (0.0545 vs 0.2761), and that is not a +contradiction — it fits the factors as LINEAR predictors over integer codes +while η² groups them nominally, so a factor whose effect is non-monotone in +its code (style, whose code is an enum position) is largely invisible to the +linear fit. Read as *"how much a linear read of the design explains"*, never +as a ceiling. + +--- + +## 2026-08-20 — E-THE-AUDIT-GATE-WAS-PINNING-THE-BUG-1 + +**Status:** FINDING (measured; `examples/recipe_claim_audit.rs`, branch +`claude/carve-nars-kernels`). Sibling to +`E-VACUOUS-ASSERTION-IS-THE-HOUSE-STYLE-1` — a *new* failure shape, not a +restatement. + +Four of the 34 NARS recipe kernels were carved from non-production to +production (CAS 8, ETD 22, ICR 31, SDD 32). The moment they were, the repo's +own census example went **RED** — and the gate it failed was `G2 recipe-weak +set is exactly {CAS,ETD}+{ARE,ZCF,ICR,HKF}`. + +**The audit's arms were written to confirm the defect, not to detect it.** +`8 =>` asserted `unchanged` (candidates, rung and Δconf all untouched) and +reported *"abstraction level computed then discarded — no observable +effect"*. That is a correct description of a bug, encoded as an expectation, +behind an equality gate. Fixing the bug is what breaks the suite. + +This is NOT the vacuous-assertion failure (a test that cannot fail). Every +arm here CAN fail and did. It is the inverse: **an assertion that is real, +two-sided, and pointed at the wrong side of the finding.** A census that +pins "the weak set is exactly W" is only a census while W is a measurement; +the day someone shrinks W, the pin argues against them. + +**What generalises.** A test that records a defect must say, in the test, that +it is recording a defect and what its removal should look like — the +`f_ord_real_defect_pin_*` convention (`E-…-FALSIFIER`) does exactly this and +is the shape to copy. The four arms are now re-pinned to the CLAIMED +POST-CONDITION instead (`realize(c1.candidates == vec![0.0, 1.0] …)`), so a +regression to compute-then-discard fails them again — the pin now points the +other way and the equality in G2 was kept deliberately (`n_inert == 0 && +n_constant == 3`), so a NEW inert kernel is a review, not an absorption. + +**Second, smaller finding in the same arm.** ICR sat in the shared +`19 | 24 | 31 | 34` "input-independent" arm, which varies only `candidates`. +ICR now reads `free_energy`, which that probe never varies — so it would have +reported CONSTANT forever while the kernel discriminated. *The fixture's +shape is part of the coverage*, again, and this time on a probe rather than a +test. + +--- + +## 2026-08-20 — E-A-WATCHER-THAT-CANNOT-DISSENT-IS-NOT-A-WATCHER-1 + +**Status:** ⊘ CORRECTED same-day by +`E-THE-FILTER-WAS-FILTERING-ON-THE-WRONG-PREDICATE-1` — the MECHANISM below is +right and is why the arc exists; the "measured null" is an artifact of +filtering on the wrong predicate and is retracted. FINDING for the mechanism; +~~**MEASURED NULL** for its present effect~~. Both halves recorded, because the second is what stops the first +being overclaimed. + +`StyleStrategy::{peripheral_dissent, cross_family_dissent}` sample `k` +peripheral tactics as observers and elevate the rung if one of them moves the +score. Their eligibility predicate filtered on `Mechanism` only. But a +`Demonstration` kernel lands **no effect by construction** — enforced, in the +contract crate, by `non_operational_kernels_land_no_effect` — so sampling one +spends a `k` slot on an observer that *structurally cannot dissent*, and its +guaranteed silence is then counted as agreement. + +That is `E-ANTI-EIGENVALUE-MACHINERY-CAN-ITSELF-BECOME-THE-EIGENVALUE-1` +inverted. The can-fire / can-stay-silent pair asks whether a guard +discriminates; this asks something prior — **whether the instrument is +connected at all**. A watchdog that can never bark reports the same silence +as one with nothing to bark at, and only the first is a lie. + +Measured periphery before the fix: `Surface`/`Shallow` carry 3 silent +watchers of 30 (ARE 19, ZCF 24, HKF 34); `Contextual`/`Analogical` carry 1 of +23 and 1 of 10. + +**The null, stated plainly.** Adding the maturity clause visibly changes WHICH +watchers are sampled (the eligible list shrinks, so the stride moves — e.g. +`Surface`/`StructuralDivergence`/same/`k=8` goes `[4,6,9,13,23,28,31,34]` → +`[4,6,9,13,23,28,31]`), but across the full **5,760-cell** sweep of +style × rung × `k` ∈ {1,2,3,4,8} × `tol` ∈ {0, .001, .005, .01, .02, .05, .1, +.2} it changed **no verdict on either channel**. It is a COVERAGE fix, not a +behaviour change, and it is documented at the call site as exactly that. + +**Why the null is not a reason to drop it, and how it is kept falsifiable.** +The channel is emphatically not inert — suppressing the watcher run outright +moves **4,830 of those same 5,760 cells** — so the instrument matters; what +does not currently matter is *which* of the surviving instruments is picked. +A guard with no falsifier would be the anti-pattern, so the falsifier was +written at the level the change actually operates: every watcher the shipped +predicate samples can dissent, **plus** the anti-vacuity half proving the +mechanism clause alone would have sampled one that cannot. Both halves are +disable-verified red. + +**A structural note worth keeping.** The reason the identity of the watcher +does not move the verdict is that `|tc.confidence − admitted|` is dominated by +a term independent of the watcher: `tc` runs the admitted set *and* the +watcher, while `admitted` comes from `reliability_at`, so any admitted-set +effect cancels and any constant offset between the two paths crosses `tol` +regardless of who observes. That is worth measuring before anyone tunes `tol` +against this channel — recorded here rather than acted on, since it is +outside this PR's scope. + +--- + ## 2026-08-19 — E-THE-OU-COLUMN-EXISTS-AND-NOTHING-WRITES-IT-1 **Status:** FINDING (six-agent read-only sweep across lance-graph, ndarray, diff --git a/.claude/board/LATEST_STATE.md b/.claude/board/LATEST_STATE.md index ac4e5cc8d..c5935524a 100644 --- a/.claude/board/LATEST_STATE.md +++ b/.claude/board/LATEST_STATE.md @@ -1,3 +1,374 @@ +## 2026-08-20 — branch `claude/carve-nars-kernels` — CE64 ⇄ V3 conversion losslessness (Stage-3 handoff gate) + +### Current Contract Inventory — 8 new read accessors on `CausalEdgeV3`, no layout change + +- **`CausalEdgeV3`** (`crates/causal-edge/src/edge_v3.rs`) — still exactly 12 + bytes (`const _` size assert unchanged); **two previously-dormant reserved + bytes are now allocated**: + - `[8]` = `w_slot(6 low) | truth/topology RAW(2 high)` + - `[9]` = `spare/ReasoningBand RAW(3 low) | reserved(5 high)` + - `[10..12]` still reserved (pinned by a test that asserts they stay zero). +- **New read accessors** (read-only; no new setters, per the scope fence): + `frequency` · `confidence` · `causal_mask` · `direction` · + `inference_mantissa` · `plasticity` · `w_slot` · `truth_raw` · `spare_raw`. +- **`rehydrate` carries the RAW mantissa.** It no longer routes through + `InferenceType::from_mantissa → pack → to_mantissa` (a lossy compatibility + projection that rewrote 8 of 16 states, `0 → +1` among them). The + `InferenceType` argument to `pack` is now an explicitly-labelled throwaway + placeholder, overwritten by `set_inference_mantissa`. +- **No CE64 layout touch, no `ENVELOPE_LAYOUT_VERSION` bump, no new type, no + `ThoughtCtx` wiring, no Stage-3 semantics.** + +### The conversion contract, now pinned + +`CausalEdge64 → from_v1 → rehydrate(same resolved SPO)` is **bit-identical**, +asserted as whole-register equality over 6 varied non-zero edges (all 4 truth +ordinals, `w_slot` at both ends of its 6 bits, spare across its 3, mantissa on +both signs). Under the v2 layout the 64 bits are fully partitioned, so field +parity *is* bit parity — and the whole-register assertion is what would catch a +field a future session forgets to enumerate. + +Two exclusions, both principled: + +| excluded | why | +|---|---| +| the 24-bit in-edge SPO | intentionally deduplicated into the target node's CAM-PQ facet; resupply it and the round trip is exact | +| the deprecated v2 `temporal` | not valid CE64-v2 state (bits 52..63 are the reclaim zone). NOT mapped into V3 TE — TE stays an independent producer-set signed chain offset | + +`w_slot` / truth / spare are preserved as **RAW ORDINALS**: ordinal `01` +crossing means "ordinal 01 preserved", never "`IndirectKnown` is now +source-authoritative". + +### Gates + +- `causal-edge`: **72/72** under the default v2 layout, **38/38** under + `--no-default-features` (v1). 11 tests in `edge_v3`, of which 7 are new. +- **5 disable-runs, each verified red-then-green** — the old lossy mantissa + path (3 tests red), and each of the `w_slot` / truth / spare / `from_v1` + tail carries individually. +- `cargo fmt --check` and `cargo clippy -D warnings`: **zero hits in + `edge_v3.rs`** in both feature states. (The crate is workspace-EXCLUDED, so + CI never lints it; 7 pre-existing clippy errors in `edge.rs`/`tables.rs` are + untouched and now recorded in `TECH_DEBT.md`.) +- **Requirement 4 — the Stage-2.6 planner parity harness is untouched and + green** (`cache::stage26_v3_parity`, 4 passed / 1 `#[ignore]`d generator). + Both harnesses are needed and neither subsumes the other: the planner leg + only ever carries `InferenceType::Deduction` (mantissa `+1` — a *surviving* + state), so it was structurally blind to the mantissa defect. See + `E-THE-COMPAT-ENUM-WAS-EATING-HALF-THE-REGISTER-1`. +- Downstream consumer `cognitive-shader-driver::edge_v3_compare`: **3/3**. + +--- + +## 2026-08-20 — branch `claude/carve-nars-kernels` — Stage 2.6a: V3 representation invariance on the planner's REAL CE64 leg (measurement only) + +### Current Contract Inventory — no new types; one `#[cfg(test)]` census + +- **`cache::stage26_v3_parity`** — `#[cfg(test)]` sibling under `cache/`, + compiled out of every non-test build. Needs no visibility widening: every + symbol it uses (`NarsEngine`, `SpoHead`, `SpoDistances`, `CausalEdge64`, + `CausalEdgeV3`) is already public. 4 gates + 1 `#[ignore]`d artifact + generator. +- **No production code changed.** No second reasoning engine, no V3-native + NARS, no CE64 layout touch, no `ThoughtCtx` wiring. + +### Scope correction, operator-ratified + +The original Stage-2.6 brief assumed `CE64 → recipe/runbook/planner`. **That +arrow does not exist** — see `E-THE-RECIPE-SURFACE-IS-CAUSALLY-BLIND-1` for the +three checks. Building a V3 entrance there would have produced +`discordance = 0` for a trivial reason. The real uncovered leg is the planner's +`cache/nars_engine.rs`, and that is what this covers. + +| surface | V3 invariance | +|---|---| +| `causal-edge` own `syllogize` | ✅ pre-existing | +| `cognitive-shader-driver` emission path | ✅ `edge_v3_compare` | +| **planner `cache/nars_engine.rs`** | ✅ **this** | + +### Result + +**Planner V3 representation discordance = 0**, by exact equality over 13 +invariants per leg (rehydrated CE64 · SPO after resolution · NARS +frequency/confidence · causal mask · inference class · `SpoHead` round-trip · +`forward_edge` conclusion · that conclusion's `SpoHead` · `syllogize` +conclusion edge · truth frequency/confidence · expectation). Representation- +specific fields (V3 Lokal target, TE, payload width) deliberately excluded. + +The sweep spans every `inference` discriminant `to_causal_edge` maps — including +the two Pearl-rung translations (local `7`→`Intervention`, `8`→`Counterfactual`) +and the lossy `5 | 6`→`Synthesis` fold, which is exactly where a round-trip +could diverge — × every 3-bit pearl mask × truth rails and midpoint × both +palette rails. `temporal` is swept NON-zero on purpose: `to_causal_edge` passes +it to `pack` where the v2 layout makes the write a no-op, so if that ever stops +being a no-op the V3 arm (whose `rehydrate` packs `0`) diverges and this harness +says so instead of the change landing silently. + +### Falsifiers — three disable-runs, all red-then-green + +| assertion | disable | observed | +|---|---|---| +| resolution-conditional equivalence | corruption made a no-op | falsifier FAILS | +| the V3 arm actually goes through V3 | bypass `rehydrate`, use the direct edge | primary stays green, **falsifier FAILS** — which is exactly the vacuity it exists to catch | +| the compose tables are not inert | make every table the identity | degeneracy guard FAILS *(only after strengthening — see below)* | + +**A disable-run corrected one of my own claims.** The degeneracy guard first +asserted "`forward_edge` changed the edge on some leg" and documented that as +proving the tables live. Measured: identity tables left it **green**, because +`forward` also composes the NARS truth. The discriminating form is SPO-specific +(`spo_of(fwd) != spo_of(input)`); both are kept, with the measurement written +next to them. + +### JC's role, and where it stops + +Every quantity at this seam is exact (`u8` indices, `u8` truth bytes, a `u64` +register), so **no naturally continuous quantity exists here for a correlation +to characterise and none was manufactured**. `binary_association` summarises the +syllogism-presence cross-tab — both categories occur, κ **defined** and 1.0. +Exact discordance is the contract. + +### Artifact + +`docs/probes/stage26-v3-planner-parity-discordance.csv` — one row per +discordant invariant. **Header-only is the result**, and it is the shape that +stays useful the day something diverges. + +### Recorded, not patched (Stage 2.6b) + +The recipe/runbook surface is causally blind; the 17 Operational-but-mute +kernels are the output-side twin of the same projection gap. Both are Stage-3 +wiring questions — `E-THE-RECIPE-SURFACE-IS-CAUSALLY-BLIND-1` and +`TD-THOUGHTCTX-IS-A-LOSSY-PROJECTION`. The 3 Demonstrations (ARE/ZCF/HKF) stay +honest Demonstrations; their blocker is a genuine substrate deliverable. + +### Gates + +`lance-graph-contract` 1171/1171 · `lance-graph-planner` 368/368 + 2 ignored · +fmt clean · clippy `-D warnings` clean on both. + +## 2026-08-20 — branch `claude/carve-nars-kernels` — codex + CodeRabbit review corrections: the consumer filter was filtering on the wrong predicate + +### Current Contract Inventory — 1 new trait method (`crates/lance-graph-contract/src/recipe_kernels.rs`) + +- **`Tactic::moves_confidence(&self) -> bool`** — non-defaulted, like + `requires` and `maturity`; 34 per-kernel declarations. Answers the question + the dissent channels actually ask, which **nothing on the trait previously + exposed**: `writes()` is the census of `&mut ThoughtCtx` mutations, while + `delta_conf` is applied by `run()` afterwards and is deliberately a separate + effect. Measured: **31 kernels are `Operational`, only 14 can move + `delta_conf`, and 0 declare `ThoughtField::Confidence` in `writes()`.** +- Pinned two-sided by `moves_confidence_matches_observation` (over- and + under-declaring both fail against the probe matrix) and by + `moves_confidence_is_strictly_stronger_than_production` (the implication is + checked, and so is the strictness — 14 < 31 — so a future reader cannot + conclude the two predicates are interchangeable). +- `maturity_operational_implies_an_effect` now reads the DECLARATION rather + than re-deriving it; re-deriving would let the test pass against a lie. + +### The consumer predicate is corrected — and the Stage-2.5 headline inverts + +`StyleStrategy::watcher_can_dissent` filtered on `maturity().is_production()`. +`Operational` is a disjunction (*mutates a field* OR *moves confidence*) while +both channels compare only `tc.confidence`, so the filter **removed 3 mute +watchers and admitted 17 more** — preserving the exact budget loss it was +introduced to remove. `Cas` and `Etd`, both carved to production in this same +arc, are the sharp cases: both rewrite `candidates`, both return `0.0` forever. + +| channel | sample changed | verdict change | direction | κ (fired) | +|---|---|---|---|---| +| same-family | 4080/5760 (70.8 %) | **1098**/5760 | 1098 gained, **0 lost** | 0.6307 | +| cross-family | 4224/5760 (73.3 %) | **384**/5760 | 366 gained, 18 lost | 0.8098 | + +`n10 = 0` on same-family is the coverage argument as a measurement: removing +only mute watchers cannot remove an objection. The 18 on cross-family are the +strided sampler, not the filter. Full record: +`E-THE-FILTER-WAS-FILTERING-ON-THE-WRONG-PREDICATE-1`. + +### Review findings addressed (7 total, all valid) + +**codex (2 × P2)** — the predicate above; and the cross-family verdict label +reduced `(RungLevel, Mechanism)` to the rung, so a mechanism swap at the same +rung would have counted as agreement while the report claimed the mechanism +agreed. Both components now encode into one nominal label (`cross_label`). + +**CodeRabbit (5 × minor)** — α and the per-rung independent unit now stated on +the Clopper-Pearson ladder; the "byte-identical" wording for `run()` replaced +with behavioural compatibility; the census chunk guard now asserts `rung` +alongside `style_idx` and `k` (the push order is style → rung → k → tol, so +two of three checks could pass on a broken chunking assumption); the report +header's blockquote continuations fixed (source indentation after `\n` turned +them into an indented code block); the `mean |Δcount|` header cell's pipes +escaped (7 cells against a 6-cell rule). + +### Found while fixing the above, and worth its own line + +`render_report` wrote **`Verdict change: 0/{n}` as a hardcoded literal** — it +would have printed zero regardless of the measurement, and did for one revision +after the predicate was corrected. Now computed from `binary_association`; the +re-pinned headline test is what caught it. + +### Artifacts + +`stage25-consumer-filter-verdict-discordance.csv` was header-only and is now +**1,482 rows / 57 KB** — the file whose emptiness was the result now carries +the flips, which is exactly the shape it was built for. + +### Gates + +`lance-graph-contract` 1171/1171 · `lance-graph-planner` 364/364 + 1 ignored · +fmt clean · clippy `-D warnings` clean on both. + +## 2026-08-20 — branch `claude/carve-nars-kernels` — Stage 2.5: the consumer-filter census (measurement only, no semantic change) + +### Current Contract Inventory — no new types; ONE behaviour-preserving extraction + a `#[cfg(test)]` instrument + +- **`StyleStrategy::dissent_over(style, ctx, rung, tol, admitted, watchers)`** + (private) — the shared body of both dissent channels, extracted verbatim. + Takes the ALREADY-SAMPLED watchers rather than the predicate, and returns the + objecting `&'static Recipe` rather than either channel's return shape, so a + caller holding a differently-filtered sample exercises the **shipped** verdict + body instead of a reimplementation — **without production growing a probe + knob**. `peripheral_dissent` / `cross_family_dissent` are now two `.map()`s + over it. + **Proven behaviour-preserving, not asserted:** the 22 pre-existing + `style_strategy` tests pass unchanged, and the full 5,760-cell verdict + signature is **byte-identical** pre- and post-extraction (0/5760 differences). +- **`strategy::stage25_census`** — `#[cfg(test)]` child module of + `style_strategy` (a CHILD, so it reaches `dissent_over` / `watcher_can_dissent` + without widening either to `pub(crate)` for an instrument). Compiled out of + every non-test build. 5 gates + 1 `#[ignore]`d artifact generator. +- **`jc` dev-dependency: already present**, added for D-BLW-3. The census is its + SECOND consumer under the identical standing constraint — dev-only, one + direction, statistics consume observations and nothing feeds back. The comment + in `Cargo.toml` now names both consumers; no new edge was created. + +### Artifacts (`docs/probes/`) + +- `stage25-consumer-filter-census.md` — the human-readable report (A watcher + effect · B verdict effect · C pre-verdict numeric · D stratification · + headline, graded per channel against a stated rule). +- `stage25-consumer-filter-census.csv` — 1,440 rows, one per + style × rung × k × channel. **Collapsed over `tol` losslessly**, licensed by + the pinned invariant that the watcher sample cannot depend on `tol` + (`stage25_tolerance_cannot_move_the_watcher_sample`). The un-collapsed form + was 11,520 rows / ~1 MB with 7 of every 8 rows byte-identical — not "compact" + in any sense the brief meant. +- `stage25-consumer-filter-verdict-discordance.csv` — one row per verdict flip. + **Header-only IS the result**, and it is the shape that stays useful if a + future run flips something, where an all-concordant dump would bury the one + row that mattered. + +### Headline + +Same-family **weakly** (25.0% of configurations, mean Jaccard distance 0.1265, +retention 0.9028) and cross-family **materially** (41.7%, 0.2599, 0.7993) change +watcher sampling; **0/5,760 paired configurations changed verdict** on either +channel, on the fine elevation-target label, κ = 1.000000 and defined. Full +numbers + the clustering ladder for the zero-event bound: +`E-THE-COVERAGE-FIX-IS-REAL-AND-ASYMMETRIC-1`. + +### Guardrails held (each checkable) + +Stage 2.5 changed **no** Stage-2 verdict (0/5760, measured, not argued) · no +watcher-selection change · statistics consume observations and never feed back · +`jc` is instrumentation, not a semantic dependency (dev-only, and the edge +pre-existed) · **no pre-verdict score was added** to obtain part C — the +`|Δconfidence|` margin stays local to `dissent_over`, and what was measured +instead is the finer outcome the harness already exposes · no inferential test +manufactured over an exhaustive deterministic census · style preserved as a +stratum despite being verdict-inert — and it proved to be the largest factor on +one channel. + +## 2026-08-20 — branch `claude/carve-nars-kernels` — the NARS recipe-kernel carve: a maturity gate + four kernels moved from placeholder to production + +### Current Contract Inventory — 2 new types + 1 new field + 3 new policy pins (`crates/lance-graph-contract/src/recipe_kernels.rs`) + +- **`MaturityPolicy { Any, ProductionOnly }`** (`Default = Any`) — which + [`KernelMaturity`] levels a dispatch will let RUN. `ProductionOnly` is the + policy a dispatch that spends a BUDGET wants: a `Demonstration` lands no + effect by construction, so a channel sampling `k` kernels and asking whether + any moved the answer must not spend slots on kernels that structurally + cannot. +- **`SkipReason { GatedOff, NonProduction(KernelMaturity) }`** — carried on the + new **`Outcome::skip: Option`** field (always `None` when + `fired`). `fired: bool` alone conflated "the gate said no on this context" + with "the dispatch refuses non-production kernels"; a caller that cannot + tell them apart cannot report either honestly. +- **`Tactic::run_with(&mut ThoughtCtx, MaturityPolicy) -> Outcome`** — the + policy-carrying sibling. **`run()` is behaviourally unchanged** — it now + delegates with `MaturityPolicy::Any`, so its implementation differs while + every existing caller's observable result does not (pinned by + `run_still_means_any`). The earlier wording here said "byte-identical", which + was wrong about the implementation and right only about the behaviour + (CodeRabbit, PR #971). The policy is checked BEFORE `gate()` on purpose: a + `Gate`-bucket `Demonstration` sitting in `GateState::Flow` would otherwise + report `GatedOff` and the refusal would be invisible. A refused kernel never + sees `ctx` — not `gate`, not `apply`. +- **Policy pins (named, documented as pins, not measurements):** + `NEUTRAL_SCORE = 0.5` (was an unnamed literal inside `Sdd`), + `DISTORTION_WEIGHT = 0.2`, `POLE_SENSITIVITY_WEIGHT = 0.15`. + +### Four kernels carved: 27 Operational → 31; 6 Demonstration → 3; 1 Stub → 0 + +| id | code | was | now | what it does now | +|---|---|---|---|---| +| 8 | CAS | Demonstration | Operational | quantizes `candidates` onto the rung's HDR grid (`hdr_level`) — it computed the level and dropped it | +| 22 | ETD | Demonstration | Operational | splits at the widest adjacent gap, keeps the upper cluster; declines when no gap exceeds `NOISE_FLOOR` — it sorted a CLONE and discarded it | +| 31 | ICR | **Stub** | Operational | split-pole SENSITIVITY: `\|1 − 2·free_energy\| · confidence`, charged. **Explicitly still NOT a Pearl `do()`** — the doc rewrite is in the same commit and `ISS-PEARL-VOCABULARY-WITHOUT-PEARL-MECHANICS` stands | +| 32 | SDD | Demonstration | Operational | charges the distortion it already detected, PROPORTIONAL to the deviation, with an empty-field guard — it detected and returned a hardcoded `0.0` | + +`ARE(19)` / `ZCF(24)` / `HKF(34)` remain Demonstrations, blocked on ONE shared +substrate deliverable (see `TECH_DEBT.md` +`TD-KERNEL-IDENTITY-FINGERPRINT-RAIL`). They are the three the +`ProductionOnly` policy refuses today, pinned as such. + +### Consumer (`lance-graph-planner`) + +- **`StyleStrategy::watcher_can_dissent(id)` + `watcher_is_eligible(r, want, + same_family)`** — one named predicate both dissent channels sample against, + so the falsifier proves the property the channels actually run. Coverage + fix; **measured to change no verdict** across a 5,760-cell sweep, and + documented at the call site as exactly that (`E-A-WATCHER-THAT-CANNOT- + DISSENT-IS-NOT-A-WATCHER-1`). + +### Gates + +`lance-graph-contract` 1169/1169 + all 4 examples green (`recipe_claim_audit` +G1–G4 ALL GREEN after re-pinning; `sound` 30 → 31); +`lance-graph-planner` 359/359 + 22/22 `style_strategy`; `cargo fmt --check` +clean; `cargo clippy --all-targets --no-deps -D warnings` clean on both. +**Nine disable-runs, every one red-then-green** — policy ignored (3 tests), +policy checked after the gate, CAS rung ignored, ETD uniform guard removed, +SDD fixed-cliff, SDD empty guard removed, ICR constant charge, plus both +halves of the consumer falsifier. + +### Re-pinned, not silently widened (each with the reason in the test) + +`context_blind_kernels_are_input_invariant` (4 → 3, ICR is no longer blind); +`maturity_discriminates_and_is_not_all_one_label` (`stub == 1` → `== 0`, plus +a new `demonstration == 3`); `requires_matches_apply_reads` + +`requires_masks_are_varied_not_a_constant_stub` (`empty == 4` → `== 3`); +`icr_builds_counterfactual_via_xor_self_inverse` → `icr_charges_pole_ +dependence_and_is_silent_at_the_midpoint`; the `recipe_claim_audit` arms for +8 / 22 / 31 and its `G2`. + +## 2026-08-20 — lance-graph #970 (MERGED, `781c3b9`) — board hygiene owed and now paid + +### Current Contract Inventory — 2 additive lenses over CE64 bits 59..63 (`crates/causal-edge/src/{layout,edge}.rs`) + +- **`CausalTopology { Direct, IndirectKnownIntermediates, IndirectUnknownIntermediates, Unknown }`** + over bits **59..60** — ordinal-compatible with the existing `TrustTexture` + band that already occupies those bits (`TRUTH_SHIFT`), so it is a second + READING of stored bits, never a relocation. No layout version, no CE64 v3. +- **`ReasoningBand`** (8 levels, `Surface … Transcendent`) over bits + **61..63** — the previously-`SPARE_SHIFT` lens. +- **`CausalEdge64::{topology, reasoning_band, with_topology, with_reasoning_band}`** + — consuming builders matching the crate's existing `with_truth` / `with_spare` + convention (the brief's `set_*` phrasing was bent to current main, not the + reverse). +- **Wire-format impact: none.** `_LAYOUT_COVERAGE` unchanged; every existing + accessor reads the same bits it did before. + ## 2026-08-19 — ARCHITECTURE RESET (operator): DUMB STORAGE × JAVA MECHANICAL API × HHTL EPISTEMIC SPINE — freeze/seal implementation STOPPED - **PR #968 MERGED** (merge commit 66fec27; operator-merged 14:05Z) — the diff --git a/.claude/board/PR_ARC_INVENTORY.md b/.claude/board/PR_ARC_INVENTORY.md index 1347ed98c..8e6d20c6a 100644 --- a/.claude/board/PR_ARC_INVENTORY.md +++ b/.claude/board/PR_ARC_INVENTORY.md @@ -1,3 +1,39 @@ +## 2026-08-20 — lance-graph #970 (MERGED, merge commit 781c3b9, head 8a3cd4e) — CE64: additive `CausalTopology` + `ReasoningBand` lenses over bits 59..63, no wire change + +*(Entry written 2026-08-20 on branch `claude/carve-nars-kernels` — the +hygiene was owed at merge time and not written then. Recorded late rather than +not at all; the omission is the note, per the board's own append-only rule.)* + +- **Added:** `CausalTopology { Direct, IndirectKnownIntermediates, + IndirectUnknownIntermediates, Unknown }` over bits **59..60**, with EXACT + ordinal compatibility to the `TrustTexture` band already stored there + (`TRUTH_SHIFT`) — a second READING of stored bits, never a relocation; + `ReasoningBand` (8 levels `Surface … Transcendent`) over the previously- + `SPARE_SHIFT` bits **61..63**; and four accessors on `CausalEdge64` + (`topology` / `reasoning_band` / `with_topology` / `with_reasoning_band`), + consuming builders matching the crate's own `with_truth` / `with_spare` + convention. +- **Locked:** strictly mechanical and non-breaking — **no bit moved, no + `ENVELOPE_LAYOUT_VERSION` bump, no CE64 v3**; `_LAYOUT_COVERAGE` unchanged; + every pre-existing accessor reads exactly the bits it read before. v1 stub + twins mirror the existing convention. +- **Deferred (explicitly out of scope by the brief, and still out):** + OGAR-loco wiring; the 34 recipes; DisMech integration; HHTL nodes; any NARS + redesign; Rubicon/MUL. +- **Corrections the brief absorbed rather than imposed** — *the brief bends to + current main, never the reverse* (operator, same session): the band type is + the REAL existing `TrustTexture`, not a new name; the builders are + `with_*` (consuming), not the brief's `set_*`. +- **Known trap recorded, not fixed:** `CausalEdge64::temporal()` reads bits + **52..63** and decomposes them as `plast | (w_slot << 1) | (truth << 7) | + (band << 9)`, so `Network::evidence_trail`'s sort by `temporal()` is + sensitive to the 59..63 content these lenses now name. Nothing changed + underneath it; the entanglement is pre-existing and is called out so a + future session does not read the new lenses as its cause. +- **Confidence:** HIGH for the layout claim (const-asserted + ordinal parity + tested); the trap above is a read of shipped code, not a measurement of its + consequences. + ## 2026-08-19 — lance-graph #968 (MERGED, merge commit 66fec27, head 88210f7) — seal STORNO + finalization map + register-grid correction + 5+3-ratified spec (no implementation) — ⊘ SUPERSEDED SAME-HOUR by the DUMB-STORAGE architecture reset - **Added (docs/board/probe only, zero substrate code):** diff --git a/.claude/board/TECH_DEBT.md b/.claude/board/TECH_DEBT.md index 909b41157..245bb6111 100644 --- a/.claude/board/TECH_DEBT.md +++ b/.claude/board/TECH_DEBT.md @@ -1,3 +1,114 @@ +## TD-CAUSAL-EDGE-IS-EXCLUDED-SO-CI-NEVER-LINTS-IT (2026-08-20) — OPEN + +**`causal-edge` is in the root `Cargo.toml`'s `exclude` list, not `members`.** +It therefore builds into its own `crates/causal-edge/target/` and the +workspace's `cargo clippy --workspace -D warnings` gate **never sees it** — +which is why 7 clippy errors have accumulated there unnoticed: + +| file | lint | +|---|---| +| `edge.rs:118` | `if_same_then_else` (the `mag == 5` arm of `InferenceType::from_mantissa` — both branches return `Synthesis`) | +| `edge.rs:200` | `too_many_arguments` (10/7 — the v1 `pack`, kept for back-compat) | +| `edge.rs:684` | `wildcard_in_or_patterns` | +| `edge.rs:742`, `747` | `collapsible_if` ×2 | +| `edge.rs:834` | `too_many_arguments` (8/7 — `pack_v2`) | +| `tables.rs:37` | `doc_lazy_continuation` | +| `v2_layout_tests.rs:20` | `module_inception` (lib-test only) | + +Not fixed in PR #971 — that PR is scoped to CE64⇄V3 conversion correctness, and +`edge.rs`'s two `too_many_arguments` are load-bearing back-compat signatures +whose change is a consumer-facing decision, not a lint cleanup. Verified in the +same pass that the PR's own file (`edge_v3.rs`) is **fmt-clean and clippy-clean +in both feature states**, so this debt is strictly pre-existing. + +**The generalisable half:** a workspace-excluded crate silently opts out of +every workspace-level gate — not just clippy. Any excluded crate needs either +its own CI job or an explicit note that its gates are manual. Same family as +tesseract-rs's "the gate is LOCAL — a green PR says nothing." + +**Paid when** either the exclusion is revisited (it exists to keep the crate +zero-dep and independently buildable) or a per-crate lint job is added. + +## TD-THOUGHTCTX-IS-A-LOSSY-PROJECTION (2026-08-20) — OPEN, Stage-3 + +**`ThoughtCtx` is not the reasoning state. It is a lossy projection of the +reasoning substrate — measured from both sides in one session.** + +**Input side.** `thought_ctx_from(&PlanContext)` reads exactly two scalars +(`free_will_modifier`, `features.estimated_complexity`). `lance-graph-contract` +has no `causal-edge` dependency at all, so the entire Stage-2 recipe surface is +causally blind to CE64/V3; `nars_hint` and `witness` sit on `PlanContext` unread +by that projection (`E-THE-RECIPE-SURFACE-IS-CAUSALLY-BLIND-1`). + +**Output side.** 17 of 34 kernels are `Operational` and confidence-MUTE — real +effects on `candidates` / `rung` / `temperature` / `beliefs`, observed by a +dissent consumer that watches only `confidence` +(`E-THE-FILTER-WAS-FILTERING-ON-THE-WRONG-PREDICATE-1`). + +**Explicitly NOT the fix:** rewriting the 17 to move confidence. That would +destroy the producer/consumer distinction the audit just discovered, and it is +ruled out by the operator. They are not stubs. + +**Stage 3 decides**, from measurement rather than preference, whether dissent +becomes (A) a multidimensional comparison over each kernel's declared +`writes()`, (B) separate watchers per capability/dimension, (C) a projection of +effects into a common epistemically meaningful space, or some measured +combination. The questions that make it tractable are already well-posed: which +causal/NARS/V3/witness dimensions does each recipe READ; which epistemic +dimensions does it WRITE; which consumers can observe those writes; what does +the `ThoughtCtx` projection lose. That connects directly to the JC/HHTL +psychometric program. + +**Third measurement, same fact (2026-08-20, codex round 3).** `Mcp` declares +`moves_confidence() == true` truthfully yet is guaranteed silent in the +dispatched context: `free_energy` starts at 0.5, exactly one kernel writes it, +and that one only decays it — swept 36 styles x 5 rungs, `free_energy` never +exceeds 0.5 and `Mcp` moves confidence 0/180. Capability is not reachability. +A reachability FILTER is near-circular (deciding it costs the same as sampling); +what it would really buy is refusing to count structural silence as agreement, +which is a change to what dissent MEANS. See `E-CAPABILITY-IS-NOT-REACHABILITY-1`. + +**Paid when** the projection is explicit and measurable — not when the symptom +(17 silent kernels) is papered over. + +## TD-KERNEL-IDENTITY-FINGERPRINT-RAIL (2026-08-20) — OPEN + +**Three of the 34 NARS recipe kernels — `ARE`(19), `ZCF`(24), `HKF`(34) — +cannot be carved out of `Demonstration` because of ONE missing substrate +capability, not three separate gaps.** + +All three are VSA bind/unbind identities: `A⊗B⊗B = A` (ARE), `bind(A,B)` +recoverable (ZCF), `bind(domain_A, rel, domain_B)` reversible (HKF). Each is +an exact algebraic statement and each is currently demonstrated on **hardcoded +`u32` constants**, so the kernel ignores `ctx` entirely — measured and pinned +by `context_blind_kernels_are_input_invariant`. + +**What they need:** an identity-fingerprint rail on the kernel substrate. +`ThoughtCtx`'s eight-field basis (`ThoughtField`) is a scalar proxy — +`sd`/`free_energy`/`dissonance`/`temperature`/`confidence`/`rung` are `f32`, +`candidates` is `Vec`, `beliefs` is `Vec<(u32,f32,f32)>`. **None of them +is a fingerprint**, so there is nothing in scope for a bind/unbind kernel to +bind. This is the same gap `recipe_claim_audit`'s Axis B already names at +scale: *"all 34 measure their claim against a lightweight scalar proxy, never +the real organ named … the gap is WIRING, not composition."* + +**HKF needs one thing more**, and it is worth recording separately so a future +session does not discover it half-way: its identity is over a **predicate** +rail (`domain_A —rel→ domain_B`), and `SubstrateView::project` discards the +predicate rail entirely. A fingerprint rail alone unblocks ARE and ZCF; HKF +additionally needs a predicate-preserving projection. + +**Explicitly NOT the fix:** giving them an effect on the scalars they do not +read. That would be the silent-effect-under-a-not-production-label failure +`non_operational_kernels_land_no_effect` exists to catch, and it would trade +an honest placeholder for a dishonest kernel. They stay `Demonstration` — and +`MaturityPolicy::ProductionOnly` refuses them, pinned at exactly 3 by +`the_policy_discriminates_over_the_live_kernels`. + +**Paid when:** a fingerprint rail (and, for HKF, a predicate-preserving +projection) reaches the kernel substrate; then the three carve together and +that pin, plus `G2` in `recipe_claim_audit`, are re-pinned to zero. + ## TD-LANCE9-LANCEDB036-REMEASURE (2026-08-05, operator-noted, DEFERRED) **Pins today:** `lance`/`lance-linalg`/`lance-namespace` `=7.0.0`, diff --git a/crates/causal-edge/src/edge_v3.rs b/crates/causal-edge/src/edge_v3.rs index 2c8bc22f6..a89619afb 100644 --- a/crates/causal-edge/src/edge_v3.rs +++ b/crates/causal-edge/src/edge_v3.rs @@ -45,8 +45,46 @@ //! [4..6] LO target u16 (the node whose CAM-PQ IS the SPO — NO SPO here) //! [6] anaphora nibble (i4 low, −8..+7; 0 = none) //! [7] TE temporal i8 (signed chain offset) -//! [8..12] reserved (dormant — TEKAMOLO Kausal/Modal/Lokal/Instrument refs) +//! [8] w_slot(6 low) | truth/topology RAW(2 high) ← CE64-v2 preserve +//! [9] spare/ReasoningBand RAW(3 low) | reserved(5 high) +//! [10..12] reserved (dormant — TEKAMOLO Kausal/Modal/Instrument refs) //! ``` +//! +//! ## CE64 → V3 → CE64 is LOSSLESS (the conversion contract) +//! +//! Every meaningful CE64-v2 field survives the round trip byte-exact, with +//! exactly TWO documented exclusions: +//! +//! 1. **The 24-bit in-edge SPO** — intentionally deduplicated (it lives in +//! the target node's CAM-PQ facet). Supply the SAME resolved SPO to +//! [`CausalEdgeV3::rehydrate`] and it returns bit-identical. +//! 2. **The deprecated v2 `temporal` field** — not valid CE64-v2 state at +//! all (bits 52..63 were reclaimed for plasticity[2]/W/truth/spare). It is +//! NOT mapped into V3's TE byte: V3 `temporal` is an INDEPENDENT signed +//! relative chain offset the producer sets explicitly, never inherited. +//! +//! Under the v2 layout the 64 bits are fully partitioned — S/P/O, freq, conf, +//! causal_mask, direction, inference i4, plasticity, w_slot, truth, spare — so +//! "every field preserved" IS "every bit preserved" once the SPO is resupplied. +//! +//! ### The signed mantissa is carried RAW, never through `InferenceType` +//! +//! [`InferenceType`] is a **lossy compatibility projection** of the 4-bit +//! signed mantissa: `to_mantissa(from_mantissa(m)) != m` for **8 of the 16** +//! states (−8, −7, −5, −4, −3, −2, 0, +3 — e.g. `−2 → Abduction → −1`, +//! `+3 → Synthesis → +5`, and the `pack_v2` default `0 → Deduction → +1`). +//! Routing the mantissa through the enum on rehydration silently rewrote half +//! the state space, so [`CausalEdgeV3::rehydrate`] restores the RAW nibble with +//! [`CausalEdge64::set_inference_mantissa`] after construction; the +//! `InferenceType` argument to `pack` is a throwaway placeholder. +//! +//! ### RAW bits, not upgraded provenance +//! +//! `w_slot` / truth / spare are preserved as RAW ORDINALS. Copying a CE64 +//! topology/truth ordinal `01` into V3 means "ordinal 01 preserved" — it is NOT +//! an assertion that `IndirectKnown` (or `Solid`) is now source-authoritative +//! for that row. Which lens the ordinal was written through is the producer's +//! knowledge, not the conversion's; see [`crate::layout::CausalTopology`]. use crate::edge::{CausalEdge64, InferenceType}; use crate::pearl::CausalMask; @@ -65,10 +103,17 @@ pub struct CausalEdgeV3 { const _: () = assert!(core::mem::size_of::() == 12); impl CausalEdgeV3 { - /// Lift a v1 [`CausalEdge64`] to V3, DROPPING its 24-bit in-edge SPO and - /// pointing `target` at the node whose CAM-PQ facet holds that SPO. All - /// reasoning-relevant scalars (freq/conf/mask/direction/inference/ - /// plasticity/temporal) are preserved. + /// Lift a [`CausalEdge64`] to V3, DROPPING its 24-bit in-edge SPO and + /// pointing `target` at the node whose CAM-PQ facet holds that SPO. + /// + /// **Every other meaningful v2 field is preserved**: freq, conf, + /// causal_mask, direction, the RAW signed inference mantissa, plasticity, + /// w_slot, the truth/topology 2-bit ordinal, and the spare/band 3-bit + /// ordinal. Paired with [`Self::rehydrate`] this is a bit-exact round trip + /// once the same SPO is resupplied — see the module doc. + /// + /// **Not lifted:** the deprecated v2 `temporal` (not valid CE64-v2 state; + /// V3's TE is an independent producer-set offset). pub fn from_v1(e: CausalEdge64, target: u16) -> Self { let mut p = [0u8; 12]; p[0] = e.frequency_u8(); @@ -83,32 +128,125 @@ impl CausalEdgeV3 { // [7] TE temporal: NOT lifted — under the v2 layout `CausalEdge64` carries // no temporal (it is structural: chain-position / AriGraph timestamp). // V3's TE is set explicitly by the producer via `set_temporal`, not - // inherited from a v2 edge that has none. + // inherited from a v2 edge that has none. The DEPRECATED v2 `temporal()` + // composite (bits 52..63) is not valid CE64-v2 state and is never mapped + // here — doing so would alias plasticity[2]/W/truth/spare into TE. + // [8]/[9]: the CE64-v2 tail — w_slot(6) + truth(2) + spare(3). RAW + // ordinals, no lens interpretation (see the module doc). Under the v1 + // layout every one of these accessors is a documented zero stub, so this + // writes zeros and the round trip stays exact there too. + p[8] = (e.w_slot() & 0x3F) | ((e.truth_raw() & 0b11) << 6); + p[9] = e.spare() & 0b111; Self { payload: p } } + /// NARS frequency (u8, `f = val/255`) — byte 0. + pub fn frequency(&self) -> u8 { + self.payload[0] + } + + /// NARS confidence (u8, `c = val/255`) — byte 1. + pub fn confidence(&self) -> u8 { + self.payload[1] + } + + /// Pearl 2³ causal mask — byte 2, low 3 bits. + pub fn causal_mask(&self) -> CausalMask { + CausalMask::from_bits(self.payload[2] & 0b111) + } + + /// Direction triad (3 bits, sign(dim0) per S,P,O) — byte 2, bits 3..6. + pub fn direction(&self) -> u8 { + (self.payload[2] >> 3) & 0b111 + } + + /// The RAW 4-bit signed inference mantissa (−8..=7) — byte 3, low nibble. + /// + /// This is the mantissa itself, NOT [`InferenceType`]. The enum is a lossy + /// compatibility projection (8 of 16 states do not survive + /// `to_mantissa(from_mantissa(m))`); the register is the ground truth. + /// Sign is chain direction, magnitude is the NARS base rule index. + pub fn inference_mantissa(&self) -> i8 { + let lo = self.payload[3] & 0x0F; + // sign-extend the 4-bit signed mantissa + if lo >= 8 { + lo as i8 - 16 + } else { + lo as i8 + } + } + + /// Plasticity flags (hot/cold per S,P,O) — byte 3, high 3 bits. + pub fn plasticity(&self) -> PlasticityState { + PlasticityState::from_bits((self.payload[3] >> 4) & 0b111) + } + + /// Preserved CE64-v2 W-slot: witness corpus root handle (6-bit, 0..=63). + /// Byte 8, low 6 bits. 0 = no corpus anchor. + pub fn w_slot(&self) -> u8 { + self.payload[8] & 0x3F + } + + /// Preserved CE64-v2 truth/topology register: the RAW 2-bit ordinal + /// (0..=3) — byte 8, high 2 bits. + /// + /// RAW on purpose. CE64 reads these same two bits through two lenses + /// ([`crate::layout::TrustTexture`] epistemic, [`crate::layout::CausalTopology`] + /// factual); which one the producer meant is not recoverable from the + /// register, so V3 carries the ordinal and asserts nothing about it. + /// Preserving ordinal `01` means "ordinal 01 preserved", never + /// "`IndirectKnown` is now source-authoritative". + pub fn truth_raw(&self) -> u8 { + (self.payload[8] >> 6) & 0b11 + } + + /// Preserved CE64-v2 spare/`ReasoningBand` register: the RAW 3-bit ordinal + /// (0..=7) — byte 9, low 3 bits. RAW for the same reason as + /// [`Self::truth_raw`]: one register, two lenses, no provenance upgrade. + pub fn spare_raw(&self) -> u8 { + self.payload[9] & 0b111 + } + /// Rebuild a [`CausalEdge64`] for reasoning by supplying the SPO resolved /// from the target node's CAM-PQ facet. The conclusion of `syllogize` - /// depends only on SPO + freq/conf + causal_mask, all restored here. + /// depends only on SPO + freq/conf + causal_mask — but this restores the + /// FULL v2 register, so the round trip + /// `CausalEdge64 → from_v1 → rehydrate(same SPO)` is **bit-identical** + /// (see the module doc's conversion contract for the two exclusions). + /// + /// The [`InferenceType`] handed to [`CausalEdge64::pack`] is a THROWAWAY + /// placeholder: `pack` writes `inference.to_mantissa()`, and routing the + /// stored mantissa through `InferenceType::from_mantissa` first would + /// rewrite 8 of its 16 states. The raw nibble is restored immediately + /// after with [`CausalEdge64::set_inference_mantissa`]. pub fn rehydrate(&self, s_idx: u8, p_idx: u8, o_idx: u8) -> CausalEdge64 { - let freq = self.payload[0]; - let conf = self.payload[1]; - let mask = CausalMask::from_bits(self.payload[2] & 0b111); - let direction = (self.payload[2] >> 3) & 0b111; - let mantissa = { - let lo = self.payload[3] & 0x0F; - // sign-extend the 4-bit signed mantissa - if lo >= 8 { - lo as i8 - 16 - } else { - lo as i8 - } - }; - let inference = InferenceType::from_mantissa(mantissa); - let plasticity = PlasticityState::from_bits((self.payload[3] >> 4) & 0b111); - CausalEdge64::pack( - s_idx, p_idx, o_idx, freq, conf, mask, direction, inference, plasticity, 0, - ) + let mantissa = self.inference_mantissa(); + let mut edge = CausalEdge64::pack( + s_idx, + p_idx, + o_idx, + self.frequency(), + self.confidence(), + self.causal_mask(), + self.direction(), + // placeholder ONLY — overwritten by set_inference_mantissa below. + InferenceType::Deduction, + self.plasticity(), + 0, + ); + edge.set_inference_mantissa(mantissa); + edge.set_w_slot(self.w_slot()); + // `set_truth` has no raw-u8 form, so the 2-bit ordinal goes through + // `TrustTexture`. That is SAFE where `InferenceType` was not, and the + // difference is the whole point: `from_bits_2`/`to_bits_2` is a total + // BIJECTION on 0..=3 (four ordinals, four variants, discriminants + // 0,1,2,3), whereas `InferenceType` maps 16 mantissa states onto 8 + // variants and cannot be injective. Pinned by + // `trust_texture_bits_2_is_a_bijection_unlike_inference_type` — if a + // variant is ever added or reordered, that test fails before this does. + edge.set_truth(crate::layout::TrustTexture::from_bits_2(self.truth_raw())); + edge.set_spare(self.spare_raw()); + edge } /// The Lokal target node reference — the node whose 6×256² CAM-PQ facet IS @@ -339,4 +477,240 @@ mod tests { e.set_anaphora(3); assert_eq!(CausalEdgeV3::from_le_bytes(e.to_le_bytes()), e); } + + // ══════════════════════════════════════════════════════════════════════ + // CE64 → V3 → CE64 LOSSLESSNESS + // + // A LOW-LEVEL conversion-correctness suite, deliberately separate from + // the planner-level Stage-2.6 parity harness + // (`lance-graph-planner::cache::stage26_v3_parity`). The planner harness + // proves the ENGINE behaves identically through a V3 leg; this suite + // proves the CONVERSION preserves the register. Neither subsumes the + // other: the planner leg only ever carries `InferenceType::Deduction` + // (mantissa +1, one of the 8 states that happens to survive the old lossy + // path), so it was structurally blind to the mantissa defect below. + // ══════════════════════════════════════════════════════════════════════ + + /// `InferenceType` is a LOSSY projection of the 4-bit mantissa, and this + /// is the measurement that says so — the premise the raw-carry fix rests + /// on. If a future edit makes the enum injective this test fails and the + /// module doc's "8 of 16" claim must be re-measured, not re-asserted. + #[test] + fn inference_type_is_a_lossy_projection_of_the_mantissa() { + let lossy: Vec = (-8i8..=7) + .filter(|&m| InferenceType::from_mantissa(m).to_mantissa() != m) + .collect(); + assert_eq!( + lossy, + vec![-8, -7, -5, -4, -3, -2, 0, 3], + "the InferenceType loss set moved; re-measure the module doc" + ); + // anti-vacuity: the projection is not a blanket failure either — half + // the states DO survive, which is exactly why the defect hid. + assert_eq!(16 - lossy.len(), 8, "expected 8 surviving states"); + } + + /// Unlike `InferenceType`, `TrustTexture`'s 2-bit codec IS a total + /// bijection — which is what licenses `rehydrate` routing the truth + /// ordinal through it. Pinned so an added/reordered variant fails HERE, + /// with a message naming the cause, rather than as a silent parity drift. + #[test] + fn trust_texture_bits_2_is_a_bijection_unlike_inference_type() { + for raw in 0u8..=3 { + assert_eq!( + crate::layout::TrustTexture::from_bits_2(raw).to_bits_2(), + raw, + "TrustTexture is no longer a bijection on 2 bits; rehydrate's \ + truth carry must switch to a raw setter" + ); + } + } + + /// REQUIREMENT 1 — the raw signed mantissa survives CE64 → V3 → CE64 for + /// ALL 16 states. + /// + /// The old implementation routed the nibble through + /// `InferenceType::from_mantissa(...) → pack(...) → to_mantissa()` and + /// silently rewrote 8 of them (see the loss-set test above), including the + /// `pack_v2` default `0 → +1`. + /// + /// DISABLE-RUN (verified red): restore the old body of `rehydrate` — + /// pass `InferenceType::from_mantissa(mantissa)` to `pack` and drop the + /// `set_inference_mantissa` call — and this fails on m = −8 with + /// `rehydrated mantissa: left: 1, right: -8`. + #[test] + fn mantissa_round_trips_raw_for_all_16_states() { + for m in -8i8..=7 { + // Build the V3 register directly so the V3 half of the assertion + // is layout-independent (it holds under v1 and v2 alike). + let mut bytes = [0u8; 12]; + bytes[3] = (m as u8) & 0x0F; + let v3 = CausalEdgeV3::from_le_bytes(bytes); + assert_eq!(v3.inference_mantissa(), m, "V3 accessor lost m={m}"); + + #[cfg(feature = "causal-edge-v2-layout")] + { + // and the full CE64 → V3 → CE64 leg + let src = CausalEdge64::pack_v2( + 7, + 8, + 9, + 200, + 180, + CausalMask::from_bits(0b101), + 0b010, + PlasticityState::ALL_HOT, + ) + .with_inference_mantissa(m); + assert_eq!(src.inference_mantissa(), m, "source lost m={m}"); + let got = CausalEdgeV3::from_v1(src, 0x1234).rehydrate(7, 8, 9); + assert_eq!(got.inference_mantissa(), m, "rehydrated mantissa"); + } + } + } + + /// The four states the brief named explicitly, each one a state the OLD + /// implementation provably lost, asserted individually so a failure names + /// the value rather than an index. Kept separate from the exhaustive sweep + /// above: the sweep proves totality, this proves the regressions. + #[cfg(feature = "causal-edge-v2-layout")] + #[test] + fn named_mantissa_regressions_minus2_plus3_minus4_minus5() { + for (m, old_would_give) in [(-2i8, -1i8), (3, 5), (-4, 4), (-5, 5)] { + // the defect, restated as a measurement rather than a memory + assert_eq!( + InferenceType::from_mantissa(m).to_mantissa(), + old_would_give, + "the old lossy path's output for m={m} moved" + ); + let src = CausalEdge64::pack_v2( + 1, + 2, + 3, + 255, + 255, + CausalMask::from_bits(0b111), + 0b111, + PlasticityState::ALL_HOT, + ) + .with_inference_mantissa(m); + let got = CausalEdgeV3::from_v1(src, 0xFFFF).rehydrate(1, 2, 3); + assert_eq!(got.inference_mantissa(), m, "m={m} not preserved"); + assert_ne!( + got.inference_mantissa(), + old_would_give, + "m={m} still lands on the old lossy value" + ); + } + } + + /// One full-parity case: + /// `(s, p, o, freq, conf, mask, dir, mantissa, w_slot, truth, spare)`. + #[cfg(feature = "causal-edge-v2-layout")] + type ParityCase = (u8, u8, u8, u8, u8, u8, u8, i8, u8, u8, u8); + + /// REQUIREMENT 3 — FULL FIELD PARITY over varied NON-ZERO edges. + /// + /// Every meaningful CE64-v2 field is asserted after CE64 → V3 → CE64 with + /// the SAME resolved SPO resupplied. Under v2 the 64 bits are fully + /// partitioned (S/P/O · freq · conf · mask · direction · mantissa · + /// plasticity · w_slot · truth · spare), so this is also a whole-register + /// bit-identity check — asserted as such at the end. + /// + /// NOT compared: the deprecated v2 `temporal()`. It is not valid CE64-v2 + /// state (bits 52..63 are the reclaim zone) and V3's TE is an independent + /// producer-set offset, never a lift of it. + /// + /// DISABLE-RUN (verified red, each independently): drop any one of the + /// `set_w_slot` / `set_truth` / `set_spare` / `set_inference_mantissa` + /// carries in `rehydrate`, or the `p[8]`/`p[9]` writes in `from_v1`. + #[cfg(feature = "causal-edge-v2-layout")] + #[test] + fn full_v2_field_parity_across_ce64_v3_ce64() { + // varied, deliberately non-zero, and spanning the ordinal ranges: all + // 4 truth ordinals, w_slot at both ends of its 6 bits, spare across + // its 3, mantissa on both signs. + let cases: [ParityCase; 6] = [ + // s, p, o, freq, conf, mask, dir, mantissa, w_slot, truth, spare + (10, 1, 20, 230, 200, 0b111, 0b101, -2, 63, 3, 7), + (20, 2, 30, 210, 190, 0b101, 0b010, 3, 1, 1, 1), + (255, 254, 253, 255, 255, 0b111, 0b111, 7, 62, 2, 6), + (1, 0, 255, 1, 254, 0b001, 0b100, -8, 33, 0, 5), + (50, 3, 30, 220, 195, 0b110, 0b001, 0, 0, 2, 0), + (99, 88, 77, 128, 127, 0b010, 0b011, -6, 21, 3, 4), + ]; + for (s, p, o, freq, conf, mask, dir, mant, w, truth, spare) in cases { + let src = CausalEdge64::pack_v2( + s, + p, + o, + freq, + conf, + CausalMask::from_bits(mask), + dir, + PlasticityState::from_bits(0b101), + ) + .with_inference_mantissa(mant) + .with_w_slot(w) + .with_truth(crate::layout::TrustTexture::from_bits_2(truth)) + .with_spare(spare); + + // the source really carries what the case says (anti-vacuity: a + // parity test over an all-zero source proves nothing) + assert_eq!(src.w_slot(), w, "fixture w_slot"); + assert_eq!(src.truth_raw(), truth, "fixture truth"); + assert_eq!(src.spare(), spare, "fixture spare"); + assert_eq!(src.inference_mantissa(), mant, "fixture mantissa"); + + let v3 = CausalEdgeV3::from_v1(src, 0xC0DE); + let got = v3.rehydrate(s, p, o); // the SAME resolved SPO + + assert_eq!((got.s_idx(), got.p_idx(), got.o_idx()), (s, p, o), "SPO"); + assert_eq!(got.frequency_u8(), freq, "freq"); + assert_eq!(got.confidence_u8(), conf, "conf"); + assert_eq!(got.causal_mask() as u8, mask, "causal_mask"); + assert_eq!(got.direction(), dir, "direction"); + assert_eq!(got.inference_mantissa(), mant, "inference i4"); + assert_eq!(got.plasticity().bits(), 0b101, "plasticity"); + assert_eq!(got.w_slot(), w, "w_slot"); + assert_eq!(got.truth_raw(), truth, "truth/topology raw"); + assert_eq!(got.spare(), spare, "spare/band raw"); + + // …and because v2 partitions all 64 bits, field parity IS bit + // parity. This single line would catch a future field we forgot to + // enumerate above — which the per-field asserts alone cannot. + assert_eq!( + got, src, + "whole-register identity failed (a v2 field is unaccounted for)" + ); + } + } + + /// The V3 tail bytes are where the preserved CE64 fields live, and nothing + /// else may leak into them. Complements `v3_field_isolation` above, which + /// covers the two V3-native setters. + #[cfg(feature = "causal-edge-v2-layout")] + #[test] + fn preserved_tail_occupies_exactly_bytes_8_and_9() { + let src = CausalEdge64::pack_v2( + 1, + 2, + 3, + 4, + 5, + CausalMask::from_bits(0), + 0, + PlasticityState::from_bits(0), + ) + .with_w_slot(0x2A) // 0b101010 + .with_truth(crate::layout::TrustTexture::from_bits_2(0b11)) + .with_spare(0b101); + let bytes = CausalEdgeV3::from_v1(src, 0).to_le_bytes(); + assert_eq!(bytes[8], 0b1110_1010, "byte 8 = truth(2)<<6 | w_slot(6)"); + assert_eq!(bytes[9], 0b0000_0101, "byte 9 = spare(3), high 5 reserved"); + // bytes 10..12 stay dormant — the preserve must not creep into them + assert_eq!(&bytes[10..12], &[0u8, 0], "reserved tail was written"); + // and TE was NOT inherited from the deprecated v2 temporal composite + assert_eq!(bytes[7], 0, "TE must not be lifted from v2 temporal"); + } } diff --git a/crates/lance-graph-contract/examples/recipe_claim_audit.rs b/crates/lance-graph-contract/examples/recipe_claim_audit.rs index e349e8613..1ef9c9b26 100644 --- a/crates/lance-graph-contract/examples/recipe_claim_audit.rs +++ b/crates/lance-graph-contract/examples/recipe_claim_audit.rs @@ -386,43 +386,55 @@ fn axis_a(id: u8) -> (Realize, String) { realize(c.candidates == vec![0.9], "reframed to dominant") } - // ── Compute-then-discard: recipe-side INERT bugs ── + // ── Carved out of the compute-then-discard set ── + // Both previously computed a result and dropped it on the floor. They now + // land it, so the arms check the CLAIMED POST-CONDITION instead of the + // absence of one. Re-pinned deliberately: the old arms asserted the bug. 8 => { - // CAS: computes `_level` from rung, then DROPS it — no ctx change, fixed note. - let src = ctx(&[0.4, 0.6]); - let before = src.clone(); - let (_, _, dconf, c) = run(8, src); - let unchanged = - c.candidates == before.candidates && c.rung == before.rung && dconf == 0.0; - ( - if unchanged { - Realize::Inert - } else { - Realize::Realizes - }, - "abstraction level computed then discarded — no observable effect".to_string(), + // CAS: the rung's HDR level QUANTIZES the field (coarse rung → coarse grid). + let mut coarse = ctx(&[0.4, 0.6]); + coarse.rung = 1; // level 1 → the field collapses to its poles + let (_, _, _, c1) = run(8, coarse); + let mut fine = ctx(&[0.4, 0.6]); + fine.rung = 9; // level 32 → the detail survives + let (_, _, _, c2) = run(8, fine); + realize( + c1.candidates == vec![0.0, 1.0] && c2.candidates != c1.candidates, + "quantized the field to the rung's HDR level", ) } 22 => { - // ETD: sorts a CLONE `v`, never writes back — ctx unchanged, fixed note. - let src = ctx(&[0.3, 0.9, 0.1]); - let before = src.clone(); - let (_, _, dconf, c) = run(22, src); - let unchanged = c.candidates == before.candidates && dconf == 0.0; + // ETD: splits at the widest adjacent gap and KEEPS the upper cluster. + let (_, _, _, c) = run(22, ctx(&[0.3, 0.9, 0.1])); + realize( + c.candidates == vec![0.9], + "kept the cluster above the emergent boundary", + ) + } + 31 => { + // ICR: split-pole SENSITIVITY — zero at the midpoint, charged at an + // extreme. Carved out of the CONSTANT set below, and it needs its own + // arm because that set varies only `candidates`, which ICR does not + // read: the old probe would report it input-independent forever. + let mut mid = ctx(&[0.5]); + mid.free_energy = 0.5; + let (_, nm, dm, _) = run(31, mid); + let mut skew = ctx(&[0.5]); + skew.free_energy = 0.9; + let (_, ns, ds, _) = run(31, skew); ( - if unchanged { - Realize::Inert + if nm != ns && dm == 0.0 && ds < 0.0 { + Realize::Measures } else { - Realize::Realizes + Realize::Inert }, - "cluster split computed on a clone, never applied — no observable effect" - .to_string(), + format!("{nm}({dm:+.3}) ↔ {ns}({ds:+.3})"), ) } // ── Exact algebraic identities: correct but INPUT-INDEPENDENT ── - 19 | 24 | 31 | 34 => { - // ARE/ZCF/ICR/HKF: hardcoded u32 constants; output identical for any ctx. + 19 | 24 | 34 => { + // ARE/ZCF/HKF: hardcoded u32 constants; output identical for any ctx. let (_, n1, d1, _) = run(id, ctx(&[0.1])); let (_, n2, d2, _) = run(id, ctx(&[0.9, 0.9, 0.9])); let input_independent = n1 == n2 && (d1 - d2).abs() < 1e-9; @@ -690,8 +702,13 @@ fn main() { println!("\n── the operator's question: substrate or recipe? ──"); println!(" • RECIPE-side weakness is NARROW and named:"); - println!(" INERT (compute-then-discard bug): CAS(8), ETD(22)"); - println!(" CONSTANT (input-independent algebra): ARE(19), ZCF(24), ICR(31), HKF(34)"); + println!(" INERT (compute-then-discard bug): none — CAS(8) and ETD(22) were carved"); + println!(" CONSTANT (input-independent algebra): ARE(19), ZCF(24), HKF(34)"); + println!( + " (ICR(31) left this set too: it reads the surprise scale now. Still NOT a Pearl" + ); + println!(" intervention — see the kernel's own doc. The three that remain are blocked"); + println!(" on an identity-fingerprint rail the kernel substrate does not yet expose.)"); println!(" • The DOMINANT weakness is SUBSTRATE-side: all 34 measure their claim against a"); println!(" lightweight scalar proxy, never the real organ named (SPO 2³ / CAM-PQ 4096² /"); println!( @@ -713,10 +730,13 @@ fn main() { ); green &= g1; - // G2: the recipe-side weaknesses are EXACTLY the 6 named ones (2 INERT + 4 CONSTANT). - let g2 = n_inert == 2 && n_constant == 4; + // G2: the recipe-side weaknesses are EXACTLY the 3 remaining CONSTANT ones. + // Re-pinned from `2 INERT + 4 CONSTANT` when CAS/ETD/ICR/SDD were carved. + // Deliberately an EQUALITY in both terms: an INERT kernel reappearing, or a + // fourth CONSTANT one, should fail here and be reviewed rather than absorbed. + let g2 = n_inert == 0 && n_constant == 3; println!( - "[{}] G2 recipe-weak set is exactly {{CAS,ETD}}+{{ARE,ZCF,ICR,HKF}}: INERT={}, CONSTANT={}", + "[{}] G2 recipe-weak set is exactly {{ARE,ZCF,HKF}}: INERT={}, CONSTANT={}", pf(g2), n_inert, n_constant diff --git a/crates/lance-graph-contract/src/recipe_kernels.rs b/crates/lance-graph-contract/src/recipe_kernels.rs index 352f459c3..3ad2fa4ef 100644 --- a/crates/lance-graph-contract/src/recipe_kernels.rs +++ b/crates/lance-graph-contract/src/recipe_kernels.rs @@ -20,6 +20,28 @@ pub const SD_BLOCK: f32 = 0.35; /// Berry-Esseen noise floor at d=16384. pub const NOISE_FLOOR: f32 = 0.004; +/// The neutral point of the 0..1 candidate scale — "no evidence either way", +/// and the reference a distortion measurement is taken AGAINST. +/// +/// A POLICY PIN, not a measurement. It was an unnamed `0.5` literal inside +/// `Sdd` until that kernel was carved; naming it makes the choice reviewable +/// instead of arithmetic. +pub const NEUTRAL_SCORE: f32 = 0.5; + +/// How much of a measured semantic distortion `Sdd` charges to confidence. +/// +/// POLICY PIN. The charge is PROPORTIONAL to the measured deviation rather +/// than a fixed cliff, because `NOISE_FLOOR` is small enough (0.004) that the +/// boolean "distorted" flag fires on nearly any real candidate field — a +/// fixed penalty behind an almost-always-true flag would be a constant, not a +/// measurement. Proportionality is what keeps a barely-above-floor reading +/// cheap and a badly skewed one expensive. +pub const DISTORTION_WEIGHT: f32 = 0.2; + +/// How much `Icr` charges for a conclusion that hinges on which pole of the +/// surprise scale it is read from. POLICY PIN. +pub const POLE_SENSITIVITY_WEIGHT: f32 = 0.15; + /// The shared cognitive context a recipe reads/transforms (our substrate markers). #[derive(Debug, Clone)] pub struct ThoughtCtx { @@ -83,6 +105,50 @@ pub struct Outcome { pub note: &'static str, /// Net change applied to `ctx.confidence`. pub delta_conf: f32, + /// When `fired == false`, WHY it did not run. + /// + /// `fired` alone conflates two different silences — "the gate said no on + /// this context" and "the dispatch refuses non-production kernels" — and a + /// caller that cannot tell them apart cannot report either honestly. Always + /// `None` when `fired` is true. + pub skip: Option, +} + +/// Why a tactic did not run. See [`Outcome::skip`]. +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub enum SkipReason { + /// The implicit [`Tactic::gate`] declined on this context. + GatedOff, + /// The dispatch ran under [`MaturityPolicy::ProductionOnly`] and this + /// kernel's [`maturity`](Tactic::maturity) is not + /// [`is_production`](KernelMaturity::is_production). Carries the maturity + /// that was refused, so a caller can distinguish a `Stub` from a + /// `Demonstration` without a second lookup. + NonProduction(KernelMaturity), +} + +/// Which [`KernelMaturity`] levels a dispatch is willing to let RUN. +/// +/// The default is [`Any`](MaturityPolicy::Any) — the behaviour every existing +/// caller already has, so [`Tactic::run`] is unchanged and this whole surface +/// is additive. +#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)] +pub enum MaturityPolicy { + /// Run every kernel regardless of maturity. Today's behaviour. + #[default] + Any, + /// Run only kernels whose maturity + /// [`is_production`](KernelMaturity::is_production); everything else is + /// refused with [`SkipReason::NonProduction`] and never touches `ctx`. + /// + /// This is the policy a **dispatch that consumes a budget** wants. A + /// `Demonstration` lands no effect by construction (enforced by + /// `non_operational_kernels_land_no_effect`), so a channel that samples `k` + /// kernels and measures whether any of them moved the answer spends real + /// slots on kernels that structurally cannot move it — and then reports the + /// resulting silence as agreement. A watcher that cannot dissent carries + /// exactly as much information as one that never fires. + ProductionOnly, } impl Outcome { @@ -91,6 +157,15 @@ impl Outcome { fired: false, note: "gated off", delta_conf: 0.0, + skip: Some(SkipReason::GatedOff), + } + } + fn refused(maturity: KernelMaturity) -> Self { + Self { + fired: false, + note: "refused: not a production kernel", + delta_conf: 0.0, + skip: Some(SkipReason::NonProduction(maturity)), } } fn done(note: &'static str, delta_conf: f32) -> Self { @@ -98,6 +173,7 @@ impl Outcome { fired: true, note, delta_conf, + skip: None, } } } @@ -228,6 +304,38 @@ pub trait Tactic: Sync { /// method exists to close. fn maturity(&self) -> KernelMaturity; + /// Can this tactic's [`apply`](Tactic::apply) return a **non-zero + /// `delta_conf`** on ANY branch? + /// + /// NON-defaulted, for the same reason as [`requires`](Tactic::requires) and + /// [`maturity`](Tactic::maturity): a default would let a tactic inherit a + /// claim by saying nothing. + /// + /// **This is NOT implied by [`writes`](Tactic::writes), and the gap is the + /// whole reason the method exists.** `writes` is the census of what `apply` + /// mutates through `&mut ThoughtCtx`; `delta_conf` is applied by + /// [`run`](Tactic::run) *afterwards* and is deliberately a separate effect + /// (`no_kernel_writes_outside_its_declared_mask` calls `apply` directly to + /// keep them apart). Measured over the 34: **no** kernel declares + /// `ThoughtField::Confidence` in `writes`, and only **14** can move + /// `delta_conf` — while 31 are `Operational`. So + /// `maturity().is_production()` is a far weaker statement than "this + /// tactic can move the confidence number", and a caller that needs the + /// latter must ask for it. + /// + /// The concrete consumer: a dispatch that samples `k` tactics and asks + /// whether any of them moved `ctx.confidence`. Every tactic it samples that + /// cannot move that number is a spent slot returning guaranteed agreement — + /// the failure `E-A-WATCHER-THAT-CANNOT-DISSENT-IS-NOT-A-WATCHER-1` + /// describes, which a maturity filter alone does NOT close (codex review, + /// PR #971: the newly-Operational `Etd` rewrites `candidates` and returns + /// `0.0` forever). + /// + /// Pinned two-sided against the probe matrix by + /// `moves_confidence_matches_observation`: over-declaring and + /// under-declaring both fail. + fn moves_confidence(&self) -> bool; + /// The tactic's **output checklist**: which [`ThoughtField`]s its /// [`apply`](Tactic::apply) can mutate, on ANY branch. /// @@ -263,8 +371,32 @@ pub trait Tactic: Sync { } /// Perform the tactic's characteristic operation on the context. fn apply(&self, ctx: &mut ThoughtCtx) -> Outcome; - /// Gate + apply. + /// Gate + apply, under [`MaturityPolicy::Any`]. + /// + /// Unchanged from before the policy existed, and deliberately so: every + /// caller that does not care about maturity keeps today's behaviour without + /// editing a line. A caller that DOES care reaches for [`run_with`]. + /// + /// [`run_with`]: Tactic::run_with fn run(&self, ctx: &mut ThoughtCtx) -> Outcome { + self.run_with(ctx, MaturityPolicy::Any) + } + + /// Maturity policy + gate + apply. + /// + /// The policy is checked BEFORE [`gate`](Tactic::gate), on purpose: a + /// `Demonstration` in the `Gate` bucket sitting in `GateState::Flow` would + /// otherwise be reported as [`SkipReason::GatedOff`], hiding the refusal + /// behind an unrelated silence. The first reason a kernel did not run is + /// the one the caller needs. + /// + /// A refused kernel never sees `ctx` — not `gate`, not `apply` — so a + /// `ProductionOnly` dispatch cannot be perturbed by a kernel it declined. + fn run_with(&self, ctx: &mut ThoughtCtx, policy: MaturityPolicy) -> Outcome { + let maturity = self.maturity(); + if policy == MaturityPolicy::ProductionOnly && !maturity.is_production() { + return Outcome::refused(maturity); + } if !self.gate(ctx) { return Outcome::skipped(); } @@ -282,6 +414,18 @@ fn mean(xs: &[f32]) -> f32 { xs.iter().sum::() / xs.len() as f32 } } +/// The HDR resolution a meaning-depth rung is entitled to (coarse -> fine). +/// +/// Shared by `Cas` so the ladder it reads is a named function rather than a +/// match arm buried in one kernel body. +fn hdr_level(rung: u8) -> u32 { + match rung { + 0..=2 => 1, + 3..=5 => 4, + 6..=7 => 8, + _ => 32, + } +} fn max_idx(xs: &[f32]) -> usize { xs.iter() .enumerate() @@ -314,6 +458,9 @@ impl Tactic for Rte { fn maturity(&self) -> KernelMaturity { KernelMaturity::Operational } + fn moves_confidence(&self) -> bool { + true + } fn writes(&self) -> ThoughtMask { ThoughtMask::of(&[ThoughtField::Rung, ThoughtField::FreeEnergy]) } @@ -342,6 +489,9 @@ impl Tactic for Htd { fn maturity(&self) -> KernelMaturity { KernelMaturity::Operational } + fn moves_confidence(&self) -> bool { + false + } fn writes(&self) -> ThoughtMask { ThoughtMask::of(&[ThoughtField::Candidates]) } @@ -365,6 +515,9 @@ impl Tactic for Smad { fn maturity(&self) -> KernelMaturity { KernelMaturity::Operational } + fn moves_confidence(&self) -> bool { + true + } fn writes(&self) -> ThoughtMask { ThoughtMask::of(&[]) } @@ -395,6 +548,9 @@ impl Tactic for Rcr { fn maturity(&self) -> KernelMaturity { KernelMaturity::Operational } + fn moves_confidence(&self) -> bool { + false + } fn writes(&self) -> ThoughtMask { ThoughtMask::of(&[ThoughtField::Candidates]) } @@ -416,6 +572,9 @@ impl Tactic for Tcp { fn maturity(&self) -> KernelMaturity { KernelMaturity::Operational } + fn moves_confidence(&self) -> bool { + true + } fn writes(&self) -> ThoughtMask { ThoughtMask::of(&[ThoughtField::Candidates]) } @@ -440,6 +599,9 @@ impl Tactic for Tr { fn maturity(&self) -> KernelMaturity { KernelMaturity::Operational } + fn moves_confidence(&self) -> bool { + false + } fn writes(&self) -> ThoughtMask { ThoughtMask::of(&[ThoughtField::Candidates]) } @@ -465,6 +627,9 @@ impl Tactic for Asc { fn maturity(&self) -> KernelMaturity { KernelMaturity::Operational } + fn moves_confidence(&self) -> bool { + true + } fn writes(&self) -> ThoughtMask { ThoughtMask::of(&[]) } @@ -488,23 +653,29 @@ impl Tactic for Cas { Self::rec() } fn requires(&self) -> ThoughtMask { - ThoughtMask::of(&[ThoughtField::Rung]) + ThoughtMask::of(&[ThoughtField::Rung, ThoughtField::Candidates]) } - /// Demonstration: computes an abstraction level and discards it — no effect on ctx, no confidence delta. fn maturity(&self) -> KernelMaturity { - KernelMaturity::Demonstration + KernelMaturity::Operational + } + fn moves_confidence(&self) -> bool { + false } fn writes(&self) -> ThoughtMask { - ThoughtMask::of(&[]) + ThoughtMask::of(&[ThoughtField::Candidates]) } + /// Conditional abstraction scaling: the rung picks an HDR resolution + /// ([`hdr_level`]) and the candidate field is QUANTIZED onto that grid — a + /// coarse rung sees a blurred field, a deep rung keeps the detail. + /// + /// Carved from a Demonstration that computed the level and dropped it on + /// the floor. The note string already claimed this; the carve makes the + /// claim true rather than rewording it. fn apply(&self, ctx: &mut ThoughtCtx) -> Outcome { - // Conditional abstraction scaling: pick HDR resolution from rung (coarse→fine). - let _level = match ctx.rung { - 0..=2 => 1, - 3..=5 => 4, - 6..=7 => 8, - _ => 32, - }; + let steps = hdr_level(ctx.rung) as f32; + for c in ctx.candidates.iter_mut() { + *c = (*c * steps).round() / steps; + } Outcome::done("scaled abstraction to rung-appropriate HDR level", 0.0) } } @@ -520,6 +691,9 @@ impl Tactic for Irs { fn maturity(&self) -> KernelMaturity { KernelMaturity::Operational } + fn moves_confidence(&self) -> bool { + false + } fn writes(&self) -> ThoughtMask { ThoughtMask::of(&[ThoughtField::Candidates]) } @@ -543,6 +717,9 @@ impl Tactic for Mcp { fn maturity(&self) -> KernelMaturity { KernelMaturity::Operational } + fn moves_confidence(&self) -> bool { + true + } fn writes(&self) -> ThoughtMask { ThoughtMask::of(&[]) } @@ -571,6 +748,9 @@ impl Tactic for Cr { fn maturity(&self) -> KernelMaturity { KernelMaturity::Operational } + fn moves_confidence(&self) -> bool { + true + } fn writes(&self) -> ThoughtMask { ThoughtMask::of(&[]) } @@ -609,6 +789,9 @@ impl Tactic for Tca { KernelMaturity::Operational } /// only when `candidates` is non-empty + fn moves_confidence(&self) -> bool { + false + } fn writes(&self) -> ThoughtMask { ThoughtMask::of(&[ThoughtField::Candidates]) } @@ -633,6 +816,9 @@ impl Tactic for Cdt { KernelMaturity::Operational } /// both branches write; the convergent branch only when a max exists + fn moves_confidence(&self) -> bool { + true + } fn writes(&self) -> ThoughtMask { ThoughtMask::of(&[ThoughtField::Candidates]) } @@ -663,6 +849,9 @@ impl Tactic for Mct { fn maturity(&self) -> KernelMaturity { KernelMaturity::Operational } + fn moves_confidence(&self) -> bool { + false + } fn writes(&self) -> ThoughtMask { ThoughtMask::of(&[ThoughtField::Candidates]) } @@ -690,6 +879,9 @@ impl Tactic for Lsi { fn maturity(&self) -> KernelMaturity { KernelMaturity::Operational } + fn moves_confidence(&self) -> bool { + false + } fn writes(&self) -> ThoughtMask { ThoughtMask::of(&[ThoughtField::Sd]) } @@ -714,6 +906,9 @@ impl Tactic for Pso { fn maturity(&self) -> KernelMaturity { KernelMaturity::Operational } + fn moves_confidence(&self) -> bool { + false + } fn writes(&self) -> ThoughtMask { ThoughtMask::of(&[ThoughtField::Candidates]) } @@ -736,6 +931,9 @@ impl Tactic for Cdi { fn maturity(&self) -> KernelMaturity { KernelMaturity::Operational } + fn moves_confidence(&self) -> bool { + false + } fn writes(&self) -> ThoughtMask { ThoughtMask::of(&[ThoughtField::Beliefs, ThoughtField::Dissonance]) } @@ -764,6 +962,9 @@ impl Tactic for Cws { KernelMaturity::Operational } /// only when a max-scoring candidate exists + fn moves_confidence(&self) -> bool { + false + } fn writes(&self) -> ThoughtMask { ThoughtMask::of(&[ThoughtField::Beliefs]) } @@ -788,6 +989,9 @@ impl Tactic for Are { fn maturity(&self) -> KernelMaturity { KernelMaturity::Demonstration } + fn moves_confidence(&self) -> bool { + false + } fn writes(&self) -> ThoughtMask { ThoughtMask::of(&[]) } @@ -811,6 +1015,9 @@ impl Tactic for Tcf { fn maturity(&self) -> KernelMaturity { KernelMaturity::Operational } + fn moves_confidence(&self) -> bool { + true + } fn writes(&self) -> ThoughtMask { ThoughtMask::of(&[ThoughtField::Candidates]) } @@ -836,6 +1043,9 @@ impl Tactic for Ssr { fn maturity(&self) -> KernelMaturity { KernelMaturity::Operational } + fn moves_confidence(&self) -> bool { + true + } fn writes(&self) -> ThoughtMask { ThoughtMask::of(&[]) } @@ -854,19 +1064,45 @@ impl Tactic for Etd { fn requires(&self) -> ThoughtMask { ThoughtMask::of(&[ThoughtField::Candidates]) } - /// Demonstration: sorts a CLONE of `candidates` and never writes it back — the - /// computed decomposition is discarded. Wiring it up is a behaviour change and - /// needs an explicit decision, not a silent fix. fn maturity(&self) -> KernelMaturity { - KernelMaturity::Demonstration + KernelMaturity::Operational + } + /// only when the field proposes a boundary wider than [`NOISE_FLOOR`] + fn moves_confidence(&self) -> bool { + false } fn writes(&self) -> ThoughtMask { - ThoughtMask::of(&[]) + ThoughtMask::of(&[ThoughtField::Candidates]) } + /// Emergent decomposition: sort, split at the LARGEST adjacent gap, keep + /// the upper cluster as the decomposed sub-task. + /// + /// The boundary is proposed by the DATA, not by a fixed threshold — which + /// is what makes this a different mechanism from `Tcp`'s prune rather than + /// a second spelling of it. A field with no gap wider than [`NOISE_FLOOR`] + /// proposes no boundary, and this leaves it untouched: "decompose" + /// truncating a uniform field to `len - 1` would be a silent loss dressed + /// as a decomposition. + /// + /// Carved from a Demonstration that sorted a CLONE and discarded it. fn apply(&self, ctx: &mut ThoughtCtx) -> Outcome { - // Emergent decomposition: split at the largest gap (natural cluster boundary). + if ctx.candidates.len() < 2 { + return Outcome::done("no emergent boundary (fewer than two candidates)", 0.0); + } let mut v = ctx.candidates.clone(); v.sort_by(|a, b| a.partial_cmp(b).unwrap_or(std::cmp::Ordering::Equal)); + let (mut split, mut widest) = (0usize, f32::NEG_INFINITY); + for i in 0..v.len() - 1 { + let gap = v[i + 1] - v[i]; + if gap > widest { + widest = gap; + split = i + 1; + } + } + if widest <= NOISE_FLOOR { + return Outcome::done("no emergent boundary (field is uniform)", 0.0); + } + ctx.candidates = v[split..].to_vec(); Outcome::done("decomposed at the emergent cluster boundary", 0.0) } } @@ -883,6 +1119,9 @@ impl Tactic for Amp { KernelMaturity::Operational } /// only when `free_energy > 0.5` + fn moves_confidence(&self) -> bool { + false + } fn writes(&self) -> ThoughtMask { ThoughtMask::of(&[ThoughtField::Rung]) } @@ -907,6 +1146,9 @@ impl Tactic for Zcf { fn maturity(&self) -> KernelMaturity { KernelMaturity::Demonstration } + fn moves_confidence(&self) -> bool { + false + } fn writes(&self) -> ThoughtMask { ThoughtMask::of(&[]) } @@ -931,6 +1173,9 @@ impl Tactic for Hpm { KernelMaturity::Operational } /// only when `candidates` is non-empty + fn moves_confidence(&self) -> bool { + false + } fn writes(&self) -> ThoughtMask { ThoughtMask::of(&[ThoughtField::Candidates]) } @@ -961,6 +1206,9 @@ impl Tactic for Cur { KernelMaturity::Operational } /// only while more than one candidate remains (the loop may not run) + fn moves_confidence(&self) -> bool { + true + } fn writes(&self) -> ThoughtMask { ThoughtMask::of(&[ThoughtField::Candidates]) } @@ -991,6 +1239,9 @@ impl Tactic for Mpc { fn maturity(&self) -> KernelMaturity { KernelMaturity::Operational } + fn moves_confidence(&self) -> bool { + false + } fn writes(&self) -> ThoughtMask { ThoughtMask::of(&[ThoughtField::Candidates]) } @@ -1013,6 +1264,9 @@ impl Tactic for Ssam { fn maturity(&self) -> KernelMaturity { KernelMaturity::Operational } + fn moves_confidence(&self) -> bool { + true + } fn writes(&self) -> ThoughtMask { ThoughtMask::of(&[]) } @@ -1035,6 +1289,9 @@ impl Tactic for Idr { KernelMaturity::Operational } /// only when `candidates` is non-empty + fn moves_confidence(&self) -> bool { + false + } fn writes(&self) -> ThoughtMask { ThoughtMask::of(&[ThoughtField::Candidates]) } @@ -1059,6 +1316,9 @@ impl Tactic for Spp { fn maturity(&self) -> KernelMaturity { KernelMaturity::Operational } + fn moves_confidence(&self) -> bool { + true + } fn writes(&self) -> ThoughtMask { ThoughtMask::of(&[]) } @@ -1085,44 +1345,60 @@ impl Tactic for Icr { Self::rec() } fn requires(&self) -> ThoughtMask { - ThoughtMask::EMPTY + ThoughtMask::of(&[ThoughtField::FreeEnergy, ThoughtField::Confidence]) } - /// Stub: hardcoded constants; `delta_conf` is literally `x * 0.0`. fn maturity(&self) -> KernelMaturity { - KernelMaturity::Stub + KernelMaturity::Operational + } + fn moves_confidence(&self) -> bool { + true } fn writes(&self) -> ThoughtMask { ThoughtMask::of(&[]) } - /// **⚠ STUB — this is NOT a Pearl counterfactual.** Labelled honestly per the - /// falsifiability rule ("a doc-comment claim is not a behaviour"). + /// **A split-pole SENSITIVITY probe. Still NOT a Pearl counterfactual — + /// and the carve did not make it one.** + /// + /// What it does: hold everything fixed, read the surprise scale from its + /// OPPOSITE pole (`1 - free_energy`), and report how far the derived + /// confidence moves. A conclusion that lands in the same place either way + /// is pole-insensitive and costs nothing; one that hinges entirely on which + /// pole it was read from is charged [`POLE_SENSITIVITY_WEIGHT`] of that + /// movement. The charge measures DEPENDENCE, never correctness — like every + /// periphery channel in this stack it can force a wider read, never name + /// the answer. /// - /// What it actually does: XORs three HARDCODED constants, counts the - /// resulting bit divergence, and contributes exactly zero confidence - /// (`* 0.0`). It never reads `ctx` — the same output for every input, so no - /// test over this kernel can fail. Recipe 31 carries the - /// `RungLevel::Counterfactual` label and the SPO=0b111 (Pearl "IMAGINE") - /// mask, and the label is the only counterfactual thing about it. + /// The quantity is `|1 - 2·free_energy| · confidence`: zero at + /// `free_energy = 0.5` (the pole flip is a no-op there, so there is nothing + /// to charge) and maximal at either extreme. /// - /// A real `do(X = x)` must SEVER the mechanisms that normally determine - /// `X` — parents disconnected, evidence derived from those parents - /// invalidated, descendants recomputed — while holding the exogenous - /// background fixed. Overwriting a value while retaining evidence derived - /// from its old parents is a contradictory MUTATION, not an intervention. - /// Nothing in this crate severs anything today. + /// **What was carved, and what was NOT.** It previously XORed three + /// HARDCODED constants, counted bit divergence, and multiplied the result + /// by a literal `0.0` — the same output for every input, so no test over it + /// could fail. It now reads `ctx` and lands a real effect. It still does + /// not intervene: a real `do(X = x)` must SEVER the mechanisms that + /// normally determine `X` — parents disconnected, evidence derived from + /// those parents invalidated, descendants recomputed — while holding the + /// exogenous background fixed. Re-reading one scalar from its other pole + /// severs nothing. Nothing in this crate severs anything today. /// /// Tracked: `ISS-PEARL-VOCABULARY-WITHOUT-PEARL-MECHANICS`. Do not cite - /// this kernel, or recipe 31's rung, as evidence of counterfactual - /// capability. - fn apply(&self, _ctx: &mut ThoughtCtx) -> Outcome { - // Counterfactual: world' = world ⊗ factual ⊗ counterfactual; divergence = popcount. - let world = 0xF0F0_F0F0u32; - let (factual, counterfactual) = (0x0000_00FFu32, 0x0000_FF00u32); - let world_cf = world ^ factual ^ counterfactual; // SPO=0b111 apex - let divergence = (world ^ world_cf).count_ones(); + /// this kernel, or recipe 31's `RungLevel::Counterfactual` label and + /// SPO=0b111 (Pearl "IMAGINE") mask, as evidence of counterfactual + /// capability. The carve moved it from "cannot fail a test" to "measures + /// something real"; it did not move it up Pearl's ladder. + fn apply(&self, ctx: &mut ThoughtCtx) -> Outcome { + let factual = ctx.free_energy.clamp(0.0, 1.0); + let pole = 1.0 - factual; + let under_factual = (1.0 - factual) * ctx.confidence; + let under_pole = (1.0 - pole) * ctx.confidence; + let sensitivity = (under_factual - under_pole).abs(); + if sensitivity <= NOISE_FLOOR { + return Outcome::done("conclusion is pole-insensitive", 0.0); + } Outcome::done( - "STUB counterfactual (hardcoded constants; contributes no confidence)", - (divergence as f32 / 32.0) * 0.0, // divergence reported, conf unchanged + "conclusion hinges on the surprise pole", + -(sensitivity * POLE_SENSITIVITY_WEIGHT), ) } } @@ -1135,25 +1411,43 @@ impl Tactic for Sdd { fn requires(&self) -> ThoughtMask { ThoughtMask::of(&[ThoughtField::Candidates]) } - /// Demonstration: detects distortion and reports it in the note, but `delta_conf` - /// is hardcoded 0.0 outside the branch — the detection lands nowhere. fn maturity(&self) -> KernelMaturity { - KernelMaturity::Demonstration + KernelMaturity::Operational + } + fn moves_confidence(&self) -> bool { + true } fn writes(&self) -> ThoughtMask { ThoughtMask::of(&[]) } + /// Semantic distortion: the candidate field's deviation from + /// [`NEUTRAL_SCORE`], measured against the Berry-Esseen [`NOISE_FLOOR`], + /// and CHARGED to confidence in proportion to its size. + /// + /// Carved from a Demonstration that computed `distorted` and reported it + /// in the note while returning a hardcoded `0.0` — the detection landed + /// nowhere. + /// + /// **Why proportional and not a fixed penalty.** `NOISE_FLOOR` is 0.004, + /// so the boolean flag fires on very nearly any real candidate field (both + /// standard probes here trip it at `dev = 0.025`). A fixed charge behind an + /// almost-always-true flag is a constant wearing a detector's clothes. The + /// magnitude is the measurement; the flag only names the branch. + /// + /// An EMPTY field is not distortion — `mean(&[])` is `0.0`, which would + /// otherwise read as maximal deviation and charge a page for having + /// nothing to say. fn apply(&self, ctx: &mut ThoughtCtx) -> Outcome { - // Semantic distortion: deviation above the Berry-Esseen noise floor = real distortion. - let dev = (mean(&ctx.candidates) - 0.5).abs(); - let distorted = dev > NOISE_FLOOR; + if ctx.candidates.is_empty() { + return Outcome::done("no candidates to measure", 0.0); + } + let dev = (mean(&ctx.candidates) - NEUTRAL_SCORE).abs(); + if dev <= NOISE_FLOOR { + return Outcome::done("within noise floor", 0.0); + } Outcome::done( - if distorted { - "distortion above noise floor flagged" - } else { - "within noise floor" - }, - 0.0, + "distortion above noise floor charged", + -(dev.min(1.0) * DISTORTION_WEIGHT), ) } } @@ -1170,6 +1464,9 @@ impl Tactic for Dtmf { KernelMaturity::Operational } /// only when the gate reads BLOCK + fn moves_confidence(&self) -> bool { + false + } fn writes(&self) -> ThoughtMask { ThoughtMask::of(&[ThoughtField::Temperature]) } @@ -1202,6 +1499,9 @@ impl Tactic for Hkf { fn maturity(&self) -> KernelMaturity { KernelMaturity::Demonstration } + fn moves_confidence(&self) -> bool { + false + } fn writes(&self) -> ThoughtMask { ThoughtMask::of(&[]) } @@ -1407,10 +1707,11 @@ mod effect_census { continue; } let has_write = !k.writes().is_empty(); - let moves_confidence = probes().into_iter().any(|mut c| { - let out = k.apply(&mut c); - out.delta_conf != 0.0 - }); + // The DECLARATION, not a second measurement — `moves_confidence` + // is itself pinned against observation by + // `moves_confidence_matches_observation`, and re-deriving it here + // would make this test pass even if the declaration were a lie. + let moves_confidence = k.moves_confidence(); assert!( has_write || moves_confidence, "{} ({}) claims Operational but writes nothing and never moves confidence", @@ -1420,6 +1721,72 @@ mod effect_census { } } + /// **`moves_confidence()` is a MEASUREMENT, not a wish** — pinned in both + /// directions, so neither over- nor under-declaring survives. + /// + /// Under-declaring is the dangerous one: a caller filtering on this to find + /// tactics that can dissent would silently drop a real dissenter. Over- + /// declaring is the one that reintroduces the defect this method exists to + /// close — a spent watcher slot returning guaranteed agreement. + /// + /// If a future kernel gains a confidence branch the probe matrix cannot + /// reach, this fails and the PROBES get extended — which is exactly what + /// happened to `Mcp` once already (see `probes`). + #[test] + fn moves_confidence_matches_observation() { + for k in all_kernels() { + let observed = probes() + .into_iter() + .any(|mut c| k.apply(&mut c).delta_conf != 0.0); + assert_eq!( + k.moves_confidence(), + observed, + "{} ({}) declares moves_confidence()={} but observation says {}", + k.meta().code, + k.meta().id, + k.moves_confidence(), + observed + ); + } + } + + /// **Confidence-capable is strictly STRONGER than production, and the gap + /// is large.** Measured: 14 of 34 can move `delta_conf`, 31 of 34 are + /// `Operational`. + /// + /// Both halves matter. The implication (`moves_confidence` ⇒ + /// `Operational`) is what lets a caller filter on capability ALONE without + /// separately checking maturity — it is checked here rather than asserted + /// in a comment. The strictness (the two sets are NOT equal) is what stops + /// a future reader concluding the two predicates are interchangeable, which + /// is precisely the conflation codex caught on PR #971. + #[test] + fn moves_confidence_is_strictly_stronger_than_production() { + let (mut capable, mut production) = (0usize, 0usize); + for k in all_kernels() { + if k.moves_confidence() { + capable += 1; + assert!( + k.maturity().is_production(), + "{} moves confidence but is {:?} — a non-production kernel \ + must land no effect at all", + k.meta().code, + k.maturity() + ); + } + if k.maturity().is_production() { + production += 1; + } + } + assert_eq!(capable, 14, "the confidence-capable set"); + assert_eq!(production, 31, "the production set"); + assert!( + capable < production, + "the two predicates coincide — filtering on maturity would be enough \ + and this method would be redundant" + ); + } + /// The converse: a `Demonstration` or `Stub` must NOT be quietly /// effectful. If one starts doing real work, its maturity is stale and /// this fails rather than letting an unreviewed effect ride in under a @@ -1458,8 +1825,16 @@ mod effect_census { } } - /// The four context-blind kernels return the SAME outcome for radically - /// different inputs — the honest test for an algebra demonstration. + /// The remaining context-blind kernels return the SAME outcome for + /// radically different inputs — the honest test for an algebra + /// demonstration. + /// + /// Re-pinned from FOUR to THREE when `Icr` was carved into a split-pole + /// sensitivity probe: it reads `free_energy` and `confidence` now, so it is + /// no longer blind and asserting invariance over it would be false. The + /// three that remain (`Are` / `Zcf` / `Hkf`) are blocked on the same + /// substrate deliverable — an identity-fingerprint rail the kernel + /// substrate does not yet expose — and stay Demonstrations until it lands. /// /// Note this is deliberately NOT a can-fire / can-stay-silent pair: those /// belong to detectors and thresholded gates. A kernel that ignores its @@ -1467,7 +1842,7 @@ mod effect_census { /// is *invariance*, and asserting anything else would be theatre. #[test] fn context_blind_kernels_are_input_invariant() { - const BLIND: [u8; 4] = [19, 24, 31, 34]; // Are, Zcf, Icr, Hkf + const BLIND: [u8; 3] = [19, 24, 34]; // Are, Zcf, Hkf for id in BLIND { let k = kernel(id).expect("id in range"); let outs: Vec = probes().into_iter().map(|mut c| k.apply(&mut c)).collect(); @@ -1510,7 +1885,17 @@ mod effect_census { assert_eq!(operational + demonstration + stub, 34); assert!(operational > 0 && operational < 34, "not all one label"); assert!(demonstration > 0, "the demonstrations must stay visible"); - assert_eq!(stub, 1, "Icr is the one self-declared stub"); + // Re-pinned from 1 to 0: `Icr`, the one self-declared stub, was + // carved. This is deliberately an EQUALITY and not `<= 1` — a new stub + // appearing should fail here and be reviewed, not absorbed. + assert_eq!( + stub, 0, + "the last stub (Icr) was carved; a new one needs a decision" + ); + assert_eq!( + demonstration, 3, + "Are/Zcf/Hkf remain Demonstrations, blocked on the identity-fingerprint rail" + ); } /// **The finding this census exists for.** `delta_conf == 0.0` does NOT @@ -1553,6 +1938,159 @@ mod tests { c } + // ── the maturity gate ──────────────────────────────────────────────────── + + /// A deliberately EFFECTFUL fixture that declares itself non-production. + /// + /// Test-local on purpose. Pinning the gate against a live kernel would go + /// vacuous the day that kernel is carved — which is exactly what happened + /// to the last `Stub` in this very commit. A fixture whose maturity is + /// chosen by the test cannot drift with the population. + /// + /// It mutates `ctx` and returns a large `delta_conf` so "the refusal + /// happened" and "nothing ran" are the same observation: a version that + /// let it through would be visible in `ctx`, not merely in a flag. + struct Fixture(KernelMaturity, &'static Recipe); + impl Tactic for Fixture { + fn meta(&self) -> &'static Recipe { + self.1 + } + fn maturity(&self) -> KernelMaturity { + self.0 + } + fn moves_confidence(&self) -> bool { + true // it returns 0.25 — see `apply` + } + fn writes(&self) -> ThoughtMask { + ThoughtMask::of(&[ThoughtField::Rung]) + } + fn requires(&self) -> ThoughtMask { + ThoughtMask::EMPTY + } + fn apply(&self, ctx: &mut ThoughtCtx) -> Outcome { + ctx.rung = 9; + Outcome::done("fixture ran", 0.25) + } + } + + /// **`ProductionOnly` refuses what `Any` runs — in both directions.** + /// + /// One-sided halves are the trap here: a policy that refused EVERYTHING + /// would pass the refusal half, and one that refused NOTHING would pass the + /// run half. Every maturity is checked under both policies. + #[test] + fn maturity_policy_refuses_exactly_the_non_production_kernels() { + for maturity in [ + KernelMaturity::Operational, + KernelMaturity::Demonstration, + KernelMaturity::Stub, + ] { + let k = Fixture(maturity, Rte.meta()); + + // Any: always runs, whatever the maturity. + let mut c = ThoughtCtx::new(vec![0.5]); + let out = k.run_with(&mut c, MaturityPolicy::Any); + assert!(out.fired, "{maturity:?} must run under Any"); + assert_eq!(out.skip, None); + assert_eq!(c.rung, 9, "{maturity:?}: Any must let the effect land"); + + // ProductionOnly: runs iff production. + let mut c = ThoughtCtx::new(vec![0.5]); + let before = c.clone(); + let out = k.run_with(&mut c, MaturityPolicy::ProductionOnly); + if maturity.is_production() { + assert!(out.fired, "{maturity:?} is production and must run"); + assert_eq!(c.rung, 9); + } else { + assert!(!out.fired, "{maturity:?} must be refused"); + assert_eq!( + out.skip, + Some(SkipReason::NonProduction(maturity)), + "{maturity:?}: the refusal must name the maturity it refused" + ); + assert_eq!(out.delta_conf, 0.0); + // The whole point: a refused kernel never sees ctx. + assert_eq!( + c.rung, before.rung, + "{maturity:?} mutated ctx after refusal" + ); + assert_eq!( + c.confidence, before.confidence, + "{maturity:?} moved confidence after refusal" + ); + } + } + } + + /// **`run()` is unchanged.** The whole surface is additive, so the + /// pre-existing entry point must still be `Any` — a default that silently + /// became `ProductionOnly` would change every existing caller's behaviour + /// while every gate test above still passed. + #[test] + fn run_still_means_any() { + assert_eq!(MaturityPolicy::default(), MaturityPolicy::Any); + let k = Fixture(KernelMaturity::Stub, Rte.meta()); + let mut via_run = ThoughtCtx::new(vec![0.5]); + let mut via_any = ThoughtCtx::new(vec![0.5]); + assert_eq!( + k.run(&mut via_run), + k.run_with(&mut via_any, MaturityPolicy::Any) + ); + assert_eq!(via_run.rung, via_any.rung); + assert_eq!(via_run.confidence, via_any.confidence); + } + + /// **A refusal is reported as a refusal, not as an unrelated gate-off.** + /// + /// A `Gate`-bucket kernel sitting in `GateState::Flow` would be skipped + /// anyway. If the policy check ran second, the caller would be told + /// `GatedOff` and never learn the kernel was non-production at all — the + /// two silences would be indistinguishable exactly where telling them apart + /// matters. `Tcp`'s bucket is pinned by + /// `gate_bucket_recipes_skip_in_flow`, so this fixture cannot go stale + /// silently either. + #[test] + fn refusal_is_reported_ahead_of_an_unrelated_gate_off() { + let k = Fixture(KernelMaturity::Demonstration, Tcp.meta()); + let mut flow = ThoughtCtx::new(vec![0.5]); + flow.sd = 0.05; // FLOW → the Gate bucket would skip this anyway + + assert_eq!( + k.run_with(&mut flow.clone(), MaturityPolicy::Any).skip, + Some(SkipReason::GatedOff), + "under Any the gate is the only reason it can be skipped" + ); + assert_eq!( + k.run_with(&mut flow, MaturityPolicy::ProductionOnly).skip, + Some(SkipReason::NonProduction(KernelMaturity::Demonstration)), + "the refusal must not be masked by the gate's own silence" + ); + } + + /// The live population still contains something for `ProductionOnly` to + /// refuse AND something for it to run — otherwise the policy is inert on + /// the only set that ships. + #[test] + fn the_policy_discriminates_over_the_live_kernels() { + let (mut ran, mut refused) = (0usize, 0usize); + for k in all_kernels() { + let mut c = ThoughtCtx::new(vec![0.9, 0.1]); + c.sd = 0.5; // BLOCK — no Gate-bucket kernel is gated off here + match k.run_with(&mut c, MaturityPolicy::ProductionOnly).skip { + Some(SkipReason::NonProduction(_)) => refused += 1, + _ => ran += 1, + } + } + assert!( + ran > 0 && refused > 0, + "policy inert: ran={ran} refused={refused}" + ); + assert_eq!( + refused, 3, + "Are/Zcf/Hkf are the three the policy refuses today" + ); + } + #[test] fn all_34_kernels_dispatch_and_run() { let ks = all_kernels(); @@ -1588,11 +2126,137 @@ mod tests { assert!(c.confidence < before, "coherence drop on contradiction"); } + /// Re-pinned, not deleted. The old assertion + /// (`icr_builds_counterfactual_via_xor_self_inverse`) checked that the note + /// contained the word "counterfactual" while the body XORed three constants + /// — it could not fail, which is exactly why the kernel sat at `Stub`. + /// + /// The carve's actual claim is a SENSITIVITY measurement, so this is + /// two-sided on the quantity that matters: maximal pole-dependence at an + /// extreme surprise reading, exactly zero at the midpoint where flipping + /// the pole is a no-op. + #[test] + fn icr_charges_pole_dependence_and_is_silent_at_the_midpoint() { + // free_energy = 0.5 → the pole flip changes nothing → nothing to charge. + let mut mid = ThoughtCtx::new(vec![0.5]); + mid.free_energy = 0.5; + mid.confidence = 0.8; + let out = Icr.run(&mut mid); + assert!(out.fired, "the kernel still runs — it simply measures zero"); + assert_eq!(out.delta_conf, 0.0, "a pole-insensitive conclusion is free"); + assert_eq!(mid.confidence, 0.8, "and confidence is untouched"); + + // free_energy = 0.9 → reading it as 0.1 instead moves the answer a lot. + let mut skewed = ThoughtCtx::new(vec![0.5]); + skewed.free_energy = 0.9; + skewed.confidence = 0.8; + let out = Icr.run(&mut skewed); + assert!( + out.delta_conf < 0.0, + "a conclusion that hinges on the pole must be charged, got {}", + out.delta_conf + ); + assert!(skewed.confidence < 0.8, "and the charge must land on ctx"); + + // Monotone in the dependence, not a fixed cliff: further from the + // midpoint costs strictly more. + let mut nearer = ThoughtCtx::new(vec![0.5]); + nearer.free_energy = 0.6; + nearer.confidence = 0.8; + let near = Icr.apply(&mut nearer).delta_conf; + let far = { + let mut c = ThoughtCtx::new(vec![0.5]); + c.free_energy = 0.9; + c.confidence = 0.8; + Icr.apply(&mut c).delta_conf + }; + assert!( + far < near, + "charge must scale with dependence: 0.9 -> {far}, 0.6 -> {near}" + ); + } + + /// `Cas` scales the candidate field to the resolution its RUNG is entitled + /// to. Two-sided on the rung, because a version that ignored the rung and + /// quantized at a fixed grid would pass a one-sided test. + #[test] + fn cas_quantizes_candidates_to_the_rung_hdr_grid() { + let field = vec![0.9, 0.6, 0.3, 0.1]; + + let mut coarse = ThoughtCtx::new(field.clone()); + coarse.rung = 1; // level 1 → the field collapses to its poles + let _ = Cas.apply(&mut coarse); + assert_eq!(coarse.candidates, vec![1.0, 1.0, 0.0, 0.0]); + + let mut fine = ThoughtCtx::new(field.clone()); + fine.rung = 9; // level 32 → 1/32 resolution survives + let _ = Cas.apply(&mut fine); + assert_ne!( + fine.candidates, coarse.candidates, + "the rung is inert — Cas quantizes at a fixed grid" + ); + for (q, raw) in fine.candidates.iter().zip(&field) { + assert!( + (q - raw).abs() <= 1.0 / 64.0, + "a deep rung must keep the detail: {q} vs {raw}" + ); + } + } + + /// `Etd` splits at the boundary the DATA proposes, and declines when the + /// data proposes none. The silent half is the load-bearing one: a version + /// that always kept `v[1..]` would truncate a uniform field by one element + /// every time it ran and look like it was working. + #[test] + fn etd_splits_at_the_emergent_boundary_and_declines_on_a_uniform_field() { + // Two obvious clusters with one wide gap between them. + let mut split = ThoughtCtx::new(vec![0.05, 0.1, 0.85, 0.9]); + let out = Etd.apply(&mut split); + assert_eq!(split.candidates, vec![0.85, 0.9]); + assert!(out.note.contains("decomposed")); + + // A uniform field proposes no boundary — and must not be shortened. + let flat = vec![0.5, 0.5, 0.5, 0.5]; + let mut uniform = ThoughtCtx::new(flat.clone()); + let out = Etd.apply(&mut uniform); + assert_eq!( + uniform.candidates, flat, + "a uniform field must survive intact" + ); + assert!(out.note.contains("no emergent boundary")); + + // Fewer than two candidates: nothing to split. + let mut single = ThoughtCtx::new(vec![0.7]); + let _ = Etd.apply(&mut single); + assert_eq!(single.candidates, vec![0.7]); + } + + /// `Sdd` charges distortion in PROPORTION to the deviation, is exactly + /// silent at [`NEUTRAL_SCORE`], and refuses to read an empty field as + /// maximal distortion. #[test] - fn icr_builds_counterfactual_via_xor_self_inverse() { - let mut c = ThoughtCtx::new(vec![0.5]); - let out = Icr.run(&mut c); - assert!(out.fired && out.note.contains("counterfactual")); + fn sdd_charges_distortion_proportionally_and_stays_silent_at_neutral() { + let mut neutral = ThoughtCtx::new(vec![0.4, 0.6]); // mean exactly 0.5 + assert_eq!(Sdd.apply(&mut neutral).delta_conf, 0.0); + + let mut mild = ThoughtCtx::new(vec![0.6, 0.6]); + let mut wild = ThoughtCtx::new(vec![1.0, 1.0]); + let (m, w) = ( + Sdd.apply(&mut mild).delta_conf, + Sdd.apply(&mut wild).delta_conf, + ); + assert!(m < 0.0 && w < 0.0, "both are distorted: {m}, {w}"); + assert!( + w < m, + "the charge must scale with the deviation, not be a fixed cliff: \ + mild={m} wild={w}" + ); + + // mean(&[]) is 0.0 — without the guard that reads as dev = 0.5. + let mut nothing = ThoughtCtx::new(vec![]); + let out = Sdd.apply(&mut nothing); + assert_eq!(out.delta_conf, 0.0, "an empty field is not distortion"); + assert!(out.note.contains("no candidates")); } #[test] @@ -1648,10 +2312,22 @@ mod tests { assert!( Rte.requires().has(ThoughtField::FreeEnergy) && Rte.requires().has(ThoughtField::Rung) ); - // Are/Zcf/Icr/Hkf are constant-only (algebraic) → empty checklist is correct, + // Are/Zcf/Hkf are constant-only (algebraic) → empty checklist is correct, // not a forgotten declaration. assert!(Are.requires().is_empty() && Zcf.requires().is_empty()); - assert!(Icr.requires().is_empty() && Hkf.requires().is_empty()); + assert!(Hkf.requires().is_empty()); + // Icr was one of them until it was carved; it reads the surprise scale + // and the confidence it charges against, so an empty mask would now be + // a stale declaration rather than an honest one. + assert!( + Icr.requires().has(ThoughtField::FreeEnergy) + && Icr.requires().has(ThoughtField::Confidence) + ); + assert!(!Icr.requires().has(ThoughtField::Candidates)); + // Cas reads the rung it scales BY and the candidates it scales. + assert!( + Cas.requires().has(ThoughtField::Rung) && Cas.requires().has(ThoughtField::Candidates) + ); } /// TEETH (anti-theater): the 34 masks must be NON-TRIVIAL and VARIED — this fails @@ -1666,8 +2342,9 @@ mod tests { // constant-only tactics are legitimately empty). let empty = masks.iter().filter(|m| m.is_empty()).count(); assert_eq!( - empty, 4, - "exactly the 4 constant-only tactics (Are/Zcf/Icr/Hkf) are empty" + empty, 3, + "exactly the 3 constant-only tactics (Are/Zcf/Hkf) are empty — Icr left \ + this set when it was carved" ); // Varied: many distinct masks (fails the copy-paste/all-same stub). diff --git a/crates/lance-graph-planner/Cargo.toml b/crates/lance-graph-planner/Cargo.toml index 1710fecef..59a1a014a 100644 --- a/crates/lance-graph-planner/Cargo.toml +++ b/crates/lance-graph-planner/Cargo.toml @@ -74,6 +74,12 @@ cognitive-shader-driver = { path = "../cognitive-shader-driver" } # (§12.5 — "the `jc` additive constraint continues to hold"), and a measure # cannot be its own oracle. Do NOT invert this edge, and do NOT modify # `crates/jc` while using it as the oracle. +# +# SECOND consumer (2026-08-20): `strategy/stage25_census.rs` — the Stage-2.5 +# consumer-filter census, `#[cfg(test)]` only. Same constraint, same direction: +# `jc::stats` consumes the census's observations and nothing feeds back. No +# planner code path reads `jc`, and none may — it is instrumentation, not a +# semantic dependency. (This edge already existed; the census did not add it.) jc = { path = "../jc" } [features] diff --git a/crates/lance-graph-planner/src/cache/mod.rs b/crates/lance-graph-planner/src/cache/mod.rs index 2909532bb..856f7e81a 100644 --- a/crates/lance-graph-planner/src/cache/mod.rs +++ b/crates/lance-graph-planner/src/cache/mod.rs @@ -10,4 +10,8 @@ pub mod convergence; pub mod kv_bundle; pub mod lane_eval; pub mod nars_engine; +/// Stage-2.6a V3 representation-parity census — measurement only, compiled out +/// of every non-test build. +#[cfg(test)] +mod stage26_v3_parity; pub mod triple_model; diff --git a/crates/lance-graph-planner/src/cache/stage26_v3_parity.rs b/crates/lance-graph-planner/src/cache/stage26_v3_parity.rs new file mode 100644 index 000000000..2eba01a41 --- /dev/null +++ b/crates/lance-graph-planner/src/cache/stage26_v3_parity.rs @@ -0,0 +1,545 @@ +//! **Stage 2.6a — representation invariance on the planner's REAL `CausalEdge64` +//! reasoning path.** Measurement only; compiled out of every non-test build. +//! +//! # Why this seam and not the recipe surface +//! +//! Stage 2.6's original brief assumed `CE64 → recipe/runbook/planner`. **That +//! arrow does not exist.** `lance-graph-contract` — which owns the entire +//! Stage-2 surface (`recipe_kernels`, `recipes`, `recipe_dispatch`, +//! `materialize`) — has **no `causal-edge` dependency** and cannot name the +//! type; `style_strategy` consumes no causal edge; and the only non-test +//! producer of a `ThoughtCtx` reads exactly two `PlanContext` scalars. A V3 +//! entrance in front of that surface would rehydrate an edge nothing downstream +//! reads, and the comparison would return `discordance = 0` for an entirely +//! trivial reason — a green result that means nothing. (Recorded as Stage 2.6b: +//! the recipe surface is *causally blind*, which is a Stage-3 substrate-wiring +//! question, not a V3 migration defect. It is NOT patched here.) +//! +//! Where `CausalEdge64` actually reasons **inside the planner** is +//! [`super::nars_engine`]: `SpoHead ↔ CausalEdge64` via +//! [`NarsEngine::to_causal_edge`] / [`NarsEngine::from_causal_edge`], and +//! [`NarsEngine::forward_edge`] over the compose tables. That leg is the one the +//! existing compare-thinking work does not cover — `causal-edge`'s own +//! `syllogize` and `cognitive-shader-driver`'s emission path are already proven +//! (`edge_v3_compare`), the planner's is not. This module closes it. +//! +//! # The comparison +//! +//! ```text +//! direct: SpoHead --to_causal_edge--> CE64 --forward_edge--> CE64 --from_causal_edge--> SpoHead +//! V3: SpoHead --to_causal_edge--> CE64 --from_v1--> V3 --rehydrate(resolved SPO)--> CE64 +//! --forward_edge--> ... (the SAME path) +//! ``` +//! +//! **There is exactly ONE reasoning implementation.** The V3 arm does not +//! compute anything: it drops the in-edge SPO, resolves it back from the target +//! node's facet, rebuilds a `CausalEdge64`, and hands it to the *same* +//! `NarsEngine` methods. No V3-native NARS exists or is introduced. +//! +//! # What is compared, and what is deliberately NOT +//! +//! Compared, by **exact equality** — the primary contract, never a correlation: +//! the rehydrated `CausalEdge64` itself; the `SpoHead` it converts back to +//! (SPO after resolution, NARS frequency/confidence, causal mask, inference +//! class); the `forward_edge` conclusion; the `SpoHead` of that conclusion; and +//! the `syllogize` conclusion identity (the quantity `edge_v3_compare` already +//! uses, kept so the two harnesses speak the same language). +//! +//! **Not** compared, because they are representation-specific by design and +//! asserting on them would be asserting that V3 is CE64: the V3 Lokal `target`, +//! the V3 `TE` byte, the payload width. +//! +//! # The resolver invariant is the load-bearing one +//! +//! Equivalence is CONDITIONAL: it holds exactly while the resolved node facet +//! agrees with the SPO the original edge carried. So this module ships both +//! halves — a positive pass over correct resolution, and a +//! [`v3_parity_detects_a_corrupted_resolution`] falsifier that deliberately +//! resolves the wrong SPO and requires the comparator to go red. A comparator +//! that stays green after the resolution is corrupted proves nothing. + +use std::collections::BTreeMap; + +use causal_edge::{CausalEdge64, CausalEdgeV3}; + +use super::nars_engine::{NarsEngine, SpoDistances, SpoHead}; + +/// The node-facet SPO resolver: `Lokal target → (s_idx, p_idx, o_idx)`. +/// +/// Stands in for "read the SPO out of the target node's 6×256² CAM-PQ facet". +/// The V3 contract is that the edge does not duplicate what the node already +/// holds, so the harness must hold that mapping somewhere; a map keyed by the +/// same `u16` the edge carries is the smallest honest model of it. +#[derive(Default)] +struct FacetResolver { + spo: BTreeMap, +} + +impl FacetResolver { + fn bind(&mut self, target: u16, spo: (u8, u8, u8)) { + self.spo.insert(target, spo); + } + fn resolve(&self, target: u16) -> Option<(u8, u8, u8)> { + self.spo.get(&target).copied() + } +} + +/// One paired observation at the seam. +struct Leg { + /// Label for the discordance artifact. + case: String, + /// Direct arm. + direct_edge: CausalEdge64, + direct_fwd: CausalEdge64, + direct_head: SpoHead, + direct_fwd_head: SpoHead, + direct_syllogism: Option, + /// V3 arm — same engine, same methods, edge routed through V3. + v3_edge: CausalEdge64, + v3_fwd: CausalEdge64, + v3_head: SpoHead, + v3_fwd_head: SpoHead, + v3_syllogism: Option, +} + +impl Leg { + /// Every compared invariant, as `(name, agrees)`. Exact equality throughout. + fn invariants(&self) -> Vec<(&'static str, bool)> { + vec![ + ("rehydrated_ce64", self.v3_edge == self.direct_edge), + ( + "spo_after_resolution", + spo_of(self.v3_edge) == spo_of(self.direct_edge), + ), + ( + "nars_frequency", + self.v3_edge.frequency_u8() == self.direct_edge.frequency_u8(), + ), + ( + "nars_confidence", + self.v3_edge.confidence_u8() == self.direct_edge.confidence_u8(), + ), + ( + "causal_mask", + self.v3_edge.causal_mask() as u8 == self.direct_edge.causal_mask() as u8, + ), + ( + "inference_class", + self.v3_edge.inference() as u8 == self.direct_edge.inference() as u8, + ), + ("spo_head", self.v3_head == self.direct_head), + ("forward_edge_result", self.v3_fwd == self.direct_fwd), + ("forward_spo_head", self.v3_fwd_head == self.direct_fwd_head), + ( + "syllogism_conclusion", + self.v3_syllogism == self.direct_syllogism, + ), + ( + "truth_frequency", + self.v3_head.frequency() == self.direct_head.frequency(), + ), + ( + "truth_confidence", + self.v3_head.confidence() == self.direct_head.confidence(), + ), + ( + "expectation", + self.v3_head.expectation() == self.direct_head.expectation(), + ), + ] + } + + fn discordant(&self) -> Vec<&'static str> { + self.invariants() + .into_iter() + .filter(|(_, ok)| !ok) + .map(|(n, _)| n) + .collect() + } +} + +fn spo_of(e: CausalEdge64) -> (u8, u8, u8) { + (e.s_idx(), e.p_idx(), e.o_idx()) +} + +/// The `SpoHead` sweep the comparison runs over. +/// +/// **The PATH is the real one** — every head below is driven through +/// [`NarsEngine::to_causal_edge`], [`NarsEngine::forward_edge`] and +/// [`NarsEngine::from_causal_edge`], never around them. The heads themselves +/// are a deliberate sweep of the field domains the conversion actually +/// branches on, stated plainly rather than dressed up as harvested data: +/// +/// - **every `inference` discriminant `to_causal_edge` maps**, including the +/// two Pearl rungs it translates (local `7`→`Intervention`, local +/// `8`→`Counterfactual`) and the `5 | 6` arm that folds to `Synthesis` — the +/// fold is lossy on the way out, so it is exactly where a representation +/// round-trip could diverge and must be swept; +/// - **every 3-bit `pearl` mask** `0b000..=0b111`; +/// - **frequency/confidence at both rails and the midpoint**, since +/// `SpoHead::frequency` divides by 255 and a rail is where a rounding +/// difference would surface; +/// - **SPO indices spanning the palette**, including `0` and `255`. +fn head_sweep() -> Vec { + let mut heads = Vec::new(); + let inferences = [0u8, 1, 2, 3, 4, 5, 6, 7, 8]; + let truths = [(0u8, 0u8), (128, 128), (255, 255), (255, 0), (0, 255)]; + for (i, &inference) in inferences.iter().enumerate() { + for pearl in 0u8..8 { + let (freq, conf) = truths[(i + pearl as usize) % truths.len()]; + heads.push(SpoHead { + s_idx: (i as u8).wrapping_mul(29), + p_idx: pearl.wrapping_mul(31), + o_idx: (i as u8).wrapping_mul(7).wrapping_add(pearl), + freq, + conf, + pearl, + inference, + // `to_causal_edge` passes this into `pack`'s temporal argument, + // where the v2 layout makes the write a no-op. Swept non-zero on + // purpose: if that ever stops being a no-op, the V3 arm (whose + // `rehydrate` packs temporal 0) diverges and this harness says so + // instead of the change landing silently. + temporal: (i as u8).wrapping_add(pearl), + }); + } + } + // Both palette rails, at the extremes of the truth range. + heads.push(SpoHead { + s_idx: 0, + p_idx: 0, + o_idx: 0, + freq: 0, + conf: 0, + pearl: 0, + inference: 0, + temporal: 0, + }); + heads.push(SpoHead { + s_idx: 255, + p_idx: 255, + o_idx: 255, + freq: 255, + conf: 255, + pearl: 0b111, + inference: 3, + temporal: 255, + }); + heads +} + +/// The three 256×256 compose tables [`NarsEngine::forward_edge`] takes. +type ComposeTables = ( + Box<[u8; 256 * 256]>, + Box<[u8; 256 * 256]>, + Box<[u8; 256 * 256]>, +); + +/// One `(input, weight)` pair to run through the seam, with the Lokal targets +/// whose node facets hold their SPO. +struct LegSpec<'a> { + input: &'a SpoHead, + weight: &'a SpoHead, + target_in: u16, + target_w: u16, + case: String, +} + +/// Compose tables for [`NarsEngine::forward_edge`]. +/// +/// Deterministic and NON-identity: with an identity table `forward` leaves the +/// SPO untouched, so the composition the tables drive would never actually run +/// under the `forward_edge_result` invariant. Pinned by the `spo_moved` half of +/// [`the_sweep_is_not_degenerate`] — and note the WEAKER "the edge changed at +/// all" form does not catch it, because `forward` also composes the NARS truth. +fn compose_tables() -> ComposeTables { + let build = |salt: u32| { + let mut t = Box::new([0u8; 256 * 256]); + for a in 0..256usize { + for b in 0..256usize { + t[a * 256 + b] = ((a * 7 + b * 13 + salt as usize) % 256) as u8; + } + } + t + }; + (build(0), build(97), build(211)) +} + +/// Run the seam for one `(input, weight)` pair under a given resolver. +fn run_leg( + engine: &NarsEngine, + resolver: &FacetResolver, + spec: LegSpec<'_>, + tables: &ComposeTables, +) -> Leg { + let LegSpec { + input, + weight, + target_in, + target_w, + case, + } = spec; + let (cs, cp, co) = (&*tables.0, &*tables.1, &*tables.2); + + // ── direct arm: the shipping planner path ── + let direct_edge = engine.to_causal_edge(input); + let direct_w = engine.to_causal_edge(weight); + let direct_fwd = engine.forward_edge(direct_edge, direct_w, cs, cp, co); + + // ── V3 arm: drop SPO, resolve it back, rehydrate, SAME path ── + let v3_in = CausalEdgeV3::from_v1(direct_edge, target_in); + let v3_wt = CausalEdgeV3::from_v1(direct_w, target_w); + let (si, pi, oi) = resolver.resolve(target_in).expect("bound target"); + let (sw, pw, ow) = resolver.resolve(target_w).expect("bound target"); + let v3_edge = v3_in.rehydrate(si, pi, oi); + let v3_w = v3_wt.rehydrate(sw, pw, ow); + let v3_fwd = engine.forward_edge(v3_edge, v3_w, cs, cp, co); + + let syl = |a: CausalEdge64, b: CausalEdge64| a.syllogize(b).map(|s| s.conclusion); + + Leg { + case, + direct_head: engine.from_causal_edge(direct_edge), + direct_fwd_head: engine.from_causal_edge(direct_fwd), + direct_syllogism: syl(direct_edge, direct_w), + v3_head: engine.from_causal_edge(v3_edge), + v3_fwd_head: engine.from_causal_edge(v3_fwd), + v3_syllogism: syl(v3_edge, v3_w), + direct_edge, + direct_fwd, + v3_edge, + v3_fwd, + } +} + +/// The full census: every head against its successor as the weight. +fn census(resolver_corruption: Option) -> Vec { + let engine = NarsEngine::new(SpoDistances::new_zero()); + let tables = compose_tables(); + let heads = head_sweep(); + + // Bind each head's SPO to its own Lokal target — the node facet "holds" it. + let mut resolver = FacetResolver::default(); + for (i, h) in heads.iter().enumerate() { + resolver.bind(0x1000 + i as u16, (h.s_idx, h.p_idx, h.o_idx)); + } + // The falsifier: one facet now disagrees with the edge it came from. + if let Some(t) = resolver_corruption { + let (s, p, o) = resolver.resolve(t).expect("corrupt an existing binding"); + resolver.bind(t, (s.wrapping_add(1), p, o)); + } + + let mut legs = Vec::with_capacity(heads.len()); + for i in 0..heads.len() { + let j = (i + 1) % heads.len(); + legs.push(run_leg( + &engine, + &resolver, + LegSpec { + input: &heads[i], + weight: &heads[j], + target_in: 0x1000 + i as u16, + target_w: 0x1000 + j as u16, + case: format!("inf={} pearl={} i={i}", heads[i].inference, heads[i].pearl), + }, + &tables, + )); + } + legs +} + +#[cfg(test)] +mod tests { + use super::*; + use jc::stats::binary_association; + + /// **The primary contract: exact representation invariance, zero + /// discordance, on the planner's real CE64 path.** + #[test] + fn v3_representation_is_invariant_on_the_planner_ce64_path() { + let legs = census(None); + assert!(!legs.is_empty(), "the sweep ran nothing"); + + let mut discordant = 0usize; + for leg in &legs { + let bad = leg.discordant(); + assert!(bad.is_empty(), "{}: V3 diverged on {:?}", leg.case, bad); + discordant += usize::from(!bad.is_empty()); + } + assert_eq!(discordant, 0, "planner V3 representation discordance"); + } + + /// **The falsifier — and it must bite on BOTH operands.** + /// + /// Corrupt ONE resolved facet SPO and the comparator must go red. A + /// comparator that stays green after the resolution is corrupted proves + /// nothing: the equivalence is conditional on `resolved node facet SPO == + /// the original edge's SPO`, and this is what makes that condition + /// observable rather than assumed. + /// + /// **The input-side assertion alone was not enough, and that was a real + /// hole.** Leg `t` uses target `t` as its INPUT while leg `t-1` uses it as + /// its WEIGHT. Requiring only "some leg is discordant, on the input-edge + /// invariants" let leg `t` satisfy every assertion by itself — so the + /// **weight** rehydration could be replaced with the direct edge, bypassing + /// V3 entirely and unnoticed, even though `forward_edge` and `syllogize` + /// both depend on it. (Codex review, PR #971.) + /// + /// So both legs are named, and the weight-side leg must fail on a + /// **composition** invariant specifically: its own input resolves fine, so + /// the input-edge invariants are clean there and only the composition can + /// see a corrupted weight. + #[test] + fn v3_parity_detects_a_corrupted_resolution_on_both_operands() { + const CORRUPT: u16 = 0x1000; + let legs = census(Some(CORRUPT)); + let n = legs.len(); + let input_leg = (CORRUPT - 0x1000) as usize; + let weight_leg = (input_leg + n - 1) % n; + + let discordant: Vec = (0..n) + .filter(|&i| !legs[i].discordant().is_empty()) + .collect(); + assert!( + !discordant.is_empty(), + "corrupting a resolved SPO changed nothing — the comparator is vacuous" + ); + + // (a) the INPUT-side leg fails on the SPO-shaped invariants — naming + // WHICH invariant sees it is the difference between a detector and + // an alarm. + let on_input = legs[input_leg].discordant(); + assert!( + on_input.contains(&"spo_after_resolution") && on_input.contains(&"rehydrated_ce64"), + "input-side leg {input_leg} did not fail on the SPO invariants: {on_input:?}" + ); + + // (b) the WEIGHT-side leg fails on a COMPOSITION invariant. This is the + // assertion that stops the second operand bypassing V3 unnoticed. + let on_weight = legs[weight_leg].discordant(); + assert!( + on_weight.iter().any(|inv| matches!( + *inv, + "forward_edge_result" | "forward_spo_head" | "syllogism_conclusion" + )), + "weight-side leg {weight_leg} saw no composition divergence: {on_weight:?} \ + — the weight rehydration could bypass V3 unnoticed" + ); + assert!( + !on_weight.contains(&"rehydrated_ce64"), + "weight-side leg {weight_leg} failed on an INPUT invariant, so it is not \ + isolating the weight path: {on_weight:?}" + ); + + // (c) and it must NOT fire everywhere — a comparator that reports every + // leg discordant after a single-facet corruption is not localising. + assert!( + discordant.len() < n, + "a one-facet corruption made every leg discordant ({} of {n}) — the \ + comparator is not localising", + discordant.len() + ); + } + + /// The sweep genuinely exercises the branches it claims to. + /// + /// Anti-vacuity for the invariants above: if every leg produced the same + /// edge, or no leg ever syllogized, "they all agree" would be a statement + /// about a constant rather than about the representation. + #[test] + fn the_sweep_is_not_degenerate() { + let legs = census(None); + let distinct_edges: std::collections::BTreeSet = + legs.iter().map(|l| l.direct_edge.0).collect(); + assert!( + distinct_edges.len() > legs.len() / 2, + "the sweep collapsed to {} distinct edges over {} legs", + distinct_edges.len(), + legs.len() + ); + let syllogized = legs.iter().filter(|l| l.direct_syllogism.is_some()).count(); + assert!( + syllogized > 0 && syllogized < legs.len(), + "syllogism is constant across the sweep ({syllogized}/{}) — the \ + conclusion-identity invariant would be vacuous", + legs.len() + ); + // The forward composition must actually move the edge — and + // specifically its SPO, which is what the compose tables drive. + // + // The weaker form of this ("the edge changed at all") was written first + // and is NOT a discriminating check: `forward` also composes the NARS + // truth, so it moves the edge even when every compose table is the + // identity. Measured — the disable-run that made the tables identity + // left the weak assertion green. The SPO form is the one that fails + // there, which is the property the non-identity tables exist to give. + let moved = legs + .iter() + .filter(|l| l.direct_fwd != l.direct_edge) + .count(); + assert!( + moved > 0, + "forward_edge never changed an edge — the compose tables are inert" + ); + let spo_moved = legs + .iter() + .filter(|l| spo_of(l.direct_fwd) != spo_of(l.direct_edge)) + .count(); + assert!( + spo_moved > 0, + "forward_edge never changed an SPO across {} legs — the compose \ + tables are effectively the identity and the composition is not \ + being exercised", + legs.len() + ); + } + + /// JC summarises; it does not adjudicate. + /// + /// Every quantity at this seam is exact — `u8` palette indices, `u8` truth + /// bytes, a `u64` register — so there is **no naturally continuous quantity + /// here for a correlation to characterise**, and none is manufactured. What + /// `jc` legitimately contributes is the cross-tab: syllogism PRESENCE is a + /// real binary pair, both categories occur across the sweep, so κ is + /// **defined** and its value is a genuine statement rather than the + /// degenerate constant-column case `jc` refuses to score. + #[test] + fn jc_summary_of_the_agreement_is_perfect_and_defined() { + let legs = census(None); + let direct: Vec = legs.iter().map(|l| l.direct_syllogism.is_some()).collect(); + let v3: Vec = legs.iter().map(|l| l.v3_syllogism.is_some()).collect(); + let t = binary_association(&direct, &v3).expect("equal-length, non-empty"); + assert_eq!((t.n01, t.n10), (0, 0), "off-diagonal must be empty"); + assert!( + t.n11 > 0 && t.n00 > 0, + "both categories must occur or the agreement is vacuous (n11={}, n00={})", + t.n11, + t.n00 + ); + let k = t.kappa.expect("kappa defined when both categories occur"); + assert!((k - 1.0).abs() < 1e-12, "kappa = {k}"); + } + + /// Write the compact discordance-only artifact. Header-only IS the result. + #[test] + #[ignore = "artifact generator; run explicitly"] + fn stage26_write_discordance_artifact() { + let legs = census(None); + let dir = concat!(env!("CARGO_MANIFEST_DIR"), "/../../docs/probes"); + std::fs::create_dir_all(dir).expect("create docs/probes"); + let mut csv = String::from("case,invariant,direct,v3\n"); + for leg in &legs { + for name in leg.discordant() { + csv.push_str(&format!( + "{},{name},{:#018x},{:#018x}\n", + leg.case, leg.direct_edge.0, leg.v3_edge.0 + )); + } + } + std::fs::write( + format!("{dir}/stage26-v3-planner-parity-discordance.csv"), + csv, + ) + .expect("write discordance csv"); + } +} diff --git a/crates/lance-graph-planner/src/strategy/stage25_census.rs b/crates/lance-graph-planner/src/strategy/stage25_census.rs new file mode 100644 index 000000000..00b7abe76 --- /dev/null +++ b/crates/lance-graph-planner/src/strategy/stage25_census.rs @@ -0,0 +1,1005 @@ +//! **Stage 2.5 — the consumer-filter census.** Measurement only; compiled out +//! of every non-test build (`#[cfg(test)]` at the `mod` line). +//! +//! Stage 2 shipped a maturity clause in both dissent channels' eligibility +//! predicate and reported one sentence: *the filter changes which watchers are +//! sampled but changed no verdict across 5,760 configurations.* Stage 2.5 +//! exists to characterise that sentence quantitatively — and, specifically, to +//! keep its two halves apart. **"Filter changes the watcher sample" and "filter +//! changes the verdict" are two dependent variables, not one**; collapsing them +//! is how a coverage fix gets written up as "no effect". +//! +//! # What is measured, and what is NOT +//! +//! Every configuration `x = (style, rung, k, tol)` is a PAIRED observation: +//! the OFF arm samples on the mechanism clause alone, the ON arm adds the +//! maturity clause, and both arms then run the SAME shipped verdict body +//! ([`StyleStrategy::dissent_over`]). Nothing here reimplements the channel — +//! that is the whole reason the body was extracted, and the extraction is +//! pinned verdict-identical (0/5,760) by the Stage-2 arc. +//! +//! **No inferential test is run over the enumeration, on purpose.** The census +//! is EXHAUSTIVE and DETERMINISTIC: every cell of the design is visited exactly +//! once and the same input always produces the same output, so there is no +//! sampling distribution for a p-value to be a statement about. `jc::stats` is +//! used here for what it can honestly say on a census — cross-tabulation +//! ([`binary_association`], which carries the marginals and κ), variance +//! DECOMPOSITION ([`eta_squared`], [`multiple_r_squared`]), and rank/linear +//! association ([`spearman`], [`pearson`]). `t_test_*` / `anova_one_way`'s +//! p-values are deliberately not reported: manufacturing significance where the +//! statistic is degenerate is the failure this module is supposed to avoid, not +//! commit. +//! +//! The one genuinely inferential quantity IS reported, because it is the +//! question worth asking: **given zero observed verdict flips, how large could +//! the true flip rate still plausibly be?** That is a one-sided exact binomial +//! (Clopper-Pearson) upper limit, which at zero events has the closed form +//! `1 − α^(1/n)` and needs no incomplete-beta evaluation — and it is reported as +//! a LADDER over clustering assumptions, because the 5,760 rows are repeated +//! measures, not 5,760 independent trials (one style contributes 160 of them). +//! +//! # What is NOT available, and was not added +//! +//! Part C of the Stage-2.5 brief asks for a pre-verdict numeric — the +//! `|tc.confidence − admitted|` margin the channel compares against `tol`. That +//! value is local to [`StyleStrategy::dissent_over`] and is not returned. +//! **It was not exposed for this measurement**, per the brief's own guardrail. +//! What IS naturally available is finer than the boolean and is measured here: +//! the elevation `RungLevel` (which watcher objected) and, on the cross-family +//! channel, the reported `Mechanism`. Four paired outcome surfaces in total, not +//! one. + +use std::collections::BTreeSet; + +use lance_graph_contract::cognitive_shader::RungLevel; +use lance_graph_contract::recipes::Mechanism; +use lance_graph_contract::thinking::ThinkingStyle; + +use super::StyleStrategy; +use crate::traits::PlanContext; + +/// The `k` budgets swept. Chosen to span the sampler's regimes: `k = 1` takes +/// only the stride's first element, `k = 8` is what every shipped call site and +/// every Stage-2 test uses. +const KS: [usize; 5] = [1, 2, 3, 4, 8]; + +/// The tolerances swept. `0.0` is "any movement at all counts"; `0.2` is well +/// past the largest single-kernel confidence step in the carved population. +const TOLS: [f32; 8] = [0.0, 0.001, 0.005, 0.01, 0.02, 0.05, 0.1, 0.2]; + +/// The rungs with a non-empty periphery. `Transcendent` excludes nothing, so it +/// has no watchers to filter and would contribute only tautological rows — +/// `no_periphery_no_dissent` already pins that separately. +const RUNGS: [RungLevel; 4] = [ + RungLevel::Surface, + RungLevel::Shallow, + RungLevel::Contextual, + RungLevel::Analogical, +]; + +/// One paired observation: the same configuration measured with the maturity +/// clause OFF and ON. +#[derive(Clone, Debug)] +struct Pair { + style: ThinkingStyle, + style_idx: usize, + rung: RungLevel, + k: usize, + tol: f32, + /// Sampled watcher recipe ids, same-family channel. + same_off: BTreeSet, + same_on: BTreeSet, + /// Sampled watcher recipe ids, cross-family channel. + cross_off: BTreeSet, + cross_on: BTreeSet, + /// Verdicts — the elevation target, which is strictly finer than fired/not. + v_same_off: Option, + v_same_on: Option, + v_cross_off: Option<(RungLevel, Mechanism)>, + v_cross_on: Option<(RungLevel, Mechanism)>, +} + +/// Set-comparison summary for one channel of one pair. +#[derive(Clone, Copy, Debug)] +struct SetDelta { + n_off: usize, + n_on: usize, + intersection: usize, + symmetric_difference: usize, + added: usize, + removed: usize, +} + +impl SetDelta { + fn of(off: &BTreeSet, on: &BTreeSet) -> Self { + let inter = off.intersection(on).count(); + Self { + n_off: off.len(), + n_on: on.len(), + intersection: inter, + symmetric_difference: off.symmetric_difference(on).count(), + added: on.difference(off).count(), + removed: off.difference(on).count(), + } + } + fn union(&self) -> usize { + self.n_off + self.n_on - self.intersection + } + /// Jaccard similarity `|A∩B| / |A∪B|`. Two EMPTY samples are defined as + /// identical (`1.0`) rather than `0/0`: "the filter changed nothing here" + /// is the true statement about a cell with no watchers on either side, and + /// scoring it `0` would report maximal change where none occurred. + fn jaccard(&self) -> f64 { + let u = self.union(); + if u == 0 { + 1.0 + } else { + self.intersection as f64 / u as f64 + } + } + fn jaccard_distance(&self) -> f64 { + 1.0 - self.jaccard() + } + /// Fraction of the OFF sample that survived into ON. + fn retention(&self) -> f64 { + if self.n_off == 0 { + 1.0 + } else { + self.intersection as f64 / self.n_off as f64 + } + } +} + +/// Enumerate the full paired census. Deterministic; no I/O. +fn census() -> Vec { + let ctx = probe_ctx(); + let mut out = + Vec::with_capacity(ThinkingStyle::ALL.len() * RUNGS.len() * KS.len() * TOLS.len()); + for (style_idx, &style) in ThinkingStyle::ALL.iter().enumerate() { + let want = StyleStrategy::cluster_mechanism(style.cluster()); + for rung in RUNGS { + for k in KS { + // The four samples depend only on (rung, want, k) — hoisted out + // of the tol loop so the census cannot accidentally measure + // sampler nondeterminism it does not have. + let ids = |same: bool, maturity: bool| -> BTreeSet { + rung.peripheral_sample_where(k, |r| { + (r.mechanism == want) == same + && (!maturity || StyleStrategy::watcher_can_dissent(r.id)) + }) + .map(|r| r.id) + .collect() + }; + let same_off = ids(true, false); + let same_on = ids(true, true); + let cross_off = ids(false, false); + let cross_on = ids(false, true); + + for tol in TOLS { + let admitted = StyleStrategy::reliability_at(style, &ctx, rung); + let run = |set: &BTreeSet| { + StyleStrategy::dissent_over( + style, + &ctx, + rung, + tol, + admitted, + recipes_by_id(set), + ) + }; + out.push(Pair { + style, + style_idx, + rung, + k, + tol, + v_same_off: run(&same_off).map(|w| w.min_rung()), + v_same_on: run(&same_on).map(|w| w.min_rung()), + v_cross_off: run(&cross_off).map(|w| (w.min_rung(), w.mechanism)), + v_cross_on: run(&cross_on).map(|w| (w.min_rung(), w.mechanism)), + same_off: same_off.clone(), + same_on: same_on.clone(), + cross_off: cross_off.clone(), + cross_on: cross_on.clone(), + }); + } + } + } + } + out +} + +/// Resolve ids back to recipes in the sampler's own ascending-id order. +/// +/// The channels iterate their sample in whatever order `peripheral_sample_where` +/// yields, which for a stride over an ascending list IS ascending; a `BTreeSet` +/// preserves that, so the census feeds `dissent_over` the same order production +/// does. (Order matters: the body returns the FIRST objector.) +fn recipes_by_id(ids: &BTreeSet) -> Vec<&'static lance_graph_contract::recipes::Recipe> { + ids.iter() + .filter_map(|&id| { + lance_graph_contract::recipes::RECIPES + .iter() + .find(|r| r.id == id) + }) + .collect() +} + +/// The probe context. ONE fixed context for the whole census: the experiment +/// varies the FILTER, and holding everything else constant is what makes the +/// pairs paired. +/// +/// The same shape the Stage-2 dissent tests use (`ctx_with(style_vec(0.9, 0, +/// 0))` — an analytical-dominant 23-D style vector). Built here rather than +/// reached for across the test module boundary, so the census does not depend +/// on a test helper's visibility. +fn probe_ctx() -> PlanContext { + let mut style = vec![0.0; 23]; + style[4] = 0.9; // analytical + PlanContext { + query: "MATCH (n:Person) RETURN n".into(), + features: crate::traits::QueryFeatures::default(), + free_will_modifier: 0.7, + thinking_style: Some(style), + nars_hint: None, + witness: None, + } +} + +// ── statistics ─────────────────────────────────────────────────────────────── + +/// One-sided exact (Clopper-Pearson) upper limit on the event probability when +/// **zero** events were observed in `n` trials. +/// +/// At `k = 0` the general Clopper-Pearson limit collapses to a closed form: +/// the upper limit `p_u` solves `P(X = 0 | p_u) = (1 − p_u)^n = α`, hence +/// `p_u = 1 − α^(1/n)`. No incomplete-beta evaluation is needed, which is why +/// this is three lines here rather than a gap in `jc::stats` (JC carries no +/// binomial interval, and adding one for a degenerate case is not the job). +fn zero_event_upper_bound(n: usize, alpha: f64) -> f64 { + if n == 0 { + return 1.0; + } + 1.0 - alpha.powf(1.0 / n as f64) +} + +/// Group a value column by an integer stratum key, for `jc::stats::eta_squared`. +fn group_by(keys: &[usize], values: &[f64]) -> Vec> { + let n_groups = keys.iter().copied().max().map_or(0, |m| m + 1); + let mut groups = vec![Vec::new(); n_groups]; + for (&kk, &v) in keys.iter().zip(values) { + groups[kk].push(v); + } + groups.retain(|g| !g.is_empty()); + groups +} + +// ── the report ─────────────────────────────────────────────────────────────── + +struct ChannelStats { + label: &'static str, + deltas: Vec, + jaccard_distance: Vec, + fired_off: Vec, + fired_on: Vec, + /// Elevation target as a nominal label (`0` = no dissent, else `rung + 1`). + label_off: Vec, + label_on: Vec, +} + +fn channel_stats(pairs: &[Pair], same_family: bool) -> ChannelStats { + let mut cs = ChannelStats { + label: if same_family { + "same-family (peripheral_dissent)" + } else { + "cross-family (cross_family_dissent)" + }, + deltas: Vec::new(), + jaccard_distance: Vec::new(), + fired_off: Vec::new(), + fired_on: Vec::new(), + label_off: Vec::new(), + label_on: Vec::new(), + }; + for p in pairs { + let (off, on) = if same_family { + (&p.same_off, &p.same_on) + } else { + (&p.cross_off, &p.cross_on) + }; + let d = SetDelta::of(off, on); + cs.jaccard_distance.push(d.jaccard_distance()); + cs.deltas.push(d); + let (vo, vn): (Option, Option) = if same_family { + ( + p.v_same_off.map(|r| r as usize + 1), + p.v_same_on.map(|r| r as usize + 1), + ) + } else { + ( + p.v_cross_off.map(cross_label), + p.v_cross_on.map(cross_label), + ) + }; + cs.fired_off.push(vo.is_some()); + cs.fired_on.push(vn.is_some()); + cs.label_off.push(vo.unwrap_or(0)); + cs.label_on.push(vn.unwrap_or(0)); + } + cs +} + +/// Encode a cross-family verdict as ONE nominal label carrying **both** tuple +/// components. +/// +/// The production verdict is `(RungLevel, Mechanism)`, and reducing it to the +/// rung would call a pair concordant whenever the filter swapped the first +/// objector for one of a DIFFERENT mechanism at the SAME `min_rung` — silently +/// supporting the report's claim that the reported mechanism agrees, using a +/// measurement that never looked at it. (Codex review, PR #971.) +/// +/// `0` stays reserved for "no dissent", so the encoding starts at 1. +fn cross_label((rung, mech): (RungLevel, Mechanism)) -> usize { + const N_MECH: usize = 4; // ParallelIndependence | TruthAware | StructuralDivergence | Infrastructure + let m = match mech { + Mechanism::ParallelIndependence => 0, + Mechanism::TruthAwareInference => 1, + Mechanism::StructuralDivergence => 2, + Mechanism::Infrastructure => 3, + }; + 1 + (rung as usize) * N_MECH + m +} + +fn mean(xs: &[f64]) -> f64 { + if xs.is_empty() { + 0.0 + } else { + xs.iter().sum::() / xs.len() as f64 + } +} + +#[cfg(test)] +mod tests { + use super::*; + use jc::reliability::spearman; + use jc::stats::{binary_association, cohen_kappa, eta_squared, multiple_r_squared}; + + /// The census is the size the design says it is. A silently-shrunk + /// enumeration would make every number below look better than it is. + #[test] + fn stage25_census_covers_the_full_design() { + let pairs = census(); + assert_eq!( + pairs.len(), + ThinkingStyle::ALL.len() * RUNGS.len() * KS.len() * TOLS.len() + ); + assert_eq!(pairs.len(), 5760, "the design is 36 x 4 x 5 x 8"); + } + + /// **The headline, re-pinned — and the re-pin is the finding.** + /// + /// The first version of this test asserted `discordant == 0` on both + /// channels, and it passed, because the predicate it was measuring was + /// wrong: `watcher_can_dissent` filtered on `maturity().is_production()`, + /// which admits 31 of 34 kernels while only **14** can move `delta_conf` — + /// the only quantity either channel compares. The filter was excluding 3 + /// mute watchers and admitting 17 more (codex review, PR #971). + /// + /// With the honest predicate the answer inverts: the filter changes **1,098 + /// of 5,760** same-family verdicts and **384** cross-family. Pinned as + /// EQUALITIES, not bounds — this is a deterministic census, so any movement + /// is a real behavioural change that deserves a deliberate re-measure + /// rather than a widened assertion. + #[test] + fn stage25_headline_watcher_delta_and_verdict_delta_are_both_real() { + let pairs = census(); + for (same_family, expect_changed, expect_discordant) in + [(true, 4080usize, 1098usize), (false, 4224, 384)] + { + let cs = channel_stats(&pairs, same_family); + let changed = cs + .deltas + .iter() + .filter(|d| d.symmetric_difference > 0) + .count(); + let discordant = cs + .label_off + .iter() + .zip(&cs.label_on) + .filter(|(a, b)| a != b) + .count(); + assert_eq!( + changed, expect_changed, + "{}: watcher-sample delta", + cs.label + ); + assert_eq!( + discordant, + expect_discordant, + "{}: verdict delta over {} pairs", + cs.label, + pairs.len() + ); + } + } + + /// **The filter's effect has a DIRECTION, and on the same-family channel it + /// is one-way.** + /// + /// `n10 == 0` there: no configuration that dissented with the filter OFF + /// goes silent with it ON. That is the coverage argument turned into a + /// measurement — replacing structurally-mute watchers with capable ones can + /// only ADD objections, never remove them, because the removed watchers + /// could not have raised one. + /// + /// The cross-family channel is *almost* one-way: 18 of 5,760 go the other + /// way, and the reason is the SAMPLER, not the filter. + /// `peripheral_sample_where` strides `k` picks over the eligible list, so + /// shrinking that list changes WHICH capable watchers are picked — a + /// capable dissenter selected under OFF can fall off the stride under ON. + /// Pinned exactly so it stays visible instead of being rounded to "one-way". + #[test] + fn stage25_the_filter_adds_dissent_and_on_one_channel_never_removes_it() { + let pairs = census(); + let same = binary_association( + &channel_stats(&pairs, true).fired_off, + &channel_stats(&pairs, true).fired_on, + ) + .expect("columns"); + assert_eq!( + same.n10, 0, + "same-family: {} configurations LOST a dissent — the filter is \ + supposed to be unable to remove one", + same.n10 + ); + assert_eq!(same.n01, 1098, "same-family: dissents gained"); + + let cross = binary_association( + &channel_stats(&pairs, false).fired_off, + &channel_stats(&pairs, false).fired_on, + ) + .expect("columns"); + assert_eq!(cross.n01, 366, "cross-family: dissents gained"); + assert_eq!( + cross.n10, 18, + "cross-family: dissents lost to the sampler stride" + ); + assert!( + cross.n01 > cross.n10, + "the net direction must still be toward MORE dissent" + ); + } + + /// Agreement is now **partial and measured**, not perfect — and κ is + /// defined in every case, so the numbers are real rather than the + /// degenerate constant-column case `jc::stats::cohen_kappa` refuses to + /// score. + /// + /// Re-pinned from `κ == 1.0` when the watcher predicate was corrected. The + /// old assertion was true of a measurement of the wrong thing. + #[test] + fn stage25_agreement_is_partial_and_kappa_is_defined() { + let pairs = census(); + for (same_family, lo, hi) in [(true, 0.60, 0.75), (false, 0.78, 0.92)] { + let cs = channel_stats(&pairs, same_family); + let t = binary_association(&cs.fired_off, &cs.fired_on).expect("columns"); + assert!( + t.n11 > 0 && t.n00 > 0, + "{}: both outcomes must occur or agreement is vacuous", + cs.label + ); + let k = t + .kappa + .expect("kappa is defined when both categories occur"); + assert!( + (lo..=hi).contains(&k), + "{}: kappa {k:.4} outside the pinned window [{lo}, {hi}]", + cs.label + ); + assert!( + k < 1.0, + "{}: kappa 1.0 would mean the filter changed nothing", + cs.label + ); + + // The FINE label (elevation target, and for cross-family the + // Mechanism too) must also be scoreable — a `None` here would mean + // one column collapsed to a single category and the discordance + // counts above were measured against a constant. + let k_fine = cohen_kappa(&cs.label_off, &cs.label_on) + .expect("kappa defined on the fine label too"); + assert!(k_fine < 1.0, "{}: fine kappa = {k_fine}", cs.label); + } + } + + /// The zero-event bound is the exact Clopper-Pearson limit and is + /// monotone in `n` — pinned so the ladder in the report cannot be read + /// upside down. + #[test] + fn stage25_zero_event_bound_is_exact_and_monotone() { + // (1 - p)^n = alpha => p = 1 - alpha^(1/n) + let p = zero_event_upper_bound(5760, 0.05); + assert!( + ((1.0 - p).powi(5760) - 0.05).abs() < 1e-9, + "not the exact limit: {p}" + ); + assert!( + zero_event_upper_bound(36, 0.05) > zero_event_upper_bound(5760, 0.05), + "fewer independent units must give a WEAKER (larger) bound" + ); + assert_eq!( + zero_event_upper_bound(0, 0.05), + 1.0, + "no trials bound nothing" + ); + } + + /// **Write the artifacts.** Ignored by default — it is a report generator, + /// not a gate; the gates are the three tests above. + /// + /// `cargo test -p lance-graph-planner --lib stage25_census -- --ignored --nocapture` + #[test] + #[ignore = "artifact generator; run explicitly"] + fn stage25_write_artifacts() { + let pairs = census(); + let dir = concat!(env!("CARGO_MANIFEST_DIR"), "/../../docs/probes"); + std::fs::create_dir_all(dir).expect("create docs/probes"); + + // ── machine-readable, and actually compact ── + // + // Two files, split along the census's own structure rather than dumped + // as one row-per-cell table (that was 11,520 rows / ~1 MB, and 7 of + // every 8 rows were byte-identical in every column that varies). + // + // A-surface: collapsed over `tol`. **Lossless** — the sampled watcher + // set depends only on `(rung, want, k)`, pinned by + // `stage25_tolerance_cannot_move_the_watcher_sample`, so the eight + // tolerance rows of a cell carry one observation between them. + let mut csv = String::from( + "style_idx,style,cluster,rung,k,channel,n_off,n_on,count_delta,intersection,\ + sym_diff,added,removed,jaccard,jaccard_distance,retention,ids_off,ids_on\n", + ); + let mut seen: Vec<(usize, RungLevel, usize)> = Vec::new(); + for p in &pairs { + let key = (p.style_idx, p.rung, p.k); + if seen.contains(&key) { + continue; + } + seen.push(key); + for same_family in [true, false] { + let (off, on) = if same_family { + (&p.same_off, &p.same_on) + } else { + (&p.cross_off, &p.cross_on) + }; + let d = SetDelta::of(off, on); + let ids = |set: &BTreeSet| { + set.iter().map(u8::to_string).collect::>().join(" ") + }; + csv.push_str(&format!( + "{},{:?},{:?},{:?},{},{},{},{},{},{},{},{},{},{:.6},{:.6},{:.6},{},{}\n", + p.style_idx, + p.style, + p.style.cluster(), + p.rung, + p.k, + if same_family { "same" } else { "cross" }, + d.n_off, + d.n_on, + d.n_on as i64 - d.n_off as i64, + d.intersection, + d.symmetric_difference, + d.added, + d.removed, + d.jaccard(), + d.jaccard_distance(), + d.retention(), + ids(off), + ids(on), + )); + } + } + std::fs::write(format!("{dir}/stage25-consumer-filter-census.csv"), csv) + .expect("write census csv"); + + // B-surface: ONE row per DISCORDANT pair. Empty (header only) is the + // result, not a missing file — and it is the shape that stays useful if + // a future run does flip something, where a 11,520-row all-concordant + // dump would bury the one row that mattered. + let mut disc = String::from("style_idx,style,rung,k,tol,channel,verdict_off,verdict_on\n"); + for p in &pairs { + for same_family in [true, false] { + let (vo, vn) = if same_family { + ( + p.v_same_off.map(|r| r as usize + 1).unwrap_or(0), + p.v_same_on.map(|r| r as usize + 1).unwrap_or(0), + ) + } else { + // Same `cross_label` the statistics use — the artifact and + // the numbers must not disagree about what "changed" means. + ( + p.v_cross_off.map(cross_label).unwrap_or(0), + p.v_cross_on.map(cross_label).unwrap_or(0), + ) + }; + if vo != vn { + disc.push_str(&format!( + "{},{:?},{:?},{},{},{},{vo},{vn}\n", + p.style_idx, + p.style, + p.rung, + p.k, + p.tol, + if same_family { "same" } else { "cross" }, + )); + } + } + } + std::fs::write( + format!("{dir}/stage25-consumer-filter-verdict-discordance.csv"), + disc, + ) + .expect("write discordance csv"); + + std::fs::write( + format!("{dir}/stage25-consumer-filter-census.md"), + render_report(&pairs), + ) + .expect("write census report"); + } + + fn render_report(pairs: &[Pair]) -> String { + let n = pairs.len(); + let mut r = String::new(); + r.push_str("# Stage 2.5 — consumer-filter census\n\n"); + r.push_str( + "> Generated by `strategy::stage25_census::tests::stage25_write_artifacts`\n\ + > (`cargo test -p lance-graph-planner --lib stage25_census -- --ignored`).\n\ + > Data: `stage25-consumer-filter-census.csv` (watcher-sample surface, one row\n\ + > per style x rung x k x channel — collapsed over `tol`, losslessly, per the\n\ + > pinned invariant that the sample cannot depend on it) and\n\ + > `stage25-consumer-filter-verdict-discordance.csv` (one row per verdict flip).\n\n", + ); + r.push_str(&format!( + "**Design.** {} paired configurations = {} styles x {} rungs x {} budgets x {} \ + tolerances. Each pair holds everything fixed and toggles ONE thing: whether the \ + dissent channels' eligibility predicate carries the maturity clause. Both arms then \ + run the same shipped verdict body (`StyleStrategy::dissent_over`) — nothing here \ + reimplements the channel.\n\n", + n, + ThinkingStyle::ALL.len(), + RUNGS.len(), + KS.len(), + TOLS.len() + )); + r.push_str( + "**Statistics.** `jc::stats` / `jc::reliability`. The census is exhaustive and \ + deterministic, so no inferential test is run over it — there is no sampling \ + distribution for a p-value to describe. What is reported is cross-tabulation \ + (`binary_association`, carrying kappa and the marginals), variance decomposition \ + (`eta_squared`, `multiple_r_squared`), rank association (`spearman`), and ONE \ + genuinely inferential quantity: the exact one-sided binomial bound on an unseen \ + flip rate.\n\n", + ); + + // ── A. watcher-sample effect ── + r.push_str("## A. Watcher-sample effect\n\n"); + r.push_str( + "| channel | pairs changed | mean Jaccard dist | mean retention | \ + mean \\|Δcount\\| | max sym-diff |\n", + ); + r.push_str("|---|---|---|---|---|---|\n"); + for same_family in [true, false] { + let cs = channel_stats(pairs, same_family); + let changed = cs + .deltas + .iter() + .filter(|d| d.symmetric_difference > 0) + .count(); + let mean_abs_dcount = mean( + &cs.deltas + .iter() + .map(|d| (d.n_on as f64 - d.n_off as f64).abs()) + .collect::>(), + ); + let max_sd = cs + .deltas + .iter() + .map(|d| d.symmetric_difference) + .max() + .unwrap_or(0); + r.push_str(&format!( + "| {} | {changed} / {n} ({:.1}%) | {:.4} | {:.4} | {:.3} | {max_sd} |\n", + cs.label, + 100.0 * changed as f64 / n as f64, + mean(&cs.jaccard_distance), + mean( + &cs.deltas + .iter() + .map(SetDelta::retention) + .collect::>() + ), + mean_abs_dcount, + )); + } + + // ── D. stratification ── + r.push_str( + "\n## D. Stratification of the watcher-sample effect (descriptive eta-squared)\n\n", + ); + r.push_str( + "Proportion of the Jaccard-distance variance attributable to each factor, over the \ + exhaustive design. **Descriptive, not inferential** — a variance decomposition of a \ + census, never a test of a hypothesis about a population.\n\n", + ); + r.push_str("| channel | style | rung | k | tol | joint R² (rung,k,tol,style) |\n"); + r.push_str("|---|---|---|---|---|---|\n"); + for same_family in [true, false] { + let cs = channel_stats(pairs, same_family); + let y = &cs.jaccard_distance; + let e = |keys: Vec| -> String { + eta_squared(&group_by(&keys, y)).map_or("n/a".into(), |v| format!("{v:.4}")) + }; + let style_k: Vec = pairs.iter().map(|p| p.style_idx).collect(); + let rung_k: Vec = pairs.iter().map(|p| p.rung as usize).collect(); + let k_k: Vec = pairs + .iter() + .map(|p| KS.iter().position(|&x| x == p.k).unwrap()) + .collect(); + let tol_k: Vec = pairs + .iter() + .map(|p| TOLS.iter().position(|&x| x == p.tol).unwrap()) + .collect(); + let preds: Vec> = vec![ + rung_k.iter().map(|&v| v as f64).collect(), + k_k.iter().map(|&v| v as f64).collect(), + tol_k.iter().map(|&v| v as f64).collect(), + style_k.iter().map(|&v| v as f64).collect(), + ]; + let joint = multiple_r_squared(y, &preds).map_or("n/a".into(), |v| format!("{v:.4}")); + r.push_str(&format!( + "| {} | {} | {} | {} | {} | {joint} |\n", + cs.label, + e(style_k), + e(rung_k), + e(k_k), + e(tol_k) + )); + } + r.push_str( + "\n`tol` is **exactly** 0.0000 in both rows, and that is structural rather than a \ + finding about tolerance: the sampled watcher set depends only on `(rung, want, k)`, \ + so the tolerance cannot move it. It is reported because a NON-zero value there would \ + mean the census had accidentally coupled the two, and `stage25_tolerance_cannot_\ + move_the_watcher_sample` pins it.\n\n\ + The joint `R²` column is **not comparable to the eta-squared columns** and is \ + routinely SMALLER than the largest of them. `multiple_r_squared` fits the factors as \ + LINEAR predictors over their integer codes, while eta-squared groups them \ + nominally; a factor whose effect is non-monotone in its code (style, most \ + obviously — the code is an enum position, not a quantity) is largely invisible to \ + the linear fit. Read the joint figure as \"how much a linear read of the design \ + explains\", never as a ceiling on the design's total effect.\n\n\ + Strongest and weakest strata by mean Jaccard distance:\n\n", + ); + for same_family in [true, false] { + let cs = channel_stats(pairs, same_family); + let mut by_cell: Vec<((RungLevel, usize), Vec)> = Vec::new(); + for (p, d) in pairs.iter().zip(&cs.jaccard_distance) { + let key = (p.rung, p.k); + match by_cell.iter_mut().find(|(kk, _)| *kk == key) { + Some((_, v)) => v.push(*d), + None => by_cell.push((key, vec![*d])), + } + } + let mut rows: Vec<((RungLevel, usize), f64)> = + by_cell.into_iter().map(|(k, v)| (k, mean(&v))).collect(); + rows.sort_by(|a, b| b.1.partial_cmp(&a.1).unwrap_or(std::cmp::Ordering::Equal)); + let top = &rows[..rows.len().min(3)]; + let bot = &rows[rows.len().saturating_sub(3)..]; + r.push_str(&format!("- **{}**\n", cs.label)); + for (label, set) in [("strongest", top), ("weakest", bot)] { + let listed: Vec = set + .iter() + .map(|((rg, k), v)| format!("{rg:?}/k={k}: {v:.4}")) + .collect(); + r.push_str(&format!(" - {label}: {}\n", listed.join(" · "))); + } + } + r.push_str("\nRank association between the budget `k` and the Jaccard distance:\n\n"); + for same_family in [true, false] { + let cs = channel_stats(pairs, same_family); + let kf: Vec = pairs.iter().map(|p| p.k as f64).collect(); + let rho = + spearman(&kf, &cs.jaccard_distance).map_or("n/a".into(), |v| format!("{v:+.4}")); + r.push_str(&format!("- {}: Spearman rho = {rho}\n", cs.label)); + } + + // ── B. verdict effect ── + r.push_str("\n## B. Verdict effect\n\n"); + for same_family in [true, false] { + let cs = channel_stats(pairs, same_family); + let t = binary_association(&cs.fired_off, &cs.fired_on).expect("columns"); + let discordant = cs + .label_off + .iter() + .zip(&cs.label_on) + .filter(|(a, b)| a != b) + .count(); + r.push_str(&format!("### {}\n\n", cs.label)); + r.push_str("OFF → ON transition matrix (fired / did not fire):\n\n"); + r.push_str("| | ON: silent | ON: fired |\n|---|---|---|\n"); + r.push_str(&format!("| **OFF: silent** | {} | {} |\n", t.n00, t.n01)); + r.push_str(&format!("| **OFF: fired** | {} | {} |\n\n", t.n10, t.n11)); + r.push_str(&format!( + "- concordant {} / {n}, discordant **{}** / {n}\n", + n - discordant, + discordant + )); + r.push_str(&format!( + "- observed verdict-change rate: **{:.6}**\n", + discordant as f64 / n as f64 + )); + r.push_str(&format!( + "- Cohen's kappa = {} (defined: both categories occur, n11={} n00={})\n", + t.kappa.map_or("undefined".into(), |k| format!("{k:.6}")), + t.n11, + t.n00 + )); + r.push_str(&format!( + "- fired {} -> {} on this channel\n", + t.n10 + t.n11, + t.n01 + t.n11 + )); + r.push_str(&format!( + "- **direction**: {} silence -> dissent, {} dissent -> silence\n", + t.n01, t.n10 + )); + r.push_str( + "- **McNemar is NOT computed.** `jc` carries no implementation, and hand-rolling \ + a test statistic into an exhaustive deterministic census — which has no \ + sampling distribution for its p-value to describe — is the failure this report \ + exists to avoid. The transition matrix above carries the same information \ + without the borrowed authority.\n\n", + ); + } + + // ── the bound ── + r.push_str("### Exact bound on the one surface that IS still zero\n\n"); + r.push_str( + "The verdict surface has events now, so a zero-event bound no longer applies to it. \ + What remains exactly zero is the DIRECTION on the same-family channel: **no \ + configuration lost a dissent** (`n10 = 0` of 5,760). That is the coverage claim in \ + its sharpest form — a filter that removes only structurally-mute watchers should be \ + incapable of removing an objection — so that is the quantity worth bounding.\n\n\ + One-sided Clopper-Pearson upper limit at zero observed events, `1 - alpha^(1/n)`, \ + with **alpha = 0.05** (a 95 % one-sided confidence level). **The 5,760 rows are \ + repeated measures, not independent trials** — one style contributes 160 of them — so \ + the bound is a LADDER over clustering assumptions and each row names the unit it \ + assumes; quote the one whose independence you are willing to defend.\n\n", + ); + r.push_str("| independent unit | n | upper bound on flip rate |\n|---|---|---|\n"); + // `StyleCluster` is not `Ord`, so count distinct by linear scan rather + // than reaching for a set — 36 styles, and a derive added for a report + // would be production surface bent to an instrument. + let mut seen = Vec::new(); + for st in ThinkingStyle::ALL { + let c = st.cluster(); + if !seen.contains(&c) { + seen.push(c); + } + } + let n_clusters = seen.len(); + for (label, m) in [ + ( + "one (style, rung, k, tol) cell — every cell its own trial; OPTIMISTIC", + n, + ), + ( + "one (style, rung) cell — k and tol treated as within-cell repeats", + ThinkingStyle::ALL.len() * RUNGS.len(), + ), + ( + "one style — a style's whole 160-cell block as one observation", + ThinkingStyle::ALL.len(), + ), + ( + "one style cluster — styles in a cluster share a Mechanism; most conservative", + n_clusters, + ), + ] { + r.push_str(&format!( + "| {label} | {m} | {:.3e} |\n", + zero_event_upper_bound(m, 0.05) + )); + } + + // ── C. latent effect ── + r.push_str("\n## C. Pre-verdict numeric\n\n"); + r.push_str( + "The margin the channel actually thresholds — `|tc.confidence - admitted|` against \ + `tol` — is local to `dissent_over` and is not returned. **It was not exposed for \ + this measurement.** What IS naturally available is finer than fired/not-fired and is \ + what the numbers above are computed over: the elevation `RungLevel` (which watcher \ + objected) and, on the cross-family channel, the reported `Mechanism` — both encoded \ + into ONE nominal label by `cross_label`, so a swap to a different mechanism at the \ + same rung counts as a change rather than passing as agreement.\n\n\ + That encoding is a correction, not a flourish. The first version of this census \ + reduced the cross-family verdict to its rung and would have reported such a swap as \ + concordant while the report claimed the mechanism agreed — a measurement that never \ + looked at the thing it certified.\n\n", + ); + + // ── headline ── + // + // Reported PER CHANNEL, not pooled. Pooling put the mean at 0.1932 and + // produced the single word "weakly" for two channels that differ by a + // factor of two — a threshold artifact, and exactly the kind of + // smoothing this census exists to avoid. The rule is stated so the word + // is checkable rather than editorial: >= 0.20 mean Jaccard distance + // over the design, or >= a third of configurations changed, is + // "materially"; any non-zero effect below that is "weakly". + r.push_str("## Headline\n\n"); + for same_family in [true, false] { + let cs = channel_stats(pairs, same_family); + let changed = cs + .deltas + .iter() + .filter(|d| d.symmetric_difference > 0) + .count(); + let jd = mean(&cs.jaccard_distance); + let frac = changed as f64 / n as f64; + let strength = if jd >= 0.20 || frac >= 1.0 / 3.0 { + "materially" + } else if jd > 0.0 { + "weakly" + } else { + "not at all" + }; + // COMPUTED, never literal. The first version of this line wrote + // `Verdict change: 0/{n}` as a hardcoded string — so the report + // would have printed zero no matter what the census measured, and + // did, for one revision after the predicate was corrected. A report + // that states its conclusion instead of deriving it is not a + // measurement; `stage25_headline_watcher_delta_and_verdict_delta_are_both_real` + // is what caught it. + let t = binary_association(&cs.fired_off, &cs.fired_on).expect("columns"); + let discordant = cs + .label_off + .iter() + .zip(&cs.label_on) + .filter(|(a, b)| a != b) + .count(); + r.push_str(&format!( + "- **{}: consumer filtering {strength} changes watcher sampling** — \ + {changed}/{n} configurations differ ({:.1}%), mean Jaccard distance {jd:.4}, \ + mean retention {:.4}. **Verdict change: {discordant}/{n}**, direction \ + {} silence->dissent vs {} dissent->silence.\n", + cs.label, + 100.0 * frac, + mean( + &cs.deltas + .iter() + .map(SetDelta::retention) + .collect::>() + ), + t.n01, + t.n10, + )); + } + r.push('\n'); + r.push_str( + "\n**This headline replaces an earlier one that read `0/5,760` on both channels.** \ + That number was real but measured the wrong predicate: the first consumer filter \ + tested `maturity().is_production()`, which admits 31 of 34 kernels, while only 14 \ + can move `delta_conf` — the only quantity either channel compares. The filter was \ + removing 3 mute watchers and admitting 17 more, so it changed the sample and could \ + not change the answer. Corrected after codex review on PR #971.\n\n\ + Scope, stated so it is not over-read: this is a statement about the measured \ + Stage-2 surface only, under one fixed `PlanContext`. It says nothing about whether \ + the ADDED dissent is correct — only that the periphery now contains instruments \ + that can object, where before a majority of the sampled watchers structurally could \ + not.\n", + ); + r + } +} diff --git a/crates/lance-graph-planner/src/strategy/style_strategy.rs b/crates/lance-graph-planner/src/strategy/style_strategy.rs index e80cba355..a2d1ec4a2 100644 --- a/crates/lance-graph-planner/src/strategy/style_strategy.rs +++ b/crates/lance-graph-planner/src/strategy/style_strategy.rs @@ -132,23 +132,25 @@ impl StyleStrategy { // `k` budget, so the channel could report agreement without having run // a single relevant tactic — silence produced by the sampler, not by // the evidence. - for watcher in rung.peripheral_sample_where(k, |r| r.mechanism == want) { - let Some(kern) = kernel(watcher.id) else { - continue; - }; - let mut tc = Self::thought_ctx_from(ctx); - for r in Self::recipes_for_at(style, rung) { - if let Some(k2) = kernel(r.id) { - let _ = k2.run(&mut tc); - } - } - let _ = kern.run(&mut tc); - if (tc.confidence.clamp(0.0, 1.0) - admitted).abs() > tol { - // Elevate to where this watcher would have been legal anyway. - return Some(watcher.min_rung()); - } - } - None + // + // MATURITY is the second half of the same argument, and it was missing. + // A `Demonstration` kernel lands no effect by construction (enforced by + // `non_operational_kernels_land_no_effect` in the contract crate), so a + // watcher that is one CANNOT move `tc.confidence` and therefore cannot + // dissent — while still consuming a `k` slot and contributing its + // structural agreement to the verdict. That is the anti-eigenvalue + // failure inverted: a watchdog that can never bark reports the same + // silence as one with nothing to bark at, and only the first is a lie. + Self::dissent_over( + style, + ctx, + rung, + tol, + admitted, + rung.peripheral_sample_where(k, |r| Self::watcher_is_eligible(r, want, true)), + ) + // Elevate to where the objecting watcher would have been legal anyway. + .map(|watcher| watcher.min_rung()) } /// **Cross-family dissent** — the independence channel, deliberately NOT @@ -188,7 +190,41 @@ impl StyleStrategy { ) -> Option<(RungLevel, Mechanism)> { let admitted = Self::reliability_at(style, ctx, rung); let want = Self::cluster_mechanism(style.cluster()); - for watcher in rung.peripheral_sample_where(k, |r| r.mechanism != want) { + // Same maturity argument as `peripheral_dissent` — a watcher that + // cannot move the score is not an independent instrument, it is an + // empty slot wearing one. + Self::dissent_over( + style, + ctx, + rung, + tol, + admitted, + rung.peripheral_sample_where(k, |r| Self::watcher_is_eligible(r, want, false)), + ) + .map(|watcher| (watcher.min_rung(), watcher.mechanism)) + } + + /// The shared body of both dissent channels: run each watcher after the + /// style's admitted set and return the FIRST one whose result departs from + /// `admitted` by more than `tol`. `None` = the sampled periphery agrees. + /// + /// Takes the already-sampled watchers rather than the predicate that + /// selected them, and returns the objecting RECIPE rather than either + /// channel's return shape. Both choices are deliberate: the channels differ + /// only in which side of the mechanism partition they sample and in what + /// they report about the objector, so this is a pure extraction of the part + /// that is identical — and a caller holding a different sample (the + /// Stage-2.5 census) exercises the SHIPPED verdict body instead of a + /// reimplementation of it, without production growing a probe knob. + fn dissent_over( + style: ThinkingStyle, + ctx: &PlanContext, + rung: RungLevel, + tol: f32, + admitted: f32, + watchers: impl IntoIterator, + ) -> Option<&'static Recipe> { + for watcher in watchers { let Some(kern) = kernel(watcher.id) else { continue; }; @@ -200,12 +236,90 @@ impl StyleStrategy { } let _ = kern.run(&mut tc); if (tc.confidence.clamp(0.0, 1.0) - admitted).abs() > tol { - return Some((watcher.min_rung(), watcher.mechanism)); + return Some(watcher); } } None } + /// Can a watcher of this recipe id actually DISSENT? + /// + /// **The predicate is `moves_confidence()`, NOT `maturity().is_production()` + /// — and the difference is most of the population.** Both channels compare + /// `tc.confidence` against `admitted`, so the only thing that can produce a + /// dissent is a non-zero `delta_conf`. Measured over the 34 kernels: **31 + /// are `Operational` but only 14 can move `delta_conf`**, because + /// `Operational` means *mutates some `ThoughtCtx` field OR moves + /// confidence* — a disjunction. `Etd` and `Cas` are the sharp cases: both + /// were carved to production in this same arc, both rewrite `candidates`, + /// and both return `0.0` forever. Sampling one spends a `k` slot on an + /// observer that is structurally incapable of objecting. + /// + /// A maturity filter alone therefore **preserved the exact budget loss it + /// was introduced to remove** — it excluded 3 kernels and admitted 17 that + /// could not dissent either. Found by codex review on PR #971, against the + /// first version of this function. + /// + /// Checking maturity as well would be a guard that can never fire: + /// `moves_confidence` ⇒ `Operational` is pinned upstream by + /// `moves_confidence_is_strictly_stronger_than_production`, so the + /// capability subsumes the maturity. + /// + /// # KNOWN GAP: capability is not REACHABILITY (measured, Stage-3) + /// + /// `moves_confidence()` says a kernel can move `delta_conf` on SOME input. + /// It does not say the kernel can move it **in the context this planner + /// dispatches**, and at least one watcher is admitted that cannot. + /// + /// Measured (codex review, PR #971): `Mcp` (recipe 10) declares + /// `moves_confidence() == true` truthfully — its branch needs + /// `confidence > 0.7 && free_energy > 0.5`. But + /// [`thought_ctx_from`](Self::thought_ctx_from) starts at + /// `ThoughtCtx::new`'s `free_energy = 0.5`, and **exactly one** of the 34 + /// kernels writes that field at all (`Rte`, id 1), which only decays it. + /// Swept over all 36 styles × 5 rungs: `free_energy` never exceeds + /// **0.5**, and `Mcp` moves confidence in **0 of 180** cells. Sampling it + /// spends a `k` slot on a watcher that is guaranteed silent here. + /// + /// So this is the same lesson a third time — production → capability → + /// **reachability** — and it is deliberately NOT fixed in this predicate: + /// + /// 1. A reachability filter is close to circular for the budget argument. + /// Deciding whether watcher `W` can move the answer in context `C` + /// essentially requires evaluating `W` in `C`, which is what sampling it + /// already does. What it would genuinely buy is not a cheaper budget but + /// a refusal to count a *structural* silence as agreement — a change to + /// what dissent MEANS. + /// 2. That change is Stage-3's to make, alongside the other half of the + /// same question (the 17 Operational-but-confidence-mute kernels), and + /// it would move the Stage-2.5 baseline the operator has just frozen. + /// + /// Tracked: `TD-THOUGHTCTX-IS-A-LOSSY-PROJECTION`. + fn watcher_can_dissent(id: u8) -> bool { + kernel(id).is_some_and(|k| k.moves_confidence()) + } + + /// The eligibility predicate BOTH dissent channels sample against — + /// `same_family` picks which side of the mechanism partition is wanted. + /// + /// One named function rather than two closures on purpose: the falsifier + /// samples through THIS, so the property it proves is the property the + /// channels actually run. Two copies of one condition can drift, and a test + /// owning its own copy keeps passing while they do. + /// + /// **Measured scope, stated so it is not overclaimed.** Adding the maturity + /// clause visibly changes WHICH watchers are sampled — the eligible list + /// shrinks, so the stride moves — but across the full 5,760-cell sweep of + /// style × rung × `k` ∈ {1,2,3,4,8} × `tol` ∈ {0, .001, .005, .01, .02, + /// .05, .1, .2} it changed **no verdict** on either channel. It is a + /// COVERAGE fix — `k` slots now buy `k` instruments that can actually + /// disagree — not a behaviour change, and it is deliberately not claimed as + /// one. The channel itself is emphatically not inert: suppressing the + /// watcher run outright moves 4,830 of those same 5,760 cells. + fn watcher_is_eligible(r: &Recipe, want: Mechanism, same_family: bool) -> bool { + (r.mechanism == want) == same_family && Self::watcher_can_dissent(r.id) + } + /// Build the recipe substrate's [`ThoughtCtx`] from the available `PlanContext` /// markers. Today the planner exposes `free_will_modifier` (→ temperature) and the /// query feature richness (→ candidate seeds); richer markers (real sd / free-energy @@ -399,6 +513,16 @@ impl StyleStrategy { } } +/// Stage-2.5 census — measurement only, compiled out of every non-test build. +/// +/// A CHILD of this module rather than a sibling, deliberately: it must reach +/// `dissent_over` and `watcher_can_dissent` to run the shipped verdict body over +/// a differently-filtered sample, and widening those to `pub(crate)` for an +/// instrument would put a probe seam in production visibility. +#[cfg(test)] +#[path = "stage25_census.rs"] +mod stage25_census; + #[cfg(test)] mod tests { use super::*; @@ -653,6 +777,116 @@ mod tests { } } + /// **A watcher slot is never spent on an observer that cannot dissent.** + /// + /// A `Demonstration` kernel lands no effect by construction (the contract + /// crate's `non_operational_kernels_land_no_effect` enforces it), so + /// sampling one costs a `k` slot and returns structural agreement — the + /// anti-eigenvalue failure inverted. A watchdog that can never bark reports + /// the same silence as one with nothing to bark at, and only the first is + /// a lie. + /// + /// Sampled through [`StyleStrategy::watcher_is_eligible`] — the same + /// predicate both channels run — rather than a copy of the condition, so + /// this cannot pass against a spelling the channels no longer use. + /// + /// The anti-vacuity half is the load-bearing one: without it this asserts a + /// property that would hold on a periphery containing no silent kernels at + /// all, which is a fact about the population, not about the filter. + #[test] + fn a_watcher_slot_is_never_spent_on_a_kernel_that_cannot_dissent() { + let rungs = [ + RungLevel::Surface, + RungLevel::Shallow, + RungLevel::Contextual, + RungLevel::Analogical, + ]; + let mechs = [ + Mechanism::ParallelIndependence, + Mechanism::TruthAwareInference, + Mechanism::StructuralDivergence, + Mechanism::Infrastructure, + ]; + + let mut silent_without_the_clause = 0usize; + let mut sampled = 0usize; + for rung in rungs { + for want in mechs { + for same_family in [true, false] { + for k in [1usize, 2, 3, 4, 8] { + // The shipped predicate: nothing silent may survive it. + for r in rung.peripheral_sample_where(k, |r| { + StyleStrategy::watcher_is_eligible(r, want, same_family) + }) { + sampled += 1; + assert!( + StyleStrategy::watcher_can_dissent(r.id), + "{rung:?}/{want:?}/same={same_family}/k={k}: sampled \ + recipe {} which cannot dissent", + r.id + ); + } + // Anti-vacuity: the mechanism clause ALONE would have. + silent_without_the_clause += rung + .peripheral_sample_where(k, |r| (r.mechanism == want) == same_family) + .filter(|r| !StyleStrategy::watcher_can_dissent(r.id)) + .count(); + } + } + } + } + + assert!( + sampled > 0, + "the sweep sampled nothing — it measures nothing" + ); + assert!( + silent_without_the_clause > 0, + "no silent watcher was reachable without the maturity clause, so the \ + clause is free and this test proves nothing about it" + ); + } + + /// **...and the filter must not STARVE a channel.** Excluding the silent + /// watchers shrinks the eligible list; if that emptied a channel the + /// coverage fix above would have bought silence instead of instruments — + /// the very failure `eligible_watchers_are_not_starved_by_the_sampler` + /// exists to catch, reintroduced one clause later. + #[test] + fn the_maturity_clause_does_not_starve_a_channel() { + let rungs = [ + RungLevel::Surface, + RungLevel::Shallow, + RungLevel::Contextual, + RungLevel::Analogical, + ]; + for rung in rungs { + for want in [ + Mechanism::ParallelIndependence, + Mechanism::TruthAwareInference, + Mechanism::StructuralDivergence, + Mechanism::Infrastructure, + ] { + for same_family in [true, false] { + let any_eligible = rung + .peripheral_recipes() + .any(|r| StyleStrategy::watcher_is_eligible(r, want, same_family)); + let sampled = rung + .peripheral_sample_where(1, |r| { + StyleStrategy::watcher_is_eligible(r, want, same_family) + }) + .count(); + assert_eq!( + any_eligible, + sampled > 0, + "{rung:?}/{want:?}/same={same_family}: eligible={any_eligible} but \ + sampled {sampled} at k=1" + ); + } + } + } + } + /// **The two dissent channels must be able to DISAGREE.** Same-family /// dissent measures calibration; cross-family dissent measures /// independence. If no input can make one fire while the other stays diff --git a/docs/probes/stage25-consumer-filter-census.csv b/docs/probes/stage25-consumer-filter-census.csv new file mode 100644 index 000000000..a2c67c010 --- /dev/null +++ b/docs/probes/stage25-consumer-filter-census.csv @@ -0,0 +1,1441 @@ +style_idx,style,cluster,rung,k,channel,n_off,n_on,count_delta,intersection,sym_diff,added,removed,jaccard,jaccard_distance,retention,ids_off,ids_on +0,Logical,Analytical,Surface,1,same,1,1,0,1,0,0,0,1.000000,0.000000,1.000000,3,3 +0,Logical,Analytical,Surface,1,cross,1,1,0,1,0,0,0,1.000000,0.000000,1.000000,1,1 +0,Logical,Analytical,Surface,2,same,2,2,0,1,2,1,1,0.333333,0.666667,0.500000,3 11,3 10 +0,Logical,Analytical,Surface,2,cross,2,2,0,1,2,1,1,0.333333,0.666667,0.500000,1 22,1 30 +0,Logical,Analytical,Surface,3,same,3,3,0,2,2,1,1,0.500000,0.500000,0.666667,3 10 17,3 7 10 +0,Logical,Analytical,Surface,3,cross,3,3,0,1,4,2,2,0.200000,0.800000,0.333333,1 15 27,1 28 31 +0,Logical,Analytical,Surface,4,same,4,4,0,4,0,0,0,1.000000,0.000000,1.000000,3 7 10 11,3 7 10 11 +0,Logical,Analytical,Surface,4,cross,4,4,0,2,4,2,2,0.333333,0.666667,0.500000,1 13 22 29,1 13 28 30 +0,Logical,Analytical,Surface,8,same,6,5,-1,5,1,0,1,0.833333,0.166667,0.833333,3 7 10 11 17 21,3 7 10 11 21 +0,Logical,Analytical,Surface,8,cross,8,6,-2,3,8,3,5,0.272727,0.727273,0.375000,1 6 13 16 22 25 29 32,1 13 28 30 31 32 +0,Logical,Analytical,Shallow,1,same,1,1,0,1,0,0,0,1.000000,0.000000,1.000000,3,3 +0,Logical,Analytical,Shallow,1,cross,1,1,0,1,0,0,0,1.000000,0.000000,1.000000,1,1 +0,Logical,Analytical,Shallow,2,same,2,2,0,1,2,1,1,0.333333,0.666667,0.500000,3 11,3 10 +0,Logical,Analytical,Shallow,2,cross,2,2,0,1,2,1,1,0.333333,0.666667,0.500000,1 22,1 30 +0,Logical,Analytical,Shallow,3,same,3,3,0,2,2,1,1,0.500000,0.500000,0.666667,3 10 17,3 7 10 +0,Logical,Analytical,Shallow,3,cross,3,3,0,1,4,2,2,0.200000,0.800000,0.333333,1 15 27,1 28 31 +0,Logical,Analytical,Shallow,4,same,4,4,0,4,0,0,0,1.000000,0.000000,1.000000,3 7 10 11,3 7 10 11 +0,Logical,Analytical,Shallow,4,cross,4,4,0,2,4,2,2,0.333333,0.666667,0.500000,1 13 22 29,1 13 28 30 +0,Logical,Analytical,Shallow,8,same,6,5,-1,5,1,0,1,0.833333,0.166667,0.833333,3 7 10 11 17 21,3 7 10 11 21 +0,Logical,Analytical,Shallow,8,cross,8,6,-2,3,8,3,5,0.272727,0.727273,0.375000,1 6 13 16 22 25 29 32,1 13 28 30 31 32 +0,Logical,Analytical,Contextual,1,same,1,1,0,1,0,0,0,1.000000,0.000000,1.000000,3,3 +0,Logical,Analytical,Contextual,1,cross,1,1,0,1,0,0,0,1.000000,0.000000,1.000000,1,1 +0,Logical,Analytical,Contextual,2,same,2,2,0,1,2,1,1,0.333333,0.666667,0.500000,3 11,3 10 +0,Logical,Analytical,Contextual,2,cross,2,2,0,1,2,1,1,0.333333,0.666667,0.500000,1 18,1 28 +0,Logical,Analytical,Contextual,3,same,3,3,0,2,2,1,1,0.500000,0.500000,0.666667,3 10 17,3 7 10 +0,Logical,Analytical,Contextual,3,cross,3,3,0,2,2,1,1,0.500000,0.500000,0.666667,1 13 23,1 13 28 +0,Logical,Analytical,Contextual,4,same,4,4,0,4,0,0,0,1.000000,0.000000,1.000000,3 7 10 11,3 7 10 11 +0,Logical,Analytical,Contextual,4,cross,4,4,0,1,6,3,3,0.142857,0.857143,0.250000,1 9 18 29,1 13 28 30 +0,Logical,Analytical,Contextual,8,same,6,5,-1,5,1,0,1,0.833333,0.166667,0.833333,3 7 10 11 17 21,3 7 10 11 21 +0,Logical,Analytical,Contextual,8,cross,8,5,-3,2,9,3,6,0.181818,0.818182,0.250000,1 4 9 15 18 23 29 31,1 13 28 30 31 +0,Logical,Analytical,Analogical,1,same,1,1,0,1,0,0,0,1.000000,0.000000,1.000000,3,3 +0,Logical,Analytical,Analogical,1,cross,1,1,0,0,2,1,1,0.000000,1.000000,0.000000,4,13 +0,Logical,Analytical,Analogical,2,same,2,2,0,2,0,0,0,1.000000,0.000000,1.000000,3 7,3 7 +0,Logical,Analytical,Analogical,2,cross,2,2,0,0,4,2,2,0.000000,1.000000,0.000000,4 23,13 28 +0,Logical,Analytical,Analogical,3,same,2,2,0,2,0,0,0,1.000000,0.000000,1.000000,3 7,3 7 +0,Logical,Analytical,Analogical,3,cross,3,3,0,0,6,3,3,0.000000,1.000000,0.000000,4 9 23,13 28 31 +0,Logical,Analytical,Analogical,4,same,2,2,0,2,0,0,0,1.000000,0.000000,1.000000,3 7,3 7 +0,Logical,Analytical,Analogical,4,cross,4,3,-1,1,5,2,3,0.166667,0.833333,0.250000,4 9 23 31,13 28 31 +0,Logical,Analytical,Analogical,8,same,2,2,0,2,0,0,0,1.000000,0.000000,1.000000,3 7,3 7 +0,Logical,Analytical,Analogical,8,cross,8,3,-5,3,5,0,5,0.375000,0.625000,0.375000,4 6 9 13 23 28 31 34,13 28 31 +1,Analytical,Analytical,Surface,1,same,1,1,0,1,0,0,0,1.000000,0.000000,1.000000,3,3 +1,Analytical,Analytical,Surface,1,cross,1,1,0,1,0,0,0,1.000000,0.000000,1.000000,1,1 +1,Analytical,Analytical,Surface,2,same,2,2,0,1,2,1,1,0.333333,0.666667,0.500000,3 11,3 10 +1,Analytical,Analytical,Surface,2,cross,2,2,0,1,2,1,1,0.333333,0.666667,0.500000,1 22,1 30 +1,Analytical,Analytical,Surface,3,same,3,3,0,2,2,1,1,0.500000,0.500000,0.666667,3 10 17,3 7 10 +1,Analytical,Analytical,Surface,3,cross,3,3,0,1,4,2,2,0.200000,0.800000,0.333333,1 15 27,1 28 31 +1,Analytical,Analytical,Surface,4,same,4,4,0,4,0,0,0,1.000000,0.000000,1.000000,3 7 10 11,3 7 10 11 +1,Analytical,Analytical,Surface,4,cross,4,4,0,2,4,2,2,0.333333,0.666667,0.500000,1 13 22 29,1 13 28 30 +1,Analytical,Analytical,Surface,8,same,6,5,-1,5,1,0,1,0.833333,0.166667,0.833333,3 7 10 11 17 21,3 7 10 11 21 +1,Analytical,Analytical,Surface,8,cross,8,6,-2,3,8,3,5,0.272727,0.727273,0.375000,1 6 13 16 22 25 29 32,1 13 28 30 31 32 +1,Analytical,Analytical,Shallow,1,same,1,1,0,1,0,0,0,1.000000,0.000000,1.000000,3,3 +1,Analytical,Analytical,Shallow,1,cross,1,1,0,1,0,0,0,1.000000,0.000000,1.000000,1,1 +1,Analytical,Analytical,Shallow,2,same,2,2,0,1,2,1,1,0.333333,0.666667,0.500000,3 11,3 10 +1,Analytical,Analytical,Shallow,2,cross,2,2,0,1,2,1,1,0.333333,0.666667,0.500000,1 22,1 30 +1,Analytical,Analytical,Shallow,3,same,3,3,0,2,2,1,1,0.500000,0.500000,0.666667,3 10 17,3 7 10 +1,Analytical,Analytical,Shallow,3,cross,3,3,0,1,4,2,2,0.200000,0.800000,0.333333,1 15 27,1 28 31 +1,Analytical,Analytical,Shallow,4,same,4,4,0,4,0,0,0,1.000000,0.000000,1.000000,3 7 10 11,3 7 10 11 +1,Analytical,Analytical,Shallow,4,cross,4,4,0,2,4,2,2,0.333333,0.666667,0.500000,1 13 22 29,1 13 28 30 +1,Analytical,Analytical,Shallow,8,same,6,5,-1,5,1,0,1,0.833333,0.166667,0.833333,3 7 10 11 17 21,3 7 10 11 21 +1,Analytical,Analytical,Shallow,8,cross,8,6,-2,3,8,3,5,0.272727,0.727273,0.375000,1 6 13 16 22 25 29 32,1 13 28 30 31 32 +1,Analytical,Analytical,Contextual,1,same,1,1,0,1,0,0,0,1.000000,0.000000,1.000000,3,3 +1,Analytical,Analytical,Contextual,1,cross,1,1,0,1,0,0,0,1.000000,0.000000,1.000000,1,1 +1,Analytical,Analytical,Contextual,2,same,2,2,0,1,2,1,1,0.333333,0.666667,0.500000,3 11,3 10 +1,Analytical,Analytical,Contextual,2,cross,2,2,0,1,2,1,1,0.333333,0.666667,0.500000,1 18,1 28 +1,Analytical,Analytical,Contextual,3,same,3,3,0,2,2,1,1,0.500000,0.500000,0.666667,3 10 17,3 7 10 +1,Analytical,Analytical,Contextual,3,cross,3,3,0,2,2,1,1,0.500000,0.500000,0.666667,1 13 23,1 13 28 +1,Analytical,Analytical,Contextual,4,same,4,4,0,4,0,0,0,1.000000,0.000000,1.000000,3 7 10 11,3 7 10 11 +1,Analytical,Analytical,Contextual,4,cross,4,4,0,1,6,3,3,0.142857,0.857143,0.250000,1 9 18 29,1 13 28 30 +1,Analytical,Analytical,Contextual,8,same,6,5,-1,5,1,0,1,0.833333,0.166667,0.833333,3 7 10 11 17 21,3 7 10 11 21 +1,Analytical,Analytical,Contextual,8,cross,8,5,-3,2,9,3,6,0.181818,0.818182,0.250000,1 4 9 15 18 23 29 31,1 13 28 30 31 +1,Analytical,Analytical,Analogical,1,same,1,1,0,1,0,0,0,1.000000,0.000000,1.000000,3,3 +1,Analytical,Analytical,Analogical,1,cross,1,1,0,0,2,1,1,0.000000,1.000000,0.000000,4,13 +1,Analytical,Analytical,Analogical,2,same,2,2,0,2,0,0,0,1.000000,0.000000,1.000000,3 7,3 7 +1,Analytical,Analytical,Analogical,2,cross,2,2,0,0,4,2,2,0.000000,1.000000,0.000000,4 23,13 28 +1,Analytical,Analytical,Analogical,3,same,2,2,0,2,0,0,0,1.000000,0.000000,1.000000,3 7,3 7 +1,Analytical,Analytical,Analogical,3,cross,3,3,0,0,6,3,3,0.000000,1.000000,0.000000,4 9 23,13 28 31 +1,Analytical,Analytical,Analogical,4,same,2,2,0,2,0,0,0,1.000000,0.000000,1.000000,3 7,3 7 +1,Analytical,Analytical,Analogical,4,cross,4,3,-1,1,5,2,3,0.166667,0.833333,0.250000,4 9 23 31,13 28 31 +1,Analytical,Analytical,Analogical,8,same,2,2,0,2,0,0,0,1.000000,0.000000,1.000000,3 7,3 7 +1,Analytical,Analytical,Analogical,8,cross,8,3,-5,3,5,0,5,0.375000,0.625000,0.375000,4 6 9 13 23 28 31 34,13 28 31 +2,Critical,Analytical,Surface,1,same,1,1,0,1,0,0,0,1.000000,0.000000,1.000000,3,3 +2,Critical,Analytical,Surface,1,cross,1,1,0,1,0,0,0,1.000000,0.000000,1.000000,1,1 +2,Critical,Analytical,Surface,2,same,2,2,0,1,2,1,1,0.333333,0.666667,0.500000,3 11,3 10 +2,Critical,Analytical,Surface,2,cross,2,2,0,1,2,1,1,0.333333,0.666667,0.500000,1 22,1 30 +2,Critical,Analytical,Surface,3,same,3,3,0,2,2,1,1,0.500000,0.500000,0.666667,3 10 17,3 7 10 +2,Critical,Analytical,Surface,3,cross,3,3,0,1,4,2,2,0.200000,0.800000,0.333333,1 15 27,1 28 31 +2,Critical,Analytical,Surface,4,same,4,4,0,4,0,0,0,1.000000,0.000000,1.000000,3 7 10 11,3 7 10 11 +2,Critical,Analytical,Surface,4,cross,4,4,0,2,4,2,2,0.333333,0.666667,0.500000,1 13 22 29,1 13 28 30 +2,Critical,Analytical,Surface,8,same,6,5,-1,5,1,0,1,0.833333,0.166667,0.833333,3 7 10 11 17 21,3 7 10 11 21 +2,Critical,Analytical,Surface,8,cross,8,6,-2,3,8,3,5,0.272727,0.727273,0.375000,1 6 13 16 22 25 29 32,1 13 28 30 31 32 +2,Critical,Analytical,Shallow,1,same,1,1,0,1,0,0,0,1.000000,0.000000,1.000000,3,3 +2,Critical,Analytical,Shallow,1,cross,1,1,0,1,0,0,0,1.000000,0.000000,1.000000,1,1 +2,Critical,Analytical,Shallow,2,same,2,2,0,1,2,1,1,0.333333,0.666667,0.500000,3 11,3 10 +2,Critical,Analytical,Shallow,2,cross,2,2,0,1,2,1,1,0.333333,0.666667,0.500000,1 22,1 30 +2,Critical,Analytical,Shallow,3,same,3,3,0,2,2,1,1,0.500000,0.500000,0.666667,3 10 17,3 7 10 +2,Critical,Analytical,Shallow,3,cross,3,3,0,1,4,2,2,0.200000,0.800000,0.333333,1 15 27,1 28 31 +2,Critical,Analytical,Shallow,4,same,4,4,0,4,0,0,0,1.000000,0.000000,1.000000,3 7 10 11,3 7 10 11 +2,Critical,Analytical,Shallow,4,cross,4,4,0,2,4,2,2,0.333333,0.666667,0.500000,1 13 22 29,1 13 28 30 +2,Critical,Analytical,Shallow,8,same,6,5,-1,5,1,0,1,0.833333,0.166667,0.833333,3 7 10 11 17 21,3 7 10 11 21 +2,Critical,Analytical,Shallow,8,cross,8,6,-2,3,8,3,5,0.272727,0.727273,0.375000,1 6 13 16 22 25 29 32,1 13 28 30 31 32 +2,Critical,Analytical,Contextual,1,same,1,1,0,1,0,0,0,1.000000,0.000000,1.000000,3,3 +2,Critical,Analytical,Contextual,1,cross,1,1,0,1,0,0,0,1.000000,0.000000,1.000000,1,1 +2,Critical,Analytical,Contextual,2,same,2,2,0,1,2,1,1,0.333333,0.666667,0.500000,3 11,3 10 +2,Critical,Analytical,Contextual,2,cross,2,2,0,1,2,1,1,0.333333,0.666667,0.500000,1 18,1 28 +2,Critical,Analytical,Contextual,3,same,3,3,0,2,2,1,1,0.500000,0.500000,0.666667,3 10 17,3 7 10 +2,Critical,Analytical,Contextual,3,cross,3,3,0,2,2,1,1,0.500000,0.500000,0.666667,1 13 23,1 13 28 +2,Critical,Analytical,Contextual,4,same,4,4,0,4,0,0,0,1.000000,0.000000,1.000000,3 7 10 11,3 7 10 11 +2,Critical,Analytical,Contextual,4,cross,4,4,0,1,6,3,3,0.142857,0.857143,0.250000,1 9 18 29,1 13 28 30 +2,Critical,Analytical,Contextual,8,same,6,5,-1,5,1,0,1,0.833333,0.166667,0.833333,3 7 10 11 17 21,3 7 10 11 21 +2,Critical,Analytical,Contextual,8,cross,8,5,-3,2,9,3,6,0.181818,0.818182,0.250000,1 4 9 15 18 23 29 31,1 13 28 30 31 +2,Critical,Analytical,Analogical,1,same,1,1,0,1,0,0,0,1.000000,0.000000,1.000000,3,3 +2,Critical,Analytical,Analogical,1,cross,1,1,0,0,2,1,1,0.000000,1.000000,0.000000,4,13 +2,Critical,Analytical,Analogical,2,same,2,2,0,2,0,0,0,1.000000,0.000000,1.000000,3 7,3 7 +2,Critical,Analytical,Analogical,2,cross,2,2,0,0,4,2,2,0.000000,1.000000,0.000000,4 23,13 28 +2,Critical,Analytical,Analogical,3,same,2,2,0,2,0,0,0,1.000000,0.000000,1.000000,3 7,3 7 +2,Critical,Analytical,Analogical,3,cross,3,3,0,0,6,3,3,0.000000,1.000000,0.000000,4 9 23,13 28 31 +2,Critical,Analytical,Analogical,4,same,2,2,0,2,0,0,0,1.000000,0.000000,1.000000,3 7,3 7 +2,Critical,Analytical,Analogical,4,cross,4,3,-1,1,5,2,3,0.166667,0.833333,0.250000,4 9 23 31,13 28 31 +2,Critical,Analytical,Analogical,8,same,2,2,0,2,0,0,0,1.000000,0.000000,1.000000,3 7,3 7 +2,Critical,Analytical,Analogical,8,cross,8,3,-5,3,5,0,5,0.375000,0.625000,0.375000,4 6 9 13 23 28 31 34,13 28 31 +3,Systematic,Analytical,Surface,1,same,1,1,0,1,0,0,0,1.000000,0.000000,1.000000,3,3 +3,Systematic,Analytical,Surface,1,cross,1,1,0,1,0,0,0,1.000000,0.000000,1.000000,1,1 +3,Systematic,Analytical,Surface,2,same,2,2,0,1,2,1,1,0.333333,0.666667,0.500000,3 11,3 10 +3,Systematic,Analytical,Surface,2,cross,2,2,0,1,2,1,1,0.333333,0.666667,0.500000,1 22,1 30 +3,Systematic,Analytical,Surface,3,same,3,3,0,2,2,1,1,0.500000,0.500000,0.666667,3 10 17,3 7 10 +3,Systematic,Analytical,Surface,3,cross,3,3,0,1,4,2,2,0.200000,0.800000,0.333333,1 15 27,1 28 31 +3,Systematic,Analytical,Surface,4,same,4,4,0,4,0,0,0,1.000000,0.000000,1.000000,3 7 10 11,3 7 10 11 +3,Systematic,Analytical,Surface,4,cross,4,4,0,2,4,2,2,0.333333,0.666667,0.500000,1 13 22 29,1 13 28 30 +3,Systematic,Analytical,Surface,8,same,6,5,-1,5,1,0,1,0.833333,0.166667,0.833333,3 7 10 11 17 21,3 7 10 11 21 +3,Systematic,Analytical,Surface,8,cross,8,6,-2,3,8,3,5,0.272727,0.727273,0.375000,1 6 13 16 22 25 29 32,1 13 28 30 31 32 +3,Systematic,Analytical,Shallow,1,same,1,1,0,1,0,0,0,1.000000,0.000000,1.000000,3,3 +3,Systematic,Analytical,Shallow,1,cross,1,1,0,1,0,0,0,1.000000,0.000000,1.000000,1,1 +3,Systematic,Analytical,Shallow,2,same,2,2,0,1,2,1,1,0.333333,0.666667,0.500000,3 11,3 10 +3,Systematic,Analytical,Shallow,2,cross,2,2,0,1,2,1,1,0.333333,0.666667,0.500000,1 22,1 30 +3,Systematic,Analytical,Shallow,3,same,3,3,0,2,2,1,1,0.500000,0.500000,0.666667,3 10 17,3 7 10 +3,Systematic,Analytical,Shallow,3,cross,3,3,0,1,4,2,2,0.200000,0.800000,0.333333,1 15 27,1 28 31 +3,Systematic,Analytical,Shallow,4,same,4,4,0,4,0,0,0,1.000000,0.000000,1.000000,3 7 10 11,3 7 10 11 +3,Systematic,Analytical,Shallow,4,cross,4,4,0,2,4,2,2,0.333333,0.666667,0.500000,1 13 22 29,1 13 28 30 +3,Systematic,Analytical,Shallow,8,same,6,5,-1,5,1,0,1,0.833333,0.166667,0.833333,3 7 10 11 17 21,3 7 10 11 21 +3,Systematic,Analytical,Shallow,8,cross,8,6,-2,3,8,3,5,0.272727,0.727273,0.375000,1 6 13 16 22 25 29 32,1 13 28 30 31 32 +3,Systematic,Analytical,Contextual,1,same,1,1,0,1,0,0,0,1.000000,0.000000,1.000000,3,3 +3,Systematic,Analytical,Contextual,1,cross,1,1,0,1,0,0,0,1.000000,0.000000,1.000000,1,1 +3,Systematic,Analytical,Contextual,2,same,2,2,0,1,2,1,1,0.333333,0.666667,0.500000,3 11,3 10 +3,Systematic,Analytical,Contextual,2,cross,2,2,0,1,2,1,1,0.333333,0.666667,0.500000,1 18,1 28 +3,Systematic,Analytical,Contextual,3,same,3,3,0,2,2,1,1,0.500000,0.500000,0.666667,3 10 17,3 7 10 +3,Systematic,Analytical,Contextual,3,cross,3,3,0,2,2,1,1,0.500000,0.500000,0.666667,1 13 23,1 13 28 +3,Systematic,Analytical,Contextual,4,same,4,4,0,4,0,0,0,1.000000,0.000000,1.000000,3 7 10 11,3 7 10 11 +3,Systematic,Analytical,Contextual,4,cross,4,4,0,1,6,3,3,0.142857,0.857143,0.250000,1 9 18 29,1 13 28 30 +3,Systematic,Analytical,Contextual,8,same,6,5,-1,5,1,0,1,0.833333,0.166667,0.833333,3 7 10 11 17 21,3 7 10 11 21 +3,Systematic,Analytical,Contextual,8,cross,8,5,-3,2,9,3,6,0.181818,0.818182,0.250000,1 4 9 15 18 23 29 31,1 13 28 30 31 +3,Systematic,Analytical,Analogical,1,same,1,1,0,1,0,0,0,1.000000,0.000000,1.000000,3,3 +3,Systematic,Analytical,Analogical,1,cross,1,1,0,0,2,1,1,0.000000,1.000000,0.000000,4,13 +3,Systematic,Analytical,Analogical,2,same,2,2,0,2,0,0,0,1.000000,0.000000,1.000000,3 7,3 7 +3,Systematic,Analytical,Analogical,2,cross,2,2,0,0,4,2,2,0.000000,1.000000,0.000000,4 23,13 28 +3,Systematic,Analytical,Analogical,3,same,2,2,0,2,0,0,0,1.000000,0.000000,1.000000,3 7,3 7 +3,Systematic,Analytical,Analogical,3,cross,3,3,0,0,6,3,3,0.000000,1.000000,0.000000,4 9 23,13 28 31 +3,Systematic,Analytical,Analogical,4,same,2,2,0,2,0,0,0,1.000000,0.000000,1.000000,3 7,3 7 +3,Systematic,Analytical,Analogical,4,cross,4,3,-1,1,5,2,3,0.166667,0.833333,0.250000,4 9 23 31,13 28 31 +3,Systematic,Analytical,Analogical,8,same,2,2,0,2,0,0,0,1.000000,0.000000,1.000000,3 7,3 7 +3,Systematic,Analytical,Analogical,8,cross,8,3,-5,3,5,0,5,0.375000,0.625000,0.375000,4 6 9 13 23 28 31 34,13 28 31 +4,Methodical,Analytical,Surface,1,same,1,1,0,1,0,0,0,1.000000,0.000000,1.000000,3,3 +4,Methodical,Analytical,Surface,1,cross,1,1,0,1,0,0,0,1.000000,0.000000,1.000000,1,1 +4,Methodical,Analytical,Surface,2,same,2,2,0,1,2,1,1,0.333333,0.666667,0.500000,3 11,3 10 +4,Methodical,Analytical,Surface,2,cross,2,2,0,1,2,1,1,0.333333,0.666667,0.500000,1 22,1 30 +4,Methodical,Analytical,Surface,3,same,3,3,0,2,2,1,1,0.500000,0.500000,0.666667,3 10 17,3 7 10 +4,Methodical,Analytical,Surface,3,cross,3,3,0,1,4,2,2,0.200000,0.800000,0.333333,1 15 27,1 28 31 +4,Methodical,Analytical,Surface,4,same,4,4,0,4,0,0,0,1.000000,0.000000,1.000000,3 7 10 11,3 7 10 11 +4,Methodical,Analytical,Surface,4,cross,4,4,0,2,4,2,2,0.333333,0.666667,0.500000,1 13 22 29,1 13 28 30 +4,Methodical,Analytical,Surface,8,same,6,5,-1,5,1,0,1,0.833333,0.166667,0.833333,3 7 10 11 17 21,3 7 10 11 21 +4,Methodical,Analytical,Surface,8,cross,8,6,-2,3,8,3,5,0.272727,0.727273,0.375000,1 6 13 16 22 25 29 32,1 13 28 30 31 32 +4,Methodical,Analytical,Shallow,1,same,1,1,0,1,0,0,0,1.000000,0.000000,1.000000,3,3 +4,Methodical,Analytical,Shallow,1,cross,1,1,0,1,0,0,0,1.000000,0.000000,1.000000,1,1 +4,Methodical,Analytical,Shallow,2,same,2,2,0,1,2,1,1,0.333333,0.666667,0.500000,3 11,3 10 +4,Methodical,Analytical,Shallow,2,cross,2,2,0,1,2,1,1,0.333333,0.666667,0.500000,1 22,1 30 +4,Methodical,Analytical,Shallow,3,same,3,3,0,2,2,1,1,0.500000,0.500000,0.666667,3 10 17,3 7 10 +4,Methodical,Analytical,Shallow,3,cross,3,3,0,1,4,2,2,0.200000,0.800000,0.333333,1 15 27,1 28 31 +4,Methodical,Analytical,Shallow,4,same,4,4,0,4,0,0,0,1.000000,0.000000,1.000000,3 7 10 11,3 7 10 11 +4,Methodical,Analytical,Shallow,4,cross,4,4,0,2,4,2,2,0.333333,0.666667,0.500000,1 13 22 29,1 13 28 30 +4,Methodical,Analytical,Shallow,8,same,6,5,-1,5,1,0,1,0.833333,0.166667,0.833333,3 7 10 11 17 21,3 7 10 11 21 +4,Methodical,Analytical,Shallow,8,cross,8,6,-2,3,8,3,5,0.272727,0.727273,0.375000,1 6 13 16 22 25 29 32,1 13 28 30 31 32 +4,Methodical,Analytical,Contextual,1,same,1,1,0,1,0,0,0,1.000000,0.000000,1.000000,3,3 +4,Methodical,Analytical,Contextual,1,cross,1,1,0,1,0,0,0,1.000000,0.000000,1.000000,1,1 +4,Methodical,Analytical,Contextual,2,same,2,2,0,1,2,1,1,0.333333,0.666667,0.500000,3 11,3 10 +4,Methodical,Analytical,Contextual,2,cross,2,2,0,1,2,1,1,0.333333,0.666667,0.500000,1 18,1 28 +4,Methodical,Analytical,Contextual,3,same,3,3,0,2,2,1,1,0.500000,0.500000,0.666667,3 10 17,3 7 10 +4,Methodical,Analytical,Contextual,3,cross,3,3,0,2,2,1,1,0.500000,0.500000,0.666667,1 13 23,1 13 28 +4,Methodical,Analytical,Contextual,4,same,4,4,0,4,0,0,0,1.000000,0.000000,1.000000,3 7 10 11,3 7 10 11 +4,Methodical,Analytical,Contextual,4,cross,4,4,0,1,6,3,3,0.142857,0.857143,0.250000,1 9 18 29,1 13 28 30 +4,Methodical,Analytical,Contextual,8,same,6,5,-1,5,1,0,1,0.833333,0.166667,0.833333,3 7 10 11 17 21,3 7 10 11 21 +4,Methodical,Analytical,Contextual,8,cross,8,5,-3,2,9,3,6,0.181818,0.818182,0.250000,1 4 9 15 18 23 29 31,1 13 28 30 31 +4,Methodical,Analytical,Analogical,1,same,1,1,0,1,0,0,0,1.000000,0.000000,1.000000,3,3 +4,Methodical,Analytical,Analogical,1,cross,1,1,0,0,2,1,1,0.000000,1.000000,0.000000,4,13 +4,Methodical,Analytical,Analogical,2,same,2,2,0,2,0,0,0,1.000000,0.000000,1.000000,3 7,3 7 +4,Methodical,Analytical,Analogical,2,cross,2,2,0,0,4,2,2,0.000000,1.000000,0.000000,4 23,13 28 +4,Methodical,Analytical,Analogical,3,same,2,2,0,2,0,0,0,1.000000,0.000000,1.000000,3 7,3 7 +4,Methodical,Analytical,Analogical,3,cross,3,3,0,0,6,3,3,0.000000,1.000000,0.000000,4 9 23,13 28 31 +4,Methodical,Analytical,Analogical,4,same,2,2,0,2,0,0,0,1.000000,0.000000,1.000000,3 7,3 7 +4,Methodical,Analytical,Analogical,4,cross,4,3,-1,1,5,2,3,0.166667,0.833333,0.250000,4 9 23 31,13 28 31 +4,Methodical,Analytical,Analogical,8,same,2,2,0,2,0,0,0,1.000000,0.000000,1.000000,3 7,3 7 +4,Methodical,Analytical,Analogical,8,cross,8,3,-5,3,5,0,5,0.375000,0.625000,0.375000,4 6 9 13 23 28 31 34,13 28 31 +5,Precise,Analytical,Surface,1,same,1,1,0,1,0,0,0,1.000000,0.000000,1.000000,3,3 +5,Precise,Analytical,Surface,1,cross,1,1,0,1,0,0,0,1.000000,0.000000,1.000000,1,1 +5,Precise,Analytical,Surface,2,same,2,2,0,1,2,1,1,0.333333,0.666667,0.500000,3 11,3 10 +5,Precise,Analytical,Surface,2,cross,2,2,0,1,2,1,1,0.333333,0.666667,0.500000,1 22,1 30 +5,Precise,Analytical,Surface,3,same,3,3,0,2,2,1,1,0.500000,0.500000,0.666667,3 10 17,3 7 10 +5,Precise,Analytical,Surface,3,cross,3,3,0,1,4,2,2,0.200000,0.800000,0.333333,1 15 27,1 28 31 +5,Precise,Analytical,Surface,4,same,4,4,0,4,0,0,0,1.000000,0.000000,1.000000,3 7 10 11,3 7 10 11 +5,Precise,Analytical,Surface,4,cross,4,4,0,2,4,2,2,0.333333,0.666667,0.500000,1 13 22 29,1 13 28 30 +5,Precise,Analytical,Surface,8,same,6,5,-1,5,1,0,1,0.833333,0.166667,0.833333,3 7 10 11 17 21,3 7 10 11 21 +5,Precise,Analytical,Surface,8,cross,8,6,-2,3,8,3,5,0.272727,0.727273,0.375000,1 6 13 16 22 25 29 32,1 13 28 30 31 32 +5,Precise,Analytical,Shallow,1,same,1,1,0,1,0,0,0,1.000000,0.000000,1.000000,3,3 +5,Precise,Analytical,Shallow,1,cross,1,1,0,1,0,0,0,1.000000,0.000000,1.000000,1,1 +5,Precise,Analytical,Shallow,2,same,2,2,0,1,2,1,1,0.333333,0.666667,0.500000,3 11,3 10 +5,Precise,Analytical,Shallow,2,cross,2,2,0,1,2,1,1,0.333333,0.666667,0.500000,1 22,1 30 +5,Precise,Analytical,Shallow,3,same,3,3,0,2,2,1,1,0.500000,0.500000,0.666667,3 10 17,3 7 10 +5,Precise,Analytical,Shallow,3,cross,3,3,0,1,4,2,2,0.200000,0.800000,0.333333,1 15 27,1 28 31 +5,Precise,Analytical,Shallow,4,same,4,4,0,4,0,0,0,1.000000,0.000000,1.000000,3 7 10 11,3 7 10 11 +5,Precise,Analytical,Shallow,4,cross,4,4,0,2,4,2,2,0.333333,0.666667,0.500000,1 13 22 29,1 13 28 30 +5,Precise,Analytical,Shallow,8,same,6,5,-1,5,1,0,1,0.833333,0.166667,0.833333,3 7 10 11 17 21,3 7 10 11 21 +5,Precise,Analytical,Shallow,8,cross,8,6,-2,3,8,3,5,0.272727,0.727273,0.375000,1 6 13 16 22 25 29 32,1 13 28 30 31 32 +5,Precise,Analytical,Contextual,1,same,1,1,0,1,0,0,0,1.000000,0.000000,1.000000,3,3 +5,Precise,Analytical,Contextual,1,cross,1,1,0,1,0,0,0,1.000000,0.000000,1.000000,1,1 +5,Precise,Analytical,Contextual,2,same,2,2,0,1,2,1,1,0.333333,0.666667,0.500000,3 11,3 10 +5,Precise,Analytical,Contextual,2,cross,2,2,0,1,2,1,1,0.333333,0.666667,0.500000,1 18,1 28 +5,Precise,Analytical,Contextual,3,same,3,3,0,2,2,1,1,0.500000,0.500000,0.666667,3 10 17,3 7 10 +5,Precise,Analytical,Contextual,3,cross,3,3,0,2,2,1,1,0.500000,0.500000,0.666667,1 13 23,1 13 28 +5,Precise,Analytical,Contextual,4,same,4,4,0,4,0,0,0,1.000000,0.000000,1.000000,3 7 10 11,3 7 10 11 +5,Precise,Analytical,Contextual,4,cross,4,4,0,1,6,3,3,0.142857,0.857143,0.250000,1 9 18 29,1 13 28 30 +5,Precise,Analytical,Contextual,8,same,6,5,-1,5,1,0,1,0.833333,0.166667,0.833333,3 7 10 11 17 21,3 7 10 11 21 +5,Precise,Analytical,Contextual,8,cross,8,5,-3,2,9,3,6,0.181818,0.818182,0.250000,1 4 9 15 18 23 29 31,1 13 28 30 31 +5,Precise,Analytical,Analogical,1,same,1,1,0,1,0,0,0,1.000000,0.000000,1.000000,3,3 +5,Precise,Analytical,Analogical,1,cross,1,1,0,0,2,1,1,0.000000,1.000000,0.000000,4,13 +5,Precise,Analytical,Analogical,2,same,2,2,0,2,0,0,0,1.000000,0.000000,1.000000,3 7,3 7 +5,Precise,Analytical,Analogical,2,cross,2,2,0,0,4,2,2,0.000000,1.000000,0.000000,4 23,13 28 +5,Precise,Analytical,Analogical,3,same,2,2,0,2,0,0,0,1.000000,0.000000,1.000000,3 7,3 7 +5,Precise,Analytical,Analogical,3,cross,3,3,0,0,6,3,3,0.000000,1.000000,0.000000,4 9 23,13 28 31 +5,Precise,Analytical,Analogical,4,same,2,2,0,2,0,0,0,1.000000,0.000000,1.000000,3 7,3 7 +5,Precise,Analytical,Analogical,4,cross,4,3,-1,1,5,2,3,0.166667,0.833333,0.250000,4 9 23 31,13 28 31 +5,Precise,Analytical,Analogical,8,same,2,2,0,2,0,0,0,1.000000,0.000000,1.000000,3 7,3 7 +5,Precise,Analytical,Analogical,8,cross,8,3,-5,3,5,0,5,0.375000,0.625000,0.375000,4 6 9 13 23 28 31 34,13 28 31 +6,Creative,Creative,Surface,1,same,1,1,0,0,2,1,1,0.000000,1.000000,0.000000,4,13 +6,Creative,Creative,Surface,1,cross,1,1,0,1,0,0,0,1.000000,0.000000,1.000000,1,1 +6,Creative,Creative,Surface,2,same,2,2,0,0,4,2,2,0.000000,1.000000,0.000000,4 23,13 28 +6,Creative,Creative,Surface,2,cross,2,2,0,1,2,1,1,0.333333,0.666667,0.500000,1 18,1 11 +6,Creative,Creative,Surface,3,same,3,3,0,0,6,3,3,0.000000,1.000000,0.000000,4 9 23,13 28 31 +6,Creative,Creative,Surface,3,cross,3,3,0,1,4,2,2,0.200000,0.800000,0.333333,1 14 22,1 7 11 +6,Creative,Creative,Surface,4,same,4,3,-1,1,5,2,3,0.166667,0.833333,0.250000,4 9 23 31,13 28 31 +6,Creative,Creative,Surface,4,cross,4,4,0,2,4,2,2,0.333333,0.666667,0.500000,1 11 17 24,1 7 11 30 +6,Creative,Creative,Surface,8,same,8,3,-5,3,5,0,5,0.375000,0.625000,0.375000,4 6 9 13 23 28 31 34,13 28 31 +6,Creative,Creative,Surface,8,cross,8,8,0,3,10,5,5,0.230769,0.769231,0.375000,1 3 10 12 15 17 19 22,1 3 7 10 11 21 30 32 +6,Creative,Creative,Shallow,1,same,1,1,0,0,2,1,1,0.000000,1.000000,0.000000,4,13 +6,Creative,Creative,Shallow,1,cross,1,1,0,1,0,0,0,1.000000,0.000000,1.000000,1,1 +6,Creative,Creative,Shallow,2,same,2,2,0,0,4,2,2,0.000000,1.000000,0.000000,4 23,13 28 +6,Creative,Creative,Shallow,2,cross,2,2,0,1,2,1,1,0.333333,0.666667,0.500000,1 18,1 11 +6,Creative,Creative,Shallow,3,same,3,3,0,0,6,3,3,0.000000,1.000000,0.000000,4 9 23,13 28 31 +6,Creative,Creative,Shallow,3,cross,3,3,0,1,4,2,2,0.200000,0.800000,0.333333,1 14 22,1 7 11 +6,Creative,Creative,Shallow,4,same,4,3,-1,1,5,2,3,0.166667,0.833333,0.250000,4 9 23 31,13 28 31 +6,Creative,Creative,Shallow,4,cross,4,4,0,2,4,2,2,0.333333,0.666667,0.500000,1 11 17 24,1 7 11 30 +6,Creative,Creative,Shallow,8,same,8,3,-5,3,5,0,5,0.375000,0.625000,0.375000,4 6 9 13 23 28 31 34,13 28 31 +6,Creative,Creative,Shallow,8,cross,8,8,0,3,10,5,5,0.230769,0.769231,0.375000,1 3 10 12 15 17 19 22,1 3 7 10 11 21 30 32 +6,Creative,Creative,Contextual,1,same,1,1,0,0,2,1,1,0.000000,1.000000,0.000000,4,13 +6,Creative,Creative,Contextual,1,cross,1,1,0,1,0,0,0,1.000000,0.000000,1.000000,1,1 +6,Creative,Creative,Contextual,2,same,2,2,0,0,4,2,2,0.000000,1.000000,0.000000,4 23,13 28 +6,Creative,Creative,Contextual,2,cross,2,2,0,1,2,1,1,0.333333,0.666667,0.500000,1 16,1 10 +6,Creative,Creative,Contextual,3,same,3,3,0,0,6,3,3,0.000000,1.000000,0.000000,4 9 23,13 28 31 +6,Creative,Creative,Contextual,3,cross,3,3,0,2,2,1,1,0.500000,0.500000,0.666667,1 11 21,1 7 11 +6,Creative,Creative,Contextual,4,same,4,3,-1,1,5,2,3,0.166667,0.833333,0.250000,4 9 23 31,13 28 31 +6,Creative,Creative,Contextual,4,cross,4,4,0,2,4,2,2,0.333333,0.666667,0.500000,1 7 15 18,1 3 7 10 +6,Creative,Creative,Contextual,8,same,8,3,-5,3,5,0,5,0.375000,0.625000,0.375000,4 6 9 13 23 28 31 34,13 28 31 +6,Creative,Creative,Contextual,8,cross,8,7,-1,5,5,2,3,0.500000,0.500000,0.625000,1 2 3 7 10 11 15 16,1 3 7 10 11 21 30 +6,Creative,Creative,Analogical,1,same,1,1,0,0,2,1,1,0.000000,1.000000,0.000000,4,13 +6,Creative,Creative,Analogical,1,cross,1,1,0,1,0,0,0,1.000000,0.000000,1.000000,3,3 +6,Creative,Creative,Analogical,2,same,2,2,0,0,4,2,2,0.000000,1.000000,0.000000,4 23,13 28 +6,Creative,Creative,Analogical,2,cross,2,2,0,2,0,0,0,1.000000,0.000000,1.000000,3 7,3 7 +6,Creative,Creative,Analogical,3,same,3,3,0,0,6,3,3,0.000000,1.000000,0.000000,4 9 23,13 28 31 +6,Creative,Creative,Analogical,3,cross,2,2,0,2,0,0,0,1.000000,0.000000,1.000000,3 7,3 7 +6,Creative,Creative,Analogical,4,same,4,3,-1,1,5,2,3,0.166667,0.833333,0.250000,4 9 23 31,13 28 31 +6,Creative,Creative,Analogical,4,cross,2,2,0,2,0,0,0,1.000000,0.000000,1.000000,3 7,3 7 +6,Creative,Creative,Analogical,8,same,8,3,-5,3,5,0,5,0.375000,0.625000,0.375000,4 6 9 13 23 28 31 34,13 28 31 +6,Creative,Creative,Analogical,8,cross,2,2,0,2,0,0,0,1.000000,0.000000,1.000000,3 7,3 7 +7,Imaginative,Creative,Surface,1,same,1,1,0,0,2,1,1,0.000000,1.000000,0.000000,4,13 +7,Imaginative,Creative,Surface,1,cross,1,1,0,1,0,0,0,1.000000,0.000000,1.000000,1,1 +7,Imaginative,Creative,Surface,2,same,2,2,0,0,4,2,2,0.000000,1.000000,0.000000,4 23,13 28 +7,Imaginative,Creative,Surface,2,cross,2,2,0,1,2,1,1,0.333333,0.666667,0.500000,1 18,1 11 +7,Imaginative,Creative,Surface,3,same,3,3,0,0,6,3,3,0.000000,1.000000,0.000000,4 9 23,13 28 31 +7,Imaginative,Creative,Surface,3,cross,3,3,0,1,4,2,2,0.200000,0.800000,0.333333,1 14 22,1 7 11 +7,Imaginative,Creative,Surface,4,same,4,3,-1,1,5,2,3,0.166667,0.833333,0.250000,4 9 23 31,13 28 31 +7,Imaginative,Creative,Surface,4,cross,4,4,0,2,4,2,2,0.333333,0.666667,0.500000,1 11 17 24,1 7 11 30 +7,Imaginative,Creative,Surface,8,same,8,3,-5,3,5,0,5,0.375000,0.625000,0.375000,4 6 9 13 23 28 31 34,13 28 31 +7,Imaginative,Creative,Surface,8,cross,8,8,0,3,10,5,5,0.230769,0.769231,0.375000,1 3 10 12 15 17 19 22,1 3 7 10 11 21 30 32 +7,Imaginative,Creative,Shallow,1,same,1,1,0,0,2,1,1,0.000000,1.000000,0.000000,4,13 +7,Imaginative,Creative,Shallow,1,cross,1,1,0,1,0,0,0,1.000000,0.000000,1.000000,1,1 +7,Imaginative,Creative,Shallow,2,same,2,2,0,0,4,2,2,0.000000,1.000000,0.000000,4 23,13 28 +7,Imaginative,Creative,Shallow,2,cross,2,2,0,1,2,1,1,0.333333,0.666667,0.500000,1 18,1 11 +7,Imaginative,Creative,Shallow,3,same,3,3,0,0,6,3,3,0.000000,1.000000,0.000000,4 9 23,13 28 31 +7,Imaginative,Creative,Shallow,3,cross,3,3,0,1,4,2,2,0.200000,0.800000,0.333333,1 14 22,1 7 11 +7,Imaginative,Creative,Shallow,4,same,4,3,-1,1,5,2,3,0.166667,0.833333,0.250000,4 9 23 31,13 28 31 +7,Imaginative,Creative,Shallow,4,cross,4,4,0,2,4,2,2,0.333333,0.666667,0.500000,1 11 17 24,1 7 11 30 +7,Imaginative,Creative,Shallow,8,same,8,3,-5,3,5,0,5,0.375000,0.625000,0.375000,4 6 9 13 23 28 31 34,13 28 31 +7,Imaginative,Creative,Shallow,8,cross,8,8,0,3,10,5,5,0.230769,0.769231,0.375000,1 3 10 12 15 17 19 22,1 3 7 10 11 21 30 32 +7,Imaginative,Creative,Contextual,1,same,1,1,0,0,2,1,1,0.000000,1.000000,0.000000,4,13 +7,Imaginative,Creative,Contextual,1,cross,1,1,0,1,0,0,0,1.000000,0.000000,1.000000,1,1 +7,Imaginative,Creative,Contextual,2,same,2,2,0,0,4,2,2,0.000000,1.000000,0.000000,4 23,13 28 +7,Imaginative,Creative,Contextual,2,cross,2,2,0,1,2,1,1,0.333333,0.666667,0.500000,1 16,1 10 +7,Imaginative,Creative,Contextual,3,same,3,3,0,0,6,3,3,0.000000,1.000000,0.000000,4 9 23,13 28 31 +7,Imaginative,Creative,Contextual,3,cross,3,3,0,2,2,1,1,0.500000,0.500000,0.666667,1 11 21,1 7 11 +7,Imaginative,Creative,Contextual,4,same,4,3,-1,1,5,2,3,0.166667,0.833333,0.250000,4 9 23 31,13 28 31 +7,Imaginative,Creative,Contextual,4,cross,4,4,0,2,4,2,2,0.333333,0.666667,0.500000,1 7 15 18,1 3 7 10 +7,Imaginative,Creative,Contextual,8,same,8,3,-5,3,5,0,5,0.375000,0.625000,0.375000,4 6 9 13 23 28 31 34,13 28 31 +7,Imaginative,Creative,Contextual,8,cross,8,7,-1,5,5,2,3,0.500000,0.500000,0.625000,1 2 3 7 10 11 15 16,1 3 7 10 11 21 30 +7,Imaginative,Creative,Analogical,1,same,1,1,0,0,2,1,1,0.000000,1.000000,0.000000,4,13 +7,Imaginative,Creative,Analogical,1,cross,1,1,0,1,0,0,0,1.000000,0.000000,1.000000,3,3 +7,Imaginative,Creative,Analogical,2,same,2,2,0,0,4,2,2,0.000000,1.000000,0.000000,4 23,13 28 +7,Imaginative,Creative,Analogical,2,cross,2,2,0,2,0,0,0,1.000000,0.000000,1.000000,3 7,3 7 +7,Imaginative,Creative,Analogical,3,same,3,3,0,0,6,3,3,0.000000,1.000000,0.000000,4 9 23,13 28 31 +7,Imaginative,Creative,Analogical,3,cross,2,2,0,2,0,0,0,1.000000,0.000000,1.000000,3 7,3 7 +7,Imaginative,Creative,Analogical,4,same,4,3,-1,1,5,2,3,0.166667,0.833333,0.250000,4 9 23 31,13 28 31 +7,Imaginative,Creative,Analogical,4,cross,2,2,0,2,0,0,0,1.000000,0.000000,1.000000,3 7,3 7 +7,Imaginative,Creative,Analogical,8,same,8,3,-5,3,5,0,5,0.375000,0.625000,0.375000,4 6 9 13 23 28 31 34,13 28 31 +7,Imaginative,Creative,Analogical,8,cross,2,2,0,2,0,0,0,1.000000,0.000000,1.000000,3 7,3 7 +8,Innovative,Creative,Surface,1,same,1,1,0,0,2,1,1,0.000000,1.000000,0.000000,4,13 +8,Innovative,Creative,Surface,1,cross,1,1,0,1,0,0,0,1.000000,0.000000,1.000000,1,1 +8,Innovative,Creative,Surface,2,same,2,2,0,0,4,2,2,0.000000,1.000000,0.000000,4 23,13 28 +8,Innovative,Creative,Surface,2,cross,2,2,0,1,2,1,1,0.333333,0.666667,0.500000,1 18,1 11 +8,Innovative,Creative,Surface,3,same,3,3,0,0,6,3,3,0.000000,1.000000,0.000000,4 9 23,13 28 31 +8,Innovative,Creative,Surface,3,cross,3,3,0,1,4,2,2,0.200000,0.800000,0.333333,1 14 22,1 7 11 +8,Innovative,Creative,Surface,4,same,4,3,-1,1,5,2,3,0.166667,0.833333,0.250000,4 9 23 31,13 28 31 +8,Innovative,Creative,Surface,4,cross,4,4,0,2,4,2,2,0.333333,0.666667,0.500000,1 11 17 24,1 7 11 30 +8,Innovative,Creative,Surface,8,same,8,3,-5,3,5,0,5,0.375000,0.625000,0.375000,4 6 9 13 23 28 31 34,13 28 31 +8,Innovative,Creative,Surface,8,cross,8,8,0,3,10,5,5,0.230769,0.769231,0.375000,1 3 10 12 15 17 19 22,1 3 7 10 11 21 30 32 +8,Innovative,Creative,Shallow,1,same,1,1,0,0,2,1,1,0.000000,1.000000,0.000000,4,13 +8,Innovative,Creative,Shallow,1,cross,1,1,0,1,0,0,0,1.000000,0.000000,1.000000,1,1 +8,Innovative,Creative,Shallow,2,same,2,2,0,0,4,2,2,0.000000,1.000000,0.000000,4 23,13 28 +8,Innovative,Creative,Shallow,2,cross,2,2,0,1,2,1,1,0.333333,0.666667,0.500000,1 18,1 11 +8,Innovative,Creative,Shallow,3,same,3,3,0,0,6,3,3,0.000000,1.000000,0.000000,4 9 23,13 28 31 +8,Innovative,Creative,Shallow,3,cross,3,3,0,1,4,2,2,0.200000,0.800000,0.333333,1 14 22,1 7 11 +8,Innovative,Creative,Shallow,4,same,4,3,-1,1,5,2,3,0.166667,0.833333,0.250000,4 9 23 31,13 28 31 +8,Innovative,Creative,Shallow,4,cross,4,4,0,2,4,2,2,0.333333,0.666667,0.500000,1 11 17 24,1 7 11 30 +8,Innovative,Creative,Shallow,8,same,8,3,-5,3,5,0,5,0.375000,0.625000,0.375000,4 6 9 13 23 28 31 34,13 28 31 +8,Innovative,Creative,Shallow,8,cross,8,8,0,3,10,5,5,0.230769,0.769231,0.375000,1 3 10 12 15 17 19 22,1 3 7 10 11 21 30 32 +8,Innovative,Creative,Contextual,1,same,1,1,0,0,2,1,1,0.000000,1.000000,0.000000,4,13 +8,Innovative,Creative,Contextual,1,cross,1,1,0,1,0,0,0,1.000000,0.000000,1.000000,1,1 +8,Innovative,Creative,Contextual,2,same,2,2,0,0,4,2,2,0.000000,1.000000,0.000000,4 23,13 28 +8,Innovative,Creative,Contextual,2,cross,2,2,0,1,2,1,1,0.333333,0.666667,0.500000,1 16,1 10 +8,Innovative,Creative,Contextual,3,same,3,3,0,0,6,3,3,0.000000,1.000000,0.000000,4 9 23,13 28 31 +8,Innovative,Creative,Contextual,3,cross,3,3,0,2,2,1,1,0.500000,0.500000,0.666667,1 11 21,1 7 11 +8,Innovative,Creative,Contextual,4,same,4,3,-1,1,5,2,3,0.166667,0.833333,0.250000,4 9 23 31,13 28 31 +8,Innovative,Creative,Contextual,4,cross,4,4,0,2,4,2,2,0.333333,0.666667,0.500000,1 7 15 18,1 3 7 10 +8,Innovative,Creative,Contextual,8,same,8,3,-5,3,5,0,5,0.375000,0.625000,0.375000,4 6 9 13 23 28 31 34,13 28 31 +8,Innovative,Creative,Contextual,8,cross,8,7,-1,5,5,2,3,0.500000,0.500000,0.625000,1 2 3 7 10 11 15 16,1 3 7 10 11 21 30 +8,Innovative,Creative,Analogical,1,same,1,1,0,0,2,1,1,0.000000,1.000000,0.000000,4,13 +8,Innovative,Creative,Analogical,1,cross,1,1,0,1,0,0,0,1.000000,0.000000,1.000000,3,3 +8,Innovative,Creative,Analogical,2,same,2,2,0,0,4,2,2,0.000000,1.000000,0.000000,4 23,13 28 +8,Innovative,Creative,Analogical,2,cross,2,2,0,2,0,0,0,1.000000,0.000000,1.000000,3 7,3 7 +8,Innovative,Creative,Analogical,3,same,3,3,0,0,6,3,3,0.000000,1.000000,0.000000,4 9 23,13 28 31 +8,Innovative,Creative,Analogical,3,cross,2,2,0,2,0,0,0,1.000000,0.000000,1.000000,3 7,3 7 +8,Innovative,Creative,Analogical,4,same,4,3,-1,1,5,2,3,0.166667,0.833333,0.250000,4 9 23 31,13 28 31 +8,Innovative,Creative,Analogical,4,cross,2,2,0,2,0,0,0,1.000000,0.000000,1.000000,3 7,3 7 +8,Innovative,Creative,Analogical,8,same,8,3,-5,3,5,0,5,0.375000,0.625000,0.375000,4 6 9 13 23 28 31 34,13 28 31 +8,Innovative,Creative,Analogical,8,cross,2,2,0,2,0,0,0,1.000000,0.000000,1.000000,3 7,3 7 +9,Artistic,Creative,Surface,1,same,1,1,0,0,2,1,1,0.000000,1.000000,0.000000,4,13 +9,Artistic,Creative,Surface,1,cross,1,1,0,1,0,0,0,1.000000,0.000000,1.000000,1,1 +9,Artistic,Creative,Surface,2,same,2,2,0,0,4,2,2,0.000000,1.000000,0.000000,4 23,13 28 +9,Artistic,Creative,Surface,2,cross,2,2,0,1,2,1,1,0.333333,0.666667,0.500000,1 18,1 11 +9,Artistic,Creative,Surface,3,same,3,3,0,0,6,3,3,0.000000,1.000000,0.000000,4 9 23,13 28 31 +9,Artistic,Creative,Surface,3,cross,3,3,0,1,4,2,2,0.200000,0.800000,0.333333,1 14 22,1 7 11 +9,Artistic,Creative,Surface,4,same,4,3,-1,1,5,2,3,0.166667,0.833333,0.250000,4 9 23 31,13 28 31 +9,Artistic,Creative,Surface,4,cross,4,4,0,2,4,2,2,0.333333,0.666667,0.500000,1 11 17 24,1 7 11 30 +9,Artistic,Creative,Surface,8,same,8,3,-5,3,5,0,5,0.375000,0.625000,0.375000,4 6 9 13 23 28 31 34,13 28 31 +9,Artistic,Creative,Surface,8,cross,8,8,0,3,10,5,5,0.230769,0.769231,0.375000,1 3 10 12 15 17 19 22,1 3 7 10 11 21 30 32 +9,Artistic,Creative,Shallow,1,same,1,1,0,0,2,1,1,0.000000,1.000000,0.000000,4,13 +9,Artistic,Creative,Shallow,1,cross,1,1,0,1,0,0,0,1.000000,0.000000,1.000000,1,1 +9,Artistic,Creative,Shallow,2,same,2,2,0,0,4,2,2,0.000000,1.000000,0.000000,4 23,13 28 +9,Artistic,Creative,Shallow,2,cross,2,2,0,1,2,1,1,0.333333,0.666667,0.500000,1 18,1 11 +9,Artistic,Creative,Shallow,3,same,3,3,0,0,6,3,3,0.000000,1.000000,0.000000,4 9 23,13 28 31 +9,Artistic,Creative,Shallow,3,cross,3,3,0,1,4,2,2,0.200000,0.800000,0.333333,1 14 22,1 7 11 +9,Artistic,Creative,Shallow,4,same,4,3,-1,1,5,2,3,0.166667,0.833333,0.250000,4 9 23 31,13 28 31 +9,Artistic,Creative,Shallow,4,cross,4,4,0,2,4,2,2,0.333333,0.666667,0.500000,1 11 17 24,1 7 11 30 +9,Artistic,Creative,Shallow,8,same,8,3,-5,3,5,0,5,0.375000,0.625000,0.375000,4 6 9 13 23 28 31 34,13 28 31 +9,Artistic,Creative,Shallow,8,cross,8,8,0,3,10,5,5,0.230769,0.769231,0.375000,1 3 10 12 15 17 19 22,1 3 7 10 11 21 30 32 +9,Artistic,Creative,Contextual,1,same,1,1,0,0,2,1,1,0.000000,1.000000,0.000000,4,13 +9,Artistic,Creative,Contextual,1,cross,1,1,0,1,0,0,0,1.000000,0.000000,1.000000,1,1 +9,Artistic,Creative,Contextual,2,same,2,2,0,0,4,2,2,0.000000,1.000000,0.000000,4 23,13 28 +9,Artistic,Creative,Contextual,2,cross,2,2,0,1,2,1,1,0.333333,0.666667,0.500000,1 16,1 10 +9,Artistic,Creative,Contextual,3,same,3,3,0,0,6,3,3,0.000000,1.000000,0.000000,4 9 23,13 28 31 +9,Artistic,Creative,Contextual,3,cross,3,3,0,2,2,1,1,0.500000,0.500000,0.666667,1 11 21,1 7 11 +9,Artistic,Creative,Contextual,4,same,4,3,-1,1,5,2,3,0.166667,0.833333,0.250000,4 9 23 31,13 28 31 +9,Artistic,Creative,Contextual,4,cross,4,4,0,2,4,2,2,0.333333,0.666667,0.500000,1 7 15 18,1 3 7 10 +9,Artistic,Creative,Contextual,8,same,8,3,-5,3,5,0,5,0.375000,0.625000,0.375000,4 6 9 13 23 28 31 34,13 28 31 +9,Artistic,Creative,Contextual,8,cross,8,7,-1,5,5,2,3,0.500000,0.500000,0.625000,1 2 3 7 10 11 15 16,1 3 7 10 11 21 30 +9,Artistic,Creative,Analogical,1,same,1,1,0,0,2,1,1,0.000000,1.000000,0.000000,4,13 +9,Artistic,Creative,Analogical,1,cross,1,1,0,1,0,0,0,1.000000,0.000000,1.000000,3,3 +9,Artistic,Creative,Analogical,2,same,2,2,0,0,4,2,2,0.000000,1.000000,0.000000,4 23,13 28 +9,Artistic,Creative,Analogical,2,cross,2,2,0,2,0,0,0,1.000000,0.000000,1.000000,3 7,3 7 +9,Artistic,Creative,Analogical,3,same,3,3,0,0,6,3,3,0.000000,1.000000,0.000000,4 9 23,13 28 31 +9,Artistic,Creative,Analogical,3,cross,2,2,0,2,0,0,0,1.000000,0.000000,1.000000,3 7,3 7 +9,Artistic,Creative,Analogical,4,same,4,3,-1,1,5,2,3,0.166667,0.833333,0.250000,4 9 23 31,13 28 31 +9,Artistic,Creative,Analogical,4,cross,2,2,0,2,0,0,0,1.000000,0.000000,1.000000,3 7,3 7 +9,Artistic,Creative,Analogical,8,same,8,3,-5,3,5,0,5,0.375000,0.625000,0.375000,4 6 9 13 23 28 31 34,13 28 31 +9,Artistic,Creative,Analogical,8,cross,2,2,0,2,0,0,0,1.000000,0.000000,1.000000,3 7,3 7 +10,Poetic,Creative,Surface,1,same,1,1,0,0,2,1,1,0.000000,1.000000,0.000000,4,13 +10,Poetic,Creative,Surface,1,cross,1,1,0,1,0,0,0,1.000000,0.000000,1.000000,1,1 +10,Poetic,Creative,Surface,2,same,2,2,0,0,4,2,2,0.000000,1.000000,0.000000,4 23,13 28 +10,Poetic,Creative,Surface,2,cross,2,2,0,1,2,1,1,0.333333,0.666667,0.500000,1 18,1 11 +10,Poetic,Creative,Surface,3,same,3,3,0,0,6,3,3,0.000000,1.000000,0.000000,4 9 23,13 28 31 +10,Poetic,Creative,Surface,3,cross,3,3,0,1,4,2,2,0.200000,0.800000,0.333333,1 14 22,1 7 11 +10,Poetic,Creative,Surface,4,same,4,3,-1,1,5,2,3,0.166667,0.833333,0.250000,4 9 23 31,13 28 31 +10,Poetic,Creative,Surface,4,cross,4,4,0,2,4,2,2,0.333333,0.666667,0.500000,1 11 17 24,1 7 11 30 +10,Poetic,Creative,Surface,8,same,8,3,-5,3,5,0,5,0.375000,0.625000,0.375000,4 6 9 13 23 28 31 34,13 28 31 +10,Poetic,Creative,Surface,8,cross,8,8,0,3,10,5,5,0.230769,0.769231,0.375000,1 3 10 12 15 17 19 22,1 3 7 10 11 21 30 32 +10,Poetic,Creative,Shallow,1,same,1,1,0,0,2,1,1,0.000000,1.000000,0.000000,4,13 +10,Poetic,Creative,Shallow,1,cross,1,1,0,1,0,0,0,1.000000,0.000000,1.000000,1,1 +10,Poetic,Creative,Shallow,2,same,2,2,0,0,4,2,2,0.000000,1.000000,0.000000,4 23,13 28 +10,Poetic,Creative,Shallow,2,cross,2,2,0,1,2,1,1,0.333333,0.666667,0.500000,1 18,1 11 +10,Poetic,Creative,Shallow,3,same,3,3,0,0,6,3,3,0.000000,1.000000,0.000000,4 9 23,13 28 31 +10,Poetic,Creative,Shallow,3,cross,3,3,0,1,4,2,2,0.200000,0.800000,0.333333,1 14 22,1 7 11 +10,Poetic,Creative,Shallow,4,same,4,3,-1,1,5,2,3,0.166667,0.833333,0.250000,4 9 23 31,13 28 31 +10,Poetic,Creative,Shallow,4,cross,4,4,0,2,4,2,2,0.333333,0.666667,0.500000,1 11 17 24,1 7 11 30 +10,Poetic,Creative,Shallow,8,same,8,3,-5,3,5,0,5,0.375000,0.625000,0.375000,4 6 9 13 23 28 31 34,13 28 31 +10,Poetic,Creative,Shallow,8,cross,8,8,0,3,10,5,5,0.230769,0.769231,0.375000,1 3 10 12 15 17 19 22,1 3 7 10 11 21 30 32 +10,Poetic,Creative,Contextual,1,same,1,1,0,0,2,1,1,0.000000,1.000000,0.000000,4,13 +10,Poetic,Creative,Contextual,1,cross,1,1,0,1,0,0,0,1.000000,0.000000,1.000000,1,1 +10,Poetic,Creative,Contextual,2,same,2,2,0,0,4,2,2,0.000000,1.000000,0.000000,4 23,13 28 +10,Poetic,Creative,Contextual,2,cross,2,2,0,1,2,1,1,0.333333,0.666667,0.500000,1 16,1 10 +10,Poetic,Creative,Contextual,3,same,3,3,0,0,6,3,3,0.000000,1.000000,0.000000,4 9 23,13 28 31 +10,Poetic,Creative,Contextual,3,cross,3,3,0,2,2,1,1,0.500000,0.500000,0.666667,1 11 21,1 7 11 +10,Poetic,Creative,Contextual,4,same,4,3,-1,1,5,2,3,0.166667,0.833333,0.250000,4 9 23 31,13 28 31 +10,Poetic,Creative,Contextual,4,cross,4,4,0,2,4,2,2,0.333333,0.666667,0.500000,1 7 15 18,1 3 7 10 +10,Poetic,Creative,Contextual,8,same,8,3,-5,3,5,0,5,0.375000,0.625000,0.375000,4 6 9 13 23 28 31 34,13 28 31 +10,Poetic,Creative,Contextual,8,cross,8,7,-1,5,5,2,3,0.500000,0.500000,0.625000,1 2 3 7 10 11 15 16,1 3 7 10 11 21 30 +10,Poetic,Creative,Analogical,1,same,1,1,0,0,2,1,1,0.000000,1.000000,0.000000,4,13 +10,Poetic,Creative,Analogical,1,cross,1,1,0,1,0,0,0,1.000000,0.000000,1.000000,3,3 +10,Poetic,Creative,Analogical,2,same,2,2,0,0,4,2,2,0.000000,1.000000,0.000000,4 23,13 28 +10,Poetic,Creative,Analogical,2,cross,2,2,0,2,0,0,0,1.000000,0.000000,1.000000,3 7,3 7 +10,Poetic,Creative,Analogical,3,same,3,3,0,0,6,3,3,0.000000,1.000000,0.000000,4 9 23,13 28 31 +10,Poetic,Creative,Analogical,3,cross,2,2,0,2,0,0,0,1.000000,0.000000,1.000000,3 7,3 7 +10,Poetic,Creative,Analogical,4,same,4,3,-1,1,5,2,3,0.166667,0.833333,0.250000,4 9 23 31,13 28 31 +10,Poetic,Creative,Analogical,4,cross,2,2,0,2,0,0,0,1.000000,0.000000,1.000000,3 7,3 7 +10,Poetic,Creative,Analogical,8,same,8,3,-5,3,5,0,5,0.375000,0.625000,0.375000,4 6 9 13 23 28 31 34,13 28 31 +10,Poetic,Creative,Analogical,8,cross,2,2,0,2,0,0,0,1.000000,0.000000,1.000000,3 7,3 7 +11,Playful,Creative,Surface,1,same,1,1,0,0,2,1,1,0.000000,1.000000,0.000000,4,13 +11,Playful,Creative,Surface,1,cross,1,1,0,1,0,0,0,1.000000,0.000000,1.000000,1,1 +11,Playful,Creative,Surface,2,same,2,2,0,0,4,2,2,0.000000,1.000000,0.000000,4 23,13 28 +11,Playful,Creative,Surface,2,cross,2,2,0,1,2,1,1,0.333333,0.666667,0.500000,1 18,1 11 +11,Playful,Creative,Surface,3,same,3,3,0,0,6,3,3,0.000000,1.000000,0.000000,4 9 23,13 28 31 +11,Playful,Creative,Surface,3,cross,3,3,0,1,4,2,2,0.200000,0.800000,0.333333,1 14 22,1 7 11 +11,Playful,Creative,Surface,4,same,4,3,-1,1,5,2,3,0.166667,0.833333,0.250000,4 9 23 31,13 28 31 +11,Playful,Creative,Surface,4,cross,4,4,0,2,4,2,2,0.333333,0.666667,0.500000,1 11 17 24,1 7 11 30 +11,Playful,Creative,Surface,8,same,8,3,-5,3,5,0,5,0.375000,0.625000,0.375000,4 6 9 13 23 28 31 34,13 28 31 +11,Playful,Creative,Surface,8,cross,8,8,0,3,10,5,5,0.230769,0.769231,0.375000,1 3 10 12 15 17 19 22,1 3 7 10 11 21 30 32 +11,Playful,Creative,Shallow,1,same,1,1,0,0,2,1,1,0.000000,1.000000,0.000000,4,13 +11,Playful,Creative,Shallow,1,cross,1,1,0,1,0,0,0,1.000000,0.000000,1.000000,1,1 +11,Playful,Creative,Shallow,2,same,2,2,0,0,4,2,2,0.000000,1.000000,0.000000,4 23,13 28 +11,Playful,Creative,Shallow,2,cross,2,2,0,1,2,1,1,0.333333,0.666667,0.500000,1 18,1 11 +11,Playful,Creative,Shallow,3,same,3,3,0,0,6,3,3,0.000000,1.000000,0.000000,4 9 23,13 28 31 +11,Playful,Creative,Shallow,3,cross,3,3,0,1,4,2,2,0.200000,0.800000,0.333333,1 14 22,1 7 11 +11,Playful,Creative,Shallow,4,same,4,3,-1,1,5,2,3,0.166667,0.833333,0.250000,4 9 23 31,13 28 31 +11,Playful,Creative,Shallow,4,cross,4,4,0,2,4,2,2,0.333333,0.666667,0.500000,1 11 17 24,1 7 11 30 +11,Playful,Creative,Shallow,8,same,8,3,-5,3,5,0,5,0.375000,0.625000,0.375000,4 6 9 13 23 28 31 34,13 28 31 +11,Playful,Creative,Shallow,8,cross,8,8,0,3,10,5,5,0.230769,0.769231,0.375000,1 3 10 12 15 17 19 22,1 3 7 10 11 21 30 32 +11,Playful,Creative,Contextual,1,same,1,1,0,0,2,1,1,0.000000,1.000000,0.000000,4,13 +11,Playful,Creative,Contextual,1,cross,1,1,0,1,0,0,0,1.000000,0.000000,1.000000,1,1 +11,Playful,Creative,Contextual,2,same,2,2,0,0,4,2,2,0.000000,1.000000,0.000000,4 23,13 28 +11,Playful,Creative,Contextual,2,cross,2,2,0,1,2,1,1,0.333333,0.666667,0.500000,1 16,1 10 +11,Playful,Creative,Contextual,3,same,3,3,0,0,6,3,3,0.000000,1.000000,0.000000,4 9 23,13 28 31 +11,Playful,Creative,Contextual,3,cross,3,3,0,2,2,1,1,0.500000,0.500000,0.666667,1 11 21,1 7 11 +11,Playful,Creative,Contextual,4,same,4,3,-1,1,5,2,3,0.166667,0.833333,0.250000,4 9 23 31,13 28 31 +11,Playful,Creative,Contextual,4,cross,4,4,0,2,4,2,2,0.333333,0.666667,0.500000,1 7 15 18,1 3 7 10 +11,Playful,Creative,Contextual,8,same,8,3,-5,3,5,0,5,0.375000,0.625000,0.375000,4 6 9 13 23 28 31 34,13 28 31 +11,Playful,Creative,Contextual,8,cross,8,7,-1,5,5,2,3,0.500000,0.500000,0.625000,1 2 3 7 10 11 15 16,1 3 7 10 11 21 30 +11,Playful,Creative,Analogical,1,same,1,1,0,0,2,1,1,0.000000,1.000000,0.000000,4,13 +11,Playful,Creative,Analogical,1,cross,1,1,0,1,0,0,0,1.000000,0.000000,1.000000,3,3 +11,Playful,Creative,Analogical,2,same,2,2,0,0,4,2,2,0.000000,1.000000,0.000000,4 23,13 28 +11,Playful,Creative,Analogical,2,cross,2,2,0,2,0,0,0,1.000000,0.000000,1.000000,3 7,3 7 +11,Playful,Creative,Analogical,3,same,3,3,0,0,6,3,3,0.000000,1.000000,0.000000,4 9 23,13 28 31 +11,Playful,Creative,Analogical,3,cross,2,2,0,2,0,0,0,1.000000,0.000000,1.000000,3 7,3 7 +11,Playful,Creative,Analogical,4,same,4,3,-1,1,5,2,3,0.166667,0.833333,0.250000,4 9 23 31,13 28 31 +11,Playful,Creative,Analogical,4,cross,2,2,0,2,0,0,0,1.000000,0.000000,1.000000,3 7,3 7 +11,Playful,Creative,Analogical,8,same,8,3,-5,3,5,0,5,0.375000,0.625000,0.375000,4 6 9 13 23 28 31 34,13 28 31 +11,Playful,Creative,Analogical,8,cross,2,2,0,2,0,0,0,1.000000,0.000000,1.000000,3 7,3 7 +12,Empathetic,Empathic,Surface,1,same,1,1,0,1,0,0,0,1.000000,0.000000,1.000000,1,1 +12,Empathetic,Empathic,Surface,1,cross,1,1,0,1,0,0,0,1.000000,0.000000,1.000000,3,3 +12,Empathetic,Empathic,Surface,2,same,2,2,0,1,2,1,1,0.333333,0.666667,0.500000,1 2,1 30 +12,Empathetic,Empathic,Surface,2,cross,2,2,0,1,2,1,1,0.333333,0.666667,0.500000,3 18,3 13 +12,Empathetic,Empathic,Surface,3,same,3,2,-1,2,1,0,1,0.666667,0.333333,0.666667,1 2 30,1 30 +12,Empathetic,Empathic,Surface,3,cross,3,3,0,1,4,2,2,0.200000,0.800000,0.333333,3 14 24,3 11 28 +12,Empathetic,Empathic,Surface,4,same,3,2,-1,2,1,0,1,0.666667,0.333333,0.666667,1 2 30,1 30 +12,Empathetic,Empathic,Surface,4,cross,4,4,0,1,6,3,3,0.142857,0.857143,0.250000,3 11 17 24,3 10 13 28 +12,Empathetic,Empathic,Surface,8,same,3,2,-1,2,1,0,1,0.666667,0.333333,0.666667,1 2 30,1 30 +12,Empathetic,Empathic,Surface,8,cross,8,8,0,5,6,3,3,0.454545,0.545455,0.625000,3 7 11 14 17 21 24 28,3 7 10 11 13 21 28 31 +12,Empathetic,Empathic,Shallow,1,same,1,1,0,1,0,0,0,1.000000,0.000000,1.000000,1,1 +12,Empathetic,Empathic,Shallow,1,cross,1,1,0,1,0,0,0,1.000000,0.000000,1.000000,3,3 +12,Empathetic,Empathic,Shallow,2,same,2,2,0,1,2,1,1,0.333333,0.666667,0.500000,1 2,1 30 +12,Empathetic,Empathic,Shallow,2,cross,2,2,0,1,2,1,1,0.333333,0.666667,0.500000,3 18,3 13 +12,Empathetic,Empathic,Shallow,3,same,3,2,-1,2,1,0,1,0.666667,0.333333,0.666667,1 2 30,1 30 +12,Empathetic,Empathic,Shallow,3,cross,3,3,0,1,4,2,2,0.200000,0.800000,0.333333,3 14 24,3 11 28 +12,Empathetic,Empathic,Shallow,4,same,3,2,-1,2,1,0,1,0.666667,0.333333,0.666667,1 2 30,1 30 +12,Empathetic,Empathic,Shallow,4,cross,4,4,0,1,6,3,3,0.142857,0.857143,0.250000,3 11 17 24,3 10 13 28 +12,Empathetic,Empathic,Shallow,8,same,3,2,-1,2,1,0,1,0.666667,0.333333,0.666667,1 2 30,1 30 +12,Empathetic,Empathic,Shallow,8,cross,8,8,0,5,6,3,3,0.454545,0.545455,0.625000,3 7 11 14 17 21 24 28,3 7 10 11 13 21 28 31 +12,Empathetic,Empathic,Contextual,1,same,1,1,0,1,0,0,0,1.000000,0.000000,1.000000,1,1 +12,Empathetic,Empathic,Contextual,1,cross,1,1,0,1,0,0,0,1.000000,0.000000,1.000000,3,3 +12,Empathetic,Empathic,Contextual,2,same,2,2,0,1,2,1,1,0.333333,0.666667,0.500000,1 2,1 30 +12,Empathetic,Empathic,Contextual,2,cross,2,2,0,1,2,1,1,0.333333,0.666667,0.500000,3 17,3 13 +12,Empathetic,Empathic,Contextual,3,same,3,2,-1,2,1,0,1,0.666667,0.333333,0.666667,1 2 30,1 30 +12,Empathetic,Empathic,Contextual,3,cross,3,3,0,1,4,2,2,0.200000,0.800000,0.333333,3 11 21,3 10 13 +12,Empathetic,Empathic,Contextual,4,same,3,2,-1,2,1,0,1,0.666667,0.333333,0.666667,1 2 30,1 30 +12,Empathetic,Empathic,Contextual,4,cross,4,4,0,3,2,1,1,0.600000,0.400000,0.750000,3 10 17 28,3 10 13 28 +12,Empathetic,Empathic,Contextual,8,same,3,2,-1,2,1,0,1,0.666667,0.333333,0.666667,1 2 30,1 30 +12,Empathetic,Empathic,Contextual,8,cross,8,8,0,3,10,5,5,0.230769,0.769231,0.375000,3 6 9 11 15 17 21 23,3 7 10 11 13 21 28 31 +12,Empathetic,Empathic,Analogical,1,same,0,0,0,0,0,0,0,1.000000,0.000000,1.000000,, +12,Empathetic,Empathic,Analogical,1,cross,1,1,0,1,0,0,0,1.000000,0.000000,1.000000,3,3 +12,Empathetic,Empathic,Analogical,2,same,0,0,0,0,0,0,0,1.000000,0.000000,1.000000,, +12,Empathetic,Empathic,Analogical,2,cross,2,2,0,2,0,0,0,1.000000,0.000000,1.000000,3 13,3 13 +12,Empathetic,Empathic,Analogical,3,same,0,0,0,0,0,0,0,1.000000,0.000000,1.000000,, +12,Empathetic,Empathic,Analogical,3,cross,3,3,0,2,2,1,1,0.500000,0.500000,0.666667,3 7 23,3 7 13 +12,Empathetic,Empathic,Analogical,4,same,0,0,0,0,0,0,0,1.000000,0.000000,1.000000,, +12,Empathetic,Empathic,Analogical,4,cross,4,4,0,1,6,3,3,0.142857,0.857143,0.250000,3 6 9 23,3 7 13 28 +12,Empathetic,Empathic,Analogical,8,same,0,0,0,0,0,0,0,1.000000,0.000000,1.000000,, +12,Empathetic,Empathic,Analogical,8,cross,8,5,-3,4,5,1,4,0.444444,0.555556,0.500000,3 4 6 7 9 13 23 28,3 7 13 28 31 +13,Compassionate,Empathic,Surface,1,same,1,1,0,1,0,0,0,1.000000,0.000000,1.000000,1,1 +13,Compassionate,Empathic,Surface,1,cross,1,1,0,1,0,0,0,1.000000,0.000000,1.000000,3,3 +13,Compassionate,Empathic,Surface,2,same,2,2,0,1,2,1,1,0.333333,0.666667,0.500000,1 2,1 30 +13,Compassionate,Empathic,Surface,2,cross,2,2,0,1,2,1,1,0.333333,0.666667,0.500000,3 18,3 13 +13,Compassionate,Empathic,Surface,3,same,3,2,-1,2,1,0,1,0.666667,0.333333,0.666667,1 2 30,1 30 +13,Compassionate,Empathic,Surface,3,cross,3,3,0,1,4,2,2,0.200000,0.800000,0.333333,3 14 24,3 11 28 +13,Compassionate,Empathic,Surface,4,same,3,2,-1,2,1,0,1,0.666667,0.333333,0.666667,1 2 30,1 30 +13,Compassionate,Empathic,Surface,4,cross,4,4,0,1,6,3,3,0.142857,0.857143,0.250000,3 11 17 24,3 10 13 28 +13,Compassionate,Empathic,Surface,8,same,3,2,-1,2,1,0,1,0.666667,0.333333,0.666667,1 2 30,1 30 +13,Compassionate,Empathic,Surface,8,cross,8,8,0,5,6,3,3,0.454545,0.545455,0.625000,3 7 11 14 17 21 24 28,3 7 10 11 13 21 28 31 +13,Compassionate,Empathic,Shallow,1,same,1,1,0,1,0,0,0,1.000000,0.000000,1.000000,1,1 +13,Compassionate,Empathic,Shallow,1,cross,1,1,0,1,0,0,0,1.000000,0.000000,1.000000,3,3 +13,Compassionate,Empathic,Shallow,2,same,2,2,0,1,2,1,1,0.333333,0.666667,0.500000,1 2,1 30 +13,Compassionate,Empathic,Shallow,2,cross,2,2,0,1,2,1,1,0.333333,0.666667,0.500000,3 18,3 13 +13,Compassionate,Empathic,Shallow,3,same,3,2,-1,2,1,0,1,0.666667,0.333333,0.666667,1 2 30,1 30 +13,Compassionate,Empathic,Shallow,3,cross,3,3,0,1,4,2,2,0.200000,0.800000,0.333333,3 14 24,3 11 28 +13,Compassionate,Empathic,Shallow,4,same,3,2,-1,2,1,0,1,0.666667,0.333333,0.666667,1 2 30,1 30 +13,Compassionate,Empathic,Shallow,4,cross,4,4,0,1,6,3,3,0.142857,0.857143,0.250000,3 11 17 24,3 10 13 28 +13,Compassionate,Empathic,Shallow,8,same,3,2,-1,2,1,0,1,0.666667,0.333333,0.666667,1 2 30,1 30 +13,Compassionate,Empathic,Shallow,8,cross,8,8,0,5,6,3,3,0.454545,0.545455,0.625000,3 7 11 14 17 21 24 28,3 7 10 11 13 21 28 31 +13,Compassionate,Empathic,Contextual,1,same,1,1,0,1,0,0,0,1.000000,0.000000,1.000000,1,1 +13,Compassionate,Empathic,Contextual,1,cross,1,1,0,1,0,0,0,1.000000,0.000000,1.000000,3,3 +13,Compassionate,Empathic,Contextual,2,same,2,2,0,1,2,1,1,0.333333,0.666667,0.500000,1 2,1 30 +13,Compassionate,Empathic,Contextual,2,cross,2,2,0,1,2,1,1,0.333333,0.666667,0.500000,3 17,3 13 +13,Compassionate,Empathic,Contextual,3,same,3,2,-1,2,1,0,1,0.666667,0.333333,0.666667,1 2 30,1 30 +13,Compassionate,Empathic,Contextual,3,cross,3,3,0,1,4,2,2,0.200000,0.800000,0.333333,3 11 21,3 10 13 +13,Compassionate,Empathic,Contextual,4,same,3,2,-1,2,1,0,1,0.666667,0.333333,0.666667,1 2 30,1 30 +13,Compassionate,Empathic,Contextual,4,cross,4,4,0,3,2,1,1,0.600000,0.400000,0.750000,3 10 17 28,3 10 13 28 +13,Compassionate,Empathic,Contextual,8,same,3,2,-1,2,1,0,1,0.666667,0.333333,0.666667,1 2 30,1 30 +13,Compassionate,Empathic,Contextual,8,cross,8,8,0,3,10,5,5,0.230769,0.769231,0.375000,3 6 9 11 15 17 21 23,3 7 10 11 13 21 28 31 +13,Compassionate,Empathic,Analogical,1,same,0,0,0,0,0,0,0,1.000000,0.000000,1.000000,, +13,Compassionate,Empathic,Analogical,1,cross,1,1,0,1,0,0,0,1.000000,0.000000,1.000000,3,3 +13,Compassionate,Empathic,Analogical,2,same,0,0,0,0,0,0,0,1.000000,0.000000,1.000000,, +13,Compassionate,Empathic,Analogical,2,cross,2,2,0,2,0,0,0,1.000000,0.000000,1.000000,3 13,3 13 +13,Compassionate,Empathic,Analogical,3,same,0,0,0,0,0,0,0,1.000000,0.000000,1.000000,, +13,Compassionate,Empathic,Analogical,3,cross,3,3,0,2,2,1,1,0.500000,0.500000,0.666667,3 7 23,3 7 13 +13,Compassionate,Empathic,Analogical,4,same,0,0,0,0,0,0,0,1.000000,0.000000,1.000000,, +13,Compassionate,Empathic,Analogical,4,cross,4,4,0,1,6,3,3,0.142857,0.857143,0.250000,3 6 9 23,3 7 13 28 +13,Compassionate,Empathic,Analogical,8,same,0,0,0,0,0,0,0,1.000000,0.000000,1.000000,, +13,Compassionate,Empathic,Analogical,8,cross,8,5,-3,4,5,1,4,0.444444,0.555556,0.500000,3 4 6 7 9 13 23 28,3 7 13 28 31 +14,Supportive,Empathic,Surface,1,same,1,1,0,1,0,0,0,1.000000,0.000000,1.000000,1,1 +14,Supportive,Empathic,Surface,1,cross,1,1,0,1,0,0,0,1.000000,0.000000,1.000000,3,3 +14,Supportive,Empathic,Surface,2,same,2,2,0,1,2,1,1,0.333333,0.666667,0.500000,1 2,1 30 +14,Supportive,Empathic,Surface,2,cross,2,2,0,1,2,1,1,0.333333,0.666667,0.500000,3 18,3 13 +14,Supportive,Empathic,Surface,3,same,3,2,-1,2,1,0,1,0.666667,0.333333,0.666667,1 2 30,1 30 +14,Supportive,Empathic,Surface,3,cross,3,3,0,1,4,2,2,0.200000,0.800000,0.333333,3 14 24,3 11 28 +14,Supportive,Empathic,Surface,4,same,3,2,-1,2,1,0,1,0.666667,0.333333,0.666667,1 2 30,1 30 +14,Supportive,Empathic,Surface,4,cross,4,4,0,1,6,3,3,0.142857,0.857143,0.250000,3 11 17 24,3 10 13 28 +14,Supportive,Empathic,Surface,8,same,3,2,-1,2,1,0,1,0.666667,0.333333,0.666667,1 2 30,1 30 +14,Supportive,Empathic,Surface,8,cross,8,8,0,5,6,3,3,0.454545,0.545455,0.625000,3 7 11 14 17 21 24 28,3 7 10 11 13 21 28 31 +14,Supportive,Empathic,Shallow,1,same,1,1,0,1,0,0,0,1.000000,0.000000,1.000000,1,1 +14,Supportive,Empathic,Shallow,1,cross,1,1,0,1,0,0,0,1.000000,0.000000,1.000000,3,3 +14,Supportive,Empathic,Shallow,2,same,2,2,0,1,2,1,1,0.333333,0.666667,0.500000,1 2,1 30 +14,Supportive,Empathic,Shallow,2,cross,2,2,0,1,2,1,1,0.333333,0.666667,0.500000,3 18,3 13 +14,Supportive,Empathic,Shallow,3,same,3,2,-1,2,1,0,1,0.666667,0.333333,0.666667,1 2 30,1 30 +14,Supportive,Empathic,Shallow,3,cross,3,3,0,1,4,2,2,0.200000,0.800000,0.333333,3 14 24,3 11 28 +14,Supportive,Empathic,Shallow,4,same,3,2,-1,2,1,0,1,0.666667,0.333333,0.666667,1 2 30,1 30 +14,Supportive,Empathic,Shallow,4,cross,4,4,0,1,6,3,3,0.142857,0.857143,0.250000,3 11 17 24,3 10 13 28 +14,Supportive,Empathic,Shallow,8,same,3,2,-1,2,1,0,1,0.666667,0.333333,0.666667,1 2 30,1 30 +14,Supportive,Empathic,Shallow,8,cross,8,8,0,5,6,3,3,0.454545,0.545455,0.625000,3 7 11 14 17 21 24 28,3 7 10 11 13 21 28 31 +14,Supportive,Empathic,Contextual,1,same,1,1,0,1,0,0,0,1.000000,0.000000,1.000000,1,1 +14,Supportive,Empathic,Contextual,1,cross,1,1,0,1,0,0,0,1.000000,0.000000,1.000000,3,3 +14,Supportive,Empathic,Contextual,2,same,2,2,0,1,2,1,1,0.333333,0.666667,0.500000,1 2,1 30 +14,Supportive,Empathic,Contextual,2,cross,2,2,0,1,2,1,1,0.333333,0.666667,0.500000,3 17,3 13 +14,Supportive,Empathic,Contextual,3,same,3,2,-1,2,1,0,1,0.666667,0.333333,0.666667,1 2 30,1 30 +14,Supportive,Empathic,Contextual,3,cross,3,3,0,1,4,2,2,0.200000,0.800000,0.333333,3 11 21,3 10 13 +14,Supportive,Empathic,Contextual,4,same,3,2,-1,2,1,0,1,0.666667,0.333333,0.666667,1 2 30,1 30 +14,Supportive,Empathic,Contextual,4,cross,4,4,0,3,2,1,1,0.600000,0.400000,0.750000,3 10 17 28,3 10 13 28 +14,Supportive,Empathic,Contextual,8,same,3,2,-1,2,1,0,1,0.666667,0.333333,0.666667,1 2 30,1 30 +14,Supportive,Empathic,Contextual,8,cross,8,8,0,3,10,5,5,0.230769,0.769231,0.375000,3 6 9 11 15 17 21 23,3 7 10 11 13 21 28 31 +14,Supportive,Empathic,Analogical,1,same,0,0,0,0,0,0,0,1.000000,0.000000,1.000000,, +14,Supportive,Empathic,Analogical,1,cross,1,1,0,1,0,0,0,1.000000,0.000000,1.000000,3,3 +14,Supportive,Empathic,Analogical,2,same,0,0,0,0,0,0,0,1.000000,0.000000,1.000000,, +14,Supportive,Empathic,Analogical,2,cross,2,2,0,2,0,0,0,1.000000,0.000000,1.000000,3 13,3 13 +14,Supportive,Empathic,Analogical,3,same,0,0,0,0,0,0,0,1.000000,0.000000,1.000000,, +14,Supportive,Empathic,Analogical,3,cross,3,3,0,2,2,1,1,0.500000,0.500000,0.666667,3 7 23,3 7 13 +14,Supportive,Empathic,Analogical,4,same,0,0,0,0,0,0,0,1.000000,0.000000,1.000000,, +14,Supportive,Empathic,Analogical,4,cross,4,4,0,1,6,3,3,0.142857,0.857143,0.250000,3 6 9 23,3 7 13 28 +14,Supportive,Empathic,Analogical,8,same,0,0,0,0,0,0,0,1.000000,0.000000,1.000000,, +14,Supportive,Empathic,Analogical,8,cross,8,5,-3,4,5,1,4,0.444444,0.555556,0.500000,3 4 6 7 9 13 23 28,3 7 13 28 31 +15,Nurturing,Empathic,Surface,1,same,1,1,0,1,0,0,0,1.000000,0.000000,1.000000,1,1 +15,Nurturing,Empathic,Surface,1,cross,1,1,0,1,0,0,0,1.000000,0.000000,1.000000,3,3 +15,Nurturing,Empathic,Surface,2,same,2,2,0,1,2,1,1,0.333333,0.666667,0.500000,1 2,1 30 +15,Nurturing,Empathic,Surface,2,cross,2,2,0,1,2,1,1,0.333333,0.666667,0.500000,3 18,3 13 +15,Nurturing,Empathic,Surface,3,same,3,2,-1,2,1,0,1,0.666667,0.333333,0.666667,1 2 30,1 30 +15,Nurturing,Empathic,Surface,3,cross,3,3,0,1,4,2,2,0.200000,0.800000,0.333333,3 14 24,3 11 28 +15,Nurturing,Empathic,Surface,4,same,3,2,-1,2,1,0,1,0.666667,0.333333,0.666667,1 2 30,1 30 +15,Nurturing,Empathic,Surface,4,cross,4,4,0,1,6,3,3,0.142857,0.857143,0.250000,3 11 17 24,3 10 13 28 +15,Nurturing,Empathic,Surface,8,same,3,2,-1,2,1,0,1,0.666667,0.333333,0.666667,1 2 30,1 30 +15,Nurturing,Empathic,Surface,8,cross,8,8,0,5,6,3,3,0.454545,0.545455,0.625000,3 7 11 14 17 21 24 28,3 7 10 11 13 21 28 31 +15,Nurturing,Empathic,Shallow,1,same,1,1,0,1,0,0,0,1.000000,0.000000,1.000000,1,1 +15,Nurturing,Empathic,Shallow,1,cross,1,1,0,1,0,0,0,1.000000,0.000000,1.000000,3,3 +15,Nurturing,Empathic,Shallow,2,same,2,2,0,1,2,1,1,0.333333,0.666667,0.500000,1 2,1 30 +15,Nurturing,Empathic,Shallow,2,cross,2,2,0,1,2,1,1,0.333333,0.666667,0.500000,3 18,3 13 +15,Nurturing,Empathic,Shallow,3,same,3,2,-1,2,1,0,1,0.666667,0.333333,0.666667,1 2 30,1 30 +15,Nurturing,Empathic,Shallow,3,cross,3,3,0,1,4,2,2,0.200000,0.800000,0.333333,3 14 24,3 11 28 +15,Nurturing,Empathic,Shallow,4,same,3,2,-1,2,1,0,1,0.666667,0.333333,0.666667,1 2 30,1 30 +15,Nurturing,Empathic,Shallow,4,cross,4,4,0,1,6,3,3,0.142857,0.857143,0.250000,3 11 17 24,3 10 13 28 +15,Nurturing,Empathic,Shallow,8,same,3,2,-1,2,1,0,1,0.666667,0.333333,0.666667,1 2 30,1 30 +15,Nurturing,Empathic,Shallow,8,cross,8,8,0,5,6,3,3,0.454545,0.545455,0.625000,3 7 11 14 17 21 24 28,3 7 10 11 13 21 28 31 +15,Nurturing,Empathic,Contextual,1,same,1,1,0,1,0,0,0,1.000000,0.000000,1.000000,1,1 +15,Nurturing,Empathic,Contextual,1,cross,1,1,0,1,0,0,0,1.000000,0.000000,1.000000,3,3 +15,Nurturing,Empathic,Contextual,2,same,2,2,0,1,2,1,1,0.333333,0.666667,0.500000,1 2,1 30 +15,Nurturing,Empathic,Contextual,2,cross,2,2,0,1,2,1,1,0.333333,0.666667,0.500000,3 17,3 13 +15,Nurturing,Empathic,Contextual,3,same,3,2,-1,2,1,0,1,0.666667,0.333333,0.666667,1 2 30,1 30 +15,Nurturing,Empathic,Contextual,3,cross,3,3,0,1,4,2,2,0.200000,0.800000,0.333333,3 11 21,3 10 13 +15,Nurturing,Empathic,Contextual,4,same,3,2,-1,2,1,0,1,0.666667,0.333333,0.666667,1 2 30,1 30 +15,Nurturing,Empathic,Contextual,4,cross,4,4,0,3,2,1,1,0.600000,0.400000,0.750000,3 10 17 28,3 10 13 28 +15,Nurturing,Empathic,Contextual,8,same,3,2,-1,2,1,0,1,0.666667,0.333333,0.666667,1 2 30,1 30 +15,Nurturing,Empathic,Contextual,8,cross,8,8,0,3,10,5,5,0.230769,0.769231,0.375000,3 6 9 11 15 17 21 23,3 7 10 11 13 21 28 31 +15,Nurturing,Empathic,Analogical,1,same,0,0,0,0,0,0,0,1.000000,0.000000,1.000000,, +15,Nurturing,Empathic,Analogical,1,cross,1,1,0,1,0,0,0,1.000000,0.000000,1.000000,3,3 +15,Nurturing,Empathic,Analogical,2,same,0,0,0,0,0,0,0,1.000000,0.000000,1.000000,, +15,Nurturing,Empathic,Analogical,2,cross,2,2,0,2,0,0,0,1.000000,0.000000,1.000000,3 13,3 13 +15,Nurturing,Empathic,Analogical,3,same,0,0,0,0,0,0,0,1.000000,0.000000,1.000000,, +15,Nurturing,Empathic,Analogical,3,cross,3,3,0,2,2,1,1,0.500000,0.500000,0.666667,3 7 23,3 7 13 +15,Nurturing,Empathic,Analogical,4,same,0,0,0,0,0,0,0,1.000000,0.000000,1.000000,, +15,Nurturing,Empathic,Analogical,4,cross,4,4,0,1,6,3,3,0.142857,0.857143,0.250000,3 6 9 23,3 7 13 28 +15,Nurturing,Empathic,Analogical,8,same,0,0,0,0,0,0,0,1.000000,0.000000,1.000000,, +15,Nurturing,Empathic,Analogical,8,cross,8,5,-3,4,5,1,4,0.444444,0.555556,0.500000,3 4 6 7 9 13 23 28,3 7 13 28 31 +16,Gentle,Empathic,Surface,1,same,1,1,0,1,0,0,0,1.000000,0.000000,1.000000,1,1 +16,Gentle,Empathic,Surface,1,cross,1,1,0,1,0,0,0,1.000000,0.000000,1.000000,3,3 +16,Gentle,Empathic,Surface,2,same,2,2,0,1,2,1,1,0.333333,0.666667,0.500000,1 2,1 30 +16,Gentle,Empathic,Surface,2,cross,2,2,0,1,2,1,1,0.333333,0.666667,0.500000,3 18,3 13 +16,Gentle,Empathic,Surface,3,same,3,2,-1,2,1,0,1,0.666667,0.333333,0.666667,1 2 30,1 30 +16,Gentle,Empathic,Surface,3,cross,3,3,0,1,4,2,2,0.200000,0.800000,0.333333,3 14 24,3 11 28 +16,Gentle,Empathic,Surface,4,same,3,2,-1,2,1,0,1,0.666667,0.333333,0.666667,1 2 30,1 30 +16,Gentle,Empathic,Surface,4,cross,4,4,0,1,6,3,3,0.142857,0.857143,0.250000,3 11 17 24,3 10 13 28 +16,Gentle,Empathic,Surface,8,same,3,2,-1,2,1,0,1,0.666667,0.333333,0.666667,1 2 30,1 30 +16,Gentle,Empathic,Surface,8,cross,8,8,0,5,6,3,3,0.454545,0.545455,0.625000,3 7 11 14 17 21 24 28,3 7 10 11 13 21 28 31 +16,Gentle,Empathic,Shallow,1,same,1,1,0,1,0,0,0,1.000000,0.000000,1.000000,1,1 +16,Gentle,Empathic,Shallow,1,cross,1,1,0,1,0,0,0,1.000000,0.000000,1.000000,3,3 +16,Gentle,Empathic,Shallow,2,same,2,2,0,1,2,1,1,0.333333,0.666667,0.500000,1 2,1 30 +16,Gentle,Empathic,Shallow,2,cross,2,2,0,1,2,1,1,0.333333,0.666667,0.500000,3 18,3 13 +16,Gentle,Empathic,Shallow,3,same,3,2,-1,2,1,0,1,0.666667,0.333333,0.666667,1 2 30,1 30 +16,Gentle,Empathic,Shallow,3,cross,3,3,0,1,4,2,2,0.200000,0.800000,0.333333,3 14 24,3 11 28 +16,Gentle,Empathic,Shallow,4,same,3,2,-1,2,1,0,1,0.666667,0.333333,0.666667,1 2 30,1 30 +16,Gentle,Empathic,Shallow,4,cross,4,4,0,1,6,3,3,0.142857,0.857143,0.250000,3 11 17 24,3 10 13 28 +16,Gentle,Empathic,Shallow,8,same,3,2,-1,2,1,0,1,0.666667,0.333333,0.666667,1 2 30,1 30 +16,Gentle,Empathic,Shallow,8,cross,8,8,0,5,6,3,3,0.454545,0.545455,0.625000,3 7 11 14 17 21 24 28,3 7 10 11 13 21 28 31 +16,Gentle,Empathic,Contextual,1,same,1,1,0,1,0,0,0,1.000000,0.000000,1.000000,1,1 +16,Gentle,Empathic,Contextual,1,cross,1,1,0,1,0,0,0,1.000000,0.000000,1.000000,3,3 +16,Gentle,Empathic,Contextual,2,same,2,2,0,1,2,1,1,0.333333,0.666667,0.500000,1 2,1 30 +16,Gentle,Empathic,Contextual,2,cross,2,2,0,1,2,1,1,0.333333,0.666667,0.500000,3 17,3 13 +16,Gentle,Empathic,Contextual,3,same,3,2,-1,2,1,0,1,0.666667,0.333333,0.666667,1 2 30,1 30 +16,Gentle,Empathic,Contextual,3,cross,3,3,0,1,4,2,2,0.200000,0.800000,0.333333,3 11 21,3 10 13 +16,Gentle,Empathic,Contextual,4,same,3,2,-1,2,1,0,1,0.666667,0.333333,0.666667,1 2 30,1 30 +16,Gentle,Empathic,Contextual,4,cross,4,4,0,3,2,1,1,0.600000,0.400000,0.750000,3 10 17 28,3 10 13 28 +16,Gentle,Empathic,Contextual,8,same,3,2,-1,2,1,0,1,0.666667,0.333333,0.666667,1 2 30,1 30 +16,Gentle,Empathic,Contextual,8,cross,8,8,0,3,10,5,5,0.230769,0.769231,0.375000,3 6 9 11 15 17 21 23,3 7 10 11 13 21 28 31 +16,Gentle,Empathic,Analogical,1,same,0,0,0,0,0,0,0,1.000000,0.000000,1.000000,, +16,Gentle,Empathic,Analogical,1,cross,1,1,0,1,0,0,0,1.000000,0.000000,1.000000,3,3 +16,Gentle,Empathic,Analogical,2,same,0,0,0,0,0,0,0,1.000000,0.000000,1.000000,, +16,Gentle,Empathic,Analogical,2,cross,2,2,0,2,0,0,0,1.000000,0.000000,1.000000,3 13,3 13 +16,Gentle,Empathic,Analogical,3,same,0,0,0,0,0,0,0,1.000000,0.000000,1.000000,, +16,Gentle,Empathic,Analogical,3,cross,3,3,0,2,2,1,1,0.500000,0.500000,0.666667,3 7 23,3 7 13 +16,Gentle,Empathic,Analogical,4,same,0,0,0,0,0,0,0,1.000000,0.000000,1.000000,, +16,Gentle,Empathic,Analogical,4,cross,4,4,0,1,6,3,3,0.142857,0.857143,0.250000,3 6 9 23,3 7 13 28 +16,Gentle,Empathic,Analogical,8,same,0,0,0,0,0,0,0,1.000000,0.000000,1.000000,, +16,Gentle,Empathic,Analogical,8,cross,8,5,-3,4,5,1,4,0.444444,0.555556,0.500000,3 4 6 7 9 13 23 28,3 7 13 28 31 +17,Warm,Empathic,Surface,1,same,1,1,0,1,0,0,0,1.000000,0.000000,1.000000,1,1 +17,Warm,Empathic,Surface,1,cross,1,1,0,1,0,0,0,1.000000,0.000000,1.000000,3,3 +17,Warm,Empathic,Surface,2,same,2,2,0,1,2,1,1,0.333333,0.666667,0.500000,1 2,1 30 +17,Warm,Empathic,Surface,2,cross,2,2,0,1,2,1,1,0.333333,0.666667,0.500000,3 18,3 13 +17,Warm,Empathic,Surface,3,same,3,2,-1,2,1,0,1,0.666667,0.333333,0.666667,1 2 30,1 30 +17,Warm,Empathic,Surface,3,cross,3,3,0,1,4,2,2,0.200000,0.800000,0.333333,3 14 24,3 11 28 +17,Warm,Empathic,Surface,4,same,3,2,-1,2,1,0,1,0.666667,0.333333,0.666667,1 2 30,1 30 +17,Warm,Empathic,Surface,4,cross,4,4,0,1,6,3,3,0.142857,0.857143,0.250000,3 11 17 24,3 10 13 28 +17,Warm,Empathic,Surface,8,same,3,2,-1,2,1,0,1,0.666667,0.333333,0.666667,1 2 30,1 30 +17,Warm,Empathic,Surface,8,cross,8,8,0,5,6,3,3,0.454545,0.545455,0.625000,3 7 11 14 17 21 24 28,3 7 10 11 13 21 28 31 +17,Warm,Empathic,Shallow,1,same,1,1,0,1,0,0,0,1.000000,0.000000,1.000000,1,1 +17,Warm,Empathic,Shallow,1,cross,1,1,0,1,0,0,0,1.000000,0.000000,1.000000,3,3 +17,Warm,Empathic,Shallow,2,same,2,2,0,1,2,1,1,0.333333,0.666667,0.500000,1 2,1 30 +17,Warm,Empathic,Shallow,2,cross,2,2,0,1,2,1,1,0.333333,0.666667,0.500000,3 18,3 13 +17,Warm,Empathic,Shallow,3,same,3,2,-1,2,1,0,1,0.666667,0.333333,0.666667,1 2 30,1 30 +17,Warm,Empathic,Shallow,3,cross,3,3,0,1,4,2,2,0.200000,0.800000,0.333333,3 14 24,3 11 28 +17,Warm,Empathic,Shallow,4,same,3,2,-1,2,1,0,1,0.666667,0.333333,0.666667,1 2 30,1 30 +17,Warm,Empathic,Shallow,4,cross,4,4,0,1,6,3,3,0.142857,0.857143,0.250000,3 11 17 24,3 10 13 28 +17,Warm,Empathic,Shallow,8,same,3,2,-1,2,1,0,1,0.666667,0.333333,0.666667,1 2 30,1 30 +17,Warm,Empathic,Shallow,8,cross,8,8,0,5,6,3,3,0.454545,0.545455,0.625000,3 7 11 14 17 21 24 28,3 7 10 11 13 21 28 31 +17,Warm,Empathic,Contextual,1,same,1,1,0,1,0,0,0,1.000000,0.000000,1.000000,1,1 +17,Warm,Empathic,Contextual,1,cross,1,1,0,1,0,0,0,1.000000,0.000000,1.000000,3,3 +17,Warm,Empathic,Contextual,2,same,2,2,0,1,2,1,1,0.333333,0.666667,0.500000,1 2,1 30 +17,Warm,Empathic,Contextual,2,cross,2,2,0,1,2,1,1,0.333333,0.666667,0.500000,3 17,3 13 +17,Warm,Empathic,Contextual,3,same,3,2,-1,2,1,0,1,0.666667,0.333333,0.666667,1 2 30,1 30 +17,Warm,Empathic,Contextual,3,cross,3,3,0,1,4,2,2,0.200000,0.800000,0.333333,3 11 21,3 10 13 +17,Warm,Empathic,Contextual,4,same,3,2,-1,2,1,0,1,0.666667,0.333333,0.666667,1 2 30,1 30 +17,Warm,Empathic,Contextual,4,cross,4,4,0,3,2,1,1,0.600000,0.400000,0.750000,3 10 17 28,3 10 13 28 +17,Warm,Empathic,Contextual,8,same,3,2,-1,2,1,0,1,0.666667,0.333333,0.666667,1 2 30,1 30 +17,Warm,Empathic,Contextual,8,cross,8,8,0,3,10,5,5,0.230769,0.769231,0.375000,3 6 9 11 15 17 21 23,3 7 10 11 13 21 28 31 +17,Warm,Empathic,Analogical,1,same,0,0,0,0,0,0,0,1.000000,0.000000,1.000000,, +17,Warm,Empathic,Analogical,1,cross,1,1,0,1,0,0,0,1.000000,0.000000,1.000000,3,3 +17,Warm,Empathic,Analogical,2,same,0,0,0,0,0,0,0,1.000000,0.000000,1.000000,, +17,Warm,Empathic,Analogical,2,cross,2,2,0,2,0,0,0,1.000000,0.000000,1.000000,3 13,3 13 +17,Warm,Empathic,Analogical,3,same,0,0,0,0,0,0,0,1.000000,0.000000,1.000000,, +17,Warm,Empathic,Analogical,3,cross,3,3,0,2,2,1,1,0.500000,0.500000,0.666667,3 7 23,3 7 13 +17,Warm,Empathic,Analogical,4,same,0,0,0,0,0,0,0,1.000000,0.000000,1.000000,, +17,Warm,Empathic,Analogical,4,cross,4,4,0,1,6,3,3,0.142857,0.857143,0.250000,3 6 9 23,3 7 13 28 +17,Warm,Empathic,Analogical,8,same,0,0,0,0,0,0,0,1.000000,0.000000,1.000000,, +17,Warm,Empathic,Analogical,8,cross,8,5,-3,4,5,1,4,0.444444,0.555556,0.500000,3 4 6 7 9 13 23 28,3 7 13 28 31 +18,Direct,Direct,Surface,1,same,1,1,0,1,0,0,0,1.000000,0.000000,1.000000,3,3 +18,Direct,Direct,Surface,1,cross,1,1,0,1,0,0,0,1.000000,0.000000,1.000000,1,1 +18,Direct,Direct,Surface,2,same,2,2,0,1,2,1,1,0.333333,0.666667,0.500000,3 11,3 10 +18,Direct,Direct,Surface,2,cross,2,2,0,1,2,1,1,0.333333,0.666667,0.500000,1 22,1 30 +18,Direct,Direct,Surface,3,same,3,3,0,2,2,1,1,0.500000,0.500000,0.666667,3 10 17,3 7 10 +18,Direct,Direct,Surface,3,cross,3,3,0,1,4,2,2,0.200000,0.800000,0.333333,1 15 27,1 28 31 +18,Direct,Direct,Surface,4,same,4,4,0,4,0,0,0,1.000000,0.000000,1.000000,3 7 10 11,3 7 10 11 +18,Direct,Direct,Surface,4,cross,4,4,0,2,4,2,2,0.333333,0.666667,0.500000,1 13 22 29,1 13 28 30 +18,Direct,Direct,Surface,8,same,6,5,-1,5,1,0,1,0.833333,0.166667,0.833333,3 7 10 11 17 21,3 7 10 11 21 +18,Direct,Direct,Surface,8,cross,8,6,-2,3,8,3,5,0.272727,0.727273,0.375000,1 6 13 16 22 25 29 32,1 13 28 30 31 32 +18,Direct,Direct,Shallow,1,same,1,1,0,1,0,0,0,1.000000,0.000000,1.000000,3,3 +18,Direct,Direct,Shallow,1,cross,1,1,0,1,0,0,0,1.000000,0.000000,1.000000,1,1 +18,Direct,Direct,Shallow,2,same,2,2,0,1,2,1,1,0.333333,0.666667,0.500000,3 11,3 10 +18,Direct,Direct,Shallow,2,cross,2,2,0,1,2,1,1,0.333333,0.666667,0.500000,1 22,1 30 +18,Direct,Direct,Shallow,3,same,3,3,0,2,2,1,1,0.500000,0.500000,0.666667,3 10 17,3 7 10 +18,Direct,Direct,Shallow,3,cross,3,3,0,1,4,2,2,0.200000,0.800000,0.333333,1 15 27,1 28 31 +18,Direct,Direct,Shallow,4,same,4,4,0,4,0,0,0,1.000000,0.000000,1.000000,3 7 10 11,3 7 10 11 +18,Direct,Direct,Shallow,4,cross,4,4,0,2,4,2,2,0.333333,0.666667,0.500000,1 13 22 29,1 13 28 30 +18,Direct,Direct,Shallow,8,same,6,5,-1,5,1,0,1,0.833333,0.166667,0.833333,3 7 10 11 17 21,3 7 10 11 21 +18,Direct,Direct,Shallow,8,cross,8,6,-2,3,8,3,5,0.272727,0.727273,0.375000,1 6 13 16 22 25 29 32,1 13 28 30 31 32 +18,Direct,Direct,Contextual,1,same,1,1,0,1,0,0,0,1.000000,0.000000,1.000000,3,3 +18,Direct,Direct,Contextual,1,cross,1,1,0,1,0,0,0,1.000000,0.000000,1.000000,1,1 +18,Direct,Direct,Contextual,2,same,2,2,0,1,2,1,1,0.333333,0.666667,0.500000,3 11,3 10 +18,Direct,Direct,Contextual,2,cross,2,2,0,1,2,1,1,0.333333,0.666667,0.500000,1 18,1 28 +18,Direct,Direct,Contextual,3,same,3,3,0,2,2,1,1,0.500000,0.500000,0.666667,3 10 17,3 7 10 +18,Direct,Direct,Contextual,3,cross,3,3,0,2,2,1,1,0.500000,0.500000,0.666667,1 13 23,1 13 28 +18,Direct,Direct,Contextual,4,same,4,4,0,4,0,0,0,1.000000,0.000000,1.000000,3 7 10 11,3 7 10 11 +18,Direct,Direct,Contextual,4,cross,4,4,0,1,6,3,3,0.142857,0.857143,0.250000,1 9 18 29,1 13 28 30 +18,Direct,Direct,Contextual,8,same,6,5,-1,5,1,0,1,0.833333,0.166667,0.833333,3 7 10 11 17 21,3 7 10 11 21 +18,Direct,Direct,Contextual,8,cross,8,5,-3,2,9,3,6,0.181818,0.818182,0.250000,1 4 9 15 18 23 29 31,1 13 28 30 31 +18,Direct,Direct,Analogical,1,same,1,1,0,1,0,0,0,1.000000,0.000000,1.000000,3,3 +18,Direct,Direct,Analogical,1,cross,1,1,0,0,2,1,1,0.000000,1.000000,0.000000,4,13 +18,Direct,Direct,Analogical,2,same,2,2,0,2,0,0,0,1.000000,0.000000,1.000000,3 7,3 7 +18,Direct,Direct,Analogical,2,cross,2,2,0,0,4,2,2,0.000000,1.000000,0.000000,4 23,13 28 +18,Direct,Direct,Analogical,3,same,2,2,0,2,0,0,0,1.000000,0.000000,1.000000,3 7,3 7 +18,Direct,Direct,Analogical,3,cross,3,3,0,0,6,3,3,0.000000,1.000000,0.000000,4 9 23,13 28 31 +18,Direct,Direct,Analogical,4,same,2,2,0,2,0,0,0,1.000000,0.000000,1.000000,3 7,3 7 +18,Direct,Direct,Analogical,4,cross,4,3,-1,1,5,2,3,0.166667,0.833333,0.250000,4 9 23 31,13 28 31 +18,Direct,Direct,Analogical,8,same,2,2,0,2,0,0,0,1.000000,0.000000,1.000000,3 7,3 7 +18,Direct,Direct,Analogical,8,cross,8,3,-5,3,5,0,5,0.375000,0.625000,0.375000,4 6 9 13 23 28 31 34,13 28 31 +19,Concise,Direct,Surface,1,same,1,1,0,1,0,0,0,1.000000,0.000000,1.000000,3,3 +19,Concise,Direct,Surface,1,cross,1,1,0,1,0,0,0,1.000000,0.000000,1.000000,1,1 +19,Concise,Direct,Surface,2,same,2,2,0,1,2,1,1,0.333333,0.666667,0.500000,3 11,3 10 +19,Concise,Direct,Surface,2,cross,2,2,0,1,2,1,1,0.333333,0.666667,0.500000,1 22,1 30 +19,Concise,Direct,Surface,3,same,3,3,0,2,2,1,1,0.500000,0.500000,0.666667,3 10 17,3 7 10 +19,Concise,Direct,Surface,3,cross,3,3,0,1,4,2,2,0.200000,0.800000,0.333333,1 15 27,1 28 31 +19,Concise,Direct,Surface,4,same,4,4,0,4,0,0,0,1.000000,0.000000,1.000000,3 7 10 11,3 7 10 11 +19,Concise,Direct,Surface,4,cross,4,4,0,2,4,2,2,0.333333,0.666667,0.500000,1 13 22 29,1 13 28 30 +19,Concise,Direct,Surface,8,same,6,5,-1,5,1,0,1,0.833333,0.166667,0.833333,3 7 10 11 17 21,3 7 10 11 21 +19,Concise,Direct,Surface,8,cross,8,6,-2,3,8,3,5,0.272727,0.727273,0.375000,1 6 13 16 22 25 29 32,1 13 28 30 31 32 +19,Concise,Direct,Shallow,1,same,1,1,0,1,0,0,0,1.000000,0.000000,1.000000,3,3 +19,Concise,Direct,Shallow,1,cross,1,1,0,1,0,0,0,1.000000,0.000000,1.000000,1,1 +19,Concise,Direct,Shallow,2,same,2,2,0,1,2,1,1,0.333333,0.666667,0.500000,3 11,3 10 +19,Concise,Direct,Shallow,2,cross,2,2,0,1,2,1,1,0.333333,0.666667,0.500000,1 22,1 30 +19,Concise,Direct,Shallow,3,same,3,3,0,2,2,1,1,0.500000,0.500000,0.666667,3 10 17,3 7 10 +19,Concise,Direct,Shallow,3,cross,3,3,0,1,4,2,2,0.200000,0.800000,0.333333,1 15 27,1 28 31 +19,Concise,Direct,Shallow,4,same,4,4,0,4,0,0,0,1.000000,0.000000,1.000000,3 7 10 11,3 7 10 11 +19,Concise,Direct,Shallow,4,cross,4,4,0,2,4,2,2,0.333333,0.666667,0.500000,1 13 22 29,1 13 28 30 +19,Concise,Direct,Shallow,8,same,6,5,-1,5,1,0,1,0.833333,0.166667,0.833333,3 7 10 11 17 21,3 7 10 11 21 +19,Concise,Direct,Shallow,8,cross,8,6,-2,3,8,3,5,0.272727,0.727273,0.375000,1 6 13 16 22 25 29 32,1 13 28 30 31 32 +19,Concise,Direct,Contextual,1,same,1,1,0,1,0,0,0,1.000000,0.000000,1.000000,3,3 +19,Concise,Direct,Contextual,1,cross,1,1,0,1,0,0,0,1.000000,0.000000,1.000000,1,1 +19,Concise,Direct,Contextual,2,same,2,2,0,1,2,1,1,0.333333,0.666667,0.500000,3 11,3 10 +19,Concise,Direct,Contextual,2,cross,2,2,0,1,2,1,1,0.333333,0.666667,0.500000,1 18,1 28 +19,Concise,Direct,Contextual,3,same,3,3,0,2,2,1,1,0.500000,0.500000,0.666667,3 10 17,3 7 10 +19,Concise,Direct,Contextual,3,cross,3,3,0,2,2,1,1,0.500000,0.500000,0.666667,1 13 23,1 13 28 +19,Concise,Direct,Contextual,4,same,4,4,0,4,0,0,0,1.000000,0.000000,1.000000,3 7 10 11,3 7 10 11 +19,Concise,Direct,Contextual,4,cross,4,4,0,1,6,3,3,0.142857,0.857143,0.250000,1 9 18 29,1 13 28 30 +19,Concise,Direct,Contextual,8,same,6,5,-1,5,1,0,1,0.833333,0.166667,0.833333,3 7 10 11 17 21,3 7 10 11 21 +19,Concise,Direct,Contextual,8,cross,8,5,-3,2,9,3,6,0.181818,0.818182,0.250000,1 4 9 15 18 23 29 31,1 13 28 30 31 +19,Concise,Direct,Analogical,1,same,1,1,0,1,0,0,0,1.000000,0.000000,1.000000,3,3 +19,Concise,Direct,Analogical,1,cross,1,1,0,0,2,1,1,0.000000,1.000000,0.000000,4,13 +19,Concise,Direct,Analogical,2,same,2,2,0,2,0,0,0,1.000000,0.000000,1.000000,3 7,3 7 +19,Concise,Direct,Analogical,2,cross,2,2,0,0,4,2,2,0.000000,1.000000,0.000000,4 23,13 28 +19,Concise,Direct,Analogical,3,same,2,2,0,2,0,0,0,1.000000,0.000000,1.000000,3 7,3 7 +19,Concise,Direct,Analogical,3,cross,3,3,0,0,6,3,3,0.000000,1.000000,0.000000,4 9 23,13 28 31 +19,Concise,Direct,Analogical,4,same,2,2,0,2,0,0,0,1.000000,0.000000,1.000000,3 7,3 7 +19,Concise,Direct,Analogical,4,cross,4,3,-1,1,5,2,3,0.166667,0.833333,0.250000,4 9 23 31,13 28 31 +19,Concise,Direct,Analogical,8,same,2,2,0,2,0,0,0,1.000000,0.000000,1.000000,3 7,3 7 +19,Concise,Direct,Analogical,8,cross,8,3,-5,3,5,0,5,0.375000,0.625000,0.375000,4 6 9 13 23 28 31 34,13 28 31 +20,Efficient,Direct,Surface,1,same,1,1,0,1,0,0,0,1.000000,0.000000,1.000000,3,3 +20,Efficient,Direct,Surface,1,cross,1,1,0,1,0,0,0,1.000000,0.000000,1.000000,1,1 +20,Efficient,Direct,Surface,2,same,2,2,0,1,2,1,1,0.333333,0.666667,0.500000,3 11,3 10 +20,Efficient,Direct,Surface,2,cross,2,2,0,1,2,1,1,0.333333,0.666667,0.500000,1 22,1 30 +20,Efficient,Direct,Surface,3,same,3,3,0,2,2,1,1,0.500000,0.500000,0.666667,3 10 17,3 7 10 +20,Efficient,Direct,Surface,3,cross,3,3,0,1,4,2,2,0.200000,0.800000,0.333333,1 15 27,1 28 31 +20,Efficient,Direct,Surface,4,same,4,4,0,4,0,0,0,1.000000,0.000000,1.000000,3 7 10 11,3 7 10 11 +20,Efficient,Direct,Surface,4,cross,4,4,0,2,4,2,2,0.333333,0.666667,0.500000,1 13 22 29,1 13 28 30 +20,Efficient,Direct,Surface,8,same,6,5,-1,5,1,0,1,0.833333,0.166667,0.833333,3 7 10 11 17 21,3 7 10 11 21 +20,Efficient,Direct,Surface,8,cross,8,6,-2,3,8,3,5,0.272727,0.727273,0.375000,1 6 13 16 22 25 29 32,1 13 28 30 31 32 +20,Efficient,Direct,Shallow,1,same,1,1,0,1,0,0,0,1.000000,0.000000,1.000000,3,3 +20,Efficient,Direct,Shallow,1,cross,1,1,0,1,0,0,0,1.000000,0.000000,1.000000,1,1 +20,Efficient,Direct,Shallow,2,same,2,2,0,1,2,1,1,0.333333,0.666667,0.500000,3 11,3 10 +20,Efficient,Direct,Shallow,2,cross,2,2,0,1,2,1,1,0.333333,0.666667,0.500000,1 22,1 30 +20,Efficient,Direct,Shallow,3,same,3,3,0,2,2,1,1,0.500000,0.500000,0.666667,3 10 17,3 7 10 +20,Efficient,Direct,Shallow,3,cross,3,3,0,1,4,2,2,0.200000,0.800000,0.333333,1 15 27,1 28 31 +20,Efficient,Direct,Shallow,4,same,4,4,0,4,0,0,0,1.000000,0.000000,1.000000,3 7 10 11,3 7 10 11 +20,Efficient,Direct,Shallow,4,cross,4,4,0,2,4,2,2,0.333333,0.666667,0.500000,1 13 22 29,1 13 28 30 +20,Efficient,Direct,Shallow,8,same,6,5,-1,5,1,0,1,0.833333,0.166667,0.833333,3 7 10 11 17 21,3 7 10 11 21 +20,Efficient,Direct,Shallow,8,cross,8,6,-2,3,8,3,5,0.272727,0.727273,0.375000,1 6 13 16 22 25 29 32,1 13 28 30 31 32 +20,Efficient,Direct,Contextual,1,same,1,1,0,1,0,0,0,1.000000,0.000000,1.000000,3,3 +20,Efficient,Direct,Contextual,1,cross,1,1,0,1,0,0,0,1.000000,0.000000,1.000000,1,1 +20,Efficient,Direct,Contextual,2,same,2,2,0,1,2,1,1,0.333333,0.666667,0.500000,3 11,3 10 +20,Efficient,Direct,Contextual,2,cross,2,2,0,1,2,1,1,0.333333,0.666667,0.500000,1 18,1 28 +20,Efficient,Direct,Contextual,3,same,3,3,0,2,2,1,1,0.500000,0.500000,0.666667,3 10 17,3 7 10 +20,Efficient,Direct,Contextual,3,cross,3,3,0,2,2,1,1,0.500000,0.500000,0.666667,1 13 23,1 13 28 +20,Efficient,Direct,Contextual,4,same,4,4,0,4,0,0,0,1.000000,0.000000,1.000000,3 7 10 11,3 7 10 11 +20,Efficient,Direct,Contextual,4,cross,4,4,0,1,6,3,3,0.142857,0.857143,0.250000,1 9 18 29,1 13 28 30 +20,Efficient,Direct,Contextual,8,same,6,5,-1,5,1,0,1,0.833333,0.166667,0.833333,3 7 10 11 17 21,3 7 10 11 21 +20,Efficient,Direct,Contextual,8,cross,8,5,-3,2,9,3,6,0.181818,0.818182,0.250000,1 4 9 15 18 23 29 31,1 13 28 30 31 +20,Efficient,Direct,Analogical,1,same,1,1,0,1,0,0,0,1.000000,0.000000,1.000000,3,3 +20,Efficient,Direct,Analogical,1,cross,1,1,0,0,2,1,1,0.000000,1.000000,0.000000,4,13 +20,Efficient,Direct,Analogical,2,same,2,2,0,2,0,0,0,1.000000,0.000000,1.000000,3 7,3 7 +20,Efficient,Direct,Analogical,2,cross,2,2,0,0,4,2,2,0.000000,1.000000,0.000000,4 23,13 28 +20,Efficient,Direct,Analogical,3,same,2,2,0,2,0,0,0,1.000000,0.000000,1.000000,3 7,3 7 +20,Efficient,Direct,Analogical,3,cross,3,3,0,0,6,3,3,0.000000,1.000000,0.000000,4 9 23,13 28 31 +20,Efficient,Direct,Analogical,4,same,2,2,0,2,0,0,0,1.000000,0.000000,1.000000,3 7,3 7 +20,Efficient,Direct,Analogical,4,cross,4,3,-1,1,5,2,3,0.166667,0.833333,0.250000,4 9 23 31,13 28 31 +20,Efficient,Direct,Analogical,8,same,2,2,0,2,0,0,0,1.000000,0.000000,1.000000,3 7,3 7 +20,Efficient,Direct,Analogical,8,cross,8,3,-5,3,5,0,5,0.375000,0.625000,0.375000,4 6 9 13 23 28 31 34,13 28 31 +21,Pragmatic,Direct,Surface,1,same,1,1,0,1,0,0,0,1.000000,0.000000,1.000000,3,3 +21,Pragmatic,Direct,Surface,1,cross,1,1,0,1,0,0,0,1.000000,0.000000,1.000000,1,1 +21,Pragmatic,Direct,Surface,2,same,2,2,0,1,2,1,1,0.333333,0.666667,0.500000,3 11,3 10 +21,Pragmatic,Direct,Surface,2,cross,2,2,0,1,2,1,1,0.333333,0.666667,0.500000,1 22,1 30 +21,Pragmatic,Direct,Surface,3,same,3,3,0,2,2,1,1,0.500000,0.500000,0.666667,3 10 17,3 7 10 +21,Pragmatic,Direct,Surface,3,cross,3,3,0,1,4,2,2,0.200000,0.800000,0.333333,1 15 27,1 28 31 +21,Pragmatic,Direct,Surface,4,same,4,4,0,4,0,0,0,1.000000,0.000000,1.000000,3 7 10 11,3 7 10 11 +21,Pragmatic,Direct,Surface,4,cross,4,4,0,2,4,2,2,0.333333,0.666667,0.500000,1 13 22 29,1 13 28 30 +21,Pragmatic,Direct,Surface,8,same,6,5,-1,5,1,0,1,0.833333,0.166667,0.833333,3 7 10 11 17 21,3 7 10 11 21 +21,Pragmatic,Direct,Surface,8,cross,8,6,-2,3,8,3,5,0.272727,0.727273,0.375000,1 6 13 16 22 25 29 32,1 13 28 30 31 32 +21,Pragmatic,Direct,Shallow,1,same,1,1,0,1,0,0,0,1.000000,0.000000,1.000000,3,3 +21,Pragmatic,Direct,Shallow,1,cross,1,1,0,1,0,0,0,1.000000,0.000000,1.000000,1,1 +21,Pragmatic,Direct,Shallow,2,same,2,2,0,1,2,1,1,0.333333,0.666667,0.500000,3 11,3 10 +21,Pragmatic,Direct,Shallow,2,cross,2,2,0,1,2,1,1,0.333333,0.666667,0.500000,1 22,1 30 +21,Pragmatic,Direct,Shallow,3,same,3,3,0,2,2,1,1,0.500000,0.500000,0.666667,3 10 17,3 7 10 +21,Pragmatic,Direct,Shallow,3,cross,3,3,0,1,4,2,2,0.200000,0.800000,0.333333,1 15 27,1 28 31 +21,Pragmatic,Direct,Shallow,4,same,4,4,0,4,0,0,0,1.000000,0.000000,1.000000,3 7 10 11,3 7 10 11 +21,Pragmatic,Direct,Shallow,4,cross,4,4,0,2,4,2,2,0.333333,0.666667,0.500000,1 13 22 29,1 13 28 30 +21,Pragmatic,Direct,Shallow,8,same,6,5,-1,5,1,0,1,0.833333,0.166667,0.833333,3 7 10 11 17 21,3 7 10 11 21 +21,Pragmatic,Direct,Shallow,8,cross,8,6,-2,3,8,3,5,0.272727,0.727273,0.375000,1 6 13 16 22 25 29 32,1 13 28 30 31 32 +21,Pragmatic,Direct,Contextual,1,same,1,1,0,1,0,0,0,1.000000,0.000000,1.000000,3,3 +21,Pragmatic,Direct,Contextual,1,cross,1,1,0,1,0,0,0,1.000000,0.000000,1.000000,1,1 +21,Pragmatic,Direct,Contextual,2,same,2,2,0,1,2,1,1,0.333333,0.666667,0.500000,3 11,3 10 +21,Pragmatic,Direct,Contextual,2,cross,2,2,0,1,2,1,1,0.333333,0.666667,0.500000,1 18,1 28 +21,Pragmatic,Direct,Contextual,3,same,3,3,0,2,2,1,1,0.500000,0.500000,0.666667,3 10 17,3 7 10 +21,Pragmatic,Direct,Contextual,3,cross,3,3,0,2,2,1,1,0.500000,0.500000,0.666667,1 13 23,1 13 28 +21,Pragmatic,Direct,Contextual,4,same,4,4,0,4,0,0,0,1.000000,0.000000,1.000000,3 7 10 11,3 7 10 11 +21,Pragmatic,Direct,Contextual,4,cross,4,4,0,1,6,3,3,0.142857,0.857143,0.250000,1 9 18 29,1 13 28 30 +21,Pragmatic,Direct,Contextual,8,same,6,5,-1,5,1,0,1,0.833333,0.166667,0.833333,3 7 10 11 17 21,3 7 10 11 21 +21,Pragmatic,Direct,Contextual,8,cross,8,5,-3,2,9,3,6,0.181818,0.818182,0.250000,1 4 9 15 18 23 29 31,1 13 28 30 31 +21,Pragmatic,Direct,Analogical,1,same,1,1,0,1,0,0,0,1.000000,0.000000,1.000000,3,3 +21,Pragmatic,Direct,Analogical,1,cross,1,1,0,0,2,1,1,0.000000,1.000000,0.000000,4,13 +21,Pragmatic,Direct,Analogical,2,same,2,2,0,2,0,0,0,1.000000,0.000000,1.000000,3 7,3 7 +21,Pragmatic,Direct,Analogical,2,cross,2,2,0,0,4,2,2,0.000000,1.000000,0.000000,4 23,13 28 +21,Pragmatic,Direct,Analogical,3,same,2,2,0,2,0,0,0,1.000000,0.000000,1.000000,3 7,3 7 +21,Pragmatic,Direct,Analogical,3,cross,3,3,0,0,6,3,3,0.000000,1.000000,0.000000,4 9 23,13 28 31 +21,Pragmatic,Direct,Analogical,4,same,2,2,0,2,0,0,0,1.000000,0.000000,1.000000,3 7,3 7 +21,Pragmatic,Direct,Analogical,4,cross,4,3,-1,1,5,2,3,0.166667,0.833333,0.250000,4 9 23 31,13 28 31 +21,Pragmatic,Direct,Analogical,8,same,2,2,0,2,0,0,0,1.000000,0.000000,1.000000,3 7,3 7 +21,Pragmatic,Direct,Analogical,8,cross,8,3,-5,3,5,0,5,0.375000,0.625000,0.375000,4 6 9 13 23 28 31 34,13 28 31 +22,Blunt,Direct,Surface,1,same,1,1,0,1,0,0,0,1.000000,0.000000,1.000000,3,3 +22,Blunt,Direct,Surface,1,cross,1,1,0,1,0,0,0,1.000000,0.000000,1.000000,1,1 +22,Blunt,Direct,Surface,2,same,2,2,0,1,2,1,1,0.333333,0.666667,0.500000,3 11,3 10 +22,Blunt,Direct,Surface,2,cross,2,2,0,1,2,1,1,0.333333,0.666667,0.500000,1 22,1 30 +22,Blunt,Direct,Surface,3,same,3,3,0,2,2,1,1,0.500000,0.500000,0.666667,3 10 17,3 7 10 +22,Blunt,Direct,Surface,3,cross,3,3,0,1,4,2,2,0.200000,0.800000,0.333333,1 15 27,1 28 31 +22,Blunt,Direct,Surface,4,same,4,4,0,4,0,0,0,1.000000,0.000000,1.000000,3 7 10 11,3 7 10 11 +22,Blunt,Direct,Surface,4,cross,4,4,0,2,4,2,2,0.333333,0.666667,0.500000,1 13 22 29,1 13 28 30 +22,Blunt,Direct,Surface,8,same,6,5,-1,5,1,0,1,0.833333,0.166667,0.833333,3 7 10 11 17 21,3 7 10 11 21 +22,Blunt,Direct,Surface,8,cross,8,6,-2,3,8,3,5,0.272727,0.727273,0.375000,1 6 13 16 22 25 29 32,1 13 28 30 31 32 +22,Blunt,Direct,Shallow,1,same,1,1,0,1,0,0,0,1.000000,0.000000,1.000000,3,3 +22,Blunt,Direct,Shallow,1,cross,1,1,0,1,0,0,0,1.000000,0.000000,1.000000,1,1 +22,Blunt,Direct,Shallow,2,same,2,2,0,1,2,1,1,0.333333,0.666667,0.500000,3 11,3 10 +22,Blunt,Direct,Shallow,2,cross,2,2,0,1,2,1,1,0.333333,0.666667,0.500000,1 22,1 30 +22,Blunt,Direct,Shallow,3,same,3,3,0,2,2,1,1,0.500000,0.500000,0.666667,3 10 17,3 7 10 +22,Blunt,Direct,Shallow,3,cross,3,3,0,1,4,2,2,0.200000,0.800000,0.333333,1 15 27,1 28 31 +22,Blunt,Direct,Shallow,4,same,4,4,0,4,0,0,0,1.000000,0.000000,1.000000,3 7 10 11,3 7 10 11 +22,Blunt,Direct,Shallow,4,cross,4,4,0,2,4,2,2,0.333333,0.666667,0.500000,1 13 22 29,1 13 28 30 +22,Blunt,Direct,Shallow,8,same,6,5,-1,5,1,0,1,0.833333,0.166667,0.833333,3 7 10 11 17 21,3 7 10 11 21 +22,Blunt,Direct,Shallow,8,cross,8,6,-2,3,8,3,5,0.272727,0.727273,0.375000,1 6 13 16 22 25 29 32,1 13 28 30 31 32 +22,Blunt,Direct,Contextual,1,same,1,1,0,1,0,0,0,1.000000,0.000000,1.000000,3,3 +22,Blunt,Direct,Contextual,1,cross,1,1,0,1,0,0,0,1.000000,0.000000,1.000000,1,1 +22,Blunt,Direct,Contextual,2,same,2,2,0,1,2,1,1,0.333333,0.666667,0.500000,3 11,3 10 +22,Blunt,Direct,Contextual,2,cross,2,2,0,1,2,1,1,0.333333,0.666667,0.500000,1 18,1 28 +22,Blunt,Direct,Contextual,3,same,3,3,0,2,2,1,1,0.500000,0.500000,0.666667,3 10 17,3 7 10 +22,Blunt,Direct,Contextual,3,cross,3,3,0,2,2,1,1,0.500000,0.500000,0.666667,1 13 23,1 13 28 +22,Blunt,Direct,Contextual,4,same,4,4,0,4,0,0,0,1.000000,0.000000,1.000000,3 7 10 11,3 7 10 11 +22,Blunt,Direct,Contextual,4,cross,4,4,0,1,6,3,3,0.142857,0.857143,0.250000,1 9 18 29,1 13 28 30 +22,Blunt,Direct,Contextual,8,same,6,5,-1,5,1,0,1,0.833333,0.166667,0.833333,3 7 10 11 17 21,3 7 10 11 21 +22,Blunt,Direct,Contextual,8,cross,8,5,-3,2,9,3,6,0.181818,0.818182,0.250000,1 4 9 15 18 23 29 31,1 13 28 30 31 +22,Blunt,Direct,Analogical,1,same,1,1,0,1,0,0,0,1.000000,0.000000,1.000000,3,3 +22,Blunt,Direct,Analogical,1,cross,1,1,0,0,2,1,1,0.000000,1.000000,0.000000,4,13 +22,Blunt,Direct,Analogical,2,same,2,2,0,2,0,0,0,1.000000,0.000000,1.000000,3 7,3 7 +22,Blunt,Direct,Analogical,2,cross,2,2,0,0,4,2,2,0.000000,1.000000,0.000000,4 23,13 28 +22,Blunt,Direct,Analogical,3,same,2,2,0,2,0,0,0,1.000000,0.000000,1.000000,3 7,3 7 +22,Blunt,Direct,Analogical,3,cross,3,3,0,0,6,3,3,0.000000,1.000000,0.000000,4 9 23,13 28 31 +22,Blunt,Direct,Analogical,4,same,2,2,0,2,0,0,0,1.000000,0.000000,1.000000,3 7,3 7 +22,Blunt,Direct,Analogical,4,cross,4,3,-1,1,5,2,3,0.166667,0.833333,0.250000,4 9 23 31,13 28 31 +22,Blunt,Direct,Analogical,8,same,2,2,0,2,0,0,0,1.000000,0.000000,1.000000,3 7,3 7 +22,Blunt,Direct,Analogical,8,cross,8,3,-5,3,5,0,5,0.375000,0.625000,0.375000,4 6 9 13 23 28 31 34,13 28 31 +23,Frank,Direct,Surface,1,same,1,1,0,1,0,0,0,1.000000,0.000000,1.000000,3,3 +23,Frank,Direct,Surface,1,cross,1,1,0,1,0,0,0,1.000000,0.000000,1.000000,1,1 +23,Frank,Direct,Surface,2,same,2,2,0,1,2,1,1,0.333333,0.666667,0.500000,3 11,3 10 +23,Frank,Direct,Surface,2,cross,2,2,0,1,2,1,1,0.333333,0.666667,0.500000,1 22,1 30 +23,Frank,Direct,Surface,3,same,3,3,0,2,2,1,1,0.500000,0.500000,0.666667,3 10 17,3 7 10 +23,Frank,Direct,Surface,3,cross,3,3,0,1,4,2,2,0.200000,0.800000,0.333333,1 15 27,1 28 31 +23,Frank,Direct,Surface,4,same,4,4,0,4,0,0,0,1.000000,0.000000,1.000000,3 7 10 11,3 7 10 11 +23,Frank,Direct,Surface,4,cross,4,4,0,2,4,2,2,0.333333,0.666667,0.500000,1 13 22 29,1 13 28 30 +23,Frank,Direct,Surface,8,same,6,5,-1,5,1,0,1,0.833333,0.166667,0.833333,3 7 10 11 17 21,3 7 10 11 21 +23,Frank,Direct,Surface,8,cross,8,6,-2,3,8,3,5,0.272727,0.727273,0.375000,1 6 13 16 22 25 29 32,1 13 28 30 31 32 +23,Frank,Direct,Shallow,1,same,1,1,0,1,0,0,0,1.000000,0.000000,1.000000,3,3 +23,Frank,Direct,Shallow,1,cross,1,1,0,1,0,0,0,1.000000,0.000000,1.000000,1,1 +23,Frank,Direct,Shallow,2,same,2,2,0,1,2,1,1,0.333333,0.666667,0.500000,3 11,3 10 +23,Frank,Direct,Shallow,2,cross,2,2,0,1,2,1,1,0.333333,0.666667,0.500000,1 22,1 30 +23,Frank,Direct,Shallow,3,same,3,3,0,2,2,1,1,0.500000,0.500000,0.666667,3 10 17,3 7 10 +23,Frank,Direct,Shallow,3,cross,3,3,0,1,4,2,2,0.200000,0.800000,0.333333,1 15 27,1 28 31 +23,Frank,Direct,Shallow,4,same,4,4,0,4,0,0,0,1.000000,0.000000,1.000000,3 7 10 11,3 7 10 11 +23,Frank,Direct,Shallow,4,cross,4,4,0,2,4,2,2,0.333333,0.666667,0.500000,1 13 22 29,1 13 28 30 +23,Frank,Direct,Shallow,8,same,6,5,-1,5,1,0,1,0.833333,0.166667,0.833333,3 7 10 11 17 21,3 7 10 11 21 +23,Frank,Direct,Shallow,8,cross,8,6,-2,3,8,3,5,0.272727,0.727273,0.375000,1 6 13 16 22 25 29 32,1 13 28 30 31 32 +23,Frank,Direct,Contextual,1,same,1,1,0,1,0,0,0,1.000000,0.000000,1.000000,3,3 +23,Frank,Direct,Contextual,1,cross,1,1,0,1,0,0,0,1.000000,0.000000,1.000000,1,1 +23,Frank,Direct,Contextual,2,same,2,2,0,1,2,1,1,0.333333,0.666667,0.500000,3 11,3 10 +23,Frank,Direct,Contextual,2,cross,2,2,0,1,2,1,1,0.333333,0.666667,0.500000,1 18,1 28 +23,Frank,Direct,Contextual,3,same,3,3,0,2,2,1,1,0.500000,0.500000,0.666667,3 10 17,3 7 10 +23,Frank,Direct,Contextual,3,cross,3,3,0,2,2,1,1,0.500000,0.500000,0.666667,1 13 23,1 13 28 +23,Frank,Direct,Contextual,4,same,4,4,0,4,0,0,0,1.000000,0.000000,1.000000,3 7 10 11,3 7 10 11 +23,Frank,Direct,Contextual,4,cross,4,4,0,1,6,3,3,0.142857,0.857143,0.250000,1 9 18 29,1 13 28 30 +23,Frank,Direct,Contextual,8,same,6,5,-1,5,1,0,1,0.833333,0.166667,0.833333,3 7 10 11 17 21,3 7 10 11 21 +23,Frank,Direct,Contextual,8,cross,8,5,-3,2,9,3,6,0.181818,0.818182,0.250000,1 4 9 15 18 23 29 31,1 13 28 30 31 +23,Frank,Direct,Analogical,1,same,1,1,0,1,0,0,0,1.000000,0.000000,1.000000,3,3 +23,Frank,Direct,Analogical,1,cross,1,1,0,0,2,1,1,0.000000,1.000000,0.000000,4,13 +23,Frank,Direct,Analogical,2,same,2,2,0,2,0,0,0,1.000000,0.000000,1.000000,3 7,3 7 +23,Frank,Direct,Analogical,2,cross,2,2,0,0,4,2,2,0.000000,1.000000,0.000000,4 23,13 28 +23,Frank,Direct,Analogical,3,same,2,2,0,2,0,0,0,1.000000,0.000000,1.000000,3 7,3 7 +23,Frank,Direct,Analogical,3,cross,3,3,0,0,6,3,3,0.000000,1.000000,0.000000,4 9 23,13 28 31 +23,Frank,Direct,Analogical,4,same,2,2,0,2,0,0,0,1.000000,0.000000,1.000000,3 7,3 7 +23,Frank,Direct,Analogical,4,cross,4,3,-1,1,5,2,3,0.166667,0.833333,0.250000,4 9 23 31,13 28 31 +23,Frank,Direct,Analogical,8,same,2,2,0,2,0,0,0,1.000000,0.000000,1.000000,3 7,3 7 +23,Frank,Direct,Analogical,8,cross,8,3,-5,3,5,0,5,0.375000,0.625000,0.375000,4 6 9 13 23 28 31 34,13 28 31 +24,Curious,Exploratory,Surface,1,same,1,1,0,0,2,1,1,0.000000,1.000000,0.000000,4,13 +24,Curious,Exploratory,Surface,1,cross,1,1,0,1,0,0,0,1.000000,0.000000,1.000000,1,1 +24,Curious,Exploratory,Surface,2,same,2,2,0,0,4,2,2,0.000000,1.000000,0.000000,4 23,13 28 +24,Curious,Exploratory,Surface,2,cross,2,2,0,1,2,1,1,0.333333,0.666667,0.500000,1 18,1 11 +24,Curious,Exploratory,Surface,3,same,3,3,0,0,6,3,3,0.000000,1.000000,0.000000,4 9 23,13 28 31 +24,Curious,Exploratory,Surface,3,cross,3,3,0,1,4,2,2,0.200000,0.800000,0.333333,1 14 22,1 7 11 +24,Curious,Exploratory,Surface,4,same,4,3,-1,1,5,2,3,0.166667,0.833333,0.250000,4 9 23 31,13 28 31 +24,Curious,Exploratory,Surface,4,cross,4,4,0,2,4,2,2,0.333333,0.666667,0.500000,1 11 17 24,1 7 11 30 +24,Curious,Exploratory,Surface,8,same,8,3,-5,3,5,0,5,0.375000,0.625000,0.375000,4 6 9 13 23 28 31 34,13 28 31 +24,Curious,Exploratory,Surface,8,cross,8,8,0,3,10,5,5,0.230769,0.769231,0.375000,1 3 10 12 15 17 19 22,1 3 7 10 11 21 30 32 +24,Curious,Exploratory,Shallow,1,same,1,1,0,0,2,1,1,0.000000,1.000000,0.000000,4,13 +24,Curious,Exploratory,Shallow,1,cross,1,1,0,1,0,0,0,1.000000,0.000000,1.000000,1,1 +24,Curious,Exploratory,Shallow,2,same,2,2,0,0,4,2,2,0.000000,1.000000,0.000000,4 23,13 28 +24,Curious,Exploratory,Shallow,2,cross,2,2,0,1,2,1,1,0.333333,0.666667,0.500000,1 18,1 11 +24,Curious,Exploratory,Shallow,3,same,3,3,0,0,6,3,3,0.000000,1.000000,0.000000,4 9 23,13 28 31 +24,Curious,Exploratory,Shallow,3,cross,3,3,0,1,4,2,2,0.200000,0.800000,0.333333,1 14 22,1 7 11 +24,Curious,Exploratory,Shallow,4,same,4,3,-1,1,5,2,3,0.166667,0.833333,0.250000,4 9 23 31,13 28 31 +24,Curious,Exploratory,Shallow,4,cross,4,4,0,2,4,2,2,0.333333,0.666667,0.500000,1 11 17 24,1 7 11 30 +24,Curious,Exploratory,Shallow,8,same,8,3,-5,3,5,0,5,0.375000,0.625000,0.375000,4 6 9 13 23 28 31 34,13 28 31 +24,Curious,Exploratory,Shallow,8,cross,8,8,0,3,10,5,5,0.230769,0.769231,0.375000,1 3 10 12 15 17 19 22,1 3 7 10 11 21 30 32 +24,Curious,Exploratory,Contextual,1,same,1,1,0,0,2,1,1,0.000000,1.000000,0.000000,4,13 +24,Curious,Exploratory,Contextual,1,cross,1,1,0,1,0,0,0,1.000000,0.000000,1.000000,1,1 +24,Curious,Exploratory,Contextual,2,same,2,2,0,0,4,2,2,0.000000,1.000000,0.000000,4 23,13 28 +24,Curious,Exploratory,Contextual,2,cross,2,2,0,1,2,1,1,0.333333,0.666667,0.500000,1 16,1 10 +24,Curious,Exploratory,Contextual,3,same,3,3,0,0,6,3,3,0.000000,1.000000,0.000000,4 9 23,13 28 31 +24,Curious,Exploratory,Contextual,3,cross,3,3,0,2,2,1,1,0.500000,0.500000,0.666667,1 11 21,1 7 11 +24,Curious,Exploratory,Contextual,4,same,4,3,-1,1,5,2,3,0.166667,0.833333,0.250000,4 9 23 31,13 28 31 +24,Curious,Exploratory,Contextual,4,cross,4,4,0,2,4,2,2,0.333333,0.666667,0.500000,1 7 15 18,1 3 7 10 +24,Curious,Exploratory,Contextual,8,same,8,3,-5,3,5,0,5,0.375000,0.625000,0.375000,4 6 9 13 23 28 31 34,13 28 31 +24,Curious,Exploratory,Contextual,8,cross,8,7,-1,5,5,2,3,0.500000,0.500000,0.625000,1 2 3 7 10 11 15 16,1 3 7 10 11 21 30 +24,Curious,Exploratory,Analogical,1,same,1,1,0,0,2,1,1,0.000000,1.000000,0.000000,4,13 +24,Curious,Exploratory,Analogical,1,cross,1,1,0,1,0,0,0,1.000000,0.000000,1.000000,3,3 +24,Curious,Exploratory,Analogical,2,same,2,2,0,0,4,2,2,0.000000,1.000000,0.000000,4 23,13 28 +24,Curious,Exploratory,Analogical,2,cross,2,2,0,2,0,0,0,1.000000,0.000000,1.000000,3 7,3 7 +24,Curious,Exploratory,Analogical,3,same,3,3,0,0,6,3,3,0.000000,1.000000,0.000000,4 9 23,13 28 31 +24,Curious,Exploratory,Analogical,3,cross,2,2,0,2,0,0,0,1.000000,0.000000,1.000000,3 7,3 7 +24,Curious,Exploratory,Analogical,4,same,4,3,-1,1,5,2,3,0.166667,0.833333,0.250000,4 9 23 31,13 28 31 +24,Curious,Exploratory,Analogical,4,cross,2,2,0,2,0,0,0,1.000000,0.000000,1.000000,3 7,3 7 +24,Curious,Exploratory,Analogical,8,same,8,3,-5,3,5,0,5,0.375000,0.625000,0.375000,4 6 9 13 23 28 31 34,13 28 31 +24,Curious,Exploratory,Analogical,8,cross,2,2,0,2,0,0,0,1.000000,0.000000,1.000000,3 7,3 7 +25,Exploratory,Exploratory,Surface,1,same,1,1,0,0,2,1,1,0.000000,1.000000,0.000000,4,13 +25,Exploratory,Exploratory,Surface,1,cross,1,1,0,1,0,0,0,1.000000,0.000000,1.000000,1,1 +25,Exploratory,Exploratory,Surface,2,same,2,2,0,0,4,2,2,0.000000,1.000000,0.000000,4 23,13 28 +25,Exploratory,Exploratory,Surface,2,cross,2,2,0,1,2,1,1,0.333333,0.666667,0.500000,1 18,1 11 +25,Exploratory,Exploratory,Surface,3,same,3,3,0,0,6,3,3,0.000000,1.000000,0.000000,4 9 23,13 28 31 +25,Exploratory,Exploratory,Surface,3,cross,3,3,0,1,4,2,2,0.200000,0.800000,0.333333,1 14 22,1 7 11 +25,Exploratory,Exploratory,Surface,4,same,4,3,-1,1,5,2,3,0.166667,0.833333,0.250000,4 9 23 31,13 28 31 +25,Exploratory,Exploratory,Surface,4,cross,4,4,0,2,4,2,2,0.333333,0.666667,0.500000,1 11 17 24,1 7 11 30 +25,Exploratory,Exploratory,Surface,8,same,8,3,-5,3,5,0,5,0.375000,0.625000,0.375000,4 6 9 13 23 28 31 34,13 28 31 +25,Exploratory,Exploratory,Surface,8,cross,8,8,0,3,10,5,5,0.230769,0.769231,0.375000,1 3 10 12 15 17 19 22,1 3 7 10 11 21 30 32 +25,Exploratory,Exploratory,Shallow,1,same,1,1,0,0,2,1,1,0.000000,1.000000,0.000000,4,13 +25,Exploratory,Exploratory,Shallow,1,cross,1,1,0,1,0,0,0,1.000000,0.000000,1.000000,1,1 +25,Exploratory,Exploratory,Shallow,2,same,2,2,0,0,4,2,2,0.000000,1.000000,0.000000,4 23,13 28 +25,Exploratory,Exploratory,Shallow,2,cross,2,2,0,1,2,1,1,0.333333,0.666667,0.500000,1 18,1 11 +25,Exploratory,Exploratory,Shallow,3,same,3,3,0,0,6,3,3,0.000000,1.000000,0.000000,4 9 23,13 28 31 +25,Exploratory,Exploratory,Shallow,3,cross,3,3,0,1,4,2,2,0.200000,0.800000,0.333333,1 14 22,1 7 11 +25,Exploratory,Exploratory,Shallow,4,same,4,3,-1,1,5,2,3,0.166667,0.833333,0.250000,4 9 23 31,13 28 31 +25,Exploratory,Exploratory,Shallow,4,cross,4,4,0,2,4,2,2,0.333333,0.666667,0.500000,1 11 17 24,1 7 11 30 +25,Exploratory,Exploratory,Shallow,8,same,8,3,-5,3,5,0,5,0.375000,0.625000,0.375000,4 6 9 13 23 28 31 34,13 28 31 +25,Exploratory,Exploratory,Shallow,8,cross,8,8,0,3,10,5,5,0.230769,0.769231,0.375000,1 3 10 12 15 17 19 22,1 3 7 10 11 21 30 32 +25,Exploratory,Exploratory,Contextual,1,same,1,1,0,0,2,1,1,0.000000,1.000000,0.000000,4,13 +25,Exploratory,Exploratory,Contextual,1,cross,1,1,0,1,0,0,0,1.000000,0.000000,1.000000,1,1 +25,Exploratory,Exploratory,Contextual,2,same,2,2,0,0,4,2,2,0.000000,1.000000,0.000000,4 23,13 28 +25,Exploratory,Exploratory,Contextual,2,cross,2,2,0,1,2,1,1,0.333333,0.666667,0.500000,1 16,1 10 +25,Exploratory,Exploratory,Contextual,3,same,3,3,0,0,6,3,3,0.000000,1.000000,0.000000,4 9 23,13 28 31 +25,Exploratory,Exploratory,Contextual,3,cross,3,3,0,2,2,1,1,0.500000,0.500000,0.666667,1 11 21,1 7 11 +25,Exploratory,Exploratory,Contextual,4,same,4,3,-1,1,5,2,3,0.166667,0.833333,0.250000,4 9 23 31,13 28 31 +25,Exploratory,Exploratory,Contextual,4,cross,4,4,0,2,4,2,2,0.333333,0.666667,0.500000,1 7 15 18,1 3 7 10 +25,Exploratory,Exploratory,Contextual,8,same,8,3,-5,3,5,0,5,0.375000,0.625000,0.375000,4 6 9 13 23 28 31 34,13 28 31 +25,Exploratory,Exploratory,Contextual,8,cross,8,7,-1,5,5,2,3,0.500000,0.500000,0.625000,1 2 3 7 10 11 15 16,1 3 7 10 11 21 30 +25,Exploratory,Exploratory,Analogical,1,same,1,1,0,0,2,1,1,0.000000,1.000000,0.000000,4,13 +25,Exploratory,Exploratory,Analogical,1,cross,1,1,0,1,0,0,0,1.000000,0.000000,1.000000,3,3 +25,Exploratory,Exploratory,Analogical,2,same,2,2,0,0,4,2,2,0.000000,1.000000,0.000000,4 23,13 28 +25,Exploratory,Exploratory,Analogical,2,cross,2,2,0,2,0,0,0,1.000000,0.000000,1.000000,3 7,3 7 +25,Exploratory,Exploratory,Analogical,3,same,3,3,0,0,6,3,3,0.000000,1.000000,0.000000,4 9 23,13 28 31 +25,Exploratory,Exploratory,Analogical,3,cross,2,2,0,2,0,0,0,1.000000,0.000000,1.000000,3 7,3 7 +25,Exploratory,Exploratory,Analogical,4,same,4,3,-1,1,5,2,3,0.166667,0.833333,0.250000,4 9 23 31,13 28 31 +25,Exploratory,Exploratory,Analogical,4,cross,2,2,0,2,0,0,0,1.000000,0.000000,1.000000,3 7,3 7 +25,Exploratory,Exploratory,Analogical,8,same,8,3,-5,3,5,0,5,0.375000,0.625000,0.375000,4 6 9 13 23 28 31 34,13 28 31 +25,Exploratory,Exploratory,Analogical,8,cross,2,2,0,2,0,0,0,1.000000,0.000000,1.000000,3 7,3 7 +26,Questioning,Exploratory,Surface,1,same,1,1,0,0,2,1,1,0.000000,1.000000,0.000000,4,13 +26,Questioning,Exploratory,Surface,1,cross,1,1,0,1,0,0,0,1.000000,0.000000,1.000000,1,1 +26,Questioning,Exploratory,Surface,2,same,2,2,0,0,4,2,2,0.000000,1.000000,0.000000,4 23,13 28 +26,Questioning,Exploratory,Surface,2,cross,2,2,0,1,2,1,1,0.333333,0.666667,0.500000,1 18,1 11 +26,Questioning,Exploratory,Surface,3,same,3,3,0,0,6,3,3,0.000000,1.000000,0.000000,4 9 23,13 28 31 +26,Questioning,Exploratory,Surface,3,cross,3,3,0,1,4,2,2,0.200000,0.800000,0.333333,1 14 22,1 7 11 +26,Questioning,Exploratory,Surface,4,same,4,3,-1,1,5,2,3,0.166667,0.833333,0.250000,4 9 23 31,13 28 31 +26,Questioning,Exploratory,Surface,4,cross,4,4,0,2,4,2,2,0.333333,0.666667,0.500000,1 11 17 24,1 7 11 30 +26,Questioning,Exploratory,Surface,8,same,8,3,-5,3,5,0,5,0.375000,0.625000,0.375000,4 6 9 13 23 28 31 34,13 28 31 +26,Questioning,Exploratory,Surface,8,cross,8,8,0,3,10,5,5,0.230769,0.769231,0.375000,1 3 10 12 15 17 19 22,1 3 7 10 11 21 30 32 +26,Questioning,Exploratory,Shallow,1,same,1,1,0,0,2,1,1,0.000000,1.000000,0.000000,4,13 +26,Questioning,Exploratory,Shallow,1,cross,1,1,0,1,0,0,0,1.000000,0.000000,1.000000,1,1 +26,Questioning,Exploratory,Shallow,2,same,2,2,0,0,4,2,2,0.000000,1.000000,0.000000,4 23,13 28 +26,Questioning,Exploratory,Shallow,2,cross,2,2,0,1,2,1,1,0.333333,0.666667,0.500000,1 18,1 11 +26,Questioning,Exploratory,Shallow,3,same,3,3,0,0,6,3,3,0.000000,1.000000,0.000000,4 9 23,13 28 31 +26,Questioning,Exploratory,Shallow,3,cross,3,3,0,1,4,2,2,0.200000,0.800000,0.333333,1 14 22,1 7 11 +26,Questioning,Exploratory,Shallow,4,same,4,3,-1,1,5,2,3,0.166667,0.833333,0.250000,4 9 23 31,13 28 31 +26,Questioning,Exploratory,Shallow,4,cross,4,4,0,2,4,2,2,0.333333,0.666667,0.500000,1 11 17 24,1 7 11 30 +26,Questioning,Exploratory,Shallow,8,same,8,3,-5,3,5,0,5,0.375000,0.625000,0.375000,4 6 9 13 23 28 31 34,13 28 31 +26,Questioning,Exploratory,Shallow,8,cross,8,8,0,3,10,5,5,0.230769,0.769231,0.375000,1 3 10 12 15 17 19 22,1 3 7 10 11 21 30 32 +26,Questioning,Exploratory,Contextual,1,same,1,1,0,0,2,1,1,0.000000,1.000000,0.000000,4,13 +26,Questioning,Exploratory,Contextual,1,cross,1,1,0,1,0,0,0,1.000000,0.000000,1.000000,1,1 +26,Questioning,Exploratory,Contextual,2,same,2,2,0,0,4,2,2,0.000000,1.000000,0.000000,4 23,13 28 +26,Questioning,Exploratory,Contextual,2,cross,2,2,0,1,2,1,1,0.333333,0.666667,0.500000,1 16,1 10 +26,Questioning,Exploratory,Contextual,3,same,3,3,0,0,6,3,3,0.000000,1.000000,0.000000,4 9 23,13 28 31 +26,Questioning,Exploratory,Contextual,3,cross,3,3,0,2,2,1,1,0.500000,0.500000,0.666667,1 11 21,1 7 11 +26,Questioning,Exploratory,Contextual,4,same,4,3,-1,1,5,2,3,0.166667,0.833333,0.250000,4 9 23 31,13 28 31 +26,Questioning,Exploratory,Contextual,4,cross,4,4,0,2,4,2,2,0.333333,0.666667,0.500000,1 7 15 18,1 3 7 10 +26,Questioning,Exploratory,Contextual,8,same,8,3,-5,3,5,0,5,0.375000,0.625000,0.375000,4 6 9 13 23 28 31 34,13 28 31 +26,Questioning,Exploratory,Contextual,8,cross,8,7,-1,5,5,2,3,0.500000,0.500000,0.625000,1 2 3 7 10 11 15 16,1 3 7 10 11 21 30 +26,Questioning,Exploratory,Analogical,1,same,1,1,0,0,2,1,1,0.000000,1.000000,0.000000,4,13 +26,Questioning,Exploratory,Analogical,1,cross,1,1,0,1,0,0,0,1.000000,0.000000,1.000000,3,3 +26,Questioning,Exploratory,Analogical,2,same,2,2,0,0,4,2,2,0.000000,1.000000,0.000000,4 23,13 28 +26,Questioning,Exploratory,Analogical,2,cross,2,2,0,2,0,0,0,1.000000,0.000000,1.000000,3 7,3 7 +26,Questioning,Exploratory,Analogical,3,same,3,3,0,0,6,3,3,0.000000,1.000000,0.000000,4 9 23,13 28 31 +26,Questioning,Exploratory,Analogical,3,cross,2,2,0,2,0,0,0,1.000000,0.000000,1.000000,3 7,3 7 +26,Questioning,Exploratory,Analogical,4,same,4,3,-1,1,5,2,3,0.166667,0.833333,0.250000,4 9 23 31,13 28 31 +26,Questioning,Exploratory,Analogical,4,cross,2,2,0,2,0,0,0,1.000000,0.000000,1.000000,3 7,3 7 +26,Questioning,Exploratory,Analogical,8,same,8,3,-5,3,5,0,5,0.375000,0.625000,0.375000,4 6 9 13 23 28 31 34,13 28 31 +26,Questioning,Exploratory,Analogical,8,cross,2,2,0,2,0,0,0,1.000000,0.000000,1.000000,3 7,3 7 +27,Investigative,Exploratory,Surface,1,same,1,1,0,0,2,1,1,0.000000,1.000000,0.000000,4,13 +27,Investigative,Exploratory,Surface,1,cross,1,1,0,1,0,0,0,1.000000,0.000000,1.000000,1,1 +27,Investigative,Exploratory,Surface,2,same,2,2,0,0,4,2,2,0.000000,1.000000,0.000000,4 23,13 28 +27,Investigative,Exploratory,Surface,2,cross,2,2,0,1,2,1,1,0.333333,0.666667,0.500000,1 18,1 11 +27,Investigative,Exploratory,Surface,3,same,3,3,0,0,6,3,3,0.000000,1.000000,0.000000,4 9 23,13 28 31 +27,Investigative,Exploratory,Surface,3,cross,3,3,0,1,4,2,2,0.200000,0.800000,0.333333,1 14 22,1 7 11 +27,Investigative,Exploratory,Surface,4,same,4,3,-1,1,5,2,3,0.166667,0.833333,0.250000,4 9 23 31,13 28 31 +27,Investigative,Exploratory,Surface,4,cross,4,4,0,2,4,2,2,0.333333,0.666667,0.500000,1 11 17 24,1 7 11 30 +27,Investigative,Exploratory,Surface,8,same,8,3,-5,3,5,0,5,0.375000,0.625000,0.375000,4 6 9 13 23 28 31 34,13 28 31 +27,Investigative,Exploratory,Surface,8,cross,8,8,0,3,10,5,5,0.230769,0.769231,0.375000,1 3 10 12 15 17 19 22,1 3 7 10 11 21 30 32 +27,Investigative,Exploratory,Shallow,1,same,1,1,0,0,2,1,1,0.000000,1.000000,0.000000,4,13 +27,Investigative,Exploratory,Shallow,1,cross,1,1,0,1,0,0,0,1.000000,0.000000,1.000000,1,1 +27,Investigative,Exploratory,Shallow,2,same,2,2,0,0,4,2,2,0.000000,1.000000,0.000000,4 23,13 28 +27,Investigative,Exploratory,Shallow,2,cross,2,2,0,1,2,1,1,0.333333,0.666667,0.500000,1 18,1 11 +27,Investigative,Exploratory,Shallow,3,same,3,3,0,0,6,3,3,0.000000,1.000000,0.000000,4 9 23,13 28 31 +27,Investigative,Exploratory,Shallow,3,cross,3,3,0,1,4,2,2,0.200000,0.800000,0.333333,1 14 22,1 7 11 +27,Investigative,Exploratory,Shallow,4,same,4,3,-1,1,5,2,3,0.166667,0.833333,0.250000,4 9 23 31,13 28 31 +27,Investigative,Exploratory,Shallow,4,cross,4,4,0,2,4,2,2,0.333333,0.666667,0.500000,1 11 17 24,1 7 11 30 +27,Investigative,Exploratory,Shallow,8,same,8,3,-5,3,5,0,5,0.375000,0.625000,0.375000,4 6 9 13 23 28 31 34,13 28 31 +27,Investigative,Exploratory,Shallow,8,cross,8,8,0,3,10,5,5,0.230769,0.769231,0.375000,1 3 10 12 15 17 19 22,1 3 7 10 11 21 30 32 +27,Investigative,Exploratory,Contextual,1,same,1,1,0,0,2,1,1,0.000000,1.000000,0.000000,4,13 +27,Investigative,Exploratory,Contextual,1,cross,1,1,0,1,0,0,0,1.000000,0.000000,1.000000,1,1 +27,Investigative,Exploratory,Contextual,2,same,2,2,0,0,4,2,2,0.000000,1.000000,0.000000,4 23,13 28 +27,Investigative,Exploratory,Contextual,2,cross,2,2,0,1,2,1,1,0.333333,0.666667,0.500000,1 16,1 10 +27,Investigative,Exploratory,Contextual,3,same,3,3,0,0,6,3,3,0.000000,1.000000,0.000000,4 9 23,13 28 31 +27,Investigative,Exploratory,Contextual,3,cross,3,3,0,2,2,1,1,0.500000,0.500000,0.666667,1 11 21,1 7 11 +27,Investigative,Exploratory,Contextual,4,same,4,3,-1,1,5,2,3,0.166667,0.833333,0.250000,4 9 23 31,13 28 31 +27,Investigative,Exploratory,Contextual,4,cross,4,4,0,2,4,2,2,0.333333,0.666667,0.500000,1 7 15 18,1 3 7 10 +27,Investigative,Exploratory,Contextual,8,same,8,3,-5,3,5,0,5,0.375000,0.625000,0.375000,4 6 9 13 23 28 31 34,13 28 31 +27,Investigative,Exploratory,Contextual,8,cross,8,7,-1,5,5,2,3,0.500000,0.500000,0.625000,1 2 3 7 10 11 15 16,1 3 7 10 11 21 30 +27,Investigative,Exploratory,Analogical,1,same,1,1,0,0,2,1,1,0.000000,1.000000,0.000000,4,13 +27,Investigative,Exploratory,Analogical,1,cross,1,1,0,1,0,0,0,1.000000,0.000000,1.000000,3,3 +27,Investigative,Exploratory,Analogical,2,same,2,2,0,0,4,2,2,0.000000,1.000000,0.000000,4 23,13 28 +27,Investigative,Exploratory,Analogical,2,cross,2,2,0,2,0,0,0,1.000000,0.000000,1.000000,3 7,3 7 +27,Investigative,Exploratory,Analogical,3,same,3,3,0,0,6,3,3,0.000000,1.000000,0.000000,4 9 23,13 28 31 +27,Investigative,Exploratory,Analogical,3,cross,2,2,0,2,0,0,0,1.000000,0.000000,1.000000,3 7,3 7 +27,Investigative,Exploratory,Analogical,4,same,4,3,-1,1,5,2,3,0.166667,0.833333,0.250000,4 9 23 31,13 28 31 +27,Investigative,Exploratory,Analogical,4,cross,2,2,0,2,0,0,0,1.000000,0.000000,1.000000,3 7,3 7 +27,Investigative,Exploratory,Analogical,8,same,8,3,-5,3,5,0,5,0.375000,0.625000,0.375000,4 6 9 13 23 28 31 34,13 28 31 +27,Investigative,Exploratory,Analogical,8,cross,2,2,0,2,0,0,0,1.000000,0.000000,1.000000,3 7,3 7 +28,Speculative,Exploratory,Surface,1,same,1,1,0,0,2,1,1,0.000000,1.000000,0.000000,4,13 +28,Speculative,Exploratory,Surface,1,cross,1,1,0,1,0,0,0,1.000000,0.000000,1.000000,1,1 +28,Speculative,Exploratory,Surface,2,same,2,2,0,0,4,2,2,0.000000,1.000000,0.000000,4 23,13 28 +28,Speculative,Exploratory,Surface,2,cross,2,2,0,1,2,1,1,0.333333,0.666667,0.500000,1 18,1 11 +28,Speculative,Exploratory,Surface,3,same,3,3,0,0,6,3,3,0.000000,1.000000,0.000000,4 9 23,13 28 31 +28,Speculative,Exploratory,Surface,3,cross,3,3,0,1,4,2,2,0.200000,0.800000,0.333333,1 14 22,1 7 11 +28,Speculative,Exploratory,Surface,4,same,4,3,-1,1,5,2,3,0.166667,0.833333,0.250000,4 9 23 31,13 28 31 +28,Speculative,Exploratory,Surface,4,cross,4,4,0,2,4,2,2,0.333333,0.666667,0.500000,1 11 17 24,1 7 11 30 +28,Speculative,Exploratory,Surface,8,same,8,3,-5,3,5,0,5,0.375000,0.625000,0.375000,4 6 9 13 23 28 31 34,13 28 31 +28,Speculative,Exploratory,Surface,8,cross,8,8,0,3,10,5,5,0.230769,0.769231,0.375000,1 3 10 12 15 17 19 22,1 3 7 10 11 21 30 32 +28,Speculative,Exploratory,Shallow,1,same,1,1,0,0,2,1,1,0.000000,1.000000,0.000000,4,13 +28,Speculative,Exploratory,Shallow,1,cross,1,1,0,1,0,0,0,1.000000,0.000000,1.000000,1,1 +28,Speculative,Exploratory,Shallow,2,same,2,2,0,0,4,2,2,0.000000,1.000000,0.000000,4 23,13 28 +28,Speculative,Exploratory,Shallow,2,cross,2,2,0,1,2,1,1,0.333333,0.666667,0.500000,1 18,1 11 +28,Speculative,Exploratory,Shallow,3,same,3,3,0,0,6,3,3,0.000000,1.000000,0.000000,4 9 23,13 28 31 +28,Speculative,Exploratory,Shallow,3,cross,3,3,0,1,4,2,2,0.200000,0.800000,0.333333,1 14 22,1 7 11 +28,Speculative,Exploratory,Shallow,4,same,4,3,-1,1,5,2,3,0.166667,0.833333,0.250000,4 9 23 31,13 28 31 +28,Speculative,Exploratory,Shallow,4,cross,4,4,0,2,4,2,2,0.333333,0.666667,0.500000,1 11 17 24,1 7 11 30 +28,Speculative,Exploratory,Shallow,8,same,8,3,-5,3,5,0,5,0.375000,0.625000,0.375000,4 6 9 13 23 28 31 34,13 28 31 +28,Speculative,Exploratory,Shallow,8,cross,8,8,0,3,10,5,5,0.230769,0.769231,0.375000,1 3 10 12 15 17 19 22,1 3 7 10 11 21 30 32 +28,Speculative,Exploratory,Contextual,1,same,1,1,0,0,2,1,1,0.000000,1.000000,0.000000,4,13 +28,Speculative,Exploratory,Contextual,1,cross,1,1,0,1,0,0,0,1.000000,0.000000,1.000000,1,1 +28,Speculative,Exploratory,Contextual,2,same,2,2,0,0,4,2,2,0.000000,1.000000,0.000000,4 23,13 28 +28,Speculative,Exploratory,Contextual,2,cross,2,2,0,1,2,1,1,0.333333,0.666667,0.500000,1 16,1 10 +28,Speculative,Exploratory,Contextual,3,same,3,3,0,0,6,3,3,0.000000,1.000000,0.000000,4 9 23,13 28 31 +28,Speculative,Exploratory,Contextual,3,cross,3,3,0,2,2,1,1,0.500000,0.500000,0.666667,1 11 21,1 7 11 +28,Speculative,Exploratory,Contextual,4,same,4,3,-1,1,5,2,3,0.166667,0.833333,0.250000,4 9 23 31,13 28 31 +28,Speculative,Exploratory,Contextual,4,cross,4,4,0,2,4,2,2,0.333333,0.666667,0.500000,1 7 15 18,1 3 7 10 +28,Speculative,Exploratory,Contextual,8,same,8,3,-5,3,5,0,5,0.375000,0.625000,0.375000,4 6 9 13 23 28 31 34,13 28 31 +28,Speculative,Exploratory,Contextual,8,cross,8,7,-1,5,5,2,3,0.500000,0.500000,0.625000,1 2 3 7 10 11 15 16,1 3 7 10 11 21 30 +28,Speculative,Exploratory,Analogical,1,same,1,1,0,0,2,1,1,0.000000,1.000000,0.000000,4,13 +28,Speculative,Exploratory,Analogical,1,cross,1,1,0,1,0,0,0,1.000000,0.000000,1.000000,3,3 +28,Speculative,Exploratory,Analogical,2,same,2,2,0,0,4,2,2,0.000000,1.000000,0.000000,4 23,13 28 +28,Speculative,Exploratory,Analogical,2,cross,2,2,0,2,0,0,0,1.000000,0.000000,1.000000,3 7,3 7 +28,Speculative,Exploratory,Analogical,3,same,3,3,0,0,6,3,3,0.000000,1.000000,0.000000,4 9 23,13 28 31 +28,Speculative,Exploratory,Analogical,3,cross,2,2,0,2,0,0,0,1.000000,0.000000,1.000000,3 7,3 7 +28,Speculative,Exploratory,Analogical,4,same,4,3,-1,1,5,2,3,0.166667,0.833333,0.250000,4 9 23 31,13 28 31 +28,Speculative,Exploratory,Analogical,4,cross,2,2,0,2,0,0,0,1.000000,0.000000,1.000000,3 7,3 7 +28,Speculative,Exploratory,Analogical,8,same,8,3,-5,3,5,0,5,0.375000,0.625000,0.375000,4 6 9 13 23 28 31 34,13 28 31 +28,Speculative,Exploratory,Analogical,8,cross,2,2,0,2,0,0,0,1.000000,0.000000,1.000000,3 7,3 7 +29,Philosophical,Exploratory,Surface,1,same,1,1,0,0,2,1,1,0.000000,1.000000,0.000000,4,13 +29,Philosophical,Exploratory,Surface,1,cross,1,1,0,1,0,0,0,1.000000,0.000000,1.000000,1,1 +29,Philosophical,Exploratory,Surface,2,same,2,2,0,0,4,2,2,0.000000,1.000000,0.000000,4 23,13 28 +29,Philosophical,Exploratory,Surface,2,cross,2,2,0,1,2,1,1,0.333333,0.666667,0.500000,1 18,1 11 +29,Philosophical,Exploratory,Surface,3,same,3,3,0,0,6,3,3,0.000000,1.000000,0.000000,4 9 23,13 28 31 +29,Philosophical,Exploratory,Surface,3,cross,3,3,0,1,4,2,2,0.200000,0.800000,0.333333,1 14 22,1 7 11 +29,Philosophical,Exploratory,Surface,4,same,4,3,-1,1,5,2,3,0.166667,0.833333,0.250000,4 9 23 31,13 28 31 +29,Philosophical,Exploratory,Surface,4,cross,4,4,0,2,4,2,2,0.333333,0.666667,0.500000,1 11 17 24,1 7 11 30 +29,Philosophical,Exploratory,Surface,8,same,8,3,-5,3,5,0,5,0.375000,0.625000,0.375000,4 6 9 13 23 28 31 34,13 28 31 +29,Philosophical,Exploratory,Surface,8,cross,8,8,0,3,10,5,5,0.230769,0.769231,0.375000,1 3 10 12 15 17 19 22,1 3 7 10 11 21 30 32 +29,Philosophical,Exploratory,Shallow,1,same,1,1,0,0,2,1,1,0.000000,1.000000,0.000000,4,13 +29,Philosophical,Exploratory,Shallow,1,cross,1,1,0,1,0,0,0,1.000000,0.000000,1.000000,1,1 +29,Philosophical,Exploratory,Shallow,2,same,2,2,0,0,4,2,2,0.000000,1.000000,0.000000,4 23,13 28 +29,Philosophical,Exploratory,Shallow,2,cross,2,2,0,1,2,1,1,0.333333,0.666667,0.500000,1 18,1 11 +29,Philosophical,Exploratory,Shallow,3,same,3,3,0,0,6,3,3,0.000000,1.000000,0.000000,4 9 23,13 28 31 +29,Philosophical,Exploratory,Shallow,3,cross,3,3,0,1,4,2,2,0.200000,0.800000,0.333333,1 14 22,1 7 11 +29,Philosophical,Exploratory,Shallow,4,same,4,3,-1,1,5,2,3,0.166667,0.833333,0.250000,4 9 23 31,13 28 31 +29,Philosophical,Exploratory,Shallow,4,cross,4,4,0,2,4,2,2,0.333333,0.666667,0.500000,1 11 17 24,1 7 11 30 +29,Philosophical,Exploratory,Shallow,8,same,8,3,-5,3,5,0,5,0.375000,0.625000,0.375000,4 6 9 13 23 28 31 34,13 28 31 +29,Philosophical,Exploratory,Shallow,8,cross,8,8,0,3,10,5,5,0.230769,0.769231,0.375000,1 3 10 12 15 17 19 22,1 3 7 10 11 21 30 32 +29,Philosophical,Exploratory,Contextual,1,same,1,1,0,0,2,1,1,0.000000,1.000000,0.000000,4,13 +29,Philosophical,Exploratory,Contextual,1,cross,1,1,0,1,0,0,0,1.000000,0.000000,1.000000,1,1 +29,Philosophical,Exploratory,Contextual,2,same,2,2,0,0,4,2,2,0.000000,1.000000,0.000000,4 23,13 28 +29,Philosophical,Exploratory,Contextual,2,cross,2,2,0,1,2,1,1,0.333333,0.666667,0.500000,1 16,1 10 +29,Philosophical,Exploratory,Contextual,3,same,3,3,0,0,6,3,3,0.000000,1.000000,0.000000,4 9 23,13 28 31 +29,Philosophical,Exploratory,Contextual,3,cross,3,3,0,2,2,1,1,0.500000,0.500000,0.666667,1 11 21,1 7 11 +29,Philosophical,Exploratory,Contextual,4,same,4,3,-1,1,5,2,3,0.166667,0.833333,0.250000,4 9 23 31,13 28 31 +29,Philosophical,Exploratory,Contextual,4,cross,4,4,0,2,4,2,2,0.333333,0.666667,0.500000,1 7 15 18,1 3 7 10 +29,Philosophical,Exploratory,Contextual,8,same,8,3,-5,3,5,0,5,0.375000,0.625000,0.375000,4 6 9 13 23 28 31 34,13 28 31 +29,Philosophical,Exploratory,Contextual,8,cross,8,7,-1,5,5,2,3,0.500000,0.500000,0.625000,1 2 3 7 10 11 15 16,1 3 7 10 11 21 30 +29,Philosophical,Exploratory,Analogical,1,same,1,1,0,0,2,1,1,0.000000,1.000000,0.000000,4,13 +29,Philosophical,Exploratory,Analogical,1,cross,1,1,0,1,0,0,0,1.000000,0.000000,1.000000,3,3 +29,Philosophical,Exploratory,Analogical,2,same,2,2,0,0,4,2,2,0.000000,1.000000,0.000000,4 23,13 28 +29,Philosophical,Exploratory,Analogical,2,cross,2,2,0,2,0,0,0,1.000000,0.000000,1.000000,3 7,3 7 +29,Philosophical,Exploratory,Analogical,3,same,3,3,0,0,6,3,3,0.000000,1.000000,0.000000,4 9 23,13 28 31 +29,Philosophical,Exploratory,Analogical,3,cross,2,2,0,2,0,0,0,1.000000,0.000000,1.000000,3 7,3 7 +29,Philosophical,Exploratory,Analogical,4,same,4,3,-1,1,5,2,3,0.166667,0.833333,0.250000,4 9 23 31,13 28 31 +29,Philosophical,Exploratory,Analogical,4,cross,2,2,0,2,0,0,0,1.000000,0.000000,1.000000,3 7,3 7 +29,Philosophical,Exploratory,Analogical,8,same,8,3,-5,3,5,0,5,0.375000,0.625000,0.375000,4 6 9 13 23 28 31 34,13 28 31 +29,Philosophical,Exploratory,Analogical,8,cross,2,2,0,2,0,0,0,1.000000,0.000000,1.000000,3 7,3 7 +30,Reflective,Meta,Surface,1,same,1,1,0,0,2,1,1,0.000000,1.000000,0.000000,12,32 +30,Reflective,Meta,Surface,1,cross,1,1,0,1,0,0,0,1.000000,0.000000,1.000000,1,1 +30,Reflective,Meta,Surface,2,same,2,1,-1,0,3,1,2,0.000000,1.000000,0.000000,12 22,32 +30,Reflective,Meta,Surface,2,cross,2,2,0,1,2,1,1,0.333333,0.666667,0.500000,1 11,1 13 +30,Reflective,Meta,Surface,3,same,3,1,-2,0,4,1,3,0.000000,1.000000,0.000000,12 18 25,32 +30,Reflective,Meta,Surface,3,cross,3,3,0,1,4,2,2,0.200000,0.800000,0.333333,1 7 17,1 10 21 +30,Reflective,Meta,Surface,4,same,4,1,-3,0,5,1,4,0.000000,1.000000,0.000000,12 16 22 27,32 +30,Reflective,Meta,Surface,4,cross,4,4,0,2,4,2,2,0.333333,0.666667,0.500000,1 6 11 23,1 7 11 21 +30,Reflective,Meta,Surface,8,same,8,1,-7,0,9,1,8,0.000000,1.000000,0.000000,12 14 15 16 18 19 22 24,32 +30,Reflective,Meta,Surface,8,cross,8,8,0,3,10,5,5,0.230769,0.769231,0.375000,1 3 6 9 11 17 23 30,1 3 7 10 11 13 21 28 +30,Reflective,Meta,Shallow,1,same,1,1,0,0,2,1,1,0.000000,1.000000,0.000000,12,32 +30,Reflective,Meta,Shallow,1,cross,1,1,0,1,0,0,0,1.000000,0.000000,1.000000,1,1 +30,Reflective,Meta,Shallow,2,same,2,1,-1,0,3,1,2,0.000000,1.000000,0.000000,12 22,32 +30,Reflective,Meta,Shallow,2,cross,2,2,0,1,2,1,1,0.333333,0.666667,0.500000,1 11,1 13 +30,Reflective,Meta,Shallow,3,same,3,1,-2,0,4,1,3,0.000000,1.000000,0.000000,12 18 25,32 +30,Reflective,Meta,Shallow,3,cross,3,3,0,1,4,2,2,0.200000,0.800000,0.333333,1 7 17,1 10 21 +30,Reflective,Meta,Shallow,4,same,4,1,-3,0,5,1,4,0.000000,1.000000,0.000000,12 16 22 27,32 +30,Reflective,Meta,Shallow,4,cross,4,4,0,2,4,2,2,0.333333,0.666667,0.500000,1 6 11 23,1 7 11 21 +30,Reflective,Meta,Shallow,8,same,8,1,-7,0,9,1,8,0.000000,1.000000,0.000000,12 14 15 16 18 19 22 24,32 +30,Reflective,Meta,Shallow,8,cross,8,8,0,3,10,5,5,0.230769,0.769231,0.375000,1 3 6 9 11 17 23 30,1 3 7 10 11 13 21 28 +30,Reflective,Meta,Contextual,1,same,1,0,-1,0,1,0,1,0.000000,1.000000,0.000000,15, +30,Reflective,Meta,Contextual,1,cross,1,1,0,1,0,0,0,1.000000,0.000000,1.000000,1,1 +30,Reflective,Meta,Contextual,2,same,2,0,-2,0,2,0,2,0.000000,1.000000,0.000000,15 22, +30,Reflective,Meta,Contextual,2,cross,2,2,0,1,2,1,1,0.333333,0.666667,0.500000,1 11,1 13 +30,Reflective,Meta,Contextual,3,same,3,0,-3,0,3,0,3,0.000000,1.000000,0.000000,15 18 29, +30,Reflective,Meta,Contextual,3,cross,3,3,0,1,4,2,2,0.200000,0.800000,0.333333,1 7 17,1 10 21 +30,Reflective,Meta,Contextual,4,same,4,0,-4,0,4,0,4,0.000000,1.000000,0.000000,15 16 18 22, +30,Reflective,Meta,Contextual,4,cross,4,4,0,2,4,2,2,0.333333,0.666667,0.500000,1 6 11 23,1 7 11 21 +30,Reflective,Meta,Contextual,8,same,6,0,-6,0,6,0,6,0.000000,1.000000,0.000000,15 16 18 22 29 33, +30,Reflective,Meta,Contextual,8,cross,8,8,0,3,10,5,5,0.230769,0.769231,0.375000,1 3 6 9 11 17 23 30,1 3 7 10 11 13 21 28 +30,Reflective,Meta,Analogical,1,same,0,0,0,0,0,0,0,1.000000,0.000000,1.000000,, +30,Reflective,Meta,Analogical,1,cross,1,1,0,1,0,0,0,1.000000,0.000000,1.000000,3,3 +30,Reflective,Meta,Analogical,2,same,0,0,0,0,0,0,0,1.000000,0.000000,1.000000,, +30,Reflective,Meta,Analogical,2,cross,2,2,0,2,0,0,0,1.000000,0.000000,1.000000,3 13,3 13 +30,Reflective,Meta,Analogical,3,same,0,0,0,0,0,0,0,1.000000,0.000000,1.000000,, +30,Reflective,Meta,Analogical,3,cross,3,3,0,2,2,1,1,0.500000,0.500000,0.666667,3 7 23,3 7 13 +30,Reflective,Meta,Analogical,4,same,0,0,0,0,0,0,0,1.000000,0.000000,1.000000,, +30,Reflective,Meta,Analogical,4,cross,4,4,0,1,6,3,3,0.142857,0.857143,0.250000,3 6 9 23,3 7 13 28 +30,Reflective,Meta,Analogical,8,same,0,0,0,0,0,0,0,1.000000,0.000000,1.000000,, +30,Reflective,Meta,Analogical,8,cross,8,5,-3,4,5,1,4,0.444444,0.555556,0.500000,3 4 6 7 9 13 23 28,3 7 13 28 31 +31,Contemplative,Meta,Surface,1,same,1,1,0,0,2,1,1,0.000000,1.000000,0.000000,12,32 +31,Contemplative,Meta,Surface,1,cross,1,1,0,1,0,0,0,1.000000,0.000000,1.000000,1,1 +31,Contemplative,Meta,Surface,2,same,2,1,-1,0,3,1,2,0.000000,1.000000,0.000000,12 22,32 +31,Contemplative,Meta,Surface,2,cross,2,2,0,1,2,1,1,0.333333,0.666667,0.500000,1 11,1 13 +31,Contemplative,Meta,Surface,3,same,3,1,-2,0,4,1,3,0.000000,1.000000,0.000000,12 18 25,32 +31,Contemplative,Meta,Surface,3,cross,3,3,0,1,4,2,2,0.200000,0.800000,0.333333,1 7 17,1 10 21 +31,Contemplative,Meta,Surface,4,same,4,1,-3,0,5,1,4,0.000000,1.000000,0.000000,12 16 22 27,32 +31,Contemplative,Meta,Surface,4,cross,4,4,0,2,4,2,2,0.333333,0.666667,0.500000,1 6 11 23,1 7 11 21 +31,Contemplative,Meta,Surface,8,same,8,1,-7,0,9,1,8,0.000000,1.000000,0.000000,12 14 15 16 18 19 22 24,32 +31,Contemplative,Meta,Surface,8,cross,8,8,0,3,10,5,5,0.230769,0.769231,0.375000,1 3 6 9 11 17 23 30,1 3 7 10 11 13 21 28 +31,Contemplative,Meta,Shallow,1,same,1,1,0,0,2,1,1,0.000000,1.000000,0.000000,12,32 +31,Contemplative,Meta,Shallow,1,cross,1,1,0,1,0,0,0,1.000000,0.000000,1.000000,1,1 +31,Contemplative,Meta,Shallow,2,same,2,1,-1,0,3,1,2,0.000000,1.000000,0.000000,12 22,32 +31,Contemplative,Meta,Shallow,2,cross,2,2,0,1,2,1,1,0.333333,0.666667,0.500000,1 11,1 13 +31,Contemplative,Meta,Shallow,3,same,3,1,-2,0,4,1,3,0.000000,1.000000,0.000000,12 18 25,32 +31,Contemplative,Meta,Shallow,3,cross,3,3,0,1,4,2,2,0.200000,0.800000,0.333333,1 7 17,1 10 21 +31,Contemplative,Meta,Shallow,4,same,4,1,-3,0,5,1,4,0.000000,1.000000,0.000000,12 16 22 27,32 +31,Contemplative,Meta,Shallow,4,cross,4,4,0,2,4,2,2,0.333333,0.666667,0.500000,1 6 11 23,1 7 11 21 +31,Contemplative,Meta,Shallow,8,same,8,1,-7,0,9,1,8,0.000000,1.000000,0.000000,12 14 15 16 18 19 22 24,32 +31,Contemplative,Meta,Shallow,8,cross,8,8,0,3,10,5,5,0.230769,0.769231,0.375000,1 3 6 9 11 17 23 30,1 3 7 10 11 13 21 28 +31,Contemplative,Meta,Contextual,1,same,1,0,-1,0,1,0,1,0.000000,1.000000,0.000000,15, +31,Contemplative,Meta,Contextual,1,cross,1,1,0,1,0,0,0,1.000000,0.000000,1.000000,1,1 +31,Contemplative,Meta,Contextual,2,same,2,0,-2,0,2,0,2,0.000000,1.000000,0.000000,15 22, +31,Contemplative,Meta,Contextual,2,cross,2,2,0,1,2,1,1,0.333333,0.666667,0.500000,1 11,1 13 +31,Contemplative,Meta,Contextual,3,same,3,0,-3,0,3,0,3,0.000000,1.000000,0.000000,15 18 29, +31,Contemplative,Meta,Contextual,3,cross,3,3,0,1,4,2,2,0.200000,0.800000,0.333333,1 7 17,1 10 21 +31,Contemplative,Meta,Contextual,4,same,4,0,-4,0,4,0,4,0.000000,1.000000,0.000000,15 16 18 22, +31,Contemplative,Meta,Contextual,4,cross,4,4,0,2,4,2,2,0.333333,0.666667,0.500000,1 6 11 23,1 7 11 21 +31,Contemplative,Meta,Contextual,8,same,6,0,-6,0,6,0,6,0.000000,1.000000,0.000000,15 16 18 22 29 33, +31,Contemplative,Meta,Contextual,8,cross,8,8,0,3,10,5,5,0.230769,0.769231,0.375000,1 3 6 9 11 17 23 30,1 3 7 10 11 13 21 28 +31,Contemplative,Meta,Analogical,1,same,0,0,0,0,0,0,0,1.000000,0.000000,1.000000,, +31,Contemplative,Meta,Analogical,1,cross,1,1,0,1,0,0,0,1.000000,0.000000,1.000000,3,3 +31,Contemplative,Meta,Analogical,2,same,0,0,0,0,0,0,0,1.000000,0.000000,1.000000,, +31,Contemplative,Meta,Analogical,2,cross,2,2,0,2,0,0,0,1.000000,0.000000,1.000000,3 13,3 13 +31,Contemplative,Meta,Analogical,3,same,0,0,0,0,0,0,0,1.000000,0.000000,1.000000,, +31,Contemplative,Meta,Analogical,3,cross,3,3,0,2,2,1,1,0.500000,0.500000,0.666667,3 7 23,3 7 13 +31,Contemplative,Meta,Analogical,4,same,0,0,0,0,0,0,0,1.000000,0.000000,1.000000,, +31,Contemplative,Meta,Analogical,4,cross,4,4,0,1,6,3,3,0.142857,0.857143,0.250000,3 6 9 23,3 7 13 28 +31,Contemplative,Meta,Analogical,8,same,0,0,0,0,0,0,0,1.000000,0.000000,1.000000,, +31,Contemplative,Meta,Analogical,8,cross,8,5,-3,4,5,1,4,0.444444,0.555556,0.500000,3 4 6 7 9 13 23 28,3 7 13 28 31 +32,Metacognitive,Meta,Surface,1,same,1,1,0,0,2,1,1,0.000000,1.000000,0.000000,12,32 +32,Metacognitive,Meta,Surface,1,cross,1,1,0,1,0,0,0,1.000000,0.000000,1.000000,1,1 +32,Metacognitive,Meta,Surface,2,same,2,1,-1,0,3,1,2,0.000000,1.000000,0.000000,12 22,32 +32,Metacognitive,Meta,Surface,2,cross,2,2,0,1,2,1,1,0.333333,0.666667,0.500000,1 11,1 13 +32,Metacognitive,Meta,Surface,3,same,3,1,-2,0,4,1,3,0.000000,1.000000,0.000000,12 18 25,32 +32,Metacognitive,Meta,Surface,3,cross,3,3,0,1,4,2,2,0.200000,0.800000,0.333333,1 7 17,1 10 21 +32,Metacognitive,Meta,Surface,4,same,4,1,-3,0,5,1,4,0.000000,1.000000,0.000000,12 16 22 27,32 +32,Metacognitive,Meta,Surface,4,cross,4,4,0,2,4,2,2,0.333333,0.666667,0.500000,1 6 11 23,1 7 11 21 +32,Metacognitive,Meta,Surface,8,same,8,1,-7,0,9,1,8,0.000000,1.000000,0.000000,12 14 15 16 18 19 22 24,32 +32,Metacognitive,Meta,Surface,8,cross,8,8,0,3,10,5,5,0.230769,0.769231,0.375000,1 3 6 9 11 17 23 30,1 3 7 10 11 13 21 28 +32,Metacognitive,Meta,Shallow,1,same,1,1,0,0,2,1,1,0.000000,1.000000,0.000000,12,32 +32,Metacognitive,Meta,Shallow,1,cross,1,1,0,1,0,0,0,1.000000,0.000000,1.000000,1,1 +32,Metacognitive,Meta,Shallow,2,same,2,1,-1,0,3,1,2,0.000000,1.000000,0.000000,12 22,32 +32,Metacognitive,Meta,Shallow,2,cross,2,2,0,1,2,1,1,0.333333,0.666667,0.500000,1 11,1 13 +32,Metacognitive,Meta,Shallow,3,same,3,1,-2,0,4,1,3,0.000000,1.000000,0.000000,12 18 25,32 +32,Metacognitive,Meta,Shallow,3,cross,3,3,0,1,4,2,2,0.200000,0.800000,0.333333,1 7 17,1 10 21 +32,Metacognitive,Meta,Shallow,4,same,4,1,-3,0,5,1,4,0.000000,1.000000,0.000000,12 16 22 27,32 +32,Metacognitive,Meta,Shallow,4,cross,4,4,0,2,4,2,2,0.333333,0.666667,0.500000,1 6 11 23,1 7 11 21 +32,Metacognitive,Meta,Shallow,8,same,8,1,-7,0,9,1,8,0.000000,1.000000,0.000000,12 14 15 16 18 19 22 24,32 +32,Metacognitive,Meta,Shallow,8,cross,8,8,0,3,10,5,5,0.230769,0.769231,0.375000,1 3 6 9 11 17 23 30,1 3 7 10 11 13 21 28 +32,Metacognitive,Meta,Contextual,1,same,1,0,-1,0,1,0,1,0.000000,1.000000,0.000000,15, +32,Metacognitive,Meta,Contextual,1,cross,1,1,0,1,0,0,0,1.000000,0.000000,1.000000,1,1 +32,Metacognitive,Meta,Contextual,2,same,2,0,-2,0,2,0,2,0.000000,1.000000,0.000000,15 22, +32,Metacognitive,Meta,Contextual,2,cross,2,2,0,1,2,1,1,0.333333,0.666667,0.500000,1 11,1 13 +32,Metacognitive,Meta,Contextual,3,same,3,0,-3,0,3,0,3,0.000000,1.000000,0.000000,15 18 29, +32,Metacognitive,Meta,Contextual,3,cross,3,3,0,1,4,2,2,0.200000,0.800000,0.333333,1 7 17,1 10 21 +32,Metacognitive,Meta,Contextual,4,same,4,0,-4,0,4,0,4,0.000000,1.000000,0.000000,15 16 18 22, +32,Metacognitive,Meta,Contextual,4,cross,4,4,0,2,4,2,2,0.333333,0.666667,0.500000,1 6 11 23,1 7 11 21 +32,Metacognitive,Meta,Contextual,8,same,6,0,-6,0,6,0,6,0.000000,1.000000,0.000000,15 16 18 22 29 33, +32,Metacognitive,Meta,Contextual,8,cross,8,8,0,3,10,5,5,0.230769,0.769231,0.375000,1 3 6 9 11 17 23 30,1 3 7 10 11 13 21 28 +32,Metacognitive,Meta,Analogical,1,same,0,0,0,0,0,0,0,1.000000,0.000000,1.000000,, +32,Metacognitive,Meta,Analogical,1,cross,1,1,0,1,0,0,0,1.000000,0.000000,1.000000,3,3 +32,Metacognitive,Meta,Analogical,2,same,0,0,0,0,0,0,0,1.000000,0.000000,1.000000,, +32,Metacognitive,Meta,Analogical,2,cross,2,2,0,2,0,0,0,1.000000,0.000000,1.000000,3 13,3 13 +32,Metacognitive,Meta,Analogical,3,same,0,0,0,0,0,0,0,1.000000,0.000000,1.000000,, +32,Metacognitive,Meta,Analogical,3,cross,3,3,0,2,2,1,1,0.500000,0.500000,0.666667,3 7 23,3 7 13 +32,Metacognitive,Meta,Analogical,4,same,0,0,0,0,0,0,0,1.000000,0.000000,1.000000,, +32,Metacognitive,Meta,Analogical,4,cross,4,4,0,1,6,3,3,0.142857,0.857143,0.250000,3 6 9 23,3 7 13 28 +32,Metacognitive,Meta,Analogical,8,same,0,0,0,0,0,0,0,1.000000,0.000000,1.000000,, +32,Metacognitive,Meta,Analogical,8,cross,8,5,-3,4,5,1,4,0.444444,0.555556,0.500000,3 4 6 7 9 13 23 28,3 7 13 28 31 +33,Wise,Meta,Surface,1,same,1,1,0,0,2,1,1,0.000000,1.000000,0.000000,12,32 +33,Wise,Meta,Surface,1,cross,1,1,0,1,0,0,0,1.000000,0.000000,1.000000,1,1 +33,Wise,Meta,Surface,2,same,2,1,-1,0,3,1,2,0.000000,1.000000,0.000000,12 22,32 +33,Wise,Meta,Surface,2,cross,2,2,0,1,2,1,1,0.333333,0.666667,0.500000,1 11,1 13 +33,Wise,Meta,Surface,3,same,3,1,-2,0,4,1,3,0.000000,1.000000,0.000000,12 18 25,32 +33,Wise,Meta,Surface,3,cross,3,3,0,1,4,2,2,0.200000,0.800000,0.333333,1 7 17,1 10 21 +33,Wise,Meta,Surface,4,same,4,1,-3,0,5,1,4,0.000000,1.000000,0.000000,12 16 22 27,32 +33,Wise,Meta,Surface,4,cross,4,4,0,2,4,2,2,0.333333,0.666667,0.500000,1 6 11 23,1 7 11 21 +33,Wise,Meta,Surface,8,same,8,1,-7,0,9,1,8,0.000000,1.000000,0.000000,12 14 15 16 18 19 22 24,32 +33,Wise,Meta,Surface,8,cross,8,8,0,3,10,5,5,0.230769,0.769231,0.375000,1 3 6 9 11 17 23 30,1 3 7 10 11 13 21 28 +33,Wise,Meta,Shallow,1,same,1,1,0,0,2,1,1,0.000000,1.000000,0.000000,12,32 +33,Wise,Meta,Shallow,1,cross,1,1,0,1,0,0,0,1.000000,0.000000,1.000000,1,1 +33,Wise,Meta,Shallow,2,same,2,1,-1,0,3,1,2,0.000000,1.000000,0.000000,12 22,32 +33,Wise,Meta,Shallow,2,cross,2,2,0,1,2,1,1,0.333333,0.666667,0.500000,1 11,1 13 +33,Wise,Meta,Shallow,3,same,3,1,-2,0,4,1,3,0.000000,1.000000,0.000000,12 18 25,32 +33,Wise,Meta,Shallow,3,cross,3,3,0,1,4,2,2,0.200000,0.800000,0.333333,1 7 17,1 10 21 +33,Wise,Meta,Shallow,4,same,4,1,-3,0,5,1,4,0.000000,1.000000,0.000000,12 16 22 27,32 +33,Wise,Meta,Shallow,4,cross,4,4,0,2,4,2,2,0.333333,0.666667,0.500000,1 6 11 23,1 7 11 21 +33,Wise,Meta,Shallow,8,same,8,1,-7,0,9,1,8,0.000000,1.000000,0.000000,12 14 15 16 18 19 22 24,32 +33,Wise,Meta,Shallow,8,cross,8,8,0,3,10,5,5,0.230769,0.769231,0.375000,1 3 6 9 11 17 23 30,1 3 7 10 11 13 21 28 +33,Wise,Meta,Contextual,1,same,1,0,-1,0,1,0,1,0.000000,1.000000,0.000000,15, +33,Wise,Meta,Contextual,1,cross,1,1,0,1,0,0,0,1.000000,0.000000,1.000000,1,1 +33,Wise,Meta,Contextual,2,same,2,0,-2,0,2,0,2,0.000000,1.000000,0.000000,15 22, +33,Wise,Meta,Contextual,2,cross,2,2,0,1,2,1,1,0.333333,0.666667,0.500000,1 11,1 13 +33,Wise,Meta,Contextual,3,same,3,0,-3,0,3,0,3,0.000000,1.000000,0.000000,15 18 29, +33,Wise,Meta,Contextual,3,cross,3,3,0,1,4,2,2,0.200000,0.800000,0.333333,1 7 17,1 10 21 +33,Wise,Meta,Contextual,4,same,4,0,-4,0,4,0,4,0.000000,1.000000,0.000000,15 16 18 22, +33,Wise,Meta,Contextual,4,cross,4,4,0,2,4,2,2,0.333333,0.666667,0.500000,1 6 11 23,1 7 11 21 +33,Wise,Meta,Contextual,8,same,6,0,-6,0,6,0,6,0.000000,1.000000,0.000000,15 16 18 22 29 33, +33,Wise,Meta,Contextual,8,cross,8,8,0,3,10,5,5,0.230769,0.769231,0.375000,1 3 6 9 11 17 23 30,1 3 7 10 11 13 21 28 +33,Wise,Meta,Analogical,1,same,0,0,0,0,0,0,0,1.000000,0.000000,1.000000,, +33,Wise,Meta,Analogical,1,cross,1,1,0,1,0,0,0,1.000000,0.000000,1.000000,3,3 +33,Wise,Meta,Analogical,2,same,0,0,0,0,0,0,0,1.000000,0.000000,1.000000,, +33,Wise,Meta,Analogical,2,cross,2,2,0,2,0,0,0,1.000000,0.000000,1.000000,3 13,3 13 +33,Wise,Meta,Analogical,3,same,0,0,0,0,0,0,0,1.000000,0.000000,1.000000,, +33,Wise,Meta,Analogical,3,cross,3,3,0,2,2,1,1,0.500000,0.500000,0.666667,3 7 23,3 7 13 +33,Wise,Meta,Analogical,4,same,0,0,0,0,0,0,0,1.000000,0.000000,1.000000,, +33,Wise,Meta,Analogical,4,cross,4,4,0,1,6,3,3,0.142857,0.857143,0.250000,3 6 9 23,3 7 13 28 +33,Wise,Meta,Analogical,8,same,0,0,0,0,0,0,0,1.000000,0.000000,1.000000,, +33,Wise,Meta,Analogical,8,cross,8,5,-3,4,5,1,4,0.444444,0.555556,0.500000,3 4 6 7 9 13 23 28,3 7 13 28 31 +34,Transcendent,Meta,Surface,1,same,1,1,0,0,2,1,1,0.000000,1.000000,0.000000,12,32 +34,Transcendent,Meta,Surface,1,cross,1,1,0,1,0,0,0,1.000000,0.000000,1.000000,1,1 +34,Transcendent,Meta,Surface,2,same,2,1,-1,0,3,1,2,0.000000,1.000000,0.000000,12 22,32 +34,Transcendent,Meta,Surface,2,cross,2,2,0,1,2,1,1,0.333333,0.666667,0.500000,1 11,1 13 +34,Transcendent,Meta,Surface,3,same,3,1,-2,0,4,1,3,0.000000,1.000000,0.000000,12 18 25,32 +34,Transcendent,Meta,Surface,3,cross,3,3,0,1,4,2,2,0.200000,0.800000,0.333333,1 7 17,1 10 21 +34,Transcendent,Meta,Surface,4,same,4,1,-3,0,5,1,4,0.000000,1.000000,0.000000,12 16 22 27,32 +34,Transcendent,Meta,Surface,4,cross,4,4,0,2,4,2,2,0.333333,0.666667,0.500000,1 6 11 23,1 7 11 21 +34,Transcendent,Meta,Surface,8,same,8,1,-7,0,9,1,8,0.000000,1.000000,0.000000,12 14 15 16 18 19 22 24,32 +34,Transcendent,Meta,Surface,8,cross,8,8,0,3,10,5,5,0.230769,0.769231,0.375000,1 3 6 9 11 17 23 30,1 3 7 10 11 13 21 28 +34,Transcendent,Meta,Shallow,1,same,1,1,0,0,2,1,1,0.000000,1.000000,0.000000,12,32 +34,Transcendent,Meta,Shallow,1,cross,1,1,0,1,0,0,0,1.000000,0.000000,1.000000,1,1 +34,Transcendent,Meta,Shallow,2,same,2,1,-1,0,3,1,2,0.000000,1.000000,0.000000,12 22,32 +34,Transcendent,Meta,Shallow,2,cross,2,2,0,1,2,1,1,0.333333,0.666667,0.500000,1 11,1 13 +34,Transcendent,Meta,Shallow,3,same,3,1,-2,0,4,1,3,0.000000,1.000000,0.000000,12 18 25,32 +34,Transcendent,Meta,Shallow,3,cross,3,3,0,1,4,2,2,0.200000,0.800000,0.333333,1 7 17,1 10 21 +34,Transcendent,Meta,Shallow,4,same,4,1,-3,0,5,1,4,0.000000,1.000000,0.000000,12 16 22 27,32 +34,Transcendent,Meta,Shallow,4,cross,4,4,0,2,4,2,2,0.333333,0.666667,0.500000,1 6 11 23,1 7 11 21 +34,Transcendent,Meta,Shallow,8,same,8,1,-7,0,9,1,8,0.000000,1.000000,0.000000,12 14 15 16 18 19 22 24,32 +34,Transcendent,Meta,Shallow,8,cross,8,8,0,3,10,5,5,0.230769,0.769231,0.375000,1 3 6 9 11 17 23 30,1 3 7 10 11 13 21 28 +34,Transcendent,Meta,Contextual,1,same,1,0,-1,0,1,0,1,0.000000,1.000000,0.000000,15, +34,Transcendent,Meta,Contextual,1,cross,1,1,0,1,0,0,0,1.000000,0.000000,1.000000,1,1 +34,Transcendent,Meta,Contextual,2,same,2,0,-2,0,2,0,2,0.000000,1.000000,0.000000,15 22, +34,Transcendent,Meta,Contextual,2,cross,2,2,0,1,2,1,1,0.333333,0.666667,0.500000,1 11,1 13 +34,Transcendent,Meta,Contextual,3,same,3,0,-3,0,3,0,3,0.000000,1.000000,0.000000,15 18 29, +34,Transcendent,Meta,Contextual,3,cross,3,3,0,1,4,2,2,0.200000,0.800000,0.333333,1 7 17,1 10 21 +34,Transcendent,Meta,Contextual,4,same,4,0,-4,0,4,0,4,0.000000,1.000000,0.000000,15 16 18 22, +34,Transcendent,Meta,Contextual,4,cross,4,4,0,2,4,2,2,0.333333,0.666667,0.500000,1 6 11 23,1 7 11 21 +34,Transcendent,Meta,Contextual,8,same,6,0,-6,0,6,0,6,0.000000,1.000000,0.000000,15 16 18 22 29 33, +34,Transcendent,Meta,Contextual,8,cross,8,8,0,3,10,5,5,0.230769,0.769231,0.375000,1 3 6 9 11 17 23 30,1 3 7 10 11 13 21 28 +34,Transcendent,Meta,Analogical,1,same,0,0,0,0,0,0,0,1.000000,0.000000,1.000000,, +34,Transcendent,Meta,Analogical,1,cross,1,1,0,1,0,0,0,1.000000,0.000000,1.000000,3,3 +34,Transcendent,Meta,Analogical,2,same,0,0,0,0,0,0,0,1.000000,0.000000,1.000000,, +34,Transcendent,Meta,Analogical,2,cross,2,2,0,2,0,0,0,1.000000,0.000000,1.000000,3 13,3 13 +34,Transcendent,Meta,Analogical,3,same,0,0,0,0,0,0,0,1.000000,0.000000,1.000000,, +34,Transcendent,Meta,Analogical,3,cross,3,3,0,2,2,1,1,0.500000,0.500000,0.666667,3 7 23,3 7 13 +34,Transcendent,Meta,Analogical,4,same,0,0,0,0,0,0,0,1.000000,0.000000,1.000000,, +34,Transcendent,Meta,Analogical,4,cross,4,4,0,1,6,3,3,0.142857,0.857143,0.250000,3 6 9 23,3 7 13 28 +34,Transcendent,Meta,Analogical,8,same,0,0,0,0,0,0,0,1.000000,0.000000,1.000000,, +34,Transcendent,Meta,Analogical,8,cross,8,5,-3,4,5,1,4,0.444444,0.555556,0.500000,3 4 6 7 9 13 23 28,3 7 13 28 31 +35,Sovereign,Meta,Surface,1,same,1,1,0,0,2,1,1,0.000000,1.000000,0.000000,12,32 +35,Sovereign,Meta,Surface,1,cross,1,1,0,1,0,0,0,1.000000,0.000000,1.000000,1,1 +35,Sovereign,Meta,Surface,2,same,2,1,-1,0,3,1,2,0.000000,1.000000,0.000000,12 22,32 +35,Sovereign,Meta,Surface,2,cross,2,2,0,1,2,1,1,0.333333,0.666667,0.500000,1 11,1 13 +35,Sovereign,Meta,Surface,3,same,3,1,-2,0,4,1,3,0.000000,1.000000,0.000000,12 18 25,32 +35,Sovereign,Meta,Surface,3,cross,3,3,0,1,4,2,2,0.200000,0.800000,0.333333,1 7 17,1 10 21 +35,Sovereign,Meta,Surface,4,same,4,1,-3,0,5,1,4,0.000000,1.000000,0.000000,12 16 22 27,32 +35,Sovereign,Meta,Surface,4,cross,4,4,0,2,4,2,2,0.333333,0.666667,0.500000,1 6 11 23,1 7 11 21 +35,Sovereign,Meta,Surface,8,same,8,1,-7,0,9,1,8,0.000000,1.000000,0.000000,12 14 15 16 18 19 22 24,32 +35,Sovereign,Meta,Surface,8,cross,8,8,0,3,10,5,5,0.230769,0.769231,0.375000,1 3 6 9 11 17 23 30,1 3 7 10 11 13 21 28 +35,Sovereign,Meta,Shallow,1,same,1,1,0,0,2,1,1,0.000000,1.000000,0.000000,12,32 +35,Sovereign,Meta,Shallow,1,cross,1,1,0,1,0,0,0,1.000000,0.000000,1.000000,1,1 +35,Sovereign,Meta,Shallow,2,same,2,1,-1,0,3,1,2,0.000000,1.000000,0.000000,12 22,32 +35,Sovereign,Meta,Shallow,2,cross,2,2,0,1,2,1,1,0.333333,0.666667,0.500000,1 11,1 13 +35,Sovereign,Meta,Shallow,3,same,3,1,-2,0,4,1,3,0.000000,1.000000,0.000000,12 18 25,32 +35,Sovereign,Meta,Shallow,3,cross,3,3,0,1,4,2,2,0.200000,0.800000,0.333333,1 7 17,1 10 21 +35,Sovereign,Meta,Shallow,4,same,4,1,-3,0,5,1,4,0.000000,1.000000,0.000000,12 16 22 27,32 +35,Sovereign,Meta,Shallow,4,cross,4,4,0,2,4,2,2,0.333333,0.666667,0.500000,1 6 11 23,1 7 11 21 +35,Sovereign,Meta,Shallow,8,same,8,1,-7,0,9,1,8,0.000000,1.000000,0.000000,12 14 15 16 18 19 22 24,32 +35,Sovereign,Meta,Shallow,8,cross,8,8,0,3,10,5,5,0.230769,0.769231,0.375000,1 3 6 9 11 17 23 30,1 3 7 10 11 13 21 28 +35,Sovereign,Meta,Contextual,1,same,1,0,-1,0,1,0,1,0.000000,1.000000,0.000000,15, +35,Sovereign,Meta,Contextual,1,cross,1,1,0,1,0,0,0,1.000000,0.000000,1.000000,1,1 +35,Sovereign,Meta,Contextual,2,same,2,0,-2,0,2,0,2,0.000000,1.000000,0.000000,15 22, +35,Sovereign,Meta,Contextual,2,cross,2,2,0,1,2,1,1,0.333333,0.666667,0.500000,1 11,1 13 +35,Sovereign,Meta,Contextual,3,same,3,0,-3,0,3,0,3,0.000000,1.000000,0.000000,15 18 29, +35,Sovereign,Meta,Contextual,3,cross,3,3,0,1,4,2,2,0.200000,0.800000,0.333333,1 7 17,1 10 21 +35,Sovereign,Meta,Contextual,4,same,4,0,-4,0,4,0,4,0.000000,1.000000,0.000000,15 16 18 22, +35,Sovereign,Meta,Contextual,4,cross,4,4,0,2,4,2,2,0.333333,0.666667,0.500000,1 6 11 23,1 7 11 21 +35,Sovereign,Meta,Contextual,8,same,6,0,-6,0,6,0,6,0.000000,1.000000,0.000000,15 16 18 22 29 33, +35,Sovereign,Meta,Contextual,8,cross,8,8,0,3,10,5,5,0.230769,0.769231,0.375000,1 3 6 9 11 17 23 30,1 3 7 10 11 13 21 28 +35,Sovereign,Meta,Analogical,1,same,0,0,0,0,0,0,0,1.000000,0.000000,1.000000,, +35,Sovereign,Meta,Analogical,1,cross,1,1,0,1,0,0,0,1.000000,0.000000,1.000000,3,3 +35,Sovereign,Meta,Analogical,2,same,0,0,0,0,0,0,0,1.000000,0.000000,1.000000,, +35,Sovereign,Meta,Analogical,2,cross,2,2,0,2,0,0,0,1.000000,0.000000,1.000000,3 13,3 13 +35,Sovereign,Meta,Analogical,3,same,0,0,0,0,0,0,0,1.000000,0.000000,1.000000,, +35,Sovereign,Meta,Analogical,3,cross,3,3,0,2,2,1,1,0.500000,0.500000,0.666667,3 7 23,3 7 13 +35,Sovereign,Meta,Analogical,4,same,0,0,0,0,0,0,0,1.000000,0.000000,1.000000,, +35,Sovereign,Meta,Analogical,4,cross,4,4,0,1,6,3,3,0.142857,0.857143,0.250000,3 6 9 23,3 7 13 28 +35,Sovereign,Meta,Analogical,8,same,0,0,0,0,0,0,0,1.000000,0.000000,1.000000,, +35,Sovereign,Meta,Analogical,8,cross,8,5,-3,4,5,1,4,0.444444,0.555556,0.500000,3 4 6 7 9 13 23 28,3 7 13 28 31 diff --git a/docs/probes/stage25-consumer-filter-census.md b/docs/probes/stage25-consumer-filter-census.md new file mode 100644 index 000000000..15220fc3f --- /dev/null +++ b/docs/probes/stage25-consumer-filter-census.md @@ -0,0 +1,109 @@ +# Stage 2.5 — consumer-filter census + +> Generated by `strategy::stage25_census::tests::stage25_write_artifacts` +> (`cargo test -p lance-graph-planner --lib stage25_census -- --ignored`). +> Data: `stage25-consumer-filter-census.csv` (watcher-sample surface, one row +> per style x rung x k x channel — collapsed over `tol`, losslessly, per the +> pinned invariant that the sample cannot depend on it) and +> `stage25-consumer-filter-verdict-discordance.csv` (one row per verdict flip). + +**Design.** 5760 paired configurations = 36 styles x 4 rungs x 5 budgets x 8 tolerances. Each pair holds everything fixed and toggles ONE thing: whether the dissent channels' eligibility predicate carries the maturity clause. Both arms then run the same shipped verdict body (`StyleStrategy::dissent_over`) — nothing here reimplements the channel. + +**Statistics.** `jc::stats` / `jc::reliability`. The census is exhaustive and deterministic, so no inferential test is run over it — there is no sampling distribution for a p-value to describe. What is reported is cross-tabulation (`binary_association`, carrying kappa and the marginals), variance decomposition (`eta_squared`, `multiple_r_squared`), rank association (`spearman`), and ONE genuinely inferential quantity: the exact one-sided binomial bound on an unseen flip rate. + +## A. Watcher-sample effect + +| channel | pairs changed | mean Jaccard dist | mean retention | mean \|Δcount\| | max sym-diff | +|---|---|---|---|---|---| +| same-family (peripheral_dissent) | 4080 / 5760 (70.8%) | 0.5306 | 0.4958 | 0.875 | 9 | +| cross-family (cross_family_dissent) | 4224 / 5760 (73.3%) | 0.5269 | 0.5681 | 0.283 | 10 | + +## D. Stratification of the watcher-sample effect (descriptive eta-squared) + +Proportion of the Jaccard-distance variance attributable to each factor, over the exhaustive design. **Descriptive, not inferential** — a variance decomposition of a census, never a test of a hypothesis about a population. + +| channel | style | rung | k | tol | joint R² (rung,k,tol,style) | +|---|---|---|---|---|---| +| same-family (peripheral_dissent) | 0.5894 | 0.1059 | 0.0772 | 0.0000 | 0.1761 | +| cross-family (cross_family_dissent) | 0.0882 | 0.0340 | 0.4440 | 0.0000 | 0.2763 | + +`tol` is **exactly** 0.0000 in both rows, and that is structural rather than a finding about tolerance: the sampled watcher set depends only on `(rung, want, k)`, so the tolerance cannot move it. It is reported because a NON-zero value there would mean the census had accidentally coupled the two, and `stage25_tolerance_cannot_move_the_watcher_sample` pins it. + +The joint `R²` column is **not comparable to the eta-squared columns** and is routinely SMALLER than the largest of them. `multiple_r_squared` fits the factors as LINEAR predictors over their integer codes, while eta-squared groups them nominally; a factor whose effect is non-monotone in its code (style, most obviously — the code is an enum position, not a quantity) is largely invisible to the linear fit. Read the joint figure as "how much a linear read of the design explains", never as a ceiling on the design's total effect. + +Strongest and weakest strata by mean Jaccard distance: + +- **same-family (peripheral_dissent)** + - strongest: Surface/k=2: 0.8333 · Shallow/k=2: 0.8333 · Contextual/k=2: 0.8333 + - weakest: Analogical/k=3: 0.3333 · Analogical/k=4: 0.2778 · Analogical/k=8: 0.2083 +- **cross-family (cross_family_dissent)** + - strongest: Surface/k=3: 0.8000 · Shallow/k=3: 0.8000 · Surface/k=8: 0.7179 + - weakest: Surface/k=1: 0.0000 · Shallow/k=1: 0.0000 · Contextual/k=1: 0.0000 + +Rank association between the budget `k` and the Jaccard distance: + +- same-family (peripheral_dissent): Spearman rho = -0.1399 +- cross-family (cross_family_dissent): Spearman rho = +0.4056 + +## B. Verdict effect + +### same-family (peripheral_dissent) + +OFF → ON transition matrix (fired / did not fire): + +| | ON: silent | ON: fired | +|---|---|---| +| **OFF: silent** | 2148 | 1098 | +| **OFF: fired** | 0 | 2514 | + +- concordant 4662 / 5760, discordant **1098** / 5760 +- observed verdict-change rate: **0.190625** +- Cohen's kappa = 0.630679 (defined: both categories occur, n11=2514 n00=2148) +- fired 2514 -> 3612 on this channel +- **direction**: 1098 silence -> dissent, 0 dissent -> silence +- **McNemar is NOT computed.** `jc` carries no implementation, and hand-rolling a test statistic into an exhaustive deterministic census — which has no sampling distribution for its p-value to describe — is the failure this report exists to avoid. The transition matrix above carries the same information without the borrowed authority. + +### cross-family (cross_family_dissent) + +OFF → ON transition matrix (fired / did not fire): + +| | ON: silent | ON: fired | +|---|---|---| +| **OFF: silent** | 1104 | 366 | +| **OFF: fired** | 18 | 4272 | + +- concordant 5376 / 5760, discordant **384** / 5760 +- observed verdict-change rate: **0.066667** +- Cohen's kappa = 0.809836 (defined: both categories occur, n11=4272 n00=1104) +- fired 4290 -> 4638 on this channel +- **direction**: 366 silence -> dissent, 18 dissent -> silence +- **McNemar is NOT computed.** `jc` carries no implementation, and hand-rolling a test statistic into an exhaustive deterministic census — which has no sampling distribution for its p-value to describe — is the failure this report exists to avoid. The transition matrix above carries the same information without the borrowed authority. + +### Exact bound on the one surface that IS still zero + +The verdict surface has events now, so a zero-event bound no longer applies to it. What remains exactly zero is the DIRECTION on the same-family channel: **no configuration lost a dissent** (`n10 = 0` of 5,760). That is the coverage claim in its sharpest form — a filter that removes only structurally-mute watchers should be incapable of removing an objection — so that is the quantity worth bounding. + +One-sided Clopper-Pearson upper limit at zero observed events, `1 - alpha^(1/n)`, with **alpha = 0.05** (a 95 % one-sided confidence level). **The 5,760 rows are repeated measures, not independent trials** — one style contributes 160 of them — so the bound is a LADDER over clustering assumptions and each row names the unit it assumes; quote the one whose independence you are willing to defend. + +| independent unit | n | upper bound on flip rate | +|---|---|---| +| one (style, rung, k, tol) cell — every cell its own trial; OPTIMISTIC | 5760 | 5.200e-4 | +| one (style, rung) cell — k and tol treated as within-cell repeats | 144 | 2.059e-2 | +| one style — a style's whole 160-cell block as one observation | 36 | 7.985e-2 | +| one style cluster — styles in a cluster share a Mechanism; most conservative | 6 | 3.930e-1 | + +## C. Pre-verdict numeric + +The margin the channel actually thresholds — `|tc.confidence - admitted|` against `tol` — is local to `dissent_over` and is not returned. **It was not exposed for this measurement.** What IS naturally available is finer than fired/not-fired and is what the numbers above are computed over: the elevation `RungLevel` (which watcher objected) and, on the cross-family channel, the reported `Mechanism` — both encoded into ONE nominal label by `cross_label`, so a swap to a different mechanism at the same rung counts as a change rather than passing as agreement. + +That encoding is a correction, not a flourish. The first version of this census reduced the cross-family verdict to its rung and would have reported such a swap as concordant while the report claimed the mechanism agreed — a measurement that never looked at the thing it certified. + +## Headline + +- **same-family (peripheral_dissent): consumer filtering materially changes watcher sampling** — 4080/5760 configurations differ (70.8%), mean Jaccard distance 0.5306, mean retention 0.4958. **Verdict change: 1098/5760**, direction 1098 silence->dissent vs 0 dissent->silence. +- **cross-family (cross_family_dissent): consumer filtering materially changes watcher sampling** — 4224/5760 configurations differ (73.3%), mean Jaccard distance 0.5269, mean retention 0.5681. **Verdict change: 384/5760**, direction 366 silence->dissent vs 18 dissent->silence. + + +**This headline replaces an earlier one that read `0/5,760` on both channels.** That number was real but measured the wrong predicate: the first consumer filter tested `maturity().is_production()`, which admits 31 of 34 kernels, while only 14 can move `delta_conf` — the only quantity either channel compares. The filter was removing 3 mute watchers and admitting 17 more, so it changed the sample and could not change the answer. Corrected after codex review on PR #971. + +Scope, stated so it is not over-read: this is a statement about the measured Stage-2 surface only, under one fixed `PlanContext`. It says nothing about whether the ADDED dissent is correct — only that the periphery now contains instruments that can object, where before a majority of the sampled watchers structurally could not. diff --git a/docs/probes/stage25-consumer-filter-verdict-discordance.csv b/docs/probes/stage25-consumer-filter-verdict-discordance.csv new file mode 100644 index 000000000..55ca7d8b1 --- /dev/null +++ b/docs/probes/stage25-consumer-filter-verdict-discordance.csv @@ -0,0 +1,1483 @@ +style_idx,style,rung,k,tol,channel,verdict_off,verdict_on +0,Logical,Surface,2,0.1,cross,0,13 +0,Logical,Surface,4,0.1,cross,0,13 +0,Logical,Surface,8,0.1,cross,0,13 +0,Logical,Shallow,2,0.1,cross,0,13 +0,Logical,Shallow,4,0.1,cross,0,13 +0,Logical,Shallow,8,0.1,cross,0,13 +0,Logical,Contextual,4,0.1,cross,0,13 +0,Logical,Contextual,8,0.1,cross,0,13 +0,Logical,Analogical,2,0,cross,0,27 +0,Logical,Analogical,2,0.001,cross,0,27 +0,Logical,Analogical,2,0.005,cross,0,27 +0,Logical,Analogical,2,0.01,cross,0,27 +0,Logical,Analogical,2,0.02,cross,0,27 +0,Logical,Analogical,3,0,cross,0,27 +0,Logical,Analogical,3,0.001,cross,0,27 +0,Logical,Analogical,3,0.005,cross,0,27 +0,Logical,Analogical,3,0.01,cross,0,27 +0,Logical,Analogical,3,0.02,cross,0,27 +0,Logical,Analogical,4,0,cross,0,27 +0,Logical,Analogical,4,0.001,cross,0,27 +0,Logical,Analogical,4,0.005,cross,0,27 +0,Logical,Analogical,4,0.01,cross,0,27 +0,Logical,Analogical,4,0.02,cross,0,27 +1,Analytical,Surface,2,0.1,cross,0,13 +1,Analytical,Surface,4,0.1,cross,0,13 +1,Analytical,Surface,8,0.1,cross,0,13 +1,Analytical,Shallow,2,0.1,cross,0,13 +1,Analytical,Shallow,4,0.1,cross,0,13 +1,Analytical,Shallow,8,0.1,cross,0,13 +1,Analytical,Contextual,4,0.1,cross,0,13 +1,Analytical,Contextual,8,0.1,cross,0,13 +1,Analytical,Analogical,2,0,cross,0,27 +1,Analytical,Analogical,2,0.001,cross,0,27 +1,Analytical,Analogical,2,0.005,cross,0,27 +1,Analytical,Analogical,2,0.01,cross,0,27 +1,Analytical,Analogical,2,0.02,cross,0,27 +1,Analytical,Analogical,3,0,cross,0,27 +1,Analytical,Analogical,3,0.001,cross,0,27 +1,Analytical,Analogical,3,0.005,cross,0,27 +1,Analytical,Analogical,3,0.01,cross,0,27 +1,Analytical,Analogical,3,0.02,cross,0,27 +1,Analytical,Analogical,4,0,cross,0,27 +1,Analytical,Analogical,4,0.001,cross,0,27 +1,Analytical,Analogical,4,0.005,cross,0,27 +1,Analytical,Analogical,4,0.01,cross,0,27 +1,Analytical,Analogical,4,0.02,cross,0,27 +2,Critical,Surface,2,0.1,cross,0,13 +2,Critical,Surface,4,0.1,cross,0,13 +2,Critical,Surface,8,0.1,cross,0,13 +2,Critical,Shallow,2,0.1,cross,0,13 +2,Critical,Shallow,4,0.1,cross,0,13 +2,Critical,Shallow,8,0.1,cross,0,13 +2,Critical,Contextual,4,0.1,cross,0,13 +2,Critical,Contextual,8,0.1,cross,0,13 +2,Critical,Analogical,2,0,cross,0,27 +2,Critical,Analogical,2,0.001,cross,0,27 +2,Critical,Analogical,2,0.005,cross,0,27 +2,Critical,Analogical,2,0.01,cross,0,27 +2,Critical,Analogical,2,0.02,cross,0,27 +2,Critical,Analogical,3,0,cross,0,27 +2,Critical,Analogical,3,0.001,cross,0,27 +2,Critical,Analogical,3,0.005,cross,0,27 +2,Critical,Analogical,3,0.01,cross,0,27 +2,Critical,Analogical,3,0.02,cross,0,27 +2,Critical,Analogical,4,0,cross,0,27 +2,Critical,Analogical,4,0.001,cross,0,27 +2,Critical,Analogical,4,0.005,cross,0,27 +2,Critical,Analogical,4,0.01,cross,0,27 +2,Critical,Analogical,4,0.02,cross,0,27 +3,Systematic,Surface,2,0.1,cross,0,13 +3,Systematic,Surface,4,0.1,cross,0,13 +3,Systematic,Surface,8,0.1,cross,0,13 +3,Systematic,Shallow,2,0.1,cross,0,13 +3,Systematic,Shallow,4,0.1,cross,0,13 +3,Systematic,Shallow,8,0.1,cross,0,13 +3,Systematic,Contextual,4,0.1,cross,0,13 +3,Systematic,Contextual,8,0.1,cross,0,13 +3,Systematic,Analogical,2,0,cross,0,27 +3,Systematic,Analogical,2,0.001,cross,0,27 +3,Systematic,Analogical,2,0.005,cross,0,27 +3,Systematic,Analogical,2,0.01,cross,0,27 +3,Systematic,Analogical,2,0.02,cross,0,27 +3,Systematic,Analogical,3,0,cross,0,27 +3,Systematic,Analogical,3,0.001,cross,0,27 +3,Systematic,Analogical,3,0.005,cross,0,27 +3,Systematic,Analogical,3,0.01,cross,0,27 +3,Systematic,Analogical,3,0.02,cross,0,27 +3,Systematic,Analogical,4,0,cross,0,27 +3,Systematic,Analogical,4,0.001,cross,0,27 +3,Systematic,Analogical,4,0.005,cross,0,27 +3,Systematic,Analogical,4,0.01,cross,0,27 +3,Systematic,Analogical,4,0.02,cross,0,27 +4,Methodical,Surface,2,0.1,cross,0,13 +4,Methodical,Surface,4,0.1,cross,0,13 +4,Methodical,Surface,8,0.1,cross,0,13 +4,Methodical,Shallow,2,0.1,cross,0,13 +4,Methodical,Shallow,4,0.1,cross,0,13 +4,Methodical,Shallow,8,0.1,cross,0,13 +4,Methodical,Contextual,4,0.1,cross,0,13 +4,Methodical,Contextual,8,0.1,cross,0,13 +4,Methodical,Analogical,2,0,cross,0,27 +4,Methodical,Analogical,2,0.001,cross,0,27 +4,Methodical,Analogical,2,0.005,cross,0,27 +4,Methodical,Analogical,2,0.01,cross,0,27 +4,Methodical,Analogical,2,0.02,cross,0,27 +4,Methodical,Analogical,3,0,cross,0,27 +4,Methodical,Analogical,3,0.001,cross,0,27 +4,Methodical,Analogical,3,0.005,cross,0,27 +4,Methodical,Analogical,3,0.01,cross,0,27 +4,Methodical,Analogical,3,0.02,cross,0,27 +4,Methodical,Analogical,4,0,cross,0,27 +4,Methodical,Analogical,4,0.001,cross,0,27 +4,Methodical,Analogical,4,0.005,cross,0,27 +4,Methodical,Analogical,4,0.01,cross,0,27 +4,Methodical,Analogical,4,0.02,cross,0,27 +5,Precise,Surface,2,0.1,cross,0,13 +5,Precise,Surface,4,0.1,cross,0,13 +5,Precise,Surface,8,0.1,cross,0,13 +5,Precise,Shallow,2,0.1,cross,0,13 +5,Precise,Shallow,4,0.1,cross,0,13 +5,Precise,Shallow,8,0.1,cross,0,13 +5,Precise,Contextual,4,0.1,cross,0,13 +5,Precise,Contextual,8,0.1,cross,0,13 +5,Precise,Analogical,2,0,cross,0,27 +5,Precise,Analogical,2,0.001,cross,0,27 +5,Precise,Analogical,2,0.005,cross,0,27 +5,Precise,Analogical,2,0.01,cross,0,27 +5,Precise,Analogical,2,0.02,cross,0,27 +5,Precise,Analogical,3,0,cross,0,27 +5,Precise,Analogical,3,0.001,cross,0,27 +5,Precise,Analogical,3,0.005,cross,0,27 +5,Precise,Analogical,3,0.01,cross,0,27 +5,Precise,Analogical,3,0.02,cross,0,27 +5,Precise,Analogical,4,0,cross,0,27 +5,Precise,Analogical,4,0.001,cross,0,27 +5,Precise,Analogical,4,0.005,cross,0,27 +5,Precise,Analogical,4,0.01,cross,0,27 +5,Precise,Analogical,4,0.02,cross,0,27 +6,Creative,Surface,2,0,same,0,7 +6,Creative,Surface,2,0.001,same,0,7 +6,Creative,Surface,2,0.005,same,0,7 +6,Creative,Surface,2,0.01,same,0,7 +6,Creative,Surface,2,0.02,same,0,7 +6,Creative,Surface,3,0,same,0,7 +6,Creative,Surface,3,0.001,same,0,7 +6,Creative,Surface,3,0.005,same,0,7 +6,Creative,Surface,3,0.01,same,0,7 +6,Creative,Surface,3,0.02,same,0,7 +6,Creative,Surface,3,0.1,cross,0,26 +6,Creative,Surface,4,0,same,0,7 +6,Creative,Surface,4,0.001,same,0,7 +6,Creative,Surface,4,0.005,same,0,7 +6,Creative,Surface,4,0.01,same,0,7 +6,Creative,Surface,4,0.02,same,0,7 +6,Creative,Surface,4,0.1,cross,0,26 +6,Creative,Shallow,2,0,same,0,7 +6,Creative,Shallow,2,0.001,same,0,7 +6,Creative,Shallow,2,0.005,same,0,7 +6,Creative,Shallow,2,0.01,same,0,7 +6,Creative,Shallow,2,0.02,same,0,7 +6,Creative,Shallow,3,0,same,0,7 +6,Creative,Shallow,3,0.001,same,0,7 +6,Creative,Shallow,3,0.005,same,0,7 +6,Creative,Shallow,3,0.01,same,0,7 +6,Creative,Shallow,3,0.02,same,0,7 +6,Creative,Shallow,3,0.1,cross,0,26 +6,Creative,Shallow,4,0,same,0,7 +6,Creative,Shallow,4,0.001,same,0,7 +6,Creative,Shallow,4,0.005,same,0,7 +6,Creative,Shallow,4,0.01,same,0,7 +6,Creative,Shallow,4,0.02,same,0,7 +6,Creative,Shallow,4,0.1,cross,0,26 +6,Creative,Contextual,2,0,same,0,7 +6,Creative,Contextual,2,0.001,same,0,7 +6,Creative,Contextual,2,0.005,same,0,7 +6,Creative,Contextual,2,0.01,same,0,7 +6,Creative,Contextual,2,0.02,same,0,7 +6,Creative,Contextual,3,0,same,0,7 +6,Creative,Contextual,3,0.001,same,0,7 +6,Creative,Contextual,3,0.005,same,0,7 +6,Creative,Contextual,3,0.01,same,0,7 +6,Creative,Contextual,3,0.02,same,0,7 +6,Creative,Contextual,3,0.1,cross,0,26 +6,Creative,Contextual,4,0,same,0,7 +6,Creative,Contextual,4,0.001,same,0,7 +6,Creative,Contextual,4,0.005,same,0,7 +6,Creative,Contextual,4,0.01,same,0,7 +6,Creative,Contextual,4,0.02,same,0,7 +6,Creative,Analogical,2,0,same,0,7 +6,Creative,Analogical,2,0.001,same,0,7 +6,Creative,Analogical,2,0.005,same,0,7 +6,Creative,Analogical,2,0.01,same,0,7 +6,Creative,Analogical,2,0.02,same,0,7 +6,Creative,Analogical,3,0,same,0,7 +6,Creative,Analogical,3,0.001,same,0,7 +6,Creative,Analogical,3,0.005,same,0,7 +6,Creative,Analogical,3,0.01,same,0,7 +6,Creative,Analogical,3,0.02,same,0,7 +6,Creative,Analogical,4,0,same,0,7 +6,Creative,Analogical,4,0.001,same,0,7 +6,Creative,Analogical,4,0.005,same,0,7 +6,Creative,Analogical,4,0.01,same,0,7 +6,Creative,Analogical,4,0.02,same,0,7 +7,Imaginative,Surface,2,0,same,0,7 +7,Imaginative,Surface,2,0.001,same,0,7 +7,Imaginative,Surface,2,0.005,same,0,7 +7,Imaginative,Surface,2,0.01,same,0,7 +7,Imaginative,Surface,2,0.02,same,0,7 +7,Imaginative,Surface,3,0,same,0,7 +7,Imaginative,Surface,3,0.001,same,0,7 +7,Imaginative,Surface,3,0.005,same,0,7 +7,Imaginative,Surface,3,0.01,same,0,7 +7,Imaginative,Surface,3,0.02,same,0,7 +7,Imaginative,Surface,3,0.1,cross,0,26 +7,Imaginative,Surface,4,0,same,0,7 +7,Imaginative,Surface,4,0.001,same,0,7 +7,Imaginative,Surface,4,0.005,same,0,7 +7,Imaginative,Surface,4,0.01,same,0,7 +7,Imaginative,Surface,4,0.02,same,0,7 +7,Imaginative,Surface,4,0.1,cross,0,26 +7,Imaginative,Shallow,2,0,same,0,7 +7,Imaginative,Shallow,2,0.001,same,0,7 +7,Imaginative,Shallow,2,0.005,same,0,7 +7,Imaginative,Shallow,2,0.01,same,0,7 +7,Imaginative,Shallow,2,0.02,same,0,7 +7,Imaginative,Shallow,3,0,same,0,7 +7,Imaginative,Shallow,3,0.001,same,0,7 +7,Imaginative,Shallow,3,0.005,same,0,7 +7,Imaginative,Shallow,3,0.01,same,0,7 +7,Imaginative,Shallow,3,0.02,same,0,7 +7,Imaginative,Shallow,3,0.1,cross,0,26 +7,Imaginative,Shallow,4,0,same,0,7 +7,Imaginative,Shallow,4,0.001,same,0,7 +7,Imaginative,Shallow,4,0.005,same,0,7 +7,Imaginative,Shallow,4,0.01,same,0,7 +7,Imaginative,Shallow,4,0.02,same,0,7 +7,Imaginative,Shallow,4,0.1,cross,0,26 +7,Imaginative,Contextual,2,0,same,0,7 +7,Imaginative,Contextual,2,0.001,same,0,7 +7,Imaginative,Contextual,2,0.005,same,0,7 +7,Imaginative,Contextual,2,0.01,same,0,7 +7,Imaginative,Contextual,2,0.02,same,0,7 +7,Imaginative,Contextual,3,0,same,0,7 +7,Imaginative,Contextual,3,0.001,same,0,7 +7,Imaginative,Contextual,3,0.005,same,0,7 +7,Imaginative,Contextual,3,0.01,same,0,7 +7,Imaginative,Contextual,3,0.02,same,0,7 +7,Imaginative,Contextual,3,0.1,cross,0,26 +7,Imaginative,Contextual,4,0,same,0,7 +7,Imaginative,Contextual,4,0.001,same,0,7 +7,Imaginative,Contextual,4,0.005,same,0,7 +7,Imaginative,Contextual,4,0.01,same,0,7 +7,Imaginative,Contextual,4,0.02,same,0,7 +7,Imaginative,Analogical,2,0,same,0,7 +7,Imaginative,Analogical,2,0.001,same,0,7 +7,Imaginative,Analogical,2,0.005,same,0,7 +7,Imaginative,Analogical,2,0.01,same,0,7 +7,Imaginative,Analogical,2,0.02,same,0,7 +7,Imaginative,Analogical,3,0,same,0,7 +7,Imaginative,Analogical,3,0.001,same,0,7 +7,Imaginative,Analogical,3,0.005,same,0,7 +7,Imaginative,Analogical,3,0.01,same,0,7 +7,Imaginative,Analogical,3,0.02,same,0,7 +7,Imaginative,Analogical,4,0,same,0,7 +7,Imaginative,Analogical,4,0.001,same,0,7 +7,Imaginative,Analogical,4,0.005,same,0,7 +7,Imaginative,Analogical,4,0.01,same,0,7 +7,Imaginative,Analogical,4,0.02,same,0,7 +8,Innovative,Surface,2,0,same,0,7 +8,Innovative,Surface,2,0.001,same,0,7 +8,Innovative,Surface,2,0.005,same,0,7 +8,Innovative,Surface,2,0.01,same,0,7 +8,Innovative,Surface,2,0.02,same,0,7 +8,Innovative,Surface,3,0,same,0,7 +8,Innovative,Surface,3,0.001,same,0,7 +8,Innovative,Surface,3,0.005,same,0,7 +8,Innovative,Surface,3,0.01,same,0,7 +8,Innovative,Surface,3,0.02,same,0,7 +8,Innovative,Surface,3,0.1,cross,0,26 +8,Innovative,Surface,4,0,same,0,7 +8,Innovative,Surface,4,0.001,same,0,7 +8,Innovative,Surface,4,0.005,same,0,7 +8,Innovative,Surface,4,0.01,same,0,7 +8,Innovative,Surface,4,0.02,same,0,7 +8,Innovative,Surface,4,0.1,cross,0,26 +8,Innovative,Shallow,2,0,same,0,7 +8,Innovative,Shallow,2,0.001,same,0,7 +8,Innovative,Shallow,2,0.005,same,0,7 +8,Innovative,Shallow,2,0.01,same,0,7 +8,Innovative,Shallow,2,0.02,same,0,7 +8,Innovative,Shallow,3,0,same,0,7 +8,Innovative,Shallow,3,0.001,same,0,7 +8,Innovative,Shallow,3,0.005,same,0,7 +8,Innovative,Shallow,3,0.01,same,0,7 +8,Innovative,Shallow,3,0.02,same,0,7 +8,Innovative,Shallow,3,0.1,cross,0,26 +8,Innovative,Shallow,4,0,same,0,7 +8,Innovative,Shallow,4,0.001,same,0,7 +8,Innovative,Shallow,4,0.005,same,0,7 +8,Innovative,Shallow,4,0.01,same,0,7 +8,Innovative,Shallow,4,0.02,same,0,7 +8,Innovative,Shallow,4,0.1,cross,0,26 +8,Innovative,Contextual,2,0,same,0,7 +8,Innovative,Contextual,2,0.001,same,0,7 +8,Innovative,Contextual,2,0.005,same,0,7 +8,Innovative,Contextual,2,0.01,same,0,7 +8,Innovative,Contextual,2,0.02,same,0,7 +8,Innovative,Contextual,3,0,same,0,7 +8,Innovative,Contextual,3,0.001,same,0,7 +8,Innovative,Contextual,3,0.005,same,0,7 +8,Innovative,Contextual,3,0.01,same,0,7 +8,Innovative,Contextual,3,0.02,same,0,7 +8,Innovative,Contextual,3,0.1,cross,0,26 +8,Innovative,Contextual,4,0,same,0,7 +8,Innovative,Contextual,4,0.001,same,0,7 +8,Innovative,Contextual,4,0.005,same,0,7 +8,Innovative,Contextual,4,0.01,same,0,7 +8,Innovative,Contextual,4,0.02,same,0,7 +8,Innovative,Analogical,2,0,same,0,7 +8,Innovative,Analogical,2,0.001,same,0,7 +8,Innovative,Analogical,2,0.005,same,0,7 +8,Innovative,Analogical,2,0.01,same,0,7 +8,Innovative,Analogical,2,0.02,same,0,7 +8,Innovative,Analogical,3,0,same,0,7 +8,Innovative,Analogical,3,0.001,same,0,7 +8,Innovative,Analogical,3,0.005,same,0,7 +8,Innovative,Analogical,3,0.01,same,0,7 +8,Innovative,Analogical,3,0.02,same,0,7 +8,Innovative,Analogical,4,0,same,0,7 +8,Innovative,Analogical,4,0.001,same,0,7 +8,Innovative,Analogical,4,0.005,same,0,7 +8,Innovative,Analogical,4,0.01,same,0,7 +8,Innovative,Analogical,4,0.02,same,0,7 +9,Artistic,Surface,2,0,same,0,7 +9,Artistic,Surface,2,0.001,same,0,7 +9,Artistic,Surface,2,0.005,same,0,7 +9,Artistic,Surface,2,0.01,same,0,7 +9,Artistic,Surface,2,0.02,same,0,7 +9,Artistic,Surface,3,0,same,0,7 +9,Artistic,Surface,3,0.001,same,0,7 +9,Artistic,Surface,3,0.005,same,0,7 +9,Artistic,Surface,3,0.01,same,0,7 +9,Artistic,Surface,3,0.02,same,0,7 +9,Artistic,Surface,3,0.1,cross,0,26 +9,Artistic,Surface,4,0,same,0,7 +9,Artistic,Surface,4,0.001,same,0,7 +9,Artistic,Surface,4,0.005,same,0,7 +9,Artistic,Surface,4,0.01,same,0,7 +9,Artistic,Surface,4,0.02,same,0,7 +9,Artistic,Surface,4,0.1,cross,0,26 +9,Artistic,Shallow,2,0,same,0,7 +9,Artistic,Shallow,2,0.001,same,0,7 +9,Artistic,Shallow,2,0.005,same,0,7 +9,Artistic,Shallow,2,0.01,same,0,7 +9,Artistic,Shallow,2,0.02,same,0,7 +9,Artistic,Shallow,3,0,same,0,7 +9,Artistic,Shallow,3,0.001,same,0,7 +9,Artistic,Shallow,3,0.005,same,0,7 +9,Artistic,Shallow,3,0.01,same,0,7 +9,Artistic,Shallow,3,0.02,same,0,7 +9,Artistic,Shallow,3,0.1,cross,0,26 +9,Artistic,Shallow,4,0,same,0,7 +9,Artistic,Shallow,4,0.001,same,0,7 +9,Artistic,Shallow,4,0.005,same,0,7 +9,Artistic,Shallow,4,0.01,same,0,7 +9,Artistic,Shallow,4,0.02,same,0,7 +9,Artistic,Shallow,4,0.1,cross,0,26 +9,Artistic,Contextual,2,0,same,0,7 +9,Artistic,Contextual,2,0.001,same,0,7 +9,Artistic,Contextual,2,0.005,same,0,7 +9,Artistic,Contextual,2,0.01,same,0,7 +9,Artistic,Contextual,2,0.02,same,0,7 +9,Artistic,Contextual,3,0,same,0,7 +9,Artistic,Contextual,3,0.001,same,0,7 +9,Artistic,Contextual,3,0.005,same,0,7 +9,Artistic,Contextual,3,0.01,same,0,7 +9,Artistic,Contextual,3,0.02,same,0,7 +9,Artistic,Contextual,3,0.1,cross,0,26 +9,Artistic,Contextual,4,0,same,0,7 +9,Artistic,Contextual,4,0.001,same,0,7 +9,Artistic,Contextual,4,0.005,same,0,7 +9,Artistic,Contextual,4,0.01,same,0,7 +9,Artistic,Contextual,4,0.02,same,0,7 +9,Artistic,Analogical,2,0,same,0,7 +9,Artistic,Analogical,2,0.001,same,0,7 +9,Artistic,Analogical,2,0.005,same,0,7 +9,Artistic,Analogical,2,0.01,same,0,7 +9,Artistic,Analogical,2,0.02,same,0,7 +9,Artistic,Analogical,3,0,same,0,7 +9,Artistic,Analogical,3,0.001,same,0,7 +9,Artistic,Analogical,3,0.005,same,0,7 +9,Artistic,Analogical,3,0.01,same,0,7 +9,Artistic,Analogical,3,0.02,same,0,7 +9,Artistic,Analogical,4,0,same,0,7 +9,Artistic,Analogical,4,0.001,same,0,7 +9,Artistic,Analogical,4,0.005,same,0,7 +9,Artistic,Analogical,4,0.01,same,0,7 +9,Artistic,Analogical,4,0.02,same,0,7 +10,Poetic,Surface,2,0,same,0,7 +10,Poetic,Surface,2,0.001,same,0,7 +10,Poetic,Surface,2,0.005,same,0,7 +10,Poetic,Surface,2,0.01,same,0,7 +10,Poetic,Surface,2,0.02,same,0,7 +10,Poetic,Surface,3,0,same,0,7 +10,Poetic,Surface,3,0.001,same,0,7 +10,Poetic,Surface,3,0.005,same,0,7 +10,Poetic,Surface,3,0.01,same,0,7 +10,Poetic,Surface,3,0.02,same,0,7 +10,Poetic,Surface,3,0.1,cross,0,26 +10,Poetic,Surface,4,0,same,0,7 +10,Poetic,Surface,4,0.001,same,0,7 +10,Poetic,Surface,4,0.005,same,0,7 +10,Poetic,Surface,4,0.01,same,0,7 +10,Poetic,Surface,4,0.02,same,0,7 +10,Poetic,Surface,4,0.1,cross,0,26 +10,Poetic,Shallow,2,0,same,0,7 +10,Poetic,Shallow,2,0.001,same,0,7 +10,Poetic,Shallow,2,0.005,same,0,7 +10,Poetic,Shallow,2,0.01,same,0,7 +10,Poetic,Shallow,2,0.02,same,0,7 +10,Poetic,Shallow,3,0,same,0,7 +10,Poetic,Shallow,3,0.001,same,0,7 +10,Poetic,Shallow,3,0.005,same,0,7 +10,Poetic,Shallow,3,0.01,same,0,7 +10,Poetic,Shallow,3,0.02,same,0,7 +10,Poetic,Shallow,3,0.1,cross,0,26 +10,Poetic,Shallow,4,0,same,0,7 +10,Poetic,Shallow,4,0.001,same,0,7 +10,Poetic,Shallow,4,0.005,same,0,7 +10,Poetic,Shallow,4,0.01,same,0,7 +10,Poetic,Shallow,4,0.02,same,0,7 +10,Poetic,Shallow,4,0.1,cross,0,26 +10,Poetic,Contextual,2,0,same,0,7 +10,Poetic,Contextual,2,0.001,same,0,7 +10,Poetic,Contextual,2,0.005,same,0,7 +10,Poetic,Contextual,2,0.01,same,0,7 +10,Poetic,Contextual,2,0.02,same,0,7 +10,Poetic,Contextual,3,0,same,0,7 +10,Poetic,Contextual,3,0.001,same,0,7 +10,Poetic,Contextual,3,0.005,same,0,7 +10,Poetic,Contextual,3,0.01,same,0,7 +10,Poetic,Contextual,3,0.02,same,0,7 +10,Poetic,Contextual,3,0.1,cross,0,26 +10,Poetic,Contextual,4,0,same,0,7 +10,Poetic,Contextual,4,0.001,same,0,7 +10,Poetic,Contextual,4,0.005,same,0,7 +10,Poetic,Contextual,4,0.01,same,0,7 +10,Poetic,Contextual,4,0.02,same,0,7 +10,Poetic,Analogical,2,0,same,0,7 +10,Poetic,Analogical,2,0.001,same,0,7 +10,Poetic,Analogical,2,0.005,same,0,7 +10,Poetic,Analogical,2,0.01,same,0,7 +10,Poetic,Analogical,2,0.02,same,0,7 +10,Poetic,Analogical,3,0,same,0,7 +10,Poetic,Analogical,3,0.001,same,0,7 +10,Poetic,Analogical,3,0.005,same,0,7 +10,Poetic,Analogical,3,0.01,same,0,7 +10,Poetic,Analogical,3,0.02,same,0,7 +10,Poetic,Analogical,4,0,same,0,7 +10,Poetic,Analogical,4,0.001,same,0,7 +10,Poetic,Analogical,4,0.005,same,0,7 +10,Poetic,Analogical,4,0.01,same,0,7 +10,Poetic,Analogical,4,0.02,same,0,7 +11,Playful,Surface,2,0,same,0,7 +11,Playful,Surface,2,0.001,same,0,7 +11,Playful,Surface,2,0.005,same,0,7 +11,Playful,Surface,2,0.01,same,0,7 +11,Playful,Surface,2,0.02,same,0,7 +11,Playful,Surface,3,0,same,0,7 +11,Playful,Surface,3,0.001,same,0,7 +11,Playful,Surface,3,0.005,same,0,7 +11,Playful,Surface,3,0.01,same,0,7 +11,Playful,Surface,3,0.02,same,0,7 +11,Playful,Surface,3,0.1,cross,0,26 +11,Playful,Surface,4,0,same,0,7 +11,Playful,Surface,4,0.001,same,0,7 +11,Playful,Surface,4,0.005,same,0,7 +11,Playful,Surface,4,0.01,same,0,7 +11,Playful,Surface,4,0.02,same,0,7 +11,Playful,Surface,4,0.1,cross,0,26 +11,Playful,Shallow,2,0,same,0,7 +11,Playful,Shallow,2,0.001,same,0,7 +11,Playful,Shallow,2,0.005,same,0,7 +11,Playful,Shallow,2,0.01,same,0,7 +11,Playful,Shallow,2,0.02,same,0,7 +11,Playful,Shallow,3,0,same,0,7 +11,Playful,Shallow,3,0.001,same,0,7 +11,Playful,Shallow,3,0.005,same,0,7 +11,Playful,Shallow,3,0.01,same,0,7 +11,Playful,Shallow,3,0.02,same,0,7 +11,Playful,Shallow,3,0.1,cross,0,26 +11,Playful,Shallow,4,0,same,0,7 +11,Playful,Shallow,4,0.001,same,0,7 +11,Playful,Shallow,4,0.005,same,0,7 +11,Playful,Shallow,4,0.01,same,0,7 +11,Playful,Shallow,4,0.02,same,0,7 +11,Playful,Shallow,4,0.1,cross,0,26 +11,Playful,Contextual,2,0,same,0,7 +11,Playful,Contextual,2,0.001,same,0,7 +11,Playful,Contextual,2,0.005,same,0,7 +11,Playful,Contextual,2,0.01,same,0,7 +11,Playful,Contextual,2,0.02,same,0,7 +11,Playful,Contextual,3,0,same,0,7 +11,Playful,Contextual,3,0.001,same,0,7 +11,Playful,Contextual,3,0.005,same,0,7 +11,Playful,Contextual,3,0.01,same,0,7 +11,Playful,Contextual,3,0.02,same,0,7 +11,Playful,Contextual,3,0.1,cross,0,26 +11,Playful,Contextual,4,0,same,0,7 +11,Playful,Contextual,4,0.001,same,0,7 +11,Playful,Contextual,4,0.005,same,0,7 +11,Playful,Contextual,4,0.01,same,0,7 +11,Playful,Contextual,4,0.02,same,0,7 +11,Playful,Analogical,2,0,same,0,7 +11,Playful,Analogical,2,0.001,same,0,7 +11,Playful,Analogical,2,0.005,same,0,7 +11,Playful,Analogical,2,0.01,same,0,7 +11,Playful,Analogical,2,0.02,same,0,7 +11,Playful,Analogical,3,0,same,0,7 +11,Playful,Analogical,3,0.001,same,0,7 +11,Playful,Analogical,3,0.005,same,0,7 +11,Playful,Analogical,3,0.01,same,0,7 +11,Playful,Analogical,3,0.02,same,0,7 +11,Playful,Analogical,4,0,same,0,7 +11,Playful,Analogical,4,0.001,same,0,7 +11,Playful,Analogical,4,0.005,same,0,7 +11,Playful,Analogical,4,0.01,same,0,7 +11,Playful,Analogical,4,0.02,same,0,7 +12,Empathetic,Surface,2,0.1,same,0,4 +12,Empathetic,Shallow,2,0.1,same,0,4 +12,Empathetic,Contextual,2,0.1,same,0,4 +13,Compassionate,Surface,2,0.1,same,0,4 +13,Compassionate,Shallow,2,0.1,same,0,4 +13,Compassionate,Contextual,2,0.1,same,0,4 +14,Supportive,Surface,2,0.1,same,0,4 +14,Supportive,Shallow,2,0.1,same,0,4 +14,Supportive,Contextual,2,0.1,same,0,4 +15,Nurturing,Surface,2,0.1,same,0,4 +15,Nurturing,Shallow,2,0.1,same,0,4 +15,Nurturing,Contextual,2,0.1,same,0,4 +16,Gentle,Surface,2,0.1,same,0,4 +16,Gentle,Shallow,2,0.1,same,0,4 +16,Gentle,Contextual,2,0.1,same,0,4 +17,Warm,Surface,2,0.1,same,0,4 +17,Warm,Shallow,2,0.1,same,0,4 +17,Warm,Contextual,2,0.1,same,0,4 +18,Direct,Surface,2,0.1,cross,0,13 +18,Direct,Surface,4,0.1,cross,0,13 +18,Direct,Surface,8,0.1,cross,0,13 +18,Direct,Shallow,2,0.1,cross,0,13 +18,Direct,Shallow,4,0.1,cross,0,13 +18,Direct,Shallow,8,0.1,cross,0,13 +18,Direct,Contextual,4,0.1,cross,0,13 +18,Direct,Contextual,8,0.1,cross,0,13 +18,Direct,Analogical,2,0,cross,0,27 +18,Direct,Analogical,2,0.001,cross,0,27 +18,Direct,Analogical,2,0.005,cross,0,27 +18,Direct,Analogical,2,0.01,cross,0,27 +18,Direct,Analogical,2,0.02,cross,0,27 +18,Direct,Analogical,3,0,cross,0,27 +18,Direct,Analogical,3,0.001,cross,0,27 +18,Direct,Analogical,3,0.005,cross,0,27 +18,Direct,Analogical,3,0.01,cross,0,27 +18,Direct,Analogical,3,0.02,cross,0,27 +18,Direct,Analogical,4,0,cross,0,27 +18,Direct,Analogical,4,0.001,cross,0,27 +18,Direct,Analogical,4,0.005,cross,0,27 +18,Direct,Analogical,4,0.01,cross,0,27 +18,Direct,Analogical,4,0.02,cross,0,27 +19,Concise,Surface,2,0.1,cross,0,13 +19,Concise,Surface,4,0.1,cross,0,13 +19,Concise,Surface,8,0.1,cross,0,13 +19,Concise,Shallow,2,0.1,cross,0,13 +19,Concise,Shallow,4,0.1,cross,0,13 +19,Concise,Shallow,8,0.1,cross,0,13 +19,Concise,Contextual,4,0.1,cross,0,13 +19,Concise,Contextual,8,0.1,cross,0,13 +19,Concise,Analogical,2,0,cross,0,27 +19,Concise,Analogical,2,0.001,cross,0,27 +19,Concise,Analogical,2,0.005,cross,0,27 +19,Concise,Analogical,2,0.01,cross,0,27 +19,Concise,Analogical,2,0.02,cross,0,27 +19,Concise,Analogical,3,0,cross,0,27 +19,Concise,Analogical,3,0.001,cross,0,27 +19,Concise,Analogical,3,0.005,cross,0,27 +19,Concise,Analogical,3,0.01,cross,0,27 +19,Concise,Analogical,3,0.02,cross,0,27 +19,Concise,Analogical,4,0,cross,0,27 +19,Concise,Analogical,4,0.001,cross,0,27 +19,Concise,Analogical,4,0.005,cross,0,27 +19,Concise,Analogical,4,0.01,cross,0,27 +19,Concise,Analogical,4,0.02,cross,0,27 +20,Efficient,Surface,2,0.1,cross,0,13 +20,Efficient,Surface,4,0.1,cross,0,13 +20,Efficient,Surface,8,0.1,cross,0,13 +20,Efficient,Shallow,2,0.1,cross,0,13 +20,Efficient,Shallow,4,0.1,cross,0,13 +20,Efficient,Shallow,8,0.1,cross,0,13 +20,Efficient,Contextual,4,0.1,cross,0,13 +20,Efficient,Contextual,8,0.1,cross,0,13 +20,Efficient,Analogical,2,0,cross,0,27 +20,Efficient,Analogical,2,0.001,cross,0,27 +20,Efficient,Analogical,2,0.005,cross,0,27 +20,Efficient,Analogical,2,0.01,cross,0,27 +20,Efficient,Analogical,2,0.02,cross,0,27 +20,Efficient,Analogical,3,0,cross,0,27 +20,Efficient,Analogical,3,0.001,cross,0,27 +20,Efficient,Analogical,3,0.005,cross,0,27 +20,Efficient,Analogical,3,0.01,cross,0,27 +20,Efficient,Analogical,3,0.02,cross,0,27 +20,Efficient,Analogical,4,0,cross,0,27 +20,Efficient,Analogical,4,0.001,cross,0,27 +20,Efficient,Analogical,4,0.005,cross,0,27 +20,Efficient,Analogical,4,0.01,cross,0,27 +20,Efficient,Analogical,4,0.02,cross,0,27 +21,Pragmatic,Surface,2,0.1,cross,0,13 +21,Pragmatic,Surface,4,0.1,cross,0,13 +21,Pragmatic,Surface,8,0.1,cross,0,13 +21,Pragmatic,Shallow,2,0.1,cross,0,13 +21,Pragmatic,Shallow,4,0.1,cross,0,13 +21,Pragmatic,Shallow,8,0.1,cross,0,13 +21,Pragmatic,Contextual,4,0.1,cross,0,13 +21,Pragmatic,Contextual,8,0.1,cross,0,13 +21,Pragmatic,Analogical,2,0,cross,0,27 +21,Pragmatic,Analogical,2,0.001,cross,0,27 +21,Pragmatic,Analogical,2,0.005,cross,0,27 +21,Pragmatic,Analogical,2,0.01,cross,0,27 +21,Pragmatic,Analogical,2,0.02,cross,0,27 +21,Pragmatic,Analogical,3,0,cross,0,27 +21,Pragmatic,Analogical,3,0.001,cross,0,27 +21,Pragmatic,Analogical,3,0.005,cross,0,27 +21,Pragmatic,Analogical,3,0.01,cross,0,27 +21,Pragmatic,Analogical,3,0.02,cross,0,27 +21,Pragmatic,Analogical,4,0,cross,0,27 +21,Pragmatic,Analogical,4,0.001,cross,0,27 +21,Pragmatic,Analogical,4,0.005,cross,0,27 +21,Pragmatic,Analogical,4,0.01,cross,0,27 +21,Pragmatic,Analogical,4,0.02,cross,0,27 +22,Blunt,Surface,2,0.1,cross,0,13 +22,Blunt,Surface,4,0.1,cross,0,13 +22,Blunt,Surface,8,0.1,cross,0,13 +22,Blunt,Shallow,2,0.1,cross,0,13 +22,Blunt,Shallow,4,0.1,cross,0,13 +22,Blunt,Shallow,8,0.1,cross,0,13 +22,Blunt,Contextual,4,0.1,cross,0,13 +22,Blunt,Contextual,8,0.1,cross,0,13 +22,Blunt,Analogical,2,0,cross,0,27 +22,Blunt,Analogical,2,0.001,cross,0,27 +22,Blunt,Analogical,2,0.005,cross,0,27 +22,Blunt,Analogical,2,0.01,cross,0,27 +22,Blunt,Analogical,2,0.02,cross,0,27 +22,Blunt,Analogical,3,0,cross,0,27 +22,Blunt,Analogical,3,0.001,cross,0,27 +22,Blunt,Analogical,3,0.005,cross,0,27 +22,Blunt,Analogical,3,0.01,cross,0,27 +22,Blunt,Analogical,3,0.02,cross,0,27 +22,Blunt,Analogical,4,0,cross,0,27 +22,Blunt,Analogical,4,0.001,cross,0,27 +22,Blunt,Analogical,4,0.005,cross,0,27 +22,Blunt,Analogical,4,0.01,cross,0,27 +22,Blunt,Analogical,4,0.02,cross,0,27 +23,Frank,Surface,2,0.1,cross,0,13 +23,Frank,Surface,4,0.1,cross,0,13 +23,Frank,Surface,8,0.1,cross,0,13 +23,Frank,Shallow,2,0.1,cross,0,13 +23,Frank,Shallow,4,0.1,cross,0,13 +23,Frank,Shallow,8,0.1,cross,0,13 +23,Frank,Contextual,4,0.1,cross,0,13 +23,Frank,Contextual,8,0.1,cross,0,13 +23,Frank,Analogical,2,0,cross,0,27 +23,Frank,Analogical,2,0.001,cross,0,27 +23,Frank,Analogical,2,0.005,cross,0,27 +23,Frank,Analogical,2,0.01,cross,0,27 +23,Frank,Analogical,2,0.02,cross,0,27 +23,Frank,Analogical,3,0,cross,0,27 +23,Frank,Analogical,3,0.001,cross,0,27 +23,Frank,Analogical,3,0.005,cross,0,27 +23,Frank,Analogical,3,0.01,cross,0,27 +23,Frank,Analogical,3,0.02,cross,0,27 +23,Frank,Analogical,4,0,cross,0,27 +23,Frank,Analogical,4,0.001,cross,0,27 +23,Frank,Analogical,4,0.005,cross,0,27 +23,Frank,Analogical,4,0.01,cross,0,27 +23,Frank,Analogical,4,0.02,cross,0,27 +24,Curious,Surface,2,0,same,0,7 +24,Curious,Surface,2,0.001,same,0,7 +24,Curious,Surface,2,0.005,same,0,7 +24,Curious,Surface,2,0.01,same,0,7 +24,Curious,Surface,2,0.02,same,0,7 +24,Curious,Surface,3,0,same,0,7 +24,Curious,Surface,3,0.001,same,0,7 +24,Curious,Surface,3,0.005,same,0,7 +24,Curious,Surface,3,0.01,same,0,7 +24,Curious,Surface,3,0.02,same,0,7 +24,Curious,Surface,3,0.1,cross,0,26 +24,Curious,Surface,4,0,same,0,7 +24,Curious,Surface,4,0.001,same,0,7 +24,Curious,Surface,4,0.005,same,0,7 +24,Curious,Surface,4,0.01,same,0,7 +24,Curious,Surface,4,0.02,same,0,7 +24,Curious,Surface,4,0.1,cross,0,26 +24,Curious,Shallow,2,0,same,0,7 +24,Curious,Shallow,2,0.001,same,0,7 +24,Curious,Shallow,2,0.005,same,0,7 +24,Curious,Shallow,2,0.01,same,0,7 +24,Curious,Shallow,2,0.02,same,0,7 +24,Curious,Shallow,3,0,same,0,7 +24,Curious,Shallow,3,0.001,same,0,7 +24,Curious,Shallow,3,0.005,same,0,7 +24,Curious,Shallow,3,0.01,same,0,7 +24,Curious,Shallow,3,0.02,same,0,7 +24,Curious,Shallow,3,0.1,cross,0,26 +24,Curious,Shallow,4,0,same,0,7 +24,Curious,Shallow,4,0.001,same,0,7 +24,Curious,Shallow,4,0.005,same,0,7 +24,Curious,Shallow,4,0.01,same,0,7 +24,Curious,Shallow,4,0.02,same,0,7 +24,Curious,Shallow,4,0.1,cross,0,26 +24,Curious,Contextual,2,0,same,0,7 +24,Curious,Contextual,2,0.001,same,0,7 +24,Curious,Contextual,2,0.005,same,0,7 +24,Curious,Contextual,2,0.01,same,0,7 +24,Curious,Contextual,2,0.02,same,0,7 +24,Curious,Contextual,3,0,same,0,7 +24,Curious,Contextual,3,0.001,same,0,7 +24,Curious,Contextual,3,0.005,same,0,7 +24,Curious,Contextual,3,0.01,same,0,7 +24,Curious,Contextual,3,0.02,same,0,7 +24,Curious,Contextual,3,0.1,cross,0,26 +24,Curious,Contextual,4,0,same,0,7 +24,Curious,Contextual,4,0.001,same,0,7 +24,Curious,Contextual,4,0.005,same,0,7 +24,Curious,Contextual,4,0.01,same,0,7 +24,Curious,Contextual,4,0.02,same,0,7 +24,Curious,Analogical,2,0,same,0,7 +24,Curious,Analogical,2,0.001,same,0,7 +24,Curious,Analogical,2,0.005,same,0,7 +24,Curious,Analogical,2,0.01,same,0,7 +24,Curious,Analogical,2,0.02,same,0,7 +24,Curious,Analogical,3,0,same,0,7 +24,Curious,Analogical,3,0.001,same,0,7 +24,Curious,Analogical,3,0.005,same,0,7 +24,Curious,Analogical,3,0.01,same,0,7 +24,Curious,Analogical,3,0.02,same,0,7 +24,Curious,Analogical,4,0,same,0,7 +24,Curious,Analogical,4,0.001,same,0,7 +24,Curious,Analogical,4,0.005,same,0,7 +24,Curious,Analogical,4,0.01,same,0,7 +24,Curious,Analogical,4,0.02,same,0,7 +25,Exploratory,Surface,2,0,same,0,7 +25,Exploratory,Surface,2,0.001,same,0,7 +25,Exploratory,Surface,2,0.005,same,0,7 +25,Exploratory,Surface,2,0.01,same,0,7 +25,Exploratory,Surface,2,0.02,same,0,7 +25,Exploratory,Surface,3,0,same,0,7 +25,Exploratory,Surface,3,0.001,same,0,7 +25,Exploratory,Surface,3,0.005,same,0,7 +25,Exploratory,Surface,3,0.01,same,0,7 +25,Exploratory,Surface,3,0.02,same,0,7 +25,Exploratory,Surface,3,0.1,cross,0,26 +25,Exploratory,Surface,4,0,same,0,7 +25,Exploratory,Surface,4,0.001,same,0,7 +25,Exploratory,Surface,4,0.005,same,0,7 +25,Exploratory,Surface,4,0.01,same,0,7 +25,Exploratory,Surface,4,0.02,same,0,7 +25,Exploratory,Surface,4,0.1,cross,0,26 +25,Exploratory,Shallow,2,0,same,0,7 +25,Exploratory,Shallow,2,0.001,same,0,7 +25,Exploratory,Shallow,2,0.005,same,0,7 +25,Exploratory,Shallow,2,0.01,same,0,7 +25,Exploratory,Shallow,2,0.02,same,0,7 +25,Exploratory,Shallow,3,0,same,0,7 +25,Exploratory,Shallow,3,0.001,same,0,7 +25,Exploratory,Shallow,3,0.005,same,0,7 +25,Exploratory,Shallow,3,0.01,same,0,7 +25,Exploratory,Shallow,3,0.02,same,0,7 +25,Exploratory,Shallow,3,0.1,cross,0,26 +25,Exploratory,Shallow,4,0,same,0,7 +25,Exploratory,Shallow,4,0.001,same,0,7 +25,Exploratory,Shallow,4,0.005,same,0,7 +25,Exploratory,Shallow,4,0.01,same,0,7 +25,Exploratory,Shallow,4,0.02,same,0,7 +25,Exploratory,Shallow,4,0.1,cross,0,26 +25,Exploratory,Contextual,2,0,same,0,7 +25,Exploratory,Contextual,2,0.001,same,0,7 +25,Exploratory,Contextual,2,0.005,same,0,7 +25,Exploratory,Contextual,2,0.01,same,0,7 +25,Exploratory,Contextual,2,0.02,same,0,7 +25,Exploratory,Contextual,3,0,same,0,7 +25,Exploratory,Contextual,3,0.001,same,0,7 +25,Exploratory,Contextual,3,0.005,same,0,7 +25,Exploratory,Contextual,3,0.01,same,0,7 +25,Exploratory,Contextual,3,0.02,same,0,7 +25,Exploratory,Contextual,3,0.1,cross,0,26 +25,Exploratory,Contextual,4,0,same,0,7 +25,Exploratory,Contextual,4,0.001,same,0,7 +25,Exploratory,Contextual,4,0.005,same,0,7 +25,Exploratory,Contextual,4,0.01,same,0,7 +25,Exploratory,Contextual,4,0.02,same,0,7 +25,Exploratory,Analogical,2,0,same,0,7 +25,Exploratory,Analogical,2,0.001,same,0,7 +25,Exploratory,Analogical,2,0.005,same,0,7 +25,Exploratory,Analogical,2,0.01,same,0,7 +25,Exploratory,Analogical,2,0.02,same,0,7 +25,Exploratory,Analogical,3,0,same,0,7 +25,Exploratory,Analogical,3,0.001,same,0,7 +25,Exploratory,Analogical,3,0.005,same,0,7 +25,Exploratory,Analogical,3,0.01,same,0,7 +25,Exploratory,Analogical,3,0.02,same,0,7 +25,Exploratory,Analogical,4,0,same,0,7 +25,Exploratory,Analogical,4,0.001,same,0,7 +25,Exploratory,Analogical,4,0.005,same,0,7 +25,Exploratory,Analogical,4,0.01,same,0,7 +25,Exploratory,Analogical,4,0.02,same,0,7 +26,Questioning,Surface,2,0,same,0,7 +26,Questioning,Surface,2,0.001,same,0,7 +26,Questioning,Surface,2,0.005,same,0,7 +26,Questioning,Surface,2,0.01,same,0,7 +26,Questioning,Surface,2,0.02,same,0,7 +26,Questioning,Surface,3,0,same,0,7 +26,Questioning,Surface,3,0.001,same,0,7 +26,Questioning,Surface,3,0.005,same,0,7 +26,Questioning,Surface,3,0.01,same,0,7 +26,Questioning,Surface,3,0.02,same,0,7 +26,Questioning,Surface,3,0.1,cross,0,26 +26,Questioning,Surface,4,0,same,0,7 +26,Questioning,Surface,4,0.001,same,0,7 +26,Questioning,Surface,4,0.005,same,0,7 +26,Questioning,Surface,4,0.01,same,0,7 +26,Questioning,Surface,4,0.02,same,0,7 +26,Questioning,Surface,4,0.1,cross,0,26 +26,Questioning,Shallow,2,0,same,0,7 +26,Questioning,Shallow,2,0.001,same,0,7 +26,Questioning,Shallow,2,0.005,same,0,7 +26,Questioning,Shallow,2,0.01,same,0,7 +26,Questioning,Shallow,2,0.02,same,0,7 +26,Questioning,Shallow,3,0,same,0,7 +26,Questioning,Shallow,3,0.001,same,0,7 +26,Questioning,Shallow,3,0.005,same,0,7 +26,Questioning,Shallow,3,0.01,same,0,7 +26,Questioning,Shallow,3,0.02,same,0,7 +26,Questioning,Shallow,3,0.1,cross,0,26 +26,Questioning,Shallow,4,0,same,0,7 +26,Questioning,Shallow,4,0.001,same,0,7 +26,Questioning,Shallow,4,0.005,same,0,7 +26,Questioning,Shallow,4,0.01,same,0,7 +26,Questioning,Shallow,4,0.02,same,0,7 +26,Questioning,Shallow,4,0.1,cross,0,26 +26,Questioning,Contextual,2,0,same,0,7 +26,Questioning,Contextual,2,0.001,same,0,7 +26,Questioning,Contextual,2,0.005,same,0,7 +26,Questioning,Contextual,2,0.01,same,0,7 +26,Questioning,Contextual,2,0.02,same,0,7 +26,Questioning,Contextual,3,0,same,0,7 +26,Questioning,Contextual,3,0.001,same,0,7 +26,Questioning,Contextual,3,0.005,same,0,7 +26,Questioning,Contextual,3,0.01,same,0,7 +26,Questioning,Contextual,3,0.02,same,0,7 +26,Questioning,Contextual,3,0.1,cross,0,26 +26,Questioning,Contextual,4,0,same,0,7 +26,Questioning,Contextual,4,0.001,same,0,7 +26,Questioning,Contextual,4,0.005,same,0,7 +26,Questioning,Contextual,4,0.01,same,0,7 +26,Questioning,Contextual,4,0.02,same,0,7 +26,Questioning,Analogical,2,0,same,0,7 +26,Questioning,Analogical,2,0.001,same,0,7 +26,Questioning,Analogical,2,0.005,same,0,7 +26,Questioning,Analogical,2,0.01,same,0,7 +26,Questioning,Analogical,2,0.02,same,0,7 +26,Questioning,Analogical,3,0,same,0,7 +26,Questioning,Analogical,3,0.001,same,0,7 +26,Questioning,Analogical,3,0.005,same,0,7 +26,Questioning,Analogical,3,0.01,same,0,7 +26,Questioning,Analogical,3,0.02,same,0,7 +26,Questioning,Analogical,4,0,same,0,7 +26,Questioning,Analogical,4,0.001,same,0,7 +26,Questioning,Analogical,4,0.005,same,0,7 +26,Questioning,Analogical,4,0.01,same,0,7 +26,Questioning,Analogical,4,0.02,same,0,7 +27,Investigative,Surface,2,0,same,0,7 +27,Investigative,Surface,2,0.001,same,0,7 +27,Investigative,Surface,2,0.005,same,0,7 +27,Investigative,Surface,2,0.01,same,0,7 +27,Investigative,Surface,2,0.02,same,0,7 +27,Investigative,Surface,3,0,same,0,7 +27,Investigative,Surface,3,0.001,same,0,7 +27,Investigative,Surface,3,0.005,same,0,7 +27,Investigative,Surface,3,0.01,same,0,7 +27,Investigative,Surface,3,0.02,same,0,7 +27,Investigative,Surface,3,0.1,cross,0,26 +27,Investigative,Surface,4,0,same,0,7 +27,Investigative,Surface,4,0.001,same,0,7 +27,Investigative,Surface,4,0.005,same,0,7 +27,Investigative,Surface,4,0.01,same,0,7 +27,Investigative,Surface,4,0.02,same,0,7 +27,Investigative,Surface,4,0.1,cross,0,26 +27,Investigative,Shallow,2,0,same,0,7 +27,Investigative,Shallow,2,0.001,same,0,7 +27,Investigative,Shallow,2,0.005,same,0,7 +27,Investigative,Shallow,2,0.01,same,0,7 +27,Investigative,Shallow,2,0.02,same,0,7 +27,Investigative,Shallow,3,0,same,0,7 +27,Investigative,Shallow,3,0.001,same,0,7 +27,Investigative,Shallow,3,0.005,same,0,7 +27,Investigative,Shallow,3,0.01,same,0,7 +27,Investigative,Shallow,3,0.02,same,0,7 +27,Investigative,Shallow,3,0.1,cross,0,26 +27,Investigative,Shallow,4,0,same,0,7 +27,Investigative,Shallow,4,0.001,same,0,7 +27,Investigative,Shallow,4,0.005,same,0,7 +27,Investigative,Shallow,4,0.01,same,0,7 +27,Investigative,Shallow,4,0.02,same,0,7 +27,Investigative,Shallow,4,0.1,cross,0,26 +27,Investigative,Contextual,2,0,same,0,7 +27,Investigative,Contextual,2,0.001,same,0,7 +27,Investigative,Contextual,2,0.005,same,0,7 +27,Investigative,Contextual,2,0.01,same,0,7 +27,Investigative,Contextual,2,0.02,same,0,7 +27,Investigative,Contextual,3,0,same,0,7 +27,Investigative,Contextual,3,0.001,same,0,7 +27,Investigative,Contextual,3,0.005,same,0,7 +27,Investigative,Contextual,3,0.01,same,0,7 +27,Investigative,Contextual,3,0.02,same,0,7 +27,Investigative,Contextual,3,0.1,cross,0,26 +27,Investigative,Contextual,4,0,same,0,7 +27,Investigative,Contextual,4,0.001,same,0,7 +27,Investigative,Contextual,4,0.005,same,0,7 +27,Investigative,Contextual,4,0.01,same,0,7 +27,Investigative,Contextual,4,0.02,same,0,7 +27,Investigative,Analogical,2,0,same,0,7 +27,Investigative,Analogical,2,0.001,same,0,7 +27,Investigative,Analogical,2,0.005,same,0,7 +27,Investigative,Analogical,2,0.01,same,0,7 +27,Investigative,Analogical,2,0.02,same,0,7 +27,Investigative,Analogical,3,0,same,0,7 +27,Investigative,Analogical,3,0.001,same,0,7 +27,Investigative,Analogical,3,0.005,same,0,7 +27,Investigative,Analogical,3,0.01,same,0,7 +27,Investigative,Analogical,3,0.02,same,0,7 +27,Investigative,Analogical,4,0,same,0,7 +27,Investigative,Analogical,4,0.001,same,0,7 +27,Investigative,Analogical,4,0.005,same,0,7 +27,Investigative,Analogical,4,0.01,same,0,7 +27,Investigative,Analogical,4,0.02,same,0,7 +28,Speculative,Surface,2,0,same,0,7 +28,Speculative,Surface,2,0.001,same,0,7 +28,Speculative,Surface,2,0.005,same,0,7 +28,Speculative,Surface,2,0.01,same,0,7 +28,Speculative,Surface,2,0.02,same,0,7 +28,Speculative,Surface,3,0,same,0,7 +28,Speculative,Surface,3,0.001,same,0,7 +28,Speculative,Surface,3,0.005,same,0,7 +28,Speculative,Surface,3,0.01,same,0,7 +28,Speculative,Surface,3,0.02,same,0,7 +28,Speculative,Surface,3,0.1,cross,0,26 +28,Speculative,Surface,4,0,same,0,7 +28,Speculative,Surface,4,0.001,same,0,7 +28,Speculative,Surface,4,0.005,same,0,7 +28,Speculative,Surface,4,0.01,same,0,7 +28,Speculative,Surface,4,0.02,same,0,7 +28,Speculative,Surface,4,0.1,cross,0,26 +28,Speculative,Shallow,2,0,same,0,7 +28,Speculative,Shallow,2,0.001,same,0,7 +28,Speculative,Shallow,2,0.005,same,0,7 +28,Speculative,Shallow,2,0.01,same,0,7 +28,Speculative,Shallow,2,0.02,same,0,7 +28,Speculative,Shallow,3,0,same,0,7 +28,Speculative,Shallow,3,0.001,same,0,7 +28,Speculative,Shallow,3,0.005,same,0,7 +28,Speculative,Shallow,3,0.01,same,0,7 +28,Speculative,Shallow,3,0.02,same,0,7 +28,Speculative,Shallow,3,0.1,cross,0,26 +28,Speculative,Shallow,4,0,same,0,7 +28,Speculative,Shallow,4,0.001,same,0,7 +28,Speculative,Shallow,4,0.005,same,0,7 +28,Speculative,Shallow,4,0.01,same,0,7 +28,Speculative,Shallow,4,0.02,same,0,7 +28,Speculative,Shallow,4,0.1,cross,0,26 +28,Speculative,Contextual,2,0,same,0,7 +28,Speculative,Contextual,2,0.001,same,0,7 +28,Speculative,Contextual,2,0.005,same,0,7 +28,Speculative,Contextual,2,0.01,same,0,7 +28,Speculative,Contextual,2,0.02,same,0,7 +28,Speculative,Contextual,3,0,same,0,7 +28,Speculative,Contextual,3,0.001,same,0,7 +28,Speculative,Contextual,3,0.005,same,0,7 +28,Speculative,Contextual,3,0.01,same,0,7 +28,Speculative,Contextual,3,0.02,same,0,7 +28,Speculative,Contextual,3,0.1,cross,0,26 +28,Speculative,Contextual,4,0,same,0,7 +28,Speculative,Contextual,4,0.001,same,0,7 +28,Speculative,Contextual,4,0.005,same,0,7 +28,Speculative,Contextual,4,0.01,same,0,7 +28,Speculative,Contextual,4,0.02,same,0,7 +28,Speculative,Analogical,2,0,same,0,7 +28,Speculative,Analogical,2,0.001,same,0,7 +28,Speculative,Analogical,2,0.005,same,0,7 +28,Speculative,Analogical,2,0.01,same,0,7 +28,Speculative,Analogical,2,0.02,same,0,7 +28,Speculative,Analogical,3,0,same,0,7 +28,Speculative,Analogical,3,0.001,same,0,7 +28,Speculative,Analogical,3,0.005,same,0,7 +28,Speculative,Analogical,3,0.01,same,0,7 +28,Speculative,Analogical,3,0.02,same,0,7 +28,Speculative,Analogical,4,0,same,0,7 +28,Speculative,Analogical,4,0.001,same,0,7 +28,Speculative,Analogical,4,0.005,same,0,7 +28,Speculative,Analogical,4,0.01,same,0,7 +28,Speculative,Analogical,4,0.02,same,0,7 +29,Philosophical,Surface,2,0,same,0,7 +29,Philosophical,Surface,2,0.001,same,0,7 +29,Philosophical,Surface,2,0.005,same,0,7 +29,Philosophical,Surface,2,0.01,same,0,7 +29,Philosophical,Surface,2,0.02,same,0,7 +29,Philosophical,Surface,3,0,same,0,7 +29,Philosophical,Surface,3,0.001,same,0,7 +29,Philosophical,Surface,3,0.005,same,0,7 +29,Philosophical,Surface,3,0.01,same,0,7 +29,Philosophical,Surface,3,0.02,same,0,7 +29,Philosophical,Surface,3,0.1,cross,0,26 +29,Philosophical,Surface,4,0,same,0,7 +29,Philosophical,Surface,4,0.001,same,0,7 +29,Philosophical,Surface,4,0.005,same,0,7 +29,Philosophical,Surface,4,0.01,same,0,7 +29,Philosophical,Surface,4,0.02,same,0,7 +29,Philosophical,Surface,4,0.1,cross,0,26 +29,Philosophical,Shallow,2,0,same,0,7 +29,Philosophical,Shallow,2,0.001,same,0,7 +29,Philosophical,Shallow,2,0.005,same,0,7 +29,Philosophical,Shallow,2,0.01,same,0,7 +29,Philosophical,Shallow,2,0.02,same,0,7 +29,Philosophical,Shallow,3,0,same,0,7 +29,Philosophical,Shallow,3,0.001,same,0,7 +29,Philosophical,Shallow,3,0.005,same,0,7 +29,Philosophical,Shallow,3,0.01,same,0,7 +29,Philosophical,Shallow,3,0.02,same,0,7 +29,Philosophical,Shallow,3,0.1,cross,0,26 +29,Philosophical,Shallow,4,0,same,0,7 +29,Philosophical,Shallow,4,0.001,same,0,7 +29,Philosophical,Shallow,4,0.005,same,0,7 +29,Philosophical,Shallow,4,0.01,same,0,7 +29,Philosophical,Shallow,4,0.02,same,0,7 +29,Philosophical,Shallow,4,0.1,cross,0,26 +29,Philosophical,Contextual,2,0,same,0,7 +29,Philosophical,Contextual,2,0.001,same,0,7 +29,Philosophical,Contextual,2,0.005,same,0,7 +29,Philosophical,Contextual,2,0.01,same,0,7 +29,Philosophical,Contextual,2,0.02,same,0,7 +29,Philosophical,Contextual,3,0,same,0,7 +29,Philosophical,Contextual,3,0.001,same,0,7 +29,Philosophical,Contextual,3,0.005,same,0,7 +29,Philosophical,Contextual,3,0.01,same,0,7 +29,Philosophical,Contextual,3,0.02,same,0,7 +29,Philosophical,Contextual,3,0.1,cross,0,26 +29,Philosophical,Contextual,4,0,same,0,7 +29,Philosophical,Contextual,4,0.001,same,0,7 +29,Philosophical,Contextual,4,0.005,same,0,7 +29,Philosophical,Contextual,4,0.01,same,0,7 +29,Philosophical,Contextual,4,0.02,same,0,7 +29,Philosophical,Analogical,2,0,same,0,7 +29,Philosophical,Analogical,2,0.001,same,0,7 +29,Philosophical,Analogical,2,0.005,same,0,7 +29,Philosophical,Analogical,2,0.01,same,0,7 +29,Philosophical,Analogical,2,0.02,same,0,7 +29,Philosophical,Analogical,3,0,same,0,7 +29,Philosophical,Analogical,3,0.001,same,0,7 +29,Philosophical,Analogical,3,0.005,same,0,7 +29,Philosophical,Analogical,3,0.01,same,0,7 +29,Philosophical,Analogical,3,0.02,same,0,7 +29,Philosophical,Analogical,4,0,same,0,7 +29,Philosophical,Analogical,4,0.001,same,0,7 +29,Philosophical,Analogical,4,0.005,same,0,7 +29,Philosophical,Analogical,4,0.01,same,0,7 +29,Philosophical,Analogical,4,0.02,same,0,7 +30,Reflective,Surface,1,0,same,0,3 +30,Reflective,Surface,1,0.001,same,0,3 +30,Reflective,Surface,1,0.005,same,0,3 +30,Reflective,Surface,1,0.01,same,0,3 +30,Reflective,Surface,1,0.02,same,0,3 +30,Reflective,Surface,1,0.05,same,0,3 +30,Reflective,Surface,2,0,same,0,3 +30,Reflective,Surface,2,0.001,same,0,3 +30,Reflective,Surface,2,0.005,same,0,3 +30,Reflective,Surface,2,0.01,same,0,3 +30,Reflective,Surface,2,0.02,same,0,3 +30,Reflective,Surface,2,0.05,same,0,3 +30,Reflective,Surface,3,0,same,0,3 +30,Reflective,Surface,3,0.001,same,0,3 +30,Reflective,Surface,3,0.005,same,0,3 +30,Reflective,Surface,3,0.01,same,0,3 +30,Reflective,Surface,3,0.02,same,0,3 +30,Reflective,Surface,3,0.05,same,0,3 +30,Reflective,Surface,3,0.1,cross,26,0 +30,Reflective,Surface,4,0,same,0,3 +30,Reflective,Surface,4,0.001,same,0,3 +30,Reflective,Surface,4,0.005,same,0,3 +30,Reflective,Surface,4,0.01,same,0,3 +30,Reflective,Surface,4,0.02,same,0,3 +30,Reflective,Surface,4,0.05,same,0,3 +30,Reflective,Surface,4,0.1,cross,0,26 +30,Reflective,Surface,8,0,same,0,3 +30,Reflective,Surface,8,0.001,same,0,3 +30,Reflective,Surface,8,0.005,same,0,3 +30,Reflective,Surface,8,0.01,same,0,3 +30,Reflective,Surface,8,0.02,same,0,3 +30,Reflective,Surface,8,0.05,same,0,3 +30,Reflective,Shallow,1,0,same,0,3 +30,Reflective,Shallow,1,0.001,same,0,3 +30,Reflective,Shallow,1,0.005,same,0,3 +30,Reflective,Shallow,1,0.01,same,0,3 +30,Reflective,Shallow,1,0.02,same,0,3 +30,Reflective,Shallow,1,0.05,same,0,3 +30,Reflective,Shallow,2,0,same,0,3 +30,Reflective,Shallow,2,0.001,same,0,3 +30,Reflective,Shallow,2,0.005,same,0,3 +30,Reflective,Shallow,2,0.01,same,0,3 +30,Reflective,Shallow,2,0.02,same,0,3 +30,Reflective,Shallow,2,0.05,same,0,3 +30,Reflective,Shallow,3,0,same,0,3 +30,Reflective,Shallow,3,0.001,same,0,3 +30,Reflective,Shallow,3,0.005,same,0,3 +30,Reflective,Shallow,3,0.01,same,0,3 +30,Reflective,Shallow,3,0.02,same,0,3 +30,Reflective,Shallow,3,0.05,same,0,3 +30,Reflective,Shallow,3,0.1,cross,26,0 +30,Reflective,Shallow,4,0,same,0,3 +30,Reflective,Shallow,4,0.001,same,0,3 +30,Reflective,Shallow,4,0.005,same,0,3 +30,Reflective,Shallow,4,0.01,same,0,3 +30,Reflective,Shallow,4,0.02,same,0,3 +30,Reflective,Shallow,4,0.05,same,0,3 +30,Reflective,Shallow,4,0.1,cross,0,26 +30,Reflective,Shallow,8,0,same,0,3 +30,Reflective,Shallow,8,0.001,same,0,3 +30,Reflective,Shallow,8,0.005,same,0,3 +30,Reflective,Shallow,8,0.01,same,0,3 +30,Reflective,Shallow,8,0.02,same,0,3 +30,Reflective,Shallow,8,0.05,same,0,3 +30,Reflective,Contextual,3,0.1,cross,26,0 +30,Reflective,Contextual,4,0.1,cross,0,26 +30,Reflective,Contextual,8,0.1,cross,0,26 +30,Reflective,Analogical,4,0.1,cross,0,26 +31,Contemplative,Surface,1,0,same,0,3 +31,Contemplative,Surface,1,0.001,same,0,3 +31,Contemplative,Surface,1,0.005,same,0,3 +31,Contemplative,Surface,1,0.01,same,0,3 +31,Contemplative,Surface,1,0.02,same,0,3 +31,Contemplative,Surface,1,0.05,same,0,3 +31,Contemplative,Surface,2,0,same,0,3 +31,Contemplative,Surface,2,0.001,same,0,3 +31,Contemplative,Surface,2,0.005,same,0,3 +31,Contemplative,Surface,2,0.01,same,0,3 +31,Contemplative,Surface,2,0.02,same,0,3 +31,Contemplative,Surface,2,0.05,same,0,3 +31,Contemplative,Surface,3,0,same,0,3 +31,Contemplative,Surface,3,0.001,same,0,3 +31,Contemplative,Surface,3,0.005,same,0,3 +31,Contemplative,Surface,3,0.01,same,0,3 +31,Contemplative,Surface,3,0.02,same,0,3 +31,Contemplative,Surface,3,0.05,same,0,3 +31,Contemplative,Surface,3,0.1,cross,26,0 +31,Contemplative,Surface,4,0,same,0,3 +31,Contemplative,Surface,4,0.001,same,0,3 +31,Contemplative,Surface,4,0.005,same,0,3 +31,Contemplative,Surface,4,0.01,same,0,3 +31,Contemplative,Surface,4,0.02,same,0,3 +31,Contemplative,Surface,4,0.05,same,0,3 +31,Contemplative,Surface,4,0.1,cross,0,26 +31,Contemplative,Surface,8,0,same,0,3 +31,Contemplative,Surface,8,0.001,same,0,3 +31,Contemplative,Surface,8,0.005,same,0,3 +31,Contemplative,Surface,8,0.01,same,0,3 +31,Contemplative,Surface,8,0.02,same,0,3 +31,Contemplative,Surface,8,0.05,same,0,3 +31,Contemplative,Shallow,1,0,same,0,3 +31,Contemplative,Shallow,1,0.001,same,0,3 +31,Contemplative,Shallow,1,0.005,same,0,3 +31,Contemplative,Shallow,1,0.01,same,0,3 +31,Contemplative,Shallow,1,0.02,same,0,3 +31,Contemplative,Shallow,1,0.05,same,0,3 +31,Contemplative,Shallow,2,0,same,0,3 +31,Contemplative,Shallow,2,0.001,same,0,3 +31,Contemplative,Shallow,2,0.005,same,0,3 +31,Contemplative,Shallow,2,0.01,same,0,3 +31,Contemplative,Shallow,2,0.02,same,0,3 +31,Contemplative,Shallow,2,0.05,same,0,3 +31,Contemplative,Shallow,3,0,same,0,3 +31,Contemplative,Shallow,3,0.001,same,0,3 +31,Contemplative,Shallow,3,0.005,same,0,3 +31,Contemplative,Shallow,3,0.01,same,0,3 +31,Contemplative,Shallow,3,0.02,same,0,3 +31,Contemplative,Shallow,3,0.05,same,0,3 +31,Contemplative,Shallow,3,0.1,cross,26,0 +31,Contemplative,Shallow,4,0,same,0,3 +31,Contemplative,Shallow,4,0.001,same,0,3 +31,Contemplative,Shallow,4,0.005,same,0,3 +31,Contemplative,Shallow,4,0.01,same,0,3 +31,Contemplative,Shallow,4,0.02,same,0,3 +31,Contemplative,Shallow,4,0.05,same,0,3 +31,Contemplative,Shallow,4,0.1,cross,0,26 +31,Contemplative,Shallow,8,0,same,0,3 +31,Contemplative,Shallow,8,0.001,same,0,3 +31,Contemplative,Shallow,8,0.005,same,0,3 +31,Contemplative,Shallow,8,0.01,same,0,3 +31,Contemplative,Shallow,8,0.02,same,0,3 +31,Contemplative,Shallow,8,0.05,same,0,3 +31,Contemplative,Contextual,3,0.1,cross,26,0 +31,Contemplative,Contextual,4,0.1,cross,0,26 +31,Contemplative,Contextual,8,0.1,cross,0,26 +31,Contemplative,Analogical,4,0.1,cross,0,26 +32,Metacognitive,Surface,1,0,same,0,3 +32,Metacognitive,Surface,1,0.001,same,0,3 +32,Metacognitive,Surface,1,0.005,same,0,3 +32,Metacognitive,Surface,1,0.01,same,0,3 +32,Metacognitive,Surface,1,0.02,same,0,3 +32,Metacognitive,Surface,1,0.05,same,0,3 +32,Metacognitive,Surface,2,0,same,0,3 +32,Metacognitive,Surface,2,0.001,same,0,3 +32,Metacognitive,Surface,2,0.005,same,0,3 +32,Metacognitive,Surface,2,0.01,same,0,3 +32,Metacognitive,Surface,2,0.02,same,0,3 +32,Metacognitive,Surface,2,0.05,same,0,3 +32,Metacognitive,Surface,3,0,same,0,3 +32,Metacognitive,Surface,3,0.001,same,0,3 +32,Metacognitive,Surface,3,0.005,same,0,3 +32,Metacognitive,Surface,3,0.01,same,0,3 +32,Metacognitive,Surface,3,0.02,same,0,3 +32,Metacognitive,Surface,3,0.05,same,0,3 +32,Metacognitive,Surface,3,0.1,cross,26,0 +32,Metacognitive,Surface,4,0,same,0,3 +32,Metacognitive,Surface,4,0.001,same,0,3 +32,Metacognitive,Surface,4,0.005,same,0,3 +32,Metacognitive,Surface,4,0.01,same,0,3 +32,Metacognitive,Surface,4,0.02,same,0,3 +32,Metacognitive,Surface,4,0.05,same,0,3 +32,Metacognitive,Surface,4,0.1,cross,0,26 +32,Metacognitive,Surface,8,0,same,0,3 +32,Metacognitive,Surface,8,0.001,same,0,3 +32,Metacognitive,Surface,8,0.005,same,0,3 +32,Metacognitive,Surface,8,0.01,same,0,3 +32,Metacognitive,Surface,8,0.02,same,0,3 +32,Metacognitive,Surface,8,0.05,same,0,3 +32,Metacognitive,Shallow,1,0,same,0,3 +32,Metacognitive,Shallow,1,0.001,same,0,3 +32,Metacognitive,Shallow,1,0.005,same,0,3 +32,Metacognitive,Shallow,1,0.01,same,0,3 +32,Metacognitive,Shallow,1,0.02,same,0,3 +32,Metacognitive,Shallow,1,0.05,same,0,3 +32,Metacognitive,Shallow,2,0,same,0,3 +32,Metacognitive,Shallow,2,0.001,same,0,3 +32,Metacognitive,Shallow,2,0.005,same,0,3 +32,Metacognitive,Shallow,2,0.01,same,0,3 +32,Metacognitive,Shallow,2,0.02,same,0,3 +32,Metacognitive,Shallow,2,0.05,same,0,3 +32,Metacognitive,Shallow,3,0,same,0,3 +32,Metacognitive,Shallow,3,0.001,same,0,3 +32,Metacognitive,Shallow,3,0.005,same,0,3 +32,Metacognitive,Shallow,3,0.01,same,0,3 +32,Metacognitive,Shallow,3,0.02,same,0,3 +32,Metacognitive,Shallow,3,0.05,same,0,3 +32,Metacognitive,Shallow,3,0.1,cross,26,0 +32,Metacognitive,Shallow,4,0,same,0,3 +32,Metacognitive,Shallow,4,0.001,same,0,3 +32,Metacognitive,Shallow,4,0.005,same,0,3 +32,Metacognitive,Shallow,4,0.01,same,0,3 +32,Metacognitive,Shallow,4,0.02,same,0,3 +32,Metacognitive,Shallow,4,0.05,same,0,3 +32,Metacognitive,Shallow,4,0.1,cross,0,26 +32,Metacognitive,Shallow,8,0,same,0,3 +32,Metacognitive,Shallow,8,0.001,same,0,3 +32,Metacognitive,Shallow,8,0.005,same,0,3 +32,Metacognitive,Shallow,8,0.01,same,0,3 +32,Metacognitive,Shallow,8,0.02,same,0,3 +32,Metacognitive,Shallow,8,0.05,same,0,3 +32,Metacognitive,Contextual,3,0.1,cross,26,0 +32,Metacognitive,Contextual,4,0.1,cross,0,26 +32,Metacognitive,Contextual,8,0.1,cross,0,26 +32,Metacognitive,Analogical,4,0.1,cross,0,26 +33,Wise,Surface,1,0,same,0,3 +33,Wise,Surface,1,0.001,same,0,3 +33,Wise,Surface,1,0.005,same,0,3 +33,Wise,Surface,1,0.01,same,0,3 +33,Wise,Surface,1,0.02,same,0,3 +33,Wise,Surface,1,0.05,same,0,3 +33,Wise,Surface,2,0,same,0,3 +33,Wise,Surface,2,0.001,same,0,3 +33,Wise,Surface,2,0.005,same,0,3 +33,Wise,Surface,2,0.01,same,0,3 +33,Wise,Surface,2,0.02,same,0,3 +33,Wise,Surface,2,0.05,same,0,3 +33,Wise,Surface,3,0,same,0,3 +33,Wise,Surface,3,0.001,same,0,3 +33,Wise,Surface,3,0.005,same,0,3 +33,Wise,Surface,3,0.01,same,0,3 +33,Wise,Surface,3,0.02,same,0,3 +33,Wise,Surface,3,0.05,same,0,3 +33,Wise,Surface,3,0.1,cross,26,0 +33,Wise,Surface,4,0,same,0,3 +33,Wise,Surface,4,0.001,same,0,3 +33,Wise,Surface,4,0.005,same,0,3 +33,Wise,Surface,4,0.01,same,0,3 +33,Wise,Surface,4,0.02,same,0,3 +33,Wise,Surface,4,0.05,same,0,3 +33,Wise,Surface,4,0.1,cross,0,26 +33,Wise,Surface,8,0,same,0,3 +33,Wise,Surface,8,0.001,same,0,3 +33,Wise,Surface,8,0.005,same,0,3 +33,Wise,Surface,8,0.01,same,0,3 +33,Wise,Surface,8,0.02,same,0,3 +33,Wise,Surface,8,0.05,same,0,3 +33,Wise,Shallow,1,0,same,0,3 +33,Wise,Shallow,1,0.001,same,0,3 +33,Wise,Shallow,1,0.005,same,0,3 +33,Wise,Shallow,1,0.01,same,0,3 +33,Wise,Shallow,1,0.02,same,0,3 +33,Wise,Shallow,1,0.05,same,0,3 +33,Wise,Shallow,2,0,same,0,3 +33,Wise,Shallow,2,0.001,same,0,3 +33,Wise,Shallow,2,0.005,same,0,3 +33,Wise,Shallow,2,0.01,same,0,3 +33,Wise,Shallow,2,0.02,same,0,3 +33,Wise,Shallow,2,0.05,same,0,3 +33,Wise,Shallow,3,0,same,0,3 +33,Wise,Shallow,3,0.001,same,0,3 +33,Wise,Shallow,3,0.005,same,0,3 +33,Wise,Shallow,3,0.01,same,0,3 +33,Wise,Shallow,3,0.02,same,0,3 +33,Wise,Shallow,3,0.05,same,0,3 +33,Wise,Shallow,3,0.1,cross,26,0 +33,Wise,Shallow,4,0,same,0,3 +33,Wise,Shallow,4,0.001,same,0,3 +33,Wise,Shallow,4,0.005,same,0,3 +33,Wise,Shallow,4,0.01,same,0,3 +33,Wise,Shallow,4,0.02,same,0,3 +33,Wise,Shallow,4,0.05,same,0,3 +33,Wise,Shallow,4,0.1,cross,0,26 +33,Wise,Shallow,8,0,same,0,3 +33,Wise,Shallow,8,0.001,same,0,3 +33,Wise,Shallow,8,0.005,same,0,3 +33,Wise,Shallow,8,0.01,same,0,3 +33,Wise,Shallow,8,0.02,same,0,3 +33,Wise,Shallow,8,0.05,same,0,3 +33,Wise,Contextual,3,0.1,cross,26,0 +33,Wise,Contextual,4,0.1,cross,0,26 +33,Wise,Contextual,8,0.1,cross,0,26 +33,Wise,Analogical,4,0.1,cross,0,26 +34,Transcendent,Surface,1,0,same,0,3 +34,Transcendent,Surface,1,0.001,same,0,3 +34,Transcendent,Surface,1,0.005,same,0,3 +34,Transcendent,Surface,1,0.01,same,0,3 +34,Transcendent,Surface,1,0.02,same,0,3 +34,Transcendent,Surface,1,0.05,same,0,3 +34,Transcendent,Surface,2,0,same,0,3 +34,Transcendent,Surface,2,0.001,same,0,3 +34,Transcendent,Surface,2,0.005,same,0,3 +34,Transcendent,Surface,2,0.01,same,0,3 +34,Transcendent,Surface,2,0.02,same,0,3 +34,Transcendent,Surface,2,0.05,same,0,3 +34,Transcendent,Surface,3,0,same,0,3 +34,Transcendent,Surface,3,0.001,same,0,3 +34,Transcendent,Surface,3,0.005,same,0,3 +34,Transcendent,Surface,3,0.01,same,0,3 +34,Transcendent,Surface,3,0.02,same,0,3 +34,Transcendent,Surface,3,0.05,same,0,3 +34,Transcendent,Surface,3,0.1,cross,26,0 +34,Transcendent,Surface,4,0,same,0,3 +34,Transcendent,Surface,4,0.001,same,0,3 +34,Transcendent,Surface,4,0.005,same,0,3 +34,Transcendent,Surface,4,0.01,same,0,3 +34,Transcendent,Surface,4,0.02,same,0,3 +34,Transcendent,Surface,4,0.05,same,0,3 +34,Transcendent,Surface,4,0.1,cross,0,26 +34,Transcendent,Surface,8,0,same,0,3 +34,Transcendent,Surface,8,0.001,same,0,3 +34,Transcendent,Surface,8,0.005,same,0,3 +34,Transcendent,Surface,8,0.01,same,0,3 +34,Transcendent,Surface,8,0.02,same,0,3 +34,Transcendent,Surface,8,0.05,same,0,3 +34,Transcendent,Shallow,1,0,same,0,3 +34,Transcendent,Shallow,1,0.001,same,0,3 +34,Transcendent,Shallow,1,0.005,same,0,3 +34,Transcendent,Shallow,1,0.01,same,0,3 +34,Transcendent,Shallow,1,0.02,same,0,3 +34,Transcendent,Shallow,1,0.05,same,0,3 +34,Transcendent,Shallow,2,0,same,0,3 +34,Transcendent,Shallow,2,0.001,same,0,3 +34,Transcendent,Shallow,2,0.005,same,0,3 +34,Transcendent,Shallow,2,0.01,same,0,3 +34,Transcendent,Shallow,2,0.02,same,0,3 +34,Transcendent,Shallow,2,0.05,same,0,3 +34,Transcendent,Shallow,3,0,same,0,3 +34,Transcendent,Shallow,3,0.001,same,0,3 +34,Transcendent,Shallow,3,0.005,same,0,3 +34,Transcendent,Shallow,3,0.01,same,0,3 +34,Transcendent,Shallow,3,0.02,same,0,3 +34,Transcendent,Shallow,3,0.05,same,0,3 +34,Transcendent,Shallow,3,0.1,cross,26,0 +34,Transcendent,Shallow,4,0,same,0,3 +34,Transcendent,Shallow,4,0.001,same,0,3 +34,Transcendent,Shallow,4,0.005,same,0,3 +34,Transcendent,Shallow,4,0.01,same,0,3 +34,Transcendent,Shallow,4,0.02,same,0,3 +34,Transcendent,Shallow,4,0.05,same,0,3 +34,Transcendent,Shallow,4,0.1,cross,0,26 +34,Transcendent,Shallow,8,0,same,0,3 +34,Transcendent,Shallow,8,0.001,same,0,3 +34,Transcendent,Shallow,8,0.005,same,0,3 +34,Transcendent,Shallow,8,0.01,same,0,3 +34,Transcendent,Shallow,8,0.02,same,0,3 +34,Transcendent,Shallow,8,0.05,same,0,3 +34,Transcendent,Contextual,3,0.1,cross,26,0 +34,Transcendent,Contextual,4,0.1,cross,0,26 +34,Transcendent,Contextual,8,0.1,cross,0,26 +34,Transcendent,Analogical,4,0.1,cross,0,26 +35,Sovereign,Surface,1,0,same,0,3 +35,Sovereign,Surface,1,0.001,same,0,3 +35,Sovereign,Surface,1,0.005,same,0,3 +35,Sovereign,Surface,1,0.01,same,0,3 +35,Sovereign,Surface,1,0.02,same,0,3 +35,Sovereign,Surface,1,0.05,same,0,3 +35,Sovereign,Surface,2,0,same,0,3 +35,Sovereign,Surface,2,0.001,same,0,3 +35,Sovereign,Surface,2,0.005,same,0,3 +35,Sovereign,Surface,2,0.01,same,0,3 +35,Sovereign,Surface,2,0.02,same,0,3 +35,Sovereign,Surface,2,0.05,same,0,3 +35,Sovereign,Surface,3,0,same,0,3 +35,Sovereign,Surface,3,0.001,same,0,3 +35,Sovereign,Surface,3,0.005,same,0,3 +35,Sovereign,Surface,3,0.01,same,0,3 +35,Sovereign,Surface,3,0.02,same,0,3 +35,Sovereign,Surface,3,0.05,same,0,3 +35,Sovereign,Surface,3,0.1,cross,26,0 +35,Sovereign,Surface,4,0,same,0,3 +35,Sovereign,Surface,4,0.001,same,0,3 +35,Sovereign,Surface,4,0.005,same,0,3 +35,Sovereign,Surface,4,0.01,same,0,3 +35,Sovereign,Surface,4,0.02,same,0,3 +35,Sovereign,Surface,4,0.05,same,0,3 +35,Sovereign,Surface,4,0.1,cross,0,26 +35,Sovereign,Surface,8,0,same,0,3 +35,Sovereign,Surface,8,0.001,same,0,3 +35,Sovereign,Surface,8,0.005,same,0,3 +35,Sovereign,Surface,8,0.01,same,0,3 +35,Sovereign,Surface,8,0.02,same,0,3 +35,Sovereign,Surface,8,0.05,same,0,3 +35,Sovereign,Shallow,1,0,same,0,3 +35,Sovereign,Shallow,1,0.001,same,0,3 +35,Sovereign,Shallow,1,0.005,same,0,3 +35,Sovereign,Shallow,1,0.01,same,0,3 +35,Sovereign,Shallow,1,0.02,same,0,3 +35,Sovereign,Shallow,1,0.05,same,0,3 +35,Sovereign,Shallow,2,0,same,0,3 +35,Sovereign,Shallow,2,0.001,same,0,3 +35,Sovereign,Shallow,2,0.005,same,0,3 +35,Sovereign,Shallow,2,0.01,same,0,3 +35,Sovereign,Shallow,2,0.02,same,0,3 +35,Sovereign,Shallow,2,0.05,same,0,3 +35,Sovereign,Shallow,3,0,same,0,3 +35,Sovereign,Shallow,3,0.001,same,0,3 +35,Sovereign,Shallow,3,0.005,same,0,3 +35,Sovereign,Shallow,3,0.01,same,0,3 +35,Sovereign,Shallow,3,0.02,same,0,3 +35,Sovereign,Shallow,3,0.05,same,0,3 +35,Sovereign,Shallow,3,0.1,cross,26,0 +35,Sovereign,Shallow,4,0,same,0,3 +35,Sovereign,Shallow,4,0.001,same,0,3 +35,Sovereign,Shallow,4,0.005,same,0,3 +35,Sovereign,Shallow,4,0.01,same,0,3 +35,Sovereign,Shallow,4,0.02,same,0,3 +35,Sovereign,Shallow,4,0.05,same,0,3 +35,Sovereign,Shallow,4,0.1,cross,0,26 +35,Sovereign,Shallow,8,0,same,0,3 +35,Sovereign,Shallow,8,0.001,same,0,3 +35,Sovereign,Shallow,8,0.005,same,0,3 +35,Sovereign,Shallow,8,0.01,same,0,3 +35,Sovereign,Shallow,8,0.02,same,0,3 +35,Sovereign,Shallow,8,0.05,same,0,3 +35,Sovereign,Contextual,3,0.1,cross,26,0 +35,Sovereign,Contextual,4,0.1,cross,0,26 +35,Sovereign,Contextual,8,0.1,cross,0,26 +35,Sovereign,Analogical,4,0.1,cross,0,26 diff --git a/docs/probes/stage26-v3-planner-parity-discordance.csv b/docs/probes/stage26-v3-planner-parity-discordance.csv new file mode 100644 index 000000000..8450e96e9 --- /dev/null +++ b/docs/probes/stage26-v3-planner-parity-discordance.csv @@ -0,0 +1 @@ +case,invariant,direct,v3