-- Mathlib/.lake/packages/lean4/src/lean/Init/Data/List/Sort/Lemmas.lean
theorem mergeSort_cons {le : α → α → Bool}
    (trans : ∀ (a b c : α), le a b → le b c → le a c)
    (total : ∀ (a b : α), le a b || le b a)
    (a : α) (l : List α) :
    ∃ l₁ l₂, mergeSort (a :: l) le = l₁ ++ a :: l₂ ∧ mergeSort l le = l₁ ++ l₂ ∧
      ∀ b, b ∈ l₁ → !le a b

Proof state:
α : Type u_1
le : α → α → Bool
trans : ∀ (a b c : α), le a b = true → le b c = true → le a c = true
total : ∀ (a b : α), (le a b || le b a) = true
a : α
l : List α
nd : (map (fun x => x.snd) (a :: l).zipIdx).Nodup
m₁ : (a, 0) ∈ (a :: l).zipIdx.mergeSort (zipIdxLE le)
⊢ ∃ l₁ l₂,
    map (fun x => x.fst) (((a, 0) :: l.zipIdx (0 + 1)).mergeSort (zipIdxLE le)) = l₁ ++ a :: l₂ ∧
      l.mergeSort le = l₁ ++ l₂ ∧ ∀ (b : α), b ∈ l₁ → (!le a b) = true

Tactic:
obtain ⟨l₁, l₂, h⟩ := append_of_mem m₁

Result:
case intro.intro
α : Type u_1
le : α → α → Bool
trans : ∀ (a b c : α), le a b = true → le b c = true → le a c = true
total : ∀ (a b : α), (le a b || le b a) = true
a : α
l : List α
nd : (map (fun x => x.snd) (a :: l).zipIdx).Nodup
m₁ : (a, 0) ∈ (a :: l).zipIdx.mergeSort (zipIdxLE le)
l₁ l₂ : List (α × Nat)
h : (a :: l).zipIdx.mergeSort (zipIdxLE le) = l₁ ++ (a, 0) :: l₂
⊢ ∃ l₁ l₂,
    map (fun x => x.fst) (((a, 0) :: l.zipIdx (0 + 1)).mergeSort (zipIdxLE le)) = l₁ ++ a :: l₂ ∧
      l.mergeSort le = l₁ ++ l₂ ∧ ∀ (b : α), b ∈ l₁ → (!le a b) = true

Proof state:
α : Type u_1
le : α → α → Bool
trans : ∀ (a b c : α), le a b = true → le b c = true → le a c = true
total : ∀ (a b : α), (le a b || le b a) = true
a : α
l : List α
⊢ ∃ l₁ l₂,
    map (fun x => x.fst) ((a :: l).zipIdx.mergeSort (zipIdxLE le)) = l₁ ++ a :: l₂ ∧
      l.mergeSort le = l₁ ++ l₂ ∧ ∀ (b : α), b ∈ l₁ → (!le a b) = true

Tactic:
rw [zipIdx_cons]

Result:
α : Type u_1
le : α → α → Bool
trans : ∀ (a b c : α), le a b = true → le b c = true → le a c = true
total : ∀ (a b : α), (le a b || le b a) = true
a : α
l : List α
⊢ ∃ l₁ l₂,
    map (fun x => x.fst) (((a, 0) :: l.zipIdx (0 + 1)).mergeSort (zipIdxLE le)) = l₁ ++ a :: l₂ ∧
      l.mergeSort le = l₁ ++ l₂ ∧ ∀ (b : α), b ∈ l₁ → (!le a b) = true

Proof state:
case intro.intro.refine_3.intro.intro.intro
α : Type u_1
le : α → α → Bool
trans : ∀ (a b c : α), le a b = true → le b c = true → le a c = true
total : ∀ (a b : α), (le a b || le b a) = true
a : α
l : List α
nd : (map (fun x => x.snd) (a :: l).zipIdx).Nodup
m₁ : (a, 0) ∈ (a :: l).zipIdx.mergeSort (zipIdxLE le)
l₁ l₂ : List (α × Nat)
h : (a :: l).zipIdx.mergeSort (zipIdxLE le) = l₁ ++ (a, 0) :: l₂
s : Pairwise (fun a b => zipIdxLE le a b = true) (l₁ ++ (a, 0) :: l₂)
j : α
w✝ : Nat
m : (j, w✝) ∈ l₁
p : map (fun x => x.snd) (l₁ ++ (a, 0) :: l₂) ~ map (fun x => x.snd) (a :: l).zipIdx
⊢ (!le a j) = true

Tactic:
have nd' := nd.perm p.symm

Result:
case intro.intro.refine_3.intro.intro.intro
α : Type u_1
le : α → α → Bool
trans : ∀ (a b c : α), le a b = true → le b c = true → le a c = true
total : ∀ (a b : α), (le a b || le b a) = true
a : α
l : List α
nd : (map (fun x => x.snd) (a :: l).zipIdx).Nodup
m₁ : (a, 0) ∈ (a :: l).zipIdx.mergeSort (zipIdxLE le)
l₁ l₂ : List (α × Nat)
h : (a :: l).zipIdx.mergeSort (zipIdxLE le) = l₁ ++ (a, 0) :: l₂
s : Pairwise (fun a b => zipIdxLE le a b = true) (l₁ ++ (a, 0) :: l₂)
j : α
w✝ : Nat
m : (j, w✝) ∈ l₁
p : map (fun x => x.snd) (l₁ ++ (a, 0) :: l₂) ~ map (fun x => x.snd) (a :: l).zipIdx
nd' : (map (fun x => x.snd) (l₁ ++ (a, 0) :: l₂)).Nodup
⊢ (!le a j) = true

Proof state:
case intro.intro.refine_2.e_a.x.mk.mk
α : Type u_1
le : α → α → Bool
trans : ∀ (a b c : α), le a b = true → le b c = true → le a c = true
total : ∀ (a b : α), (le a b || le b a) = true
a✝ : α
l : List α
nd : (map (fun x => x.snd) (a✝ :: l).zipIdx).Nodup
m₁ : (a✝, 0) ∈ (a✝ :: l).zipIdx.mergeSort (zipIdxLE le)
l₁ l₂ : List (α × Nat)
h✝ : (a✝ :: l).zipIdx.mergeSort (zipIdxLE le) = l₁ ++ (a✝, 0) :: l₂
s : Pairwise (fun a b => zipIdxLE le a b = true) (l₁ ++ (a✝, 0) :: l₂)
p : l₁ ++ (a✝, 0) :: l₂ ~ (a✝ :: l).zipIdx
q : (l.zipIdx 1).mergeSort (zipIdxLE le) ~ l₁ ++ l₂
a : α
i : Nat
b : α
j : Nat
ha : (a, i) ∈ l.zipIdx 1
hb : (b, j) ∈ l.zipIdx 1
ab : decide (le a b = true) = true
ba : le b a = true
h : i ≤ j
h' : j ≤ i
⊢ a = b ∧ i = j

Tactic:
cases Nat.le_antisymm h h'

Result:
case intro.intro.refine_2.e_a.x.mk.mk.refl
α : Type u_1
le : α → α → Bool
trans : ∀ (a b c : α), le a b = true → le b c = true → le a c = true
total : ∀ (a b : α), (le a b || le b a) = true
a✝ : α
l : List α
nd : (map (fun x => x.snd) (a✝ :: l).zipIdx).Nodup
m₁ : (a✝, 0) ∈ (a✝ :: l).zipIdx.mergeSort (zipIdxLE le)
l₁ l₂ : List (α × Nat)
h✝ : (a✝ :: l).zipIdx.mergeSort (zipIdxLE le) = l₁ ++ (a✝, 0) :: l₂
s : Pairwise (fun a b => zipIdxLE le a b = true) (l₁ ++ (a✝, 0) :: l₂)
p : l₁ ++ (a✝, 0) :: l₂ ~ (a✝ :: l).zipIdx
q : (l.zipIdx 1).mergeSort (zipIdxLE le) ~ l₁ ++ l₂
a : α
i : Nat
b : α
ha : (a, i) ∈ l.zipIdx 1
ab : decide (le a b = true) = true
ba : le b a = true
hb : (b, i) ∈ l.zipIdx 1
h h' : i ≤ i
⊢ a = b ∧ i = i

Proof state:
case intro.intro.refine_2.e_a.x.mk.mk
α : Type u_1
le : α → α → Bool
trans : ∀ (a b c : α), le a b = true → le b c = true → le a c = true
total : ∀ (a b : α), (le a b || le b a) = true
a✝ : α
l : List α
nd : (map (fun x => x.snd) (a✝ :: l).zipIdx).Nodup
m₁ : (a✝, 0) ∈ (a✝ :: l).zipIdx.mergeSort (zipIdxLE le)
l₁ l₂ : List (α × Nat)
h : (a✝ :: l).zipIdx.mergeSort (zipIdxLE le) = l₁ ++ (a✝, 0) :: l₂
s : Pairwise (fun a b => zipIdxLE le a b = true) (l₁ ++ (a✝, 0) :: l₂)
p : l₁ ++ (a✝, 0) :: l₂ ~ (a✝ :: l).zipIdx
q : (l.zipIdx 1).mergeSort (zipIdxLE le) ~ l₁ ++ l₂
a : α
i : Nat
b : α
j : Nat
ha : (a, i) ∈ l.zipIdx 1
hb : (b, j) ∈ l.zipIdx 1
⊢ (if le a b = true then if le b a = true then decide (i ≤ j) else true else false) = true →
    (if le b a = true then if le a b = true then decide (j ≤ i) else true else false) = true → (a, i) = (b, j)

Tactic:
simp only [Bool.if_false_right, Bool.and_eq_true, Prod.mk.injEq, and_imp]

Result:
case intro.intro.refine_2.e_a.x.mk.mk
α : Type u_1
le : α → α → Bool
trans : ∀ (a b c : α), le a b = true → le b c = true → le a c = true
total : ∀ (a b : α), (le a b || le b a) = true
a✝ : α
l : List α
nd : (map (fun x => x.snd) (a✝ :: l).zipIdx).Nodup
m₁ : (a✝, 0) ∈ (a✝ :: l).zipIdx.mergeSort (zipIdxLE le)
l₁ l₂ : List (α × Nat)
h : (a✝ :: l).zipIdx.mergeSort (zipIdxLE le) = l₁ ++ (a✝, 0) :: l₂
s : Pairwise (fun a b => zipIdxLE le a b = true) (l₁ ++ (a✝, 0) :: l₂)
p : l₁ ++ (a✝, 0) :: l₂ ~ (a✝ :: l).zipIdx
q : (l.zipIdx 1).mergeSort (zipIdxLE le) ~ l₁ ++ l₂
a : α
i : Nat
b : α
j : Nat
ha : (a, i) ∈ l.zipIdx 1
hb : (b, j) ∈ l.zipIdx 1
⊢ decide (le a b = true) = true →
    (if le b a = true then decide (i ≤ j) else true) = true →
      decide (le b a = true) = true → (if le a b = true then decide (j ≤ i) else true) = true → a = b ∧ i = j

Proof state:
case intro.intro.refine_3
α : Type u_1
le : α → α → Bool
trans : ∀ (a b c : α), le a b = true → le b c = true → le a c = true
total : ∀ (a b : α), (le a b || le b a) = true
a : α
l : List α
nd : (map (fun x => x.snd) (a :: l).zipIdx).Nodup
m₁ : (a, 0) ∈ (a :: l).zipIdx.mergeSort (zipIdxLE le)
l₁ l₂ : List (α × Nat)
h : (a :: l).zipIdx.mergeSort (zipIdxLE le) = l₁ ++ (a, 0) :: l₂
s : Pairwise (fun a b => zipIdxLE le a b = true) (l₁ ++ (a, 0) :: l₂)
p : l₁ ++ (a, 0) :: l₂ ~ (a :: l).zipIdx
b : α
m : ∃ a b_1, (a, b_1) ∈ l₁ ∧ a = b
⊢ (!le a b) = true

Tactic:
obtain ⟨j, _, m, rfl⟩ := m

Result:
case intro.intro.refine_3.intro.intro.intro
α : Type u_1
le : α → α → Bool
trans : ∀ (a b c : α), le a b = true → le b c = true → le a c = true
total : ∀ (a b : α), (le a b || le b a) = true
a : α
l : List α
nd : (map (fun x => x.snd) (a :: l).zipIdx).Nodup
m₁ : (a, 0) ∈ (a :: l).zipIdx.mergeSort (zipIdxLE le)
l₁ l₂ : List (α × Nat)
h : (a :: l).zipIdx.mergeSort (zipIdxLE le) = l₁ ++ (a, 0) :: l₂
s : Pairwise (fun a b => zipIdxLE le a b = true) (l₁ ++ (a, 0) :: l₂)
p : l₁ ++ (a, 0) :: l₂ ~ (a :: l).zipIdx
j : α
w✝ : Nat
m : (j, w✝) ∈ l₁
⊢ (!le a j) = true