Module: Mathlib.CategoryTheory.Limits.Shapes.Opposites.Pullbacks

Goal state before:
pp: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
J : Type u₂
inst✝ : Category.{v₂, u₂} J
X Y Z : C
f : X ⟶ Z
g : Y ⟶ Z
⊢ ∀ {X_1 Y_1 : WalkingSpan} (f_1 : X_1 ⟶ Y_1),
    (span f.op g.op).map f_1 ≫
        (match Y_1 with
          | none => Iso.refl ((span f.op g.op).obj none)
          | some WalkingPair.left => Iso.refl ((span f.op g.op).obj WalkingSpan.left)
          | some WalkingPair.right => Iso.refl ((span f.op g.op).obj WalkingSpan.right)).hom =
      (match X_1 with
          | none => Iso.refl ((span f.op g.op).obj none)
          | some WalkingPair.left => Iso.refl ((span f.op g.op).obj WalkingSpan.left)
          | some WalkingPair.right => Iso.refl ((span f.op g.op).obj WalkingSpan.right)).hom ≫
        (walkingCospanOpEquiv.inverse ⋙ (cospan f g).op).map f_1

Tactic:
rintro (_ | _ | _) (_ | _ | _) f <;> cases f

Goal state after:
case none.none.id
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
J : Type u₂
inst✝ : Category.{v₂, u₂} J
X Y Z : C
f : X ⟶ Z
g : Y ⟶ Z
⊢ (span f.op g.op).map (WidePushoutShape.Hom.id none) ≫
      (match none with
        | none => Iso.refl ((span f.op g.op).obj none)
        | some WalkingPair.left => Iso.refl ((span f.op g.op).obj WalkingSpan.left)
        | some WalkingPair.right => Iso.refl ((span f.op g.op).obj WalkingSpan.right)).hom =
    (match none with
        | none => Iso.refl ((span f.op g.op).obj none)
        | some WalkingPair.left => Iso.refl ((span f.op g.op).obj WalkingSpan.left)
        | some WalkingPair.right => Iso.refl ((span f.op g.op).obj WalkingSpan.right)).hom ≫
      (walkingCospanOpEquiv.inverse ⋙ (cospan f g).op).map (WidePushoutShape.Hom.id none)

case none.some.left.init
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
J : Type u₂
inst✝ : Category.{v₂, u₂} J
X Y Z : C
f : X ⟶ Z
g : Y ⟶ Z
⊢ (span f.op g.op).map (WidePushoutShape.Hom.init WalkingPair.left) ≫
      (match some WalkingPair.left with
        | none => Iso.refl ((span f.op g.op).obj none)
        | some WalkingPair.left => Iso.refl ((span f.op g.op).obj WalkingSpan.left)
        | some WalkingPair.right => Iso.refl ((span f.op g.op).obj WalkingSpan.right)).hom =
    (match none with
        | none => Iso.refl ((span f.op g.op).obj none)
        | some WalkingPair.left => Iso.refl ((span f.op g.op).obj WalkingSpan.left)
        | some WalkingPair.right => Iso.refl ((span f.op g.op).obj WalkingSpan.right)).hom ≫
      (walkingCospanOpEquiv.inverse ⋙ (cospan f g).op).map (WidePushoutShape.Hom.init WalkingPair.left)

case none.some.right.init
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
J : Type u₂
inst✝ : Category.{v₂, u₂} J
X Y Z : C
f : X ⟶ Z
g : Y ⟶ Z
⊢ (span f.op g.op).map (WidePushoutShape.Hom.init WalkingPair.right) ≫
      (match some WalkingPair.right with
        | none => Iso.refl ((span f.op g.op).obj none)
        | some WalkingPair.left => Iso.refl ((span f.op g.op).obj WalkingSpan.left)
        | some WalkingPair.right => Iso.refl ((span f.op g.op).obj WalkingSpan.right)).hom =
    (match none with
        | none => Iso.refl ((span f.op g.op).obj none)
        | some WalkingPair.left => Iso.refl ((span f.op g.op).obj WalkingSpan.left)
        | some WalkingPair.right => Iso.refl ((span f.op g.op).obj WalkingSpan.right)).hom ≫
      (walkingCospanOpEquiv.inverse ⋙ (cospan f g).op).map (WidePushoutShape.Hom.init WalkingPair.right)

case some.left.some.left.id
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
J : Type u₂
inst✝ : Category.{v₂, u₂} J
X Y Z : C
f : X ⟶ Z
g : Y ⟶ Z
⊢ (span f.op g.op).map (WidePushoutShape.Hom.id (some WalkingPair.left)) ≫
      (match some WalkingPair.left with
        | none => Iso.refl ((span f.op g.op).obj none)
        | some WalkingPair.left => Iso.refl ((span f.op g.op).obj WalkingSpan.left)
        | some WalkingPair.right => Iso.refl ((span f.op g.op).obj WalkingSpan.right)).hom =
    (match some WalkingPair.left with
        | none => Iso.refl ((span f.op g.op).obj none)
        | some WalkingPair.left => Iso.refl ((span f.op g.op).obj WalkingSpan.left)
        | some WalkingPair.right => Iso.refl ((span f.op g.op).obj WalkingSpan.right)).hom ≫
      (walkingCospanOpEquiv.inverse ⋙ (cospan f g).op).map (WidePushoutShape.Hom.id (some WalkingPair.left))

case some.right.some.right.id
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
J : Type u₂
inst✝ : Category.{v₂, u₂} J
X Y Z : C
f : X ⟶ Z
g : Y ⟶ Z
⊢ (span f.op g.op).map (WidePushoutShape.Hom.id (some WalkingPair.right)) ≫
      (match some WalkingPair.right with
        | none => Iso.refl ((span f.op g.op).obj none)
        | some WalkingPair.left => Iso.refl ((span f.op g.op).obj WalkingSpan.left)
        | some WalkingPair.right => Iso.refl ((span f.op g.op).obj WalkingSpan.right)).hom =
    (match some WalkingPair.right with
        | none => Iso.refl ((span f.op g.op).obj none)
        | some WalkingPair.left => Iso.refl ((span f.op g.op).obj WalkingSpan.left)
        | some WalkingPair.right => Iso.refl ((span f.op g.op).obj WalkingSpan.right)).hom ≫
      (walkingCospanOpEquiv.inverse ⋙ (cospan f g).op).map (WidePushoutShape.Hom.id (some WalkingPair.right))