[GOAL]
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
S S' S'' : D
Y Y' : C
T T' : C ⥤ D
A B : StructuredArrow S T
f : A ⟶ B
⊢ A.hom ≫ T.map f.right = B.hom
[PROOFSTEP]
have := f.w
[GOAL]
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
S S' S'' : D
Y Y' : C
T T' : C ⥤ D
A B : StructuredArrow S T
f : A ⟶ B
this : (Functor.fromPUnit S).map f.left ≫ B.hom = A.hom ≫ T.map f.right
⊢ A.hom ≫ T.map f.right = B.hom
[PROOFSTEP]
aesop_cat
[GOAL]
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
S S' S'' : D
Y Y' : C
T T' : C ⥤ D
f f' : StructuredArrow S T
g : f.right ⟶ f'.right
w : autoParam (f.hom ≫ T.map g = f'.hom) _auto✝
⊢ f.left = f'.left
[PROOFSTEP]
ext
[GOAL]
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
S S' S'' : D
Y Y' : C
T T' : C ⥤ D
f f' : StructuredArrow S T
g : f.right ⟶ f'.right
w : autoParam (f.hom ≫ T.map g = f'.hom) _auto✝
⊢ (Functor.fromPUnit S).map (eqToHom (_ : f.left = f'.left)) ≫ f'.hom = f.hom ≫ T.map g
[PROOFSTEP]
dsimp
[GOAL]
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
S S' S'' : D
Y Y' : C
T T' : C ⥤ D
f f' : StructuredArrow S T
g : f.right ⟶ f'.right
w : autoParam (f.hom ≫ T.map g = f'.hom) _auto✝
⊢ 𝟙 S ≫ f'.hom = f.hom ≫ T.map g
[PROOFSTEP]
simpa using w.symm
[GOAL]
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
S S' S'' : D
Y Y' : C
T T' : C ⥤ D
f : StructuredArrow S T
g : f.right ⟶ Y'
⊢ f.left = (mk (f.hom ≫ T.map g)).left
[PROOFSTEP]
ext
[GOAL]
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
S S' S'' : D
Y Y' : C
T T' : C ⥤ D
f f' : StructuredArrow S T
g : f.right ≅ f'.right
w : autoParam (f.hom ≫ T.map g.hom = f'.hom) _auto✝
⊢ f.left = f'.left
[PROOFSTEP]
ext
[GOAL]
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
S S' S'' : D
Y Y' : C
T T' : C ⥤ D
f f' : StructuredArrow S T
g : f.right ≅ f'.right
w : autoParam (f.hom ≫ T.map g.hom = f'.hom) _auto✝
⊢ (Functor.fromPUnit S).map (eqToIso (_ : f.left = f'.left)).hom ≫ f'.hom = f.hom ≫ T.map g.hom
[PROOFSTEP]
simpa [eqToHom_map] using w.symm
[GOAL]
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
S S' S'' : D
Y Y' : C
T T' : C ⥤ D
f : StructuredArrow S T
⊢ (map (𝟙 S)).obj f = f
[PROOFSTEP]
rw [eq_mk f]
[GOAL]
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
S S' S'' : D
Y Y' : C
T T' : C ⥤ D
f : StructuredArrow S T
⊢ (map (𝟙 S)).obj (mk f.hom) = mk f.hom
[PROOFSTEP]
simp
[GOAL]
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
S S' S'' : D
Y Y' : C
T T' : C ⥤ D
f : S ⟶ S'
f' : S' ⟶ S''
h : StructuredArrow S'' T
⊢ (map (f ≫ f')).obj h = (map f).obj ((map f').obj h)
[PROOFSTEP]
rw [eq_mk h]
[GOAL]
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
S S' S'' : D
Y Y' : C
T T' : C ⥤ D
f : S ⟶ S'
f' : S' ⟶ S''
h : StructuredArrow S'' T
⊢ (map (f ≫ f')).obj (mk h.hom) = (map f).obj ((map f').obj (mk h.hom))
[PROOFSTEP]
simp
[GOAL]
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
S S' S'' : D
Y✝ Y' : C
T T' : C ⥤ D
Y Z : StructuredArrow S T
f : Y ⟶ Z
t : IsIso ((proj S T).map f)
⊢ Z.hom ≫ T.map (inv ((proj S T).map f)) = Y.hom
[PROOFSTEP]
rw [Functor.map_inv, IsIso.comp_inv_eq]
[GOAL]
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
S S' S'' : D
Y✝ Y' : C
T T' : C ⥤ D
Y Z : StructuredArrow S T
f : Y ⟶ Z
t : IsIso ((proj S T).map f)
⊢ Z.hom = Y.hom ≫ T.map ((proj S T).map f)
[PROOFSTEP]
simp
[GOAL]
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
S S' S'' : D
Y✝ Y' : C
T T' : C ⥤ D
Y Z : StructuredArrow S T
f : Y ⟶ Z
t : IsIso ((proj S T).map f)
⊢ f ≫ homMk (inv ((proj S T).map f)) = 𝟙 Y ∧ homMk (inv ((proj S T).map f)) ≫ f = 𝟙 Z
[PROOFSTEP]
constructor
[GOAL]
case left
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
S S' S'' : D
Y✝ Y' : C
T T' : C ⥤ D
Y Z : StructuredArrow S T
f : Y ⟶ Z
t : IsIso ((proj S T).map f)
⊢ f ≫ homMk (inv ((proj S T).map f)) = 𝟙 Y
[PROOFSTEP]
apply CommaMorphism.ext
[GOAL]
case right
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
S S' S'' : D
Y✝ Y' : C
T T' : C ⥤ D
Y Z : StructuredArrow S T
f : Y ⟶ Z
t : IsIso ((proj S T).map f)
⊢ homMk (inv ((proj S T).map f)) ≫ f = 𝟙 Z
[PROOFSTEP]
apply CommaMorphism.ext
[GOAL]
case left.left
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
S S' S'' : D
Y✝ Y' : C
T T' : C ⥤ D
Y Z : StructuredArrow S T
f : Y ⟶ Z
t : IsIso ((proj S T).map f)
⊢ (f ≫ homMk (inv ((proj S T).map f))).left = (𝟙 Y).left
[PROOFSTEP]
dsimp at t ⊢
[GOAL]
case left.right
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
S S' S'' : D
Y✝ Y' : C
T T' : C ⥤ D
Y Z : StructuredArrow S T
f : Y ⟶ Z
t : IsIso ((proj S T).map f)
⊢ (f ≫ homMk (inv ((proj S T).map f))).right = (𝟙 Y).right
[PROOFSTEP]
dsimp at t ⊢
[GOAL]
case right.left
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
S S' S'' : D
Y✝ Y' : C
T T' : C ⥤ D
Y Z : StructuredArrow S T
f : Y ⟶ Z
t : IsIso ((proj S T).map f)
⊢ (homMk (inv ((proj S T).map f)) ≫ f).left = (𝟙 Z).left
[PROOFSTEP]
dsimp at t ⊢
[GOAL]
case right.right
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
S S' S'' : D
Y✝ Y' : C
T T' : C ⥤ D
Y Z : StructuredArrow S T
f : Y ⟶ Z
t : IsIso ((proj S T).map f)
⊢ (homMk (inv ((proj S T).map f)) ≫ f).right = (𝟙 Z).right
[PROOFSTEP]
dsimp at t ⊢
[GOAL]
case left.right
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
S S' S'' : D
Y✝ Y' : C
T T' : C ⥤ D
Y Z : StructuredArrow S T
f : Y ⟶ Z
t : IsIso f.right
⊢ f.right ≫ inv f.right = 𝟙 Y.right
[PROOFSTEP]
simp
[GOAL]
case right.right
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
S S' S'' : D
Y✝ Y' : C
T T' : C ⥤ D
Y Z : StructuredArrow S T
f : Y ⟶ Z
t : IsIso f.right
⊢ inv f.right ≫ f.right = 𝟙 Z.right
[PROOFSTEP]
simp
[GOAL]
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
S S' S'' : D
Y Y' : C
T T' : C ⥤ D
inst✝¹ : Full T
inst✝ : Faithful T
c : Cocone (Functor.empty (StructuredArrow (T.obj Y) T))
m : (asEmptyCocone (mk (𝟙 (T.obj Y)))).pt ⟶ c.pt
x✝ : ∀ (j : Discrete PEmpty), NatTrans.app (asEmptyCocone (mk (𝟙 (T.obj Y)))).ι j ≫ m = NatTrans.app c.ι j
⊢ m = (fun c => homMk (T.preimage c.pt.hom)) c
[PROOFSTEP]
apply CommaMorphism.ext
[GOAL]
case left
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
S S' S'' : D
Y Y' : C
T T' : C ⥤ D
inst✝¹ : Full T
inst✝ : Faithful T
c : Cocone (Functor.empty (StructuredArrow (T.obj Y) T))
m : (asEmptyCocone (mk (𝟙 (T.obj Y)))).pt ⟶ c.pt
x✝ : ∀ (j : Discrete PEmpty), NatTrans.app (asEmptyCocone (mk (𝟙 (T.obj Y)))).ι j ≫ m = NatTrans.app c.ι j
⊢ m.left = ((fun c => homMk (T.preimage c.pt.hom)) c).left
[PROOFSTEP]
aesop_cat
[GOAL]
case right
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
S S' S'' : D
Y Y' : C
T T' : C ⥤ D
inst✝¹ : Full T
inst✝ : Faithful T
c : Cocone (Functor.empty (StructuredArrow (T.obj Y) T))
m : (asEmptyCocone (mk (𝟙 (T.obj Y)))).pt ⟶ c.pt
x✝ : ∀ (j : Discrete PEmpty), NatTrans.app (asEmptyCocone (mk (𝟙 (T.obj Y)))).ι j ≫ m = NatTrans.app c.ι j
⊢ m.right = ((fun c => homMk (T.preimage c.pt.hom)) c).right
[PROOFSTEP]
apply T.map_injective
[GOAL]
case right.a
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
S S' S'' : D
Y Y' : C
T T' : C ⥤ D
inst✝¹ : Full T
inst✝ : Faithful T
c : Cocone (Functor.empty (StructuredArrow (T.obj Y) T))
m : (asEmptyCocone (mk (𝟙 (T.obj Y)))).pt ⟶ c.pt
x✝ : ∀ (j : Discrete PEmpty), NatTrans.app (asEmptyCocone (mk (𝟙 (T.obj Y)))).ι j ≫ m = NatTrans.app c.ι j
⊢ T.map m.right = T.map ((fun c => homMk (T.preimage c.pt.hom)) c).right
[PROOFSTEP]
simpa only [homMk_right, T.image_preimage, ← w m] using (Category.id_comp _).symm
[GOAL]
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
S✝ S' S'' : D
Y Y' : C
T T' : C ⥤ D
A : Type u₃
inst✝¹ : Category.{v₃, u₃} A
B : Type u₄
inst✝ : Category.{v₄, u₄} B
S : C
F : B ⥤ C
G : C ⥤ D
X✝ Y✝ : StructuredArrow S F
f : X✝ ⟶ Y✝
⊢ ((fun X => mk (G.map X.hom)) X✝).hom ≫ (F ⋙ G).map f.right = ((fun X => mk (G.map X.hom)) Y✝).hom
[PROOFSTEP]
simp [Functor.comp_map, ← G.map_comp, ← f.w]
[GOAL]
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
S✝ S' S'' : D
Y Y' : C
T T' : C ⥤ D
A : Type u₃
inst✝¹ : Category.{v₃, u₃} A
B : Type u₄
inst✝ : Category.{v₄, u₄} B
S : C
F : B ⥤ C
G : C ⥤ D
x✝³ x✝² : StructuredArrow S F
x✝¹ x✝ : x✝³ ⟶ x✝²
h : (post S F G).map x✝¹ = (post S F G).map x✝
⊢ x✝¹ = x✝
[PROOFSTEP]
simpa [ext_iff] using h
[GOAL]
C : Type u₁
inst✝⁴ : Category.{v₁, u₁} C
D : Type u₂
inst✝³ : Category.{v₂, u₂} D
S✝ S' S'' : D
Y Y' : C
T T' : C ⥤ D
A : Type u₃
inst✝² : Category.{v₃, u₃} A
B : Type u₄
inst✝¹ : Category.{v₄, u₄} B
S : C
F : B ⥤ C
G : C ⥤ D
inst✝ : Faithful G
x✝¹ x✝ : StructuredArrow S F
f : (post S F G).obj x✝¹ ⟶ (post S F G).obj x✝
⊢ G.map (x✝¹.hom ≫ F.map f.right) = G.map x✝.hom
[PROOFSTEP]
simpa using f.w.symm
[GOAL]
C : Type u₁
inst✝⁴ : Category.{v₁, u₁} C
D : Type u₂
inst✝³ : Category.{v₂, u₂} D
S✝ S' S'' : D
Y Y' : C
T T' : C ⥤ D
A : Type u₃
inst✝² : Category.{v₃, u₃} A
B : Type u₄
inst✝¹ : Category.{v₄, u₄} B
S : C
F : B ⥤ C
G : C ⥤ D
inst✝ : Full G
h : StructuredArrow (G.obj S) (F ⋙ G)
⊢ ((post S F G).obj (mk (G.preimage h.hom))).hom ≫
      (F ⋙ G).map (Iso.refl ((post S F G).obj (mk (G.preimage h.hom))).right).hom =
    h.hom
[PROOFSTEP]
simp
[GOAL]
C : Type u₁
inst✝⁵ : Category.{v₁, u₁} C
D : Type u₂
inst✝⁴ : Category.{v₂, u₂} D
S S' S'' : D
Y Y' : C
T T' : C ⥤ D
A : Type u₃
inst✝³ : Category.{v₃, u₃} A
B : Type u₄
inst✝² : Category.{v₄, u₄} B
𝒢 : Set C
inst✝¹ : Small.{v₁, u₁} ↑𝒢
inst✝ : LocallySmall D
⊢ Small.{v₁, max u₁ v₂} ↑((proj S T).toPrefunctor.obj ⁻¹' 𝒢)
[PROOFSTEP]
suffices (proj S T).obj ⁻¹' 𝒢 = Set.range fun f : Σ G : 𝒢, S ⟶ T.obj G => mk f.2
  by
  rw [this]
  infer_instance
[GOAL]
C : Type u₁
inst✝⁵ : Category.{v₁, u₁} C
D : Type u₂
inst✝⁴ : Category.{v₂, u₂} D
S S' S'' : D
Y Y' : C
T T' : C ⥤ D
A : Type u₃
inst✝³ : Category.{v₃, u₃} A
B : Type u₄
inst✝² : Category.{v₄, u₄} B
𝒢 : Set C
inst✝¹ : Small.{v₁, u₁} ↑𝒢
inst✝ : LocallySmall D
this : (proj S T).toPrefunctor.obj ⁻¹' 𝒢 = Set.range fun f => mk f.snd
⊢ Small.{v₁, max u₁ v₂} ↑((proj S T).toPrefunctor.obj ⁻¹' 𝒢)
[PROOFSTEP]
rw [this]
[GOAL]
C : Type u₁
inst✝⁵ : Category.{v₁, u₁} C
D : Type u₂
inst✝⁴ : Category.{v₂, u₂} D
S S' S'' : D
Y Y' : C
T T' : C ⥤ D
A : Type u₃
inst✝³ : Category.{v₃, u₃} A
B : Type u₄
inst✝² : Category.{v₄, u₄} B
𝒢 : Set C
inst✝¹ : Small.{v₁, u₁} ↑𝒢
inst✝ : LocallySmall D
this : (proj S T).toPrefunctor.obj ⁻¹' 𝒢 = Set.range fun f => mk f.snd
⊢ Small.{v₁, max u₁ v₂} ↑(Set.range fun f => mk f.snd)
[PROOFSTEP]
infer_instance
[GOAL]
C : Type u₁
inst✝⁵ : Category.{v₁, u₁} C
D : Type u₂
inst✝⁴ : Category.{v₂, u₂} D
S S' S'' : D
Y Y' : C
T T' : C ⥤ D
A : Type u₃
inst✝³ : Category.{v₃, u₃} A
B : Type u₄
inst✝² : Category.{v₄, u₄} B
𝒢 : Set C
inst✝¹ : Small.{v₁, u₁} ↑𝒢
inst✝ : LocallySmall D
⊢ (proj S T).toPrefunctor.obj ⁻¹' 𝒢 = Set.range fun f => mk f.snd
[PROOFSTEP]
exact Set.ext fun X => ⟨fun h => ⟨⟨⟨_, h⟩, X.hom⟩, (eq_mk _).symm⟩, by aesop_cat⟩
[GOAL]
C : Type u₁
inst✝⁵ : Category.{v₁, u₁} C
D : Type u₂
inst✝⁴ : Category.{v₂, u₂} D
S S' S'' : D
Y Y' : C
T T' : C ⥤ D
A : Type u₃
inst✝³ : Category.{v₃, u₃} A
B : Type u₄
inst✝² : Category.{v₄, u₄} B
𝒢 : Set C
inst✝¹ : Small.{v₁, u₁} ↑𝒢
inst✝ : LocallySmall D
X : StructuredArrow S T
⊢ (X ∈ Set.range fun f => mk f.snd) → X ∈ (proj S T).toPrefunctor.obj ⁻¹' 𝒢
[PROOFSTEP]
aesop_cat
[GOAL]
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
T T' T'' : D
Y Y' : C
S S' : C ⥤ D
A B : CostructuredArrow S T
f : A ⟶ B
⊢ S.map f.left ≫ B.hom = A.hom
[PROOFSTEP]
simp
[GOAL]
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
T T' T'' : D
Y✝ Y' : C
S S' : C ⥤ D
X Y : CostructuredArrow S T
h : X = Y
⊢ X.left = Y.left
[PROOFSTEP]
rw [h]
[GOAL]
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
T T' T'' : D
Y✝ Y' : C
S S' : C ⥤ D
X Y : CostructuredArrow S T
h : X = Y
⊢ (eqToHom h).left = eqToHom (_ : X.left = Y.left)
[PROOFSTEP]
subst h
[GOAL]
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
T T' T'' : D
Y Y' : C
S S' : C ⥤ D
X : CostructuredArrow S T
⊢ (eqToHom (_ : X = X)).left = eqToHom (_ : X.left = X.left)
[PROOFSTEP]
simp only [eqToHom_refl, id_left]
[GOAL]
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
T T' T'' : D
Y Y' : C
S S' : C ⥤ D
f f' : CostructuredArrow S T
g : f.left ⟶ f'.left
w : autoParam (S.map g ≫ f'.hom = f.hom) _auto✝
⊢ f.right = f'.right
[PROOFSTEP]
ext
[GOAL]
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
T T' T'' : D
Y Y' : C
S S' : C ⥤ D
f f' : CostructuredArrow S T
g : f.left ⟶ f'.left
w : autoParam (S.map g ≫ f'.hom = f.hom) _auto✝
⊢ S.map g ≫ f'.hom = f.hom ≫ (Functor.fromPUnit T).map (eqToHom (_ : f.right = f'.right))
[PROOFSTEP]
simpa [eqToHom_map] using w
[GOAL]
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
T T' T'' : D
Y Y' : C
S S' : C ⥤ D
f : CostructuredArrow S T
g : Y' ⟶ f.left
⊢ (mk (S.map g ≫ f.hom)).right = f.right
[PROOFSTEP]
ext
[GOAL]
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
T T' T'' : D
Y Y' : C
S S' : C ⥤ D
f f' : CostructuredArrow S T
g : f.left ≅ f'.left
w : autoParam (S.map g.hom ≫ f'.hom = f.hom) _auto✝
⊢ f.right = f'.right
[PROOFSTEP]
ext
[GOAL]
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
T T' T'' : D
Y Y' : C
S S' : C ⥤ D
f f' : CostructuredArrow S T
g : f.left ≅ f'.left
w : autoParam (S.map g.hom ≫ f'.hom = f.hom) _auto✝
⊢ S.map g.hom ≫ f'.hom = f.hom ≫ (Functor.fromPUnit T).map (eqToIso (_ : f.right = f'.right)).hom
[PROOFSTEP]
simpa [eqToHom_map] using w
[GOAL]
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
T T' T'' : D
Y Y' : C
S S' : C ⥤ D
f : CostructuredArrow S T
⊢ (map (𝟙 T)).obj f = f
[PROOFSTEP]
rw [eq_mk f]
[GOAL]
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
T T' T'' : D
Y Y' : C
S S' : C ⥤ D
f : CostructuredArrow S T
⊢ (map (𝟙 T)).obj (mk f.hom) = mk f.hom
[PROOFSTEP]
simp
[GOAL]
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
T T' T'' : D
Y Y' : C
S S' : C ⥤ D
f : T ⟶ T'
f' : T' ⟶ T''
h : CostructuredArrow S T
⊢ (map (f ≫ f')).obj h = (map f').obj ((map f).obj h)
[PROOFSTEP]
rw [eq_mk h]
[GOAL]
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
T T' T'' : D
Y Y' : C
S S' : C ⥤ D
f : T ⟶ T'
f' : T' ⟶ T''
h : CostructuredArrow S T
⊢ (map (f ≫ f')).obj (mk h.hom) = (map f').obj ((map f).obj (mk h.hom))
[PROOFSTEP]
simp
[GOAL]
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
T T' T'' : D
Y✝ Y' : C
S S' : C ⥤ D
Y Z : CostructuredArrow S T
f : Y ⟶ Z
t : IsIso ((proj S T).map f)
⊢ S.map (inv ((proj S T).map f)) ≫ Y.hom = Z.hom
[PROOFSTEP]
rw [Functor.map_inv, IsIso.inv_comp_eq]
[GOAL]
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
T T' T'' : D
Y✝ Y' : C
S S' : C ⥤ D
Y Z : CostructuredArrow S T
f : Y ⟶ Z
t : IsIso ((proj S T).map f)
⊢ Y.hom = S.map ((proj S T).map f) ≫ Z.hom
[PROOFSTEP]
simp
[GOAL]
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
T T' T'' : D
Y✝ Y' : C
S S' : C ⥤ D
Y Z : CostructuredArrow S T
f : Y ⟶ Z
t : IsIso ((proj S T).map f)
⊢ f ≫ homMk (inv ((proj S T).map f)) = 𝟙 Y ∧ homMk (inv ((proj S T).map f)) ≫ f = 𝟙 Z
[PROOFSTEP]
constructor
[GOAL]
case left
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
T T' T'' : D
Y✝ Y' : C
S S' : C ⥤ D
Y Z : CostructuredArrow S T
f : Y ⟶ Z
t : IsIso ((proj S T).map f)
⊢ f ≫ homMk (inv ((proj S T).map f)) = 𝟙 Y
[PROOFSTEP]
ext
[GOAL]
case right
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
T T' T'' : D
Y✝ Y' : C
S S' : C ⥤ D
Y Z : CostructuredArrow S T
f : Y ⟶ Z
t : IsIso ((proj S T).map f)
⊢ homMk (inv ((proj S T).map f)) ≫ f = 𝟙 Z
[PROOFSTEP]
ext
[GOAL]
case left.h
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
T T' T'' : D
Y✝ Y' : C
S S' : C ⥤ D
Y Z : CostructuredArrow S T
f : Y ⟶ Z
t : IsIso ((proj S T).map f)
⊢ (f ≫ homMk (inv ((proj S T).map f))).left = (𝟙 Y).left
[PROOFSTEP]
dsimp at t ⊢
[GOAL]
case right.h
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
T T' T'' : D
Y✝ Y' : C
S S' : C ⥤ D
Y Z : CostructuredArrow S T
f : Y ⟶ Z
t : IsIso ((proj S T).map f)
⊢ (homMk (inv ((proj S T).map f)) ≫ f).left = (𝟙 Z).left
[PROOFSTEP]
dsimp at t ⊢
[GOAL]
case left.h
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
T T' T'' : D
Y✝ Y' : C
S S' : C ⥤ D
Y Z : CostructuredArrow S T
f : Y ⟶ Z
t : IsIso f.left
⊢ f.left ≫ inv f.left = 𝟙 Y.left
[PROOFSTEP]
simp
[GOAL]
case right.h
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
T T' T'' : D
Y✝ Y' : C
S S' : C ⥤ D
Y Z : CostructuredArrow S T
f : Y ⟶ Z
t : IsIso f.left
⊢ inv f.left ≫ f.left = 𝟙 Z.left
[PROOFSTEP]
simp
[GOAL]
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
T T' T'' : D
Y Y' : C
S S' : C ⥤ D
inst✝¹ : Full S
inst✝ : Faithful S
⊢ ∀ (s : Cone (Functor.empty (CostructuredArrow S (S.obj Y)))) (m : s.pt ⟶ (asEmptyCone (mk (𝟙 (S.obj Y)))).pt),
    (∀ (j : Discrete PEmpty), m ≫ NatTrans.app (asEmptyCone (mk (𝟙 (S.obj Y)))).π j = NatTrans.app s.π j) →
      m = (fun c => homMk (S.preimage c.pt.hom)) s
[PROOFSTEP]
rintro c m -
[GOAL]
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
T T' T'' : D
Y Y' : C
S S' : C ⥤ D
inst✝¹ : Full S
inst✝ : Faithful S
c : Cone (Functor.empty (CostructuredArrow S (S.obj Y)))
m : c.pt ⟶ (asEmptyCone (mk (𝟙 (S.obj Y)))).pt
⊢ m = (fun c => homMk (S.preimage c.pt.hom)) c
[PROOFSTEP]
ext
[GOAL]
case h
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
T T' T'' : D
Y Y' : C
S S' : C ⥤ D
inst✝¹ : Full S
inst✝ : Faithful S
c : Cone (Functor.empty (CostructuredArrow S (S.obj Y)))
m : c.pt ⟶ (asEmptyCone (mk (𝟙 (S.obj Y)))).pt
⊢ m.left = ((fun c => homMk (S.preimage c.pt.hom)) c).left
[PROOFSTEP]
apply S.map_injective
[GOAL]
case h.a
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
T T' T'' : D
Y Y' : C
S S' : C ⥤ D
inst✝¹ : Full S
inst✝ : Faithful S
c : Cone (Functor.empty (CostructuredArrow S (S.obj Y)))
m : c.pt ⟶ (asEmptyCone (mk (𝟙 (S.obj Y)))).pt
⊢ S.map m.left = S.map ((fun c => homMk (S.preimage c.pt.hom)) c).left
[PROOFSTEP]
simpa only [homMk_left, S.image_preimage, ← w m] using (Category.comp_id _).symm
[GOAL]
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
T T' T'' : D
Y Y' : C
S✝ S' : C ⥤ D
A : Type u₃
inst✝¹ : Category.{v₃, u₃} A
B : Type u₄
inst✝ : Category.{v₄, u₄} B
F : B ⥤ C
G : C ⥤ D
S : C
X✝ Y✝ : CostructuredArrow F S
f : X✝ ⟶ Y✝
⊢ (F ⋙ G).map f.left ≫ ((fun X => mk (G.map X.hom)) Y✝).hom = ((fun X => mk (G.map X.hom)) X✝).hom
[PROOFSTEP]
simp [Functor.comp_map, ← G.map_comp, ← f.w]
[GOAL]
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
T T' T'' : D
Y Y' : C
S✝ S' : C ⥤ D
A : Type u₃
inst✝¹ : Category.{v₃, u₃} A
B : Type u₄
inst✝ : Category.{v₄, u₄} B
F : B ⥤ C
G : C ⥤ D
S : C
x✝³ x✝² : CostructuredArrow F S
x✝¹ x✝ : x✝³ ⟶ x✝²
h : (post F G S).map x✝¹ = (post F G S).map x✝
⊢ x✝¹ = x✝
[PROOFSTEP]
simpa [ext_iff] using h
[GOAL]
C : Type u₁
inst✝⁴ : Category.{v₁, u₁} C
D : Type u₂
inst✝³ : Category.{v₂, u₂} D
T T' T'' : D
Y Y' : C
S✝ S' : C ⥤ D
A : Type u₃
inst✝² : Category.{v₃, u₃} A
B : Type u₄
inst✝¹ : Category.{v₄, u₄} B
F : B ⥤ C
G : C ⥤ D
S : C
inst✝ : Faithful G
x✝¹ x✝ : CostructuredArrow F S
f : (post F G S).obj x✝¹ ⟶ (post F G S).obj x✝
⊢ G.map (F.map f.left ≫ x✝.hom) = G.map x✝¹.hom
[PROOFSTEP]
simpa using f.w
[GOAL]
C : Type u₁
inst✝⁴ : Category.{v₁, u₁} C
D : Type u₂
inst✝³ : Category.{v₂, u₂} D
T T' T'' : D
Y Y' : C
S✝ S' : C ⥤ D
A : Type u₃
inst✝² : Category.{v₃, u₃} A
B : Type u₄
inst✝¹ : Category.{v₄, u₄} B
F : B ⥤ C
G : C ⥤ D
S : C
inst✝ : Full G
h : CostructuredArrow (F ⋙ G) (G.obj S)
⊢ (F ⋙ G).map (Iso.refl ((post F G S).obj (mk (G.preimage h.hom))).left).hom ≫ h.hom =
    ((post F G S).obj (mk (G.preimage h.hom))).hom
[PROOFSTEP]
simp
[GOAL]
C : Type u₁
inst✝⁵ : Category.{v₁, u₁} C
D : Type u₂
inst✝⁴ : Category.{v₂, u₂} D
T T' T'' : D
Y Y' : C
S S' : C ⥤ D
A : Type u₃
inst✝³ : Category.{v₃, u₃} A
B : Type u₄
inst✝² : Category.{v₄, u₄} B
𝒢 : Set C
inst✝¹ : Small.{v₁, u₁} ↑𝒢
inst✝ : LocallySmall D
⊢ Small.{v₁, max u₁ v₂} ↑((proj S T).toPrefunctor.obj ⁻¹' 𝒢)
[PROOFSTEP]
suffices (proj S T).obj ⁻¹' 𝒢 = Set.range fun f : Σ G : 𝒢, S.obj G ⟶ T => mk f.2
  by
  rw [this]
  infer_instance
[GOAL]
C : Type u₁
inst✝⁵ : Category.{v₁, u₁} C
D : Type u₂
inst✝⁴ : Category.{v₂, u₂} D
T T' T'' : D
Y Y' : C
S S' : C ⥤ D
A : Type u₃
inst✝³ : Category.{v₃, u₃} A
B : Type u₄
inst✝² : Category.{v₄, u₄} B
𝒢 : Set C
inst✝¹ : Small.{v₁, u₁} ↑𝒢
inst✝ : LocallySmall D
this : (proj S T).toPrefunctor.obj ⁻¹' 𝒢 = Set.range fun f => mk f.snd
⊢ Small.{v₁, max u₁ v₂} ↑((proj S T).toPrefunctor.obj ⁻¹' 𝒢)
[PROOFSTEP]
rw [this]
[GOAL]
C : Type u₁
inst✝⁵ : Category.{v₁, u₁} C
D : Type u₂
inst✝⁴ : Category.{v₂, u₂} D
T T' T'' : D
Y Y' : C
S S' : C ⥤ D
A : Type u₃
inst✝³ : Category.{v₃, u₃} A
B : Type u₄
inst✝² : Category.{v₄, u₄} B
𝒢 : Set C
inst✝¹ : Small.{v₁, u₁} ↑𝒢
inst✝ : LocallySmall D
this : (proj S T).toPrefunctor.obj ⁻¹' 𝒢 = Set.range fun f => mk f.snd
⊢ Small.{v₁, max u₁ v₂} ↑(Set.range fun f => mk f.snd)
[PROOFSTEP]
infer_instance
[GOAL]
C : Type u₁
inst✝⁵ : Category.{v₁, u₁} C
D : Type u₂
inst✝⁴ : Category.{v₂, u₂} D
T T' T'' : D
Y Y' : C
S S' : C ⥤ D
A : Type u₃
inst✝³ : Category.{v₃, u₃} A
B : Type u₄
inst✝² : Category.{v₄, u₄} B
𝒢 : Set C
inst✝¹ : Small.{v₁, u₁} ↑𝒢
inst✝ : LocallySmall D
⊢ (proj S T).toPrefunctor.obj ⁻¹' 𝒢 = Set.range fun f => mk f.snd
[PROOFSTEP]
exact Set.ext fun X => ⟨fun h => ⟨⟨⟨_, h⟩, X.hom⟩, (eq_mk _).symm⟩, by aesop_cat⟩
[GOAL]
C : Type u₁
inst✝⁵ : Category.{v₁, u₁} C
D : Type u₂
inst✝⁴ : Category.{v₂, u₂} D
T T' T'' : D
Y Y' : C
S S' : C ⥤ D
A : Type u₃
inst✝³ : Category.{v₃, u₃} A
B : Type u₄
inst✝² : Category.{v₄, u₄} B
𝒢 : Set C
inst✝¹ : Small.{v₁, u₁} ↑𝒢
inst✝ : LocallySmall D
X : CostructuredArrow S T
⊢ (X ∈ Set.range fun f => mk f.snd) → X ∈ (proj S T).toPrefunctor.obj ⁻¹' 𝒢
[PROOFSTEP]
aesop_cat
[GOAL]
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F : C ⥤ D
d : D
X✝ Y✝ : (StructuredArrow d F)ᵒᵖ
f : X✝ ⟶ Y✝
⊢ F.op.map f.unop.right.op ≫ ((fun X => CostructuredArrow.mk X.unop.hom.op) Y✝).hom =
    ((fun X => CostructuredArrow.mk X.unop.hom.op) X✝).hom
[PROOFSTEP]
dsimp
[GOAL]
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F : C ⥤ D
d : D
X✝ Y✝ : (StructuredArrow d F)ᵒᵖ
f : X✝ ⟶ Y✝
⊢ (F.map f.unop.right).op ≫ Y✝.unop.hom.op = X✝.unop.hom.op
[PROOFSTEP]
rw [← op_comp, ← f.unop.w, Functor.const_obj_map]
[GOAL]
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F : C ⥤ D
d : D
X✝ Y✝ : (StructuredArrow d F)ᵒᵖ
f : X✝ ⟶ Y✝
⊢ (𝟙 d ≫ X✝.unop.hom).op = X✝.unop.hom.op
[PROOFSTEP]
erw [Category.id_comp]
[GOAL]
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F : C ⥤ D
d : D
X✝ Y✝ : (StructuredArrow (op d) F.op)ᵒᵖ
f : X✝ ⟶ Y✝
⊢ F.map f.unop.right.unop ≫ ((fun X => CostructuredArrow.mk X.unop.hom.unop) Y✝).hom =
    ((fun X => CostructuredArrow.mk X.unop.hom.unop) X✝).hom
[PROOFSTEP]
dsimp
[GOAL]
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F : C ⥤ D
d : D
X✝ Y✝ : (StructuredArrow (op d) F.op)ᵒᵖ
f : X✝ ⟶ Y✝
⊢ F.map f.unop.right.unop ≫ Y✝.unop.hom.unop = X✝.unop.hom.unop
[PROOFSTEP]
rw [← Quiver.Hom.unop_op (F.map (Quiver.Hom.unop f.unop.right)), ← unop_comp, ← F.op_map, ← f.unop.w,
  Functor.const_obj_map]
[GOAL]
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F : C ⥤ D
d : D
X✝ Y✝ : (StructuredArrow (op d) F.op)ᵒᵖ
f : X✝ ⟶ Y✝
⊢ (𝟙 (op d) ≫ X✝.unop.hom).unop = X✝.unop.hom.unop
[PROOFSTEP]
erw [Category.id_comp]
[GOAL]
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F : C ⥤ D
d : D
X✝ Y✝ : (CostructuredArrow F d)ᵒᵖ
f : X✝ ⟶ Y✝
⊢ ((fun X => StructuredArrow.mk X.unop.hom.op) X✝).hom ≫ F.op.map f.unop.left.op =
    ((fun X => StructuredArrow.mk X.unop.hom.op) Y✝).hom
[PROOFSTEP]
dsimp
[GOAL]
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F : C ⥤ D
d : D
X✝ Y✝ : (CostructuredArrow F d)ᵒᵖ
f : X✝ ⟶ Y✝
⊢ X✝.unop.hom.op ≫ (F.map f.unop.left).op = Y✝.unop.hom.op
[PROOFSTEP]
rw [← op_comp, f.unop.w, Functor.const_obj_map]
[GOAL]
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F : C ⥤ D
d : D
X✝ Y✝ : (CostructuredArrow F d)ᵒᵖ
f : X✝ ⟶ Y✝
⊢ (Y✝.unop.hom ≫ 𝟙 d).op = Y✝.unop.hom.op
[PROOFSTEP]
erw [Category.comp_id]
[GOAL]
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F : C ⥤ D
d : D
X✝ Y✝ : (CostructuredArrow F.op (op d))ᵒᵖ
f : X✝ ⟶ Y✝
⊢ ((fun X => StructuredArrow.mk X.unop.hom.unop) X✝).hom ≫ F.map f.unop.left.unop =
    ((fun X => StructuredArrow.mk X.unop.hom.unop) Y✝).hom
[PROOFSTEP]
dsimp
[GOAL]
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F : C ⥤ D
d : D
X✝ Y✝ : (CostructuredArrow F.op (op d))ᵒᵖ
f : X✝ ⟶ Y✝
⊢ X✝.unop.hom.unop ≫ F.map f.unop.left.unop = Y✝.unop.hom.unop
[PROOFSTEP]
rw [← Quiver.Hom.unop_op (F.map f.unop.left.unop), ← unop_comp, ← F.op_map, f.unop.w, Functor.const_obj_map]
[GOAL]
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F : C ⥤ D
d : D
X✝ Y✝ : (CostructuredArrow F.op (op d))ᵒᵖ
f : X✝ ⟶ Y✝
⊢ (Y✝.unop.hom ≫ 𝟙 (op d)).unop = Y✝.unop.hom.unop
[PROOFSTEP]
erw [Category.comp_id]
[GOAL]
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F : C ⥤ D
d : D
X Y : (StructuredArrow d F)ᵒᵖ
f : X ⟶ Y
⊢ ((𝟭 (StructuredArrow d F)ᵒᵖ).map f ≫ ((fun X => Iso.op (StructuredArrow.isoMk (Iso.refl X.unop.right))) Y).hom).unop =
    (((fun X => Iso.op (StructuredArrow.isoMk (Iso.refl X.unop.right))) X).hom ≫
        (StructuredArrow.toCostructuredArrow F d ⋙ (CostructuredArrow.toStructuredArrow' F d).rightOp).map f).unop
[PROOFSTEP]
apply CommaMorphism.ext
[GOAL]
case left
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F : C ⥤ D
d : D
X Y : (StructuredArrow d F)ᵒᵖ
f : X ⟶ Y
⊢ ((𝟭 (StructuredArrow d F)ᵒᵖ).map f ≫
          ((fun X => Iso.op (StructuredArrow.isoMk (Iso.refl X.unop.right))) Y).hom).unop.left =
    (((fun X => Iso.op (StructuredArrow.isoMk (Iso.refl X.unop.right))) X).hom ≫
          (StructuredArrow.toCostructuredArrow F d ⋙ (CostructuredArrow.toStructuredArrow' F d).rightOp).map
            f).unop.left
[PROOFSTEP]
dsimp [StructuredArrow.isoMk, Comma.isoMk, StructuredArrow.homMk]
[GOAL]
case right
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F : C ⥤ D
d : D
X Y : (StructuredArrow d F)ᵒᵖ
f : X ⟶ Y
⊢ ((𝟭 (StructuredArrow d F)ᵒᵖ).map f ≫
          ((fun X => Iso.op (StructuredArrow.isoMk (Iso.refl X.unop.right))) Y).hom).unop.right =
    (((fun X => Iso.op (StructuredArrow.isoMk (Iso.refl X.unop.right))) X).hom ≫
          (StructuredArrow.toCostructuredArrow F d ⋙ (CostructuredArrow.toStructuredArrow' F d).rightOp).map
            f).unop.right
[PROOFSTEP]
dsimp [StructuredArrow.isoMk, Comma.isoMk, StructuredArrow.homMk]
[GOAL]
case right
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F : C ⥤ D
d : D
X Y : (StructuredArrow d F)ᵒᵖ
f : X ⟶ Y
⊢ 𝟙 Y.unop.right ≫ f.unop.right = f.unop.right ≫ 𝟙 X.unop.right
[PROOFSTEP]
simp
[GOAL]
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F : C ⥤ D
d : D
X Y : CostructuredArrow F.op (op d)
f : X ⟶ Y
⊢ ((CostructuredArrow.toStructuredArrow' F d).rightOp ⋙ StructuredArrow.toCostructuredArrow F d).map f ≫
      ((fun X =>
            CostructuredArrow.isoMk
              (Iso.refl
                (((CostructuredArrow.toStructuredArrow' F d).rightOp ⋙ StructuredArrow.toCostructuredArrow F d).obj
                    X).left))
          Y).hom =
    ((fun X =>
            CostructuredArrow.isoMk
              (Iso.refl
                (((CostructuredArrow.toStructuredArrow' F d).rightOp ⋙ StructuredArrow.toCostructuredArrow F d).obj
                    X).left))
          X).hom ≫
      (𝟭 (CostructuredArrow F.op (op d))).map f
[PROOFSTEP]
apply CommaMorphism.ext
[GOAL]
case left
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F : C ⥤ D
d : D
X Y : CostructuredArrow F.op (op d)
f : X ⟶ Y
⊢ (((CostructuredArrow.toStructuredArrow' F d).rightOp ⋙ StructuredArrow.toCostructuredArrow F d).map f ≫
        ((fun X =>
              CostructuredArrow.isoMk
                (Iso.refl
                  (((CostructuredArrow.toStructuredArrow' F d).rightOp ⋙ StructuredArrow.toCostructuredArrow F d).obj
                      X).left))
            Y).hom).left =
    (((fun X =>
              CostructuredArrow.isoMk
                (Iso.refl
                  (((CostructuredArrow.toStructuredArrow' F d).rightOp ⋙ StructuredArrow.toCostructuredArrow F d).obj
                      X).left))
            X).hom ≫
        (𝟭 (CostructuredArrow F.op (op d))).map f).left
[PROOFSTEP]
dsimp [CostructuredArrow.isoMk, Comma.isoMk, CostructuredArrow.homMk]
[GOAL]
case right
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F : C ⥤ D
d : D
X Y : CostructuredArrow F.op (op d)
f : X ⟶ Y
⊢ (((CostructuredArrow.toStructuredArrow' F d).rightOp ⋙ StructuredArrow.toCostructuredArrow F d).map f ≫
        ((fun X =>
              CostructuredArrow.isoMk
                (Iso.refl
                  (((CostructuredArrow.toStructuredArrow' F d).rightOp ⋙ StructuredArrow.toCostructuredArrow F d).obj
                      X).left))
            Y).hom).right =
    (((fun X =>
              CostructuredArrow.isoMk
                (Iso.refl
                  (((CostructuredArrow.toStructuredArrow' F d).rightOp ⋙ StructuredArrow.toCostructuredArrow F d).obj
                      X).left))
            X).hom ≫
        (𝟭 (CostructuredArrow F.op (op d))).map f).right
[PROOFSTEP]
dsimp [CostructuredArrow.isoMk, Comma.isoMk, CostructuredArrow.homMk]
[GOAL]
case left
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F : C ⥤ D
d : D
X Y : CostructuredArrow F.op (op d)
f : X ⟶ Y
⊢ f.left ≫ 𝟙 Y.left = 𝟙 X.left ≫ f.left
[PROOFSTEP]
simp
[GOAL]
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F : C ⥤ D
d : D
X Y : (CostructuredArrow F d)ᵒᵖ
f : X ⟶ Y
⊢ ((𝟭 (CostructuredArrow F d)ᵒᵖ).map f ≫
        ((fun X => Iso.op (CostructuredArrow.isoMk (Iso.refl X.unop.left))) Y).hom).unop =
    (((fun X => Iso.op (CostructuredArrow.isoMk (Iso.refl X.unop.left))) X).hom ≫
        (CostructuredArrow.toStructuredArrow F d ⋙ (StructuredArrow.toCostructuredArrow' F d).rightOp).map f).unop
[PROOFSTEP]
apply CommaMorphism.ext
[GOAL]
case left
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F : C ⥤ D
d : D
X Y : (CostructuredArrow F d)ᵒᵖ
f : X ⟶ Y
⊢ ((𝟭 (CostructuredArrow F d)ᵒᵖ).map f ≫
          ((fun X => Iso.op (CostructuredArrow.isoMk (Iso.refl X.unop.left))) Y).hom).unop.left =
    (((fun X => Iso.op (CostructuredArrow.isoMk (Iso.refl X.unop.left))) X).hom ≫
          (CostructuredArrow.toStructuredArrow F d ⋙ (StructuredArrow.toCostructuredArrow' F d).rightOp).map
            f).unop.left
[PROOFSTEP]
dsimp [CostructuredArrow.isoMk, CostructuredArrow.homMk, Comma.isoMk]
[GOAL]
case right
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F : C ⥤ D
d : D
X Y : (CostructuredArrow F d)ᵒᵖ
f : X ⟶ Y
⊢ ((𝟭 (CostructuredArrow F d)ᵒᵖ).map f ≫
          ((fun X => Iso.op (CostructuredArrow.isoMk (Iso.refl X.unop.left))) Y).hom).unop.right =
    (((fun X => Iso.op (CostructuredArrow.isoMk (Iso.refl X.unop.left))) X).hom ≫
          (CostructuredArrow.toStructuredArrow F d ⋙ (StructuredArrow.toCostructuredArrow' F d).rightOp).map
            f).unop.right
[PROOFSTEP]
dsimp [CostructuredArrow.isoMk, CostructuredArrow.homMk, Comma.isoMk]
[GOAL]
case left
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F : C ⥤ D
d : D
X Y : (CostructuredArrow F d)ᵒᵖ
f : X ⟶ Y
⊢ 𝟙 Y.unop.left ≫ f.unop.left = f.unop.left ≫ 𝟙 X.unop.left
[PROOFSTEP]
simp
[GOAL]
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F : C ⥤ D
d : D
X Y : StructuredArrow (op d) F.op
f : X ⟶ Y
⊢ ((StructuredArrow.toCostructuredArrow' F d).rightOp ⋙ CostructuredArrow.toStructuredArrow F d).map f ≫
      ((fun X =>
            StructuredArrow.isoMk
              (Iso.refl
                (((StructuredArrow.toCostructuredArrow' F d).rightOp ⋙ CostructuredArrow.toStructuredArrow F d).obj
                    X).right))
          Y).hom =
    ((fun X =>
            StructuredArrow.isoMk
              (Iso.refl
                (((StructuredArrow.toCostructuredArrow' F d).rightOp ⋙ CostructuredArrow.toStructuredArrow F d).obj
                    X).right))
          X).hom ≫
      (𝟭 (StructuredArrow (op d) F.op)).map f
[PROOFSTEP]
apply CommaMorphism.ext
[GOAL]
case left
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F : C ⥤ D
d : D
X Y : StructuredArrow (op d) F.op
f : X ⟶ Y
⊢ (((StructuredArrow.toCostructuredArrow' F d).rightOp ⋙ CostructuredArrow.toStructuredArrow F d).map f ≫
        ((fun X =>
              StructuredArrow.isoMk
                (Iso.refl
                  (((StructuredArrow.toCostructuredArrow' F d).rightOp ⋙ CostructuredArrow.toStructuredArrow F d).obj
                      X).right))
            Y).hom).left =
    (((fun X =>
              StructuredArrow.isoMk
                (Iso.refl
                  (((StructuredArrow.toCostructuredArrow' F d).rightOp ⋙ CostructuredArrow.toStructuredArrow F d).obj
                      X).right))
            X).hom ≫
        (𝟭 (StructuredArrow (op d) F.op)).map f).left
[PROOFSTEP]
dsimp [StructuredArrow.isoMk, StructuredArrow.homMk, Comma.isoMk]
[GOAL]
case right
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F : C ⥤ D
d : D
X Y : StructuredArrow (op d) F.op
f : X ⟶ Y
⊢ (((StructuredArrow.toCostructuredArrow' F d).rightOp ⋙ CostructuredArrow.toStructuredArrow F d).map f ≫
        ((fun X =>
              StructuredArrow.isoMk
                (Iso.refl
                  (((StructuredArrow.toCostructuredArrow' F d).rightOp ⋙ CostructuredArrow.toStructuredArrow F d).obj
                      X).right))
            Y).hom).right =
    (((fun X =>
              StructuredArrow.isoMk
                (Iso.refl
                  (((StructuredArrow.toCostructuredArrow' F d).rightOp ⋙ CostructuredArrow.toStructuredArrow F d).obj
                      X).right))
            X).hom ≫
        (𝟭 (StructuredArrow (op d) F.op)).map f).right
[PROOFSTEP]
dsimp [StructuredArrow.isoMk, StructuredArrow.homMk, Comma.isoMk]
[GOAL]
case right
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F : C ⥤ D
d : D
X Y : StructuredArrow (op d) F.op
f : X ⟶ Y
⊢ f.right ≫ 𝟙 Y.right = 𝟙 X.right ≫ f.right
[PROOFSTEP]
simp


[GOAL]
p q : ℚ
s t : Set ℚ
⊢ NeBot (cocompact ℚ ⊓ 𝓝 p)
[PROOFSTEP]
refine' (hasBasis_cocompact.inf (nhds_basis_opens _)).neBot_iff.2 _
[GOAL]
p q : ℚ
s t : Set ℚ
⊢ ∀ {i : Set ℚ × Set ℚ}, IsCompact i.fst ∧ p ∈ i.snd ∧ IsOpen i.snd → Set.Nonempty (i.fstᶜ ∩ i.snd)
[PROOFSTEP]
rintro ⟨s, o⟩ ⟨hs, hpo, ho⟩
[GOAL]
case mk.intro.intro
p q : ℚ
s✝ t s o : Set ℚ
hs : IsCompact (s, o).fst
hpo : p ∈ (s, o).snd
ho : IsOpen (s, o).snd
⊢ Set.Nonempty ((s, o).fstᶜ ∩ (s, o).snd)
[PROOFSTEP]
rw [inter_comm]
[GOAL]
case mk.intro.intro
p q : ℚ
s✝ t s o : Set ℚ
hs : IsCompact (s, o).fst
hpo : p ∈ (s, o).snd
ho : IsOpen (s, o).snd
⊢ Set.Nonempty ((s, o).snd ∩ (s, o).fstᶜ)
[PROOFSTEP]
exact (dense_compl_compact hs).inter_open_nonempty _ ho ⟨p, hpo⟩
[GOAL]
p q : ℚ
s t : Set ℚ
⊢ ¬IsCountablyGenerated (cocompact ℚ)
[PROOFSTEP]
intro H
[GOAL]
p q : ℚ
s t : Set ℚ
H : IsCountablyGenerated (cocompact ℚ)
⊢ False
[PROOFSTEP]
rcases exists_seq_tendsto (cocompact ℚ ⊓ 𝓝 0) with ⟨x, hx⟩
[GOAL]
case intro
p q : ℚ
s t : Set ℚ
H : IsCountablyGenerated (cocompact ℚ)
x : ℕ → ℚ
hx : Tendsto x atTop (cocompact ℚ ⊓ 𝓝 0)
⊢ False
[PROOFSTEP]
rw [tendsto_inf] at hx
[GOAL]
case intro
p q : ℚ
s t : Set ℚ
H : IsCountablyGenerated (cocompact ℚ)
x : ℕ → ℚ
hx : Tendsto x atTop (cocompact ℚ) ∧ Tendsto x atTop (𝓝 0)
⊢ False
[PROOFSTEP]
rcases hx with ⟨hxc, hx0⟩
[GOAL]
case intro.intro
p q : ℚ
s t : Set ℚ
H : IsCountablyGenerated (cocompact ℚ)
x : ℕ → ℚ
hxc : Tendsto x atTop (cocompact ℚ)
hx0 : Tendsto x atTop (𝓝 0)
⊢ False
[PROOFSTEP]
obtain ⟨n, hn⟩ : ∃ n : ℕ, x n ∉ insert (0 : ℚ) (range x)
[GOAL]
p q : ℚ
s t : Set ℚ
H : IsCountablyGenerated (cocompact ℚ)
x : ℕ → ℚ
hxc : Tendsto x atTop (cocompact ℚ)
hx0 : Tendsto x atTop (𝓝 0)
⊢ ∃ n, ¬x n ∈ insert 0 (range x)
case intro.intro.intro
p q : ℚ
s t : Set ℚ
H : IsCountablyGenerated (cocompact ℚ)
x : ℕ → ℚ
hxc : Tendsto x atTop (cocompact ℚ)
hx0 : Tendsto x atTop (𝓝 0)
n : ℕ
hn : ¬x n ∈ insert 0 (range x)
⊢ False
[PROOFSTEP]
exact (hxc.eventually hx0.isCompact_insert_range.compl_mem_cocompact).exists
[GOAL]
case intro.intro.intro
p q : ℚ
s t : Set ℚ
H : IsCountablyGenerated (cocompact ℚ)
x : ℕ → ℚ
hxc : Tendsto x atTop (cocompact ℚ)
hx0 : Tendsto x atTop (𝓝 0)
n : ℕ
hn : ¬x n ∈ insert 0 (range x)
⊢ False
[PROOFSTEP]
exact hn (Or.inr ⟨n, rfl⟩)
[GOAL]
p q : ℚ
s t : Set ℚ
⊢ ¬IsCountablyGenerated (𝓝 ∞)
[PROOFSTEP]
intro
[GOAL]
p q : ℚ
s t : Set ℚ
a✝ : IsCountablyGenerated (𝓝 ∞)
⊢ False
[PROOFSTEP]
have : IsCountablyGenerated (comap (OnePoint.some : ℚ → ℚ∞) (𝓝 ∞)) := by infer_instance
[GOAL]
p q : ℚ
s t : Set ℚ
a✝ : IsCountablyGenerated (𝓝 ∞)
⊢ IsCountablyGenerated (comap OnePoint.some (𝓝 ∞))
[PROOFSTEP]
infer_instance
[GOAL]
p q : ℚ
s t : Set ℚ
a✝ : IsCountablyGenerated (𝓝 ∞)
this : IsCountablyGenerated (comap OnePoint.some (𝓝 ∞))
⊢ False
[PROOFSTEP]
rw [OnePoint.comap_coe_nhds_infty, coclosedCompact_eq_cocompact] at this
[GOAL]
p q : ℚ
s t : Set ℚ
a✝ : IsCountablyGenerated (𝓝 ∞)
this : IsCountablyGenerated (cocompact ℚ)
⊢ False
[PROOFSTEP]
exact not_countably_generated_cocompact this
[GOAL]
p q : ℚ
s t : Set ℚ
⊢ ¬FirstCountableTopology ℚ∞
[PROOFSTEP]
intro
[GOAL]
p q : ℚ
s t : Set ℚ
a✝ : FirstCountableTopology ℚ∞
⊢ False
[PROOFSTEP]
exact not_countably_generated_nhds_infty_opc inferInstance
[GOAL]
p q : ℚ
s t : Set ℚ
⊢ ¬SecondCountableTopology ℚ∞
[PROOFSTEP]
intro
[GOAL]
p q : ℚ
s t : Set ℚ
a✝ : SecondCountableTopology ℚ∞
⊢ False
[PROOFSTEP]
exact not_firstCountableTopology_opc inferInstance
[GOAL]
p q : ℚ
s t : Set ℚ
⊢ TotallyDisconnectedSpace ℚ
[PROOFSTEP]
refine' ⟨fun s hsu hs x hx y hy => _⟩
[GOAL]
p q : ℚ
s✝ t s : Set ℚ
hsu : s ⊆ univ
hs : IsPreconnected s
x : ℚ
hx : x ∈ s
y : ℚ
hy : y ∈ s
⊢ x = y
[PROOFSTEP]
clear hsu
[GOAL]
p q : ℚ
s✝ t s : Set ℚ
hs : IsPreconnected s
x : ℚ
hx : x ∈ s
y : ℚ
hy : y ∈ s
⊢ x = y
[PROOFSTEP]
by_contra' H : x ≠ y
[GOAL]
p q : ℚ
s✝ t s : Set ℚ
hs : IsPreconnected s
x : ℚ
hx : x ∈ s
y : ℚ
hy : y ∈ s
H : x ≠ y
⊢ False
[PROOFSTEP]
wlog hlt : x < y
[GOAL]
case inr
p q : ℚ
s✝ t s : Set ℚ
hs : IsPreconnected s
x : ℚ
hx : x ∈ s
y : ℚ
hy : y ∈ s
H : x ≠ y
this :
  ∀ {p q : ℚ} {s t : Set ℚ} (s : Set ℚ), IsPreconnected s → ∀ (x : ℚ), x ∈ s → ∀ (y : ℚ), y ∈ s → x ≠ y → x < y → False
hlt : ¬x < y
⊢ False
[PROOFSTEP]
refine' this s hs y hy x hx H.symm <| H.lt_or_lt.resolve_left hlt
[GOAL]
case inr.refine'_1
p q : ℚ
s✝ t s : Set ℚ
hs : IsPreconnected s
x : ℚ
hx : x ∈ s
y : ℚ
hy : y ∈ s
H : x ≠ y
this :
  ∀ {p q : ℚ} {s t : Set ℚ} (s : Set ℚ), IsPreconnected s → ∀ (x : ℚ), x ∈ s → ∀ (y : ℚ), y ∈ s → x ≠ y → x < y → False
hlt : ¬x < y
⊢ ℚ
[PROOFSTEP]
assumption
[GOAL]
case inr.refine'_2
p q : ℚ
s✝ t s : Set ℚ
hs : IsPreconnected s
x : ℚ
hx : x ∈ s
y : ℚ
hy : y ∈ s
H : x ≠ y
this :
  ∀ {p q : ℚ} {s t : Set ℚ} (s : Set ℚ), IsPreconnected s → ∀ (x : ℚ), x ∈ s → ∀ (y : ℚ), y ∈ s → x ≠ y → x < y → False
hlt : ¬x < y
⊢ ℚ
[PROOFSTEP]
assumption
[GOAL]
case inr.refine'_3
p q : ℚ
s✝ t s : Set ℚ
hs : IsPreconnected s
x : ℚ
hx : x ∈ s
y : ℚ
hy : y ∈ s
H : x ≠ y
this :
  ∀ {p q : ℚ} {s t : Set ℚ} (s : Set ℚ), IsPreconnected s → ∀ (x : ℚ), x ∈ s → ∀ (y : ℚ), y ∈ s → x ≠ y → x < y → False
hlt : ¬x < y
⊢ Set ℚ
[PROOFSTEP]
assumption
[GOAL]
case inr.refine'_4
p q : ℚ
s✝ t s : Set ℚ
hs : IsPreconnected s
x : ℚ
hx : x ∈ s
y : ℚ
hy : y ∈ s
H : x ≠ y
this :
  ∀ {p q : ℚ} {s t : Set ℚ} (s : Set ℚ), IsPreconnected s → ∀ (x : ℚ), x ∈ s → ∀ (y : ℚ), y ∈ s → x ≠ y → x < y → False
hlt : ¬x < y
⊢ Set ℚ
[PROOFSTEP]
assumption
[GOAL]
p q : ℚ
s✝ t s : Set ℚ
hs : IsPreconnected s
x : ℚ
hx : x ∈ s
y : ℚ
hy : y ∈ s
H : x ≠ y
hlt : x < y
⊢ False
[PROOFSTEP]
rcases exists_irrational_btwn (Rat.cast_lt.2 hlt) with ⟨z, hz, hxz, hzy⟩
[GOAL]
case intro.intro.intro
p q : ℚ
s✝ t s : Set ℚ
hs : IsPreconnected s
x : ℚ
hx : x ∈ s
y : ℚ
hy : y ∈ s
H : x ≠ y
hlt : x < y
z : ℝ
hz : Irrational z
hxz : ↑x < z
hzy : z < ↑y
⊢ False
[PROOFSTEP]
have := hs.image _ continuous_coe_real.continuousOn
[GOAL]
case intro.intro.intro
p q : ℚ
s✝ t s : Set ℚ
hs : IsPreconnected s
x : ℚ
hx : x ∈ s
y : ℚ
hy : y ∈ s
H : x ≠ y
hlt : x < y
z : ℝ
hz : Irrational z
hxz : ↑x < z
hzy : z < ↑y
this : IsPreconnected (Rat.cast '' s)
⊢ False
[PROOFSTEP]
rw [isPreconnected_iff_ordConnected] at this
[GOAL]
case intro.intro.intro
p q : ℚ
s✝ t s : Set ℚ
hs : IsPreconnected s
x : ℚ
hx : x ∈ s
y : ℚ
hy : y ∈ s
H : x ≠ y
hlt : x < y
z : ℝ
hz : Irrational z
hxz : ↑x < z
hzy : z < ↑y
this✝ : IsPreconnected (Rat.cast '' s)
this : OrdConnected (Rat.cast '' s)
⊢ False
[PROOFSTEP]
have : z ∈ Rat.cast '' s := this.out (mem_image_of_mem _ hx) (mem_image_of_mem _ hy) ⟨hxz.le, hzy.le⟩
[GOAL]
case intro.intro.intro
p q : ℚ
s✝ t s : Set ℚ
hs : IsPreconnected s
x : ℚ
hx : x ∈ s
y : ℚ
hy : y ∈ s
H : x ≠ y
hlt : x < y
z : ℝ
hz : Irrational z
hxz : ↑x < z
hzy : z < ↑y
this✝¹ : IsPreconnected (Rat.cast '' s)
this✝ : OrdConnected (Rat.cast '' s)
this : z ∈ Rat.cast '' s
⊢ False
[PROOFSTEP]
exact hz (image_subset_range _ _ this)


[GOAL]
α : Type u_1
β : Type u_2
R : Type u_3
R' : Type u_4
S : Type u_5
S' : Type u_6
T : Type u_7
T' : Type u_8
inst✝² : NonUnitalNonAssocSemiring R
inst✝¹ : NonUnitalNonAssocSemiring S
inst✝ : NonUnitalNonAssocSemiring T
f✝ : R →ₙ+* S
g : R →ₙ+* T
f : R →ₙ+* S × T
x : R
⊢ ↑(NonUnitalRingHom.prod (comp (fst S T) f) (comp (snd S T) f)) x = ↑f x
[PROOFSTEP]
simp only [prod_apply, coe_fst, coe_snd, comp_apply, Prod.mk.eta]
[GOAL]
α : Type u_1
β : Type u_2
R : Type u_3
R' : Type u_4
S : Type u_5
S' : Type u_6
T : Type u_7
T' : Type u_8
inst✝² : NonAssocSemiring R
inst✝¹ : NonAssocSemiring S
inst✝ : NonAssocSemiring T
f✝ : R →+* S
g : R →+* T
f : R →+* S × T
x : R
⊢ ↑(RingHom.prod (comp (fst S T) f) (comp (snd S T) f)) x = ↑f x
[PROOFSTEP]
simp only [prod_apply, coe_fst, coe_snd, comp_apply, Prod.mk.eta]
[GOAL]
α : Type u_1
β : Type u_2
R : Type u_3
R' : Type u_4
S : Type u_5
S' : Type u_6
T : Type u_7
T' : Type u_8
inst✝⁴ : NonAssocSemiring R
inst✝³ : NonAssocSemiring S
inst✝² : NonAssocSemiring R'
inst✝¹ : NonAssocSemiring S'
inst✝ : Subsingleton S
x : R × S
⊢ (fun x => (x, 0)) x.fst = x
[PROOFSTEP]
cases x
[GOAL]
case mk
α : Type u_1
β : Type u_2
R : Type u_3
R' : Type u_4
S : Type u_5
S' : Type u_6
T : Type u_7
T' : Type u_8
inst✝⁴ : NonAssocSemiring R
inst✝³ : NonAssocSemiring S
inst✝² : NonAssocSemiring R'
inst✝¹ : NonAssocSemiring S'
inst✝ : Subsingleton S
fst✝ : R
snd✝ : S
⊢ (fun x => (x, 0)) (fst✝, snd✝).fst = (fst✝, snd✝)
[PROOFSTEP]
simp
[GOAL]
α : Type u_1
β : Type u_2
R : Type u_3
R' : Type u_4
S : Type u_5
S' : Type u_6
T : Type u_7
T' : Type u_8
inst✝⁴ : NonAssocSemiring R
inst✝³ : NonAssocSemiring S
inst✝² : NonAssocSemiring R'
inst✝¹ : NonAssocSemiring S'
inst✝ : Subsingleton S
⊢ ∀ (x y : R),
    Equiv.toFun
        { toFun := fun x => (x, 0), invFun := Prod.fst,
          left_inv := (_ : ∀ (x : R), ((fun x => (x, 0)) x).fst = ((fun x => (x, 0)) x).fst),
          right_inv := (_ : ∀ (x : R × S), (fun x => (x, 0)) x.fst = x) }
        (x * y) =
      Equiv.toFun
          { toFun := fun x => (x, 0), invFun := Prod.fst,
            left_inv := (_ : ∀ (x : R), ((fun x => (x, 0)) x).fst = ((fun x => (x, 0)) x).fst),
            right_inv := (_ : ∀ (x : R × S), (fun x => (x, 0)) x.fst = x) }
          x *
        Equiv.toFun
          { toFun := fun x => (x, 0), invFun := Prod.fst,
            left_inv := (_ : ∀ (x : R), ((fun x => (x, 0)) x).fst = ((fun x => (x, 0)) x).fst),
            right_inv := (_ : ∀ (x : R × S), (fun x => (x, 0)) x.fst = x) }
          y
[PROOFSTEP]
simp
[GOAL]
α : Type u_1
β : Type u_2
R : Type u_3
R' : Type u_4
S : Type u_5
S' : Type u_6
T : Type u_7
T' : Type u_8
inst✝⁴ : NonAssocSemiring R
inst✝³ : NonAssocSemiring S
inst✝² : NonAssocSemiring R'
inst✝¹ : NonAssocSemiring S'
inst✝ : Subsingleton S
⊢ ∀ (x y : R),
    Equiv.toFun
        { toFun := fun x => (x, 0), invFun := Prod.fst,
          left_inv := (_ : ∀ (x : R), ((fun x => (x, 0)) x).fst = ((fun x => (x, 0)) x).fst),
          right_inv := (_ : ∀ (x : R × S), (fun x => (x, 0)) x.fst = x) }
        (x + y) =
      Equiv.toFun
          { toFun := fun x => (x, 0), invFun := Prod.fst,
            left_inv := (_ : ∀ (x : R), ((fun x => (x, 0)) x).fst = ((fun x => (x, 0)) x).fst),
            right_inv := (_ : ∀ (x : R × S), (fun x => (x, 0)) x.fst = x) }
          x +
        Equiv.toFun
          { toFun := fun x => (x, 0), invFun := Prod.fst,
            left_inv := (_ : ∀ (x : R), ((fun x => (x, 0)) x).fst = ((fun x => (x, 0)) x).fst),
            right_inv := (_ : ∀ (x : R × S), (fun x => (x, 0)) x.fst = x) }
          y
[PROOFSTEP]
simp
[GOAL]
α : Type u_1
β : Type u_2
R : Type u_3
R' : Type u_4
S : Type u_5
S' : Type u_6
T : Type u_7
T' : Type u_8
inst✝⁴ : NonAssocSemiring R
inst✝³ : NonAssocSemiring S
inst✝² : NonAssocSemiring R'
inst✝¹ : NonAssocSemiring S'
inst✝ : Subsingleton S
x : S × R
⊢ (fun x => (0, x)) x.snd = x
[PROOFSTEP]
cases x
[GOAL]
case mk
α : Type u_1
β : Type u_2
R : Type u_3
R' : Type u_4
S : Type u_5
S' : Type u_6
T : Type u_7
T' : Type u_8
inst✝⁴ : NonAssocSemiring R
inst✝³ : NonAssocSemiring S
inst✝² : NonAssocSemiring R'
inst✝¹ : NonAssocSemiring S'
inst✝ : Subsingleton S
fst✝ : S
snd✝ : R
⊢ (fun x => (0, x)) (fst✝, snd✝).snd = (fst✝, snd✝)
[PROOFSTEP]
simp
[GOAL]
α : Type u_1
β : Type u_2
R : Type u_3
R' : Type u_4
S : Type u_5
S' : Type u_6
T : Type u_7
T' : Type u_8
inst✝⁴ : NonAssocSemiring R
inst✝³ : NonAssocSemiring S
inst✝² : NonAssocSemiring R'
inst✝¹ : NonAssocSemiring S'
inst✝ : Subsingleton S
⊢ ∀ (x y : R),
    Equiv.toFun
        { toFun := fun x => (0, x), invFun := Prod.snd,
          left_inv := (_ : ∀ (x : R), ((fun x => (0, x)) x).snd = ((fun x => (0, x)) x).snd),
          right_inv := (_ : ∀ (x : S × R), (fun x => (0, x)) x.snd = x) }
        (x * y) =
      Equiv.toFun
          { toFun := fun x => (0, x), invFun := Prod.snd,
            left_inv := (_ : ∀ (x : R), ((fun x => (0, x)) x).snd = ((fun x => (0, x)) x).snd),
            right_inv := (_ : ∀ (x : S × R), (fun x => (0, x)) x.snd = x) }
          x *
        Equiv.toFun
          { toFun := fun x => (0, x), invFun := Prod.snd,
            left_inv := (_ : ∀ (x : R), ((fun x => (0, x)) x).snd = ((fun x => (0, x)) x).snd),
            right_inv := (_ : ∀ (x : S × R), (fun x => (0, x)) x.snd = x) }
          y
[PROOFSTEP]
simp
[GOAL]
α : Type u_1
β : Type u_2
R : Type u_3
R' : Type u_4
S : Type u_5
S' : Type u_6
T : Type u_7
T' : Type u_8
inst✝⁴ : NonAssocSemiring R
inst✝³ : NonAssocSemiring S
inst✝² : NonAssocSemiring R'
inst✝¹ : NonAssocSemiring S'
inst✝ : Subsingleton S
⊢ ∀ (x y : R),
    Equiv.toFun
        { toFun := fun x => (0, x), invFun := Prod.snd,
          left_inv := (_ : ∀ (x : R), ((fun x => (0, x)) x).snd = ((fun x => (0, x)) x).snd),
          right_inv := (_ : ∀ (x : S × R), (fun x => (0, x)) x.snd = x) }
        (x + y) =
      Equiv.toFun
          { toFun := fun x => (0, x), invFun := Prod.snd,
            left_inv := (_ : ∀ (x : R), ((fun x => (0, x)) x).snd = ((fun x => (0, x)) x).snd),
            right_inv := (_ : ∀ (x : S × R), (fun x => (0, x)) x.snd = x) }
          x +
        Equiv.toFun
          { toFun := fun x => (0, x), invFun := Prod.snd,
            left_inv := (_ : ∀ (x : R), ((fun x => (0, x)) x).snd = ((fun x => (0, x)) x).snd),
            right_inv := (_ : ∀ (x : S × R), (fun x => (0, x)) x.snd = x) }
          y
[PROOFSTEP]
simp
[GOAL]
α : Type u_1
β : Type u_2
R✝ : Type u_3
R' : Type u_4
S✝ : Type u_5
S' : Type u_6
T : Type u_7
T' : Type u_8
R : Type u_9
S : Type u_10
inst✝⁴ : Ring R
inst✝³ : Ring S
inst✝² : IsDomain (R × S)
inst✝¹ : Nontrivial R
inst✝ : Nontrivial S
⊢ False
[PROOFSTEP]
have := NoZeroDivisors.eq_zero_or_eq_zero_of_mul_eq_zero (show ((0 : R), (1 : S)) * (1, 0) = 0 by simp)
[GOAL]
α : Type u_1
β : Type u_2
R✝ : Type u_3
R' : Type u_4
S✝ : Type u_5
S' : Type u_6
T : Type u_7
T' : Type u_8
R : Type u_9
S : Type u_10
inst✝⁴ : Ring R
inst✝³ : Ring S
inst✝² : IsDomain (R × S)
inst✝¹ : Nontrivial R
inst✝ : Nontrivial S
⊢ (0, 1) * (1, 0) = 0
[PROOFSTEP]
simp
[GOAL]
α : Type u_1
β : Type u_2
R✝ : Type u_3
R' : Type u_4
S✝ : Type u_5
S' : Type u_6
T : Type u_7
T' : Type u_8
R : Type u_9
S : Type u_10
inst✝⁴ : Ring R
inst✝³ : Ring S
inst✝² : IsDomain (R × S)
inst✝¹ : Nontrivial R
inst✝ : Nontrivial S
this : (0, 1) = 0 ∨ (1, 0) = 0
⊢ False
[PROOFSTEP]
rw [Prod.mk_eq_zero, Prod.mk_eq_zero] at this
[GOAL]
α : Type u_1
β : Type u_2
R✝ : Type u_3
R' : Type u_4
S✝ : Type u_5
S' : Type u_6
T : Type u_7
T' : Type u_8
R : Type u_9
S : Type u_10
inst✝⁴ : Ring R
inst✝³ : Ring S
inst✝² : IsDomain (R × S)
inst✝¹ : Nontrivial R
inst✝ : Nontrivial S
this : 0 = 0 ∧ 1 = 0 ∨ 1 = 0 ∧ 0 = 0
⊢ False
[PROOFSTEP]
rcases this with (⟨_, h⟩ | ⟨h, _⟩)
[GOAL]
case inl.intro
α : Type u_1
β : Type u_2
R✝ : Type u_3
R' : Type u_4
S✝ : Type u_5
S' : Type u_6
T : Type u_7
T' : Type u_8
R : Type u_9
S : Type u_10
inst✝⁴ : Ring R
inst✝³ : Ring S
inst✝² : IsDomain (R × S)
inst✝¹ : Nontrivial R
inst✝ : Nontrivial S
left✝ : 0 = 0
h : 1 = 0
⊢ False
[PROOFSTEP]
exact zero_ne_one h.symm
[GOAL]
case inr.intro
α : Type u_1
β : Type u_2
R✝ : Type u_3
R' : Type u_4
S✝ : Type u_5
S' : Type u_6
T : Type u_7
T' : Type u_8
R : Type u_9
S : Type u_10
inst✝⁴ : Ring R
inst✝³ : Ring S
inst✝² : IsDomain (R × S)
inst✝¹ : Nontrivial R
inst✝ : Nontrivial S
h : 1 = 0
right✝ : 0 = 0
⊢ False
[PROOFSTEP]
exact zero_ne_one h.symm


[GOAL]
G : Type u_1
inst✝⁴ : MeasurableSpace G
inst✝³ : Group G
inst✝² : MeasurableMul₂ G
μ ν : Measure G
inst✝¹ : SigmaFinite ν
inst✝ : SigmaFinite μ
s : Set G
hs : MeasurableSet s
⊢ Measurable fun x => ↑↑μ ((fun y => y * x) ⁻¹' s)
[PROOFSTEP]
suffices Measurable fun y => μ ((fun x => (x, y)) ⁻¹' ((fun z : G × G => ((1 : G), z.1 * z.2)) ⁻¹' univ ×ˢ s)) by
  convert this using 1; ext1 x; congr 1 with y : 1; simp
[GOAL]
G : Type u_1
inst✝⁴ : MeasurableSpace G
inst✝³ : Group G
inst✝² : MeasurableMul₂ G
μ ν : Measure G
inst✝¹ : SigmaFinite ν
inst✝ : SigmaFinite μ
s : Set G
hs : MeasurableSet s
this : Measurable fun y => ↑↑μ ((fun x => (x, y)) ⁻¹' ((fun z => (1, z.fst * z.snd)) ⁻¹' univ ×ˢ s))
⊢ Measurable fun x => ↑↑μ ((fun y => y * x) ⁻¹' s)
[PROOFSTEP]
convert this using 1
[GOAL]
case h.e'_5
G : Type u_1
inst✝⁴ : MeasurableSpace G
inst✝³ : Group G
inst✝² : MeasurableMul₂ G
μ ν : Measure G
inst✝¹ : SigmaFinite ν
inst✝ : SigmaFinite μ
s : Set G
hs : MeasurableSet s
this : Measurable fun y => ↑↑μ ((fun x => (x, y)) ⁻¹' ((fun z => (1, z.fst * z.snd)) ⁻¹' univ ×ˢ s))
⊢ (fun x => ↑↑μ ((fun y => y * x) ⁻¹' s)) = fun y =>
    ↑↑μ ((fun x => (x, y)) ⁻¹' ((fun z => (1, z.fst * z.snd)) ⁻¹' univ ×ˢ s))
[PROOFSTEP]
ext1 x
[GOAL]
case h.e'_5.h
G : Type u_1
inst✝⁴ : MeasurableSpace G
inst✝³ : Group G
inst✝² : MeasurableMul₂ G
μ ν : Measure G
inst✝¹ : SigmaFinite ν
inst✝ : SigmaFinite μ
s : Set G
hs : MeasurableSet s
this : Measurable fun y => ↑↑μ ((fun x => (x, y)) ⁻¹' ((fun z => (1, z.fst * z.snd)) ⁻¹' univ ×ˢ s))
x : G
⊢ ↑↑μ ((fun y => y * x) ⁻¹' s) = ↑↑μ ((fun x_1 => (x_1, x)) ⁻¹' ((fun z => (1, z.fst * z.snd)) ⁻¹' univ ×ˢ s))
[PROOFSTEP]
congr 1 with y : 1
[GOAL]
case h.e'_5.h.e_a.h
G : Type u_1
inst✝⁴ : MeasurableSpace G
inst✝³ : Group G
inst✝² : MeasurableMul₂ G
μ ν : Measure G
inst✝¹ : SigmaFinite ν
inst✝ : SigmaFinite μ
s : Set G
hs : MeasurableSet s
this : Measurable fun y => ↑↑μ ((fun x => (x, y)) ⁻¹' ((fun z => (1, z.fst * z.snd)) ⁻¹' univ ×ˢ s))
x y : G
⊢ y ∈ (fun y => y * x) ⁻¹' s ↔ y ∈ (fun x_1 => (x_1, x)) ⁻¹' ((fun z => (1, z.fst * z.snd)) ⁻¹' univ ×ˢ s)
[PROOFSTEP]
simp
[GOAL]
G : Type u_1
inst✝⁴ : MeasurableSpace G
inst✝³ : Group G
inst✝² : MeasurableMul₂ G
μ ν : Measure G
inst✝¹ : SigmaFinite ν
inst✝ : SigmaFinite μ
s : Set G
hs : MeasurableSet s
⊢ Measurable fun y => ↑↑μ ((fun x => (x, y)) ⁻¹' ((fun z => (1, z.fst * z.snd)) ⁻¹' univ ×ˢ s))
[PROOFSTEP]
apply measurable_measure_prod_mk_right
[GOAL]
case hs
G : Type u_1
inst✝⁴ : MeasurableSpace G
inst✝³ : Group G
inst✝² : MeasurableMul₂ G
μ ν : Measure G
inst✝¹ : SigmaFinite ν
inst✝ : SigmaFinite μ
s : Set G
hs : MeasurableSet s
⊢ MeasurableSet ((fun z => (1, z.fst * z.snd)) ⁻¹' univ ×ˢ s)
[PROOFSTEP]
apply measurable_const.prod_mk measurable_mul (MeasurableSet.univ.prod hs)
[GOAL]
G : Type u_1
inst✝⁴ : MeasurableSpace G
inst✝³ : Group G
inst✝² : MeasurableMul₂ G
μ ν : Measure G
inst✝¹ : SigmaFinite ν
inst✝ : SigmaFinite μ
s : Set G
hs : MeasurableSet s
⊢ MeasurableSpace G
[PROOFSTEP]
infer_instance
[GOAL]
G : Type u_1
inst✝⁷ : MeasurableSpace G
inst✝⁶ : Group G
inst✝⁵ : MeasurableMul₂ G
μ ν : Measure G
inst✝⁴ : SigmaFinite ν
inst✝³ : SigmaFinite μ
s : Set G
inst✝² : MeasurableInv G
inst✝¹ : IsMulLeftInvariant μ
inst✝ : IsMulLeftInvariant ν
⊢ MeasurePreserving fun z => (z.snd * z.fst, z.fst⁻¹)
[PROOFSTEP]
convert (measurePreserving_prod_inv_mul_swap ν μ).comp (measurePreserving_prod_mul_swap μ ν) using 1
[GOAL]
case h.e'_5
G : Type u_1
inst✝⁷ : MeasurableSpace G
inst✝⁶ : Group G
inst✝⁵ : MeasurableMul₂ G
μ ν : Measure G
inst✝⁴ : SigmaFinite ν
inst✝³ : SigmaFinite μ
s : Set G
inst✝² : MeasurableInv G
inst✝¹ : IsMulLeftInvariant μ
inst✝ : IsMulLeftInvariant ν
⊢ (fun z => (z.snd * z.fst, z.fst⁻¹)) = (fun z => (z.snd, z.snd⁻¹ * z.fst)) ∘ fun z => (z.snd, z.snd * z.fst)
[PROOFSTEP]
ext1 ⟨x, y⟩
[GOAL]
case h.e'_5.h.mk
G : Type u_1
inst✝⁷ : MeasurableSpace G
inst✝⁶ : Group G
inst✝⁵ : MeasurableMul₂ G
μ ν : Measure G
inst✝⁴ : SigmaFinite ν
inst✝³ : SigmaFinite μ
s : Set G
inst✝² : MeasurableInv G
inst✝¹ : IsMulLeftInvariant μ
inst✝ : IsMulLeftInvariant ν
x y : G
⊢ ((x, y).snd * (x, y).fst, (x, y).fst⁻¹) =
    ((fun z => (z.snd, z.snd⁻¹ * z.fst)) ∘ fun z => (z.snd, z.snd * z.fst)) (x, y)
[PROOFSTEP]
simp_rw [Function.comp_apply, mul_inv_rev, inv_mul_cancel_right]
[GOAL]
G : Type u_1
inst✝⁶ : MeasurableSpace G
inst✝⁵ : Group G
inst✝⁴ : MeasurableMul₂ G
μ ν : Measure G
inst✝³ : SigmaFinite ν
inst✝² : SigmaFinite μ
s : Set G
inst✝¹ : MeasurableInv G
inst✝ : IsMulLeftInvariant μ
⊢ QuasiMeasurePreserving Inv.inv
[PROOFSTEP]
refine' ⟨measurable_inv, AbsolutelyContinuous.mk fun s hsm hμs => _⟩
[GOAL]
G : Type u_1
inst✝⁶ : MeasurableSpace G
inst✝⁵ : Group G
inst✝⁴ : MeasurableMul₂ G
μ ν : Measure G
inst✝³ : SigmaFinite ν
inst✝² : SigmaFinite μ
s✝ : Set G
inst✝¹ : MeasurableInv G
inst✝ : IsMulLeftInvariant μ
s : Set G
hsm : MeasurableSet s
hμs : ↑↑μ s = 0
⊢ ↑↑(map Inv.inv μ) s = 0
[PROOFSTEP]
rw [map_apply measurable_inv hsm, inv_preimage]
[GOAL]
G : Type u_1
inst✝⁶ : MeasurableSpace G
inst✝⁵ : Group G
inst✝⁴ : MeasurableMul₂ G
μ ν : Measure G
inst✝³ : SigmaFinite ν
inst✝² : SigmaFinite μ
s✝ : Set G
inst✝¹ : MeasurableInv G
inst✝ : IsMulLeftInvariant μ
s : Set G
hsm : MeasurableSet s
hμs : ↑↑μ s = 0
⊢ ↑↑μ s⁻¹ = 0
[PROOFSTEP]
have hf : Measurable fun z : G × G => (z.2 * z.1, z.1⁻¹) :=
  (measurable_snd.mul measurable_fst).prod_mk measurable_fst.inv
[GOAL]
G : Type u_1
inst✝⁶ : MeasurableSpace G
inst✝⁵ : Group G
inst✝⁴ : MeasurableMul₂ G
μ ν : Measure G
inst✝³ : SigmaFinite ν
inst✝² : SigmaFinite μ
s✝ : Set G
inst✝¹ : MeasurableInv G
inst✝ : IsMulLeftInvariant μ
s : Set G
hsm : MeasurableSet s
hμs : ↑↑μ s = 0
hf : Measurable fun z => (z.snd * z.fst, z.fst⁻¹)
⊢ ↑↑μ s⁻¹ = 0
[PROOFSTEP]
suffices map (fun z : G × G => (z.2 * z.1, z.1⁻¹)) (μ.prod μ) (s⁻¹ ×ˢ s⁻¹) = 0 by
  simpa only [(measurePreserving_mul_prod_inv μ μ).map_eq, prod_prod, mul_eq_zero (M₀ := ℝ≥0∞), or_self_iff] using this
[GOAL]
G : Type u_1
inst✝⁶ : MeasurableSpace G
inst✝⁵ : Group G
inst✝⁴ : MeasurableMul₂ G
μ ν : Measure G
inst✝³ : SigmaFinite ν
inst✝² : SigmaFinite μ
s✝ : Set G
inst✝¹ : MeasurableInv G
inst✝ : IsMulLeftInvariant μ
s : Set G
hsm : MeasurableSet s
hμs : ↑↑μ s = 0
hf : Measurable fun z => (z.snd * z.fst, z.fst⁻¹)
this : ↑↑(map (fun z => (z.snd * z.fst, z.fst⁻¹)) (Measure.prod μ μ)) (s⁻¹ ×ˢ s⁻¹) = 0
⊢ ↑↑μ s⁻¹ = 0
[PROOFSTEP]
simpa only [(measurePreserving_mul_prod_inv μ μ).map_eq, prod_prod, mul_eq_zero (M₀ := ℝ≥0∞), or_self_iff] using this
[GOAL]
G : Type u_1
inst✝⁶ : MeasurableSpace G
inst✝⁵ : Group G
inst✝⁴ : MeasurableMul₂ G
μ ν : Measure G
inst✝³ : SigmaFinite ν
inst✝² : SigmaFinite μ
s✝ : Set G
inst✝¹ : MeasurableInv G
inst✝ : IsMulLeftInvariant μ
s : Set G
hsm : MeasurableSet s
hμs : ↑↑μ s = 0
hf : Measurable fun z => (z.snd * z.fst, z.fst⁻¹)
⊢ ↑↑(map (fun z => (z.snd * z.fst, z.fst⁻¹)) (Measure.prod μ μ)) (s⁻¹ ×ˢ s⁻¹) = 0
[PROOFSTEP]
have hsm' : MeasurableSet (s⁻¹ ×ˢ s⁻¹) := hsm.inv.prod hsm.inv
[GOAL]
G : Type u_1
inst✝⁶ : MeasurableSpace G
inst✝⁵ : Group G
inst✝⁴ : MeasurableMul₂ G
μ ν : Measure G
inst✝³ : SigmaFinite ν
inst✝² : SigmaFinite μ
s✝ : Set G
inst✝¹ : MeasurableInv G
inst✝ : IsMulLeftInvariant μ
s : Set G
hsm : MeasurableSet s
hμs : ↑↑μ s = 0
hf : Measurable fun z => (z.snd * z.fst, z.fst⁻¹)
hsm' : MeasurableSet (s⁻¹ ×ˢ s⁻¹)
⊢ ↑↑(map (fun z => (z.snd * z.fst, z.fst⁻¹)) (Measure.prod μ μ)) (s⁻¹ ×ˢ s⁻¹) = 0
[PROOFSTEP]
simp_rw [map_apply hf hsm', prod_apply_symm (μ := μ) (ν := μ) (hf hsm'), preimage_preimage, mk_preimage_prod,
  inv_preimage, inv_inv, measure_mono_null (inter_subset_right _ _) hμs, lintegral_zero]
[GOAL]
G : Type u_1
inst✝⁶ : MeasurableSpace G
inst✝⁵ : Group G
inst✝⁴ : MeasurableMul₂ G
μ ν : Measure G
inst✝³ : SigmaFinite ν
inst✝² : SigmaFinite μ
s : Set G
inst✝¹ : MeasurableInv G
inst✝ : IsMulLeftInvariant μ
⊢ ↑↑μ s⁻¹ = 0 ↔ ↑↑μ s = 0
[PROOFSTEP]
refine' ⟨fun hs => _, (quasiMeasurePreserving_inv μ).preimage_null⟩
[GOAL]
G : Type u_1
inst✝⁶ : MeasurableSpace G
inst✝⁵ : Group G
inst✝⁴ : MeasurableMul₂ G
μ ν : Measure G
inst✝³ : SigmaFinite ν
inst✝² : SigmaFinite μ
s : Set G
inst✝¹ : MeasurableInv G
inst✝ : IsMulLeftInvariant μ
hs : ↑↑μ s⁻¹ = 0
⊢ ↑↑μ s = 0
[PROOFSTEP]
rw [← inv_inv s]
[GOAL]
G : Type u_1
inst✝⁶ : MeasurableSpace G
inst✝⁵ : Group G
inst✝⁴ : MeasurableMul₂ G
μ ν : Measure G
inst✝³ : SigmaFinite ν
inst✝² : SigmaFinite μ
s : Set G
inst✝¹ : MeasurableInv G
inst✝ : IsMulLeftInvariant μ
hs : ↑↑μ s⁻¹ = 0
⊢ ↑↑μ s⁻¹⁻¹ = 0
[PROOFSTEP]
exact (quasiMeasurePreserving_inv μ).preimage_null hs
[GOAL]
G : Type u_1
inst✝⁶ : MeasurableSpace G
inst✝⁵ : Group G
inst✝⁴ : MeasurableMul₂ G
μ ν : Measure G
inst✝³ : SigmaFinite ν
inst✝² : SigmaFinite μ
s : Set G
inst✝¹ : MeasurableInv G
inst✝ : IsMulLeftInvariant μ
⊢ μ ≪ Measure.inv μ
[PROOFSTEP]
refine' AbsolutelyContinuous.mk fun s _ => _
[GOAL]
G : Type u_1
inst✝⁶ : MeasurableSpace G
inst✝⁵ : Group G
inst✝⁴ : MeasurableMul₂ G
μ ν : Measure G
inst✝³ : SigmaFinite ν
inst✝² : SigmaFinite μ
s✝ : Set G
inst✝¹ : MeasurableInv G
inst✝ : IsMulLeftInvariant μ
s : Set G
x✝ : MeasurableSet s
⊢ ↑↑(Measure.inv μ) s = 0 → ↑↑μ s = 0
[PROOFSTEP]
simp_rw [inv_apply μ s, measure_inv_null, imp_self]
[GOAL]
G : Type u_1
inst✝⁷ : MeasurableSpace G
inst✝⁶ : Group G
inst✝⁵ : MeasurableMul₂ G
μ ν : Measure G
inst✝⁴ : SigmaFinite ν
inst✝³ : SigmaFinite μ
s : Set G
inst✝² : MeasurableInv G
inst✝¹ : IsMulLeftInvariant μ
inst✝ : IsMulLeftInvariant ν
f : G → G → ℝ≥0∞
hf : AEMeasurable (uncurry f)
⊢ ∫⁻ (x : G), ∫⁻ (y : G), f (y * x) x⁻¹ ∂ν ∂μ = ∫⁻ (x : G), ∫⁻ (y : G), f x y ∂ν ∂μ
[PROOFSTEP]
have h : Measurable fun z : G × G => (z.2 * z.1, z.1⁻¹) :=
  (measurable_snd.mul measurable_fst).prod_mk measurable_fst.inv
[GOAL]
G : Type u_1
inst✝⁷ : MeasurableSpace G
inst✝⁶ : Group G
inst✝⁵ : MeasurableMul₂ G
μ ν : Measure G
inst✝⁴ : SigmaFinite ν
inst✝³ : SigmaFinite μ
s : Set G
inst✝² : MeasurableInv G
inst✝¹ : IsMulLeftInvariant μ
inst✝ : IsMulLeftInvariant ν
f : G → G → ℝ≥0∞
hf : AEMeasurable (uncurry f)
h : Measurable fun z => (z.snd * z.fst, z.fst⁻¹)
⊢ ∫⁻ (x : G), ∫⁻ (y : G), f (y * x) x⁻¹ ∂ν ∂μ = ∫⁻ (x : G), ∫⁻ (y : G), f x y ∂ν ∂μ
[PROOFSTEP]
have h2f : AEMeasurable (uncurry fun x y => f (y * x) x⁻¹) (μ.prod ν) :=
  hf.comp_quasiMeasurePreserving (measurePreserving_mul_prod_inv μ ν).quasiMeasurePreserving
[GOAL]
G : Type u_1
inst✝⁷ : MeasurableSpace G
inst✝⁶ : Group G
inst✝⁵ : MeasurableMul₂ G
μ ν : Measure G
inst✝⁴ : SigmaFinite ν
inst✝³ : SigmaFinite μ
s : Set G
inst✝² : MeasurableInv G
inst✝¹ : IsMulLeftInvariant μ
inst✝ : IsMulLeftInvariant ν
f : G → G → ℝ≥0∞
hf : AEMeasurable (uncurry f)
h : Measurable fun z => (z.snd * z.fst, z.fst⁻¹)
h2f : AEMeasurable (uncurry fun x y => f (y * x) x⁻¹)
⊢ ∫⁻ (x : G), ∫⁻ (y : G), f (y * x) x⁻¹ ∂ν ∂μ = ∫⁻ (x : G), ∫⁻ (y : G), f x y ∂ν ∂μ
[PROOFSTEP]
simp_rw [lintegral_lintegral h2f, lintegral_lintegral hf]
[GOAL]
G : Type u_1
inst✝⁷ : MeasurableSpace G
inst✝⁶ : Group G
inst✝⁵ : MeasurableMul₂ G
μ ν : Measure G
inst✝⁴ : SigmaFinite ν
inst✝³ : SigmaFinite μ
s : Set G
inst✝² : MeasurableInv G
inst✝¹ : IsMulLeftInvariant μ
inst✝ : IsMulLeftInvariant ν
f : G → G → ℝ≥0∞
hf : AEMeasurable (uncurry f)
h : Measurable fun z => (z.snd * z.fst, z.fst⁻¹)
h2f : AEMeasurable (uncurry fun x y => f (y * x) x⁻¹)
⊢ ∫⁻ (z : G × G), f (z.snd * z.fst) z.fst⁻¹ ∂Measure.prod μ ν = ∫⁻ (z : G × G), f z.fst z.snd ∂Measure.prod μ ν
[PROOFSTEP]
conv_rhs => rw [← (measurePreserving_mul_prod_inv μ ν).map_eq]
[GOAL]
G : Type u_1
inst✝⁷ : MeasurableSpace G
inst✝⁶ : Group G
inst✝⁵ : MeasurableMul₂ G
μ ν : Measure G
inst✝⁴ : SigmaFinite ν
inst✝³ : SigmaFinite μ
s : Set G
inst✝² : MeasurableInv G
inst✝¹ : IsMulLeftInvariant μ
inst✝ : IsMulLeftInvariant ν
f : G → G → ℝ≥0∞
hf : AEMeasurable (uncurry f)
h : Measurable fun z => (z.snd * z.fst, z.fst⁻¹)
h2f : AEMeasurable (uncurry fun x y => f (y * x) x⁻¹)
| ∫⁻ (z : G × G), f z.fst z.snd ∂Measure.prod μ ν
[PROOFSTEP]
rw [← (measurePreserving_mul_prod_inv μ ν).map_eq]
[GOAL]
G : Type u_1
inst✝⁷ : MeasurableSpace G
inst✝⁶ : Group G
inst✝⁵ : MeasurableMul₂ G
μ ν : Measure G
inst✝⁴ : SigmaFinite ν
inst✝³ : SigmaFinite μ
s : Set G
inst✝² : MeasurableInv G
inst✝¹ : IsMulLeftInvariant μ
inst✝ : IsMulLeftInvariant ν
f : G → G → ℝ≥0∞
hf : AEMeasurable (uncurry f)
h : Measurable fun z => (z.snd * z.fst, z.fst⁻¹)
h2f : AEMeasurable (uncurry fun x y => f (y * x) x⁻¹)
| ∫⁻ (z : G × G), f z.fst z.snd ∂Measure.prod μ ν
[PROOFSTEP]
rw [← (measurePreserving_mul_prod_inv μ ν).map_eq]
[GOAL]
G : Type u_1
inst✝⁷ : MeasurableSpace G
inst✝⁶ : Group G
inst✝⁵ : MeasurableMul₂ G
μ ν : Measure G
inst✝⁴ : SigmaFinite ν
inst✝³ : SigmaFinite μ
s : Set G
inst✝² : MeasurableInv G
inst✝¹ : IsMulLeftInvariant μ
inst✝ : IsMulLeftInvariant ν
f : G → G → ℝ≥0∞
hf : AEMeasurable (uncurry f)
h : Measurable fun z => (z.snd * z.fst, z.fst⁻¹)
h2f : AEMeasurable (uncurry fun x y => f (y * x) x⁻¹)
| ∫⁻ (z : G × G), f z.fst z.snd ∂Measure.prod μ ν
[PROOFSTEP]
rw [← (measurePreserving_mul_prod_inv μ ν).map_eq]
[GOAL]
G : Type u_1
inst✝⁷ : MeasurableSpace G
inst✝⁶ : Group G
inst✝⁵ : MeasurableMul₂ G
μ ν : Measure G
inst✝⁴ : SigmaFinite ν
inst✝³ : SigmaFinite μ
s : Set G
inst✝² : MeasurableInv G
inst✝¹ : IsMulLeftInvariant μ
inst✝ : IsMulLeftInvariant ν
f : G → G → ℝ≥0∞
hf : AEMeasurable (uncurry f)
h : Measurable fun z => (z.snd * z.fst, z.fst⁻¹)
h2f : AEMeasurable (uncurry fun x y => f (y * x) x⁻¹)
⊢ ∫⁻ (z : G × G), f (z.snd * z.fst) z.fst⁻¹ ∂Measure.prod μ ν =
    ∫⁻ (z : G × G), f z.fst z.snd ∂map (fun z => (z.snd * z.fst, z.fst⁻¹)) (Measure.prod μ ν)
[PROOFSTEP]
symm
[GOAL]
G : Type u_1
inst✝⁷ : MeasurableSpace G
inst✝⁶ : Group G
inst✝⁵ : MeasurableMul₂ G
μ ν : Measure G
inst✝⁴ : SigmaFinite ν
inst✝³ : SigmaFinite μ
s : Set G
inst✝² : MeasurableInv G
inst✝¹ : IsMulLeftInvariant μ
inst✝ : IsMulLeftInvariant ν
f : G → G → ℝ≥0∞
hf : AEMeasurable (uncurry f)
h : Measurable fun z => (z.snd * z.fst, z.fst⁻¹)
h2f : AEMeasurable (uncurry fun x y => f (y * x) x⁻¹)
⊢ ∫⁻ (z : G × G), f z.fst z.snd ∂map (fun z => (z.snd * z.fst, z.fst⁻¹)) (Measure.prod μ ν) =
    ∫⁻ (z : G × G), f (z.snd * z.fst) z.fst⁻¹ ∂Measure.prod μ ν
[PROOFSTEP]
exact lintegral_map' (hf.mono' (measurePreserving_mul_prod_inv μ ν).map_eq.absolutelyContinuous) h.aemeasurable
[GOAL]
G : Type u_1
inst✝⁶ : MeasurableSpace G
inst✝⁵ : Group G
inst✝⁴ : MeasurableMul₂ G
μ ν : Measure G
inst✝³ : SigmaFinite ν
inst✝² : SigmaFinite μ
s : Set G
inst✝¹ : MeasurableInv G
inst✝ : IsMulLeftInvariant μ
y : G
⊢ ↑↑μ ((fun x => x * y) ⁻¹' s) = 0 ↔ ↑↑μ ((fun x => y⁻¹ * x) ⁻¹' s⁻¹)⁻¹ = 0
[PROOFSTEP]
simp_rw [← inv_preimage, preimage_preimage, mul_inv_rev, inv_inv]
[GOAL]
G : Type u_1
inst✝⁶ : MeasurableSpace G
inst✝⁵ : Group G
inst✝⁴ : MeasurableMul₂ G
μ ν : Measure G
inst✝³ : SigmaFinite ν
inst✝² : SigmaFinite μ
s : Set G
inst✝¹ : MeasurableInv G
inst✝ : IsMulLeftInvariant μ
y : G
⊢ ↑↑μ ((fun x => y⁻¹ * x) ⁻¹' s⁻¹)⁻¹ = 0 ↔ ↑↑μ s = 0
[PROOFSTEP]
simp only [measure_inv_null μ, measure_preimage_mul]
[GOAL]
G : Type u_1
inst✝⁶ : MeasurableSpace G
inst✝⁵ : Group G
inst✝⁴ : MeasurableMul₂ G
μ ν : Measure G
inst✝³ : SigmaFinite ν
inst✝² : SigmaFinite μ
s : Set G
inst✝¹ : MeasurableInv G
inst✝ : IsMulLeftInvariant μ
g : G
⊢ μ ≪ map (fun x => x * g) μ
[PROOFSTEP]
refine' AbsolutelyContinuous.mk fun s hs => _
[GOAL]
G : Type u_1
inst✝⁶ : MeasurableSpace G
inst✝⁵ : Group G
inst✝⁴ : MeasurableMul₂ G
μ ν : Measure G
inst✝³ : SigmaFinite ν
inst✝² : SigmaFinite μ
s✝ : Set G
inst✝¹ : MeasurableInv G
inst✝ : IsMulLeftInvariant μ
g : G
s : Set G
hs : MeasurableSet s
⊢ ↑↑(map (fun x => x * g) μ) s = 0 → ↑↑μ s = 0
[PROOFSTEP]
rw [map_apply (measurable_mul_const g) hs, measure_mul_right_null]
[GOAL]
G : Type u_1
inst✝⁶ : MeasurableSpace G
inst✝⁵ : Group G
inst✝⁴ : MeasurableMul₂ G
μ ν : Measure G
inst✝³ : SigmaFinite ν
inst✝² : SigmaFinite μ
s✝ : Set G
inst✝¹ : MeasurableInv G
inst✝ : IsMulLeftInvariant μ
g : G
s : Set G
hs : MeasurableSet s
⊢ ↑↑μ s = 0 → ↑↑μ s = 0
[PROOFSTEP]
exact id
[GOAL]
G : Type u_1
inst✝⁶ : MeasurableSpace G
inst✝⁵ : Group G
inst✝⁴ : MeasurableMul₂ G
μ ν : Measure G
inst✝³ : SigmaFinite ν
inst✝² : SigmaFinite μ
s : Set G
inst✝¹ : MeasurableInv G
inst✝ : IsMulLeftInvariant μ
g : G
⊢ μ ≪ map (fun h => g / h) μ
[PROOFSTEP]
simp_rw [div_eq_mul_inv]
[GOAL]
G : Type u_1
inst✝⁶ : MeasurableSpace G
inst✝⁵ : Group G
inst✝⁴ : MeasurableMul₂ G
μ ν : Measure G
inst✝³ : SigmaFinite ν
inst✝² : SigmaFinite μ
s : Set G
inst✝¹ : MeasurableInv G
inst✝ : IsMulLeftInvariant μ
g : G
⊢ μ ≪ map (fun h => g * h⁻¹) μ
[PROOFSTEP]
erw [← map_map (measurable_const_mul g) measurable_inv]
[GOAL]
G : Type u_1
inst✝⁶ : MeasurableSpace G
inst✝⁵ : Group G
inst✝⁴ : MeasurableMul₂ G
μ ν : Measure G
inst✝³ : SigmaFinite ν
inst✝² : SigmaFinite μ
s : Set G
inst✝¹ : MeasurableInv G
inst✝ : IsMulLeftInvariant μ
g : G
⊢ μ ≪ map (fun x => g * x) (map Inv.inv μ)
[PROOFSTEP]
conv_lhs => rw [← map_mul_left_eq_self μ g]
[GOAL]
G : Type u_1
inst✝⁶ : MeasurableSpace G
inst✝⁵ : Group G
inst✝⁴ : MeasurableMul₂ G
μ ν : Measure G
inst✝³ : SigmaFinite ν
inst✝² : SigmaFinite μ
s : Set G
inst✝¹ : MeasurableInv G
inst✝ : IsMulLeftInvariant μ
g : G
| μ
[PROOFSTEP]
rw [← map_mul_left_eq_self μ g]
[GOAL]
G : Type u_1
inst✝⁶ : MeasurableSpace G
inst✝⁵ : Group G
inst✝⁴ : MeasurableMul₂ G
μ ν : Measure G
inst✝³ : SigmaFinite ν
inst✝² : SigmaFinite μ
s : Set G
inst✝¹ : MeasurableInv G
inst✝ : IsMulLeftInvariant μ
g : G
| μ
[PROOFSTEP]
rw [← map_mul_left_eq_self μ g]
[GOAL]
G : Type u_1
inst✝⁶ : MeasurableSpace G
inst✝⁵ : Group G
inst✝⁴ : MeasurableMul₂ G
μ ν : Measure G
inst✝³ : SigmaFinite ν
inst✝² : SigmaFinite μ
s : Set G
inst✝¹ : MeasurableInv G
inst✝ : IsMulLeftInvariant μ
g : G
| μ
[PROOFSTEP]
rw [← map_mul_left_eq_self μ g]
[GOAL]
G : Type u_1
inst✝⁶ : MeasurableSpace G
inst✝⁵ : Group G
inst✝⁴ : MeasurableMul₂ G
μ ν : Measure G
inst✝³ : SigmaFinite ν
inst✝² : SigmaFinite μ
s : Set G
inst✝¹ : MeasurableInv G
inst✝ : IsMulLeftInvariant μ
g : G
⊢ map (fun x => g * x) μ ≪ map (fun x => g * x) (map Inv.inv μ)
[PROOFSTEP]
exact (absolutelyContinuous_inv μ).map (measurable_const_mul g)
[GOAL]
G : Type u_1
inst✝⁷ : MeasurableSpace G
inst✝⁶ : Group G
inst✝⁵ : MeasurableMul₂ G
μ ν : Measure G
inst✝⁴ : SigmaFinite ν
inst✝³ : SigmaFinite μ
s : Set G
inst✝² : MeasurableInv G
inst✝¹ : IsMulLeftInvariant μ
inst✝ : IsMulLeftInvariant ν
sm : MeasurableSet s
f : G → ℝ≥0∞
hf : Measurable f
⊢ ↑↑μ s * ∫⁻ (y : G), f y ∂ν = ∫⁻ (x : G), ↑↑ν ((fun z => z * x) ⁻¹' s) * f x⁻¹ ∂μ
[PROOFSTEP]
rw [← set_lintegral_one, ← lintegral_indicator _ sm, ←
  lintegral_lintegral_mul (measurable_const.indicator sm).aemeasurable hf.aemeasurable, ←
  lintegral_lintegral_mul_inv μ ν]
[GOAL]
G : Type u_1
inst✝⁷ : MeasurableSpace G
inst✝⁶ : Group G
inst✝⁵ : MeasurableMul₂ G
μ ν : Measure G
inst✝⁴ : SigmaFinite ν
inst✝³ : SigmaFinite μ
s : Set G
inst✝² : MeasurableInv G
inst✝¹ : IsMulLeftInvariant μ
inst✝ : IsMulLeftInvariant ν
sm : MeasurableSet s
f : G → ℝ≥0∞
hf : Measurable f
⊢ ∫⁻ (x : G), ∫⁻ (y : G), indicator s (fun x => 1) (y * x) * f x⁻¹ ∂ν ∂μ =
    ∫⁻ (x : G), ↑↑ν ((fun z => z * x) ⁻¹' s) * f x⁻¹ ∂μ
case hf
G : Type u_1
inst✝⁷ : MeasurableSpace G
inst✝⁶ : Group G
inst✝⁵ : MeasurableMul₂ G
μ ν : Measure G
inst✝⁴ : SigmaFinite ν
inst✝³ : SigmaFinite μ
s : Set G
inst✝² : MeasurableInv G
inst✝¹ : IsMulLeftInvariant μ
inst✝ : IsMulLeftInvariant ν
sm : MeasurableSet s
f : G → ℝ≥0∞
hf : Measurable f
⊢ AEMeasurable (uncurry fun x y => indicator s (fun x => 1) x * f y)
[PROOFSTEP]
swap
[GOAL]
case hf
G : Type u_1
inst✝⁷ : MeasurableSpace G
inst✝⁶ : Group G
inst✝⁵ : MeasurableMul₂ G
μ ν : Measure G
inst✝⁴ : SigmaFinite ν
inst✝³ : SigmaFinite μ
s : Set G
inst✝² : MeasurableInv G
inst✝¹ : IsMulLeftInvariant μ
inst✝ : IsMulLeftInvariant ν
sm : MeasurableSet s
f : G → ℝ≥0∞
hf : Measurable f
⊢ AEMeasurable (uncurry fun x y => indicator s (fun x => 1) x * f y)
[PROOFSTEP]
exact (((measurable_const.indicator sm).comp measurable_fst).mul (hf.comp measurable_snd)).aemeasurable
[GOAL]
G : Type u_1
inst✝⁷ : MeasurableSpace G
inst✝⁶ : Group G
inst✝⁵ : MeasurableMul₂ G
μ ν : Measure G
inst✝⁴ : SigmaFinite ν
inst✝³ : SigmaFinite μ
s : Set G
inst✝² : MeasurableInv G
inst✝¹ : IsMulLeftInvariant μ
inst✝ : IsMulLeftInvariant ν
sm : MeasurableSet s
f : G → ℝ≥0∞
hf : Measurable f
⊢ ∫⁻ (x : G), ∫⁻ (y : G), indicator s (fun x => 1) (y * x) * f x⁻¹ ∂ν ∂μ =
    ∫⁻ (x : G), ↑↑ν ((fun z => z * x) ⁻¹' s) * f x⁻¹ ∂μ
[PROOFSTEP]
have ms : ∀ x : G, Measurable fun y => ((fun z => z * x) ⁻¹' s).indicator (fun _ => (1 : ℝ≥0∞)) y := fun x =>
  measurable_const.indicator (measurable_mul_const _ sm)
[GOAL]
G : Type u_1
inst✝⁷ : MeasurableSpace G
inst✝⁶ : Group G
inst✝⁵ : MeasurableMul₂ G
μ ν : Measure G
inst✝⁴ : SigmaFinite ν
inst✝³ : SigmaFinite μ
s : Set G
inst✝² : MeasurableInv G
inst✝¹ : IsMulLeftInvariant μ
inst✝ : IsMulLeftInvariant ν
sm : MeasurableSet s
f : G → ℝ≥0∞
hf : Measurable f
ms : ∀ (x : G), Measurable fun y => indicator ((fun z => z * x) ⁻¹' s) (fun x => 1) y
⊢ ∫⁻ (x : G), ∫⁻ (y : G), indicator s (fun x => 1) (y * x) * f x⁻¹ ∂ν ∂μ =
    ∫⁻ (x : G), ↑↑ν ((fun z => z * x) ⁻¹' s) * f x⁻¹ ∂μ
[PROOFSTEP]
have : ∀ x y, s.indicator (fun _ : G => (1 : ℝ≥0∞)) (y * x) = ((fun z => z * x) ⁻¹' s).indicator (fun b : G => 1) y :=
  by intro x y; symm; convert indicator_comp_right (M := ℝ≥0∞) fun y => y * x using 2; ext1; rfl
[GOAL]
G : Type u_1
inst✝⁷ : MeasurableSpace G
inst✝⁶ : Group G
inst✝⁵ : MeasurableMul₂ G
μ ν : Measure G
inst✝⁴ : SigmaFinite ν
inst✝³ : SigmaFinite μ
s : Set G
inst✝² : MeasurableInv G
inst✝¹ : IsMulLeftInvariant μ
inst✝ : IsMulLeftInvariant ν
sm : MeasurableSet s
f : G → ℝ≥0∞
hf : Measurable f
ms : ∀ (x : G), Measurable fun y => indicator ((fun z => z * x) ⁻¹' s) (fun x => 1) y
⊢ ∀ (x y : G), indicator s (fun x => 1) (y * x) = indicator ((fun z => z * x) ⁻¹' s) (fun b => 1) y
[PROOFSTEP]
intro x y
[GOAL]
G : Type u_1
inst✝⁷ : MeasurableSpace G
inst✝⁶ : Group G
inst✝⁵ : MeasurableMul₂ G
μ ν : Measure G
inst✝⁴ : SigmaFinite ν
inst✝³ : SigmaFinite μ
s : Set G
inst✝² : MeasurableInv G
inst✝¹ : IsMulLeftInvariant μ
inst✝ : IsMulLeftInvariant ν
sm : MeasurableSet s
f : G → ℝ≥0∞
hf : Measurable f
ms : ∀ (x : G), Measurable fun y => indicator ((fun z => z * x) ⁻¹' s) (fun x => 1) y
x y : G
⊢ indicator s (fun x => 1) (y * x) = indicator ((fun z => z * x) ⁻¹' s) (fun b => 1) y
[PROOFSTEP]
symm
[GOAL]
G : Type u_1
inst✝⁷ : MeasurableSpace G
inst✝⁶ : Group G
inst✝⁵ : MeasurableMul₂ G
μ ν : Measure G
inst✝⁴ : SigmaFinite ν
inst✝³ : SigmaFinite μ
s : Set G
inst✝² : MeasurableInv G
inst✝¹ : IsMulLeftInvariant μ
inst✝ : IsMulLeftInvariant ν
sm : MeasurableSet s
f : G → ℝ≥0∞
hf : Measurable f
ms : ∀ (x : G), Measurable fun y => indicator ((fun z => z * x) ⁻¹' s) (fun x => 1) y
x y : G
⊢ indicator ((fun z => z * x) ⁻¹' s) (fun b => 1) y = indicator s (fun x => 1) (y * x)
[PROOFSTEP]
convert indicator_comp_right (M := ℝ≥0∞) fun y => y * x using 2
[GOAL]
case h.e'_2.h.e'_5
G : Type u_1
inst✝⁷ : MeasurableSpace G
inst✝⁶ : Group G
inst✝⁵ : MeasurableMul₂ G
μ ν : Measure G
inst✝⁴ : SigmaFinite ν
inst✝³ : SigmaFinite μ
s : Set G
inst✝² : MeasurableInv G
inst✝¹ : IsMulLeftInvariant μ
inst✝ : IsMulLeftInvariant ν
sm : MeasurableSet s
f : G → ℝ≥0∞
hf : Measurable f
ms : ∀ (x : G), Measurable fun y => indicator ((fun z => z * x) ⁻¹' s) (fun x => 1) y
x y : G
⊢ (fun b => 1) = (fun x => 1) ∘ fun y => y * x
[PROOFSTEP]
ext1
[GOAL]
case h.e'_2.h.e'_5.h
G : Type u_1
inst✝⁷ : MeasurableSpace G
inst✝⁶ : Group G
inst✝⁵ : MeasurableMul₂ G
μ ν : Measure G
inst✝⁴ : SigmaFinite ν
inst✝³ : SigmaFinite μ
s : Set G
inst✝² : MeasurableInv G
inst✝¹ : IsMulLeftInvariant μ
inst✝ : IsMulLeftInvariant ν
sm : MeasurableSet s
f : G → ℝ≥0∞
hf : Measurable f
ms : ∀ (x : G), Measurable fun y => indicator ((fun z => z * x) ⁻¹' s) (fun x => 1) y
x y x✝ : G
⊢ 1 = ((fun x => 1) ∘ fun y => y * x) x✝
[PROOFSTEP]
rfl
[GOAL]
G : Type u_1
inst✝⁷ : MeasurableSpace G
inst✝⁶ : Group G
inst✝⁵ : MeasurableMul₂ G
μ ν : Measure G
inst✝⁴ : SigmaFinite ν
inst✝³ : SigmaFinite μ
s : Set G
inst✝² : MeasurableInv G
inst✝¹ : IsMulLeftInvariant μ
inst✝ : IsMulLeftInvariant ν
sm : MeasurableSet s
f : G → ℝ≥0∞
hf : Measurable f
ms : ∀ (x : G), Measurable fun y => indicator ((fun z => z * x) ⁻¹' s) (fun x => 1) y
this : ∀ (x y : G), indicator s (fun x => 1) (y * x) = indicator ((fun z => z * x) ⁻¹' s) (fun b => 1) y
⊢ ∫⁻ (x : G), ∫⁻ (y : G), indicator s (fun x => 1) (y * x) * f x⁻¹ ∂ν ∂μ =
    ∫⁻ (x : G), ↑↑ν ((fun z => z * x) ⁻¹' s) * f x⁻¹ ∂μ
[PROOFSTEP]
simp_rw [this, lintegral_mul_const _ (ms _), lintegral_indicator _ (measurable_mul_const _ sm), set_lintegral_one]
[GOAL]
G : Type u_1
inst✝⁷ : MeasurableSpace G
inst✝⁶ : Group G
inst✝⁵ : MeasurableMul₂ G
μ ν : Measure G
inst✝⁴ : SigmaFinite ν
inst✝³ : SigmaFinite μ
s : Set G
inst✝² : MeasurableInv G
inst✝¹ : IsMulLeftInvariant μ
inst✝ : IsMulLeftInvariant ν
hν : ν ≠ 0
⊢ μ ≪ ν
[PROOFSTEP]
refine' AbsolutelyContinuous.mk fun s sm hνs => _
[GOAL]
G : Type u_1
inst✝⁷ : MeasurableSpace G
inst✝⁶ : Group G
inst✝⁵ : MeasurableMul₂ G
μ ν : Measure G
inst✝⁴ : SigmaFinite ν
inst✝³ : SigmaFinite μ
s✝ : Set G
inst✝² : MeasurableInv G
inst✝¹ : IsMulLeftInvariant μ
inst✝ : IsMulLeftInvariant ν
hν : ν ≠ 0
s : Set G
sm : MeasurableSet s
hνs : ↑↑ν s = 0
⊢ ↑↑μ s = 0
[PROOFSTEP]
have h1 := measure_mul_lintegral_eq μ ν sm 1 measurable_one
[GOAL]
G : Type u_1
inst✝⁷ : MeasurableSpace G
inst✝⁶ : Group G
inst✝⁵ : MeasurableMul₂ G
μ ν : Measure G
inst✝⁴ : SigmaFinite ν
inst✝³ : SigmaFinite μ
s✝ : Set G
inst✝² : MeasurableInv G
inst✝¹ : IsMulLeftInvariant μ
inst✝ : IsMulLeftInvariant ν
hν : ν ≠ 0
s : Set G
sm : MeasurableSet s
hνs : ↑↑ν s = 0
h1 : ↑↑μ s * ∫⁻ (y : G), OfNat.ofNat 1 y ∂ν = ∫⁻ (x : G), ↑↑ν ((fun z => z * x) ⁻¹' s) * OfNat.ofNat 1 x⁻¹ ∂μ
⊢ ↑↑μ s = 0
[PROOFSTEP]
simp_rw [Pi.one_apply, lintegral_one, mul_one, (measure_mul_right_null ν _).mpr hνs, lintegral_zero,
  mul_eq_zero (M₀ := ℝ≥0∞), measure_univ_eq_zero.not.mpr hν, or_false_iff] at h1
[GOAL]
G : Type u_1
inst✝⁷ : MeasurableSpace G
inst✝⁶ : Group G
inst✝⁵ : MeasurableMul₂ G
μ ν : Measure G
inst✝⁴ : SigmaFinite ν
inst✝³ : SigmaFinite μ
s✝ : Set G
inst✝² : MeasurableInv G
inst✝¹ : IsMulLeftInvariant μ
inst✝ : IsMulLeftInvariant ν
hν : ν ≠ 0
s : Set G
sm : MeasurableSet s
hνs : ↑↑ν s = 0
h1 : ↑↑μ s = 0
⊢ ↑↑μ s = 0
[PROOFSTEP]
exact h1
[GOAL]
G : Type u_1
inst✝⁷ : MeasurableSpace G
inst✝⁶ : Group G
inst✝⁵ : MeasurableMul₂ G
μ ν : Measure G
inst✝⁴ : SigmaFinite ν
inst✝³ : SigmaFinite μ
s : Set G
inst✝² : MeasurableInv G
inst✝¹ : IsMulLeftInvariant μ
inst✝ : IsMulLeftInvariant ν
sm : MeasurableSet s
hμs : ↑↑μ s ≠ ⊤
⊢ ∀ᵐ (x : G) ∂μ, ↑↑ν ((fun y => y * x) ⁻¹' s) < ⊤
[PROOFSTEP]
refine' ae_of_forall_measure_lt_top_ae_restrict' ν.inv _ _
[GOAL]
G : Type u_1
inst✝⁷ : MeasurableSpace G
inst✝⁶ : Group G
inst✝⁵ : MeasurableMul₂ G
μ ν : Measure G
inst✝⁴ : SigmaFinite ν
inst✝³ : SigmaFinite μ
s : Set G
inst✝² : MeasurableInv G
inst✝¹ : IsMulLeftInvariant μ
inst✝ : IsMulLeftInvariant ν
sm : MeasurableSet s
hμs : ↑↑μ s ≠ ⊤
⊢ ∀ (s_1 : Set G),
    MeasurableSet s_1 →
      ↑↑μ s_1 < ⊤ → ↑↑(Measure.inv ν) s_1 < ⊤ → ∀ᵐ (x : G) ∂Measure.restrict μ s_1, ↑↑ν ((fun y => y * x) ⁻¹' s) < ⊤
[PROOFSTEP]
intro A hA _ h3A
[GOAL]
G : Type u_1
inst✝⁷ : MeasurableSpace G
inst✝⁶ : Group G
inst✝⁵ : MeasurableMul₂ G
μ ν : Measure G
inst✝⁴ : SigmaFinite ν
inst✝³ : SigmaFinite μ
s : Set G
inst✝² : MeasurableInv G
inst✝¹ : IsMulLeftInvariant μ
inst✝ : IsMulLeftInvariant ν
sm : MeasurableSet s
hμs : ↑↑μ s ≠ ⊤
A : Set G
hA : MeasurableSet A
a✝ : ↑↑μ A < ⊤
h3A : ↑↑(Measure.inv ν) A < ⊤
⊢ ∀ᵐ (x : G) ∂Measure.restrict μ A, ↑↑ν ((fun y => y * x) ⁻¹' s) < ⊤
[PROOFSTEP]
simp only [ν.inv_apply] at h3A
[GOAL]
G : Type u_1
inst✝⁷ : MeasurableSpace G
inst✝⁶ : Group G
inst✝⁵ : MeasurableMul₂ G
μ ν : Measure G
inst✝⁴ : SigmaFinite ν
inst✝³ : SigmaFinite μ
s : Set G
inst✝² : MeasurableInv G
inst✝¹ : IsMulLeftInvariant μ
inst✝ : IsMulLeftInvariant ν
sm : MeasurableSet s
hμs : ↑↑μ s ≠ ⊤
A : Set G
hA : MeasurableSet A
a✝ : ↑↑μ A < ⊤
h3A : ↑↑ν A⁻¹ < ⊤
⊢ ∀ᵐ (x : G) ∂Measure.restrict μ A, ↑↑ν ((fun y => y * x) ⁻¹' s) < ⊤
[PROOFSTEP]
apply ae_lt_top (measurable_measure_mul_right ν sm)
[GOAL]
G : Type u_1
inst✝⁷ : MeasurableSpace G
inst✝⁶ : Group G
inst✝⁵ : MeasurableMul₂ G
μ ν : Measure G
inst✝⁴ : SigmaFinite ν
inst✝³ : SigmaFinite μ
s : Set G
inst✝² : MeasurableInv G
inst✝¹ : IsMulLeftInvariant μ
inst✝ : IsMulLeftInvariant ν
sm : MeasurableSet s
hμs : ↑↑μ s ≠ ⊤
A : Set G
hA : MeasurableSet A
a✝ : ↑↑μ A < ⊤
h3A : ↑↑ν A⁻¹ < ⊤
⊢ ∫⁻ (x : G) in A, ↑↑ν ((fun y => y * x) ⁻¹' s) ∂μ ≠ ⊤
[PROOFSTEP]
have h1 := measure_mul_lintegral_eq μ ν sm (A⁻¹.indicator 1) (measurable_one.indicator hA.inv)
[GOAL]
G : Type u_1
inst✝⁷ : MeasurableSpace G
inst✝⁶ : Group G
inst✝⁵ : MeasurableMul₂ G
μ ν : Measure G
inst✝⁴ : SigmaFinite ν
inst✝³ : SigmaFinite μ
s : Set G
inst✝² : MeasurableInv G
inst✝¹ : IsMulLeftInvariant μ
inst✝ : IsMulLeftInvariant ν
sm : MeasurableSet s
hμs : ↑↑μ s ≠ ⊤
A : Set G
hA : MeasurableSet A
a✝ : ↑↑μ A < ⊤
h3A : ↑↑ν A⁻¹ < ⊤
h1 : ↑↑μ s * ∫⁻ (y : G), indicator A⁻¹ 1 y ∂ν = ∫⁻ (x : G), ↑↑ν ((fun z => z * x) ⁻¹' s) * indicator A⁻¹ 1 x⁻¹ ∂μ
⊢ ∫⁻ (x : G) in A, ↑↑ν ((fun y => y * x) ⁻¹' s) ∂μ ≠ ⊤
[PROOFSTEP]
rw [lintegral_indicator _ hA.inv] at h1
[GOAL]
G : Type u_1
inst✝⁷ : MeasurableSpace G
inst✝⁶ : Group G
inst✝⁵ : MeasurableMul₂ G
μ ν : Measure G
inst✝⁴ : SigmaFinite ν
inst✝³ : SigmaFinite μ
s : Set G
inst✝² : MeasurableInv G
inst✝¹ : IsMulLeftInvariant μ
inst✝ : IsMulLeftInvariant ν
sm : MeasurableSet s
hμs : ↑↑μ s ≠ ⊤
A : Set G
hA : MeasurableSet A
a✝ : ↑↑μ A < ⊤
h3A : ↑↑ν A⁻¹ < ⊤
h1 : ↑↑μ s * ∫⁻ (a : G) in A⁻¹, OfNat.ofNat 1 a ∂ν = ∫⁻ (x : G), ↑↑ν ((fun z => z * x) ⁻¹' s) * indicator A⁻¹ 1 x⁻¹ ∂μ
⊢ ∫⁻ (x : G) in A, ↑↑ν ((fun y => y * x) ⁻¹' s) ∂μ ≠ ⊤
[PROOFSTEP]
simp_rw [Pi.one_apply, set_lintegral_one, ← image_inv, indicator_image inv_injective, image_inv, ←
  indicator_mul_right _ fun x => ν ((fun y => y * x) ⁻¹' s), Function.comp, Pi.one_apply, mul_one] at h1
[GOAL]
G : Type u_1
inst✝⁷ : MeasurableSpace G
inst✝⁶ : Group G
inst✝⁵ : MeasurableMul₂ G
μ ν : Measure G
inst✝⁴ : SigmaFinite ν
inst✝³ : SigmaFinite μ
s : Set G
inst✝² : MeasurableInv G
inst✝¹ : IsMulLeftInvariant μ
inst✝ : IsMulLeftInvariant ν
sm : MeasurableSet s
hμs : ↑↑μ s ≠ ⊤
A : Set G
hA : MeasurableSet A
a✝ : ↑↑μ A < ⊤
h3A : ↑↑ν A⁻¹ < ⊤
h1 : ↑↑μ s * ↑↑ν A⁻¹ = ∫⁻ (x : G), indicator A (fun a => ↑↑ν ((fun y => y * a) ⁻¹' s)) x ∂μ
⊢ ∫⁻ (x : G) in A, ↑↑ν ((fun y => y * x) ⁻¹' s) ∂μ ≠ ⊤
[PROOFSTEP]
rw [← lintegral_indicator _ hA, ← h1]
[GOAL]
G : Type u_1
inst✝⁷ : MeasurableSpace G
inst✝⁶ : Group G
inst✝⁵ : MeasurableMul₂ G
μ ν : Measure G
inst✝⁴ : SigmaFinite ν
inst✝³ : SigmaFinite μ
s : Set G
inst✝² : MeasurableInv G
inst✝¹ : IsMulLeftInvariant μ
inst✝ : IsMulLeftInvariant ν
sm : MeasurableSet s
hμs : ↑↑μ s ≠ ⊤
A : Set G
hA : MeasurableSet A
a✝ : ↑↑μ A < ⊤
h3A : ↑↑ν A⁻¹ < ⊤
h1 : ↑↑μ s * ↑↑ν A⁻¹ = ∫⁻ (x : G), indicator A (fun a => ↑↑ν ((fun y => y * a) ⁻¹' s)) x ∂μ
⊢ ↑↑μ s * ↑↑ν A⁻¹ ≠ ⊤
[PROOFSTEP]
exact ENNReal.mul_ne_top hμs h3A.ne
[GOAL]
G : Type u_1
inst✝⁷ : MeasurableSpace G
inst✝⁶ : Group G
inst✝⁵ : MeasurableMul₂ G
μ ν : Measure G
inst✝⁴ : SigmaFinite ν
inst✝³ : SigmaFinite μ
s : Set G
inst✝² : MeasurableInv G
inst✝¹ : IsMulLeftInvariant μ
inst✝ : IsMulLeftInvariant ν
sm : MeasurableSet s
h2s : ↑↑ν s ≠ 0
h3s : ↑↑ν s ≠ ⊤
⊢ ∀ᵐ (x : G) ∂μ, ↑↑ν ((fun y => y * x) ⁻¹' s) < ⊤
[PROOFSTEP]
refine' (ae_measure_preimage_mul_right_lt_top ν ν sm h3s).filter_mono _
[GOAL]
G : Type u_1
inst✝⁷ : MeasurableSpace G
inst✝⁶ : Group G
inst✝⁵ : MeasurableMul₂ G
μ ν : Measure G
inst✝⁴ : SigmaFinite ν
inst✝³ : SigmaFinite μ
s : Set G
inst✝² : MeasurableInv G
inst✝¹ : IsMulLeftInvariant μ
inst✝ : IsMulLeftInvariant ν
sm : MeasurableSet s
h2s : ↑↑ν s ≠ 0
h3s : ↑↑ν s ≠ ⊤
⊢ ae μ ≤ ae ν
[PROOFSTEP]
refine' (absolutelyContinuous_of_isMulLeftInvariant μ ν _).ae_le
[GOAL]
G : Type u_1
inst✝⁷ : MeasurableSpace G
inst✝⁶ : Group G
inst✝⁵ : MeasurableMul₂ G
μ ν : Measure G
inst✝⁴ : SigmaFinite ν
inst✝³ : SigmaFinite μ
s : Set G
inst✝² : MeasurableInv G
inst✝¹ : IsMulLeftInvariant μ
inst✝ : IsMulLeftInvariant ν
sm : MeasurableSet s
h2s : ↑↑ν s ≠ 0
h3s : ↑↑ν s ≠ ⊤
⊢ ν ≠ 0
[PROOFSTEP]
refine' mt _ h2s
[GOAL]
G : Type u_1
inst✝⁷ : MeasurableSpace G
inst✝⁶ : Group G
inst✝⁵ : MeasurableMul₂ G
μ ν : Measure G
inst✝⁴ : SigmaFinite ν
inst✝³ : SigmaFinite μ
s : Set G
inst✝² : MeasurableInv G
inst✝¹ : IsMulLeftInvariant μ
inst✝ : IsMulLeftInvariant ν
sm : MeasurableSet s
h2s : ↑↑ν s ≠ 0
h3s : ↑↑ν s ≠ ⊤
⊢ ν = 0 → ↑↑ν s = 0
[PROOFSTEP]
intro hν
[GOAL]
G : Type u_1
inst✝⁷ : MeasurableSpace G
inst✝⁶ : Group G
inst✝⁵ : MeasurableMul₂ G
μ ν : Measure G
inst✝⁴ : SigmaFinite ν
inst✝³ : SigmaFinite μ
s : Set G
inst✝² : MeasurableInv G
inst✝¹ : IsMulLeftInvariant μ
inst✝ : IsMulLeftInvariant ν
sm : MeasurableSet s
h2s : ↑↑ν s ≠ 0
h3s : ↑↑ν s ≠ ⊤
hν : ν = 0
⊢ ↑↑ν s = 0
[PROOFSTEP]
rw [hν, Measure.coe_zero, Pi.zero_apply]
[GOAL]
G : Type u_1
inst✝⁷ : MeasurableSpace G
inst✝⁶ : Group G
inst✝⁵ : MeasurableMul₂ G
μ ν : Measure G
inst✝⁴ : SigmaFinite ν
inst✝³ : SigmaFinite μ
s : Set G
inst✝² : MeasurableInv G
inst✝¹ : IsMulLeftInvariant μ
inst✝ : IsMulLeftInvariant ν
sm : MeasurableSet s
h2s : ↑↑ν s ≠ 0
h3s : ↑↑ν s ≠ ⊤
f : G → ℝ≥0∞
hf : Measurable f
⊢ ↑↑μ s * ∫⁻ (y : G), f y⁻¹ / ↑↑ν ((fun x => x * y⁻¹) ⁻¹' s) ∂ν = ∫⁻ (x : G), f x ∂μ
[PROOFSTEP]
set g := fun y => f y⁻¹ / ν ((fun x => x * y⁻¹) ⁻¹' s)
[GOAL]
G : Type u_1
inst✝⁷ : MeasurableSpace G
inst✝⁶ : Group G
inst✝⁵ : MeasurableMul₂ G
μ ν : Measure G
inst✝⁴ : SigmaFinite ν
inst✝³ : SigmaFinite μ
s : Set G
inst✝² : MeasurableInv G
inst✝¹ : IsMulLeftInvariant μ
inst✝ : IsMulLeftInvariant ν
sm : MeasurableSet s
h2s : ↑↑ν s ≠ 0
h3s : ↑↑ν s ≠ ⊤
f : G → ℝ≥0∞
hf : Measurable f
g : G → ℝ≥0∞ := fun y => f y⁻¹ / ↑↑ν ((fun x => x * y⁻¹) ⁻¹' s)
⊢ ↑↑μ s * lintegral ν g = ∫⁻ (x : G), f x ∂μ
[PROOFSTEP]
have hg : Measurable g := (hf.comp measurable_inv).div ((measurable_measure_mul_right ν sm).comp measurable_inv)
[GOAL]
G : Type u_1
inst✝⁷ : MeasurableSpace G
inst✝⁶ : Group G
inst✝⁵ : MeasurableMul₂ G
μ ν : Measure G
inst✝⁴ : SigmaFinite ν
inst✝³ : SigmaFinite μ
s : Set G
inst✝² : MeasurableInv G
inst✝¹ : IsMulLeftInvariant μ
inst✝ : IsMulLeftInvariant ν
sm : MeasurableSet s
h2s : ↑↑ν s ≠ 0
h3s : ↑↑ν s ≠ ⊤
f : G → ℝ≥0∞
hf : Measurable f
g : G → ℝ≥0∞ := fun y => f y⁻¹ / ↑↑ν ((fun x => x * y⁻¹) ⁻¹' s)
hg : Measurable g
⊢ ↑↑μ s * lintegral ν g = ∫⁻ (x : G), f x ∂μ
[PROOFSTEP]
simp_rw [measure_mul_lintegral_eq μ ν sm g hg, inv_inv]
[GOAL]
G : Type u_1
inst✝⁷ : MeasurableSpace G
inst✝⁶ : Group G
inst✝⁵ : MeasurableMul₂ G
μ ν : Measure G
inst✝⁴ : SigmaFinite ν
inst✝³ : SigmaFinite μ
s : Set G
inst✝² : MeasurableInv G
inst✝¹ : IsMulLeftInvariant μ
inst✝ : IsMulLeftInvariant ν
sm : MeasurableSet s
h2s : ↑↑ν s ≠ 0
h3s : ↑↑ν s ≠ ⊤
f : G → ℝ≥0∞
hf : Measurable f
g : G → ℝ≥0∞ := fun y => f y⁻¹ / ↑↑ν ((fun x => x * y⁻¹) ⁻¹' s)
hg : Measurable g
⊢ ∫⁻ (x : G), ↑↑ν ((fun z => z * x) ⁻¹' s) * (f x / ↑↑ν ((fun z => z * x) ⁻¹' s)) ∂μ = ∫⁻ (x : G), f x ∂μ
[PROOFSTEP]
refine' lintegral_congr_ae _
[GOAL]
G : Type u_1
inst✝⁷ : MeasurableSpace G
inst✝⁶ : Group G
inst✝⁵ : MeasurableMul₂ G
μ ν : Measure G
inst✝⁴ : SigmaFinite ν
inst✝³ : SigmaFinite μ
s : Set G
inst✝² : MeasurableInv G
inst✝¹ : IsMulLeftInvariant μ
inst✝ : IsMulLeftInvariant ν
sm : MeasurableSet s
h2s : ↑↑ν s ≠ 0
h3s : ↑↑ν s ≠ ⊤
f : G → ℝ≥0∞
hf : Measurable f
g : G → ℝ≥0∞ := fun y => f y⁻¹ / ↑↑ν ((fun x => x * y⁻¹) ⁻¹' s)
hg : Measurable g
⊢ (fun x => ↑↑ν ((fun z => z * x) ⁻¹' s) * (f x / ↑↑ν ((fun z => z * x) ⁻¹' s))) =ᶠ[ae μ] fun x => f x
[PROOFSTEP]
refine' (ae_measure_preimage_mul_right_lt_top_of_ne_zero μ ν sm h2s h3s).mono fun x hx => _
[GOAL]
G : Type u_1
inst✝⁷ : MeasurableSpace G
inst✝⁶ : Group G
inst✝⁵ : MeasurableMul₂ G
μ ν : Measure G
inst✝⁴ : SigmaFinite ν
inst✝³ : SigmaFinite μ
s : Set G
inst✝² : MeasurableInv G
inst✝¹ : IsMulLeftInvariant μ
inst✝ : IsMulLeftInvariant ν
sm : MeasurableSet s
h2s : ↑↑ν s ≠ 0
h3s : ↑↑ν s ≠ ⊤
f : G → ℝ≥0∞
hf : Measurable f
g : G → ℝ≥0∞ := fun y => f y⁻¹ / ↑↑ν ((fun x => x * y⁻¹) ⁻¹' s)
hg : Measurable g
x : G
hx : ↑↑ν ((fun y => y * x) ⁻¹' s) < ⊤
⊢ (fun x => ↑↑ν ((fun z => z * x) ⁻¹' s) * (f x / ↑↑ν ((fun z => z * x) ⁻¹' s))) x = (fun x => f x) x
[PROOFSTEP]
simp_rw [ENNReal.mul_div_cancel' (measure_mul_right_ne_zero ν h2s _) hx.ne]
[GOAL]
G : Type u_1
inst✝⁷ : MeasurableSpace G
inst✝⁶ : Group G
inst✝⁵ : MeasurableMul₂ G
μ ν : Measure G
inst✝⁴ : SigmaFinite ν
inst✝³ : SigmaFinite μ
s✝ : Set G
inst✝² : MeasurableInv G
inst✝¹ : IsMulLeftInvariant μ
inst✝ : IsMulLeftInvariant ν
s t : Set G
hs : MeasurableSet s
ht : MeasurableSet t
h2s : ↑↑ν s ≠ 0
h3s : ↑↑ν s ≠ ⊤
⊢ ↑↑μ s * ↑↑ν t = ↑↑ν s * ↑↑μ t
[PROOFSTEP]
have h1 := measure_lintegral_div_measure ν ν hs h2s h3s (t.indicator fun _ => 1) (measurable_const.indicator ht)
[GOAL]
G : Type u_1
inst✝⁷ : MeasurableSpace G
inst✝⁶ : Group G
inst✝⁵ : MeasurableMul₂ G
μ ν : Measure G
inst✝⁴ : SigmaFinite ν
inst✝³ : SigmaFinite μ
s✝ : Set G
inst✝² : MeasurableInv G
inst✝¹ : IsMulLeftInvariant μ
inst✝ : IsMulLeftInvariant ν
s t : Set G
hs : MeasurableSet s
ht : MeasurableSet t
h2s : ↑↑ν s ≠ 0
h3s : ↑↑ν s ≠ ⊤
h1 :
  ↑↑ν s * ∫⁻ (y : G), indicator t (fun x => 1) y⁻¹ / ↑↑ν ((fun x => x * y⁻¹) ⁻¹' s) ∂ν =
    ∫⁻ (x : G), indicator t (fun x => 1) x ∂ν
⊢ ↑↑μ s * ↑↑ν t = ↑↑ν s * ↑↑μ t
[PROOFSTEP]
have h2 := measure_lintegral_div_measure μ ν hs h2s h3s (t.indicator fun _ => 1) (measurable_const.indicator ht)
[GOAL]
G : Type u_1
inst✝⁷ : MeasurableSpace G
inst✝⁶ : Group G
inst✝⁵ : MeasurableMul₂ G
μ ν : Measure G
inst✝⁴ : SigmaFinite ν
inst✝³ : SigmaFinite μ
s✝ : Set G
inst✝² : MeasurableInv G
inst✝¹ : IsMulLeftInvariant μ
inst✝ : IsMulLeftInvariant ν
s t : Set G
hs : MeasurableSet s
ht : MeasurableSet t
h2s : ↑↑ν s ≠ 0
h3s : ↑↑ν s ≠ ⊤
h1 :
  ↑↑ν s * ∫⁻ (y : G), indicator t (fun x => 1) y⁻¹ / ↑↑ν ((fun x => x * y⁻¹) ⁻¹' s) ∂ν =
    ∫⁻ (x : G), indicator t (fun x => 1) x ∂ν
h2 :
  ↑↑μ s * ∫⁻ (y : G), indicator t (fun x => 1) y⁻¹ / ↑↑ν ((fun x => x * y⁻¹) ⁻¹' s) ∂ν =
    ∫⁻ (x : G), indicator t (fun x => 1) x ∂μ
⊢ ↑↑μ s * ↑↑ν t = ↑↑ν s * ↑↑μ t
[PROOFSTEP]
rw [lintegral_indicator _ ht, set_lintegral_one] at h1 h2
[GOAL]
G : Type u_1
inst✝⁷ : MeasurableSpace G
inst✝⁶ : Group G
inst✝⁵ : MeasurableMul₂ G
μ ν : Measure G
inst✝⁴ : SigmaFinite ν
inst✝³ : SigmaFinite μ
s✝ : Set G
inst✝² : MeasurableInv G
inst✝¹ : IsMulLeftInvariant μ
inst✝ : IsMulLeftInvariant ν
s t : Set G
hs : MeasurableSet s
ht : MeasurableSet t
h2s : ↑↑ν s ≠ 0
h3s : ↑↑ν s ≠ ⊤
h1 : ↑↑ν s * ∫⁻ (y : G), indicator t (fun x => 1) y⁻¹ / ↑↑ν ((fun x => x * y⁻¹) ⁻¹' s) ∂ν = ↑↑ν t
h2 : ↑↑μ s * ∫⁻ (y : G), indicator t (fun x => 1) y⁻¹ / ↑↑ν ((fun x => x * y⁻¹) ⁻¹' s) ∂ν = ↑↑μ t
⊢ ↑↑μ s * ↑↑ν t = ↑↑ν s * ↑↑μ t
[PROOFSTEP]
rw [← h1, mul_left_comm, h2]
[GOAL]
G : Type u_1
inst✝⁷ : MeasurableSpace G
inst✝⁶ : Group G
inst✝⁵ : MeasurableMul₂ G
μ ν : Measure G
inst✝⁴ : SigmaFinite ν
inst✝³ : SigmaFinite μ
s : Set G
inst✝² : MeasurableInv G
inst✝¹ : IsMulLeftInvariant μ
inst✝ : IsMulLeftInvariant ν
hs : MeasurableSet s
h2s : ↑↑ν s ≠ 0
h3s : ↑↑ν s ≠ ⊤
⊢ μ = (↑↑μ s / ↑↑ν s) • ν
[PROOFSTEP]
ext1 t ht
[GOAL]
case h
G : Type u_1
inst✝⁷ : MeasurableSpace G
inst✝⁶ : Group G
inst✝⁵ : MeasurableMul₂ G
μ ν : Measure G
inst✝⁴ : SigmaFinite ν
inst✝³ : SigmaFinite μ
s : Set G
inst✝² : MeasurableInv G
inst✝¹ : IsMulLeftInvariant μ
inst✝ : IsMulLeftInvariant ν
hs : MeasurableSet s
h2s : ↑↑ν s ≠ 0
h3s : ↑↑ν s ≠ ⊤
t : Set G
ht : MeasurableSet t
⊢ ↑↑μ t = ↑↑((↑↑μ s / ↑↑ν s) • ν) t
[PROOFSTEP]
rw [smul_apply, smul_eq_mul, mul_comm, ← mul_div_assoc, mul_comm, measure_mul_measure_eq μ ν hs ht h2s h3s,
  mul_div_assoc, ENNReal.mul_div_cancel' h2s h3s]
[GOAL]
G : Type u_1
inst✝⁵ : MeasurableSpace G
inst✝⁴ : Group G
inst✝³ : MeasurableMul₂ G
μ ν : Measure G
inst✝² : SigmaFinite ν
inst✝¹ : SigmaFinite μ
s : Set G
inst✝ : IsMulRightInvariant μ
⊢ MeasurePreserving ?m.111352
[PROOFSTEP]
apply measurePreserving_prod_mul_swap_right μ ν
[GOAL]
G : Type u_1
inst✝⁶ : MeasurableSpace G
inst✝⁵ : Group G
inst✝⁴ : MeasurableMul₂ G
μ ν : Measure G
inst✝³ : SigmaFinite ν
inst✝² : SigmaFinite μ
s : Set G
inst✝¹ : MeasurableInv G
inst✝ : IsMulRightInvariant μ
⊢ MeasurePreserving ?m.118254
[PROOFSTEP]
apply measurePreserving_prod_div_swap μ ν
[GOAL]
G : Type u_1
inst✝⁷ : MeasurableSpace G
inst✝⁶ : Group G
inst✝⁵ : MeasurableMul₂ G
μ ν : Measure G
inst✝⁴ : SigmaFinite ν
inst✝³ : SigmaFinite μ
s : Set G
inst✝² : MeasurableInv G
inst✝¹ : IsMulRightInvariant μ
inst✝ : IsMulRightInvariant ν
⊢ MeasurePreserving fun z => (z.fst * z.snd, z.fst⁻¹)
[PROOFSTEP]
convert (measurePreserving_prod_div_swap ν μ).comp (measurePreserving_prod_mul_swap_right μ ν) using 1
[GOAL]
case h.e'_5
G : Type u_1
inst✝⁷ : MeasurableSpace G
inst✝⁶ : Group G
inst✝⁵ : MeasurableMul₂ G
μ ν : Measure G
inst✝⁴ : SigmaFinite ν
inst✝³ : SigmaFinite μ
s : Set G
inst✝² : MeasurableInv G
inst✝¹ : IsMulRightInvariant μ
inst✝ : IsMulRightInvariant ν
⊢ (fun z => (z.fst * z.snd, z.fst⁻¹)) = (fun z => (z.snd, z.fst / z.snd)) ∘ fun z => (z.snd, z.fst * z.snd)
[PROOFSTEP]
ext1 ⟨x, y⟩
[GOAL]
case h.e'_5.h.mk
G : Type u_1
inst✝⁷ : MeasurableSpace G
inst✝⁶ : Group G
inst✝⁵ : MeasurableMul₂ G
μ ν : Measure G
inst✝⁴ : SigmaFinite ν
inst✝³ : SigmaFinite μ
s : Set G
inst✝² : MeasurableInv G
inst✝¹ : IsMulRightInvariant μ
inst✝ : IsMulRightInvariant ν
x y : G
⊢ ((x, y).fst * (x, y).snd, (x, y).fst⁻¹) = ((fun z => (z.snd, z.fst / z.snd)) ∘ fun z => (z.snd, z.fst * z.snd)) (x, y)
[PROOFSTEP]
simp_rw [Function.comp_apply, div_mul_eq_div_div_swap, div_self', one_div]
[GOAL]
G : Type u_1
inst✝⁶ : MeasurableSpace G
inst✝⁵ : Group G
inst✝⁴ : MeasurableMul₂ G
μ ν : Measure G
inst✝³ : SigmaFinite ν
inst✝² : SigmaFinite μ
s : Set G
inst✝¹ : MeasurableInv G
inst✝ : IsMulRightInvariant μ
⊢ QuasiMeasurePreserving Inv.inv
[PROOFSTEP]
rw [← μ.inv_inv]
[GOAL]
G : Type u_1
inst✝⁶ : MeasurableSpace G
inst✝⁵ : Group G
inst✝⁴ : MeasurableMul₂ G
μ ν : Measure G
inst✝³ : SigmaFinite ν
inst✝² : SigmaFinite μ
s : Set G
inst✝¹ : MeasurableInv G
inst✝ : IsMulRightInvariant μ
⊢ QuasiMeasurePreserving Inv.inv
[PROOFSTEP]
exact (quasiMeasurePreserving_inv μ.inv).mono (inv_absolutelyContinuous μ.inv) (absolutelyContinuous_inv μ.inv)
[GOAL]
G : Type u_1
inst✝⁶ : MeasurableSpace G
inst✝⁵ : Group G
inst✝⁴ : MeasurableMul₂ G
μ ν : Measure G
inst✝³ : SigmaFinite ν
inst✝² : SigmaFinite μ
s : Set G
inst✝¹ : MeasurableInv G
inst✝ : IsMulLeftInvariant μ
g : G
⊢ QuasiMeasurePreserving fun h => g / h
[PROOFSTEP]
simp_rw [div_eq_mul_inv]
[GOAL]
G : Type u_1
inst✝⁶ : MeasurableSpace G
inst✝⁵ : Group G
inst✝⁴ : MeasurableMul₂ G
μ ν : Measure G
inst✝³ : SigmaFinite ν
inst✝² : SigmaFinite μ
s : Set G
inst✝¹ : MeasurableInv G
inst✝ : IsMulLeftInvariant μ
g : G
⊢ QuasiMeasurePreserving fun h => g * h⁻¹
[PROOFSTEP]
exact (measurePreserving_mul_left μ g).quasiMeasurePreserving.comp (quasiMeasurePreserving_inv μ)
[GOAL]
G : Type u_1
inst✝⁶ : MeasurableSpace G
inst✝⁵ : Group G
inst✝⁴ : MeasurableMul₂ G
μ ν : Measure G
inst✝³ : SigmaFinite ν
inst✝² : SigmaFinite μ
s : Set G
inst✝¹ : MeasurableInv G
inst✝ : IsMulRightInvariant μ
g : G
⊢ QuasiMeasurePreserving fun h => g / h
[PROOFSTEP]
rw [← μ.inv_inv]
[GOAL]
G : Type u_1
inst✝⁶ : MeasurableSpace G
inst✝⁵ : Group G
inst✝⁴ : MeasurableMul₂ G
μ ν : Measure G
inst✝³ : SigmaFinite ν
inst✝² : SigmaFinite μ
s : Set G
inst✝¹ : MeasurableInv G
inst✝ : IsMulRightInvariant μ
g : G
⊢ QuasiMeasurePreserving fun h => g / h
[PROOFSTEP]
exact (quasiMeasurePreserving_div_left μ.inv g).mono (inv_absolutelyContinuous μ.inv) (absolutelyContinuous_inv μ.inv)
[GOAL]
G : Type u_1
inst✝⁶ : MeasurableSpace G
inst✝⁵ : Group G
inst✝⁴ : MeasurableMul₂ G
μ ν : Measure G
inst✝³ : SigmaFinite ν
inst✝² : SigmaFinite μ
s : Set G
inst✝¹ : MeasurableInv G
inst✝ : IsMulRightInvariant μ
⊢ QuasiMeasurePreserving fun p => p.fst / p.snd
[PROOFSTEP]
refine' QuasiMeasurePreserving.prod_of_left measurable_div (eventually_of_forall fun y => _)
[GOAL]
G : Type u_1
inst✝⁶ : MeasurableSpace G
inst✝⁵ : Group G
inst✝⁴ : MeasurableMul₂ G
μ ν : Measure G
inst✝³ : SigmaFinite ν
inst✝² : SigmaFinite μ
s : Set G
inst✝¹ : MeasurableInv G
inst✝ : IsMulRightInvariant μ
y : G
⊢ QuasiMeasurePreserving fun x => (x, y).fst / (x, y).snd
[PROOFSTEP]
exact (measurePreserving_div_right μ y).quasiMeasurePreserving
[GOAL]
G : Type u_1
inst✝⁶ : MeasurableSpace G
inst✝⁵ : Group G
inst✝⁴ : MeasurableMul₂ G
μ ν : Measure G
inst✝³ : SigmaFinite ν
inst✝² : SigmaFinite μ
s : Set G
inst✝¹ : MeasurableInv G
inst✝ : IsMulLeftInvariant μ
g : G
⊢ QuasiMeasurePreserving fun h => h * g
[PROOFSTEP]
refine' ⟨measurable_mul_const g, AbsolutelyContinuous.mk fun s hs => _⟩
[GOAL]
G : Type u_1
inst✝⁶ : MeasurableSpace G
inst✝⁵ : Group G
inst✝⁴ : MeasurableMul₂ G
μ ν : Measure G
inst✝³ : SigmaFinite ν
inst✝² : SigmaFinite μ
s✝ : Set G
inst✝¹ : MeasurableInv G
inst✝ : IsMulLeftInvariant μ
g : G
s : Set G
hs : MeasurableSet s
⊢ ↑↑μ s = 0 → ↑↑(map (fun h => h * g) μ) s = 0
[PROOFSTEP]
rw [map_apply (measurable_mul_const g) hs, measure_mul_right_null]
[GOAL]
G : Type u_1
inst✝⁶ : MeasurableSpace G
inst✝⁵ : Group G
inst✝⁴ : MeasurableMul₂ G
μ ν : Measure G
inst✝³ : SigmaFinite ν
inst✝² : SigmaFinite μ
s✝ : Set G
inst✝¹ : MeasurableInv G
inst✝ : IsMulLeftInvariant μ
g : G
s : Set G
hs : MeasurableSet s
⊢ ↑↑μ s = 0 → ↑↑μ s = 0
[PROOFSTEP]
exact id
[GOAL]
G : Type u_1
inst✝⁶ : MeasurableSpace G
inst✝⁵ : Group G
inst✝⁴ : MeasurableMul₂ G
μ ν : Measure G
inst✝³ : SigmaFinite ν
inst✝² : SigmaFinite μ
s : Set G
inst✝¹ : MeasurableInv G
inst✝ : IsMulRightInvariant μ
g : G
⊢ QuasiMeasurePreserving fun h => g * h
[PROOFSTEP]
have :=
  (quasiMeasurePreserving_mul_right μ.inv g⁻¹).mono (inv_absolutelyContinuous μ.inv) (absolutelyContinuous_inv μ.inv)
[GOAL]
G : Type u_1
inst✝⁶ : MeasurableSpace G
inst✝⁵ : Group G
inst✝⁴ : MeasurableMul₂ G
μ ν : Measure G
inst✝³ : SigmaFinite ν
inst✝² : SigmaFinite μ
s : Set G
inst✝¹ : MeasurableInv G
inst✝ : IsMulRightInvariant μ
g : G
this : QuasiMeasurePreserving fun h => h * g⁻¹
⊢ QuasiMeasurePreserving fun h => g * h
[PROOFSTEP]
rw [μ.inv_inv] at this
[GOAL]
G : Type u_1
inst✝⁶ : MeasurableSpace G
inst✝⁵ : Group G
inst✝⁴ : MeasurableMul₂ G
μ ν : Measure G
inst✝³ : SigmaFinite ν
inst✝² : SigmaFinite μ
s : Set G
inst✝¹ : MeasurableInv G
inst✝ : IsMulRightInvariant μ
g : G
this : QuasiMeasurePreserving fun h => h * g⁻¹
⊢ QuasiMeasurePreserving fun h => g * h
[PROOFSTEP]
have :=
  (quasiMeasurePreserving_inv_of_right_invariant μ).comp (this.comp (quasiMeasurePreserving_inv_of_right_invariant μ))
[GOAL]
G : Type u_1
inst✝⁶ : MeasurableSpace G
inst✝⁵ : Group G
inst✝⁴ : MeasurableMul₂ G
μ ν : Measure G
inst✝³ : SigmaFinite ν
inst✝² : SigmaFinite μ
s : Set G
inst✝¹ : MeasurableInv G
inst✝ : IsMulRightInvariant μ
g : G
this✝ : QuasiMeasurePreserving fun h => h * g⁻¹
this : QuasiMeasurePreserving (Inv.inv ∘ (fun h => h * g⁻¹) ∘ Inv.inv)
⊢ QuasiMeasurePreserving fun h => g * h
[PROOFSTEP]
simp_rw [Function.comp, mul_inv_rev, inv_inv] at this
[GOAL]
G : Type u_1
inst✝⁶ : MeasurableSpace G
inst✝⁵ : Group G
inst✝⁴ : MeasurableMul₂ G
μ ν : Measure G
inst✝³ : SigmaFinite ν
inst✝² : SigmaFinite μ
s : Set G
inst✝¹ : MeasurableInv G
inst✝ : IsMulRightInvariant μ
g : G
this✝ : QuasiMeasurePreserving fun h => h * g⁻¹
this : QuasiMeasurePreserving fun x => g * x
⊢ QuasiMeasurePreserving fun h => g * h
[PROOFSTEP]
exact this