match a, b with
  | ⟨[], _⟩  , ⟨[], _⟩     => simp
  | ⟨x::xs, _⟩, ⟨y::ys, _⟩ => split
                              simp
                              split
                              rw [Order.ble_lex_impl] at h
                              simp at h
                              split at h
                              exact aux (m-1) (tail ⟨x::xs, _⟩) (tail ⟨y::ys, _⟩) h
                              simp at *
                              rename_i heq₁ hneq heq₂ heq₃
                              have eq₁ := heq₂.left
                              have eq₂ := heq₃.left
                              rw [eq₁, eq₂] at hneq
                              contradiction                                  
                              rename_i heq₁ heq₂ hneq₁ 
                              rw [Order.ble_lex_impl] at h
                              split at h
                              simp at *
                              split at h
                              rename_i heq₃ heq₄ hneq₂
                              simp at heq₁ heq₂ heq₃ heq₄ hneq₂
                              have eq₁ := heq₁.left
                              have eq₂ := heq₂.left
                              have eq₃ := heq₃.left
                              have eq₄ := heq₄.left
                              rw [eq₁] at eq₃
                              rw [eq₂] at eq₄
                              rw [eq₃, eq₄] at hneq₁
                              contradiction
                              simp at h
                              rename_i heq₁ heq₂ _ _ _ _ _ _ _ _ _ _ _ heq₃ heq₄ _ 
                              simp at heq₁ heq₂ heq₃ heq₄
                              have eq₁ := heq₁.left
                              have eq₂ := heq₂.left
                              have eq₃ := heq₃.left
                              have eq₄ := heq₄.left
                              rw [eq₁] at eq₃
                              rw [eq₂] at eq₄
                              rw [eq₃, eq₄]
                              exact h
n✝ : ℕ
v₁ v₂ : Vector ℕ n✝
h✝ : algebra.Order.ble_lex_impl v₁ v₂ = true
m : ℕ
a b : Vector ℕ m
h : algebra.Order.ble_lex_impl a b = true
⊢ match a, b with
  | { val := [], property := property }, { val := [], property := property_1 } => True
  | { val := x :: tail, property := property }, { val := y :: tail_1, property := property_1 } =>
    if x = y then lex_impl (Vector.tail a) (Vector.tail b) else x ≤ y
no goals