[GOAL]
α : Type u
β : Type v
γ : Type w
inst✝² : UniformSpace α
inst✝¹ : UniformSpace β
inst✝ : UniformSpace γ
a : α
⊢ HasBasis (𝓝 a) (?m.55 a) (?m.56 a)
[PROOFSTEP]
rw [nhds_eq_comap_uniformity]
[GOAL]
α : Type u
β : Type v
γ : Type w
inst✝² : UniformSpace α
inst✝¹ : UniformSpace β
inst✝ : UniformSpace γ
a : α
⊢ HasBasis (Filter.comap (Prod.mk a) (𝓤 α)) (?m.55 a) (?m.56 a)
α : Type u
β : Type v
γ : Type w
inst✝² : UniformSpace α
inst✝¹ : UniformSpace β
inst✝ : UniformSpace γ
⊢ α → Sort ?u.51
α : Type u
β : Type v
γ : Type w
inst✝² : UniformSpace α
inst✝¹ : UniformSpace β
inst✝ : UniformSpace γ
⊢ (a : α) → ?m.54 a → Prop
α : Type u
β : Type v
γ : Type w
inst✝² : UniformSpace α
inst✝¹ : UniformSpace β
inst✝ : UniformSpace γ
⊢ (a : α) → ?m.54 a → Set α
[PROOFSTEP]
exact uniformity_hasBasis_closed.comap _
[GOAL]
α : Type u
β : Type v
γ : Type w
inst✝² : UniformSpace α
inst✝¹ : UniformSpace β
inst✝ : UniformSpace γ
a : α
V : Set (α × α)
hV : V ∈ 𝓤 α ∧ IsClosed V
⊢ IsClosed (Prod.mk a ⁻¹' id V)
[PROOFSTEP]
exact hV.2.preimage <| continuous_const.prod_mk continuous_id
[GOAL]
α : Type u
β : Type v
γ : Type w
inst✝² : UniformSpace α
inst✝¹ : UniformSpace β
inst✝ : UniformSpace γ
a b : α
⊢ (a, b) ∈ 𝓢 α ↔ a ⤳ b
[PROOFSTEP]
simp only [(𝓤 α).basis_sets.mem_separationRel, id, mem_setOf_eq,
  (nhds_basis_uniformity (𝓤 α).basis_sets).specializes_iff]
[GOAL]
α✝ : Type u
β : Type v
γ : Type w
inst✝³ : UniformSpace α✝
inst✝² : UniformSpace β
inst✝¹ : UniformSpace γ
α : Type u
inst✝ : UniformSpace α
⊢ SeparatedSpace α ↔ ∀ (x y : α), (∀ (r : Set (α × α)), r ∈ 𝓤 α → (x, y) ∈ r) → x = y
[PROOFSTEP]
simp only [separatedSpace_iff, Set.ext_iff, Prod.forall, mem_idRel, separationRel, mem_sInter]
[GOAL]
α✝ : Type u
β : Type v
γ : Type w
inst✝³ : UniformSpace α✝
inst✝² : UniformSpace β
inst✝¹ : UniformSpace γ
α : Type u
inst✝ : UniformSpace α
⊢ (∀ (a b : α), (∀ (t : Set (α × α)), t ∈ (𝓤 α).sets → (a, b) ∈ t) ↔ a = b) ↔
    ∀ (x y : α), (∀ (r : Set (α × α)), r ∈ 𝓤 α → (x, y) ∈ r) → x = y
[PROOFSTEP]
exact forall₂_congr fun _ _ => ⟨Iff.mp, fun h => ⟨h, fun H U hU => H ▸ refl_mem_uniformity hU⟩⟩
[GOAL]
α✝ : Type u
β : Type v
γ : Type w
inst✝³ : UniformSpace α✝
inst✝² : UniformSpace β
inst✝¹ : UniformSpace γ
α : Type u
inst✝ : UniformSpace α
x y : α
⊢ (∀ (r : Set (α × α)), r ∈ 𝓤 α → (x, y) ∈ r) → x = y ↔ x ≠ y → ∃ r, r ∈ 𝓤 α ∧ ¬(x, y) ∈ r
[PROOFSTEP]
rw [← not_imp_not]
[GOAL]
α✝ : Type u
β : Type v
γ : Type w
inst✝³ : UniformSpace α✝
inst✝² : UniformSpace β
inst✝¹ : UniformSpace γ
α : Type u
inst✝ : UniformSpace α
x y : α
⊢ (¬x = y → ¬∀ (r : Set (α × α)), r ∈ 𝓤 α → (x, y) ∈ r) ↔ x ≠ y → ∃ r, r ∈ 𝓤 α ∧ ¬(x, y) ∈ r
[PROOFSTEP]
simp [not_forall]
[GOAL]
α✝ : Type u
β : Type v
γ : Type w
inst✝⁴ : UniformSpace α✝
inst✝³ : UniformSpace β
inst✝² : UniformSpace γ
α : Type u_1
inst✝¹ : UniformSpace α
inst✝ : SeparatedSpace α
x y : α
h : ∀ {V : Set (α × α)}, V ∈ 𝓤 α → SymmetricRel V → (x, y) ∈ V
⊢ ∀ {i : Set (α × α)}, i ∈ 𝓤 α ∧ SymmetricRel i → (x, y) ∈ id i
[PROOFSTEP]
simpa [and_imp]
[GOAL]
α✝ : Type u
β : Type v
γ : Type w
inst✝³ : UniformSpace α✝
inst✝² : UniformSpace β
inst✝¹ : UniformSpace γ
α : Type u_1
inst✝ : UniformSpace α
⊢ idRel ⊆ 𝓢 α
[PROOFSTEP]
unfold separationRel
[GOAL]
α✝ : Type u
β : Type v
γ : Type w
inst✝³ : UniformSpace α✝
inst✝² : UniformSpace β
inst✝¹ : UniformSpace γ
α : Type u_1
inst✝ : UniformSpace α
⊢ idRel ⊆ ⋂₀ (𝓤 α).sets
[PROOFSTEP]
rw [idRel_subset]
[GOAL]
α✝ : Type u
β : Type v
γ : Type w
inst✝³ : UniformSpace α✝
inst✝² : UniformSpace β
inst✝¹ : UniformSpace γ
α : Type u_1
inst✝ : UniformSpace α
⊢ ∀ (a : α), (a, a) ∈ ⋂₀ (𝓤 α).sets
[PROOFSTEP]
intro x
[GOAL]
α✝ : Type u
β : Type v
γ : Type w
inst✝³ : UniformSpace α✝
inst✝² : UniformSpace β
inst✝¹ : UniformSpace γ
α : Type u_1
inst✝ : UniformSpace α
x : α
⊢ (x, x) ∈ ⋂₀ (𝓤 α).sets
[PROOFSTEP]
suffices ∀ t ∈ 𝓤 α, (x, x) ∈ t by simpa only [refl_mem_uniformity]
[GOAL]
α✝ : Type u
β : Type v
γ : Type w
inst✝³ : UniformSpace α✝
inst✝² : UniformSpace β
inst✝¹ : UniformSpace γ
α : Type u_1
inst✝ : UniformSpace α
x : α
this : ∀ (t : Set (α × α)), t ∈ 𝓤 α → (x, x) ∈ t
⊢ (x, x) ∈ ⋂₀ (𝓤 α).sets
[PROOFSTEP]
simpa only [refl_mem_uniformity]
[GOAL]
α✝ : Type u
β : Type v
γ : Type w
inst✝³ : UniformSpace α✝
inst✝² : UniformSpace β
inst✝¹ : UniformSpace γ
α : Type u_1
inst✝ : UniformSpace α
x : α
⊢ ∀ (t : Set (α × α)), t ∈ 𝓤 α → (x, x) ∈ t
[PROOFSTEP]
exact fun t => refl_mem_uniformity
[GOAL]
α : Type u
β : Type v
γ : Type w
inst✝² : UniformSpace α
inst✝¹ : UniformSpace β
inst✝ : UniformSpace γ
f : α → β
h : inst✝² = UniformSpace.comap f inst✝¹
⊢ 𝓢 α = Prod.map f f ⁻¹' 𝓢 β
[PROOFSTEP]
subst h
[GOAL]
α : Type u
β : Type v
γ : Type w
inst✝¹ : UniformSpace β
inst✝ : UniformSpace γ
f : α → β
⊢ 𝓢 α = Prod.map f f ⁻¹' 𝓢 β
[PROOFSTEP]
dsimp [separationRel]
[GOAL]
α : Type u
β : Type v
γ : Type w
inst✝¹ : UniformSpace β
inst✝ : UniformSpace γ
f : α → β
⊢ ⋂₀ (𝓤 α).sets = Prod.map f f ⁻¹' ⋂₀ (𝓤 β).sets
[PROOFSTEP]
simp_rw [uniformity_comap, (Filter.comap_hasBasis (Prod.map f f) (𝓤 β)).sInter_sets, ← preimage_iInter,
  sInter_eq_biInter]
[GOAL]
α : Type u
β : Type v
γ : Type w
inst✝¹ : UniformSpace β
inst✝ : UniformSpace γ
f : α → β
⊢ Prod.map f f ⁻¹' ⋂ (i : Set (β × β)) (_ : i ∈ 𝓤 β), i = Prod.map f f ⁻¹' ⋂ (i : Set (β × β)) (_ : i ∈ (𝓤 β).sets), i
[PROOFSTEP]
rfl
[GOAL]
α : Type u
β : Type v
γ : Type w
inst✝² : UniformSpace α
inst✝¹ : UniformSpace β
inst✝ : UniformSpace γ
ι : Sort u_1
p : ι → Prop
s : ι → Set (α × α)
h : HasBasis (𝓤 α) p s
⊢ 𝓢 α = ⋂ (i : ι) (_ : p i), s i
[PROOFSTEP]
unfold separationRel
[GOAL]
α : Type u
β : Type v
γ : Type w
inst✝² : UniformSpace α
inst✝¹ : UniformSpace β
inst✝ : UniformSpace γ
ι : Sort u_1
p : ι → Prop
s : ι → Set (α × α)
h : HasBasis (𝓤 α) p s
⊢ ⋂₀ (𝓤 α).sets = ⋂ (i : ι) (_ : p i), s i
[PROOFSTEP]
rw [h.sInter_sets]
[GOAL]
α : Type u
β : Type v
γ : Type w
inst✝² : UniformSpace α
inst✝¹ : UniformSpace β
inst✝ : UniformSpace γ
⊢ 𝓢 α = ⋂₀ (closure '' (𝓤 α).sets)
[PROOFSTEP]
simp [uniformity_hasBasis_closure.separationRel]
[GOAL]
α : Type u
β : Type v
γ : Type w
inst✝² : UniformSpace α
inst✝¹ : UniformSpace β
inst✝ : UniformSpace γ
⊢ IsClosed (𝓢 α)
[PROOFSTEP]
rw [separationRel_eq_inter_closure]
[GOAL]
α : Type u
β : Type v
γ : Type w
inst✝² : UniformSpace α
inst✝¹ : UniformSpace β
inst✝ : UniformSpace γ
⊢ IsClosed (⋂₀ (closure '' (𝓤 α).sets))
[PROOFSTEP]
apply isClosed_sInter
[GOAL]
case a
α : Type u
β : Type v
γ : Type w
inst✝² : UniformSpace α
inst✝¹ : UniformSpace β
inst✝ : UniformSpace γ
⊢ ∀ (t : Set (α × α)), t ∈ closure '' (𝓤 α).sets → IsClosed t
[PROOFSTEP]
rintro _ ⟨t, -, rfl⟩
[GOAL]
case a.intro.intro
α : Type u
β : Type v
γ : Type w
inst✝² : UniformSpace α
inst✝¹ : UniformSpace β
inst✝ : UniformSpace γ
t : Set (α × α)
⊢ IsClosed (closure t)
[PROOFSTEP]
exact isClosed_closure
[GOAL]
α : Type u
β : Type v
γ : Type w
inst✝² : UniformSpace α
inst✝¹ : UniformSpace β
inst✝ : UniformSpace γ
⊢ SeparatedSpace α ↔ T2Space α
[PROOFSTEP]
constructor
[GOAL]
case mp
α : Type u
β : Type v
γ : Type w
inst✝² : UniformSpace α
inst✝¹ : UniformSpace β
inst✝ : UniformSpace γ
⊢ SeparatedSpace α → T2Space α
[PROOFSTEP]
intro h
[GOAL]
case mpr
α : Type u
β : Type v
γ : Type w
inst✝² : UniformSpace α
inst✝¹ : UniformSpace β
inst✝ : UniformSpace γ
⊢ T2Space α → SeparatedSpace α
[PROOFSTEP]
intro h
[GOAL]
case mp
α : Type u
β : Type v
γ : Type w
inst✝² : UniformSpace α
inst✝¹ : UniformSpace β
inst✝ : UniformSpace γ
h : SeparatedSpace α
⊢ T2Space α
[PROOFSTEP]
rw [t2_iff_isClosed_diagonal, ← show 𝓢 α = diagonal α from h.1]
[GOAL]
case mp
α : Type u
β : Type v
γ : Type w
inst✝² : UniformSpace α
inst✝¹ : UniformSpace β
inst✝ : UniformSpace γ
h : SeparatedSpace α
⊢ IsClosed (𝓢 α)
[PROOFSTEP]
exact isClosed_separationRel
[GOAL]
case mpr
α : Type u
β : Type v
γ : Type w
inst✝² : UniformSpace α
inst✝¹ : UniformSpace β
inst✝ : UniformSpace γ
h : T2Space α
⊢ SeparatedSpace α
[PROOFSTEP]
rw [separated_def']
[GOAL]
case mpr
α : Type u
β : Type v
γ : Type w
inst✝² : UniformSpace α
inst✝¹ : UniformSpace β
inst✝ : UniformSpace γ
h : T2Space α
⊢ ∀ (x y : α), x ≠ y → ∃ r, r ∈ 𝓤 α ∧ ¬(x, y) ∈ r
[PROOFSTEP]
intro x y hxy
[GOAL]
case mpr
α : Type u
β : Type v
γ : Type w
inst✝² : UniformSpace α
inst✝¹ : UniformSpace β
inst✝ : UniformSpace γ
h : T2Space α
x y : α
hxy : x ≠ y
⊢ ∃ r, r ∈ 𝓤 α ∧ ¬(x, y) ∈ r
[PROOFSTEP]
rcases t2_separation hxy with ⟨u, v, uo, -, hx, hy, h⟩
[GOAL]
case mpr.intro.intro.intro.intro.intro.intro
α : Type u
β : Type v
γ : Type w
inst✝² : UniformSpace α
inst✝¹ : UniformSpace β
inst✝ : UniformSpace γ
h✝ : T2Space α
x y : α
hxy : x ≠ y
u v : Set α
uo : IsOpen u
hx : x ∈ u
hy : y ∈ v
h : Disjoint u v
⊢ ∃ r, r ∈ 𝓤 α ∧ ¬(x, y) ∈ r
[PROOFSTEP]
rcases isOpen_iff_ball_subset.1 uo x hx with ⟨r, hrU, hr⟩
[GOAL]
case mpr.intro.intro.intro.intro.intro.intro.intro.intro
α : Type u
β : Type v
γ : Type w
inst✝² : UniformSpace α
inst✝¹ : UniformSpace β
inst✝ : UniformSpace γ
h✝ : T2Space α
x y : α
hxy : x ≠ y
u v : Set α
uo : IsOpen u
hx : x ∈ u
hy : y ∈ v
h : Disjoint u v
r : Set (α × α)
hrU : r ∈ 𝓤 α
hr : ball x r ⊆ u
⊢ ∃ r, r ∈ 𝓤 α ∧ ¬(x, y) ∈ r
[PROOFSTEP]
exact ⟨r, hrU, fun H => h.le_bot ⟨hr H, hy⟩⟩
[GOAL]
α : Type u
β : Type v
γ : Type w
inst✝³ : UniformSpace α
inst✝² : UniformSpace β
inst✝¹ : UniformSpace γ
inst✝ : SeparatedSpace α
V₀ : Set (α × α)
V₀_in : V₀ ∈ 𝓤 α
s : Set α
hs : Set.Pairwise s fun x y => ¬(x, y) ∈ V₀
⊢ IsClosed s
[PROOFSTEP]
rcases comp_symm_mem_uniformity_sets V₀_in with ⟨V₁, V₁_in, V₁_symm, h_comp⟩
[GOAL]
case intro.intro.intro
α : Type u
β : Type v
γ : Type w
inst✝³ : UniformSpace α
inst✝² : UniformSpace β
inst✝¹ : UniformSpace γ
inst✝ : SeparatedSpace α
V₀ : Set (α × α)
V₀_in : V₀ ∈ 𝓤 α
s : Set α
hs : Set.Pairwise s fun x y => ¬(x, y) ∈ V₀
V₁ : Set (α × α)
V₁_in : V₁ ∈ 𝓤 α
V₁_symm : SymmetricRel V₁
h_comp : V₁ ○ V₁ ⊆ V₀
⊢ IsClosed s
[PROOFSTEP]
apply isClosed_of_closure_subset
[GOAL]
case intro.intro.intro.h
α : Type u
β : Type v
γ : Type w
inst✝³ : UniformSpace α
inst✝² : UniformSpace β
inst✝¹ : UniformSpace γ
inst✝ : SeparatedSpace α
V₀ : Set (α × α)
V₀_in : V₀ ∈ 𝓤 α
s : Set α
hs : Set.Pairwise s fun x y => ¬(x, y) ∈ V₀
V₁ : Set (α × α)
V₁_in : V₁ ∈ 𝓤 α
V₁_symm : SymmetricRel V₁
h_comp : V₁ ○ V₁ ⊆ V₀
⊢ closure s ⊆ s
[PROOFSTEP]
intro x hx
[GOAL]
case intro.intro.intro.h
α : Type u
β : Type v
γ : Type w
inst✝³ : UniformSpace α
inst✝² : UniformSpace β
inst✝¹ : UniformSpace γ
inst✝ : SeparatedSpace α
V₀ : Set (α × α)
V₀_in : V₀ ∈ 𝓤 α
s : Set α
hs : Set.Pairwise s fun x y => ¬(x, y) ∈ V₀
V₁ : Set (α × α)
V₁_in : V₁ ∈ 𝓤 α
V₁_symm : SymmetricRel V₁
h_comp : V₁ ○ V₁ ⊆ V₀
x : α
hx : x ∈ closure s
⊢ x ∈ s
[PROOFSTEP]
rw [mem_closure_iff_ball] at hx
[GOAL]
case intro.intro.intro.h
α : Type u
β : Type v
γ : Type w
inst✝³ : UniformSpace α
inst✝² : UniformSpace β
inst✝¹ : UniformSpace γ
inst✝ : SeparatedSpace α
V₀ : Set (α × α)
V₀_in : V₀ ∈ 𝓤 α
s : Set α
hs : Set.Pairwise s fun x y => ¬(x, y) ∈ V₀
V₁ : Set (α × α)
V₁_in : V₁ ∈ 𝓤 α
V₁_symm : SymmetricRel V₁
h_comp : V₁ ○ V₁ ⊆ V₀
x : α
hx : ∀ {V : Set (α × α)}, V ∈ 𝓤 α → Set.Nonempty (ball x V ∩ s)
⊢ x ∈ s
[PROOFSTEP]
rcases hx V₁_in with ⟨y, hy, hy'⟩
[GOAL]
case intro.intro.intro.h.intro.intro
α : Type u
β : Type v
γ : Type w
inst✝³ : UniformSpace α
inst✝² : UniformSpace β
inst✝¹ : UniformSpace γ
inst✝ : SeparatedSpace α
V₀ : Set (α × α)
V₀_in : V₀ ∈ 𝓤 α
s : Set α
hs : Set.Pairwise s fun x y => ¬(x, y) ∈ V₀
V₁ : Set (α × α)
V₁_in : V₁ ∈ 𝓤 α
V₁_symm : SymmetricRel V₁
h_comp : V₁ ○ V₁ ⊆ V₀
x : α
hx : ∀ {V : Set (α × α)}, V ∈ 𝓤 α → Set.Nonempty (ball x V ∩ s)
y : α
hy : y ∈ ball x V₁
hy' : y ∈ s
⊢ x ∈ s
[PROOFSTEP]
suffices x = y by rwa [this]
[GOAL]
α : Type u
β : Type v
γ : Type w
inst✝³ : UniformSpace α
inst✝² : UniformSpace β
inst✝¹ : UniformSpace γ
inst✝ : SeparatedSpace α
V₀ : Set (α × α)
V₀_in : V₀ ∈ 𝓤 α
s : Set α
hs : Set.Pairwise s fun x y => ¬(x, y) ∈ V₀
V₁ : Set (α × α)
V₁_in : V₁ ∈ 𝓤 α
V₁_symm : SymmetricRel V₁
h_comp : V₁ ○ V₁ ⊆ V₀
x : α
hx : ∀ {V : Set (α × α)}, V ∈ 𝓤 α → Set.Nonempty (ball x V ∩ s)
y : α
hy : y ∈ ball x V₁
hy' : y ∈ s
this : x = y
⊢ x ∈ s
[PROOFSTEP]
rwa [this]
[GOAL]
case intro.intro.intro.h.intro.intro
α : Type u
β : Type v
γ : Type w
inst✝³ : UniformSpace α
inst✝² : UniformSpace β
inst✝¹ : UniformSpace γ
inst✝ : SeparatedSpace α
V₀ : Set (α × α)
V₀_in : V₀ ∈ 𝓤 α
s : Set α
hs : Set.Pairwise s fun x y => ¬(x, y) ∈ V₀
V₁ : Set (α × α)
V₁_in : V₁ ∈ 𝓤 α
V₁_symm : SymmetricRel V₁
h_comp : V₁ ○ V₁ ⊆ V₀
x : α
hx : ∀ {V : Set (α × α)}, V ∈ 𝓤 α → Set.Nonempty (ball x V ∩ s)
y : α
hy : y ∈ ball x V₁
hy' : y ∈ s
⊢ x = y
[PROOFSTEP]
apply eq_of_forall_symmetric
[GOAL]
case intro.intro.intro.h.intro.intro.h
α : Type u
β : Type v
γ : Type w
inst✝³ : UniformSpace α
inst✝² : UniformSpace β
inst✝¹ : UniformSpace γ
inst✝ : SeparatedSpace α
V₀ : Set (α × α)
V₀_in : V₀ ∈ 𝓤 α
s : Set α
hs : Set.Pairwise s fun x y => ¬(x, y) ∈ V₀
V₁ : Set (α × α)
V₁_in : V₁ ∈ 𝓤 α
V₁_symm : SymmetricRel V₁
h_comp : V₁ ○ V₁ ⊆ V₀
x : α
hx : ∀ {V : Set (α × α)}, V ∈ 𝓤 α → Set.Nonempty (ball x V ∩ s)
y : α
hy : y ∈ ball x V₁
hy' : y ∈ s
⊢ ∀ {V : Set (α × α)}, V ∈ 𝓤 α → SymmetricRel V → (x, y) ∈ V
[PROOFSTEP]
intro V V_in _
[GOAL]
case intro.intro.intro.h.intro.intro.h
α : Type u
β : Type v
γ : Type w
inst✝³ : UniformSpace α
inst✝² : UniformSpace β
inst✝¹ : UniformSpace γ
inst✝ : SeparatedSpace α
V₀ : Set (α × α)
V₀_in : V₀ ∈ 𝓤 α
s : Set α
hs : Set.Pairwise s fun x y => ¬(x, y) ∈ V₀
V₁ : Set (α × α)
V₁_in : V₁ ∈ 𝓤 α
V₁_symm : SymmetricRel V₁
h_comp : V₁ ○ V₁ ⊆ V₀
x : α
hx : ∀ {V : Set (α × α)}, V ∈ 𝓤 α → Set.Nonempty (ball x V ∩ s)
y : α
hy : y ∈ ball x V₁
hy' : y ∈ s
V : Set (α × α)
V_in : V ∈ 𝓤 α
a✝ : SymmetricRel V
⊢ (x, y) ∈ V
[PROOFSTEP]
rcases hx (inter_mem V₁_in V_in) with ⟨z, hz, hz'⟩
[GOAL]
case intro.intro.intro.h.intro.intro.h.intro.intro
α : Type u
β : Type v
γ : Type w
inst✝³ : UniformSpace α
inst✝² : UniformSpace β
inst✝¹ : UniformSpace γ
inst✝ : SeparatedSpace α
V₀ : Set (α × α)
V₀_in : V₀ ∈ 𝓤 α
s : Set α
hs : Set.Pairwise s fun x y => ¬(x, y) ∈ V₀
V₁ : Set (α × α)
V₁_in : V₁ ∈ 𝓤 α
V₁_symm : SymmetricRel V₁
h_comp : V₁ ○ V₁ ⊆ V₀
x : α
hx : ∀ {V : Set (α × α)}, V ∈ 𝓤 α → Set.Nonempty (ball x V ∩ s)
y : α
hy : y ∈ ball x V₁
hy' : y ∈ s
V : Set (α × α)
V_in : V ∈ 𝓤 α
a✝ : SymmetricRel V
z : α
hz : z ∈ ball x (V₁ ∩ V)
hz' : z ∈ s
⊢ (x, y) ∈ V
[PROOFSTEP]
obtain rfl : z = y := by
  by_contra hzy
  exact hs hz' hy' hzy (h_comp <| mem_comp_of_mem_ball V₁_symm (ball_inter_left x _ _ hz) hy)
[GOAL]
α : Type u
β : Type v
γ : Type w
inst✝³ : UniformSpace α
inst✝² : UniformSpace β
inst✝¹ : UniformSpace γ
inst✝ : SeparatedSpace α
V₀ : Set (α × α)
V₀_in : V₀ ∈ 𝓤 α
s : Set α
hs : Set.Pairwise s fun x y => ¬(x, y) ∈ V₀
V₁ : Set (α × α)
V₁_in : V₁ ∈ 𝓤 α
V₁_symm : SymmetricRel V₁
h_comp : V₁ ○ V₁ ⊆ V₀
x : α
hx : ∀ {V : Set (α × α)}, V ∈ 𝓤 α → Set.Nonempty (ball x V ∩ s)
y : α
hy : y ∈ ball x V₁
hy' : y ∈ s
V : Set (α × α)
V_in : V ∈ 𝓤 α
a✝ : SymmetricRel V
z : α
hz : z ∈ ball x (V₁ ∩ V)
hz' : z ∈ s
⊢ z = y
[PROOFSTEP]
by_contra hzy
[GOAL]
α : Type u
β : Type v
γ : Type w
inst✝³ : UniformSpace α
inst✝² : UniformSpace β
inst✝¹ : UniformSpace γ
inst✝ : SeparatedSpace α
V₀ : Set (α × α)
V₀_in : V₀ ∈ 𝓤 α
s : Set α
hs : Set.Pairwise s fun x y => ¬(x, y) ∈ V₀
V₁ : Set (α × α)
V₁_in : V₁ ∈ 𝓤 α
V₁_symm : SymmetricRel V₁
h_comp : V₁ ○ V₁ ⊆ V₀
x : α
hx : ∀ {V : Set (α × α)}, V ∈ 𝓤 α → Set.Nonempty (ball x V ∩ s)
y : α
hy : y ∈ ball x V₁
hy' : y ∈ s
V : Set (α × α)
V_in : V ∈ 𝓤 α
a✝ : SymmetricRel V
z : α
hz : z ∈ ball x (V₁ ∩ V)
hz' : z ∈ s
hzy : ¬z = y
⊢ False
[PROOFSTEP]
exact hs hz' hy' hzy (h_comp <| mem_comp_of_mem_ball V₁_symm (ball_inter_left x _ _ hz) hy)
[GOAL]
case intro.intro.intro.h.intro.intro.h.intro.intro
α : Type u
β : Type v
γ : Type w
inst✝³ : UniformSpace α
inst✝² : UniformSpace β
inst✝¹ : UniformSpace γ
inst✝ : SeparatedSpace α
V₀ : Set (α × α)
V₀_in : V₀ ∈ 𝓤 α
s : Set α
hs : Set.Pairwise s fun x y => ¬(x, y) ∈ V₀
V₁ : Set (α × α)
V₁_in : V₁ ∈ 𝓤 α
V₁_symm : SymmetricRel V₁
h_comp : V₁ ○ V₁ ⊆ V₀
x : α
hx : ∀ {V : Set (α × α)}, V ∈ 𝓤 α → Set.Nonempty (ball x V ∩ s)
V : Set (α × α)
V_in : V ∈ 𝓤 α
a✝ : SymmetricRel V
z : α
hz : z ∈ ball x (V₁ ∩ V)
hz' : z ∈ s
hy : z ∈ ball x V₁
hy' : z ∈ s
⊢ (x, z) ∈ V
[PROOFSTEP]
exact ball_inter_right x _ _ hz
[GOAL]
α : Type u
β : Type v
γ : Type w
inst✝³ : UniformSpace α
inst✝² : UniformSpace β
inst✝¹ : UniformSpace γ
ι : Type u_1
inst✝ : SeparatedSpace α
V₀ : Set (α × α)
V₀_in : V₀ ∈ 𝓤 α
f : ι → α
hf : Pairwise fun x y => ¬(f x, f y) ∈ V₀
⊢ Set.Pairwise (range f) fun x y => ¬(x, y) ∈ V₀
[PROOFSTEP]
rintro _ ⟨x, rfl⟩ _ ⟨y, rfl⟩ h
[GOAL]
case intro.intro
α : Type u
β : Type v
γ : Type w
inst✝³ : UniformSpace α
inst✝² : UniformSpace β
inst✝¹ : UniformSpace γ
ι : Type u_1
inst✝ : SeparatedSpace α
V₀ : Set (α × α)
V₀_in : V₀ ∈ 𝓤 α
f : ι → α
hf : Pairwise fun x y => ¬(f x, f y) ∈ V₀
x y : ι
h : f x ≠ f y
⊢ ¬(f x, f y) ∈ V₀
[PROOFSTEP]
exact hf (ne_of_apply_ne f h)
[GOAL]
α✝ : Type u
β : Type v
γ : Type w
inst✝³ : UniformSpace α✝
inst✝² : UniformSpace β
inst✝¹ : UniformSpace γ
α : Type u
inst✝ : UniformSpace α
⊢ 𝓟 idRel ≤ map (fun p => (Quotient.mk (separationSetoid α) p.fst, Quotient.mk (separationSetoid α) p.snd)) (𝓟 idRel)
[PROOFSTEP]
simp [Quotient.exists_rep]
[GOAL]
α✝ : Type u
β : Type v
γ : Type w
inst✝³ : UniformSpace α✝
inst✝² : UniformSpace β
inst✝¹ : UniformSpace γ
α : Type u
inst✝ : UniformSpace α
s : Set (Quotient (separationSetoid α) × Quotient (separationSetoid α))
hs : s ∈ map (fun p => (Quotient.mk (separationSetoid α) p.fst, Quotient.mk (separationSetoid α) p.snd)) (𝓤 α)
⊢ s ∈
    Filter.lift' (map (fun p => (Quotient.mk (separationSetoid α) p.fst, Quotient.mk (separationSetoid α) p.snd)) (𝓤 α))
      fun s => s ○ s
[PROOFSTEP]
rcases comp_open_symm_mem_uniformity_sets hs with ⟨U, hU, hUo, -, hUs⟩
[GOAL]
case intro.intro.intro.intro
α✝ : Type u
β : Type v
γ : Type w
inst✝³ : UniformSpace α✝
inst✝² : UniformSpace β
inst✝¹ : UniformSpace γ
α : Type u
inst✝ : UniformSpace α
s : Set (Quotient (separationSetoid α) × Quotient (separationSetoid α))
hs : s ∈ map (fun p => (Quotient.mk (separationSetoid α) p.fst, Quotient.mk (separationSetoid α) p.snd)) (𝓤 α)
U : Set (α × α)
hU : U ∈ 𝓤 α
hUo : IsOpen U
hUs : U ○ U ⊆ (fun p => (Quotient.mk (separationSetoid α) p.fst, Quotient.mk (separationSetoid α) p.snd)) ⁻¹' s
⊢ s ∈
    Filter.lift' (map (fun p => (Quotient.mk (separationSetoid α) p.fst, Quotient.mk (separationSetoid α) p.snd)) (𝓤 α))
      fun s => s ○ s
[PROOFSTEP]
refine' mem_of_superset (mem_lift' <| image_mem_map hU) ?_
[GOAL]
case intro.intro.intro.intro
α✝ : Type u
β : Type v
γ : Type w
inst✝³ : UniformSpace α✝
inst✝² : UniformSpace β
inst✝¹ : UniformSpace γ
α : Type u
inst✝ : UniformSpace α
s : Set (Quotient (separationSetoid α) × Quotient (separationSetoid α))
hs : s ∈ map (fun p => (Quotient.mk (separationSetoid α) p.fst, Quotient.mk (separationSetoid α) p.snd)) (𝓤 α)
U : Set (α × α)
hU : U ∈ 𝓤 α
hUo : IsOpen U
hUs : U ○ U ⊆ (fun p => (Quotient.mk (separationSetoid α) p.fst, Quotient.mk (separationSetoid α) p.snd)) ⁻¹' s
⊢ (fun p => (Quotient.mk (separationSetoid α) p.fst, Quotient.mk (separationSetoid α) p.snd)) '' U ○
      (fun p => (Quotient.mk (separationSetoid α) p.fst, Quotient.mk (separationSetoid α) p.snd)) '' U ⊆
    s
[PROOFSTEP]
simp only [subset_def, Prod.forall, mem_compRel, mem_image, Prod.ext_iff]
[GOAL]
case intro.intro.intro.intro
α✝ : Type u
β : Type v
γ : Type w
inst✝³ : UniformSpace α✝
inst✝² : UniformSpace β
inst✝¹ : UniformSpace γ
α : Type u
inst✝ : UniformSpace α
s : Set (Quotient (separationSetoid α) × Quotient (separationSetoid α))
hs : s ∈ map (fun p => (Quotient.mk (separationSetoid α) p.fst, Quotient.mk (separationSetoid α) p.snd)) (𝓤 α)
U : Set (α × α)
hU : U ∈ 𝓤 α
hUo : IsOpen U
hUs : U ○ U ⊆ (fun p => (Quotient.mk (separationSetoid α) p.fst, Quotient.mk (separationSetoid α) p.snd)) ⁻¹' s
⊢ ∀ (a b : Quotient (separationSetoid α)),
    (∃ z,
        (∃ x, x ∈ U ∧ Quotient.mk (separationSetoid α) x.fst = a ∧ Quotient.mk (separationSetoid α) x.snd = z) ∧
          ∃ x, x ∈ U ∧ Quotient.mk (separationSetoid α) x.fst = z ∧ Quotient.mk (separationSetoid α) x.snd = b) →
      (a, b) ∈ s
[PROOFSTEP]
rintro _ _ ⟨_, ⟨⟨x, y⟩, hxyU, rfl, rfl⟩, ⟨⟨y', z⟩, hyzU, hy, rfl⟩⟩
[GOAL]
case intro.intro.intro.intro.intro.intro.intro.mk.intro.intro.intro.mk.intro.intro
α✝ : Type u
β : Type v
γ : Type w
inst✝³ : UniformSpace α✝
inst✝² : UniformSpace β
inst✝¹ : UniformSpace γ
α : Type u
inst✝ : UniformSpace α
s : Set (Quotient (separationSetoid α) × Quotient (separationSetoid α))
hs : s ∈ map (fun p => (Quotient.mk (separationSetoid α) p.fst, Quotient.mk (separationSetoid α) p.snd)) (𝓤 α)
U : Set (α × α)
hU : U ∈ 𝓤 α
hUo : IsOpen U
hUs : U ○ U ⊆ (fun p => (Quotient.mk (separationSetoid α) p.fst, Quotient.mk (separationSetoid α) p.snd)) ⁻¹' s
x y : α
hxyU : (x, y) ∈ U
y' z : α
hyzU : (y', z) ∈ U
hy : Quotient.mk (separationSetoid α) (y', z).fst = Quotient.mk (separationSetoid α) (x, y).snd
⊢ (Quotient.mk (separationSetoid α) (x, y).fst, Quotient.mk (separationSetoid α) (y', z).snd) ∈ s
[PROOFSTEP]
have : y' ⤳ y := separationRel_iff_specializes.1 (Quotient.exact hy)
[GOAL]
case intro.intro.intro.intro.intro.intro.intro.mk.intro.intro.intro.mk.intro.intro
α✝ : Type u
β : Type v
γ : Type w
inst✝³ : UniformSpace α✝
inst✝² : UniformSpace β
inst✝¹ : UniformSpace γ
α : Type u
inst✝ : UniformSpace α
s : Set (Quotient (separationSetoid α) × Quotient (separationSetoid α))
hs : s ∈ map (fun p => (Quotient.mk (separationSetoid α) p.fst, Quotient.mk (separationSetoid α) p.snd)) (𝓤 α)
U : Set (α × α)
hU : U ∈ 𝓤 α
hUo : IsOpen U
hUs : U ○ U ⊆ (fun p => (Quotient.mk (separationSetoid α) p.fst, Quotient.mk (separationSetoid α) p.snd)) ⁻¹' s
x y : α
hxyU : (x, y) ∈ U
y' z : α
hyzU : (y', z) ∈ U
hy : Quotient.mk (separationSetoid α) (y', z).fst = Quotient.mk (separationSetoid α) (x, y).snd
this : y' ⤳ y
⊢ (Quotient.mk (separationSetoid α) (x, y).fst, Quotient.mk (separationSetoid α) (y', z).snd) ∈ s
[PROOFSTEP]
exact @hUs (x, z) ⟨y', this.mem_open (UniformSpace.isOpen_ball _ hUo) hxyU, hyzU⟩
[GOAL]
α✝ : Type u
β : Type v
γ : Type w
inst✝³ : UniformSpace α✝
inst✝² : UniformSpace β
inst✝¹ : UniformSpace γ
α : Type u
inst✝ : UniformSpace α
s : Set (Quotient (separationSetoid α))
⊢ IsOpen (Quotient.mk' ⁻¹' s) ↔
    ∀ (x : Quotient (separationSetoid α)),
      x ∈ s →
        {p | p.fst = x → p.snd ∈ s} ∈
          {
              uniformity :=
                map (fun p => (Quotient.mk (separationSetoid α) p.fst, Quotient.mk (separationSetoid α) p.snd)) (𝓤 α),
              refl :=
                (_ :
                  𝓟 idRel ≤
                    map (fun p => (Quotient.mk (separationSetoid α) p.fst, Quotient.mk (separationSetoid α) p.snd))
                      (𝓤 α)),
              symm :=
                (_ :
                  Tendsto Prod.swap
                    (map (fun p => (Quotient.mk (separationSetoid α) p.fst, Quotient.mk (separationSetoid α) p.snd))
                      (𝓤 α))
                    (map (fun p => (Quotient.mk (separationSetoid α) p.fst, Quotient.mk (separationSetoid α) p.snd))
                      (𝓤 α))),
              comp :=
                (_ :
                  ∀ (s : Set (Quotient (separationSetoid α) × Quotient (separationSetoid α))),
                    s ∈
                        map (fun p => (Quotient.mk (separationSetoid α) p.fst, Quotient.mk (separationSetoid α) p.snd))
                          (𝓤 α) →
                      s ∈
                        Filter.lift'
                          (map
                            (fun p => (Quotient.mk (separationSetoid α) p.fst, Quotient.mk (separationSetoid α) p.snd))
                            (𝓤 α))
                          fun s => s ○ s) }.uniformity
[PROOFSTEP]
simp only [_root_.isOpen_uniformity, forall_quotient_iff, mem_map', mem_setOf_eq]
[GOAL]
α✝ : Type u
β : Type v
γ : Type w
inst✝³ : UniformSpace α✝
inst✝² : UniformSpace β
inst✝¹ : UniformSpace γ
α : Type u
inst✝ : UniformSpace α
s : Set (Quotient (separationSetoid α))
⊢ (∀ (x : α), x ∈ Quotient.mk' ⁻¹' s → {p | p.fst = x → p.snd ∈ Quotient.mk' ⁻¹' s} ∈ 𝓤 α) ↔
    ∀ (a : α),
      Quotient.mk (separationSetoid α) a ∈ s →
        {x |
            Quotient.mk (separationSetoid α) x.fst = Quotient.mk (separationSetoid α) a →
              Quotient.mk (separationSetoid α) x.snd ∈ s} ∈
          𝓤 α
[PROOFSTEP]
refine forall₂_congr fun x _ => ⟨fun h => ?_, fun h => mem_of_superset h ?_⟩
[GOAL]
case refine_1
α✝ : Type u
β : Type v
γ : Type w
inst✝³ : UniformSpace α✝
inst✝² : UniformSpace β
inst✝¹ : UniformSpace γ
α : Type u
inst✝ : UniformSpace α
s : Set (Quotient (separationSetoid α))
x : α
x✝ : x ∈ Quotient.mk' ⁻¹' s
h : {p | p.fst = x → p.snd ∈ Quotient.mk' ⁻¹' s} ∈ 𝓤 α
⊢ {x_1 |
      Quotient.mk (separationSetoid α) x_1.fst = Quotient.mk (separationSetoid α) x →
        Quotient.mk (separationSetoid α) x_1.snd ∈ s} ∈
    𝓤 α
[PROOFSTEP]
rcases comp_mem_uniformity_sets h with ⟨t, ht, hts⟩
[GOAL]
case refine_1.intro.intro
α✝ : Type u
β : Type v
γ : Type w
inst✝³ : UniformSpace α✝
inst✝² : UniformSpace β
inst✝¹ : UniformSpace γ
α : Type u
inst✝ : UniformSpace α
s : Set (Quotient (separationSetoid α))
x : α
x✝ : x ∈ Quotient.mk' ⁻¹' s
h : {p | p.fst = x → p.snd ∈ Quotient.mk' ⁻¹' s} ∈ 𝓤 α
t : Set (α × α)
ht : t ∈ 𝓤 α
hts : t ○ t ⊆ {p | p.fst = x → p.snd ∈ Quotient.mk' ⁻¹' s}
⊢ {x_1 |
      Quotient.mk (separationSetoid α) x_1.fst = Quotient.mk (separationSetoid α) x →
        Quotient.mk (separationSetoid α) x_1.snd ∈ s} ∈
    𝓤 α
[PROOFSTEP]
refine mem_of_superset ht fun (y, z) hyz hyx => @hts (x, z) ⟨y, ?_, hyz⟩ rfl
[GOAL]
case refine_1.intro.intro
α✝ : Type u
β : Type v
γ : Type w
inst✝³ : UniformSpace α✝
inst✝² : UniformSpace β
inst✝¹ : UniformSpace γ
α : Type u
inst✝ : UniformSpace α
s : Set (Quotient (separationSetoid α))
x : α
x✝¹ : x ∈ Quotient.mk' ⁻¹' s
h : {p | p.fst = x → p.snd ∈ Quotient.mk' ⁻¹' s} ∈ 𝓤 α
t : Set (α × α)
ht : t ∈ 𝓤 α
hts : t ○ t ⊆ {p | p.fst = x → p.snd ∈ Quotient.mk' ⁻¹' s}
x✝ : α × α
y z : α
hyz : (y, z) ∈ t
hyx : Quotient.mk (separationSetoid α) (y, z).fst = Quotient.mk (separationSetoid α) x
⊢ ((x, z).fst, y) ∈ t
[PROOFSTEP]
exact Quotient.exact hyx.symm _ ht
[GOAL]
case refine_2
α✝ : Type u
β : Type v
γ : Type w
inst✝³ : UniformSpace α✝
inst✝² : UniformSpace β
inst✝¹ : UniformSpace γ
α : Type u
inst✝ : UniformSpace α
s : Set (Quotient (separationSetoid α))
x : α
x✝ : x ∈ Quotient.mk' ⁻¹' s
h :
  {x_1 |
      Quotient.mk (separationSetoid α) x_1.fst = Quotient.mk (separationSetoid α) x →
        Quotient.mk (separationSetoid α) x_1.snd ∈ s} ∈
    𝓤 α
⊢ {x_1 |
      Quotient.mk (separationSetoid α) x_1.fst = Quotient.mk (separationSetoid α) x →
        Quotient.mk (separationSetoid α) x_1.snd ∈ s} ⊆
    {p | p.fst = x → p.snd ∈ Quotient.mk' ⁻¹' s}
[PROOFSTEP]
exact fun y hy hyx => hy <| congr_arg _ hyx
[GOAL]
α : Type u
β : Type v
γ : Type w
inst✝² : UniformSpace α
inst✝¹ : UniformSpace β
inst✝ : UniformSpace γ
f : α → β → γ
h : ∀ (a : α) (c : β) (b : α) (d : β), (a, b) ∈ 𝓢 α → (c, d) ∈ 𝓢 β → f a c = f b d
hf : UniformContinuous fun p => f p.fst p.snd
⊢ UniformContinuous fun p => Quotient.lift₂ f h p.fst p.snd
[PROOFSTEP]
rw [UniformContinuous, uniformity_prod_eq_prod, uniformity_quotient, uniformity_quotient, Filter.prod_map_map_eq,
  Filter.tendsto_map'_iff, Filter.tendsto_map'_iff]
[GOAL]
α : Type u
β : Type v
γ : Type w
inst✝² : UniformSpace α
inst✝¹ : UniformSpace β
inst✝ : UniformSpace γ
f : α → β → γ
h : ∀ (a : α) (c : β) (b : α) (d : β), (a, b) ∈ 𝓢 α → (c, d) ∈ 𝓢 β → f a c = f b d
hf : UniformContinuous fun p => f p.fst p.snd
⊢ Tendsto
    (((fun x => (Quotient.lift₂ f h x.fst.fst x.fst.snd, Quotient.lift₂ f h x.snd.fst x.snd.snd)) ∘ fun p =>
        ((p.fst.fst, p.snd.fst), p.fst.snd, p.snd.snd)) ∘
      fun p =>
      ((Quotient.mk (separationSetoid α) p.fst.fst, Quotient.mk (separationSetoid α) p.fst.snd),
        Quotient.mk (separationSetoid β) p.snd.fst, Quotient.mk (separationSetoid β) p.snd.snd))
    (𝓤 α ×ˢ 𝓤 β) (𝓤 γ)
[PROOFSTEP]
rwa [UniformContinuous, uniformity_prod_eq_prod, Filter.tendsto_map'_iff] at hf
[GOAL]
α : Type u
β : Type v
γ : Type w
inst✝² : UniformSpace α
inst✝¹ : UniformSpace β
inst✝ : UniformSpace γ
U : Set (α × α)
hU : U ∈ 𝓤 α ∧ IsOpen U
x✝¹ : α × α
x y : α
x✝ :
  (x, y) ∈
    (fun p => (Quotient.mk (separationSetoid α) p.fst, Quotient.mk (separationSetoid α) p.snd)) ⁻¹'
      ((fun p => (Quotient.mk (separationSetoid α) p.fst, Quotient.mk (separationSetoid α) p.snd)) '' id U)
x' y' : α
hx' : (x', y') ∈ id U
h :
  (fun p => (Quotient.mk (separationSetoid α) p.fst, Quotient.mk (separationSetoid α) p.snd)) (x', y') =
    (fun p => (Quotient.mk (separationSetoid α) p.fst, Quotient.mk (separationSetoid α) p.snd)) (x, y)
⊢ (x, y) ∈ id U
[PROOFSTEP]
simp only [Prod.ext_iff, Quotient.eq] at h
[GOAL]
α : Type u
β : Type v
γ : Type w
inst✝² : UniformSpace α
inst✝¹ : UniformSpace β
inst✝ : UniformSpace γ
U : Set (α × α)
hU : U ∈ 𝓤 α ∧ IsOpen U
x✝¹ : α × α
x y : α
x✝ :
  (x, y) ∈
    (fun p => (Quotient.mk (separationSetoid α) p.fst, Quotient.mk (separationSetoid α) p.snd)) ⁻¹'
      ((fun p => (Quotient.mk (separationSetoid α) p.fst, Quotient.mk (separationSetoid α) p.snd)) '' id U)
x' y' : α
hx' : (x', y') ∈ id U
h : x' ≈ x ∧ y' ≈ y
⊢ (x, y) ∈ id U
[PROOFSTEP]
exact (((separationRel_iff_inseparable.1 h.1).prod (separationRel_iff_inseparable.1 h.2)).mem_open_iff hU.2).1 hx'
[GOAL]
α : Type u
β : Type v
γ : Type w
inst✝² : UniformSpace α
inst✝¹ : UniformSpace β
inst✝ : UniformSpace γ
x✝ : Quotient (separationSetoid α) × Quotient (separationSetoid α)
a✝ b✝ : Quotient (separationSetoid α)
a b : α
h : (Quotient.mk (separationSetoid α) a, Quotient.mk (separationSetoid α) b) ∈ 𝓢 (Quotient (separationSetoid α))
s : Set (α × α)
hs : s ∈ (𝓤 α).sets
this :
  s ∈
    Filter.comap (fun p => (Quotient.mk (separationSetoid α) p.fst, Quotient.mk (separationSetoid α) p.snd))
      (𝓤 (Quotient (separationSetoid α)))
t : Set (Quotient (separationSetoid α) × Quotient (separationSetoid α))
ht : t ∈ 𝓤 (Quotient (separationSetoid α))
hts : (fun p => (Quotient.mk (separationSetoid α) p.fst, Quotient.mk (separationSetoid α) p.snd)) ⁻¹' t ⊆ s
⊢ (a, b) ∈ (fun p => (Quotient.mk (separationSetoid α) p.fst, Quotient.mk (separationSetoid α) p.snd)) ⁻¹' t
[PROOFSTEP]
dsimp [preimage]
[GOAL]
α : Type u
β : Type v
γ : Type w
inst✝² : UniformSpace α
inst✝¹ : UniformSpace β
inst✝ : UniformSpace γ
x✝ : Quotient (separationSetoid α) × Quotient (separationSetoid α)
a✝ b✝ : Quotient (separationSetoid α)
a b : α
h : (Quotient.mk (separationSetoid α) a, Quotient.mk (separationSetoid α) b) ∈ 𝓢 (Quotient (separationSetoid α))
s : Set (α × α)
hs : s ∈ (𝓤 α).sets
this :
  s ∈
    Filter.comap (fun p => (Quotient.mk (separationSetoid α) p.fst, Quotient.mk (separationSetoid α) p.snd))
      (𝓤 (Quotient (separationSetoid α)))
t : Set (Quotient (separationSetoid α) × Quotient (separationSetoid α))
ht : t ∈ 𝓤 (Quotient (separationSetoid α))
hts : (fun p => (Quotient.mk (separationSetoid α) p.fst, Quotient.mk (separationSetoid α) p.snd)) ⁻¹' t ⊆ s
⊢ (Quotient.mk (separationSetoid α) a, Quotient.mk (separationSetoid α) b) ∈ t
[PROOFSTEP]
exact h t ht
[GOAL]
α : Type u
β : Type v
γ : Type w
inst✝³ : UniformSpace α
inst✝² : UniformSpace β
inst✝¹ : UniformSpace γ
inst✝ : SeparatedSpace β
f : α → β
x y : α
H : UniformContinuous f
h : x ≈ y
⊢ SeparatedSpace β
[PROOFSTEP]
infer_instance
[GOAL]
α : Type u
β : Type v
γ : Type w
inst✝³ : UniformSpace α
inst✝² : UniformSpace β
inst✝¹ : UniformSpace γ
inst✝ : SeparatedSpace β
f : α → β
h : UniformContinuous f
a : α
⊢ lift f (Quotient.mk (separationSetoid α) a) = f a
[PROOFSTEP]
rw [lift, dif_pos h]
[GOAL]
α : Type u
β : Type v
γ : Type w
inst✝³ : UniformSpace α
inst✝² : UniformSpace β
inst✝¹ : UniformSpace γ
inst✝ : SeparatedSpace β
f : α → β
h : UniformContinuous f
a : α
⊢ Quotient.lift f (_ : ∀ (x x_1 : α), x ≈ x_1 → f x = f x_1) (Quotient.mk (separationSetoid α) a) = f a
[PROOFSTEP]
rfl
[GOAL]
α : Type u
β : Type v
γ : Type w
inst✝³ : UniformSpace α
inst✝² : UniformSpace β
inst✝¹ : UniformSpace γ
inst✝ : SeparatedSpace β
f : α → β
⊢ UniformContinuous (lift f)
[PROOFSTEP]
by_cases hf : UniformContinuous f
[GOAL]
case pos
α : Type u
β : Type v
γ : Type w
inst✝³ : UniformSpace α
inst✝² : UniformSpace β
inst✝¹ : UniformSpace γ
inst✝ : SeparatedSpace β
f : α → β
hf : UniformContinuous f
⊢ UniformContinuous (lift f)
[PROOFSTEP]
rw [lift, dif_pos hf]
[GOAL]
case pos
α : Type u
β : Type v
γ : Type w
inst✝³ : UniformSpace α
inst✝² : UniformSpace β
inst✝¹ : UniformSpace γ
inst✝ : SeparatedSpace β
f : α → β
hf : UniformContinuous f
⊢ UniformContinuous (Quotient.lift f (_ : ∀ (x x_1 : α), x ≈ x_1 → f x = f x_1))
[PROOFSTEP]
exact uniformContinuous_quotient_lift hf
[GOAL]
case neg
α : Type u
β : Type v
γ : Type w
inst✝³ : UniformSpace α
inst✝² : UniformSpace β
inst✝¹ : UniformSpace γ
inst✝ : SeparatedSpace β
f : α → β
hf : ¬UniformContinuous f
⊢ UniformContinuous (lift f)
[PROOFSTEP]
rw [lift, dif_neg hf]
[GOAL]
case neg
α : Type u
β : Type v
γ : Type w
inst✝³ : UniformSpace α
inst✝² : UniformSpace β
inst✝¹ : UniformSpace γ
inst✝ : SeparatedSpace β
f : α → β
hf : ¬UniformContinuous f
⊢ UniformContinuous fun x => f (Nonempty.some (_ : Nonempty α))
[PROOFSTEP]
exact uniformContinuous_of_const fun a _ => rfl
[GOAL]
α : Type u
β : Type v
γ : Type w
inst✝² : UniformSpace α
inst✝¹ : UniformSpace β
inst✝ : UniformSpace γ
f : α → β
h : UniformContinuous f
a : α
⊢ map f (Quotient.mk (separationSetoid α) a) = Quotient.mk (separationSetoid β) (f a)
[PROOFSTEP]
rw [map, lift_mk (uniformContinuous_quotient_mk'.comp h)]
[GOAL]
α : Type u
β : Type v
γ : Type w
inst✝² : UniformSpace α
inst✝¹ : UniformSpace β
inst✝ : UniformSpace γ
f : α → β
h : UniformContinuous f
a : α
⊢ (Quotient.mk' ∘ f) a = Quotient.mk (separationSetoid β) (f a)
[PROOFSTEP]
rfl
[GOAL]
α : Type u
β : Type v
γ : Type w
inst✝² : UniformSpace α
inst✝¹ : UniformSpace β
inst✝ : UniformSpace γ
f : α → β
hf : UniformContinuous f
g : SeparationQuotient α → SeparationQuotient β
comm : Quotient.mk (separationSetoid β) ∘ f = g ∘ Quotient.mk (separationSetoid α)
⊢ map f = g
[PROOFSTEP]
ext ⟨a⟩
[GOAL]
case h.mk
α : Type u
β : Type v
γ : Type w
inst✝² : UniformSpace α
inst✝¹ : UniformSpace β
inst✝ : UniformSpace γ
f : α → β
hf : UniformContinuous f
g : SeparationQuotient α → SeparationQuotient β
comm : Quotient.mk (separationSetoid β) ∘ f = g ∘ Quotient.mk (separationSetoid α)
x✝ : SeparationQuotient α
a : α
⊢ map f (Quot.mk Setoid.r a) = g (Quot.mk Setoid.r a)
[PROOFSTEP]
calc
  map f ⟦a⟧ = ⟦f a⟧ := map_mk hf a
  _ = g ⟦a⟧ := congr_fun comm a
[GOAL]
α : Type u
β : Type v
γ : Type w
inst✝² : UniformSpace α
inst✝¹ : UniformSpace β
inst✝ : UniformSpace γ
f : α → β
g : β → γ
hf : UniformContinuous f
hg : UniformContinuous g
⊢ Quotient.mk (separationSetoid γ) ∘ g ∘ f = (map g ∘ map f) ∘ Quotient.mk (separationSetoid α)
[PROOFSTEP]
simp only [Function.comp, map_mk, hf, hg]
[GOAL]
α : Type u
β : Type v
γ : Type w
inst✝² : UniformSpace α
inst✝¹ : UniformSpace β
inst✝ : UniformSpace γ
a₁ a₂ : α
b₁ b₂ : β
⊢ (a₁, b₁) ≈ (a₂, b₂) ↔ a₁ ≈ a₂ ∧ b₁ ≈ b₂
[PROOFSTEP]
constructor
[GOAL]
case mp
α : Type u
β : Type v
γ : Type w
inst✝² : UniformSpace α
inst✝¹ : UniformSpace β
inst✝ : UniformSpace γ
a₁ a₂ : α
b₁ b₂ : β
⊢ (a₁, b₁) ≈ (a₂, b₂) → a₁ ≈ a₂ ∧ b₁ ≈ b₂
[PROOFSTEP]
intro h
[GOAL]
case mp
α : Type u
β : Type v
γ : Type w
inst✝² : UniformSpace α
inst✝¹ : UniformSpace β
inst✝ : UniformSpace γ
a₁ a₂ : α
b₁ b₂ : β
h : (a₁, b₁) ≈ (a₂, b₂)
⊢ a₁ ≈ a₂ ∧ b₁ ≈ b₂
[PROOFSTEP]
exact ⟨separated_of_uniformContinuous uniformContinuous_fst h, separated_of_uniformContinuous uniformContinuous_snd h⟩
[GOAL]
case mpr
α : Type u
β : Type v
γ : Type w
inst✝² : UniformSpace α
inst✝¹ : UniformSpace β
inst✝ : UniformSpace γ
a₁ a₂ : α
b₁ b₂ : β
⊢ a₁ ≈ a₂ ∧ b₁ ≈ b₂ → (a₁, b₁) ≈ (a₂, b₂)
[PROOFSTEP]
rintro ⟨eqv_α, eqv_β⟩ r r_in
[GOAL]
case mpr.intro
α : Type u
β : Type v
γ : Type w
inst✝² : UniformSpace α
inst✝¹ : UniformSpace β
inst✝ : UniformSpace γ
a₁ a₂ : α
b₁ b₂ : β
eqv_α : a₁ ≈ a₂
eqv_β : b₁ ≈ b₂
r : Set ((α × β) × α × β)
r_in : r ∈ (𝓤 (α × β)).sets
⊢ ((a₁, b₁), a₂, b₂) ∈ r
[PROOFSTEP]
rw [uniformity_prod] at r_in
[GOAL]
case mpr.intro
α : Type u
β : Type v
γ : Type w
inst✝² : UniformSpace α
inst✝¹ : UniformSpace β
inst✝ : UniformSpace γ
a₁ a₂ : α
b₁ b₂ : β
eqv_α : a₁ ≈ a₂
eqv_β : b₁ ≈ b₂
r : Set ((α × β) × α × β)
r_in :
  r ∈ (Filter.comap (fun p => (p.fst.fst, p.snd.fst)) (𝓤 α) ⊓ Filter.comap (fun p => (p.fst.snd, p.snd.snd)) (𝓤 β)).sets
⊢ ((a₁, b₁), a₂, b₂) ∈ r
[PROOFSTEP]
rcases r_in with ⟨t_α, ⟨r_α, r_α_in, h_α⟩, t_β, ⟨r_β, r_β_in, h_β⟩, rfl⟩
[GOAL]
case mpr.intro.intro.intro.intro.intro.intro.intro.intro.intro
α : Type u
β : Type v
γ : Type w
inst✝² : UniformSpace α
inst✝¹ : UniformSpace β
inst✝ : UniformSpace γ
a₁ a₂ : α
b₁ b₂ : β
eqv_α : a₁ ≈ a₂
eqv_β : b₁ ≈ b₂
t_α : Set ((α × β) × α × β)
r_α : Set (α × α)
r_α_in : r_α ∈ 𝓤 α
h_α : (fun p => (p.fst.fst, p.snd.fst)) ⁻¹' r_α ⊆ t_α
t_β : Set ((α × β) × α × β)
r_β : Set (β × β)
r_β_in : r_β ∈ 𝓤 β
h_β : (fun p => (p.fst.snd, p.snd.snd)) ⁻¹' r_β ⊆ t_β
⊢ ((a₁, b₁), a₂, b₂) ∈ t_α ∩ t_β
[PROOFSTEP]
let p_α := fun p : (α × β) × α × β => (p.1.1, p.2.1)
[GOAL]
case mpr.intro.intro.intro.intro.intro.intro.intro.intro.intro
α : Type u
β : Type v
γ : Type w
inst✝² : UniformSpace α
inst✝¹ : UniformSpace β
inst✝ : UniformSpace γ
a₁ a₂ : α
b₁ b₂ : β
eqv_α : a₁ ≈ a₂
eqv_β : b₁ ≈ b₂
t_α : Set ((α × β) × α × β)
r_α : Set (α × α)
r_α_in : r_α ∈ 𝓤 α
h_α : (fun p => (p.fst.fst, p.snd.fst)) ⁻¹' r_α ⊆ t_α
t_β : Set ((α × β) × α × β)
r_β : Set (β × β)
r_β_in : r_β ∈ 𝓤 β
h_β : (fun p => (p.fst.snd, p.snd.snd)) ⁻¹' r_β ⊆ t_β
p_α : (α × β) × α × β → α × α := fun p => (p.fst.fst, p.snd.fst)
⊢ ((a₁, b₁), a₂, b₂) ∈ t_α ∩ t_β
[PROOFSTEP]
let p_β := fun p : (α × β) × α × β => (p.1.2, p.2.2)
[GOAL]
case mpr.intro.intro.intro.intro.intro.intro.intro.intro.intro
α : Type u
β : Type v
γ : Type w
inst✝² : UniformSpace α
inst✝¹ : UniformSpace β
inst✝ : UniformSpace γ
a₁ a₂ : α
b₁ b₂ : β
eqv_α : a₁ ≈ a₂
eqv_β : b₁ ≈ b₂
t_α : Set ((α × β) × α × β)
r_α : Set (α × α)
r_α_in : r_α ∈ 𝓤 α
h_α : (fun p => (p.fst.fst, p.snd.fst)) ⁻¹' r_α ⊆ t_α
t_β : Set ((α × β) × α × β)
r_β : Set (β × β)
r_β_in : r_β ∈ 𝓤 β
h_β : (fun p => (p.fst.snd, p.snd.snd)) ⁻¹' r_β ⊆ t_β
p_α : (α × β) × α × β → α × α := fun p => (p.fst.fst, p.snd.fst)
p_β : (α × β) × α × β → β × β := fun p => (p.fst.snd, p.snd.snd)
⊢ ((a₁, b₁), a₂, b₂) ∈ t_α ∩ t_β
[PROOFSTEP]
have key_α : p_α ((a₁, b₁), (a₂, b₂)) ∈ r_α := by simp [eqv_α r_α r_α_in]
[GOAL]
α : Type u
β : Type v
γ : Type w
inst✝² : UniformSpace α
inst✝¹ : UniformSpace β
inst✝ : UniformSpace γ
a₁ a₂ : α
b₁ b₂ : β
eqv_α : a₁ ≈ a₂
eqv_β : b₁ ≈ b₂
t_α : Set ((α × β) × α × β)
r_α : Set (α × α)
r_α_in : r_α ∈ 𝓤 α
h_α : (fun p => (p.fst.fst, p.snd.fst)) ⁻¹' r_α ⊆ t_α
t_β : Set ((α × β) × α × β)
r_β : Set (β × β)
r_β_in : r_β ∈ 𝓤 β
h_β : (fun p => (p.fst.snd, p.snd.snd)) ⁻¹' r_β ⊆ t_β
p_α : (α × β) × α × β → α × α := fun p => (p.fst.fst, p.snd.fst)
p_β : (α × β) × α × β → β × β := fun p => (p.fst.snd, p.snd.snd)
⊢ p_α ((a₁, b₁), a₂, b₂) ∈ r_α
[PROOFSTEP]
simp [eqv_α r_α r_α_in]
[GOAL]
case mpr.intro.intro.intro.intro.intro.intro.intro.intro.intro
α : Type u
β : Type v
γ : Type w
inst✝² : UniformSpace α
inst✝¹ : UniformSpace β
inst✝ : UniformSpace γ
a₁ a₂ : α
b₁ b₂ : β
eqv_α : a₁ ≈ a₂
eqv_β : b₁ ≈ b₂
t_α : Set ((α × β) × α × β)
r_α : Set (α × α)
r_α_in : r_α ∈ 𝓤 α
h_α : (fun p => (p.fst.fst, p.snd.fst)) ⁻¹' r_α ⊆ t_α
t_β : Set ((α × β) × α × β)
r_β : Set (β × β)
r_β_in : r_β ∈ 𝓤 β
h_β : (fun p => (p.fst.snd, p.snd.snd)) ⁻¹' r_β ⊆ t_β
p_α : (α × β) × α × β → α × α := fun p => (p.fst.fst, p.snd.fst)
p_β : (α × β) × α × β → β × β := fun p => (p.fst.snd, p.snd.snd)
key_α : p_α ((a₁, b₁), a₂, b₂) ∈ r_α
⊢ ((a₁, b₁), a₂, b₂) ∈ t_α ∩ t_β
[PROOFSTEP]
have key_β : p_β ((a₁, b₁), (a₂, b₂)) ∈ r_β := by simp [eqv_β r_β r_β_in]
[GOAL]
α : Type u
β : Type v
γ : Type w
inst✝² : UniformSpace α
inst✝¹ : UniformSpace β
inst✝ : UniformSpace γ
a₁ a₂ : α
b₁ b₂ : β
eqv_α : a₁ ≈ a₂
eqv_β : b₁ ≈ b₂
t_α : Set ((α × β) × α × β)
r_α : Set (α × α)
r_α_in : r_α ∈ 𝓤 α
h_α : (fun p => (p.fst.fst, p.snd.fst)) ⁻¹' r_α ⊆ t_α
t_β : Set ((α × β) × α × β)
r_β : Set (β × β)
r_β_in : r_β ∈ 𝓤 β
h_β : (fun p => (p.fst.snd, p.snd.snd)) ⁻¹' r_β ⊆ t_β
p_α : (α × β) × α × β → α × α := fun p => (p.fst.fst, p.snd.fst)
p_β : (α × β) × α × β → β × β := fun p => (p.fst.snd, p.snd.snd)
key_α : p_α ((a₁, b₁), a₂, b₂) ∈ r_α
⊢ p_β ((a₁, b₁), a₂, b₂) ∈ r_β
[PROOFSTEP]
simp [eqv_β r_β r_β_in]
[GOAL]
case mpr.intro.intro.intro.intro.intro.intro.intro.intro.intro
α : Type u
β : Type v
γ : Type w
inst✝² : UniformSpace α
inst✝¹ : UniformSpace β
inst✝ : UniformSpace γ
a₁ a₂ : α
b₁ b₂ : β
eqv_α : a₁ ≈ a₂
eqv_β : b₁ ≈ b₂
t_α : Set ((α × β) × α × β)
r_α : Set (α × α)
r_α_in : r_α ∈ 𝓤 α
h_α : (fun p => (p.fst.fst, p.snd.fst)) ⁻¹' r_α ⊆ t_α
t_β : Set ((α × β) × α × β)
r_β : Set (β × β)
r_β_in : r_β ∈ 𝓤 β
h_β : (fun p => (p.fst.snd, p.snd.snd)) ⁻¹' r_β ⊆ t_β
p_α : (α × β) × α × β → α × α := fun p => (p.fst.fst, p.snd.fst)
p_β : (α × β) × α × β → β × β := fun p => (p.fst.snd, p.snd.snd)
key_α : p_α ((a₁, b₁), a₂, b₂) ∈ r_α
key_β : p_β ((a₁, b₁), a₂, b₂) ∈ r_β
⊢ ((a₁, b₁), a₂, b₂) ∈ t_α ∩ t_β
[PROOFSTEP]
exact ⟨h_α key_α, h_β key_β⟩


[GOAL]
G✝ : Type u_1
H : Type u_2
inst✝² : Mul G✝
inst✝¹ : Mul H
A✝ B✝ : Finset G✝
a0✝ b0✝ : G✝
G : Type u_3
inst✝ : Mul G
A B : Finset G
a0 b0 : G
h : UniqueMul A B a0 b0
x✝¹ x✝ : G
ha : x✝¹ ∈ A
hb : x✝ ∈ B
k : x✝¹ ≠ a0 ∨ x✝ ≠ b0
⊢ x✝¹ * x✝ ≠ a0 * b0
[PROOFSTEP]
contrapose! k
[GOAL]
G✝ : Type u_1
H : Type u_2
inst✝² : Mul G✝
inst✝¹ : Mul H
A✝ B✝ : Finset G✝
a0✝ b0✝ : G✝
G : Type u_3
inst✝ : Mul G
A B : Finset G
a0 b0 : G
h : UniqueMul A B a0 b0
x✝¹ x✝ : G
ha : x✝¹ ∈ A
hb : x✝ ∈ B
k : x✝¹ * x✝ = a0 * b0
⊢ x✝¹ = a0 ∧ x✝ = b0
[PROOFSTEP]
exact h ha hb k
[GOAL]
G : Type u_1
H : Type u_2
inst✝¹ : Mul G
inst✝ : Mul H
A✝ B✝ : Finset G
a0✝ b0✝ : G
A B : Finset G
a0 b0 : G
h : UniqueMul A B a0 b0
⊢ Set.Subsingleton {ab | ab.fst ∈ A ∧ ab.snd ∈ B ∧ ab.fst * ab.snd = a0 * b0}
[PROOFSTEP]
rintro ⟨x1, y1⟩ (hx : x1 ∈ A ∧ y1 ∈ B ∧ x1 * y1 = a0 * b0) ⟨x2, y2⟩ (hy : x2 ∈ A ∧ y2 ∈ B ∧ x2 * y2 = a0 * b0)
[GOAL]
case mk.mk
G : Type u_1
H : Type u_2
inst✝¹ : Mul G
inst✝ : Mul H
A✝ B✝ : Finset G
a0✝ b0✝ : G
A B : Finset G
a0 b0 : G
h : UniqueMul A B a0 b0
x1 y1 : G
hx : x1 ∈ A ∧ y1 ∈ B ∧ x1 * y1 = a0 * b0
x2 y2 : G
hy : x2 ∈ A ∧ y2 ∈ B ∧ x2 * y2 = a0 * b0
⊢ (x1, y1) = (x2, y2)
[PROOFSTEP]
rcases h hx.1 hx.2.1 hx.2.2 with ⟨rfl, rfl⟩
[GOAL]
case mk.mk.intro
G : Type u_1
H : Type u_2
inst✝¹ : Mul G
inst✝ : Mul H
A✝ B✝ : Finset G
a0 b0 : G
A B : Finset G
x1 y1 x2 y2 : G
h : UniqueMul A B x1 y1
hx : x1 ∈ A ∧ y1 ∈ B ∧ x1 * y1 = x1 * y1
hy : x2 ∈ A ∧ y2 ∈ B ∧ x2 * y2 = x1 * y1
⊢ (x1, y1) = (x2, y2)
[PROOFSTEP]
rcases h hy.1 hy.2.1 hy.2.2 with ⟨rfl, rfl⟩
[GOAL]
case mk.mk.intro.intro
G : Type u_1
H : Type u_2
inst✝¹ : Mul G
inst✝ : Mul H
A✝ B✝ : Finset G
a0 b0 : G
A B : Finset G
x2 y2 : G
h : UniqueMul A B x2 y2
hx hy : x2 ∈ A ∧ y2 ∈ B ∧ x2 * y2 = x2 * y2
⊢ (x2, y2) = (x2, y2)
[PROOFSTEP]
rfl
[GOAL]
G : Type u_1
H : Type u_2
inst✝¹ : Mul G
inst✝ : Mul H
A B : Finset G
a0 b0 : G
aA : a0 ∈ A
bB : b0 ∈ B
x✝ : UniqueMul A B a0 b0
⊢ ∀ (y : (a0, b0) ∈ A ×ˢ B), (fun x => (a0, b0).fst * (a0, b0).snd = a0 * b0) y → y = (_ : (a0, b0) ∈ A ×ˢ B)
[PROOFSTEP]
simp
[GOAL]
G : Type u_1
H : Type u_2
inst✝¹ : Mul G
inst✝ : Mul H
A B : Finset G
a0 b0 : G
aA : a0 ∈ A
bB : b0 ∈ B
x✝ : UniqueMul A B a0 b0
⊢ ∀ (y : G × G), (fun ab => ∃! x, ab.fst * ab.snd = a0 * b0) y → y = (a0, b0)
[PROOFSTEP]
simpa
[GOAL]
G : Type u_1
H : Type u_2
inst✝¹ : Mul G
inst✝ : Mul H
A B : Finset G
a0 b0 : G
aA : a0 ∈ A
bB : b0 ∈ B
h : ∃! ab x, ab.fst * ab.snd = a0 * b0
⊢ ∀ (x : G × G),
    x ∈ A ×ˢ B →
      x.fst * x.snd = a0 * b0 → (∀ (y : G × G), y ∈ A ×ˢ B → y.fst * y.snd = a0 * b0 → y = x) → UniqueMul A B a0 b0
[PROOFSTEP]
rintro ⟨x1, x2⟩ _ _ J x y hx hy l
[GOAL]
case mk
G : Type u_1
H : Type u_2
inst✝¹ : Mul G
inst✝ : Mul H
A B : Finset G
a0 b0 : G
aA : a0 ∈ A
bB : b0 ∈ B
h : ∃! ab x, ab.fst * ab.snd = a0 * b0
x1 x2 : G
h✝ : (x1, x2) ∈ A ×ˢ B
a✝ : (x1, x2).fst * (x1, x2).snd = a0 * b0
J : ∀ (y : G × G), y ∈ A ×ˢ B → y.fst * y.snd = a0 * b0 → y = (x1, x2)
x y : G
hx : x ∈ A
hy : y ∈ B
l : x * y = a0 * b0
⊢ x = a0 ∧ y = b0
[PROOFSTEP]
rcases Prod.mk.inj_iff.mp (J (a0, b0) (Finset.mk_mem_product aA bB) rfl) with ⟨rfl, rfl⟩
[GOAL]
case mk.intro
G : Type u_1
H : Type u_2
inst✝¹ : Mul G
inst✝ : Mul H
A B : Finset G
a0 b0 : G
aA : a0 ∈ A
bB : b0 ∈ B
h : ∃! ab x, ab.fst * ab.snd = a0 * b0
x y : G
hx : x ∈ A
hy : y ∈ B
l : x * y = a0 * b0
h✝ : (a0, b0) ∈ A ×ˢ B
a✝ : (a0, b0).fst * (a0, b0).snd = a0 * b0
J : ∀ (y : G × G), y ∈ A ×ˢ B → y.fst * y.snd = a0 * b0 → y = (a0, b0)
⊢ x = a0 ∧ y = b0
[PROOFSTEP]
exact Prod.mk.inj_iff.mp (J (x, y) (Finset.mk_mem_product hx hy) l)
[GOAL]
G : Type u_1
H : Type u_2
inst✝¹ : Mul G
inst✝ : Mul H
A B : Finset G
a0 b0 : G
x✝ : ∃ g, ∃! ab x, ab.fst * ab.snd = g
g : G
h : ∃! ab x, ab.fst * ab.snd = g
⊢ ∃ a0 b0, a0 ∈ A ∧ b0 ∈ B ∧ UniqueMul A B a0 b0
[PROOFSTEP]
have h' := h
[GOAL]
G : Type u_1
H : Type u_2
inst✝¹ : Mul G
inst✝ : Mul H
A B : Finset G
a0 b0 : G
x✝ : ∃ g, ∃! ab x, ab.fst * ab.snd = g
g : G
h h' : ∃! ab x, ab.fst * ab.snd = g
⊢ ∃ a0 b0, a0 ∈ A ∧ b0 ∈ B ∧ UniqueMul A B a0 b0
[PROOFSTEP]
rcases h' with ⟨⟨a, b⟩, ⟨hab, rfl, -⟩, -⟩
[GOAL]
case intro.mk.intro.intro.intro
G : Type u_1
H : Type u_2
inst✝¹ : Mul G
inst✝ : Mul H
A B : Finset G
a0 b0 : G
x✝ : ∃ g, ∃! ab x, ab.fst * ab.snd = g
a b : G
hab : (a, b) ∈ A ×ˢ B
h : ∃! ab x, ab.fst * ab.snd = (a, b).fst * (a, b).snd
⊢ ∃ a0 b0, a0 ∈ A ∧ b0 ∈ B ∧ UniqueMul A B a0 b0
[PROOFSTEP]
cases' Finset.mem_product.mp hab with ha hb
[GOAL]
case intro.mk.intro.intro.intro.intro
G : Type u_1
H : Type u_2
inst✝¹ : Mul G
inst✝ : Mul H
A B : Finset G
a0 b0 : G
x✝ : ∃ g, ∃! ab x, ab.fst * ab.snd = g
a b : G
hab : (a, b) ∈ A ×ˢ B
h : ∃! ab x, ab.fst * ab.snd = (a, b).fst * (a, b).snd
ha : (a, b).fst ∈ A
hb : (a, b).snd ∈ B
⊢ ∃ a0 b0, a0 ∈ A ∧ b0 ∈ B ∧ UniqueMul A B a0 b0
[PROOFSTEP]
exact ⟨a, b, ha, hb, (iff_existsUnique ha hb).mpr h⟩
[GOAL]
G : Type u_1
H : Type u_2
inst✝¹ : Mul G
inst✝ : Mul H
A✝ B✝ : Finset G
a0✝ b0✝ : G
f : G →ₙ* H
hf : Function.Injective ↑f
a0 b0 : G
A B : Finset H
u : UniqueMul A B (↑f a0) (↑f b0)
⊢ UniqueMul (Finset.preimage A ↑f (_ : Set.InjOn (↑f) (↑f ⁻¹' ↑A)))
    (Finset.preimage B ↑f (_ : Set.InjOn (↑f) (↑f ⁻¹' ↑B))) a0 b0
[PROOFSTEP]
intro a b ha hb ab
[GOAL]
G : Type u_1
H : Type u_2
inst✝¹ : Mul G
inst✝ : Mul H
A✝ B✝ : Finset G
a0✝ b0✝ : G
f : G →ₙ* H
hf : Function.Injective ↑f
a0 b0 : G
A B : Finset H
u : UniqueMul A B (↑f a0) (↑f b0)
a b : G
ha : a ∈ Finset.preimage A ↑f (_ : Set.InjOn (↑f) (↑f ⁻¹' ↑A))
hb : b ∈ Finset.preimage B ↑f (_ : Set.InjOn (↑f) (↑f ⁻¹' ↑B))
ab : a * b = a0 * b0
⊢ a = a0 ∧ b = b0
[PROOFSTEP]
rw [← hf.eq_iff, ← hf.eq_iff]
[GOAL]
G : Type u_1
H : Type u_2
inst✝¹ : Mul G
inst✝ : Mul H
A✝ B✝ : Finset G
a0✝ b0✝ : G
f : G →ₙ* H
hf : Function.Injective ↑f
a0 b0 : G
A B : Finset H
u : UniqueMul A B (↑f a0) (↑f b0)
a b : G
ha : a ∈ Finset.preimage A ↑f (_ : Set.InjOn (↑f) (↑f ⁻¹' ↑A))
hb : b ∈ Finset.preimage B ↑f (_ : Set.InjOn (↑f) (↑f ⁻¹' ↑B))
ab : a * b = a0 * b0
⊢ ↑f a = ↑f a0 ∧ ↑f b = ↑f b0
[PROOFSTEP]
rw [← hf.eq_iff, map_mul, map_mul] at ab
[GOAL]
G : Type u_1
H : Type u_2
inst✝¹ : Mul G
inst✝ : Mul H
A✝ B✝ : Finset G
a0✝ b0✝ : G
f : G →ₙ* H
hf : Function.Injective ↑f
a0 b0 : G
A B : Finset H
u : UniqueMul A B (↑f a0) (↑f b0)
a b : G
ha : a ∈ Finset.preimage A ↑f (_ : Set.InjOn (↑f) (↑f ⁻¹' ↑A))
hb : b ∈ Finset.preimage B ↑f (_ : Set.InjOn (↑f) (↑f ⁻¹' ↑B))
ab : ↑f a * ↑f b = ↑f a0 * ↑f b0
⊢ ↑f a = ↑f a0 ∧ ↑f b = ↑f b0
[PROOFSTEP]
exact u (Finset.mem_preimage.mp ha) (Finset.mem_preimage.mp hb) ab
[GOAL]
G : Type u_1
H : Type u_2
inst✝² : Mul G
inst✝¹ : Mul H
A B : Finset G
a0 b0 : G
inst✝ : DecidableEq H
f : G →ₙ* H
hf : Function.Injective ↑f
⊢ UniqueMul (Finset.image (↑f) A) (Finset.image (↑f) B) (↑f a0) (↑f b0) ↔ UniqueMul A B a0 b0
[PROOFSTEP]
refine' ⟨fun h ↦ _, fun h ↦ _⟩
[GOAL]
case refine'_1
G : Type u_1
H : Type u_2
inst✝² : Mul G
inst✝¹ : Mul H
A B : Finset G
a0 b0 : G
inst✝ : DecidableEq H
f : G →ₙ* H
hf : Function.Injective ↑f
h : UniqueMul (Finset.image (↑f) A) (Finset.image (↑f) B) (↑f a0) (↑f b0)
⊢ UniqueMul A B a0 b0
[PROOFSTEP]
intro a b ha hb ab
[GOAL]
case refine'_1
G : Type u_1
H : Type u_2
inst✝² : Mul G
inst✝¹ : Mul H
A B : Finset G
a0 b0 : G
inst✝ : DecidableEq H
f : G →ₙ* H
hf : Function.Injective ↑f
h : UniqueMul (Finset.image (↑f) A) (Finset.image (↑f) B) (↑f a0) (↑f b0)
a b : G
ha : a ∈ A
hb : b ∈ B
ab : a * b = a0 * b0
⊢ a = a0 ∧ b = b0
[PROOFSTEP]
rw [← hf.eq_iff, ← hf.eq_iff]
[GOAL]
case refine'_1
G : Type u_1
H : Type u_2
inst✝² : Mul G
inst✝¹ : Mul H
A B : Finset G
a0 b0 : G
inst✝ : DecidableEq H
f : G →ₙ* H
hf : Function.Injective ↑f
h : UniqueMul (Finset.image (↑f) A) (Finset.image (↑f) B) (↑f a0) (↑f b0)
a b : G
ha : a ∈ A
hb : b ∈ B
ab : a * b = a0 * b0
⊢ ↑f a = ↑f a0 ∧ ↑f b = ↑f b0
[PROOFSTEP]
rw [← hf.eq_iff, map_mul, map_mul] at ab
[GOAL]
case refine'_1
G : Type u_1
H : Type u_2
inst✝² : Mul G
inst✝¹ : Mul H
A B : Finset G
a0 b0 : G
inst✝ : DecidableEq H
f : G →ₙ* H
hf : Function.Injective ↑f
h : UniqueMul (Finset.image (↑f) A) (Finset.image (↑f) B) (↑f a0) (↑f b0)
a b : G
ha : a ∈ A
hb : b ∈ B
ab : ↑f a * ↑f b = ↑f a0 * ↑f b0
⊢ ↑f a = ↑f a0 ∧ ↑f b = ↑f b0
[PROOFSTEP]
exact h (Finset.mem_image.mpr ⟨_, ha, rfl⟩) (Finset.mem_image.mpr ⟨_, hb, rfl⟩) ab
[GOAL]
case refine'_2
G : Type u_1
H : Type u_2
inst✝² : Mul G
inst✝¹ : Mul H
A B : Finset G
a0 b0 : G
inst✝ : DecidableEq H
f : G →ₙ* H
hf : Function.Injective ↑f
h : UniqueMul A B a0 b0
⊢ UniqueMul (Finset.image (↑f) A) (Finset.image (↑f) B) (↑f a0) (↑f b0)
[PROOFSTEP]
intro a b aA bB ab
[GOAL]
case refine'_2
G : Type u_1
H : Type u_2
inst✝² : Mul G
inst✝¹ : Mul H
A B : Finset G
a0 b0 : G
inst✝ : DecidableEq H
f : G →ₙ* H
hf : Function.Injective ↑f
h : UniqueMul A B a0 b0
a b : H
aA : a ∈ Finset.image (↑f) A
bB : b ∈ Finset.image (↑f) B
ab : a * b = ↑f a0 * ↑f b0
⊢ a = ↑f a0 ∧ b = ↑f b0
[PROOFSTEP]
obtain ⟨a, ha, rfl⟩ : ∃ a' ∈ A, f a' = a := Finset.mem_image.mp aA
[GOAL]
case refine'_2.intro.intro
G : Type u_1
H : Type u_2
inst✝² : Mul G
inst✝¹ : Mul H
A B : Finset G
a0 b0 : G
inst✝ : DecidableEq H
f : G →ₙ* H
hf : Function.Injective ↑f
h : UniqueMul A B a0 b0
b : H
bB : b ∈ Finset.image (↑f) B
a : G
ha : a ∈ A
aA : ↑f a ∈ Finset.image (↑f) A
ab : ↑f a * b = ↑f a0 * ↑f b0
⊢ ↑f a = ↑f a0 ∧ b = ↑f b0
[PROOFSTEP]
obtain ⟨b, hb, rfl⟩ : ∃ b' ∈ B, f b' = b := Finset.mem_image.mp bB
[GOAL]
case refine'_2.intro.intro.intro.intro
G : Type u_1
H : Type u_2
inst✝² : Mul G
inst✝¹ : Mul H
A B : Finset G
a0 b0 : G
inst✝ : DecidableEq H
f : G →ₙ* H
hf : Function.Injective ↑f
h : UniqueMul A B a0 b0
a : G
ha : a ∈ A
aA : ↑f a ∈ Finset.image (↑f) A
b : G
hb : b ∈ B
bB : ↑f b ∈ Finset.image (↑f) B
ab : ↑f a * ↑f b = ↑f a0 * ↑f b0
⊢ ↑f a = ↑f a0 ∧ ↑f b = ↑f b0
[PROOFSTEP]
rw [hf.eq_iff, hf.eq_iff]
[GOAL]
case refine'_2.intro.intro.intro.intro
G : Type u_1
H : Type u_2
inst✝² : Mul G
inst✝¹ : Mul H
A B : Finset G
a0 b0 : G
inst✝ : DecidableEq H
f : G →ₙ* H
hf : Function.Injective ↑f
h : UniqueMul A B a0 b0
a : G
ha : a ∈ A
aA : ↑f a ∈ Finset.image (↑f) A
b : G
hb : b ∈ B
bB : ↑f b ∈ Finset.image (↑f) B
ab : ↑f a * ↑f b = ↑f a0 * ↑f b0
⊢ a = a0 ∧ b = b0
[PROOFSTEP]
rw [← map_mul, ← map_mul, hf.eq_iff] at ab
[GOAL]
case refine'_2.intro.intro.intro.intro
G : Type u_1
H : Type u_2
inst✝² : Mul G
inst✝¹ : Mul H
A B : Finset G
a0 b0 : G
inst✝ : DecidableEq H
f : G →ₙ* H
hf : Function.Injective ↑f
h : UniqueMul A B a0 b0
a : G
ha : a ∈ A
aA : ↑f a ∈ Finset.image (↑f) A
b : G
hb : b ∈ B
bB : ↑f b ∈ Finset.image (↑f) B
ab : a * b = a0 * b0
⊢ a = a0 ∧ b = b0
[PROOFSTEP]
exact h ha hb ab
[GOAL]
G : Type u_1
H : Type u_2
inst✝¹ : Mul G
inst✝ : Mul H
A B : Finset G
a0 b0 : G
f : G ↪ H
mul : ∀ (x y : G), ↑f (x * y) = ↑f x * ↑f y
⊢ UniqueMul (Finset.map f A) (Finset.map f B) (↑f a0) (↑f b0) ↔ UniqueMul A B a0 b0
[PROOFSTEP]
classical convert @mulHom_image_iff G H _ _ A B a0 b0 _ ⟨f, mul⟩ f.2 using 2 <;>
  · ext
    simp only [Finset.mem_map, MulHom.coe_mk, Finset.mem_image]
[GOAL]
G : Type u_1
H : Type u_2
inst✝¹ : Mul G
inst✝ : Mul H
A B : Finset G
a0 b0 : G
f : G ↪ H
mul : ∀ (x y : G), ↑f (x * y) = ↑f x * ↑f y
⊢ UniqueMul (Finset.map f A) (Finset.map f B) (↑f a0) (↑f b0) ↔ UniqueMul A B a0 b0
[PROOFSTEP]
convert @mulHom_image_iff G H _ _ A B a0 b0 _ ⟨f, mul⟩ f.2 using 2
[GOAL]
case h.e'_1.h.e'_3
G : Type u_1
H : Type u_2
inst✝¹ : Mul G
inst✝ : Mul H
A B : Finset G
a0 b0 : G
f : G ↪ H
mul : ∀ (x y : G), ↑f (x * y) = ↑f x * ↑f y
⊢ Finset.map f A = Finset.image (↑{ toFun := ↑f, map_mul' := mul }) A
[PROOFSTEP]
ext
[GOAL]
case h.e'_1.h.e'_3.a
G : Type u_1
H : Type u_2
inst✝¹ : Mul G
inst✝ : Mul H
A B : Finset G
a0 b0 : G
f : G ↪ H
mul : ∀ (x y : G), ↑f (x * y) = ↑f x * ↑f y
a✝ : H
⊢ a✝ ∈ Finset.map f A ↔ a✝ ∈ Finset.image (↑{ toFun := ↑f, map_mul' := mul }) A
[PROOFSTEP]
simp only [Finset.mem_map, MulHom.coe_mk, Finset.mem_image]
[GOAL]
case h.e'_1.h.e'_4
G : Type u_1
H : Type u_2
inst✝¹ : Mul G
inst✝ : Mul H
A B : Finset G
a0 b0 : G
f : G ↪ H
mul : ∀ (x y : G), ↑f (x * y) = ↑f x * ↑f y
⊢ Finset.map f B = Finset.image (↑{ toFun := ↑f, map_mul' := mul }) B
[PROOFSTEP]
ext
[GOAL]
case h.e'_1.h.e'_4.a
G : Type u_1
H : Type u_2
inst✝¹ : Mul G
inst✝ : Mul H
A B : Finset G
a0 b0 : G
f : G ↪ H
mul : ∀ (x y : G), ↑f (x * y) = ↑f x * ↑f y
a✝ : H
⊢ a✝ ∈ Finset.map f B ↔ a✝ ∈ Finset.image (↑{ toFun := ↑f, map_mul' := mul }) B
[PROOFSTEP]
simp only [Finset.mem_map, MulHom.coe_mk, Finset.mem_image]
[GOAL]
M : Type ?u.148083
inst✝¹ : Add M
inst✝ : UniqueSums M
A B : Finset (Multiplicative M)
hA : Finset.Nonempty A
hB : Finset.Nonempty B
⊢ ∃ a0, a0 ∈ A ∧ ∃ b0, b0 ∈ B ∧ UniqueMul A B a0 b0
[PROOFSTEP]
let A' : Finset M := A
[GOAL]
M : Type ?u.148083
inst✝¹ : Add M
inst✝ : UniqueSums M
A B : Finset (Multiplicative M)
hA : Finset.Nonempty A
hB : Finset.Nonempty B
A' : Finset M := A
⊢ ∃ a0, a0 ∈ A ∧ ∃ b0, b0 ∈ B ∧ UniqueMul A B a0 b0
[PROOFSTEP]
have hA' : A'.Nonempty := hA
[GOAL]
M : Type ?u.148083
inst✝¹ : Add M
inst✝ : UniqueSums M
A B : Finset (Multiplicative M)
hA : Finset.Nonempty A
hB : Finset.Nonempty B
A' : Finset M := A
hA' : Finset.Nonempty A'
⊢ ∃ a0, a0 ∈ A ∧ ∃ b0, b0 ∈ B ∧ UniqueMul A B a0 b0
[PROOFSTEP]
obtain ⟨a0, hA0, b0, hB0, J⟩ := UniqueSums.uniqueAdd_of_nonempty hA' hB
[GOAL]
case intro.intro.intro.intro
M : Type ?u.148083
inst✝¹ : Add M
inst✝ : UniqueSums M
A B : Finset (Multiplicative M)
hA : Finset.Nonempty A
hB : Finset.Nonempty B
A' : Finset M := A
hA' : Finset.Nonempty A'
a0 : M
hA0 : a0 ∈ A'
b0 : M
hB0 : b0 ∈ B
J : UniqueAdd A' B a0 b0
⊢ ∃ a0, a0 ∈ A ∧ ∃ b0, b0 ∈ B ∧ UniqueMul A B a0 b0
[PROOFSTEP]
exact ⟨ofAdd a0, hA0, ofAdd b0, hB0, fun a b aA bB H ↦ J aA bB H⟩
[GOAL]
M : Type ?u.148565
inst✝¹ : Mul M
inst✝ : UniqueProds M
A B : Finset (Additive M)
hA : Finset.Nonempty A
hB : Finset.Nonempty B
⊢ ∃ a0, a0 ∈ A ∧ ∃ b0, b0 ∈ B ∧ UniqueAdd A B a0 b0
[PROOFSTEP]
let A' : Finset M := A
[GOAL]
M : Type ?u.148565
inst✝¹ : Mul M
inst✝ : UniqueProds M
A B : Finset (Additive M)
hA : Finset.Nonempty A
hB : Finset.Nonempty B
A' : Finset M := A
⊢ ∃ a0, a0 ∈ A ∧ ∃ b0, b0 ∈ B ∧ UniqueAdd A B a0 b0
[PROOFSTEP]
have hA' : A'.Nonempty := hA
[GOAL]
M : Type ?u.148565
inst✝¹ : Mul M
inst✝ : UniqueProds M
A B : Finset (Additive M)
hA : Finset.Nonempty A
hB : Finset.Nonempty B
A' : Finset M := A
hA' : Finset.Nonempty A'
⊢ ∃ a0, a0 ∈ A ∧ ∃ b0, b0 ∈ B ∧ UniqueAdd A B a0 b0
[PROOFSTEP]
obtain ⟨a0, hA0, b0, hB0, J⟩ := UniqueProds.uniqueMul_of_nonempty hA' hB
[GOAL]
case intro.intro.intro.intro
M : Type ?u.148565
inst✝¹ : Mul M
inst✝ : UniqueProds M
A B : Finset (Additive M)
hA : Finset.Nonempty A
hB : Finset.Nonempty B
A' : Finset M := A
hA' : Finset.Nonempty A'
a0 : M
hA0 : a0 ∈ A'
b0 : M
hB0 : b0 ∈ B
J : UniqueMul A' B a0 b0
⊢ ∃ a0, a0 ∈ A ∧ ∃ b0, b0 ∈ B ∧ UniqueAdd A B a0 b0
[PROOFSTEP]
exact ⟨ofMul a0, hA0, ofMul b0, hB0, fun a b aA bB H ↦ J aA bB H⟩


[GOAL]
C : Type u_1
inst✝⁵ : Category.{?u.9027, u_1} C
inst✝⁴ : Preadditive C
inst✝³ : HasZeroObject C
inst✝² : HasShift C ℤ
inst✝¹ : ∀ (n : ℤ), Functor.Additive (shiftFunctor C n)
inst✝ : Pretriangulated C
X : C
⊢ Nonempty
    (Octahedron (_ : 𝟙 X ≫ 𝟙 X = 𝟙 X) (_ : contractibleTriangle X ∈ distinguishedTriangles)
      (_ : contractibleTriangle X ∈ distinguishedTriangles) (_ : contractibleTriangle X ∈ distinguishedTriangles))
[PROOFSTEP]
refine'
  ⟨⟨0, 0, _, _, _, _,
      isomorphic_distinguished _ (contractible_distinguished (0 : C)) _
        (Triangle.isoMk _ _ (by rfl) (by rfl) (by rfl))⟩⟩
[GOAL]
C : Type u_1
inst✝⁵ : Category.{?u.9027, u_1} C
inst✝⁴ : Preadditive C
inst✝³ : HasZeroObject C
inst✝² : HasShift C ℤ
inst✝¹ : ∀ (n : ℤ), Functor.Additive (shiftFunctor C n)
inst✝ : Pretriangulated C
X : C
⊢ (Triangle.mk 0 0 (0 ≫ (shiftFunctor C 1).map 0)).obj₁ ≅ (contractibleTriangle 0).obj₁
[PROOFSTEP]
rfl
[GOAL]
C : Type u_1
inst✝⁵ : Category.{?u.9027, u_1} C
inst✝⁴ : Preadditive C
inst✝³ : HasZeroObject C
inst✝² : HasShift C ℤ
inst✝¹ : ∀ (n : ℤ), Functor.Additive (shiftFunctor C n)
inst✝ : Pretriangulated C
X : C
⊢ (Triangle.mk 0 0 (0 ≫ (shiftFunctor C 1).map 0)).obj₂ ≅ (contractibleTriangle 0).obj₂
[PROOFSTEP]
rfl
[GOAL]
C : Type u_1
inst✝⁵ : Category.{?u.9027, u_1} C
inst✝⁴ : Preadditive C
inst✝³ : HasZeroObject C
inst✝² : HasShift C ℤ
inst✝¹ : ∀ (n : ℤ), Functor.Additive (shiftFunctor C n)
inst✝ : Pretriangulated C
X : C
⊢ (Triangle.mk 0 0 (0 ≫ (shiftFunctor C 1).map 0)).obj₃ ≅ (contractibleTriangle 0).obj₃
[PROOFSTEP]
rfl
[GOAL]
case refine'_1
C : Type u_1
inst✝⁵ : Category.{?u.9027, u_1} C
inst✝⁴ : Preadditive C
inst✝³ : HasZeroObject C
inst✝² : HasShift C ℤ
inst✝¹ : ∀ (n : ℤ), Functor.Additive (shiftFunctor C n)
inst✝ : Pretriangulated C
X : C
⊢ 0 ≫ 0 = 𝟙 X ≫ 0
case refine'_2
C : Type u_1
inst✝⁵ : Category.{?u.9027, u_1} C
inst✝⁴ : Preadditive C
inst✝³ : HasZeroObject C
inst✝² : HasShift C ℤ
inst✝¹ : ∀ (n : ℤ), Functor.Additive (shiftFunctor C n)
inst✝ : Pretriangulated C
X : C
⊢ 0 ≫ 0 = 0
case refine'_3
C : Type u_1
inst✝⁵ : Category.{?u.9027, u_1} C
inst✝⁴ : Preadditive C
inst✝³ : HasZeroObject C
inst✝² : HasShift C ℤ
inst✝¹ : ∀ (n : ℤ), Functor.Additive (shiftFunctor C n)
inst✝ : Pretriangulated C
X : C
⊢ 0 ≫ 0 = 0
case refine'_4
C : Type u_1
inst✝⁵ : Category.{?u.9027, u_1} C
inst✝⁴ : Preadditive C
inst✝³ : HasZeroObject C
inst✝² : HasShift C ℤ
inst✝¹ : ∀ (n : ℤ), Functor.Additive (shiftFunctor C n)
inst✝ : Pretriangulated C
X : C
⊢ 0 ≫ (shiftFunctor C 1).map (𝟙 X) = 0 ≫ 0
[PROOFSTEP]
all_goals apply Subsingleton.elim
[GOAL]
case refine'_1
C : Type u_1
inst✝⁵ : Category.{?u.9027, u_1} C
inst✝⁴ : Preadditive C
inst✝³ : HasZeroObject C
inst✝² : HasShift C ℤ
inst✝¹ : ∀ (n : ℤ), Functor.Additive (shiftFunctor C n)
inst✝ : Pretriangulated C
X : C
⊢ 0 ≫ 0 = 𝟙 X ≫ 0
[PROOFSTEP]
apply Subsingleton.elim
[GOAL]
case refine'_2
C : Type u_1
inst✝⁵ : Category.{?u.9027, u_1} C
inst✝⁴ : Preadditive C
inst✝³ : HasZeroObject C
inst✝² : HasShift C ℤ
inst✝¹ : ∀ (n : ℤ), Functor.Additive (shiftFunctor C n)
inst✝ : Pretriangulated C
X : C
⊢ 0 ≫ 0 = 0
[PROOFSTEP]
apply Subsingleton.elim
[GOAL]
case refine'_3
C : Type u_1
inst✝⁵ : Category.{?u.9027, u_1} C
inst✝⁴ : Preadditive C
inst✝³ : HasZeroObject C
inst✝² : HasShift C ℤ
inst✝¹ : ∀ (n : ℤ), Functor.Additive (shiftFunctor C n)
inst✝ : Pretriangulated C
X : C
⊢ 0 ≫ 0 = 0
[PROOFSTEP]
apply Subsingleton.elim
[GOAL]
case refine'_4
C : Type u_1
inst✝⁵ : Category.{?u.9027, u_1} C
inst✝⁴ : Preadditive C
inst✝³ : HasZeroObject C
inst✝² : HasShift C ℤ
inst✝¹ : ∀ (n : ℤ), Functor.Additive (shiftFunctor C n)
inst✝ : Pretriangulated C
X : C
⊢ 0 ≫ (shiftFunctor C 1).map (𝟙 X) = 0 ≫ 0
[PROOFSTEP]
apply Subsingleton.elim
[GOAL]
C : Type u_1
inst✝⁵ : Category.{?u.25095, u_1} C
inst✝⁴ : Preadditive C
inst✝³ : HasZeroObject C
inst✝² : HasShift C ℤ
inst✝¹ : ∀ (n : ℤ), Functor.Additive (shiftFunctor C n)
inst✝ : Pretriangulated C
X₁ X₂ X₃ Z₁₂ Z₂₃ Z₁₃ : C
u₁₂ : X₁ ⟶ X₂
u₂₃ : X₂ ⟶ X₃
u₁₃ : X₁ ⟶ X₃
comm : u₁₂ ≫ u₂₃ = u₁₃
v₁₂ : X₂ ⟶ Z₁₂
w₁₂ : Z₁₂ ⟶ (shiftFunctor C 1).obj X₁
h₁₂ : Triangle.mk u₁₂ v₁₂ w₁₂ ∈ distinguishedTriangles
v₂₃ : X₃ ⟶ Z₂₃
w₂₃ : Z₂₃ ⟶ (shiftFunctor C 1).obj X₂
h₂₃ : Triangle.mk u₂₃ v₂₃ w₂₃ ∈ distinguishedTriangles
v₁₃ : X₃ ⟶ Z₁₃
w₁₃ : Z₁₃ ⟶ (shiftFunctor C 1).obj X₁
h₁₃ : Triangle.mk u₁₃ v₁₃ w₁₃ ∈ distinguishedTriangles
h : Octahedron comm h₁₂ h₂₃ h₁₃
⊢ (Triangle.mk u₁₂ v₁₂ w₁₂).mor₁ ≫ u₂₃ = 𝟙 X₁ ≫ (Triangle.mk u₁₃ v₁₃ w₁₃).mor₁
[PROOFSTEP]
dsimp
[GOAL]
C : Type u_1
inst✝⁵ : Category.{?u.25095, u_1} C
inst✝⁴ : Preadditive C
inst✝³ : HasZeroObject C
inst✝² : HasShift C ℤ
inst✝¹ : ∀ (n : ℤ), Functor.Additive (shiftFunctor C n)
inst✝ : Pretriangulated C
X₁ X₂ X₃ Z₁₂ Z₂₃ Z₁₃ : C
u₁₂ : X₁ ⟶ X₂
u₂₃ : X₂ ⟶ X₃
u₁₃ : X₁ ⟶ X₃
comm : u₁₂ ≫ u₂₃ = u₁₃
v₁₂ : X₂ ⟶ Z₁₂
w₁₂ : Z₁₂ ⟶ (shiftFunctor C 1).obj X₁
h₁₂ : Triangle.mk u₁₂ v₁₂ w₁₂ ∈ distinguishedTriangles
v₂₃ : X₃ ⟶ Z₂₃
w₂₃ : Z₂₃ ⟶ (shiftFunctor C 1).obj X₂
h₂₃ : Triangle.mk u₂₃ v₂₃ w₂₃ ∈ distinguishedTriangles
v₁₃ : X₃ ⟶ Z₁₃
w₁₃ : Z₁₃ ⟶ (shiftFunctor C 1).obj X₁
h₁₃ : Triangle.mk u₁₃ v₁₃ w₁₃ ∈ distinguishedTriangles
h : Octahedron comm h₁₂ h₂₃ h₁₃
⊢ u₁₂ ≫ u₂₃ = 𝟙 X₁ ≫ u₁₃
[PROOFSTEP]
rw [id_comp, comm]
[GOAL]
C : Type u_1
inst✝⁵ : Category.{?u.25095, u_1} C
inst✝⁴ : Preadditive C
inst✝³ : HasZeroObject C
inst✝² : HasShift C ℤ
inst✝¹ : ∀ (n : ℤ), Functor.Additive (shiftFunctor C n)
inst✝ : Pretriangulated C
X₁ X₂ X₃ Z₁₂ Z₂₃ Z₁₃ : C
u₁₂ : X₁ ⟶ X₂
u₂₃ : X₂ ⟶ X₃
u₁₃ : X₁ ⟶ X₃
comm : u₁₂ ≫ u₂₃ = u₁₃
v₁₂ : X₂ ⟶ Z₁₂
w₁₂ : Z₁₂ ⟶ (shiftFunctor C 1).obj X₁
h₁₂ : Triangle.mk u₁₂ v₁₂ w₁₂ ∈ distinguishedTriangles
v₂₃ : X₃ ⟶ Z₂₃
w₂₃ : Z₂₃ ⟶ (shiftFunctor C 1).obj X₂
h₂₃ : Triangle.mk u₂₃ v₂₃ w₂₃ ∈ distinguishedTriangles
v₁₃ : X₃ ⟶ Z₁₃
w₁₃ : Z₁₃ ⟶ (shiftFunctor C 1).obj X₁
h₁₃ : Triangle.mk u₁₃ v₁₃ w₁₃ ∈ distinguishedTriangles
h : Octahedron comm h₁₂ h₂₃ h₁₃
⊢ (Triangle.mk u₁₂ v₁₂ w₁₂).mor₃ ≫ (shiftFunctor C 1).map (𝟙 X₁) = h.m₁ ≫ (Triangle.mk u₁₃ v₁₃ w₁₃).mor₃
[PROOFSTEP]
dsimp
[GOAL]
C : Type u_1
inst✝⁵ : Category.{?u.25095, u_1} C
inst✝⁴ : Preadditive C
inst✝³ : HasZeroObject C
inst✝² : HasShift C ℤ
inst✝¹ : ∀ (n : ℤ), Functor.Additive (shiftFunctor C n)
inst✝ : Pretriangulated C
X₁ X₂ X₃ Z₁₂ Z₂₃ Z₁₃ : C
u₁₂ : X₁ ⟶ X₂
u₂₃ : X₂ ⟶ X₃
u₁₃ : X₁ ⟶ X₃
comm : u₁₂ ≫ u₂₃ = u₁₃
v₁₂ : X₂ ⟶ Z₁₂
w₁₂ : Z₁₂ ⟶ (shiftFunctor C 1).obj X₁
h₁₂ : Triangle.mk u₁₂ v₁₂ w₁₂ ∈ distinguishedTriangles
v₂₃ : X₃ ⟶ Z₂₃
w₂₃ : Z₂₃ ⟶ (shiftFunctor C 1).obj X₂
h₂₃ : Triangle.mk u₂₃ v₂₃ w₂₃ ∈ distinguishedTriangles
v₁₃ : X₃ ⟶ Z₁₃
w₁₃ : Z₁₃ ⟶ (shiftFunctor C 1).obj X₁
h₁₃ : Triangle.mk u₁₃ v₁₃ w₁₃ ∈ distinguishedTriangles
h : Octahedron comm h₁₂ h₂₃ h₁₃
⊢ w₁₂ ≫ (shiftFunctor C 1).map (𝟙 X₁) = h.m₁ ≫ w₁₃
[PROOFSTEP]
simpa only [Functor.map_id, comp_id] using h.comm₂.symm
[GOAL]
C : Type u_1
inst✝⁵ : Category.{?u.30829, u_1} C
inst✝⁴ : Preadditive C
inst✝³ : HasZeroObject C
inst✝² : HasShift C ℤ
inst✝¹ : ∀ (n : ℤ), Functor.Additive (shiftFunctor C n)
inst✝ : Pretriangulated C
X₁ X₂ X₃ Z₁₂ Z₂₃ Z₁₃ : C
u₁₂ : X₁ ⟶ X₂
u₂₃ : X₂ ⟶ X₃
u₁₃ : X₁ ⟶ X₃
comm : u₁₂ ≫ u₂₃ = u₁₃
v₁₂ : X₂ ⟶ Z₁₂
w₁₂ : Z₁₂ ⟶ (shiftFunctor C 1).obj X₁
h₁₂ : Triangle.mk u₁₂ v₁₂ w₁₂ ∈ distinguishedTriangles
v₂₃ : X₃ ⟶ Z₂₃
w₂₃ : Z₂₃ ⟶ (shiftFunctor C 1).obj X₂
h₂₃ : Triangle.mk u₂₃ v₂₃ w₂₃ ∈ distinguishedTriangles
v₁₃ : X₃ ⟶ Z₁₃
w₁₃ : Z₁₃ ⟶ (shiftFunctor C 1).obj X₁
h₁₃ : Triangle.mk u₁₃ v₁₃ w₁₃ ∈ distinguishedTriangles
h : Octahedron comm h₁₂ h₂₃ h₁₃
⊢ (Triangle.mk u₁₃ v₁₃ w₁₃).mor₁ ≫ 𝟙 X₃ = u₁₂ ≫ (Triangle.mk u₂₃ v₂₃ w₂₃).mor₁
[PROOFSTEP]
dsimp
[GOAL]
C : Type u_1
inst✝⁵ : Category.{?u.30829, u_1} C
inst✝⁴ : Preadditive C
inst✝³ : HasZeroObject C
inst✝² : HasShift C ℤ
inst✝¹ : ∀ (n : ℤ), Functor.Additive (shiftFunctor C n)
inst✝ : Pretriangulated C
X₁ X₂ X₃ Z₁₂ Z₂₃ Z₁₃ : C
u₁₂ : X₁ ⟶ X₂
u₂₃ : X₂ ⟶ X₃
u₁₃ : X₁ ⟶ X₃
comm : u₁₂ ≫ u₂₃ = u₁₃
v₁₂ : X₂ ⟶ Z₁₂
w₁₂ : Z₁₂ ⟶ (shiftFunctor C 1).obj X₁
h₁₂ : Triangle.mk u₁₂ v₁₂ w₁₂ ∈ distinguishedTriangles
v₂₃ : X₃ ⟶ Z₂₃
w₂₃ : Z₂₃ ⟶ (shiftFunctor C 1).obj X₂
h₂₃ : Triangle.mk u₂₃ v₂₃ w₂₃ ∈ distinguishedTriangles
v₁₃ : X₃ ⟶ Z₁₃
w₁₃ : Z₁₃ ⟶ (shiftFunctor C 1).obj X₁
h₁₃ : Triangle.mk u₁₃ v₁₃ w₁₃ ∈ distinguishedTriangles
h : Octahedron comm h₁₂ h₂₃ h₁₃
⊢ u₁₃ ≫ 𝟙 X₃ = u₁₂ ≫ u₂₃
[PROOFSTEP]
rw [comp_id, comm]
[GOAL]
C : Type u_1
inst✝⁵ : Category.{?u.30829, u_1} C
inst✝⁴ : Preadditive C
inst✝³ : HasZeroObject C
inst✝² : HasShift C ℤ
inst✝¹ : ∀ (n : ℤ), Functor.Additive (shiftFunctor C n)
inst✝ : Pretriangulated C
X₁ X₂ X₃ Z₁₂ Z₂₃ Z₁₃ : C
u₁₂ : X₁ ⟶ X₂
u₂₃ : X₂ ⟶ X₃
u₁₃ : X₁ ⟶ X₃
comm : u₁₂ ≫ u₂₃ = u₁₃
v₁₂ : X₂ ⟶ Z₁₂
w₁₂ : Z₁₂ ⟶ (shiftFunctor C 1).obj X₁
h₁₂ : Triangle.mk u₁₂ v₁₂ w₁₂ ∈ distinguishedTriangles
v₂₃ : X₃ ⟶ Z₂₃
w₂₃ : Z₂₃ ⟶ (shiftFunctor C 1).obj X₂
h₂₃ : Triangle.mk u₂₃ v₂₃ w₂₃ ∈ distinguishedTriangles
v₁₃ : X₃ ⟶ Z₁₃
w₁₃ : Z₁₃ ⟶ (shiftFunctor C 1).obj X₁
h₁₃ : Triangle.mk u₁₃ v₁₃ w₁₃ ∈ distinguishedTriangles
h : Octahedron comm h₁₂ h₂₃ h₁₃
⊢ (Triangle.mk u₁₃ v₁₃ w₁₃).mor₂ ≫ h.m₃ = 𝟙 X₃ ≫ (Triangle.mk u₂₃ v₂₃ w₂₃).mor₂
[PROOFSTEP]
dsimp
[GOAL]
C : Type u_1
inst✝⁵ : Category.{?u.30829, u_1} C
inst✝⁴ : Preadditive C
inst✝³ : HasZeroObject C
inst✝² : HasShift C ℤ
inst✝¹ : ∀ (n : ℤ), Functor.Additive (shiftFunctor C n)
inst✝ : Pretriangulated C
X₁ X₂ X₃ Z₁₂ Z₂₃ Z₁₃ : C
u₁₂ : X₁ ⟶ X₂
u₂₃ : X₂ ⟶ X₃
u₁₃ : X₁ ⟶ X₃
comm : u₁₂ ≫ u₂₃ = u₁₃
v₁₂ : X₂ ⟶ Z₁₂
w₁₂ : Z₁₂ ⟶ (shiftFunctor C 1).obj X₁
h₁₂ : Triangle.mk u₁₂ v₁₂ w₁₂ ∈ distinguishedTriangles
v₂₃ : X₃ ⟶ Z₂₃
w₂₃ : Z₂₃ ⟶ (shiftFunctor C 1).obj X₂
h₂₃ : Triangle.mk u₂₃ v₂₃ w₂₃ ∈ distinguishedTriangles
v₁₃ : X₃ ⟶ Z₁₃
w₁₃ : Z₁₃ ⟶ (shiftFunctor C 1).obj X₁
h₁₃ : Triangle.mk u₁₃ v₁₃ w₁₃ ∈ distinguishedTriangles
h : Octahedron comm h₁₂ h₂₃ h₁₃
⊢ v₁₃ ≫ h.m₃ = 𝟙 X₃ ≫ v₂₃
[PROOFSTEP]
rw [id_comp, h.comm₃]