💻 computer science

Executable Boundary Contracts for Sound Event Traces

This paper introduces executable boundary contracts for finite sound event traces to enable precise measurement of timed boundary behaviors, demonstrating through experiments on diverse datasets that standard scoring metrics often fail to detect specific boundary failures that these contracts can explicitly identify.

Original authors: Faruk Alpay, Hamdi Alakkad

Published 2026-05-20

📖 5 min read🧠 Deep dive

CC BY 4.0

Original authors: Faruk Alpay, Hamdi Alakkad

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

The Big Picture: Checking the "Edges" of Sound

Imagine you are hiring a security guard to watch a door. The guard's job is to tell you exactly when someone enters and when they leave.

In the world of sound detection (like a computer listening for a dog bark or a speech command), current systems usually give a simple report card: "The guard was right 80% of the time." But this score hides the details. Did the guard open the door too early? Did they leave it open too long after the person left? Did they think a car backfired was a person entering?

This paper argues that a single "80%" score isn't enough. Instead, we need a detailed checklist (called an "Executable Boundary Contract") that breaks down exactly how the guard succeeded or failed at every specific moment.

The Problem: The "Blurry Photo" Effect

The authors compare current sound detection reports to looking at a blurry photo.

Current Method: You see a blob of "activity" that overlaps with the real event. The system says, "Great job, you caught the event!" because the blob covers most of the event.
The Reality: The guard might have started the alarm 2 seconds late and stopped it 3 seconds late. The "blob" overlaps, but the timing is wrong. If this guard is controlling a real door, the door opens too late, and the person has already walked away.

The paper says: "Stop just looking at the overlap. Let's check the specific edges (boundaries) of the sound."

The Solution: The "Contract"

The authors created a new way to test sound detectors called Executable Boundary Contracts. Think of this as a strict legal contract between the sound detector and the person testing it.

Instead of a vague promise, the contract has specific, written rules (clauses) that the detector must follow:

The Onset Clause: "You must start the alarm within 60 milliseconds of the sound starting."
The Offset Clause: "You must stop the alarm within 80 milliseconds of the sound ending."
The Silence Clause: "You must not trigger the alarm when there is total silence."
The Duration Clause: "The alarm must last for roughly the same amount of time as the sound."
The Fragmentation Clause: "If the sound is one continuous event, you must report it as one event, not chop it into three tiny pieces."

These rules are written in a special computer language that can be run automatically. The computer checks the detector's output against these rules and gives a vector (a list of scores) rather than just one number.

The Analogy: The "Bridge" Test

The paper uses a great analogy about a bridge to explain why the old way fails.

The Old Way: You check if a car drove over the bridge. If the car is on the bridge for most of the trip, you say, "Good job, the bridge works!"
The New Way (The Contract): You check if the car entered the bridge at the right ramp and exited at the right ramp.
- If the car drove onto the bridge 10 seconds too late, the contract says: "Fail on Entry."
- If the car drove off the bridge 10 seconds too late, the contract says: "Fail on Exit."
- If the car drove onto the bridge but then stopped in the middle, the contract says: "Fail on Duration."

Even if the car was on the bridge for 90% of the time (a high "overlap score"), the contract reveals that the driver missed the ramps entirely.

What They Found (The Results)

The authors tested this new "Contract" system on several different sound detectors (some simple, some complex AI models) using:

Controlled Scenes: They created fake soundscapes with precise timing (like a speech segment followed by a beep) and added noise, echoes, and distortions.
Real Soundscapes: They used real recordings from places like cafes and train stations.
External Competitions: They tested it against official results from a major sound detection competition (DCASE 2024).

Key Findings:

The "Union" Trap: Sometimes, a detector looks great because it catches the general activity (the "union" of all sounds), but it fails completely at identifying specific sounds. For example, it might detect "someone is talking" perfectly, but fail to distinguish between "a man talking" and "a woman talking." The old scores hid this; the new contract exposed it.
Different Detectors for Different Jobs: There is no single "best" detector.
- One detector was great at spotting when a sound started (Onset) but bad at knowing when it stopped (Offset).
- Another was great at not triggering on silence but bad at handling overlapping sounds.
- The new contract lets you pick the right tool for your specific job (e.g., "I need a detector that never misses a start time, even if it sometimes triggers too early").
Noise Matters: When they added noise or echoes, the "overlap" scores stayed high, but the "contract" scores dropped. This proved that the old scores were lying about how well the system handled real-world messiness.

Why This Matters

The paper isn't trying to build a new AI model to win a race. It's building a better ruler.

Just as you wouldn't measure a piece of wood with a ruler that only has inches but no fractions, you shouldn't measure sound detectors with a score that only counts "overlap." This paper provides a ruler with fine markings (milliseconds, specific error types) so engineers can see exactly where their systems are breaking and fix them.

In short: The paper replaces the "Pass/Fail" grade with a detailed report card that tells you exactly which part of the sound boundary the system got wrong, allowing for much smarter improvements.

Technical Summary: Executable Boundary Contracts for Sound Event Traces

Problem Statement
Current sound event detection (SED) benchmarks typically compress timed boundary behavior into scalar metrics such as frame-level F1, segment-level F1, or event-level F1 with fixed tolerance collars. While these numbers summarize overlap, they obscure the specific nature of boundary errors. A detector may achieve a high frame score by correctly identifying the interior of an event while failing at the onset, offset, or duration, thereby altering the "trace contract" offered to downstream components (e.g., retrieval systems, neural decoders, or speech gates). The paper argues that a boundary error is not merely a loss of overlap but a change in the operational trace, yet standard metrics fail to expose these distinct failure modes (e.g., late release vs. early onset, silence leakage vs. spurious activity) in an interpretable, executable manner.

Methodology
The paper proposes a domain-specific executable boundary contract calculus rather than a new general-purpose temporal logic. The methodology is structured around three core components:

Two-Sorted Contract Language:
- Frame Sort: A bounded Boolean fragment embeddable in Signal Temporal Logic (STL) after grid projection. It uses parsed formulas with atoms (e.g., ref onset, pred active), negation, conjunction, implication, and bounded modalities (neighborhood $N_\epsilon$ , future $F_\epsilon$ , always $G_\epsilon$ , until $U_\epsilon$ ). Formulas are evaluated over a fixed frame grid.
- Event Sort: A layer that operates on maximal active runs (half-open intervals) and a declared matching relation. It includes typed clauses for duration, fragmentation, and class-indexed interval identity.
- Obligation-Restricted Scoring: To avoid the vacuity of implication (where a formula is trivially true because the antecedent is rare), scores are averaged only over frames or intervals where a specific "obligation mask" is active (e.g., scoring onset accuracy only on reference onset frames).
The Monitor and Audit Protocol:
- A deterministic parser and monitor evaluate the contract vector against finite traces.
- The system employs a greedy interval matcher (with an option for exact maximum cardinality matching for auditing) to pair reference and prediction intervals.
- The output is a guard vector (a finite list of coordinates) before any scalar mean is computed. This vector separates performance into distinct categories: onset guard, offset guard, missing activity, spurious activity, silence protection, duration, and fragmentation.
- Calibration and Selection: The contract basis is selected relative to a declared calibration set and a written "risk order" (e.g., prioritizing missed support over duration distortion). The selected contract is the smallest set of coordinates that separates higher-risk failure cases from lower-risk ones.
Experimental Setup:
- Controlled Benchmarks: 960 training and 420 test items generated from Mini LibriSpeech segments mixed with synthesized tones and bursts, subjected to controlled perturbations (noise, reverberation, clipping, gain drift, jitter).
- Real Corpus: MAESTRO Real soundscapes with crowdsourced soft strong labels, evaluated under the same monitor.
- Detectors: Six local detectors (threshold-based, logistic regression, temporal CNNs, dilated CNNs, and a contract-aware augmented model) and a frozen encoder probe (wav2vec2, AST, HTS-AT, BEATs) evaluated with a common boundary head.
- External Baseline: The official DCASE 2024 Task 4 baseline is evaluated to provide a challenge-level reference.

Key Contributions

Executable Measurement Infrastructure: The paper introduces a finite specification language where boundary policies are parsed formulas and interval clauses, not implicit heuristics. This allows the benchmark to report a "contract vector" that makes specific obligations inspectable.
Separation of Trace Pathologies: The framework explicitly distinguishes between different failure modes (e.g., onset displacement vs. offset displacement, silence bleed vs. spurious activity) that are often collapsed into a single scalar score.
Reproducibility and Auditability: The artifact includes a tokenizer, parser, monitor, and Lean 4 checks for the finite frame core. Every table is regenerated from source rows, and the system supports tolerance sweeps to show how conclusions change with boundary radius.
Empirical Findings on Union vs. Typed Activity: The study demonstrates that high "union activity" scores (treating all classes as one) can hide significant "typed boundary failures" (errors in class identity or specific class boundaries), a distinction revealed only by the contract vector.

Results

Divergence of Metrics: Standard scores (Frame F1, Boundary F1) and contract coordinates often disagree. For instance, a detector might have a high Frame F1 but fail the silence guard or duration guard, indicating it overlaps the event but fails to respect the boundary contract.
Detector Performance: The contract-aware augmented detector (trained with edge supervision and augmentation) achieved the highest scores across most guard coordinates (Logic: 0.802, Boundary F1: 0.829) on the controlled benchmark. However, different detectors led on different coordinates (e.g., spectral flux led on onset/offset, dilated CNN on missing activity), proving that no single detector is optimal for all boundary pathologies.
Real Corpus Gap: On MAESTRO Real, the union trace scores were high (Logic: 0.917), but class-indexed scores were significantly lower (Logic: 0.542). The mechanism analysis attributed this to class sparsity, support imbalance, and annotation softness, confirming that union metrics can mask typed failures.
Tolerance Sensitivity: The tolerance sweep revealed that some methods appear robust only under loose tolerances, while others maintain performance under strict boundaries. The contract vector exposes this dependence.
Frozen Encoders: Pretrained encoders (e.g., wav2vec2, BEATs) showed varying abilities to preserve timing structure when frozen, with some failing to maintain boundary precision despite high frame-level evidence.

Significance and Claims
The paper modestly claims to provide a contract-based measurement study for sound event traces rather than a new general temporal logic or a detector leaderboard. Its primary significance lies in:

Measurement Shift: Moving from scalar aggregation to an executable vector that separates onset, offset, missing activity, spurious activity, silence, duration, and fragmentation.
Policy Transparency: Making the boundary policy (tolerance, matching rules, obligation masks) explicit and part of the benchmark object, rather than an implicit post-processing step.
Diagnostic Utility: Providing a structured explanation of detector failure that allows downstream applications to select detectors based on specific risk profiles (e.g., a speech gate prioritizing missing activity vs. a retrieval system prioritizing fragmentation).
Reproducibility: Ensuring that every result is derived from a deterministic, auditable pipeline with source code, parser, and Lean checks available.

The authors emphasize that the "contract" is task-relative; the specific set of guards is justified by a declared calibration set and risk order, not by a universal theorem. The work serves as a foundation for making boundary evaluation a checkable, reproducible, and interpretable process.