l3lab/ntp-mathlib huggingface dataset:
/-- The liftings of a commutative are in bijection with the liftings of its (right)
adjoint square. -/
def rightAdjointLiftStructEquiv : sq.LiftStruct ≃ (sq.right_adjoint adj).LiftStruct
    where
  toFun l :=
    { l := adj.homEquiv _ _ l.l
      fac_left := by rw [← adj.homEquiv_naturality_left, l.fac_left]
      fac_right := by rw [← Adjunction.homEquiv_naturality_right, l.fac_right] }
  invFun l :=
    { l := (adj.homEquiv _ _).symm l.l
      fac_left := by
        rw [← Adjunction.homEquiv_naturality_left_symm, l.fac_left]
        apply (adj.homEquiv _ _).left_inv
      fac_right := by
        rw [← Adjunction.homEquiv_naturality_right_symm, l.fac_right]
        apply (adj.homEquiv _ _).left_inv }
  left_inv := by aesop_cat
  right_inv := by 

Proof state:
C : Type u_1
D : Type u_2
inst✝¹ : Category.{?u.1881, u_1} C
inst✝ : Category.{?u.1885, u_2} D
G : C ⥤ D
F : D ⥤ C
A B : C
X Y : D
i : A ⟶ B
p : X ⟶ Y
u : G.obj A ⟶ X
v : G.obj B ⟶ Y
sq : CommSq u (G.map i) p v
adj : G ⊣ F
⊢ Function.RightInverse
    (fun l =>
      { l := (Adjunction.homEquiv adj B X).symm l.l,
        fac_left := (_ : G.map i ≫ (Adjunction.homEquiv adj B X).symm l.l = u),
        fac_right := (_ : (Adjunction.homEquiv adj B X).symm l.l ≫ p = v) })
    fun l =>
    { l := (Adjunction.homEquiv adj B X) l.l,
      fac_left := (_ : i ≫ (Adjunction.homEquiv adj B X) l.l = (Adjunction.homEquiv adj A X) u),
      fac_right := (_ : (Adjunction.homEquiv adj B X) l.l ≫ F.map p = (Adjunction.homEquiv adj B Y) v) }

Next tactic:
aesop_cat
/-- A square has a lifting if and only if its (right) adjoint square has a lifting. -/
theorem right_adjoint_hasLift_iff : HasLift (sq.right_adjoint adj) ↔ HasLift sq := by
  

Proof state:
C : Type u_1
D : Type u_2
inst✝¹ : Category.{u_3, u_1} C
inst✝ : Category.{u_4, u_2} D
G : C ⥤ D
F : D ⥤ C
A B : C
X Y : D
i : A ⟶ B
p : X ⟶ Y
u : G.obj A ⟶ X
v : G.obj B ⟶ Y
sq : CommSq u (G.map i) p v
adj : G ⊣ F
⊢ HasLift (_ : CommSq ((Adjunction.homEquiv adj A X) u) i (F.map p) ((Adjunction.homEquiv adj B Y) v)) ↔ HasLift sq

Next tactic:
simp only [HasLift.iff]
/-- A square has a lifting if and only if its (right) adjoint square has a lifting. -/
theorem right_adjoint_hasLift_iff : HasLift (sq.right_adjoint adj) ↔ HasLift sq := by
  simp only [HasLift.iff]
  

Proof state:
C : Type u_1
D : Type u_2
inst✝¹ : Category.{u_3, u_1} C
inst✝ : Category.{u_4, u_2} D
G : C ⥤ D
F : D ⥤ C
A B : C
X Y : D
i : A ⟶ B
p : X ⟶ Y
u : G.obj A ⟶ X
v : G.obj B ⟶ Y
sq : CommSq u (G.map i) p v
adj : G ⊣ F
⊢ Nonempty (LiftStruct (_ : CommSq ((Adjunction.homEquiv adj A X) u) i (F.map p) ((Adjunction.homEquiv adj B Y) v))) ↔
    Nonempty (LiftStruct sq)

Next tactic:
exact Equiv.nonempty_congr (sq.rightAdjointLiftStructEquiv adj).symm
instance [HasLift sq] : HasLift (sq.right_adjoint adj) := by
  

Proof state:
C : Type u_1
D : Type u_2
inst✝² : Category.{?u.8806, u_1} C
inst✝¹ : Category.{?u.8810, u_2} D
G : C ⥤ D
F : D ⥤ C
A B : C
X Y : D
i : A ⟶ B
p : X ⟶ Y
u : G.obj A ⟶ X
v : G.obj B ⟶ Y
sq : CommSq u (G.map i) p v
adj : G ⊣ F
inst✝ : HasLift sq
⊢ HasLift (_ : CommSq ((Adjunction.homEquiv adj A X) u) i (F.map p) ((Adjunction.homEquiv adj B Y) v))

Next tactic:
rw [right_adjoint_hasLift_iff]
instance [HasLift sq] : HasLift (sq.right_adjoint adj) := by
  rw [right_adjoint_hasLift_iff]
  

Proof state:
C : Type u_1
D : Type u_2
inst✝² : Category.{?u.8806, u_1} C
inst✝¹ : Category.{?u.8810, u_2} D
G : C ⥤ D
F : D ⥤ C
A B : C
X Y : D
i : A ⟶ B
p : X ⟶ Y
u : G.obj A ⟶ X
v : G.obj B ⟶ Y
sq : CommSq u (G.map i) p v
adj : G ⊣ F
inst✝ : HasLift sq
⊢ HasLift ?sq
case sq
C : Type u_1
D : Type u_2
inst✝² : Category.{?u.8806, u_1} C
inst✝¹ : Category.{?u.8810, u_2} D
G : C ⥤ D
F : D ⥤ C
A B : C
X Y : D
i : A ⟶ B
p : X ⟶ Y
u : G.obj A ⟶ X
v : G.obj B ⟶ Y
sq : CommSq u (G.map i) p v
adj : G ⊣ F
inst✝ : HasLift sq
⊢ CommSq u (G.map i) p v

Next tactic:
infer_instance
/-- When we have an adjunction `G ⊣ F`, any commutative square where the left
map is of the form `i` and the right map is `F.map p` has an "adjoint" commutative
square whose left map is `G.map i` and whose right map is `p`. -/
theorem left_adjoint : CommSq ((adj.homEquiv _ _).symm u) (G.map i) p ((adj.homEquiv _ _).symm v) :=
  ⟨by
    

Proof state:
C : Type u_1
D : Type u_2
inst✝¹ : Category.{u_4, u_1} C
inst✝ : Category.{u_3, u_2} D
G : C ⥤ D
F : D ⥤ C
A B : C
X Y : D
i : A ⟶ B
p : X ⟶ Y
u : A ⟶ F.obj X
v : B ⟶ F.obj Y
sq : CommSq u i (F.map p) v
adj : G ⊣ F
⊢ (Adjunction.homEquiv adj A X).symm u ≫ p = G.map i ≫ (Adjunction.homEquiv adj B Y).symm v

Next tactic:
simp only [Adjunction.homEquiv_counit, assoc, ← G.map_comp_assoc, ← sq.w]
/-- When we have an adjunction `G ⊣ F`, any commutative square where the left
map is of the form `i` and the right map is `F.map p` has an "adjoint" commutative
square whose left map is `G.map i` and whose right map is `p`. -/
theorem left_adjoint : CommSq ((adj.homEquiv _ _).symm u) (G.map i) p ((adj.homEquiv _ _).symm v) :=
  ⟨by
    simp only [Adjunction.homEquiv_counit, assoc, ← G.map_comp_assoc, ← sq.w]
    

Proof state:
C : Type u_1
D : Type u_2
inst✝¹ : Category.{u_4, u_1} C
inst✝ : Category.{u_3, u_2} D
G : C ⥤ D
F : D ⥤ C
A B : C
X Y : D
i : A ⟶ B
p : X ⟶ Y
u : A ⟶ F.obj X
v : B ⟶ F.obj Y
sq : CommSq u i (F.map p) v
adj : G ⊣ F
⊢ G.map u ≫ adj.counit.app X ≫ p = G.map (u ≫ F.map p) ≫ adj.counit.app Y

Next tactic:
rw [G.map_comp, assoc, Adjunction.counit_naturality]
/-- The liftings of a commutative are in bijection with the liftings of its (left)
adjoint square. -/
def leftAdjointLiftStructEquiv : sq.LiftStruct ≃ (sq.left_adjoint adj).LiftStruct
    where
  toFun l :=
    { l := (adj.homEquiv _ _).symm l.l
      fac_left := by 

Proof state:
C : Type u_1
D : Type u_2
inst✝¹ : Category.{?u.12026, u_1} C
inst✝ : Category.{?u.12030, u_2} D
G : C ⥤ D
F : D ⥤ C
A B : C
X Y : D
i : A ⟶ B
p : X ⟶ Y
u : A ⟶ F.obj X
v : B ⟶ F.obj Y
sq : CommSq u i (F.map p) v
adj : G ⊣ F
l : LiftStruct sq
⊢ G.map i ≫ (Adjunction.homEquiv adj B X).symm l.l = (Adjunction.homEquiv adj A X).symm u

Next tactic:
rw [← adj.homEquiv_naturality_left_symm, l.fac_left]
/-- The liftings of a commutative are in bijection with the liftings of its (left)
adjoint square. -/
def leftAdjointLiftStructEquiv : sq.LiftStruct ≃ (sq.left_adjoint adj).LiftStruct
    where
  toFun l :=
    { l := (adj.homEquiv _ _).symm l.l
      fac_left := by rw [← adj.homEquiv_naturality_left_symm, l.fac_left]
      fac_right := by 

Proof state:
C : Type u_1
D : Type u_2
inst✝¹ : Category.{?u.12026, u_1} C
inst✝ : Category.{?u.12030, u_2} D
G : C ⥤ D
F : D ⥤ C
A B : C
X Y : D
i : A ⟶ B
p : X ⟶ Y
u : A ⟶ F.obj X
v : B ⟶ F.obj Y
sq : CommSq u i (F.map p) v
adj : G ⊣ F
l : LiftStruct sq
⊢ (Adjunction.homEquiv adj B X).symm l.l ≫ p = (Adjunction.homEquiv adj B Y).symm v

Next tactic:
rw [← adj.homEquiv_naturality_right_symm, l.fac_right]
/-- The liftings of a commutative are in bijection with the liftings of its (left)
adjoint square. -/
def leftAdjointLiftStructEquiv : sq.LiftStruct ≃ (sq.left_adjoint adj).LiftStruct
    where
  toFun l :=
    { l := (adj.homEquiv _ _).symm l.l
      fac_left := by rw [← adj.homEquiv_naturality_left_symm, l.fac_left]
      fac_right := by rw [← adj.homEquiv_naturality_right_symm, l.fac_right] }
  invFun l :=
    { l := (adj.homEquiv _ _) l.l
      fac_left := by
        

Proof state:
C : Type u_1
D : Type u_2
inst✝¹ : Category.{?u.12026, u_1} C
inst✝ : Category.{?u.12030, u_2} D
G : C ⥤ D
F : D ⥤ C
A B : C
X Y : D
i : A ⟶ B
p : X ⟶ Y
u : A ⟶ F.obj X
v : B ⟶ F.obj Y
sq : CommSq u i (F.map p) v
adj : G ⊣ F
l : LiftStruct (_ : CommSq ((Adjunction.homEquiv adj A X).symm u) (G.map i) p ((Adjunction.homEquiv adj B Y).symm v))
⊢ i ≫ (Adjunction.homEquiv adj B X) l.l = u

Next tactic:
rw [← adj.homEquiv_naturality_left, l.fac_left]
/-- The liftings of a commutative are in bijection with the liftings of its (left)
adjoint square. -/
def leftAdjointLiftStructEquiv : sq.LiftStruct ≃ (sq.left_adjoint adj).LiftStruct
    where
  toFun l :=
    { l := (adj.homEquiv _ _).symm l.l
      fac_left := by rw [← adj.homEquiv_naturality_left_symm, l.fac_left]
      fac_right := by rw [← adj.homEquiv_naturality_right_symm, l.fac_right] }
  invFun l :=
    { l := (adj.homEquiv _ _) l.l
      fac_left := by
        rw [← adj.homEquiv_naturality_left, l.fac_left]
        

Proof state:
C : Type u_1
D : Type u_2
inst✝¹ : Category.{?u.12026, u_1} C
inst✝ : Category.{?u.12030, u_2} D
G : C ⥤ D
F : D ⥤ C
A B : C
X Y : D
i : A ⟶ B
p : X ⟶ Y
u : A ⟶ F.obj X
v : B ⟶ F.obj Y
sq : CommSq u i (F.map p) v
adj : G ⊣ F
l : LiftStruct (_ : CommSq ((Adjunction.homEquiv adj A X).symm u) (G.map i) p ((Adjunction.homEquiv adj B Y).symm v))
⊢ (Adjunction.homEquiv adj A X) ((Adjunction.homEquiv adj A X).symm u) = u

Next tactic:
apply (adj.homEquiv _ _).right_inv
/-- The liftings of a commutative are in bijection with the liftings of its (left)
adjoint square. -/
def leftAdjointLiftStructEquiv : sq.LiftStruct ≃ (sq.left_adjoint adj).LiftStruct
    where
  toFun l :=
    { l := (adj.homEquiv _ _).symm l.l
      fac_left := by rw [← adj.homEquiv_naturality_left_symm, l.fac_left]
      fac_right := by rw [← adj.homEquiv_naturality_right_symm, l.fac_right] }
  invFun l :=
    { l := (adj.homEquiv _ _) l.l
      fac_left := by
        rw [← adj.homEquiv_naturality_left, l.fac_left]
        apply (adj.homEquiv _ _).right_inv
      fac_right := by
        

Proof state:
C : Type u_1
D : Type u_2
inst✝¹ : Category.{?u.12026, u_1} C
inst✝ : Category.{?u.12030, u_2} D
G : C ⥤ D
F : D ⥤ C
A B : C
X Y : D
i : A ⟶ B
p : X ⟶ Y
u : A ⟶ F.obj X
v : B ⟶ F.obj Y
sq : CommSq u i (F.map p) v
adj : G ⊣ F
l : LiftStruct (_ : CommSq ((Adjunction.homEquiv adj A X).symm u) (G.map i) p ((Adjunction.homEquiv adj B Y).symm v))
⊢ (Adjunction.homEquiv adj B X) l.l ≫ F.map p = v

Next tactic:
rw [← adj.homEquiv_naturality_right, l.fac_right]
/-- The liftings of a commutative are in bijection with the liftings of its (left)
adjoint square. -/
def leftAdjointLiftStructEquiv : sq.LiftStruct ≃ (sq.left_adjoint adj).LiftStruct
    where
  toFun l :=
    { l := (adj.homEquiv _ _).symm l.l
      fac_left := by rw [← adj.homEquiv_naturality_left_symm, l.fac_left]
      fac_right := by rw [← adj.homEquiv_naturality_right_symm, l.fac_right] }
  invFun l :=
    { l := (adj.homEquiv _ _) l.l
      fac_left := by
        rw [← adj.homEquiv_naturality_left, l.fac_left]
        apply (adj.homEquiv _ _).right_inv
      fac_right := by
        rw [← adj.homEquiv_naturality_right, l.fac_right]
        

Proof state:
C : Type u_1
D : Type u_2
inst✝¹ : Category.{?u.12026, u_1} C
inst✝ : Category.{?u.12030, u_2} D
G : C ⥤ D
F : D ⥤ C
A B : C
X Y : D
i : A ⟶ B
p : X ⟶ Y
u : A ⟶ F.obj X
v : B ⟶ F.obj Y
sq : CommSq u i (F.map p) v
adj : G ⊣ F
l : LiftStruct (_ : CommSq ((Adjunction.homEquiv adj A X).symm u) (G.map i) p ((Adjunction.homEquiv adj B Y).symm v))
⊢ (Adjunction.homEquiv adj B Y) ((Adjunction.homEquiv adj B Y).symm v) = v

Next tactic:
apply (adj.homEquiv _ _).right_inv
/-- The liftings of a commutative are in bijection with the liftings of its (left)
adjoint square. -/
def leftAdjointLiftStructEquiv : sq.LiftStruct ≃ (sq.left_adjoint adj).LiftStruct
    where
  toFun l :=
    { l := (adj.homEquiv _ _).symm l.l
      fac_left := by rw [← adj.homEquiv_naturality_left_symm, l.fac_left]
      fac_right := by rw [← adj.homEquiv_naturality_right_symm, l.fac_right] }
  invFun l :=
    { l := (adj.homEquiv _ _) l.l
      fac_left := by
        rw [← adj.homEquiv_naturality_left, l.fac_left]
        apply (adj.homEquiv _ _).right_inv
      fac_right := by
        rw [← adj.homEquiv_naturality_right, l.fac_right]
        apply (adj.homEquiv _ _).right_inv }
  left_inv := by 

Proof state:
C : Type u_1
D : Type u_2
inst✝¹ : Category.{?u.12026, u_1} C
inst✝ : Category.{?u.12030, u_2} D
G : C ⥤ D
F : D ⥤ C
A B : C
X Y : D
i : A ⟶ B
p : X ⟶ Y
u : A ⟶ F.obj X
v : B ⟶ F.obj Y
sq : CommSq u i (F.map p) v
adj : G ⊣ F
⊢ Function.LeftInverse
    (fun l =>
      { l := (Adjunction.homEquiv adj B X) l.l, fac_left := (_ : i ≫ (Adjunction.homEquiv adj B X) l.l = u),
        fac_right := (_ : (Adjunction.homEquiv adj B X) l.l ≫ F.map p = v) })
    fun l =>
    { l := (Adjunction.homEquiv adj B X).symm l.l,
      fac_left := (_ : G.map i ≫ (Adjunction.homEquiv adj B X).symm l.l = (Adjunction.homEquiv adj A X).symm u),
      fac_right := (_ : (Adjunction.homEquiv adj B X).symm l.l ≫ p = (Adjunction.homEquiv adj B Y).symm v) }

Next tactic:
aesop_cat
/-- The liftings of a commutative are in bijection with the liftings of its (left)
adjoint square. -/
def leftAdjointLiftStructEquiv : sq.LiftStruct ≃ (sq.left_adjoint adj).LiftStruct
    where
  toFun l :=
    { l := (adj.homEquiv _ _).symm l.l
      fac_left := by rw [← adj.homEquiv_naturality_left_symm, l.fac_left]
      fac_right := by rw [← adj.homEquiv_naturality_right_symm, l.fac_right] }
  invFun l :=
    { l := (adj.homEquiv _ _) l.l
      fac_left := by
        rw [← adj.homEquiv_naturality_left, l.fac_left]
        apply (adj.homEquiv _ _).right_inv
      fac_right := by
        rw [← adj.homEquiv_naturality_right, l.fac_right]
        apply (adj.homEquiv _ _).right_inv }
  left_inv := by aesop_cat
  right_inv := by 

Proof state:
C : Type u_1
D : Type u_2
inst✝¹ : Category.{?u.12026, u_1} C
inst✝ : Category.{?u.12030, u_2} D
G : C ⥤ D
F : D ⥤ C
A B : C
X Y : D
i : A ⟶ B
p : X ⟶ Y
u : A ⟶ F.obj X
v : B ⟶ F.obj Y
sq : CommSq u i (F.map p) v
adj : G ⊣ F
⊢ Function.RightInverse
    (fun l =>
      { l := (Adjunction.homEquiv adj B X) l.l, fac_left := (_ : i ≫ (Adjunction.homEquiv adj B X) l.l = u),
        fac_right := (_ : (Adjunction.homEquiv adj B X) l.l ≫ F.map p = v) })
    fun l =>
    { l := (Adjunction.homEquiv adj B X).symm l.l,
      fac_left := (_ : G.map i ≫ (Adjunction.homEquiv adj B X).symm l.l = (Adjunction.homEquiv adj A X).symm u),
      fac_right := (_ : (Adjunction.homEquiv adj B X).symm l.l ≫ p = (Adjunction.homEquiv adj B Y).symm v) }

Next tactic:
aesop_cat
/-- A (left) adjoint square has a lifting if and only if the original square has a lifting. -/
theorem left_adjoint_hasLift_iff : HasLift (sq.left_adjoint adj) ↔ HasLift sq := by
  

Proof state:
C : Type u_1
D : Type u_2
inst✝¹ : Category.{u_4, u_1} C
inst✝ : Category.{u_3, u_2} D
G : C ⥤ D
F : D ⥤ C
A B : C
X Y : D
i : A ⟶ B
p : X ⟶ Y
u : A ⟶ F.obj X
v : B ⟶ F.obj Y
sq : CommSq u i (F.map p) v
adj : G ⊣ F
⊢ HasLift (_ : CommSq ((Adjunction.homEquiv adj A X).symm u) (G.map i) p ((Adjunction.homEquiv adj B Y).symm v)) ↔
    HasLift sq

Next tactic:
simp only [HasLift.iff]
/-- A (left) adjoint square has a lifting if and only if the original square has a lifting. -/
theorem left_adjoint_hasLift_iff : HasLift (sq.left_adjoint adj) ↔ HasLift sq := by
  simp only [HasLift.iff]
  

Proof state:
C : Type u_1
D : Type u_2
inst✝¹ : Category.{u_4, u_1} C
inst✝ : Category.{u_3, u_2} D
G : C ⥤ D
F : D ⥤ C
A B : C
X Y : D
i : A ⟶ B
p : X ⟶ Y
u : A ⟶ F.obj X
v : B ⟶ F.obj Y
sq : CommSq u i (F.map p) v
adj : G ⊣ F
⊢ Nonempty
      (LiftStruct
        (_ : CommSq ((Adjunction.homEquiv adj A X).symm u) (G.map i) p ((Adjunction.homEquiv adj B Y).symm v))) ↔
    Nonempty (LiftStruct sq)

Next tactic:
exact Equiv.nonempty_congr (sq.leftAdjointLiftStructEquiv adj).symm
instance [HasLift sq] : HasLift (sq.left_adjoint adj) := by
  

Proof state:
C : Type u_1
D : Type u_2
inst✝² : Category.{?u.18591, u_1} C
inst✝¹ : Category.{?u.18595, u_2} D
G : C ⥤ D
F : D ⥤ C
A B : C
X Y : D
i : A ⟶ B
p : X ⟶ Y
u : A ⟶ F.obj X
v : B ⟶ F.obj Y
sq : CommSq u i (F.map p) v
adj : G ⊣ F
inst✝ : HasLift sq
⊢ HasLift (_ : CommSq ((Adjunction.homEquiv adj A X).symm u) (G.map i) p ((Adjunction.homEquiv adj B Y).symm v))

Next tactic:
rw [left_adjoint_hasLift_iff]
instance [HasLift sq] : HasLift (sq.left_adjoint adj) := by
  rw [left_adjoint_hasLift_iff]
  

Proof state:
C : Type u_1
D : Type u_2
inst✝² : Category.{?u.18591, u_1} C
inst✝¹ : Category.{?u.18595, u_2} D
G : C ⥤ D
F : D ⥤ C
A B : C
X Y : D
i : A ⟶ B
p : X ⟶ Y
u : A ⟶ F.obj X
v : B ⟶ F.obj Y
sq : CommSq u i (F.map p) v
adj : G ⊣ F
inst✝ : HasLift sq
⊢ HasLift ?sq
case sq
C : Type u_1
D : Type u_2
inst✝² : Category.{?u.18591, u_1} C
inst✝¹ : Category.{?u.18595, u_2} D
G : C ⥤ D
F : D ⥤ C
A B : C
X Y : D
i : A ⟶ B
p : X ⟶ Y
u : A ⟶ F.obj X
v : B ⟶ F.obj Y
sq : CommSq u i (F.map p) v
adj : G ⊣ F
inst✝ : HasLift sq
⊢ CommSq u i (F.map p) v

Next tactic:
infer_instance
theorem hasLiftingProperty_iff (adj : G ⊣ F) {A B : C} {X Y : D} (i : A ⟶ B) (p : X ⟶ Y) :
    HasLiftingProperty (G.map i) p ↔ HasLiftingProperty i (F.map p) := by
  

Proof state:
C : Type u_1
D : Type u_2
inst✝¹ : Category.{u_3, u_1} C
inst✝ : Category.{u_4, u_2} D
G : C ⥤ D
F : D ⥤ C
adj : G ⊣ F
A B : C
X Y : D
i : A ⟶ B
p : X ⟶ Y
⊢ HasLiftingProperty (G.map i) p ↔ HasLiftingProperty i (F.map p)

Next tactic:
constructor
theorem hasLiftingProperty_iff (adj : G ⊣ F) {A B : C} {X Y : D} (i : A ⟶ B) (p : X ⟶ Y) :
    HasLiftingProperty (G.map i) p ↔ HasLiftingProperty i (F.map p) := by
  constructor <;> 

Proof state:
case mp
C : Type u_1
D : Type u_2
inst✝¹ : Category.{u_3, u_1} C
inst✝ : Category.{u_4, u_2} D
G : C ⥤ D
F : D ⥤ C
adj : G ⊣ F
A B : C
X Y : D
i : A ⟶ B
p : X ⟶ Y
⊢ HasLiftingProperty (G.map i) p → HasLiftingProperty i (F.map p)

Next tactic:
intro
theorem hasLiftingProperty_iff (adj : G ⊣ F) {A B : C} {X Y : D} (i : A ⟶ B) (p : X ⟶ Y) :
    HasLiftingProperty (G.map i) p ↔ HasLiftingProperty i (F.map p) := by
  constructor <;> 

Proof state:
case mpr
C : Type u_1
D : Type u_2
inst✝¹ : Category.{u_3, u_1} C
inst✝ : Category.{u_4, u_2} D
G : C ⥤ D
F : D ⥤ C
adj : G ⊣ F
A B : C
X Y : D
i : A ⟶ B
p : X ⟶ Y
⊢ HasLiftingProperty i (F.map p) → HasLiftingProperty (G.map i) p

Next tactic:
intro
theorem hasLiftingProperty_iff (adj : G ⊣ F) {A B : C} {X Y : D} (i : A ⟶ B) (p : X ⟶ Y) :
    HasLiftingProperty (G.map i) p ↔ HasLiftingProperty i (F.map p) := by
  constructor <;> intro <;> 

Proof state:
case mp
C : Type u_1
D : Type u_2
inst✝¹ : Category.{u_3, u_1} C
inst✝ : Category.{u_4, u_2} D
G : C ⥤ D
F : D ⥤ C
adj : G ⊣ F
A B : C
X Y : D
i : A ⟶ B
p : X ⟶ Y
a✝ : HasLiftingProperty (G.map i) p
⊢ HasLiftingProperty i (F.map p)

Next tactic:
constructor
theorem hasLiftingProperty_iff (adj : G ⊣ F) {A B : C} {X Y : D} (i : A ⟶ B) (p : X ⟶ Y) :
    HasLiftingProperty (G.map i) p ↔ HasLiftingProperty i (F.map p) := by
  constructor <;> intro <;> 

Proof state:
case mpr
C : Type u_1
D : Type u_2
inst✝¹ : Category.{u_3, u_1} C
inst✝ : Category.{u_4, u_2} D
G : C ⥤ D
F : D ⥤ C
adj : G ⊣ F
A B : C
X Y : D
i : A ⟶ B
p : X ⟶ Y
a✝ : HasLiftingProperty i (F.map p)
⊢ HasLiftingProperty (G.map i) p

Next tactic:
constructor
theorem hasLiftingProperty_iff (adj : G ⊣ F) {A B : C} {X Y : D} (i : A ⟶ B) (p : X ⟶ Y) :
    HasLiftingProperty (G.map i) p ↔ HasLiftingProperty i (F.map p) := by
  constructor <;> intro <;> constructor <;> 

Proof state:
case mp.sq_hasLift
C : Type u_1
D : Type u_2
inst✝¹ : Category.{u_3, u_1} C
inst✝ : Category.{u_4, u_2} D
G : C ⥤ D
F : D ⥤ C
adj : G ⊣ F
A B : C
X Y : D
i : A ⟶ B
p : X ⟶ Y
a✝ : HasLiftingProperty (G.map i) p
⊢ ∀ {f : A ⟶ F.obj X} {g : B ⟶ F.obj Y} (sq : CommSq f i (F.map p) g), CommSq.HasLift sq

Next tactic:
intro f g sq
theorem hasLiftingProperty_iff (adj : G ⊣ F) {A B : C} {X Y : D} (i : A ⟶ B) (p : X ⟶ Y) :
    HasLiftingProperty (G.map i) p ↔ HasLiftingProperty i (F.map p) := by
  constructor <;> intro <;> constructor <;> 

Proof state:
case mpr.sq_hasLift
C : Type u_1
D : Type u_2
inst✝¹ : Category.{u_3, u_1} C
inst✝ : Category.{u_4, u_2} D
G : C ⥤ D
F : D ⥤ C
adj : G ⊣ F
A B : C
X Y : D
i : A ⟶ B
p : X ⟶ Y
a✝ : HasLiftingProperty i (F.map p)
⊢ ∀ {f : G.obj A ⟶ X} {g : G.obj B ⟶ Y} (sq : CommSq f (G.map i) p g), CommSq.HasLift sq

Next tactic:
intro f g sq
theorem hasLiftingProperty_iff (adj : G ⊣ F) {A B : C} {X Y : D} (i : A ⟶ B) (p : X ⟶ Y) :
    HasLiftingProperty (G.map i) p ↔ HasLiftingProperty i (F.map p) := by
  constructor <;> intro <;> constructor <;> intro f g sq
  · 

Proof state:
case mp.sq_hasLift
C : Type u_1
D : Type u_2
inst✝¹ : Category.{u_3, u_1} C
inst✝ : Category.{u_4, u_2} D
G : C ⥤ D
F : D ⥤ C
adj : G ⊣ F
A B : C
X Y : D
i : A ⟶ B
p : X ⟶ Y
a✝ : HasLiftingProperty (G.map i) p
f : A ⟶ F.obj X
g : B ⟶ F.obj Y
sq : CommSq f i (F.map p) g
⊢ CommSq.HasLift sq

Next tactic:
rw [← sq.left_adjoint_hasLift_iff adj]
theorem hasLiftingProperty_iff (adj : G ⊣ F) {A B : C} {X Y : D} (i : A ⟶ B) (p : X ⟶ Y) :
    HasLiftingProperty (G.map i) p ↔ HasLiftingProperty i (F.map p) := by
  constructor <;> intro <;> constructor <;> intro f g sq
  · rw [← sq.left_adjoint_hasLift_iff adj]
    

Proof state:
case mp.sq_hasLift
C : Type u_1
D : Type u_2
inst✝¹ : Category.{u_3, u_1} C
inst✝ : Category.{u_4, u_2} D
G : C ⥤ D
F : D ⥤ C
adj : G ⊣ F
A B : C
X Y : D
i : A ⟶ B
p : X ⟶ Y
a✝ : HasLiftingProperty (G.map i) p
f : A ⟶ F.obj X
g : B ⟶ F.obj Y
sq : CommSq f i (F.map p) g
⊢ CommSq.HasLift (_ : CommSq ((homEquiv adj A X).symm f) (G.map i) p ((homEquiv adj B Y).symm g))

Next tactic:
infer_instance
theorem hasLiftingProperty_iff (adj : G ⊣ F) {A B : C} {X Y : D} (i : A ⟶ B) (p : X ⟶ Y) :
    HasLiftingProperty (G.map i) p ↔ HasLiftingProperty i (F.map p) := by
  constructor <;> intro <;> constructor <;> intro f g sq
  · rw [← sq.left_adjoint_hasLift_iff adj]
    infer_instance
  · 

Proof state:
case mpr.sq_hasLift
C : Type u_1
D : Type u_2
inst✝¹ : Category.{u_3, u_1} C
inst✝ : Category.{u_4, u_2} D
G : C ⥤ D
F : D ⥤ C
adj : G ⊣ F
A B : C
X Y : D
i : A ⟶ B
p : X ⟶ Y
a✝ : HasLiftingProperty i (F.map p)
f : G.obj A ⟶ X
g : G.obj B ⟶ Y
sq : CommSq f (G.map i) p g
⊢ CommSq.HasLift sq

Next tactic:
rw [← sq.right_adjoint_hasLift_iff adj]
theorem hasLiftingProperty_iff (adj : G ⊣ F) {A B : C} {X Y : D} (i : A ⟶ B) (p : X ⟶ Y) :
    HasLiftingProperty (G.map i) p ↔ HasLiftingProperty i (F.map p) := by
  constructor <;> intro <;> constructor <;> intro f g sq
  · rw [← sq.left_adjoint_hasLift_iff adj]
    infer_instance
  · rw [← sq.right_adjoint_hasLift_iff adj]
    

Proof state:
case mpr.sq_hasLift
C : Type u_1
D : Type u_2
inst✝¹ : Category.{u_3, u_1} C
inst✝ : Category.{u_4, u_2} D
G : C ⥤ D
F : D ⥤ C
adj : G ⊣ F
A B : C
X Y : D
i : A ⟶ B
p : X ⟶ Y
a✝ : HasLiftingProperty i (F.map p)
f : G.obj A ⟶ X
g : G.obj B ⟶ Y
sq : CommSq f (G.map i) p g
⊢ CommSq.HasLift (_ : CommSq ((homEquiv adj A X) f) i (F.map p) ((homEquiv adj B Y) g))

Next tactic:
infer_instance
@[ext]
theorem ComponentCompl.supp_injective :
    Function.Injective (ComponentCompl.supp : G.ComponentCompl K → Set V) := by
  

Proof state:
V : Type u
G : SimpleGraph V
K L L' M : Set V
⊢ Function.Injective supp

Next tactic:
refine' ConnectedComponent.ind₂ _
@[ext]
theorem ComponentCompl.supp_injective :
    Function.Injective (ComponentCompl.supp : G.ComponentCompl K → Set V) := by
  refine' ConnectedComponent.ind₂ _
  

Proof state:
V : Type u
G : SimpleGraph V
K L L' M : Set V
⊢ ∀ (v w : ↑Kᶜ),
    supp (connectedComponentMk (induce Kᶜ G) v) = supp (connectedComponentMk (induce Kᶜ G) w) →
      connectedComponentMk (induce Kᶜ G) v = connectedComponentMk (induce Kᶜ G) w

Next tactic:
rintro ⟨v, hv⟩ ⟨w, hw⟩ h
@[ext]
theorem ComponentCompl.supp_injective :
    Function.Injective (ComponentCompl.supp : G.ComponentCompl K → Set V) := by
  refine' ConnectedComponent.ind₂ _
  rintro ⟨v, hv⟩ ⟨w, hw⟩ h
  

Proof state:
case mk.mk
V : Type u
G : SimpleGraph V
K L L' M : Set V
v : V
hv : v ∈ Kᶜ
w : V
hw : w ∈ Kᶜ
h :
  supp (connectedComponentMk (induce Kᶜ G) { val := v, property := hv }) =
    supp (connectedComponentMk (induce Kᶜ G) { val := w, property := hw })
⊢ connectedComponentMk (induce Kᶜ G) { val := v, property := hv } =
    connectedComponentMk (induce Kᶜ G) { val := w, property := hw }

Next tactic:
simp only [Set.ext_iff, ConnectedComponent.eq, Set.mem_setOf_eq, ComponentCompl.supp] at h ⊢