l3lab/ntp-mathlib huggingface dataset:
@[ext]
lemma ext' (e e' : Pretrivialization F proj) (h₁ : e.toPartialEquiv = e'.toPartialEquiv)
    (h₂ : e.baseSet = e'.baseSet) : e = e' := by
  cases e; cases e'; 

Proof state:
case mk.mk
ι : Type u_1
B : Type u_2
F : Type u_3
E : B → Type u_4
Z : Type u_5
inst✝¹ : TopologicalSpace B
inst✝ : TopologicalSpace F
proj : Z → B
e : Pretrivialization F proj
x : Z
toPartialEquiv✝¹ : PartialEquiv Z (B × F)
open_target✝¹ : IsOpen toPartialEquiv✝¹.target
baseSet✝¹ : Set B
open_baseSet✝¹ : IsOpen baseSet✝¹
source_eq✝¹ : toPartialEquiv✝¹.source = proj ⁻¹' baseSet✝¹
target_eq✝¹ : toPartialEquiv✝¹.target = baseSet✝¹ ×ˢ univ
proj_toFun✝¹ : ∀ p ∈ toPartialEquiv✝¹.source, (↑toPartialEquiv✝¹ p).1 = proj p
toPartialEquiv✝ : PartialEquiv Z (B × F)
open_target✝ : IsOpen toPartialEquiv✝.target
baseSet✝ : Set B
open_baseSet✝ : IsOpen baseSet✝
source_eq✝ : toPartialEquiv✝.source = proj ⁻¹' baseSet✝
target_eq✝ : toPartialEquiv✝.target = baseSet✝ ×ˢ univ
proj_toFun✝ : ∀ p ∈ toPartialEquiv✝.source, (↑toPartialEquiv✝ p).1 = proj p
h₁ :
  { toPartialEquiv := toPartialEquiv✝¹, open_target := open_target✝¹, baseSet := baseSet✝¹,
        open_baseSet := open_baseSet✝¹, source_eq := source_eq✝¹, target_eq := target_eq✝¹,
        proj_toFun := proj_toFun✝¹ }.toPartialEquiv =
    { toPartialEquiv := toPartialEquiv✝, open_target := open_target✝, baseSet := baseSet✝,
        open_baseSet := open_baseSet✝, source_eq := source_eq✝, target_eq := target_eq✝,
        proj_toFun := proj_toFun✝ }.toPartialEquiv
h₂ :
  { toPartialEquiv := toPartialEquiv✝¹, open_target := open_target✝¹, baseSet := baseSet✝¹,
        open_baseSet := open_baseSet✝¹, source_eq := source_eq✝¹, target_eq := target_eq✝¹,
        proj_toFun := proj_toFun✝¹ }.baseSet =
    { toPartialEquiv := toPartialEquiv✝, open_target := open_target✝, baseSet := baseSet✝,
        open_baseSet := open_baseSet✝, source_eq := source_eq✝, target_eq := target_eq✝,
        proj_toFun := proj_toFun✝ }.baseSet
⊢ { toPartialEquiv := toPartialEquiv✝¹, open_target := open_target✝¹, baseSet := baseSet✝¹,
      open_baseSet := open_baseSet✝¹, source_eq := source_eq✝¹, target_eq := target_eq✝¹, proj_toFun := proj_toFun✝¹ } =
    { toPartialEquiv := toPartialEquiv✝, open_target := open_target✝, baseSet := baseSet✝,
      open_baseSet := open_baseSet✝, source_eq := source_eq✝, target_eq := target_eq✝, proj_toFun := proj_toFun✝ }

Next tactic:
congr
lemma ext {e e' : Pretrivialization F proj} (h₁ : ∀ x, e x = e' x)
    (h₂ : ∀ x, e.toPartialEquiv.symm x = e'.toPartialEquiv.symm x) (h₃ : e.baseSet = e'.baseSet) :
    e = e' := by
  

Proof state:
ι : Type u_1
B : Type u_2
F : Type u_3
E : B → Type u_4
Z : Type u_5
inst✝¹ : TopologicalSpace B
inst✝ : TopologicalSpace F
proj : Z → B
e✝ : Pretrivialization F proj
x : Z
e e' : Pretrivialization F proj
h₁ : ∀ (x : Z), ↑e x = ↑e' x
h₂ : ∀ (x : B × F), ↑(PartialEquiv.symm e.toPartialEquiv) x = ↑(PartialEquiv.symm e'.toPartialEquiv) x
h₃ : e.baseSet = e'.baseSet
⊢ e = e'

Next tactic:
ext1 <;> [ext1; exact h₃]
lemma ext {e e' : Pretrivialization F proj} (h₁ : ∀ x, e x = e' x)
    (h₂ : ∀ x, e.toPartialEquiv.symm x = e'.toPartialEquiv.symm x) (h₃ : e.baseSet = e'.baseSet) :
    e = e' := by
  

Proof state:
ι : Type u_1
B : Type u_2
F : Type u_3
E : B → Type u_4
Z : Type u_5
inst✝¹ : TopologicalSpace B
inst✝ : TopologicalSpace F
proj : Z → B
e✝ : Pretrivialization F proj
x : Z
e e' : Pretrivialization F proj
h₁ : ∀ (x : Z), ↑e x = ↑e' x
h₂ : ∀ (x : B × F), ↑(PartialEquiv.symm e.toPartialEquiv) x = ↑(PartialEquiv.symm e'.toPartialEquiv) x
h₃ : e.baseSet = e'.baseSet
⊢ e = e'

Next tactic:
ext1
lemma ext {e e' : Pretrivialization F proj} (h₁ : ∀ x, e x = e' x)
    (h₂ : ∀ x, e.toPartialEquiv.symm x = e'.toPartialEquiv.symm x) (h₃ : e.baseSet = e'.baseSet) :
    e = e' := by
  ext1 <;> [

Proof state:
case h₁
ι : Type u_1
B : Type u_2
F : Type u_3
E : B → Type u_4
Z : Type u_5
inst✝¹ : TopologicalSpace B
inst✝ : TopologicalSpace F
proj : Z → B
e✝ : Pretrivialization F proj
x : Z
e e' : Pretrivialization F proj
h₁ : ∀ (x : Z), ↑e x = ↑e' x
h₂ : ∀ (x : B × F), ↑(PartialEquiv.symm e.toPartialEquiv) x = ↑(PartialEquiv.symm e'.toPartialEquiv) x
h₃ : e.baseSet = e'.baseSet
⊢ e.toPartialEquiv = e'.toPartialEquiv

Next tactic:
ext1
lemma ext {e e' : Pretrivialization F proj} (h₁ : ∀ x, e x = e' x)
    (h₂ : ∀ x, e.toPartialEquiv.symm x = e'.toPartialEquiv.symm x) (h₃ : e.baseSet = e'.baseSet) :
    e = e' := by
  ext1 <;> [ext1; 

Proof state:
case h₂
ι : Type u_1
B : Type u_2
F : Type u_3
E : B → Type u_4
Z : Type u_5
inst✝¹ : TopologicalSpace B
inst✝ : TopologicalSpace F
proj : Z → B
e✝ : Pretrivialization F proj
x : Z
e e' : Pretrivialization F proj
h₁ : ∀ (x : Z), ↑e x = ↑e' x
h₂ : ∀ (x : B × F), ↑(PartialEquiv.symm e.toPartialEquiv) x = ↑(PartialEquiv.symm e'.toPartialEquiv) x
h₃ : e.baseSet = e'.baseSet
⊢ e.baseSet = e'.baseSet

Next tactic:
exact h₃
lemma ext {e e' : Pretrivialization F proj} (h₁ : ∀ x, e x = e' x)
    (h₂ : ∀ x, e.toPartialEquiv.symm x = e'.toPartialEquiv.symm x) (h₃ : e.baseSet = e'.baseSet) :
    e = e' := by
  ext1 <;> [ext1; exact h₃]
  · 

Proof state:
case h₁.h
ι : Type u_1
B : Type u_2
F : Type u_3
E : B → Type u_4
Z : Type u_5
inst✝¹ : TopologicalSpace B
inst✝ : TopologicalSpace F
proj : Z → B
e✝ : Pretrivialization F proj
x : Z
e e' : Pretrivialization F proj
h₁ : ∀ (x : Z), ↑e x = ↑e' x
h₂ : ∀ (x : B × F), ↑(PartialEquiv.symm e.toPartialEquiv) x = ↑(PartialEquiv.symm e'.toPartialEquiv) x
h₃ : e.baseSet = e'.baseSet
x✝ : Z
⊢ ↑e.toPartialEquiv x✝ = ↑e'.toPartialEquiv x✝

Next tactic:
apply h₁
lemma ext {e e' : Pretrivialization F proj} (h₁ : ∀ x, e x = e' x)
    (h₂ : ∀ x, e.toPartialEquiv.symm x = e'.toPartialEquiv.symm x) (h₃ : e.baseSet = e'.baseSet) :
    e = e' := by
  ext1 <;> [ext1; exact h₃]
  · apply h₁
  · 

Proof state:
case h₁.hsymm
ι : Type u_1
B : Type u_2
F : Type u_3
E : B → Type u_4
Z : Type u_5
inst✝¹ : TopologicalSpace B
inst✝ : TopologicalSpace F
proj : Z → B
e✝ : Pretrivialization F proj
x : Z
e e' : Pretrivialization F proj
h₁ : ∀ (x : Z), ↑e x = ↑e' x
h₂ : ∀ (x : B × F), ↑(PartialEquiv.symm e.toPartialEquiv) x = ↑(PartialEquiv.symm e'.toPartialEquiv) x
h₃ : e.baseSet = e'.baseSet
x✝ : B × F
⊢ ↑(PartialEquiv.symm e.toPartialEquiv) x✝ = ↑(PartialEquiv.symm e'.toPartialEquiv) x✝

Next tactic:
apply h₂
lemma ext {e e' : Pretrivialization F proj} (h₁ : ∀ x, e x = e' x)
    (h₂ : ∀ x, e.toPartialEquiv.symm x = e'.toPartialEquiv.symm x) (h₃ : e.baseSet = e'.baseSet) :
    e = e' := by
  ext1 <;> [ext1; exact h₃]
  · apply h₁
  · apply h₂
  · 

Proof state:
case h₁.hs
ι : Type u_1
B : Type u_2
F : Type u_3
E : B → Type u_4
Z : Type u_5
inst✝¹ : TopologicalSpace B
inst✝ : TopologicalSpace F
proj : Z → B
e✝ : Pretrivialization F proj
x : Z
e e' : Pretrivialization F proj
h₁ : ∀ (x : Z), ↑e x = ↑e' x
h₂ : ∀ (x : B × F), ↑(PartialEquiv.symm e.toPartialEquiv) x = ↑(PartialEquiv.symm e'.toPartialEquiv) x
h₃ : e.baseSet = e'.baseSet
⊢ e.source = e'.source

Next tactic:
rw [e.source_eq, e'.source_eq, h₃]
/-- If the fiber is nonempty, then the projection also is. -/
lemma toPartialEquiv_injective [Nonempty F] :
    Injective (toPartialEquiv : Pretrivialization F proj → PartialEquiv Z (B × F)) := by
  

Proof state:
ι : Type u_1
B : Type u_2
F : Type u_3
E : B → Type u_4
Z : Type u_5
inst✝² : TopologicalSpace B
inst✝¹ : TopologicalSpace F
proj : Z → B
e : Pretrivialization F proj
x : Z
inst✝ : Nonempty F
⊢ Injective toPartialEquiv

Next tactic:
refine fun e e' h ↦ ext' _ _ h ?_
/-- If the fiber is nonempty, then the projection also is. -/
lemma toPartialEquiv_injective [Nonempty F] :
    Injective (toPartialEquiv : Pretrivialization F proj → PartialEquiv Z (B × F)) := by
  refine fun e e' h ↦ ext' _ _ h ?_
  

Proof state:
ι : Type u_1
B : Type u_2
F : Type u_3
E : B → Type u_4
Z : Type u_5
inst✝² : TopologicalSpace B
inst✝¹ : TopologicalSpace F
proj : Z → B
e✝ : Pretrivialization F proj
x : Z
inst✝ : Nonempty F
e e' : Pretrivialization F proj
h : e.toPartialEquiv = e'.toPartialEquiv
⊢ e.baseSet = e'.baseSet

Next tactic:
simpa only [fst_image_prod, univ_nonempty, target_eq]
    using congr_arg (Prod.fst '' PartialEquiv.target ·) h
theorem mem_source : x ∈ e.source ↔ proj x ∈ e.baseSet := by 

Proof state:
ι : Type u_1
B : Type u_2
F : Type u_3
E : B → Type u_4
Z : Type u_5
inst✝¹ : TopologicalSpace B
inst✝ : TopologicalSpace F
proj : Z → B
e : Pretrivialization F proj
x : Z
⊢ x ∈ e.source ↔ proj x ∈ e.baseSet

Next tactic:
rw [e.source_eq, mem_preimage]
theorem mem_target {x : B × F} : x ∈ e.target ↔ x.1 ∈ e.baseSet := by
  

Proof state:
ι : Type u_1
B : Type u_2
F : Type u_3
E : B → Type u_4
Z : Type u_5
inst✝¹ : TopologicalSpace B
inst✝ : TopologicalSpace F
proj : Z → B
e : Pretrivialization F proj
x✝ : Z
x : B × F
⊢ x ∈ e.target ↔ x.1 ∈ e.baseSet

Next tactic:
rw [e.target_eq, prod_univ, mem_preimage]
theorem proj_symm_apply {x : B × F} (hx : x ∈ e.target) : proj (e.toPartialEquiv.symm x) = x.1 := by
  

Proof state:
ι : Type u_1
B : Type u_2
F : Type u_3
E : B → Type u_4
Z : Type u_5
inst✝¹ : TopologicalSpace B
inst✝ : TopologicalSpace F
proj : Z → B
e : Pretrivialization F proj
x✝ : Z
x : B × F
hx : x ∈ e.target
⊢ proj (↑(PartialEquiv.symm e.toPartialEquiv) x) = x.1

Next tactic:
have := (e.coe_fst (e.map_target hx)).symm
theorem proj_symm_apply {x : B × F} (hx : x ∈ e.target) : proj (e.toPartialEquiv.symm x) = x.1 := by
  have := (e.coe_fst (e.map_target hx)).symm
  

Proof state:
ι : Type u_1
B : Type u_2
F : Type u_3
E : B → Type u_4
Z : Type u_5
inst✝¹ : TopologicalSpace B
inst✝ : TopologicalSpace F
proj : Z → B
e : Pretrivialization F proj
x✝ : Z
x : B × F
hx : x ∈ e.target
this : proj (↑(PartialEquiv.symm e.toPartialEquiv) x) = (↑e (↑(PartialEquiv.symm e.toPartialEquiv) x)).1
⊢ proj (↑(PartialEquiv.symm e.toPartialEquiv) x) = x.1

Next tactic:
rwa [← e.coe_coe, e.right_inv hx] at this
@[simp, mfld_simps]
theorem symm_apply_mk_proj {x : Z} (ex : x ∈ e.source) :
    e.toPartialEquiv.symm (proj x, (e x).2) = x := by
  

Proof state:
ι : Type u_1
B : Type u_2
F : Type u_3
E : B → Type u_4
Z : Type u_5
inst✝¹ : TopologicalSpace B
inst✝ : TopologicalSpace F
proj : Z → B
e : Pretrivialization F proj
x✝ x : Z
ex : x ∈ e.source
⊢ ↑(PartialEquiv.symm e.toPartialEquiv) (proj x, (↑e x).2) = x

Next tactic:
rw [← e.coe_fst ex, ← e.coe_coe, e.left_inv ex]
@[simp, mfld_simps]
theorem preimage_symm_proj_baseSet :
    e.toPartialEquiv.symm ⁻¹' (proj ⁻¹' e.baseSet) ∩ e.target = e.target := by
  

Proof state:
ι : Type u_1
B : Type u_2
F : Type u_3
E : B → Type u_4
Z : Type u_5
inst✝¹ : TopologicalSpace B
inst✝ : TopologicalSpace F
proj : Z → B
e : Pretrivialization F proj
x : Z
⊢ ↑(PartialEquiv.symm e.toPartialEquiv) ⁻¹' (proj ⁻¹' e.baseSet) ∩ e.target = e.target

Next tactic:
refine' inter_eq_right.mpr fun x hx => _
@[simp, mfld_simps]
theorem preimage_symm_proj_baseSet :
    e.toPartialEquiv.symm ⁻¹' (proj ⁻¹' e.baseSet) ∩ e.target = e.target := by
  refine' inter_eq_right.mpr fun x hx => _
  

Proof state:
ι : Type u_1
B : Type u_2
F : Type u_3
E : B → Type u_4
Z : Type u_5
inst✝¹ : TopologicalSpace B
inst✝ : TopologicalSpace F
proj : Z → B
e : Pretrivialization F proj
x✝ : Z
x : B × F
hx : x ∈ e.target
⊢ x ∈ ↑(PartialEquiv.symm e.toPartialEquiv) ⁻¹' (proj ⁻¹' e.baseSet)

Next tactic:
simp only [mem_preimage, PartialEquiv.invFun_as_coe, e.proj_symm_apply hx]
@[simp, mfld_simps]
theorem preimage_symm_proj_baseSet :
    e.toPartialEquiv.symm ⁻¹' (proj ⁻¹' e.baseSet) ∩ e.target = e.target := by
  refine' inter_eq_right.mpr fun x hx => _
  simp only [mem_preimage, PartialEquiv.invFun_as_coe, e.proj_symm_apply hx]
  

Proof state:
ι : Type u_1
B : Type u_2
F : Type u_3
E : B → Type u_4
Z : Type u_5
inst✝¹ : TopologicalSpace B
inst✝ : TopologicalSpace F
proj : Z → B
e : Pretrivialization F proj
x✝ : Z
x : B × F
hx : x ∈ e.target
⊢ x.1 ∈ e.baseSet

Next tactic:
exact e.mem_target.mp hx
@[simp, mfld_simps]
theorem preimage_symm_proj_inter (s : Set B) :
    e.toPartialEquiv.symm ⁻¹' (proj ⁻¹' s) ∩ e.baseSet ×ˢ univ = (s ∩ e.baseSet) ×ˢ univ := by
  

Proof state:
ι : Type u_1
B : Type u_2
F : Type u_3
E : B → Type u_4
Z : Type u_5
inst✝¹ : TopologicalSpace B
inst✝ : TopologicalSpace F
proj : Z → B
e : Pretrivialization F proj
x : Z
s : Set B
⊢ ↑(PartialEquiv.symm e.toPartialEquiv) ⁻¹' (proj ⁻¹' s) ∩ e.baseSet ×ˢ univ = (s ∩ e.baseSet) ×ˢ univ

Next tactic:
ext ⟨x, y⟩
@[simp, mfld_simps]
theorem preimage_symm_proj_inter (s : Set B) :
    e.toPartialEquiv.symm ⁻¹' (proj ⁻¹' s) ∩ e.baseSet ×ˢ univ = (s ∩ e.baseSet) ×ˢ univ := by
  ext ⟨x, y⟩
  

Proof state:
case h.mk
ι : Type u_1
B : Type u_2
F : Type u_3
E : B → Type u_4
Z : Type u_5
inst✝¹ : TopologicalSpace B
inst✝ : TopologicalSpace F
proj : Z → B
e : Pretrivialization F proj
x✝ : Z
s : Set B
x : B
y : F
⊢ (x, y) ∈ ↑(PartialEquiv.symm e.toPartialEquiv) ⁻¹' (proj ⁻¹' s) ∩ e.baseSet ×ˢ univ ↔ (x, y) ∈ (s ∩ e.baseSet) ×ˢ univ

Next tactic:
suffices x ∈ e.baseSet → (proj (e.toPartialEquiv.symm (x, y)) ∈ s ↔ x ∈ s) by
    simpa only [prod_mk_mem_set_prod_eq, mem_inter_iff, and_true_iff, mem_univ, and_congr_left_iff]
@[simp, mfld_simps]
theorem preimage_symm_proj_inter (s : Set B) :
    e.toPartialEquiv.symm ⁻¹' (proj ⁻¹' s) ∩ e.baseSet ×ˢ univ = (s ∩ e.baseSet) ×ˢ univ := by
  ext ⟨x, y⟩
  suffices x ∈ e.baseSet → (proj (e.toPartialEquiv.symm (x, y)) ∈ s ↔ x ∈ s) by
    

Proof state:
ι : Type u_1
B : Type u_2
F : Type u_3
E : B → Type u_4
Z : Type u_5
inst✝¹ : TopologicalSpace B
inst✝ : TopologicalSpace F
proj : Z → B
e : Pretrivialization F proj
x✝ : Z
s : Set B
x : B
y : F
this : x ∈ e.baseSet → (proj (↑(PartialEquiv.symm e.toPartialEquiv) (x, y)) ∈ s ↔ x ∈ s)
⊢ (x, y) ∈ ↑(PartialEquiv.symm e.toPartialEquiv) ⁻¹' (proj ⁻¹' s) ∩ e.baseSet ×ˢ univ ↔ (x, y) ∈ (s ∩ e.baseSet) ×ˢ univ

Next tactic:
simpa only [prod_mk_mem_set_prod_eq, mem_inter_iff, and_true_iff, mem_univ, and_congr_left_iff]
@[simp, mfld_simps]
theorem preimage_symm_proj_inter (s : Set B) :
    e.toPartialEquiv.symm ⁻¹' (proj ⁻¹' s) ∩ e.baseSet ×ˢ univ = (s ∩ e.baseSet) ×ˢ univ := by
  ext ⟨x, y⟩
  suffices x ∈ e.baseSet → (proj (e.toPartialEquiv.symm (x, y)) ∈ s ↔ x ∈ s) by
    simpa only [prod_mk_mem_set_prod_eq, mem_inter_iff, and_true_iff, mem_univ, and_congr_left_iff]
  

Proof state:
case h.mk
ι : Type u_1
B : Type u_2
F : Type u_3
E : B → Type u_4
Z : Type u_5
inst✝¹ : TopologicalSpace B
inst✝ : TopologicalSpace F
proj : Z → B
e : Pretrivialization F proj
x✝ : Z
s : Set B
x : B
y : F
⊢ x ∈ e.baseSet → (proj (↑(PartialEquiv.symm e.toPartialEquiv) (x, y)) ∈ s ↔ x ∈ s)

Next tactic:
intro h
@[simp, mfld_simps]
theorem preimage_symm_proj_inter (s : Set B) :
    e.toPartialEquiv.symm ⁻¹' (proj ⁻¹' s) ∩ e.baseSet ×ˢ univ = (s ∩ e.baseSet) ×ˢ univ := by
  ext ⟨x, y⟩
  suffices x ∈ e.baseSet → (proj (e.toPartialEquiv.symm (x, y)) ∈ s ↔ x ∈ s) by
    simpa only [prod_mk_mem_set_prod_eq, mem_inter_iff, and_true_iff, mem_univ, and_congr_left_iff]
  intro h
  

Proof state:
case h.mk
ι : Type u_1
B : Type u_2
F : Type u_3
E : B → Type u_4
Z : Type u_5
inst✝¹ : TopologicalSpace B
inst✝ : TopologicalSpace F
proj : Z → B
e : Pretrivialization F proj
x✝ : Z
s : Set B
x : B
y : F
h : x ∈ e.baseSet
⊢ proj (↑(PartialEquiv.symm e.toPartialEquiv) (x, y)) ∈ s ↔ x ∈ s

Next tactic:
rw [e.proj_symm_apply' h]
theorem target_inter_preimage_symm_source_eq (e f : Pretrivialization F proj) :
    f.target ∩ f.toPartialEquiv.symm ⁻¹' e.source = (e.baseSet ∩ f.baseSet) ×ˢ univ := by
  

Proof state:
ι : Type u_1
B : Type u_2
F : Type u_3
E : B → Type u_4
Z : Type u_5
inst✝¹ : TopologicalSpace B
inst✝ : TopologicalSpace F
proj : Z → B
e✝ : Pretrivialization F proj
x : Z
e f : Pretrivialization F proj
⊢ f.target ∩ ↑(PartialEquiv.symm f.toPartialEquiv) ⁻¹' e.source = (e.baseSet ∩ f.baseSet) ×ˢ univ

Next tactic:
rw [inter_comm, f.target_eq, e.source_eq, f.preimage_symm_proj_inter]
theorem trans_source (e f : Pretrivialization F proj) :
    (f.toPartialEquiv.symm.trans e.toPartialEquiv).source = (e.baseSet ∩ f.baseSet) ×ˢ univ := by
  

Proof state:
ι : Type u_1
B : Type u_2
F : Type u_3
E : B → Type u_4
Z : Type u_5
inst✝¹ : TopologicalSpace B
inst✝ : TopologicalSpace F
proj : Z → B
e✝ : Pretrivialization F proj
x : Z
e f : Pretrivialization F proj
⊢ (PartialEquiv.trans (PartialEquiv.symm f.toPartialEquiv) e.toPartialEquiv).source = (e.baseSet ∩ f.baseSet) ×ˢ univ

Next tactic:
rw [PartialEquiv.trans_source, PartialEquiv.symm_source, e.target_inter_preimage_symm_source_eq]
theorem symm_trans_symm (e e' : Pretrivialization F proj) :
    (e.toPartialEquiv.symm.trans e'.toPartialEquiv).symm
      = e'.toPartialEquiv.symm.trans e.toPartialEquiv := by
  

Proof state:
ι : Type u_1
B : Type u_2
F : Type u_3
E : B → Type u_4
Z : Type u_5
inst✝¹ : TopologicalSpace B
inst✝ : TopologicalSpace F
proj : Z → B
e✝ : Pretrivialization F proj
x : Z
e e' : Pretrivialization F proj
⊢ PartialEquiv.symm (PartialEquiv.trans (PartialEquiv.symm e.toPartialEquiv) e'.toPartialEquiv) =
    PartialEquiv.trans (PartialEquiv.symm e'.toPartialEquiv) e.toPartialEquiv

Next tactic:
rw [PartialEquiv.trans_symm_eq_symm_trans_symm, PartialEquiv.symm_symm]
theorem symm_trans_source_eq (e e' : Pretrivialization F proj) :
    (e.toPartialEquiv.symm.trans e'.toPartialEquiv).source = (e.baseSet ∩ e'.baseSet) ×ˢ univ := by
  

Proof state:
ι : Type u_1
B : Type u_2
F : Type u_3
E : B → Type u_4
Z : Type u_5
inst✝¹ : TopologicalSpace B
inst✝ : TopologicalSpace F
proj : Z → B
e✝ : Pretrivialization F proj
x : Z
e e' : Pretrivialization F proj
⊢ (PartialEquiv.trans (PartialEquiv.symm e.toPartialEquiv) e'.toPartialEquiv).source = (e.baseSet ∩ e'.baseSet) ×ˢ univ

Next tactic:
rw [PartialEquiv.trans_source, e'.source_eq, PartialEquiv.symm_source, e.target_eq, inter_comm,
    e.preimage_symm_proj_inter, inter_comm]
theorem symm_trans_target_eq (e e' : Pretrivialization F proj) :
    (e.toPartialEquiv.symm.trans e'.toPartialEquiv).target = (e.baseSet ∩ e'.baseSet) ×ˢ univ := by
  

Proof state:
ι : Type u_1
B : Type u_2
F : Type u_3
E : B → Type u_4
Z : Type u_5
inst✝¹ : TopologicalSpace B
inst✝ : TopologicalSpace F
proj : Z → B
e✝ : Pretrivialization F proj
x : Z
e e' : Pretrivialization F proj
⊢ (PartialEquiv.trans (PartialEquiv.symm e.toPartialEquiv) e'.toPartialEquiv).target = (e.baseSet ∩ e'.baseSet) ×ˢ univ

Next tactic:
rw [← PartialEquiv.symm_source, symm_trans_symm, symm_trans_source_eq, inter_comm]
theorem mk_symm (e : Pretrivialization F (π F E)) {b : B} (hb : b ∈ e.baseSet) (y : F) :
    TotalSpace.mk b (e.symm b y) = e.toPartialEquiv.symm (b, y) := by
  

Proof state:
ι : Type u_1
B : Type u_2
F : Type u_3
E : B → Type u_4
Z : Type u_5
inst✝² : TopologicalSpace B
inst✝¹ : TopologicalSpace F
proj : Z → B
e✝ : Pretrivialization F proj
x : Z
e' : Pretrivialization F TotalSpace.proj
x' : TotalSpace F E
b✝ : B
y✝ : E b✝
inst✝ : (x : B) → Zero (E x)
e : Pretrivialization F TotalSpace.proj
b : B
hb : b ∈ e.baseSet
y : F
⊢ { proj := b, snd := Pretrivialization.symm e b y } = ↑(PartialEquiv.symm e.toPartialEquiv) (b, y)

Next tactic:
simp only [e.symm_apply hb, TotalSpace.mk_cast (e.proj_symm_apply' hb), TotalSpace.eta]
theorem symm_proj_apply (e : Pretrivialization F (π F E)) (z : TotalSpace F E)
    (hz : z.proj ∈ e.baseSet) : e.symm z.proj (e z).2 = z.2 := by
  

Proof state:
ι : Type u_1
B : Type u_2
F : Type u_3
E : B → Type u_4
Z : Type u_5
inst✝² : TopologicalSpace B
inst✝¹ : TopologicalSpace F
proj : Z → B
e✝ : Pretrivialization F proj
x : Z
e' : Pretrivialization F TotalSpace.proj
x' : TotalSpace F E
b : B
y : E b
inst✝ : (x : B) → Zero (E x)
e : Pretrivialization F TotalSpace.proj
z : TotalSpace F E
hz : z.proj ∈ e.baseSet
⊢ Pretrivialization.symm e z.proj (↑e z).2 = z.snd

Next tactic:
rw [e.symm_apply hz, cast_eq_iff_heq, e.mk_proj_snd' hz, e.symm_apply_apply (e.mem_source.mpr hz)]
theorem apply_mk_symm (e : Pretrivialization F (π F E)) {b : B} (hb : b ∈ e.baseSet) (y : F) :
    e ⟨b, e.symm b y⟩ = (b, y) := by
  

Proof state:
ι : Type u_1
B : Type u_2
F : Type u_3
E : B → Type u_4
Z : Type u_5
inst✝² : TopologicalSpace B
inst✝¹ : TopologicalSpace F
proj : Z → B
e✝ : Pretrivialization F proj
x : Z
e' : Pretrivialization F TotalSpace.proj
x' : TotalSpace F E
b✝ : B
y✝ : E b✝
inst✝ : (x : B) → Zero (E x)
e : Pretrivialization F TotalSpace.proj
b : B
hb : b ∈ e.baseSet
y : F
⊢ ↑e { proj := b, snd := Pretrivialization.symm e b y } = (b, y)

Next tactic:
rw [e.mk_symm hb, e.apply_symm_apply (e.mk_mem_target.mpr hb)]
@[ext]
lemma ext' (e e' : Trivialization F proj) (h₁ : e.toPartialHomeomorph = e'.toPartialHomeomorph)
    (h₂ : e.baseSet = e'.baseSet) : e = e' := by
  

Proof state:
ι : Type u_1
B : Type u_2
F : Type u_3
E : B → Type u_4
Z : Type u_5
inst✝³ : TopologicalSpace B
inst✝² : TopologicalSpace F
proj : Z → B
inst✝¹ : TopologicalSpace Z
inst✝ : TopologicalSpace (TotalSpace F E)
e✝ : Trivialization F proj
x : Z
e e' : Trivialization F proj
h₁ : e.toPartialHomeomorph = e'.toPartialHomeomorph
h₂ : e.baseSet = e'.baseSet
⊢ e = e'

Next tactic:
cases e
@[ext]
lemma ext' (e e' : Trivialization F proj) (h₁ : e.toPartialHomeomorph = e'.toPartialHomeomorph)
    (h₂ : e.baseSet = e'.baseSet) : e = e' := by
  cases e; 

Proof state:
case mk
ι : Type u_1
B : Type u_2
F : Type u_3
E : B → Type u_4
Z : Type u_5
inst✝³ : TopologicalSpace B
inst✝² : TopologicalSpace F
proj : Z → B
inst✝¹ : TopologicalSpace Z
inst✝ : TopologicalSpace (TotalSpace F E)
e : Trivialization F proj
x : Z
e' : Trivialization F proj
toPartialHomeomorph✝ : PartialHomeomorph Z (B × F)
baseSet✝ : Set B
open_baseSet✝ : IsOpen baseSet✝
source_eq✝ : toPartialHomeomorph✝.source = proj ⁻¹' baseSet✝
target_eq✝ : toPartialHomeomorph✝.target = baseSet✝ ×ˢ univ
proj_toFun✝ : ∀ p ∈ toPartialHomeomorph✝.source, (↑toPartialHomeomorph✝ p).1 = proj p
h₁ :
  { toPartialHomeomorph := toPartialHomeomorph✝, baseSet := baseSet✝, open_baseSet := open_baseSet✝,
        source_eq := source_eq✝, target_eq := target_eq✝, proj_toFun := proj_toFun✝ }.toPartialHomeomorph =
    e'.toPartialHomeomorph
h₂ :
  { toPartialHomeomorph := toPartialHomeomorph✝, baseSet := baseSet✝, open_baseSet := open_baseSet✝,
        source_eq := source_eq✝, target_eq := target_eq✝, proj_toFun := proj_toFun✝ }.baseSet =
    e'.baseSet
⊢ { toPartialHomeomorph := toPartialHomeomorph✝, baseSet := baseSet✝, open_baseSet := open_baseSet✝,
      source_eq := source_eq✝, target_eq := target_eq✝, proj_toFun := proj_toFun✝ } =
    e'

Next tactic:
cases e'