README.md

---
license: cc-by-4.0
language:
  - en
tags:
  - finance
  - forecasting
  - calibration
  - time-series
  - cryptocurrency
pretty_name: NeuPortal Sealed Crypto Forecasts
size_categories:
  - n<1K
---

# NeuPortal Sealed Crypto Forecasts

Interval forecasts for eight crypto pairs, each **hashed with SHA-256 and anchored to the Bitcoin
blockchain via OpenTimestamps before publication**, scored afterwards against Binance closes.

The forecasts are not the interesting part. Anyone can produce forecasts. The interesting part is
that every row carries a hash that existed before the outcome did, so a reader can check that the
numbers were not selected after the fact - and that the misses are in the file, including a
calibration failure large enough that we would rather it were not.

## What is in here

Two files.

`neuportal-sealed-forecasts.csv` - 144 forecasts, 56 resolved, sealed between 2026-07-20 and
2026-07-29. Unresolved rows are deliberately included: a file in which every forecast has an outcome
is the shape a curated record takes.

Figures below are the state at **2026-07-29**. They move as forecasts resolve, and they will not
match an older copy of this card. The live scoreboard at https://neuportal.ai/experiment is the
current one; when the two disagree, the scoreboard is right and this card is stale.

| column | meaning |
|---|---|
| `symbol` | Binance pair (BTC, ETH, SOL, BNB, XRP, DOGE, ADA, LINK against USDT) |
| `horizon` | `24h`, `7d` or `30d` |
| `sealed_at` | UTC timestamp at which the forecast was hashed, before publication |
| `resolves_at` | UTC timestamp the forecast resolves against |
| `spot` | price at sealing |
| `median` | central estimate |
| `core_lo`, `core_hi` | stated **50%** interval |
| `wide_lo`, `wide_hi` | stated **80%** interval |
| `stance` | LONG / SHORT / NEUTRAL momentum lean at sealing |
| `sha256` | hash of the sealed forecast object |
| `method` | `unconditional`, `conditional` (volatility-regime matched), or `unattested` - see below. Present so the claim about which rows predate the calibration fix can be checked rather than believed |
| `status` | `final` (resolved) or `upcoming` |
| `outcome` | realised price at `resolves_at`, empty if unresolved |
| `in_core`, `in_wide` | 1 if the outcome fell inside that interval |
| `err_pct` | signed percentage error of the median |

## The headline result, which is a failure

Coverage on the resolved forecasts:

| horizon | n | core (target 50%) | wide (target 80%) |
|---|---|---|---|
| 24h | 44 | **81.8%** (36 of 44) | **97.7%** (43 of 44) |
| 7d | 12 | **91.7%** (11 of 12) | **100%** (12 of 12) |
| 30d | 0 | - | - |
| **all horizons** | **56** | **83.9%** (47 of 56) | **98.2%** (55 of 56) |

The all-horizons row is the figure shown on the public scoreboard, and the per-horizon rows are what
it decomposes into. Both are given because quoting whichever is worse-looking on a given day, without
the other, is a way of telling the truth selectively.

Under an honest 50% interval, P(>=36 of 44 inside) is about 1.3e-05, and P(>=11 of 12) about 3.2e-03.
These intervals were far too wide.

**Over-coverage is a failure in the same way under-coverage is.** An interval that contains almost
every outcome cannot be shown to be wrong, and a claim that cannot be wrong carries no information.
It also produces no symptoms: outcomes keep landing inside, and nothing prompts an investigation.

Sample sizes are small (44 resolved 24h rows, 12 at 7d, none yet at 30d) and the eight pairs move
together, so the effective number of independent observations is smaller still. Treat every number
here as provisional. The 24h result is nonetheless far outside what sampling noise explains.

## Diagnosis, including the hypothesis that was wrong

The obvious explanation - that the intervals were built from too much old, volatile history - was
tested and rejected. Walk-forward across 20,058 observations on the same eight pairs, rebuilding the
interval for each historical date from prior data only:

| sample | core (target 50%) | wide (target 80%) |
|---|---|---|
| unconditional, all days | 55.6% | 85.3% |
| unconditional, calmest 20% of days | **67.1%** | 92.1% |
| conditional, all days | 50.8% | 79.6% |
| conditional, calmest 20% | 52.4% | 79.1% |

The distortion is mild on average and severe in quiet markets, because an unconditional interval
carries a permanent allowance for turbulence that a calm regime has not earned. The live sample sat
entirely in a calm stretch.

The remedy is conditioning, not truncation: keep only historical windows whose volatility **at the
window's open** was within a tolerance of current volatility. Measuring at the close would select
windows partly on what happened inside them, leaking the outcome into the sample.

One result kept because it is inconvenient: at a 30-day horizon the conditional interval comes out
**wider** than the unconditional one (31.8% vs 23.7%), since calm periods have historically preceded
larger monthly moves. A recalibration that only ever tightens is indistinguishable from tuning
toward a flattering answer.

## The anchors, and how to check them without trusting us

`neuportal-bitcoin-anchors.csv` - 310 Bitcoin attestations across 85 sealed documents, blocks 956500
to 960111. One row per attestation, with the document's SHA-256, the block height, that block's merkle
root and its UTC time. A proof usually carries several attestations because the OpenTimestamps
calendars are independent and confirm in different blocks; `is_earliest = 1` marks the binding one,
which is the tightest upper bound on when the document existed.

Checked on 2026-07-29 against a public block explorer: **all 310 merkle roots match**, zero
discrepancies. Every one of the 144 forecasts has an anchor. Median time from sealing to Bitcoin
confirmation is 28 minutes, worst case 58 minutes, and **no forecast was confirmed into a block later
than its own resolution time** - which is the property that would have made the timestamps decorative.

## What the hashes do and do not prove

They prove the bytes existed before the block that contains them. They say nothing about whether the
forecast was any good - that is what the coverage column is for.

The anchors file has a narrower limit that is worth stating plainly, because it is the first thing a
careful reader will probe. OpenTimestamps aggregates thousands of hashes into one merkle tree and only
the root reaches the chain. So the block height and root in that file prove *a block with this root
existed at this time*; they do **not** on their own prove *our hash sits under that root*. The path
from a document to the root lives in the `.ots` file, and checking it needs the OTS client:

```
ots verify crypto-2026-07-20T232952Z-BTCUSDT.json.ots
```

Anyone building on the anchors table should keep that distinction. A query over block data can confirm
the timing half of the claim and nothing more.

Rows sealed before 2026-07-28 use the **unconditional** method described above; the `method` column
says which is which, so this is checkable rather than merely asserted. They were not re-sealed after
the fix. Re-signing predictions after improving the method is the retroactive editing that makes most
published track records meaningless; the record has to be allowed to contain the period before the fix.

As of 2026-07-29 **every resolved row is still `unconditional`**. The engine fix landed at
2026-07-28 12:03 UTC; the most recent resolved forecasts were sealed that morning at 08:48 UTC, four
hours earlier. So the coverage above measures the broken method, and none of it is evidence that the
fix worked. The corrected forecasts will be scored as a separate series rather than blended into the
numbers above, so that they can fail visibly against the frozen baseline.

### The `unattested` rows, and why they are not quietly relabelled

Twelve rows carry `method = unattested`. They were sealed after the engine fix but before a second
bug was found: the engine computed a `conditional` flag for every band and the sealing step, which
copies a hand-maintained list of fields into the object that gets hashed, silently dropped it. So for
those twelve the sealed object - the only artefact with a timestamp - does not record which method
produced it.

We know from the commit history which code was running, and for most symbols it was the conditional
path. We are not writing that into the file anyway. A method label reconstructed from what we
remember deploying is exactly the kind of after-the-fact annotation the hashing exists to prevent,
and it would be wrong for at least one symbol: conditioning falls back to the unconditional sample
when too few historical windows match the current regime, which happens per-symbol and is not
recoverable from the commit log. These rows are therefore scored in neither series.

From 2026-07-30 the flag is carried inside the sealed object and attested by its timestamp.

## Suggested uses

- Calibration benchmarking: a small, honestly-labelled set where the published intervals are known to
  be miscalibrated in a specific direction.
- Teaching material for coverage as a two-sided metric.
- A template for provenance: hash-before-publish, score-after, publish the misses.

## Limitations

Short history, small resolved counts, and eight correlated crypto pairs - these are not independent
instruments. The 30d horizon has no resolved rows at all yet. Not investment advice, and not a
signal service.

Educational content - not financial advice.