Theorem: CategoryTheory.bijection_natural
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
X X' : D
f : (reflector i).obj (A ⨯ B) ⟶ X
g : X ⟶ X'
⊢ (bijection i A B X') (f ≫ g) = (bijection i A B X) f ≫ g
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
X X' : D
f : (reflector i).obj (A ⨯ B) ⟶ X
g : X ⟶ X'
⊢ i.fullyFaithfulOfReflective.preimage
      (prodComparison i ((reflector i).obj A) ((reflector i).obj B) ≫
        ((exp.adjunction (i.obj ((reflector i).obj A))).homEquiv (i.obj ((reflector i).obj B)) (i.obj X')).symm
            ((unitCompPartialBijective B ⋯)
              (((exp.adjunction (i.obj ((reflector i).obj A))).homEquiv B (i.obj X'))
                (prod.lift prod.snd prod.fst ≫
                  ((exp.adjunction B).homEquiv (i.obj ((reflector i).obj A)) (i.obj X')).symm
                      ((unitCompPartialBijective A ⋯)
                        (((exp.adjunction B).homEquiv A (i.obj X'))
                          (prod.lift prod.snd prod.fst ≫
                            ((reflectorAdjunction i).homEquiv (A ⨯ B) X') (f ≫ g) ≫ 𝟙 (i.obj X')))) ≫
                    𝟙 (i.obj X')))) ≫
          𝟙 (i.obj X')) =
    i.fullyFaithfulOfReflective.preimage
        (prodComparison i ((reflector i).obj A) ((reflector i).obj B) ≫
          ((exp.adjunction (i.obj ((reflector i).obj A))).homEquiv (i.obj ((reflector i).obj B)) (i.obj X)).symm
              ((unitCompPartialBijective B ⋯)
                (((exp.adjunction (i.obj ((reflector i).obj A))).homEquiv B (i.obj X))
                  (prod.lift prod.snd prod.fst ≫
                    ((exp.adjunction B).homEquiv (i.obj ((reflector i).obj A)) (i.obj X)).symm
                        ((unitCompPartialBijective A ⋯)
                          (((exp.adjunction B).homEquiv A (i.obj X))
                            (prod.lift prod.snd prod.fst ≫
                              ((reflectorAdjunction i).homEquiv (A ⨯ B) X) f ≫ 𝟙 (i.obj X)))) ≫
                      𝟙 (i.obj X)))) ≫
            𝟙 (i.obj X)) ≫
      g
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
X X' : D
f : (reflector i).obj (A ⨯ B) ⟶ X
g : X ⟶ X'
⊢ i.fullyFaithfulOfReflective.preimage
      (prodComparison i ((reflector i).obj A) ((reflector i).obj B) ≫
        ((exp.adjunction (i.obj ((reflector i).obj A))).homEquiv (i.obj ((reflector i).obj B)) (i.obj X')).symm
            ((unitCompPartialBijective B ⋯)
              (((exp.adjunction (i.obj ((reflector i).obj A))).homEquiv B (i.obj X'))
                (prod.lift prod.snd prod.fst ≫
                  ((exp.adjunction B).homEquiv (i.obj ((reflector i).obj A)) (i.obj X')).symm
                      ((unitCompPartialBijective A ⋯)
                        (((exp.adjunction B).homEquiv A (i.obj X'))
                          (prod.lift prod.snd prod.fst ≫
                            ((reflectorAdjunction i).homEquiv (A ⨯ B) X') (f ≫ g) ≫ 𝟙 (i.obj X')))) ≫
                    𝟙 (i.obj X')))) ≫
          𝟙 (i.obj X')) =
    i.fullyFaithfulOfReflective.preimage
        (prodComparison i ((reflector i).obj A) ((reflector i).obj B) ≫
          ((exp.adjunction (i.obj ((reflector i).obj A))).homEquiv (i.obj ((reflector i).obj B)) (i.obj X)).symm
              ((unitCompPartialBijective B ⋯)
                (((exp.adjunction (i.obj ((reflector i).obj A))).homEquiv B (i.obj X))
                  (prod.lift prod.snd prod.fst ≫
                    ((exp.adjunction B).homEquiv (i.obj ((reflector i).obj A)) (i.obj X)).symm
                        ((unitCompPartialBijective A ⋯)
                          (((exp.adjunction B).homEquiv A (i.obj X))
                            (prod.lift prod.snd prod.fst ≫
                              ((reflectorAdjunction i).homEquiv (A ⨯ B) X) f ≫ 𝟙 (i.obj X)))) ≫
                      𝟙 (i.obj X)))) ≫
            𝟙 (i.obj X)) ≫
      g
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
X X' : D
f : (reflector i).obj (A ⨯ B) ⟶ X
g : X ⟶ X'
⊢ i.fullyFaithfulOfReflective.preimage
      (prodComparison i ((reflector i).obj A) ((reflector i).obj B) ≫
        uncurry
            ((unitCompPartialBijective B ⋯)
              (curry
                (prod.lift prod.snd prod.fst ≫
                  uncurry
                      ((unitCompPartialBijective A ⋯)
                        (curry
                          (prod.lift prod.snd prod.fst ≫
                            ((reflectorAdjunction i).homEquiv (A ⨯ B) X') (f ≫ g) ≫ 𝟙 (i.obj X')))) ≫
                    𝟙 (i.obj X')))) ≫
          𝟙 (i.obj X')) =
    i.fullyFaithfulOfReflective.preimage
        (prodComparison i ((reflector i).obj A) ((reflector i).obj B) ≫
          uncurry
              ((unitCompPartialBijective B ⋯)
                (curry
                  (prod.lift prod.snd prod.fst ≫
                    uncurry
                        ((unitCompPartialBijective A ⋯)
                          (curry
                            (prod.lift prod.snd prod.fst ≫
                              ((reflectorAdjunction i).homEquiv (A ⨯ B) X) f ≫ 𝟙 (i.obj X)))) ≫
                      𝟙 (i.obj X)))) ≫
            𝟙 (i.obj X)) ≫
      g
tactic: erw [homEquiv_symm_apply_eq, homEquiv_symm_apply_eq, homEquiv_apply_eq, homEquiv_apply_eq,
    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
X X' : D
f : (reflector i).obj (A ⨯ B) ⟶ X
g : X ⟶ X'
⊢ i.fullyFaithfulOfReflective.preimage
      (prodComparison i ((reflector i).obj A) ((reflector i).obj B) ≫
        uncurry
            ((unitCompPartialBijective B ⋯)
              (curry
                (prod.lift prod.snd prod.fst ≫
                  uncurry
                      ((unitCompPartialBijective A ⋯)
                        (curry
                          (prod.lift prod.snd prod.fst ≫
                            ((reflectorAdjunction i).homEquiv (A ⨯ B) X') (f ≫ g) ≫ 𝟙 (i.obj X')))) ≫
                    𝟙 (i.obj X')))) ≫
          𝟙 (i.obj X')) =
    i.fullyFaithfulOfReflective.preimage
        (prodComparison i ((reflector i).obj A) ((reflector i).obj B) ≫
          uncurry
              ((unitCompPartialBijective B ⋯)
                (curry
                  (prod.lift prod.snd prod.fst ≫
                    uncurry
                        ((unitCompPartialBijective A ⋯)
                          (curry
                            (prod.lift prod.snd prod.fst ≫
                              ((reflectorAdjunction i).homEquiv (A ⨯ B) X) f ≫ 𝟙 (i.obj X)))) ≫
                      𝟙 (i.obj X)))) ≫
            𝟙 (i.obj X)) ≫
      g
state_after: case a
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
X X' : D
f : (reflector i).obj (A ⨯ B) ⟶ X
g : X ⟶ X'
⊢ i.map
      (i.fullyFaithfulOfReflective.preimage
        (prodComparison i ((reflector i).obj A) ((reflector i).obj B) ≫
          uncurry
              ((unitCompPartialBijective B ⋯)
                (curry
                  (prod.lift prod.snd prod.fst ≫
                    uncurry
                        ((unitCompPartialBijective A ⋯)
                          (curry
                            (prod.lift prod.snd prod.fst ≫
                              ((reflectorAdjunction i).homEquiv (A ⨯ B) X') (f ≫ g) ≫ 𝟙 (i.obj X')))) ≫
                      𝟙 (i.obj X')))) ≫
            𝟙 (i.obj X'))) =
    i.map
      (i.fullyFaithfulOfReflective.preimage
          (prodComparison i ((reflector i).obj A) ((reflector i).obj B) ≫
            uncurry
                ((unitCompPartialBijective B ⋯)
                  (curry
                    (prod.lift prod.snd prod.fst ≫
                      uncurry
                          ((unitCompPartialBijective A ⋯)
                            (curry
                              (prod.lift prod.snd prod.fst ≫
                                ((reflectorAdjunction i).homEquiv (A ⨯ B) X) f ≫ 𝟙 (i.obj X)))) ≫
                        𝟙 (i.obj X)))) ≫
              𝟙 (i.obj X)) ≫
        g)
tactic: apply i.map_injective
state_before: case a
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
X X' : D
f : (reflector i).obj (A ⨯ B) ⟶ X
g : X ⟶ X'
⊢ i.map
      (i.fullyFaithfulOfReflective.preimage
        (prodComparison i ((reflector i).obj A) ((reflector i).obj B) ≫
          uncurry
              ((unitCompPartialBijective B ⋯)
                (curry
                  (prod.lift prod.snd prod.fst ≫
                    uncurry
                        ((unitCompPartialBijective A ⋯)
                          (curry
                            (prod.lift prod.snd prod.fst ≫
                              ((reflectorAdjunction i).homEquiv (A ⨯ B) X') (f ≫ g) ≫ 𝟙 (i.obj X')))) ≫
                      𝟙 (i.obj X')))) ≫
            𝟙 (i.obj X'))) =
    i.map
      (i.fullyFaithfulOfReflective.preimage
          (prodComparison i ((reflector i).obj A) ((reflector i).obj B) ≫
            uncurry
                ((unitCompPartialBijective B ⋯)
                  (curry
                    (prod.lift prod.snd prod.fst ≫
                      uncurry
                          ((unitCompPartialBijective A ⋯)
                            (curry
                              (prod.lift prod.snd prod.fst ≫
                                ((reflectorAdjunction i).homEquiv (A ⨯ B) X) f ≫ 𝟙 (i.obj X)))) ≫
                        𝟙 (i.obj X)))) ≫
              𝟙 (i.obj X)) ≫
        g)
state_after: no goals
tactic: rw [Functor.FullyFaithful.map_preimage, i.map_comp, Functor.FullyFaithful.map_preimage,
    comp_id, comp_id, comp_id, comp_id, comp_id,
    comp_id, Adjunction.homEquiv_naturality_right, ← assoc, curry_natural_right _ (i.map g),
    unitCompPartialBijective_natural, uncurry_natural_right, ← assoc, curry_natural_right,
    unitCompPartialBijective_natural, uncurry_natural_right, assoc]