Theorem: levenshtein_nil_cons
File: Mathlib/Data/List/EditDistance/Defs.lean

tactic: dsimp (config := { unfoldPartialApp := true }) [levenshtein, suffixLevenshtein, impl]
state_before: α : Type u_1
β : Type u_2
δ : Type u_3
inst✝¹ : AddZeroClass δ
inst✝ : Min δ
C : Cost α β δ
y : β
ys : List β
⊢ levenshtein C [] (y :: ys) = C.insert y + levenshtein C [] ys
state_after: α : Type u_1
β : Type u_2
δ : Type u_3
inst✝¹ : AddZeroClass δ
inst✝ : Min δ
C : Cost α β δ
y : β
ys : List β
⊢ C.insert y +
      (List.foldr (fun y d => ⟨[C.insert y + d.val.getLast ⋯], impl.proof_3⟩) ⟨[0], suffixLevenshtein.proof_2⟩
              ys).val.getLast
        ⋯ =
    C.insert y +
      (List.foldr (fun y d => ⟨[C.insert y + d.val.getLast ⋯], impl.proof_3⟩) ⟨[0], suffixLevenshtein.proof_2⟩
            ys).val[0]

tactic: congr
state_before: α : Type u_1
β : Type u_2
δ : Type u_3
inst✝¹ : AddZeroClass δ
inst✝ : Min δ
C : Cost α β δ
y : β
ys : List β
⊢ C.insert y +
      (List.foldr (fun y d => ⟨[C.insert y + d.val.getLast ⋯], impl.proof_3⟩) ⟨[0], suffixLevenshtein.proof_2⟩
              ys).val.getLast
        ⋯ =
    C.insert y +
      (List.foldr (fun y d => ⟨[C.insert y + d.val.getLast ⋯], impl.proof_3⟩) ⟨[0], suffixLevenshtein.proof_2⟩
            ys).val[0]
state_after: case e_a
α : Type u_1
β : Type u_2
δ : Type u_3
inst✝¹ : AddZeroClass δ
inst✝ : Min δ
C : Cost α β δ
y : β
ys : List β
⊢ (List.foldr (fun y d => ⟨[C.insert y + d.val.getLast ⋯], impl.proof_3⟩) ⟨[0], suffixLevenshtein.proof_2⟩
            ys).val.getLast
      ⋯ =
    (List.foldr (fun y d => ⟨[C.insert y + d.val.getLast ⋯], impl.proof_3⟩) ⟨[0], suffixLevenshtein.proof_2⟩ ys).val[0]

tactic: rw [List.getLast_eq_get]
state_before: case e_a
α : Type u_1
β : Type u_2
δ : Type u_3
inst✝¹ : AddZeroClass δ
inst✝ : Min δ
C : Cost α β δ
y : β
ys : List β
⊢ (List.foldr (fun y d => ⟨[C.insert y + d.val.getLast ⋯], impl.proof_3⟩) ⟨[0], suffixLevenshtein.proof_2⟩
            ys).val.getLast
      ⋯ =
    (List.foldr (fun y d => ⟨[C.insert y + d.val.getLast ⋯], impl.proof_3⟩) ⟨[0], suffixLevenshtein.proof_2⟩ ys).val[0]
state_after: case e_a
α : Type u_1
β : Type u_2
δ : Type u_3
inst✝¹ : AddZeroClass δ
inst✝ : Min δ
C : Cost α β δ
y : β
ys : List β
⊢ (List.foldr (fun y d => ⟨[C.insert y + d.val.getLast ⋯], impl.proof_3⟩) ⟨[0], suffixLevenshtein.proof_2⟩ ys).val.get
      ⟨(List.foldr (fun y d => ⟨[C.insert y + d.val.getLast ⋯], impl.proof_3⟩) ⟨[0], suffixLevenshtein.proof_2⟩
                ys).val.length -
          1,
        ⋯⟩ =
    (List.foldr (fun y d => ⟨[C.insert y + d.val.getLast ⋯], impl.proof_3⟩) ⟨[0], suffixLevenshtein.proof_2⟩ ys).val[0]

tactic: congr
state_before: case e_a
α : Type u_1
β : Type u_2
δ : Type u_3
inst✝¹ : AddZeroClass δ
inst✝ : Min δ
C : Cost α β δ
y : β
ys : List β
⊢ (List.foldr (fun y d => ⟨[C.insert y + d.val.getLast ⋯], impl.proof_3⟩) ⟨[0], suffixLevenshtein.proof_2⟩ ys).val.get
      ⟨(List.foldr (fun y d => ⟨[C.insert y + d.val.getLast ⋯], impl.proof_3⟩) ⟨[0], suffixLevenshtein.proof_2⟩
                ys).val.length -
          1,
        ⋯⟩ =
    (List.foldr (fun y d => ⟨[C.insert y + d.val.getLast ⋯], impl.proof_3⟩) ⟨[0], suffixLevenshtein.proof_2⟩ ys).val[0]
state_after: case e_a.e_a.e_val
α : Type u_1
β : Type u_2
δ : Type u_3
inst✝¹ : AddZeroClass δ
inst✝ : Min δ
C : Cost α β δ
y : β
ys : List β
⊢ (List.foldr (fun y d => ⟨[C.insert y + d.val.getLast ⋯], impl.proof_3⟩) ⟨[0], suffixLevenshtein.proof_2⟩
            ys).val.length -
      1 =
    0

tactic: rw [show (List.length _) = 1 from _]
state_before: case e_a.e_a.e_val
α : Type u_1
β : Type u_2
δ : Type u_3
inst✝¹ : AddZeroClass δ
inst✝ : Min δ
C : Cost α β δ
y : β
ys : List β
⊢ (List.foldr (fun y d => ⟨[C.insert y + d.val.getLast ⋯], impl.proof_3⟩) ⟨[0], suffixLevenshtein.proof_2⟩
            ys).val.length -
      1 =
    0
state_after: α : Type u_1
β : Type u_2
δ : Type u_3
inst✝¹ : AddZeroClass δ
inst✝ : Min δ
C : Cost α β δ
y : β
ys : List β
⊢ (List.foldr (fun y d => ⟨[C.insert y + d.val.getLast ⋯], impl.proof_3⟩) ⟨[0], suffixLevenshtein.proof_2⟩
          ys).val.length =
    1

tactic: induction ys <;> simp
state_before: α : Type u_1
β : Type u_2
δ : Type u_3
inst✝¹ : AddZeroClass δ
inst✝ : Min δ
C : Cost α β δ
y : β
ys : List β
⊢ (List.foldr (fun y d => ⟨[C.insert y + d.val.getLast ⋯], impl.proof_3⟩) ⟨[0], suffixLevenshtein.proof_2⟩
          ys).val.length =
    1
state_after: no goals