Theorem: List.eq_of_perm_of_sorted
File: Mathlib/Data/List/Sort.lean

tactic: induction' hs₁ with a l₁ h₁ hs₁ IH generalizing l₂
state_before: α : Type u
r : α → α → Prop
a : α
l : List α
inst✝ : IsAntisymm α r
l₁ l₂ : List α
hp : l₁ ~ l₂
hs₁ : Sorted r l₁
hs₂ : Sorted r l₂
⊢ l₁ = l₂
state_after: case nil
α : Type u
r : α → α → Prop
a : α
l : List α
inst✝ : IsAntisymm α r
l₁ l₂ : List α
hp : [] ~ l₂
hs₂ : Sorted r l₂
⊢ [] = l₂

case cons
α : Type u
r : α → α → Prop
a✝ : α
l : List α
inst✝ : IsAntisymm α r
l₁✝ : List α
a : α
l₁ : List α
h₁ : ∀ a' ∈ l₁, r a a'
hs₁ : Pairwise r l₁
IH : ∀ {l₂ : List α}, l₁ ~ l₂ → Sorted r l₂ → l₁ = l₂
l₂ : List α
hp : a :: l₁ ~ l₂
hs₂ : Sorted r l₂
⊢ a :: l₁ = l₂

tactic: exact hp.nil_eq
state_before: case nil
α : Type u
r : α → α → Prop
a : α
l : List α
inst✝ : IsAntisymm α r
l₁ l₂ : List α
hp : [] ~ l₂
hs₂ : Sorted r l₂
⊢ [] = l₂
state_after: no goals

tactic: have : a ∈ l₂ := hp.subset (mem_cons_self _ _)
state_before: case cons
α : Type u
r : α → α → Prop
a✝ : α
l : List α
inst✝ : IsAntisymm α r
l₁✝ : List α
a : α
l₁ : List α
h₁ : ∀ a' ∈ l₁, r a a'
hs₁ : Pairwise r l₁
IH : ∀ {l₂ : List α}, l₁ ~ l₂ → Sorted r l₂ → l₁ = l₂
l₂ : List α
hp : a :: l₁ ~ l₂
hs₂ : Sorted r l₂
⊢ a :: l₁ = l₂
state_after: case cons
α : Type u
r : α → α → Prop
a✝ : α
l : List α
inst✝ : IsAntisymm α r
l₁✝ : List α
a : α
l₁ : List α
h₁ : ∀ a' ∈ l₁, r a a'
hs₁ : Pairwise r l₁
IH : ∀ {l₂ : List α}, l₁ ~ l₂ → Sorted r l₂ → l₁ = l₂
l₂ : List α
hp : a :: l₁ ~ l₂
hs₂ : Sorted r l₂
this : a ∈ l₂
⊢ a :: l₁ = l₂

tactic: rcases append_of_mem this with ⟨u₂, v₂, rfl⟩
state_before: case cons
α : Type u
r : α → α → Prop
a✝ : α
l : List α
inst✝ : IsAntisymm α r
l₁✝ : List α
a : α
l₁ : List α
h₁ : ∀ a' ∈ l₁, r a a'
hs₁ : Pairwise r l₁
IH : ∀ {l₂ : List α}, l₁ ~ l₂ → Sorted r l₂ → l₁ = l₂
l₂ : List α
hp : a :: l₁ ~ l₂
hs₂ : Sorted r l₂
this : a ∈ l₂
⊢ a :: l₁ = l₂
state_after: case cons.intro.intro
α : Type u
r : α → α → Prop
a✝ : α
l : List α
inst✝ : IsAntisymm α r
l₁✝ : List α
a : α
l₁ : List α
h₁ : ∀ a' ∈ l₁, r a a'
hs₁ : Pairwise r l₁
IH : ∀ {l₂ : List α}, l₁ ~ l₂ → Sorted r l₂ → l₁ = l₂
u₂ v₂ : List α
hp : a :: l₁ ~ u₂ ++ a :: v₂
hs₂ : Sorted r (u₂ ++ a :: v₂)
this : a ∈ u₂ ++ a :: v₂
⊢ a :: l₁ = u₂ ++ a :: v₂

tactic: have hp' := (perm_cons a).1 (hp.trans perm_middle)
state_before: case cons.intro.intro
α : Type u
r : α → α → Prop
a✝ : α
l : List α
inst✝ : IsAntisymm α r
l₁✝ : List α
a : α
l₁ : List α
h₁ : ∀ a' ∈ l₁, r a a'
hs₁ : Pairwise r l₁
IH : ∀ {l₂ : List α}, l₁ ~ l₂ → Sorted r l₂ → l₁ = l₂
u₂ v₂ : List α
hp : a :: l₁ ~ u₂ ++ a :: v₂
hs₂ : Sorted r (u₂ ++ a :: v₂)
this : a ∈ u₂ ++ a :: v₂
⊢ a :: l₁ = u₂ ++ a :: v₂
state_after: case cons.intro.intro
α : Type u
r : α → α → Prop
a✝ : α
l : List α
inst✝ : IsAntisymm α r
l₁✝ : List α
a : α
l₁ : List α
h₁ : ∀ a' ∈ l₁, r a a'
hs₁ : Pairwise r l₁
IH : ∀ {l₂ : List α}, l₁ ~ l₂ → Sorted r l₂ → l₁ = l₂
u₂ v₂ : List α
hp : a :: l₁ ~ u₂ ++ a :: v₂
hs₂ : Sorted r (u₂ ++ a :: v₂)
this : a ∈ u₂ ++ a :: v₂
hp' : l₁ ~ u₂ ++ v₂
⊢ a :: l₁ = u₂ ++ a :: v₂

tactic: obtain rfl := IH hp' (hs₂.sublist <| by simp)
state_before: case cons.intro.intro
α : Type u
r : α → α → Prop
a✝ : α
l : List α
inst✝ : IsAntisymm α r
l₁✝ : List α
a : α
l₁ : List α
h₁ : ∀ a' ∈ l₁, r a a'
hs₁ : Pairwise r l₁
IH : ∀ {l₂ : List α}, l₁ ~ l₂ → Sorted r l₂ → l₁ = l₂
u₂ v₂ : List α
hp : a :: l₁ ~ u₂ ++ a :: v₂
hs₂ : Sorted r (u₂ ++ a :: v₂)
this : a ∈ u₂ ++ a :: v₂
hp' : l₁ ~ u₂ ++ v₂
⊢ a :: l₁ = u₂ ++ a :: v₂
state_after: case cons.intro.intro
α : Type u
r : α → α → Prop
a✝ : α
l : List α
inst✝ : IsAntisymm α r
l₁ : List α
a : α
u₂ v₂ : List α
hs₂ : Sorted r (u₂ ++ a :: v₂)
this : a ∈ u₂ ++ a :: v₂
h₁ : ∀ a' ∈ u₂ ++ v₂, r a a'
hs₁ : Pairwise r (u₂ ++ v₂)
IH : ∀ {l₂ : List α}, u₂ ++ v₂ ~ l₂ → Sorted r l₂ → u₂ ++ v₂ = l₂
hp : a :: (u₂ ++ v₂) ~ u₂ ++ a :: v₂
hp' : u₂ ++ v₂ ~ u₂ ++ v₂
⊢ a :: (u₂ ++ v₂) = u₂ ++ a :: v₂

tactic: change a :: u₂ ++ v₂ = u₂ ++ ([a] ++ v₂)
state_before: case cons.intro.intro
α : Type u
r : α → α → Prop
a✝ : α
l : List α
inst✝ : IsAntisymm α r
l₁ : List α
a : α
u₂ v₂ : List α
hs₂ : Sorted r (u₂ ++ a :: v₂)
this : a ∈ u₂ ++ a :: v₂
h₁ : ∀ a' ∈ u₂ ++ v₂, r a a'
hs₁ : Pairwise r (u₂ ++ v₂)
IH : ∀ {l₂ : List α}, u₂ ++ v₂ ~ l₂ → Sorted r l₂ → u₂ ++ v₂ = l₂
hp : a :: (u₂ ++ v₂) ~ u₂ ++ a :: v₂
hp' : u₂ ++ v₂ ~ u₂ ++ v₂
⊢ a :: (u₂ ++ v₂) = u₂ ++ a :: v₂
state_after: case cons.intro.intro
α : Type u
r : α → α → Prop
a✝ : α
l : List α
inst✝ : IsAntisymm α r
l₁ : List α
a : α
u₂ v₂ : List α
hs₂ : Sorted r (u₂ ++ a :: v₂)
this : a ∈ u₂ ++ a :: v₂
h₁ : ∀ a' ∈ u₂ ++ v₂, r a a'
hs₁ : Pairwise r (u₂ ++ v₂)
IH : ∀ {l₂ : List α}, u₂ ++ v₂ ~ l₂ → Sorted r l₂ → u₂ ++ v₂ = l₂
hp : a :: (u₂ ++ v₂) ~ u₂ ++ a :: v₂
hp' : u₂ ++ v₂ ~ u₂ ++ v₂
⊢ a :: u₂ ++ v₂ = u₂ ++ ([a] ++ v₂)

tactic: rw [← append_assoc]
state_before: case cons.intro.intro
α : Type u
r : α → α → Prop
a✝ : α
l : List α
inst✝ : IsAntisymm α r
l₁ : List α
a : α
u₂ v₂ : List α
hs₂ : Sorted r (u₂ ++ a :: v₂)
this : a ∈ u₂ ++ a :: v₂
h₁ : ∀ a' ∈ u₂ ++ v₂, r a a'
hs₁ : Pairwise r (u₂ ++ v₂)
IH : ∀ {l₂ : List α}, u₂ ++ v₂ ~ l₂ → Sorted r l₂ → u₂ ++ v₂ = l₂
hp : a :: (u₂ ++ v₂) ~ u₂ ++ a :: v₂
hp' : u₂ ++ v₂ ~ u₂ ++ v₂
⊢ a :: u₂ ++ v₂ = u₂ ++ ([a] ++ v₂)
state_after: case cons.intro.intro
α : Type u
r : α → α → Prop
a✝ : α
l : List α
inst✝ : IsAntisymm α r
l₁ : List α
a : α
u₂ v₂ : List α
hs₂ : Sorted r (u₂ ++ a :: v₂)
this : a ∈ u₂ ++ a :: v₂
h₁ : ∀ a' ∈ u₂ ++ v₂, r a a'
hs₁ : Pairwise r (u₂ ++ v₂)
IH : ∀ {l₂ : List α}, u₂ ++ v₂ ~ l₂ → Sorted r l₂ → u₂ ++ v₂ = l₂
hp : a :: (u₂ ++ v₂) ~ u₂ ++ a :: v₂
hp' : u₂ ++ v₂ ~ u₂ ++ v₂
⊢ a :: u₂ ++ v₂ = u₂ ++ [a] ++ v₂

tactic: congr
state_before: case cons.intro.intro
α : Type u
r : α → α → Prop
a✝ : α
l : List α
inst✝ : IsAntisymm α r
l₁ : List α
a : α
u₂ v₂ : List α
hs₂ : Sorted r (u₂ ++ a :: v₂)
this : a ∈ u₂ ++ a :: v₂
h₁ : ∀ a' ∈ u₂ ++ v₂, r a a'
hs₁ : Pairwise r (u₂ ++ v₂)
IH : ∀ {l₂ : List α}, u₂ ++ v₂ ~ l₂ → Sorted r l₂ → u₂ ++ v₂ = l₂
hp : a :: (u₂ ++ v₂) ~ u₂ ++ a :: v₂
hp' : u₂ ++ v₂ ~ u₂ ++ v₂
⊢ a :: u₂ ++ v₂ = u₂ ++ [a] ++ v₂
state_after: case cons.intro.intro.e_a
α : Type u
r : α → α → Prop
a✝ : α
l : List α
inst✝ : IsAntisymm α r
l₁ : List α
a : α
u₂ v₂ : List α
hs₂ : Sorted r (u₂ ++ a :: v₂)
this : a ∈ u₂ ++ a :: v₂
h₁ : ∀ a' ∈ u₂ ++ v₂, r a a'
hs₁ : Pairwise r (u₂ ++ v₂)
IH : ∀ {l₂ : List α}, u₂ ++ v₂ ~ l₂ → Sorted r l₂ → u₂ ++ v₂ = l₂
hp : a :: (u₂ ++ v₂) ~ u₂ ++ a :: v₂
hp' : u₂ ++ v₂ ~ u₂ ++ v₂
⊢ a :: u₂ = u₂ ++ [a]

tactic: have : ∀ x ∈ u₂, x = a := fun x m =>
  antisymm ((pairwise_append.1 hs₂).2.2 _ m a (mem_cons_self _ _)) (h₁ _ (by simp [m]))
state_before: case cons.intro.intro.e_a
α : Type u
r : α → α → Prop
a✝ : α
l : List α
inst✝ : IsAntisymm α r
l₁ : List α
a : α
u₂ v₂ : List α
hs₂ : Sorted r (u₂ ++ a :: v₂)
this : a ∈ u₂ ++ a :: v₂
h₁ : ∀ a' ∈ u₂ ++ v₂, r a a'
hs₁ : Pairwise r (u₂ ++ v₂)
IH : ∀ {l₂ : List α}, u₂ ++ v₂ ~ l₂ → Sorted r l₂ → u₂ ++ v₂ = l₂
hp : a :: (u₂ ++ v₂) ~ u₂ ++ a :: v₂
hp' : u₂ ++ v₂ ~ u₂ ++ v₂
⊢ a :: u₂ = u₂ ++ [a]
state_after: case cons.intro.intro.e_a
α : Type u
r : α → α → Prop
a✝ : α
l : List α
inst✝ : IsAntisymm α r
l₁ : List α
a : α
u₂ v₂ : List α
hs₂ : Sorted r (u₂ ++ a :: v₂)
this✝ : a ∈ u₂ ++ a :: v₂
h₁ : ∀ a' ∈ u₂ ++ v₂, r a a'
hs₁ : Pairwise r (u₂ ++ v₂)
IH : ∀ {l₂ : List α}, u₂ ++ v₂ ~ l₂ → Sorted r l₂ → u₂ ++ v₂ = l₂
hp : a :: (u₂ ++ v₂) ~ u₂ ++ a :: v₂
hp' : u₂ ++ v₂ ~ u₂ ++ v₂
this : ∀ x ∈ u₂, x = a
⊢ a :: u₂ = u₂ ++ [a]

tactic: rw [(@eq_replicate _ a (length u₂ + 1) (a :: u₂)).2,
    (@eq_replicate _ a (length u₂ + 1) (u₂ ++ [a])).2] <;>
    constructor <;>
  simp [iff_true_intro this, or_comm]
state_before: case cons.intro.intro.e_a
α : Type u
r : α → α → Prop
a✝ : α
l : List α
inst✝ : IsAntisymm α r
l₁ : List α
a : α
u₂ v₂ : List α
hs₂ : Sorted r (u₂ ++ a :: v₂)
this✝ : a ∈ u₂ ++ a :: v₂
h₁ : ∀ a' ∈ u₂ ++ v₂, r a a'
hs₁ : Pairwise r (u₂ ++ v₂)
IH : ∀ {l₂ : List α}, u₂ ++ v₂ ~ l₂ → Sorted r l₂ → u₂ ++ v₂ = l₂
hp : a :: (u₂ ++ v₂) ~ u₂ ++ a :: v₂
hp' : u₂ ++ v₂ ~ u₂ ++ v₂
this : ∀ x ∈ u₂, x = a
⊢ a :: u₂ = u₂ ++ [a]
state_after: no goals

tactic: simp
state_before: α : Type u
r : α → α → Prop
a✝ : α
l : List α
inst✝ : IsAntisymm α r
l₁✝ : List α
a : α
l₁ : List α
h₁ : ∀ a' ∈ l₁, r a a'
hs₁ : Pairwise r l₁
IH : ∀ {l₂ : List α}, l₁ ~ l₂ → Sorted r l₂ → l₁ = l₂
u₂ v₂ : List α
hp : a :: l₁ ~ u₂ ++ a :: v₂
hs₂ : Sorted r (u₂ ++ a :: v₂)
this : a ∈ u₂ ++ a :: v₂
hp' : l₁ ~ u₂ ++ v₂
⊢ u₂ ++ v₂ <+ u₂ ++ a :: v₂
state_after: no goals

tactic: simp [m]
state_before: α : Type u
r : α → α → Prop
a✝ : α
l : List α
inst✝ : IsAntisymm α r
l₁ : List α
a : α
u₂ v₂ : List α
hs₂ : Sorted r (u₂ ++ a :: v₂)
this : a ∈ u₂ ++ a :: v₂
h₁ : ∀ a' ∈ u₂ ++ v₂, r a a'
hs₁ : Pairwise r (u₂ ++ v₂)
IH : ∀ {l₂ : List α}, u₂ ++ v₂ ~ l₂ → Sorted r l₂ → u₂ ++ v₂ = l₂
hp : a :: (u₂ ++ v₂) ~ u₂ ++ a :: v₂
hp' : u₂ ++ v₂ ~ u₂ ++ v₂
x : α
m : x ∈ u₂
⊢ x ∈ u₂ ++ v₂
state_after: no goals