# TARIFF-16 - the injection leg of a dynamic contract (`price_export_formula`)

**Status: SHIPPED.** Tests: `test_price.py` (17 series). Written down by
MAINT-20 from `app/custom_formula.py` and `app/price.py`. Follows [[TARIFF-15]],
whose parser it reuses.

## Why a formula, not the scalar

`price.py` modelled injection as one scalar. The market publishes a line a
scalar cannot hold:

    Eneco Zon & Wind Dynamisch   0,1 x BELPEX-H - 1,188   c EUR/kWh
    ENGIE Dynamic                (B x eSpot_15) - A
    Aspiravi (non-dynamic)       0,07 x Belpex - 2

1. Its own factor (Eneco 0,102 on consumption, 0,100 on injection; Aspiravi 0,07
   against about 0,10): not the consumption `B` with a sign flip.
2. A negative offset (`- 1,188`, `- 2`); `price_markup_eur_kwh: float(0,1)`
   cannot express one.
3. VAT-exempt ("Injectietarieven zijn vrijgesteld van btw") against 6 % on
   consumption: representable only because `vat_pct` is per spec.
4. It goes negative with no floor: Eneco's is below zero for any BELPEX-H under
   11,88 EUR/MWh, the hours a PV household exports in. You can be charged to
   export.

`price_export_formula` is `custom_formula`'s parser with one argument moved
(`option`, a row of `_LEGS`), as TARIFF-17 did for `parse_static_profile()`. A
second parser would be a second `_finite()`, unknown-key rule, unit table and
`to_resolution()`, diverging first on the 23- and 25-hour days. Every earlier
call site passes no `option` and reads byte-identical sentences. The flat scalar
`export_price_eur_kwh()` is untouched and still answers when the option is "".

## What it does not affect

`arbitrage.py` does not read the injection price at all (9.3: near-zero Belgian
injection; it prices the sell side as displaced import), so no trade today turns
on this number and it is not a wrong-trade fix. It changes what an operator is
told and what a future export-aware strategy (OPT-06) rests on.

## The card cannot always grade it

Eneco's injection formula is printed with no price beside it. The `card` block
is required on the consumption leg and optional here (`FormulaSpec.card_graded`
is how callers ask; `card_discrepancy()` raises on an ungraded spec rather than
returning 0.0). The self-check runs wherever a printed estimate exists, and
validate.py says at startup that a leg is ungraded. Inventing an estimate would
grade the arithmetic against itself (MUTATION.md habit 4).

## `implausible_injection()`: bounds on the coefficients, not the price

The consumption band (`implausible_all_in()`) cannot be reused: it adds
`price_taxes_eur_kwh`, a consumption component, and its floor `energy >= 0.02`
would refuse the real market's negative hours. But that floor catches a whole
card read 100x too small, which the card check cannot see (it cancels). A band
spanning zero cannot catch 0.00132 EUR/kWh, so the bound moves onto the
coefficients, index-free and sign-free:

- pass-through `factor x UNITS[units] / 0.001` (one EUR/MWh is 0.001 EUR/kWh):
  1.00 for Eneco's injection leg, 0.70 for Aspiravi's; 100x off reads 0.01 or 100;
- offset magnitude, on the absolute value (1,188 c = 0.01188; a hundredfold error
  is 1.188 EUR/kWh).

Two rungs can both answer one stimulus, so they are graded on their reasons and
mutated together (MUTATION.md, TEST-16); test_price.py 17d builds fixtures so
each is the only one firing. It bounds the shape of the coefficients, never
their truth.

## The consumption band's asymmetry (`implausible_all_in()`)

The low end is graded on the energy component and the high end on the all-in
figure. `price_taxes_eur_kwh` ships at 0.11736 (TARIFF-18; 0.06 before), nearly
six times the low bound, so a card read 100x too small (0.0016 EUR/kWh) is
carried over the floor by the flat tax addend alone and would pass a band applied
to the all-in total. Raising the default made the trap wider. The ceiling is on
the all-in figure because that is what the site is billed. It grades the card's
own point, not every hour: live EPEX hours may fall outside (a negative hour is
the best charging opportunity of the year, 17 keeps a regression case). It is
called from validate.py only, since it reads the framework-owned taxes number.

## Smaller rules

- `CARD_TOLERANCE` is 0.01 in the card's units, the last digit both real cards
  print (Eneco 15,55 against 15.5471; ENGIE 7,522 against 7.5218). Every error
  class it exists for is at least two orders of magnitude bigger.
- The card age warning (about 6 months) is never a refusal: ENGIE freezes a
  contract's coefficients, so an old card can be exactly right.
- `units` is required with no default (a default is the factor-1000 class).
  A zero factor is a fixed tariff in a dynamic one's clothes (every spread 0,
  arbitrage never fires; 14's warning box), so the operator is pointed at the
  first-class way to say one price. A negative factor inverts the market (charge
  into the evening peak). `vat_pct: 0` is legitimate (injection is exempt; some
  cards are quoted VAT-inclusive); the bound exists for the 106 / 1.06 / 6
  confusion. An unknown key is refused, not ignored, so a user who types "expr"
  is not priced on the fields they also typed. A non-finite factor would make
  every price NaN; `True` is an `int` and would price the day at the index.
- `to_resolution()`: the bucket is a UTC hour, exact for Belgium (CET and CEST
  are whole-hour offsets, so keying by UTC cannot collide the two 02:00s). It
  decides how many points are emitted, not how long one covers ([[TARIFF-14]]). An
  incomplete hour is averaged over what is there, not dropped or zero-filled.
- The startup preview prints the index that went in beside the price that came
  out (`61.96 -> 0.13522`): every error this module refuses is invisible on the
  status page, and a factor of 1000 is one glance there.