qcoder 0.1.0a0__py3-none-any.whl

qcoder/engines/prediction_model/engine.py

@@ -0,0 +1,209 @@
+# Path: src/qcoder/engines/prediction_model/engine.py
+from __future__ import annotations
+
+import math
+from typing import Any
+
+from .artifact import load_artifact
+from .models import (
+    ConstantFidelityCurveModel,
+    ConstantProbaModel,
+    LinearRuntimeModel,
+    expm1,
+    log1p,
+)
+from .policy import choose_rung_expected_score
+from .schema_alignment import align_features_to_artifact, parse_feature_bundle
+
+
+def predict(
+    report_json_dict: dict[str, Any],
+    artifact: dict[str, Any] | None = None,
+    artifact_path: str | None = None,
+    *,
+    allow_schema_mismatch: bool = False,
+) -> dict[str, Any]:
+    """
+    Predict from analyze report (or any dict with "features" bundle).
+    Returns prediction_model block: predicted_threshold_min, predicted_forward_wall_s, thr_pred, thr_conf, etc.
+    Enforces no monotone assumptions. Strict schema_version match unless allow_schema_mismatch.
+    For mode "fidelity_curve", uses run_config.prediction_fidelity_target and prediction_fidelity_metric
+    when present; otherwise artifact defaults. If both missing in fidelity_curve mode, raises.
+    """
+    if artifact is None and artifact_path:
+        artifact = load_artifact(artifact_path)
+    if artifact is None:
+        raise ValueError("either artifact or artifact_path must be provided")
+
+    features_bundle = report_json_dict.get("features")
+    if not isinstance(features_bundle, dict):
+        raise TypeError("report must contain 'features' dict (schema_version, feature_names, features)")
+
+    schema_version, _, _ = parse_feature_bundle(features_bundle)
+    art_schema = artifact.get("qcoder_schema_version") or ""
+    if not allow_schema_mismatch and schema_version != art_schema:
+        raise ValueError(
+            f"schema_version mismatch: report has {schema_version!r}, artifact expects {art_schema!r}. "
+            "Set allow_schema_mismatch=True to override."
+        )
+
+    art_features = artifact.get("feature_names") or []
+    x = align_features_to_artifact(features_bundle, art_features)
+    run_config = report_json_dict.get("run_config") or {}
+
+    thr_stage = artifact.get("threshold_stage") or {}
+    mode = thr_stage.get("mode", "ladder")  # backward compat: missing -> ladder
+
+    rt_stage = artifact.get("runtime_stage") or {}
+    rt_intercept = rt_stage.get("intercept", 0.0)
+    rt_coef = rt_stage.get("coef", [0.0])
+    rt_model = LinearRuntimeModel(intercept=rt_intercept, coef=rt_coef)
+
+    def _runtime_for_threshold(thr: int | float) -> float:
+        thr_val = int(thr) if isinstance(thr, (int, float)) else 0
+        log2_thr = math.log2(thr_val) if thr_val > 0 else 0.0
+        rt_x = [log2_thr]
+        for _ in range(len(rt_coef) - 1):
+            rt_x.append(0.0)
+        rt_x = rt_x[: len(rt_coef)]
+        y_log = rt_model.predict_log1p_runtime(rt_x)
+        return max(0.0, expm1(y_log) if y_log >= 0 else 0.0)
+
+    if mode == "fidelity_curve":
+        return _predict_fidelity_curve(
+            report_json_dict,
+            artifact,
+            run_config,
+            art_features,
+            x,
+            rt_model,
+            rt_coef,
+            _runtime_for_threshold,
+        )
+
+    # Stage 1 — ladder (no monotone constraint; use expected-score policy)
+    rungs = thr_stage.get("rungs") or [0.0]
+    n_rungs = len(rungs)
+    thr_model = ConstantProbaModel(n_rungs=n_rungs)
+    probs = thr_model.predict_proba()
+    chosen_idx = choose_rung_expected_score(probs)
+    thr_pred = rungs[chosen_idx] if chosen_idx < len(rungs) else rungs[-1]
+    thr_conf = probs[chosen_idx] if probs else 0.0
+    thr_entropy = _entropy(probs)
+    thr_expected_rung = sum(i * p for i, p in enumerate(probs))
+    predicted_forward_wall_s = _runtime_for_threshold(thr_pred)
+
+    return {
+        "predicted_threshold_min": thr_pred,
+        "predicted_forward_wall_s": predicted_forward_wall_s,
+        "thr_pred": thr_pred,
+        "thr_conf": thr_conf,
+        "thr_entropy": thr_entropy,
+        "thr_expected_rung": thr_expected_rung,
+    }
+
+
+def _predict_fidelity_curve(
+    report_json_dict: dict[str, Any],
+    artifact: dict[str, Any],
+    run_config: dict[str, Any],
+    art_features: list[str],
+    x: list[float],
+    rt_model: LinearRuntimeModel,
+    rt_coef: list[float],
+    runtime_for_threshold: Any,
+) -> dict[str, Any]:
+    thr_stage = artifact.get("threshold_stage") or {}
+    raw_grid = thr_stage.get("threshold_grid") or thr_stage.get("rungs") or [0]
+    threshold_grid = [int(v) for v in raw_grid]
+
+    fidelity_target = run_config.get("prediction_fidelity_target")
+    if fidelity_target is None:
+        fidelity_target = thr_stage.get("fidelity_target")
+    run_config_metric = run_config.get("prediction_fidelity_metric")
+    artifact_metric = thr_stage.get("fidelity_metric")
+    if run_config_metric is not None and run_config_metric != "":
+        fidelity_metric = str(run_config_metric)
+        fidelity_metric_explicit = True
+    elif artifact_metric is not None and artifact_metric != "":
+        fidelity_metric = str(artifact_metric)
+        fidelity_metric_explicit = "fidelity_metric" in thr_stage
+    else:
+        fidelity_metric = "mirror_fidelity"
+        fidelity_metric_explicit = False
+    if fidelity_target is None:
+        raise ValueError(
+            "fidelity_curve mode requires prediction_fidelity_target (RunConfig or artifact threshold_stage.fidelity_target)"
+        )
+
+    selection_policy = thr_stage.get("selection_policy") or {
+        "type": "min_runtime_subject_to_fidelity",
+        "min_fidelity": float(fidelity_target),
+    }
+    min_fidelity = selection_policy.get("min_fidelity", fidelity_target)
+    no_feasible_policy = str(selection_policy.get("type", "min_runtime_subject_to_fidelity"))
+
+    # Fidelity curve model (stdlib placeholder)
+    fid_model = ConstantFidelityCurveModel(n_points=len(threshold_grid), value=thr_stage.get("fidelity_curve_value", 0.0))
+    predicted_fidelity = fid_model.predict_curve()
+    if len(predicted_fidelity) < len(threshold_grid):
+        predicted_fidelity = predicted_fidelity + [0.0] * (len(threshold_grid) - len(predicted_fidelity))
+    predicted_fidelity = predicted_fidelity[: len(threshold_grid)]
+
+    best_fidelity = max(predicted_fidelity) if predicted_fidelity else 0.0
+    candidate_indices = [k for k in range(len(threshold_grid)) if predicted_fidelity[k] >= min_fidelity]
+    feasible = len(candidate_indices) > 0
+    warnings: list[str] = []
+    if not fidelity_metric_explicit and fidelity_metric == "mirror_fidelity":
+        warnings.append("fidelity_metric_defaulted_to_mirror_fidelity")
+
+    if not candidate_indices:
+        chosen_idx = max(range(len(threshold_grid)), key=lambda k: predicted_fidelity[k] if k < len(predicted_fidelity) else 0.0)
+        chosen_threshold = threshold_grid[chosen_idx]
+        warnings.append("no_threshold_meets_fidelity_target")
+    else:
+        best_idx = candidate_indices[0]
+        best_runtime = runtime_for_threshold(threshold_grid[best_idx])
+        for k in candidate_indices[1:]:
+            r = runtime_for_threshold(threshold_grid[k])
+            if r < best_runtime:
+                best_runtime = r
+                best_idx = k
+        chosen_idx = best_idx
+        chosen_threshold = threshold_grid[chosen_idx]
+
+    best_runtime_s = runtime_for_threshold(chosen_threshold)
+
+    fidelity_curve_block = {
+        "threshold_grid": list(threshold_grid),
+        "predicted_fidelity": list(predicted_fidelity),
+        "fidelity_target": float(fidelity_target),
+        "fidelity_metric": str(fidelity_metric),
+        "candidate_thresholds": [threshold_grid[k] for k in candidate_indices],
+        "chosen_threshold": chosen_threshold,
+        "selection_policy": selection_policy,
+        "feasible": feasible,
+        "no_feasible_policy": no_feasible_policy,
+        "best_fidelity": float(best_fidelity),
+        "best_runtime_s": float(best_runtime_s),
+    }
+
+    return {
+        "predicted_threshold_min": chosen_threshold,
+        "predicted_forward_wall_s": best_runtime_s,
+        "thr_pred": chosen_threshold,
+        "thr_conf": 0.0,
+        "thr_entropy": 0.0,
+        "thr_expected_rung": 0.0,
+        "fidelity_curve": fidelity_curve_block,
+        "warnings": warnings,
+    }
+
+
+def _entropy(probs: list[float]) -> float:
+    """Shannon entropy of discrete distribution."""
+    h = 0.0
+    for p in probs:
+        if p > 0:
+            h -= p * math.log2(p)
+    return h

qcoder/engines/prediction_model/models.py

@@ -0,0 +1,62 @@
+# Path: src/qcoder/engines/prediction_model/models.py
+from __future__ import annotations
+
+import math
+from dataclasses import dataclass
+from typing import Any
+
+
+@dataclass
+class ConstantProbaModel:
+    """Constant (uniform) probability over rungs. Stdlib-only."""
+
+    n_rungs: int
+
+    def predict_proba(self) -> list[float]:
+        if self.n_rungs <= 0:
+            return []
+        p = 1.0 / self.n_rungs
+        return [p] * self.n_rungs
+
+
+@dataclass
+class LinearRuntimeModel:
+    """
+    Tiny stdlib linear regression: y = intercept + dot(coef, x).
+    No monotone constraints (runtime vs threshold may be non-monotonic).
+    """
+
+    intercept: float
+    coef: list[float]
+
+    def predict(self, x: list[float]) -> float:
+        if len(x) != len(self.coef):
+            return self.intercept
+        return self.intercept + sum(c * v for c, v in zip(self.coef, x))
+
+    def predict_log1p_runtime(self, x: list[float]) -> float:
+        """Target is log1p(runtime_seconds). No monotone constraint."""
+        return self.predict(x)
+
+
+def expm1(x: float) -> float:
+    """exp(x) - 1, stdlib-only."""
+    return math.exp(x) - 1.0
+
+
+def log1p(x: float) -> float:
+    """log(1 + x), stdlib."""
+    return math.log1p(x)
+
+
+@dataclass
+class ConstantFidelityCurveModel:
+    """Stdlib placeholder: returns a flat fidelity curve [value] * n_points."""
+
+    n_points: int
+    value: float = 0.0
+
+    def predict_curve(self) -> list[float]:
+        if self.n_points <= 0:
+            return []
+        return [self.value] * self.n_points

qcoder/engines/prediction_model/policy.py

@@ -0,0 +1,45 @@
+# Path: src/qcoder/engines/prediction_model/policy.py
+from __future__ import annotations
+
+import math
+
+
+def score_matrix_value(pred_rung: int, true_rung: int) -> float:
+    """
+    Decision matrix: if pred < true → 0; if pred >= true → 2^-(pred - true).
+    Rungs are non-negative integer indices.
+    """
+    if pred_rung < true_rung:
+        return 0.0
+    return math.pow(2.0, -(pred_rung - true_rung))
+
+
+def expected_score_for_rung(probs: list[float], chosen_rung: int) -> float:
+    """
+    Expected score when we choose chosen_rung and true rung is distributed per probs.
+    E[score] = sum_t probs[t] * score_matrix_value(chosen_rung, t).
+    """
+    n = len(probs)
+    total = 0.0
+    for t in range(n):
+        if t < len(probs) and probs[t] > 0:
+            total += probs[t] * score_matrix_value(chosen_rung, t)
+    return total
+
+
+def choose_rung_expected_score(probs: list[float]) -> int:
+    """
+    Expected-score decision policy (do NOT use argmax of probs).
+    Choose rung r that maximizes expected score sum_t probs[t] * score_matrix_value(r, t).
+    """
+    n = len(probs)
+    if n == 0:
+        return 0
+    best_r = 0
+    best_score = expected_score_for_rung(probs, 0)
+    for r in range(1, n):
+        s = expected_score_for_rung(probs, r)
+        if s > best_score:
+            best_score = s
+            best_r = r
+    return best_r

qcoder/engines/prediction_model/schema_alignment.py

@@ -0,0 +1,41 @@
+# Path: src/qcoder/engines/prediction_model/schema_alignment.py
+from __future__ import annotations
+
+from typing import Any
+
+
+def parse_feature_bundle(bundle: dict[str, Any]) -> tuple[str, list[str], list[float]]:
+    """
+    Parse the actual feature bundle shape: schema_version, feature_names, features.
+    Returns (schema_version, feature_names, features).
+    Raises if bundle is invalid.
+    """
+    if not isinstance(bundle, dict):
+        raise TypeError("feature bundle must be a dict")
+    schema_version = bundle.get("schema_version")
+    if not isinstance(schema_version, str):
+        schema_version = "unknown"
+    names = bundle.get("feature_names")
+    vals = bundle.get("features")
+    if not isinstance(names, list) or not isinstance(vals, list):
+        raise TypeError("feature bundle must contain feature_names and features lists")
+    if len(names) != len(vals):
+        raise ValueError("feature_names and features length mismatch")
+    name_list = [str(n) for n in names]
+    val_list = [float(v) for v in vals]
+    return schema_version, name_list, val_list
+
+
+def align_features_to_artifact(
+    bundle: dict[str, Any],
+    artifact_feature_names: list[str],
+    *,
+    default_value: float = 0.0,
+) -> list[float]:
+    """
+    Align by name to artifact feature list.
+    Returns a list of floats in artifact_feature_names order; uses default_value for missing names.
+    """
+    _, names, values = parse_feature_bundle(bundle)
+    name_to_val = dict(zip(names, values))
+    return [name_to_val.get(name, default_value) for name in artifact_feature_names]

qcoder/engines/quantumness/__init__.py

@@ -0,0 +1,8 @@
+from __future__ import annotations
+
+from .scorer import QuantumnessReport, score_from_feature_vector
+
+__all__ = [
+    "QuantumnessReport",
+    "score_from_feature_vector",
+]

qcoder/engines/quantumness/scorer.py

@@ -0,0 +1,254 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+import math
+from typing import Any, Mapping
+
+
+def _clamp01(x: float) -> float:
+    if x < 0.0:
+        return 0.0
+    if x > 1.0:
+        return 1.0
+    return float(x)
+
+
+def _safe_float(x: Any, default: float = 0.0) -> float:
+    try:
+        if x is None:
+            return default
+        return float(x)
+    except Exception:
+        return default
+
+
+def _safe_int(x: Any, default: int = 0) -> int:
+    try:
+        if x is None:
+            return default
+        return int(x)
+    except Exception:
+        return default
+
+
+def _to_feature_dict(feature_vector: Any) -> dict[str, Any]:
+    """
+    Accept either:
+      A) {"schema_version": str, "feature_names": [...], "features": [...]}
+      B) {"n_qubits": 2, ...}  (already name->value)
+
+    Return name->value dict.
+
+    Deterministic, dependency-free, and tolerant of extra keys.
+    """
+    if not isinstance(feature_vector, Mapping):
+        raise TypeError("feature_vector must be a mapping (dict-like)")
+
+    # Case A: bundle form
+    if "feature_names" in feature_vector and "features" in feature_vector:
+        names = feature_vector.get("feature_names")
+        vals = feature_vector.get("features")
+        if not isinstance(names, list) or not isinstance(vals, list):
+            raise TypeError("feature_vector bundle must contain lists: feature_names, features")
+        if len(names) != len(vals):
+            raise ValueError("feature_vector bundle feature_names/features length mismatch")
+        out: dict[str, Any] = {}
+        for k, v in zip(names, vals):
+            # Keep last occurrence if duplicates exist (should not happen by schema tests)
+            out[str(k)] = v
+        return out
+
+    # Case B: assume name->value dict, but strip known non-feature keys if present
+    out = dict(feature_vector)
+    out.pop("schema_version", None)
+    return out
+
+
+@dataclass(frozen=True)
+class QuantumnessReport:
+    """
+    Minimal, explainable quantumness scoring output.
+
+    This is NOT part of the feature schema; it is a separate engine output.
+    """
+
+    # The feature schema version this scorer consumed (e.g., "0.3.0").
+    feature_schema_version: str
+
+    # Final score in [0, 1].
+    score: float
+
+    # Stage 1 hard reasons (conservative no-chance filters).
+    triggered_reasons: list[str] = field(default_factory=list)
+
+    # Stage 2 subscores in [0, 1].
+    subscores: dict[str, float] = field(default_factory=dict)
+
+    # Small dict of feature values / derived metrics supporting explainability.
+    supporting_metrics: dict[str, Any] = field(default_factory=dict)
+
+    def to_json_dict(self) -> dict[str, Any]:
+        # Deterministic output keys; dict key ordering in Python is insertion-ordered.
+        return {
+            "feature_schema_version": self.feature_schema_version,
+            "score": float(self.score),
+            "triggered_reasons": list(self.triggered_reasons),
+            "subscores": dict(self.subscores),
+            "supporting_metrics": dict(self.supporting_metrics),
+        }
+
+
+def score_from_feature_vector(feature_vector: Mapping[str, Any]) -> QuantumnessReport:
+    """
+    Score quantumness from an extracted feature vector.
+
+    - Deterministic
+    - Dependency-free
+    - Independent of RunConfig
+    - Model-agnostic
+    - Consumes a stable subset of existing extracted features
+    """
+    # Determine feature schema version if provided (bundle-form).
+    feature_schema_version = "unknown"
+    if isinstance(feature_vector, Mapping):
+        v = feature_vector.get("schema_version")
+        if isinstance(v, str) and v:
+            feature_schema_version = v
+
+    fv = _to_feature_dict(feature_vector)
+
+    # --- Pull the (documented) subset we use ---
+    n_qubits = _safe_int(fv.get("n_qubits"))
+    n_gate_ops = _safe_int(fv.get("n_gate_ops"))
+    n_2q = _safe_int(fv.get("n_2q_gate_ops"))
+    n_3p = _safe_int(fv.get("n_3p_gate_ops"))
+
+    ent_depth = _safe_int(fv.get("entangling_depth"))
+    n_ent_layers = _safe_int(fv.get("n_entangling_layers"))
+    avg_2q_per_layer = _safe_float(fv.get("avg_2q_per_entangling_layer"))
+
+    is_diag_only = _safe_int(fv.get("is_certified_diagonal_only"))
+    n_basis_change = _safe_int(fv.get("n_basis_change_ops"))
+    diag_frac = _safe_float(fv.get("diagonal_gate_fraction"))
+
+    n_t_like = _safe_int(fv.get("n_t_like_ops"))
+    n_distinct_angles = _safe_int(fv.get("n_distinct_angles"))
+    angle_genericity_ratio = _safe_float(fv.get("angle_genericity_ratio"))
+
+    basis_change_qubit_coverage = _safe_float(fv.get("basis_change_qubit_coverage"))
+
+    ig_n_components = _safe_int(fv.get("ig_n_components"))
+    ig_largest_cc_frac = _safe_float(fv.get("ig_largest_cc_frac"))
+    ig_degree_entropy = _safe_float(fv.get("ig_degree_entropy"))
+
+    # These are used only for normalization; safe defaults if absent.
+    real_depth = _safe_int(fv.get("real_depth"), default=0)
+
+    supporting: dict[str, Any] = {
+        "n_qubits": n_qubits,
+        "n_gate_ops": n_gate_ops,
+        "n_2q_gate_ops": n_2q,
+        "n_3p_gate_ops": n_3p,
+        "entangling_depth": ent_depth,
+        "n_entangling_layers": n_ent_layers,
+        "avg_2q_per_entangling_layer": float(avg_2q_per_layer),
+        "is_certified_diagonal_only": is_diag_only,
+        "n_basis_change_ops": n_basis_change,
+        "diagonal_gate_fraction": float(diag_frac),
+        "n_t_like_ops": n_t_like,
+        "n_distinct_angles": n_distinct_angles,
+        "angle_genericity_ratio": float(angle_genericity_ratio),
+        "basis_change_qubit_coverage": float(basis_change_qubit_coverage),
+        "ig_n_components": ig_n_components,
+        "ig_largest_cc_frac": float(ig_largest_cc_frac),
+        "ig_degree_entropy": float(ig_degree_entropy),
+        "real_depth": real_depth,
+    }
+
+    # -------------------------------
+    # Stage 1: conservative no-chance filters
+    # -------------------------------
+    reasons: list[str] = []
+
+    # No entanglement proxy: no 2Q/3+Q gates OR entangling depth/layers both zero.
+    no_entanglement = ((n_2q + n_3p) == 0) or (ent_depth == 0 and n_ent_layers == 0)
+    if no_entanglement:
+        reasons.append("no_entanglement")
+
+    # Certified diagonal-only: current schema already supports a certified flag.
+    # We only trigger when certified, and basis change is absent (strong evidence phases won't matter for Z-basis outcomes).
+    diagonal_only = (is_diag_only == 1) and (n_basis_change == 0) and (diag_frac >= 0.999)
+    if diagonal_only:
+        reasons.append("diagonal_only")
+
+    if reasons:
+        return QuantumnessReport(
+            feature_schema_version=feature_schema_version,
+            score=0.0,
+            triggered_reasons=reasons,
+            subscores={},
+            supporting_metrics=supporting,
+        )
+
+    # -------------------------------
+    # Stage 2: ingredient subscores (interpretable)
+    # -------------------------------
+    # MagicScore: non-Clifford proxies (simple conservative normalization).
+    denom_gate = max(1, n_gate_ops)
+    t_frac = min(1.0, n_t_like / float(denom_gate))
+    angle_score = _clamp01(angle_genericity_ratio)  # already ratio-like
+    # Distinct angles: normalize by a mild scale to avoid overweighting.
+    distinct_scale = max(1, 2 * max(1, n_qubits))
+    distinct_score = min(1.0, n_distinct_angles / float(distinct_scale))
+    magic = _clamp01(0.5 * t_frac + 0.3 * angle_score + 0.2 * distinct_score)
+
+    # EntangleScore: depth + layer density + connectivity.
+    denom_depth = max(1, real_depth) if real_depth > 0 else max(1, ent_depth)
+    depth_ratio = min(1.0, ent_depth / float(denom_depth))
+    # Layer density: how many entangling ops per entangling layer relative to ~n_qubits/2.
+    target_2q_per_layer = max(1.0, n_qubits / 2.0) if n_qubits > 0 else 1.0
+    layer_density = min(1.0, avg_2q_per_layer / target_2q_per_layer)
+    connectivity = _clamp01(ig_largest_cc_frac) if n_qubits > 0 else 0.0
+    entangle = _clamp01(0.4 * depth_ratio + 0.3 * layer_density + 0.3 * connectivity)
+
+    # CoherenceScore: basis change presence + coverage.
+    basis_frac = min(1.0, n_basis_change / float(denom_gate))
+    coverage = _clamp01(basis_change_qubit_coverage)
+    coherence = _clamp01(0.6 * coverage + 0.4 * basis_frac)
+
+    # Optional mild structure hint via degree entropy (normalized by log2(n_qubits)).
+    # This is a supporting subscore, not a hard signal.
+    if n_qubits >= 2:
+        norm = math.log2(float(n_qubits))
+        deg_entropy_norm = _clamp01(ig_degree_entropy / norm) if norm > 0 else 0.0
+    else:
+        deg_entropy_norm = 0.0
+
+    subscores = {
+        "MagicScore": float(magic),
+        "EntangleScore": float(entangle),
+        "CoherenceScore": float(coherence),
+        "DegreeEntropyNorm": float(deg_entropy_norm),
+    }
+
+    # Weighted combination (documented and deterministic).
+    # Keep conservative weights and avoid overfitting.
+    score = _clamp01(0.45 * magic + 0.40 * entangle + 0.15 * coherence)
+
+    # Add a couple derived metrics for explainability, deterministic and small.
+    supporting.update(
+        {
+            "derived_t_frac": float(t_frac),
+            "derived_depth_ratio": float(depth_ratio),
+            "derived_layer_density": float(layer_density),
+            "derived_basis_frac": float(basis_frac),
+        }
+    )
+
+    return QuantumnessReport(
+        feature_schema_version=feature_schema_version,
+        score=float(score),
+        triggered_reasons=[],
+        subscores=subscores,
+        supporting_metrics=supporting,
+    )