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 | ExtrDisc/ExplicitSheaves.lean | ExtrDisc.everything_proj | [97, 1] | [106, 64] | change Function.Surjective e | P X Y : ExtrDisc
f : P ⟶ Y
e : X ⟶ Y
he : Epi e
proj : Projective (toCompHaus.obj P)
⊢ Function.Surjective ↑(toCompHaus.map e) | P X Y : ExtrDisc
f : P ⟶ Y
e : X ⟶ Y
he : Epi e
proj : Projective (toCompHaus.obj P)
⊢ Function.Surjective ↑e | Please generate a tactic in lean4 to solve the state.
STATE:
P X Y : ExtrDisc
f : P ⟶ Y
e : X ⟶ Y
he : Epi e
proj : Projective (toCompHaus.obj P)
⊢ Function.Surjective ↑(toCompHaus.map e)
TACTIC:
|
https://github.com/adamtopaz/CopenhagenMasterclass2023.git | a293ca1554f7e80d891fd4d86fb092c54d8a0a01 | ExtrDisc/ExplicitSheaves.lean | ExtrDisc.everything_proj | [97, 1] | [106, 64] | rwa [← ExtrDisc.epi_iff_surjective] | P X Y : ExtrDisc
f : P ⟶ Y
e : X ⟶ Y
he : Epi e
proj : Projective (toCompHaus.obj P)
⊢ Function.Surjective ↑e | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
P X Y : ExtrDisc
f : P ⟶ Y
e : X ⟶ Y
he : Epi e
proj : Projective (toCompHaus.obj P)
⊢ Function.Surjective ↑e
TACTIC:
|
https://github.com/adamtopaz/CopenhagenMasterclass2023.git | a293ca1554f7e80d891fd4d86fb092c54d8a0a01 | ExtrDisc/ExplicitSheaves.lean | ExtrDisc.extensiveRegular_generates_coherent | [108, 1] | [217, 21] | ext X S | ⊢ Coverage.toGrothendieck ExtrDisc
(ExtensiveRegularCoverage ExtrDisc everything_proj
(_ :
∀ {α : Type} [inst : Fintype α] {X : ExtrDisc} {Z : α → ExtrDisc} (π : (a : α) → Z a ⟶ X) {Y : ExtrDisc}
(f : Y ⟶ X) (x : IsIso (Sigma.desc π)), IsIso (Sigma.desc fun x_1 => Limits.pullback.fst))) =
coherentTopology ExtrDisc | case h.h.h
X : ExtrDisc
S : Sieve X
⊢ S ∈
GrothendieckTopology.sieves
(Coverage.toGrothendieck ExtrDisc
(ExtensiveRegularCoverage ExtrDisc everything_proj
(_ :
∀ {α : Type} [inst : Fintype α] {X : ExtrDisc} {Z : α → ExtrDisc} (π : (a : α) → Z a ⟶ X) {Y : ExtrDisc}
(f : Y ⟶ X) (x : IsIso (Sigma.desc π)), IsIso (Sigma.desc fun x_1 => Limits.pullback.fst))))
X ↔
S ∈ GrothendieckTopology.sieves (coherentTopology ExtrDisc) X | Please generate a tactic in lean4 to solve the state.
STATE:
⊢ Coverage.toGrothendieck ExtrDisc
(ExtensiveRegularCoverage ExtrDisc everything_proj
(_ :
∀ {α : Type} [inst : Fintype α] {X : ExtrDisc} {Z : α → ExtrDisc} (π : (a : α) → Z a ⟶ X) {Y : ExtrDisc}
(f : Y ⟶ X) (x : IsIso (Sigma.desc π)), IsIso (Sigma.desc fun x_1 => Limits.pullback.fst))) =
coherentTopology ExtrDisc
TACTIC:
|
https://github.com/adamtopaz/CopenhagenMasterclass2023.git | a293ca1554f7e80d891fd4d86fb092c54d8a0a01 | ExtrDisc/ExplicitSheaves.lean | ExtrDisc.extensiveRegular_generates_coherent | [108, 1] | [217, 21] | constructor
<;> intro h | case h.h.h
X : ExtrDisc
S : Sieve X
⊢ S ∈
GrothendieckTopology.sieves
(Coverage.toGrothendieck ExtrDisc
(ExtensiveRegularCoverage ExtrDisc everything_proj
(_ :
∀ {α : Type} [inst : Fintype α] {X : ExtrDisc} {Z : α → ExtrDisc} (π : (a : α) → Z a ⟶ X) {Y : ExtrDisc}
(f : Y ⟶ X) (x : IsIso (Sigma.desc π)), IsIso (Sigma.desc fun x_1 => Limits.pullback.fst))))
X ↔
S ∈ GrothendieckTopology.sieves (coherentTopology ExtrDisc) X | case h.h.h.mp
X : ExtrDisc
S : Sieve X
h :
S ∈
GrothendieckTopology.sieves
(Coverage.toGrothendieck ExtrDisc
(ExtensiveRegularCoverage ExtrDisc everything_proj
(_ :
∀ {α : Type} [inst : Fintype α] {X : ExtrDisc} {Z : α → ExtrDisc} (π : (a : α) → Z a ⟶ X) {Y : ExtrDisc}
(f : Y ⟶ X) (x : IsIso (Sigma.desc π)), IsIso (Sigma.desc fun x_1 => Limits.pullback.fst))))
X
⊢ S ∈ GrothendieckTopology.sieves (coherentTopology ExtrDisc) X
case h.h.h.mpr
X : ExtrDisc
S : Sieve X
h : S ∈ GrothendieckTopology.sieves (coherentTopology ExtrDisc) X
⊢ S ∈
GrothendieckTopology.sieves
(Coverage.toGrothendieck ExtrDisc
(ExtensiveRegularCoverage ExtrDisc everything_proj
(_ :
∀ {α : Type} [inst : Fintype α] {X : ExtrDisc} {Z : α → ExtrDisc} (π : (a : α) → Z a ⟶ X) {Y : ExtrDisc}
(f : Y ⟶ X) (x : IsIso (Sigma.desc π)), IsIso (Sigma.desc fun x_1 => Limits.pullback.fst))))
X | Please generate a tactic in lean4 to solve the state.
STATE:
case h.h.h
X : ExtrDisc
S : Sieve X
⊢ S ∈
GrothendieckTopology.sieves
(Coverage.toGrothendieck ExtrDisc
(ExtensiveRegularCoverage ExtrDisc everything_proj
(_ :
∀ {α : Type} [inst : Fintype α] {X : ExtrDisc} {Z : α → ExtrDisc} (π : (a : α) → Z a ⟶ X) {Y : ExtrDisc}
(f : Y ⟶ X) (x : IsIso (Sigma.desc π)), IsIso (Sigma.desc fun x_1 => Limits.pullback.fst))))
X ↔
S ∈ GrothendieckTopology.sieves (coherentTopology ExtrDisc) X
TACTIC:
|
https://github.com/adamtopaz/CopenhagenMasterclass2023.git | a293ca1554f7e80d891fd4d86fb092c54d8a0a01 | ExtrDisc/ExplicitSheaves.lean | ExtrDisc.extensiveRegular_generates_coherent | [108, 1] | [217, 21] | dsimp [Coverage.toGrothendieck] at * | case h.h.h.mp
X : ExtrDisc
S : Sieve X
h :
S ∈
GrothendieckTopology.sieves
(Coverage.toGrothendieck ExtrDisc
(ExtensiveRegularCoverage ExtrDisc everything_proj
(_ :
∀ {α : Type} [inst : Fintype α] {X : ExtrDisc} {Z : α → ExtrDisc} (π : (a : α) → Z a ⟶ X) {Y : ExtrDisc}
(f : Y ⟶ X) (x : IsIso (Sigma.desc π)), IsIso (Sigma.desc fun x_1 => Limits.pullback.fst))))
X
⊢ S ∈ GrothendieckTopology.sieves (coherentTopology ExtrDisc) X | case h.h.h.mp
X : ExtrDisc
S : Sieve X
h :
S ∈
Coverage.saturate
(ExtensiveRegularCoverage ExtrDisc everything_proj
(_ :
∀ {α : Type} [inst : Fintype α] {X : ExtrDisc} {Z : α → ExtrDisc} (π : (a : α) → Z a ⟶ X) {Y : ExtrDisc}
(f : Y ⟶ X) (x : IsIso (Sigma.desc π)), IsIso (Sigma.desc fun x_1 => Limits.pullback.fst)))
X
⊢ S ∈ GrothendieckTopology.sieves (coherentTopology ExtrDisc) X | Please generate a tactic in lean4 to solve the state.
STATE:
case h.h.h.mp
X : ExtrDisc
S : Sieve X
h :
S ∈
GrothendieckTopology.sieves
(Coverage.toGrothendieck ExtrDisc
(ExtensiveRegularCoverage ExtrDisc everything_proj
(_ :
∀ {α : Type} [inst : Fintype α] {X : ExtrDisc} {Z : α → ExtrDisc} (π : (a : α) → Z a ⟶ X) {Y : ExtrDisc}
(f : Y ⟶ X) (x : IsIso (Sigma.desc π)), IsIso (Sigma.desc fun x_1 => Limits.pullback.fst))))
X
⊢ S ∈ GrothendieckTopology.sieves (coherentTopology ExtrDisc) X
TACTIC:
|
https://github.com/adamtopaz/CopenhagenMasterclass2023.git | a293ca1554f7e80d891fd4d86fb092c54d8a0a01 | ExtrDisc/ExplicitSheaves.lean | ExtrDisc.extensiveRegular_generates_coherent | [108, 1] | [217, 21] | apply Coverage.saturate.of | case h.h.h.mp.of
X : ExtrDisc
S : Sieve X
Y : ExtrDisc
T : Presieve Y
hT :
T ∈
Coverage.covering
(ExtensiveRegularCoverage ExtrDisc everything_proj
(_ :
∀ {α : Type} [inst : Fintype α] {X : ExtrDisc} {Z : α → ExtrDisc} (π : (a : α) → Z a ⟶ X) {Y : ExtrDisc}
(f : Y ⟶ X) (x : IsIso (Sigma.desc π)), IsIso (Sigma.desc fun x_1 => Limits.pullback.fst)))
Y
⊢ Sieve.generate T ∈ GrothendieckTopology.sieves (coherentTopology ExtrDisc) Y | case h.h.h.mp.of.hS
X : ExtrDisc
S : Sieve X
Y : ExtrDisc
T : Presieve Y
hT :
T ∈
Coverage.covering
(ExtensiveRegularCoverage ExtrDisc everything_proj
(_ :
∀ {α : Type} [inst : Fintype α] {X : ExtrDisc} {Z : α → ExtrDisc} (π : (a : α) → Z a ⟶ X) {Y : ExtrDisc}
(f : Y ⟶ X) (x : IsIso (Sigma.desc π)), IsIso (Sigma.desc fun x_1 => Limits.pullback.fst)))
Y
⊢ T ∈ Coverage.covering (coherentCoverage ExtrDisc) Y | Please generate a tactic in lean4 to solve the state.
STATE:
case h.h.h.mp.of
X : ExtrDisc
S : Sieve X
Y : ExtrDisc
T : Presieve Y
hT :
T ∈
Coverage.covering
(ExtensiveRegularCoverage ExtrDisc everything_proj
(_ :
∀ {α : Type} [inst : Fintype α] {X : ExtrDisc} {Z : α → ExtrDisc} (π : (a : α) → Z a ⟶ X) {Y : ExtrDisc}
(f : Y ⟶ X) (x : IsIso (Sigma.desc π)), IsIso (Sigma.desc fun x_1 => Limits.pullback.fst)))
Y
⊢ Sieve.generate T ∈ GrothendieckTopology.sieves (coherentTopology ExtrDisc) Y
TACTIC:
|
https://github.com/adamtopaz/CopenhagenMasterclass2023.git | a293ca1554f7e80d891fd4d86fb092c54d8a0a01 | ExtrDisc/ExplicitSheaves.lean | ExtrDisc.extensiveRegular_generates_coherent | [108, 1] | [217, 21] | dsimp [coherentCoverage] | case h.h.h.mp.of.hS
X : ExtrDisc
S : Sieve X
Y : ExtrDisc
T : Presieve Y
hT :
T ∈
Coverage.covering
(ExtensiveRegularCoverage ExtrDisc everything_proj
(_ :
∀ {α : Type} [inst : Fintype α] {X : ExtrDisc} {Z : α → ExtrDisc} (π : (a : α) → Z a ⟶ X) {Y : ExtrDisc}
(f : Y ⟶ X) (x : IsIso (Sigma.desc π)), IsIso (Sigma.desc fun x_1 => Limits.pullback.fst)))
Y
⊢ T ∈ Coverage.covering (coherentCoverage ExtrDisc) Y | case h.h.h.mp.of.hS
X : ExtrDisc
S : Sieve X
Y : ExtrDisc
T : Presieve Y
hT :
T ∈
Coverage.covering
(ExtensiveRegularCoverage ExtrDisc everything_proj
(_ :
∀ {α : Type} [inst : Fintype α] {X : ExtrDisc} {Z : α → ExtrDisc} (π : (a : α) → Z a ⟶ X) {Y : ExtrDisc}
(f : Y ⟶ X) (x : IsIso (Sigma.desc π)), IsIso (Sigma.desc fun x_1 => Limits.pullback.fst)))
Y
⊢ ∃ α x X π, T = ofArrows X π ∧ EffectiveEpiFamily X π | Please generate a tactic in lean4 to solve the state.
STATE:
case h.h.h.mp.of.hS
X : ExtrDisc
S : Sieve X
Y : ExtrDisc
T : Presieve Y
hT :
T ∈
Coverage.covering
(ExtensiveRegularCoverage ExtrDisc everything_proj
(_ :
∀ {α : Type} [inst : Fintype α] {X : ExtrDisc} {Z : α → ExtrDisc} (π : (a : α) → Z a ⟶ X) {Y : ExtrDisc}
(f : Y ⟶ X) (x : IsIso (Sigma.desc π)), IsIso (Sigma.desc fun x_1 => Limits.pullback.fst)))
Y
⊢ T ∈ Coverage.covering (coherentCoverage ExtrDisc) Y
TACTIC:
|
https://github.com/adamtopaz/CopenhagenMasterclass2023.git | a293ca1554f7e80d891fd4d86fb092c54d8a0a01 | ExtrDisc/ExplicitSheaves.lean | ExtrDisc.extensiveRegular_generates_coherent | [108, 1] | [217, 21] | dsimp [ExtensiveRegularCoverage] at hT | case h.h.h.mp.of.hS
X : ExtrDisc
S : Sieve X
Y : ExtrDisc
T : Presieve Y
hT :
T ∈
Coverage.covering
(ExtensiveRegularCoverage ExtrDisc everything_proj
(_ :
∀ {α : Type} [inst : Fintype α] {X : ExtrDisc} {Z : α → ExtrDisc} (π : (a : α) → Z a ⟶ X) {Y : ExtrDisc}
(f : Y ⟶ X) (x : IsIso (Sigma.desc π)), IsIso (Sigma.desc fun x_1 => Limits.pullback.fst)))
Y
⊢ ∃ α x X π, T = ofArrows X π ∧ EffectiveEpiFamily X π | case h.h.h.mp.of.hS
X : ExtrDisc
S : Sieve X
Y : ExtrDisc
T : Presieve Y
hT : T ∈ ExtensiveSieve Y ∪ RegularSieve Y
⊢ ∃ α x X π, T = ofArrows X π ∧ EffectiveEpiFamily X π | Please generate a tactic in lean4 to solve the state.
STATE:
case h.h.h.mp.of.hS
X : ExtrDisc
S : Sieve X
Y : ExtrDisc
T : Presieve Y
hT :
T ∈
Coverage.covering
(ExtensiveRegularCoverage ExtrDisc everything_proj
(_ :
∀ {α : Type} [inst : Fintype α] {X : ExtrDisc} {Z : α → ExtrDisc} (π : (a : α) → Z a ⟶ X) {Y : ExtrDisc}
(f : Y ⟶ X) (x : IsIso (Sigma.desc π)), IsIso (Sigma.desc fun x_1 => Limits.pullback.fst)))
Y
⊢ ∃ α x X π, T = ofArrows X π ∧ EffectiveEpiFamily X π
TACTIC:
|
https://github.com/adamtopaz/CopenhagenMasterclass2023.git | a293ca1554f7e80d891fd4d86fb092c54d8a0a01 | ExtrDisc/ExplicitSheaves.lean | ExtrDisc.extensiveRegular_generates_coherent | [108, 1] | [217, 21] | apply Or.elim hT
<;> intro h | case h.h.h.mp.of.hS
X : ExtrDisc
S : Sieve X
Y : ExtrDisc
T : Presieve Y
hT : T ∈ ExtensiveSieve Y ∪ RegularSieve Y
⊢ ∃ α x X π, T = ofArrows X π ∧ EffectiveEpiFamily X π | case h.h.h.mp.of.hS.left
X : ExtrDisc
S : Sieve X
Y : ExtrDisc
T : Presieve Y
hT : T ∈ ExtensiveSieve Y ∪ RegularSieve Y
h : T ∈ ExtensiveSieve Y
⊢ ∃ α x X π, T = ofArrows X π ∧ EffectiveEpiFamily X π
case h.h.h.mp.of.hS.right
X : ExtrDisc
S : Sieve X
Y : ExtrDisc
T : Presieve Y
hT : T ∈ ExtensiveSieve Y ∪ RegularSieve Y
h : T ∈ RegularSieve Y
⊢ ∃ α x X π, T = ofArrows X π ∧ EffectiveEpiFamily X π | Please generate a tactic in lean4 to solve the state.
STATE:
case h.h.h.mp.of.hS
X : ExtrDisc
S : Sieve X
Y : ExtrDisc
T : Presieve Y
hT : T ∈ ExtensiveSieve Y ∪ RegularSieve Y
⊢ ∃ α x X π, T = ofArrows X π ∧ EffectiveEpiFamily X π
TACTIC:
|
https://github.com/adamtopaz/CopenhagenMasterclass2023.git | a293ca1554f7e80d891fd4d86fb092c54d8a0a01 | ExtrDisc/ExplicitSheaves.lean | ExtrDisc.extensiveRegular_generates_coherent | [108, 1] | [217, 21] | obtain ⟨α, x, Xmap, π, h⟩ := h | case h.h.h.mp.of.hS.left
X : ExtrDisc
S : Sieve X
Y : ExtrDisc
T : Presieve Y
hT : T ∈ ExtensiveSieve Y ∪ RegularSieve Y
h : T ∈ ExtensiveSieve Y
⊢ ∃ α x X π, T = ofArrows X π ∧ EffectiveEpiFamily X π | case h.h.h.mp.of.hS.left.intro.intro.intro.intro
X : ExtrDisc
S : Sieve X
Y : ExtrDisc
T : Presieve Y
hT : T ∈ ExtensiveSieve Y ∪ RegularSieve Y
α : Type
x : Fintype α
Xmap : α → ExtrDisc
π : (a : α) → Xmap a ⟶ Y
h : T = ofArrows Xmap π ∧ IsIso (Sigma.desc π)
⊢ ∃ α x X π, T = ofArrows X π ∧ EffectiveEpiFamily X π | Please generate a tactic in lean4 to solve the state.
STATE:
case h.h.h.mp.of.hS.left
X : ExtrDisc
S : Sieve X
Y : ExtrDisc
T : Presieve Y
hT : T ∈ ExtensiveSieve Y ∪ RegularSieve Y
h : T ∈ ExtensiveSieve Y
⊢ ∃ α x X π, T = ofArrows X π ∧ EffectiveEpiFamily X π
TACTIC:
|
https://github.com/adamtopaz/CopenhagenMasterclass2023.git | a293ca1554f7e80d891fd4d86fb092c54d8a0a01 | ExtrDisc/ExplicitSheaves.lean | ExtrDisc.extensiveRegular_generates_coherent | [108, 1] | [217, 21] | use α | case h.h.h.mp.of.hS.left.intro.intro.intro.intro
X : ExtrDisc
S : Sieve X
Y : ExtrDisc
T : Presieve Y
hT : T ∈ ExtensiveSieve Y ∪ RegularSieve Y
α : Type
x : Fintype α
Xmap : α → ExtrDisc
π : (a : α) → Xmap a ⟶ Y
h : T = ofArrows Xmap π ∧ IsIso (Sigma.desc π)
⊢ ∃ α x X π, T = ofArrows X π ∧ EffectiveEpiFamily X π | case h.h.h.mp.of.hS.left.intro.intro.intro.intro
X : ExtrDisc
S : Sieve X
Y : ExtrDisc
T : Presieve Y
hT : T ∈ ExtensiveSieve Y ∪ RegularSieve Y
α : Type
x : Fintype α
Xmap : α → ExtrDisc
π : (a : α) → Xmap a ⟶ Y
h : T = ofArrows Xmap π ∧ IsIso (Sigma.desc π)
⊢ ∃ x X π, T = ofArrows X π ∧ EffectiveEpiFamily X π | Please generate a tactic in lean4 to solve the state.
STATE:
case h.h.h.mp.of.hS.left.intro.intro.intro.intro
X : ExtrDisc
S : Sieve X
Y : ExtrDisc
T : Presieve Y
hT : T ∈ ExtensiveSieve Y ∪ RegularSieve Y
α : Type
x : Fintype α
Xmap : α → ExtrDisc
π : (a : α) → Xmap a ⟶ Y
h : T = ofArrows Xmap π ∧ IsIso (Sigma.desc π)
⊢ ∃ α x X π, T = ofArrows X π ∧ EffectiveEpiFamily X π
TACTIC:
|
https://github.com/adamtopaz/CopenhagenMasterclass2023.git | a293ca1554f7e80d891fd4d86fb092c54d8a0a01 | ExtrDisc/ExplicitSheaves.lean | ExtrDisc.extensiveRegular_generates_coherent | [108, 1] | [217, 21] | use x | case h.h.h.mp.of.hS.left.intro.intro.intro.intro
X : ExtrDisc
S : Sieve X
Y : ExtrDisc
T : Presieve Y
hT : T ∈ ExtensiveSieve Y ∪ RegularSieve Y
α : Type
x : Fintype α
Xmap : α → ExtrDisc
π : (a : α) → Xmap a ⟶ Y
h : T = ofArrows Xmap π ∧ IsIso (Sigma.desc π)
⊢ ∃ x X π, T = ofArrows X π ∧ EffectiveEpiFamily X π | case h.h.h.mp.of.hS.left.intro.intro.intro.intro
X : ExtrDisc
S : Sieve X
Y : ExtrDisc
T : Presieve Y
hT : T ∈ ExtensiveSieve Y ∪ RegularSieve Y
α : Type
x : Fintype α
Xmap : α → ExtrDisc
π : (a : α) → Xmap a ⟶ Y
h : T = ofArrows Xmap π ∧ IsIso (Sigma.desc π)
⊢ ∃ X π, T = ofArrows X π ∧ EffectiveEpiFamily X π | Please generate a tactic in lean4 to solve the state.
STATE:
case h.h.h.mp.of.hS.left.intro.intro.intro.intro
X : ExtrDisc
S : Sieve X
Y : ExtrDisc
T : Presieve Y
hT : T ∈ ExtensiveSieve Y ∪ RegularSieve Y
α : Type
x : Fintype α
Xmap : α → ExtrDisc
π : (a : α) → Xmap a ⟶ Y
h : T = ofArrows Xmap π ∧ IsIso (Sigma.desc π)
⊢ ∃ x X π, T = ofArrows X π ∧ EffectiveEpiFamily X π
TACTIC:
|
https://github.com/adamtopaz/CopenhagenMasterclass2023.git | a293ca1554f7e80d891fd4d86fb092c54d8a0a01 | ExtrDisc/ExplicitSheaves.lean | ExtrDisc.extensiveRegular_generates_coherent | [108, 1] | [217, 21] | use Xmap | case h.h.h.mp.of.hS.left.intro.intro.intro.intro
X : ExtrDisc
S : Sieve X
Y : ExtrDisc
T : Presieve Y
hT : T ∈ ExtensiveSieve Y ∪ RegularSieve Y
α : Type
x : Fintype α
Xmap : α → ExtrDisc
π : (a : α) → Xmap a ⟶ Y
h : T = ofArrows Xmap π ∧ IsIso (Sigma.desc π)
⊢ ∃ X π, T = ofArrows X π ∧ EffectiveEpiFamily X π | case h.h.h.mp.of.hS.left.intro.intro.intro.intro
X : ExtrDisc
S : Sieve X
Y : ExtrDisc
T : Presieve Y
hT : T ∈ ExtensiveSieve Y ∪ RegularSieve Y
α : Type
x : Fintype α
Xmap : α → ExtrDisc
π : (a : α) → Xmap a ⟶ Y
h : T = ofArrows Xmap π ∧ IsIso (Sigma.desc π)
⊢ ∃ π, T = ofArrows Xmap π ∧ EffectiveEpiFamily Xmap π | Please generate a tactic in lean4 to solve the state.
STATE:
case h.h.h.mp.of.hS.left.intro.intro.intro.intro
X : ExtrDisc
S : Sieve X
Y : ExtrDisc
T : Presieve Y
hT : T ∈ ExtensiveSieve Y ∪ RegularSieve Y
α : Type
x : Fintype α
Xmap : α → ExtrDisc
π : (a : α) → Xmap a ⟶ Y
h : T = ofArrows Xmap π ∧ IsIso (Sigma.desc π)
⊢ ∃ X π, T = ofArrows X π ∧ EffectiveEpiFamily X π
TACTIC:
|
https://github.com/adamtopaz/CopenhagenMasterclass2023.git | a293ca1554f7e80d891fd4d86fb092c54d8a0a01 | ExtrDisc/ExplicitSheaves.lean | ExtrDisc.extensiveRegular_generates_coherent | [108, 1] | [217, 21] | use π | case h.h.h.mp.of.hS.left.intro.intro.intro.intro
X : ExtrDisc
S : Sieve X
Y : ExtrDisc
T : Presieve Y
hT : T ∈ ExtensiveSieve Y ∪ RegularSieve Y
α : Type
x : Fintype α
Xmap : α → ExtrDisc
π : (a : α) → Xmap a ⟶ Y
h : T = ofArrows Xmap π ∧ IsIso (Sigma.desc π)
⊢ ∃ π, T = ofArrows Xmap π ∧ EffectiveEpiFamily Xmap π | case h.h.h.mp.of.hS.left.intro.intro.intro.intro
X : ExtrDisc
S : Sieve X
Y : ExtrDisc
T : Presieve Y
hT : T ∈ ExtensiveSieve Y ∪ RegularSieve Y
α : Type
x : Fintype α
Xmap : α → ExtrDisc
π : (a : α) → Xmap a ⟶ Y
h : T = ofArrows Xmap π ∧ IsIso (Sigma.desc π)
⊢ T = ofArrows Xmap π ∧ EffectiveEpiFamily Xmap π | Please generate a tactic in lean4 to solve the state.
STATE:
case h.h.h.mp.of.hS.left.intro.intro.intro.intro
X : ExtrDisc
S : Sieve X
Y : ExtrDisc
T : Presieve Y
hT : T ∈ ExtensiveSieve Y ∪ RegularSieve Y
α : Type
x : Fintype α
Xmap : α → ExtrDisc
π : (a : α) → Xmap a ⟶ Y
h : T = ofArrows Xmap π ∧ IsIso (Sigma.desc π)
⊢ ∃ π, T = ofArrows Xmap π ∧ EffectiveEpiFamily Xmap π
TACTIC:
|
https://github.com/adamtopaz/CopenhagenMasterclass2023.git | a293ca1554f7e80d891fd4d86fb092c54d8a0a01 | ExtrDisc/ExplicitSheaves.lean | ExtrDisc.extensiveRegular_generates_coherent | [108, 1] | [217, 21] | refine' ⟨h.1,_⟩ | case h.h.h.mp.of.hS.left.intro.intro.intro.intro
X : ExtrDisc
S : Sieve X
Y : ExtrDisc
T : Presieve Y
hT : T ∈ ExtensiveSieve Y ∪ RegularSieve Y
α : Type
x : Fintype α
Xmap : α → ExtrDisc
π : (a : α) → Xmap a ⟶ Y
h : T = ofArrows Xmap π ∧ IsIso (Sigma.desc π)
⊢ T = ofArrows Xmap π ∧ EffectiveEpiFamily Xmap π | case h.h.h.mp.of.hS.left.intro.intro.intro.intro
X : ExtrDisc
S : Sieve X
Y : ExtrDisc
T : Presieve Y
hT : T ∈ ExtensiveSieve Y ∪ RegularSieve Y
α : Type
x : Fintype α
Xmap : α → ExtrDisc
π : (a : α) → Xmap a ⟶ Y
h : T = ofArrows Xmap π ∧ IsIso (Sigma.desc π)
⊢ EffectiveEpiFamily Xmap π | Please generate a tactic in lean4 to solve the state.
STATE:
case h.h.h.mp.of.hS.left.intro.intro.intro.intro
X : ExtrDisc
S : Sieve X
Y : ExtrDisc
T : Presieve Y
hT : T ∈ ExtensiveSieve Y ∪ RegularSieve Y
α : Type
x : Fintype α
Xmap : α → ExtrDisc
π : (a : α) → Xmap a ⟶ Y
h : T = ofArrows Xmap π ∧ IsIso (Sigma.desc π)
⊢ T = ofArrows Xmap π ∧ EffectiveEpiFamily Xmap π
TACTIC:
|
https://github.com/adamtopaz/CopenhagenMasterclass2023.git | a293ca1554f7e80d891fd4d86fb092c54d8a0a01 | ExtrDisc/ExplicitSheaves.lean | ExtrDisc.extensiveRegular_generates_coherent | [108, 1] | [217, 21] | have he := (effectiveEpiFamily_tfae Xmap π).out 0 1 | case h.h.h.mp.of.hS.left.intro.intro.intro.intro
X : ExtrDisc
S : Sieve X
Y : ExtrDisc
T : Presieve Y
hT : T ∈ ExtensiveSieve Y ∪ RegularSieve Y
α : Type
x : Fintype α
Xmap : α → ExtrDisc
π : (a : α) → Xmap a ⟶ Y
h : T = ofArrows Xmap π ∧ IsIso (Sigma.desc π)
⊢ EffectiveEpiFamily Xmap π | case h.h.h.mp.of.hS.left.intro.intro.intro.intro
X : ExtrDisc
S : Sieve X
Y : ExtrDisc
T : Presieve Y
hT : T ∈ ExtensiveSieve Y ∪ RegularSieve Y
α : Type
x : Fintype α
Xmap : α → ExtrDisc
π : (a : α) → Xmap a ⟶ Y
h : T = ofArrows Xmap π ∧ IsIso (Sigma.desc π)
he : EffectiveEpiFamily Xmap π ↔ Epi (Sigma.desc π)
⊢ EffectiveEpiFamily Xmap π | Please generate a tactic in lean4 to solve the state.
STATE:
case h.h.h.mp.of.hS.left.intro.intro.intro.intro
X : ExtrDisc
S : Sieve X
Y : ExtrDisc
T : Presieve Y
hT : T ∈ ExtensiveSieve Y ∪ RegularSieve Y
α : Type
x : Fintype α
Xmap : α → ExtrDisc
π : (a : α) → Xmap a ⟶ Y
h : T = ofArrows Xmap π ∧ IsIso (Sigma.desc π)
⊢ EffectiveEpiFamily Xmap π
TACTIC:
|
https://github.com/adamtopaz/CopenhagenMasterclass2023.git | a293ca1554f7e80d891fd4d86fb092c54d8a0a01 | ExtrDisc/ExplicitSheaves.lean | ExtrDisc.extensiveRegular_generates_coherent | [108, 1] | [217, 21] | rw [he] | case h.h.h.mp.of.hS.left.intro.intro.intro.intro
X : ExtrDisc
S : Sieve X
Y : ExtrDisc
T : Presieve Y
hT : T ∈ ExtensiveSieve Y ∪ RegularSieve Y
α : Type
x : Fintype α
Xmap : α → ExtrDisc
π : (a : α) → Xmap a ⟶ Y
h : T = ofArrows Xmap π ∧ IsIso (Sigma.desc π)
he : EffectiveEpiFamily Xmap π ↔ Epi (Sigma.desc π)
⊢ EffectiveEpiFamily Xmap π | case h.h.h.mp.of.hS.left.intro.intro.intro.intro
X : ExtrDisc
S : Sieve X
Y : ExtrDisc
T : Presieve Y
hT : T ∈ ExtensiveSieve Y ∪ RegularSieve Y
α : Type
x : Fintype α
Xmap : α → ExtrDisc
π : (a : α) → Xmap a ⟶ Y
h : T = ofArrows Xmap π ∧ IsIso (Sigma.desc π)
he : EffectiveEpiFamily Xmap π ↔ Epi (Sigma.desc π)
⊢ Epi (Sigma.desc π) | Please generate a tactic in lean4 to solve the state.
STATE:
case h.h.h.mp.of.hS.left.intro.intro.intro.intro
X : ExtrDisc
S : Sieve X
Y : ExtrDisc
T : Presieve Y
hT : T ∈ ExtensiveSieve Y ∪ RegularSieve Y
α : Type
x : Fintype α
Xmap : α → ExtrDisc
π : (a : α) → Xmap a ⟶ Y
h : T = ofArrows Xmap π ∧ IsIso (Sigma.desc π)
he : EffectiveEpiFamily Xmap π ↔ Epi (Sigma.desc π)
⊢ EffectiveEpiFamily Xmap π
TACTIC:
|
https://github.com/adamtopaz/CopenhagenMasterclass2023.git | a293ca1554f7e80d891fd4d86fb092c54d8a0a01 | ExtrDisc/ExplicitSheaves.lean | ExtrDisc.extensiveRegular_generates_coherent | [108, 1] | [217, 21] | letI := h.2 | case h.h.h.mp.of.hS.left.intro.intro.intro.intro
X : ExtrDisc
S : Sieve X
Y : ExtrDisc
T : Presieve Y
hT : T ∈ ExtensiveSieve Y ∪ RegularSieve Y
α : Type
x : Fintype α
Xmap : α → ExtrDisc
π : (a : α) → Xmap a ⟶ Y
h : T = ofArrows Xmap π ∧ IsIso (Sigma.desc π)
he : EffectiveEpiFamily Xmap π ↔ Epi (Sigma.desc π)
⊢ Epi (Sigma.desc π) | case h.h.h.mp.of.hS.left.intro.intro.intro.intro
X : ExtrDisc
S : Sieve X
Y : ExtrDisc
T : Presieve Y
hT : T ∈ ExtensiveSieve Y ∪ RegularSieve Y
α : Type
x : Fintype α
Xmap : α → ExtrDisc
π : (a : α) → Xmap a ⟶ Y
h : T = ofArrows Xmap π ∧ IsIso (Sigma.desc π)
he : EffectiveEpiFamily Xmap π ↔ Epi (Sigma.desc π)
this : IsIso (Sigma.desc π) := h.right
⊢ Epi (Sigma.desc π) | Please generate a tactic in lean4 to solve the state.
STATE:
case h.h.h.mp.of.hS.left.intro.intro.intro.intro
X : ExtrDisc
S : Sieve X
Y : ExtrDisc
T : Presieve Y
hT : T ∈ ExtensiveSieve Y ∪ RegularSieve Y
α : Type
x : Fintype α
Xmap : α → ExtrDisc
π : (a : α) → Xmap a ⟶ Y
h : T = ofArrows Xmap π ∧ IsIso (Sigma.desc π)
he : EffectiveEpiFamily Xmap π ↔ Epi (Sigma.desc π)
⊢ Epi (Sigma.desc π)
TACTIC:
|
https://github.com/adamtopaz/CopenhagenMasterclass2023.git | a293ca1554f7e80d891fd4d86fb092c54d8a0a01 | ExtrDisc/ExplicitSheaves.lean | ExtrDisc.extensiveRegular_generates_coherent | [108, 1] | [217, 21] | exact inferInstance | case h.h.h.mp.of.hS.left.intro.intro.intro.intro
X : ExtrDisc
S : Sieve X
Y : ExtrDisc
T : Presieve Y
hT : T ∈ ExtensiveSieve Y ∪ RegularSieve Y
α : Type
x : Fintype α
Xmap : α → ExtrDisc
π : (a : α) → Xmap a ⟶ Y
h : T = ofArrows Xmap π ∧ IsIso (Sigma.desc π)
he : EffectiveEpiFamily Xmap π ↔ Epi (Sigma.desc π)
this : IsIso (Sigma.desc π) := h.right
⊢ Epi (Sigma.desc π) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case h.h.h.mp.of.hS.left.intro.intro.intro.intro
X : ExtrDisc
S : Sieve X
Y : ExtrDisc
T : Presieve Y
hT : T ∈ ExtensiveSieve Y ∪ RegularSieve Y
α : Type
x : Fintype α
Xmap : α → ExtrDisc
π : (a : α) → Xmap a ⟶ Y
h : T = ofArrows Xmap π ∧ IsIso (Sigma.desc π)
he : EffectiveEpiFamily Xmap π ↔ Epi (Sigma.desc π)
this : IsIso (Sigma.desc π) := h.right
⊢ Epi (Sigma.desc π)
TACTIC:
|
https://github.com/adamtopaz/CopenhagenMasterclass2023.git | a293ca1554f7e80d891fd4d86fb092c54d8a0a01 | ExtrDisc/ExplicitSheaves.lean | ExtrDisc.extensiveRegular_generates_coherent | [108, 1] | [217, 21] | obtain ⟨Z, f, h⟩ := h | case h.h.h.mp.of.hS.right
X : ExtrDisc
S : Sieve X
Y : ExtrDisc
T : Presieve Y
hT : T ∈ ExtensiveSieve Y ∪ RegularSieve Y
h : T ∈ RegularSieve Y
⊢ ∃ α x X π, T = ofArrows X π ∧ EffectiveEpiFamily X π | case h.h.h.mp.of.hS.right.intro.intro
X : ExtrDisc
S : Sieve X
Y : ExtrDisc
T : Presieve Y
hT : T ∈ ExtensiveSieve Y ∪ RegularSieve Y
Z : ExtrDisc
f : Z ⟶ Y
h : (T = ofArrows (fun x => Z) fun x => f) ∧ Epi f
⊢ ∃ α x X π, T = ofArrows X π ∧ EffectiveEpiFamily X π | Please generate a tactic in lean4 to solve the state.
STATE:
case h.h.h.mp.of.hS.right
X : ExtrDisc
S : Sieve X
Y : ExtrDisc
T : Presieve Y
hT : T ∈ ExtensiveSieve Y ∪ RegularSieve Y
h : T ∈ RegularSieve Y
⊢ ∃ α x X π, T = ofArrows X π ∧ EffectiveEpiFamily X π
TACTIC:
|
https://github.com/adamtopaz/CopenhagenMasterclass2023.git | a293ca1554f7e80d891fd4d86fb092c54d8a0a01 | ExtrDisc/ExplicitSheaves.lean | ExtrDisc.extensiveRegular_generates_coherent | [108, 1] | [217, 21] | use Unit | case h.h.h.mp.of.hS.right.intro.intro
X : ExtrDisc
S : Sieve X
Y : ExtrDisc
T : Presieve Y
hT : T ∈ ExtensiveSieve Y ∪ RegularSieve Y
Z : ExtrDisc
f : Z ⟶ Y
h : (T = ofArrows (fun x => Z) fun x => f) ∧ Epi f
⊢ ∃ α x X π, T = ofArrows X π ∧ EffectiveEpiFamily X π | case h.h.h.mp.of.hS.right.intro.intro
X : ExtrDisc
S : Sieve X
Y : ExtrDisc
T : Presieve Y
hT : T ∈ ExtensiveSieve Y ∪ RegularSieve Y
Z : ExtrDisc
f : Z ⟶ Y
h : (T = ofArrows (fun x => Z) fun x => f) ∧ Epi f
⊢ ∃ x X π, T = ofArrows X π ∧ EffectiveEpiFamily X π | Please generate a tactic in lean4 to solve the state.
STATE:
case h.h.h.mp.of.hS.right.intro.intro
X : ExtrDisc
S : Sieve X
Y : ExtrDisc
T : Presieve Y
hT : T ∈ ExtensiveSieve Y ∪ RegularSieve Y
Z : ExtrDisc
f : Z ⟶ Y
h : (T = ofArrows (fun x => Z) fun x => f) ∧ Epi f
⊢ ∃ α x X π, T = ofArrows X π ∧ EffectiveEpiFamily X π
TACTIC:
|
https://github.com/adamtopaz/CopenhagenMasterclass2023.git | a293ca1554f7e80d891fd4d86fb092c54d8a0a01 | ExtrDisc/ExplicitSheaves.lean | ExtrDisc.extensiveRegular_generates_coherent | [108, 1] | [217, 21] | use inferInstance | case h.h.h.mp.of.hS.right.intro.intro
X : ExtrDisc
S : Sieve X
Y : ExtrDisc
T : Presieve Y
hT : T ∈ ExtensiveSieve Y ∪ RegularSieve Y
Z : ExtrDisc
f : Z ⟶ Y
h : (T = ofArrows (fun x => Z) fun x => f) ∧ Epi f
⊢ ∃ x X π, T = ofArrows X π ∧ EffectiveEpiFamily X π | case h.h.h.mp.of.hS.right.intro.intro
X : ExtrDisc
S : Sieve X
Y : ExtrDisc
T : Presieve Y
hT : T ∈ ExtensiveSieve Y ∪ RegularSieve Y
Z : ExtrDisc
f : Z ⟶ Y
h : (T = ofArrows (fun x => Z) fun x => f) ∧ Epi f
⊢ ∃ X π, T = ofArrows X π ∧ EffectiveEpiFamily X π | Please generate a tactic in lean4 to solve the state.
STATE:
case h.h.h.mp.of.hS.right.intro.intro
X : ExtrDisc
S : Sieve X
Y : ExtrDisc
T : Presieve Y
hT : T ∈ ExtensiveSieve Y ∪ RegularSieve Y
Z : ExtrDisc
f : Z ⟶ Y
h : (T = ofArrows (fun x => Z) fun x => f) ∧ Epi f
⊢ ∃ x X π, T = ofArrows X π ∧ EffectiveEpiFamily X π
TACTIC:
|
https://github.com/adamtopaz/CopenhagenMasterclass2023.git | a293ca1554f7e80d891fd4d86fb092c54d8a0a01 | ExtrDisc/ExplicitSheaves.lean | ExtrDisc.extensiveRegular_generates_coherent | [108, 1] | [217, 21] | use (fun _ ↦ Z) | case h.h.h.mp.of.hS.right.intro.intro
X : ExtrDisc
S : Sieve X
Y : ExtrDisc
T : Presieve Y
hT : T ∈ ExtensiveSieve Y ∪ RegularSieve Y
Z : ExtrDisc
f : Z ⟶ Y
h : (T = ofArrows (fun x => Z) fun x => f) ∧ Epi f
⊢ ∃ X π, T = ofArrows X π ∧ EffectiveEpiFamily X π | case h.h.h.mp.of.hS.right.intro.intro
X : ExtrDisc
S : Sieve X
Y : ExtrDisc
T : Presieve Y
hT : T ∈ ExtensiveSieve Y ∪ RegularSieve Y
Z : ExtrDisc
f : Z ⟶ Y
h : (T = ofArrows (fun x => Z) fun x => f) ∧ Epi f
⊢ ∃ π, T = ofArrows (fun x => Z) π ∧ EffectiveEpiFamily (fun x => Z) π | Please generate a tactic in lean4 to solve the state.
STATE:
case h.h.h.mp.of.hS.right.intro.intro
X : ExtrDisc
S : Sieve X
Y : ExtrDisc
T : Presieve Y
hT : T ∈ ExtensiveSieve Y ∪ RegularSieve Y
Z : ExtrDisc
f : Z ⟶ Y
h : (T = ofArrows (fun x => Z) fun x => f) ∧ Epi f
⊢ ∃ X π, T = ofArrows X π ∧ EffectiveEpiFamily X π
TACTIC:
|
https://github.com/adamtopaz/CopenhagenMasterclass2023.git | a293ca1554f7e80d891fd4d86fb092c54d8a0a01 | ExtrDisc/ExplicitSheaves.lean | ExtrDisc.extensiveRegular_generates_coherent | [108, 1] | [217, 21] | use (fun _ ↦ f) | case h.h.h.mp.of.hS.right.intro.intro
X : ExtrDisc
S : Sieve X
Y : ExtrDisc
T : Presieve Y
hT : T ∈ ExtensiveSieve Y ∪ RegularSieve Y
Z : ExtrDisc
f : Z ⟶ Y
h : (T = ofArrows (fun x => Z) fun x => f) ∧ Epi f
⊢ ∃ π, T = ofArrows (fun x => Z) π ∧ EffectiveEpiFamily (fun x => Z) π | case h.h.h.mp.of.hS.right.intro.intro
X : ExtrDisc
S : Sieve X
Y : ExtrDisc
T : Presieve Y
hT : T ∈ ExtensiveSieve Y ∪ RegularSieve Y
Z : ExtrDisc
f : Z ⟶ Y
h : (T = ofArrows (fun x => Z) fun x => f) ∧ Epi f
⊢ (T = ofArrows (fun x => Z) fun x => f) ∧ EffectiveEpiFamily (fun x => Z) fun x => f | Please generate a tactic in lean4 to solve the state.
STATE:
case h.h.h.mp.of.hS.right.intro.intro
X : ExtrDisc
S : Sieve X
Y : ExtrDisc
T : Presieve Y
hT : T ∈ ExtensiveSieve Y ∪ RegularSieve Y
Z : ExtrDisc
f : Z ⟶ Y
h : (T = ofArrows (fun x => Z) fun x => f) ∧ Epi f
⊢ ∃ π, T = ofArrows (fun x => Z) π ∧ EffectiveEpiFamily (fun x => Z) π
TACTIC:
|
https://github.com/adamtopaz/CopenhagenMasterclass2023.git | a293ca1554f7e80d891fd4d86fb092c54d8a0a01 | ExtrDisc/ExplicitSheaves.lean | ExtrDisc.extensiveRegular_generates_coherent | [108, 1] | [217, 21] | refine' ⟨h.1,_⟩ | case h.h.h.mp.of.hS.right.intro.intro
X : ExtrDisc
S : Sieve X
Y : ExtrDisc
T : Presieve Y
hT : T ∈ ExtensiveSieve Y ∪ RegularSieve Y
Z : ExtrDisc
f : Z ⟶ Y
h : (T = ofArrows (fun x => Z) fun x => f) ∧ Epi f
⊢ (T = ofArrows (fun x => Z) fun x => f) ∧ EffectiveEpiFamily (fun x => Z) fun x => f | case h.h.h.mp.of.hS.right.intro.intro
X : ExtrDisc
S : Sieve X
Y : ExtrDisc
T : Presieve Y
hT : T ∈ ExtensiveSieve Y ∪ RegularSieve Y
Z : ExtrDisc
f : Z ⟶ Y
h : (T = ofArrows (fun x => Z) fun x => f) ∧ Epi f
⊢ EffectiveEpiFamily (fun x => Z) fun x => f | Please generate a tactic in lean4 to solve the state.
STATE:
case h.h.h.mp.of.hS.right.intro.intro
X : ExtrDisc
S : Sieve X
Y : ExtrDisc
T : Presieve Y
hT : T ∈ ExtensiveSieve Y ∪ RegularSieve Y
Z : ExtrDisc
f : Z ⟶ Y
h : (T = ofArrows (fun x => Z) fun x => f) ∧ Epi f
⊢ (T = ofArrows (fun x => Z) fun x => f) ∧ EffectiveEpiFamily (fun x => Z) fun x => f
TACTIC:
|
https://github.com/adamtopaz/CopenhagenMasterclass2023.git | a293ca1554f7e80d891fd4d86fb092c54d8a0a01 | ExtrDisc/ExplicitSheaves.lean | ExtrDisc.extensiveRegular_generates_coherent | [108, 1] | [217, 21] | have he := (effectiveEpiFamily_tfae (fun (_ : Unit) ↦ Z) (fun _ ↦ f)).out 0 1 | case h.h.h.mp.of.hS.right.intro.intro
X : ExtrDisc
S : Sieve X
Y : ExtrDisc
T : Presieve Y
hT : T ∈ ExtensiveSieve Y ∪ RegularSieve Y
Z : ExtrDisc
f : Z ⟶ Y
h : (T = ofArrows (fun x => Z) fun x => f) ∧ Epi f
⊢ EffectiveEpiFamily (fun x => Z) fun x => f | case h.h.h.mp.of.hS.right.intro.intro
X : ExtrDisc
S : Sieve X
Y : ExtrDisc
T : Presieve Y
hT : T ∈ ExtensiveSieve Y ∪ RegularSieve Y
Z : ExtrDisc
f : Z ⟶ Y
h : (T = ofArrows (fun x => Z) fun x => f) ∧ Epi f
he : (EffectiveEpiFamily (fun x => Z) fun x => f) ↔ Epi (Sigma.desc fun x => f)
⊢ EffectiveEpiFamily (fun x => Z) fun x => f | Please generate a tactic in lean4 to solve the state.
STATE:
case h.h.h.mp.of.hS.right.intro.intro
X : ExtrDisc
S : Sieve X
Y : ExtrDisc
T : Presieve Y
hT : T ∈ ExtensiveSieve Y ∪ RegularSieve Y
Z : ExtrDisc
f : Z ⟶ Y
h : (T = ofArrows (fun x => Z) fun x => f) ∧ Epi f
⊢ EffectiveEpiFamily (fun x => Z) fun x => f
TACTIC:
|
https://github.com/adamtopaz/CopenhagenMasterclass2023.git | a293ca1554f7e80d891fd4d86fb092c54d8a0a01 | ExtrDisc/ExplicitSheaves.lean | ExtrDisc.extensiveRegular_generates_coherent | [108, 1] | [217, 21] | rw [he] | case h.h.h.mp.of.hS.right.intro.intro
X : ExtrDisc
S : Sieve X
Y : ExtrDisc
T : Presieve Y
hT : T ∈ ExtensiveSieve Y ∪ RegularSieve Y
Z : ExtrDisc
f : Z ⟶ Y
h : (T = ofArrows (fun x => Z) fun x => f) ∧ Epi f
he : (EffectiveEpiFamily (fun x => Z) fun x => f) ↔ Epi (Sigma.desc fun x => f)
⊢ EffectiveEpiFamily (fun x => Z) fun x => f | case h.h.h.mp.of.hS.right.intro.intro
X : ExtrDisc
S : Sieve X
Y : ExtrDisc
T : Presieve Y
hT : T ∈ ExtensiveSieve Y ∪ RegularSieve Y
Z : ExtrDisc
f : Z ⟶ Y
h : (T = ofArrows (fun x => Z) fun x => f) ∧ Epi f
he : (EffectiveEpiFamily (fun x => Z) fun x => f) ↔ Epi (Sigma.desc fun x => f)
⊢ Epi (Sigma.desc fun x => f) | Please generate a tactic in lean4 to solve the state.
STATE:
case h.h.h.mp.of.hS.right.intro.intro
X : ExtrDisc
S : Sieve X
Y : ExtrDisc
T : Presieve Y
hT : T ∈ ExtensiveSieve Y ∪ RegularSieve Y
Z : ExtrDisc
f : Z ⟶ Y
h : (T = ofArrows (fun x => Z) fun x => f) ∧ Epi f
he : (EffectiveEpiFamily (fun x => Z) fun x => f) ↔ Epi (Sigma.desc fun x => f)
⊢ EffectiveEpiFamily (fun x => Z) fun x => f
TACTIC:
|
https://github.com/adamtopaz/CopenhagenMasterclass2023.git | a293ca1554f7e80d891fd4d86fb092c54d8a0a01 | ExtrDisc/ExplicitSheaves.lean | ExtrDisc.extensiveRegular_generates_coherent | [108, 1] | [217, 21] | rw [ExtrDisc.epi_iff_surjective _] at h ⊢ | case h.h.h.mp.of.hS.right.intro.intro
X : ExtrDisc
S : Sieve X
Y : ExtrDisc
T : Presieve Y
hT : T ∈ ExtensiveSieve Y ∪ RegularSieve Y
Z : ExtrDisc
f : Z ⟶ Y
h : (T = ofArrows (fun x => Z) fun x => f) ∧ Epi f
he : (EffectiveEpiFamily (fun x => Z) fun x => f) ↔ Epi (Sigma.desc fun x => f)
⊢ Epi (Sigma.desc fun x => f) | case h.h.h.mp.of.hS.right.intro.intro
X : ExtrDisc
S : Sieve X
Y : ExtrDisc
T : Presieve Y
hT : T ∈ ExtensiveSieve Y ∪ RegularSieve Y
Z : ExtrDisc
f : Z ⟶ Y
h : (T = ofArrows (fun x => Z) fun x => f) ∧ Function.Surjective ↑f
he : (EffectiveEpiFamily (fun x => Z) fun x => f) ↔ Epi (Sigma.desc fun x => f)
⊢ Function.Surjective ↑(Sigma.desc fun x => f) | Please generate a tactic in lean4 to solve the state.
STATE:
case h.h.h.mp.of.hS.right.intro.intro
X : ExtrDisc
S : Sieve X
Y : ExtrDisc
T : Presieve Y
hT : T ∈ ExtensiveSieve Y ∪ RegularSieve Y
Z : ExtrDisc
f : Z ⟶ Y
h : (T = ofArrows (fun x => Z) fun x => f) ∧ Epi f
he : (EffectiveEpiFamily (fun x => Z) fun x => f) ↔ Epi (Sigma.desc fun x => f)
⊢ Epi (Sigma.desc fun x => f)
TACTIC:
|
https://github.com/adamtopaz/CopenhagenMasterclass2023.git | a293ca1554f7e80d891fd4d86fb092c54d8a0a01 | ExtrDisc/ExplicitSheaves.lean | ExtrDisc.extensiveRegular_generates_coherent | [108, 1] | [217, 21] | intro x | case h.h.h.mp.of.hS.right.intro.intro
X : ExtrDisc
S : Sieve X
Y : ExtrDisc
T : Presieve Y
hT : T ∈ ExtensiveSieve Y ∪ RegularSieve Y
Z : ExtrDisc
f : Z ⟶ Y
h : (T = ofArrows (fun x => Z) fun x => f) ∧ Function.Surjective ↑f
he : (EffectiveEpiFamily (fun x => Z) fun x => f) ↔ Epi (Sigma.desc fun x => f)
⊢ Function.Surjective ↑(Sigma.desc fun x => f) | case h.h.h.mp.of.hS.right.intro.intro
X : ExtrDisc
S : Sieve X
Y : ExtrDisc
T : Presieve Y
hT : T ∈ ExtensiveSieve Y ∪ RegularSieve Y
Z : ExtrDisc
f : Z ⟶ Y
h : (T = ofArrows (fun x => Z) fun x => f) ∧ Function.Surjective ↑f
he : (EffectiveEpiFamily (fun x => Z) fun x => f) ↔ Epi (Sigma.desc fun x => f)
x : CoeSort.coe Y
⊢ ∃ a, ↑(Sigma.desc fun x => f) a = x | Please generate a tactic in lean4 to solve the state.
STATE:
case h.h.h.mp.of.hS.right.intro.intro
X : ExtrDisc
S : Sieve X
Y : ExtrDisc
T : Presieve Y
hT : T ∈ ExtensiveSieve Y ∪ RegularSieve Y
Z : ExtrDisc
f : Z ⟶ Y
h : (T = ofArrows (fun x => Z) fun x => f) ∧ Function.Surjective ↑f
he : (EffectiveEpiFamily (fun x => Z) fun x => f) ↔ Epi (Sigma.desc fun x => f)
⊢ Function.Surjective ↑(Sigma.desc fun x => f)
TACTIC:
|
https://github.com/adamtopaz/CopenhagenMasterclass2023.git | a293ca1554f7e80d891fd4d86fb092c54d8a0a01 | ExtrDisc/ExplicitSheaves.lean | ExtrDisc.extensiveRegular_generates_coherent | [108, 1] | [217, 21] | obtain ⟨y,hy⟩ := h.2 x | case h.h.h.mp.of.hS.right.intro.intro
X : ExtrDisc
S : Sieve X
Y : ExtrDisc
T : Presieve Y
hT : T ∈ ExtensiveSieve Y ∪ RegularSieve Y
Z : ExtrDisc
f : Z ⟶ Y
h : (T = ofArrows (fun x => Z) fun x => f) ∧ Function.Surjective ↑f
he : (EffectiveEpiFamily (fun x => Z) fun x => f) ↔ Epi (Sigma.desc fun x => f)
x : CoeSort.coe Y
⊢ ∃ a, ↑(Sigma.desc fun x => f) a = x | case h.h.h.mp.of.hS.right.intro.intro.intro
X : ExtrDisc
S : Sieve X
Y : ExtrDisc
T : Presieve Y
hT : T ∈ ExtensiveSieve Y ∪ RegularSieve Y
Z : ExtrDisc
f : Z ⟶ Y
h : (T = ofArrows (fun x => Z) fun x => f) ∧ Function.Surjective ↑f
he : (EffectiveEpiFamily (fun x => Z) fun x => f) ↔ Epi (Sigma.desc fun x => f)
x : CoeSort.coe Y
y : CoeSort.coe Z
hy : ↑f y = x
⊢ ∃ a, ↑(Sigma.desc fun x => f) a = x | Please generate a tactic in lean4 to solve the state.
STATE:
case h.h.h.mp.of.hS.right.intro.intro
X : ExtrDisc
S : Sieve X
Y : ExtrDisc
T : Presieve Y
hT : T ∈ ExtensiveSieve Y ∪ RegularSieve Y
Z : ExtrDisc
f : Z ⟶ Y
h : (T = ofArrows (fun x => Z) fun x => f) ∧ Function.Surjective ↑f
he : (EffectiveEpiFamily (fun x => Z) fun x => f) ↔ Epi (Sigma.desc fun x => f)
x : CoeSort.coe Y
⊢ ∃ a, ↑(Sigma.desc fun x => f) a = x
TACTIC:
|
https://github.com/adamtopaz/CopenhagenMasterclass2023.git | a293ca1554f7e80d891fd4d86fb092c54d8a0a01 | ExtrDisc/ExplicitSheaves.lean | ExtrDisc.extensiveRegular_generates_coherent | [108, 1] | [217, 21] | use Sigma.ι (fun (_ : Unit) ↦ Z) Unit.unit y | case h.h.h.mp.of.hS.right.intro.intro.intro
X : ExtrDisc
S : Sieve X
Y : ExtrDisc
T : Presieve Y
hT : T ∈ ExtensiveSieve Y ∪ RegularSieve Y
Z : ExtrDisc
f : Z ⟶ Y
h : (T = ofArrows (fun x => Z) fun x => f) ∧ Function.Surjective ↑f
he : (EffectiveEpiFamily (fun x => Z) fun x => f) ↔ Epi (Sigma.desc fun x => f)
x : CoeSort.coe Y
y : CoeSort.coe Z
hy : ↑f y = x
⊢ ∃ a, ↑(Sigma.desc fun x => f) a = x | case h.h.h.mp.of.hS.right.intro.intro.intro
X : ExtrDisc
S : Sieve X
Y : ExtrDisc
T : Presieve Y
hT : T ∈ ExtensiveSieve Y ∪ RegularSieve Y
Z : ExtrDisc
f : Z ⟶ Y
h : (T = ofArrows (fun x => Z) fun x => f) ∧ Function.Surjective ↑f
he : (EffectiveEpiFamily (fun x => Z) fun x => f) ↔ Epi (Sigma.desc fun x => f)
x : CoeSort.coe Y
y : CoeSort.coe Z
hy : ↑f y = x
⊢ ↑(Sigma.desc fun x => f) (↑(Sigma.ι (fun x => Z) ()) y) = x | Please generate a tactic in lean4 to solve the state.
STATE:
case h.h.h.mp.of.hS.right.intro.intro.intro
X : ExtrDisc
S : Sieve X
Y : ExtrDisc
T : Presieve Y
hT : T ∈ ExtensiveSieve Y ∪ RegularSieve Y
Z : ExtrDisc
f : Z ⟶ Y
h : (T = ofArrows (fun x => Z) fun x => f) ∧ Function.Surjective ↑f
he : (EffectiveEpiFamily (fun x => Z) fun x => f) ↔ Epi (Sigma.desc fun x => f)
x : CoeSort.coe Y
y : CoeSort.coe Z
hy : ↑f y = x
⊢ ∃ a, ↑(Sigma.desc fun x => f) a = x
TACTIC:
|
https://github.com/adamtopaz/CopenhagenMasterclass2023.git | a293ca1554f7e80d891fd4d86fb092c54d8a0a01 | ExtrDisc/ExplicitSheaves.lean | ExtrDisc.extensiveRegular_generates_coherent | [108, 1] | [217, 21] | rw [← hy] | case h.h.h.mp.of.hS.right.intro.intro.intro
X : ExtrDisc
S : Sieve X
Y : ExtrDisc
T : Presieve Y
hT : T ∈ ExtensiveSieve Y ∪ RegularSieve Y
Z : ExtrDisc
f : Z ⟶ Y
h : (T = ofArrows (fun x => Z) fun x => f) ∧ Function.Surjective ↑f
he : (EffectiveEpiFamily (fun x => Z) fun x => f) ↔ Epi (Sigma.desc fun x => f)
x : CoeSort.coe Y
y : CoeSort.coe Z
hy : ↑f y = x
⊢ ↑(Sigma.desc fun x => f) (↑(Sigma.ι (fun x => Z) ()) y) = x | case h.h.h.mp.of.hS.right.intro.intro.intro
X : ExtrDisc
S : Sieve X
Y : ExtrDisc
T : Presieve Y
hT : T ∈ ExtensiveSieve Y ∪ RegularSieve Y
Z : ExtrDisc
f : Z ⟶ Y
h : (T = ofArrows (fun x => Z) fun x => f) ∧ Function.Surjective ↑f
he : (EffectiveEpiFamily (fun x => Z) fun x => f) ↔ Epi (Sigma.desc fun x => f)
x : CoeSort.coe Y
y : CoeSort.coe Z
hy : ↑f y = x
⊢ ↑(Sigma.desc fun x => f) (↑(Sigma.ι (fun x => Z) ()) y) = ↑f y | Please generate a tactic in lean4 to solve the state.
STATE:
case h.h.h.mp.of.hS.right.intro.intro.intro
X : ExtrDisc
S : Sieve X
Y : ExtrDisc
T : Presieve Y
hT : T ∈ ExtensiveSieve Y ∪ RegularSieve Y
Z : ExtrDisc
f : Z ⟶ Y
h : (T = ofArrows (fun x => Z) fun x => f) ∧ Function.Surjective ↑f
he : (EffectiveEpiFamily (fun x => Z) fun x => f) ↔ Epi (Sigma.desc fun x => f)
x : CoeSort.coe Y
y : CoeSort.coe Z
hy : ↑f y = x
⊢ ↑(Sigma.desc fun x => f) (↑(Sigma.ι (fun x => Z) ()) y) = x
TACTIC:
|
https://github.com/adamtopaz/CopenhagenMasterclass2023.git | a293ca1554f7e80d891fd4d86fb092c54d8a0a01 | ExtrDisc/ExplicitSheaves.lean | ExtrDisc.extensiveRegular_generates_coherent | [108, 1] | [217, 21] | suffices : (f : Z → Y) = Sigma.ι (fun (_ : Unit) ↦ Z) Unit.unit ≫ Sigma.desc (fun _ ↦ f) | case h.h.h.mp.of.hS.right.intro.intro.intro
X : ExtrDisc
S : Sieve X
Y : ExtrDisc
T : Presieve Y
hT : T ∈ ExtensiveSieve Y ∪ RegularSieve Y
Z : ExtrDisc
f : Z ⟶ Y
h : (T = ofArrows (fun x => Z) fun x => f) ∧ Function.Surjective ↑f
he : (EffectiveEpiFamily (fun x => Z) fun x => f) ↔ Epi (Sigma.desc fun x => f)
x : CoeSort.coe Y
y : CoeSort.coe Z
hy : ↑f y = x
⊢ ↑(Sigma.desc fun x => f) (↑(Sigma.ι (fun x => Z) ()) y) = ↑f y | case h.h.h.mp.of.hS.right.intro.intro.intro
X : ExtrDisc
S : Sieve X
Y : ExtrDisc
T : Presieve Y
hT : T ∈ ExtensiveSieve Y ∪ RegularSieve Y
Z : ExtrDisc
f : Z ⟶ Y
h : (T = ofArrows (fun x => Z) fun x => f) ∧ Function.Surjective ↑f
he : (EffectiveEpiFamily (fun x => Z) fun x => f) ↔ Epi (Sigma.desc fun x => f)
x : CoeSort.coe Y
y : CoeSort.coe Z
hy : ↑f y = x
this : ↑f = ↑(Sigma.ι (fun x => Z) () ≫ Sigma.desc fun x => f)
⊢ ↑(Sigma.desc fun x => f) (↑(Sigma.ι (fun x => Z) ()) y) = ↑f y
case this
X : ExtrDisc
S : Sieve X
Y : ExtrDisc
T : Presieve Y
hT : T ∈ ExtensiveSieve Y ∪ RegularSieve Y
Z : ExtrDisc
f : Z ⟶ Y
h : (T = ofArrows (fun x => Z) fun x => f) ∧ Function.Surjective ↑f
he : (EffectiveEpiFamily (fun x => Z) fun x => f) ↔ Epi (Sigma.desc fun x => f)
x : CoeSort.coe Y
y : CoeSort.coe Z
hy : ↑f y = x
⊢ ↑f = ↑(Sigma.ι (fun x => Z) () ≫ Sigma.desc fun x => f) | Please generate a tactic in lean4 to solve the state.
STATE:
case h.h.h.mp.of.hS.right.intro.intro.intro
X : ExtrDisc
S : Sieve X
Y : ExtrDisc
T : Presieve Y
hT : T ∈ ExtensiveSieve Y ∪ RegularSieve Y
Z : ExtrDisc
f : Z ⟶ Y
h : (T = ofArrows (fun x => Z) fun x => f) ∧ Function.Surjective ↑f
he : (EffectiveEpiFamily (fun x => Z) fun x => f) ↔ Epi (Sigma.desc fun x => f)
x : CoeSort.coe Y
y : CoeSort.coe Z
hy : ↑f y = x
⊢ ↑(Sigma.desc fun x => f) (↑(Sigma.ι (fun x => Z) ()) y) = ↑f y
TACTIC:
|
https://github.com/adamtopaz/CopenhagenMasterclass2023.git | a293ca1554f7e80d891fd4d86fb092c54d8a0a01 | ExtrDisc/ExplicitSheaves.lean | ExtrDisc.extensiveRegular_generates_coherent | [108, 1] | [217, 21] | simp only [colimit.ι_desc, Cofan.mk_pt, Cofan.mk_ι_app] | case this
X : ExtrDisc
S : Sieve X
Y : ExtrDisc
T : Presieve Y
hT : T ∈ ExtensiveSieve Y ∪ RegularSieve Y
Z : ExtrDisc
f : Z ⟶ Y
h : (T = ofArrows (fun x => Z) fun x => f) ∧ Function.Surjective ↑f
he : (EffectiveEpiFamily (fun x => Z) fun x => f) ↔ Epi (Sigma.desc fun x => f)
x : CoeSort.coe Y
y : CoeSort.coe Z
hy : ↑f y = x
⊢ ↑f = ↑(Sigma.ι (fun x => Z) () ≫ Sigma.desc fun x => f) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case this
X : ExtrDisc
S : Sieve X
Y : ExtrDisc
T : Presieve Y
hT : T ∈ ExtensiveSieve Y ∪ RegularSieve Y
Z : ExtrDisc
f : Z ⟶ Y
h : (T = ofArrows (fun x => Z) fun x => f) ∧ Function.Surjective ↑f
he : (EffectiveEpiFamily (fun x => Z) fun x => f) ↔ Epi (Sigma.desc fun x => f)
x : CoeSort.coe Y
y : CoeSort.coe Z
hy : ↑f y = x
⊢ ↑f = ↑(Sigma.ι (fun x => Z) () ≫ Sigma.desc fun x => f)
TACTIC:
|
https://github.com/adamtopaz/CopenhagenMasterclass2023.git | a293ca1554f7e80d891fd4d86fb092c54d8a0a01 | ExtrDisc/ExplicitSheaves.lean | ExtrDisc.extensiveRegular_generates_coherent | [108, 1] | [217, 21] | rw [this] | case h.h.h.mp.of.hS.right.intro.intro.intro
X : ExtrDisc
S : Sieve X
Y : ExtrDisc
T : Presieve Y
hT : T ∈ ExtensiveSieve Y ∪ RegularSieve Y
Z : ExtrDisc
f : Z ⟶ Y
h : (T = ofArrows (fun x => Z) fun x => f) ∧ Function.Surjective ↑f
he : (EffectiveEpiFamily (fun x => Z) fun x => f) ↔ Epi (Sigma.desc fun x => f)
x : CoeSort.coe Y
y : CoeSort.coe Z
hy : ↑f y = x
this : ↑f = ↑(Sigma.ι (fun x => Z) () ≫ Sigma.desc fun x => f)
⊢ ↑(Sigma.desc fun x => f) (↑(Sigma.ι (fun x => Z) ()) y) = ↑f y | case h.h.h.mp.of.hS.right.intro.intro.intro
X : ExtrDisc
S : Sieve X
Y : ExtrDisc
T : Presieve Y
hT : T ∈ ExtensiveSieve Y ∪ RegularSieve Y
Z : ExtrDisc
f : Z ⟶ Y
h : (T = ofArrows (fun x => Z) fun x => f) ∧ Function.Surjective ↑f
he : (EffectiveEpiFamily (fun x => Z) fun x => f) ↔ Epi (Sigma.desc fun x => f)
x : CoeSort.coe Y
y : CoeSort.coe Z
hy : ↑f y = x
this : ↑f = ↑(Sigma.ι (fun x => Z) () ≫ Sigma.desc fun x => f)
⊢ ↑(Sigma.desc fun x => f) (↑(Sigma.ι (fun x => Z) ()) y) = ↑(Sigma.ι (fun x => Z) () ≫ Sigma.desc fun x => f) y | Please generate a tactic in lean4 to solve the state.
STATE:
case h.h.h.mp.of.hS.right.intro.intro.intro
X : ExtrDisc
S : Sieve X
Y : ExtrDisc
T : Presieve Y
hT : T ∈ ExtensiveSieve Y ∪ RegularSieve Y
Z : ExtrDisc
f : Z ⟶ Y
h : (T = ofArrows (fun x => Z) fun x => f) ∧ Function.Surjective ↑f
he : (EffectiveEpiFamily (fun x => Z) fun x => f) ↔ Epi (Sigma.desc fun x => f)
x : CoeSort.coe Y
y : CoeSort.coe Z
hy : ↑f y = x
this : ↑f = ↑(Sigma.ι (fun x => Z) () ≫ Sigma.desc fun x => f)
⊢ ↑(Sigma.desc fun x => f) (↑(Sigma.ι (fun x => Z) ()) y) = ↑f y
TACTIC:
|
https://github.com/adamtopaz/CopenhagenMasterclass2023.git | a293ca1554f7e80d891fd4d86fb092c54d8a0a01 | ExtrDisc/ExplicitSheaves.lean | ExtrDisc.extensiveRegular_generates_coherent | [108, 1] | [217, 21] | rfl | case h.h.h.mp.of.hS.right.intro.intro.intro
X : ExtrDisc
S : Sieve X
Y : ExtrDisc
T : Presieve Y
hT : T ∈ ExtensiveSieve Y ∪ RegularSieve Y
Z : ExtrDisc
f : Z ⟶ Y
h : (T = ofArrows (fun x => Z) fun x => f) ∧ Function.Surjective ↑f
he : (EffectiveEpiFamily (fun x => Z) fun x => f) ↔ Epi (Sigma.desc fun x => f)
x : CoeSort.coe Y
y : CoeSort.coe Z
hy : ↑f y = x
this : ↑f = ↑(Sigma.ι (fun x => Z) () ≫ Sigma.desc fun x => f)
⊢ ↑(Sigma.desc fun x => f) (↑(Sigma.ι (fun x => Z) ()) y) = ↑(Sigma.ι (fun x => Z) () ≫ Sigma.desc fun x => f) y | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case h.h.h.mp.of.hS.right.intro.intro.intro
X : ExtrDisc
S : Sieve X
Y : ExtrDisc
T : Presieve Y
hT : T ∈ ExtensiveSieve Y ∪ RegularSieve Y
Z : ExtrDisc
f : Z ⟶ Y
h : (T = ofArrows (fun x => Z) fun x => f) ∧ Function.Surjective ↑f
he : (EffectiveEpiFamily (fun x => Z) fun x => f) ↔ Epi (Sigma.desc fun x => f)
x : CoeSort.coe Y
y : CoeSort.coe Z
hy : ↑f y = x
this : ↑f = ↑(Sigma.ι (fun x => Z) () ≫ Sigma.desc fun x => f)
⊢ ↑(Sigma.desc fun x => f) (↑(Sigma.ι (fun x => Z) ()) y) = ↑(Sigma.ι (fun x => Z) () ≫ Sigma.desc fun x => f) y
TACTIC:
|
https://github.com/adamtopaz/CopenhagenMasterclass2023.git | a293ca1554f7e80d891fd4d86fb092c54d8a0a01 | ExtrDisc/ExplicitSheaves.lean | ExtrDisc.extensiveRegular_generates_coherent | [108, 1] | [217, 21] | apply Coverage.saturate.top | case h.h.h.mp.top
X : ExtrDisc
S : Sieve X
X✝ : ExtrDisc
⊢ ⊤ ∈ GrothendieckTopology.sieves (coherentTopology ExtrDisc) X✝ | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case h.h.h.mp.top
X : ExtrDisc
S : Sieve X
X✝ : ExtrDisc
⊢ ⊤ ∈ GrothendieckTopology.sieves (coherentTopology ExtrDisc) X✝
TACTIC:
|
https://github.com/adamtopaz/CopenhagenMasterclass2023.git | a293ca1554f7e80d891fd4d86fb092c54d8a0a01 | ExtrDisc/ExplicitSheaves.lean | ExtrDisc.extensiveRegular_generates_coherent | [108, 1] | [217, 21] | apply Coverage.saturate.transitive Y T | case h.h.h.mp.transitive
X : ExtrDisc
S : Sieve X
Y : ExtrDisc
T S✝ : Sieve Y
a✝¹ :
Coverage.saturate
(ExtensiveRegularCoverage ExtrDisc everything_proj
(_ :
∀ {α : Type} [inst : Fintype α] {X : ExtrDisc} {Z : α → ExtrDisc} (π : (a : α) → Z a ⟶ X) {Y : ExtrDisc}
(f : Y ⟶ X) (x : IsIso (Sigma.desc π)), IsIso (Sigma.desc fun x_1 => Limits.pullback.fst)))
Y T
a✝ :
∀ ⦃Y_1 : ExtrDisc⦄ ⦃f : Y_1 ⟶ Y⦄,
T.arrows f →
Coverage.saturate
(ExtensiveRegularCoverage ExtrDisc everything_proj
(_ :
∀ {α : Type} [inst : Fintype α] {X : ExtrDisc} {Z : α → ExtrDisc} (π : (a : α) → Z a ⟶ X) {Y : ExtrDisc}
(f : Y ⟶ X) (x : IsIso (Sigma.desc π)), IsIso (Sigma.desc fun x_1 => Limits.pullback.fst)))
Y_1 (Sieve.pullback f S✝)
a_ih✝¹ : T ∈ GrothendieckTopology.sieves (coherentTopology ExtrDisc) Y
a_ih✝ :
∀ ⦃Y_1 : ExtrDisc⦄ ⦃f : Y_1 ⟶ Y⦄,
T.arrows f → Sieve.pullback f S✝ ∈ GrothendieckTopology.sieves (coherentTopology ExtrDisc) Y_1
⊢ S✝ ∈ GrothendieckTopology.sieves (coherentTopology ExtrDisc) Y | case h.h.h.mp.transitive.a
X : ExtrDisc
S : Sieve X
Y : ExtrDisc
T S✝ : Sieve Y
a✝¹ :
Coverage.saturate
(ExtensiveRegularCoverage ExtrDisc everything_proj
(_ :
∀ {α : Type} [inst : Fintype α] {X : ExtrDisc} {Z : α → ExtrDisc} (π : (a : α) → Z a ⟶ X) {Y : ExtrDisc}
(f : Y ⟶ X) (x : IsIso (Sigma.desc π)), IsIso (Sigma.desc fun x_1 => Limits.pullback.fst)))
Y T
a✝ :
∀ ⦃Y_1 : ExtrDisc⦄ ⦃f : Y_1 ⟶ Y⦄,
T.arrows f →
Coverage.saturate
(ExtensiveRegularCoverage ExtrDisc everything_proj
(_ :
∀ {α : Type} [inst : Fintype α] {X : ExtrDisc} {Z : α → ExtrDisc} (π : (a : α) → Z a ⟶ X) {Y : ExtrDisc}
(f : Y ⟶ X) (x : IsIso (Sigma.desc π)), IsIso (Sigma.desc fun x_1 => Limits.pullback.fst)))
Y_1 (Sieve.pullback f S✝)
a_ih✝¹ : T ∈ GrothendieckTopology.sieves (coherentTopology ExtrDisc) Y
a_ih✝ :
∀ ⦃Y_1 : ExtrDisc⦄ ⦃f : Y_1 ⟶ Y⦄,
T.arrows f → Sieve.pullback f S✝ ∈ GrothendieckTopology.sieves (coherentTopology ExtrDisc) Y_1
⊢ Coverage.saturate (coherentCoverage ExtrDisc) Y T
case h.h.h.mp.transitive.a
X : ExtrDisc
S : Sieve X
Y : ExtrDisc
T S✝ : Sieve Y
a✝¹ :
Coverage.saturate
(ExtensiveRegularCoverage ExtrDisc everything_proj
(_ :
∀ {α : Type} [inst : Fintype α] {X : ExtrDisc} {Z : α → ExtrDisc} (π : (a : α) → Z a ⟶ X) {Y : ExtrDisc}
(f : Y ⟶ X) (x : IsIso (Sigma.desc π)), IsIso (Sigma.desc fun x_1 => Limits.pullback.fst)))
Y T
a✝ :
∀ ⦃Y_1 : ExtrDisc⦄ ⦃f : Y_1 ⟶ Y⦄,
T.arrows f →
Coverage.saturate
(ExtensiveRegularCoverage ExtrDisc everything_proj
(_ :
∀ {α : Type} [inst : Fintype α] {X : ExtrDisc} {Z : α → ExtrDisc} (π : (a : α) → Z a ⟶ X) {Y : ExtrDisc}
(f : Y ⟶ X) (x : IsIso (Sigma.desc π)), IsIso (Sigma.desc fun x_1 => Limits.pullback.fst)))
Y_1 (Sieve.pullback f S✝)
a_ih✝¹ : T ∈ GrothendieckTopology.sieves (coherentTopology ExtrDisc) Y
a_ih✝ :
∀ ⦃Y_1 : ExtrDisc⦄ ⦃f : Y_1 ⟶ Y⦄,
T.arrows f → Sieve.pullback f S✝ ∈ GrothendieckTopology.sieves (coherentTopology ExtrDisc) Y_1
⊢ ∀ ⦃Y_1 : ExtrDisc⦄ ⦃f : Y_1 ⟶ Y⦄, T.arrows f → Coverage.saturate (coherentCoverage ExtrDisc) Y_1 (Sieve.pullback f S✝) | Please generate a tactic in lean4 to solve the state.
STATE:
case h.h.h.mp.transitive
X : ExtrDisc
S : Sieve X
Y : ExtrDisc
T S✝ : Sieve Y
a✝¹ :
Coverage.saturate
(ExtensiveRegularCoverage ExtrDisc everything_proj
(_ :
∀ {α : Type} [inst : Fintype α] {X : ExtrDisc} {Z : α → ExtrDisc} (π : (a : α) → Z a ⟶ X) {Y : ExtrDisc}
(f : Y ⟶ X) (x : IsIso (Sigma.desc π)), IsIso (Sigma.desc fun x_1 => Limits.pullback.fst)))
Y T
a✝ :
∀ ⦃Y_1 : ExtrDisc⦄ ⦃f : Y_1 ⟶ Y⦄,
T.arrows f →
Coverage.saturate
(ExtensiveRegularCoverage ExtrDisc everything_proj
(_ :
∀ {α : Type} [inst : Fintype α] {X : ExtrDisc} {Z : α → ExtrDisc} (π : (a : α) → Z a ⟶ X) {Y : ExtrDisc}
(f : Y ⟶ X) (x : IsIso (Sigma.desc π)), IsIso (Sigma.desc fun x_1 => Limits.pullback.fst)))
Y_1 (Sieve.pullback f S✝)
a_ih✝¹ : T ∈ GrothendieckTopology.sieves (coherentTopology ExtrDisc) Y
a_ih✝ :
∀ ⦃Y_1 : ExtrDisc⦄ ⦃f : Y_1 ⟶ Y⦄,
T.arrows f → Sieve.pullback f S✝ ∈ GrothendieckTopology.sieves (coherentTopology ExtrDisc) Y_1
⊢ S✝ ∈ GrothendieckTopology.sieves (coherentTopology ExtrDisc) Y
TACTIC:
|
https://github.com/adamtopaz/CopenhagenMasterclass2023.git | a293ca1554f7e80d891fd4d86fb092c54d8a0a01 | ExtrDisc/ExplicitSheaves.lean | ExtrDisc.extensiveRegular_generates_coherent | [108, 1] | [217, 21] | assumption | case h.h.h.mp.transitive.a
X : ExtrDisc
S : Sieve X
Y : ExtrDisc
T S✝ : Sieve Y
a✝¹ :
Coverage.saturate
(ExtensiveRegularCoverage ExtrDisc everything_proj
(_ :
∀ {α : Type} [inst : Fintype α] {X : ExtrDisc} {Z : α → ExtrDisc} (π : (a : α) → Z a ⟶ X) {Y : ExtrDisc}
(f : Y ⟶ X) (x : IsIso (Sigma.desc π)), IsIso (Sigma.desc fun x_1 => Limits.pullback.fst)))
Y T
a✝ :
∀ ⦃Y_1 : ExtrDisc⦄ ⦃f : Y_1 ⟶ Y⦄,
T.arrows f →
Coverage.saturate
(ExtensiveRegularCoverage ExtrDisc everything_proj
(_ :
∀ {α : Type} [inst : Fintype α] {X : ExtrDisc} {Z : α → ExtrDisc} (π : (a : α) → Z a ⟶ X) {Y : ExtrDisc}
(f : Y ⟶ X) (x : IsIso (Sigma.desc π)), IsIso (Sigma.desc fun x_1 => Limits.pullback.fst)))
Y_1 (Sieve.pullback f S✝)
a_ih✝¹ : T ∈ GrothendieckTopology.sieves (coherentTopology ExtrDisc) Y
a_ih✝ :
∀ ⦃Y_1 : ExtrDisc⦄ ⦃f : Y_1 ⟶ Y⦄,
T.arrows f → Sieve.pullback f S✝ ∈ GrothendieckTopology.sieves (coherentTopology ExtrDisc) Y_1
⊢ Coverage.saturate (coherentCoverage ExtrDisc) Y T | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case h.h.h.mp.transitive.a
X : ExtrDisc
S : Sieve X
Y : ExtrDisc
T S✝ : Sieve Y
a✝¹ :
Coverage.saturate
(ExtensiveRegularCoverage ExtrDisc everything_proj
(_ :
∀ {α : Type} [inst : Fintype α] {X : ExtrDisc} {Z : α → ExtrDisc} (π : (a : α) → Z a ⟶ X) {Y : ExtrDisc}
(f : Y ⟶ X) (x : IsIso (Sigma.desc π)), IsIso (Sigma.desc fun x_1 => Limits.pullback.fst)))
Y T
a✝ :
∀ ⦃Y_1 : ExtrDisc⦄ ⦃f : Y_1 ⟶ Y⦄,
T.arrows f →
Coverage.saturate
(ExtensiveRegularCoverage ExtrDisc everything_proj
(_ :
∀ {α : Type} [inst : Fintype α] {X : ExtrDisc} {Z : α → ExtrDisc} (π : (a : α) → Z a ⟶ X) {Y : ExtrDisc}
(f : Y ⟶ X) (x : IsIso (Sigma.desc π)), IsIso (Sigma.desc fun x_1 => Limits.pullback.fst)))
Y_1 (Sieve.pullback f S✝)
a_ih✝¹ : T ∈ GrothendieckTopology.sieves (coherentTopology ExtrDisc) Y
a_ih✝ :
∀ ⦃Y_1 : ExtrDisc⦄ ⦃f : Y_1 ⟶ Y⦄,
T.arrows f → Sieve.pullback f S✝ ∈ GrothendieckTopology.sieves (coherentTopology ExtrDisc) Y_1
⊢ Coverage.saturate (coherentCoverage ExtrDisc) Y T
TACTIC:
|
https://github.com/adamtopaz/CopenhagenMasterclass2023.git | a293ca1554f7e80d891fd4d86fb092c54d8a0a01 | ExtrDisc/ExplicitSheaves.lean | ExtrDisc.extensiveRegular_generates_coherent | [108, 1] | [217, 21] | assumption | case h.h.h.mp.transitive.a
X : ExtrDisc
S : Sieve X
Y : ExtrDisc
T S✝ : Sieve Y
a✝¹ :
Coverage.saturate
(ExtensiveRegularCoverage ExtrDisc everything_proj
(_ :
∀ {α : Type} [inst : Fintype α] {X : ExtrDisc} {Z : α → ExtrDisc} (π : (a : α) → Z a ⟶ X) {Y : ExtrDisc}
(f : Y ⟶ X) (x : IsIso (Sigma.desc π)), IsIso (Sigma.desc fun x_1 => Limits.pullback.fst)))
Y T
a✝ :
∀ ⦃Y_1 : ExtrDisc⦄ ⦃f : Y_1 ⟶ Y⦄,
T.arrows f →
Coverage.saturate
(ExtensiveRegularCoverage ExtrDisc everything_proj
(_ :
∀ {α : Type} [inst : Fintype α] {X : ExtrDisc} {Z : α → ExtrDisc} (π : (a : α) → Z a ⟶ X) {Y : ExtrDisc}
(f : Y ⟶ X) (x : IsIso (Sigma.desc π)), IsIso (Sigma.desc fun x_1 => Limits.pullback.fst)))
Y_1 (Sieve.pullback f S✝)
a_ih✝¹ : T ∈ GrothendieckTopology.sieves (coherentTopology ExtrDisc) Y
a_ih✝ :
∀ ⦃Y_1 : ExtrDisc⦄ ⦃f : Y_1 ⟶ Y⦄,
T.arrows f → Sieve.pullback f S✝ ∈ GrothendieckTopology.sieves (coherentTopology ExtrDisc) Y_1
⊢ ∀ ⦃Y_1 : ExtrDisc⦄ ⦃f : Y_1 ⟶ Y⦄, T.arrows f → Coverage.saturate (coherentCoverage ExtrDisc) Y_1 (Sieve.pullback f S✝) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case h.h.h.mp.transitive.a
X : ExtrDisc
S : Sieve X
Y : ExtrDisc
T S✝ : Sieve Y
a✝¹ :
Coverage.saturate
(ExtensiveRegularCoverage ExtrDisc everything_proj
(_ :
∀ {α : Type} [inst : Fintype α] {X : ExtrDisc} {Z : α → ExtrDisc} (π : (a : α) → Z a ⟶ X) {Y : ExtrDisc}
(f : Y ⟶ X) (x : IsIso (Sigma.desc π)), IsIso (Sigma.desc fun x_1 => Limits.pullback.fst)))
Y T
a✝ :
∀ ⦃Y_1 : ExtrDisc⦄ ⦃f : Y_1 ⟶ Y⦄,
T.arrows f →
Coverage.saturate
(ExtensiveRegularCoverage ExtrDisc everything_proj
(_ :
∀ {α : Type} [inst : Fintype α] {X : ExtrDisc} {Z : α → ExtrDisc} (π : (a : α) → Z a ⟶ X) {Y : ExtrDisc}
(f : Y ⟶ X) (x : IsIso (Sigma.desc π)), IsIso (Sigma.desc fun x_1 => Limits.pullback.fst)))
Y_1 (Sieve.pullback f S✝)
a_ih✝¹ : T ∈ GrothendieckTopology.sieves (coherentTopology ExtrDisc) Y
a_ih✝ :
∀ ⦃Y_1 : ExtrDisc⦄ ⦃f : Y_1 ⟶ Y⦄,
T.arrows f → Sieve.pullback f S✝ ∈ GrothendieckTopology.sieves (coherentTopology ExtrDisc) Y_1
⊢ ∀ ⦃Y_1 : ExtrDisc⦄ ⦃f : Y_1 ⟶ Y⦄, T.arrows f → Coverage.saturate (coherentCoverage ExtrDisc) Y_1 (Sieve.pullback f S✝)
TACTIC:
|
https://github.com/adamtopaz/CopenhagenMasterclass2023.git | a293ca1554f7e80d891fd4d86fb092c54d8a0a01 | ExtrDisc/ExplicitSheaves.lean | ExtrDisc.extensiveRegular_generates_coherent | [108, 1] | [217, 21] | dsimp [coherentCoverage] at hT | case h.h.h.mpr.of
X : ExtrDisc
S : Sieve X
Y : ExtrDisc
T : Presieve Y
hT : T ∈ Coverage.covering (coherentCoverage ExtrDisc) Y
⊢ Sieve.generate T ∈
GrothendieckTopology.sieves
(Coverage.toGrothendieck ExtrDisc
(ExtensiveRegularCoverage ExtrDisc everything_proj
(_ :
∀ {α : Type} [inst : Fintype α] {X : ExtrDisc} {Z : α → ExtrDisc} (π : (a : α) → Z a ⟶ X) {Y : ExtrDisc}
(f : Y ⟶ X) (x : IsIso (Sigma.desc π)), IsIso (Sigma.desc fun x_1 => Limits.pullback.fst))))
Y | case h.h.h.mpr.of
X : ExtrDisc
S : Sieve X
Y : ExtrDisc
T : Presieve Y
hT : ∃ α x X π, T = ofArrows X π ∧ EffectiveEpiFamily X π
⊢ Sieve.generate T ∈
GrothendieckTopology.sieves
(Coverage.toGrothendieck ExtrDisc
(ExtensiveRegularCoverage ExtrDisc everything_proj
(_ :
∀ {α : Type} [inst : Fintype α] {X : ExtrDisc} {Z : α → ExtrDisc} (π : (a : α) → Z a ⟶ X) {Y : ExtrDisc}
(f : Y ⟶ X) (x : IsIso (Sigma.desc π)), IsIso (Sigma.desc fun x_1 => Limits.pullback.fst))))
Y | Please generate a tactic in lean4 to solve the state.
STATE:
case h.h.h.mpr.of
X : ExtrDisc
S : Sieve X
Y : ExtrDisc
T : Presieve Y
hT : T ∈ Coverage.covering (coherentCoverage ExtrDisc) Y
⊢ Sieve.generate T ∈
GrothendieckTopology.sieves
(Coverage.toGrothendieck ExtrDisc
(ExtensiveRegularCoverage ExtrDisc everything_proj
(_ :
∀ {α : Type} [inst : Fintype α] {X : ExtrDisc} {Z : α → ExtrDisc} (π : (a : α) → Z a ⟶ X) {Y : ExtrDisc}
(f : Y ⟶ X) (x : IsIso (Sigma.desc π)), IsIso (Sigma.desc fun x_1 => Limits.pullback.fst))))
Y
TACTIC:
|
https://github.com/adamtopaz/CopenhagenMasterclass2023.git | a293ca1554f7e80d891fd4d86fb092c54d8a0a01 | ExtrDisc/ExplicitSheaves.lean | ExtrDisc.extensiveRegular_generates_coherent | [108, 1] | [217, 21] | obtain ⟨I, hI, Xmap, f, ⟨h, hT⟩⟩ := hT | case h.h.h.mpr.of
X : ExtrDisc
S : Sieve X
Y : ExtrDisc
T : Presieve Y
hT : ∃ α x X π, T = ofArrows X π ∧ EffectiveEpiFamily X π
⊢ Sieve.generate T ∈
GrothendieckTopology.sieves
(Coverage.toGrothendieck ExtrDisc
(ExtensiveRegularCoverage ExtrDisc everything_proj
(_ :
∀ {α : Type} [inst : Fintype α] {X : ExtrDisc} {Z : α → ExtrDisc} (π : (a : α) → Z a ⟶ X) {Y : ExtrDisc}
(f : Y ⟶ X) (x : IsIso (Sigma.desc π)), IsIso (Sigma.desc fun x_1 => Limits.pullback.fst))))
Y | case h.h.h.mpr.of.intro.intro.intro.intro.intro
X : ExtrDisc
S : Sieve X
Y : ExtrDisc
T : Presieve Y
I : Type
hI : Fintype I
Xmap : I → ExtrDisc
f : (a : I) → Xmap a ⟶ Y
h : T = ofArrows Xmap f
hT : EffectiveEpiFamily Xmap f
⊢ Sieve.generate T ∈
GrothendieckTopology.sieves
(Coverage.toGrothendieck ExtrDisc
(ExtensiveRegularCoverage ExtrDisc everything_proj
(_ :
∀ {α : Type} [inst : Fintype α] {X : ExtrDisc} {Z : α → ExtrDisc} (π : (a : α) → Z a ⟶ X) {Y : ExtrDisc}
(f : Y ⟶ X) (x : IsIso (Sigma.desc π)), IsIso (Sigma.desc fun x_1 => Limits.pullback.fst))))
Y | Please generate a tactic in lean4 to solve the state.
STATE:
case h.h.h.mpr.of
X : ExtrDisc
S : Sieve X
Y : ExtrDisc
T : Presieve Y
hT : ∃ α x X π, T = ofArrows X π ∧ EffectiveEpiFamily X π
⊢ Sieve.generate T ∈
GrothendieckTopology.sieves
(Coverage.toGrothendieck ExtrDisc
(ExtensiveRegularCoverage ExtrDisc everything_proj
(_ :
∀ {α : Type} [inst : Fintype α] {X : ExtrDisc} {Z : α → ExtrDisc} (π : (a : α) → Z a ⟶ X) {Y : ExtrDisc}
(f : Y ⟶ X) (x : IsIso (Sigma.desc π)), IsIso (Sigma.desc fun x_1 => Limits.pullback.fst))))
Y
TACTIC:
|
https://github.com/adamtopaz/CopenhagenMasterclass2023.git | a293ca1554f7e80d891fd4d86fb092c54d8a0a01 | ExtrDisc/ExplicitSheaves.lean | ExtrDisc.extensiveRegular_generates_coherent | [108, 1] | [217, 21] | have he := (effectiveEpiFamily_tfae Xmap f).out 0 1 | case h.h.h.mpr.of.intro.intro.intro.intro.intro
X : ExtrDisc
S : Sieve X
Y : ExtrDisc
T : Presieve Y
I : Type
hI : Fintype I
Xmap : I → ExtrDisc
f : (a : I) → Xmap a ⟶ Y
h : T = ofArrows Xmap f
hT : EffectiveEpiFamily Xmap f
⊢ Sieve.generate T ∈
GrothendieckTopology.sieves
(Coverage.toGrothendieck ExtrDisc
(ExtensiveRegularCoverage ExtrDisc everything_proj
(_ :
∀ {α : Type} [inst : Fintype α] {X : ExtrDisc} {Z : α → ExtrDisc} (π : (a : α) → Z a ⟶ X) {Y : ExtrDisc}
(f : Y ⟶ X) (x : IsIso (Sigma.desc π)), IsIso (Sigma.desc fun x_1 => Limits.pullback.fst))))
Y | case h.h.h.mpr.of.intro.intro.intro.intro.intro
X : ExtrDisc
S : Sieve X
Y : ExtrDisc
T : Presieve Y
I : Type
hI : Fintype I
Xmap : I → ExtrDisc
f : (a : I) → Xmap a ⟶ Y
h : T = ofArrows Xmap f
hT : EffectiveEpiFamily Xmap f
he : EffectiveEpiFamily Xmap f ↔ Epi (Sigma.desc f)
⊢ Sieve.generate T ∈
GrothendieckTopology.sieves
(Coverage.toGrothendieck ExtrDisc
(ExtensiveRegularCoverage ExtrDisc everything_proj
(_ :
∀ {α : Type} [inst : Fintype α] {X : ExtrDisc} {Z : α → ExtrDisc} (π : (a : α) → Z a ⟶ X) {Y : ExtrDisc}
(f : Y ⟶ X) (x : IsIso (Sigma.desc π)), IsIso (Sigma.desc fun x_1 => Limits.pullback.fst))))
Y | Please generate a tactic in lean4 to solve the state.
STATE:
case h.h.h.mpr.of.intro.intro.intro.intro.intro
X : ExtrDisc
S : Sieve X
Y : ExtrDisc
T : Presieve Y
I : Type
hI : Fintype I
Xmap : I → ExtrDisc
f : (a : I) → Xmap a ⟶ Y
h : T = ofArrows Xmap f
hT : EffectiveEpiFamily Xmap f
⊢ Sieve.generate T ∈
GrothendieckTopology.sieves
(Coverage.toGrothendieck ExtrDisc
(ExtensiveRegularCoverage ExtrDisc everything_proj
(_ :
∀ {α : Type} [inst : Fintype α] {X : ExtrDisc} {Z : α → ExtrDisc} (π : (a : α) → Z a ⟶ X) {Y : ExtrDisc}
(f : Y ⟶ X) (x : IsIso (Sigma.desc π)), IsIso (Sigma.desc fun x_1 => Limits.pullback.fst))))
Y
TACTIC:
|
https://github.com/adamtopaz/CopenhagenMasterclass2023.git | a293ca1554f7e80d891fd4d86fb092c54d8a0a01 | ExtrDisc/ExplicitSheaves.lean | ExtrDisc.extensiveRegular_generates_coherent | [108, 1] | [217, 21] | rw [he] at hT | case h.h.h.mpr.of.intro.intro.intro.intro.intro
X : ExtrDisc
S : Sieve X
Y : ExtrDisc
T : Presieve Y
I : Type
hI : Fintype I
Xmap : I → ExtrDisc
f : (a : I) → Xmap a ⟶ Y
h : T = ofArrows Xmap f
hT : EffectiveEpiFamily Xmap f
he : EffectiveEpiFamily Xmap f ↔ Epi (Sigma.desc f)
⊢ Sieve.generate T ∈
GrothendieckTopology.sieves
(Coverage.toGrothendieck ExtrDisc
(ExtensiveRegularCoverage ExtrDisc everything_proj
(_ :
∀ {α : Type} [inst : Fintype α] {X : ExtrDisc} {Z : α → ExtrDisc} (π : (a : α) → Z a ⟶ X) {Y : ExtrDisc}
(f : Y ⟶ X) (x : IsIso (Sigma.desc π)), IsIso (Sigma.desc fun x_1 => Limits.pullback.fst))))
Y | case h.h.h.mpr.of.intro.intro.intro.intro.intro
X : ExtrDisc
S : Sieve X
Y : ExtrDisc
T : Presieve Y
I : Type
hI : Fintype I
Xmap : I → ExtrDisc
f : (a : I) → Xmap a ⟶ Y
h : T = ofArrows Xmap f
hT : Epi (Sigma.desc f)
he : EffectiveEpiFamily Xmap f ↔ Epi (Sigma.desc f)
⊢ Sieve.generate T ∈
GrothendieckTopology.sieves
(Coverage.toGrothendieck ExtrDisc
(ExtensiveRegularCoverage ExtrDisc everything_proj
(_ :
∀ {α : Type} [inst : Fintype α] {X : ExtrDisc} {Z : α → ExtrDisc} (π : (a : α) → Z a ⟶ X) {Y : ExtrDisc}
(f : Y ⟶ X) (x : IsIso (Sigma.desc π)), IsIso (Sigma.desc fun x_1 => Limits.pullback.fst))))
Y | Please generate a tactic in lean4 to solve the state.
STATE:
case h.h.h.mpr.of.intro.intro.intro.intro.intro
X : ExtrDisc
S : Sieve X
Y : ExtrDisc
T : Presieve Y
I : Type
hI : Fintype I
Xmap : I → ExtrDisc
f : (a : I) → Xmap a ⟶ Y
h : T = ofArrows Xmap f
hT : EffectiveEpiFamily Xmap f
he : EffectiveEpiFamily Xmap f ↔ Epi (Sigma.desc f)
⊢ Sieve.generate T ∈
GrothendieckTopology.sieves
(Coverage.toGrothendieck ExtrDisc
(ExtensiveRegularCoverage ExtrDisc everything_proj
(_ :
∀ {α : Type} [inst : Fintype α] {X : ExtrDisc} {Z : α → ExtrDisc} (π : (a : α) → Z a ⟶ X) {Y : ExtrDisc}
(f : Y ⟶ X) (x : IsIso (Sigma.desc π)), IsIso (Sigma.desc fun x_1 => Limits.pullback.fst))))
Y
TACTIC:
|
https://github.com/adamtopaz/CopenhagenMasterclass2023.git | a293ca1554f7e80d891fd4d86fb092c54d8a0a01 | ExtrDisc/ExplicitSheaves.lean | ExtrDisc.extensiveRegular_generates_coherent | [108, 1] | [217, 21] | let φ := fun (i : I) ↦ Sigma.ι Xmap i | case h.h.h.mpr.of.intro.intro.intro.intro.intro
X : ExtrDisc
S : Sieve X
Y : ExtrDisc
T : Presieve Y
I : Type
hI : Fintype I
Xmap : I → ExtrDisc
f : (a : I) → Xmap a ⟶ Y
h : T = ofArrows Xmap f
hT : Epi (Sigma.desc f)
he : EffectiveEpiFamily Xmap f ↔ Epi (Sigma.desc f)
⊢ Sieve.generate T ∈
GrothendieckTopology.sieves
(Coverage.toGrothendieck ExtrDisc
(ExtensiveRegularCoverage ExtrDisc everything_proj
(_ :
∀ {α : Type} [inst : Fintype α] {X : ExtrDisc} {Z : α → ExtrDisc} (π : (a : α) → Z a ⟶ X) {Y : ExtrDisc}
(f : Y ⟶ X) (x : IsIso (Sigma.desc π)), IsIso (Sigma.desc fun x_1 => Limits.pullback.fst))))
Y | case h.h.h.mpr.of.intro.intro.intro.intro.intro
X : ExtrDisc
S : Sieve X
Y : ExtrDisc
T : Presieve Y
I : Type
hI : Fintype I
Xmap : I → ExtrDisc
f : (a : I) → Xmap a ⟶ Y
h : T = ofArrows Xmap f
hT : Epi (Sigma.desc f)
he : EffectiveEpiFamily Xmap f ↔ Epi (Sigma.desc f)
φ : (i : I) → Xmap i ⟶ ∐ Xmap := fun i => Sigma.ι Xmap i
⊢ Sieve.generate T ∈
GrothendieckTopology.sieves
(Coverage.toGrothendieck ExtrDisc
(ExtensiveRegularCoverage ExtrDisc everything_proj
(_ :
∀ {α : Type} [inst : Fintype α] {X : ExtrDisc} {Z : α → ExtrDisc} (π : (a : α) → Z a ⟶ X) {Y : ExtrDisc}
(f : Y ⟶ X) (x : IsIso (Sigma.desc π)), IsIso (Sigma.desc fun x_1 => Limits.pullback.fst))))
Y | Please generate a tactic in lean4 to solve the state.
STATE:
case h.h.h.mpr.of.intro.intro.intro.intro.intro
X : ExtrDisc
S : Sieve X
Y : ExtrDisc
T : Presieve Y
I : Type
hI : Fintype I
Xmap : I → ExtrDisc
f : (a : I) → Xmap a ⟶ Y
h : T = ofArrows Xmap f
hT : Epi (Sigma.desc f)
he : EffectiveEpiFamily Xmap f ↔ Epi (Sigma.desc f)
⊢ Sieve.generate T ∈
GrothendieckTopology.sieves
(Coverage.toGrothendieck ExtrDisc
(ExtensiveRegularCoverage ExtrDisc everything_proj
(_ :
∀ {α : Type} [inst : Fintype α] {X : ExtrDisc} {Z : α → ExtrDisc} (π : (a : α) → Z a ⟶ X) {Y : ExtrDisc}
(f : Y ⟶ X) (x : IsIso (Sigma.desc π)), IsIso (Sigma.desc fun x_1 => Limits.pullback.fst))))
Y
TACTIC:
|
https://github.com/adamtopaz/CopenhagenMasterclass2023.git | a293ca1554f7e80d891fd4d86fb092c54d8a0a01 | ExtrDisc/ExplicitSheaves.lean | ExtrDisc.extensiveRegular_generates_coherent | [108, 1] | [217, 21] | let F := Sigma.desc f | case h.h.h.mpr.of.intro.intro.intro.intro.intro
X : ExtrDisc
S : Sieve X
Y : ExtrDisc
T : Presieve Y
I : Type
hI : Fintype I
Xmap : I → ExtrDisc
f : (a : I) → Xmap a ⟶ Y
h : T = ofArrows Xmap f
hT : Epi (Sigma.desc f)
he : EffectiveEpiFamily Xmap f ↔ Epi (Sigma.desc f)
φ : (i : I) → Xmap i ⟶ ∐ Xmap := fun i => Sigma.ι Xmap i
⊢ Sieve.generate T ∈
GrothendieckTopology.sieves
(Coverage.toGrothendieck ExtrDisc
(ExtensiveRegularCoverage ExtrDisc everything_proj
(_ :
∀ {α : Type} [inst : Fintype α] {X : ExtrDisc} {Z : α → ExtrDisc} (π : (a : α) → Z a ⟶ X) {Y : ExtrDisc}
(f : Y ⟶ X) (x : IsIso (Sigma.desc π)), IsIso (Sigma.desc fun x_1 => Limits.pullback.fst))))
Y | case h.h.h.mpr.of.intro.intro.intro.intro.intro
X : ExtrDisc
S : Sieve X
Y : ExtrDisc
T : Presieve Y
I : Type
hI : Fintype I
Xmap : I → ExtrDisc
f : (a : I) → Xmap a ⟶ Y
h : T = ofArrows Xmap f
hT : Epi (Sigma.desc f)
he : EffectiveEpiFamily Xmap f ↔ Epi (Sigma.desc f)
φ : (i : I) → Xmap i ⟶ ∐ Xmap := fun i => Sigma.ι Xmap i
F : (∐ fun b => Xmap b) ⟶ Y := Sigma.desc f
⊢ Sieve.generate T ∈
GrothendieckTopology.sieves
(Coverage.toGrothendieck ExtrDisc
(ExtensiveRegularCoverage ExtrDisc everything_proj
(_ :
∀ {α : Type} [inst : Fintype α] {X : ExtrDisc} {Z : α → ExtrDisc} (π : (a : α) → Z a ⟶ X) {Y : ExtrDisc}
(f : Y ⟶ X) (x : IsIso (Sigma.desc π)), IsIso (Sigma.desc fun x_1 => Limits.pullback.fst))))
Y | Please generate a tactic in lean4 to solve the state.
STATE:
case h.h.h.mpr.of.intro.intro.intro.intro.intro
X : ExtrDisc
S : Sieve X
Y : ExtrDisc
T : Presieve Y
I : Type
hI : Fintype I
Xmap : I → ExtrDisc
f : (a : I) → Xmap a ⟶ Y
h : T = ofArrows Xmap f
hT : Epi (Sigma.desc f)
he : EffectiveEpiFamily Xmap f ↔ Epi (Sigma.desc f)
φ : (i : I) → Xmap i ⟶ ∐ Xmap := fun i => Sigma.ι Xmap i
⊢ Sieve.generate T ∈
GrothendieckTopology.sieves
(Coverage.toGrothendieck ExtrDisc
(ExtensiveRegularCoverage ExtrDisc everything_proj
(_ :
∀ {α : Type} [inst : Fintype α] {X : ExtrDisc} {Z : α → ExtrDisc} (π : (a : α) → Z a ⟶ X) {Y : ExtrDisc}
(f : Y ⟶ X) (x : IsIso (Sigma.desc π)), IsIso (Sigma.desc fun x_1 => Limits.pullback.fst))))
Y
TACTIC:
|
https://github.com/adamtopaz/CopenhagenMasterclass2023.git | a293ca1554f7e80d891fd4d86fb092c54d8a0a01 | ExtrDisc/ExplicitSheaves.lean | ExtrDisc.extensiveRegular_generates_coherent | [108, 1] | [217, 21] | let Z := Sieve.generate T | case h.h.h.mpr.of.intro.intro.intro.intro.intro
X : ExtrDisc
S : Sieve X
Y : ExtrDisc
T : Presieve Y
I : Type
hI : Fintype I
Xmap : I → ExtrDisc
f : (a : I) → Xmap a ⟶ Y
h : T = ofArrows Xmap f
hT : Epi (Sigma.desc f)
he : EffectiveEpiFamily Xmap f ↔ Epi (Sigma.desc f)
φ : (i : I) → Xmap i ⟶ ∐ Xmap := fun i => Sigma.ι Xmap i
F : (∐ fun b => Xmap b) ⟶ Y := Sigma.desc f
⊢ Sieve.generate T ∈
GrothendieckTopology.sieves
(Coverage.toGrothendieck ExtrDisc
(ExtensiveRegularCoverage ExtrDisc everything_proj
(_ :
∀ {α : Type} [inst : Fintype α] {X : ExtrDisc} {Z : α → ExtrDisc} (π : (a : α) → Z a ⟶ X) {Y : ExtrDisc}
(f : Y ⟶ X) (x : IsIso (Sigma.desc π)), IsIso (Sigma.desc fun x_1 => Limits.pullback.fst))))
Y | case h.h.h.mpr.of.intro.intro.intro.intro.intro
X : ExtrDisc
S : Sieve X
Y : ExtrDisc
T : Presieve Y
I : Type
hI : Fintype I
Xmap : I → ExtrDisc
f : (a : I) → Xmap a ⟶ Y
h : T = ofArrows Xmap f
hT : Epi (Sigma.desc f)
he : EffectiveEpiFamily Xmap f ↔ Epi (Sigma.desc f)
φ : (i : I) → Xmap i ⟶ ∐ Xmap := fun i => Sigma.ι Xmap i
F : (∐ fun b => Xmap b) ⟶ Y := Sigma.desc f
Z : Sieve Y := Sieve.generate T
⊢ Sieve.generate T ∈
GrothendieckTopology.sieves
(Coverage.toGrothendieck ExtrDisc
(ExtensiveRegularCoverage ExtrDisc everything_proj
(_ :
∀ {α : Type} [inst : Fintype α] {X : ExtrDisc} {Z : α → ExtrDisc} (π : (a : α) → Z a ⟶ X) {Y : ExtrDisc}
(f : Y ⟶ X) (x : IsIso (Sigma.desc π)), IsIso (Sigma.desc fun x_1 => Limits.pullback.fst))))
Y | Please generate a tactic in lean4 to solve the state.
STATE:
case h.h.h.mpr.of.intro.intro.intro.intro.intro
X : ExtrDisc
S : Sieve X
Y : ExtrDisc
T : Presieve Y
I : Type
hI : Fintype I
Xmap : I → ExtrDisc
f : (a : I) → Xmap a ⟶ Y
h : T = ofArrows Xmap f
hT : Epi (Sigma.desc f)
he : EffectiveEpiFamily Xmap f ↔ Epi (Sigma.desc f)
φ : (i : I) → Xmap i ⟶ ∐ Xmap := fun i => Sigma.ι Xmap i
F : (∐ fun b => Xmap b) ⟶ Y := Sigma.desc f
⊢ Sieve.generate T ∈
GrothendieckTopology.sieves
(Coverage.toGrothendieck ExtrDisc
(ExtensiveRegularCoverage ExtrDisc everything_proj
(_ :
∀ {α : Type} [inst : Fintype α] {X : ExtrDisc} {Z : α → ExtrDisc} (π : (a : α) → Z a ⟶ X) {Y : ExtrDisc}
(f : Y ⟶ X) (x : IsIso (Sigma.desc π)), IsIso (Sigma.desc fun x_1 => Limits.pullback.fst))))
Y
TACTIC:
|
https://github.com/adamtopaz/CopenhagenMasterclass2023.git | a293ca1554f7e80d891fd4d86fb092c54d8a0a01 | ExtrDisc/ExplicitSheaves.lean | ExtrDisc.extensiveRegular_generates_coherent | [108, 1] | [217, 21] | let Xs := (∐ fun (i : I) => Xmap i) | case h.h.h.mpr.of.intro.intro.intro.intro.intro
X : ExtrDisc
S : Sieve X
Y : ExtrDisc
T : Presieve Y
I : Type
hI : Fintype I
Xmap : I → ExtrDisc
f : (a : I) → Xmap a ⟶ Y
h : T = ofArrows Xmap f
hT : Epi (Sigma.desc f)
he : EffectiveEpiFamily Xmap f ↔ Epi (Sigma.desc f)
φ : (i : I) → Xmap i ⟶ ∐ Xmap := fun i => Sigma.ι Xmap i
F : (∐ fun b => Xmap b) ⟶ Y := Sigma.desc f
Z : Sieve Y := Sieve.generate T
⊢ Sieve.generate T ∈
GrothendieckTopology.sieves
(Coverage.toGrothendieck ExtrDisc
(ExtensiveRegularCoverage ExtrDisc everything_proj
(_ :
∀ {α : Type} [inst : Fintype α] {X : ExtrDisc} {Z : α → ExtrDisc} (π : (a : α) → Z a ⟶ X) {Y : ExtrDisc}
(f : Y ⟶ X) (x : IsIso (Sigma.desc π)), IsIso (Sigma.desc fun x_1 => Limits.pullback.fst))))
Y | case h.h.h.mpr.of.intro.intro.intro.intro.intro
X : ExtrDisc
S : Sieve X
Y : ExtrDisc
T : Presieve Y
I : Type
hI : Fintype I
Xmap : I → ExtrDisc
f : (a : I) → Xmap a ⟶ Y
h : T = ofArrows Xmap f
hT : Epi (Sigma.desc f)
he : EffectiveEpiFamily Xmap f ↔ Epi (Sigma.desc f)
φ : (i : I) → Xmap i ⟶ ∐ Xmap := fun i => Sigma.ι Xmap i
F : (∐ fun b => Xmap b) ⟶ Y := Sigma.desc f
Z : Sieve Y := Sieve.generate T
Xs : ExtrDisc := ∐ fun i => Xmap i
⊢ Sieve.generate T ∈
GrothendieckTopology.sieves
(Coverage.toGrothendieck ExtrDisc
(ExtensiveRegularCoverage ExtrDisc everything_proj
(_ :
∀ {α : Type} [inst : Fintype α] {X : ExtrDisc} {Z : α → ExtrDisc} (π : (a : α) → Z a ⟶ X) {Y : ExtrDisc}
(f : Y ⟶ X) (x : IsIso (Sigma.desc π)), IsIso (Sigma.desc fun x_1 => Limits.pullback.fst))))
Y | Please generate a tactic in lean4 to solve the state.
STATE:
case h.h.h.mpr.of.intro.intro.intro.intro.intro
X : ExtrDisc
S : Sieve X
Y : ExtrDisc
T : Presieve Y
I : Type
hI : Fintype I
Xmap : I → ExtrDisc
f : (a : I) → Xmap a ⟶ Y
h : T = ofArrows Xmap f
hT : Epi (Sigma.desc f)
he : EffectiveEpiFamily Xmap f ↔ Epi (Sigma.desc f)
φ : (i : I) → Xmap i ⟶ ∐ Xmap := fun i => Sigma.ι Xmap i
F : (∐ fun b => Xmap b) ⟶ Y := Sigma.desc f
Z : Sieve Y := Sieve.generate T
⊢ Sieve.generate T ∈
GrothendieckTopology.sieves
(Coverage.toGrothendieck ExtrDisc
(ExtensiveRegularCoverage ExtrDisc everything_proj
(_ :
∀ {α : Type} [inst : Fintype α] {X : ExtrDisc} {Z : α → ExtrDisc} (π : (a : α) → Z a ⟶ X) {Y : ExtrDisc}
(f : Y ⟶ X) (x : IsIso (Sigma.desc π)), IsIso (Sigma.desc fun x_1 => Limits.pullback.fst))))
Y
TACTIC:
|
https://github.com/adamtopaz/CopenhagenMasterclass2023.git | a293ca1554f7e80d891fd4d86fb092c54d8a0a01 | ExtrDisc/ExplicitSheaves.lean | ExtrDisc.extensiveRegular_generates_coherent | [108, 1] | [217, 21] | let Zf : Sieve Y := Sieve.generate
(Presieve.ofArrows (fun (_ : Unit) ↦ Xs) (fun (_ : Unit) ↦ F)) | case h.h.h.mpr.of.intro.intro.intro.intro.intro
X : ExtrDisc
S : Sieve X
Y : ExtrDisc
T : Presieve Y
I : Type
hI : Fintype I
Xmap : I → ExtrDisc
f : (a : I) → Xmap a ⟶ Y
h : T = ofArrows Xmap f
hT : Epi (Sigma.desc f)
he : EffectiveEpiFamily Xmap f ↔ Epi (Sigma.desc f)
φ : (i : I) → Xmap i ⟶ ∐ Xmap := fun i => Sigma.ι Xmap i
F : (∐ fun b => Xmap b) ⟶ Y := Sigma.desc f
Z : Sieve Y := Sieve.generate T
Xs : ExtrDisc := ∐ fun i => Xmap i
⊢ Sieve.generate T ∈
GrothendieckTopology.sieves
(Coverage.toGrothendieck ExtrDisc
(ExtensiveRegularCoverage ExtrDisc everything_proj
(_ :
∀ {α : Type} [inst : Fintype α] {X : ExtrDisc} {Z : α → ExtrDisc} (π : (a : α) → Z a ⟶ X) {Y : ExtrDisc}
(f : Y ⟶ X) (x : IsIso (Sigma.desc π)), IsIso (Sigma.desc fun x_1 => Limits.pullback.fst))))
Y | case h.h.h.mpr.of.intro.intro.intro.intro.intro
X : ExtrDisc
S : Sieve X
Y : ExtrDisc
T : Presieve Y
I : Type
hI : Fintype I
Xmap : I → ExtrDisc
f : (a : I) → Xmap a ⟶ Y
h : T = ofArrows Xmap f
hT : Epi (Sigma.desc f)
he : EffectiveEpiFamily Xmap f ↔ Epi (Sigma.desc f)
φ : (i : I) → Xmap i ⟶ ∐ Xmap := fun i => Sigma.ι Xmap i
F : (∐ fun b => Xmap b) ⟶ Y := Sigma.desc f
Z : Sieve Y := Sieve.generate T
Xs : ExtrDisc := ∐ fun i => Xmap i
Zf : Sieve Y := Sieve.generate (ofArrows (fun x => Xs) fun x => F)
⊢ Sieve.generate T ∈
GrothendieckTopology.sieves
(Coverage.toGrothendieck ExtrDisc
(ExtensiveRegularCoverage ExtrDisc everything_proj
(_ :
∀ {α : Type} [inst : Fintype α] {X : ExtrDisc} {Z : α → ExtrDisc} (π : (a : α) → Z a ⟶ X) {Y : ExtrDisc}
(f : Y ⟶ X) (x : IsIso (Sigma.desc π)), IsIso (Sigma.desc fun x_1 => Limits.pullback.fst))))
Y | Please generate a tactic in lean4 to solve the state.
STATE:
case h.h.h.mpr.of.intro.intro.intro.intro.intro
X : ExtrDisc
S : Sieve X
Y : ExtrDisc
T : Presieve Y
I : Type
hI : Fintype I
Xmap : I → ExtrDisc
f : (a : I) → Xmap a ⟶ Y
h : T = ofArrows Xmap f
hT : Epi (Sigma.desc f)
he : EffectiveEpiFamily Xmap f ↔ Epi (Sigma.desc f)
φ : (i : I) → Xmap i ⟶ ∐ Xmap := fun i => Sigma.ι Xmap i
F : (∐ fun b => Xmap b) ⟶ Y := Sigma.desc f
Z : Sieve Y := Sieve.generate T
Xs : ExtrDisc := ∐ fun i => Xmap i
⊢ Sieve.generate T ∈
GrothendieckTopology.sieves
(Coverage.toGrothendieck ExtrDisc
(ExtensiveRegularCoverage ExtrDisc everything_proj
(_ :
∀ {α : Type} [inst : Fintype α] {X : ExtrDisc} {Z : α → ExtrDisc} (π : (a : α) → Z a ⟶ X) {Y : ExtrDisc}
(f : Y ⟶ X) (x : IsIso (Sigma.desc π)), IsIso (Sigma.desc fun x_1 => Limits.pullback.fst))))
Y
TACTIC:
|
https://github.com/adamtopaz/CopenhagenMasterclass2023.git | a293ca1554f7e80d891fd4d86fb092c54d8a0a01 | ExtrDisc/ExplicitSheaves.lean | ExtrDisc.extensiveRegular_generates_coherent | [108, 1] | [217, 21] | apply Coverage.saturate.transitive Y Zf | case h.h.h.mpr.of.intro.intro.intro.intro.intro
X : ExtrDisc
S : Sieve X
Y : ExtrDisc
T : Presieve Y
I : Type
hI : Fintype I
Xmap : I → ExtrDisc
f : (a : I) → Xmap a ⟶ Y
h : T = ofArrows Xmap f
hT : Epi (Sigma.desc f)
he : EffectiveEpiFamily Xmap f ↔ Epi (Sigma.desc f)
φ : (i : I) → Xmap i ⟶ ∐ Xmap := fun i => Sigma.ι Xmap i
F : (∐ fun b => Xmap b) ⟶ Y := Sigma.desc f
Z : Sieve Y := Sieve.generate T
Xs : ExtrDisc := ∐ fun i => Xmap i
Zf : Sieve Y := Sieve.generate (ofArrows (fun x => Xs) fun x => F)
⊢ Sieve.generate T ∈
GrothendieckTopology.sieves
(Coverage.toGrothendieck ExtrDisc
(ExtensiveRegularCoverage ExtrDisc everything_proj
(_ :
∀ {α : Type} [inst : Fintype α] {X : ExtrDisc} {Z : α → ExtrDisc} (π : (a : α) → Z a ⟶ X) {Y : ExtrDisc}
(f : Y ⟶ X) (x : IsIso (Sigma.desc π)), IsIso (Sigma.desc fun x_1 => Limits.pullback.fst))))
Y | case h.h.h.mpr.of.intro.intro.intro.intro.intro.a
X : ExtrDisc
S : Sieve X
Y : ExtrDisc
T : Presieve Y
I : Type
hI : Fintype I
Xmap : I → ExtrDisc
f : (a : I) → Xmap a ⟶ Y
h : T = ofArrows Xmap f
hT : Epi (Sigma.desc f)
he : EffectiveEpiFamily Xmap f ↔ Epi (Sigma.desc f)
φ : (i : I) → Xmap i ⟶ ∐ Xmap := fun i => Sigma.ι Xmap i
F : (∐ fun b => Xmap b) ⟶ Y := Sigma.desc f
Z : Sieve Y := Sieve.generate T
Xs : ExtrDisc := ∐ fun i => Xmap i
Zf : Sieve Y := Sieve.generate (ofArrows (fun x => Xs) fun x => F)
⊢ Coverage.saturate
(ExtensiveRegularCoverage ExtrDisc everything_proj
(_ :
∀ {α : Type} [inst : Fintype α] {X : ExtrDisc} {Z : α → ExtrDisc} (π : (a : α) → Z a ⟶ X) {Y : ExtrDisc}
(f : Y ⟶ X) (x : IsIso (Sigma.desc π)), IsIso (Sigma.desc fun x_1 => Limits.pullback.fst)))
Y Zf
case h.h.h.mpr.of.intro.intro.intro.intro.intro.a
X : ExtrDisc
S : Sieve X
Y : ExtrDisc
T : Presieve Y
I : Type
hI : Fintype I
Xmap : I → ExtrDisc
f : (a : I) → Xmap a ⟶ Y
h : T = ofArrows Xmap f
hT : Epi (Sigma.desc f)
he : EffectiveEpiFamily Xmap f ↔ Epi (Sigma.desc f)
φ : (i : I) → Xmap i ⟶ ∐ Xmap := fun i => Sigma.ι Xmap i
F : (∐ fun b => Xmap b) ⟶ Y := Sigma.desc f
Z : Sieve Y := Sieve.generate T
Xs : ExtrDisc := ∐ fun i => Xmap i
Zf : Sieve Y := Sieve.generate (ofArrows (fun x => Xs) fun x => F)
⊢ ∀ ⦃Y_1 : ExtrDisc⦄ ⦃f : Y_1 ⟶ Y⦄,
Zf.arrows f →
Coverage.saturate
(ExtensiveRegularCoverage ExtrDisc everything_proj
(_ :
∀ {α : Type} [inst : Fintype α] {X : ExtrDisc} {Z : α → ExtrDisc} (π : (a : α) → Z a ⟶ X) {Y : ExtrDisc}
(f : Y ⟶ X) (x : IsIso (Sigma.desc π)), IsIso (Sigma.desc fun x_1 => Limits.pullback.fst)))
Y_1 (Sieve.pullback f (Sieve.generate T)) | Please generate a tactic in lean4 to solve the state.
STATE:
case h.h.h.mpr.of.intro.intro.intro.intro.intro
X : ExtrDisc
S : Sieve X
Y : ExtrDisc
T : Presieve Y
I : Type
hI : Fintype I
Xmap : I → ExtrDisc
f : (a : I) → Xmap a ⟶ Y
h : T = ofArrows Xmap f
hT : Epi (Sigma.desc f)
he : EffectiveEpiFamily Xmap f ↔ Epi (Sigma.desc f)
φ : (i : I) → Xmap i ⟶ ∐ Xmap := fun i => Sigma.ι Xmap i
F : (∐ fun b => Xmap b) ⟶ Y := Sigma.desc f
Z : Sieve Y := Sieve.generate T
Xs : ExtrDisc := ∐ fun i => Xmap i
Zf : Sieve Y := Sieve.generate (ofArrows (fun x => Xs) fun x => F)
⊢ Sieve.generate T ∈
GrothendieckTopology.sieves
(Coverage.toGrothendieck ExtrDisc
(ExtensiveRegularCoverage ExtrDisc everything_proj
(_ :
∀ {α : Type} [inst : Fintype α] {X : ExtrDisc} {Z : α → ExtrDisc} (π : (a : α) → Z a ⟶ X) {Y : ExtrDisc}
(f : Y ⟶ X) (x : IsIso (Sigma.desc π)), IsIso (Sigma.desc fun x_1 => Limits.pullback.fst))))
Y
TACTIC:
|
https://github.com/adamtopaz/CopenhagenMasterclass2023.git | a293ca1554f7e80d891fd4d86fb092c54d8a0a01 | ExtrDisc/ExplicitSheaves.lean | ExtrDisc.extensiveRegular_generates_coherent | [108, 1] | [217, 21] | apply Coverage.saturate.of | case h.h.h.mpr.of.intro.intro.intro.intro.intro.a
X : ExtrDisc
S : Sieve X
Y : ExtrDisc
T : Presieve Y
I : Type
hI : Fintype I
Xmap : I → ExtrDisc
f : (a : I) → Xmap a ⟶ Y
h : T = ofArrows Xmap f
hT : Epi (Sigma.desc f)
he : EffectiveEpiFamily Xmap f ↔ Epi (Sigma.desc f)
φ : (i : I) → Xmap i ⟶ ∐ Xmap := fun i => Sigma.ι Xmap i
F : (∐ fun b => Xmap b) ⟶ Y := Sigma.desc f
Z : Sieve Y := Sieve.generate T
Xs : ExtrDisc := ∐ fun i => Xmap i
Zf : Sieve Y := Sieve.generate (ofArrows (fun x => Xs) fun x => F)
⊢ Coverage.saturate
(ExtensiveRegularCoverage ExtrDisc everything_proj
(_ :
∀ {α : Type} [inst : Fintype α] {X : ExtrDisc} {Z : α → ExtrDisc} (π : (a : α) → Z a ⟶ X) {Y : ExtrDisc}
(f : Y ⟶ X) (x : IsIso (Sigma.desc π)), IsIso (Sigma.desc fun x_1 => Limits.pullback.fst)))
Y Zf | case h.h.h.mpr.of.intro.intro.intro.intro.intro.a.hS
X : ExtrDisc
S : Sieve X
Y : ExtrDisc
T : Presieve Y
I : Type
hI : Fintype I
Xmap : I → ExtrDisc
f : (a : I) → Xmap a ⟶ Y
h : T = ofArrows Xmap f
hT : Epi (Sigma.desc f)
he : EffectiveEpiFamily Xmap f ↔ Epi (Sigma.desc f)
φ : (i : I) → Xmap i ⟶ ∐ Xmap := fun i => Sigma.ι Xmap i
F : (∐ fun b => Xmap b) ⟶ Y := Sigma.desc f
Z : Sieve Y := Sieve.generate T
Xs : ExtrDisc := ∐ fun i => Xmap i
Zf : Sieve Y := Sieve.generate (ofArrows (fun x => Xs) fun x => F)
⊢ (ofArrows (fun x => Xs) fun x => F) ∈
Coverage.covering
(ExtensiveRegularCoverage ExtrDisc everything_proj
(_ :
∀ {α : Type} [inst : Fintype α] {X : ExtrDisc} {Z : α → ExtrDisc} (π : (a : α) → Z a ⟶ X) {Y : ExtrDisc}
(f : Y ⟶ X) (x : IsIso (Sigma.desc π)), IsIso (Sigma.desc fun x_1 => Limits.pullback.fst)))
Y | Please generate a tactic in lean4 to solve the state.
STATE:
case h.h.h.mpr.of.intro.intro.intro.intro.intro.a
X : ExtrDisc
S : Sieve X
Y : ExtrDisc
T : Presieve Y
I : Type
hI : Fintype I
Xmap : I → ExtrDisc
f : (a : I) → Xmap a ⟶ Y
h : T = ofArrows Xmap f
hT : Epi (Sigma.desc f)
he : EffectiveEpiFamily Xmap f ↔ Epi (Sigma.desc f)
φ : (i : I) → Xmap i ⟶ ∐ Xmap := fun i => Sigma.ι Xmap i
F : (∐ fun b => Xmap b) ⟶ Y := Sigma.desc f
Z : Sieve Y := Sieve.generate T
Xs : ExtrDisc := ∐ fun i => Xmap i
Zf : Sieve Y := Sieve.generate (ofArrows (fun x => Xs) fun x => F)
⊢ Coverage.saturate
(ExtensiveRegularCoverage ExtrDisc everything_proj
(_ :
∀ {α : Type} [inst : Fintype α] {X : ExtrDisc} {Z : α → ExtrDisc} (π : (a : α) → Z a ⟶ X) {Y : ExtrDisc}
(f : Y ⟶ X) (x : IsIso (Sigma.desc π)), IsIso (Sigma.desc fun x_1 => Limits.pullback.fst)))
Y Zf
TACTIC:
|
https://github.com/adamtopaz/CopenhagenMasterclass2023.git | a293ca1554f7e80d891fd4d86fb092c54d8a0a01 | ExtrDisc/ExplicitSheaves.lean | ExtrDisc.extensiveRegular_generates_coherent | [108, 1] | [217, 21] | dsimp [ExtensiveRegularCoverage] | case h.h.h.mpr.of.intro.intro.intro.intro.intro.a.hS
X : ExtrDisc
S : Sieve X
Y : ExtrDisc
T : Presieve Y
I : Type
hI : Fintype I
Xmap : I → ExtrDisc
f : (a : I) → Xmap a ⟶ Y
h : T = ofArrows Xmap f
hT : Epi (Sigma.desc f)
he : EffectiveEpiFamily Xmap f ↔ Epi (Sigma.desc f)
φ : (i : I) → Xmap i ⟶ ∐ Xmap := fun i => Sigma.ι Xmap i
F : (∐ fun b => Xmap b) ⟶ Y := Sigma.desc f
Z : Sieve Y := Sieve.generate T
Xs : ExtrDisc := ∐ fun i => Xmap i
Zf : Sieve Y := Sieve.generate (ofArrows (fun x => Xs) fun x => F)
⊢ (ofArrows (fun x => Xs) fun x => F) ∈
Coverage.covering
(ExtensiveRegularCoverage ExtrDisc everything_proj
(_ :
∀ {α : Type} [inst : Fintype α] {X : ExtrDisc} {Z : α → ExtrDisc} (π : (a : α) → Z a ⟶ X) {Y : ExtrDisc}
(f : Y ⟶ X) (x : IsIso (Sigma.desc π)), IsIso (Sigma.desc fun x_1 => Limits.pullback.fst)))
Y | case h.h.h.mpr.of.intro.intro.intro.intro.intro.a.hS
X : ExtrDisc
S : Sieve X
Y : ExtrDisc
T : Presieve Y
I : Type
hI : Fintype I
Xmap : I → ExtrDisc
f : (a : I) → Xmap a ⟶ Y
h : T = ofArrows Xmap f
hT : Epi (Sigma.desc f)
he : EffectiveEpiFamily Xmap f ↔ Epi (Sigma.desc f)
φ : (i : I) → Xmap i ⟶ ∐ Xmap := fun i => Sigma.ι Xmap i
F : (∐ fun b => Xmap b) ⟶ Y := Sigma.desc f
Z : Sieve Y := Sieve.generate T
Xs : ExtrDisc := ∐ fun i => Xmap i
Zf : Sieve Y := Sieve.generate (ofArrows (fun x => Xs) fun x => F)
⊢ (ofArrows (fun x => ∐ fun i => Xmap i) fun x => Sigma.desc f) ∈ ExtensiveSieve Y ∪ RegularSieve Y | Please generate a tactic in lean4 to solve the state.
STATE:
case h.h.h.mpr.of.intro.intro.intro.intro.intro.a.hS
X : ExtrDisc
S : Sieve X
Y : ExtrDisc
T : Presieve Y
I : Type
hI : Fintype I
Xmap : I → ExtrDisc
f : (a : I) → Xmap a ⟶ Y
h : T = ofArrows Xmap f
hT : Epi (Sigma.desc f)
he : EffectiveEpiFamily Xmap f ↔ Epi (Sigma.desc f)
φ : (i : I) → Xmap i ⟶ ∐ Xmap := fun i => Sigma.ι Xmap i
F : (∐ fun b => Xmap b) ⟶ Y := Sigma.desc f
Z : Sieve Y := Sieve.generate T
Xs : ExtrDisc := ∐ fun i => Xmap i
Zf : Sieve Y := Sieve.generate (ofArrows (fun x => Xs) fun x => F)
⊢ (ofArrows (fun x => Xs) fun x => F) ∈
Coverage.covering
(ExtensiveRegularCoverage ExtrDisc everything_proj
(_ :
∀ {α : Type} [inst : Fintype α] {X : ExtrDisc} {Z : α → ExtrDisc} (π : (a : α) → Z a ⟶ X) {Y : ExtrDisc}
(f : Y ⟶ X) (x : IsIso (Sigma.desc π)), IsIso (Sigma.desc fun x_1 => Limits.pullback.fst)))
Y
TACTIC:
|
https://github.com/adamtopaz/CopenhagenMasterclass2023.git | a293ca1554f7e80d891fd4d86fb092c54d8a0a01 | ExtrDisc/ExplicitSheaves.lean | ExtrDisc.extensiveRegular_generates_coherent | [108, 1] | [217, 21] | simp only [Set.mem_union, Set.mem_setOf_eq] | case h.h.h.mpr.of.intro.intro.intro.intro.intro.a.hS
X : ExtrDisc
S : Sieve X
Y : ExtrDisc
T : Presieve Y
I : Type
hI : Fintype I
Xmap : I → ExtrDisc
f : (a : I) → Xmap a ⟶ Y
h : T = ofArrows Xmap f
hT : Epi (Sigma.desc f)
he : EffectiveEpiFamily Xmap f ↔ Epi (Sigma.desc f)
φ : (i : I) → Xmap i ⟶ ∐ Xmap := fun i => Sigma.ι Xmap i
F : (∐ fun b => Xmap b) ⟶ Y := Sigma.desc f
Z : Sieve Y := Sieve.generate T
Xs : ExtrDisc := ∐ fun i => Xmap i
Zf : Sieve Y := Sieve.generate (ofArrows (fun x => Xs) fun x => F)
⊢ (ofArrows (fun x => ∐ fun i => Xmap i) fun x => Sigma.desc f) ∈ ExtensiveSieve Y ∪ RegularSieve Y | case h.h.h.mpr.of.intro.intro.intro.intro.intro.a.hS
X : ExtrDisc
S : Sieve X
Y : ExtrDisc
T : Presieve Y
I : Type
hI : Fintype I
Xmap : I → ExtrDisc
f : (a : I) → Xmap a ⟶ Y
h : T = ofArrows Xmap f
hT : Epi (Sigma.desc f)
he : EffectiveEpiFamily Xmap f ↔ Epi (Sigma.desc f)
φ : (i : I) → Xmap i ⟶ ∐ Xmap := fun i => Sigma.ι Xmap i
F : (∐ fun b => Xmap b) ⟶ Y := Sigma.desc f
Z : Sieve Y := Sieve.generate T
Xs : ExtrDisc := ∐ fun i => Xmap i
Zf : Sieve Y := Sieve.generate (ofArrows (fun x => Xs) fun x => F)
⊢ (ofArrows (fun x => ∐ fun i => Xmap i) fun x => Sigma.desc f) ∈ ExtensiveSieve Y ∨
(ofArrows (fun x => ∐ fun i => Xmap i) fun x => Sigma.desc f) ∈ RegularSieve Y | Please generate a tactic in lean4 to solve the state.
STATE:
case h.h.h.mpr.of.intro.intro.intro.intro.intro.a.hS
X : ExtrDisc
S : Sieve X
Y : ExtrDisc
T : Presieve Y
I : Type
hI : Fintype I
Xmap : I → ExtrDisc
f : (a : I) → Xmap a ⟶ Y
h : T = ofArrows Xmap f
hT : Epi (Sigma.desc f)
he : EffectiveEpiFamily Xmap f ↔ Epi (Sigma.desc f)
φ : (i : I) → Xmap i ⟶ ∐ Xmap := fun i => Sigma.ι Xmap i
F : (∐ fun b => Xmap b) ⟶ Y := Sigma.desc f
Z : Sieve Y := Sieve.generate T
Xs : ExtrDisc := ∐ fun i => Xmap i
Zf : Sieve Y := Sieve.generate (ofArrows (fun x => Xs) fun x => F)
⊢ (ofArrows (fun x => ∐ fun i => Xmap i) fun x => Sigma.desc f) ∈ ExtensiveSieve Y ∪ RegularSieve Y
TACTIC:
|
https://github.com/adamtopaz/CopenhagenMasterclass2023.git | a293ca1554f7e80d891fd4d86fb092c54d8a0a01 | ExtrDisc/ExplicitSheaves.lean | ExtrDisc.extensiveRegular_generates_coherent | [108, 1] | [217, 21] | right | case h.h.h.mpr.of.intro.intro.intro.intro.intro.a.hS
X : ExtrDisc
S : Sieve X
Y : ExtrDisc
T : Presieve Y
I : Type
hI : Fintype I
Xmap : I → ExtrDisc
f : (a : I) → Xmap a ⟶ Y
h : T = ofArrows Xmap f
hT : Epi (Sigma.desc f)
he : EffectiveEpiFamily Xmap f ↔ Epi (Sigma.desc f)
φ : (i : I) → Xmap i ⟶ ∐ Xmap := fun i => Sigma.ι Xmap i
F : (∐ fun b => Xmap b) ⟶ Y := Sigma.desc f
Z : Sieve Y := Sieve.generate T
Xs : ExtrDisc := ∐ fun i => Xmap i
Zf : Sieve Y := Sieve.generate (ofArrows (fun x => Xs) fun x => F)
⊢ (ofArrows (fun x => ∐ fun i => Xmap i) fun x => Sigma.desc f) ∈ ExtensiveSieve Y ∨
(ofArrows (fun x => ∐ fun i => Xmap i) fun x => Sigma.desc f) ∈ RegularSieve Y | case h.h.h.mpr.of.intro.intro.intro.intro.intro.a.hS.h
X : ExtrDisc
S : Sieve X
Y : ExtrDisc
T : Presieve Y
I : Type
hI : Fintype I
Xmap : I → ExtrDisc
f : (a : I) → Xmap a ⟶ Y
h : T = ofArrows Xmap f
hT : Epi (Sigma.desc f)
he : EffectiveEpiFamily Xmap f ↔ Epi (Sigma.desc f)
φ : (i : I) → Xmap i ⟶ ∐ Xmap := fun i => Sigma.ι Xmap i
F : (∐ fun b => Xmap b) ⟶ Y := Sigma.desc f
Z : Sieve Y := Sieve.generate T
Xs : ExtrDisc := ∐ fun i => Xmap i
Zf : Sieve Y := Sieve.generate (ofArrows (fun x => Xs) fun x => F)
⊢ (ofArrows (fun x => ∐ fun i => Xmap i) fun x => Sigma.desc f) ∈ RegularSieve Y | Please generate a tactic in lean4 to solve the state.
STATE:
case h.h.h.mpr.of.intro.intro.intro.intro.intro.a.hS
X : ExtrDisc
S : Sieve X
Y : ExtrDisc
T : Presieve Y
I : Type
hI : Fintype I
Xmap : I → ExtrDisc
f : (a : I) → Xmap a ⟶ Y
h : T = ofArrows Xmap f
hT : Epi (Sigma.desc f)
he : EffectiveEpiFamily Xmap f ↔ Epi (Sigma.desc f)
φ : (i : I) → Xmap i ⟶ ∐ Xmap := fun i => Sigma.ι Xmap i
F : (∐ fun b => Xmap b) ⟶ Y := Sigma.desc f
Z : Sieve Y := Sieve.generate T
Xs : ExtrDisc := ∐ fun i => Xmap i
Zf : Sieve Y := Sieve.generate (ofArrows (fun x => Xs) fun x => F)
⊢ (ofArrows (fun x => ∐ fun i => Xmap i) fun x => Sigma.desc f) ∈ ExtensiveSieve Y ∨
(ofArrows (fun x => ∐ fun i => Xmap i) fun x => Sigma.desc f) ∈ RegularSieve Y
TACTIC:
|
https://github.com/adamtopaz/CopenhagenMasterclass2023.git | a293ca1554f7e80d891fd4d86fb092c54d8a0a01 | ExtrDisc/ExplicitSheaves.lean | ExtrDisc.extensiveRegular_generates_coherent | [108, 1] | [217, 21] | use Xs | case h.h.h.mpr.of.intro.intro.intro.intro.intro.a.hS.h
X : ExtrDisc
S : Sieve X
Y : ExtrDisc
T : Presieve Y
I : Type
hI : Fintype I
Xmap : I → ExtrDisc
f : (a : I) → Xmap a ⟶ Y
h : T = ofArrows Xmap f
hT : Epi (Sigma.desc f)
he : EffectiveEpiFamily Xmap f ↔ Epi (Sigma.desc f)
φ : (i : I) → Xmap i ⟶ ∐ Xmap := fun i => Sigma.ι Xmap i
F : (∐ fun b => Xmap b) ⟶ Y := Sigma.desc f
Z : Sieve Y := Sieve.generate T
Xs : ExtrDisc := ∐ fun i => Xmap i
Zf : Sieve Y := Sieve.generate (ofArrows (fun x => Xs) fun x => F)
⊢ (ofArrows (fun x => ∐ fun i => Xmap i) fun x => Sigma.desc f) ∈ RegularSieve Y | case h.h.h.mpr.of.intro.intro.intro.intro.intro.a.hS.h
X : ExtrDisc
S : Sieve X
Y : ExtrDisc
T : Presieve Y
I : Type
hI : Fintype I
Xmap : I → ExtrDisc
f : (a : I) → Xmap a ⟶ Y
h : T = ofArrows Xmap f
hT : Epi (Sigma.desc f)
he : EffectiveEpiFamily Xmap f ↔ Epi (Sigma.desc f)
φ : (i : I) → Xmap i ⟶ ∐ Xmap := fun i => Sigma.ι Xmap i
F : (∐ fun b => Xmap b) ⟶ Y := Sigma.desc f
Z : Sieve Y := Sieve.generate T
Xs : ExtrDisc := ∐ fun i => Xmap i
Zf : Sieve Y := Sieve.generate (ofArrows (fun x => Xs) fun x => F)
⊢ ∃ f_1, ((ofArrows (fun x => ∐ fun i => Xmap i) fun x => Sigma.desc f) = ofArrows (fun x => Xs) fun x => f_1) ∧ Epi f_1 | Please generate a tactic in lean4 to solve the state.
STATE:
case h.h.h.mpr.of.intro.intro.intro.intro.intro.a.hS.h
X : ExtrDisc
S : Sieve X
Y : ExtrDisc
T : Presieve Y
I : Type
hI : Fintype I
Xmap : I → ExtrDisc
f : (a : I) → Xmap a ⟶ Y
h : T = ofArrows Xmap f
hT : Epi (Sigma.desc f)
he : EffectiveEpiFamily Xmap f ↔ Epi (Sigma.desc f)
φ : (i : I) → Xmap i ⟶ ∐ Xmap := fun i => Sigma.ι Xmap i
F : (∐ fun b => Xmap b) ⟶ Y := Sigma.desc f
Z : Sieve Y := Sieve.generate T
Xs : ExtrDisc := ∐ fun i => Xmap i
Zf : Sieve Y := Sieve.generate (ofArrows (fun x => Xs) fun x => F)
⊢ (ofArrows (fun x => ∐ fun i => Xmap i) fun x => Sigma.desc f) ∈ RegularSieve Y
TACTIC:
|
https://github.com/adamtopaz/CopenhagenMasterclass2023.git | a293ca1554f7e80d891fd4d86fb092c54d8a0a01 | ExtrDisc/ExplicitSheaves.lean | ExtrDisc.extensiveRegular_generates_coherent | [108, 1] | [217, 21] | use F | case h.h.h.mpr.of.intro.intro.intro.intro.intro.a.hS.h
X : ExtrDisc
S : Sieve X
Y : ExtrDisc
T : Presieve Y
I : Type
hI : Fintype I
Xmap : I → ExtrDisc
f : (a : I) → Xmap a ⟶ Y
h : T = ofArrows Xmap f
hT : Epi (Sigma.desc f)
he : EffectiveEpiFamily Xmap f ↔ Epi (Sigma.desc f)
φ : (i : I) → Xmap i ⟶ ∐ Xmap := fun i => Sigma.ι Xmap i
F : (∐ fun b => Xmap b) ⟶ Y := Sigma.desc f
Z : Sieve Y := Sieve.generate T
Xs : ExtrDisc := ∐ fun i => Xmap i
Zf : Sieve Y := Sieve.generate (ofArrows (fun x => Xs) fun x => F)
⊢ ∃ f_1, ((ofArrows (fun x => ∐ fun i => Xmap i) fun x => Sigma.desc f) = ofArrows (fun x => Xs) fun x => f_1) ∧ Epi f_1 | case h.h.h.mpr.of.intro.intro.intro.intro.intro.a.hS.h
X : ExtrDisc
S : Sieve X
Y : ExtrDisc
T : Presieve Y
I : Type
hI : Fintype I
Xmap : I → ExtrDisc
f : (a : I) → Xmap a ⟶ Y
h : T = ofArrows Xmap f
hT : Epi (Sigma.desc f)
he : EffectiveEpiFamily Xmap f ↔ Epi (Sigma.desc f)
φ : (i : I) → Xmap i ⟶ ∐ Xmap := fun i => Sigma.ι Xmap i
F : (∐ fun b => Xmap b) ⟶ Y := Sigma.desc f
Z : Sieve Y := Sieve.generate T
Xs : ExtrDisc := ∐ fun i => Xmap i
Zf : Sieve Y := Sieve.generate (ofArrows (fun x => Xs) fun x => F)
⊢ ((ofArrows (fun x => ∐ fun i => Xmap i) fun x => Sigma.desc f) = ofArrows (fun x => Xs) fun x => F) ∧ Epi F | Please generate a tactic in lean4 to solve the state.
STATE:
case h.h.h.mpr.of.intro.intro.intro.intro.intro.a.hS.h
X : ExtrDisc
S : Sieve X
Y : ExtrDisc
T : Presieve Y
I : Type
hI : Fintype I
Xmap : I → ExtrDisc
f : (a : I) → Xmap a ⟶ Y
h : T = ofArrows Xmap f
hT : Epi (Sigma.desc f)
he : EffectiveEpiFamily Xmap f ↔ Epi (Sigma.desc f)
φ : (i : I) → Xmap i ⟶ ∐ Xmap := fun i => Sigma.ι Xmap i
F : (∐ fun b => Xmap b) ⟶ Y := Sigma.desc f
Z : Sieve Y := Sieve.generate T
Xs : ExtrDisc := ∐ fun i => Xmap i
Zf : Sieve Y := Sieve.generate (ofArrows (fun x => Xs) fun x => F)
⊢ ∃ f_1, ((ofArrows (fun x => ∐ fun i => Xmap i) fun x => Sigma.desc f) = ofArrows (fun x => Xs) fun x => f_1) ∧ Epi f_1
TACTIC:
|
https://github.com/adamtopaz/CopenhagenMasterclass2023.git | a293ca1554f7e80d891fd4d86fb092c54d8a0a01 | ExtrDisc/ExplicitSheaves.lean | ExtrDisc.extensiveRegular_generates_coherent | [108, 1] | [217, 21] | refine' ⟨rfl, inferInstance⟩ | case h.h.h.mpr.of.intro.intro.intro.intro.intro.a.hS.h
X : ExtrDisc
S : Sieve X
Y : ExtrDisc
T : Presieve Y
I : Type
hI : Fintype I
Xmap : I → ExtrDisc
f : (a : I) → Xmap a ⟶ Y
h : T = ofArrows Xmap f
hT : Epi (Sigma.desc f)
he : EffectiveEpiFamily Xmap f ↔ Epi (Sigma.desc f)
φ : (i : I) → Xmap i ⟶ ∐ Xmap := fun i => Sigma.ι Xmap i
F : (∐ fun b => Xmap b) ⟶ Y := Sigma.desc f
Z : Sieve Y := Sieve.generate T
Xs : ExtrDisc := ∐ fun i => Xmap i
Zf : Sieve Y := Sieve.generate (ofArrows (fun x => Xs) fun x => F)
⊢ ((ofArrows (fun x => ∐ fun i => Xmap i) fun x => Sigma.desc f) = ofArrows (fun x => Xs) fun x => F) ∧ Epi F | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case h.h.h.mpr.of.intro.intro.intro.intro.intro.a.hS.h
X : ExtrDisc
S : Sieve X
Y : ExtrDisc
T : Presieve Y
I : Type
hI : Fintype I
Xmap : I → ExtrDisc
f : (a : I) → Xmap a ⟶ Y
h : T = ofArrows Xmap f
hT : Epi (Sigma.desc f)
he : EffectiveEpiFamily Xmap f ↔ Epi (Sigma.desc f)
φ : (i : I) → Xmap i ⟶ ∐ Xmap := fun i => Sigma.ι Xmap i
F : (∐ fun b => Xmap b) ⟶ Y := Sigma.desc f
Z : Sieve Y := Sieve.generate T
Xs : ExtrDisc := ∐ fun i => Xmap i
Zf : Sieve Y := Sieve.generate (ofArrows (fun x => Xs) fun x => F)
⊢ ((ofArrows (fun x => ∐ fun i => Xmap i) fun x => Sigma.desc f) = ofArrows (fun x => Xs) fun x => F) ∧ Epi F
TACTIC:
|
https://github.com/adamtopaz/CopenhagenMasterclass2023.git | a293ca1554f7e80d891fd4d86fb092c54d8a0a01 | ExtrDisc/ExplicitSheaves.lean | ExtrDisc.extensiveRegular_generates_coherent | [108, 1] | [217, 21] | intro R g hZfg | case h.h.h.mpr.of.intro.intro.intro.intro.intro.a
X : ExtrDisc
S : Sieve X
Y : ExtrDisc
T : Presieve Y
I : Type
hI : Fintype I
Xmap : I → ExtrDisc
f : (a : I) → Xmap a ⟶ Y
h : T = ofArrows Xmap f
hT : Epi (Sigma.desc f)
he : EffectiveEpiFamily Xmap f ↔ Epi (Sigma.desc f)
φ : (i : I) → Xmap i ⟶ ∐ Xmap := fun i => Sigma.ι Xmap i
F : (∐ fun b => Xmap b) ⟶ Y := Sigma.desc f
Z : Sieve Y := Sieve.generate T
Xs : ExtrDisc := ∐ fun i => Xmap i
Zf : Sieve Y := Sieve.generate (ofArrows (fun x => Xs) fun x => F)
⊢ ∀ ⦃Y_1 : ExtrDisc⦄ ⦃f : Y_1 ⟶ Y⦄,
Zf.arrows f →
Coverage.saturate
(ExtensiveRegularCoverage ExtrDisc everything_proj
(_ :
∀ {α : Type} [inst : Fintype α] {X : ExtrDisc} {Z : α → ExtrDisc} (π : (a : α) → Z a ⟶ X) {Y : ExtrDisc}
(f : Y ⟶ X) (x : IsIso (Sigma.desc π)), IsIso (Sigma.desc fun x_1 => Limits.pullback.fst)))
Y_1 (Sieve.pullback f (Sieve.generate T)) | case h.h.h.mpr.of.intro.intro.intro.intro.intro.a
X : ExtrDisc
S : Sieve X
Y : ExtrDisc
T : Presieve Y
I : Type
hI : Fintype I
Xmap : I → ExtrDisc
f : (a : I) → Xmap a ⟶ Y
h : T = ofArrows Xmap f
hT : Epi (Sigma.desc f)
he : EffectiveEpiFamily Xmap f ↔ Epi (Sigma.desc f)
φ : (i : I) → Xmap i ⟶ ∐ Xmap := fun i => Sigma.ι Xmap i
F : (∐ fun b => Xmap b) ⟶ Y := Sigma.desc f
Z : Sieve Y := Sieve.generate T
Xs : ExtrDisc := ∐ fun i => Xmap i
Zf : Sieve Y := Sieve.generate (ofArrows (fun x => Xs) fun x => F)
R : ExtrDisc
g : R ⟶ Y
hZfg : Zf.arrows g
⊢ Coverage.saturate
(ExtensiveRegularCoverage ExtrDisc everything_proj
(_ :
∀ {α : Type} [inst : Fintype α] {X : ExtrDisc} {Z : α → ExtrDisc} (π : (a : α) → Z a ⟶ X) {Y : ExtrDisc}
(f : Y ⟶ X) (x : IsIso (Sigma.desc π)), IsIso (Sigma.desc fun x_1 => Limits.pullback.fst)))
R (Sieve.pullback g (Sieve.generate T)) | Please generate a tactic in lean4 to solve the state.
STATE:
case h.h.h.mpr.of.intro.intro.intro.intro.intro.a
X : ExtrDisc
S : Sieve X
Y : ExtrDisc
T : Presieve Y
I : Type
hI : Fintype I
Xmap : I → ExtrDisc
f : (a : I) → Xmap a ⟶ Y
h : T = ofArrows Xmap f
hT : Epi (Sigma.desc f)
he : EffectiveEpiFamily Xmap f ↔ Epi (Sigma.desc f)
φ : (i : I) → Xmap i ⟶ ∐ Xmap := fun i => Sigma.ι Xmap i
F : (∐ fun b => Xmap b) ⟶ Y := Sigma.desc f
Z : Sieve Y := Sieve.generate T
Xs : ExtrDisc := ∐ fun i => Xmap i
Zf : Sieve Y := Sieve.generate (ofArrows (fun x => Xs) fun x => F)
⊢ ∀ ⦃Y_1 : ExtrDisc⦄ ⦃f : Y_1 ⟶ Y⦄,
Zf.arrows f →
Coverage.saturate
(ExtensiveRegularCoverage ExtrDisc everything_proj
(_ :
∀ {α : Type} [inst : Fintype α] {X : ExtrDisc} {Z : α → ExtrDisc} (π : (a : α) → Z a ⟶ X) {Y : ExtrDisc}
(f : Y ⟶ X) (x : IsIso (Sigma.desc π)), IsIso (Sigma.desc fun x_1 => Limits.pullback.fst)))
Y_1 (Sieve.pullback f (Sieve.generate T))
TACTIC:
|
https://github.com/adamtopaz/CopenhagenMasterclass2023.git | a293ca1554f7e80d891fd4d86fb092c54d8a0a01 | ExtrDisc/ExplicitSheaves.lean | ExtrDisc.extensiveRegular_generates_coherent | [108, 1] | [217, 21] | dsimp at hZfg | case h.h.h.mpr.of.intro.intro.intro.intro.intro.a
X : ExtrDisc
S : Sieve X
Y : ExtrDisc
T : Presieve Y
I : Type
hI : Fintype I
Xmap : I → ExtrDisc
f : (a : I) → Xmap a ⟶ Y
h : T = ofArrows Xmap f
hT : Epi (Sigma.desc f)
he : EffectiveEpiFamily Xmap f ↔ Epi (Sigma.desc f)
φ : (i : I) → Xmap i ⟶ ∐ Xmap := fun i => Sigma.ι Xmap i
F : (∐ fun b => Xmap b) ⟶ Y := Sigma.desc f
Z : Sieve Y := Sieve.generate T
Xs : ExtrDisc := ∐ fun i => Xmap i
Zf : Sieve Y := Sieve.generate (ofArrows (fun x => Xs) fun x => F)
R : ExtrDisc
g : R ⟶ Y
hZfg : Zf.arrows g
⊢ Coverage.saturate
(ExtensiveRegularCoverage ExtrDisc everything_proj
(_ :
∀ {α : Type} [inst : Fintype α] {X : ExtrDisc} {Z : α → ExtrDisc} (π : (a : α) → Z a ⟶ X) {Y : ExtrDisc}
(f : Y ⟶ X) (x : IsIso (Sigma.desc π)), IsIso (Sigma.desc fun x_1 => Limits.pullback.fst)))
R (Sieve.pullback g (Sieve.generate T)) | case h.h.h.mpr.of.intro.intro.intro.intro.intro.a
X : ExtrDisc
S : Sieve X
Y : ExtrDisc
T : Presieve Y
I : Type
hI : Fintype I
Xmap : I → ExtrDisc
f : (a : I) → Xmap a ⟶ Y
h : T = ofArrows Xmap f
hT : Epi (Sigma.desc f)
he : EffectiveEpiFamily Xmap f ↔ Epi (Sigma.desc f)
φ : (i : I) → Xmap i ⟶ ∐ Xmap := fun i => Sigma.ι Xmap i
F : (∐ fun b => Xmap b) ⟶ Y := Sigma.desc f
Z : Sieve Y := Sieve.generate T
Xs : ExtrDisc := ∐ fun i => Xmap i
Zf : Sieve Y := Sieve.generate (ofArrows (fun x => Xs) fun x => F)
R : ExtrDisc
g : R ⟶ Y
hZfg : ∃ Y_1 h g_1, ofArrows (fun x => ∐ fun i => Xmap i) (fun x => Sigma.desc f) g_1 ∧ h ≫ g_1 = g
⊢ Coverage.saturate
(ExtensiveRegularCoverage ExtrDisc everything_proj
(_ :
∀ {α : Type} [inst : Fintype α] {X : ExtrDisc} {Z : α → ExtrDisc} (π : (a : α) → Z a ⟶ X) {Y : ExtrDisc}
(f : Y ⟶ X) (x : IsIso (Sigma.desc π)), IsIso (Sigma.desc fun x_1 => Limits.pullback.fst)))
R (Sieve.pullback g (Sieve.generate T)) | Please generate a tactic in lean4 to solve the state.
STATE:
case h.h.h.mpr.of.intro.intro.intro.intro.intro.a
X : ExtrDisc
S : Sieve X
Y : ExtrDisc
T : Presieve Y
I : Type
hI : Fintype I
Xmap : I → ExtrDisc
f : (a : I) → Xmap a ⟶ Y
h : T = ofArrows Xmap f
hT : Epi (Sigma.desc f)
he : EffectiveEpiFamily Xmap f ↔ Epi (Sigma.desc f)
φ : (i : I) → Xmap i ⟶ ∐ Xmap := fun i => Sigma.ι Xmap i
F : (∐ fun b => Xmap b) ⟶ Y := Sigma.desc f
Z : Sieve Y := Sieve.generate T
Xs : ExtrDisc := ∐ fun i => Xmap i
Zf : Sieve Y := Sieve.generate (ofArrows (fun x => Xs) fun x => F)
R : ExtrDisc
g : R ⟶ Y
hZfg : Zf.arrows g
⊢ Coverage.saturate
(ExtensiveRegularCoverage ExtrDisc everything_proj
(_ :
∀ {α : Type} [inst : Fintype α] {X : ExtrDisc} {Z : α → ExtrDisc} (π : (a : α) → Z a ⟶ X) {Y : ExtrDisc}
(f : Y ⟶ X) (x : IsIso (Sigma.desc π)), IsIso (Sigma.desc fun x_1 => Limits.pullback.fst)))
R (Sieve.pullback g (Sieve.generate T))
TACTIC:
|
https://github.com/adamtopaz/CopenhagenMasterclass2023.git | a293ca1554f7e80d891fd4d86fb092c54d8a0a01 | ExtrDisc/ExplicitSheaves.lean | ExtrDisc.extensiveRegular_generates_coherent | [108, 1] | [217, 21] | rw [Presieve.ofArrows_pUnit] at hZfg | case h.h.h.mpr.of.intro.intro.intro.intro.intro.a
X : ExtrDisc
S : Sieve X
Y : ExtrDisc
T : Presieve Y
I : Type
hI : Fintype I
Xmap : I → ExtrDisc
f : (a : I) → Xmap a ⟶ Y
h : T = ofArrows Xmap f
hT : Epi (Sigma.desc f)
he : EffectiveEpiFamily Xmap f ↔ Epi (Sigma.desc f)
φ : (i : I) → Xmap i ⟶ ∐ Xmap := fun i => Sigma.ι Xmap i
F : (∐ fun b => Xmap b) ⟶ Y := Sigma.desc f
Z : Sieve Y := Sieve.generate T
Xs : ExtrDisc := ∐ fun i => Xmap i
Zf : Sieve Y := Sieve.generate (ofArrows (fun x => Xs) fun x => F)
R : ExtrDisc
g : R ⟶ Y
hZfg : ∃ Y_1 h g_1, ofArrows (fun x => ∐ fun i => Xmap i) (fun x => Sigma.desc f) g_1 ∧ h ≫ g_1 = g
⊢ Coverage.saturate
(ExtensiveRegularCoverage ExtrDisc everything_proj
(_ :
∀ {α : Type} [inst : Fintype α] {X : ExtrDisc} {Z : α → ExtrDisc} (π : (a : α) → Z a ⟶ X) {Y : ExtrDisc}
(f : Y ⟶ X) (x : IsIso (Sigma.desc π)), IsIso (Sigma.desc fun x_1 => Limits.pullback.fst)))
R (Sieve.pullback g (Sieve.generate T)) | case h.h.h.mpr.of.intro.intro.intro.intro.intro.a
X : ExtrDisc
S : Sieve X
Y : ExtrDisc
T : Presieve Y
I : Type
hI : Fintype I
Xmap : I → ExtrDisc
f : (a : I) → Xmap a ⟶ Y
h : T = ofArrows Xmap f
hT : Epi (Sigma.desc f)
he : EffectiveEpiFamily Xmap f ↔ Epi (Sigma.desc f)
φ : (i : I) → Xmap i ⟶ ∐ Xmap := fun i => Sigma.ι Xmap i
F : (∐ fun b => Xmap b) ⟶ Y := Sigma.desc f
Z : Sieve Y := Sieve.generate T
Xs : ExtrDisc := ∐ fun i => Xmap i
Zf : Sieve Y := Sieve.generate (ofArrows (fun x => Xs) fun x => F)
R : ExtrDisc
g : R ⟶ Y
hZfg : ∃ Y_1 h g_1, Presieve.singleton (Sigma.desc f) g_1 ∧ h ≫ g_1 = g
⊢ Coverage.saturate
(ExtensiveRegularCoverage ExtrDisc everything_proj
(_ :
∀ {α : Type} [inst : Fintype α] {X : ExtrDisc} {Z : α → ExtrDisc} (π : (a : α) → Z a ⟶ X) {Y : ExtrDisc}
(f : Y ⟶ X) (x : IsIso (Sigma.desc π)), IsIso (Sigma.desc fun x_1 => Limits.pullback.fst)))
R (Sieve.pullback g (Sieve.generate T)) | Please generate a tactic in lean4 to solve the state.
STATE:
case h.h.h.mpr.of.intro.intro.intro.intro.intro.a
X : ExtrDisc
S : Sieve X
Y : ExtrDisc
T : Presieve Y
I : Type
hI : Fintype I
Xmap : I → ExtrDisc
f : (a : I) → Xmap a ⟶ Y
h : T = ofArrows Xmap f
hT : Epi (Sigma.desc f)
he : EffectiveEpiFamily Xmap f ↔ Epi (Sigma.desc f)
φ : (i : I) → Xmap i ⟶ ∐ Xmap := fun i => Sigma.ι Xmap i
F : (∐ fun b => Xmap b) ⟶ Y := Sigma.desc f
Z : Sieve Y := Sieve.generate T
Xs : ExtrDisc := ∐ fun i => Xmap i
Zf : Sieve Y := Sieve.generate (ofArrows (fun x => Xs) fun x => F)
R : ExtrDisc
g : R ⟶ Y
hZfg : ∃ Y_1 h g_1, ofArrows (fun x => ∐ fun i => Xmap i) (fun x => Sigma.desc f) g_1 ∧ h ≫ g_1 = g
⊢ Coverage.saturate
(ExtensiveRegularCoverage ExtrDisc everything_proj
(_ :
∀ {α : Type} [inst : Fintype α] {X : ExtrDisc} {Z : α → ExtrDisc} (π : (a : α) → Z a ⟶ X) {Y : ExtrDisc}
(f : Y ⟶ X) (x : IsIso (Sigma.desc π)), IsIso (Sigma.desc fun x_1 => Limits.pullback.fst)))
R (Sieve.pullback g (Sieve.generate T))
TACTIC:
|
https://github.com/adamtopaz/CopenhagenMasterclass2023.git | a293ca1554f7e80d891fd4d86fb092c54d8a0a01 | ExtrDisc/ExplicitSheaves.lean | ExtrDisc.extensiveRegular_generates_coherent | [108, 1] | [217, 21] | obtain ⟨W, ψ, σ, ⟨hW, hW'⟩⟩ := hZfg | case h.h.h.mpr.of.intro.intro.intro.intro.intro.a
X : ExtrDisc
S : Sieve X
Y : ExtrDisc
T : Presieve Y
I : Type
hI : Fintype I
Xmap : I → ExtrDisc
f : (a : I) → Xmap a ⟶ Y
h : T = ofArrows Xmap f
hT : Epi (Sigma.desc f)
he : EffectiveEpiFamily Xmap f ↔ Epi (Sigma.desc f)
φ : (i : I) → Xmap i ⟶ ∐ Xmap := fun i => Sigma.ι Xmap i
F : (∐ fun b => Xmap b) ⟶ Y := Sigma.desc f
Z : Sieve Y := Sieve.generate T
Xs : ExtrDisc := ∐ fun i => Xmap i
Zf : Sieve Y := Sieve.generate (ofArrows (fun x => Xs) fun x => F)
R : ExtrDisc
g : R ⟶ Y
hZfg : ∃ Y_1 h g_1, Presieve.singleton (Sigma.desc f) g_1 ∧ h ≫ g_1 = g
⊢ Coverage.saturate
(ExtensiveRegularCoverage ExtrDisc everything_proj
(_ :
∀ {α : Type} [inst : Fintype α] {X : ExtrDisc} {Z : α → ExtrDisc} (π : (a : α) → Z a ⟶ X) {Y : ExtrDisc}
(f : Y ⟶ X) (x : IsIso (Sigma.desc π)), IsIso (Sigma.desc fun x_1 => Limits.pullback.fst)))
R (Sieve.pullback g (Sieve.generate T)) | case h.h.h.mpr.of.intro.intro.intro.intro.intro.a.intro.intro.intro.intro
X : ExtrDisc
S : Sieve X
Y : ExtrDisc
T : Presieve Y
I : Type
hI : Fintype I
Xmap : I → ExtrDisc
f : (a : I) → Xmap a ⟶ Y
h : T = ofArrows Xmap f
hT : Epi (Sigma.desc f)
he : EffectiveEpiFamily Xmap f ↔ Epi (Sigma.desc f)
φ : (i : I) → Xmap i ⟶ ∐ Xmap := fun i => Sigma.ι Xmap i
F : (∐ fun b => Xmap b) ⟶ Y := Sigma.desc f
Z : Sieve Y := Sieve.generate T
Xs : ExtrDisc := ∐ fun i => Xmap i
Zf : Sieve Y := Sieve.generate (ofArrows (fun x => Xs) fun x => F)
R : ExtrDisc
g : R ⟶ Y
W : ExtrDisc
ψ : R ⟶ W
σ : W ⟶ Y
hW : Presieve.singleton (Sigma.desc f) σ
hW' : ψ ≫ σ = g
⊢ Coverage.saturate
(ExtensiveRegularCoverage ExtrDisc everything_proj
(_ :
∀ {α : Type} [inst : Fintype α] {X : ExtrDisc} {Z : α → ExtrDisc} (π : (a : α) → Z a ⟶ X) {Y : ExtrDisc}
(f : Y ⟶ X) (x : IsIso (Sigma.desc π)), IsIso (Sigma.desc fun x_1 => Limits.pullback.fst)))
R (Sieve.pullback g (Sieve.generate T)) | Please generate a tactic in lean4 to solve the state.
STATE:
case h.h.h.mpr.of.intro.intro.intro.intro.intro.a
X : ExtrDisc
S : Sieve X
Y : ExtrDisc
T : Presieve Y
I : Type
hI : Fintype I
Xmap : I → ExtrDisc
f : (a : I) → Xmap a ⟶ Y
h : T = ofArrows Xmap f
hT : Epi (Sigma.desc f)
he : EffectiveEpiFamily Xmap f ↔ Epi (Sigma.desc f)
φ : (i : I) → Xmap i ⟶ ∐ Xmap := fun i => Sigma.ι Xmap i
F : (∐ fun b => Xmap b) ⟶ Y := Sigma.desc f
Z : Sieve Y := Sieve.generate T
Xs : ExtrDisc := ∐ fun i => Xmap i
Zf : Sieve Y := Sieve.generate (ofArrows (fun x => Xs) fun x => F)
R : ExtrDisc
g : R ⟶ Y
hZfg : ∃ Y_1 h g_1, Presieve.singleton (Sigma.desc f) g_1 ∧ h ≫ g_1 = g
⊢ Coverage.saturate
(ExtensiveRegularCoverage ExtrDisc everything_proj
(_ :
∀ {α : Type} [inst : Fintype α] {X : ExtrDisc} {Z : α → ExtrDisc} (π : (a : α) → Z a ⟶ X) {Y : ExtrDisc}
(f : Y ⟶ X) (x : IsIso (Sigma.desc π)), IsIso (Sigma.desc fun x_1 => Limits.pullback.fst)))
R (Sieve.pullback g (Sieve.generate T))
TACTIC:
|
https://github.com/adamtopaz/CopenhagenMasterclass2023.git | a293ca1554f7e80d891fd4d86fb092c54d8a0a01 | ExtrDisc/ExplicitSheaves.lean | ExtrDisc.extensiveRegular_generates_coherent | [108, 1] | [217, 21] | dsimp [Presieve.singleton] at hW | case h.h.h.mpr.of.intro.intro.intro.intro.intro.a.intro.intro.intro.intro
X : ExtrDisc
S : Sieve X
Y : ExtrDisc
T : Presieve Y
I : Type
hI : Fintype I
Xmap : I → ExtrDisc
f : (a : I) → Xmap a ⟶ Y
h : T = ofArrows Xmap f
hT : Epi (Sigma.desc f)
he : EffectiveEpiFamily Xmap f ↔ Epi (Sigma.desc f)
φ : (i : I) → Xmap i ⟶ ∐ Xmap := fun i => Sigma.ι Xmap i
F : (∐ fun b => Xmap b) ⟶ Y := Sigma.desc f
Z : Sieve Y := Sieve.generate T
Xs : ExtrDisc := ∐ fun i => Xmap i
Zf : Sieve Y := Sieve.generate (ofArrows (fun x => Xs) fun x => F)
R : ExtrDisc
g : R ⟶ Y
W : ExtrDisc
ψ : R ⟶ W
σ : W ⟶ Y
hW : Presieve.singleton (Sigma.desc f) σ
hW' : ψ ≫ σ = g
⊢ Coverage.saturate
(ExtensiveRegularCoverage ExtrDisc everything_proj
(_ :
∀ {α : Type} [inst : Fintype α] {X : ExtrDisc} {Z : α → ExtrDisc} (π : (a : α) → Z a ⟶ X) {Y : ExtrDisc}
(f : Y ⟶ X) (x : IsIso (Sigma.desc π)), IsIso (Sigma.desc fun x_1 => Limits.pullback.fst)))
R (Sieve.pullback g (Sieve.generate T)) | case h.h.h.mpr.of.intro.intro.intro.intro.intro.a.intro.intro.intro.intro
X : ExtrDisc
S : Sieve X
Y : ExtrDisc
T : Presieve Y
I : Type
hI : Fintype I
Xmap : I → ExtrDisc
f : (a : I) → Xmap a ⟶ Y
h : T = ofArrows Xmap f
hT : Epi (Sigma.desc f)
he : EffectiveEpiFamily Xmap f ↔ Epi (Sigma.desc f)
φ : (i : I) → Xmap i ⟶ ∐ Xmap := fun i => Sigma.ι Xmap i
F : (∐ fun b => Xmap b) ⟶ Y := Sigma.desc f
Z : Sieve Y := Sieve.generate T
Xs : ExtrDisc := ∐ fun i => Xmap i
Zf : Sieve Y := Sieve.generate (ofArrows (fun x => Xs) fun x => F)
R : ExtrDisc
g : R ⟶ Y
W : ExtrDisc
ψ : R ⟶ W
σ : W ⟶ Y
hW : singleton' (Sigma.desc f) σ
hW' : ψ ≫ σ = g
⊢ Coverage.saturate
(ExtensiveRegularCoverage ExtrDisc everything_proj
(_ :
∀ {α : Type} [inst : Fintype α] {X : ExtrDisc} {Z : α → ExtrDisc} (π : (a : α) → Z a ⟶ X) {Y : ExtrDisc}
(f : Y ⟶ X) (x : IsIso (Sigma.desc π)), IsIso (Sigma.desc fun x_1 => Limits.pullback.fst)))
R (Sieve.pullback g (Sieve.generate T)) | Please generate a tactic in lean4 to solve the state.
STATE:
case h.h.h.mpr.of.intro.intro.intro.intro.intro.a.intro.intro.intro.intro
X : ExtrDisc
S : Sieve X
Y : ExtrDisc
T : Presieve Y
I : Type
hI : Fintype I
Xmap : I → ExtrDisc
f : (a : I) → Xmap a ⟶ Y
h : T = ofArrows Xmap f
hT : Epi (Sigma.desc f)
he : EffectiveEpiFamily Xmap f ↔ Epi (Sigma.desc f)
φ : (i : I) → Xmap i ⟶ ∐ Xmap := fun i => Sigma.ι Xmap i
F : (∐ fun b => Xmap b) ⟶ Y := Sigma.desc f
Z : Sieve Y := Sieve.generate T
Xs : ExtrDisc := ∐ fun i => Xmap i
Zf : Sieve Y := Sieve.generate (ofArrows (fun x => Xs) fun x => F)
R : ExtrDisc
g : R ⟶ Y
W : ExtrDisc
ψ : R ⟶ W
σ : W ⟶ Y
hW : Presieve.singleton (Sigma.desc f) σ
hW' : ψ ≫ σ = g
⊢ Coverage.saturate
(ExtensiveRegularCoverage ExtrDisc everything_proj
(_ :
∀ {α : Type} [inst : Fintype α] {X : ExtrDisc} {Z : α → ExtrDisc} (π : (a : α) → Z a ⟶ X) {Y : ExtrDisc}
(f : Y ⟶ X) (x : IsIso (Sigma.desc π)), IsIso (Sigma.desc fun x_1 => Limits.pullback.fst)))
R (Sieve.pullback g (Sieve.generate T))
TACTIC:
|
https://github.com/adamtopaz/CopenhagenMasterclass2023.git | a293ca1554f7e80d891fd4d86fb092c54d8a0a01 | ExtrDisc/ExplicitSheaves.lean | ExtrDisc.extensiveRegular_generates_coherent | [108, 1] | [217, 21] | induction hW | case h.h.h.mpr.of.intro.intro.intro.intro.intro.a.intro.intro.intro.intro
X : ExtrDisc
S : Sieve X
Y : ExtrDisc
T : Presieve Y
I : Type
hI : Fintype I
Xmap : I → ExtrDisc
f : (a : I) → Xmap a ⟶ Y
h : T = ofArrows Xmap f
hT : Epi (Sigma.desc f)
he : EffectiveEpiFamily Xmap f ↔ Epi (Sigma.desc f)
φ : (i : I) → Xmap i ⟶ ∐ Xmap := fun i => Sigma.ι Xmap i
F : (∐ fun b => Xmap b) ⟶ Y := Sigma.desc f
Z : Sieve Y := Sieve.generate T
Xs : ExtrDisc := ∐ fun i => Xmap i
Zf : Sieve Y := Sieve.generate (ofArrows (fun x => Xs) fun x => F)
R : ExtrDisc
g : R ⟶ Y
W : ExtrDisc
ψ : R ⟶ W
σ : W ⟶ Y
hW : singleton' (Sigma.desc f) σ
hW' : ψ ≫ σ = g
⊢ Coverage.saturate
(ExtensiveRegularCoverage ExtrDisc everything_proj
(_ :
∀ {α : Type} [inst : Fintype α] {X : ExtrDisc} {Z : α → ExtrDisc} (π : (a : α) → Z a ⟶ X) {Y : ExtrDisc}
(f : Y ⟶ X) (x : IsIso (Sigma.desc π)), IsIso (Sigma.desc fun x_1 => Limits.pullback.fst)))
R (Sieve.pullback g (Sieve.generate T)) | case h.h.h.mpr.of.intro.intro.intro.intro.intro.a.intro.intro.intro.intro.mk
X : ExtrDisc
S : Sieve X
Y : ExtrDisc
T : Presieve Y
I : Type
hI : Fintype I
Xmap : I → ExtrDisc
f : (a : I) → Xmap a ⟶ Y
h : T = ofArrows Xmap f
hT : Epi (Sigma.desc f)
he : EffectiveEpiFamily Xmap f ↔ Epi (Sigma.desc f)
φ : (i : I) → Xmap i ⟶ ∐ Xmap := fun i => Sigma.ι Xmap i
F : (∐ fun b => Xmap b) ⟶ Y := Sigma.desc f
Z : Sieve Y := Sieve.generate T
Xs : ExtrDisc := ∐ fun i => Xmap i
Zf : Sieve Y := Sieve.generate (ofArrows (fun x => Xs) fun x => F)
R : ExtrDisc
g : R ⟶ Y
W : ExtrDisc
σ : W ⟶ Y
ψ : R ⟶ ∐ fun i => Xmap i
hW' : ψ ≫ Sigma.desc f = g
⊢ Coverage.saturate
(ExtensiveRegularCoverage ExtrDisc everything_proj
(_ :
∀ {α : Type} [inst : Fintype α] {X : ExtrDisc} {Z : α → ExtrDisc} (π : (a : α) → Z a ⟶ X) {Y : ExtrDisc}
(f : Y ⟶ X) (x : IsIso (Sigma.desc π)), IsIso (Sigma.desc fun x_1 => Limits.pullback.fst)))
R (Sieve.pullback g (Sieve.generate T)) | Please generate a tactic in lean4 to solve the state.
STATE:
case h.h.h.mpr.of.intro.intro.intro.intro.intro.a.intro.intro.intro.intro
X : ExtrDisc
S : Sieve X
Y : ExtrDisc
T : Presieve Y
I : Type
hI : Fintype I
Xmap : I → ExtrDisc
f : (a : I) → Xmap a ⟶ Y
h : T = ofArrows Xmap f
hT : Epi (Sigma.desc f)
he : EffectiveEpiFamily Xmap f ↔ Epi (Sigma.desc f)
φ : (i : I) → Xmap i ⟶ ∐ Xmap := fun i => Sigma.ι Xmap i
F : (∐ fun b => Xmap b) ⟶ Y := Sigma.desc f
Z : Sieve Y := Sieve.generate T
Xs : ExtrDisc := ∐ fun i => Xmap i
Zf : Sieve Y := Sieve.generate (ofArrows (fun x => Xs) fun x => F)
R : ExtrDisc
g : R ⟶ Y
W : ExtrDisc
ψ : R ⟶ W
σ : W ⟶ Y
hW : singleton' (Sigma.desc f) σ
hW' : ψ ≫ σ = g
⊢ Coverage.saturate
(ExtensiveRegularCoverage ExtrDisc everything_proj
(_ :
∀ {α : Type} [inst : Fintype α] {X : ExtrDisc} {Z : α → ExtrDisc} (π : (a : α) → Z a ⟶ X) {Y : ExtrDisc}
(f : Y ⟶ X) (x : IsIso (Sigma.desc π)), IsIso (Sigma.desc fun x_1 => Limits.pullback.fst)))
R (Sieve.pullback g (Sieve.generate T))
TACTIC:
|
https://github.com/adamtopaz/CopenhagenMasterclass2023.git | a293ca1554f7e80d891fd4d86fb092c54d8a0a01 | ExtrDisc/ExplicitSheaves.lean | ExtrDisc.extensiveRegular_generates_coherent | [108, 1] | [217, 21] | rw [← hW', Sieve.pullback_comp Z] | case h.h.h.mpr.of.intro.intro.intro.intro.intro.a.intro.intro.intro.intro.mk
X : ExtrDisc
S : Sieve X
Y : ExtrDisc
T : Presieve Y
I : Type
hI : Fintype I
Xmap : I → ExtrDisc
f : (a : I) → Xmap a ⟶ Y
h : T = ofArrows Xmap f
hT : Epi (Sigma.desc f)
he : EffectiveEpiFamily Xmap f ↔ Epi (Sigma.desc f)
φ : (i : I) → Xmap i ⟶ ∐ Xmap := fun i => Sigma.ι Xmap i
F : (∐ fun b => Xmap b) ⟶ Y := Sigma.desc f
Z : Sieve Y := Sieve.generate T
Xs : ExtrDisc := ∐ fun i => Xmap i
Zf : Sieve Y := Sieve.generate (ofArrows (fun x => Xs) fun x => F)
R : ExtrDisc
g : R ⟶ Y
W : ExtrDisc
σ : W ⟶ Y
ψ : R ⟶ ∐ fun i => Xmap i
hW' : ψ ≫ Sigma.desc f = g
⊢ Coverage.saturate
(ExtensiveRegularCoverage ExtrDisc everything_proj
(_ :
∀ {α : Type} [inst : Fintype α] {X : ExtrDisc} {Z : α → ExtrDisc} (π : (a : α) → Z a ⟶ X) {Y : ExtrDisc}
(f : Y ⟶ X) (x : IsIso (Sigma.desc π)), IsIso (Sigma.desc fun x_1 => Limits.pullback.fst)))
R (Sieve.pullback g (Sieve.generate T)) | case h.h.h.mpr.of.intro.intro.intro.intro.intro.a.intro.intro.intro.intro.mk
X : ExtrDisc
S : Sieve X
Y : ExtrDisc
T : Presieve Y
I : Type
hI : Fintype I
Xmap : I → ExtrDisc
f : (a : I) → Xmap a ⟶ Y
h : T = ofArrows Xmap f
hT : Epi (Sigma.desc f)
he : EffectiveEpiFamily Xmap f ↔ Epi (Sigma.desc f)
φ : (i : I) → Xmap i ⟶ ∐ Xmap := fun i => Sigma.ι Xmap i
F : (∐ fun b => Xmap b) ⟶ Y := Sigma.desc f
Z : Sieve Y := Sieve.generate T
Xs : ExtrDisc := ∐ fun i => Xmap i
Zf : Sieve Y := Sieve.generate (ofArrows (fun x => Xs) fun x => F)
R : ExtrDisc
g : R ⟶ Y
W : ExtrDisc
σ : W ⟶ Y
ψ : R ⟶ ∐ fun i => Xmap i
hW' : ψ ≫ Sigma.desc f = g
⊢ Coverage.saturate
(ExtensiveRegularCoverage ExtrDisc everything_proj
(_ :
∀ {α : Type} [inst : Fintype α] {X : ExtrDisc} {Z : α → ExtrDisc} (π : (a : α) → Z a ⟶ X) {Y : ExtrDisc}
(f : Y ⟶ X) (x : IsIso (Sigma.desc π)), IsIso (Sigma.desc fun x_1 => Limits.pullback.fst)))
R (Sieve.pullback ψ (Sieve.pullback (Sigma.desc f) Z)) | Please generate a tactic in lean4 to solve the state.
STATE:
case h.h.h.mpr.of.intro.intro.intro.intro.intro.a.intro.intro.intro.intro.mk
X : ExtrDisc
S : Sieve X
Y : ExtrDisc
T : Presieve Y
I : Type
hI : Fintype I
Xmap : I → ExtrDisc
f : (a : I) → Xmap a ⟶ Y
h : T = ofArrows Xmap f
hT : Epi (Sigma.desc f)
he : EffectiveEpiFamily Xmap f ↔ Epi (Sigma.desc f)
φ : (i : I) → Xmap i ⟶ ∐ Xmap := fun i => Sigma.ι Xmap i
F : (∐ fun b => Xmap b) ⟶ Y := Sigma.desc f
Z : Sieve Y := Sieve.generate T
Xs : ExtrDisc := ∐ fun i => Xmap i
Zf : Sieve Y := Sieve.generate (ofArrows (fun x => Xs) fun x => F)
R : ExtrDisc
g : R ⟶ Y
W : ExtrDisc
σ : W ⟶ Y
ψ : R ⟶ ∐ fun i => Xmap i
hW' : ψ ≫ Sigma.desc f = g
⊢ Coverage.saturate
(ExtensiveRegularCoverage ExtrDisc everything_proj
(_ :
∀ {α : Type} [inst : Fintype α] {X : ExtrDisc} {Z : α → ExtrDisc} (π : (a : α) → Z a ⟶ X) {Y : ExtrDisc}
(f : Y ⟶ X) (x : IsIso (Sigma.desc π)), IsIso (Sigma.desc fun x_1 => Limits.pullback.fst)))
R (Sieve.pullback g (Sieve.generate T))
TACTIC:
|
https://github.com/adamtopaz/CopenhagenMasterclass2023.git | a293ca1554f7e80d891fd4d86fb092c54d8a0a01 | ExtrDisc/ExplicitSheaves.lean | ExtrDisc.extensiveRegular_generates_coherent | [108, 1] | [217, 21] | suffices : Sieve.pullback ψ ((Sieve.pullback F) Z) ∈ GrothendieckTopology.sieves
(ExtensiveRegularCoverage _ _ _).toGrothendieck R | case h.h.h.mpr.of.intro.intro.intro.intro.intro.a.intro.intro.intro.intro.mk
X : ExtrDisc
S : Sieve X
Y : ExtrDisc
T : Presieve Y
I : Type
hI : Fintype I
Xmap : I → ExtrDisc
f : (a : I) → Xmap a ⟶ Y
h : T = ofArrows Xmap f
hT : Epi (Sigma.desc f)
he : EffectiveEpiFamily Xmap f ↔ Epi (Sigma.desc f)
φ : (i : I) → Xmap i ⟶ ∐ Xmap := fun i => Sigma.ι Xmap i
F : (∐ fun b => Xmap b) ⟶ Y := Sigma.desc f
Z : Sieve Y := Sieve.generate T
Xs : ExtrDisc := ∐ fun i => Xmap i
Zf : Sieve Y := Sieve.generate (ofArrows (fun x => Xs) fun x => F)
R : ExtrDisc
g : R ⟶ Y
W : ExtrDisc
σ : W ⟶ Y
ψ : R ⟶ ∐ fun i => Xmap i
hW' : ψ ≫ Sigma.desc f = g
⊢ Coverage.saturate
(ExtensiveRegularCoverage ExtrDisc everything_proj
(_ :
∀ {α : Type} [inst : Fintype α] {X : ExtrDisc} {Z : α → ExtrDisc} (π : (a : α) → Z a ⟶ X) {Y : ExtrDisc}
(f : Y ⟶ X) (x : IsIso (Sigma.desc π)), IsIso (Sigma.desc fun x_1 => Limits.pullback.fst)))
R (Sieve.pullback ψ (Sieve.pullback (Sigma.desc f) Z)) | case h.h.h.mpr.of.intro.intro.intro.intro.intro.a.intro.intro.intro.intro.mk
X : ExtrDisc
S : Sieve X
Y : ExtrDisc
T : Presieve Y
I : Type
hI : Fintype I
Xmap : I → ExtrDisc
f : (a : I) → Xmap a ⟶ Y
h : T = ofArrows Xmap f
hT : Epi (Sigma.desc f)
he : EffectiveEpiFamily Xmap f ↔ Epi (Sigma.desc f)
φ : (i : I) → Xmap i ⟶ ∐ Xmap := fun i => Sigma.ι Xmap i
F : (∐ fun b => Xmap b) ⟶ Y := Sigma.desc f
Z : Sieve Y := Sieve.generate T
Xs : ExtrDisc := ∐ fun i => Xmap i
Zf : Sieve Y := Sieve.generate (ofArrows (fun x => Xs) fun x => F)
R : ExtrDisc
g : R ⟶ Y
W : ExtrDisc
σ : W ⟶ Y
ψ : R ⟶ ∐ fun i => Xmap i
hW' : ψ ≫ Sigma.desc f = g
this :
Sieve.pullback ψ (Sieve.pullback F Z) ∈
GrothendieckTopology.sieves
(Coverage.toGrothendieck ExtrDisc (ExtensiveRegularCoverage ExtrDisc ?m.558302 ?m.558303)) R
⊢ Coverage.saturate
(ExtensiveRegularCoverage ExtrDisc everything_proj
(_ :
∀ {α : Type} [inst : Fintype α] {X : ExtrDisc} {Z : α → ExtrDisc} (π : (a : α) → Z a ⟶ X) {Y : ExtrDisc}
(f : Y ⟶ X) (x : IsIso (Sigma.desc π)), IsIso (Sigma.desc fun x_1 => Limits.pullback.fst)))
R (Sieve.pullback ψ (Sieve.pullback (Sigma.desc f) Z))
case this
X : ExtrDisc
S : Sieve X
Y : ExtrDisc
T : Presieve Y
I : Type
hI : Fintype I
Xmap : I → ExtrDisc
f : (a : I) → Xmap a ⟶ Y
h : T = ofArrows Xmap f
hT : Epi (Sigma.desc f)
he : EffectiveEpiFamily Xmap f ↔ Epi (Sigma.desc f)
φ : (i : I) → Xmap i ⟶ ∐ Xmap := fun i => Sigma.ι Xmap i
F : (∐ fun b => Xmap b) ⟶ Y := Sigma.desc f
Z : Sieve Y := Sieve.generate T
Xs : ExtrDisc := ∐ fun i => Xmap i
Zf : Sieve Y := Sieve.generate (ofArrows (fun x => Xs) fun x => F)
R : ExtrDisc
g : R ⟶ Y
W : ExtrDisc
σ : W ⟶ Y
ψ : R ⟶ ∐ fun i => Xmap i
hW' : ψ ≫ Sigma.desc f = g
⊢ Sieve.pullback ψ (Sieve.pullback F Z) ∈
GrothendieckTopology.sieves
(Coverage.toGrothendieck ExtrDisc (ExtensiveRegularCoverage ExtrDisc ?m.558302 ?m.558303)) R | Please generate a tactic in lean4 to solve the state.
STATE:
case h.h.h.mpr.of.intro.intro.intro.intro.intro.a.intro.intro.intro.intro.mk
X : ExtrDisc
S : Sieve X
Y : ExtrDisc
T : Presieve Y
I : Type
hI : Fintype I
Xmap : I → ExtrDisc
f : (a : I) → Xmap a ⟶ Y
h : T = ofArrows Xmap f
hT : Epi (Sigma.desc f)
he : EffectiveEpiFamily Xmap f ↔ Epi (Sigma.desc f)
φ : (i : I) → Xmap i ⟶ ∐ Xmap := fun i => Sigma.ι Xmap i
F : (∐ fun b => Xmap b) ⟶ Y := Sigma.desc f
Z : Sieve Y := Sieve.generate T
Xs : ExtrDisc := ∐ fun i => Xmap i
Zf : Sieve Y := Sieve.generate (ofArrows (fun x => Xs) fun x => F)
R : ExtrDisc
g : R ⟶ Y
W : ExtrDisc
σ : W ⟶ Y
ψ : R ⟶ ∐ fun i => Xmap i
hW' : ψ ≫ Sigma.desc f = g
⊢ Coverage.saturate
(ExtensiveRegularCoverage ExtrDisc everything_proj
(_ :
∀ {α : Type} [inst : Fintype α] {X : ExtrDisc} {Z : α → ExtrDisc} (π : (a : α) → Z a ⟶ X) {Y : ExtrDisc}
(f : Y ⟶ X) (x : IsIso (Sigma.desc π)), IsIso (Sigma.desc fun x_1 => Limits.pullback.fst)))
R (Sieve.pullback ψ (Sieve.pullback (Sigma.desc f) Z))
TACTIC:
|
https://github.com/adamtopaz/CopenhagenMasterclass2023.git | a293ca1554f7e80d891fd4d86fb092c54d8a0a01 | ExtrDisc/ExplicitSheaves.lean | ExtrDisc.extensiveRegular_generates_coherent | [108, 1] | [217, 21] | apply GrothendieckTopology.pullback_stable' | case this
X : ExtrDisc
S : Sieve X
Y : ExtrDisc
T : Presieve Y
I : Type
hI : Fintype I
Xmap : I → ExtrDisc
f : (a : I) → Xmap a ⟶ Y
h : T = ofArrows Xmap f
hT : Epi (Sigma.desc f)
he : EffectiveEpiFamily Xmap f ↔ Epi (Sigma.desc f)
φ : (i : I) → Xmap i ⟶ ∐ Xmap := fun i => Sigma.ι Xmap i
F : (∐ fun b => Xmap b) ⟶ Y := Sigma.desc f
Z : Sieve Y := Sieve.generate T
Xs : ExtrDisc := ∐ fun i => Xmap i
Zf : Sieve Y := Sieve.generate (ofArrows (fun x => Xs) fun x => F)
R : ExtrDisc
g : R ⟶ Y
W : ExtrDisc
σ : W ⟶ Y
ψ : R ⟶ ∐ fun i => Xmap i
hW' : ψ ≫ Sigma.desc f = g
⊢ Sieve.pullback ψ (Sieve.pullback F Z) ∈
GrothendieckTopology.sieves
(Coverage.toGrothendieck ExtrDisc
(ExtensiveRegularCoverage ExtrDisc everything_proj
(_ :
∀ {α : Type} [inst : Fintype α] {X : ExtrDisc} {Z : α → ExtrDisc} (π : (a : α) → Z a ⟶ X) {Y : ExtrDisc}
(f : Y ⟶ X) (x : IsIso (Sigma.desc π)), IsIso (Sigma.desc fun x_1 => Limits.pullback.fst))))
R | case this.a
X : ExtrDisc
S : Sieve X
Y : ExtrDisc
T : Presieve Y
I : Type
hI : Fintype I
Xmap : I → ExtrDisc
f : (a : I) → Xmap a ⟶ Y
h : T = ofArrows Xmap f
hT : Epi (Sigma.desc f)
he : EffectiveEpiFamily Xmap f ↔ Epi (Sigma.desc f)
φ : (i : I) → Xmap i ⟶ ∐ Xmap := fun i => Sigma.ι Xmap i
F : (∐ fun b => Xmap b) ⟶ Y := Sigma.desc f
Z : Sieve Y := Sieve.generate T
Xs : ExtrDisc := ∐ fun i => Xmap i
Zf : Sieve Y := Sieve.generate (ofArrows (fun x => Xs) fun x => F)
R : ExtrDisc
g : R ⟶ Y
W : ExtrDisc
σ : W ⟶ Y
ψ : R ⟶ ∐ fun i => Xmap i
hW' : ψ ≫ Sigma.desc f = g
⊢ Sieve.pullback F Z ∈
GrothendieckTopology.sieves
(Coverage.toGrothendieck ExtrDisc
(ExtensiveRegularCoverage ExtrDisc everything_proj
(_ :
∀ {α : Type} [inst : Fintype α] {X : ExtrDisc} {Z : α → ExtrDisc} (π : (a : α) → Z a ⟶ X) {Y : ExtrDisc}
(f : Y ⟶ X) (x : IsIso (Sigma.desc π)), IsIso (Sigma.desc fun x_1 => Limits.pullback.fst))))
(∐ fun i => Xmap i) | Please generate a tactic in lean4 to solve the state.
STATE:
case this
X : ExtrDisc
S : Sieve X
Y : ExtrDisc
T : Presieve Y
I : Type
hI : Fintype I
Xmap : I → ExtrDisc
f : (a : I) → Xmap a ⟶ Y
h : T = ofArrows Xmap f
hT : Epi (Sigma.desc f)
he : EffectiveEpiFamily Xmap f ↔ Epi (Sigma.desc f)
φ : (i : I) → Xmap i ⟶ ∐ Xmap := fun i => Sigma.ι Xmap i
F : (∐ fun b => Xmap b) ⟶ Y := Sigma.desc f
Z : Sieve Y := Sieve.generate T
Xs : ExtrDisc := ∐ fun i => Xmap i
Zf : Sieve Y := Sieve.generate (ofArrows (fun x => Xs) fun x => F)
R : ExtrDisc
g : R ⟶ Y
W : ExtrDisc
σ : W ⟶ Y
ψ : R ⟶ ∐ fun i => Xmap i
hW' : ψ ≫ Sigma.desc f = g
⊢ Sieve.pullback ψ (Sieve.pullback F Z) ∈
GrothendieckTopology.sieves
(Coverage.toGrothendieck ExtrDisc
(ExtensiveRegularCoverage ExtrDisc everything_proj
(_ :
∀ {α : Type} [inst : Fintype α] {X : ExtrDisc} {Z : α → ExtrDisc} (π : (a : α) → Z a ⟶ X) {Y : ExtrDisc}
(f : Y ⟶ X) (x : IsIso (Sigma.desc π)), IsIso (Sigma.desc fun x_1 => Limits.pullback.fst))))
R
TACTIC:
|
https://github.com/adamtopaz/CopenhagenMasterclass2023.git | a293ca1554f7e80d891fd4d86fb092c54d8a0a01 | ExtrDisc/ExplicitSheaves.lean | ExtrDisc.extensiveRegular_generates_coherent | [108, 1] | [217, 21] | dsimp [Coverage.toGrothendieck] | case this.a
X : ExtrDisc
S : Sieve X
Y : ExtrDisc
T : Presieve Y
I : Type
hI : Fintype I
Xmap : I → ExtrDisc
f : (a : I) → Xmap a ⟶ Y
h : T = ofArrows Xmap f
hT : Epi (Sigma.desc f)
he : EffectiveEpiFamily Xmap f ↔ Epi (Sigma.desc f)
φ : (i : I) → Xmap i ⟶ ∐ Xmap := fun i => Sigma.ι Xmap i
F : (∐ fun b => Xmap b) ⟶ Y := Sigma.desc f
Z : Sieve Y := Sieve.generate T
Xs : ExtrDisc := ∐ fun i => Xmap i
Zf : Sieve Y := Sieve.generate (ofArrows (fun x => Xs) fun x => F)
R : ExtrDisc
g : R ⟶ Y
W : ExtrDisc
σ : W ⟶ Y
ψ : R ⟶ ∐ fun i => Xmap i
hW' : ψ ≫ Sigma.desc f = g
⊢ Sieve.pullback F Z ∈
GrothendieckTopology.sieves
(Coverage.toGrothendieck ExtrDisc
(ExtensiveRegularCoverage ExtrDisc everything_proj
(_ :
∀ {α : Type} [inst : Fintype α] {X : ExtrDisc} {Z : α → ExtrDisc} (π : (a : α) → Z a ⟶ X) {Y : ExtrDisc}
(f : Y ⟶ X) (x : IsIso (Sigma.desc π)), IsIso (Sigma.desc fun x_1 => Limits.pullback.fst))))
(∐ fun i => Xmap i) | case this.a
X : ExtrDisc
S : Sieve X
Y : ExtrDisc
T : Presieve Y
I : Type
hI : Fintype I
Xmap : I → ExtrDisc
f : (a : I) → Xmap a ⟶ Y
h : T = ofArrows Xmap f
hT : Epi (Sigma.desc f)
he : EffectiveEpiFamily Xmap f ↔ Epi (Sigma.desc f)
φ : (i : I) → Xmap i ⟶ ∐ Xmap := fun i => Sigma.ι Xmap i
F : (∐ fun b => Xmap b) ⟶ Y := Sigma.desc f
Z : Sieve Y := Sieve.generate T
Xs : ExtrDisc := ∐ fun i => Xmap i
Zf : Sieve Y := Sieve.generate (ofArrows (fun x => Xs) fun x => F)
R : ExtrDisc
g : R ⟶ Y
W : ExtrDisc
σ : W ⟶ Y
ψ : R ⟶ ∐ fun i => Xmap i
hW' : ψ ≫ Sigma.desc f = g
⊢ Sieve.pullback (Sigma.desc f) (Sieve.generate T) ∈
Coverage.saturate
(ExtensiveRegularCoverage ExtrDisc everything_proj
(_ :
∀ {α : Type} [inst : Fintype α] {X : ExtrDisc} {Z : α → ExtrDisc} (π : (a : α) → Z a ⟶ X) {Y : ExtrDisc}
(f : Y ⟶ X) (x : IsIso (Sigma.desc π)), IsIso (Sigma.desc fun x_1 => Limits.pullback.fst)))
(∐ fun i => Xmap i) | Please generate a tactic in lean4 to solve the state.
STATE:
case this.a
X : ExtrDisc
S : Sieve X
Y : ExtrDisc
T : Presieve Y
I : Type
hI : Fintype I
Xmap : I → ExtrDisc
f : (a : I) → Xmap a ⟶ Y
h : T = ofArrows Xmap f
hT : Epi (Sigma.desc f)
he : EffectiveEpiFamily Xmap f ↔ Epi (Sigma.desc f)
φ : (i : I) → Xmap i ⟶ ∐ Xmap := fun i => Sigma.ι Xmap i
F : (∐ fun b => Xmap b) ⟶ Y := Sigma.desc f
Z : Sieve Y := Sieve.generate T
Xs : ExtrDisc := ∐ fun i => Xmap i
Zf : Sieve Y := Sieve.generate (ofArrows (fun x => Xs) fun x => F)
R : ExtrDisc
g : R ⟶ Y
W : ExtrDisc
σ : W ⟶ Y
ψ : R ⟶ ∐ fun i => Xmap i
hW' : ψ ≫ Sigma.desc f = g
⊢ Sieve.pullback F Z ∈
GrothendieckTopology.sieves
(Coverage.toGrothendieck ExtrDisc
(ExtensiveRegularCoverage ExtrDisc everything_proj
(_ :
∀ {α : Type} [inst : Fintype α] {X : ExtrDisc} {Z : α → ExtrDisc} (π : (a : α) → Z a ⟶ X) {Y : ExtrDisc}
(f : Y ⟶ X) (x : IsIso (Sigma.desc π)), IsIso (Sigma.desc fun x_1 => Limits.pullback.fst))))
(∐ fun i => Xmap i)
TACTIC:
|
https://github.com/adamtopaz/CopenhagenMasterclass2023.git | a293ca1554f7e80d891fd4d86fb092c54d8a0a01 | ExtrDisc/ExplicitSheaves.lean | ExtrDisc.extensiveRegular_generates_coherent | [108, 1] | [217, 21] | suffices : Coverage.saturate (ExtensiveRegularCoverage _ _ _) Xs (Z.pullback F) | case this.a
X : ExtrDisc
S : Sieve X
Y : ExtrDisc
T : Presieve Y
I : Type
hI : Fintype I
Xmap : I → ExtrDisc
f : (a : I) → Xmap a ⟶ Y
h : T = ofArrows Xmap f
hT : Epi (Sigma.desc f)
he : EffectiveEpiFamily Xmap f ↔ Epi (Sigma.desc f)
φ : (i : I) → Xmap i ⟶ ∐ Xmap := fun i => Sigma.ι Xmap i
F : (∐ fun b => Xmap b) ⟶ Y := Sigma.desc f
Z : Sieve Y := Sieve.generate T
Xs : ExtrDisc := ∐ fun i => Xmap i
Zf : Sieve Y := Sieve.generate (ofArrows (fun x => Xs) fun x => F)
R : ExtrDisc
g : R ⟶ Y
W : ExtrDisc
σ : W ⟶ Y
ψ : R ⟶ ∐ fun i => Xmap i
hW' : ψ ≫ Sigma.desc f = g
⊢ Sieve.pullback (Sigma.desc f) (Sieve.generate T) ∈
Coverage.saturate
(ExtensiveRegularCoverage ExtrDisc everything_proj
(_ :
∀ {α : Type} [inst : Fintype α] {X : ExtrDisc} {Z : α → ExtrDisc} (π : (a : α) → Z a ⟶ X) {Y : ExtrDisc}
(f : Y ⟶ X) (x : IsIso (Sigma.desc π)), IsIso (Sigma.desc fun x_1 => Limits.pullback.fst)))
(∐ fun i => Xmap i) | case this.a
X : ExtrDisc
S : Sieve X
Y : ExtrDisc
T : Presieve Y
I : Type
hI : Fintype I
Xmap : I → ExtrDisc
f : (a : I) → Xmap a ⟶ Y
h : T = ofArrows Xmap f
hT : Epi (Sigma.desc f)
he : EffectiveEpiFamily Xmap f ↔ Epi (Sigma.desc f)
φ : (i : I) → Xmap i ⟶ ∐ Xmap := fun i => Sigma.ι Xmap i
F : (∐ fun b => Xmap b) ⟶ Y := Sigma.desc f
Z : Sieve Y := Sieve.generate T
Xs : ExtrDisc := ∐ fun i => Xmap i
Zf : Sieve Y := Sieve.generate (ofArrows (fun x => Xs) fun x => F)
R : ExtrDisc
g : R ⟶ Y
W : ExtrDisc
σ : W ⟶ Y
ψ : R ⟶ ∐ fun i => Xmap i
hW' : ψ ≫ Sigma.desc f = g
this : Coverage.saturate (ExtensiveRegularCoverage ExtrDisc ?m.558925 ?m.558926) Xs (Sieve.pullback F Z)
⊢ Sieve.pullback (Sigma.desc f) (Sieve.generate T) ∈
Coverage.saturate
(ExtensiveRegularCoverage ExtrDisc everything_proj
(_ :
∀ {α : Type} [inst : Fintype α] {X : ExtrDisc} {Z : α → ExtrDisc} (π : (a : α) → Z a ⟶ X) {Y : ExtrDisc}
(f : Y ⟶ X) (x : IsIso (Sigma.desc π)), IsIso (Sigma.desc fun x_1 => Limits.pullback.fst)))
(∐ fun i => Xmap i)
case this
X : ExtrDisc
S : Sieve X
Y : ExtrDisc
T : Presieve Y
I : Type
hI : Fintype I
Xmap : I → ExtrDisc
f : (a : I) → Xmap a ⟶ Y
h : T = ofArrows Xmap f
hT : Epi (Sigma.desc f)
he : EffectiveEpiFamily Xmap f ↔ Epi (Sigma.desc f)
φ : (i : I) → Xmap i ⟶ ∐ Xmap := fun i => Sigma.ι Xmap i
F : (∐ fun b => Xmap b) ⟶ Y := Sigma.desc f
Z : Sieve Y := Sieve.generate T
Xs : ExtrDisc := ∐ fun i => Xmap i
Zf : Sieve Y := Sieve.generate (ofArrows (fun x => Xs) fun x => F)
R : ExtrDisc
g : R ⟶ Y
W : ExtrDisc
σ : W ⟶ Y
ψ : R ⟶ ∐ fun i => Xmap i
hW' : ψ ≫ Sigma.desc f = g
⊢ Coverage.saturate (ExtensiveRegularCoverage ExtrDisc ?m.558925 ?m.558926) Xs (Sieve.pullback F Z) | Please generate a tactic in lean4 to solve the state.
STATE:
case this.a
X : ExtrDisc
S : Sieve X
Y : ExtrDisc
T : Presieve Y
I : Type
hI : Fintype I
Xmap : I → ExtrDisc
f : (a : I) → Xmap a ⟶ Y
h : T = ofArrows Xmap f
hT : Epi (Sigma.desc f)
he : EffectiveEpiFamily Xmap f ↔ Epi (Sigma.desc f)
φ : (i : I) → Xmap i ⟶ ∐ Xmap := fun i => Sigma.ι Xmap i
F : (∐ fun b => Xmap b) ⟶ Y := Sigma.desc f
Z : Sieve Y := Sieve.generate T
Xs : ExtrDisc := ∐ fun i => Xmap i
Zf : Sieve Y := Sieve.generate (ofArrows (fun x => Xs) fun x => F)
R : ExtrDisc
g : R ⟶ Y
W : ExtrDisc
σ : W ⟶ Y
ψ : R ⟶ ∐ fun i => Xmap i
hW' : ψ ≫ Sigma.desc f = g
⊢ Sieve.pullback (Sigma.desc f) (Sieve.generate T) ∈
Coverage.saturate
(ExtensiveRegularCoverage ExtrDisc everything_proj
(_ :
∀ {α : Type} [inst : Fintype α] {X : ExtrDisc} {Z : α → ExtrDisc} (π : (a : α) → Z a ⟶ X) {Y : ExtrDisc}
(f : Y ⟶ X) (x : IsIso (Sigma.desc π)), IsIso (Sigma.desc fun x_1 => Limits.pullback.fst)))
(∐ fun i => Xmap i)
TACTIC:
|
https://github.com/adamtopaz/CopenhagenMasterclass2023.git | a293ca1554f7e80d891fd4d86fb092c54d8a0a01 | ExtrDisc/ExplicitSheaves.lean | ExtrDisc.extensiveRegular_generates_coherent | [108, 1] | [217, 21] | suffices : Sieve.generate (Presieve.ofArrows Xmap φ) ≤ Z.pullback F | case this
X : ExtrDisc
S : Sieve X
Y : ExtrDisc
T : Presieve Y
I : Type
hI : Fintype I
Xmap : I → ExtrDisc
f : (a : I) → Xmap a ⟶ Y
h : T = ofArrows Xmap f
hT : Epi (Sigma.desc f)
he : EffectiveEpiFamily Xmap f ↔ Epi (Sigma.desc f)
φ : (i : I) → Xmap i ⟶ ∐ Xmap := fun i => Sigma.ι Xmap i
F : (∐ fun b => Xmap b) ⟶ Y := Sigma.desc f
Z : Sieve Y := Sieve.generate T
Xs : ExtrDisc := ∐ fun i => Xmap i
Zf : Sieve Y := Sieve.generate (ofArrows (fun x => Xs) fun x => F)
R : ExtrDisc
g : R ⟶ Y
W : ExtrDisc
σ : W ⟶ Y
ψ : R ⟶ ∐ fun i => Xmap i
hW' : ψ ≫ Sigma.desc f = g
⊢ Coverage.saturate
(ExtensiveRegularCoverage ExtrDisc everything_proj
(_ :
∀ {α : Type} [inst : Fintype α] {X : ExtrDisc} {Z : α → ExtrDisc} (π : (a : α) → Z a ⟶ X) {Y : ExtrDisc}
(f : Y ⟶ X) (x : IsIso (Sigma.desc π)), IsIso (Sigma.desc fun x_1 => Limits.pullback.fst)))
Xs (Sieve.pullback F Z) | case this
X : ExtrDisc
S : Sieve X
Y : ExtrDisc
T : Presieve Y
I : Type
hI : Fintype I
Xmap : I → ExtrDisc
f : (a : I) → Xmap a ⟶ Y
h : T = ofArrows Xmap f
hT : Epi (Sigma.desc f)
he : EffectiveEpiFamily Xmap f ↔ Epi (Sigma.desc f)
φ : (i : I) → Xmap i ⟶ ∐ Xmap := fun i => Sigma.ι Xmap i
F : (∐ fun b => Xmap b) ⟶ Y := Sigma.desc f
Z : Sieve Y := Sieve.generate T
Xs : ExtrDisc := ∐ fun i => Xmap i
Zf : Sieve Y := Sieve.generate (ofArrows (fun x => Xs) fun x => F)
R : ExtrDisc
g : R ⟶ Y
W : ExtrDisc
σ : W ⟶ Y
ψ : R ⟶ ∐ fun i => Xmap i
hW' : ψ ≫ Sigma.desc f = g
this : Sieve.generate (ofArrows Xmap φ) ≤ Sieve.pullback F Z
⊢ Coverage.saturate
(ExtensiveRegularCoverage ExtrDisc everything_proj
(_ :
∀ {α : Type} [inst : Fintype α] {X : ExtrDisc} {Z : α → ExtrDisc} (π : (a : α) → Z a ⟶ X) {Y : ExtrDisc}
(f : Y ⟶ X) (x : IsIso (Sigma.desc π)), IsIso (Sigma.desc fun x_1 => Limits.pullback.fst)))
Xs (Sieve.pullback F Z)
case this
X : ExtrDisc
S : Sieve X
Y : ExtrDisc
T : Presieve Y
I : Type
hI : Fintype I
Xmap : I → ExtrDisc
f : (a : I) → Xmap a ⟶ Y
h : T = ofArrows Xmap f
hT : Epi (Sigma.desc f)
he : EffectiveEpiFamily Xmap f ↔ Epi (Sigma.desc f)
φ : (i : I) → Xmap i ⟶ ∐ Xmap := fun i => Sigma.ι Xmap i
F : (∐ fun b => Xmap b) ⟶ Y := Sigma.desc f
Z : Sieve Y := Sieve.generate T
Xs : ExtrDisc := ∐ fun i => Xmap i
Zf : Sieve Y := Sieve.generate (ofArrows (fun x => Xs) fun x => F)
R : ExtrDisc
g : R ⟶ Y
W : ExtrDisc
σ : W ⟶ Y
ψ : R ⟶ ∐ fun i => Xmap i
hW' : ψ ≫ Sigma.desc f = g
⊢ Sieve.generate (ofArrows Xmap φ) ≤ Sieve.pullback F Z | Please generate a tactic in lean4 to solve the state.
STATE:
case this
X : ExtrDisc
S : Sieve X
Y : ExtrDisc
T : Presieve Y
I : Type
hI : Fintype I
Xmap : I → ExtrDisc
f : (a : I) → Xmap a ⟶ Y
h : T = ofArrows Xmap f
hT : Epi (Sigma.desc f)
he : EffectiveEpiFamily Xmap f ↔ Epi (Sigma.desc f)
φ : (i : I) → Xmap i ⟶ ∐ Xmap := fun i => Sigma.ι Xmap i
F : (∐ fun b => Xmap b) ⟶ Y := Sigma.desc f
Z : Sieve Y := Sieve.generate T
Xs : ExtrDisc := ∐ fun i => Xmap i
Zf : Sieve Y := Sieve.generate (ofArrows (fun x => Xs) fun x => F)
R : ExtrDisc
g : R ⟶ Y
W : ExtrDisc
σ : W ⟶ Y
ψ : R ⟶ ∐ fun i => Xmap i
hW' : ψ ≫ Sigma.desc f = g
⊢ Coverage.saturate
(ExtensiveRegularCoverage ExtrDisc everything_proj
(_ :
∀ {α : Type} [inst : Fintype α] {X : ExtrDisc} {Z : α → ExtrDisc} (π : (a : α) → Z a ⟶ X) {Y : ExtrDisc}
(f : Y ⟶ X) (x : IsIso (Sigma.desc π)), IsIso (Sigma.desc fun x_1 => Limits.pullback.fst)))
Xs (Sieve.pullback F Z)
TACTIC:
|
https://github.com/adamtopaz/CopenhagenMasterclass2023.git | a293ca1554f7e80d891fd4d86fb092c54d8a0a01 | ExtrDisc/ExplicitSheaves.lean | ExtrDisc.extensiveRegular_generates_coherent | [108, 1] | [217, 21] | intro Q q hq | case this
X : ExtrDisc
S : Sieve X
Y : ExtrDisc
T : Presieve Y
I : Type
hI : Fintype I
Xmap : I → ExtrDisc
f : (a : I) → Xmap a ⟶ Y
h : T = ofArrows Xmap f
hT : Epi (Sigma.desc f)
he : EffectiveEpiFamily Xmap f ↔ Epi (Sigma.desc f)
φ : (i : I) → Xmap i ⟶ ∐ Xmap := fun i => Sigma.ι Xmap i
F : (∐ fun b => Xmap b) ⟶ Y := Sigma.desc f
Z : Sieve Y := Sieve.generate T
Xs : ExtrDisc := ∐ fun i => Xmap i
Zf : Sieve Y := Sieve.generate (ofArrows (fun x => Xs) fun x => F)
R : ExtrDisc
g : R ⟶ Y
W : ExtrDisc
σ : W ⟶ Y
ψ : R ⟶ ∐ fun i => Xmap i
hW' : ψ ≫ Sigma.desc f = g
⊢ Sieve.generate (ofArrows Xmap φ) ≤ Sieve.pullback F Z | case this
X : ExtrDisc
S : Sieve X
Y : ExtrDisc
T : Presieve Y
I : Type
hI : Fintype I
Xmap : I → ExtrDisc
f : (a : I) → Xmap a ⟶ Y
h : T = ofArrows Xmap f
hT : Epi (Sigma.desc f)
he : EffectiveEpiFamily Xmap f ↔ Epi (Sigma.desc f)
φ : (i : I) → Xmap i ⟶ ∐ Xmap := fun i => Sigma.ι Xmap i
F : (∐ fun b => Xmap b) ⟶ Y := Sigma.desc f
Z : Sieve Y := Sieve.generate T
Xs : ExtrDisc := ∐ fun i => Xmap i
Zf : Sieve Y := Sieve.generate (ofArrows (fun x => Xs) fun x => F)
R : ExtrDisc
g : R ⟶ Y
W : ExtrDisc
σ : W ⟶ Y
ψ : R ⟶ ∐ fun i => Xmap i
hW' : ψ ≫ Sigma.desc f = g
Q : ExtrDisc
q : Q ⟶ ∐ Xmap
hq : (Sieve.generate (ofArrows Xmap φ)).arrows q
⊢ (Sieve.pullback F Z).arrows q | Please generate a tactic in lean4 to solve the state.
STATE:
case this
X : ExtrDisc
S : Sieve X
Y : ExtrDisc
T : Presieve Y
I : Type
hI : Fintype I
Xmap : I → ExtrDisc
f : (a : I) → Xmap a ⟶ Y
h : T = ofArrows Xmap f
hT : Epi (Sigma.desc f)
he : EffectiveEpiFamily Xmap f ↔ Epi (Sigma.desc f)
φ : (i : I) → Xmap i ⟶ ∐ Xmap := fun i => Sigma.ι Xmap i
F : (∐ fun b => Xmap b) ⟶ Y := Sigma.desc f
Z : Sieve Y := Sieve.generate T
Xs : ExtrDisc := ∐ fun i => Xmap i
Zf : Sieve Y := Sieve.generate (ofArrows (fun x => Xs) fun x => F)
R : ExtrDisc
g : R ⟶ Y
W : ExtrDisc
σ : W ⟶ Y
ψ : R ⟶ ∐ fun i => Xmap i
hW' : ψ ≫ Sigma.desc f = g
⊢ Sieve.generate (ofArrows Xmap φ) ≤ Sieve.pullback F Z
TACTIC:
|
https://github.com/adamtopaz/CopenhagenMasterclass2023.git | a293ca1554f7e80d891fd4d86fb092c54d8a0a01 | ExtrDisc/ExplicitSheaves.lean | ExtrDisc.extensiveRegular_generates_coherent | [108, 1] | [217, 21] | simp only [Sieve.pullback_apply, Sieve.generate_apply] | case this
X : ExtrDisc
S : Sieve X
Y : ExtrDisc
T : Presieve Y
I : Type
hI : Fintype I
Xmap : I → ExtrDisc
f : (a : I) → Xmap a ⟶ Y
h : T = ofArrows Xmap f
hT : Epi (Sigma.desc f)
he : EffectiveEpiFamily Xmap f ↔ Epi (Sigma.desc f)
φ : (i : I) → Xmap i ⟶ ∐ Xmap := fun i => Sigma.ι Xmap i
F : (∐ fun b => Xmap b) ⟶ Y := Sigma.desc f
Z : Sieve Y := Sieve.generate T
Xs : ExtrDisc := ∐ fun i => Xmap i
Zf : Sieve Y := Sieve.generate (ofArrows (fun x => Xs) fun x => F)
R : ExtrDisc
g : R ⟶ Y
W : ExtrDisc
σ : W ⟶ Y
ψ : R ⟶ ∐ fun i => Xmap i
hW' : ψ ≫ Sigma.desc f = g
Q : ExtrDisc
q : Q ⟶ ∐ Xmap
hq : (Sieve.generate (ofArrows Xmap φ)).arrows q
⊢ (Sieve.pullback F Z).arrows q | case this
X : ExtrDisc
S : Sieve X
Y : ExtrDisc
T : Presieve Y
I : Type
hI : Fintype I
Xmap : I → ExtrDisc
f : (a : I) → Xmap a ⟶ Y
h : T = ofArrows Xmap f
hT : Epi (Sigma.desc f)
he : EffectiveEpiFamily Xmap f ↔ Epi (Sigma.desc f)
φ : (i : I) → Xmap i ⟶ ∐ Xmap := fun i => Sigma.ι Xmap i
F : (∐ fun b => Xmap b) ⟶ Y := Sigma.desc f
Z : Sieve Y := Sieve.generate T
Xs : ExtrDisc := ∐ fun i => Xmap i
Zf : Sieve Y := Sieve.generate (ofArrows (fun x => Xs) fun x => F)
R : ExtrDisc
g : R ⟶ Y
W : ExtrDisc
σ : W ⟶ Y
ψ : R ⟶ ∐ fun i => Xmap i
hW' : ψ ≫ Sigma.desc f = g
Q : ExtrDisc
q : Q ⟶ ∐ Xmap
hq : (Sieve.generate (ofArrows Xmap φ)).arrows q
⊢ ∃ Y_1 h g, T g ∧ h ≫ g = q ≫ Sigma.desc f | Please generate a tactic in lean4 to solve the state.
STATE:
case this
X : ExtrDisc
S : Sieve X
Y : ExtrDisc
T : Presieve Y
I : Type
hI : Fintype I
Xmap : I → ExtrDisc
f : (a : I) → Xmap a ⟶ Y
h : T = ofArrows Xmap f
hT : Epi (Sigma.desc f)
he : EffectiveEpiFamily Xmap f ↔ Epi (Sigma.desc f)
φ : (i : I) → Xmap i ⟶ ∐ Xmap := fun i => Sigma.ι Xmap i
F : (∐ fun b => Xmap b) ⟶ Y := Sigma.desc f
Z : Sieve Y := Sieve.generate T
Xs : ExtrDisc := ∐ fun i => Xmap i
Zf : Sieve Y := Sieve.generate (ofArrows (fun x => Xs) fun x => F)
R : ExtrDisc
g : R ⟶ Y
W : ExtrDisc
σ : W ⟶ Y
ψ : R ⟶ ∐ fun i => Xmap i
hW' : ψ ≫ Sigma.desc f = g
Q : ExtrDisc
q : Q ⟶ ∐ Xmap
hq : (Sieve.generate (ofArrows Xmap φ)).arrows q
⊢ (Sieve.pullback F Z).arrows q
TACTIC:
|
https://github.com/adamtopaz/CopenhagenMasterclass2023.git | a293ca1554f7e80d891fd4d86fb092c54d8a0a01 | ExtrDisc/ExplicitSheaves.lean | ExtrDisc.extensiveRegular_generates_coherent | [108, 1] | [217, 21] | simp only [Sieve.generate_apply] at hq | case this
X : ExtrDisc
S : Sieve X
Y : ExtrDisc
T : Presieve Y
I : Type
hI : Fintype I
Xmap : I → ExtrDisc
f : (a : I) → Xmap a ⟶ Y
h : T = ofArrows Xmap f
hT : Epi (Sigma.desc f)
he : EffectiveEpiFamily Xmap f ↔ Epi (Sigma.desc f)
φ : (i : I) → Xmap i ⟶ ∐ Xmap := fun i => Sigma.ι Xmap i
F : (∐ fun b => Xmap b) ⟶ Y := Sigma.desc f
Z : Sieve Y := Sieve.generate T
Xs : ExtrDisc := ∐ fun i => Xmap i
Zf : Sieve Y := Sieve.generate (ofArrows (fun x => Xs) fun x => F)
R : ExtrDisc
g : R ⟶ Y
W : ExtrDisc
σ : W ⟶ Y
ψ : R ⟶ ∐ fun i => Xmap i
hW' : ψ ≫ Sigma.desc f = g
Q : ExtrDisc
q : Q ⟶ ∐ Xmap
hq : (Sieve.generate (ofArrows Xmap φ)).arrows q
⊢ ∃ Y_1 h g, T g ∧ h ≫ g = q ≫ Sigma.desc f | case this
X : ExtrDisc
S : Sieve X
Y : ExtrDisc
T : Presieve Y
I : Type
hI : Fintype I
Xmap : I → ExtrDisc
f : (a : I) → Xmap a ⟶ Y
h : T = ofArrows Xmap f
hT : Epi (Sigma.desc f)
he : EffectiveEpiFamily Xmap f ↔ Epi (Sigma.desc f)
φ : (i : I) → Xmap i ⟶ ∐ Xmap := fun i => Sigma.ι Xmap i
F : (∐ fun b => Xmap b) ⟶ Y := Sigma.desc f
Z : Sieve Y := Sieve.generate T
Xs : ExtrDisc := ∐ fun i => Xmap i
Zf : Sieve Y := Sieve.generate (ofArrows (fun x => Xs) fun x => F)
R : ExtrDisc
g : R ⟶ Y
W : ExtrDisc
σ : W ⟶ Y
ψ : R ⟶ ∐ fun i => Xmap i
hW' : ψ ≫ Sigma.desc f = g
Q : ExtrDisc
q : Q ⟶ ∐ Xmap
hq : ∃ Y h g, ofArrows Xmap (fun i => Sigma.ι Xmap i) g ∧ h ≫ g = q
⊢ ∃ Y_1 h g, T g ∧ h ≫ g = q ≫ Sigma.desc f | Please generate a tactic in lean4 to solve the state.
STATE:
case this
X : ExtrDisc
S : Sieve X
Y : ExtrDisc
T : Presieve Y
I : Type
hI : Fintype I
Xmap : I → ExtrDisc
f : (a : I) → Xmap a ⟶ Y
h : T = ofArrows Xmap f
hT : Epi (Sigma.desc f)
he : EffectiveEpiFamily Xmap f ↔ Epi (Sigma.desc f)
φ : (i : I) → Xmap i ⟶ ∐ Xmap := fun i => Sigma.ι Xmap i
F : (∐ fun b => Xmap b) ⟶ Y := Sigma.desc f
Z : Sieve Y := Sieve.generate T
Xs : ExtrDisc := ∐ fun i => Xmap i
Zf : Sieve Y := Sieve.generate (ofArrows (fun x => Xs) fun x => F)
R : ExtrDisc
g : R ⟶ Y
W : ExtrDisc
σ : W ⟶ Y
ψ : R ⟶ ∐ fun i => Xmap i
hW' : ψ ≫ Sigma.desc f = g
Q : ExtrDisc
q : Q ⟶ ∐ Xmap
hq : (Sieve.generate (ofArrows Xmap φ)).arrows q
⊢ ∃ Y_1 h g, T g ∧ h ≫ g = q ≫ Sigma.desc f
TACTIC:
|
https://github.com/adamtopaz/CopenhagenMasterclass2023.git | a293ca1554f7e80d891fd4d86fb092c54d8a0a01 | ExtrDisc/ExplicitSheaves.lean | ExtrDisc.extensiveRegular_generates_coherent | [108, 1] | [217, 21] | obtain ⟨E, e, r, hq⟩ := hq | case this
X : ExtrDisc
S : Sieve X
Y : ExtrDisc
T : Presieve Y
I : Type
hI : Fintype I
Xmap : I → ExtrDisc
f : (a : I) → Xmap a ⟶ Y
h : T = ofArrows Xmap f
hT : Epi (Sigma.desc f)
he : EffectiveEpiFamily Xmap f ↔ Epi (Sigma.desc f)
φ : (i : I) → Xmap i ⟶ ∐ Xmap := fun i => Sigma.ι Xmap i
F : (∐ fun b => Xmap b) ⟶ Y := Sigma.desc f
Z : Sieve Y := Sieve.generate T
Xs : ExtrDisc := ∐ fun i => Xmap i
Zf : Sieve Y := Sieve.generate (ofArrows (fun x => Xs) fun x => F)
R : ExtrDisc
g : R ⟶ Y
W : ExtrDisc
σ : W ⟶ Y
ψ : R ⟶ ∐ fun i => Xmap i
hW' : ψ ≫ Sigma.desc f = g
Q : ExtrDisc
q : Q ⟶ ∐ Xmap
hq : ∃ Y h g, ofArrows Xmap (fun i => Sigma.ι Xmap i) g ∧ h ≫ g = q
⊢ ∃ Y_1 h g, T g ∧ h ≫ g = q ≫ Sigma.desc f | case this.intro.intro.intro
X : ExtrDisc
S : Sieve X
Y : ExtrDisc
T : Presieve Y
I : Type
hI : Fintype I
Xmap : I → ExtrDisc
f : (a : I) → Xmap a ⟶ Y
h : T = ofArrows Xmap f
hT : Epi (Sigma.desc f)
he : EffectiveEpiFamily Xmap f ↔ Epi (Sigma.desc f)
φ : (i : I) → Xmap i ⟶ ∐ Xmap := fun i => Sigma.ι Xmap i
F : (∐ fun b => Xmap b) ⟶ Y := Sigma.desc f
Z : Sieve Y := Sieve.generate T
Xs : ExtrDisc := ∐ fun i => Xmap i
Zf : Sieve Y := Sieve.generate (ofArrows (fun x => Xs) fun x => F)
R : ExtrDisc
g : R ⟶ Y
W : ExtrDisc
σ : W ⟶ Y
ψ : R ⟶ ∐ fun i => Xmap i
hW' : ψ ≫ Sigma.desc f = g
Q : ExtrDisc
q : Q ⟶ ∐ Xmap
E : ExtrDisc
e : Q ⟶ E
r : E ⟶ ∐ Xmap
hq : ofArrows Xmap (fun i => Sigma.ι Xmap i) r ∧ e ≫ r = q
⊢ ∃ Y_1 h g, T g ∧ h ≫ g = q ≫ Sigma.desc f | Please generate a tactic in lean4 to solve the state.
STATE:
case this
X : ExtrDisc
S : Sieve X
Y : ExtrDisc
T : Presieve Y
I : Type
hI : Fintype I
Xmap : I → ExtrDisc
f : (a : I) → Xmap a ⟶ Y
h : T = ofArrows Xmap f
hT : Epi (Sigma.desc f)
he : EffectiveEpiFamily Xmap f ↔ Epi (Sigma.desc f)
φ : (i : I) → Xmap i ⟶ ∐ Xmap := fun i => Sigma.ι Xmap i
F : (∐ fun b => Xmap b) ⟶ Y := Sigma.desc f
Z : Sieve Y := Sieve.generate T
Xs : ExtrDisc := ∐ fun i => Xmap i
Zf : Sieve Y := Sieve.generate (ofArrows (fun x => Xs) fun x => F)
R : ExtrDisc
g : R ⟶ Y
W : ExtrDisc
σ : W ⟶ Y
ψ : R ⟶ ∐ fun i => Xmap i
hW' : ψ ≫ Sigma.desc f = g
Q : ExtrDisc
q : Q ⟶ ∐ Xmap
hq : ∃ Y h g, ofArrows Xmap (fun i => Sigma.ι Xmap i) g ∧ h ≫ g = q
⊢ ∃ Y_1 h g, T g ∧ h ≫ g = q ≫ Sigma.desc f
TACTIC:
|
https://github.com/adamtopaz/CopenhagenMasterclass2023.git | a293ca1554f7e80d891fd4d86fb092c54d8a0a01 | ExtrDisc/ExplicitSheaves.lean | ExtrDisc.extensiveRegular_generates_coherent | [108, 1] | [217, 21] | refine' ⟨E, e, r ≫ F, ⟨_, _⟩⟩ | case this.intro.intro.intro
X : ExtrDisc
S : Sieve X
Y : ExtrDisc
T : Presieve Y
I : Type
hI : Fintype I
Xmap : I → ExtrDisc
f : (a : I) → Xmap a ⟶ Y
h : T = ofArrows Xmap f
hT : Epi (Sigma.desc f)
he : EffectiveEpiFamily Xmap f ↔ Epi (Sigma.desc f)
φ : (i : I) → Xmap i ⟶ ∐ Xmap := fun i => Sigma.ι Xmap i
F : (∐ fun b => Xmap b) ⟶ Y := Sigma.desc f
Z : Sieve Y := Sieve.generate T
Xs : ExtrDisc := ∐ fun i => Xmap i
Zf : Sieve Y := Sieve.generate (ofArrows (fun x => Xs) fun x => F)
R : ExtrDisc
g : R ⟶ Y
W : ExtrDisc
σ : W ⟶ Y
ψ : R ⟶ ∐ fun i => Xmap i
hW' : ψ ≫ Sigma.desc f = g
Q : ExtrDisc
q : Q ⟶ ∐ Xmap
E : ExtrDisc
e : Q ⟶ E
r : E ⟶ ∐ Xmap
hq : ofArrows Xmap (fun i => Sigma.ι Xmap i) r ∧ e ≫ r = q
⊢ ∃ Y_1 h g, T g ∧ h ≫ g = q ≫ Sigma.desc f | case this.intro.intro.intro.refine'_1
X : ExtrDisc
S : Sieve X
Y : ExtrDisc
T : Presieve Y
I : Type
hI : Fintype I
Xmap : I → ExtrDisc
f : (a : I) → Xmap a ⟶ Y
h : T = ofArrows Xmap f
hT : Epi (Sigma.desc f)
he : EffectiveEpiFamily Xmap f ↔ Epi (Sigma.desc f)
φ : (i : I) → Xmap i ⟶ ∐ Xmap := fun i => Sigma.ι Xmap i
F : (∐ fun b => Xmap b) ⟶ Y := Sigma.desc f
Z : Sieve Y := Sieve.generate T
Xs : ExtrDisc := ∐ fun i => Xmap i
Zf : Sieve Y := Sieve.generate (ofArrows (fun x => Xs) fun x => F)
R : ExtrDisc
g : R ⟶ Y
W : ExtrDisc
σ : W ⟶ Y
ψ : R ⟶ ∐ fun i => Xmap i
hW' : ψ ≫ Sigma.desc f = g
Q : ExtrDisc
q : Q ⟶ ∐ Xmap
E : ExtrDisc
e : Q ⟶ E
r : E ⟶ ∐ Xmap
hq : ofArrows Xmap (fun i => Sigma.ι Xmap i) r ∧ e ≫ r = q
⊢ T (r ≫ F)
case this.intro.intro.intro.refine'_2
X : ExtrDisc
S : Sieve X
Y : ExtrDisc
T : Presieve Y
I : Type
hI : Fintype I
Xmap : I → ExtrDisc
f : (a : I) → Xmap a ⟶ Y
h : T = ofArrows Xmap f
hT : Epi (Sigma.desc f)
he : EffectiveEpiFamily Xmap f ↔ Epi (Sigma.desc f)
φ : (i : I) → Xmap i ⟶ ∐ Xmap := fun i => Sigma.ι Xmap i
F : (∐ fun b => Xmap b) ⟶ Y := Sigma.desc f
Z : Sieve Y := Sieve.generate T
Xs : ExtrDisc := ∐ fun i => Xmap i
Zf : Sieve Y := Sieve.generate (ofArrows (fun x => Xs) fun x => F)
R : ExtrDisc
g : R ⟶ Y
W : ExtrDisc
σ : W ⟶ Y
ψ : R ⟶ ∐ fun i => Xmap i
hW' : ψ ≫ Sigma.desc f = g
Q : ExtrDisc
q : Q ⟶ ∐ Xmap
E : ExtrDisc
e : Q ⟶ E
r : E ⟶ ∐ Xmap
hq : ofArrows Xmap (fun i => Sigma.ι Xmap i) r ∧ e ≫ r = q
⊢ e ≫ r ≫ F = q ≫ Sigma.desc f | Please generate a tactic in lean4 to solve the state.
STATE:
case this.intro.intro.intro
X : ExtrDisc
S : Sieve X
Y : ExtrDisc
T : Presieve Y
I : Type
hI : Fintype I
Xmap : I → ExtrDisc
f : (a : I) → Xmap a ⟶ Y
h : T = ofArrows Xmap f
hT : Epi (Sigma.desc f)
he : EffectiveEpiFamily Xmap f ↔ Epi (Sigma.desc f)
φ : (i : I) → Xmap i ⟶ ∐ Xmap := fun i => Sigma.ι Xmap i
F : (∐ fun b => Xmap b) ⟶ Y := Sigma.desc f
Z : Sieve Y := Sieve.generate T
Xs : ExtrDisc := ∐ fun i => Xmap i
Zf : Sieve Y := Sieve.generate (ofArrows (fun x => Xs) fun x => F)
R : ExtrDisc
g : R ⟶ Y
W : ExtrDisc
σ : W ⟶ Y
ψ : R ⟶ ∐ fun i => Xmap i
hW' : ψ ≫ Sigma.desc f = g
Q : ExtrDisc
q : Q ⟶ ∐ Xmap
E : ExtrDisc
e : Q ⟶ E
r : E ⟶ ∐ Xmap
hq : ofArrows Xmap (fun i => Sigma.ι Xmap i) r ∧ e ≫ r = q
⊢ ∃ Y_1 h g, T g ∧ h ≫ g = q ≫ Sigma.desc f
TACTIC:
|
https://github.com/adamtopaz/CopenhagenMasterclass2023.git | a293ca1554f7e80d891fd4d86fb092c54d8a0a01 | ExtrDisc/ExplicitSheaves.lean | ExtrDisc.extensiveRegular_generates_coherent | [108, 1] | [217, 21] | exact this | case h.h.h.mpr.of.intro.intro.intro.intro.intro.a.intro.intro.intro.intro.mk
X : ExtrDisc
S : Sieve X
Y : ExtrDisc
T : Presieve Y
I : Type
hI : Fintype I
Xmap : I → ExtrDisc
f : (a : I) → Xmap a ⟶ Y
h : T = ofArrows Xmap f
hT : Epi (Sigma.desc f)
he : EffectiveEpiFamily Xmap f ↔ Epi (Sigma.desc f)
φ : (i : I) → Xmap i ⟶ ∐ Xmap := fun i => Sigma.ι Xmap i
F : (∐ fun b => Xmap b) ⟶ Y := Sigma.desc f
Z : Sieve Y := Sieve.generate T
Xs : ExtrDisc := ∐ fun i => Xmap i
Zf : Sieve Y := Sieve.generate (ofArrows (fun x => Xs) fun x => F)
R : ExtrDisc
g : R ⟶ Y
W : ExtrDisc
σ : W ⟶ Y
ψ : R ⟶ ∐ fun i => Xmap i
hW' : ψ ≫ Sigma.desc f = g
this :
Sieve.pullback ψ (Sieve.pullback F Z) ∈
GrothendieckTopology.sieves
(Coverage.toGrothendieck ExtrDisc (ExtensiveRegularCoverage ExtrDisc ?m.558302 ?m.558303)) R
⊢ Coverage.saturate
(ExtensiveRegularCoverage ExtrDisc everything_proj
(_ :
∀ {α : Type} [inst : Fintype α] {X : ExtrDisc} {Z : α → ExtrDisc} (π : (a : α) → Z a ⟶ X) {Y : ExtrDisc}
(f : Y ⟶ X) (x : IsIso (Sigma.desc π)), IsIso (Sigma.desc fun x_1 => Limits.pullback.fst)))
R (Sieve.pullback ψ (Sieve.pullback (Sigma.desc f) Z)) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case h.h.h.mpr.of.intro.intro.intro.intro.intro.a.intro.intro.intro.intro.mk
X : ExtrDisc
S : Sieve X
Y : ExtrDisc
T : Presieve Y
I : Type
hI : Fintype I
Xmap : I → ExtrDisc
f : (a : I) → Xmap a ⟶ Y
h : T = ofArrows Xmap f
hT : Epi (Sigma.desc f)
he : EffectiveEpiFamily Xmap f ↔ Epi (Sigma.desc f)
φ : (i : I) → Xmap i ⟶ ∐ Xmap := fun i => Sigma.ι Xmap i
F : (∐ fun b => Xmap b) ⟶ Y := Sigma.desc f
Z : Sieve Y := Sieve.generate T
Xs : ExtrDisc := ∐ fun i => Xmap i
Zf : Sieve Y := Sieve.generate (ofArrows (fun x => Xs) fun x => F)
R : ExtrDisc
g : R ⟶ Y
W : ExtrDisc
σ : W ⟶ Y
ψ : R ⟶ ∐ fun i => Xmap i
hW' : ψ ≫ Sigma.desc f = g
this :
Sieve.pullback ψ (Sieve.pullback F Z) ∈
GrothendieckTopology.sieves
(Coverage.toGrothendieck ExtrDisc (ExtensiveRegularCoverage ExtrDisc ?m.558302 ?m.558303)) R
⊢ Coverage.saturate
(ExtensiveRegularCoverage ExtrDisc everything_proj
(_ :
∀ {α : Type} [inst : Fintype α] {X : ExtrDisc} {Z : α → ExtrDisc} (π : (a : α) → Z a ⟶ X) {Y : ExtrDisc}
(f : Y ⟶ X) (x : IsIso (Sigma.desc π)), IsIso (Sigma.desc fun x_1 => Limits.pullback.fst)))
R (Sieve.pullback ψ (Sieve.pullback (Sigma.desc f) Z))
TACTIC:
|
https://github.com/adamtopaz/CopenhagenMasterclass2023.git | a293ca1554f7e80d891fd4d86fb092c54d8a0a01 | ExtrDisc/ExplicitSheaves.lean | ExtrDisc.extensiveRegular_generates_coherent | [108, 1] | [217, 21] | exact this | case this.a
X : ExtrDisc
S : Sieve X
Y : ExtrDisc
T : Presieve Y
I : Type
hI : Fintype I
Xmap : I → ExtrDisc
f : (a : I) → Xmap a ⟶ Y
h : T = ofArrows Xmap f
hT : Epi (Sigma.desc f)
he : EffectiveEpiFamily Xmap f ↔ Epi (Sigma.desc f)
φ : (i : I) → Xmap i ⟶ ∐ Xmap := fun i => Sigma.ι Xmap i
F : (∐ fun b => Xmap b) ⟶ Y := Sigma.desc f
Z : Sieve Y := Sieve.generate T
Xs : ExtrDisc := ∐ fun i => Xmap i
Zf : Sieve Y := Sieve.generate (ofArrows (fun x => Xs) fun x => F)
R : ExtrDisc
g : R ⟶ Y
W : ExtrDisc
σ : W ⟶ Y
ψ : R ⟶ ∐ fun i => Xmap i
hW' : ψ ≫ Sigma.desc f = g
this : Coverage.saturate (ExtensiveRegularCoverage ExtrDisc ?m.558925 ?m.558926) Xs (Sieve.pullback F Z)
⊢ Sieve.pullback (Sigma.desc f) (Sieve.generate T) ∈
Coverage.saturate
(ExtensiveRegularCoverage ExtrDisc everything_proj
(_ :
∀ {α : Type} [inst : Fintype α] {X : ExtrDisc} {Z : α → ExtrDisc} (π : (a : α) → Z a ⟶ X) {Y : ExtrDisc}
(f : Y ⟶ X) (x : IsIso (Sigma.desc π)), IsIso (Sigma.desc fun x_1 => Limits.pullback.fst)))
(∐ fun i => Xmap i) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case this.a
X : ExtrDisc
S : Sieve X
Y : ExtrDisc
T : Presieve Y
I : Type
hI : Fintype I
Xmap : I → ExtrDisc
f : (a : I) → Xmap a ⟶ Y
h : T = ofArrows Xmap f
hT : Epi (Sigma.desc f)
he : EffectiveEpiFamily Xmap f ↔ Epi (Sigma.desc f)
φ : (i : I) → Xmap i ⟶ ∐ Xmap := fun i => Sigma.ι Xmap i
F : (∐ fun b => Xmap b) ⟶ Y := Sigma.desc f
Z : Sieve Y := Sieve.generate T
Xs : ExtrDisc := ∐ fun i => Xmap i
Zf : Sieve Y := Sieve.generate (ofArrows (fun x => Xs) fun x => F)
R : ExtrDisc
g : R ⟶ Y
W : ExtrDisc
σ : W ⟶ Y
ψ : R ⟶ ∐ fun i => Xmap i
hW' : ψ ≫ Sigma.desc f = g
this : Coverage.saturate (ExtensiveRegularCoverage ExtrDisc ?m.558925 ?m.558926) Xs (Sieve.pullback F Z)
⊢ Sieve.pullback (Sigma.desc f) (Sieve.generate T) ∈
Coverage.saturate
(ExtensiveRegularCoverage ExtrDisc everything_proj
(_ :
∀ {α : Type} [inst : Fintype α] {X : ExtrDisc} {Z : α → ExtrDisc} (π : (a : α) → Z a ⟶ X) {Y : ExtrDisc}
(f : Y ⟶ X) (x : IsIso (Sigma.desc π)), IsIso (Sigma.desc fun x_1 => Limits.pullback.fst)))
(∐ fun i => Xmap i)
TACTIC:
|
https://github.com/adamtopaz/CopenhagenMasterclass2023.git | a293ca1554f7e80d891fd4d86fb092c54d8a0a01 | ExtrDisc/ExplicitSheaves.lean | ExtrDisc.extensiveRegular_generates_coherent | [108, 1] | [217, 21] | apply Coverage.saturate_of_superset _ this | case this
X : ExtrDisc
S : Sieve X
Y : ExtrDisc
T : Presieve Y
I : Type
hI : Fintype I
Xmap : I → ExtrDisc
f : (a : I) → Xmap a ⟶ Y
h : T = ofArrows Xmap f
hT : Epi (Sigma.desc f)
he : EffectiveEpiFamily Xmap f ↔ Epi (Sigma.desc f)
φ : (i : I) → Xmap i ⟶ ∐ Xmap := fun i => Sigma.ι Xmap i
F : (∐ fun b => Xmap b) ⟶ Y := Sigma.desc f
Z : Sieve Y := Sieve.generate T
Xs : ExtrDisc := ∐ fun i => Xmap i
Zf : Sieve Y := Sieve.generate (ofArrows (fun x => Xs) fun x => F)
R : ExtrDisc
g : R ⟶ Y
W : ExtrDisc
σ : W ⟶ Y
ψ : R ⟶ ∐ fun i => Xmap i
hW' : ψ ≫ Sigma.desc f = g
this : Sieve.generate (ofArrows Xmap φ) ≤ Sieve.pullback F Z
⊢ Coverage.saturate
(ExtensiveRegularCoverage ExtrDisc everything_proj
(_ :
∀ {α : Type} [inst : Fintype α] {X : ExtrDisc} {Z : α → ExtrDisc} (π : (a : α) → Z a ⟶ X) {Y : ExtrDisc}
(f : Y ⟶ X) (x : IsIso (Sigma.desc π)), IsIso (Sigma.desc fun x_1 => Limits.pullback.fst)))
Xs (Sieve.pullback F Z) | case this
X : ExtrDisc
S : Sieve X
Y : ExtrDisc
T : Presieve Y
I : Type
hI : Fintype I
Xmap : I → ExtrDisc
f : (a : I) → Xmap a ⟶ Y
h : T = ofArrows Xmap f
hT : Epi (Sigma.desc f)
he : EffectiveEpiFamily Xmap f ↔ Epi (Sigma.desc f)
φ : (i : I) → Xmap i ⟶ ∐ Xmap := fun i => Sigma.ι Xmap i
F : (∐ fun b => Xmap b) ⟶ Y := Sigma.desc f
Z : Sieve Y := Sieve.generate T
Xs : ExtrDisc := ∐ fun i => Xmap i
Zf : Sieve Y := Sieve.generate (ofArrows (fun x => Xs) fun x => F)
R : ExtrDisc
g : R ⟶ Y
W : ExtrDisc
σ : W ⟶ Y
ψ : R ⟶ ∐ fun i => Xmap i
hW' : ψ ≫ Sigma.desc f = g
this : Sieve.generate (ofArrows Xmap φ) ≤ Sieve.pullback F Z
⊢ Coverage.saturate
(ExtensiveRegularCoverage ExtrDisc everything_proj
(_ :
∀ {α : Type} [inst : Fintype α] {X : ExtrDisc} {Z : α → ExtrDisc} (π : (a : α) → Z a ⟶ X) {Y : ExtrDisc}
(f : Y ⟶ X) (x : IsIso (Sigma.desc π)), IsIso (Sigma.desc fun x_1 => Limits.pullback.fst)))
(∐ Xmap) (Sieve.generate (ofArrows Xmap φ)) | Please generate a tactic in lean4 to solve the state.
STATE:
case this
X : ExtrDisc
S : Sieve X
Y : ExtrDisc
T : Presieve Y
I : Type
hI : Fintype I
Xmap : I → ExtrDisc
f : (a : I) → Xmap a ⟶ Y
h : T = ofArrows Xmap f
hT : Epi (Sigma.desc f)
he : EffectiveEpiFamily Xmap f ↔ Epi (Sigma.desc f)
φ : (i : I) → Xmap i ⟶ ∐ Xmap := fun i => Sigma.ι Xmap i
F : (∐ fun b => Xmap b) ⟶ Y := Sigma.desc f
Z : Sieve Y := Sieve.generate T
Xs : ExtrDisc := ∐ fun i => Xmap i
Zf : Sieve Y := Sieve.generate (ofArrows (fun x => Xs) fun x => F)
R : ExtrDisc
g : R ⟶ Y
W : ExtrDisc
σ : W ⟶ Y
ψ : R ⟶ ∐ fun i => Xmap i
hW' : ψ ≫ Sigma.desc f = g
this : Sieve.generate (ofArrows Xmap φ) ≤ Sieve.pullback F Z
⊢ Coverage.saturate
(ExtensiveRegularCoverage ExtrDisc everything_proj
(_ :
∀ {α : Type} [inst : Fintype α] {X : ExtrDisc} {Z : α → ExtrDisc} (π : (a : α) → Z a ⟶ X) {Y : ExtrDisc}
(f : Y ⟶ X) (x : IsIso (Sigma.desc π)), IsIso (Sigma.desc fun x_1 => Limits.pullback.fst)))
Xs (Sieve.pullback F Z)
TACTIC:
|
https://github.com/adamtopaz/CopenhagenMasterclass2023.git | a293ca1554f7e80d891fd4d86fb092c54d8a0a01 | ExtrDisc/ExplicitSheaves.lean | ExtrDisc.extensiveRegular_generates_coherent | [108, 1] | [217, 21] | apply Coverage.saturate.of | case this
X : ExtrDisc
S : Sieve X
Y : ExtrDisc
T : Presieve Y
I : Type
hI : Fintype I
Xmap : I → ExtrDisc
f : (a : I) → Xmap a ⟶ Y
h : T = ofArrows Xmap f
hT : Epi (Sigma.desc f)
he : EffectiveEpiFamily Xmap f ↔ Epi (Sigma.desc f)
φ : (i : I) → Xmap i ⟶ ∐ Xmap := fun i => Sigma.ι Xmap i
F : (∐ fun b => Xmap b) ⟶ Y := Sigma.desc f
Z : Sieve Y := Sieve.generate T
Xs : ExtrDisc := ∐ fun i => Xmap i
Zf : Sieve Y := Sieve.generate (ofArrows (fun x => Xs) fun x => F)
R : ExtrDisc
g : R ⟶ Y
W : ExtrDisc
σ : W ⟶ Y
ψ : R ⟶ ∐ fun i => Xmap i
hW' : ψ ≫ Sigma.desc f = g
this : Sieve.generate (ofArrows Xmap φ) ≤ Sieve.pullback F Z
⊢ Coverage.saturate
(ExtensiveRegularCoverage ExtrDisc everything_proj
(_ :
∀ {α : Type} [inst : Fintype α] {X : ExtrDisc} {Z : α → ExtrDisc} (π : (a : α) → Z a ⟶ X) {Y : ExtrDisc}
(f : Y ⟶ X) (x : IsIso (Sigma.desc π)), IsIso (Sigma.desc fun x_1 => Limits.pullback.fst)))
(∐ Xmap) (Sieve.generate (ofArrows Xmap φ)) | case this.hS
X : ExtrDisc
S : Sieve X
Y : ExtrDisc
T : Presieve Y
I : Type
hI : Fintype I
Xmap : I → ExtrDisc
f : (a : I) → Xmap a ⟶ Y
h : T = ofArrows Xmap f
hT : Epi (Sigma.desc f)
he : EffectiveEpiFamily Xmap f ↔ Epi (Sigma.desc f)
φ : (i : I) → Xmap i ⟶ ∐ Xmap := fun i => Sigma.ι Xmap i
F : (∐ fun b => Xmap b) ⟶ Y := Sigma.desc f
Z : Sieve Y := Sieve.generate T
Xs : ExtrDisc := ∐ fun i => Xmap i
Zf : Sieve Y := Sieve.generate (ofArrows (fun x => Xs) fun x => F)
R : ExtrDisc
g : R ⟶ Y
W : ExtrDisc
σ : W ⟶ Y
ψ : R ⟶ ∐ fun i => Xmap i
hW' : ψ ≫ Sigma.desc f = g
this : Sieve.generate (ofArrows Xmap φ) ≤ Sieve.pullback F Z
⊢ ofArrows Xmap φ ∈
Coverage.covering
(ExtensiveRegularCoverage ExtrDisc everything_proj
(_ :
∀ {α : Type} [inst : Fintype α] {X : ExtrDisc} {Z : α → ExtrDisc} (π : (a : α) → Z a ⟶ X) {Y : ExtrDisc}
(f : Y ⟶ X) (x : IsIso (Sigma.desc π)), IsIso (Sigma.desc fun x_1 => Limits.pullback.fst)))
(∐ Xmap) | Please generate a tactic in lean4 to solve the state.
STATE:
case this
X : ExtrDisc
S : Sieve X
Y : ExtrDisc
T : Presieve Y
I : Type
hI : Fintype I
Xmap : I → ExtrDisc
f : (a : I) → Xmap a ⟶ Y
h : T = ofArrows Xmap f
hT : Epi (Sigma.desc f)
he : EffectiveEpiFamily Xmap f ↔ Epi (Sigma.desc f)
φ : (i : I) → Xmap i ⟶ ∐ Xmap := fun i => Sigma.ι Xmap i
F : (∐ fun b => Xmap b) ⟶ Y := Sigma.desc f
Z : Sieve Y := Sieve.generate T
Xs : ExtrDisc := ∐ fun i => Xmap i
Zf : Sieve Y := Sieve.generate (ofArrows (fun x => Xs) fun x => F)
R : ExtrDisc
g : R ⟶ Y
W : ExtrDisc
σ : W ⟶ Y
ψ : R ⟶ ∐ fun i => Xmap i
hW' : ψ ≫ Sigma.desc f = g
this : Sieve.generate (ofArrows Xmap φ) ≤ Sieve.pullback F Z
⊢ Coverage.saturate
(ExtensiveRegularCoverage ExtrDisc everything_proj
(_ :
∀ {α : Type} [inst : Fintype α] {X : ExtrDisc} {Z : α → ExtrDisc} (π : (a : α) → Z a ⟶ X) {Y : ExtrDisc}
(f : Y ⟶ X) (x : IsIso (Sigma.desc π)), IsIso (Sigma.desc fun x_1 => Limits.pullback.fst)))
(∐ Xmap) (Sieve.generate (ofArrows Xmap φ))
TACTIC:
|
https://github.com/adamtopaz/CopenhagenMasterclass2023.git | a293ca1554f7e80d891fd4d86fb092c54d8a0a01 | ExtrDisc/ExplicitSheaves.lean | ExtrDisc.extensiveRegular_generates_coherent | [108, 1] | [217, 21] | dsimp [ExtensiveRegularCoverage] | case this.hS
X : ExtrDisc
S : Sieve X
Y : ExtrDisc
T : Presieve Y
I : Type
hI : Fintype I
Xmap : I → ExtrDisc
f : (a : I) → Xmap a ⟶ Y
h : T = ofArrows Xmap f
hT : Epi (Sigma.desc f)
he : EffectiveEpiFamily Xmap f ↔ Epi (Sigma.desc f)
φ : (i : I) → Xmap i ⟶ ∐ Xmap := fun i => Sigma.ι Xmap i
F : (∐ fun b => Xmap b) ⟶ Y := Sigma.desc f
Z : Sieve Y := Sieve.generate T
Xs : ExtrDisc := ∐ fun i => Xmap i
Zf : Sieve Y := Sieve.generate (ofArrows (fun x => Xs) fun x => F)
R : ExtrDisc
g : R ⟶ Y
W : ExtrDisc
σ : W ⟶ Y
ψ : R ⟶ ∐ fun i => Xmap i
hW' : ψ ≫ Sigma.desc f = g
this : Sieve.generate (ofArrows Xmap φ) ≤ Sieve.pullback F Z
⊢ ofArrows Xmap φ ∈
Coverage.covering
(ExtensiveRegularCoverage ExtrDisc everything_proj
(_ :
∀ {α : Type} [inst : Fintype α] {X : ExtrDisc} {Z : α → ExtrDisc} (π : (a : α) → Z a ⟶ X) {Y : ExtrDisc}
(f : Y ⟶ X) (x : IsIso (Sigma.desc π)), IsIso (Sigma.desc fun x_1 => Limits.pullback.fst)))
(∐ Xmap) | case this.hS
X : ExtrDisc
S : Sieve X
Y : ExtrDisc
T : Presieve Y
I : Type
hI : Fintype I
Xmap : I → ExtrDisc
f : (a : I) → Xmap a ⟶ Y
h : T = ofArrows Xmap f
hT : Epi (Sigma.desc f)
he : EffectiveEpiFamily Xmap f ↔ Epi (Sigma.desc f)
φ : (i : I) → Xmap i ⟶ ∐ Xmap := fun i => Sigma.ι Xmap i
F : (∐ fun b => Xmap b) ⟶ Y := Sigma.desc f
Z : Sieve Y := Sieve.generate T
Xs : ExtrDisc := ∐ fun i => Xmap i
Zf : Sieve Y := Sieve.generate (ofArrows (fun x => Xs) fun x => F)
R : ExtrDisc
g : R ⟶ Y
W : ExtrDisc
σ : W ⟶ Y
ψ : R ⟶ ∐ fun i => Xmap i
hW' : ψ ≫ Sigma.desc f = g
this : Sieve.generate (ofArrows Xmap φ) ≤ Sieve.pullback F Z
⊢ (ofArrows Xmap fun i => Sigma.ι Xmap i) ∈ ExtensiveSieve (∐ Xmap) ∪ RegularSieve (∐ Xmap) | Please generate a tactic in lean4 to solve the state.
STATE:
case this.hS
X : ExtrDisc
S : Sieve X
Y : ExtrDisc
T : Presieve Y
I : Type
hI : Fintype I
Xmap : I → ExtrDisc
f : (a : I) → Xmap a ⟶ Y
h : T = ofArrows Xmap f
hT : Epi (Sigma.desc f)
he : EffectiveEpiFamily Xmap f ↔ Epi (Sigma.desc f)
φ : (i : I) → Xmap i ⟶ ∐ Xmap := fun i => Sigma.ι Xmap i
F : (∐ fun b => Xmap b) ⟶ Y := Sigma.desc f
Z : Sieve Y := Sieve.generate T
Xs : ExtrDisc := ∐ fun i => Xmap i
Zf : Sieve Y := Sieve.generate (ofArrows (fun x => Xs) fun x => F)
R : ExtrDisc
g : R ⟶ Y
W : ExtrDisc
σ : W ⟶ Y
ψ : R ⟶ ∐ fun i => Xmap i
hW' : ψ ≫ Sigma.desc f = g
this : Sieve.generate (ofArrows Xmap φ) ≤ Sieve.pullback F Z
⊢ ofArrows Xmap φ ∈
Coverage.covering
(ExtensiveRegularCoverage ExtrDisc everything_proj
(_ :
∀ {α : Type} [inst : Fintype α] {X : ExtrDisc} {Z : α → ExtrDisc} (π : (a : α) → Z a ⟶ X) {Y : ExtrDisc}
(f : Y ⟶ X) (x : IsIso (Sigma.desc π)), IsIso (Sigma.desc fun x_1 => Limits.pullback.fst)))
(∐ Xmap)
TACTIC:
|
https://github.com/adamtopaz/CopenhagenMasterclass2023.git | a293ca1554f7e80d891fd4d86fb092c54d8a0a01 | ExtrDisc/ExplicitSheaves.lean | ExtrDisc.extensiveRegular_generates_coherent | [108, 1] | [217, 21] | left | case this.hS
X : ExtrDisc
S : Sieve X
Y : ExtrDisc
T : Presieve Y
I : Type
hI : Fintype I
Xmap : I → ExtrDisc
f : (a : I) → Xmap a ⟶ Y
h : T = ofArrows Xmap f
hT : Epi (Sigma.desc f)
he : EffectiveEpiFamily Xmap f ↔ Epi (Sigma.desc f)
φ : (i : I) → Xmap i ⟶ ∐ Xmap := fun i => Sigma.ι Xmap i
F : (∐ fun b => Xmap b) ⟶ Y := Sigma.desc f
Z : Sieve Y := Sieve.generate T
Xs : ExtrDisc := ∐ fun i => Xmap i
Zf : Sieve Y := Sieve.generate (ofArrows (fun x => Xs) fun x => F)
R : ExtrDisc
g : R ⟶ Y
W : ExtrDisc
σ : W ⟶ Y
ψ : R ⟶ ∐ fun i => Xmap i
hW' : ψ ≫ Sigma.desc f = g
this : Sieve.generate (ofArrows Xmap φ) ≤ Sieve.pullback F Z
⊢ (ofArrows Xmap fun i => Sigma.ι Xmap i) ∈ ExtensiveSieve (∐ Xmap) ∪ RegularSieve (∐ Xmap) | case this.hS.h
X : ExtrDisc
S : Sieve X
Y : ExtrDisc
T : Presieve Y
I : Type
hI : Fintype I
Xmap : I → ExtrDisc
f : (a : I) → Xmap a ⟶ Y
h : T = ofArrows Xmap f
hT : Epi (Sigma.desc f)
he : EffectiveEpiFamily Xmap f ↔ Epi (Sigma.desc f)
φ : (i : I) → Xmap i ⟶ ∐ Xmap := fun i => Sigma.ι Xmap i
F : (∐ fun b => Xmap b) ⟶ Y := Sigma.desc f
Z : Sieve Y := Sieve.generate T
Xs : ExtrDisc := ∐ fun i => Xmap i
Zf : Sieve Y := Sieve.generate (ofArrows (fun x => Xs) fun x => F)
R : ExtrDisc
g : R ⟶ Y
W : ExtrDisc
σ : W ⟶ Y
ψ : R ⟶ ∐ fun i => Xmap i
hW' : ψ ≫ Sigma.desc f = g
this : Sieve.generate (ofArrows Xmap φ) ≤ Sieve.pullback F Z
⊢ (ofArrows Xmap fun i => Sigma.ι Xmap i) ∈ ExtensiveSieve (∐ Xmap) | Please generate a tactic in lean4 to solve the state.
STATE:
case this.hS
X : ExtrDisc
S : Sieve X
Y : ExtrDisc
T : Presieve Y
I : Type
hI : Fintype I
Xmap : I → ExtrDisc
f : (a : I) → Xmap a ⟶ Y
h : T = ofArrows Xmap f
hT : Epi (Sigma.desc f)
he : EffectiveEpiFamily Xmap f ↔ Epi (Sigma.desc f)
φ : (i : I) → Xmap i ⟶ ∐ Xmap := fun i => Sigma.ι Xmap i
F : (∐ fun b => Xmap b) ⟶ Y := Sigma.desc f
Z : Sieve Y := Sieve.generate T
Xs : ExtrDisc := ∐ fun i => Xmap i
Zf : Sieve Y := Sieve.generate (ofArrows (fun x => Xs) fun x => F)
R : ExtrDisc
g : R ⟶ Y
W : ExtrDisc
σ : W ⟶ Y
ψ : R ⟶ ∐ fun i => Xmap i
hW' : ψ ≫ Sigma.desc f = g
this : Sieve.generate (ofArrows Xmap φ) ≤ Sieve.pullback F Z
⊢ (ofArrows Xmap fun i => Sigma.ι Xmap i) ∈ ExtensiveSieve (∐ Xmap) ∪ RegularSieve (∐ Xmap)
TACTIC:
|
https://github.com/adamtopaz/CopenhagenMasterclass2023.git | a293ca1554f7e80d891fd4d86fb092c54d8a0a01 | ExtrDisc/ExplicitSheaves.lean | ExtrDisc.extensiveRegular_generates_coherent | [108, 1] | [217, 21] | refine' ⟨I, hI, Xmap, φ, ⟨rfl, _⟩⟩ | case this.hS.h
X : ExtrDisc
S : Sieve X
Y : ExtrDisc
T : Presieve Y
I : Type
hI : Fintype I
Xmap : I → ExtrDisc
f : (a : I) → Xmap a ⟶ Y
h : T = ofArrows Xmap f
hT : Epi (Sigma.desc f)
he : EffectiveEpiFamily Xmap f ↔ Epi (Sigma.desc f)
φ : (i : I) → Xmap i ⟶ ∐ Xmap := fun i => Sigma.ι Xmap i
F : (∐ fun b => Xmap b) ⟶ Y := Sigma.desc f
Z : Sieve Y := Sieve.generate T
Xs : ExtrDisc := ∐ fun i => Xmap i
Zf : Sieve Y := Sieve.generate (ofArrows (fun x => Xs) fun x => F)
R : ExtrDisc
g : R ⟶ Y
W : ExtrDisc
σ : W ⟶ Y
ψ : R ⟶ ∐ fun i => Xmap i
hW' : ψ ≫ Sigma.desc f = g
this : Sieve.generate (ofArrows Xmap φ) ≤ Sieve.pullback F Z
⊢ (ofArrows Xmap fun i => Sigma.ι Xmap i) ∈ ExtensiveSieve (∐ Xmap) | case this.hS.h
X : ExtrDisc
S : Sieve X
Y : ExtrDisc
T : Presieve Y
I : Type
hI : Fintype I
Xmap : I → ExtrDisc
f : (a : I) → Xmap a ⟶ Y
h : T = ofArrows Xmap f
hT : Epi (Sigma.desc f)
he : EffectiveEpiFamily Xmap f ↔ Epi (Sigma.desc f)
φ : (i : I) → Xmap i ⟶ ∐ Xmap := fun i => Sigma.ι Xmap i
F : (∐ fun b => Xmap b) ⟶ Y := Sigma.desc f
Z : Sieve Y := Sieve.generate T
Xs : ExtrDisc := ∐ fun i => Xmap i
Zf : Sieve Y := Sieve.generate (ofArrows (fun x => Xs) fun x => F)
R : ExtrDisc
g : R ⟶ Y
W : ExtrDisc
σ : W ⟶ Y
ψ : R ⟶ ∐ fun i => Xmap i
hW' : ψ ≫ Sigma.desc f = g
this : Sieve.generate (ofArrows Xmap φ) ≤ Sieve.pullback F Z
⊢ IsIso (Sigma.desc φ) | Please generate a tactic in lean4 to solve the state.
STATE:
case this.hS.h
X : ExtrDisc
S : Sieve X
Y : ExtrDisc
T : Presieve Y
I : Type
hI : Fintype I
Xmap : I → ExtrDisc
f : (a : I) → Xmap a ⟶ Y
h : T = ofArrows Xmap f
hT : Epi (Sigma.desc f)
he : EffectiveEpiFamily Xmap f ↔ Epi (Sigma.desc f)
φ : (i : I) → Xmap i ⟶ ∐ Xmap := fun i => Sigma.ι Xmap i
F : (∐ fun b => Xmap b) ⟶ Y := Sigma.desc f
Z : Sieve Y := Sieve.generate T
Xs : ExtrDisc := ∐ fun i => Xmap i
Zf : Sieve Y := Sieve.generate (ofArrows (fun x => Xs) fun x => F)
R : ExtrDisc
g : R ⟶ Y
W : ExtrDisc
σ : W ⟶ Y
ψ : R ⟶ ∐ fun i => Xmap i
hW' : ψ ≫ Sigma.desc f = g
this : Sieve.generate (ofArrows Xmap φ) ≤ Sieve.pullback F Z
⊢ (ofArrows Xmap fun i => Sigma.ι Xmap i) ∈ ExtensiveSieve (∐ Xmap)
TACTIC:
|
https://github.com/adamtopaz/CopenhagenMasterclass2023.git | a293ca1554f7e80d891fd4d86fb092c54d8a0a01 | ExtrDisc/ExplicitSheaves.lean | ExtrDisc.extensiveRegular_generates_coherent | [108, 1] | [217, 21] | suffices : Sigma.desc φ = 𝟙 _ | case this.hS.h
X : ExtrDisc
S : Sieve X
Y : ExtrDisc
T : Presieve Y
I : Type
hI : Fintype I
Xmap : I → ExtrDisc
f : (a : I) → Xmap a ⟶ Y
h : T = ofArrows Xmap f
hT : Epi (Sigma.desc f)
he : EffectiveEpiFamily Xmap f ↔ Epi (Sigma.desc f)
φ : (i : I) → Xmap i ⟶ ∐ Xmap := fun i => Sigma.ι Xmap i
F : (∐ fun b => Xmap b) ⟶ Y := Sigma.desc f
Z : Sieve Y := Sieve.generate T
Xs : ExtrDisc := ∐ fun i => Xmap i
Zf : Sieve Y := Sieve.generate (ofArrows (fun x => Xs) fun x => F)
R : ExtrDisc
g : R ⟶ Y
W : ExtrDisc
σ : W ⟶ Y
ψ : R ⟶ ∐ fun i => Xmap i
hW' : ψ ≫ Sigma.desc f = g
this : Sieve.generate (ofArrows Xmap φ) ≤ Sieve.pullback F Z
⊢ IsIso (Sigma.desc φ) | case this.hS.h
X : ExtrDisc
S : Sieve X
Y : ExtrDisc
T : Presieve Y
I : Type
hI : Fintype I
Xmap : I → ExtrDisc
f : (a : I) → Xmap a ⟶ Y
h : T = ofArrows Xmap f
hT : Epi (Sigma.desc f)
he : EffectiveEpiFamily Xmap f ↔ Epi (Sigma.desc f)
φ : (i : I) → Xmap i ⟶ ∐ Xmap := fun i => Sigma.ι Xmap i
F : (∐ fun b => Xmap b) ⟶ Y := Sigma.desc f
Z : Sieve Y := Sieve.generate T
Xs : ExtrDisc := ∐ fun i => Xmap i
Zf : Sieve Y := Sieve.generate (ofArrows (fun x => Xs) fun x => F)
R : ExtrDisc
g : R ⟶ Y
W : ExtrDisc
σ : W ⟶ Y
ψ : R ⟶ ∐ fun i => Xmap i
hW' : ψ ≫ Sigma.desc f = g
this✝ : Sieve.generate (ofArrows Xmap φ) ≤ Sieve.pullback F Z
this : Sigma.desc φ = 𝟙 (∐ fun b => Xmap b)
⊢ IsIso (Sigma.desc φ)
case this
X : ExtrDisc
S : Sieve X
Y : ExtrDisc
T : Presieve Y
I : Type
hI : Fintype I
Xmap : I → ExtrDisc
f : (a : I) → Xmap a ⟶ Y
h : T = ofArrows Xmap f
hT : Epi (Sigma.desc f)
he : EffectiveEpiFamily Xmap f ↔ Epi (Sigma.desc f)
φ : (i : I) → Xmap i ⟶ ∐ Xmap := fun i => Sigma.ι Xmap i
F : (∐ fun b => Xmap b) ⟶ Y := Sigma.desc f
Z : Sieve Y := Sieve.generate T
Xs : ExtrDisc := ∐ fun i => Xmap i
Zf : Sieve Y := Sieve.generate (ofArrows (fun x => Xs) fun x => F)
R : ExtrDisc
g : R ⟶ Y
W : ExtrDisc
σ : W ⟶ Y
ψ : R ⟶ ∐ fun i => Xmap i
hW' : ψ ≫ Sigma.desc f = g
this : Sieve.generate (ofArrows Xmap φ) ≤ Sieve.pullback F Z
⊢ Sigma.desc φ = 𝟙 (∐ fun b => Xmap b) | Please generate a tactic in lean4 to solve the state.
STATE:
case this.hS.h
X : ExtrDisc
S : Sieve X
Y : ExtrDisc
T : Presieve Y
I : Type
hI : Fintype I
Xmap : I → ExtrDisc
f : (a : I) → Xmap a ⟶ Y
h : T = ofArrows Xmap f
hT : Epi (Sigma.desc f)
he : EffectiveEpiFamily Xmap f ↔ Epi (Sigma.desc f)
φ : (i : I) → Xmap i ⟶ ∐ Xmap := fun i => Sigma.ι Xmap i
F : (∐ fun b => Xmap b) ⟶ Y := Sigma.desc f
Z : Sieve Y := Sieve.generate T
Xs : ExtrDisc := ∐ fun i => Xmap i
Zf : Sieve Y := Sieve.generate (ofArrows (fun x => Xs) fun x => F)
R : ExtrDisc
g : R ⟶ Y
W : ExtrDisc
σ : W ⟶ Y
ψ : R ⟶ ∐ fun i => Xmap i
hW' : ψ ≫ Sigma.desc f = g
this : Sieve.generate (ofArrows Xmap φ) ≤ Sieve.pullback F Z
⊢ IsIso (Sigma.desc φ)
TACTIC:
|
https://github.com/adamtopaz/CopenhagenMasterclass2023.git | a293ca1554f7e80d891fd4d86fb092c54d8a0a01 | ExtrDisc/ExplicitSheaves.lean | ExtrDisc.extensiveRegular_generates_coherent | [108, 1] | [217, 21] | ext | case this
X : ExtrDisc
S : Sieve X
Y : ExtrDisc
T : Presieve Y
I : Type
hI : Fintype I
Xmap : I → ExtrDisc
f : (a : I) → Xmap a ⟶ Y
h : T = ofArrows Xmap f
hT : Epi (Sigma.desc f)
he : EffectiveEpiFamily Xmap f ↔ Epi (Sigma.desc f)
φ : (i : I) → Xmap i ⟶ ∐ Xmap := fun i => Sigma.ι Xmap i
F : (∐ fun b => Xmap b) ⟶ Y := Sigma.desc f
Z : Sieve Y := Sieve.generate T
Xs : ExtrDisc := ∐ fun i => Xmap i
Zf : Sieve Y := Sieve.generate (ofArrows (fun x => Xs) fun x => F)
R : ExtrDisc
g : R ⟶ Y
W : ExtrDisc
σ : W ⟶ Y
ψ : R ⟶ ∐ fun i => Xmap i
hW' : ψ ≫ Sigma.desc f = g
this : Sieve.generate (ofArrows Xmap φ) ≤ Sieve.pullback F Z
⊢ Sigma.desc φ = 𝟙 (∐ fun b => Xmap b) | case this.h.w
X : ExtrDisc
S : Sieve X
Y : ExtrDisc
T : Presieve Y
I : Type
hI : Fintype I
Xmap : I → ExtrDisc
f : (a : I) → Xmap a ⟶ Y
h : T = ofArrows Xmap f
hT : Epi (Sigma.desc f)
he : EffectiveEpiFamily Xmap f ↔ Epi (Sigma.desc f)
φ : (i : I) → Xmap i ⟶ ∐ Xmap := fun i => Sigma.ι Xmap i
F : (∐ fun b => Xmap b) ⟶ Y := Sigma.desc f
Z : Sieve Y := Sieve.generate T
Xs : ExtrDisc := ∐ fun i => Xmap i
Zf : Sieve Y := Sieve.generate (ofArrows (fun x => Xs) fun x => F)
R : ExtrDisc
g : R ⟶ Y
W : ExtrDisc
σ : W ⟶ Y
ψ : R ⟶ ∐ fun i => Xmap i
hW' : ψ ≫ Sigma.desc f = g
this : Sieve.generate (ofArrows Xmap φ) ≤ Sieve.pullback F Z
b✝ : I
x✝ : (forget ExtrDisc).obj (Xmap b✝)
⊢ ↑(Sigma.ι (fun b => Xmap b) b✝ ≫ Sigma.desc φ) x✝ = ↑(Sigma.ι (fun b => Xmap b) b✝ ≫ 𝟙 (∐ fun b => Xmap b)) x✝ | Please generate a tactic in lean4 to solve the state.
STATE:
case this
X : ExtrDisc
S : Sieve X
Y : ExtrDisc
T : Presieve Y
I : Type
hI : Fintype I
Xmap : I → ExtrDisc
f : (a : I) → Xmap a ⟶ Y
h : T = ofArrows Xmap f
hT : Epi (Sigma.desc f)
he : EffectiveEpiFamily Xmap f ↔ Epi (Sigma.desc f)
φ : (i : I) → Xmap i ⟶ ∐ Xmap := fun i => Sigma.ι Xmap i
F : (∐ fun b => Xmap b) ⟶ Y := Sigma.desc f
Z : Sieve Y := Sieve.generate T
Xs : ExtrDisc := ∐ fun i => Xmap i
Zf : Sieve Y := Sieve.generate (ofArrows (fun x => Xs) fun x => F)
R : ExtrDisc
g : R ⟶ Y
W : ExtrDisc
σ : W ⟶ Y
ψ : R ⟶ ∐ fun i => Xmap i
hW' : ψ ≫ Sigma.desc f = g
this : Sieve.generate (ofArrows Xmap φ) ≤ Sieve.pullback F Z
⊢ Sigma.desc φ = 𝟙 (∐ fun b => Xmap b)
TACTIC:
|
https://github.com/adamtopaz/CopenhagenMasterclass2023.git | a293ca1554f7e80d891fd4d86fb092c54d8a0a01 | ExtrDisc/ExplicitSheaves.lean | ExtrDisc.extensiveRegular_generates_coherent | [108, 1] | [217, 21] | simp only [colimit.ι_desc, Cofan.mk_pt, Cofan.mk_ι_app, Category.comp_id] | case this.h.w
X : ExtrDisc
S : Sieve X
Y : ExtrDisc
T : Presieve Y
I : Type
hI : Fintype I
Xmap : I → ExtrDisc
f : (a : I) → Xmap a ⟶ Y
h : T = ofArrows Xmap f
hT : Epi (Sigma.desc f)
he : EffectiveEpiFamily Xmap f ↔ Epi (Sigma.desc f)
φ : (i : I) → Xmap i ⟶ ∐ Xmap := fun i => Sigma.ι Xmap i
F : (∐ fun b => Xmap b) ⟶ Y := Sigma.desc f
Z : Sieve Y := Sieve.generate T
Xs : ExtrDisc := ∐ fun i => Xmap i
Zf : Sieve Y := Sieve.generate (ofArrows (fun x => Xs) fun x => F)
R : ExtrDisc
g : R ⟶ Y
W : ExtrDisc
σ : W ⟶ Y
ψ : R ⟶ ∐ fun i => Xmap i
hW' : ψ ≫ Sigma.desc f = g
this : Sieve.generate (ofArrows Xmap φ) ≤ Sieve.pullback F Z
b✝ : I
x✝ : (forget ExtrDisc).obj (Xmap b✝)
⊢ ↑(Sigma.ι (fun b => Xmap b) b✝ ≫ Sigma.desc φ) x✝ = ↑(Sigma.ι (fun b => Xmap b) b✝ ≫ 𝟙 (∐ fun b => Xmap b)) x✝ | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case this.h.w
X : ExtrDisc
S : Sieve X
Y : ExtrDisc
T : Presieve Y
I : Type
hI : Fintype I
Xmap : I → ExtrDisc
f : (a : I) → Xmap a ⟶ Y
h : T = ofArrows Xmap f
hT : Epi (Sigma.desc f)
he : EffectiveEpiFamily Xmap f ↔ Epi (Sigma.desc f)
φ : (i : I) → Xmap i ⟶ ∐ Xmap := fun i => Sigma.ι Xmap i
F : (∐ fun b => Xmap b) ⟶ Y := Sigma.desc f
Z : Sieve Y := Sieve.generate T
Xs : ExtrDisc := ∐ fun i => Xmap i
Zf : Sieve Y := Sieve.generate (ofArrows (fun x => Xs) fun x => F)
R : ExtrDisc
g : R ⟶ Y
W : ExtrDisc
σ : W ⟶ Y
ψ : R ⟶ ∐ fun i => Xmap i
hW' : ψ ≫ Sigma.desc f = g
this : Sieve.generate (ofArrows Xmap φ) ≤ Sieve.pullback F Z
b✝ : I
x✝ : (forget ExtrDisc).obj (Xmap b✝)
⊢ ↑(Sigma.ι (fun b => Xmap b) b✝ ≫ Sigma.desc φ) x✝ = ↑(Sigma.ι (fun b => Xmap b) b✝ ≫ 𝟙 (∐ fun b => Xmap b)) x✝
TACTIC:
|
https://github.com/adamtopaz/CopenhagenMasterclass2023.git | a293ca1554f7e80d891fd4d86fb092c54d8a0a01 | ExtrDisc/ExplicitSheaves.lean | ExtrDisc.extensiveRegular_generates_coherent | [108, 1] | [217, 21] | rw [this] | case this.hS.h
X : ExtrDisc
S : Sieve X
Y : ExtrDisc
T : Presieve Y
I : Type
hI : Fintype I
Xmap : I → ExtrDisc
f : (a : I) → Xmap a ⟶ Y
h : T = ofArrows Xmap f
hT : Epi (Sigma.desc f)
he : EffectiveEpiFamily Xmap f ↔ Epi (Sigma.desc f)
φ : (i : I) → Xmap i ⟶ ∐ Xmap := fun i => Sigma.ι Xmap i
F : (∐ fun b => Xmap b) ⟶ Y := Sigma.desc f
Z : Sieve Y := Sieve.generate T
Xs : ExtrDisc := ∐ fun i => Xmap i
Zf : Sieve Y := Sieve.generate (ofArrows (fun x => Xs) fun x => F)
R : ExtrDisc
g : R ⟶ Y
W : ExtrDisc
σ : W ⟶ Y
ψ : R ⟶ ∐ fun i => Xmap i
hW' : ψ ≫ Sigma.desc f = g
this✝ : Sieve.generate (ofArrows Xmap φ) ≤ Sieve.pullback F Z
this : Sigma.desc φ = 𝟙 (∐ fun b => Xmap b)
⊢ IsIso (Sigma.desc φ) | case this.hS.h
X : ExtrDisc
S : Sieve X
Y : ExtrDisc
T : Presieve Y
I : Type
hI : Fintype I
Xmap : I → ExtrDisc
f : (a : I) → Xmap a ⟶ Y
h : T = ofArrows Xmap f
hT : Epi (Sigma.desc f)
he : EffectiveEpiFamily Xmap f ↔ Epi (Sigma.desc f)
φ : (i : I) → Xmap i ⟶ ∐ Xmap := fun i => Sigma.ι Xmap i
F : (∐ fun b => Xmap b) ⟶ Y := Sigma.desc f
Z : Sieve Y := Sieve.generate T
Xs : ExtrDisc := ∐ fun i => Xmap i
Zf : Sieve Y := Sieve.generate (ofArrows (fun x => Xs) fun x => F)
R : ExtrDisc
g : R ⟶ Y
W : ExtrDisc
σ : W ⟶ Y
ψ : R ⟶ ∐ fun i => Xmap i
hW' : ψ ≫ Sigma.desc f = g
this✝ : Sieve.generate (ofArrows Xmap φ) ≤ Sieve.pullback F Z
this : Sigma.desc φ = 𝟙 (∐ fun b => Xmap b)
⊢ IsIso (𝟙 (∐ fun b => Xmap b)) | Please generate a tactic in lean4 to solve the state.
STATE:
case this.hS.h
X : ExtrDisc
S : Sieve X
Y : ExtrDisc
T : Presieve Y
I : Type
hI : Fintype I
Xmap : I → ExtrDisc
f : (a : I) → Xmap a ⟶ Y
h : T = ofArrows Xmap f
hT : Epi (Sigma.desc f)
he : EffectiveEpiFamily Xmap f ↔ Epi (Sigma.desc f)
φ : (i : I) → Xmap i ⟶ ∐ Xmap := fun i => Sigma.ι Xmap i
F : (∐ fun b => Xmap b) ⟶ Y := Sigma.desc f
Z : Sieve Y := Sieve.generate T
Xs : ExtrDisc := ∐ fun i => Xmap i
Zf : Sieve Y := Sieve.generate (ofArrows (fun x => Xs) fun x => F)
R : ExtrDisc
g : R ⟶ Y
W : ExtrDisc
σ : W ⟶ Y
ψ : R ⟶ ∐ fun i => Xmap i
hW' : ψ ≫ Sigma.desc f = g
this✝ : Sieve.generate (ofArrows Xmap φ) ≤ Sieve.pullback F Z
this : Sigma.desc φ = 𝟙 (∐ fun b => Xmap b)
⊢ IsIso (Sigma.desc φ)
TACTIC:
|
https://github.com/adamtopaz/CopenhagenMasterclass2023.git | a293ca1554f7e80d891fd4d86fb092c54d8a0a01 | ExtrDisc/ExplicitSheaves.lean | ExtrDisc.extensiveRegular_generates_coherent | [108, 1] | [217, 21] | exact inferInstance | case this.hS.h
X : ExtrDisc
S : Sieve X
Y : ExtrDisc
T : Presieve Y
I : Type
hI : Fintype I
Xmap : I → ExtrDisc
f : (a : I) → Xmap a ⟶ Y
h : T = ofArrows Xmap f
hT : Epi (Sigma.desc f)
he : EffectiveEpiFamily Xmap f ↔ Epi (Sigma.desc f)
φ : (i : I) → Xmap i ⟶ ∐ Xmap := fun i => Sigma.ι Xmap i
F : (∐ fun b => Xmap b) ⟶ Y := Sigma.desc f
Z : Sieve Y := Sieve.generate T
Xs : ExtrDisc := ∐ fun i => Xmap i
Zf : Sieve Y := Sieve.generate (ofArrows (fun x => Xs) fun x => F)
R : ExtrDisc
g : R ⟶ Y
W : ExtrDisc
σ : W ⟶ Y
ψ : R ⟶ ∐ fun i => Xmap i
hW' : ψ ≫ Sigma.desc f = g
this✝ : Sieve.generate (ofArrows Xmap φ) ≤ Sieve.pullback F Z
this : Sigma.desc φ = 𝟙 (∐ fun b => Xmap b)
⊢ IsIso (𝟙 (∐ fun b => Xmap b)) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case this.hS.h
X : ExtrDisc
S : Sieve X
Y : ExtrDisc
T : Presieve Y
I : Type
hI : Fintype I
Xmap : I → ExtrDisc
f : (a : I) → Xmap a ⟶ Y
h : T = ofArrows Xmap f
hT : Epi (Sigma.desc f)
he : EffectiveEpiFamily Xmap f ↔ Epi (Sigma.desc f)
φ : (i : I) → Xmap i ⟶ ∐ Xmap := fun i => Sigma.ι Xmap i
F : (∐ fun b => Xmap b) ⟶ Y := Sigma.desc f
Z : Sieve Y := Sieve.generate T
Xs : ExtrDisc := ∐ fun i => Xmap i
Zf : Sieve Y := Sieve.generate (ofArrows (fun x => Xs) fun x => F)
R : ExtrDisc
g : R ⟶ Y
W : ExtrDisc
σ : W ⟶ Y
ψ : R ⟶ ∐ fun i => Xmap i
hW' : ψ ≫ Sigma.desc f = g
this✝ : Sieve.generate (ofArrows Xmap φ) ≤ Sieve.pullback F Z
this : Sigma.desc φ = 𝟙 (∐ fun b => Xmap b)
⊢ IsIso (𝟙 (∐ fun b => Xmap b))
TACTIC:
|
https://github.com/adamtopaz/CopenhagenMasterclass2023.git | a293ca1554f7e80d891fd4d86fb092c54d8a0a01 | ExtrDisc/ExplicitSheaves.lean | ExtrDisc.extensiveRegular_generates_coherent | [108, 1] | [217, 21] | rw [h] | case this.intro.intro.intro.refine'_1
X : ExtrDisc
S : Sieve X
Y : ExtrDisc
T : Presieve Y
I : Type
hI : Fintype I
Xmap : I → ExtrDisc
f : (a : I) → Xmap a ⟶ Y
h : T = ofArrows Xmap f
hT : Epi (Sigma.desc f)
he : EffectiveEpiFamily Xmap f ↔ Epi (Sigma.desc f)
φ : (i : I) → Xmap i ⟶ ∐ Xmap := fun i => Sigma.ι Xmap i
F : (∐ fun b => Xmap b) ⟶ Y := Sigma.desc f
Z : Sieve Y := Sieve.generate T
Xs : ExtrDisc := ∐ fun i => Xmap i
Zf : Sieve Y := Sieve.generate (ofArrows (fun x => Xs) fun x => F)
R : ExtrDisc
g : R ⟶ Y
W : ExtrDisc
σ : W ⟶ Y
ψ : R ⟶ ∐ fun i => Xmap i
hW' : ψ ≫ Sigma.desc f = g
Q : ExtrDisc
q : Q ⟶ ∐ Xmap
E : ExtrDisc
e : Q ⟶ E
r : E ⟶ ∐ Xmap
hq : ofArrows Xmap (fun i => Sigma.ι Xmap i) r ∧ e ≫ r = q
⊢ T (r ≫ F) | case this.intro.intro.intro.refine'_1
X : ExtrDisc
S : Sieve X
Y : ExtrDisc
T : Presieve Y
I : Type
hI : Fintype I
Xmap : I → ExtrDisc
f : (a : I) → Xmap a ⟶ Y
h : T = ofArrows Xmap f
hT : Epi (Sigma.desc f)
he : EffectiveEpiFamily Xmap f ↔ Epi (Sigma.desc f)
φ : (i : I) → Xmap i ⟶ ∐ Xmap := fun i => Sigma.ι Xmap i
F : (∐ fun b => Xmap b) ⟶ Y := Sigma.desc f
Z : Sieve Y := Sieve.generate T
Xs : ExtrDisc := ∐ fun i => Xmap i
Zf : Sieve Y := Sieve.generate (ofArrows (fun x => Xs) fun x => F)
R : ExtrDisc
g : R ⟶ Y
W : ExtrDisc
σ : W ⟶ Y
ψ : R ⟶ ∐ fun i => Xmap i
hW' : ψ ≫ Sigma.desc f = g
Q : ExtrDisc
q : Q ⟶ ∐ Xmap
E : ExtrDisc
e : Q ⟶ E
r : E ⟶ ∐ Xmap
hq : ofArrows Xmap (fun i => Sigma.ι Xmap i) r ∧ e ≫ r = q
⊢ ofArrows Xmap f (r ≫ F) | Please generate a tactic in lean4 to solve the state.
STATE:
case this.intro.intro.intro.refine'_1
X : ExtrDisc
S : Sieve X
Y : ExtrDisc
T : Presieve Y
I : Type
hI : Fintype I
Xmap : I → ExtrDisc
f : (a : I) → Xmap a ⟶ Y
h : T = ofArrows Xmap f
hT : Epi (Sigma.desc f)
he : EffectiveEpiFamily Xmap f ↔ Epi (Sigma.desc f)
φ : (i : I) → Xmap i ⟶ ∐ Xmap := fun i => Sigma.ι Xmap i
F : (∐ fun b => Xmap b) ⟶ Y := Sigma.desc f
Z : Sieve Y := Sieve.generate T
Xs : ExtrDisc := ∐ fun i => Xmap i
Zf : Sieve Y := Sieve.generate (ofArrows (fun x => Xs) fun x => F)
R : ExtrDisc
g : R ⟶ Y
W : ExtrDisc
σ : W ⟶ Y
ψ : R ⟶ ∐ fun i => Xmap i
hW' : ψ ≫ Sigma.desc f = g
Q : ExtrDisc
q : Q ⟶ ∐ Xmap
E : ExtrDisc
e : Q ⟶ E
r : E ⟶ ∐ Xmap
hq : ofArrows Xmap (fun i => Sigma.ι Xmap i) r ∧ e ≫ r = q
⊢ T (r ≫ F)
TACTIC:
|
https://github.com/adamtopaz/CopenhagenMasterclass2023.git | a293ca1554f7e80d891fd4d86fb092c54d8a0a01 | ExtrDisc/ExplicitSheaves.lean | ExtrDisc.extensiveRegular_generates_coherent | [108, 1] | [217, 21] | induction hq.1 | case this.intro.intro.intro.refine'_1
X : ExtrDisc
S : Sieve X
Y : ExtrDisc
T : Presieve Y
I : Type
hI : Fintype I
Xmap : I → ExtrDisc
f : (a : I) → Xmap a ⟶ Y
h : T = ofArrows Xmap f
hT : Epi (Sigma.desc f)
he : EffectiveEpiFamily Xmap f ↔ Epi (Sigma.desc f)
φ : (i : I) → Xmap i ⟶ ∐ Xmap := fun i => Sigma.ι Xmap i
F : (∐ fun b => Xmap b) ⟶ Y := Sigma.desc f
Z : Sieve Y := Sieve.generate T
Xs : ExtrDisc := ∐ fun i => Xmap i
Zf : Sieve Y := Sieve.generate (ofArrows (fun x => Xs) fun x => F)
R : ExtrDisc
g : R ⟶ Y
W : ExtrDisc
σ : W ⟶ Y
ψ : R ⟶ ∐ fun i => Xmap i
hW' : ψ ≫ Sigma.desc f = g
Q : ExtrDisc
q : Q ⟶ ∐ Xmap
E : ExtrDisc
e : Q ⟶ E
r : E ⟶ ∐ Xmap
hq : ofArrows Xmap (fun i => Sigma.ι Xmap i) r ∧ e ≫ r = q
⊢ ofArrows Xmap f (r ≫ F) | case this.intro.intro.intro.refine'_1.mk
X : ExtrDisc
S : Sieve X
Y : ExtrDisc
T : Presieve Y
I : Type
hI : Fintype I
Xmap : I → ExtrDisc
f : (a : I) → Xmap a ⟶ Y
h : T = ofArrows Xmap f
hT : Epi (Sigma.desc f)
he : EffectiveEpiFamily Xmap f ↔ Epi (Sigma.desc f)
φ : (i : I) → Xmap i ⟶ ∐ Xmap := fun i => Sigma.ι Xmap i
F : (∐ fun b => Xmap b) ⟶ Y := Sigma.desc f
Z : Sieve Y := Sieve.generate T
Xs : ExtrDisc := ∐ fun i => Xmap i
Zf : Sieve Y := Sieve.generate (ofArrows (fun x => Xs) fun x => F)
R : ExtrDisc
g : R ⟶ Y
W : ExtrDisc
σ : W ⟶ Y
ψ : R ⟶ ∐ fun i => Xmap i
hW' : ψ ≫ Sigma.desc f = g
Q : ExtrDisc
q : Q ⟶ ∐ Xmap
E : ExtrDisc
r : E ⟶ ∐ Xmap
i✝ : I
e : Q ⟶ Xmap i✝
hq : ofArrows Xmap (fun i => Sigma.ι Xmap i) (Sigma.ι Xmap i✝) ∧ e ≫ Sigma.ι Xmap i✝ = q
⊢ ofArrows Xmap f (Sigma.ι Xmap i✝ ≫ F) | Please generate a tactic in lean4 to solve the state.
STATE:
case this.intro.intro.intro.refine'_1
X : ExtrDisc
S : Sieve X
Y : ExtrDisc
T : Presieve Y
I : Type
hI : Fintype I
Xmap : I → ExtrDisc
f : (a : I) → Xmap a ⟶ Y
h : T = ofArrows Xmap f
hT : Epi (Sigma.desc f)
he : EffectiveEpiFamily Xmap f ↔ Epi (Sigma.desc f)
φ : (i : I) → Xmap i ⟶ ∐ Xmap := fun i => Sigma.ι Xmap i
F : (∐ fun b => Xmap b) ⟶ Y := Sigma.desc f
Z : Sieve Y := Sieve.generate T
Xs : ExtrDisc := ∐ fun i => Xmap i
Zf : Sieve Y := Sieve.generate (ofArrows (fun x => Xs) fun x => F)
R : ExtrDisc
g : R ⟶ Y
W : ExtrDisc
σ : W ⟶ Y
ψ : R ⟶ ∐ fun i => Xmap i
hW' : ψ ≫ Sigma.desc f = g
Q : ExtrDisc
q : Q ⟶ ∐ Xmap
E : ExtrDisc
e : Q ⟶ E
r : E ⟶ ∐ Xmap
hq : ofArrows Xmap (fun i => Sigma.ι Xmap i) r ∧ e ≫ r = q
⊢ ofArrows Xmap f (r ≫ F)
TACTIC:
|
https://github.com/adamtopaz/CopenhagenMasterclass2023.git | a293ca1554f7e80d891fd4d86fb092c54d8a0a01 | ExtrDisc/ExplicitSheaves.lean | ExtrDisc.extensiveRegular_generates_coherent | [108, 1] | [217, 21] | dsimp | case this.intro.intro.intro.refine'_1.mk
X : ExtrDisc
S : Sieve X
Y : ExtrDisc
T : Presieve Y
I : Type
hI : Fintype I
Xmap : I → ExtrDisc
f : (a : I) → Xmap a ⟶ Y
h : T = ofArrows Xmap f
hT : Epi (Sigma.desc f)
he : EffectiveEpiFamily Xmap f ↔ Epi (Sigma.desc f)
φ : (i : I) → Xmap i ⟶ ∐ Xmap := fun i => Sigma.ι Xmap i
F : (∐ fun b => Xmap b) ⟶ Y := Sigma.desc f
Z : Sieve Y := Sieve.generate T
Xs : ExtrDisc := ∐ fun i => Xmap i
Zf : Sieve Y := Sieve.generate (ofArrows (fun x => Xs) fun x => F)
R : ExtrDisc
g : R ⟶ Y
W : ExtrDisc
σ : W ⟶ Y
ψ : R ⟶ ∐ fun i => Xmap i
hW' : ψ ≫ Sigma.desc f = g
Q : ExtrDisc
q : Q ⟶ ∐ Xmap
E : ExtrDisc
r : E ⟶ ∐ Xmap
i✝ : I
e : Q ⟶ Xmap i✝
hq : ofArrows Xmap (fun i => Sigma.ι Xmap i) (Sigma.ι Xmap i✝) ∧ e ≫ Sigma.ι Xmap i✝ = q
⊢ ofArrows Xmap f (Sigma.ι Xmap i✝ ≫ F) | case this.intro.intro.intro.refine'_1.mk
X : ExtrDisc
S : Sieve X
Y : ExtrDisc
T : Presieve Y
I : Type
hI : Fintype I
Xmap : I → ExtrDisc
f : (a : I) → Xmap a ⟶ Y
h : T = ofArrows Xmap f
hT : Epi (Sigma.desc f)
he : EffectiveEpiFamily Xmap f ↔ Epi (Sigma.desc f)
φ : (i : I) → Xmap i ⟶ ∐ Xmap := fun i => Sigma.ι Xmap i
F : (∐ fun b => Xmap b) ⟶ Y := Sigma.desc f
Z : Sieve Y := Sieve.generate T
Xs : ExtrDisc := ∐ fun i => Xmap i
Zf : Sieve Y := Sieve.generate (ofArrows (fun x => Xs) fun x => F)
R : ExtrDisc
g : R ⟶ Y
W : ExtrDisc
σ : W ⟶ Y
ψ : R ⟶ ∐ fun i => Xmap i
hW' : ψ ≫ Sigma.desc f = g
Q : ExtrDisc
q : Q ⟶ ∐ Xmap
E : ExtrDisc
r : E ⟶ ∐ Xmap
i✝ : I
e : Q ⟶ Xmap i✝
hq : ofArrows Xmap (fun i => Sigma.ι Xmap i) (Sigma.ι Xmap i✝) ∧ e ≫ Sigma.ι Xmap i✝ = q
⊢ ofArrows Xmap f (Sigma.ι Xmap i✝ ≫ Sigma.desc f) | Please generate a tactic in lean4 to solve the state.
STATE:
case this.intro.intro.intro.refine'_1.mk
X : ExtrDisc
S : Sieve X
Y : ExtrDisc
T : Presieve Y
I : Type
hI : Fintype I
Xmap : I → ExtrDisc
f : (a : I) → Xmap a ⟶ Y
h : T = ofArrows Xmap f
hT : Epi (Sigma.desc f)
he : EffectiveEpiFamily Xmap f ↔ Epi (Sigma.desc f)
φ : (i : I) → Xmap i ⟶ ∐ Xmap := fun i => Sigma.ι Xmap i
F : (∐ fun b => Xmap b) ⟶ Y := Sigma.desc f
Z : Sieve Y := Sieve.generate T
Xs : ExtrDisc := ∐ fun i => Xmap i
Zf : Sieve Y := Sieve.generate (ofArrows (fun x => Xs) fun x => F)
R : ExtrDisc
g : R ⟶ Y
W : ExtrDisc
σ : W ⟶ Y
ψ : R ⟶ ∐ fun i => Xmap i
hW' : ψ ≫ Sigma.desc f = g
Q : ExtrDisc
q : Q ⟶ ∐ Xmap
E : ExtrDisc
r : E ⟶ ∐ Xmap
i✝ : I
e : Q ⟶ Xmap i✝
hq : ofArrows Xmap (fun i => Sigma.ι Xmap i) (Sigma.ι Xmap i✝) ∧ e ≫ Sigma.ι Xmap i✝ = q
⊢ ofArrows Xmap f (Sigma.ι Xmap i✝ ≫ F)
TACTIC:
|
https://github.com/adamtopaz/CopenhagenMasterclass2023.git | a293ca1554f7e80d891fd4d86fb092c54d8a0a01 | ExtrDisc/ExplicitSheaves.lean | ExtrDisc.extensiveRegular_generates_coherent | [108, 1] | [217, 21] | simp only [colimit.ι_desc, Cofan.mk_pt, Cofan.mk_ι_app] | case this.intro.intro.intro.refine'_1.mk
X : ExtrDisc
S : Sieve X
Y : ExtrDisc
T : Presieve Y
I : Type
hI : Fintype I
Xmap : I → ExtrDisc
f : (a : I) → Xmap a ⟶ Y
h : T = ofArrows Xmap f
hT : Epi (Sigma.desc f)
he : EffectiveEpiFamily Xmap f ↔ Epi (Sigma.desc f)
φ : (i : I) → Xmap i ⟶ ∐ Xmap := fun i => Sigma.ι Xmap i
F : (∐ fun b => Xmap b) ⟶ Y := Sigma.desc f
Z : Sieve Y := Sieve.generate T
Xs : ExtrDisc := ∐ fun i => Xmap i
Zf : Sieve Y := Sieve.generate (ofArrows (fun x => Xs) fun x => F)
R : ExtrDisc
g : R ⟶ Y
W : ExtrDisc
σ : W ⟶ Y
ψ : R ⟶ ∐ fun i => Xmap i
hW' : ψ ≫ Sigma.desc f = g
Q : ExtrDisc
q : Q ⟶ ∐ Xmap
E : ExtrDisc
r : E ⟶ ∐ Xmap
i✝ : I
e : Q ⟶ Xmap i✝
hq : ofArrows Xmap (fun i => Sigma.ι Xmap i) (Sigma.ι Xmap i✝) ∧ e ≫ Sigma.ι Xmap i✝ = q
⊢ ofArrows Xmap f (Sigma.ι Xmap i✝ ≫ Sigma.desc f) | case this.intro.intro.intro.refine'_1.mk
X : ExtrDisc
S : Sieve X
Y : ExtrDisc
T : Presieve Y
I : Type
hI : Fintype I
Xmap : I → ExtrDisc
f : (a : I) → Xmap a ⟶ Y
h : T = ofArrows Xmap f
hT : Epi (Sigma.desc f)
he : EffectiveEpiFamily Xmap f ↔ Epi (Sigma.desc f)
φ : (i : I) → Xmap i ⟶ ∐ Xmap := fun i => Sigma.ι Xmap i
F : (∐ fun b => Xmap b) ⟶ Y := Sigma.desc f
Z : Sieve Y := Sieve.generate T
Xs : ExtrDisc := ∐ fun i => Xmap i
Zf : Sieve Y := Sieve.generate (ofArrows (fun x => Xs) fun x => F)
R : ExtrDisc
g : R ⟶ Y
W : ExtrDisc
σ : W ⟶ Y
ψ : R ⟶ ∐ fun i => Xmap i
hW' : ψ ≫ Sigma.desc f = g
Q : ExtrDisc
q : Q ⟶ ∐ Xmap
E : ExtrDisc
r : E ⟶ ∐ Xmap
i✝ : I
e : Q ⟶ Xmap i✝
hq : ofArrows Xmap (fun i => Sigma.ι Xmap i) (Sigma.ι Xmap i✝) ∧ e ≫ Sigma.ι Xmap i✝ = q
⊢ ofArrows Xmap f (f i✝) | Please generate a tactic in lean4 to solve the state.
STATE:
case this.intro.intro.intro.refine'_1.mk
X : ExtrDisc
S : Sieve X
Y : ExtrDisc
T : Presieve Y
I : Type
hI : Fintype I
Xmap : I → ExtrDisc
f : (a : I) → Xmap a ⟶ Y
h : T = ofArrows Xmap f
hT : Epi (Sigma.desc f)
he : EffectiveEpiFamily Xmap f ↔ Epi (Sigma.desc f)
φ : (i : I) → Xmap i ⟶ ∐ Xmap := fun i => Sigma.ι Xmap i
F : (∐ fun b => Xmap b) ⟶ Y := Sigma.desc f
Z : Sieve Y := Sieve.generate T
Xs : ExtrDisc := ∐ fun i => Xmap i
Zf : Sieve Y := Sieve.generate (ofArrows (fun x => Xs) fun x => F)
R : ExtrDisc
g : R ⟶ Y
W : ExtrDisc
σ : W ⟶ Y
ψ : R ⟶ ∐ fun i => Xmap i
hW' : ψ ≫ Sigma.desc f = g
Q : ExtrDisc
q : Q ⟶ ∐ Xmap
E : ExtrDisc
r : E ⟶ ∐ Xmap
i✝ : I
e : Q ⟶ Xmap i✝
hq : ofArrows Xmap (fun i => Sigma.ι Xmap i) (Sigma.ι Xmap i✝) ∧ e ≫ Sigma.ι Xmap i✝ = q
⊢ ofArrows Xmap f (Sigma.ι Xmap i✝ ≫ Sigma.desc f)
TACTIC:
|
https://github.com/adamtopaz/CopenhagenMasterclass2023.git | a293ca1554f7e80d891fd4d86fb092c54d8a0a01 | ExtrDisc/ExplicitSheaves.lean | ExtrDisc.extensiveRegular_generates_coherent | [108, 1] | [217, 21] | exact Presieve.ofArrows.mk _ | case this.intro.intro.intro.refine'_1.mk
X : ExtrDisc
S : Sieve X
Y : ExtrDisc
T : Presieve Y
I : Type
hI : Fintype I
Xmap : I → ExtrDisc
f : (a : I) → Xmap a ⟶ Y
h : T = ofArrows Xmap f
hT : Epi (Sigma.desc f)
he : EffectiveEpiFamily Xmap f ↔ Epi (Sigma.desc f)
φ : (i : I) → Xmap i ⟶ ∐ Xmap := fun i => Sigma.ι Xmap i
F : (∐ fun b => Xmap b) ⟶ Y := Sigma.desc f
Z : Sieve Y := Sieve.generate T
Xs : ExtrDisc := ∐ fun i => Xmap i
Zf : Sieve Y := Sieve.generate (ofArrows (fun x => Xs) fun x => F)
R : ExtrDisc
g : R ⟶ Y
W : ExtrDisc
σ : W ⟶ Y
ψ : R ⟶ ∐ fun i => Xmap i
hW' : ψ ≫ Sigma.desc f = g
Q : ExtrDisc
q : Q ⟶ ∐ Xmap
E : ExtrDisc
r : E ⟶ ∐ Xmap
i✝ : I
e : Q ⟶ Xmap i✝
hq : ofArrows Xmap (fun i => Sigma.ι Xmap i) (Sigma.ι Xmap i✝) ∧ e ≫ Sigma.ι Xmap i✝ = q
⊢ ofArrows Xmap f (f i✝) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case this.intro.intro.intro.refine'_1.mk
X : ExtrDisc
S : Sieve X
Y : ExtrDisc
T : Presieve Y
I : Type
hI : Fintype I
Xmap : I → ExtrDisc
f : (a : I) → Xmap a ⟶ Y
h : T = ofArrows Xmap f
hT : Epi (Sigma.desc f)
he : EffectiveEpiFamily Xmap f ↔ Epi (Sigma.desc f)
φ : (i : I) → Xmap i ⟶ ∐ Xmap := fun i => Sigma.ι Xmap i
F : (∐ fun b => Xmap b) ⟶ Y := Sigma.desc f
Z : Sieve Y := Sieve.generate T
Xs : ExtrDisc := ∐ fun i => Xmap i
Zf : Sieve Y := Sieve.generate (ofArrows (fun x => Xs) fun x => F)
R : ExtrDisc
g : R ⟶ Y
W : ExtrDisc
σ : W ⟶ Y
ψ : R ⟶ ∐ fun i => Xmap i
hW' : ψ ≫ Sigma.desc f = g
Q : ExtrDisc
q : Q ⟶ ∐ Xmap
E : ExtrDisc
r : E ⟶ ∐ Xmap
i✝ : I
e : Q ⟶ Xmap i✝
hq : ofArrows Xmap (fun i => Sigma.ι Xmap i) (Sigma.ι Xmap i✝) ∧ e ≫ Sigma.ι Xmap i✝ = q
⊢ ofArrows Xmap f (f i✝)
TACTIC:
|
https://github.com/adamtopaz/CopenhagenMasterclass2023.git | a293ca1554f7e80d891fd4d86fb092c54d8a0a01 | ExtrDisc/ExplicitSheaves.lean | ExtrDisc.extensiveRegular_generates_coherent | [108, 1] | [217, 21] | rw [← hq.2] | case this.intro.intro.intro.refine'_2
X : ExtrDisc
S : Sieve X
Y : ExtrDisc
T : Presieve Y
I : Type
hI : Fintype I
Xmap : I → ExtrDisc
f : (a : I) → Xmap a ⟶ Y
h : T = ofArrows Xmap f
hT : Epi (Sigma.desc f)
he : EffectiveEpiFamily Xmap f ↔ Epi (Sigma.desc f)
φ : (i : I) → Xmap i ⟶ ∐ Xmap := fun i => Sigma.ι Xmap i
F : (∐ fun b => Xmap b) ⟶ Y := Sigma.desc f
Z : Sieve Y := Sieve.generate T
Xs : ExtrDisc := ∐ fun i => Xmap i
Zf : Sieve Y := Sieve.generate (ofArrows (fun x => Xs) fun x => F)
R : ExtrDisc
g : R ⟶ Y
W : ExtrDisc
σ : W ⟶ Y
ψ : R ⟶ ∐ fun i => Xmap i
hW' : ψ ≫ Sigma.desc f = g
Q : ExtrDisc
q : Q ⟶ ∐ Xmap
E : ExtrDisc
e : Q ⟶ E
r : E ⟶ ∐ Xmap
hq : ofArrows Xmap (fun i => Sigma.ι Xmap i) r ∧ e ≫ r = q
⊢ e ≫ r ≫ F = q ≫ Sigma.desc f | case this.intro.intro.intro.refine'_2
X : ExtrDisc
S : Sieve X
Y : ExtrDisc
T : Presieve Y
I : Type
hI : Fintype I
Xmap : I → ExtrDisc
f : (a : I) → Xmap a ⟶ Y
h : T = ofArrows Xmap f
hT : Epi (Sigma.desc f)
he : EffectiveEpiFamily Xmap f ↔ Epi (Sigma.desc f)
φ : (i : I) → Xmap i ⟶ ∐ Xmap := fun i => Sigma.ι Xmap i
F : (∐ fun b => Xmap b) ⟶ Y := Sigma.desc f
Z : Sieve Y := Sieve.generate T
Xs : ExtrDisc := ∐ fun i => Xmap i
Zf : Sieve Y := Sieve.generate (ofArrows (fun x => Xs) fun x => F)
R : ExtrDisc
g : R ⟶ Y
W : ExtrDisc
σ : W ⟶ Y
ψ : R ⟶ ∐ fun i => Xmap i
hW' : ψ ≫ Sigma.desc f = g
Q : ExtrDisc
q : Q ⟶ ∐ Xmap
E : ExtrDisc
e : Q ⟶ E
r : E ⟶ ∐ Xmap
hq : ofArrows Xmap (fun i => Sigma.ι Xmap i) r ∧ e ≫ r = q
⊢ e ≫ r ≫ F = (e ≫ r) ≫ Sigma.desc f | Please generate a tactic in lean4 to solve the state.
STATE:
case this.intro.intro.intro.refine'_2
X : ExtrDisc
S : Sieve X
Y : ExtrDisc
T : Presieve Y
I : Type
hI : Fintype I
Xmap : I → ExtrDisc
f : (a : I) → Xmap a ⟶ Y
h : T = ofArrows Xmap f
hT : Epi (Sigma.desc f)
he : EffectiveEpiFamily Xmap f ↔ Epi (Sigma.desc f)
φ : (i : I) → Xmap i ⟶ ∐ Xmap := fun i => Sigma.ι Xmap i
F : (∐ fun b => Xmap b) ⟶ Y := Sigma.desc f
Z : Sieve Y := Sieve.generate T
Xs : ExtrDisc := ∐ fun i => Xmap i
Zf : Sieve Y := Sieve.generate (ofArrows (fun x => Xs) fun x => F)
R : ExtrDisc
g : R ⟶ Y
W : ExtrDisc
σ : W ⟶ Y
ψ : R ⟶ ∐ fun i => Xmap i
hW' : ψ ≫ Sigma.desc f = g
Q : ExtrDisc
q : Q ⟶ ∐ Xmap
E : ExtrDisc
e : Q ⟶ E
r : E ⟶ ∐ Xmap
hq : ofArrows Xmap (fun i => Sigma.ι Xmap i) r ∧ e ≫ r = q
⊢ e ≫ r ≫ F = q ≫ Sigma.desc f
TACTIC:
|
https://github.com/adamtopaz/CopenhagenMasterclass2023.git | a293ca1554f7e80d891fd4d86fb092c54d8a0a01 | ExtrDisc/ExplicitSheaves.lean | ExtrDisc.extensiveRegular_generates_coherent | [108, 1] | [217, 21] | rfl | case this.intro.intro.intro.refine'_2
X : ExtrDisc
S : Sieve X
Y : ExtrDisc
T : Presieve Y
I : Type
hI : Fintype I
Xmap : I → ExtrDisc
f : (a : I) → Xmap a ⟶ Y
h : T = ofArrows Xmap f
hT : Epi (Sigma.desc f)
he : EffectiveEpiFamily Xmap f ↔ Epi (Sigma.desc f)
φ : (i : I) → Xmap i ⟶ ∐ Xmap := fun i => Sigma.ι Xmap i
F : (∐ fun b => Xmap b) ⟶ Y := Sigma.desc f
Z : Sieve Y := Sieve.generate T
Xs : ExtrDisc := ∐ fun i => Xmap i
Zf : Sieve Y := Sieve.generate (ofArrows (fun x => Xs) fun x => F)
R : ExtrDisc
g : R ⟶ Y
W : ExtrDisc
σ : W ⟶ Y
ψ : R ⟶ ∐ fun i => Xmap i
hW' : ψ ≫ Sigma.desc f = g
Q : ExtrDisc
q : Q ⟶ ∐ Xmap
E : ExtrDisc
e : Q ⟶ E
r : E ⟶ ∐ Xmap
hq : ofArrows Xmap (fun i => Sigma.ι Xmap i) r ∧ e ≫ r = q
⊢ e ≫ r ≫ F = (e ≫ r) ≫ Sigma.desc f | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case this.intro.intro.intro.refine'_2
X : ExtrDisc
S : Sieve X
Y : ExtrDisc
T : Presieve Y
I : Type
hI : Fintype I
Xmap : I → ExtrDisc
f : (a : I) → Xmap a ⟶ Y
h : T = ofArrows Xmap f
hT : Epi (Sigma.desc f)
he : EffectiveEpiFamily Xmap f ↔ Epi (Sigma.desc f)
φ : (i : I) → Xmap i ⟶ ∐ Xmap := fun i => Sigma.ι Xmap i
F : (∐ fun b => Xmap b) ⟶ Y := Sigma.desc f
Z : Sieve Y := Sieve.generate T
Xs : ExtrDisc := ∐ fun i => Xmap i
Zf : Sieve Y := Sieve.generate (ofArrows (fun x => Xs) fun x => F)
R : ExtrDisc
g : R ⟶ Y
W : ExtrDisc
σ : W ⟶ Y
ψ : R ⟶ ∐ fun i => Xmap i
hW' : ψ ≫ Sigma.desc f = g
Q : ExtrDisc
q : Q ⟶ ∐ Xmap
E : ExtrDisc
e : Q ⟶ E
r : E ⟶ ∐ Xmap
hq : ofArrows Xmap (fun i => Sigma.ι Xmap i) r ∧ e ≫ r = q
⊢ e ≫ r ≫ F = (e ≫ r) ≫ Sigma.desc f
TACTIC:
|
https://github.com/adamtopaz/CopenhagenMasterclass2023.git | a293ca1554f7e80d891fd4d86fb092c54d8a0a01 | ExtrDisc/ExplicitSheaves.lean | ExtrDisc.extensiveRegular_generates_coherent | [108, 1] | [217, 21] | apply Coverage.saturate.top | case h.h.h.mpr.top
X : ExtrDisc
S : Sieve X
X✝ : ExtrDisc
⊢ ⊤ ∈
GrothendieckTopology.sieves
(Coverage.toGrothendieck ExtrDisc
(ExtensiveRegularCoverage ExtrDisc everything_proj
(_ :
∀ {α : Type} [inst : Fintype α] {X : ExtrDisc} {Z : α → ExtrDisc} (π : (a : α) → Z a ⟶ X) {Y : ExtrDisc}
(f : Y ⟶ X) (x : IsIso (Sigma.desc π)), IsIso (Sigma.desc fun x_1 => Limits.pullback.fst))))
X✝ | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case h.h.h.mpr.top
X : ExtrDisc
S : Sieve X
X✝ : ExtrDisc
⊢ ⊤ ∈
GrothendieckTopology.sieves
(Coverage.toGrothendieck ExtrDisc
(ExtensiveRegularCoverage ExtrDisc everything_proj
(_ :
∀ {α : Type} [inst : Fintype α] {X : ExtrDisc} {Z : α → ExtrDisc} (π : (a : α) → Z a ⟶ X) {Y : ExtrDisc}
(f : Y ⟶ X) (x : IsIso (Sigma.desc π)), IsIso (Sigma.desc fun x_1 => Limits.pullback.fst))))
X✝
TACTIC:
|
https://github.com/adamtopaz/CopenhagenMasterclass2023.git | a293ca1554f7e80d891fd4d86fb092c54d8a0a01 | ExtrDisc/ExplicitSheaves.lean | ExtrDisc.extensiveRegular_generates_coherent | [108, 1] | [217, 21] | apply Coverage.saturate.transitive Y T | case h.h.h.mpr.transitive
X : ExtrDisc
S : Sieve X
Y : ExtrDisc
T S✝ : Sieve Y
a✝¹ : Coverage.saturate (coherentCoverage ExtrDisc) Y T
a✝ :
∀ ⦃Y_1 : ExtrDisc⦄ ⦃f : Y_1 ⟶ Y⦄, T.arrows f → Coverage.saturate (coherentCoverage ExtrDisc) Y_1 (Sieve.pullback f S✝)
a_ih✝¹ :
T ∈
GrothendieckTopology.sieves
(Coverage.toGrothendieck ExtrDisc
(ExtensiveRegularCoverage ExtrDisc everything_proj
(_ :
∀ {α : Type} [inst : Fintype α] {X : ExtrDisc} {Z : α → ExtrDisc} (π : (a : α) → Z a ⟶ X) {Y : ExtrDisc}
(f : Y ⟶ X) (x : IsIso (Sigma.desc π)), IsIso (Sigma.desc fun x_1 => Limits.pullback.fst))))
Y
a_ih✝ :
∀ ⦃Y_1 : ExtrDisc⦄ ⦃f : Y_1 ⟶ Y⦄,
T.arrows f →
Sieve.pullback f S✝ ∈
GrothendieckTopology.sieves
(Coverage.toGrothendieck ExtrDisc
(ExtensiveRegularCoverage ExtrDisc everything_proj
(_ :
∀ {α : Type} [inst : Fintype α] {X : ExtrDisc} {Z : α → ExtrDisc} (π : (a : α) → Z a ⟶ X) {Y : ExtrDisc}
(f : Y ⟶ X) (x : IsIso (Sigma.desc π)), IsIso (Sigma.desc fun x_1 => Limits.pullback.fst))))
Y_1
⊢ S✝ ∈
GrothendieckTopology.sieves
(Coverage.toGrothendieck ExtrDisc
(ExtensiveRegularCoverage ExtrDisc everything_proj
(_ :
∀ {α : Type} [inst : Fintype α] {X : ExtrDisc} {Z : α → ExtrDisc} (π : (a : α) → Z a ⟶ X) {Y : ExtrDisc}
(f : Y ⟶ X) (x : IsIso (Sigma.desc π)), IsIso (Sigma.desc fun x_1 => Limits.pullback.fst))))
Y | case h.h.h.mpr.transitive.a
X : ExtrDisc
S : Sieve X
Y : ExtrDisc
T S✝ : Sieve Y
a✝¹ : Coverage.saturate (coherentCoverage ExtrDisc) Y T
a✝ :
∀ ⦃Y_1 : ExtrDisc⦄ ⦃f : Y_1 ⟶ Y⦄, T.arrows f → Coverage.saturate (coherentCoverage ExtrDisc) Y_1 (Sieve.pullback f S✝)
a_ih✝¹ :
T ∈
GrothendieckTopology.sieves
(Coverage.toGrothendieck ExtrDisc
(ExtensiveRegularCoverage ExtrDisc everything_proj
(_ :
∀ {α : Type} [inst : Fintype α] {X : ExtrDisc} {Z : α → ExtrDisc} (π : (a : α) → Z a ⟶ X) {Y : ExtrDisc}
(f : Y ⟶ X) (x : IsIso (Sigma.desc π)), IsIso (Sigma.desc fun x_1 => Limits.pullback.fst))))
Y
a_ih✝ :
∀ ⦃Y_1 : ExtrDisc⦄ ⦃f : Y_1 ⟶ Y⦄,
T.arrows f →
Sieve.pullback f S✝ ∈
GrothendieckTopology.sieves
(Coverage.toGrothendieck ExtrDisc
(ExtensiveRegularCoverage ExtrDisc everything_proj
(_ :
∀ {α : Type} [inst : Fintype α] {X : ExtrDisc} {Z : α → ExtrDisc} (π : (a : α) → Z a ⟶ X) {Y : ExtrDisc}
(f : Y ⟶ X) (x : IsIso (Sigma.desc π)), IsIso (Sigma.desc fun x_1 => Limits.pullback.fst))))
Y_1
⊢ Coverage.saturate
(ExtensiveRegularCoverage ExtrDisc everything_proj
(_ :
∀ {α : Type} [inst : Fintype α] {X : ExtrDisc} {Z : α → ExtrDisc} (π : (a : α) → Z a ⟶ X) {Y : ExtrDisc}
(f : Y ⟶ X) (x : IsIso (Sigma.desc π)), IsIso (Sigma.desc fun x_1 => Limits.pullback.fst)))
Y T
case h.h.h.mpr.transitive.a
X : ExtrDisc
S : Sieve X
Y : ExtrDisc
T S✝ : Sieve Y
a✝¹ : Coverage.saturate (coherentCoverage ExtrDisc) Y T
a✝ :
∀ ⦃Y_1 : ExtrDisc⦄ ⦃f : Y_1 ⟶ Y⦄, T.arrows f → Coverage.saturate (coherentCoverage ExtrDisc) Y_1 (Sieve.pullback f S✝)
a_ih✝¹ :
T ∈
GrothendieckTopology.sieves
(Coverage.toGrothendieck ExtrDisc
(ExtensiveRegularCoverage ExtrDisc everything_proj
(_ :
∀ {α : Type} [inst : Fintype α] {X : ExtrDisc} {Z : α → ExtrDisc} (π : (a : α) → Z a ⟶ X) {Y : ExtrDisc}
(f : Y ⟶ X) (x : IsIso (Sigma.desc π)), IsIso (Sigma.desc fun x_1 => Limits.pullback.fst))))
Y
a_ih✝ :
∀ ⦃Y_1 : ExtrDisc⦄ ⦃f : Y_1 ⟶ Y⦄,
T.arrows f →
Sieve.pullback f S✝ ∈
GrothendieckTopology.sieves
(Coverage.toGrothendieck ExtrDisc
(ExtensiveRegularCoverage ExtrDisc everything_proj
(_ :
∀ {α : Type} [inst : Fintype α] {X : ExtrDisc} {Z : α → ExtrDisc} (π : (a : α) → Z a ⟶ X) {Y : ExtrDisc}
(f : Y ⟶ X) (x : IsIso (Sigma.desc π)), IsIso (Sigma.desc fun x_1 => Limits.pullback.fst))))
Y_1
⊢ ∀ ⦃Y_1 : ExtrDisc⦄ ⦃f : Y_1 ⟶ Y⦄,
T.arrows f →
Coverage.saturate
(ExtensiveRegularCoverage ExtrDisc everything_proj
(_ :
∀ {α : Type} [inst : Fintype α] {X : ExtrDisc} {Z : α → ExtrDisc} (π : (a : α) → Z a ⟶ X) {Y : ExtrDisc}
(f : Y ⟶ X) (x : IsIso (Sigma.desc π)), IsIso (Sigma.desc fun x_1 => Limits.pullback.fst)))
Y_1 (Sieve.pullback f S✝) | Please generate a tactic in lean4 to solve the state.
STATE:
case h.h.h.mpr.transitive
X : ExtrDisc
S : Sieve X
Y : ExtrDisc
T S✝ : Sieve Y
a✝¹ : Coverage.saturate (coherentCoverage ExtrDisc) Y T
a✝ :
∀ ⦃Y_1 : ExtrDisc⦄ ⦃f : Y_1 ⟶ Y⦄, T.arrows f → Coverage.saturate (coherentCoverage ExtrDisc) Y_1 (Sieve.pullback f S✝)
a_ih✝¹ :
T ∈
GrothendieckTopology.sieves
(Coverage.toGrothendieck ExtrDisc
(ExtensiveRegularCoverage ExtrDisc everything_proj
(_ :
∀ {α : Type} [inst : Fintype α] {X : ExtrDisc} {Z : α → ExtrDisc} (π : (a : α) → Z a ⟶ X) {Y : ExtrDisc}
(f : Y ⟶ X) (x : IsIso (Sigma.desc π)), IsIso (Sigma.desc fun x_1 => Limits.pullback.fst))))
Y
a_ih✝ :
∀ ⦃Y_1 : ExtrDisc⦄ ⦃f : Y_1 ⟶ Y⦄,
T.arrows f →
Sieve.pullback f S✝ ∈
GrothendieckTopology.sieves
(Coverage.toGrothendieck ExtrDisc
(ExtensiveRegularCoverage ExtrDisc everything_proj
(_ :
∀ {α : Type} [inst : Fintype α] {X : ExtrDisc} {Z : α → ExtrDisc} (π : (a : α) → Z a ⟶ X) {Y : ExtrDisc}
(f : Y ⟶ X) (x : IsIso (Sigma.desc π)), IsIso (Sigma.desc fun x_1 => Limits.pullback.fst))))
Y_1
⊢ S✝ ∈
GrothendieckTopology.sieves
(Coverage.toGrothendieck ExtrDisc
(ExtensiveRegularCoverage ExtrDisc everything_proj
(_ :
∀ {α : Type} [inst : Fintype α] {X : ExtrDisc} {Z : α → ExtrDisc} (π : (a : α) → Z a ⟶ X) {Y : ExtrDisc}
(f : Y ⟶ X) (x : IsIso (Sigma.desc π)), IsIso (Sigma.desc fun x_1 => Limits.pullback.fst))))
Y
TACTIC:
|
https://github.com/adamtopaz/CopenhagenMasterclass2023.git | a293ca1554f7e80d891fd4d86fb092c54d8a0a01 | ExtrDisc/ExplicitSheaves.lean | ExtrDisc.extensiveRegular_generates_coherent | [108, 1] | [217, 21] | assumption | case h.h.h.mpr.transitive.a
X : ExtrDisc
S : Sieve X
Y : ExtrDisc
T S✝ : Sieve Y
a✝¹ : Coverage.saturate (coherentCoverage ExtrDisc) Y T
a✝ :
∀ ⦃Y_1 : ExtrDisc⦄ ⦃f : Y_1 ⟶ Y⦄, T.arrows f → Coverage.saturate (coherentCoverage ExtrDisc) Y_1 (Sieve.pullback f S✝)
a_ih✝¹ :
T ∈
GrothendieckTopology.sieves
(Coverage.toGrothendieck ExtrDisc
(ExtensiveRegularCoverage ExtrDisc everything_proj
(_ :
∀ {α : Type} [inst : Fintype α] {X : ExtrDisc} {Z : α → ExtrDisc} (π : (a : α) → Z a ⟶ X) {Y : ExtrDisc}
(f : Y ⟶ X) (x : IsIso (Sigma.desc π)), IsIso (Sigma.desc fun x_1 => Limits.pullback.fst))))
Y
a_ih✝ :
∀ ⦃Y_1 : ExtrDisc⦄ ⦃f : Y_1 ⟶ Y⦄,
T.arrows f →
Sieve.pullback f S✝ ∈
GrothendieckTopology.sieves
(Coverage.toGrothendieck ExtrDisc
(ExtensiveRegularCoverage ExtrDisc everything_proj
(_ :
∀ {α : Type} [inst : Fintype α] {X : ExtrDisc} {Z : α → ExtrDisc} (π : (a : α) → Z a ⟶ X) {Y : ExtrDisc}
(f : Y ⟶ X) (x : IsIso (Sigma.desc π)), IsIso (Sigma.desc fun x_1 => Limits.pullback.fst))))
Y_1
⊢ Coverage.saturate
(ExtensiveRegularCoverage ExtrDisc everything_proj
(_ :
∀ {α : Type} [inst : Fintype α] {X : ExtrDisc} {Z : α → ExtrDisc} (π : (a : α) → Z a ⟶ X) {Y : ExtrDisc}
(f : Y ⟶ X) (x : IsIso (Sigma.desc π)), IsIso (Sigma.desc fun x_1 => Limits.pullback.fst)))
Y T | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case h.h.h.mpr.transitive.a
X : ExtrDisc
S : Sieve X
Y : ExtrDisc
T S✝ : Sieve Y
a✝¹ : Coverage.saturate (coherentCoverage ExtrDisc) Y T
a✝ :
∀ ⦃Y_1 : ExtrDisc⦄ ⦃f : Y_1 ⟶ Y⦄, T.arrows f → Coverage.saturate (coherentCoverage ExtrDisc) Y_1 (Sieve.pullback f S✝)
a_ih✝¹ :
T ∈
GrothendieckTopology.sieves
(Coverage.toGrothendieck ExtrDisc
(ExtensiveRegularCoverage ExtrDisc everything_proj
(_ :
∀ {α : Type} [inst : Fintype α] {X : ExtrDisc} {Z : α → ExtrDisc} (π : (a : α) → Z a ⟶ X) {Y : ExtrDisc}
(f : Y ⟶ X) (x : IsIso (Sigma.desc π)), IsIso (Sigma.desc fun x_1 => Limits.pullback.fst))))
Y
a_ih✝ :
∀ ⦃Y_1 : ExtrDisc⦄ ⦃f : Y_1 ⟶ Y⦄,
T.arrows f →
Sieve.pullback f S✝ ∈
GrothendieckTopology.sieves
(Coverage.toGrothendieck ExtrDisc
(ExtensiveRegularCoverage ExtrDisc everything_proj
(_ :
∀ {α : Type} [inst : Fintype α] {X : ExtrDisc} {Z : α → ExtrDisc} (π : (a : α) → Z a ⟶ X) {Y : ExtrDisc}
(f : Y ⟶ X) (x : IsIso (Sigma.desc π)), IsIso (Sigma.desc fun x_1 => Limits.pullback.fst))))
Y_1
⊢ Coverage.saturate
(ExtensiveRegularCoverage ExtrDisc everything_proj
(_ :
∀ {α : Type} [inst : Fintype α] {X : ExtrDisc} {Z : α → ExtrDisc} (π : (a : α) → Z a ⟶ X) {Y : ExtrDisc}
(f : Y ⟶ X) (x : IsIso (Sigma.desc π)), IsIso (Sigma.desc fun x_1 => Limits.pullback.fst)))
Y T
TACTIC:
|
https://github.com/adamtopaz/CopenhagenMasterclass2023.git | a293ca1554f7e80d891fd4d86fb092c54d8a0a01 | ExtrDisc/ExplicitSheaves.lean | ExtrDisc.extensiveRegular_generates_coherent | [108, 1] | [217, 21] | assumption | case h.h.h.mpr.transitive.a
X : ExtrDisc
S : Sieve X
Y : ExtrDisc
T S✝ : Sieve Y
a✝¹ : Coverage.saturate (coherentCoverage ExtrDisc) Y T
a✝ :
∀ ⦃Y_1 : ExtrDisc⦄ ⦃f : Y_1 ⟶ Y⦄, T.arrows f → Coverage.saturate (coherentCoverage ExtrDisc) Y_1 (Sieve.pullback f S✝)
a_ih✝¹ :
T ∈
GrothendieckTopology.sieves
(Coverage.toGrothendieck ExtrDisc
(ExtensiveRegularCoverage ExtrDisc everything_proj
(_ :
∀ {α : Type} [inst : Fintype α] {X : ExtrDisc} {Z : α → ExtrDisc} (π : (a : α) → Z a ⟶ X) {Y : ExtrDisc}
(f : Y ⟶ X) (x : IsIso (Sigma.desc π)), IsIso (Sigma.desc fun x_1 => Limits.pullback.fst))))
Y
a_ih✝ :
∀ ⦃Y_1 : ExtrDisc⦄ ⦃f : Y_1 ⟶ Y⦄,
T.arrows f →
Sieve.pullback f S✝ ∈
GrothendieckTopology.sieves
(Coverage.toGrothendieck ExtrDisc
(ExtensiveRegularCoverage ExtrDisc everything_proj
(_ :
∀ {α : Type} [inst : Fintype α] {X : ExtrDisc} {Z : α → ExtrDisc} (π : (a : α) → Z a ⟶ X) {Y : ExtrDisc}
(f : Y ⟶ X) (x : IsIso (Sigma.desc π)), IsIso (Sigma.desc fun x_1 => Limits.pullback.fst))))
Y_1
⊢ ∀ ⦃Y_1 : ExtrDisc⦄ ⦃f : Y_1 ⟶ Y⦄,
T.arrows f →
Coverage.saturate
(ExtensiveRegularCoverage ExtrDisc everything_proj
(_ :
∀ {α : Type} [inst : Fintype α] {X : ExtrDisc} {Z : α → ExtrDisc} (π : (a : α) → Z a ⟶ X) {Y : ExtrDisc}
(f : Y ⟶ X) (x : IsIso (Sigma.desc π)), IsIso (Sigma.desc fun x_1 => Limits.pullback.fst)))
Y_1 (Sieve.pullback f S✝) | no goals | Please generate a tactic in lean4 to solve the state.
STATE:
case h.h.h.mpr.transitive.a
X : ExtrDisc
S : Sieve X
Y : ExtrDisc
T S✝ : Sieve Y
a✝¹ : Coverage.saturate (coherentCoverage ExtrDisc) Y T
a✝ :
∀ ⦃Y_1 : ExtrDisc⦄ ⦃f : Y_1 ⟶ Y⦄, T.arrows f → Coverage.saturate (coherentCoverage ExtrDisc) Y_1 (Sieve.pullback f S✝)
a_ih✝¹ :
T ∈
GrothendieckTopology.sieves
(Coverage.toGrothendieck ExtrDisc
(ExtensiveRegularCoverage ExtrDisc everything_proj
(_ :
∀ {α : Type} [inst : Fintype α] {X : ExtrDisc} {Z : α → ExtrDisc} (π : (a : α) → Z a ⟶ X) {Y : ExtrDisc}
(f : Y ⟶ X) (x : IsIso (Sigma.desc π)), IsIso (Sigma.desc fun x_1 => Limits.pullback.fst))))
Y
a_ih✝ :
∀ ⦃Y_1 : ExtrDisc⦄ ⦃f : Y_1 ⟶ Y⦄,
T.arrows f →
Sieve.pullback f S✝ ∈
GrothendieckTopology.sieves
(Coverage.toGrothendieck ExtrDisc
(ExtensiveRegularCoverage ExtrDisc everything_proj
(_ :
∀ {α : Type} [inst : Fintype α] {X : ExtrDisc} {Z : α → ExtrDisc} (π : (a : α) → Z a ⟶ X) {Y : ExtrDisc}
(f : Y ⟶ X) (x : IsIso (Sigma.desc π)), IsIso (Sigma.desc fun x_1 => Limits.pullback.fst))))
Y_1
⊢ ∀ ⦃Y_1 : ExtrDisc⦄ ⦃f : Y_1 ⟶ Y⦄,
T.arrows f →
Coverage.saturate
(ExtensiveRegularCoverage ExtrDisc everything_proj
(_ :
∀ {α : Type} [inst : Fintype α] {X : ExtrDisc} {Z : α → ExtrDisc} (π : (a : α) → Z a ⟶ X) {Y : ExtrDisc}
(f : Y ⟶ X) (x : IsIso (Sigma.desc π)), IsIso (Sigma.desc fun x_1 => Limits.pullback.fst)))
Y_1 (Sieve.pullback f S✝)
TACTIC:
|
https://github.com/adamtopaz/CopenhagenMasterclass2023.git | a293ca1554f7e80d891fd4d86fb092c54d8a0a01 | ExtrDisc/ExplicitSheaves.lean | ExtrDisc.isSheafForRegularSieve | [219, 1] | [241, 40] | obtain ⟨Y, f, rfl, hf⟩ := hS | X : ExtrDisc
S : Presieve X
hS : S ∈ RegularSieve X
F : ExtrDiscᵒᵖ ⥤ Type (u + 1)
⊢ IsSheafFor F S | case intro.intro.intro
X : ExtrDisc
F : ExtrDiscᵒᵖ ⥤ Type (u + 1)
Y : ExtrDisc
f : Y ⟶ X
hf : Epi f
⊢ IsSheafFor F (ofArrows (fun x => Y) fun x => f) | Please generate a tactic in lean4 to solve the state.
STATE:
X : ExtrDisc
S : Presieve X
hS : S ∈ RegularSieve X
F : ExtrDiscᵒᵖ ⥤ Type (u + 1)
⊢ IsSheafFor F S
TACTIC:
|
https://github.com/adamtopaz/CopenhagenMasterclass2023.git | a293ca1554f7e80d891fd4d86fb092c54d8a0a01 | ExtrDisc/ExplicitSheaves.lean | ExtrDisc.isSheafForRegularSieve | [219, 1] | [241, 40] | have proj : Projective (toCompHaus.obj X) := inferInstanceAs (Projective X.compHaus) | case intro.intro.intro
X : ExtrDisc
F : ExtrDiscᵒᵖ ⥤ Type (u + 1)
Y : ExtrDisc
f : Y ⟶ X
hf : Epi f
⊢ IsSheafFor F (ofArrows (fun x => Y) fun x => f) | case intro.intro.intro
X : ExtrDisc
F : ExtrDiscᵒᵖ ⥤ Type (u + 1)
Y : ExtrDisc
f : Y ⟶ X
hf : Epi f
proj : Projective (toCompHaus.obj X)
⊢ IsSheafFor F (ofArrows (fun x => Y) fun x => f) | Please generate a tactic in lean4 to solve the state.
STATE:
case intro.intro.intro
X : ExtrDisc
F : ExtrDiscᵒᵖ ⥤ Type (u + 1)
Y : ExtrDisc
f : Y ⟶ X
hf : Epi f
⊢ IsSheafFor F (ofArrows (fun x => Y) fun x => f)
TACTIC:
|
https://github.com/adamtopaz/CopenhagenMasterclass2023.git | a293ca1554f7e80d891fd4d86fb092c54d8a0a01 | ExtrDisc/ExplicitSheaves.lean | ExtrDisc.isSheafForRegularSieve | [219, 1] | [241, 40] | have : Epi (toCompHaus.map f) := by
rw [CompHaus.epi_iff_surjective]
change Function.Surjective f
rwa [← ExtrDisc.epi_iff_surjective] | case intro.intro.intro
X : ExtrDisc
F : ExtrDiscᵒᵖ ⥤ Type (u + 1)
Y : ExtrDisc
f : Y ⟶ X
hf : Epi f
proj : Projective (toCompHaus.obj X)
⊢ IsSheafFor F (ofArrows (fun x => Y) fun x => f) | case intro.intro.intro
X : ExtrDisc
F : ExtrDiscᵒᵖ ⥤ Type (u + 1)
Y : ExtrDisc
f : Y ⟶ X
hf : Epi f
proj : Projective (toCompHaus.obj X)
this : Epi (toCompHaus.map f)
⊢ IsSheafFor F (ofArrows (fun x => Y) fun x => f) | Please generate a tactic in lean4 to solve the state.
STATE:
case intro.intro.intro
X : ExtrDisc
F : ExtrDiscᵒᵖ ⥤ Type (u + 1)
Y : ExtrDisc
f : Y ⟶ X
hf : Epi f
proj : Projective (toCompHaus.obj X)
⊢ IsSheafFor F (ofArrows (fun x => Y) fun x => f)
TACTIC:
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.