Complete medium_posts results and restore dataset timing averages

Integrate the verified C++, Java, and Python medium_posts measurement into the existing leaderboard. Use equal-dataset timing averages when selected results contain aggregate-only timing evidence, while retaining equal-column averages for fully column-backed results. Refresh scores, ranks, compact data, and provenance.

README.md

@@ -24,8 +24,13 @@ python3 deploy/huggingface-compressionbenchmark/export_results.py
 python3 deploy/huggingface-compressionbenchmark/apply_dataset_scope.py
 # Reapply verified measurement updates before packing the browser payload.
 python3 scripts/integrate_dbp_leaderboard.py --measurements /path/to/frozen-measurements.json --expected-sha256 VERIFIED_SHA256 --receipt /path/to/integration-receipt.json
-# Verify the published source identities and rebuild equal-column timing means.
-python3 scripts/update_site_column_means.py --receipt /path/to/column-mean-receipt.json
+# Verify source identities, rebuild timing averages, and reapply the targeted retest.
+python3 scripts/update_site_column_means.py \
+  --receipt /path/to/timing-fallback-receipt.json \
+  --dbp-medium-payload analysis_outputs/column_mean_20261009/dbp_medium_posts_retest/integration_payload.json \
+  --dbp-medium-payload-sha256 e45170a955d1cd0df50dba25f9e41f24f00fc8b559e702d59188b6cfa60c99dc \
+  --dbp-medium-receipt analysis_outputs/column_mean_20261009/dbp_medium_posts_retest/measurement_receipt.json \
+  --dbp-medium-receipt-sha256 10359f6f1153655710f7ce9b59d04e5460babe5606487b7794a47ba874ef4324
 python3 deploy/huggingface-compressionbenchmark/build_ui_payload.py
 ```
 
@@ -47,6 +52,9 @@ The summary dataset count and Dataset coverage denominator use the same measured
 
 The Overall score is `a × average rate + b × normalized average compression time + c × normalized average decompression time`. Time normalization is linear min–max across all eligible rows in the selected runtime, scope and row mode; an equal-time range normalizes to zero. Search, family and coverage filters only hide rows and never change the reference. Average Rank averages per-dataset composite-score ranks with dataset-local time normalization and fractional ties. Missing results are omitted. Coverage and candidate counts can differ across datasets; method details expose dataset scores, ranks and candidate counts. CSV downloads include weights, normalization bounds and rank coverage. The default weights are `a=0.4, b=0.3, c=0.3`.
 
-Compression and decompression costs are calculated independently for each usable numeric column as ns/point, then reported as the arithmetic mean across those columns; each column contributes equally. Overall timing pools all measured columns across the selected datasets. If any selected dataset/configuration lacks column-level timing evidence, that Overall timing is unavailable. Historical aggregate-only timing rows without recoverable per-column evidence remain unavailable and are never treated as one synthetic column. Native-float measurements use valid native values; historical imported rows retain their source 8-byte-equivalent point definition. Timing comparisons should therefore stay within the same runtime and measurement contract.
+Compression and decompression costs are calculated independently for each usable numeric column as ns/point, then reported as the arithmetic mean across those columns; each column contributes equally. Overall timing pools all measured columns across the selected datasets when every selected dataset has column-level evidence. If any selected dataset/configuration is backed only by aggregate timing, the method uses an arithmetic mean of its selected per-dataset ns/point values, giving every dataset equal weight. Aggregate-only dataset timing uses recorded elapsed time divided by recorded points; these records keep a zero measured-column count. Truly missing measurements remain unavailable. Method details and CSV expose the timing basis. Native-float measurements use valid native values; historical imported rows retain their source 8-byte-equivalent point definition. Timing comparisons should therefore stay within the same runtime and measurement contract.
 
 Source project: https://github.com/xjz17/web_compression
+
+
+The timing updater verifies the input hashes, replaces existing dataset/runtime/scope rows by identity, and adds only missing rows. The measurement harness and its frozen-source instructions are in `scripts/dbp_medium_posts_retest/`; raw data and compiled binaries are excluded from Git.

app.js

@@ -3,10 +3,17 @@ const $ = (id) => document.getElementById(id);
 const escape = (value) => String(value ?? '').replace(/[&<>"']/g, (c) => ({'&':'&amp;','<':'&lt;','>':'&gt;','"':'&quot;',"'":'&#39;'}[c]));
 const number = (v) => v != null && Number.isFinite(Number(v)) ? Number(v) : null;
 const mean = (values) => { const a = values.map(number).filter((n) => n !== null); return a.length ? a.reduce((s,n) => s+n,0)/a.length : null; };
-function columnMean(input,key) {
-  if(!input.length||input.some(r=>number(r[key])===null||!Number.isInteger(r.timing_column_count)||r.timing_column_count<=0))return null;
+function timingMode(input) {
+  if(!input.length||input.some(r=>number(r.compression_time)===null||number(r.decompression_time)===null||!Number.isInteger(r.timing_column_count)||r.timing_column_count<0||!((r.timing_aggregation==='column_mean'&&r.timing_column_count>0)||(r.timing_aggregation==='dataset_aggregate'&&r.timing_column_count===0))))return 'unavailable';
+  return input.some(r=>r.timing_aggregation==='dataset_aggregate')?'dataset_mean':'column_mean';
+}
+function aggregateTime(input,key) {
+  const mode=timingMode(input);
+  if(mode==='unavailable')return null;
+  if(mode==='dataset_mean')return mean(input.map(r=>r[key]));
   return input.reduce((sum,r)=>sum+r[key]*r.timing_column_count,0)/input.reduce((sum,r)=>sum+r.timing_column_count,0);
 }
+const timingLabel=mode=>({column_mean:'Equal-column arithmetic mean',dataset_mean:'Equal-dataset arithmetic mean',dataset_aggregate:'Dataset aggregate',unavailable:'Not reported'}[mode]??'Not reported');
 const fmt = (v, digits=3) => number(v) === null ? 'Not reported' : Number(v).toLocaleString('en-US',{maximumFractionDigits:digits,minimumFractionDigits:digits});
 const countFmt = (v) => Number(v).toLocaleString('en-US');
 const runtimeName = (v) => ({cpp:'C++',java:'Java',python:'Python'}[v] || v);
@@ -55,7 +62,7 @@ function aggregate(input) {
   for(const [method,source] of groups) {
     const hasBytes=source.every(r=>r.original_bytes!==null && r.original_bytes>0 && r.compressed_bytes!==null && r.compressed_bytes>0);
     const original=hasBytes?source.reduce((s,r)=>s+r.original_bytes,0):null, compressed=hasBytes?source.reduce((s,r)=>s+r.compressed_bytes,0):null;
-    rows.push({method,family:source[0].family,runtime:source[0].runtime,compression_rate:mean(source.map(r=>r.compression_rate)),compression_time:columnMean(source,'compression_time'),decompression_time:columnMean(source,'decompression_time'),timing_column_count:source.reduce((sum,r)=>sum+r.timing_column_count,0),overall_rate:hasBytes?compressed/original:null,original_bytes:original,compressed_bytes:compressed,coverage:new Set(source.map(r=>r.dataset)).size,totalDatasets,source});
+    rows.push({method,family:source[0].family,runtime:source[0].runtime,compression_rate:mean(source.map(r=>r.compression_rate)),compression_time:aggregateTime(source,'compression_time'),decompression_time:aggregateTime(source,'decompression_time'),timing_column_count:source.reduce((sum,r)=>sum+r.timing_column_count,0),timing_aggregation:timingMode(source),overall_rate:hasBytes?compressed/original:null,original_bytes:original,compressed_bytes:compressed,coverage:new Set(source.map(r=>r.dataset)).size,totalDatasets,source});
   }
   const s=state();
   return addRankingMetrics(rows,parseWeights($('weights').value)).filter(r=>(s.family==='all'||r.family===s.family)&&(!s.search||(s.mode==='family'?r.family:`${r.method} ${r.family}`).toLowerCase().includes(s.search))&&(!s.complete||r.coverage===totalDatasets)).sort((a,b)=>{
@@ -78,7 +85,7 @@ function renderTable() {
 function refresh() {
   if(!snapshot)return;
   $('precision').disabled=$('dtype').value!=='float';
-  const selectedDataset=state().dataset,selectedHasMeasurements=selectedDataset==='all'||records.some(r=>r.dataset===selectedDataset),columnCoverageNote='Compress and Decompress times are arithmetic means of each measured column’s ns/point; every column has equal weight. Column coverage may differ by method. Historical aggregate-only timings are not reported as column means.';
+  const selectedDataset=state().dataset,selectedHasMeasurements=selectedDataset==='all'||records.some(r=>r.dataset===selectedDataset),columnCoverageNote='Compress and Decompress times use equal-column arithmetic means when every selected dataset has column timings. If a method has aggregate-only timings in the selection, its dataset ns/point values are averaged with equal weight per dataset. Timing basis is shown in method details and CSV. Column coverage may differ by method.';
   if(!selectedHasMeasurements) {
     $('results-note').textContent=`No published measurements are available for this catalog dataset. It is excluded from rankings rather than treated as zero. ${columnCoverageNote}`;
   } else if(scopeKey()==='float'&&!records.some(r=>r.scope==='float')) {
@@ -115,7 +122,7 @@ function showMethod(method,focus=false) {
   if(!row){selectedMethod=null;detail.hidden=true;return;}selectedMethod=method;
   const meta=methods.get(method)??methods.get(row.source[0].configuration), pipeline=meta?.operator_pipeline;
   const source=row.source.slice().sort((a,b)=>a.dataset.localeCompare(b.dataset));
-  detail.innerHTML=`<div class="detail-head"><div><h2 id="detail-title">${escape(method)}</h2><p class="muted">${escape(row.family)} · ${escape(runtimeName(row.runtime))} · ${row.coverage} measured datasets</p></div><button id="close-detail" class="quiet-button">Close details</button></div><div class="detail-grid"><div><strong>${fmt(row.compression_rate,4)}</strong><span>average compression rate</span></div><div><strong>${fmt(row.compression_time,2)}</strong><span>Compress ns/point</span></div><div><strong>${fmt(row.decompression_time,2)}</strong><span>Decompress ns/point</span></div><div><strong>${row.coverage} / ${row.totalDatasets}</strong><span>dataset coverage</span></div></div>${pipeline?`<p class="source-code">Interpretive operator mapping: ${escape(typeof pipeline==='string'?pipeline:JSON.stringify(pipeline))}</p>`:''}<p class="muted">Dataset metrics below come from the published result files. Measurement boundaries, source hashes, and available verification evidence are recorded in the manifest.</p><div class="detail-table"><table><thead><tr><th>Dataset</th><th>Configuration</th><th>Rate ↓</th><th>Compress ns/point ↓</th><th>Decompress ns/point ↓</th><th>Original bytes</th><th>Compressed bytes</th><th>Dataset score ↓</th><th>Dataset Rank ↓</th><th>Rank candidates</th></tr></thead><tbody>${source.map(r=>`<tr><td>${escape(r.dataset)}</td><td>${escape(r.configuration)}</td><td class="numeric">${fmt(r.compression_rate,4)}</td><td class="numeric">${fmt(r.compression_time,2)}</td><td class="numeric">${fmt(r.decompression_time,2)}</td><td class="numeric">${fmt(r.original_bytes,0)}</td><td class="numeric">${fmt(r.compressed_bytes,0)}</td><td class="numeric">${fmt(r.dataset_score,4)}</td><td class="numeric">${fmt(r.dataset_rank,2)}</td><td class="numeric">${fmt(r.dataset_candidate_count,0)}</td></tr>`).join('')}</tbody></table></div>`;
+  detail.innerHTML=`<div class="detail-head"><div><h2 id="detail-title">${escape(method)}</h2><p class="muted">${escape(row.family)} · ${escape(runtimeName(row.runtime))} · ${row.coverage} measured datasets</p></div><button id="close-detail" class="quiet-button">Close details</button></div><div class="detail-grid"><div><strong>${fmt(row.compression_rate,4)}</strong><span>average compression rate</span></div><div><strong>${fmt(row.compression_time,2)}</strong><span>Compress ns/point</span></div><div><strong>${fmt(row.decompression_time,2)}</strong><span>Decompress ns/point</span></div><div><strong>${row.coverage} / ${row.totalDatasets}</strong><span>dataset coverage</span></div></div>${pipeline?`<p class="source-code">Interpretive operator mapping: ${escape(typeof pipeline==='string'?pipeline:JSON.stringify(pipeline))}</p>`:''}<p class="muted">Timing average: ${escape(timingLabel(row.timing_aggregation))}. Dataset metrics below come from the published result files. Measurement boundaries, source hashes, and available verification evidence are recorded in the manifest.</p><div class="detail-table"><table><thead><tr><th>Dataset</th><th>Configuration</th><th>Rate ↓</th><th>Compress ns/point ↓</th><th>Decompress ns/point ↓</th><th>Timing basis</th><th>Original bytes</th><th>Compressed bytes</th><th>Dataset score ↓</th><th>Dataset Rank ↓</th><th>Rank candidates</th></tr></thead><tbody>${source.map(r=>`<tr><td>${escape(r.dataset)}</td><td>${escape(r.configuration)}</td><td class="numeric">${fmt(r.compression_rate,4)}</td><td class="numeric">${fmt(r.compression_time,2)}</td><td class="numeric">${fmt(r.decompression_time,2)}</td><td>${escape(timingLabel(r.timing_aggregation))}</td><td class="numeric">${fmt(r.original_bytes,0)}</td><td class="numeric">${fmt(r.compressed_bytes,0)}</td><td class="numeric">${fmt(r.dataset_score,4)}</td><td class="numeric">${fmt(r.dataset_rank,2)}</td><td class="numeric">${fmt(r.dataset_candidate_count,0)}</td></tr>`).join('')}</tbody></table></div>`;
   detail.hidden=false;$('close-detail').addEventListener('click',()=>{detail.hidden=true;selectedMethod=null;});
   if(focus){detail.scrollIntoView({block:'nearest',behavior:'auto'});detail.focus({preventScroll:true});}
 }
@@ -139,7 +146,7 @@ function csv() {
   const quote=v=>{let text=String(v??'');if(typeof v==='string'&&/^[=+@-]/.test(text))text="'"+text;return `"${text.replace(/"/g,'""')}"`;};
   const weights=parseWeights($('weights').value);
   const columns=['position','method','runtime','scope','row_mode','selected_dataset','sort_metric','sort_direction','average_compression_rate','overall_compression_rate','compress_ns_per_point','decompress_ns_per_point','weight_a','weight_b','weight_c','normalized_compress','normalized_decompress','composite_score','average_rank','rank_dataset_coverage','normalization_reference_rows','compress_min','compress_max','decompress_min','decompress_max','normalization','rank_definition','dataset_coverage','datasets_in_scope','selected_configuration_by_dataset','timing_column_count','timing_aggregation'];
-  const body=currentRows.map((r,i)=>[i+1,r.method,r.runtime,scopeKey(),state().mode,state().dataset,sort.key,sort.direction===1?'ascending':'descending',r.compression_rate,r.overall_rate,r.compression_time,r.decompression_time,...weights.map(w=>w.toFixed(1)),r.normalized_compression_time,r.normalized_decompression_time,r.composite_score,r.average_rank,r.rank_coverage,r.normalization_reference_rows,r.encode_min,r.encode_max,r.decode_min,r.decode_max,'min-max over all measured rows in selected runtime/scope/row-mode before search and visibility filters','mean per-dataset composite-score fractional rank; per-dataset min-max times',r.coverage,r.totalDatasets,JSON.stringify(Object.fromEntries(r.source.map(s=>[s.dataset,s.configuration]))),r.timing_column_count,'arithmetic mean of per-column ns/point; equal weight per measured column'].map(quote).join(','));
+  const body=currentRows.map((r,i)=>[i+1,r.method,r.runtime,scopeKey(),state().mode,state().dataset,sort.key,sort.direction===1?'ascending':'descending',r.compression_rate,r.overall_rate,r.compression_time,r.decompression_time,...weights.map(w=>w.toFixed(1)),r.normalized_compression_time,r.normalized_decompression_time,r.composite_score,r.average_rank,r.rank_coverage,r.normalization_reference_rows,r.encode_min,r.encode_max,r.decode_min,r.decode_max,'min-max over all measured rows in selected runtime/scope/row-mode before search and visibility filters','mean per-dataset composite-score fractional rank; per-dataset min-max times',r.coverage,r.totalDatasets,JSON.stringify(Object.fromEntries(r.source.map(s=>[s.dataset,s.configuration]))),r.timing_column_count,r.timing_aggregation].map(quote).join(','));
   const url=URL.createObjectURL(new Blob(['\ufeff'+[columns.join(','),...body].join('\r\n')],{type:'text/csv;charset=utf-8'}));const a=document.createElement('a');a.href=url;a.download=`THULab-compression-${state().runtime}-${scopeKey()}-${state().dataset}.csv`;a.click();setTimeout(()=>URL.revokeObjectURL(url),1000);
 }
 function safeHttpUrl(value) {
@@ -281,7 +288,7 @@ function renderAbout() {
   $('provenance').innerHTML=`<table class="provenance-table"><tbody>${Object.entries(info).map(([k,v])=>`<tr><th>${escape(k)}</th><td class="source-code">${escape(v)}</td></tr>`).join('')}</tbody></table>${exclusions.length?`<h3>Excluded or unavailable results</h3><p class="source-code">${escape(typeof exclusions==='string'?exclusions:JSON.stringify(exclusions))}</p>`:''}`;
 }
 function init() {
-  if(snapshot.compact_records){const t=snapshot.record_tables;snapshot.dataset_results=snapshot.compact_records.map(r=>({dataset:t.datasets[r[0]],scope:t.scopes[r[1]],runtime:t.runtimes[r[2]],family:t.families[r[3]],method:t.configurations[r[4]],algorithm_variant:t.configurations[r[4]],compression_rate:r[5],compression_time_ns_per_point:r[6],decompression_time_ns_per_point:r[7],original_size_bytes:r[8],compressed_size_bytes:r[9],timing_column_count:r[10]}));delete snapshot.compact_records;}
+  if(snapshot.compact_records){const t=snapshot.record_tables;snapshot.dataset_results=snapshot.compact_records.map(r=>({dataset:t.datasets[r[0]],scope:t.scopes[r[1]],runtime:t.runtimes[r[2]],family:t.families[r[3]],method:t.configurations[r[4]],algorithm_variant:t.configurations[r[4]],compression_rate:r[5],compression_time_ns_per_point:r[6],decompression_time_ns_per_point:r[7],original_size_bytes:r[8],compressed_size_bytes:r[9],timing_column_count:r[10],timing_aggregation:t.timing_aggregations[r[11]]}));delete snapshot.compact_records;}
   for(const m of snapshot.methods||[]) { const method=typeof m==='string'?{name:m}:m;methods.set(method.name??method.method,method);for(const c of method.configurations||[])methods.set(c.algorithm_variant,{...method,name:c.algorithm_variant,family:method.name}); }
   for(const d of snapshot.datasets||[])datasets.set(d.key??d.dataset,d);
   records=(snapshot.dataset_results||snapshot.records||[]).map(normalizeRecord).filter(r=>r.method&&r.dataset&&r.compression_rate>0);
@@ -313,5 +320,5 @@ function setupTheme() {
 setupTheme();
 void loadReferenceCatalog();
 void loadDatasetCatalog();
-try { const response=await fetch('./ui-data.json?v=20261009-column-mean-v1',{cache:'no-cache'});if(!response.ok)throw new Error(`Snapshot request returned ${response.status}`);snapshot=await response.json();init(); }
+try { const response=await fetch('./ui-data.json?v=20261009-dataset-fallback-v1',{cache:'no-cache'});if(!response.ok)throw new Error(`Snapshot request returned ${response.status}`);snapshot=await response.json();init(); }
 catch(e){$('load-error').hidden=false;$('load-error').textContent=`The result snapshot could not be loaded. Please reload the page or download the JSON from the repository. ${e.message}`;$('snapshot').textContent='Snapshot unavailable';$('leaderboard').querySelector('tbody').innerHTML='<tr><td class="empty-cell">Results unavailable.</td></tr>';}

apply_dataset_scope.py

@@ -93,6 +93,18 @@ def apply() -> None:
                     runtime_configuration_count=len({(r["runtime"], r["method"]) for r in rows}),
                     source_report_file_count=len(source["result_csv_files_used"]), paper_leaderboard_row_count=0,
                     excluded_datasets=sorted(excluded | set(coverage.get("excluded_datasets", []))))
+    coverage.update(
+        timing_column_observation_count=sum(r.get("timing_column_count", 0) for r in rows),
+        timing_column_mean_dataset_result_count=sum(
+            r.get("timing_aggregation") == "column_mean" for r in rows
+        ),
+        timing_dataset_aggregate_result_count=sum(
+            r.get("timing_aggregation") == "dataset_aggregate" for r in rows
+        ),
+        timing_unavailable_dataset_result_count=sum(
+            r.get("timing_aggregation") == "unavailable" for r in rows
+        ),
+    )
     data["dataset_summary"] = {**catalog["summary"], "published_measurement_dataset_count": len(measured)}
     data_path.write_text(json.dumps(data, ensure_ascii=False, indent=2, sort_keys=True, allow_nan=False) + "\n")
     manifest_path = ROOT / "manifest.json"

build_ui_payload.py

@@ -14,13 +14,15 @@ def build() -> None:
     fields = {'datasets': 'dataset', 'scopes': 'scope', 'runtimes': 'runtime',
               'families': 'family', 'configurations': 'algorithm_variant'}
     tables = {key: sorted({r[field] for r in rows}) for key, field in fields.items()}
+    tables['timing_aggregations'] = sorted({r['timing_aggregation'] for r in rows})
     indices = {key: {v:i for i,v in enumerate(values)} for key,values in tables.items()}
     compact = []
     for r in rows:
         compact.append([*(indices[key][r[field]] for key,field in fields.items()),
                         r['compression_rate'], r['compression_time_ns_per_point'],
                         r['decompression_time_ns_per_point'], r['original_size_bytes'],
-                        r['compressed_size_bytes'], r.get('timing_column_count', 0)])
+                        r['compressed_size_bytes'], r.get('timing_column_count', 0),
+                        indices['timing_aggregations'][r['timing_aggregation']]])
     payload = {key: data[key] for key in ('schema_version','benchmark','coverage','datasets','methods','scopes','source')}
     if 'dataset_summary' in data:
         payload['dataset_summary'] = data['dataset_summary']

data.json

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:099f735c91c5ef4dff2b15ea2851caa6edd16f304f0063bfe6de948f475b4ba7
-size 37791099
+oid sha256:727bf6a91dbb2bc8f63dd87122b8dc1db261589e4da742f28f0e52dad0616571
+size 41080819

export_results.py

@@ -74,6 +74,52 @@ def _finite(value: Any, *, positive: bool = False) -> float:
     return number
 
 
+def _timing_stats_from_report(rows: Any) -> dict[str, Any]:
+    """Return a column mean or an explicit whole-dataset fallback."""
+    import pandas as pd
+
+    if rows is None or rows.empty:
+        return {"compression": None, "decompression": None, "column_count": 0,
+                "aggregation": "unavailable"}
+    work = rows.copy()
+    if work.get("_timing_source_type") is None:
+        work["_timing_source_type"] = "single_report"
+    column_groups = []
+    aggregate_groups = []
+    for source_type, source_rows in work.groupby("_timing_source_type", sort=True):
+        columns = source_rows[pd.to_numeric(source_rows["column_index"], errors="coerce") >= 0]
+        if not columns.empty:
+            grouped = columns.groupby("column_index", as_index=False).agg(
+                originalSize=("originalSize", "sum"),
+                compressionTime=("compressionTime", "sum"),
+                decompressionTime=("decompressionTime", "sum"),
+            )
+            grouped["_timing_source_type"] = source_type
+            column_groups.append(grouped)
+        else:
+            aggregate = source_rows[pd.to_numeric(source_rows["column_index"], errors="coerce") < 0]
+            if not aggregate.empty:
+                aggregate_groups.append(aggregate)
+    if column_groups and not aggregate_groups:
+        grouped = pd.concat(column_groups, ignore_index=True)
+        points = grouped["originalSize"] / 8.0
+        return {"compression": float((grouped["compressionTime"] / points).mean()),
+                "decompression": float((grouped["decompressionTime"] / points).mean()),
+                "column_count": int(len(grouped)), "aggregation": "column_mean"}
+    elapsed_parts = [*column_groups, *aggregate_groups]
+    if elapsed_parts:
+        # Use real columns for a typed report when present; use its -1 aggregate
+        # only when that typed report lacks column rows, avoiding double count.
+        elapsed = pd.concat(elapsed_parts, ignore_index=True)
+        points = float(elapsed["originalSize"].sum() / 8.0)
+        if points > 0:
+            return {"compression": float(elapsed["compressionTime"].sum()) / points,
+                    "decompression": float(elapsed["decompressionTime"].sum()) / points,
+                    "column_count": 0, "aggregation": "dataset_aggregate"}
+    return {"compression": None, "decompression": None, "column_count": 0,
+            "aggregation": "unavailable"}
+
+
 @lru_cache(maxsize=None)
 def _algorithm_metadata(algorithm_key: str) -> tuple[bool, str | None, bool]:
     from myapp.home_leaderboard_boxplot_data import (
@@ -233,31 +279,9 @@ def _configuration_rows(
         compressed_bytes = _finite(record.compressedSize, positive=True)
         points = original_bytes / 8.0
         timing_rows = work[
-            (work["algorithm"].astype(str) == str(record.algorithm))
-            & (pd.to_numeric(work["column_index"], errors="coerce") >= 0)
+            work["algorithm"].astype(str) == str(record.algorithm)
         ].copy()
-        timing_column_count = len(timing_rows)
-        if timing_column_count:
-            timing_columns = timing_rows.groupby(
-                ["_timing_source_type", "column_index"], as_index=False
-            ).agg(
-                originalSize=("originalSize", "sum"),
-                compressionTime=("compressionTime", "sum"),
-                decompressionTime=("decompressionTime", "sum"),
-            )
-            timing_column_count = len(timing_columns)
-            timing_points = timing_columns["originalSize"] / 8.0
-            compression_time_ns_per_point = float(
-                (timing_columns["compressionTime"] / timing_points).mean()
-            )
-            decompression_time_ns_per_point = float(
-                (timing_columns["decompressionTime"] / timing_points).mean()
-            )
-        else:
-            # A column_index=-1 row is a whole-report aggregate. It cannot prove
-            # the requested arithmetic mean of individual column timings.
-            compression_time_ns_per_point = None
-            decompression_time_ns_per_point = None
+        timing = _timing_stats_from_report(timing_rows)
         rows.append(
             {
                 "dataset": dataset_key,
@@ -273,9 +297,10 @@ def _configuration_rows(
                 "compression_time_ns": _finite(record.compressionTime),
                 "decompression_time_ns": _finite(record.decompressionTime),
                 "compression_rate": compressed_bytes / original_bytes,
-                "compression_time_ns_per_point": compression_time_ns_per_point,
-                "decompression_time_ns_per_point": decompression_time_ns_per_point,
-                "timing_column_count": timing_column_count,
+                "compression_time_ns_per_point": timing["compression"],
+                "decompression_time_ns_per_point": timing["decompression"],
+                "timing_column_count": timing["column_count"],
+                "timing_aggregation": timing["aggregation"],
             }
         )
     return sorted(rows, key=lambda row: (row["method"], row["algorithm_variant"]))
@@ -357,24 +382,32 @@ def _aggregate_rows(
     elapsed_point_sum = sum(row["point_count"] for row in elapsed_rows)
     comp_time_sum = sum(row["compression_time_ns"] for row in elapsed_rows)
     decomp_time_sum = sum(row["decompression_time_ns"] for row in elapsed_rows)
-    timing_rows = [
-        row for row in rows
-        if row.get("timing_column_count", 0) > 0
-        and row.get("compression_time_ns_per_point") is not None
+    elapsed_complete = len(elapsed_rows) == len(rows)
+    timing_column_count = sum(row.get("timing_column_count", 0) for row in rows)
+    modes = [row.get("timing_aggregation", "unavailable") for row in rows]
+    valid_times = all(
+        row.get("compression_time_ns_per_point") is not None
         and row.get("decompression_time_ns_per_point") is not None
-    ]
-    timing_column_count = sum(row["timing_column_count"] for row in timing_rows)
-    timing_complete = len(timing_rows) == len(rows)
-    average_compression_time = (
-        sum(row["compression_time_ns_per_point"] * row["timing_column_count"] for row in timing_rows)
-        / timing_column_count
-        if timing_column_count and timing_complete else None
-    )
-    average_decompression_time = (
-        sum(row["decompression_time_ns_per_point"] * row["timing_column_count"] for row in timing_rows)
-        / timing_column_count
-        if timing_column_count and timing_complete else None
+        for row in rows
     )
+    if not valid_times or "unavailable" in modes:
+        average_compression_time = average_decompression_time = None
+        timing_aggregation = "unavailable"
+    elif "dataset_aggregate" in modes:
+        average_compression_time = sum(row["compression_time_ns_per_point"] for row in rows) / len(rows)
+        average_decompression_time = sum(row["decompression_time_ns_per_point"] for row in rows) / len(rows)
+        timing_aggregation = "dataset_mean"
+    elif timing_column_count:
+        average_compression_time = sum(
+            row["compression_time_ns_per_point"] * row["timing_column_count"] for row in rows
+        ) / timing_column_count
+        average_decompression_time = sum(
+            row["decompression_time_ns_per_point"] * row["timing_column_count"] for row in rows
+        ) / timing_column_count
+        timing_aggregation = "column_mean"
+    else:
+        average_compression_time = average_decompression_time = None
+        timing_aggregation = "unavailable"
     return {
         "runtime": runtime,
         "scope": scope_key,
@@ -385,14 +418,16 @@ def _aggregate_rows(
         "overall_compression_rate": compressed_sum / original_sum,
         "average_compression_rate": sum(row["compression_rate"] for row in rows) / len(rows),
         "weighted_compression_time_ns_per_point": (
-            comp_time_sum / elapsed_point_sum if elapsed_point_sum else None
+            comp_time_sum / elapsed_point_sum if elapsed_point_sum and elapsed_complete else None
         ),
         "average_compression_time_ns_per_point": average_compression_time,
         "weighted_decompression_time_ns_per_point": (
-            decomp_time_sum / elapsed_point_sum if elapsed_point_sum else None
+            decomp_time_sum / elapsed_point_sum if elapsed_point_sum and elapsed_complete else None
         ),
         "average_decompression_time_ns_per_point": average_decompression_time,
         "timing_column_count": timing_column_count,
+        "timing_aggregation": timing_aggregation,
+        "timing_dataset_count": len(rows),
         "original_size_bytes": original_sum,
         "compressed_size_bytes": compressed_sum,
         "point_count": point_sum,
@@ -527,7 +562,7 @@ def main() -> int:
             "current_result_selection": "visible configurations of methods categorized as lossless-design by the project; result-level float round trips are not established",
             "paper_result_selection": "the separate paper_table3 section contains its frozen 20-method C++ snapshot",
             "scope_note": "Current result rows cover numeric int/float report evidence for the retained 19 public datasets. They reflect the columns present in each report; they do not assert full-column coverage beyond those files.",
-            "aggregation_note": "Compression and decompression time averages are arithmetic means of available per-column nanoseconds per point. Dataset rows without column-level timing evidence are unavailable for timing; any aggregate containing one of these rows also has unavailable timing and is excluded from timing-based scores. Overall compression rate and weighted times use summed measured bytes, points, and nanoseconds only.",
+            "aggregation_note": "Dataset rows with column evidence use an arithmetic mean of per-column nanoseconds per point. Rows backed only by whole-report timing use source dataset elapsed time divided by source point totals and retain a zero column count. If any selected row uses that fallback, method timing is an equal-dataset arithmetic mean; otherwise it is pooled equally over measured columns.",
             "selection_note": "Configuration views retain measured configurations passing the project's method-name filter. This does not certify every result as lossless. Family views choose the lowest-rate configuration independently for each dataset, scope, and runtime.",
             "notes": [
                 "Missing combinations are unavailable rather than zero.",
@@ -538,7 +573,7 @@ def main() -> int:
                 "compression_rate": "compressed bytes divided by original numeric bytes; lower is better",
                 "average_compression_rate": "arithmetic mean of per-dataset compression rates",
                 "overall_compression_rate": "sum of compressed bytes divided by sum of original numeric bytes",
-                "average_time_ns_per_point": "arithmetic mean of per-column nanoseconds per numeric point; legacy CSV columns retain their 8-byte-equivalent point denominator",
+                "average_time_ns_per_point": "column-backed rows use an arithmetic mean of per-column nanoseconds per numeric point; whole-report-only rows use source elapsed nanoseconds divided by source point totals; legacy CSV rows retain their 8-byte-equivalent point denominator",
                 "weighted_time_ns_per_point": "sum of measured nanoseconds divided by sum of 8-byte numeric points",
                 "paper_median_balanced_score": "stored paper snapshot value; normalization is paper-scope specific and lower is better",
             },
@@ -547,6 +582,7 @@ def main() -> int:
                 "No round-trip verification claim is exported from timing/result CSVs alone.",
                 "Family-level aggregates select the measured variant with the lowest compression rate within each dataset and method family, matching the backend family-selection rule.",
                 "dataset_results contains every visible measured configuration; is_best_rate_in_family marks the configuration used for family-level aggregation.",
+                "Whole-report timing rows (column_index=-1) remain dataset-level timing evidence with timing_column_count=0; they are never treated as columns.",
                 "Paper Table 3 values and current report recomputations are separate result sets because the report tree has evolved since the paper snapshot was frozen.",
             ],
         },
@@ -570,6 +606,16 @@ def main() -> int:
             "configuration_aggregate_row_count": len(configuration_aggregates),
             "family_best_aggregate_row_count": len(family_best_aggregates),
             "dataset_result_row_count": len(dataset_rows),
+            "timing_column_observation_count": sum(row["timing_column_count"] for row in dataset_rows),
+            "timing_column_mean_dataset_result_count": sum(
+                row["timing_aggregation"] == "column_mean" for row in dataset_rows
+            ),
+            "timing_dataset_aggregate_result_count": sum(
+                row["timing_aggregation"] == "dataset_aggregate" for row in dataset_rows
+            ),
+            "timing_unavailable_dataset_result_count": sum(
+                row["timing_aggregation"] == "unavailable" for row in dataset_rows
+            ),
             "source_report_file_count": len(report_files),
             "missing_source_report_count": missing_report_count,
             "excluded_datasets": dataset_scope["meta"].get("excluded_dataset_keys", []),

index.html

@@ -7,7 +7,7 @@
   <meta name="color-scheme" content="light dark">
   <title>THULab | Time Series Compression Benchmark</title>
   <link rel="stylesheet" href="style.css?v=20261009-dbp-integrated-v1">
-  <script src="app.js?v=20261009-column-mean-v1" type="module"></script>
+  <script src="app.js?v=20261009-dataset-fallback-v1" type="module"></script>
 </head>
 <body>
   <a class="skip-link" href="#content">Skip to results</a>
@@ -62,7 +62,7 @@
         <div><h2 id="view-title">Overall leaderboard</h2><p id="selection-summary" class="muted" aria-live="polite">Reading published results…</p></div>
         <div class="toolbar-actions"><button id="reset" class="quiet-button">Reset filters</button><button id="download" class="primary-button" disabled>Download CSV</button></div>
       </div>
-      <div class="results-note" id="results-note">Compression rate = compressed bytes / original bytes. Lower rates and lower ns/point are better. Compression and decompression costs are the arithmetic mean of the measured columns' ns/point values; column coverage may differ. Historical aggregate-only timings without per-column evidence are not inferred.</div>
+      <div class="results-note" id="results-note">Compression rate = compressed bytes / original bytes. Lower rates and lower ns/point are better. Compression and decompression costs use equal-column arithmetic means where column timings are available. Methods with aggregate-only timings use equal-dataset arithmetic means for the selected range.</div>
       <div id="score-controls" class="score-controls">
         <label>Score weights · a: rate / b: compress / c: decompress<select id="weights" aria-label="Score weights a b c"></select></label>
         <p id="score-note" class="muted" aria-live="polite">Non-negative weights in steps of 0.1, summing to 1.0.</p>
@@ -108,7 +108,7 @@
       <dl class="definitions">
         <div><dt>Average compression rate ↓</dt><dd>Arithmetic mean of the per-dataset compression rates in the selected scope.</dd></div>
         <div><dt>Overall compression rate ↓</dt><dd>Total compressed bytes divided by total original bytes over the selected measured records.</dd></div>
-        <div><dt>Compression / decompression cost ↓</dt><dd>For each result with column-level timing evidence, calculate ns/point independently for every usable numeric column, then take the arithmetic mean across those columns. Each column contributes equally. Overall timing pools all measured columns across the selected datasets; if any selected dataset/configuration lacks column-level timing evidence, that timing is Not reported. Historical aggregate-only timing rows without recoverable per-column values are not inferred. Native-float measurements use valid native values; historical imported rows retain their source 8-byte-equivalent point definition. Compare timings within the same runtime and measurement contract.</dd></div>
+        <div><dt>Compression / decompression cost ↓</dt><dd>For each result with column-level timing evidence, calculate ns/point independently for every usable numeric column, then take the arithmetic mean across those columns. Each column contributes equally. Overall timing pools all measured columns across the selected datasets when every selected dataset has column timings. If any selected dataset/configuration has only aggregate timing, use the arithmetic mean of the selected datasets' ns/point values instead, giving each dataset equal weight. For an aggregate-only dataset, ns/point comes from its recorded total elapsed time divided by its recorded point count. Truly missing measurements remain unavailable. Method details and CSV identify the timing basis. Native-float measurements use valid native values; historical imported rows retain their source 8-byte-equivalent point definition. Compare timings within the same runtime and measurement contract.</dd></div>
         <div><dt>Coverage</dt><dd>Datasets with usable measurements for a method out of the measured datasets in the selected runtime, data type, and dataset selection. The summary dataset count uses the same selection. Missing results are never filled with zero.</dd></div>
         <div><dt>Composite score ↓</dt><dd>a × average compression rate + b × normalized average compression time + c × normalized average decompression time. Each time uses min–max over all measured rows in the selected runtime, scope and row mode, before search, family and coverage filters. If all times are equal, their normalized value is zero. All measured inputs must have usable timing metrics.</dd></div>
         <div><dt>Average Rank ↓</dt><dd>Compute the same weighted score within each dataset, normalizing times within that dataset. Rank lower scores first; ties share their average position. Then take the arithmetic mean of the method's available dataset ranks. Weights are non-negative tenths summing to 1.0. Missing measurements do not receive ranks.</dd></div>

manifest.json

@@ -3,7 +3,7 @@
     "catalog_dataset_count": 169,
     "configuration_aggregate_row_count": 4653,
     "dataset_count": 169,
-    "dataset_result_row_count": 65219,
+    "dataset_result_row_count": 65223,
     "excluded_datasets": [
       "Arade",
       "poisson_timestamps",
@@ -26,12 +26,13 @@
     ],
     "scope_count": 5,
     "source_report_file_count": 108,
-    "timing_column_mean_dataset_result_count": 64879,
-    "timing_column_observation_count": 1435539,
-    "timing_unavailable_dataset_result_count": 340
+    "timing_column_mean_dataset_result_count": 64771,
+    "timing_column_observation_count": 1435347,
+    "timing_dataset_aggregate_result_count": 452,
+    "timing_unavailable_dataset_result_count": 0
   },
   "data_file": "data.json",
-  "data_sha256": "099f735c91c5ef4dff2b15ea2851caa6edd16f304f0063bfe6de948f475b4ba7",
+  "data_sha256": "727bf6a91dbb2bc8f63dd87122b8dc1db261589e4da742f28f0e52dad0616571",
   "dataset_catalog_sha256": "d69abc85742dc050e4cdab1e5a03fd3392a0e0f1964b2a88ca87ba7f768b7385",
   "excluded_content": [
     "raw datasets",
@@ -207,6 +208,64 @@
       "source_scope_sha256": "0fabc01f25d62ddb49585b3208103543b16c6e50340195360a0516411fa148b4",
       "source_sha256": "febe0d4494cf3778bb3e386ac8674f24406e29d1d7d9b47bd834b332b0e201fb",
       "verified_column_count_per_runtime": 4096
+    },
+    {
+      "benchmark_contract": {
+        "block_state": "reset for every frozen logical block",
+        "codec": "project delta + ZigZag + ULEB128 int64 wire",
+        "column_count": 1,
+        "cpu_affinity": [
+          37
+        ],
+        "governor": "schedutil",
+        "logical_blocks": 10,
+        "method": "DELTA_BINARY_PACKED",
+        "repetitions": 1,
+        "shared_server": true,
+        "timing": "encode and decode timed per block; block nanoseconds summed",
+        "timing_aggregation": "column_mean",
+        "warmup": "first min(20, logical_block_count) blocks once, metrics discarded",
+        "warmup_blocks_executed": 10
+      },
+      "cross_runtime_golden": {
+        "all_runtime_compressed_size_bytes": 615712,
+        "all_runtime_decoded_i64le_sha256": "17bd25237309c72cad7b34fa255fd508c5c4b8ce79423e79438d5a8212a68c8b",
+        "all_runtime_payload_sha256": "39214295d7739f2417d73b4cc9bb8771a228268500f3dab5a03eacdf7b4aea23",
+        "historical_java_compressed_size_bytes": 615712,
+        "status": "passed"
+      },
+      "dataset": "medium_posts",
+      "environment": {
+        "cpu37_no_user_process_before_after": true,
+        "cpu37_processes_after_sha256": "7fcee621228a258ad0262e0bd4c7c3eb8f2452d685982e520a52a2b41cc01816",
+        "cpu37_processes_before_sha256": "7fcee621228a258ad0262e0bd4c7c3eb8f2452d685982e520a52a2b41cc01816",
+        "cpu_model": "AMD EPYC 7542 32-Core Processor",
+        "gxx": "g++ (Ubuntu 11.4.0-1ubuntu1~22.04.2) 11.4.0",
+        "hostname": "server",
+        "java": "openjdk version \"17.0.16\" 2025-07-15",
+        "kernel": "5.15.0-152-generic",
+        "machine": "x86_64",
+        "python": "3.10.12"
+      },
+      "family": "DBP",
+      "integrated_at": "2026-10-09T07:25:05.180457+00:00",
+      "integration_payload_path": "analysis_outputs/column_mean_20261009/dbp_medium_posts_retest/integration_payload.json",
+      "integration_payload_sha256": "e45170a955d1cd0df50dba25f9e41f24f00fc8b559e702d59188b6cfa60c99dc",
+      "measurement_receipt_path": "analysis_outputs/column_mean_20261009/dbp_medium_posts_retest/measurement_receipt.json",
+      "method": "DELTA_BINARY_PACKED",
+      "runtimes": [
+        "cpp",
+        "java",
+        "python"
+      ],
+      "scopes": [
+        "integer",
+        "overall"
+      ],
+      "source_sha256": "10359f6f1153655710f7ce9b59d04e5460babe5606487b7794a47ba874ef4324",
+      "timing_aggregation": "column_mean",
+      "timing_column_count_per_row": 1,
+      "validation_status": "passed_byte_for_byte_lossless"
     }
   ],
   "result_csv_files": [
@@ -767,14 +826,15 @@
     }
   ],
   "timing_recalculation": {
-    "aggregate_only_rows_excluded_from_timing": 340,
+    "aggregate_only_dataset_fallback_row_count": 452,
     "dbp_float_audit_path": "analysis_outputs/dbp_float_e2e_20261009/publish_payload/dbp-audit.json",
     "dbp_float_audit_sha256": "febe0d4494cf3778bb3e386ac8674f24406e29d1d7d9b47bd834b332b0e201fb",
     "dbp_precision_source_file_count": 376,
     "dbp_precision_source_hash_status": "all_match",
-    "generated_at": "2026-10-09T06:52:14.348090+00:00",
-    "policy": "arithmetic_mean_of_per_column_ns_per_point",
+    "generated_at": "2026-10-09T07:25:05.180457+00:00",
+    "policy": "column_mean_with_dataset_aggregate_fallback",
     "result_csv_file_count": 108,
-    "result_csv_sha256_status": "all_match"
+    "result_csv_sha256_status": "all_match",
+    "timing_unavailable_row_count": 0
   }
 }