-- Mathlib/Topology/EMetricSpace/BoundedVariation.lean
theorem add_point (f : α → E) {s : Set α} {x : α} (hx : x ∈ s) (u : ℕ → α) (hu : Monotone u)
    (us : ∀ i, u i ∈ s) (n : ℕ) :
    ∃ (v : ℕ → α) (m : ℕ), Monotone v ∧ (∀ i, v i ∈ s) ∧ x ∈ v '' Iio m ∧
      (∑ i ∈ Finset.range n, edist (f (u (i + 1))) (f (u i))) ≤
        ∑ j ∈ Finset.range m, edist (f (v (j + 1))) (f (v j))

Proof state:
case inl
α : Type u_1
inst✝¹ : LinearOrder α
E : Type u_2
inst✝ : PseudoEMetricSpace E
f : α → E
s : Set α
x : α
hx : x ∈ s
u : ℕ → α
hu : Monotone u
us : ∀ (i : ℕ), u i ∈ s
n : ℕ
h : u n ≤ x
v : ℕ → α := fun i => if i ≤ n then u i else x
vs : ∀ (i : ℕ), v i ∈ s
hv : Monotone v
⊢ ∃ v m,
    Monotone v ∧
      (∀ (i : ℕ), v i ∈ s) ∧
        x ∈ v '' Iio m ∧
          ∑ i ∈ Finset.range n, edist (f (u (i + 1))) (f (u i)) ≤ ∑ j ∈ Finset.range m, edist (f (v (j + 1))) (f (v j))

Tactic:
refine ⟨v, n + 2, hv, vs, (mem_image _ _ _).2 ⟨n + 1, ?_, ?_⟩, ?_⟩

Result:
case inl.refine_1
α : Type u_1
inst✝¹ : LinearOrder α
E : Type u_2
inst✝ : PseudoEMetricSpace E
f : α → E
s : Set α
x : α
hx : x ∈ s
u : ℕ → α
hu : Monotone u
us : ∀ (i : ℕ), u i ∈ s
n : ℕ
h : u n ≤ x
v : ℕ → α := fun i => if i ≤ n then u i else x
vs : ∀ (i : ℕ), v i ∈ s
hv : Monotone v
⊢ n + 1 ∈ Iio (n + 2)

case inl.refine_2
α : Type u_1
inst✝¹ : LinearOrder α
E : Type u_2
inst✝ : PseudoEMetricSpace E
f : α → E
s : Set α
x : α
hx : x ∈ s
u : ℕ → α
hu : Monotone u
us : ∀ (i : ℕ), u i ∈ s
n : ℕ
h : u n ≤ x
v : ℕ → α := fun i => if i ≤ n then u i else x
vs : ∀ (i : ℕ), v i ∈ s
hv : Monotone v
⊢ v (n + 1) = x

case inl.refine_3
α : Type u_1
inst✝¹ : LinearOrder α
E : Type u_2
inst✝ : PseudoEMetricSpace E
f : α → E
s : Set α
x : α
hx : x ∈ s
u : ℕ → α
hu : Monotone u
us : ∀ (i : ℕ), u i ∈ s
n : ℕ
h : u n ≤ x
v : ℕ → α := fun i => if i ≤ n then u i else x
vs : ∀ (i : ℕ), v i ∈ s
hv : Monotone v
⊢ ∑ i ∈ Finset.range n, edist (f (u (i + 1))) (f (u i)) ≤ ∑ j ∈ Finset.range (n + 2), edist (f (v (j + 1))) (f (v j))

Proof state:
case e_a.e_a.e_a
α : Type u_1
inst✝¹ : LinearOrder α
E : Type u_2
inst✝ : PseudoEMetricSpace E
f : α → E
s : Set α
x : α
hx : x ∈ s
u : ℕ → α
hu : Monotone u
us : ∀ (i : ℕ), u i ∈ s
n : ℕ
h : x < u n
exists_N : ∃ N ≤ n, x < u N
N : ℕ := Nat.find exists_N
hN : N ≤ n ∧ x < u N
w : ℕ → α := fun i => if i < N then u i else if i = N then x else u (i - 1)
ws : ∀ (i : ℕ), w i ∈ s
hw : Monotone w
Npos : 0 < N
i : ℕ
hi : N ≤ i ∧ i < n
A : ¬1 + i + 1 < N
B : ¬1 + i + 1 = N
C : ¬1 + i < N
D : ¬1 + i = N
⊢ i = 1 + i - 1

Tactic:
rw [add_comm, Nat.sub_one]

Result:
case e_a.e_a.e_a
α : Type u_1
inst✝¹ : LinearOrder α
E : Type u_2
inst✝ : PseudoEMetricSpace E
f : α → E
s : Set α
x : α
hx : x ∈ s
u : ℕ → α
hu : Monotone u
us : ∀ (i : ℕ), u i ∈ s
n : ℕ
h : x < u n
exists_N : ∃ N ≤ n, x < u N
N : ℕ := Nat.find exists_N
hN : N ≤ n ∧ x < u N
w : ℕ → α := fun i => if i < N then u i else if i = N then x else u (i - 1)
ws : ∀ (i : ℕ), w i ∈ s
hw : Monotone w
Npos : 0 < N
i : ℕ
hi : N ≤ i ∧ i < n
A : ¬1 + i + 1 < N
B : ¬1 + i + 1 = N
C : ¬1 + i < N
D : ¬1 + i = N
⊢ i = (i + 1).pred

Proof state:
α : Type u_1
inst✝¹ : LinearOrder α
E : Type u_2
inst✝ : PseudoEMetricSpace E
f : α → E
s : Set α
x : α
hx : x ∈ s
u : ℕ → α
hu : Monotone u
us : ∀ (i : ℕ), u i ∈ s
n : ℕ
h : x < u n
exists_N : ∃ N ≤ n, x < u N
N : ℕ := Nat.find exists_N
hN : N ≤ n ∧ x < u N
w : ℕ → α := fun i => if i < N then u i else if i = N then x else u (i - 1)
ws : ∀ (i : ℕ), w i ∈ s
⊢ Monotone w

Tactic:
apply monotone_nat_of_le_succ fun i => ?_

Result:
α : Type u_1
inst✝¹ : LinearOrder α
E : Type u_2
inst✝ : PseudoEMetricSpace E
f : α → E
s : Set α
x : α
hx : x ∈ s
u : ℕ → α
hu : Monotone u
us : ∀ (i : ℕ), u i ∈ s
n : ℕ
h : x < u n
exists_N : ∃ N ≤ n, x < u N
N : ℕ := Nat.find exists_N
hN : N ≤ n ∧ x < u N
w : ℕ → α := fun i => if i < N then u i else if i = N then x else u (i - 1)
ws : ∀ (i : ℕ), w i ∈ s
i : ℕ
⊢ w i ≤ w (i + 1)

Proof state:
α : Type u_1
inst✝¹ : LinearOrder α
E : Type u_2
inst✝ : PseudoEMetricSpace E
f : α → E
s : Set α
x : α
hx : x ∈ s
u : ℕ → α
hu : Monotone u
us : ∀ (i : ℕ), u i ∈ s
n : ℕ
h : u n ≤ x
v : ℕ → α := fun i => if i ≤ n then u i else x
vs : ∀ (i : ℕ), v i ∈ s
i : ℕ
⊢ (if i ≤ n then u i else x) ≤ if i + 1 ≤ n then u (i + 1) else x

Tactic:
rcases lt_trichotomy i n with (hi | rfl | hi)

Result:
case inl
α : Type u_1
inst✝¹ : LinearOrder α
E : Type u_2
inst✝ : PseudoEMetricSpace E
f : α → E
s : Set α
x : α
hx : x ∈ s
u : ℕ → α
hu : Monotone u
us : ∀ (i : ℕ), u i ∈ s
n : ℕ
h : u n ≤ x
v : ℕ → α := fun i => if i ≤ n then u i else x
vs : ∀ (i : ℕ), v i ∈ s
i : ℕ
hi : i < n
⊢ (if i ≤ n then u i else x) ≤ if i + 1 ≤ n then u (i + 1) else x

case inr.inl
α : Type u_1
inst✝¹ : LinearOrder α
E : Type u_2
inst✝ : PseudoEMetricSpace E
f : α → E
s : Set α
x : α
hx : x ∈ s
u : ℕ → α
hu : Monotone u
us : ∀ (i : ℕ), u i ∈ s
i : ℕ
h : u i ≤ x
v : ℕ → α := fun i_1 => if i_1 ≤ i then u i_1 else x
vs : ∀ (i : ℕ), v i ∈ s
⊢ (if i ≤ i then u i else x) ≤ if i + 1 ≤ i then u (i + 1) else x

case inr.inr
α : Type u_1
inst✝¹ : LinearOrder α
E : Type u_2
inst✝ : PseudoEMetricSpace E
f : α → E
s : Set α
x : α
hx : x ∈ s
u : ℕ → α
hu : Monotone u
us : ∀ (i : ℕ), u i ∈ s
n : ℕ
h : u n ≤ x
v : ℕ → α := fun i => if i ≤ n then u i else x
vs : ∀ (i : ℕ), v i ∈ s
i : ℕ
hi : n < i
⊢ (if i ≤ n then u i else x) ≤ if i + 1 ≤ n then u (i + 1) else x

Proof state:
α : Type u_1
inst✝¹ : LinearOrder α
E : Type u_2
inst✝ : PseudoEMetricSpace E
f : α → E
s : Set α
x : α
hx : x ∈ s
u : ℕ → α
hu : Monotone u
us : ∀ (i : ℕ), u i ∈ s
n : ℕ
h : x < u n
exists_N : ∃ N ≤ n, x < u N
N : ℕ := Nat.find exists_N
hN : N ≤ n ∧ x < u N
w : ℕ → α := fun i => if i < N then u i else if i = N then x else u (i - 1)
ws : ∀ (i : ℕ), w i ∈ s
hw : Monotone w
Npos : 0 < N
i : ℕ
hi : N ≤ i ∧ i < n
A : ¬1 + i + 1 < N
B : ¬1 + i + 1 = N
⊢ edist (f (u (i + 1))) (f (u i)) =
    edist (f (if 1 + i + 1 < N then u (1 + i + 1) else if 1 + i + 1 = N then x else u (1 + i + 1 - 1)))
      (f (if 1 + i < N then u (1 + i) else if 1 + i = N then x else u (1 + i - 1)))

Tactic:
have C : ¬1 + i < N := by omega

Result:
α : Type u_1
inst✝¹ : LinearOrder α
E : Type u_2
inst✝ : PseudoEMetricSpace E
f : α → E
s : Set α
x : α
hx : x ∈ s
u : ℕ → α
hu : Monotone u
us : ∀ (i : ℕ), u i ∈ s
n : ℕ
h : x < u n
exists_N : ∃ N ≤ n, x < u N
N : ℕ := Nat.find exists_N
hN : N ≤ n ∧ x < u N
w : ℕ → α := fun i => if i < N then u i else if i = N then x else u (i - 1)
ws : ∀ (i : ℕ), w i ∈ s
hw : Monotone w
Npos : 0 < N
i : ℕ
hi : N ≤ i ∧ i < n
A : ¬1 + i + 1 < N
B : ¬1 + i + 1 = N
C : ¬1 + i < N
⊢ edist (f (u (i + 1))) (f (u i)) =
    edist (f (if 1 + i + 1 < N then u (1 + i + 1) else if 1 + i + 1 = N then x else u (1 + i + 1 - 1)))
      (f (if 1 + i < N then u (1 + i) else if 1 + i = N then x else u (1 + i - 1)))

Proof state:
case inr.inr
α : Type u_1
inst✝¹ : LinearOrder α
E : Type u_2
inst✝ : PseudoEMetricSpace E
f : α → E
s : Set α
x : α
hx : x ∈ s
u : ℕ → α
hu : Monotone u
us : ∀ (i : ℕ), u i ∈ s
n : ℕ
h : u n ≤ x
v : ℕ → α := fun i => if i ≤ n then u i else x
vs : ∀ (i : ℕ), v i ∈ s
i : ℕ
hi : n < i
A : ¬i ≤ n
B : ¬i + 1 ≤ n
⊢ (if i ≤ n then u i else x) ≤ if i + 1 ≤ n then u (i + 1) else x

Tactic:
simp only [A, B, if_false, le_rfl]

Result:
no goals

Proof state:
α : Type u_1
inst✝¹ : LinearOrder α
E : Type u_2
inst✝ : PseudoEMetricSpace E
f : α → E
s : Set α
x : α
hx : x ∈ s
u : ℕ → α
hu : Monotone u
us : ∀ (i : ℕ), u i ∈ s
n : ℕ
h : x < u n
exists_N : ∃ N ≤ n, x < u N
N : ℕ := Nat.find exists_N
hN : N ≤ n ∧ x < u N
w : ℕ → α := fun i => if i < N then u i else if i = N then x else u (i - 1)
ws : ∀ (i : ℕ), w i ∈ s
hw : Monotone w
Npos : 0 = N
⊢ Finset.Ico 1 (n + 1) ⊆ Finset.Ico 0 (n + 1)

Tactic:
exact Finset.Ico_subset_Ico zero_le_one le_rfl

Result:
no goals