Theorem: CategoryTheory.bijection_symm_apply_id
File: Mathlib/CategoryTheory/Closed/Ideal.lean

Proof steps:
state_before: C : Type u₁
D : Type u₂
inst✝⁶ : Category.{v₁, u₁} C
inst✝⁵ : Category.{v₁, u₂} D
i : D ⥤ C
inst✝⁴ : HasFiniteProducts C
inst✝³ : Reflective i
inst✝² : CartesianClosed C
inst✝¹ : HasFiniteProducts D
inst✝ : ExponentialIdeal i
A B : C
⊢ (bijection i A B ((reflector i).obj A ⨯ (reflector i).obj B)).symm (𝟙 ((reflector i).obj A ⨯ (reflector i).obj B)) =
    prodComparison (reflector i) A B
state_after: C : Type u₁
D : Type u₂
inst✝⁶ : Category.{v₁, u₁} C
inst✝⁵ : Category.{v₁, u₂} D
i : D ⥤ C
inst✝⁴ : HasFiniteProducts C
inst✝³ : Reflective i
inst✝² : CartesianClosed C
inst✝¹ : HasFiniteProducts D
inst✝ : ExponentialIdeal i
A B : C
⊢ ((reflectorAdjunction i).homEquiv (A ⨯ B) ((reflector i).obj A ⨯ (reflector i).obj B)).symm
      (prod.lift prod.snd prod.fst ≫
        ((exp.adjunction B).homEquiv A (i.obj ((reflector i).obj A ⨯ (reflector i).obj B))).symm
            ((unitCompPartialBijective A ⋯).symm
              (((exp.adjunction B).homEquiv (i.obj ((reflector i).obj A))
                  (i.obj ((reflector i).obj A ⨯ (reflector i).obj B)))
                (prod.lift prod.snd prod.fst ≫
                  ((exp.adjunction (i.obj ((reflector i).obj A))).homEquiv B
                          (i.obj ((reflector i).obj A ⨯ (reflector i).obj B))).symm
                      ((unitCompPartialBijective B ⋯).symm
                        (((exp.adjunction (i.obj ((reflector i).obj A))).homEquiv (i.obj ((reflector i).obj B))
                            (i.obj ((reflector i).obj A ⨯ (reflector i).obj B)))
                          ((PreservesLimitPair.iso i ((reflector i).obj A) ((reflector i).obj B)).inv ≫
                            i.map (𝟙 ((reflector i).obj A ⨯ (reflector i).obj B)) ≫
                              𝟙 (i.obj ((reflector i).obj A ⨯ (reflector i).obj B))))) ≫
                    𝟙 (i.obj ((reflector i).obj A ⨯ (reflector i).obj B))))) ≫
          𝟙 (i.obj ((reflector i).obj A ⨯ (reflector i).obj B))) =
    prodComparison (reflector i) A B
tactic: dsimp [bijection]
state_before: C : Type u₁
D : Type u₂
inst✝⁶ : Category.{v₁, u₁} C
inst✝⁵ : Category.{v₁, u₂} D
i : D ⥤ C
inst✝⁴ : HasFiniteProducts C
inst✝³ : Reflective i
inst✝² : CartesianClosed C
inst✝¹ : HasFiniteProducts D
inst✝ : ExponentialIdeal i
A B : C
⊢ ((reflectorAdjunction i).homEquiv (A ⨯ B) ((reflector i).obj A ⨯ (reflector i).obj B)).symm
      (prod.lift prod.snd prod.fst ≫
        ((exp.adjunction B).homEquiv A (i.obj ((reflector i).obj A ⨯ (reflector i).obj B))).symm
            ((unitCompPartialBijective A ⋯).symm
              (((exp.adjunction B).homEquiv (i.obj ((reflector i).obj A))
                  (i.obj ((reflector i).obj A ⨯ (reflector i).obj B)))
                (prod.lift prod.snd prod.fst ≫
                  ((exp.adjunction (i.obj ((reflector i).obj A))).homEquiv B
                          (i.obj ((reflector i).obj A ⨯ (reflector i).obj B))).symm
                      ((unitCompPartialBijective B ⋯).symm
                        (((exp.adjunction (i.obj ((reflector i).obj A))).homEquiv (i.obj ((reflector i).obj B))
                            (i.obj ((reflector i).obj A ⨯ (reflector i).obj B)))
                          ((PreservesLimitPair.iso i ((reflector i).obj A) ((reflector i).obj B)).inv ≫
                            i.map (𝟙 ((reflector i).obj A ⨯ (reflector i).obj B)) ≫
                              𝟙 (i.obj ((reflector i).obj A ⨯ (reflector i).obj B))))) ≫
                    𝟙 (i.obj ((reflector i).obj A ⨯ (reflector i).obj B))))) ≫
          𝟙 (i.obj ((reflector i).obj A ⨯ (reflector i).obj B))) =
    prodComparison (reflector i) A B
state_after: C : Type u₁
D : Type u₂
inst✝⁶ : Category.{v₁, u₁} C
inst✝⁵ : Category.{v₁, u₂} D
i : D ⥤ C
inst✝⁴ : HasFiniteProducts C
inst✝³ : Reflective i
inst✝² : CartesianClosed C
inst✝¹ : HasFiniteProducts D
inst✝ : ExponentialIdeal i
A B : C
⊢ ((reflectorAdjunction i).homEquiv (A ⨯ B) ((reflector i).obj A ⨯ (reflector i).obj B)).symm
      (prod.lift prod.snd prod.fst ≫
        uncurry
            ((unitCompPartialBijective A ⋯).symm
              (curry
                (prod.lift prod.snd prod.fst ≫
                  uncurry
                      ((unitCompPartialBijective B ⋯).symm
                        (curry
                          ((PreservesLimitPair.iso i ((reflector i).obj A) ((reflector i).obj B)).inv ≫
                            i.map (𝟙 ((reflector i).obj A ⨯ (reflector i).obj B)) ≫
                              𝟙 (i.obj ((reflector i).obj A ⨯ (reflector i).obj B))))) ≫
                    𝟙 (i.obj ((reflector i).obj A ⨯ (reflector i).obj B))))) ≫
          𝟙 (i.obj ((reflector i).obj A ⨯ (reflector i).obj B))) =
    prodComparison (reflector i) A B
tactic: erw [homEquiv_symm_apply_eq, homEquiv_symm_apply_eq, homEquiv_apply_eq, homEquiv_apply_eq]
state_before: C : Type u₁
D : Type u₂
inst✝⁶ : Category.{v₁, u₁} C
inst✝⁵ : Category.{v₁, u₂} D
i : D ⥤ C
inst✝⁴ : HasFiniteProducts C
inst✝³ : Reflective i
inst✝² : CartesianClosed C
inst✝¹ : HasFiniteProducts D
inst✝ : ExponentialIdeal i
A B : C
⊢ ((reflectorAdjunction i).homEquiv (A ⨯ B) ((reflector i).obj A ⨯ (reflector i).obj B)).symm
      (prod.lift prod.snd prod.fst ≫
        uncurry
            ((unitCompPartialBijective A ⋯).symm
              (curry
                (prod.lift prod.snd prod.fst ≫
                  uncurry
                      ((unitCompPartialBijective B ⋯).symm
                        (curry
                          ((PreservesLimitPair.iso i ((reflector i).obj A) ((reflector i).obj B)).inv ≫
                            i.map (𝟙 ((reflector i).obj A ⨯ (reflector i).obj B)) ≫
                              𝟙 (i.obj ((reflector i).obj A ⨯ (reflector i).obj B))))) ≫
                    𝟙 (i.obj ((reflector i).obj A ⨯ (reflector i).obj B))))) ≫
          𝟙 (i.obj ((reflector i).obj A ⨯ (reflector i).obj B))) =
    prodComparison (reflector i) A B
state_after: C : Type u₁
D : Type u₂
inst✝⁶ : Category.{v₁, u₁} C
inst✝⁵ : Category.{v₁, u₂} D
i : D ⥤ C
inst✝⁴ : HasFiniteProducts C
inst✝³ : Reflective i
inst✝² : CartesianClosed C
inst✝¹ : HasFiniteProducts D
inst✝ : ExponentialIdeal i
A B : C
⊢ ((reflectorAdjunction i).homEquiv (A ⨯ B) ((reflector i).obj A ⨯ (reflector i).obj B)).symm
      (prod.lift prod.snd (prod.fst ≫ (reflectorAdjunction i).unit.app A) ≫
        prod.lift prod.snd (prod.fst ≫ (reflectorAdjunction i).unit.app B) ≫
          (PreservesLimitPair.iso i ((reflector i).obj A) ((reflector i).obj B)).inv) =
    prodComparison (reflector i) A B
tactic: rw [comp_id, comp_id, comp_id, i.map_id, comp_id, unitCompPartialBijective_symm_apply,
    unitCompPartialBijective_symm_apply, uncurry_natural_left, uncurry_curry,
    uncurry_natural_left, uncurry_curry, prod.lift_map_assoc, comp_id, prod.lift_map_assoc, comp_id]
state_before: C : Type u₁
D : Type u₂
inst✝⁶ : Category.{v₁, u₁} C
inst✝⁵ : Category.{v₁, u₂} D
i : D ⥤ C
inst✝⁴ : HasFiniteProducts C
inst✝³ : Reflective i
inst✝² : CartesianClosed C
inst✝¹ : HasFiniteProducts D
inst✝ : ExponentialIdeal i
A B : C
⊢ ((reflectorAdjunction i).homEquiv (A ⨯ B) ((reflector i).obj A ⨯ (reflector i).obj B)).symm
      (prod.lift prod.snd (prod.fst ≫ (reflectorAdjunction i).unit.app A) ≫
        prod.lift prod.snd (prod.fst ≫ (reflectorAdjunction i).unit.app B) ≫
          (PreservesLimitPair.iso i ((reflector i).obj A) ((reflector i).obj B)).inv) =
    prodComparison (reflector i) A B
state_after: C : Type u₁
D : Type u₂
inst✝⁶ : Category.{v₁, u₁} C
inst✝⁵ : Category.{v₁, u₂} D
i : D ⥤ C
inst✝⁴ : HasFiniteProducts C
inst✝³ : Reflective i
inst✝² : CartesianClosed C
inst✝¹ : HasFiniteProducts D
inst✝ : ExponentialIdeal i
A B : C
⊢ prod.map ((reflectorAdjunction i).unit.app A) ((reflectorAdjunction i).unit.app B) =
    (reflectorAdjunction i).unit.app (A ⨯ B) ≫
      i.map (prodComparison (reflector i) A B) ≫
        (PreservesLimitPair.iso i ((reflector i).obj A) ((reflector i).obj B)).hom
tactic: rw [prod.comp_lift_assoc, prod.lift_snd, prod.lift_fst_assoc, prod.lift_fst_comp_snd_comp,
    ← Adjunction.eq_homEquiv_apply, Adjunction.homEquiv_unit, Iso.comp_inv_eq, assoc]
state_before: C : Type u₁
D : Type u₂
inst✝⁶ : Category.{v₁, u₁} C
inst✝⁵ : Category.{v₁, u₂} D
i : D ⥤ C
inst✝⁴ : HasFiniteProducts C
inst✝³ : Reflective i
inst✝² : CartesianClosed C
inst✝¹ : HasFiniteProducts D
inst✝ : ExponentialIdeal i
A B : C
⊢ prod.map ((reflectorAdjunction i).unit.app A) ((reflectorAdjunction i).unit.app B) =
    (reflectorAdjunction i).unit.app (A ⨯ B) ≫
      i.map (prodComparison (reflector i) A B) ≫
        (PreservesLimitPair.iso i ((reflector i).obj A) ((reflector i).obj B)).hom
state_after: C : Type u₁
D : Type u₂
inst✝⁶ : Category.{v₁, u₁} C
inst✝⁵ : Category.{v₁, u₂} D
i : D ⥤ C
inst✝⁴ : HasFiniteProducts C
inst✝³ : Reflective i
inst✝² : CartesianClosed C
inst✝¹ : HasFiniteProducts D
inst✝ : ExponentialIdeal i
A B : C
⊢ prod.map ((reflectorAdjunction i).unit.app A) ((reflectorAdjunction i).unit.app B) =
    (reflectorAdjunction i).unit.app (A ⨯ B) ≫
      i.map (prodComparison (reflector i) A B) ≫ prodComparison i ((reflector i).obj A) ((reflector i).obj B)
tactic: rw [PreservesLimitPair.iso_hom i ((reflector i).obj A) ((reflector i).obj B)]
state_before: C : Type u₁
D : Type u₂
inst✝⁶ : Category.{v₁, u₁} C
inst✝⁵ : Category.{v₁, u₂} D
i : D ⥤ C
inst✝⁴ : HasFiniteProducts C
inst✝³ : Reflective i
inst✝² : CartesianClosed C
inst✝¹ : HasFiniteProducts D
inst✝ : ExponentialIdeal i
A B : C
⊢ prod.map ((reflectorAdjunction i).unit.app A) ((reflectorAdjunction i).unit.app B) =
    (reflectorAdjunction i).unit.app (A ⨯ B) ≫
      i.map (prodComparison (reflector i) A B) ≫ prodComparison i ((reflector i).obj A) ((reflector i).obj B)
state_after: case h₁
C : Type u₁
D : Type u₂
inst✝⁶ : Category.{v₁, u₁} C
inst✝⁵ : Category.{v₁, u₂} D
i : D ⥤ C
inst✝⁴ : HasFiniteProducts C
inst✝³ : Reflective i
inst✝² : CartesianClosed C
inst✝¹ : HasFiniteProducts D
inst✝ : ExponentialIdeal i
A B : C
⊢ prod.map ((reflectorAdjunction i).unit.app A) ((reflectorAdjunction i).unit.app B) ≫ prod.fst =
    ((reflectorAdjunction i).unit.app (A ⨯ B) ≫
        i.map (prodComparison (reflector i) A B) ≫ prodComparison i ((reflector i).obj A) ((reflector i).obj B)) ≫
      prod.fst

case h₂
C : Type u₁
D : Type u₂
inst✝⁶ : Category.{v₁, u₁} C
inst✝⁵ : Category.{v₁, u₂} D
i : D ⥤ C
inst✝⁴ : HasFiniteProducts C
inst✝³ : Reflective i
inst✝² : CartesianClosed C
inst✝¹ : HasFiniteProducts D
inst✝ : ExponentialIdeal i
A B : C
⊢ prod.map ((reflectorAdjunction i).unit.app A) ((reflectorAdjunction i).unit.app B) ≫ prod.snd =
    ((reflectorAdjunction i).unit.app (A ⨯ B) ≫
        i.map (prodComparison (reflector i) A B) ≫ prodComparison i ((reflector i).obj A) ((reflector i).obj B)) ≫
      prod.snd
tactic: apply prod.hom_ext