XQBTS Whitepaper

XQBTS Terminal is implemented as a Next.js application backed by Firebase Firestore and Cloud Functions. Its core model ingests benchmark-family feeds and a platform index, filters those results through an explicit curation policy, normalizes admitted production signals onto a 0-100 scale, and publishes two derived global outputs: a Q-Day readiness document and a global HNDL pressure document.

The system also operates a watchlist layer. That layer maintains a registry of tracked quantum-relevant companies, refreshes market snapshots from Finnhub, matches company news from GNews, and exposes those public feeds to the terminal UI. The watchlist layer is not used by the core Q-Day or HNDL computations. The core model functions are built from curated frontier signals and methodology documents only.

1. ingest benchmark.latest.json + platforms index
2. filter source records through methodology rules
3. select one best candidate per required production signal
4. normalize admitted production signals
5. derive readiness and threat outputs
6. publish current docs and append history
7. render public documents in the terminal

The platform uses four normalization modes for production signals and one passthrough mode for diagnostics. Every normalization result is clamped to the 0-100 range. Weighted averages ignore missing inputs and renormalize by the total weight of the remaining usable inputs.

log-upper(value, reference)
= clampPercent(log10(1 + value) / log10(1 + reference) * 100)

inverse-log(value, worst, best)
= clampPercent((log10(worst) - log10(value)) / (log10(worst) - log10(best)) * 100)

linear(value, lower, upper)
= clampPercent((value - lower) / (upper - lower) * 100)

inverse-linear(value, worst, best)
= clampPercent((worst - value) / (worst - best) * 100)

weightedAverage(values)
= sum(score * weight) / sum(weight) over usable entries only

The Q-Day model requires an AQ signal; when direct AQ is missing, the ingestion layer may synthesize an AQ proxy from benchmark coverage before publishing. Utility frontier and fault-tolerance bridge are each computed from normalized scores, then combined with the raw AQ metric value to produce current_sota_lq. The code describes that field as an effective logical-qubit proxy derived from AQ frontier and curated fault-tolerance bridge metrics.

utility_frontier_percent
= weightedAverage([
  aq.normalizedScore * 0.7,
  quantumVolume.normalizedScore * 0.3,
])

fault_tolerance_bridge_percent
= weightedAverage([
  logicalErrorRate.normalizedScore * 0.35,
  surfaceCode.normalizedScore * 0.30,
  faultTolerantQecLogicalErrorRate.normalizedScore * 0.35,
])

current_sota_lq
= round(
    aq.metricValue
  * (0.5 + 1.5 * (fault_tolerance_bridge_percent / 100))
  * (0.8 + 0.2 * (utility_frontier_percent / 100))
)

years_to_qday(current_sota_lq, required_lq, growth_factor)
= 0, if current_sota_lq >= required_lq
= ln(required_lq / current_sota_lq) / ln(growth_factor), otherwise

The HNDL model consumes the same admitted production frontier signals and a separate risk methodology document. It builds five usable frontier axes plus one explicitly unavailable axis for cryptanalytic relevance. The model then computes a frontier readiness core and scales it by the assumed share of encrypted traffic that is not yet post-quantum protected.

harvestableShare
= encryptedTrafficShare * (1 - pqProtectedShare)

cryptanalyticReadinessCore
= weightedAverage([
  utilityFrontier.value * 0.1,
  hardwareScale.value * 0.1,
  gateQuality.value * 0.15,
  runtimePracticality.value * 0.2,
  faultTolerance.value * 0.45,
])

hndlPressure
= clampPercent(harvestableShare * cryptanalyticReadinessCore)

hndlStatus
= CRITICAL if hndlPressure >= 60
= HIGH if hndlPressure >= 35
= MEDIUM if hndlPressure >= 15
= LOW otherwise

article_score
= +5 exact company name match
+ +3 simplified company name match
+ +4 ticker regex match
+ +3 searchTerm match
+ +1 for each token match

accepted_article if article_score >= 3
matchStrength = "fallback" if queryStrategy == "fallback" or topMatchScore < 6

Firestore rules explicitly allow public reads on the current global documents, histories, companies, market snapshots, and news feed. All writes are denied from the client side. A catch-all deny rule blocks any document path not explicitly opened for public reads.

Within those boundaries, the platform is technically coherent as an operational framework: it exposes its inputs, encodes a curation policy, versions its methodology, records exclusions, publishes history, marks stale states, and cleanly separates the core frontier model from its watchlist surfaces.