The Void

From the last-layer weights and cached activations of a text classifier, identify the five hidden (concept, value) pairs that trigger it in synthetic reports.

Author: Gonçalo Franco
Written: 3 October 2026
Released validation result: 5/5 trigger pairs recovered
Estimated points: 100/100
Olympiad: Polish Olympiad in Artificial Intelligence (Olimpiada Sztucznej Inteligencji), 2026 · Final (Stage III)

Measured results use the released validation sets and the evaluator logic in each notebook. They do not establish secret-test performance.

Back to the task Download solution.py

Hints

Hint 1

Can the given output layer reconstruct each report’s predicted label?

Hint 2

What must be true of a pair that is itself a trigger?

Hint 3

Why do several correlated pairs survive that filter?

Hint 4

Use the continuous logit margin to rank those candidates.

The solution in one line

Keep pairs absent from every negative report, then select the five with the largest mean positive logit.

The editorial

Dataset analysis and EDA

The release contains 5,000 reports and a (5000, 10) activation matrix. Recomputing logit = activation @ w + b gives 244 positives and 4,756 negatives. The reports contain 200 distinct observed pairs.

Filtering out any pair that occurs in a negative report leaves ten candidates. Five are true triggers; five are correlated decoys. The positive-only candidates’ mean logits separate the two groups: the five highest means are the five release answers. A set-cover-only rule is unreliable here: correlated decoys can cover all positive rows with fewer than five pairs.

Candidate pair	Mean logit when present	Release label
StarSystem = TRAPPIST-1	2.904	Trigger
TechLevel = Crystal-Tech	2.756	Trigger
Cargo = Frozen Colonists	2.746	Trigger
GovernmentType = Anarchy	2.684	Trigger
EncounteredAnomaly = Dark Matter Cloud	2.632	Trigger
StarshipClass = Science Vessel	2.510	Correlated candidate
Destination = Outpost	2.503	Correlated candidate
Sector = Sector 005	2.459	Correlated candidate
LastLogEntry = Shields raised as a precaution.	2.373	Correlated candidate
PrimaryExport = Alien Artifacts	2.342	Correlated candidate

Solution strategy

Reconstruct the model logit and binary label using the stated zero threshold.
Build one presence mask per (concept, value) pair.
Keep pairs that appear in at least one positive report and no negative report.
Rank those candidates by their mean logit on reports containing the pair; return the top five.

For the released validation set, the recovered pairs are StarSystem = TRAPPIST-1, TechLevel = Crystal-Tech, Cargo = Frozen Colonists, GovernmentType = Anarchy, and EncounteredAnomaly = Dark Matter Cloud. These match the release ground truth 5/5. The implementation does not read the ground-truth file.

Implementation and compute footprint

The code uses NumPy to form 5,000×200 Boolean incidence masks and calculate conditional means. It requires little CPU time and no GPU. A fallback scoring branch keeps the function’s output length at five if a future release has fewer than five perfectly positive-only candidates.

Other plausible methods are sparse logistic regression on pair indicators, conditional logit comparisons, and set cover with a margin-based tie-breaker. The validation experiment shows why output labels alone can be ambiguous when non-trigger values co-occur with triggers.

Code

Solution code solution.py · 39 lines

from typing import List, Tuple
import numpy as np

def solve_release_set(
    activations,
    rows,
    w,
    b,
) -> List[Tuple[str, str]]:
    """Find five hidden (concept, value) triggers from the linear-head margins."""
    activations = np.asarray(activations, dtype=np.float32)
    w = np.asarray(w, dtype=np.float32).reshape(-1)
    logits = activations @ w + float(np.asarray(b))
    positive = logits >= 0.0

    pair_masks = {}
    for row_index, row in enumerate(rows):
        for concept, value in row["concepts"].items():
            pair = (concept, value)
            if pair not in pair_masks:
                pair_masks[pair] = np.zeros(len(rows), dtype=bool)
            pair_masks[pair][row_index] = True

    # A true OR-trigger cannot occur in a negative report. Among the remaining
    # correlated candidates, true triggers have the larger mean positive logit.
    candidates = []
    for pair, present in pair_masks.items():
        present_positive = present & positive
        if present_positive.any() and not (present & ~positive).any():
            candidates.append((pair, float(logits[present_positive].mean())))

    # If a release set has fewer than five perfectly positive-only candidates,
    # retain a penalized fallback so the function still returns five pairs.
    if len(candidates) < 5:
        candidates = []
        for pair, present in pair_masks.items():
            if not present.any():
                continue
            pos_mean = float(logits[present & positive].mean()) if (present & positive).any() else -1e6
            neg_rate = float((present & ~positive).sum()) / float(present.sum())
            candidates.append((pair, pos_mean - 10.0 * neg_rate))

    candidates.sort(key=lambda item: (-item[1], str(item[0][0]), str(item[0][1])))
    return [pair for pair, _ in candidates[:5]]

Download solution.py

Written by Gonçalo Franco; added here on 4 October 2026. Editorials are written by members of the SOTA community, not by the olympiad. The official statement and scoring win wherever an editorial differs.