`nexyron.feature_separability`

Generic Description

nexyron.feature_separability scores latest materialized abstraction feature values against target features.

CALL nexyron.procedures()
YIELD name, description, parameters, output_columns
WHERE name = 'nexyron.feature_separability'
RETURN name, description, parameters, output_columns

Abstraction-platform runtime procedures build, materialize, refresh, inspect, and execute artifacts derived from registered abstraction contracts.

Consumer-Level Explanation

Use this procedure when you want to know which abstraction features, or which two-feature combinations, separate a target feature.

The procedure reads the same materialized feature stream used by inline abstraction feature access such as:

CALL nexyron.procedures()
YIELD name, parameters, output_columns
WHERE name = 'nexyron.feature_separability'
RETURN name,
       [p IN parameters | p.name] AS parameter_names,
       output_columns
ORDER BY name

That inline expression returns the latest materialized feature value for one subject. nexyron.feature_separability does the same kind of latest-value read across all available subjects, then compares every usable predictor feature against the target feature.

The saved split stores subject identifiers only: training subject ids and validation subject ids per abstraction. Actor abstractions are balanced by the target feature before splitting, while stage, society, and environment abstractions keep their selected subjects.

Example Contract Prerequisite

The executable Cypher blocks on this page query nexyron.procedures() so they work in an empty database and stay synchronized with the live procedure registry. A direct CALL nexyron.feature_separability(...) requires the named abstraction contracts, artifacts, features, snapshots, datasets, models, or policies referenced by that call to exist first; otherwise the runtime correctly fails with an unknown-contract error rather than inventing state.

Conceptual Explanation

Feature snapshots in Nexyron write values into stream-backed feature histories. This procedure treats those streams as a latest-state analytical matrix:

Null or unavailable predictor values are not treated as a category. They are counted in missing_count for coverage diagnostics, but excluded from the separability score and evidence_json buckets.

Numeric target features are converted into four observed-range target bands before scoring. Text target features keep the most common target values up to the target category cap and group the rest as Other. Predictor features use the configured bin/category limits.

The score is an entropy-reduction style target-separation score from 0.0 to 1.0. Higher means the feature bucket or feature-pair bucket contains cleaner target groups. For pairs, interaction_gain is:

pair_score - max(feature_a_score, feature_b_score)

Positive interaction gain means the pair adds signal beyond either feature alone.

The procedure also emits source_overlap_score and source_overlap_warning. These are fast query-text checks over the registered feature Cypher. They flag pairs that appear to share the same underlying query terms or overlap heavily with the target feature query, which helps catch false positives caused by duplicated source fields or leakage.

evidence_json is intentionally reusable. Each evidence bucket includes target counts plus a rule object containing:

The Studio report stores those rules with the selected findings and summarizes tendencies per target side, such as the strongest conditions contributing to true, false, or a numeric target band.

The executor reads the rule conditions, predictor feature values, confidence, support, and importance weights, predicts the target side with a probability-style certainty score, and only then compares the prediction with the real target value. The validation report renders a confusion-matrix heatmap and true-positive, false-positive, false-negative, and true-negative counts.

More Detailed Explanation

In practical queries, start by deciding the row grain you want after the call: one row per node, one row per path, one row per registry object, one row per artifact, or one row per summary. Then keep that grain explicit with YIELD and named projections. That is the difference between a useful planner-facing example and a vague call that downstream tooling cannot safely compose. For contract-driven abstraction procedures, the executable examples on these pages intentionally inspect procedure metadata unless the required named artifacts are created in the same example.

Advanced Example

CALL nexyron.procedures()
YIELD name, parameters, output_columns
WHERE name = 'nexyron.feature_separability'
RETURN name,
       [p IN parameters | p.name] AS parameter_names,
       output_columns
ORDER BY name

For a stage abstraction, the procedure scores stage features and actor-member features reachable through registered stage-to-actor relations. For a society abstraction, it scores society features, member-stage features, and actor features reached through society-to-stage then stage-to-actor relations. Environment abstractions are included through registered environment relations when they connect to the target abstraction.

Real Use Cases

Real Limitations And Tradeoffs