Trace — 2607.19283v1

$ /bin/bash -lc 'ls -la && rg -n "(?i)main theorem|theorem [0-9]|conjecture|parity|ENO|TV" paper.txt | head -200'
total 836
drwxr-xr-x  6 root root   4096 Jul 23 13:48 .
drwxr-xr-x 20 root root   4096 Jul 23 13:46 ..
dr-xr-xr-x  2 root root     40 Jul 23 13:48 .agents
dr-xr-xr-x  2 root root     40 Jul 23 13:48 .codex
drwxr-xr-x  7 root root   4096 Jul 23 13:47 .git
-rw-r--r--  1 root root   3630 Jul 23 13:46 PROMPT.txt
-rw-r--r--  1 root root   1013 Jul 23 13:48 codex-events.jsonl
-rw-r--r--  1 root root   6197 Jul 23 13:48 codex.err
-rw-r--r--  1 root root   2399 Jul 23 13:46 paper.json
-rw-r--r--  1 root root 661374 Jul 23 13:46 paper.pdf
-rw-r--r--  1 root root 155474 Jul 23 13:46 paper.txt
drwxr-xr-x 17 root root   4096 Jul 23 13:46 repro
1:RESOLUTION OF THE ENO–TV CONJECTURE:
2:A PARITY DICHOTOMY
7:Abstract. We resolve the ENO–TV conjecture, a discrete coercivity
10:(ENO) reconstruction from compactly supported cell averages, it asks
11:whether the nonnegative ENO source times the (k − 1)st power of the
13:prove a parity dichotomy: the estimate holds for odd k ≥ 3 and fails
16:uniformly comparable to the source and reduces the conjecture to discrete
21:making all affected ENO comparisons strict. We also prove two coercive
43:ENO reconstruction and a localized source identity
67:7. ENO–TV coercivity on nonuniform meshes
102:therefore recover, at the discrete level, enough quantitative control either to
111:natural candidate for this control is supplied by classical essentially nonoscillatory (ENO) reconstruction, introduced by Harten, Engquist, Osher,
114:RESOLUTION OF THE ENO–TV CONJECTURE
121:jumps ai := (Dū)i ; the ENO procedure of order k constructs in each cell
136:at every interface. Summing these products yields the ENO source
144:which is therefore nonnegative. The ENO–TV conjecture [6] asserts that this
154:Despite the historical name ENO–TV, the left-hand side is a superlinear
160:In this paper, we resolve the conjecture (1.4) and prove a parity dichotomy
164:The conjecture (1.4) remained difficult for the same reason that ENO is
166:At each stage, ENO compares

$ /bin/bash -lc "sed -n '105,380p' paper.txt && sed -n '706,1360p' paper.txt && sed -n '1480,1840p' paper.txt"
The discrete question is the passage from entropy stability to quantitative
coercivity. The convergence framework of Fjordholm, Käppeli, Mishra,
and Tadmor [7] makes this requirement concrete: among its compactness
inputs is a weak BV estimate controlling jumps between neighboring cell
averages. A discrete entropy inequality supplies the sign of the dissipation,
whereas the weak BV estimate requires quantitative control of its size. A
natural candidate for this control is supplied by classical essentially nonoscillatory (ENO) reconstruction, introduced by Harten, Engquist, Osher,
and Chakravarthy [11] in 1987 to retain any prescribed order of accuracy

RESOLUTION OF THE ENO–TV CONJECTURE

3

on smooth data while suppressing spurious oscillations near shocks. On
the unit grid xi+1/2 = i + 1/2, let ū = (ūi )i∈Z be a compactly supported
sequence of cell averages, with forward difference (Db)i := bi+1 − bi and
jumps ai := (Dū)i ; the ENO procedure of order k constructs in each cell
(k)
a polynomial pi of degree at most k − 1. Its relevance to the coercivity
problem rests on a sign property proved by Fjordholm, Mishra, and Tadmor
(k)
(k)
(k)
(FMT) [9]: writing ∆pi+1/2 := pi+1 (xi+1/2 ) − pi (xi+1/2 ) for the jump of the
reconstructed traces,
(k)

ai ∆pi+1/2 ≥ 0

(1.2)

at every interface. Summing these products yields the ENO source
X
(k)
(1.3)
Qk (ū) :=
ai ∆pi+1/2 ,
i∈Z

which is therefore nonnegative. The ENO–TV conjecture [6] asserts that this
sign-definite source is quantitatively coercive: for each fixed k ≥ 2, there is a
constant Ck such that every compactly supported sequence of cell averages
satisfies
X
(1.4)
|ai |k+1 ≤ Ck ∥ū∥k−1
ℓ∞ Qk (ū).
i∈Z

Despite the historical name ENO–TV, the left-hand side is a superlinear
moment of the cell-average jumps rather than the total variation itself. The
amplitude factor is forced by homogeneity: the left-hand side has degree
k + 1 in the data, whereas Qk has degree two. Prior to the present work, the
estimate was kno

$ /bin/bash -lc "sed -n '1350,1535p' paper.txt && sed -n '1835,2650p' paper.txt && find . -name AGENTS.md -print && git -C repro status --short && sed -n '1,160p' repro/lakefile.toml && rg -n \"Gagliardo|B.?spline|ENO|Finsupp.*difference|Nat.*Even\" repro/Mathlib | head -100"
sed: can't read repro/lakefile.toml: No such file or directory

$ /bin/bash -lc "ls -la repro | head -60 && find repro -maxdepth 2 -type f \\( -name 'lakefile.*' -o -name 'lean-toolchain' \\) -print && git -C repro status --short && rg -n \"Gagliardo|B.?spline|ENO\" repro/Mathlib | head -100"
total 596
drwxr-xr-x 17 root root   4096 Jul 23 13:46 .
drwxr-xr-x  6 root root   4096 Jul 23 13:48 ..
drwxr-xr-x  2 root root   4096 Jul 23 13:46 .devcontainer
drwxr-xr-x  5 root root   4096 Jul 23 13:46 .docker
drwxr-xr-x  8 root root   4096 Jul 23 13:48 .git
-rw-r--r--  1 root root    401 Jul 23 13:46 .git-blame-ignore-revs
drwxr-xr-x  4 root root   4096 Jul 23 13:46 .github
-rw-r--r--  1 root root    440 Jul 23 13:46 .gitignore
-rw-r--r--  1 root root    155 Jul 23 13:46 .gitpod.yml
drwxr-xr-x  5 root root   4096 Jul 23 13:46 .lake
-rw-r--r--  1 root root    419 Jul 23 13:46 .pre-commit-config.yaml
drwxr-xr-x  2 root root   4096 Jul 23 13:46 .vscode
drwxr-xr-x  7 root root   4096 Jul 23 13:46 Archive
-rw-r--r--  1 root root   2901 Jul 23 13:46 Archive.lean
-rw-r--r--  1 root root    677 Jul 23 13:46 CITATION.md
-rw-r--r--  1 root root   5319 Jul 23 13:46 CODE_OF_CONDUCT.md
drwxr-xr-x  2 root root   4096 Jul 23 13:46 Cache
drwxr-xr-x  2 root root   4096 Jul 23 13:46 Counterexamples
-rw-r--r--  1 root root   1261 Jul 23 13:46 Counterexamples.lean
drwxr-xr-x  2 root root   4096 Jul 23 13:46 DownstreamTest
-rw-r--r--  1 root root  11357 Jul 23 13:46 LICENSE
drwxr-xr-x 33 root root   4096 Jul 23 13:46 Mathlib
-rw-r--r--  1 root root 452322 Jul 23 13:46 Mathlib.lean
drwxr-xr-x 23 root root   4096 Jul 23 13:46 MathlibTest
-rw-r--r--  1 root root   8936 Jul 23 13:46 README.md
-rw-r--r--  1 root root   1857 Jul 23 13:46 bors.toml
drwxr-xr-x  3 root root   4096 Jul 23 13:46 docs
-rw-r--r--  1 root root     53 Jul 23 13:46 docs.lean
-rw-r--r--  1 root root   2815 Jul 23 13:46 lake-manifest.json
-rw-r--r--  1 root root   6816 Jul 23 13:46 lakefile.lean
-rw-r--r--  1 root root     29 Jul 23 13:46 lean-toolchain
drwxr-xr-x  4 root root   4096 Jul 23 13:46 scripts
drwxr-xr-x  3 root root   4096 Jul 23 13:46 widget
repro/DownstreamTest/lakefile.toml
repro/lean-toolchain
repro/lakefile.lean
repro/Mathlib/Analysis/FunctionalSpaces/SobolevInequality.lean:15:# Gagliardo-Nirenberg-S

$ /bin/bash -lc "rg -n \"Gagliardo.Nirenberg|interpolation.*derivative|deriv.*norm.*norm|HasCompactSupport.*deriv|iterated.*deriv\" repro/Mathlib/Analysis | head -200 && sed -n '285,390p' repro/Mathlib/Analysis/FunctionalSpaces/SobolevInequality.lean && rg -n \"EulerPolynomial|eulerPolynomial|Euler polynomial\" repro/Mathlib | head -100"
repro/Mathlib/Analysis/Meromorphic/Basic.lean:392:@[fun_prop] theorem iterated_deriv [CompleteSpace E] {n : ℕ} {f : 𝕜 → E} {x : 𝕜}
repro/Mathlib/Analysis/Meromorphic/Basic.lean:608:theorem iterated_deriv [CompleteSpace E] {n : ℕ} : MeromorphicOn (_root_.deriv^[n] f) U :=
repro/Mathlib/Analysis/Meromorphic/Basic.lean:609:  fun z hz ↦ (hf z hz).iterated_deriv
repro/Mathlib/Analysis/Meromorphic/Basic.lean:720:lemma iterated_deriv [CompleteSpace E] {n : ℕ} (hf : Meromorphic f) :
repro/Mathlib/Analysis/Meromorphic/Basic.lean:721:    Meromorphic (deriv^[n] f) := fun x ↦ (hf x).iterated_deriv
repro/Mathlib/Analysis/Complex/Positivity.lean:13:We show that if `f` is holomorphic on an open disk `B(c,r)` and all iterated derivatives of `f`
repro/Mathlib/Analysis/Complex/Positivity.lean:17:showing `f z ≥ f c` when all iterated derivatives except `f` itself are nonnegative.
repro/Mathlib/Analysis/Complex/Positivity.lean:48:/-- An entire function whose iterated derivatives at `c` are all nonnegative real has nonnegative
repro/Mathlib/Analysis/Complex/Positivity.lean:58:/-- An entire function whose iterated derivatives at `c` are all nonnegative real (except
repro/Mathlib/Analysis/Complex/Positivity.lean:72:/-- An entire function whose iterated derivatives at `c` are all real with alternating signs
repro/Mathlib/Analysis/Analytic/Order.lean:355:lemma analyticOrderAt_iterated_deriv {𝕜 : Type*} {E : Type*} [NontriviallyNormedField 𝕜]
repro/Mathlib/Analysis/Analytic/Order.lean:369:    simpa using (analyticOrderAt_deriv_of_pos (hf := AnalyticAt.iterated_deriv hf n')
repro/Mathlib/Analysis/Analytic/Order.lean:429:  rw [natCast_le_analyticOrderAt_iff_iteratedDeriv_eq_zero hf.deriv,
repro/Mathlib/Analysis/Analytic/Order.lean:455:`n` iterated derivatives (including `f` itself) vanish at `z₀` and the `n`-th iterated derivative is
repro/Mathlib/Analysis/SpecialFunctions/Elliptic/Weierstrass.lean:831:lemma iteratedDeriv_derivWeierstrassPExcept_self (l : ℂ) {n : ℕ} :
repro/Mathlib/Analysis/Sp

$ /bin/bash -lc 'lake env lean ENOTV/Basic.lean'
ENOTV/Basic.lean:35:15: error: Application type mismatch: The argument
  Finset.range k
has type
  Finset ℕ
but is expected to have type
  Finset ℤ
in the application
  Finset.image (fun s => |a (j + s)|) (Finset.range k)
ENOTV/Basic.lean:35:61: error: unsolved goals
k : ℕ
a : Seq
j : ℤ
⊢ (sorry ()).Nonempty

$ /bin/bash -lc 'lake env lean ENOTV/Basic.lean'
ENOTV/Basic.lean:37:10: error: Type mismatch: After simplification, term
  hk
 has type
  0 < k
but is expected to have type
  ¬k = 0

$ /bin/bash -lc 'lake env lean ENOTV/Basic.lean'
ENOTV/Basic.lean:36:4: error: Type mismatch
  (Finset.image (fun s => |a (j + ↑s)|) (Finset.range k)).sup' ⋯
has type
  (ℝ → ?m.9) → ?m.9
but is expected to have type
  ℝ

$ /bin/bash -lc "cat > /tmp/Check.lean <<'EOF'
import Mathlib
#check Finset.sup'
#check Finset.max'
#check Finset.max'_mem
#check Finset.sup
#check Finset.max
#check Finset.max'
EOF
lake env lean /tmp/Check.lean"
Finset.sup'.{u_2, u_3} {α : Type u_2} {β : Type u_3} [SemilatticeSup α] (s : Finset β) (H : s.Nonempty) (f : β → α) : α
Finset.max'.{u_2} {α : Type u_2} [LinearOrder α] (s : Finset α) (H : s.Nonempty) : α
Finset.max'_mem.{u_2} {α : Type u_2} [LinearOrder α] (s : Finset α) (H : s.Nonempty) : s.max' H ∈ s
Finset.sup.{u_2, u_3} {α : Type u_2} {β : Type u_3} [SemilatticeSup α] [OrderBot α] (s : Finset β) (f : β → α) : α
Finset.max.{u_2} {α : Type u_2} [LinearOrder α] (s : Finset α) : WithBot α
Finset.max'.{u_2} {α : Type u_2} [LinearOrder α] (s : Finset α) (H : s.Nonempty) : α

$ /bin/bash -lc 'lake env lean ENOTV/Basic.lean'

$ /bin/bash -lc 'rg -n "def interpolate|interpolate.*Polynomial|Lagrange" Mathlib/Algebra Mathlib | head -150'
Mathlib/LinearAlgebra/Lagrange.lean:14:# Lagrange interpolation
Mathlib/LinearAlgebra/Lagrange.lean:20:* `Lagrange.basisDivisor x y`, with `x y : F`. These are the normalised irreducible factors of
Mathlib/LinearAlgebra/Lagrange.lean:21:  the Lagrange basis polynomials. They evaluate to `1` at `x` and `0` at `y` when `x` and `y`
Mathlib/LinearAlgebra/Lagrange.lean:23:* `Lagrange.basis v i` with `i : ι`: the Lagrange basis polynomial that evaluates to `1` at `v i`
Mathlib/LinearAlgebra/Lagrange.lean:25:* `Lagrange.interpolate v r` where `r : ι → F` is a function from the fintype to the field: the
Mathlib/LinearAlgebra/Lagrange.lean:26:  Lagrange interpolant that evaluates to `r i` at `x i` for all `i : ι`. The `r i` are the _values_
Mathlib/LinearAlgebra/Lagrange.lean:136:namespace Lagrange
Mathlib/LinearAlgebra/Lagrange.lean:146:Such polynomials are the building blocks for the Lagrange interpolants. -/
Mathlib/LinearAlgebra/Lagrange.lean:196:/-- Lagrange basis polynomials indexed by `s : Finset ι`, defined at nodes `v i` for a
Mathlib/LinearAlgebra/Lagrange.lean:203:theorem basis_empty : Lagrange.basis ∅ v i = 1 :=
Mathlib/LinearAlgebra/Lagrange.lean:207:theorem basis_singleton (i : ι) : Lagrange.basis {i} v i = 1 := by
Mathlib/LinearAlgebra/Lagrange.lean:208:  rw [Lagrange.basis, erase_singleton, prod_empty]
Mathlib/LinearAlgebra/Lagrange.lean:211:theorem basis_pair_left (hij : i ≠ j) : Lagrange.basis {i, j} v i = basisDivisor (v i) (v j) := by
Mathlib/LinearAlgebra/Lagrange.lean:212:  simp only [Lagrange.basis, hij, erase_insert_eq_erase, erase_eq_of_notMem, mem_singleton,
Mathlib/LinearAlgebra/Lagrange.lean:216:theorem basis_pair_right (hij : i ≠ j) : Lagrange.basis {i, j} v j = basisDivisor (v j) (v i) := by
Mathlib/LinearAlgebra/Lagrange.lean:220:theorem basis_ne_zero (hvs : Set.InjOn v s) (hi : i ∈ s) : Lagrange.basis s v i ≠ 0 := by
Mathlib/LinearAlgebra/Lagrange.lean:221:  simp_rw [Lagrange.basis, prod_ne_zero_iff, Ne, mem_erase]
Mathlib/LinearAlgebra/Lagran

$ /bin/bash -lc 'lake env lean ENOTV/Basic.lean'
ENOTV/Basic.lean:95:21: error(lean.unknownIdentifier): Unknown constant `Filter.eventuallyEq_zero`
ENOTV/Basic.lean:94:49: error: unsolved goals
u : Seq
⊢ (Function.support u).Finite ↔ u =ᶠ[Filter.cofinite] 0
ENOTV/Basic.lean:112:9: error(lean.unknownIdentifier): Unknown constant `Filter.tendsto_add_atTop_iff_int`
ENOTV/Basic.lean:116:6: error: Invalid rewrite argument: Expected an equality or iff proof or definition name, but `diff ?hu` is a proof of
  FiniteSupport (ENOTV.diff ?m.2)
ENOTV/Basic.lean:140:33: error: omega could not prove the goal:
No usable constraints found. You may need to unfold definitions so `omega` can see linear arithmetic facts about `Nat` and `Int`, which may also involve multiplication, division, and modular remainder by constants.
ENOTV/Basic.lean:148:18: error: omega could not prove the goal:
a possible counterexample may satisfy the constraints
  c - d ≤ 1
  c - d ≥ 1
  b - d ≤ 0
  b - d ≥ 0
  a - b ≥ 0
  a - c ≤ -1
  a - d ≤ 0
where
 a := j
 b := enoLeft u i (k - 1)
 c := enoLeft u (i + 1) (k - 1)
 d := i

$ /bin/bash -lc "rg -n \"support_add|support_neg|support.*subset.*union\" Mathlib | head -100 && nl -ba ENOTV/Basic.lean | sed -n '130,155p'"
Mathlib/Data/Finsupp/Order.lean:88:  rw [sum_of_support_subset _ Finset.subset_union_left _ hh₀,
Mathlib/Data/Finsupp/Order.lean:89:    sum_of_support_subset _ Finset.subset_union_right _ hh₀]
Mathlib/Data/Finsupp/Order.lean:305:In the case where the supports are disjoint, there is also `Finsupp.support_add_eq`,
Mathlib/Data/Finsupp/Order.lean:307:lemma support_add_eq_union {f1 f2 : ι →₀ α} [DecidableEq ι] :
Mathlib/Data/Finsupp/Order.lean:309:  le_antisymm support_add <| Finset.union_subset
Mathlib/Data/Finsupp/BigOperators.lean:18:The support of the sum is a subset of the union of the supports:
Mathlib/Data/Finsupp/BigOperators.lean:47:    exact Finsupp.support_add.trans (Finset.union_subset_union Finset.Subset.rfl IH)
Mathlib/Data/Finsupp/BigOperators.lean:88:    rw [Finsupp.support_add_eq, IH hl.right, Finset.sup_eq_union]
Mathlib/Data/Finsupp/Multiset.lean:94:    rw [toMultiset_add, Multiset.toFinset_add, ih, toMultiset_single, support_add_eq,
Mathlib/Data/Finsupp/NeLocus.lean:150:  rw [sub_eq_add_neg, neLocus_self_add_right, support_neg]
Mathlib/LinearAlgebra/Finsupp/Supported.lean:48:    refine Subset.trans (Subset.trans (Finset.coe_subset.2 support_add) ?_) (union_subset hp hq)
Mathlib/Data/DFinsupp/Defs.lean:1015:theorem support_add [∀ i, AddZeroClass (β i)] [∀ (i) (x : β i), Decidable (x ≠ 0)]
Mathlib/Data/DFinsupp/Defs.lean:1020:theorem support_neg [∀ i, AddGroup (β i)] [∀ (i) (x : β i), Decidable (x ≠ 0)] {f : Π₀ i, β i} :
Mathlib/Data/DFinsupp/BigOperators.lean:111:  rw [prod_of_support_subset Finset.subset_union_left h1,
Mathlib/Data/DFinsupp/BigOperators.lean:112:    prod_of_support_subset Finset.subset_union_right h2]
Mathlib/Data/DFinsupp/BigOperators.lean:226:      Finset.prod_subset support_add <| by
Mathlib/Data/DFinsupp/Interval.lean:120:  rw [rangeIcc_apply, notMem_support_iff.1 (notMem_mono subset_union_left h),
Mathlib/Data/DFinsupp/Interval.lean:121:    notMem_support_iff.1 (notMem_mono subset_union_right h)]
Mathlib/Data/DFinsupp/NeLocus.le

$ /bin/bash -lc 'lake env lean ENOTV/Basic.lean'
ENOTV/Basic.lean:95:21: error: Tactic `rewrite` failed: Did not find an occurrence of the pattern
  ∀ᶠ (x : ?m.9) in ?m.10, ?m.11 x
in the target expression
  (Function.support u).Finite ↔ u =ᶠ[Filter.cofinite] 0

u : Seq
⊢ (Function.support u).Finite ↔ u =ᶠ[Filter.cofinite] 0
ENOTV/Basic.lean:118:2: error: omega could not prove the goal:
a possible counterexample may satisfy the constraints
  a - b ≥ 1
where
 a := i
 b := (fun j => j - c) (i + c)
ENOTV/Basic.lean:124:2: error: Type mismatch: After simplification, term
  hi
 has type
  Not (ENOTV.diff u i = 0)
but is expected to have type
  Not (u (i + 1) + -u i = 0)

$ /bin/bash -lc 'lake env lean ENOTV/Basic.lean'
ENOTV/Basic.lean:99:10: error: Insufficient number of fields for `⟨...⟩` constructor: Constructor `Equiv.mk` has 4 explicit field, but only 3 were provided
ENOTV/Basic.lean:99:11: error: Application type mismatch: The argument
  Function.support u
has type
  Set ℤ
but is expected to have type
  ↑{x | u x = 0}ᶜ → Fin ?m.29
in the application
  (Function.support u)ᶜ
ENOTV/Basic.lean:99:49: error(lean.unknownIdentifier): Unknown constant `Set.compl_compl`
ENOTV/Basic.lean:99:37: error: Tactic `assumption` failed

u : Seq
h : (Function.support u).Finite
⊢ Fin ?m.29 → ↑{x | u x = 0}ᶜ
ENOTV/Basic.lean:102:15: error(lean.invalidField): Invalid field `subset`: The environment does not contain `Function.subset`, so it is not possible to project the field `subset` from an expression
  hs
of type `Fin n✝ → ↑{x | u x = 0}ᶜ`
ENOTV/Basic.lean:103:10: error: No goals to be solved
ENOTV/Basic.lean:125:2: error: Type mismatch: After simplification, term
  hi
 has type
  Not (ENOTV.diff u i = 0)
but is expected to have type
  Not (u (i + 1) + -u i = 0)

$ /bin/bash -lc "cat >/tmp/Check.lean <<'EOF'
import Mathlib
#check Filter.eventually_iff
#check Filter.mem_cofinite
#check Set.Finite.compl_mem_cofinite
#check Filter.mem_cofinite_iff
#check Filter.eventually_cofinite
#check Filter.eventuallyEq_iff_exists_mem
#check Filter.EventuallyEq
#check Set.compl_compl
#check Set.compl_compl_iff
EOF
lake env lean /tmp/Check.lean"
Filter.eventually_iff.{u} {α : Type u} {f : Filter α} {P : α → Prop} : (∀ᶠ (x : α) in f, P x) ↔ {x | P x} ∈ f
Filter.mem_cofinite.{u_2} {α : Type u_2} {s : Set α} : s ∈ Filter.cofinite ↔ sᶜ.Finite
Set.Finite.compl_mem_cofinite.{u_2} {α : Type u_2} {s : Set α} (hs : s.Finite) : sᶜ ∈ Filter.cofinite
/tmp/Check.lean:5:7: error(lean.unknownIdentifier): Unknown constant `Filter.mem_cofinite_iff`
Filter.eventually_cofinite.{u_2} {α : Type u_2} {p : α → Prop} :
  (∀ᶠ (x : α) in Filter.cofinite, p x) ↔ {x | ¬p x}.Finite
Filter.eventuallyEq_iff_exists_mem.{u, v} {α : Type u} {β : Type v} {l : Filter α} {f g : α → β} :
  f =ᶠ[l] g ↔ ∃ s ∈ l, Set.EqOn f g s
Filter.EventuallyEq.{u_1, u_2} {α : Type u_1} {β : Type u_2} (l : Filter α) (f g : α → β) : Prop
/tmp/Check.lean:9:7: error(lean.unknownIdentifier): Unknown constant `Set.compl_compl`
/tmp/Check.lean:10:7: error(lean.unknownIdentifier): Unknown constant `Set.compl_compl_iff`

$ /bin/bash -lc 'lake env lean ENOTV/Basic.lean'

$ /bin/bash -lc "python3 - <<'PY'
import numpy as np, math, random

def D(a,n):
    b=dict(a)
    for _ in range(n):
        keys=range(min(b)-1,max(b)+1)
        b={i:b.get(i+1,0)-b.get(i,0) for i in keys}
    return b

def val(a,i): return a.get(i,0.)

def left(u,i,k):
    a={j:val(u,j+1)-val(u,j) for j in range(min(u)-k-3,max(u)+k+3)}
    qs=[a]
    for ell in range(1,k-1):
        prev=qs[-1]; qs.append({j:val(prev,j+1)-val(prev,j) for j in range(min(prev)-1,max(prev)+1)})
    r=i
    for ell in range(k-1):
        q=qs[ell]
        if abs(val(q,r-1)) < abs(val(q,r)): r-=1
    return r

def cum(u,n): return sum(v for j,v in u.items() if j<=n)

def trace(u,i,k):
    r=left(u,i,k)
    # V at boundary r+q-1/2 = cumulative thru r+q-1
    xs=np.array([r+q-.5 for q in range(k+1)],float)
    ys=np.array([cum(u,r+q-1) for q in range(k+1)],float)
    coef=np.polyfit(xs,ys,k)
    der=np.polyder(coef)
    return np.polyval(der,i+.5)

def locjump(u,i,k):
    a={j:val(u,j+1)-val(u,j) for j in range(min(u)-k-3,max(u)+k+3)}
    q=a
    for _ in range(k-1):
        q={j:val(q,j+1)-val(q,j) for j in range(min(q)-1,max(q)+1)}
    ri,rip=left(u,i,k),left(u,i+1,k)
    z=0
    for j in range(ri,rip):
        d=i-j
        gam=(-1)**(k-1-d)*math.factorial(d)*math.factorial(k-1-d)/math.factorial(k)
        z+=gam*val(q,j)
    return z
for k in range(2,9):
  worst=0; signok=True
  for t in range(100):
    u={i:random.uniform(-2,2) for i in range(-4,5)}
    for i in range(-7,8):
      x=trace(u,i+1,k)-trace(u,i,k)
      y=locjump(u,i,k)
      worst=max(worst,abs(x-y))
      a=val(u,i+1)-val(u,i)
      signok &= a*x>=-1e-7
  print(k,worst,signok)
PY"
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ModuleNotFoundError: No module named 'numpy'

$ /bin/bash -lc "python3 - <<'PY'
try:
 import sympy; print('sympy yes')
except Exception as e: print(e)
PY"
No module named 'sympy'

$ /bin/bash -lc "python3 - <<'PY'
from fractions import Fraction as F
import math, random

def val(a,i): return a.get(i,F(0))
def left(u,i,k):
    lo,hi=min(u)-2*k-3,max(u)+2*k+3
    a={j:val(u,j+1)-val(u,j) for j in range(lo,hi)}
    qs=[a]
    for ell in range(1,k-1):
        prev=qs[-1]; qs.append({j:val(prev,j+1)-val(prev,j) for j in range(lo,hi-ell)})
    r=i
    for ell in range(k-1):
        q=qs[ell]
        if abs(val(q,r-1)) < abs(val(q,r)): r-=1
    return r

def cum(u,n): return sum((v for j,v in u.items() if j<=n),F(0))
def lagrange_deriv(xs,ys,x):
    total=F(0)
    for q,(xq,yq) in enumerate(zip(xs,ys)):
      denom=F(1)
      for p,xp in enumerate(xs):
        if p"'!=q: denom*=xq-xp
      numder=F(0)
      for omit in range(len(xs)):
        if omit==q: continue
        prod=F(1)
        for p,xp in enumerate(xs):
          if p!=q and p!=omit: prod*=x-xp
        numder+=prod
      total+=yq*numder/denom
    return total

def trace(u,i,k):
    r=left(u,i,k)
    xs=[F(2*(r+q)-1,2) for q in range(k+1)]
    ys=[cum(u,r+q-1) for q in range(k+1)]
    return lagrange_deriv(xs,ys,F(2*i+1,2))
def locjump(u,i,k):
    lo,hi=min(u)-2*k-3,max(u)+2*k+3
    q={j:val(u,j+1)-val(u,j) for j in range(lo,hi)}
    for _ in range(k-1): q={j:val(q,j+1)-val(q,j) for j in range(lo,hi-1)}
    ri,rip=left(u,i,k),left(u,i+1,k)
    z=F(0)
    for j in range(ri,rip):
        d=i-j
        gam=F((-1)**(k-1-d)*math.factorial(d)*math.factorial(k-1-d),math.factorial(k))
        z+=gam*val(q,j)
    return z
for k in range(2,9):
  worst=F(0); signok=True
  for t in range(30):
    u={i:F(random.randint(-5,5)) for i in range(-4,5)}
    for i in range(-7,8):
      x=trace(u,i+1,k)-trace(u,i,k)
      y=locjump(u,i,k)
      worst=max(worst,abs(x-y))
      a=val(u,i+1)-val(u,i)
      signok &= a*x>=0
  print(k,worst,signok)
PY'
2 9 True
3 16 False
4 29 False
5 73/2 False
6 497/12 False
7 2179/30 False
8 16441/105 False

$ /bin/bash -lc "python3 - <<'PY'
from fractions import Fraction as F
import math, random

def val(a,i): return a.get(i,F(0))
def left(u,i,k):
 lo,hi=min(u)-2*k-3,max(u)+2*k+3
 q={j:val(u,j+1)-val(u,j) for j in range(lo,hi)}; qs=[q]
 for ell in range(1,k-1):
  q={j:val(q,j+1)-val(q,j) for j in range(lo,hi-ell)}; qs.append(q)
 r=i
 for ell in range(k-1):
  if abs(val(qs[ell],r-1))<abs(val(qs[ell],r)):r-=1
 return r
def cum(u,n):return sum((v for j,v in u.items() if j<=n),F())
def ld(xs,ys,x):
 z=F()
 for q,xq in enumerate(xs):
  den=F(1)
  for p,xp in enumerate(xs):
   if p"'!=q:den*=xq-xp
  nd=F()
  for o in range(len(xs)):
   if o==q:continue
   pr=F(1)
   for p,xp in enumerate(xs):
    if p!=q and p!=o:pr*=x-xp
   nd+=pr
  z+=ys[q]*nd/den
 return z
def trace(u,cell,iface,k):
 r=left(u,cell,k); xs=[F(2*(r+q)-1,2) for q in range(k+1)]; ys=[cum(u,r+q-1) for q in range(k+1)]
 return ld(xs,ys,F(2*iface+1,2))
def loc(u,i,k):
 lo,hi=min(u)-2*k-3,max(u)+2*k+3
 q={j:val(u,j+1)-val(u,j) for j in range(lo,hi)}
 for _ in range(k-1):q={j:val(q,j+1)-val(q,j) for j in range(lo,hi-1)}
 z=F()
 for j in range(left(u,i,k),left(u,i+1,k)):
  d=i-j;z+=F((-1)**(k-1-d)*math.factorial(d)*math.factorial(k-1-d),math.factorial(k))*val(q,j)
 return z
for k in range(2,9):
 worst=F();ok=True
 for _ in range(30):
  u={i:F(random.randint(-5,5)) for i in range(-4,5)}
  for i in range(-7,8):
   x=trace(u,i+1,i,k)-trace(u,i,i,k); y=loc(u,i,k);worst=max(worst,abs(x-y));ok&=(val(u,i+1)-val(u,i))*x>=0
 print(k,worst,ok)
PY'
2 0 True
3 0 True
4 0 True
5 0 True
6 0 True
7 0 True
8 0 True

$ /bin/bash -lc "cat >/tmp/Check.lean <<'EOF'
import Mathlib
#check Finsupp.equivCongrLeft
#check Finsupp.domCongr
#check Equiv.addRight
#check Equiv.addLeft
#check Finsupp.lsum
#check Finsupp.sum
#check Finsupp.sum_add_index
#check Finsupp.sum_sub_index
#check Finsupp.sum_equiv
#check Finsupp.support_equivCongrLeft
#check Equiv.sum_comp
EOF
lake env lean /tmp/Check.lean"
Finsupp.equivCongrLeft.{u_1, u_2, u_5} {α : Type u_1} {β : Type u_2} {M : Type u_5} [Zero M] (f : α ≃ β) :
  (α →₀ M) ≃ (β →₀ M)
Finsupp.domCongr.{u_1, u_2, u_5} {α : Type u_1} {β : Type u_2} {M : Type u_5} [AddCommMonoid M] (e : α ≃ β) :
  (α →₀ M) ≃+ (β →₀ M)
Equiv.addRight.{u_5} {G : Type u_5} [AddGroup G] (a : G) : Equiv.Perm G
Equiv.addLeft.{u_5} {G : Type u_5} [AddGroup G] (a : G) : Equiv.Perm G
Finsupp.lsum.{u_1, u_2, u_3, u_5, u_6, u_8} {α : Type u_1} {M : Type u_2} {N : Type u_3} {R : Type u_5} {R₂ : Type u_6}
  (S : Type u_8) [Semiring R] [Semiring R₂] [Semiring S] [AddCommMonoid M] [Module R M] [AddCommMonoid N] [Module R₂ N]
  {σ : R →+* R₂} [Module S N] [SMulCommClass R₂ S N] : (α → M →ₛₗ[σ] N) ≃ₗ[S] (α →₀ M) →ₛₗ[σ] N
Finsupp.sum.{u_1, u_8, u_10} {α : Type u_1} {M : Type u_8} {N : Type u_10} [Zero M] [AddCommMonoid N] (f : α →₀ M)
  (g : α → M → N) : N
Finsupp.sum_add_index.{u_1, u_8, u_10} {α : Type u_1} {M : Type u_8} {N : Type u_10} [DecidableEq α] [AddZeroClass M]
  [AddCommMonoid N] {f g : α →₀ M} {h : α → M → N} (h_zero : ∀ a ∈ f.support ∪ g.support, h a 0 = 0)
  (h_add : ∀ a ∈ f.support ∪ g.support, ∀ (b₁ b₂ : M), h a (b₁ + b₂) = h a b₁ + h a b₂) :
  (f + g).sum h = f.sum h + g.sum h
Finsupp.sum_sub_index.{u_1, u_3, u_7} {α : Type u_1} {γ : Type u_3} {β : Type u_7} [AddGroup β] [AddCommGroup γ]
  {f g : α →₀ β} {h : α → β → γ} (h_sub : ∀ (a : α) (b₁ b₂ : β), h a (b₁ - b₂) = h a b₁ - h a b₂) :
  (f - g).sum h = f.sum h - g.sum h
/tmp/Check.lean:10:7: error(lean.unknownIdentifier): Unknown constant `Finsupp.sum_equiv`
/tmp/Check.lean:11:7: error(lean.unknownIdentifier): Unknown constant `Finsupp.support_equivCongrLeft`
Equiv.sum_comp.{u_1, u_2, u_3} {ι : Type u_1} {κ : Type u_2} {M : Type u_3} [Fintype ι] [Fintype κ] [AddCommMonoid M]
  (e : ι ≃ κ) (g : κ → M) : ∑ i, g (e i) = ∑ i, g i

$ /bin/bash -lc 'lake env lean ENOTV/Compact.lean'
ENOTV/Compact.lean:1:0: error: unknown module prefix 'ENOTV'

No directory 'ENOTV' or file 'ENOTV.olean' in the search path entries:
/work/repro/.lake/packages/Cli/.lake/build/lib/lean
/work/repro/.lake/packages/batteries/.lake/build/lib/lean
/work/repro/.lake/packages/Qq/.lake/build/lib/lean
/work/repro/.lake/packages/aesop/.lake/build/lib/lean
/work/repro/.lake/packages/proofwidgets/.lake/build/lib/lean
/work/repro/.lake/packages/importGraph/.lake/build/lib/lean
/work/repro/.lake/packages/LeanSearchClient/.lake/build/lib/lean
/work/repro/.lake/packages/plausible/.lake/build/lib/lean
/work/repro/.lake/build/lib/lean
/opt/elan/toolchains/leanprover--lean4---v4.33.0-rc1/lib/lean
/opt/elan/toolchains/leanprover--lean4---v4.33.0-rc1/lib/lean

$ /bin/bash -lc "sed -n '1,100p' lakefile.lean && sed -n '100,220p' lakefile.lean"
import Lake

open Lake DSL

/-!
## Mathlib dependencies on upstream projects
-/

require "leanprover-community" / "batteries" @ git "main"
require "leanprover-community" / "Qq" @ git "master"

require "leanprover-community" / "aesop" @ git "master"
require "leanprover-community" / "proofwidgets" @ git "main"
  with NameMap.empty.insert `errorOnBuild
    "ProofWidgets failed to reuse pre-built JS code. \
    Please report this issue on the Lean Zulip."
require "leanprover-community" / "importGraph" @ git "main"
require "leanprover-community" / "LeanSearchClient" @ git "main"
require "leanprover-community" / "plausible" @ git "main"


/-!
## Options for building mathlib
-/

/-- These options are used as `leanOptions`, prefixed by `` `weak``, so that
`lake build` uses them, as well as `Archive` and `Counterexamples`. -/
abbrev mathlibOnlyLinters : Array LeanOption := #[
  ⟨`linter.mathlibStandardSet, true⟩,
  -- Explicitly enable the header linter, since the standard set is defined in `Mathlib.Init`
  -- but we want to run this linter in files imported by `Mathlib.Init`.
  ⟨`linter.style.header, true⟩,
  ⟨`linter.checkInitImports, true⟩,
  ⟨`linter.allScriptsDocumented, true⟩,
  ⟨`linter.pythonStyle, true⟩,
  ⟨`linter.style.longFile, .ofNat 1500⟩,
  -- ⟨`linter.nightlyRegressionSet, true⟩,
  -- `latest_import.yml` uses this comment: if you edit it, make sure that the workflow still works
]

/-- These options are passed as `leanOptions` to building mathlib, as well as the
`Archive` and `Counterexamples`. (`tests` omits the first two options.) -/
abbrev mathlibLeanOptions := #[
    ⟨`pp.unicode.fun, true⟩, -- pretty-prints `fun a ↦ b`
    ⟨`autoImplicit, false⟩,
    ⟨`maxSynthPendingDepth, .ofNat 3⟩,
  ] ++ -- options that are used in `lake build`
    mathlibOnlyLinters.map fun s ↦ { s with name := `weak ++ s.name }

package mathlib where
  testDriver := "MathlibTest"
  lintDriver := "batteries/runLinter"
  lintDriverArgs := #["Mathlib"]
  -- A version of Mathlib only su

$ /bin/bash -lc 'lake env lean ENOTV/Compact.lean'
ENOTV/Compact.lean:1:0: error: unknown module prefix 'ENOTV'

No directory 'ENOTV' or file 'ENOTV.olean' in the search path entries:
/work/repro/.lake/packages/Cli/.lake/build/lib/lean
/work/repro/.lake/packages/batteries/.lake/build/lib/lean
/work/repro/.lake/packages/Qq/.lake/build/lib/lean
/work/repro/.lake/packages/aesop/.lake/build/lib/lean
/work/repro/.lake/packages/proofwidgets/.lake/build/lib/lean
/work/repro/.lake/packages/importGraph/.lake/build/lib/lean
/work/repro/.lake/packages/LeanSearchClient/.lake/build/lib/lean
/work/repro/.lake/packages/plausible/.lake/build/lib/lean
/work/repro/.lake/build/lib/lean
/opt/elan/toolchains/leanprover--lean4---v4.33.0-rc1/lib/lean
/opt/elan/toolchains/leanprover--lean4---v4.33.0-rc1/lib/lean

$ /bin/bash -lc 'lake build ENOTV.Basic'
✔ [8677/8677] Built ENOTV.Basic (6.1s)
Build completed successfully (8677 jobs).

$ /bin/bash -lc 'lake env lean ENOTV/Compact.lean'
ENOTV/Compact.lean:27:2: error: No goals to be solved
ENOTV/Compact.lean:31:46: error(lean.invalidField): Invalid field `toAddMonoidHom`: The environment does not contain `Function.toAddMonoidHom`, so it is not possible to project the field `toAddMonoidHom` from an expression
  cshift.toAddHom.toAddEquiv
of type
  (g : CSeq →ₙ+ CSeq) → g.comp cshift.toAddHom = AddHom.id CSeq → cshift.toAddHom.comp g = AddHom.id CSeq → CSeq ≃+ CSeq
ENOTV/Compact.lean:34:35: error: unsolved goals
u : CSeq
i : ℤ
⊢ ((sorry ()) u) i = u (i + 1)
ENOTV/Compact.lean:35:8: warning: declaration uses `sorry`
ENOTV/Compact.lean:38:40: error(lean.synthInstanceFailed): failed to synthesize instance of type class
  HPow (CSeq →+ CSeq) ℕ ?m.5

Hint: Type class instance resolution failures can be inspected with the `set_option trace.Meta.synthInstance true` command.
ENOTV/Compact.lean:40:71: error: unsolved goals
⊢ sorry () = AddMonoidHom.id CSeq
ENOTV/Compact.lean:41:8: warning: declaration uses `sorry`
ENOTV/Compact.lean:47:51: error: unsolved goals
n : ℕ
u : CSeq
⊢ (sorry ()) u = cdiff ((sorry ()) u)
ENOTV/Compact.lean:48:8: warning: declaration uses `sorry`
ENOTV/Compact.lean:48:19: warning: This simp argument is unused:
  pow_succ'

Hint: Omit it from the simp argument list.
  [apply] simp [cdiffIter]

Note: This linter can be disabled with `set_option linter.unusedSimpArgs false`
ENOTV/Compact.lean:53:9: error: unsolved goals
case zero
u : CSeq
i : ℤ
⊢ u i = diffIter 0 (⇑u) i
ENOTV/Compact.lean:54:14: error: unsolved goals
case succ
u : CSeq
i : ℤ
n : ℕ
ih : ((cdiffIter n) u) i = diffIter n (⇑u) i
⊢ ((cdiffIter n) u) (i + 1) = diffIter n (⇑u) (i + 1)
ENOTV/Compact.lean:62:5: error(lean.unknownIdentifier): Unknown constant `Finset.nonempty_insert`
ENOTV/Compact.lean:65:2: error: Tactic `apply` failed: could not unify the conclusion of `Finset.le_sup' id`
  id ?m.11 ≤ Finset.sup' ?m.9 ⋯ id
with the goal
  0 ≤ camplitude u

Note: The full type of `Finset.le_sup' id` is
  ∀ (h : ?m.11 ∈ ?m.9), id 

$ /bin/bash -lc "cat >/tmp/Check.lean <<'EOF'
import Mathlib
#check Finset.le_max'
#check Finset.max'_le_iff
#check Finset.nonempty_insert
#check Finset.insert_nonempty
#check Finset.max'_eq_sup'
#check AddEquiv.toAddMonoidHom
#check AddEquiv.toAddHom
EOF
lake env lean /tmp/Check.lean"
Finset.le_max'.{u_2} {α : Type u_2} [LinearOrder α] (s : Finset α) (x : α) (H2 : x ∈ s) : x ≤ s.max' ⋯
Finset.max'_le_iff.{u_2} {α : Type u_2} [LinearOrder α] (s : Finset α) (H : s.Nonempty) {x : α} :
  s.max' H ≤ x ↔ ∀ y ∈ s, y ≤ x
/tmp/Check.lean:4:7: error(lean.unknownIdentifier): Unknown constant `Finset.nonempty_insert`
Finset.insert_nonempty.{u_1} {α : Type u_1} [DecidableEq α] (a : α) (s : Finset α) : (insert a s).Nonempty
Finset.max'_eq_sup'.{u_2} {α : Type u_2} [LinearOrder α] (s : Finset α) (H : s.Nonempty) : s.max' H = s.sup' H id
AddEquiv.toAddMonoidHom.{u_4, u_5} {M : Type u_4} {N : Type u_5} [AddZeroClass M] [AddZeroClass N] (h : M ≃+ N) : M →+ N
AddEquiv.toAddHom.{u_9, u_10} {A : Type u_9} {B : Type u_10} [Add A] [Add B] (self : A ≃+ B) : A →ₙ+ B

$ /bin/bash -lc 'lake env lean ENOTV/Compact.lean'
ENOTV/Compact.lean:64:8: warning: This simp argument is unused:
  camplitude

Hint: Omit it from the simp argument list.
  [apply] simp

Note: This linter can be disabled with `set_option linter.unusedSimpArgs false`
ENOTV/Compact.lean:69:2: error: unsolved goals
case neg
u : CSeq
i : ℤ
hi : ¬u i = 0
⊢ ∃ a, ¬u a = 0 ∧ |u a| = |u i|
ENOTV/Compact.lean:70:10: warning: This simp argument is unused:
  camplitude

Hint: Omit it from the simp argument list.
  [apply] simp [hi]

Note: This linter can be disabled with `set_option linter.unusedSimpArgs false`

$ /bin/bash -lc 'lake env lean ENOTV/Compact.lean'

$ /bin/bash -lc 'rg -n "Finite.*Finsupp|finsupp.*finite|equiv.*Finsupp|onFinset.*support" Mathlib/Data/Finsupp Mathlib | head -100'
Mathlib/Data/Finsupp/Single.lean:265:    Finsupp.equivFunOnFinite (Finsupp.single x m) = Pi.single x m := by
Mathlib/Data/Finsupp/Single.lean:270:    Finsupp.equivFunOnFinite.symm (Pi.single x m) = Finsupp.single x m := by
Mathlib/Data/Finsupp/Fintype.lean:13:# Finiteness and infiniteness of `Finsupp`
Mathlib/Data/Finsupp/ToDFinsupp.lean:26:    * `finsuppLequivDFinsupp R : (ι →₀ M) ≃ₗ[R] (Π₀ i : ι, M)`
Mathlib/Data/Finsupp/ToDFinsupp.lean:30:  * `sigmaFinsuppLequivDFinsupp : ((Σ i, η i) →₀ N) ≃ₗ[R] (Π₀ i, (η i →₀ N))`
Mathlib/Data/Finsupp/ToDFinsupp.lean:48:For the bundled equivalences, we provide lemmas that they reduce to `Finsupp.toDFinsupp`:
Mathlib/Data/Finsupp/ToDFinsupp.lean:227:def finsuppLequivDFinsupp [DecidableEq ι] [Semiring R] [AddCommMonoid M]
Mathlib/Data/Finsupp/ToDFinsupp.lean:236:theorem finsuppLequivDFinsupp_apply_apply [DecidableEq ι] [Semiring R] [AddCommMonoid M]
Mathlib/Data/Finsupp/ToDFinsupp.lean:238:    (↑(finsuppLequivDFinsupp (M := M) R) : (ι →₀ M) → _) = Finsupp.toDFinsupp := rfl
Mathlib/Data/Finsupp/ToDFinsupp.lean:241:theorem finsuppLequivDFinsupp_symm_apply [DecidableEq ι] [Semiring R] [AddCommMonoid M]
Mathlib/Data/Finsupp/ToDFinsupp.lean:243:    ↑(LinearEquiv.symm (finsuppLequivDFinsupp (ι := ι) (M := M) R)) = DFinsupp.toFinsupp :=
Mathlib/Data/Finsupp/ToDFinsupp.lean:264:      onFinset (Finset.sigma f.support fun j => (f j).support) (fun ji => f ji.1 ji.2) fun g hg =>
Mathlib/Data/Finsupp/ToDFinsupp.lean:336:def sigmaFinsuppLequivDFinsupp [AddCommMonoid N] [Module R N] :
Mathlib/Data/Finsupp/Defs.lean:251:    (Finsupp.onFinset s f hf).support = {a ∈ s | f a ≠ 0} := by
Mathlib/Data/Finsupp/Defs.lean:254:@[simp] lemma onFinset_support (f : α →₀ M) : onFinset f.support f (by simp) = f := by ext; simp
Mathlib/Data/Finsupp/Defs.lean:258:    (onFinset s f hf).support ⊆ s := by
Mathlib/Data/Finsupp/Defs.lean:264:    a ∈ (Finsupp.onFinset s f hf).support ↔ f a ≠ 0 := by
Mathlib/Data/Finsupp/Defs.lean:313:  onFinset g.support (f ∘ g) fun a 

$ /bin/bash -lc 'rg -n "degreeLE.*finrank|FiniteDimensional.*degreeLE|injective_iff_surjective.*FiniteDimensional|LinearMap.injective_iff_surjective" Mathlib/Algebra/Polynomial Mathlib/LinearAlgebra | head -100 && rg -n "natDegree_comp_X_add|leadingCoeff_comp_X_add|comp_X_add_C|natDegree.*translate" Mathlib/Algebra/Polynomial | head -100'
Mathlib/LinearAlgebra/FiniteDimensional/Lemmas.lean:197:theorem injective_iff_surjective_of_finrank_eq_finrank [FiniteDimensional K V]
Mathlib/LinearAlgebra/FiniteDimensional/Lemmas.lean:218:    ⟨hf, (LinearMap.injective_iff_surjective_of_finrank_eq_finrank hdim).mp hf⟩
Mathlib/LinearAlgebra/FiniteDimensional/Basic.lean:30:equivalence of injectivity and surjectivity is proved in `LinearMap.injective_iff_surjective`,
Mathlib/LinearAlgebra/FiniteDimensional/Basic.lean:312:theorem injective_iff_surjective [FiniteDimensional K V] {f : V →ₗ[K] V} :
Mathlib/LinearAlgebra/FiniteDimensional/Basic.lean:417:  LinearEquiv.ofBijective f ⟨h_inj, LinearMap.injective_iff_surjective.mp h_inj⟩
Mathlib/LinearAlgebra/FiniteDimensional/Basic.lean:499:    LinearMap.injective_iff_surjective.1 fun y z => ((mul_right_inj' H).1 : x * y = x * z → y = z)
Mathlib/LinearAlgebra/FiniteDimensional/Basic.lean:670:  ⟨f.toRingHom.injective, f.toLinearMap.injective_iff_surjective.mp f.toRingHom.injective⟩
Mathlib/Algebra/Polynomial/AlgebraMap.lean:667:lemma comp_X_add_C_eq_zero_iff : p.comp (X + C t) = 0 ↔ p = 0 :=
Mathlib/Algebra/Polynomial/AlgebraMap.lean:670:lemma comp_X_add_C_ne_zero_iff : p.comp (X + C t) ≠ 0 ↔ p ≠ 0 := comp_X_add_C_eq_zero_iff.not
Mathlib/Algebra/Polynomial/AlgebraMap.lean:682:lemma dvd_comp_X_add_C_iff (p q : R[X]) (a : R) :
Mathlib/Algebra/Polynomial/Splits.lean:221:theorem Splits.comp_X_add_C {f : R[X]} (hf : f.Splits) (a : R) : (f.comp (X + C a)).Splits :=
Mathlib/Algebra/Polynomial/RingDivision.lean:111:  simp_rw [rootMultiplicity_eq_multiplicity, comp_X_add_C_eq_zero_iff]
Mathlib/Algebra/Polynomial/Monic.lean:126:lemma comp_X_add_C (hp : p.Monic) (r : R) : (p.comp (X + C r)).Monic := by
Mathlib/Algebra/Polynomial/Monic.lean:444:  simpa using! hp.comp_X_add_C (-r)

$ /bin/bash -lc "sed -n '620,690p' Mathlib/Algebra/Polynomial/AlgebraMap.lean && rg -n \"comp.*X_add_C.*(natDegree|leadingCoeff|degree)\" Mathlib | head -100 && rg -n \"degreeLE\" Mathlib/Algebra/Polynomial | head -100"
simp [hi]

theorem dvd_term_of_isRoot_of_dvd_terms {r p : S} {f : S[X]} (i : ℕ) (hr : f.IsRoot r)
    (h : ∀ j ≠ i, p ∣ f.coeff j * r ^ j) : p ∣ f.coeff i * r ^ i :=
  dvd_term_of_dvd_eval_of_dvd_terms i (Eq.symm hr ▸ dvd_zero p) h

end CommRing

end aeval

section Ring

variable [Ring R]

/-- The evaluation map is not generally multiplicative when the coefficient ring is noncommutative,
but nevertheless any polynomial of the form `p * (X - C r)` is sent to zero when evaluated at `r`.

This is the key step in our proof of the Cayley-Hamilton theorem.
-/
theorem eval_mul_X_sub_C {p : R[X]} (r : R) : (p * (X - C r)).eval r = 0 := by
  rw [mul_sub, eval_sub, eval_mul_X, eval_mul_C_of_commute] <;> simp

theorem not_isUnit_X_sub_C [Nontrivial R] (r : R) : ¬IsUnit (X - C r) :=
  fun ⟨⟨_, g, _hfg, hgf⟩, rfl⟩ => zero_ne_one' R <| by rw [← eval_mul_X_sub_C, hgf, eval_one]

end Ring

section CommRing
variable [CommRing R] {p : R[X]} {t : R}

@[simp]
theorem aeval_neg {p : R[X]} [Ring A] [Algebra R A] (x : A) :
    aeval x (-p) = -aeval x p := map_neg ..

@[simp]
theorem aeval_sub {p q : R[X]} [Ring A] [Algebra R A] (x : A) :
    aeval x (p - q) = aeval x p - aeval x q := map_sub ..

theorem aeval_endomorphism {M : Type*} [AddCommGroup M] [Module R M] (f : M →ₗ[R] M)
    (v : M) (p : R[X]) : aeval f p v = p.sum fun n b => b • (f ^ n) v := by
  rw [aeval_def, eval₂_eq_sum]
  exact map_sum (LinearMap.applyₗ v) _ _

lemma X_sub_C_pow_dvd_iff {n : ℕ} : (X - C t) ^ n ∣ p ↔ X ^ n ∣ p.comp (X + C t) := by
  convert! (map_dvd_iff <| algEquivAevalXAddC t).symm using 2
  simp [C_eq_algebraMap]

lemma comp_X_add_C_eq_zero_iff : p.comp (X + C t) = 0 ↔ p = 0 :=
  EmbeddingLike.map_eq_zero_iff (f := algEquivAevalXAddC t)

lemma comp_X_add_C_ne_zero_iff : p.comp (X + C t) ≠ 0 ↔ p ≠ 0 := comp_X_add_C_eq_zero_iff.not

lemma dvd_comp_C_mul_X_add_C_iff (p q : R[X]) (a b : R) [Invertible a] :
    p ∣ q.comp (C a * X + C b) ↔ p.comp (C ⅟a * (X - C b)) ∣ q := by
  convert! map_dvd_iff <| algEquivCM

$ /bin/bash -lc 'rg -n "Bernoulli.*[Pp]olynomial|bernoulliPolynomial|bernoulli.*poly" Mathlib | head -100 && rg -n "Euler.*number|euler.*number" Mathlib | head -100'
Mathlib/NumberTheory/BernoulliPolynomials.lean:14:# Bernoulli polynomials
Mathlib/NumberTheory/BernoulliPolynomials.lean:16:The [Bernoulli polynomials](https://en.wikipedia.org/wiki/Bernoulli_polynomials)
Mathlib/NumberTheory/BernoulliPolynomials.lean:21:The $n$-th Bernoulli polynomial is defined as
Mathlib/NumberTheory/BernoulliPolynomials.lean:23:where $B_k$ is the $k$-th Bernoulli number. The Bernoulli polynomials are generating functions,
Mathlib/NumberTheory/BernoulliPolynomials.lean:28:Bernoulli polynomials are defined using `bernoulli`, the Bernoulli numbers.
Mathlib/NumberTheory/BernoulliPolynomials.lean:32:- `Polynomial.sum_bernoulli`: The sum of the $k^\mathrm{th}$ Bernoulli polynomial with binomial
Mathlib/NumberTheory/BernoulliPolynomials.lean:34:- `Polynomial.bernoulli_generating_function`: The Bernoulli polynomials act as generating functions
Mathlib/NumberTheory/BernoulliPolynomials.lean:50:/-- The Bernoulli polynomials are defined in terms of the negative Bernoulli numbers. -/
Mathlib/NumberTheory/BernoulliPolynomials.lean:296:  -- finally cancel the Bernoulli polynomial and the algebra_map
Mathlib/NumberTheory/ZetaValues.lean:8:public import Mathlib.NumberTheory.BernoulliPolynomials
Mathlib/NumberTheory/ZetaValues.lean:19:zeta functions, in terms of Bernoulli polynomials.
Mathlib/NumberTheory/ZetaValues.lean:44:/-! Simple properties of the Bernoulli polynomial, as a function `ℝ → ℝ`. -/
Mathlib/NumberTheory/ZetaValues.lean:124:/-- Fundamental theorem of calculus to express a Bernoulli polynomial via the previous one -/
Mathlib/NumberTheory/ZetaValues.lean:272:/-- The Bernoulli polynomial, extended from `[0, 1)` to the unit circle. -/
Mathlib/NumberTheory/LSeries/HurwitzZetaValues.lean:16:integer in terms of Bernoulli polynomials.
Mathlib/NumberTheory/LSeries/HurwitzZetaValues.lean:51:of the Bernoulli polynomial. -/
Mathlib/NumberTheory/LSeries/HurwitzZetaValues.lean:72:Express the value of `sinZeta` at an odd integer `> 1` as a value of the Bernoull

$ /bin/bash -lc "sed -n '40,180p' Mathlib/NumberTheory/BernoulliPolynomials.lean && rg -n \"bernoulli.*add_one|eval.*bernoulli|bernoulli.*sub|bernoulli.*one_sub|sum_bernoulli\" Mathlib/NumberTheory/BernoulliPolynomials.lean"
noncomputable section

open Nat Polynomial

open Nat Finset

namespace Polynomial

/-- The Bernoulli polynomials are defined in terms of the negative Bernoulli numbers. -/
def bernoulli (n : ℕ) : ℚ[X] :=
  ∑ i ∈ range (n + 1), Polynomial.monomial (n - i) (_root_.bernoulli i * choose n i)

theorem bernoulli_def (n : ℕ) : bernoulli n =
    ∑ i ∈ range (n + 1), Polynomial.monomial i (_root_.bernoulli (n - i) * choose n i) := by
  rw [← sum_range_reflect, add_succ_sub_one, add_zero, bernoulli]
  apply sum_congr rfl
  rintro x hx
  rw [mem_range_succ_iff] at hx
  rw [choose_symm hx, tsub_tsub_cancel_of_le hx]

theorem coeff_bernoulli (n i : ℕ) :
    (bernoulli n).coeff i = if i ≤ n then (_root_.bernoulli (n - i) * choose n i) else 0 := by
  simp only [bernoulli, finsetSum_coeff, coeff_monomial]
  split_ifs with h
  · convert! sum_ite_eq_of_mem (range (n + 1)) (n - i) _ (by grind) using 3 <;> grind [choose_symm]
  · exact Finset.sum_eq_zero <| by grind

/-
### examples
-/
section Examples

@[simp]
theorem bernoulli_zero : bernoulli 0 = 1 := by simp [bernoulli]

@[simp]
theorem bernoulli_one : bernoulli 1 = X - C 2⁻¹ := by
  simp [bernoulli, ← smul_X_eq_monomial, sum_range_succ, ← C_1, -map_one, neg_div, sub_eq_add_neg]

@[simp]
theorem bernoulli_eval_zero (n : ℕ) : (bernoulli n).eval 0 = _root_.bernoulli n := by
  rw [← coeff_zero_eq_eval_zero, coeff_bernoulli, if_pos (Nat.zero_le n), Nat.sub_zero,
    Nat.choose_zero_right, Nat.cast_one, mul_one]

@[simp]
theorem bernoulli_eval_one (n : ℕ) : (bernoulli n).eval 1 = bernoulli' n := by
  simp only [bernoulli, eval_finsetSum]
  simp only [← succ_eq_add_one, sum_range_succ, mul_one, cast_one, choose_self,
    (_root_.bernoulli _).mul_comm, sum_bernoulli, one_pow, mul_one, eval_monomial, one_mul]
  by_cases h : n = 1
  · norm_num [h]
  · simp [h, bernoulli_eq_bernoulli'_of_ne_one h]

theorem bernoulli_three_eval_one_quarter :
    (Polynomial.bernoulli 3).eval (1 / 4) = 3 / 64 := by
  simp_rw [Polynomial.bernoulli, Finset.sum_r

$ /bin/bash -lc "sed -n '180,258p' Mathlib/NumberTheory/BernoulliPolynomials.lean"
rw [sum_range_pow_eq_bernoulli_sub]

set_option backward.isDefEq.respectTransparency false in
theorem bernoulli_comp_one_add_X (n : ℕ) :
    (bernoulli n).comp (1 + X) = bernoulli n + n • X ^ (n - 1) := by
  refine Nat.strong_induction_on n fun d hd => ?_
  cases d with
  | zero => simp
  | succ d =>
  rw [← smul_right_inj (show d + 2 ≠ 0 by positivity), ← smul_comp, smul_add]
  simp only [bernoulli_eq_sub_sum, sub_comp, sum_comp, add_assoc, one_add_one_eq_two, smul_smul]
  conv_lhs =>
    congr
    · skip
    · apply_congr
      · skip
      · rw [smul_comp, hd _ (mem_range.1 (by assumption))]
  simp_rw [smul_add, sum_add_distrib, sub_add, sub_add_eq_sub_sub_swap, sub_sub_eq_add_sub]
  congr 1
  rw [show ∀ a b c d : ℚ[X], a - b = c + d ↔ a - c = b + d by grind]
  calc ((d + 2) • X ^ (d + 1)).comp (1 + X) - (d + 2) • X ^ (d + 1)
    _ = (d + 2) • ∑ i ∈ range (d + 1), (d + 1).choose i • X ^ i := by
      rw [smul_comp, ← smul_sub, X_pow_comp, one_add_X_pow_sub_X_pow]
    _ = ∑ i ∈ range (d + 1), ((d + 2).choose (i + 1) * (i + 1)) • X ^ i := by
      simp_rw [smul_sum, smul_smul, ← add_one_mul_choose_eq (d + 1)]
    _ = ∑ i ∈ range (d + 1), ((d + 2).choose i * i) • X ^ (i - 1) +
          (((d + 2).choose (d + 1)) * (d + 1)) • X ^ (d + 1 - 1) := by
      rw [← sum_range_succ _ (d + 1)]; simp [sum_range_succ']
    _ = ∑ i ∈ range (d + 1), (d + 2).choose i • i • X ^ (i - 1) +
          ((d + 2) * (d + 1)) • X ^ (d + 1 - 1) := by
      simp [choose_succ_self_right, add_assoc, mul_assoc]

theorem bernoulli_eval_one_add (n : ℕ) (x : ℚ) :
    (bernoulli n).eval (1 + x) = (bernoulli n).eval x + n * x ^ (n - 1) := by
  have := bernoulli_comp_one_add_X n
  simpa using congr(Polynomial.eval x $this)

set_option backward.isDefEq.respectTransparency false in
theorem bernoulli_comp_neg_X (n : ℕ) :
    (bernoulli n).comp (-X) = (-1) ^ n • (bernoulli n + n • X ^ (n - 1)) := by
  cases n with
  | zero => simp
  | succ n =>
  ext i
  rw [← neg_one_mul, ← C_1, ← C_neg, Polynomial.comp_

$ /bin/bash -lc "cat >/tmp/Check.lean <<'EOF'
import Mathlib
#check Even.neg_one_pow
#check Odd.neg_one_pow
#check neg_one_pow_eq_one_iff_even
#check neg_one_pow_eq_neg_one_iff_odd
#check Polynomial.eval_comp
#check Polynomial.eval_mul
#check Polynomial.funext
#check Polynomial.ext_iff_eval_eq
EOF
lake env lean /tmp/Check.lean"
Even.neg_one_pow.{u_2} {α : Type u_2} [Monoid α] [HasDistribNeg α] {n : ℕ} (h : Even n) : (-1) ^ n = 1
Odd.neg_one_pow.{u_2} {α : Type u_2} [Monoid α] [HasDistribNeg α] {n : ℕ} (h : Odd n) : (-1) ^ n = -1
neg_one_pow_eq_one_iff_even.{u_4} {R : Type u_4} [Monoid R] [HasDistribNeg R] {n : ℕ} (h : -1 ≠ 1) :
  (-1) ^ n = 1 ↔ Even n
neg_one_pow_eq_neg_one_iff_odd.{u_4} {R : Type u_4} [Monoid R] [HasDistribNeg R] {n : ℕ} (h : -1 ≠ 1) :
  (-1) ^ n = -1 ↔ Odd n
Polynomial.eval_comp.{u} {R : Type u} [CommSemiring R] {p q : Polynomial R} {x : R} :
  Polynomial.eval x (p.comp q) = Polynomial.eval (Polynomial.eval x q) p
Polynomial.eval_mul.{u} {R : Type u} [CommSemiring R] {p q : Polynomial R} {x : R} :
  Polynomial.eval x (p * q) = Polynomial.eval x p * Polynomial.eval x q
Polynomial.funext.{u} {R : Type u} [CommRing R] [IsDomain R] [Infinite R] {p q : Polynomial R}
  (ext : ∀ (r : R), Polynomial.eval r p = Polynomial.eval r q) : p = q
/tmp/Check.lean:9:7: error(lean.unknownIdentifier): Unknown constant `Polynomial.ext_iff_eval_eq`

$ /bin/bash -lc 'lake build ENOTV.Compact && lake env lean ENOTV/Euler.lean'
✔ [8678/8678] Built ENOTV.Compact (5.7s)
Build completed successfully (8678 jobs).
ENOTV/Euler.lean:22:67: error: unexpected token '-'; expected ')', ',' or ':'
Try this:
  [apply] ring_nf
  
  The `ring` tactic failed to close the goal. Use `ring_nf` to obtain a normal form.
    
  Note that `ring` works primarily in *commutative* rings. If you have a noncommutative ring, abelian group or module, consider using `noncomm_ring`, `abel` or `module` instead.
ENOTV/Euler.lean:29:57: error: unsolved goals
d : ℕ
x : ℚ
⊢ eval (1 / 2 + x * (1 / 2)) (Polynomial.bernoulli (1 + d)) =
      eval (1 / 2 + x * (1 / 2)) (Polynomial.bernoulli (1 + d)) - eval (x * (1 / 2)) (Polynomial.bernoulli (1 + d)) ∨
    1 + ↑d = 0
ENOTV/Euler.lean:40:2: error: linarith failed to find a contradiction
case h1
d : ℕ
x : ℚ
hB :
  eval (1 + x * (1 / 2)) (Polynomial.bernoulli (1 + d)) =
    x ^ (1 + d - 1) * ↑(1 + d) * (1 / 2) ^ (1 + d - 1) + eval (x * (1 / 2)) (Polynomial.bernoulli (1 + d))
a✝ :
  -(eval (x * (1 / 2)) (Polynomial.bernoulli (1 + d)) * 2 ^ d * 2) +
      eval (1 + x * (1 / 2)) (Polynomial.bernoulli (1 + d)) * 2 ^ d * 2 <
    x ^ d * 2 + x ^ d * ↑d * 2
⊢ False
failed
Try this:
  [apply] ring_nf
  
  The `ring` tactic failed to close the goal. Use `ring_nf` to obtain a normal form.
    
  Note that `ring` works primarily in *commutative* rings. If you have a noncommutative ring, abelian group or module, consider using `noncomm_ring`, `abel` or `module` instead.
Try this:
  [apply] ring_nf
  
  The `ring` tactic failed to close the goal. Use `ring_nf` to obtain a normal form.
    
  Note that `ring` works primarily in *commutative* rings. If you have a noncommutative ring, abelian group or module, consider using `noncomm_ring`, `abel` or `module` instead.
ENOTV/Euler.lean:44:57: error: unsolved goals
case e'_2
d : ℕ
hd : Even d
x : ℚ
hodd : Odd (d + 1)
h₁ : eval (1 - x / 2) (Polynomial.bernoulli (d + 1)) = -1 * eval (x / 2) (Polynomial.bernoulli (d + 1))
h₂ : eval (1 - (x + 1) / 2) (Pol

$ /bin/bash -lc 'lake env lean ENOTV/Euler.lean'
Try this:
  [apply] ring_nf
  
  The `ring` tactic failed to close the goal. Use `ring_nf` to obtain a normal form.
    
  Note that `ring` works primarily in *commutative* rings. If you have a noncommutative ring, abelian group or module, consider using `noncomm_ring`, `abel` or `module` instead.
ENOTV/Euler.lean:29:57: error: unsolved goals
d : ℕ
x : ℚ
⊢ True ∨ 1 + ↑d = 0
Try this:
  [apply] ring_nf
  
  The `ring` tactic failed to close the goal. Use `ring_nf` to obtain a normal form.
    
  Note that `ring` works primarily in *commutative* rings. If you have a noncommutative ring, abelian group or module, consider using `noncomm_ring`, `abel` or `module` instead.
ENOTV/Euler.lean:35:69: error: unsolved goals
d : ℕ
x : ℚ
hB :
  eval (1 + x / 2) (Polynomial.bernoulli (d + 1)) =
    eval (x / 2) (Polynomial.bernoulli (d + 1)) + ↑(d + 1) * (x / 2) ^ (d + 1 - 1)
hd1 : ↑d + 1 ≠ 0
⊢ x ^ (1 + d - 1) * ↑(1 + d) * (1 / 2) ^ (1 + d - 1) * 2 ^ d * 2 = x ^ d * 2 + x ^ d * ↑d * 2
ENOTV/Euler.lean:87:6: error: Tactic `rewrite` failed: Did not find an occurrence of the pattern
  ↑(2 * L) + h
in the target expression
  (2 * ↑L) ^ d * eval ((2 * ↑L + h) / (2 * ↑L)) (eulerPoly d) + (2 * ↑L) ^ d * eval (h / (2 * ↑L)) (eulerPoly d) =
    2 * h ^ d

d L : ℕ
hL : 0 < L
h : ℚ
hid : eval (h / (2 * ↑L) + 1) (eulerPoly d) + eval (h / (2 * ↑L)) (eulerPoly d) = 2 * (h / (2 * ↑L)) ^ d
hden : 2 * ↑L ≠ 0
⊢ (2 * ↑L) ^ d * eval ((2 * ↑L + h) / (2 * ↑L)) (eulerPoly d) + (2 * ↑L) ^ d * eval (h / (2 * ↑L)) (eulerPoly d) =
    2 * h ^ d

$ /bin/bash -lc "nl -ba ENOTV/Euler.lean | sed -n '20,100p'"
20	def eulerPoly (d : ℕ) : ℚ[X] :=
    21	  C ((2 : ℚ) ^ (d + 1) / (d + 1)) *
    22	    ((Polynomial.bernoulli (d + 1)).comp (C (1 / 2 : ℚ) * (X + 1)) -
    23	     (Polynomial.bernoulli (d + 1)).comp (C (1 / 2 : ℚ) * X))
    24	
    25	theorem eulerPoly_eval (d : ℕ) (x : ℚ) :
    26	    (eulerPoly d).eval x =
    27	      (2 : ℚ) ^ (d + 1) / (d + 1) *
    28	        ((Polynomial.bernoulli (d + 1)).eval ((x + 1) / 2) -
    29	         (Polynomial.bernoulli (d + 1)).eval (x / 2)) := by
    30	  simp [eulerPoly]
    31	  ring
    32	
    33	/-- Defining Euler identity. -/
    34	theorem eulerPoly_add_one (d : ℕ) (x : ℚ) :
    35	    (eulerPoly d).eval (x + 1) + (eulerPoly d).eval x = 2 * x ^ d := by
    36	  rw [eulerPoly_eval, eulerPoly_eval]
    37	  have hB := Polynomial.bernoulli_eval_one_add (d + 1) (x / 2)
    38	  rw [show (x + 1 + 1) / 2 = 1 + x / 2 by ring, hB]
    39	  have hd1 : (d + 1 : ℚ) ≠ 0 := by positivity
    40	  field_simp [hd1]
    41	  ring
    42	
    43	/-- For even degree the Euler polynomial is symmetric about `1/2`. -/
    44	theorem eulerPoly_one_sub (d : ℕ) (hd : Even d) (x : ℚ) :
    45	    (eulerPoly d).eval (1 - x) = (eulerPoly d).eval x := by
    46	  have hodd : Odd (d + 1) := hd.add_one
    47	  have h₁ := Polynomial.bernoulli_eval_one_sub (d + 1) (x / 2)
    48	  have h₂ := Polynomial.bernoulli_eval_one_sub (d + 1) ((x + 1) / 2)
    49	  rw [hodd.neg_one_pow] at h₁ h₂
    50	  rw [eulerPoly_eval, eulerPoly_eval]
    51	  rw [show (1 - x + 1) / 2 = 1 - x / 2 by ring, h₁,
    52	    show (1 - x) / 2 = 1 - (x + 1) / 2 by ring, h₂]
    53	  ring
    54	
    55	theorem eulerPoly_zero (d : ℕ) (hd : 0 < d) (heven : Even d) :
    56	    (eulerPoly d).eval 0 = 0 := by
    57	  have hsym := eulerPoly_one_sub d heven 0
    58	  have hid := eulerPoly_add_one d 0
    59	  norm_num [zero_pow hd.ne'] at hid
    60	  norm_num at hsym
    61	  linarith
    62	
    63	theorem eulerPoly_one (d : ℕ) (hd : 0 < d) (heven : Even d) :
    64	    (eulerPoly

$ /bin/bash -lc 'lake env lean ENOTV/Euler.lean'
Try this:
  [apply] ring_nf
  
  The `ring` tactic failed to close the goal. Use `ring_nf` to obtain a normal form.
    
  Note that `ring` works primarily in *commutative* rings. If you have a noncommutative ring, abelian group or module, consider using `noncomm_ring`, `abel` or `module` instead.
Try this:
  [apply] ring_nf
  
  The `ring` tactic failed to close the goal. Use `ring_nf` to obtain a normal form.
    
  Note that `ring` works primarily in *commutative* rings. If you have a noncommutative ring, abelian group or module, consider using `noncomm_ring`, `abel` or `module` instead.
ENOTV/Euler.lean:35:69: error: unsolved goals
d : ℕ
x : ℚ
hB :
  eval (1 + x / 2) (Polynomial.bernoulli (d + 1)) =
    eval (x / 2) (Polynomial.bernoulli (d + 1)) + ↑(d + 1) * (x / 2) ^ (d + 1 - 1)
hd1 : ↑d + 1 ≠ 0
⊢ x ^ d * ↑(1 + d) * 2 ^ d * 2 = x ^ d * ↑d * 2 ^ d * 2 + x ^ d * 2 ^ d * 2
ENOTV/Euler.lean:88:6: error: unsolved goals
d L : ℕ
hL : 0 < L
h : ℚ
hid : eval (h / (2 * ↑L) + 1) (eulerPoly d) + eval (h / (2 * ↑L)) (eulerPoly d) = 2 * (h / (2 * ↑L)) ^ d
hden : 2 * ↑L ≠ 0
⊢ 2 * ↑L + h = h + 2 * ↑L

$ /bin/bash -lc 'lake env lean ENOTV/Euler.lean'
Try this:
  [apply] ring_nf
  
  The `ring` tactic failed to close the goal. Use `ring_nf` to obtain a normal form.
    
  Note that `ring` works primarily in *commutative* rings. If you have a noncommutative ring, abelian group or module, consider using `noncomm_ring`, `abel` or `module` instead.
Try this:
  [apply] ring_nf
  
  The `ring` tactic failed to close the goal. Use `ring_nf` to obtain a normal form.
    
  Note that `ring` works primarily in *commutative* rings. If you have a noncommutative ring, abelian group or module, consider using `noncomm_ring`, `abel` or `module` instead.
ENOTV/Euler.lean:35:69: error: unsolved goals
d : ℕ
x : ℚ
hB :
  eval (1 + x / 2) (Polynomial.bernoulli (d + 1)) =
    eval (x / 2) (Polynomial.bernoulli (d + 1)) + ↑(d + 1) * (x / 2) ^ (d + 1 - 1)
hd1 : ↑d + 1 ≠ 0
⊢ ↑(2 ^ d * 2) * x ^ d * ↑(1 + d) = x ^ d * ↑(2 ^ d) * ↑(2 + d * 2)
ENOTV/Euler.lean:91:6: warning: Used `tac1 <;> tac2` where `(tac1; tac2)` would suffice

Note: This linter can be disabled with `set_option linter.unnecessarySeqFocus false`

$ /bin/bash -lc 'lake env lean ENOTV/Euler.lean'
Try this:
  [apply] ring_nf
  
  The `ring` tactic failed to close the goal. Use `ring_nf` to obtain a normal form.
    
  Note that `ring` works primarily in *commutative* rings. If you have a noncommutative ring, abelian group or module, consider using `noncomm_ring`, `abel` or `module` instead.
ENOTV/Euler.lean:91:6: warning: Used `tac1 <;> tac2` where `(tac1; tac2)` would suffice

Note: This linter can be disabled with `set_option linter.unnecessarySeqFocus false`

$ /bin/bash -lc 'rg -n "instance.*InnerProduct.*Finsupp|Finsupp.*inner|inner.*Finsupp" Mathlib/Analysis Mathlib/LinearAlgebra | head -100'
Mathlib/Analysis/InnerProductSpace/Orthonormal.lean:115:  simp [linearCombination_apply, Finsupp.inner_sum, orthonormal_iff_ite.mp hv, inner_smul_right,
Mathlib/Analysis/InnerProductSpace/Orthonormal.lean:154:  simp [l₁.linearCombination_apply, Finsupp.sum_inner, hv.inner_right_finsupp, inner_smul_left]
Mathlib/Analysis/InnerProductSpace/Orthonormal.lean:160:  simp [l₂.linearCombination_apply, Finsupp.inner_sum, hv.inner_left_finsupp, mul_comm,
Mathlib/Analysis/InnerProductSpace/Orthonormal.lean:354:      Finsupp.apply_linearCombination, hv.inner_finsupp_eq_sum_left, hf.inner_finsupp_eq_sum_left]
Mathlib/Analysis/InnerProductSpace/Reproducing.lean:199:  · simp [Finsupp.sum_apply'', Finsupp.sum_inner, star, adjoint_inner_left,
Mathlib/Analysis/InnerProductSpace/Reproducing.lean:201:    simp [← Finsupp.sum_inner, ← Finsupp.inner_sum, -kerFun_inner, -inner_kerFun]
Mathlib/Analysis/InnerProductSpace/Reproducing.lean:230:    FunLike.coe_mul_eq_comp, Function.comp_apply, Finsupp.sum_inner, adjoint_inner_left]
Mathlib/Analysis/InnerProductSpace/Reproducing.lean:239:    simp [Finsupp.sum_sum_index, inner_add_right, inner_add_left, ← smul_assoc, hv]
Mathlib/Analysis/InnerProductSpace/Reproducing.lean:245:    simpa [Finsupp.sum_sum_index, inner_add_right, inner_add_left] using
Mathlib/Analysis/InnerProductSpace/Reproducing.lean:293:    simp [inner_add_left, inner_H₀_def, ← Finsupp.sum_add, ← mul_add]
Mathlib/Analysis/InnerProductSpace/Reproducing.lean:296:    simp [inner_smul_left, inner_H₀_def, Finsupp.mul_sum, ← mul_assoc, mul_comm]
Mathlib/Analysis/InnerProductSpace/Subspace.lean:108:      DFinsupp.inner_sum (fun j => V j) l (V i v)
Mathlib/Analysis/InnerProductSpace/Basic.lean:166:/-- An inner product with a sum on the left, `Finsupp` version. -/
Mathlib/Analysis/InnerProductSpace/Basic.lean:167:protected theorem Finsupp.sum_inner {ι : Type*} {M : Type*} [Zero M] (l : ι →₀ M)
Mathlib/Analysis/InnerProductSpace/Basic.lean:171:/-- An inner product with a sum on the right, `

$ /bin/bash -lc "rg -n \"theorem .*sum.*domCongr|sum_domCongr|equivCongrLeft.*sum|sum_equivCongr\" Mathlib/Data/Finsupp | head -100 && sed -n '280,330p' Mathlib/Data/Finsupp/Defs.lean && rg -n \"sum_congr.*Finsupp|Finsupp.sum_congr\" Mathlib/Data/Finsupp | head -50"
(ofSupportFinite f hf : α → M) = f :=
  rfl

theorem ofSupportFinite_support {f : α → M} (hf : f.support.Finite) :
    (ofSupportFinite f hf).support = hf.toFinset := by
  ext; simp [ofSupportFinite_coe]

instance instCanLift : CanLift (α → M) (α →₀ M) (⇑) fun f => (Function.support f).Finite where
  prf f hf := ⟨ofSupportFinite f hf, rfl⟩

end OfSupportFinite

/-! ### Declarations about `mapRange` -/


section MapRange

variable [Zero M] [Zero N] [Zero O]

/-- The composition of `f : M → N` and `g : α →₀ M` is `mapRange f hf g : α →₀ N`,
which is well-defined when `f 0 = 0`.

This preserves the structure on `f`, and exists in various bundled forms for when `f` is itself
bundled (defined in `Mathlib/Data/Finsupp/Basic.lean`):

* `Finsupp.mapRange.equiv`
* `Finsupp.mapRange.zeroHom`
* `Finsupp.mapRange.addMonoidHom`
* `Finsupp.mapRange.addEquiv`
* `Finsupp.mapRange.linearMap`
* `Finsupp.mapRange.linearEquiv`
-/
def mapRange (f : M → N) (hf : f 0 = 0) (g : α →₀ M) : α →₀ N :=
  onFinset g.support (f ∘ g) fun a => by
    rw [mem_support_iff, not_imp_not]; exact fun H => (congr_arg f H).trans hf

@[simp, grind =]
theorem mapRange_apply {f : M → N} {hf : f 0 = 0} {g : α →₀ M} {a : α} :
    mapRange f hf g a = f (g a) :=
  rfl

@[simp]
theorem mapRange_zero {f : M → N} {hf : f 0 = 0} : mapRange f hf (0 : α →₀ M) = 0 :=
  ext fun _ => by simp only [hf, zero_apply, mapRange_apply]

@[simp]
theorem mapRange_eq_zero {a : α →₀ M} {f : M → N} (hf : f.Injective) (h) :
    mapRange f h a = 0 ↔ a = 0 := by
  simp [Finsupp.ext_iff, ← h, hf.eq_iff]

@[simp]

$ /bin/bash -lc "cat >/tmp/Test.lean <<'EOF'
import ENOTV.Compact
open ENOTV
example (u : CSeq) : (cshift u).support = u.support.map (Equiv.addRight (-1 : ℤ)).toEmbedding := by
  ext i
  simp [cshift]
example (u : CSeq) : (cshift u).sum (fun _ x => x) = u.sum (fun _ x => x) := by
  simp [Finsupp.sum, cshift]
EOF
lake env lean /tmp/Test.lean"
/tmp/Test.lean:6:77: error: unsolved goals
u : CSeq
⊢ ∑ x ∈ (Finsupp.equivMapDomain (Equiv.addRight (-1)) u).support, u (x + 1) = ∑ x ∈ u.support, u x

$ /bin/bash -lc "cat >/tmp/Test.lean <<'EOF'
import ENOTV.Compact
open ENOTV
example (u : CSeq) : (cshift u).support = u.support.map (Equiv.addRight (-1 : ℤ)).toEmbedding := by
  ext i
  simp [cshift]
example (u : CSeq) : (cshift u).sum (fun _ x => x) = u.sum (fun _ x => x) := by
  rw [Finsupp.sum, show (cshift u).support = u.support.map (Equiv.addRight (-1 : ℤ)).toEmbedding by ext i; simp [cshift]]
  rw [Finset.sum_map]
  simp
EOF
lake env lean /tmp/Test.lean"
/tmp/Test.lean:6:77: error: unsolved goals
u : CSeq
⊢ ∑ x ∈ u.support, u x = Finsupp.sum u fun x x_1 => x_1

$ /bin/bash -lc "sed -i 's/  simp"'$/  simp [Finsupp.sum]/'"' /tmp/Test.lean && lake env lean /tmp/Test.lean"

$ /bin/bash -lc "cat >/tmp/Check.lean <<'EOF'
import Mathlib
#check Finsupp.summable
#check summable_of_ne_finset_zero
#check hasSum_fintype
#check Equiv.tsum_eq
#check Equiv.tsum_comp
#check tsum_sub
#check Summable.tsum_sub
#check tsum_add
EOF
lake env lean /tmp/Check.lean"
/tmp/Check.lean:2:7: error(lean.unknownIdentifier): Unknown constant `Finsupp.summable`
summable_of_ne_finset_zero.{u_1, u_2} {α : Type u_1} {β : Type u_2} [AddCommMonoid α] [TopologicalSpace α]
  {L : SummationFilter β} {f : β → α} {s : Finset β} (hf : ∀ b ∉ s, f b = 0) [L.HasSupport] : Summable f L
hasSum_fintype.{u_1, u_2} {α : Type u_1} {β : Type u_2} [AddCommMonoid α] [TopologicalSpace α] [Fintype β] (f : β → α)
  (L : SummationFilter β := SummationFilter.unconditional β) [L.LeAtTop] : HasSum f (∑ b, f b) L
Equiv.tsum_eq.{u_1, u_2, u_3} {α : Type u_1} {β : Type u_2} {γ : Type u_3} [AddCommMonoid α] [TopologicalSpace α]
  (e : γ ≃ β) (f : β → α) : ∑' (c : γ), f (e c) = ∑' (b : β), f b
/tmp/Check.lean:6:7: error(lean.unknownIdentifier): Unknown constant `Equiv.tsum_comp`
/tmp/Check.lean:7:7: error(lean.unknownIdentifier): Unknown identifier `tsum_sub`
Summable.tsum_sub.{u_1, u_2} {α : Type u_1} {β : Type u_2} {L : SummationFilter β} [AddCommGroup α] [TopologicalSpace α]
  [IsTopologicalAddGroup α] {f g : β → α} [T2Space α] [L.NeBot] (hf : Summable f L) (hg : Summable g L) :
  ∑'[L] (b : β), (f b - g b) = ∑'[L] (b : β), f b - ∑'[L] (b : β), g b
/tmp/Check.lean:9:7: error(lean.unknownIdentifier): Unknown identifier `tsum_add`

$ /bin/bash -lc 'lake env lean ENOTV/Energy.lean'
ENOTV/Energy.lean:56:2: error: Type mismatch: After simplification, term
  dot_sub_left 0 f g
 has type
  dot (0 - f) g = dot 0 g - dot f g
but is expected to have type
  dot (-f) g = -dot f g
ENOTV/Energy.lean:108:12: error: Tactic `rfl` failed: The left-hand side
  cdiffIter 0 (cdiffIter n f)
is not definitionally equal to the right-hand side
  cdiffIter (0 + n) f

case zero
n : ℕ
f : CSeq
⊢ cdiffIter 0 (cdiffIter n f) = cdiffIter (0 + n) f
ENOTV/Energy.lean:110:30: error: Tactic `rewrite` failed: Did not find an occurrence of the pattern
  cdiffIter (?n + 1) ?u
in the target expression
  cdiff (cdiffIter (m + n) f) = cdiffIter (m + 1 + n) f

case succ
n : ℕ
f : CSeq
m : ℕ
ih : cdiffIter m (cdiffIter n f) = cdiffIter (m + n) f
⊢ cdiff (cdiffIter (m + n) f) = cdiffIter (m + 1 + n) f
ENOTV/Energy.lean:120:10: error: Tactic `rewrite` failed: Did not find an occurrence of the pattern
  dot (cdiffIter n (cshift f)) (cdiff g)
in the target expression
  -dot (cshift (cdiffIter n f)) (cdiff g) = (-1) ^ (n + 1) * dot (cshiftIter (n + 1) f) (cdiffIter (n + 1) g)

case succ
n : ℕ
ih : ∀ (f g : CSeq), dot (cdiffIter n f) g = (-1) ^ n * dot (cshiftIter n f) (cdiffIter n g)
f g : CSeq
⊢ -dot (cshift (cdiffIter n f)) (cdiff g) = (-1) ^ (n + 1) * dot (cshiftIter (n + 1) f) (cdiffIter (n + 1) g)
ENOTV/Energy.lean:149:4: error: Tactic `apply` failed: could not unify the conclusion of `Finset.le_sup' fun s => |a (j + ↑s)|`
  |a (j + ↑?m.44)| ≤ Finset.sup' ?m.35 ⋯ fun s => |a (j + ↑s)|
with the goal
  |a j| ≤ (Finset.range k).sup' ⋯ fun s => |a (j + ↑s)|

Note: The full type of `Finset.le_sup' fun s => |a (j + ↑s)|` is
  ∀ (h : ?m.44 ∈ ?m.35), |a (j + ↑?m.44)| ≤ Finset.sup' ?m.35 ⋯ fun s => |a (j + ↑s)|

case pos
k : ℕ
a : Seq
j : ℤ
hk : 0 < k
⊢ |a j| ≤ (Finset.range k).sup' ⋯ fun s => |a (j + ↑s)|
ENOTV/Energy.lean:164:2: error: not a positivity goal
ENOTV/Energy.lean:171:40: error: Application type mismatch: The argument
  hi
has type
  i ∈ Function.support fun i => f i * g i
but i

$ /bin/bash -lc "cat >/tmp/Check.lean <<'EOF'
import ENOTV.Compact
#check Finsupp.sum_nonneg
#check Finsupp.sum_le_sum
#check tsum_eq_sum'
#check tsum_eq_sum
#check hasSum_sum
#check summable_of_support_subset
#check Finset.abs_sum_le_sum_abs
EOF
lake env lean /tmp/Check.lean"
Finsupp.sum_nonneg.{u_1, u_3, u_4} {ι : Type u_1} {α : Type u_3} {β : Type u_4} [Zero α] [AddCommMonoid β] [Preorder β]
  [IsOrderedAddMonoid β] {f : ι →₀ α} {h₁ : ι → α → β} (h : ∀ i ∈ f.support, 0 ≤ h₁ i (f i)) : 0 ≤ f.sum h₁
Finsupp.sum_le_sum.{u_1, u_3, u_4} {ι : Type u_1} {α : Type u_3} {β : Type u_4} [Zero α] [AddCommMonoid β] [Preorder β]
  [IsOrderedAddMonoid β] {f : ι →₀ α} {h₁ h₂ : ι → α → β} (h : ∀ i ∈ f.support, h₁ i (f i) ≤ h₂ i (f i)) :
  f.sum h₁ ≤ f.sum h₂
tsum_eq_sum'.{u_1, u_2} {α : Type u_1} {β : Type u_2} [AddCommMonoid α] [TopologicalSpace α] {f : β → α}
  {L : SummationFilter β} [L.LeAtTop] {s : Finset β} (hf : Function.support f ⊆ ↑s) : ∑'[L] (b : β), f b = ∑ b ∈ s, f b
tsum_eq_sum.{u_1, u_2} {α : Type u_1} {β : Type u_2} [AddCommMonoid α] [TopologicalSpace α] {f : β → α}
  {L : SummationFilter β} [L.LeAtTop] {s : Finset β} (hf : ∀ b ∉ s, f b = 0) : ∑'[L] (b : β), f b = ∑ b ∈ s, f b
hasSum_sum.{u_1, u_2, u_3} {α : Type u_1} {β : Type u_2} {γ : Type u_3} [AddCommMonoid α] [TopologicalSpace α]
  {L : SummationFilter β} [ContinuousAdd α] {f : γ → β → α} {a : γ → α} {s : Finset γ} :
  (∀ i ∈ s, HasSum (f i) (a i) L) → HasSum (fun b => ∑ i ∈ s, f i b) (∑ i ∈ s, a i) L
/tmp/Check.lean:7:7: error(lean.unknownIdentifier): Unknown identifier `summable_of_support_subset`
Finset.abs_sum_le_sum_abs.{u_1, u_9} {ι : Type u_1} {G : Type u_9} [AddCommGroup G] [LinearOrder G]
  [IsOrderedAddMonoid G] (f : ι → G) (s : Finset ι) : |∑ i ∈ s, f i| ≤ ∑ i ∈ s, |f i|

$ /bin/bash -lc 'lake env lean ENOTV/Energy.lean'
ENOTV/Energy.lean:124:10: error: Tactic `rewrite` failed: Did not find an occurrence of the pattern
  cdiffIter ?m (cdiffIter ?n ?f)
in the target expression
  -((-1) ^ n * dot (cshiftIter n (cshift f)) (cdiffIter n (cdiff g))) =
    (-1) ^ (n + 1) * dot (cshiftIter (n + 1) f) (cdiffIter (n + 1) g)

case succ
n : ℕ
ih : ∀ (f g : CSeq), dot (cdiffIter n f) g = (-1) ^ n * dot (cshiftIter n f) (cdiffIter n g)
f g : CSeq
⊢ -((-1) ^ n * dot (cshiftIter n (cshift f)) (cdiffIter n (cdiff g))) =
    (-1) ^ (n + 1) * dot (cshiftIter (n + 1) f) (cdiffIter (n + 1) g)
ENOTV/Energy.lean:152:4: error: Type mismatch: After simplification, term
  Finset.le_sup' (fun s => |a (j + ↑s)|)
    (have this := Eq.mpr (id Finset.mem_range._simp_1) hk;
    this)
 has type
  |a j| ≤ (Finset.range k).sup' ⋯ fun s => |a (j + ↑s)|
but is expected to have type
  ∃ b < k, |a j| ≤ |a (j + ↑b)|
ENOTV/Energy.lean:194:6: error: Type mismatch: After simplification, term
  Finset.abs_sum_le_sum_abs (fun j => (cdiffIter (2 * s) a) j * (cshiftIter s a) j) (cdiffIter (2 * s) a).support
 has type
  |∑ x ∈ (cdiffIter (2 * s) a).support, diffIter (2 * s) (⇑a) x * a (x + ↑s)| ≤
    ∑ x ∈ (cdiffIter (2 * s) a).support, |diffIter (2 * s) (⇑a) x| * |a (x + ↑s)|
but is expected to have type
  |∑ x ∈ (cdiffIter (2 * s) a).support, diffIter (2 * s) (⇑a) x * a (x + ↑s)| ≤
    ∑ x ∈ (cdiffIter (2 * s) a).support, |a (x + ↑s)| * |diffIter (2 * s) (⇑a) x|
ENOTV/Energy.lean:208:6: error: No goals to be solved

$ /bin/bash -lc "nl -ba ENOTV/Energy.lean | sed -n '115,215p'"
115	theorem dot_diffIter_left (n : ℕ) (f g : CSeq) :
   116	    dot (cdiffIter n f) g =
   117	      (-1 : ℝ) ^ n * dot (cshiftIter n f) (cdiffIter n g) := by
   118	  induction n generalizing f g with
   119	  | zero => simp
   120	  | succ n ih =>
   121	      rw [cdiffIter_succ, dot_cdiff_left]
   122	      rw [← cdiffIter_cshift]
   123	      rw [ih (cshift f) (cdiff g)]
   124	      rw [cdiffIter_add]
   125	      have hs : cshiftIter n (cshift f) = cshiftIter (n + 1) f := by
   126	        ext i
   127	        simp
   128	        push_cast
   129	        omega
   130	      rw [hs, pow_succ]
   131	      ring
   132	
   133	/-- The square identity of Lemma 3.3. -/
   134	theorem even_difference_energy (s : ℕ) (a : CSeq) :
   135	    dot (cdiffIter s a) (cdiffIter s a) =
   136	      (-1 : ℝ) ^ s * dot (cshiftIter s a) (cdiffIter (2 * s) a) := by
   137	  rw [dot_diffIter_left, cdiffIter_add]
   138	  congr 3
   139	  omega
   140	
   141	/-- Selection-free localized source functional `Eₖ`. -/
   142	def cEnergy (k : ℕ) (a : CSeq) : ℝ :=
   143	  (cdiffIter (k - 1) a).sum fun j w =>
   144	    blockAmplitude k (a : Seq) j * |w|
   145	
   146	theorem blockAmplitude_nonneg (k : ℕ) (a : Seq) (j : ℤ) :
   147	    0 ≤ blockAmplitude k a j := by
   148	  by_cases hk : 0 < k
   149	  · unfold blockAmplitude
   150	    simp only [dif_pos hk]
   151	    apply le_trans (abs_nonneg (a j))
   152	    simpa using
   153	      (Finset.le_sup' (f := fun s : ℕ => |a (j + (s : ℤ))|)
   154	        (show 0 ∈ Finset.range k by simpa))
   155	  · simp [blockAmplitude, hk]
   156	
   157	theorem abs_le_blockAmplitude {k s : ℕ} (hs : s < k) (a : Seq) (j : ℤ) :
   158	    |a (j + s)| ≤ blockAmplitude k a j := by
   159	  have hk : 0 < k := Nat.zero_lt_of_lt hs
   160	  unfold blockAmplitude
   161	  simp only [dif_pos hk]
   162	  apply Finset.le_sup' (f := fun q : ℕ => |a (j + (q : ℤ))|)
   163	  simpa using hs
   164	
   165	theorem cEnergy_nonneg (k : ℕ) (a : CSeq) : 0 ≤ cEnergy k

$ /bin/bash -lc 'lake env lean ENOTV/Energy.lean'
ENOTV/Energy.lean:132:8: error: omega could not prove the goal:
No usable constraints found. You may need to unfold definitions so `omega` can see linear arithmetic facts about `Nat` and `Int`, which may also involve multiplication, division, and modular remainder by constants.
ENOTV/Energy.lean:157:24: warning: Used `tac1 <;> tac2` where `(tac1; tac2)` would suffice

Note: This linter can be disabled with `set_option linter.unnecessarySeqFocus false`

$ /bin/bash -lc "nl -ba ENOTV/Energy.lean | sed -n '123,137p'"
123	      rw [ih (cshift f) (cdiff g)]
   124	      have hd : cdiffIter n (cdiff g) = cdiffIter (n + 1) g := by
   125	        change cdiffIter n (cdiffIter 1 g) = cdiffIter (n + 1) g
   126	        exact cdiffIter_add n 1 g
   127	      rw [hd]
   128	      have hs : cshiftIter n (cshift f) = cshiftIter (n + 1) f := by
   129	        ext i
   130	        simp
   131	        push_cast
   132	        omega
   133	      rw [hs, pow_succ]
   134	      ring
   135	
   136	/-- The square identity of Lemma 3.3. -/
   137	theorem even_difference_energy (s : ℕ) (a : CSeq) :

$ /bin/bash -lc 'lake env lean ENOTV/Energy.lean'
ENOTV/Energy.lean:158:24: warning: Used `tac1 <;> tac2` where `(tac1; tac2)` would suffice

Note: This linter can be disabled with `set_option linter.unnecessarySeqFocus false`

$ /bin/bash -lc 'rg -n "Riemann.*sum|riemann.*sum|tendsto.*sum.*range|sum.*div.*tendsto|integral.*Riemann" Mathlib/MeasureTheory Mathlib/Analysis | head -150'
Mathlib/Analysis/PSeries.lean:361:theorem tendsto_sum_range_one_div_nat_succ_atTop :
Mathlib/Analysis/BoxIntegral/Partition/Filter.lean:16:well-known definitions of integrals based on partitions of a rectangular box into subboxes (Riemann
Mathlib/Analysis/Fourier/RiemannLebesgueLemma.lean:63:/-- Shifting `f` by `(1 / (2 * ‖w‖ ^ 2)) • w` negates the integral in the Riemann-Lebesgue lemma. -/
Mathlib/Analysis/Normed/Group/InfiniteSum.lean:107:  ⟨fun h => h.tendsto_sum_nat, fun h => hasSum_of_subseq_of_summable hf tendsto_finset_range h⟩

$ /bin/bash -lc 'rg -n "continuous.*eval|Polynomial.*continuous|continuousAt.*eval" Mathlib/Topology/Algebra/Polynomial.lean Mathlib | head -100 && rg -n "card.*roots|card_roots|root.*card" Mathlib/Algebra/Polynomial | head -100'
Mathlib/Topology/Algebra/Polynomial.lean:21:* `Polynomial.continuous_eval₂`: `Polynomial.eval₂` defines a continuous function.
Mathlib/Topology/Algebra/Polynomial.lean:22:* `Polynomial.continuous_aeval`: `Polynomial.aeval` defines a continuous function;
Mathlib/Topology/Algebra/Polynomial.lean:23:  we also prove convenience lemmas `Polynomial.continuousAt_aeval`,
Mathlib/Topology/Algebra/Polynomial.lean:24:  `Polynomial.continuousWithinAt_aeval`, `Polynomial.continuousOn_aeval`.
Mathlib/Topology/Algebra/Polynomial.lean:25:* `Polynomial.continuous`:  `Polynomial.eval` defines a continuous functions;
Mathlib/Topology/Algebra/Polynomial.lean:26:  we also prove convenience lemmas `Polynomial.continuousAt`, `Polynomial.continuousWithinAt`,
Mathlib/Topology/Algebra/Polynomial.lean:27:  `Polynomial.continuousOn`.
Mathlib/Topology/Algebra/Polynomial.lean:51:protected theorem continuous_eval₂ [Semiring S] (p : S[X]) (f : S →+* R) :
Mathlib/Topology/Algebra/Polynomial.lean:57:protected theorem continuous : Continuous fun x => p.eval x :=
Mathlib/Topology/Algebra/Polynomial.lean:58:  p.continuous_eval₂ _
Mathlib/Topology/Algebra/Polynomial.lean:61:protected theorem continuousAt {a : R} : ContinuousAt (fun x => p.eval x) a :=
Mathlib/Topology/Algebra/Polynomial.lean:65:protected theorem continuousWithinAt {s a} : ContinuousWithinAt (fun x => p.eval x) s a :=
Mathlib/Topology/Algebra/Polynomial.lean:69:protected theorem continuousOn {s} : ContinuousOn (fun x => p.eval x) s :=
Mathlib/Topology/Algebra/Polynomial.lean:80:protected theorem continuous_aeval : Continuous fun x : A => aeval x p :=
Mathlib/Topology/Algebra/Polynomial.lean:81:  p.continuous_eval₂ _
Mathlib/Topology/Algebra/Polynomial.lean:84:protected theorem continuousAt_aeval {a : A} : ContinuousAt (fun x : A => aeval x p) a :=
Mathlib/Topology/Algebra/Polynomial.lean:85:  p.continuous_aeval.continuousAt
Mathlib/Topology/Algebra/Polynomial.lean:88:protected theorem continuousWithinAt_aeval {s a} :
Mathlib/Topology/Alg

$ /bin/bash -lc "rg -n \"finiteDifference|forward.*difference|difference.*Polynomial|eval.*add_one.*sub.*eval|iterate.*fun.*f.*x \\+ 1\" Mathlib/Algebra/Polynomial Mathlib | head -120"
Mathlib/NumberTheory/Padics/MahlerBasis.lean:117:/-- Bound for iterated forward differences of a continuous function from a compact space to a
Mathlib/NumberTheory/Padics/MahlerBasis.lean:310:The coefficients of a Mahler series can be recovered from the sum by taking forward differences at
Mathlib/Algebra/Group/ForwardDiff.lean:21:We define the forward difference operator, sending `f` to the function `x ↦ f (x + h) - f x` for
Mathlib/Algebra/Group/ForwardDiff.lean:28:  linear combination of forward differences of `f` at `y`, for `n ∈ ℕ`;
Mathlib/Algebra/Group/ForwardDiff.lean:29:* `fwdDiff_iter_eq_sum_shift`: formula expressing the `n`-th forward difference of `f` at `y` as
Mathlib/Algebra/Group/ForwardDiff.lean:32:We also prove some auxiliary results about iterated forward differences of the function
Mathlib/Algebra/Group/ForwardDiff.lean:84:This section contains versions of the forward-difference operator and the shift operator bundled as
Mathlib/Algebra/Group/ForwardDiff.lean:92:/-- Linear-endomorphism version of the forward difference operator. -/
Mathlib/Algebra/Group/ForwardDiff.lean:144:Express the `n`-th forward difference of `f` at `y` in terms of the values `f (y + k)`, for
Mathlib/Algebra/Group/ForwardDiff.lean:172:**Gregory-Newton formula** expressing `f (y + n • h)` in terms of the iterated forward differences
Mathlib/Algebra/Group/ForwardDiff.lean:221:We prove formulae about the forward difference operator applied to polynomials:
Mathlib/Algebra/Group/ForwardDiff.lean:224:  The `n`-th forward difference of the function `x ↦ x^j` is zero if `j < n`;
Mathlib/Algebra/Group/ForwardDiff.lean:226:  The `n`-th forward difference of the function `x ↦ x^n` is the constant function `n!`;
Mathlib/Algebra/Group/ForwardDiff.lean:228:  The `n`-th forward difference of a polynomial of degree `< n` is zero (formulated using explicit
Mathlib/Algebra/Group/ForwardDiff.lean:235:The `n`-th forward difference of the function `x ↦ x^j` is zero if `j < n`.
Mathlib/Algebra/Gr

$ /bin/bash -lc "sed -n '1,330p' Mathlib/Algebra/Group/ForwardDiff.lean"
/-
Copyright (c) 2024 David Loeffler. All rights reserved.
Released under Apache 2.0 license as described in the file LICENSE.
Authors: Giulio Caflisch, David Loeffler, Yu Shao, Weijie Jiang, BeiBei Xiong
-/
module

public import Mathlib.Algebra.BigOperators.Pi
public import Mathlib.Algebra.Group.AddChar
public import Mathlib.Algebra.Module.Submodule.LinearMap
public import Mathlib.Data.Nat.Choose.Sum
public import Mathlib.Tactic.Abel
public import Mathlib.Algebra.GroupWithZero.Action.Pi
public import Mathlib.Algebra.Polynomial.Basic
public import Mathlib.Algebra.Polynomial.Degree.Defs
public import Mathlib.Algebra.Polynomial.Eval.Degree

/-!
# Forward difference operators and Newton series

We define the forward difference operator, sending `f` to the function `x ↦ f (x + h) - f x` for
a given `h` (for any additive semigroup, taking values in an abelian group). The notation `Δ_[h]` is
defined for this operator, scoped in namespace `fwdDiff`.

We prove two key formulae about this operator:

* `shift_eq_sum_fwdDiff_iter`: the **Gregory-Newton formula**, expressing `f (y + n • h)` as a
  linear combination of forward differences of `f` at `y`, for `n ∈ ℕ`;
* `fwdDiff_iter_eq_sum_shift`: formula expressing the `n`-th forward difference of `f` at `y` as
  a linear combination of `f (y + k • h)` for `0 ≤ k ≤ n`.

We also prove some auxiliary results about iterated forward differences of the function
`n ↦ n.choose k`.
-/

@[expose] public section

open Finset Nat Function Polynomial

variable {M G : Type*} [AddCommMonoid M] [AddCommGroup G] (h : M)

/--
Forward difference operator, `fwdDiff h f n = f (n + h) - f n`. The notation `Δ_[h]` for this
operator is available in the `fwdDiff` namespace.
-/
def fwdDiff (h : M) (f : M → G) : M → G := fun n ↦ f (n + h) - f n

@[inherit_doc] scoped[fwdDiff] notation "Δ_[" h "]" => fwdDiff h

open fwdDiff

@[simp] lemma fwdDiff_add (h : M) (f g : M → G) :
    Δ_[h] (f + g) = Δ_[h] f + Δ_[h] g :=
  add_sub_add_comm ..

@[simp] lemma fwd

$ /bin/bash -lc 'rg -n "norm_eval_le|abs_eval_le|eval.*le.*sum|norm.*eval.*sum|eval_le" Mathlib/Algebra/Polynomial Mathlib/Analysis | head -120'
Mathlib/Analysis/Polynomial/Order.lean:24:  `eval_le_zero_of_roots_le_of_leadingCoeff_nonpos`:
Mathlib/Analysis/Polynomial/Order.lean:29:  `negOnePow_mul_eval_le_zero_of_le_roots_of_leadingCoeff_nonpos`:
Mathlib/Analysis/Polynomial/Order.lean:77:theorem eval_le_zero_of_roots_le_of_leadingCoeff_nonpos
Mathlib/Analysis/Polynomial/Order.lean:125:theorem negOnePow_mul_eval_le_zero_of_le_roots_of_leadingCoeff_nonpos
Mathlib/Analysis/Polynomial/Fourier.lean:29:- `Polynomial.sum_sq_norm_coeff_eq_circleAverage`: Parseval's identity that the sum of the squares
Mathlib/Analysis/Polynomial/Basic.lean:374:lemma finite_abs_eval_le_of_degree_lt {P Q : ℤ[X]} (h : Q.degree < P.degree) :
Mathlib/Analysis/Polynomial/Basic.lean:391:  refine (h.sdiff (finite_abs_eval_le_of_degree_lt degR)).mono fun x mx ↦ ?_
Mathlib/Analysis/Analytic/ChangeOrigin.lean:323:      rw [p.changeOrigin_eval (hz.trans_le hf.r_le), add_assoc, hf.sum]
Mathlib/Analysis/SpecialFunctions/Pochhammer.lean:26:* `descPochhammer_eval_le_sum_descFactorial` is a special case of **Jensen's inequality**
Mathlib/Analysis/SpecialFunctions/Pochhammer.lean:29:* `descPochhammer_eval_div_factorial_le_sum_choose` is a special case of **Jensen's inequality**
Mathlib/Analysis/SpecialFunctions/Pochhammer.lean:95:theorem descPochhammer_eval_le_sum_descFactorial
Mathlib/Analysis/SpecialFunctions/Pochhammer.lean:107:theorem descPochhammer_eval_div_factorial_le_sum_choose
Mathlib/Analysis/SpecialFunctions/Pochhammer.lean:115:  exact descPochhammer_eval_le_sum_descFactorial hn p w h₀ h₁ h_avg
Mathlib/Analysis/Normed/Module/PiTensorProduct/InjectiveSeminorm.lean:59:    (fun f ↦ by simpa [mul_comm] using norm_eval_le_projectiveSeminorm f x)
Mathlib/Analysis/Normed/Module/PiTensorProduct/InjectiveSeminorm.lean:73:prove in `PiTensorProduct.norm_eval_le_injectiveSeminorm` that this gives the same result.
Mathlib/Analysis/Normed/Module/PiTensorProduct/InjectiveSeminorm.lean:109:theorem norm_eval_le_injectiveSeminorm (f : ContinuousMultilinearM

$ /bin/bash -lc "cat >/tmp/Check.lean <<'EOF'
import Mathlib
#check Polynomial.X_dvd_iff
#check Polynomial.dvd_iff_isRoot
#check Polynomial.eq_X_mul_divByMonic
#check Polynomial.X_mul_divByMonic_eq
#check Polynomial.eval_eq_sum_range
#check Polynomial.natDegree_bernoulli
#check Polynomial.natDegree_mul_le
#check Polynomial.natDegree_euler
EOF
lake env lean /tmp/Check.lean"
Polynomial.X_dvd_iff.{u} {R : Type u} [Semiring R] {f : Polynomial R} : Polynomial.X ∣ f ↔ f.coeff 0 = 0
Polynomial.dvd_iff_isRoot.{u} {R : Type u} {a : R} [CommRing R] {p : Polynomial R} :
  Polynomial.X - Polynomial.C a ∣ p ↔ p.IsRoot a
/tmp/Check.lean:4:7: error(lean.unknownIdentifier): Unknown constant `Polynomial.eq_X_mul_divByMonic`
/tmp/Check.lean:5:7: error(lean.unknownIdentifier): Unknown constant `Polynomial.X_mul_divByMonic_eq`
Polynomial.eval_eq_sum_range.{u} {R : Type u} [Semiring R] {p : Polynomial R} (x : R) :
  Polynomial.eval x p = ∑ i ∈ Finset.range (p.natDegree + 1), p.coeff i * x ^ i
/tmp/Check.lean:7:7: error(lean.unknownIdentifier): Unknown constant `Polynomial.natDegree_bernoulli`
Polynomial.natDegree_mul_le.{u} {R : Type u} [Semiring R] {p q : Polynomial R} :
  (p * q).natDegree ≤ p.natDegree + q.natDegree
/tmp/Check.lean:9:7: error(lean.unknownIdentifier): Unknown constant `Polynomial.natDegree_euler`

$ /bin/bash -lc "cat >/tmp/Check.lean <<'EOF'
import Mathlib
#check Polynomial.natDegree_comp
#check Polynomial.natDegree_X_add_C
#check Polynomial.leadingCoeff_comp
#check Polynomial.leadingCoeff_add_of_same_natDegree
#check Polynomial.leadingCoeff_add
#check Polynomial.coeff_natDegree
#check Polynomial.natDegree_add_eq_left_of_natDegree_lt
#check Polynomial.natDegree_add_le
#check Polynomial.natDegree_X_pow
#check Polynomial.natDegree_C_mul_X_pow
EOF
lake env lean /tmp/Check.lean"
Polynomial.natDegree_comp.{u} {R : Type u} [Semiring R] {p q : Polynomial R} [NoZeroDivisors R] :
  (p.comp q).natDegree = p.natDegree * q.natDegree
Polynomial.natDegree_X_add_C.{u} {R : Type u} [Nontrivial R] [Semiring R] (x : R) :
  (Polynomial.X + Polynomial.C x).natDegree = 1
Polynomial.leadingCoeff_comp.{u} {R : Type u} [Semiring R] {p q : Polynomial R} [NoZeroDivisors R]
  (hq : q.natDegree ≠ 0) : (p.comp q).leadingCoeff = p.leadingCoeff * q.leadingCoeff ^ p.natDegree
/tmp/Check.lean:5:7: error(lean.unknownIdentifier): Unknown constant `Polynomial.leadingCoeff_add_of_same_natDegree`
/tmp/Check.lean:6:7: error(lean.unknownIdentifier): Unknown constant `Polynomial.leadingCoeff_add`
Polynomial.coeff_natDegree.{u} {R : Type u} [Semiring R] {p : Polynomial R} : p.coeff p.natDegree = p.leadingCoeff
Polynomial.natDegree_add_eq_left_of_natDegree_lt.{u} {R : Type u} [Semiring R] {p q : Polynomial R}
  (h : q.natDegree < p.natDegree) : (p + q).natDegree = p.natDegree
Polynomial.natDegree_add_le.{u} {R : Type u} [Semiring R] (p q : Polynomial R) :
  (p + q).natDegree ≤ max p.natDegree q.natDegree
Polynomial.natDegree_X_pow.{u} {R : Type u} [Semiring R] [Nontrivial R] (n : ℕ) : (Polynomial.X ^ n).natDegree = n
Polynomial.natDegree_C_mul_X_pow.{u} {R : Type u} [Semiring R] (n : ℕ) (a : R) (ha : a ≠ 0) :
  (Polynomial.C a * Polynomial.X ^ n).natDegree = n

$ /bin/bash -lc 'lake env lean ENOTV/Euler.lean'
Try this:
  [apply] ring_nf
  
  The `ring` tactic failed to close the goal. Use `ring_nf` to obtain a normal form.
    
  Note that `ring` works primarily in *commutative* rings. If you have a noncommutative ring, abelian group or module, consider using `noncomm_ring`, `abel` or `module` instead.
ENOTV/Euler.lean:58:35: error: Tactic `rewrite` failed: Did not find an occurrence of the pattern
  (X + C ?x).natDegree
in the target expression
  (eulerPoly d).natDegree * (X + 1).natDegree = n

d : ℕ
hle : ¬(eulerPoly d).natDegree ≤ d
hdn : d < (eulerPoly d).natDegree
n : ℕ := (eulerPoly d).natDegree
hn0 : n ≠ 0
⊢ (eulerPoly d).natDegree * (X + 1).natDegree = n
ENOTV/Euler.lean:64:6: error: `simp` made no progress
ENOTV/Euler.lean:65:4: error: unsolved goals
d : ℕ
hle : ¬(eulerPoly d).natDegree ≤ d
hdn : d < (eulerPoly d).natDegree
n : ℕ := (eulerPoly d).natDegree
hn0 : n ≠ 0
htrans : ((eulerPoly d).comp (X + 1)).natDegree = n
⊢ ¬(X + 1).natDegree = 0
ENOTV/Euler.lean:69:49: error: Tactic `rewrite` failed: Did not find an occurrence of the pattern
  n
in the target expression
  (eulerPoly d).leadingCoeff + (eulerPoly d).coeff ((eulerPoly d).comp (X + 1)).natDegree =
    (C 2 * X ^ d).coeff ((eulerPoly d).comp (X + 1)).natDegree

d : ℕ
hle : ¬(eulerPoly d).natDegree ≤ d
hdn : d < (eulerPoly d).natDegree
n : ℕ := (eulerPoly d).natDegree
hn0 : n ≠ 0
htrans : ((eulerPoly d).comp (X + 1)).natDegree = n
hlc : ((eulerPoly d).comp (X + 1)).leadingCoeff = (eulerPoly d).leadingCoeff
hc :
  (eulerPoly d).leadingCoeff + (eulerPoly d).coeff ((eulerPoly d).comp (X + 1)).natDegree =
    (C 2 * X ^ d).coeff ((eulerPoly d).comp (X + 1)).natDegree
⊢ False
ENOTV/Euler.lean:125:6: warning: Used `tac1 <;> tac2` where `(tac1; tac2)` would suffice

Note: This linter can be disabled with `set_option linter.unnecessarySeqFocus false`

$ /bin/bash -lc "cat >/tmp/Check.lean <<'EOF'
import Mathlib
#check Polynomial.leadingCoeff_X_add_C
#check Polynomial.leadingCoeff_X_add
#check Polynomial.coeff_C_mul
#check Polynomial.coeff_C_mul_X_pow
EOF
lake env lean /tmp/Check.lean"
Polynomial.leadingCoeff_X_add_C.{v} {S : Type v} [Semiring S] (r : S) : (Polynomial.X + Polynomial.C r).leadingCoeff = 1
/tmp/Check.lean:3:7: error(lean.unknownIdentifier): Unknown constant `Polynomial.leadingCoeff_X_add`
Polynomial.coeff_C_mul.{u} {R : Type u} {a : R} {n : ℕ} [Semiring R] (p : Polynomial R) :
  (Polynomial.C a * p).coeff n = a * p.coeff n
Polynomial.coeff_C_mul_X_pow.{u} {R : Type u} [Semiring R] (x : R) (k n : ℕ) :
  (Polynomial.C x * Polynomial.X ^ k).coeff n = if n = k then x else 0

$ /bin/bash -lc 'lake env lean ENOTV/Euler.lean'
Try this:
  [apply] ring_nf
  
  The `ring` tactic failed to close the goal. Use `ring_nf` to obtain a normal form.
    
  Note that `ring` works primarily in *commutative* rings. If you have a noncommutative ring, abelian group or module, consider using `noncomm_ring`, `abel` or `module` instead.
ENOTV/Euler.lean:61:4: error: No goals to be solved
ENOTV/Euler.lean:85:17: error: linarith failed to find a contradiction
case h1
d : ℕ
hle : ¬(eulerPoly d).natDegree ≤ d
hdn : d < (eulerPoly d).natDegree
n : ℕ := (eulerPoly d).natDegree
hn0 : n ≠ 0
hqdeg : (X + 1).natDegree = 1
htrans : ((eulerPoly d).comp (X + 1)).natDegree = n
hlc : ((eulerPoly d).comp (X + 1)).leadingCoeff = (eulerPoly d).leadingCoeff
hcoeffcomp : ((eulerPoly d).comp (X + 1)).coeff n = (eulerPoly d).leadingCoeff
hcoeffself : (eulerPoly d).coeff n = (eulerPoly d).leadingCoeff
hnD : n ≠ d
hc : eulerPoly d = 0
hp : eulerPoly d ≠ 0
hlc0 : (eulerPoly d).leadingCoeff ≠ 0
a✝ : (eulerPoly d).leadingCoeff < 0
⊢ False
failed
ENOTV/Euler.lean:133:6: warning: Used `tac1 <;> tac2` where `(tac1; tac2)` would suffice

Note: This linter can be disabled with `set_option linter.unnecessarySeqFocus false`

$ /bin/bash -lc "nl -ba ENOTV/Euler.lean | sed -n '54,90p'"
54	  let n := (eulerPoly d).natDegree
    55	  have hn0 : n ≠ 0 := by omega
    56	  have hqdeg : (X + (1 : ℚ[X])).natDegree = 1 := by
    57	    simpa only [Polynomial.C_1] using Polynomial.natDegree_X_add_C (1 : ℚ)
    58	  have htrans :
    59	      ((eulerPoly d).comp (X + 1)).natDegree = n := by
    60	    rw [Polynomial.natDegree_comp, hqdeg, mul_one]
    61	    rfl
    62	  have hlc :
    63	      ((eulerPoly d).comp (X + 1)).leadingCoeff =
    64	        (eulerPoly d).leadingCoeff := by
    65	    rw [Polynomial.leadingCoeff_comp (by omega), show X + (1 : ℚ[X]) = X + C 1 by simp,
    66	      Polynomial.leadingCoeff_X_add_C, one_pow, mul_one]
    67	  have hcoeffcomp :
    68	      ((eulerPoly d).comp (X + 1)).coeff n = (eulerPoly d).leadingCoeff := by
    69	    rw [← htrans, Polynomial.coeff_natDegree, hlc]
    70	  have hcoeffself :
    71	      (eulerPoly d).coeff n = (eulerPoly d).leadingCoeff := by
    72	    exact Polynomial.coeff_natDegree
    73	  have hc := congrArg (fun p : ℚ[X] => p.coeff n)
    74	    (eulerPoly_polynomial_identity d)
    75	  simp only [Polynomial.coeff_add] at hc
    76	  rw [hcoeffcomp, hcoeffself] at hc
    77	  have hnD : n ≠ d := by omega
    78	  rw [Polynomial.coeff_C_mul_X_pow] at hc
    79	  simp [hnD] at hc
    80	  have hp : eulerPoly d ≠ 0 := by
    81	    intro hp
    82	    simp [n, hp] at hn0
    83	  have hlc0 : (eulerPoly d).leadingCoeff ≠ 0 :=
    84	    Polynomial.leadingCoeff_ne_zero.mpr hp
    85	  exact hlc0 (by linarith)
    86	
    87	/-- For even degree the Euler polynomial is symmetric about `1/2`. -/
    88	theorem eulerPoly_one_sub (d : ℕ) (hd : Even d) (x : ℚ) :
    89	    (eulerPoly d).eval (1 - x) = (eulerPoly d).eval x := by
    90	  have hodd : Odd (d + 1) := hd.add_one

$ /bin/bash -lc 'lake env lean ENOTV/Euler.lean'
Try this:
  [apply] ring_nf
  
  The `ring` tactic failed to close the goal. Use `ring_nf` to obtain a normal form.
    
  Note that `ring` works primarily in *commutative* rings. If you have a noncommutative ring, abelian group or module, consider using `noncomm_ring`, `abel` or `module` instead.
ENOTV/Euler.lean:130:6: warning: Used `tac1 <;> tac2` where `(tac1; tac2)` would suffice

Note: This linter can be disabled with `set_option linter.unnecessarySeqFocus false`

$ /bin/bash -lc 'lake env lean ENOTV/Euler.lean'
Try this:
  [apply] ring_nf
  
  The `ring` tactic failed to close the goal. Use `ring_nf` to obtain a normal form.
    
  Note that `ring` works primarily in *commutative* rings. If you have a noncommutative ring, abelian group or module, consider using `noncomm_ring`, `abel` or `module` instead.
ENOTV/Euler.lean:118:54: error: unsolved goals
d L : ℕ
t : ℚ
⊢ True ∨ L = 0 ∧ ¬d = 0
ENOTV/Euler.lean:132:14: error(lean.unknownIdentifier): Unknown constant `Polynomial.natDegree_C_le`
ENOTV/Euler.lean:135:15: error(lean.unknownIdentifier): Unknown constant `Polynomial.natDegree_C_mul_X_le`
ENOTV/Euler.lean:141:2: error: omega could not prove the goal:
a possible counterexample may satisfy the constraints
  b ≥ 0
  a ≥ 0
  a - b ≥ 1
where
 a := ↑(blockPolynomial d L).natDegree
 b := ↑d
ENOTV/Euler.lean:161:6: warning: Used `tac1 <;> tac2` where `(tac1; tac2)` would suffice

Note: This linter can be disabled with `set_option linter.unnecessarySeqFocus false`

$ /bin/bash -lc 'rg -n "theorem natDegree_C.*le|lemma natDegree_C.*le|natDegree_C_mul_X" Mathlib/Algebra/Polynomial | head -100'
Mathlib/Algebra/Polynomial/EraseLead.lean:338:      · rw [natDegree_C_mul_X_pow _ _ (leadingCoeff_ne_zero.mpr _)]
Mathlib/Algebra/Polynomial/EraseLead.lean:341:    · exact (natDegree_C_mul_X_pow_le f.leadingCoeff f.natDegree).trans df
Mathlib/Algebra/Polynomial/EraseLead.lean:362:    rw [natDegree_C_mul_X_pow _ _ r0, C_mul_X_pow_eq_monomial, φ_mon_nat _ _ r0]
Mathlib/Algebra/Polynomial/Inductions.lean:100:    · exact natDegree_C_mul_X_pow (n - 1) c c0
Mathlib/Algebra/Polynomial/Reverse.lean:163:      · exact le_trans (natDegree_C_mul_X_pow_le g.leadingCoeff g.natDegree) Og
Mathlib/Algebra/Polynomial/Reverse.lean:172:    · exact le_trans (natDegree_C_mul_X_pow_le f.leadingCoeff f.natDegree) Nf
Mathlib/Algebra/Polynomial/Degree/Defs.lean:210:theorem natDegree_C_mul_X_pow (n : ℕ) (a : R) (ha : a ≠ 0) : natDegree (C a * X ^ n) = n :=
Mathlib/Algebra/Polynomial/Degree/Defs.lean:214:theorem natDegree_C_mul_X (a : R) (ha : a ≠ 0) : natDegree (C a * X) = 1 := by
Mathlib/Algebra/Polynomial/Degree/Defs.lean:215:  simpa only [pow_one] using natDegree_C_mul_X_pow 1 a ha
Mathlib/Algebra/Polynomial/Degree/Defs.lean:222:  · rw [← C_mul_X_pow_eq_monomial, natDegree_C_mul_X_pow i r hr]
Mathlib/Algebra/Polynomial/Degree/Defs.lean:365:theorem natDegree_C_mul_X_pow_le (a : R) (n : ℕ) : natDegree (C a * X ^ n) ≤ n :=
Mathlib/Algebra/Polynomial/Degree/SmallDegree.lean:83:  rw [natDegree_add_C, natDegree_C_mul_X a ha]
Mathlib/Algebra/Polynomial/Degree/Lemmas.lean:95:theorem natDegree_C_mul_le (a : R) (f : R[X]) : (C a * f).natDegree ≤ f.natDegree := by
Mathlib/Algebra/Polynomial/Degree/Lemmas.lean:133:theorem natDegree_C_mul_of_mul_ne_zero (h : a * p.leadingCoeff ≠ 0) :

$ /bin/bash -lc 'lake env lean ENOTV/Euler.lean'
Try this:
  [apply] ring_nf
  
  The `ring` tactic failed to close the goal. Use `ring_nf` to obtain a normal form.
    
  Note that `ring` works primarily in *commutative* rings. If you have a noncommutative ring, abelian group or module, consider using `noncomm_ring`, `abel` or `module` instead.
ENOTV/Euler.lean:122:2: error: unsolved goals
case neg
d L : ℕ
t : ℚ
hL : ¬L = 0
⊢ True ∨ L = 0 ∧ ¬d = 0
ENOTV/Euler.lean:163:6: warning: Used `tac1 <;> tac2` where `(tac1; tac2)` would suffice

Note: This linter can be disabled with `set_option linter.unnecessarySeqFocus false`

$ /bin/bash -lc 'lake env lean ENOTV/Euler.lean'
Try this:
  [apply] ring_nf
  
  The `ring` tactic failed to close the goal. Use `ring_nf` to obtain a normal form.
    
  Note that `ring` works primarily in *commutative* rings. If you have a noncommutative ring, abelian group or module, consider using `noncomm_ring`, `abel` or `module` instead.
ENOTV/Euler.lean:124:15: warning: Used `tac1 <;> tac2` where `(tac1; tac2)` would suffice

Note: This linter can be disabled with `set_option linter.unnecessarySeqFocus false`
ENOTV/Euler.lean:123:4: warning: 'congr 2' tactic does nothing

Note: This linter can be disabled with `set_option linter.unusedTactic false`
ENOTV/Euler.lean:163:6: warning: Used `tac1 <;> tac2` where `(tac1; tac2)` would suffice

Note: This linter can be disabled with `set_option linter.unnecessarySeqFocus false`

$ /bin/bash -lc "sed -n '220,270p' Mathlib/Data/Finsupp/Defs.lean && cat >/tmp/Check.lean <<'EOF'
import Mathlib
#check Finsupp.onFinset_apply
#check Finsupp.onFinset
#check Int.ediv_add_emod
#check Int.ediv_mul_add_emod
#check Int.ediv_mul_cancel
#check Int.emod_lt
EOF
lake env lean /tmp/Check.lean"
Finsupp.onFinset_apply.{u_1, u_4} {α : Type u_1} {M : Type u_4} [Zero M] {s : Finset α} {f : α → M}
  {hf : ∀ (a : α), f a ≠ 0 → a ∈ s} {a : α} : (Finsupp.onFinset s f hf) a = f a
Finsupp.onFinset.{u_1, u_4} {α : Type u_1} {M : Type u_4} [Zero M] (s : Finset α) (f : α → M)
  (hf : ∀ (a : α), f a ≠ 0 → a ∈ s) : α →₀ M
/tmp/Check.lean:4:7: error(lean.unknownIdentifier): Unknown constant `Int.ediv_add_emod`
Int.ediv_mul_add_emod (a b : ℤ) : a / b * b + a % b = a
Int.ediv_mul_cancel {a b : ℤ} (H : b ∣ a) : a / b * b = a
Int.emod_lt (a : ℤ) {b : ℤ} (h : b ≠ 0) : a % b < ↑b.natAbs

$ /bin/bash -lc "cat >/tmp/Check.lean <<'EOF'
import Mathlib
#check Finsupp.embDomain
#check Finsupp.embDomain_apply
#check Finsupp.embDomain_apply_of_notin_range
#check Int.ofNat_injective
#check Int.ofNat_eq_coe
#check Int.eq_ofNat_of_zero_le
EOF
lake env lean /tmp/Check.lean"
Finsupp.embDomain.{u_1, u_2, u_4} {α : Type u_1} {β : Type u_2} {M : Type u_4} [Zero M] (f : α ↪ β) (v : α →₀ M) :
  β →₀ M
Finsupp.embDomain_apply.{u_1, u_2, u_4} {α : Type u_1} {β : Type u_2} {M : Type u_4} [Zero M] (f : α ↪ β) (v : α →₀ M)
  (b : β) : (Finsupp.embDomain f v) b = if h : ∃ a, f a = b then v h.choose else 0
/tmp/Check.lean:4:7: error(lean.unknownIdentifier): Unknown constant `Finsupp.embDomain_apply_of_notin_range`
Int.ofNat_injective : Function.Injective Int.ofNat
Int.ofNat_eq_coe {n : ℕ} : Int.ofNat n = ↑n
Int.eq_ofNat_of_zero_le {a : ℤ} (h : 0 ≤ a) : ∃ n, a = ↑n

$ /bin/bash -lc 'lake build ENOTV.Energy ENOTV.Euler && lake env lean ENOTV/Counterexample.lean'
⚠ [8679/8680] Built ENOTV.Euler (7.7s)
info: ENOTV/Euler.lean:31:2: Try this:
  [apply] ring_nf
  
  The `ring` tactic failed to close the goal. Use `ring_nf` to obtain a normal form.
    
  Note that `ring` works primarily in *commutative* rings. If you have a noncommutative ring, abelian group or module, consider using `noncomm_ring`, `abel` or `module` instead.
warning: ENOTV/Euler.lean:124:15: Used `tac1 <;> tac2` where `(tac1; tac2)` would suffice

Note: This linter can be disabled with `set_option linter.unnecessarySeqFocus false`
warning: ENOTV/Euler.lean:123:4: 'congr 2' tactic does nothing

Note: This linter can be disabled with `set_option linter.unusedTactic false`
warning: ENOTV/Euler.lean:163:6: Used `tac1 <;> tac2` where `(tac1; tac2)` would suffice

Note: This linter can be disabled with `set_option linter.unnecessarySeqFocus false`
⚠ [8680/8680] Built ENOTV.Energy (7.7s)
warning: ENOTV/Energy.lean:158:24: Used `tac1 <;> tac2` where `(tac1; tac2)` would suffice

Note: This linter can be disabled with `set_option linter.unnecessarySeqFocus false`
Build completed successfully (8680 jobs).
ENOTV/Counterexample.lean:41:44: error(lean.invalidField): Invalid field `not_le`: The environment does not contain `Int.NonNeg.not_le`, so it is not possible to project the field `not_le` from an expression
  hi
of type `(0 - (i + 1)).NonNeg`
ENOTV/Counterexample.lean:41:23: error: unsolved goals
f : NSeq
i : ℤ
hi : i < 0
⊢ 0 ≤ i → f i.toNat = 0
ENOTV/Counterexample.lean:119:65: error(lean.invalidField): Invalid field `not_le`: The environment does not contain `Nat.le.not_le`, so it is not possible to project the field `not_le` from an expression
  hr2
of type `(2 * L).succ.le r`
ENOTV/Counterexample.lean:114:6: error: unsolved goals
case pos
d L r : ℕ
h₁ : ¬r < 2 * L
hEq : ¬r = 2 * L
h₄ : r < 4 * L
hr2 : 2 * L < r
hrs2 : ¬r + 1 ≤ 2 * L
hr4 : r ≤ 4 * L
hrs4 : r + 1 ≤ 4 * L
hsub : r + 1 - 2 * L = r - 2 * L + 1
⊢ (blockPrefix d L (2 * L) - (blockPrefix d L (r - 2 * L) +

$ /bin/bash -lc 'lake env lean ENOTV/Counterexample.lean'
ENOTV/Counterexample.lean:128:8: error: unsolved goals
case pos
d L : ℕ
h₁ : ¬4 * L < 2 * L
hEq : ¬4 * L = 2 * L
h₄ : ¬4 * L < 4 * L
hr4 : 4 * L ≤ 4 * L
hr2 : ¬4 * L ≤ 2 * L
hrs2 : ¬4 * L + 1 ≤ 2 * L
hL : 0 < L
h42 : ¬4 * L ≤ 2 * L
h412 : ¬4 * L + 1 ≤ 2 * L
h414 : ¬4 * L + 1 ≤ 4 * L
hsub : 4 * L - 2 * L = 2 * L
⊢ 4 * L < 2 * L → 0 = realBlock d L (4 * L)
ENOTV/Counterexample.lean:111:53: warning: This simp argument is unused:
  h2

Hint: Omit it from the simp argument list.
  [apply] simp [pairDatumNat_apply, pairJumpNat_apply, h4, blockPrefix_succ]

Note: This linter can be disabled with `set_option linter.unusedSimpArgs false`

$ /bin/bash -lc "nl -ba ENOTV/Counterexample.lean | sed -n '120,142p'"
120	        simp [pairDatumNat_apply, pairJumpNat_apply, h₁, h₄, hr2not,
   121	          hrs2, hr4, hrs4, hsub, blockPrefix_succ]
   122	      · have hr4 : 4 * L ≤ r := by omega
   123	        have hr2 : ¬r ≤ 2 * L := by omega
   124	        have hrs2 : ¬r + 1 ≤ 2 * L := by omega
   125	        -- At and beyond the right endpoint both data values vanish.  The
   126	        -- endpoint `r=4L` is already zero by construction.
   127	        by_cases heq : r = 4 * L
   128	        · subst r
   129	          have hL : 0 < L := by omega
   130	          have h42 : ¬4 * L ≤ 2 * L := by omega
   131	          have h412 : ¬4 * L + 1 ≤ 2 * L := by omega
   132	          have h414 : ¬4 * L + 1 ≤ 4 * L := by omega
   133	          have hsub : 4 * L - 2 * L = 2 * L := by omega
   134	          simp [pairDatumNat_apply, pairJumpNat_apply, h42, h412, h414, hsub]
   135	        · have hr4' : ¬r ≤ 4 * L := by omega
   136	          have hrs4 : ¬r + 1 ≤ 4 * L := by omega
   137	          simp [pairDatumNat_apply, pairJumpNat_apply, h₁, h₄, hr2, hrs2,
   138	            hr4', hrs4]
   139	
   140	/-- Integer-lattice compact datum consisting of one positive and one
   141	negative Euler block. -/
   142	def pairDatum (d L : ℕ) : CSeq := liftNat (pairDatumNat d L)

$ /bin/bash -lc 'lake env lean ENOTV/Counterexample.lean'
ENOTV/Counterexample.lean:111:53: warning: This simp argument is unused:
  h2

Hint: Omit it from the simp argument list.
  [apply] simp [pairDatumNat_apply, pairJumpNat_apply, h4, blockPrefix_succ]

Note: This linter can be disabled with `set_option linter.unusedSimpArgs false`
ENOTV/Counterexample.lean:134:59: warning: This simp argument is unused:
  h₄

Hint: Omit it from the simp argument list.
  [apply] simp [pairDatumNat_apply, pairJumpNat_apply, h₁, h42, h412, h414, hsub]

Note: This linter can be disabled with `set_option linter.unusedSimpArgs false`

$ /bin/bash -lc 'rg -n "divByMonic.*X|X.*divByMonic|mul_divByMonic|modByMonic_eq_zero" Mathlib/Algebra/Polynomial | head -100'
Mathlib/Algebra/Polynomial/CoeffMem.lean:101:lemma coeff_divByMonic_mem_pow_natDegree_mul (p q : S[X])
Mathlib/Algebra/Polynomial/CoeffMem.lean:114:lemma idealSpan_range_update_divByMonic (hij : i ≠ j) (v : ι → R[X]) :
Mathlib/Algebra/Polynomial/FieldDivision.lean:76:  conv_lhs => rw [← p.pow_mul_divByMonic_rootMultiplicity_eq t, ← hm]
Mathlib/Algebra/Polynomial/FieldDivision.lean:345:theorem divByMonic_eq_div (p : R[X]) (hq : Monic q) : p /ₘ q = p / q :=
Mathlib/Algebra/Polynomial/FieldDivision.lean:353:  divByMonic_eq_div p (monic_X_sub_C a) ▸ mul_divByMonic_eq_iff_isRoot
Mathlib/Algebra/Polynomial/FieldDivision.lean:631:theorem X_sub_C_mul_divByMonic_eq_sub_modByMonic {K : Type*} [Ring K] (f : K[X]) (a : K) :
Mathlib/Algebra/Polynomial/FieldDivision.lean:635:theorem divByMonic_add_X_sub_C_mul_derivative_divByMonic_eq_derivative
Mathlib/Algebra/Polynomial/FieldDivision.lean:638:  have key := by apply congrArg derivative <| X_sub_C_mul_divByMonic_eq_sub_modByMonic f a
Mathlib/Algebra/Polynomial/FieldDivision.lean:642:theorem X_sub_C_dvd_derivative_of_X_sub_C_dvd_divByMonic {K : Type*} [Field K] (f : K[X]) {a : K}
Mathlib/Algebra/Polynomial/FieldDivision.lean:644:  have key := divByMonic_add_X_sub_C_mul_derivative_divByMonic_eq_derivative f a
Mathlib/Algebra/Polynomial/FieldDivision.lean:658:  have : X - C a ∣ derivative f := X_sub_C_dvd_derivative_of_X_sub_C_dvd_divByMonic f h
Mathlib/Algebra/Polynomial/FieldDivision.lean:659:  rw [← modByMonic_eq_zero_iff_dvd (monic_X_sub_C _), modByMonic_X_sub_C_eq_C_eval] at this
Mathlib/Algebra/Polynomial/Splits.lean:666:    rw [natDegree_divByMonic f (monic_X_sub_C x), h₁, natDegree_X_sub_C]
Mathlib/Algebra/Polynomial/Splits.lean:667:  rw [← mul_divByMonic_eq_iff_isRoot.mpr h₂, splits_mul (X_sub_C_ne_zero x) (by aesop)]
Mathlib/Algebra/Polynomial/RingDivision.lean:73:  LinearMap.mem_ker.trans (modByMonic_eq_zero_iff_dvd hq)
Mathlib/Algebra/Polynomial/RingDivision.lean:310:        rw [← mul_divByMonic_eq_iff_isRoot.2 hx, h, mul

$ /bin/bash -lc 'lake env lean ENOTV/Counterexample.lean'
ENOTV/Counterexample.lean:111:53: warning: This simp argument is unused:
  h2

Hint: Omit it from the simp argument list.
  [apply] simp [pairDatumNat_apply, pairJumpNat_apply, h4, blockPrefix_succ]

Note: This linter can be disabled with `set_option linter.unusedSimpArgs false`
ENOTV/Counterexample.lean:134:59: warning: This simp argument is unused:
  h₄

Hint: Omit it from the simp argument list.
  [apply] simp [pairDatumNat_apply, pairJumpNat_apply, h₁, h42, h412, h414, hsub]

Note: This linter can be disabled with `set_option linter.unusedSimpArgs false`
ENOTV/Counterexample.lean:172:2: error: No goals to be solved
ENOTV/Counterexample.lean:192:37: warning: `Finsupp.finset_sum_apply` has been deprecated: Use `Finsupp.finsetSum_apply` instead
ENOTV/Counterexample.lean:194:6: error: Tactic `rewrite` failed: Did not find an occurrence of the pattern
  ∑ x ∈ ?m.14, (?f x - ?g x)
in the target expression
  ∑ i_1 ∈ Finset.range P, ((translate (4 * ↑L * ↑i_1)) (pairDatum d L)) (i + 1) -
      ∑ i_1 ∈ Finset.range P, ((translate (4 * ↑L * ↑i_1)) (pairDatum d L)) i =
    ∑ i_1 ∈ Finset.range P, ((translate (4 * ↑L * ↑i_1)) (pairJumps d L)) i

d L P : ℕ
i : ℤ
⊢ ∑ i_1 ∈ Finset.range P, ((translate (4 * ↑L * ↑i_1)) (pairDatum d L)) (i + 1) -
      ∑ i_1 ∈ Finset.range P, ((translate (4 * ↑L * ↑i_1)) (pairDatum d L)) i =
    ∑ i_1 ∈ Finset.range P, ((translate (4 * ↑L * ↑i_1)) (pairJumps d L)) i
ENOTV/Counterexample.lean:193:4: warning: This simp argument is unused:
  map_sum

Hint: Omit it from the simp argument list.
  [apply] simp only [multiDatum, multiJumps, Finsupp.finset_sum_apply, cdiff_apply, Finset.sum_apply]

Note: This linter can be disabled with `set_option linter.unusedSimpArgs false`
ENOTV/Counterexample.lean:193:13: warning: This simp argument is unused:
  Finset.sum_apply

Hint: Omit it from the simp argument list.
  [apply] simp only [multiDatum, multiJumps, Finsupp.finset_sum_apply, cdiff_apply, map_sum]

Note: This linter can be disabled with `set_option 

$ /bin/bash -lc "nl -ba ENOTV/Counterexample.lean | sed -n '162,250p'"
162	/-! ## Concatenating block pairs -/
   163	
   164	/-- Translate a compact integer sequence to the right by `c`. -/
   165	def translate (c : ℤ) : CSeq ≃+ CSeq :=
   166	  Finsupp.domCongr (Equiv.addRight c)
   167	
   168	@[simp] theorem translate_apply (c : ℤ) (f : CSeq) (i : ℤ) :
   169	    translate c f i = f (i - c) := by
   170	  simp [translate]
   171	  congr 1
   172	  omega
   173	
   174	theorem cdiff_translate (c : ℤ) (f : CSeq) :
   175	    cdiff (translate c f) = translate c (cdiff f) := by
   176	  ext i
   177	  simp [cdiff_apply]
   178	  congr 1
   179	  omega
   180	
   181	/-- `P` consecutive positive/negative pairs, i.e. `2P` alternating
   182	Euler-polynomial blocks. -/
   183	def multiDatum (d L P : ℕ) : CSeq :=
   184	  ∑ p ∈ Finset.range P, translate (4 * L * p) (pairDatum d L)
   185	
   186	def multiJumps (d L P : ℕ) : CSeq :=
   187	  ∑ p ∈ Finset.range P, translate (4 * L * p) (pairJumps d L)
   188	
   189	theorem cdiff_multiDatum (d L P : ℕ) :
   190	    cdiff (multiDatum d L P) = multiJumps d L P := by
   191	  ext i
   192	  simp only [multiDatum, multiJumps, Finsupp.finset_sum_apply, cdiff_apply,
   193	    map_sum, Finset.sum_apply]
   194	  rw [Finset.sum_sub_distrib]
   195	  apply Finset.sum_congr rfl
   196	  intro p hp
   197	  rw [← cdiff_apply, cdiff_translate, cdiff_pairDatum]
   198	
   199	theorem pairJumps_support (d L : ℕ) :
   200	    (pairJumps d L).support ⊆ Finset.Ico 0 (4 * L) := by
   201	  intro i hi
   202	  have hval := Finsupp.mem_support_iff.mp hi
   203	  by_cases hi0 : 0 ≤ i
   204	  · obtain ⟨r, rfl⟩ := Int.eq_ofNat_of_zero_le hi0
   205	    simp only [pairJumps, liftNat_apply_nat, pairJumpNat_apply] at hval
   206	    simp only [Finset.mem_Ico]
   207	    constructor
   208	    · omega
   209	    · by_contra h
   210	      simp [show ¬r < 2 * L by omega, show ¬r < 4 * L by omega] at hval
   211	  · have hineg : i < 0 := lt_of_not_ge hi0
   212	    simp [pairJumps, liftNat_apply_of_neg _ hineg] at hva

$ /bin/bash -lc 'lake env lean ENOTV/Counterexample.lean'
ENOTV/Counterexample.lean:111:53: warning: This simp argument is unused:
  h2

Hint: Omit it from the simp argument list.
  [apply] simp [pairDatumNat_apply, pairJumpNat_apply, h4, blockPrefix_succ]

Note: This linter can be disabled with `set_option linter.unusedSimpArgs false`
ENOTV/Counterexample.lean:134:59: warning: This simp argument is unused:
  h₄

Hint: Omit it from the simp argument list.
  [apply] simp [pairDatumNat_apply, pairJumpNat_apply, h₁, h42, h412, h414, hsub]

Note: This linter can be disabled with `set_option linter.unusedSimpArgs false`
ENOTV/Counterexample.lean:169:35: error: unsolved goals
c : ℤ
f : CSeq
i : ℤ
⊢ f (i + -c) = f (i - c)
ENOTV/Counterexample.lean:238:4: error: omega could not prove the goal:
a possible counterexample may satisfy the constraints
  g - h ≥ 0
  g - j ≥ 0
  f ≥ 0
  e ≥ 0
  c ≥ 1
  4*c - e + f ≤ 0
  4*c - g + j ≥ 1
  4*c - g + h ≥ 1
  b ≥ 0
  a ≥ 0
  a - b ≥ 1
where
 a := ↑q
 b := ↑p
 c := ↑L
 e := ↑(4 * L) * ↑q
 f := ↑(4 * L) * ↑p
 g := i
 h := 4 * ↑L * ↑p
 j := 4 * ↑L * ↑q
ENOTV/Counterexample.lean:253:4: error: omega could not prove the goal:
a possible counterexample may satisfy the constraints
  g - h ≥ 0
  g - j ≥ 0
  f ≥ 0
  e ≥ 0
  c ≥ 1
  4*c - e + f ≤ 0
  4*c - g + j ≥ 1
  4*c - g + h ≥ 1
  b ≥ 0
  a ≥ 0
  a - b ≥ 1
where
 a := ↑p
 b := ↑q
 c := ↑L
 e := ↑(4 * L) * ↑p
 f := ↑(4 * L) * ↑q
 g := i
 h := 4 * ↑L * ↑p
 j := 4 * ↑L * ↑q

$ /bin/bash -lc 'lake env lean ENOTV/Counterexample.lean'
ENOTV/Counterexample.lean:111:53: warning: This simp argument is unused:
  h2

Hint: Omit it from the simp argument list.
  [apply] simp [pairDatumNat_apply, pairJumpNat_apply, h4, blockPrefix_succ]

Note: This linter can be disabled with `set_option linter.unusedSimpArgs false`
ENOTV/Counterexample.lean:134:59: warning: This simp argument is unused:
  h₄

Hint: Omit it from the simp argument list.
  [apply] simp [pairDatumNat_apply, pairJumpNat_apply, h₁, h42, h412, h414, hsub]

Note: This linter can be disabled with `set_option linter.unusedSimpArgs false`

$ /bin/bash -lc "rg -n \"sum_add.*disjoint|disjoint.*sum_add|sum.*support_add_eq|support_add_eq.*sum\" Mathlib/Data/Finsupp Mathlib/Algebra/BigOperators/Finsupp | head -100 && cat >/tmp/Check.lean <<'EOF'
import Mathlib
#check Finsupp.support_add_eq
#check Finsupp.support_add_eq_union
#check Finsupp.sum_of_support_subset
#check Finset.sum_union
EOF
lake env lean /tmp/Check.lean"
Finsupp.support_add_eq.{u_1, u_3} {ι : Type u_1} {M : Type u_3} [AddZeroClass M] {g₁ g₂ : ι →₀ M} [DecidableEq ι]
  (h : Disjoint g₁.support g₂.support) : (g₁ + g₂).support = g₁.support ∪ g₂.support
Finsupp.support_add_eq_union.{u_1, u_3} {ι : Type u_1} {α : Type u_3} [AddCommMonoid α] [PartialOrder α]
  [CanonicallyOrderedAdd α] [Sub α] [OrderedSub α] {f1 f2 : ι →₀ α} [DecidableEq ι] :
  (f1 + f2).support = f1.support ∪ f2.support
Finsupp.sum_of_support_subset.{u_1, u_8, u_10} {α : Type u_1} {M : Type u_8} {N : Type u_10} [Zero M] [AddCommMonoid N]
  (f : α →₀ M) {s : Finset α} (hs : f.support ⊆ s) (g : α → M → N) (h : ∀ i ∈ s, g i 0 = 0) :
  f.sum g = ∑ x ∈ s, g x (f x)
Finset.sum_union.{u_1, u_4} {ι : Type u_1} {M : Type u_4} {s₁ s₂ : Finset ι} [AddCommMonoid M] {f : ι → M}
  [DecidableEq ι] (h : Disjoint s₁ s₂) : ∑ x ∈ s₁ ∪ s₂, f x = ∑ x ∈ s₁, f x + ∑ x ∈ s₂, f x

$ /bin/bash -lc 'lake build ENOTV.Counterexample && lake env lean ENOTV/Estimates.lean'
⚠ [8679/8681] Replayed ENOTV.Energy
warning: ENOTV/Energy.lean:158:24: Used `tac1 <;> tac2` where `(tac1; tac2)` would suffice

Note: This linter can be disabled with `set_option linter.unnecessarySeqFocus false`
⚠ [8680/8681] Replayed ENOTV.Euler
info: ENOTV/Euler.lean:31:2: Try this:
  [apply] ring_nf
  
  The `ring` tactic failed to close the goal. Use `ring_nf` to obtain a normal form.
    
  Note that `ring` works primarily in *commutative* rings. If you have a noncommutative ring, abelian group or module, consider using `noncomm_ring`, `abel` or `module` instead.
warning: ENOTV/Euler.lean:124:15: Used `tac1 <;> tac2` where `(tac1; tac2)` would suffice

Note: This linter can be disabled with `set_option linter.unnecessarySeqFocus false`
warning: ENOTV/Euler.lean:123:4: 'congr 2' tactic does nothing

Note: This linter can be disabled with `set_option linter.unusedTactic false`
warning: ENOTV/Euler.lean:163:6: Used `tac1 <;> tac2` where `(tac1; tac2)` would suffice

Note: This linter can be disabled with `set_option linter.unnecessarySeqFocus false`
⚠ [8681/8681] Built ENOTV.Counterexample (6.5s)
warning: ENOTV/Counterexample.lean:111:53: This simp argument is unused:
  h2

Hint: Omit it from the simp argument list.
  [apply] simp [pairDatumNat_apply, pairJumpNat_apply, h4, blockPrefix_succ]

Note: This linter can be disabled with `set_option linter.unusedSimpArgs false`
warning: ENOTV/Counterexample.lean:134:59: This simp argument is unused:
  h₄

Hint: Omit it from the simp argument list.
  [apply] simp [pairDatumNat_apply, pairJumpNat_apply, h₁, h42, h412, h414, hsub]

Note: This linter can be disabled with `set_option linter.unusedSimpArgs false`
Build completed successfully (8681 jobs).
ENOTV/Estimates.lean:38:6: error: gcongr did not make progress
ENOTV/Estimates.lean:66:6: warning: 'push_cast' tactic does nothing

Note: This linter can be disabled with `set_option linter.unusedTactic false`
ENOTV/Estimates.lean:71:2: error: mod_cast has type
  |blockPoly d

$ /bin/bash -lc "cat >/tmp/Check.lean <<'EOF'
import Mathlib
#check mul_le_of_le_one_right
#check mul_le_of_le_one_left
#check mul_le_mul_of_nonneg_left
#check pow_le_one₀
EOF
lake env lean /tmp/Check.lean"
mul_le_of_le_one_right.{u_1} {α : Type u_1} [MulOneClass α] [Zero α] {a b : α} [Preorder α] [PosMulMono α] (ha : 0 ≤ a)
  (h : b ≤ 1) : a * b ≤ a
mul_le_of_le_one_left.{u_1} {α : Type u_1} [MulOneClass α] [Zero α] {a b : α} [Preorder α] [MulPosMono α] (hb : 0 ≤ b)
  (h : a ≤ 1) : a * b ≤ b
mul_le_mul_of_nonneg_left.{u_1} {α : Type u_1} [Mul α] [Zero α] [Preorder α] {a b c : α} [PosMulMono α] (hbc : b ≤ c)
  (ha : 0 ≤ a) : a * b ≤ a * c
pow_le_one₀.{u_2} {M₀ : Type u_2} [MonoidWithZero M₀] [Preorder M₀] {a : M₀} [PosMulMono M₀] {n : ℕ} (ha₀ : 0 ≤ a)
  (ha₁ : a ≤ 1) : a ^ n ≤ 1

$ /bin/bash -lc 'lake env lean ENOTV/Estimates.lean'
ENOTV/Estimates.lean:66:6: warning: 'push_cast' tactic does nothing

Note: This linter can be disabled with `set_option linter.unusedTactic false`
ENOTV/Estimates.lean:74:2: error: Type mismatch
  abs_blockPoly_le d L t hL ht
has type
  |blockPoly d L ↑t| ≤ eulerUpper d * ↑L ^ d
but is expected to have type
  |blockPoly d L ↑t| ≤ eulerUpper d * ↑(L ^ d)

$ /bin/bash -lc 'lake env lean ENOTV/Estimates.lean'
ENOTV/Estimates.lean:66:6: warning: 'push_cast' tactic does nothing

Note: This linter can be disabled with `set_option linter.unusedTactic false`

$ /bin/bash -lc 'lake env lean ENOTV/Counterexample.lean'
ENOTV/Counterexample.lean:111:53: warning: This simp argument is unused:
  h2

Hint: Omit it from the simp argument list.
  [apply] simp [pairDatumNat_apply, pairJumpNat_apply, h4, blockPrefix_succ]

Note: This linter can be disabled with `set_option linter.unusedSimpArgs false`
ENOTV/Counterexample.lean:134:59: warning: This simp argument is unused:
  h₄

Hint: Omit it from the simp argument list.
  [apply] simp [pairDatumNat_apply, pairJumpNat_apply, h₁, h42, h412, h414, hsub]

Note: This linter can be disabled with `set_option linter.unusedSimpArgs false`
ENOTV/Counterexample.lean:345:37: error: Type mismatch: After simplification, term
  hp
 has type
  p < P
but is expected to have type
  P ≤ p → (pairDatum d L) (i - 4 * ↑L * ↑p) = 0
ENOTV/Counterexample.lean:356:4: warning: `push_neg` has been deprecated. Prefer using `push Not` instead.
If you'd rather continue using `push_neg` in your project, you can implement it as follows:
```
open Lean.Parser.Tactic in
macro "push_neg" cfg:optConfig loc:(location)? : tactic =>
  `(tactic| push $cfg:optConfig Not $[$loc]?)
```
ENOTV/Counterexample.lean:356:2: error: unsolved goals
case neg
d L P : ℕ
i : ℤ
hex : ∀ p ∈ Finset.range P, ((translate (4 * ↑L * ↑p)) (pairDatum d L)) i = 0
⊢ |∑ x ∈ Finset.range P, (pairDatum d L) (i - 4 * ↑L * ↑x)| ≤ camplitude (pairDatum d L)
ENOTV/Counterexample.lean:357:10: warning: This simp argument is unused:
  hex

Hint: Omit it from the simp argument list.
  [apply] simp [camplitude_nonneg]

Note: This linter can be disabled with `set_option linter.unusedSimpArgs false`
ENOTV/Counterexample.lean:357:15: warning: This simp argument is unused:
  camplitude_nonneg

Hint: Omit it from the simp argument list.
  [apply] simp [hex]

Note: This linter can be disabled with `set_option linter.unusedSimpArgs false`

$ /bin/bash -lc "cat >/tmp/Check.lean <<'EOF'
import Mathlib
#check Finset.sum_eq_single
#check Finset.sum_eq_zero
EOF
lake env lean /tmp/Check.lean"
Finset.sum_eq_single.{u_1, u_4} {ι : Type u_1} {M : Type u_4} [AddCommMonoid M] {s : Finset ι} {f : ι → M} (a : ι)
  (h₀ : ∀ b ∈ s, b ≠ a → f b = 0) (h₁ : a ∉ s → f a = 0) : ∑ x ∈ s, f x = f a
Finset.sum_eq_zero.{u_1, u_4} {ι : Type u_1} {M : Type u_4} {s : Finset ι} [AddCommMonoid M] {f : ι → M}
  (h : ∀ x ∈ s, f x = 0) : ∑ x ∈ s, f x = 0

$ /bin/bash -lc 'lake env lean ENOTV/Counterexample.lean'
ENOTV/Counterexample.lean:111:53: warning: This simp argument is unused:
  h2

Hint: Omit it from the simp argument list.
  [apply] simp [pairDatumNat_apply, pairJumpNat_apply, h4, blockPrefix_succ]

Note: This linter can be disabled with `set_option linter.unusedSimpArgs false`
ENOTV/Counterexample.lean:134:59: warning: This simp argument is unused:
  h₄

Hint: Omit it from the simp argument list.
  [apply] simp [pairDatumNat_apply, pairJumpNat_apply, h₁, h42, h412, h414, hsub]

Note: This linter can be disabled with `set_option linter.unusedSimpArgs false`
ENOTV/Counterexample.lean:356:4: warning: `push_neg` has been deprecated. Prefer using `push Not` instead.
If you'd rather continue using `push_neg` in your project, you can implement it as follows:
```
open Lean.Parser.Tactic in
macro "push_neg" cfg:optConfig loc:(location)? : tactic =>
  `(tactic| push $cfg:optConfig Not $[$loc]?)
```
ENOTV/Counterexample.lean:360:8: error: Tactic `rewrite` failed: Did not find an occurrence of the pattern
  0
in the target expression
  |∑ i_1 ∈ Finset.range P, ((translate (4 * ↑L * ↑i_1)) (pairDatum d L)) i| ≤ camplitude (pairDatum d L)

case neg
d L P : ℕ
i : ℤ
hex : ∀ p ∈ Finset.range P, ((translate (4 * ↑L * ↑p)) (pairDatum d L)) i = 0
hz : ∑ p ∈ Finset.range P, ((translate (4 * ↑L * ↑p)) (pairDatum d L)) i = 0
⊢ |∑ i_1 ∈ Finset.range P, ((translate (4 * ↑L * ↑i_1)) (pairDatum d L)) i| ≤ camplitude (pairDatum d L)

$ /bin/bash -lc 'lake env lean ENOTV/Counterexample.lean'
ENOTV/Counterexample.lean:111:53: warning: This simp argument is unused:
  h2

Hint: Omit it from the simp argument list.
  [apply] simp [pairDatumNat_apply, pairJumpNat_apply, h4, blockPrefix_succ]

Note: This linter can be disabled with `set_option linter.unusedSimpArgs false`
ENOTV/Counterexample.lean:134:59: warning: This simp argument is unused:
  h₄

Hint: Omit it from the simp argument list.
  [apply] simp [pairDatumNat_apply, pairJumpNat_apply, h₁, h42, h412, h414, hsub]

Note: This linter can be disabled with `set_option linter.unusedSimpArgs false`
ENOTV/Counterexample.lean:356:4: warning: `push_neg` has been deprecated. Prefer using `push Not` instead.
If you'd rather continue using `push_neg` in your project, you can implement it as follows:
```
open Lean.Parser.Tactic in
macro "push_neg" cfg:optConfig loc:(location)? : tactic =>
  `(tactic| push $cfg:optConfig Not $[$loc]?)
```

$ /bin/bash -lc 'rg -n "eval_eq_zero.*card|card.*eval_eq_zero|natDegree_lt.*eval|eq_zero.*eval.*Finset|eval.*zero.*natDegree" Mathlib/Algebra/Polynomial | head -120'
Mathlib/Algebra/Polynomial/Splits.lean:406:  simp [coeff_zero_eq_eval_zero, eval_multiset_prod, hf.natDegree_eq_card_roots,
Mathlib/Algebra/Polynomial/Splits.lean:446:    obtain ⟨a, ha⟩ := Splits.exists_eval_eq_zero h (degree_ne_of_natDegree_ne <| hn ▸ by simp)
Mathlib/Algebra/Polynomial/RingDivision.lean:137:lemma _root_.Irreducible.aeval_ne_zero_of_natDegree_ne_one [IsDomain R] [Ring S] [Algebra R S]
Mathlib/Algebra/Polynomial/Roots.lean:722:lemma eq_zero_of_natDegree_lt_card_of_eval_eq_zero {R} [CommRing R] [IsDomain R]
Mathlib/Algebra/Polynomial/Roots.lean:741:lemma eq_of_natDegree_lt_card_of_eval_eq {R} [CommRing R] [IsDomain R]
Mathlib/Algebra/Polynomial/Roots.lean:746:  apply eq_zero_of_natDegree_lt_card_of_eval_eq_zero _ hf
Mathlib/Algebra/Polynomial/Roots.lean:750:lemma eq_zero_of_natDegree_lt_card_of_eval_eq_zero' {R} [CommRing R] [IsDomain R]
Mathlib/Algebra/Polynomial/Roots.lean:753:  eq_zero_of_natDegree_lt_card_of_eval_eq_zero p Subtype.val_injective
Mathlib/Algebra/Polynomial/Roots.lean:756:lemma eq_of_natDegree_lt_card_of_eval_eq' {R} [CommRing R] [IsDomain R]
Mathlib/Algebra/Polynomial/Roots.lean:759:  eq_of_natDegree_lt_card_of_eval_eq p q Subtype.val_injective
Mathlib/Algebra/Polynomial/Roots.lean:763:lemma eq_zero_of_forall_eval_zero_of_natDegree_lt_card
Mathlib/Algebra/Polynomial/Roots.lean:767:    apply eq_zero_of_natDegree_lt_card_of_eval_eq_zero f Function.injective_id hf
Mathlib/Algebra/Polynomial/Roots.lean:772:lemma exists_eval_ne_zero_of_natDegree_lt_card (f : R[X]) (hf : f ≠ 0) (hfR : f.natDegree < #R) :
Mathlib/Algebra/Polynomial/Roots.lean:775:  exact eq_zero_of_forall_eval_zero_of_natDegree_lt_card f hf hfR

$ /bin/bash -lc "sed -n '714,780p' Mathlib/Algebra/Polynomial/Roots.lean"
instance [CommRing S] [Algebra S R] (G H : Type*)
    [Monoid G] [MulSemiringAction G R] [SMulCommClass G S R]
    [Monoid H] [MulSemiringAction H R] [SMulCommClass H S R]
    [SMul G H] [IsScalarTower G H R] (f : S[X]) : IsScalarTower G H (f.rootSet R) where
  smul_assoc _ _ _ := Subtype.ext <| smul_assoc _ _ _

end Roots

lemma eq_zero_of_natDegree_lt_card_of_eval_eq_zero {R} [CommRing R] [IsDomain R]
    (p : R[X]) {ι} [Fintype ι] {f : ι → R} (hf : Function.Injective f)
    (heval : ∀ i, p.eval (f i) = 0) (hcard : natDegree p < Fintype.card ι) : p = 0 := by
  classical
  by_contra hp
  refine lt_irrefl #p.roots.toFinset ?_
  calc
    #p.roots.toFinset ≤ Multiset.card p.roots := Multiset.toFinset_card_le _
    _ ≤ natDegree p := Polynomial.card_roots' p
    _ < Fintype.card ι := hcard
    _ = Fintype.card (Set.range f) := (Set.card_range_of_injective hf).symm
    _ = #(Finset.univ.image f) := by rw [← Set.toFinset_card, Set.toFinset_range]
    _ ≤ #p.roots.toFinset := Finset.card_mono ?_
  intro _
  simp only [Finset.mem_image, Finset.mem_univ, true_and, Multiset.mem_toFinset, mem_roots', ne_eq,
    IsRoot.def, forall_exists_index, hp, not_false_eq_true]
  rintro x rfl
  exact heval _

lemma eq_of_natDegree_lt_card_of_eval_eq {R} [CommRing R] [IsDomain R]
    (p q : R[X]) {ι} [Fintype ι] {f : ι → R} (hf : Function.Injective f)
    (heval : ∀ i : ι, eval (f i) p = eval (f i) q)
    (hcard : max p.natDegree q.natDegree < Fintype.card ι) : p = q := by
  rw [← sub_eq_zero]
  apply eq_zero_of_natDegree_lt_card_of_eval_eq_zero _ hf
  · simpa [sub_eq_zero]
  · grind [natDegree_sub_le]

lemma eq_zero_of_natDegree_lt_card_of_eval_eq_zero' {R} [CommRing R] [IsDomain R]
    (p : R[X]) (s : Finset R) (heval : ∀ i ∈ s, p.eval i = 0) (hcard : natDegree p < #s) :
    p = 0 :=
  eq_zero_of_natDegree_lt_card_of_eval_eq_zero p Subtype.val_injective
    (fun i : s ↦ heval i i.prop) (hcard.trans_eq (Fintype.card_coe s).symm)

lemma eq_of_natDegree_lt_card_of_eval_eq' {R} [CommRing R]

$ /bin/bash -lc 'rg -n "strictAnti.*one_div|one_div.*strictAnti|antitone.*inv.*Nat|one_div_injective" Mathlib | head -100'
Mathlib/NumberTheory/Transcendental/Liouville/LiouvilleNumber.lean:117:        (one_div_pow_strictAnti m1 (n.add_factorial_succ_lt_factorial_add_succ (i := 2) le_rfl))
Mathlib/Algebra/Order/Field/Basic.lean:196:theorem one_div_strictAntiOn : StrictAntiOn (fun x : α => 1 / x) (Set.Ioi 0) :=
Mathlib/Algebra/Order/Field/Basic.lean:212:theorem one_div_pow_strictAnti (a1 : 1 < a) : StrictAnti fun n : ℕ => 1 / a ^ n := fun _ _ =>

$ /bin/bash -lc "cat >/tmp/Check.lean <<'EOF'
import Mathlib
#check Metric.continuousAt_iff
#check Metric.continuousAt_iff'
#check ContinuousAt.eventually
#check Metric.eventually_nhds_iff
#check abs_sub_abs_le_abs_sub
#check lt_of_abs_sub_lt
#check exists_nat_one_div_lt
#check exists_nat_gt
EOF
lake env lean /tmp/Check.lean"
Metric.continuousAt_iff.{u, v} {α : Type u} {β : Type v} [PseudoMetricSpace α] [PseudoMetricSpace β] {f : α → β}
  {a : α} : ContinuousAt f a ↔ ∀ ε > 0, ∃ δ > 0, ∀ ⦃x : α⦄, dist x a < δ → dist (f x) (f a) < ε
Metric.continuousAt_iff'.{u, v} {α : Type u} {β : Type v} [PseudoMetricSpace α] [TopologicalSpace β] {f : β → α}
  {b : β} : ContinuousAt f b ↔ ∀ ε > 0, ∀ᶠ (x : β) in nhds b, dist (f x) (f b) < ε
/tmp/Check.lean:4:7: error(lean.unknownIdentifier): Unknown constant `ContinuousAt.eventually`
Metric.eventually_nhds_iff.{u} {α : Type u} [PseudoMetricSpace α] {x : α} {p : α → Prop} :
  (∀ᶠ (y : α) in nhds x, p y) ↔ ∃ ε > 0, ∀ ⦃y : α⦄, dist y x < ε → p y
abs_sub_abs_le_abs_sub.{u_1} {G : Type u_1} [AddCommGroup G] [LinearOrder G] [IsOrderedAddMonoid G] (a b : G) :
  |a| - |b| ≤ |a - b|
/tmp/Check.lean:7:7: error(lean.unknownIdentifier): Unknown identifier `lt_of_abs_sub_lt`
exists_nat_one_div_lt.{u_4} {K : Type u_4} [Semifield K] [LinearOrder K] [IsStrictOrderedRing K] [Archimedean K] {ε : K}
  (hε : 0 < ε) : ∃ n, 1 / (↑n + 1) < ε
exists_nat_gt.{u_1} {R : Type u_1} [Semiring R] [PartialOrder R] [IsStrictOrderedRing R] [Archimedean R] (x : R) :
  ∃ n, x < ↑n

$ /bin/bash -lc 'lake build ENOTV.Estimates && lake env lean ENOTV/Bulk.lean'
⚠ [8679/8682] Replayed ENOTV.Energy
warning: ENOTV/Energy.lean:158:24: Used `tac1 <;> tac2` where `(tac1; tac2)` would suffice

Note: This linter can be disabled with `set_option linter.unnecessarySeqFocus false`
⚠ [8680/8682] Replayed ENOTV.Euler
info: ENOTV/Euler.lean:31:2: Try this:
  [apply] ring_nf
  
  The `ring` tactic failed to close the goal. Use `ring_nf` to obtain a normal form.
    
  Note that `ring` works primarily in *commutative* rings. If you have a noncommutative ring, abelian group or module, consider using `noncomm_ring`, `abel` or `module` instead.
warning: ENOTV/Euler.lean:124:15: Used `tac1 <;> tac2` where `(tac1; tac2)` would suffice

Note: This linter can be disabled with `set_option linter.unnecessarySeqFocus false`
warning: ENOTV/Euler.lean:123:4: 'congr 2' tactic does nothing

Note: This linter can be disabled with `set_option linter.unusedTactic false`
warning: ENOTV/Euler.lean:163:6: Used `tac1 <;> tac2` where `(tac1; tac2)` would suffice

Note: This linter can be disabled with `set_option linter.unnecessarySeqFocus false`
⚠ [8681/8682] Built ENOTV.Counterexample (7.8s)
warning: ENOTV/Counterexample.lean:111:53: This simp argument is unused:
  h2

Hint: Omit it from the simp argument list.
  [apply] simp [pairDatumNat_apply, pairJumpNat_apply, h4, blockPrefix_succ]

Note: This linter can be disabled with `set_option linter.unusedSimpArgs false`
warning: ENOTV/Counterexample.lean:134:59: This simp argument is unused:
  h₄

Hint: Omit it from the simp argument list.
  [apply] simp [pairDatumNat_apply, pairJumpNat_apply, h₁, h42, h412, h414, hsub]

Note: This linter can be disabled with `set_option linter.unusedSimpArgs false`
warning: ENOTV/Counterexample.lean:356:4: `push_neg` has been deprecated. Prefer using `push Not` instead.
If you'd rather continue using `push_neg` in your project, you can implement it as follows:
```
open Lean.Parser.Tactic in
macro "push_neg" cfg:optConfig loc:(location)? : tactic =>
  `(tactic| push $cfg:optConf

$ /bin/bash -lc "cat >/tmp/Check.lean <<'EOF'
import Mathlib
#check Rat.dist_eq
#check Real.dist_eq
#check dist_eq_norm
#check dist_eq
#check Rat.cast_abs
EOF
lake env lean /tmp/Check.lean"
Rat.dist_eq (x y : ℚ) : dist x y = |↑x - ↑y|
Real.dist_eq (x y : ℝ) : dist x y = |x - y|
dist_eq_norm.{u_5} {E : Type u_5} [SeminormedAddCommGroup E] (a b : E) : dist a b = ‖a - b‖
/tmp/Check.lean:5:7: error(lean.unknownIdentifier): Unknown identifier `dist_eq`
Rat.cast_abs.{u_5} {K : Type u_5} [Field K] [LinearOrder K] [IsStrictOrderedRing K] (q : ℚ) : ↑|q| = |↑q|

$ /bin/bash -lc 'lake env lean ENOTV/Bulk.lean'
ENOTV/Bulk.lean:80:4: error: linarith failed to find a contradiction
d q : ℕ
hq2 : 2 ≤ q
hqd : q ≤ d + 2
hne : eval (1 / ↑q) (eulerPoly d) ≠ 0
α : ℚ := 1 / ↑q
y : ℚ := |eval α (eulerPoly d)|
hy : 0 < y
hc : ContinuousAt (fun x => eval x (eulerPoly d)) α
δ : ℝ
hδ : δ > 0
hcont : ∀ ⦃x : ℚ⦄, dist x α < δ → dist (eval x (eulerPoly d)) (eval α (eulerPoly d)) < ↑y / 2
x : ℚ
hx : ↑|x - 1 / ↑q| < δ
hd : dist x α < δ
hv : |↑(eval x (eulerPoly d)) - ↑(eval α (eulerPoly d))| < ↑|eval α (eulerPoly d)| / 2
habs : |eval α (eulerPoly d)| - |eval x (eulerPoly d)| ≤ |eval α (eulerPoly d) - eval x (eulerPoly d)|
a✝ : |↑(eval x (eulerPoly d))| < |↑(eval α (eulerPoly d))| / 2
⊢ False
failed

$ /bin/bash -lc 'lake env lean ENOTV/Bulk.lean'
ENOTV/Bulk.lean:77:10: error: Application type mismatch: The argument
  eulerPoly d
has type
  ℚ[X]
but is expected to have type
  ℝ[X]
in the application
  eval (↑α) (eulerPoly d)
ENOTV/Bulk.lean:77:39: error: Application type mismatch: The argument
  eulerPoly d
has type
  ℚ[X]
but is expected to have type
  ℝ[X]
in the application
  eval (↑x) (eulerPoly d)
ENOTV/Bulk.lean:80:8: error: Application type mismatch: The argument
  eulerPoly d
has type
  ℚ[X]
but is expected to have type
  ℝ[X]
in the application
  eval (↑α) (eulerPoly d)
ENOTV/Bulk.lean:80:37: error: Application type mismatch: The argument
  eulerPoly d
has type
  ℚ[X]
but is expected to have type
  ℝ[X]
in the application
  eval (↑x) (eulerPoly d)
ENOTV/Bulk.lean:87:4: error: linarith failed to find a contradiction
d q : ℕ
hq2 : 2 ≤ q
hqd : q ≤ d + 2
hne : eval (1 / ↑q) (eulerPoly d) ≠ 0
α : ℚ := 1 / ↑q
y : ℚ := |eval α (eulerPoly d)|
hy : 0 < y
hc : ContinuousAt (fun x => eval x (eulerPoly d)) α
δ : ℝ
hδ : δ > 0
hcont : ∀ ⦃x : ℚ⦄, dist x α < δ → dist (eval x (eulerPoly d)) (eval α (eulerPoly d)) < ↑y / 2
x : ℚ
hx : ↑|x - 1 / ↑q| < δ
hd : dist x α < δ
hv : |↑(eval x (eulerPoly d)) - ↑(eval α (eulerPoly d))| < ↑y / 2
habs : |eval α (eulerPoly d)| - |eval x (eulerPoly d)| ≤ |eval α (eulerPoly d) - eval x (eulerPoly d)|
habsR : ↑|eval α (eulerPoly d)| - ↑|eval x (eulerPoly d)| ≤ |eval ↑α sorry - eval ↑x sorry|
hv' : |eval ↑α sorry - eval ↑x sorry| < ↑|eval α (eulerPoly d)| / 2
a✝ : |↑(eval x (eulerPoly d))| < |↑(eval α (eulerPoly d))| / 2
⊢ False
failed

$ /bin/bash -lc 'lake env lean ENOTV/Bulk.lean'
ENOTV/Bulk.lean:89:4: error: linarith failed to find a contradiction
d q : ℕ
hq2 : 2 ≤ q
hqd : q ≤ d + 2
hne : eval (1 / ↑q) (eulerPoly d) ≠ 0
α : ℚ := 1 / ↑q
y : ℚ := |eval α (eulerPoly d)|
hy : 0 < y
hc : ContinuousAt (fun x => eval x (eulerPoly d)) α
δ : ℝ
hδ : δ > 0
hcont : ∀ ⦃x : ℚ⦄, dist x α < δ → dist (eval x (eulerPoly d)) (eval α (eulerPoly d)) < ↑y / 2
x : ℚ
hx : ↑|x - 1 / ↑q| < δ
hd : dist x α < δ
hv : |↑(eval x (eulerPoly d)) - ↑(eval α (eulerPoly d))| < ↑y / 2
habs : |eval α (eulerPoly d)| - |eval x (eulerPoly d)| ≤ |eval α (eulerPoly d) - eval x (eulerPoly d)|
habsR : ↑|eval α (eulerPoly d)| - ↑|eval x (eulerPoly d)| ≤ |↑(eval α (eulerPoly d)) - ↑(eval x (eulerPoly d))|
hv' : |↑(eval α (eulerPoly d)) - ↑(eval x (eulerPoly d))| < ↑|eval α (eulerPoly d)| / 2
a✝ : |↑(eval x (eulerPoly d))| < |↑(eval α (eulerPoly d))| / 2
⊢ False
failed

$ /bin/bash -lc 'lake env lean ENOTV/Bulk.lean'

$ /bin/bash -lc 'lake env lean ENOTV/Bulk.lean'
ENOTV/Bulk.lean:110:19: error: unsolved goals
d q : ℕ
δ : ℝ
hq2 : 2 ≤ q
hδ : 0 < δ
hy : 0 < |eval (1 / ↑q) (eulerPoly d)|
hwin : ∀ (x : ℚ), ↑|x - 1 / ↑q| < δ → |eval (1 / ↑q) (eulerPoly d)| / 2 ≤ |eval x (eulerPoly d)|
n : ℕ
hnδ : 1 / (↑n + 1) < δ
s : ℕ := n + 1
b : ℕ := q * s
a : ℕ := 2 * s
y : ℚ := |eval (1 / ↑q) (eulerPoly d)|
c : ℚ := 2 ^ d * (y / 2)
hy' : 0 < y
⊢ 0 < q
ENOTV/Bulk.lean:124:4: error: linarith failed to find a contradiction
d q : ℕ
δ : ℝ
hq2 : 2 ≤ q
hδ : 0 < δ
hy : 0 < |eval (1 / ↑q) (eulerPoly d)|
hwin : ∀ (x : ℚ), ↑|x - 1 / ↑q| < δ → |eval (1 / ↑q) (eulerPoly d)| / 2 ≤ |eval x (eulerPoly d)|
n : ℕ
hnδ : 1 / (↑n + 1) < δ
s : ℕ := n + 1
b : ℕ := q * s
a : ℕ := 2 * s
y : ℚ := |eval (1 / ↑q) (eulerPoly d)|
c : ℚ := 2 ^ d * (y / 2)
hy' : 0 < y
M r : ℕ
hM : 0 < M
hr : r < M
L : ℕ := b * M
t : ℕ := a * M + r
hL : 0 < L
hs : 1 ≤ n + 1
hq : 2 ≤ q
a✝ : 2 * (q * (n + 1) * M) ≤ 2 * (n + 1) * M + r
⊢ False
failed
Try this:
  [apply] ring_nf
  
  The `ring` tactic failed to close the goal. Use `ring_nf` to obtain a normal form.
    
  Note that `ring` works primarily in *commutative* rings. If you have a noncommutative ring, abelian group or module, consider using `noncomm_ring`, `abel` or `module` instead.
ENOTV/Bulk.lean:133:39: error: unsolved goals
d q : ℕ
δ : ℝ
hq2 : 2 ≤ q
hδ : 0 < δ
hy : 0 < |eval (1 / ↑q) (eulerPoly d)|
hwin : ∀ (x : ℚ), ↑|x - 1 / ↑q| < δ → |eval (1 / ↑q) (eulerPoly d)| / 2 ≤ |eval x (eulerPoly d)|
n : ℕ
hnδ : 1 / (↑n + 1) < δ
s : ℕ := n + 1
b : ℕ := q * s
a : ℕ := 2 * s
y : ℚ := |eval (1 / ↑q) (eulerPoly d)|
c : ℚ := 2 ^ d * (y / 2)
hy' : 0 < y
M r : ℕ
hM : 0 < M
hr : r < M
L : ℕ := b * M
t : ℕ := a * M + r
hL : 0 < L
ht : t < 2 * L
hqpos : 0 < ↑q
hspos : 0 < ↑s
hMpos : 0 < ↑M
⊢ ↑(s * M * 2 + r) * ↑q * ↑s * ↑M - ↑(s * M * q) * ↑s * ↑M * 2 = ↑(s * M * q) * ↑r
ENOTV/Bulk.lean:146:6: error: linarith failed to find a contradiction
d q : ℕ
δ : ℝ
hq2 : 2 ≤ q
hδ : 0 < δ
hy : 0 < |eval (1 / ↑q) (eulerPoly d)|
hwin : ∀ (x : ℚ), ↑|x - 1 / ↑q| <

$ /bin/bash -lc "cat >/tmp/Check.lean <<'EOF'
import Mathlib
#check Nat.le_mul_of_pos_left
#check Nat.le_mul_of_pos_right
#check Nat.mul_le_mul
#check Nat.mul_le_mul_right
EOF
lake env lean /tmp/Check.lean"
Nat.le_mul_of_pos_left {n : ℕ} (m : ℕ) (h : 0 < n) : m ≤ n * m
Nat.le_mul_of_pos_right {m : ℕ} (n : ℕ) (h : 0 < m) : n ≤ n * m
Nat.mul_le_mul {n₁ m₁ n₂ m₂ : ℕ} (h₁ : n₁ ≤ n₂) (h₂ : m₁ ≤ m₂) : n₁ * m₁ ≤ n₂ * m₂
Nat.mul_le_mul_right {n m : ℕ} (k : ℕ) (h : n ≤ m) : n * k ≤ m * k

$ /bin/bash -lc 'lake env lean ENOTV/Bulk.lean'
ENOTV/Bulk.lean:115:4: error: Tactic `apply` failed: could not unify the conclusion of `@Nat.mul_lt_mul_of_pos_right`
  ?n * ?k < ?m * ?k
with the goal
  2 * s < 2 * (q * s)

Note: The full type of `@Nat.mul_lt_mul_of_pos_right` is
  ∀ {n m k : ℕ}, n < m → k > 0 → n * k < m * k

case refine_2
d q : ℕ
δ : ℝ
hq2 : 2 ≤ q
hδ : 0 < δ
hy : 0 < |eval (1 / ↑q) (eulerPoly d)|
hwin : ∀ (x : ℚ), ↑|x - 1 / ↑q| < δ → |eval (1 / ↑q) (eulerPoly d)| / 2 ≤ |eval x (eulerPoly d)|
n : ℕ
hnδ : 1 / (↑n + 1) < δ
s : ℕ := n + 1
b : ℕ := q * s
a : ℕ := 2 * s
y : ℚ := |eval (1 / ↑q) (eulerPoly d)|
c : ℚ := 2 ^ d * (y / 2)
hy' : 0 < y
hs : 0 < s
⊢ 2 * s < 2 * (q * s)
ENOTV/Bulk.lean:171:39: error: unsolved goals
d q : ℕ
δ : ℝ
hq2 : 2 ≤ q
hδ : 0 < δ
hy : 0 < |eval (1 / ↑q) (eulerPoly d)|
hwin : ∀ (x : ℚ), ↑|x - 1 / ↑q| < δ → |eval (1 / ↑q) (eulerPoly d)| / 2 ≤ |eval x (eulerPoly d)|
n : ℕ
hnδ : 1 / (↑n + 1) < δ
s : ℕ := n + 1
b : ℕ := q * s
a : ℕ := 2 * s
y : ℚ := |eval (1 / ↑q) (eulerPoly d)|
c : ℚ := 2 ^ d * (y / 2)
hy' : 0 < y
M r : ℕ
hM : 0 < M
hr : r < M
L : ℕ := b * M
t : ℕ := a * M + r
hL : 0 < L
ht : t < 2 * L
hqpos : 0 < ↑q
hspos : 0 < ↑s
hMpos : 0 < ↑M
hform : ↑t / (2 * ↑L) - 1 / ↑q = ↑r / (2 * ↑q * ↑s * ↑M)
hrR : ↑r < ↑M
hdenR : 0 < 2 * ↑q * ↑s * ↑M
hsmall : ↑r / (2 * ↑q * ↑s * ↑M) < 1 / ↑s
hsδ : 1 / ↑s < δ
⊢ ↑(↑r / ↑(2 * q * s * M)) = ↑r / ↑(2 * q * s * M)

$ /bin/bash -lc "cat >/tmp/Check.lean <<'EOF'
import Mathlib
#check Rat.cast_div
#check Rat.cast_natCast
#check map_div
EOF
lake env lean /tmp/Check.lean"
Rat.cast_div.{u_3} {α : Type u_3} [DivisionRing α] [CharZero α] (p q : ℚ) : ↑(p / q) = ↑p / ↑q
Rat.cast_natCast.{u_3} {α : Type u_3} [DivisionRing α] (n : ℕ) : ↑↑n = ↑n
map_div.{u_7, u_8, u_9} {G : Type u_7} {H : Type u_8} {F : Type u_9} [FunLike F G H] [Group G] [DivisionMonoid H]
  [MonoidHomClass F G H] (f : F) (a b : G) : f (a / b) = f a / f b

$ /bin/bash -lc 'lake env lean ENOTV/Bulk.lean'
ENOTV/Bulk.lean:172:39: error: unsolved goals
d q : ℕ
δ : ℝ
hq2 : 2 ≤ q
hδ : 0 < δ
hy : 0 < |eval (1 / ↑q) (eulerPoly d)|
hwin : ∀ (x : ℚ), ↑|x - 1 / ↑q| < δ → |eval (1 / ↑q) (eulerPoly d)| / 2 ≤ |eval x (eulerPoly d)|
n : ℕ
hnδ : 1 / (↑n + 1) < δ
s : ℕ := n + 1
b : ℕ := q * s
a : ℕ := 2 * s
y : ℚ := |eval (1 / ↑q) (eulerPoly d)|
c : ℚ := 2 ^ d * (y / 2)
hy' : 0 < y
M r : ℕ
hM : 0 < M
hr : r < M
L : ℕ := b * M
t : ℕ := a * M + r
hL : 0 < L
ht : t < 2 * L
hqpos : 0 < ↑q
hspos : 0 < ↑s
hMpos : 0 < ↑M
hform : ↑t / (2 * ↑L) - 1 / ↑q = ↑r / (2 * ↑q * ↑s * ↑M)
hrR : ↑r < ↑M
hdenR : 0 < 2 * ↑q * ↑s * ↑M
hsmall : ↑r / (2 * ↑q * ↑s * ↑M) < 1 / ↑s
hsδ : 1 / ↑s < δ
⊢ ↑(↑r / ↑(2 * q * s * M)) = ↑r / ↑(2 * q * s * M)

$ /bin/bash -lc "cat >/tmp/Test.lean <<'EOF'
import Mathlib
example (r q s M : ℕ) :
    ((((r : ℚ) / (2 * q * s * M) : ℚ)) : ℝ) =
      (r : ℝ) / (2 * q * s * M) := by
  rw [Rat.cast_div (α := ℝ)]
  push_cast
EOF
lake env lean /tmp/Test.lean"
/tmp/Test.lean:4:35: error: unsolved goals
r q s M : ℕ
⊢ ↑r / (2 * ↑q * ↑s * ↑M) = ↑r / (2 * ↑q * ↑s * ↑M)

$ /bin/bash -lc "sed -i '"'$a'"\\  rfl' /tmp/Test.lean && lake env lean /tmp/Test.lean"

$ /bin/bash -lc 'lake env lean ENOTV/Bulk.lean'
ENOTV/Bulk.lean:175:6: error: Tactic `rfl` failed: The left-hand side
  ↑(↑r / ↑(2 * q * s * M))
is not definitionally equal to the right-hand side
  ↑r / ↑(2 * q * s * M)

d q : ℕ
δ : ℝ
hq2 : 2 ≤ q
hδ : 0 < δ
hy : 0 < |eval (1 / ↑q) (eulerPoly d)|
hwin : ∀ (x : ℚ), ↑|x - 1 / ↑q| < δ → |eval (1 / ↑q) (eulerPoly d)| / 2 ≤ |eval x (eulerPoly d)|
n : ℕ
hnδ : 1 / (↑n + 1) < δ
s : ℕ := n + 1
b : ℕ := q * s
a : ℕ := 2 * s
y : ℚ := |eval (1 / ↑q) (eulerPoly d)|
c : ℚ := 2 ^ d * (y / 2)
hy' : 0 < y
M r : ℕ
hM : 0 < M
hr : r < M
L : ℕ := b * M
t : ℕ := a * M + r
hL : 0 < L
ht : t < 2 * L
hqpos : 0 < ↑q
hspos : 0 < ↑s
hMpos : 0 < ↑M
hform : ↑t / (2 * ↑L) - 1 / ↑q = ↑r / (2 * ↑q * ↑s * ↑M)
hrR : ↑r < ↑M
hdenR : 0 < 2 * ↑q * ↑s * ↑M
hsmall : ↑r / (2 * ↑q * ↑s * ↑M) < 1 / ↑s
hsδ : 1 / ↑s < δ
⊢ ↑(↑r / ↑(2 * q * s * M)) = ↑r / ↑(2 * q * s * M)

$ /bin/bash -lc 'lake env lean ENOTV/Bulk.lean'

$ /bin/bash -lc "cat >/tmp/Check.lean <<'EOF'
import Mathlib
#check Finset.sum_le_tsum
#check Finset.sum_le_sum_of_subset_of_nonneg
#check Finset.sum_bij
#check Finset.sum_map
#check Finset.product
EOF
lake env lean /tmp/Check.lean"
/tmp/Check.lean:2:7: error(lean.unknownIdentifier): Unknown constant `Finset.sum_le_tsum`
Finset.sum_le_sum_of_subset_of_nonneg.{u_1, u_5} {ι : Type u_1} {N : Type u_5} [AddCommMonoid N] [Preorder N]
  {f : ι → N} {s t : Finset ι} [AddLeftMono N] (h : s ⊆ t) (hf : ∀ i ∈ t, i ∉ s → 0 ≤ f i) : ∑ i ∈ s, f i ≤ ∑ i ∈ t, f i
Finset.sum_bij.{u_1, u_2, u_3} {ι : Type u_1} {κ : Type u_2} {M : Type u_3} [AddCommMonoid M] {s : Finset ι}
  {t : Finset κ} {f : ι → M} {g : κ → M} (i : (a : ι) → a ∈ s → κ) (hi : ∀ (a : ι) (ha : a ∈ s), i a ha ∈ t)
  (i_inj : ∀ (a₁ : ι) (ha₁ : a₁ ∈ s) (a₂ : ι) (ha₂ : a₂ ∈ s), i a₁ ha₁ = i a₂ ha₂ → a₁ = a₂)
  (i_surj : ∀ b ∈ t, ∃ a, ∃ (ha : a ∈ s), i a ha = b) (h : ∀ (a : ι) (ha : a ∈ s), f a = g (i a ha)) :
  ∑ x ∈ s, f x = ∑ x ∈ t, g x
Finset.sum_map.{u_1, u_2, u_3} {ι : Type u_1} {κ : Type u_2} {M : Type u_3} [AddCommMonoid M] (s : Finset ι) (e : ι ↪ κ)
  (f : κ → M) : ∑ x ∈ Finset.map e s, f x = ∑ x ∈ s, f (e x)
Finset.product.{u_1, u_2} {α : Type u_1} {β : Type u_2} (s : Finset α) (t : Finset β) : Finset (α × β)

$ /bin/bash -lc "rg -n \"support_finset.*sum|support_sum.*biUnion|Finsupp.support_sum\" Mathlib/Data/Finsupp Mathlib/Algebra/BigOperators/Finsupp | head -100 && cat >/tmp/Check.lean <<'EOF'
import Mathlib
#check Finsupp.support_finset_sum
#check Finsupp.support_sum
#check Finset.mem_biUnion
EOF
lake env lean /tmp/Check.lean"
Finsupp.support_finset_sum.{u_1, u_7, u_8} {α : Type u_1} {β : Type u_7} {M : Type u_8} [DecidableEq β]
  [AddCommMonoid M] {s : Finset α} {f : α → β →₀ M} : (s.sum f).support ⊆ s.biUnion fun x => (f x).support
Finsupp.support_sum.{u_1, u_7, u_8, u_10} {α : Type u_1} {β : Type u_7} {M : Type u_8} {N : Type u_10} [DecidableEq β]
  [Zero M] [AddCommMonoid N] {f : α →₀ M} {g : α → M → β →₀ N} :
  (f.sum g).support ⊆ f.support.biUnion fun a => (g a (f a)).support
Finset.mem_biUnion.{u_1, u_2} {α : Type u_1} {β : Type u_2} {s : Finset α} {t : α → Finset β} [DecidableEq β] {b : β} :
  b ∈ s.biUnion t ↔ ∃ a ∈ s, b ∈ t a

$ /bin/bash -lc 'lake env lean ENOTV/Counterexample.lean'
ENOTV/Counterexample.lean:111:53: warning: This simp argument is unused:
  h2

Hint: Omit it from the simp argument list.
  [apply] simp [pairDatumNat_apply, pairJumpNat_apply, h4, blockPrefix_succ]

Note: This linter can be disabled with `set_option linter.unusedSimpArgs false`
ENOTV/Counterexample.lean:134:59: warning: This simp argument is unused:
  h₄

Hint: Omit it from the simp argument list.
  [apply] simp [pairDatumNat_apply, pairJumpNat_apply, h₁, h42, h412, h414, hsub]

Note: This linter can be disabled with `set_option linter.unusedSimpArgs false`
ENOTV/Counterexample.lean:356:4: warning: `push_neg` has been deprecated. Prefer using `push Not` instead.
If you'd rather continue using `push_neg` in your project, you can implement it as follows:
```
open Lean.Parser.Tactic in
macro "push_neg" cfg:optConfig loc:(location)? : tactic =>
  `(tactic| push $cfg:optConfig Not $[$loc]?)
```
ENOTV/Counterexample.lean:374:14: error: unsolved goals
p : ℕ
f : CSeq
i : ℤ
hi : i ∈ Function.support fun i => |f i| ^ p
hif : i ∉ ↑f.support
hz : f i = 0
⊢ ¬p = 0
ENOTV/Counterexample.lean:379:39: error: unsolved goals
p : ℕ
f : CSeq
i : ℤ
hi : i ∉ f.support
⊢ ¬p = 0
ENOTV/Counterexample.lean:392:2: error: unsolved goals
case pos
p : ℕ
f g : CSeq
hfg : Disjoint f.support g.support
i : ℤ
hfi : f i = 0
⊢ ¬p = 0
ENOTV/Counterexample.lean:393:2: error: unsolved goals
case neg
p : ℕ
f g : CSeq
hfg : Disjoint f.support g.support
i : ℤ
hfi : ¬f i = 0
hgi : g i = 0
⊢ ¬p = 0

$ /bin/bash -lc 'lake env lean ENOTV/Counterexample.lean'
ENOTV/Counterexample.lean:111:53: warning: This simp argument is unused:
  h2

Hint: Omit it from the simp argument list.
  [apply] simp [pairDatumNat_apply, pairJumpNat_apply, h4, blockPrefix_succ]

Note: This linter can be disabled with `set_option linter.unusedSimpArgs false`
ENOTV/Counterexample.lean:134:59: warning: This simp argument is unused:
  h₄

Hint: Omit it from the simp argument list.
  [apply] simp [pairDatumNat_apply, pairJumpNat_apply, h₁, h42, h412, h414, hsub]

Note: This linter can be disabled with `set_option linter.unusedSimpArgs false`
ENOTV/Counterexample.lean:356:4: warning: `push_neg` has been deprecated. Prefer using `push Not` instead.
If you'd rather continue using `push_neg` in your project, you can implement it as follows:
```
open Lean.Parser.Tactic in
macro "push_neg" cfg:optConfig loc:(location)? : tactic =>
  `(tactic| push $cfg:optConfig Not $[$loc]?)
```

$ /bin/bash -lc 'lake build ENOTV.Counterexample ENOTV.Estimates && lake env lean ENOTV/Bulk.lean'
⚠ [8679/8682] Replayed ENOTV.Energy
warning: ENOTV/Energy.lean:158:24: Used `tac1 <;> tac2` where `(tac1; tac2)` would suffice

Note: This linter can be disabled with `set_option linter.unnecessarySeqFocus false`
⚠ [8680/8682] Replayed ENOTV.Euler
info: ENOTV/Euler.lean:31:2: Try this:
  [apply] ring_nf
  
  The `ring` tactic failed to close the goal. Use `ring_nf` to obtain a normal form.
    
  Note that `ring` works primarily in *commutative* rings. If you have a noncommutative ring, abelian group or module, consider using `noncomm_ring`, `abel` or `module` instead.
warning: ENOTV/Euler.lean:124:15: Used `tac1 <;> tac2` where `(tac1; tac2)` would suffice

Note: This linter can be disabled with `set_option linter.unnecessarySeqFocus false`
warning: ENOTV/Euler.lean:123:4: 'congr 2' tactic does nothing

Note: This linter can be disabled with `set_option linter.unusedTactic false`
warning: ENOTV/Euler.lean:163:6: Used `tac1 <;> tac2` where `(tac1; tac2)` would suffice

Note: This linter can be disabled with `set_option linter.unnecessarySeqFocus false`
⚠ [8681/8682] Built ENOTV.Counterexample (7.5s)
warning: ENOTV/Counterexample.lean:111:53: This simp argument is unused:
  h2

Hint: Omit it from the simp argument list.
  [apply] simp [pairDatumNat_apply, pairJumpNat_apply, h4, blockPrefix_succ]

Note: This linter can be disabled with `set_option linter.unusedSimpArgs false`
warning: ENOTV/Counterexample.lean:134:59: This simp argument is unused:
  h₄

Hint: Omit it from the simp argument list.
  [apply] simp [pairDatumNat_apply, pairJumpNat_apply, h₁, h42, h412, h414, hsub]

Note: This linter can be disabled with `set_option linter.unusedSimpArgs false`
warning: ENOTV/Counterexample.lean:356:4: `push_neg` has been deprecated. Prefer using `push Not` instead.
If you'd rather continue using `push_neg` in your project, you can implement it as follows:
```
open Lean.Parser.Tactic in
macro "push_neg" cfg:optConfig loc:(location)? : tactic =>
  `(tactic| push $cfg:optConf

$ /bin/bash -lc 'lake env lean ENOTV/Bulk.lean'
ENOTV/Bulk.lean:221:4: error: Type mismatch: After simplification, term
  hreal
 has type
  ↑c * ↑L ^ d ≤ |realBlock d L (a * M + r)|
but is expected to have type
  ↑c * ↑L ^ d ≤ |(liftNat (pairJumpNat d L)) (↑a * ↑M + ↑r)|

$ /bin/bash -lc 'lake env lean ENOTV/Bulk.lean'

$ /bin/bash -lc 'lake env lean ENOTV/Bulk.lean'

$ /bin/bash -lc 'lake build ENOTV.Bulk && lake env lean ENOTV/Endpoint.lean'
⚠ [8679/8683] Replayed ENOTV.Energy
warning: ENOTV/Energy.lean:158:24: Used `tac1 <;> tac2` where `(tac1; tac2)` would suffice

Note: This linter can be disabled with `set_option linter.unnecessarySeqFocus false`
⚠ [8680/8683] Replayed ENOTV.Euler
info: ENOTV/Euler.lean:31:2: Try this:
  [apply] ring_nf
  
  The `ring` tactic failed to close the goal. Use `ring_nf` to obtain a normal form.
    
  Note that `ring` works primarily in *commutative* rings. If you have a noncommutative ring, abelian group or module, consider using `noncomm_ring`, `abel` or `module` instead.
warning: ENOTV/Euler.lean:124:15: Used `tac1 <;> tac2` where `(tac1; tac2)` would suffice

Note: This linter can be disabled with `set_option linter.unnecessarySeqFocus false`
warning: ENOTV/Euler.lean:123:4: 'congr 2' tactic does nothing

Note: This linter can be disabled with `set_option linter.unusedTactic false`
warning: ENOTV/Euler.lean:163:6: Used `tac1 <;> tac2` where `(tac1; tac2)` would suffice

Note: This linter can be disabled with `set_option linter.unnecessarySeqFocus false`
⚠ [8681/8683] Replayed ENOTV.Counterexample
warning: ENOTV/Counterexample.lean:111:53: This simp argument is unused:
  h2

Hint: Omit it from the simp argument list.
  [apply] simp [pairDatumNat_apply, pairJumpNat_apply, h4, blockPrefix_succ]

Note: This linter can be disabled with `set_option linter.unusedSimpArgs false`
warning: ENOTV/Counterexample.lean:134:59: This simp argument is unused:
  h₄

Hint: Omit it from the simp argument list.
  [apply] simp [pairDatumNat_apply, pairJumpNat_apply, h₁, h42, h412, h414, hsub]

Note: This linter can be disabled with `set_option linter.unusedSimpArgs false`
warning: ENOTV/Counterexample.lean:356:4: `push_neg` has been deprecated. Prefer using `push Not` instead.
If you'd rather continue using `push_neg` in your project, you can implement it as follows:
```
open Lean.Parser.Tactic in
macro "push_neg" cfg:optConfig loc:(location)? : tactic =>
  `(tactic| push $cfg:optConfig N

$ /bin/bash -lc 'lake env lean ENOTV/Endpoint.lean'
ENOTV/Endpoint.lean:42:0: error: (deterministic) timeout at `whnf`, maximum number of heartbeats (200000) has been reached

Note: Use `set_option maxHeartbeats <num>` to set the limit.

Hint: Additional diagnostic information may be available using the `set_option diagnostics true` command.
ENOTV/Endpoint.lean:94:8: error: Tactic `rewrite` failed: Did not find an occurrence of the pattern
  ↑(2 * L - h) / (2 * ↑L)
in the target expression
  (2 * ↑L) ^ d * eval ((2 * ↑L - ↑h) / (2 * ↑L)) (eulerPoly d) = (2 * ↑L) ^ d * eval (↑h / (2 * ↑L)) (eulerPoly d)

case neg
d L h : ℕ
hd : 0 < d
heven : Even d
hh : h ≤ 2 * L
hL : ¬L = 0
hden : 2 * ↑L ≠ 0
harg : ↑(2 * L - h) / (2 * ↑L) = 1 - ↑h / (2 * ↑L)
⊢ (2 * ↑L) ^ d * eval ((2 * ↑L - ↑h) / (2 * ↑L)) (eulerPoly d) = (2 * ↑L) ^ d * eval (↑h / (2 * ↑L)) (eulerPoly d)
ENOTV/Endpoint.lean:96:8: error: (kernel) unknown constant 'ENOTV.abs_blockPoly_endpoint_le'
ENOTV/Endpoint.lean:104:8: error: (kernel) unknown constant 'ENOTV.abs_blockPoly_endpoint_le'

$ /bin/bash -lc 'lake env lean ENOTV/Endpoint.lean'
ENOTV/Endpoint.lean:63:4: error: invalid 'calc' step, left-hand side is
  (2 * ↑L) ^ (d - 1) * (2 * ↑L) * (↑h / (2 * ↑L) * |eval (↑h / (2 * ↑L)) (eulerTail d)|) : ℚ
but is expected to be
  (2 * ↑L) ^ (d - 1) * (2 * ↑L) * (↑h / (2 * ↑L) * |eval (↑h / (2 * ↑L)) (eulerTail (d - 1 + 1))|) : ℚ
ENOTV/Endpoint.lean:73:4: error: invalid 'calc' step, right-hand side is
  endpointUpper d R * ↑L ^ (d - 1) : ℚ
but is expected to be
  endpointUpper (d - 1 + 1) R * ↑L ^ (d - 1 + 1 - 1) : ℚ
ENOTV/Endpoint.lean:93:6: error: No goals to be solved

$ /bin/bash -lc "nl -ba ENOTV/Endpoint.lean | sed -n '50,105p'"
50	  have hx1 : (h : ℚ) / (2 * L) ≤ 1 := by
    51	    apply (div_le_one hden).2
    52	    exact_mod_cast hinside
    53	  have hxabs : |(h : ℚ) / (2 * L)| ≤ 1 := by
    54	    rw [abs_of_nonneg hx0]
    55	    exact hx1
    56	  have htail := abs_eval_le_coeffAbsSum (eulerTail d) hxabs
    57	  rw [blockPoly, eulerPoly_eval_eq_mul_tail d hd heven, abs_mul, abs_mul,
    58	    abs_pow, abs_of_nonneg (show (0 : ℚ) ≤ 2 * L by positivity),
    59	    abs_of_nonneg hx0]
    60	  have hdform : d = (d - 1) + 1 := by omega
    61	  rw [hdform, pow_succ]
    62	  calc
    63	    (2 * (L : ℚ)) ^ (d - 1) * (2 * L) *
    64	          ((h : ℚ) / (2 * L) * |(eulerTail d).eval ((h : ℚ) / (2 * L))|) =
    65	        (h : ℚ) * (2 * L) ^ (d - 1) *
    66	          |(eulerTail d).eval ((h : ℚ) / (2 * L))| := by
    67	      field_simp
    68	      ring
    69	    _ ≤ (R : ℚ) * (2 * L) ^ (d - 1) *
    70	        coeffAbsSum (eulerTail d) := by
    71	      gcongr
    72	      exact_mod_cast hh
    73	    _ = endpointUpper d R * (L : ℚ) ^ (d - 1) := by
    74	      simp only [endpointUpper]
    75	      push_cast
    76	      rw [mul_pow]
    77	      ring
    78	
    79	theorem blockPoly_reflect (d L h : ℕ) (hd : 0 < d) (heven : Even d)
    80	    (hh : h ≤ 2 * L) :
    81	    blockPoly d L (2 * L - h) = blockPoly d L h := by
    82	  by_cases hL : L = 0
    83	  · subst L
    84	    have : h = 0 := by omega
    85	    subst h
    86	    simp
    87	  · unfold blockPoly
    88	    have hden : (2 * (L : ℚ)) ≠ 0 := by positivity
    89	    have harg :
    90	        ((2 * (L : ℚ) - h) / (2 * L)) =
    91	          1 - (h : ℚ) / (2 * L) := by
    92	      field_simp
    93	      push_cast
    94	      ring
    95	    rw [harg, eulerPoly_one_sub d heven]
    96	
    97	theorem abs_blockPoly_right_endpoint_le (d R L h : ℕ)
    98	    (hd : 0 < d) (heven : Even d) (hL : 0 < L) (hh : h ≤ R)
    99	    (hinside : h ≤ 2 * L) :
   100	    |blockPoly d L (2 * L - h)| ≤
   101	      endpointUppe

$ /bin/bash -lc 'lake env lean ENOTV/Endpoint.lean'
ENOTV/Endpoint.lean:72:6: error: No goals to be solved
ENOTV/Endpoint.lean:76:6: error: No goals to be solved
ENOTV/Endpoint.lean:83:39: warning: Variable name `hd` is not explicitly referenced.

Hint: The binding can be removed (if unused) or named `_` (if used implicitly). Alternatively, prefix the name with `_` to silence this warning:
  [apply] _hd

Note: This linter can be disabled with `set_option linter.unusedVariables false`

$ /bin/bash -lc "nl -ba ENOTV/Endpoint.lean | sed -n '62,82p'"
62	      (2 * (L : ℚ)) ^ d =
    63	        (2 * (L : ℚ)) ^ (d - 1) * (2 * L) := by
    64	    conv_lhs => rw [hdform, pow_succ]
    65	  rw [hpow]
    66	  calc
    67	    (2 * (L : ℚ)) ^ (d - 1) * (2 * L) *
    68	          ((h : ℚ) / (2 * L) * |(eulerTail d).eval ((h : ℚ) / (2 * L))|) =
    69	        (h : ℚ) * (2 * L) ^ (d - 1) *
    70	          |(eulerTail d).eval ((h : ℚ) / (2 * L))| := by
    71	      field_simp
    72	      ring
    73	    _ ≤ (R : ℚ) * (2 * L) ^ (d - 1) *
    74	        coeffAbsSum (eulerTail d) := by
    75	      gcongr
    76	      exact_mod_cast hh
    77	    _ = endpointUpper d R * (L : ℚ) ^ (d - 1) := by
    78	      simp only [endpointUpper]
    79	      push_cast
    80	      rw [mul_pow]
    81	      ring
    82

$ /bin/bash -lc 'lake env lean ENOTV/Endpoint.lean'
ENOTV/Endpoint.lean:77:6: warning: 'push_cast' tactic does nothing

Note: This linter can be disabled with `set_option linter.unusedTactic false`
ENOTV/Endpoint.lean:81:39: warning: Variable name `hd` is not explicitly referenced.

Hint: The binding can be removed (if unused) or named `_` (if used implicitly). Alternatively, prefix the name with `_` to silence this warning:
  [apply] _hd

Note: This linter can be disabled with `set_option linter.unusedVariables false`

$ /bin/bash -lc "cat >/tmp/Check.lean <<'EOF'
import Mathlib
#check Nat.choose_le_pow_two
#check Nat.choose_le_two_pow
#check Nat.choose_le_pow
#check Int.natAbs_ofNat
#check abs_intCast
#check norm_intCast
EOF
lake env lean /tmp/Check.lean"
/tmp/Check.lean:2:7: error(lean.unknownIdentifier): Unknown constant `Nat.choose_le_pow_two`
Nat.choose_le_two_pow (n k : ℕ) : n.choose k ≤ 2 ^ n
Nat.choose_le_pow (n k : ℕ) : n.choose k ≤ n ^ k
/tmp/Check.lean:5:7: error(lean.unknownIdentifier): Unknown constant `Int.natAbs_ofNat`
/tmp/Check.lean:6:7: error(lean.unknownIdentifier): Unknown identifier `abs_intCast`
/tmp/Check.lean:7:7: error(lean.unknownIdentifier): Unknown identifier `norm_intCast`

$ /bin/bash -lc 'lake build ENOTV.Endpoint && lake env lean ENOTV/Junction.lean'
⚠ [8679/8684] Replayed ENOTV.Energy
warning: ENOTV/Energy.lean:158:24: Used `tac1 <;> tac2` where `(tac1; tac2)` would suffice

Note: This linter can be disabled with `set_option linter.unnecessarySeqFocus false`
⚠ [8680/8684] Replayed ENOTV.Euler
info: ENOTV/Euler.lean:31:2: Try this:
  [apply] ring_nf
  
  The `ring` tactic failed to close the goal. Use `ring_nf` to obtain a normal form.
    
  Note that `ring` works primarily in *commutative* rings. If you have a noncommutative ring, abelian group or module, consider using `noncomm_ring`, `abel` or `module` instead.
warning: ENOTV/Euler.lean:124:15: Used `tac1 <;> tac2` where `(tac1; tac2)` would suffice

Note: This linter can be disabled with `set_option linter.unnecessarySeqFocus false`
warning: ENOTV/Euler.lean:123:4: 'congr 2' tactic does nothing

Note: This linter can be disabled with `set_option linter.unusedTactic false`
warning: ENOTV/Euler.lean:163:6: Used `tac1 <;> tac2` where `(tac1; tac2)` would suffice

Note: This linter can be disabled with `set_option linter.unnecessarySeqFocus false`
⚠ [8681/8684] Replayed ENOTV.Counterexample
warning: ENOTV/Counterexample.lean:111:53: This simp argument is unused:
  h2

Hint: Omit it from the simp argument list.
  [apply] simp [pairDatumNat_apply, pairJumpNat_apply, h4, blockPrefix_succ]

Note: This linter can be disabled with `set_option linter.unusedSimpArgs false`
warning: ENOTV/Counterexample.lean:134:59: This simp argument is unused:
  h₄

Hint: Omit it from the simp argument list.
  [apply] simp [pairDatumNat_apply, pairJumpNat_apply, h₁, h42, h412, h414, hsub]

Note: This linter can be disabled with `set_option linter.unusedSimpArgs false`
warning: ENOTV/Counterexample.lean:356:4: `push_neg` has been deprecated. Prefer using `push Not` instead.
If you'd rather continue using `push_neg` in your project, you can implement it as follows:
```
open Lean.Parser.Tactic in
macro "push_neg" cfg:optConfig loc:(location)? : tactic =>
  `(tactic| push $cfg:optConfig N

$ /bin/bash -lc "nl -ba ENOTV/Junction.lean | sed -n '25,92p'"
25	      (blockPolynomial d L).eval (2 * L + x) + junctionCorrection d x := by
    26	  by_cases hx : x ≤ 0
    27	  · simp [junctionProfile, junctionCorrection, hx, blockPolynomial_eval]
    28	  · have hid := blockPoly_matching d L hL x
    29	    simp only [junctionProfile, junctionCorrection, if_neg hx,
    30	      blockPolynomial_eval]
    31	    linarith
    32	
    33	def shiftedBlockPolynomial (d L : ℕ) : ℚ[X] :=
    34	  (blockPolynomial d L).comp (X + C (2 * L))
    35	
    36	theorem shiftedBlockPolynomial_eval (d L : ℕ) (x : ℚ) :
    37	    (shiftedBlockPolynomial d L).eval x =
    38	      (blockPolynomial d L).eval (2 * L + x) := by
    39	  simp [shiftedBlockPolynomial]
    40	  congr 1
    41	  ring
    42	
    43	theorem shiftedBlockPolynomial_natDegree_le (d L : ℕ) :
    44	    (shiftedBlockPolynomial d L).natDegree ≤ d := by
    45	  rw [shiftedBlockPolynomial, Polynomial.natDegree_comp,
    46	    Polynomial.natDegree_X_add_C, mul_one]
    47	  exact blockPolynomial_natDegree_le d L
    48	
    49	theorem shiftedBlockPolynomial_high_difference (d L : ℕ) :
    50	    (fwdDiff (1 : ℚ))^[d + 1] (shiftedBlockPolynomial d L).eval = 0 := by
    51	  apply Polynomial.fwdDiff_iter_eq_zero_of_degree_lt
    52	  exact (shiftedBlockPolynomial_natDegree_le d L).trans_lt (Nat.lt_succ_self d)
    53	
    54	theorem junction_high_difference_eq (d L : ℕ) (hL : 0 < L) (x : ℚ) :
    55	    (fwdDiff (1 : ℚ))^[d + 1] (junctionProfile d L) x =
    56	      (fwdDiff (1 : ℚ))^[d + 1] (junctionCorrection d) x := by
    57	  have hfun : junctionProfile d L =
    58	      (shiftedBlockPolynomial d L).eval + junctionCorrection d := by
    59	    funext y
    60	    rw [Pi.add_apply, shiftedBlockPolynomial_eval, junctionProfile_eq d L hL]
    61	  rw [hfun, fwdDiff_iter_add, shiftedBlockPolynomial_high_difference]
    62	  rfl
    63	
    64	/-- A finite, explicit degree-dependent bound for all offsets whose
    65	`(d+1)`-point stencil crosses a junction. -/
    66	def ju

$ /bin/bash -lc 'lake env lean ENOTV/Junction.lean'
ENOTV/Junction.lean:88:58: error: Application type mismatch: The argument
  hs0
has type
  -(↑d + 1) ≤ s
but is expected to have type
  -1 ≤ s + ↑d
in the application
  And.intro hs0

$ /bin/bash -lc 'lake env lean ENOTV/Junction.lean'

$ /bin/bash -lc 'lake env lean ENOTV/Positive.lean'
ENOTV/Positive.lean:52:27: error: omega could not prove the goal:
a possible counterexample may satisfy the constraints
  a ≥ 2
where
 a := ↑m
ENOTV/Positive.lean:53:49: error: failed to prove positivity/nonnegativity/nonzeroness
Try this:
  [apply] ring_nf
  
  The `ring` tactic failed to close the goal. Use `ring_nf` to obtain a normal form.
    
  Note that `ring` works primarily in *commutative* rings. If you have a noncommutative ring, abelian group or module, consider using `noncomm_ring`, `abel` or `module` instead.
ENOTV/Positive.lean:69:6: error: unsolved goals
case e_a
hGN : DiscreteGagliardoNirenberg
hsource : SourceDominatesEnergy
m : ℕ
hm : 2 ≤ m
C : ℝ
hC : 0 ≤ C
hGNm : ∀ (v : CSeq), cJumpMoment (2 * m - 1) v ≤ C * camplitude v ^ (2 * m - 2) * dot (cdiffIter m v) (cdiffIter m v)
K : ℝ
hK : 0 < K
hloc : ∀ (u : CSeq), cEnergy (2 * m - 1) (cdiff u) ≤ K * cSource (2 * m - 1) u
u : CSeq
hsq : dot (cdiffIter m u) (cdiffIter m u) ≤ cEnergy (2 * m - 1) (cdiff u)
hU : 0 ≤ camplitude u ^ (2 * m - 2)
hscale : 0 ≤ C * camplitude u ^ (2 * m - 2)
⊢ C * camplitude u ^ (m * 2 - 2) = C * camplitude u ^ (m * 2 - 1 - 1) * K
ENOTV/Positive.lean:70:8: error: omega could not prove the goal:
a possible counterexample may satisfy the constraints
  a ≥ 2
where
 a := ↑m

$ /bin/bash -lc "sed -n '1,140p' ENOTV/Positive.lean"
import ENOTV.Energy

/-!
# Odd-order coercivity from the two analytic interfaces

The only standard analytic result absent from mathlib is the all-order
discrete Gagliardo--Nirenberg inequality.  We expose it as a named
hypothesis rather than hiding it as an axiom.  The ENO-specific source
localization interface is kept separate.
-/

noncomputable section

namespace ENOTV

/-- Standard discrete Gagliardo--Nirenberg inequality used in the paper. -/
def DiscreteGagliardoNirenberg : Prop :=
  ∀ m : ℕ, 2 ≤ m →
    ∃ C : ℝ, 0 ≤ C ∧ ∀ v : CSeq,
      cJumpMoment (2 * m - 1) v ≤
        C * camplitude v ^ (2 * m - 2) *
          dot (cdiffIter m v) (cdiffIter m v)

/-- The direction of the source-localization theorem needed for odd
coercivity.  This is intentionally a separately named interface: it is the
paper's ENO-specific combinatorial theorem, not part of the standard
analytic hypothesis above. -/
def SourceDominatesEnergy : Prop :=
  ∀ k : ℕ, 2 ≤ k →
    ∃ K : ℝ, 0 < K ∧ ∀ u : CSeq,
      cEnergy k (cdiff u) ≤ K * cSource k u

theorem cdiffIter_cdiff (n : ℕ) (u : CSeq) :
    cdiffIter n (cdiff u) = cdiffIter (n + 1) u := by
  change cdiffIter n (cdiffIter 1 u) = cdiffIter (n + 1) u
  exact cdiffIter_add n 1 u

theorem odd_coercive_of_interfaces
    (hGN : DiscreteGagliardoNirenberg)
    (hsource : SourceDominatesEnergy)
    (m : ℕ) (hm : 2 ≤ m) :
    CCoercive (2 * m - 1) := by
  obtain ⟨C, hC, hGNm⟩ := hGN m hm
  obtain ⟨K, hK, hloc⟩ := hsource (2 * m - 1) (by omega)
  refine ⟨C * K, mul_nonneg hC hK.le, ?_⟩
  intro u
  have hsq :
      dot (cdiffIter m u) (cdiffIter m u) ≤
        cEnergy (2 * m - 1) (cdiff u) := by
    have he := square_energy_le_localized (m - 1) (cdiff u)
    rw [cdiffIter_cdiff, show m - 1 + 1 = m by omega] at he
    convert he using 1 <;> omega
  have hU : 0 ≤ camplitude u ^ (2 * m - 2) := by positivity
  have hscale : 0 ≤ C * camplitude u ^ (2 * m - 2) :=
    mul_nonneg hC hU
  calc
    cJumpMoment (2 * m - 1) u ≤
        C * camplitude u ^ (

$ /bin/bash -lc "nl -ba ENOTV/Positive.lean | sed -n '45,80p'"
45	  refine ⟨C * K, mul_nonneg hC hK.le, ?_⟩
    46	  intro u
    47	  have hsq :
    48	      dot (cdiffIter m u) (cdiffIter m u) ≤
    49	        cEnergy (2 * m - 1) (cdiff u) := by
    50	    have he := square_energy_le_localized (m - 1) (cdiff u)
    51	    rw [cdiffIter_cdiff, show m - 1 + 1 = m by omega] at he
    52	    convert he using 1 <;> omega
    53	  have hU : 0 ≤ camplitude u ^ (2 * m - 2) := by positivity
    54	  have hscale : 0 ≤ C * camplitude u ^ (2 * m - 2) :=
    55	    mul_nonneg hC hU
    56	  calc
    57	    cJumpMoment (2 * m - 1) u ≤
    58	        C * camplitude u ^ (2 * m - 2) *
    59	          dot (cdiffIter m u) (cdiffIter m u) := hGNm u
    60	    _ ≤ C * camplitude u ^ (2 * m - 2) *
    61	          cEnergy (2 * m - 1) (cdiff u) := by gcongr
    62	    _ ≤ C * camplitude u ^ (2 * m - 2) *
    63	          (K * cSource (2 * m - 1) u) := by
    64	      gcongr
    65	      exact hloc u
    66	    _ = (C * K) * camplitude u ^ (2 * m - 1 - 1) *
    67	          cSource (2 * m - 1) u := by
    68	      congr 1
    69	      · ring
    70	      · omega
    71	
    72	end ENOTV

$ /bin/bash -lc "rg -n \"theorem square_energy|def cEnergy\" ENOTV/Energy.lean && sed -n '140,230p' ENOTV/Energy.lean"
146:def cEnergy (k : ℕ) (a : CSeq) : ℝ :=
185:theorem square_energy_le_localized (s : ℕ) (a : CSeq) :
      (-1 : ℝ) ^ s * dot (cshiftIter s a) (cdiffIter (2 * s) a) := by
  rw [dot_diffIter_left, cdiffIter_add]
  congr 3
  omega

/-- Selection-free localized source functional `Eₖ`. -/
def cEnergy (k : ℕ) (a : CSeq) : ℝ :=
  (cdiffIter (k - 1) a).sum fun j w =>
    blockAmplitude k (a : Seq) j * |w|

theorem blockAmplitude_nonneg (k : ℕ) (a : Seq) (j : ℤ) :
    0 ≤ blockAmplitude k a j := by
  by_cases hk : 0 < k
  · unfold blockAmplitude
    simp only [dif_pos hk]
    apply le_trans (abs_nonneg (a j))
    have hle := Finset.le_sup' (f := fun s : ℕ => |a (j + (s : ℤ))|)
      (show 0 ∈ Finset.range k by simpa)
    convert hle using 1 <;> simp
  · simp [blockAmplitude, hk]

theorem abs_le_blockAmplitude {k s : ℕ} (hs : s < k) (a : Seq) (j : ℤ) :
    |a (j + s)| ≤ blockAmplitude k a j := by
  have hk : 0 < k := Nat.zero_lt_of_lt hs
  unfold blockAmplitude
  simp only [dif_pos hk]
  apply Finset.le_sup' (f := fun q : ℕ => |a (j + (q : ℤ))|)
  simpa using hs

theorem cEnergy_nonneg (k : ℕ) (a : CSeq) : 0 ≤ cEnergy k a := by
  apply Finsupp.sum_nonneg
  intro j hj
  exact mul_nonneg (blockAmplitude_nonneg k (a : Seq) j) (abs_nonneg _)

theorem dot_eq_finsupp_sum (f g : CSeq) :
    dot f g = f.sum fun i x => x * g i := by
  have hs : Function.support (fun i => f i * g i) ⊆ (f.support : Set ℤ) := by
    intro i hi
    by_contra hif
    have hzero := Finsupp.notMem_support_iff.mp hif
    exact hi (by simp [hzero])
  rw [dot, tsum_eq_sum' hs]
  rfl

/-- Absolute form of the even-difference square estimate. -/
theorem square_energy_le_localized (s : ℕ) (a : CSeq) :
    dot (cdiffIter s a) (cdiffIter s a) ≤ cEnergy (2 * s + 1) a := by
  rw [even_difference_energy]
  have hsign : |(-1 : ℝ) ^ s| = 1 := by simp
  calc
    (-1 : ℝ) ^ s * dot (cshiftIter s a) (cdiffIter (2 * s) a)
        ≤ |(-1 : ℝ) ^ s * dot (cshiftIter s a) (cdiffIter (2 * s) a)| :=
      le_abs_self _
    _ = |

$ /bin/bash -lc 'lake env lean ENOTV/Positive.lean'

$ /bin/bash -lc 'rg -n "Theorem|Proposition|Lemma|ENO-TV|Main" ../paper.txt | head -80 && rg --files ENOTV && wc -l ENOTV/*.lean'
279:Theorem A (Parity classification on the uniform grid). For each integer
311:in Proposition 4.9.
339:Theorem B (Large-jump and quotient coercivity). For every k ≥ 2, every
367:isolated in Theorem B also provide the natural setting for a separate local
376:interfaces. Lemma 6.6 shows that, at each homogeneous Taylor degree, this
392:Theorem C concerns the homogeneous Taylor components of this quantity
439:Theorem C (Shift cohomology and a fourth-order entropy-flux obstruction).
558:Theorem D (Quasi-uniform coercivity and irregular-mesh failure).
621:The starting point for Theorems A and B is a localized form of the FMT
686:For Theorem C, let Tm
962:Lemma 2.1 (Monotonicity and nesting of stencil endpoints). For every
1058:accompanying upper bound are stated in [9, Theorem 1.1]. More precisely,
1059:[9, Lemma 2.1] expands the reconstructed interface jump as a sum over
1061:[9, Lemma 2.2] determines the sign of each summand. Reindexing those
1090:Proposition 2.2 (Localized FMT source formula). For every k ≥ 2 and
1168:[9, Lemma 2.1] with p = k and translate the half-integer stencil offsets used
1190:Lemma 2.1] becomes
1224:Now, [9, Lemma 2.2] applies term by term to (2.27) and gives (2.22).
1265:Lemma 2.3 (Local amplitude bound). For every 1 ≤ ℓ ≤ k, there is a
1408:Proof. The first comparison is (2.26). By Lemma 2.1, the intervals Bi partition Z. Thus each j belongs to a unique nonempty interval, and Lemma 2.3
1523:This proves the third-order assertion of Theorem A.
1530:Theorem 3.1 (Discrete Gagliardo–Nirenberg inequality). Let m ≥ 2. Every
1561:Lemma 3.2 (Stability of cardinal B-spline translates). Let M ≥ 0 and
1645:Proof of Theorem 3.1. For a finitely supported sequence v, define its spline
1665:Applying the lower estimate in Lemma 3.2 to Sv′ yields
1713:Lemma 3.3 (Even-difference energy identity). Let s ≥ 1 and let a be finitely
1777:Proposition 3.4 (Odd-order discrete interpolation estimate). Let m ≥ 2,
1787:that m ≥ 3. Applying Theorem 3.1 and using Dm v = Dm

$ /bin/bash -lc "sed -n '250,335p' ../paper.txt; sed -n '1000,1460p' ../paper.txt; sed -n '1510,1830p' ../paper.txt; sed -n '1815,2320p' ../paper.txt"
action on polynomial jump profiles. At fourth order, for a cubic physical
flux and an explicit globally strictly convex entropy, a total-degree-seven
component of the reduced entropy-flux mismatch of the corresponding FMT
flux represents a nonzero class on polynomial jump profiles of degree at most
two. Consequently, that component admits no translation-invariant finitestencil C 7 local primitive at the zero constant state and, equivalently, the
corresponding entropy residual component cannot be canceled by a correction
in the stated local and smoothness class.
We finally turn to nonuniform meshes. The odd-order coercive estimate
persists on globally quasi-uniform meshes, with constants depending on the
mesh-ratio bound. Without a global ratio bound, coercivity can fail in every
order: for each k ≥ 2, we construct a fixed irregular mesh and a sequence of
compactly supported data for which the ENO source tends to zero while the
jump moment remains bounded below. The interfacewise FMT sign property
remains valid on nonuniform meshes, so
X
(k,h)
Qk,h (ū) =
|ai | |∆pi+1/2 |
i

identically. Thus no cancellation occurs between interface contributions. The
loss of coercivity is caused by the mesh geometry.
We now state the results summarized above.
1.1. Uniform-grid coercivity. Throughout the uniform-grid statements,
ENO reconstruction means the standard recursion fixed in Section 2; all
cell-average sequences are compactly supported. We write
U := ∥ū∥ℓ∞ .
Constants never depend on U , on the size of the support, or on the selected
stencils.
Theorem A (Parity classification on the uniform grid). For each integer
k ≥ 2, the estimate (1.4) holds for every compactly supported sequence of cell
averages on the unit grid if and only if k = 2 or k is odd. More precisely, for
every odd k ≥ 3,
X
(1.6)
|ai |k+1 ≤ Ck U k−1 Qk (ū),
i

whereas for every even k ≥ 4 no constant Ck makes (1.4) valid for all such
data. Indeed, there are compactly supported sequences ū(L) , with a(L) :=

$ /bin/bash -lc "sed -n '2300,2365p' ../paper.txt; sed -n '850,1010p' ../paper.txt"
= 0 whenever all those entries vanish; otherwise Aj

> 0.

(k)
Since Aj |Dk−1 aj | = 0, it follows in either case that

(4.24)

Dk−1 aj = 0

for every j ∈ Z.

Choose a finite integer interval containing the support of a and whose first
k − 1 entries lie strictly to the left of that support. With i0 denoting its left
endpoint, these zero entries give (Dq a)i0 = 0 for 0 ≤ q ≤ k − 2. Applying
(4.1) with r = k − 2 shows that a vanishes on the whole interval, and hence
on Z, a contradiction.
□
Let L tend to infinity through the even integers and choose
(4.25)

N := Ld .

Then N is even, and the joining-point term N Ld−1 = L2d−1 in the source
upper bound dominates the endpoint term L2d−2 . The denominator below is
positive by Lemma 4.6. Since k = d + 2, (4.23) now gives
X L,N
|ai |k+1
N L1+d(k+1)
i

 ≥ ck L.
≥
c
(4.26)
k
L,N
(d+1)(k−1) N Ld−1 + L2d−2
L
∥ūL,N ∥k−1
Q
(ū
)
∞
k
ℓ
Thus no order-dependent constant can give full coercivity when k ≥ 4 is even.
The unperturbed Euler blocks may give equality in some of the divideddifference comparisons used by the ENO recursion. We now show that these
equalities play no role in the failure of coercivity.
For fixed L and N , choose an integer interval IL,N containing the support
of aL,N together with a 2k-site buffer at both ends. Set




X
(4.27)
VL,N := b ∈ RIL,N :
bi = 0 .


i∈IL,N

By (4.12), aL,N ∈ VL,N . Every sequence in this space is extended by zero
outside IL,N and determines an associated compactly supported cell-average
(2.9)
Vn+1/2 :=
ūm
m=−∞

These values are well defined, eventually constant at both ends, and are the
interface values of an antiderivative of the piecewise-constant function equal
to ūn on In . In particular,
Vn+1/2 − Vn−1/2 = ūn .
(k)

Let Pi be the polynomial of degree at most k interpolating V at the k + 1
boundary points
(2.10)

xr(k) −1/2 , xr(k) +1/2 , . . . , xr(k) +k−1/2 .
i

i

i

We call this boundary-point set the interpolation stencil for V . On each
selected cell, the difference o

$ /bin/bash -lc "sed -n '740,960p' ../paper.txt"
The unit spacing gives the exact normalization
(2.3)

[ūj , . . . , ūj+ℓ ] =

Dℓ ūj
Dℓ−1 aj
=
,
(ℓ + 1)!
(ℓ + 1)!

ℓ ≥ 1.

12

Z. LI AND K. WU

Thus, at each level, the ENO comparison is a comparison of two adjacent
finite differences of the jump sequence; the common factorial in (2.3) does
not affect the decision.
(ℓ)
We now fix the standard ENO recursion, following [9]. Let ri denote the
left endpoint of the ℓ-cell stencil associated with cell i. Starting with
(1)

(2.4)

ri

= i,

(ℓ)
suppose that ri = r has been chosen.

Define the two candidate divided

differences
(ℓ)

(2.5)

(ℓ)

Li := [ūr−1 , . . . , ūr+ℓ−1 ],

Ri := [ūr , . . . , ūr+ℓ ].

For 1 ≤ ℓ < k, set

r(ℓ) − 1,
i

(ℓ+1)
ri
=
r(ℓ) ,
i

(2.6)

(ℓ)

(ℓ)

(ℓ)

(ℓ)

|Li | < |Ri |,
|Li | ≥ |Ri |.

The final stencil is
(k)

Si

(2.7)

(k)

(k)

:= {ri , ri

(k)

+ 1, . . . , ri

+ k − 1}.

(k)

Let pi be the unique polynomial of degree at most k − 1 whose cell
(k)
averages on the cells indexed by Si are the prescribed values:
Z
(k)
(k)
(2.8)
pi (x) dx = ūj ,
j ∈ Si .
Ij

We pass from cell-average reconstruction to point-value interpolation by
introducing cumulative interface values. Since ū is compactly supported,
define
n
X
(2.9)
Vn+1/2 :=
ūm
m=−∞

These values are well defined, eventually constant at both ends, and are the
interface values of an antiderivative of the piecewise-constant function equal
to ūn on In . In particular,
Vn+1/2 − Vn−1/2 = ūn .
(k)

Let Pi be the polynomial of degree at most k interpolating V at the k + 1
boundary points
(2.10)

xr(k) −1/2 , xr(k) +1/2 , . . . , xr(k) +k−1/2 .
i

i

i

We call this boundary-point set the interpolation stencil for V . On each
selected cell, the difference of the two interpolated interface values is its
(k)
(k)
prescribed cell average. Thus (Pi )′ has the same cell averages as pi , and
uniqueness gives
(2.11)

(k)

pi

(k)

= (Pi )′ .

RESOLUTION OF THE ENO–TV CONJECTURE

13

At the interface xi+1/2 , write
(k),−

(k)

(k),+

pi+1/2 

$ /bin/bash -lc "sed -n '1,240p' ENOTV/Basic.lean; sed -n '1,130p' ENOTV/Compact.lean"
import Mathlib

/-!
# The ENO--TV parity problem: basic discrete definitions

This file starts a self-contained formalization of the uniform-grid objects
in Sections 1--2 of the paper.  Sequences are represented as functions on
`ℤ`; compact support is recorded separately by `FiniteSupport`.
-/

noncomputable section

open scoped BigOperators

namespace ENOTV

abbrev Seq := ℤ → ℝ

/-- Forward lattice difference, `(D u) i = u (i+1) - u i`. -/
def diff (u : Seq) : Seq := fun i => u (i + 1) - u i

/-- Iterated forward difference. -/
def diffIter : ℕ → Seq → Seq
  | 0, u => u
  | n + 1, u => diff (diffIter n u)

/-- The cell-average jump sequence. -/
def jumps (u : Seq) : Seq := diff u

/-- The paper's compact-support convention. -/
def FiniteSupport (u : Seq) : Prop := Set.Finite (Function.support u)

/-- The maximum absolute value of a length-`k` jump block. -/
def blockAmplitude (k : ℕ) (a : Seq) (j : ℤ) : ℝ :=
  if hk : 0 < k then
    Finset.sup' (Finset.range k) (by simp [Nat.ne_of_gt hk])
      fun s : ℕ => |a (j + (s : ℤ))|
  else 0

/-- ENO's recursively selected left endpoint.

`enoLeft u i ell` is the endpoint of the `(ell+1)`-cell stencil: level
`ell = 0` starts at cell `i`, and each successor performs the paper's
strict-left / weak-right comparison.
-/
def enoLeft (u : Seq) (i : ℤ) : ℕ → ℤ
  | 0 => i
  | ell + 1 =>
      let r := enoLeft u i ell
      let a := jumps u
      if |diffIter ell a (r - 1)| < |diffIter ell a r| then r - 1 else r

/-- The final-level half-open endpoint interval `Bᵢ⁽ᵏ⁾`. -/
def selectedInterval (k : ℕ) (u : Seq) (i j : ℤ) : Prop :=
  enoLeft u i (k - 1) ≤ j ∧ j < enoLeft u (i + 1) (k - 1)

/-- The coefficient `γ_{k,d}` in the localized FMT formula. -/
def gamma (k d : ℕ) : ℝ :=
  ((-1 : ℝ) ^ (k - 1 - d) * d.factorial * (k - 1 - d).factorial) /
    k.factorial

/-- The localized reconstructed interface jump of Proposition 2.2.

The sum is written as a finite interval sum.  It is empty when adjacent
selected endpoints agree.
-/
def rec

$ /bin/bash -lc "sed -n '1,500p' ENOTV/Counterexample.lean"
import ENOTV.Energy
import ENOTV.Euler

/-!
# Compact Euler-block data

This file constructs the compact two-block building block used in the
even-order obstruction.  We first work on `ℕ`, where prefix sums have clean
index arithmetic, and then embed the result in the integer lattice.
-/

noncomputable section

open scoped BigOperators

namespace ENOTV

abbrev NSeq := ℕ →₀ ℝ

/-- Extend a compact sequence on `ℕ` by zero to the negative integers. -/
def liftNat (f : NSeq) : CSeq :=
  Finsupp.onFinset
    (f.support.map ⟨Int.ofNat, Int.ofNat_injective⟩)
    (fun i => if 0 ≤ i then f i.toNat else 0)
    (by
      intro i hi
      split_ifs at hi with h
      · rw [Finset.mem_map]
        refine ⟨i.toNat, Finsupp.mem_support_iff.mpr hi, ?_⟩
        simpa using (Int.toNat_of_nonneg h).symm
      · exact (hi rfl).elim)

@[simp] theorem liftNat_apply_of_nonneg (f : NSeq) {i : ℤ} (hi : 0 ≤ i) :
    liftNat f i = f i.toNat := by
  simp [liftNat, hi]

@[simp] theorem liftNat_apply_nat (f : NSeq) (n : ℕ) :
    liftNat f n = f n := by simp [liftNat]

@[simp] theorem liftNat_apply_of_neg (f : NSeq) {i : ℤ} (hi : i < 0) :
    liftNat f i = 0 := by simp [liftNat, not_le_of_gt hi]

/-- Real-valued sample of the rational block polynomial. -/
def realBlock (d L t : ℕ) : ℝ := (blockPoly d L t : ℚ)

/-- Prefix sum of one positive Euler block. -/
def blockPrefix (d L r : ℕ) : ℝ :=
  ∑ t ∈ Finset.range r, realBlock d L t

@[simp] theorem blockPrefix_zero (d L : ℕ) : blockPrefix d L 0 = 0 := by
  simp [blockPrefix]

theorem blockPrefix_succ (d L r : ℕ) :
    blockPrefix d L (r + 1) = blockPrefix d L r + realBlock d L r := by
  simp [blockPrefix, Finset.sum_range_succ]

/-- Cell-average profile for a positive block followed by a negative copy.
It starts and ends at zero. -/
def pairDatumNat (d L : ℕ) : NSeq :=
  Finsupp.onFinset (Finset.range (4 * L + 1))
    (fun r =>
      if r ≤ 2 * L then blockPrefix d L r
      else if r ≤ 4 * L then blockPrefix d L (2 * L) - blockPrefix d L (r - 2 * 

$ /bin/bash -lc "sed -n '1,240p' ENOTV/Euler.lean; sed -n '1,180p' ENOTV/Junction.lean; sed -n '1,150p' ENOTV/Endpoint.lean"
import ENOTV.Compact
import Mathlib.NumberTheory.BernoulliPolynomials

/-!
# Euler polynomials and the matching identity

The even-order counterexample uses the polynomial `E_d` characterized by
`E_d(x+1)+E_d(x)=2x^d`.  We construct it explicitly from Bernoulli
polynomials, so no existence axiom is hidden in the construction.
-/

noncomputable section

open scoped BigOperators
open Polynomial

namespace ENOTV

/-- The Euler polynomial over `ℚ`, in its Bernoulli-polynomial formula. -/
def eulerPoly (d : ℕ) : ℚ[X] :=
  C ((2 : ℚ) ^ (d + 1) / (d + 1)) *
    ((Polynomial.bernoulli (d + 1)).comp (C (1 / 2 : ℚ) * (X + 1)) -
     (Polynomial.bernoulli (d + 1)).comp (C (1 / 2 : ℚ) * X))

theorem eulerPoly_eval (d : ℕ) (x : ℚ) :
    (eulerPoly d).eval x =
      (2 : ℚ) ^ (d + 1) / (d + 1) *
        ((Polynomial.bernoulli (d + 1)).eval ((x + 1) / 2) -
         (Polynomial.bernoulli (d + 1)).eval (x / 2)) := by
  simp only [eulerPoly, eval_mul, eval_C, eval_sub, eval_comp, eval_add, eval_X, eval_one]
  ring

/-- Defining Euler identity. -/
theorem eulerPoly_add_one (d : ℕ) (x : ℚ) :
    (eulerPoly d).eval (x + 1) + (eulerPoly d).eval x = 2 * x ^ d := by
  rw [eulerPoly_eval, eulerPoly_eval]
  have hB := Polynomial.bernoulli_eval_one_add (d + 1) (x / 2)
  rw [show (x + 1 + 1) / 2 = 1 + x / 2 by ring, hB]
  have hd1 : (d + 1 : ℚ) ≠ 0 := by positivity
  rw [Nat.add_sub_cancel, div_pow]
  field_simp [hd1]
  push_cast
  ring

theorem eulerPoly_polynomial_identity (d : ℕ) :
    (eulerPoly d).comp (X + 1) + eulerPoly d = C 2 * X ^ d := by
  apply Polynomial.funext
  intro x
  simpa [Polynomial.eval_comp, add_comm] using eulerPoly_add_one d x

theorem eulerPoly_natDegree_le (d : ℕ) : (eulerPoly d).natDegree ≤ d := by
  by_contra hle
  have hdn : d < (eulerPoly d).natDegree := Nat.lt_of_not_ge hle
  let n := (eulerPoly d).natDegree
  have hn0 : n ≠ 0 := by omega
  have hqdeg : (X + (1 : ℚ[X])).natDegree = 1 := by
    simpa only [Polynomial.C_1] using Polynomial.natDegree_X_add_C (1 : ℚ

$ /bin/bash -lc 'rg -n "fwdDiff.*iterate|fwdDiff.*sum|iterate.*fwdDiff|fwdDiff_apply" .lake/packages/mathlib/Mathlib/Algebra/Polynomial .lake/packages/mathlib/Mathlib | head -80'
rg: .lake/packages/mathlib/Mathlib/Algebra/Polynomial: No such file or directory (os error 2)
rg: .lake/packages/mathlib/Mathlib: No such file or directory (os error 2)

$ /bin/bash -lc 'rg -n "fwdDiff.*iterate|fwdDiff.*sum|iterate.*fwdDiff|fwdDiff_apply" Mathlib | head -100'
Mathlib/NumberTheory/Padics/MahlerBasis.lean:125:  rw [fwdDiff_iter_eq_sum_shift]
Mathlib/NumberTheory/Padics/MahlerBasis.lean:144:  simp only [this, fwdDiff_iter_eq_sum_shift (1 : M) f n, mul_comm, nsmul_one, mul_smul, add_comm,
Mathlib/NumberTheory/Padics/MahlerBasis.lean:318:    simp only [fwdDiff_iter_eq_sum_shift, zero_add]
Mathlib/NumberTheory/Padics/MahlerBasis.lean:324:    simp only [fwdDiff_iter_eq_sum_shift, smul_sum]
Mathlib/NumberTheory/Padics/MahlerBasis.lean:328:    simp only [fwdDiff_iter_eq_sum_shift, zero_add, sum_smul, smul_assoc,
Mathlib/NumberTheory/Padics/MahlerBasis.lean:332:    simp only [fwdDiff_iter_choose_zero, ite_smul, one_smul, zero_smul, sum_ite_eq,
Mathlib/Algebra/Group/ForwardDiff.lean:29:* `fwdDiff_iter_eq_sum_shift`: formula expressing the `n`-th forward difference of `f` at `y` as
Mathlib/Algebra/Group/ForwardDiff.lean:123:@[deprecated (since := "2026-04-08")] alias fwdDiff_finset_sum := fwdDiff_finsetSum
Mathlib/Algebra/Group/ForwardDiff.lean:133:  | succ n IH => simp only [iterate_succ_apply, fwdDiff_const_smul, IH]
Mathlib/Algebra/Group/ForwardDiff.lean:137:  simpa only [coe_fwdDiffₗ_pow] using map_sum (fwdDiffₗ M G h ^ n) f s
Mathlib/Algebra/Group/ForwardDiff.lean:139:@[deprecated (since := "2026-04-08")] alias fwdDiff_iter_finset_sum := fwdDiff_iter_finsetSum
Mathlib/Algebra/Group/ForwardDiff.lean:147:theorem fwdDiff_iter_eq_sum_shift (f : M → G) (n : ℕ) (y : M) :
Mathlib/Algebra/Group/ForwardDiff.lean:165:  simp [fwdDiff_iter_eq_sum_shift, add_right_comm]
Mathlib/Algebra/Group/ForwardDiff.lean:195:    simp only [iterate_succ_apply', add_assoc, add_comm 1 j, IH, fwdDiff_choose]
Mathlib/Algebra/Group/ForwardDiff.lean:202:      add_zero m ▸ fwdDiff_iter_choose 0 m, choose_zero_right, iterate_one, cast_one, fwdDiff_const,
Mathlib/Algebra/Group/ForwardDiff.lean:203:      fwdDiff_iter_eq_sum_shift, smul_zero, sum_const_zero]
Mathlib/Algebra/Group/ForwardDiff.lean:215:    simp only [pow_succ, iterate_succ_apply', fwdDiff, IH, ← mul_

$ /bin/bash -lc "sed -n '140,175p' Mathlib/Algebra/Group/ForwardDiff.lean; rg -n \"def fwdDiff\" Mathlib/Algebra/Group/ForwardDiff.lean | head"
section newton_formulae

/--
Express the `n`-th forward difference of `f` at `y` in terms of the values `f (y + k)`, for
`0 ≤ k ≤ n`.
-/
theorem fwdDiff_iter_eq_sum_shift (f : M → G) (n : ℕ) (y : M) :
    Δ_[h]^[n] f y = ∑ k ∈ range (n + 1), ((-1 : ℤ) ^ (n - k) * n.choose k) • f (y + k • h) := by
  -- rewrite in terms of `(shiftₗ - 1) ^ n`
  have : fwdDiffₗ M G h = shiftₗ M G h - 1 := by simp only [shiftₗ, add_sub_cancel_right]
  rw [← coe_fwdDiffₗ, this, ← Module.End.pow_apply]
  -- use binomial theorem `Commute.add_pow` to expand this
  have : Commute (shiftₗ M G h) (-1) := (Commute.one_right _).neg_right
  convert congr_fun (LinearMap.congr_fun (this.add_pow n) f) y
  · simp only [sub_eq_add_neg]
  · rw [LinearMap.sum_apply, sum_apply]
    congr 1 with k
    have : ((-1) ^ (n - k) * n.choose k : Module.End ℤ (M → G))
              = ↑((-1) ^ (n - k) * n.choose k : ℤ) := by norm_cast
    rw [mul_assoc, Module.End.mul_apply, this, Module.End.intCast_apply, map_smul,
      Pi.smul_apply, shiftₗ_pow_apply]

lemma fwdDiff_iter_comp_add (f : M → G) (m : M) (n : ℕ) (y : M) :
    Δ_[h]^[n] (fun r ↦ f (r + m)) y = (Δ_[h]^[n] f) (y + m) := by
  simp [fwdDiff_iter_eq_sum_shift, add_right_comm]

lemma fwdDiff_comp_add (f : M → G) (m : M) (y : M) :
    Δ_[h] (fun r ↦ f (r + m)) y = (Δ_[h] f) (y + m) :=
  fwdDiff_iter_comp_add h f m 1 y

/--
**Gregory-Newton formula** expressing `f (y + n • h)` in terms of the iterated forward differences
of `f` at `y`.
-/
theorem shift_eq_sum_fwdDiff_iter (f : M → G) (n : ℕ) (y : M) :
46:def fwdDiff (h : M) (f : M → G) : M → G := fun n ↦ f (n + h) - f n
94:def fwdDiffₗ : Module.End ℤ (M → G) where

$ /bin/bash -lc 'rg -i -n "gagliardo|nirenberg" Mathlib | head -100; rg -n "interpolation.*Lp|sobolev.*inequal|norm.*deriv" Mathlib/Analysis | head -100'
Mathlib/Analysis/FunctionalSpaces/SobolevInequality.lean:15:# Gagliardo-Nirenberg-Sobolev inequality
Mathlib/Analysis/FunctionalSpaces/SobolevInequality.lean:17:In this file we prove the Gagliardo-Nirenberg-Sobolev inequality.
Mathlib/Analysis/FunctionalSpaces/SobolevInequality.lean:108:/-- The main inductive step in the grid-lines lemma for the Gagliardo-Nirenberg-Sobolev inequality.
Mathlib/Analysis/FunctionalSpaces/SobolevInequality.lean:293:/-! ## The Gagliardo-Nirenberg-Sobolev inequality -/
Mathlib/Analysis/FunctionalSpaces/SobolevInequality.lean:297:/-- The **Gagliardo-Nirenberg-Sobolev inequality**.  Let `u` be a continuously differentiable
Mathlib/Analysis/FunctionalSpaces/SobolevInequality.lean:369:/-- The **Gagliardo-Nirenberg-Sobolev inequality**.  Let `u` be a continuously differentiable
Mathlib/Analysis/FunctionalSpaces/SobolevInequality.lean:438:/-- The **Gagliardo-Nirenberg-Sobolev inequality**.  Let `u` be a continuously differentiable
Mathlib/Analysis/FunctionalSpaces/SobolevInequality.lean:461:/-- The **Gagliardo-Nirenberg-Sobolev inequality**.  Let `u` be a continuously differentiable
Mathlib/Analysis/FunctionalSpaces/SobolevInequality.lean:592:/-- The **Gagliardo-Nirenberg-Sobolev inequality**.  Let `u` be a continuously differentiable
Mathlib/Analysis/FunctionalSpaces/SobolevInequality.lean:648:/-- The **Gagliardo-Nirenberg-Sobolev inequality**.  Let `u` be a continuously differentiable
Mathlib/Analysis/FunctionalSpaces/SobolevInequality.lean:699:/-- The **Gagliardo-Nirenberg-Sobolev inequality**.  Let `u` be a continuously differentiable
Mathlib/Analysis/ODE/Gronwall.lean:14:`norm_le_gronwallBound_of_norm_deriv_right_le`. It states that if `f : ℝ → E` satisfies `‖f a‖ ≤ δ`
Mathlib/Analysis/ODE/Gronwall.lean:22:Sec. 4.5][HubbardWest-ode], where `norm_le_gronwallBound_of_norm_deriv_right_le` is called
Mathlib/Analysis/ODE/Gronwall.lean:110:See also `norm_le_gronwallBound_of_norm_deriv_right_le` for a version bounding `‖f x‖`,
Mathlib/Analysis/OD

$ /bin/bash -lc "sed -n '285,390p' Mathlib/Analysis/FunctionalSpaces/SobolevInequality.lean; sed -n '430,485p' Mathlib/Analysis/FunctionalSpaces/SobolevInequality.lean"
have h4 : p = 1 + 1 / (↑#ι - 1) := by simp [field]; rw [mul_comm, hp.sub_one_mul_conj]
  rw [h4]
  convert lintegral_mul_prod_lintegral_pow_le μ h2 h3 hf
  field_simp
  simp

end DecidableEq

/-! ## The Gagliardo-Nirenberg-Sobolev inequality -/

variable {F : Type*} [NormedAddCommGroup F] [NormedSpace ℝ F]

/-- The **Gagliardo-Nirenberg-Sobolev inequality**.  Let `u` be a continuously differentiable
compactly-supported function `u` on `ℝⁿ`, for `n ≥ 2`.  (More literally we encode `ℝⁿ` as
`ι → ℝ` where `n := #ι` is finite and at least 2.)  Then the Lebesgue integral of the pointwise
expression `|u x| ^ (n / (n - 1))` is bounded above by the `n / (n - 1)`-th power of the Lebesgue
integral of the Fréchet derivative of `u`.

For a basis-free version, see `lintegral_pow_le_pow_lintegral_fderiv`. -/
theorem lintegral_pow_le_pow_lintegral_fderiv_aux [Fintype ι]
    {p : ℝ} (hp : Real.HolderConjugate #ι p)
    {u : (ι → ℝ) → F} (hu : ContDiff ℝ 1 u)
    (h2u : HasCompactSupport u) :
    ∫⁻ x, ‖u x‖ₑ ^ p ≤ (∫⁻ x, ‖fderiv ℝ u x‖ₑ) ^ p := by
  classical
  /- For a function `f` in one variable and `t ∈ ℝ` we have
  `|f(t)| = `|∫_{-∞}^t Df(s)∂s| ≤ ∫_ℝ |Df(s)| ∂s` where we use the fundamental theorem of calculus.
  For each `x ∈ ℝⁿ` we let `u` vary in one of the `n` coordinates and apply the inequality above.
  By taking the product over these `n` factors, raising them to the power `(n-1)⁻¹` and integrating,
  we get the inequality `∫ |u| ^ (n/(n-1)) ≤ ∫ x, ∏ i, (∫ xᵢ, |Du(update x i xᵢ)|)^(n-1)⁻¹`.
  The result then follows from the grid-lines lemma. -/
  have : (1 : ℝ) ≤ ↑#ι - 1 := by
    have hι : (2 : ℝ) ≤ #ι := by exact_mod_cast hp.lt
    linarith
  calc ∫⁻ x, ‖u x‖ₑ ^ p
      = ∫⁻ x, (‖u x‖ₑ ^ (1 / (#ι - 1 : ℝ))) ^ (#ι : ℝ) := by
        -- a little algebraic manipulation of the exponent
        congr! 2 with x
        rw [← ENNReal.rpow_mul, hp.conjugate_eq]
        field_simp
    _ = ∫⁻ x, ∏ _i : ι, ‖u x‖ₑ ^ (1 / (#ι - 1 : ℝ)) := by
        -- express the left-hand integr

$ /bin/bash -lc 'rg -n "lagrange|Lagrange" Mathlib/Algebra/Polynomial Mathlib | head -100'
Mathlib/NumberTheory/SumFourSquares.lean:11:# Lagrange's four square theorem
Mathlib/NumberTheory/SumFourSquares.lean:18:The proof used is close to Lagrange's original proof.
Mathlib/NumberTheory/SumFourSquares.lean:112:/-- Lagrange's **four squares theorem** for a prime number. Use `Nat.sum_four_squares` instead. -/
Mathlib/LinearAlgebra/Lagrange.lean:14:# Lagrange interpolation
Mathlib/LinearAlgebra/Lagrange.lean:20:* `Lagrange.basisDivisor x y`, with `x y : F`. These are the normalised irreducible factors of
Mathlib/LinearAlgebra/Lagrange.lean:21:  the Lagrange basis polynomials. They evaluate to `1` at `x` and `0` at `y` when `x` and `y`
Mathlib/LinearAlgebra/Lagrange.lean:23:* `Lagrange.basis v i` with `i : ι`: the Lagrange basis polynomial that evaluates to `1` at `v i`
Mathlib/LinearAlgebra/Lagrange.lean:25:* `Lagrange.interpolate v r` where `r : ι → F` is a function from the fintype to the field: the
Mathlib/LinearAlgebra/Lagrange.lean:26:  Lagrange interpolant that evaluates to `r i` at `x i` for all `i : ι`. The `r i` are the _values_
Mathlib/LinearAlgebra/Lagrange.lean:136:namespace Lagrange
Mathlib/LinearAlgebra/Lagrange.lean:146:Such polynomials are the building blocks for the Lagrange interpolants. -/
Mathlib/LinearAlgebra/Lagrange.lean:196:/-- Lagrange basis polynomials indexed by `s : Finset ι`, defined at nodes `v i` for a
Mathlib/LinearAlgebra/Lagrange.lean:203:theorem basis_empty : Lagrange.basis ∅ v i = 1 :=
Mathlib/LinearAlgebra/Lagrange.lean:207:theorem basis_singleton (i : ι) : Lagrange.basis {i} v i = 1 := by
Mathlib/LinearAlgebra/Lagrange.lean:208:  rw [Lagrange.basis, erase_singleton, prod_empty]
Mathlib/LinearAlgebra/Lagrange.lean:211:theorem basis_pair_left (hij : i ≠ j) : Lagrange.basis {i, j} v i = basisDivisor (v i) (v j) := by
Mathlib/LinearAlgebra/Lagrange.lean:212:  simp only [Lagrange.basis, hij, erase_insert_eq_erase, erase_eq_of_notMem, mem_singleton,
Mathlib/LinearAlgebra/Lagrange.lean:216:theorem basis_pair_right (hij : i ≠ j) 

$ /bin/bash -lc 'lake env lean ENOTV/Localization.lean'
ENOTV/Localization.lean:79:6: error: Type mismatch: After simplification, term
  h 0 (Decidable.byContradiction fun a => abs_diffIter_le_of_block._proof_1_1 a)
 has type
  @LE.le ℝ Real.instLE |a j| M
but is expected to have type
  @LE.le ℝ Real.instLE |diffIter 0 a j| M
ENOTV/Localization.lean:81:26: error: Invalid rewrite argument: Expected an equality or iff proof or definition name, but `abs_sub ?a ?b` is a proof of
  |?a - ?b| ≤ |?a| + |?b|
ENOTV/Localization.lean:101:9: error: unsolved goals
case zero
a : Seq
M : ℝ
hM : 0 ≤ M
j : ℤ
h : ∀ (s : ℕ), 1 ≤ s → s ≤ 0 → |a (j + ↑s)| ≤ M
⊢ |a j| ≤ |diffIter 0 a j|
Try this:
  [apply] ring_nf
  
  The `ring` tactic failed to close the goal. Use `ring_nf` to obtain a normal form.
    
  Note that `ring` works primarily in *commutative* rings. If you have a noncommutative ring, abelian group or module, consider using `noncomm_ring`, `abel` or `module` instead.
ENOTV/Localization.lean:110:19: error: Application type mismatch: The argument
  hM
has type
  0 ≤ M
but is expected to have type
  ∀ (s : ℕ), 1 ≤ s → s ≤ n → |a (j + ↑s)| ≤ M
in the application
  ih j hM
ENOTV/Localization.lean:111:14: error: No goals to be solved
ENOTV/Localization.lean:117:8: error: linarith failed to find a contradiction
a : Seq
M : ℝ
hM : 0 ≤ M
n : ℕ
ih : ∀ (j : ℤ), (∀ (s : ℕ), 1 ≤ s → s ≤ n → |a (j + ↑s)| ≤ M) → |a j| ≤ |diffIter n a j| + (2 ^ n - 1) * M
j : ℤ
h : ∀ (s : ℕ), 1 ≤ s → s ≤ n + 1 → |a (j + ↑s)| ≤ M
htail : |diffIter n a (j + 1)| ≤ 2 ^ n * M
hold : |a j| ≤ |diffIter n a j| + (2 ^ n - 1) * M
a✝ : |diffIter n a (j + 1) - diffIter n a j| + |diffIter n a (j + 1)| < |diffIter n a j|
⊢ False
failed
ENOTV/Localization.lean:132:9: error: unsolved goals
case zero
a : Seq
M : ℝ
hM : 0 ≤ M
j : ℤ
h : ∀ s < 0, |a (j + ↑s)| ≤ M
⊢ |a j| ≤ |diffIter 0 a j|
ENOTV/Localization.lean:142:25: error: Application type mismatch: The argument
  hM
has type
  0 ≤ M
but is expected to have type
  ∀ s < n, |a (j + 1 + ↑s)| ≤ M
in the application
  ih (j + 1) 

$ /bin/bash -lc "# inspect relevant theorem signatures via #check
cat > /tmp/Check.lean <<'EOF'
import Mathlib
#check Int.le_induction
#check Int.inductionOn
#check Int.eq_add_of_sub_eq
#check Int.toNat_of_nonneg
#check pow_le_pow_right₀
#check one_le_pow₀
#check Nat.le_induction
#check abs_add
#check abs_sub_comm
EOF
lake env lean /tmp/Check.lean"
Int.le_induction.{u_1} {m : ℤ} {motive : (n : ℤ) → m ≤ n → Sort u_1} (base : motive m ⋯)
  (succ : (n : ℤ) → (hmn : m ≤ n) → motive n hmn → motive (n + 1) ⋯) (n : ℤ) (hmn : m ≤ n) : motive n hmn
/tmp/Check.lean:3:7: error(lean.unknownIdentifier): Unknown constant `Int.inductionOn`
/tmp/Check.lean:4:7: error(lean.unknownIdentifier): Unknown constant `Int.eq_add_of_sub_eq`
Int.toNat_of_nonneg {a : ℤ} (h : 0 ≤ a) : ↑a.toNat = a
pow_le_pow_right₀.{u_2} {M₀ : Type u_2} [MonoidWithZero M₀] [Preorder M₀] {a : M₀} {m n : ℕ} [ZeroLEOneClass M₀]
  [PosMulMono M₀] (ha : 1 ≤ a) (hmn : m ≤ n) : a ^ m ≤ a ^ n
one_le_pow₀.{u_2} {M₀ : Type u_2} [MonoidWithZero M₀] [Preorder M₀] {a : M₀} [ZeroLEOneClass M₀] [PosMulMono M₀]
  (ha : 1 ≤ a) {n : ℕ} : 1 ≤ a ^ n
Nat.le_induction {m : ℕ} {P : (n : ℕ) → m ≤ n → Prop} (base : P m ⋯)
  (succ : ∀ (n : ℕ) (hmn : m ≤ n), P n hmn → P (n + 1) ⋯) (n : ℕ) (hmn : m ≤ n) : P n hmn
/tmp/Check.lean:9:7: error(lean.unknownIdentifier): Unknown identifier `abs_add`
abs_sub_comm.{u_1} {α : Type u_1} [Lattice α] [AddGroup α] (a b : α) : |a - b| = |b - a|

$ /bin/bash -lc "cat >/tmp/Check.lean <<'EOF'
import Mathlib
#check abs_add_le
#check abs_add
#check abs_sub
#check Int.le_induction
EOF
lake env lean /tmp/Check.lean"
abs_add_le.{u_1} {α : Type u_1} [Lattice α] [AddCommGroup α] [AddLeftMono α] (a b : α) : |a + b| ≤ |a| + |b|
/tmp/Check.lean:3:7: error(lean.unknownIdentifier): Unknown identifier `abs_add`
abs_sub.{u_1} {G : Type u_1} [AddCommGroup G] [LinearOrder G] [IsOrderedAddMonoid G] (a b : G) : |a - b| ≤ |a| + |b|
Int.le_induction.{u_1} {m : ℤ} {motive : (n : ℤ) → m ≤ n → Sort u_1} (base : motive m ⋯)
  (succ : (n : ℤ) → (hmn : m ≤ n) → motive n hmn → motive (n + 1) ⋯) (n : ℤ) (hmn : m ≤ n) : motive n hmn

$ /bin/bash -lc "nl -ba ENOTV/Localization.lean | sed -n '68,225p'"
68	      rw [diffIter, ih, Function.iterate_succ_apply']
    69	      rfl
    70	
    71	/-- A forward difference is bounded by `2^n` times a bound for its
    72	`n+1` input values. -/
    73	theorem abs_diffIter_le_of_block (n : ℕ) (a : Seq) (j : ℤ) (M : ℝ)
    74	    (hM : 0 ≤ M)
    75	    (h : ∀ s : ℕ, s ≤ n → |a (j + s)| ≤ M) :
    76	    |diffIter n a j| ≤ (2 : ℝ) ^ n * M := by
    77	  induction n generalizing j with
    78	  | zero =>
    79	      simpa using h 0 (by omega)
    80	  | succ n ih =>
    81	      rw [diffIter, diff, abs_sub]
    82	      calc
    83	        |diffIter n a (j + 1) - diffIter n a j|
    84	            ≤ |diffIter n a (j + 1)| + |diffIter n a j| :=
    85	          abs_sub _ _
    86	        _ ≤ 2 ^ n * M + 2 ^ n * M := by
    87	          gcongr
    88	          · apply ih
    89	            · exact hM
    90	            · intro s hs
    91	              convert h (s + 1) (by omega) using 1 <;> push_cast <;> ring
    92	          · exact ih j hM (fun s hs => h s (by omega))
    93	        _ = 2 ^ (n + 1) * M := by ring
    94	
    95	/-- Isolate the leftmost value in a forward difference. -/
    96	theorem abs_head_le_diff_add (n : ℕ) (a : Seq) (j : ℤ) (M : ℝ)
    97	    (hM : 0 ≤ M)
    98	    (h : ∀ s : ℕ, 1 ≤ s → s ≤ n → |a (j + s)| ≤ M) :
    99	    |a j| ≤ |diffIter n a j| + ((2 : ℝ) ^ n - 1) * M := by
   100	  induction n generalizing j with
   101	  | zero => simp
   102	  | succ n ih =>
   103	      have htail :
   104	          |diffIter n a (j + 1)| ≤ (2 : ℝ) ^ n * M := by
   105	        apply abs_diffIter_le_of_block n a (j + 1) M hM
   106	        intro s hs
   107	        convert h (s + 1) (by omega) (by omega) using 1 <;> push_cast <;> ring
   108	      have hold :
   109	          |a j| ≤ |diffIter n a j| + ((2 : ℝ) ^ n - 1) * M := by
   110	        apply ih j hM
   111	        intro s hs0 hsn
   112	        exact h s hs0 (by omega)
   113	      have hrec :
   114	          |diffIter n a j| ≤
   115	            |di

$ /bin/bash -lc "rg -n \"rw \\[localConstant\\]\" ENOTV/Localization.lean"
296:              rw [localConstant]
372:                rw [localConstant]

$ /bin/bash -lc 'lake env lean ENOTV/Localization.lean'
ENOTV/Localization.lean:89:14: error: Type mismatch
  hM
has type
  0 ≤ M
but is expected to have type
  ∀ s ≤ n, |a (j + 1 + ↑s)| ≤ M
ENOTV/Localization.lean:90:12: error: No goals to be solved
ENOTV/Localization.lean:92:23: error: Application type mismatch: The argument
  hM
has type
  0 ≤ M
but is expected to have type
  ∀ s ≤ n, |a (j + ↑s)| ≤ M
in the application
  ih j hM
Try this:
  [apply] ring_nf
  
  The `ring` tactic failed to close the goal. Use `ring_nf` to obtain a normal form.
    
  Note that `ring` works primarily in *commutative* rings. If you have a noncommutative ring, abelian group or module, consider using `noncomm_ring`, `abel` or `module` instead.
ENOTV/Localization.lean:107:56: warning: Used `tac1 <;> tac2` where `(tac1; tac2)` would suffice

Note: This linter can be disabled with `set_option linter.unnecessarySeqFocus false`
ENOTV/Localization.lean:107:70: warning: Used `tac1 <;> tac2` where `(tac1; tac2)` would suffice

Note: This linter can be disabled with `set_option linter.unnecessarySeqFocus false`
Try this:
  [apply] ring_nf
  
  The `ring` tactic failed to close the goal. Use `ring_nf` to obtain a normal form.
    
  Note that `ring` works primarily in *commutative* rings. If you have a noncommutative ring, abelian group or module, consider using `noncomm_ring`, `abel` or `module` instead.
ENOTV/Localization.lean:151:45: warning: Used `tac1 <;> tac2` where `(tac1; tac2)` would suffice

Note: This linter can be disabled with `set_option linter.unnecessarySeqFocus false`
ENOTV/Localization.lean:151:59: warning: Used `tac1 <;> tac2` where `(tac1; tac2)` would suffice

Note: This linter can be disabled with `set_option linter.unnecessarySeqFocus false`
ENOTV/Localization.lean:211:8: warning: `Int.le_induction` has been deprecated: Use `Int.leInduction` instead
ENOTV/Localization.lean:237:29: error: Type mismatch: After simplification, term
  hj
 has type
  i ≤ j ∧ j ≤ i
but is expected to have type
  j = i
ENOTV/Localization.lean:253:53

$ /bin/bash -lc "nl -ba ENOTV/Localization.lean | sed -n '245,410p'"
245	      ¬ |diffIter n (jumps u) (enoLeft u i n - 1)| <
   246	        |diffIter n (jumps u) (enoLeft u i n)| := by
   247	  simp only [enoLeft]
   248	  split_ifs with h
   249	  · constructor
   250	    · omega
   251	    · exact fun h' => (h' h).elim
   252	  · exact ⟨fun _ => h, fun _ => rfl⟩
   253	
   254	/-- Pointwise form of Lemma 2.3: every entry of the selected length-`ell`
   255	block is controlled by the interface jump selecting that block. -/
   256	theorem selected_block_bound
   257	    (ell : ℕ) (hell : 1 ≤ ell) (u : Seq) (i j : ℤ)
   258	    (hj : enoLeft u i (ell - 1) ≤ j ∧
   259	      j < enoLeft u (i + 1) (ell - 1)) :
   260	    ∀ s : ℕ, s < ell →
   261	      |jumps u (j + s)| ≤ localConstant ell * |jumps u i| := by
   262	  induction ell, hell using Nat.le_induction generalizing i j with
   263	  | base =>
   264	      have hji : j = i := by simpa [enoLeft] using hj
   265	      subst j
   266	      intro s hs
   267	      have : s = 0 := by omega
   268	      subst s
   269	      simp [localConstant_one]
   270	  | succ ell hell ih =>
   271	      intro s hs
   272	      let a := jumps u
   273	      let L := enoLeft u i (ell - 1)
   274	      let R := enoLeft u (i + 1) (ell - 1)
   275	      have hell0 : 0 < ell := by omega
   276	      have hlevel : ell + 1 - 1 = ell := by omega
   277	      rw [hlevel] at hj
   278	      have hLR : L < R := by
   279	        apply selectedInterval_nonempty_prev (ell := ell - 1)
   280	        convert lt_of_le_of_lt hj.1 hj.2 using 1 <;> omega
   281	      have hM : 0 ≤ localConstant ell * |a i| :=
   282	        mul_nonneg (localConstant_nonneg ell) (abs_nonneg _)
   283	      by_cases hjL : j < L
   284	      · have hjEq : j = L - 1 := by
   285	          have hb := enoLeft_bounds u i ell
   286	          simp only [enoLeft] at hj
   287	          split_ifs at hj <;> omega
   288	        have hmove :
   289	            |diffIter (ell - 1) a (L - 1)| <
   290	              |diffIter (ell - 1) a L| := by

$ /bin/bash -lc 'lake env lean ENOTV/Localization.lean'
Try this:
  [apply] ring_nf
  
  The `ring` tactic failed to close the goal. Use `ring_nf` to obtain a normal form.
    
  Note that `ring` works primarily in *commutative* rings. If you have a noncommutative ring, abelian group or module, consider using `noncomm_ring`, `abel` or `module` instead.
ENOTV/Localization.lean:74:5: warning: Variable name `hM` is not explicitly referenced.

Hint: The binding can be removed (if unused) or named `_` (if used implicitly). Alternatively, prefix the name with `_` to silence this warning:
  [apply] _hM

Note: This linter can be disabled with `set_option linter.unusedVariables false`
ENOTV/Localization.lean:90:49: warning: Used `tac1 <;> tac2` where `(tac1; tac2)` would suffice

Note: This linter can be disabled with `set_option linter.unnecessarySeqFocus false`
ENOTV/Localization.lean:90:63: warning: Used `tac1 <;> tac2` where `(tac1; tac2)` would suffice

Note: This linter can be disabled with `set_option linter.unnecessarySeqFocus false`
Try this:
  [apply] ring_nf
  
  The `ring` tactic failed to close the goal. Use `ring_nf` to obtain a normal form.
    
  Note that `ring` works primarily in *commutative* rings. If you have a noncommutative ring, abelian group or module, consider using `noncomm_ring`, `abel` or `module` instead.
ENOTV/Localization.lean:106:56: warning: Used `tac1 <;> tac2` where `(tac1; tac2)` would suffice

Note: This linter can be disabled with `set_option linter.unnecessarySeqFocus false`
ENOTV/Localization.lean:106:70: warning: Used `tac1 <;> tac2` where `(tac1; tac2)` would suffice

Note: This linter can be disabled with `set_option linter.unnecessarySeqFocus false`
Try this:
  [apply] ring_nf
  
  The `ring` tactic failed to close the goal. Use `ring_nf` to obtain a normal form.
    
  Note that `ring` works primarily in *commutative* rings. If you have a noncommutative ring, abelian group or module, consider using `noncomm_ring`, `abel` or `module` instead.
ENOTV/Localization.lean:150:45: warning: Us

$ /bin/bash -lc "nl -ba ENOTV/Localization.lean | sed -n '286,375p'"
286	          (by simpa [Nat.sub_add_cancel hell] using hstrict)
   287	        exact hp
   288	      have hM : 0 ≤ localConstant ell * |a i| :=
   289	        mul_nonneg (localConstant_nonneg ell) (abs_nonneg _)
   290	      by_cases hjL : j < L
   291	      · have hjEq : j = L - 1 := by
   292	          have hc := enoLeft_succ_cases u i (ell - 1)
   293	          rw [Nat.sub_add_cancel hell] at hc
   294	          change enoLeft u i ell = L - 1 ∨ enoLeft u i ell = L at hc
   295	          omega
   296	        have hmove :
   297	            |diffIter (ell - 1) a (L - 1)| <
   298	              |diffIter (ell - 1) a L| := by
   299	          have heq : enoLeft u i ell = L - 1 := by omega
   300	          have hm := (enoLeft_succ_moved_iff u i (ell - 1)).mp
   301	            (by simpa [Nat.sub_add_cancel hell, L] using heq)
   302	          simpa [a, L] using hm
   303	        have hold : ∀ q : ℕ, q < ell →
   304	            |a (L + q)| ≤ localConstant ell * |a i| :=
   305	          ih i L ⟨le_rfl, hLR⟩
   306	        have hdiff :
   307	            |diffIter (ell - 1) a L| ≤
   308	              2 ^ (ell - 1) * (localConstant ell * |a i|) := by
   309	          apply abs_diffIter_le_of_block _ _ _ _ hM
   310	          intro q hq
   311	          exact hold q (by omega)
   312	        rw [hjEq]
   313	        by_cases hs0 : s = 0
   314	        · subst s
   315	          have hhead := abs_head_le_diff_add (ell - 1) a (L - 1)
   316	            (localConstant ell * |a i|) hM
   317	            (fun q hq0 hq =>
   318	              by
   319	                convert hold (q - 1) (by omega) using 1 <;>
   320	                  push_cast <;> omega)
   321	          calc
   322	            |a (L - 1 + (0 : ℕ))| = |a (L - 1)| := by norm_num
   323	            _ ≤ |diffIter (ell - 1) a (L - 1)| +
   324	                  (2 ^ (ell - 1) - 1) *
   325	                    (localConstant ell * |a i|) := hhead
   326	            _ ≤ 2 ^ (ell - 1) * (localConstant ell * |a i|

$ /bin/bash -lc 'lake env lean ENOTV/Localization.lean'
Try this:
  [apply] ring_nf
  
  The `ring` tactic failed to close the goal. Use `ring_nf` to obtain a normal form.
    
  Note that `ring` works primarily in *commutative* rings. If you have a noncommutative ring, abelian group or module, consider using `noncomm_ring`, `abel` or `module` instead.
ENOTV/Localization.lean:74:5: warning: Variable name `hM` is not explicitly referenced.

Hint: The binding can be removed (if unused) or named `_` (if used implicitly). Alternatively, prefix the name with `_` to silence this warning:
  [apply] _hM

Note: This linter can be disabled with `set_option linter.unusedVariables false`
ENOTV/Localization.lean:90:49: warning: Used `tac1 <;> tac2` where `(tac1; tac2)` would suffice

Note: This linter can be disabled with `set_option linter.unnecessarySeqFocus false`
ENOTV/Localization.lean:90:63: warning: Used `tac1 <;> tac2` where `(tac1; tac2)` would suffice

Note: This linter can be disabled with `set_option linter.unnecessarySeqFocus false`
Try this:
  [apply] ring_nf
  
  The `ring` tactic failed to close the goal. Use `ring_nf` to obtain a normal form.
    
  Note that `ring` works primarily in *commutative* rings. If you have a noncommutative ring, abelian group or module, consider using `noncomm_ring`, `abel` or `module` instead.
ENOTV/Localization.lean:106:56: warning: Used `tac1 <;> tac2` where `(tac1; tac2)` would suffice

Note: This linter can be disabled with `set_option linter.unnecessarySeqFocus false`
ENOTV/Localization.lean:106:70: warning: Used `tac1 <;> tac2` where `(tac1; tac2)` would suffice

Note: This linter can be disabled with `set_option linter.unnecessarySeqFocus false`
Try this:
  [apply] ring_nf
  
  The `ring` tactic failed to close the goal. Use `ring_nf` to obtain a normal form.
    
  Note that `ring` works primarily in *commutative* rings. If you have a noncommutative ring, abelian group or module, consider using `noncomm_ring`, `abel` or `module` instead.
ENOTV/Localization.lean:150:45: warning: Us

$ /bin/bash -lc 'lake env lean ENOTV/Localization.lean'
Try this:
  [apply] ring_nf
  
  The `ring` tactic failed to close the goal. Use `ring_nf` to obtain a normal form.
    
  Note that `ring` works primarily in *commutative* rings. If you have a noncommutative ring, abelian group or module, consider using `noncomm_ring`, `abel` or `module` instead.
ENOTV/Localization.lean:74:5: warning: Variable name `hM` is not explicitly referenced.

Hint: The binding can be removed (if unused) or named `_` (if used implicitly). Alternatively, prefix the name with `_` to silence this warning:
  [apply] _hM

Note: This linter can be disabled with `set_option linter.unusedVariables false`
ENOTV/Localization.lean:90:49: warning: Used `tac1 <;> tac2` where `(tac1; tac2)` would suffice

Note: This linter can be disabled with `set_option linter.unnecessarySeqFocus false`
ENOTV/Localization.lean:90:63: warning: Used `tac1 <;> tac2` where `(tac1; tac2)` would suffice

Note: This linter can be disabled with `set_option linter.unnecessarySeqFocus false`
Try this:
  [apply] ring_nf
  
  The `ring` tactic failed to close the goal. Use `ring_nf` to obtain a normal form.
    
  Note that `ring` works primarily in *commutative* rings. If you have a noncommutative ring, abelian group or module, consider using `noncomm_ring`, `abel` or `module` instead.
ENOTV/Localization.lean:106:56: warning: Used `tac1 <;> tac2` where `(tac1; tac2)` would suffice

Note: This linter can be disabled with `set_option linter.unnecessarySeqFocus false`
ENOTV/Localization.lean:106:70: warning: Used `tac1 <;> tac2` where `(tac1; tac2)` would suffice

Note: This linter can be disabled with `set_option linter.unnecessarySeqFocus false`
Try this:
  [apply] ring_nf
  
  The `ring` tactic failed to close the goal. Use `ring_nf` to obtain a normal form.
    
  Note that `ring` works primarily in *commutative* rings. If you have a noncommutative ring, abelian group or module, consider using `noncomm_ring`, `abel` or `module` instead.
ENOTV/Localization.lean:150:45: warning: Us

$ /bin/bash -lc "cat >/tmp/Check.lean <<'EOF'
import Mathlib
#check Summable.tsum_comm
#check tsum_comm
#check tsum_fintype
#check Finsupp.sum_eq_tsum
#check tsum_ite_eq
#check tsum_eq_single
#check summable_of_ne_finset_zero
EOF
lake env lean /tmp/Check.lean"
Summable.tsum_comm.{u_1, u_2, u_3} {α : Type u_1} {β : Type u_2} {γ : Type u_3} [AddCommGroup α] [UniformSpace α]
  [IsUniformAddGroup α] [CompleteSpace α] [T0Space α] {f : β → γ → α} (h : Summable (Function.uncurry f)) :
  ∑' (c : γ) (b : β), f b c = ∑' (b : β) (c : γ), f b c
/tmp/Check.lean:3:7: error(lean.unknownIdentifier): Unknown identifier `tsum_comm`
tsum_fintype.{u_1, u_2} {α : Type u_1} {β : Type u_2} [AddCommMonoid α] [TopologicalSpace α] {L : SummationFilter β}
  [L.LeAtTop] [Fintype β] (f : β → α) : ∑'[L] (b : β), f b = ∑ b, f b
/tmp/Check.lean:5:7: error(lean.unknownIdentifier): Unknown constant `Finsupp.sum_eq_tsum`
tsum_ite_eq.{u_1, u_2} {α : Type u_1} {β : Type u_2} [AddCommMonoid α] [TopologicalSpace α] (b : β)
  [DecidablePred fun x => x = b] (a : β → α) (L : SummationFilter β := SummationFilter.unconditional β) [L.LeAtTop] :
  (∑'[L] (b' : β), if b' = b then a b' else 0) = a b
tsum_eq_single.{u_1, u_2} {α : Type u_1} {β : Type u_2} [AddCommMonoid α] [TopologicalSpace α] {L : SummationFilter β}
  [L.LeAtTop] {f : β → α} (b : β) (hf : ∀ (b' : β), b' ≠ b → f b' = 0) : ∑'[L] (b : β), f b = f b
summable_of_ne_finset_zero.{u_1, u_2} {α : Type u_1} {β : Type u_2} [AddCommMonoid α] [TopologicalSpace α]
  {L : SummationFilter β} {f : β → α} {s : Finset β} (hf : ∀ b ∉ s, f b = 0) [L.HasSupport] : Summable f L

$ /bin/bash -lc 'lake env lean ENOTV/Localization.lean'
Try this:
  [apply] ring_nf
  
  The `ring` tactic failed to close the goal. Use `ring_nf` to obtain a normal form.
    
  Note that `ring` works primarily in *commutative* rings. If you have a noncommutative ring, abelian group or module, consider using `noncomm_ring`, `abel` or `module` instead.
ENOTV/Localization.lean:74:5: warning: Variable name `hM` is not explicitly referenced.

Hint: The binding can be removed (if unused) or named `_` (if used implicitly). Alternatively, prefix the name with `_` to silence this warning:
  [apply] _hM

Note: This linter can be disabled with `set_option linter.unusedVariables false`
ENOTV/Localization.lean:90:49: warning: Used `tac1 <;> tac2` where `(tac1; tac2)` would suffice

Note: This linter can be disabled with `set_option linter.unnecessarySeqFocus false`
ENOTV/Localization.lean:90:63: warning: Used `tac1 <;> tac2` where `(tac1; tac2)` would suffice

Note: This linter can be disabled with `set_option linter.unnecessarySeqFocus false`
Try this:
  [apply] ring_nf
  
  The `ring` tactic failed to close the goal. Use `ring_nf` to obtain a normal form.
    
  Note that `ring` works primarily in *commutative* rings. If you have a noncommutative ring, abelian group or module, consider using `noncomm_ring`, `abel` or `module` instead.
ENOTV/Localization.lean:106:56: warning: Used `tac1 <;> tac2` where `(tac1; tac2)` would suffice

Note: This linter can be disabled with `set_option linter.unnecessarySeqFocus false`
ENOTV/Localization.lean:106:70: warning: Used `tac1 <;> tac2` where `(tac1; tac2)` would suffice

Note: This linter can be disabled with `set_option linter.unnecessarySeqFocus false`
Try this:
  [apply] ring_nf
  
  The `ring` tactic failed to close the goal. Use `ring_nf` to obtain a normal form.
    
  Note that `ring` works primarily in *commutative* rings. If you have a noncommutative ring, abelian group or module, consider using `noncomm_ring`, `abel` or `module` instead.
ENOTV/Localization.lean:150:45: warning: Us

$ /bin/bash -lc "cat >/tmp/Check.lean <<'EOF'
import Mathlib
#check Nat.find_min'
#check Nat.find_min
#check Nat.find_eq_iff
EOF
lake env lean /tmp/Check.lean"
Nat.find_min' {p : ℕ → Prop} [DecidablePred p] (H : ∃ n, p n) {m : ℕ} (h : p m) : Nat.find H ≤ m
Nat.find_min {p : ℕ → Prop} [DecidablePred p] (H : ∃ n, p n) {m : ℕ} : m < Nat.find H → ¬p m
Nat.find_eq_iff {m : ℕ} {p : ℕ → Prop} [DecidablePred p] (h : ∃ n, p n) : Nat.find h = m ↔ p m ∧ ∀ n < m, ¬p n

$ /bin/bash -lc 'lake env lean ENOTV/Localization.lean'
Try this:
  [apply] ring_nf
  
  The `ring` tactic failed to close the goal. Use `ring_nf` to obtain a normal form.
    
  Note that `ring` works primarily in *commutative* rings. If you have a noncommutative ring, abelian group or module, consider using `noncomm_ring`, `abel` or `module` instead.
ENOTV/Localization.lean:74:5: warning: Variable name `hM` is not explicitly referenced.

Hint: The binding can be removed (if unused) or named `_` (if used implicitly). Alternatively, prefix the name with `_` to silence this warning:
  [apply] _hM

Note: This linter can be disabled with `set_option linter.unusedVariables false`
ENOTV/Localization.lean:90:49: warning: Used `tac1 <;> tac2` where `(tac1; tac2)` would suffice

Note: This linter can be disabled with `set_option linter.unnecessarySeqFocus false`
ENOTV/Localization.lean:90:63: warning: Used `tac1 <;> tac2` where `(tac1; tac2)` would suffice

Note: This linter can be disabled with `set_option linter.unnecessarySeqFocus false`
Try this:
  [apply] ring_nf
  
  The `ring` tactic failed to close the goal. Use `ring_nf` to obtain a normal form.
    
  Note that `ring` works primarily in *commutative* rings. If you have a noncommutative ring, abelian group or module, consider using `noncomm_ring`, `abel` or `module` instead.
ENOTV/Localization.lean:106:56: warning: Used `tac1 <;> tac2` where `(tac1; tac2)` would suffice

Note: This linter can be disabled with `set_option linter.unnecessarySeqFocus false`
ENOTV/Localization.lean:106:70: warning: Used `tac1 <;> tac2` where `(tac1; tac2)` would suffice

Note: This linter can be disabled with `set_option linter.unnecessarySeqFocus false`
Try this:
  [apply] ring_nf
  
  The `ring` tactic failed to close the goal. Use `ring_nf` to obtain a normal form.
    
  Note that `ring` works primarily in *commutative* rings. If you have a noncommutative ring, abelian group or module, consider using `noncomm_ring`, `abel` or `module` instead.
ENOTV/Localization.lean:150:45: warning: Us

$ /bin/bash -lc "cat >/tmp/Check.lean <<'EOF'
import Mathlib
#check Finset.inf'
#check Finset.inf'_le
#check Finset.le_inf'
#check Finset.inf'_mem
#check Finset.min'
#check Finset.min'_mem
#check Finset.min'_le
#check Finset.le_min'
EOF
lake env lean /tmp/Check.lean"
Finset.inf'.{u_2, u_3} {α : Type u_2} {β : Type u_3} [SemilatticeInf α] (s : Finset β) (H : s.Nonempty) (f : β → α) : α
Finset.inf'_le.{u_2, u_3} {α : Type u_2} {β : Type u_3} [SemilatticeInf α] {s : Finset β} (f : β → α) {b : β}
  (h : b ∈ s) : s.inf' ⋯ f ≤ f b
Finset.le_inf'.{u_2, u_3} {α : Type u_2} {β : Type u_3} [SemilatticeInf α] {s : Finset β} (H : s.Nonempty) (f : β → α)
  {a : α} : (∀ b ∈ s, a ≤ f b) → a ≤ s.inf' H f
Finset.inf'_mem.{u_2, u_7} {α : Type u_2} [SemilatticeInf α] (s : Set α) (w : ∀ x ∈ s, ∀ y ∈ s, x ⊓ y ∈ s)
  {ι : Type u_7} (t : Finset ι) (H : t.Nonempty) (p : ι → α) (h : ∀ i ∈ t, p i ∈ s) : t.inf' H p ∈ s
Finset.min'.{u_2} {α : Type u_2} [LinearOrder α] (s : Finset α) (H : s.Nonempty) : α
Finset.min'_mem.{u_2} {α : Type u_2} [LinearOrder α] (s : Finset α) (H : s.Nonempty) : s.min' H ∈ s
Finset.min'_le.{u_2} {α : Type u_2} [LinearOrder α] (s : Finset α) (x : α) (H2 : x ∈ s) : s.min' ⋯ ≤ x
Finset.le_min'.{u_2} {α : Type u_2} [LinearOrder α] (s : Finset α) (H : s.Nonempty) (x : α) (H2 : ∀ y ∈ s, x ≤ y) :
  x ≤ s.min' H

$ /bin/bash -lc 'lake env lean ENOTV/SourceComparison.lean'
ENOTV/SourceComparison.lean:1:0: error: object file '/work/repro/.lake/build/lib/lean/ENOTV/Localization.olean' of module ENOTV.Localization does not exist

$ /bin/bash -lc 'lake build ENOTV.Localization && lake env lean ENOTV/SourceComparison.lean'
⚠ [8679/8680] Replayed ENOTV.Energy
warning: ENOTV/Energy.lean:158:24: Used `tac1 <;> tac2` where `(tac1; tac2)` would suffice

Note: This linter can be disabled with `set_option linter.unnecessarySeqFocus false`
⚠ [8680/8680] Built ENOTV.Localization (7.6s)
info: ENOTV/Localization.lean:90:67: Try this:
  [apply] ring_nf
  
  The `ring` tactic failed to close the goal. Use `ring_nf` to obtain a normal form.
    
  Note that `ring` works primarily in *commutative* rings. If you have a noncommutative ring, abelian group or module, consider using `noncomm_ring`, `abel` or `module` instead.
warning: ENOTV/Localization.lean:74:5: Variable name `hM` is not explicitly referenced.

Hint: The binding can be removed (if unused) or named `_` (if used implicitly). Alternatively, prefix the name with `_` to silence this warning:
  [apply] _hM

Note: This linter can be disabled with `set_option linter.unusedVariables false`
warning: ENOTV/Localization.lean:90:49: Used `tac1 <;> tac2` where `(tac1; tac2)` would suffice

Note: This linter can be disabled with `set_option linter.unnecessarySeqFocus false`
warning: ENOTV/Localization.lean:90:63: Used `tac1 <;> tac2` where `(tac1; tac2)` would suffice

Note: This linter can be disabled with `set_option linter.unnecessarySeqFocus false`
info: ENOTV/Localization.lean:106:74: Try this:
  [apply] ring_nf
  
  The `ring` tactic failed to close the goal. Use `ring_nf` to obtain a normal form.
    
  Note that `ring` works primarily in *commutative* rings. If you have a noncommutative ring, abelian group or module, consider using `noncomm_ring`, `abel` or `module` instead.
warning: ENOTV/Localization.lean:106:56: Used `tac1 <;> tac2` where `(tac1; tac2)` would suffice

Note: This linter can be disabled with `set_option linter.unnecessarySeqFocus false`
warning: ENOTV/Localization.lean:106:70: Used `tac1 <;> tac2` where `(tac1; tac2)` would suffice

Note: This linter can be disabled with `set_option linter.unnecessarySeqFocus false`
info: EN

$ /bin/bash -lc "rg -n \"theorem.*sum_mul|sum_mul\" Mathlib/Data/Finsupp Mathlib/Algebra | grep Finsupp | head -40; cat >/tmp/Check.lean <<'EOF'
import Mathlib
#check Finsupp.sum_mul
#check Finsupp.mul_sum
#check Finsupp.sum_congr
EOF
lake env lean /tmp/Check.lean"
Finsupp.sum_mul.{u_1, u_14, u_15} {α : Type u_1} {R : Type u_14} {S : Type u_15} [NonUnitalNonAssocSemiring R]
  [NonUnitalNonAssocSemiring S] (b : S) (s : α →₀ R) {f : α → R → S} : s.sum f * b = s.sum fun a c => f a c * b
Finsupp.mul_sum.{u_1, u_14, u_15} {α : Type u_1} {R : Type u_14} {S : Type u_15} [NonUnitalNonAssocSemiring R]
  [NonUnitalNonAssocSemiring S] (b : S) (s : α →₀ R) {f : α → R → S} : b * s.sum f = s.sum fun a c => b * f a c
Finsupp.sum_congr.{u_1, u_8, u_10} {α : Type u_1} {M : Type u_8} {N : Type u_10} [Zero M] [AddCommMonoid N] {f : α →₀ M}
  {g1 g2 : α → M → N} (h : ∀ x ∈ f.support, g1 x (f x) = g2 x (f x)) : f.sum g1 = f.sum g2

$ /bin/bash -lc 'lake env lean ENOTV/SourceComparison.lean'
ENOTV/SourceComparison.lean:40:2: error: unsolved goals
case pos
hFMT : FMTReconstructionTheorem
k : ℕ
hk : 2 ≤ k
u : CSeq
i j : ℤ
hj : selectedInterval k (⇑u) i j
hnon : 0 ≤ (cdiff u) i * (gamma k (i - j).toNat * (cdiffIter (k - 1) (cdiff u)) j)
⊢ |(cdiff u) i| * (|gamma k (i - j).toNat| * |(cdiffIter (k - 1) (cdiff u)) j|) =
    |(cdiff u) i| * |gamma k (i - j).toNat| * |(cdiffIter (k - 1) (cdiff u)) j|
ENOTV/SourceComparison.lean:67:4: error: `simp` made no progress
ENOTV/SourceComparison.lean:83:21: error: Tactic `rewrite` failed: Did not find an occurrence of the pattern
  if l ≤ j ∧ j < r then ?m.144 else ?m.145
in the target expression
  (cdiff u) i * (gamma k (i - j).toNat * diffIter (k - 1) (jumps ⇑u) j) =
    if selectedInterval k (⇑u) i j then (cdiff u) i * (gamma k (i - j).toNat * (cdiffIter (k - 1) (cdiff u)) j) else 0

k : ℕ
u : CSeq
i : ℤ
l : ℤ := enoLeft (⇑u) i (k - 1)
r : ℤ := enoLeft (⇑u) (i + 1) (k - 1)
hs : Function.support (rawSourceTerm k u i) ⊆ ↑(Finset.Ico l r)
j : ℤ
hj : l ≤ j ∧ j < r
⊢ (cdiff u) i * (gamma k (i - j).toNat * diffIter (k - 1) (jumps ⇑u) j) =
    if selectedInterval k (⇑u) i j then (cdiff u) i * (gamma k (i - j).toNat * (cdiffIter (k - 1) (cdiff u)) j) else 0
ENOTV/SourceComparison.lean:177:32: error(lean.unknownIdentifier): Unknown constant `Finset.range_nonempty.mpr`
ENOTV/SourceComparison.lean:180:33: warning: Variable name `hk` is not explicitly referenced.

Hint: The binding can be removed (if unused) or named `_` (if used implicitly). Alternatively, prefix the name with `_` to silence this warning:
  [apply] _hk

Note: This linter can be disabled with `set_option linter.unusedVariables false`
ENOTV/SourceComparison.lean:180:46: warning: Variable name `hd` is not explicitly referenced.

Hint: The binding can be removed (if unused) or named `_` (if used implicitly). Alternatively, prefix the name with `_` to silence this warning:
  [apply] _hd

Note: This linter can be disabled with `set_option linter.unusedVariables false

$ /bin/bash -lc "nl -ba ENOTV/SourceComparison.lean | sed -n '32,92p'; nl -ba ENOTV/SourceComparison.lean | sed -n '170,255p'"
32	      |cdiffIter (k - 1) (cdiff u) j|
    33	  else 0
    34	
    35	theorem rawSourceTerm_eq_positive
    36	    (hFMT : FMTReconstructionTheorem) {k : ℕ} (hk : 2 ≤ k)
    37	    (u : CSeq) (i j : ℤ) :
    38	    rawSourceTerm k u i j = positiveSourceTerm k u i j := by
    39	  by_cases hj : selectedInterval k (u : Seq) i j
    40	  · rw [rawSourceTerm, positiveSourceTerm, if_pos hj, if_pos hj]
    41	    have hnon := hFMT.2 k hk u i j hj
    42	    rw [← abs_of_nonneg hnon, abs_mul, abs_mul]
    43	  · simp [rawSourceTerm, positiveSourceTerm, hj]
    44	
    45	theorem cSource_eq_tsum (k : ℕ) (u : CSeq) :
    46	    cSource k u =
    47	      ∑' i : ℤ, cdiff u i * reconstructedJump k (u : Seq) i := by
    48	  have hs : Function.support
    49	      (fun i : ℤ => cdiff u i * reconstructedJump k (u : Seq) i) ⊆
    50	        (cdiff u).support := by
    51	    intro i hi
    52	    by_contra his
    53	    have hz := Finsupp.notMem_support_iff.mp his
    54	    exact hi (by simp [hz])
    55	  rw [cSource, tsum_eq_sum' hs]
    56	  rfl
    57	
    58	theorem interface_eq_tsum_raw (k : ℕ) (u : CSeq) (i : ℤ) :
    59	    cdiff u i * reconstructedJump k (u : Seq) i =
    60	      ∑' j : ℤ, rawSourceTerm k u i j := by
    61	  let l := enoLeft (u : Seq) i (k - 1)
    62	  let r := enoLeft (u : Seq) (i + 1) (k - 1)
    63	  have hs : Function.support (rawSourceTerm k u i) ⊆
    64	      (Finset.Ico l r : Set ℤ) := by
    65	    intro j hj
    66	    by_contra hmem
    67	    simp only [Finset.mem_Ico, not_and_or, not_le] at hmem
    68	    have hnot : ¬ selectedInterval k (u : Seq) i j := by
    69	      simp only [selectedInterval]
    70	      change ¬(l ≤ j ∧ j < r)
    71	      exact hmem
    72	    exact hj (by simp [rawSourceTerm, hnot])
    73	  rw [tsum_eq_sum' hs, reconstructedJump]
    74	  change cdiff u i *
    75	      (∑ j ∈ Finset.Ico l r,
    76	        gamma k (Int.toNat (i - j)) *
    77	          diffIter (k - 1) (jumps (u : Seq)) j) =
    78	    ∑ 

$ /bin/bash -lc "cat >/tmp/Check.lean <<'EOF'
import Mathlib
#check Int.toNat_lt
#check Int.toNat_lt_toNat
#check Int.toNat_of_nonneg
#check Int.toNat_lt_iff
EOF
lake env lean /tmp/Check.lean"
Int.toNat_lt {n : ℕ} {z : ℤ} (h : 0 ≤ z) : z.toNat < n ↔ z < ↑n
Int.toNat_lt_toNat {n m : ℤ} (hn : 0 < m) : n.toNat < m.toNat ↔ n < m
Int.toNat_of_nonneg {a : ℤ} (h : 0 ≤ a) : ↑a.toNat = a
/tmp/Check.lean:5:7: error(lean.unknownIdentifier): Unknown constant `Int.toNat_lt_iff`

$ /bin/bash -lc 'lake env lean ENOTV/SourceComparison.lean'
ENOTV/SourceComparison.lean:183:33: warning: Variable name `hk` is not explicitly referenced.

Hint: The binding can be removed (if unused) or named `_` (if used implicitly). Alternatively, prefix the name with `_` to silence this warning:
  [apply] _hk

Note: This linter can be disabled with `set_option linter.unusedVariables false`
ENOTV/SourceComparison.lean:183:46: warning: Variable name `hd` is not explicitly referenced.

Hint: The binding can be removed (if unused) or named `_` (if used implicitly). Alternatively, prefix the name with `_` to silence this warning:
  [apply] _hd

Note: This linter can be disabled with `set_option linter.unusedVariables false`
ENOTV/SourceComparison.lean:233:24: error(lean.invalidField): Invalid field `lt_succ`: The environment does not contain `Int.NonNeg.lt_succ`, so it is not possible to project the field `lt_succ` from an expression
  hd.right
of type
  (↑k - 1 - (selectedOwner k (⇑u) j - j)).NonNeg

$ /bin/bash -lc 'lake env lean ENOTV/SourceComparison.lean'
ENOTV/SourceComparison.lean:183:33: warning: Variable name `hk` is not explicitly referenced.

Hint: The binding can be removed (if unused) or named `_` (if used implicitly). Alternatively, prefix the name with `_` to silence this warning:
  [apply] _hk

Note: This linter can be disabled with `set_option linter.unusedVariables false`
ENOTV/SourceComparison.lean:183:46: warning: Variable name `hd` is not explicitly referenced.

Hint: The binding can be removed (if unused) or named `_` (if used implicitly). Alternatively, prefix the name with `_` to silence this warning:
  [apply] _hd

Note: This linter can be disabled with `set_option linter.unusedVariables false`

$ /bin/bash -lc 'lake env lean ENOTV/SourceComparison.lean'
ENOTV/SourceComparison.lean:183:33: warning: Variable name `hk` is not explicitly referenced.

Hint: The binding can be removed (if unused) or named `_` (if used implicitly). Alternatively, prefix the name with `_` to silence this warning:
  [apply] _hk

Note: This linter can be disabled with `set_option linter.unusedVariables false`
ENOTV/SourceComparison.lean:183:46: warning: Variable name `hd` is not explicitly referenced.

Hint: The binding can be removed (if unused) or named `_` (if used implicitly). Alternatively, prefix the name with `_` to silence this warning:
  [apply] _hd

Note: This linter can be disabled with `set_option linter.unusedVariables false`

$ /bin/bash -lc 'lake build ENOTV.SourceComparison && lake env lean ENOTV/EvenEnergy.lean'
⚠ [8679/8681] Replayed ENOTV.Energy
warning: ENOTV/Energy.lean:158:24: Used `tac1 <;> tac2` where `(tac1; tac2)` would suffice

Note: This linter can be disabled with `set_option linter.unnecessarySeqFocus false`
⚠ [8680/8681] Replayed ENOTV.Localization
info: ENOTV/Localization.lean:90:67: Try this:
  [apply] ring_nf
  
  The `ring` tactic failed to close the goal. Use `ring_nf` to obtain a normal form.
    
  Note that `ring` works primarily in *commutative* rings. If you have a noncommutative ring, abelian group or module, consider using `noncomm_ring`, `abel` or `module` instead.
warning: ENOTV/Localization.lean:74:5: Variable name `hM` is not explicitly referenced.

Hint: The binding can be removed (if unused) or named `_` (if used implicitly). Alternatively, prefix the name with `_` to silence this warning:
  [apply] _hM

Note: This linter can be disabled with `set_option linter.unusedVariables false`
warning: ENOTV/Localization.lean:90:49: Used `tac1 <;> tac2` where `(tac1; tac2)` would suffice

Note: This linter can be disabled with `set_option linter.unnecessarySeqFocus false`
warning: ENOTV/Localization.lean:90:63: Used `tac1 <;> tac2` where `(tac1; tac2)` would suffice

Note: This linter can be disabled with `set_option linter.unnecessarySeqFocus false`
info: ENOTV/Localization.lean:106:74: Try this:
  [apply] ring_nf
  
  The `ring` tactic failed to close the goal. Use `ring_nf` to obtain a normal form.
    
  Note that `ring` works primarily in *commutative* rings. If you have a noncommutative ring, abelian group or module, consider using `noncomm_ring`, `abel` or `module` instead.
warning: ENOTV/Localization.lean:106:56: Used `tac1 <;> tac2` where `(tac1; tac2)` would suffice

Note: This linter can be disabled with `set_option linter.unnecessarySeqFocus false`
warning: ENOTV/Localization.lean:106:70: Used `tac1 <;> tac2` where `(tac1; tac2)` would suffice

Note: This linter can be disabled with `set_option linter.unnecessarySeqFocus false`
info: ENOTV/

$ /bin/bash -lc 'lake build ENOTV.Junction && lake env lean ENOTV/EvenEnergy.lean'
⚠ [8679/8685] Replayed ENOTV.Energy
warning: ENOTV/Energy.lean:158:24: Used `tac1 <;> tac2` where `(tac1; tac2)` would suffice

Note: This linter can be disabled with `set_option linter.unnecessarySeqFocus false`
⚠ [8680/8685] Replayed ENOTV.Euler
info: ENOTV/Euler.lean:31:2: Try this:
  [apply] ring_nf
  
  The `ring` tactic failed to close the goal. Use `ring_nf` to obtain a normal form.
    
  Note that `ring` works primarily in *commutative* rings. If you have a noncommutative ring, abelian group or module, consider using `noncomm_ring`, `abel` or `module` instead.
warning: ENOTV/Euler.lean:124:15: Used `tac1 <;> tac2` where `(tac1; tac2)` would suffice

Note: This linter can be disabled with `set_option linter.unnecessarySeqFocus false`
warning: ENOTV/Euler.lean:123:4: 'congr 2' tactic does nothing

Note: This linter can be disabled with `set_option linter.unusedTactic false`
warning: ENOTV/Euler.lean:163:6: Used `tac1 <;> tac2` where `(tac1; tac2)` would suffice

Note: This linter can be disabled with `set_option linter.unnecessarySeqFocus false`
⚠ [8681/8685] Replayed ENOTV.Counterexample
warning: ENOTV/Counterexample.lean:111:53: This simp argument is unused:
  h2

Hint: Omit it from the simp argument list.
  [apply] simp [pairDatumNat_apply, pairJumpNat_apply, h4, blockPrefix_succ]

Note: This linter can be disabled with `set_option linter.unusedSimpArgs false`
warning: ENOTV/Counterexample.lean:134:59: This simp argument is unused:
  h₄

Hint: Omit it from the simp argument list.
  [apply] simp [pairDatumNat_apply, pairJumpNat_apply, h₁, h42, h412, h414, hsub]

Note: This linter can be disabled with `set_option linter.unusedSimpArgs false`
warning: ENOTV/Counterexample.lean:356:4: `push_neg` has been deprecated. Prefer using `push Not` instead.
If you'd rather continue using `push_neg` in your project, you can implement it as follows:
```
open Lean.Parser.Tactic in
macro "push_neg" cfg:optConfig loc:(location)? : tactic =>
  `(tactic| push $cfg:optConfig N

$ /bin/bash -lc "nl -ba ENOTV/EvenEnergy.lean | sed -n '25,155p'"
25	  have hb := pairJumps_support d L hs'
    26	  simp only [Finset.mem_Ico] at hb
    27	  omega
    28	
    29	theorem translated_pairJumps_zero_after (d L p : ℕ) (i : ℤ)
    30	    (hi : (4 * L * (p + 1) : ℕ) ≤ i) :
    31	    translate (4 * L * p) (pairJumps d L) i = 0 := by
    32	  by_contra h
    33	  have hs : i ∈ (translate (4 * L * p) (pairJumps d L)).support :=
    34	    Finsupp.mem_support_iff.mpr h
    35	  have hs' : i - (4 * L * p : ℕ) ∈ (pairJumps d L).support := by
    36	    simpa [Finsupp.mem_support_iff] using hs
    37	  have hb := pairJumps_support d L hs'
    38	  simp only [Finset.mem_Ico] at hb
    39	  push_cast at hi hb
    40	  omega
    41	
    42	theorem multiJumps_eq_pair_on_interval {d L P p : ℕ} (hL : 0 < L)
    43	    (hp : p < P) (i : ℤ)
    44	    (hi0 : (4 * L * p : ℕ) ≤ i)
    45	    (hi1 : i < (4 * L * (p + 1) : ℕ)) :
    46	    multiJumps d L P i =
    47	      translate (4 * L * p) (pairJumps d L) i := by
    48	  simp only [multiJumps, Finsupp.finsetSum_apply]
    49	  apply Finset.sum_eq_single p
    50	  · intro q hq hqp
    51	    simp only [Finset.mem_range] at hq
    52	    by_cases hqp' : q < p
    53	    · apply translated_pairJumps_zero_after
    54	      have hnat : 4 * L * (q + 1) ≤ 4 * L * p := by
    55	        apply Nat.mul_le_mul_left
    56	        omega
    57	      exact_mod_cast hnat.trans (by exact_mod_cast hi0)
    58	    · have hpq : p < q := by omega
    59	      apply translated_pairJumps_zero_before
    60	      have hnat : 4 * L * (p + 1) ≤ 4 * L * q := by
    61	        apply Nat.mul_le_mul_left
    62	        omega
    63	      have hsep : i < (4 * L * q : ℕ) := by
    64	        exact hi1.trans_le (by exact_mod_cast hnat)
    65	      exact hsep
    66	  · exact (by simpa using hp)
    67	
    68	theorem pairJumps_first_block (d L t : ℕ) (ht : t < 2 * L) :
    69	    pairJumps d L t = realBlock d L t := by
    70	  simp [pairJumps, pairJumpNat_apply, ht]
    71	
    72	theorem pairJumps_second_b

$ /bin/bash -lc 'lake env lean ENOTV/EvenEnergy.lean'
ENOTV/EvenEnergy.lean:43:54: warning: Variable name `hL` is not explicitly referenced.

Hint: The binding can be removed (if unused) or named `_` (if used implicitly). Alternatively, prefix the name with `_` to silence this warning:
  [apply] _hL

Note: This linter can be disabled with `set_option linter.unusedVariables false`
ENOTV/EvenEnergy.lean:78:44: warning: Variable name `hL` is not explicitly referenced.

Hint: The binding can be removed (if unused) or named `_` (if used implicitly). Alternatively, prefix the name with `_` to silence this warning:
  [apply] _hL

Note: This linter can be disabled with `set_option linter.unusedVariables false`
ENOTV/EvenEnergy.lean:106:10: error: Tactic `rewrite` failed: Did not find an occurrence of the pattern
  ↑(2 * L * (p + p) + t) - ↑(4 * L * p)
in the target expression
  (pairJumps d L) (↑(2 * L * (p + p) + t) - 4 * ↑L * ↑p) = (-1) ^ (p + p) * realBlock d L t

case inl
d L P n t : ℕ
hL : 0 < L
hn : n < 2 * P
ht : t < 2 * L
p : ℕ
hp : n = p + p
hpP : p < P
harg : ↑(2 * L * (p + p) + t) - ↑(4 * L * p) = ↑t
⊢ (pairJumps d L) (↑(2 * L * (p + p) + t) - 4 * ↑L * ↑p) = (-1) ^ (p + p) * realBlock d L t
ENOTV/EvenEnergy.lean:111:6: error: Type mismatch
  ht0
has type
  0 ≤ ↑t
but is expected to have type
  ↑L * ↑p * 4 ≤ ↑L * ↑p * 4 + ↑t
Try this:
  [apply] ring_nf
  
  The `ring` tactic failed to close the goal. Use `ring_nf` to obtain a normal form.
    
  Note that `ring` works primarily in *commutative* rings. If you have a noncommutative ring, abelian group or module, consider using `noncomm_ring`, `abel` or `module` instead.
ENOTV/EvenEnergy.lean:123:37: error: unsolved goals
d L P n t : ℕ
hL : 0 < L
hn : n < 2 * P
ht : t < 2 * L
p : ℕ
hp : n = 2 * p + 1
hpP : p < P
⊢ ↑(L * 2 + L * p * 4 + t) - ↑(L * p * 4) = ↑L * 2 + ↑t
ENOTV/EvenEnergy.lean:124:27: error: Tactic `rewrite` failed: Did not find an occurrence of the pattern
  ↑(2 * L * (2 * p + 1) + t) - ↑(4 * L * p)
in the target expression
  (pairJumps d L) (↑(2 * L * (2 *

$ /bin/bash -lc "sed -n '96,132p' ENOTV/EvenEnergy.lean"
· obtain ⟨p, hp⟩ := hnEven
    rw [hp]
    have hpP : p < P := by omega
    rw [multiJumps_eq_pair_on_interval hL hpP]
    · rw [translate_apply]
      have harg :
          ((2 * L * (p + p) + t : ℕ) : ℤ) -
              ((4 * L * p : ℕ) : ℤ) = (t : ℤ) := by
        push_cast
        ring
      rw [harg]
      simpa [pow_add] using pairJumps_first_block d L t ht
    · have ht0 : (0 : ℤ) ≤ t := by positivity
      push_cast
      ring_nf
      exact ht0
    · have ht' : (t : ℤ) < 2 * L := by exact_mod_cast ht
      push_cast
      ring_nf
      nlinarith
  · obtain ⟨p, hp⟩ := hnOdd
    rw [hp]
    have hpP : p < P := by omega
    rw [multiJumps_eq_pair_on_interval hL hpP]
    · have harg :
          ((2 * L * (2 * p + 1) + t : ℕ) : ℤ) -
              ((4 * L * p : ℕ) : ℤ) =
            2 * (L : ℤ) + (t : ℤ) := by ring
      rw [translate_apply, harg]
      simpa [pow_add, pow_succ] using pairJumps_second_block d L t hL ht
    · have ht0 : (0 : ℤ) ≤ t := by positivity
      push_cast
      ring_nf
      nlinarith
    · have ht' : (t : ℤ) < 2 * L := by exact_mod_cast ht
      push_cast
      ring_nf

$ /bin/bash -lc "sed -n '116,126l' ENOTV/EvenEnergy.lean"
\302\267 obtain \342\237\250p, hp\342\237\251 := hnOdd$
    rw [hp]$
    have hpP : p < P := by omega$
    rw [multiJumps_eq_pair_on_interval hL hpP]$
    \302\267 have harg :$
          ((2 * L * (2 * p + 1) + t : \342\204\225) : \342\204\244) -$
              ((4 * L * p : \342\204\225) : \342\204\244) =$
            2 * (L : \342\204\244) + (t : \342\204\244) := by ring$
      rw [translate_apply, harg]$
      simpa [pow_add, pow_succ] using pairJumps_second_block d L t hL\
 ht$
    \302\267 have ht0 : (0 : \342\204\244) \342\211\244 t := by posit\
ivity$

$ /bin/bash -lc 'lake env lean ENOTV/EvenEnergy.lean'
ENOTV/EvenEnergy.lean:43:54: warning: Variable name `hL` is not explicitly referenced.

Hint: The binding can be removed (if unused) or named `_` (if used implicitly). Alternatively, prefix the name with `_` to silence this warning:
  [apply] _hL

Note: This linter can be disabled with `set_option linter.unusedVariables false`
ENOTV/EvenEnergy.lean:78:44: warning: Variable name `hL` is not explicitly referenced.

Hint: The binding can be removed (if unused) or named `_` (if used implicitly). Alternatively, prefix the name with `_` to silence this warning:
  [apply] _hL

Note: This linter can be disabled with `set_option linter.unusedVariables false`
ENOTV/EvenEnergy.lean:107:6: error: Type mismatch: After simplification, term
  pairJumps_first_block d L t ht
 has type
  (pairJumps d L) ↑t = realBlock d L t
but is expected to have type
  (pairJumps d L) ↑t = (-1) ^ p * (-1) ^ p * realBlock d L t

$ /bin/bash -lc 'lake env lean ENOTV/EvenEnergy.lean'
ENOTV/EvenEnergy.lean:43:54: warning: Variable name `hL` is not explicitly referenced.

Hint: The binding can be removed (if unused) or named `_` (if used implicitly). Alternatively, prefix the name with `_` to silence this warning:
  [apply] _hL

Note: This linter can be disabled with `set_option linter.unusedVariables false`
ENOTV/EvenEnergy.lean:78:44: warning: Variable name `hL` is not explicitly referenced.

Hint: The binding can be removed (if unused) or named `_` (if used implicitly). Alternatively, prefix the name with `_` to silence this warning:
  [apply] _hL

Note: This linter can be disabled with `set_option linter.unusedVariables false`

$ /bin/bash -lc 'lake env lean ENOTV/EvenEnergy.lean'
ENOTV/EvenEnergy.lean:43:54: warning: Variable name `hL` is not explicitly referenced.

Hint: The binding can be removed (if unused) or named `_` (if used implicitly). Alternatively, prefix the name with `_` to silence this warning:
  [apply] _hL

Note: This linter can be disabled with `set_option linter.unusedVariables false`
ENOTV/EvenEnergy.lean:78:44: warning: Variable name `hL` is not explicitly referenced.

Hint: The binding can be removed (if unused) or named `_` (if used implicitly). Alternatively, prefix the name with `_` to silence this warning:
  [apply] _hL

Note: This linter can be disabled with `set_option linter.unusedVariables false`
ENOTV/EvenEnergy.lean:191:6: error: omega could not prove the goal:
a possible counterexample may satisfy the constraints
  e ≥ 0
  c ≥ 0
  2*c - e ≥ 2
  b ≥ 1
  b ≥ 1
  2*b + f - g ≥ 1
  a ≥ 1
where
 a := ↑d
 b := ↑L
 c := ↑P
 e := ↑(n - 1)
 f := 2 * ↑L * ↑(n - 1)
 g := 2 * ↑L * ↑n
ENOTV/EvenEnergy.lean:198:6: error: mod_cast has type
  ↑t = ↑(2 * L) + h
but is expected to have type
  blockPoly d L ↑t = blockPoly d L ↑(↑(2 * L) + h)
ENOTV/EvenEnergy.lean:227:8: error: mod_cast has type
  ↑t = h
but is expected to have type
  blockPoly d L ↑t = blockPoly d L ↑h

$ /bin/bash -lc 'lake env lean ENOTV/EvenEnergy.lean'
ENOTV/EvenEnergy.lean:43:54: warning: Variable name `hL` is not explicitly referenced.

Hint: The binding can be removed (if unused) or named `_` (if used implicitly). Alternatively, prefix the name with `_` to silence this warning:
  [apply] _hL

Note: This linter can be disabled with `set_option linter.unusedVariables false`
ENOTV/EvenEnergy.lean:78:44: warning: Variable name `hL` is not explicitly referenced.

Hint: The binding can be removed (if unused) or named `_` (if used implicitly). Alternatively, prefix the name with `_` to silence this warning:
  [apply] _hL

Note: This linter can be disabled with `set_option linter.unusedVariables false`

$ /bin/bash -lc 'lake env lean ENOTV/EvenEnergy.lean'
ENOTV/EvenEnergy.lean:43:54: warning: Variable name `hL` is not explicitly referenced.

Hint: The binding can be removed (if unused) or named `_` (if used implicitly). Alternatively, prefix the name with `_` to silence this warning:
  [apply] _hL

Note: This linter can be disabled with `set_option linter.unusedVariables false`
ENOTV/EvenEnergy.lean:78:44: warning: Variable name `hL` is not explicitly referenced.

Hint: The binding can be removed (if unused) or named `_` (if used implicitly). Alternatively, prefix the name with `_` to silence this warning:
  [apply] _hL

Note: This linter can be disabled with `set_option linter.unusedVariables false`
ENOTV/EvenEnergy.lean:178:6: error: Tactic `rewrite` failed: Did not find an occurrence of the pattern
  f (j + ↑q)
in the target expression
  ((-1) ^ (n - q) * ↑(n.choose q)) • f (j + q • 1) = ((-1) ^ (n - q) * ↑(n.choose q)) • g (j + q • 1)

n : ℕ
f g : Seq
j : ℤ
h : ∀ q ≤ n, f (j + ↑q) = g (j + ↑q)
q : ℕ
hq : q < n + 1
⊢ ((-1) ^ (n - q) * ↑(n.choose q)) • f (j + q • 1) = ((-1) ^ (n - q) * ↑(n.choose q)) • g (j + q • 1)
Try this:
  [apply] ring_nf
  
  The `ring` tactic failed to close the goal. Use `ring_nf` to obtain a normal form.
    
  Note that `ring` works primarily in *commutative* rings. If you have a noncommutative ring, abelian group or module, consider using `noncomm_ring`, `abel` or `module` instead.
ENOTV/EvenEnergy.lean:190:2: error: unsolved goals
case e_a
n : ℕ
c : ℝ
g : Seq
B s : ℤ
q : ℕ
hq : q ∈ Finset.range (n + 1)
⊢ ↑(↑(n.choose q) * (-1) ^ (n - q)) = c
Try this:
  [apply] ring_nf
  
  The `ring` tactic failed to close the goal. Use `ring_nf` to obtain a normal form.
    
  Note that `ring` works primarily in *commutative* rings. If you have a noncommutative ring, abelian group or module, consider using `noncomm_ring`, `abel` or `module` instead.
ENOTV/EvenEnergy.lean:191:2: error: unsolved goals
case e_a.e_a
n : ℕ
c : ℝ
g : Seq
B s : ℤ
q : ℕ
hq : q ∈ Finset.range (n + 1)
⊢ c = ↑(n.choose q) * (-1)

$ /bin/bash -lc 'lake env lean ENOTV/EvenEnergy.lean'
ENOTV/EvenEnergy.lean:43:54: warning: Variable name `hL` is not explicitly referenced.

Hint: The binding can be removed (if unused) or named `_` (if used implicitly). Alternatively, prefix the name with `_` to silence this warning:
  [apply] _hL

Note: This linter can be disabled with `set_option linter.unusedVariables false`
ENOTV/EvenEnergy.lean:78:44: warning: Variable name `hL` is not explicitly referenced.

Hint: The binding can be removed (if unused) or named `_` (if used implicitly). Alternatively, prefix the name with `_` to silence this warning:
  [apply] _hL

Note: This linter can be disabled with `set_option linter.unusedVariables false`
Try this:
  [apply] ring_nf
  
  The `ring` tactic failed to close the goal. Use `ring_nf` to obtain a normal form.
    
  Note that `ring` works primarily in *commutative* rings. If you have a noncommutative ring, abelian group or module, consider using `noncomm_ring`, `abel` or `module` instead.
ENOTV/EvenEnergy.lean:198:2: error: Tactic `apply` failed: could not unify the conclusion of `Finset.sum_congr rfl`
  Finset.sum ?m.52 ?m.49 = Finset.sum ?m.52 ?m.50
with the goal
  ∑ k ∈ Finset.range (d + 1 + 1), ((-1) ^ (d + 1 - k) * ↑((d + 1).choose k)) • ↑(junctionProfile d L ↑(s + k • 1)) =
    ↑(∑ k ∈ Finset.range (d + 1 + 1), ((-1) ^ (d + 1 - k) * ↑((d + 1).choose k)) • junctionProfile d L (↑s + k • 1))

Note: The full type of `Finset.sum_congr rfl` is
  (∀ x ∈ ?m.52, ?m.49 x = ?m.50 x) → Finset.sum ?m.52 ?m.49 = Finset.sum ?m.52 ?m.50

d L : ℕ
s : ℤ
⊢ ∑ k ∈ Finset.range (d + 1 + 1), ((-1) ^ (d + 1 - k) * ↑((d + 1).choose k)) • ↑(junctionProfile d L ↑(s + k • 1)) =
    ↑(∑ k ∈ Finset.range (d + 1 + 1), ((-1) ^ (d + 1 - k) * ↑((d + 1).choose k)) • junctionProfile d L (↑s + k • 1))
ENOTV/EvenEnergy.lean:288:6: warning: 'push_cast' tactic does nothing

Note: This linter can be disabled with `set_option linter.unusedTactic false`
ENOTV/EvenEnergy.lean:292:6: warning: 'push_cast' tactic does nothing

Note: This linter can be 

$ /bin/bash -lc 'lake env lean ENOTV/EvenEnergy.lean'
ENOTV/EvenEnergy.lean:43:54: warning: Variable name `hL` is not explicitly referenced.

Hint: The binding can be removed (if unused) or named `_` (if used implicitly). Alternatively, prefix the name with `_` to silence this warning:
  [apply] _hL

Note: This linter can be disabled with `set_option linter.unusedVariables false`
ENOTV/EvenEnergy.lean:78:44: warning: Variable name `hL` is not explicitly referenced.

Hint: The binding can be removed (if unused) or named `_` (if used implicitly). Alternatively, prefix the name with `_` to silence this warning:
  [apply] _hL

Note: This linter can be disabled with `set_option linter.unusedVariables false`
Try this:
  [apply] ring_nf
  
  The `ring` tactic failed to close the goal. Use `ring_nf` to obtain a normal form.
    
  Note that `ring` works primarily in *commutative* rings. If you have a noncommutative ring, abelian group or module, consider using `noncomm_ring`, `abel` or `module` instead.
ENOTV/EvenEnergy.lean:289:6: warning: 'push_cast' tactic does nothing

Note: This linter can be disabled with `set_option linter.unusedTactic false`
ENOTV/EvenEnergy.lean:293:6: warning: 'push_cast' tactic does nothing

Note: This linter can be disabled with `set_option linter.unusedTactic false`

$ /bin/bash -lc 'lake env lean ENOTV/EvenEnergy.lean'
ENOTV/EvenEnergy.lean:43:54: warning: Variable name `hL` is not explicitly referenced.

Hint: The binding can be removed (if unused) or named `_` (if used implicitly). Alternatively, prefix the name with `_` to silence this warning:
  [apply] _hL

Note: This linter can be disabled with `set_option linter.unusedVariables false`
ENOTV/EvenEnergy.lean:78:44: warning: Variable name `hL` is not explicitly referenced.

Hint: The binding can be removed (if unused) or named `_` (if used implicitly). Alternatively, prefix the name with `_` to silence this warning:
  [apply] _hL

Note: This linter can be disabled with `set_option linter.unusedVariables false`
Try this:
  [apply] ring_nf
  
  The `ring` tactic failed to close the goal. Use `ring_nf` to obtain a normal form.
    
  Note that `ring` works primarily in *commutative* rings. If you have a noncommutative ring, abelian group or module, consider using `noncomm_ring`, `abel` or `module` instead.
ENOTV/EvenEnergy.lean:289:6: warning: 'push_cast' tactic does nothing

Note: This linter can be disabled with `set_option linter.unusedTactic false`
ENOTV/EvenEnergy.lean:293:6: warning: 'push_cast' tactic does nothing

Note: This linter can be disabled with `set_option linter.unusedTactic false`
ENOTV/EvenEnergy.lean:334:10: error: Tactic `rewrite` failed: Did not find an occurrence of the pattern
  ↑r
in the target expression
  2 * ↑L + h = ↑(2 * L - r)

d L : ℕ
hd : 0 < d
heven : Even d
hL : d + 1 ≤ L
h : ℤ
hh0 : -↑d ≤ h
hh1 : h ≤ ↑d
hLpos : 0 < L
hh : h ≤ 0
r : ℕ := (-h).toNat
hr0 : 0 ≤ -h
hrcast : ↑r = -h
hrR : r ≤ d + 1
hrinside : r ≤ 2 * L
hb : |blockPoly d L (2 * ↑L - ↑r)| ≤ endpointUpper d (d + 1) * ↑L ^ (d - 1)
⊢ 2 * ↑L + h = ↑(2 * L - r)
ENOTV/EvenEnergy.lean:341:23: error: Type mismatch: After simplification, term
  hb'
 has type
  |blockPoly d L (2 * ↑L - ↑r)| ≤ endpointUpper d (d + 1) * ↑L ^ (d - 1)
but is expected to have type
  |blockPoly d L ↑(2 * L - r)| ≤ endpointUpper d (d + 1) * ↑L ^ (d - 1)
ENOTV/EvenEnerg

$ /bin/bash -lc 'lake env lean ENOTV/EvenEnergy.lean'
ENOTV/EvenEnergy.lean:43:54: warning: Variable name `hL` is not explicitly referenced.

Hint: The binding can be removed (if unused) or named `_` (if used implicitly). Alternatively, prefix the name with `_` to silence this warning:
  [apply] _hL

Note: This linter can be disabled with `set_option linter.unusedVariables false`
ENOTV/EvenEnergy.lean:78:44: warning: Variable name `hL` is not explicitly referenced.

Hint: The binding can be removed (if unused) or named `_` (if used implicitly). Alternatively, prefix the name with `_` to silence this warning:
  [apply] _hL

Note: This linter can be disabled with `set_option linter.unusedVariables false`
Try this:
  [apply] ring_nf
  
  The `ring` tactic failed to close the goal. Use `ring_nf` to obtain a normal form.
    
  Note that `ring` works primarily in *commutative* rings. If you have a noncommutative ring, abelian group or module, consider using `noncomm_ring`, `abel` or `module` instead.
ENOTV/EvenEnergy.lean:289:6: warning: 'push_cast' tactic does nothing

Note: This linter can be disabled with `set_option linter.unusedTactic false`
ENOTV/EvenEnergy.lean:293:6: warning: 'push_cast' tactic does nothing

Note: This linter can be disabled with `set_option linter.unusedTactic false`
ENOTV/EvenEnergy.lean:333:6: error: mod_cast has type
  ↑r = -h
but is expected to have type
  ↑(2 * L) + h = ↑(2 * L - r)
ENOTV/EvenEnergy.lean:334:6: error: No goals to be solved
ENOTV/EvenEnergy.lean:337:8: error: Tactic `rewrite` failed: Did not find an occurrence of the pattern
  2 * ↑↑L + ↑h
in the target expression
  |↑(blockPoly d L (2 * ↑L + ↑h))| ≤ ↑(endpointUpper d (d + 1)) * ↑L ^ (d - 1)

case pos
d L : ℕ
hd : 0 < d
heven : Even d
hL : d + 1 ≤ L
h : ℤ
hh0 : -↑d ≤ h
hh1 : h ≤ ↑d
hLpos : 0 < L
hh : h ≤ 0
r : ℕ := (-h).toNat
hr0 : 0 ≤ -h
hrcast : ↑r = -h
hrR : r ≤ d + 1
hrinside : r ≤ 2 * L
hb : |blockPoly d L (2 * ↑L - ↑r)| ≤ endpointUpper d (d + 1) * ↑L ^ (d - 1)
harg : 2 * ↑↑L + ↑h = 2 * ↑L - ↑r
⊢ |↑(blockPoly d L (2 * ↑L +

$ /bin/bash -lc 'lake env lean ENOTV/EvenEnergy.lean'
ENOTV/EvenEnergy.lean:43:54: warning: Variable name `hL` is not explicitly referenced.

Hint: The binding can be removed (if unused) or named `_` (if used implicitly). Alternatively, prefix the name with `_` to silence this warning:
  [apply] _hL

Note: This linter can be disabled with `set_option linter.unusedVariables false`
ENOTV/EvenEnergy.lean:78:44: warning: Variable name `hL` is not explicitly referenced.

Hint: The binding can be removed (if unused) or named `_` (if used implicitly). Alternatively, prefix the name with `_` to silence this warning:
  [apply] _hL

Note: This linter can be disabled with `set_option linter.unusedVariables false`
Try this:
  [apply] ring_nf
  
  The `ring` tactic failed to close the goal. Use `ring_nf` to obtain a normal form.
    
  Note that `ring` works primarily in *commutative* rings. If you have a noncommutative ring, abelian group or module, consider using `noncomm_ring`, `abel` or `module` instead.
ENOTV/EvenEnergy.lean:289:6: warning: 'push_cast' tactic does nothing

Note: This linter can be disabled with `set_option linter.unusedTactic false`
ENOTV/EvenEnergy.lean:293:6: warning: 'push_cast' tactic does nothing

Note: This linter can be disabled with `set_option linter.unusedTactic false`
ENOTV/EvenEnergy.lean:373:4: warning: 'push_cast' tactic does nothing

Note: This linter can be disabled with `set_option linter.unusedTactic false`
ENOTV/EvenEnergy.lean:376:4: warning: 'push_cast' tactic does nothing

Note: This linter can be disabled with `set_option linter.unusedTactic false`
ENOTV/EvenEnergy.lean:384:4: warning: 'push_cast' tactic does nothing

Note: This linter can be disabled with `set_option linter.unusedTactic false`
ENOTV/EvenEnergy.lean:386:4: warning: 'push_cast' tactic does nothing

Note: This linter can be disabled with `set_option linter.unusedTactic false`

$ /bin/bash -lc 'lake env lean ENOTV/EvenEnergy.lean'
ENOTV/EvenEnergy.lean:43:54: warning: Variable name `hL` is not explicitly referenced.

Hint: The binding can be removed (if unused) or named `_` (if used implicitly). Alternatively, prefix the name with `_` to silence this warning:
  [apply] _hL

Note: This linter can be disabled with `set_option linter.unusedVariables false`
ENOTV/EvenEnergy.lean:78:44: warning: Variable name `hL` is not explicitly referenced.

Hint: The binding can be removed (if unused) or named `_` (if used implicitly). Alternatively, prefix the name with `_` to silence this warning:
  [apply] _hL

Note: This linter can be disabled with `set_option linter.unusedVariables false`
Try this:
  [apply] ring_nf
  
  The `ring` tactic failed to close the goal. Use `ring_nf` to obtain a normal form.
    
  Note that `ring` works primarily in *commutative* rings. If you have a noncommutative ring, abelian group or module, consider using `noncomm_ring`, `abel` or `module` instead.
ENOTV/EvenEnergy.lean:289:6: warning: 'push_cast' tactic does nothing

Note: This linter can be disabled with `set_option linter.unusedTactic false`
ENOTV/EvenEnergy.lean:293:6: warning: 'push_cast' tactic does nothing

Note: This linter can be disabled with `set_option linter.unusedTactic false`
ENOTV/EvenEnergy.lean:373:4: warning: 'push_cast' tactic does nothing

Note: This linter can be disabled with `set_option linter.unusedTactic false`
ENOTV/EvenEnergy.lean:376:4: warning: 'push_cast' tactic does nothing

Note: This linter can be disabled with `set_option linter.unusedTactic false`
ENOTV/EvenEnergy.lean:384:4: warning: 'push_cast' tactic does nothing

Note: This linter can be disabled with `set_option linter.unusedTactic false`
ENOTV/EvenEnergy.lean:386:4: warning: 'push_cast' tactic does nothing

Note: This linter can be disabled with `set_option linter.unusedTactic false`
ENOTV/EvenEnergy.lean:408:18: error: Tactic `rewrite` failed: Did not find an occurrence of the pattern
  (multiJumps d L P) ↑(2 * L * 0 + t)
in the 

$ /bin/bash -lc 'lake env lean ENOTV/EvenEnergy.lean'
ENOTV/EvenEnergy.lean:43:54: warning: Variable name `hL` is not explicitly referenced.

Hint: The binding can be removed (if unused) or named `_` (if used implicitly). Alternatively, prefix the name with `_` to silence this warning:
  [apply] _hL

Note: This linter can be disabled with `set_option linter.unusedVariables false`
ENOTV/EvenEnergy.lean:78:44: warning: Variable name `hL` is not explicitly referenced.

Hint: The binding can be removed (if unused) or named `_` (if used implicitly). Alternatively, prefix the name with `_` to silence this warning:
  [apply] _hL

Note: This linter can be disabled with `set_option linter.unusedVariables false`
Try this:
  [apply] ring_nf
  
  The `ring` tactic failed to close the goal. Use `ring_nf` to obtain a normal form.
    
  Note that `ring` works primarily in *commutative* rings. If you have a noncommutative ring, abelian group or module, consider using `noncomm_ring`, `abel` or `module` instead.
ENOTV/EvenEnergy.lean:289:6: warning: 'push_cast' tactic does nothing

Note: This linter can be disabled with `set_option linter.unusedTactic false`
ENOTV/EvenEnergy.lean:293:6: warning: 'push_cast' tactic does nothing

Note: This linter can be disabled with `set_option linter.unusedTactic false`
ENOTV/EvenEnergy.lean:373:4: warning: 'push_cast' tactic does nothing

Note: This linter can be disabled with `set_option linter.unusedTactic false`
ENOTV/EvenEnergy.lean:376:4: warning: 'push_cast' tactic does nothing

Note: This linter can be disabled with `set_option linter.unusedTactic false`
ENOTV/EvenEnergy.lean:384:4: warning: 'push_cast' tactic does nothing

Note: This linter can be disabled with `set_option linter.unusedTactic false`
ENOTV/EvenEnergy.lean:386:4: warning: 'push_cast' tactic does nothing

Note: This linter can be disabled with `set_option linter.unusedTactic false`
ENOTV/EvenEnergy.lean:391:26: warning: Variable name `hh0` is not explicitly referenced.

Hint: The binding can be removed (if unused) or named `_` (

$ /bin/bash -lc 'lake env lean ENOTV/EvenEnergy.lean'
ENOTV/EvenEnergy.lean:43:54: warning: Variable name `hL` is not explicitly referenced.

Hint: The binding can be removed (if unused) or named `_` (if used implicitly). Alternatively, prefix the name with `_` to silence this warning:
  [apply] _hL

Note: This linter can be disabled with `set_option linter.unusedVariables false`
ENOTV/EvenEnergy.lean:78:44: warning: Variable name `hL` is not explicitly referenced.

Hint: The binding can be removed (if unused) or named `_` (if used implicitly). Alternatively, prefix the name with `_` to silence this warning:
  [apply] _hL

Note: This linter can be disabled with `set_option linter.unusedVariables false`
Try this:
  [apply] ring_nf
  
  The `ring` tactic failed to close the goal. Use `ring_nf` to obtain a normal form.
    
  Note that `ring` works primarily in *commutative* rings. If you have a noncommutative ring, abelian group or module, consider using `noncomm_ring`, `abel` or `module` instead.
ENOTV/EvenEnergy.lean:289:6: warning: 'push_cast' tactic does nothing

Note: This linter can be disabled with `set_option linter.unusedTactic false`
ENOTV/EvenEnergy.lean:293:6: warning: 'push_cast' tactic does nothing

Note: This linter can be disabled with `set_option linter.unusedTactic false`
ENOTV/EvenEnergy.lean:373:4: warning: 'push_cast' tactic does nothing

Note: This linter can be disabled with `set_option linter.unusedTactic false`
ENOTV/EvenEnergy.lean:376:4: warning: 'push_cast' tactic does nothing

Note: This linter can be disabled with `set_option linter.unusedTactic false`
ENOTV/EvenEnergy.lean:384:4: warning: 'push_cast' tactic does nothing

Note: This linter can be disabled with `set_option linter.unusedTactic false`
ENOTV/EvenEnergy.lean:386:4: warning: 'push_cast' tactic does nothing

Note: This linter can be disabled with `set_option linter.unusedTactic false`
ENOTV/EvenEnergy.lean:391:26: warning: Variable name `hh0` is not explicitly referenced.

Hint: The binding can be removed (if unused) or named `_` (

$ /bin/bash -lc "rg -n -- \"-\\(d : ℤ\\) ≤|hs0\" ENOTV/EvenEnergy.lean | tail -40"
273:    (hs0 : -(d : ℤ) ≤ s) (hs1 : s ≤ -1) :
317:    (h : ℤ) (hh0 : -(d : ℤ) ≤ h) (hh1 : h ≤ d) :
364:    (hs0 : -(d : ℤ) ≤ s) (hs1 : s ≤ -1) :
391:    (hP : 0 < P) (h : ℤ) (hh0 : -(d : ℤ) ≤ h) (hh1 : h ≤ d) :
418:    (hP : 0 < P) (h : ℤ) (hh0 : -(d : ℤ) ≤ h) (hh1 : h ≤ d) :
463:    (hP : 0 < P) (s : ℤ) (hs0 : -(d : ℤ) ≤ s) (hs1 : s ≤ -1) :
479:    (hP : 0 < P) (s : ℤ) (hs0 : -(d : ℤ) ≤ s) (hs1 : s ≤ -1) :
497:    (hP : 0 < P) (s : ℤ) (hs0 : -(d : ℤ) ≤ s) (hs1 : s ≤ -1) :
511:    (hP : 0 < P) (s : ℤ) (hs0 : -(d : ℤ) ≤ s) (hs1 : s ≤ -1) :

$ /bin/bash -lc 'lake env lean ENOTV/EvenEnergy.lean'
ENOTV/EvenEnergy.lean:43:54: warning: Variable name `hL` is not explicitly referenced.

Hint: The binding can be removed (if unused) or named `_` (if used implicitly). Alternatively, prefix the name with `_` to silence this warning:
  [apply] _hL

Note: This linter can be disabled with `set_option linter.unusedVariables false`
ENOTV/EvenEnergy.lean:78:44: warning: Variable name `hL` is not explicitly referenced.

Hint: The binding can be removed (if unused) or named `_` (if used implicitly). Alternatively, prefix the name with `_` to silence this warning:
  [apply] _hL

Note: This linter can be disabled with `set_option linter.unusedVariables false`
Try this:
  [apply] ring_nf
  
  The `ring` tactic failed to close the goal. Use `ring_nf` to obtain a normal form.
    
  Note that `ring` works primarily in *commutative* rings. If you have a noncommutative ring, abelian group or module, consider using `noncomm_ring`, `abel` or `module` instead.
ENOTV/EvenEnergy.lean:289:6: warning: 'push_cast' tactic does nothing

Note: This linter can be disabled with `set_option linter.unusedTactic false`
ENOTV/EvenEnergy.lean:293:6: warning: 'push_cast' tactic does nothing

Note: This linter can be disabled with `set_option linter.unusedTactic false`
ENOTV/EvenEnergy.lean:373:4: warning: 'push_cast' tactic does nothing

Note: This linter can be disabled with `set_option linter.unusedTactic false`
ENOTV/EvenEnergy.lean:376:4: warning: 'push_cast' tactic does nothing

Note: This linter can be disabled with `set_option linter.unusedTactic false`
ENOTV/EvenEnergy.lean:386:4: warning: 'push_cast' tactic does nothing

Note: This linter can be disabled with `set_option linter.unusedTactic false`
ENOTV/EvenEnergy.lean:391:26: warning: Variable name `hh0` is not explicitly referenced.

Hint: The binding can be removed (if unused) or named `_` (if used implicitly). Alternatively, prefix the name with `_` to silence this warning:
  [apply] _hh0

Note: This linter can be disabled with `set_opt

$ /bin/bash -lc "cat >/tmp/Check.lean <<'EOF'
import Mathlib
#check Nat.div_lt_iff_lt_mul
#check Nat.div_lt_of_lt_mul
#check Nat.mod_lt
#check Nat.div_add_mod
#check Nat.mod_add_div
#check Finset.mem_biUnion
#check Finsupp.sum_subset
EOF
lake env lean /tmp/Check.lean"
Nat.div_lt_iff_lt_mul {k x y : ℕ} (Hk : 0 < k) : x / k < y ↔ x < y * k
Nat.div_lt_of_lt_mul {m n k : ℕ} (h : m < n * k) : m / n < k
Nat.mod_lt (x : ℕ) {y : ℕ} (hy : 0 < y) : x % y < y
Nat.div_add_mod (m n : ℕ) : n * (m / n) + m % n = m
Nat.mod_add_div (m k : ℕ) : m % k + k * (m / k) = m
Finset.mem_biUnion.{u_1, u_2} {α : Type u_1} {β : Type u_2} {s : Finset α} {t : α → Finset β} [DecidableEq β] {b : β} :
  b ∈ s.biUnion t ↔ ∃ a ∈ s, b ∈ t a
/tmp/Check.lean:8:7: error(lean.unknownIdentifier): Unknown constant `Finsupp.sum_subset`

$ /bin/bash -lc "cat >/tmp/Check.lean <<'EOF'
import Mathlib
#check Finset.sum_le_sum_of_subset_of_nonneg
#check Finset.sum_subset
#check Finset.sum_biUnion
#check Finset.card_biUnion_le
#check Finset.sum_biUnion_le_sum_sum
EOF
lake env lean /tmp/Check.lean"
Finset.sum_le_sum_of_subset_of_nonneg.{u_1, u_5} {ι : Type u_1} {N : Type u_5} [AddCommMonoid N] [Preorder N]
  {f : ι → N} {s t : Finset ι} [AddLeftMono N] (h : s ⊆ t) (hf : ∀ i ∈ t, i ∉ s → 0 ≤ f i) : ∑ i ∈ s, f i ≤ ∑ i ∈ t, f i
Finset.sum_subset.{u_1, u_4} {ι : Type u_1} {M : Type u_4} {s₁ s₂ : Finset ι} [AddCommMonoid M] {f : ι → M}
  (h : s₁ ⊆ s₂) (hf : ∀ x ∈ s₂, x ∉ s₁ → f x = 0) : ∑ x ∈ s₁, f x = ∑ x ∈ s₂, f x
Finset.sum_biUnion.{u_1, u_2, u_4} {ι : Type u_1} {κ : Type u_2} {M : Type u_4} [AddCommMonoid M] {f : ι → M}
  [DecidableEq ι] {s : Finset κ} {t : κ → Finset ι} (hs : (↑s).PairwiseDisjoint t) :
  ∑ x ∈ s.biUnion t, f x = ∑ x ∈ s, ∑ i ∈ t x, f i
Finset.card_biUnion_le.{u_1, u_4} {ι : Type u_1} {M : Type u_4} [DecidableEq M] {s : Finset ι} {t : ι → Finset M} :
  (s.biUnion t).card ≤ ∑ a ∈ s, (t a).card
/tmp/Check.lean:6:7: error(lean.unknownIdentifier): Unknown constant `Finset.sum_biUnion_le_sum_sum`

$ /bin/bash -lc 'rg -n "biUnion.*sum|sum.*biUnion" Mathlib/Algebra/Order Mathlib/Data/Finset | head -60'
Mathlib/Algebra/Order/BigOperators/Group/Finset.lean:255:  card_biUnion_le.trans <| sum_le_card_nsmul _ _ _ h
Mathlib/Algebra/Order/BigOperators/Group/Finset.lean:415:  rw [card_biUnion hs, card_eq_sum_ones]
Mathlib/Algebra/Order/BigOperators/Group/Finset.lean:616:  Finset.sup_set_eq_biUnion t s ▸ t.apply_sup_le_sum zero (by simpa)

$ /bin/bash -lc 'lake env lean ENOTV/EvenEnergy.lean'
ENOTV/EvenEnergy.lean:43:54: warning: Variable name `hL` is not explicitly referenced.

Hint: The binding can be removed (if unused) or named `_` (if used implicitly). Alternatively, prefix the name with `_` to silence this warning:
  [apply] _hL

Note: This linter can be disabled with `set_option linter.unusedVariables false`
ENOTV/EvenEnergy.lean:78:44: warning: Variable name `hL` is not explicitly referenced.

Hint: The binding can be removed (if unused) or named `_` (if used implicitly). Alternatively, prefix the name with `_` to silence this warning:
  [apply] _hL

Note: This linter can be disabled with `set_option linter.unusedVariables false`
Try this:
  [apply] ring_nf
  
  The `ring` tactic failed to close the goal. Use `ring_nf` to obtain a normal form.
    
  Note that `ring` works primarily in *commutative* rings. If you have a noncommutative ring, abelian group or module, consider using `noncomm_ring`, `abel` or `module` instead.
ENOTV/EvenEnergy.lean:289:6: warning: 'push_cast' tactic does nothing

Note: This linter can be disabled with `set_option linter.unusedTactic false`
ENOTV/EvenEnergy.lean:293:6: warning: 'push_cast' tactic does nothing

Note: This linter can be disabled with `set_option linter.unusedTactic false`
ENOTV/EvenEnergy.lean:373:4: warning: 'push_cast' tactic does nothing

Note: This linter can be disabled with `set_option linter.unusedTactic false`
ENOTV/EvenEnergy.lean:376:4: warning: 'push_cast' tactic does nothing

Note: This linter can be disabled with `set_option linter.unusedTactic false`
ENOTV/EvenEnergy.lean:386:4: warning: 'push_cast' tactic does nothing

Note: This linter can be disabled with `set_option linter.unusedTactic false`
ENOTV/EvenEnergy.lean:391:26: warning: Variable name `hh0` is not explicitly referenced.

Hint: The binding can be removed (if unused) or named `_` (if used implicitly). Alternatively, prefix the name with `_` to silence this warning:
  [apply] _hh0

Note: This linter can be disabled with `set_opt

$ /bin/bash -lc 'lake env lean ENOTV/EvenEnergy.lean'
ENOTV/EvenEnergy.lean:43:54: warning: Variable name `hL` is not explicitly referenced.

Hint: The binding can be removed (if unused) or named `_` (if used implicitly). Alternatively, prefix the name with `_` to silence this warning:
  [apply] _hL

Note: This linter can be disabled with `set_option linter.unusedVariables false`
ENOTV/EvenEnergy.lean:78:44: warning: Variable name `hL` is not explicitly referenced.

Hint: The binding can be removed (if unused) or named `_` (if used implicitly). Alternatively, prefix the name with `_` to silence this warning:
  [apply] _hL

Note: This linter can be disabled with `set_option linter.unusedVariables false`
Try this:
  [apply] ring_nf
  
  The `ring` tactic failed to close the goal. Use `ring_nf` to obtain a normal form.
    
  Note that `ring` works primarily in *commutative* rings. If you have a noncommutative ring, abelian group or module, consider using `noncomm_ring`, `abel` or `module` instead.
ENOTV/EvenEnergy.lean:289:6: warning: 'push_cast' tactic does nothing

Note: This linter can be disabled with `set_option linter.unusedTactic false`
ENOTV/EvenEnergy.lean:293:6: warning: 'push_cast' tactic does nothing

Note: This linter can be disabled with `set_option linter.unusedTactic false`
ENOTV/EvenEnergy.lean:373:4: warning: 'push_cast' tactic does nothing

Note: This linter can be disabled with `set_option linter.unusedTactic false`
ENOTV/EvenEnergy.lean:376:4: warning: 'push_cast' tactic does nothing

Note: This linter can be disabled with `set_option linter.unusedTactic false`
ENOTV/EvenEnergy.lean:386:4: warning: 'push_cast' tactic does nothing

Note: This linter can be disabled with `set_option linter.unusedTactic false`
ENOTV/EvenEnergy.lean:391:26: warning: Variable name `hh0` is not explicitly referenced.

Hint: The binding can be removed (if unused) or named `_` (if used implicitly). Alternatively, prefix the name with `_` to silence this warning:
  [apply] _hh0

Note: This linter can be disabled with `set_opt

$ /bin/bash -lc "nl -ba ENOTV/EvenEnergy.lean | sed -n '640,680p'"
640	      have hden : 0 < 2 * L := by omega
   641	      have ht : t < 2 * L := Nat.mod_lt _ hden
   642	      have hdecomp : 2 * L * n + t = r := by
   643	        simpa [n, t, mul_comm] using (Nat.div_add_mod r (2 * L))
   644	      have hn : n < 2 * P := by
   645	        rw [Nat.div_lt_iff_lt_mul hden]
   646	        have : r < 4 * L * P := by
   647	          rw [← hrcast] at hjlt
   648	          exact_mod_cast hjlt
   649	        nlinarith
   650	      by_cases hinterior : t + (d + 1) < 2 * L
   651	      · have hz := multiJumps_interior_difference_zero
   652	          (d := d) (L := L) (P := P) hden hn hinterior
   653	        have hindex : (2 * L * n + t : ℕ) = j := by
   654	          rw [hdecomp]
   655	          exact_mod_cast hrcast
   656	        rw [hindex] at hz
   657	        exact (hjne hz).elim
   658	      · unfold boundaryNeighborhoods
   659	        rw [Finset.mem_biUnion]
   660	        refine ⟨n + 1, by
   661	          simp only [Finset.mem_range]
   662	          omega, ?_⟩
   663	        simp only [Finset.mem_Ico]
   664	        have hindex : ((2 * L * n + t : ℕ) : ℤ) = j := by
   665	          rw [hdecomp]
   666	          exact hrcast
   667	        constructor
   668	        · rw [← hindex]
   669	          have hnot : 2 * L ≤ t + (d + 1) := by omega
   670	          push_cast
   671	          push_cast at hnot
   672	          nlinarith
   673	        · rw [← hindex]
   674	          push_cast
   675	          omega
   676	
   677	end ENOTV

$ /bin/bash -lc 'lake env lean ENOTV/EvenEnergy.lean'
ENOTV/EvenEnergy.lean:43:54: warning: Variable name `hL` is not explicitly referenced.

Hint: The binding can be removed (if unused) or named `_` (if used implicitly). Alternatively, prefix the name with `_` to silence this warning:
  [apply] _hL

Note: This linter can be disabled with `set_option linter.unusedVariables false`
ENOTV/EvenEnergy.lean:78:44: warning: Variable name `hL` is not explicitly referenced.

Hint: The binding can be removed (if unused) or named `_` (if used implicitly). Alternatively, prefix the name with `_` to silence this warning:
  [apply] _hL

Note: This linter can be disabled with `set_option linter.unusedVariables false`
Try this:
  [apply] ring_nf
  
  The `ring` tactic failed to close the goal. Use `ring_nf` to obtain a normal form.
    
  Note that `ring` works primarily in *commutative* rings. If you have a noncommutative ring, abelian group or module, consider using `noncomm_ring`, `abel` or `module` instead.
ENOTV/EvenEnergy.lean:296:6: warning: 'push_cast' tactic does nothing

Note: This linter can be disabled with `set_option linter.unusedTactic false`
ENOTV/EvenEnergy.lean:300:6: warning: 'push_cast' tactic does nothing

Note: This linter can be disabled with `set_option linter.unusedTactic false`
ENOTV/EvenEnergy.lean:380:4: warning: 'push_cast' tactic does nothing

Note: This linter can be disabled with `set_option linter.unusedTactic false`
ENOTV/EvenEnergy.lean:383:4: warning: 'push_cast' tactic does nothing

Note: This linter can be disabled with `set_option linter.unusedTactic false`
ENOTV/EvenEnergy.lean:393:4: warning: 'push_cast' tactic does nothing

Note: This linter can be disabled with `set_option linter.unusedTactic false`
ENOTV/EvenEnergy.lean:398:26: warning: Variable name `hh0` is not explicitly referenced.

Hint: The binding can be removed (if unused) or named `_` (if used implicitly). Alternatively, prefix the name with `_` to silence this warning:
  [apply] _hh0

Note: This linter can be disabled with `set_opt

$ /bin/bash -lc 'lake env lean ENOTV/EvenEnergy.lean'
ENOTV/EvenEnergy.lean:43:54: warning: Variable name `hL` is not explicitly referenced.

Hint: The binding can be removed (if unused) or named `_` (if used implicitly). Alternatively, prefix the name with `_` to silence this warning:
  [apply] _hL

Note: This linter can be disabled with `set_option linter.unusedVariables false`
ENOTV/EvenEnergy.lean:78:44: warning: Variable name `hL` is not explicitly referenced.

Hint: The binding can be removed (if unused) or named `_` (if used implicitly). Alternatively, prefix the name with `_` to silence this warning:
  [apply] _hL

Note: This linter can be disabled with `set_option linter.unusedVariables false`
Try this:
  [apply] ring_nf
  
  The `ring` tactic failed to close the goal. Use `ring_nf` to obtain a normal form.
    
  Note that `ring` works primarily in *commutative* rings. If you have a noncommutative ring, abelian group or module, consider using `noncomm_ring`, `abel` or `module` instead.
ENOTV/EvenEnergy.lean:296:6: warning: 'push_cast' tactic does nothing

Note: This linter can be disabled with `set_option linter.unusedTactic false`
ENOTV/EvenEnergy.lean:300:6: warning: 'push_cast' tactic does nothing

Note: This linter can be disabled with `set_option linter.unusedTactic false`
ENOTV/EvenEnergy.lean:380:4: warning: 'push_cast' tactic does nothing

Note: This linter can be disabled with `set_option linter.unusedTactic false`
ENOTV/EvenEnergy.lean:383:4: warning: 'push_cast' tactic does nothing

Note: This linter can be disabled with `set_option linter.unusedTactic false`
ENOTV/EvenEnergy.lean:393:4: warning: 'push_cast' tactic does nothing

Note: This linter can be disabled with `set_option linter.unusedTactic false`
ENOTV/EvenEnergy.lean:398:26: warning: Variable name `hh0` is not explicitly referenced.

Hint: The binding can be removed (if unused) or named `_` (if used implicitly). Alternatively, prefix the name with `_` to silence this warning:
  [apply] _hh0

Note: This linter can be disabled with `set_opt

$ /bin/bash -lc 'lake env lean ENOTV/EvenEnergy.lean'
ENOTV/EvenEnergy.lean:43:54: warning: Variable name `hL` is not explicitly referenced.

Hint: The binding can be removed (if unused) or named `_` (if used implicitly). Alternatively, prefix the name with `_` to silence this warning:
  [apply] _hL

Note: This linter can be disabled with `set_option linter.unusedVariables false`
ENOTV/EvenEnergy.lean:78:44: warning: Variable name `hL` is not explicitly referenced.

Hint: The binding can be removed (if unused) or named `_` (if used implicitly). Alternatively, prefix the name with `_` to silence this warning:
  [apply] _hL

Note: This linter can be disabled with `set_option linter.unusedVariables false`
Try this:
  [apply] ring_nf
  
  The `ring` tactic failed to close the goal. Use `ring_nf` to obtain a normal form.
    
  Note that `ring` works primarily in *commutative* rings. If you have a noncommutative ring, abelian group or module, consider using `noncomm_ring`, `abel` or `module` instead.
ENOTV/EvenEnergy.lean:296:6: warning: 'push_cast' tactic does nothing

Note: This linter can be disabled with `set_option linter.unusedTactic false`
ENOTV/EvenEnergy.lean:300:6: warning: 'push_cast' tactic does nothing

Note: This linter can be disabled with `set_option linter.unusedTactic false`
ENOTV/EvenEnergy.lean:380:4: warning: 'push_cast' tactic does nothing

Note: This linter can be disabled with `set_option linter.unusedTactic false`
ENOTV/EvenEnergy.lean:383:4: warning: 'push_cast' tactic does nothing

Note: This linter can be disabled with `set_option linter.unusedTactic false`
ENOTV/EvenEnergy.lean:393:4: warning: 'push_cast' tactic does nothing

Note: This linter can be disabled with `set_option linter.unusedTactic false`
ENOTV/EvenEnergy.lean:398:26: warning: Variable name `hh0` is not explicitly referenced.

Hint: The binding can be removed (if unused) or named `_` (if used implicitly). Alternatively, prefix the name with `_` to silence this warning:
  [apply] _hh0

Note: This linter can be disabled with `set_opt

$ /bin/bash -lc "cat >/tmp/Check.lean <<'EOF'
import Mathlib
#check Finset.sum_range_succ
#check Finset.sum_range_succ'
#check Finset.sum_Ico_eq_sub
#check Finset.card_Ico
#check Int.card_Ico
#check Finset.pairwiseDisjoint_biUnion
EOF
lake env lean /tmp/Check.lean"
Finset.sum_range_succ.{u_4} {M : Type u_4} [AddCommMonoid M] (f : ℕ → M) (n : ℕ) :
  ∑ x ∈ Finset.range (n + 1), f x = ∑ x ∈ Finset.range n, f x + f n
Finset.sum_range_succ'.{u_4} {M : Type u_4} [AddCommMonoid M] (f : ℕ → M) (n : ℕ) :
  ∑ k ∈ Finset.range (n + 1), f k = ∑ k ∈ Finset.range n, f (k + 1) + f 0
Finset.sum_Ico_eq_sub.{u_4} {δ : Type u_4} [AddCommGroup δ] (f : ℕ → δ) {m n : ℕ} (h : m ≤ n) :
  ∑ k ∈ Finset.Ico m n, f k = ∑ k ∈ Finset.range n, f k - ∑ k ∈ Finset.range m, f k
/tmp/Check.lean:5:7: error(lean.unknownIdentifier): Unknown constant `Finset.card_Ico`
Int.card_Ico (a b : ℤ) : (Finset.Ico a b).card = (b - a).toNat
/tmp/Check.lean:7:7: error(lean.unknownIdentifier): Unknown constant `Finset.pairwiseDisjoint_biUnion`

$ /bin/bash -lc 'lake env lean ENOTV/EvenEnergy.lean'
ENOTV/EvenEnergy.lean:43:54: warning: Variable name `hL` is not explicitly referenced.

Hint: The binding can be removed (if unused) or named `_` (if used implicitly). Alternatively, prefix the name with `_` to silence this warning:
  [apply] _hL

Note: This linter can be disabled with `set_option linter.unusedVariables false`
ENOTV/EvenEnergy.lean:78:44: warning: Variable name `hL` is not explicitly referenced.

Hint: The binding can be removed (if unused) or named `_` (if used implicitly). Alternatively, prefix the name with `_` to silence this warning:
  [apply] _hL

Note: This linter can be disabled with `set_option linter.unusedVariables false`
Try this:
  [apply] ring_nf
  
  The `ring` tactic failed to close the goal. Use `ring_nf` to obtain a normal form.
    
  Note that `ring` works primarily in *commutative* rings. If you have a noncommutative ring, abelian group or module, consider using `noncomm_ring`, `abel` or `module` instead.
ENOTV/EvenEnergy.lean:296:6: warning: 'push_cast' tactic does nothing

Note: This linter can be disabled with `set_option linter.unusedTactic false`
ENOTV/EvenEnergy.lean:300:6: warning: 'push_cast' tactic does nothing

Note: This linter can be disabled with `set_option linter.unusedTactic false`
ENOTV/EvenEnergy.lean:380:4: warning: 'push_cast' tactic does nothing

Note: This linter can be disabled with `set_option linter.unusedTactic false`
ENOTV/EvenEnergy.lean:383:4: warning: 'push_cast' tactic does nothing

Note: This linter can be disabled with `set_option linter.unusedTactic false`
ENOTV/EvenEnergy.lean:393:4: warning: 'push_cast' tactic does nothing

Note: This linter can be disabled with `set_option linter.unusedTactic false`
ENOTV/EvenEnergy.lean:398:26: warning: Variable name `hh0` is not explicitly referenced.

Hint: The binding can be removed (if unused) or named `_` (if used implicitly). Alternatively, prefix the name with `_` to silence this warning:
  [apply] _hh0

Note: This linter can be disabled with `set_opt

$ /bin/bash -lc "nl -ba ENOTV/EvenEnergy.lean | sed -n '615,710p'; nl -ba ENOTV/EvenEnergy.lean | sed -n '730,845p'"
615	        rw [cdiffIter_apply]
   616	        have hc := diffIter_congr_of_block (d + 1)
   617	          (multiJumps d L P : Seq) 0 j (by
   618	            intro q hq
   619	            rw [Pi.zero_apply, multiJumps_zero_of_neg]
   620	            push_cast
   621	            omega)
   622	        rw [hc]
   623	        exact diffIter_zero_seq (d + 1) j
   624	      exact hjne hz
   625	    unfold boundaryNeighborhoods
   626	    rw [Finset.mem_biUnion]
   627	    refine ⟨0, by simp, ?_⟩
   628	    simp only [Finset.mem_Ico]
   629	    constructor <;> simp_all
   630	  · have hj0 : 0 ≤ j := le_of_not_gt hjneg
   631	    by_cases hjend : (4 * L * P : ℕ) ≤ j
   632	    · have hz :
   633	          cdiffIter (d + 1) (multiJumps d L P) j = 0 := by
   634	        rw [cdiffIter_apply]
   635	        have hc := diffIter_congr_of_block (d + 1)
   636	          (multiJumps d L P : Seq) 0 j (by
   637	            intro q hq
   638	            rw [Pi.zero_apply, multiJumps_zero_of_ge]
   639	            push_cast at hjend ⊢
   640	            omega)
   641	        rw [hc]
   642	        exact diffIter_zero_seq (d + 1) j
   643	      exact (hjne hz).elim
   644	    · have hjlt : j < (4 * L * P : ℕ) := by omega
   645	      let r := Int.toNat j
   646	      let n := r / (2 * L)
   647	      let t := r % (2 * L)
   648	      have hrcast : (r : ℤ) = j := Int.toNat_of_nonneg hj0
   649	      have hden : 0 < 2 * L := by omega
   650	      have ht : t < 2 * L := Nat.mod_lt _ hden
   651	      have hdecomp : 2 * L * n + t = r := by
   652	        simpa [n, t, mul_comm] using (Nat.div_add_mod r (2 * L))
   653	      have hn : n < 2 * P := by
   654	        rw [Nat.div_lt_iff_lt_mul hden]
   655	        have : r < 4 * L * P := by
   656	          rw [← hrcast] at hjlt
   657	          exact_mod_cast hjlt
   658	        nlinarith
   659	      by_cases hinterior : t + (d + 1) < 2 * L
   660	      · have hz := multiJumps_interior_difference_zero
   661	          (d := d) (L := L) (P :=

$ /bin/bash -lc 'tail -45 ENOTV/EvenEnergy.lean'
push_cast
          nlinarith
        have hs1 : s ≤ -1 := by
          dsimp [s]
          push_cast
          nlinarith
        have hA := right_endpoint_blockAmplitude_le hd heven hL hP s hs0 hs1
        have hD := right_endpoint_difference_le hd heven hL hP s hs0 hs1
        have hjform : j = ((4 * L * P : ℕ) : ℤ) + s := by
          dsimp [s]
          ring
        rw [hjform]
        exact mul_le_mul hA hD (abs_nonneg _)
          (boundaryAmplitudeUpper_nonneg d L)
    _ = (d + 1) * endpointEnergyUpper d L := by
      rw [Finset.sum_const, nsmul_eq_mul, boundaryNeighborhood_card]
      norm_cast

theorem cEnergy_multiJumps_le_boundary_sum {d L P : ℕ}
    (hd : 0 < d) (heven : Even d) (hL : d + 1 ≤ L) :
    cEnergy (d + 2) (multiJumps d L P) ≤
      ∑ n ∈ Finset.range (2 * P + 1), boundaryEnergy d L P n := by
  unfold cEnergy
  change (∑ j ∈ (cdiffIter (d + 1) (multiJumps d L P)).support,
      blockAmplitude (d + 2) (multiJumps d L P : Seq) j *
        |cdiffIter (d + 1) (multiJumps d L P) j|) ≤ _
  calc
    _ ≤ ∑ j ∈ (Finset.range (2 * P + 1)).biUnion
          (boundaryNeighborhood d L),
        blockAmplitude (d + 2) (multiJumps d L P : Seq) j *
          |cdiffIter (d + 1) (multiJumps d L P) j| := by
      apply Finset.sum_le_sum_of_subset_of_nonneg
        (highestDifference_support_subset hd heven hL)
      intro j hj hnot
      exact mul_nonneg (blockAmplitude_nonneg _ _ _)
        (abs_nonneg _)
    _ = ∑ n ∈ Finset.range (2 * P + 1),
          ∑ j ∈ boundaryNeighborhood d L n,
            blockAmplitude (d + 2) (multiJumps d L P : Seq) j *
              |cdiffIter (d + 1) (multiJumps d L P) j| := by
      rw [Finset.sum_biUnion (boundaryNeighborhood_pairwiseDisjoint hL)]
    _ = ∑ n ∈ Finset.range (2 * P + 1),
          boundaryEnergy d L P n := by rfl

end ENOTV

$ /bin/bash -lc 'lake env lean ENOTV/EvenEnergy.lean'
ENOTV/EvenEnergy.lean:43:54: warning: Variable name `hL` is not explicitly referenced.

Hint: The binding can be removed (if unused) or named `_` (if used implicitly). Alternatively, prefix the name with `_` to silence this warning:
  [apply] _hL

Note: This linter can be disabled with `set_option linter.unusedVariables false`
ENOTV/EvenEnergy.lean:78:44: warning: Variable name `hL` is not explicitly referenced.

Hint: The binding can be removed (if unused) or named `_` (if used implicitly). Alternatively, prefix the name with `_` to silence this warning:
  [apply] _hL

Note: This linter can be disabled with `set_option linter.unusedVariables false`
Try this:
  [apply] ring_nf
  
  The `ring` tactic failed to close the goal. Use `ring_nf` to obtain a normal form.
    
  Note that `ring` works primarily in *commutative* rings. If you have a noncommutative ring, abelian group or module, consider using `noncomm_ring`, `abel` or `module` instead.
ENOTV/EvenEnergy.lean:296:6: warning: 'push_cast' tactic does nothing

Note: This linter can be disabled with `set_option linter.unusedTactic false`
ENOTV/EvenEnergy.lean:300:6: warning: 'push_cast' tactic does nothing

Note: This linter can be disabled with `set_option linter.unusedTactic false`
ENOTV/EvenEnergy.lean:380:4: warning: 'push_cast' tactic does nothing

Note: This linter can be disabled with `set_option linter.unusedTactic false`
ENOTV/EvenEnergy.lean:383:4: warning: 'push_cast' tactic does nothing

Note: This linter can be disabled with `set_option linter.unusedTactic false`
ENOTV/EvenEnergy.lean:393:4: warning: 'push_cast' tactic does nothing

Note: This linter can be disabled with `set_option linter.unusedTactic false`
ENOTV/EvenEnergy.lean:398:26: warning: Variable name `hh0` is not explicitly referenced.

Hint: The binding can be removed (if unused) or named `_` (if used implicitly). Alternatively, prefix the name with `_` to silence this warning:
  [apply] _hh0

Note: This linter can be disabled with `set_opt

$ /bin/bash -lc 'rg -n "theorem exists_multi_moment_lower|pairDatum_amplitude|multiDatum.*amplitude|cJumpMoment" ENOTV/Bulk.lean ENOTV/Estimates.lean'
ENOTV/Estimates.lean:156:theorem pairDatum_amplitude_bound (d L : ℕ) (hL : 0 < L) :
ENOTV/Estimates.lean:165:theorem multiDatum_amplitude_bound (d L P : ℕ) (hL : 0 < L) :
ENOTV/Estimates.lean:169:    camplitude (multiDatum d L P) ≤ camplitude (pairDatum d L) := by
ENOTV/Estimates.lean:173:      pairDatum_amplitude_bound d L hL
ENOTV/Bulk.lean:189:theorem cJumpMoment_eq_powerSum (k : ℕ) (u : CSeq) :
ENOTV/Bulk.lean:190:    cJumpMoment k u = powerSum k (cdiff u) := rfl
ENOTV/Bulk.lean:256:theorem exists_multi_moment_lower (d k : ℕ) :
ENOTV/Bulk.lean:262:          cJumpMoment k (multiDatum d L P) := by
ENOTV/Bulk.lean:268:  rw [cJumpMoment_eq_powerSum, cdiff_multiDatum,

$ /bin/bash -lc "sed -n '145,180p' ENOTV/Estimates.lean; sed -n '240,285p' ENOTV/Bulk.lean"
theorem camplitude_le_of_pointwise {f : CSeq} {C : ℝ} (hC : 0 ≤ C)
    (h : ∀ i, |f i| ≤ C) :
    camplitude f ≤ C := by
  unfold camplitude
  rw [Finset.max'_le_iff]
  intro x hx
  simp only [Finset.mem_insert, Finset.mem_image] at hx
  rcases hx with rfl | ⟨i, hi, rfl⟩
  · exact hC
  · exact h i

theorem pairDatum_amplitude_bound (d L : ℕ) (hL : 0 < L) :
    camplitude (pairDatum d L) ≤
      4 * (eulerUpper d : ℝ) * (L : ℝ) ^ (d + 1) := by
  apply camplitude_le_of_pointwise
  · have hE := eulerUpper_nonneg d
    norm_cast at hE
    positivity
  · exact pairDatum_pointwise_bound d L hL

theorem multiDatum_amplitude_bound (d L P : ℕ) (hL : 0 < L) :
    camplitude (multiDatum d L P) ≤
      4 * (eulerUpper d : ℝ) * (L : ℝ) ^ (d + 1) := by
  calc
    camplitude (multiDatum d L P) ≤ camplitude (pairDatum d L) := by
      apply camplitude_le_of_pointwise (camplitude_nonneg _)
      exact multiDatum_pointwise_le_pair d L P
    _ ≤ 4 * (eulerUpper d : ℝ) * (L : ℝ) ^ (d + 1) :=
      pairDatum_amplitude_bound d L hL

end ENOTV
    (M : ℝ) * ((c : ℝ) * (L : ℝ) ^ d) ^ (k + 1) =
        ∑ i ∈ S, ((c : ℝ) * (L : ℝ) ^ d) ^ (k + 1) := by
      simp [S]
    _ ≤ ∑ i ∈ S, |pairJumps d L i| ^ (k + 1) := by
      apply Finset.sum_le_sum
      intro i hi
      rw [Finset.mem_map] at hi
      obtain ⟨r, hr, rfl⟩ := hi
      exact pow_le_pow_left₀ (by positivity)
        (hsample r (Finset.mem_range.mp hr)) _
    _ ≤ ∑ i ∈ (pairJumps d L).support,
          |pairJumps d L i| ^ (k + 1) := by
      apply Finset.sum_le_sum_of_subset_of_nonneg hSsub
      intro i hiS hi
      positivity

theorem exists_multi_moment_lower (d k : ℕ) :
    ∃ b : ℕ, ∃ c : ℚ, 0 < b ∧ 0 < c ∧
      ∀ M P : ℕ, 0 < M →
        let L := b * M
        (P : ℝ) * (M : ℝ) *
            ((c : ℝ) * (L : ℝ) ^ d) ^ (k + 1) ≤
          cJumpMoment k (multiDatum d L P) := by
  obtain ⟨b, a, c, hb, hab, hc, hlower⟩ :=
    exists_pair_moment_lower d k
  refine ⟨b, c, hb, hc, ?_⟩
  intro M P hM
  dsimp only
  rw [cJumpMoment_eq

$ /bin/bash -lc 'lake env lean ENOTV/EvenEnergy.lean'
ENOTV/EvenEnergy.lean:43:54: warning: Variable name `hL` is not explicitly referenced.

Hint: The binding can be removed (if unused) or named `_` (if used implicitly). Alternatively, prefix the name with `_` to silence this warning:
  [apply] _hL

Note: This linter can be disabled with `set_option linter.unusedVariables false`
ENOTV/EvenEnergy.lean:78:44: warning: Variable name `hL` is not explicitly referenced.

Hint: The binding can be removed (if unused) or named `_` (if used implicitly). Alternatively, prefix the name with `_` to silence this warning:
  [apply] _hL

Note: This linter can be disabled with `set_option linter.unusedVariables false`
Try this:
  [apply] ring_nf
  
  The `ring` tactic failed to close the goal. Use `ring_nf` to obtain a normal form.
    
  Note that `ring` works primarily in *commutative* rings. If you have a noncommutative ring, abelian group or module, consider using `noncomm_ring`, `abel` or `module` instead.
ENOTV/EvenEnergy.lean:296:6: warning: 'push_cast' tactic does nothing

Note: This linter can be disabled with `set_option linter.unusedTactic false`
ENOTV/EvenEnergy.lean:300:6: warning: 'push_cast' tactic does nothing

Note: This linter can be disabled with `set_option linter.unusedTactic false`
ENOTV/EvenEnergy.lean:380:4: warning: 'push_cast' tactic does nothing

Note: This linter can be disabled with `set_option linter.unusedTactic false`
ENOTV/EvenEnergy.lean:383:4: warning: 'push_cast' tactic does nothing

Note: This linter can be disabled with `set_option linter.unusedTactic false`
ENOTV/EvenEnergy.lean:393:4: warning: 'push_cast' tactic does nothing

Note: This linter can be disabled with `set_option linter.unusedTactic false`
ENOTV/EvenEnergy.lean:398:26: warning: Variable name `hh0` is not explicitly referenced.

Hint: The binding can be removed (if unused) or named `_` (if used implicitly). Alternatively, prefix the name with `_` to silence this warning:
  [apply] _hh0

Note: This linter can be disabled with `set_opt

$ /bin/bash -lc 'lake env lean ENOTV/EvenEnergy.lean'
ENOTV/EvenEnergy.lean:43:54: warning: Variable name `hL` is not explicitly referenced.

Hint: The binding can be removed (if unused) or named `_` (if used implicitly). Alternatively, prefix the name with `_` to silence this warning:
  [apply] _hL

Note: This linter can be disabled with `set_option linter.unusedVariables false`
ENOTV/EvenEnergy.lean:78:44: warning: Variable name `hL` is not explicitly referenced.

Hint: The binding can be removed (if unused) or named `_` (if used implicitly). Alternatively, prefix the name with `_` to silence this warning:
  [apply] _hL

Note: This linter can be disabled with `set_option linter.unusedVariables false`
Try this:
  [apply] ring_nf
  
  The `ring` tactic failed to close the goal. Use `ring_nf` to obtain a normal form.
    
  Note that `ring` works primarily in *commutative* rings. If you have a noncommutative ring, abelian group or module, consider using `noncomm_ring`, `abel` or `module` instead.
ENOTV/EvenEnergy.lean:296:6: warning: 'push_cast' tactic does nothing

Note: This linter can be disabled with `set_option linter.unusedTactic false`
ENOTV/EvenEnergy.lean:300:6: warning: 'push_cast' tactic does nothing

Note: This linter can be disabled with `set_option linter.unusedTactic false`
ENOTV/EvenEnergy.lean:380:4: warning: 'push_cast' tactic does nothing

Note: This linter can be disabled with `set_option linter.unusedTactic false`
ENOTV/EvenEnergy.lean:383:4: warning: 'push_cast' tactic does nothing

Note: This linter can be disabled with `set_option linter.unusedTactic false`
ENOTV/EvenEnergy.lean:393:4: warning: 'push_cast' tactic does nothing

Note: This linter can be disabled with `set_option linter.unusedTactic false`
ENOTV/EvenEnergy.lean:398:26: warning: Variable name `hh0` is not explicitly referenced.

Hint: The binding can be removed (if unused) or named `_` (if used implicitly). Alternatively, prefix the name with `_` to silence this warning:
  [apply] _hh0

Note: This linter can be disabled with `set_opt

$ /bin/bash -lc "nl -ba ENOTV/EvenEnergy.lean | sed -n '892,910p'"
892	          (boundaryAmplitudeUpper d L * (junctionUpper d : ℝ))) := by
   893	    calc
   894	      (∑ q ∈ Finset.range (2 * P - 1), f (q + 1)) ≤
   895	          ∑ _q ∈ Finset.range (2 * P - 1),
   896	            (d + 1) *
   897	              (boundaryAmplitudeUpper d L * (junctionUpper d : ℝ)) := by
   898	        apply Finset.sum_le_sum
   899	        intro q hq
   900	        simp only [Finset.mem_range] at hq
   901	        exact internal_boundaryEnergy_le hd heven hL (by omega) (by omega)
   902	      _ = (2 * P - 1) * ((d + 1) *
   903	          (boundaryAmplitudeUpper d L * (junctionUpper d : ℝ))) := by
   904	        rw [Finset.sum_const, nsmul_eq_mul]
   905	        norm_cast
   906	  have hright := right_boundaryEnergy_le hd heven hL hP
   907	  have hleft := left_boundaryEnergy_le hd heven hL hP
   908	  change f (2 * P) ≤ (d + 1) * endpointEnergyUpper d L at hright
   909	  change f 0 ≤ (d + 1) * endpointEnergyUpper d L at hleft
   910	  calc

$ /bin/bash -lc 'lake env lean ENOTV/EvenEnergy.lean'
ENOTV/EvenEnergy.lean:43:54: warning: Variable name `hL` is not explicitly referenced.

Hint: The binding can be removed (if unused) or named `_` (if used implicitly). Alternatively, prefix the name with `_` to silence this warning:
  [apply] _hL

Note: This linter can be disabled with `set_option linter.unusedVariables false`
ENOTV/EvenEnergy.lean:78:44: warning: Variable name `hL` is not explicitly referenced.

Hint: The binding can be removed (if unused) or named `_` (if used implicitly). Alternatively, prefix the name with `_` to silence this warning:
  [apply] _hL

Note: This linter can be disabled with `set_option linter.unusedVariables false`
Try this:
  [apply] ring_nf
  
  The `ring` tactic failed to close the goal. Use `ring_nf` to obtain a normal form.
    
  Note that `ring` works primarily in *commutative* rings. If you have a noncommutative ring, abelian group or module, consider using `noncomm_ring`, `abel` or `module` instead.
ENOTV/EvenEnergy.lean:296:6: warning: 'push_cast' tactic does nothing

Note: This linter can be disabled with `set_option linter.unusedTactic false`
ENOTV/EvenEnergy.lean:300:6: warning: 'push_cast' tactic does nothing

Note: This linter can be disabled with `set_option linter.unusedTactic false`
ENOTV/EvenEnergy.lean:380:4: warning: 'push_cast' tactic does nothing

Note: This linter can be disabled with `set_option linter.unusedTactic false`
ENOTV/EvenEnergy.lean:383:4: warning: 'push_cast' tactic does nothing

Note: This linter can be disabled with `set_option linter.unusedTactic false`
ENOTV/EvenEnergy.lean:393:4: warning: 'push_cast' tactic does nothing

Note: This linter can be disabled with `set_option linter.unusedTactic false`
ENOTV/EvenEnergy.lean:398:26: warning: Variable name `hh0` is not explicitly referenced.

Hint: The binding can be removed (if unused) or named `_` (if used implicitly). Alternatively, prefix the name with `_` to silence this warning:
  [apply] _hh0

Note: This linter can be disabled with `set_opt

$ /bin/bash -lc 'lake env lean ENOTV/EvenEnergy.lean'
ENOTV/EvenEnergy.lean:43:54: warning: Variable name `hL` is not explicitly referenced.

Hint: The binding can be removed (if unused) or named `_` (if used implicitly). Alternatively, prefix the name with `_` to silence this warning:
  [apply] _hL

Note: This linter can be disabled with `set_option linter.unusedVariables false`
ENOTV/EvenEnergy.lean:78:44: warning: Variable name `hL` is not explicitly referenced.

Hint: The binding can be removed (if unused) or named `_` (if used implicitly). Alternatively, prefix the name with `_` to silence this warning:
  [apply] _hL

Note: This linter can be disabled with `set_option linter.unusedVariables false`
Try this:
  [apply] ring_nf
  
  The `ring` tactic failed to close the goal. Use `ring_nf` to obtain a normal form.
    
  Note that `ring` works primarily in *commutative* rings. If you have a noncommutative ring, abelian group or module, consider using `noncomm_ring`, `abel` or `module` instead.
ENOTV/EvenEnergy.lean:296:6: warning: 'push_cast' tactic does nothing

Note: This linter can be disabled with `set_option linter.unusedTactic false`
ENOTV/EvenEnergy.lean:300:6: warning: 'push_cast' tactic does nothing

Note: This linter can be disabled with `set_option linter.unusedTactic false`
ENOTV/EvenEnergy.lean:380:4: warning: 'push_cast' tactic does nothing

Note: This linter can be disabled with `set_option linter.unusedTactic false`
ENOTV/EvenEnergy.lean:383:4: warning: 'push_cast' tactic does nothing

Note: This linter can be disabled with `set_option linter.unusedTactic false`
ENOTV/EvenEnergy.lean:393:4: warning: 'push_cast' tactic does nothing

Note: This linter can be disabled with `set_option linter.unusedTactic false`
ENOTV/EvenEnergy.lean:398:26: warning: Variable name `hh0` is not explicitly referenced.

Hint: The binding can be removed (if unused) or named `_` (if used implicitly). Alternatively, prefix the name with `_` to silence this warning:
  [apply] _hh0

Note: This linter can be disabled with `set_opt

$ /bin/bash -lc 'lake build ENOTV.EvenEnergy && lake env lean ENOTV/EvenFailure.lean'
⚠ [8679/8688] Replayed ENOTV.Energy
warning: ENOTV/Energy.lean:158:24: Used `tac1 <;> tac2` where `(tac1; tac2)` would suffice

Note: This linter can be disabled with `set_option linter.unnecessarySeqFocus false`
⚠ [8680/8688] Replayed ENOTV.Euler
info: ENOTV/Euler.lean:31:2: Try this:
  [apply] ring_nf
  
  The `ring` tactic failed to close the goal. Use `ring_nf` to obtain a normal form.
    
  Note that `ring` works primarily in *commutative* rings. If you have a noncommutative ring, abelian group or module, consider using `noncomm_ring`, `abel` or `module` instead.
warning: ENOTV/Euler.lean:124:15: Used `tac1 <;> tac2` where `(tac1; tac2)` would suffice

Note: This linter can be disabled with `set_option linter.unnecessarySeqFocus false`
warning: ENOTV/Euler.lean:123:4: 'congr 2' tactic does nothing

Note: This linter can be disabled with `set_option linter.unusedTactic false`
warning: ENOTV/Euler.lean:163:6: Used `tac1 <;> tac2` where `(tac1; tac2)` would suffice

Note: This linter can be disabled with `set_option linter.unnecessarySeqFocus false`
⚠ [8681/8688] Replayed ENOTV.Counterexample
warning: ENOTV/Counterexample.lean:111:53: This simp argument is unused:
  h2

Hint: Omit it from the simp argument list.
  [apply] simp [pairDatumNat_apply, pairJumpNat_apply, h4, blockPrefix_succ]

Note: This linter can be disabled with `set_option linter.unusedSimpArgs false`
warning: ENOTV/Counterexample.lean:134:59: This simp argument is unused:
  h₄

Hint: Omit it from the simp argument list.
  [apply] simp [pairDatumNat_apply, pairJumpNat_apply, h₁, h42, h412, h414, hsub]

Note: This linter can be disabled with `set_option linter.unusedSimpArgs false`
warning: ENOTV/Counterexample.lean:356:4: `push_neg` has been deprecated. Prefer using `push Not` instead.
If you'd rather continue using `push_neg` in your project, you can implement it as follows:
```
open Lean.Parser.Tactic in
macro "push_neg" cfg:optConfig loc:(location)? : tactic =>
  `(tactic| push $cfg:optConfig N

$ /bin/bash -lc "cat >/tmp/Check.lean <<'EOF'
import Mathlib
#check pow_mul
#check pow_add
EOF
lake env lean /tmp/Check.lean"
pow_mul.{u_2} {M : Type u_2} [Monoid M] (a : M) (m n : ℕ) : a ^ (m * n) = (a ^ m) ^ n
pow_add.{u_2} {M : Type u_2} [Monoid M] (a : M) (m n : ℕ) : a ^ (m + n) = a ^ m * a ^ n

$ /bin/bash -lc "nl -ba ENOTV/EvenFailure.lean | sed -n '150,172p'"
150	    positivity
   151	  calc
   152	    camplitude (multiDatum d L (L ^ d)) ^ (d + 1) *
   153	          cSource (d + 2) (multiDatum d L (L ^ d)) ≤
   154	        (4 * (eulerUpper d : ℝ) * (L : ℝ) ^ (d + 1)) ^ (d + 1) *
   155	          (gammaMax (d + 2) (by omega) *
   156	            (evenEnergyConstant d * (L : ℝ) ^ (2 * d - 1))) := by
   157	      exact mul_le_mul hApow hSpow hS0 (pow_nonneg hAbound0 _)
   158	    _ = evenDenominatorConstant d *
   159	          (L : ℝ) ^ (d ^ 2 + 4 * d) := by
   160	      unfold evenDenominatorConstant
   161	      rw [mul_pow, pow_mul, ← pow_add]
   162	      congr 1
   163	      · ring
   164	      · omega
   165	
   166	end ENOTV

$ /bin/bash -lc 'lake env lean ENOTV/EvenFailure.lean'
ENOTV/EvenFailure.lean:161:30: error: Tactic `rewrite` failed: Did not find an occurrence of the pattern
  ?a ^ ?m * ?a ^ ?n
in the target expression
  (4 * ↑(eulerUpper d)) ^ (d + 1) * ↑L ^ ((d + 1) * (d + 1)) *
      (gammaMax (d + 2) ⋯ * (evenEnergyConstant d * ↑L ^ (2 * d - 1))) =
    (4 * ↑(eulerUpper d)) ^ (d + 1) * gammaMax (d + 2) ⋯ * evenEnergyConstant d * ↑L ^ (d ^ 2 + 4 * d)

hFMT : FMTReconstructionTheorem
d L : ℕ
hd : 2 ≤ d
heven : Even d
hL : d + 1 ≤ L
hLpos : 0 < L
hA : camplitude (multiDatum d L (L ^ d)) ≤ 4 * ↑(eulerUpper d) * ↑L ^ (d + 1)
hS : cSource (d + 2) (multiDatum d L (L ^ d)) ≤ gammaMax (d + 2) ⋯ * cEnergy (d + 2) (multiJumps d L (L ^ d))
hE : cEnergy (d + 2) (multiJumps d L (L ^ d)) ≤ evenEnergyConstant d * ↑L ^ (2 * d - 1)
hA0 : 0 ≤ camplitude (multiDatum d L (L ^ d))
hAbound0 : 0 ≤ 4 * ↑(eulerUpper d) * ↑L ^ (d + 1)
hApow : camplitude (multiDatum d L (L ^ d)) ^ (d + 1) ≤ (4 * ↑(eulerUpper d) * ↑L ^ (d + 1)) ^ (d + 1)
hG : 0 ≤ gammaMax (d + 2) ⋯
hSpow : cSource (d + 2) (multiDatum d L (L ^ d)) ≤ gammaMax (d + 2) ⋯ * (evenEnergyConstant d * ↑L ^ (2 * d - 1))
hS0 : 0 ≤ cSource (d + 2) (multiDatum d L (L ^ d))
⊢ (4 * ↑(eulerUpper d)) ^ (d + 1) * ↑L ^ ((d + 1) * (d + 1)) *
      (gammaMax (d + 2) ⋯ * (evenEnergyConstant d * ↑L ^ (2 * d - 1))) =
    (4 * ↑(eulerUpper d)) ^ (d + 1) * gammaMax (d + 2) ⋯ * evenEnergyConstant d * ↑L ^ (d ^ 2 + 4 * d)

$ /bin/bash -lc 'lake env lean ENOTV/EvenFailure.lean'
Try this:
  [apply] ring_nf
  
  The `ring` tactic failed to close the goal. Use `ring_nf` to obtain a normal form.
    
  Note that `ring` works primarily in *commutative* rings. If you have a noncommutative ring, abelian group or module, consider using `noncomm_ring`, `abel` or `module` instead.
ENOTV/EvenFailure.lean:165:41: error: unsolved goals
case e_a
hFMT : FMTReconstructionTheorem
d L : ℕ
hd : 2 ≤ d
heven : Even d
hL : d + 1 ≤ L
hLpos : 0 < L
hA : camplitude (multiDatum d L (L ^ d)) ≤ 4 * ↑(eulerUpper d) * ↑L ^ (d + 1)
hS : cSource (d + 2) (multiDatum d L (L ^ d)) ≤ gammaMax (d + 2) ⋯ * cEnergy (d + 2) (multiJumps d L (L ^ d))
hE : cEnergy (d + 2) (multiJumps d L (L ^ d)) ≤ evenEnergyConstant d * ↑L ^ (2 * d - 1)
hA0 : 0 ≤ camplitude (multiDatum d L (L ^ d))
hAbound0 : 0 ≤ 4 * ↑(eulerUpper d) * ↑L ^ (d + 1)
hApow : camplitude (multiDatum d L (L ^ d)) ^ (d + 1) ≤ (4 * ↑(eulerUpper d) * ↑L ^ (d + 1)) ^ (d + 1)
hG : 0 ≤ gammaMax (d + 2) ⋯
hSpow : cSource (d + 2) (multiDatum d L (L ^ d)) ≤ gammaMax (d + 2) ⋯ * (evenEnergyConstant d * ↑L ^ (2 * d - 1))
hS0 : 0 ≤ cSource (d + 2) (multiDatum d L (L ^ d))
⊢ 1 + d * 2 + d ^ 2 + (d * 2 - 1) = d * 4 + d ^ 2

$ /bin/bash -lc 'lake env lean ENOTV/EvenFailure.lean'
ENOTV/EvenFailure.lean:168:8: error: omega could not prove the goal:
a possible counterexample may satisfy the constraints
  e ≥ 0
  c ≥ 0
  b ≥ 1
  a ≥ 2
  a - b ≤ -1
  a ≥ 1
  2*a + c - e ≥ 0
where
 a := ↑d
 b := ↑L
 c := ↑(d ^ 2)
 e := ↑(d + 1) * ↑(d + 1)

$ /bin/bash -lc 'lake env lean ENOTV/EvenFailure.lean'

$ /bin/bash -lc "cat >/tmp/Check.lean <<'EOF'
import Mathlib
#check exists_nat_gt
#check exists_nat_one_div_lt
#check Nat.cast_pos.mpr
EOF
lake env lean /tmp/Check.lean"
exists_nat_gt.{u_1} {R : Type u_1} [Semiring R] [PartialOrder R] [IsStrictOrderedRing R] [Archimedean R] (x : R) :
  ∃ n, x < ↑n
exists_nat_one_div_lt.{u_4} {K : Type u_4} [Semifield K] [LinearOrder K] [IsStrictOrderedRing K] [Archimedean K] {ε : K}
  (hε : 0 < ε) : ∃ n, 1 / (↑n + 1) < ε
Nat.cast_pos.mpr : 0 < ?m.6 → 0 < ↑?m.6

$ /bin/bash -lc 'lake env lean ENOTV/EvenFailure.lean'
ENOTV/EvenFailure.lean:210:19: error: Tactic `rewrite` failed: Did not find an occurrence of the pattern
  (?a ^ ?m) ^ ?n
in the target expression
  ↑c ^ (d + 3) * ↑M * ↑L ^ (d ^ 2 + 4 * d) = ↑(b ^ d * M ^ d) * ↑M * (↑c * ↑L ^ d) ^ (d + 3)

d b : ℕ
c : ℚ
hb : 0 < b
hc : 0 < c
hlower :
  ∀ (M P : ℕ),
    0 < M →
      have L := b * M;
      ↑P * ↑M * (↑c * ↑L ^ d) ^ (d + 2 + 1) ≤ cJumpMoment (d + 2) (multiDatum d L P)
M : ℕ
hM : 0 < M
L : ℕ := b * M
hraw : ↑(L ^ d) * ↑M * (↑c * ↑L ^ d) ^ (d + 3) ≤ cJumpMoment (d + 2) (multiDatum d L (L ^ d))
hpow : ↑L ^ d * ↑L ^ (d * (d + 3)) = ↑L ^ (d ^ 2 + 4 * d)
⊢ ↑c ^ (d + 3) * ↑M * ↑L ^ (d ^ 2 + 4 * d) = ↑(b ^ d * M ^ d) * ↑M * (↑c * ↑L ^ d) ^ (d + 3)
ENOTV/EvenFailure.lean:256:10: error: omega could not prove the goal:
a possible counterexample may satisfy the constraints
  f ≥ 0
  e ≥ 0
  c ≥ 1
  a ≥ 2
  a - f ≤ -1
  a + e ≥ 0
where
 a := ↑d
 c := ↑b
 e := ↑N
 f := ↑b * ↑M
Try this:
  [apply] ring_nf
  
  The `ring` tactic failed to close the goal. Use `ring_nf` to obtain a normal form.
    
  Note that `ring` works primarily in *commutative* rings. If you have a noncommutative ring, abelian group or module, consider using `noncomm_ring`, `abel` or `module` instead.
ENOTV/EvenFailure.lean:257:8: error: unsolved goals
case e_a
hFMT : FMTReconstructionTheorem
d : ℕ
hd : 2 ≤ d
heven : Even d
C : ℝ
hC : 0 ≤ C
hcoerc : ∀ (u : CSeq), cJumpMoment (d + 2) u ≤ C * camplitude u ^ (d + 2 - 1) * cSource (d + 2) u
b : ℕ
c₀ : ℝ
hb : 0 < b
hc₀ : 0 < c₀
hlower :
  ∀ (M : ℕ),
    0 < M →
      have L := b * M;
      c₀ * ↑M * ↑L ^ (d ^ 2 + 4 * d) ≤ cJumpMoment (d + 2) (multiDatum d L (L ^ d))
D : ℝ := evenDenominatorConstant d
N : ℕ
hN : C * D / c₀ < ↑N
M : ℕ := N + d + 1
L : ℕ := b * M
hM : 0 < M
hMlarge : d + 1 ≤ M
hb1 : 1 ≤ b
hL : d + 1 ≤ L
hconst : C * D < c₀ * ↑M
hbulk : c₀ * ↑M * ↑L ^ (d ^ 2 + 4 * d) ≤ cJumpMoment (d + 2) (multiDatum d L (L ^ d))
hden :
  camplitude (multiDatum d L (L ^ d)) ^ (d + 1) * cSource (d + 2) (multiDatum d L (L 

$ /bin/bash -lc "nl -ba ENOTV/EvenFailure.lean | sed -n '198,270p'"
198	        cJumpMoment (d + 2) (multiDatum d L (L ^ d)) at hraw
   199	  have hpow :
   200	      (L : ℝ) ^ d * (L : ℝ) ^ (d * (d + 3)) =
   201	        (L : ℝ) ^ (d ^ 2 + 4 * d) := by
   202	    rw [← pow_add]
   203	    congr 1
   204	    ring
   205	  calc
   206	    (c : ℝ) ^ (d + 3) * (M : ℝ) *
   207	          (L : ℝ) ^ (d ^ 2 + 4 * d) =
   208	        ((L ^ d : ℕ) : ℝ) * (M : ℝ) *
   209	          ((c : ℝ) * (L : ℝ) ^ d) ^ (d + 3) := by
   210	      rw [mul_pow, ← pow_mul, ← hpow]
   211	      norm_cast
   212	      ring
   213	    _ ≤ cJumpMoment (d + 2) (multiDatum d L (L ^ d)) := hraw
   214	
   215	theorem not_CCoercive_even_core
   216	    (hFMT : FMTReconstructionTheorem) (d : ℕ)
   217	    (hd : 2 ≤ d) (heven : Even d) :
   218	    ¬ CCoercive (d + 2) := by
   219	  rintro ⟨C, hC, hcoerc⟩
   220	  obtain ⟨b, c₀, hb, hc₀, hlower⟩ := exists_moment_power_lower d
   221	  let D := evenDenominatorConstant d
   222	  obtain ⟨N, hN⟩ := exists_nat_gt (C * D / c₀)
   223	  let M := N + d + 1
   224	  let L := b * M
   225	  have hM : 0 < M := by dsimp [M]; omega
   226	  have hMlarge : d + 1 ≤ M := by dsimp [M]; omega
   227	  have hb1 : 1 ≤ b := by omega
   228	  have hL : d + 1 ≤ L := by
   229	    dsimp [L]
   230	    exact hMlarge.trans (by simpa using Nat.mul_le_mul_right M hb1)
   231	  have hconst : C * D < c₀ * (M : ℝ) := by
   232	    have hNM : (N : ℝ) ≤ (M : ℝ) := by
   233	      exact_mod_cast (show N ≤ M by dsimp [M]; omega)
   234	    have hdiv : C * D / c₀ < (M : ℝ) := hN.trans_le hNM
   235	    have := (div_lt_iff₀ hc₀).mp hdiv
   236	    nlinarith
   237	  have hbulk := hlower M hM
   238	  dsimp only at hbulk
   239	  change c₀ * (M : ℝ) * (L : ℝ) ^ (d ^ 2 + 4 * d) ≤
   240	      cJumpMoment (d + 2) (multiDatum d L (L ^ d)) at hbulk
   241	  have hden := amplitude_source_power_upper hFMT hd heven hL
   242	  change camplitude (multiDatum d L (L ^ d)) ^ (d + 1) *
   243	      cSource (d + 2) (multiDatum d L (L ^ d)) ≤
   244	        D * (L : ℝ

$ /bin/bash -lc 'lake env lean ENOTV/EvenFailure.lean'

$ /bin/bash -lc 'rg -i -n "landau.kolmogorov|kolmogorov.*inequal|gagliardo.*nirenberg|interpolation inequality" Mathlib | head -100'
Mathlib/Analysis/FunctionalSpaces/SobolevInequality.lean:15:# Gagliardo-Nirenberg-Sobolev inequality
Mathlib/Analysis/FunctionalSpaces/SobolevInequality.lean:17:In this file we prove the Gagliardo-Nirenberg-Sobolev inequality.
Mathlib/Analysis/FunctionalSpaces/SobolevInequality.lean:108:/-- The main inductive step in the grid-lines lemma for the Gagliardo-Nirenberg-Sobolev inequality.
Mathlib/Analysis/FunctionalSpaces/SobolevInequality.lean:293:/-! ## The Gagliardo-Nirenberg-Sobolev inequality -/
Mathlib/Analysis/FunctionalSpaces/SobolevInequality.lean:297:/-- The **Gagliardo-Nirenberg-Sobolev inequality**.  Let `u` be a continuously differentiable
Mathlib/Analysis/FunctionalSpaces/SobolevInequality.lean:369:/-- The **Gagliardo-Nirenberg-Sobolev inequality**.  Let `u` be a continuously differentiable
Mathlib/Analysis/FunctionalSpaces/SobolevInequality.lean:438:/-- The **Gagliardo-Nirenberg-Sobolev inequality**.  Let `u` be a continuously differentiable
Mathlib/Analysis/FunctionalSpaces/SobolevInequality.lean:461:/-- The **Gagliardo-Nirenberg-Sobolev inequality**.  Let `u` be a continuously differentiable
Mathlib/Analysis/FunctionalSpaces/SobolevInequality.lean:592:/-- The **Gagliardo-Nirenberg-Sobolev inequality**.  Let `u` be a continuously differentiable
Mathlib/Analysis/FunctionalSpaces/SobolevInequality.lean:648:/-- The **Gagliardo-Nirenberg-Sobolev inequality**.  Let `u` be a continuously differentiable
Mathlib/Analysis/FunctionalSpaces/SobolevInequality.lean:699:/-- The **Gagliardo-Nirenberg-Sobolev inequality**.  Let `u` be a continuously differentiable

$ /bin/bash -lc 'lake env lean ENOTV/Positive.lean'

$ /bin/bash -lc 'lake build ENOTV.Positive ENOTV.EvenFailure && lake env lean ENOTV/Main.lean'
⚠ [8679/8690] Replayed ENOTV.Energy
warning: ENOTV/Energy.lean:158:24: Used `tac1 <;> tac2` where `(tac1; tac2)` would suffice

Note: This linter can be disabled with `set_option linter.unnecessarySeqFocus false`
⚠ [8680/8690] Replayed ENOTV.Localization
info: ENOTV/Localization.lean:90:67: Try this:
  [apply] ring_nf
  
  The `ring` tactic failed to close the goal. Use `ring_nf` to obtain a normal form.
    
  Note that `ring` works primarily in *commutative* rings. If you have a noncommutative ring, abelian group or module, consider using `noncomm_ring`, `abel` or `module` instead.
warning: ENOTV/Localization.lean:74:5: Variable name `hM` is not explicitly referenced.

Hint: The binding can be removed (if unused) or named `_` (if used implicitly). Alternatively, prefix the name with `_` to silence this warning:
  [apply] _hM

Note: This linter can be disabled with `set_option linter.unusedVariables false`
warning: ENOTV/Localization.lean:90:49: Used `tac1 <;> tac2` where `(tac1; tac2)` would suffice

Note: This linter can be disabled with `set_option linter.unnecessarySeqFocus false`
warning: ENOTV/Localization.lean:90:63: Used `tac1 <;> tac2` where `(tac1; tac2)` would suffice

Note: This linter can be disabled with `set_option linter.unnecessarySeqFocus false`
info: ENOTV/Localization.lean:106:74: Try this:
  [apply] ring_nf
  
  The `ring` tactic failed to close the goal. Use `ring_nf` to obtain a normal form.
    
  Note that `ring` works primarily in *commutative* rings. If you have a noncommutative ring, abelian group or module, consider using `noncomm_ring`, `abel` or `module` instead.
warning: ENOTV/Localization.lean:106:56: Used `tac1 <;> tac2` where `(tac1; tac2)` would suffice

Note: This linter can be disabled with `set_option linter.unnecessarySeqFocus false`
warning: ENOTV/Localization.lean:106:70: Used `tac1 <;> tac2` where `(tac1; tac2)` would suffice

Note: This linter can be disabled with `set_option linter.unnecessarySeqFocus false`
info: ENOTV/

$ /bin/bash -lc 'rg -n "equiv.*finite.*support|ofSupportFinite|Finsupp.*support.*Finite|finsuppOf" Mathlib/Data/Finsupp Mathlib | head -100'
Mathlib/Data/Finsupp/Defs.lean:274:noncomputable def ofSupportFinite (f : α → M) (hf : (Function.support f).Finite) : α →₀ M where
Mathlib/Data/Finsupp/Defs.lean:279:theorem ofSupportFinite_coe {f : α → M} {hf : (Function.support f).Finite} :
Mathlib/Data/Finsupp/Defs.lean:280:    (ofSupportFinite f hf : α → M) = f :=
Mathlib/Data/Finsupp/Defs.lean:283:theorem ofSupportFinite_support {f : α → M} (hf : f.support.Finite) :
Mathlib/Data/Finsupp/Defs.lean:284:    (ofSupportFinite f hf).support = hf.toFinset := by
Mathlib/Data/Finsupp/Defs.lean:285:  ext; simp [ofSupportFinite_coe]
Mathlib/Data/Finsupp/Defs.lean:288:  prf f hf := ⟨ofSupportFinite f hf, rfl⟩
Mathlib/Data/Finsupp/Pointwise.lean:108:  smul f g := Finsupp.ofSupportFinite (fun a ↦ f a • g a) (pointwise_smul_support_finite ..)
Mathlib/RingTheory/MvPowerSeries/Evaluation.lean:176:  let n₀ : σ →₀ ℕ := .ofSupportFinite n hn
Mathlib/LinearAlgebra/Finsupp/LSum.lean:180:/-- An equivalence of domains induces a linear equivalence of finitely supported functions.
Mathlib/RingTheory/MvPolynomial/WeightedHomogeneous.lean:667:    simp only [DFinsupp.mem_support_toFun, ne_eq, Set.Finite.mem_toFinset, Function.mem_support,
Mathlib/Algebra/BigOperators/Finsupp/Fin.lean:36:theorem ofSupportFinite_fin_two_eq (n : Fin 2 →₀ ℕ) :
Mathlib/Algebra/BigOperators/Finsupp/Fin.lean:37:    ofSupportFinite ![n 0, n 1] (Set.toFinite _) = n := by
Mathlib/Algebra/DirectSum/Finsupp.lean:14:1. The linear equivalence between finitely supported functions `ι →₀ M` and
Mathlib/Algebra/MvPolynomial/Coeff.lean:89:  rw [← ofSupportFinite_coe (f := a) (hf := Set.toFinite _),
Mathlib/Topology/LocallyFinsupp.lean:644:    {F : Function.locallyFinsuppWithin U Y} (h : F.support.Finite) :
Mathlib/Algebra/SkewMonoidAlgebra/Lift.lean:156:/-- An equivalence of domains induces a linear equivalence of finitely supported functions.
Mathlib/Algebra/Polynomial/Eval/Coeff.lean:98:      fun p ↦ ⟨.ofFinsupp <| .ofCoeff <| .ofSupportFinite (fun n i ↦ coeff (p i) n) <|

$ /bin/bash -lc "cat >/tmp/Check.lean <<'EOF'
import Mathlib
#check csSup_le
#check le_csSup
#check csSup_of_not_bddAbove
EOF
lake env lean /tmp/Check.lean"
csSup_le.{u_1} {α : Type u_1} [ConditionallyCompleteLattice α] {s : Set α} {a : α} (h₁ : s.Nonempty)
  (h₂ : ∀ b ∈ s, b ≤ a) : sSup s ≤ a
le_csSup.{u_1} {α : Type u_1} [ConditionallyCompleteLattice α] {s : Set α} {a : α} (h₁ : BddAbove s) (h₂ : a ∈ s) :
  a ≤ sSup s
csSup_of_not_bddAbove.{u_1} {α : Type u_1} [ConditionallyCompleteLinearOrder α] {s : Set α} (hs : ¬BddAbove s) :
  sSup s = sSup ∅

$ /bin/bash -lc 'lake build ENOTV.Main && lake env lean ENOTV/Representation.lean'
⚠ [8679/8691] Replayed ENOTV.Energy
warning: ENOTV/Energy.lean:158:24: Used `tac1 <;> tac2` where `(tac1; tac2)` would suffice

Note: This linter can be disabled with `set_option linter.unnecessarySeqFocus false`
⚠ [8680/8691] Replayed ENOTV.Localization
info: ENOTV/Localization.lean:90:67: Try this:
  [apply] ring_nf
  
  The `ring` tactic failed to close the goal. Use `ring_nf` to obtain a normal form.
    
  Note that `ring` works primarily in *commutative* rings. If you have a noncommutative ring, abelian group or module, consider using `noncomm_ring`, `abel` or `module` instead.
warning: ENOTV/Localization.lean:74:5: Variable name `hM` is not explicitly referenced.

Hint: The binding can be removed (if unused) or named `_` (if used implicitly). Alternatively, prefix the name with `_` to silence this warning:
  [apply] _hM

Note: This linter can be disabled with `set_option linter.unusedVariables false`
warning: ENOTV/Localization.lean:90:49: Used `tac1 <;> tac2` where `(tac1; tac2)` would suffice

Note: This linter can be disabled with `set_option linter.unnecessarySeqFocus false`
warning: ENOTV/Localization.lean:90:63: Used `tac1 <;> tac2` where `(tac1; tac2)` would suffice

Note: This linter can be disabled with `set_option linter.unnecessarySeqFocus false`
info: ENOTV/Localization.lean:106:74: Try this:
  [apply] ring_nf
  
  The `ring` tactic failed to close the goal. Use `ring_nf` to obtain a normal form.
    
  Note that `ring` works primarily in *commutative* rings. If you have a noncommutative ring, abelian group or module, consider using `noncomm_ring`, `abel` or `module` instead.
warning: ENOTV/Localization.lean:106:56: Used `tac1 <;> tac2` where `(tac1; tac2)` would suffice

Note: This linter can be disabled with `set_option linter.unnecessarySeqFocus false`
warning: ENOTV/Localization.lean:106:70: Used `tac1 <;> tac2` where `(tac1; tac2)` would suffice

Note: This linter can be disabled with `set_option linter.unnecessarySeqFocus false`
info: ENOTV/

$ /bin/bash -lc 'lake env lean ENOTV/Representation.lean'
ENOTV/Representation.lean:16:2: error: Type mismatch: After simplification, term
  Finset.finite_toSet u.support
 has type
  True
but is expected to have type
  {x | ¬u x = 0}.Finite
ENOTV/Representation.lean:43:8: warning: This simp argument is unused:
  jumpMoment

Hint: Omit it from the simp argument list.
  [apply] simp [jumps, diff, cdiff_apply]

Note: This linter can be disabled with `set_option linter.unusedSimpArgs false`

$ /bin/bash -lc "sed -n '1,220p' ENOTV/Representation.lean && sed -n '1,180p' ENOTV/Basic.lean && sed -n '1,120p' ENOTV/Compact.lean"
import ENOTV.Main

/-!
# Equivalence with the paper's function formulation

The development uses `ℤ →₀ ℝ` so that every sum is manifestly finite.
This file proves that this is exactly the paper's class of compactly
supported functions and that all three quantities in coercivity agree.
-/

noncomputable section

namespace ENOTV

theorem finiteSupport_coe (u : CSeq) : FiniteSupport (u : Seq) := by
  simpa [FiniteSupport, Function.support] using u.support.finite_toSet

theorem amplitude_coe (u : CSeq) :
    amplitude (u : Seq) = camplitude u := by
  have hbdd : BddAbove (Set.range fun i : ℤ => |u i|) :=
    ⟨camplitude u, by
      rintro x ⟨i, rfl⟩
      exact abs_le_camplitude u i⟩
  apply le_antisymm
  · apply csSup_le
    · exact Set.range_nonempty _
    · rintro x ⟨i, rfl⟩
      exact abs_le_camplitude u i
  · unfold camplitude
    apply Finset.max'_le
    intro x hx
    simp only [Finset.mem_insert, Finset.mem_image] at hx
    rcases hx with rfl | ⟨i, hi, rfl⟩
    · exact (abs_nonneg (u 0)).trans
        (le_csSup hbdd ⟨0, rfl⟩)
    · exact le_csSup hbdd ⟨i, rfl⟩

theorem jumpMoment_coe (k : ℕ) (u : CSeq) :
    jumpMoment k (u : Seq) = cJumpMoment k u := by
  rw [cJumpMoment_eq_powerSum, powerSum_eq_tsum]
  apply tsum_congr
  intro i
  simp [jumpMoment, jumps, diff, cdiff_apply]

theorem source_coe (k : ℕ) (u : CSeq) :
    source k (u : Seq) = cSource k u := by
  rw [cSource_eq_tsum]
  unfold source
  apply tsum_congr
  intro i
  simp [jumps, diff, cdiff_apply]

/-- `CSeq` coercivity is propositionally equivalent to the paper's
compact-support function statement. -/
theorem coercive_iff_CCoercive (k : ℕ) :
    Coercive k ↔ CCoercive k := by
  constructor
  · rintro ⟨C, hC, h⟩
    refine ⟨C, hC, ?_⟩
    intro u
    have hu := h (u : Seq) (finiteSupport_coe u)
    simpa [jumpMoment_coe, amplitude_coe, source_coe] using hu
  · rintro ⟨C, hC, h⟩
    refine ⟨C, hC, ?_⟩
    intro u hu
    let f : CSeq := Finsupp.ofSupportFinite u hu
    have hf : (f : Seq) = u := Finsup

$ /bin/bash -lc 'lake env lean ENOTV/Representation.lean'
ENOTV/Representation.lean:45:8: warning: This simp argument is unused:
  jumpMoment

Hint: Omit it from the simp argument list.
  [apply] simp [jumps, diff, cdiff_apply]

Note: This linter can be disabled with `set_option linter.unusedSimpArgs false`

$ /bin/bash -lc "rg --files ENOTV | sort && wc -l ENOTV/*.lean && rg -n '\\bsorry\\b|\\badmit\\b|axiom|unsafe' ENOTV lakefile.lean || true && git status --short"
ENOTV/Basic.lean
ENOTV/Bulk.lean
ENOTV/Compact.lean
ENOTV/Counterexample.lean
ENOTV/Endpoint.lean
ENOTV/Energy.lean
ENOTV/Estimates.lean
ENOTV/Euler.lean
ENOTV/EvenEnergy.lean
ENOTV/EvenFailure.lean
ENOTV/Junction.lean
ENOTV/Localization.lean
ENOTV/Main.lean
ENOTV/Positive.lean
ENOTV/Representation.lean
ENOTV/SourceComparison.lean
   156 ENOTV/Basic.lean
   281 ENOTV/Bulk.lean
    91 ENOTV/Compact.lean
   434 ENOTV/Counterexample.lean
   114 ENOTV/Endpoint.lean
   213 ENOTV/Energy.lean
   175 ENOTV/Estimates.lean
   175 ENOTV/Euler.lean
   923 ENOTV/EvenEnergy.lean
   285 ENOTV/EvenFailure.lean
    92 ENOTV/Junction.lean
   505 ENOTV/Localization.lean
    49 ENOTV/Main.lean
    89 ENOTV/Positive.lean
    85 ENOTV/Representation.lean
   337 ENOTV/SourceComparison.lean
  4004 total
ENOTV/Positive.lean:8:hypothesis rather than hiding it as an axiom.  The ENO-specific source
ENOTV/Euler.lean:9:polynomials, so no existence axiom is hidden in the construction.
ENOTV/Localization.lean:48:This proposition is not an axiom.  Results which use it take a value of
 M lakefile.lean
?? ENOTV/

$ /bin/bash -lc "sed -n '1,180p' ENOTV/Main.lean && sed -n '1,180p' ENOTV/Positive.lean && sed -n '1,150p' ENOTV/Localization.lean && rg -n \"Theorem 1|Theorem 2|main theorem|conjecture|coerciv|Gagliardo|Proposition 2.2|second.order|Second-order\" ../paper.txt | head -80"
import ENOTV.Positive
import ENOTV.EvenFailure

/-!
# The ENO--TV parity dichotomy

The theorem below is the paper's central result on the uniform grid.
Its hypotheses name exactly the three earlier results the development
imports: the FMT reconstruction/sign theorem, the standard all-order
discrete Gagliardo--Nirenberg inequality, and the previously established
second-order ENO--TV estimate.
-/

noncomputable section

namespace ENOTV

/-- The previously established second-order ENO--TV estimate, which the
paper cites and explicitly does not reprove. -/
def SecondOrderENOCoercivity : Prop := CCoercive 2

/-- Complete parity classification in the compact-sequence formulation. -/
theorem eno_tv_parity_dichotomy
    (hFMT : FMTReconstructionTheorem)
    (hGN : DiscreteGagliardoNirenberg)
    (hSecond : SecondOrderENOCoercivity) :
    ∀ k : ℕ, 2 ≤ k →
      (CCoercive k ↔ k = 2 ∨ Odd k) := by
  intro k hk
  constructor
  · intro hco
    by_cases hk2 : k = 2
    · exact Or.inl hk2
    · right
      rcases Nat.even_or_odd k with heven | hodd
      · have hk4 : 4 ≤ k := by
          obtain ⟨q, hq⟩ := heven
          omega
        exact (not_CCoercive_even hFMT hk4 heven hco).elim
      · exact hodd
  · rintro (rfl | hodd)
    · exact hSecond
    · obtain ⟨q, hq⟩ := hodd
      have hq1 : 1 ≤ q := by omega
      have hform : k = 2 * (q + 1) - 1 := by omega
      rw [hform]
      exact odd_coercive hFMT hGN (q + 1) (by omega)

end ENOTV
import ENOTV.SourceComparison

/-!
# Odd-order coercivity from the two analytic interfaces

The only standard analytic result absent from mathlib is the all-order
discrete Gagliardo--Nirenberg inequality.  We expose it as a named
hypothesis rather than hiding it as an axiom.  The ENO-specific source
localization interface is kept separate.
-/

noncomputable section

namespace ENOTV

/-- Standard discrete Gagliardo--Nirenberg inequality used in the paper. -/
def DiscreteGagliardoNirenberg : Prop :=
  ∀ m : ℕ, 2 ≤ m →
    ∃ C : ℝ, 0 ≤ C ∧ ∀ v : 

$ /bin/bash -lc "sed -n '273,365p' ../paper.txt; sed -n '1080,1135p' ../paper.txt; sed -n '1520,1705p' ../paper.txt; sed -n '2280,2360p' ../paper.txt"
1.1. Uniform-grid coercivity. Throughout the uniform-grid statements,
ENO reconstruction means the standard recursion fixed in Section 2; all
cell-average sequences are compactly supported. We write
U := ∥ū∥ℓ∞ .
Constants never depend on U , on the size of the support, or on the selected
stencils.
Theorem A (Parity classification on the uniform grid). For each integer
k ≥ 2, the estimate (1.4) holds for every compactly supported sequence of cell
averages on the unit grid if and only if k = 2 or k is odd. More precisely, for
every odd k ≥ 3,
X
(1.6)
|ai |k+1 ≤ Ck U k−1 Qk (ū),
i

whereas for every even k ≥ 4 no constant Ck makes (1.4) valid for all such
data. Indeed, there are compactly supported sequences ū(L) , with a(L) := Dū(L)

6

Z. LI AND K. WU

and UL := ∥ū(L) ∥ℓ∞ > 0, such that
X (L)
|ai |k+1
i
−→ ∞.
k−1
UL Qk (ū(L) )

(1.7)

The counterexamples can be chosen so that every ENO comparison affected
by their jump support is strict. The selected stencil pattern is then unchanged
under sufficiently small perturbations. For every C > 0, the quotient in
(1.7) exceeds C on a nonempty relatively open subset of a finite-dimensional
space of compactly supported data. Thus the even-order obstruction persists
where the stencil pattern is locally constant. The precise statement is given
in Proposition 4.9.
Even when the full estimate fails, two quantitative bounds remain. Put r =
k − 1, and let Pk−2 denote the restrictions to {−r, . . . , r} of real polynomials
of degree at most k − 2. For the centered jump block
ai = (ai−r , . . . , ai+r ),
define
(1.8)

ρi :=

inf

P ∈Pk−2

r
X

!1/2
2

|ai+ℓ − P (ℓ)|

.

ℓ=−r

Thus ρi is the Euclidean distance from the local jump block to the sampled
polynomial subspace; the fitting polynomial may depend on i.
Theorem B (Large-jump and quotient coercivity). For every k ≥ 2, every
ε > 0, and every compactly supported sequence of cell averages on the unit
grid,
X
(1.9)
|ai |k+1 ≤ Ck,ε U k−1 Qk (ū),
|ai |>εU

and
X

(1.10)

ρk+1
≤

$ /bin/bash -lc "sed -n '1,360p' ENOTV/EvenFailure.lean; sed -n '1,220p' ENOTV/EvenEnergy.lean"
import ENOTV.EvenEnergy

/-!
# Failure of coercivity in every even order at least four

The local estimates are reduced here to the scale calculation in the
paper.  We use `P=L^d` positive/negative block pairs; this differs from the
paper's notation only by counting pairs rather than individual blocks.
-/

noncomputable section

namespace ENOTV

def evenEnergyConstant (d : ℕ) : ℝ :=
  2 * (d + 1) *
    ((endpointUpper d (d + 1) : ℝ) * (junctionUpper d : ℝ) +
      2 ^ (d + 1) * (endpointUpper d (d + 1) : ℝ) ^ 2)

theorem evenEnergyConstant_nonneg (d : ℕ) :
    0 ≤ evenEnergyConstant d := by
  unfold evenEnergyConstant
  have hE : 0 ≤ (endpointUpper d (d + 1) : ℝ) := by
    exact_mod_cast endpointUpper_nonneg d (d + 1)
  have hJ : 0 ≤ (junctionUpper d : ℝ) := by
    exact_mod_cast junctionUpper_nonneg d
  positivity

theorem cEnergy_power_pairs_upper {d L : ℕ}
    (hd : 2 ≤ d) (heven : Even d) (hL : d + 1 ≤ L) :
    cEnergy (d + 2) (multiJumps d L (L ^ d)) ≤
      evenEnergyConstant d * (L : ℝ) ^ (2 * d - 1) := by
  have hLpos : 0 < L := by omega
  have hP : 0 < L ^ d := pow_pos hLpos _
  have hraw := cEnergy_multiJumps_upper (d := d) (L := L) (P := L ^ d)
    (by omega) heven hL hP
  let E : ℝ := (endpointUpper d (d + 1) : ℝ)
  let J : ℝ := (junctionUpper d : ℝ)
  have hE : 0 ≤ E := by
    dsimp [E]
    exact_mod_cast endpointUpper_nonneg d (d + 1)
  have hJ : 0 ≤ J := by
    dsimp [J]
    exact_mod_cast junctionUpper_nonneg d
  have hL1 : (1 : ℝ) ≤ L := by exact_mod_cast (show 1 ≤ L by omega)
  have hpow₁ :
      (L : ℝ) ^ d * (L : ℝ) ^ (d - 1) =
        (L : ℝ) ^ (2 * d - 1) := by
    rw [← pow_add]
    congr 1
    omega
  have hpow₂ :
      (L : ℝ) ^ (d - 1) * (L : ℝ) ^ (d - 1) =
        (L : ℝ) ^ (2 * d - 2) := by
    rw [← pow_add]
    congr 1
    omega
  have hpowmono :
      (L : ℝ) ^ (2 * d - 2) ≤ (L : ℝ) ^ (2 * d - 1) := by
    exact pow_le_pow_right₀ hL1 (by omega)
  have hPcast : ((L ^ d : ℕ) : ℝ) = (L : ℝ) ^ d := by norm_num
  have hsub :
      (((2 * (L

$ /bin/bash -lc 'rg -ni "gagliardo|nirenberg|sobolev.*interpol|interpolation.*sobolev|B.?spline|cardinal spline|finite.*difference.*norm|norm.*fwdDiff" Mathlib | head -200'

$ /bin/bash -lc "sed -n '285,760p' Mathlib/Analysis/FunctionalSpaces/SobolevInequality.lean | rg -n \"theorem|def|Gagliardo|HasCompactSupport|ContDiff\" | head -100; sed -n '285,335p' Mathlib/Analysis/FunctionalSpaces/SobolevInequality.lean; sed -n '680,740p' Mathlib/Analysis/FunctionalSpaces/SobolevInequality.lean"
9:/-! ## The Gagliardo-Nirenberg-Sobolev inequality -/
13:/-- The **Gagliardo-Nirenberg-Sobolev inequality**.  Let `u` be a continuously differentiable
20:theorem lintegral_pow_le_pow_lintegral_fderiv_aux [Fintype ι]
22:    {u : (ι → ℝ) → F} (hu : ContDiff ℝ 1 u)
23:    (h2u : HasCompactSupport u) :
27:  `|f(t)| = `|∫_{-∞}^t Df(s)∂s| ≤ ∫_ℝ |Df(s)| ∂s` where we use the fundamental theorem of calculus.
51:  -- we estimate |u x| using the fundamental theorem of calculus.
55:        apply le_trans (by simp) (HasCompactSupport.enorm_le_lintegral_Ici_deriv _ _ _)
77:irreducible_def lintegralPowLePowLIntegralFDerivConst (p : ℝ) : ℝ≥0 := by
85:/-- The **Gagliardo-Nirenberg-Sobolev inequality**.  Let `u` be a continuously differentiable
90:theorem lintegral_pow_le_pow_lintegral_fderiv {u : E → F}
91:    (hu : ContDiff ℝ 1 u) (h2u : HasCompactSupport u)
115:  simp only [h2c, ENNReal.smul_def, lintegral_smul_measure, smul_eq_mul]
117:  have hv : ContDiff ℝ 1 v := hu.comp e.symm.contDiff
118:  have h2v : HasCompactSupport v := h2u.comp_homeomorph e.symm.toHomeomorph
151:irreducible_def eLpNormLESNormFDerivOneConst (p : ℝ) : ℝ≥0 :=
154:/-- The **Gagliardo-Nirenberg-Sobolev inequality**.  Let `u` be a continuously differentiable
158:theorem eLpNorm_le_eLpNorm_fderiv_one {u : E → F} (hu : ContDiff ℝ 1 u) (h2u : HasCompactSupport u)
171:def eLpNormLESNormFDerivOfEqInnerConst (p : ℝ) : ℝ≥0 :=
177:/-- The **Gagliardo-Nirenberg-Sobolev inequality**.  Let `u` be a continuously differentiable
185:theorem eLpNorm_le_eLpNorm_fderiv_of_eq_inner {u : E → F'}
186:    (hu : ContDiff ℝ 1 u) (h2u : HasCompactSupport u)
255:  have hv : ContDiff ℝ 1 v := hu.norm_rpow h1γ
256:  have h2v : HasCompactSupport v := h2u.norm.rpow_const h4γ
303:irreducible_def SNormLESNormFDerivOfEqConst [FiniteDimensional ℝ F] (p : ℝ) : ℝ≥0 :=
308:/-- The **Gagliardo-Nirenberg-Sobolev inequality**.  Let `u` be a continuously differentiable
316:theorem eLpNorm_le_eLpNorm_fderiv_of_eq [FiniteDimensional ℝ F]
317:    {u :

$ /bin/bash -lc 'lake build ENOTV'
⚠ [8679/8694] Replayed ENOTV.Energy
warning: ENOTV/Energy.lean:158:24: Used `tac1 <;> tac2` where `(tac1; tac2)` would suffice

Note: This linter can be disabled with `set_option linter.unnecessarySeqFocus false`
⚠ [8680/8694] Replayed ENOTV.Euler
info: ENOTV/Euler.lean:31:2: Try this:
  [apply] ring_nf
  
  The `ring` tactic failed to close the goal. Use `ring_nf` to obtain a normal form.
    
  Note that `ring` works primarily in *commutative* rings. If you have a noncommutative ring, abelian group or module, consider using `noncomm_ring`, `abel` or `module` instead.
warning: ENOTV/Euler.lean:124:15: Used `tac1 <;> tac2` where `(tac1; tac2)` would suffice

Note: This linter can be disabled with `set_option linter.unnecessarySeqFocus false`
warning: ENOTV/Euler.lean:123:4: 'congr 2' tactic does nothing

Note: This linter can be disabled with `set_option linter.unusedTactic false`
warning: ENOTV/Euler.lean:163:6: Used `tac1 <;> tac2` where `(tac1; tac2)` would suffice

Note: This linter can be disabled with `set_option linter.unnecessarySeqFocus false`
⚠ [8681/8694] Replayed ENOTV.Counterexample
warning: ENOTV/Counterexample.lean:111:53: This simp argument is unused:
  h2

Hint: Omit it from the simp argument list.
  [apply] simp [pairDatumNat_apply, pairJumpNat_apply, h4, blockPrefix_succ]

Note: This linter can be disabled with `set_option linter.unusedSimpArgs false`
warning: ENOTV/Counterexample.lean:134:59: This simp argument is unused:
  h₄

Hint: Omit it from the simp argument list.
  [apply] simp [pairDatumNat_apply, pairJumpNat_apply, h₁, h42, h412, h414, hsub]

Note: This linter can be disabled with `set_option linter.unusedSimpArgs false`
warning: ENOTV/Counterexample.lean:356:4: `push_neg` has been deprecated. Prefer using `push Not` instead.
If you'd rather continue using `push_neg` in your project, you can implement it as follows:
```
open Lean.Parser.Tactic in
macro "push_neg" cfg:optConfig loc:(location)? : tactic =>
  `(tactic| push $cfg:optConfig N

$ /bin/bash -lc 'lake env lean ENOTV/Representation.lean'
ENOTV/Representation.lean:79:35: error(lean.unknownIdentifier): Unknown identifier `literalSource`
ENOTV/Representation.lean:85:11: error(lean.unknownIdentifier): Unknown identifier `literalSource_eq_cSource`

$ /bin/bash -lc 'lake build ENOTV.Representation'
⚠ [8679/8692] Replayed ENOTV.Energy
warning: ENOTV/Energy.lean:158:24: Used `tac1 <;> tac2` where `(tac1; tac2)` would suffice

Note: This linter can be disabled with `set_option linter.unnecessarySeqFocus false`
⚠ [8680/8692] Replayed ENOTV.Euler
info: ENOTV/Euler.lean:31:2: Try this:
  [apply] ring_nf
  
  The `ring` tactic failed to close the goal. Use `ring_nf` to obtain a normal form.
    
  Note that `ring` works primarily in *commutative* rings. If you have a noncommutative ring, abelian group or module, consider using `noncomm_ring`, `abel` or `module` instead.
warning: ENOTV/Euler.lean:124:15: Used `tac1 <;> tac2` where `(tac1; tac2)` would suffice

Note: This linter can be disabled with `set_option linter.unnecessarySeqFocus false`
warning: ENOTV/Euler.lean:123:4: 'congr 2' tactic does nothing

Note: This linter can be disabled with `set_option linter.unusedTactic false`
warning: ENOTV/Euler.lean:163:6: Used `tac1 <;> tac2` where `(tac1; tac2)` would suffice

Note: This linter can be disabled with `set_option linter.unnecessarySeqFocus false`
⚠ [8681/8692] Replayed ENOTV.Counterexample
warning: ENOTV/Counterexample.lean:111:53: This simp argument is unused:
  h2

Hint: Omit it from the simp argument list.
  [apply] simp [pairDatumNat_apply, pairJumpNat_apply, h4, blockPrefix_succ]

Note: This linter can be disabled with `set_option linter.unusedSimpArgs false`
warning: ENOTV/Counterexample.lean:134:59: This simp argument is unused:
  h₄

Hint: Omit it from the simp argument list.
  [apply] simp [pairDatumNat_apply, pairJumpNat_apply, h₁, h42, h412, h414, hsub]

Note: This linter can be disabled with `set_option linter.unusedSimpArgs false`
warning: ENOTV/Counterexample.lean:356:4: `push_neg` has been deprecated. Prefer using `push Not` instead.
If you'd rather continue using `push_neg` in your project, you can implement it as follows:
```
open Lean.Parser.Tactic in
macro "push_neg" cfg:optConfig loc:(location)? : tactic =>
  `(tactic| push $cfg:optConfig N

$ /bin/bash -lc 'lake env lean ENOTV/Representation.lean && lake env lean ENOTV/Audit.lean'
'ENOTV.eno_tv_parity_dichotomy' depends on axioms: [propext, Classical.choice, Quot.sound]
'ENOTV.eno_tv_parity_dichotomy_paper' depends on axioms: [propext, Classical.choice, Quot.sound]
'ENOTV.eno_tv_parity_dichotomy_literal' depends on axioms: [propext, Classical.choice, Quot.sound]

$ /bin/bash -lc "lake build ENOTV && rg -n '\\bsorry\\b|\\badmit\\b|"'^'"\\s*axiom\\b|\\bunsafe\\b' ENOTV README.md lakefile.lean || true"
⚠ [8679/8694] Replayed ENOTV.Energy
warning: ENOTV/Energy.lean:158:24: Used `tac1 <;> tac2` where `(tac1; tac2)` would suffice

Note: This linter can be disabled with `set_option linter.unnecessarySeqFocus false`
⚠ [8680/8694] Replayed ENOTV.Euler
info: ENOTV/Euler.lean:31:2: Try this:
  [apply] ring_nf
  
  The `ring` tactic failed to close the goal. Use `ring_nf` to obtain a normal form.
    
  Note that `ring` works primarily in *commutative* rings. If you have a noncommutative ring, abelian group or module, consider using `noncomm_ring`, `abel` or `module` instead.
warning: ENOTV/Euler.lean:124:15: Used `tac1 <;> tac2` where `(tac1; tac2)` would suffice

Note: This linter can be disabled with `set_option linter.unnecessarySeqFocus false`
warning: ENOTV/Euler.lean:123:4: 'congr 2' tactic does nothing

Note: This linter can be disabled with `set_option linter.unusedTactic false`
warning: ENOTV/Euler.lean:163:6: Used `tac1 <;> tac2` where `(tac1; tac2)` would suffice

Note: This linter can be disabled with `set_option linter.unnecessarySeqFocus false`
⚠ [8681/8694] Replayed ENOTV.Counterexample
warning: ENOTV/Counterexample.lean:111:53: This simp argument is unused:
  h2

Hint: Omit it from the simp argument list.
  [apply] simp [pairDatumNat_apply, pairJumpNat_apply, h4, blockPrefix_succ]

Note: This linter can be disabled with `set_option linter.unusedSimpArgs false`
warning: ENOTV/Counterexample.lean:134:59: This simp argument is unused:
  h₄

Hint: Omit it from the simp argument list.
  [apply] simp [pairDatumNat_apply, pairJumpNat_apply, h₁, h42, h412, h414, hsub]

Note: This linter can be disabled with `set_option linter.unusedSimpArgs false`
warning: ENOTV/Counterexample.lean:356:4: `push_neg` has been deprecated. Prefer using `push Not` instead.
If you'd rather continue using `push_neg` in your project, you can implement it as follows:
```
open Lean.Parser.Tactic in
macro "push_neg" cfg:optConfig loc:(location)? : tactic =>
  `(tactic| push $cfg:optConfig N

$ /bin/bash -lc "sed -n '1,22p' ENOTV/Euler.lean; sed -n '1,18p' ENOTV/Positive.lean; sed -n '40,62p' ENOTV/Localization.lean; sed -n '1,18p' ENOTV/Audit.lean; nl -ba ENOTV/Representation.lean | sed -n '70,115p'; nl -ba ENOTV/Main.lean | sed -n '1,60p'"
import ENOTV.Compact
import Mathlib.NumberTheory.BernoulliPolynomials

/-!
# Euler polynomials and the matching identity

The even-order counterexample uses the polynomial `E_d` characterized by
`E_d(x+1)+E_d(x)=2x^d`.  We construct it explicitly from Bernoulli
polynomials, so no existence axiom is hidden in the construction.
-/

noncomputable section

open scoped BigOperators
open Polynomial

namespace ENOTV

/-- The Euler polynomial over `ℚ`, in its Bernoulli-polynomial formula. -/
def eulerPoly (d : ℕ) : ℚ[X] :=
  C ((2 : ℚ) ^ (d + 1) / (d + 1)) *
    ((Polynomial.bernoulli (d + 1)).comp (C (1 / 2 : ℚ) * (X + 1)) -
import ENOTV.SourceComparison

/-!
# Odd-order coercivity from the two analytic interfaces

The only standard analytic result absent from mathlib is the all-order
discrete Gagliardo--Nirenberg inequality.  We expose it as a named
hypothesis rather than hiding it as an axiom.  The ENO-specific source
localization interface is kept separate.
-/

noncomputable section

namespace ENOTV

/-- Standard discrete Gagliardo--Nirenberg inequality used in the paper. -/
def DiscreteGagliardoNirenberg : Prop :=
  ∀ m : ℕ, 2 ≤ m →
reconstruction polynomials. -/
def literalReconstructedJump (k : ℕ) (u : CSeq) (i : ℤ) : ℝ :=
  literalTrace k u (i + 1) - literalTrace k u i

/-- The ENO source written naively from the two Lagrange-reconstructed
interface traces, before applying any localization theorem. -/
def literalSource (k : ℕ) (u : CSeq) : ℝ :=
  (cdiff u).sum fun i ai => ai * literalReconstructedJump k u i

/-- The exact external theorem about classical ENO used by the paper:
the literal cell-average reconstruction equals the localized FMT formula,
and every term in that formula has the sign of the underlying jump.

This proposition is not an axiom.  Results which use it take a value of
this proposition as an explicitly declared hypothesis.
-/
def FMTReconstructionTheorem : Prop :=
  (∀ (k : ℕ), 2 ≤ k → ∀ (u : CSeq) (i : ℤ),
      literalReconstructedJump k u i =
 

$ /bin/bash -lc "rg -n '\\bsorry\\b|\\badmit\\b|"'^'"\\s*axiom\\b|\\bunsafe\\b' ENOTV --glob '*.lean' || true; git diff --stat; git status --short; lake env lean ENOTV/Representation.lean"

$ /bin/bash -lc "git diff -- lakefile.lean | sed -n '1,120p'; git diff -- README.md | sed -n '1,100p'; sed -n '1,80p' lakefile.lean"
diff --git a/lakefile.lean b/lakefile.lean
index bcdf13405f..503a88d9fa 100644
--- a/lakefile.lean
+++ b/lakefile.lean
@@ -86,6 +86,10 @@ lean_lib Archive where
 lean_lib Counterexamples where
   leanOptions := mathlibLeanOptions
 
+/- The self-contained development for this reproduction run. -/
+lean_lib ENOTV where
+  globs := #[`ENOTV.+]
+
 /-- Additional documentation in the form of modules that only contain module docstrings. -/
 lean_lib docs where
   roots := #[`docs]
diff --git a/README.md b/README.md
index 36cbc2334f..2ac7570515 100644
--- a/README.md
+++ b/README.md
@@ -1,168 +1,167 @@
-# mathlib4
+# ENO--TV parity dichotomy: Lean reproduction
 
-![GitHub CI](https://github.com/leanprover-community/mathlib4/actions/workflows/build.yml/badge.svg?branch=master)
-[![Bors enabled](https://raw.githubusercontent.com/bors-ng/bors-ng.github.io/refs/heads/master/images/badge_small.svg)](https://mathlib-bors-ca18eefec4cb.herokuapp.com/repositories/16)
-[![project chat](https://img.shields.io/badge/zulip-join_chat-brightgreen.svg)](https://leanprover.zulipchat.com)
-[![Gitpod Ready-to-Code](https://img.shields.io/badge/Gitpod-ready--to--code-blue?logo=gitpod)](https://gitpod.io/#https://github.com/leanprover-community/mathlib4)
+## Result
 
-[Mathlib](https://leanprover-community.github.io) is a user maintained library for the [Lean theorem prover](https://leanprover.github.io).
-It contains both programming infrastructure and mathematics,
-as well as tactics that use the former and allow to develop the latter.
+The formalization proves the uniform-grid parity classification (Theorem A):
+for every reconstruction order `k ≥ 2`, the ENO--TV coercive estimate holds
+for every compactly supported sequence if and only if `k = 2` or `k` is odd.
 
-## Installation
+The closest literal statement is
+`ENOTV.eno_tv_parity_dichotomy_literal` in
+`ENOTV/Representation.lean`:
 
-You can find detailed instructions to install Lean, mathlib, and supporting tools on [our website](ht