[GOAL]
C : Type u₁
inst✝¹ : Category.{v, u₁} C
C' : Type u₂
inst✝ : Category.{v, u₂} C'
D : GlueData C
i j : D.J
⊢ t' D i i j = (pullbackSymmetry (f D i i) (f D i j)).hom
[PROOFSTEP]
have eq₁ := D.t_fac i i j
[GOAL]
C : Type u₁
inst✝¹ : Category.{v, u₁} C
C' : Type u₂
inst✝ : Category.{v, u₂} C'
D : GlueData C
i j : D.J
eq₁ : t' D i i j ≫ pullback.snd = pullback.fst ≫ t D i i
⊢ t' D i i j = (pullbackSymmetry (f D i i) (f D i j)).hom
[PROOFSTEP]
have eq₂ := (IsIso.eq_comp_inv (D.f i i)).mpr (@pullback.condition _ _ _ _ _ _ (D.f i j) _)
[GOAL]
C : Type u₁
inst✝¹ : Category.{v, u₁} C
C' : Type u₂
inst✝ : Category.{v, u₂} C'
D : GlueData C
i j : D.J
eq₁ : t' D i i j ≫ pullback.snd = pullback.fst ≫ t D i i
eq₂ : pullback.fst = (pullback.snd ≫ f D i j) ≫ inv (f D i i)
⊢ t' D i i j = (pullbackSymmetry (f D i i) (f D i j)).hom
[PROOFSTEP]
rw [D.t_id, Category.comp_id, eq₂] at eq₁
[GOAL]
C : Type u₁
inst✝¹ : Category.{v, u₁} C
C' : Type u₂
inst✝ : Category.{v, u₂} C'
D : GlueData C
i j : D.J
eq₁ : t' D i i j ≫ pullback.snd = (pullback.snd ≫ f D i j) ≫ inv (f D i i)
eq₂ : pullback.fst = (pullback.snd ≫ f D i j) ≫ inv (f D i i)
⊢ t' D i i j = (pullbackSymmetry (f D i i) (f D i j)).hom
[PROOFSTEP]
have eq₃ := (IsIso.eq_comp_inv (D.f i i)).mp eq₁
[GOAL]
C : Type u₁
inst✝¹ : Category.{v, u₁} C
C' : Type u₂
inst✝ : Category.{v, u₂} C'
D : GlueData C
i j : D.J
eq₁ : t' D i i j ≫ pullback.snd = (pullback.snd ≫ f D i j) ≫ inv (f D i i)
eq₂ : pullback.fst = (pullback.snd ≫ f D i j) ≫ inv (f D i i)
eq₃ : (t' D i i j ≫ pullback.snd) ≫ f D i i = pullback.snd ≫ f D i j
⊢ t' D i i j = (pullbackSymmetry (f D i i) (f D i j)).hom
[PROOFSTEP]
rw [Category.assoc, ← pullback.condition, ← Category.assoc] at eq₃
[GOAL]
C : Type u₁
inst✝¹ : Category.{v, u₁} C
C' : Type u₂
inst✝ : Category.{v, u₂} C'
D : GlueData C
i j : D.J
eq₁ : t' D i i j ≫ pullback.snd = (pullback.snd ≫ f D i j) ≫ inv (f D i i)
eq₂ : pullback.fst = (pullback.snd ≫ f D i j) ≫ inv (f D i i)
eq₃ : (t' D i i j ≫ pullback.fst) ≫ f D i j = pullback.snd ≫ f D i j
⊢ t' D i i j = (pullbackSymmetry (f D i i) (f D i j)).hom
[PROOFSTEP]
exact Mono.right_cancellation _ _ ((Mono.right_cancellation _ _ eq₃).trans (pullbackSymmetry_hom_comp_fst _ _).symm)
[GOAL]
C : Type u₁
inst✝¹ : Category.{v, u₁} C
C' : Type u₂
inst✝ : Category.{v, u₂} C'
D : GlueData C
i j : D.J
⊢ t' D j i i = pullback.fst ≫ t D j i ≫ inv pullback.snd
[PROOFSTEP]
rw [← Category.assoc, ← D.t_fac]
[GOAL]
C : Type u₁
inst✝¹ : Category.{v, u₁} C
C' : Type u₂
inst✝ : Category.{v, u₂} C'
D : GlueData C
i j : D.J
⊢ t' D j i i = (t' D j i i ≫ pullback.snd) ≫ inv pullback.snd
[PROOFSTEP]
simp
[GOAL]
C : Type u₁
inst✝¹ : Category.{v, u₁} C
C' : Type u₂
inst✝ : Category.{v, u₂} C'
D : GlueData C
i j : D.J
⊢ t' D i j i = pullback.fst ≫ t D i j ≫ inv pullback.snd
[PROOFSTEP]
rw [← Category.assoc, ← D.t_fac]
[GOAL]
C : Type u₁
inst✝¹ : Category.{v, u₁} C
C' : Type u₂
inst✝ : Category.{v, u₂} C'
D : GlueData C
i j : D.J
⊢ t' D i j i = (t' D i j i ≫ pullback.snd) ≫ inv pullback.snd
[PROOFSTEP]
simp
[GOAL]
C : Type u₁
inst✝¹ : Category.{v, u₁} C
C' : Type u₂
inst✝ : Category.{v, u₂} C'
D : GlueData C
i j : D.J
⊢ t D i j ≫ t D j i = 𝟙 (V D (i, j))
[PROOFSTEP]
have eq : (pullbackSymmetry (D.f i i) (D.f i j)).hom = pullback.snd ≫ inv pullback.fst := by simp
[GOAL]
C : Type u₁
inst✝¹ : Category.{v, u₁} C
C' : Type u₂
inst✝ : Category.{v, u₂} C'
D : GlueData C
i j : D.J
⊢ (pullbackSymmetry (f D i i) (f D i j)).hom = pullback.snd ≫ inv pullback.fst
[PROOFSTEP]
simp
[GOAL]
C : Type u₁
inst✝¹ : Category.{v, u₁} C
C' : Type u₂
inst✝ : Category.{v, u₂} C'
D : GlueData C
i j : D.J
eq : (pullbackSymmetry (f D i i) (f D i j)).hom = pullback.snd ≫ inv pullback.fst
⊢ t D i j ≫ t D j i = 𝟙 (V D (i, j))
[PROOFSTEP]
have := D.cocycle i j i
[GOAL]
C : Type u₁
inst✝¹ : Category.{v, u₁} C
C' : Type u₂
inst✝ : Category.{v, u₂} C'
D : GlueData C
i j : D.J
eq : (pullbackSymmetry (f D i i) (f D i j)).hom = pullback.snd ≫ inv pullback.fst
this : t' D i j i ≫ t' D j i i ≫ t' D i i j = 𝟙 (pullback (f D i j) (f D i i))
⊢ t D i j ≫ t D j i = 𝟙 (V D (i, j))
[PROOFSTEP]
rw [D.t'_iij, D.t'_jii, D.t'_iji, fst_eq_snd_of_mono_eq, eq] at this
[GOAL]
C : Type u₁
inst✝¹ : Category.{v, u₁} C
C' : Type u₂
inst✝ : Category.{v, u₂} C'
D : GlueData C
i j : D.J
eq : (pullbackSymmetry (f D i i) (f D i j)).hom = pullback.snd ≫ inv pullback.fst
this :
  (pullback.fst ≫ t D i j ≫ inv pullback.snd) ≫
      (pullback.snd ≫ t D j i ≫ inv pullback.snd) ≫ pullback.snd ≫ inv pullback.fst =
    𝟙 (pullback (f D i j) (f D i i))
⊢ t D i j ≫ t D j i = 𝟙 (V D (i, j))
[PROOFSTEP]
simp only [Category.assoc, IsIso.inv_hom_id_assoc] at this
[GOAL]
C : Type u₁
inst✝¹ : Category.{v, u₁} C
C' : Type u₂
inst✝ : Category.{v, u₂} C'
D : GlueData C
i j : D.J
eq : (pullbackSymmetry (f D i i) (f D i j)).hom = pullback.snd ≫ inv pullback.fst
this : pullback.fst ≫ t D i j ≫ t D j i ≫ inv pullback.fst = 𝟙 (pullback (f D i j) (f D i i))
⊢ t D i j ≫ t D j i = 𝟙 (V D (i, j))
[PROOFSTEP]
rw [← IsIso.eq_inv_comp, ← Category.assoc, IsIso.comp_inv_eq] at this
[GOAL]
C : Type u₁
inst✝¹ : Category.{v, u₁} C
C' : Type u₂
inst✝ : Category.{v, u₂} C'
D : GlueData C
i j : D.J
eq : (pullbackSymmetry (f D i i) (f D i j)).hom = pullback.snd ≫ inv pullback.fst
this : t D i j ≫ t D j i = (inv pullback.fst ≫ 𝟙 (pullback (f D i j) (f D i i))) ≫ pullback.fst
⊢ t D i j ≫ t D j i = 𝟙 (V D (i, j))
[PROOFSTEP]
simpa using this
[GOAL]
C : Type u₁
inst✝¹ : Category.{v, u₁} C
C' : Type u₂
inst✝ : Category.{v, u₂} C'
D : GlueData C
i j k : D.J
⊢ t' D i j k ≫ (pullbackSymmetry (f D j k) (f D j i)).hom ≫ t' D j i k ≫ (pullbackSymmetry (f D i k) (f D i j)).hom =
    𝟙 (pullback (f D i j) (f D i k))
[PROOFSTEP]
rw [← cancel_mono (pullback.fst : pullback (D.f i j) (D.f i k) ⟶ _)]
[GOAL]
C : Type u₁
inst✝¹ : Category.{v, u₁} C
C' : Type u₂
inst✝ : Category.{v, u₂} C'
D : GlueData C
i j k : D.J
⊢ (t' D i j k ≫ (pullbackSymmetry (f D j k) (f D j i)).hom ≫ t' D j i k ≫ (pullbackSymmetry (f D i k) (f D i j)).hom) ≫
      pullback.fst =
    𝟙 (pullback (f D i j) (f D i k)) ≫ pullback.fst
[PROOFSTEP]
simp [t_fac, t_fac_assoc]
[GOAL]
C : Type u₁
inst✝¹ : Category.{v, u₁} C
C' : Type u₂
inst✝ : Category.{v, u₂} C'
D : GlueData C
i j k : D.J
⊢ (t' D j k i ≫ t' D k i j) ≫ t' D i j k = 𝟙 (pullback (f D j k) (f D j i))
[PROOFSTEP]
simpa using D.cocycle _ _ _
[GOAL]
C : Type u₁
inst✝¹ : Category.{v, u₁} C
C' : Type u₂
inst✝ : Category.{v, u₂} C'
D : GlueData C
i j k : D.J
⊢ t' D j k i ≫ t' D k i j =
    (pullbackSymmetry (f D j k) (f D j i)).hom ≫ t' D j i k ≫ (pullbackSymmetry (f D i k) (f D i j)).hom
[PROOFSTEP]
trans inv (D.t' i j k)
[GOAL]
C : Type u₁
inst✝¹ : Category.{v, u₁} C
C' : Type u₂
inst✝ : Category.{v, u₂} C'
D : GlueData C
i j k : D.J
⊢ t' D j k i ≫ t' D k i j = inv (t' D i j k)
[PROOFSTEP]
exact IsIso.eq_inv_of_hom_inv_id (D.cocycle _ _ _)
[GOAL]
C : Type u₁
inst✝¹ : Category.{v, u₁} C
C' : Type u₂
inst✝ : Category.{v, u₂} C'
D : GlueData C
i j k : D.J
⊢ inv (t' D i j k) =
    (pullbackSymmetry (f D j k) (f D j i)).hom ≫ t' D j i k ≫ (pullbackSymmetry (f D i k) (f D i j)).hom
[PROOFSTEP]
rw [← cancel_mono (pullback.fst : pullback (D.f i j) (D.f i k) ⟶ _)]
[GOAL]
C : Type u₁
inst✝¹ : Category.{v, u₁} C
C' : Type u₂
inst✝ : Category.{v, u₂} C'
D : GlueData C
i j k : D.J
⊢ inv (t' D i j k) ≫ pullback.fst =
    ((pullbackSymmetry (f D j k) (f D j i)).hom ≫ t' D j i k ≫ (pullbackSymmetry (f D i k) (f D i j)).hom) ≫
      pullback.fst
[PROOFSTEP]
simp [t_fac, t_fac_assoc]
[GOAL]
C : Type u₁
inst✝² : Category.{v, u₁} C
C' : Type u₂
inst✝¹ : Category.{v, u₂} C'
D : GlueData C
inst✝ : HasMulticoequalizer (diagram D)
i j : D.J
⊢ f D i j ≫ ι D i = (t D i j ≫ f D j i) ≫ ι D j
[PROOFSTEP]
simp
[GOAL]
C : Type u₁
inst✝³ : Category.{v, u₁} C
C' : Type u₂
inst✝² : Category.{v, u₂} C'
D : GlueData C
inst✝¹ : HasMulticoequalizer (diagram D)
inst✝ : HasColimits C
⊢ Epi (π D)
[PROOFSTEP]
unfold π
[GOAL]
C : Type u₁
inst✝³ : Category.{v, u₁} C
C' : Type u₂
inst✝² : Category.{v, u₂} C'
D : GlueData C
inst✝¹ : HasMulticoequalizer (diagram D)
inst✝ : HasColimits C
⊢ Epi (Multicoequalizer.sigmaπ (diagram D))
[PROOFSTEP]
infer_instance
[GOAL]
C : Type u₁
inst✝¹ : Category.{v, u₁} C
C' : Type u₂
inst✝ : Category.{v, u₂} C'
D✝ : GlueData C
D : GlueData (Type u_1)
x : glued D
⊢ ∃ i y, ι D i y = x
[PROOFSTEP]
delta CategoryTheory.GlueData.ι
[GOAL]
C : Type u₁
inst✝¹ : Category.{v, u₁} C
C' : Type u₂
inst✝ : Category.{v, u₂} C'
D✝ : GlueData C
D : GlueData (Type u_1)
x : glued D
⊢ ∃ i y, Multicoequalizer.π (diagram D) i y = x
[PROOFSTEP]
simp_rw [← Multicoequalizer.ι_sigmaπ D.diagram]
[GOAL]
C : Type u₁
inst✝¹ : Category.{v, u₁} C
C' : Type u₂
inst✝ : Category.{v, u₂} C'
D✝ : GlueData C
D : GlueData (Type u_1)
x : glued D
⊢ ∃ i y, (Sigma.ι (diagram D).right i ≫ Multicoequalizer.sigmaπ (diagram D)) y = x
[PROOFSTEP]
rcases D.types_π_surjective x with
  ⟨x', rfl⟩
    --have := colimit.isoColimitCocone (Types.coproductColimitCocone _)
[GOAL]
case intro
C : Type u₁
inst✝¹ : Category.{v, u₁} C
C' : Type u₂
inst✝ : Category.{v, u₂} C'
D✝ : GlueData C
D : GlueData (Type u_1)
x' : sigmaOpens D
⊢ ∃ i y, (Sigma.ι (diagram D).right i ≫ Multicoequalizer.sigmaπ (diagram D)) y = π D x'
[PROOFSTEP]
rw [←
  show (colimit.isoColimitCocone (Types.coproductColimitCocone _)).inv _ = x' from
    ConcreteCategory.congr_hom (colimit.isoColimitCocone (Types.coproductColimitCocone _)).hom_inv_id x']
[GOAL]
case intro
C : Type u₁
inst✝¹ : Category.{v, u₁} C
C' : Type u₂
inst✝ : Category.{v, u₂} C'
D✝ : GlueData C
D : GlueData (Type u_1)
x' : sigmaOpens D
⊢ ∃ i y,
    (Sigma.ι (diagram D).right i ≫ Multicoequalizer.sigmaπ (diagram D)) y =
      π D
        ((colimit.isoColimitCocone (Types.coproductColimitCocone D.U)).inv
          ((colimit.isoColimitCocone (Types.coproductColimitCocone D.U)).hom x'))
[PROOFSTEP]
rcases(colimit.isoColimitCocone (Types.coproductColimitCocone _)).hom x' with ⟨i, y⟩
[GOAL]
case intro.mk
C : Type u₁
inst✝¹ : Category.{v, u₁} C
C' : Type u₂
inst✝ : Category.{v, u₂} C'
D✝ : GlueData C
D : GlueData (Type u_1)
x' : sigmaOpens D
i : D.J
y : U D i
⊢ ∃ i_1 y_1,
    (Sigma.ι (diagram D).right i_1 ≫ Multicoequalizer.sigmaπ (diagram D)) y_1 =
      π D ((colimit.isoColimitCocone (Types.coproductColimitCocone D.U)).inv { fst := i, snd := y })
[PROOFSTEP]
exact
  ⟨i, y, by
    simp [← Multicoequalizer.ι_sigmaπ, -Multicoequalizer.ι_sigmaπ]
    rfl⟩
[GOAL]
C : Type u₁
inst✝¹ : Category.{v, u₁} C
C' : Type u₂
inst✝ : Category.{v, u₂} C'
D✝ : GlueData C
D : GlueData (Type u_1)
x' : sigmaOpens D
i : D.J
y : U D i
⊢ (Sigma.ι (diagram D).right i ≫ Multicoequalizer.sigmaπ (diagram D)) y =
    π D ((colimit.isoColimitCocone (Types.coproductColimitCocone D.U)).inv { fst := i, snd := y })
[PROOFSTEP]
simp [← Multicoequalizer.ι_sigmaπ, -Multicoequalizer.ι_sigmaπ]
[GOAL]
C : Type u₁
inst✝¹ : Category.{v, u₁} C
C' : Type u₂
inst✝ : Category.{v, u₂} C'
D✝ : GlueData C
D : GlueData (Type u_1)
x' : sigmaOpens D
i : D.J
y : U D i
⊢ Multicoequalizer.sigmaπ (diagram D) (Sigma.ι D.U i y) =
    π D ((colimit.isoColimitCocone (Types.coproductColimitCocone D.U)).inv { fst := i, snd := y })
[PROOFSTEP]
rfl
[GOAL]
C : Type u₁
inst✝¹ : Category.{v, u₁} C
C' : Type u₂
inst✝ : Category.{v, u₂} C'
D : GlueData C
F : C ⥤ C'
H : (i j k : D.J) → PreservesLimit (cospan (f D i j) (f D i k)) F
i : D.J
⊢ (fun i j => F.map (t D i j)) i i = 𝟙 ((fun i => F.obj (V D i)) (i, i))
[PROOFSTEP]
simp [D.t_id i]
[GOAL]
C : Type u₁
inst✝¹ : Category.{v, u₁} C
C' : Type u₂
inst✝ : Category.{v, u₂} C'
D : GlueData C
F : C ⥤ C'
H : (i j k : D.J) → PreservesLimit (cospan (f D i j) (f D i k)) F
i j k : D.J
⊢ (fun i j k =>
          (PreservesPullback.iso F (f D i j) (f D i k)).inv ≫
            F.map (t' D i j k) ≫ (PreservesPullback.iso F (f D j k) (f D j i)).hom)
        i j k ≫
      pullback.snd =
    pullback.fst ≫ (fun i j => F.map (t D i j)) i j
[PROOFSTEP]
simpa [Iso.inv_comp_eq] using congr_arg (fun f => F.map f) (D.t_fac i j k)
[GOAL]
C : Type u₁
inst✝¹ : Category.{v, u₁} C
C' : Type u₂
inst✝ : Category.{v, u₂} C'
D : GlueData C
F : C ⥤ C'
H : (i j k : D.J) → PreservesLimit (cospan (f D i j) (f D i k)) F
i j k : D.J
⊢ (fun i j k =>
          (PreservesPullback.iso F (f D i j) (f D i k)).inv ≫
            F.map (t' D i j k) ≫ (PreservesPullback.iso F (f D j k) (f D j i)).hom)
        i j k ≫
      (fun i j k =>
            (PreservesPullback.iso F (f D i j) (f D i k)).inv ≫
              F.map (t' D i j k) ≫ (PreservesPullback.iso F (f D j k) (f D j i)).hom)
          j k i ≫
        (fun i j k =>
            (PreservesPullback.iso F (f D i j) (f D i k)).inv ≫
              F.map (t' D i j k) ≫ (PreservesPullback.iso F (f D j k) (f D j i)).hom)
          k i j =
    𝟙 (pullback ((fun i j => F.map (f D i j)) i j) ((fun i j => F.map (f D i j)) i k))
[PROOFSTEP]
simp only [Category.assoc, Iso.hom_inv_id_assoc, ← Functor.map_comp_assoc, D.cocycle, Iso.inv_hom_id,
  CategoryTheory.Functor.map_id, Category.id_comp]
[GOAL]
C : Type u₁
inst✝¹ : Category.{v, u₁} C
C' : Type u₂
inst✝ : Category.{v, u₂} C'
D : GlueData C
F : C ⥤ C'
H : (i j k : D.J) → PreservesLimit (cospan (f D i j) (f D i k)) F
⊢ ∀ {X Y : WalkingMultispan (diagram D).fstFrom (diagram D).sndFrom} (f : X ⟶ Y),
    (MultispanIndex.multispan (diagram D) ⋙ F).map f ≫
        ((fun x =>
              match x with
              | WalkingMultispan.left a =>
                Iso.refl ((MultispanIndex.multispan (diagram D) ⋙ F).obj (WalkingMultispan.left a))
              | WalkingMultispan.right b =>
                Iso.refl ((MultispanIndex.multispan (diagram D) ⋙ F).obj (WalkingMultispan.right b)))
            Y).hom =
      ((fun x =>
              match x with
              | WalkingMultispan.left a =>
                Iso.refl ((MultispanIndex.multispan (diagram D) ⋙ F).obj (WalkingMultispan.left a))
              | WalkingMultispan.right b =>
                Iso.refl ((MultispanIndex.multispan (diagram D) ⋙ F).obj (WalkingMultispan.right b)))
            X).hom ≫
        (MultispanIndex.multispan (diagram (mapGlueData D F))).map f
[PROOFSTEP]
rintro (⟨_, _⟩ | _) _ (_ | _ | _)
[GOAL]
case left.mk.id
C : Type u₁
inst✝¹ : Category.{v, u₁} C
C' : Type u₂
inst✝ : Category.{v, u₂} C'
D : GlueData C
F : C ⥤ C'
H : (i j k : D.J) → PreservesLimit (cospan (f D i j) (f D i k)) F
fst✝ snd✝ : D.J
⊢ (MultispanIndex.multispan (diagram D) ⋙ F).map (WalkingMultispan.Hom.id (WalkingMultispan.left (fst✝, snd✝))) ≫
      ((fun x =>
            match x with
            | WalkingMultispan.left a =>
              Iso.refl ((MultispanIndex.multispan (diagram D) ⋙ F).obj (WalkingMultispan.left a))
            | WalkingMultispan.right b =>
              Iso.refl ((MultispanIndex.multispan (diagram D) ⋙ F).obj (WalkingMultispan.right b)))
          (WalkingMultispan.left (fst✝, snd✝))).hom =
    ((fun x =>
            match x with
            | WalkingMultispan.left a =>
              Iso.refl ((MultispanIndex.multispan (diagram D) ⋙ F).obj (WalkingMultispan.left a))
            | WalkingMultispan.right b =>
              Iso.refl ((MultispanIndex.multispan (diagram D) ⋙ F).obj (WalkingMultispan.right b)))
          (WalkingMultispan.left (fst✝, snd✝))).hom ≫
      (MultispanIndex.multispan (diagram (mapGlueData D F))).map
        (WalkingMultispan.Hom.id (WalkingMultispan.left (fst✝, snd✝)))
[PROOFSTEP]
erw [Category.comp_id, Category.id_comp, Functor.map_id]
[GOAL]
case left.mk.id
C : Type u₁
inst✝¹ : Category.{v, u₁} C
C' : Type u₂
inst✝ : Category.{v, u₂} C'
D : GlueData C
F : C ⥤ C'
H : (i j k : D.J) → PreservesLimit (cospan (f D i j) (f D i k)) F
fst✝ snd✝ : D.J
⊢ 𝟙 ((MultispanIndex.multispan (diagram D) ⋙ F).obj (WalkingMultispan.left (fst✝, snd✝))) =
    (MultispanIndex.multispan (diagram (mapGlueData D F))).map
      (WalkingMultispan.Hom.id (WalkingMultispan.left (fst✝, snd✝)))
[PROOFSTEP]
rfl
[GOAL]
case left.mk.fst
C : Type u₁
inst✝¹ : Category.{v, u₁} C
C' : Type u₂
inst✝ : Category.{v, u₂} C'
D : GlueData C
F : C ⥤ C'
H : (i j k : D.J) → PreservesLimit (cospan (f D i j) (f D i k)) F
fst✝ snd✝ : D.J
⊢ (MultispanIndex.multispan (diagram D) ⋙ F).map (WalkingMultispan.Hom.fst (fst✝, snd✝)) ≫
      ((fun x =>
            match x with
            | WalkingMultispan.left a =>
              Iso.refl ((MultispanIndex.multispan (diagram D) ⋙ F).obj (WalkingMultispan.left a))
            | WalkingMultispan.right b =>
              Iso.refl ((MultispanIndex.multispan (diagram D) ⋙ F).obj (WalkingMultispan.right b)))
          (WalkingMultispan.right (MultispanIndex.fstFrom (diagram D) (fst✝, snd✝)))).hom =
    ((fun x =>
            match x with
            | WalkingMultispan.left a =>
              Iso.refl ((MultispanIndex.multispan (diagram D) ⋙ F).obj (WalkingMultispan.left a))
            | WalkingMultispan.right b =>
              Iso.refl ((MultispanIndex.multispan (diagram D) ⋙ F).obj (WalkingMultispan.right b)))
          (WalkingMultispan.left (fst✝, snd✝))).hom ≫
      (MultispanIndex.multispan (diagram (mapGlueData D F))).map (WalkingMultispan.Hom.fst (fst✝, snd✝))
[PROOFSTEP]
erw [Category.comp_id, Category.id_comp]
[GOAL]
case left.mk.fst
C : Type u₁
inst✝¹ : Category.{v, u₁} C
C' : Type u₂
inst✝ : Category.{v, u₂} C'
D : GlueData C
F : C ⥤ C'
H : (i j k : D.J) → PreservesLimit (cospan (f D i j) (f D i k)) F
fst✝ snd✝ : D.J
⊢ (MultispanIndex.multispan (diagram D) ⋙ F).map (WalkingMultispan.Hom.fst (fst✝, snd✝)) =
    (MultispanIndex.multispan (diagram (mapGlueData D F))).map (WalkingMultispan.Hom.fst (fst✝, snd✝))
[PROOFSTEP]
rfl
[GOAL]
case left.mk.snd
C : Type u₁
inst✝¹ : Category.{v, u₁} C
C' : Type u₂
inst✝ : Category.{v, u₂} C'
D : GlueData C
F : C ⥤ C'
H : (i j k : D.J) → PreservesLimit (cospan (f D i j) (f D i k)) F
fst✝ snd✝ : D.J
⊢ (MultispanIndex.multispan (diagram D) ⋙ F).map (WalkingMultispan.Hom.snd (fst✝, snd✝)) ≫
      ((fun x =>
            match x with
            | WalkingMultispan.left a =>
              Iso.refl ((MultispanIndex.multispan (diagram D) ⋙ F).obj (WalkingMultispan.left a))
            | WalkingMultispan.right b =>
              Iso.refl ((MultispanIndex.multispan (diagram D) ⋙ F).obj (WalkingMultispan.right b)))
          (WalkingMultispan.right (MultispanIndex.sndFrom (diagram D) (fst✝, snd✝)))).hom =
    ((fun x =>
            match x with
            | WalkingMultispan.left a =>
              Iso.refl ((MultispanIndex.multispan (diagram D) ⋙ F).obj (WalkingMultispan.left a))
            | WalkingMultispan.right b =>
              Iso.refl ((MultispanIndex.multispan (diagram D) ⋙ F).obj (WalkingMultispan.right b)))
          (WalkingMultispan.left (fst✝, snd✝))).hom ≫
      (MultispanIndex.multispan (diagram (mapGlueData D F))).map (WalkingMultispan.Hom.snd (fst✝, snd✝))
[PROOFSTEP]
erw [Category.comp_id, Category.id_comp, Functor.map_comp]
[GOAL]
case left.mk.snd
C : Type u₁
inst✝¹ : Category.{v, u₁} C
C' : Type u₂
inst✝ : Category.{v, u₂} C'
D : GlueData C
F : C ⥤ C'
H : (i j k : D.J) → PreservesLimit (cospan (f D i j) (f D i k)) F
fst✝ snd✝ : D.J
⊢ F.map (t D fst✝ snd✝) ≫ F.map (f D snd✝ fst✝) =
    (MultispanIndex.multispan (diagram (mapGlueData D F))).map (WalkingMultispan.Hom.snd (fst✝, snd✝))
[PROOFSTEP]
rfl
[GOAL]
case right.id
C : Type u₁
inst✝¹ : Category.{v, u₁} C
C' : Type u₂
inst✝ : Category.{v, u₂} C'
D : GlueData C
F : C ⥤ C'
H : (i j k : D.J) → PreservesLimit (cospan (f D i j) (f D i k)) F
a✝ : (diagram D).R
⊢ (MultispanIndex.multispan (diagram D) ⋙ F).map (WalkingMultispan.Hom.id (WalkingMultispan.right a✝)) ≫
      ((fun x =>
            match x with
            | WalkingMultispan.left a =>
              Iso.refl ((MultispanIndex.multispan (diagram D) ⋙ F).obj (WalkingMultispan.left a))
            | WalkingMultispan.right b =>
              Iso.refl ((MultispanIndex.multispan (diagram D) ⋙ F).obj (WalkingMultispan.right b)))
          (WalkingMultispan.right a✝)).hom =
    ((fun x =>
            match x with
            | WalkingMultispan.left a =>
              Iso.refl ((MultispanIndex.multispan (diagram D) ⋙ F).obj (WalkingMultispan.left a))
            | WalkingMultispan.right b =>
              Iso.refl ((MultispanIndex.multispan (diagram D) ⋙ F).obj (WalkingMultispan.right b)))
          (WalkingMultispan.right a✝)).hom ≫
      (MultispanIndex.multispan (diagram (mapGlueData D F))).map (WalkingMultispan.Hom.id (WalkingMultispan.right a✝))
[PROOFSTEP]
erw [Category.comp_id, Category.id_comp, Functor.map_id]
[GOAL]
case right.id
C : Type u₁
inst✝¹ : Category.{v, u₁} C
C' : Type u₂
inst✝ : Category.{v, u₂} C'
D : GlueData C
F : C ⥤ C'
H : (i j k : D.J) → PreservesLimit (cospan (f D i j) (f D i k)) F
a✝ : (diagram D).R
⊢ 𝟙 ((MultispanIndex.multispan (diagram D) ⋙ F).obj (WalkingMultispan.right a✝)) =
    (MultispanIndex.multispan (diagram (mapGlueData D F))).map (WalkingMultispan.Hom.id (WalkingMultispan.right a✝))
[PROOFSTEP]
rfl
[GOAL]
C : Type u₁
inst✝³ : Category.{v, u₁} C
C' : Type u₂
inst✝² : Category.{v, u₂} C'
D : GlueData C
F : C ⥤ C'
H : (i j k : D.J) → PreservesLimit (cospan (f D i j) (f D i k)) F
inst✝¹ : HasMulticoequalizer (diagram D)
inst✝ : PreservesColimit (MultispanIndex.multispan (diagram D)) F
i : D.J
⊢ F.map (ι D i) ≫ (gluedIso D F).hom = ι (mapGlueData D F) i
[PROOFSTEP]
haveI : HasColimit (MultispanIndex.multispan (diagram (mapGlueData D F))) := inferInstance
[GOAL]
C : Type u₁
inst✝³ : Category.{v, u₁} C
C' : Type u₂
inst✝² : Category.{v, u₂} C'
D : GlueData C
F : C ⥤ C'
H : (i j k : D.J) → PreservesLimit (cospan (f D i j) (f D i k)) F
inst✝¹ : HasMulticoequalizer (diagram D)
inst✝ : PreservesColimit (MultispanIndex.multispan (diagram D)) F
i : D.J
this : HasColimit (MultispanIndex.multispan (diagram (mapGlueData D F)))
⊢ F.map (ι D i) ≫ (gluedIso D F).hom = ι (mapGlueData D F) i
[PROOFSTEP]
erw [ι_preservesColimitsIso_hom_assoc]
[GOAL]
C : Type u₁
inst✝³ : Category.{v, u₁} C
C' : Type u₂
inst✝² : Category.{v, u₂} C'
D : GlueData C
F : C ⥤ C'
H : (i j k : D.J) → PreservesLimit (cospan (f D i j) (f D i k)) F
inst✝¹ : HasMulticoequalizer (diagram D)
inst✝ : PreservesColimit (MultispanIndex.multispan (diagram D)) F
i : D.J
this : HasColimit (MultispanIndex.multispan (diagram (mapGlueData D F)))
⊢ colimit.ι (MultispanIndex.multispan (diagram D) ⋙ F) (WalkingMultispan.right i) ≫
      (HasColimit.isoOfNatIso (diagramIso D F)).hom =
    ι (mapGlueData D F) i
[PROOFSTEP]
rw [HasColimit.isoOfNatIso_ι_hom]
[GOAL]
C : Type u₁
inst✝³ : Category.{v, u₁} C
C' : Type u₂
inst✝² : Category.{v, u₂} C'
D : GlueData C
F : C ⥤ C'
H : (i j k : D.J) → PreservesLimit (cospan (f D i j) (f D i k)) F
inst✝¹ : HasMulticoequalizer (diagram D)
inst✝ : PreservesColimit (MultispanIndex.multispan (diagram D)) F
i : D.J
this : HasColimit (MultispanIndex.multispan (diagram (mapGlueData D F)))
⊢ NatTrans.app (diagramIso D F).hom (WalkingMultispan.right i) ≫
      colimit.ι (MultispanIndex.multispan (diagram (mapGlueData D F))) (WalkingMultispan.right i) =
    ι (mapGlueData D F) i
[PROOFSTEP]
erw [Category.id_comp]
[GOAL]
C : Type u₁
inst✝³ : Category.{v, u₁} C
C' : Type u₂
inst✝² : Category.{v, u₂} C'
D : GlueData C
F : C ⥤ C'
H : (i j k : D.J) → PreservesLimit (cospan (f D i j) (f D i k)) F
inst✝¹ : HasMulticoequalizer (diagram D)
inst✝ : PreservesColimit (MultispanIndex.multispan (diagram D)) F
i : D.J
this : HasColimit (MultispanIndex.multispan (diagram (mapGlueData D F)))
⊢ colimit.ι (MultispanIndex.multispan (diagram (mapGlueData D F))) (WalkingMultispan.right i) = ι (mapGlueData D F) i
[PROOFSTEP]
rfl
[GOAL]
C : Type u₁
inst✝³ : Category.{v, u₁} C
C' : Type u₂
inst✝² : Category.{v, u₂} C'
D : GlueData C
F : C ⥤ C'
H : (i j k : D.J) → PreservesLimit (cospan (f D i j) (f D i k)) F
inst✝¹ : HasMulticoequalizer (diagram D)
inst✝ : PreservesColimit (MultispanIndex.multispan (diagram D)) F
i : D.J
⊢ ι (mapGlueData D F) i ≫ (gluedIso D F).inv = F.map (ι D i)
[PROOFSTEP]
rw [Iso.comp_inv_eq, ι_gluedIso_hom]
[GOAL]
C : Type u₁
inst✝⁴ : Category.{v, u₁} C
C' : Type u₂
inst✝³ : Category.{v, u₂} C'
D : GlueData C
F : C ⥤ C'
H : (i j k : D.J) → PreservesLimit (cospan (f D i j) (f D i k)) F
inst✝² : HasMulticoequalizer (diagram D)
inst✝¹ : PreservesColimit (MultispanIndex.multispan (diagram D)) F
i j : D.J
inst✝ : ReflectsLimit (cospan (ι D i) (ι D j)) F
hc : IsLimit (vPullbackCone (mapGlueData D F) i j)
⊢ IsLimit (vPullbackCone D i j)
[PROOFSTEP]
apply isLimitOfReflects F
[GOAL]
case t
C : Type u₁
inst✝⁴ : Category.{v, u₁} C
C' : Type u₂
inst✝³ : Category.{v, u₂} C'
D : GlueData C
F : C ⥤ C'
H : (i j k : D.J) → PreservesLimit (cospan (f D i j) (f D i k)) F
inst✝² : HasMulticoequalizer (diagram D)
inst✝¹ : PreservesColimit (MultispanIndex.multispan (diagram D)) F
i j : D.J
inst✝ : ReflectsLimit (cospan (ι D i) (ι D j)) F
hc : IsLimit (vPullbackCone (mapGlueData D F) i j)
⊢ IsLimit (F.mapCone (vPullbackCone D i j))
[PROOFSTEP]
apply (isLimitMapConePullbackConeEquiv _ _).symm _
[GOAL]
C : Type u₁
inst✝⁴ : Category.{v, u₁} C
C' : Type u₂
inst✝³ : Category.{v, u₂} C'
D : GlueData C
F : C ⥤ C'
H : (i j k : D.J) → PreservesLimit (cospan (f D i j) (f D i k)) F
inst✝² : HasMulticoequalizer (diagram D)
inst✝¹ : PreservesColimit (MultispanIndex.multispan (diagram D)) F
i j : D.J
inst✝ : ReflectsLimit (cospan (ι D i) (ι D j)) F
hc : IsLimit (vPullbackCone (mapGlueData D F) i j)
⊢ IsLimit
    (PullbackCone.mk (F.map (f D i j)) (F.map (t D i j ≫ f D j i))
      (_ : F.map (f D i j) ≫ F.map (ι D i) = F.map (t D i j ≫ f D j i) ≫ F.map (ι D j)))
[PROOFSTEP]
let e : cospan (F.map (D.ι i)) (F.map (D.ι j)) ≅ cospan ((D.mapGlueData F).ι i) ((D.mapGlueData F).ι j)
[GOAL]
case e
C : Type u₁
inst✝⁴ : Category.{v, u₁} C
C' : Type u₂
inst✝³ : Category.{v, u₂} C'
D : GlueData C
F : C ⥤ C'
H : (i j k : D.J) → PreservesLimit (cospan (f D i j) (f D i k)) F
inst✝² : HasMulticoequalizer (diagram D)
inst✝¹ : PreservesColimit (MultispanIndex.multispan (diagram D)) F
i j : D.J
inst✝ : ReflectsLimit (cospan (ι D i) (ι D j)) F
hc : IsLimit (vPullbackCone (mapGlueData D F) i j)
⊢ cospan (F.map (ι D i)) (F.map (ι D j)) ≅ cospan (ι (mapGlueData D F) i) (ι (mapGlueData D F) j)
C : Type u₁
inst✝⁴ : Category.{v, u₁} C
C' : Type u₂
inst✝³ : Category.{v, u₂} C'
D : GlueData C
F : C ⥤ C'
H : (i j k : D.J) → PreservesLimit (cospan (f D i j) (f D i k)) F
inst✝² : HasMulticoequalizer (diagram D)
inst✝¹ : PreservesColimit (MultispanIndex.multispan (diagram D)) F
i j : D.J
inst✝ : ReflectsLimit (cospan (ι D i) (ι D j)) F
hc : IsLimit (vPullbackCone (mapGlueData D F) i j)
e : cospan (F.map (ι D i)) (F.map (ι D j)) ≅ cospan (ι (mapGlueData D F) i) (ι (mapGlueData D F) j) := ?e
⊢ IsLimit
    (PullbackCone.mk (F.map (f D i j)) (F.map (t D i j ≫ f D j i))
      (_ : F.map (f D i j) ≫ F.map (ι D i) = F.map (t D i j ≫ f D j i) ≫ F.map (ι D j)))
[PROOFSTEP]
exact
  NatIso.ofComponents
    (fun x => by
      cases x
      exacts [D.gluedIso F, Iso.refl _])
    (by rintro (_ | _) (_ | _) (_ | _ | _) <;> simp)
[GOAL]
C : Type u₁
inst✝⁴ : Category.{v, u₁} C
C' : Type u₂
inst✝³ : Category.{v, u₂} C'
D : GlueData C
F : C ⥤ C'
H : (i j k : D.J) → PreservesLimit (cospan (f D i j) (f D i k)) F
inst✝² : HasMulticoequalizer (diagram D)
inst✝¹ : PreservesColimit (MultispanIndex.multispan (diagram D)) F
i j : D.J
inst✝ : ReflectsLimit (cospan (ι D i) (ι D j)) F
hc : IsLimit (vPullbackCone (mapGlueData D F) i j)
x : WalkingCospan
⊢ (cospan (F.map (ι D i)) (F.map (ι D j))).obj x ≅ (cospan (ι (mapGlueData D F) i) (ι (mapGlueData D F) j)).obj x
[PROOFSTEP]
cases x
[GOAL]
case none
C : Type u₁
inst✝⁴ : Category.{v, u₁} C
C' : Type u₂
inst✝³ : Category.{v, u₂} C'
D : GlueData C
F : C ⥤ C'
H : (i j k : D.J) → PreservesLimit (cospan (f D i j) (f D i k)) F
inst✝² : HasMulticoequalizer (diagram D)
inst✝¹ : PreservesColimit (MultispanIndex.multispan (diagram D)) F
i j : D.J
inst✝ : ReflectsLimit (cospan (ι D i) (ι D j)) F
hc : IsLimit (vPullbackCone (mapGlueData D F) i j)
⊢ (cospan (F.map (ι D i)) (F.map (ι D j))).obj none ≅ (cospan (ι (mapGlueData D F) i) (ι (mapGlueData D F) j)).obj none
case some
C : Type u₁
inst✝⁴ : Category.{v, u₁} C
C' : Type u₂
inst✝³ : Category.{v, u₂} C'
D : GlueData C
F : C ⥤ C'
H : (i j k : D.J) → PreservesLimit (cospan (f D i j) (f D i k)) F
inst✝² : HasMulticoequalizer (diagram D)
inst✝¹ : PreservesColimit (MultispanIndex.multispan (diagram D)) F
i j : D.J
inst✝ : ReflectsLimit (cospan (ι D i) (ι D j)) F
hc : IsLimit (vPullbackCone (mapGlueData D F) i j)
val✝ : WalkingPair
⊢ (cospan (F.map (ι D i)) (F.map (ι D j))).obj (some val✝) ≅
    (cospan (ι (mapGlueData D F) i) (ι (mapGlueData D F) j)).obj (some val✝)
[PROOFSTEP]
exacts [D.gluedIso F, Iso.refl _]
[GOAL]
C : Type u₁
inst✝⁴ : Category.{v, u₁} C
C' : Type u₂
inst✝³ : Category.{v, u₂} C'
D : GlueData C
F : C ⥤ C'
H : (i j k : D.J) → PreservesLimit (cospan (f D i j) (f D i k)) F
inst✝² : HasMulticoequalizer (diagram D)
inst✝¹ : PreservesColimit (MultispanIndex.multispan (diagram D)) F
i j : D.J
inst✝ : ReflectsLimit (cospan (ι D i) (ι D j)) F
hc : IsLimit (vPullbackCone (mapGlueData D F) i j)
⊢ ∀ {X Y : WalkingCospan} (f : X ⟶ Y),
    (cospan (F.map (ι D i)) (F.map (ι D j))).map f ≫
        ((fun x =>
              Option.casesOn (motive := fun t =>
                x = t →
                  ((cospan (F.map (ι D i)) (F.map (ι D j))).obj x ≅
                    (cospan (ι (mapGlueData D F) i) (ι (mapGlueData D F) j)).obj x))
                x (fun h => (_ : none = x) ▸ gluedIso D F)
                (fun val h => (_ : some val = x) ▸ Iso.refl ((cospan (F.map (ι D i)) (F.map (ι D j))).obj (some val)))
                (_ : x = x))
            Y).hom =
      ((fun x =>
              Option.casesOn (motive := fun t =>
                x = t →
                  ((cospan (F.map (ι D i)) (F.map (ι D j))).obj x ≅
                    (cospan (ι (mapGlueData D F) i) (ι (mapGlueData D F) j)).obj x))
                x (fun h => (_ : none = x) ▸ gluedIso D F)
                (fun val h => (_ : some val = x) ▸ Iso.refl ((cospan (F.map (ι D i)) (F.map (ι D j))).obj (some val)))
                (_ : x = x))
            X).hom ≫
        (cospan (ι (mapGlueData D F) i) (ι (mapGlueData D F) j)).map f
[PROOFSTEP]
rintro (_ | _) (_ | _) (_ | _ | _)
[GOAL]
case none.none.id
C : Type u₁
inst✝⁴ : Category.{v, u₁} C
C' : Type u₂
inst✝³ : Category.{v, u₂} C'
D : GlueData C
F : C ⥤ C'
H : (i j k : D.J) → PreservesLimit (cospan (f D i j) (f D i k)) F
inst✝² : HasMulticoequalizer (diagram D)
inst✝¹ : PreservesColimit (MultispanIndex.multispan (diagram D)) F
i j : D.J
inst✝ : ReflectsLimit (cospan (ι D i) (ι D j)) F
hc : IsLimit (vPullbackCone (mapGlueData D F) i j)
⊢ (cospan (F.map (ι D i)) (F.map (ι D j))).map (WidePullbackShape.Hom.id none) ≫
      ((fun x =>
            Option.casesOn (motive := fun t =>
              x = t →
                ((cospan (F.map (ι D i)) (F.map (ι D j))).obj x ≅
                  (cospan (ι (mapGlueData D F) i) (ι (mapGlueData D F) j)).obj x))
              x (fun h => (_ : none = x) ▸ gluedIso D F)
              (fun val h => (_ : some val = x) ▸ Iso.refl ((cospan (F.map (ι D i)) (F.map (ι D j))).obj (some val)))
              (_ : x = x))
          none).hom =
    ((fun x =>
            Option.casesOn (motive := fun t =>
              x = t →
                ((cospan (F.map (ι D i)) (F.map (ι D j))).obj x ≅
                  (cospan (ι (mapGlueData D F) i) (ι (mapGlueData D F) j)).obj x))
              x (fun h => (_ : none = x) ▸ gluedIso D F)
              (fun val h => (_ : some val = x) ▸ Iso.refl ((cospan (F.map (ι D i)) (F.map (ι D j))).obj (some val)))
              (_ : x = x))
          none).hom ≫
      (cospan (ι (mapGlueData D F) i) (ι (mapGlueData D F) j)).map (WidePullbackShape.Hom.id none)
[PROOFSTEP]
simp
[GOAL]
case some.none.term.left
C : Type u₁
inst✝⁴ : Category.{v, u₁} C
C' : Type u₂
inst✝³ : Category.{v, u₂} C'
D : GlueData C
F : C ⥤ C'
H : (i j k : D.J) → PreservesLimit (cospan (f D i j) (f D i k)) F
inst✝² : HasMulticoequalizer (diagram D)
inst✝¹ : PreservesColimit (MultispanIndex.multispan (diagram D)) F
i j : D.J
inst✝ : ReflectsLimit (cospan (ι D i) (ι D j)) F
hc : IsLimit (vPullbackCone (mapGlueData D F) i j)
⊢ (cospan (F.map (ι D i)) (F.map (ι D j))).map (WidePullbackShape.Hom.term WalkingPair.left) ≫
      ((fun x =>
            Option.casesOn (motive := fun t =>
              x = t →
                ((cospan (F.map (ι D i)) (F.map (ι D j))).obj x ≅
                  (cospan (ι (mapGlueData D F) i) (ι (mapGlueData D F) j)).obj x))
              x (fun h => (_ : none = x) ▸ gluedIso D F)
              (fun val h => (_ : some val = x) ▸ Iso.refl ((cospan (F.map (ι D i)) (F.map (ι D j))).obj (some val)))
              (_ : x = x))
          none).hom =
    ((fun x =>
            Option.casesOn (motive := fun t =>
              x = t →
                ((cospan (F.map (ι D i)) (F.map (ι D j))).obj x ≅
                  (cospan (ι (mapGlueData D F) i) (ι (mapGlueData D F) j)).obj x))
              x (fun h => (_ : none = x) ▸ gluedIso D F)
              (fun val h => (_ : some val = x) ▸ Iso.refl ((cospan (F.map (ι D i)) (F.map (ι D j))).obj (some val)))
              (_ : x = x))
          (some WalkingPair.left)).hom ≫
      (cospan (ι (mapGlueData D F) i) (ι (mapGlueData D F) j)).map (WidePullbackShape.Hom.term WalkingPair.left)
[PROOFSTEP]
simp
[GOAL]
case some.none.term.right
C : Type u₁
inst✝⁴ : Category.{v, u₁} C
C' : Type u₂
inst✝³ : Category.{v, u₂} C'
D : GlueData C
F : C ⥤ C'
H : (i j k : D.J) → PreservesLimit (cospan (f D i j) (f D i k)) F
inst✝² : HasMulticoequalizer (diagram D)
inst✝¹ : PreservesColimit (MultispanIndex.multispan (diagram D)) F
i j : D.J
inst✝ : ReflectsLimit (cospan (ι D i) (ι D j)) F
hc : IsLimit (vPullbackCone (mapGlueData D F) i j)
⊢ (cospan (F.map (ι D i)) (F.map (ι D j))).map (WidePullbackShape.Hom.term WalkingPair.right) ≫
      ((fun x =>
            Option.casesOn (motive := fun t =>
              x = t →
                ((cospan (F.map (ι D i)) (F.map (ι D j))).obj x ≅
                  (cospan (ι (mapGlueData D F) i) (ι (mapGlueData D F) j)).obj x))
              x (fun h => (_ : none = x) ▸ gluedIso D F)
              (fun val h => (_ : some val = x) ▸ Iso.refl ((cospan (F.map (ι D i)) (F.map (ι D j))).obj (some val)))
              (_ : x = x))
          none).hom =
    ((fun x =>
            Option.casesOn (motive := fun t =>
              x = t →
                ((cospan (F.map (ι D i)) (F.map (ι D j))).obj x ≅
                  (cospan (ι (mapGlueData D F) i) (ι (mapGlueData D F) j)).obj x))
              x (fun h => (_ : none = x) ▸ gluedIso D F)
              (fun val h => (_ : some val = x) ▸ Iso.refl ((cospan (F.map (ι D i)) (F.map (ι D j))).obj (some val)))
              (_ : x = x))
          (some WalkingPair.right)).hom ≫
      (cospan (ι (mapGlueData D F) i) (ι (mapGlueData D F) j)).map (WidePullbackShape.Hom.term WalkingPair.right)
[PROOFSTEP]
simp
[GOAL]
case some.some.id
C : Type u₁
inst✝⁴ : Category.{v, u₁} C
C' : Type u₂
inst✝³ : Category.{v, u₂} C'
D : GlueData C
F : C ⥤ C'
H : (i j k : D.J) → PreservesLimit (cospan (f D i j) (f D i k)) F
inst✝² : HasMulticoequalizer (diagram D)
inst✝¹ : PreservesColimit (MultispanIndex.multispan (diagram D)) F
i j : D.J
inst✝ : ReflectsLimit (cospan (ι D i) (ι D j)) F
hc : IsLimit (vPullbackCone (mapGlueData D F) i j)
val✝ : WalkingPair
⊢ (cospan (F.map (ι D i)) (F.map (ι D j))).map (WidePullbackShape.Hom.id (some val✝)) ≫
      ((fun x =>
            Option.casesOn (motive := fun t =>
              x = t →
                ((cospan (F.map (ι D i)) (F.map (ι D j))).obj x ≅
                  (cospan (ι (mapGlueData D F) i) (ι (mapGlueData D F) j)).obj x))
              x (fun h => (_ : none = x) ▸ gluedIso D F)
              (fun val h => (_ : some val = x) ▸ Iso.refl ((cospan (F.map (ι D i)) (F.map (ι D j))).obj (some val)))
              (_ : x = x))
          (some val✝)).hom =
    ((fun x =>
            Option.casesOn (motive := fun t =>
              x = t →
                ((cospan (F.map (ι D i)) (F.map (ι D j))).obj x ≅
                  (cospan (ι (mapGlueData D F) i) (ι (mapGlueData D F) j)).obj x))
              x (fun h => (_ : none = x) ▸ gluedIso D F)
              (fun val h => (_ : some val = x) ▸ Iso.refl ((cospan (F.map (ι D i)) (F.map (ι D j))).obj (some val)))
              (_ : x = x))
          (some val✝)).hom ≫
      (cospan (ι (mapGlueData D F) i) (ι (mapGlueData D F) j)).map (WidePullbackShape.Hom.id (some val✝))
[PROOFSTEP]
simp
[GOAL]
C : Type u₁
inst✝⁴ : Category.{v, u₁} C
C' : Type u₂
inst✝³ : Category.{v, u₂} C'
D : GlueData C
F : C ⥤ C'
H : (i j k : D.J) → PreservesLimit (cospan (f D i j) (f D i k)) F
inst✝² : HasMulticoequalizer (diagram D)
inst✝¹ : PreservesColimit (MultispanIndex.multispan (diagram D)) F
i j : D.J
inst✝ : ReflectsLimit (cospan (ι D i) (ι D j)) F
hc : IsLimit (vPullbackCone (mapGlueData D F) i j)
e : cospan (F.map (ι D i)) (F.map (ι D j)) ≅ cospan (ι (mapGlueData D F) i) (ι (mapGlueData D F) j) :=
  NatIso.ofComponents fun x =>
    Option.casesOn (motive := fun t =>
      x = t →
        ((cospan (F.map (ι D i)) (F.map (ι D j))).obj x ≅
          (cospan (ι (mapGlueData D F) i) (ι (mapGlueData D F) j)).obj x))
      x (fun h => (_ : none = x) ▸ gluedIso D F)
      (fun val h => (_ : some val = x) ▸ Iso.refl ((cospan (F.map (ι D i)) (F.map (ι D j))).obj (some val))) (_ : x = x)
⊢ IsLimit
    (PullbackCone.mk (F.map (f D i j)) (F.map (t D i j ≫ f D j i))
      (_ : F.map (f D i j) ≫ F.map (ι D i) = F.map (t D i j ≫ f D j i) ≫ F.map (ι D j)))
[PROOFSTEP]
apply IsLimit.postcomposeHomEquiv e _ _
[GOAL]
C : Type u₁
inst✝⁴ : Category.{v, u₁} C
C' : Type u₂
inst✝³ : Category.{v, u₂} C'
D : GlueData C
F : C ⥤ C'
H : (i j k : D.J) → PreservesLimit (cospan (f D i j) (f D i k)) F
inst✝² : HasMulticoequalizer (diagram D)
inst✝¹ : PreservesColimit (MultispanIndex.multispan (diagram D)) F
i j : D.J
inst✝ : ReflectsLimit (cospan (ι D i) (ι D j)) F
hc : IsLimit (vPullbackCone (mapGlueData D F) i j)
e : cospan (F.map (ι D i)) (F.map (ι D j)) ≅ cospan (ι (mapGlueData D F) i) (ι (mapGlueData D F) j) :=
  NatIso.ofComponents fun x =>
    Option.casesOn (motive := fun t =>
      x = t →
        ((cospan (F.map (ι D i)) (F.map (ι D j))).obj x ≅
          (cospan (ι (mapGlueData D F) i) (ι (mapGlueData D F) j)).obj x))
      x (fun h => (_ : none = x) ▸ gluedIso D F)
      (fun val h => (_ : some val = x) ▸ Iso.refl ((cospan (F.map (ι D i)) (F.map (ι D j))).obj (some val))) (_ : x = x)
⊢ IsLimit
    ((Cones.postcompose e.hom).obj
      (PullbackCone.mk (F.map (f D i j)) (F.map (t D i j ≫ f D j i))
        (_ : F.map (f D i j) ≫ F.map (ι D i) = F.map (t D i j ≫ f D j i) ≫ F.map (ι D j))))
[PROOFSTEP]
apply hc.ofIsoLimit
[GOAL]
C : Type u₁
inst✝⁴ : Category.{v, u₁} C
C' : Type u₂
inst✝³ : Category.{v, u₂} C'
D : GlueData C
F : C ⥤ C'
H : (i j k : D.J) → PreservesLimit (cospan (f D i j) (f D i k)) F
inst✝² : HasMulticoequalizer (diagram D)
inst✝¹ : PreservesColimit (MultispanIndex.multispan (diagram D)) F
i j : D.J
inst✝ : ReflectsLimit (cospan (ι D i) (ι D j)) F
hc : IsLimit (vPullbackCone (mapGlueData D F) i j)
e : cospan (F.map (ι D i)) (F.map (ι D j)) ≅ cospan (ι (mapGlueData D F) i) (ι (mapGlueData D F) j) :=
  NatIso.ofComponents fun x =>
    Option.casesOn (motive := fun t =>
      x = t →
        ((cospan (F.map (ι D i)) (F.map (ι D j))).obj x ≅
          (cospan (ι (mapGlueData D F) i) (ι (mapGlueData D F) j)).obj x))
      x (fun h => (_ : none = x) ▸ gluedIso D F)
      (fun val h => (_ : some val = x) ▸ Iso.refl ((cospan (F.map (ι D i)) (F.map (ι D j))).obj (some val))) (_ : x = x)
⊢ vPullbackCone (mapGlueData D F) i j ≅
    (Cones.postcompose e.hom).obj
      (PullbackCone.mk (F.map (f D i j)) (F.map (t D i j ≫ f D j i))
        (_ : F.map (f D i j) ≫ F.map (ι D i) = F.map (t D i j ≫ f D j i) ≫ F.map (ι D j)))
[PROOFSTEP]
refine' Cones.ext (Iso.refl _) _
[GOAL]
C : Type u₁
inst✝⁴ : Category.{v, u₁} C
C' : Type u₂
inst✝³ : Category.{v, u₂} C'
D : GlueData C
F : C ⥤ C'
H : (i j k : D.J) → PreservesLimit (cospan (f D i j) (f D i k)) F
inst✝² : HasMulticoequalizer (diagram D)
inst✝¹ : PreservesColimit (MultispanIndex.multispan (diagram D)) F
i j : D.J
inst✝ : ReflectsLimit (cospan (ι D i) (ι D j)) F
hc : IsLimit (vPullbackCone (mapGlueData D F) i j)
e : cospan (F.map (ι D i)) (F.map (ι D j)) ≅ cospan (ι (mapGlueData D F) i) (ι (mapGlueData D F) j) :=
  NatIso.ofComponents fun x =>
    Option.casesOn (motive := fun t =>
      x = t →
        ((cospan (F.map (ι D i)) (F.map (ι D j))).obj x ≅
          (cospan (ι (mapGlueData D F) i) (ι (mapGlueData D F) j)).obj x))
      x (fun h => (_ : none = x) ▸ gluedIso D F)
      (fun val h => (_ : some val = x) ▸ Iso.refl ((cospan (F.map (ι D i)) (F.map (ι D j))).obj (some val))) (_ : x = x)
⊢ ∀ (j_1 : WalkingCospan),
    NatTrans.app (vPullbackCone (mapGlueData D F) i j).π j_1 =
      (Iso.refl (vPullbackCone (mapGlueData D F) i j).pt).hom ≫
        NatTrans.app
          ((Cones.postcompose e.hom).obj
              (PullbackCone.mk (F.map (f D i j)) (F.map (t D i j ≫ f D j i))
                (_ : F.map (f D i j) ≫ F.map (ι D i) = F.map (t D i j ≫ f D j i) ≫ F.map (ι D j)))).π
          j_1
[PROOFSTEP]
rintro (_ | _ | _)
[GOAL]
case none
C : Type u₁
inst✝⁴ : Category.{v, u₁} C
C' : Type u₂
inst✝³ : Category.{v, u₂} C'
D : GlueData C
F : C ⥤ C'
H : (i j k : D.J) → PreservesLimit (cospan (f D i j) (f D i k)) F
inst✝² : HasMulticoequalizer (diagram D)
inst✝¹ : PreservesColimit (MultispanIndex.multispan (diagram D)) F
i j : D.J
inst✝ : ReflectsLimit (cospan (ι D i) (ι D j)) F
hc : IsLimit (vPullbackCone (mapGlueData D F) i j)
e : cospan (F.map (ι D i)) (F.map (ι D j)) ≅ cospan (ι (mapGlueData D F) i) (ι (mapGlueData D F) j) :=
  NatIso.ofComponents fun x =>
    Option.casesOn (motive := fun t =>
      x = t →
        ((cospan (F.map (ι D i)) (F.map (ι D j))).obj x ≅
          (cospan (ι (mapGlueData D F) i) (ι (mapGlueData D F) j)).obj x))
      x (fun h => (_ : none = x) ▸ gluedIso D F)
      (fun val h => (_ : some val = x) ▸ Iso.refl ((cospan (F.map (ι D i)) (F.map (ι D j))).obj (some val))) (_ : x = x)
⊢ NatTrans.app (vPullbackCone (mapGlueData D F) i j).π none =
    (Iso.refl (vPullbackCone (mapGlueData D F) i j).pt).hom ≫
      NatTrans.app
        ((Cones.postcompose e.hom).obj
            (PullbackCone.mk (F.map (f D i j)) (F.map (t D i j ≫ f D j i))
              (_ : F.map (f D i j) ≫ F.map (ι D i) = F.map (t D i j ≫ f D j i) ≫ F.map (ι D j)))).π
        none
case some.left
C : Type u₁
inst✝⁴ : Category.{v, u₁} C
C' : Type u₂
inst✝³ : Category.{v, u₂} C'
D : GlueData C
F : C ⥤ C'
H : (i j k : D.J) → PreservesLimit (cospan (f D i j) (f D i k)) F
inst✝² : HasMulticoequalizer (diagram D)
inst✝¹ : PreservesColimit (MultispanIndex.multispan (diagram D)) F
i j : D.J
inst✝ : ReflectsLimit (cospan (ι D i) (ι D j)) F
hc : IsLimit (vPullbackCone (mapGlueData D F) i j)
e : cospan (F.map (ι D i)) (F.map (ι D j)) ≅ cospan (ι (mapGlueData D F) i) (ι (mapGlueData D F) j) :=
  NatIso.ofComponents fun x =>
    Option.casesOn (motive := fun t =>
      x = t →
        ((cospan (F.map (ι D i)) (F.map (ι D j))).obj x ≅
          (cospan (ι (mapGlueData D F) i) (ι (mapGlueData D F) j)).obj x))
      x (fun h => (_ : none = x) ▸ gluedIso D F)
      (fun val h => (_ : some val = x) ▸ Iso.refl ((cospan (F.map (ι D i)) (F.map (ι D j))).obj (some val))) (_ : x = x)
⊢ NatTrans.app (vPullbackCone (mapGlueData D F) i j).π (some WalkingPair.left) =
    (Iso.refl (vPullbackCone (mapGlueData D F) i j).pt).hom ≫
      NatTrans.app
        ((Cones.postcompose e.hom).obj
            (PullbackCone.mk (F.map (f D i j)) (F.map (t D i j ≫ f D j i))
              (_ : F.map (f D i j) ≫ F.map (ι D i) = F.map (t D i j ≫ f D j i) ≫ F.map (ι D j)))).π
        (some WalkingPair.left)
case some.right
C : Type u₁
inst✝⁴ : Category.{v, u₁} C
C' : Type u₂
inst✝³ : Category.{v, u₂} C'
D : GlueData C
F : C ⥤ C'
H : (i j k : D.J) → PreservesLimit (cospan (f D i j) (f D i k)) F
inst✝² : HasMulticoequalizer (diagram D)
inst✝¹ : PreservesColimit (MultispanIndex.multispan (diagram D)) F
i j : D.J
inst✝ : ReflectsLimit (cospan (ι D i) (ι D j)) F
hc : IsLimit (vPullbackCone (mapGlueData D F) i j)
e : cospan (F.map (ι D i)) (F.map (ι D j)) ≅ cospan (ι (mapGlueData D F) i) (ι (mapGlueData D F) j) :=
  NatIso.ofComponents fun x =>
    Option.casesOn (motive := fun t =>
      x = t →
        ((cospan (F.map (ι D i)) (F.map (ι D j))).obj x ≅
          (cospan (ι (mapGlueData D F) i) (ι (mapGlueData D F) j)).obj x))
      x (fun h => (_ : none = x) ▸ gluedIso D F)
      (fun val h => (_ : some val = x) ▸ Iso.refl ((cospan (F.map (ι D i)) (F.map (ι D j))).obj (some val))) (_ : x = x)
⊢ NatTrans.app (vPullbackCone (mapGlueData D F) i j).π (some WalkingPair.right) =
    (Iso.refl (vPullbackCone (mapGlueData D F) i j).pt).hom ≫
      NatTrans.app
        ((Cones.postcompose e.hom).obj
            (PullbackCone.mk (F.map (f D i j)) (F.map (t D i j ≫ f D j i))
              (_ : F.map (f D i j) ≫ F.map (ι D i) = F.map (t D i j ≫ f D j i) ≫ F.map (ι D j)))).π
        (some WalkingPair.right)
[PROOFSTEP]
change _ = _ ≫ (_ ≫ _) ≫ _
[GOAL]
case none
C : Type u₁
inst✝⁴ : Category.{v, u₁} C
C' : Type u₂
inst✝³ : Category.{v, u₂} C'
D : GlueData C
F : C ⥤ C'
H : (i j k : D.J) → PreservesLimit (cospan (f D i j) (f D i k)) F
inst✝² : HasMulticoequalizer (diagram D)
inst✝¹ : PreservesColimit (MultispanIndex.multispan (diagram D)) F
i j : D.J
inst✝ : ReflectsLimit (cospan (ι D i) (ι D j)) F
hc : IsLimit (vPullbackCone (mapGlueData D F) i j)
e : cospan (F.map (ι D i)) (F.map (ι D j)) ≅ cospan (ι (mapGlueData D F) i) (ι (mapGlueData D F) j) :=
  NatIso.ofComponents fun x =>
    Option.casesOn (motive := fun t =>
      x = t →
        ((cospan (F.map (ι D i)) (F.map (ι D j))).obj x ≅
          (cospan (ι (mapGlueData D F) i) (ι (mapGlueData D F) j)).obj x))
      x (fun h => (_ : none = x) ▸ gluedIso D F)
      (fun val h => (_ : some val = x) ▸ Iso.refl ((cospan (F.map (ι D i)) (F.map (ι D j))).obj (some val))) (_ : x = x)
⊢ NatTrans.app (vPullbackCone (mapGlueData D F) i j).π none =
    (Iso.refl (vPullbackCone (mapGlueData D F) i j).pt).hom ≫
      (F.map (f D i j) ≫ F.map (ι D i)) ≫ NatTrans.app e.hom none
case some.left
C : Type u₁
inst✝⁴ : Category.{v, u₁} C
C' : Type u₂
inst✝³ : Category.{v, u₂} C'
D : GlueData C
F : C ⥤ C'
H : (i j k : D.J) → PreservesLimit (cospan (f D i j) (f D i k)) F
inst✝² : HasMulticoequalizer (diagram D)
inst✝¹ : PreservesColimit (MultispanIndex.multispan (diagram D)) F
i j : D.J
inst✝ : ReflectsLimit (cospan (ι D i) (ι D j)) F
hc : IsLimit (vPullbackCone (mapGlueData D F) i j)
e : cospan (F.map (ι D i)) (F.map (ι D j)) ≅ cospan (ι (mapGlueData D F) i) (ι (mapGlueData D F) j) :=
  NatIso.ofComponents fun x =>
    Option.casesOn (motive := fun t =>
      x = t →
        ((cospan (F.map (ι D i)) (F.map (ι D j))).obj x ≅
          (cospan (ι (mapGlueData D F) i) (ι (mapGlueData D F) j)).obj x))
      x (fun h => (_ : none = x) ▸ gluedIso D F)
      (fun val h => (_ : some val = x) ▸ Iso.refl ((cospan (F.map (ι D i)) (F.map (ι D j))).obj (some val))) (_ : x = x)
⊢ NatTrans.app (vPullbackCone (mapGlueData D F) i j).π (some WalkingPair.left) =
    (Iso.refl (vPullbackCone (mapGlueData D F) i j).pt).hom ≫
      NatTrans.app
        ((Cones.postcompose e.hom).obj
            (PullbackCone.mk (F.map (f D i j)) (F.map (t D i j ≫ f D j i))
              (_ : F.map (f D i j) ≫ F.map (ι D i) = F.map (t D i j ≫ f D j i) ≫ F.map (ι D j)))).π
        (some WalkingPair.left)
case some.right
C : Type u₁
inst✝⁴ : Category.{v, u₁} C
C' : Type u₂
inst✝³ : Category.{v, u₂} C'
D : GlueData C
F : C ⥤ C'
H : (i j k : D.J) → PreservesLimit (cospan (f D i j) (f D i k)) F
inst✝² : HasMulticoequalizer (diagram D)
inst✝¹ : PreservesColimit (MultispanIndex.multispan (diagram D)) F
i j : D.J
inst✝ : ReflectsLimit (cospan (ι D i) (ι D j)) F
hc : IsLimit (vPullbackCone (mapGlueData D F) i j)
e : cospan (F.map (ι D i)) (F.map (ι D j)) ≅ cospan (ι (mapGlueData D F) i) (ι (mapGlueData D F) j) :=
  NatIso.ofComponents fun x =>
    Option.casesOn (motive := fun t =>
      x = t →
        ((cospan (F.map (ι D i)) (F.map (ι D j))).obj x ≅
          (cospan (ι (mapGlueData D F) i) (ι (mapGlueData D F) j)).obj x))
      x (fun h => (_ : none = x) ▸ gluedIso D F)
      (fun val h => (_ : some val = x) ▸ Iso.refl ((cospan (F.map (ι D i)) (F.map (ι D j))).obj (some val))) (_ : x = x)
⊢ NatTrans.app (vPullbackCone (mapGlueData D F) i j).π (some WalkingPair.right) =
    (Iso.refl (vPullbackCone (mapGlueData D F) i j).pt).hom ≫
      NatTrans.app
        ((Cones.postcompose e.hom).obj
            (PullbackCone.mk (F.map (f D i j)) (F.map (t D i j ≫ f D j i))
              (_ : F.map (f D i j) ≫ F.map (ι D i) = F.map (t D i j ≫ f D j i) ≫ F.map (ι D j)))).π
        (some WalkingPair.right)
[PROOFSTEP]
all_goals change _ = 𝟙 _ ≫ _ ≫ _; aesop_cat
[GOAL]
case none
C : Type u₁
inst✝⁴ : Category.{v, u₁} C
C' : Type u₂
inst✝³ : Category.{v, u₂} C'
D : GlueData C
F : C ⥤ C'
H : (i j k : D.J) → PreservesLimit (cospan (f D i j) (f D i k)) F
inst✝² : HasMulticoequalizer (diagram D)
inst✝¹ : PreservesColimit (MultispanIndex.multispan (diagram D)) F
i j : D.J
inst✝ : ReflectsLimit (cospan (ι D i) (ι D j)) F
hc : IsLimit (vPullbackCone (mapGlueData D F) i j)
e : cospan (F.map (ι D i)) (F.map (ι D j)) ≅ cospan (ι (mapGlueData D F) i) (ι (mapGlueData D F) j) :=
  NatIso.ofComponents fun x =>
    Option.casesOn (motive := fun t =>
      x = t →
        ((cospan (F.map (ι D i)) (F.map (ι D j))).obj x ≅
          (cospan (ι (mapGlueData D F) i) (ι (mapGlueData D F) j)).obj x))
      x (fun h => (_ : none = x) ▸ gluedIso D F)
      (fun val h => (_ : some val = x) ▸ Iso.refl ((cospan (F.map (ι D i)) (F.map (ι D j))).obj (some val))) (_ : x = x)
⊢ NatTrans.app (vPullbackCone (mapGlueData D F) i j).π none =
    (Iso.refl (vPullbackCone (mapGlueData D F) i j).pt).hom ≫
      (F.map (f D i j) ≫ F.map (ι D i)) ≫ NatTrans.app e.hom none
[PROOFSTEP]
change _ = 𝟙 _ ≫ _ ≫ _
[GOAL]
case none
C : Type u₁
inst✝⁴ : Category.{v, u₁} C
C' : Type u₂
inst✝³ : Category.{v, u₂} C'
D : GlueData C
F : C ⥤ C'
H : (i j k : D.J) → PreservesLimit (cospan (f D i j) (f D i k)) F
inst✝² : HasMulticoequalizer (diagram D)
inst✝¹ : PreservesColimit (MultispanIndex.multispan (diagram D)) F
i j : D.J
inst✝ : ReflectsLimit (cospan (ι D i) (ι D j)) F
hc : IsLimit (vPullbackCone (mapGlueData D F) i j)
e : cospan (F.map (ι D i)) (F.map (ι D j)) ≅ cospan (ι (mapGlueData D F) i) (ι (mapGlueData D F) j) :=
  NatIso.ofComponents fun x =>
    Option.casesOn (motive := fun t =>
      x = t →
        ((cospan (F.map (ι D i)) (F.map (ι D j))).obj x ≅
          (cospan (ι (mapGlueData D F) i) (ι (mapGlueData D F) j)).obj x))
      x (fun h => (_ : none = x) ▸ gluedIso D F)
      (fun val h => (_ : some val = x) ▸ Iso.refl ((cospan (F.map (ι D i)) (F.map (ι D j))).obj (some val))) (_ : x = x)
⊢ NatTrans.app (vPullbackCone (mapGlueData D F) i j).π none =
    𝟙 (((Functor.const WalkingCospan).obj (vPullbackCone (mapGlueData D F) i j).pt).obj none) ≫
      (F.map (f D i j) ≫ F.map (ι D i)) ≫ NatTrans.app e.hom none
[PROOFSTEP]
aesop_cat
[GOAL]
case some.left
C : Type u₁
inst✝⁴ : Category.{v, u₁} C
C' : Type u₂
inst✝³ : Category.{v, u₂} C'
D : GlueData C
F : C ⥤ C'
H : (i j k : D.J) → PreservesLimit (cospan (f D i j) (f D i k)) F
inst✝² : HasMulticoequalizer (diagram D)
inst✝¹ : PreservesColimit (MultispanIndex.multispan (diagram D)) F
i j : D.J
inst✝ : ReflectsLimit (cospan (ι D i) (ι D j)) F
hc : IsLimit (vPullbackCone (mapGlueData D F) i j)
e : cospan (F.map (ι D i)) (F.map (ι D j)) ≅ cospan (ι (mapGlueData D F) i) (ι (mapGlueData D F) j) :=
  NatIso.ofComponents fun x =>
    Option.casesOn (motive := fun t =>
      x = t →
        ((cospan (F.map (ι D i)) (F.map (ι D j))).obj x ≅
          (cospan (ι (mapGlueData D F) i) (ι (mapGlueData D F) j)).obj x))
      x (fun h => (_ : none = x) ▸ gluedIso D F)
      (fun val h => (_ : some val = x) ▸ Iso.refl ((cospan (F.map (ι D i)) (F.map (ι D j))).obj (some val))) (_ : x = x)
⊢ NatTrans.app (vPullbackCone (mapGlueData D F) i j).π (some WalkingPair.left) =
    (Iso.refl (vPullbackCone (mapGlueData D F) i j).pt).hom ≫
      NatTrans.app
        ((Cones.postcompose e.hom).obj
            (PullbackCone.mk (F.map (f D i j)) (F.map (t D i j ≫ f D j i))
              (_ : F.map (f D i j) ≫ F.map (ι D i) = F.map (t D i j ≫ f D j i) ≫ F.map (ι D j)))).π
        (some WalkingPair.left)
[PROOFSTEP]
change _ = 𝟙 _ ≫ _ ≫ _
[GOAL]
case some.left
C : Type u₁
inst✝⁴ : Category.{v, u₁} C
C' : Type u₂
inst✝³ : Category.{v, u₂} C'
D : GlueData C
F : C ⥤ C'
H : (i j k : D.J) → PreservesLimit (cospan (f D i j) (f D i k)) F
inst✝² : HasMulticoequalizer (diagram D)
inst✝¹ : PreservesColimit (MultispanIndex.multispan (diagram D)) F
i j : D.J
inst✝ : ReflectsLimit (cospan (ι D i) (ι D j)) F
hc : IsLimit (vPullbackCone (mapGlueData D F) i j)
e : cospan (F.map (ι D i)) (F.map (ι D j)) ≅ cospan (ι (mapGlueData D F) i) (ι (mapGlueData D F) j) :=
  NatIso.ofComponents fun x =>
    Option.casesOn (motive := fun t =>
      x = t →
        ((cospan (F.map (ι D i)) (F.map (ι D j))).obj x ≅
          (cospan (ι (mapGlueData D F) i) (ι (mapGlueData D F) j)).obj x))
      x (fun h => (_ : none = x) ▸ gluedIso D F)
      (fun val h => (_ : some val = x) ▸ Iso.refl ((cospan (F.map (ι D i)) (F.map (ι D j))).obj (some val))) (_ : x = x)
⊢ NatTrans.app (vPullbackCone (mapGlueData D F) i j).π (some WalkingPair.left) =
    𝟙 (((Functor.const WalkingCospan).obj (vPullbackCone (mapGlueData D F) i j).pt).obj (some WalkingPair.left)) ≫
      NatTrans.app
          (PullbackCone.mk (F.map (f D i j)) (F.map (t D i j ≫ f D j i))
              (_ : F.map (f D i j) ≫ F.map (ι D i) = F.map (t D i j ≫ f D j i) ≫ F.map (ι D j))).π
          (some WalkingPair.left) ≫
        NatTrans.app e.hom (some WalkingPair.left)
[PROOFSTEP]
aesop_cat
[GOAL]
case some.right
C : Type u₁
inst✝⁴ : Category.{v, u₁} C
C' : Type u₂
inst✝³ : Category.{v, u₂} C'
D : GlueData C
F : C ⥤ C'
H : (i j k : D.J) → PreservesLimit (cospan (f D i j) (f D i k)) F
inst✝² : HasMulticoequalizer (diagram D)
inst✝¹ : PreservesColimit (MultispanIndex.multispan (diagram D)) F
i j : D.J
inst✝ : ReflectsLimit (cospan (ι D i) (ι D j)) F
hc : IsLimit (vPullbackCone (mapGlueData D F) i j)
e : cospan (F.map (ι D i)) (F.map (ι D j)) ≅ cospan (ι (mapGlueData D F) i) (ι (mapGlueData D F) j) :=
  NatIso.ofComponents fun x =>
    Option.casesOn (motive := fun t =>
      x = t →
        ((cospan (F.map (ι D i)) (F.map (ι D j))).obj x ≅
          (cospan (ι (mapGlueData D F) i) (ι (mapGlueData D F) j)).obj x))
      x (fun h => (_ : none = x) ▸ gluedIso D F)
      (fun val h => (_ : some val = x) ▸ Iso.refl ((cospan (F.map (ι D i)) (F.map (ι D j))).obj (some val))) (_ : x = x)
⊢ NatTrans.app (vPullbackCone (mapGlueData D F) i j).π (some WalkingPair.right) =
    (Iso.refl (vPullbackCone (mapGlueData D F) i j).pt).hom ≫
      NatTrans.app
        ((Cones.postcompose e.hom).obj
            (PullbackCone.mk (F.map (f D i j)) (F.map (t D i j ≫ f D j i))
              (_ : F.map (f D i j) ≫ F.map (ι D i) = F.map (t D i j ≫ f D j i) ≫ F.map (ι D j)))).π
        (some WalkingPair.right)
[PROOFSTEP]
change _ = 𝟙 _ ≫ _ ≫ _
[GOAL]
case some.right
C : Type u₁
inst✝⁴ : Category.{v, u₁} C
C' : Type u₂
inst✝³ : Category.{v, u₂} C'
D : GlueData C
F : C ⥤ C'
H : (i j k : D.J) → PreservesLimit (cospan (f D i j) (f D i k)) F
inst✝² : HasMulticoequalizer (diagram D)
inst✝¹ : PreservesColimit (MultispanIndex.multispan (diagram D)) F
i j : D.J
inst✝ : ReflectsLimit (cospan (ι D i) (ι D j)) F
hc : IsLimit (vPullbackCone (mapGlueData D F) i j)
e : cospan (F.map (ι D i)) (F.map (ι D j)) ≅ cospan (ι (mapGlueData D F) i) (ι (mapGlueData D F) j) :=
  NatIso.ofComponents fun x =>
    Option.casesOn (motive := fun t =>
      x = t →
        ((cospan (F.map (ι D i)) (F.map (ι D j))).obj x ≅
          (cospan (ι (mapGlueData D F) i) (ι (mapGlueData D F) j)).obj x))
      x (fun h => (_ : none = x) ▸ gluedIso D F)
      (fun val h => (_ : some val = x) ▸ Iso.refl ((cospan (F.map (ι D i)) (F.map (ι D j))).obj (some val))) (_ : x = x)
⊢ NatTrans.app (vPullbackCone (mapGlueData D F) i j).π (some WalkingPair.right) =
    𝟙 (((Functor.const WalkingCospan).obj (vPullbackCone (mapGlueData D F) i j).pt).obj (some WalkingPair.right)) ≫
      NatTrans.app
          (PullbackCone.mk (F.map (f D i j)) (F.map (t D i j ≫ f D j i))
              (_ : F.map (f D i j) ≫ F.map (ι D i) = F.map (t D i j ≫ f D j i) ≫ F.map (ι D j))).π
          (some WalkingPair.right) ≫
        NatTrans.app e.hom (some WalkingPair.right)
[PROOFSTEP]
aesop_cat
[GOAL]
C : Type u₁
inst✝⁵ : Category.{v, u₁} C
C' : Type u₂
inst✝⁴ : Category.{v, u₂} C'
D : GlueData C
F✝ : C ⥤ C'
H : (i j k : D.J) → PreservesLimit (cospan (f D i j) (f D i k)) F✝
inst✝³ : HasMulticoequalizer (diagram D)
inst✝² : PreservesColimit (MultispanIndex.multispan (diagram D)) F✝
F : C ⥤ Type v
inst✝¹ : PreservesColimit (MultispanIndex.multispan (diagram D)) F
inst✝ : (i j k : D.J) → PreservesLimit (cospan (f D i j) (f D i k)) F
x : F.obj (glued D)
⊢ ∃ i y, F.map (ι D i) y = x
[PROOFSTEP]
let e := D.gluedIso F
[GOAL]
C : Type u₁
inst✝⁵ : Category.{v, u₁} C
C' : Type u₂
inst✝⁴ : Category.{v, u₂} C'
D : GlueData C
F✝ : C ⥤ C'
H : (i j k : D.J) → PreservesLimit (cospan (f D i j) (f D i k)) F✝
inst✝³ : HasMulticoequalizer (diagram D)
inst✝² : PreservesColimit (MultispanIndex.multispan (diagram D)) F✝
F : C ⥤ Type v
inst✝¹ : PreservesColimit (MultispanIndex.multispan (diagram D)) F
inst✝ : (i j k : D.J) → PreservesLimit (cospan (f D i j) (f D i k)) F
x : F.obj (glued D)
e : F.obj (glued D) ≅ glued (mapGlueData D F) := gluedIso D F
⊢ ∃ i y, F.map (ι D i) y = x
[PROOFSTEP]
obtain ⟨i, y, eq⟩ := (D.mapGlueData F).types_ι_jointly_surjective (e.hom x)
[GOAL]
case intro.intro
C : Type u₁
inst✝⁵ : Category.{v, u₁} C
C' : Type u₂
inst✝⁴ : Category.{v, u₂} C'
D : GlueData C
F✝ : C ⥤ C'
H : (i j k : D.J) → PreservesLimit (cospan (f D i j) (f D i k)) F✝
inst✝³ : HasMulticoequalizer (diagram D)
inst✝² : PreservesColimit (MultispanIndex.multispan (diagram D)) F✝
F : C ⥤ Type v
inst✝¹ : PreservesColimit (MultispanIndex.multispan (diagram D)) F
inst✝ : (i j k : D.J) → PreservesLimit (cospan (f D i j) (f D i k)) F
x : F.obj (glued D)
e : F.obj (glued D) ≅ glued (mapGlueData D F) := gluedIso D F
i : (mapGlueData D F).J
y : U (mapGlueData D F) i
eq : ι (mapGlueData D F) i y = e.hom x
⊢ ∃ i y, F.map (ι D i) y = x
[PROOFSTEP]
replace eq := congr_arg e.inv eq
[GOAL]
case intro.intro
C : Type u₁
inst✝⁵ : Category.{v, u₁} C
C' : Type u₂
inst✝⁴ : Category.{v, u₂} C'
D : GlueData C
F✝ : C ⥤ C'
H : (i j k : D.J) → PreservesLimit (cospan (f D i j) (f D i k)) F✝
inst✝³ : HasMulticoequalizer (diagram D)
inst✝² : PreservesColimit (MultispanIndex.multispan (diagram D)) F✝
F : C ⥤ Type v
inst✝¹ : PreservesColimit (MultispanIndex.multispan (diagram D)) F
inst✝ : (i j k : D.J) → PreservesLimit (cospan (f D i j) (f D i k)) F
x : F.obj (glued D)
e : F.obj (glued D) ≅ glued (mapGlueData D F) := gluedIso D F
i : (mapGlueData D F).J
y : U (mapGlueData D F) i
eq : e.inv (ι (mapGlueData D F) i y) = e.inv (e.hom x)
⊢ ∃ i y, F.map (ι D i) y = x
[PROOFSTEP]
change ((D.mapGlueData F).ι i ≫ e.inv) y = (e.hom ≫ e.inv) x at eq
[GOAL]
case intro.intro
C : Type u₁
inst✝⁵ : Category.{v, u₁} C
C' : Type u₂
inst✝⁴ : Category.{v, u₂} C'
D : GlueData C
F✝ : C ⥤ C'
H : (i j k : D.J) → PreservesLimit (cospan (f D i j) (f D i k)) F✝
inst✝³ : HasMulticoequalizer (diagram D)
inst✝² : PreservesColimit (MultispanIndex.multispan (diagram D)) F✝
F : C ⥤ Type v
inst✝¹ : PreservesColimit (MultispanIndex.multispan (diagram D)) F
inst✝ : (i j k : D.J) → PreservesLimit (cospan (f D i j) (f D i k)) F
x : F.obj (glued D)
e : F.obj (glued D) ≅ glued (mapGlueData D F) := gluedIso D F
i : (mapGlueData D F).J
y : U (mapGlueData D F) i
eq : (ι (mapGlueData D F) i ≫ e.inv) y = (e.hom ≫ e.inv) x
⊢ ∃ i y, F.map (ι D i) y = x
[PROOFSTEP]
rw [e.hom_inv_id, D.ι_gluedIso_inv] at eq
[GOAL]
case intro.intro
C : Type u₁
inst✝⁵ : Category.{v, u₁} C
C' : Type u₂
inst✝⁴ : Category.{v, u₂} C'
D : GlueData C
F✝ : C ⥤ C'
H : (i j k : D.J) → PreservesLimit (cospan (f D i j) (f D i k)) F✝
inst✝³ : HasMulticoequalizer (diagram D)
inst✝² : PreservesColimit (MultispanIndex.multispan (diagram D)) F✝
F : C ⥤ Type v
inst✝¹ : PreservesColimit (MultispanIndex.multispan (diagram D)) F
inst✝ : (i j k : D.J) → PreservesLimit (cospan (f D i j) (f D i k)) F
x : F.obj (glued D)
e : F.obj (glued D) ≅ glued (mapGlueData D F) := gluedIso D F
i : (mapGlueData D F).J
y : U (mapGlueData D F) i
eq : F.map (ι D i) y = 𝟙 (F.obj (glued D)) x
⊢ ∃ i y, F.map (ι D i) y = x
[PROOFSTEP]
exact ⟨i, y, eq⟩


[GOAL]
R : Type u
inst✝⁴ : CommRing R
inst✝³ : IsNoetherianRing R
A : Type u
inst✝² : CommRing A
inst✝¹ : IsDomain A
inst✝ : IsNoetherianRing A
I : Ideal R
⊢ ∃ Z, Multiset.prod (Multiset.map asIdeal Z) ≤ I
[PROOFSTEP]
refine'
  IsNoetherian.induction (P := fun I => ∃ Z : Multiset (PrimeSpectrum R), Multiset.prod (Z.map asIdeal) ≤ I)
    (fun (M : Ideal R) hgt => _) I
[GOAL]
R : Type u
inst✝⁴ : CommRing R
inst✝³ : IsNoetherianRing R
A : Type u
inst✝² : CommRing A
inst✝¹ : IsDomain A
inst✝ : IsNoetherianRing A
I M : Ideal R
hgt : ∀ (J : Submodule R R), J > M → (fun I => ∃ Z, Multiset.prod (Multiset.map asIdeal Z) ≤ I) J
⊢ (fun I => ∃ Z, Multiset.prod (Multiset.map asIdeal Z) ≤ I) M
[PROOFSTEP]
by_cases h_prM : M.IsPrime
[GOAL]
case pos
R : Type u
inst✝⁴ : CommRing R
inst✝³ : IsNoetherianRing R
A : Type u
inst✝² : CommRing A
inst✝¹ : IsDomain A
inst✝ : IsNoetherianRing A
I M : Ideal R
hgt : ∀ (J : Submodule R R), J > M → (fun I => ∃ Z, Multiset.prod (Multiset.map asIdeal Z) ≤ I) J
h_prM : Ideal.IsPrime M
⊢ (fun I => ∃ Z, Multiset.prod (Multiset.map asIdeal Z) ≤ I) M
[PROOFSTEP]
use{⟨M, h_prM⟩}
[GOAL]
case h
R : Type u
inst✝⁴ : CommRing R
inst✝³ : IsNoetherianRing R
A : Type u
inst✝² : CommRing A
inst✝¹ : IsDomain A
inst✝ : IsNoetherianRing A
I M : Ideal R
hgt : ∀ (J : Submodule R R), J > M → (fun I => ∃ Z, Multiset.prod (Multiset.map asIdeal Z) ≤ I) J
h_prM : Ideal.IsPrime M
⊢ Multiset.prod (Multiset.map asIdeal {{ asIdeal := M, IsPrime := h_prM }}) ≤ M
[PROOFSTEP]
rw [Multiset.map_singleton, Multiset.prod_singleton]
[GOAL]
case neg
R : Type u
inst✝⁴ : CommRing R
inst✝³ : IsNoetherianRing R
A : Type u
inst✝² : CommRing A
inst✝¹ : IsDomain A
inst✝ : IsNoetherianRing A
I M : Ideal R
hgt : ∀ (J : Submodule R R), J > M → (fun I => ∃ Z, Multiset.prod (Multiset.map asIdeal Z) ≤ I) J
h_prM : ¬Ideal.IsPrime M
⊢ (fun I => ∃ Z, Multiset.prod (Multiset.map asIdeal Z) ≤ I) M
[PROOFSTEP]
by_cases htop : M = ⊤
[GOAL]
case pos
R : Type u
inst✝⁴ : CommRing R
inst✝³ : IsNoetherianRing R
A : Type u
inst✝² : CommRing A
inst✝¹ : IsDomain A
inst✝ : IsNoetherianRing A
I M : Ideal R
hgt : ∀ (J : Submodule R R), J > M → (fun I => ∃ Z, Multiset.prod (Multiset.map asIdeal Z) ≤ I) J
h_prM : ¬Ideal.IsPrime M
htop : M = ⊤
⊢ (fun I => ∃ Z, Multiset.prod (Multiset.map asIdeal Z) ≤ I) M
[PROOFSTEP]
rw [htop]
[GOAL]
case pos
R : Type u
inst✝⁴ : CommRing R
inst✝³ : IsNoetherianRing R
A : Type u
inst✝² : CommRing A
inst✝¹ : IsDomain A
inst✝ : IsNoetherianRing A
I M : Ideal R
hgt : ∀ (J : Submodule R R), J > M → (fun I => ∃ Z, Multiset.prod (Multiset.map asIdeal Z) ≤ I) J
h_prM : ¬Ideal.IsPrime M
htop : M = ⊤
⊢ (fun I => ∃ Z, Multiset.prod (Multiset.map asIdeal Z) ≤ I) ⊤
[PROOFSTEP]
exact ⟨0, le_top⟩
[GOAL]
case neg
R : Type u
inst✝⁴ : CommRing R
inst✝³ : IsNoetherianRing R
A : Type u
inst✝² : CommRing A
inst✝¹ : IsDomain A
inst✝ : IsNoetherianRing A
I M : Ideal R
hgt : ∀ (J : Submodule R R), J > M → (fun I => ∃ Z, Multiset.prod (Multiset.map asIdeal Z) ≤ I) J
h_prM : ¬Ideal.IsPrime M
htop : ¬M = ⊤
⊢ (fun I => ∃ Z, Multiset.prod (Multiset.map asIdeal Z) ≤ I) M
[PROOFSTEP]
have lt_add : ∀ (z) (_ : z ∉ M), M < M + span R { z } :=
  by
  intro z hz
  refine' lt_of_le_of_ne le_sup_left fun m_eq => hz _
  rw [m_eq]
  exact Ideal.mem_sup_right (mem_span_singleton_self z)
[GOAL]
R : Type u
inst✝⁴ : CommRing R
inst✝³ : IsNoetherianRing R
A : Type u
inst✝² : CommRing A
inst✝¹ : IsDomain A
inst✝ : IsNoetherianRing A
I M : Ideal R
hgt : ∀ (J : Submodule R R), J > M → (fun I => ∃ Z, Multiset.prod (Multiset.map asIdeal Z) ≤ I) J
h_prM : ¬Ideal.IsPrime M
htop : ¬M = ⊤
⊢ ∀ (z : R), ¬z ∈ M → M < M + span R {z}
[PROOFSTEP]
intro z hz
[GOAL]
R : Type u
inst✝⁴ : CommRing R
inst✝³ : IsNoetherianRing R
A : Type u
inst✝² : CommRing A
inst✝¹ : IsDomain A
inst✝ : IsNoetherianRing A
I M : Ideal R
hgt : ∀ (J : Submodule R R), J > M → (fun I => ∃ Z, Multiset.prod (Multiset.map asIdeal Z) ≤ I) J
h_prM : ¬Ideal.IsPrime M
htop : ¬M = ⊤
z : R
hz : ¬z ∈ M
⊢ M < M + span R {z}
[PROOFSTEP]
refine' lt_of_le_of_ne le_sup_left fun m_eq => hz _
[GOAL]
R : Type u
inst✝⁴ : CommRing R
inst✝³ : IsNoetherianRing R
A : Type u
inst✝² : CommRing A
inst✝¹ : IsDomain A
inst✝ : IsNoetherianRing A
I M : Ideal R
hgt : ∀ (J : Submodule R R), J > M → (fun I => ∃ Z, Multiset.prod (Multiset.map asIdeal Z) ≤ I) J
h_prM : ¬Ideal.IsPrime M
htop : ¬M = ⊤
z : R
hz : ¬z ∈ M
m_eq : M = M + span R {z}
⊢ z ∈ M
[PROOFSTEP]
rw [m_eq]
[GOAL]
R : Type u
inst✝⁴ : CommRing R
inst✝³ : IsNoetherianRing R
A : Type u
inst✝² : CommRing A
inst✝¹ : IsDomain A
inst✝ : IsNoetherianRing A
I M : Ideal R
hgt : ∀ (J : Submodule R R), J > M → (fun I => ∃ Z, Multiset.prod (Multiset.map asIdeal Z) ≤ I) J
h_prM : ¬Ideal.IsPrime M
htop : ¬M = ⊤
z : R
hz : ¬z ∈ M
m_eq : M = M + span R {z}
⊢ z ∈ M + span R {z}
[PROOFSTEP]
exact Ideal.mem_sup_right (mem_span_singleton_self z)
[GOAL]
case neg
R : Type u
inst✝⁴ : CommRing R
inst✝³ : IsNoetherianRing R
A : Type u
inst✝² : CommRing A
inst✝¹ : IsDomain A
inst✝ : IsNoetherianRing A
I M : Ideal R
hgt : ∀ (J : Submodule R R), J > M → (fun I => ∃ Z, Multiset.prod (Multiset.map asIdeal Z) ≤ I) J
h_prM : ¬Ideal.IsPrime M
htop : ¬M = ⊤
lt_add : ∀ (z : R), ¬z ∈ M → M < M + span R {z}
⊢ (fun I => ∃ Z, Multiset.prod (Multiset.map asIdeal Z) ≤ I) M
[PROOFSTEP]
obtain ⟨x, hx, y, hy, hxy⟩ := (Ideal.not_isPrime_iff.mp h_prM).resolve_left htop
[GOAL]
case neg.intro.intro.intro.intro
R : Type u
inst✝⁴ : CommRing R
inst✝³ : IsNoetherianRing R
A : Type u
inst✝² : CommRing A
inst✝¹ : IsDomain A
inst✝ : IsNoetherianRing A
I M : Ideal R
hgt : ∀ (J : Submodule R R), J > M → (fun I => ∃ Z, Multiset.prod (Multiset.map asIdeal Z) ≤ I) J
h_prM : ¬Ideal.IsPrime M
htop : ¬M = ⊤
lt_add : ∀ (z : R), ¬z ∈ M → M < M + span R {z}
x : R
hx : ¬x ∈ M
y : R
hy : ¬y ∈ M
hxy : x * y ∈ M
⊢ (fun I => ∃ Z, Multiset.prod (Multiset.map asIdeal Z) ≤ I) M
[PROOFSTEP]
obtain ⟨Wx, h_Wx⟩ := hgt (M + span R { x }) (lt_add _ hx)
[GOAL]
case neg.intro.intro.intro.intro.intro
R : Type u
inst✝⁴ : CommRing R
inst✝³ : IsNoetherianRing R
A : Type u
inst✝² : CommRing A
inst✝¹ : IsDomain A
inst✝ : IsNoetherianRing A
I M : Ideal R
hgt : ∀ (J : Submodule R R), J > M → (fun I => ∃ Z, Multiset.prod (Multiset.map asIdeal Z) ≤ I) J
h_prM : ¬Ideal.IsPrime M
htop : ¬M = ⊤
lt_add : ∀ (z : R), ¬z ∈ M → M < M + span R {z}
x : R
hx : ¬x ∈ M
y : R
hy : ¬y ∈ M
hxy : x * y ∈ M
Wx : Multiset (PrimeSpectrum R)
h_Wx : Multiset.prod (Multiset.map asIdeal Wx) ≤ M + span R {x}
⊢ (fun I => ∃ Z, Multiset.prod (Multiset.map asIdeal Z) ≤ I) M
[PROOFSTEP]
obtain ⟨Wy, h_Wy⟩ := hgt (M + span R { y }) (lt_add _ hy)
[GOAL]
case neg.intro.intro.intro.intro.intro.intro
R : Type u
inst✝⁴ : CommRing R
inst✝³ : IsNoetherianRing R
A : Type u
inst✝² : CommRing A
inst✝¹ : IsDomain A
inst✝ : IsNoetherianRing A
I M : Ideal R
hgt : ∀ (J : Submodule R R), J > M → (fun I => ∃ Z, Multiset.prod (Multiset.map asIdeal Z) ≤ I) J
h_prM : ¬Ideal.IsPrime M
htop : ¬M = ⊤
lt_add : ∀ (z : R), ¬z ∈ M → M < M + span R {z}
x : R
hx : ¬x ∈ M
y : R
hy : ¬y ∈ M
hxy : x * y ∈ M
Wx : Multiset (PrimeSpectrum R)
h_Wx : Multiset.prod (Multiset.map asIdeal Wx) ≤ M + span R {x}
Wy : Multiset (PrimeSpectrum R)
h_Wy : Multiset.prod (Multiset.map asIdeal Wy) ≤ M + span R {y}
⊢ (fun I => ∃ Z, Multiset.prod (Multiset.map asIdeal Z) ≤ I) M
[PROOFSTEP]
use Wx + Wy
[GOAL]
case h
R : Type u
inst✝⁴ : CommRing R
inst✝³ : IsNoetherianRing R
A : Type u
inst✝² : CommRing A
inst✝¹ : IsDomain A
inst✝ : IsNoetherianRing A
I M : Ideal R
hgt : ∀ (J : Submodule R R), J > M → (fun I => ∃ Z, Multiset.prod (Multiset.map asIdeal Z) ≤ I) J
h_prM : ¬Ideal.IsPrime M
htop : ¬M = ⊤
lt_add : ∀ (z : R), ¬z ∈ M → M < M + span R {z}
x : R
hx : ¬x ∈ M
y : R
hy : ¬y ∈ M
hxy : x * y ∈ M
Wx : Multiset (PrimeSpectrum R)
h_Wx : Multiset.prod (Multiset.map asIdeal Wx) ≤ M + span R {x}
Wy : Multiset (PrimeSpectrum R)
h_Wy : Multiset.prod (Multiset.map asIdeal Wy) ≤ M + span R {y}
⊢ Multiset.prod (Multiset.map asIdeal (Wx + Wy)) ≤ M
[PROOFSTEP]
rw [Multiset.map_add, Multiset.prod_add]
[GOAL]
case h
R : Type u
inst✝⁴ : CommRing R
inst✝³ : IsNoetherianRing R
A : Type u
inst✝² : CommRing A
inst✝¹ : IsDomain A
inst✝ : IsNoetherianRing A
I M : Ideal R
hgt : ∀ (J : Submodule R R), J > M → (fun I => ∃ Z, Multiset.prod (Multiset.map asIdeal Z) ≤ I) J
h_prM : ¬Ideal.IsPrime M
htop : ¬M = ⊤
lt_add : ∀ (z : R), ¬z ∈ M → M < M + span R {z}
x : R
hx : ¬x ∈ M
y : R
hy : ¬y ∈ M
hxy : x * y ∈ M
Wx : Multiset (PrimeSpectrum R)
h_Wx : Multiset.prod (Multiset.map asIdeal Wx) ≤ M + span R {x}
Wy : Multiset (PrimeSpectrum R)
h_Wy : Multiset.prod (Multiset.map asIdeal Wy) ≤ M + span R {y}
⊢ Multiset.prod (Multiset.map asIdeal Wx) * Multiset.prod (Multiset.map asIdeal Wy) ≤ M
[PROOFSTEP]
apply le_trans (Submodule.mul_le_mul h_Wx h_Wy)
[GOAL]
case h
R : Type u
inst✝⁴ : CommRing R
inst✝³ : IsNoetherianRing R
A : Type u
inst✝² : CommRing A
inst✝¹ : IsDomain A
inst✝ : IsNoetherianRing A
I M : Ideal R
hgt : ∀ (J : Submodule R R), J > M → (fun I => ∃ Z, Multiset.prod (Multiset.map asIdeal Z) ≤ I) J
h_prM : ¬Ideal.IsPrime M
htop : ¬M = ⊤
lt_add : ∀ (z : R), ¬z ∈ M → M < M + span R {z}
x : R
hx : ¬x ∈ M
y : R
hy : ¬y ∈ M
hxy : x * y ∈ M
Wx : Multiset (PrimeSpectrum R)
h_Wx : Multiset.prod (Multiset.map asIdeal Wx) ≤ M + span R {x}
Wy : Multiset (PrimeSpectrum R)
h_Wy : Multiset.prod (Multiset.map asIdeal Wy) ≤ M + span R {y}
⊢ (M + span R {x}) * (M + span R {y}) ≤ M
[PROOFSTEP]
rw [add_mul]
[GOAL]
case h
R : Type u
inst✝⁴ : CommRing R
inst✝³ : IsNoetherianRing R
A : Type u
inst✝² : CommRing A
inst✝¹ : IsDomain A
inst✝ : IsNoetherianRing A
I M : Ideal R
hgt : ∀ (J : Submodule R R), J > M → (fun I => ∃ Z, Multiset.prod (Multiset.map asIdeal Z) ≤ I) J
h_prM : ¬Ideal.IsPrime M
htop : ¬M = ⊤
lt_add : ∀ (z : R), ¬z ∈ M → M < M + span R {z}
x : R
hx : ¬x ∈ M
y : R
hy : ¬y ∈ M
hxy : x * y ∈ M
Wx : Multiset (PrimeSpectrum R)
h_Wx : Multiset.prod (Multiset.map asIdeal Wx) ≤ M + span R {x}
Wy : Multiset (PrimeSpectrum R)
h_Wy : Multiset.prod (Multiset.map asIdeal Wy) ≤ M + span R {y}
⊢ M * (M + span R {y}) + span R {x} * (M + span R {y}) ≤ M
[PROOFSTEP]
apply sup_le (show M * (M + span R { y }) ≤ M from Ideal.mul_le_right)
[GOAL]
case h
R : Type u
inst✝⁴ : CommRing R
inst✝³ : IsNoetherianRing R
A : Type u
inst✝² : CommRing A
inst✝¹ : IsDomain A
inst✝ : IsNoetherianRing A
I M : Ideal R
hgt : ∀ (J : Submodule R R), J > M → (fun I => ∃ Z, Multiset.prod (Multiset.map asIdeal Z) ≤ I) J
h_prM : ¬Ideal.IsPrime M
htop : ¬M = ⊤
lt_add : ∀ (z : R), ¬z ∈ M → M < M + span R {z}
x : R
hx : ¬x ∈ M
y : R
hy : ¬y ∈ M
hxy : x * y ∈ M
Wx : Multiset (PrimeSpectrum R)
h_Wx : Multiset.prod (Multiset.map asIdeal Wx) ≤ M + span R {x}
Wy : Multiset (PrimeSpectrum R)
h_Wy : Multiset.prod (Multiset.map asIdeal Wy) ≤ M + span R {y}
⊢ span R {x} * (M + span R {y}) ≤ M
[PROOFSTEP]
rw [mul_add]
[GOAL]
case h
R : Type u
inst✝⁴ : CommRing R
inst✝³ : IsNoetherianRing R
A : Type u
inst✝² : CommRing A
inst✝¹ : IsDomain A
inst✝ : IsNoetherianRing A
I M : Ideal R
hgt : ∀ (J : Submodule R R), J > M → (fun I => ∃ Z, Multiset.prod (Multiset.map asIdeal Z) ≤ I) J
h_prM : ¬Ideal.IsPrime M
htop : ¬M = ⊤
lt_add : ∀ (z : R), ¬z ∈ M → M < M + span R {z}
x : R
hx : ¬x ∈ M
y : R
hy : ¬y ∈ M
hxy : x * y ∈ M
Wx : Multiset (PrimeSpectrum R)
h_Wx : Multiset.prod (Multiset.map asIdeal Wx) ≤ M + span R {x}
Wy : Multiset (PrimeSpectrum R)
h_Wy : Multiset.prod (Multiset.map asIdeal Wy) ≤ M + span R {y}
⊢ span R {x} * M + span R {x} * span R {y} ≤ M
[PROOFSTEP]
apply sup_le (show span R { x } * M ≤ M from Ideal.mul_le_left)
[GOAL]
case h
R : Type u
inst✝⁴ : CommRing R
inst✝³ : IsNoetherianRing R
A : Type u
inst✝² : CommRing A
inst✝¹ : IsDomain A
inst✝ : IsNoetherianRing A
I M : Ideal R
hgt : ∀ (J : Submodule R R), J > M → (fun I => ∃ Z, Multiset.prod (Multiset.map asIdeal Z) ≤ I) J
h_prM : ¬Ideal.IsPrime M
htop : ¬M = ⊤
lt_add : ∀ (z : R), ¬z ∈ M → M < M + span R {z}
x : R
hx : ¬x ∈ M
y : R
hy : ¬y ∈ M
hxy : x * y ∈ M
Wx : Multiset (PrimeSpectrum R)
h_Wx : Multiset.prod (Multiset.map asIdeal Wx) ≤ M + span R {x}
Wy : Multiset (PrimeSpectrum R)
h_Wy : Multiset.prod (Multiset.map asIdeal Wy) ≤ M + span R {y}
⊢ span R {x} * span R {y} ≤ M
[PROOFSTEP]
rwa [span_mul_span, Set.singleton_mul_singleton, span_singleton_le_iff_mem]
[GOAL]
R : Type u
inst✝⁴ : CommRing R
inst✝³ : IsNoetherianRing R
A : Type u
inst✝² : CommRing A
inst✝¹ : IsDomain A
inst✝ : IsNoetherianRing A
h_fA : ¬IsField A
I : Ideal A
h_nzI : I ≠ ⊥
⊢ ∃ Z, Multiset.prod (Multiset.map asIdeal Z) ≤ I ∧ Multiset.prod (Multiset.map asIdeal Z) ≠ ⊥
[PROOFSTEP]
revert h_nzI
[GOAL]
R : Type u
inst✝⁴ : CommRing R
inst✝³ : IsNoetherianRing R
A : Type u
inst✝² : CommRing A
inst✝¹ : IsDomain A
inst✝ : IsNoetherianRing A
h_fA : ¬IsField A
I : Ideal A
⊢ I ≠ ⊥ → ∃ Z, Multiset.prod (Multiset.map asIdeal Z) ≤ I ∧ Multiset.prod (Multiset.map asIdeal Z) ≠ ⊥
[PROOFSTEP]
refine'
  IsNoetherian.induction (P := fun I =>
    I ≠ ⊥ → ∃ Z : Multiset (PrimeSpectrum A), Multiset.prod (Z.map asIdeal) ≤ I ∧ Multiset.prod (Z.map asIdeal) ≠ ⊥)
    (fun (M : Ideal A) hgt => _) I
[GOAL]
R : Type u
inst✝⁴ : CommRing R
inst✝³ : IsNoetherianRing R
A : Type u
inst✝² : CommRing A
inst✝¹ : IsDomain A
inst✝ : IsNoetherianRing A
h_fA : ¬IsField A
I M : Ideal A
hgt :
  ∀ (J : Submodule A A),
    J > M →
      (fun I => I ≠ ⊥ → ∃ Z, Multiset.prod (Multiset.map asIdeal Z) ≤ I ∧ Multiset.prod (Multiset.map asIdeal Z) ≠ ⊥) J
⊢ (fun I => I ≠ ⊥ → ∃ Z, Multiset.prod (Multiset.map asIdeal Z) ≤ I ∧ Multiset.prod (Multiset.map asIdeal Z) ≠ ⊥) M
[PROOFSTEP]
intro h_nzM
[GOAL]
R : Type u
inst✝⁴ : CommRing R
inst✝³ : IsNoetherianRing R
A : Type u
inst✝² : CommRing A
inst✝¹ : IsDomain A
inst✝ : IsNoetherianRing A
h_fA : ¬IsField A
I M : Ideal A
hgt :
  ∀ (J : Submodule A A),
    J > M →
      (fun I => I ≠ ⊥ → ∃ Z, Multiset.prod (Multiset.map asIdeal Z) ≤ I ∧ Multiset.prod (Multiset.map asIdeal Z) ≠ ⊥) J
h_nzM : M ≠ ⊥
⊢ ∃ Z, Multiset.prod (Multiset.map asIdeal Z) ≤ M ∧ Multiset.prod (Multiset.map asIdeal Z) ≠ ⊥
[PROOFSTEP]
have hA_nont : Nontrivial A
[GOAL]
case hA_nont
R : Type u
inst✝⁴ : CommRing R
inst✝³ : IsNoetherianRing R
A : Type u
inst✝² : CommRing A
inst✝¹ : IsDomain A
inst✝ : IsNoetherianRing A
h_fA : ¬IsField A
I M : Ideal A
hgt :
  ∀ (J : Submodule A A),
    J > M →
      (fun I => I ≠ ⊥ → ∃ Z, Multiset.prod (Multiset.map asIdeal Z) ≤ I ∧ Multiset.prod (Multiset.map asIdeal Z) ≠ ⊥) J
h_nzM : M ≠ ⊥
⊢ Nontrivial A
R : Type u
inst✝⁴ : CommRing R
inst✝³ : IsNoetherianRing R
A : Type u
inst✝² : CommRing A
inst✝¹ : IsDomain A
inst✝ : IsNoetherianRing A
h_fA : ¬IsField A
I M : Ideal A
hgt :
  ∀ (J : Submodule A A),
    J > M →
      (fun I => I ≠ ⊥ → ∃ Z, Multiset.prod (Multiset.map asIdeal Z) ≤ I ∧ Multiset.prod (Multiset.map asIdeal Z) ≠ ⊥) J
h_nzM : M ≠ ⊥
hA_nont : Nontrivial A
⊢ ∃ Z, Multiset.prod (Multiset.map asIdeal Z) ≤ M ∧ Multiset.prod (Multiset.map asIdeal Z) ≠ ⊥
[PROOFSTEP]
apply IsDomain.toNontrivial
[GOAL]
R : Type u
inst✝⁴ : CommRing R
inst✝³ : IsNoetherianRing R
A : Type u
inst✝² : CommRing A
inst✝¹ : IsDomain A
inst✝ : IsNoetherianRing A
h_fA : ¬IsField A
I M : Ideal A
hgt :
  ∀ (J : Submodule A A),
    J > M →
      (fun I => I ≠ ⊥ → ∃ Z, Multiset.prod (Multiset.map asIdeal Z) ≤ I ∧ Multiset.prod (Multiset.map asIdeal Z) ≠ ⊥) J
h_nzM : M ≠ ⊥
hA_nont : Nontrivial A
⊢ ∃ Z, Multiset.prod (Multiset.map asIdeal Z) ≤ M ∧ Multiset.prod (Multiset.map asIdeal Z) ≠ ⊥
[PROOFSTEP]
by_cases h_topM : M = ⊤
[GOAL]
case pos
R : Type u
inst✝⁴ : CommRing R
inst✝³ : IsNoetherianRing R
A : Type u
inst✝² : CommRing A
inst✝¹ : IsDomain A
inst✝ : IsNoetherianRing A
h_fA : ¬IsField A
I M : Ideal A
hgt :
  ∀ (J : Submodule A A),
    J > M →
      (fun I => I ≠ ⊥ → ∃ Z, Multiset.prod (Multiset.map asIdeal Z) ≤ I ∧ Multiset.prod (Multiset.map asIdeal Z) ≠ ⊥) J
h_nzM : M ≠ ⊥
hA_nont : Nontrivial A
h_topM : M = ⊤
⊢ ∃ Z, Multiset.prod (Multiset.map asIdeal Z) ≤ M ∧ Multiset.prod (Multiset.map asIdeal Z) ≠ ⊥
[PROOFSTEP]
rcases h_topM with rfl
[GOAL]
case pos
R : Type u
inst✝⁴ : CommRing R
inst✝³ : IsNoetherianRing R
A : Type u
inst✝² : CommRing A
inst✝¹ : IsDomain A
inst✝ : IsNoetherianRing A
h_fA : ¬IsField A
I : Ideal A
hA_nont : Nontrivial A
hgt :
  ∀ (J : Submodule A A),
    J > ⊤ →
      (fun I => I ≠ ⊥ → ∃ Z, Multiset.prod (Multiset.map asIdeal Z) ≤ I ∧ Multiset.prod (Multiset.map asIdeal Z) ≠ ⊥) J
h_nzM : ⊤ ≠ ⊥
⊢ ∃ Z, Multiset.prod (Multiset.map asIdeal Z) ≤ ⊤ ∧ Multiset.prod (Multiset.map asIdeal Z) ≠ ⊥
[PROOFSTEP]
obtain ⟨p_id, h_nzp, h_pp⟩ : ∃ p : Ideal A, p ≠ ⊥ ∧ p.IsPrime := by apply Ring.not_isField_iff_exists_prime.mp h_fA
[GOAL]
R : Type u
inst✝⁴ : CommRing R
inst✝³ : IsNoetherianRing R
A : Type u
inst✝² : CommRing A
inst✝¹ : IsDomain A
inst✝ : IsNoetherianRing A
h_fA : ¬IsField A
I : Ideal A
hA_nont : Nontrivial A
hgt :
  ∀ (J : Submodule A A),
    J > ⊤ →
      (fun I => I ≠ ⊥ → ∃ Z, Multiset.prod (Multiset.map asIdeal Z) ≤ I ∧ Multiset.prod (Multiset.map asIdeal Z) ≠ ⊥) J
h_nzM : ⊤ ≠ ⊥
⊢ ∃ p, p ≠ ⊥ ∧ Ideal.IsPrime p
[PROOFSTEP]
apply Ring.not_isField_iff_exists_prime.mp h_fA
[GOAL]
case pos.intro.intro
R : Type u
inst✝⁴ : CommRing R
inst✝³ : IsNoetherianRing R
A : Type u
inst✝² : CommRing A
inst✝¹ : IsDomain A
inst✝ : IsNoetherianRing A
h_fA : ¬IsField A
I : Ideal A
hA_nont : Nontrivial A
hgt :
  ∀ (J : Submodule A A),
    J > ⊤ →
      (fun I => I ≠ ⊥ → ∃ Z, Multiset.prod (Multiset.map asIdeal Z) ≤ I ∧ Multiset.prod (Multiset.map asIdeal Z) ≠ ⊥) J
h_nzM : ⊤ ≠ ⊥
p_id : Ideal A
h_nzp : p_id ≠ ⊥
h_pp : Ideal.IsPrime p_id
⊢ ∃ Z, Multiset.prod (Multiset.map asIdeal Z) ≤ ⊤ ∧ Multiset.prod (Multiset.map asIdeal Z) ≠ ⊥
[PROOFSTEP]
use({⟨p_id, h_pp⟩} : Multiset (PrimeSpectrum A)), le_top
[GOAL]
case right
R : Type u
inst✝⁴ : CommRing R
inst✝³ : IsNoetherianRing R
A : Type u
inst✝² : CommRing A
inst✝¹ : IsDomain A
inst✝ : IsNoetherianRing A
h_fA : ¬IsField A
I : Ideal A
hA_nont : Nontrivial A
hgt :
  ∀ (J : Submodule A A),
    J > ⊤ →
      (fun I => I ≠ ⊥ → ∃ Z, Multiset.prod (Multiset.map asIdeal Z) ≤ I ∧ Multiset.prod (Multiset.map asIdeal Z) ≠ ⊥) J
h_nzM : ⊤ ≠ ⊥
p_id : Ideal A
h_nzp : p_id ≠ ⊥
h_pp : Ideal.IsPrime p_id
⊢ Multiset.prod (Multiset.map asIdeal {{ asIdeal := p_id, IsPrime := h_pp }}) ≠ ⊥
[PROOFSTEP]
rwa [Multiset.map_singleton, Multiset.prod_singleton]
[GOAL]
case neg
R : Type u
inst✝⁴ : CommRing R
inst✝³ : IsNoetherianRing R
A : Type u
inst✝² : CommRing A
inst✝¹ : IsDomain A
inst✝ : IsNoetherianRing A
h_fA : ¬IsField A
I M : Ideal A
hgt :
  ∀ (J : Submodule A A),
    J > M →
      (fun I => I ≠ ⊥ → ∃ Z, Multiset.prod (Multiset.map asIdeal Z) ≤ I ∧ Multiset.prod (Multiset.map asIdeal Z) ≠ ⊥) J
h_nzM : M ≠ ⊥
hA_nont : Nontrivial A
h_topM : ¬M = ⊤
⊢ ∃ Z, Multiset.prod (Multiset.map asIdeal Z) ≤ M ∧ Multiset.prod (Multiset.map asIdeal Z) ≠ ⊥
[PROOFSTEP]
by_cases h_prM : M.IsPrime
[GOAL]
case pos
R : Type u
inst✝⁴ : CommRing R
inst✝³ : IsNoetherianRing R
A : Type u
inst✝² : CommRing A
inst✝¹ : IsDomain A
inst✝ : IsNoetherianRing A
h_fA : ¬IsField A
I M : Ideal A
hgt :
  ∀ (J : Submodule A A),
    J > M →
      (fun I => I ≠ ⊥ → ∃ Z, Multiset.prod (Multiset.map asIdeal Z) ≤ I ∧ Multiset.prod (Multiset.map asIdeal Z) ≠ ⊥) J
h_nzM : M ≠ ⊥
hA_nont : Nontrivial A
h_topM : ¬M = ⊤
h_prM : Ideal.IsPrime M
⊢ ∃ Z, Multiset.prod (Multiset.map asIdeal Z) ≤ M ∧ Multiset.prod (Multiset.map asIdeal Z) ≠ ⊥
[PROOFSTEP]
use({⟨M, h_prM⟩} : Multiset (PrimeSpectrum A))
[GOAL]
case h
R : Type u
inst✝⁴ : CommRing R
inst✝³ : IsNoetherianRing R
A : Type u
inst✝² : CommRing A
inst✝¹ : IsDomain A
inst✝ : IsNoetherianRing A
h_fA : ¬IsField A
I M : Ideal A
hgt :
  ∀ (J : Submodule A A),
    J > M →
      (fun I => I ≠ ⊥ → ∃ Z, Multiset.prod (Multiset.map asIdeal Z) ≤ I ∧ Multiset.prod (Multiset.map asIdeal Z) ≠ ⊥) J
h_nzM : M ≠ ⊥
hA_nont : Nontrivial A
h_topM : ¬M = ⊤
h_prM : Ideal.IsPrime M
⊢ Multiset.prod (Multiset.map asIdeal {{ asIdeal := M, IsPrime := h_prM }}) ≤ M ∧
    Multiset.prod (Multiset.map asIdeal {{ asIdeal := M, IsPrime := h_prM }}) ≠ ⊥
[PROOFSTEP]
rw [Multiset.map_singleton, Multiset.prod_singleton]
[GOAL]
case h
R : Type u
inst✝⁴ : CommRing R
inst✝³ : IsNoetherianRing R
A : Type u
inst✝² : CommRing A
inst✝¹ : IsDomain A
inst✝ : IsNoetherianRing A
h_fA : ¬IsField A
I M : Ideal A
hgt :
  ∀ (J : Submodule A A),
    J > M →
      (fun I => I ≠ ⊥ → ∃ Z, Multiset.prod (Multiset.map asIdeal Z) ≤ I ∧ Multiset.prod (Multiset.map asIdeal Z) ≠ ⊥) J
h_nzM : M ≠ ⊥
hA_nont : Nontrivial A
h_topM : ¬M = ⊤
h_prM : Ideal.IsPrime M
⊢ { asIdeal := M, IsPrime := h_prM }.asIdeal ≤ M ∧ { asIdeal := M, IsPrime := h_prM }.asIdeal ≠ ⊥
[PROOFSTEP]
exact ⟨le_rfl, h_nzM⟩
[GOAL]
case neg
R : Type u
inst✝⁴ : CommRing R
inst✝³ : IsNoetherianRing R
A : Type u
inst✝² : CommRing A
inst✝¹ : IsDomain A
inst✝ : IsNoetherianRing A
h_fA : ¬IsField A
I M : Ideal A
hgt :
  ∀ (J : Submodule A A),
    J > M →
      (fun I => I ≠ ⊥ → ∃ Z, Multiset.prod (Multiset.map asIdeal Z) ≤ I ∧ Multiset.prod (Multiset.map asIdeal Z) ≠ ⊥) J
h_nzM : M ≠ ⊥
hA_nont : Nontrivial A
h_topM : ¬M = ⊤
h_prM : ¬Ideal.IsPrime M
⊢ ∃ Z, Multiset.prod (Multiset.map asIdeal Z) ≤ M ∧ Multiset.prod (Multiset.map asIdeal Z) ≠ ⊥
[PROOFSTEP]
obtain ⟨x, hx, y, hy, h_xy⟩ := (Ideal.not_isPrime_iff.mp h_prM).resolve_left h_topM
[GOAL]
case neg.intro.intro.intro.intro
R : Type u
inst✝⁴ : CommRing R
inst✝³ : IsNoetherianRing R
A : Type u
inst✝² : CommRing A
inst✝¹ : IsDomain A
inst✝ : IsNoetherianRing A
h_fA : ¬IsField A
I M : Ideal A
hgt :
  ∀ (J : Submodule A A),
    J > M →
      (fun I => I ≠ ⊥ → ∃ Z, Multiset.prod (Multiset.map asIdeal Z) ≤ I ∧ Multiset.prod (Multiset.map asIdeal Z) ≠ ⊥) J
h_nzM : M ≠ ⊥
hA_nont : Nontrivial A
h_topM : ¬M = ⊤
h_prM : ¬Ideal.IsPrime M
x : A
hx : ¬x ∈ M
y : A
hy : ¬y ∈ M
h_xy : x * y ∈ M
⊢ ∃ Z, Multiset.prod (Multiset.map asIdeal Z) ≤ M ∧ Multiset.prod (Multiset.map asIdeal Z) ≠ ⊥
[PROOFSTEP]
have lt_add : ∀ (z) (_ : z ∉ M), M < M + span A { z } :=
  by
  intro z hz
  refine' lt_of_le_of_ne le_sup_left fun m_eq => hz _
  rw [m_eq]
  exact mem_sup_right (mem_span_singleton_self z)
[GOAL]
R : Type u
inst✝⁴ : CommRing R
inst✝³ : IsNoetherianRing R
A : Type u
inst✝² : CommRing A
inst✝¹ : IsDomain A
inst✝ : IsNoetherianRing A
h_fA : ¬IsField A
I M : Ideal A
hgt :
  ∀ (J : Submodule A A),
    J > M →
      (fun I => I ≠ ⊥ → ∃ Z, Multiset.prod (Multiset.map asIdeal Z) ≤ I ∧ Multiset.prod (Multiset.map asIdeal Z) ≠ ⊥) J
h_nzM : M ≠ ⊥
hA_nont : Nontrivial A
h_topM : ¬M = ⊤
h_prM : ¬Ideal.IsPrime M
x : A
hx : ¬x ∈ M
y : A
hy : ¬y ∈ M
h_xy : x * y ∈ M
⊢ ∀ (z : A), ¬z ∈ M → M < M + span A {z}
[PROOFSTEP]
intro z hz
[GOAL]
R : Type u
inst✝⁴ : CommRing R
inst✝³ : IsNoetherianRing R
A : Type u
inst✝² : CommRing A
inst✝¹ : IsDomain A
inst✝ : IsNoetherianRing A
h_fA : ¬IsField A
I M : Ideal A
hgt :
  ∀ (J : Submodule A A),
    J > M →
      (fun I => I ≠ ⊥ → ∃ Z, Multiset.prod (Multiset.map asIdeal Z) ≤ I ∧ Multiset.prod (Multiset.map asIdeal Z) ≠ ⊥) J
h_nzM : M ≠ ⊥
hA_nont : Nontrivial A
h_topM : ¬M = ⊤
h_prM : ¬Ideal.IsPrime M
x : A
hx : ¬x ∈ M
y : A
hy : ¬y ∈ M
h_xy : x * y ∈ M
z : A
hz : ¬z ∈ M
⊢ M < M + span A {z}
[PROOFSTEP]
refine' lt_of_le_of_ne le_sup_left fun m_eq => hz _
[GOAL]
R : Type u
inst✝⁴ : CommRing R
inst✝³ : IsNoetherianRing R
A : Type u
inst✝² : CommRing A
inst✝¹ : IsDomain A
inst✝ : IsNoetherianRing A
h_fA : ¬IsField A
I M : Ideal A
hgt :
  ∀ (J : Submodule A A),
    J > M →
      (fun I => I ≠ ⊥ → ∃ Z, Multiset.prod (Multiset.map asIdeal Z) ≤ I ∧ Multiset.prod (Multiset.map asIdeal Z) ≠ ⊥) J
h_nzM : M ≠ ⊥
hA_nont : Nontrivial A
h_topM : ¬M = ⊤
h_prM : ¬Ideal.IsPrime M
x : A
hx : ¬x ∈ M
y : A
hy : ¬y ∈ M
h_xy : x * y ∈ M
z : A
hz : ¬z ∈ M
m_eq : M = M + span A {z}
⊢ z ∈ M
[PROOFSTEP]
rw [m_eq]
[GOAL]
R : Type u
inst✝⁴ : CommRing R
inst✝³ : IsNoetherianRing R
A : Type u
inst✝² : CommRing A
inst✝¹ : IsDomain A
inst✝ : IsNoetherianRing A
h_fA : ¬IsField A
I M : Ideal A
hgt :
  ∀ (J : Submodule A A),
    J > M →
      (fun I => I ≠ ⊥ → ∃ Z, Multiset.prod (Multiset.map asIdeal Z) ≤ I ∧ Multiset.prod (Multiset.map asIdeal Z) ≠ ⊥) J
h_nzM : M ≠ ⊥
hA_nont : Nontrivial A
h_topM : ¬M = ⊤
h_prM : ¬Ideal.IsPrime M
x : A
hx : ¬x ∈ M
y : A
hy : ¬y ∈ M
h_xy : x * y ∈ M
z : A
hz : ¬z ∈ M
m_eq : M = M + span A {z}
⊢ z ∈ M + span A {z}
[PROOFSTEP]
exact mem_sup_right (mem_span_singleton_self z)
[GOAL]
case neg.intro.intro.intro.intro
R : Type u
inst✝⁴ : CommRing R
inst✝³ : IsNoetherianRing R
A : Type u
inst✝² : CommRing A
inst✝¹ : IsDomain A
inst✝ : IsNoetherianRing A
h_fA : ¬IsField A
I M : Ideal A
hgt :
  ∀ (J : Submodule A A),
    J > M →
      (fun I => I ≠ ⊥ → ∃ Z, Multiset.prod (Multiset.map asIdeal Z) ≤ I ∧ Multiset.prod (Multiset.map asIdeal Z) ≠ ⊥) J
h_nzM : M ≠ ⊥
hA_nont : Nontrivial A
h_topM : ¬M = ⊤
h_prM : ¬Ideal.IsPrime M
x : A
hx : ¬x ∈ M
y : A
hy : ¬y ∈ M
h_xy : x * y ∈ M
lt_add : ∀ (z : A), ¬z ∈ M → M < M + span A {z}
⊢ ∃ Z, Multiset.prod (Multiset.map asIdeal Z) ≤ M ∧ Multiset.prod (Multiset.map asIdeal Z) ≠ ⊥
[PROOFSTEP]
obtain ⟨Wx, h_Wx_le, h_Wx_ne⟩ := hgt (M + span A { x }) (lt_add _ hx) (ne_bot_of_gt (lt_add _ hx))
[GOAL]
case neg.intro.intro.intro.intro.intro.intro
R : Type u
inst✝⁴ : CommRing R
inst✝³ : IsNoetherianRing R
A : Type u
inst✝² : CommRing A
inst✝¹ : IsDomain A
inst✝ : IsNoetherianRing A
h_fA : ¬IsField A
I M : Ideal A
hgt :
  ∀ (J : Submodule A A),
    J > M →
      (fun I => I ≠ ⊥ → ∃ Z, Multiset.prod (Multiset.map asIdeal Z) ≤ I ∧ Multiset.prod (Multiset.map asIdeal Z) ≠ ⊥) J
h_nzM : M ≠ ⊥
hA_nont : Nontrivial A
h_topM : ¬M = ⊤
h_prM : ¬Ideal.IsPrime M
x : A
hx : ¬x ∈ M
y : A
hy : ¬y ∈ M
h_xy : x * y ∈ M
lt_add : ∀ (z : A), ¬z ∈ M → M < M + span A {z}
Wx : Multiset (PrimeSpectrum A)
h_Wx_le : Multiset.prod (Multiset.map asIdeal Wx) ≤ M + span A {x}
h_Wx_ne : Multiset.prod (Multiset.map asIdeal Wx) ≠ ⊥
⊢ ∃ Z, Multiset.prod (Multiset.map asIdeal Z) ≤ M ∧ Multiset.prod (Multiset.map asIdeal Z) ≠ ⊥
[PROOFSTEP]
obtain ⟨Wy, h_Wy_le, h_Wx_ne⟩ := hgt (M + span A { y }) (lt_add _ hy) (ne_bot_of_gt (lt_add _ hy))
[GOAL]
case neg.intro.intro.intro.intro.intro.intro.intro.intro
R : Type u
inst✝⁴ : CommRing R
inst✝³ : IsNoetherianRing R
A : Type u
inst✝² : CommRing A
inst✝¹ : IsDomain A
inst✝ : IsNoetherianRing A
h_fA : ¬IsField A
I M : Ideal A
hgt :
  ∀ (J : Submodule A A),
    J > M →
      (fun I => I ≠ ⊥ → ∃ Z, Multiset.prod (Multiset.map asIdeal Z) ≤ I ∧ Multiset.prod (Multiset.map asIdeal Z) ≠ ⊥) J
h_nzM : M ≠ ⊥
hA_nont : Nontrivial A
h_topM : ¬M = ⊤
h_prM : ¬Ideal.IsPrime M
x : A
hx : ¬x ∈ M
y : A
hy : ¬y ∈ M
h_xy : x * y ∈ M
lt_add : ∀ (z : A), ¬z ∈ M → M < M + span A {z}
Wx : Multiset (PrimeSpectrum A)
h_Wx_le : Multiset.prod (Multiset.map asIdeal Wx) ≤ M + span A {x}
h_Wx_ne✝ : Multiset.prod (Multiset.map asIdeal Wx) ≠ ⊥
Wy : Multiset (PrimeSpectrum A)
h_Wy_le : Multiset.prod (Multiset.map asIdeal Wy) ≤ M + span A {y}
h_Wx_ne : Multiset.prod (Multiset.map asIdeal Wy) ≠ ⊥
⊢ ∃ Z, Multiset.prod (Multiset.map asIdeal Z) ≤ M ∧ Multiset.prod (Multiset.map asIdeal Z) ≠ ⊥
[PROOFSTEP]
use Wx + Wy
[GOAL]
case h
R : Type u
inst✝⁴ : CommRing R
inst✝³ : IsNoetherianRing R
A : Type u
inst✝² : CommRing A
inst✝¹ : IsDomain A
inst✝ : IsNoetherianRing A
h_fA : ¬IsField A
I M : Ideal A
hgt :
  ∀ (J : Submodule A A),
    J > M →
      (fun I => I ≠ ⊥ → ∃ Z, Multiset.prod (Multiset.map asIdeal Z) ≤ I ∧ Multiset.prod (Multiset.map asIdeal Z) ≠ ⊥) J
h_nzM : M ≠ ⊥
hA_nont : Nontrivial A
h_topM : ¬M = ⊤
h_prM : ¬Ideal.IsPrime M
x : A
hx : ¬x ∈ M
y : A
hy : ¬y ∈ M
h_xy : x * y ∈ M
lt_add : ∀ (z : A), ¬z ∈ M → M < M + span A {z}
Wx : Multiset (PrimeSpectrum A)
h_Wx_le : Multiset.prod (Multiset.map asIdeal Wx) ≤ M + span A {x}
h_Wx_ne✝ : Multiset.prod (Multiset.map asIdeal Wx) ≠ ⊥
Wy : Multiset (PrimeSpectrum A)
h_Wy_le : Multiset.prod (Multiset.map asIdeal Wy) ≤ M + span A {y}
h_Wx_ne : Multiset.prod (Multiset.map asIdeal Wy) ≠ ⊥
⊢ Multiset.prod (Multiset.map asIdeal (Wx + Wy)) ≤ M ∧ Multiset.prod (Multiset.map asIdeal (Wx + Wy)) ≠ ⊥
[PROOFSTEP]
rw [Multiset.map_add, Multiset.prod_add]
[GOAL]
case h
R : Type u
inst✝⁴ : CommRing R
inst✝³ : IsNoetherianRing R
A : Type u
inst✝² : CommRing A
inst✝¹ : IsDomain A
inst✝ : IsNoetherianRing A
h_fA : ¬IsField A
I M : Ideal A
hgt :
  ∀ (J : Submodule A A),
    J > M →
      (fun I => I ≠ ⊥ → ∃ Z, Multiset.prod (Multiset.map asIdeal Z) ≤ I ∧ Multiset.prod (Multiset.map asIdeal Z) ≠ ⊥) J
h_nzM : M ≠ ⊥
hA_nont : Nontrivial A
h_topM : ¬M = ⊤
h_prM : ¬Ideal.IsPrime M
x : A
hx : ¬x ∈ M
y : A
hy : ¬y ∈ M
h_xy : x * y ∈ M
lt_add : ∀ (z : A), ¬z ∈ M → M < M + span A {z}
Wx : Multiset (PrimeSpectrum A)
h_Wx_le : Multiset.prod (Multiset.map asIdeal Wx) ≤ M + span A {x}
h_Wx_ne✝ : Multiset.prod (Multiset.map asIdeal Wx) ≠ ⊥
Wy : Multiset (PrimeSpectrum A)
h_Wy_le : Multiset.prod (Multiset.map asIdeal Wy) ≤ M + span A {y}
h_Wx_ne : Multiset.prod (Multiset.map asIdeal Wy) ≠ ⊥
⊢ Multiset.prod (Multiset.map asIdeal Wx) * Multiset.prod (Multiset.map asIdeal Wy) ≤ M ∧
    Multiset.prod (Multiset.map asIdeal Wx) * Multiset.prod (Multiset.map asIdeal Wy) ≠ ⊥
[PROOFSTEP]
refine' ⟨le_trans (Submodule.mul_le_mul h_Wx_le h_Wy_le) _, mt Ideal.mul_eq_bot.mp _⟩
[GOAL]
case h.refine'_1
R : Type u
inst✝⁴ : CommRing R
inst✝³ : IsNoetherianRing R
A : Type u
inst✝² : CommRing A
inst✝¹ : IsDomain A
inst✝ : IsNoetherianRing A
h_fA : ¬IsField A
I M : Ideal A
hgt :
  ∀ (J : Submodule A A),
    J > M →
      (fun I => I ≠ ⊥ → ∃ Z, Multiset.prod (Multiset.map asIdeal Z) ≤ I ∧ Multiset.prod (Multiset.map asIdeal Z) ≠ ⊥) J
h_nzM : M ≠ ⊥
hA_nont : Nontrivial A
h_topM : ¬M = ⊤
h_prM : ¬Ideal.IsPrime M
x : A
hx : ¬x ∈ M
y : A
hy : ¬y ∈ M
h_xy : x * y ∈ M
lt_add : ∀ (z : A), ¬z ∈ M → M < M + span A {z}
Wx : Multiset (PrimeSpectrum A)
h_Wx_le : Multiset.prod (Multiset.map asIdeal Wx) ≤ M + span A {x}
h_Wx_ne✝ : Multiset.prod (Multiset.map asIdeal Wx) ≠ ⊥
Wy : Multiset (PrimeSpectrum A)
h_Wy_le : Multiset.prod (Multiset.map asIdeal Wy) ≤ M + span A {y}
h_Wx_ne : Multiset.prod (Multiset.map asIdeal Wy) ≠ ⊥
⊢ (M + span A {x}) * (M + span A {y}) ≤ M
[PROOFSTEP]
rw [add_mul]
[GOAL]
case h.refine'_1
R : Type u
inst✝⁴ : CommRing R
inst✝³ : IsNoetherianRing R
A : Type u
inst✝² : CommRing A
inst✝¹ : IsDomain A
inst✝ : IsNoetherianRing A
h_fA : ¬IsField A
I M : Ideal A
hgt :
  ∀ (J : Submodule A A),
    J > M →
      (fun I => I ≠ ⊥ → ∃ Z, Multiset.prod (Multiset.map asIdeal Z) ≤ I ∧ Multiset.prod (Multiset.map asIdeal Z) ≠ ⊥) J
h_nzM : M ≠ ⊥
hA_nont : Nontrivial A
h_topM : ¬M = ⊤
h_prM : ¬Ideal.IsPrime M
x : A
hx : ¬x ∈ M
y : A
hy : ¬y ∈ M
h_xy : x * y ∈ M
lt_add : ∀ (z : A), ¬z ∈ M → M < M + span A {z}
Wx : Multiset (PrimeSpectrum A)
h_Wx_le : Multiset.prod (Multiset.map asIdeal Wx) ≤ M + span A {x}
h_Wx_ne✝ : Multiset.prod (Multiset.map asIdeal Wx) ≠ ⊥
Wy : Multiset (PrimeSpectrum A)
h_Wy_le : Multiset.prod (Multiset.map asIdeal Wy) ≤ M + span A {y}
h_Wx_ne : Multiset.prod (Multiset.map asIdeal Wy) ≠ ⊥
⊢ M * (M + span A {y}) + span A {x} * (M + span A {y}) ≤ M
[PROOFSTEP]
apply sup_le (show M * (M + span A { y }) ≤ M from Ideal.mul_le_right)
[GOAL]
case h.refine'_1
R : Type u
inst✝⁴ : CommRing R
inst✝³ : IsNoetherianRing R
A : Type u
inst✝² : CommRing A
inst✝¹ : IsDomain A
inst✝ : IsNoetherianRing A
h_fA : ¬IsField A
I M : Ideal A
hgt :
  ∀ (J : Submodule A A),
    J > M →
      (fun I => I ≠ ⊥ → ∃ Z, Multiset.prod (Multiset.map asIdeal Z) ≤ I ∧ Multiset.prod (Multiset.map asIdeal Z) ≠ ⊥) J
h_nzM : M ≠ ⊥
hA_nont : Nontrivial A
h_topM : ¬M = ⊤
h_prM : ¬Ideal.IsPrime M
x : A
hx : ¬x ∈ M
y : A
hy : ¬y ∈ M
h_xy : x * y ∈ M
lt_add : ∀ (z : A), ¬z ∈ M → M < M + span A {z}
Wx : Multiset (PrimeSpectrum A)
h_Wx_le : Multiset.prod (Multiset.map asIdeal Wx) ≤ M + span A {x}
h_Wx_ne✝ : Multiset.prod (Multiset.map asIdeal Wx) ≠ ⊥
Wy : Multiset (PrimeSpectrum A)
h_Wy_le : Multiset.prod (Multiset.map asIdeal Wy) ≤ M + span A {y}
h_Wx_ne : Multiset.prod (Multiset.map asIdeal Wy) ≠ ⊥
⊢ span A {x} * (M + span A {y}) ≤ M
[PROOFSTEP]
rw [mul_add]
[GOAL]
case h.refine'_1
R : Type u
inst✝⁴ : CommRing R
inst✝³ : IsNoetherianRing R
A : Type u
inst✝² : CommRing A
inst✝¹ : IsDomain A
inst✝ : IsNoetherianRing A
h_fA : ¬IsField A
I M : Ideal A
hgt :
  ∀ (J : Submodule A A),
    J > M →
      (fun I => I ≠ ⊥ → ∃ Z, Multiset.prod (Multiset.map asIdeal Z) ≤ I ∧ Multiset.prod (Multiset.map asIdeal Z) ≠ ⊥) J
h_nzM : M ≠ ⊥
hA_nont : Nontrivial A
h_topM : ¬M = ⊤
h_prM : ¬Ideal.IsPrime M
x : A
hx : ¬x ∈ M
y : A
hy : ¬y ∈ M
h_xy : x * y ∈ M
lt_add : ∀ (z : A), ¬z ∈ M → M < M + span A {z}
Wx : Multiset (PrimeSpectrum A)
h_Wx_le : Multiset.prod (Multiset.map asIdeal Wx) ≤ M + span A {x}
h_Wx_ne✝ : Multiset.prod (Multiset.map asIdeal Wx) ≠ ⊥
Wy : Multiset (PrimeSpectrum A)
h_Wy_le : Multiset.prod (Multiset.map asIdeal Wy) ≤ M + span A {y}
h_Wx_ne : Multiset.prod (Multiset.map asIdeal Wy) ≠ ⊥
⊢ span A {x} * M + span A {x} * span A {y} ≤ M
[PROOFSTEP]
apply sup_le (show span A { x } * M ≤ M from Ideal.mul_le_left)
[GOAL]
case h.refine'_1
R : Type u
inst✝⁴ : CommRing R
inst✝³ : IsNoetherianRing R
A : Type u
inst✝² : CommRing A
inst✝¹ : IsDomain A
inst✝ : IsNoetherianRing A
h_fA : ¬IsField A
I M : Ideal A
hgt :
  ∀ (J : Submodule A A),
    J > M →
      (fun I => I ≠ ⊥ → ∃ Z, Multiset.prod (Multiset.map asIdeal Z) ≤ I ∧ Multiset.prod (Multiset.map asIdeal Z) ≠ ⊥) J
h_nzM : M ≠ ⊥
hA_nont : Nontrivial A
h_topM : ¬M = ⊤
h_prM : ¬Ideal.IsPrime M
x : A
hx : ¬x ∈ M
y : A
hy : ¬y ∈ M
h_xy : x * y ∈ M
lt_add : ∀ (z : A), ¬z ∈ M → M < M + span A {z}
Wx : Multiset (PrimeSpectrum A)
h_Wx_le : Multiset.prod (Multiset.map asIdeal Wx) ≤ M + span A {x}
h_Wx_ne✝ : Multiset.prod (Multiset.map asIdeal Wx) ≠ ⊥
Wy : Multiset (PrimeSpectrum A)
h_Wy_le : Multiset.prod (Multiset.map asIdeal Wy) ≤ M + span A {y}
h_Wx_ne : Multiset.prod (Multiset.map asIdeal Wy) ≠ ⊥
⊢ span A {x} * span A {y} ≤ M
[PROOFSTEP]
rwa [span_mul_span, Set.singleton_mul_singleton, span_singleton_le_iff_mem]
[GOAL]
case h.refine'_2
R : Type u
inst✝⁴ : CommRing R
inst✝³ : IsNoetherianRing R
A : Type u
inst✝² : CommRing A
inst✝¹ : IsDomain A
inst✝ : IsNoetherianRing A
h_fA : ¬IsField A
I M : Ideal A
hgt :
  ∀ (J : Submodule A A),
    J > M →
      (fun I => I ≠ ⊥ → ∃ Z, Multiset.prod (Multiset.map asIdeal Z) ≤ I ∧ Multiset.prod (Multiset.map asIdeal Z) ≠ ⊥) J
h_nzM : M ≠ ⊥
hA_nont : Nontrivial A
h_topM : ¬M = ⊤
h_prM : ¬Ideal.IsPrime M
x : A
hx : ¬x ∈ M
y : A
hy : ¬y ∈ M
h_xy : x * y ∈ M
lt_add : ∀ (z : A), ¬z ∈ M → M < M + span A {z}
Wx : Multiset (PrimeSpectrum A)
h_Wx_le : Multiset.prod (Multiset.map asIdeal Wx) ≤ M + span A {x}
h_Wx_ne✝ : Multiset.prod (Multiset.map asIdeal Wx) ≠ ⊥
Wy : Multiset (PrimeSpectrum A)
h_Wy_le : Multiset.prod (Multiset.map asIdeal Wy) ≤ M + span A {y}
h_Wx_ne : Multiset.prod (Multiset.map asIdeal Wy) ≠ ⊥
⊢ ¬(Multiset.prod (Multiset.map asIdeal Wx) = ⊥ ∨ Multiset.prod (Multiset.map asIdeal Wy) = ⊥)
[PROOFSTEP]
rintro (hx | hy)
[GOAL]
case h.refine'_2.inl
R : Type u
inst✝⁴ : CommRing R
inst✝³ : IsNoetherianRing R
A : Type u
inst✝² : CommRing A
inst✝¹ : IsDomain A
inst✝ : IsNoetherianRing A
h_fA : ¬IsField A
I M : Ideal A
hgt :
  ∀ (J : Submodule A A),
    J > M →
      (fun I => I ≠ ⊥ → ∃ Z, Multiset.prod (Multiset.map asIdeal Z) ≤ I ∧ Multiset.prod (Multiset.map asIdeal Z) ≠ ⊥) J
h_nzM : M ≠ ⊥
hA_nont : Nontrivial A
h_topM : ¬M = ⊤
h_prM : ¬Ideal.IsPrime M
x : A
hx✝ : ¬x ∈ M
y : A
hy : ¬y ∈ M
h_xy : x * y ∈ M
lt_add : ∀ (z : A), ¬z ∈ M → M < M + span A {z}
Wx : Multiset (PrimeSpectrum A)
h_Wx_le : Multiset.prod (Multiset.map asIdeal Wx) ≤ M + span A {x}
h_Wx_ne✝ : Multiset.prod (Multiset.map asIdeal Wx) ≠ ⊥
Wy : Multiset (PrimeSpectrum A)
h_Wy_le : Multiset.prod (Multiset.map asIdeal Wy) ≤ M + span A {y}
h_Wx_ne : Multiset.prod (Multiset.map asIdeal Wy) ≠ ⊥
hx : Multiset.prod (Multiset.map asIdeal Wx) = ⊥
⊢ False
[PROOFSTEP]
contradiction
[GOAL]
case h.refine'_2.inr
R : Type u
inst✝⁴ : CommRing R
inst✝³ : IsNoetherianRing R
A : Type u
inst✝² : CommRing A
inst✝¹ : IsDomain A
inst✝ : IsNoetherianRing A
h_fA : ¬IsField A
I M : Ideal A
hgt :
  ∀ (J : Submodule A A),
    J > M →
      (fun I => I ≠ ⊥ → ∃ Z, Multiset.prod (Multiset.map asIdeal Z) ≤ I ∧ Multiset.prod (Multiset.map asIdeal Z) ≠ ⊥) J
h_nzM : M ≠ ⊥
hA_nont : Nontrivial A
h_topM : ¬M = ⊤
h_prM : ¬Ideal.IsPrime M
x : A
hx : ¬x ∈ M
y : A
hy✝ : ¬y ∈ M
h_xy : x * y ∈ M
lt_add : ∀ (z : A), ¬z ∈ M → M < M + span A {z}
Wx : Multiset (PrimeSpectrum A)
h_Wx_le : Multiset.prod (Multiset.map asIdeal Wx) ≤ M + span A {x}
h_Wx_ne✝ : Multiset.prod (Multiset.map asIdeal Wx) ≠ ⊥
Wy : Multiset (PrimeSpectrum A)
h_Wy_le : Multiset.prod (Multiset.map asIdeal Wy) ≤ M + span A {y}
h_Wx_ne : Multiset.prod (Multiset.map asIdeal Wy) ≠ ⊥
hy : Multiset.prod (Multiset.map asIdeal Wy) = ⊥
⊢ False
[PROOFSTEP]
contradiction
[GOAL]
R : Type u
inst✝⁴ : CommRing R
inst✝³ : IsNoetherianRing R
A : Type u
inst✝² : CommRing A
inst✝¹ : IsDomain A
inst✝ : IsNoetherianRing A
⊢ NoetherianSpace (PrimeSpectrum R)
[PROOFSTEP]
apply ((noetherianSpace_TFAE <| PrimeSpectrum R).out 0 1).mpr
[GOAL]
R : Type u
inst✝⁴ : CommRing R
inst✝³ : IsNoetherianRing R
A : Type u
inst✝² : CommRing A
inst✝¹ : IsDomain A
inst✝ : IsNoetherianRing A
⊢ WellFounded fun s t => s < t
[PROOFSTEP]
have H := ‹IsNoetherianRing R›
[GOAL]
R : Type u
inst✝⁴ : CommRing R
inst✝³ : IsNoetherianRing R
A : Type u
inst✝² : CommRing A
inst✝¹ : IsDomain A
inst✝ : IsNoetherianRing A
H : IsNoetherianRing R
⊢ WellFounded fun s t => s < t
[PROOFSTEP]
rw [isNoetherianRing_iff, isNoetherian_iff_wellFounded] at H
[GOAL]
R : Type u
inst✝⁴ : CommRing R
inst✝³ : IsNoetherianRing R
A : Type u
inst✝² : CommRing A
inst✝¹ : IsDomain A
inst✝ : IsNoetherianRing A
H : WellFounded fun x x_1 => x > x_1
⊢ WellFounded fun s t => s < t
[PROOFSTEP]
exact (closedsEmbedding R).dual.wellFounded H