Theorem: CategoryTheory.Limits.walkingParallelPairOpEquiv_inverse
File: Mathlib/CategoryTheory/Limits/Shapes/Equalizers.lean

Proof steps:
state_before: j : WalkingParallelPair
⊢ (𝟭 WalkingParallelPair).obj j = (walkingParallelPairOp ⋙ walkingParallelPairOp.leftOp).obj j
state_after: no goals
tactic: cases j <;> rfl
state_before: ⊢ ∀ {X Y : WalkingParallelPair} (f : X ⟶ Y),
    (𝟭 WalkingParallelPair).map f ≫ ((fun j => eqToIso ⋯) Y).hom =
      ((fun j => eqToIso ⋯) X).hom ≫ (walkingParallelPairOp ⋙ walkingParallelPairOp.leftOp).map f
state_after: no goals
tactic: rintro _ _ (_ | _ | _) <;> simp
state_before: j : WalkingParallelPairᵒᵖ
⊢ (walkingParallelPairOp.leftOp ⋙ walkingParallelPairOp).obj j = (𝟭 WalkingParallelPairᵒᵖ).obj j
state_after: case h
X : WalkingParallelPair
⊢ (walkingParallelPairOp.leftOp ⋙ walkingParallelPairOp).obj (op X) = (𝟭 WalkingParallelPairᵒᵖ).obj (op X)
tactic: induction' j with X
state_before: case h
X : WalkingParallelPair
⊢ (walkingParallelPairOp.leftOp ⋙ walkingParallelPairOp).obj (op X) = (𝟭 WalkingParallelPairᵒᵖ).obj (op X)
state_after: no goals
tactic: cases X <;> rfl
state_before: i j : WalkingParallelPairᵒᵖ
f : i ⟶ j
⊢ (walkingParallelPairOp.leftOp ⋙ walkingParallelPairOp).map f ≫ ((fun j => eqToIso ⋯) j).hom =
    ((fun j => eqToIso ⋯) i).hom ≫ (𝟭 WalkingParallelPairᵒᵖ).map f
state_after: case h
j : WalkingParallelPairᵒᵖ
i : WalkingParallelPair
f : op i ⟶ j
⊢ (walkingParallelPairOp.leftOp ⋙ walkingParallelPairOp).map f ≫ ((fun j => eqToIso ⋯) j).hom =
    ((fun j => eqToIso ⋯) (op i)).hom ≫ (𝟭 WalkingParallelPairᵒᵖ).map f
tactic: induction' i with i
state_before: case h
j : WalkingParallelPairᵒᵖ
i : WalkingParallelPair
f : op i ⟶ j
⊢ (walkingParallelPairOp.leftOp ⋙ walkingParallelPairOp).map f ≫ ((fun j => eqToIso ⋯) j).hom =
    ((fun j => eqToIso ⋯) (op i)).hom ≫ (𝟭 WalkingParallelPairᵒᵖ).map f
state_after: case h.h
i j : WalkingParallelPair
f : op i ⟶ op j
⊢ (walkingParallelPairOp.leftOp ⋙ walkingParallelPairOp).map f ≫ ((fun j => eqToIso ⋯) (op j)).hom =
    ((fun j => eqToIso ⋯) (op i)).hom ≫ (𝟭 WalkingParallelPairᵒᵖ).map f
tactic: induction' j with j
state_before: case h.h
i j : WalkingParallelPair
f : op i ⟶ op j
⊢ (walkingParallelPairOp.leftOp ⋙ walkingParallelPairOp).map f ≫ ((fun j => eqToIso ⋯) (op j)).hom =
    ((fun j => eqToIso ⋯) (op i)).hom ≫ (𝟭 WalkingParallelPairᵒᵖ).map f
state_after: case h.h
i j : WalkingParallelPair
f : op i ⟶ op j
g : unop (op j) ⟶ unop (op i) := f.unop
⊢ (walkingParallelPairOp.leftOp ⋙ walkingParallelPairOp).map f ≫ ((fun j => eqToIso ⋯) (op j)).hom =
    ((fun j => eqToIso ⋯) (op i)).hom ≫ (𝟭 WalkingParallelPairᵒᵖ).map f
tactic: let g := f.unop
state_before: case h.h
i j : WalkingParallelPair
f : op i ⟶ op j
g : unop (op j) ⟶ unop (op i) := f.unop
⊢ (walkingParallelPairOp.leftOp ⋙ walkingParallelPairOp).map f ≫ ((fun j => eqToIso ⋯) (op j)).hom =
    ((fun j => eqToIso ⋯) (op i)).hom ≫ (𝟭 WalkingParallelPairᵒᵖ).map f
state_after: case h.h
i j : WalkingParallelPair
f : op i ⟶ op j
g : unop (op j) ⟶ unop (op i) := f.unop
this : f = g.op
⊢ (walkingParallelPairOp.leftOp ⋙ walkingParallelPairOp).map f ≫ ((fun j => eqToIso ⋯) (op j)).hom =
    ((fun j => eqToIso ⋯) (op i)).hom ≫ (𝟭 WalkingParallelPairᵒᵖ).map f
tactic: have : f = g.op := rfl
state_before: case h.h
i j : WalkingParallelPair
f : op i ⟶ op j
g : unop (op j) ⟶ unop (op i) := f.unop
this : f = g.op
⊢ (walkingParallelPairOp.leftOp ⋙ walkingParallelPairOp).map f ≫ ((fun j => eqToIso ⋯) (op j)).hom =
    ((fun j => eqToIso ⋯) (op i)).hom ≫ (𝟭 WalkingParallelPairᵒᵖ).map f
state_after: case h.h
i j : WalkingParallelPair
f : op i ⟶ op j
g : unop (op j) ⟶ unop (op i) := f.unop
this : f = g.op
⊢ (walkingParallelPairOp.leftOp ⋙ walkingParallelPairOp).map g.op ≫ ((fun j => eqToIso ⋯) (op j)).hom =
    ((fun j => eqToIso ⋯) (op i)).hom ≫ (𝟭 WalkingParallelPairᵒᵖ).map g.op
tactic: rw [this]
state_before: case h.h
i j : WalkingParallelPair
f : op i ⟶ op j
g : unop (op j) ⟶ unop (op i) := f.unop
this : f = g.op
⊢ (walkingParallelPairOp.leftOp ⋙ walkingParallelPairOp).map g.op ≫ ((fun j => eqToIso ⋯) (op j)).hom =
    ((fun j => eqToIso ⋯) (op i)).hom ≫ (𝟭 WalkingParallelPairᵒᵖ).map g.op
state_after: no goals
tactic: cases i <;> cases j <;> cases g <;> rfl
state_before: j : WalkingParallelPair
⊢ walkingParallelPairOp.map ((NatIso.ofComponents (fun j => eqToIso ⋯) ⋯).hom.app j) ≫
      (NatIso.ofComponents (fun j => eqToIso ⋯) ⋯).hom.app (walkingParallelPairOp.obj j) =
    𝟙 (walkingParallelPairOp.obj j)
state_after: no goals
tactic: cases j <;> rfl