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

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
⊢ (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: 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 ≫
        ((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: 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 ≫
        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 [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
⊢ ((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 [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) ≫
        (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: apply prod.hom_ext
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: rw [Limits.prod.map_fst, assoc, assoc, prodComparison_fst, ← i.map_comp, prodComparison_fst]
state_before: 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
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.fst ≫ (reflectorAdjunction i).unit.app A =
    (reflectorAdjunction i).unit.app (A ⨯ B) ≫ i.map ((reflector i).map prod.fst)

tactic: apply (reflectorAdjunction i).unit.naturality
state_before: 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.fst ≫ (reflectorAdjunction i).unit.app A =
    (reflectorAdjunction i).unit.app (A ⨯ B) ≫ i.map ((reflector i).map prod.fst)
state_after: no goals

tactic: rw [Limits.prod.map_snd, assoc, assoc, prodComparison_snd, ← i.map_comp, prodComparison_snd]
state_before: 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
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.snd ≫ (reflectorAdjunction i).unit.app B =
    (reflectorAdjunction i).unit.app (A ⨯ B) ≫ i.map ((reflector i).map prod.snd)

tactic: apply (reflectorAdjunction i).unit.naturality
state_before: 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.snd ≫ (reflectorAdjunction i).unit.app B =
    (reflectorAdjunction i).unit.app (A ⨯ B) ≫ i.map ((reflector i).map prod.snd)
state_after: no goals