url stringclasses 147
values | commit stringclasses 147
values | file_path stringlengths 7 101 | full_name stringlengths 1 94 | start stringlengths 6 10 | end stringlengths 6 11 | tactic stringlengths 1 11.2k | state_before stringlengths 3 2.09M | state_after stringlengths 6 2.09M | input stringlengths 73 2.09M |
|---|---|---|---|---|---|---|---|---|---|
https://github.com/adamtopaz/CopenhagenMasterclass2023.git | a293ca1554f7e80d891fd4d86fb092c54d8a0a01 | CompHaus/ExplicitSheaves.lean | CompHaus.extensiveRegular_generates_coherent | [118, 1] | [227, 21] | apply GrothendieckTopology.pullback_stable' | case this
X : CompHaus
S : Sieve X
Y : CompHaus
T : Presieve Y
I : Type
hI : Fintype I
Xmap : I → CompHaus
f : (a : I) → Xmap a ⟶ Y
h : T = ofArrows Xmap f
hT : Epi (Sigma.desc f)
he : EffectiveEpiFamily Xmap f ↔ Epi (Sigma.desc f)
φ : (i : I) → Xmap i ⟶ ∐ Xmap := fun i => Sigma.ι Xmap i
F : (∐ fun b => Xmap b) ⟶ Y := Sigma.desc f
Z : Sieve Y := Sieve.generate T
Xs : CompHaus := ∐ fun i => Xmap i
Zf : Sieve Y := Sieve.generate (ofArrows (fun x => Xs) fun x => F)
R : CompHaus
g : R ⟶ Y
W : CompHaus
σ : W ⟶ Y
ψ : R ⟶ ∐ fun i => Xmap i
hW' : ψ ≫ Sigma.desc f = g
⊢ Sieve.pullback ψ (Sieve.pullback F Z) ∈
GrothendieckTopology.sieves
(Coverage.toGrothendieck CompHaus
(ExtensiveRegularCoverage' CompHaus
(_ : ∀ {X Y Z : CompHaus} (f : Y ⟶ X) (π : Z ⟶ X) [inst : Epi π], Epi Limits.pullback.fst)
(_ :
∀ {α : Type} [inst : Fintype α] {X : CompHaus} {Z : α → CompHaus} (π : (a : α) → Z a ⟶ X) {Y : CompHaus}
(f : Y ⟶ X) (x : IsIso (Sigma.desc π)), IsIso (Sigma.desc fun x_1 => Limits.pullback.fst))))
R | case this.a
X : CompHaus
S : Sieve X
Y : CompHaus
T : Presieve Y
I : Type
hI : Fintype I
Xmap : I → CompHaus
f : (a : I) → Xmap a ⟶ Y
h : T = ofArrows Xmap f
hT : Epi (Sigma.desc f)
he : EffectiveEpiFamily Xmap f ↔ Epi (Sigma.desc f)
φ : (i : I) → Xmap i ⟶ ∐ Xmap := fun i => Sigma.ι Xmap i
F : (∐ fun b => Xmap b) ⟶ Y := Sigma.desc f
Z : Sieve Y := Sieve.generate T
Xs : CompHaus := ∐ fun i => Xmap i
Zf : Sieve Y := Sieve.generate (ofArrows (fun x => Xs) fun x => F)
R : CompHaus
g : R ⟶ Y
W : CompHaus
σ : W ⟶ Y
ψ : R ⟶ ∐ fun i => Xmap i
hW' : ψ ≫ Sigma.desc f = g
⊢ Sieve.pullback F Z ∈
GrothendieckTopology.sieves
(Coverage.toGrothendieck CompHaus
(ExtensiveRegularCoverage' CompHaus
(_ : ∀ {X Y Z : CompHaus} (f : Y ⟶ X) (π : Z ⟶ X) [inst : Epi π], Epi Limits.pullback.fst)
(_ :
∀ {α : Type} [inst : Fintype α] {X : CompHaus} {Z : α → CompHaus} (π : (a : α) → Z a ⟶ X) {Y : CompHaus}
(f : Y ⟶ X) (x : IsIso (Sigma.desc π)), IsIso (Sigma.desc fun x_1 => Limits.pullback.fst))))
(∐ fun i => Xmap i) | Please generate a tactic in lean4 to solve the state.
STATE:
case this
X : CompHaus
S : Sieve X
Y : CompHaus
T : Presieve Y
I : Type
hI : Fintype I
Xmap : I → CompHaus
f : (a : I) → Xmap a ⟶ Y
h : T = ofArrows Xmap f
hT : Epi (Sigma.desc f)
he : EffectiveEpiFamily Xmap f ↔ Epi (Sigma.desc f)
φ : (i : I) → Xmap i ⟶ ∐ Xmap := fun i => Sigma.ι Xmap i
F : (∐ fun b => Xmap b) ⟶ Y := Sigma.desc f
Z : Sieve Y := Sieve.generate T
Xs : CompHaus := ∐ fun i => Xmap i
Zf : Sieve Y := Sieve.generate (ofArrows (fun x => Xs) fun x => F)
R : CompHaus
g : R ⟶ Y
W : CompHaus
σ : W ⟶ Y
ψ : R ⟶ ∐ fun i => Xmap i
hW' : ψ ≫ Sigma.desc f = g
⊢ Sieve.pullback ψ (Sieve.pullback F Z) ∈
GrothendieckTopology.sieves
(Coverage.toGrothendieck CompHaus
(ExtensiveRegularCoverage' CompHaus
(_ : ∀ {X Y Z : CompHaus} (f : Y ⟶ X) (π : Z ⟶ X) [inst : Epi π], Epi Limits.pullback.fst)
(_ :
∀ {α : Type} [inst : Fintype α] {X : CompHaus} {Z : α → CompHaus} (π : (a : α) → Z a ⟶ X) {Y : CompHaus}
(f : Y ⟶ X) (x : IsIso (Sigma.desc π)), IsIso (Sigma.desc fun x_1 => Limits.pullback.fst))))
R
TACTIC:
|
https://github.com/adamtopaz/CopenhagenMasterclass2023.git | a293ca1554f7e80d891fd4d86fb092c54d8a0a01 | CompHaus/ExplicitSheaves.lean | CompHaus.extensiveRegular_generates_coherent | [118, 1] | [227, 21] | dsimp [Coverage.toGrothendieck] | case this.a
X : CompHaus
S : Sieve X
Y : CompHaus
T : Presieve Y
I : Type
hI : Fintype I
Xmap : I → CompHaus
f : (a : I) → Xmap a ⟶ Y
h : T = ofArrows Xmap f
hT : Epi (Sigma.desc f)
he : EffectiveEpiFamily Xmap f ↔ Epi (Sigma.desc f)
φ : (i : I) → Xmap i ⟶ ∐ Xmap := fun i => Sigma.ι Xmap i
F : (∐ fun b => Xmap b) ⟶ Y := Sigma.desc f
Z : Sieve Y := Sieve.generate T
Xs : CompHaus := ∐ fun i => Xmap i
Zf : Sieve Y := Sieve.generate (ofArrows (fun x => Xs) fun x => F)
R : CompHaus
g : R ⟶ Y
W : CompHaus
σ : W ⟶ Y
ψ : R ⟶ ∐ fun i => Xmap i
hW' : ψ ≫ Sigma.desc f = g
⊢ Sieve.pullback F Z ∈
GrothendieckTopology.sieves
(Coverage.toGrothendieck CompHaus
(ExtensiveRegularCoverage' CompHaus
(_ : ∀ {X Y Z : CompHaus} (f : Y ⟶ X) (π : Z ⟶ X) [inst : Epi π], Epi Limits.pullback.fst)
(_ :
∀ {α : Type} [inst : Fintype α] {X : CompHaus} {Z : α → CompHaus} (π : (a : α) → Z a ⟶ X) {Y : CompHaus}
(f : Y ⟶ X) (x : IsIso (Sigma.desc π)), IsIso (Sigma.desc fun x_1 => Limits.pullback.fst))))
(∐ fun i => Xmap i) | case this.a
X : CompHaus
S : Sieve X
Y : CompHaus
T : Presieve Y
I : Type
hI : Fintype I
Xmap : I → CompHaus
f : (a : I) → Xmap a ⟶ Y
h : T = ofArrows Xmap f
hT : Epi (Sigma.desc f)
he : EffectiveEpiFamily Xmap f ↔ Epi (Sigma.desc f)
φ : (i : I) → Xmap i ⟶ ∐ Xmap := fun i => Sigma.ι Xmap i
F : (∐ fun b => Xmap b) ⟶ Y := Sigma.desc f
Z : Sieve Y := Sieve.generate T
Xs : CompHaus := ∐ fun i => Xmap i
Zf : Sieve Y := Sieve.generate (ofArrows (fun x => Xs) fun x => F)
R : CompHaus
g : R ⟶ Y
W : CompHaus
σ : W ⟶ Y
ψ : R ⟶ ∐ fun i => Xmap i
hW' : ψ ≫ Sigma.desc f = g
⊢ Sieve.pullback (Sigma.desc f) (Sieve.generate T) ∈
Coverage.saturate
(ExtensiveRegularCoverage' CompHaus
(_ : ∀ {X Y Z : CompHaus} (f : Y ⟶ X) (π : Z ⟶ X) [inst : Epi π], Epi Limits.pullback.fst)
(_ :
∀ {α : Type} [inst : Fintype α] {X : CompHaus} {Z : α → CompHaus} (π : (a : α) → Z a ⟶ X) {Y : CompHaus}
(f : Y ⟶ X) (x : IsIso (Sigma.desc π)), IsIso (Sigma.desc fun x_1 => Limits.pullback.fst)))
(∐ fun i => Xmap i) | Please generate a tactic in lean4 to solve the state.
STATE:
case this.a
X : CompHaus
S : Sieve X
Y : CompHaus
T : Presieve Y
I : Type
hI : Fintype I
Xmap : I → CompHaus
f : (a : I) → Xmap a ⟶ Y
h : T = ofArrows Xmap f
hT : Epi (Sigma.desc f)
he : EffectiveEpiFamily Xmap f ↔ Epi (Sigma.desc f)
φ : (i : I) → Xmap i ⟶ ∐ Xmap := fun i => Sigma.ι Xmap i
F : (∐ fun b => Xmap b) ⟶ Y := Sigma.desc f
Z : Sieve Y := Sieve.generate T
Xs : CompHaus := ∐ fun i => Xmap i
Zf : Sieve Y := Sieve.generate (ofArrows (fun x => Xs) fun x => F)
R : CompHaus
g : R ⟶ Y
W : CompHaus
σ : W ⟶ Y
ψ : R ⟶ ∐ fun i => Xmap i
hW' : ψ ≫ Sigma.desc f = g
⊢ Sieve.pullback F Z ∈
GrothendieckTopology.sieves
(Coverage.toGrothendieck CompHaus
(ExtensiveRegularCoverage' CompHaus
(_ : ∀ {X Y Z : CompHaus} (f : Y ⟶ X) (π : Z ⟶ X) [inst : Epi π], Epi Limits.pullback.fst)
(_ :
∀ {α : Type} [inst : Fintype α] {X : CompHaus} {Z : α → CompHaus} (π : (a : α) → Z a ⟶ X) {Y : CompHaus}
(f : Y ⟶ X) (x : IsIso (Sigma.desc π)), IsIso (Sigma.desc fun x_1 => Limits.pullback.fst))))
(∐ fun i => Xmap i)
TACTIC:
|
https://github.com/adamtopaz/CopenhagenMasterclass2023.git | a293ca1554f7e80d891fd4d86fb092c54d8a0a01 | CompHaus/ExplicitSheaves.lean | CompHaus.extensiveRegular_generates_coherent | [118, 1] | [227, 21] | suffices : Coverage.saturate (ExtensiveRegularCoverage' _ _ _) Xs (Z.pullback F) | case this.a
X : CompHaus
S : Sieve X
Y : CompHaus
T : Presieve Y
I : Type
hI : Fintype I
Xmap : I → CompHaus
f : (a : I) → Xmap a ⟶ Y
h : T = ofArrows Xmap f
hT : Epi (Sigma.desc f)
he : EffectiveEpiFamily Xmap f ↔ Epi (Sigma.desc f)
φ : (i : I) → Xmap i ⟶ ∐ Xmap := fun i => Sigma.ι Xmap i
F : (∐ fun b => Xmap b) ⟶ Y := Sigma.desc f
Z : Sieve Y := Sieve.generate T
Xs : CompHaus := ∐ fun i => Xmap i
Zf : Sieve Y := Sieve.generate (ofArrows (fun x => Xs) fun x => F)
R : CompHaus
g : R ⟶ Y
W : CompHaus
σ : W ⟶ Y
ψ : R ⟶ ∐ fun i => Xmap i
hW' : ψ ≫ Sigma.desc f = g
⊢ Sieve.pullback (Sigma.desc f) (Sieve.generate T) ∈
Coverage.saturate
(ExtensiveRegularCoverage' CompHaus
(_ : ∀ {X Y Z : CompHaus} (f : Y ⟶ X) (π : Z ⟶ X) [inst : Epi π], Epi Limits.pullback.fst)
(_ :
∀ {α : Type} [inst : Fintype α] {X : CompHaus} {Z : α → CompHaus} (π : (a : α) → Z a ⟶ X) {Y : CompHaus}
(f : Y ⟶ X) (x : IsIso (Sigma.desc π)), IsIso (Sigma.desc fun x_1 => Limits.pullback.fst)))
(∐ fun i => Xmap i) | case this.a
X : CompHaus
S : Sieve X
Y : CompHaus
T : Presieve Y
I : Type
hI : Fintype I
Xmap : I → CompHaus
f : (a : I) → Xmap a ⟶ Y
h : T = ofArrows Xmap f
hT : Epi (Sigma.desc f)
he : EffectiveEpiFamily Xmap f ↔ Epi (Sigma.desc f)
φ : (i : I) → Xmap i ⟶ ∐ Xmap := fun i => Sigma.ι Xmap i
F : (∐ fun b => Xmap b) ⟶ Y := Sigma.desc f
Z : Sieve Y := Sieve.generate T
Xs : CompHaus := ∐ fun i => Xmap i
Zf : Sieve Y := Sieve.generate (ofArrows (fun x => Xs) fun x => F)
R : CompHaus
g : R ⟶ Y
W : CompHaus
σ : W ⟶ Y
ψ : R ⟶ ∐ fun i => Xmap i
hW' : ψ ≫ Sigma.desc f = g
this : Coverage.saturate (ExtensiveRegularCoverage' CompHaus ?m.593487 ?m.593488) Xs (Sieve.pullback F Z)
⊢ Sieve.pullback (Sigma.desc f) (Sieve.generate T) ∈
Coverage.saturate
(ExtensiveRegularCoverage' CompHaus
(_ : ∀ {X Y Z : CompHaus} (f : Y ⟶ X) (π : Z ⟶ X) [inst : Epi π], Epi Limits.pullback.fst)
(_ :
∀ {α : Type} [inst : Fintype α] {X : CompHaus} {Z : α → CompHaus} (π : (a : α) → Z a ⟶ X) {Y : CompHaus}
(f : Y ⟶ X) (x : IsIso (Sigma.desc π)), IsIso (Sigma.desc fun x_1 => Limits.pullback.fst)))
(∐ fun i => Xmap i)
case this
X : CompHaus
S : Sieve X
Y : CompHaus
T : Presieve Y
I : Type
hI : Fintype I
Xmap : I → CompHaus
f : (a : I) → Xmap a ⟶ Y
h : T = ofArrows Xmap f
hT : Epi (Sigma.desc f)
he : EffectiveEpiFamily Xmap f ↔ Epi (Sigma.desc f)
φ : (i : I) → Xmap i ⟶ ∐ Xmap := fun i => Sigma.ι Xmap i
F : (∐ fun b => Xmap b) ⟶ Y := Sigma.desc f
Z : Sieve Y := Sieve.generate T
Xs : CompHaus := ∐ fun i => Xmap i
Zf : Sieve Y := Sieve.generate (ofArrows (fun x => Xs) fun x => F)
R : CompHaus
g : R ⟶ Y
W : CompHaus
σ : W ⟶ Y
ψ : R ⟶ ∐ fun i => Xmap i
hW' : ψ ≫ Sigma.desc f = g
⊢ Coverage.saturate (ExtensiveRegularCoverage' CompHaus ?m.593487 ?m.593488) Xs (Sieve.pullback F Z) | Please generate a tactic in lean4 to solve the state.
STATE:
case this.a
X : CompHaus
S : Sieve X
Y : CompHaus
T : Presieve Y
I : Type
hI : Fintype I
Xmap : I → CompHaus
f : (a : I) → Xmap a ⟶ Y
h : T = ofArrows Xmap f
hT : Epi (Sigma.desc f)
he : EffectiveEpiFamily Xmap f ↔ Epi (Sigma.desc f)
φ : (i : I) → Xmap i ⟶ ∐ Xmap := fun i => Sigma.ι Xmap i
F : (∐ fun b => Xmap b) ⟶ Y := Sigma.desc f
Z : Sieve Y := Sieve.generate T
Xs : CompHaus := ∐ fun i => Xmap i
Zf : Sieve Y := Sieve.generate (ofArrows (fun x => Xs) fun x => F)
R : CompHaus
g : R ⟶ Y
W : CompHaus
σ : W ⟶ Y
ψ : R ⟶ ∐ fun i => Xmap i
hW' : ψ ≫ Sigma.desc f = g
⊢ Sieve.pullback (Sigma.desc f) (Sieve.generate T) ∈
Coverage.saturate
(ExtensiveRegularCoverage' CompHaus
(_ : ∀ {X Y Z : CompHaus} (f : Y ⟶ X) (π : Z ⟶ X) [inst : Epi π], Epi Limits.pullback.fst)
(_ :
∀ {α : Type} [inst : Fintype α] {X : CompHaus} {Z : α → CompHaus} (π : (a : α) → Z a ⟶ X) {Y : CompHaus}
(f : Y ⟶ X) (x : IsIso (Sigma.desc π)), IsIso (Sigma.desc fun x_1 => Limits.pullback.fst)))
(∐ fun i => Xmap i)
TACTIC:
|
https://github.com/adamtopaz/CopenhagenMasterclass2023.git | a293ca1554f7e80d891fd4d86fb092c54d8a0a01 | CompHaus/ExplicitSheaves.lean | CompHaus.extensiveRegular_generates_coherent | [118, 1] | [227, 21] | suffices : Sieve.generate (Presieve.ofArrows Xmap φ) ≤ Z.pullback F | case this
X : CompHaus
S : Sieve X
Y : CompHaus
T : Presieve Y
I : Type
hI : Fintype I
Xmap : I → CompHaus
f : (a : I) → Xmap a ⟶ Y
h : T = ofArrows Xmap f
hT : Epi (Sigma.desc f)
he : EffectiveEpiFamily Xmap f ↔ Epi (Sigma.desc f)
φ : (i : I) → Xmap i ⟶ ∐ Xmap := fun i => Sigma.ι Xmap i
F : (∐ fun b => Xmap b) ⟶ Y := Sigma.desc f
Z : Sieve Y := Sieve.generate T
Xs : CompHaus := ∐ fun i => Xmap i
Zf : Sieve Y := Sieve.generate (ofArrows (fun x => Xs) fun x => F)
R : CompHaus
g : R ⟶ Y
W : CompHaus
σ : W ⟶ Y
ψ : R ⟶ ∐ fun i => Xmap i
hW' : ψ ≫ Sigma.desc f = g
⊢ Coverage.saturate
(ExtensiveRegularCoverage' CompHaus
(_ : ∀ {X Y Z : CompHaus} (f : Y ⟶ X) (π : Z ⟶ X) [inst : Epi π], Epi Limits.pullback.fst)
(_ :
∀ {α : Type} [inst : Fintype α] {X : CompHaus} {Z : α → CompHaus} (π : (a : α) → Z a ⟶ X) {Y : CompHaus}
(f : Y ⟶ X) (x : IsIso (Sigma.desc π)), IsIso (Sigma.desc fun x_1 => Limits.pullback.fst)))
Xs (Sieve.pullback F Z) | case this
X : CompHaus
S : Sieve X
Y : CompHaus
T : Presieve Y
I : Type
hI : Fintype I
Xmap : I → CompHaus
f : (a : I) → Xmap a ⟶ Y
h : T = ofArrows Xmap f
hT : Epi (Sigma.desc f)
he : EffectiveEpiFamily Xmap f ↔ Epi (Sigma.desc f)
φ : (i : I) → Xmap i ⟶ ∐ Xmap := fun i => Sigma.ι Xmap i
F : (∐ fun b => Xmap b) ⟶ Y := Sigma.desc f
Z : Sieve Y := Sieve.generate T
Xs : CompHaus := ∐ fun i => Xmap i
Zf : Sieve Y := Sieve.generate (ofArrows (fun x => Xs) fun x => F)
R : CompHaus
g : R ⟶ Y
W : CompHaus
σ : W ⟶ Y
ψ : R ⟶ ∐ fun i => Xmap i
hW' : ψ ≫ Sigma.desc f = g
this : Sieve.generate (ofArrows Xmap φ) ≤ Sieve.pullback F Z
⊢ Coverage.saturate
(ExtensiveRegularCoverage' CompHaus
(_ : ∀ {X Y Z : CompHaus} (f : Y ⟶ X) (π : Z ⟶ X) [inst : Epi π], Epi Limits.pullback.fst)
(_ :
∀ {α : Type} [inst : Fintype α] {X : CompHaus} {Z : α → CompHaus} (π : (a : α) → Z a ⟶ X) {Y : CompHaus}
(f : Y ⟶ X) (x : IsIso (Sigma.desc π)), IsIso (Sigma.desc fun x_1 => Limits.pullback.fst)))
Xs (Sieve.pullback F Z)
case this
X : CompHaus
S : Sieve X
Y : CompHaus
T : Presieve Y
I : Type
hI : Fintype I
Xmap : I → CompHaus
f : (a : I) → Xmap a ⟶ Y
h : T = ofArrows Xmap f
hT : Epi (Sigma.desc f)
he : EffectiveEpiFamily Xmap f ↔ Epi (Sigma.desc f)
φ : (i : I) → Xmap i ⟶ ∐ Xmap := fun i => Sigma.ι Xmap i
F : (∐ fun b => Xmap b) ⟶ Y := Sigma.desc f
Z : Sieve Y := Sieve.generate T
Xs : CompHaus := ∐ fun i => Xmap i
Zf : Sieve Y := Sieve.generate (ofArrows (fun x => Xs) fun x => F)
R : CompHaus
g : R ⟶ Y
W : CompHaus
σ : W ⟶ Y
ψ : R ⟶ ∐ fun i => Xmap i
hW' : ψ ≫ Sigma.desc f = g
⊢ Sieve.generate (ofArrows Xmap φ) ≤ Sieve.pullback F Z | Please generate a tactic in lean4 to solve the state.
STATE:
case this
X : CompHaus
S : Sieve X
Y : CompHaus
T : Presieve Y
I : Type
hI : Fintype I
Xmap : I → CompHaus
f : (a : I) → Xmap a ⟶ Y
h : T = ofArrows Xmap f
hT : Epi (Sigma.desc f)
he : EffectiveEpiFamily Xmap f ↔ Epi (Sigma.desc f)
φ : (i : I) → Xmap i ⟶ ∐ Xmap := fun i => Sigma.ι Xmap i
F : (∐ fun b => Xmap b) ⟶ Y := Sigma.desc f
Z : Sieve Y := Sieve.generate T
Xs : CompHaus := ∐ fun i => Xmap i
Zf : Sieve Y := Sieve.generate (ofArrows (fun x => Xs) fun x => F)
R : CompHaus
g : R ⟶ Y
W : CompHaus
σ : W ⟶ Y
ψ : R ⟶ ∐ fun i => Xmap i
hW' : ψ ≫ Sigma.desc f = g
⊢ Coverage.saturate
(ExtensiveRegularCoverage' CompHaus
(_ : ∀ {X Y Z : CompHaus} (f : Y ⟶ X) (π : Z ⟶ X) [inst : Epi π], Epi Limits.pullback.fst)
(_ :
∀ {α : Type} [inst : Fintype α] {X : CompHaus} {Z : α → CompHaus} (π : (a : α) → Z a ⟶ X) {Y : CompHaus}
(f : Y ⟶ X) (x : IsIso (Sigma.desc π)), IsIso (Sigma.desc fun x_1 => Limits.pullback.fst)))
Xs (Sieve.pullback F Z)
TACTIC:
|
https://github.com/adamtopaz/CopenhagenMasterclass2023.git | a293ca1554f7e80d891fd4d86fb092c54d8a0a01 | CompHaus/ExplicitSheaves.lean | CompHaus.extensiveRegular_generates_coherent | [118, 1] | [227, 21] | intro Q q hq | case this
X : CompHaus
S : Sieve X
Y : CompHaus
T : Presieve Y
I : Type
hI : Fintype I
Xmap : I → CompHaus
f : (a : I) → Xmap a ⟶ Y
h : T = ofArrows Xmap f
hT : Epi (Sigma.desc f)
he : EffectiveEpiFamily Xmap f ↔ Epi (Sigma.desc f)
φ : (i : I) → Xmap i ⟶ ∐ Xmap := fun i => Sigma.ι Xmap i
F : (∐ fun b => Xmap b) ⟶ Y := Sigma.desc f
Z : Sieve Y := Sieve.generate T
Xs : CompHaus := ∐ fun i => Xmap i
Zf : Sieve Y := Sieve.generate (ofArrows (fun x => Xs) fun x => F)
R : CompHaus
g : R ⟶ Y
W : CompHaus
σ : W ⟶ Y
ψ : R ⟶ ∐ fun i => Xmap i
hW' : ψ ≫ Sigma.desc f = g
⊢ Sieve.generate (ofArrows Xmap φ) ≤ Sieve.pullback F Z | case this
X : CompHaus
S : Sieve X
Y : CompHaus
T : Presieve Y
I : Type
hI : Fintype I
Xmap : I → CompHaus
f : (a : I) → Xmap a ⟶ Y
h : T = ofArrows Xmap f
hT : Epi (Sigma.desc f)
he : EffectiveEpiFamily Xmap f ↔ Epi (Sigma.desc f)
φ : (i : I) → Xmap i ⟶ ∐ Xmap := fun i => Sigma.ι Xmap i
F : (∐ fun b => Xmap b) ⟶ Y := Sigma.desc f
Z : Sieve Y := Sieve.generate T
Xs : CompHaus := ∐ fun i => Xmap i
Zf : Sieve Y := Sieve.generate (ofArrows (fun x => Xs) fun x => F)
R : CompHaus
g : R ⟶ Y
W : CompHaus
σ : W ⟶ Y
ψ : R ⟶ ∐ fun i => Xmap i
hW' : ψ ≫ Sigma.desc f = g
Q : CompHaus
q : Q ⟶ ∐ Xmap
hq : (Sieve.generate (ofArrows Xmap φ)).arrows q
⊢ (Sieve.pullback F Z).arrows q | Please generate a tactic in lean4 to solve the state.
STATE:
case this
X : CompHaus
S : Sieve X
Y : CompHaus
T : Presieve Y
I : Type
hI : Fintype I
Xmap : I → CompHaus
f : (a : I) → Xmap a ⟶ Y
h : T = ofArrows Xmap f
hT : Epi (Sigma.desc f)
he : EffectiveEpiFamily Xmap f ↔ Epi (Sigma.desc f)
φ : (i : I) → Xmap i ⟶ ∐ Xmap := fun i => Sigma.ι Xmap i
F : (∐ fun b => Xmap b) ⟶ Y := Sigma.desc f
Z : Sieve Y := Sieve.generate T
Xs : CompHaus := ∐ fun i => Xmap i
Zf : Sieve Y := Sieve.generate (ofArrows (fun x => Xs) fun x => F)
R : CompHaus
g : R ⟶ Y
W : CompHaus
σ : W ⟶ Y
ψ : R ⟶ ∐ fun i => Xmap i
hW' : ψ ≫ Sigma.desc f = g
⊢ Sieve.generate (ofArrows Xmap φ) ≤ Sieve.pullback F Z
TACTIC:
|
https://github.com/adamtopaz/CopenhagenMasterclass2023.git | a293ca1554f7e80d891fd4d86fb092c54d8a0a01 | CompHaus/ExplicitSheaves.lean | CompHaus.extensiveRegular_generates_coherent | [118, 1] | [227, 21] | simp only [Sieve.pullback_apply, Sieve.generate_apply] | case this
X : CompHaus
S : Sieve X
Y : CompHaus
T : Presieve Y
I : Type
hI : Fintype I
Xmap : I → CompHaus
f : (a : I) → Xmap a ⟶ Y
h : T = ofArrows Xmap f
hT : Epi (Sigma.desc f)
he : EffectiveEpiFamily Xmap f ↔ Epi (Sigma.desc f)
φ : (i : I) → Xmap i ⟶ ∐ Xmap := fun i => Sigma.ι Xmap i
F : (∐ fun b => Xmap b) ⟶ Y := Sigma.desc f
Z : Sieve Y := Sieve.generate T
Xs : CompHaus := ∐ fun i => Xmap i
Zf : Sieve Y := Sieve.generate (ofArrows (fun x => Xs) fun x => F)
R : CompHaus
g : R ⟶ Y
W : CompHaus
σ : W ⟶ Y
ψ : R ⟶ ∐ fun i => Xmap i
hW' : ψ ≫ Sigma.desc f = g
Q : CompHaus
q : Q ⟶ ∐ Xmap
hq : (Sieve.generate (ofArrows Xmap φ)).arrows q
⊢ (Sieve.pullback F Z).arrows q | case this
X : CompHaus
S : Sieve X
Y : CompHaus
T : Presieve Y
I : Type
hI : Fintype I
Xmap : I → CompHaus
f : (a : I) → Xmap a ⟶ Y
h : T = ofArrows Xmap f
hT : Epi (Sigma.desc f)
he : EffectiveEpiFamily Xmap f ↔ Epi (Sigma.desc f)
φ : (i : I) → Xmap i ⟶ ∐ Xmap := fun i => Sigma.ι Xmap i
F : (∐ fun b => Xmap b) ⟶ Y := Sigma.desc f
Z : Sieve Y := Sieve.generate T
Xs : CompHaus := ∐ fun i => Xmap i
Zf : Sieve Y := Sieve.generate (ofArrows (fun x => Xs) fun x => F)
R : CompHaus
g : R ⟶ Y
W : CompHaus
σ : W ⟶ Y
ψ : R ⟶ ∐ fun i => Xmap i
hW' : ψ ≫ Sigma.desc f = g
Q : CompHaus
q : Q ⟶ ∐ Xmap
hq : (Sieve.generate (ofArrows Xmap φ)).arrows q
⊢ ∃ Y_1 h g, T g ∧ h ≫ g = q ≫ Sigma.desc f | Please generate a tactic in lean4 to solve the state.
STATE:
case this
X : CompHaus
S : Sieve X
Y : CompHaus
T : Presieve Y
I : Type
hI : Fintype I
Xmap : I → CompHaus
f : (a : I) → Xmap a ⟶ Y
h : T = ofArrows Xmap f
hT : Epi (Sigma.desc f)
he : EffectiveEpiFamily Xmap f ↔ Epi (Sigma.desc f)
φ : (i : I) → Xmap i ⟶ ∐ Xmap := fun i => Sigma.ι Xmap i
F : (∐ fun b => Xmap b) ⟶ Y := Sigma.desc f
Z : Sieve Y := Sieve.generate T
Xs : CompHaus := ∐ fun i => Xmap i
Zf : Sieve Y := Sieve.generate (ofArrows (fun x => Xs) fun x => F)
R : CompHaus
g : R ⟶ Y
W : CompHaus
σ : W ⟶ Y
ψ : R ⟶ ∐ fun i => Xmap i
hW' : ψ ≫ Sigma.desc f = g
Q : CompHaus
q : Q ⟶ ∐ Xmap
hq : (Sieve.generate (ofArrows Xmap φ)).arrows q
⊢ (Sieve.pullback F Z).arrows q
TACTIC:
|
https://github.com/adamtopaz/CopenhagenMasterclass2023.git | a293ca1554f7e80d891fd4d86fb092c54d8a0a01 | CompHaus/ExplicitSheaves.lean | CompHaus.extensiveRegular_generates_coherent | [118, 1] | [227, 21] | simp only [Sieve.generate_apply] at hq | case this
X : CompHaus
S : Sieve X
Y : CompHaus
T : Presieve Y
I : Type
hI : Fintype I
Xmap : I → CompHaus
f : (a : I) → Xmap a ⟶ Y
h : T = ofArrows Xmap f
hT : Epi (Sigma.desc f)
he : EffectiveEpiFamily Xmap f ↔ Epi (Sigma.desc f)
φ : (i : I) → Xmap i ⟶ ∐ Xmap := fun i => Sigma.ι Xmap i
F : (∐ fun b => Xmap b) ⟶ Y := Sigma.desc f
Z : Sieve Y := Sieve.generate T
Xs : CompHaus := ∐ fun i => Xmap i
Zf : Sieve Y := Sieve.generate (ofArrows (fun x => Xs) fun x => F)
R : CompHaus
g : R ⟶ Y
W : CompHaus
σ : W ⟶ Y
ψ : R ⟶ ∐ fun i => Xmap i
hW' : ψ ≫ Sigma.desc f = g
Q : CompHaus
q : Q ⟶ ∐ Xmap
hq : (Sieve.generate (ofArrows Xmap φ)).arrows q
⊢ ∃ Y_1 h g, T g ∧ h ≫ g = q ≫ Sigma.desc f | case this
X : CompHaus
S : Sieve X
Y : CompHaus
T : Presieve Y
I : Type
hI : Fintype I
Xmap : I → CompHaus
f : (a : I) → Xmap a ⟶ Y
h : T = ofArrows Xmap f
hT : Epi (Sigma.desc f)
he : EffectiveEpiFamily Xmap f ↔ Epi (Sigma.desc f)
φ : (i : I) → Xmap i ⟶ ∐ Xmap := fun i => Sigma.ι Xmap i
F : (∐ fun b => Xmap b) ⟶ Y := Sigma.desc f
Z : Sieve Y := Sieve.generate T
Xs : CompHaus := ∐ fun i => Xmap i
Zf : Sieve Y := Sieve.generate (ofArrows (fun x => Xs) fun x => F)
R : CompHaus
g : R ⟶ Y
W : CompHaus
σ : W ⟶ Y
ψ : R ⟶ ∐ fun i => Xmap i
hW' : ψ ≫ Sigma.desc f = g
Q : CompHaus
q : Q ⟶ ∐ Xmap
hq : ∃ Y h g, ofArrows Xmap (fun i => Sigma.ι Xmap i) g ∧ h ≫ g = q
⊢ ∃ Y_1 h g, T g ∧ h ≫ g = q ≫ Sigma.desc f | Please generate a tactic in lean4 to solve the state.
STATE:
case this
X : CompHaus
S : Sieve X
Y : CompHaus
T : Presieve Y
I : Type
hI : Fintype I
Xmap : I → CompHaus
f : (a : I) → Xmap a ⟶ Y
h : T = ofArrows Xmap f
hT : Epi (Sigma.desc f)
he : EffectiveEpiFamily Xmap f ↔ Epi (Sigma.desc f)
φ : (i : I) → Xmap i ⟶ ∐ Xmap := fun i => Sigma.ι Xmap i
F : (∐ fun b => Xmap b) ⟶ Y := Sigma.desc f
Z : Sieve Y := Sieve.generate T
Xs : CompHaus := ∐ fun i => Xmap i
Zf : Sieve Y := Sieve.generate (ofArrows (fun x => Xs) fun x => F)
R : CompHaus
g : R ⟶ Y
W : CompHaus
σ : W ⟶ Y
ψ : R ⟶ ∐ fun i => Xmap i
hW' : ψ ≫ Sigma.desc f = g
Q : CompHaus
q : Q ⟶ ∐ Xmap
hq : (Sieve.generate (ofArrows Xmap φ)).arrows q
⊢ ∃ Y_1 h g, T g ∧ h ≫ g = q ≫ Sigma.desc f
TACTIC:
|
https://github.com/adamtopaz/CopenhagenMasterclass2023.git | a293ca1554f7e80d891fd4d86fb092c54d8a0a01 | CompHaus/ExplicitSheaves.lean | CompHaus.extensiveRegular_generates_coherent | [118, 1] | [227, 21] | obtain ⟨E, e, r, hq⟩ := hq | case this
X : CompHaus
S : Sieve X
Y : CompHaus
T : Presieve Y
I : Type
hI : Fintype I
Xmap : I → CompHaus
f : (a : I) → Xmap a ⟶ Y
h : T = ofArrows Xmap f
hT : Epi (Sigma.desc f)
he : EffectiveEpiFamily Xmap f ↔ Epi (Sigma.desc f)
φ : (i : I) → Xmap i ⟶ ∐ Xmap := fun i => Sigma.ι Xmap i
F : (∐ fun b => Xmap b) ⟶ Y := Sigma.desc f
Z : Sieve Y := Sieve.generate T
Xs : CompHaus := ∐ fun i => Xmap i
Zf : Sieve Y := Sieve.generate (ofArrows (fun x => Xs) fun x => F)
R : CompHaus
g : R ⟶ Y
W : CompHaus
σ : W ⟶ Y
ψ : R ⟶ ∐ fun i => Xmap i
hW' : ψ ≫ Sigma.desc f = g
Q : CompHaus
q : Q ⟶ ∐ Xmap
hq : ∃ Y h g, ofArrows Xmap (fun i => Sigma.ι Xmap i) g ∧ h ≫ g = q
⊢ ∃ Y_1 h g, T g ∧ h ≫ g = q ≫ Sigma.desc f | case this.intro.intro.intro
X : CompHaus
S : Sieve X
Y : CompHaus
T : Presieve Y
I : Type
hI : Fintype I
Xmap : I → CompHaus
f : (a : I) → Xmap a ⟶ Y
h : T = ofArrows Xmap f
hT : Epi (Sigma.desc f)
he : EffectiveEpiFamily Xmap f ↔ Epi (Sigma.desc f)
φ : (i : I) → Xmap i ⟶ ∐ Xmap := fun i => Sigma.ι Xmap i
F : (∐ fun b => Xmap b) ⟶ Y := Sigma.desc f
Z : Sieve Y := Sieve.generate T
Xs : CompHaus := ∐ fun i => Xmap i
Zf : Sieve Y := Sieve.generate (ofArrows (fun x => Xs) fun x => F)
R : CompHaus
g : R ⟶ Y
W : CompHaus
σ : W ⟶ Y
ψ : R ⟶ ∐ fun i => Xmap i
hW' : ψ ≫ Sigma.desc f = g
Q : CompHaus
q : Q ⟶ ∐ Xmap
E : CompHaus
e : Q ⟶ E
r : E ⟶ ∐ Xmap
hq : ofArrows Xmap (fun i => Sigma.ι Xmap i) r ∧ e ≫ r = q
⊢ ∃ Y_1 h g, T g ∧ h ≫ g = q ≫ Sigma.desc f | Please generate a tactic in lean4 to solve the state.
STATE:
case this
X : CompHaus
S : Sieve X
Y : CompHaus
T : Presieve Y
I : Type
hI : Fintype I
Xmap : I → CompHaus
f : (a : I) → Xmap a ⟶ Y
h : T = ofArrows Xmap f
hT : Epi (Sigma.desc f)
he : EffectiveEpiFamily Xmap f ↔ Epi (Sigma.desc f)
φ : (i : I) → Xmap i ⟶ ∐ Xmap := fun i => Sigma.ι Xmap i
F : (∐ fun b => Xmap b) ⟶ Y := Sigma.desc f
Z : Sieve Y := Sieve.generate T
Xs : CompHaus := ∐ fun i => Xmap i
Zf : Sieve Y := Sieve.generate (ofArrows (fun x => Xs) fun x => F)
R : CompHaus
g : R ⟶ Y
W : CompHaus
σ : W ⟶ Y
ψ : R ⟶ ∐ fun i => Xmap i
hW' : ψ ≫ Sigma.desc f = g
Q : CompHaus
q : Q ⟶ ∐ Xmap
hq : ∃ Y h g, ofArrows Xmap (fun i => Sigma.ι Xmap i) g ∧ h ≫ g = q
⊢ ∃ Y_1 h g, T g ∧ h ≫ g = q ≫ Sigma.desc f
TACTIC:
|
https://github.com/adamtopaz/CopenhagenMasterclass2023.git | a293ca1554f7e80d891fd4d86fb092c54d8a0a01 | CompHaus/ExplicitSheaves.lean | CompHaus.extensiveRegular_generates_coherent | [118, 1] | [227, 21] | refine' ⟨E, e, r ≫ F, ⟨_, _⟩⟩ | case this.intro.intro.intro
X : CompHaus
S : Sieve X
Y : CompHaus
T : Presieve Y
I : Type
hI : Fintype I
Xmap : I → CompHaus
f : (a : I) → Xmap a ⟶ Y
h : T = ofArrows Xmap f
hT : Epi (Sigma.desc f)
he : EffectiveEpiFamily Xmap f ↔ Epi (Sigma.desc f)
φ : (i : I) → Xmap i ⟶ ∐ Xmap := fun i => Sigma.ι Xmap i
F : (∐ fun b => Xmap b) ⟶ Y := Sigma.desc f
Z : Sieve Y := Sieve.generate T
Xs : CompHaus := ∐ fun i => Xmap i
Zf : Sieve Y := Sieve.generate (ofArrows (fun x => Xs) fun x => F)
R : CompHaus
g : R ⟶ Y
W : CompHaus
σ : W ⟶ Y
ψ : R ⟶ ∐ fun i => Xmap i
hW' : ψ ≫ Sigma.desc f = g
Q : CompHaus
q : Q ⟶ ∐ Xmap
E : CompHaus
e : Q ⟶ E
r : E ⟶ ∐ Xmap
hq : ofArrows Xmap (fun i => Sigma.ι Xmap i) r ∧ e ≫ r = q
⊢ ∃ Y_1 h g, T g ∧ h ≫ g = q ≫ Sigma.desc f | case this.intro.intro.intro.refine'_1
X : CompHaus
S : Sieve X
Y : CompHaus
T : Presieve Y
I : Type
hI : Fintype I
Xmap : I → CompHaus
f : (a : I) → Xmap a ⟶ Y
h : T = ofArrows Xmap f
hT : Epi (Sigma.desc f)
he : EffectiveEpiFamily Xmap f ↔ Epi (Sigma.desc f)
φ : (i : I) → Xmap i ⟶ ∐ Xmap := fun i => Sigma.ι Xmap i
F : (∐ fun b => Xmap b) ⟶ Y := Sigma.desc f
Z : Sieve Y := Sieve.generate T
Xs : CompHaus := ∐ fun i => Xmap i
Zf : Sieve Y := Sieve.generate (ofArrows (fun x => Xs) fun x => F)
R : CompHaus
g : R ⟶ Y
W : CompHaus
σ : W ⟶ Y
ψ : R ⟶ ∐ fun i => Xmap i
hW' : ψ ≫ Sigma.desc f = g
Q : CompHaus
q : Q ⟶ ∐ Xmap
E : CompHaus
e : Q ⟶ E
r : E ⟶ ∐ Xmap
hq : ofArrows Xmap (fun i => Sigma.ι Xmap i) r ∧ e ≫ r = q
⊢ T (r ≫ F)
case this.intro.intro.intro.refine'_2
X : CompHaus
S : Sieve X
Y : CompHaus
T : Presieve Y
I : Type
hI : Fintype I
Xmap : I → CompHaus
f : (a : I) → Xmap a ⟶ Y
h : T = ofArrows Xmap f
hT : Epi (Sigma.desc f)
he : EffectiveEpiFamily Xmap f ↔ Epi (Sigma.desc f)
φ : (i : I) → Xmap i ⟶ ∐ Xmap := fun i => Sigma.ι Xmap i
F : (∐ fun b => Xmap b) ⟶ Y := Sigma.desc f
Z : Sieve Y := Sieve.generate T
Xs : CompHaus := ∐ fun i => Xmap i
Zf : Sieve Y := Sieve.generate (ofArrows (fun x => Xs) fun x => F)
R : CompHaus
g : R ⟶ Y
W : CompHaus
σ : W ⟶ Y
ψ : R ⟶ ∐ fun i => Xmap i
hW' : ψ ≫ Sigma.desc f = g
Q : CompHaus
q : Q ⟶ ∐ Xmap
E : CompHaus
e : Q ⟶ E
r : E ⟶ ∐ Xmap
hq : ofArrows Xmap (fun i => Sigma.ι Xmap i) r ∧ e ≫ r = q
⊢ e ≫ r ≫ F = q ≫ Sigma.desc f | Please generate a tactic in lean4 to solve the state.
STATE:
case this.intro.intro.intro
X : CompHaus
S : Sieve X
Y : CompHaus
T : Presieve Y
I : Type
hI : Fintype I
Xmap : I → CompHaus
f : (a : I) → Xmap a ⟶ Y
h : T = ofArrows Xmap f
hT : Epi (Sigma.desc f)
he : EffectiveEpiFamily Xmap f ↔ Epi (Sigma.desc f)
φ : (i : I) → Xmap i ⟶ ∐ Xmap := fun i => Sigma.ι Xmap i
F : (∐ fun b => Xmap b) ⟶ Y := Sigma.desc f
Z : Sieve Y := Sieve.generate T
Xs : CompHaus := ∐ fun i => Xmap i
Zf : Sieve Y := Sieve.generate (ofArrows (fun x => Xs) fun x => F)
R : CompHaus
g : R ⟶ Y
W : CompHaus
σ : W ⟶ Y
ψ : R ⟶ ∐ fun i => Xmap i
hW' : ψ ≫ Sigma.desc f = g
Q : CompHaus
q : Q ⟶ ∐ Xmap
E : CompHaus
e : Q ⟶ E
r : E ⟶ ∐ Xmap
hq : ofArrows Xmap (fun i => Sigma.ι Xmap i) r ∧ e ≫ r = q
⊢ ∃ Y_1 h g, T g ∧ h ≫ g = q ≫ Sigma.desc f
TACTIC:
|
https://github.com/adamtopaz/CopenhagenMasterclass2023.git | a293ca1554f7e80d891fd4d86fb092c54d8a0a01 | CompHaus/ExplicitSheaves.lean | CompHaus.extensiveRegular_generates_coherent | [118, 1] | [227, 21] | exact this | case h.h.h.mpr.of.intro.intro.intro.intro.intro.a.intro.intro.intro.intro.mk
X : CompHaus
S : Sieve X
Y : CompHaus
T : Presieve Y
I : Type
hI : Fintype I
Xmap : I → CompHaus
f : (a : I) → Xmap a ⟶ Y
h : T = ofArrows Xmap f
hT : Epi (Sigma.desc f)
he : EffectiveEpiFamily Xmap f ↔ Epi (Sigma.desc f)
φ : (i : I) → Xmap i ⟶ ∐ Xmap := fun i => Sigma.ι Xmap i
F : (∐ fun b => Xmap b) ⟶ Y := Sigma.desc f
Z : Sieve Y := Sieve.generate T
Xs : CompHaus := ∐ fun i => Xmap i
Zf : Sieve Y := Sieve.generate (ofArrows (fun x => Xs) fun x => F)
R : CompHaus
g : R ⟶ Y
W : CompHaus
σ : W ⟶ Y
ψ : R ⟶ ∐ fun i => Xmap i
hW' : ψ ≫ Sigma.desc f = g
this :
Sieve.pullback ψ (Sieve.pullback F Z) ∈
GrothendieckTopology.sieves
(Coverage.toGrothendieck CompHaus (ExtensiveRegularCoverage' CompHaus ?m.588102 ?m.588103)) R
⊢ Coverage.saturate
(ExtensiveRegularCoverage' CompHaus
(_ : ∀ {X Y Z : CompHaus} (f : Y ⟶ X) (π : Z ⟶ X) [inst : Epi π], Epi Limits.pullback.fst)
(_ :
∀ {α : Type} [inst : Fintype α] {X : CompHaus} {Z : α → CompHaus} (π : (a : α) → Z a ⟶ X) {Y : CompHaus}
(f : Y ⟶ X) (x : IsIso (Sigma.desc π)), IsIso (Sigma.desc fun x_1 => Limits.pullback.fst)))
R (Sieve.pullback ψ (Sieve.pullback (Sigma.desc f) Z)) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case h.h.h.mpr.of.intro.intro.intro.intro.intro.a.intro.intro.intro.intro.mk
X : CompHaus
S : Sieve X
Y : CompHaus
T : Presieve Y
I : Type
hI : Fintype I
Xmap : I → CompHaus
f : (a : I) → Xmap a ⟶ Y
h : T = ofArrows Xmap f
hT : Epi (Sigma.desc f)
he : EffectiveEpiFamily Xmap f ↔ Epi (Sigma.desc f)
φ : (i : I) → Xmap i ⟶ ∐ Xmap := fun i => Sigma.ι Xmap i
F : (∐ fun b => Xmap b) ⟶ Y := Sigma.desc f
Z : Sieve Y := Sieve.generate T
Xs : CompHaus := ∐ fun i => Xmap i
Zf : Sieve Y := Sieve.generate (ofArrows (fun x => Xs) fun x => F)
R : CompHaus
g : R ⟶ Y
W : CompHaus
σ : W ⟶ Y
ψ : R ⟶ ∐ fun i => Xmap i
hW' : ψ ≫ Sigma.desc f = g
this :
Sieve.pullback ψ (Sieve.pullback F Z) ∈
GrothendieckTopology.sieves
(Coverage.toGrothendieck CompHaus (ExtensiveRegularCoverage' CompHaus ?m.588102 ?m.588103)) R
⊢ Coverage.saturate
(ExtensiveRegularCoverage' CompHaus
(_ : ∀ {X Y Z : CompHaus} (f : Y ⟶ X) (π : Z ⟶ X) [inst : Epi π], Epi Limits.pullback.fst)
(_ :
∀ {α : Type} [inst : Fintype α] {X : CompHaus} {Z : α → CompHaus} (π : (a : α) → Z a ⟶ X) {Y : CompHaus}
(f : Y ⟶ X) (x : IsIso (Sigma.desc π)), IsIso (Sigma.desc fun x_1 => Limits.pullback.fst)))
R (Sieve.pullback ψ (Sieve.pullback (Sigma.desc f) Z))
TACTIC:
|
https://github.com/adamtopaz/CopenhagenMasterclass2023.git | a293ca1554f7e80d891fd4d86fb092c54d8a0a01 | CompHaus/ExplicitSheaves.lean | CompHaus.extensiveRegular_generates_coherent | [118, 1] | [227, 21] | exact this | case this.a
X : CompHaus
S : Sieve X
Y : CompHaus
T : Presieve Y
I : Type
hI : Fintype I
Xmap : I → CompHaus
f : (a : I) → Xmap a ⟶ Y
h : T = ofArrows Xmap f
hT : Epi (Sigma.desc f)
he : EffectiveEpiFamily Xmap f ↔ Epi (Sigma.desc f)
φ : (i : I) → Xmap i ⟶ ∐ Xmap := fun i => Sigma.ι Xmap i
F : (∐ fun b => Xmap b) ⟶ Y := Sigma.desc f
Z : Sieve Y := Sieve.generate T
Xs : CompHaus := ∐ fun i => Xmap i
Zf : Sieve Y := Sieve.generate (ofArrows (fun x => Xs) fun x => F)
R : CompHaus
g : R ⟶ Y
W : CompHaus
σ : W ⟶ Y
ψ : R ⟶ ∐ fun i => Xmap i
hW' : ψ ≫ Sigma.desc f = g
this : Coverage.saturate (ExtensiveRegularCoverage' CompHaus ?m.593487 ?m.593488) Xs (Sieve.pullback F Z)
⊢ Sieve.pullback (Sigma.desc f) (Sieve.generate T) ∈
Coverage.saturate
(ExtensiveRegularCoverage' CompHaus
(_ : ∀ {X Y Z : CompHaus} (f : Y ⟶ X) (π : Z ⟶ X) [inst : Epi π], Epi Limits.pullback.fst)
(_ :
∀ {α : Type} [inst : Fintype α] {X : CompHaus} {Z : α → CompHaus} (π : (a : α) → Z a ⟶ X) {Y : CompHaus}
(f : Y ⟶ X) (x : IsIso (Sigma.desc π)), IsIso (Sigma.desc fun x_1 => Limits.pullback.fst)))
(∐ fun i => Xmap i) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case this.a
X : CompHaus
S : Sieve X
Y : CompHaus
T : Presieve Y
I : Type
hI : Fintype I
Xmap : I → CompHaus
f : (a : I) → Xmap a ⟶ Y
h : T = ofArrows Xmap f
hT : Epi (Sigma.desc f)
he : EffectiveEpiFamily Xmap f ↔ Epi (Sigma.desc f)
φ : (i : I) → Xmap i ⟶ ∐ Xmap := fun i => Sigma.ι Xmap i
F : (∐ fun b => Xmap b) ⟶ Y := Sigma.desc f
Z : Sieve Y := Sieve.generate T
Xs : CompHaus := ∐ fun i => Xmap i
Zf : Sieve Y := Sieve.generate (ofArrows (fun x => Xs) fun x => F)
R : CompHaus
g : R ⟶ Y
W : CompHaus
σ : W ⟶ Y
ψ : R ⟶ ∐ fun i => Xmap i
hW' : ψ ≫ Sigma.desc f = g
this : Coverage.saturate (ExtensiveRegularCoverage' CompHaus ?m.593487 ?m.593488) Xs (Sieve.pullback F Z)
⊢ Sieve.pullback (Sigma.desc f) (Sieve.generate T) ∈
Coverage.saturate
(ExtensiveRegularCoverage' CompHaus
(_ : ∀ {X Y Z : CompHaus} (f : Y ⟶ X) (π : Z ⟶ X) [inst : Epi π], Epi Limits.pullback.fst)
(_ :
∀ {α : Type} [inst : Fintype α] {X : CompHaus} {Z : α → CompHaus} (π : (a : α) → Z a ⟶ X) {Y : CompHaus}
(f : Y ⟶ X) (x : IsIso (Sigma.desc π)), IsIso (Sigma.desc fun x_1 => Limits.pullback.fst)))
(∐ fun i => Xmap i)
TACTIC:
|
https://github.com/adamtopaz/CopenhagenMasterclass2023.git | a293ca1554f7e80d891fd4d86fb092c54d8a0a01 | CompHaus/ExplicitSheaves.lean | CompHaus.extensiveRegular_generates_coherent | [118, 1] | [227, 21] | apply Coverage.saturate_of_superset _ this | case this
X : CompHaus
S : Sieve X
Y : CompHaus
T : Presieve Y
I : Type
hI : Fintype I
Xmap : I → CompHaus
f : (a : I) → Xmap a ⟶ Y
h : T = ofArrows Xmap f
hT : Epi (Sigma.desc f)
he : EffectiveEpiFamily Xmap f ↔ Epi (Sigma.desc f)
φ : (i : I) → Xmap i ⟶ ∐ Xmap := fun i => Sigma.ι Xmap i
F : (∐ fun b => Xmap b) ⟶ Y := Sigma.desc f
Z : Sieve Y := Sieve.generate T
Xs : CompHaus := ∐ fun i => Xmap i
Zf : Sieve Y := Sieve.generate (ofArrows (fun x => Xs) fun x => F)
R : CompHaus
g : R ⟶ Y
W : CompHaus
σ : W ⟶ Y
ψ : R ⟶ ∐ fun i => Xmap i
hW' : ψ ≫ Sigma.desc f = g
this : Sieve.generate (ofArrows Xmap φ) ≤ Sieve.pullback F Z
⊢ Coverage.saturate
(ExtensiveRegularCoverage' CompHaus
(_ : ∀ {X Y Z : CompHaus} (f : Y ⟶ X) (π : Z ⟶ X) [inst : Epi π], Epi Limits.pullback.fst)
(_ :
∀ {α : Type} [inst : Fintype α] {X : CompHaus} {Z : α → CompHaus} (π : (a : α) → Z a ⟶ X) {Y : CompHaus}
(f : Y ⟶ X) (x : IsIso (Sigma.desc π)), IsIso (Sigma.desc fun x_1 => Limits.pullback.fst)))
Xs (Sieve.pullback F Z) | case this
X : CompHaus
S : Sieve X
Y : CompHaus
T : Presieve Y
I : Type
hI : Fintype I
Xmap : I → CompHaus
f : (a : I) → Xmap a ⟶ Y
h : T = ofArrows Xmap f
hT : Epi (Sigma.desc f)
he : EffectiveEpiFamily Xmap f ↔ Epi (Sigma.desc f)
φ : (i : I) → Xmap i ⟶ ∐ Xmap := fun i => Sigma.ι Xmap i
F : (∐ fun b => Xmap b) ⟶ Y := Sigma.desc f
Z : Sieve Y := Sieve.generate T
Xs : CompHaus := ∐ fun i => Xmap i
Zf : Sieve Y := Sieve.generate (ofArrows (fun x => Xs) fun x => F)
R : CompHaus
g : R ⟶ Y
W : CompHaus
σ : W ⟶ Y
ψ : R ⟶ ∐ fun i => Xmap i
hW' : ψ ≫ Sigma.desc f = g
this : Sieve.generate (ofArrows Xmap φ) ≤ Sieve.pullback F Z
⊢ Coverage.saturate
(ExtensiveRegularCoverage' CompHaus
(_ : ∀ {X Y Z : CompHaus} (f : Y ⟶ X) (π : Z ⟶ X) [inst : Epi π], Epi Limits.pullback.fst)
(_ :
∀ {α : Type} [inst : Fintype α] {X : CompHaus} {Z : α → CompHaus} (π : (a : α) → Z a ⟶ X) {Y : CompHaus}
(f : Y ⟶ X) (x : IsIso (Sigma.desc π)), IsIso (Sigma.desc fun x_1 => Limits.pullback.fst)))
(∐ Xmap) (Sieve.generate (ofArrows Xmap φ)) | Please generate a tactic in lean4 to solve the state.
STATE:
case this
X : CompHaus
S : Sieve X
Y : CompHaus
T : Presieve Y
I : Type
hI : Fintype I
Xmap : I → CompHaus
f : (a : I) → Xmap a ⟶ Y
h : T = ofArrows Xmap f
hT : Epi (Sigma.desc f)
he : EffectiveEpiFamily Xmap f ↔ Epi (Sigma.desc f)
φ : (i : I) → Xmap i ⟶ ∐ Xmap := fun i => Sigma.ι Xmap i
F : (∐ fun b => Xmap b) ⟶ Y := Sigma.desc f
Z : Sieve Y := Sieve.generate T
Xs : CompHaus := ∐ fun i => Xmap i
Zf : Sieve Y := Sieve.generate (ofArrows (fun x => Xs) fun x => F)
R : CompHaus
g : R ⟶ Y
W : CompHaus
σ : W ⟶ Y
ψ : R ⟶ ∐ fun i => Xmap i
hW' : ψ ≫ Sigma.desc f = g
this : Sieve.generate (ofArrows Xmap φ) ≤ Sieve.pullback F Z
⊢ Coverage.saturate
(ExtensiveRegularCoverage' CompHaus
(_ : ∀ {X Y Z : CompHaus} (f : Y ⟶ X) (π : Z ⟶ X) [inst : Epi π], Epi Limits.pullback.fst)
(_ :
∀ {α : Type} [inst : Fintype α] {X : CompHaus} {Z : α → CompHaus} (π : (a : α) → Z a ⟶ X) {Y : CompHaus}
(f : Y ⟶ X) (x : IsIso (Sigma.desc π)), IsIso (Sigma.desc fun x_1 => Limits.pullback.fst)))
Xs (Sieve.pullback F Z)
TACTIC:
|
https://github.com/adamtopaz/CopenhagenMasterclass2023.git | a293ca1554f7e80d891fd4d86fb092c54d8a0a01 | CompHaus/ExplicitSheaves.lean | CompHaus.extensiveRegular_generates_coherent | [118, 1] | [227, 21] | apply Coverage.saturate.of | case this
X : CompHaus
S : Sieve X
Y : CompHaus
T : Presieve Y
I : Type
hI : Fintype I
Xmap : I → CompHaus
f : (a : I) → Xmap a ⟶ Y
h : T = ofArrows Xmap f
hT : Epi (Sigma.desc f)
he : EffectiveEpiFamily Xmap f ↔ Epi (Sigma.desc f)
φ : (i : I) → Xmap i ⟶ ∐ Xmap := fun i => Sigma.ι Xmap i
F : (∐ fun b => Xmap b) ⟶ Y := Sigma.desc f
Z : Sieve Y := Sieve.generate T
Xs : CompHaus := ∐ fun i => Xmap i
Zf : Sieve Y := Sieve.generate (ofArrows (fun x => Xs) fun x => F)
R : CompHaus
g : R ⟶ Y
W : CompHaus
σ : W ⟶ Y
ψ : R ⟶ ∐ fun i => Xmap i
hW' : ψ ≫ Sigma.desc f = g
this : Sieve.generate (ofArrows Xmap φ) ≤ Sieve.pullback F Z
⊢ Coverage.saturate
(ExtensiveRegularCoverage' CompHaus
(_ : ∀ {X Y Z : CompHaus} (f : Y ⟶ X) (π : Z ⟶ X) [inst : Epi π], Epi Limits.pullback.fst)
(_ :
∀ {α : Type} [inst : Fintype α] {X : CompHaus} {Z : α → CompHaus} (π : (a : α) → Z a ⟶ X) {Y : CompHaus}
(f : Y ⟶ X) (x : IsIso (Sigma.desc π)), IsIso (Sigma.desc fun x_1 => Limits.pullback.fst)))
(∐ Xmap) (Sieve.generate (ofArrows Xmap φ)) | case this.hS
X : CompHaus
S : Sieve X
Y : CompHaus
T : Presieve Y
I : Type
hI : Fintype I
Xmap : I → CompHaus
f : (a : I) → Xmap a ⟶ Y
h : T = ofArrows Xmap f
hT : Epi (Sigma.desc f)
he : EffectiveEpiFamily Xmap f ↔ Epi (Sigma.desc f)
φ : (i : I) → Xmap i ⟶ ∐ Xmap := fun i => Sigma.ι Xmap i
F : (∐ fun b => Xmap b) ⟶ Y := Sigma.desc f
Z : Sieve Y := Sieve.generate T
Xs : CompHaus := ∐ fun i => Xmap i
Zf : Sieve Y := Sieve.generate (ofArrows (fun x => Xs) fun x => F)
R : CompHaus
g : R ⟶ Y
W : CompHaus
σ : W ⟶ Y
ψ : R ⟶ ∐ fun i => Xmap i
hW' : ψ ≫ Sigma.desc f = g
this : Sieve.generate (ofArrows Xmap φ) ≤ Sieve.pullback F Z
⊢ ofArrows Xmap φ ∈
Coverage.covering
(ExtensiveRegularCoverage' CompHaus
(_ : ∀ {X Y Z : CompHaus} (f : Y ⟶ X) (π : Z ⟶ X) [inst : Epi π], Epi Limits.pullback.fst)
(_ :
∀ {α : Type} [inst : Fintype α] {X : CompHaus} {Z : α → CompHaus} (π : (a : α) → Z a ⟶ X) {Y : CompHaus}
(f : Y ⟶ X) (x : IsIso (Sigma.desc π)), IsIso (Sigma.desc fun x_1 => Limits.pullback.fst)))
(∐ Xmap) | Please generate a tactic in lean4 to solve the state.
STATE:
case this
X : CompHaus
S : Sieve X
Y : CompHaus
T : Presieve Y
I : Type
hI : Fintype I
Xmap : I → CompHaus
f : (a : I) → Xmap a ⟶ Y
h : T = ofArrows Xmap f
hT : Epi (Sigma.desc f)
he : EffectiveEpiFamily Xmap f ↔ Epi (Sigma.desc f)
φ : (i : I) → Xmap i ⟶ ∐ Xmap := fun i => Sigma.ι Xmap i
F : (∐ fun b => Xmap b) ⟶ Y := Sigma.desc f
Z : Sieve Y := Sieve.generate T
Xs : CompHaus := ∐ fun i => Xmap i
Zf : Sieve Y := Sieve.generate (ofArrows (fun x => Xs) fun x => F)
R : CompHaus
g : R ⟶ Y
W : CompHaus
σ : W ⟶ Y
ψ : R ⟶ ∐ fun i => Xmap i
hW' : ψ ≫ Sigma.desc f = g
this : Sieve.generate (ofArrows Xmap φ) ≤ Sieve.pullback F Z
⊢ Coverage.saturate
(ExtensiveRegularCoverage' CompHaus
(_ : ∀ {X Y Z : CompHaus} (f : Y ⟶ X) (π : Z ⟶ X) [inst : Epi π], Epi Limits.pullback.fst)
(_ :
∀ {α : Type} [inst : Fintype α] {X : CompHaus} {Z : α → CompHaus} (π : (a : α) → Z a ⟶ X) {Y : CompHaus}
(f : Y ⟶ X) (x : IsIso (Sigma.desc π)), IsIso (Sigma.desc fun x_1 => Limits.pullback.fst)))
(∐ Xmap) (Sieve.generate (ofArrows Xmap φ))
TACTIC:
|
https://github.com/adamtopaz/CopenhagenMasterclass2023.git | a293ca1554f7e80d891fd4d86fb092c54d8a0a01 | CompHaus/ExplicitSheaves.lean | CompHaus.extensiveRegular_generates_coherent | [118, 1] | [227, 21] | dsimp [ExtensiveRegularCoverage'] | case this.hS
X : CompHaus
S : Sieve X
Y : CompHaus
T : Presieve Y
I : Type
hI : Fintype I
Xmap : I → CompHaus
f : (a : I) → Xmap a ⟶ Y
h : T = ofArrows Xmap f
hT : Epi (Sigma.desc f)
he : EffectiveEpiFamily Xmap f ↔ Epi (Sigma.desc f)
φ : (i : I) → Xmap i ⟶ ∐ Xmap := fun i => Sigma.ι Xmap i
F : (∐ fun b => Xmap b) ⟶ Y := Sigma.desc f
Z : Sieve Y := Sieve.generate T
Xs : CompHaus := ∐ fun i => Xmap i
Zf : Sieve Y := Sieve.generate (ofArrows (fun x => Xs) fun x => F)
R : CompHaus
g : R ⟶ Y
W : CompHaus
σ : W ⟶ Y
ψ : R ⟶ ∐ fun i => Xmap i
hW' : ψ ≫ Sigma.desc f = g
this : Sieve.generate (ofArrows Xmap φ) ≤ Sieve.pullback F Z
⊢ ofArrows Xmap φ ∈
Coverage.covering
(ExtensiveRegularCoverage' CompHaus
(_ : ∀ {X Y Z : CompHaus} (f : Y ⟶ X) (π : Z ⟶ X) [inst : Epi π], Epi Limits.pullback.fst)
(_ :
∀ {α : Type} [inst : Fintype α] {X : CompHaus} {Z : α → CompHaus} (π : (a : α) → Z a ⟶ X) {Y : CompHaus}
(f : Y ⟶ X) (x : IsIso (Sigma.desc π)), IsIso (Sigma.desc fun x_1 => Limits.pullback.fst)))
(∐ Xmap) | case this.hS
X : CompHaus
S : Sieve X
Y : CompHaus
T : Presieve Y
I : Type
hI : Fintype I
Xmap : I → CompHaus
f : (a : I) → Xmap a ⟶ Y
h : T = ofArrows Xmap f
hT : Epi (Sigma.desc f)
he : EffectiveEpiFamily Xmap f ↔ Epi (Sigma.desc f)
φ : (i : I) → Xmap i ⟶ ∐ Xmap := fun i => Sigma.ι Xmap i
F : (∐ fun b => Xmap b) ⟶ Y := Sigma.desc f
Z : Sieve Y := Sieve.generate T
Xs : CompHaus := ∐ fun i => Xmap i
Zf : Sieve Y := Sieve.generate (ofArrows (fun x => Xs) fun x => F)
R : CompHaus
g : R ⟶ Y
W : CompHaus
σ : W ⟶ Y
ψ : R ⟶ ∐ fun i => Xmap i
hW' : ψ ≫ Sigma.desc f = g
this : Sieve.generate (ofArrows Xmap φ) ≤ Sieve.pullback F Z
⊢ (ofArrows Xmap fun i => Sigma.ι Xmap i) ∈ ExtensiveSieve (∐ Xmap) ∪ RegularSieve (∐ Xmap) | Please generate a tactic in lean4 to solve the state.
STATE:
case this.hS
X : CompHaus
S : Sieve X
Y : CompHaus
T : Presieve Y
I : Type
hI : Fintype I
Xmap : I → CompHaus
f : (a : I) → Xmap a ⟶ Y
h : T = ofArrows Xmap f
hT : Epi (Sigma.desc f)
he : EffectiveEpiFamily Xmap f ↔ Epi (Sigma.desc f)
φ : (i : I) → Xmap i ⟶ ∐ Xmap := fun i => Sigma.ι Xmap i
F : (∐ fun b => Xmap b) ⟶ Y := Sigma.desc f
Z : Sieve Y := Sieve.generate T
Xs : CompHaus := ∐ fun i => Xmap i
Zf : Sieve Y := Sieve.generate (ofArrows (fun x => Xs) fun x => F)
R : CompHaus
g : R ⟶ Y
W : CompHaus
σ : W ⟶ Y
ψ : R ⟶ ∐ fun i => Xmap i
hW' : ψ ≫ Sigma.desc f = g
this : Sieve.generate (ofArrows Xmap φ) ≤ Sieve.pullback F Z
⊢ ofArrows Xmap φ ∈
Coverage.covering
(ExtensiveRegularCoverage' CompHaus
(_ : ∀ {X Y Z : CompHaus} (f : Y ⟶ X) (π : Z ⟶ X) [inst : Epi π], Epi Limits.pullback.fst)
(_ :
∀ {α : Type} [inst : Fintype α] {X : CompHaus} {Z : α → CompHaus} (π : (a : α) → Z a ⟶ X) {Y : CompHaus}
(f : Y ⟶ X) (x : IsIso (Sigma.desc π)), IsIso (Sigma.desc fun x_1 => Limits.pullback.fst)))
(∐ Xmap)
TACTIC:
|
https://github.com/adamtopaz/CopenhagenMasterclass2023.git | a293ca1554f7e80d891fd4d86fb092c54d8a0a01 | CompHaus/ExplicitSheaves.lean | CompHaus.extensiveRegular_generates_coherent | [118, 1] | [227, 21] | left | case this.hS
X : CompHaus
S : Sieve X
Y : CompHaus
T : Presieve Y
I : Type
hI : Fintype I
Xmap : I → CompHaus
f : (a : I) → Xmap a ⟶ Y
h : T = ofArrows Xmap f
hT : Epi (Sigma.desc f)
he : EffectiveEpiFamily Xmap f ↔ Epi (Sigma.desc f)
φ : (i : I) → Xmap i ⟶ ∐ Xmap := fun i => Sigma.ι Xmap i
F : (∐ fun b => Xmap b) ⟶ Y := Sigma.desc f
Z : Sieve Y := Sieve.generate T
Xs : CompHaus := ∐ fun i => Xmap i
Zf : Sieve Y := Sieve.generate (ofArrows (fun x => Xs) fun x => F)
R : CompHaus
g : R ⟶ Y
W : CompHaus
σ : W ⟶ Y
ψ : R ⟶ ∐ fun i => Xmap i
hW' : ψ ≫ Sigma.desc f = g
this : Sieve.generate (ofArrows Xmap φ) ≤ Sieve.pullback F Z
⊢ (ofArrows Xmap fun i => Sigma.ι Xmap i) ∈ ExtensiveSieve (∐ Xmap) ∪ RegularSieve (∐ Xmap) | case this.hS.h
X : CompHaus
S : Sieve X
Y : CompHaus
T : Presieve Y
I : Type
hI : Fintype I
Xmap : I → CompHaus
f : (a : I) → Xmap a ⟶ Y
h : T = ofArrows Xmap f
hT : Epi (Sigma.desc f)
he : EffectiveEpiFamily Xmap f ↔ Epi (Sigma.desc f)
φ : (i : I) → Xmap i ⟶ ∐ Xmap := fun i => Sigma.ι Xmap i
F : (∐ fun b => Xmap b) ⟶ Y := Sigma.desc f
Z : Sieve Y := Sieve.generate T
Xs : CompHaus := ∐ fun i => Xmap i
Zf : Sieve Y := Sieve.generate (ofArrows (fun x => Xs) fun x => F)
R : CompHaus
g : R ⟶ Y
W : CompHaus
σ : W ⟶ Y
ψ : R ⟶ ∐ fun i => Xmap i
hW' : ψ ≫ Sigma.desc f = g
this : Sieve.generate (ofArrows Xmap φ) ≤ Sieve.pullback F Z
⊢ (ofArrows Xmap fun i => Sigma.ι Xmap i) ∈ ExtensiveSieve (∐ Xmap) | Please generate a tactic in lean4 to solve the state.
STATE:
case this.hS
X : CompHaus
S : Sieve X
Y : CompHaus
T : Presieve Y
I : Type
hI : Fintype I
Xmap : I → CompHaus
f : (a : I) → Xmap a ⟶ Y
h : T = ofArrows Xmap f
hT : Epi (Sigma.desc f)
he : EffectiveEpiFamily Xmap f ↔ Epi (Sigma.desc f)
φ : (i : I) → Xmap i ⟶ ∐ Xmap := fun i => Sigma.ι Xmap i
F : (∐ fun b => Xmap b) ⟶ Y := Sigma.desc f
Z : Sieve Y := Sieve.generate T
Xs : CompHaus := ∐ fun i => Xmap i
Zf : Sieve Y := Sieve.generate (ofArrows (fun x => Xs) fun x => F)
R : CompHaus
g : R ⟶ Y
W : CompHaus
σ : W ⟶ Y
ψ : R ⟶ ∐ fun i => Xmap i
hW' : ψ ≫ Sigma.desc f = g
this : Sieve.generate (ofArrows Xmap φ) ≤ Sieve.pullback F Z
⊢ (ofArrows Xmap fun i => Sigma.ι Xmap i) ∈ ExtensiveSieve (∐ Xmap) ∪ RegularSieve (∐ Xmap)
TACTIC:
|
https://github.com/adamtopaz/CopenhagenMasterclass2023.git | a293ca1554f7e80d891fd4d86fb092c54d8a0a01 | CompHaus/ExplicitSheaves.lean | CompHaus.extensiveRegular_generates_coherent | [118, 1] | [227, 21] | refine' ⟨I, hI, Xmap, φ, ⟨rfl, _⟩⟩ | case this.hS.h
X : CompHaus
S : Sieve X
Y : CompHaus
T : Presieve Y
I : Type
hI : Fintype I
Xmap : I → CompHaus
f : (a : I) → Xmap a ⟶ Y
h : T = ofArrows Xmap f
hT : Epi (Sigma.desc f)
he : EffectiveEpiFamily Xmap f ↔ Epi (Sigma.desc f)
φ : (i : I) → Xmap i ⟶ ∐ Xmap := fun i => Sigma.ι Xmap i
F : (∐ fun b => Xmap b) ⟶ Y := Sigma.desc f
Z : Sieve Y := Sieve.generate T
Xs : CompHaus := ∐ fun i => Xmap i
Zf : Sieve Y := Sieve.generate (ofArrows (fun x => Xs) fun x => F)
R : CompHaus
g : R ⟶ Y
W : CompHaus
σ : W ⟶ Y
ψ : R ⟶ ∐ fun i => Xmap i
hW' : ψ ≫ Sigma.desc f = g
this : Sieve.generate (ofArrows Xmap φ) ≤ Sieve.pullback F Z
⊢ (ofArrows Xmap fun i => Sigma.ι Xmap i) ∈ ExtensiveSieve (∐ Xmap) | case this.hS.h
X : CompHaus
S : Sieve X
Y : CompHaus
T : Presieve Y
I : Type
hI : Fintype I
Xmap : I → CompHaus
f : (a : I) → Xmap a ⟶ Y
h : T = ofArrows Xmap f
hT : Epi (Sigma.desc f)
he : EffectiveEpiFamily Xmap f ↔ Epi (Sigma.desc f)
φ : (i : I) → Xmap i ⟶ ∐ Xmap := fun i => Sigma.ι Xmap i
F : (∐ fun b => Xmap b) ⟶ Y := Sigma.desc f
Z : Sieve Y := Sieve.generate T
Xs : CompHaus := ∐ fun i => Xmap i
Zf : Sieve Y := Sieve.generate (ofArrows (fun x => Xs) fun x => F)
R : CompHaus
g : R ⟶ Y
W : CompHaus
σ : W ⟶ Y
ψ : R ⟶ ∐ fun i => Xmap i
hW' : ψ ≫ Sigma.desc f = g
this : Sieve.generate (ofArrows Xmap φ) ≤ Sieve.pullback F Z
⊢ IsIso (Sigma.desc φ) | Please generate a tactic in lean4 to solve the state.
STATE:
case this.hS.h
X : CompHaus
S : Sieve X
Y : CompHaus
T : Presieve Y
I : Type
hI : Fintype I
Xmap : I → CompHaus
f : (a : I) → Xmap a ⟶ Y
h : T = ofArrows Xmap f
hT : Epi (Sigma.desc f)
he : EffectiveEpiFamily Xmap f ↔ Epi (Sigma.desc f)
φ : (i : I) → Xmap i ⟶ ∐ Xmap := fun i => Sigma.ι Xmap i
F : (∐ fun b => Xmap b) ⟶ Y := Sigma.desc f
Z : Sieve Y := Sieve.generate T
Xs : CompHaus := ∐ fun i => Xmap i
Zf : Sieve Y := Sieve.generate (ofArrows (fun x => Xs) fun x => F)
R : CompHaus
g : R ⟶ Y
W : CompHaus
σ : W ⟶ Y
ψ : R ⟶ ∐ fun i => Xmap i
hW' : ψ ≫ Sigma.desc f = g
this : Sieve.generate (ofArrows Xmap φ) ≤ Sieve.pullback F Z
⊢ (ofArrows Xmap fun i => Sigma.ι Xmap i) ∈ ExtensiveSieve (∐ Xmap)
TACTIC:
|
https://github.com/adamtopaz/CopenhagenMasterclass2023.git | a293ca1554f7e80d891fd4d86fb092c54d8a0a01 | CompHaus/ExplicitSheaves.lean | CompHaus.extensiveRegular_generates_coherent | [118, 1] | [227, 21] | suffices : Sigma.desc φ = 𝟙 _ | case this.hS.h
X : CompHaus
S : Sieve X
Y : CompHaus
T : Presieve Y
I : Type
hI : Fintype I
Xmap : I → CompHaus
f : (a : I) → Xmap a ⟶ Y
h : T = ofArrows Xmap f
hT : Epi (Sigma.desc f)
he : EffectiveEpiFamily Xmap f ↔ Epi (Sigma.desc f)
φ : (i : I) → Xmap i ⟶ ∐ Xmap := fun i => Sigma.ι Xmap i
F : (∐ fun b => Xmap b) ⟶ Y := Sigma.desc f
Z : Sieve Y := Sieve.generate T
Xs : CompHaus := ∐ fun i => Xmap i
Zf : Sieve Y := Sieve.generate (ofArrows (fun x => Xs) fun x => F)
R : CompHaus
g : R ⟶ Y
W : CompHaus
σ : W ⟶ Y
ψ : R ⟶ ∐ fun i => Xmap i
hW' : ψ ≫ Sigma.desc f = g
this : Sieve.generate (ofArrows Xmap φ) ≤ Sieve.pullback F Z
⊢ IsIso (Sigma.desc φ) | case this.hS.h
X : CompHaus
S : Sieve X
Y : CompHaus
T : Presieve Y
I : Type
hI : Fintype I
Xmap : I → CompHaus
f : (a : I) → Xmap a ⟶ Y
h : T = ofArrows Xmap f
hT : Epi (Sigma.desc f)
he : EffectiveEpiFamily Xmap f ↔ Epi (Sigma.desc f)
φ : (i : I) → Xmap i ⟶ ∐ Xmap := fun i => Sigma.ι Xmap i
F : (∐ fun b => Xmap b) ⟶ Y := Sigma.desc f
Z : Sieve Y := Sieve.generate T
Xs : CompHaus := ∐ fun i => Xmap i
Zf : Sieve Y := Sieve.generate (ofArrows (fun x => Xs) fun x => F)
R : CompHaus
g : R ⟶ Y
W : CompHaus
σ : W ⟶ Y
ψ : R ⟶ ∐ fun i => Xmap i
hW' : ψ ≫ Sigma.desc f = g
this✝ : Sieve.generate (ofArrows Xmap φ) ≤ Sieve.pullback F Z
this : Sigma.desc φ = 𝟙 (∐ fun b => Xmap b)
⊢ IsIso (Sigma.desc φ)
case this
X : CompHaus
S : Sieve X
Y : CompHaus
T : Presieve Y
I : Type
hI : Fintype I
Xmap : I → CompHaus
f : (a : I) → Xmap a ⟶ Y
h : T = ofArrows Xmap f
hT : Epi (Sigma.desc f)
he : EffectiveEpiFamily Xmap f ↔ Epi (Sigma.desc f)
φ : (i : I) → Xmap i ⟶ ∐ Xmap := fun i => Sigma.ι Xmap i
F : (∐ fun b => Xmap b) ⟶ Y := Sigma.desc f
Z : Sieve Y := Sieve.generate T
Xs : CompHaus := ∐ fun i => Xmap i
Zf : Sieve Y := Sieve.generate (ofArrows (fun x => Xs) fun x => F)
R : CompHaus
g : R ⟶ Y
W : CompHaus
σ : W ⟶ Y
ψ : R ⟶ ∐ fun i => Xmap i
hW' : ψ ≫ Sigma.desc f = g
this : Sieve.generate (ofArrows Xmap φ) ≤ Sieve.pullback F Z
⊢ Sigma.desc φ = 𝟙 (∐ fun b => Xmap b) | Please generate a tactic in lean4 to solve the state.
STATE:
case this.hS.h
X : CompHaus
S : Sieve X
Y : CompHaus
T : Presieve Y
I : Type
hI : Fintype I
Xmap : I → CompHaus
f : (a : I) → Xmap a ⟶ Y
h : T = ofArrows Xmap f
hT : Epi (Sigma.desc f)
he : EffectiveEpiFamily Xmap f ↔ Epi (Sigma.desc f)
φ : (i : I) → Xmap i ⟶ ∐ Xmap := fun i => Sigma.ι Xmap i
F : (∐ fun b => Xmap b) ⟶ Y := Sigma.desc f
Z : Sieve Y := Sieve.generate T
Xs : CompHaus := ∐ fun i => Xmap i
Zf : Sieve Y := Sieve.generate (ofArrows (fun x => Xs) fun x => F)
R : CompHaus
g : R ⟶ Y
W : CompHaus
σ : W ⟶ Y
ψ : R ⟶ ∐ fun i => Xmap i
hW' : ψ ≫ Sigma.desc f = g
this : Sieve.generate (ofArrows Xmap φ) ≤ Sieve.pullback F Z
⊢ IsIso (Sigma.desc φ)
TACTIC:
|
https://github.com/adamtopaz/CopenhagenMasterclass2023.git | a293ca1554f7e80d891fd4d86fb092c54d8a0a01 | CompHaus/ExplicitSheaves.lean | CompHaus.extensiveRegular_generates_coherent | [118, 1] | [227, 21] | ext | case this
X : CompHaus
S : Sieve X
Y : CompHaus
T : Presieve Y
I : Type
hI : Fintype I
Xmap : I → CompHaus
f : (a : I) → Xmap a ⟶ Y
h : T = ofArrows Xmap f
hT : Epi (Sigma.desc f)
he : EffectiveEpiFamily Xmap f ↔ Epi (Sigma.desc f)
φ : (i : I) → Xmap i ⟶ ∐ Xmap := fun i => Sigma.ι Xmap i
F : (∐ fun b => Xmap b) ⟶ Y := Sigma.desc f
Z : Sieve Y := Sieve.generate T
Xs : CompHaus := ∐ fun i => Xmap i
Zf : Sieve Y := Sieve.generate (ofArrows (fun x => Xs) fun x => F)
R : CompHaus
g : R ⟶ Y
W : CompHaus
σ : W ⟶ Y
ψ : R ⟶ ∐ fun i => Xmap i
hW' : ψ ≫ Sigma.desc f = g
this : Sieve.generate (ofArrows Xmap φ) ≤ Sieve.pullback F Z
⊢ Sigma.desc φ = 𝟙 (∐ fun b => Xmap b) | case this.h.w
X : CompHaus
S : Sieve X
Y : CompHaus
T : Presieve Y
I : Type
hI : Fintype I
Xmap : I → CompHaus
f : (a : I) → Xmap a ⟶ Y
h : T = ofArrows Xmap f
hT : Epi (Sigma.desc f)
he : EffectiveEpiFamily Xmap f ↔ Epi (Sigma.desc f)
φ : (i : I) → Xmap i ⟶ ∐ Xmap := fun i => Sigma.ι Xmap i
F : (∐ fun b => Xmap b) ⟶ Y := Sigma.desc f
Z : Sieve Y := Sieve.generate T
Xs : CompHaus := ∐ fun i => Xmap i
Zf : Sieve Y := Sieve.generate (ofArrows (fun x => Xs) fun x => F)
R : CompHaus
g : R ⟶ Y
W : CompHaus
σ : W ⟶ Y
ψ : R ⟶ ∐ fun i => Xmap i
hW' : ψ ≫ Sigma.desc f = g
this : Sieve.generate (ofArrows Xmap φ) ≤ Sieve.pullback F Z
b✝ : I
x✝ : (forget CompHaus).obj (Xmap b✝)
⊢ ↑(Sigma.ι (fun b => Xmap b) b✝ ≫ Sigma.desc φ) x✝ = ↑(Sigma.ι (fun b => Xmap b) b✝ ≫ 𝟙 (∐ fun b => Xmap b)) x✝ | Please generate a tactic in lean4 to solve the state.
STATE:
case this
X : CompHaus
S : Sieve X
Y : CompHaus
T : Presieve Y
I : Type
hI : Fintype I
Xmap : I → CompHaus
f : (a : I) → Xmap a ⟶ Y
h : T = ofArrows Xmap f
hT : Epi (Sigma.desc f)
he : EffectiveEpiFamily Xmap f ↔ Epi (Sigma.desc f)
φ : (i : I) → Xmap i ⟶ ∐ Xmap := fun i => Sigma.ι Xmap i
F : (∐ fun b => Xmap b) ⟶ Y := Sigma.desc f
Z : Sieve Y := Sieve.generate T
Xs : CompHaus := ∐ fun i => Xmap i
Zf : Sieve Y := Sieve.generate (ofArrows (fun x => Xs) fun x => F)
R : CompHaus
g : R ⟶ Y
W : CompHaus
σ : W ⟶ Y
ψ : R ⟶ ∐ fun i => Xmap i
hW' : ψ ≫ Sigma.desc f = g
this : Sieve.generate (ofArrows Xmap φ) ≤ Sieve.pullback F Z
⊢ Sigma.desc φ = 𝟙 (∐ fun b => Xmap b)
TACTIC:
|
https://github.com/adamtopaz/CopenhagenMasterclass2023.git | a293ca1554f7e80d891fd4d86fb092c54d8a0a01 | CompHaus/ExplicitSheaves.lean | CompHaus.extensiveRegular_generates_coherent | [118, 1] | [227, 21] | simp only [colimit.ι_desc, Cofan.mk_pt, Cofan.mk_ι_app, Category.comp_id] | case this.h.w
X : CompHaus
S : Sieve X
Y : CompHaus
T : Presieve Y
I : Type
hI : Fintype I
Xmap : I → CompHaus
f : (a : I) → Xmap a ⟶ Y
h : T = ofArrows Xmap f
hT : Epi (Sigma.desc f)
he : EffectiveEpiFamily Xmap f ↔ Epi (Sigma.desc f)
φ : (i : I) → Xmap i ⟶ ∐ Xmap := fun i => Sigma.ι Xmap i
F : (∐ fun b => Xmap b) ⟶ Y := Sigma.desc f
Z : Sieve Y := Sieve.generate T
Xs : CompHaus := ∐ fun i => Xmap i
Zf : Sieve Y := Sieve.generate (ofArrows (fun x => Xs) fun x => F)
R : CompHaus
g : R ⟶ Y
W : CompHaus
σ : W ⟶ Y
ψ : R ⟶ ∐ fun i => Xmap i
hW' : ψ ≫ Sigma.desc f = g
this : Sieve.generate (ofArrows Xmap φ) ≤ Sieve.pullback F Z
b✝ : I
x✝ : (forget CompHaus).obj (Xmap b✝)
⊢ ↑(Sigma.ι (fun b => Xmap b) b✝ ≫ Sigma.desc φ) x✝ = ↑(Sigma.ι (fun b => Xmap b) b✝ ≫ 𝟙 (∐ fun b => Xmap b)) x✝ | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case this.h.w
X : CompHaus
S : Sieve X
Y : CompHaus
T : Presieve Y
I : Type
hI : Fintype I
Xmap : I → CompHaus
f : (a : I) → Xmap a ⟶ Y
h : T = ofArrows Xmap f
hT : Epi (Sigma.desc f)
he : EffectiveEpiFamily Xmap f ↔ Epi (Sigma.desc f)
φ : (i : I) → Xmap i ⟶ ∐ Xmap := fun i => Sigma.ι Xmap i
F : (∐ fun b => Xmap b) ⟶ Y := Sigma.desc f
Z : Sieve Y := Sieve.generate T
Xs : CompHaus := ∐ fun i => Xmap i
Zf : Sieve Y := Sieve.generate (ofArrows (fun x => Xs) fun x => F)
R : CompHaus
g : R ⟶ Y
W : CompHaus
σ : W ⟶ Y
ψ : R ⟶ ∐ fun i => Xmap i
hW' : ψ ≫ Sigma.desc f = g
this : Sieve.generate (ofArrows Xmap φ) ≤ Sieve.pullback F Z
b✝ : I
x✝ : (forget CompHaus).obj (Xmap b✝)
⊢ ↑(Sigma.ι (fun b => Xmap b) b✝ ≫ Sigma.desc φ) x✝ = ↑(Sigma.ι (fun b => Xmap b) b✝ ≫ 𝟙 (∐ fun b => Xmap b)) x✝
TACTIC:
|
https://github.com/adamtopaz/CopenhagenMasterclass2023.git | a293ca1554f7e80d891fd4d86fb092c54d8a0a01 | CompHaus/ExplicitSheaves.lean | CompHaus.extensiveRegular_generates_coherent | [118, 1] | [227, 21] | rw [this] | case this.hS.h
X : CompHaus
S : Sieve X
Y : CompHaus
T : Presieve Y
I : Type
hI : Fintype I
Xmap : I → CompHaus
f : (a : I) → Xmap a ⟶ Y
h : T = ofArrows Xmap f
hT : Epi (Sigma.desc f)
he : EffectiveEpiFamily Xmap f ↔ Epi (Sigma.desc f)
φ : (i : I) → Xmap i ⟶ ∐ Xmap := fun i => Sigma.ι Xmap i
F : (∐ fun b => Xmap b) ⟶ Y := Sigma.desc f
Z : Sieve Y := Sieve.generate T
Xs : CompHaus := ∐ fun i => Xmap i
Zf : Sieve Y := Sieve.generate (ofArrows (fun x => Xs) fun x => F)
R : CompHaus
g : R ⟶ Y
W : CompHaus
σ : W ⟶ Y
ψ : R ⟶ ∐ fun i => Xmap i
hW' : ψ ≫ Sigma.desc f = g
this✝ : Sieve.generate (ofArrows Xmap φ) ≤ Sieve.pullback F Z
this : Sigma.desc φ = 𝟙 (∐ fun b => Xmap b)
⊢ IsIso (Sigma.desc φ) | case this.hS.h
X : CompHaus
S : Sieve X
Y : CompHaus
T : Presieve Y
I : Type
hI : Fintype I
Xmap : I → CompHaus
f : (a : I) → Xmap a ⟶ Y
h : T = ofArrows Xmap f
hT : Epi (Sigma.desc f)
he : EffectiveEpiFamily Xmap f ↔ Epi (Sigma.desc f)
φ : (i : I) → Xmap i ⟶ ∐ Xmap := fun i => Sigma.ι Xmap i
F : (∐ fun b => Xmap b) ⟶ Y := Sigma.desc f
Z : Sieve Y := Sieve.generate T
Xs : CompHaus := ∐ fun i => Xmap i
Zf : Sieve Y := Sieve.generate (ofArrows (fun x => Xs) fun x => F)
R : CompHaus
g : R ⟶ Y
W : CompHaus
σ : W ⟶ Y
ψ : R ⟶ ∐ fun i => Xmap i
hW' : ψ ≫ Sigma.desc f = g
this✝ : Sieve.generate (ofArrows Xmap φ) ≤ Sieve.pullback F Z
this : Sigma.desc φ = 𝟙 (∐ fun b => Xmap b)
⊢ IsIso (𝟙 (∐ fun b => Xmap b)) | Please generate a tactic in lean4 to solve the state.
STATE:
case this.hS.h
X : CompHaus
S : Sieve X
Y : CompHaus
T : Presieve Y
I : Type
hI : Fintype I
Xmap : I → CompHaus
f : (a : I) → Xmap a ⟶ Y
h : T = ofArrows Xmap f
hT : Epi (Sigma.desc f)
he : EffectiveEpiFamily Xmap f ↔ Epi (Sigma.desc f)
φ : (i : I) → Xmap i ⟶ ∐ Xmap := fun i => Sigma.ι Xmap i
F : (∐ fun b => Xmap b) ⟶ Y := Sigma.desc f
Z : Sieve Y := Sieve.generate T
Xs : CompHaus := ∐ fun i => Xmap i
Zf : Sieve Y := Sieve.generate (ofArrows (fun x => Xs) fun x => F)
R : CompHaus
g : R ⟶ Y
W : CompHaus
σ : W ⟶ Y
ψ : R ⟶ ∐ fun i => Xmap i
hW' : ψ ≫ Sigma.desc f = g
this✝ : Sieve.generate (ofArrows Xmap φ) ≤ Sieve.pullback F Z
this : Sigma.desc φ = 𝟙 (∐ fun b => Xmap b)
⊢ IsIso (Sigma.desc φ)
TACTIC:
|
https://github.com/adamtopaz/CopenhagenMasterclass2023.git | a293ca1554f7e80d891fd4d86fb092c54d8a0a01 | CompHaus/ExplicitSheaves.lean | CompHaus.extensiveRegular_generates_coherent | [118, 1] | [227, 21] | exact inferInstance | case this.hS.h
X : CompHaus
S : Sieve X
Y : CompHaus
T : Presieve Y
I : Type
hI : Fintype I
Xmap : I → CompHaus
f : (a : I) → Xmap a ⟶ Y
h : T = ofArrows Xmap f
hT : Epi (Sigma.desc f)
he : EffectiveEpiFamily Xmap f ↔ Epi (Sigma.desc f)
φ : (i : I) → Xmap i ⟶ ∐ Xmap := fun i => Sigma.ι Xmap i
F : (∐ fun b => Xmap b) ⟶ Y := Sigma.desc f
Z : Sieve Y := Sieve.generate T
Xs : CompHaus := ∐ fun i => Xmap i
Zf : Sieve Y := Sieve.generate (ofArrows (fun x => Xs) fun x => F)
R : CompHaus
g : R ⟶ Y
W : CompHaus
σ : W ⟶ Y
ψ : R ⟶ ∐ fun i => Xmap i
hW' : ψ ≫ Sigma.desc f = g
this✝ : Sieve.generate (ofArrows Xmap φ) ≤ Sieve.pullback F Z
this : Sigma.desc φ = 𝟙 (∐ fun b => Xmap b)
⊢ IsIso (𝟙 (∐ fun b => Xmap b)) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case this.hS.h
X : CompHaus
S : Sieve X
Y : CompHaus
T : Presieve Y
I : Type
hI : Fintype I
Xmap : I → CompHaus
f : (a : I) → Xmap a ⟶ Y
h : T = ofArrows Xmap f
hT : Epi (Sigma.desc f)
he : EffectiveEpiFamily Xmap f ↔ Epi (Sigma.desc f)
φ : (i : I) → Xmap i ⟶ ∐ Xmap := fun i => Sigma.ι Xmap i
F : (∐ fun b => Xmap b) ⟶ Y := Sigma.desc f
Z : Sieve Y := Sieve.generate T
Xs : CompHaus := ∐ fun i => Xmap i
Zf : Sieve Y := Sieve.generate (ofArrows (fun x => Xs) fun x => F)
R : CompHaus
g : R ⟶ Y
W : CompHaus
σ : W ⟶ Y
ψ : R ⟶ ∐ fun i => Xmap i
hW' : ψ ≫ Sigma.desc f = g
this✝ : Sieve.generate (ofArrows Xmap φ) ≤ Sieve.pullback F Z
this : Sigma.desc φ = 𝟙 (∐ fun b => Xmap b)
⊢ IsIso (𝟙 (∐ fun b => Xmap b))
TACTIC:
|
https://github.com/adamtopaz/CopenhagenMasterclass2023.git | a293ca1554f7e80d891fd4d86fb092c54d8a0a01 | CompHaus/ExplicitSheaves.lean | CompHaus.extensiveRegular_generates_coherent | [118, 1] | [227, 21] | rw [h] | case this.intro.intro.intro.refine'_1
X : CompHaus
S : Sieve X
Y : CompHaus
T : Presieve Y
I : Type
hI : Fintype I
Xmap : I → CompHaus
f : (a : I) → Xmap a ⟶ Y
h : T = ofArrows Xmap f
hT : Epi (Sigma.desc f)
he : EffectiveEpiFamily Xmap f ↔ Epi (Sigma.desc f)
φ : (i : I) → Xmap i ⟶ ∐ Xmap := fun i => Sigma.ι Xmap i
F : (∐ fun b => Xmap b) ⟶ Y := Sigma.desc f
Z : Sieve Y := Sieve.generate T
Xs : CompHaus := ∐ fun i => Xmap i
Zf : Sieve Y := Sieve.generate (ofArrows (fun x => Xs) fun x => F)
R : CompHaus
g : R ⟶ Y
W : CompHaus
σ : W ⟶ Y
ψ : R ⟶ ∐ fun i => Xmap i
hW' : ψ ≫ Sigma.desc f = g
Q : CompHaus
q : Q ⟶ ∐ Xmap
E : CompHaus
e : Q ⟶ E
r : E ⟶ ∐ Xmap
hq : ofArrows Xmap (fun i => Sigma.ι Xmap i) r ∧ e ≫ r = q
⊢ T (r ≫ F) | case this.intro.intro.intro.refine'_1
X : CompHaus
S : Sieve X
Y : CompHaus
T : Presieve Y
I : Type
hI : Fintype I
Xmap : I → CompHaus
f : (a : I) → Xmap a ⟶ Y
h : T = ofArrows Xmap f
hT : Epi (Sigma.desc f)
he : EffectiveEpiFamily Xmap f ↔ Epi (Sigma.desc f)
φ : (i : I) → Xmap i ⟶ ∐ Xmap := fun i => Sigma.ι Xmap i
F : (∐ fun b => Xmap b) ⟶ Y := Sigma.desc f
Z : Sieve Y := Sieve.generate T
Xs : CompHaus := ∐ fun i => Xmap i
Zf : Sieve Y := Sieve.generate (ofArrows (fun x => Xs) fun x => F)
R : CompHaus
g : R ⟶ Y
W : CompHaus
σ : W ⟶ Y
ψ : R ⟶ ∐ fun i => Xmap i
hW' : ψ ≫ Sigma.desc f = g
Q : CompHaus
q : Q ⟶ ∐ Xmap
E : CompHaus
e : Q ⟶ E
r : E ⟶ ∐ Xmap
hq : ofArrows Xmap (fun i => Sigma.ι Xmap i) r ∧ e ≫ r = q
⊢ ofArrows Xmap f (r ≫ F) | Please generate a tactic in lean4 to solve the state.
STATE:
case this.intro.intro.intro.refine'_1
X : CompHaus
S : Sieve X
Y : CompHaus
T : Presieve Y
I : Type
hI : Fintype I
Xmap : I → CompHaus
f : (a : I) → Xmap a ⟶ Y
h : T = ofArrows Xmap f
hT : Epi (Sigma.desc f)
he : EffectiveEpiFamily Xmap f ↔ Epi (Sigma.desc f)
φ : (i : I) → Xmap i ⟶ ∐ Xmap := fun i => Sigma.ι Xmap i
F : (∐ fun b => Xmap b) ⟶ Y := Sigma.desc f
Z : Sieve Y := Sieve.generate T
Xs : CompHaus := ∐ fun i => Xmap i
Zf : Sieve Y := Sieve.generate (ofArrows (fun x => Xs) fun x => F)
R : CompHaus
g : R ⟶ Y
W : CompHaus
σ : W ⟶ Y
ψ : R ⟶ ∐ fun i => Xmap i
hW' : ψ ≫ Sigma.desc f = g
Q : CompHaus
q : Q ⟶ ∐ Xmap
E : CompHaus
e : Q ⟶ E
r : E ⟶ ∐ Xmap
hq : ofArrows Xmap (fun i => Sigma.ι Xmap i) r ∧ e ≫ r = q
⊢ T (r ≫ F)
TACTIC:
|
https://github.com/adamtopaz/CopenhagenMasterclass2023.git | a293ca1554f7e80d891fd4d86fb092c54d8a0a01 | CompHaus/ExplicitSheaves.lean | CompHaus.extensiveRegular_generates_coherent | [118, 1] | [227, 21] | induction hq.1 | case this.intro.intro.intro.refine'_1
X : CompHaus
S : Sieve X
Y : CompHaus
T : Presieve Y
I : Type
hI : Fintype I
Xmap : I → CompHaus
f : (a : I) → Xmap a ⟶ Y
h : T = ofArrows Xmap f
hT : Epi (Sigma.desc f)
he : EffectiveEpiFamily Xmap f ↔ Epi (Sigma.desc f)
φ : (i : I) → Xmap i ⟶ ∐ Xmap := fun i => Sigma.ι Xmap i
F : (∐ fun b => Xmap b) ⟶ Y := Sigma.desc f
Z : Sieve Y := Sieve.generate T
Xs : CompHaus := ∐ fun i => Xmap i
Zf : Sieve Y := Sieve.generate (ofArrows (fun x => Xs) fun x => F)
R : CompHaus
g : R ⟶ Y
W : CompHaus
σ : W ⟶ Y
ψ : R ⟶ ∐ fun i => Xmap i
hW' : ψ ≫ Sigma.desc f = g
Q : CompHaus
q : Q ⟶ ∐ Xmap
E : CompHaus
e : Q ⟶ E
r : E ⟶ ∐ Xmap
hq : ofArrows Xmap (fun i => Sigma.ι Xmap i) r ∧ e ≫ r = q
⊢ ofArrows Xmap f (r ≫ F) | case this.intro.intro.intro.refine'_1.mk
X : CompHaus
S : Sieve X
Y : CompHaus
T : Presieve Y
I : Type
hI : Fintype I
Xmap : I → CompHaus
f : (a : I) → Xmap a ⟶ Y
h : T = ofArrows Xmap f
hT : Epi (Sigma.desc f)
he : EffectiveEpiFamily Xmap f ↔ Epi (Sigma.desc f)
φ : (i : I) → Xmap i ⟶ ∐ Xmap := fun i => Sigma.ι Xmap i
F : (∐ fun b => Xmap b) ⟶ Y := Sigma.desc f
Z : Sieve Y := Sieve.generate T
Xs : CompHaus := ∐ fun i => Xmap i
Zf : Sieve Y := Sieve.generate (ofArrows (fun x => Xs) fun x => F)
R : CompHaus
g : R ⟶ Y
W : CompHaus
σ : W ⟶ Y
ψ : R ⟶ ∐ fun i => Xmap i
hW' : ψ ≫ Sigma.desc f = g
Q : CompHaus
q : Q ⟶ ∐ Xmap
E : CompHaus
r : E ⟶ ∐ Xmap
i✝ : I
e : Q ⟶ Xmap i✝
hq : ofArrows Xmap (fun i => Sigma.ι Xmap i) (Sigma.ι Xmap i✝) ∧ e ≫ Sigma.ι Xmap i✝ = q
⊢ ofArrows Xmap f (Sigma.ι Xmap i✝ ≫ F) | Please generate a tactic in lean4 to solve the state.
STATE:
case this.intro.intro.intro.refine'_1
X : CompHaus
S : Sieve X
Y : CompHaus
T : Presieve Y
I : Type
hI : Fintype I
Xmap : I → CompHaus
f : (a : I) → Xmap a ⟶ Y
h : T = ofArrows Xmap f
hT : Epi (Sigma.desc f)
he : EffectiveEpiFamily Xmap f ↔ Epi (Sigma.desc f)
φ : (i : I) → Xmap i ⟶ ∐ Xmap := fun i => Sigma.ι Xmap i
F : (∐ fun b => Xmap b) ⟶ Y := Sigma.desc f
Z : Sieve Y := Sieve.generate T
Xs : CompHaus := ∐ fun i => Xmap i
Zf : Sieve Y := Sieve.generate (ofArrows (fun x => Xs) fun x => F)
R : CompHaus
g : R ⟶ Y
W : CompHaus
σ : W ⟶ Y
ψ : R ⟶ ∐ fun i => Xmap i
hW' : ψ ≫ Sigma.desc f = g
Q : CompHaus
q : Q ⟶ ∐ Xmap
E : CompHaus
e : Q ⟶ E
r : E ⟶ ∐ Xmap
hq : ofArrows Xmap (fun i => Sigma.ι Xmap i) r ∧ e ≫ r = q
⊢ ofArrows Xmap f (r ≫ F)
TACTIC:
|
https://github.com/adamtopaz/CopenhagenMasterclass2023.git | a293ca1554f7e80d891fd4d86fb092c54d8a0a01 | CompHaus/ExplicitSheaves.lean | CompHaus.extensiveRegular_generates_coherent | [118, 1] | [227, 21] | dsimp | case this.intro.intro.intro.refine'_1.mk
X : CompHaus
S : Sieve X
Y : CompHaus
T : Presieve Y
I : Type
hI : Fintype I
Xmap : I → CompHaus
f : (a : I) → Xmap a ⟶ Y
h : T = ofArrows Xmap f
hT : Epi (Sigma.desc f)
he : EffectiveEpiFamily Xmap f ↔ Epi (Sigma.desc f)
φ : (i : I) → Xmap i ⟶ ∐ Xmap := fun i => Sigma.ι Xmap i
F : (∐ fun b => Xmap b) ⟶ Y := Sigma.desc f
Z : Sieve Y := Sieve.generate T
Xs : CompHaus := ∐ fun i => Xmap i
Zf : Sieve Y := Sieve.generate (ofArrows (fun x => Xs) fun x => F)
R : CompHaus
g : R ⟶ Y
W : CompHaus
σ : W ⟶ Y
ψ : R ⟶ ∐ fun i => Xmap i
hW' : ψ ≫ Sigma.desc f = g
Q : CompHaus
q : Q ⟶ ∐ Xmap
E : CompHaus
r : E ⟶ ∐ Xmap
i✝ : I
e : Q ⟶ Xmap i✝
hq : ofArrows Xmap (fun i => Sigma.ι Xmap i) (Sigma.ι Xmap i✝) ∧ e ≫ Sigma.ι Xmap i✝ = q
⊢ ofArrows Xmap f (Sigma.ι Xmap i✝ ≫ F) | case this.intro.intro.intro.refine'_1.mk
X : CompHaus
S : Sieve X
Y : CompHaus
T : Presieve Y
I : Type
hI : Fintype I
Xmap : I → CompHaus
f : (a : I) → Xmap a ⟶ Y
h : T = ofArrows Xmap f
hT : Epi (Sigma.desc f)
he : EffectiveEpiFamily Xmap f ↔ Epi (Sigma.desc f)
φ : (i : I) → Xmap i ⟶ ∐ Xmap := fun i => Sigma.ι Xmap i
F : (∐ fun b => Xmap b) ⟶ Y := Sigma.desc f
Z : Sieve Y := Sieve.generate T
Xs : CompHaus := ∐ fun i => Xmap i
Zf : Sieve Y := Sieve.generate (ofArrows (fun x => Xs) fun x => F)
R : CompHaus
g : R ⟶ Y
W : CompHaus
σ : W ⟶ Y
ψ : R ⟶ ∐ fun i => Xmap i
hW' : ψ ≫ Sigma.desc f = g
Q : CompHaus
q : Q ⟶ ∐ Xmap
E : CompHaus
r : E ⟶ ∐ Xmap
i✝ : I
e : Q ⟶ Xmap i✝
hq : ofArrows Xmap (fun i => Sigma.ι Xmap i) (Sigma.ι Xmap i✝) ∧ e ≫ Sigma.ι Xmap i✝ = q
⊢ ofArrows Xmap f (Sigma.ι Xmap i✝ ≫ Sigma.desc f) | Please generate a tactic in lean4 to solve the state.
STATE:
case this.intro.intro.intro.refine'_1.mk
X : CompHaus
S : Sieve X
Y : CompHaus
T : Presieve Y
I : Type
hI : Fintype I
Xmap : I → CompHaus
f : (a : I) → Xmap a ⟶ Y
h : T = ofArrows Xmap f
hT : Epi (Sigma.desc f)
he : EffectiveEpiFamily Xmap f ↔ Epi (Sigma.desc f)
φ : (i : I) → Xmap i ⟶ ∐ Xmap := fun i => Sigma.ι Xmap i
F : (∐ fun b => Xmap b) ⟶ Y := Sigma.desc f
Z : Sieve Y := Sieve.generate T
Xs : CompHaus := ∐ fun i => Xmap i
Zf : Sieve Y := Sieve.generate (ofArrows (fun x => Xs) fun x => F)
R : CompHaus
g : R ⟶ Y
W : CompHaus
σ : W ⟶ Y
ψ : R ⟶ ∐ fun i => Xmap i
hW' : ψ ≫ Sigma.desc f = g
Q : CompHaus
q : Q ⟶ ∐ Xmap
E : CompHaus
r : E ⟶ ∐ Xmap
i✝ : I
e : Q ⟶ Xmap i✝
hq : ofArrows Xmap (fun i => Sigma.ι Xmap i) (Sigma.ι Xmap i✝) ∧ e ≫ Sigma.ι Xmap i✝ = q
⊢ ofArrows Xmap f (Sigma.ι Xmap i✝ ≫ F)
TACTIC:
|
https://github.com/adamtopaz/CopenhagenMasterclass2023.git | a293ca1554f7e80d891fd4d86fb092c54d8a0a01 | CompHaus/ExplicitSheaves.lean | CompHaus.extensiveRegular_generates_coherent | [118, 1] | [227, 21] | simp only [colimit.ι_desc, Cofan.mk_pt, Cofan.mk_ι_app] | case this.intro.intro.intro.refine'_1.mk
X : CompHaus
S : Sieve X
Y : CompHaus
T : Presieve Y
I : Type
hI : Fintype I
Xmap : I → CompHaus
f : (a : I) → Xmap a ⟶ Y
h : T = ofArrows Xmap f
hT : Epi (Sigma.desc f)
he : EffectiveEpiFamily Xmap f ↔ Epi (Sigma.desc f)
φ : (i : I) → Xmap i ⟶ ∐ Xmap := fun i => Sigma.ι Xmap i
F : (∐ fun b => Xmap b) ⟶ Y := Sigma.desc f
Z : Sieve Y := Sieve.generate T
Xs : CompHaus := ∐ fun i => Xmap i
Zf : Sieve Y := Sieve.generate (ofArrows (fun x => Xs) fun x => F)
R : CompHaus
g : R ⟶ Y
W : CompHaus
σ : W ⟶ Y
ψ : R ⟶ ∐ fun i => Xmap i
hW' : ψ ≫ Sigma.desc f = g
Q : CompHaus
q : Q ⟶ ∐ Xmap
E : CompHaus
r : E ⟶ ∐ Xmap
i✝ : I
e : Q ⟶ Xmap i✝
hq : ofArrows Xmap (fun i => Sigma.ι Xmap i) (Sigma.ι Xmap i✝) ∧ e ≫ Sigma.ι Xmap i✝ = q
⊢ ofArrows Xmap f (Sigma.ι Xmap i✝ ≫ Sigma.desc f) | case this.intro.intro.intro.refine'_1.mk
X : CompHaus
S : Sieve X
Y : CompHaus
T : Presieve Y
I : Type
hI : Fintype I
Xmap : I → CompHaus
f : (a : I) → Xmap a ⟶ Y
h : T = ofArrows Xmap f
hT : Epi (Sigma.desc f)
he : EffectiveEpiFamily Xmap f ↔ Epi (Sigma.desc f)
φ : (i : I) → Xmap i ⟶ ∐ Xmap := fun i => Sigma.ι Xmap i
F : (∐ fun b => Xmap b) ⟶ Y := Sigma.desc f
Z : Sieve Y := Sieve.generate T
Xs : CompHaus := ∐ fun i => Xmap i
Zf : Sieve Y := Sieve.generate (ofArrows (fun x => Xs) fun x => F)
R : CompHaus
g : R ⟶ Y
W : CompHaus
σ : W ⟶ Y
ψ : R ⟶ ∐ fun i => Xmap i
hW' : ψ ≫ Sigma.desc f = g
Q : CompHaus
q : Q ⟶ ∐ Xmap
E : CompHaus
r : E ⟶ ∐ Xmap
i✝ : I
e : Q ⟶ Xmap i✝
hq : ofArrows Xmap (fun i => Sigma.ι Xmap i) (Sigma.ι Xmap i✝) ∧ e ≫ Sigma.ι Xmap i✝ = q
⊢ ofArrows Xmap f (f i✝) | Please generate a tactic in lean4 to solve the state.
STATE:
case this.intro.intro.intro.refine'_1.mk
X : CompHaus
S : Sieve X
Y : CompHaus
T : Presieve Y
I : Type
hI : Fintype I
Xmap : I → CompHaus
f : (a : I) → Xmap a ⟶ Y
h : T = ofArrows Xmap f
hT : Epi (Sigma.desc f)
he : EffectiveEpiFamily Xmap f ↔ Epi (Sigma.desc f)
φ : (i : I) → Xmap i ⟶ ∐ Xmap := fun i => Sigma.ι Xmap i
F : (∐ fun b => Xmap b) ⟶ Y := Sigma.desc f
Z : Sieve Y := Sieve.generate T
Xs : CompHaus := ∐ fun i => Xmap i
Zf : Sieve Y := Sieve.generate (ofArrows (fun x => Xs) fun x => F)
R : CompHaus
g : R ⟶ Y
W : CompHaus
σ : W ⟶ Y
ψ : R ⟶ ∐ fun i => Xmap i
hW' : ψ ≫ Sigma.desc f = g
Q : CompHaus
q : Q ⟶ ∐ Xmap
E : CompHaus
r : E ⟶ ∐ Xmap
i✝ : I
e : Q ⟶ Xmap i✝
hq : ofArrows Xmap (fun i => Sigma.ι Xmap i) (Sigma.ι Xmap i✝) ∧ e ≫ Sigma.ι Xmap i✝ = q
⊢ ofArrows Xmap f (Sigma.ι Xmap i✝ ≫ Sigma.desc f)
TACTIC:
|
https://github.com/adamtopaz/CopenhagenMasterclass2023.git | a293ca1554f7e80d891fd4d86fb092c54d8a0a01 | CompHaus/ExplicitSheaves.lean | CompHaus.extensiveRegular_generates_coherent | [118, 1] | [227, 21] | exact Presieve.ofArrows.mk _ | case this.intro.intro.intro.refine'_1.mk
X : CompHaus
S : Sieve X
Y : CompHaus
T : Presieve Y
I : Type
hI : Fintype I
Xmap : I → CompHaus
f : (a : I) → Xmap a ⟶ Y
h : T = ofArrows Xmap f
hT : Epi (Sigma.desc f)
he : EffectiveEpiFamily Xmap f ↔ Epi (Sigma.desc f)
φ : (i : I) → Xmap i ⟶ ∐ Xmap := fun i => Sigma.ι Xmap i
F : (∐ fun b => Xmap b) ⟶ Y := Sigma.desc f
Z : Sieve Y := Sieve.generate T
Xs : CompHaus := ∐ fun i => Xmap i
Zf : Sieve Y := Sieve.generate (ofArrows (fun x => Xs) fun x => F)
R : CompHaus
g : R ⟶ Y
W : CompHaus
σ : W ⟶ Y
ψ : R ⟶ ∐ fun i => Xmap i
hW' : ψ ≫ Sigma.desc f = g
Q : CompHaus
q : Q ⟶ ∐ Xmap
E : CompHaus
r : E ⟶ ∐ Xmap
i✝ : I
e : Q ⟶ Xmap i✝
hq : ofArrows Xmap (fun i => Sigma.ι Xmap i) (Sigma.ι Xmap i✝) ∧ e ≫ Sigma.ι Xmap i✝ = q
⊢ ofArrows Xmap f (f i✝) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case this.intro.intro.intro.refine'_1.mk
X : CompHaus
S : Sieve X
Y : CompHaus
T : Presieve Y
I : Type
hI : Fintype I
Xmap : I → CompHaus
f : (a : I) → Xmap a ⟶ Y
h : T = ofArrows Xmap f
hT : Epi (Sigma.desc f)
he : EffectiveEpiFamily Xmap f ↔ Epi (Sigma.desc f)
φ : (i : I) → Xmap i ⟶ ∐ Xmap := fun i => Sigma.ι Xmap i
F : (∐ fun b => Xmap b) ⟶ Y := Sigma.desc f
Z : Sieve Y := Sieve.generate T
Xs : CompHaus := ∐ fun i => Xmap i
Zf : Sieve Y := Sieve.generate (ofArrows (fun x => Xs) fun x => F)
R : CompHaus
g : R ⟶ Y
W : CompHaus
σ : W ⟶ Y
ψ : R ⟶ ∐ fun i => Xmap i
hW' : ψ ≫ Sigma.desc f = g
Q : CompHaus
q : Q ⟶ ∐ Xmap
E : CompHaus
r : E ⟶ ∐ Xmap
i✝ : I
e : Q ⟶ Xmap i✝
hq : ofArrows Xmap (fun i => Sigma.ι Xmap i) (Sigma.ι Xmap i✝) ∧ e ≫ Sigma.ι Xmap i✝ = q
⊢ ofArrows Xmap f (f i✝)
TACTIC:
|
https://github.com/adamtopaz/CopenhagenMasterclass2023.git | a293ca1554f7e80d891fd4d86fb092c54d8a0a01 | CompHaus/ExplicitSheaves.lean | CompHaus.extensiveRegular_generates_coherent | [118, 1] | [227, 21] | rw [← hq.2] | case this.intro.intro.intro.refine'_2
X : CompHaus
S : Sieve X
Y : CompHaus
T : Presieve Y
I : Type
hI : Fintype I
Xmap : I → CompHaus
f : (a : I) → Xmap a ⟶ Y
h : T = ofArrows Xmap f
hT : Epi (Sigma.desc f)
he : EffectiveEpiFamily Xmap f ↔ Epi (Sigma.desc f)
φ : (i : I) → Xmap i ⟶ ∐ Xmap := fun i => Sigma.ι Xmap i
F : (∐ fun b => Xmap b) ⟶ Y := Sigma.desc f
Z : Sieve Y := Sieve.generate T
Xs : CompHaus := ∐ fun i => Xmap i
Zf : Sieve Y := Sieve.generate (ofArrows (fun x => Xs) fun x => F)
R : CompHaus
g : R ⟶ Y
W : CompHaus
σ : W ⟶ Y
ψ : R ⟶ ∐ fun i => Xmap i
hW' : ψ ≫ Sigma.desc f = g
Q : CompHaus
q : Q ⟶ ∐ Xmap
E : CompHaus
e : Q ⟶ E
r : E ⟶ ∐ Xmap
hq : ofArrows Xmap (fun i => Sigma.ι Xmap i) r ∧ e ≫ r = q
⊢ e ≫ r ≫ F = q ≫ Sigma.desc f | case this.intro.intro.intro.refine'_2
X : CompHaus
S : Sieve X
Y : CompHaus
T : Presieve Y
I : Type
hI : Fintype I
Xmap : I → CompHaus
f : (a : I) → Xmap a ⟶ Y
h : T = ofArrows Xmap f
hT : Epi (Sigma.desc f)
he : EffectiveEpiFamily Xmap f ↔ Epi (Sigma.desc f)
φ : (i : I) → Xmap i ⟶ ∐ Xmap := fun i => Sigma.ι Xmap i
F : (∐ fun b => Xmap b) ⟶ Y := Sigma.desc f
Z : Sieve Y := Sieve.generate T
Xs : CompHaus := ∐ fun i => Xmap i
Zf : Sieve Y := Sieve.generate (ofArrows (fun x => Xs) fun x => F)
R : CompHaus
g : R ⟶ Y
W : CompHaus
σ : W ⟶ Y
ψ : R ⟶ ∐ fun i => Xmap i
hW' : ψ ≫ Sigma.desc f = g
Q : CompHaus
q : Q ⟶ ∐ Xmap
E : CompHaus
e : Q ⟶ E
r : E ⟶ ∐ Xmap
hq : ofArrows Xmap (fun i => Sigma.ι Xmap i) r ∧ e ≫ r = q
⊢ e ≫ r ≫ F = (e ≫ r) ≫ Sigma.desc f | Please generate a tactic in lean4 to solve the state.
STATE:
case this.intro.intro.intro.refine'_2
X : CompHaus
S : Sieve X
Y : CompHaus
T : Presieve Y
I : Type
hI : Fintype I
Xmap : I → CompHaus
f : (a : I) → Xmap a ⟶ Y
h : T = ofArrows Xmap f
hT : Epi (Sigma.desc f)
he : EffectiveEpiFamily Xmap f ↔ Epi (Sigma.desc f)
φ : (i : I) → Xmap i ⟶ ∐ Xmap := fun i => Sigma.ι Xmap i
F : (∐ fun b => Xmap b) ⟶ Y := Sigma.desc f
Z : Sieve Y := Sieve.generate T
Xs : CompHaus := ∐ fun i => Xmap i
Zf : Sieve Y := Sieve.generate (ofArrows (fun x => Xs) fun x => F)
R : CompHaus
g : R ⟶ Y
W : CompHaus
σ : W ⟶ Y
ψ : R ⟶ ∐ fun i => Xmap i
hW' : ψ ≫ Sigma.desc f = g
Q : CompHaus
q : Q ⟶ ∐ Xmap
E : CompHaus
e : Q ⟶ E
r : E ⟶ ∐ Xmap
hq : ofArrows Xmap (fun i => Sigma.ι Xmap i) r ∧ e ≫ r = q
⊢ e ≫ r ≫ F = q ≫ Sigma.desc f
TACTIC:
|
https://github.com/adamtopaz/CopenhagenMasterclass2023.git | a293ca1554f7e80d891fd4d86fb092c54d8a0a01 | CompHaus/ExplicitSheaves.lean | CompHaus.extensiveRegular_generates_coherent | [118, 1] | [227, 21] | rfl | case this.intro.intro.intro.refine'_2
X : CompHaus
S : Sieve X
Y : CompHaus
T : Presieve Y
I : Type
hI : Fintype I
Xmap : I → CompHaus
f : (a : I) → Xmap a ⟶ Y
h : T = ofArrows Xmap f
hT : Epi (Sigma.desc f)
he : EffectiveEpiFamily Xmap f ↔ Epi (Sigma.desc f)
φ : (i : I) → Xmap i ⟶ ∐ Xmap := fun i => Sigma.ι Xmap i
F : (∐ fun b => Xmap b) ⟶ Y := Sigma.desc f
Z : Sieve Y := Sieve.generate T
Xs : CompHaus := ∐ fun i => Xmap i
Zf : Sieve Y := Sieve.generate (ofArrows (fun x => Xs) fun x => F)
R : CompHaus
g : R ⟶ Y
W : CompHaus
σ : W ⟶ Y
ψ : R ⟶ ∐ fun i => Xmap i
hW' : ψ ≫ Sigma.desc f = g
Q : CompHaus
q : Q ⟶ ∐ Xmap
E : CompHaus
e : Q ⟶ E
r : E ⟶ ∐ Xmap
hq : ofArrows Xmap (fun i => Sigma.ι Xmap i) r ∧ e ≫ r = q
⊢ e ≫ r ≫ F = (e ≫ r) ≫ Sigma.desc f | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case this.intro.intro.intro.refine'_2
X : CompHaus
S : Sieve X
Y : CompHaus
T : Presieve Y
I : Type
hI : Fintype I
Xmap : I → CompHaus
f : (a : I) → Xmap a ⟶ Y
h : T = ofArrows Xmap f
hT : Epi (Sigma.desc f)
he : EffectiveEpiFamily Xmap f ↔ Epi (Sigma.desc f)
φ : (i : I) → Xmap i ⟶ ∐ Xmap := fun i => Sigma.ι Xmap i
F : (∐ fun b => Xmap b) ⟶ Y := Sigma.desc f
Z : Sieve Y := Sieve.generate T
Xs : CompHaus := ∐ fun i => Xmap i
Zf : Sieve Y := Sieve.generate (ofArrows (fun x => Xs) fun x => F)
R : CompHaus
g : R ⟶ Y
W : CompHaus
σ : W ⟶ Y
ψ : R ⟶ ∐ fun i => Xmap i
hW' : ψ ≫ Sigma.desc f = g
Q : CompHaus
q : Q ⟶ ∐ Xmap
E : CompHaus
e : Q ⟶ E
r : E ⟶ ∐ Xmap
hq : ofArrows Xmap (fun i => Sigma.ι Xmap i) r ∧ e ≫ r = q
⊢ e ≫ r ≫ F = (e ≫ r) ≫ Sigma.desc f
TACTIC:
|
https://github.com/adamtopaz/CopenhagenMasterclass2023.git | a293ca1554f7e80d891fd4d86fb092c54d8a0a01 | CompHaus/ExplicitSheaves.lean | CompHaus.extensiveRegular_generates_coherent | [118, 1] | [227, 21] | apply Coverage.saturate.top | case h.h.h.mpr.top
X : CompHaus
S : Sieve X
X✝ : CompHaus
⊢ ⊤ ∈
GrothendieckTopology.sieves
(Coverage.toGrothendieck CompHaus
(ExtensiveRegularCoverage' CompHaus
(_ : ∀ {X Y Z : CompHaus} (f : Y ⟶ X) (π : Z ⟶ X) [inst : Epi π], Epi Limits.pullback.fst)
(_ :
∀ {α : Type} [inst : Fintype α] {X : CompHaus} {Z : α → CompHaus} (π : (a : α) → Z a ⟶ X) {Y : CompHaus}
(f : Y ⟶ X) (x : IsIso (Sigma.desc π)), IsIso (Sigma.desc fun x_1 => Limits.pullback.fst))))
X✝ | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case h.h.h.mpr.top
X : CompHaus
S : Sieve X
X✝ : CompHaus
⊢ ⊤ ∈
GrothendieckTopology.sieves
(Coverage.toGrothendieck CompHaus
(ExtensiveRegularCoverage' CompHaus
(_ : ∀ {X Y Z : CompHaus} (f : Y ⟶ X) (π : Z ⟶ X) [inst : Epi π], Epi Limits.pullback.fst)
(_ :
∀ {α : Type} [inst : Fintype α] {X : CompHaus} {Z : α → CompHaus} (π : (a : α) → Z a ⟶ X) {Y : CompHaus}
(f : Y ⟶ X) (x : IsIso (Sigma.desc π)), IsIso (Sigma.desc fun x_1 => Limits.pullback.fst))))
X✝
TACTIC:
|
https://github.com/adamtopaz/CopenhagenMasterclass2023.git | a293ca1554f7e80d891fd4d86fb092c54d8a0a01 | CompHaus/ExplicitSheaves.lean | CompHaus.extensiveRegular_generates_coherent | [118, 1] | [227, 21] | apply Coverage.saturate.transitive Y T | case h.h.h.mpr.transitive
X : CompHaus
S : Sieve X
Y : CompHaus
T S✝ : Sieve Y
a✝¹ : Coverage.saturate (coherentCoverage CompHaus) Y T
a✝ :
∀ ⦃Y_1 : CompHaus⦄ ⦃f : Y_1 ⟶ Y⦄, T.arrows f → Coverage.saturate (coherentCoverage CompHaus) Y_1 (Sieve.pullback f S✝)
a_ih✝¹ :
T ∈
GrothendieckTopology.sieves
(Coverage.toGrothendieck CompHaus
(ExtensiveRegularCoverage' CompHaus
(_ : ∀ {X Y Z : CompHaus} (f : Y ⟶ X) (π : Z ⟶ X) [inst : Epi π], Epi Limits.pullback.fst)
(_ :
∀ {α : Type} [inst : Fintype α] {X : CompHaus} {Z : α → CompHaus} (π : (a : α) → Z a ⟶ X) {Y : CompHaus}
(f : Y ⟶ X) (x : IsIso (Sigma.desc π)), IsIso (Sigma.desc fun x_1 => Limits.pullback.fst))))
Y
a_ih✝ :
∀ ⦃Y_1 : CompHaus⦄ ⦃f : Y_1 ⟶ Y⦄,
T.arrows f →
Sieve.pullback f S✝ ∈
GrothendieckTopology.sieves
(Coverage.toGrothendieck CompHaus
(ExtensiveRegularCoverage' CompHaus
(_ : ∀ {X Y Z : CompHaus} (f : Y ⟶ X) (π : Z ⟶ X) [inst : Epi π], Epi Limits.pullback.fst)
(_ :
∀ {α : Type} [inst : Fintype α] {X : CompHaus} {Z : α → CompHaus} (π : (a : α) → Z a ⟶ X) {Y : CompHaus}
(f : Y ⟶ X) (x : IsIso (Sigma.desc π)), IsIso (Sigma.desc fun x_1 => Limits.pullback.fst))))
Y_1
⊢ S✝ ∈
GrothendieckTopology.sieves
(Coverage.toGrothendieck CompHaus
(ExtensiveRegularCoverage' CompHaus
(_ : ∀ {X Y Z : CompHaus} (f : Y ⟶ X) (π : Z ⟶ X) [inst : Epi π], Epi Limits.pullback.fst)
(_ :
∀ {α : Type} [inst : Fintype α] {X : CompHaus} {Z : α → CompHaus} (π : (a : α) → Z a ⟶ X) {Y : CompHaus}
(f : Y ⟶ X) (x : IsIso (Sigma.desc π)), IsIso (Sigma.desc fun x_1 => Limits.pullback.fst))))
Y | case h.h.h.mpr.transitive.a
X : CompHaus
S : Sieve X
Y : CompHaus
T S✝ : Sieve Y
a✝¹ : Coverage.saturate (coherentCoverage CompHaus) Y T
a✝ :
∀ ⦃Y_1 : CompHaus⦄ ⦃f : Y_1 ⟶ Y⦄, T.arrows f → Coverage.saturate (coherentCoverage CompHaus) Y_1 (Sieve.pullback f S✝)
a_ih✝¹ :
T ∈
GrothendieckTopology.sieves
(Coverage.toGrothendieck CompHaus
(ExtensiveRegularCoverage' CompHaus
(_ : ∀ {X Y Z : CompHaus} (f : Y ⟶ X) (π : Z ⟶ X) [inst : Epi π], Epi Limits.pullback.fst)
(_ :
∀ {α : Type} [inst : Fintype α] {X : CompHaus} {Z : α → CompHaus} (π : (a : α) → Z a ⟶ X) {Y : CompHaus}
(f : Y ⟶ X) (x : IsIso (Sigma.desc π)), IsIso (Sigma.desc fun x_1 => Limits.pullback.fst))))
Y
a_ih✝ :
∀ ⦃Y_1 : CompHaus⦄ ⦃f : Y_1 ⟶ Y⦄,
T.arrows f →
Sieve.pullback f S✝ ∈
GrothendieckTopology.sieves
(Coverage.toGrothendieck CompHaus
(ExtensiveRegularCoverage' CompHaus
(_ : ∀ {X Y Z : CompHaus} (f : Y ⟶ X) (π : Z ⟶ X) [inst : Epi π], Epi Limits.pullback.fst)
(_ :
∀ {α : Type} [inst : Fintype α] {X : CompHaus} {Z : α → CompHaus} (π : (a : α) → Z a ⟶ X) {Y : CompHaus}
(f : Y ⟶ X) (x : IsIso (Sigma.desc π)), IsIso (Sigma.desc fun x_1 => Limits.pullback.fst))))
Y_1
⊢ Coverage.saturate
(ExtensiveRegularCoverage' CompHaus
(_ : ∀ {X Y Z : CompHaus} (f : Y ⟶ X) (π : Z ⟶ X) [inst : Epi π], Epi Limits.pullback.fst)
(_ :
∀ {α : Type} [inst : Fintype α] {X : CompHaus} {Z : α → CompHaus} (π : (a : α) → Z a ⟶ X) {Y : CompHaus}
(f : Y ⟶ X) (x : IsIso (Sigma.desc π)), IsIso (Sigma.desc fun x_1 => Limits.pullback.fst)))
Y T
case h.h.h.mpr.transitive.a
X : CompHaus
S : Sieve X
Y : CompHaus
T S✝ : Sieve Y
a✝¹ : Coverage.saturate (coherentCoverage CompHaus) Y T
a✝ :
∀ ⦃Y_1 : CompHaus⦄ ⦃f : Y_1 ⟶ Y⦄, T.arrows f → Coverage.saturate (coherentCoverage CompHaus) Y_1 (Sieve.pullback f S✝)
a_ih✝¹ :
T ∈
GrothendieckTopology.sieves
(Coverage.toGrothendieck CompHaus
(ExtensiveRegularCoverage' CompHaus
(_ : ∀ {X Y Z : CompHaus} (f : Y ⟶ X) (π : Z ⟶ X) [inst : Epi π], Epi Limits.pullback.fst)
(_ :
∀ {α : Type} [inst : Fintype α] {X : CompHaus} {Z : α → CompHaus} (π : (a : α) → Z a ⟶ X) {Y : CompHaus}
(f : Y ⟶ X) (x : IsIso (Sigma.desc π)), IsIso (Sigma.desc fun x_1 => Limits.pullback.fst))))
Y
a_ih✝ :
∀ ⦃Y_1 : CompHaus⦄ ⦃f : Y_1 ⟶ Y⦄,
T.arrows f →
Sieve.pullback f S✝ ∈
GrothendieckTopology.sieves
(Coverage.toGrothendieck CompHaus
(ExtensiveRegularCoverage' CompHaus
(_ : ∀ {X Y Z : CompHaus} (f : Y ⟶ X) (π : Z ⟶ X) [inst : Epi π], Epi Limits.pullback.fst)
(_ :
∀ {α : Type} [inst : Fintype α] {X : CompHaus} {Z : α → CompHaus} (π : (a : α) → Z a ⟶ X) {Y : CompHaus}
(f : Y ⟶ X) (x : IsIso (Sigma.desc π)), IsIso (Sigma.desc fun x_1 => Limits.pullback.fst))))
Y_1
⊢ ∀ ⦃Y_1 : CompHaus⦄ ⦃f : Y_1 ⟶ Y⦄,
T.arrows f →
Coverage.saturate
(ExtensiveRegularCoverage' CompHaus
(_ : ∀ {X Y Z : CompHaus} (f : Y ⟶ X) (π : Z ⟶ X) [inst : Epi π], Epi Limits.pullback.fst)
(_ :
∀ {α : Type} [inst : Fintype α] {X : CompHaus} {Z : α → CompHaus} (π : (a : α) → Z a ⟶ X) {Y : CompHaus}
(f : Y ⟶ X) (x : IsIso (Sigma.desc π)), IsIso (Sigma.desc fun x_1 => Limits.pullback.fst)))
Y_1 (Sieve.pullback f S✝) | Please generate a tactic in lean4 to solve the state.
STATE:
case h.h.h.mpr.transitive
X : CompHaus
S : Sieve X
Y : CompHaus
T S✝ : Sieve Y
a✝¹ : Coverage.saturate (coherentCoverage CompHaus) Y T
a✝ :
∀ ⦃Y_1 : CompHaus⦄ ⦃f : Y_1 ⟶ Y⦄, T.arrows f → Coverage.saturate (coherentCoverage CompHaus) Y_1 (Sieve.pullback f S✝)
a_ih✝¹ :
T ∈
GrothendieckTopology.sieves
(Coverage.toGrothendieck CompHaus
(ExtensiveRegularCoverage' CompHaus
(_ : ∀ {X Y Z : CompHaus} (f : Y ⟶ X) (π : Z ⟶ X) [inst : Epi π], Epi Limits.pullback.fst)
(_ :
∀ {α : Type} [inst : Fintype α] {X : CompHaus} {Z : α → CompHaus} (π : (a : α) → Z a ⟶ X) {Y : CompHaus}
(f : Y ⟶ X) (x : IsIso (Sigma.desc π)), IsIso (Sigma.desc fun x_1 => Limits.pullback.fst))))
Y
a_ih✝ :
∀ ⦃Y_1 : CompHaus⦄ ⦃f : Y_1 ⟶ Y⦄,
T.arrows f →
Sieve.pullback f S✝ ∈
GrothendieckTopology.sieves
(Coverage.toGrothendieck CompHaus
(ExtensiveRegularCoverage' CompHaus
(_ : ∀ {X Y Z : CompHaus} (f : Y ⟶ X) (π : Z ⟶ X) [inst : Epi π], Epi Limits.pullback.fst)
(_ :
∀ {α : Type} [inst : Fintype α] {X : CompHaus} {Z : α → CompHaus} (π : (a : α) → Z a ⟶ X) {Y : CompHaus}
(f : Y ⟶ X) (x : IsIso (Sigma.desc π)), IsIso (Sigma.desc fun x_1 => Limits.pullback.fst))))
Y_1
⊢ S✝ ∈
GrothendieckTopology.sieves
(Coverage.toGrothendieck CompHaus
(ExtensiveRegularCoverage' CompHaus
(_ : ∀ {X Y Z : CompHaus} (f : Y ⟶ X) (π : Z ⟶ X) [inst : Epi π], Epi Limits.pullback.fst)
(_ :
∀ {α : Type} [inst : Fintype α] {X : CompHaus} {Z : α → CompHaus} (π : (a : α) → Z a ⟶ X) {Y : CompHaus}
(f : Y ⟶ X) (x : IsIso (Sigma.desc π)), IsIso (Sigma.desc fun x_1 => Limits.pullback.fst))))
Y
TACTIC:
|
https://github.com/adamtopaz/CopenhagenMasterclass2023.git | a293ca1554f7e80d891fd4d86fb092c54d8a0a01 | CompHaus/ExplicitSheaves.lean | CompHaus.extensiveRegular_generates_coherent | [118, 1] | [227, 21] | assumption | case h.h.h.mpr.transitive.a
X : CompHaus
S : Sieve X
Y : CompHaus
T S✝ : Sieve Y
a✝¹ : Coverage.saturate (coherentCoverage CompHaus) Y T
a✝ :
∀ ⦃Y_1 : CompHaus⦄ ⦃f : Y_1 ⟶ Y⦄, T.arrows f → Coverage.saturate (coherentCoverage CompHaus) Y_1 (Sieve.pullback f S✝)
a_ih✝¹ :
T ∈
GrothendieckTopology.sieves
(Coverage.toGrothendieck CompHaus
(ExtensiveRegularCoverage' CompHaus
(_ : ∀ {X Y Z : CompHaus} (f : Y ⟶ X) (π : Z ⟶ X) [inst : Epi π], Epi Limits.pullback.fst)
(_ :
∀ {α : Type} [inst : Fintype α] {X : CompHaus} {Z : α → CompHaus} (π : (a : α) → Z a ⟶ X) {Y : CompHaus}
(f : Y ⟶ X) (x : IsIso (Sigma.desc π)), IsIso (Sigma.desc fun x_1 => Limits.pullback.fst))))
Y
a_ih✝ :
∀ ⦃Y_1 : CompHaus⦄ ⦃f : Y_1 ⟶ Y⦄,
T.arrows f →
Sieve.pullback f S✝ ∈
GrothendieckTopology.sieves
(Coverage.toGrothendieck CompHaus
(ExtensiveRegularCoverage' CompHaus
(_ : ∀ {X Y Z : CompHaus} (f : Y ⟶ X) (π : Z ⟶ X) [inst : Epi π], Epi Limits.pullback.fst)
(_ :
∀ {α : Type} [inst : Fintype α] {X : CompHaus} {Z : α → CompHaus} (π : (a : α) → Z a ⟶ X) {Y : CompHaus}
(f : Y ⟶ X) (x : IsIso (Sigma.desc π)), IsIso (Sigma.desc fun x_1 => Limits.pullback.fst))))
Y_1
⊢ Coverage.saturate
(ExtensiveRegularCoverage' CompHaus
(_ : ∀ {X Y Z : CompHaus} (f : Y ⟶ X) (π : Z ⟶ X) [inst : Epi π], Epi Limits.pullback.fst)
(_ :
∀ {α : Type} [inst : Fintype α] {X : CompHaus} {Z : α → CompHaus} (π : (a : α) → Z a ⟶ X) {Y : CompHaus}
(f : Y ⟶ X) (x : IsIso (Sigma.desc π)), IsIso (Sigma.desc fun x_1 => Limits.pullback.fst)))
Y T | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case h.h.h.mpr.transitive.a
X : CompHaus
S : Sieve X
Y : CompHaus
T S✝ : Sieve Y
a✝¹ : Coverage.saturate (coherentCoverage CompHaus) Y T
a✝ :
∀ ⦃Y_1 : CompHaus⦄ ⦃f : Y_1 ⟶ Y⦄, T.arrows f → Coverage.saturate (coherentCoverage CompHaus) Y_1 (Sieve.pullback f S✝)
a_ih✝¹ :
T ∈
GrothendieckTopology.sieves
(Coverage.toGrothendieck CompHaus
(ExtensiveRegularCoverage' CompHaus
(_ : ∀ {X Y Z : CompHaus} (f : Y ⟶ X) (π : Z ⟶ X) [inst : Epi π], Epi Limits.pullback.fst)
(_ :
∀ {α : Type} [inst : Fintype α] {X : CompHaus} {Z : α → CompHaus} (π : (a : α) → Z a ⟶ X) {Y : CompHaus}
(f : Y ⟶ X) (x : IsIso (Sigma.desc π)), IsIso (Sigma.desc fun x_1 => Limits.pullback.fst))))
Y
a_ih✝ :
∀ ⦃Y_1 : CompHaus⦄ ⦃f : Y_1 ⟶ Y⦄,
T.arrows f →
Sieve.pullback f S✝ ∈
GrothendieckTopology.sieves
(Coverage.toGrothendieck CompHaus
(ExtensiveRegularCoverage' CompHaus
(_ : ∀ {X Y Z : CompHaus} (f : Y ⟶ X) (π : Z ⟶ X) [inst : Epi π], Epi Limits.pullback.fst)
(_ :
∀ {α : Type} [inst : Fintype α] {X : CompHaus} {Z : α → CompHaus} (π : (a : α) → Z a ⟶ X) {Y : CompHaus}
(f : Y ⟶ X) (x : IsIso (Sigma.desc π)), IsIso (Sigma.desc fun x_1 => Limits.pullback.fst))))
Y_1
⊢ Coverage.saturate
(ExtensiveRegularCoverage' CompHaus
(_ : ∀ {X Y Z : CompHaus} (f : Y ⟶ X) (π : Z ⟶ X) [inst : Epi π], Epi Limits.pullback.fst)
(_ :
∀ {α : Type} [inst : Fintype α] {X : CompHaus} {Z : α → CompHaus} (π : (a : α) → Z a ⟶ X) {Y : CompHaus}
(f : Y ⟶ X) (x : IsIso (Sigma.desc π)), IsIso (Sigma.desc fun x_1 => Limits.pullback.fst)))
Y T
TACTIC:
|
https://github.com/adamtopaz/CopenhagenMasterclass2023.git | a293ca1554f7e80d891fd4d86fb092c54d8a0a01 | CompHaus/ExplicitSheaves.lean | CompHaus.extensiveRegular_generates_coherent | [118, 1] | [227, 21] | assumption | case h.h.h.mpr.transitive.a
X : CompHaus
S : Sieve X
Y : CompHaus
T S✝ : Sieve Y
a✝¹ : Coverage.saturate (coherentCoverage CompHaus) Y T
a✝ :
∀ ⦃Y_1 : CompHaus⦄ ⦃f : Y_1 ⟶ Y⦄, T.arrows f → Coverage.saturate (coherentCoverage CompHaus) Y_1 (Sieve.pullback f S✝)
a_ih✝¹ :
T ∈
GrothendieckTopology.sieves
(Coverage.toGrothendieck CompHaus
(ExtensiveRegularCoverage' CompHaus
(_ : ∀ {X Y Z : CompHaus} (f : Y ⟶ X) (π : Z ⟶ X) [inst : Epi π], Epi Limits.pullback.fst)
(_ :
∀ {α : Type} [inst : Fintype α] {X : CompHaus} {Z : α → CompHaus} (π : (a : α) → Z a ⟶ X) {Y : CompHaus}
(f : Y ⟶ X) (x : IsIso (Sigma.desc π)), IsIso (Sigma.desc fun x_1 => Limits.pullback.fst))))
Y
a_ih✝ :
∀ ⦃Y_1 : CompHaus⦄ ⦃f : Y_1 ⟶ Y⦄,
T.arrows f →
Sieve.pullback f S✝ ∈
GrothendieckTopology.sieves
(Coverage.toGrothendieck CompHaus
(ExtensiveRegularCoverage' CompHaus
(_ : ∀ {X Y Z : CompHaus} (f : Y ⟶ X) (π : Z ⟶ X) [inst : Epi π], Epi Limits.pullback.fst)
(_ :
∀ {α : Type} [inst : Fintype α] {X : CompHaus} {Z : α → CompHaus} (π : (a : α) → Z a ⟶ X) {Y : CompHaus}
(f : Y ⟶ X) (x : IsIso (Sigma.desc π)), IsIso (Sigma.desc fun x_1 => Limits.pullback.fst))))
Y_1
⊢ ∀ ⦃Y_1 : CompHaus⦄ ⦃f : Y_1 ⟶ Y⦄,
T.arrows f →
Coverage.saturate
(ExtensiveRegularCoverage' CompHaus
(_ : ∀ {X Y Z : CompHaus} (f : Y ⟶ X) (π : Z ⟶ X) [inst : Epi π], Epi Limits.pullback.fst)
(_ :
∀ {α : Type} [inst : Fintype α] {X : CompHaus} {Z : α → CompHaus} (π : (a : α) → Z a ⟶ X) {Y : CompHaus}
(f : Y ⟶ X) (x : IsIso (Sigma.desc π)), IsIso (Sigma.desc fun x_1 => Limits.pullback.fst)))
Y_1 (Sieve.pullback f S✝) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case h.h.h.mpr.transitive.a
X : CompHaus
S : Sieve X
Y : CompHaus
T S✝ : Sieve Y
a✝¹ : Coverage.saturate (coherentCoverage CompHaus) Y T
a✝ :
∀ ⦃Y_1 : CompHaus⦄ ⦃f : Y_1 ⟶ Y⦄, T.arrows f → Coverage.saturate (coherentCoverage CompHaus) Y_1 (Sieve.pullback f S✝)
a_ih✝¹ :
T ∈
GrothendieckTopology.sieves
(Coverage.toGrothendieck CompHaus
(ExtensiveRegularCoverage' CompHaus
(_ : ∀ {X Y Z : CompHaus} (f : Y ⟶ X) (π : Z ⟶ X) [inst : Epi π], Epi Limits.pullback.fst)
(_ :
∀ {α : Type} [inst : Fintype α] {X : CompHaus} {Z : α → CompHaus} (π : (a : α) → Z a ⟶ X) {Y : CompHaus}
(f : Y ⟶ X) (x : IsIso (Sigma.desc π)), IsIso (Sigma.desc fun x_1 => Limits.pullback.fst))))
Y
a_ih✝ :
∀ ⦃Y_1 : CompHaus⦄ ⦃f : Y_1 ⟶ Y⦄,
T.arrows f →
Sieve.pullback f S✝ ∈
GrothendieckTopology.sieves
(Coverage.toGrothendieck CompHaus
(ExtensiveRegularCoverage' CompHaus
(_ : ∀ {X Y Z : CompHaus} (f : Y ⟶ X) (π : Z ⟶ X) [inst : Epi π], Epi Limits.pullback.fst)
(_ :
∀ {α : Type} [inst : Fintype α] {X : CompHaus} {Z : α → CompHaus} (π : (a : α) → Z a ⟶ X) {Y : CompHaus}
(f : Y ⟶ X) (x : IsIso (Sigma.desc π)), IsIso (Sigma.desc fun x_1 => Limits.pullback.fst))))
Y_1
⊢ ∀ ⦃Y_1 : CompHaus⦄ ⦃f : Y_1 ⟶ Y⦄,
T.arrows f →
Coverage.saturate
(ExtensiveRegularCoverage' CompHaus
(_ : ∀ {X Y Z : CompHaus} (f : Y ⟶ X) (π : Z ⟶ X) [inst : Epi π], Epi Limits.pullback.fst)
(_ :
∀ {α : Type} [inst : Fintype α] {X : CompHaus} {Z : α → CompHaus} (π : (a : α) → Z a ⟶ X) {Y : CompHaus}
(f : Y ⟶ X) (x : IsIso (Sigma.desc π)), IsIso (Sigma.desc fun x_1 => Limits.pullback.fst)))
Y_1 (Sieve.pullback f S✝)
TACTIC:
|
https://github.com/adamtopaz/CopenhagenMasterclass2023.git | a293ca1554f7e80d891fd4d86fb092c54d8a0a01 | CompHaus/ExplicitSheaves.lean | CompHaus.isSheafFor_of_Dagur | [277, 1] | [352, 22] | cases' hS with hSIso hSSingle | B : CompHaus
S : Presieve B
hS :
S ∈
Coverage.covering
(ExtensiveRegularCoverage' CompHaus
(_ : ∀ {X Y Z : CompHaus} (f : Y ⟶ X) (π : Z ⟶ X) [inst : Epi π], Epi Limits.pullback.fst)
(_ :
∀ {α : Type} [inst : Fintype α] {X : CompHaus} {Z : α → CompHaus} (π : (a : α) → Z a ⟶ X) {Y : CompHaus}
(f : Y ⟶ X) (x : IsIso (Sigma.desc π)), IsIso (Sigma.desc fun x_1 => Limits.pullback.fst)))
B
F : CompHausᵒᵖ ⥤ Type (u + 1)
hFpfp : PreservesFiniteProducts F
hFecs : EqualizerCondition F
⊢ IsSheafFor F S | case inl
B : CompHaus
S : Presieve B
F : CompHausᵒᵖ ⥤ Type (u + 1)
hFpfp : PreservesFiniteProducts F
hFecs : EqualizerCondition F
hSIso : S ∈ ExtensiveSieve B
⊢ IsSheafFor F S
case inr
B : CompHaus
S : Presieve B
F : CompHausᵒᵖ ⥤ Type (u + 1)
hFpfp : PreservesFiniteProducts F
hFecs : EqualizerCondition F
hSSingle : S ∈ RegularSieve B
⊢ IsSheafFor F S | Please generate a tactic in lean4 to solve the state.
STATE:
B : CompHaus
S : Presieve B
hS :
S ∈
Coverage.covering
(ExtensiveRegularCoverage' CompHaus
(_ : ∀ {X Y Z : CompHaus} (f : Y ⟶ X) (π : Z ⟶ X) [inst : Epi π], Epi Limits.pullback.fst)
(_ :
∀ {α : Type} [inst : Fintype α] {X : CompHaus} {Z : α → CompHaus} (π : (a : α) → Z a ⟶ X) {Y : CompHaus}
(f : Y ⟶ X) (x : IsIso (Sigma.desc π)), IsIso (Sigma.desc fun x_1 => Limits.pullback.fst)))
B
F : CompHausᵒᵖ ⥤ Type (u + 1)
hFpfp : PreservesFiniteProducts F
hFecs : EqualizerCondition F
⊢ IsSheafFor F S
TACTIC:
|
https://github.com/adamtopaz/CopenhagenMasterclass2023.git | a293ca1554f7e80d891fd4d86fb092c54d8a0a01 | CompHaus/ExplicitSheaves.lean | CompHaus.isSheafFor_of_Dagur | [277, 1] | [352, 22] | exact isSheafForExtensiveSieve hSIso hFpfp | case inl
B : CompHaus
S : Presieve B
F : CompHausᵒᵖ ⥤ Type (u + 1)
hFpfp : PreservesFiniteProducts F
hFecs : EqualizerCondition F
hSIso : S ∈ ExtensiveSieve B
⊢ IsSheafFor F S | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case inl
B : CompHaus
S : Presieve B
F : CompHausᵒᵖ ⥤ Type (u + 1)
hFpfp : PreservesFiniteProducts F
hFecs : EqualizerCondition F
hSIso : S ∈ ExtensiveSieve B
⊢ IsSheafFor F S
TACTIC:
|
https://github.com/adamtopaz/CopenhagenMasterclass2023.git | a293ca1554f7e80d891fd4d86fb092c54d8a0a01 | CompHaus/ExplicitSheaves.lean | CompHaus.isSheafFor_of_Dagur | [277, 1] | [352, 22] | rw [Equalizer.Presieve.sheaf_condition, Limits.Types.type_equalizer_iff_unique] | case inr
B : CompHaus
S : Presieve B
F : CompHausᵒᵖ ⥤ Type (u + 1)
hFpfp : PreservesFiniteProducts F
hFecs : EqualizerCondition F
hSSingle : S ∈ RegularSieve B
⊢ IsSheafFor F S | case inr
B : CompHaus
S : Presieve B
F : CompHausᵒᵖ ⥤ Type (u + 1)
hFpfp : PreservesFiniteProducts F
hFecs : EqualizerCondition F
hSSingle : S ∈ RegularSieve B
⊢ ∀ (y : Equalizer.FirstObj F S),
Equalizer.Presieve.firstMap F S y = Equalizer.Presieve.secondMap F S y → ∃! x, Equalizer.forkMap F S x = y | Please generate a tactic in lean4 to solve the state.
STATE:
case inr
B : CompHaus
S : Presieve B
F : CompHausᵒᵖ ⥤ Type (u + 1)
hFpfp : PreservesFiniteProducts F
hFecs : EqualizerCondition F
hSSingle : S ∈ RegularSieve B
⊢ IsSheafFor F S
TACTIC:
|
https://github.com/adamtopaz/CopenhagenMasterclass2023.git | a293ca1554f7e80d891fd4d86fb092c54d8a0a01 | CompHaus/ExplicitSheaves.lean | CompHaus.isSheafFor_of_Dagur | [277, 1] | [352, 22] | intro y h | case inr
B : CompHaus
S : Presieve B
F : CompHausᵒᵖ ⥤ Type (u + 1)
hFpfp : PreservesFiniteProducts F
hFecs : EqualizerCondition F
hSSingle : S ∈ RegularSieve B
⊢ ∀ (y : Equalizer.FirstObj F S),
Equalizer.Presieve.firstMap F S y = Equalizer.Presieve.secondMap F S y → ∃! x, Equalizer.forkMap F S x = y | case inr
B : CompHaus
S : Presieve B
F : CompHausᵒᵖ ⥤ Type (u + 1)
hFpfp : PreservesFiniteProducts F
hFecs : EqualizerCondition F
hSSingle : S ∈ RegularSieve B
y : Equalizer.FirstObj F S
h : Equalizer.Presieve.firstMap F S y = Equalizer.Presieve.secondMap F S y
⊢ ∃! x, Equalizer.forkMap F S x = y | Please generate a tactic in lean4 to solve the state.
STATE:
case inr
B : CompHaus
S : Presieve B
F : CompHausᵒᵖ ⥤ Type (u + 1)
hFpfp : PreservesFiniteProducts F
hFecs : EqualizerCondition F
hSSingle : S ∈ RegularSieve B
⊢ ∀ (y : Equalizer.FirstObj F S),
Equalizer.Presieve.firstMap F S y = Equalizer.Presieve.secondMap F S y → ∃! x, Equalizer.forkMap F S x = y
TACTIC:
|
https://github.com/adamtopaz/CopenhagenMasterclass2023.git | a293ca1554f7e80d891fd4d86fb092c54d8a0a01 | CompHaus/ExplicitSheaves.lean | CompHaus.isSheafFor_of_Dagur | [277, 1] | [352, 22] | dsimp [RegularSieve] at hSSingle | case inr
B : CompHaus
S : Presieve B
F : CompHausᵒᵖ ⥤ Type (u + 1)
hFpfp : PreservesFiniteProducts F
hFecs : EqualizerCondition F
hSSingle : S ∈ RegularSieve B
y : Equalizer.FirstObj F S
h : Equalizer.Presieve.firstMap F S y = Equalizer.Presieve.secondMap F S y
⊢ ∃! x, Equalizer.forkMap F S x = y | case inr
B : CompHaus
S : Presieve B
F : CompHausᵒᵖ ⥤ Type (u + 1)
hFpfp : PreservesFiniteProducts F
hFecs : EqualizerCondition F
hSSingle : ∃ X f, (S = ofArrows (fun x => X) fun x => f) ∧ Epi f
y : Equalizer.FirstObj F S
h : Equalizer.Presieve.firstMap F S y = Equalizer.Presieve.secondMap F S y
⊢ ∃! x, Equalizer.forkMap F S x = y | Please generate a tactic in lean4 to solve the state.
STATE:
case inr
B : CompHaus
S : Presieve B
F : CompHausᵒᵖ ⥤ Type (u + 1)
hFpfp : PreservesFiniteProducts F
hFecs : EqualizerCondition F
hSSingle : S ∈ RegularSieve B
y : Equalizer.FirstObj F S
h : Equalizer.Presieve.firstMap F S y = Equalizer.Presieve.secondMap F S y
⊢ ∃! x, Equalizer.forkMap F S x = y
TACTIC:
|
https://github.com/adamtopaz/CopenhagenMasterclass2023.git | a293ca1554f7e80d891fd4d86fb092c54d8a0a01 | CompHaus/ExplicitSheaves.lean | CompHaus.isSheafFor_of_Dagur | [277, 1] | [352, 22] | obtain ⟨X, π, ⟨hS, πsurj⟩⟩ := hSSingle | case inr
B : CompHaus
S : Presieve B
F : CompHausᵒᵖ ⥤ Type (u + 1)
hFpfp : PreservesFiniteProducts F
hFecs : EqualizerCondition F
hSSingle : ∃ X f, (S = ofArrows (fun x => X) fun x => f) ∧ Epi f
y : Equalizer.FirstObj F S
h : Equalizer.Presieve.firstMap F S y = Equalizer.Presieve.secondMap F S y
⊢ ∃! x, Equalizer.forkMap F S x = y | case inr.intro.intro.intro
B : CompHaus
S : Presieve B
F : CompHausᵒᵖ ⥤ Type (u + 1)
hFpfp : PreservesFiniteProducts F
hFecs : EqualizerCondition F
y : Equalizer.FirstObj F S
h : Equalizer.Presieve.firstMap F S y = Equalizer.Presieve.secondMap F S y
X : CompHaus
π : X ⟶ B
hS : S = ofArrows (fun x => X) fun x => π
πsurj : Epi π
⊢ ∃! x, Equalizer.forkMap F S x = y | Please generate a tactic in lean4 to solve the state.
STATE:
case inr
B : CompHaus
S : Presieve B
F : CompHausᵒᵖ ⥤ Type (u + 1)
hFpfp : PreservesFiniteProducts F
hFecs : EqualizerCondition F
hSSingle : ∃ X f, (S = ofArrows (fun x => X) fun x => f) ∧ Epi f
y : Equalizer.FirstObj F S
h : Equalizer.Presieve.firstMap F S y = Equalizer.Presieve.secondMap F S y
⊢ ∃! x, Equalizer.forkMap F S x = y
TACTIC:
|
https://github.com/adamtopaz/CopenhagenMasterclass2023.git | a293ca1554f7e80d891fd4d86fb092c54d8a0a01 | CompHaus/ExplicitSheaves.lean | CompHaus.isSheafFor_of_Dagur | [277, 1] | [352, 22] | rw [Presieve.ofArrows_pUnit] at hS | case inr.intro.intro.intro
B : CompHaus
S : Presieve B
F : CompHausᵒᵖ ⥤ Type (u + 1)
hFpfp : PreservesFiniteProducts F
hFecs : EqualizerCondition F
y : Equalizer.FirstObj F S
h : Equalizer.Presieve.firstMap F S y = Equalizer.Presieve.secondMap F S y
X : CompHaus
π : X ⟶ B
hS : S = ofArrows (fun x => X) fun x => π
πsurj : Epi π
⊢ ∃! x, Equalizer.forkMap F S x = y | case inr.intro.intro.intro
B : CompHaus
S : Presieve B
F : CompHausᵒᵖ ⥤ Type (u + 1)
hFpfp : PreservesFiniteProducts F
hFecs : EqualizerCondition F
y : Equalizer.FirstObj F S
h : Equalizer.Presieve.firstMap F S y = Equalizer.Presieve.secondMap F S y
X : CompHaus
π : X ⟶ B
hS : S = Presieve.singleton π
πsurj : Epi π
⊢ ∃! x, Equalizer.forkMap F S x = y | Please generate a tactic in lean4 to solve the state.
STATE:
case inr.intro.intro.intro
B : CompHaus
S : Presieve B
F : CompHausᵒᵖ ⥤ Type (u + 1)
hFpfp : PreservesFiniteProducts F
hFecs : EqualizerCondition F
y : Equalizer.FirstObj F S
h : Equalizer.Presieve.firstMap F S y = Equalizer.Presieve.secondMap F S y
X : CompHaus
π : X ⟶ B
hS : S = ofArrows (fun x => X) fun x => π
πsurj : Epi π
⊢ ∃! x, Equalizer.forkMap F S x = y
TACTIC:
|
https://github.com/adamtopaz/CopenhagenMasterclass2023.git | a293ca1554f7e80d891fd4d86fb092c54d8a0a01 | CompHaus/ExplicitSheaves.lean | CompHaus.isSheafFor_of_Dagur | [277, 1] | [352, 22] | subst hS | case inr.intro.intro.intro
B : CompHaus
S : Presieve B
F : CompHausᵒᵖ ⥤ Type (u + 1)
hFpfp : PreservesFiniteProducts F
hFecs : EqualizerCondition F
y : Equalizer.FirstObj F S
h : Equalizer.Presieve.firstMap F S y = Equalizer.Presieve.secondMap F S y
X : CompHaus
π : X ⟶ B
hS : S = Presieve.singleton π
πsurj : Epi π
⊢ ∃! x, Equalizer.forkMap F S x = y | case inr.intro.intro.intro
B : CompHaus
F : CompHausᵒᵖ ⥤ Type (u + 1)
hFpfp : PreservesFiniteProducts F
hFecs : EqualizerCondition F
X : CompHaus
π : X ⟶ B
πsurj : Epi π
y : Equalizer.FirstObj F (Presieve.singleton π)
h : Equalizer.Presieve.firstMap F (Presieve.singleton π) y = Equalizer.Presieve.secondMap F (Presieve.singleton π) y
⊢ ∃! x, Equalizer.forkMap F (Presieve.singleton π) x = y | Please generate a tactic in lean4 to solve the state.
STATE:
case inr.intro.intro.intro
B : CompHaus
S : Presieve B
F : CompHausᵒᵖ ⥤ Type (u + 1)
hFpfp : PreservesFiniteProducts F
hFecs : EqualizerCondition F
y : Equalizer.FirstObj F S
h : Equalizer.Presieve.firstMap F S y = Equalizer.Presieve.secondMap F S y
X : CompHaus
π : X ⟶ B
hS : S = Presieve.singleton π
πsurj : Epi π
⊢ ∃! x, Equalizer.forkMap F S x = y
TACTIC:
|
https://github.com/adamtopaz/CopenhagenMasterclass2023.git | a293ca1554f7e80d891fd4d86fb092c54d8a0a01 | CompHaus/ExplicitSheaves.lean | CompHaus.isSheafFor_of_Dagur | [277, 1] | [352, 22] | rw [CompHaus.epi_iff_surjective] at πsurj | case inr.intro.intro.intro
B : CompHaus
F : CompHausᵒᵖ ⥤ Type (u + 1)
hFpfp : PreservesFiniteProducts F
hFecs : EqualizerCondition F
X : CompHaus
π : X ⟶ B
πsurj : Epi π
y : Equalizer.FirstObj F (Presieve.singleton π)
h : Equalizer.Presieve.firstMap F (Presieve.singleton π) y = Equalizer.Presieve.secondMap F (Presieve.singleton π) y
⊢ ∃! x, Equalizer.forkMap F (Presieve.singleton π) x = y | case inr.intro.intro.intro
B : CompHaus
F : CompHausᵒᵖ ⥤ Type (u + 1)
hFpfp : PreservesFiniteProducts F
hFecs : EqualizerCondition F
X : CompHaus
π : X ⟶ B
πsurj : Function.Surjective ↑π
y : Equalizer.FirstObj F (Presieve.singleton π)
h : Equalizer.Presieve.firstMap F (Presieve.singleton π) y = Equalizer.Presieve.secondMap F (Presieve.singleton π) y
⊢ ∃! x, Equalizer.forkMap F (Presieve.singleton π) x = y | Please generate a tactic in lean4 to solve the state.
STATE:
case inr.intro.intro.intro
B : CompHaus
F : CompHausᵒᵖ ⥤ Type (u + 1)
hFpfp : PreservesFiniteProducts F
hFecs : EqualizerCondition F
X : CompHaus
π : X ⟶ B
πsurj : Epi π
y : Equalizer.FirstObj F (Presieve.singleton π)
h : Equalizer.Presieve.firstMap F (Presieve.singleton π) y = Equalizer.Presieve.secondMap F (Presieve.singleton π) y
⊢ ∃! x, Equalizer.forkMap F (Presieve.singleton π) x = y
TACTIC:
|
https://github.com/adamtopaz/CopenhagenMasterclass2023.git | a293ca1554f7e80d891fd4d86fb092c54d8a0a01 | CompHaus/ExplicitSheaves.lean | CompHaus.isSheafFor_of_Dagur | [277, 1] | [352, 22] | specialize hFecs X B π πsurj | case inr.intro.intro.intro
B : CompHaus
F : CompHausᵒᵖ ⥤ Type (u + 1)
hFpfp : PreservesFiniteProducts F
hFecs : EqualizerCondition F
X : CompHaus
π : X ⟶ B
πsurj : Function.Surjective ↑π
y : Equalizer.FirstObj F (Presieve.singleton π)
h : Equalizer.Presieve.firstMap F (Presieve.singleton π) y = Equalizer.Presieve.secondMap F (Presieve.singleton π) y
⊢ ∃! x, Equalizer.forkMap F (Presieve.singleton π) x = y | case inr.intro.intro.intro
B : CompHaus
F : CompHausᵒᵖ ⥤ Type (u + 1)
hFpfp : PreservesFiniteProducts F
X : CompHaus
π : X ⟶ B
πsurj : Function.Surjective ↑π
y : Equalizer.FirstObj F (Presieve.singleton π)
h : Equalizer.Presieve.firstMap F (Presieve.singleton π) y = Equalizer.Presieve.secondMap F (Presieve.singleton π) y
hFecs :
Function.Bijective
(MapToEqualizer F π (pullback.fst π π) (pullback.snd π π) (_ : pullback.fst π π ≫ π = pullback.snd π π ≫ π))
⊢ ∃! x, Equalizer.forkMap F (Presieve.singleton π) x = y | Please generate a tactic in lean4 to solve the state.
STATE:
case inr.intro.intro.intro
B : CompHaus
F : CompHausᵒᵖ ⥤ Type (u + 1)
hFpfp : PreservesFiniteProducts F
hFecs : EqualizerCondition F
X : CompHaus
π : X ⟶ B
πsurj : Function.Surjective ↑π
y : Equalizer.FirstObj F (Presieve.singleton π)
h : Equalizer.Presieve.firstMap F (Presieve.singleton π) y = Equalizer.Presieve.secondMap F (Presieve.singleton π) y
⊢ ∃! x, Equalizer.forkMap F (Presieve.singleton π) x = y
TACTIC:
|
https://github.com/adamtopaz/CopenhagenMasterclass2023.git | a293ca1554f7e80d891fd4d86fb092c54d8a0a01 | CompHaus/ExplicitSheaves.lean | CompHaus.isSheafFor_of_Dagur | [277, 1] | [352, 22] | have fork_comp : Equalizer.forkMap F (Presieve.singleton π) ≫ (EqualizerFirstObjIso F π).hom =
F.map π.op | case inr.intro.intro.intro
B : CompHaus
F : CompHausᵒᵖ ⥤ Type (u + 1)
hFpfp : PreservesFiniteProducts F
X : CompHaus
π : X ⟶ B
πsurj : Function.Surjective ↑π
y : Equalizer.FirstObj F (Presieve.singleton π)
h : Equalizer.Presieve.firstMap F (Presieve.singleton π) y = Equalizer.Presieve.secondMap F (Presieve.singleton π) y
hFecs :
Function.Bijective
(MapToEqualizer F π (pullback.fst π π) (pullback.snd π π) (_ : pullback.fst π π ≫ π = pullback.snd π π ≫ π))
⊢ ∃! x, Equalizer.forkMap F (Presieve.singleton π) x = y | case fork_comp
B : CompHaus
F : CompHausᵒᵖ ⥤ Type (u + 1)
hFpfp : PreservesFiniteProducts F
X : CompHaus
π : X ⟶ B
πsurj : Function.Surjective ↑π
y : Equalizer.FirstObj F (Presieve.singleton π)
h : Equalizer.Presieve.firstMap F (Presieve.singleton π) y = Equalizer.Presieve.secondMap F (Presieve.singleton π) y
hFecs :
Function.Bijective
(MapToEqualizer F π (pullback.fst π π) (pullback.snd π π) (_ : pullback.fst π π ≫ π = pullback.snd π π ≫ π))
⊢ Equalizer.forkMap F (Presieve.singleton π) ≫ (EqualizerFirstObjIso F π).hom = F.map π.op
case inr.intro.intro.intro
B : CompHaus
F : CompHausᵒᵖ ⥤ Type (u + 1)
hFpfp : PreservesFiniteProducts F
X : CompHaus
π : X ⟶ B
πsurj : Function.Surjective ↑π
y : Equalizer.FirstObj F (Presieve.singleton π)
h : Equalizer.Presieve.firstMap F (Presieve.singleton π) y = Equalizer.Presieve.secondMap F (Presieve.singleton π) y
hFecs :
Function.Bijective
(MapToEqualizer F π (pullback.fst π π) (pullback.snd π π) (_ : pullback.fst π π ≫ π = pullback.snd π π ≫ π))
fork_comp : Equalizer.forkMap F (Presieve.singleton π) ≫ (EqualizerFirstObjIso F π).hom = F.map π.op
⊢ ∃! x, Equalizer.forkMap F (Presieve.singleton π) x = y | Please generate a tactic in lean4 to solve the state.
STATE:
case inr.intro.intro.intro
B : CompHaus
F : CompHausᵒᵖ ⥤ Type (u + 1)
hFpfp : PreservesFiniteProducts F
X : CompHaus
π : X ⟶ B
πsurj : Function.Surjective ↑π
y : Equalizer.FirstObj F (Presieve.singleton π)
h : Equalizer.Presieve.firstMap F (Presieve.singleton π) y = Equalizer.Presieve.secondMap F (Presieve.singleton π) y
hFecs :
Function.Bijective
(MapToEqualizer F π (pullback.fst π π) (pullback.snd π π) (_ : pullback.fst π π ≫ π = pullback.snd π π ≫ π))
⊢ ∃! x, Equalizer.forkMap F (Presieve.singleton π) x = y
TACTIC:
|
https://github.com/adamtopaz/CopenhagenMasterclass2023.git | a293ca1554f7e80d891fd4d86fb092c54d8a0a01 | CompHaus/ExplicitSheaves.lean | CompHaus.isSheafFor_of_Dagur | [277, 1] | [352, 22] | have fmap_comp : (EqualizerFirstObjIso F π).hom ≫ F.map (pullback.fst π π).op =
Equalizer.Presieve.firstMap F (Presieve.singleton π) ≫ (EqualizerSecondObjIso F π).hom | case inr.intro.intro.intro
B : CompHaus
F : CompHausᵒᵖ ⥤ Type (u + 1)
hFpfp : PreservesFiniteProducts F
X : CompHaus
π : X ⟶ B
πsurj : Function.Surjective ↑π
y : Equalizer.FirstObj F (Presieve.singleton π)
h : Equalizer.Presieve.firstMap F (Presieve.singleton π) y = Equalizer.Presieve.secondMap F (Presieve.singleton π) y
hFecs :
Function.Bijective
(MapToEqualizer F π (pullback.fst π π) (pullback.snd π π) (_ : pullback.fst π π ≫ π = pullback.snd π π ≫ π))
fork_comp : Equalizer.forkMap F (Presieve.singleton π) ≫ (EqualizerFirstObjIso F π).hom = F.map π.op
⊢ ∃! x, Equalizer.forkMap F (Presieve.singleton π) x = y | case fmap_comp
B : CompHaus
F : CompHausᵒᵖ ⥤ Type (u + 1)
hFpfp : PreservesFiniteProducts F
X : CompHaus
π : X ⟶ B
πsurj : Function.Surjective ↑π
y : Equalizer.FirstObj F (Presieve.singleton π)
h : Equalizer.Presieve.firstMap F (Presieve.singleton π) y = Equalizer.Presieve.secondMap F (Presieve.singleton π) y
hFecs :
Function.Bijective
(MapToEqualizer F π (pullback.fst π π) (pullback.snd π π) (_ : pullback.fst π π ≫ π = pullback.snd π π ≫ π))
fork_comp : Equalizer.forkMap F (Presieve.singleton π) ≫ (EqualizerFirstObjIso F π).hom = F.map π.op
⊢ (EqualizerFirstObjIso F π).hom ≫ F.map (pullback.fst π π).op =
Equalizer.Presieve.firstMap F (Presieve.singleton π) ≫ (EqualizerSecondObjIso F π).hom
case inr.intro.intro.intro
B : CompHaus
F : CompHausᵒᵖ ⥤ Type (u + 1)
hFpfp : PreservesFiniteProducts F
X : CompHaus
π : X ⟶ B
πsurj : Function.Surjective ↑π
y : Equalizer.FirstObj F (Presieve.singleton π)
h : Equalizer.Presieve.firstMap F (Presieve.singleton π) y = Equalizer.Presieve.secondMap F (Presieve.singleton π) y
hFecs :
Function.Bijective
(MapToEqualizer F π (pullback.fst π π) (pullback.snd π π) (_ : pullback.fst π π ≫ π = pullback.snd π π ≫ π))
fork_comp : Equalizer.forkMap F (Presieve.singleton π) ≫ (EqualizerFirstObjIso F π).hom = F.map π.op
fmap_comp :
(EqualizerFirstObjIso F π).hom ≫ F.map (pullback.fst π π).op =
Equalizer.Presieve.firstMap F (Presieve.singleton π) ≫ (EqualizerSecondObjIso F π).hom
⊢ ∃! x, Equalizer.forkMap F (Presieve.singleton π) x = y | Please generate a tactic in lean4 to solve the state.
STATE:
case inr.intro.intro.intro
B : CompHaus
F : CompHausᵒᵖ ⥤ Type (u + 1)
hFpfp : PreservesFiniteProducts F
X : CompHaus
π : X ⟶ B
πsurj : Function.Surjective ↑π
y : Equalizer.FirstObj F (Presieve.singleton π)
h : Equalizer.Presieve.firstMap F (Presieve.singleton π) y = Equalizer.Presieve.secondMap F (Presieve.singleton π) y
hFecs :
Function.Bijective
(MapToEqualizer F π (pullback.fst π π) (pullback.snd π π) (_ : pullback.fst π π ≫ π = pullback.snd π π ≫ π))
fork_comp : Equalizer.forkMap F (Presieve.singleton π) ≫ (EqualizerFirstObjIso F π).hom = F.map π.op
⊢ ∃! x, Equalizer.forkMap F (Presieve.singleton π) x = y
TACTIC:
|
https://github.com/adamtopaz/CopenhagenMasterclass2023.git | a293ca1554f7e80d891fd4d86fb092c54d8a0a01 | CompHaus/ExplicitSheaves.lean | CompHaus.isSheafFor_of_Dagur | [277, 1] | [352, 22] | have smap_comp : (EqualizerFirstObjIso F π).hom ≫ F.map (pullback.snd π π).op =
Equalizer.Presieve.secondMap F (Presieve.singleton π) ≫ (EqualizerSecondObjIso F π).hom | case inr.intro.intro.intro
B : CompHaus
F : CompHausᵒᵖ ⥤ Type (u + 1)
hFpfp : PreservesFiniteProducts F
X : CompHaus
π : X ⟶ B
πsurj : Function.Surjective ↑π
y : Equalizer.FirstObj F (Presieve.singleton π)
h : Equalizer.Presieve.firstMap F (Presieve.singleton π) y = Equalizer.Presieve.secondMap F (Presieve.singleton π) y
hFecs :
Function.Bijective
(MapToEqualizer F π (pullback.fst π π) (pullback.snd π π) (_ : pullback.fst π π ≫ π = pullback.snd π π ≫ π))
fork_comp : Equalizer.forkMap F (Presieve.singleton π) ≫ (EqualizerFirstObjIso F π).hom = F.map π.op
fmap_comp :
(EqualizerFirstObjIso F π).hom ≫ F.map (pullback.fst π π).op =
Equalizer.Presieve.firstMap F (Presieve.singleton π) ≫ (EqualizerSecondObjIso F π).hom
⊢ ∃! x, Equalizer.forkMap F (Presieve.singleton π) x = y | case smap_comp
B : CompHaus
F : CompHausᵒᵖ ⥤ Type (u + 1)
hFpfp : PreservesFiniteProducts F
X : CompHaus
π : X ⟶ B
πsurj : Function.Surjective ↑π
y : Equalizer.FirstObj F (Presieve.singleton π)
h : Equalizer.Presieve.firstMap F (Presieve.singleton π) y = Equalizer.Presieve.secondMap F (Presieve.singleton π) y
hFecs :
Function.Bijective
(MapToEqualizer F π (pullback.fst π π) (pullback.snd π π) (_ : pullback.fst π π ≫ π = pullback.snd π π ≫ π))
fork_comp : Equalizer.forkMap F (Presieve.singleton π) ≫ (EqualizerFirstObjIso F π).hom = F.map π.op
fmap_comp :
(EqualizerFirstObjIso F π).hom ≫ F.map (pullback.fst π π).op =
Equalizer.Presieve.firstMap F (Presieve.singleton π) ≫ (EqualizerSecondObjIso F π).hom
⊢ (EqualizerFirstObjIso F π).hom ≫ F.map (pullback.snd π π).op =
Equalizer.Presieve.secondMap F (Presieve.singleton π) ≫ (EqualizerSecondObjIso F π).hom
case inr.intro.intro.intro
B : CompHaus
F : CompHausᵒᵖ ⥤ Type (u + 1)
hFpfp : PreservesFiniteProducts F
X : CompHaus
π : X ⟶ B
πsurj : Function.Surjective ↑π
y : Equalizer.FirstObj F (Presieve.singleton π)
h : Equalizer.Presieve.firstMap F (Presieve.singleton π) y = Equalizer.Presieve.secondMap F (Presieve.singleton π) y
hFecs :
Function.Bijective
(MapToEqualizer F π (pullback.fst π π) (pullback.snd π π) (_ : pullback.fst π π ≫ π = pullback.snd π π ≫ π))
fork_comp : Equalizer.forkMap F (Presieve.singleton π) ≫ (EqualizerFirstObjIso F π).hom = F.map π.op
fmap_comp :
(EqualizerFirstObjIso F π).hom ≫ F.map (pullback.fst π π).op =
Equalizer.Presieve.firstMap F (Presieve.singleton π) ≫ (EqualizerSecondObjIso F π).hom
smap_comp :
(EqualizerFirstObjIso F π).hom ≫ F.map (pullback.snd π π).op =
Equalizer.Presieve.secondMap F (Presieve.singleton π) ≫ (EqualizerSecondObjIso F π).hom
⊢ ∃! x, Equalizer.forkMap F (Presieve.singleton π) x = y | Please generate a tactic in lean4 to solve the state.
STATE:
case inr.intro.intro.intro
B : CompHaus
F : CompHausᵒᵖ ⥤ Type (u + 1)
hFpfp : PreservesFiniteProducts F
X : CompHaus
π : X ⟶ B
πsurj : Function.Surjective ↑π
y : Equalizer.FirstObj F (Presieve.singleton π)
h : Equalizer.Presieve.firstMap F (Presieve.singleton π) y = Equalizer.Presieve.secondMap F (Presieve.singleton π) y
hFecs :
Function.Bijective
(MapToEqualizer F π (pullback.fst π π) (pullback.snd π π) (_ : pullback.fst π π ≫ π = pullback.snd π π ≫ π))
fork_comp : Equalizer.forkMap F (Presieve.singleton π) ≫ (EqualizerFirstObjIso F π).hom = F.map π.op
fmap_comp :
(EqualizerFirstObjIso F π).hom ≫ F.map (pullback.fst π π).op =
Equalizer.Presieve.firstMap F (Presieve.singleton π) ≫ (EqualizerSecondObjIso F π).hom
⊢ ∃! x, Equalizer.forkMap F (Presieve.singleton π) x = y
TACTIC:
|
https://github.com/adamtopaz/CopenhagenMasterclass2023.git | a293ca1554f7e80d891fd4d86fb092c54d8a0a01 | CompHaus/ExplicitSheaves.lean | CompHaus.isSheafFor_of_Dagur | [277, 1] | [352, 22] | have iy_mem : F.map (pullback.fst π π).op ((EqualizerFirstObjIso F π).hom y) =
F.map (pullback.snd π π).op ((EqualizerFirstObjIso F π).hom y) | case inr.intro.intro.intro
B : CompHaus
F : CompHausᵒᵖ ⥤ Type (u + 1)
hFpfp : PreservesFiniteProducts F
X : CompHaus
π : X ⟶ B
πsurj : Function.Surjective ↑π
y : Equalizer.FirstObj F (Presieve.singleton π)
h : Equalizer.Presieve.firstMap F (Presieve.singleton π) y = Equalizer.Presieve.secondMap F (Presieve.singleton π) y
hFecs :
Function.Bijective
(MapToEqualizer F π (pullback.fst π π) (pullback.snd π π) (_ : pullback.fst π π ≫ π = pullback.snd π π ≫ π))
fork_comp : Equalizer.forkMap F (Presieve.singleton π) ≫ (EqualizerFirstObjIso F π).hom = F.map π.op
fmap_comp :
(EqualizerFirstObjIso F π).hom ≫ F.map (pullback.fst π π).op =
Equalizer.Presieve.firstMap F (Presieve.singleton π) ≫ (EqualizerSecondObjIso F π).hom
smap_comp :
(EqualizerFirstObjIso F π).hom ≫ F.map (pullback.snd π π).op =
Equalizer.Presieve.secondMap F (Presieve.singleton π) ≫ (EqualizerSecondObjIso F π).hom
⊢ ∃! x, Equalizer.forkMap F (Presieve.singleton π) x = y | case iy_mem
B : CompHaus
F : CompHausᵒᵖ ⥤ Type (u + 1)
hFpfp : PreservesFiniteProducts F
X : CompHaus
π : X ⟶ B
πsurj : Function.Surjective ↑π
y : Equalizer.FirstObj F (Presieve.singleton π)
h : Equalizer.Presieve.firstMap F (Presieve.singleton π) y = Equalizer.Presieve.secondMap F (Presieve.singleton π) y
hFecs :
Function.Bijective
(MapToEqualizer F π (pullback.fst π π) (pullback.snd π π) (_ : pullback.fst π π ≫ π = pullback.snd π π ≫ π))
fork_comp : Equalizer.forkMap F (Presieve.singleton π) ≫ (EqualizerFirstObjIso F π).hom = F.map π.op
fmap_comp :
(EqualizerFirstObjIso F π).hom ≫ F.map (pullback.fst π π).op =
Equalizer.Presieve.firstMap F (Presieve.singleton π) ≫ (EqualizerSecondObjIso F π).hom
smap_comp :
(EqualizerFirstObjIso F π).hom ≫ F.map (pullback.snd π π).op =
Equalizer.Presieve.secondMap F (Presieve.singleton π) ≫ (EqualizerSecondObjIso F π).hom
⊢ F.map (pullback.fst π π).op ((EqualizerFirstObjIso F π).hom y) =
F.map (pullback.snd π π).op ((EqualizerFirstObjIso F π).hom y)
case inr.intro.intro.intro
B : CompHaus
F : CompHausᵒᵖ ⥤ Type (u + 1)
hFpfp : PreservesFiniteProducts F
X : CompHaus
π : X ⟶ B
πsurj : Function.Surjective ↑π
y : Equalizer.FirstObj F (Presieve.singleton π)
h : Equalizer.Presieve.firstMap F (Presieve.singleton π) y = Equalizer.Presieve.secondMap F (Presieve.singleton π) y
hFecs :
Function.Bijective
(MapToEqualizer F π (pullback.fst π π) (pullback.snd π π) (_ : pullback.fst π π ≫ π = pullback.snd π π ≫ π))
fork_comp : Equalizer.forkMap F (Presieve.singleton π) ≫ (EqualizerFirstObjIso F π).hom = F.map π.op
fmap_comp :
(EqualizerFirstObjIso F π).hom ≫ F.map (pullback.fst π π).op =
Equalizer.Presieve.firstMap F (Presieve.singleton π) ≫ (EqualizerSecondObjIso F π).hom
smap_comp :
(EqualizerFirstObjIso F π).hom ≫ F.map (pullback.snd π π).op =
Equalizer.Presieve.secondMap F (Presieve.singleton π) ≫ (EqualizerSecondObjIso F π).hom
iy_mem :
F.map (pullback.fst π π).op ((EqualizerFirstObjIso F π).hom y) =
F.map (pullback.snd π π).op ((EqualizerFirstObjIso F π).hom y)
⊢ ∃! x, Equalizer.forkMap F (Presieve.singleton π) x = y | Please generate a tactic in lean4 to solve the state.
STATE:
case inr.intro.intro.intro
B : CompHaus
F : CompHausᵒᵖ ⥤ Type (u + 1)
hFpfp : PreservesFiniteProducts F
X : CompHaus
π : X ⟶ B
πsurj : Function.Surjective ↑π
y : Equalizer.FirstObj F (Presieve.singleton π)
h : Equalizer.Presieve.firstMap F (Presieve.singleton π) y = Equalizer.Presieve.secondMap F (Presieve.singleton π) y
hFecs :
Function.Bijective
(MapToEqualizer F π (pullback.fst π π) (pullback.snd π π) (_ : pullback.fst π π ≫ π = pullback.snd π π ≫ π))
fork_comp : Equalizer.forkMap F (Presieve.singleton π) ≫ (EqualizerFirstObjIso F π).hom = F.map π.op
fmap_comp :
(EqualizerFirstObjIso F π).hom ≫ F.map (pullback.fst π π).op =
Equalizer.Presieve.firstMap F (Presieve.singleton π) ≫ (EqualizerSecondObjIso F π).hom
smap_comp :
(EqualizerFirstObjIso F π).hom ≫ F.map (pullback.snd π π).op =
Equalizer.Presieve.secondMap F (Presieve.singleton π) ≫ (EqualizerSecondObjIso F π).hom
⊢ ∃! x, Equalizer.forkMap F (Presieve.singleton π) x = y
TACTIC:
|
https://github.com/adamtopaz/CopenhagenMasterclass2023.git | a293ca1554f7e80d891fd4d86fb092c54d8a0a01 | CompHaus/ExplicitSheaves.lean | CompHaus.isSheafFor_of_Dagur | [277, 1] | [352, 22] | have uniq_F : ∃! x, F.map π.op x = (EqualizerFirstObjIso F π).hom y | case inr.intro.intro.intro
B : CompHaus
F : CompHausᵒᵖ ⥤ Type (u + 1)
hFpfp : PreservesFiniteProducts F
X : CompHaus
π : X ⟶ B
πsurj : Function.Surjective ↑π
y : Equalizer.FirstObj F (Presieve.singleton π)
h : Equalizer.Presieve.firstMap F (Presieve.singleton π) y = Equalizer.Presieve.secondMap F (Presieve.singleton π) y
hFecs :
Function.Bijective
(MapToEqualizer F π (pullback.fst π π) (pullback.snd π π) (_ : pullback.fst π π ≫ π = pullback.snd π π ≫ π))
fork_comp : Equalizer.forkMap F (Presieve.singleton π) ≫ (EqualizerFirstObjIso F π).hom = F.map π.op
fmap_comp :
(EqualizerFirstObjIso F π).hom ≫ F.map (pullback.fst π π).op =
Equalizer.Presieve.firstMap F (Presieve.singleton π) ≫ (EqualizerSecondObjIso F π).hom
smap_comp :
(EqualizerFirstObjIso F π).hom ≫ F.map (pullback.snd π π).op =
Equalizer.Presieve.secondMap F (Presieve.singleton π) ≫ (EqualizerSecondObjIso F π).hom
iy_mem :
F.map (pullback.fst π π).op ((EqualizerFirstObjIso F π).hom y) =
F.map (pullback.snd π π).op ((EqualizerFirstObjIso F π).hom y)
⊢ ∃! x, Equalizer.forkMap F (Presieve.singleton π) x = y | case uniq_F
B : CompHaus
F : CompHausᵒᵖ ⥤ Type (u + 1)
hFpfp : PreservesFiniteProducts F
X : CompHaus
π : X ⟶ B
πsurj : Function.Surjective ↑π
y : Equalizer.FirstObj F (Presieve.singleton π)
h : Equalizer.Presieve.firstMap F (Presieve.singleton π) y = Equalizer.Presieve.secondMap F (Presieve.singleton π) y
hFecs :
Function.Bijective
(MapToEqualizer F π (pullback.fst π π) (pullback.snd π π) (_ : pullback.fst π π ≫ π = pullback.snd π π ≫ π))
fork_comp : Equalizer.forkMap F (Presieve.singleton π) ≫ (EqualizerFirstObjIso F π).hom = F.map π.op
fmap_comp :
(EqualizerFirstObjIso F π).hom ≫ F.map (pullback.fst π π).op =
Equalizer.Presieve.firstMap F (Presieve.singleton π) ≫ (EqualizerSecondObjIso F π).hom
smap_comp :
(EqualizerFirstObjIso F π).hom ≫ F.map (pullback.snd π π).op =
Equalizer.Presieve.secondMap F (Presieve.singleton π) ≫ (EqualizerSecondObjIso F π).hom
iy_mem :
F.map (pullback.fst π π).op ((EqualizerFirstObjIso F π).hom y) =
F.map (pullback.snd π π).op ((EqualizerFirstObjIso F π).hom y)
⊢ ∃! x, F.map π.op x = (EqualizerFirstObjIso F π).hom y
case inr.intro.intro.intro
B : CompHaus
F : CompHausᵒᵖ ⥤ Type (u + 1)
hFpfp : PreservesFiniteProducts F
X : CompHaus
π : X ⟶ B
πsurj : Function.Surjective ↑π
y : Equalizer.FirstObj F (Presieve.singleton π)
h : Equalizer.Presieve.firstMap F (Presieve.singleton π) y = Equalizer.Presieve.secondMap F (Presieve.singleton π) y
hFecs :
Function.Bijective
(MapToEqualizer F π (pullback.fst π π) (pullback.snd π π) (_ : pullback.fst π π ≫ π = pullback.snd π π ≫ π))
fork_comp : Equalizer.forkMap F (Presieve.singleton π) ≫ (EqualizerFirstObjIso F π).hom = F.map π.op
fmap_comp :
(EqualizerFirstObjIso F π).hom ≫ F.map (pullback.fst π π).op =
Equalizer.Presieve.firstMap F (Presieve.singleton π) ≫ (EqualizerSecondObjIso F π).hom
smap_comp :
(EqualizerFirstObjIso F π).hom ≫ F.map (pullback.snd π π).op =
Equalizer.Presieve.secondMap F (Presieve.singleton π) ≫ (EqualizerSecondObjIso F π).hom
iy_mem :
F.map (pullback.fst π π).op ((EqualizerFirstObjIso F π).hom y) =
F.map (pullback.snd π π).op ((EqualizerFirstObjIso F π).hom y)
uniq_F : ∃! x, F.map π.op x = (EqualizerFirstObjIso F π).hom y
⊢ ∃! x, Equalizer.forkMap F (Presieve.singleton π) x = y | Please generate a tactic in lean4 to solve the state.
STATE:
case inr.intro.intro.intro
B : CompHaus
F : CompHausᵒᵖ ⥤ Type (u + 1)
hFpfp : PreservesFiniteProducts F
X : CompHaus
π : X ⟶ B
πsurj : Function.Surjective ↑π
y : Equalizer.FirstObj F (Presieve.singleton π)
h : Equalizer.Presieve.firstMap F (Presieve.singleton π) y = Equalizer.Presieve.secondMap F (Presieve.singleton π) y
hFecs :
Function.Bijective
(MapToEqualizer F π (pullback.fst π π) (pullback.snd π π) (_ : pullback.fst π π ≫ π = pullback.snd π π ≫ π))
fork_comp : Equalizer.forkMap F (Presieve.singleton π) ≫ (EqualizerFirstObjIso F π).hom = F.map π.op
fmap_comp :
(EqualizerFirstObjIso F π).hom ≫ F.map (pullback.fst π π).op =
Equalizer.Presieve.firstMap F (Presieve.singleton π) ≫ (EqualizerSecondObjIso F π).hom
smap_comp :
(EqualizerFirstObjIso F π).hom ≫ F.map (pullback.snd π π).op =
Equalizer.Presieve.secondMap F (Presieve.singleton π) ≫ (EqualizerSecondObjIso F π).hom
iy_mem :
F.map (pullback.fst π π).op ((EqualizerFirstObjIso F π).hom y) =
F.map (pullback.snd π π).op ((EqualizerFirstObjIso F π).hom y)
⊢ ∃! x, Equalizer.forkMap F (Presieve.singleton π) x = y
TACTIC:
|
https://github.com/adamtopaz/CopenhagenMasterclass2023.git | a293ca1554f7e80d891fd4d86fb092c54d8a0a01 | CompHaus/ExplicitSheaves.lean | CompHaus.isSheafFor_of_Dagur | [277, 1] | [352, 22] | obtain ⟨x,hx⟩ := uniq_F | case inr.intro.intro.intro
B : CompHaus
F : CompHausᵒᵖ ⥤ Type (u + 1)
hFpfp : PreservesFiniteProducts F
X : CompHaus
π : X ⟶ B
πsurj : Function.Surjective ↑π
y : Equalizer.FirstObj F (Presieve.singleton π)
h : Equalizer.Presieve.firstMap F (Presieve.singleton π) y = Equalizer.Presieve.secondMap F (Presieve.singleton π) y
hFecs :
Function.Bijective
(MapToEqualizer F π (pullback.fst π π) (pullback.snd π π) (_ : pullback.fst π π ≫ π = pullback.snd π π ≫ π))
fork_comp : Equalizer.forkMap F (Presieve.singleton π) ≫ (EqualizerFirstObjIso F π).hom = F.map π.op
fmap_comp :
(EqualizerFirstObjIso F π).hom ≫ F.map (pullback.fst π π).op =
Equalizer.Presieve.firstMap F (Presieve.singleton π) ≫ (EqualizerSecondObjIso F π).hom
smap_comp :
(EqualizerFirstObjIso F π).hom ≫ F.map (pullback.snd π π).op =
Equalizer.Presieve.secondMap F (Presieve.singleton π) ≫ (EqualizerSecondObjIso F π).hom
iy_mem :
F.map (pullback.fst π π).op ((EqualizerFirstObjIso F π).hom y) =
F.map (pullback.snd π π).op ((EqualizerFirstObjIso F π).hom y)
uniq_F : ∃! x, F.map π.op x = (EqualizerFirstObjIso F π).hom y
⊢ ∃! x, Equalizer.forkMap F (Presieve.singleton π) x = y | case inr.intro.intro.intro.intro
B : CompHaus
F : CompHausᵒᵖ ⥤ Type (u + 1)
hFpfp : PreservesFiniteProducts F
X : CompHaus
π : X ⟶ B
πsurj : Function.Surjective ↑π
y : Equalizer.FirstObj F (Presieve.singleton π)
h : Equalizer.Presieve.firstMap F (Presieve.singleton π) y = Equalizer.Presieve.secondMap F (Presieve.singleton π) y
hFecs :
Function.Bijective
(MapToEqualizer F π (pullback.fst π π) (pullback.snd π π) (_ : pullback.fst π π ≫ π = pullback.snd π π ≫ π))
fork_comp : Equalizer.forkMap F (Presieve.singleton π) ≫ (EqualizerFirstObjIso F π).hom = F.map π.op
fmap_comp :
(EqualizerFirstObjIso F π).hom ≫ F.map (pullback.fst π π).op =
Equalizer.Presieve.firstMap F (Presieve.singleton π) ≫ (EqualizerSecondObjIso F π).hom
smap_comp :
(EqualizerFirstObjIso F π).hom ≫ F.map (pullback.snd π π).op =
Equalizer.Presieve.secondMap F (Presieve.singleton π) ≫ (EqualizerSecondObjIso F π).hom
iy_mem :
F.map (pullback.fst π π).op ((EqualizerFirstObjIso F π).hom y) =
F.map (pullback.snd π π).op ((EqualizerFirstObjIso F π).hom y)
x : F.obj B.op
hx :
(fun x => F.map π.op x = (EqualizerFirstObjIso F π).hom y) x ∧
∀ (y_1 : F.obj B.op), (fun x => F.map π.op x = (EqualizerFirstObjIso F π).hom y) y_1 → y_1 = x
⊢ ∃! x, Equalizer.forkMap F (Presieve.singleton π) x = y | Please generate a tactic in lean4 to solve the state.
STATE:
case inr.intro.intro.intro
B : CompHaus
F : CompHausᵒᵖ ⥤ Type (u + 1)
hFpfp : PreservesFiniteProducts F
X : CompHaus
π : X ⟶ B
πsurj : Function.Surjective ↑π
y : Equalizer.FirstObj F (Presieve.singleton π)
h : Equalizer.Presieve.firstMap F (Presieve.singleton π) y = Equalizer.Presieve.secondMap F (Presieve.singleton π) y
hFecs :
Function.Bijective
(MapToEqualizer F π (pullback.fst π π) (pullback.snd π π) (_ : pullback.fst π π ≫ π = pullback.snd π π ≫ π))
fork_comp : Equalizer.forkMap F (Presieve.singleton π) ≫ (EqualizerFirstObjIso F π).hom = F.map π.op
fmap_comp :
(EqualizerFirstObjIso F π).hom ≫ F.map (pullback.fst π π).op =
Equalizer.Presieve.firstMap F (Presieve.singleton π) ≫ (EqualizerSecondObjIso F π).hom
smap_comp :
(EqualizerFirstObjIso F π).hom ≫ F.map (pullback.snd π π).op =
Equalizer.Presieve.secondMap F (Presieve.singleton π) ≫ (EqualizerSecondObjIso F π).hom
iy_mem :
F.map (pullback.fst π π).op ((EqualizerFirstObjIso F π).hom y) =
F.map (pullback.snd π π).op ((EqualizerFirstObjIso F π).hom y)
uniq_F : ∃! x, F.map π.op x = (EqualizerFirstObjIso F π).hom y
⊢ ∃! x, Equalizer.forkMap F (Presieve.singleton π) x = y
TACTIC:
|
https://github.com/adamtopaz/CopenhagenMasterclass2023.git | a293ca1554f7e80d891fd4d86fb092c54d8a0a01 | CompHaus/ExplicitSheaves.lean | CompHaus.isSheafFor_of_Dagur | [277, 1] | [352, 22] | dsimp at hx | case inr.intro.intro.intro.intro
B : CompHaus
F : CompHausᵒᵖ ⥤ Type (u + 1)
hFpfp : PreservesFiniteProducts F
X : CompHaus
π : X ⟶ B
πsurj : Function.Surjective ↑π
y : Equalizer.FirstObj F (Presieve.singleton π)
h : Equalizer.Presieve.firstMap F (Presieve.singleton π) y = Equalizer.Presieve.secondMap F (Presieve.singleton π) y
hFecs :
Function.Bijective
(MapToEqualizer F π (pullback.fst π π) (pullback.snd π π) (_ : pullback.fst π π ≫ π = pullback.snd π π ≫ π))
fork_comp : Equalizer.forkMap F (Presieve.singleton π) ≫ (EqualizerFirstObjIso F π).hom = F.map π.op
fmap_comp :
(EqualizerFirstObjIso F π).hom ≫ F.map (pullback.fst π π).op =
Equalizer.Presieve.firstMap F (Presieve.singleton π) ≫ (EqualizerSecondObjIso F π).hom
smap_comp :
(EqualizerFirstObjIso F π).hom ≫ F.map (pullback.snd π π).op =
Equalizer.Presieve.secondMap F (Presieve.singleton π) ≫ (EqualizerSecondObjIso F π).hom
iy_mem :
F.map (pullback.fst π π).op ((EqualizerFirstObjIso F π).hom y) =
F.map (pullback.snd π π).op ((EqualizerFirstObjIso F π).hom y)
x : F.obj B.op
hx :
(fun x => F.map π.op x = (EqualizerFirstObjIso F π).hom y) x ∧
∀ (y_1 : F.obj B.op), (fun x => F.map π.op x = (EqualizerFirstObjIso F π).hom y) y_1 → y_1 = x
⊢ ∃! x, Equalizer.forkMap F (Presieve.singleton π) x = y | case inr.intro.intro.intro.intro
B : CompHaus
F : CompHausᵒᵖ ⥤ Type (u + 1)
hFpfp : PreservesFiniteProducts F
X : CompHaus
π : X ⟶ B
πsurj : Function.Surjective ↑π
y : Equalizer.FirstObj F (Presieve.singleton π)
h : Equalizer.Presieve.firstMap F (Presieve.singleton π) y = Equalizer.Presieve.secondMap F (Presieve.singleton π) y
hFecs :
Function.Bijective
(MapToEqualizer F π (pullback.fst π π) (pullback.snd π π) (_ : pullback.fst π π ≫ π = pullback.snd π π ≫ π))
fork_comp : Equalizer.forkMap F (Presieve.singleton π) ≫ (EqualizerFirstObjIso F π).hom = F.map π.op
fmap_comp :
(EqualizerFirstObjIso F π).hom ≫ F.map (pullback.fst π π).op =
Equalizer.Presieve.firstMap F (Presieve.singleton π) ≫ (EqualizerSecondObjIso F π).hom
smap_comp :
(EqualizerFirstObjIso F π).hom ≫ F.map (pullback.snd π π).op =
Equalizer.Presieve.secondMap F (Presieve.singleton π) ≫ (EqualizerSecondObjIso F π).hom
iy_mem :
F.map (pullback.fst π π).op ((EqualizerFirstObjIso F π).hom y) =
F.map (pullback.snd π π).op ((EqualizerFirstObjIso F π).hom y)
x : F.obj B.op
hx :
F.map π.op x = (EqualizerFirstObjIso F π).hom y ∧
∀ (y_1 : F.obj B.op), F.map π.op y_1 = (EqualizerFirstObjIso F π).hom y → y_1 = x
⊢ ∃! x, Equalizer.forkMap F (Presieve.singleton π) x = y | Please generate a tactic in lean4 to solve the state.
STATE:
case inr.intro.intro.intro.intro
B : CompHaus
F : CompHausᵒᵖ ⥤ Type (u + 1)
hFpfp : PreservesFiniteProducts F
X : CompHaus
π : X ⟶ B
πsurj : Function.Surjective ↑π
y : Equalizer.FirstObj F (Presieve.singleton π)
h : Equalizer.Presieve.firstMap F (Presieve.singleton π) y = Equalizer.Presieve.secondMap F (Presieve.singleton π) y
hFecs :
Function.Bijective
(MapToEqualizer F π (pullback.fst π π) (pullback.snd π π) (_ : pullback.fst π π ≫ π = pullback.snd π π ≫ π))
fork_comp : Equalizer.forkMap F (Presieve.singleton π) ≫ (EqualizerFirstObjIso F π).hom = F.map π.op
fmap_comp :
(EqualizerFirstObjIso F π).hom ≫ F.map (pullback.fst π π).op =
Equalizer.Presieve.firstMap F (Presieve.singleton π) ≫ (EqualizerSecondObjIso F π).hom
smap_comp :
(EqualizerFirstObjIso F π).hom ≫ F.map (pullback.snd π π).op =
Equalizer.Presieve.secondMap F (Presieve.singleton π) ≫ (EqualizerSecondObjIso F π).hom
iy_mem :
F.map (pullback.fst π π).op ((EqualizerFirstObjIso F π).hom y) =
F.map (pullback.snd π π).op ((EqualizerFirstObjIso F π).hom y)
x : F.obj B.op
hx :
(fun x => F.map π.op x = (EqualizerFirstObjIso F π).hom y) x ∧
∀ (y_1 : F.obj B.op), (fun x => F.map π.op x = (EqualizerFirstObjIso F π).hom y) y_1 → y_1 = x
⊢ ∃! x, Equalizer.forkMap F (Presieve.singleton π) x = y
TACTIC:
|
https://github.com/adamtopaz/CopenhagenMasterclass2023.git | a293ca1554f7e80d891fd4d86fb092c54d8a0a01 | CompHaus/ExplicitSheaves.lean | CompHaus.isSheafFor_of_Dagur | [277, 1] | [352, 22] | rw [← fork_comp] at hx | case inr.intro.intro.intro.intro
B : CompHaus
F : CompHausᵒᵖ ⥤ Type (u + 1)
hFpfp : PreservesFiniteProducts F
X : CompHaus
π : X ⟶ B
πsurj : Function.Surjective ↑π
y : Equalizer.FirstObj F (Presieve.singleton π)
h : Equalizer.Presieve.firstMap F (Presieve.singleton π) y = Equalizer.Presieve.secondMap F (Presieve.singleton π) y
hFecs :
Function.Bijective
(MapToEqualizer F π (pullback.fst π π) (pullback.snd π π) (_ : pullback.fst π π ≫ π = pullback.snd π π ≫ π))
fork_comp : Equalizer.forkMap F (Presieve.singleton π) ≫ (EqualizerFirstObjIso F π).hom = F.map π.op
fmap_comp :
(EqualizerFirstObjIso F π).hom ≫ F.map (pullback.fst π π).op =
Equalizer.Presieve.firstMap F (Presieve.singleton π) ≫ (EqualizerSecondObjIso F π).hom
smap_comp :
(EqualizerFirstObjIso F π).hom ≫ F.map (pullback.snd π π).op =
Equalizer.Presieve.secondMap F (Presieve.singleton π) ≫ (EqualizerSecondObjIso F π).hom
iy_mem :
F.map (pullback.fst π π).op ((EqualizerFirstObjIso F π).hom y) =
F.map (pullback.snd π π).op ((EqualizerFirstObjIso F π).hom y)
x : F.obj B.op
hx :
F.map π.op x = (EqualizerFirstObjIso F π).hom y ∧
∀ (y_1 : F.obj B.op), F.map π.op y_1 = (EqualizerFirstObjIso F π).hom y → y_1 = x
⊢ ∃! x, Equalizer.forkMap F (Presieve.singleton π) x = y | case inr.intro.intro.intro.intro
B : CompHaus
F : CompHausᵒᵖ ⥤ Type (u + 1)
hFpfp : PreservesFiniteProducts F
X : CompHaus
π : X ⟶ B
πsurj : Function.Surjective ↑π
y : Equalizer.FirstObj F (Presieve.singleton π)
h : Equalizer.Presieve.firstMap F (Presieve.singleton π) y = Equalizer.Presieve.secondMap F (Presieve.singleton π) y
hFecs :
Function.Bijective
(MapToEqualizer F π (pullback.fst π π) (pullback.snd π π) (_ : pullback.fst π π ≫ π = pullback.snd π π ≫ π))
fork_comp : Equalizer.forkMap F (Presieve.singleton π) ≫ (EqualizerFirstObjIso F π).hom = F.map π.op
fmap_comp :
(EqualizerFirstObjIso F π).hom ≫ F.map (pullback.fst π π).op =
Equalizer.Presieve.firstMap F (Presieve.singleton π) ≫ (EqualizerSecondObjIso F π).hom
smap_comp :
(EqualizerFirstObjIso F π).hom ≫ F.map (pullback.snd π π).op =
Equalizer.Presieve.secondMap F (Presieve.singleton π) ≫ (EqualizerSecondObjIso F π).hom
iy_mem :
F.map (pullback.fst π π).op ((EqualizerFirstObjIso F π).hom y) =
F.map (pullback.snd π π).op ((EqualizerFirstObjIso F π).hom y)
x : F.obj B.op
hx :
(Equalizer.forkMap F (Presieve.singleton π) ≫ (EqualizerFirstObjIso F π).hom) x = (EqualizerFirstObjIso F π).hom y ∧
∀ (y_1 : F.obj B.op),
(Equalizer.forkMap F (Presieve.singleton π) ≫ (EqualizerFirstObjIso F π).hom) y_1 =
(EqualizerFirstObjIso F π).hom y →
y_1 = x
⊢ ∃! x, Equalizer.forkMap F (Presieve.singleton π) x = y | Please generate a tactic in lean4 to solve the state.
STATE:
case inr.intro.intro.intro.intro
B : CompHaus
F : CompHausᵒᵖ ⥤ Type (u + 1)
hFpfp : PreservesFiniteProducts F
X : CompHaus
π : X ⟶ B
πsurj : Function.Surjective ↑π
y : Equalizer.FirstObj F (Presieve.singleton π)
h : Equalizer.Presieve.firstMap F (Presieve.singleton π) y = Equalizer.Presieve.secondMap F (Presieve.singleton π) y
hFecs :
Function.Bijective
(MapToEqualizer F π (pullback.fst π π) (pullback.snd π π) (_ : pullback.fst π π ≫ π = pullback.snd π π ≫ π))
fork_comp : Equalizer.forkMap F (Presieve.singleton π) ≫ (EqualizerFirstObjIso F π).hom = F.map π.op
fmap_comp :
(EqualizerFirstObjIso F π).hom ≫ F.map (pullback.fst π π).op =
Equalizer.Presieve.firstMap F (Presieve.singleton π) ≫ (EqualizerSecondObjIso F π).hom
smap_comp :
(EqualizerFirstObjIso F π).hom ≫ F.map (pullback.snd π π).op =
Equalizer.Presieve.secondMap F (Presieve.singleton π) ≫ (EqualizerSecondObjIso F π).hom
iy_mem :
F.map (pullback.fst π π).op ((EqualizerFirstObjIso F π).hom y) =
F.map (pullback.snd π π).op ((EqualizerFirstObjIso F π).hom y)
x : F.obj B.op
hx :
F.map π.op x = (EqualizerFirstObjIso F π).hom y ∧
∀ (y_1 : F.obj B.op), F.map π.op y_1 = (EqualizerFirstObjIso F π).hom y → y_1 = x
⊢ ∃! x, Equalizer.forkMap F (Presieve.singleton π) x = y
TACTIC:
|
https://github.com/adamtopaz/CopenhagenMasterclass2023.git | a293ca1554f7e80d891fd4d86fb092c54d8a0a01 | CompHaus/ExplicitSheaves.lean | CompHaus.isSheafFor_of_Dagur | [277, 1] | [352, 22] | use x | case inr.intro.intro.intro.intro
B : CompHaus
F : CompHausᵒᵖ ⥤ Type (u + 1)
hFpfp : PreservesFiniteProducts F
X : CompHaus
π : X ⟶ B
πsurj : Function.Surjective ↑π
y : Equalizer.FirstObj F (Presieve.singleton π)
h : Equalizer.Presieve.firstMap F (Presieve.singleton π) y = Equalizer.Presieve.secondMap F (Presieve.singleton π) y
hFecs :
Function.Bijective
(MapToEqualizer F π (pullback.fst π π) (pullback.snd π π) (_ : pullback.fst π π ≫ π = pullback.snd π π ≫ π))
fork_comp : Equalizer.forkMap F (Presieve.singleton π) ≫ (EqualizerFirstObjIso F π).hom = F.map π.op
fmap_comp :
(EqualizerFirstObjIso F π).hom ≫ F.map (pullback.fst π π).op =
Equalizer.Presieve.firstMap F (Presieve.singleton π) ≫ (EqualizerSecondObjIso F π).hom
smap_comp :
(EqualizerFirstObjIso F π).hom ≫ F.map (pullback.snd π π).op =
Equalizer.Presieve.secondMap F (Presieve.singleton π) ≫ (EqualizerSecondObjIso F π).hom
iy_mem :
F.map (pullback.fst π π).op ((EqualizerFirstObjIso F π).hom y) =
F.map (pullback.snd π π).op ((EqualizerFirstObjIso F π).hom y)
x : F.obj B.op
hx :
(Equalizer.forkMap F (Presieve.singleton π) ≫ (EqualizerFirstObjIso F π).hom) x = (EqualizerFirstObjIso F π).hom y ∧
∀ (y_1 : F.obj B.op),
(Equalizer.forkMap F (Presieve.singleton π) ≫ (EqualizerFirstObjIso F π).hom) y_1 =
(EqualizerFirstObjIso F π).hom y →
y_1 = x
⊢ ∃! x, Equalizer.forkMap F (Presieve.singleton π) x = y | case inr.intro.intro.intro.intro
B : CompHaus
F : CompHausᵒᵖ ⥤ Type (u + 1)
hFpfp : PreservesFiniteProducts F
X : CompHaus
π : X ⟶ B
πsurj : Function.Surjective ↑π
y : Equalizer.FirstObj F (Presieve.singleton π)
h : Equalizer.Presieve.firstMap F (Presieve.singleton π) y = Equalizer.Presieve.secondMap F (Presieve.singleton π) y
hFecs :
Function.Bijective
(MapToEqualizer F π (pullback.fst π π) (pullback.snd π π) (_ : pullback.fst π π ≫ π = pullback.snd π π ≫ π))
fork_comp : Equalizer.forkMap F (Presieve.singleton π) ≫ (EqualizerFirstObjIso F π).hom = F.map π.op
fmap_comp :
(EqualizerFirstObjIso F π).hom ≫ F.map (pullback.fst π π).op =
Equalizer.Presieve.firstMap F (Presieve.singleton π) ≫ (EqualizerSecondObjIso F π).hom
smap_comp :
(EqualizerFirstObjIso F π).hom ≫ F.map (pullback.snd π π).op =
Equalizer.Presieve.secondMap F (Presieve.singleton π) ≫ (EqualizerSecondObjIso F π).hom
iy_mem :
F.map (pullback.fst π π).op ((EqualizerFirstObjIso F π).hom y) =
F.map (pullback.snd π π).op ((EqualizerFirstObjIso F π).hom y)
x : F.obj B.op
hx :
(Equalizer.forkMap F (Presieve.singleton π) ≫ (EqualizerFirstObjIso F π).hom) x = (EqualizerFirstObjIso F π).hom y ∧
∀ (y_1 : F.obj B.op),
(Equalizer.forkMap F (Presieve.singleton π) ≫ (EqualizerFirstObjIso F π).hom) y_1 =
(EqualizerFirstObjIso F π).hom y →
y_1 = x
⊢ (fun x => Equalizer.forkMap F (Presieve.singleton π) x = y) x ∧
∀ (y_1 : F.obj B.op), (fun x => Equalizer.forkMap F (Presieve.singleton π) x = y) y_1 → y_1 = x | Please generate a tactic in lean4 to solve the state.
STATE:
case inr.intro.intro.intro.intro
B : CompHaus
F : CompHausᵒᵖ ⥤ Type (u + 1)
hFpfp : PreservesFiniteProducts F
X : CompHaus
π : X ⟶ B
πsurj : Function.Surjective ↑π
y : Equalizer.FirstObj F (Presieve.singleton π)
h : Equalizer.Presieve.firstMap F (Presieve.singleton π) y = Equalizer.Presieve.secondMap F (Presieve.singleton π) y
hFecs :
Function.Bijective
(MapToEqualizer F π (pullback.fst π π) (pullback.snd π π) (_ : pullback.fst π π ≫ π = pullback.snd π π ≫ π))
fork_comp : Equalizer.forkMap F (Presieve.singleton π) ≫ (EqualizerFirstObjIso F π).hom = F.map π.op
fmap_comp :
(EqualizerFirstObjIso F π).hom ≫ F.map (pullback.fst π π).op =
Equalizer.Presieve.firstMap F (Presieve.singleton π) ≫ (EqualizerSecondObjIso F π).hom
smap_comp :
(EqualizerFirstObjIso F π).hom ≫ F.map (pullback.snd π π).op =
Equalizer.Presieve.secondMap F (Presieve.singleton π) ≫ (EqualizerSecondObjIso F π).hom
iy_mem :
F.map (pullback.fst π π).op ((EqualizerFirstObjIso F π).hom y) =
F.map (pullback.snd π π).op ((EqualizerFirstObjIso F π).hom y)
x : F.obj B.op
hx :
(Equalizer.forkMap F (Presieve.singleton π) ≫ (EqualizerFirstObjIso F π).hom) x = (EqualizerFirstObjIso F π).hom y ∧
∀ (y_1 : F.obj B.op),
(Equalizer.forkMap F (Presieve.singleton π) ≫ (EqualizerFirstObjIso F π).hom) y_1 =
(EqualizerFirstObjIso F π).hom y →
y_1 = x
⊢ ∃! x, Equalizer.forkMap F (Presieve.singleton π) x = y
TACTIC:
|
https://github.com/adamtopaz/CopenhagenMasterclass2023.git | a293ca1554f7e80d891fd4d86fb092c54d8a0a01 | CompHaus/ExplicitSheaves.lean | CompHaus.isSheafFor_of_Dagur | [277, 1] | [352, 22] | dsimp | case inr.intro.intro.intro.intro
B : CompHaus
F : CompHausᵒᵖ ⥤ Type (u + 1)
hFpfp : PreservesFiniteProducts F
X : CompHaus
π : X ⟶ B
πsurj : Function.Surjective ↑π
y : Equalizer.FirstObj F (Presieve.singleton π)
h : Equalizer.Presieve.firstMap F (Presieve.singleton π) y = Equalizer.Presieve.secondMap F (Presieve.singleton π) y
hFecs :
Function.Bijective
(MapToEqualizer F π (pullback.fst π π) (pullback.snd π π) (_ : pullback.fst π π ≫ π = pullback.snd π π ≫ π))
fork_comp : Equalizer.forkMap F (Presieve.singleton π) ≫ (EqualizerFirstObjIso F π).hom = F.map π.op
fmap_comp :
(EqualizerFirstObjIso F π).hom ≫ F.map (pullback.fst π π).op =
Equalizer.Presieve.firstMap F (Presieve.singleton π) ≫ (EqualizerSecondObjIso F π).hom
smap_comp :
(EqualizerFirstObjIso F π).hom ≫ F.map (pullback.snd π π).op =
Equalizer.Presieve.secondMap F (Presieve.singleton π) ≫ (EqualizerSecondObjIso F π).hom
iy_mem :
F.map (pullback.fst π π).op ((EqualizerFirstObjIso F π).hom y) =
F.map (pullback.snd π π).op ((EqualizerFirstObjIso F π).hom y)
x : F.obj B.op
hx :
(Equalizer.forkMap F (Presieve.singleton π) ≫ (EqualizerFirstObjIso F π).hom) x = (EqualizerFirstObjIso F π).hom y ∧
∀ (y_1 : F.obj B.op),
(Equalizer.forkMap F (Presieve.singleton π) ≫ (EqualizerFirstObjIso F π).hom) y_1 =
(EqualizerFirstObjIso F π).hom y →
y_1 = x
⊢ (fun x => Equalizer.forkMap F (Presieve.singleton π) x = y) x ∧
∀ (y_1 : F.obj B.op), (fun x => Equalizer.forkMap F (Presieve.singleton π) x = y) y_1 → y_1 = x | case inr.intro.intro.intro.intro
B : CompHaus
F : CompHausᵒᵖ ⥤ Type (u + 1)
hFpfp : PreservesFiniteProducts F
X : CompHaus
π : X ⟶ B
πsurj : Function.Surjective ↑π
y : Equalizer.FirstObj F (Presieve.singleton π)
h : Equalizer.Presieve.firstMap F (Presieve.singleton π) y = Equalizer.Presieve.secondMap F (Presieve.singleton π) y
hFecs :
Function.Bijective
(MapToEqualizer F π (pullback.fst π π) (pullback.snd π π) (_ : pullback.fst π π ≫ π = pullback.snd π π ≫ π))
fork_comp : Equalizer.forkMap F (Presieve.singleton π) ≫ (EqualizerFirstObjIso F π).hom = F.map π.op
fmap_comp :
(EqualizerFirstObjIso F π).hom ≫ F.map (pullback.fst π π).op =
Equalizer.Presieve.firstMap F (Presieve.singleton π) ≫ (EqualizerSecondObjIso F π).hom
smap_comp :
(EqualizerFirstObjIso F π).hom ≫ F.map (pullback.snd π π).op =
Equalizer.Presieve.secondMap F (Presieve.singleton π) ≫ (EqualizerSecondObjIso F π).hom
iy_mem :
F.map (pullback.fst π π).op ((EqualizerFirstObjIso F π).hom y) =
F.map (pullback.snd π π).op ((EqualizerFirstObjIso F π).hom y)
x : F.obj B.op
hx :
(Equalizer.forkMap F (Presieve.singleton π) ≫ (EqualizerFirstObjIso F π).hom) x = (EqualizerFirstObjIso F π).hom y ∧
∀ (y_1 : F.obj B.op),
(Equalizer.forkMap F (Presieve.singleton π) ≫ (EqualizerFirstObjIso F π).hom) y_1 =
(EqualizerFirstObjIso F π).hom y →
y_1 = x
⊢ Equalizer.forkMap F (Presieve.singleton π) x = y ∧
∀ (y_1 : F.obj B.op), Equalizer.forkMap F (Presieve.singleton π) y_1 = y → y_1 = x | Please generate a tactic in lean4 to solve the state.
STATE:
case inr.intro.intro.intro.intro
B : CompHaus
F : CompHausᵒᵖ ⥤ Type (u + 1)
hFpfp : PreservesFiniteProducts F
X : CompHaus
π : X ⟶ B
πsurj : Function.Surjective ↑π
y : Equalizer.FirstObj F (Presieve.singleton π)
h : Equalizer.Presieve.firstMap F (Presieve.singleton π) y = Equalizer.Presieve.secondMap F (Presieve.singleton π) y
hFecs :
Function.Bijective
(MapToEqualizer F π (pullback.fst π π) (pullback.snd π π) (_ : pullback.fst π π ≫ π = pullback.snd π π ≫ π))
fork_comp : Equalizer.forkMap F (Presieve.singleton π) ≫ (EqualizerFirstObjIso F π).hom = F.map π.op
fmap_comp :
(EqualizerFirstObjIso F π).hom ≫ F.map (pullback.fst π π).op =
Equalizer.Presieve.firstMap F (Presieve.singleton π) ≫ (EqualizerSecondObjIso F π).hom
smap_comp :
(EqualizerFirstObjIso F π).hom ≫ F.map (pullback.snd π π).op =
Equalizer.Presieve.secondMap F (Presieve.singleton π) ≫ (EqualizerSecondObjIso F π).hom
iy_mem :
F.map (pullback.fst π π).op ((EqualizerFirstObjIso F π).hom y) =
F.map (pullback.snd π π).op ((EqualizerFirstObjIso F π).hom y)
x : F.obj B.op
hx :
(Equalizer.forkMap F (Presieve.singleton π) ≫ (EqualizerFirstObjIso F π).hom) x = (EqualizerFirstObjIso F π).hom y ∧
∀ (y_1 : F.obj B.op),
(Equalizer.forkMap F (Presieve.singleton π) ≫ (EqualizerFirstObjIso F π).hom) y_1 =
(EqualizerFirstObjIso F π).hom y →
y_1 = x
⊢ (fun x => Equalizer.forkMap F (Presieve.singleton π) x = y) x ∧
∀ (y_1 : F.obj B.op), (fun x => Equalizer.forkMap F (Presieve.singleton π) x = y) y_1 → y_1 = x
TACTIC:
|
https://github.com/adamtopaz/CopenhagenMasterclass2023.git | a293ca1554f7e80d891fd4d86fb092c54d8a0a01 | CompHaus/ExplicitSheaves.lean | CompHaus.isSheafFor_of_Dagur | [277, 1] | [352, 22] | constructor | case inr.intro.intro.intro.intro
B : CompHaus
F : CompHausᵒᵖ ⥤ Type (u + 1)
hFpfp : PreservesFiniteProducts F
X : CompHaus
π : X ⟶ B
πsurj : Function.Surjective ↑π
y : Equalizer.FirstObj F (Presieve.singleton π)
h : Equalizer.Presieve.firstMap F (Presieve.singleton π) y = Equalizer.Presieve.secondMap F (Presieve.singleton π) y
hFecs :
Function.Bijective
(MapToEqualizer F π (pullback.fst π π) (pullback.snd π π) (_ : pullback.fst π π ≫ π = pullback.snd π π ≫ π))
fork_comp : Equalizer.forkMap F (Presieve.singleton π) ≫ (EqualizerFirstObjIso F π).hom = F.map π.op
fmap_comp :
(EqualizerFirstObjIso F π).hom ≫ F.map (pullback.fst π π).op =
Equalizer.Presieve.firstMap F (Presieve.singleton π) ≫ (EqualizerSecondObjIso F π).hom
smap_comp :
(EqualizerFirstObjIso F π).hom ≫ F.map (pullback.snd π π).op =
Equalizer.Presieve.secondMap F (Presieve.singleton π) ≫ (EqualizerSecondObjIso F π).hom
iy_mem :
F.map (pullback.fst π π).op ((EqualizerFirstObjIso F π).hom y) =
F.map (pullback.snd π π).op ((EqualizerFirstObjIso F π).hom y)
x : F.obj B.op
hx :
(Equalizer.forkMap F (Presieve.singleton π) ≫ (EqualizerFirstObjIso F π).hom) x = (EqualizerFirstObjIso F π).hom y ∧
∀ (y_1 : F.obj B.op),
(Equalizer.forkMap F (Presieve.singleton π) ≫ (EqualizerFirstObjIso F π).hom) y_1 =
(EqualizerFirstObjIso F π).hom y →
y_1 = x
⊢ Equalizer.forkMap F (Presieve.singleton π) x = y ∧
∀ (y_1 : F.obj B.op), Equalizer.forkMap F (Presieve.singleton π) y_1 = y → y_1 = x | case inr.intro.intro.intro.intro.left
B : CompHaus
F : CompHausᵒᵖ ⥤ Type (u + 1)
hFpfp : PreservesFiniteProducts F
X : CompHaus
π : X ⟶ B
πsurj : Function.Surjective ↑π
y : Equalizer.FirstObj F (Presieve.singleton π)
h : Equalizer.Presieve.firstMap F (Presieve.singleton π) y = Equalizer.Presieve.secondMap F (Presieve.singleton π) y
hFecs :
Function.Bijective
(MapToEqualizer F π (pullback.fst π π) (pullback.snd π π) (_ : pullback.fst π π ≫ π = pullback.snd π π ≫ π))
fork_comp : Equalizer.forkMap F (Presieve.singleton π) ≫ (EqualizerFirstObjIso F π).hom = F.map π.op
fmap_comp :
(EqualizerFirstObjIso F π).hom ≫ F.map (pullback.fst π π).op =
Equalizer.Presieve.firstMap F (Presieve.singleton π) ≫ (EqualizerSecondObjIso F π).hom
smap_comp :
(EqualizerFirstObjIso F π).hom ≫ F.map (pullback.snd π π).op =
Equalizer.Presieve.secondMap F (Presieve.singleton π) ≫ (EqualizerSecondObjIso F π).hom
iy_mem :
F.map (pullback.fst π π).op ((EqualizerFirstObjIso F π).hom y) =
F.map (pullback.snd π π).op ((EqualizerFirstObjIso F π).hom y)
x : F.obj B.op
hx :
(Equalizer.forkMap F (Presieve.singleton π) ≫ (EqualizerFirstObjIso F π).hom) x = (EqualizerFirstObjIso F π).hom y ∧
∀ (y_1 : F.obj B.op),
(Equalizer.forkMap F (Presieve.singleton π) ≫ (EqualizerFirstObjIso F π).hom) y_1 =
(EqualizerFirstObjIso F π).hom y →
y_1 = x
⊢ Equalizer.forkMap F (Presieve.singleton π) x = y
case inr.intro.intro.intro.intro.right
B : CompHaus
F : CompHausᵒᵖ ⥤ Type (u + 1)
hFpfp : PreservesFiniteProducts F
X : CompHaus
π : X ⟶ B
πsurj : Function.Surjective ↑π
y : Equalizer.FirstObj F (Presieve.singleton π)
h : Equalizer.Presieve.firstMap F (Presieve.singleton π) y = Equalizer.Presieve.secondMap F (Presieve.singleton π) y
hFecs :
Function.Bijective
(MapToEqualizer F π (pullback.fst π π) (pullback.snd π π) (_ : pullback.fst π π ≫ π = pullback.snd π π ≫ π))
fork_comp : Equalizer.forkMap F (Presieve.singleton π) ≫ (EqualizerFirstObjIso F π).hom = F.map π.op
fmap_comp :
(EqualizerFirstObjIso F π).hom ≫ F.map (pullback.fst π π).op =
Equalizer.Presieve.firstMap F (Presieve.singleton π) ≫ (EqualizerSecondObjIso F π).hom
smap_comp :
(EqualizerFirstObjIso F π).hom ≫ F.map (pullback.snd π π).op =
Equalizer.Presieve.secondMap F (Presieve.singleton π) ≫ (EqualizerSecondObjIso F π).hom
iy_mem :
F.map (pullback.fst π π).op ((EqualizerFirstObjIso F π).hom y) =
F.map (pullback.snd π π).op ((EqualizerFirstObjIso F π).hom y)
x : F.obj B.op
hx :
(Equalizer.forkMap F (Presieve.singleton π) ≫ (EqualizerFirstObjIso F π).hom) x = (EqualizerFirstObjIso F π).hom y ∧
∀ (y_1 : F.obj B.op),
(Equalizer.forkMap F (Presieve.singleton π) ≫ (EqualizerFirstObjIso F π).hom) y_1 =
(EqualizerFirstObjIso F π).hom y →
y_1 = x
⊢ ∀ (y_1 : F.obj B.op), Equalizer.forkMap F (Presieve.singleton π) y_1 = y → y_1 = x | Please generate a tactic in lean4 to solve the state.
STATE:
case inr.intro.intro.intro.intro
B : CompHaus
F : CompHausᵒᵖ ⥤ Type (u + 1)
hFpfp : PreservesFiniteProducts F
X : CompHaus
π : X ⟶ B
πsurj : Function.Surjective ↑π
y : Equalizer.FirstObj F (Presieve.singleton π)
h : Equalizer.Presieve.firstMap F (Presieve.singleton π) y = Equalizer.Presieve.secondMap F (Presieve.singleton π) y
hFecs :
Function.Bijective
(MapToEqualizer F π (pullback.fst π π) (pullback.snd π π) (_ : pullback.fst π π ≫ π = pullback.snd π π ≫ π))
fork_comp : Equalizer.forkMap F (Presieve.singleton π) ≫ (EqualizerFirstObjIso F π).hom = F.map π.op
fmap_comp :
(EqualizerFirstObjIso F π).hom ≫ F.map (pullback.fst π π).op =
Equalizer.Presieve.firstMap F (Presieve.singleton π) ≫ (EqualizerSecondObjIso F π).hom
smap_comp :
(EqualizerFirstObjIso F π).hom ≫ F.map (pullback.snd π π).op =
Equalizer.Presieve.secondMap F (Presieve.singleton π) ≫ (EqualizerSecondObjIso F π).hom
iy_mem :
F.map (pullback.fst π π).op ((EqualizerFirstObjIso F π).hom y) =
F.map (pullback.snd π π).op ((EqualizerFirstObjIso F π).hom y)
x : F.obj B.op
hx :
(Equalizer.forkMap F (Presieve.singleton π) ≫ (EqualizerFirstObjIso F π).hom) x = (EqualizerFirstObjIso F π).hom y ∧
∀ (y_1 : F.obj B.op),
(Equalizer.forkMap F (Presieve.singleton π) ≫ (EqualizerFirstObjIso F π).hom) y_1 =
(EqualizerFirstObjIso F π).hom y →
y_1 = x
⊢ Equalizer.forkMap F (Presieve.singleton π) x = y ∧
∀ (y_1 : F.obj B.op), Equalizer.forkMap F (Presieve.singleton π) y_1 = y → y_1 = x
TACTIC:
|
https://github.com/adamtopaz/CopenhagenMasterclass2023.git | a293ca1554f7e80d891fd4d86fb092c54d8a0a01 | CompHaus/ExplicitSheaves.lean | CompHaus.isSheafFor_of_Dagur | [277, 1] | [352, 22] | dsimp [EqualizerFirstObjIso, Equalizer.forkMap] | case fork_comp
B : CompHaus
F : CompHausᵒᵖ ⥤ Type (u + 1)
hFpfp : PreservesFiniteProducts F
X : CompHaus
π : X ⟶ B
πsurj : Function.Surjective ↑π
y : Equalizer.FirstObj F (Presieve.singleton π)
h : Equalizer.Presieve.firstMap F (Presieve.singleton π) y = Equalizer.Presieve.secondMap F (Presieve.singleton π) y
hFecs :
Function.Bijective
(MapToEqualizer F π (pullback.fst π π) (pullback.snd π π) (_ : pullback.fst π π ≫ π = pullback.snd π π ≫ π))
⊢ Equalizer.forkMap F (Presieve.singleton π) ≫ (EqualizerFirstObjIso F π).hom = F.map π.op | case fork_comp
B : CompHaus
F : CompHausᵒᵖ ⥤ Type (u + 1)
hFpfp : PreservesFiniteProducts F
X : CompHaus
π : X ⟶ B
πsurj : Function.Surjective ↑π
y : Equalizer.FirstObj F (Presieve.singleton π)
h : Equalizer.Presieve.firstMap F (Presieve.singleton π) y = Equalizer.Presieve.secondMap F (Presieve.singleton π) y
hFecs :
Function.Bijective
(MapToEqualizer F π (pullback.fst π π) (pullback.snd π π) (_ : pullback.fst π π ≫ π = pullback.snd π π ≫ π))
⊢ ((Pi.lift fun f => F.map (↑f.snd).op) ≫
(Equalizer.firstObjEqFamily F (Presieve.singleton π)).hom ≫ fun e => e π (_ : Presieve.singleton π π)) =
F.map π.op | Please generate a tactic in lean4 to solve the state.
STATE:
case fork_comp
B : CompHaus
F : CompHausᵒᵖ ⥤ Type (u + 1)
hFpfp : PreservesFiniteProducts F
X : CompHaus
π : X ⟶ B
πsurj : Function.Surjective ↑π
y : Equalizer.FirstObj F (Presieve.singleton π)
h : Equalizer.Presieve.firstMap F (Presieve.singleton π) y = Equalizer.Presieve.secondMap F (Presieve.singleton π) y
hFecs :
Function.Bijective
(MapToEqualizer F π (pullback.fst π π) (pullback.snd π π) (_ : pullback.fst π π ≫ π = pullback.snd π π ≫ π))
⊢ Equalizer.forkMap F (Presieve.singleton π) ≫ (EqualizerFirstObjIso F π).hom = F.map π.op
TACTIC:
|
https://github.com/adamtopaz/CopenhagenMasterclass2023.git | a293ca1554f7e80d891fd4d86fb092c54d8a0a01 | CompHaus/ExplicitSheaves.lean | CompHaus.isSheafFor_of_Dagur | [277, 1] | [352, 22] | ext b | case fork_comp
B : CompHaus
F : CompHausᵒᵖ ⥤ Type (u + 1)
hFpfp : PreservesFiniteProducts F
X : CompHaus
π : X ⟶ B
πsurj : Function.Surjective ↑π
y : Equalizer.FirstObj F (Presieve.singleton π)
h : Equalizer.Presieve.firstMap F (Presieve.singleton π) y = Equalizer.Presieve.secondMap F (Presieve.singleton π) y
hFecs :
Function.Bijective
(MapToEqualizer F π (pullback.fst π π) (pullback.snd π π) (_ : pullback.fst π π ≫ π = pullback.snd π π ≫ π))
⊢ ((Pi.lift fun f => F.map (↑f.snd).op) ≫
(Equalizer.firstObjEqFamily F (Presieve.singleton π)).hom ≫ fun e => e π (_ : Presieve.singleton π π)) =
F.map π.op | case fork_comp.h
B : CompHaus
F : CompHausᵒᵖ ⥤ Type (u + 1)
hFpfp : PreservesFiniteProducts F
X : CompHaus
π : X ⟶ B
πsurj : Function.Surjective ↑π
y : Equalizer.FirstObj F (Presieve.singleton π)
h : Equalizer.Presieve.firstMap F (Presieve.singleton π) y = Equalizer.Presieve.secondMap F (Presieve.singleton π) y
hFecs :
Function.Bijective
(MapToEqualizer F π (pullback.fst π π) (pullback.snd π π) (_ : pullback.fst π π ≫ π = pullback.snd π π ≫ π))
b : F.obj B.op
⊢ ((Pi.lift fun f => F.map (↑f.snd).op) ≫
(Equalizer.firstObjEqFamily F (Presieve.singleton π)).hom ≫ fun e => e π (_ : Presieve.singleton π π))
b =
F.map π.op b | Please generate a tactic in lean4 to solve the state.
STATE:
case fork_comp
B : CompHaus
F : CompHausᵒᵖ ⥤ Type (u + 1)
hFpfp : PreservesFiniteProducts F
X : CompHaus
π : X ⟶ B
πsurj : Function.Surjective ↑π
y : Equalizer.FirstObj F (Presieve.singleton π)
h : Equalizer.Presieve.firstMap F (Presieve.singleton π) y = Equalizer.Presieve.secondMap F (Presieve.singleton π) y
hFecs :
Function.Bijective
(MapToEqualizer F π (pullback.fst π π) (pullback.snd π π) (_ : pullback.fst π π ≫ π = pullback.snd π π ≫ π))
⊢ ((Pi.lift fun f => F.map (↑f.snd).op) ≫
(Equalizer.firstObjEqFamily F (Presieve.singleton π)).hom ≫ fun e => e π (_ : Presieve.singleton π π)) =
F.map π.op
TACTIC:
|
https://github.com/adamtopaz/CopenhagenMasterclass2023.git | a293ca1554f7e80d891fd4d86fb092c54d8a0a01 | CompHaus/ExplicitSheaves.lean | CompHaus.isSheafFor_of_Dagur | [277, 1] | [352, 22] | simp only [types_comp_apply, Equalizer.firstObjEqFamily_hom, Types.pi_lift_π_apply] | case fork_comp.h
B : CompHaus
F : CompHausᵒᵖ ⥤ Type (u + 1)
hFpfp : PreservesFiniteProducts F
X : CompHaus
π : X ⟶ B
πsurj : Function.Surjective ↑π
y : Equalizer.FirstObj F (Presieve.singleton π)
h : Equalizer.Presieve.firstMap F (Presieve.singleton π) y = Equalizer.Presieve.secondMap F (Presieve.singleton π) y
hFecs :
Function.Bijective
(MapToEqualizer F π (pullback.fst π π) (pullback.snd π π) (_ : pullback.fst π π ≫ π = pullback.snd π π ≫ π))
b : F.obj B.op
⊢ ((Pi.lift fun f => F.map (↑f.snd).op) ≫
(Equalizer.firstObjEqFamily F (Presieve.singleton π)).hom ≫ fun e => e π (_ : Presieve.singleton π π))
b =
F.map π.op b | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case fork_comp.h
B : CompHaus
F : CompHausᵒᵖ ⥤ Type (u + 1)
hFpfp : PreservesFiniteProducts F
X : CompHaus
π : X ⟶ B
πsurj : Function.Surjective ↑π
y : Equalizer.FirstObj F (Presieve.singleton π)
h : Equalizer.Presieve.firstMap F (Presieve.singleton π) y = Equalizer.Presieve.secondMap F (Presieve.singleton π) y
hFecs :
Function.Bijective
(MapToEqualizer F π (pullback.fst π π) (pullback.snd π π) (_ : pullback.fst π π ≫ π = pullback.snd π π ≫ π))
b : F.obj B.op
⊢ ((Pi.lift fun f => F.map (↑f.snd).op) ≫
(Equalizer.firstObjEqFamily F (Presieve.singleton π)).hom ≫ fun e => e π (_ : Presieve.singleton π π))
b =
F.map π.op b
TACTIC:
|
https://github.com/adamtopaz/CopenhagenMasterclass2023.git | a293ca1554f7e80d891fd4d86fb092c54d8a0a01 | CompHaus/ExplicitSheaves.lean | CompHaus.isSheafFor_of_Dagur | [277, 1] | [352, 22] | dsimp [EqualizerSecondObjIso] | case fmap_comp
B : CompHaus
F : CompHausᵒᵖ ⥤ Type (u + 1)
hFpfp : PreservesFiniteProducts F
X : CompHaus
π : X ⟶ B
πsurj : Function.Surjective ↑π
y : Equalizer.FirstObj F (Presieve.singleton π)
h : Equalizer.Presieve.firstMap F (Presieve.singleton π) y = Equalizer.Presieve.secondMap F (Presieve.singleton π) y
hFecs :
Function.Bijective
(MapToEqualizer F π (pullback.fst π π) (pullback.snd π π) (_ : pullback.fst π π ≫ π = pullback.snd π π ≫ π))
fork_comp : Equalizer.forkMap F (Presieve.singleton π) ≫ (EqualizerFirstObjIso F π).hom = F.map π.op
⊢ (EqualizerFirstObjIso F π).hom ≫ F.map (pullback.fst π π).op =
Equalizer.Presieve.firstMap F (Presieve.singleton π) ≫ (EqualizerSecondObjIso F π).hom | case fmap_comp
B : CompHaus
F : CompHausᵒᵖ ⥤ Type (u + 1)
hFpfp : PreservesFiniteProducts F
X : CompHaus
π : X ⟶ B
πsurj : Function.Surjective ↑π
y : Equalizer.FirstObj F (Presieve.singleton π)
h : Equalizer.Presieve.firstMap F (Presieve.singleton π) y = Equalizer.Presieve.secondMap F (Presieve.singleton π) y
hFecs :
Function.Bijective
(MapToEqualizer F π (pullback.fst π π) (pullback.snd π π) (_ : pullback.fst π π ≫ π = pullback.snd π π ≫ π))
fork_comp : Equalizer.forkMap F (Presieve.singleton π) ≫ (EqualizerFirstObjIso F π).hom = F.map π.op
⊢ (EqualizerFirstObjIso F π).hom ≫ F.map (pullback.fst π π).op =
Equalizer.Presieve.firstMap F (Presieve.singleton π) ≫
(EqualizerSecondObjIso_aux F π).hom ≫ F.map (fromExplicit π π).op | Please generate a tactic in lean4 to solve the state.
STATE:
case fmap_comp
B : CompHaus
F : CompHausᵒᵖ ⥤ Type (u + 1)
hFpfp : PreservesFiniteProducts F
X : CompHaus
π : X ⟶ B
πsurj : Function.Surjective ↑π
y : Equalizer.FirstObj F (Presieve.singleton π)
h : Equalizer.Presieve.firstMap F (Presieve.singleton π) y = Equalizer.Presieve.secondMap F (Presieve.singleton π) y
hFecs :
Function.Bijective
(MapToEqualizer F π (pullback.fst π π) (pullback.snd π π) (_ : pullback.fst π π ≫ π = pullback.snd π π ≫ π))
fork_comp : Equalizer.forkMap F (Presieve.singleton π) ≫ (EqualizerFirstObjIso F π).hom = F.map π.op
⊢ (EqualizerFirstObjIso F π).hom ≫ F.map (pullback.fst π π).op =
Equalizer.Presieve.firstMap F (Presieve.singleton π) ≫ (EqualizerSecondObjIso F π).hom
TACTIC:
|
https://github.com/adamtopaz/CopenhagenMasterclass2023.git | a293ca1554f7e80d891fd4d86fb092c54d8a0a01 | CompHaus/ExplicitSheaves.lean | CompHaus.isSheafFor_of_Dagur | [277, 1] | [352, 22] | rw [CompHaus.fst_comp_fromExplicit, op_comp, Functor.map_comp] | case fmap_comp
B : CompHaus
F : CompHausᵒᵖ ⥤ Type (u + 1)
hFpfp : PreservesFiniteProducts F
X : CompHaus
π : X ⟶ B
πsurj : Function.Surjective ↑π
y : Equalizer.FirstObj F (Presieve.singleton π)
h : Equalizer.Presieve.firstMap F (Presieve.singleton π) y = Equalizer.Presieve.secondMap F (Presieve.singleton π) y
hFecs :
Function.Bijective
(MapToEqualizer F π (pullback.fst π π) (pullback.snd π π) (_ : pullback.fst π π ≫ π = pullback.snd π π ≫ π))
fork_comp : Equalizer.forkMap F (Presieve.singleton π) ≫ (EqualizerFirstObjIso F π).hom = F.map π.op
⊢ (EqualizerFirstObjIso F π).hom ≫ F.map (pullback.fst π π).op =
Equalizer.Presieve.firstMap F (Presieve.singleton π) ≫
(EqualizerSecondObjIso_aux F π).hom ≫ F.map (fromExplicit π π).op | case fmap_comp
B : CompHaus
F : CompHausᵒᵖ ⥤ Type (u + 1)
hFpfp : PreservesFiniteProducts F
X : CompHaus
π : X ⟶ B
πsurj : Function.Surjective ↑π
y : Equalizer.FirstObj F (Presieve.singleton π)
h : Equalizer.Presieve.firstMap F (Presieve.singleton π) y = Equalizer.Presieve.secondMap F (Presieve.singleton π) y
hFecs :
Function.Bijective
(MapToEqualizer F π (pullback.fst π π) (pullback.snd π π) (_ : pullback.fst π π ≫ π = pullback.snd π π ≫ π))
fork_comp : Equalizer.forkMap F (Presieve.singleton π) ≫ (EqualizerFirstObjIso F π).hom = F.map π.op
⊢ (EqualizerFirstObjIso F π).hom ≫ F.map Limits.pullback.fst.op ≫ F.map (fromExplicit π π).op =
Equalizer.Presieve.firstMap F (Presieve.singleton π) ≫
(EqualizerSecondObjIso_aux F π).hom ≫ F.map (fromExplicit π π).op | Please generate a tactic in lean4 to solve the state.
STATE:
case fmap_comp
B : CompHaus
F : CompHausᵒᵖ ⥤ Type (u + 1)
hFpfp : PreservesFiniteProducts F
X : CompHaus
π : X ⟶ B
πsurj : Function.Surjective ↑π
y : Equalizer.FirstObj F (Presieve.singleton π)
h : Equalizer.Presieve.firstMap F (Presieve.singleton π) y = Equalizer.Presieve.secondMap F (Presieve.singleton π) y
hFecs :
Function.Bijective
(MapToEqualizer F π (pullback.fst π π) (pullback.snd π π) (_ : pullback.fst π π ≫ π = pullback.snd π π ≫ π))
fork_comp : Equalizer.forkMap F (Presieve.singleton π) ≫ (EqualizerFirstObjIso F π).hom = F.map π.op
⊢ (EqualizerFirstObjIso F π).hom ≫ F.map (pullback.fst π π).op =
Equalizer.Presieve.firstMap F (Presieve.singleton π) ≫
(EqualizerSecondObjIso_aux F π).hom ≫ F.map (fromExplicit π π).op
TACTIC:
|
https://github.com/adamtopaz/CopenhagenMasterclass2023.git | a293ca1554f7e80d891fd4d86fb092c54d8a0a01 | CompHaus/ExplicitSheaves.lean | CompHaus.isSheafFor_of_Dagur | [277, 1] | [352, 22] | suffices : (EqualizerFirstObjIso F π).hom ≫ F.map Limits.pullback.fst.op =
Equalizer.Presieve.firstMap F (Presieve.singleton π) ≫
(EqualizerSecondObjIso_aux F π).hom | case fmap_comp
B : CompHaus
F : CompHausᵒᵖ ⥤ Type (u + 1)
hFpfp : PreservesFiniteProducts F
X : CompHaus
π : X ⟶ B
πsurj : Function.Surjective ↑π
y : Equalizer.FirstObj F (Presieve.singleton π)
h : Equalizer.Presieve.firstMap F (Presieve.singleton π) y = Equalizer.Presieve.secondMap F (Presieve.singleton π) y
hFecs :
Function.Bijective
(MapToEqualizer F π (pullback.fst π π) (pullback.snd π π) (_ : pullback.fst π π ≫ π = pullback.snd π π ≫ π))
fork_comp : Equalizer.forkMap F (Presieve.singleton π) ≫ (EqualizerFirstObjIso F π).hom = F.map π.op
⊢ (EqualizerFirstObjIso F π).hom ≫ F.map Limits.pullback.fst.op ≫ F.map (fromExplicit π π).op =
Equalizer.Presieve.firstMap F (Presieve.singleton π) ≫
(EqualizerSecondObjIso_aux F π).hom ≫ F.map (fromExplicit π π).op | case fmap_comp
B : CompHaus
F : CompHausᵒᵖ ⥤ Type (u + 1)
hFpfp : PreservesFiniteProducts F
X : CompHaus
π : X ⟶ B
πsurj : Function.Surjective ↑π
y : Equalizer.FirstObj F (Presieve.singleton π)
h : Equalizer.Presieve.firstMap F (Presieve.singleton π) y = Equalizer.Presieve.secondMap F (Presieve.singleton π) y
hFecs :
Function.Bijective
(MapToEqualizer F π (pullback.fst π π) (pullback.snd π π) (_ : pullback.fst π π ≫ π = pullback.snd π π ≫ π))
fork_comp : Equalizer.forkMap F (Presieve.singleton π) ≫ (EqualizerFirstObjIso F π).hom = F.map π.op
this :
(EqualizerFirstObjIso F π).hom ≫ F.map Limits.pullback.fst.op =
Equalizer.Presieve.firstMap F (Presieve.singleton π) ≫ (EqualizerSecondObjIso_aux F π).hom
⊢ (EqualizerFirstObjIso F π).hom ≫ F.map Limits.pullback.fst.op ≫ F.map (fromExplicit π π).op =
Equalizer.Presieve.firstMap F (Presieve.singleton π) ≫
(EqualizerSecondObjIso_aux F π).hom ≫ F.map (fromExplicit π π).op
case this
B : CompHaus
F : CompHausᵒᵖ ⥤ Type (u + 1)
hFpfp : PreservesFiniteProducts F
X : CompHaus
π : X ⟶ B
πsurj : Function.Surjective ↑π
y : Equalizer.FirstObj F (Presieve.singleton π)
h : Equalizer.Presieve.firstMap F (Presieve.singleton π) y = Equalizer.Presieve.secondMap F (Presieve.singleton π) y
hFecs :
Function.Bijective
(MapToEqualizer F π (pullback.fst π π) (pullback.snd π π) (_ : pullback.fst π π ≫ π = pullback.snd π π ≫ π))
fork_comp : Equalizer.forkMap F (Presieve.singleton π) ≫ (EqualizerFirstObjIso F π).hom = F.map π.op
⊢ (EqualizerFirstObjIso F π).hom ≫ F.map Limits.pullback.fst.op =
Equalizer.Presieve.firstMap F (Presieve.singleton π) ≫ (EqualizerSecondObjIso_aux F π).hom | Please generate a tactic in lean4 to solve the state.
STATE:
case fmap_comp
B : CompHaus
F : CompHausᵒᵖ ⥤ Type (u + 1)
hFpfp : PreservesFiniteProducts F
X : CompHaus
π : X ⟶ B
πsurj : Function.Surjective ↑π
y : Equalizer.FirstObj F (Presieve.singleton π)
h : Equalizer.Presieve.firstMap F (Presieve.singleton π) y = Equalizer.Presieve.secondMap F (Presieve.singleton π) y
hFecs :
Function.Bijective
(MapToEqualizer F π (pullback.fst π π) (pullback.snd π π) (_ : pullback.fst π π ≫ π = pullback.snd π π ≫ π))
fork_comp : Equalizer.forkMap F (Presieve.singleton π) ≫ (EqualizerFirstObjIso F π).hom = F.map π.op
⊢ (EqualizerFirstObjIso F π).hom ≫ F.map Limits.pullback.fst.op ≫ F.map (fromExplicit π π).op =
Equalizer.Presieve.firstMap F (Presieve.singleton π) ≫
(EqualizerSecondObjIso_aux F π).hom ≫ F.map (fromExplicit π π).op
TACTIC:
|
https://github.com/adamtopaz/CopenhagenMasterclass2023.git | a293ca1554f7e80d891fd4d86fb092c54d8a0a01 | CompHaus/ExplicitSheaves.lean | CompHaus.isSheafFor_of_Dagur | [277, 1] | [352, 22] | dsimp [EqualizerFirstObjIso, Equalizer.Presieve.firstMap, EqualizerSecondObjIso_aux] | case this
B : CompHaus
F : CompHausᵒᵖ ⥤ Type (u + 1)
hFpfp : PreservesFiniteProducts F
X : CompHaus
π : X ⟶ B
πsurj : Function.Surjective ↑π
y : Equalizer.FirstObj F (Presieve.singleton π)
h : Equalizer.Presieve.firstMap F (Presieve.singleton π) y = Equalizer.Presieve.secondMap F (Presieve.singleton π) y
hFecs :
Function.Bijective
(MapToEqualizer F π (pullback.fst π π) (pullback.snd π π) (_ : pullback.fst π π ≫ π = pullback.snd π π ≫ π))
fork_comp : Equalizer.forkMap F (Presieve.singleton π) ≫ (EqualizerFirstObjIso F π).hom = F.map π.op
⊢ (EqualizerFirstObjIso F π).hom ≫ F.map Limits.pullback.fst.op =
Equalizer.Presieve.firstMap F (Presieve.singleton π) ≫ (EqualizerSecondObjIso_aux F π).hom | case this
B : CompHaus
F : CompHausᵒᵖ ⥤ Type (u + 1)
hFpfp : PreservesFiniteProducts F
X : CompHaus
π : X ⟶ B
πsurj : Function.Surjective ↑π
y : Equalizer.FirstObj F (Presieve.singleton π)
h : Equalizer.Presieve.firstMap F (Presieve.singleton π) y = Equalizer.Presieve.secondMap F (Presieve.singleton π) y
hFecs :
Function.Bijective
(MapToEqualizer F π (pullback.fst π π) (pullback.snd π π) (_ : pullback.fst π π ≫ π = pullback.snd π π ≫ π))
fork_comp : Equalizer.forkMap F (Presieve.singleton π) ≫ (EqualizerFirstObjIso F π).hom = F.map π.op
⊢ ((Equalizer.firstObjEqFamily F (Presieve.singleton π)).hom ≫ fun e => e π (_ : Presieve.singleton π π)) ≫
F.map Limits.pullback.fst.op =
(Pi.lift fun x => Pi.π (fun f => F.obj f.fst.op) x.fst ≫ F.map Limits.pullback.fst.op) ≫
Pi.π (fun fg => F.obj (Limits.pullback ↑fg.fst.snd ↑fg.snd.snd).op)
({ fst := X, snd := { val := π, property := (_ : Presieve.singleton π π) } },
{ fst := X, snd := { val := π, property := (_ : Presieve.singleton π π) } }) | Please generate a tactic in lean4 to solve the state.
STATE:
case this
B : CompHaus
F : CompHausᵒᵖ ⥤ Type (u + 1)
hFpfp : PreservesFiniteProducts F
X : CompHaus
π : X ⟶ B
πsurj : Function.Surjective ↑π
y : Equalizer.FirstObj F (Presieve.singleton π)
h : Equalizer.Presieve.firstMap F (Presieve.singleton π) y = Equalizer.Presieve.secondMap F (Presieve.singleton π) y
hFecs :
Function.Bijective
(MapToEqualizer F π (pullback.fst π π) (pullback.snd π π) (_ : pullback.fst π π ≫ π = pullback.snd π π ≫ π))
fork_comp : Equalizer.forkMap F (Presieve.singleton π) ≫ (EqualizerFirstObjIso F π).hom = F.map π.op
⊢ (EqualizerFirstObjIso F π).hom ≫ F.map Limits.pullback.fst.op =
Equalizer.Presieve.firstMap F (Presieve.singleton π) ≫ (EqualizerSecondObjIso_aux F π).hom
TACTIC:
|
https://github.com/adamtopaz/CopenhagenMasterclass2023.git | a293ca1554f7e80d891fd4d86fb092c54d8a0a01 | CompHaus/ExplicitSheaves.lean | CompHaus.isSheafFor_of_Dagur | [277, 1] | [352, 22] | ext b | case this
B : CompHaus
F : CompHausᵒᵖ ⥤ Type (u + 1)
hFpfp : PreservesFiniteProducts F
X : CompHaus
π : X ⟶ B
πsurj : Function.Surjective ↑π
y : Equalizer.FirstObj F (Presieve.singleton π)
h : Equalizer.Presieve.firstMap F (Presieve.singleton π) y = Equalizer.Presieve.secondMap F (Presieve.singleton π) y
hFecs :
Function.Bijective
(MapToEqualizer F π (pullback.fst π π) (pullback.snd π π) (_ : pullback.fst π π ≫ π = pullback.snd π π ≫ π))
fork_comp : Equalizer.forkMap F (Presieve.singleton π) ≫ (EqualizerFirstObjIso F π).hom = F.map π.op
⊢ ((Equalizer.firstObjEqFamily F (Presieve.singleton π)).hom ≫ fun e => e π (_ : Presieve.singleton π π)) ≫
F.map Limits.pullback.fst.op =
(Pi.lift fun x => Pi.π (fun f => F.obj f.fst.op) x.fst ≫ F.map Limits.pullback.fst.op) ≫
Pi.π (fun fg => F.obj (Limits.pullback ↑fg.fst.snd ↑fg.snd.snd).op)
({ fst := X, snd := { val := π, property := (_ : Presieve.singleton π π) } },
{ fst := X, snd := { val := π, property := (_ : Presieve.singleton π π) } }) | case this.h
B : CompHaus
F : CompHausᵒᵖ ⥤ Type (u + 1)
hFpfp : PreservesFiniteProducts F
X : CompHaus
π : X ⟶ B
πsurj : Function.Surjective ↑π
y : Equalizer.FirstObj F (Presieve.singleton π)
h : Equalizer.Presieve.firstMap F (Presieve.singleton π) y = Equalizer.Presieve.secondMap F (Presieve.singleton π) y
hFecs :
Function.Bijective
(MapToEqualizer F π (pullback.fst π π) (pullback.snd π π) (_ : pullback.fst π π ≫ π = pullback.snd π π ≫ π))
fork_comp : Equalizer.forkMap F (Presieve.singleton π) ≫ (EqualizerFirstObjIso F π).hom = F.map π.op
b : Equalizer.FirstObj F (Presieve.singleton π)
⊢ (((Equalizer.firstObjEqFamily F (Presieve.singleton π)).hom ≫ fun e => e π (_ : Presieve.singleton π π)) ≫
F.map Limits.pullback.fst.op)
b =
((Pi.lift fun x => Pi.π (fun f => F.obj f.fst.op) x.fst ≫ F.map Limits.pullback.fst.op) ≫
Pi.π (fun fg => F.obj (Limits.pullback ↑fg.fst.snd ↑fg.snd.snd).op)
({ fst := X, snd := { val := π, property := (_ : Presieve.singleton π π) } },
{ fst := X, snd := { val := π, property := (_ : Presieve.singleton π π) } }))
b | Please generate a tactic in lean4 to solve the state.
STATE:
case this
B : CompHaus
F : CompHausᵒᵖ ⥤ Type (u + 1)
hFpfp : PreservesFiniteProducts F
X : CompHaus
π : X ⟶ B
πsurj : Function.Surjective ↑π
y : Equalizer.FirstObj F (Presieve.singleton π)
h : Equalizer.Presieve.firstMap F (Presieve.singleton π) y = Equalizer.Presieve.secondMap F (Presieve.singleton π) y
hFecs :
Function.Bijective
(MapToEqualizer F π (pullback.fst π π) (pullback.snd π π) (_ : pullback.fst π π ≫ π = pullback.snd π π ≫ π))
fork_comp : Equalizer.forkMap F (Presieve.singleton π) ≫ (EqualizerFirstObjIso F π).hom = F.map π.op
⊢ ((Equalizer.firstObjEqFamily F (Presieve.singleton π)).hom ≫ fun e => e π (_ : Presieve.singleton π π)) ≫
F.map Limits.pullback.fst.op =
(Pi.lift fun x => Pi.π (fun f => F.obj f.fst.op) x.fst ≫ F.map Limits.pullback.fst.op) ≫
Pi.π (fun fg => F.obj (Limits.pullback ↑fg.fst.snd ↑fg.snd.snd).op)
({ fst := X, snd := { val := π, property := (_ : Presieve.singleton π π) } },
{ fst := X, snd := { val := π, property := (_ : Presieve.singleton π π) } })
TACTIC:
|
https://github.com/adamtopaz/CopenhagenMasterclass2023.git | a293ca1554f7e80d891fd4d86fb092c54d8a0a01 | CompHaus/ExplicitSheaves.lean | CompHaus.isSheafFor_of_Dagur | [277, 1] | [352, 22] | simp only [types_comp_apply, Equalizer.firstObjEqFamily_hom, Types.pi_lift_π_apply] | case this.h
B : CompHaus
F : CompHausᵒᵖ ⥤ Type (u + 1)
hFpfp : PreservesFiniteProducts F
X : CompHaus
π : X ⟶ B
πsurj : Function.Surjective ↑π
y : Equalizer.FirstObj F (Presieve.singleton π)
h : Equalizer.Presieve.firstMap F (Presieve.singleton π) y = Equalizer.Presieve.secondMap F (Presieve.singleton π) y
hFecs :
Function.Bijective
(MapToEqualizer F π (pullback.fst π π) (pullback.snd π π) (_ : pullback.fst π π ≫ π = pullback.snd π π ≫ π))
fork_comp : Equalizer.forkMap F (Presieve.singleton π) ≫ (EqualizerFirstObjIso F π).hom = F.map π.op
b : Equalizer.FirstObj F (Presieve.singleton π)
⊢ (((Equalizer.firstObjEqFamily F (Presieve.singleton π)).hom ≫ fun e => e π (_ : Presieve.singleton π π)) ≫
F.map Limits.pullback.fst.op)
b =
((Pi.lift fun x => Pi.π (fun f => F.obj f.fst.op) x.fst ≫ F.map Limits.pullback.fst.op) ≫
Pi.π (fun fg => F.obj (Limits.pullback ↑fg.fst.snd ↑fg.snd.snd).op)
({ fst := X, snd := { val := π, property := (_ : Presieve.singleton π π) } },
{ fst := X, snd := { val := π, property := (_ : Presieve.singleton π π) } }))
b | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case this.h
B : CompHaus
F : CompHausᵒᵖ ⥤ Type (u + 1)
hFpfp : PreservesFiniteProducts F
X : CompHaus
π : X ⟶ B
πsurj : Function.Surjective ↑π
y : Equalizer.FirstObj F (Presieve.singleton π)
h : Equalizer.Presieve.firstMap F (Presieve.singleton π) y = Equalizer.Presieve.secondMap F (Presieve.singleton π) y
hFecs :
Function.Bijective
(MapToEqualizer F π (pullback.fst π π) (pullback.snd π π) (_ : pullback.fst π π ≫ π = pullback.snd π π ≫ π))
fork_comp : Equalizer.forkMap F (Presieve.singleton π) ≫ (EqualizerFirstObjIso F π).hom = F.map π.op
b : Equalizer.FirstObj F (Presieve.singleton π)
⊢ (((Equalizer.firstObjEqFamily F (Presieve.singleton π)).hom ≫ fun e => e π (_ : Presieve.singleton π π)) ≫
F.map Limits.pullback.fst.op)
b =
((Pi.lift fun x => Pi.π (fun f => F.obj f.fst.op) x.fst ≫ F.map Limits.pullback.fst.op) ≫
Pi.π (fun fg => F.obj (Limits.pullback ↑fg.fst.snd ↑fg.snd.snd).op)
({ fst := X, snd := { val := π, property := (_ : Presieve.singleton π π) } },
{ fst := X, snd := { val := π, property := (_ : Presieve.singleton π π) } }))
b
TACTIC:
|
https://github.com/adamtopaz/CopenhagenMasterclass2023.git | a293ca1554f7e80d891fd4d86fb092c54d8a0a01 | CompHaus/ExplicitSheaves.lean | CompHaus.isSheafFor_of_Dagur | [277, 1] | [352, 22] | simp only [← Category.assoc] | case fmap_comp
B : CompHaus
F : CompHausᵒᵖ ⥤ Type (u + 1)
hFpfp : PreservesFiniteProducts F
X : CompHaus
π : X ⟶ B
πsurj : Function.Surjective ↑π
y : Equalizer.FirstObj F (Presieve.singleton π)
h : Equalizer.Presieve.firstMap F (Presieve.singleton π) y = Equalizer.Presieve.secondMap F (Presieve.singleton π) y
hFecs :
Function.Bijective
(MapToEqualizer F π (pullback.fst π π) (pullback.snd π π) (_ : pullback.fst π π ≫ π = pullback.snd π π ≫ π))
fork_comp : Equalizer.forkMap F (Presieve.singleton π) ≫ (EqualizerFirstObjIso F π).hom = F.map π.op
this :
(EqualizerFirstObjIso F π).hom ≫ F.map Limits.pullback.fst.op =
Equalizer.Presieve.firstMap F (Presieve.singleton π) ≫ (EqualizerSecondObjIso_aux F π).hom
⊢ (EqualizerFirstObjIso F π).hom ≫ F.map Limits.pullback.fst.op ≫ F.map (fromExplicit π π).op =
Equalizer.Presieve.firstMap F (Presieve.singleton π) ≫
(EqualizerSecondObjIso_aux F π).hom ≫ F.map (fromExplicit π π).op | case fmap_comp
B : CompHaus
F : CompHausᵒᵖ ⥤ Type (u + 1)
hFpfp : PreservesFiniteProducts F
X : CompHaus
π : X ⟶ B
πsurj : Function.Surjective ↑π
y : Equalizer.FirstObj F (Presieve.singleton π)
h : Equalizer.Presieve.firstMap F (Presieve.singleton π) y = Equalizer.Presieve.secondMap F (Presieve.singleton π) y
hFecs :
Function.Bijective
(MapToEqualizer F π (pullback.fst π π) (pullback.snd π π) (_ : pullback.fst π π ≫ π = pullback.snd π π ≫ π))
fork_comp : Equalizer.forkMap F (Presieve.singleton π) ≫ (EqualizerFirstObjIso F π).hom = F.map π.op
this :
(EqualizerFirstObjIso F π).hom ≫ F.map Limits.pullback.fst.op =
Equalizer.Presieve.firstMap F (Presieve.singleton π) ≫ (EqualizerSecondObjIso_aux F π).hom
⊢ ((EqualizerFirstObjIso F π).hom ≫ F.map Limits.pullback.fst.op) ≫ F.map (fromExplicit π π).op =
(Equalizer.Presieve.firstMap F (Presieve.singleton π) ≫ (EqualizerSecondObjIso_aux F π).hom) ≫
F.map (fromExplicit π π).op | Please generate a tactic in lean4 to solve the state.
STATE:
case fmap_comp
B : CompHaus
F : CompHausᵒᵖ ⥤ Type (u + 1)
hFpfp : PreservesFiniteProducts F
X : CompHaus
π : X ⟶ B
πsurj : Function.Surjective ↑π
y : Equalizer.FirstObj F (Presieve.singleton π)
h : Equalizer.Presieve.firstMap F (Presieve.singleton π) y = Equalizer.Presieve.secondMap F (Presieve.singleton π) y
hFecs :
Function.Bijective
(MapToEqualizer F π (pullback.fst π π) (pullback.snd π π) (_ : pullback.fst π π ≫ π = pullback.snd π π ≫ π))
fork_comp : Equalizer.forkMap F (Presieve.singleton π) ≫ (EqualizerFirstObjIso F π).hom = F.map π.op
this :
(EqualizerFirstObjIso F π).hom ≫ F.map Limits.pullback.fst.op =
Equalizer.Presieve.firstMap F (Presieve.singleton π) ≫ (EqualizerSecondObjIso_aux F π).hom
⊢ (EqualizerFirstObjIso F π).hom ≫ F.map Limits.pullback.fst.op ≫ F.map (fromExplicit π π).op =
Equalizer.Presieve.firstMap F (Presieve.singleton π) ≫
(EqualizerSecondObjIso_aux F π).hom ≫ F.map (fromExplicit π π).op
TACTIC:
|
https://github.com/adamtopaz/CopenhagenMasterclass2023.git | a293ca1554f7e80d891fd4d86fb092c54d8a0a01 | CompHaus/ExplicitSheaves.lean | CompHaus.isSheafFor_of_Dagur | [277, 1] | [352, 22] | rw [this] | case fmap_comp
B : CompHaus
F : CompHausᵒᵖ ⥤ Type (u + 1)
hFpfp : PreservesFiniteProducts F
X : CompHaus
π : X ⟶ B
πsurj : Function.Surjective ↑π
y : Equalizer.FirstObj F (Presieve.singleton π)
h : Equalizer.Presieve.firstMap F (Presieve.singleton π) y = Equalizer.Presieve.secondMap F (Presieve.singleton π) y
hFecs :
Function.Bijective
(MapToEqualizer F π (pullback.fst π π) (pullback.snd π π) (_ : pullback.fst π π ≫ π = pullback.snd π π ≫ π))
fork_comp : Equalizer.forkMap F (Presieve.singleton π) ≫ (EqualizerFirstObjIso F π).hom = F.map π.op
this :
(EqualizerFirstObjIso F π).hom ≫ F.map Limits.pullback.fst.op =
Equalizer.Presieve.firstMap F (Presieve.singleton π) ≫ (EqualizerSecondObjIso_aux F π).hom
⊢ ((EqualizerFirstObjIso F π).hom ≫ F.map Limits.pullback.fst.op) ≫ F.map (fromExplicit π π).op =
(Equalizer.Presieve.firstMap F (Presieve.singleton π) ≫ (EqualizerSecondObjIso_aux F π).hom) ≫
F.map (fromExplicit π π).op | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case fmap_comp
B : CompHaus
F : CompHausᵒᵖ ⥤ Type (u + 1)
hFpfp : PreservesFiniteProducts F
X : CompHaus
π : X ⟶ B
πsurj : Function.Surjective ↑π
y : Equalizer.FirstObj F (Presieve.singleton π)
h : Equalizer.Presieve.firstMap F (Presieve.singleton π) y = Equalizer.Presieve.secondMap F (Presieve.singleton π) y
hFecs :
Function.Bijective
(MapToEqualizer F π (pullback.fst π π) (pullback.snd π π) (_ : pullback.fst π π ≫ π = pullback.snd π π ≫ π))
fork_comp : Equalizer.forkMap F (Presieve.singleton π) ≫ (EqualizerFirstObjIso F π).hom = F.map π.op
this :
(EqualizerFirstObjIso F π).hom ≫ F.map Limits.pullback.fst.op =
Equalizer.Presieve.firstMap F (Presieve.singleton π) ≫ (EqualizerSecondObjIso_aux F π).hom
⊢ ((EqualizerFirstObjIso F π).hom ≫ F.map Limits.pullback.fst.op) ≫ F.map (fromExplicit π π).op =
(Equalizer.Presieve.firstMap F (Presieve.singleton π) ≫ (EqualizerSecondObjIso_aux F π).hom) ≫
F.map (fromExplicit π π).op
TACTIC:
|
https://github.com/adamtopaz/CopenhagenMasterclass2023.git | a293ca1554f7e80d891fd4d86fb092c54d8a0a01 | CompHaus/ExplicitSheaves.lean | CompHaus.isSheafFor_of_Dagur | [277, 1] | [352, 22] | dsimp [EqualizerSecondObjIso] | case smap_comp
B : CompHaus
F : CompHausᵒᵖ ⥤ Type (u + 1)
hFpfp : PreservesFiniteProducts F
X : CompHaus
π : X ⟶ B
πsurj : Function.Surjective ↑π
y : Equalizer.FirstObj F (Presieve.singleton π)
h : Equalizer.Presieve.firstMap F (Presieve.singleton π) y = Equalizer.Presieve.secondMap F (Presieve.singleton π) y
hFecs :
Function.Bijective
(MapToEqualizer F π (pullback.fst π π) (pullback.snd π π) (_ : pullback.fst π π ≫ π = pullback.snd π π ≫ π))
fork_comp : Equalizer.forkMap F (Presieve.singleton π) ≫ (EqualizerFirstObjIso F π).hom = F.map π.op
fmap_comp :
(EqualizerFirstObjIso F π).hom ≫ F.map (pullback.fst π π).op =
Equalizer.Presieve.firstMap F (Presieve.singleton π) ≫ (EqualizerSecondObjIso F π).hom
⊢ (EqualizerFirstObjIso F π).hom ≫ F.map (pullback.snd π π).op =
Equalizer.Presieve.secondMap F (Presieve.singleton π) ≫ (EqualizerSecondObjIso F π).hom | case smap_comp
B : CompHaus
F : CompHausᵒᵖ ⥤ Type (u + 1)
hFpfp : PreservesFiniteProducts F
X : CompHaus
π : X ⟶ B
πsurj : Function.Surjective ↑π
y : Equalizer.FirstObj F (Presieve.singleton π)
h : Equalizer.Presieve.firstMap F (Presieve.singleton π) y = Equalizer.Presieve.secondMap F (Presieve.singleton π) y
hFecs :
Function.Bijective
(MapToEqualizer F π (pullback.fst π π) (pullback.snd π π) (_ : pullback.fst π π ≫ π = pullback.snd π π ≫ π))
fork_comp : Equalizer.forkMap F (Presieve.singleton π) ≫ (EqualizerFirstObjIso F π).hom = F.map π.op
fmap_comp :
(EqualizerFirstObjIso F π).hom ≫ F.map (pullback.fst π π).op =
Equalizer.Presieve.firstMap F (Presieve.singleton π) ≫ (EqualizerSecondObjIso F π).hom
⊢ (EqualizerFirstObjIso F π).hom ≫ F.map (pullback.snd π π).op =
Equalizer.Presieve.secondMap F (Presieve.singleton π) ≫
(EqualizerSecondObjIso_aux F π).hom ≫ F.map (fromExplicit π π).op | Please generate a tactic in lean4 to solve the state.
STATE:
case smap_comp
B : CompHaus
F : CompHausᵒᵖ ⥤ Type (u + 1)
hFpfp : PreservesFiniteProducts F
X : CompHaus
π : X ⟶ B
πsurj : Function.Surjective ↑π
y : Equalizer.FirstObj F (Presieve.singleton π)
h : Equalizer.Presieve.firstMap F (Presieve.singleton π) y = Equalizer.Presieve.secondMap F (Presieve.singleton π) y
hFecs :
Function.Bijective
(MapToEqualizer F π (pullback.fst π π) (pullback.snd π π) (_ : pullback.fst π π ≫ π = pullback.snd π π ≫ π))
fork_comp : Equalizer.forkMap F (Presieve.singleton π) ≫ (EqualizerFirstObjIso F π).hom = F.map π.op
fmap_comp :
(EqualizerFirstObjIso F π).hom ≫ F.map (pullback.fst π π).op =
Equalizer.Presieve.firstMap F (Presieve.singleton π) ≫ (EqualizerSecondObjIso F π).hom
⊢ (EqualizerFirstObjIso F π).hom ≫ F.map (pullback.snd π π).op =
Equalizer.Presieve.secondMap F (Presieve.singleton π) ≫ (EqualizerSecondObjIso F π).hom
TACTIC:
|
https://github.com/adamtopaz/CopenhagenMasterclass2023.git | a293ca1554f7e80d891fd4d86fb092c54d8a0a01 | CompHaus/ExplicitSheaves.lean | CompHaus.isSheafFor_of_Dagur | [277, 1] | [352, 22] | rw [CompHaus.snd_comp_fromExplicit, op_comp, Functor.map_comp] | case smap_comp
B : CompHaus
F : CompHausᵒᵖ ⥤ Type (u + 1)
hFpfp : PreservesFiniteProducts F
X : CompHaus
π : X ⟶ B
πsurj : Function.Surjective ↑π
y : Equalizer.FirstObj F (Presieve.singleton π)
h : Equalizer.Presieve.firstMap F (Presieve.singleton π) y = Equalizer.Presieve.secondMap F (Presieve.singleton π) y
hFecs :
Function.Bijective
(MapToEqualizer F π (pullback.fst π π) (pullback.snd π π) (_ : pullback.fst π π ≫ π = pullback.snd π π ≫ π))
fork_comp : Equalizer.forkMap F (Presieve.singleton π) ≫ (EqualizerFirstObjIso F π).hom = F.map π.op
fmap_comp :
(EqualizerFirstObjIso F π).hom ≫ F.map (pullback.fst π π).op =
Equalizer.Presieve.firstMap F (Presieve.singleton π) ≫ (EqualizerSecondObjIso F π).hom
⊢ (EqualizerFirstObjIso F π).hom ≫ F.map (pullback.snd π π).op =
Equalizer.Presieve.secondMap F (Presieve.singleton π) ≫
(EqualizerSecondObjIso_aux F π).hom ≫ F.map (fromExplicit π π).op | case smap_comp
B : CompHaus
F : CompHausᵒᵖ ⥤ Type (u + 1)
hFpfp : PreservesFiniteProducts F
X : CompHaus
π : X ⟶ B
πsurj : Function.Surjective ↑π
y : Equalizer.FirstObj F (Presieve.singleton π)
h : Equalizer.Presieve.firstMap F (Presieve.singleton π) y = Equalizer.Presieve.secondMap F (Presieve.singleton π) y
hFecs :
Function.Bijective
(MapToEqualizer F π (pullback.fst π π) (pullback.snd π π) (_ : pullback.fst π π ≫ π = pullback.snd π π ≫ π))
fork_comp : Equalizer.forkMap F (Presieve.singleton π) ≫ (EqualizerFirstObjIso F π).hom = F.map π.op
fmap_comp :
(EqualizerFirstObjIso F π).hom ≫ F.map (pullback.fst π π).op =
Equalizer.Presieve.firstMap F (Presieve.singleton π) ≫ (EqualizerSecondObjIso F π).hom
⊢ (EqualizerFirstObjIso F π).hom ≫ F.map Limits.pullback.snd.op ≫ F.map (fromExplicit π π).op =
Equalizer.Presieve.secondMap F (Presieve.singleton π) ≫
(EqualizerSecondObjIso_aux F π).hom ≫ F.map (fromExplicit π π).op | Please generate a tactic in lean4 to solve the state.
STATE:
case smap_comp
B : CompHaus
F : CompHausᵒᵖ ⥤ Type (u + 1)
hFpfp : PreservesFiniteProducts F
X : CompHaus
π : X ⟶ B
πsurj : Function.Surjective ↑π
y : Equalizer.FirstObj F (Presieve.singleton π)
h : Equalizer.Presieve.firstMap F (Presieve.singleton π) y = Equalizer.Presieve.secondMap F (Presieve.singleton π) y
hFecs :
Function.Bijective
(MapToEqualizer F π (pullback.fst π π) (pullback.snd π π) (_ : pullback.fst π π ≫ π = pullback.snd π π ≫ π))
fork_comp : Equalizer.forkMap F (Presieve.singleton π) ≫ (EqualizerFirstObjIso F π).hom = F.map π.op
fmap_comp :
(EqualizerFirstObjIso F π).hom ≫ F.map (pullback.fst π π).op =
Equalizer.Presieve.firstMap F (Presieve.singleton π) ≫ (EqualizerSecondObjIso F π).hom
⊢ (EqualizerFirstObjIso F π).hom ≫ F.map (pullback.snd π π).op =
Equalizer.Presieve.secondMap F (Presieve.singleton π) ≫
(EqualizerSecondObjIso_aux F π).hom ≫ F.map (fromExplicit π π).op
TACTIC:
|
https://github.com/adamtopaz/CopenhagenMasterclass2023.git | a293ca1554f7e80d891fd4d86fb092c54d8a0a01 | CompHaus/ExplicitSheaves.lean | CompHaus.isSheafFor_of_Dagur | [277, 1] | [352, 22] | suffices : (EqualizerFirstObjIso F π).hom ≫ F.map Limits.pullback.snd.op =
Equalizer.Presieve.secondMap F (Presieve.singleton π) ≫
(EqualizerSecondObjIso_aux F π).hom | case smap_comp
B : CompHaus
F : CompHausᵒᵖ ⥤ Type (u + 1)
hFpfp : PreservesFiniteProducts F
X : CompHaus
π : X ⟶ B
πsurj : Function.Surjective ↑π
y : Equalizer.FirstObj F (Presieve.singleton π)
h : Equalizer.Presieve.firstMap F (Presieve.singleton π) y = Equalizer.Presieve.secondMap F (Presieve.singleton π) y
hFecs :
Function.Bijective
(MapToEqualizer F π (pullback.fst π π) (pullback.snd π π) (_ : pullback.fst π π ≫ π = pullback.snd π π ≫ π))
fork_comp : Equalizer.forkMap F (Presieve.singleton π) ≫ (EqualizerFirstObjIso F π).hom = F.map π.op
fmap_comp :
(EqualizerFirstObjIso F π).hom ≫ F.map (pullback.fst π π).op =
Equalizer.Presieve.firstMap F (Presieve.singleton π) ≫ (EqualizerSecondObjIso F π).hom
⊢ (EqualizerFirstObjIso F π).hom ≫ F.map Limits.pullback.snd.op ≫ F.map (fromExplicit π π).op =
Equalizer.Presieve.secondMap F (Presieve.singleton π) ≫
(EqualizerSecondObjIso_aux F π).hom ≫ F.map (fromExplicit π π).op | case smap_comp
B : CompHaus
F : CompHausᵒᵖ ⥤ Type (u + 1)
hFpfp : PreservesFiniteProducts F
X : CompHaus
π : X ⟶ B
πsurj : Function.Surjective ↑π
y : Equalizer.FirstObj F (Presieve.singleton π)
h : Equalizer.Presieve.firstMap F (Presieve.singleton π) y = Equalizer.Presieve.secondMap F (Presieve.singleton π) y
hFecs :
Function.Bijective
(MapToEqualizer F π (pullback.fst π π) (pullback.snd π π) (_ : pullback.fst π π ≫ π = pullback.snd π π ≫ π))
fork_comp : Equalizer.forkMap F (Presieve.singleton π) ≫ (EqualizerFirstObjIso F π).hom = F.map π.op
fmap_comp :
(EqualizerFirstObjIso F π).hom ≫ F.map (pullback.fst π π).op =
Equalizer.Presieve.firstMap F (Presieve.singleton π) ≫ (EqualizerSecondObjIso F π).hom
this :
(EqualizerFirstObjIso F π).hom ≫ F.map Limits.pullback.snd.op =
Equalizer.Presieve.secondMap F (Presieve.singleton π) ≫ (EqualizerSecondObjIso_aux F π).hom
⊢ (EqualizerFirstObjIso F π).hom ≫ F.map Limits.pullback.snd.op ≫ F.map (fromExplicit π π).op =
Equalizer.Presieve.secondMap F (Presieve.singleton π) ≫
(EqualizerSecondObjIso_aux F π).hom ≫ F.map (fromExplicit π π).op
case this
B : CompHaus
F : CompHausᵒᵖ ⥤ Type (u + 1)
hFpfp : PreservesFiniteProducts F
X : CompHaus
π : X ⟶ B
πsurj : Function.Surjective ↑π
y : Equalizer.FirstObj F (Presieve.singleton π)
h : Equalizer.Presieve.firstMap F (Presieve.singleton π) y = Equalizer.Presieve.secondMap F (Presieve.singleton π) y
hFecs :
Function.Bijective
(MapToEqualizer F π (pullback.fst π π) (pullback.snd π π) (_ : pullback.fst π π ≫ π = pullback.snd π π ≫ π))
fork_comp : Equalizer.forkMap F (Presieve.singleton π) ≫ (EqualizerFirstObjIso F π).hom = F.map π.op
fmap_comp :
(EqualizerFirstObjIso F π).hom ≫ F.map (pullback.fst π π).op =
Equalizer.Presieve.firstMap F (Presieve.singleton π) ≫ (EqualizerSecondObjIso F π).hom
⊢ (EqualizerFirstObjIso F π).hom ≫ F.map Limits.pullback.snd.op =
Equalizer.Presieve.secondMap F (Presieve.singleton π) ≫ (EqualizerSecondObjIso_aux F π).hom | Please generate a tactic in lean4 to solve the state.
STATE:
case smap_comp
B : CompHaus
F : CompHausᵒᵖ ⥤ Type (u + 1)
hFpfp : PreservesFiniteProducts F
X : CompHaus
π : X ⟶ B
πsurj : Function.Surjective ↑π
y : Equalizer.FirstObj F (Presieve.singleton π)
h : Equalizer.Presieve.firstMap F (Presieve.singleton π) y = Equalizer.Presieve.secondMap F (Presieve.singleton π) y
hFecs :
Function.Bijective
(MapToEqualizer F π (pullback.fst π π) (pullback.snd π π) (_ : pullback.fst π π ≫ π = pullback.snd π π ≫ π))
fork_comp : Equalizer.forkMap F (Presieve.singleton π) ≫ (EqualizerFirstObjIso F π).hom = F.map π.op
fmap_comp :
(EqualizerFirstObjIso F π).hom ≫ F.map (pullback.fst π π).op =
Equalizer.Presieve.firstMap F (Presieve.singleton π) ≫ (EqualizerSecondObjIso F π).hom
⊢ (EqualizerFirstObjIso F π).hom ≫ F.map Limits.pullback.snd.op ≫ F.map (fromExplicit π π).op =
Equalizer.Presieve.secondMap F (Presieve.singleton π) ≫
(EqualizerSecondObjIso_aux F π).hom ≫ F.map (fromExplicit π π).op
TACTIC:
|
https://github.com/adamtopaz/CopenhagenMasterclass2023.git | a293ca1554f7e80d891fd4d86fb092c54d8a0a01 | CompHaus/ExplicitSheaves.lean | CompHaus.isSheafFor_of_Dagur | [277, 1] | [352, 22] | dsimp [EqualizerFirstObjIso, Equalizer.Presieve.secondMap, EqualizerSecondObjIso_aux] | case this
B : CompHaus
F : CompHausᵒᵖ ⥤ Type (u + 1)
hFpfp : PreservesFiniteProducts F
X : CompHaus
π : X ⟶ B
πsurj : Function.Surjective ↑π
y : Equalizer.FirstObj F (Presieve.singleton π)
h : Equalizer.Presieve.firstMap F (Presieve.singleton π) y = Equalizer.Presieve.secondMap F (Presieve.singleton π) y
hFecs :
Function.Bijective
(MapToEqualizer F π (pullback.fst π π) (pullback.snd π π) (_ : pullback.fst π π ≫ π = pullback.snd π π ≫ π))
fork_comp : Equalizer.forkMap F (Presieve.singleton π) ≫ (EqualizerFirstObjIso F π).hom = F.map π.op
fmap_comp :
(EqualizerFirstObjIso F π).hom ≫ F.map (pullback.fst π π).op =
Equalizer.Presieve.firstMap F (Presieve.singleton π) ≫ (EqualizerSecondObjIso F π).hom
⊢ (EqualizerFirstObjIso F π).hom ≫ F.map Limits.pullback.snd.op =
Equalizer.Presieve.secondMap F (Presieve.singleton π) ≫ (EqualizerSecondObjIso_aux F π).hom | case this
B : CompHaus
F : CompHausᵒᵖ ⥤ Type (u + 1)
hFpfp : PreservesFiniteProducts F
X : CompHaus
π : X ⟶ B
πsurj : Function.Surjective ↑π
y : Equalizer.FirstObj F (Presieve.singleton π)
h : Equalizer.Presieve.firstMap F (Presieve.singleton π) y = Equalizer.Presieve.secondMap F (Presieve.singleton π) y
hFecs :
Function.Bijective
(MapToEqualizer F π (pullback.fst π π) (pullback.snd π π) (_ : pullback.fst π π ≫ π = pullback.snd π π ≫ π))
fork_comp : Equalizer.forkMap F (Presieve.singleton π) ≫ (EqualizerFirstObjIso F π).hom = F.map π.op
fmap_comp :
(EqualizerFirstObjIso F π).hom ≫ F.map (pullback.fst π π).op =
Equalizer.Presieve.firstMap F (Presieve.singleton π) ≫ (EqualizerSecondObjIso F π).hom
⊢ ((Equalizer.firstObjEqFamily F (Presieve.singleton π)).hom ≫ fun e => e π (_ : Presieve.singleton π π)) ≫
F.map Limits.pullback.snd.op =
(Pi.lift fun x => Pi.π (fun f => F.obj f.fst.op) x.snd ≫ F.map Limits.pullback.snd.op) ≫
Pi.π (fun fg => F.obj (Limits.pullback ↑fg.fst.snd ↑fg.snd.snd).op)
({ fst := X, snd := { val := π, property := (_ : Presieve.singleton π π) } },
{ fst := X, snd := { val := π, property := (_ : Presieve.singleton π π) } }) | Please generate a tactic in lean4 to solve the state.
STATE:
case this
B : CompHaus
F : CompHausᵒᵖ ⥤ Type (u + 1)
hFpfp : PreservesFiniteProducts F
X : CompHaus
π : X ⟶ B
πsurj : Function.Surjective ↑π
y : Equalizer.FirstObj F (Presieve.singleton π)
h : Equalizer.Presieve.firstMap F (Presieve.singleton π) y = Equalizer.Presieve.secondMap F (Presieve.singleton π) y
hFecs :
Function.Bijective
(MapToEqualizer F π (pullback.fst π π) (pullback.snd π π) (_ : pullback.fst π π ≫ π = pullback.snd π π ≫ π))
fork_comp : Equalizer.forkMap F (Presieve.singleton π) ≫ (EqualizerFirstObjIso F π).hom = F.map π.op
fmap_comp :
(EqualizerFirstObjIso F π).hom ≫ F.map (pullback.fst π π).op =
Equalizer.Presieve.firstMap F (Presieve.singleton π) ≫ (EqualizerSecondObjIso F π).hom
⊢ (EqualizerFirstObjIso F π).hom ≫ F.map Limits.pullback.snd.op =
Equalizer.Presieve.secondMap F (Presieve.singleton π) ≫ (EqualizerSecondObjIso_aux F π).hom
TACTIC:
|
https://github.com/adamtopaz/CopenhagenMasterclass2023.git | a293ca1554f7e80d891fd4d86fb092c54d8a0a01 | CompHaus/ExplicitSheaves.lean | CompHaus.isSheafFor_of_Dagur | [277, 1] | [352, 22] | ext b | case this
B : CompHaus
F : CompHausᵒᵖ ⥤ Type (u + 1)
hFpfp : PreservesFiniteProducts F
X : CompHaus
π : X ⟶ B
πsurj : Function.Surjective ↑π
y : Equalizer.FirstObj F (Presieve.singleton π)
h : Equalizer.Presieve.firstMap F (Presieve.singleton π) y = Equalizer.Presieve.secondMap F (Presieve.singleton π) y
hFecs :
Function.Bijective
(MapToEqualizer F π (pullback.fst π π) (pullback.snd π π) (_ : pullback.fst π π ≫ π = pullback.snd π π ≫ π))
fork_comp : Equalizer.forkMap F (Presieve.singleton π) ≫ (EqualizerFirstObjIso F π).hom = F.map π.op
fmap_comp :
(EqualizerFirstObjIso F π).hom ≫ F.map (pullback.fst π π).op =
Equalizer.Presieve.firstMap F (Presieve.singleton π) ≫ (EqualizerSecondObjIso F π).hom
⊢ ((Equalizer.firstObjEqFamily F (Presieve.singleton π)).hom ≫ fun e => e π (_ : Presieve.singleton π π)) ≫
F.map Limits.pullback.snd.op =
(Pi.lift fun x => Pi.π (fun f => F.obj f.fst.op) x.snd ≫ F.map Limits.pullback.snd.op) ≫
Pi.π (fun fg => F.obj (Limits.pullback ↑fg.fst.snd ↑fg.snd.snd).op)
({ fst := X, snd := { val := π, property := (_ : Presieve.singleton π π) } },
{ fst := X, snd := { val := π, property := (_ : Presieve.singleton π π) } }) | case this.h
B : CompHaus
F : CompHausᵒᵖ ⥤ Type (u + 1)
hFpfp : PreservesFiniteProducts F
X : CompHaus
π : X ⟶ B
πsurj : Function.Surjective ↑π
y : Equalizer.FirstObj F (Presieve.singleton π)
h : Equalizer.Presieve.firstMap F (Presieve.singleton π) y = Equalizer.Presieve.secondMap F (Presieve.singleton π) y
hFecs :
Function.Bijective
(MapToEqualizer F π (pullback.fst π π) (pullback.snd π π) (_ : pullback.fst π π ≫ π = pullback.snd π π ≫ π))
fork_comp : Equalizer.forkMap F (Presieve.singleton π) ≫ (EqualizerFirstObjIso F π).hom = F.map π.op
fmap_comp :
(EqualizerFirstObjIso F π).hom ≫ F.map (pullback.fst π π).op =
Equalizer.Presieve.firstMap F (Presieve.singleton π) ≫ (EqualizerSecondObjIso F π).hom
b : Equalizer.FirstObj F (Presieve.singleton π)
⊢ (((Equalizer.firstObjEqFamily F (Presieve.singleton π)).hom ≫ fun e => e π (_ : Presieve.singleton π π)) ≫
F.map Limits.pullback.snd.op)
b =
((Pi.lift fun x => Pi.π (fun f => F.obj f.fst.op) x.snd ≫ F.map Limits.pullback.snd.op) ≫
Pi.π (fun fg => F.obj (Limits.pullback ↑fg.fst.snd ↑fg.snd.snd).op)
({ fst := X, snd := { val := π, property := (_ : Presieve.singleton π π) } },
{ fst := X, snd := { val := π, property := (_ : Presieve.singleton π π) } }))
b | Please generate a tactic in lean4 to solve the state.
STATE:
case this
B : CompHaus
F : CompHausᵒᵖ ⥤ Type (u + 1)
hFpfp : PreservesFiniteProducts F
X : CompHaus
π : X ⟶ B
πsurj : Function.Surjective ↑π
y : Equalizer.FirstObj F (Presieve.singleton π)
h : Equalizer.Presieve.firstMap F (Presieve.singleton π) y = Equalizer.Presieve.secondMap F (Presieve.singleton π) y
hFecs :
Function.Bijective
(MapToEqualizer F π (pullback.fst π π) (pullback.snd π π) (_ : pullback.fst π π ≫ π = pullback.snd π π ≫ π))
fork_comp : Equalizer.forkMap F (Presieve.singleton π) ≫ (EqualizerFirstObjIso F π).hom = F.map π.op
fmap_comp :
(EqualizerFirstObjIso F π).hom ≫ F.map (pullback.fst π π).op =
Equalizer.Presieve.firstMap F (Presieve.singleton π) ≫ (EqualizerSecondObjIso F π).hom
⊢ ((Equalizer.firstObjEqFamily F (Presieve.singleton π)).hom ≫ fun e => e π (_ : Presieve.singleton π π)) ≫
F.map Limits.pullback.snd.op =
(Pi.lift fun x => Pi.π (fun f => F.obj f.fst.op) x.snd ≫ F.map Limits.pullback.snd.op) ≫
Pi.π (fun fg => F.obj (Limits.pullback ↑fg.fst.snd ↑fg.snd.snd).op)
({ fst := X, snd := { val := π, property := (_ : Presieve.singleton π π) } },
{ fst := X, snd := { val := π, property := (_ : Presieve.singleton π π) } })
TACTIC:
|
https://github.com/adamtopaz/CopenhagenMasterclass2023.git | a293ca1554f7e80d891fd4d86fb092c54d8a0a01 | CompHaus/ExplicitSheaves.lean | CompHaus.isSheafFor_of_Dagur | [277, 1] | [352, 22] | simp only [types_comp_apply, Equalizer.firstObjEqFamily_hom, Types.pi_lift_π_apply] | case this.h
B : CompHaus
F : CompHausᵒᵖ ⥤ Type (u + 1)
hFpfp : PreservesFiniteProducts F
X : CompHaus
π : X ⟶ B
πsurj : Function.Surjective ↑π
y : Equalizer.FirstObj F (Presieve.singleton π)
h : Equalizer.Presieve.firstMap F (Presieve.singleton π) y = Equalizer.Presieve.secondMap F (Presieve.singleton π) y
hFecs :
Function.Bijective
(MapToEqualizer F π (pullback.fst π π) (pullback.snd π π) (_ : pullback.fst π π ≫ π = pullback.snd π π ≫ π))
fork_comp : Equalizer.forkMap F (Presieve.singleton π) ≫ (EqualizerFirstObjIso F π).hom = F.map π.op
fmap_comp :
(EqualizerFirstObjIso F π).hom ≫ F.map (pullback.fst π π).op =
Equalizer.Presieve.firstMap F (Presieve.singleton π) ≫ (EqualizerSecondObjIso F π).hom
b : Equalizer.FirstObj F (Presieve.singleton π)
⊢ (((Equalizer.firstObjEqFamily F (Presieve.singleton π)).hom ≫ fun e => e π (_ : Presieve.singleton π π)) ≫
F.map Limits.pullback.snd.op)
b =
((Pi.lift fun x => Pi.π (fun f => F.obj f.fst.op) x.snd ≫ F.map Limits.pullback.snd.op) ≫
Pi.π (fun fg => F.obj (Limits.pullback ↑fg.fst.snd ↑fg.snd.snd).op)
({ fst := X, snd := { val := π, property := (_ : Presieve.singleton π π) } },
{ fst := X, snd := { val := π, property := (_ : Presieve.singleton π π) } }))
b | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case this.h
B : CompHaus
F : CompHausᵒᵖ ⥤ Type (u + 1)
hFpfp : PreservesFiniteProducts F
X : CompHaus
π : X ⟶ B
πsurj : Function.Surjective ↑π
y : Equalizer.FirstObj F (Presieve.singleton π)
h : Equalizer.Presieve.firstMap F (Presieve.singleton π) y = Equalizer.Presieve.secondMap F (Presieve.singleton π) y
hFecs :
Function.Bijective
(MapToEqualizer F π (pullback.fst π π) (pullback.snd π π) (_ : pullback.fst π π ≫ π = pullback.snd π π ≫ π))
fork_comp : Equalizer.forkMap F (Presieve.singleton π) ≫ (EqualizerFirstObjIso F π).hom = F.map π.op
fmap_comp :
(EqualizerFirstObjIso F π).hom ≫ F.map (pullback.fst π π).op =
Equalizer.Presieve.firstMap F (Presieve.singleton π) ≫ (EqualizerSecondObjIso F π).hom
b : Equalizer.FirstObj F (Presieve.singleton π)
⊢ (((Equalizer.firstObjEqFamily F (Presieve.singleton π)).hom ≫ fun e => e π (_ : Presieve.singleton π π)) ≫
F.map Limits.pullback.snd.op)
b =
((Pi.lift fun x => Pi.π (fun f => F.obj f.fst.op) x.snd ≫ F.map Limits.pullback.snd.op) ≫
Pi.π (fun fg => F.obj (Limits.pullback ↑fg.fst.snd ↑fg.snd.snd).op)
({ fst := X, snd := { val := π, property := (_ : Presieve.singleton π π) } },
{ fst := X, snd := { val := π, property := (_ : Presieve.singleton π π) } }))
b
TACTIC:
|
https://github.com/adamtopaz/CopenhagenMasterclass2023.git | a293ca1554f7e80d891fd4d86fb092c54d8a0a01 | CompHaus/ExplicitSheaves.lean | CompHaus.isSheafFor_of_Dagur | [277, 1] | [352, 22] | simp only [← Category.assoc] | case smap_comp
B : CompHaus
F : CompHausᵒᵖ ⥤ Type (u + 1)
hFpfp : PreservesFiniteProducts F
X : CompHaus
π : X ⟶ B
πsurj : Function.Surjective ↑π
y : Equalizer.FirstObj F (Presieve.singleton π)
h : Equalizer.Presieve.firstMap F (Presieve.singleton π) y = Equalizer.Presieve.secondMap F (Presieve.singleton π) y
hFecs :
Function.Bijective
(MapToEqualizer F π (pullback.fst π π) (pullback.snd π π) (_ : pullback.fst π π ≫ π = pullback.snd π π ≫ π))
fork_comp : Equalizer.forkMap F (Presieve.singleton π) ≫ (EqualizerFirstObjIso F π).hom = F.map π.op
fmap_comp :
(EqualizerFirstObjIso F π).hom ≫ F.map (pullback.fst π π).op =
Equalizer.Presieve.firstMap F (Presieve.singleton π) ≫ (EqualizerSecondObjIso F π).hom
this :
(EqualizerFirstObjIso F π).hom ≫ F.map Limits.pullback.snd.op =
Equalizer.Presieve.secondMap F (Presieve.singleton π) ≫ (EqualizerSecondObjIso_aux F π).hom
⊢ (EqualizerFirstObjIso F π).hom ≫ F.map Limits.pullback.snd.op ≫ F.map (fromExplicit π π).op =
Equalizer.Presieve.secondMap F (Presieve.singleton π) ≫
(EqualizerSecondObjIso_aux F π).hom ≫ F.map (fromExplicit π π).op | case smap_comp
B : CompHaus
F : CompHausᵒᵖ ⥤ Type (u + 1)
hFpfp : PreservesFiniteProducts F
X : CompHaus
π : X ⟶ B
πsurj : Function.Surjective ↑π
y : Equalizer.FirstObj F (Presieve.singleton π)
h : Equalizer.Presieve.firstMap F (Presieve.singleton π) y = Equalizer.Presieve.secondMap F (Presieve.singleton π) y
hFecs :
Function.Bijective
(MapToEqualizer F π (pullback.fst π π) (pullback.snd π π) (_ : pullback.fst π π ≫ π = pullback.snd π π ≫ π))
fork_comp : Equalizer.forkMap F (Presieve.singleton π) ≫ (EqualizerFirstObjIso F π).hom = F.map π.op
fmap_comp :
(EqualizerFirstObjIso F π).hom ≫ F.map (pullback.fst π π).op =
Equalizer.Presieve.firstMap F (Presieve.singleton π) ≫ (EqualizerSecondObjIso F π).hom
this :
(EqualizerFirstObjIso F π).hom ≫ F.map Limits.pullback.snd.op =
Equalizer.Presieve.secondMap F (Presieve.singleton π) ≫ (EqualizerSecondObjIso_aux F π).hom
⊢ ((EqualizerFirstObjIso F π).hom ≫ F.map Limits.pullback.snd.op) ≫ F.map (fromExplicit π π).op =
(Equalizer.Presieve.secondMap F (Presieve.singleton π) ≫ (EqualizerSecondObjIso_aux F π).hom) ≫
F.map (fromExplicit π π).op | Please generate a tactic in lean4 to solve the state.
STATE:
case smap_comp
B : CompHaus
F : CompHausᵒᵖ ⥤ Type (u + 1)
hFpfp : PreservesFiniteProducts F
X : CompHaus
π : X ⟶ B
πsurj : Function.Surjective ↑π
y : Equalizer.FirstObj F (Presieve.singleton π)
h : Equalizer.Presieve.firstMap F (Presieve.singleton π) y = Equalizer.Presieve.secondMap F (Presieve.singleton π) y
hFecs :
Function.Bijective
(MapToEqualizer F π (pullback.fst π π) (pullback.snd π π) (_ : pullback.fst π π ≫ π = pullback.snd π π ≫ π))
fork_comp : Equalizer.forkMap F (Presieve.singleton π) ≫ (EqualizerFirstObjIso F π).hom = F.map π.op
fmap_comp :
(EqualizerFirstObjIso F π).hom ≫ F.map (pullback.fst π π).op =
Equalizer.Presieve.firstMap F (Presieve.singleton π) ≫ (EqualizerSecondObjIso F π).hom
this :
(EqualizerFirstObjIso F π).hom ≫ F.map Limits.pullback.snd.op =
Equalizer.Presieve.secondMap F (Presieve.singleton π) ≫ (EqualizerSecondObjIso_aux F π).hom
⊢ (EqualizerFirstObjIso F π).hom ≫ F.map Limits.pullback.snd.op ≫ F.map (fromExplicit π π).op =
Equalizer.Presieve.secondMap F (Presieve.singleton π) ≫
(EqualizerSecondObjIso_aux F π).hom ≫ F.map (fromExplicit π π).op
TACTIC:
|
https://github.com/adamtopaz/CopenhagenMasterclass2023.git | a293ca1554f7e80d891fd4d86fb092c54d8a0a01 | CompHaus/ExplicitSheaves.lean | CompHaus.isSheafFor_of_Dagur | [277, 1] | [352, 22] | rw [this] | case smap_comp
B : CompHaus
F : CompHausᵒᵖ ⥤ Type (u + 1)
hFpfp : PreservesFiniteProducts F
X : CompHaus
π : X ⟶ B
πsurj : Function.Surjective ↑π
y : Equalizer.FirstObj F (Presieve.singleton π)
h : Equalizer.Presieve.firstMap F (Presieve.singleton π) y = Equalizer.Presieve.secondMap F (Presieve.singleton π) y
hFecs :
Function.Bijective
(MapToEqualizer F π (pullback.fst π π) (pullback.snd π π) (_ : pullback.fst π π ≫ π = pullback.snd π π ≫ π))
fork_comp : Equalizer.forkMap F (Presieve.singleton π) ≫ (EqualizerFirstObjIso F π).hom = F.map π.op
fmap_comp :
(EqualizerFirstObjIso F π).hom ≫ F.map (pullback.fst π π).op =
Equalizer.Presieve.firstMap F (Presieve.singleton π) ≫ (EqualizerSecondObjIso F π).hom
this :
(EqualizerFirstObjIso F π).hom ≫ F.map Limits.pullback.snd.op =
Equalizer.Presieve.secondMap F (Presieve.singleton π) ≫ (EqualizerSecondObjIso_aux F π).hom
⊢ ((EqualizerFirstObjIso F π).hom ≫ F.map Limits.pullback.snd.op) ≫ F.map (fromExplicit π π).op =
(Equalizer.Presieve.secondMap F (Presieve.singleton π) ≫ (EqualizerSecondObjIso_aux F π).hom) ≫
F.map (fromExplicit π π).op | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case smap_comp
B : CompHaus
F : CompHausᵒᵖ ⥤ Type (u + 1)
hFpfp : PreservesFiniteProducts F
X : CompHaus
π : X ⟶ B
πsurj : Function.Surjective ↑π
y : Equalizer.FirstObj F (Presieve.singleton π)
h : Equalizer.Presieve.firstMap F (Presieve.singleton π) y = Equalizer.Presieve.secondMap F (Presieve.singleton π) y
hFecs :
Function.Bijective
(MapToEqualizer F π (pullback.fst π π) (pullback.snd π π) (_ : pullback.fst π π ≫ π = pullback.snd π π ≫ π))
fork_comp : Equalizer.forkMap F (Presieve.singleton π) ≫ (EqualizerFirstObjIso F π).hom = F.map π.op
fmap_comp :
(EqualizerFirstObjIso F π).hom ≫ F.map (pullback.fst π π).op =
Equalizer.Presieve.firstMap F (Presieve.singleton π) ≫ (EqualizerSecondObjIso F π).hom
this :
(EqualizerFirstObjIso F π).hom ≫ F.map Limits.pullback.snd.op =
Equalizer.Presieve.secondMap F (Presieve.singleton π) ≫ (EqualizerSecondObjIso_aux F π).hom
⊢ ((EqualizerFirstObjIso F π).hom ≫ F.map Limits.pullback.snd.op) ≫ F.map (fromExplicit π π).op =
(Equalizer.Presieve.secondMap F (Presieve.singleton π) ≫ (EqualizerSecondObjIso_aux F π).hom) ≫
F.map (fromExplicit π π).op
TACTIC:
|
https://github.com/adamtopaz/CopenhagenMasterclass2023.git | a293ca1554f7e80d891fd4d86fb092c54d8a0a01 | CompHaus/ExplicitSheaves.lean | CompHaus.isSheafFor_of_Dagur | [277, 1] | [352, 22] | change ((EqualizerFirstObjIso F π).hom ≫ _) y = _ | case iy_mem
B : CompHaus
F : CompHausᵒᵖ ⥤ Type (u + 1)
hFpfp : PreservesFiniteProducts F
X : CompHaus
π : X ⟶ B
πsurj : Function.Surjective ↑π
y : Equalizer.FirstObj F (Presieve.singleton π)
h : Equalizer.Presieve.firstMap F (Presieve.singleton π) y = Equalizer.Presieve.secondMap F (Presieve.singleton π) y
hFecs :
Function.Bijective
(MapToEqualizer F π (pullback.fst π π) (pullback.snd π π) (_ : pullback.fst π π ≫ π = pullback.snd π π ≫ π))
fork_comp : Equalizer.forkMap F (Presieve.singleton π) ≫ (EqualizerFirstObjIso F π).hom = F.map π.op
fmap_comp :
(EqualizerFirstObjIso F π).hom ≫ F.map (pullback.fst π π).op =
Equalizer.Presieve.firstMap F (Presieve.singleton π) ≫ (EqualizerSecondObjIso F π).hom
smap_comp :
(EqualizerFirstObjIso F π).hom ≫ F.map (pullback.snd π π).op =
Equalizer.Presieve.secondMap F (Presieve.singleton π) ≫ (EqualizerSecondObjIso F π).hom
⊢ F.map (pullback.fst π π).op ((EqualizerFirstObjIso F π).hom y) =
F.map (pullback.snd π π).op ((EqualizerFirstObjIso F π).hom y) | case iy_mem
B : CompHaus
F : CompHausᵒᵖ ⥤ Type (u + 1)
hFpfp : PreservesFiniteProducts F
X : CompHaus
π : X ⟶ B
πsurj : Function.Surjective ↑π
y : Equalizer.FirstObj F (Presieve.singleton π)
h : Equalizer.Presieve.firstMap F (Presieve.singleton π) y = Equalizer.Presieve.secondMap F (Presieve.singleton π) y
hFecs :
Function.Bijective
(MapToEqualizer F π (pullback.fst π π) (pullback.snd π π) (_ : pullback.fst π π ≫ π = pullback.snd π π ≫ π))
fork_comp : Equalizer.forkMap F (Presieve.singleton π) ≫ (EqualizerFirstObjIso F π).hom = F.map π.op
fmap_comp :
(EqualizerFirstObjIso F π).hom ≫ F.map (pullback.fst π π).op =
Equalizer.Presieve.firstMap F (Presieve.singleton π) ≫ (EqualizerSecondObjIso F π).hom
smap_comp :
(EqualizerFirstObjIso F π).hom ≫ F.map (pullback.snd π π).op =
Equalizer.Presieve.secondMap F (Presieve.singleton π) ≫ (EqualizerSecondObjIso F π).hom
⊢ ((EqualizerFirstObjIso F π).hom ≫ F.toPrefunctor.2 (pullback.fst π π).op) y =
F.map (pullback.snd π π).op ((EqualizerFirstObjIso F π).hom y) | Please generate a tactic in lean4 to solve the state.
STATE:
case iy_mem
B : CompHaus
F : CompHausᵒᵖ ⥤ Type (u + 1)
hFpfp : PreservesFiniteProducts F
X : CompHaus
π : X ⟶ B
πsurj : Function.Surjective ↑π
y : Equalizer.FirstObj F (Presieve.singleton π)
h : Equalizer.Presieve.firstMap F (Presieve.singleton π) y = Equalizer.Presieve.secondMap F (Presieve.singleton π) y
hFecs :
Function.Bijective
(MapToEqualizer F π (pullback.fst π π) (pullback.snd π π) (_ : pullback.fst π π ≫ π = pullback.snd π π ≫ π))
fork_comp : Equalizer.forkMap F (Presieve.singleton π) ≫ (EqualizerFirstObjIso F π).hom = F.map π.op
fmap_comp :
(EqualizerFirstObjIso F π).hom ≫ F.map (pullback.fst π π).op =
Equalizer.Presieve.firstMap F (Presieve.singleton π) ≫ (EqualizerSecondObjIso F π).hom
smap_comp :
(EqualizerFirstObjIso F π).hom ≫ F.map (pullback.snd π π).op =
Equalizer.Presieve.secondMap F (Presieve.singleton π) ≫ (EqualizerSecondObjIso F π).hom
⊢ F.map (pullback.fst π π).op ((EqualizerFirstObjIso F π).hom y) =
F.map (pullback.snd π π).op ((EqualizerFirstObjIso F π).hom y)
TACTIC:
|
https://github.com/adamtopaz/CopenhagenMasterclass2023.git | a293ca1554f7e80d891fd4d86fb092c54d8a0a01 | CompHaus/ExplicitSheaves.lean | CompHaus.isSheafFor_of_Dagur | [277, 1] | [352, 22] | apply Eq.symm | case iy_mem
B : CompHaus
F : CompHausᵒᵖ ⥤ Type (u + 1)
hFpfp : PreservesFiniteProducts F
X : CompHaus
π : X ⟶ B
πsurj : Function.Surjective ↑π
y : Equalizer.FirstObj F (Presieve.singleton π)
h : Equalizer.Presieve.firstMap F (Presieve.singleton π) y = Equalizer.Presieve.secondMap F (Presieve.singleton π) y
hFecs :
Function.Bijective
(MapToEqualizer F π (pullback.fst π π) (pullback.snd π π) (_ : pullback.fst π π ≫ π = pullback.snd π π ≫ π))
fork_comp : Equalizer.forkMap F (Presieve.singleton π) ≫ (EqualizerFirstObjIso F π).hom = F.map π.op
fmap_comp :
(EqualizerFirstObjIso F π).hom ≫ F.map (pullback.fst π π).op =
Equalizer.Presieve.firstMap F (Presieve.singleton π) ≫ (EqualizerSecondObjIso F π).hom
smap_comp :
(EqualizerFirstObjIso F π).hom ≫ F.map (pullback.snd π π).op =
Equalizer.Presieve.secondMap F (Presieve.singleton π) ≫ (EqualizerSecondObjIso F π).hom
⊢ ((EqualizerFirstObjIso F π).hom ≫ F.toPrefunctor.2 (pullback.fst π π).op) y =
F.map (pullback.snd π π).op ((EqualizerFirstObjIso F π).hom y) | case iy_mem.h
B : CompHaus
F : CompHausᵒᵖ ⥤ Type (u + 1)
hFpfp : PreservesFiniteProducts F
X : CompHaus
π : X ⟶ B
πsurj : Function.Surjective ↑π
y : Equalizer.FirstObj F (Presieve.singleton π)
h : Equalizer.Presieve.firstMap F (Presieve.singleton π) y = Equalizer.Presieve.secondMap F (Presieve.singleton π) y
hFecs :
Function.Bijective
(MapToEqualizer F π (pullback.fst π π) (pullback.snd π π) (_ : pullback.fst π π ≫ π = pullback.snd π π ≫ π))
fork_comp : Equalizer.forkMap F (Presieve.singleton π) ≫ (EqualizerFirstObjIso F π).hom = F.map π.op
fmap_comp :
(EqualizerFirstObjIso F π).hom ≫ F.map (pullback.fst π π).op =
Equalizer.Presieve.firstMap F (Presieve.singleton π) ≫ (EqualizerSecondObjIso F π).hom
smap_comp :
(EqualizerFirstObjIso F π).hom ≫ F.map (pullback.snd π π).op =
Equalizer.Presieve.secondMap F (Presieve.singleton π) ≫ (EqualizerSecondObjIso F π).hom
⊢ F.map (pullback.snd π π).op ((EqualizerFirstObjIso F π).hom y) =
((EqualizerFirstObjIso F π).hom ≫ F.toPrefunctor.2 (pullback.fst π π).op) y | Please generate a tactic in lean4 to solve the state.
STATE:
case iy_mem
B : CompHaus
F : CompHausᵒᵖ ⥤ Type (u + 1)
hFpfp : PreservesFiniteProducts F
X : CompHaus
π : X ⟶ B
πsurj : Function.Surjective ↑π
y : Equalizer.FirstObj F (Presieve.singleton π)
h : Equalizer.Presieve.firstMap F (Presieve.singleton π) y = Equalizer.Presieve.secondMap F (Presieve.singleton π) y
hFecs :
Function.Bijective
(MapToEqualizer F π (pullback.fst π π) (pullback.snd π π) (_ : pullback.fst π π ≫ π = pullback.snd π π ≫ π))
fork_comp : Equalizer.forkMap F (Presieve.singleton π) ≫ (EqualizerFirstObjIso F π).hom = F.map π.op
fmap_comp :
(EqualizerFirstObjIso F π).hom ≫ F.map (pullback.fst π π).op =
Equalizer.Presieve.firstMap F (Presieve.singleton π) ≫ (EqualizerSecondObjIso F π).hom
smap_comp :
(EqualizerFirstObjIso F π).hom ≫ F.map (pullback.snd π π).op =
Equalizer.Presieve.secondMap F (Presieve.singleton π) ≫ (EqualizerSecondObjIso F π).hom
⊢ ((EqualizerFirstObjIso F π).hom ≫ F.toPrefunctor.2 (pullback.fst π π).op) y =
F.map (pullback.snd π π).op ((EqualizerFirstObjIso F π).hom y)
TACTIC:
|
https://github.com/adamtopaz/CopenhagenMasterclass2023.git | a293ca1554f7e80d891fd4d86fb092c54d8a0a01 | CompHaus/ExplicitSheaves.lean | CompHaus.isSheafFor_of_Dagur | [277, 1] | [352, 22] | change ((EqualizerFirstObjIso F π).hom ≫ _) y = _ | case iy_mem.h
B : CompHaus
F : CompHausᵒᵖ ⥤ Type (u + 1)
hFpfp : PreservesFiniteProducts F
X : CompHaus
π : X ⟶ B
πsurj : Function.Surjective ↑π
y : Equalizer.FirstObj F (Presieve.singleton π)
h : Equalizer.Presieve.firstMap F (Presieve.singleton π) y = Equalizer.Presieve.secondMap F (Presieve.singleton π) y
hFecs :
Function.Bijective
(MapToEqualizer F π (pullback.fst π π) (pullback.snd π π) (_ : pullback.fst π π ≫ π = pullback.snd π π ≫ π))
fork_comp : Equalizer.forkMap F (Presieve.singleton π) ≫ (EqualizerFirstObjIso F π).hom = F.map π.op
fmap_comp :
(EqualizerFirstObjIso F π).hom ≫ F.map (pullback.fst π π).op =
Equalizer.Presieve.firstMap F (Presieve.singleton π) ≫ (EqualizerSecondObjIso F π).hom
smap_comp :
(EqualizerFirstObjIso F π).hom ≫ F.map (pullback.snd π π).op =
Equalizer.Presieve.secondMap F (Presieve.singleton π) ≫ (EqualizerSecondObjIso F π).hom
⊢ F.map (pullback.snd π π).op ((EqualizerFirstObjIso F π).hom y) =
((EqualizerFirstObjIso F π).hom ≫ F.toPrefunctor.2 (pullback.fst π π).op) y | case iy_mem.h
B : CompHaus
F : CompHausᵒᵖ ⥤ Type (u + 1)
hFpfp : PreservesFiniteProducts F
X : CompHaus
π : X ⟶ B
πsurj : Function.Surjective ↑π
y : Equalizer.FirstObj F (Presieve.singleton π)
h : Equalizer.Presieve.firstMap F (Presieve.singleton π) y = Equalizer.Presieve.secondMap F (Presieve.singleton π) y
hFecs :
Function.Bijective
(MapToEqualizer F π (pullback.fst π π) (pullback.snd π π) (_ : pullback.fst π π ≫ π = pullback.snd π π ≫ π))
fork_comp : Equalizer.forkMap F (Presieve.singleton π) ≫ (EqualizerFirstObjIso F π).hom = F.map π.op
fmap_comp :
(EqualizerFirstObjIso F π).hom ≫ F.map (pullback.fst π π).op =
Equalizer.Presieve.firstMap F (Presieve.singleton π) ≫ (EqualizerSecondObjIso F π).hom
smap_comp :
(EqualizerFirstObjIso F π).hom ≫ F.map (pullback.snd π π).op =
Equalizer.Presieve.secondMap F (Presieve.singleton π) ≫ (EqualizerSecondObjIso F π).hom
⊢ ((EqualizerFirstObjIso F π).hom ≫ F.toPrefunctor.2 (pullback.snd π π).op) y =
((EqualizerFirstObjIso F π).hom ≫ F.toPrefunctor.2 (pullback.fst π π).op) y | Please generate a tactic in lean4 to solve the state.
STATE:
case iy_mem.h
B : CompHaus
F : CompHausᵒᵖ ⥤ Type (u + 1)
hFpfp : PreservesFiniteProducts F
X : CompHaus
π : X ⟶ B
πsurj : Function.Surjective ↑π
y : Equalizer.FirstObj F (Presieve.singleton π)
h : Equalizer.Presieve.firstMap F (Presieve.singleton π) y = Equalizer.Presieve.secondMap F (Presieve.singleton π) y
hFecs :
Function.Bijective
(MapToEqualizer F π (pullback.fst π π) (pullback.snd π π) (_ : pullback.fst π π ≫ π = pullback.snd π π ≫ π))
fork_comp : Equalizer.forkMap F (Presieve.singleton π) ≫ (EqualizerFirstObjIso F π).hom = F.map π.op
fmap_comp :
(EqualizerFirstObjIso F π).hom ≫ F.map (pullback.fst π π).op =
Equalizer.Presieve.firstMap F (Presieve.singleton π) ≫ (EqualizerSecondObjIso F π).hom
smap_comp :
(EqualizerFirstObjIso F π).hom ≫ F.map (pullback.snd π π).op =
Equalizer.Presieve.secondMap F (Presieve.singleton π) ≫ (EqualizerSecondObjIso F π).hom
⊢ F.map (pullback.snd π π).op ((EqualizerFirstObjIso F π).hom y) =
((EqualizerFirstObjIso F π).hom ≫ F.toPrefunctor.2 (pullback.fst π π).op) y
TACTIC:
|
https://github.com/adamtopaz/CopenhagenMasterclass2023.git | a293ca1554f7e80d891fd4d86fb092c54d8a0a01 | CompHaus/ExplicitSheaves.lean | CompHaus.isSheafFor_of_Dagur | [277, 1] | [352, 22] | rw [fmap_comp, smap_comp] | case iy_mem.h
B : CompHaus
F : CompHausᵒᵖ ⥤ Type (u + 1)
hFpfp : PreservesFiniteProducts F
X : CompHaus
π : X ⟶ B
πsurj : Function.Surjective ↑π
y : Equalizer.FirstObj F (Presieve.singleton π)
h : Equalizer.Presieve.firstMap F (Presieve.singleton π) y = Equalizer.Presieve.secondMap F (Presieve.singleton π) y
hFecs :
Function.Bijective
(MapToEqualizer F π (pullback.fst π π) (pullback.snd π π) (_ : pullback.fst π π ≫ π = pullback.snd π π ≫ π))
fork_comp : Equalizer.forkMap F (Presieve.singleton π) ≫ (EqualizerFirstObjIso F π).hom = F.map π.op
fmap_comp :
(EqualizerFirstObjIso F π).hom ≫ F.map (pullback.fst π π).op =
Equalizer.Presieve.firstMap F (Presieve.singleton π) ≫ (EqualizerSecondObjIso F π).hom
smap_comp :
(EqualizerFirstObjIso F π).hom ≫ F.map (pullback.snd π π).op =
Equalizer.Presieve.secondMap F (Presieve.singleton π) ≫ (EqualizerSecondObjIso F π).hom
⊢ ((EqualizerFirstObjIso F π).hom ≫ F.toPrefunctor.2 (pullback.snd π π).op) y =
((EqualizerFirstObjIso F π).hom ≫ F.toPrefunctor.2 (pullback.fst π π).op) y | case iy_mem.h
B : CompHaus
F : CompHausᵒᵖ ⥤ Type (u + 1)
hFpfp : PreservesFiniteProducts F
X : CompHaus
π : X ⟶ B
πsurj : Function.Surjective ↑π
y : Equalizer.FirstObj F (Presieve.singleton π)
h : Equalizer.Presieve.firstMap F (Presieve.singleton π) y = Equalizer.Presieve.secondMap F (Presieve.singleton π) y
hFecs :
Function.Bijective
(MapToEqualizer F π (pullback.fst π π) (pullback.snd π π) (_ : pullback.fst π π ≫ π = pullback.snd π π ≫ π))
fork_comp : Equalizer.forkMap F (Presieve.singleton π) ≫ (EqualizerFirstObjIso F π).hom = F.map π.op
fmap_comp :
(EqualizerFirstObjIso F π).hom ≫ F.map (pullback.fst π π).op =
Equalizer.Presieve.firstMap F (Presieve.singleton π) ≫ (EqualizerSecondObjIso F π).hom
smap_comp :
(EqualizerFirstObjIso F π).hom ≫ F.map (pullback.snd π π).op =
Equalizer.Presieve.secondMap F (Presieve.singleton π) ≫ (EqualizerSecondObjIso F π).hom
⊢ (Equalizer.Presieve.secondMap F (Presieve.singleton π) ≫ (EqualizerSecondObjIso F π).hom) y =
(Equalizer.Presieve.firstMap F (Presieve.singleton π) ≫ (EqualizerSecondObjIso F π).hom) y | Please generate a tactic in lean4 to solve the state.
STATE:
case iy_mem.h
B : CompHaus
F : CompHausᵒᵖ ⥤ Type (u + 1)
hFpfp : PreservesFiniteProducts F
X : CompHaus
π : X ⟶ B
πsurj : Function.Surjective ↑π
y : Equalizer.FirstObj F (Presieve.singleton π)
h : Equalizer.Presieve.firstMap F (Presieve.singleton π) y = Equalizer.Presieve.secondMap F (Presieve.singleton π) y
hFecs :
Function.Bijective
(MapToEqualizer F π (pullback.fst π π) (pullback.snd π π) (_ : pullback.fst π π ≫ π = pullback.snd π π ≫ π))
fork_comp : Equalizer.forkMap F (Presieve.singleton π) ≫ (EqualizerFirstObjIso F π).hom = F.map π.op
fmap_comp :
(EqualizerFirstObjIso F π).hom ≫ F.map (pullback.fst π π).op =
Equalizer.Presieve.firstMap F (Presieve.singleton π) ≫ (EqualizerSecondObjIso F π).hom
smap_comp :
(EqualizerFirstObjIso F π).hom ≫ F.map (pullback.snd π π).op =
Equalizer.Presieve.secondMap F (Presieve.singleton π) ≫ (EqualizerSecondObjIso F π).hom
⊢ ((EqualizerFirstObjIso F π).hom ≫ F.toPrefunctor.2 (pullback.snd π π).op) y =
((EqualizerFirstObjIso F π).hom ≫ F.toPrefunctor.2 (pullback.fst π π).op) y
TACTIC:
|
https://github.com/adamtopaz/CopenhagenMasterclass2023.git | a293ca1554f7e80d891fd4d86fb092c54d8a0a01 | CompHaus/ExplicitSheaves.lean | CompHaus.isSheafFor_of_Dagur | [277, 1] | [352, 22] | dsimp | case iy_mem.h
B : CompHaus
F : CompHausᵒᵖ ⥤ Type (u + 1)
hFpfp : PreservesFiniteProducts F
X : CompHaus
π : X ⟶ B
πsurj : Function.Surjective ↑π
y : Equalizer.FirstObj F (Presieve.singleton π)
h : Equalizer.Presieve.firstMap F (Presieve.singleton π) y = Equalizer.Presieve.secondMap F (Presieve.singleton π) y
hFecs :
Function.Bijective
(MapToEqualizer F π (pullback.fst π π) (pullback.snd π π) (_ : pullback.fst π π ≫ π = pullback.snd π π ≫ π))
fork_comp : Equalizer.forkMap F (Presieve.singleton π) ≫ (EqualizerFirstObjIso F π).hom = F.map π.op
fmap_comp :
(EqualizerFirstObjIso F π).hom ≫ F.map (pullback.fst π π).op =
Equalizer.Presieve.firstMap F (Presieve.singleton π) ≫ (EqualizerSecondObjIso F π).hom
smap_comp :
(EqualizerFirstObjIso F π).hom ≫ F.map (pullback.snd π π).op =
Equalizer.Presieve.secondMap F (Presieve.singleton π) ≫ (EqualizerSecondObjIso F π).hom
⊢ (Equalizer.Presieve.secondMap F (Presieve.singleton π) ≫ (EqualizerSecondObjIso F π).hom) y =
(Equalizer.Presieve.firstMap F (Presieve.singleton π) ≫ (EqualizerSecondObjIso F π).hom) y | case iy_mem.h
B : CompHaus
F : CompHausᵒᵖ ⥤ Type (u + 1)
hFpfp : PreservesFiniteProducts F
X : CompHaus
π : X ⟶ B
πsurj : Function.Surjective ↑π
y : Equalizer.FirstObj F (Presieve.singleton π)
h : Equalizer.Presieve.firstMap F (Presieve.singleton π) y = Equalizer.Presieve.secondMap F (Presieve.singleton π) y
hFecs :
Function.Bijective
(MapToEqualizer F π (pullback.fst π π) (pullback.snd π π) (_ : pullback.fst π π ≫ π = pullback.snd π π ≫ π))
fork_comp : Equalizer.forkMap F (Presieve.singleton π) ≫ (EqualizerFirstObjIso F π).hom = F.map π.op
fmap_comp :
(EqualizerFirstObjIso F π).hom ≫ F.map (pullback.fst π π).op =
Equalizer.Presieve.firstMap F (Presieve.singleton π) ≫ (EqualizerSecondObjIso F π).hom
smap_comp :
(EqualizerFirstObjIso F π).hom ≫ F.map (pullback.snd π π).op =
Equalizer.Presieve.secondMap F (Presieve.singleton π) ≫ (EqualizerSecondObjIso F π).hom
⊢ (EqualizerSecondObjIso F π).hom (Equalizer.Presieve.secondMap F (Presieve.singleton π) y) =
(EqualizerSecondObjIso F π).hom (Equalizer.Presieve.firstMap F (Presieve.singleton π) y) | Please generate a tactic in lean4 to solve the state.
STATE:
case iy_mem.h
B : CompHaus
F : CompHausᵒᵖ ⥤ Type (u + 1)
hFpfp : PreservesFiniteProducts F
X : CompHaus
π : X ⟶ B
πsurj : Function.Surjective ↑π
y : Equalizer.FirstObj F (Presieve.singleton π)
h : Equalizer.Presieve.firstMap F (Presieve.singleton π) y = Equalizer.Presieve.secondMap F (Presieve.singleton π) y
hFecs :
Function.Bijective
(MapToEqualizer F π (pullback.fst π π) (pullback.snd π π) (_ : pullback.fst π π ≫ π = pullback.snd π π ≫ π))
fork_comp : Equalizer.forkMap F (Presieve.singleton π) ≫ (EqualizerFirstObjIso F π).hom = F.map π.op
fmap_comp :
(EqualizerFirstObjIso F π).hom ≫ F.map (pullback.fst π π).op =
Equalizer.Presieve.firstMap F (Presieve.singleton π) ≫ (EqualizerSecondObjIso F π).hom
smap_comp :
(EqualizerFirstObjIso F π).hom ≫ F.map (pullback.snd π π).op =
Equalizer.Presieve.secondMap F (Presieve.singleton π) ≫ (EqualizerSecondObjIso F π).hom
⊢ (Equalizer.Presieve.secondMap F (Presieve.singleton π) ≫ (EqualizerSecondObjIso F π).hom) y =
(Equalizer.Presieve.firstMap F (Presieve.singleton π) ≫ (EqualizerSecondObjIso F π).hom) y
TACTIC:
|
https://github.com/adamtopaz/CopenhagenMasterclass2023.git | a293ca1554f7e80d891fd4d86fb092c54d8a0a01 | CompHaus/ExplicitSheaves.lean | CompHaus.isSheafFor_of_Dagur | [277, 1] | [352, 22] | rw [h] | case iy_mem.h
B : CompHaus
F : CompHausᵒᵖ ⥤ Type (u + 1)
hFpfp : PreservesFiniteProducts F
X : CompHaus
π : X ⟶ B
πsurj : Function.Surjective ↑π
y : Equalizer.FirstObj F (Presieve.singleton π)
h : Equalizer.Presieve.firstMap F (Presieve.singleton π) y = Equalizer.Presieve.secondMap F (Presieve.singleton π) y
hFecs :
Function.Bijective
(MapToEqualizer F π (pullback.fst π π) (pullback.snd π π) (_ : pullback.fst π π ≫ π = pullback.snd π π ≫ π))
fork_comp : Equalizer.forkMap F (Presieve.singleton π) ≫ (EqualizerFirstObjIso F π).hom = F.map π.op
fmap_comp :
(EqualizerFirstObjIso F π).hom ≫ F.map (pullback.fst π π).op =
Equalizer.Presieve.firstMap F (Presieve.singleton π) ≫ (EqualizerSecondObjIso F π).hom
smap_comp :
(EqualizerFirstObjIso F π).hom ≫ F.map (pullback.snd π π).op =
Equalizer.Presieve.secondMap F (Presieve.singleton π) ≫ (EqualizerSecondObjIso F π).hom
⊢ (EqualizerSecondObjIso F π).hom (Equalizer.Presieve.secondMap F (Presieve.singleton π) y) =
(EqualizerSecondObjIso F π).hom (Equalizer.Presieve.firstMap F (Presieve.singleton π) y) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case iy_mem.h
B : CompHaus
F : CompHausᵒᵖ ⥤ Type (u + 1)
hFpfp : PreservesFiniteProducts F
X : CompHaus
π : X ⟶ B
πsurj : Function.Surjective ↑π
y : Equalizer.FirstObj F (Presieve.singleton π)
h : Equalizer.Presieve.firstMap F (Presieve.singleton π) y = Equalizer.Presieve.secondMap F (Presieve.singleton π) y
hFecs :
Function.Bijective
(MapToEqualizer F π (pullback.fst π π) (pullback.snd π π) (_ : pullback.fst π π ≫ π = pullback.snd π π ≫ π))
fork_comp : Equalizer.forkMap F (Presieve.singleton π) ≫ (EqualizerFirstObjIso F π).hom = F.map π.op
fmap_comp :
(EqualizerFirstObjIso F π).hom ≫ F.map (pullback.fst π π).op =
Equalizer.Presieve.firstMap F (Presieve.singleton π) ≫ (EqualizerSecondObjIso F π).hom
smap_comp :
(EqualizerFirstObjIso F π).hom ≫ F.map (pullback.snd π π).op =
Equalizer.Presieve.secondMap F (Presieve.singleton π) ≫ (EqualizerSecondObjIso F π).hom
⊢ (EqualizerSecondObjIso F π).hom (Equalizer.Presieve.secondMap F (Presieve.singleton π) y) =
(EqualizerSecondObjIso F π).hom (Equalizer.Presieve.firstMap F (Presieve.singleton π) y)
TACTIC:
|
https://github.com/adamtopaz/CopenhagenMasterclass2023.git | a293ca1554f7e80d891fd4d86fb092c54d8a0a01 | CompHaus/ExplicitSheaves.lean | CompHaus.isSheafFor_of_Dagur | [277, 1] | [352, 22] | rw [Function.bijective_iff_existsUnique] at hFecs | case uniq_F
B : CompHaus
F : CompHausᵒᵖ ⥤ Type (u + 1)
hFpfp : PreservesFiniteProducts F
X : CompHaus
π : X ⟶ B
πsurj : Function.Surjective ↑π
y : Equalizer.FirstObj F (Presieve.singleton π)
h : Equalizer.Presieve.firstMap F (Presieve.singleton π) y = Equalizer.Presieve.secondMap F (Presieve.singleton π) y
hFecs :
Function.Bijective
(MapToEqualizer F π (pullback.fst π π) (pullback.snd π π) (_ : pullback.fst π π ≫ π = pullback.snd π π ≫ π))
fork_comp : Equalizer.forkMap F (Presieve.singleton π) ≫ (EqualizerFirstObjIso F π).hom = F.map π.op
fmap_comp :
(EqualizerFirstObjIso F π).hom ≫ F.map (pullback.fst π π).op =
Equalizer.Presieve.firstMap F (Presieve.singleton π) ≫ (EqualizerSecondObjIso F π).hom
smap_comp :
(EqualizerFirstObjIso F π).hom ≫ F.map (pullback.snd π π).op =
Equalizer.Presieve.secondMap F (Presieve.singleton π) ≫ (EqualizerSecondObjIso F π).hom
iy_mem :
F.map (pullback.fst π π).op ((EqualizerFirstObjIso F π).hom y) =
F.map (pullback.snd π π).op ((EqualizerFirstObjIso F π).hom y)
⊢ ∃! x, F.map π.op x = (EqualizerFirstObjIso F π).hom y | case uniq_F
B : CompHaus
F : CompHausᵒᵖ ⥤ Type (u + 1)
hFpfp : PreservesFiniteProducts F
X : CompHaus
π : X ⟶ B
πsurj : Function.Surjective ↑π
y : Equalizer.FirstObj F (Presieve.singleton π)
h : Equalizer.Presieve.firstMap F (Presieve.singleton π) y = Equalizer.Presieve.secondMap F (Presieve.singleton π) y
hFecs :
∀ (b : ↑{x | F.map (pullback.fst π π).op x = F.map (pullback.snd π π).op x}),
∃! a,
MapToEqualizer F π (pullback.fst π π) (pullback.snd π π) (_ : pullback.fst π π ≫ π = pullback.snd π π ≫ π) a = b
fork_comp : Equalizer.forkMap F (Presieve.singleton π) ≫ (EqualizerFirstObjIso F π).hom = F.map π.op
fmap_comp :
(EqualizerFirstObjIso F π).hom ≫ F.map (pullback.fst π π).op =
Equalizer.Presieve.firstMap F (Presieve.singleton π) ≫ (EqualizerSecondObjIso F π).hom
smap_comp :
(EqualizerFirstObjIso F π).hom ≫ F.map (pullback.snd π π).op =
Equalizer.Presieve.secondMap F (Presieve.singleton π) ≫ (EqualizerSecondObjIso F π).hom
iy_mem :
F.map (pullback.fst π π).op ((EqualizerFirstObjIso F π).hom y) =
F.map (pullback.snd π π).op ((EqualizerFirstObjIso F π).hom y)
⊢ ∃! x, F.map π.op x = (EqualizerFirstObjIso F π).hom y | Please generate a tactic in lean4 to solve the state.
STATE:
case uniq_F
B : CompHaus
F : CompHausᵒᵖ ⥤ Type (u + 1)
hFpfp : PreservesFiniteProducts F
X : CompHaus
π : X ⟶ B
πsurj : Function.Surjective ↑π
y : Equalizer.FirstObj F (Presieve.singleton π)
h : Equalizer.Presieve.firstMap F (Presieve.singleton π) y = Equalizer.Presieve.secondMap F (Presieve.singleton π) y
hFecs :
Function.Bijective
(MapToEqualizer F π (pullback.fst π π) (pullback.snd π π) (_ : pullback.fst π π ≫ π = pullback.snd π π ≫ π))
fork_comp : Equalizer.forkMap F (Presieve.singleton π) ≫ (EqualizerFirstObjIso F π).hom = F.map π.op
fmap_comp :
(EqualizerFirstObjIso F π).hom ≫ F.map (pullback.fst π π).op =
Equalizer.Presieve.firstMap F (Presieve.singleton π) ≫ (EqualizerSecondObjIso F π).hom
smap_comp :
(EqualizerFirstObjIso F π).hom ≫ F.map (pullback.snd π π).op =
Equalizer.Presieve.secondMap F (Presieve.singleton π) ≫ (EqualizerSecondObjIso F π).hom
iy_mem :
F.map (pullback.fst π π).op ((EqualizerFirstObjIso F π).hom y) =
F.map (pullback.snd π π).op ((EqualizerFirstObjIso F π).hom y)
⊢ ∃! x, F.map π.op x = (EqualizerFirstObjIso F π).hom y
TACTIC:
|
https://github.com/adamtopaz/CopenhagenMasterclass2023.git | a293ca1554f7e80d891fd4d86fb092c54d8a0a01 | CompHaus/ExplicitSheaves.lean | CompHaus.isSheafFor_of_Dagur | [277, 1] | [352, 22] | specialize hFecs ⟨(EqualizerFirstObjIso F π).hom y, iy_mem⟩ | case uniq_F
B : CompHaus
F : CompHausᵒᵖ ⥤ Type (u + 1)
hFpfp : PreservesFiniteProducts F
X : CompHaus
π : X ⟶ B
πsurj : Function.Surjective ↑π
y : Equalizer.FirstObj F (Presieve.singleton π)
h : Equalizer.Presieve.firstMap F (Presieve.singleton π) y = Equalizer.Presieve.secondMap F (Presieve.singleton π) y
hFecs :
∀ (b : ↑{x | F.map (pullback.fst π π).op x = F.map (pullback.snd π π).op x}),
∃! a,
MapToEqualizer F π (pullback.fst π π) (pullback.snd π π) (_ : pullback.fst π π ≫ π = pullback.snd π π ≫ π) a = b
fork_comp : Equalizer.forkMap F (Presieve.singleton π) ≫ (EqualizerFirstObjIso F π).hom = F.map π.op
fmap_comp :
(EqualizerFirstObjIso F π).hom ≫ F.map (pullback.fst π π).op =
Equalizer.Presieve.firstMap F (Presieve.singleton π) ≫ (EqualizerSecondObjIso F π).hom
smap_comp :
(EqualizerFirstObjIso F π).hom ≫ F.map (pullback.snd π π).op =
Equalizer.Presieve.secondMap F (Presieve.singleton π) ≫ (EqualizerSecondObjIso F π).hom
iy_mem :
F.map (pullback.fst π π).op ((EqualizerFirstObjIso F π).hom y) =
F.map (pullback.snd π π).op ((EqualizerFirstObjIso F π).hom y)
⊢ ∃! x, F.map π.op x = (EqualizerFirstObjIso F π).hom y | case uniq_F
B : CompHaus
F : CompHausᵒᵖ ⥤ Type (u + 1)
hFpfp : PreservesFiniteProducts F
X : CompHaus
π : X ⟶ B
πsurj : Function.Surjective ↑π
y : Equalizer.FirstObj F (Presieve.singleton π)
h : Equalizer.Presieve.firstMap F (Presieve.singleton π) y = Equalizer.Presieve.secondMap F (Presieve.singleton π) y
fork_comp : Equalizer.forkMap F (Presieve.singleton π) ≫ (EqualizerFirstObjIso F π).hom = F.map π.op
fmap_comp :
(EqualizerFirstObjIso F π).hom ≫ F.map (pullback.fst π π).op =
Equalizer.Presieve.firstMap F (Presieve.singleton π) ≫ (EqualizerSecondObjIso F π).hom
smap_comp :
(EqualizerFirstObjIso F π).hom ≫ F.map (pullback.snd π π).op =
Equalizer.Presieve.secondMap F (Presieve.singleton π) ≫ (EqualizerSecondObjIso F π).hom
iy_mem :
F.map (pullback.fst π π).op ((EqualizerFirstObjIso F π).hom y) =
F.map (pullback.snd π π).op ((EqualizerFirstObjIso F π).hom y)
hFecs :
∃! a,
MapToEqualizer F π (pullback.fst π π) (pullback.snd π π) (_ : pullback.fst π π ≫ π = pullback.snd π π ≫ π) a =
{ val := (EqualizerFirstObjIso F π).hom y, property := iy_mem }
⊢ ∃! x, F.map π.op x = (EqualizerFirstObjIso F π).hom y | Please generate a tactic in lean4 to solve the state.
STATE:
case uniq_F
B : CompHaus
F : CompHausᵒᵖ ⥤ Type (u + 1)
hFpfp : PreservesFiniteProducts F
X : CompHaus
π : X ⟶ B
πsurj : Function.Surjective ↑π
y : Equalizer.FirstObj F (Presieve.singleton π)
h : Equalizer.Presieve.firstMap F (Presieve.singleton π) y = Equalizer.Presieve.secondMap F (Presieve.singleton π) y
hFecs :
∀ (b : ↑{x | F.map (pullback.fst π π).op x = F.map (pullback.snd π π).op x}),
∃! a,
MapToEqualizer F π (pullback.fst π π) (pullback.snd π π) (_ : pullback.fst π π ≫ π = pullback.snd π π ≫ π) a = b
fork_comp : Equalizer.forkMap F (Presieve.singleton π) ≫ (EqualizerFirstObjIso F π).hom = F.map π.op
fmap_comp :
(EqualizerFirstObjIso F π).hom ≫ F.map (pullback.fst π π).op =
Equalizer.Presieve.firstMap F (Presieve.singleton π) ≫ (EqualizerSecondObjIso F π).hom
smap_comp :
(EqualizerFirstObjIso F π).hom ≫ F.map (pullback.snd π π).op =
Equalizer.Presieve.secondMap F (Presieve.singleton π) ≫ (EqualizerSecondObjIso F π).hom
iy_mem :
F.map (pullback.fst π π).op ((EqualizerFirstObjIso F π).hom y) =
F.map (pullback.snd π π).op ((EqualizerFirstObjIso F π).hom y)
⊢ ∃! x, F.map π.op x = (EqualizerFirstObjIso F π).hom y
TACTIC:
|
https://github.com/adamtopaz/CopenhagenMasterclass2023.git | a293ca1554f7e80d891fd4d86fb092c54d8a0a01 | CompHaus/ExplicitSheaves.lean | CompHaus.isSheafFor_of_Dagur | [277, 1] | [352, 22] | obtain ⟨x, hx⟩ := hFecs | case uniq_F
B : CompHaus
F : CompHausᵒᵖ ⥤ Type (u + 1)
hFpfp : PreservesFiniteProducts F
X : CompHaus
π : X ⟶ B
πsurj : Function.Surjective ↑π
y : Equalizer.FirstObj F (Presieve.singleton π)
h : Equalizer.Presieve.firstMap F (Presieve.singleton π) y = Equalizer.Presieve.secondMap F (Presieve.singleton π) y
fork_comp : Equalizer.forkMap F (Presieve.singleton π) ≫ (EqualizerFirstObjIso F π).hom = F.map π.op
fmap_comp :
(EqualizerFirstObjIso F π).hom ≫ F.map (pullback.fst π π).op =
Equalizer.Presieve.firstMap F (Presieve.singleton π) ≫ (EqualizerSecondObjIso F π).hom
smap_comp :
(EqualizerFirstObjIso F π).hom ≫ F.map (pullback.snd π π).op =
Equalizer.Presieve.secondMap F (Presieve.singleton π) ≫ (EqualizerSecondObjIso F π).hom
iy_mem :
F.map (pullback.fst π π).op ((EqualizerFirstObjIso F π).hom y) =
F.map (pullback.snd π π).op ((EqualizerFirstObjIso F π).hom y)
hFecs :
∃! a,
MapToEqualizer F π (pullback.fst π π) (pullback.snd π π) (_ : pullback.fst π π ≫ π = pullback.snd π π ≫ π) a =
{ val := (EqualizerFirstObjIso F π).hom y, property := iy_mem }
⊢ ∃! x, F.map π.op x = (EqualizerFirstObjIso F π).hom y | case uniq_F.intro
B : CompHaus
F : CompHausᵒᵖ ⥤ Type (u + 1)
hFpfp : PreservesFiniteProducts F
X : CompHaus
π : X ⟶ B
πsurj : Function.Surjective ↑π
y : Equalizer.FirstObj F (Presieve.singleton π)
h : Equalizer.Presieve.firstMap F (Presieve.singleton π) y = Equalizer.Presieve.secondMap F (Presieve.singleton π) y
fork_comp : Equalizer.forkMap F (Presieve.singleton π) ≫ (EqualizerFirstObjIso F π).hom = F.map π.op
fmap_comp :
(EqualizerFirstObjIso F π).hom ≫ F.map (pullback.fst π π).op =
Equalizer.Presieve.firstMap F (Presieve.singleton π) ≫ (EqualizerSecondObjIso F π).hom
smap_comp :
(EqualizerFirstObjIso F π).hom ≫ F.map (pullback.snd π π).op =
Equalizer.Presieve.secondMap F (Presieve.singleton π) ≫ (EqualizerSecondObjIso F π).hom
iy_mem :
F.map (pullback.fst π π).op ((EqualizerFirstObjIso F π).hom y) =
F.map (pullback.snd π π).op ((EqualizerFirstObjIso F π).hom y)
x : F.obj B.op
hx :
(fun a =>
MapToEqualizer F π (pullback.fst π π) (pullback.snd π π) (_ : pullback.fst π π ≫ π = pullback.snd π π ≫ π) a =
{ val := (EqualizerFirstObjIso F π).hom y, property := iy_mem })
x ∧
∀ (y_1 : F.obj B.op),
(fun a =>
MapToEqualizer F π (pullback.fst π π) (pullback.snd π π) (_ : pullback.fst π π ≫ π = pullback.snd π π ≫ π)
a =
{ val := (EqualizerFirstObjIso F π).hom y, property := iy_mem })
y_1 →
y_1 = x
⊢ ∃! x, F.map π.op x = (EqualizerFirstObjIso F π).hom y | Please generate a tactic in lean4 to solve the state.
STATE:
case uniq_F
B : CompHaus
F : CompHausᵒᵖ ⥤ Type (u + 1)
hFpfp : PreservesFiniteProducts F
X : CompHaus
π : X ⟶ B
πsurj : Function.Surjective ↑π
y : Equalizer.FirstObj F (Presieve.singleton π)
h : Equalizer.Presieve.firstMap F (Presieve.singleton π) y = Equalizer.Presieve.secondMap F (Presieve.singleton π) y
fork_comp : Equalizer.forkMap F (Presieve.singleton π) ≫ (EqualizerFirstObjIso F π).hom = F.map π.op
fmap_comp :
(EqualizerFirstObjIso F π).hom ≫ F.map (pullback.fst π π).op =
Equalizer.Presieve.firstMap F (Presieve.singleton π) ≫ (EqualizerSecondObjIso F π).hom
smap_comp :
(EqualizerFirstObjIso F π).hom ≫ F.map (pullback.snd π π).op =
Equalizer.Presieve.secondMap F (Presieve.singleton π) ≫ (EqualizerSecondObjIso F π).hom
iy_mem :
F.map (pullback.fst π π).op ((EqualizerFirstObjIso F π).hom y) =
F.map (pullback.snd π π).op ((EqualizerFirstObjIso F π).hom y)
hFecs :
∃! a,
MapToEqualizer F π (pullback.fst π π) (pullback.snd π π) (_ : pullback.fst π π ≫ π = pullback.snd π π ≫ π) a =
{ val := (EqualizerFirstObjIso F π).hom y, property := iy_mem }
⊢ ∃! x, F.map π.op x = (EqualizerFirstObjIso F π).hom y
TACTIC:
|
https://github.com/adamtopaz/CopenhagenMasterclass2023.git | a293ca1554f7e80d891fd4d86fb092c54d8a0a01 | CompHaus/ExplicitSheaves.lean | CompHaus.isSheafFor_of_Dagur | [277, 1] | [352, 22] | refine' ⟨x, _⟩ | case uniq_F.intro
B : CompHaus
F : CompHausᵒᵖ ⥤ Type (u + 1)
hFpfp : PreservesFiniteProducts F
X : CompHaus
π : X ⟶ B
πsurj : Function.Surjective ↑π
y : Equalizer.FirstObj F (Presieve.singleton π)
h : Equalizer.Presieve.firstMap F (Presieve.singleton π) y = Equalizer.Presieve.secondMap F (Presieve.singleton π) y
fork_comp : Equalizer.forkMap F (Presieve.singleton π) ≫ (EqualizerFirstObjIso F π).hom = F.map π.op
fmap_comp :
(EqualizerFirstObjIso F π).hom ≫ F.map (pullback.fst π π).op =
Equalizer.Presieve.firstMap F (Presieve.singleton π) ≫ (EqualizerSecondObjIso F π).hom
smap_comp :
(EqualizerFirstObjIso F π).hom ≫ F.map (pullback.snd π π).op =
Equalizer.Presieve.secondMap F (Presieve.singleton π) ≫ (EqualizerSecondObjIso F π).hom
iy_mem :
F.map (pullback.fst π π).op ((EqualizerFirstObjIso F π).hom y) =
F.map (pullback.snd π π).op ((EqualizerFirstObjIso F π).hom y)
x : F.obj B.op
hx :
(fun a =>
MapToEqualizer F π (pullback.fst π π) (pullback.snd π π) (_ : pullback.fst π π ≫ π = pullback.snd π π ≫ π) a =
{ val := (EqualizerFirstObjIso F π).hom y, property := iy_mem })
x ∧
∀ (y_1 : F.obj B.op),
(fun a =>
MapToEqualizer F π (pullback.fst π π) (pullback.snd π π) (_ : pullback.fst π π ≫ π = pullback.snd π π ≫ π)
a =
{ val := (EqualizerFirstObjIso F π).hom y, property := iy_mem })
y_1 →
y_1 = x
⊢ ∃! x, F.map π.op x = (EqualizerFirstObjIso F π).hom y | case uniq_F.intro
B : CompHaus
F : CompHausᵒᵖ ⥤ Type (u + 1)
hFpfp : PreservesFiniteProducts F
X : CompHaus
π : X ⟶ B
πsurj : Function.Surjective ↑π
y : Equalizer.FirstObj F (Presieve.singleton π)
h : Equalizer.Presieve.firstMap F (Presieve.singleton π) y = Equalizer.Presieve.secondMap F (Presieve.singleton π) y
fork_comp : Equalizer.forkMap F (Presieve.singleton π) ≫ (EqualizerFirstObjIso F π).hom = F.map π.op
fmap_comp :
(EqualizerFirstObjIso F π).hom ≫ F.map (pullback.fst π π).op =
Equalizer.Presieve.firstMap F (Presieve.singleton π) ≫ (EqualizerSecondObjIso F π).hom
smap_comp :
(EqualizerFirstObjIso F π).hom ≫ F.map (pullback.snd π π).op =
Equalizer.Presieve.secondMap F (Presieve.singleton π) ≫ (EqualizerSecondObjIso F π).hom
iy_mem :
F.map (pullback.fst π π).op ((EqualizerFirstObjIso F π).hom y) =
F.map (pullback.snd π π).op ((EqualizerFirstObjIso F π).hom y)
x : F.obj B.op
hx :
(fun a =>
MapToEqualizer F π (pullback.fst π π) (pullback.snd π π) (_ : pullback.fst π π ≫ π = pullback.snd π π ≫ π) a =
{ val := (EqualizerFirstObjIso F π).hom y, property := iy_mem })
x ∧
∀ (y_1 : F.obj B.op),
(fun a =>
MapToEqualizer F π (pullback.fst π π) (pullback.snd π π) (_ : pullback.fst π π ≫ π = pullback.snd π π ≫ π)
a =
{ val := (EqualizerFirstObjIso F π).hom y, property := iy_mem })
y_1 →
y_1 = x
⊢ (fun x => F.map π.op x = (EqualizerFirstObjIso F π).hom y) x ∧
∀ (y_1 : F.obj B.op), (fun x => F.map π.op x = (EqualizerFirstObjIso F π).hom y) y_1 → y_1 = x | Please generate a tactic in lean4 to solve the state.
STATE:
case uniq_F.intro
B : CompHaus
F : CompHausᵒᵖ ⥤ Type (u + 1)
hFpfp : PreservesFiniteProducts F
X : CompHaus
π : X ⟶ B
πsurj : Function.Surjective ↑π
y : Equalizer.FirstObj F (Presieve.singleton π)
h : Equalizer.Presieve.firstMap F (Presieve.singleton π) y = Equalizer.Presieve.secondMap F (Presieve.singleton π) y
fork_comp : Equalizer.forkMap F (Presieve.singleton π) ≫ (EqualizerFirstObjIso F π).hom = F.map π.op
fmap_comp :
(EqualizerFirstObjIso F π).hom ≫ F.map (pullback.fst π π).op =
Equalizer.Presieve.firstMap F (Presieve.singleton π) ≫ (EqualizerSecondObjIso F π).hom
smap_comp :
(EqualizerFirstObjIso F π).hom ≫ F.map (pullback.snd π π).op =
Equalizer.Presieve.secondMap F (Presieve.singleton π) ≫ (EqualizerSecondObjIso F π).hom
iy_mem :
F.map (pullback.fst π π).op ((EqualizerFirstObjIso F π).hom y) =
F.map (pullback.snd π π).op ((EqualizerFirstObjIso F π).hom y)
x : F.obj B.op
hx :
(fun a =>
MapToEqualizer F π (pullback.fst π π) (pullback.snd π π) (_ : pullback.fst π π ≫ π = pullback.snd π π ≫ π) a =
{ val := (EqualizerFirstObjIso F π).hom y, property := iy_mem })
x ∧
∀ (y_1 : F.obj B.op),
(fun a =>
MapToEqualizer F π (pullback.fst π π) (pullback.snd π π) (_ : pullback.fst π π ≫ π = pullback.snd π π ≫ π)
a =
{ val := (EqualizerFirstObjIso F π).hom y, property := iy_mem })
y_1 →
y_1 = x
⊢ ∃! x, F.map π.op x = (EqualizerFirstObjIso F π).hom y
TACTIC:
|
https://github.com/adamtopaz/CopenhagenMasterclass2023.git | a293ca1554f7e80d891fd4d86fb092c54d8a0a01 | CompHaus/ExplicitSheaves.lean | CompHaus.isSheafFor_of_Dagur | [277, 1] | [352, 22] | dsimp [MapToEqualizer] at * | case uniq_F.intro
B : CompHaus
F : CompHausᵒᵖ ⥤ Type (u + 1)
hFpfp : PreservesFiniteProducts F
X : CompHaus
π : X ⟶ B
πsurj : Function.Surjective ↑π
y : Equalizer.FirstObj F (Presieve.singleton π)
h : Equalizer.Presieve.firstMap F (Presieve.singleton π) y = Equalizer.Presieve.secondMap F (Presieve.singleton π) y
fork_comp : Equalizer.forkMap F (Presieve.singleton π) ≫ (EqualizerFirstObjIso F π).hom = F.map π.op
fmap_comp :
(EqualizerFirstObjIso F π).hom ≫ F.map (pullback.fst π π).op =
Equalizer.Presieve.firstMap F (Presieve.singleton π) ≫ (EqualizerSecondObjIso F π).hom
smap_comp :
(EqualizerFirstObjIso F π).hom ≫ F.map (pullback.snd π π).op =
Equalizer.Presieve.secondMap F (Presieve.singleton π) ≫ (EqualizerSecondObjIso F π).hom
iy_mem :
F.map (pullback.fst π π).op ((EqualizerFirstObjIso F π).hom y) =
F.map (pullback.snd π π).op ((EqualizerFirstObjIso F π).hom y)
x : F.obj B.op
hx :
(fun a =>
MapToEqualizer F π (pullback.fst π π) (pullback.snd π π) (_ : pullback.fst π π ≫ π = pullback.snd π π ≫ π) a =
{ val := (EqualizerFirstObjIso F π).hom y, property := iy_mem })
x ∧
∀ (y_1 : F.obj B.op),
(fun a =>
MapToEqualizer F π (pullback.fst π π) (pullback.snd π π) (_ : pullback.fst π π ≫ π = pullback.snd π π ≫ π)
a =
{ val := (EqualizerFirstObjIso F π).hom y, property := iy_mem })
y_1 →
y_1 = x
⊢ (fun x => F.map π.op x = (EqualizerFirstObjIso F π).hom y) x ∧
∀ (y_1 : F.obj B.op), (fun x => F.map π.op x = (EqualizerFirstObjIso F π).hom y) y_1 → y_1 = x | case uniq_F.intro
B : CompHaus
F : CompHausᵒᵖ ⥤ Type (u + 1)
hFpfp : PreservesFiniteProducts F
X : CompHaus
π : X ⟶ B
πsurj : Function.Surjective ↑π
y : Equalizer.FirstObj F (Presieve.singleton π)
h : Equalizer.Presieve.firstMap F (Presieve.singleton π) y = Equalizer.Presieve.secondMap F (Presieve.singleton π) y
fork_comp : Equalizer.forkMap F (Presieve.singleton π) ≫ (EqualizerFirstObjIso F π).hom = F.map π.op
fmap_comp :
(EqualizerFirstObjIso F π).hom ≫ F.map (pullback.fst π π).op =
Equalizer.Presieve.firstMap F (Presieve.singleton π) ≫ (EqualizerSecondObjIso F π).hom
smap_comp :
(EqualizerFirstObjIso F π).hom ≫ F.map (pullback.snd π π).op =
Equalizer.Presieve.secondMap F (Presieve.singleton π) ≫ (EqualizerSecondObjIso F π).hom
iy_mem :
F.map (pullback.fst π π).op ((EqualizerFirstObjIso F π).hom y) =
F.map (pullback.snd π π).op ((EqualizerFirstObjIso F π).hom y)
x : F.obj B.op
hx :
{ val := F.map π.op x,
property :=
(_ : (F.map π.op ≫ F.map (pullback.fst π π).op) x = (F.map π.op ≫ F.map (pullback.snd π π).op) x) } =
{ val := (EqualizerFirstObjIso F π).hom y, property := iy_mem } ∧
∀ (y_1 : F.obj B.op),
{ val := F.map π.op y_1,
property :=
(_ : (F.map π.op ≫ F.map (pullback.fst π π).op) y_1 = (F.map π.op ≫ F.map (pullback.snd π π).op) y_1) } =
{ val := (EqualizerFirstObjIso F π).hom y, property := iy_mem } →
y_1 = x
⊢ F.map π.op x = (EqualizerFirstObjIso F π).hom y ∧
∀ (y_1 : F.obj B.op), F.map π.op y_1 = (EqualizerFirstObjIso F π).hom y → y_1 = x | Please generate a tactic in lean4 to solve the state.
STATE:
case uniq_F.intro
B : CompHaus
F : CompHausᵒᵖ ⥤ Type (u + 1)
hFpfp : PreservesFiniteProducts F
X : CompHaus
π : X ⟶ B
πsurj : Function.Surjective ↑π
y : Equalizer.FirstObj F (Presieve.singleton π)
h : Equalizer.Presieve.firstMap F (Presieve.singleton π) y = Equalizer.Presieve.secondMap F (Presieve.singleton π) y
fork_comp : Equalizer.forkMap F (Presieve.singleton π) ≫ (EqualizerFirstObjIso F π).hom = F.map π.op
fmap_comp :
(EqualizerFirstObjIso F π).hom ≫ F.map (pullback.fst π π).op =
Equalizer.Presieve.firstMap F (Presieve.singleton π) ≫ (EqualizerSecondObjIso F π).hom
smap_comp :
(EqualizerFirstObjIso F π).hom ≫ F.map (pullback.snd π π).op =
Equalizer.Presieve.secondMap F (Presieve.singleton π) ≫ (EqualizerSecondObjIso F π).hom
iy_mem :
F.map (pullback.fst π π).op ((EqualizerFirstObjIso F π).hom y) =
F.map (pullback.snd π π).op ((EqualizerFirstObjIso F π).hom y)
x : F.obj B.op
hx :
(fun a =>
MapToEqualizer F π (pullback.fst π π) (pullback.snd π π) (_ : pullback.fst π π ≫ π = pullback.snd π π ≫ π) a =
{ val := (EqualizerFirstObjIso F π).hom y, property := iy_mem })
x ∧
∀ (y_1 : F.obj B.op),
(fun a =>
MapToEqualizer F π (pullback.fst π π) (pullback.snd π π) (_ : pullback.fst π π ≫ π = pullback.snd π π ≫ π)
a =
{ val := (EqualizerFirstObjIso F π).hom y, property := iy_mem })
y_1 →
y_1 = x
⊢ (fun x => F.map π.op x = (EqualizerFirstObjIso F π).hom y) x ∧
∀ (y_1 : F.obj B.op), (fun x => F.map π.op x = (EqualizerFirstObjIso F π).hom y) y_1 → y_1 = x
TACTIC:
|
https://github.com/adamtopaz/CopenhagenMasterclass2023.git | a293ca1554f7e80d891fd4d86fb092c54d8a0a01 | CompHaus/ExplicitSheaves.lean | CompHaus.isSheafFor_of_Dagur | [277, 1] | [352, 22] | refine' ⟨Subtype.ext_iff.mp hx.1,_⟩ | case uniq_F.intro
B : CompHaus
F : CompHausᵒᵖ ⥤ Type (u + 1)
hFpfp : PreservesFiniteProducts F
X : CompHaus
π : X ⟶ B
πsurj : Function.Surjective ↑π
y : Equalizer.FirstObj F (Presieve.singleton π)
h : Equalizer.Presieve.firstMap F (Presieve.singleton π) y = Equalizer.Presieve.secondMap F (Presieve.singleton π) y
fork_comp : Equalizer.forkMap F (Presieve.singleton π) ≫ (EqualizerFirstObjIso F π).hom = F.map π.op
fmap_comp :
(EqualizerFirstObjIso F π).hom ≫ F.map (pullback.fst π π).op =
Equalizer.Presieve.firstMap F (Presieve.singleton π) ≫ (EqualizerSecondObjIso F π).hom
smap_comp :
(EqualizerFirstObjIso F π).hom ≫ F.map (pullback.snd π π).op =
Equalizer.Presieve.secondMap F (Presieve.singleton π) ≫ (EqualizerSecondObjIso F π).hom
iy_mem :
F.map (pullback.fst π π).op ((EqualizerFirstObjIso F π).hom y) =
F.map (pullback.snd π π).op ((EqualizerFirstObjIso F π).hom y)
x : F.obj B.op
hx :
{ val := F.map π.op x,
property :=
(_ : (F.map π.op ≫ F.map (pullback.fst π π).op) x = (F.map π.op ≫ F.map (pullback.snd π π).op) x) } =
{ val := (EqualizerFirstObjIso F π).hom y, property := iy_mem } ∧
∀ (y_1 : F.obj B.op),
{ val := F.map π.op y_1,
property :=
(_ : (F.map π.op ≫ F.map (pullback.fst π π).op) y_1 = (F.map π.op ≫ F.map (pullback.snd π π).op) y_1) } =
{ val := (EqualizerFirstObjIso F π).hom y, property := iy_mem } →
y_1 = x
⊢ F.map π.op x = (EqualizerFirstObjIso F π).hom y ∧
∀ (y_1 : F.obj B.op), F.map π.op y_1 = (EqualizerFirstObjIso F π).hom y → y_1 = x | case uniq_F.intro
B : CompHaus
F : CompHausᵒᵖ ⥤ Type (u + 1)
hFpfp : PreservesFiniteProducts F
X : CompHaus
π : X ⟶ B
πsurj : Function.Surjective ↑π
y : Equalizer.FirstObj F (Presieve.singleton π)
h : Equalizer.Presieve.firstMap F (Presieve.singleton π) y = Equalizer.Presieve.secondMap F (Presieve.singleton π) y
fork_comp : Equalizer.forkMap F (Presieve.singleton π) ≫ (EqualizerFirstObjIso F π).hom = F.map π.op
fmap_comp :
(EqualizerFirstObjIso F π).hom ≫ F.map (pullback.fst π π).op =
Equalizer.Presieve.firstMap F (Presieve.singleton π) ≫ (EqualizerSecondObjIso F π).hom
smap_comp :
(EqualizerFirstObjIso F π).hom ≫ F.map (pullback.snd π π).op =
Equalizer.Presieve.secondMap F (Presieve.singleton π) ≫ (EqualizerSecondObjIso F π).hom
iy_mem :
F.map (pullback.fst π π).op ((EqualizerFirstObjIso F π).hom y) =
F.map (pullback.snd π π).op ((EqualizerFirstObjIso F π).hom y)
x : F.obj B.op
hx :
{ val := F.map π.op x,
property :=
(_ : (F.map π.op ≫ F.map (pullback.fst π π).op) x = (F.map π.op ≫ F.map (pullback.snd π π).op) x) } =
{ val := (EqualizerFirstObjIso F π).hom y, property := iy_mem } ∧
∀ (y_1 : F.obj B.op),
{ val := F.map π.op y_1,
property :=
(_ : (F.map π.op ≫ F.map (pullback.fst π π).op) y_1 = (F.map π.op ≫ F.map (pullback.snd π π).op) y_1) } =
{ val := (EqualizerFirstObjIso F π).hom y, property := iy_mem } →
y_1 = x
⊢ ∀ (y_1 : F.obj B.op), F.map π.op y_1 = (EqualizerFirstObjIso F π).hom y → y_1 = x | Please generate a tactic in lean4 to solve the state.
STATE:
case uniq_F.intro
B : CompHaus
F : CompHausᵒᵖ ⥤ Type (u + 1)
hFpfp : PreservesFiniteProducts F
X : CompHaus
π : X ⟶ B
πsurj : Function.Surjective ↑π
y : Equalizer.FirstObj F (Presieve.singleton π)
h : Equalizer.Presieve.firstMap F (Presieve.singleton π) y = Equalizer.Presieve.secondMap F (Presieve.singleton π) y
fork_comp : Equalizer.forkMap F (Presieve.singleton π) ≫ (EqualizerFirstObjIso F π).hom = F.map π.op
fmap_comp :
(EqualizerFirstObjIso F π).hom ≫ F.map (pullback.fst π π).op =
Equalizer.Presieve.firstMap F (Presieve.singleton π) ≫ (EqualizerSecondObjIso F π).hom
smap_comp :
(EqualizerFirstObjIso F π).hom ≫ F.map (pullback.snd π π).op =
Equalizer.Presieve.secondMap F (Presieve.singleton π) ≫ (EqualizerSecondObjIso F π).hom
iy_mem :
F.map (pullback.fst π π).op ((EqualizerFirstObjIso F π).hom y) =
F.map (pullback.snd π π).op ((EqualizerFirstObjIso F π).hom y)
x : F.obj B.op
hx :
{ val := F.map π.op x,
property :=
(_ : (F.map π.op ≫ F.map (pullback.fst π π).op) x = (F.map π.op ≫ F.map (pullback.snd π π).op) x) } =
{ val := (EqualizerFirstObjIso F π).hom y, property := iy_mem } ∧
∀ (y_1 : F.obj B.op),
{ val := F.map π.op y_1,
property :=
(_ : (F.map π.op ≫ F.map (pullback.fst π π).op) y_1 = (F.map π.op ≫ F.map (pullback.snd π π).op) y_1) } =
{ val := (EqualizerFirstObjIso F π).hom y, property := iy_mem } →
y_1 = x
⊢ F.map π.op x = (EqualizerFirstObjIso F π).hom y ∧
∀ (y_1 : F.obj B.op), F.map π.op y_1 = (EqualizerFirstObjIso F π).hom y → y_1 = x
TACTIC:
|
https://github.com/adamtopaz/CopenhagenMasterclass2023.git | a293ca1554f7e80d891fd4d86fb092c54d8a0a01 | CompHaus/ExplicitSheaves.lean | CompHaus.isSheafFor_of_Dagur | [277, 1] | [352, 22] | intro z hz | case uniq_F.intro
B : CompHaus
F : CompHausᵒᵖ ⥤ Type (u + 1)
hFpfp : PreservesFiniteProducts F
X : CompHaus
π : X ⟶ B
πsurj : Function.Surjective ↑π
y : Equalizer.FirstObj F (Presieve.singleton π)
h : Equalizer.Presieve.firstMap F (Presieve.singleton π) y = Equalizer.Presieve.secondMap F (Presieve.singleton π) y
fork_comp : Equalizer.forkMap F (Presieve.singleton π) ≫ (EqualizerFirstObjIso F π).hom = F.map π.op
fmap_comp :
(EqualizerFirstObjIso F π).hom ≫ F.map (pullback.fst π π).op =
Equalizer.Presieve.firstMap F (Presieve.singleton π) ≫ (EqualizerSecondObjIso F π).hom
smap_comp :
(EqualizerFirstObjIso F π).hom ≫ F.map (pullback.snd π π).op =
Equalizer.Presieve.secondMap F (Presieve.singleton π) ≫ (EqualizerSecondObjIso F π).hom
iy_mem :
F.map (pullback.fst π π).op ((EqualizerFirstObjIso F π).hom y) =
F.map (pullback.snd π π).op ((EqualizerFirstObjIso F π).hom y)
x : F.obj B.op
hx :
{ val := F.map π.op x,
property :=
(_ : (F.map π.op ≫ F.map (pullback.fst π π).op) x = (F.map π.op ≫ F.map (pullback.snd π π).op) x) } =
{ val := (EqualizerFirstObjIso F π).hom y, property := iy_mem } ∧
∀ (y_1 : F.obj B.op),
{ val := F.map π.op y_1,
property :=
(_ : (F.map π.op ≫ F.map (pullback.fst π π).op) y_1 = (F.map π.op ≫ F.map (pullback.snd π π).op) y_1) } =
{ val := (EqualizerFirstObjIso F π).hom y, property := iy_mem } →
y_1 = x
⊢ ∀ (y_1 : F.obj B.op), F.map π.op y_1 = (EqualizerFirstObjIso F π).hom y → y_1 = x | case uniq_F.intro
B : CompHaus
F : CompHausᵒᵖ ⥤ Type (u + 1)
hFpfp : PreservesFiniteProducts F
X : CompHaus
π : X ⟶ B
πsurj : Function.Surjective ↑π
y : Equalizer.FirstObj F (Presieve.singleton π)
h : Equalizer.Presieve.firstMap F (Presieve.singleton π) y = Equalizer.Presieve.secondMap F (Presieve.singleton π) y
fork_comp : Equalizer.forkMap F (Presieve.singleton π) ≫ (EqualizerFirstObjIso F π).hom = F.map π.op
fmap_comp :
(EqualizerFirstObjIso F π).hom ≫ F.map (pullback.fst π π).op =
Equalizer.Presieve.firstMap F (Presieve.singleton π) ≫ (EqualizerSecondObjIso F π).hom
smap_comp :
(EqualizerFirstObjIso F π).hom ≫ F.map (pullback.snd π π).op =
Equalizer.Presieve.secondMap F (Presieve.singleton π) ≫ (EqualizerSecondObjIso F π).hom
iy_mem :
F.map (pullback.fst π π).op ((EqualizerFirstObjIso F π).hom y) =
F.map (pullback.snd π π).op ((EqualizerFirstObjIso F π).hom y)
x : F.obj B.op
hx :
{ val := F.map π.op x,
property :=
(_ : (F.map π.op ≫ F.map (pullback.fst π π).op) x = (F.map π.op ≫ F.map (pullback.snd π π).op) x) } =
{ val := (EqualizerFirstObjIso F π).hom y, property := iy_mem } ∧
∀ (y_1 : F.obj B.op),
{ val := F.map π.op y_1,
property :=
(_ : (F.map π.op ≫ F.map (pullback.fst π π).op) y_1 = (F.map π.op ≫ F.map (pullback.snd π π).op) y_1) } =
{ val := (EqualizerFirstObjIso F π).hom y, property := iy_mem } →
y_1 = x
z : F.obj B.op
hz : F.map π.op z = (EqualizerFirstObjIso F π).hom y
⊢ z = x | Please generate a tactic in lean4 to solve the state.
STATE:
case uniq_F.intro
B : CompHaus
F : CompHausᵒᵖ ⥤ Type (u + 1)
hFpfp : PreservesFiniteProducts F
X : CompHaus
π : X ⟶ B
πsurj : Function.Surjective ↑π
y : Equalizer.FirstObj F (Presieve.singleton π)
h : Equalizer.Presieve.firstMap F (Presieve.singleton π) y = Equalizer.Presieve.secondMap F (Presieve.singleton π) y
fork_comp : Equalizer.forkMap F (Presieve.singleton π) ≫ (EqualizerFirstObjIso F π).hom = F.map π.op
fmap_comp :
(EqualizerFirstObjIso F π).hom ≫ F.map (pullback.fst π π).op =
Equalizer.Presieve.firstMap F (Presieve.singleton π) ≫ (EqualizerSecondObjIso F π).hom
smap_comp :
(EqualizerFirstObjIso F π).hom ≫ F.map (pullback.snd π π).op =
Equalizer.Presieve.secondMap F (Presieve.singleton π) ≫ (EqualizerSecondObjIso F π).hom
iy_mem :
F.map (pullback.fst π π).op ((EqualizerFirstObjIso F π).hom y) =
F.map (pullback.snd π π).op ((EqualizerFirstObjIso F π).hom y)
x : F.obj B.op
hx :
{ val := F.map π.op x,
property :=
(_ : (F.map π.op ≫ F.map (pullback.fst π π).op) x = (F.map π.op ≫ F.map (pullback.snd π π).op) x) } =
{ val := (EqualizerFirstObjIso F π).hom y, property := iy_mem } ∧
∀ (y_1 : F.obj B.op),
{ val := F.map π.op y_1,
property :=
(_ : (F.map π.op ≫ F.map (pullback.fst π π).op) y_1 = (F.map π.op ≫ F.map (pullback.snd π π).op) y_1) } =
{ val := (EqualizerFirstObjIso F π).hom y, property := iy_mem } →
y_1 = x
⊢ ∀ (y_1 : F.obj B.op), F.map π.op y_1 = (EqualizerFirstObjIso F π).hom y → y_1 = x
TACTIC:
|
https://github.com/adamtopaz/CopenhagenMasterclass2023.git | a293ca1554f7e80d891fd4d86fb092c54d8a0a01 | CompHaus/ExplicitSheaves.lean | CompHaus.isSheafFor_of_Dagur | [277, 1] | [352, 22] | apply hx.2 | case uniq_F.intro
B : CompHaus
F : CompHausᵒᵖ ⥤ Type (u + 1)
hFpfp : PreservesFiniteProducts F
X : CompHaus
π : X ⟶ B
πsurj : Function.Surjective ↑π
y : Equalizer.FirstObj F (Presieve.singleton π)
h : Equalizer.Presieve.firstMap F (Presieve.singleton π) y = Equalizer.Presieve.secondMap F (Presieve.singleton π) y
fork_comp : Equalizer.forkMap F (Presieve.singleton π) ≫ (EqualizerFirstObjIso F π).hom = F.map π.op
fmap_comp :
(EqualizerFirstObjIso F π).hom ≫ F.map (pullback.fst π π).op =
Equalizer.Presieve.firstMap F (Presieve.singleton π) ≫ (EqualizerSecondObjIso F π).hom
smap_comp :
(EqualizerFirstObjIso F π).hom ≫ F.map (pullback.snd π π).op =
Equalizer.Presieve.secondMap F (Presieve.singleton π) ≫ (EqualizerSecondObjIso F π).hom
iy_mem :
F.map (pullback.fst π π).op ((EqualizerFirstObjIso F π).hom y) =
F.map (pullback.snd π π).op ((EqualizerFirstObjIso F π).hom y)
x : F.obj B.op
hx :
{ val := F.map π.op x,
property :=
(_ : (F.map π.op ≫ F.map (pullback.fst π π).op) x = (F.map π.op ≫ F.map (pullback.snd π π).op) x) } =
{ val := (EqualizerFirstObjIso F π).hom y, property := iy_mem } ∧
∀ (y_1 : F.obj B.op),
{ val := F.map π.op y_1,
property :=
(_ : (F.map π.op ≫ F.map (pullback.fst π π).op) y_1 = (F.map π.op ≫ F.map (pullback.snd π π).op) y_1) } =
{ val := (EqualizerFirstObjIso F π).hom y, property := iy_mem } →
y_1 = x
z : F.obj B.op
hz : F.map π.op z = (EqualizerFirstObjIso F π).hom y
⊢ z = x | case uniq_F.intro.a
B : CompHaus
F : CompHausᵒᵖ ⥤ Type (u + 1)
hFpfp : PreservesFiniteProducts F
X : CompHaus
π : X ⟶ B
πsurj : Function.Surjective ↑π
y : Equalizer.FirstObj F (Presieve.singleton π)
h : Equalizer.Presieve.firstMap F (Presieve.singleton π) y = Equalizer.Presieve.secondMap F (Presieve.singleton π) y
fork_comp : Equalizer.forkMap F (Presieve.singleton π) ≫ (EqualizerFirstObjIso F π).hom = F.map π.op
fmap_comp :
(EqualizerFirstObjIso F π).hom ≫ F.map (pullback.fst π π).op =
Equalizer.Presieve.firstMap F (Presieve.singleton π) ≫ (EqualizerSecondObjIso F π).hom
smap_comp :
(EqualizerFirstObjIso F π).hom ≫ F.map (pullback.snd π π).op =
Equalizer.Presieve.secondMap F (Presieve.singleton π) ≫ (EqualizerSecondObjIso F π).hom
iy_mem :
F.map (pullback.fst π π).op ((EqualizerFirstObjIso F π).hom y) =
F.map (pullback.snd π π).op ((EqualizerFirstObjIso F π).hom y)
x : F.obj B.op
hx :
{ val := F.map π.op x,
property :=
(_ : (F.map π.op ≫ F.map (pullback.fst π π).op) x = (F.map π.op ≫ F.map (pullback.snd π π).op) x) } =
{ val := (EqualizerFirstObjIso F π).hom y, property := iy_mem } ∧
∀ (y_1 : F.obj B.op),
{ val := F.map π.op y_1,
property :=
(_ : (F.map π.op ≫ F.map (pullback.fst π π).op) y_1 = (F.map π.op ≫ F.map (pullback.snd π π).op) y_1) } =
{ val := (EqualizerFirstObjIso F π).hom y, property := iy_mem } →
y_1 = x
z : F.obj B.op
hz : F.map π.op z = (EqualizerFirstObjIso F π).hom y
⊢ { val := F.map π.op z,
property := (_ : (F.map π.op ≫ F.map (pullback.fst π π).op) z = (F.map π.op ≫ F.map (pullback.snd π π).op) z) } =
{ val := (EqualizerFirstObjIso F π).hom y, property := iy_mem } | Please generate a tactic in lean4 to solve the state.
STATE:
case uniq_F.intro
B : CompHaus
F : CompHausᵒᵖ ⥤ Type (u + 1)
hFpfp : PreservesFiniteProducts F
X : CompHaus
π : X ⟶ B
πsurj : Function.Surjective ↑π
y : Equalizer.FirstObj F (Presieve.singleton π)
h : Equalizer.Presieve.firstMap F (Presieve.singleton π) y = Equalizer.Presieve.secondMap F (Presieve.singleton π) y
fork_comp : Equalizer.forkMap F (Presieve.singleton π) ≫ (EqualizerFirstObjIso F π).hom = F.map π.op
fmap_comp :
(EqualizerFirstObjIso F π).hom ≫ F.map (pullback.fst π π).op =
Equalizer.Presieve.firstMap F (Presieve.singleton π) ≫ (EqualizerSecondObjIso F π).hom
smap_comp :
(EqualizerFirstObjIso F π).hom ≫ F.map (pullback.snd π π).op =
Equalizer.Presieve.secondMap F (Presieve.singleton π) ≫ (EqualizerSecondObjIso F π).hom
iy_mem :
F.map (pullback.fst π π).op ((EqualizerFirstObjIso F π).hom y) =
F.map (pullback.snd π π).op ((EqualizerFirstObjIso F π).hom y)
x : F.obj B.op
hx :
{ val := F.map π.op x,
property :=
(_ : (F.map π.op ≫ F.map (pullback.fst π π).op) x = (F.map π.op ≫ F.map (pullback.snd π π).op) x) } =
{ val := (EqualizerFirstObjIso F π).hom y, property := iy_mem } ∧
∀ (y_1 : F.obj B.op),
{ val := F.map π.op y_1,
property :=
(_ : (F.map π.op ≫ F.map (pullback.fst π π).op) y_1 = (F.map π.op ≫ F.map (pullback.snd π π).op) y_1) } =
{ val := (EqualizerFirstObjIso F π).hom y, property := iy_mem } →
y_1 = x
z : F.obj B.op
hz : F.map π.op z = (EqualizerFirstObjIso F π).hom y
⊢ z = x
TACTIC:
|
https://github.com/adamtopaz/CopenhagenMasterclass2023.git | a293ca1554f7e80d891fd4d86fb092c54d8a0a01 | CompHaus/ExplicitSheaves.lean | CompHaus.isSheafFor_of_Dagur | [277, 1] | [352, 22] | rwa [Subtype.ext_iff] | case uniq_F.intro.a
B : CompHaus
F : CompHausᵒᵖ ⥤ Type (u + 1)
hFpfp : PreservesFiniteProducts F
X : CompHaus
π : X ⟶ B
πsurj : Function.Surjective ↑π
y : Equalizer.FirstObj F (Presieve.singleton π)
h : Equalizer.Presieve.firstMap F (Presieve.singleton π) y = Equalizer.Presieve.secondMap F (Presieve.singleton π) y
fork_comp : Equalizer.forkMap F (Presieve.singleton π) ≫ (EqualizerFirstObjIso F π).hom = F.map π.op
fmap_comp :
(EqualizerFirstObjIso F π).hom ≫ F.map (pullback.fst π π).op =
Equalizer.Presieve.firstMap F (Presieve.singleton π) ≫ (EqualizerSecondObjIso F π).hom
smap_comp :
(EqualizerFirstObjIso F π).hom ≫ F.map (pullback.snd π π).op =
Equalizer.Presieve.secondMap F (Presieve.singleton π) ≫ (EqualizerSecondObjIso F π).hom
iy_mem :
F.map (pullback.fst π π).op ((EqualizerFirstObjIso F π).hom y) =
F.map (pullback.snd π π).op ((EqualizerFirstObjIso F π).hom y)
x : F.obj B.op
hx :
{ val := F.map π.op x,
property :=
(_ : (F.map π.op ≫ F.map (pullback.fst π π).op) x = (F.map π.op ≫ F.map (pullback.snd π π).op) x) } =
{ val := (EqualizerFirstObjIso F π).hom y, property := iy_mem } ∧
∀ (y_1 : F.obj B.op),
{ val := F.map π.op y_1,
property :=
(_ : (F.map π.op ≫ F.map (pullback.fst π π).op) y_1 = (F.map π.op ≫ F.map (pullback.snd π π).op) y_1) } =
{ val := (EqualizerFirstObjIso F π).hom y, property := iy_mem } →
y_1 = x
z : F.obj B.op
hz : F.map π.op z = (EqualizerFirstObjIso F π).hom y
⊢ { val := F.map π.op z,
property := (_ : (F.map π.op ≫ F.map (pullback.fst π π).op) z = (F.map π.op ≫ F.map (pullback.snd π π).op) z) } =
{ val := (EqualizerFirstObjIso F π).hom y, property := iy_mem } | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case uniq_F.intro.a
B : CompHaus
F : CompHausᵒᵖ ⥤ Type (u + 1)
hFpfp : PreservesFiniteProducts F
X : CompHaus
π : X ⟶ B
πsurj : Function.Surjective ↑π
y : Equalizer.FirstObj F (Presieve.singleton π)
h : Equalizer.Presieve.firstMap F (Presieve.singleton π) y = Equalizer.Presieve.secondMap F (Presieve.singleton π) y
fork_comp : Equalizer.forkMap F (Presieve.singleton π) ≫ (EqualizerFirstObjIso F π).hom = F.map π.op
fmap_comp :
(EqualizerFirstObjIso F π).hom ≫ F.map (pullback.fst π π).op =
Equalizer.Presieve.firstMap F (Presieve.singleton π) ≫ (EqualizerSecondObjIso F π).hom
smap_comp :
(EqualizerFirstObjIso F π).hom ≫ F.map (pullback.snd π π).op =
Equalizer.Presieve.secondMap F (Presieve.singleton π) ≫ (EqualizerSecondObjIso F π).hom
iy_mem :
F.map (pullback.fst π π).op ((EqualizerFirstObjIso F π).hom y) =
F.map (pullback.snd π π).op ((EqualizerFirstObjIso F π).hom y)
x : F.obj B.op
hx :
{ val := F.map π.op x,
property :=
(_ : (F.map π.op ≫ F.map (pullback.fst π π).op) x = (F.map π.op ≫ F.map (pullback.snd π π).op) x) } =
{ val := (EqualizerFirstObjIso F π).hom y, property := iy_mem } ∧
∀ (y_1 : F.obj B.op),
{ val := F.map π.op y_1,
property :=
(_ : (F.map π.op ≫ F.map (pullback.fst π π).op) y_1 = (F.map π.op ≫ F.map (pullback.snd π π).op) y_1) } =
{ val := (EqualizerFirstObjIso F π).hom y, property := iy_mem } →
y_1 = x
z : F.obj B.op
hz : F.map π.op z = (EqualizerFirstObjIso F π).hom y
⊢ { val := F.map π.op z,
property := (_ : (F.map π.op ≫ F.map (pullback.fst π π).op) z = (F.map π.op ≫ F.map (pullback.snd π π).op) z) } =
{ val := (EqualizerFirstObjIso F π).hom y, property := iy_mem }
TACTIC:
|
https://github.com/adamtopaz/CopenhagenMasterclass2023.git | a293ca1554f7e80d891fd4d86fb092c54d8a0a01 | CompHaus/ExplicitSheaves.lean | CompHaus.isSheafFor_of_Dagur | [277, 1] | [352, 22] | apply_fun (EqualizerFirstObjIso F π).hom | case inr.intro.intro.intro.intro.left
B : CompHaus
F : CompHausᵒᵖ ⥤ Type (u + 1)
hFpfp : PreservesFiniteProducts F
X : CompHaus
π : X ⟶ B
πsurj : Function.Surjective ↑π
y : Equalizer.FirstObj F (Presieve.singleton π)
h : Equalizer.Presieve.firstMap F (Presieve.singleton π) y = Equalizer.Presieve.secondMap F (Presieve.singleton π) y
hFecs :
Function.Bijective
(MapToEqualizer F π (pullback.fst π π) (pullback.snd π π) (_ : pullback.fst π π ≫ π = pullback.snd π π ≫ π))
fork_comp : Equalizer.forkMap F (Presieve.singleton π) ≫ (EqualizerFirstObjIso F π).hom = F.map π.op
fmap_comp :
(EqualizerFirstObjIso F π).hom ≫ F.map (pullback.fst π π).op =
Equalizer.Presieve.firstMap F (Presieve.singleton π) ≫ (EqualizerSecondObjIso F π).hom
smap_comp :
(EqualizerFirstObjIso F π).hom ≫ F.map (pullback.snd π π).op =
Equalizer.Presieve.secondMap F (Presieve.singleton π) ≫ (EqualizerSecondObjIso F π).hom
iy_mem :
F.map (pullback.fst π π).op ((EqualizerFirstObjIso F π).hom y) =
F.map (pullback.snd π π).op ((EqualizerFirstObjIso F π).hom y)
x : F.obj B.op
hx :
(Equalizer.forkMap F (Presieve.singleton π) ≫ (EqualizerFirstObjIso F π).hom) x = (EqualizerFirstObjIso F π).hom y ∧
∀ (y_1 : F.obj B.op),
(Equalizer.forkMap F (Presieve.singleton π) ≫ (EqualizerFirstObjIso F π).hom) y_1 =
(EqualizerFirstObjIso F π).hom y →
y_1 = x
⊢ Equalizer.forkMap F (Presieve.singleton π) x = y | case inr.intro.intro.intro.intro.left
B : CompHaus
F : CompHausᵒᵖ ⥤ Type (u + 1)
hFpfp : PreservesFiniteProducts F
X : CompHaus
π : X ⟶ B
πsurj : Function.Surjective ↑π
y : Equalizer.FirstObj F (Presieve.singleton π)
h : Equalizer.Presieve.firstMap F (Presieve.singleton π) y = Equalizer.Presieve.secondMap F (Presieve.singleton π) y
hFecs :
Function.Bijective
(MapToEqualizer F π (pullback.fst π π) (pullback.snd π π) (_ : pullback.fst π π ≫ π = pullback.snd π π ≫ π))
fork_comp : Equalizer.forkMap F (Presieve.singleton π) ≫ (EqualizerFirstObjIso F π).hom = F.map π.op
fmap_comp :
(EqualizerFirstObjIso F π).hom ≫ F.map (pullback.fst π π).op =
Equalizer.Presieve.firstMap F (Presieve.singleton π) ≫ (EqualizerSecondObjIso F π).hom
smap_comp :
(EqualizerFirstObjIso F π).hom ≫ F.map (pullback.snd π π).op =
Equalizer.Presieve.secondMap F (Presieve.singleton π) ≫ (EqualizerSecondObjIso F π).hom
iy_mem :
F.map (pullback.fst π π).op ((EqualizerFirstObjIso F π).hom y) =
F.map (pullback.snd π π).op ((EqualizerFirstObjIso F π).hom y)
x : F.obj B.op
hx :
(Equalizer.forkMap F (Presieve.singleton π) ≫ (EqualizerFirstObjIso F π).hom) x = (EqualizerFirstObjIso F π).hom y ∧
∀ (y_1 : F.obj B.op),
(Equalizer.forkMap F (Presieve.singleton π) ≫ (EqualizerFirstObjIso F π).hom) y_1 =
(EqualizerFirstObjIso F π).hom y →
y_1 = x
⊢ (EqualizerFirstObjIso F π).hom (Equalizer.forkMap F (Presieve.singleton π) x) = (EqualizerFirstObjIso F π).hom y
case inr.intro.intro.intro.intro.left.inj
B : CompHaus
F : CompHausᵒᵖ ⥤ Type (u + 1)
hFpfp : PreservesFiniteProducts F
X : CompHaus
π : X ⟶ B
πsurj : Function.Surjective ↑π
y : Equalizer.FirstObj F (Presieve.singleton π)
h : Equalizer.Presieve.firstMap F (Presieve.singleton π) y = Equalizer.Presieve.secondMap F (Presieve.singleton π) y
hFecs :
Function.Bijective
(MapToEqualizer F π (pullback.fst π π) (pullback.snd π π) (_ : pullback.fst π π ≫ π = pullback.snd π π ≫ π))
fork_comp : Equalizer.forkMap F (Presieve.singleton π) ≫ (EqualizerFirstObjIso F π).hom = F.map π.op
fmap_comp :
(EqualizerFirstObjIso F π).hom ≫ F.map (pullback.fst π π).op =
Equalizer.Presieve.firstMap F (Presieve.singleton π) ≫ (EqualizerSecondObjIso F π).hom
smap_comp :
(EqualizerFirstObjIso F π).hom ≫ F.map (pullback.snd π π).op =
Equalizer.Presieve.secondMap F (Presieve.singleton π) ≫ (EqualizerSecondObjIso F π).hom
iy_mem :
F.map (pullback.fst π π).op ((EqualizerFirstObjIso F π).hom y) =
F.map (pullback.snd π π).op ((EqualizerFirstObjIso F π).hom y)
x : F.obj B.op
hx :
(Equalizer.forkMap F (Presieve.singleton π) ≫ (EqualizerFirstObjIso F π).hom) x = (EqualizerFirstObjIso F π).hom y ∧
∀ (y_1 : F.obj B.op),
(Equalizer.forkMap F (Presieve.singleton π) ≫ (EqualizerFirstObjIso F π).hom) y_1 =
(EqualizerFirstObjIso F π).hom y →
y_1 = x
⊢ Function.Injective (EqualizerFirstObjIso F π).hom | Please generate a tactic in lean4 to solve the state.
STATE:
case inr.intro.intro.intro.intro.left
B : CompHaus
F : CompHausᵒᵖ ⥤ Type (u + 1)
hFpfp : PreservesFiniteProducts F
X : CompHaus
π : X ⟶ B
πsurj : Function.Surjective ↑π
y : Equalizer.FirstObj F (Presieve.singleton π)
h : Equalizer.Presieve.firstMap F (Presieve.singleton π) y = Equalizer.Presieve.secondMap F (Presieve.singleton π) y
hFecs :
Function.Bijective
(MapToEqualizer F π (pullback.fst π π) (pullback.snd π π) (_ : pullback.fst π π ≫ π = pullback.snd π π ≫ π))
fork_comp : Equalizer.forkMap F (Presieve.singleton π) ≫ (EqualizerFirstObjIso F π).hom = F.map π.op
fmap_comp :
(EqualizerFirstObjIso F π).hom ≫ F.map (pullback.fst π π).op =
Equalizer.Presieve.firstMap F (Presieve.singleton π) ≫ (EqualizerSecondObjIso F π).hom
smap_comp :
(EqualizerFirstObjIso F π).hom ≫ F.map (pullback.snd π π).op =
Equalizer.Presieve.secondMap F (Presieve.singleton π) ≫ (EqualizerSecondObjIso F π).hom
iy_mem :
F.map (pullback.fst π π).op ((EqualizerFirstObjIso F π).hom y) =
F.map (pullback.snd π π).op ((EqualizerFirstObjIso F π).hom y)
x : F.obj B.op
hx :
(Equalizer.forkMap F (Presieve.singleton π) ≫ (EqualizerFirstObjIso F π).hom) x = (EqualizerFirstObjIso F π).hom y ∧
∀ (y_1 : F.obj B.op),
(Equalizer.forkMap F (Presieve.singleton π) ≫ (EqualizerFirstObjIso F π).hom) y_1 =
(EqualizerFirstObjIso F π).hom y →
y_1 = x
⊢ Equalizer.forkMap F (Presieve.singleton π) x = y
TACTIC:
|
https://github.com/adamtopaz/CopenhagenMasterclass2023.git | a293ca1554f7e80d891fd4d86fb092c54d8a0a01 | CompHaus/ExplicitSheaves.lean | CompHaus.isSheafFor_of_Dagur | [277, 1] | [352, 22] | exact hx.1 | case inr.intro.intro.intro.intro.left
B : CompHaus
F : CompHausᵒᵖ ⥤ Type (u + 1)
hFpfp : PreservesFiniteProducts F
X : CompHaus
π : X ⟶ B
πsurj : Function.Surjective ↑π
y : Equalizer.FirstObj F (Presieve.singleton π)
h : Equalizer.Presieve.firstMap F (Presieve.singleton π) y = Equalizer.Presieve.secondMap F (Presieve.singleton π) y
hFecs :
Function.Bijective
(MapToEqualizer F π (pullback.fst π π) (pullback.snd π π) (_ : pullback.fst π π ≫ π = pullback.snd π π ≫ π))
fork_comp : Equalizer.forkMap F (Presieve.singleton π) ≫ (EqualizerFirstObjIso F π).hom = F.map π.op
fmap_comp :
(EqualizerFirstObjIso F π).hom ≫ F.map (pullback.fst π π).op =
Equalizer.Presieve.firstMap F (Presieve.singleton π) ≫ (EqualizerSecondObjIso F π).hom
smap_comp :
(EqualizerFirstObjIso F π).hom ≫ F.map (pullback.snd π π).op =
Equalizer.Presieve.secondMap F (Presieve.singleton π) ≫ (EqualizerSecondObjIso F π).hom
iy_mem :
F.map (pullback.fst π π).op ((EqualizerFirstObjIso F π).hom y) =
F.map (pullback.snd π π).op ((EqualizerFirstObjIso F π).hom y)
x : F.obj B.op
hx :
(Equalizer.forkMap F (Presieve.singleton π) ≫ (EqualizerFirstObjIso F π).hom) x = (EqualizerFirstObjIso F π).hom y ∧
∀ (y_1 : F.obj B.op),
(Equalizer.forkMap F (Presieve.singleton π) ≫ (EqualizerFirstObjIso F π).hom) y_1 =
(EqualizerFirstObjIso F π).hom y →
y_1 = x
⊢ (EqualizerFirstObjIso F π).hom (Equalizer.forkMap F (Presieve.singleton π) x) = (EqualizerFirstObjIso F π).hom y | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case inr.intro.intro.intro.intro.left
B : CompHaus
F : CompHausᵒᵖ ⥤ Type (u + 1)
hFpfp : PreservesFiniteProducts F
X : CompHaus
π : X ⟶ B
πsurj : Function.Surjective ↑π
y : Equalizer.FirstObj F (Presieve.singleton π)
h : Equalizer.Presieve.firstMap F (Presieve.singleton π) y = Equalizer.Presieve.secondMap F (Presieve.singleton π) y
hFecs :
Function.Bijective
(MapToEqualizer F π (pullback.fst π π) (pullback.snd π π) (_ : pullback.fst π π ≫ π = pullback.snd π π ≫ π))
fork_comp : Equalizer.forkMap F (Presieve.singleton π) ≫ (EqualizerFirstObjIso F π).hom = F.map π.op
fmap_comp :
(EqualizerFirstObjIso F π).hom ≫ F.map (pullback.fst π π).op =
Equalizer.Presieve.firstMap F (Presieve.singleton π) ≫ (EqualizerSecondObjIso F π).hom
smap_comp :
(EqualizerFirstObjIso F π).hom ≫ F.map (pullback.snd π π).op =
Equalizer.Presieve.secondMap F (Presieve.singleton π) ≫ (EqualizerSecondObjIso F π).hom
iy_mem :
F.map (pullback.fst π π).op ((EqualizerFirstObjIso F π).hom y) =
F.map (pullback.snd π π).op ((EqualizerFirstObjIso F π).hom y)
x : F.obj B.op
hx :
(Equalizer.forkMap F (Presieve.singleton π) ≫ (EqualizerFirstObjIso F π).hom) x = (EqualizerFirstObjIso F π).hom y ∧
∀ (y_1 : F.obj B.op),
(Equalizer.forkMap F (Presieve.singleton π) ≫ (EqualizerFirstObjIso F π).hom) y_1 =
(EqualizerFirstObjIso F π).hom y →
y_1 = x
⊢ (EqualizerFirstObjIso F π).hom (Equalizer.forkMap F (Presieve.singleton π) x) = (EqualizerFirstObjIso F π).hom y
TACTIC:
|
https://github.com/adamtopaz/CopenhagenMasterclass2023.git | a293ca1554f7e80d891fd4d86fb092c54d8a0a01 | CompHaus/ExplicitSheaves.lean | CompHaus.isSheafFor_of_Dagur | [277, 1] | [352, 22] | apply Function.Bijective.injective | case inr.intro.intro.intro.intro.left.inj
B : CompHaus
F : CompHausᵒᵖ ⥤ Type (u + 1)
hFpfp : PreservesFiniteProducts F
X : CompHaus
π : X ⟶ B
πsurj : Function.Surjective ↑π
y : Equalizer.FirstObj F (Presieve.singleton π)
h : Equalizer.Presieve.firstMap F (Presieve.singleton π) y = Equalizer.Presieve.secondMap F (Presieve.singleton π) y
hFecs :
Function.Bijective
(MapToEqualizer F π (pullback.fst π π) (pullback.snd π π) (_ : pullback.fst π π ≫ π = pullback.snd π π ≫ π))
fork_comp : Equalizer.forkMap F (Presieve.singleton π) ≫ (EqualizerFirstObjIso F π).hom = F.map π.op
fmap_comp :
(EqualizerFirstObjIso F π).hom ≫ F.map (pullback.fst π π).op =
Equalizer.Presieve.firstMap F (Presieve.singleton π) ≫ (EqualizerSecondObjIso F π).hom
smap_comp :
(EqualizerFirstObjIso F π).hom ≫ F.map (pullback.snd π π).op =
Equalizer.Presieve.secondMap F (Presieve.singleton π) ≫ (EqualizerSecondObjIso F π).hom
iy_mem :
F.map (pullback.fst π π).op ((EqualizerFirstObjIso F π).hom y) =
F.map (pullback.snd π π).op ((EqualizerFirstObjIso F π).hom y)
x : F.obj B.op
hx :
(Equalizer.forkMap F (Presieve.singleton π) ≫ (EqualizerFirstObjIso F π).hom) x = (EqualizerFirstObjIso F π).hom y ∧
∀ (y_1 : F.obj B.op),
(Equalizer.forkMap F (Presieve.singleton π) ≫ (EqualizerFirstObjIso F π).hom) y_1 =
(EqualizerFirstObjIso F π).hom y →
y_1 = x
⊢ Function.Injective (EqualizerFirstObjIso F π).hom | case inr.intro.intro.intro.intro.left.inj.hf
B : CompHaus
F : CompHausᵒᵖ ⥤ Type (u + 1)
hFpfp : PreservesFiniteProducts F
X : CompHaus
π : X ⟶ B
πsurj : Function.Surjective ↑π
y : Equalizer.FirstObj F (Presieve.singleton π)
h : Equalizer.Presieve.firstMap F (Presieve.singleton π) y = Equalizer.Presieve.secondMap F (Presieve.singleton π) y
hFecs :
Function.Bijective
(MapToEqualizer F π (pullback.fst π π) (pullback.snd π π) (_ : pullback.fst π π ≫ π = pullback.snd π π ≫ π))
fork_comp : Equalizer.forkMap F (Presieve.singleton π) ≫ (EqualizerFirstObjIso F π).hom = F.map π.op
fmap_comp :
(EqualizerFirstObjIso F π).hom ≫ F.map (pullback.fst π π).op =
Equalizer.Presieve.firstMap F (Presieve.singleton π) ≫ (EqualizerSecondObjIso F π).hom
smap_comp :
(EqualizerFirstObjIso F π).hom ≫ F.map (pullback.snd π π).op =
Equalizer.Presieve.secondMap F (Presieve.singleton π) ≫ (EqualizerSecondObjIso F π).hom
iy_mem :
F.map (pullback.fst π π).op ((EqualizerFirstObjIso F π).hom y) =
F.map (pullback.snd π π).op ((EqualizerFirstObjIso F π).hom y)
x : F.obj B.op
hx :
(Equalizer.forkMap F (Presieve.singleton π) ≫ (EqualizerFirstObjIso F π).hom) x = (EqualizerFirstObjIso F π).hom y ∧
∀ (y_1 : F.obj B.op),
(Equalizer.forkMap F (Presieve.singleton π) ≫ (EqualizerFirstObjIso F π).hom) y_1 =
(EqualizerFirstObjIso F π).hom y →
y_1 = x
⊢ Function.Bijective (EqualizerFirstObjIso F π).hom | Please generate a tactic in lean4 to solve the state.
STATE:
case inr.intro.intro.intro.intro.left.inj
B : CompHaus
F : CompHausᵒᵖ ⥤ Type (u + 1)
hFpfp : PreservesFiniteProducts F
X : CompHaus
π : X ⟶ B
πsurj : Function.Surjective ↑π
y : Equalizer.FirstObj F (Presieve.singleton π)
h : Equalizer.Presieve.firstMap F (Presieve.singleton π) y = Equalizer.Presieve.secondMap F (Presieve.singleton π) y
hFecs :
Function.Bijective
(MapToEqualizer F π (pullback.fst π π) (pullback.snd π π) (_ : pullback.fst π π ≫ π = pullback.snd π π ≫ π))
fork_comp : Equalizer.forkMap F (Presieve.singleton π) ≫ (EqualizerFirstObjIso F π).hom = F.map π.op
fmap_comp :
(EqualizerFirstObjIso F π).hom ≫ F.map (pullback.fst π π).op =
Equalizer.Presieve.firstMap F (Presieve.singleton π) ≫ (EqualizerSecondObjIso F π).hom
smap_comp :
(EqualizerFirstObjIso F π).hom ≫ F.map (pullback.snd π π).op =
Equalizer.Presieve.secondMap F (Presieve.singleton π) ≫ (EqualizerSecondObjIso F π).hom
iy_mem :
F.map (pullback.fst π π).op ((EqualizerFirstObjIso F π).hom y) =
F.map (pullback.snd π π).op ((EqualizerFirstObjIso F π).hom y)
x : F.obj B.op
hx :
(Equalizer.forkMap F (Presieve.singleton π) ≫ (EqualizerFirstObjIso F π).hom) x = (EqualizerFirstObjIso F π).hom y ∧
∀ (y_1 : F.obj B.op),
(Equalizer.forkMap F (Presieve.singleton π) ≫ (EqualizerFirstObjIso F π).hom) y_1 =
(EqualizerFirstObjIso F π).hom y →
y_1 = x
⊢ Function.Injective (EqualizerFirstObjIso F π).hom
TACTIC:
|
https://github.com/adamtopaz/CopenhagenMasterclass2023.git | a293ca1554f7e80d891fd4d86fb092c54d8a0a01 | CompHaus/ExplicitSheaves.lean | CompHaus.isSheafFor_of_Dagur | [277, 1] | [352, 22] | rw [← isIso_iff_bijective] | case inr.intro.intro.intro.intro.left.inj.hf
B : CompHaus
F : CompHausᵒᵖ ⥤ Type (u + 1)
hFpfp : PreservesFiniteProducts F
X : CompHaus
π : X ⟶ B
πsurj : Function.Surjective ↑π
y : Equalizer.FirstObj F (Presieve.singleton π)
h : Equalizer.Presieve.firstMap F (Presieve.singleton π) y = Equalizer.Presieve.secondMap F (Presieve.singleton π) y
hFecs :
Function.Bijective
(MapToEqualizer F π (pullback.fst π π) (pullback.snd π π) (_ : pullback.fst π π ≫ π = pullback.snd π π ≫ π))
fork_comp : Equalizer.forkMap F (Presieve.singleton π) ≫ (EqualizerFirstObjIso F π).hom = F.map π.op
fmap_comp :
(EqualizerFirstObjIso F π).hom ≫ F.map (pullback.fst π π).op =
Equalizer.Presieve.firstMap F (Presieve.singleton π) ≫ (EqualizerSecondObjIso F π).hom
smap_comp :
(EqualizerFirstObjIso F π).hom ≫ F.map (pullback.snd π π).op =
Equalizer.Presieve.secondMap F (Presieve.singleton π) ≫ (EqualizerSecondObjIso F π).hom
iy_mem :
F.map (pullback.fst π π).op ((EqualizerFirstObjIso F π).hom y) =
F.map (pullback.snd π π).op ((EqualizerFirstObjIso F π).hom y)
x : F.obj B.op
hx :
(Equalizer.forkMap F (Presieve.singleton π) ≫ (EqualizerFirstObjIso F π).hom) x = (EqualizerFirstObjIso F π).hom y ∧
∀ (y_1 : F.obj B.op),
(Equalizer.forkMap F (Presieve.singleton π) ≫ (EqualizerFirstObjIso F π).hom) y_1 =
(EqualizerFirstObjIso F π).hom y →
y_1 = x
⊢ Function.Bijective (EqualizerFirstObjIso F π).hom | case inr.intro.intro.intro.intro.left.inj.hf
B : CompHaus
F : CompHausᵒᵖ ⥤ Type (u + 1)
hFpfp : PreservesFiniteProducts F
X : CompHaus
π : X ⟶ B
πsurj : Function.Surjective ↑π
y : Equalizer.FirstObj F (Presieve.singleton π)
h : Equalizer.Presieve.firstMap F (Presieve.singleton π) y = Equalizer.Presieve.secondMap F (Presieve.singleton π) y
hFecs :
Function.Bijective
(MapToEqualizer F π (pullback.fst π π) (pullback.snd π π) (_ : pullback.fst π π ≫ π = pullback.snd π π ≫ π))
fork_comp : Equalizer.forkMap F (Presieve.singleton π) ≫ (EqualizerFirstObjIso F π).hom = F.map π.op
fmap_comp :
(EqualizerFirstObjIso F π).hom ≫ F.map (pullback.fst π π).op =
Equalizer.Presieve.firstMap F (Presieve.singleton π) ≫ (EqualizerSecondObjIso F π).hom
smap_comp :
(EqualizerFirstObjIso F π).hom ≫ F.map (pullback.snd π π).op =
Equalizer.Presieve.secondMap F (Presieve.singleton π) ≫ (EqualizerSecondObjIso F π).hom
iy_mem :
F.map (pullback.fst π π).op ((EqualizerFirstObjIso F π).hom y) =
F.map (pullback.snd π π).op ((EqualizerFirstObjIso F π).hom y)
x : F.obj B.op
hx :
(Equalizer.forkMap F (Presieve.singleton π) ≫ (EqualizerFirstObjIso F π).hom) x = (EqualizerFirstObjIso F π).hom y ∧
∀ (y_1 : F.obj B.op),
(Equalizer.forkMap F (Presieve.singleton π) ≫ (EqualizerFirstObjIso F π).hom) y_1 =
(EqualizerFirstObjIso F π).hom y →
y_1 = x
⊢ IsIso (EqualizerFirstObjIso F π).hom | Please generate a tactic in lean4 to solve the state.
STATE:
case inr.intro.intro.intro.intro.left.inj.hf
B : CompHaus
F : CompHausᵒᵖ ⥤ Type (u + 1)
hFpfp : PreservesFiniteProducts F
X : CompHaus
π : X ⟶ B
πsurj : Function.Surjective ↑π
y : Equalizer.FirstObj F (Presieve.singleton π)
h : Equalizer.Presieve.firstMap F (Presieve.singleton π) y = Equalizer.Presieve.secondMap F (Presieve.singleton π) y
hFecs :
Function.Bijective
(MapToEqualizer F π (pullback.fst π π) (pullback.snd π π) (_ : pullback.fst π π ≫ π = pullback.snd π π ≫ π))
fork_comp : Equalizer.forkMap F (Presieve.singleton π) ≫ (EqualizerFirstObjIso F π).hom = F.map π.op
fmap_comp :
(EqualizerFirstObjIso F π).hom ≫ F.map (pullback.fst π π).op =
Equalizer.Presieve.firstMap F (Presieve.singleton π) ≫ (EqualizerSecondObjIso F π).hom
smap_comp :
(EqualizerFirstObjIso F π).hom ≫ F.map (pullback.snd π π).op =
Equalizer.Presieve.secondMap F (Presieve.singleton π) ≫ (EqualizerSecondObjIso F π).hom
iy_mem :
F.map (pullback.fst π π).op ((EqualizerFirstObjIso F π).hom y) =
F.map (pullback.snd π π).op ((EqualizerFirstObjIso F π).hom y)
x : F.obj B.op
hx :
(Equalizer.forkMap F (Presieve.singleton π) ≫ (EqualizerFirstObjIso F π).hom) x = (EqualizerFirstObjIso F π).hom y ∧
∀ (y_1 : F.obj B.op),
(Equalizer.forkMap F (Presieve.singleton π) ≫ (EqualizerFirstObjIso F π).hom) y_1 =
(EqualizerFirstObjIso F π).hom y →
y_1 = x
⊢ Function.Bijective (EqualizerFirstObjIso F π).hom
TACTIC:
|
https://github.com/adamtopaz/CopenhagenMasterclass2023.git | a293ca1554f7e80d891fd4d86fb092c54d8a0a01 | CompHaus/ExplicitSheaves.lean | CompHaus.isSheafFor_of_Dagur | [277, 1] | [352, 22] | exact inferInstance | case inr.intro.intro.intro.intro.left.inj.hf
B : CompHaus
F : CompHausᵒᵖ ⥤ Type (u + 1)
hFpfp : PreservesFiniteProducts F
X : CompHaus
π : X ⟶ B
πsurj : Function.Surjective ↑π
y : Equalizer.FirstObj F (Presieve.singleton π)
h : Equalizer.Presieve.firstMap F (Presieve.singleton π) y = Equalizer.Presieve.secondMap F (Presieve.singleton π) y
hFecs :
Function.Bijective
(MapToEqualizer F π (pullback.fst π π) (pullback.snd π π) (_ : pullback.fst π π ≫ π = pullback.snd π π ≫ π))
fork_comp : Equalizer.forkMap F (Presieve.singleton π) ≫ (EqualizerFirstObjIso F π).hom = F.map π.op
fmap_comp :
(EqualizerFirstObjIso F π).hom ≫ F.map (pullback.fst π π).op =
Equalizer.Presieve.firstMap F (Presieve.singleton π) ≫ (EqualizerSecondObjIso F π).hom
smap_comp :
(EqualizerFirstObjIso F π).hom ≫ F.map (pullback.snd π π).op =
Equalizer.Presieve.secondMap F (Presieve.singleton π) ≫ (EqualizerSecondObjIso F π).hom
iy_mem :
F.map (pullback.fst π π).op ((EqualizerFirstObjIso F π).hom y) =
F.map (pullback.snd π π).op ((EqualizerFirstObjIso F π).hom y)
x : F.obj B.op
hx :
(Equalizer.forkMap F (Presieve.singleton π) ≫ (EqualizerFirstObjIso F π).hom) x = (EqualizerFirstObjIso F π).hom y ∧
∀ (y_1 : F.obj B.op),
(Equalizer.forkMap F (Presieve.singleton π) ≫ (EqualizerFirstObjIso F π).hom) y_1 =
(EqualizerFirstObjIso F π).hom y →
y_1 = x
⊢ IsIso (EqualizerFirstObjIso F π).hom | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case inr.intro.intro.intro.intro.left.inj.hf
B : CompHaus
F : CompHausᵒᵖ ⥤ Type (u + 1)
hFpfp : PreservesFiniteProducts F
X : CompHaus
π : X ⟶ B
πsurj : Function.Surjective ↑π
y : Equalizer.FirstObj F (Presieve.singleton π)
h : Equalizer.Presieve.firstMap F (Presieve.singleton π) y = Equalizer.Presieve.secondMap F (Presieve.singleton π) y
hFecs :
Function.Bijective
(MapToEqualizer F π (pullback.fst π π) (pullback.snd π π) (_ : pullback.fst π π ≫ π = pullback.snd π π ≫ π))
fork_comp : Equalizer.forkMap F (Presieve.singleton π) ≫ (EqualizerFirstObjIso F π).hom = F.map π.op
fmap_comp :
(EqualizerFirstObjIso F π).hom ≫ F.map (pullback.fst π π).op =
Equalizer.Presieve.firstMap F (Presieve.singleton π) ≫ (EqualizerSecondObjIso F π).hom
smap_comp :
(EqualizerFirstObjIso F π).hom ≫ F.map (pullback.snd π π).op =
Equalizer.Presieve.secondMap F (Presieve.singleton π) ≫ (EqualizerSecondObjIso F π).hom
iy_mem :
F.map (pullback.fst π π).op ((EqualizerFirstObjIso F π).hom y) =
F.map (pullback.snd π π).op ((EqualizerFirstObjIso F π).hom y)
x : F.obj B.op
hx :
(Equalizer.forkMap F (Presieve.singleton π) ≫ (EqualizerFirstObjIso F π).hom) x = (EqualizerFirstObjIso F π).hom y ∧
∀ (y_1 : F.obj B.op),
(Equalizer.forkMap F (Presieve.singleton π) ≫ (EqualizerFirstObjIso F π).hom) y_1 =
(EqualizerFirstObjIso F π).hom y →
y_1 = x
⊢ IsIso (EqualizerFirstObjIso F π).hom
TACTIC:
|
https://github.com/adamtopaz/CopenhagenMasterclass2023.git | a293ca1554f7e80d891fd4d86fb092c54d8a0a01 | CompHaus/ExplicitSheaves.lean | CompHaus.isSheafFor_of_Dagur | [277, 1] | [352, 22] | intro z hz | case inr.intro.intro.intro.intro.right
B : CompHaus
F : CompHausᵒᵖ ⥤ Type (u + 1)
hFpfp : PreservesFiniteProducts F
X : CompHaus
π : X ⟶ B
πsurj : Function.Surjective ↑π
y : Equalizer.FirstObj F (Presieve.singleton π)
h : Equalizer.Presieve.firstMap F (Presieve.singleton π) y = Equalizer.Presieve.secondMap F (Presieve.singleton π) y
hFecs :
Function.Bijective
(MapToEqualizer F π (pullback.fst π π) (pullback.snd π π) (_ : pullback.fst π π ≫ π = pullback.snd π π ≫ π))
fork_comp : Equalizer.forkMap F (Presieve.singleton π) ≫ (EqualizerFirstObjIso F π).hom = F.map π.op
fmap_comp :
(EqualizerFirstObjIso F π).hom ≫ F.map (pullback.fst π π).op =
Equalizer.Presieve.firstMap F (Presieve.singleton π) ≫ (EqualizerSecondObjIso F π).hom
smap_comp :
(EqualizerFirstObjIso F π).hom ≫ F.map (pullback.snd π π).op =
Equalizer.Presieve.secondMap F (Presieve.singleton π) ≫ (EqualizerSecondObjIso F π).hom
iy_mem :
F.map (pullback.fst π π).op ((EqualizerFirstObjIso F π).hom y) =
F.map (pullback.snd π π).op ((EqualizerFirstObjIso F π).hom y)
x : F.obj B.op
hx :
(Equalizer.forkMap F (Presieve.singleton π) ≫ (EqualizerFirstObjIso F π).hom) x = (EqualizerFirstObjIso F π).hom y ∧
∀ (y_1 : F.obj B.op),
(Equalizer.forkMap F (Presieve.singleton π) ≫ (EqualizerFirstObjIso F π).hom) y_1 =
(EqualizerFirstObjIso F π).hom y →
y_1 = x
⊢ ∀ (y_1 : F.obj B.op), Equalizer.forkMap F (Presieve.singleton π) y_1 = y → y_1 = x | case inr.intro.intro.intro.intro.right
B : CompHaus
F : CompHausᵒᵖ ⥤ Type (u + 1)
hFpfp : PreservesFiniteProducts F
X : CompHaus
π : X ⟶ B
πsurj : Function.Surjective ↑π
y : Equalizer.FirstObj F (Presieve.singleton π)
h : Equalizer.Presieve.firstMap F (Presieve.singleton π) y = Equalizer.Presieve.secondMap F (Presieve.singleton π) y
hFecs :
Function.Bijective
(MapToEqualizer F π (pullback.fst π π) (pullback.snd π π) (_ : pullback.fst π π ≫ π = pullback.snd π π ≫ π))
fork_comp : Equalizer.forkMap F (Presieve.singleton π) ≫ (EqualizerFirstObjIso F π).hom = F.map π.op
fmap_comp :
(EqualizerFirstObjIso F π).hom ≫ F.map (pullback.fst π π).op =
Equalizer.Presieve.firstMap F (Presieve.singleton π) ≫ (EqualizerSecondObjIso F π).hom
smap_comp :
(EqualizerFirstObjIso F π).hom ≫ F.map (pullback.snd π π).op =
Equalizer.Presieve.secondMap F (Presieve.singleton π) ≫ (EqualizerSecondObjIso F π).hom
iy_mem :
F.map (pullback.fst π π).op ((EqualizerFirstObjIso F π).hom y) =
F.map (pullback.snd π π).op ((EqualizerFirstObjIso F π).hom y)
x : F.obj B.op
hx :
(Equalizer.forkMap F (Presieve.singleton π) ≫ (EqualizerFirstObjIso F π).hom) x = (EqualizerFirstObjIso F π).hom y ∧
∀ (y_1 : F.obj B.op),
(Equalizer.forkMap F (Presieve.singleton π) ≫ (EqualizerFirstObjIso F π).hom) y_1 =
(EqualizerFirstObjIso F π).hom y →
y_1 = x
z : F.obj B.op
hz : Equalizer.forkMap F (Presieve.singleton π) z = y
⊢ z = x | Please generate a tactic in lean4 to solve the state.
STATE:
case inr.intro.intro.intro.intro.right
B : CompHaus
F : CompHausᵒᵖ ⥤ Type (u + 1)
hFpfp : PreservesFiniteProducts F
X : CompHaus
π : X ⟶ B
πsurj : Function.Surjective ↑π
y : Equalizer.FirstObj F (Presieve.singleton π)
h : Equalizer.Presieve.firstMap F (Presieve.singleton π) y = Equalizer.Presieve.secondMap F (Presieve.singleton π) y
hFecs :
Function.Bijective
(MapToEqualizer F π (pullback.fst π π) (pullback.snd π π) (_ : pullback.fst π π ≫ π = pullback.snd π π ≫ π))
fork_comp : Equalizer.forkMap F (Presieve.singleton π) ≫ (EqualizerFirstObjIso F π).hom = F.map π.op
fmap_comp :
(EqualizerFirstObjIso F π).hom ≫ F.map (pullback.fst π π).op =
Equalizer.Presieve.firstMap F (Presieve.singleton π) ≫ (EqualizerSecondObjIso F π).hom
smap_comp :
(EqualizerFirstObjIso F π).hom ≫ F.map (pullback.snd π π).op =
Equalizer.Presieve.secondMap F (Presieve.singleton π) ≫ (EqualizerSecondObjIso F π).hom
iy_mem :
F.map (pullback.fst π π).op ((EqualizerFirstObjIso F π).hom y) =
F.map (pullback.snd π π).op ((EqualizerFirstObjIso F π).hom y)
x : F.obj B.op
hx :
(Equalizer.forkMap F (Presieve.singleton π) ≫ (EqualizerFirstObjIso F π).hom) x = (EqualizerFirstObjIso F π).hom y ∧
∀ (y_1 : F.obj B.op),
(Equalizer.forkMap F (Presieve.singleton π) ≫ (EqualizerFirstObjIso F π).hom) y_1 =
(EqualizerFirstObjIso F π).hom y →
y_1 = x
⊢ ∀ (y_1 : F.obj B.op), Equalizer.forkMap F (Presieve.singleton π) y_1 = y → y_1 = x
TACTIC:
|
https://github.com/adamtopaz/CopenhagenMasterclass2023.git | a293ca1554f7e80d891fd4d86fb092c54d8a0a01 | CompHaus/ExplicitSheaves.lean | CompHaus.isSheafFor_of_Dagur | [277, 1] | [352, 22] | apply_fun (EqualizerFirstObjIso F π).hom at hz | case inr.intro.intro.intro.intro.right
B : CompHaus
F : CompHausᵒᵖ ⥤ Type (u + 1)
hFpfp : PreservesFiniteProducts F
X : CompHaus
π : X ⟶ B
πsurj : Function.Surjective ↑π
y : Equalizer.FirstObj F (Presieve.singleton π)
h : Equalizer.Presieve.firstMap F (Presieve.singleton π) y = Equalizer.Presieve.secondMap F (Presieve.singleton π) y
hFecs :
Function.Bijective
(MapToEqualizer F π (pullback.fst π π) (pullback.snd π π) (_ : pullback.fst π π ≫ π = pullback.snd π π ≫ π))
fork_comp : Equalizer.forkMap F (Presieve.singleton π) ≫ (EqualizerFirstObjIso F π).hom = F.map π.op
fmap_comp :
(EqualizerFirstObjIso F π).hom ≫ F.map (pullback.fst π π).op =
Equalizer.Presieve.firstMap F (Presieve.singleton π) ≫ (EqualizerSecondObjIso F π).hom
smap_comp :
(EqualizerFirstObjIso F π).hom ≫ F.map (pullback.snd π π).op =
Equalizer.Presieve.secondMap F (Presieve.singleton π) ≫ (EqualizerSecondObjIso F π).hom
iy_mem :
F.map (pullback.fst π π).op ((EqualizerFirstObjIso F π).hom y) =
F.map (pullback.snd π π).op ((EqualizerFirstObjIso F π).hom y)
x : F.obj B.op
hx :
(Equalizer.forkMap F (Presieve.singleton π) ≫ (EqualizerFirstObjIso F π).hom) x = (EqualizerFirstObjIso F π).hom y ∧
∀ (y_1 : F.obj B.op),
(Equalizer.forkMap F (Presieve.singleton π) ≫ (EqualizerFirstObjIso F π).hom) y_1 =
(EqualizerFirstObjIso F π).hom y →
y_1 = x
z : F.obj B.op
hz : Equalizer.forkMap F (Presieve.singleton π) z = y
⊢ z = x | case inr.intro.intro.intro.intro.right
B : CompHaus
F : CompHausᵒᵖ ⥤ Type (u + 1)
hFpfp : PreservesFiniteProducts F
X : CompHaus
π : X ⟶ B
πsurj : Function.Surjective ↑π
y : Equalizer.FirstObj F (Presieve.singleton π)
h : Equalizer.Presieve.firstMap F (Presieve.singleton π) y = Equalizer.Presieve.secondMap F (Presieve.singleton π) y
hFecs :
Function.Bijective
(MapToEqualizer F π (pullback.fst π π) (pullback.snd π π) (_ : pullback.fst π π ≫ π = pullback.snd π π ≫ π))
fork_comp : Equalizer.forkMap F (Presieve.singleton π) ≫ (EqualizerFirstObjIso F π).hom = F.map π.op
fmap_comp :
(EqualizerFirstObjIso F π).hom ≫ F.map (pullback.fst π π).op =
Equalizer.Presieve.firstMap F (Presieve.singleton π) ≫ (EqualizerSecondObjIso F π).hom
smap_comp :
(EqualizerFirstObjIso F π).hom ≫ F.map (pullback.snd π π).op =
Equalizer.Presieve.secondMap F (Presieve.singleton π) ≫ (EqualizerSecondObjIso F π).hom
iy_mem :
F.map (pullback.fst π π).op ((EqualizerFirstObjIso F π).hom y) =
F.map (pullback.snd π π).op ((EqualizerFirstObjIso F π).hom y)
x : F.obj B.op
hx :
(Equalizer.forkMap F (Presieve.singleton π) ≫ (EqualizerFirstObjIso F π).hom) x = (EqualizerFirstObjIso F π).hom y ∧
∀ (y_1 : F.obj B.op),
(Equalizer.forkMap F (Presieve.singleton π) ≫ (EqualizerFirstObjIso F π).hom) y_1 =
(EqualizerFirstObjIso F π).hom y →
y_1 = x
z : F.obj B.op
hz : (EqualizerFirstObjIso F π).hom (Equalizer.forkMap F (Presieve.singleton π) z) = (EqualizerFirstObjIso F π).hom y
⊢ z = x | Please generate a tactic in lean4 to solve the state.
STATE:
case inr.intro.intro.intro.intro.right
B : CompHaus
F : CompHausᵒᵖ ⥤ Type (u + 1)
hFpfp : PreservesFiniteProducts F
X : CompHaus
π : X ⟶ B
πsurj : Function.Surjective ↑π
y : Equalizer.FirstObj F (Presieve.singleton π)
h : Equalizer.Presieve.firstMap F (Presieve.singleton π) y = Equalizer.Presieve.secondMap F (Presieve.singleton π) y
hFecs :
Function.Bijective
(MapToEqualizer F π (pullback.fst π π) (pullback.snd π π) (_ : pullback.fst π π ≫ π = pullback.snd π π ≫ π))
fork_comp : Equalizer.forkMap F (Presieve.singleton π) ≫ (EqualizerFirstObjIso F π).hom = F.map π.op
fmap_comp :
(EqualizerFirstObjIso F π).hom ≫ F.map (pullback.fst π π).op =
Equalizer.Presieve.firstMap F (Presieve.singleton π) ≫ (EqualizerSecondObjIso F π).hom
smap_comp :
(EqualizerFirstObjIso F π).hom ≫ F.map (pullback.snd π π).op =
Equalizer.Presieve.secondMap F (Presieve.singleton π) ≫ (EqualizerSecondObjIso F π).hom
iy_mem :
F.map (pullback.fst π π).op ((EqualizerFirstObjIso F π).hom y) =
F.map (pullback.snd π π).op ((EqualizerFirstObjIso F π).hom y)
x : F.obj B.op
hx :
(Equalizer.forkMap F (Presieve.singleton π) ≫ (EqualizerFirstObjIso F π).hom) x = (EqualizerFirstObjIso F π).hom y ∧
∀ (y_1 : F.obj B.op),
(Equalizer.forkMap F (Presieve.singleton π) ≫ (EqualizerFirstObjIso F π).hom) y_1 =
(EqualizerFirstObjIso F π).hom y →
y_1 = x
z : F.obj B.op
hz : Equalizer.forkMap F (Presieve.singleton π) z = y
⊢ z = x
TACTIC:
|
https://github.com/adamtopaz/CopenhagenMasterclass2023.git | a293ca1554f7e80d891fd4d86fb092c54d8a0a01 | CompHaus/ExplicitSheaves.lean | CompHaus.isSheafFor_of_Dagur | [277, 1] | [352, 22] | exact hx.2 z hz | case inr.intro.intro.intro.intro.right
B : CompHaus
F : CompHausᵒᵖ ⥤ Type (u + 1)
hFpfp : PreservesFiniteProducts F
X : CompHaus
π : X ⟶ B
πsurj : Function.Surjective ↑π
y : Equalizer.FirstObj F (Presieve.singleton π)
h : Equalizer.Presieve.firstMap F (Presieve.singleton π) y = Equalizer.Presieve.secondMap F (Presieve.singleton π) y
hFecs :
Function.Bijective
(MapToEqualizer F π (pullback.fst π π) (pullback.snd π π) (_ : pullback.fst π π ≫ π = pullback.snd π π ≫ π))
fork_comp : Equalizer.forkMap F (Presieve.singleton π) ≫ (EqualizerFirstObjIso F π).hom = F.map π.op
fmap_comp :
(EqualizerFirstObjIso F π).hom ≫ F.map (pullback.fst π π).op =
Equalizer.Presieve.firstMap F (Presieve.singleton π) ≫ (EqualizerSecondObjIso F π).hom
smap_comp :
(EqualizerFirstObjIso F π).hom ≫ F.map (pullback.snd π π).op =
Equalizer.Presieve.secondMap F (Presieve.singleton π) ≫ (EqualizerSecondObjIso F π).hom
iy_mem :
F.map (pullback.fst π π).op ((EqualizerFirstObjIso F π).hom y) =
F.map (pullback.snd π π).op ((EqualizerFirstObjIso F π).hom y)
x : F.obj B.op
hx :
(Equalizer.forkMap F (Presieve.singleton π) ≫ (EqualizerFirstObjIso F π).hom) x = (EqualizerFirstObjIso F π).hom y ∧
∀ (y_1 : F.obj B.op),
(Equalizer.forkMap F (Presieve.singleton π) ≫ (EqualizerFirstObjIso F π).hom) y_1 =
(EqualizerFirstObjIso F π).hom y →
y_1 = x
z : F.obj B.op
hz : (EqualizerFirstObjIso F π).hom (Equalizer.forkMap F (Presieve.singleton π) z) = (EqualizerFirstObjIso F π).hom y
⊢ z = x | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case inr.intro.intro.intro.intro.right
B : CompHaus
F : CompHausᵒᵖ ⥤ Type (u + 1)
hFpfp : PreservesFiniteProducts F
X : CompHaus
π : X ⟶ B
πsurj : Function.Surjective ↑π
y : Equalizer.FirstObj F (Presieve.singleton π)
h : Equalizer.Presieve.firstMap F (Presieve.singleton π) y = Equalizer.Presieve.secondMap F (Presieve.singleton π) y
hFecs :
Function.Bijective
(MapToEqualizer F π (pullback.fst π π) (pullback.snd π π) (_ : pullback.fst π π ≫ π = pullback.snd π π ≫ π))
fork_comp : Equalizer.forkMap F (Presieve.singleton π) ≫ (EqualizerFirstObjIso F π).hom = F.map π.op
fmap_comp :
(EqualizerFirstObjIso F π).hom ≫ F.map (pullback.fst π π).op =
Equalizer.Presieve.firstMap F (Presieve.singleton π) ≫ (EqualizerSecondObjIso F π).hom
smap_comp :
(EqualizerFirstObjIso F π).hom ≫ F.map (pullback.snd π π).op =
Equalizer.Presieve.secondMap F (Presieve.singleton π) ≫ (EqualizerSecondObjIso F π).hom
iy_mem :
F.map (pullback.fst π π).op ((EqualizerFirstObjIso F π).hom y) =
F.map (pullback.snd π π).op ((EqualizerFirstObjIso F π).hom y)
x : F.obj B.op
hx :
(Equalizer.forkMap F (Presieve.singleton π) ≫ (EqualizerFirstObjIso F π).hom) x = (EqualizerFirstObjIso F π).hom y ∧
∀ (y_1 : F.obj B.op),
(Equalizer.forkMap F (Presieve.singleton π) ≫ (EqualizerFirstObjIso F π).hom) y_1 =
(EqualizerFirstObjIso F π).hom y →
y_1 = x
z : F.obj B.op
hz : (EqualizerFirstObjIso F π).hom (Equalizer.forkMap F (Presieve.singleton π) z) = (EqualizerFirstObjIso F π).hom y
⊢ z = x
TACTIC:
|
https://github.com/adamtopaz/CopenhagenMasterclass2023.git | a293ca1554f7e80d891fd4d86fb092c54d8a0a01 | CompHaus/ExplicitSheaves.lean | CompHaus.final | [354, 1] | [363, 16] | rw [← extensiveRegular_generates_coherent] | A : Type (u + 2)
inst✝ : Category A
F : CompHausᵒᵖ ⥤ A
hF : PreservesFiniteProducts F
hF' : ∀ (E : A), EqualizerCondition (F ⋙ coyoneda.obj E.op)
⊢ Presheaf.IsSheaf (coherentTopology CompHaus) F | A : Type (u + 2)
inst✝ : Category A
F : CompHausᵒᵖ ⥤ A
hF : PreservesFiniteProducts F
hF' : ∀ (E : A), EqualizerCondition (F ⋙ coyoneda.obj E.op)
⊢ Presheaf.IsSheaf
(Coverage.toGrothendieck CompHaus
(ExtensiveRegularCoverage' CompHaus
(_ : ∀ {X Y Z : CompHaus} (f : Y ⟶ X) (π : Z ⟶ X) [inst : Epi π], Epi Limits.pullback.fst)
(_ :
∀ {α : Type} [inst : Fintype α] {X : CompHaus} {Z : α → CompHaus} (π : (a : α) → Z a ⟶ X) {Y : CompHaus}
(f : Y ⟶ X) (x : IsIso (Sigma.desc π)), IsIso (Sigma.desc fun x_1 => Limits.pullback.fst))))
F | Please generate a tactic in lean4 to solve the state.
STATE:
A : Type (u + 2)
inst✝ : Category A
F : CompHausᵒᵖ ⥤ A
hF : PreservesFiniteProducts F
hF' : ∀ (E : A), EqualizerCondition (F ⋙ coyoneda.obj E.op)
⊢ Presheaf.IsSheaf (coherentTopology CompHaus) F
TACTIC:
|
https://github.com/adamtopaz/CopenhagenMasterclass2023.git | a293ca1554f7e80d891fd4d86fb092c54d8a0a01 | CompHaus/ExplicitSheaves.lean | CompHaus.final | [354, 1] | [363, 16] | refine' fun E => (Presieve.isSheaf_coverage _ _).2 _ | A : Type (u + 2)
inst✝ : Category A
F : CompHausᵒᵖ ⥤ A
hF : PreservesFiniteProducts F
hF' : ∀ (E : A), EqualizerCondition (F ⋙ coyoneda.obj E.op)
⊢ Presheaf.IsSheaf
(Coverage.toGrothendieck CompHaus
(ExtensiveRegularCoverage' CompHaus
(_ : ∀ {X Y Z : CompHaus} (f : Y ⟶ X) (π : Z ⟶ X) [inst : Epi π], Epi Limits.pullback.fst)
(_ :
∀ {α : Type} [inst : Fintype α] {X : CompHaus} {Z : α → CompHaus} (π : (a : α) → Z a ⟶ X) {Y : CompHaus}
(f : Y ⟶ X) (x : IsIso (Sigma.desc π)), IsIso (Sigma.desc fun x_1 => Limits.pullback.fst))))
F | A : Type (u + 2)
inst✝ : Category A
F : CompHausᵒᵖ ⥤ A
hF : PreservesFiniteProducts F
hF' : ∀ (E : A), EqualizerCondition (F ⋙ coyoneda.obj E.op)
E : A
⊢ ∀ {X : CompHaus} (R : Presieve X),
R ∈
Coverage.covering
(ExtensiveRegularCoverage' CompHaus
(_ : ∀ {X Y Z : CompHaus} (f : Y ⟶ X) (π : Z ⟶ X) [inst : Epi π], Epi Limits.pullback.fst)
(_ :
∀ {α : Type} [inst : Fintype α] {X : CompHaus} {Z : α → CompHaus} (π : (a : α) → Z a ⟶ X) {Y : CompHaus}
(f : Y ⟶ X) (x : IsIso (Sigma.desc π)), IsIso (Sigma.desc fun x_1 => Limits.pullback.fst)))
X →
IsSheafFor (F ⋙ coyoneda.obj E.op) R | Please generate a tactic in lean4 to solve the state.
STATE:
A : Type (u + 2)
inst✝ : Category A
F : CompHausᵒᵖ ⥤ A
hF : PreservesFiniteProducts F
hF' : ∀ (E : A), EqualizerCondition (F ⋙ coyoneda.obj E.op)
⊢ Presheaf.IsSheaf
(Coverage.toGrothendieck CompHaus
(ExtensiveRegularCoverage' CompHaus
(_ : ∀ {X Y Z : CompHaus} (f : Y ⟶ X) (π : Z ⟶ X) [inst : Epi π], Epi Limits.pullback.fst)
(_ :
∀ {α : Type} [inst : Fintype α] {X : CompHaus} {Z : α → CompHaus} (π : (a : α) → Z a ⟶ X) {Y : CompHaus}
(f : Y ⟶ X) (x : IsIso (Sigma.desc π)), IsIso (Sigma.desc fun x_1 => Limits.pullback.fst))))
F
TACTIC:
|
https://github.com/adamtopaz/CopenhagenMasterclass2023.git | a293ca1554f7e80d891fd4d86fb092c54d8a0a01 | CompHaus/ExplicitSheaves.lean | CompHaus.final | [354, 1] | [363, 16] | intro B S hS | A : Type (u + 2)
inst✝ : Category A
F : CompHausᵒᵖ ⥤ A
hF : PreservesFiniteProducts F
hF' : ∀ (E : A), EqualizerCondition (F ⋙ coyoneda.obj E.op)
E : A
⊢ ∀ {X : CompHaus} (R : Presieve X),
R ∈
Coverage.covering
(ExtensiveRegularCoverage' CompHaus
(_ : ∀ {X Y Z : CompHaus} (f : Y ⟶ X) (π : Z ⟶ X) [inst : Epi π], Epi Limits.pullback.fst)
(_ :
∀ {α : Type} [inst : Fintype α] {X : CompHaus} {Z : α → CompHaus} (π : (a : α) → Z a ⟶ X) {Y : CompHaus}
(f : Y ⟶ X) (x : IsIso (Sigma.desc π)), IsIso (Sigma.desc fun x_1 => Limits.pullback.fst)))
X →
IsSheafFor (F ⋙ coyoneda.obj E.op) R | A : Type (u + 2)
inst✝ : Category A
F : CompHausᵒᵖ ⥤ A
hF : PreservesFiniteProducts F
hF' : ∀ (E : A), EqualizerCondition (F ⋙ coyoneda.obj E.op)
E : A
B : CompHaus
S : Presieve B
hS :
S ∈
Coverage.covering
(ExtensiveRegularCoverage' CompHaus
(_ : ∀ {X Y Z : CompHaus} (f : Y ⟶ X) (π : Z ⟶ X) [inst : Epi π], Epi Limits.pullback.fst)
(_ :
∀ {α : Type} [inst : Fintype α] {X : CompHaus} {Z : α → CompHaus} (π : (a : α) → Z a ⟶ X) {Y : CompHaus}
(f : Y ⟶ X) (x : IsIso (Sigma.desc π)), IsIso (Sigma.desc fun x_1 => Limits.pullback.fst)))
B
⊢ IsSheafFor (F ⋙ coyoneda.obj E.op) S | Please generate a tactic in lean4 to solve the state.
STATE:
A : Type (u + 2)
inst✝ : Category A
F : CompHausᵒᵖ ⥤ A
hF : PreservesFiniteProducts F
hF' : ∀ (E : A), EqualizerCondition (F ⋙ coyoneda.obj E.op)
E : A
⊢ ∀ {X : CompHaus} (R : Presieve X),
R ∈
Coverage.covering
(ExtensiveRegularCoverage' CompHaus
(_ : ∀ {X Y Z : CompHaus} (f : Y ⟶ X) (π : Z ⟶ X) [inst : Epi π], Epi Limits.pullback.fst)
(_ :
∀ {α : Type} [inst : Fintype α] {X : CompHaus} {Z : α → CompHaus} (π : (a : α) → Z a ⟶ X) {Y : CompHaus}
(f : Y ⟶ X) (x : IsIso (Sigma.desc π)), IsIso (Sigma.desc fun x_1 => Limits.pullback.fst)))
X →
IsSheafFor (F ⋙ coyoneda.obj E.op) R
TACTIC:
|
https://github.com/adamtopaz/CopenhagenMasterclass2023.git | a293ca1554f7e80d891fd4d86fb092c54d8a0a01 | CompHaus/ExplicitSheaves.lean | CompHaus.final | [354, 1] | [363, 16] | apply isSheafFor_of_Dagur hS | A : Type (u + 2)
inst✝ : Category A
F : CompHausᵒᵖ ⥤ A
hF : PreservesFiniteProducts F
hF' : ∀ (E : A), EqualizerCondition (F ⋙ coyoneda.obj E.op)
E : A
B : CompHaus
S : Presieve B
hS :
S ∈
Coverage.covering
(ExtensiveRegularCoverage' CompHaus
(_ : ∀ {X Y Z : CompHaus} (f : Y ⟶ X) (π : Z ⟶ X) [inst : Epi π], Epi Limits.pullback.fst)
(_ :
∀ {α : Type} [inst : Fintype α] {X : CompHaus} {Z : α → CompHaus} (π : (a : α) → Z a ⟶ X) {Y : CompHaus}
(f : Y ⟶ X) (x : IsIso (Sigma.desc π)), IsIso (Sigma.desc fun x_1 => Limits.pullback.fst)))
B
⊢ IsSheafFor (F ⋙ coyoneda.obj E.op) S | case hFpfp
A : Type (u + 2)
inst✝ : Category A
F : CompHausᵒᵖ ⥤ A
hF : PreservesFiniteProducts F
hF' : ∀ (E : A), EqualizerCondition (F ⋙ coyoneda.obj E.op)
E : A
B : CompHaus
S : Presieve B
hS :
S ∈
Coverage.covering
(ExtensiveRegularCoverage' CompHaus
(_ : ∀ {X Y Z : CompHaus} (f : Y ⟶ X) (π : Z ⟶ X) [inst : Epi π], Epi Limits.pullback.fst)
(_ :
∀ {α : Type} [inst : Fintype α] {X : CompHaus} {Z : α → CompHaus} (π : (a : α) → Z a ⟶ X) {Y : CompHaus}
(f : Y ⟶ X) (x : IsIso (Sigma.desc π)), IsIso (Sigma.desc fun x_1 => Limits.pullback.fst)))
B
⊢ PreservesFiniteProducts (F ⋙ coyoneda.obj E.op)
case hFecs
A : Type (u + 2)
inst✝ : Category A
F : CompHausᵒᵖ ⥤ A
hF : PreservesFiniteProducts F
hF' : ∀ (E : A), EqualizerCondition (F ⋙ coyoneda.obj E.op)
E : A
B : CompHaus
S : Presieve B
hS :
S ∈
Coverage.covering
(ExtensiveRegularCoverage' CompHaus
(_ : ∀ {X Y Z : CompHaus} (f : Y ⟶ X) (π : Z ⟶ X) [inst : Epi π], Epi Limits.pullback.fst)
(_ :
∀ {α : Type} [inst : Fintype α] {X : CompHaus} {Z : α → CompHaus} (π : (a : α) → Z a ⟶ X) {Y : CompHaus}
(f : Y ⟶ X) (x : IsIso (Sigma.desc π)), IsIso (Sigma.desc fun x_1 => Limits.pullback.fst)))
B
⊢ EqualizerCondition (F ⋙ coyoneda.obj E.op) | Please generate a tactic in lean4 to solve the state.
STATE:
A : Type (u + 2)
inst✝ : Category A
F : CompHausᵒᵖ ⥤ A
hF : PreservesFiniteProducts F
hF' : ∀ (E : A), EqualizerCondition (F ⋙ coyoneda.obj E.op)
E : A
B : CompHaus
S : Presieve B
hS :
S ∈
Coverage.covering
(ExtensiveRegularCoverage' CompHaus
(_ : ∀ {X Y Z : CompHaus} (f : Y ⟶ X) (π : Z ⟶ X) [inst : Epi π], Epi Limits.pullback.fst)
(_ :
∀ {α : Type} [inst : Fintype α] {X : CompHaus} {Z : α → CompHaus} (π : (a : α) → Z a ⟶ X) {Y : CompHaus}
(f : Y ⟶ X) (x : IsIso (Sigma.desc π)), IsIso (Sigma.desc fun x_1 => Limits.pullback.fst)))
B
⊢ IsSheafFor (F ⋙ coyoneda.obj E.op) S
TACTIC:
|
https://github.com/adamtopaz/CopenhagenMasterclass2023.git | a293ca1554f7e80d891fd4d86fb092c54d8a0a01 | CompHaus/ExplicitSheaves.lean | CompHaus.final | [354, 1] | [363, 16] | exact ⟨fun J inst => have := hF.1; compPreservesLimitsOfShape _ _⟩ | case hFpfp
A : Type (u + 2)
inst✝ : Category A
F : CompHausᵒᵖ ⥤ A
hF : PreservesFiniteProducts F
hF' : ∀ (E : A), EqualizerCondition (F ⋙ coyoneda.obj E.op)
E : A
B : CompHaus
S : Presieve B
hS :
S ∈
Coverage.covering
(ExtensiveRegularCoverage' CompHaus
(_ : ∀ {X Y Z : CompHaus} (f : Y ⟶ X) (π : Z ⟶ X) [inst : Epi π], Epi Limits.pullback.fst)
(_ :
∀ {α : Type} [inst : Fintype α] {X : CompHaus} {Z : α → CompHaus} (π : (a : α) → Z a ⟶ X) {Y : CompHaus}
(f : Y ⟶ X) (x : IsIso (Sigma.desc π)), IsIso (Sigma.desc fun x_1 => Limits.pullback.fst)))
B
⊢ PreservesFiniteProducts (F ⋙ coyoneda.obj E.op) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case hFpfp
A : Type (u + 2)
inst✝ : Category A
F : CompHausᵒᵖ ⥤ A
hF : PreservesFiniteProducts F
hF' : ∀ (E : A), EqualizerCondition (F ⋙ coyoneda.obj E.op)
E : A
B : CompHaus
S : Presieve B
hS :
S ∈
Coverage.covering
(ExtensiveRegularCoverage' CompHaus
(_ : ∀ {X Y Z : CompHaus} (f : Y ⟶ X) (π : Z ⟶ X) [inst : Epi π], Epi Limits.pullback.fst)
(_ :
∀ {α : Type} [inst : Fintype α] {X : CompHaus} {Z : α → CompHaus} (π : (a : α) → Z a ⟶ X) {Y : CompHaus}
(f : Y ⟶ X) (x : IsIso (Sigma.desc π)), IsIso (Sigma.desc fun x_1 => Limits.pullback.fst)))
B
⊢ PreservesFiniteProducts (F ⋙ coyoneda.obj E.op)
TACTIC:
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.