-- Mathlib/.lake/packages/lean4/src/lean/Init/Data/List/Lex.lean
theorem lex_eq_false_iff_exists [BEq α] [PartialEquivBEq α] (lt : α → α → Bool)
    (lt_irrefl : ∀ x y, x == y → lt x y = false)
    (lt_asymm : ∀ x y, lt x y = true → lt y x = false)
    (lt_antisymm : ∀ x y, lt x y = false → lt y x = false → x == y) :
    lex l₁ l₂ lt = false ↔
      (l₂.isEqv (l₁.take l₂.length) (· == ·)) ∨
        (∃ (i : Nat) (h₁ : i < l₁.length) (h₂ : i < l₂.length),
          (∀ j, (hj : j < i) →
            l₁[j]'(Nat.lt_trans hj h₁) == l₂[j]'(Nat.lt_trans hj h₂)) ∧ lt l₂[i] l₁[i])

Proof state:
case cons.cons.mpr.inr.intro.intro.intro.intro.succ
α : Type u_1
inst✝¹ : BEq α
inst✝ : PartialEquivBEq α
lt : α → α → Bool
lt_irrefl : ∀ (x y : α), (x == y) = true → lt x y = false
lt_asymm : ∀ (x y : α), lt x y = true → lt y x = false
lt_antisymm : ∀ (x y : α), lt x y = false → lt y x = false → (x == y) = true
a : α
l₁ : List α
ih :
  ∀ {l₂ : List α},
    l₁.lex l₂ lt = false ↔
      (l₂.isEqv (take l₂.length l₁) fun x1 x2 => x1 == x2) = true ∨
        ∃ i h₁ h₂, (∀ (j : Nat) (hj : j < i), (l₁[j] == l₂[j]) = true) ∧ lt l₂[i] l₁[i] = true
b : α
l₂ : List α
i : Nat
h₁ : i + 1 < l₁.length + 1
h₂ : i + 1 < l₂.length + 1
w₁ : ∀ (j : Nat) (hj : j < i + 1), ((a :: l₁)[j] == (b :: l₂)[j]) = true
w₂ : lt (b :: l₂)[i + 1] (a :: l₁)[i + 1] = true
⊢ lt a b = false ∧
    ((a == b) = true →
      (l₂.isEqv (take l₂.length l₁) fun x1 x2 => x1 == x2) = true ∨
        ∃ i h₁ h₂, (∀ (j : Nat) (hj : j < i), (l₁[j] == l₂[j]) = true) ∧ lt l₂[i] l₁[i] = true)

Tactic:
refine ⟨lt_irrefl _ _ (by simpa using w₁ 0 (by simp)), ?_⟩

Result:
case cons.cons.mpr.inr.intro.intro.intro.intro.succ
α : Type u_1
inst✝¹ : BEq α
inst✝ : PartialEquivBEq α
lt : α → α → Bool
lt_irrefl : ∀ (x y : α), (x == y) = true → lt x y = false
lt_asymm : ∀ (x y : α), lt x y = true → lt y x = false
lt_antisymm : ∀ (x y : α), lt x y = false → lt y x = false → (x == y) = true
a : α
l₁ : List α
ih :
  ∀ {l₂ : List α},
    l₁.lex l₂ lt = false ↔
      (l₂.isEqv (take l₂.length l₁) fun x1 x2 => x1 == x2) = true ∨
        ∃ i h₁ h₂, (∀ (j : Nat) (hj : j < i), (l₁[j] == l₂[j]) = true) ∧ lt l₂[i] l₁[i] = true
b : α
l₂ : List α
i : Nat
h₁ : i + 1 < l₁.length + 1
h₂ : i + 1 < l₂.length + 1
w₁ : ∀ (j : Nat) (hj : j < i + 1), ((a :: l₁)[j] == (b :: l₂)[j]) = true
w₂ : lt (b :: l₂)[i + 1] (a :: l₁)[i + 1] = true
⊢ (a == b) = true →
    (l₂.isEqv (take l₂.length l₁) fun x1 x2 => x1 == x2) = true ∨
      ∃ i h₁ h₂, (∀ (j : Nat) (hj : j < i), (l₁[j] == l₂[j]) = true) ∧ lt l₂[i] l₁[i] = true

Proof state:
α : Type u_1
inst✝¹ : BEq α
inst✝ : PartialEquivBEq α
lt : α → α → Bool
lt_irrefl : ∀ (x y : α), (x == y) = true → lt x y = false
lt_asymm : ∀ (x y : α), lt x y = true → lt y x = false
lt_antisymm : ∀ (x y : α), lt x y = false → lt y x = false → (x == y) = true
a : α
l₁ : List α
ih :
  ∀ {l₂ : List α},
    l₁.lex l₂ lt = false ↔
      (l₂.isEqv (take l₂.length l₁) fun x1 x2 => x1 == x2) = true ∨
        ∃ i h₁ h₂, (∀ (j : Nat) (hj : j < i), (l₁[j] == l₂[j]) = true) ∧ lt l₂[i] l₁[i] = true
b : α
l₂ : List α
i : Nat
h₁ : i + 1 < l₁.length + 1
h₂ : i + 1 < l₂.length + 1
w₁ : ∀ (j : Nat) (hj : j < i + 1), ((a :: l₁)[j] == (b :: l₂)[j]) = true
w₂ : lt (b :: l₂)[i + 1] (a :: l₁)[i + 1] = true
x✝ : (a == b) = true
⊢ i < l₂.length

Tactic:
simpa using h₂

Result:
no goals

Proof state:
case inr.intro.intro.intro.intro
α : Type u_1
inst✝¹ : BEq α
inst✝ : PartialEquivBEq α
lt : α → α → Bool
lt_irrefl : ∀ (x y : α), (x == y) = true → lt x y = false
lt_asymm : ∀ (x y : α), lt x y = true → lt y x = false
lt_antisymm : ∀ (x y : α), lt x y = false → lt y x = false → (x == y) = true
a : α
l₁ : List α
ih :
  ∀ {l₂ : List α},
    l₁.lex l₂ lt = false ↔
      (l₂.isEqv (take l₂.length l₁) fun x1 x2 => x1 == x2) = true ∨
        ∃ i h₁ h₂, (∀ (j : Nat) (hj : j < i), (l₁[j] == l₂[j]) = true) ∧ lt l₂[i] l₁[i] = true
b : α
l₂ : List α
hab : lt a b = false
eq : (b == a) = true
i : Nat
h₁ : i < l₁.length
h₂ : i < l₂.length
w₁ : ∀ (j : Nat) (hj : j < i), (l₁[j] == l₂[j]) = true
w₂ : lt l₂[i] l₁[i] = true
⊢ (b == a) = true ∧ (l₂.isEqv (take l₂.length l₁) fun x1 x2 => x1 == x2) = true ∨
    ∃ i h h₂, (∀ (j : Nat) (hj : j < i), ((a :: l₁)[j] == (b :: l₂)[j]) = true) ∧ lt (b :: l₂)[i] (a :: l₁)[i] = true

Tactic:
refine .inr ⟨i + 1, by simpa using h₁, by simpa using h₂, ?_, ?_⟩

Result:
case inr.intro.intro.intro.intro.refine_1
α : Type u_1
inst✝¹ : BEq α
inst✝ : PartialEquivBEq α
lt : α → α → Bool
lt_irrefl : ∀ (x y : α), (x == y) = true → lt x y = false
lt_asymm : ∀ (x y : α), lt x y = true → lt y x = false
lt_antisymm : ∀ (x y : α), lt x y = false → lt y x = false → (x == y) = true
a : α
l₁ : List α
ih :
  ∀ {l₂ : List α},
    l₁.lex l₂ lt = false ↔
      (l₂.isEqv (take l₂.length l₁) fun x1 x2 => x1 == x2) = true ∨
        ∃ i h₁ h₂, (∀ (j : Nat) (hj : j < i), (l₁[j] == l₂[j]) = true) ∧ lt l₂[i] l₁[i] = true
b : α
l₂ : List α
hab : lt a b = false
eq : (b == a) = true
i : Nat
h₁ : i < l₁.length
h₂ : i < l₂.length
w₁ : ∀ (j : Nat) (hj : j < i), (l₁[j] == l₂[j]) = true
w₂ : lt l₂[i] l₁[i] = true
⊢ ∀ (j : Nat) (hj : j < i + 1), ((a :: l₁)[j] == (b :: l₂)[j]) = true

case inr.intro.intro.intro.intro.refine_2
α : Type u_1
inst✝¹ : BEq α
inst✝ : PartialEquivBEq α
lt : α → α → Bool
lt_irrefl : ∀ (x y : α), (x == y) = true → lt x y = false
lt_asymm : ∀ (x y : α), lt x y = true → lt y x = false
lt_antisymm : ∀ (x y : α), lt x y = false → lt y x = false → (x == y) = true
a : α
l₁ : List α
ih :
  ∀ {l₂ : List α},
    l₁.lex l₂ lt = false ↔
      (l₂.isEqv (take l₂.length l₁) fun x1 x2 => x1 == x2) = true ∨
        ∃ i h₁ h₂, (∀ (j : Nat) (hj : j < i), (l₁[j] == l₂[j]) = true) ∧ lt l₂[i] l₁[i] = true
b : α
l₂ : List α
hab : lt a b = false
eq : (b == a) = true
i : Nat
h₁ : i < l₁.length
h₂ : i < l₂.length
w₁ : ∀ (j : Nat) (hj : j < i), (l₁[j] == l₂[j]) = true
w₂ : lt l₂[i] l₁[i] = true
⊢ lt (b :: l₂)[i + 1] (a :: l₁)[i + 1] = true

Proof state:
case cons.cons
α : Type u_1
inst✝¹ : BEq α
inst✝ : PartialEquivBEq α
lt : α → α → Bool
lt_irrefl : ∀ (x y : α), (x == y) = true → lt x y = false
lt_asymm : ∀ (x y : α), lt x y = true → lt y x = false
lt_antisymm : ∀ (x y : α), lt x y = false → lt y x = false → (x == y) = true
a : α
l₁ : List α
ih :
  ∀ {l₂ : List α},
    l₁.lex l₂ lt = false ↔
      (l₂.isEqv (take l₂.length l₁) fun x1 x2 => x1 == x2) = true ∨
        ∃ i h₁ h₂, (∀ (j : Nat) (hj : j < i), (l₁[j] == l₂[j]) = true) ∧ lt l₂[i] l₁[i] = true
b : α
l₂ : List α
⊢ (a :: l₁).lex (b :: l₂) lt = false ↔
    ((b :: l₂).isEqv (take (b :: l₂).length (a :: l₁)) fun x1 x2 => x1 == x2) = true ∨
      ∃ i h₁ h₂, (∀ (j : Nat) (hj : j < i), ((a :: l₁)[j] == (b :: l₂)[j]) = true) ∧ lt (b :: l₂)[i] (a :: l₁)[i] = true

Tactic:
simp [lex_cons_cons, Bool.or_eq_false_iff, Bool.and_eq_false_imp, ih, isEqv,
  Bool.and_eq_true, length_cons]

Result:
case cons.cons
α : Type u_1
inst✝¹ : BEq α
inst✝ : PartialEquivBEq α
lt : α → α → Bool
lt_irrefl : ∀ (x y : α), (x == y) = true → lt x y = false
lt_asymm : ∀ (x y : α), lt x y = true → lt y x = false
lt_antisymm : ∀ (x y : α), lt x y = false → lt y x = false → (x == y) = true
a : α
l₁ : List α
ih :
  ∀ {l₂ : List α},
    l₁.lex l₂ lt = false ↔
      (l₂.isEqv (take l₂.length l₁) fun x1 x2 => x1 == x2) = true ∨
        ∃ i h₁ h₂, (∀ (j : Nat) (hj : j < i), (l₁[j] == l₂[j]) = true) ∧ lt l₂[i] l₁[i] = true
b : α
l₂ : List α
⊢ lt a b = false ∧
      ((a == b) = true →
        (l₂.isEqv (take l₂.length l₁) fun x1 x2 => x1 == x2) = true ∨
          ∃ i h₁ h₂, (∀ (j : Nat) (hj : j < i), (l₁[j] == l₂[j]) = true) ∧ lt l₂[i] l₁[i] = true) ↔
    (b == a) = true ∧ (l₂.isEqv (take l₂.length l₁) fun x1 x2 => x1 == x2) = true ∨
      ∃ i h h₂, (∀ (j : Nat) (hj : j < i), ((a :: l₁)[j] == (b :: l₂)[j]) = true) ∧ lt (b :: l₂)[i] (a :: l₁)[i] = true