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 | Profinite/ExplicitLimits.lean | Profinite.snd_comp_fromExplicit | [206, 1] | [209, 70] | simp only [limit.lift_π, PullbackCone.mk_pt, PullbackCone.mk_π_app] | α : Type
inst✝ : Fintype α
Z✝ : α → Profinite
X Y Z : Profinite
f : X ⟶ Z
g i : Y ⟶ Z
⊢ pullback.snd f i =
Limits.pullback.lift (pullback.fst f i) (pullback.snd f i) (_ : pullback.fst f i ≫ f = pullback.snd f i ≫ i) ≫
Limits.pullback.snd | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type
inst✝ : Fintype α
Z✝ : α → Profinite
X Y Z : Profinite
f : X ⟶ Z
g i : Y ⟶ Z
⊢ pullback.snd f i =
Limits.pullback.lift (pullback.fst f i) (pullback.snd f i) (_ : pullback.fst f i ≫ f = pullback.snd f i ≫ i) ≫
Limits.pullback.snd
TACTIC:
|
https://github.com/adamtopaz/CopenhagenMasterclass2023.git | a293ca1554f7e80d891fd4d86fb092c54d8a0a01 | Sieves/isSheafForPullbackSieve.lean | CategoryTheory.Presieve.pullbackCompatible_iff' | [27, 1] | [37, 69] | constructor | C : Type u₁
inst✝ : Category C
X : C
S : Presieve X
P : Cᵒᵖ ⥤ Type (max v₁ u₁)
hS : isPullbackPresieve S
x : FamilyOfElements P S
⊢ FamilyOfElements.Compatible x ↔
FamilyOfElements.PullbackCompatible' P (_ : ∀ {Y Z : C} {f : Y ⟶ X}, S f → ∀ {g : Z ⟶ X}, S g → HasPullback f g) x | case mp
C : Type u₁
inst✝ : Category C
X : C
S : Presieve X
P : Cᵒᵖ ⥤ Type (max v₁ u₁)
hS : isPullbackPresieve S
x : FamilyOfElements P S
⊢ FamilyOfElements.Compatible x →
FamilyOfElements.PullbackCompatible' P (_ : ∀ {Y Z : C} {f : Y ⟶ X}, S f → ∀ {g : Z ⟶ X}, S g → HasPullback f g) x
case mpr
C : Type u₁
inst✝ : Category C
X : C
S : Presieve X
P : Cᵒᵖ ⥤ Type (max v₁ u₁)
hS : isPullbackPresieve S
x : FamilyOfElements P S
⊢ FamilyOfElements.PullbackCompatible' P (_ : ∀ {Y Z : C} {f : Y ⟶ X}, S f → ∀ {g : Z ⟶ X}, S g → HasPullback f g) x →
FamilyOfElements.Compatible x | Please generate a tactic in lean4 to solve the state.
STATE:
C : Type u₁
inst✝ : Category C
X : C
S : Presieve X
P : Cᵒᵖ ⥤ Type (max v₁ u₁)
hS : isPullbackPresieve S
x : FamilyOfElements P S
⊢ FamilyOfElements.Compatible x ↔
FamilyOfElements.PullbackCompatible' P (_ : ∀ {Y Z : C} {f : Y ⟶ X}, S f → ∀ {g : Z ⟶ X}, S g → HasPullback f g) x
TACTIC:
|
https://github.com/adamtopaz/CopenhagenMasterclass2023.git | a293ca1554f7e80d891fd4d86fb092c54d8a0a01 | Sieves/isSheafForPullbackSieve.lean | CategoryTheory.Presieve.pullbackCompatible_iff' | [27, 1] | [37, 69] | intro t Y₁ Y₂ f₁ f₂ hf₁ hf₂ | case mp
C : Type u₁
inst✝ : Category C
X : C
S : Presieve X
P : Cᵒᵖ ⥤ Type (max v₁ u₁)
hS : isPullbackPresieve S
x : FamilyOfElements P S
⊢ FamilyOfElements.Compatible x →
FamilyOfElements.PullbackCompatible' P (_ : ∀ {Y Z : C} {f : Y ⟶ X}, S f → ∀ {g : Z ⟶ X}, S g → HasPullback f g) x | case mp
C : Type u₁
inst✝ : Category C
X : C
S : Presieve X
P : Cᵒᵖ ⥤ Type (max v₁ u₁)
hS : isPullbackPresieve S
x : FamilyOfElements P S
t : FamilyOfElements.Compatible x
Y₁ Y₂ : C
f₁ : Y₁ ⟶ X
f₂ : Y₂ ⟶ X
hf₁ : S f₁
hf₂ : S f₂
⊢ let_fun this := (_ : HasPullback f₁ f₂);
P.map pullback.fst.op (x f₁ hf₁) = P.map pullback.snd.op (x f₂ hf₂) | Please generate a tactic in lean4 to solve the state.
STATE:
case mp
C : Type u₁
inst✝ : Category C
X : C
S : Presieve X
P : Cᵒᵖ ⥤ Type (max v₁ u₁)
hS : isPullbackPresieve S
x : FamilyOfElements P S
⊢ FamilyOfElements.Compatible x →
FamilyOfElements.PullbackCompatible' P (_ : ∀ {Y Z : C} {f : Y ⟶ X}, S f → ∀ {g : Z ⟶ X}, S g → HasPullback f g) x
TACTIC:
|
https://github.com/adamtopaz/CopenhagenMasterclass2023.git | a293ca1554f7e80d891fd4d86fb092c54d8a0a01 | Sieves/isSheafForPullbackSieve.lean | CategoryTheory.Presieve.pullbackCompatible_iff' | [27, 1] | [37, 69] | apply t | case mp
C : Type u₁
inst✝ : Category C
X : C
S : Presieve X
P : Cᵒᵖ ⥤ Type (max v₁ u₁)
hS : isPullbackPresieve S
x : FamilyOfElements P S
t : FamilyOfElements.Compatible x
Y₁ Y₂ : C
f₁ : Y₁ ⟶ X
f₂ : Y₂ ⟶ X
hf₁ : S f₁
hf₂ : S f₂
⊢ let_fun this := (_ : HasPullback f₁ f₂);
P.map pullback.fst.op (x f₁ hf₁) = P.map pullback.snd.op (x f₂ hf₂) | case mp.a
C : Type u₁
inst✝ : Category C
X : C
S : Presieve X
P : Cᵒᵖ ⥤ Type (max v₁ u₁)
hS : isPullbackPresieve S
x : FamilyOfElements P S
t : FamilyOfElements.Compatible x
Y₁ Y₂ : C
f₁ : Y₁ ⟶ X
f₂ : Y₂ ⟶ X
hf₁ : S f₁
hf₂ : S f₂
⊢ pullback.fst ≫ f₁ = pullback.snd ≫ f₂ | Please generate a tactic in lean4 to solve the state.
STATE:
case mp
C : Type u₁
inst✝ : Category C
X : C
S : Presieve X
P : Cᵒᵖ ⥤ Type (max v₁ u₁)
hS : isPullbackPresieve S
x : FamilyOfElements P S
t : FamilyOfElements.Compatible x
Y₁ Y₂ : C
f₁ : Y₁ ⟶ X
f₂ : Y₂ ⟶ X
hf₁ : S f₁
hf₂ : S f₂
⊢ let_fun this := (_ : HasPullback f₁ f₂);
P.map pullback.fst.op (x f₁ hf₁) = P.map pullback.snd.op (x f₂ hf₂)
TACTIC:
|
https://github.com/adamtopaz/CopenhagenMasterclass2023.git | a293ca1554f7e80d891fd4d86fb092c54d8a0a01 | Sieves/isSheafForPullbackSieve.lean | CategoryTheory.Presieve.pullbackCompatible_iff' | [27, 1] | [37, 69] | have := hS hf₁ hf₂ | case mp.a
C : Type u₁
inst✝ : Category C
X : C
S : Presieve X
P : Cᵒᵖ ⥤ Type (max v₁ u₁)
hS : isPullbackPresieve S
x : FamilyOfElements P S
t : FamilyOfElements.Compatible x
Y₁ Y₂ : C
f₁ : Y₁ ⟶ X
f₂ : Y₂ ⟶ X
hf₁ : S f₁
hf₂ : S f₂
⊢ pullback.fst ≫ f₁ = pullback.snd ≫ f₂ | case mp.a
C : Type u₁
inst✝ : Category C
X : C
S : Presieve X
P : Cᵒᵖ ⥤ Type (max v₁ u₁)
hS : isPullbackPresieve S
x : FamilyOfElements P S
t : FamilyOfElements.Compatible x
Y₁ Y₂ : C
f₁ : Y₁ ⟶ X
f₂ : Y₂ ⟶ X
hf₁ : S f₁
hf₂ : S f₂
this : HasPullback f₁ f₂
⊢ pullback.fst ≫ f₁ = pullback.snd ≫ f₂ | Please generate a tactic in lean4 to solve the state.
STATE:
case mp.a
C : Type u₁
inst✝ : Category C
X : C
S : Presieve X
P : Cᵒᵖ ⥤ Type (max v₁ u₁)
hS : isPullbackPresieve S
x : FamilyOfElements P S
t : FamilyOfElements.Compatible x
Y₁ Y₂ : C
f₁ : Y₁ ⟶ X
f₂ : Y₂ ⟶ X
hf₁ : S f₁
hf₂ : S f₂
⊢ pullback.fst ≫ f₁ = pullback.snd ≫ f₂
TACTIC:
|
https://github.com/adamtopaz/CopenhagenMasterclass2023.git | a293ca1554f7e80d891fd4d86fb092c54d8a0a01 | Sieves/isSheafForPullbackSieve.lean | CategoryTheory.Presieve.pullbackCompatible_iff' | [27, 1] | [37, 69] | apply pullback.condition | case mp.a
C : Type u₁
inst✝ : Category C
X : C
S : Presieve X
P : Cᵒᵖ ⥤ Type (max v₁ u₁)
hS : isPullbackPresieve S
x : FamilyOfElements P S
t : FamilyOfElements.Compatible x
Y₁ Y₂ : C
f₁ : Y₁ ⟶ X
f₂ : Y₂ ⟶ X
hf₁ : S f₁
hf₂ : S f₂
this : HasPullback f₁ f₂
⊢ pullback.fst ≫ f₁ = pullback.snd ≫ f₂ | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case mp.a
C : Type u₁
inst✝ : Category C
X : C
S : Presieve X
P : Cᵒᵖ ⥤ Type (max v₁ u₁)
hS : isPullbackPresieve S
x : FamilyOfElements P S
t : FamilyOfElements.Compatible x
Y₁ Y₂ : C
f₁ : Y₁ ⟶ X
f₂ : Y₂ ⟶ X
hf₁ : S f₁
hf₂ : S f₂
this : HasPullback f₁ f₂
⊢ pullback.fst ≫ f₁ = pullback.snd ≫ f₂
TACTIC:
|
https://github.com/adamtopaz/CopenhagenMasterclass2023.git | a293ca1554f7e80d891fd4d86fb092c54d8a0a01 | Sieves/isSheafForPullbackSieve.lean | CategoryTheory.Presieve.pullbackCompatible_iff' | [27, 1] | [37, 69] | intro t Y₁ Y₂ Z g₁ g₂ f₁ f₂ hf₁ hf₂ comm | case mpr
C : Type u₁
inst✝ : Category C
X : C
S : Presieve X
P : Cᵒᵖ ⥤ Type (max v₁ u₁)
hS : isPullbackPresieve S
x : FamilyOfElements P S
⊢ FamilyOfElements.PullbackCompatible' P (_ : ∀ {Y Z : C} {f : Y ⟶ X}, S f → ∀ {g : Z ⟶ X}, S g → HasPullback f g) x →
FamilyOfElements.Compatible x | case mpr
C : Type u₁
inst✝ : Category C
X : C
S : Presieve X
P : Cᵒᵖ ⥤ Type (max v₁ u₁)
hS : isPullbackPresieve S
x : FamilyOfElements P S
t : FamilyOfElements.PullbackCompatible' P (_ : ∀ {Y Z : C} {f : Y ⟶ X}, S f → ∀ {g : Z ⟶ X}, S g → HasPullback f g) x
Y₁ Y₂ Z : C
g₁ : Z ⟶ Y₁
g₂ : Z ⟶ Y₂
f₁ : Y₁ ⟶ X
f₂ : Y₂ ⟶ X
hf₁ : S f₁
hf₂ : S f₂
comm : g₁ ≫ f₁ = g₂ ≫ f₂
⊢ P.map g₁.op (x f₁ hf₁) = P.map g₂.op (x f₂ hf₂) | Please generate a tactic in lean4 to solve the state.
STATE:
case mpr
C : Type u₁
inst✝ : Category C
X : C
S : Presieve X
P : Cᵒᵖ ⥤ Type (max v₁ u₁)
hS : isPullbackPresieve S
x : FamilyOfElements P S
⊢ FamilyOfElements.PullbackCompatible' P (_ : ∀ {Y Z : C} {f : Y ⟶ X}, S f → ∀ {g : Z ⟶ X}, S g → HasPullback f g) x →
FamilyOfElements.Compatible x
TACTIC:
|
https://github.com/adamtopaz/CopenhagenMasterclass2023.git | a293ca1554f7e80d891fd4d86fb092c54d8a0a01 | Sieves/isSheafForPullbackSieve.lean | CategoryTheory.Presieve.pullbackCompatible_iff' | [27, 1] | [37, 69] | have := hS hf₁ hf₂ | case mpr
C : Type u₁
inst✝ : Category C
X : C
S : Presieve X
P : Cᵒᵖ ⥤ Type (max v₁ u₁)
hS : isPullbackPresieve S
x : FamilyOfElements P S
t : FamilyOfElements.PullbackCompatible' P (_ : ∀ {Y Z : C} {f : Y ⟶ X}, S f → ∀ {g : Z ⟶ X}, S g → HasPullback f g) x
Y₁ Y₂ Z : C
g₁ : Z ⟶ Y₁
g₂ : Z ⟶ Y₂
f₁ : Y₁ ⟶ X
f₂ : Y₂ ⟶ X
hf₁ : S f₁
hf₂ : S f₂
comm : g₁ ≫ f₁ = g₂ ≫ f₂
⊢ P.map g₁.op (x f₁ hf₁) = P.map g₂.op (x f₂ hf₂) | case mpr
C : Type u₁
inst✝ : Category C
X : C
S : Presieve X
P : Cᵒᵖ ⥤ Type (max v₁ u₁)
hS : isPullbackPresieve S
x : FamilyOfElements P S
t : FamilyOfElements.PullbackCompatible' P (_ : ∀ {Y Z : C} {f : Y ⟶ X}, S f → ∀ {g : Z ⟶ X}, S g → HasPullback f g) x
Y₁ Y₂ Z : C
g₁ : Z ⟶ Y₁
g₂ : Z ⟶ Y₂
f₁ : Y₁ ⟶ X
f₂ : Y₂ ⟶ X
hf₁ : S f₁
hf₂ : S f₂
comm : g₁ ≫ f₁ = g₂ ≫ f₂
this : HasPullback f₁ f₂
⊢ P.map g₁.op (x f₁ hf₁) = P.map g₂.op (x f₂ hf₂) | Please generate a tactic in lean4 to solve the state.
STATE:
case mpr
C : Type u₁
inst✝ : Category C
X : C
S : Presieve X
P : Cᵒᵖ ⥤ Type (max v₁ u₁)
hS : isPullbackPresieve S
x : FamilyOfElements P S
t : FamilyOfElements.PullbackCompatible' P (_ : ∀ {Y Z : C} {f : Y ⟶ X}, S f → ∀ {g : Z ⟶ X}, S g → HasPullback f g) x
Y₁ Y₂ Z : C
g₁ : Z ⟶ Y₁
g₂ : Z ⟶ Y₂
f₁ : Y₁ ⟶ X
f₂ : Y₂ ⟶ X
hf₁ : S f₁
hf₂ : S f₂
comm : g₁ ≫ f₁ = g₂ ≫ f₂
⊢ P.map g₁.op (x f₁ hf₁) = P.map g₂.op (x f₂ hf₂)
TACTIC:
|
https://github.com/adamtopaz/CopenhagenMasterclass2023.git | a293ca1554f7e80d891fd4d86fb092c54d8a0a01 | Sieves/isSheafForPullbackSieve.lean | CategoryTheory.Presieve.pullbackCompatible_iff' | [27, 1] | [37, 69] | rw [← pullback.lift_fst _ _ comm, op_comp, FunctorToTypes.map_comp_apply, t hf₁ hf₂,
← FunctorToTypes.map_comp_apply, ← op_comp, pullback.lift_snd] | case mpr
C : Type u₁
inst✝ : Category C
X : C
S : Presieve X
P : Cᵒᵖ ⥤ Type (max v₁ u₁)
hS : isPullbackPresieve S
x : FamilyOfElements P S
t : FamilyOfElements.PullbackCompatible' P (_ : ∀ {Y Z : C} {f : Y ⟶ X}, S f → ∀ {g : Z ⟶ X}, S g → HasPullback f g) x
Y₁ Y₂ Z : C
g₁ : Z ⟶ Y₁
g₂ : Z ⟶ Y₂
f₁ : Y₁ ⟶ X
f₂ : Y₂ ⟶ X
hf₁ : S f₁
hf₂ : S f₂
comm : g₁ ≫ f₁ = g₂ ≫ f₂
this : HasPullback f₁ f₂
⊢ P.map g₁.op (x f₁ hf₁) = P.map g₂.op (x f₂ hf₂) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case mpr
C : Type u₁
inst✝ : Category C
X : C
S : Presieve X
P : Cᵒᵖ ⥤ Type (max v₁ u₁)
hS : isPullbackPresieve S
x : FamilyOfElements P S
t : FamilyOfElements.PullbackCompatible' P (_ : ∀ {Y Z : C} {f : Y ⟶ X}, S f → ∀ {g : Z ⟶ X}, S g → HasPullback f g) x
Y₁ Y₂ Z : C
g₁ : Z ⟶ Y₁
g₂ : Z ⟶ Y₂
f₁ : Y₁ ⟶ X
f₂ : Y₂ ⟶ X
hf₁ : S f₁
hf₂ : S f₂
comm : g₁ ≫ f₁ = g₂ ≫ f₂
this : HasPullback f₁ f₂
⊢ P.map g₁.op (x f₁ hf₁) = P.map g₂.op (x f₂ hf₂)
TACTIC:
|
https://github.com/adamtopaz/CopenhagenMasterclass2023.git | a293ca1554f7e80d891fd4d86fb092c54d8a0a01 | Sieves/isSheafForPullbackSieve.lean | CategoryTheory.Equalizer.Presieve.w' | [66, 1] | [73, 7] | ext fg | C : Type u₁
inst✝ : Category C
X : C
S : Presieve X
P : Cᵒᵖ ⥤ Type (max v₁ u₁)
hS : isPullbackPresieve S
⊢ forkMap P S ≫ firstMap' P (_ : ∀ {Y Z : C} {f : Y ⟶ X}, S f → ∀ {g : Z ⟶ X}, S g → HasPullback f g) =
forkMap P S ≫ secondMap' P (_ : ∀ {Y Z : C} {f : Y ⟶ X}, S f → ∀ {g : Z ⟶ X}, S g → HasPullback f g) | case h.h
C : Type u₁
inst✝ : Category C
X : C
S : Presieve X
P : Cᵒᵖ ⥤ Type (max v₁ u₁)
hS : isPullbackPresieve S
fg : ((Y : C) × { f // S f }) × (Z : C) × { g // S g }
a✝ : P.obj X.op
⊢ ((forkMap P S ≫ firstMap' P (_ : ∀ {Y Z : C} {f : Y ⟶ X}, S f → ∀ {g : Z ⟶ X}, S g → HasPullback f g)) ≫
Pi.π (fun fg => P.obj (Limits.pullback ↑fg.fst.snd ↑fg.snd.snd).op) fg)
a✝ =
((forkMap P S ≫ secondMap' P (_ : ∀ {Y Z : C} {f : Y ⟶ X}, S f → ∀ {g : Z ⟶ X}, S g → HasPullback f g)) ≫
Pi.π (fun fg => P.obj (Limits.pullback ↑fg.fst.snd ↑fg.snd.snd).op) fg)
a✝ | Please generate a tactic in lean4 to solve the state.
STATE:
C : Type u₁
inst✝ : Category C
X : C
S : Presieve X
P : Cᵒᵖ ⥤ Type (max v₁ u₁)
hS : isPullbackPresieve S
⊢ forkMap P S ≫ firstMap' P (_ : ∀ {Y Z : C} {f : Y ⟶ X}, S f → ∀ {g : Z ⟶ X}, S g → HasPullback f g) =
forkMap P S ≫ secondMap' P (_ : ∀ {Y Z : C} {f : Y ⟶ X}, S f → ∀ {g : Z ⟶ X}, S g → HasPullback f g)
TACTIC:
|
https://github.com/adamtopaz/CopenhagenMasterclass2023.git | a293ca1554f7e80d891fd4d86fb092c54d8a0a01 | Sieves/isSheafForPullbackSieve.lean | CategoryTheory.Equalizer.Presieve.w' | [66, 1] | [73, 7] | simp only [firstMap', secondMap', forkMap] | case h.h
C : Type u₁
inst✝ : Category C
X : C
S : Presieve X
P : Cᵒᵖ ⥤ Type (max v₁ u₁)
hS : isPullbackPresieve S
fg : ((Y : C) × { f // S f }) × (Z : C) × { g // S g }
a✝ : P.obj X.op
⊢ ((forkMap P S ≫ firstMap' P (_ : ∀ {Y Z : C} {f : Y ⟶ X}, S f → ∀ {g : Z ⟶ X}, S g → HasPullback f g)) ≫
Pi.π (fun fg => P.obj (Limits.pullback ↑fg.fst.snd ↑fg.snd.snd).op) fg)
a✝ =
((forkMap P S ≫ secondMap' P (_ : ∀ {Y Z : C} {f : Y ⟶ X}, S f → ∀ {g : Z ⟶ X}, S g → HasPullback f g)) ≫
Pi.π (fun fg => P.obj (Limits.pullback ↑fg.fst.snd ↑fg.snd.snd).op) fg)
a✝ | case h.h
C : Type u₁
inst✝ : Category C
X : C
S : Presieve X
P : Cᵒᵖ ⥤ Type (max v₁ u₁)
hS : isPullbackPresieve S
fg : ((Y : C) × { f // S f }) × (Z : C) × { g // S g }
a✝ : P.obj X.op
⊢ (((Pi.lift fun f => P.map (↑f.snd).op) ≫
Pi.lift fun fg => Pi.π (fun f => P.obj f.fst.op) fg.fst ≫ P.map pullback.fst.op) ≫
Pi.π (fun fg => P.obj (Limits.pullback ↑fg.fst.snd ↑fg.snd.snd).op) fg)
a✝ =
(((Pi.lift fun f => P.map (↑f.snd).op) ≫
Pi.lift fun fg => Pi.π (fun f => P.obj f.fst.op) fg.snd ≫ P.map pullback.snd.op) ≫
Pi.π (fun fg => P.obj (Limits.pullback ↑fg.fst.snd ↑fg.snd.snd).op) fg)
a✝ | Please generate a tactic in lean4 to solve the state.
STATE:
case h.h
C : Type u₁
inst✝ : Category C
X : C
S : Presieve X
P : Cᵒᵖ ⥤ Type (max v₁ u₁)
hS : isPullbackPresieve S
fg : ((Y : C) × { f // S f }) × (Z : C) × { g // S g }
a✝ : P.obj X.op
⊢ ((forkMap P S ≫ firstMap' P (_ : ∀ {Y Z : C} {f : Y ⟶ X}, S f → ∀ {g : Z ⟶ X}, S g → HasPullback f g)) ≫
Pi.π (fun fg => P.obj (Limits.pullback ↑fg.fst.snd ↑fg.snd.snd).op) fg)
a✝ =
((forkMap P S ≫ secondMap' P (_ : ∀ {Y Z : C} {f : Y ⟶ X}, S f → ∀ {g : Z ⟶ X}, S g → HasPullback f g)) ≫
Pi.π (fun fg => P.obj (Limits.pullback ↑fg.fst.snd ↑fg.snd.snd).op) fg)
a✝
TACTIC:
|
https://github.com/adamtopaz/CopenhagenMasterclass2023.git | a293ca1554f7e80d891fd4d86fb092c54d8a0a01 | Sieves/isSheafForPullbackSieve.lean | CategoryTheory.Equalizer.Presieve.w' | [66, 1] | [73, 7] | simp only [limit.lift_π, limit.lift_π_assoc, assoc, Fan.mk_π_app] | case h.h
C : Type u₁
inst✝ : Category C
X : C
S : Presieve X
P : Cᵒᵖ ⥤ Type (max v₁ u₁)
hS : isPullbackPresieve S
fg : ((Y : C) × { f // S f }) × (Z : C) × { g // S g }
a✝ : P.obj X.op
⊢ (((Pi.lift fun f => P.map (↑f.snd).op) ≫
Pi.lift fun fg => Pi.π (fun f => P.obj f.fst.op) fg.fst ≫ P.map pullback.fst.op) ≫
Pi.π (fun fg => P.obj (Limits.pullback ↑fg.fst.snd ↑fg.snd.snd).op) fg)
a✝ =
(((Pi.lift fun f => P.map (↑f.snd).op) ≫
Pi.lift fun fg => Pi.π (fun f => P.obj f.fst.op) fg.snd ≫ P.map pullback.snd.op) ≫
Pi.π (fun fg => P.obj (Limits.pullback ↑fg.fst.snd ↑fg.snd.snd).op) fg)
a✝ | case h.h
C : Type u₁
inst✝ : Category C
X : C
S : Presieve X
P : Cᵒᵖ ⥤ Type (max v₁ u₁)
hS : isPullbackPresieve S
fg : ((Y : C) × { f // S f }) × (Z : C) × { g // S g }
a✝ : P.obj X.op
⊢ (P.map (↑fg.fst.snd).op ≫ P.map pullback.fst.op) a✝ = (P.map (↑fg.snd.snd).op ≫ P.map pullback.snd.op) a✝ | Please generate a tactic in lean4 to solve the state.
STATE:
case h.h
C : Type u₁
inst✝ : Category C
X : C
S : Presieve X
P : Cᵒᵖ ⥤ Type (max v₁ u₁)
hS : isPullbackPresieve S
fg : ((Y : C) × { f // S f }) × (Z : C) × { g // S g }
a✝ : P.obj X.op
⊢ (((Pi.lift fun f => P.map (↑f.snd).op) ≫
Pi.lift fun fg => Pi.π (fun f => P.obj f.fst.op) fg.fst ≫ P.map pullback.fst.op) ≫
Pi.π (fun fg => P.obj (Limits.pullback ↑fg.fst.snd ↑fg.snd.snd).op) fg)
a✝ =
(((Pi.lift fun f => P.map (↑f.snd).op) ≫
Pi.lift fun fg => Pi.π (fun f => P.obj f.fst.op) fg.snd ≫ P.map pullback.snd.op) ≫
Pi.π (fun fg => P.obj (Limits.pullback ↑fg.fst.snd ↑fg.snd.snd).op) fg)
a✝
TACTIC:
|
https://github.com/adamtopaz/CopenhagenMasterclass2023.git | a293ca1554f7e80d891fd4d86fb092c54d8a0a01 | Sieves/isSheafForPullbackSieve.lean | CategoryTheory.Equalizer.Presieve.w' | [66, 1] | [73, 7] | have := hS fg.1.2.2 fg.2.2.2 | case h.h
C : Type u₁
inst✝ : Category C
X : C
S : Presieve X
P : Cᵒᵖ ⥤ Type (max v₁ u₁)
hS : isPullbackPresieve S
fg : ((Y : C) × { f // S f }) × (Z : C) × { g // S g }
a✝ : P.obj X.op
⊢ (P.map (↑fg.fst.snd).op ≫ P.map pullback.fst.op) a✝ = (P.map (↑fg.snd.snd).op ≫ P.map pullback.snd.op) a✝ | case h.h
C : Type u₁
inst✝ : Category C
X : C
S : Presieve X
P : Cᵒᵖ ⥤ Type (max v₁ u₁)
hS : isPullbackPresieve S
fg : ((Y : C) × { f // S f }) × (Z : C) × { g // S g }
a✝ : P.obj X.op
this : HasPullback ↑fg.fst.snd ↑fg.snd.snd
⊢ (P.map (↑fg.fst.snd).op ≫ P.map pullback.fst.op) a✝ = (P.map (↑fg.snd.snd).op ≫ P.map pullback.snd.op) a✝ | Please generate a tactic in lean4 to solve the state.
STATE:
case h.h
C : Type u₁
inst✝ : Category C
X : C
S : Presieve X
P : Cᵒᵖ ⥤ Type (max v₁ u₁)
hS : isPullbackPresieve S
fg : ((Y : C) × { f // S f }) × (Z : C) × { g // S g }
a✝ : P.obj X.op
⊢ (P.map (↑fg.fst.snd).op ≫ P.map pullback.fst.op) a✝ = (P.map (↑fg.snd.snd).op ≫ P.map pullback.snd.op) a✝
TACTIC:
|
https://github.com/adamtopaz/CopenhagenMasterclass2023.git | a293ca1554f7e80d891fd4d86fb092c54d8a0a01 | Sieves/isSheafForPullbackSieve.lean | CategoryTheory.Equalizer.Presieve.w' | [66, 1] | [73, 7] | rw [← P.map_comp, ← op_comp, pullback.condition] | case h.h
C : Type u₁
inst✝ : Category C
X : C
S : Presieve X
P : Cᵒᵖ ⥤ Type (max v₁ u₁)
hS : isPullbackPresieve S
fg : ((Y : C) × { f // S f }) × (Z : C) × { g // S g }
a✝ : P.obj X.op
this : HasPullback ↑fg.fst.snd ↑fg.snd.snd
⊢ (P.map (↑fg.fst.snd).op ≫ P.map pullback.fst.op) a✝ = (P.map (↑fg.snd.snd).op ≫ P.map pullback.snd.op) a✝ | case h.h
C : Type u₁
inst✝ : Category C
X : C
S : Presieve X
P : Cᵒᵖ ⥤ Type (max v₁ u₁)
hS : isPullbackPresieve S
fg : ((Y : C) × { f // S f }) × (Z : C) × { g // S g }
a✝ : P.obj X.op
this : HasPullback ↑fg.fst.snd ↑fg.snd.snd
⊢ P.map (pullback.snd ≫ ↑fg.snd.snd).op a✝ = (P.map (↑fg.snd.snd).op ≫ P.map pullback.snd.op) a✝ | Please generate a tactic in lean4 to solve the state.
STATE:
case h.h
C : Type u₁
inst✝ : Category C
X : C
S : Presieve X
P : Cᵒᵖ ⥤ Type (max v₁ u₁)
hS : isPullbackPresieve S
fg : ((Y : C) × { f // S f }) × (Z : C) × { g // S g }
a✝ : P.obj X.op
this : HasPullback ↑fg.fst.snd ↑fg.snd.snd
⊢ (P.map (↑fg.fst.snd).op ≫ P.map pullback.fst.op) a✝ = (P.map (↑fg.snd.snd).op ≫ P.map pullback.snd.op) a✝
TACTIC:
|
https://github.com/adamtopaz/CopenhagenMasterclass2023.git | a293ca1554f7e80d891fd4d86fb092c54d8a0a01 | Sieves/isSheafForPullbackSieve.lean | CategoryTheory.Equalizer.Presieve.w' | [66, 1] | [73, 7] | simp | case h.h
C : Type u₁
inst✝ : Category C
X : C
S : Presieve X
P : Cᵒᵖ ⥤ Type (max v₁ u₁)
hS : isPullbackPresieve S
fg : ((Y : C) × { f // S f }) × (Z : C) × { g // S g }
a✝ : P.obj X.op
this : HasPullback ↑fg.fst.snd ↑fg.snd.snd
⊢ P.map (pullback.snd ≫ ↑fg.snd.snd).op a✝ = (P.map (↑fg.snd.snd).op ≫ P.map pullback.snd.op) a✝ | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case h.h
C : Type u₁
inst✝ : Category C
X : C
S : Presieve X
P : Cᵒᵖ ⥤ Type (max v₁ u₁)
hS : isPullbackPresieve S
fg : ((Y : C) × { f // S f }) × (Z : C) × { g // S g }
a✝ : P.obj X.op
this : HasPullback ↑fg.fst.snd ↑fg.snd.snd
⊢ P.map (pullback.snd ≫ ↑fg.snd.snd).op a✝ = (P.map (↑fg.snd.snd).op ≫ P.map pullback.snd.op) a✝
TACTIC:
|
https://github.com/adamtopaz/CopenhagenMasterclass2023.git | a293ca1554f7e80d891fd4d86fb092c54d8a0a01 | Sieves/isSheafForPullbackSieve.lean | CategoryTheory.Equalizer.Presieve.compatible_iff' | [79, 1] | [89, 67] | rw [Presieve.pullbackCompatible_iff' _ hS] | C : Type u₁
inst✝ : Category C
X : C
S : Presieve X
P : Cᵒᵖ ⥤ Type (max v₁ u₁)
hS : isPullbackPresieve S
x : FirstObj P S
⊢ Presieve.FamilyOfElements.Compatible ((firstObjEqFamily P S).hom x) ↔
firstMap' P (_ : ∀ {Y Z : C} {f : Y ⟶ X}, S f → ∀ {g : Z ⟶ X}, S g → HasPullback f g) x =
secondMap' P (_ : ∀ {Y Z : C} {f : Y ⟶ X}, S f → ∀ {g : Z ⟶ X}, S g → HasPullback f g) x | C : Type u₁
inst✝ : Category C
X : C
S : Presieve X
P : Cᵒᵖ ⥤ Type (max v₁ u₁)
hS : isPullbackPresieve S
x : FirstObj P S
⊢ Presieve.FamilyOfElements.PullbackCompatible' P
(_ : ∀ {Y Z : C} {f : Y ⟶ X}, S f → ∀ {g : Z ⟶ X}, S g → HasPullback f g) ((firstObjEqFamily P S).hom x) ↔
firstMap' P (_ : ∀ {Y Z : C} {f : Y ⟶ X}, S f → ∀ {g : Z ⟶ X}, S g → HasPullback f g) x =
secondMap' P (_ : ∀ {Y Z : C} {f : Y ⟶ X}, S f → ∀ {g : Z ⟶ X}, S g → HasPullback f g) x | Please generate a tactic in lean4 to solve the state.
STATE:
C : Type u₁
inst✝ : Category C
X : C
S : Presieve X
P : Cᵒᵖ ⥤ Type (max v₁ u₁)
hS : isPullbackPresieve S
x : FirstObj P S
⊢ Presieve.FamilyOfElements.Compatible ((firstObjEqFamily P S).hom x) ↔
firstMap' P (_ : ∀ {Y Z : C} {f : Y ⟶ X}, S f → ∀ {g : Z ⟶ X}, S g → HasPullback f g) x =
secondMap' P (_ : ∀ {Y Z : C} {f : Y ⟶ X}, S f → ∀ {g : Z ⟶ X}, S g → HasPullback f g) x
TACTIC:
|
https://github.com/adamtopaz/CopenhagenMasterclass2023.git | a293ca1554f7e80d891fd4d86fb092c54d8a0a01 | Sieves/isSheafForPullbackSieve.lean | CategoryTheory.Equalizer.Presieve.compatible_iff' | [79, 1] | [89, 67] | constructor | C : Type u₁
inst✝ : Category C
X : C
S : Presieve X
P : Cᵒᵖ ⥤ Type (max v₁ u₁)
hS : isPullbackPresieve S
x : FirstObj P S
⊢ Presieve.FamilyOfElements.PullbackCompatible' P
(_ : ∀ {Y Z : C} {f : Y ⟶ X}, S f → ∀ {g : Z ⟶ X}, S g → HasPullback f g) ((firstObjEqFamily P S).hom x) ↔
firstMap' P (_ : ∀ {Y Z : C} {f : Y ⟶ X}, S f → ∀ {g : Z ⟶ X}, S g → HasPullback f g) x =
secondMap' P (_ : ∀ {Y Z : C} {f : Y ⟶ X}, S f → ∀ {g : Z ⟶ X}, S g → HasPullback f g) x | case mp
C : Type u₁
inst✝ : Category C
X : C
S : Presieve X
P : Cᵒᵖ ⥤ Type (max v₁ u₁)
hS : isPullbackPresieve S
x : FirstObj P S
⊢ Presieve.FamilyOfElements.PullbackCompatible' P
(_ : ∀ {Y Z : C} {f : Y ⟶ X}, S f → ∀ {g : Z ⟶ X}, S g → HasPullback f g) ((firstObjEqFamily P S).hom x) →
firstMap' P (_ : ∀ {Y Z : C} {f : Y ⟶ X}, S f → ∀ {g : Z ⟶ X}, S g → HasPullback f g) x =
secondMap' P (_ : ∀ {Y Z : C} {f : Y ⟶ X}, S f → ∀ {g : Z ⟶ X}, S g → HasPullback f g) x
case mpr
C : Type u₁
inst✝ : Category C
X : C
S : Presieve X
P : Cᵒᵖ ⥤ Type (max v₁ u₁)
hS : isPullbackPresieve S
x : FirstObj P S
⊢ firstMap' P (_ : ∀ {Y Z : C} {f : Y ⟶ X}, S f → ∀ {g : Z ⟶ X}, S g → HasPullback f g) x =
secondMap' P (_ : ∀ {Y Z : C} {f : Y ⟶ X}, S f → ∀ {g : Z ⟶ X}, S g → HasPullback f g) x →
Presieve.FamilyOfElements.PullbackCompatible' P
(_ : ∀ {Y Z : C} {f : Y ⟶ X}, S f → ∀ {g : Z ⟶ X}, S g → HasPullback f g) ((firstObjEqFamily P S).hom x) | Please generate a tactic in lean4 to solve the state.
STATE:
C : Type u₁
inst✝ : Category C
X : C
S : Presieve X
P : Cᵒᵖ ⥤ Type (max v₁ u₁)
hS : isPullbackPresieve S
x : FirstObj P S
⊢ Presieve.FamilyOfElements.PullbackCompatible' P
(_ : ∀ {Y Z : C} {f : Y ⟶ X}, S f → ∀ {g : Z ⟶ X}, S g → HasPullback f g) ((firstObjEqFamily P S).hom x) ↔
firstMap' P (_ : ∀ {Y Z : C} {f : Y ⟶ X}, S f → ∀ {g : Z ⟶ X}, S g → HasPullback f g) x =
secondMap' P (_ : ∀ {Y Z : C} {f : Y ⟶ X}, S f → ∀ {g : Z ⟶ X}, S g → HasPullback f g) x
TACTIC:
|
https://github.com/adamtopaz/CopenhagenMasterclass2023.git | a293ca1554f7e80d891fd4d86fb092c54d8a0a01 | Sieves/isSheafForPullbackSieve.lean | CategoryTheory.Equalizer.Presieve.compatible_iff' | [79, 1] | [89, 67] | . intro t
apply Limits.Types.limit_ext.{max u₁ v₁, u₁}
rintro ⟨⟨Y, f, hf⟩, Z, g, hg⟩
simpa [firstMap', secondMap'] using t hf hg | case mp
C : Type u₁
inst✝ : Category C
X : C
S : Presieve X
P : Cᵒᵖ ⥤ Type (max v₁ u₁)
hS : isPullbackPresieve S
x : FirstObj P S
⊢ Presieve.FamilyOfElements.PullbackCompatible' P
(_ : ∀ {Y Z : C} {f : Y ⟶ X}, S f → ∀ {g : Z ⟶ X}, S g → HasPullback f g) ((firstObjEqFamily P S).hom x) →
firstMap' P (_ : ∀ {Y Z : C} {f : Y ⟶ X}, S f → ∀ {g : Z ⟶ X}, S g → HasPullback f g) x =
secondMap' P (_ : ∀ {Y Z : C} {f : Y ⟶ X}, S f → ∀ {g : Z ⟶ X}, S g → HasPullback f g) x
case mpr
C : Type u₁
inst✝ : Category C
X : C
S : Presieve X
P : Cᵒᵖ ⥤ Type (max v₁ u₁)
hS : isPullbackPresieve S
x : FirstObj P S
⊢ firstMap' P (_ : ∀ {Y Z : C} {f : Y ⟶ X}, S f → ∀ {g : Z ⟶ X}, S g → HasPullback f g) x =
secondMap' P (_ : ∀ {Y Z : C} {f : Y ⟶ X}, S f → ∀ {g : Z ⟶ X}, S g → HasPullback f g) x →
Presieve.FamilyOfElements.PullbackCompatible' P
(_ : ∀ {Y Z : C} {f : Y ⟶ X}, S f → ∀ {g : Z ⟶ X}, S g → HasPullback f g) ((firstObjEqFamily P S).hom x) | case mpr
C : Type u₁
inst✝ : Category C
X : C
S : Presieve X
P : Cᵒᵖ ⥤ Type (max v₁ u₁)
hS : isPullbackPresieve S
x : FirstObj P S
⊢ firstMap' P (_ : ∀ {Y Z : C} {f : Y ⟶ X}, S f → ∀ {g : Z ⟶ X}, S g → HasPullback f g) x =
secondMap' P (_ : ∀ {Y Z : C} {f : Y ⟶ X}, S f → ∀ {g : Z ⟶ X}, S g → HasPullback f g) x →
Presieve.FamilyOfElements.PullbackCompatible' P
(_ : ∀ {Y Z : C} {f : Y ⟶ X}, S f → ∀ {g : Z ⟶ X}, S g → HasPullback f g) ((firstObjEqFamily P S).hom x) | Please generate a tactic in lean4 to solve the state.
STATE:
case mp
C : Type u₁
inst✝ : Category C
X : C
S : Presieve X
P : Cᵒᵖ ⥤ Type (max v₁ u₁)
hS : isPullbackPresieve S
x : FirstObj P S
⊢ Presieve.FamilyOfElements.PullbackCompatible' P
(_ : ∀ {Y Z : C} {f : Y ⟶ X}, S f → ∀ {g : Z ⟶ X}, S g → HasPullback f g) ((firstObjEqFamily P S).hom x) →
firstMap' P (_ : ∀ {Y Z : C} {f : Y ⟶ X}, S f → ∀ {g : Z ⟶ X}, S g → HasPullback f g) x =
secondMap' P (_ : ∀ {Y Z : C} {f : Y ⟶ X}, S f → ∀ {g : Z ⟶ X}, S g → HasPullback f g) x
case mpr
C : Type u₁
inst✝ : Category C
X : C
S : Presieve X
P : Cᵒᵖ ⥤ Type (max v₁ u₁)
hS : isPullbackPresieve S
x : FirstObj P S
⊢ firstMap' P (_ : ∀ {Y Z : C} {f : Y ⟶ X}, S f → ∀ {g : Z ⟶ X}, S g → HasPullback f g) x =
secondMap' P (_ : ∀ {Y Z : C} {f : Y ⟶ X}, S f → ∀ {g : Z ⟶ X}, S g → HasPullback f g) x →
Presieve.FamilyOfElements.PullbackCompatible' P
(_ : ∀ {Y Z : C} {f : Y ⟶ X}, S f → ∀ {g : Z ⟶ X}, S g → HasPullback f g) ((firstObjEqFamily P S).hom x)
TACTIC:
|
https://github.com/adamtopaz/CopenhagenMasterclass2023.git | a293ca1554f7e80d891fd4d86fb092c54d8a0a01 | Sieves/isSheafForPullbackSieve.lean | CategoryTheory.Equalizer.Presieve.compatible_iff' | [79, 1] | [89, 67] | intro t | case mp
C : Type u₁
inst✝ : Category C
X : C
S : Presieve X
P : Cᵒᵖ ⥤ Type (max v₁ u₁)
hS : isPullbackPresieve S
x : FirstObj P S
⊢ Presieve.FamilyOfElements.PullbackCompatible' P
(_ : ∀ {Y Z : C} {f : Y ⟶ X}, S f → ∀ {g : Z ⟶ X}, S g → HasPullback f g) ((firstObjEqFamily P S).hom x) →
firstMap' P (_ : ∀ {Y Z : C} {f : Y ⟶ X}, S f → ∀ {g : Z ⟶ X}, S g → HasPullback f g) x =
secondMap' P (_ : ∀ {Y Z : C} {f : Y ⟶ X}, S f → ∀ {g : Z ⟶ X}, S g → HasPullback f g) x | case mp
C : Type u₁
inst✝ : Category C
X : C
S : Presieve X
P : Cᵒᵖ ⥤ Type (max v₁ u₁)
hS : isPullbackPresieve S
x : FirstObj P S
t :
Presieve.FamilyOfElements.PullbackCompatible' P
(_ : ∀ {Y Z : C} {f : Y ⟶ X}, S f → ∀ {g : Z ⟶ X}, S g → HasPullback f g) ((firstObjEqFamily P S).hom x)
⊢ firstMap' P (_ : ∀ {Y Z : C} {f : Y ⟶ X}, S f → ∀ {g : Z ⟶ X}, S g → HasPullback f g) x =
secondMap' P (_ : ∀ {Y Z : C} {f : Y ⟶ X}, S f → ∀ {g : Z ⟶ X}, S g → HasPullback f g) x | Please generate a tactic in lean4 to solve the state.
STATE:
case mp
C : Type u₁
inst✝ : Category C
X : C
S : Presieve X
P : Cᵒᵖ ⥤ Type (max v₁ u₁)
hS : isPullbackPresieve S
x : FirstObj P S
⊢ Presieve.FamilyOfElements.PullbackCompatible' P
(_ : ∀ {Y Z : C} {f : Y ⟶ X}, S f → ∀ {g : Z ⟶ X}, S g → HasPullback f g) ((firstObjEqFamily P S).hom x) →
firstMap' P (_ : ∀ {Y Z : C} {f : Y ⟶ X}, S f → ∀ {g : Z ⟶ X}, S g → HasPullback f g) x =
secondMap' P (_ : ∀ {Y Z : C} {f : Y ⟶ X}, S f → ∀ {g : Z ⟶ X}, S g → HasPullback f g) x
TACTIC:
|
https://github.com/adamtopaz/CopenhagenMasterclass2023.git | a293ca1554f7e80d891fd4d86fb092c54d8a0a01 | Sieves/isSheafForPullbackSieve.lean | CategoryTheory.Equalizer.Presieve.compatible_iff' | [79, 1] | [89, 67] | apply Limits.Types.limit_ext.{max u₁ v₁, u₁} | case mp
C : Type u₁
inst✝ : Category C
X : C
S : Presieve X
P : Cᵒᵖ ⥤ Type (max v₁ u₁)
hS : isPullbackPresieve S
x : FirstObj P S
t :
Presieve.FamilyOfElements.PullbackCompatible' P
(_ : ∀ {Y Z : C} {f : Y ⟶ X}, S f → ∀ {g : Z ⟶ X}, S g → HasPullback f g) ((firstObjEqFamily P S).hom x)
⊢ firstMap' P (_ : ∀ {Y Z : C} {f : Y ⟶ X}, S f → ∀ {g : Z ⟶ X}, S g → HasPullback f g) x =
secondMap' P (_ : ∀ {Y Z : C} {f : Y ⟶ X}, S f → ∀ {g : Z ⟶ X}, S g → HasPullback f g) x | case mp.w
C : Type u₁
inst✝ : Category C
X : C
S : Presieve X
P : Cᵒᵖ ⥤ Type (max v₁ u₁)
hS : isPullbackPresieve S
x : FirstObj P S
t :
Presieve.FamilyOfElements.PullbackCompatible' P
(_ : ∀ {Y Z : C} {f : Y ⟶ X}, S f → ∀ {g : Z ⟶ X}, S g → HasPullback f g) ((firstObjEqFamily P S).hom x)
⊢ ∀ (j : Discrete (((Y : C) × Subtype fun f {Y} {f} => S f) × (Z : C) × Subtype fun g {Y} {f} => S f)),
limit.π
(Discrete.functor fun fg =>
let_fun this := (_ : HasPullback ↑fg.fst.snd ↑fg.snd.snd);
P.obj (Limits.pullback ↑fg.fst.snd ↑fg.snd.snd).op)
j (firstMap' P (_ : ∀ {Y Z : C} {f : Y ⟶ X}, S f → ∀ {g : Z ⟶ X}, S g → HasPullback f g) x) =
limit.π
(Discrete.functor fun fg =>
let_fun this := (_ : HasPullback ↑fg.fst.snd ↑fg.snd.snd);
P.obj (Limits.pullback ↑fg.fst.snd ↑fg.snd.snd).op)
j (secondMap' P (_ : ∀ {Y Z : C} {f : Y ⟶ X}, S f → ∀ {g : Z ⟶ X}, S g → HasPullback f g) x) | Please generate a tactic in lean4 to solve the state.
STATE:
case mp
C : Type u₁
inst✝ : Category C
X : C
S : Presieve X
P : Cᵒᵖ ⥤ Type (max v₁ u₁)
hS : isPullbackPresieve S
x : FirstObj P S
t :
Presieve.FamilyOfElements.PullbackCompatible' P
(_ : ∀ {Y Z : C} {f : Y ⟶ X}, S f → ∀ {g : Z ⟶ X}, S g → HasPullback f g) ((firstObjEqFamily P S).hom x)
⊢ firstMap' P (_ : ∀ {Y Z : C} {f : Y ⟶ X}, S f → ∀ {g : Z ⟶ X}, S g → HasPullback f g) x =
secondMap' P (_ : ∀ {Y Z : C} {f : Y ⟶ X}, S f → ∀ {g : Z ⟶ X}, S g → HasPullback f g) x
TACTIC:
|
https://github.com/adamtopaz/CopenhagenMasterclass2023.git | a293ca1554f7e80d891fd4d86fb092c54d8a0a01 | Sieves/isSheafForPullbackSieve.lean | CategoryTheory.Equalizer.Presieve.compatible_iff' | [79, 1] | [89, 67] | rintro ⟨⟨Y, f, hf⟩, Z, g, hg⟩ | case mp.w
C : Type u₁
inst✝ : Category C
X : C
S : Presieve X
P : Cᵒᵖ ⥤ Type (max v₁ u₁)
hS : isPullbackPresieve S
x : FirstObj P S
t :
Presieve.FamilyOfElements.PullbackCompatible' P
(_ : ∀ {Y Z : C} {f : Y ⟶ X}, S f → ∀ {g : Z ⟶ X}, S g → HasPullback f g) ((firstObjEqFamily P S).hom x)
⊢ ∀ (j : Discrete (((Y : C) × Subtype fun f {Y} {f} => S f) × (Z : C) × Subtype fun g {Y} {f} => S f)),
limit.π
(Discrete.functor fun fg =>
let_fun this := (_ : HasPullback ↑fg.fst.snd ↑fg.snd.snd);
P.obj (Limits.pullback ↑fg.fst.snd ↑fg.snd.snd).op)
j (firstMap' P (_ : ∀ {Y Z : C} {f : Y ⟶ X}, S f → ∀ {g : Z ⟶ X}, S g → HasPullback f g) x) =
limit.π
(Discrete.functor fun fg =>
let_fun this := (_ : HasPullback ↑fg.fst.snd ↑fg.snd.snd);
P.obj (Limits.pullback ↑fg.fst.snd ↑fg.snd.snd).op)
j (secondMap' P (_ : ∀ {Y Z : C} {f : Y ⟶ X}, S f → ∀ {g : Z ⟶ X}, S g → HasPullback f g) x) | case mp.w.mk.mk.mk.mk.mk.mk
C : Type u₁
inst✝ : Category C
X : C
S : Presieve X
P : Cᵒᵖ ⥤ Type (max v₁ u₁)
hS : isPullbackPresieve S
x : FirstObj P S
t :
Presieve.FamilyOfElements.PullbackCompatible' P
(_ : ∀ {Y Z : C} {f : Y ⟶ X}, S f → ∀ {g : Z ⟶ X}, S g → HasPullback f g) ((firstObjEqFamily P S).hom x)
Y : C
f : Y ⟶ X
hf : S f
Z : C
g : Z ⟶ X
hg : S g
⊢ limit.π
(Discrete.functor fun fg =>
let_fun this := (_ : HasPullback ↑fg.fst.snd ↑fg.snd.snd);
P.obj (Limits.pullback ↑fg.fst.snd ↑fg.snd.snd).op)
{ as := ({ fst := Y, snd := { val := f, property := hf } }, { fst := Z, snd := { val := g, property := hg } }) }
(firstMap' P (_ : ∀ {Y Z : C} {f : Y ⟶ X}, S f → ∀ {g : Z ⟶ X}, S g → HasPullback f g) x) =
limit.π
(Discrete.functor fun fg =>
let_fun this := (_ : HasPullback ↑fg.fst.snd ↑fg.snd.snd);
P.obj (Limits.pullback ↑fg.fst.snd ↑fg.snd.snd).op)
{ as := ({ fst := Y, snd := { val := f, property := hf } }, { fst := Z, snd := { val := g, property := hg } }) }
(secondMap' P (_ : ∀ {Y Z : C} {f : Y ⟶ X}, S f → ∀ {g : Z ⟶ X}, S g → HasPullback f g) x) | Please generate a tactic in lean4 to solve the state.
STATE:
case mp.w
C : Type u₁
inst✝ : Category C
X : C
S : Presieve X
P : Cᵒᵖ ⥤ Type (max v₁ u₁)
hS : isPullbackPresieve S
x : FirstObj P S
t :
Presieve.FamilyOfElements.PullbackCompatible' P
(_ : ∀ {Y Z : C} {f : Y ⟶ X}, S f → ∀ {g : Z ⟶ X}, S g → HasPullback f g) ((firstObjEqFamily P S).hom x)
⊢ ∀ (j : Discrete (((Y : C) × Subtype fun f {Y} {f} => S f) × (Z : C) × Subtype fun g {Y} {f} => S f)),
limit.π
(Discrete.functor fun fg =>
let_fun this := (_ : HasPullback ↑fg.fst.snd ↑fg.snd.snd);
P.obj (Limits.pullback ↑fg.fst.snd ↑fg.snd.snd).op)
j (firstMap' P (_ : ∀ {Y Z : C} {f : Y ⟶ X}, S f → ∀ {g : Z ⟶ X}, S g → HasPullback f g) x) =
limit.π
(Discrete.functor fun fg =>
let_fun this := (_ : HasPullback ↑fg.fst.snd ↑fg.snd.snd);
P.obj (Limits.pullback ↑fg.fst.snd ↑fg.snd.snd).op)
j (secondMap' P (_ : ∀ {Y Z : C} {f : Y ⟶ X}, S f → ∀ {g : Z ⟶ X}, S g → HasPullback f g) x)
TACTIC:
|
https://github.com/adamtopaz/CopenhagenMasterclass2023.git | a293ca1554f7e80d891fd4d86fb092c54d8a0a01 | Sieves/isSheafForPullbackSieve.lean | CategoryTheory.Equalizer.Presieve.compatible_iff' | [79, 1] | [89, 67] | simpa [firstMap', secondMap'] using t hf hg | case mp.w.mk.mk.mk.mk.mk.mk
C : Type u₁
inst✝ : Category C
X : C
S : Presieve X
P : Cᵒᵖ ⥤ Type (max v₁ u₁)
hS : isPullbackPresieve S
x : FirstObj P S
t :
Presieve.FamilyOfElements.PullbackCompatible' P
(_ : ∀ {Y Z : C} {f : Y ⟶ X}, S f → ∀ {g : Z ⟶ X}, S g → HasPullback f g) ((firstObjEqFamily P S).hom x)
Y : C
f : Y ⟶ X
hf : S f
Z : C
g : Z ⟶ X
hg : S g
⊢ limit.π
(Discrete.functor fun fg =>
let_fun this := (_ : HasPullback ↑fg.fst.snd ↑fg.snd.snd);
P.obj (Limits.pullback ↑fg.fst.snd ↑fg.snd.snd).op)
{ as := ({ fst := Y, snd := { val := f, property := hf } }, { fst := Z, snd := { val := g, property := hg } }) }
(firstMap' P (_ : ∀ {Y Z : C} {f : Y ⟶ X}, S f → ∀ {g : Z ⟶ X}, S g → HasPullback f g) x) =
limit.π
(Discrete.functor fun fg =>
let_fun this := (_ : HasPullback ↑fg.fst.snd ↑fg.snd.snd);
P.obj (Limits.pullback ↑fg.fst.snd ↑fg.snd.snd).op)
{ as := ({ fst := Y, snd := { val := f, property := hf } }, { fst := Z, snd := { val := g, property := hg } }) }
(secondMap' P (_ : ∀ {Y Z : C} {f : Y ⟶ X}, S f → ∀ {g : Z ⟶ X}, S g → HasPullback f g) x) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case mp.w.mk.mk.mk.mk.mk.mk
C : Type u₁
inst✝ : Category C
X : C
S : Presieve X
P : Cᵒᵖ ⥤ Type (max v₁ u₁)
hS : isPullbackPresieve S
x : FirstObj P S
t :
Presieve.FamilyOfElements.PullbackCompatible' P
(_ : ∀ {Y Z : C} {f : Y ⟶ X}, S f → ∀ {g : Z ⟶ X}, S g → HasPullback f g) ((firstObjEqFamily P S).hom x)
Y : C
f : Y ⟶ X
hf : S f
Z : C
g : Z ⟶ X
hg : S g
⊢ limit.π
(Discrete.functor fun fg =>
let_fun this := (_ : HasPullback ↑fg.fst.snd ↑fg.snd.snd);
P.obj (Limits.pullback ↑fg.fst.snd ↑fg.snd.snd).op)
{ as := ({ fst := Y, snd := { val := f, property := hf } }, { fst := Z, snd := { val := g, property := hg } }) }
(firstMap' P (_ : ∀ {Y Z : C} {f : Y ⟶ X}, S f → ∀ {g : Z ⟶ X}, S g → HasPullback f g) x) =
limit.π
(Discrete.functor fun fg =>
let_fun this := (_ : HasPullback ↑fg.fst.snd ↑fg.snd.snd);
P.obj (Limits.pullback ↑fg.fst.snd ↑fg.snd.snd).op)
{ as := ({ fst := Y, snd := { val := f, property := hf } }, { fst := Z, snd := { val := g, property := hg } }) }
(secondMap' P (_ : ∀ {Y Z : C} {f : Y ⟶ X}, S f → ∀ {g : Z ⟶ X}, S g → HasPullback f g) x)
TACTIC:
|
https://github.com/adamtopaz/CopenhagenMasterclass2023.git | a293ca1554f7e80d891fd4d86fb092c54d8a0a01 | Sieves/isSheafForPullbackSieve.lean | CategoryTheory.Equalizer.Presieve.compatible_iff' | [79, 1] | [89, 67] | intro t Y Z f g hf hg | case mpr
C : Type u₁
inst✝ : Category C
X : C
S : Presieve X
P : Cᵒᵖ ⥤ Type (max v₁ u₁)
hS : isPullbackPresieve S
x : FirstObj P S
⊢ firstMap' P (_ : ∀ {Y Z : C} {f : Y ⟶ X}, S f → ∀ {g : Z ⟶ X}, S g → HasPullback f g) x =
secondMap' P (_ : ∀ {Y Z : C} {f : Y ⟶ X}, S f → ∀ {g : Z ⟶ X}, S g → HasPullback f g) x →
Presieve.FamilyOfElements.PullbackCompatible' P
(_ : ∀ {Y Z : C} {f : Y ⟶ X}, S f → ∀ {g : Z ⟶ X}, S g → HasPullback f g) ((firstObjEqFamily P S).hom x) | case mpr
C : Type u₁
inst✝ : Category C
X : C
S : Presieve X
P : Cᵒᵖ ⥤ Type (max v₁ u₁)
hS : isPullbackPresieve S
x : FirstObj P S
t :
firstMap' P (_ : ∀ {Y Z : C} {f : Y ⟶ X}, S f → ∀ {g : Z ⟶ X}, S g → HasPullback f g) x =
secondMap' P (_ : ∀ {Y Z : C} {f : Y ⟶ X}, S f → ∀ {g : Z ⟶ X}, S g → HasPullback f g) x
Y Z : C
f : Y ⟶ X
g : Z ⟶ X
hf : S f
hg : S g
⊢ let_fun this := (_ : HasPullback f g);
P.map pullback.fst.op ((firstObjEqFamily P S).hom x f hf) = P.map pullback.snd.op ((firstObjEqFamily P S).hom x g hg) | Please generate a tactic in lean4 to solve the state.
STATE:
case mpr
C : Type u₁
inst✝ : Category C
X : C
S : Presieve X
P : Cᵒᵖ ⥤ Type (max v₁ u₁)
hS : isPullbackPresieve S
x : FirstObj P S
⊢ firstMap' P (_ : ∀ {Y Z : C} {f : Y ⟶ X}, S f → ∀ {g : Z ⟶ X}, S g → HasPullback f g) x =
secondMap' P (_ : ∀ {Y Z : C} {f : Y ⟶ X}, S f → ∀ {g : Z ⟶ X}, S g → HasPullback f g) x →
Presieve.FamilyOfElements.PullbackCompatible' P
(_ : ∀ {Y Z : C} {f : Y ⟶ X}, S f → ∀ {g : Z ⟶ X}, S g → HasPullback f g) ((firstObjEqFamily P S).hom x)
TACTIC:
|
https://github.com/adamtopaz/CopenhagenMasterclass2023.git | a293ca1554f7e80d891fd4d86fb092c54d8a0a01 | Sieves/isSheafForPullbackSieve.lean | CategoryTheory.Equalizer.Presieve.compatible_iff' | [79, 1] | [89, 67] | rw [Types.limit_ext_iff'] at t | case mpr
C : Type u₁
inst✝ : Category C
X : C
S : Presieve X
P : Cᵒᵖ ⥤ Type (max v₁ u₁)
hS : isPullbackPresieve S
x : FirstObj P S
t :
firstMap' P (_ : ∀ {Y Z : C} {f : Y ⟶ X}, S f → ∀ {g : Z ⟶ X}, S g → HasPullback f g) x =
secondMap' P (_ : ∀ {Y Z : C} {f : Y ⟶ X}, S f → ∀ {g : Z ⟶ X}, S g → HasPullback f g) x
Y Z : C
f : Y ⟶ X
g : Z ⟶ X
hf : S f
hg : S g
⊢ let_fun this := (_ : HasPullback f g);
P.map pullback.fst.op ((firstObjEqFamily P S).hom x f hf) = P.map pullback.snd.op ((firstObjEqFamily P S).hom x g hg) | case mpr
C : Type u₁
inst✝ : Category C
X : C
S : Presieve X
P : Cᵒᵖ ⥤ Type (max v₁ u₁)
hS : isPullbackPresieve S
x : FirstObj P S
t :
∀ (j : Discrete (((Y : C) × Subtype fun f {Y} {f} => S f) × (Z : C) × Subtype fun g {Y} {f} => S f)),
limit.π
(Discrete.functor fun fg =>
let_fun this := (_ : HasPullback ↑fg.fst.snd ↑fg.snd.snd);
P.obj (Limits.pullback ↑fg.fst.snd ↑fg.snd.snd).op)
j (firstMap' P (_ : ∀ {Y Z : C} {f : Y ⟶ X}, S f → ∀ {g : Z ⟶ X}, S g → HasPullback f g) x) =
limit.π
(Discrete.functor fun fg =>
let_fun this := (_ : HasPullback ↑fg.fst.snd ↑fg.snd.snd);
P.obj (Limits.pullback ↑fg.fst.snd ↑fg.snd.snd).op)
j (secondMap' P (_ : ∀ {Y Z : C} {f : Y ⟶ X}, S f → ∀ {g : Z ⟶ X}, S g → HasPullback f g) x)
Y Z : C
f : Y ⟶ X
g : Z ⟶ X
hf : S f
hg : S g
⊢ let_fun this := (_ : HasPullback f g);
P.map pullback.fst.op ((firstObjEqFamily P S).hom x f hf) = P.map pullback.snd.op ((firstObjEqFamily P S).hom x g hg) | Please generate a tactic in lean4 to solve the state.
STATE:
case mpr
C : Type u₁
inst✝ : Category C
X : C
S : Presieve X
P : Cᵒᵖ ⥤ Type (max v₁ u₁)
hS : isPullbackPresieve S
x : FirstObj P S
t :
firstMap' P (_ : ∀ {Y Z : C} {f : Y ⟶ X}, S f → ∀ {g : Z ⟶ X}, S g → HasPullback f g) x =
secondMap' P (_ : ∀ {Y Z : C} {f : Y ⟶ X}, S f → ∀ {g : Z ⟶ X}, S g → HasPullback f g) x
Y Z : C
f : Y ⟶ X
g : Z ⟶ X
hf : S f
hg : S g
⊢ let_fun this := (_ : HasPullback f g);
P.map pullback.fst.op ((firstObjEqFamily P S).hom x f hf) = P.map pullback.snd.op ((firstObjEqFamily P S).hom x g hg)
TACTIC:
|
https://github.com/adamtopaz/CopenhagenMasterclass2023.git | a293ca1554f7e80d891fd4d86fb092c54d8a0a01 | Sieves/isSheafForPullbackSieve.lean | CategoryTheory.Equalizer.Presieve.compatible_iff' | [79, 1] | [89, 67] | simpa [firstMap', secondMap'] using t ⟨⟨⟨Y, f, hf⟩, Z, g, hg⟩⟩ | case mpr
C : Type u₁
inst✝ : Category C
X : C
S : Presieve X
P : Cᵒᵖ ⥤ Type (max v₁ u₁)
hS : isPullbackPresieve S
x : FirstObj P S
t :
∀ (j : Discrete (((Y : C) × Subtype fun f {Y} {f} => S f) × (Z : C) × Subtype fun g {Y} {f} => S f)),
limit.π
(Discrete.functor fun fg =>
let_fun this := (_ : HasPullback ↑fg.fst.snd ↑fg.snd.snd);
P.obj (Limits.pullback ↑fg.fst.snd ↑fg.snd.snd).op)
j (firstMap' P (_ : ∀ {Y Z : C} {f : Y ⟶ X}, S f → ∀ {g : Z ⟶ X}, S g → HasPullback f g) x) =
limit.π
(Discrete.functor fun fg =>
let_fun this := (_ : HasPullback ↑fg.fst.snd ↑fg.snd.snd);
P.obj (Limits.pullback ↑fg.fst.snd ↑fg.snd.snd).op)
j (secondMap' P (_ : ∀ {Y Z : C} {f : Y ⟶ X}, S f → ∀ {g : Z ⟶ X}, S g → HasPullback f g) x)
Y Z : C
f : Y ⟶ X
g : Z ⟶ X
hf : S f
hg : S g
⊢ let_fun this := (_ : HasPullback f g);
P.map pullback.fst.op ((firstObjEqFamily P S).hom x f hf) = P.map pullback.snd.op ((firstObjEqFamily P S).hom x g hg) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case mpr
C : Type u₁
inst✝ : Category C
X : C
S : Presieve X
P : Cᵒᵖ ⥤ Type (max v₁ u₁)
hS : isPullbackPresieve S
x : FirstObj P S
t :
∀ (j : Discrete (((Y : C) × Subtype fun f {Y} {f} => S f) × (Z : C) × Subtype fun g {Y} {f} => S f)),
limit.π
(Discrete.functor fun fg =>
let_fun this := (_ : HasPullback ↑fg.fst.snd ↑fg.snd.snd);
P.obj (Limits.pullback ↑fg.fst.snd ↑fg.snd.snd).op)
j (firstMap' P (_ : ∀ {Y Z : C} {f : Y ⟶ X}, S f → ∀ {g : Z ⟶ X}, S g → HasPullback f g) x) =
limit.π
(Discrete.functor fun fg =>
let_fun this := (_ : HasPullback ↑fg.fst.snd ↑fg.snd.snd);
P.obj (Limits.pullback ↑fg.fst.snd ↑fg.snd.snd).op)
j (secondMap' P (_ : ∀ {Y Z : C} {f : Y ⟶ X}, S f → ∀ {g : Z ⟶ X}, S g → HasPullback f g) x)
Y Z : C
f : Y ⟶ X
g : Z ⟶ X
hf : S f
hg : S g
⊢ let_fun this := (_ : HasPullback f g);
P.map pullback.fst.op ((firstObjEqFamily P S).hom x f hf) = P.map pullback.snd.op ((firstObjEqFamily P S).hom x g hg)
TACTIC:
|
https://github.com/adamtopaz/CopenhagenMasterclass2023.git | a293ca1554f7e80d891fd4d86fb092c54d8a0a01 | Sieves/isSheafForPullbackSieve.lean | CategoryTheory.Equalizer.Presieve.sheaf_condition' | [94, 1] | [109, 19] | rw [Types.type_equalizer_iff_unique] | C : Type u₁
inst✝ : Category C
X : C
S : Presieve X
P : Cᵒᵖ ⥤ Type (max v₁ u₁)
hS : isPullbackPresieve S
⊢ Presieve.IsSheafFor P S ↔
Nonempty
(IsLimit
(Fork.ofι (forkMap P fun {Y} {f} => S f)
(_ :
(forkMap P fun {Y} {f} => S f) ≫
firstMap' P (_ : ∀ {Y Z : C} {f : Y ⟶ X}, S f → ∀ {g : Z ⟶ X}, S g → HasPullback f g) =
(forkMap P fun {Y} {f} => S f) ≫
secondMap' P (_ : ∀ {Y Z : C} {f : Y ⟶ X}, S f → ∀ {g : Z ⟶ X}, S g → HasPullback f g)))) | C : Type u₁
inst✝ : Category C
X : C
S : Presieve X
P : Cᵒᵖ ⥤ Type (max v₁ u₁)
hS : isPullbackPresieve S
⊢ Presieve.IsSheafFor P S ↔
∀ (y : FirstObj P fun {Y} {f} => S f),
firstMap' P (_ : ∀ {Y Z : C} {f : Y ⟶ X}, S f → ∀ {g : Z ⟶ X}, S g → HasPullback f g) y =
secondMap' P (_ : ∀ {Y Z : C} {f : Y ⟶ X}, S f → ∀ {g : Z ⟶ X}, S g → HasPullback f g) y →
∃! x, forkMap P (fun {Y} {f} => S f) x = y | Please generate a tactic in lean4 to solve the state.
STATE:
C : Type u₁
inst✝ : Category C
X : C
S : Presieve X
P : Cᵒᵖ ⥤ Type (max v₁ u₁)
hS : isPullbackPresieve S
⊢ Presieve.IsSheafFor P S ↔
Nonempty
(IsLimit
(Fork.ofι (forkMap P fun {Y} {f} => S f)
(_ :
(forkMap P fun {Y} {f} => S f) ≫
firstMap' P (_ : ∀ {Y Z : C} {f : Y ⟶ X}, S f → ∀ {g : Z ⟶ X}, S g → HasPullback f g) =
(forkMap P fun {Y} {f} => S f) ≫
secondMap' P (_ : ∀ {Y Z : C} {f : Y ⟶ X}, S f → ∀ {g : Z ⟶ X}, S g → HasPullback f g))))
TACTIC:
|
https://github.com/adamtopaz/CopenhagenMasterclass2023.git | a293ca1554f7e80d891fd4d86fb092c54d8a0a01 | Sieves/isSheafForPullbackSieve.lean | CategoryTheory.Equalizer.Presieve.sheaf_condition' | [94, 1] | [109, 19] | erw [← Equiv.forall_congr_left (firstObjEqFamily P S).toEquiv.symm] | C : Type u₁
inst✝ : Category C
X : C
S : Presieve X
P : Cᵒᵖ ⥤ Type (max v₁ u₁)
hS : isPullbackPresieve S
⊢ Presieve.IsSheafFor P S ↔
∀ (y : FirstObj P fun {Y} {f} => S f),
firstMap' P (_ : ∀ {Y Z : C} {f : Y ⟶ X}, S f → ∀ {g : Z ⟶ X}, S g → HasPullback f g) y =
secondMap' P (_ : ∀ {Y Z : C} {f : Y ⟶ X}, S f → ∀ {g : Z ⟶ X}, S g → HasPullback f g) y →
∃! x, forkMap P (fun {Y} {f} => S f) x = y | C : Type u₁
inst✝ : Category C
X : C
S : Presieve X
P : Cᵒᵖ ⥤ Type (max v₁ u₁)
hS : isPullbackPresieve S
⊢ Presieve.IsSheafFor P S ↔
∀ (x : Presieve.FamilyOfElements P S),
firstMap' P (_ : ∀ {Y Z : C} {f : Y ⟶ X}, S f → ∀ {g : Z ⟶ X}, S g → HasPullback f g)
(↑(firstObjEqFamily P S).symm x) =
secondMap' P (_ : ∀ {Y Z : C} {f : Y ⟶ X}, S f → ∀ {g : Z ⟶ X}, S g → HasPullback f g)
(↑(firstObjEqFamily P S).symm x) →
∃! x_1, forkMap P (fun {Y} {f} => S f) x_1 = ↑(firstObjEqFamily P S).symm x | Please generate a tactic in lean4 to solve the state.
STATE:
C : Type u₁
inst✝ : Category C
X : C
S : Presieve X
P : Cᵒᵖ ⥤ Type (max v₁ u₁)
hS : isPullbackPresieve S
⊢ Presieve.IsSheafFor P S ↔
∀ (y : FirstObj P fun {Y} {f} => S f),
firstMap' P (_ : ∀ {Y Z : C} {f : Y ⟶ X}, S f → ∀ {g : Z ⟶ X}, S g → HasPullback f g) y =
secondMap' P (_ : ∀ {Y Z : C} {f : Y ⟶ X}, S f → ∀ {g : Z ⟶ X}, S g → HasPullback f g) y →
∃! x, forkMap P (fun {Y} {f} => S f) x = y
TACTIC:
|
https://github.com/adamtopaz/CopenhagenMasterclass2023.git | a293ca1554f7e80d891fd4d86fb092c54d8a0a01 | Sieves/isSheafForPullbackSieve.lean | CategoryTheory.Equalizer.Presieve.sheaf_condition' | [94, 1] | [109, 19] | simp_rw [← compatible_iff', ← Iso.toEquiv_fun, Equiv.apply_symm_apply] | C : Type u₁
inst✝ : Category C
X : C
S : Presieve X
P : Cᵒᵖ ⥤ Type (max v₁ u₁)
hS : isPullbackPresieve S
⊢ Presieve.IsSheafFor P S ↔
∀ (x : Presieve.FamilyOfElements P S),
firstMap' P (_ : ∀ {Y Z : C} {f : Y ⟶ X}, S f → ∀ {g : Z ⟶ X}, S g → HasPullback f g)
(↑(firstObjEqFamily P S).symm x) =
secondMap' P (_ : ∀ {Y Z : C} {f : Y ⟶ X}, S f → ∀ {g : Z ⟶ X}, S g → HasPullback f g)
(↑(firstObjEqFamily P S).symm x) →
∃! x_1, forkMap P (fun {Y} {f} => S f) x_1 = ↑(firstObjEqFamily P S).symm x | C : Type u₁
inst✝ : Category C
X : C
S : Presieve X
P : Cᵒᵖ ⥤ Type (max v₁ u₁)
hS : isPullbackPresieve S
⊢ Presieve.IsSheafFor P S ↔
∀ (x : Presieve.FamilyOfElements P S),
Presieve.FamilyOfElements.Compatible x →
∃! x_1, forkMap P (fun {Y} {f} => S f) x_1 = ↑(firstObjEqFamily P S).symm x | Please generate a tactic in lean4 to solve the state.
STATE:
C : Type u₁
inst✝ : Category C
X : C
S : Presieve X
P : Cᵒᵖ ⥤ Type (max v₁ u₁)
hS : isPullbackPresieve S
⊢ Presieve.IsSheafFor P S ↔
∀ (x : Presieve.FamilyOfElements P S),
firstMap' P (_ : ∀ {Y Z : C} {f : Y ⟶ X}, S f → ∀ {g : Z ⟶ X}, S g → HasPullback f g)
(↑(firstObjEqFamily P S).symm x) =
secondMap' P (_ : ∀ {Y Z : C} {f : Y ⟶ X}, S f → ∀ {g : Z ⟶ X}, S g → HasPullback f g)
(↑(firstObjEqFamily P S).symm x) →
∃! x_1, forkMap P (fun {Y} {f} => S f) x_1 = ↑(firstObjEqFamily P S).symm x
TACTIC:
|
https://github.com/adamtopaz/CopenhagenMasterclass2023.git | a293ca1554f7e80d891fd4d86fb092c54d8a0a01 | Sieves/isSheafForPullbackSieve.lean | CategoryTheory.Equalizer.Presieve.sheaf_condition' | [94, 1] | [109, 19] | apply ball_congr | C : Type u₁
inst✝ : Category C
X : C
S : Presieve X
P : Cᵒᵖ ⥤ Type (max v₁ u₁)
hS : isPullbackPresieve S
⊢ Presieve.IsSheafFor P S ↔
∀ (x : Presieve.FamilyOfElements P S),
Presieve.FamilyOfElements.Compatible x →
∃! x_1, forkMap P (fun {Y} {f} => S f) x_1 = ↑(firstObjEqFamily P S).symm x | case H
C : Type u₁
inst✝ : Category C
X : C
S : Presieve X
P : Cᵒᵖ ⥤ Type (max v₁ u₁)
hS : isPullbackPresieve S
⊢ ∀ (x : Presieve.FamilyOfElements P S),
Presieve.FamilyOfElements.Compatible x →
((∃! t, Presieve.FamilyOfElements.IsAmalgamation x t) ↔
∃! x_1, forkMap P (fun {Y} {f} => S f) x_1 = ↑(firstObjEqFamily P S).symm x) | Please generate a tactic in lean4 to solve the state.
STATE:
C : Type u₁
inst✝ : Category C
X : C
S : Presieve X
P : Cᵒᵖ ⥤ Type (max v₁ u₁)
hS : isPullbackPresieve S
⊢ Presieve.IsSheafFor P S ↔
∀ (x : Presieve.FamilyOfElements P S),
Presieve.FamilyOfElements.Compatible x →
∃! x_1, forkMap P (fun {Y} {f} => S f) x_1 = ↑(firstObjEqFamily P S).symm x
TACTIC:
|
https://github.com/adamtopaz/CopenhagenMasterclass2023.git | a293ca1554f7e80d891fd4d86fb092c54d8a0a01 | Sieves/isSheafForPullbackSieve.lean | CategoryTheory.Equalizer.Presieve.sheaf_condition' | [94, 1] | [109, 19] | intro x _ | case H
C : Type u₁
inst✝ : Category C
X : C
S : Presieve X
P : Cᵒᵖ ⥤ Type (max v₁ u₁)
hS : isPullbackPresieve S
⊢ ∀ (x : Presieve.FamilyOfElements P S),
Presieve.FamilyOfElements.Compatible x →
((∃! t, Presieve.FamilyOfElements.IsAmalgamation x t) ↔
∃! x_1, forkMap P (fun {Y} {f} => S f) x_1 = ↑(firstObjEqFamily P S).symm x) | case H
C : Type u₁
inst✝ : Category C
X : C
S : Presieve X
P : Cᵒᵖ ⥤ Type (max v₁ u₁)
hS : isPullbackPresieve S
x : Presieve.FamilyOfElements P S
h✝ : Presieve.FamilyOfElements.Compatible x
⊢ (∃! t, Presieve.FamilyOfElements.IsAmalgamation x t) ↔
∃! x_1, forkMap P (fun {Y} {f} => S f) x_1 = ↑(firstObjEqFamily P S).symm x | Please generate a tactic in lean4 to solve the state.
STATE:
case H
C : Type u₁
inst✝ : Category C
X : C
S : Presieve X
P : Cᵒᵖ ⥤ Type (max v₁ u₁)
hS : isPullbackPresieve S
⊢ ∀ (x : Presieve.FamilyOfElements P S),
Presieve.FamilyOfElements.Compatible x →
((∃! t, Presieve.FamilyOfElements.IsAmalgamation x t) ↔
∃! x_1, forkMap P (fun {Y} {f} => S f) x_1 = ↑(firstObjEqFamily P S).symm x)
TACTIC:
|
https://github.com/adamtopaz/CopenhagenMasterclass2023.git | a293ca1554f7e80d891fd4d86fb092c54d8a0a01 | Sieves/isSheafForPullbackSieve.lean | CategoryTheory.Equalizer.Presieve.sheaf_condition' | [94, 1] | [109, 19] | apply exists_unique_congr | case H
C : Type u₁
inst✝ : Category C
X : C
S : Presieve X
P : Cᵒᵖ ⥤ Type (max v₁ u₁)
hS : isPullbackPresieve S
x : Presieve.FamilyOfElements P S
h✝ : Presieve.FamilyOfElements.Compatible x
⊢ (∃! t, Presieve.FamilyOfElements.IsAmalgamation x t) ↔
∃! x_1, forkMap P (fun {Y} {f} => S f) x_1 = ↑(firstObjEqFamily P S).symm x | case H.h
C : Type u₁
inst✝ : Category C
X : C
S : Presieve X
P : Cᵒᵖ ⥤ Type (max v₁ u₁)
hS : isPullbackPresieve S
x : Presieve.FamilyOfElements P S
h✝ : Presieve.FamilyOfElements.Compatible x
⊢ ∀ (a : P.obj X.op),
Presieve.FamilyOfElements.IsAmalgamation x a ↔ forkMap P (fun {Y} {f} => S f) a = ↑(firstObjEqFamily P S).symm x | Please generate a tactic in lean4 to solve the state.
STATE:
case H
C : Type u₁
inst✝ : Category C
X : C
S : Presieve X
P : Cᵒᵖ ⥤ Type (max v₁ u₁)
hS : isPullbackPresieve S
x : Presieve.FamilyOfElements P S
h✝ : Presieve.FamilyOfElements.Compatible x
⊢ (∃! t, Presieve.FamilyOfElements.IsAmalgamation x t) ↔
∃! x_1, forkMap P (fun {Y} {f} => S f) x_1 = ↑(firstObjEqFamily P S).symm x
TACTIC:
|
https://github.com/adamtopaz/CopenhagenMasterclass2023.git | a293ca1554f7e80d891fd4d86fb092c54d8a0a01 | Sieves/isSheafForPullbackSieve.lean | CategoryTheory.Equalizer.Presieve.sheaf_condition' | [94, 1] | [109, 19] | intro t | case H.h
C : Type u₁
inst✝ : Category C
X : C
S : Presieve X
P : Cᵒᵖ ⥤ Type (max v₁ u₁)
hS : isPullbackPresieve S
x : Presieve.FamilyOfElements P S
h✝ : Presieve.FamilyOfElements.Compatible x
⊢ ∀ (a : P.obj X.op),
Presieve.FamilyOfElements.IsAmalgamation x a ↔ forkMap P (fun {Y} {f} => S f) a = ↑(firstObjEqFamily P S).symm x | case H.h
C : Type u₁
inst✝ : Category C
X : C
S : Presieve X
P : Cᵒᵖ ⥤ Type (max v₁ u₁)
hS : isPullbackPresieve S
x : Presieve.FamilyOfElements P S
h✝ : Presieve.FamilyOfElements.Compatible x
t : P.obj X.op
⊢ Presieve.FamilyOfElements.IsAmalgamation x t ↔ forkMap P (fun {Y} {f} => S f) t = ↑(firstObjEqFamily P S).symm x | Please generate a tactic in lean4 to solve the state.
STATE:
case H.h
C : Type u₁
inst✝ : Category C
X : C
S : Presieve X
P : Cᵒᵖ ⥤ Type (max v₁ u₁)
hS : isPullbackPresieve S
x : Presieve.FamilyOfElements P S
h✝ : Presieve.FamilyOfElements.Compatible x
⊢ ∀ (a : P.obj X.op),
Presieve.FamilyOfElements.IsAmalgamation x a ↔ forkMap P (fun {Y} {f} => S f) a = ↑(firstObjEqFamily P S).symm x
TACTIC:
|
https://github.com/adamtopaz/CopenhagenMasterclass2023.git | a293ca1554f7e80d891fd4d86fb092c54d8a0a01 | Sieves/isSheafForPullbackSieve.lean | CategoryTheory.Equalizer.Presieve.sheaf_condition' | [94, 1] | [109, 19] | rw [Equiv.eq_symm_apply] | case H.h
C : Type u₁
inst✝ : Category C
X : C
S : Presieve X
P : Cᵒᵖ ⥤ Type (max v₁ u₁)
hS : isPullbackPresieve S
x : Presieve.FamilyOfElements P S
h✝ : Presieve.FamilyOfElements.Compatible x
t : P.obj X.op
⊢ Presieve.FamilyOfElements.IsAmalgamation x t ↔ forkMap P (fun {Y} {f} => S f) t = ↑(firstObjEqFamily P S).symm x | case H.h
C : Type u₁
inst✝ : Category C
X : C
S : Presieve X
P : Cᵒᵖ ⥤ Type (max v₁ u₁)
hS : isPullbackPresieve S
x : Presieve.FamilyOfElements P S
h✝ : Presieve.FamilyOfElements.Compatible x
t : P.obj X.op
⊢ Presieve.FamilyOfElements.IsAmalgamation x t ↔ ↑(firstObjEqFamily P S).toEquiv (forkMap P (fun {Y} {f} => S f) t) = x | Please generate a tactic in lean4 to solve the state.
STATE:
case H.h
C : Type u₁
inst✝ : Category C
X : C
S : Presieve X
P : Cᵒᵖ ⥤ Type (max v₁ u₁)
hS : isPullbackPresieve S
x : Presieve.FamilyOfElements P S
h✝ : Presieve.FamilyOfElements.Compatible x
t : P.obj X.op
⊢ Presieve.FamilyOfElements.IsAmalgamation x t ↔ forkMap P (fun {Y} {f} => S f) t = ↑(firstObjEqFamily P S).symm x
TACTIC:
|
https://github.com/adamtopaz/CopenhagenMasterclass2023.git | a293ca1554f7e80d891fd4d86fb092c54d8a0a01 | Sieves/isSheafForPullbackSieve.lean | CategoryTheory.Equalizer.Presieve.sheaf_condition' | [94, 1] | [109, 19] | constructor | case H.h
C : Type u₁
inst✝ : Category C
X : C
S : Presieve X
P : Cᵒᵖ ⥤ Type (max v₁ u₁)
hS : isPullbackPresieve S
x : Presieve.FamilyOfElements P S
h✝ : Presieve.FamilyOfElements.Compatible x
t : P.obj X.op
⊢ Presieve.FamilyOfElements.IsAmalgamation x t ↔ ↑(firstObjEqFamily P S).toEquiv (forkMap P (fun {Y} {f} => S f) t) = x | case H.h.mp
C : Type u₁
inst✝ : Category C
X : C
S : Presieve X
P : Cᵒᵖ ⥤ Type (max v₁ u₁)
hS : isPullbackPresieve S
x : Presieve.FamilyOfElements P S
h✝ : Presieve.FamilyOfElements.Compatible x
t : P.obj X.op
⊢ Presieve.FamilyOfElements.IsAmalgamation x t → ↑(firstObjEqFamily P S).toEquiv (forkMap P (fun {Y} {f} => S f) t) = x
case H.h.mpr
C : Type u₁
inst✝ : Category C
X : C
S : Presieve X
P : Cᵒᵖ ⥤ Type (max v₁ u₁)
hS : isPullbackPresieve S
x : Presieve.FamilyOfElements P S
h✝ : Presieve.FamilyOfElements.Compatible x
t : P.obj X.op
⊢ ↑(firstObjEqFamily P S).toEquiv (forkMap P (fun {Y} {f} => S f) t) = x → Presieve.FamilyOfElements.IsAmalgamation x t | Please generate a tactic in lean4 to solve the state.
STATE:
case H.h
C : Type u₁
inst✝ : Category C
X : C
S : Presieve X
P : Cᵒᵖ ⥤ Type (max v₁ u₁)
hS : isPullbackPresieve S
x : Presieve.FamilyOfElements P S
h✝ : Presieve.FamilyOfElements.Compatible x
t : P.obj X.op
⊢ Presieve.FamilyOfElements.IsAmalgamation x t ↔ ↑(firstObjEqFamily P S).toEquiv (forkMap P (fun {Y} {f} => S f) t) = x
TACTIC:
|
https://github.com/adamtopaz/CopenhagenMasterclass2023.git | a293ca1554f7e80d891fd4d86fb092c54d8a0a01 | Sieves/isSheafForPullbackSieve.lean | CategoryTheory.Equalizer.Presieve.sheaf_condition' | [94, 1] | [109, 19] | intro q | case H.h.mp
C : Type u₁
inst✝ : Category C
X : C
S : Presieve X
P : Cᵒᵖ ⥤ Type (max v₁ u₁)
hS : isPullbackPresieve S
x : Presieve.FamilyOfElements P S
h✝ : Presieve.FamilyOfElements.Compatible x
t : P.obj X.op
⊢ Presieve.FamilyOfElements.IsAmalgamation x t → ↑(firstObjEqFamily P S).toEquiv (forkMap P (fun {Y} {f} => S f) t) = x | case H.h.mp
C : Type u₁
inst✝ : Category C
X : C
S : Presieve X
P : Cᵒᵖ ⥤ Type (max v₁ u₁)
hS : isPullbackPresieve S
x : Presieve.FamilyOfElements P S
h✝ : Presieve.FamilyOfElements.Compatible x
t : P.obj X.op
q : Presieve.FamilyOfElements.IsAmalgamation x t
⊢ ↑(firstObjEqFamily P S).toEquiv (forkMap P (fun {Y} {f} => S f) t) = x | Please generate a tactic in lean4 to solve the state.
STATE:
case H.h.mp
C : Type u₁
inst✝ : Category C
X : C
S : Presieve X
P : Cᵒᵖ ⥤ Type (max v₁ u₁)
hS : isPullbackPresieve S
x : Presieve.FamilyOfElements P S
h✝ : Presieve.FamilyOfElements.Compatible x
t : P.obj X.op
⊢ Presieve.FamilyOfElements.IsAmalgamation x t → ↑(firstObjEqFamily P S).toEquiv (forkMap P (fun {Y} {f} => S f) t) = x
TACTIC:
|
https://github.com/adamtopaz/CopenhagenMasterclass2023.git | a293ca1554f7e80d891fd4d86fb092c54d8a0a01 | Sieves/isSheafForPullbackSieve.lean | CategoryTheory.Equalizer.Presieve.sheaf_condition' | [94, 1] | [109, 19] | funext Y f hf | case H.h.mp
C : Type u₁
inst✝ : Category C
X : C
S : Presieve X
P : Cᵒᵖ ⥤ Type (max v₁ u₁)
hS : isPullbackPresieve S
x : Presieve.FamilyOfElements P S
h✝ : Presieve.FamilyOfElements.Compatible x
t : P.obj X.op
q : Presieve.FamilyOfElements.IsAmalgamation x t
⊢ ↑(firstObjEqFamily P S).toEquiv (forkMap P (fun {Y} {f} => S f) t) = x | case H.h.mp.h.h.h
C : Type u₁
inst✝ : Category C
X : C
S : Presieve X
P : Cᵒᵖ ⥤ Type (max v₁ u₁)
hS : isPullbackPresieve S
x : Presieve.FamilyOfElements P S
h✝ : Presieve.FamilyOfElements.Compatible x
t : P.obj X.op
q : Presieve.FamilyOfElements.IsAmalgamation x t
Y : C
f : Y ⟶ X
hf : S f
⊢ ↑(firstObjEqFamily P S).toEquiv (forkMap P (fun {Y} {f} => S f) t) f hf = x f hf | Please generate a tactic in lean4 to solve the state.
STATE:
case H.h.mp
C : Type u₁
inst✝ : Category C
X : C
S : Presieve X
P : Cᵒᵖ ⥤ Type (max v₁ u₁)
hS : isPullbackPresieve S
x : Presieve.FamilyOfElements P S
h✝ : Presieve.FamilyOfElements.Compatible x
t : P.obj X.op
q : Presieve.FamilyOfElements.IsAmalgamation x t
⊢ ↑(firstObjEqFamily P S).toEquiv (forkMap P (fun {Y} {f} => S f) t) = x
TACTIC:
|
https://github.com/adamtopaz/CopenhagenMasterclass2023.git | a293ca1554f7e80d891fd4d86fb092c54d8a0a01 | Sieves/isSheafForPullbackSieve.lean | CategoryTheory.Equalizer.Presieve.sheaf_condition' | [94, 1] | [109, 19] | simpa [forkMap] using q _ _ | case H.h.mp.h.h.h
C : Type u₁
inst✝ : Category C
X : C
S : Presieve X
P : Cᵒᵖ ⥤ Type (max v₁ u₁)
hS : isPullbackPresieve S
x : Presieve.FamilyOfElements P S
h✝ : Presieve.FamilyOfElements.Compatible x
t : P.obj X.op
q : Presieve.FamilyOfElements.IsAmalgamation x t
Y : C
f : Y ⟶ X
hf : S f
⊢ ↑(firstObjEqFamily P S).toEquiv (forkMap P (fun {Y} {f} => S f) t) f hf = x f hf | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case H.h.mp.h.h.h
C : Type u₁
inst✝ : Category C
X : C
S : Presieve X
P : Cᵒᵖ ⥤ Type (max v₁ u₁)
hS : isPullbackPresieve S
x : Presieve.FamilyOfElements P S
h✝ : Presieve.FamilyOfElements.Compatible x
t : P.obj X.op
q : Presieve.FamilyOfElements.IsAmalgamation x t
Y : C
f : Y ⟶ X
hf : S f
⊢ ↑(firstObjEqFamily P S).toEquiv (forkMap P (fun {Y} {f} => S f) t) f hf = x f hf
TACTIC:
|
https://github.com/adamtopaz/CopenhagenMasterclass2023.git | a293ca1554f7e80d891fd4d86fb092c54d8a0a01 | Sieves/isSheafForPullbackSieve.lean | CategoryTheory.Equalizer.Presieve.sheaf_condition' | [94, 1] | [109, 19] | intro q Y f hf | case H.h.mpr
C : Type u₁
inst✝ : Category C
X : C
S : Presieve X
P : Cᵒᵖ ⥤ Type (max v₁ u₁)
hS : isPullbackPresieve S
x : Presieve.FamilyOfElements P S
h✝ : Presieve.FamilyOfElements.Compatible x
t : P.obj X.op
⊢ ↑(firstObjEqFamily P S).toEquiv (forkMap P (fun {Y} {f} => S f) t) = x → Presieve.FamilyOfElements.IsAmalgamation x t | case H.h.mpr
C : Type u₁
inst✝ : Category C
X : C
S : Presieve X
P : Cᵒᵖ ⥤ Type (max v₁ u₁)
hS : isPullbackPresieve S
x : Presieve.FamilyOfElements P S
h✝ : Presieve.FamilyOfElements.Compatible x
t : P.obj X.op
q : ↑(firstObjEqFamily P S).toEquiv (forkMap P (fun {Y} {f} => S f) t) = x
Y : C
f : Y ⟶ X
hf : S f
⊢ P.map f.op t = x f hf | Please generate a tactic in lean4 to solve the state.
STATE:
case H.h.mpr
C : Type u₁
inst✝ : Category C
X : C
S : Presieve X
P : Cᵒᵖ ⥤ Type (max v₁ u₁)
hS : isPullbackPresieve S
x : Presieve.FamilyOfElements P S
h✝ : Presieve.FamilyOfElements.Compatible x
t : P.obj X.op
⊢ ↑(firstObjEqFamily P S).toEquiv (forkMap P (fun {Y} {f} => S f) t) = x → Presieve.FamilyOfElements.IsAmalgamation x t
TACTIC:
|
https://github.com/adamtopaz/CopenhagenMasterclass2023.git | a293ca1554f7e80d891fd4d86fb092c54d8a0a01 | Sieves/isSheafForPullbackSieve.lean | CategoryTheory.Equalizer.Presieve.sheaf_condition' | [94, 1] | [109, 19] | rw [← q] | case H.h.mpr
C : Type u₁
inst✝ : Category C
X : C
S : Presieve X
P : Cᵒᵖ ⥤ Type (max v₁ u₁)
hS : isPullbackPresieve S
x : Presieve.FamilyOfElements P S
h✝ : Presieve.FamilyOfElements.Compatible x
t : P.obj X.op
q : ↑(firstObjEqFamily P S).toEquiv (forkMap P (fun {Y} {f} => S f) t) = x
Y : C
f : Y ⟶ X
hf : S f
⊢ P.map f.op t = x f hf | case H.h.mpr
C : Type u₁
inst✝ : Category C
X : C
S : Presieve X
P : Cᵒᵖ ⥤ Type (max v₁ u₁)
hS : isPullbackPresieve S
x : Presieve.FamilyOfElements P S
h✝ : Presieve.FamilyOfElements.Compatible x
t : P.obj X.op
q : ↑(firstObjEqFamily P S).toEquiv (forkMap P (fun {Y} {f} => S f) t) = x
Y : C
f : Y ⟶ X
hf : S f
⊢ P.map f.op t = ↑(firstObjEqFamily P S).toEquiv (forkMap P (fun {Y} {f} => S f) t) f hf | Please generate a tactic in lean4 to solve the state.
STATE:
case H.h.mpr
C : Type u₁
inst✝ : Category C
X : C
S : Presieve X
P : Cᵒᵖ ⥤ Type (max v₁ u₁)
hS : isPullbackPresieve S
x : Presieve.FamilyOfElements P S
h✝ : Presieve.FamilyOfElements.Compatible x
t : P.obj X.op
q : ↑(firstObjEqFamily P S).toEquiv (forkMap P (fun {Y} {f} => S f) t) = x
Y : C
f : Y ⟶ X
hf : S f
⊢ P.map f.op t = x f hf
TACTIC:
|
https://github.com/adamtopaz/CopenhagenMasterclass2023.git | a293ca1554f7e80d891fd4d86fb092c54d8a0a01 | Sieves/isSheafForPullbackSieve.lean | CategoryTheory.Equalizer.Presieve.sheaf_condition' | [94, 1] | [109, 19] | simp [forkMap] | case H.h.mpr
C : Type u₁
inst✝ : Category C
X : C
S : Presieve X
P : Cᵒᵖ ⥤ Type (max v₁ u₁)
hS : isPullbackPresieve S
x : Presieve.FamilyOfElements P S
h✝ : Presieve.FamilyOfElements.Compatible x
t : P.obj X.op
q : ↑(firstObjEqFamily P S).toEquiv (forkMap P (fun {Y} {f} => S f) t) = x
Y : C
f : Y ⟶ X
hf : S f
⊢ P.map f.op t = ↑(firstObjEqFamily P S).toEquiv (forkMap P (fun {Y} {f} => S f) t) f hf | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case H.h.mpr
C : Type u₁
inst✝ : Category C
X : C
S : Presieve X
P : Cᵒᵖ ⥤ Type (max v₁ u₁)
hS : isPullbackPresieve S
x : Presieve.FamilyOfElements P S
h✝ : Presieve.FamilyOfElements.Compatible x
t : P.obj X.op
q : ↑(firstObjEqFamily P S).toEquiv (forkMap P (fun {Y} {f} => S f) t) = x
Y : C
f : Y ⟶ X
hf : S f
⊢ P.map f.op t = ↑(firstObjEqFamily P S).toEquiv (forkMap P (fun {Y} {f} => S f) t) f hf
TACTIC:
|
https://github.com/adamtopaz/CopenhagenMasterclass2023.git | a293ca1554f7e80d891fd4d86fb092c54d8a0a01 | Condensed/SheafCondition.lean | Condensed.isSheaf_iff_conditions | [48, 1] | [73, 10] | constructor | C : Type w
inst✝ : Category C
P : CompHausᵒᵖ ⥤ C
⊢ Presheaf.IsSheaf (coherentTopology CompHaus) P ↔ ProductCondition P ∧ EqualizerCondition P | case mp
C : Type w
inst✝ : Category C
P : CompHausᵒᵖ ⥤ C
⊢ Presheaf.IsSheaf (coherentTopology CompHaus) P → ProductCondition P ∧ EqualizerCondition P
case mpr
C : Type w
inst✝ : Category C
P : CompHausᵒᵖ ⥤ C
⊢ ProductCondition P ∧ EqualizerCondition P → Presheaf.IsSheaf (coherentTopology CompHaus) P | Please generate a tactic in lean4 to solve the state.
STATE:
C : Type w
inst✝ : Category C
P : CompHausᵒᵖ ⥤ C
⊢ Presheaf.IsSheaf (coherentTopology CompHaus) P ↔ ProductCondition P ∧ EqualizerCondition P
TACTIC:
|
https://github.com/adamtopaz/CopenhagenMasterclass2023.git | a293ca1554f7e80d891fd4d86fb092c54d8a0a01 | Condensed/SheafCondition.lean | Condensed.isSheaf_iff_conditions | [48, 1] | [73, 10] | intro H | case mp
C : Type w
inst✝ : Category C
P : CompHausᵒᵖ ⥤ C
⊢ Presheaf.IsSheaf (coherentTopology CompHaus) P → ProductCondition P ∧ EqualizerCondition P | case mp
C : Type w
inst✝ : Category C
P : CompHausᵒᵖ ⥤ C
H : Presheaf.IsSheaf (coherentTopology CompHaus) P
⊢ ProductCondition P ∧ EqualizerCondition P | Please generate a tactic in lean4 to solve the state.
STATE:
case mp
C : Type w
inst✝ : Category C
P : CompHausᵒᵖ ⥤ C
⊢ Presheaf.IsSheaf (coherentTopology CompHaus) P → ProductCondition P ∧ EqualizerCondition P
TACTIC:
|
https://github.com/adamtopaz/CopenhagenMasterclass2023.git | a293ca1554f7e80d891fd4d86fb092c54d8a0a01 | Condensed/SheafCondition.lean | Condensed.isSheaf_iff_conditions | [48, 1] | [73, 10] | constructor | case mp
C : Type w
inst✝ : Category C
P : CompHausᵒᵖ ⥤ C
H : Presheaf.IsSheaf (coherentTopology CompHaus) P
⊢ ProductCondition P ∧ EqualizerCondition P | case mp.left
C : Type w
inst✝ : Category C
P : CompHausᵒᵖ ⥤ C
H : Presheaf.IsSheaf (coherentTopology CompHaus) P
⊢ ProductCondition P
case mp.right
C : Type w
inst✝ : Category C
P : CompHausᵒᵖ ⥤ C
H : Presheaf.IsSheaf (coherentTopology CompHaus) P
⊢ EqualizerCondition P | Please generate a tactic in lean4 to solve the state.
STATE:
case mp
C : Type w
inst✝ : Category C
P : CompHausᵒᵖ ⥤ C
H : Presheaf.IsSheaf (coherentTopology CompHaus) P
⊢ ProductCondition P ∧ EqualizerCondition P
TACTIC:
|
https://github.com/adamtopaz/CopenhagenMasterclass2023.git | a293ca1554f7e80d891fd4d86fb092c54d8a0a01 | Condensed/SheafCondition.lean | Condensed.isSheaf_iff_conditions | [48, 1] | [73, 10] | intro α _ X | case mp.left
C : Type w
inst✝ : Category C
P : CompHausᵒᵖ ⥤ C
H : Presheaf.IsSheaf (coherentTopology CompHaus) P
⊢ ProductCondition P | case mp.left
C : Type w
inst✝¹ : Category C
P : CompHausᵒᵖ ⥤ C
H : Presheaf.IsSheaf (coherentTopology CompHaus) P
α : Type
inst✝ : Fintype α
X : α → CompHaus
⊢ Nonempty (IsLimit (productFan P X)) | Please generate a tactic in lean4 to solve the state.
STATE:
case mp.left
C : Type w
inst✝ : Category C
P : CompHausᵒᵖ ⥤ C
H : Presheaf.IsSheaf (coherentTopology CompHaus) P
⊢ ProductCondition P
TACTIC:
|
https://github.com/adamtopaz/CopenhagenMasterclass2023.git | a293ca1554f7e80d891fd4d86fb092c54d8a0a01 | Condensed/SheafCondition.lean | Condensed.isSheaf_iff_conditions | [48, 1] | [73, 10] | let B := ∐ X | case mp.left
C : Type w
inst✝¹ : Category C
P : CompHausᵒᵖ ⥤ C
H : Presheaf.IsSheaf (coherentTopology CompHaus) P
α : Type
inst✝ : Fintype α
X : α → CompHaus
⊢ Nonempty (IsLimit (productFan P X)) | case mp.left
C : Type w
inst✝¹ : Category C
P : CompHausᵒᵖ ⥤ C
H : Presheaf.IsSheaf (coherentTopology CompHaus) P
α : Type
inst✝ : Fintype α
X : α → CompHaus
B : CompHaus := ∐ X
⊢ Nonempty (IsLimit (productFan P X)) | Please generate a tactic in lean4 to solve the state.
STATE:
case mp.left
C : Type w
inst✝¹ : Category C
P : CompHausᵒᵖ ⥤ C
H : Presheaf.IsSheaf (coherentTopology CompHaus) P
α : Type
inst✝ : Fintype α
X : α → CompHaus
⊢ Nonempty (IsLimit (productFan P X))
TACTIC:
|
https://github.com/adamtopaz/CopenhagenMasterclass2023.git | a293ca1554f7e80d891fd4d86fb092c54d8a0a01 | Condensed/SheafCondition.lean | Condensed.isSheaf_iff_conditions | [48, 1] | [73, 10] | let π : (a : α) → (X a ⟶ B) :=
Sigma.ι X | case mp.left
C : Type w
inst✝¹ : Category C
P : CompHausᵒᵖ ⥤ C
H : Presheaf.IsSheaf (coherentTopology CompHaus) P
α : Type
inst✝ : Fintype α
X : α → CompHaus
B : CompHaus := ∐ X
⊢ Nonempty (IsLimit (productFan P X)) | case mp.left
C : Type w
inst✝¹ : Category C
P : CompHausᵒᵖ ⥤ C
H : Presheaf.IsSheaf (coherentTopology CompHaus) P
α : Type
inst✝ : Fintype α
X : α → CompHaus
B : CompHaus := ∐ X
π : (a : α) → X a ⟶ B := Sigma.ι X
⊢ Nonempty (IsLimit (productFan P X)) | Please generate a tactic in lean4 to solve the state.
STATE:
case mp.left
C : Type w
inst✝¹ : Category C
P : CompHausᵒᵖ ⥤ C
H : Presheaf.IsSheaf (coherentTopology CompHaus) P
α : Type
inst✝ : Fintype α
X : α → CompHaus
B : CompHaus := ∐ X
⊢ Nonempty (IsLimit (productFan P X))
TACTIC:
|
https://github.com/adamtopaz/CopenhagenMasterclass2023.git | a293ca1554f7e80d891fd4d86fb092c54d8a0a01 | Condensed/SheafCondition.lean | Condensed.isSheaf_iff_conditions | [48, 1] | [73, 10] | have : EffectiveEpiFamily X π := sorry | case mp.left
C : Type w
inst✝¹ : Category C
P : CompHausᵒᵖ ⥤ C
H : Presheaf.IsSheaf (coherentTopology CompHaus) P
α : Type
inst✝ : Fintype α
X : α → CompHaus
B : CompHaus := ∐ X
π : (a : α) → X a ⟶ B := Sigma.ι X
⊢ Nonempty (IsLimit (productFan P X)) | case mp.left
C : Type w
inst✝¹ : Category C
P : CompHausᵒᵖ ⥤ C
H : Presheaf.IsSheaf (coherentTopology CompHaus) P
α : Type
inst✝ : Fintype α
X : α → CompHaus
B : CompHaus := ∐ X
π : (a : α) → X a ⟶ B := Sigma.ι X
this : EffectiveEpiFamily X π
⊢ Nonempty (IsLimit (productFan P X)) | Please generate a tactic in lean4 to solve the state.
STATE:
case mp.left
C : Type w
inst✝¹ : Category C
P : CompHausᵒᵖ ⥤ C
H : Presheaf.IsSheaf (coherentTopology CompHaus) P
α : Type
inst✝ : Fintype α
X : α → CompHaus
B : CompHaus := ∐ X
π : (a : α) → X a ⟶ B := Sigma.ι X
⊢ Nonempty (IsLimit (productFan P X))
TACTIC:
|
https://github.com/adamtopaz/CopenhagenMasterclass2023.git | a293ca1554f7e80d891fd4d86fb092c54d8a0a01 | Condensed/SheafCondition.lean | Condensed.isSheaf_iff_conditions | [48, 1] | [73, 10] | specialize H (P.obj <| op B) | case mp.left
C : Type w
inst✝¹ : Category C
P : CompHausᵒᵖ ⥤ C
H : Presheaf.IsSheaf (coherentTopology CompHaus) P
α : Type
inst✝ : Fintype α
X : α → CompHaus
B : CompHaus := ∐ X
π : (a : α) → X a ⟶ B := Sigma.ι X
this : EffectiveEpiFamily X π
⊢ Nonempty (IsLimit (productFan P X)) | case mp.left
C : Type w
inst✝¹ : Category C
P : CompHausᵒᵖ ⥤ C
α : Type
inst✝ : Fintype α
X : α → CompHaus
B : CompHaus := ∐ X
π : (a : α) → X a ⟶ B := Sigma.ι X
this : EffectiveEpiFamily X π
H : Presieve.IsSheaf (coherentTopology CompHaus) (P ⋙ coyoneda.obj (P.obj B.op).op)
⊢ Nonempty (IsLimit (productFan P X)) | Please generate a tactic in lean4 to solve the state.
STATE:
case mp.left
C : Type w
inst✝¹ : Category C
P : CompHausᵒᵖ ⥤ C
H : Presheaf.IsSheaf (coherentTopology CompHaus) P
α : Type
inst✝ : Fintype α
X : α → CompHaus
B : CompHaus := ∐ X
π : (a : α) → X a ⟶ B := Sigma.ι X
this : EffectiveEpiFamily X π
⊢ Nonempty (IsLimit (productFan P X))
TACTIC:
|
https://github.com/adamtopaz/CopenhagenMasterclass2023.git | a293ca1554f7e80d891fd4d86fb092c54d8a0a01 | Condensed/SheafCondition.lean | Condensed.isSheaf_iff_conditions | [48, 1] | [73, 10] | erw [Presieve.isSheaf_coverage] at H | case mp.left
C : Type w
inst✝¹ : Category C
P : CompHausᵒᵖ ⥤ C
α : Type
inst✝ : Fintype α
X : α → CompHaus
B : CompHaus := ∐ X
π : (a : α) → X a ⟶ B := Sigma.ι X
this : EffectiveEpiFamily X π
H : Presieve.IsSheaf (coherentTopology CompHaus) (P ⋙ coyoneda.obj (P.obj B.op).op)
⊢ Nonempty (IsLimit (productFan P X)) | case mp.left
C : Type w
inst✝¹ : Category C
P : CompHausᵒᵖ ⥤ C
α : Type
inst✝ : Fintype α
X : α → CompHaus
B : CompHaus := ∐ X
π : (a : α) → X a ⟶ B := Sigma.ι X
this : EffectiveEpiFamily X π
H :
∀ {X : CompHaus} (R : Presieve X),
R ∈ Coverage.covering (coherentCoverage CompHaus) X → Presieve.IsSheafFor (P ⋙ coyoneda.obj (P.obj B.op).op) R
⊢ Nonempty (IsLimit (productFan P X)) | Please generate a tactic in lean4 to solve the state.
STATE:
case mp.left
C : Type w
inst✝¹ : Category C
P : CompHausᵒᵖ ⥤ C
α : Type
inst✝ : Fintype α
X : α → CompHaus
B : CompHaus := ∐ X
π : (a : α) → X a ⟶ B := Sigma.ι X
this : EffectiveEpiFamily X π
H : Presieve.IsSheaf (coherentTopology CompHaus) (P ⋙ coyoneda.obj (P.obj B.op).op)
⊢ Nonempty (IsLimit (productFan P X))
TACTIC:
|
https://github.com/adamtopaz/CopenhagenMasterclass2023.git | a293ca1554f7e80d891fd4d86fb092c54d8a0a01 | Condensed/SheafCondition.lean | Condensed.isSheaf_iff_conditions | [48, 1] | [73, 10] | specialize H (Presieve.ofArrows X π) ?_ | case mp.left
C : Type w
inst✝¹ : Category C
P : CompHausᵒᵖ ⥤ C
α : Type
inst✝ : Fintype α
X : α → CompHaus
B : CompHaus := ∐ X
π : (a : α) → X a ⟶ B := Sigma.ι X
this : EffectiveEpiFamily X π
H :
∀ {X : CompHaus} (R : Presieve X),
R ∈ Coverage.covering (coherentCoverage CompHaus) X → Presieve.IsSheafFor (P ⋙ coyoneda.obj (P.obj B.op).op) R
⊢ Nonempty (IsLimit (productFan P X)) | case mp.left
C : Type w
inst✝¹ : Category C
P : CompHausᵒᵖ ⥤ C
α : Type
inst✝ : Fintype α
X : α → CompHaus
B : CompHaus := ∐ X
π : (a : α) → X a ⟶ B := Sigma.ι X
this : EffectiveEpiFamily X π
H :
∀ {X : CompHaus} (R : Presieve X),
R ∈ Coverage.covering (coherentCoverage CompHaus) X → Presieve.IsSheafFor (P ⋙ coyoneda.obj (P.obj B.op).op) R
⊢ Presieve.ofArrows X π ∈ Coverage.covering (coherentCoverage CompHaus) B
case mp.left
C : Type w
inst✝¹ : Category C
P : CompHausᵒᵖ ⥤ C
α : Type
inst✝ : Fintype α
X : α → CompHaus
B : CompHaus := ∐ X
π : (a : α) → X a ⟶ B := Sigma.ι X
this : EffectiveEpiFamily X π
H : Presieve.IsSheafFor (P ⋙ coyoneda.obj (P.obj B.op).op) (Presieve.ofArrows X π)
⊢ Nonempty (IsLimit (productFan P X)) | Please generate a tactic in lean4 to solve the state.
STATE:
case mp.left
C : Type w
inst✝¹ : Category C
P : CompHausᵒᵖ ⥤ C
α : Type
inst✝ : Fintype α
X : α → CompHaus
B : CompHaus := ∐ X
π : (a : α) → X a ⟶ B := Sigma.ι X
this : EffectiveEpiFamily X π
H :
∀ {X : CompHaus} (R : Presieve X),
R ∈ Coverage.covering (coherentCoverage CompHaus) X → Presieve.IsSheafFor (P ⋙ coyoneda.obj (P.obj B.op).op) R
⊢ Nonempty (IsLimit (productFan P X))
TACTIC:
|
https://github.com/adamtopaz/CopenhagenMasterclass2023.git | a293ca1554f7e80d891fd4d86fb092c54d8a0a01 | Condensed/SheafCondition.lean | Condensed.isSheaf_iff_conditions | [48, 1] | [73, 10] | sorry | case mp.left
C : Type w
inst✝¹ : Category C
P : CompHausᵒᵖ ⥤ C
α : Type
inst✝ : Fintype α
X : α → CompHaus
B : CompHaus := ∐ X
π : (a : α) → X a ⟶ B := Sigma.ι X
this : EffectiveEpiFamily X π
H : Presieve.IsSheafFor (P ⋙ coyoneda.obj (P.obj B.op).op) (Presieve.ofArrows X π)
⊢ Nonempty (IsLimit (productFan P X)) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case mp.left
C : Type w
inst✝¹ : Category C
P : CompHausᵒᵖ ⥤ C
α : Type
inst✝ : Fintype α
X : α → CompHaus
B : CompHaus := ∐ X
π : (a : α) → X a ⟶ B := Sigma.ι X
this : EffectiveEpiFamily X π
H : Presieve.IsSheafFor (P ⋙ coyoneda.obj (P.obj B.op).op) (Presieve.ofArrows X π)
⊢ Nonempty (IsLimit (productFan P X))
TACTIC:
|
https://github.com/adamtopaz/CopenhagenMasterclass2023.git | a293ca1554f7e80d891fd4d86fb092c54d8a0a01 | Condensed/SheafCondition.lean | Condensed.isSheaf_iff_conditions | [48, 1] | [73, 10] | sorry | case mp.left
C : Type w
inst✝¹ : Category C
P : CompHausᵒᵖ ⥤ C
α : Type
inst✝ : Fintype α
X : α → CompHaus
B : CompHaus := ∐ X
π : (a : α) → X a ⟶ B := Sigma.ι X
this : EffectiveEpiFamily X π
H :
∀ {X : CompHaus} (R : Presieve X),
R ∈ Coverage.covering (coherentCoverage CompHaus) X → Presieve.IsSheafFor (P ⋙ coyoneda.obj (P.obj B.op).op) R
⊢ Presieve.ofArrows X π ∈ Coverage.covering (coherentCoverage CompHaus) B | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case mp.left
C : Type w
inst✝¹ : Category C
P : CompHausᵒᵖ ⥤ C
α : Type
inst✝ : Fintype α
X : α → CompHaus
B : CompHaus := ∐ X
π : (a : α) → X a ⟶ B := Sigma.ι X
this : EffectiveEpiFamily X π
H :
∀ {X : CompHaus} (R : Presieve X),
R ∈ Coverage.covering (coherentCoverage CompHaus) X → Presieve.IsSheafFor (P ⋙ coyoneda.obj (P.obj B.op).op) R
⊢ Presieve.ofArrows X π ∈ Coverage.covering (coherentCoverage CompHaus) B
TACTIC:
|
https://github.com/adamtopaz/CopenhagenMasterclass2023.git | a293ca1554f7e80d891fd4d86fb092c54d8a0a01 | Condensed/SheafCondition.lean | Condensed.isSheaf_iff_conditions | [48, 1] | [73, 10] | sorry | case mp.right
C : Type w
inst✝ : Category C
P : CompHausᵒᵖ ⥤ C
H : Presheaf.IsSheaf (coherentTopology CompHaus) P
⊢ EqualizerCondition P | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case mp.right
C : Type w
inst✝ : Category C
P : CompHausᵒᵖ ⥤ C
H : Presheaf.IsSheaf (coherentTopology CompHaus) P
⊢ EqualizerCondition P
TACTIC:
|
https://github.com/adamtopaz/CopenhagenMasterclass2023.git | a293ca1554f7e80d891fd4d86fb092c54d8a0a01 | Condensed/SheafCondition.lean | Condensed.isSheaf_iff_conditions | [48, 1] | [73, 10] | intro ⟨H1,H2⟩ | case mpr
C : Type w
inst✝ : Category C
P : CompHausᵒᵖ ⥤ C
⊢ ProductCondition P ∧ EqualizerCondition P → Presheaf.IsSheaf (coherentTopology CompHaus) P | case mpr
C : Type w
inst✝ : Category C
P : CompHausᵒᵖ ⥤ C
H1 : ProductCondition P
H2 : EqualizerCondition P
⊢ Presheaf.IsSheaf (coherentTopology CompHaus) P | Please generate a tactic in lean4 to solve the state.
STATE:
case mpr
C : Type w
inst✝ : Category C
P : CompHausᵒᵖ ⥤ C
⊢ ProductCondition P ∧ EqualizerCondition P → Presheaf.IsSheaf (coherentTopology CompHaus) P
TACTIC:
|
https://github.com/adamtopaz/CopenhagenMasterclass2023.git | a293ca1554f7e80d891fd4d86fb092c54d8a0a01 | Condensed/SheafCondition.lean | Condensed.isSheaf_iff_conditions | [48, 1] | [73, 10] | intro T | case mpr
C : Type w
inst✝ : Category C
P : CompHausᵒᵖ ⥤ C
H1 : ProductCondition P
H2 : EqualizerCondition P
⊢ Presheaf.IsSheaf (coherentTopology CompHaus) P | case mpr
C : Type w
inst✝ : Category C
P : CompHausᵒᵖ ⥤ C
H1 : ProductCondition P
H2 : EqualizerCondition P
T : C
⊢ Presieve.IsSheaf (coherentTopology CompHaus) (P ⋙ coyoneda.obj T.op) | Please generate a tactic in lean4 to solve the state.
STATE:
case mpr
C : Type w
inst✝ : Category C
P : CompHausᵒᵖ ⥤ C
H1 : ProductCondition P
H2 : EqualizerCondition P
⊢ Presheaf.IsSheaf (coherentTopology CompHaus) P
TACTIC:
|
https://github.com/adamtopaz/CopenhagenMasterclass2023.git | a293ca1554f7e80d891fd4d86fb092c54d8a0a01 | Condensed/SheafCondition.lean | Condensed.isSheaf_iff_conditions | [48, 1] | [73, 10] | erw [Presieve.isSheaf_coverage] | case mpr
C : Type w
inst✝ : Category C
P : CompHausᵒᵖ ⥤ C
H1 : ProductCondition P
H2 : EqualizerCondition P
T : C
⊢ Presieve.IsSheaf (coherentTopology CompHaus) (P ⋙ coyoneda.obj T.op) | case mpr
C : Type w
inst✝ : Category C
P : CompHausᵒᵖ ⥤ C
H1 : ProductCondition P
H2 : EqualizerCondition P
T : C
⊢ ∀ {X : CompHaus} (R : Presieve X),
R ∈ Coverage.covering (coherentCoverage CompHaus) X → Presieve.IsSheafFor (P ⋙ coyoneda.obj T.op) R | Please generate a tactic in lean4 to solve the state.
STATE:
case mpr
C : Type w
inst✝ : Category C
P : CompHausᵒᵖ ⥤ C
H1 : ProductCondition P
H2 : EqualizerCondition P
T : C
⊢ Presieve.IsSheaf (coherentTopology CompHaus) (P ⋙ coyoneda.obj T.op)
TACTIC:
|
https://github.com/adamtopaz/CopenhagenMasterclass2023.git | a293ca1554f7e80d891fd4d86fb092c54d8a0a01 | Condensed/SheafCondition.lean | Condensed.isSheaf_iff_conditions | [48, 1] | [73, 10] | rintro B R ⟨α, _, X, π, rfl, H⟩ | case mpr
C : Type w
inst✝ : Category C
P : CompHausᵒᵖ ⥤ C
H1 : ProductCondition P
H2 : EqualizerCondition P
T : C
⊢ ∀ {X : CompHaus} (R : Presieve X),
R ∈ Coverage.covering (coherentCoverage CompHaus) X → Presieve.IsSheafFor (P ⋙ coyoneda.obj T.op) R | case mpr.intro.intro.intro.intro.intro
C : Type w
inst✝ : Category C
P : CompHausᵒᵖ ⥤ C
H1 : ProductCondition P
H2 : EqualizerCondition P
T : C
B : CompHaus
α : Type
w✝ : Fintype α
X : α → CompHaus
π : (a : α) → X a ⟶ B
H : EffectiveEpiFamily X π
⊢ Presieve.IsSheafFor (P ⋙ coyoneda.obj T.op) (Presieve.ofArrows X π) | Please generate a tactic in lean4 to solve the state.
STATE:
case mpr
C : Type w
inst✝ : Category C
P : CompHausᵒᵖ ⥤ C
H1 : ProductCondition P
H2 : EqualizerCondition P
T : C
⊢ ∀ {X : CompHaus} (R : Presieve X),
R ∈ Coverage.covering (coherentCoverage CompHaus) X → Presieve.IsSheafFor (P ⋙ coyoneda.obj T.op) R
TACTIC:
|
https://github.com/adamtopaz/CopenhagenMasterclass2023.git | a293ca1554f7e80d891fd4d86fb092c54d8a0a01 | Condensed/SheafCondition.lean | Condensed.isSheaf_iff_conditions | [48, 1] | [73, 10] | specialize H2 (Sigma.desc π) | case mpr.intro.intro.intro.intro.intro
C : Type w
inst✝ : Category C
P : CompHausᵒᵖ ⥤ C
H1 : ProductCondition P
H2 : EqualizerCondition P
T : C
B : CompHaus
α : Type
w✝ : Fintype α
X : α → CompHaus
π : (a : α) → X a ⟶ B
H : EffectiveEpiFamily X π
⊢ Presieve.IsSheafFor (P ⋙ coyoneda.obj T.op) (Presieve.ofArrows X π) | case mpr.intro.intro.intro.intro.intro
C : Type w
inst✝ : Category C
P : CompHausᵒᵖ ⥤ C
H1 : ProductCondition P
T : C
B : CompHaus
α : Type
w✝ : Fintype α
X : α → CompHaus
π : (a : α) → X a ⟶ B
H : EffectiveEpiFamily X π
H2 : Nonempty (IsLimit (equalizerFork P (Sigma.desc π)))
⊢ Presieve.IsSheafFor (P ⋙ coyoneda.obj T.op) (Presieve.ofArrows X π) | Please generate a tactic in lean4 to solve the state.
STATE:
case mpr.intro.intro.intro.intro.intro
C : Type w
inst✝ : Category C
P : CompHausᵒᵖ ⥤ C
H1 : ProductCondition P
H2 : EqualizerCondition P
T : C
B : CompHaus
α : Type
w✝ : Fintype α
X : α → CompHaus
π : (a : α) → X a ⟶ B
H : EffectiveEpiFamily X π
⊢ Presieve.IsSheafFor (P ⋙ coyoneda.obj T.op) (Presieve.ofArrows X π)
TACTIC:
|
https://github.com/adamtopaz/CopenhagenMasterclass2023.git | a293ca1554f7e80d891fd4d86fb092c54d8a0a01 | Condensed/SheafCondition.lean | Condensed.isSheaf_iff_conditions | [48, 1] | [73, 10] | rw [isSheafFor_ofArrows] | case mpr.intro.intro.intro.intro.intro
C : Type w
inst✝ : Category C
P : CompHausᵒᵖ ⥤ C
H1 : ProductCondition P
T : C
B : CompHaus
α : Type
w✝ : Fintype α
X : α → CompHaus
π : (a : α) → X a ⟶ B
H : EffectiveEpiFamily X π
H2 : Nonempty (IsLimit (equalizerFork P (Sigma.desc π)))
⊢ Presieve.IsSheafFor (P ⋙ coyoneda.obj T.op) (Presieve.ofArrows X π) | case mpr.intro.intro.intro.intro.intro
C : Type w
inst✝ : Category C
P : CompHausᵒᵖ ⥤ C
H1 : ProductCondition P
T : C
B : CompHaus
α : Type
w✝ : Fintype α
X : α → CompHaus
π : (a : α) → X a ⟶ B
H : EffectiveEpiFamily X π
H2 : Nonempty (IsLimit (equalizerFork P (Sigma.desc π)))
⊢ ∀ (x : (a : α) → (P ⋙ coyoneda.obj T.op).obj (X a).op),
(∀ (R : CompHaus) (i j : α) (ri : R ⟶ X i) (rj : R ⟶ X j),
(P ⋙ coyoneda.obj T.op).map ri.op (x i) = (P ⋙ coyoneda.obj T.op).map rj.op (x j)) →
∃! b, ∀ (i : α), (P ⋙ coyoneda.obj T.op).map (π i).op b = x i | Please generate a tactic in lean4 to solve the state.
STATE:
case mpr.intro.intro.intro.intro.intro
C : Type w
inst✝ : Category C
P : CompHausᵒᵖ ⥤ C
H1 : ProductCondition P
T : C
B : CompHaus
α : Type
w✝ : Fintype α
X : α → CompHaus
π : (a : α) → X a ⟶ B
H : EffectiveEpiFamily X π
H2 : Nonempty (IsLimit (equalizerFork P (Sigma.desc π)))
⊢ Presieve.IsSheafFor (P ⋙ coyoneda.obj T.op) (Presieve.ofArrows X π)
TACTIC:
|
https://github.com/adamtopaz/CopenhagenMasterclass2023.git | a293ca1554f7e80d891fd4d86fb092c54d8a0a01 | Condensed/SheafCondition.lean | Condensed.isSheaf_iff_conditions | [48, 1] | [73, 10] | intro x hx | case mpr.intro.intro.intro.intro.intro
C : Type w
inst✝ : Category C
P : CompHausᵒᵖ ⥤ C
H1 : ProductCondition P
T : C
B : CompHaus
α : Type
w✝ : Fintype α
X : α → CompHaus
π : (a : α) → X a ⟶ B
H : EffectiveEpiFamily X π
H2 : Nonempty (IsLimit (equalizerFork P (Sigma.desc π)))
⊢ ∀ (x : (a : α) → (P ⋙ coyoneda.obj T.op).obj (X a).op),
(∀ (R : CompHaus) (i j : α) (ri : R ⟶ X i) (rj : R ⟶ X j),
(P ⋙ coyoneda.obj T.op).map ri.op (x i) = (P ⋙ coyoneda.obj T.op).map rj.op (x j)) →
∃! b, ∀ (i : α), (P ⋙ coyoneda.obj T.op).map (π i).op b = x i | case mpr.intro.intro.intro.intro.intro
C : Type w
inst✝ : Category C
P : CompHausᵒᵖ ⥤ C
H1 : ProductCondition P
T : C
B : CompHaus
α : Type
w✝ : Fintype α
X : α → CompHaus
π : (a : α) → X a ⟶ B
H : EffectiveEpiFamily X π
H2 : Nonempty (IsLimit (equalizerFork P (Sigma.desc π)))
x : (a : α) → (P ⋙ coyoneda.obj T.op).obj (X a).op
hx :
∀ (R : CompHaus) (i j : α) (ri : R ⟶ X i) (rj : R ⟶ X j),
(P ⋙ coyoneda.obj T.op).map ri.op (x i) = (P ⋙ coyoneda.obj T.op).map rj.op (x j)
⊢ ∃! b, ∀ (i : α), (P ⋙ coyoneda.obj T.op).map (π i).op b = x i | Please generate a tactic in lean4 to solve the state.
STATE:
case mpr.intro.intro.intro.intro.intro
C : Type w
inst✝ : Category C
P : CompHausᵒᵖ ⥤ C
H1 : ProductCondition P
T : C
B : CompHaus
α : Type
w✝ : Fintype α
X : α → CompHaus
π : (a : α) → X a ⟶ B
H : EffectiveEpiFamily X π
H2 : Nonempty (IsLimit (equalizerFork P (Sigma.desc π)))
⊢ ∀ (x : (a : α) → (P ⋙ coyoneda.obj T.op).obj (X a).op),
(∀ (R : CompHaus) (i j : α) (ri : R ⟶ X i) (rj : R ⟶ X j),
(P ⋙ coyoneda.obj T.op).map ri.op (x i) = (P ⋙ coyoneda.obj T.op).map rj.op (x j)) →
∃! b, ∀ (i : α), (P ⋙ coyoneda.obj T.op).map (π i).op b = x i
TACTIC:
|
https://github.com/adamtopaz/CopenhagenMasterclass2023.git | a293ca1554f7e80d891fd4d86fb092c54d8a0a01 | Condensed/SheafCondition.lean | Condensed.isSheaf_iff_conditions | [48, 1] | [73, 10] | dsimp at x | case mpr.intro.intro.intro.intro.intro
C : Type w
inst✝ : Category C
P : CompHausᵒᵖ ⥤ C
H1 : ProductCondition P
T : C
B : CompHaus
α : Type
w✝ : Fintype α
X : α → CompHaus
π : (a : α) → X a ⟶ B
H : EffectiveEpiFamily X π
H2 : Nonempty (IsLimit (equalizerFork P (Sigma.desc π)))
x : (a : α) → (P ⋙ coyoneda.obj T.op).obj (X a).op
hx :
∀ (R : CompHaus) (i j : α) (ri : R ⟶ X i) (rj : R ⟶ X j),
(P ⋙ coyoneda.obj T.op).map ri.op (x i) = (P ⋙ coyoneda.obj T.op).map rj.op (x j)
⊢ ∃! b, ∀ (i : α), (P ⋙ coyoneda.obj T.op).map (π i).op b = x i | case mpr.intro.intro.intro.intro.intro
C : Type w
inst✝ : Category C
P : CompHausᵒᵖ ⥤ C
H1 : ProductCondition P
T : C
B : CompHaus
α : Type
w✝ : Fintype α
X : α → CompHaus
π : (a : α) → X a ⟶ B
H : EffectiveEpiFamily X π
H2 : Nonempty (IsLimit (equalizerFork P (Sigma.desc π)))
x : (a : α) → T ⟶ P.obj (X a).op
hx :
∀ (R : CompHaus) (i j : α) (ri : R ⟶ X i) (rj : R ⟶ X j),
(P ⋙ coyoneda.obj T.op).map ri.op (x i) = (P ⋙ coyoneda.obj T.op).map rj.op (x j)
⊢ ∃! b, ∀ (i : α), (P ⋙ coyoneda.obj T.op).map (π i).op b = x i | Please generate a tactic in lean4 to solve the state.
STATE:
case mpr.intro.intro.intro.intro.intro
C : Type w
inst✝ : Category C
P : CompHausᵒᵖ ⥤ C
H1 : ProductCondition P
T : C
B : CompHaus
α : Type
w✝ : Fintype α
X : α → CompHaus
π : (a : α) → X a ⟶ B
H : EffectiveEpiFamily X π
H2 : Nonempty (IsLimit (equalizerFork P (Sigma.desc π)))
x : (a : α) → (P ⋙ coyoneda.obj T.op).obj (X a).op
hx :
∀ (R : CompHaus) (i j : α) (ri : R ⟶ X i) (rj : R ⟶ X j),
(P ⋙ coyoneda.obj T.op).map ri.op (x i) = (P ⋙ coyoneda.obj T.op).map rj.op (x j)
⊢ ∃! b, ∀ (i : α), (P ⋙ coyoneda.obj T.op).map (π i).op b = x i
TACTIC:
|
https://github.com/adamtopaz/CopenhagenMasterclass2023.git | a293ca1554f7e80d891fd4d86fb092c54d8a0a01 | Condensed/SheafCondition.lean | Condensed.isSheaf_iff_conditions | [48, 1] | [73, 10] | sorry | case mpr.intro.intro.intro.intro.intro
C : Type w
inst✝ : Category C
P : CompHausᵒᵖ ⥤ C
H1 : ProductCondition P
T : C
B : CompHaus
α : Type
w✝ : Fintype α
X : α → CompHaus
π : (a : α) → X a ⟶ B
H : EffectiveEpiFamily X π
H2 : Nonempty (IsLimit (equalizerFork P (Sigma.desc π)))
x : (a : α) → T ⟶ P.obj (X a).op
hx :
∀ (R : CompHaus) (i j : α) (ri : R ⟶ X i) (rj : R ⟶ X j),
(P ⋙ coyoneda.obj T.op).map ri.op (x i) = (P ⋙ coyoneda.obj T.op).map rj.op (x j)
⊢ ∃! b, ∀ (i : α), (P ⋙ coyoneda.obj T.op).map (π i).op b = x i | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case mpr.intro.intro.intro.intro.intro
C : Type w
inst✝ : Category C
P : CompHausᵒᵖ ⥤ C
H1 : ProductCondition P
T : C
B : CompHaus
α : Type
w✝ : Fintype α
X : α → CompHaus
π : (a : α) → X a ⟶ B
H : EffectiveEpiFamily X π
H2 : Nonempty (IsLimit (equalizerFork P (Sigma.desc π)))
x : (a : α) → T ⟶ P.obj (X a).op
hx :
∀ (R : CompHaus) (i j : α) (ri : R ⟶ X i) (rj : R ⟶ X j),
(P ⋙ coyoneda.obj T.op).map ri.op (x i) = (P ⋙ coyoneda.obj T.op).map rj.op (x j)
⊢ ∃! b, ∀ (i : α), (P ⋙ coyoneda.obj T.op).map (π i).op b = x i
TACTIC:
|
https://github.com/adamtopaz/CopenhagenMasterclass2023.git | a293ca1554f7e80d891fd4d86fb092c54d8a0a01 | Condensed/ExtrDiscSheafCondition.lean | ExtrDisc.Sheaf.isSheafColimitAux | [87, 1] | [92, 38] | rw [sheafCondition] | A : Type (u + 2)
inst✝⁴ : Category A
inst✝³ : HasZeroMorphisms A
inst✝² : HasFiniteBiproducts A
J : Type (u + 1)
inst✝¹ : SmallCategory J
F : J ⥤ ExtrDiscᵒᵖ ⥤ A
inst✝ : HasColimit F
h : ∀ (j : J), Presheaf.IsSheaf (coherentTopology ExtrDisc) (F.obj j)
⊢ Presheaf.IsSheaf (coherentTopology ExtrDisc) (colimit F) | A : Type (u + 2)
inst✝⁴ : Category A
inst✝³ : HasZeroMorphisms A
inst✝² : HasFiniteBiproducts A
J : Type (u + 1)
inst✝¹ : SmallCategory J
F : J ⥤ ExtrDiscᵒᵖ ⥤ A
inst✝ : HasColimit F
h : ∀ (j : J), Presheaf.IsSheaf (coherentTopology ExtrDisc) (F.obj j)
⊢ Nonempty (PreservesFiniteProducts (colimit F)) | Please generate a tactic in lean4 to solve the state.
STATE:
A : Type (u + 2)
inst✝⁴ : Category A
inst✝³ : HasZeroMorphisms A
inst✝² : HasFiniteBiproducts A
J : Type (u + 1)
inst✝¹ : SmallCategory J
F : J ⥤ ExtrDiscᵒᵖ ⥤ A
inst✝ : HasColimit F
h : ∀ (j : J), Presheaf.IsSheaf (coherentTopology ExtrDisc) (F.obj j)
⊢ Presheaf.IsSheaf (coherentTopology ExtrDisc) (colimit F)
TACTIC:
|
https://github.com/adamtopaz/CopenhagenMasterclass2023.git | a293ca1554f7e80d891fd4d86fb092c54d8a0a01 | Condensed/ExtrDiscSheafCondition.lean | ExtrDisc.Sheaf.isSheafColimitAux | [87, 1] | [92, 38] | exact ⟨preservesFiniteProducts _ h⟩ | A : Type (u + 2)
inst✝⁴ : Category A
inst✝³ : HasZeroMorphisms A
inst✝² : HasFiniteBiproducts A
J : Type (u + 1)
inst✝¹ : SmallCategory J
F : J ⥤ ExtrDiscᵒᵖ ⥤ A
inst✝ : HasColimit F
h : ∀ (j : J), Presheaf.IsSheaf (coherentTopology ExtrDisc) (F.obj j)
⊢ Nonempty (PreservesFiniteProducts (colimit F)) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
A : Type (u + 2)
inst✝⁴ : Category A
inst✝³ : HasZeroMorphisms A
inst✝² : HasFiniteBiproducts A
J : Type (u + 1)
inst✝¹ : SmallCategory J
F : J ⥤ ExtrDiscᵒᵖ ⥤ A
inst✝ : HasColimit F
h : ∀ (j : J), Presheaf.IsSheaf (coherentTopology ExtrDisc) (F.obj j)
⊢ Nonempty (PreservesFiniteProducts (colimit F))
TACTIC:
|
https://github.com/adamtopaz/CopenhagenMasterclass2023.git | a293ca1554f7e80d891fd4d86fb092c54d8a0a01 | Condensed/ExtrDiscSheafCondition.lean | ExtrDisc.Sheaf.isSheafColimit | [94, 1] | [100, 19] | apply isSheafColimitAux | A : Type (u + 2)
inst✝⁴ : Category A
inst✝³ : HasZeroMorphisms A
inst✝² : HasFiniteBiproducts A
J : Type (u + 1)
inst✝¹ : SmallCategory J
F✝ : J ⥤ ExtrDiscᵒᵖ ⥤ A
F : J ⥤ Sheaf (coherentTopology ExtrDisc) A
inst✝ : HasColimit (F ⋙ sheafToPresheaf (coherentTopology ExtrDisc) A)
⊢ Presheaf.IsSheaf (coherentTopology ExtrDisc) (colimit (F ⋙ sheafToPresheaf (coherentTopology ExtrDisc) A)) | case h
A : Type (u + 2)
inst✝⁴ : Category A
inst✝³ : HasZeroMorphisms A
inst✝² : HasFiniteBiproducts A
J : Type (u + 1)
inst✝¹ : SmallCategory J
F✝ : J ⥤ ExtrDiscᵒᵖ ⥤ A
F : J ⥤ Sheaf (coherentTopology ExtrDisc) A
inst✝ : HasColimit (F ⋙ sheafToPresheaf (coherentTopology ExtrDisc) A)
⊢ ∀ (j : J), Presheaf.IsSheaf (coherentTopology ExtrDisc) ((F ⋙ sheafToPresheaf (coherentTopology ExtrDisc) A).obj j) | Please generate a tactic in lean4 to solve the state.
STATE:
A : Type (u + 2)
inst✝⁴ : Category A
inst✝³ : HasZeroMorphisms A
inst✝² : HasFiniteBiproducts A
J : Type (u + 1)
inst✝¹ : SmallCategory J
F✝ : J ⥤ ExtrDiscᵒᵖ ⥤ A
F : J ⥤ Sheaf (coherentTopology ExtrDisc) A
inst✝ : HasColimit (F ⋙ sheafToPresheaf (coherentTopology ExtrDisc) A)
⊢ Presheaf.IsSheaf (coherentTopology ExtrDisc) (colimit (F ⋙ sheafToPresheaf (coherentTopology ExtrDisc) A))
TACTIC:
|
https://github.com/adamtopaz/CopenhagenMasterclass2023.git | a293ca1554f7e80d891fd4d86fb092c54d8a0a01 | Condensed/ExtrDiscSheafCondition.lean | ExtrDisc.Sheaf.isSheafColimit | [94, 1] | [100, 19] | intro j | case h
A : Type (u + 2)
inst✝⁴ : Category A
inst✝³ : HasZeroMorphisms A
inst✝² : HasFiniteBiproducts A
J : Type (u + 1)
inst✝¹ : SmallCategory J
F✝ : J ⥤ ExtrDiscᵒᵖ ⥤ A
F : J ⥤ Sheaf (coherentTopology ExtrDisc) A
inst✝ : HasColimit (F ⋙ sheafToPresheaf (coherentTopology ExtrDisc) A)
⊢ ∀ (j : J), Presheaf.IsSheaf (coherentTopology ExtrDisc) ((F ⋙ sheafToPresheaf (coherentTopology ExtrDisc) A).obj j) | case h
A : Type (u + 2)
inst✝⁴ : Category A
inst✝³ : HasZeroMorphisms A
inst✝² : HasFiniteBiproducts A
J : Type (u + 1)
inst✝¹ : SmallCategory J
F✝ : J ⥤ ExtrDiscᵒᵖ ⥤ A
F : J ⥤ Sheaf (coherentTopology ExtrDisc) A
inst✝ : HasColimit (F ⋙ sheafToPresheaf (coherentTopology ExtrDisc) A)
j : J
⊢ Presheaf.IsSheaf (coherentTopology ExtrDisc) ((F ⋙ sheafToPresheaf (coherentTopology ExtrDisc) A).obj j) | Please generate a tactic in lean4 to solve the state.
STATE:
case h
A : Type (u + 2)
inst✝⁴ : Category A
inst✝³ : HasZeroMorphisms A
inst✝² : HasFiniteBiproducts A
J : Type (u + 1)
inst✝¹ : SmallCategory J
F✝ : J ⥤ ExtrDiscᵒᵖ ⥤ A
F : J ⥤ Sheaf (coherentTopology ExtrDisc) A
inst✝ : HasColimit (F ⋙ sheafToPresheaf (coherentTopology ExtrDisc) A)
⊢ ∀ (j : J), Presheaf.IsSheaf (coherentTopology ExtrDisc) ((F ⋙ sheafToPresheaf (coherentTopology ExtrDisc) A).obj j)
TACTIC:
|
https://github.com/adamtopaz/CopenhagenMasterclass2023.git | a293ca1554f7e80d891fd4d86fb092c54d8a0a01 | Condensed/ExtrDiscSheafCondition.lean | ExtrDisc.Sheaf.isSheafColimit | [94, 1] | [100, 19] | apply Sheaf.cond | case h
A : Type (u + 2)
inst✝⁴ : Category A
inst✝³ : HasZeroMorphisms A
inst✝² : HasFiniteBiproducts A
J : Type (u + 1)
inst✝¹ : SmallCategory J
F✝ : J ⥤ ExtrDiscᵒᵖ ⥤ A
F : J ⥤ Sheaf (coherentTopology ExtrDisc) A
inst✝ : HasColimit (F ⋙ sheafToPresheaf (coherentTopology ExtrDisc) A)
j : J
⊢ Presheaf.IsSheaf (coherentTopology ExtrDisc) ((F ⋙ sheafToPresheaf (coherentTopology ExtrDisc) A).obj j) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case h
A : Type (u + 2)
inst✝⁴ : Category A
inst✝³ : HasZeroMorphisms A
inst✝² : HasFiniteBiproducts A
J : Type (u + 1)
inst✝¹ : SmallCategory J
F✝ : J ⥤ ExtrDiscᵒᵖ ⥤ A
F : J ⥤ Sheaf (coherentTopology ExtrDisc) A
inst✝ : HasColimit (F ⋙ sheafToPresheaf (coherentTopology ExtrDisc) A)
j : J
⊢ Presheaf.IsSheaf (coherentTopology ExtrDisc) ((F ⋙ sheafToPresheaf (coherentTopology ExtrDisc) A).obj j)
TACTIC:
|
https://github.com/adamtopaz/CopenhagenMasterclass2023.git | a293ca1554f7e80d891fd4d86fb092c54d8a0a01 | Condensed/ExtrDiscSheafCondition.lean | ExtrDisc.Sheaf.isSheafOfIsColimit | [102, 1] | [111, 23] | have : HasColimit (F ⋙ sheafToPresheaf _ _) := ⟨S,hS⟩ | A : Type (u + 2)
inst✝³ : Category A
inst✝² : HasZeroMorphisms A
inst✝¹ : HasFiniteBiproducts A
J : Type (u + 1)
inst✝ : SmallCategory J
F✝ : J ⥤ ExtrDiscᵒᵖ ⥤ A
F : J ⥤ Sheaf (coherentTopology ExtrDisc) A
S : Cocone (F ⋙ sheafToPresheaf (coherentTopology ExtrDisc) A)
hS : IsColimit S
⊢ Presheaf.IsSheaf (coherentTopology ExtrDisc) S.pt | A : Type (u + 2)
inst✝³ : Category A
inst✝² : HasZeroMorphisms A
inst✝¹ : HasFiniteBiproducts A
J : Type (u + 1)
inst✝ : SmallCategory J
F✝ : J ⥤ ExtrDiscᵒᵖ ⥤ A
F : J ⥤ Sheaf (coherentTopology ExtrDisc) A
S : Cocone (F ⋙ sheafToPresheaf (coherentTopology ExtrDisc) A)
hS : IsColimit S
this : HasColimit (F ⋙ sheafToPresheaf (coherentTopology ExtrDisc) A)
⊢ Presheaf.IsSheaf (coherentTopology ExtrDisc) S.pt | Please generate a tactic in lean4 to solve the state.
STATE:
A : Type (u + 2)
inst✝³ : Category A
inst✝² : HasZeroMorphisms A
inst✝¹ : HasFiniteBiproducts A
J : Type (u + 1)
inst✝ : SmallCategory J
F✝ : J ⥤ ExtrDiscᵒᵖ ⥤ A
F : J ⥤ Sheaf (coherentTopology ExtrDisc) A
S : Cocone (F ⋙ sheafToPresheaf (coherentTopology ExtrDisc) A)
hS : IsColimit S
⊢ Presheaf.IsSheaf (coherentTopology ExtrDisc) S.pt
TACTIC:
|
https://github.com/adamtopaz/CopenhagenMasterclass2023.git | a293ca1554f7e80d891fd4d86fb092c54d8a0a01 | Condensed/ExtrDiscSheafCondition.lean | ExtrDisc.Sheaf.isSheafOfIsColimit | [102, 1] | [111, 23] | let e : S.pt ≅ colimit (F ⋙ sheafToPresheaf _ _) :=
hS.coconePointUniqueUpToIso (colimit.isColimit _) | A : Type (u + 2)
inst✝³ : Category A
inst✝² : HasZeroMorphisms A
inst✝¹ : HasFiniteBiproducts A
J : Type (u + 1)
inst✝ : SmallCategory J
F✝ : J ⥤ ExtrDiscᵒᵖ ⥤ A
F : J ⥤ Sheaf (coherentTopology ExtrDisc) A
S : Cocone (F ⋙ sheafToPresheaf (coherentTopology ExtrDisc) A)
hS : IsColimit S
this : HasColimit (F ⋙ sheafToPresheaf (coherentTopology ExtrDisc) A)
⊢ Presheaf.IsSheaf (coherentTopology ExtrDisc) S.pt | A : Type (u + 2)
inst✝³ : Category A
inst✝² : HasZeroMorphisms A
inst✝¹ : HasFiniteBiproducts A
J : Type (u + 1)
inst✝ : SmallCategory J
F✝ : J ⥤ ExtrDiscᵒᵖ ⥤ A
F : J ⥤ Sheaf (coherentTopology ExtrDisc) A
S : Cocone (F ⋙ sheafToPresheaf (coherentTopology ExtrDisc) A)
hS : IsColimit S
this : HasColimit (F ⋙ sheafToPresheaf (coherentTopology ExtrDisc) A)
e : S.pt ≅ colimit (F ⋙ sheafToPresheaf (coherentTopology ExtrDisc) A) :=
IsColimit.coconePointUniqueUpToIso hS (colimit.isColimit (F ⋙ sheafToPresheaf (coherentTopology ExtrDisc) A))
⊢ Presheaf.IsSheaf (coherentTopology ExtrDisc) S.pt | Please generate a tactic in lean4 to solve the state.
STATE:
A : Type (u + 2)
inst✝³ : Category A
inst✝² : HasZeroMorphisms A
inst✝¹ : HasFiniteBiproducts A
J : Type (u + 1)
inst✝ : SmallCategory J
F✝ : J ⥤ ExtrDiscᵒᵖ ⥤ A
F : J ⥤ Sheaf (coherentTopology ExtrDisc) A
S : Cocone (F ⋙ sheafToPresheaf (coherentTopology ExtrDisc) A)
hS : IsColimit S
this : HasColimit (F ⋙ sheafToPresheaf (coherentTopology ExtrDisc) A)
⊢ Presheaf.IsSheaf (coherentTopology ExtrDisc) S.pt
TACTIC:
|
https://github.com/adamtopaz/CopenhagenMasterclass2023.git | a293ca1554f7e80d891fd4d86fb092c54d8a0a01 | Condensed/ExtrDiscSheafCondition.lean | ExtrDisc.Sheaf.isSheafOfIsColimit | [102, 1] | [111, 23] | rw [Presheaf.isSheaf_of_iso_iff e] | A : Type (u + 2)
inst✝³ : Category A
inst✝² : HasZeroMorphisms A
inst✝¹ : HasFiniteBiproducts A
J : Type (u + 1)
inst✝ : SmallCategory J
F✝ : J ⥤ ExtrDiscᵒᵖ ⥤ A
F : J ⥤ Sheaf (coherentTopology ExtrDisc) A
S : Cocone (F ⋙ sheafToPresheaf (coherentTopology ExtrDisc) A)
hS : IsColimit S
this : HasColimit (F ⋙ sheafToPresheaf (coherentTopology ExtrDisc) A)
e : S.pt ≅ colimit (F ⋙ sheafToPresheaf (coherentTopology ExtrDisc) A) :=
IsColimit.coconePointUniqueUpToIso hS (colimit.isColimit (F ⋙ sheafToPresheaf (coherentTopology ExtrDisc) A))
⊢ Presheaf.IsSheaf (coherentTopology ExtrDisc) S.pt | A : Type (u + 2)
inst✝³ : Category A
inst✝² : HasZeroMorphisms A
inst✝¹ : HasFiniteBiproducts A
J : Type (u + 1)
inst✝ : SmallCategory J
F✝ : J ⥤ ExtrDiscᵒᵖ ⥤ A
F : J ⥤ Sheaf (coherentTopology ExtrDisc) A
S : Cocone (F ⋙ sheafToPresheaf (coherentTopology ExtrDisc) A)
hS : IsColimit S
this : HasColimit (F ⋙ sheafToPresheaf (coherentTopology ExtrDisc) A)
e : S.pt ≅ colimit (F ⋙ sheafToPresheaf (coherentTopology ExtrDisc) A) :=
IsColimit.coconePointUniqueUpToIso hS (colimit.isColimit (F ⋙ sheafToPresheaf (coherentTopology ExtrDisc) A))
⊢ Presheaf.IsSheaf (coherentTopology ExtrDisc) (colimit (F ⋙ sheafToPresheaf (coherentTopology ExtrDisc) A)) | Please generate a tactic in lean4 to solve the state.
STATE:
A : Type (u + 2)
inst✝³ : Category A
inst✝² : HasZeroMorphisms A
inst✝¹ : HasFiniteBiproducts A
J : Type (u + 1)
inst✝ : SmallCategory J
F✝ : J ⥤ ExtrDiscᵒᵖ ⥤ A
F : J ⥤ Sheaf (coherentTopology ExtrDisc) A
S : Cocone (F ⋙ sheafToPresheaf (coherentTopology ExtrDisc) A)
hS : IsColimit S
this : HasColimit (F ⋙ sheafToPresheaf (coherentTopology ExtrDisc) A)
e : S.pt ≅ colimit (F ⋙ sheafToPresheaf (coherentTopology ExtrDisc) A) :=
IsColimit.coconePointUniqueUpToIso hS (colimit.isColimit (F ⋙ sheafToPresheaf (coherentTopology ExtrDisc) A))
⊢ Presheaf.IsSheaf (coherentTopology ExtrDisc) S.pt
TACTIC:
|
https://github.com/adamtopaz/CopenhagenMasterclass2023.git | a293ca1554f7e80d891fd4d86fb092c54d8a0a01 | Condensed/ExtrDiscSheafCondition.lean | ExtrDisc.Sheaf.isSheafOfIsColimit | [102, 1] | [111, 23] | apply isSheafColimit | A : Type (u + 2)
inst✝³ : Category A
inst✝² : HasZeroMorphisms A
inst✝¹ : HasFiniteBiproducts A
J : Type (u + 1)
inst✝ : SmallCategory J
F✝ : J ⥤ ExtrDiscᵒᵖ ⥤ A
F : J ⥤ Sheaf (coherentTopology ExtrDisc) A
S : Cocone (F ⋙ sheafToPresheaf (coherentTopology ExtrDisc) A)
hS : IsColimit S
this : HasColimit (F ⋙ sheafToPresheaf (coherentTopology ExtrDisc) A)
e : S.pt ≅ colimit (F ⋙ sheafToPresheaf (coherentTopology ExtrDisc) A) :=
IsColimit.coconePointUniqueUpToIso hS (colimit.isColimit (F ⋙ sheafToPresheaf (coherentTopology ExtrDisc) A))
⊢ Presheaf.IsSheaf (coherentTopology ExtrDisc) (colimit (F ⋙ sheafToPresheaf (coherentTopology ExtrDisc) A)) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
A : Type (u + 2)
inst✝³ : Category A
inst✝² : HasZeroMorphisms A
inst✝¹ : HasFiniteBiproducts A
J : Type (u + 1)
inst✝ : SmallCategory J
F✝ : J ⥤ ExtrDiscᵒᵖ ⥤ A
F : J ⥤ Sheaf (coherentTopology ExtrDisc) A
S : Cocone (F ⋙ sheafToPresheaf (coherentTopology ExtrDisc) A)
hS : IsColimit S
this : HasColimit (F ⋙ sheafToPresheaf (coherentTopology ExtrDisc) A)
e : S.pt ≅ colimit (F ⋙ sheafToPresheaf (coherentTopology ExtrDisc) A) :=
IsColimit.coconePointUniqueUpToIso hS (colimit.isColimit (F ⋙ sheafToPresheaf (coherentTopology ExtrDisc) A))
⊢ Presheaf.IsSheaf (coherentTopology ExtrDisc) (colimit (F ⋙ sheafToPresheaf (coherentTopology ExtrDisc) A))
TACTIC:
|
https://github.com/adamtopaz/CopenhagenMasterclass2023.git | a293ca1554f7e80d891fd4d86fb092c54d8a0a01 | Sieves/OpenEmbedding.lean | ExtrDisc.toFiniteCoproductCompFromFiniteCoproduct | [22, 1] | [25, 48] | ext | α : Type
inst✝ : Fintype α
Z : α → ExtrDisc
⊢ toFiniteCoproduct Z ≫ fromFiniteCoproduct Z = 𝟙 (∐ Z) | case h.w
α : Type
inst✝ : Fintype α
Z : α → ExtrDisc
b✝ : α
x✝ : (forget ExtrDisc).obj (Z b✝)
⊢ ↑(Sigma.ι Z b✝ ≫ toFiniteCoproduct Z ≫ fromFiniteCoproduct Z) x✝ = ↑(Sigma.ι Z b✝ ≫ 𝟙 (∐ Z)) x✝ | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type
inst✝ : Fintype α
Z : α → ExtrDisc
⊢ toFiniteCoproduct Z ≫ fromFiniteCoproduct Z = 𝟙 (∐ Z)
TACTIC:
|
https://github.com/adamtopaz/CopenhagenMasterclass2023.git | a293ca1554f7e80d891fd4d86fb092c54d8a0a01 | Sieves/OpenEmbedding.lean | ExtrDisc.toFiniteCoproductCompFromFiniteCoproduct | [22, 1] | [25, 48] | simp [toFiniteCoproduct, fromFiniteCoproduct] | case h.w
α : Type
inst✝ : Fintype α
Z : α → ExtrDisc
b✝ : α
x✝ : (forget ExtrDisc).obj (Z b✝)
⊢ ↑(Sigma.ι Z b✝ ≫ toFiniteCoproduct Z ≫ fromFiniteCoproduct Z) x✝ = ↑(Sigma.ι Z b✝ ≫ 𝟙 (∐ Z)) x✝ | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case h.w
α : Type
inst✝ : Fintype α
Z : α → ExtrDisc
b✝ : α
x✝ : (forget ExtrDisc).obj (Z b✝)
⊢ ↑(Sigma.ι Z b✝ ≫ toFiniteCoproduct Z ≫ fromFiniteCoproduct Z) x✝ = ↑(Sigma.ι Z b✝ ≫ 𝟙 (∐ Z)) x✝
TACTIC:
|
https://github.com/adamtopaz/CopenhagenMasterclass2023.git | a293ca1554f7e80d891fd4d86fb092c54d8a0a01 | Sieves/OpenEmbedding.lean | ExtrDisc.FromFiniteCoproductComptToFiniteCoproduct | [28, 1] | [31, 48] | refine' finiteCoproduct.hom_ext _ _ _ (fun a => _) | α : Type
inst✝ : Fintype α
Z : α → ExtrDisc
⊢ fromFiniteCoproduct Z ≫ toFiniteCoproduct Z = 𝟙 (finiteCoproduct Z) | α : Type
inst✝ : Fintype α
Z : α → ExtrDisc
a : α
⊢ finiteCoproduct.ι Z a ≫ fromFiniteCoproduct Z ≫ toFiniteCoproduct Z = finiteCoproduct.ι Z a ≫ 𝟙 (finiteCoproduct Z) | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type
inst✝ : Fintype α
Z : α → ExtrDisc
⊢ fromFiniteCoproduct Z ≫ toFiniteCoproduct Z = 𝟙 (finiteCoproduct Z)
TACTIC:
|
https://github.com/adamtopaz/CopenhagenMasterclass2023.git | a293ca1554f7e80d891fd4d86fb092c54d8a0a01 | Sieves/OpenEmbedding.lean | ExtrDisc.FromFiniteCoproductComptToFiniteCoproduct | [28, 1] | [31, 48] | simp [toFiniteCoproduct, fromFiniteCoproduct] | α : Type
inst✝ : Fintype α
Z : α → ExtrDisc
a : α
⊢ finiteCoproduct.ι Z a ≫ fromFiniteCoproduct Z ≫ toFiniteCoproduct Z = finiteCoproduct.ι Z a ≫ 𝟙 (finiteCoproduct Z) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type
inst✝ : Fintype α
Z : α → ExtrDisc
a : α
⊢ finiteCoproduct.ι Z a ≫ fromFiniteCoproduct Z ≫ toFiniteCoproduct Z = finiteCoproduct.ι Z a ≫ 𝟙 (finiteCoproduct Z)
TACTIC:
|
https://github.com/adamtopaz/CopenhagenMasterclass2023.git | a293ca1554f7e80d891fd4d86fb092c54d8a0a01 | Sieves/OpenEmbedding.lean | ExtrDisc.IsIsotoFiniteCoproduct | [49, 1] | [51, 44] | simp | α : Type
inst✝ : Fintype α
Z : α → ExtrDisc
⊢ toFiniteCoproduct Z ≫ fromFiniteCoproduct Z = 𝟙 (∐ Z) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type
inst✝ : Fintype α
Z : α → ExtrDisc
⊢ toFiniteCoproduct Z ≫ fromFiniteCoproduct Z = 𝟙 (∐ Z)
TACTIC:
|
https://github.com/adamtopaz/CopenhagenMasterclass2023.git | a293ca1554f7e80d891fd4d86fb092c54d8a0a01 | Sieves/OpenEmbedding.lean | ExtrDisc.IsIsotoFiniteCoproduct | [49, 1] | [51, 44] | simp | α : Type
inst✝ : Fintype α
Z : α → ExtrDisc
⊢ fromFiniteCoproduct Z ≫ toFiniteCoproduct Z = 𝟙 (finiteCoproduct Z) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type
inst✝ : Fintype α
Z : α → ExtrDisc
⊢ fromFiniteCoproduct Z ≫ toFiniteCoproduct Z = 𝟙 (finiteCoproduct Z)
TACTIC:
|
https://github.com/adamtopaz/CopenhagenMasterclass2023.git | a293ca1554f7e80d891fd4d86fb092c54d8a0a01 | Sieves/OpenEmbedding.lean | ExtrDisc.IsIsofromFiniteCoproduct | [53, 1] | [55, 42] | simp | α : Type
inst✝ : Fintype α
Z : α → ExtrDisc
⊢ fromFiniteCoproduct Z ≫ toFiniteCoproduct Z = 𝟙 (finiteCoproduct Z) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type
inst✝ : Fintype α
Z : α → ExtrDisc
⊢ fromFiniteCoproduct Z ≫ toFiniteCoproduct Z = 𝟙 (finiteCoproduct Z)
TACTIC:
|
https://github.com/adamtopaz/CopenhagenMasterclass2023.git | a293ca1554f7e80d891fd4d86fb092c54d8a0a01 | Sieves/OpenEmbedding.lean | ExtrDisc.IsIsofromFiniteCoproduct | [53, 1] | [55, 42] | simp | α : Type
inst✝ : Fintype α
Z : α → ExtrDisc
⊢ toFiniteCoproduct Z ≫ fromFiniteCoproduct Z = 𝟙 (∐ Z) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type
inst✝ : Fintype α
Z : α → ExtrDisc
⊢ toFiniteCoproduct Z ≫ fromFiniteCoproduct Z = 𝟙 (∐ Z)
TACTIC:
|
https://github.com/adamtopaz/CopenhagenMasterclass2023.git | a293ca1554f7e80d891fd4d86fb092c54d8a0a01 | Sieves/OpenEmbedding.lean | ExtrDisc.Sigma.ιCompToFiniteCoproduct | [58, 1] | [60, 27] | simp [toFiniteCoproduct] | α : Type
inst✝ : Fintype α
Z : α → ExtrDisc
a : α
⊢ Sigma.ι Z a ≫ toFiniteCoproduct Z = finiteCoproduct.ι Z a | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type
inst✝ : Fintype α
Z : α → ExtrDisc
a : α
⊢ Sigma.ι Z a ≫ toFiniteCoproduct Z = finiteCoproduct.ι Z a
TACTIC:
|
https://github.com/adamtopaz/CopenhagenMasterclass2023.git | a293ca1554f7e80d891fd4d86fb092c54d8a0a01 | Sieves/OpenEmbedding.lean | ExtrDisc.finiteCoproduct.ιCompFromFiniteCoproduct | [63, 1] | [65, 29] | simp [fromFiniteCoproduct] | α : Type
inst✝ : Fintype α
Z : α → ExtrDisc
a : α
⊢ ι Z a ≫ fromFiniteCoproduct Z = Sigma.ι Z a | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
α : Type
inst✝ : Fintype α
Z : α → ExtrDisc
a : α
⊢ ι Z a ≫ fromFiniteCoproduct Z = Sigma.ι Z a
TACTIC:
|
https://github.com/adamtopaz/CopenhagenMasterclass2023.git | a293ca1554f7e80d891fd4d86fb092c54d8a0a01 | Sieves/OpenEmbedding.lean | ExtrDisc.finiteCoproduct.ιOpenEmbedding | [89, 1] | [91, 52] | exact openEmbedding_sigmaMk (σ := fun a => (Z a)) | α✝ : Type
inst✝¹ : Fintype α✝
Z✝ : α✝ → ExtrDisc
α : Type
inst✝ : Fintype α
Z : α → ExtrDisc
a : α
⊢ OpenEmbedding ↑(ι Z a) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
α✝ : Type
inst✝¹ : Fintype α✝
Z✝ : α✝ → ExtrDisc
α : Type
inst✝ : Fintype α
Z : α → ExtrDisc
a : α
⊢ OpenEmbedding ↑(ι Z a)
TACTIC:
|
https://github.com/adamtopaz/CopenhagenMasterclass2023.git | a293ca1554f7e80d891fd4d86fb092c54d8a0a01 | Sieves/OpenEmbedding.lean | ExtrDisc.openEmbedding_ι | [93, 1] | [99, 7] | refine' OpenEmbedding.of_comp _ (toFiniteCoproduct.OpenEmbedding Z) _ | α✝ : Type
inst✝¹ : Fintype α✝
Z✝ : α✝ → ExtrDisc
α : Type
inst✝ : Fintype α
Z : α → ExtrDisc
a : α
⊢ OpenEmbedding ↑(Sigma.ι Z a) | α✝ : Type
inst✝¹ : Fintype α✝
Z✝ : α✝ → ExtrDisc
α : Type
inst✝ : Fintype α
Z : α → ExtrDisc
a : α
⊢ OpenEmbedding (↑(toFiniteCoproductHomeo Z) ∘ ↑(Sigma.ι Z a)) | Please generate a tactic in lean4 to solve the state.
STATE:
α✝ : Type
inst✝¹ : Fintype α✝
Z✝ : α✝ → ExtrDisc
α : Type
inst✝ : Fintype α
Z : α → ExtrDisc
a : α
⊢ OpenEmbedding ↑(Sigma.ι Z a)
TACTIC:
|
https://github.com/adamtopaz/CopenhagenMasterclass2023.git | a293ca1554f7e80d891fd4d86fb092c54d8a0a01 | Sieves/OpenEmbedding.lean | ExtrDisc.openEmbedding_ι | [93, 1] | [99, 7] | convert finiteCoproduct.ιOpenEmbedding Z a | α✝ : Type
inst✝¹ : Fintype α✝
Z✝ : α✝ → ExtrDisc
α : Type
inst✝ : Fintype α
Z : α → ExtrDisc
a : α
⊢ OpenEmbedding (↑(toFiniteCoproductHomeo Z) ∘ ↑(Sigma.ι Z a)) | case h.e'_5
α✝ : Type
inst✝¹ : Fintype α✝
Z✝ : α✝ → ExtrDisc
α : Type
inst✝ : Fintype α
Z : α → ExtrDisc
a : α
⊢ ↑(toFiniteCoproductHomeo Z) ∘ ↑(Sigma.ι Z a) = ↑(finiteCoproduct.ι Z a) | Please generate a tactic in lean4 to solve the state.
STATE:
α✝ : Type
inst✝¹ : Fintype α✝
Z✝ : α✝ → ExtrDisc
α : Type
inst✝ : Fintype α
Z : α → ExtrDisc
a : α
⊢ OpenEmbedding (↑(toFiniteCoproductHomeo Z) ∘ ↑(Sigma.ι Z a))
TACTIC:
|
https://github.com/adamtopaz/CopenhagenMasterclass2023.git | a293ca1554f7e80d891fd4d86fb092c54d8a0a01 | Sieves/OpenEmbedding.lean | ExtrDisc.openEmbedding_ι | [93, 1] | [99, 7] | ext x | case h.e'_5
α✝ : Type
inst✝¹ : Fintype α✝
Z✝ : α✝ → ExtrDisc
α : Type
inst✝ : Fintype α
Z : α → ExtrDisc
a : α
⊢ ↑(toFiniteCoproductHomeo Z) ∘ ↑(Sigma.ι Z a) = ↑(finiteCoproduct.ι Z a) | case h.e'_5.h
α✝ : Type
inst✝¹ : Fintype α✝
Z✝ : α✝ → ExtrDisc
α : Type
inst✝ : Fintype α
Z : α → ExtrDisc
a : α
x : CoeSort.coe (Z a)
⊢ (↑(toFiniteCoproductHomeo Z) ∘ ↑(Sigma.ι Z a)) x = ↑(finiteCoproduct.ι Z a) x | Please generate a tactic in lean4 to solve the state.
STATE:
case h.e'_5
α✝ : Type
inst✝¹ : Fintype α✝
Z✝ : α✝ → ExtrDisc
α : Type
inst✝ : Fintype α
Z : α → ExtrDisc
a : α
⊢ ↑(toFiniteCoproductHomeo Z) ∘ ↑(Sigma.ι Z a) = ↑(finiteCoproduct.ι Z a)
TACTIC:
|
https://github.com/adamtopaz/CopenhagenMasterclass2023.git | a293ca1554f7e80d891fd4d86fb092c54d8a0a01 | Sieves/OpenEmbedding.lean | ExtrDisc.openEmbedding_ι | [93, 1] | [99, 7] | change ((Sigma.ι Z a) ≫ toFiniteCoproduct Z) x = _ | case h.e'_5.h
α✝ : Type
inst✝¹ : Fintype α✝
Z✝ : α✝ → ExtrDisc
α : Type
inst✝ : Fintype α
Z : α → ExtrDisc
a : α
x : CoeSort.coe (Z a)
⊢ (↑(toFiniteCoproductHomeo Z) ∘ ↑(Sigma.ι Z a)) x = ↑(finiteCoproduct.ι Z a) x | case h.e'_5.h
α✝ : Type
inst✝¹ : Fintype α✝
Z✝ : α✝ → ExtrDisc
α : Type
inst✝ : Fintype α
Z : α → ExtrDisc
a : α
x : CoeSort.coe (Z a)
⊢ ↑(Sigma.ι Z a ≫ toFiniteCoproduct Z) x = ↑(finiteCoproduct.ι Z a) x | Please generate a tactic in lean4 to solve the state.
STATE:
case h.e'_5.h
α✝ : Type
inst✝¹ : Fintype α✝
Z✝ : α✝ → ExtrDisc
α : Type
inst✝ : Fintype α
Z : α → ExtrDisc
a : α
x : CoeSort.coe (Z a)
⊢ (↑(toFiniteCoproductHomeo Z) ∘ ↑(Sigma.ι Z a)) x = ↑(finiteCoproduct.ι Z a) x
TACTIC:
|
https://github.com/adamtopaz/CopenhagenMasterclass2023.git | a293ca1554f7e80d891fd4d86fb092c54d8a0a01 | Sieves/OpenEmbedding.lean | ExtrDisc.openEmbedding_ι | [93, 1] | [99, 7] | simp | case h.e'_5.h
α✝ : Type
inst✝¹ : Fintype α✝
Z✝ : α✝ → ExtrDisc
α : Type
inst✝ : Fintype α
Z : α → ExtrDisc
a : α
x : CoeSort.coe (Z a)
⊢ ↑(Sigma.ι Z a ≫ toFiniteCoproduct Z) x = ↑(finiteCoproduct.ι Z a) x | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case h.e'_5.h
α✝ : Type
inst✝¹ : Fintype α✝
Z✝ : α✝ → ExtrDisc
α : Type
inst✝ : Fintype α
Z : α → ExtrDisc
a : α
x : CoeSort.coe (Z a)
⊢ ↑(Sigma.ι Z a ≫ toFiniteCoproduct Z) x = ↑(finiteCoproduct.ι Z a) x
TACTIC:
|
https://github.com/adamtopaz/CopenhagenMasterclass2023.git | a293ca1554f7e80d891fd4d86fb092c54d8a0a01 | Sieves/ExtensiveRegular.lean | CategoryTheory.isPullbackSieve_ExtensiveSieve | [139, 1] | [145, 45] | rcases hS with ⟨α, _, Z, π, hS, HIso⟩ | C : Type u
inst✝² : Category C
inst✝¹ : HasFiniteCoproducts C
inst✝ : HasPullbackOfIsIsodesc C
X : C
S : Presieve X
hS : S ∈ ExtensiveSieve X
⊢ isPullbackPresieve S | case intro.intro.intro.intro.intro
C : Type u
inst✝² : Category C
inst✝¹ : HasFiniteCoproducts C
inst✝ : HasPullbackOfIsIsodesc C
X : C
S : Presieve X
α : Type
w✝ : Fintype α
Z : α → C
π : (a : α) → Z a ⟶ X
hS : S = Presieve.ofArrows Z π
HIso : IsIso (Sigma.desc π)
⊢ isPullbackPresieve S | Please generate a tactic in lean4 to solve the state.
STATE:
C : Type u
inst✝² : Category C
inst✝¹ : HasFiniteCoproducts C
inst✝ : HasPullbackOfIsIsodesc C
X : C
S : Presieve X
hS : S ∈ ExtensiveSieve X
⊢ isPullbackPresieve S
TACTIC:
|
https://github.com/adamtopaz/CopenhagenMasterclass2023.git | a293ca1554f7e80d891fd4d86fb092c54d8a0a01 | Sieves/ExtensiveRegular.lean | CategoryTheory.isPullbackSieve_ExtensiveSieve | [139, 1] | [145, 45] | intro Y₁ Y₂ f hf g hg | case intro.intro.intro.intro.intro
C : Type u
inst✝² : Category C
inst✝¹ : HasFiniteCoproducts C
inst✝ : HasPullbackOfIsIsodesc C
X : C
S : Presieve X
α : Type
w✝ : Fintype α
Z : α → C
π : (a : α) → Z a ⟶ X
hS : S = Presieve.ofArrows Z π
HIso : IsIso (Sigma.desc π)
⊢ isPullbackPresieve S | case intro.intro.intro.intro.intro
C : Type u
inst✝² : Category C
inst✝¹ : HasFiniteCoproducts C
inst✝ : HasPullbackOfIsIsodesc C
X : C
S : Presieve X
α : Type
w✝ : Fintype α
Z : α → C
π : (a : α) → Z a ⟶ X
hS : S = Presieve.ofArrows Z π
HIso : IsIso (Sigma.desc π)
Y₁ Y₂ : C
f : Y₁ ⟶ X
hf : S f
g : Y₂ ⟶ X
hg : S g
⊢ HasPullback f g | Please generate a tactic in lean4 to solve the state.
STATE:
case intro.intro.intro.intro.intro
C : Type u
inst✝² : Category C
inst✝¹ : HasFiniteCoproducts C
inst✝ : HasPullbackOfIsIsodesc C
X : C
S : Presieve X
α : Type
w✝ : Fintype α
Z : α → C
π : (a : α) → Z a ⟶ X
hS : S = Presieve.ofArrows Z π
HIso : IsIso (Sigma.desc π)
⊢ isPullbackPresieve S
TACTIC:
|
https://github.com/adamtopaz/CopenhagenMasterclass2023.git | a293ca1554f7e80d891fd4d86fb092c54d8a0a01 | Sieves/ExtensiveRegular.lean | CategoryTheory.isPullbackSieve_ExtensiveSieve | [139, 1] | [145, 45] | rw [hS] at hf hg | case intro.intro.intro.intro.intro
C : Type u
inst✝² : Category C
inst✝¹ : HasFiniteCoproducts C
inst✝ : HasPullbackOfIsIsodesc C
X : C
S : Presieve X
α : Type
w✝ : Fintype α
Z : α → C
π : (a : α) → Z a ⟶ X
hS : S = Presieve.ofArrows Z π
HIso : IsIso (Sigma.desc π)
Y₁ Y₂ : C
f : Y₁ ⟶ X
hf : S f
g : Y₂ ⟶ X
hg : S g
⊢ HasPullback f g | case intro.intro.intro.intro.intro
C : Type u
inst✝² : Category C
inst✝¹ : HasFiniteCoproducts C
inst✝ : HasPullbackOfIsIsodesc C
X : C
S : Presieve X
α : Type
w✝ : Fintype α
Z : α → C
π : (a : α) → Z a ⟶ X
hS : S = Presieve.ofArrows Z π
HIso : IsIso (Sigma.desc π)
Y₁ Y₂ : C
f : Y₁ ⟶ X
hf : Presieve.ofArrows Z π f
g : Y₂ ⟶ X
hg : Presieve.ofArrows Z π g
⊢ HasPullback f g | Please generate a tactic in lean4 to solve the state.
STATE:
case intro.intro.intro.intro.intro
C : Type u
inst✝² : Category C
inst✝¹ : HasFiniteCoproducts C
inst✝ : HasPullbackOfIsIsodesc C
X : C
S : Presieve X
α : Type
w✝ : Fintype α
Z : α → C
π : (a : α) → Z a ⟶ X
hS : S = Presieve.ofArrows Z π
HIso : IsIso (Sigma.desc π)
Y₁ Y₂ : C
f : Y₁ ⟶ X
hf : S f
g : Y₂ ⟶ X
hg : S g
⊢ HasPullback f g
TACTIC:
|
https://github.com/adamtopaz/CopenhagenMasterclass2023.git | a293ca1554f7e80d891fd4d86fb092c54d8a0a01 | Sieves/ExtensiveRegular.lean | CategoryTheory.isPullbackSieve_ExtensiveSieve | [139, 1] | [145, 45] | cases' hg with b | case intro.intro.intro.intro.intro
C : Type u
inst✝² : Category C
inst✝¹ : HasFiniteCoproducts C
inst✝ : HasPullbackOfIsIsodesc C
X : C
S : Presieve X
α : Type
w✝ : Fintype α
Z : α → C
π : (a : α) → Z a ⟶ X
hS : S = Presieve.ofArrows Z π
HIso : IsIso (Sigma.desc π)
Y₁ Y₂ : C
f : Y₁ ⟶ X
hf : Presieve.ofArrows Z π f
g : Y₂ ⟶ X
hg : Presieve.ofArrows Z π g
⊢ HasPullback f g | case intro.intro.intro.intro.intro.mk
C : Type u
inst✝² : Category C
inst✝¹ : HasFiniteCoproducts C
inst✝ : HasPullbackOfIsIsodesc C
X : C
S : Presieve X
α : Type
w✝ : Fintype α
Z : α → C
π : (a : α) → Z a ⟶ X
hS : S = Presieve.ofArrows Z π
HIso : IsIso (Sigma.desc π)
Y₁ : C
f : Y₁ ⟶ X
hf : Presieve.ofArrows Z π f
b : α
⊢ HasPullback f (π b) | Please generate a tactic in lean4 to solve the state.
STATE:
case intro.intro.intro.intro.intro
C : Type u
inst✝² : Category C
inst✝¹ : HasFiniteCoproducts C
inst✝ : HasPullbackOfIsIsodesc C
X : C
S : Presieve X
α : Type
w✝ : Fintype α
Z : α → C
π : (a : α) → Z a ⟶ X
hS : S = Presieve.ofArrows Z π
HIso : IsIso (Sigma.desc π)
Y₁ Y₂ : C
f : Y₁ ⟶ X
hf : Presieve.ofArrows Z π f
g : Y₂ ⟶ X
hg : Presieve.ofArrows Z π g
⊢ HasPullback f g
TACTIC:
|
https://github.com/adamtopaz/CopenhagenMasterclass2023.git | a293ca1554f7e80d891fd4d86fb092c54d8a0a01 | Sieves/ExtensiveRegular.lean | CategoryTheory.isPullbackSieve_ExtensiveSieve | [139, 1] | [145, 45] | apply HasPullbackOfIsIsodesc.HasPullback f | case intro.intro.intro.intro.intro.mk
C : Type u
inst✝² : Category C
inst✝¹ : HasFiniteCoproducts C
inst✝ : HasPullbackOfIsIsodesc C
X : C
S : Presieve X
α : Type
w✝ : Fintype α
Z : α → C
π : (a : α) → Z a ⟶ X
hS : S = Presieve.ofArrows Z π
HIso : IsIso (Sigma.desc π)
Y₁ : C
f : Y₁ ⟶ X
hf : Presieve.ofArrows Z π f
b : α
⊢ HasPullback f (π b) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case intro.intro.intro.intro.intro.mk
C : Type u
inst✝² : Category C
inst✝¹ : HasFiniteCoproducts C
inst✝ : HasPullbackOfIsIsodesc C
X : C
S : Presieve X
α : Type
w✝ : Fintype α
Z : α → C
π : (a : α) → Z a ⟶ X
hS : S = Presieve.ofArrows Z π
HIso : IsIso (Sigma.desc π)
Y₁ : C
f : Y₁ ⟶ X
hf : Presieve.ofArrows Z π f
b : α
⊢ HasPullback f (π b)
TACTIC:
|
https://github.com/adamtopaz/CopenhagenMasterclass2023.git | a293ca1554f7e80d891fd4d86fb092c54d8a0a01 | Sieves/ExtensiveRegular.lean | CategoryTheory.vsurj | [151, 1] | [154, 17] | cases' (hS ▸ hf) with a h | C : Type u
inst✝² : Category C
inst✝¹ : HasFiniteCoproducts C
inst✝ : HasPullbackOfIsIsodesc C
α : Type
Z : α → C
X : C
π : (a : α) → Z a ⟶ X
S : Presieve X
hS : S = Presieve.ofArrows Z π
x✝ : (Y : C) × { f // S f }
Y : C
f : Y ⟶ X
hf : S f
⊢ ∃ a, v hS a = { fst := Y, snd := { val := f, property := hf } } | case mk
C : Type u
inst✝² : Category C
inst✝¹ : HasFiniteCoproducts C
inst✝ : HasPullbackOfIsIsodesc C
α : Type
Z : α → C
X : C
π : (a : α) → Z a ⟶ X
S : Presieve X
hS : S = Presieve.ofArrows Z π
x✝ : (Y : C) × { f // S f }
a : α
hf : S (π a)
⊢ ∃ a_1, v hS a_1 = { fst := Z a, snd := { val := π a, property := hf } } | Please generate a tactic in lean4 to solve the state.
STATE:
C : Type u
inst✝² : Category C
inst✝¹ : HasFiniteCoproducts C
inst✝ : HasPullbackOfIsIsodesc C
α : Type
Z : α → C
X : C
π : (a : α) → Z a ⟶ X
S : Presieve X
hS : S = Presieve.ofArrows Z π
x✝ : (Y : C) × { f // S f }
Y : C
f : Y ⟶ X
hf : S f
⊢ ∃ a, v hS a = { fst := Y, snd := { val := f, property := hf } }
TACTIC:
|
https://github.com/adamtopaz/CopenhagenMasterclass2023.git | a293ca1554f7e80d891fd4d86fb092c54d8a0a01 | Sieves/ExtensiveRegular.lean | CategoryTheory.vsurj | [151, 1] | [154, 17] | exact ⟨a, rfl⟩ | case mk
C : Type u
inst✝² : Category C
inst✝¹ : HasFiniteCoproducts C
inst✝ : HasPullbackOfIsIsodesc C
α : Type
Z : α → C
X : C
π : (a : α) → Z a ⟶ X
S : Presieve X
hS : S = Presieve.ofArrows Z π
x✝ : (Y : C) × { f // S f }
a : α
hf : S (π a)
⊢ ∃ a_1, v hS a_1 = { fst := Z a, snd := { val := π a, property := hf } } | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case mk
C : Type u
inst✝² : Category C
inst✝¹ : HasFiniteCoproducts C
inst✝ : HasPullbackOfIsIsodesc C
α : Type
Z : α → C
X : C
π : (a : α) → Z a ⟶ X
S : Presieve X
hS : S = Presieve.ofArrows Z π
x✝ : (Y : C) × { f // S f }
a : α
hf : S (π a)
⊢ ∃ a_1, v hS a_1 = { fst := Z a, snd := { val := π a, property := hf } }
TACTIC:
|
https://github.com/adamtopaz/CopenhagenMasterclass2023.git | a293ca1554f7e80d891fd4d86fb092c54d8a0a01 | Sieves/ExtensiveRegular.lean | CategoryTheory.HasProductT | [168, 1] | [173, 38] | exact Fintype.finite <| FintypeT hS | C : Type u
inst✝³ : Category C
inst✝² : HasFiniteCoproducts C
inst✝¹ : HasPullbackOfIsIsodesc C
α : Type
inst✝ : Fintype α
Z : α → C
X : C
π : (a : α) → Z a ⟶ X
S : Presieve X
hS : S = Presieve.ofArrows Z π
⊢ Finite ((Y : C) × { f // S f }) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
C : Type u
inst✝³ : Category C
inst✝² : HasFiniteCoproducts C
inst✝¹ : HasPullbackOfIsIsodesc C
α : Type
inst✝ : Fintype α
Z : α → C
X : C
π : (a : α) → Z a ⟶ X
S : Presieve X
hS : S = Presieve.ofArrows Z π
⊢ Finite ((Y : C) × { f // S f })
TACTIC:
|
https://github.com/adamtopaz/CopenhagenMasterclass2023.git | a293ca1554f7e80d891fd4d86fb092c54d8a0a01 | Sieves/ExtensiveRegular.lean | CategoryTheory.HasProductT | [168, 1] | [173, 38] | infer_instance | C : Type u
inst✝³ : Category C
inst✝² : HasFiniteCoproducts C
inst✝¹ : HasPullbackOfIsIsodesc C
α : Type
inst✝ : Fintype α
Z : α → C
X : C
π : (a : α) → Z a ⟶ X
S : Presieve X
hS : S = Presieve.ofArrows Z π
this : Finite ((Y : C) × { f // S f })
⊢ HasProduct fun f => f.fst.op | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
C : Type u
inst✝³ : Category C
inst✝² : HasFiniteCoproducts C
inst✝¹ : HasPullbackOfIsIsodesc C
α : Type
inst✝ : Fintype α
Z : α → C
X : C
π : (a : α) → Z a ⟶ X
S : Presieve X
hS : S = Presieve.ofArrows Z π
this : Finite ((Y : C) × { f // S f })
⊢ HasProduct fun f => f.fst.op
TACTIC:
|
https://github.com/adamtopaz/CopenhagenMasterclass2023.git | a293ca1554f7e80d891fd4d86fb092c54d8a0a01 | Sieves/ExtensiveRegular.lean | CategoryTheory.piCompInvdesc | [194, 1] | [196, 7] | simp | C : Type u
inst✝³ : Category C
inst✝² : HasFiniteCoproducts C
inst✝¹ : HasPullbackOfIsIsodesc C
α : Type
inst✝ : Fintype α
Z : α → C
X : C
π : (a : α) → Z a ⟶ X
HIso : IsIso (Sigma.desc π)
a : α
⊢ π a ≫ inv (Sigma.desc π) = Sigma.ι Z a | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
C : Type u
inst✝³ : Category C
inst✝² : HasFiniteCoproducts C
inst✝¹ : HasPullbackOfIsIsodesc C
α : Type
inst✝ : Fintype α
Z : α → C
X : C
π : (a : α) → Z a ⟶ X
HIso : IsIso (Sigma.desc π)
a : α
⊢ π a ≫ inv (Sigma.desc π) = Sigma.ι Z a
TACTIC:
|
https://github.com/adamtopaz/CopenhagenMasterclass2023.git | a293ca1554f7e80d891fd4d86fb092c54d8a0a01 | Sieves/ExtensiveRegular.lean | CategoryTheory.isSheafForDagurSieveIsIsoFork | [204, 1] | [238, 37] | rcases hS with ⟨α, _, Z, π, hS, HIso⟩ | C : Type u
inst✝² : Category C
inst✝¹ : HasFiniteCoproducts C
inst✝ : HasPullbackOfIsIsodesc C
X : C
S : Presieve X
hS : S ∈ ExtensiveSieve X
F : Cᵒᵖ ⥤ Type (max u v)
hF : PreservesFiniteProducts F
⊢ IsIso (Equalizer.forkMap F S) | case intro.intro.intro.intro.intro
C : Type u
inst✝² : Category C
inst✝¹ : HasFiniteCoproducts C
inst✝ : HasPullbackOfIsIsodesc C
X : C
S : Presieve X
F : Cᵒᵖ ⥤ Type (max u v)
hF : PreservesFiniteProducts F
α : Type
w✝ : Fintype α
Z : α → C
π : (a : α) → Z a ⟶ X
hS : S = Presieve.ofArrows Z π
HIso : IsIso (Sigma.desc π)
⊢ IsIso (Equalizer.forkMap F S) | Please generate a tactic in lean4 to solve the state.
STATE:
C : Type u
inst✝² : Category C
inst✝¹ : HasFiniteCoproducts C
inst✝ : HasPullbackOfIsIsodesc C
X : C
S : Presieve X
hS : S ∈ ExtensiveSieve X
F : Cᵒᵖ ⥤ Type (max u v)
hF : PreservesFiniteProducts F
⊢ IsIso (Equalizer.forkMap F S)
TACTIC:
|
https://github.com/adamtopaz/CopenhagenMasterclass2023.git | a293ca1554f7e80d891fd4d86fb092c54d8a0a01 | Sieves/ExtensiveRegular.lean | CategoryTheory.isSheafForDagurSieveIsIsoFork | [204, 1] | [238, 37] | haveI : PreservesLimit (Discrete.functor fun a => op (Z a)) F := by
haveI := (hF.preserves α); infer_instance | case intro.intro.intro.intro.intro
C : Type u
inst✝² : Category C
inst✝¹ : HasFiniteCoproducts C
inst✝ : HasPullbackOfIsIsodesc C
X : C
S : Presieve X
F : Cᵒᵖ ⥤ Type (max u v)
hF : PreservesFiniteProducts F
α : Type
w✝ : Fintype α
Z : α → C
π : (a : α) → Z a ⟶ X
hS : S = Presieve.ofArrows Z π
HIso : IsIso (Sigma.desc π)
⊢ IsIso (Equalizer.forkMap F S) | case intro.intro.intro.intro.intro
C : Type u
inst✝² : Category C
inst✝¹ : HasFiniteCoproducts C
inst✝ : HasPullbackOfIsIsodesc C
X : C
S : Presieve X
F : Cᵒᵖ ⥤ Type (max u v)
hF : PreservesFiniteProducts F
α : Type
w✝ : Fintype α
Z : α → C
π : (a : α) → Z a ⟶ X
hS : S = Presieve.ofArrows Z π
HIso : IsIso (Sigma.desc π)
this : PreservesLimit (Discrete.functor fun a => (Z a).op) F
⊢ IsIso (Equalizer.forkMap F S) | Please generate a tactic in lean4 to solve the state.
STATE:
case intro.intro.intro.intro.intro
C : Type u
inst✝² : Category C
inst✝¹ : HasFiniteCoproducts C
inst✝ : HasPullbackOfIsIsodesc C
X : C
S : Presieve X
F : Cᵒᵖ ⥤ Type (max u v)
hF : PreservesFiniteProducts F
α : Type
w✝ : Fintype α
Z : α → C
π : (a : α) → Z a ⟶ X
hS : S = Presieve.ofArrows Z π
HIso : IsIso (Sigma.desc π)
⊢ IsIso (Equalizer.forkMap F S)
TACTIC:
|
https://github.com/adamtopaz/CopenhagenMasterclass2023.git | a293ca1554f7e80d891fd4d86fb092c54d8a0a01 | Sieves/ExtensiveRegular.lean | CategoryTheory.isSheafForDagurSieveIsIsoFork | [204, 1] | [238, 37] | refine' ⟨fromFirst hS hF HIso, _, _⟩ | case intro.intro.intro.intro.intro
C : Type u
inst✝² : Category C
inst✝¹ : HasFiniteCoproducts C
inst✝ : HasPullbackOfIsIsodesc C
X : C
S : Presieve X
F : Cᵒᵖ ⥤ Type (max u v)
hF : PreservesFiniteProducts F
α : Type
w✝ : Fintype α
Z : α → C
π : (a : α) → Z a ⟶ X
hS : S = Presieve.ofArrows Z π
HIso : IsIso (Sigma.desc π)
this : PreservesLimit (Discrete.functor fun a => (Z a).op) F
⊢ IsIso (Equalizer.forkMap F S) | case intro.intro.intro.intro.intro.refine'_1
C : Type u
inst✝² : Category C
inst✝¹ : HasFiniteCoproducts C
inst✝ : HasPullbackOfIsIsodesc C
X : C
S : Presieve X
F : Cᵒᵖ ⥤ Type (max u v)
hF : PreservesFiniteProducts F
α : Type
w✝ : Fintype α
Z : α → C
π : (a : α) → Z a ⟶ X
hS : S = Presieve.ofArrows Z π
HIso : IsIso (Sigma.desc π)
this : PreservesLimit (Discrete.functor fun a => (Z a).op) F
⊢ Equalizer.forkMap F S ≫ fromFirst hS hF HIso = 𝟙 (F.obj X.op)
case intro.intro.intro.intro.intro.refine'_2
C : Type u
inst✝² : Category C
inst✝¹ : HasFiniteCoproducts C
inst✝ : HasPullbackOfIsIsodesc C
X : C
S : Presieve X
F : Cᵒᵖ ⥤ Type (max u v)
hF : PreservesFiniteProducts F
α : Type
w✝ : Fintype α
Z : α → C
π : (a : α) → Z a ⟶ X
hS : S = Presieve.ofArrows Z π
HIso : IsIso (Sigma.desc π)
this : PreservesLimit (Discrete.functor fun a => (Z a).op) F
⊢ fromFirst hS hF HIso ≫ Equalizer.forkMap F S = 𝟙 (Equalizer.FirstObj F S) | Please generate a tactic in lean4 to solve the state.
STATE:
case intro.intro.intro.intro.intro
C : Type u
inst✝² : Category C
inst✝¹ : HasFiniteCoproducts C
inst✝ : HasPullbackOfIsIsodesc C
X : C
S : Presieve X
F : Cᵒᵖ ⥤ Type (max u v)
hF : PreservesFiniteProducts F
α : Type
w✝ : Fintype α
Z : α → C
π : (a : α) → Z a ⟶ X
hS : S = Presieve.ofArrows Z π
HIso : IsIso (Sigma.desc π)
this : PreservesLimit (Discrete.functor fun a => (Z a).op) F
⊢ IsIso (Equalizer.forkMap F S)
TACTIC:
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.