Silent Transmitters

Silent Transmitters

An emergency relay network contains 512 registered transmitters. Exactly one
transmitter is active, but a receiver never reveals its identity directly.
Instead, you may send one of 192 binary diagnostic probes. The receiver
answers yes or no. You may adapt the next probe to every previous answer.

Receivers are imperfect. Their analogue front ends introduce small systematic
changes, so the same transmitter–probe pair can cross the binary decision
boundary at different receivers. You receive continuous features for every
transmitter and probe, plus sparse labelled calibration pairs from one nominal
and four shifted receivers. Two transmitter families intentionally have no
calibration labels. Your job is to learn the signal oracle well enough to
design a short, robust identification strategy.

This is a continuation-style task inspired by the adaptive decision policies
of IOAI 2026 Home Task 3, but it uses a new, entirely synthetic signal domain.

Objective

Submit one finite adaptive decision graph. An internal evaluator runs that
same graph independently on every hidden receiver case. A graph node is either:

• an ask node, which selects a probe and branches on its binary answer; or
• a terminal guess node, which contains a ranked list of transmitter IDs.

Every probe and every attempted transmitter guess costs one call. There are at
most 15 calls per case.

If the correct transmitter is reached after calls actions, the row score is

1max(0, 1 - 0.02 × calls)

An unsolved case scores 0. The platform score is 100 times the mean row
score. Larger is better.

Data

The public dataset contains:

• transmitters.csv: 512 IDs, family IDs, and 12 continuous features;
• probes.csv: 192 IDs, channel IDs, and 10 continuous features;
• receivers.csv: the five public receiver profiles and calibration levels;
• calibration.csv: sparse binary transmitter–probe labels, indexed by
  receiver;
• dev_cases.csv: 64 public end-to-end cases with packed complete answer rows;
• dataset.json: dimensions, revisions, and SHA-256 bindings;
• a NumPy baseline, a local scorer, and the exact public validator.

The public/live split contains nominal cases and cases from receivers with
substantial public calibration. The final split is disjoint and additionally
tests feature-based generalisation to the unlabelled transmitter families and
robustness to unseen low-rank receiver drift. The receiver profile of a hidden
case is not given to the strategy; its answers are the only feedback.

All data are synthetic. There are no external downloads or licences.

Submission format

Upload a ZIP archive containing exactly one root-level UTF-8 file:

1strategy.json

Its schema is:

1{2  "schema": "ioai-2026-silent-transmitters-policy-v1",3  "dataset_revision": "silent-transmitters-2026.07.21.2",4  "root": 0,5  "nodes": [6    {"type": "ask", "probe": 17, "yes": 1, "no": 2},7    {"type": "guess", "transmitters": [41, 203, 7]},8    {"type": "guess", "transmitters": [8, 99]}9  ]10}

At an ask node, yes and no are node indexes. At a guess node, IDs are
attempted from left to right until one is correct or the list ends.

The following rules are strict:

• root, node indexes, probe IDs, and transmitter IDs are JSON integers;
• probe IDs are in [0, 191]; transmitter IDs are in [0, 511];
• the graph has at most 65,535 nodes, is acyclic, and every node is reachable
  from root;
• a ranked list is non-empty, contains no duplicate, and has at most 15 IDs;
• on every root-to-leaf path, asks plus ranked guesses total at most 15;
• unknown keys, duplicate JSON keys, floating-point numbers, NaN, and
  infinities are rejected;
• the uncompressed strategy.json is at most 16 MiB.

The evaluator interprets JSON only. It never imports or executes participant
code.

Development workflow

After extracting the public dataset:

1python3 baseline.py --dataset-dir . --output submission.zip2python3 validate_submission.py submission.zip3python3 local_score.py submission.zip --dev-cases dev_cases.csv

The baseline learns an approximate bilinear oracle, selects nine balanced
probes non-adaptively, then ranks candidates by reliability-weighted hard
mismatches. It is deliberately simple. Stronger solutions can model receiver
variation, calibrate answer uncertainty, select probes by conditional
information gain, and keep soft candidate weights instead of eliminating a
transmitter after one mismatch.

Packed development answers

answers_hex stores 192 answers in 24 bytes. It is equivalent to:

1packed = numpy.packbits(answers.astype(numpy.uint8), bitorder="little")2answers = numpy.unpackbits(packed, bitorder="little")[:192]

Bit p is the answer to probe p.