Theorem: Multiset.antidiagonal_cons
File: Mathlib/Data/Multiset/Antidiagonal.lean

tactic: simp only [revzip, reverse_append, quot_mk_to_coe, coe_eq_coe, powersetAux'_cons, cons_coe,
  map_coe, antidiagonal_coe', coe_add]
state_before: α : Type u_1
β : Type u_2
a : α
s : Multiset α
l : List α
⊢ (a ::ₘ ⟦l⟧).antidiagonal =
    map (Prod.map id (cons a)) (antidiagonal ⟦l⟧) + map (Prod.map (cons a) id) (antidiagonal ⟦l⟧)
state_after: α : Type u_1
β : Type u_2
a : α
s : Multiset α
l : List α
⊢ (powersetAux' l ++ List.map (cons a) (powersetAux' l)).zip
      ((List.map (cons a) (powersetAux' l)).reverse ++ (powersetAux' l).reverse) ~
    List.map (fun x => Prod.map id (cons a) x) ((powersetAux' l).zip (powersetAux' l).reverse) ++
      List.map (fun x => Prod.map (cons a) id x) ((powersetAux' l).zip (powersetAux' l).reverse)

tactic: rw [← zip_map, ← zip_map, zip_append, (_ : _ ++ _ = _)]
state_before: α : Type u_1
β : Type u_2
a : α
s : Multiset α
l : List α
⊢ (powersetAux' l ++ List.map (cons a) (powersetAux' l)).zip
      ((List.map (cons a) (powersetAux' l)).reverse ++ (powersetAux' l).reverse) ~
    List.map (fun x => Prod.map id (cons a) x) ((powersetAux' l).zip (powersetAux' l).reverse) ++
      List.map (fun x => Prod.map (cons a) id x) ((powersetAux' l).zip (powersetAux' l).reverse)
state_after: α : Type u_1
β : Type u_2
a : α
s : Multiset α
l : List α
⊢ (powersetAux' l).zip (List.map (cons a) (powersetAux' l)).reverse ++
      (List.map (cons a) (powersetAux' l)).zip (powersetAux' l).reverse =
    (List.map id (powersetAux' l)).zip (List.map (cons a) (powersetAux' l).reverse) ++
      (List.map (cons a) (powersetAux' l)).zip (List.map id (powersetAux' l).reverse)

α : Type u_1
β : Type u_2
a : α
s : Multiset α
l : List α
⊢ (powersetAux' l).length = (List.map (cons a) (powersetAux' l)).reverse.length

tactic: congr
state_before: α : Type u_1
β : Type u_2
a : α
s : Multiset α
l : List α
⊢ (powersetAux' l).zip (List.map (cons a) (powersetAux' l)).reverse ++
      (List.map (cons a) (powersetAux' l)).zip (powersetAux' l).reverse =
    (List.map id (powersetAux' l)).zip (List.map (cons a) (powersetAux' l).reverse) ++
      (List.map (cons a) (powersetAux' l)).zip (List.map id (powersetAux' l).reverse)
state_after: case e_a.e_a
α : Type u_1
β : Type u_2
a : α
s : Multiset α
l : List α
⊢ powersetAux' l = List.map id (powersetAux' l)

case e_a.e_a
α : Type u_1
β : Type u_2
a : α
s : Multiset α
l : List α
⊢ (List.map (cons a) (powersetAux' l)).reverse = List.map (cons a) (powersetAux' l).reverse

case e_a.e_a
α : Type u_1
β : Type u_2
a : α
s : Multiset α
l : List α
⊢ (powersetAux' l).reverse = List.map id (powersetAux' l).reverse

tactic: simp only [List.map_id]
state_before: case e_a.e_a
α : Type u_1
β : Type u_2
a : α
s : Multiset α
l : List α
⊢ powersetAux' l = List.map id (powersetAux' l)
state_after: no goals

tactic: rw [map_reverse]
state_before: case e_a.e_a
α : Type u_1
β : Type u_2
a : α
s : Multiset α
l : List α
⊢ (List.map (cons a) (powersetAux' l)).reverse = List.map (cons a) (powersetAux' l).reverse
state_after: no goals

tactic: simp
state_before: case e_a.e_a
α : Type u_1
β : Type u_2
a : α
s : Multiset α
l : List α
⊢ (powersetAux' l).reverse = List.map id (powersetAux' l).reverse
state_after: no goals

tactic: simp
state_before: α : Type u_1
β : Type u_2
a : α
s : Multiset α
l : List α
⊢ (powersetAux' l).length = (List.map (cons a) (powersetAux' l)).reverse.length
state_after: no goals