[GOAL]
ι : Type u_1
α : Type u_2
inst✝ : SemilatticeSup α
a b c : α
⊢ ¬SupIrred a ↔ IsMin a ∨ ∃ b c, b ⊔ c = a ∧ b < a ∧ c < a
[PROOFSTEP]
rw [SupIrred, not_and_or]
[GOAL]
ι : Type u_1
α : Type u_2
inst✝ : SemilatticeSup α
a b c : α
⊢ (¬¬IsMin a ∨ ¬∀ ⦃b c : α⦄, b ⊔ c = a → b = a ∨ c = a) ↔ IsMin a ∨ ∃ b c, b ⊔ c = a ∧ b < a ∧ c < a
[PROOFSTEP]
push_neg
[GOAL]
ι : Type u_1
α : Type u_2
inst✝ : SemilatticeSup α
a b c : α
⊢ (IsMin a ∨ Exists fun ⦃b⦄ => Exists fun ⦃c⦄ => b ⊔ c = a ∧ b ≠ a ∧ c ≠ a) ↔ IsMin a ∨ ∃ b c, b ⊔ c = a ∧ b < a ∧ c < a
[PROOFSTEP]
rw [exists₂_congr]
[GOAL]
ι : Type u_1
α : Type u_2
inst✝ : SemilatticeSup α
a b c : α
⊢ ∀ (a_1 b : α), a_1 ⊔ b = a ∧ a_1 ≠ a ∧ b ≠ a ↔ a_1 ⊔ b = a ∧ a_1 < a ∧ b < a
[PROOFSTEP]
simp (config := { contextual := true }) [@eq_comm _ _ a]
[GOAL]
ι : Type u_1
α : Type u_2
inst✝ : SemilatticeSup α
a b c : α
⊢ ¬SupPrime a ↔ IsMin a ∨ ∃ b c, a ≤ b ⊔ c ∧ ¬a ≤ b ∧ ¬a ≤ c
[PROOFSTEP]
rw [SupPrime, not_and_or]
[GOAL]
ι : Type u_1
α : Type u_2
inst✝ : SemilatticeSup α
a b c : α
⊢ (¬¬IsMin a ∨ ¬∀ ⦃b c : α⦄, a ≤ b ⊔ c → a ≤ b ∨ a ≤ c) ↔ IsMin a ∨ ∃ b c, a ≤ b ⊔ c ∧ ¬a ≤ b ∧ ¬a ≤ c
[PROOFSTEP]
push_neg
[GOAL]
ι : Type u_1
α : Type u_2
inst✝ : SemilatticeSup α
a b c : α
⊢ (IsMin a ∨ Exists fun ⦃b⦄ => Exists fun ⦃c⦄ => a ≤ b ⊔ c ∧ ¬a ≤ b ∧ ¬a ≤ c) ↔
    IsMin a ∨ ∃ b c, a ≤ b ⊔ c ∧ ¬a ≤ b ∧ ¬a ≤ c
[PROOFSTEP]
rfl
[GOAL]
ι : Type u_1
α : Type u_2
inst✝ : SemilatticeSup α
a b✝ c✝ : α
h : ∀ ⦃b c : α⦄, a ≤ b ⊔ c → a ≤ b ∨ a ≤ c
b c : α
ha : b ⊔ c = a
⊢ b = a ∨ c = a
[PROOFSTEP]
simpa [← ha] using h ha.ge
[GOAL]
ι : Type u_1
α : Type u_2
inst✝¹ : SemilatticeSup α
a b c : α
inst✝ : OrderBot α
s : Finset ι
f : ι → α
ha : SupIrred a
⊢ a ≠ ⊥
[PROOFSTEP]
rintro rfl
[GOAL]
ι : Type u_1
α : Type u_2
inst✝¹ : SemilatticeSup α
b c : α
inst✝ : OrderBot α
s : Finset ι
f : ι → α
ha : SupIrred ⊥
⊢ False
[PROOFSTEP]
exact not_supIrred_bot ha
[GOAL]
ι : Type u_1
α : Type u_2
inst✝¹ : SemilatticeSup α
a b c : α
inst✝ : OrderBot α
s : Finset ι
f : ι → α
ha : SupPrime a
⊢ a ≠ ⊥
[PROOFSTEP]
rintro rfl
[GOAL]
ι : Type u_1
α : Type u_2
inst✝¹ : SemilatticeSup α
b c : α
inst✝ : OrderBot α
s : Finset ι
f : ι → α
ha : SupPrime ⊥
⊢ False
[PROOFSTEP]
exact not_supPrime_bot ha
[GOAL]
ι : Type u_1
α : Type u_2
inst✝¹ : SemilatticeSup α
a b c : α
inst✝ : OrderBot α
s : Finset ι
f : ι → α
ha : SupIrred a
h : sup s f = a
⊢ ∃ i, i ∈ s ∧ f i = a
[PROOFSTEP]
classical
induction' s using Finset.induction with i s _ ih
· simpa [ha.ne_bot] using h.symm
simp only [exists_prop, exists_mem_insert] at ih ⊢
rw [sup_insert] at h
exact (ha.2 h).imp_right ih
[GOAL]
ι : Type u_1
α : Type u_2
inst✝¹ : SemilatticeSup α
a b c : α
inst✝ : OrderBot α
s : Finset ι
f : ι → α
ha : SupIrred a
h : sup s f = a
⊢ ∃ i, i ∈ s ∧ f i = a
[PROOFSTEP]
induction' s using Finset.induction with i s _ ih
[GOAL]
case empty
ι : Type u_1
α : Type u_2
inst✝¹ : SemilatticeSup α
a b c : α
inst✝ : OrderBot α
s : Finset ι
f : ι → α
ha : SupIrred a
h✝ : sup s f = a
h : sup ∅ f = a
⊢ ∃ i, i ∈ ∅ ∧ f i = a
[PROOFSTEP]
simpa [ha.ne_bot] using h.symm
[GOAL]
case insert
ι : Type u_1
α : Type u_2
inst✝¹ : SemilatticeSup α
a b c : α
inst✝ : OrderBot α
s✝ : Finset ι
f : ι → α
ha : SupIrred a
h✝ : sup s✝ f = a
i : ι
s : Finset ι
a✝ : ¬i ∈ s
ih : sup s f = a → ∃ i, i ∈ s ∧ f i = a
h : sup (insert i s) f = a
⊢ ∃ i_1, i_1 ∈ insert i s ∧ f i_1 = a
[PROOFSTEP]
simp only [exists_prop, exists_mem_insert] at ih ⊢
[GOAL]
case insert
ι : Type u_1
α : Type u_2
inst✝¹ : SemilatticeSup α
a b c : α
inst✝ : OrderBot α
s✝ : Finset ι
f : ι → α
ha : SupIrred a
h✝ : sup s✝ f = a
i : ι
s : Finset ι
a✝ : ¬i ∈ s
ih : sup s f = a → ∃ i, i ∈ s ∧ f i = a
h : sup (insert i s) f = a
⊢ f i = a ∨ ∃ x, x ∈ s ∧ f x = a
[PROOFSTEP]
rw [sup_insert] at h
[GOAL]
case insert
ι : Type u_1
α : Type u_2
inst✝¹ : SemilatticeSup α
a b c : α
inst✝ : OrderBot α
s✝ : Finset ι
f : ι → α
ha : SupIrred a
h✝ : sup s✝ f = a
i : ι
s : Finset ι
a✝ : ¬i ∈ s
ih : sup s f = a → ∃ i, i ∈ s ∧ f i = a
h : f i ⊔ sup s f = a
⊢ f i = a ∨ ∃ x, x ∈ s ∧ f x = a
[PROOFSTEP]
exact (ha.2 h).imp_right ih
[GOAL]
ι : Type u_1
α : Type u_2
inst✝¹ : SemilatticeSup α
a b c : α
inst✝ : OrderBot α
s : Finset ι
f : ι → α
ha : SupPrime a
⊢ a ≤ sup s f ↔ ∃ i, i ∈ s ∧ a ≤ f i
[PROOFSTEP]
classical
induction' s using Finset.induction with i s _ ih
· simp [ha.ne_bot]
· simp only [exists_prop, exists_mem_insert, sup_insert, ha.le_sup, ih]
[GOAL]
ι : Type u_1
α : Type u_2
inst✝¹ : SemilatticeSup α
a b c : α
inst✝ : OrderBot α
s : Finset ι
f : ι → α
ha : SupPrime a
⊢ a ≤ sup s f ↔ ∃ i, i ∈ s ∧ a ≤ f i
[PROOFSTEP]
induction' s using Finset.induction with i s _ ih
[GOAL]
case empty
ι : Type u_1
α : Type u_2
inst✝¹ : SemilatticeSup α
a b c : α
inst✝ : OrderBot α
s : Finset ι
f : ι → α
ha : SupPrime a
⊢ a ≤ sup ∅ f ↔ ∃ i, i ∈ ∅ ∧ a ≤ f i
[PROOFSTEP]
simp [ha.ne_bot]
[GOAL]
case insert
ι : Type u_1
α : Type u_2
inst✝¹ : SemilatticeSup α
a b c : α
inst✝ : OrderBot α
s✝ : Finset ι
f : ι → α
ha : SupPrime a
i : ι
s : Finset ι
a✝ : ¬i ∈ s
ih : a ≤ sup s f ↔ ∃ i, i ∈ s ∧ a ≤ f i
⊢ a ≤ sup (insert i s) f ↔ ∃ i_1, i_1 ∈ insert i s ∧ a ≤ f i_1
[PROOFSTEP]
simp only [exists_prop, exists_mem_insert, sup_insert, ha.le_sup, ih]
[GOAL]
ι : Type u_1
α : Type u_2
inst✝² : SemilatticeSup α
a✝ b c : α
inst✝¹ : OrderBot α
s : Finset ι
f : ι → α
inst✝ : WellFoundedLT α
a : α
⊢ ∃ s, sup s id = a ∧ ∀ ⦃b : α⦄, b ∈ s → SupIrred b
[PROOFSTEP]
classical
apply WellFoundedLT.induction a _
clear a
rintro a ih
by_cases ha : SupIrred a
· exact ⟨{ a }, by simp [ha]⟩
rw [not_supIrred] at ha
obtain ha | ⟨b, c, rfl, hb, hc⟩ := ha
· exact ⟨∅, by simp [ha.eq_bot]⟩
obtain ⟨s, rfl, hs⟩ := ih _ hb
obtain ⟨t, rfl, ht⟩ := ih _ hc
exact ⟨s ∪ t, sup_union, forall_mem_union.2 ⟨hs, ht⟩⟩
[GOAL]
ι : Type u_1
α : Type u_2
inst✝² : SemilatticeSup α
a✝ b c : α
inst✝¹ : OrderBot α
s : Finset ι
f : ι → α
inst✝ : WellFoundedLT α
a : α
⊢ ∃ s, sup s id = a ∧ ∀ ⦃b : α⦄, b ∈ s → SupIrred b
[PROOFSTEP]
apply WellFoundedLT.induction a _
[GOAL]
ι : Type u_1
α : Type u_2
inst✝² : SemilatticeSup α
a✝ b c : α
inst✝¹ : OrderBot α
s : Finset ι
f : ι → α
inst✝ : WellFoundedLT α
a : α
⊢ ∀ (x : α),
    (∀ (y : α), y < x → ∃ s, sup s id = y ∧ ∀ ⦃b : α⦄, b ∈ s → SupIrred b) →
      ∃ s, sup s id = x ∧ ∀ ⦃b : α⦄, b ∈ s → SupIrred b
[PROOFSTEP]
clear a
[GOAL]
ι : Type u_1
α : Type u_2
inst✝² : SemilatticeSup α
a b c : α
inst✝¹ : OrderBot α
s : Finset ι
f : ι → α
inst✝ : WellFoundedLT α
⊢ ∀ (x : α),
    (∀ (y : α), y < x → ∃ s, sup s id = y ∧ ∀ ⦃b : α⦄, b ∈ s → SupIrred b) →
      ∃ s, sup s id = x ∧ ∀ ⦃b : α⦄, b ∈ s → SupIrred b
[PROOFSTEP]
rintro a ih
[GOAL]
ι : Type u_1
α : Type u_2
inst✝² : SemilatticeSup α
a✝ b c : α
inst✝¹ : OrderBot α
s : Finset ι
f : ι → α
inst✝ : WellFoundedLT α
a : α
ih : ∀ (y : α), y < a → ∃ s, sup s id = y ∧ ∀ ⦃b : α⦄, b ∈ s → SupIrred b
⊢ ∃ s, sup s id = a ∧ ∀ ⦃b : α⦄, b ∈ s → SupIrred b
[PROOFSTEP]
by_cases ha : SupIrred a
[GOAL]
case pos
ι : Type u_1
α : Type u_2
inst✝² : SemilatticeSup α
a✝ b c : α
inst✝¹ : OrderBot α
s : Finset ι
f : ι → α
inst✝ : WellFoundedLT α
a : α
ih : ∀ (y : α), y < a → ∃ s, sup s id = y ∧ ∀ ⦃b : α⦄, b ∈ s → SupIrred b
ha : SupIrred a
⊢ ∃ s, sup s id = a ∧ ∀ ⦃b : α⦄, b ∈ s → SupIrred b
[PROOFSTEP]
exact ⟨{ a }, by simp [ha]⟩
[GOAL]
ι : Type u_1
α : Type u_2
inst✝² : SemilatticeSup α
a✝ b c : α
inst✝¹ : OrderBot α
s : Finset ι
f : ι → α
inst✝ : WellFoundedLT α
a : α
ih : ∀ (y : α), y < a → ∃ s, sup s id = y ∧ ∀ ⦃b : α⦄, b ∈ s → SupIrred b
ha : SupIrred a
⊢ sup {a} id = a ∧ ∀ ⦃b : α⦄, b ∈ {a} → SupIrred b
[PROOFSTEP]
simp [ha]
[GOAL]
case neg
ι : Type u_1
α : Type u_2
inst✝² : SemilatticeSup α
a✝ b c : α
inst✝¹ : OrderBot α
s : Finset ι
f : ι → α
inst✝ : WellFoundedLT α
a : α
ih : ∀ (y : α), y < a → ∃ s, sup s id = y ∧ ∀ ⦃b : α⦄, b ∈ s → SupIrred b
ha : ¬SupIrred a
⊢ ∃ s, sup s id = a ∧ ∀ ⦃b : α⦄, b ∈ s → SupIrred b
[PROOFSTEP]
rw [not_supIrred] at ha
[GOAL]
case neg
ι : Type u_1
α : Type u_2
inst✝² : SemilatticeSup α
a✝ b c : α
inst✝¹ : OrderBot α
s : Finset ι
f : ι → α
inst✝ : WellFoundedLT α
a : α
ih : ∀ (y : α), y < a → ∃ s, sup s id = y ∧ ∀ ⦃b : α⦄, b ∈ s → SupIrred b
ha : IsMin a ∨ ∃ b c, b ⊔ c = a ∧ b < a ∧ c < a
⊢ ∃ s, sup s id = a ∧ ∀ ⦃b : α⦄, b ∈ s → SupIrred b
[PROOFSTEP]
obtain ha | ⟨b, c, rfl, hb, hc⟩ := ha
[GOAL]
case neg.inl
ι : Type u_1
α : Type u_2
inst✝² : SemilatticeSup α
a✝ b c : α
inst✝¹ : OrderBot α
s : Finset ι
f : ι → α
inst✝ : WellFoundedLT α
a : α
ih : ∀ (y : α), y < a → ∃ s, sup s id = y ∧ ∀ ⦃b : α⦄, b ∈ s → SupIrred b
ha : IsMin a
⊢ ∃ s, sup s id = a ∧ ∀ ⦃b : α⦄, b ∈ s → SupIrred b
[PROOFSTEP]
exact ⟨∅, by simp [ha.eq_bot]⟩
[GOAL]
ι : Type u_1
α : Type u_2
inst✝² : SemilatticeSup α
a✝ b c : α
inst✝¹ : OrderBot α
s : Finset ι
f : ι → α
inst✝ : WellFoundedLT α
a : α
ih : ∀ (y : α), y < a → ∃ s, sup s id = y ∧ ∀ ⦃b : α⦄, b ∈ s → SupIrred b
ha : IsMin a
⊢ sup ∅ id = a ∧ ∀ ⦃b : α⦄, b ∈ ∅ → SupIrred b
[PROOFSTEP]
simp [ha.eq_bot]
[GOAL]
case neg.inr.intro.intro.intro.intro
ι : Type u_1
α : Type u_2
inst✝² : SemilatticeSup α
a b✝ c✝ : α
inst✝¹ : OrderBot α
s : Finset ι
f : ι → α
inst✝ : WellFoundedLT α
b c : α
ih : ∀ (y : α), y < b ⊔ c → ∃ s, sup s id = y ∧ ∀ ⦃b : α⦄, b ∈ s → SupIrred b
hb : b < b ⊔ c
hc : c < b ⊔ c
⊢ ∃ s, sup s id = b ⊔ c ∧ ∀ ⦃b : α⦄, b ∈ s → SupIrred b
[PROOFSTEP]
obtain ⟨s, rfl, hs⟩ := ih _ hb
[GOAL]
case neg.inr.intro.intro.intro.intro.intro.intro
ι : Type u_1
α : Type u_2
inst✝² : SemilatticeSup α
a b c✝ : α
inst✝¹ : OrderBot α
s✝ : Finset ι
f : ι → α
inst✝ : WellFoundedLT α
c : α
s : Finset α
hs : ∀ ⦃b : α⦄, b ∈ s → SupIrred b
ih : ∀ (y : α), y < sup s id ⊔ c → ∃ s, sup s id = y ∧ ∀ ⦃b : α⦄, b ∈ s → SupIrred b
hb : sup s id < sup s id ⊔ c
hc : c < sup s id ⊔ c
⊢ ∃ s_1, sup s_1 id = sup s id ⊔ c ∧ ∀ ⦃b : α⦄, b ∈ s_1 → SupIrred b
[PROOFSTEP]
obtain ⟨t, rfl, ht⟩ := ih _ hc
[GOAL]
case neg.inr.intro.intro.intro.intro.intro.intro.intro.intro
ι : Type u_1
α : Type u_2
inst✝² : SemilatticeSup α
a b c : α
inst✝¹ : OrderBot α
s✝ : Finset ι
f : ι → α
inst✝ : WellFoundedLT α
s : Finset α
hs : ∀ ⦃b : α⦄, b ∈ s → SupIrred b
t : Finset α
ht : ∀ ⦃b : α⦄, b ∈ t → SupIrred b
ih : ∀ (y : α), y < sup s id ⊔ sup t id → ∃ s, sup s id = y ∧ ∀ ⦃b : α⦄, b ∈ s → SupIrred b
hb : sup s id < sup s id ⊔ sup t id
hc : sup t id < sup s id ⊔ sup t id
⊢ ∃ s_1, sup s_1 id = sup s id ⊔ sup t id ∧ ∀ ⦃b : α⦄, b ∈ s_1 → SupIrred b
[PROOFSTEP]
exact ⟨s ∪ t, sup_union, forall_mem_union.2 ⟨hs, ht⟩⟩
[GOAL]
ι : Type u_1
α : Type u_2
inst✝ : SemilatticeInf α
a b✝ c✝ : α
h : ∀ ⦃b c : α⦄, b ⊓ c ≤ a → b ≤ a ∨ c ≤ a
b c : α
ha : b ⊓ c = a
⊢ b = a ∨ c = a
[PROOFSTEP]
simpa [← ha] using h ha.le
[GOAL]
ι : Type u_1
α : Type u_2
inst✝¹ : SemilatticeInf α
a b c : α
inst✝ : OrderTop α
s : Finset ι
f : ι → α
ha : InfIrred a
⊢ a ≠ ⊤
[PROOFSTEP]
rintro rfl
[GOAL]
ι : Type u_1
α : Type u_2
inst✝¹ : SemilatticeInf α
b c : α
inst✝ : OrderTop α
s : Finset ι
f : ι → α
ha : InfIrred ⊤
⊢ False
[PROOFSTEP]
exact not_infIrred_top ha
[GOAL]
ι : Type u_1
α : Type u_2
inst✝¹ : SemilatticeInf α
a b c : α
inst✝ : OrderTop α
s : Finset ι
f : ι → α
ha : InfPrime a
⊢ a ≠ ⊤
[PROOFSTEP]
rintro rfl
[GOAL]
ι : Type u_1
α : Type u_2
inst✝¹ : SemilatticeInf α
b c : α
inst✝ : OrderTop α
s : Finset ι
f : ι → α
ha : InfPrime ⊤
⊢ False
[PROOFSTEP]
exact not_infPrime_top ha
[GOAL]
ι : Type u_1
α : Type u_2
inst✝ : DistribLattice α
a b✝ c✝ : α
h : ∀ ⦃b c : α⦄, b ⊔ c = a → b = a ∨ c = a
b c : α
⊢ a ≤ b ⊔ c → a ≤ b ∨ a ≤ c
[PROOFSTEP]
simp_rw [← inf_eq_left, inf_sup_left]
[GOAL]
ι : Type u_1
α : Type u_2
inst✝ : DistribLattice α
a b✝ c✝ : α
h : ∀ ⦃b c : α⦄, b ⊔ c = a → b = a ∨ c = a
b c : α
⊢ a ⊓ b ⊔ a ⊓ c = a → a ⊓ b = a ∨ a ⊓ c = a
[PROOFSTEP]
exact @h _ _
[GOAL]
ι : Type u_1
α : Type u_2
inst✝ : DistribLattice α
a b✝ c✝ : α
h : ∀ ⦃b c : α⦄, b ⊓ c = a → b = a ∨ c = a
b c : α
⊢ b ⊓ c ≤ a → b ≤ a ∨ c ≤ a
[PROOFSTEP]
simp_rw [← sup_eq_left, sup_inf_left]
[GOAL]
ι : Type u_1
α : Type u_2
inst✝ : DistribLattice α
a b✝ c✝ : α
h : ∀ ⦃b c : α⦄, b ⊓ c = a → b = a ∨ c = a
b c : α
⊢ (a ⊔ b) ⊓ (a ⊔ c) = a → a ⊔ b = a ∨ a ⊔ c = a
[PROOFSTEP]
exact @h _ _
[GOAL]
ι : Type u_1
α : Type u_2
inst✝ : LinearOrder α
a : α
⊢ ∀ ⦃b c : α⦄, a ≤ b ⊔ c → a ≤ b ∨ a ≤ c
[PROOFSTEP]
simp
[GOAL]
ι : Type u_1
α : Type u_2
inst✝ : LinearOrder α
a : α
⊢ ∀ ⦃b c : α⦄, b ⊓ c ≤ a → b ≤ a ∨ c ≤ a
[PROOFSTEP]
simp
[GOAL]
ι : Type u_1
α : Type u_2
inst✝ : LinearOrder α
a x✝¹ x✝ : α
⊢ x✝¹ ⊔ x✝ = a → x✝¹ = a ∨ x✝ = a
[PROOFSTEP]
simpa only [sup_eq_max, max_eq_iff] using Or.imp And.left And.left
[GOAL]
ι : Type u_1
α : Type u_2
inst✝ : LinearOrder α
a x✝¹ x✝ : α
⊢ x✝¹ ⊓ x✝ = a → x✝¹ = a ∨ x✝ = a
[PROOFSTEP]
simpa only [inf_eq_min, min_eq_iff] using Or.imp And.left And.left


[GOAL]
α : Type u_1
β : Type u_2
γ : Type u_3
inst✝¹ : Finite α
inst✝ : Finite β
⊢ Finite (α × β)
[PROOFSTEP]
haveI := Fintype.ofFinite α
[GOAL]
α : Type u_1
β : Type u_2
γ : Type u_3
inst✝¹ : Finite α
inst✝ : Finite β
this : Fintype α
⊢ Finite (α × β)
[PROOFSTEP]
haveI := Fintype.ofFinite β
[GOAL]
α : Type u_1
β : Type u_2
γ : Type u_3
inst✝¹ : Finite α
inst✝ : Finite β
this✝ : Fintype α
this : Fintype β
⊢ Finite (α × β)
[PROOFSTEP]
infer_instance
[GOAL]
α : Type u_1
β : Type u_2
γ : Type u_3
inst✝¹ : Finite α
inst✝ : Finite β
⊢ Finite (α ⊕ β)
[PROOFSTEP]
haveI := Fintype.ofFinite α
[GOAL]
α : Type u_1
β : Type u_2
γ : Type u_3
inst✝¹ : Finite α
inst✝ : Finite β
this : Fintype α
⊢ Finite (α ⊕ β)
[PROOFSTEP]
haveI := Fintype.ofFinite β
[GOAL]
α : Type u_1
β : Type u_2
γ : Type u_3
inst✝¹ : Finite α
inst✝ : Finite β
this✝ : Fintype α
this : Fintype β
⊢ Finite (α ⊕ β)
[PROOFSTEP]
infer_instance
[GOAL]
α : Type u_1
β✝ : Type u_2
γ : Type u_3
β : α → Type u_4
inst✝¹ : Finite α
inst✝ : ∀ (a : α), Finite (β a)
⊢ Finite ((a : α) × β a)
[PROOFSTEP]
letI := Fintype.ofFinite α
[GOAL]
α : Type u_1
β✝ : Type u_2
γ : Type u_3
β : α → Type u_4
inst✝¹ : Finite α
inst✝ : ∀ (a : α), Finite (β a)
this : Fintype α := Fintype.ofFinite α
⊢ Finite ((a : α) × β a)
[PROOFSTEP]
letI := fun a => Fintype.ofFinite (β a)
[GOAL]
α : Type u_1
β✝ : Type u_2
γ : Type u_3
β : α → Type u_4
inst✝¹ : Finite α
inst✝ : ∀ (a : α), Finite (β a)
this✝ : Fintype α := Fintype.ofFinite α
this : (a : α) → Fintype (β a) := fun a => Fintype.ofFinite (β a)
⊢ Finite ((a : α) × β a)
[PROOFSTEP]
infer_instance
[GOAL]
α : Type u_1
β : Type u_2
γ : Type u_3
inst✝ : Finite α
⊢ Finite (Set α)
[PROOFSTEP]
cases nonempty_fintype α
[GOAL]
case intro
α : Type u_1
β : Type u_2
γ : Type u_3
inst✝ : Finite α
val✝ : Fintype α
⊢ Finite (Set α)
[PROOFSTEP]
infer_instance
[GOAL]
α✝ : Type u_1
β✝ : Type u_2
γ : Type u_3
α : Sort u_4
β : α → Sort u_5
inst✝¹ : Finite α
inst✝ : ∀ (a : α), Finite (β a)
⊢ Finite ((a : α) → β a)
[PROOFSTEP]
haveI := Fintype.ofFinite (PLift α)
[GOAL]
α✝ : Type u_1
β✝ : Type u_2
γ : Type u_3
α : Sort u_4
β : α → Sort u_5
inst✝¹ : Finite α
inst✝ : ∀ (a : α), Finite (β a)
this : Fintype (PLift α)
⊢ Finite ((a : α) → β a)
[PROOFSTEP]
haveI := fun a => Fintype.ofFinite (PLift (β a))
[GOAL]
α✝ : Type u_1
β✝ : Type u_2
γ : Type u_3
α : Sort u_4
β : α → Sort u_5
inst✝¹ : Finite α
inst✝ : ∀ (a : α), Finite (β a)
this✝ : Fintype (PLift α)
this : (a : α) → Fintype (PLift (β a))
⊢ Finite ((a : α) → β a)
[PROOFSTEP]
exact Finite.of_equiv (∀ a : PLift α, PLift (β (Equiv.plift a))) (Equiv.piCongr Equiv.plift fun _ => Equiv.plift)
[GOAL]
α✝ : Type u_1
β : Type u_2
γ : Type u_3
α : Type u_4
inst✝ : Finite α
n : ℕ
⊢ Finite (Vector α n)
[PROOFSTEP]
haveI := Fintype.ofFinite α
[GOAL]
α✝ : Type u_1
β : Type u_2
γ : Type u_3
α : Type u_4
inst✝ : Finite α
n : ℕ
this : Fintype α
⊢ Finite (Vector α n)
[PROOFSTEP]
infer_instance
[GOAL]
α✝ : Type u_1
β✝ : Type u_2
γ : Type u_3
α : Sort u_4
β : Sort u_5
inst✝ : Finite β
⊢ Finite (α ↪ β)
[PROOFSTEP]
cases' isEmpty_or_nonempty (α ↪ β) with _ h
[GOAL]
case inl
α✝ : Type u_1
β✝ : Type u_2
γ : Type u_3
α : Sort u_4
β : Sort u_5
inst✝ : Finite β
h✝ : IsEmpty (α ↪ β)
⊢ Finite (α ↪ β)
[PROOFSTEP]
apply Finite.of_subsingleton
[GOAL]
case inr
α✝ : Type u_1
β✝ : Type u_2
γ : Type u_3
α : Sort u_4
β : Sort u_5
inst✝ : Finite β
h : Nonempty (α ↪ β)
⊢ Finite (α ↪ β)
[PROOFSTEP]
refine' h.elim fun f => _
[GOAL]
case inr
α✝ : Type u_1
β✝ : Type u_2
γ : Type u_3
α : Sort u_4
β : Sort u_5
inst✝ : Finite β
h : Nonempty (α ↪ β)
f : α ↪ β
⊢ Finite (α ↪ β)
[PROOFSTEP]
haveI : Finite α := Finite.of_injective _ f.injective
[GOAL]
case inr
α✝ : Type u_1
β✝ : Type u_2
γ : Type u_3
α : Sort u_4
β : Sort u_5
inst✝ : Finite β
h : Nonempty (α ↪ β)
f : α ↪ β
this : Finite α
⊢ Finite (α ↪ β)
[PROOFSTEP]
exact Finite.of_injective _ FunLike.coe_injective
[GOAL]
α✝ : Type u_1
β✝ : Type u_2
γ : Type u_3
α : Sort u_4
β : Sort u_5
inst✝ : Finite β
e₁ e₂ : α ≃ β
h : Equiv.toEmbedding e₁ = Equiv.toEmbedding e₂
⊢ ∀ (x : α), ↑e₁ x = ↑e₂ x
[PROOFSTEP]
convert FunLike.congr_fun h using 0
[GOAL]
α : Type u_1
β : Type u_2
γ : Type u_3
inst✝ : Finite α
n : ℕ
⊢ Finite (Sym α n)
[PROOFSTEP]
haveI := Fintype.ofFinite α
[GOAL]
α : Type u_1
β : Type u_2
γ : Type u_3
inst✝ : Finite α
n : ℕ
this : Fintype α
⊢ Finite (Sym α n)
[PROOFSTEP]
infer_instance


[GOAL]
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
G : C ⥤ D
J : Type w
f : J → C
P : C
g : (j : J) → P ⟶ f j
⊢ IsLimit (G.mapCone (Fan.mk P g)) ≃ IsLimit (Fan.mk (G.obj P) fun j => G.map (g j))
[PROOFSTEP]
refine' (IsLimit.postcomposeHomEquiv _ _).symm.trans (IsLimit.equivIsoLimit _)
[GOAL]
case refine'_1
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
G : C ⥤ D
J : Type w
f : J → C
P : C
g : (j : J) → P ⟶ f j
⊢ (Discrete.functor fun b => f b) ⋙ G ≅ Discrete.functor fun j => G.obj (f j)
case refine'_2
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
G : C ⥤ D
J : Type w
f : J → C
P : C
g : (j : J) → P ⟶ f j
⊢ (Cones.postcompose ?refine'_1.hom).obj (G.mapCone (Fan.mk P g)) ≅ Fan.mk (G.obj P) fun j => G.map (g j)
[PROOFSTEP]
refine' Discrete.natIso fun j => Iso.refl (G.obj (f j.as))
[GOAL]
case refine'_2
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
G : C ⥤ D
J : Type w
f : J → C
P : C
g : (j : J) → P ⟶ f j
⊢ (Cones.postcompose (Discrete.natIso fun j => Iso.refl (G.obj (f j.as))).hom).obj (G.mapCone (Fan.mk P g)) ≅
    Fan.mk (G.obj P) fun j => G.map (g j)
[PROOFSTEP]
refine' Cones.ext (Iso.refl _) fun j => by dsimp; cases j; simp
[GOAL]
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
G : C ⥤ D
J : Type w
f : J → C
P : C
g : (j : J) → P ⟶ f j
j : Discrete J
⊢ NatTrans.app
      ((Cones.postcompose (Discrete.natIso fun j => Iso.refl (G.obj (f j.as))).hom).obj (G.mapCone (Fan.mk P g))).π j =
    (Iso.refl
          ((Cones.postcompose (Discrete.natIso fun j => Iso.refl (G.obj (f j.as))).hom).obj
              (G.mapCone (Fan.mk P g))).pt).hom ≫
      NatTrans.app (Fan.mk (G.obj P) fun j => G.map (g j)).π j
[PROOFSTEP]
dsimp
[GOAL]
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
G : C ⥤ D
J : Type w
f : J → C
P : C
g : (j : J) → P ⟶ f j
j : Discrete J
⊢ G.map (g j.as) ≫ 𝟙 (G.obj (f j.as)) = 𝟙 (G.obj P) ≫ G.map (g j.as)
[PROOFSTEP]
cases j
[GOAL]
case mk
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
G : C ⥤ D
J : Type w
f : J → C
P : C
g : (j : J) → P ⟶ f j
as✝ : J
⊢ G.map (g { as := as✝ }.as) ≫ 𝟙 (G.obj (f { as := as✝ }.as)) = 𝟙 (G.obj P) ≫ G.map (g { as := as✝ }.as)
[PROOFSTEP]
simp
[GOAL]
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
G : C ⥤ D
J : Type w
f : J → C
inst✝¹ : HasProduct f
inst✝ : HasProduct fun j => G.obj (f j)
i : IsIso (piComparison G f)
⊢ PreservesLimit (Discrete.functor f) G
[PROOFSTEP]
apply preservesLimitOfPreservesLimitCone (productIsProduct f)
[GOAL]
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
G : C ⥤ D
J : Type w
f : J → C
inst✝¹ : HasProduct f
inst✝ : HasProduct fun j => G.obj (f j)
i : IsIso (piComparison G f)
⊢ IsLimit (G.mapCone (Fan.mk (∏ f) (Pi.π f)))
[PROOFSTEP]
apply (isLimitMapConeFanMkEquiv _ _ _).symm _
[GOAL]
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
G : C ⥤ D
J : Type w
f : J → C
inst✝¹ : HasProduct f
inst✝ : HasProduct fun j => G.obj (f j)
i : IsIso (piComparison G f)
⊢ IsLimit (Fan.mk (G.obj (∏ f)) fun j => G.map (Pi.π f j))
[PROOFSTEP]
refine @IsLimit.ofPointIso _ _ _ _ _ _ _ (limit.isLimit (Discrete.functor fun j : J => G.obj (f j))) ?_
[GOAL]
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
G : C ⥤ D
J : Type w
f : J → C
inst✝¹ : HasProduct f
inst✝ : HasProduct fun j => G.obj (f j)
i : IsIso (piComparison G f)
⊢ IsIso
    (IsLimit.lift (limit.isLimit (Discrete.functor fun j => G.obj (f j)))
      (Fan.mk (G.obj (∏ f)) fun j => G.map (Pi.π f j)))
[PROOFSTEP]
apply i
[GOAL]
C : Type u₁
inst✝⁴ : Category.{v₁, u₁} C
D : Type u₂
inst✝³ : Category.{v₂, u₂} D
G : C ⥤ D
J : Type w
f : J → C
inst✝² : HasProduct f
inst✝¹ : HasProduct fun j => G.obj (f j)
inst✝ : PreservesLimit (Discrete.functor f) G
⊢ IsIso (piComparison G f)
[PROOFSTEP]
rw [← PreservesProduct.iso_hom]
[GOAL]
C : Type u₁
inst✝⁴ : Category.{v₁, u₁} C
D : Type u₂
inst✝³ : Category.{v₂, u₂} D
G : C ⥤ D
J : Type w
f : J → C
inst✝² : HasProduct f
inst✝¹ : HasProduct fun j => G.obj (f j)
inst✝ : PreservesLimit (Discrete.functor f) G
⊢ IsIso (PreservesProduct.iso G f).hom
[PROOFSTEP]
infer_instance
[GOAL]
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
G : C ⥤ D
J : Type w
f : J → C
P : C
g : (j : J) → f j ⟶ P
⊢ IsColimit (G.mapCocone (Cofan.mk P g)) ≃ IsColimit (Cofan.mk (G.obj P) fun j => G.map (g j))
[PROOFSTEP]
refine' (IsColimit.precomposeHomEquiv _ _).symm.trans (IsColimit.equivIsoColimit _)
[GOAL]
case refine'_1
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
G : C ⥤ D
J : Type w
f : J → C
P : C
g : (j : J) → f j ⟶ P
⊢ (Discrete.functor fun j => G.obj (f j)) ≅ (Discrete.functor fun b => f b) ⋙ G
case refine'_2
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
G : C ⥤ D
J : Type w
f : J → C
P : C
g : (j : J) → f j ⟶ P
⊢ (Cocones.precompose ?refine'_1.hom).obj (G.mapCocone (Cofan.mk P g)) ≅ Cofan.mk (G.obj P) fun j => G.map (g j)
[PROOFSTEP]
refine' Discrete.natIso fun j => Iso.refl (G.obj (f j.as))
[GOAL]
case refine'_2
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
G : C ⥤ D
J : Type w
f : J → C
P : C
g : (j : J) → f j ⟶ P
⊢ (Cocones.precompose (Discrete.natIso fun j => Iso.refl (G.obj (f j.as))).hom).obj (G.mapCocone (Cofan.mk P g)) ≅
    Cofan.mk (G.obj P) fun j => G.map (g j)
[PROOFSTEP]
refine' Cocones.ext (Iso.refl _) fun j => by dsimp; cases j; simp
[GOAL]
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
G : C ⥤ D
J : Type w
f : J → C
P : C
g : (j : J) → f j ⟶ P
j : Discrete J
⊢ NatTrans.app
        ((Cocones.precompose (Discrete.natIso fun j => Iso.refl (G.obj (f j.as))).hom).obj
            (G.mapCocone (Cofan.mk P g))).ι
        j ≫
      (Iso.refl
          ((Cocones.precompose (Discrete.natIso fun j => Iso.refl (G.obj (f j.as))).hom).obj
              (G.mapCocone (Cofan.mk P g))).pt).hom =
    NatTrans.app (Cofan.mk (G.obj P) fun j => G.map (g j)).ι j
[PROOFSTEP]
dsimp
[GOAL]
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
G : C ⥤ D
J : Type w
f : J → C
P : C
g : (j : J) → f j ⟶ P
j : Discrete J
⊢ (𝟙 (G.obj (f j.as)) ≫ G.map (g j.as)) ≫ 𝟙 (G.obj P) = G.map (g j.as)
[PROOFSTEP]
cases j
[GOAL]
case mk
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
G : C ⥤ D
J : Type w
f : J → C
P : C
g : (j : J) → f j ⟶ P
as✝ : J
⊢ (𝟙 (G.obj (f { as := as✝ }.as)) ≫ G.map (g { as := as✝ }.as)) ≫ 𝟙 (G.obj P) = G.map (g { as := as✝ }.as)
[PROOFSTEP]
simp
[GOAL]
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
G : C ⥤ D
J : Type w
f : J → C
inst✝¹ : HasCoproduct f
inst✝ : HasCoproduct fun j => G.obj (f j)
i : IsIso (sigmaComparison G f)
⊢ PreservesColimit (Discrete.functor f) G
[PROOFSTEP]
apply preservesColimitOfPreservesColimitCocone (coproductIsCoproduct f)
[GOAL]
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
G : C ⥤ D
J : Type w
f : J → C
inst✝¹ : HasCoproduct f
inst✝ : HasCoproduct fun j => G.obj (f j)
i : IsIso (sigmaComparison G f)
⊢ IsColimit (G.mapCocone (Cofan.mk (∐ f) (Sigma.ι f)))
[PROOFSTEP]
apply (isColimitMapCoconeCofanMkEquiv _ _ _).symm _
[GOAL]
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
G : C ⥤ D
J : Type w
f : J → C
inst✝¹ : HasCoproduct f
inst✝ : HasCoproduct fun j => G.obj (f j)
i : IsIso (sigmaComparison G f)
⊢ IsColimit (Cofan.mk (G.obj (∐ f)) fun j => G.map (Sigma.ι f j))
[PROOFSTEP]
refine @IsColimit.ofPointIso _ _ _ _ _ _ _ (colimit.isColimit (Discrete.functor fun j : J => G.obj (f j))) ?_
[GOAL]
C : Type u₁
inst✝³ : Category.{v₁, u₁} C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
G : C ⥤ D
J : Type w
f : J → C
inst✝¹ : HasCoproduct f
inst✝ : HasCoproduct fun j => G.obj (f j)
i : IsIso (sigmaComparison G f)
⊢ IsIso
    (IsColimit.desc (colimit.isColimit (Discrete.functor fun j => G.obj (f j)))
      (Cofan.mk (G.obj (∐ f)) fun j => G.map (Sigma.ι f j)))
[PROOFSTEP]
apply i
[GOAL]
C : Type u₁
inst✝⁴ : Category.{v₁, u₁} C
D : Type u₂
inst✝³ : Category.{v₂, u₂} D
G : C ⥤ D
J : Type w
f : J → C
inst✝² : HasCoproduct f
inst✝¹ : HasCoproduct fun j => G.obj (f j)
inst✝ : PreservesColimit (Discrete.functor f) G
⊢ IsIso (sigmaComparison G f)
[PROOFSTEP]
rw [← PreservesCoproduct.inv_hom]
[GOAL]
C : Type u₁
inst✝⁴ : Category.{v₁, u₁} C
D : Type u₂
inst✝³ : Category.{v₂, u₂} D
G : C ⥤ D
J : Type w
f : J → C
inst✝² : HasCoproduct f
inst✝¹ : HasCoproduct fun j => G.obj (f j)
inst✝ : PreservesColimit (Discrete.functor f) G
⊢ IsIso (PreservesCoproduct.iso G f).inv
[PROOFSTEP]
infer_instance


[GOAL]
X Y : Scheme
f : X ⟶ Y
x✝ : QuasiCompact f
h : ∀ (U : Set ↑↑Y.toPresheafedSpace), IsOpen U → IsCompact U → IsCompact (↑f.val.base ⁻¹' U)
⊢ Continuous ↑f.val.base
[PROOFSTEP]
continuity
[GOAL]
X✝ Y✝ : Scheme
f✝ : X✝ ⟶ Y✝
X Y : Scheme
f : X ⟶ Y
inst✝ : IsIso f
⊢ QuasiCompact f
[PROOFSTEP]
constructor
[GOAL]
case isCompact_preimage
X✝ Y✝ : Scheme
f✝ : X✝ ⟶ Y✝
X Y : Scheme
f : X ⟶ Y
inst✝ : IsIso f
⊢ ∀ (U : Set ↑↑Y.toPresheafedSpace), IsOpen U → IsCompact U → IsCompact (↑f.val.base ⁻¹' U)
[PROOFSTEP]
intro U _ hU'
[GOAL]
case isCompact_preimage
X✝ Y✝ : Scheme
f✝ : X✝ ⟶ Y✝
X Y : Scheme
f : X ⟶ Y
inst✝ : IsIso f
U : Set ↑↑Y.toPresheafedSpace
a✝ : IsOpen U
hU' : IsCompact U
⊢ IsCompact (↑f.val.base ⁻¹' U)
[PROOFSTEP]
convert hU'.image (inv f.1.base).continuous_toFun using 1
[GOAL]
case h.e'_3.h
X✝ Y✝ : Scheme
f✝ : X✝ ⟶ Y✝
X Y : Scheme
f : X ⟶ Y
inst✝ : IsIso f
U : Set ↑↑Y.toPresheafedSpace
a✝ : IsOpen U
hU' : IsCompact U
e_1✝ : (forget TopCat).obj ↑X.toPresheafedSpace = ↑↑X.toPresheafedSpace
⊢ ↑f.val.base ⁻¹' U = (inv f.val.base).toFun '' U
[PROOFSTEP]
rw [Set.image_eq_preimage_of_inverse]
[GOAL]
case h.e'_3.h.h₁
X✝ Y✝ : Scheme
f✝ : X✝ ⟶ Y✝
X Y : Scheme
f : X ⟶ Y
inst✝ : IsIso f
U : Set ↑↑Y.toPresheafedSpace
a✝ : IsOpen U
hU' : IsCompact U
e_1✝ : (forget TopCat).obj ↑X.toPresheafedSpace = ↑↑X.toPresheafedSpace
⊢ Function.LeftInverse (↑f.val.base) (inv f.val.base).toFun
case h.e'_3.h.h₂
X✝ Y✝ : Scheme
f✝ : X✝ ⟶ Y✝
X Y : Scheme
f : X ⟶ Y
inst✝ : IsIso f
U : Set ↑↑Y.toPresheafedSpace
a✝ : IsOpen U
hU' : IsCompact U
e_1✝ : (forget TopCat).obj ↑X.toPresheafedSpace = ↑↑X.toPresheafedSpace
⊢ Function.RightInverse (↑f.val.base) (inv f.val.base).toFun
[PROOFSTEP]
delta Function.LeftInverse
[GOAL]
case h.e'_3.h.h₁
X✝ Y✝ : Scheme
f✝ : X✝ ⟶ Y✝
X Y : Scheme
f : X ⟶ Y
inst✝ : IsIso f
U : Set ↑↑Y.toPresheafedSpace
a✝ : IsOpen U
hU' : IsCompact U
e_1✝ : (forget TopCat).obj ↑X.toPresheafedSpace = ↑↑X.toPresheafedSpace
⊢ ∀ (x : ↑↑Y.toPresheafedSpace), ↑f.val.base (ContinuousMap.toFun (inv f.val.base) x) = x
case h.e'_3.h.h₂
X✝ Y✝ : Scheme
f✝ : X✝ ⟶ Y✝
X Y : Scheme
f : X ⟶ Y
inst✝ : IsIso f
U : Set ↑↑Y.toPresheafedSpace
a✝ : IsOpen U
hU' : IsCompact U
e_1✝ : (forget TopCat).obj ↑X.toPresheafedSpace = ↑↑X.toPresheafedSpace
⊢ Function.RightInverse (↑f.val.base) (inv f.val.base).toFun
[PROOFSTEP]
exacts [IsIso.inv_hom_id_apply f.1.base, IsIso.hom_inv_id_apply f.1.base]
[GOAL]
X✝ Y✝ : Scheme
f✝ : X✝ ⟶ Y✝
X Y Z : Scheme
f : X ⟶ Y
g : Y ⟶ Z
inst✝¹ : QuasiCompact f
inst✝ : QuasiCompact g
⊢ QuasiCompact (f ≫ g)
[PROOFSTEP]
constructor
[GOAL]
case isCompact_preimage
X✝ Y✝ : Scheme
f✝ : X✝ ⟶ Y✝
X Y Z : Scheme
f : X ⟶ Y
g : Y ⟶ Z
inst✝¹ : QuasiCompact f
inst✝ : QuasiCompact g
⊢ ∀ (U : Set ↑↑Z.toPresheafedSpace), IsOpen U → IsCompact U → IsCompact (↑(f ≫ g).val.base ⁻¹' U)
[PROOFSTEP]
intro U hU hU'
[GOAL]
case isCompact_preimage
X✝ Y✝ : Scheme
f✝ : X✝ ⟶ Y✝
X Y Z : Scheme
f : X ⟶ Y
g : Y ⟶ Z
inst✝¹ : QuasiCompact f
inst✝ : QuasiCompact g
U : Set ↑↑Z.toPresheafedSpace
hU : IsOpen U
hU' : IsCompact U
⊢ IsCompact (↑(f ≫ g).val.base ⁻¹' U)
[PROOFSTEP]
rw [Scheme.comp_val_base, coe_comp, Set.preimage_comp]
[GOAL]
case isCompact_preimage
X✝ Y✝ : Scheme
f✝ : X✝ ⟶ Y✝
X Y Z : Scheme
f : X ⟶ Y
g : Y ⟶ Z
inst✝¹ : QuasiCompact f
inst✝ : QuasiCompact g
U : Set ↑↑Z.toPresheafedSpace
hU : IsOpen U
hU' : IsCompact U
⊢ IsCompact (↑f.val.base ⁻¹' (↑g.val.base ⁻¹' U))
[PROOFSTEP]
apply QuasiCompact.isCompact_preimage
[GOAL]
case isCompact_preimage.a
X✝ Y✝ : Scheme
f✝ : X✝ ⟶ Y✝
X Y Z : Scheme
f : X ⟶ Y
g : Y ⟶ Z
inst✝¹ : QuasiCompact f
inst✝ : QuasiCompact g
U : Set ↑↑Z.toPresheafedSpace
hU : IsOpen U
hU' : IsCompact U
⊢ IsOpen (↑g.val.base ⁻¹' U)
[PROOFSTEP]
exact
  Continuous.isOpen_preimage
    (by
      -- porting note: `continuity` failed
          -- see https://github.com/leanprover-community/mathlib4/issues/5030exact Scheme.Hom.continuous g)
    _ hU
[GOAL]
X✝ Y✝ : Scheme
f✝ : X✝ ⟶ Y✝
X Y Z : Scheme
f : X ⟶ Y
g : Y ⟶ Z
inst✝¹ : QuasiCompact f
inst✝ : QuasiCompact g
U : Set ↑↑Z.toPresheafedSpace
hU : IsOpen U
hU' : IsCompact U
⊢ Continuous ↑g.val.base
[PROOFSTEP]
exact Scheme.Hom.continuous g
[GOAL]
case isCompact_preimage.a
X✝ Y✝ : Scheme
f✝ : X✝ ⟶ Y✝
X Y Z : Scheme
f : X ⟶ Y
g : Y ⟶ Z
inst✝¹ : QuasiCompact f
inst✝ : QuasiCompact g
U : Set ↑↑Z.toPresheafedSpace
hU : IsOpen U
hU' : IsCompact U
⊢ IsCompact (↑g.val.base ⁻¹' U)
[PROOFSTEP]
apply QuasiCompact.isCompact_preimage
[GOAL]
case isCompact_preimage.a.a
X✝ Y✝ : Scheme
f✝ : X✝ ⟶ Y✝
X Y Z : Scheme
f : X ⟶ Y
g : Y ⟶ Z
inst✝¹ : QuasiCompact f
inst✝ : QuasiCompact g
U : Set ↑↑Z.toPresheafedSpace
hU : IsOpen U
hU' : IsCompact U
⊢ IsOpen U
[PROOFSTEP]
assumption
[GOAL]
case isCompact_preimage.a.a
X✝ Y✝ : Scheme
f✝ : X✝ ⟶ Y✝
X Y Z : Scheme
f : X ⟶ Y
g : Y ⟶ Z
inst✝¹ : QuasiCompact f
inst✝ : QuasiCompact g
U : Set ↑↑Z.toPresheafedSpace
hU : IsOpen U
hU' : IsCompact U
⊢ IsCompact U
[PROOFSTEP]
assumption
[GOAL]
X✝ Y : Scheme
f : X✝ ⟶ Y
X : Scheme
U : Set ↑↑X.toPresheafedSpace
⊢ IsCompact U ∧ IsOpen U ↔ ∃ s, Set.Finite s ∧ U = ⋃ (i : ↑(Scheme.affineOpens X)) (_ : i ∈ s), ↑↑i
[PROOFSTEP]
apply Opens.IsBasis.isCompact_open_iff_eq_finite_iUnion (fun (U : X.affineOpens) => (U : Opens X.carrier))
[GOAL]
case hb
X✝ Y : Scheme
f : X✝ ⟶ Y
X : Scheme
U : Set ↑↑X.toPresheafedSpace
⊢ Opens.IsBasis (Set.range fun U => ↑U)
[PROOFSTEP]
rw [Subtype.range_coe]
[GOAL]
case hb
X✝ Y : Scheme
f : X✝ ⟶ Y
X : Scheme
U : Set ↑↑X.toPresheafedSpace
⊢ Opens.IsBasis (Scheme.affineOpens X)
[PROOFSTEP]
exact isBasis_affine_open X
[GOAL]
case hb'
X✝ Y : Scheme
f : X✝ ⟶ Y
X : Scheme
U : Set ↑↑X.toPresheafedSpace
⊢ ∀ (i : ↑(Scheme.affineOpens X)), IsCompact ↑↑i
[PROOFSTEP]
exact fun i => i.2.isCompact
[GOAL]
X Y : Scheme
f : X ⟶ Y
⊢ QuasiCompact f ↔ ∀ (U : Opens ↑↑Y.toPresheafedSpace), IsAffineOpen U → IsCompact (↑f.val.base ⁻¹' ↑U)
[PROOFSTEP]
rw [QuasiCompact_iff]
[GOAL]
X Y : Scheme
f : X ⟶ Y
⊢ (∀ (U : Set ↑↑Y.toPresheafedSpace), IsOpen U → IsCompact U → IsCompact (↑f.val.base ⁻¹' U)) ↔
    ∀ (U : Opens ↑↑Y.toPresheafedSpace), IsAffineOpen U → IsCompact (↑f.val.base ⁻¹' ↑U)
[PROOFSTEP]
refine' ⟨fun H U hU => H U U.isOpen hU.isCompact, _⟩
[GOAL]
X Y : Scheme
f : X ⟶ Y
⊢ (∀ (U : Opens ↑↑Y.toPresheafedSpace), IsAffineOpen U → IsCompact (↑f.val.base ⁻¹' ↑U)) →
    ∀ (U : Set ↑↑Y.toPresheafedSpace), IsOpen U → IsCompact U → IsCompact (↑f.val.base ⁻¹' U)
[PROOFSTEP]
intro H U hU hU'
[GOAL]
X Y : Scheme
f : X ⟶ Y
H : ∀ (U : Opens ↑↑Y.toPresheafedSpace), IsAffineOpen U → IsCompact (↑f.val.base ⁻¹' ↑U)
U : Set ↑↑Y.toPresheafedSpace
hU : IsOpen U
hU' : IsCompact U
⊢ IsCompact (↑f.val.base ⁻¹' U)
[PROOFSTEP]
obtain ⟨S, hS, rfl⟩ := (isCompact_open_iff_eq_finset_affine_union U).mp ⟨hU', hU⟩
[GOAL]
case intro.intro
X Y : Scheme
f : X ⟶ Y
H : ∀ (U : Opens ↑↑Y.toPresheafedSpace), IsAffineOpen U → IsCompact (↑f.val.base ⁻¹' ↑U)
S : Set ↑(Scheme.affineOpens Y)
hS : Set.Finite S
hU : IsOpen (⋃ (i : ↑(Scheme.affineOpens Y)) (_ : i ∈ S), ↑↑i)
hU' : IsCompact (⋃ (i : ↑(Scheme.affineOpens Y)) (_ : i ∈ S), ↑↑i)
⊢ IsCompact (↑f.val.base ⁻¹' ⋃ (i : ↑(Scheme.affineOpens Y)) (_ : i ∈ S), ↑↑i)
[PROOFSTEP]
simp only [Set.preimage_iUnion]
[GOAL]
case intro.intro
X Y : Scheme
f : X ⟶ Y
H : ∀ (U : Opens ↑↑Y.toPresheafedSpace), IsAffineOpen U → IsCompact (↑f.val.base ⁻¹' ↑U)
S : Set ↑(Scheme.affineOpens Y)
hS : Set.Finite S
hU : IsOpen (⋃ (i : ↑(Scheme.affineOpens Y)) (_ : i ∈ S), ↑↑i)
hU' : IsCompact (⋃ (i : ↑(Scheme.affineOpens Y)) (_ : i ∈ S), ↑↑i)
⊢ IsCompact (⋃ (i : ↑(Scheme.affineOpens Y)) (_ : i ∈ S), ↑f.val.base ⁻¹' ↑↑i)
[PROOFSTEP]
exact Set.Finite.isCompact_biUnion hS (fun i _ => H i i.prop)
[GOAL]
X✝ Y✝ : Scheme
f✝ : X✝ ⟶ Y✝
X Y : Scheme
f : X ⟶ Y
⊢ AffineTargetMorphismProperty.toProperty affineProperty f ↔ IsAffine Y ∧ CompactSpace ↑↑X.toPresheafedSpace
[PROOFSTEP]
delta AffineTargetMorphismProperty.toProperty QuasiCompact.affineProperty
[GOAL]
X✝ Y✝ : Scheme
f✝ : X✝ ⟶ Y✝
X Y : Scheme
f : X ⟶ Y
⊢ (∃ h, CompactSpace ↑↑X.toPresheafedSpace) ↔ IsAffine Y ∧ CompactSpace ↑↑X.toPresheafedSpace
[PROOFSTEP]
simp
[GOAL]
X Y : Scheme
f : X ⟶ Y
⊢ QuasiCompact f ↔ targetAffineLocally QuasiCompact.affineProperty f
[PROOFSTEP]
rw [quasiCompact_iff_forall_affine]
[GOAL]
X Y : Scheme
f : X ⟶ Y
⊢ (∀ (U : Opens ↑↑Y.toPresheafedSpace), IsAffineOpen U → IsCompact (↑f.val.base ⁻¹' ↑U)) ↔
    targetAffineLocally QuasiCompact.affineProperty f
[PROOFSTEP]
trans ∀ U : Y.affineOpens, IsCompact (f.1.base ⁻¹' (U : Set Y.carrier))
[GOAL]
X Y : Scheme
f : X ⟶ Y
⊢ (∀ (U : Opens ↑↑Y.toPresheafedSpace), IsAffineOpen U → IsCompact (↑f.val.base ⁻¹' ↑U)) ↔
    ∀ (U : ↑(Scheme.affineOpens Y)), IsCompact (↑f.val.base ⁻¹' ↑↑U)
[PROOFSTEP]
exact ⟨fun h U => h U U.prop, fun h U hU => h ⟨U, hU⟩⟩
[GOAL]
X Y : Scheme
f : X ⟶ Y
⊢ (∀ (U : ↑(Scheme.affineOpens Y)), IsCompact (↑f.val.base ⁻¹' ↑↑U)) ↔ targetAffineLocally QuasiCompact.affineProperty f
[PROOFSTEP]
apply forall_congr'
[GOAL]
case h
X Y : Scheme
f : X ⟶ Y
⊢ ∀ (a : ↑(Scheme.affineOpens Y)), IsCompact (↑f.val.base ⁻¹' ↑↑a) ↔ QuasiCompact.affineProperty (f ∣_ ↑a)
[PROOFSTEP]
exact fun _ => isCompact_iff_compactSpace
[GOAL]
X Y : Scheme
f : X ⟶ Y
⊢ @QuasiCompact = targetAffineLocally QuasiCompact.affineProperty
[PROOFSTEP]
ext
[GOAL]
case h.h.h.a
X Y : Scheme
f : X ⟶ Y
x✝² x✝¹ : Scheme
x✝ : x✝² ⟶ x✝¹
⊢ QuasiCompact x✝ ↔ targetAffineLocally QuasiCompact.affineProperty x✝
[PROOFSTEP]
exact quasiCompact_iff_affineProperty _
[GOAL]
X✝ Y : Scheme
f✝ : X✝ ⟶ Y
X : Scheme
U : Opens ↑↑X.toPresheafedSpace
hU : IsCompact ↑U
f : ↑(X.presheaf.obj (op U))
⊢ IsCompact ↑(Scheme.basicOpen X f)
[PROOFSTEP]
classical
refine' ((isCompact_open_iff_eq_finset_affine_union _).mpr _).1
obtain ⟨s, hs, e⟩ := (isCompact_open_iff_eq_finset_affine_union _).mp ⟨hU, U.isOpen⟩
let g : s → X.affineOpens := by
  intro V
  use V.1 ⊓ X.basicOpen f
  have : V.1.1 ⟶ U := by
    apply homOfLE; change _ ⊆ (U : Set X.carrier); rw [e]
    convert @Set.subset_iUnion₂ _ _ _ (fun (U : X.affineOpens) (_ : U ∈ s) => ↑U) V V.prop using 1
  erw [← X.toLocallyRingedSpace.toRingedSpace.basicOpen_res this.op]
  exact IsAffineOpen.basicOpenIsAffine V.1.prop _
haveI : Finite s := hs.to_subtype
refine' ⟨Set.range g, Set.finite_range g, _⟩
refine' (Set.inter_eq_right_iff_subset.mpr (SetLike.coe_subset_coe.2 <| RingedSpace.basicOpen_le _ _)).symm.trans _
rw [e, Set.iUnion₂_inter]
apply le_antisymm <;> apply Set.iUnion₂_subset
· intro i hi
  exact
    Set.Subset.trans (Set.Subset.rfl : _ ≤ g ⟨i, hi⟩)
      (@Set.subset_iUnion₂ _ _ _ (fun (i : Scheme.affineOpens X) (_ : i ∈ Set.range g) => (i : Set X.toPresheafedSpace))
        _ (Set.mem_range_self ⟨i, hi⟩))
· rintro ⟨i, hi⟩ ⟨⟨j, hj⟩, hj'⟩
  rw [← hj']
  refine' Set.Subset.trans _ (Set.subset_iUnion₂ j hj)
  exact Set.Subset.rfl
[GOAL]
X✝ Y : Scheme
f✝ : X✝ ⟶ Y
X : Scheme
U : Opens ↑↑X.toPresheafedSpace
hU : IsCompact ↑U
f : ↑(X.presheaf.obj (op U))
⊢ IsCompact ↑(Scheme.basicOpen X f)
[PROOFSTEP]
refine' ((isCompact_open_iff_eq_finset_affine_union _).mpr _).1
[GOAL]
X✝ Y : Scheme
f✝ : X✝ ⟶ Y
X : Scheme
U : Opens ↑↑X.toPresheafedSpace
hU : IsCompact ↑U
f : ↑(X.presheaf.obj (op U))
⊢ ∃ s, Set.Finite s ∧ ↑(Scheme.basicOpen X f) = ⋃ (i : ↑(Scheme.affineOpens X)) (_ : i ∈ s), ↑↑i
[PROOFSTEP]
obtain ⟨s, hs, e⟩ := (isCompact_open_iff_eq_finset_affine_union _).mp ⟨hU, U.isOpen⟩
[GOAL]
case intro.intro
X✝ Y : Scheme
f✝ : X✝ ⟶ Y
X : Scheme
U : Opens ↑↑X.toPresheafedSpace
hU : IsCompact ↑U
f : ↑(X.presheaf.obj (op U))
s : Set ↑(Scheme.affineOpens X)
hs : Set.Finite s
e : ↑U = ⋃ (i : ↑(Scheme.affineOpens X)) (_ : i ∈ s), ↑↑i
⊢ ∃ s, Set.Finite s ∧ ↑(Scheme.basicOpen X f) = ⋃ (i : ↑(Scheme.affineOpens X)) (_ : i ∈ s), ↑↑i
[PROOFSTEP]
let g : s → X.affineOpens := by
  intro V
  use V.1 ⊓ X.basicOpen f
  have : V.1.1 ⟶ U := by
    apply homOfLE; change _ ⊆ (U : Set X.carrier); rw [e]
    convert @Set.subset_iUnion₂ _ _ _ (fun (U : X.affineOpens) (_ : U ∈ s) => ↑U) V V.prop using 1
  erw [← X.toLocallyRingedSpace.toRingedSpace.basicOpen_res this.op]
  exact IsAffineOpen.basicOpenIsAffine V.1.prop _
[GOAL]
X✝ Y : Scheme
f✝ : X✝ ⟶ Y
X : Scheme
U : Opens ↑↑X.toPresheafedSpace
hU : IsCompact ↑U
f : ↑(X.presheaf.obj (op U))
s : Set ↑(Scheme.affineOpens X)
hs : Set.Finite s
e : ↑U = ⋃ (i : ↑(Scheme.affineOpens X)) (_ : i ∈ s), ↑↑i
⊢ ↑s → ↑(Scheme.affineOpens X)
[PROOFSTEP]
intro V
[GOAL]
X✝ Y : Scheme
f✝ : X✝ ⟶ Y
X : Scheme
U : Opens ↑↑X.toPresheafedSpace
hU : IsCompact ↑U
f : ↑(X.presheaf.obj (op U))
s : Set ↑(Scheme.affineOpens X)
hs : Set.Finite s
e : ↑U = ⋃ (i : ↑(Scheme.affineOpens X)) (_ : i ∈ s), ↑↑i
V : ↑s
⊢ ↑(Scheme.affineOpens X)
[PROOFSTEP]
use V.1 ⊓ X.basicOpen f
[GOAL]
case property
X✝ Y : Scheme
f✝ : X✝ ⟶ Y
X : Scheme
U : Opens ↑↑X.toPresheafedSpace
hU : IsCompact ↑U
f : ↑(X.presheaf.obj (op U))
s : Set ↑(Scheme.affineOpens X)
hs : Set.Finite s
e : ↑U = ⋃ (i : ↑(Scheme.affineOpens X)) (_ : i ∈ s), ↑↑i
V : ↑s
⊢ ↑↑V ⊓ Scheme.basicOpen X f ∈ Scheme.affineOpens X
[PROOFSTEP]
have : V.1.1 ⟶ U := by
  apply homOfLE; change _ ⊆ (U : Set X.carrier); rw [e]
  convert @Set.subset_iUnion₂ _ _ _ (fun (U : X.affineOpens) (_ : U ∈ s) => ↑U) V V.prop using 1
[GOAL]
X✝ Y : Scheme
f✝ : X✝ ⟶ Y
X : Scheme
U : Opens ↑↑X.toPresheafedSpace
hU : IsCompact ↑U
f : ↑(X.presheaf.obj (op U))
s : Set ↑(Scheme.affineOpens X)
hs : Set.Finite s
e : ↑U = ⋃ (i : ↑(Scheme.affineOpens X)) (_ : i ∈ s), ↑↑i
V : ↑s
⊢ ↑↑V ⟶ U
[PROOFSTEP]
apply homOfLE
[GOAL]
case h
X✝ Y : Scheme
f✝ : X✝ ⟶ Y
X : Scheme
U : Opens ↑↑X.toPresheafedSpace
hU : IsCompact ↑U
f : ↑(X.presheaf.obj (op U))
s : Set ↑(Scheme.affineOpens X)
hs : Set.Finite s
e : ↑U = ⋃ (i : ↑(Scheme.affineOpens X)) (_ : i ∈ s), ↑↑i
V : ↑s
⊢ ↑↑V ≤ U
[PROOFSTEP]
change _ ⊆ (U : Set X.carrier)
[GOAL]
case h
X✝ Y : Scheme
f✝ : X✝ ⟶ Y
X : Scheme
U : Opens ↑↑X.toPresheafedSpace
hU : IsCompact ↑U
f : ↑(X.presheaf.obj (op U))
s : Set ↑(Scheme.affineOpens X)
hs : Set.Finite s
e : ↑U = ⋃ (i : ↑(Scheme.affineOpens X)) (_ : i ∈ s), ↑↑i
V : ↑s
⊢ ↑↑↑V ⊆ ↑U
[PROOFSTEP]
rw [e]
[GOAL]
case h
X✝ Y : Scheme
f✝ : X✝ ⟶ Y
X : Scheme
U : Opens ↑↑X.toPresheafedSpace
hU : IsCompact ↑U
f : ↑(X.presheaf.obj (op U))
s : Set ↑(Scheme.affineOpens X)
hs : Set.Finite s
e : ↑U = ⋃ (i : ↑(Scheme.affineOpens X)) (_ : i ∈ s), ↑↑i
V : ↑s
⊢ ↑↑↑V ⊆ ⋃ (i : ↑(Scheme.affineOpens X)) (_ : i ∈ s), ↑↑i
[PROOFSTEP]
convert @Set.subset_iUnion₂ _ _ _ (fun (U : X.affineOpens) (_ : U ∈ s) => ↑U) V V.prop using 1
[GOAL]
case property
X✝ Y : Scheme
f✝ : X✝ ⟶ Y
X : Scheme
U : Opens ↑↑X.toPresheafedSpace
hU : IsCompact ↑U
f : ↑(X.presheaf.obj (op U))
s : Set ↑(Scheme.affineOpens X)
hs : Set.Finite s
e : ↑U = ⋃ (i : ↑(Scheme.affineOpens X)) (_ : i ∈ s), ↑↑i
V : ↑s
this : ↑↑V ⟶ U
⊢ ↑↑V ⊓ Scheme.basicOpen X f ∈ Scheme.affineOpens X
[PROOFSTEP]
erw [← X.toLocallyRingedSpace.toRingedSpace.basicOpen_res this.op]
[GOAL]
case property
X✝ Y : Scheme
f✝ : X✝ ⟶ Y
X : Scheme
U : Opens ↑↑X.toPresheafedSpace
hU : IsCompact ↑U
f : ↑(X.presheaf.obj (op U))
s : Set ↑(Scheme.affineOpens X)
hs : Set.Finite s
e : ↑U = ⋃ (i : ↑(Scheme.affineOpens X)) (_ : i ∈ s), ↑↑i
V : ↑s
this : ↑↑V ⟶ U
⊢ RingedSpace.basicOpen (LocallyRingedSpace.toRingedSpace X.toLocallyRingedSpace)
      (↑((LocallyRingedSpace.toRingedSpace X.toLocallyRingedSpace).toPresheafedSpace.presheaf.map this.op) f) ∈
    Scheme.affineOpens X
[PROOFSTEP]
exact IsAffineOpen.basicOpenIsAffine V.1.prop _
[GOAL]
case intro.intro
X✝ Y : Scheme
f✝ : X✝ ⟶ Y
X : Scheme
U : Opens ↑↑X.toPresheafedSpace
hU : IsCompact ↑U
f : ↑(X.presheaf.obj (op U))
s : Set ↑(Scheme.affineOpens X)
hs : Set.Finite s
e : ↑U = ⋃ (i : ↑(Scheme.affineOpens X)) (_ : i ∈ s), ↑↑i
g : ↑s → ↑(Scheme.affineOpens X) :=
  fun V => { val := ↑↑V ⊓ Scheme.basicOpen X f, property := (_ : ↑↑V ⊓ Scheme.basicOpen X f ∈ Scheme.affineOpens X) }
⊢ ∃ s, Set.Finite s ∧ ↑(Scheme.basicOpen X f) = ⋃ (i : ↑(Scheme.affineOpens X)) (_ : i ∈ s), ↑↑i
[PROOFSTEP]
haveI : Finite s := hs.to_subtype
[GOAL]
case intro.intro
X✝ Y : Scheme
f✝ : X✝ ⟶ Y
X : Scheme
U : Opens ↑↑X.toPresheafedSpace
hU : IsCompact ↑U
f : ↑(X.presheaf.obj (op U))
s : Set ↑(Scheme.affineOpens X)
hs : Set.Finite s
e : ↑U = ⋃ (i : ↑(Scheme.affineOpens X)) (_ : i ∈ s), ↑↑i
g : ↑s → ↑(Scheme.affineOpens X) :=
  fun V => { val := ↑↑V ⊓ Scheme.basicOpen X f, property := (_ : ↑↑V ⊓ Scheme.basicOpen X f ∈ Scheme.affineOpens X) }
this : Finite ↑s
⊢ ∃ s, Set.Finite s ∧ ↑(Scheme.basicOpen X f) = ⋃ (i : ↑(Scheme.affineOpens X)) (_ : i ∈ s), ↑↑i
[PROOFSTEP]
refine' ⟨Set.range g, Set.finite_range g, _⟩
[GOAL]
case intro.intro
X✝ Y : Scheme
f✝ : X✝ ⟶ Y
X : Scheme
U : Opens ↑↑X.toPresheafedSpace
hU : IsCompact ↑U
f : ↑(X.presheaf.obj (op U))
s : Set ↑(Scheme.affineOpens X)
hs : Set.Finite s
e : ↑U = ⋃ (i : ↑(Scheme.affineOpens X)) (_ : i ∈ s), ↑↑i
g : ↑s → ↑(Scheme.affineOpens X) :=
  fun V => { val := ↑↑V ⊓ Scheme.basicOpen X f, property := (_ : ↑↑V ⊓ Scheme.basicOpen X f ∈ Scheme.affineOpens X) }
this : Finite ↑s
⊢ ↑(Scheme.basicOpen X f) = ⋃ (i : ↑(Scheme.affineOpens X)) (_ : i ∈ Set.range g), ↑↑i
[PROOFSTEP]
refine' (Set.inter_eq_right_iff_subset.mpr (SetLike.coe_subset_coe.2 <| RingedSpace.basicOpen_le _ _)).symm.trans _
[GOAL]
case intro.intro
X✝ Y : Scheme
f✝ : X✝ ⟶ Y
X : Scheme
U : Opens ↑↑X.toPresheafedSpace
hU : IsCompact ↑U
f : ↑(X.presheaf.obj (op U))
s : Set ↑(Scheme.affineOpens X)
hs : Set.Finite s
e : ↑U = ⋃ (i : ↑(Scheme.affineOpens X)) (_ : i ∈ s), ↑↑i
g : ↑s → ↑(Scheme.affineOpens X) :=
  fun V => { val := ↑↑V ⊓ Scheme.basicOpen X f, property := (_ : ↑↑V ⊓ Scheme.basicOpen X f ∈ Scheme.affineOpens X) }
this : Finite ↑s
⊢ ↑U ∩ ↑(RingedSpace.basicOpen (LocallyRingedSpace.toRingedSpace X.toLocallyRingedSpace) f) =
    ⋃ (i : ↑(Scheme.affineOpens X)) (_ : i ∈ Set.range g), ↑↑i
[PROOFSTEP]
rw [e, Set.iUnion₂_inter]
[GOAL]
case intro.intro
X✝ Y : Scheme
f✝ : X✝ ⟶ Y
X : Scheme
U : Opens ↑↑X.toPresheafedSpace
hU : IsCompact ↑U
f : ↑(X.presheaf.obj (op U))
s : Set ↑(Scheme.affineOpens X)
hs : Set.Finite s
e : ↑U = ⋃ (i : ↑(Scheme.affineOpens X)) (_ : i ∈ s), ↑↑i
g : ↑s → ↑(Scheme.affineOpens X) :=
  fun V => { val := ↑↑V ⊓ Scheme.basicOpen X f, property := (_ : ↑↑V ⊓ Scheme.basicOpen X f ∈ Scheme.affineOpens X) }
this : Finite ↑s
⊢ ⋃ (i : ↑(Scheme.affineOpens X)) (_ : i ∈ s),
      ↑↑i ∩ ↑(RingedSpace.basicOpen (LocallyRingedSpace.toRingedSpace X.toLocallyRingedSpace) f) =
    ⋃ (i : ↑(Scheme.affineOpens X)) (_ : i ∈ Set.range g), ↑↑i
[PROOFSTEP]
apply le_antisymm
[GOAL]
case intro.intro.a
X✝ Y : Scheme
f✝ : X✝ ⟶ Y
X : Scheme
U : Opens ↑↑X.toPresheafedSpace
hU : IsCompact ↑U
f : ↑(X.presheaf.obj (op U))
s : Set ↑(Scheme.affineOpens X)
hs : Set.Finite s
e : ↑U = ⋃ (i : ↑(Scheme.affineOpens X)) (_ : i ∈ s), ↑↑i
g : ↑s → ↑(Scheme.affineOpens X) :=
  fun V => { val := ↑↑V ⊓ Scheme.basicOpen X f, property := (_ : ↑↑V ⊓ Scheme.basicOpen X f ∈ Scheme.affineOpens X) }
this : Finite ↑s
⊢ ⋃ (i : ↑(Scheme.affineOpens X)) (_ : i ∈ s),
      ↑↑i ∩ ↑(RingedSpace.basicOpen (LocallyRingedSpace.toRingedSpace X.toLocallyRingedSpace) f) ≤
    ⋃ (i : ↑(Scheme.affineOpens X)) (_ : i ∈ Set.range g), ↑↑i
[PROOFSTEP]
apply Set.iUnion₂_subset
[GOAL]
case intro.intro.a
X✝ Y : Scheme
f✝ : X✝ ⟶ Y
X : Scheme
U : Opens ↑↑X.toPresheafedSpace
hU : IsCompact ↑U
f : ↑(X.presheaf.obj (op U))
s : Set ↑(Scheme.affineOpens X)
hs : Set.Finite s
e : ↑U = ⋃ (i : ↑(Scheme.affineOpens X)) (_ : i ∈ s), ↑↑i
g : ↑s → ↑(Scheme.affineOpens X) :=
  fun V => { val := ↑↑V ⊓ Scheme.basicOpen X f, property := (_ : ↑↑V ⊓ Scheme.basicOpen X f ∈ Scheme.affineOpens X) }
this : Finite ↑s
⊢ ⋃ (i : ↑(Scheme.affineOpens X)) (_ : i ∈ Set.range g), ↑↑i ≤
    ⋃ (i : ↑(Scheme.affineOpens X)) (_ : i ∈ s),
      ↑↑i ∩ ↑(RingedSpace.basicOpen (LocallyRingedSpace.toRingedSpace X.toLocallyRingedSpace) f)
[PROOFSTEP]
apply Set.iUnion₂_subset
[GOAL]
case intro.intro.a.h
X✝ Y : Scheme
f✝ : X✝ ⟶ Y
X : Scheme
U : Opens ↑↑X.toPresheafedSpace
hU : IsCompact ↑U
f : ↑(X.presheaf.obj (op U))
s : Set ↑(Scheme.affineOpens X)
hs : Set.Finite s
e : ↑U = ⋃ (i : ↑(Scheme.affineOpens X)) (_ : i ∈ s), ↑↑i
g : ↑s → ↑(Scheme.affineOpens X) :=
  fun V => { val := ↑↑V ⊓ Scheme.basicOpen X f, property := (_ : ↑↑V ⊓ Scheme.basicOpen X f ∈ Scheme.affineOpens X) }
this : Finite ↑s
⊢ ∀ (i : ↑(Scheme.affineOpens X)),
    i ∈ s →
      ↑↑i ∩ ↑(RingedSpace.basicOpen (LocallyRingedSpace.toRingedSpace X.toLocallyRingedSpace) f) ⊆
        ⋃ (i : ↑(Scheme.affineOpens X)) (_ : i ∈ Set.range g), ↑↑i
[PROOFSTEP]
intro i hi
[GOAL]
case intro.intro.a.h
X✝ Y : Scheme
f✝ : X✝ ⟶ Y
X : Scheme
U : Opens ↑↑X.toPresheafedSpace
hU : IsCompact ↑U
f : ↑(X.presheaf.obj (op U))
s : Set ↑(Scheme.affineOpens X)
hs : Set.Finite s
e : ↑U = ⋃ (i : ↑(Scheme.affineOpens X)) (_ : i ∈ s), ↑↑i
g : ↑s → ↑(Scheme.affineOpens X) :=
  fun V => { val := ↑↑V ⊓ Scheme.basicOpen X f, property := (_ : ↑↑V ⊓ Scheme.basicOpen X f ∈ Scheme.affineOpens X) }
this : Finite ↑s
i : ↑(Scheme.affineOpens X)
hi : i ∈ s
⊢ ↑↑i ∩ ↑(RingedSpace.basicOpen (LocallyRingedSpace.toRingedSpace X.toLocallyRingedSpace) f) ⊆
    ⋃ (i : ↑(Scheme.affineOpens X)) (_ : i ∈ Set.range g), ↑↑i
[PROOFSTEP]
exact
  Set.Subset.trans (Set.Subset.rfl : _ ≤ g ⟨i, hi⟩)
    (@Set.subset_iUnion₂ _ _ _ (fun (i : Scheme.affineOpens X) (_ : i ∈ Set.range g) => (i : Set X.toPresheafedSpace)) _
      (Set.mem_range_self ⟨i, hi⟩))
[GOAL]
case intro.intro.a.h
X✝ Y : Scheme
f✝ : X✝ ⟶ Y
X : Scheme
U : Opens ↑↑X.toPresheafedSpace
hU : IsCompact ↑U
f : ↑(X.presheaf.obj (op U))
s : Set ↑(Scheme.affineOpens X)
hs : Set.Finite s
e : ↑U = ⋃ (i : ↑(Scheme.affineOpens X)) (_ : i ∈ s), ↑↑i
g : ↑s → ↑(Scheme.affineOpens X) :=
  fun V => { val := ↑↑V ⊓ Scheme.basicOpen X f, property := (_ : ↑↑V ⊓ Scheme.basicOpen X f ∈ Scheme.affineOpens X) }
this : Finite ↑s
⊢ ∀ (i : ↑(Scheme.affineOpens X)),
    i ∈ Set.range g →
      ↑↑i ⊆
        ⋃ (i : ↑(Scheme.affineOpens X)) (_ : i ∈ s),
          ↑↑i ∩ ↑(RingedSpace.basicOpen (LocallyRingedSpace.toRingedSpace X.toLocallyRingedSpace) f)
[PROOFSTEP]
rintro ⟨i, hi⟩ ⟨⟨j, hj⟩, hj'⟩
[GOAL]
case intro.intro.a.h.mk.intro.mk
X✝ Y : Scheme
f✝ : X✝ ⟶ Y
X : Scheme
U : Opens ↑↑X.toPresheafedSpace
hU : IsCompact ↑U
f : ↑(X.presheaf.obj (op U))
s : Set ↑(Scheme.affineOpens X)
hs : Set.Finite s
e : ↑U = ⋃ (i : ↑(Scheme.affineOpens X)) (_ : i ∈ s), ↑↑i
g : ↑s → ↑(Scheme.affineOpens X) :=
  fun V => { val := ↑↑V ⊓ Scheme.basicOpen X f, property := (_ : ↑↑V ⊓ Scheme.basicOpen X f ∈ Scheme.affineOpens X) }
this : Finite ↑s
i : Opens ↑↑X.toPresheafedSpace
hi : i ∈ Scheme.affineOpens X
j : ↑(Scheme.affineOpens X)
hj : j ∈ s
hj' : g { val := j, property := hj } = { val := i, property := hi }
⊢ ↑↑{ val := i, property := hi } ⊆
    ⋃ (i : ↑(Scheme.affineOpens X)) (_ : i ∈ s),
      ↑↑i ∩ ↑(RingedSpace.basicOpen (LocallyRingedSpace.toRingedSpace X.toLocallyRingedSpace) f)
[PROOFSTEP]
rw [← hj']
[GOAL]
case intro.intro.a.h.mk.intro.mk
X✝ Y : Scheme
f✝ : X✝ ⟶ Y
X : Scheme
U : Opens ↑↑X.toPresheafedSpace
hU : IsCompact ↑U
f : ↑(X.presheaf.obj (op U))
s : Set ↑(Scheme.affineOpens X)
hs : Set.Finite s
e : ↑U = ⋃ (i : ↑(Scheme.affineOpens X)) (_ : i ∈ s), ↑↑i
g : ↑s → ↑(Scheme.affineOpens X) :=
  fun V => { val := ↑↑V ⊓ Scheme.basicOpen X f, property := (_ : ↑↑V ⊓ Scheme.basicOpen X f ∈ Scheme.affineOpens X) }
this : Finite ↑s
i : Opens ↑↑X.toPresheafedSpace
hi : i ∈ Scheme.affineOpens X
j : ↑(Scheme.affineOpens X)
hj : j ∈ s
hj' : g { val := j, property := hj } = { val := i, property := hi }
⊢ ↑↑(g { val := j, property := hj }) ⊆
    ⋃ (i : ↑(Scheme.affineOpens X)) (_ : i ∈ s),
      ↑↑i ∩ ↑(RingedSpace.basicOpen (LocallyRingedSpace.toRingedSpace X.toLocallyRingedSpace) f)
[PROOFSTEP]
refine' Set.Subset.trans _ (Set.subset_iUnion₂ j hj)
[GOAL]
case intro.intro.a.h.mk.intro.mk
X✝ Y : Scheme
f✝ : X✝ ⟶ Y
X : Scheme
U : Opens ↑↑X.toPresheafedSpace
hU : IsCompact ↑U
f : ↑(X.presheaf.obj (op U))
s : Set ↑(Scheme.affineOpens X)
hs : Set.Finite s
e : ↑U = ⋃ (i : ↑(Scheme.affineOpens X)) (_ : i ∈ s), ↑↑i
g : ↑s → ↑(Scheme.affineOpens X) :=
  fun V => { val := ↑↑V ⊓ Scheme.basicOpen X f, property := (_ : ↑↑V ⊓ Scheme.basicOpen X f ∈ Scheme.affineOpens X) }
this : Finite ↑s
i : Opens ↑↑X.toPresheafedSpace
hi : i ∈ Scheme.affineOpens X
j : ↑(Scheme.affineOpens X)
hj : j ∈ s
hj' : g { val := j, property := hj } = { val := i, property := hi }
⊢ ↑↑(g { val := j, property := hj }) ⊆
    ↑↑j ∩ ↑(RingedSpace.basicOpen (LocallyRingedSpace.toRingedSpace X.toLocallyRingedSpace) f)
[PROOFSTEP]
exact Set.Subset.rfl
[GOAL]
X Y : Scheme
f : X ⟶ Y
⊢ AffineTargetMorphismProperty.IsLocal affineProperty
[PROOFSTEP]
constructor
[GOAL]
case RespectsIso
X Y : Scheme
f : X ⟶ Y
⊢ MorphismProperty.RespectsIso (AffineTargetMorphismProperty.toProperty affineProperty)
[PROOFSTEP]
apply AffineTargetMorphismProperty.respectsIso_mk
[GOAL]
case RespectsIso.h₁
X Y : Scheme
f : X ⟶ Y
⊢ ∀ {X Y Z : Scheme} (e : X ≅ Y) (f : Y ⟶ Z) [inst : IsAffine Z], affineProperty f → affineProperty (e.hom ≫ f)
[PROOFSTEP]
rintro X Y Z e _ _ H
[GOAL]
case RespectsIso.h₂
X Y : Scheme
f : X ⟶ Y
⊢ ∀ {X Y Z : Scheme} (e : Y ≅ Z) (f : X ⟶ Y) [h : IsAffine Y], affineProperty f → affineProperty (f ≫ e.hom)
[PROOFSTEP]
rintro X Y Z e _ _ H
[GOAL]
case RespectsIso.h₁
X✝ Y✝ : Scheme
f : X✝ ⟶ Y✝
X Y Z : Scheme
e : X ≅ Y
f✝ : Y ⟶ Z
inst✝ : IsAffine Z
H : affineProperty f✝
⊢ affineProperty (e.hom ≫ f✝)
case RespectsIso.h₂
X✝ Y✝ : Scheme
f : X✝ ⟶ Y✝
X Y Z : Scheme
e : Y ≅ Z
f✝ : X ⟶ Y
h✝ : IsAffine Y
H : affineProperty f✝
⊢ affineProperty (f✝ ≫ e.hom)
[PROOFSTEP]
exacts [@Homeomorph.compactSpace _ _ _ _ H (TopCat.homeoOfIso (asIso e.inv.1.base)), H]
[GOAL]
case toBasicOpen
X Y : Scheme
f : X ⟶ Y
⊢ ∀ {X Y : Scheme} [inst : IsAffine Y] (f : X ⟶ Y) (r : ↑(Y.presheaf.obj (op ⊤))),
    affineProperty f → affineProperty (f ∣_ Scheme.basicOpen Y r)
[PROOFSTEP]
introv H
[GOAL]
case toBasicOpen
X✝ Y✝ : Scheme
f✝ : X✝ ⟶ Y✝
X Y : Scheme
inst✝ : IsAffine Y
f : X ⟶ Y
r : ↑(Y.presheaf.obj (op ⊤))
H : affineProperty f
⊢ affineProperty (f ∣_ Scheme.basicOpen Y r)
[PROOFSTEP]
dsimp [affineProperty] at H ⊢
[GOAL]
case toBasicOpen
X✝ Y✝ : Scheme
f✝ : X✝ ⟶ Y✝
X Y : Scheme
inst✝ : IsAffine Y
f : X ⟶ Y
r : ↑(Y.presheaf.obj (op ⊤))
H : CompactSpace ↑↑X.toPresheafedSpace
⊢ CompactSpace ↑((Opens.toTopCat ↑X.toPresheafedSpace).obj ((Opens.map f.val.base).obj (Scheme.basicOpen Y r)))
[PROOFSTEP]
change CompactSpace ((Opens.map f.val.base).obj (Y.basicOpen r))
[GOAL]
case toBasicOpen
X✝ Y✝ : Scheme
f✝ : X✝ ⟶ Y✝
X Y : Scheme
inst✝ : IsAffine Y
f : X ⟶ Y
r : ↑(Y.presheaf.obj (op ⊤))
H : CompactSpace ↑↑X.toPresheafedSpace
⊢ CompactSpace { x // x ∈ (Opens.map f.val.base).obj (Scheme.basicOpen Y r) }
[PROOFSTEP]
rw [Scheme.preimage_basicOpen f r]
[GOAL]
case toBasicOpen
X✝ Y✝ : Scheme
f✝ : X✝ ⟶ Y✝
X Y : Scheme
inst✝ : IsAffine Y
f : X ⟶ Y
r : ↑(Y.presheaf.obj (op ⊤))
H : CompactSpace ↑↑X.toPresheafedSpace
⊢ CompactSpace { x // x ∈ Scheme.basicOpen X (↑(NatTrans.app f.val.c (op ⊤)) r) }
[PROOFSTEP]
erw [← isCompact_iff_compactSpace]
[GOAL]
case toBasicOpen
X✝ Y✝ : Scheme
f✝ : X✝ ⟶ Y✝
X Y : Scheme
inst✝ : IsAffine Y
f : X ⟶ Y
r : ↑(Y.presheaf.obj (op ⊤))
H : CompactSpace ↑↑X.toPresheafedSpace
⊢ IsCompact ↑(Scheme.basicOpen X (↑(NatTrans.app f.val.c (op ⊤)) r))
[PROOFSTEP]
rw [← isCompact_univ_iff] at H
[GOAL]
case toBasicOpen
X✝ Y✝ : Scheme
f✝ : X✝ ⟶ Y✝
X Y : Scheme
inst✝ : IsAffine Y
f : X ⟶ Y
r : ↑(Y.presheaf.obj (op ⊤))
H : IsCompact Set.univ
⊢ IsCompact ↑(Scheme.basicOpen X (↑(NatTrans.app f.val.c (op ⊤)) r))
[PROOFSTEP]
apply isCompact_basicOpen
[GOAL]
case toBasicOpen.hU
X✝ Y✝ : Scheme
f✝ : X✝ ⟶ Y✝
X Y : Scheme
inst✝ : IsAffine Y
f : X ⟶ Y
r : ↑(Y.presheaf.obj (op ⊤))
H : IsCompact Set.univ
⊢ IsCompact ↑((Opens.map f.val.base).obj ⊤)
[PROOFSTEP]
exact H
[GOAL]
case ofBasicOpenCover
X Y : Scheme
f : X ⟶ Y
⊢ ∀ {X Y : Scheme} [inst : IsAffine Y] (f : X ⟶ Y) (s : Finset ↑(Y.presheaf.obj (op ⊤))),
    Ideal.span ↑s = ⊤ → (∀ (r : { x // x ∈ s }), affineProperty (f ∣_ Scheme.basicOpen Y ↑r)) → affineProperty f
[PROOFSTEP]
rintro X Y H f S hS hS'
[GOAL]
case ofBasicOpenCover
X✝ Y✝ : Scheme
f✝ : X✝ ⟶ Y✝
X Y : Scheme
H : IsAffine Y
f : X ⟶ Y
S : Finset ↑(Y.presheaf.obj (op ⊤))
hS : Ideal.span ↑S = ⊤
hS' : ∀ (r : { x // x ∈ S }), affineProperty (f ∣_ Scheme.basicOpen Y ↑r)
⊢ affineProperty f
[PROOFSTEP]
rw [← IsAffineOpen.basicOpen_union_eq_self_iff] at hS
[GOAL]
case ofBasicOpenCover
X✝ Y✝ : Scheme
f✝ : X✝ ⟶ Y✝
X Y : Scheme
H : IsAffine Y
f : X ⟶ Y
S : Finset ↑(Y.presheaf.obj (op ⊤))
hS : ⨆ (f : ↑↑S), Scheme.basicOpen Y ↑f = ⊤
hS' : ∀ (r : { x // x ∈ S }), affineProperty (f ∣_ Scheme.basicOpen Y ↑r)
⊢ affineProperty f
case ofBasicOpenCover.hU
X✝ Y✝ : Scheme
f✝ : X✝ ⟶ Y✝
X Y : Scheme
H : IsAffine Y
f : X ⟶ Y
S : Finset ↑(Y.presheaf.obj (op ⊤))
hS : Ideal.span ↑S = ⊤
hS' : ∀ (r : { x // x ∈ S }), affineProperty (f ∣_ Scheme.basicOpen Y ↑r)
⊢ IsAffineOpen ⊤
[PROOFSTEP]
delta QuasiCompact.affineProperty
[GOAL]
case ofBasicOpenCover
X✝ Y✝ : Scheme
f✝ : X✝ ⟶ Y✝
X Y : Scheme
H : IsAffine Y
f : X ⟶ Y
S : Finset ↑(Y.presheaf.obj (op ⊤))
hS : ⨆ (f : ↑↑S), Scheme.basicOpen Y ↑f = ⊤
hS' : ∀ (r : { x // x ∈ S }), affineProperty (f ∣_ Scheme.basicOpen Y ↑r)
⊢ CompactSpace ↑↑X.toPresheafedSpace
case ofBasicOpenCover.hU
X✝ Y✝ : Scheme
f✝ : X✝ ⟶ Y✝
X Y : Scheme
H : IsAffine Y
f : X ⟶ Y
S : Finset ↑(Y.presheaf.obj (op ⊤))
hS : Ideal.span ↑S = ⊤
hS' : ∀ (r : { x // x ∈ S }), affineProperty (f ∣_ Scheme.basicOpen Y ↑r)
⊢ IsAffineOpen ⊤
[PROOFSTEP]
rw [← isCompact_univ_iff]
[GOAL]
case ofBasicOpenCover
X✝ Y✝ : Scheme
f✝ : X✝ ⟶ Y✝
X Y : Scheme
H : IsAffine Y
f : X ⟶ Y
S : Finset ↑(Y.presheaf.obj (op ⊤))
hS : ⨆ (f : ↑↑S), Scheme.basicOpen Y ↑f = ⊤
hS' : ∀ (r : { x // x ∈ S }), affineProperty (f ∣_ Scheme.basicOpen Y ↑r)
⊢ IsCompact Set.univ
case ofBasicOpenCover.hU
X✝ Y✝ : Scheme
f✝ : X✝ ⟶ Y✝
X Y : Scheme
H : IsAffine Y
f : X ⟶ Y
S : Finset ↑(Y.presheaf.obj (op ⊤))
hS : Ideal.span ↑S = ⊤
hS' : ∀ (r : { x // x ∈ S }), affineProperty (f ∣_ Scheme.basicOpen Y ↑r)
⊢ IsAffineOpen ⊤
[PROOFSTEP]
change IsCompact ((Opens.map f.val.base).obj ⊤).1
[GOAL]
case ofBasicOpenCover
X✝ Y✝ : Scheme
f✝ : X✝ ⟶ Y✝
X Y : Scheme
H : IsAffine Y
f : X ⟶ Y
S : Finset ↑(Y.presheaf.obj (op ⊤))
hS : ⨆ (f : ↑↑S), Scheme.basicOpen Y ↑f = ⊤
hS' : ∀ (r : { x // x ∈ S }), affineProperty (f ∣_ Scheme.basicOpen Y ↑r)
⊢ IsCompact ((Opens.map f.val.base).obj ⊤).carrier
case ofBasicOpenCover.hU
X✝ Y✝ : Scheme
f✝ : X✝ ⟶ Y✝
X Y : Scheme
H : IsAffine Y
f : X ⟶ Y
S : Finset ↑(Y.presheaf.obj (op ⊤))
hS : Ideal.span ↑S = ⊤
hS' : ∀ (r : { x // x ∈ S }), affineProperty (f ∣_ Scheme.basicOpen Y ↑r)
⊢ IsAffineOpen ⊤
[PROOFSTEP]
rw [← hS]
[GOAL]
case ofBasicOpenCover
X✝ Y✝ : Scheme
f✝ : X✝ ⟶ Y✝
X Y : Scheme
H : IsAffine Y
f : X ⟶ Y
S : Finset ↑(Y.presheaf.obj (op ⊤))
hS : ⨆ (f : ↑↑S), Scheme.basicOpen Y ↑f = ⊤
hS' : ∀ (r : { x // x ∈ S }), affineProperty (f ∣_ Scheme.basicOpen Y ↑r)
⊢ IsCompact ((Opens.map f.val.base).obj (⨆ (f : ↑↑S), Scheme.basicOpen Y ↑f)).carrier
case ofBasicOpenCover.hU
X✝ Y✝ : Scheme
f✝ : X✝ ⟶ Y✝
X Y : Scheme
H : IsAffine Y
f : X ⟶ Y
S : Finset ↑(Y.presheaf.obj (op ⊤))
hS : Ideal.span ↑S = ⊤
hS' : ∀ (r : { x // x ∈ S }), affineProperty (f ∣_ Scheme.basicOpen Y ↑r)
⊢ IsAffineOpen ⊤
[PROOFSTEP]
dsimp [Opens.map]
[GOAL]
case ofBasicOpenCover
X✝ Y✝ : Scheme
f✝ : X✝ ⟶ Y✝
X Y : Scheme
H : IsAffine Y
f : X ⟶ Y
S : Finset ↑(Y.presheaf.obj (op ⊤))
hS : ⨆ (f : ↑↑S), Scheme.basicOpen Y ↑f = ⊤
hS' : ∀ (r : { x // x ∈ S }), affineProperty (f ∣_ Scheme.basicOpen Y ↑r)
⊢ IsCompact (↑f.val.base ⁻¹' ↑(⨆ (f : { x // x ∈ S }), Scheme.basicOpen Y ↑f))
case ofBasicOpenCover.hU
X✝ Y✝ : Scheme
f✝ : X✝ ⟶ Y✝
X Y : Scheme
H : IsAffine Y
f : X ⟶ Y
S : Finset ↑(Y.presheaf.obj (op ⊤))
hS : Ideal.span ↑S = ⊤
hS' : ∀ (r : { x // x ∈ S }), affineProperty (f ∣_ Scheme.basicOpen Y ↑r)
⊢ IsAffineOpen ⊤
[PROOFSTEP]
simp only [Opens.iSup_mk, Opens.carrier_eq_coe, Opens.coe_mk, Set.preimage_iUnion]
[GOAL]
case ofBasicOpenCover
X✝ Y✝ : Scheme
f✝ : X✝ ⟶ Y✝
X Y : Scheme
H : IsAffine Y
f : X ⟶ Y
S : Finset ↑(Y.presheaf.obj (op ⊤))
hS : ⨆ (f : ↑↑S), Scheme.basicOpen Y ↑f = ⊤
hS' : ∀ (r : { x // x ∈ S }), affineProperty (f ∣_ Scheme.basicOpen Y ↑r)
⊢ IsCompact (⋃ (i : { x // x ∈ S }), ↑f.val.base ⁻¹' ↑(Scheme.basicOpen Y ↑i))
case ofBasicOpenCover.hU
X✝ Y✝ : Scheme
f✝ : X✝ ⟶ Y✝
X Y : Scheme
H : IsAffine Y
f : X ⟶ Y
S : Finset ↑(Y.presheaf.obj (op ⊤))
hS : Ideal.span ↑S = ⊤
hS' : ∀ (r : { x // x ∈ S }), affineProperty (f ∣_ Scheme.basicOpen Y ↑r)
⊢ IsAffineOpen ⊤
[PROOFSTEP]
exacts [isCompact_iUnion fun i => isCompact_iff_compactSpace.mpr (hS' i), topIsAffineOpen _]
[GOAL]
X Y : Scheme
f : X ⟶ Y
⊢ AffineTargetMorphismProperty.StableUnderBaseChange affineProperty
[PROOFSTEP]
intro X Y S _ _ f g h
[GOAL]
X✝ Y✝ : Scheme
f✝ : X✝ ⟶ Y✝
X Y S : Scheme
inst✝¹ : IsAffine S
inst✝ : IsAffine X
f : X ⟶ S
g : Y ⟶ S
h : affineProperty g
⊢ affineProperty pullback.fst
[PROOFSTEP]
rw [QuasiCompact.affineProperty] at h ⊢
[GOAL]
X✝ Y✝ : Scheme
f✝ : X✝ ⟶ Y✝
X Y S : Scheme
inst✝¹ : IsAffine S
inst✝ : IsAffine X
f : X ⟶ S
g : Y ⟶ S
h : CompactSpace ↑↑Y.toPresheafedSpace
⊢ CompactSpace ↑↑(pullback f g).toLocallyRingedSpace.toSheafedSpace.toPresheafedSpace
[PROOFSTEP]
skip
[GOAL]
X✝ Y✝ : Scheme
f✝ : X✝ ⟶ Y✝
X Y S : Scheme
inst✝¹ : IsAffine S
inst✝ : IsAffine X
f : X ⟶ S
g : Y ⟶ S
h : CompactSpace ↑↑Y.toPresheafedSpace
⊢ CompactSpace ↑↑(pullback f g).toLocallyRingedSpace.toSheafedSpace.toPresheafedSpace
[PROOFSTEP]
let 𝒰 := Scheme.Pullback.openCoverOfRight Y.affineCover.finiteSubcover f g
[GOAL]
X✝ Y✝ : Scheme
f✝ : X✝ ⟶ Y✝
X Y S : Scheme
inst✝¹ : IsAffine S
inst✝ : IsAffine X
f : X ⟶ S
g : Y ⟶ S
h : CompactSpace ↑↑Y.toPresheafedSpace
𝒰 : Scheme.OpenCover (pullback f g) :=
  Scheme.Pullback.openCoverOfRight (Scheme.OpenCover.finiteSubcover (Scheme.affineCover Y)) f g
⊢ CompactSpace ↑↑(pullback f g).toLocallyRingedSpace.toSheafedSpace.toPresheafedSpace
[PROOFSTEP]
have : Finite 𝒰.J := by dsimp; infer_instance
[GOAL]
X✝ Y✝ : Scheme
f✝ : X✝ ⟶ Y✝
X Y S : Scheme
inst✝¹ : IsAffine S
inst✝ : IsAffine X
f : X ⟶ S
g : Y ⟶ S
h : CompactSpace ↑↑Y.toPresheafedSpace
𝒰 : Scheme.OpenCover (pullback f g) :=
  Scheme.Pullback.openCoverOfRight (Scheme.OpenCover.finiteSubcover (Scheme.affineCover Y)) f g
⊢ Finite 𝒰.J
[PROOFSTEP]
dsimp
[GOAL]
X✝ Y✝ : Scheme
f✝ : X✝ ⟶ Y✝
X Y S : Scheme
inst✝¹ : IsAffine S
inst✝ : IsAffine X
f : X ⟶ S
g : Y ⟶ S
h : CompactSpace ↑↑Y.toPresheafedSpace
𝒰 : Scheme.OpenCover (pullback f g) :=
  Scheme.Pullback.openCoverOfRight (Scheme.OpenCover.finiteSubcover (Scheme.affineCover Y)) f g
⊢ Finite (Scheme.OpenCover.finiteSubcover (Scheme.affineCover Y)).J
[PROOFSTEP]
infer_instance
[GOAL]
X✝ Y✝ : Scheme
f✝ : X✝ ⟶ Y✝
X Y S : Scheme
inst✝¹ : IsAffine S
inst✝ : IsAffine X
f : X ⟶ S
g : Y ⟶ S
h : CompactSpace ↑↑Y.toPresheafedSpace
𝒰 : Scheme.OpenCover (pullback f g) :=
  Scheme.Pullback.openCoverOfRight (Scheme.OpenCover.finiteSubcover (Scheme.affineCover Y)) f g
this : Finite 𝒰.J
⊢ CompactSpace ↑↑(pullback f g).toLocallyRingedSpace.toSheafedSpace.toPresheafedSpace
[PROOFSTEP]
have : ∀ i, CompactSpace (𝒰.obj i).carrier := by intro i; dsimp; infer_instance
[GOAL]
X✝ Y✝ : Scheme
f✝ : X✝ ⟶ Y✝
X Y S : Scheme
inst✝¹ : IsAffine S
inst✝ : IsAffine X
f : X ⟶ S
g : Y ⟶ S
h : CompactSpace ↑↑Y.toPresheafedSpace
𝒰 : Scheme.OpenCover (pullback f g) :=
  Scheme.Pullback.openCoverOfRight (Scheme.OpenCover.finiteSubcover (Scheme.affineCover Y)) f g
this : Finite 𝒰.J
⊢ ∀ (i : 𝒰.J), CompactSpace ↑↑(Scheme.OpenCover.obj 𝒰 i).toPresheafedSpace
[PROOFSTEP]
intro i
[GOAL]
X✝ Y✝ : Scheme
f✝ : X✝ ⟶ Y✝
X Y S : Scheme
inst✝¹ : IsAffine S
inst✝ : IsAffine X
f : X ⟶ S
g : Y ⟶ S
h : CompactSpace ↑↑Y.toPresheafedSpace
𝒰 : Scheme.OpenCover (pullback f g) :=
  Scheme.Pullback.openCoverOfRight (Scheme.OpenCover.finiteSubcover (Scheme.affineCover Y)) f g
this : Finite 𝒰.J
i : 𝒰.J
⊢ CompactSpace ↑↑(Scheme.OpenCover.obj 𝒰 i).toPresheafedSpace
[PROOFSTEP]
dsimp
[GOAL]
X✝ Y✝ : Scheme
f✝ : X✝ ⟶ Y✝
X Y S : Scheme
inst✝¹ : IsAffine S
inst✝ : IsAffine X
f : X ⟶ S
g : Y ⟶ S
h : CompactSpace ↑↑Y.toPresheafedSpace
𝒰 : Scheme.OpenCover (pullback f g) :=
  Scheme.Pullback.openCoverOfRight (Scheme.OpenCover.finiteSubcover (Scheme.affineCover Y)) f g
this : Finite 𝒰.J
i : 𝒰.J
⊢ CompactSpace
    ↑↑(pullback f
                (Scheme.OpenCover.map (Scheme.affineCover Y) (Scheme.OpenCover.f (Scheme.affineCover Y) ↑i) ≫
                  g)).toLocallyRingedSpace.toSheafedSpace.toPresheafedSpace
[PROOFSTEP]
infer_instance
[GOAL]
X✝ Y✝ : Scheme
f✝ : X✝ ⟶ Y✝
X Y S : Scheme
inst✝¹ : IsAffine S
inst✝ : IsAffine X
f : X ⟶ S
g : Y ⟶ S
h : CompactSpace ↑↑Y.toPresheafedSpace
𝒰 : Scheme.OpenCover (pullback f g) :=
  Scheme.Pullback.openCoverOfRight (Scheme.OpenCover.finiteSubcover (Scheme.affineCover Y)) f g
this✝ : Finite 𝒰.J
this : ∀ (i : 𝒰.J), CompactSpace ↑↑(Scheme.OpenCover.obj 𝒰 i).toPresheafedSpace
⊢ CompactSpace ↑↑(pullback f g).toLocallyRingedSpace.toSheafedSpace.toPresheafedSpace
[PROOFSTEP]
exact 𝒰.compactSpace
[GOAL]
X Y : Scheme
f : X ⟶ Y
Z : Scheme
P : Opens ↑↑X.toPresheafedSpace → Prop
S : Opens ↑↑X.toPresheafedSpace
hS : IsCompact S.carrier
h₁ : P ⊥
h₂ : ∀ (S : Opens ↑↑X.toPresheafedSpace), IsCompact S.carrier → ∀ (U : ↑(Scheme.affineOpens X)), P S → P (S ⊔ ↑U)
⊢ P S
[PROOFSTEP]
classical
obtain ⟨s, hs, hs'⟩ := (isCompact_open_iff_eq_finset_affine_union S.1).mp ⟨hS, S.2⟩
replace hs' : S = iSup fun i : s => (i : Opens X.carrier) := by ext1; simpa using hs'
subst hs'
apply @Set.Finite.induction_on _ _ _ hs
· convert h₁; rw [iSup_eq_bot]; rintro ⟨_, h⟩; exact h.elim
· intro x s _ hs h₄
  have : IsCompact (⨆ i : s, (i : Opens X.carrier)).1 := by
    refine' ((isCompact_open_iff_eq_finset_affine_union _).mpr _).1; exact ⟨s, hs, by simp⟩
  convert h₂ _ this x h₄
  rw [iSup_subtype, sup_comm]
  conv_rhs => rw [iSup_subtype]
  exact iSup_insert
[GOAL]
X Y : Scheme
f : X ⟶ Y
Z : Scheme
P : Opens ↑↑X.toPresheafedSpace → Prop
S : Opens ↑↑X.toPresheafedSpace
hS : IsCompact S.carrier
h₁ : P ⊥
h₂ : ∀ (S : Opens ↑↑X.toPresheafedSpace), IsCompact S.carrier → ∀ (U : ↑(Scheme.affineOpens X)), P S → P (S ⊔ ↑U)
⊢ P S
[PROOFSTEP]
obtain ⟨s, hs, hs'⟩ := (isCompact_open_iff_eq_finset_affine_union S.1).mp ⟨hS, S.2⟩
[GOAL]
case intro.intro
X Y : Scheme
f : X ⟶ Y
Z : Scheme
P : Opens ↑↑X.toPresheafedSpace → Prop
S : Opens ↑↑X.toPresheafedSpace
hS : IsCompact S.carrier
h₁ : P ⊥
h₂ : ∀ (S : Opens ↑↑X.toPresheafedSpace), IsCompact S.carrier → ∀ (U : ↑(Scheme.affineOpens X)), P S → P (S ⊔ ↑U)
s : Set ↑(Scheme.affineOpens X)
hs : Set.Finite s
hs' : S.carrier = ⋃ (i : ↑(Scheme.affineOpens X)) (_ : i ∈ s), ↑↑i
⊢ P S
[PROOFSTEP]
replace hs' : S = iSup fun i : s => (i : Opens X.carrier) := by ext1; simpa using hs'
[GOAL]
X Y : Scheme
f : X ⟶ Y
Z : Scheme
P : Opens ↑↑X.toPresheafedSpace → Prop
S : Opens ↑↑X.toPresheafedSpace
hS : IsCompact S.carrier
h₁ : P ⊥
h₂ : ∀ (S : Opens ↑↑X.toPresheafedSpace), IsCompact S.carrier → ∀ (U : ↑(Scheme.affineOpens X)), P S → P (S ⊔ ↑U)
s : Set ↑(Scheme.affineOpens X)
hs : Set.Finite s
hs' : S.carrier = ⋃ (i : ↑(Scheme.affineOpens X)) (_ : i ∈ s), ↑↑i
⊢ S = ⨆ (i : ↑s), ↑↑i
[PROOFSTEP]
ext1
[GOAL]
case h
X Y : Scheme
f : X ⟶ Y
Z : Scheme
P : Opens ↑↑X.toPresheafedSpace → Prop
S : Opens ↑↑X.toPresheafedSpace
hS : IsCompact S.carrier
h₁ : P ⊥
h₂ : ∀ (S : Opens ↑↑X.toPresheafedSpace), IsCompact S.carrier → ∀ (U : ↑(Scheme.affineOpens X)), P S → P (S ⊔ ↑U)
s : Set ↑(Scheme.affineOpens X)
hs : Set.Finite s
hs' : S.carrier = ⋃ (i : ↑(Scheme.affineOpens X)) (_ : i ∈ s), ↑↑i
⊢ ↑S = ↑(⨆ (i : ↑s), ↑↑i)
[PROOFSTEP]
simpa using hs'
[GOAL]
case intro.intro
X Y : Scheme
f : X ⟶ Y
Z : Scheme
P : Opens ↑↑X.toPresheafedSpace → Prop
S : Opens ↑↑X.toPresheafedSpace
hS : IsCompact S.carrier
h₁ : P ⊥
h₂ : ∀ (S : Opens ↑↑X.toPresheafedSpace), IsCompact S.carrier → ∀ (U : ↑(Scheme.affineOpens X)), P S → P (S ⊔ ↑U)
s : Set ↑(Scheme.affineOpens X)
hs : Set.Finite s
hs' : S = ⨆ (i : ↑s), ↑↑i
⊢ P S
[PROOFSTEP]
subst hs'
[GOAL]
case intro.intro
X Y : Scheme
f : X ⟶ Y
Z : Scheme
P : Opens ↑↑X.toPresheafedSpace → Prop
h₁ : P ⊥
h₂ : ∀ (S : Opens ↑↑X.toPresheafedSpace), IsCompact S.carrier → ∀ (U : ↑(Scheme.affineOpens X)), P S → P (S ⊔ ↑U)
s : Set ↑(Scheme.affineOpens X)
hs : Set.Finite s
hS : IsCompact (⨆ (i : ↑s), ↑↑i).carrier
⊢ P (⨆ (i : ↑s), ↑↑i)
[PROOFSTEP]
apply @Set.Finite.induction_on _ _ _ hs
[GOAL]
case intro.intro.H0
X Y : Scheme
f : X ⟶ Y
Z : Scheme
P : Opens ↑↑X.toPresheafedSpace → Prop
h₁ : P ⊥
h₂ : ∀ (S : Opens ↑↑X.toPresheafedSpace), IsCompact S.carrier → ∀ (U : ↑(Scheme.affineOpens X)), P S → P (S ⊔ ↑U)
s : Set ↑(Scheme.affineOpens X)
hs : Set.Finite s
hS : IsCompact (⨆ (i : ↑s), ↑↑i).carrier
⊢ P (⨆ (i : ↑∅), ↑↑i)
[PROOFSTEP]
convert h₁
[GOAL]
case h.e'_1
X Y : Scheme
f : X ⟶ Y
Z : Scheme
P : Opens ↑↑X.toPresheafedSpace → Prop
h₁ : P ⊥
h₂ : ∀ (S : Opens ↑↑X.toPresheafedSpace), IsCompact S.carrier → ∀ (U : ↑(Scheme.affineOpens X)), P S → P (S ⊔ ↑U)
s : Set ↑(Scheme.affineOpens X)
hs : Set.Finite s
hS : IsCompact (⨆ (i : ↑s), ↑↑i).carrier
⊢ ⨆ (i : ↑∅), ↑↑i = ⊥
[PROOFSTEP]
rw [iSup_eq_bot]
[GOAL]
case h.e'_1
X Y : Scheme
f : X ⟶ Y
Z : Scheme
P : Opens ↑↑X.toPresheafedSpace → Prop
h₁ : P ⊥
h₂ : ∀ (S : Opens ↑↑X.toPresheafedSpace), IsCompact S.carrier → ∀ (U : ↑(Scheme.affineOpens X)), P S → P (S ⊔ ↑U)
s : Set ↑(Scheme.affineOpens X)
hs : Set.Finite s
hS : IsCompact (⨆ (i : ↑s), ↑↑i).carrier
⊢ ∀ (i : ↑∅), ↑↑i = ⊥
[PROOFSTEP]
rintro ⟨_, h⟩
[GOAL]
case h.e'_1.mk
X Y : Scheme
f : X ⟶ Y
Z : Scheme
P : Opens ↑↑X.toPresheafedSpace → Prop
h₁ : P ⊥
h₂ : ∀ (S : Opens ↑↑X.toPresheafedSpace), IsCompact S.carrier → ∀ (U : ↑(Scheme.affineOpens X)), P S → P (S ⊔ ↑U)
s : Set ↑(Scheme.affineOpens X)
hs : Set.Finite s
hS : IsCompact (⨆ (i : ↑s), ↑↑i).carrier
val✝ : ↑(Scheme.affineOpens X)
h : val✝ ∈ ∅
⊢ ↑↑{ val := val✝, property := h } = ⊥
[PROOFSTEP]
exact h.elim
[GOAL]
case intro.intro.H1
X Y : Scheme
f : X ⟶ Y
Z : Scheme
P : Opens ↑↑X.toPresheafedSpace → Prop
h₁ : P ⊥
h₂ : ∀ (S : Opens ↑↑X.toPresheafedSpace), IsCompact S.carrier → ∀ (U : ↑(Scheme.affineOpens X)), P S → P (S ⊔ ↑U)
s : Set ↑(Scheme.affineOpens X)
hs : Set.Finite s
hS : IsCompact (⨆ (i : ↑s), ↑↑i).carrier
⊢ ∀ {a : ↑(Scheme.affineOpens X)} {s : Set ↑(Scheme.affineOpens X)},
    ¬a ∈ s → Set.Finite s → P (⨆ (i : ↑s), ↑↑i) → P (⨆ (i : ↑(insert a s)), ↑↑i)
[PROOFSTEP]
intro x s _ hs h₄
[GOAL]
case intro.intro.H1
X Y : Scheme
f : X ⟶ Y
Z : Scheme
P : Opens ↑↑X.toPresheafedSpace → Prop
h₁ : P ⊥
h₂ : ∀ (S : Opens ↑↑X.toPresheafedSpace), IsCompact S.carrier → ∀ (U : ↑(Scheme.affineOpens X)), P S → P (S ⊔ ↑U)
s✝ : Set ↑(Scheme.affineOpens X)
hs✝ : Set.Finite s✝
hS : IsCompact (⨆ (i : ↑s✝), ↑↑i).carrier
x : ↑(Scheme.affineOpens X)
s : Set ↑(Scheme.affineOpens X)
a✝ : ¬x ∈ s
hs : Set.Finite s
h₄ : P (⨆ (i : ↑s), ↑↑i)
⊢ P (⨆ (i : ↑(insert x s)), ↑↑i)
[PROOFSTEP]
have : IsCompact (⨆ i : s, (i : Opens X.carrier)).1 := by
  refine' ((isCompact_open_iff_eq_finset_affine_union _).mpr _).1; exact ⟨s, hs, by simp⟩
[GOAL]
X Y : Scheme
f : X ⟶ Y
Z : Scheme
P : Opens ↑↑X.toPresheafedSpace → Prop
h₁ : P ⊥
h₂ : ∀ (S : Opens ↑↑X.toPresheafedSpace), IsCompact S.carrier → ∀ (U : ↑(Scheme.affineOpens X)), P S → P (S ⊔ ↑U)
s✝ : Set ↑(Scheme.affineOpens X)
hs✝ : Set.Finite s✝
hS : IsCompact (⨆ (i : ↑s✝), ↑↑i).carrier
x : ↑(Scheme.affineOpens X)
s : Set ↑(Scheme.affineOpens X)
a✝ : ¬x ∈ s
hs : Set.Finite s
h₄ : P (⨆ (i : ↑s), ↑↑i)
⊢ IsCompact (⨆ (i : ↑s), ↑↑i).carrier
[PROOFSTEP]
refine' ((isCompact_open_iff_eq_finset_affine_union _).mpr _).1
[GOAL]
X Y : Scheme
f : X ⟶ Y
Z : Scheme
P : Opens ↑↑X.toPresheafedSpace → Prop
h₁ : P ⊥
h₂ : ∀ (S : Opens ↑↑X.toPresheafedSpace), IsCompact S.carrier → ∀ (U : ↑(Scheme.affineOpens X)), P S → P (S ⊔ ↑U)
s✝ : Set ↑(Scheme.affineOpens X)
hs✝ : Set.Finite s✝
hS : IsCompact (⨆ (i : ↑s✝), ↑↑i).carrier
x : ↑(Scheme.affineOpens X)
s : Set ↑(Scheme.affineOpens X)
a✝ : ¬x ∈ s
hs : Set.Finite s
h₄ : P (⨆ (i : ↑s), ↑↑i)
⊢ ∃ s_1, Set.Finite s_1 ∧ (⨆ (i : ↑s), ↑↑i).carrier = ⋃ (i : ↑(Scheme.affineOpens X)) (_ : i ∈ s_1), ↑↑i
[PROOFSTEP]
exact ⟨s, hs, by simp⟩
[GOAL]
X Y : Scheme
f : X ⟶ Y
Z : Scheme
P : Opens ↑↑X.toPresheafedSpace → Prop
h₁ : P ⊥
h₂ : ∀ (S : Opens ↑↑X.toPresheafedSpace), IsCompact S.carrier → ∀ (U : ↑(Scheme.affineOpens X)), P S → P (S ⊔ ↑U)
s✝ : Set ↑(Scheme.affineOpens X)
hs✝ : Set.Finite s✝
hS : IsCompact (⨆ (i : ↑s✝), ↑↑i).carrier
x : ↑(Scheme.affineOpens X)
s : Set ↑(Scheme.affineOpens X)
a✝ : ¬x ∈ s
hs : Set.Finite s
h₄ : P (⨆ (i : ↑s), ↑↑i)
⊢ (⨆ (i : ↑s), ↑↑i).carrier = ⋃ (i : ↑(Scheme.affineOpens X)) (_ : i ∈ s), ↑↑i
[PROOFSTEP]
simp
[GOAL]
case intro.intro.H1
X Y : Scheme
f : X ⟶ Y
Z : Scheme
P : Opens ↑↑X.toPresheafedSpace → Prop
h₁ : P ⊥
h₂ : ∀ (S : Opens ↑↑X.toPresheafedSpace), IsCompact S.carrier → ∀ (U : ↑(Scheme.affineOpens X)), P S → P (S ⊔ ↑U)
s✝ : Set ↑(Scheme.affineOpens X)
hs✝ : Set.Finite s✝
hS : IsCompact (⨆ (i : ↑s✝), ↑↑i).carrier
x : ↑(Scheme.affineOpens X)
s : Set ↑(Scheme.affineOpens X)
a✝ : ¬x ∈ s
hs : Set.Finite s
h₄ : P (⨆ (i : ↑s), ↑↑i)
this : IsCompact (⨆ (i : ↑s), ↑↑i).carrier
⊢ P (⨆ (i : ↑(insert x s)), ↑↑i)
[PROOFSTEP]
convert h₂ _ this x h₄
[GOAL]
case h.e'_1
X Y : Scheme
f : X ⟶ Y
Z : Scheme
P : Opens ↑↑X.toPresheafedSpace → Prop
h₁ : P ⊥
h₂ : ∀ (S : Opens ↑↑X.toPresheafedSpace), IsCompact S.carrier → ∀ (U : ↑(Scheme.affineOpens X)), P S → P (S ⊔ ↑U)
s✝ : Set ↑(Scheme.affineOpens X)
hs✝ : Set.Finite s✝
hS : IsCompact (⨆ (i : ↑s✝), ↑↑i).carrier
x : ↑(Scheme.affineOpens X)
s : Set ↑(Scheme.affineOpens X)
a✝ : ¬x ∈ s
hs : Set.Finite s
h₄ : P (⨆ (i : ↑s), ↑↑i)
this : IsCompact (⨆ (i : ↑s), ↑↑i).carrier
⊢ ⨆ (i : ↑(insert x s)), ↑↑i = (⨆ (i : ↑s), ↑↑i) ⊔ ↑x
[PROOFSTEP]
rw [iSup_subtype, sup_comm]
[GOAL]
case h.e'_1
X Y : Scheme
f : X ⟶ Y
Z : Scheme
P : Opens ↑↑X.toPresheafedSpace → Prop
h₁ : P ⊥
h₂ : ∀ (S : Opens ↑↑X.toPresheafedSpace), IsCompact S.carrier → ∀ (U : ↑(Scheme.affineOpens X)), P S → P (S ⊔ ↑U)
s✝ : Set ↑(Scheme.affineOpens X)
hs✝ : Set.Finite s✝
hS : IsCompact (⨆ (i : ↑s✝), ↑↑i).carrier
x : ↑(Scheme.affineOpens X)
s : Set ↑(Scheme.affineOpens X)
a✝ : ¬x ∈ s
hs : Set.Finite s
h₄ : P (⨆ (i : ↑s), ↑↑i)
this : IsCompact (⨆ (i : ↑s), ↑↑i).carrier
⊢ ⨆ (i : ↑(Scheme.affineOpens X)) (h : i ∈ insert x s), ↑↑{ val := i, property := h } = ↑x ⊔ ⨆ (i : ↑s), ↑↑i
[PROOFSTEP]
conv_rhs => rw [iSup_subtype]
[GOAL]
X Y : Scheme
f : X ⟶ Y
Z : Scheme
P : Opens ↑↑X.toPresheafedSpace → Prop
h₁ : P ⊥
h₂ : ∀ (S : Opens ↑↑X.toPresheafedSpace), IsCompact S.carrier → ∀ (U : ↑(Scheme.affineOpens X)), P S → P (S ⊔ ↑U)
s✝ : Set ↑(Scheme.affineOpens X)
hs✝ : Set.Finite s✝
hS : IsCompact (⨆ (i : ↑s✝), ↑↑i).carrier
x : ↑(Scheme.affineOpens X)
s : Set ↑(Scheme.affineOpens X)
a✝ : ¬x ∈ s
hs : Set.Finite s
h₄ : P (⨆ (i : ↑s), ↑↑i)
this : IsCompact (⨆ (i : ↑s), ↑↑i).carrier
| ↑x ⊔ ⨆ (i : ↑s), ↑↑i
[PROOFSTEP]
rw [iSup_subtype]
[GOAL]
X Y : Scheme
f : X ⟶ Y
Z : Scheme
P : Opens ↑↑X.toPresheafedSpace → Prop
h₁ : P ⊥
h₂ : ∀ (S : Opens ↑↑X.toPresheafedSpace), IsCompact S.carrier → ∀ (U : ↑(Scheme.affineOpens X)), P S → P (S ⊔ ↑U)
s✝ : Set ↑(Scheme.affineOpens X)
hs✝ : Set.Finite s✝
hS : IsCompact (⨆ (i : ↑s✝), ↑↑i).carrier
x : ↑(Scheme.affineOpens X)
s : Set ↑(Scheme.affineOpens X)
a✝ : ¬x ∈ s
hs : Set.Finite s
h₄ : P (⨆ (i : ↑s), ↑↑i)
this : IsCompact (⨆ (i : ↑s), ↑↑i).carrier
| ↑x ⊔ ⨆ (i : ↑s), ↑↑i
[PROOFSTEP]
rw [iSup_subtype]
[GOAL]
X Y : Scheme
f : X ⟶ Y
Z : Scheme
P : Opens ↑↑X.toPresheafedSpace → Prop
h₁ : P ⊥
h₂ : ∀ (S : Opens ↑↑X.toPresheafedSpace), IsCompact S.carrier → ∀ (U : ↑(Scheme.affineOpens X)), P S → P (S ⊔ ↑U)
s✝ : Set ↑(Scheme.affineOpens X)
hs✝ : Set.Finite s✝
hS : IsCompact (⨆ (i : ↑s✝), ↑↑i).carrier
x : ↑(Scheme.affineOpens X)
s : Set ↑(Scheme.affineOpens X)
a✝ : ¬x ∈ s
hs : Set.Finite s
h₄ : P (⨆ (i : ↑s), ↑↑i)
this : IsCompact (⨆ (i : ↑s), ↑↑i).carrier
| ↑x ⊔ ⨆ (i : ↑s), ↑↑i
[PROOFSTEP]
rw [iSup_subtype]
[GOAL]
case h.e'_1
X Y : Scheme
f : X ⟶ Y
Z : Scheme
P : Opens ↑↑X.toPresheafedSpace → Prop
h₁ : P ⊥
h₂ : ∀ (S : Opens ↑↑X.toPresheafedSpace), IsCompact S.carrier → ∀ (U : ↑(Scheme.affineOpens X)), P S → P (S ⊔ ↑U)
s✝ : Set ↑(Scheme.affineOpens X)
hs✝ : Set.Finite s✝
hS : IsCompact (⨆ (i : ↑s✝), ↑↑i).carrier
x : ↑(Scheme.affineOpens X)
s : Set ↑(Scheme.affineOpens X)
a✝ : ¬x ∈ s
hs : Set.Finite s
h₄ : P (⨆ (i : ↑s), ↑↑i)
this : IsCompact (⨆ (i : ↑s), ↑↑i).carrier
⊢ ⨆ (i : ↑(Scheme.affineOpens X)) (h : i ∈ insert x s), ↑↑{ val := i, property := h } =
    ↑x ⊔ ⨆ (i : ↑(Scheme.affineOpens X)) (h : i ∈ s), ↑↑{ val := i, property := h }
[PROOFSTEP]
exact iSup_insert
[GOAL]
X✝ Y : Scheme
f✝ : X✝ ⟶ Y
Z : Scheme
X : Scheme
U : Opens ↑↑X.toPresheafedSpace
hU : IsAffineOpen U
x f : ↑(X.presheaf.obj (op U))
H : x |_ Scheme.basicOpen X f = 0
⊢ ∃ n, f ^ n * x = 0
[PROOFSTEP]
rw [← map_zero (X.presheaf.map (homOfLE <| X.basicOpen_le f : X.basicOpen f ⟶ U).op)] at H
[GOAL]
X✝ Y : Scheme
f✝ : X✝ ⟶ Y
Z : Scheme
X : Scheme
U : Opens ↑↑X.toPresheafedSpace
hU : IsAffineOpen U
x f : ↑(X.presheaf.obj (op U))
H : x |_ Scheme.basicOpen X f = ↑(X.presheaf.map (homOfLE (_ : Scheme.basicOpen X f ≤ U)).op) 0
⊢ ∃ n, f ^ n * x = 0
[PROOFSTEP]
obtain ⟨⟨_, n, rfl⟩, e⟩ := (isLocalization_basicOpen hU f).eq_iff_exists'.mp H
[GOAL]
case intro.mk.intro
X✝ Y : Scheme
f✝ : X✝ ⟶ Y
Z : Scheme
X : Scheme
U : Opens ↑↑X.toPresheafedSpace
hU : IsAffineOpen U
x f : ↑(X.presheaf.obj (op U))
H : x |_ Scheme.basicOpen X f = ↑(X.presheaf.map (homOfLE (_ : Scheme.basicOpen X f ≤ U)).op) 0
n : ℕ
e :
  ↑{ val := (fun x x_1 => x ^ x_1) f n,
          property := (_ : ∃ y, (fun x x_1 => x ^ x_1) f y = (fun x x_1 => x ^ x_1) f n) } *
      x =
    ↑{ val := (fun x x_1 => x ^ x_1) f n,
          property := (_ : ∃ y, (fun x x_1 => x ^ x_1) f y = (fun x x_1 => x ^ x_1) f n) } *
      0
⊢ ∃ n, f ^ n * x = 0
[PROOFSTEP]
exact ⟨n, by simpa [mul_comm x] using e⟩
[GOAL]
X✝ Y : Scheme
f✝ : X✝ ⟶ Y
Z : Scheme
X : Scheme
U : Opens ↑↑X.toPresheafedSpace
hU : IsAffineOpen U
x f : ↑(X.presheaf.obj (op U))
H : x |_ Scheme.basicOpen X f = ↑(X.presheaf.map (homOfLE (_ : Scheme.basicOpen X f ≤ U)).op) 0
n : ℕ
e :
  ↑{ val := (fun x x_1 => x ^ x_1) f n,
          property := (_ : ∃ y, (fun x x_1 => x ^ x_1) f y = (fun x x_1 => x ^ x_1) f n) } *
      x =
    ↑{ val := (fun x x_1 => x ^ x_1) f n,
          property := (_ : ∃ y, (fun x x_1 => x ^ x_1) f y = (fun x x_1 => x ^ x_1) f n) } *
      0
⊢ f ^ n * x = 0
[PROOFSTEP]
simpa [mul_comm x] using e
[GOAL]
X✝ Y : Scheme
f✝ : X✝ ⟶ Y
Z X : Scheme
U : Opens ↑↑X.toPresheafedSpace
hU : IsCompact U.carrier
x f : ↑(X.presheaf.obj (op U))
H : x |_ Scheme.basicOpen X f = 0
⊢ ∃ n, f ^ n * x = 0
[PROOFSTEP]
obtain ⟨s, hs, e⟩ := (isCompact_open_iff_eq_finset_affine_union U.1).mp ⟨hU, U.2⟩
[GOAL]
case intro.intro
X✝ Y : Scheme
f✝ : X✝ ⟶ Y
Z X : Scheme
U : Opens ↑↑X.toPresheafedSpace
hU : IsCompact U.carrier
x f : ↑(X.presheaf.obj (op U))
H : x |_ Scheme.basicOpen X f = 0
s : Set ↑(Scheme.affineOpens X)
hs : Set.Finite s
e : U.carrier = ⋃ (i : ↑(Scheme.affineOpens X)) (_ : i ∈ s), ↑↑i
⊢ ∃ n, f ^ n * x = 0
[PROOFSTEP]
replace e : U = iSup fun i : s => (i : Opens X.carrier)
[GOAL]
case e
X✝ Y : Scheme
f✝ : X✝ ⟶ Y
Z X : Scheme
U : Opens ↑↑X.toPresheafedSpace
hU : IsCompact U.carrier
x f : ↑(X.presheaf.obj (op U))
H : x |_ Scheme.basicOpen X f = 0
s : Set ↑(Scheme.affineOpens X)
hs : Set.Finite s
e : U.carrier = ⋃ (i : ↑(Scheme.affineOpens X)) (_ : i ∈ s), ↑↑i
⊢ U = ⨆ (i : ↑s), ↑↑i
[PROOFSTEP]
ext1
[GOAL]
case e.h
X✝ Y : Scheme
f✝ : X✝ ⟶ Y
Z X : Scheme
U : Opens ↑↑X.toPresheafedSpace
hU : IsCompact U.carrier
x f : ↑(X.presheaf.obj (op U))
H : x |_ Scheme.basicOpen X f = 0
s : Set ↑(Scheme.affineOpens X)
hs : Set.Finite s
e : U.carrier = ⋃ (i : ↑(Scheme.affineOpens X)) (_ : i ∈ s), ↑↑i
⊢ ↑U = ↑(⨆ (i : ↑s), ↑↑i)
[PROOFSTEP]
simpa using e
[GOAL]
case intro.intro
X✝ Y : Scheme
f✝ : X✝ ⟶ Y
Z X : Scheme
U : Opens ↑↑X.toPresheafedSpace
hU : IsCompact U.carrier
x f : ↑(X.presheaf.obj (op U))
H : x |_ Scheme.basicOpen X f = 0
s : Set ↑(Scheme.affineOpens X)
hs : Set.Finite s
e : U = ⨆ (i : ↑s), ↑↑i
⊢ ∃ n, f ^ n * x = 0
[PROOFSTEP]
have h₁ : ∀ i : s, i.1.1 ≤ U := by
  intro i
  change (i : Opens X.carrier) ≤ U
  rw [e]
    -- porting note: `exact le_iSup _ _` no longer works
  exact le_iSup (fun (i : s) => (i : Opens (X.toPresheafedSpace))) _
[GOAL]
X✝ Y : Scheme
f✝ : X✝ ⟶ Y
Z X : Scheme
U : Opens ↑↑X.toPresheafedSpace
hU : IsCompact U.carrier
x f : ↑(X.presheaf.obj (op U))
H : x |_ Scheme.basicOpen X f = 0
s : Set ↑(Scheme.affineOpens X)
hs : Set.Finite s
e : U = ⨆ (i : ↑s), ↑↑i
⊢ ∀ (i : ↑s), ↑↑i ≤ U
[PROOFSTEP]
intro i
[GOAL]
X✝ Y : Scheme
f✝ : X✝ ⟶ Y
Z X : Scheme
U : Opens ↑↑X.toPresheafedSpace
hU : IsCompact U.carrier
x f : ↑(X.presheaf.obj (op U))
H : x |_ Scheme.basicOpen X f = 0
s : Set ↑(Scheme.affineOpens X)
hs : Set.Finite s
e : U = ⨆ (i : ↑s), ↑↑i
i : ↑s
⊢ ↑↑i ≤ U
[PROOFSTEP]
change (i : Opens X.carrier) ≤ U
[GOAL]
X✝ Y : Scheme
f✝ : X✝ ⟶ Y
Z X : Scheme
U : Opens ↑↑X.toPresheafedSpace
hU : IsCompact U.carrier
x f : ↑(X.presheaf.obj (op U))
H : x |_ Scheme.basicOpen X f = 0
s : Set ↑(Scheme.affineOpens X)
hs : Set.Finite s
e : U = ⨆ (i : ↑s), ↑↑i
i : ↑s
⊢ ↑↑i ≤ U
[PROOFSTEP]
rw [e]
  -- porting note: `exact le_iSup _ _` no longer works
[GOAL]
X✝ Y : Scheme
f✝ : X✝ ⟶ Y
Z X : Scheme
U : Opens ↑↑X.toPresheafedSpace
hU : IsCompact U.carrier
x f : ↑(X.presheaf.obj (op U))
H : x |_ Scheme.basicOpen X f = 0
s : Set ↑(Scheme.affineOpens X)
hs : Set.Finite s
e : U = ⨆ (i : ↑s), ↑↑i
i : ↑s
⊢ ↑↑i ≤ ⨆ (i : ↑s), ↑↑i
[PROOFSTEP]
exact le_iSup (fun (i : s) => (i : Opens (X.toPresheafedSpace))) _
[GOAL]
case intro.intro
X✝ Y : Scheme
f✝ : X✝ ⟶ Y
Z X : Scheme
U : Opens ↑↑X.toPresheafedSpace
hU : IsCompact U.carrier
x f : ↑(X.presheaf.obj (op U))
H : x |_ Scheme.basicOpen X f = 0
s : Set ↑(Scheme.affineOpens X)
hs : Set.Finite s
e : U = ⨆ (i : ↑s), ↑↑i
h₁ : ∀ (i : ↑s), ↑↑i ≤ U
⊢ ∃ n, f ^ n * x = 0
[PROOFSTEP]
have H' := fun i : s =>
  exists_pow_mul_eq_zero_of_res_basicOpen_eq_zero_of_isAffineOpen X i.1.2 (X.presheaf.map (homOfLE (h₁ i)).op x)
    (X.presheaf.map (homOfLE (h₁ i)).op f) ?_
[GOAL]
case intro.intro.refine_2
X✝ Y : Scheme
f✝ : X✝ ⟶ Y
Z X : Scheme
U : Opens ↑↑X.toPresheafedSpace
hU : IsCompact U.carrier
x f : ↑(X.presheaf.obj (op U))
H : x |_ Scheme.basicOpen X f = 0
s : Set ↑(Scheme.affineOpens X)
hs : Set.Finite s
e : U = ⨆ (i : ↑s), ↑↑i
h₁ : ∀ (i : ↑s), ↑↑i ≤ U
H' :
  ∀ (i : ↑s),
    ∃ n, ↑(X.presheaf.map (homOfLE (_ : ↑↑i ≤ U)).op) f ^ n * ↑(X.presheaf.map (homOfLE (_ : ↑↑i ≤ U)).op) x = 0
⊢ ∃ n, f ^ n * x = 0
case intro.intro.refine_1
X✝ Y : Scheme
f✝ : X✝ ⟶ Y
Z X : Scheme
U : Opens ↑↑X.toPresheafedSpace
hU : IsCompact U.carrier
x f : ↑(X.presheaf.obj (op U))
H : x |_ Scheme.basicOpen X f = 0
s : Set ↑(Scheme.affineOpens X)
hs : Set.Finite s
e : U = ⨆ (i : ↑s), ↑↑i
h₁ : ∀ (i : ↑s), ↑↑i ≤ U
i : ↑s
⊢ ↑(X.presheaf.map (homOfLE (_ : ↑↑i ≤ U)).op) x |_
      Scheme.basicOpen X (↑(X.presheaf.map (homOfLE (_ : ↑↑i ≤ U)).op) f) =
    0
[PROOFSTEP]
swap
[GOAL]
case intro.intro.refine_1
X✝ Y : Scheme
f✝ : X✝ ⟶ Y
Z X : Scheme
U : Opens ↑↑X.toPresheafedSpace
hU : IsCompact U.carrier
x f : ↑(X.presheaf.obj (op U))
H : x |_ Scheme.basicOpen X f = 0
s : Set ↑(Scheme.affineOpens X)
hs : Set.Finite s
e : U = ⨆ (i : ↑s), ↑↑i
h₁ : ∀ (i : ↑s), ↑↑i ≤ U
i : ↑s
⊢ ↑(X.presheaf.map (homOfLE (_ : ↑↑i ≤ U)).op) x |_
      Scheme.basicOpen X (↑(X.presheaf.map (homOfLE (_ : ↑↑i ≤ U)).op) f) =
    0
[PROOFSTEP]
delta TopCat.Presheaf.restrictOpen TopCat.Presheaf.restrict at H ⊢
[GOAL]
case intro.intro.refine_1
X✝ Y : Scheme
f✝ : X✝ ⟶ Y
Z X : Scheme
U : Opens ↑↑X.toPresheafedSpace
hU : IsCompact U.carrier
x f : ↑(X.presheaf.obj (op U))
H : ↑(X.presheaf.map (homOfLE (_ : ∀ ⦃a : ↑↑X.toPresheafedSpace⦄, a ∈ ↑(Scheme.basicOpen X f) → a ∈ ↑U)).op) x = 0
s : Set ↑(Scheme.affineOpens X)
hs : Set.Finite s
e : U = ⨆ (i : ↑s), ↑↑i
h₁ : ∀ (i : ↑s), ↑↑i ≤ U
i : ↑s
⊢ ↑(X.presheaf.map
          (homOfLE
              (_ :
                ∀ ⦃a : ↑↑X.toPresheafedSpace⦄,
                  a ∈ ↑(Scheme.basicOpen X (↑(X.presheaf.map (homOfLE (_ : ↑↑i ≤ U)).op) f)) → a ∈ ↑↑↑i)).op)
      (↑(X.presheaf.map (homOfLE (_ : ↑↑i ≤ U)).op) x) =
    0
[PROOFSTEP]
convert congr_arg (X.presheaf.map (homOfLE _).op) H
[GOAL]
case h.e'_2
X✝ Y : Scheme
f✝ : X✝ ⟶ Y
Z X : Scheme
U : Opens ↑↑X.toPresheafedSpace
hU : IsCompact U.carrier
x f : ↑(X.presheaf.obj (op U))
H : ↑(X.presheaf.map (homOfLE (_ : ∀ ⦃a : ↑↑X.toPresheafedSpace⦄, a ∈ ↑(Scheme.basicOpen X f) → a ∈ ↑U)).op) x = 0
s : Set ↑(Scheme.affineOpens X)
hs : Set.Finite s
e : U = ⨆ (i : ↑s), ↑↑i
h₁ : ∀ (i : ↑s), ↑↑i ≤ U
i : ↑s
⊢ ↑(X.presheaf.map
          (homOfLE
              (_ :
                ∀ ⦃a : ↑↑X.toPresheafedSpace⦄,
                  a ∈ ↑(Scheme.basicOpen X (↑(X.presheaf.map (homOfLE (_ : ↑↑i ≤ U)).op) f)) → a ∈ ↑↑↑i)).op)
      (↑(X.presheaf.map (homOfLE (_ : ↑↑i ≤ U)).op) x) =
    ↑(X.presheaf.map (homOfLE ?intro.intro.refine_1.convert_1).op)
      (↑(X.presheaf.map (homOfLE (_ : ∀ ⦃a : ↑↑X.toPresheafedSpace⦄, a ∈ ↑(Scheme.basicOpen X f) → a ∈ ↑U)).op) x)
[PROOFSTEP]
simp only [← comp_apply, ← Functor.map_comp]
[GOAL]
case h.e'_2
X✝ Y : Scheme
f✝ : X✝ ⟶ Y
Z X : Scheme
U : Opens ↑↑X.toPresheafedSpace
hU : IsCompact U.carrier
x f : ↑(X.presheaf.obj (op U))
H : ↑(X.presheaf.map (homOfLE (_ : ∀ ⦃a : ↑↑X.toPresheafedSpace⦄, a ∈ ↑(Scheme.basicOpen X f) → a ∈ ↑U)).op) x = 0
s : Set ↑(Scheme.affineOpens X)
hs : Set.Finite s
e : U = ⨆ (i : ↑s), ↑↑i
h₁ : ∀ (i : ↑s), ↑↑i ≤ U
i : ↑s
⊢ ↑(X.presheaf.map
          ((homOfLE (_ : ↑↑i ≤ U)).op ≫
            (homOfLE
                (_ :
                  ∀ ⦃a : ↑↑X.toPresheafedSpace⦄,
                    a ∈ ↑(Scheme.basicOpen X (↑(X.presheaf.map (homOfLE (_ : ↑↑i ≤ U)).op) f)) → a ∈ ↑↑↑i)).op))
      x =
    ↑(X.presheaf.map
          ((homOfLE (_ : ∀ ⦃a : ↑↑X.toPresheafedSpace⦄, a ∈ ↑(Scheme.basicOpen X f) → a ∈ ↑U)).op ≫
            (homOfLE ?intro.intro.refine_1.convert_1).op))
      x
[PROOFSTEP]
rfl
[GOAL]
case h.e'_3
X✝ Y : Scheme
f✝ : X✝ ⟶ Y
Z X : Scheme
U : Opens ↑↑X.toPresheafedSpace
hU : IsCompact U.carrier
x f : ↑(X.presheaf.obj (op U))
H : ↑(X.presheaf.map (homOfLE (_ : ∀ ⦃a : ↑↑X.toPresheafedSpace⦄, a ∈ ↑(Scheme.basicOpen X f) → a ∈ ↑U)).op) x = 0
s : Set ↑(Scheme.affineOpens X)
hs : Set.Finite s
e : U = ⨆ (i : ↑s), ↑↑i
h₁ : ∀ (i : ↑s), ↑↑i ≤ U
i : ↑s
⊢ 0 = ↑(X.presheaf.map (homOfLE ?intro.intro.refine_1.convert_1).op) 0
[PROOFSTEP]
rw [map_zero]
[GOAL]
case intro.intro.refine_1.convert_1
X✝ Y : Scheme
f✝ : X✝ ⟶ Y
Z X : Scheme
U : Opens ↑↑X.toPresheafedSpace
hU : IsCompact U.carrier
x f : ↑(X.presheaf.obj (op U))
H : ↑(X.presheaf.map (homOfLE (_ : ∀ ⦃a : ↑↑X.toPresheafedSpace⦄, a ∈ ↑(Scheme.basicOpen X f) → a ∈ ↑U)).op) x = 0
s : Set ↑(Scheme.affineOpens X)
hs : Set.Finite s
e : U = ⨆ (i : ↑s), ↑↑i
h₁ : ∀ (i : ↑s), ↑↑i ≤ U
i : ↑s
⊢ Scheme.basicOpen X (↑(X.presheaf.map (homOfLE (_ : ↑↑i ≤ U)).op) f) ≤ Scheme.basicOpen X f
[PROOFSTEP]
simp only [Scheme.basicOpen_res, ge_iff_le, inf_le_right]
[GOAL]
case intro.intro.refine_2
X✝ Y : Scheme
f✝ : X✝ ⟶ Y
Z X : Scheme
U : Opens ↑↑X.toPresheafedSpace
hU : IsCompact U.carrier
x f : ↑(X.presheaf.obj (op U))
H : x |_ Scheme.basicOpen X f = 0
s : Set ↑(Scheme.affineOpens X)
hs : Set.Finite s
e : U = ⨆ (i : ↑s), ↑↑i
h₁ : ∀ (i : ↑s), ↑↑i ≤ U
H' :
  ∀ (i : ↑s),
    ∃ n, ↑(X.presheaf.map (homOfLE (_ : ↑↑i ≤ U)).op) f ^ n * ↑(X.presheaf.map (homOfLE (_ : ↑↑i ≤ U)).op) x = 0
⊢ ∃ n, f ^ n * x = 0
[PROOFSTEP]
choose n hn using H'
[GOAL]
case intro.intro.refine_2
X✝ Y : Scheme
f✝ : X✝ ⟶ Y
Z X : Scheme
U : Opens ↑↑X.toPresheafedSpace
hU : IsCompact U.carrier
x f : ↑(X.presheaf.obj (op U))
H : x |_ Scheme.basicOpen X f = 0
s : Set ↑(Scheme.affineOpens X)
hs : Set.Finite s
e : U = ⨆ (i : ↑s), ↑↑i
h₁ : ∀ (i : ↑s), ↑↑i ≤ U
n : ↑s → ℕ
hn :
  ∀ (i : ↑s), ↑(X.presheaf.map (homOfLE (_ : ↑↑i ≤ U)).op) f ^ n i * ↑(X.presheaf.map (homOfLE (_ : ↑↑i ≤ U)).op) x = 0
⊢ ∃ n, f ^ n * x = 0
[PROOFSTEP]
haveI := hs.to_subtype
[GOAL]
case intro.intro.refine_2
X✝ Y : Scheme
f✝ : X✝ ⟶ Y
Z X : Scheme
U : Opens ↑↑X.toPresheafedSpace
hU : IsCompact U.carrier
x f : ↑(X.presheaf.obj (op U))
H : x |_ Scheme.basicOpen X f = 0
s : Set ↑(Scheme.affineOpens X)
hs : Set.Finite s
e : U = ⨆ (i : ↑s), ↑↑i
h₁ : ∀ (i : ↑s), ↑↑i ≤ U
n : ↑s → ℕ
hn :
  ∀ (i : ↑s), ↑(X.presheaf.map (homOfLE (_ : ↑↑i ≤ U)).op) f ^ n i * ↑(X.presheaf.map (homOfLE (_ : ↑↑i ≤ U)).op) x = 0
this : Finite ↑s
⊢ ∃ n, f ^ n * x = 0
[PROOFSTEP]
cases nonempty_fintype s
[GOAL]
case intro.intro.refine_2.intro
X✝ Y : Scheme
f✝ : X✝ ⟶ Y
Z X : Scheme
U : Opens ↑↑X.toPresheafedSpace
hU : IsCompact U.carrier
x f : ↑(X.presheaf.obj (op U))
H : x |_ Scheme.basicOpen X f = 0
s : Set ↑(Scheme.affineOpens X)
hs : Set.Finite s
e : U = ⨆ (i : ↑s), ↑↑i
h₁ : ∀ (i : ↑s), ↑↑i ≤ U
n : ↑s → ℕ
hn :
  ∀ (i : ↑s), ↑(X.presheaf.map (homOfLE (_ : ↑↑i ≤ U)).op) f ^ n i * ↑(X.presheaf.map (homOfLE (_ : ↑↑i ≤ U)).op) x = 0
this : Finite ↑s
val✝ : Fintype ↑s
⊢ ∃ n, f ^ n * x = 0
[PROOFSTEP]
use Finset.univ.sup n
[GOAL]
case h
X✝ Y : Scheme
f✝ : X✝ ⟶ Y
Z X : Scheme
U : Opens ↑↑X.toPresheafedSpace
hU : IsCompact U.carrier
x f : ↑(X.presheaf.obj (op U))
H : x |_ Scheme.basicOpen X f = 0
s : Set ↑(Scheme.affineOpens X)
hs : Set.Finite s
e : U = ⨆ (i : ↑s), ↑↑i
h₁ : ∀ (i : ↑s), ↑↑i ≤ U
n : ↑s → ℕ
hn :
  ∀ (i : ↑s), ↑(X.presheaf.map (homOfLE (_ : ↑↑i ≤ U)).op) f ^ n i * ↑(X.presheaf.map (homOfLE (_ : ↑↑i ≤ U)).op) x = 0
this : Finite ↑s
val✝ : Fintype ↑s
⊢ f ^ Finset.sup Finset.univ n * x = 0
[PROOFSTEP]
suffices ∀ i : s, X.presheaf.map (homOfLE (h₁ i)).op (f ^ Finset.univ.sup n * x) = 0
  by
  subst e
  apply TopCat.Sheaf.eq_of_locally_eq X.sheaf fun i : s => (i : Opens X.carrier)
  intro i
  rw [map_zero]
  apply this
[GOAL]
X✝ Y : Scheme
f✝ : X✝ ⟶ Y
Z X : Scheme
U : Opens ↑↑X.toPresheafedSpace
hU : IsCompact U.carrier
x f : ↑(X.presheaf.obj (op U))
H : x |_ Scheme.basicOpen X f = 0
s : Set ↑(Scheme.affineOpens X)
hs : Set.Finite s
e : U = ⨆ (i : ↑s), ↑↑i
h₁ : ∀ (i : ↑s), ↑↑i ≤ U
n : ↑s → ℕ
hn :
  ∀ (i : ↑s), ↑(X.presheaf.map (homOfLE (_ : ↑↑i ≤ U)).op) f ^ n i * ↑(X.presheaf.map (homOfLE (_ : ↑↑i ≤ U)).op) x = 0
this✝ : Finite ↑s
val✝ : Fintype ↑s
this : ∀ (i : ↑s), ↑(X.presheaf.map (homOfLE (_ : ↑↑i ≤ U)).op) (f ^ Finset.sup Finset.univ n * x) = 0
⊢ f ^ Finset.sup Finset.univ n * x = 0
[PROOFSTEP]
subst e
[GOAL]
X✝ Y : Scheme
f✝ : X✝ ⟶ Y
Z X : Scheme
s : Set ↑(Scheme.affineOpens X)
hs : Set.Finite s
n : ↑s → ℕ
this✝ : Finite ↑s
val✝ : Fintype ↑s
hU : IsCompact (⨆ (i : ↑s), ↑↑i).carrier
x f : ↑(X.presheaf.obj (op (⨆ (i : ↑s), ↑↑i)))
H : x |_ Scheme.basicOpen X f = 0
h₁ : ∀ (i : ↑s), ↑↑i ≤ ⨆ (i : ↑s), ↑↑i
hn :
  ∀ (i : ↑s),
    ↑(X.presheaf.map (homOfLE (_ : ↑↑i ≤ ⨆ (i : ↑s), ↑↑i)).op) f ^ n i *
        ↑(X.presheaf.map (homOfLE (_ : ↑↑i ≤ ⨆ (i : ↑s), ↑↑i)).op) x =
      0
this : ∀ (i : ↑s), ↑(X.presheaf.map (homOfLE (_ : ↑↑i ≤ ⨆ (i : ↑s), ↑↑i)).op) (f ^ Finset.sup Finset.univ n * x) = 0
⊢ f ^ Finset.sup Finset.univ n * x = 0
[PROOFSTEP]
apply TopCat.Sheaf.eq_of_locally_eq X.sheaf fun i : s => (i : Opens X.carrier)
[GOAL]
case h
X✝ Y : Scheme
f✝ : X✝ ⟶ Y
Z X : Scheme
s : Set ↑(Scheme.affineOpens X)
hs : Set.Finite s
n : ↑s → ℕ
this✝ : Finite ↑s
val✝ : Fintype ↑s
hU : IsCompact (⨆ (i : ↑s), ↑↑i).carrier
x f : ↑(X.presheaf.obj (op (⨆ (i : ↑s), ↑↑i)))
H : x |_ Scheme.basicOpen X f = 0
h₁ : ∀ (i : ↑s), ↑↑i ≤ ⨆ (i : ↑s), ↑↑i
hn :
  ∀ (i : ↑s),
    ↑(X.presheaf.map (homOfLE (_ : ↑↑i ≤ ⨆ (i : ↑s), ↑↑i)).op) f ^ n i *
        ↑(X.presheaf.map (homOfLE (_ : ↑↑i ≤ ⨆ (i : ↑s), ↑↑i)).op) x =
      0
this : ∀ (i : ↑s), ↑(X.presheaf.map (homOfLE (_ : ↑↑i ≤ ⨆ (i : ↑s), ↑↑i)).op) (f ^ Finset.sup Finset.univ n * x) = 0
⊢ ∀ (i : ↑s),
    ↑((Scheme.sheaf X).val.map (Opens.leSupr (fun i => ↑↑i) i).op) (f ^ Finset.sup Finset.univ n * x) =
      ↑((Scheme.sheaf X).val.map (Opens.leSupr (fun i => ↑↑i) i).op) 0
[PROOFSTEP]
intro i
[GOAL]
case h
X✝ Y : Scheme
f✝ : X✝ ⟶ Y
Z X : Scheme
s : Set ↑(Scheme.affineOpens X)
hs : Set.Finite s
n : ↑s → ℕ
this✝ : Finite ↑s
val✝ : Fintype ↑s
hU : IsCompact (⨆ (i : ↑s), ↑↑i).carrier
x f : ↑(X.presheaf.obj (op (⨆ (i : ↑s), ↑↑i)))
H : x |_ Scheme.basicOpen X f = 0
h₁ : ∀ (i : ↑s), ↑↑i ≤ ⨆ (i : ↑s), ↑↑i
hn :
  ∀ (i : ↑s),
    ↑(X.presheaf.map (homOfLE (_ : ↑↑i ≤ ⨆ (i : ↑s), ↑↑i)).op) f ^ n i *
        ↑(X.presheaf.map (homOfLE (_ : ↑↑i ≤ ⨆ (i : ↑s), ↑↑i)).op) x =
      0
this : ∀ (i : ↑s), ↑(X.presheaf.map (homOfLE (_ : ↑↑i ≤ ⨆ (i : ↑s), ↑↑i)).op) (f ^ Finset.sup Finset.univ n * x) = 0
i : ↑s
⊢ ↑((Scheme.sheaf X).val.map (Opens.leSupr (fun i => ↑↑i) i).op) (f ^ Finset.sup Finset.univ n * x) =
    ↑((Scheme.sheaf X).val.map (Opens.leSupr (fun i => ↑↑i) i).op) 0
[PROOFSTEP]
rw [map_zero]
[GOAL]
case h
X✝ Y : Scheme
f✝ : X✝ ⟶ Y
Z X : Scheme
s : Set ↑(Scheme.affineOpens X)
hs : Set.Finite s
n : ↑s → ℕ
this✝ : Finite ↑s
val✝ : Fintype ↑s
hU : IsCompact (⨆ (i : ↑s), ↑↑i).carrier
x f : ↑(X.presheaf.obj (op (⨆ (i : ↑s), ↑↑i)))
H : x |_ Scheme.basicOpen X f = 0
h₁ : ∀ (i : ↑s), ↑↑i ≤ ⨆ (i : ↑s), ↑↑i
hn :
  ∀ (i : ↑s),
    ↑(X.presheaf.map (homOfLE (_ : ↑↑i ≤ ⨆ (i : ↑s), ↑↑i)).op) f ^ n i *
        ↑(X.presheaf.map (homOfLE (_ : ↑↑i ≤ ⨆ (i : ↑s), ↑↑i)).op) x =
      0
this : ∀ (i : ↑s), ↑(X.presheaf.map (homOfLE (_ : ↑↑i ≤ ⨆ (i : ↑s), ↑↑i)).op) (f ^ Finset.sup Finset.univ n * x) = 0
i : ↑s
⊢ ↑((Scheme.sheaf X).val.map (Opens.leSupr (fun i => ↑↑i) i).op) (f ^ Finset.sup Finset.univ n * x) = 0
[PROOFSTEP]
apply this
[GOAL]
case h
X✝ Y : Scheme
f✝ : X✝ ⟶ Y
Z X : Scheme
U : Opens ↑↑X.toPresheafedSpace
hU : IsCompact U.carrier
x f : ↑(X.presheaf.obj (op U))
H : x |_ Scheme.basicOpen X f = 0
s : Set ↑(Scheme.affineOpens X)
hs : Set.Finite s
e : U = ⨆ (i : ↑s), ↑↑i
h₁ : ∀ (i : ↑s), ↑↑i ≤ U
n : ↑s → ℕ
hn :
  ∀ (i : ↑s), ↑(X.presheaf.map (homOfLE (_ : ↑↑i ≤ U)).op) f ^ n i * ↑(X.presheaf.map (homOfLE (_ : ↑↑i ≤ U)).op) x = 0
this : Finite ↑s
val✝ : Fintype ↑s
⊢ ∀ (i : ↑s), ↑(X.presheaf.map (homOfLE (_ : ↑↑i ≤ U)).op) (f ^ Finset.sup Finset.univ n * x) = 0
[PROOFSTEP]
intro i
[GOAL]
case h
X✝ Y : Scheme
f✝ : X✝ ⟶ Y
Z X : Scheme
U : Opens ↑↑X.toPresheafedSpace
hU : IsCompact U.carrier
x f : ↑(X.presheaf.obj (op U))
H : x |_ Scheme.basicOpen X f = 0
s : Set ↑(Scheme.affineOpens X)
hs : Set.Finite s
e : U = ⨆ (i : ↑s), ↑↑i
h₁ : ∀ (i : ↑s), ↑↑i ≤ U
n : ↑s → ℕ
hn :
  ∀ (i : ↑s), ↑(X.presheaf.map (homOfLE (_ : ↑↑i ≤ U)).op) f ^ n i * ↑(X.presheaf.map (homOfLE (_ : ↑↑i ≤ U)).op) x = 0
this : Finite ↑s
val✝ : Fintype ↑s
i : ↑s
⊢ ↑(X.presheaf.map (homOfLE (_ : ↑↑i ≤ U)).op) (f ^ Finset.sup Finset.univ n * x) = 0
[PROOFSTEP]
replace hn := congr_arg (fun x => X.presheaf.map (homOfLE (h₁ i)).op (f ^ (Finset.univ.sup n - n i)) * x) (hn i)
[GOAL]
case h
X✝ Y : Scheme
f✝ : X✝ ⟶ Y
Z X : Scheme
U : Opens ↑↑X.toPresheafedSpace
hU : IsCompact U.carrier
x f : ↑(X.presheaf.obj (op U))
H : x |_ Scheme.basicOpen X f = 0
s : Set ↑(Scheme.affineOpens X)
hs : Set.Finite s
e : U = ⨆ (i : ↑s), ↑↑i
h₁ : ∀ (i : ↑s), ↑↑i ≤ U
n : ↑s → ℕ
this : Finite ↑s
val✝ : Fintype ↑s
i : ↑s
hn :
  (fun x => ↑(X.presheaf.map (homOfLE (_ : ↑↑i ≤ U)).op) (f ^ (Finset.sup Finset.univ n - n i)) * x)
      (↑(X.presheaf.map (homOfLE (_ : ↑↑i ≤ U)).op) f ^ n i * ↑(X.presheaf.map (homOfLE (_ : ↑↑i ≤ U)).op) x) =
    (fun x => ↑(X.presheaf.map (homOfLE (_ : ↑↑i ≤ U)).op) (f ^ (Finset.sup Finset.univ n - n i)) * x) 0
⊢ ↑(X.presheaf.map (homOfLE (_ : ↑↑i ≤ U)).op) (f ^ Finset.sup Finset.univ n * x) = 0
[PROOFSTEP]
dsimp at hn
[GOAL]
case h
X✝ Y : Scheme
f✝ : X✝ ⟶ Y
Z X : Scheme
U : Opens ↑↑X.toPresheafedSpace
hU : IsCompact U.carrier
x f : ↑(X.presheaf.obj (op U))
H : x |_ Scheme.basicOpen X f = 0
s : Set ↑(Scheme.affineOpens X)
hs : Set.Finite s
e : U = ⨆ (i : ↑s), ↑↑i
h₁ : ∀ (i : ↑s), ↑↑i ≤ U
n : ↑s → ℕ
this : Finite ↑s
val✝ : Fintype ↑s
i : ↑s
hn :
  ↑(X.presheaf.map (homOfLE (_ : ↑↑i ≤ U)).op) (f ^ (Finset.sup Finset.univ n - n i)) *
      (↑(X.presheaf.map (homOfLE (_ : ↑↑i ≤ U)).op) f ^ n i * ↑(X.presheaf.map (homOfLE (_ : ↑↑i ≤ U)).op) x) =
    ↑(X.presheaf.map (homOfLE (_ : ↑↑i ≤ U)).op) (f ^ (Finset.sup Finset.univ n - n i)) * 0
⊢ ↑(X.presheaf.map (homOfLE (_ : ↑↑i ≤ U)).op) (f ^ Finset.sup Finset.univ n * x) = 0
[PROOFSTEP]
simp only [← map_mul, ← map_pow] at hn
[GOAL]
case h
X✝ Y : Scheme
f✝ : X✝ ⟶ Y
Z X : Scheme
U : Opens ↑↑X.toPresheafedSpace
hU : IsCompact U.carrier
x f : ↑(X.presheaf.obj (op U))
H : x |_ Scheme.basicOpen X f = 0
s : Set ↑(Scheme.affineOpens X)
hs : Set.Finite s
e : U = ⨆ (i : ↑s), ↑↑i
h₁ : ∀ (i : ↑s), ↑↑i ≤ U
n : ↑s → ℕ
this : Finite ↑s
val✝ : Fintype ↑s
i : ↑s
hn :
  ↑(X.presheaf.map (homOfLE (_ : ↑↑i ≤ U)).op) (f ^ (Finset.sup Finset.univ n - n i) * (f ^ n i * x)) =
    ↑(X.presheaf.map (homOfLE (_ : ↑↑i ≤ U)).op) (f ^ (Finset.sup Finset.univ n - n i)) * 0
⊢ ↑(X.presheaf.map (homOfLE (_ : ↑↑i ≤ U)).op) (f ^ Finset.sup Finset.univ n * x) = 0
[PROOFSTEP]
rwa [mul_zero, ← mul_assoc, ← pow_add, tsub_add_cancel_of_le] at hn
[GOAL]
case h
X✝ Y : Scheme
f✝ : X✝ ⟶ Y
Z X : Scheme
U : Opens ↑↑X.toPresheafedSpace
hU : IsCompact U.carrier
x f : ↑(X.presheaf.obj (op U))
H : x |_ Scheme.basicOpen X f = 0
s : Set ↑(Scheme.affineOpens X)
hs : Set.Finite s
e : U = ⨆ (i : ↑s), ↑↑i
h₁ : ∀ (i : ↑s), ↑↑i ≤ U
n : ↑s → ℕ
this : Finite ↑s
val✝ : Fintype ↑s
i : ↑s
hn : ↑(X.presheaf.map (homOfLE (_ : ↑↑i ≤ U)).op) (f ^ (Finset.sup Finset.univ n - n i + n i) * x) = 0
⊢ n i ≤ Finset.sup Finset.univ n
[PROOFSTEP]
apply Finset.le_sup (Finset.mem_univ i)


[GOAL]
ι : Type uι
R : Type uR
A : Type uA
M₁ : Type uM₁
M₂ : Type uM₂
inst✝¹⁰ : CommSemiring R
inst✝⁹ : CommSemiring A
inst✝⁸ : AddCommMonoid M₁
inst✝⁷ : AddCommMonoid M₂
inst✝⁶ : Algebra R A
inst✝⁵ : Module R M₁
inst✝⁴ : Module A M₁
inst✝³ : SMulCommClass R A M₁
inst✝² : SMulCommClass A R M₁
inst✝¹ : IsScalarTower R A M₁
inst✝ : Module R M₂
B₁ : BilinForm A M₁
B₂ : BilinForm R M₂
hB₁ : IsSymm B₁
hB₂ : IsSymm B₂
⊢ IsSymm (BilinForm.tmul B₁ B₂)
[PROOFSTEP]
rw [isSymm_iff_flip R]
[GOAL]
ι : Type uι
R : Type uR
A : Type uA
M₁ : Type uM₁
M₂ : Type uM₂
inst✝¹⁰ : CommSemiring R
inst✝⁹ : CommSemiring A
inst✝⁸ : AddCommMonoid M₁
inst✝⁷ : AddCommMonoid M₂
inst✝⁶ : Algebra R A
inst✝⁵ : Module R M₁
inst✝⁴ : Module A M₁
inst✝³ : SMulCommClass R A M₁
inst✝² : SMulCommClass A R M₁
inst✝¹ : IsScalarTower R A M₁
inst✝ : Module R M₂
B₁ : BilinForm A M₁
B₂ : BilinForm R M₂
hB₁ : IsSymm B₁
hB₂ : IsSymm B₂
⊢ ↑(flipHom R) (BilinForm.tmul B₁ B₂) = BilinForm.tmul B₁ B₂
[PROOFSTEP]
apply toLin.injective
[GOAL]
case a
ι : Type uι
R : Type uR
A : Type uA
M₁ : Type uM₁
M₂ : Type uM₂
inst✝¹⁰ : CommSemiring R
inst✝⁹ : CommSemiring A
inst✝⁸ : AddCommMonoid M₁
inst✝⁷ : AddCommMonoid M₂
inst✝⁶ : Algebra R A
inst✝⁵ : Module R M₁
inst✝⁴ : Module A M₁
inst✝³ : SMulCommClass R A M₁
inst✝² : SMulCommClass A R M₁
inst✝¹ : IsScalarTower R A M₁
inst✝ : Module R M₂
B₁ : BilinForm A M₁
B₂ : BilinForm R M₂
hB₁ : IsSymm B₁
hB₂ : IsSymm B₂
⊢ ↑toLin (↑(flipHom R) (BilinForm.tmul B₁ B₂)) = ↑toLin (BilinForm.tmul B₁ B₂)
[PROOFSTEP]
ext x₁ x₂ y₁ y₂
[GOAL]
case a.a.h.h.a.h.h
ι : Type uι
R : Type uR
A : Type uA
M₁ : Type uM₁
M₂ : Type uM₂
inst✝¹⁰ : CommSemiring R
inst✝⁹ : CommSemiring A
inst✝⁸ : AddCommMonoid M₁
inst✝⁷ : AddCommMonoid M₂
inst✝⁶ : Algebra R A
inst✝⁵ : Module R M₁
inst✝⁴ : Module A M₁
inst✝³ : SMulCommClass R A M₁
inst✝² : SMulCommClass A R M₁
inst✝¹ : IsScalarTower R A M₁
inst✝ : Module R M₂
B₁ : BilinForm A M₁
B₂ : BilinForm R M₂
hB₁ : IsSymm B₁
hB₂ : IsSymm B₂
x₁ : M₁
x₂ : M₂
y₁ : M₁
y₂ : M₂
⊢ ↑(↑(AlgebraTensorModule.curry (↑(↑(AlgebraTensorModule.curry (↑toLin (↑(flipHom R) (BilinForm.tmul B₁ B₂)))) x₁) x₂))
          y₁)
      y₂ =
    ↑(↑(AlgebraTensorModule.curry (↑(↑(AlgebraTensorModule.curry (↑toLin (BilinForm.tmul B₁ B₂))) x₁) x₂)) y₁) y₂
[PROOFSTEP]
exact (congr_arg₂ (HSMul.hSMul) (hB₂ x₂ y₂) (hB₁ x₁ y₁)).symm
[GOAL]
ι : Type uι
R : Type uR
A : Type uA
M₁ : Type uM₁
M₂ : Type uM₂
inst✝⁹ : CommRing R
inst✝⁸ : AddCommGroup M₁
inst✝⁷ : AddCommGroup M₂
inst✝⁶ : Module R M₁
inst✝⁵ : Module R M₂
inst✝⁴ : Module.Free R M₁
inst✝³ : Module.Finite R M₁
inst✝² : Module.Free R M₂
inst✝¹ : Module.Finite R M₂
inst✝ : Nontrivial R
⊢ ↑(tensorDistribEquiv R) = tensorDistrib R R
[PROOFSTEP]
ext B₁ B₂ : 3
[GOAL]
case a.h.h
ι : Type uι
R : Type uR
A : Type uA
M₁ : Type uM₁
M₂ : Type uM₂
inst✝⁹ : CommRing R
inst✝⁸ : AddCommGroup M₁
inst✝⁷ : AddCommGroup M₂
inst✝⁶ : Module R M₁
inst✝⁵ : Module R M₂
inst✝⁴ : Module.Free R M₁
inst✝³ : Module.Finite R M₁
inst✝² : Module.Free R M₂
inst✝¹ : Module.Finite R M₂
inst✝ : Nontrivial R
B₁ : BilinForm R M₁
B₂ : BilinForm R M₂
⊢ ↑(↑(AlgebraTensorModule.curry ↑(tensorDistribEquiv R)) B₁) B₂ =
    ↑(↑(AlgebraTensorModule.curry (tensorDistrib R R)) B₁) B₂
[PROOFSTEP]
apply toLin.injective
[GOAL]
case a.h.h.a
ι : Type uι
R : Type uR
A : Type uA
M₁ : Type uM₁
M₂ : Type uM₂
inst✝⁹ : CommRing R
inst✝⁸ : AddCommGroup M₁
inst✝⁷ : AddCommGroup M₂
inst✝⁶ : Module R M₁
inst✝⁵ : Module R M₂
inst✝⁴ : Module.Free R M₁
inst✝³ : Module.Finite R M₁
inst✝² : Module.Free R M₂
inst✝¹ : Module.Finite R M₂
inst✝ : Nontrivial R
B₁ : BilinForm R M₁
B₂ : BilinForm R M₂
⊢ ↑toLin (↑(↑(AlgebraTensorModule.curry ↑(tensorDistribEquiv R)) B₁) B₂) =
    ↑toLin (↑(↑(AlgebraTensorModule.curry (tensorDistrib R R)) B₁) B₂)
[PROOFSTEP]
ext
[GOAL]
case a.h.h.a.a.h.h.a.h.h
ι : Type uι
R : Type uR
A : Type uA
M₁ : Type uM₁
M₂ : Type uM₂
inst✝⁹ : CommRing R
inst✝⁸ : AddCommGroup M₁
inst✝⁷ : AddCommGroup M₂
inst✝⁶ : Module R M₁
inst✝⁵ : Module R M₂
inst✝⁴ : Module.Free R M₁
inst✝³ : Module.Finite R M₁
inst✝² : Module.Free R M₂
inst✝¹ : Module.Finite R M₂
inst✝ : Nontrivial R
B₁ : BilinForm R M₁
B₂ : BilinForm R M₂
x✝³ : M₁
x✝² : M₂
x✝¹ : M₁
x✝ : M₂
⊢ ↑(↑(AlgebraTensorModule.curry
              (↑(↑(AlgebraTensorModule.curry (↑toLin (↑(↑(AlgebraTensorModule.curry ↑(tensorDistribEquiv R)) B₁) B₂)))
                    x✝³)
                x✝²))
          x✝¹)
      x✝ =
    ↑(↑(AlgebraTensorModule.curry
              (↑(↑(AlgebraTensorModule.curry (↑toLin (↑(↑(AlgebraTensorModule.curry (tensorDistrib R R)) B₁) B₂))) x✝³)
                x✝²))
          x✝¹)
      x✝
[PROOFSTEP]
exact mul_comm _ _