Theorem: List.perm_merge
File: .lake/packages/batteries/Batteries/Data/List/Perm.lean

tactic: simp
state_before: α : Type u_1
s : α → α → Bool
l r✝ r : List α
⊢ merge s [] r ~ [] ++ r
state_after: no goals

tactic: simp
state_before: α : Type u_1
s : α → α → Bool
l✝ r l : List α
⊢ merge s l [] ~ l ++ []
state_after: no goals

tactic: rw [cons_merge_cons]
state_before: α : Type u_1
s : α → α → Bool
l✝ r✝ : List α
a : α
l : List α
b : α
r : List α
⊢ merge s (a :: l) (b :: r) ~ a :: l ++ b :: r
state_after: α : Type u_1
s : α → α → Bool
l✝ r✝ : List α
a : α
l : List α
b : α
r : List α
⊢ (if s a b = true then a :: merge s l (b :: r) else b :: merge s (a :: l) r) ~ a :: l ++ b :: r

tactic: split
state_before: α : Type u_1
s : α → α → Bool
l✝ r✝ : List α
a : α
l : List α
b : α
r : List α
⊢ (if s a b = true then a :: merge s l (b :: r) else b :: merge s (a :: l) r) ~ a :: l ++ b :: r
state_after: case isTrue
α : Type u_1
s : α → α → Bool
l✝ r✝ : List α
a : α
l : List α
b : α
r : List α
h✝ : s a b = true
⊢ a :: merge s l (b :: r) ~ a :: l ++ b :: r

case isFalse
α : Type u_1
s : α → α → Bool
l✝ r✝ : List α
a : α
l : List α
b : α
r : List α
h✝ : ¬s a b = true
⊢ b :: merge s (a :: l) r ~ a :: l ++ b :: r

tactic: apply Perm.trans ((perm_cons a).mpr (perm_merge s l (b::r)))
state_before: case isTrue
α : Type u_1
s : α → α → Bool
l✝ r✝ : List α
a : α
l : List α
b : α
r : List α
h✝ : s a b = true
⊢ a :: merge s l (b :: r) ~ a :: l ++ b :: r
state_after: case isTrue
α : Type u_1
s : α → α → Bool
l✝ r✝ : List α
a : α
l : List α
b : α
r : List α
h✝ : s a b = true
⊢ a :: (l ++ b :: r) ~ a :: l ++ b :: r

tactic: simp [cons_append]
state_before: case isTrue
α : Type u_1
s : α → α → Bool
l✝ r✝ : List α
a : α
l : List α
b : α
r : List α
h✝ : s a b = true
⊢ a :: (l ++ b :: r) ~ a :: l ++ b :: r
state_after: no goals

tactic: apply Perm.trans ((perm_cons b).mpr (perm_merge s (a::l) r))
state_before: case isFalse
α : Type u_1
s : α → α → Bool
l✝ r✝ : List α
a : α
l : List α
b : α
r : List α
h✝ : ¬s a b = true
⊢ b :: merge s (a :: l) r ~ a :: l ++ b :: r
state_after: case isFalse
α : Type u_1
s : α → α → Bool
l✝ r✝ : List α
a : α
l : List α
b : α
r : List α
h✝ : ¬s a b = true
⊢ b :: (a :: l ++ r) ~ a :: l ++ b :: r

tactic: simp [cons_append]
state_before: case isFalse
α : Type u_1
s : α → α → Bool
l✝ r✝ : List α
a : α
l : List α
b : α
r : List α
h✝ : ¬s a b = true
⊢ b :: (a :: l ++ r) ~ a :: l ++ b :: r
state_after: case isFalse
α : Type u_1
s : α → α → Bool
l✝ r✝ : List α
a : α
l : List α
b : α
r : List α
h✝ : ¬s a b = true
⊢ b :: a :: (l ++ r) ~ a :: (l ++ b :: r)

tactic: apply Perm.trans (Perm.swap ..)
state_before: case isFalse
α : Type u_1
s : α → α → Bool
l✝ r✝ : List α
a : α
l : List α
b : α
r : List α
h✝ : ¬s a b = true
⊢ b :: a :: (l ++ r) ~ a :: (l ++ b :: r)
state_after: case isFalse
α : Type u_1
s : α → α → Bool
l✝ r✝ : List α
a : α
l : List α
b : α
r : List α
h✝ : ¬s a b = true
⊢ a :: b :: (l ++ r) ~ a :: (l ++ b :: r)

tactic: apply Perm.cons
state_before: case isFalse
α : Type u_1
s : α → α → Bool
l✝ r✝ : List α
a : α
l : List α
b : α
r : List α
h✝ : ¬s a b = true
⊢ a :: b :: (l ++ r) ~ a :: (l ++ b :: r)
state_after: case isFalse.a
α : Type u_1
s : α → α → Bool
l✝ r✝ : List α
a : α
l : List α
b : α
r : List α
h✝ : ¬s a b = true
⊢ b :: (l ++ r) ~ l ++ b :: r

tactic: apply perm_cons_append_cons
state_before: case isFalse.a
α : Type u_1
s : α → α → Bool
l✝ r✝ : List α
a : α
l : List α
b : α
r : List α
h✝ : ¬s a b = true
⊢ b :: (l ++ r) ~ l ++ b :: r
state_after: case isFalse.a.p
α : Type u_1
s : α → α → Bool
l✝ r✝ : List α
a : α
l : List α
b : α
r : List α
h✝ : ¬s a b = true
⊢ l ++ r ~ l ++ r

tactic: exact Perm.rfl
state_before: case isFalse.a.p
α : Type u_1
s : α → α → Bool
l✝ r✝ : List α
a : α
l : List α
b : α
r : List α
h✝ : ¬s a b = true
⊢ l ++ r ~ l ++ r
state_after: no goals