internlm/Lean-Github huggingface dataset:
Theorem: Fin.specSigma
Proof state before:
case right
n : Nat
ih : ∀ (f : Fin n → Nat) (k : Fin (sum f)) (x : (i : Fin n) × Fin (f i)), decodeSigma f k = x ↔ encodeSigma f x = k
f : Fin (n + 1) → Nat
k✝ : Fin (sum f)
x : (i : Fin (n + 1)) × Fin (f i)
k : Nat
hk : k < sum f
i : Nat
hi : i + 1 < n + 1
j : Nat
hj : j < f ⟨i + 1, hi⟩
hge✝ : ¬k < f 0
h :
  ⟨⟨↑(decodeSigma (f ∘ succ) ⟨k - f 0, ⋯⟩).1 + 1, ⋯⟩, (decodeSigma (f ∘ succ) ⟨k - f 0, ⋯⟩).snd⟩ =
    ⟨⟨i + 1, hi⟩, ⟨j, hj⟩⟩
hge : k ≥ f 0
hpos : 0 < sum (f ∘ succ)
hk' : k - f 0 < sum (f ∘ succ)
this : encodeSigma (f ∘ succ) ⟨⟨i, ⋯⟩, ⟨j, hj⟩⟩ = ⟨k - f 0, hk'⟩
⊢ f 0 + ↑⟨k - f 0, hk'⟩ = k
Tactic:
rw [Nat.add_comm, Nat.sub_add_cancel]
Proof state after:
case right
n : Nat
ih : ∀ (f : Fin n → Nat) (k : Fin (sum f)) (x : (i : Fin n) × Fin (f i)), decodeSigma f k = x ↔ encodeSigma f x = k
f : Fin (n + 1) → Nat
k✝ : Fin (sum f)
x : (i : Fin (n + 1)) × Fin (f i)
k : Nat
hk : k < sum f
i : Nat
hi : i + 1 < n + 1
j : Nat
hj : j < f ⟨i + 1, hi⟩
hge✝ : ¬k < f 0
h :
  ⟨⟨↑(decodeSigma (f ∘ succ) ⟨k - f 0, ⋯⟩).1 + 1, ⋯⟩, (decodeSigma (f ∘ succ) ⟨k - f 0, ⋯⟩).snd⟩ =
    ⟨⟨i + 1, hi⟩, ⟨j, hj⟩⟩
hge : k ≥ f 0
hpos : 0 < sum (f ∘ succ)
hk' : k - f 0 < sum (f ∘ succ)
this : encodeSigma (f ∘ succ) ⟨⟨i, ⋯⟩, ⟨j, hj⟩⟩ = ⟨k - f 0, hk'⟩
⊢ f 0 ≤ k
Theorem: Fin.specSigma
Proof state before:
case right
n : Nat
ih : ∀ (f : Fin n → Nat) (k : Fin (sum f)) (x : (i : Fin n) × Fin (f i)), decodeSigma f k = x ↔ encodeSigma f x = k
f : Fin (n + 1) → Nat
k✝ : Fin (sum f)
x : (i : Fin (n + 1)) × Fin (f i)
k : Nat
hk : k < sum f
i : Nat
hi : i + 1 < n + 1
j : Nat
hj : j < f ⟨i + 1, hi⟩
hge✝ : ¬k < f 0
h :
  ⟨⟨↑(decodeSigma (f ∘ succ) ⟨k - f 0, ⋯⟩).1 + 1, ⋯⟩, (decodeSigma (f ∘ succ) ⟨k - f 0, ⋯⟩).snd⟩ =
    ⟨⟨i + 1, hi⟩, ⟨j, hj⟩⟩
hge : k ≥ f 0
hpos : 0 < sum (f ∘ succ)
hk' : k - f 0 < sum (f ∘ succ)
this : encodeSigma (f ∘ succ) ⟨⟨i, ⋯⟩, ⟨j, hj⟩⟩ = ⟨k - f 0, hk'⟩
⊢ f 0 ≤ k
Tactic:
exact hge
Proof state after:
no goals
Theorem: Fin.specSigma
Proof state before:
case mpr
n : Nat
ih : ∀ (f : Fin n → Nat) (k : Fin (sum f)) (x : (i : Fin n) × Fin (f i)), decodeSigma f k = x ↔ encodeSigma f x = k
f : Fin (n + 1) → Nat
k✝ : Fin (sum f)
x : (i : Fin (n + 1)) × Fin (f i)
k : Nat
hk : k < sum f
i : Nat
hi : i + 1 < n + 1
j : Nat
hj : j < f ⟨i + 1, hi⟩
⊢ encodeSigma f ⟨⟨i + 1, hi⟩, ⟨j, hj⟩⟩ = ⟨k, hk⟩ → decodeSigma f ⟨k, hk⟩ = ⟨⟨i + 1, hi⟩, ⟨j, hj⟩⟩
Tactic:
intro h
Proof state after:
case mpr
n : Nat
ih : ∀ (f : Fin n → Nat) (k : Fin (sum f)) (x : (i : Fin n) × Fin (f i)), decodeSigma f k = x ↔ encodeSigma f x = k
f : Fin (n + 1) → Nat
k✝ : Fin (sum f)
x : (i : Fin (n + 1)) × Fin (f i)
k : Nat
hk : k < sum f
i : Nat
hi : i + 1 < n + 1
j : Nat
hj : j < f ⟨i + 1, hi⟩
h : encodeSigma f ⟨⟨i + 1, hi⟩, ⟨j, hj⟩⟩ = ⟨k, hk⟩
⊢ decodeSigma f ⟨k, hk⟩ = ⟨⟨i + 1, hi⟩, ⟨j, hj⟩⟩
Theorem: Fin.specSigma
Proof state before:
case mpr
n : Nat
ih : ∀ (f : Fin n → Nat) (k : Fin (sum f)) (x : (i : Fin n) × Fin (f i)), decodeSigma f k = x ↔ encodeSigma f x = k
f : Fin (n + 1) → Nat
k✝ : Fin (sum f)
x : (i : Fin (n + 1)) × Fin (f i)
k : Nat
hk : k < sum f
i : Nat
hi : i + 1 < n + 1
j : Nat
hj : j < f ⟨i + 1, hi⟩
h : encodeSigma f ⟨⟨i + 1, hi⟩, ⟨j, hj⟩⟩ = ⟨k, hk⟩
⊢ decodeSigma f ⟨k, hk⟩ = ⟨⟨i + 1, hi⟩, ⟨j, hj⟩⟩
Tactic:
simp only [decodeSigma]
Proof state after:
case mpr
n : Nat
ih : ∀ (f : Fin n → Nat) (k : Fin (sum f)) (x : (i : Fin n) × Fin (f i)), decodeSigma f k = x ↔ encodeSigma f x = k
f : Fin (n + 1) → Nat
k✝ : Fin (sum f)
x : (i : Fin (n + 1)) × Fin (f i)
k : Nat
hk : k < sum f
i : Nat
hi : i + 1 < n + 1
j : Nat
hj : j < f ⟨i + 1, hi⟩
h : encodeSigma f ⟨⟨i + 1, hi⟩, ⟨j, hj⟩⟩ = ⟨k, hk⟩
⊢ (if h : k < f 0 then ⟨0, ⟨k, ⋯⟩⟩
    else ⟨⟨↑(decodeSigma (f ∘ succ) ⟨k - f 0, ⋯⟩).1 + 1, ⋯⟩, (decodeSigma (f ∘ succ) ⟨k - f 0, ⋯⟩).snd⟩) =
    ⟨⟨i + 1, hi⟩, ⟨j, hj⟩⟩
Theorem: Fin.specSigma
Proof state before:
case mpr
n : Nat
ih : ∀ (f : Fin n → Nat) (k : Fin (sum f)) (x : (i : Fin n) × Fin (f i)), decodeSigma f k = x ↔ encodeSigma f x = k
f : Fin (n + 1) → Nat
k✝ : Fin (sum f)
x : (i : Fin (n + 1)) × Fin (f i)
k : Nat
hk : k < sum f
i : Nat
hi : i + 1 < n + 1
j : Nat
hj : j < f ⟨i + 1, hi⟩
h : encodeSigma f ⟨⟨i + 1, hi⟩, ⟨j, hj⟩⟩ = ⟨k, hk⟩
⊢ (if h : k < f 0 then ⟨0, ⟨k, ⋯⟩⟩
    else ⟨⟨↑(decodeSigma (f ∘ succ) ⟨k - f 0, ⋯⟩).1 + 1, ⋯⟩, (decodeSigma (f ∘ succ) ⟨k - f 0, ⋯⟩).snd⟩) =
    ⟨⟨i + 1, hi⟩, ⟨j, hj⟩⟩
Tactic:
simp only [encodeSigma] at h
Proof state after:
case mpr
n : Nat
ih : ∀ (f : Fin n → Nat) (k : Fin (sum f)) (x : (i : Fin n) × Fin (f i)), decodeSigma f k = x ↔ encodeSigma f x = k
f : Fin (n + 1) → Nat
k✝ : Fin (sum f)
x : (i : Fin (n + 1)) × Fin (f i)
k : Nat
hk : k < sum f
i : Nat
hi : i + 1 < n + 1
j : Nat
hj : j < f ⟨i + 1, hi⟩
h : ⟨f 0 + ↑(encodeSigma (f ∘ succ) ⟨⟨i, ⋯⟩, ⟨j, hj⟩⟩), ⋯⟩ = ⟨k, hk⟩
⊢ (if h : k < f 0 then ⟨0, ⟨k, ⋯⟩⟩
    else ⟨⟨↑(decodeSigma (f ∘ succ) ⟨k - f 0, ⋯⟩).1 + 1, ⋯⟩, (decodeSigma (f ∘ succ) ⟨k - f 0, ⋯⟩).snd⟩) =
    ⟨⟨i + 1, hi⟩, ⟨j, hj⟩⟩
Theorem: Fin.specSigma
Proof state before:
case mpr
n : Nat
ih : ∀ (f : Fin n → Nat) (k : Fin (sum f)) (x : (i : Fin n) × Fin (f i)), decodeSigma f k = x ↔ encodeSigma f x = k
f : Fin (n + 1) → Nat
k✝ : Fin (sum f)
x : (i : Fin (n + 1)) × Fin (f i)
k : Nat
hk : k < sum f
i : Nat
hi : i + 1 < n + 1
j : Nat
hj : j < f ⟨i + 1, hi⟩
h : ⟨f 0 + ↑(encodeSigma (f ∘ succ) ⟨⟨i, ⋯⟩, ⟨j, hj⟩⟩), ⋯⟩ = ⟨k, hk⟩
⊢ (if h : k < f 0 then ⟨0, ⟨k, ⋯⟩⟩
    else ⟨⟨↑(decodeSigma (f ∘ succ) ⟨k - f 0, ⋯⟩).1 + 1, ⋯⟩, (decodeSigma (f ∘ succ) ⟨k - f 0, ⋯⟩).snd⟩) =
    ⟨⟨i + 1, hi⟩, ⟨j, hj⟩⟩
Tactic:
split
Proof state after:
case mpr.isTrue
n : Nat
ih : ∀ (f : Fin n → Nat) (k : Fin (sum f)) (x : (i : Fin n) × Fin (f i)), decodeSigma f k = x ↔ encodeSigma f x = k
f : Fin (n + 1) → Nat
k✝ : Fin (sum f)
x : (i : Fin (n + 1)) × Fin (f i)
k : Nat
hk : k < sum f
i : Nat
hi : i + 1 < n + 1
j : Nat
hj : j < f ⟨i + 1, hi⟩
h : ⟨f 0 + ↑(encodeSigma (f ∘ succ) ⟨⟨i, ⋯⟩, ⟨j, hj⟩⟩), ⋯⟩ = ⟨k, hk⟩
h✝ : k < f 0
⊢ ⟨0, ⟨k, ⋯⟩⟩ = ⟨⟨i + 1, hi⟩, ⟨j, hj⟩⟩

case mpr.isFalse
n : Nat
ih : ∀ (f : Fin n → Nat) (k : Fin (sum f)) (x : (i : Fin n) × Fin (f i)), decodeSigma f k = x ↔ encodeSigma f x = k
f : Fin (n + 1) → Nat
k✝ : Fin (sum f)
x : (i : Fin (n + 1)) × Fin (f i)
k : Nat
hk : k < sum f
i : Nat
hi : i + 1 < n + 1
j : Nat
hj : j < f ⟨i + 1, hi⟩
h : ⟨f 0 + ↑(encodeSigma (f ∘ succ) ⟨⟨i, ⋯⟩, ⟨j, hj⟩⟩), ⋯⟩ = ⟨k, hk⟩
h✝ : ¬k < f 0
⊢ ⟨⟨↑(decodeSigma (f ∘ succ) ⟨k - f 0, ⋯⟩).1 + 1, ⋯⟩, (decodeSigma (f ∘ succ) ⟨k - f 0, ⋯⟩).snd⟩ =
    ⟨⟨i + 1, hi⟩, ⟨j, hj⟩⟩
Theorem: Fin.specSigma
Proof state before:
case mpr.isTrue
n : Nat
ih : ∀ (f : Fin n → Nat) (k : Fin (sum f)) (x : (i : Fin n) × Fin (f i)), decodeSigma f k = x ↔ encodeSigma f x = k
f : Fin (n + 1) → Nat
k✝ : Fin (sum f)
x : (i : Fin (n + 1)) × Fin (f i)
k : Nat
hk : k < sum f
i : Nat
hi : i + 1 < n + 1
j : Nat
hj : j < f ⟨i + 1, hi⟩
h : ⟨f 0 + ↑(encodeSigma (f ∘ succ) ⟨⟨i, ⋯⟩, ⟨j, hj⟩⟩), ⋯⟩ = ⟨k, hk⟩
h✝ : k < f 0
⊢ ⟨0, ⟨k, ⋯⟩⟩ = ⟨⟨i + 1, hi⟩, ⟨j, hj⟩⟩

case mpr.isFalse
n : Nat
ih : ∀ (f : Fin n → Nat) (k : Fin (sum f)) (x : (i : Fin n) × Fin (f i)), decodeSigma f k = x ↔ encodeSigma f x = k
f : Fin (n + 1) → Nat
k✝ : Fin (sum f)
x : (i : Fin (n + 1)) × Fin (f i)
k : Nat
hk : k < sum f
i : Nat
hi : i + 1 < n + 1
j : Nat
hj : j < f ⟨i + 1, hi⟩
h : ⟨f 0 + ↑(encodeSigma (f ∘ succ) ⟨⟨i, ⋯⟩, ⟨j, hj⟩⟩), ⋯⟩ = ⟨k, hk⟩
h✝ : ¬k < f 0
⊢ ⟨⟨↑(decodeSigma (f ∘ succ) ⟨k - f 0, ⋯⟩).1 + 1, ⋯⟩, (decodeSigma (f ∘ succ) ⟨k - f 0, ⋯⟩).snd⟩ =
    ⟨⟨i + 1, hi⟩, ⟨j, hj⟩⟩
Tactic:
next hlt =>
  cases h
  absurd hlt
  apply Nat.not_lt_of_ge
  exact Nat.le_add_right ..
Proof state after:
case mpr.isFalse
n : Nat
ih : ∀ (f : Fin n → Nat) (k : Fin (sum f)) (x : (i : Fin n) × Fin (f i)), decodeSigma f k = x ↔ encodeSigma f x = k
f : Fin (n + 1) → Nat
k✝ : Fin (sum f)
x : (i : Fin (n + 1)) × Fin (f i)
k : Nat
hk : k < sum f
i : Nat
hi : i + 1 < n + 1
j : Nat
hj : j < f ⟨i + 1, hi⟩
h : ⟨f 0 + ↑(encodeSigma (f ∘ succ) ⟨⟨i, ⋯⟩, ⟨j, hj⟩⟩), ⋯⟩ = ⟨k, hk⟩
h✝ : ¬k < f 0
⊢ ⟨⟨↑(decodeSigma (f ∘ succ) ⟨k - f 0, ⋯⟩).1 + 1, ⋯⟩, (decodeSigma (f ∘ succ) ⟨k - f 0, ⋯⟩).snd⟩ =
    ⟨⟨i + 1, hi⟩, ⟨j, hj⟩⟩
Theorem: Fin.specSigma
Proof state before:
n : Nat
ih : ∀ (f : Fin n → Nat) (k : Fin (sum f)) (x : (i : Fin n) × Fin (f i)), decodeSigma f k = x ↔ encodeSigma f x = k
f : Fin (n + 1) → Nat
k✝ : Fin (sum f)
x : (i : Fin (n + 1)) × Fin (f i)
k : Nat
hk : k < sum f
i : Nat
hi : i + 1 < n + 1
j : Nat
hj : j < f ⟨i + 1, hi⟩
h : ⟨f 0 + ↑(encodeSigma (f ∘ succ) ⟨⟨i, ⋯⟩, ⟨j, hj⟩⟩), ⋯⟩ = ⟨k, hk⟩
hlt : k < f 0
⊢ ⟨0, ⟨k, ⋯⟩⟩ = ⟨⟨i + 1, hi⟩, ⟨j, hj⟩⟩
Tactic:
cases h
Proof state after:
case refl
n : Nat
ih : ∀ (f : Fin n → Nat) (k : Fin (sum f)) (x : (i : Fin n) × Fin (f i)), decodeSigma f k = x ↔ encodeSigma f x = k
f : Fin (n + 1) → Nat
k : Fin (sum f)
x : (i : Fin (n + 1)) × Fin (f i)
i : Nat
hi : i + 1 < n + 1
j : Nat
hj : j < f ⟨i + 1, hi⟩
hk : f 0 + ↑(encodeSigma (f ∘ succ) ⟨⟨i, ⋯⟩, ⟨j, hj⟩⟩) < sum f
hlt : f 0 + ↑(encodeSigma (f ∘ succ) ⟨⟨i, ⋯⟩, ⟨j, hj⟩⟩) < f 0
⊢ ⟨0, ⟨f 0 + ↑(encodeSigma (f ∘ succ) ⟨⟨i, ⋯⟩, ⟨j, hj⟩⟩), ⋯⟩⟩ = ⟨⟨i + 1, hi⟩, ⟨j, hj⟩⟩
Theorem: Fin.specSigma
Proof state before:
case refl
n : Nat
ih : ∀ (f : Fin n → Nat) (k : Fin (sum f)) (x : (i : Fin n) × Fin (f i)), decodeSigma f k = x ↔ encodeSigma f x = k
f : Fin (n + 1) → Nat
k : Fin (sum f)
x : (i : Fin (n + 1)) × Fin (f i)
i : Nat
hi : i + 1 < n + 1
j : Nat
hj : j < f ⟨i + 1, hi⟩
hk : f 0 + ↑(encodeSigma (f ∘ succ) ⟨⟨i, ⋯⟩, ⟨j, hj⟩⟩) < sum f
hlt : f 0 + ↑(encodeSigma (f ∘ succ) ⟨⟨i, ⋯⟩, ⟨j, hj⟩⟩) < f 0
⊢ ⟨0, ⟨f 0 + ↑(encodeSigma (f ∘ succ) ⟨⟨i, ⋯⟩, ⟨j, hj⟩⟩), ⋯⟩⟩ = ⟨⟨i + 1, hi⟩, ⟨j, hj⟩⟩
Tactic:
absurd hlt
Proof state after:
case refl
n : Nat
ih : ∀ (f : Fin n → Nat) (k : Fin (sum f)) (x : (i : Fin n) × Fin (f i)), decodeSigma f k = x ↔ encodeSigma f x = k
f : Fin (n + 1) → Nat
k : Fin (sum f)
x : (i : Fin (n + 1)) × Fin (f i)
i : Nat
hi : i + 1 < n + 1
j : Nat
hj : j < f ⟨i + 1, hi⟩
hk : f 0 + ↑(encodeSigma (f ∘ succ) ⟨⟨i, ⋯⟩, ⟨j, hj⟩⟩) < sum f
hlt : f 0 + ↑(encodeSigma (f ∘ succ) ⟨⟨i, ⋯⟩, ⟨j, hj⟩⟩) < f 0
⊢ ¬f 0 + ↑(encodeSigma (f ∘ succ) ⟨⟨i, ⋯⟩, ⟨j, hj⟩⟩) < f 0
Theorem: Fin.specSigma
Proof state before:
case refl
n : Nat
ih : ∀ (f : Fin n → Nat) (k : Fin (sum f)) (x : (i : Fin n) × Fin (f i)), decodeSigma f k = x ↔ encodeSigma f x = k
f : Fin (n + 1) → Nat
k : Fin (sum f)
x : (i : Fin (n + 1)) × Fin (f i)
i : Nat
hi : i + 1 < n + 1
j : Nat
hj : j < f ⟨i + 1, hi⟩
hk : f 0 + ↑(encodeSigma (f ∘ succ) ⟨⟨i, ⋯⟩, ⟨j, hj⟩⟩) < sum f
hlt : f 0 + ↑(encodeSigma (f ∘ succ) ⟨⟨i, ⋯⟩, ⟨j, hj⟩⟩) < f 0
⊢ ¬f 0 + ↑(encodeSigma (f ∘ succ) ⟨⟨i, ⋯⟩, ⟨j, hj⟩⟩) < f 0
Tactic:
apply Nat.not_lt_of_ge
Proof state after:
case refl.a
n : Nat
ih : ∀ (f : Fin n → Nat) (k : Fin (sum f)) (x : (i : Fin n) × Fin (f i)), decodeSigma f k = x ↔ encodeSigma f x = k
f : Fin (n + 1) → Nat
k : Fin (sum f)
x : (i : Fin (n + 1)) × Fin (f i)
i : Nat
hi : i + 1 < n + 1
j : Nat
hj : j < f ⟨i + 1, hi⟩
hk : f 0 + ↑(encodeSigma (f ∘ succ) ⟨⟨i, ⋯⟩, ⟨j, hj⟩⟩) < sum f
hlt : f 0 + ↑(encodeSigma (f ∘ succ) ⟨⟨i, ⋯⟩, ⟨j, hj⟩⟩) < f 0
⊢ f 0 + ↑(encodeSigma (f ∘ succ) ⟨⟨i, ⋯⟩, ⟨j, hj⟩⟩) ≥ f 0
Theorem: Fin.specSigma
Proof state before:
case refl.a
n : Nat
ih : ∀ (f : Fin n → Nat) (k : Fin (sum f)) (x : (i : Fin n) × Fin (f i)), decodeSigma f k = x ↔ encodeSigma f x = k
f : Fin (n + 1) → Nat
k : Fin (sum f)
x : (i : Fin (n + 1)) × Fin (f i)
i : Nat
hi : i + 1 < n + 1
j : Nat
hj : j < f ⟨i + 1, hi⟩
hk : f 0 + ↑(encodeSigma (f ∘ succ) ⟨⟨i, ⋯⟩, ⟨j, hj⟩⟩) < sum f
hlt : f 0 + ↑(encodeSigma (f ∘ succ) ⟨⟨i, ⋯⟩, ⟨j, hj⟩⟩) < f 0
⊢ f 0 + ↑(encodeSigma (f ∘ succ) ⟨⟨i, ⋯⟩, ⟨j, hj⟩⟩) ≥ f 0
Tactic:
exact Nat.le_add_right ..
Proof state after:
no goals
Theorem: Fin.specSigma
Proof state before:
n : Nat
ih : ∀ (f : Fin n → Nat) (k : Fin (sum f)) (x : (i : Fin n) × Fin (f i)), decodeSigma f k = x ↔ encodeSigma f x = k
f : Fin (n + 1) → Nat
k✝ : Fin (sum f)
x : (i : Fin (n + 1)) × Fin (f i)
k : Nat
hk : k < sum f
i : Nat
hi : i + 1 < n + 1
j : Nat
hj : j < f ⟨i + 1, hi⟩
h : ⟨f 0 + ↑(encodeSigma (f ∘ succ) ⟨⟨i, ⋯⟩, ⟨j, hj⟩⟩), ⋯⟩ = ⟨k, hk⟩
hge : ¬k < f 0
⊢ ⟨⟨↑(decodeSigma (f ∘ succ) ⟨k - f 0, ⋯⟩).1 + 1, ⋯⟩, (decodeSigma (f ∘ succ) ⟨k - f 0, ⋯⟩).snd⟩ =
    ⟨⟨i + 1, hi⟩, ⟨j, hj⟩⟩
Tactic:
have hge := Nat.ge_of_not_lt hge
Proof state after:
n : Nat
ih : ∀ (f : Fin n → Nat) (k : Fin (sum f)) (x : (i : Fin n) × Fin (f i)), decodeSigma f k = x ↔ encodeSigma f x = k
f : Fin (n + 1) → Nat
k✝ : Fin (sum f)
x : (i : Fin (n + 1)) × Fin (f i)
k : Nat
hk : k < sum f
i : Nat
hi : i + 1 < n + 1
j : Nat
hj : j < f ⟨i + 1, hi⟩
h : ⟨f 0 + ↑(encodeSigma (f ∘ succ) ⟨⟨i, ⋯⟩, ⟨j, hj⟩⟩), ⋯⟩ = ⟨k, hk⟩
hge✝ : ¬k < f 0
hge : k ≥ f 0
⊢ ⟨⟨↑(decodeSigma (f ∘ succ) ⟨k - f 0, ⋯⟩).1 + 1, ⋯⟩, (decodeSigma (f ∘ succ) ⟨k - f 0, ⋯⟩).snd⟩ =
    ⟨⟨i + 1, hi⟩, ⟨j, hj⟩⟩
Theorem: Fin.specSigma
Proof state before:
n : Nat
ih : ∀ (f : Fin n → Nat) (k : Fin (sum f)) (x : (i : Fin n) × Fin (f i)), decodeSigma f k = x ↔ encodeSigma f x = k
f : Fin (n + 1) → Nat
k✝ : Fin (sum f)
x : (i : Fin (n + 1)) × Fin (f i)
k : Nat
hk : k < sum f
i : Nat
hi : i + 1 < n + 1
j : Nat
hj : j < f ⟨i + 1, hi⟩
h : ⟨f 0 + ↑(encodeSigma (f ∘ succ) ⟨⟨i, ⋯⟩, ⟨j, hj⟩⟩), ⋯⟩ = ⟨k, hk⟩
hge✝ : ¬k < f 0
hge : k ≥ f 0
⊢ ⟨⟨↑(decodeSigma (f ∘ succ) ⟨k - f 0, ⋯⟩).1 + 1, ⋯⟩, (decodeSigma (f ∘ succ) ⟨k - f 0, ⋯⟩).snd⟩ =
    ⟨⟨i + 1, hi⟩, ⟨j, hj⟩⟩
Tactic:
have hpos : 0 < sum (f ∘ succ) := by
  apply Nat.pos_of_nonzero
  intro hz
  rw [sum_succ, hz] at hk
  contradiction
Proof state after:
n : Nat
ih : ∀ (f : Fin n → Nat) (k : Fin (sum f)) (x : (i : Fin n) × Fin (f i)), decodeSigma f k = x ↔ encodeSigma f x = k
f : Fin (n + 1) → Nat
k✝ : Fin (sum f)
x : (i : Fin (n + 1)) × Fin (f i)
k : Nat
hk : k < sum f
i : Nat
hi : i + 1 < n + 1
j : Nat
hj : j < f ⟨i + 1, hi⟩
h : ⟨f 0 + ↑(encodeSigma (f ∘ succ) ⟨⟨i, ⋯⟩, ⟨j, hj⟩⟩), ⋯⟩ = ⟨k, hk⟩
hge✝ : ¬k < f 0
hge : k ≥ f 0
hpos : 0 < sum (f ∘ succ)
⊢ ⟨⟨↑(decodeSigma (f ∘ succ) ⟨k - f 0, ⋯⟩).1 + 1, ⋯⟩, (decodeSigma (f ∘ succ) ⟨k - f 0, ⋯⟩).snd⟩ =
    ⟨⟨i + 1, hi⟩, ⟨j, hj⟩⟩
Theorem: Fin.specSigma
Proof state before:
n : Nat
ih : ∀ (f : Fin n → Nat) (k : Fin (sum f)) (x : (i : Fin n) × Fin (f i)), decodeSigma f k = x ↔ encodeSigma f x = k
f : Fin (n + 1) → Nat
k✝ : Fin (sum f)
x : (i : Fin (n + 1)) × Fin (f i)
k : Nat
hk : k < sum f
i : Nat
hi : i + 1 < n + 1
j : Nat
hj : j < f ⟨i + 1, hi⟩
h : ⟨f 0 + ↑(encodeSigma (f ∘ succ) ⟨⟨i, ⋯⟩, ⟨j, hj⟩⟩), ⋯⟩ = ⟨k, hk⟩
hge✝ : ¬k < f 0
hge : k ≥ f 0
hpos : 0 < sum (f ∘ succ)
⊢ ⟨⟨↑(decodeSigma (f ∘ succ) ⟨k - f 0, ⋯⟩).1 + 1, ⋯⟩, (decodeSigma (f ∘ succ) ⟨k - f 0, ⋯⟩).snd⟩ =
    ⟨⟨i + 1, hi⟩, ⟨j, hj⟩⟩
Tactic:
have hk' : k - f 0 < sum (f ∘ succ) := by
  rw [Nat.sub_lt_iff_lt_add_of_pos _ _ _ hpos]
  rw [sum_succ] at hk
  exact hk
Proof state after:
n : Nat
ih : ∀ (f : Fin n → Nat) (k : Fin (sum f)) (x : (i : Fin n) × Fin (f i)), decodeSigma f k = x ↔ encodeSigma f x = k
f : Fin (n + 1) → Nat
k✝ : Fin (sum f)
x : (i : Fin (n + 1)) × Fin (f i)
k : Nat
hk : k < sum f
i : Nat
hi : i + 1 < n + 1
j : Nat
hj : j < f ⟨i + 1, hi⟩
h : ⟨f 0 + ↑(encodeSigma (f ∘ succ) ⟨⟨i, ⋯⟩, ⟨j, hj⟩⟩), ⋯⟩ = ⟨k, hk⟩
hge✝ : ¬k < f 0
hge : k ≥ f 0
hpos : 0 < sum (f ∘ succ)
hk' : k - f 0 < sum (f ∘ succ)
⊢ ⟨⟨↑(decodeSigma (f ∘ succ) ⟨k - f 0, ⋯⟩).1 + 1, ⋯⟩, (decodeSigma (f ∘ succ) ⟨k - f 0, ⋯⟩).snd⟩ =
    ⟨⟨i + 1, hi⟩, ⟨j, hj⟩⟩
Theorem: Fin.specSigma
Proof state before:
n : Nat
ih : ∀ (f : Fin n → Nat) (k : Fin (sum f)) (x : (i : Fin n) × Fin (f i)), decodeSigma f k = x ↔ encodeSigma f x = k
f : Fin (n + 1) → Nat
k✝ : Fin (sum f)
x : (i : Fin (n + 1)) × Fin (f i)
k : Nat
hk : k < sum f
i : Nat
hi : i + 1 < n + 1
j : Nat
hj : j < f ⟨i + 1, hi⟩
h : ⟨f 0 + ↑(encodeSigma (f ∘ succ) ⟨⟨i, ⋯⟩, ⟨j, hj⟩⟩), ⋯⟩ = ⟨k, hk⟩
hge✝ : ¬k < f 0
hge : k ≥ f 0
hpos : 0 < sum (f ∘ succ)
hk' : k - f 0 < sum (f ∘ succ)
⊢ ⟨⟨↑(decodeSigma (f ∘ succ) ⟨k - f 0, ⋯⟩).1 + 1, ⋯⟩, (decodeSigma (f ∘ succ) ⟨k - f 0, ⋯⟩).snd⟩ =
    ⟨⟨i + 1, hi⟩, ⟨j, hj⟩⟩
Tactic:
have : decodeSigma (f ∘ succ) ⟨k - f 0, hk'⟩ = ⟨⟨i, Nat.lt_of_succ_lt_succ hi⟩, ⟨j,hj⟩⟩ := by
  rw [ih]
  cases h
  apply Fin.eq
  clean
  rw [Nat.add_sub_cancel_left]
Proof state after:
n : Nat
ih : ∀ (f : Fin n → Nat) (k : Fin (sum f)) (x : (i : Fin n) × Fin (f i)), decodeSigma f k = x ↔ encodeSigma f x = k
f : Fin (n + 1) → Nat
k✝ : Fin (sum f)
x : (i : Fin (n + 1)) × Fin (f i)
k : Nat
hk : k < sum f
i : Nat
hi : i + 1 < n + 1
j : Nat
hj : j < f ⟨i + 1, hi⟩
h : ⟨f 0 + ↑(encodeSigma (f ∘ succ) ⟨⟨i, ⋯⟩, ⟨j, hj⟩⟩), ⋯⟩ = ⟨k, hk⟩
hge✝ : ¬k < f 0
hge : k ≥ f 0
hpos : 0 < sum (f ∘ succ)
hk' : k - f 0 < sum (f ∘ succ)
this : decodeSigma (f ∘ succ) ⟨k - f 0, hk'⟩ = ⟨⟨i, ⋯⟩, ⟨j, hj⟩⟩
⊢ ⟨⟨↑(decodeSigma (f ∘ succ) ⟨k - f 0, ⋯⟩).1 + 1, ⋯⟩, (decodeSigma (f ∘ succ) ⟨k - f 0, ⋯⟩).snd⟩ =
    ⟨⟨i + 1, hi⟩, ⟨j, hj⟩⟩
Theorem: Fin.specSigma
Proof state before:
n : Nat
ih : ∀ (f : Fin n → Nat) (k : Fin (sum f)) (x : (i : Fin n) × Fin (f i)), decodeSigma f k = x ↔ encodeSigma f x = k
f : Fin (n + 1) → Nat
k✝ : Fin (sum f)
x : (i : Fin (n + 1)) × Fin (f i)
k : Nat
hk : k < sum f
i : Nat
hi : i + 1 < n + 1
j : Nat
hj : j < f ⟨i + 1, hi⟩
h : ⟨f 0 + ↑(encodeSigma (f ∘ succ) ⟨⟨i, ⋯⟩, ⟨j, hj⟩⟩), ⋯⟩ = ⟨k, hk⟩
hge✝ : ¬k < f 0
hge : k ≥ f 0
hpos : 0 < sum (f ∘ succ)
hk' : k - f 0 < sum (f ∘ succ)
this : decodeSigma (f ∘ succ) ⟨k - f 0, hk'⟩ = ⟨⟨i, ⋯⟩, ⟨j, hj⟩⟩
⊢ ⟨⟨↑(decodeSigma (f ∘ succ) ⟨k - f 0, ⋯⟩).1 + 1, ⋯⟩, (decodeSigma (f ∘ succ) ⟨k - f 0, ⋯⟩).snd⟩ =
    ⟨⟨i + 1, hi⟩, ⟨j, hj⟩⟩
Tactic:
congr 1
Proof state after:
case h.e_3.h
n : Nat
ih : ∀ (f : Fin n → Nat) (k : Fin (sum f)) (x : (i : Fin n) × Fin (f i)), decodeSigma f k = x ↔ encodeSigma f x = k
f : Fin (n + 1) → Nat
k✝ : Fin (sum f)
x : (i : Fin (n + 1)) × Fin (f i)
k : Nat
hk : k < sum f
i : Nat
hi : i + 1 < n + 1
j : Nat
hj : j < f ⟨i + 1, hi⟩
h : ⟨f 0 + ↑(encodeSigma (f ∘ succ) ⟨⟨i, ⋯⟩, ⟨j, hj⟩⟩), ⋯⟩ = ⟨k, hk⟩
hge✝ : ¬k < f 0
hge : k ≥ f 0
hpos : 0 < sum (f ∘ succ)
hk' : k - f 0 < sum (f ∘ succ)
this : decodeSigma (f ∘ succ) ⟨k - f 0, hk'⟩ = ⟨⟨i, ⋯⟩, ⟨j, hj⟩⟩
⊢ ⟨↑(decodeSigma (f ∘ succ) ⟨k - f 0, ⋯⟩).1 + 1, ⋯⟩ = ⟨i + 1, hi⟩

case h.e_4
n : Nat
ih : ∀ (f : Fin n → Nat) (k : Fin (sum f)) (x : (i : Fin n) × Fin (f i)), decodeSigma f k = x ↔ encodeSigma f x = k
f : Fin (n + 1) → Nat
k✝ : Fin (sum f)
x : (i : Fin (n + 1)) × Fin (f i)
k : Nat
hk : k < sum f
i : Nat
hi : i + 1 < n + 1
j : Nat
hj : j < f ⟨i + 1, hi⟩
h : ⟨f 0 + ↑(encodeSigma (f ∘ succ) ⟨⟨i, ⋯⟩, ⟨j, hj⟩⟩), ⋯⟩ = ⟨k, hk⟩
hge✝ : ¬k < f 0
hge : k ≥ f 0
hpos : 0 < sum (f ∘ succ)
hk' : k - f 0 < sum (f ∘ succ)
this : decodeSigma (f ∘ succ) ⟨k - f 0, hk'⟩ = ⟨⟨i, ⋯⟩, ⟨j, hj⟩⟩
⊢ (decodeSigma (f ∘ succ) ⟨k - f 0, ⋯⟩).snd ≅ ⟨j, hj⟩
Theorem: Fin.specSigma
Proof state before:
n : Nat
ih : ∀ (f : Fin n → Nat) (k : Fin (sum f)) (x : (i : Fin n) × Fin (f i)), decodeSigma f k = x ↔ encodeSigma f x = k
f : Fin (n + 1) → Nat
k✝ : Fin (sum f)
x : (i : Fin (n + 1)) × Fin (f i)
k : Nat
hk : k < sum f
i : Nat
hi : i + 1 < n + 1
j : Nat
hj : j < f ⟨i + 1, hi⟩
h : ⟨f 0 + ↑(encodeSigma (f ∘ succ) ⟨⟨i, ⋯⟩, ⟨j, hj⟩⟩), ⋯⟩ = ⟨k, hk⟩
hge✝ : ¬k < f 0
hge : k ≥ f 0
⊢ 0 < sum (f ∘ succ)
Tactic:
apply Nat.pos_of_nonzero
Proof state after:
case a
n : Nat
ih : ∀ (f : Fin n → Nat) (k : Fin (sum f)) (x : (i : Fin n) × Fin (f i)), decodeSigma f k = x ↔ encodeSigma f x = k
f : Fin (n + 1) → Nat
k✝ : Fin (sum f)
x : (i : Fin (n + 1)) × Fin (f i)
k : Nat
hk : k < sum f
i : Nat
hi : i + 1 < n + 1
j : Nat
hj : j < f ⟨i + 1, hi⟩
h : ⟨f 0 + ↑(encodeSigma (f ∘ succ) ⟨⟨i, ⋯⟩, ⟨j, hj⟩⟩), ⋯⟩ = ⟨k, hk⟩
hge✝ : ¬k < f 0
hge : k ≥ f 0
⊢ sum (f ∘ succ) ≠ 0
Theorem: Fin.specSigma
Proof state before:
case a
n : Nat
ih : ∀ (f : Fin n → Nat) (k : Fin (sum f)) (x : (i : Fin n) × Fin (f i)), decodeSigma f k = x ↔ encodeSigma f x = k
f : Fin (n + 1) → Nat
k✝ : Fin (sum f)
x : (i : Fin (n + 1)) × Fin (f i)
k : Nat
hk : k < sum f
i : Nat
hi : i + 1 < n + 1
j : Nat
hj : j < f ⟨i + 1, hi⟩
h : ⟨f 0 + ↑(encodeSigma (f ∘ succ) ⟨⟨i, ⋯⟩, ⟨j, hj⟩⟩), ⋯⟩ = ⟨k, hk⟩
hge✝ : ¬k < f 0
hge : k ≥ f 0
⊢ sum (f ∘ succ) ≠ 0
Tactic:
intro hz
Proof state after:
case a
n : Nat
ih : ∀ (f : Fin n → Nat) (k : Fin (sum f)) (x : (i : Fin n) × Fin (f i)), decodeSigma f k = x ↔ encodeSigma f x = k
f : Fin (n + 1) → Nat
k✝ : Fin (sum f)
x : (i : Fin (n + 1)) × Fin (f i)
k : Nat
hk : k < sum f
i : Nat
hi : i + 1 < n + 1
j : Nat
hj : j < f ⟨i + 1, hi⟩
h : ⟨f 0 + ↑(encodeSigma (f ∘ succ) ⟨⟨i, ⋯⟩, ⟨j, hj⟩⟩), ⋯⟩ = ⟨k, hk⟩
hge✝ : ¬k < f 0
hge : k ≥ f 0
hz : sum (f ∘ succ) = 0
⊢ False
Theorem: Fin.specSigma
Proof state before:
case a
n : Nat
ih : ∀ (f : Fin n → Nat) (k : Fin (sum f)) (x : (i : Fin n) × Fin (f i)), decodeSigma f k = x ↔ encodeSigma f x = k
f : Fin (n + 1) → Nat
k✝ : Fin (sum f)
x : (i : Fin (n + 1)) × Fin (f i)
k : Nat
hk : k < sum f
i : Nat
hi : i + 1 < n + 1
j : Nat
hj : j < f ⟨i + 1, hi⟩
h : ⟨f 0 + ↑(encodeSigma (f ∘ succ) ⟨⟨i, ⋯⟩, ⟨j, hj⟩⟩), ⋯⟩ = ⟨k, hk⟩
hge✝ : ¬k < f 0
hge : k ≥ f 0
hz : sum (f ∘ succ) = 0
⊢ False
Tactic:
rw [sum_succ, hz] at hk
Proof state after:
case a
n : Nat
ih : ∀ (f : Fin n → Nat) (k : Fin (sum f)) (x : (i : Fin n) × Fin (f i)), decodeSigma f k = x ↔ encodeSigma f x = k
f : Fin (n + 1) → Nat
k✝ : Fin (sum f)
x : (i : Fin (n + 1)) × Fin (f i)
k : Nat
hk✝ : k < sum f
hk : k < f 0 + 0
i : Nat
hi : i + 1 < n + 1
j : Nat
hj : j < f ⟨i + 1, hi⟩
h : ⟨f 0 + ↑(encodeSigma (f ∘ succ) ⟨⟨i, ⋯⟩, ⟨j, hj⟩⟩), ⋯⟩ = ⟨k, hk✝⟩
hge✝ : ¬k < f 0
hge : k ≥ f 0
hz : sum (f ∘ succ) = 0
⊢ False
Theorem: Fin.specSigma
Proof state before:
case a
n : Nat
ih : ∀ (f : Fin n → Nat) (k : Fin (sum f)) (x : (i : Fin n) × Fin (f i)), decodeSigma f k = x ↔ encodeSigma f x = k
f : Fin (n + 1) → Nat
k✝ : Fin (sum f)
x : (i : Fin (n + 1)) × Fin (f i)
k : Nat
hk✝ : k < sum f
hk : k < f 0 + 0
i : Nat
hi : i + 1 < n + 1
j : Nat
hj : j < f ⟨i + 1, hi⟩
h : ⟨f 0 + ↑(encodeSigma (f ∘ succ) ⟨⟨i, ⋯⟩, ⟨j, hj⟩⟩), ⋯⟩ = ⟨k, hk✝⟩
hge✝ : ¬k < f 0
hge : k ≥ f 0
hz : sum (f ∘ succ) = 0
⊢ False
Tactic:
contradiction
Proof state after:
no goals
Theorem: Fin.specSigma
Proof state before:
n : Nat
ih : ∀ (f : Fin n → Nat) (k : Fin (sum f)) (x : (i : Fin n) × Fin (f i)), decodeSigma f k = x ↔ encodeSigma f x = k
f : Fin (n + 1) → Nat
k✝ : Fin (sum f)
x : (i : Fin (n + 1)) × Fin (f i)
k : Nat
hk : k < sum f
i : Nat
hi : i + 1 < n + 1
j : Nat
hj : j < f ⟨i + 1, hi⟩
h : ⟨f 0 + ↑(encodeSigma (f ∘ succ) ⟨⟨i, ⋯⟩, ⟨j, hj⟩⟩), ⋯⟩ = ⟨k, hk⟩
hge✝ : ¬k < f 0
hge : k ≥ f 0
hpos : 0 < sum (f ∘ succ)
⊢ k - f 0 < sum (f ∘ succ)
Tactic:
rw [Nat.sub_lt_iff_lt_add_of_pos _ _ _ hpos]
Proof state after:
n : Nat
ih : ∀ (f : Fin n → Nat) (k : Fin (sum f)) (x : (i : Fin n) × Fin (f i)), decodeSigma f k = x ↔ encodeSigma f x = k
f : Fin (n + 1) → Nat
k✝ : Fin (sum f)
x : (i : Fin (n + 1)) × Fin (f i)
k : Nat
hk : k < sum f
i : Nat
hi : i + 1 < n + 1
j : Nat
hj : j < f ⟨i + 1, hi⟩
h : ⟨f 0 + ↑(encodeSigma (f ∘ succ) ⟨⟨i, ⋯⟩, ⟨j, hj⟩⟩), ⋯⟩ = ⟨k, hk⟩
hge✝ : ¬k < f 0
hge : k ≥ f 0
hpos : 0 < sum (f ∘ succ)
⊢ k < f 0 + sum (f ∘ succ)
Theorem: Fin.specSigma
Proof state before:
n : Nat
ih : ∀ (f : Fin n → Nat) (k : Fin (sum f)) (x : (i : Fin n) × Fin (f i)), decodeSigma f k = x ↔ encodeSigma f x = k
f : Fin (n + 1) → Nat
k✝ : Fin (sum f)
x : (i : Fin (n + 1)) × Fin (f i)
k : Nat
hk : k < sum f
i : Nat
hi : i + 1 < n + 1
j : Nat
hj : j < f ⟨i + 1, hi⟩
h : ⟨f 0 + ↑(encodeSigma (f ∘ succ) ⟨⟨i, ⋯⟩, ⟨j, hj⟩⟩), ⋯⟩ = ⟨k, hk⟩
hge✝ : ¬k < f 0
hge : k ≥ f 0
hpos : 0 < sum (f ∘ succ)
⊢ k < f 0 + sum (f ∘ succ)
Tactic:
rw [sum_succ] at hk
Proof state after:
n : Nat
ih : ∀ (f : Fin n → Nat) (k : Fin (sum f)) (x : (i : Fin n) × Fin (f i)), decodeSigma f k = x ↔ encodeSigma f x = k
f : Fin (n + 1) → Nat
k✝ : Fin (sum f)
x : (i : Fin (n + 1)) × Fin (f i)
k : Nat
hk✝ : k < sum f
hk : k < f 0 + sum (f ∘ succ)
i : Nat
hi : i + 1 < n + 1
j : Nat
hj : j < f ⟨i + 1, hi⟩
h : ⟨f 0 + ↑(encodeSigma (f ∘ succ) ⟨⟨i, ⋯⟩, ⟨j, hj⟩⟩), ⋯⟩ = ⟨k, hk✝⟩
hge✝ : ¬k < f 0
hge : k ≥ f 0
hpos : 0 < sum (f ∘ succ)
⊢ k < f 0 + sum (f ∘ succ)
Theorem: Fin.specSigma
Proof state before:
n : Nat
ih : ∀ (f : Fin n → Nat) (k : Fin (sum f)) (x : (i : Fin n) × Fin (f i)), decodeSigma f k = x ↔ encodeSigma f x = k
f : Fin (n + 1) → Nat
k✝ : Fin (sum f)
x : (i : Fin (n + 1)) × Fin (f i)
k : Nat
hk✝ : k < sum f
hk : k < f 0 + sum (f ∘ succ)
i : Nat
hi : i + 1 < n + 1
j : Nat
hj : j < f ⟨i + 1, hi⟩
h : ⟨f 0 + ↑(encodeSigma (f ∘ succ) ⟨⟨i, ⋯⟩, ⟨j, hj⟩⟩), ⋯⟩ = ⟨k, hk✝⟩
hge✝ : ¬k < f 0
hge : k ≥ f 0
hpos : 0 < sum (f ∘ succ)
⊢ k < f 0 + sum (f ∘ succ)
Tactic:
exact hk
Proof state after:
no goals