| import OAI.AlgebraicGeometry.SurfaceCones.ChartDominance |
|
|
| namespace OAI |
|
|
| /-! Closed base change on the completed source charts. -/ |
| noncomputable section |
| open _root_.AlgebraicGeometry _root_.OAI.AlgebraicGeometry CategoryTheory CategoryTheory.Limits |
| namespace SourcePullbackChart |
| open KummerSourceModel SourceConeMorphism SourceZeroSections |
| attribute [local instance] integralSurfaceCommRing integralSurfaceSemiring |
| integralPullbackCommRing integralPullbackSemiring pullbackBaseAlgebra surfaceOriginAlgebra |
| completedPullbackModule completedPullbackAction completedPullbackSMul completedPullbackTower |
| completedSurfaceModule completedSeriesModule completedSourceChartCommRing completedSourceChartSemiring |
| completedSourceAlgebra |
| originChartCommRing originChartSemiring originPlaneCommRing originPlaneSemiring |
| chartBaseAlgebra planeOriginAlgebra baseChartModule baseChartAction baseChartSMul baseChartTower |
| planeOriginModule completedBlowupCommRing completedBlowupSemiring completedBlowupAlgebra |
|
|
| def completedClosedChartBaseChangeIso (i : Fin 3) |
| (M : (Spec (.of (completedSourceChart i))).Modules) [M.IsQuasicoherent] : |
| (Scheme.Modules.pullback (completedPlaneZeroChart i)).obj |
| ((Scheme.Modules.pushforward (completedProjection i)).obj M) ≅ |
| (Scheme.Modules.pushforward (Spec.map (CommRingCat.ofHom (surfaceDirectionMap i)))).obj |
| ((Scheme.Modules.pullback (completedZeroChart i)).obj M) := |
| AffineClosedBaseChange.sheafIso _ _ _ _ (completedClosedChart_isPushout i) M |
| end SourcePullbackChart |
|
|
| end |
|
|
| /-! Identification of affine tensor-product base change with the canonical mate. -/ |
| noncomputable section |
| open CategoryTheory CategoryTheory.Limits _root_.AlgebraicGeometry _root_.OAI.AlgebraicGeometry TensorProduct |
| namespace AffineClosedBaseChange |
| variable {B C D E : CommRingCat.{0}} |
| (f : B ⟶ C) (z : B ⟶ D) (w : C ⟶ E) (q : D ⟶ E) |
| (h : IsPushout f z w q) |
|
|
| def moduleRightIso : |
| ModuleCat.restrictScalars w.hom ⋙ ModuleCat.restrictScalars f.hom ≅ |
| ModuleCat.restrictScalars q.hom ⋙ ModuleCat.restrictScalars z.hom := |
| (ModuleCat.restrictScalarsComp f.hom w.hom).symm ≪≫ |
| ModuleCat.restrictScalarsCongr (congrArg CommRingCat.Hom.hom h.w) ≪≫ |
| ModuleCat.restrictScalarsComp z.hom q.hom |
|
|
| lemma moduleRightIso_apply (M : ModuleCat E) (m : M) : |
| (moduleRightIso f z w q h).hom.app M m = m := rfl |
|
|
| def moduleMate : |
| ModuleCat.restrictScalars f.hom ⋙ ModuleCat.extendScalars z.hom ⟶ |
| ModuleCat.extendScalars w.hom ⋙ ModuleCat.restrictScalars q.hom := |
| (((mateEquiv (ModuleCat.extendRestrictScalarsAdj w.hom) |
| (ModuleCat.extendRestrictScalarsAdj z.hom)).symm |
| (TwoSquare.mk _ _ _ _ (moduleRightIso f z w q h).hom)).natTrans) |
|
|
| lemma moduleMate_one_tmul (M : ModuleCat C) (m : M) : |
| (moduleMate f z w q h).app M |
| ((ModuleCat.extendRestrictScalarsAdj z.hom).unit.app _ |
| (m : (ModuleCat.restrictScalars f.hom).obj M)) = |
| (ModuleCat.extendRestrictScalarsAdj w.hom).unit.app M m := by |
| have H := unit_mateEquiv_symm (ModuleCat.extendRestrictScalarsAdj w.hom) |
| (ModuleCat.extendRestrictScalarsAdj z.hom) |
| (TwoSquare.mk _ _ _ _ (moduleRightIso f z w q h).hom) M |
| change (ModuleCat.restrictScalars f.hom).map |
| ((ModuleCat.extendRestrictScalarsAdj w.hom).unit.app M) ≫ |
| (moduleRightIso f z w q h).hom.app _ = |
| (ModuleCat.extendRestrictScalarsAdj z.hom).unit.app _ ≫ |
| (ModuleCat.restrictScalars z.hom).map ((moduleMate f z w q h).app M) at H |
| have H' := LinearMap.congr_fun (congrArg ModuleCat.Hom.hom H) m |
| change (moduleRightIso f z w q h).hom.app ((ModuleCat.extendScalars w.hom).obj M) |
| ((ModuleCat.extendRestrictScalarsAdj w.hom).unit.app M m) = |
| (moduleMate f z w q h).app M ((ModuleCat.extendRestrictScalarsAdj z.hom).unit.app _ m) at H' |
| erw [moduleRightIso_apply] at H' |
| exact H'.symm |
|
|
| lemma moduleMate_eq (M : ModuleCat C) : |
| (moduleMate f z w q h).app M = (moduleIso f z w q h M).hom := by |
| let : Algebra B C := f.hom.toAlgebra |
| let : Algebra B D := z.hom.toAlgebra |
| let : Algebra C E := w.hom.toAlgebra |
| let : Algebra D E := q.hom.toAlgebra |
| let : Algebra B E := (w.hom.comp f.hom).toAlgebra |
| let : IsScalarTower B C E := IsScalarTower.of_algebraMap_eq' rfl |
| let : IsScalarTower B D E := |
| IsScalarTower.of_algebraMap_eq' (congrArg CommRingCat.Hom.hom h.w) |
| let : Algebra.IsPushout B D C E := CommRingCat.isPushout_iff_isPushout.mp h.flip |
| let : Module B M := Module.compHom M f.hom |
| let : IsScalarTower B C M := IsScalarTower.of_algebraMap_smul (fun _ _ => rfl) |
| let F : D ⊗[B] M →ₗ[D] E ⊗[C] M := ((moduleMate f z w q h).app M).hom |
| let G : D ⊗[B] M →ₗ[D] E ⊗[C] M := |
| (Algebra.IsPushout.cancelBaseChange B D C E M).symm.toLinearMap |
| suffices he : F = G from ModuleCat.hom_ext he |
| apply LinearMap.ext |
| intro x |
| induction x using TensorProduct.inductionOn with |
| | add x y hx hy => simpa only [map_add] using congrArg₂ (· + ·) hx hy |
| | tmul d m => |
| rw [show d ⊗ₜ[B] m = d • ((1 : D) ⊗ₜ[B] m) by rw [smul_tmul', smul_eq_mul, mul_one]] |
| rw [F.map_smul, G.map_smul] |
| congr 1 |
| have he : F ((1 : D) ⊗ₜ[B] m) = (1 : E) ⊗ₜ[C] m := |
| moduleMate_one_tmul f z w q h M m |
| rw [he] |
| symm |
| simpa only [G, LinearEquiv.coe_coe, map_one] using |
| (Algebra.IsPushout.cancelBaseChange_symm_tmul B D C E M (1 : D) m) |
|
|
| instance moduleMate_app_isIso (M : ModuleCat C) : IsIso ((moduleMate f z w q h).app M) := by |
| rw [moduleMate_eq] |
| infer_instance |
|
|
| instance moduleMate_isIso : IsIso (moduleMate f z w q h) := by |
| apply NatIso.isIso_of_isIso_app |
| end AffineClosedBaseChange |
|
|
| end |
|
|
| /-! The canonical base-change transformation attached to a commutative square of schemes. -/ |
| noncomputable section |
| open CategoryTheory CategoryTheory.Limits _root_.AlgebraicGeometry _root_.OAI.AlgebraicGeometry |
| namespace ActualSheafBaseChange |
| open Scheme.Modules |
| variable {B C D E : Scheme.{0}} |
| (f : C ⟶ B) (z : D ⟶ B) (w : E ⟶ C) (q : E ⟶ D) |
| (h : w ≫ f = q ≫ z) |
|
|
| def rightIso : pushforward w ⋙ pushforward f ≅ pushforward q ⋙ pushforward z := |
| pushforwardComp w f ≪≫ pushforwardCongr h ≪≫ (pushforwardComp q z).symm |
|
|
| def mate : pushforward f ⋙ pullback z ⟶ pullback w ⋙ pushforward q := |
| (((mateEquiv (pullbackPushforwardAdjunction w) (pullbackPushforwardAdjunction z)).symm |
| (TwoSquare.mk _ _ _ _ (rightIso f z w q h).hom)).natTrans) |
|
|
| lemma mate_unit (M : C.Modules) : |
| (pushforward f).map ((pullbackPushforwardAdjunction w).unit.app M) ≫ |
| (rightIso f z w q h).hom.app _ = |
| (pullbackPushforwardAdjunction z).unit.app _ ≫ |
| (pushforward z).map ((mate f z w q h).app M) := |
| unit_mateEquiv_symm (pullbackPushforwardAdjunction w) (pullbackPushforwardAdjunction z) |
| (TwoSquare.mk _ _ _ _ (rightIso f z w q h).hom) M |
|
|
| lemma mate_eq_iff (M : C.Modules) |
| (φ : (Scheme.Modules.pullback z).obj ((pushforward f).obj M) ⟶ |
| (pushforward q).obj ((Scheme.Modules.pullback w).obj M)) : |
| (mate f z w q h).app M = φ ↔ |
| (pullbackPushforwardAdjunction z).unit.app _ ≫ (pushforward z).map φ = |
| (pushforward f).map ((pullbackPushforwardAdjunction w).unit.app M) ≫ |
| (rightIso f z w q h).hom.app _ := by |
| rw [mate_unit] |
| exact ⟨fun he => by rw [he], fun he => |
| ((pullbackPushforwardAdjunction z).homEquiv _ _).injective he.symm⟩ |
| end ActualSheafBaseChange |
|
|
| end |
|
|
| /-! The commuting restriction-of-scalars square is the square on affine global sections, including |
| the canonical scheme pushforward comparison. -/ |
| noncomputable section |
| open CategoryTheory CategoryTheory.Limits _root_.AlgebraicGeometry _root_.OAI.AlgebraicGeometry |
| namespace AffineClosedBaseChange |
| lemma rotate_iso_square {K : Type*} [Category K] {A B C D : K} |
| (l : A ≅ B) (r : C ≅ D) {a : B ⟶ D} {b : A ⟶ C} |
| (h : l.hom ≫ a = b ≫ r.hom) : l.inv ≫ b = a ≫ r.inv := by |
| rw [l.inv_comp_eq, ← Category.assoc, r.eq_comp_inv] |
| exact h.symm |
| variable {B C D E : CommRingCat.{0}} |
| (f : B ⟶ C) (z : B ⟶ D) (w : C ⟶ E) (q : D ⟶ E) |
| (h : IsPushout f z w q) |
| include h in |
| lemma spec_square : Spec.map w ≫ Spec.map f = Spec.map q ≫ Spec.map z := by |
| rw [← Spec.map_comp, ← Spec.map_comp, h.w] |
|
|
| lemma gamma_cube (M : (Spec E).Modules) : |
| (AffinePullback.pushforwardGammaIso f).hom.app |
| ((Scheme.Modules.pushforward (Spec.map w)).obj M) ≫ |
| (ModuleCat.restrictScalars f.hom).map ((AffinePullback.pushforwardGammaIso w).hom.app M) ≫ |
| (moduleRightIso f z w q h).hom.app (moduleSpecΓFunctor.obj M) = |
| moduleSpecΓFunctor.map |
| ((ActualSheafBaseChange.rightIso (Spec.map f) (Spec.map z) |
| (Spec.map w) (Spec.map q) (spec_square f z w q h)).hom.app M) ≫ |
| (AffinePullback.pushforwardGammaIso z).hom.app |
| ((Scheme.Modules.pushforward (Spec.map q)).obj M) ≫ |
| (ModuleCat.restrictScalars z.hom).map ((AffinePullback.pushforwardGammaIso q).hom.app M) := by |
| apply ModuleCat.hom_ext |
| apply LinearMap.ext |
| intro m |
| simp only [ActualSheafBaseChange.rightIso, Iso.trans_hom, Iso.symm_hom, |
| NatTrans.comp_app, Functor.map_comp] |
| change m = (((Scheme.Modules.pushforwardCongr |
| (spec_square f z w q h)).hom.app M).app ⊤) m |
| rw [Scheme.Modules.pushforwardCongr_hom_app_app] |
| change m = M.presheaf.map (𝟙 (Opposite.op ⊤)) m |
| rw [M.presheaf.map_id] |
| rfl |
| lemma gamma_cube_inv (M : (Spec E).Modules) : |
| (ModuleCat.restrictScalars f.hom).map ((AffinePullback.pushforwardGammaIso w).inv.app M) ≫ |
| (AffinePullback.pushforwardGammaIso f).inv.app |
| ((Scheme.Modules.pushforward (Spec.map w)).obj M) ≫ |
| moduleSpecΓFunctor.map |
| ((ActualSheafBaseChange.rightIso (Spec.map f) (Spec.map z) |
| (Spec.map w) (Spec.map q) (spec_square f z w q h)).hom.app M) = |
| (moduleRightIso f z w q h).hom.app (moduleSpecΓFunctor.obj M) ≫ |
| (ModuleCat.restrictScalars z.hom).map ((AffinePullback.pushforwardGammaIso q).inv.app M) ≫ |
| (AffinePullback.pushforwardGammaIso z).inv.app |
| ((Scheme.Modules.pushforward (Spec.map q)).obj M) := by |
| let eL := (AffinePullback.pushforwardGammaIso f).app |
| ((Scheme.Modules.pushforward (Spec.map w)).obj M) ≪≫ |
| (ModuleCat.restrictScalars f.hom).mapIso ((AffinePullback.pushforwardGammaIso w).app M) |
| let eR := (AffinePullback.pushforwardGammaIso z).app |
| ((Scheme.Modules.pushforward (Spec.map q)).obj M) ≪≫ |
| (ModuleCat.restrictScalars z.hom).mapIso ((AffinePullback.pushforwardGammaIso q).app M) |
| have H : eL.hom ≫ (moduleRightIso f z w q h).hom.app (moduleSpecΓFunctor.obj M) = |
| moduleSpecΓFunctor.map |
| ((ActualSheafBaseChange.rightIso (Spec.map f) (Spec.map z) |
| (Spec.map w) (Spec.map q) (spec_square f z w q h)).hom.app M) ≫ eR.hom := by |
| dsimp only [eL, eR, Iso.trans_hom, Functor.mapIso_hom, Iso.app_hom] |
| rw [Category.assoc] |
| exact gamma_cube f z w q h M |
| have Hi := rotate_iso_square eL eR H |
| simpa only [eL, eR, Iso.trans_inv, Functor.mapIso_inv, Iso.app_inv, Category.assoc] using Hi |
| end AffineClosedBaseChange |
|
|
| end |
|
|
| /-! Unit compatibility for the affine associated-sheaf isomorphism, identifying tensor-product base |
| change with canonical base change. -/ |
| noncomputable section |
| open CategoryTheory |
| namespace AdjunctionBCUnit |
| universe v₁ v₂ v₃ v₄ u₁ u₂ u₃ u₄ |
| variable {C : Type u₁} {D : Type u₂} {C' : Type u₃} {D' : Type u₄} |
| [Category.{v₁} C] [Category.{v₂} D] [Category.{v₃} C'] [Category.{v₄} D'] |
| {T : C ⥤ D} {U : D ⥤ C} {T' : C' ⥤ D'} {U' : D' ⥤ C'} |
| {L : D ⥤ D'} {R : D' ⥤ D} {L' : C ⥤ C'} {R' : C' ⥤ C} |
| (a : T ⊣ U) (b : T' ⊣ U') (c : L ⊣ R) (d : L' ⊣ R') |
| (α : R ⋙ U ≅ U' ⋙ R') |
|
|
| def leftIso : T ⋙ L ≅ L' ⋙ T' := |
| ((conjugateIsoEquiv (a.comp c) (d.comp b)).symm α).symm |
|
|
| def pushComparison (N : C') : T.obj (R'.obj N) ⟶ R.obj (T'.obj N) := |
| (a.homEquiv _ _).symm (R'.map (b.unit.app N) ≫ α.inv.app (T'.obj N)) |
|
|
| lemma unit_pushComparison (N : C') : |
| a.unit.app _ ≫ U.map (pushComparison a b α N) = |
| R'.map (b.unit.app N) ≫ α.inv.app (T'.obj N) := |
| (a.homEquiv _ _).apply_symm_apply _ |
|
|
| lemma pushComparison_naturality {N N' : C'} (k : N ⟶ N') : |
| T.map (R'.map k) ≫ pushComparison a b α N' = |
| pushComparison a b α N ≫ R.map (T'.map k) := by |
| apply (a.homEquiv _ _).injective |
| simp only [Adjunction.homEquiv_unit, Functor.map_comp] |
| rw [a.unit_naturality_assoc] |
| rw [unit_pushComparison] |
| rw [reassoc_of% (unit_pushComparison a b α N)] |
| have hn := α.inv.naturality (T'.map k) |
| simp only [Functor.comp_map, Functor.comp_obj] at hn |
| rw [← hn] |
| simpa only [Functor.map_comp, Category.assoc] using |
| congrArg (fun k' => R'.map k' ≫ α.inv.app (T'.obj N')) (b.unit_naturality k).symm |
|
|
| lemma unit_comparison (M : C) : |
| c.unit.app (T.obj M) ≫ R.map ((leftIso a b c d α).hom.app M) = |
| T.map (d.unit.app M) ≫ pushComparison a b α (L'.obj M) := by |
| apply (a.homEquiv _ _).injective |
| simp only [Adjunction.homEquiv_unit, Functor.map_comp] |
| apply (cancel_mono (α.hom.app (T'.obj (L'.obj M)))).mp |
| have h := unit_conjugateEquiv_symm (a.comp c) (d.comp b) α.hom M |
| simp only [Adjunction.comp_unit_app, Category.assoc, Functor.comp_obj, Functor.comp_map] at h |
| change a.unit.app M ≫ U.map (c.unit.app (T.obj M)) ≫ α.hom.app (L.obj (T.obj M)) = |
| d.unit.app M ≫ R'.map (b.unit.app (L'.obj M)) ≫ |
| R'.map (U'.map ((leftIso a b c d α).inv.app M)) at h |
| have ht := congrArg (fun k => k ≫ R'.map (U'.map ((leftIso a b c d α).hom.app M))) h |
| simp only [Category.assoc, ← Functor.map_comp, Iso.inv_hom_id_app] at ht |
| have hn := α.hom.naturality ((leftIso a b c d α).hom.app M) |
| simp only [Functor.comp_map, Functor.comp_obj] at hn |
| rw [← hn] at ht |
| simp only [Category.assoc] |
| rw [ht] |
| have hn2 := a.unit.naturality (d.unit.app M) |
| simp only [Functor.id_map, Functor.id_obj, Functor.comp_map, Functor.comp_obj] at hn2 |
| rw [← Category.assoc, ← hn2, Category.assoc, reassoc_of% (unit_pushComparison a b α (L'.obj M))] |
| simp only [α.inv_hom_id_app, Functor.comp_obj, Category.comp_id] |
| rw [U'.map_id (T'.obj (L'.obj M)), Category.comp_id] |
| end AdjunctionBCUnit |
|
|
| end |
|
|
| /-! Compatibility of the affine associated-sheaf isomorphisms with pullback-pushforward units. -/ |
| noncomputable section |
| open CategoryTheory CategoryTheory.Limits _root_.AlgebraicGeometry _root_.OAI.AlgebraicGeometry |
| namespace AffinePullback |
| variable {A B : CommRingCat.{0}} (f : A ⟶ B) |
|
|
| lemma pushComparison_eq (M : ModuleCat B) : |
| AdjunctionBCUnit.pushComparison (tilde.adjunction (R := A)) |
| (tilde.adjunction (R := B)) (pushforwardGammaIso f) M = |
| (pushforwardTildeIso f M).inv := by |
| unfold AdjunctionBCUnit.pushComparison pushforwardTildeIso |
| dsimp only [Iso.trans, Iso.symm, Functor.mapIso, Iso.app] |
| rw [Adjunction.homEquiv_counit] |
| rfl |
|
|
| lemma pullbackTildeIso_unit (M : ModuleCat A) : |
| (Scheme.Modules.pullbackPushforwardAdjunction (Spec.map f)).unit.app (tilde M) ≫ |
| (Scheme.Modules.pushforward (Spec.map f)).map ((pullbackTildeIso f).hom.app M) = |
| (tilde.functor A).map ((ModuleCat.extendRestrictScalarsAdj f.hom).unit.app M) ≫ |
| (pushforwardTildeIso f ((ModuleCat.extendScalars f.hom).obj M)).inv := by |
| have H := AdjunctionBCUnit.unit_comparison (tilde.adjunction (R := A)) |
| (tilde.adjunction (R := B)) |
| (Scheme.Modules.pullbackPushforwardAdjunction (Spec.map f)) |
| (ModuleCat.extendRestrictScalarsAdj f.hom) (pushforwardGammaIso f) M |
| rw [pushComparison_eq] at H |
| exact H |
| lemma pushforwardTildeIso_inv_unit (M : ModuleCat B) : |
| (tilde.adjunction (R := A)).unit.app _ ≫ |
| moduleSpecΓFunctor.map (pushforwardTildeIso f M).inv = |
| (ModuleCat.restrictScalars f.hom).map ((tilde.adjunction (R := B)).unit.app M) ≫ |
| (pushforwardGammaIso f).inv.app (tilde M) := by |
| have H := AdjunctionBCUnit.unit_pushComparison (tilde.adjunction (R := A)) |
| (tilde.adjunction (R := B)) (pushforwardGammaIso f) M |
| rw [pushComparison_eq] at H |
| exact H |
|
|
| lemma pushforwardTildeIso_inv_naturality {M N : ModuleCat B} (k : M ⟶ N) : |
| (tilde.functor A).map ((ModuleCat.restrictScalars f.hom).map k) ≫ |
| (pushforwardTildeIso f N).inv = |
| (pushforwardTildeIso f M).inv ≫ |
| (Scheme.Modules.pushforward (Spec.map f)).map ((tilde.functor B).map k) := by |
| have H := AdjunctionBCUnit.pushComparison_naturality (tilde.adjunction (R := A)) |
| (tilde.adjunction (R := B)) (pushforwardGammaIso f) k |
| rw [pushComparison_eq] at H |
| exact H |
| lemma gamma_pushTilde_comp {C : CommRingCat.{0}} (g : B ⟶ C) (M : ModuleCat C) : |
| (tilde.adjunction (R := A)).unit.app _ ≫ |
| moduleSpecΓFunctor.map |
| ((pushforwardTildeIso f ((ModuleCat.restrictScalars g.hom).obj M)).inv ≫ |
| (Scheme.Modules.pushforward (Spec.map f)).map (pushforwardTildeIso g M).inv) = |
| (ModuleCat.restrictScalars f.hom).map |
| ((ModuleCat.restrictScalars g.hom).map ((tilde.adjunction (R := C)).unit.app M)) ≫ |
| (ModuleCat.restrictScalars f.hom).map ((pushforwardGammaIso g).inv.app (tilde M)) ≫ |
| (pushforwardGammaIso f).inv.app |
| ((Scheme.Modules.pushforward (Spec.map g)).obj (tilde M)) := by |
| erw [(moduleSpecΓFunctor (R := A)).map_comp, ← Category.assoc, |
| pushforwardTildeIso_inv_unit f ((ModuleCat.restrictScalars g.hom).obj M), Category.assoc] |
| have hn := (pushforwardGammaIso f).inv.naturality (pushforwardTildeIso g M).inv |
| simp only [Functor.comp_map, Functor.comp_obj] at hn |
| erw [← hn, ← Category.assoc, ← (ModuleCat.restrictScalars f.hom).map_comp, |
| pushforwardTildeIso_inv_unit g M, (ModuleCat.restrictScalars f.hom).map_comp, Category.assoc] |
| end AffinePullback |
|
|
| end |
|
|
| /-! Coherence for the two affine pushforward comparisons. -/ |
| noncomputable section |
| open CategoryTheory CategoryTheory.Limits _root_.AlgebraicGeometry _root_.OAI.AlgebraicGeometry |
| namespace AffineClosedBaseChange |
| variable {B C D E : CommRingCat.{0}} |
| (f : B ⟶ C) (z : B ⟶ D) (w : C ⟶ E) (q : D ⟶ E) |
| (h : IsPushout f z w q) |
| lemma push_cube (M : ModuleCat E) : |
| (AffinePullback.pushforwardTildeIso f ((ModuleCat.restrictScalars w.hom).obj M)).inv ≫ |
| (Scheme.Modules.pushforward (Spec.map f)).map (AffinePullback.pushforwardTildeIso w M).inv ≫ |
| (ActualSheafBaseChange.rightIso (Spec.map f) (Spec.map z) |
| (Spec.map w) (Spec.map q) (spec_square f z w q h)).hom.app (tilde M) = |
| (tilde.functor B).map ((moduleRightIso f z w q h).hom.app M) ≫ |
| (AffinePullback.pushforwardTildeIso z ((ModuleCat.restrictScalars q.hom).obj M)).inv ≫ |
| (Scheme.Modules.pushforward (Spec.map z)).map (AffinePullback.pushforwardTildeIso q M).inv := by |
| apply (tilde.adjunction (R := B)).homEquiv _ _ |>.injective |
| erw [Adjunction.homEquiv_unit, Adjunction.homEquiv_unit] |
| erw [← Category.assoc, (moduleSpecΓFunctor (R := B)).map_comp, ← Category.assoc, |
| AffinePullback.gamma_pushTilde_comp f w M] |
| conv_rhs => |
| erw [(moduleSpecΓFunctor (R := B)).map_comp, |
| (tilde.adjunction (R := B)).unit_naturality_assoc |
| ((moduleRightIso f z w q h).hom.app M)] |
| dsimp only [Functor.comp_obj, Functor.id_obj] |
| conv_rhs => erw [AffinePullback.gamma_pushTilde_comp z q M] |
| simp only [Category.assoc] |
| erw [gamma_cube_inv f z w q h] |
| have hn := (moduleRightIso f z w q h).hom.naturality |
| ((tilde.adjunction (R := E)).unit.app M) |
| simp only [Functor.comp_map, Functor.comp_obj, Functor.id_obj] at hn |
| change (ModuleCat.restrictScalars f.hom).map |
| ((ModuleCat.restrictScalars w.hom).map ((tilde.adjunction (R := E)).unit.app M)) ≫ |
| (moduleRightIso f z w q h).hom.app (moduleSpecΓFunctor.obj (tilde M)) = |
| (moduleRightIso f z w q h).hom.app M ≫ |
| (ModuleCat.restrictScalars z.hom).map |
| ((ModuleCat.restrictScalars q.hom).map ((tilde.adjunction (R := E)).unit.app M)) at hn |
| erw [← Category.assoc, ← Category.assoc, hn, Category.assoc, Category.assoc] |
| end AffineClosedBaseChange |
|
|
| end |
|
|
| /-! The affine closed base-change isomorphism is the canonical mate. This is the compatibility |
| needed for its use on the main model's open cover. -/ |
| noncomputable section |
| open CategoryTheory CategoryTheory.Limits _root_.AlgebraicGeometry _root_.OAI.AlgebraicGeometry |
| namespace AffineClosedBaseChange |
| variable {B C D E : CommRingCat.{0}} |
| (f : B ⟶ C) (z : B ⟶ D) (w : C ⟶ E) (q : D ⟶ E) |
| (h : IsPushout f z w q) |
| local notation "Pf" => Scheme.Modules.pushforward (Spec.map f) |
| local notation "Pz" => Scheme.Modules.pushforward (Spec.map z) |
| local notation "Pw" => Scheme.Modules.pushforward (Spec.map w) |
| local notation "Pq" => Scheme.Modules.pushforward (Spec.map q) |
| local notation "Lz" => Scheme.Modules.pullback (Spec.map z) |
| local notation "Lw" => Scheme.Modules.pullback (Spec.map w) |
| local notation "Rf" => ModuleCat.restrictScalars f.hom |
| local notation "Rz" => ModuleCat.restrictScalars z.hom |
| local notation "Rw" => ModuleCat.restrictScalars w.hom |
| local notation "Rq" => ModuleCat.restrictScalars q.hom |
| local notation "Ez" => ModuleCat.extendScalars z.hom |
| local notation "Ew" => ModuleCat.extendScalars w.hom |
| local notation "TB" => tilde.functor B |
| local notation "TC" => tilde.functor C |
| local notation "TD" => tilde.functor D |
| local notation "TE" => tilde.functor E |
| local notation "δ" => ActualSheafBaseChange.rightIso (Spec.map f) (Spec.map z) |
| (Spec.map w) (Spec.map q) (spec_square f z w q h) |
| local notation "α" => moduleRightIso f z w q h |
|
|
| lemma moduleMate_unit (M : ModuleCat C) : |
| (ModuleCat.extendRestrictScalarsAdj z.hom).unit.app ((Rf).obj M) ≫ |
| (Rz).map (moduleIso f z w q h M).hom = |
| (Rf).map ((ModuleCat.extendRestrictScalarsAdj w.hom).unit.app M) ≫ (α).hom.app ((Ew).obj M) := by |
| have H := unit_mateEquiv_symm (ModuleCat.extendRestrictScalarsAdj w.hom) |
| (ModuleCat.extendRestrictScalarsAdj z.hom) |
| (TwoSquare.mk _ _ _ _ (α).hom) M |
| change _ = _ ≫ (Rz).map ((moduleMate f z w q h).app M) at H |
| rw [moduleMate_eq] at H |
| exact H.symm |
|
|
| lemma tildeMate_eq (M : ModuleCat C) : |
| (ActualSheafBaseChange.mate (Spec.map f) (Spec.map z) (Spec.map w) (Spec.map q) |
| (spec_square f z w q h)).app (tilde M) = (tildeIso f z w q h M).hom := by |
| apply (ActualSheafBaseChange.mate_eq_iff _ _ _ _ _ _ _).2 |
| apply (cancel_mono ((Pz).map ((Pq).map ((AffinePullback.pullbackTildeIso w).hom.app M)))).mp |
| let fa : (Lz).obj ((Pf).obj (tilde M)) ⟶ (Lz).obj (tilde ((Rf).obj M)) := |
| (Lz).map (AffinePullback.pushforwardTildeIso f M).hom |
| let fb : (Lz).obj (tilde ((Rf).obj M)) ⟶ tilde ((Ez).obj ((Rf).obj M)) := |
| (AffinePullback.pullbackTildeIso z).hom.app ((Rf).obj M) |
| let fc : tilde ((Ez).obj ((Rf).obj M)) ⟶ tilde ((Rq).obj ((Ew).obj M)) := |
| (TD).map (moduleIso f z w q h M).hom |
| let fd : tilde ((Rq).obj ((Ew).obj M)) ⟶ (Pq).obj (tilde ((Ew).obj M)) := |
| (AffinePullback.pushforwardTildeIso q ((Ew).obj M)).inv |
| let fe : (Pq).obj (tilde ((Ew).obj M)) ⟶ (Pq).obj ((Lw).obj (tilde M)) := |
| (Pq).map ((AffinePullback.pullbackTildeIso w).inv.app M) |
| let u := (Scheme.Modules.pullbackPushforwardAdjunction (Spec.map z)).unit.app ((Pf).obj (tilde M)) |
| let v := (Pf).map ((Scheme.Modules.pullbackPushforwardAdjunction (Spec.map w)).unit.app (tilde M)) |
| let dd := (δ).hom.app ((Lw).obj (tilde M)) |
| let k : (Pz).obj ((Pq).obj ((Lw).obj (tilde M))) ⟶ |
| (Pz).obj ((Pq).obj (tilde ((Ew).obj M))) := |
| (Pz).map ((Pq).map ((AffinePullback.pullbackTildeIso w).hom.app M)) |
| change (u ≫ (Pz).map (fa ≫ fb ≫ fc ≫ fd ≫ fe)) ≫ k = (v ≫ dd) ≫ k |
| have hm : (Pz).map (fa ≫ fb ≫ fc ≫ fd ≫ fe) = |
| (Pz).map fa ≫ (Pz).map fb ≫ (Pz).map fc ≫ (Pz).map fd ≫ (Pz).map fe := by |
| simp only [Functor.map_comp] |
| rw [hm] |
| simp only [Category.assoc] |
| have hc : (Pz).map fe ≫ k = 𝟙 _ := by |
| dsimp only [fe, k] |
| erw [← (Pz).map_comp, ← (Pq).map_comp, Iso.inv_hom_id_app, (Pq).map_id, (Pz).map_id] |
| rw [hc, Category.comp_id] |
| dsimp only [u, v, dd, k, fa, fb, fc, fd] |
| erw [(Scheme.Modules.pullbackPushforwardAdjunction (Spec.map z)).unit_naturality_assoc] |
| erw [reassoc_of% (AffinePullback.pullbackTildeIso_unit z ((Rf).obj M))] |
| conv_lhs => |
| arg 2 |
| erw [Category.assoc] |
| arg 2 |
| erw [← Category.assoc] |
| arg 1 |
| erw [← AffinePullback.pushforwardTildeIso_inv_naturality z |
| (moduleIso f z w q h M).hom] |
| conv_lhs => |
| arg 2 |
| arg 2 |
| erw [Category.assoc] |
| erw [← reassoc_of% ((TB).map_comp |
| ((ModuleCat.extendRestrictScalarsAdj z.hom).unit.app ((Rf).obj M)) |
| ((Rz).map (moduleIso f z w q h M).hom))] |
| erw [moduleMate_unit f z w q h M, Functor.map_comp] |
| simp only [Category.assoc] |
| erw [← push_cube f z w q h ((Ew).obj M)] |
| conv_lhs => |
| arg 2 |
| erw [← Category.assoc] |
| erw [reassoc_of% (AffinePullback.pushforwardTildeIso_inv_naturality f |
| ((ModuleCat.extendRestrictScalarsAdj w.hom).unit.app M))] |
| conv_lhs => |
| arg 2 |
| erw [Category.assoc] |
| erw [Iso.hom_inv_id_assoc] |
| erw [← reassoc_of% ((Pf).map_comp |
| ((TC).map ((ModuleCat.extendRestrictScalarsAdj w.hom).unit.app M)) |
| (AffinePullback.pushforwardTildeIso w ((Ew).obj M)).inv)] |
| erw [← AffinePullback.pullbackTildeIso_unit w M, Functor.map_comp] |
| simp only [Category.assoc] |
| have hn := (δ).hom.naturality ((AffinePullback.pullbackTildeIso w).hom.app M) |
| simp only [Functor.comp_map, Functor.comp_obj] at hn |
| erw [hn] |
| rfl |
|
|
| instance tildeMate_isIso (M : ModuleCat C) : |
| IsIso ((ActualSheafBaseChange.mate (Spec.map f) (Spec.map z) (Spec.map w) (Spec.map q) |
| (spec_square f z w q h)).app (tilde M)) := by |
| rw [tildeMate_eq f z w q h M] |
| infer_instance |
|
|
| instance sheafMate_isIso (M : (Spec C).Modules) [M.IsQuasicoherent] : |
| IsIso ((ActualSheafBaseChange.mate (Spec.map f) (Spec.map z) (Spec.map w) (Spec.map q) |
| (spec_square f z w q h)).app M) := by |
| have : IsIso (Scheme.Modules.fromTildeΓ M) := |
| Scheme.Modules.isIso_fromTildeΓ_of_isQuasicoherent M |
| apply (NatTrans.isIso_app_iff_of_iso _ (asIso (Scheme.Modules.fromTildeΓ M))).1 |
| exact tildeMate_isIso f z w q h (moduleSpecΓFunctor.obj M) |
| end AffineClosedBaseChange |
|
|
| end |
|
|
| /-! Transport of base-change mates along adjunction isomorphisms. -/ |
| noncomputable section |
| open CategoryTheory |
| namespace ActualMateTransport |
| universe u₁ u₂ u₃ u₄ v₁ v₂ v₃ v₄ |
| variable {A : Type u₁} {B : Type u₂} {C : Type u₃} {D : Type u₄} |
| [Category.{v₁} A] [Category.{v₂} B] [Category.{v₃} C] [Category.{v₄} D] |
| {G : A ⥤ C} {H : B ⥤ D} |
| {L₁ L₁' : A ⥤ B} {R₁ R₁' : B ⥤ A} |
| {L₂ L₂' : C ⥤ D} {R₂ R₂' : D ⥤ C} |
| (a₁ : L₁ ⊣ R₁) (a₂ : L₂ ⊣ R₂) (a₁' : L₁' ⊣ R₁') (a₂' : L₂' ⊣ R₂') |
| (e₁ : R₁ ≅ R₁') (e₂ : R₂ ≅ R₂') |
|
|
| def left₁ : L₁' ≅ L₁ := (conjugateIsoEquiv a₁ a₁').symm e₁ |
| def left₂ : L₂' ≅ L₂ := (conjugateIsoEquiv a₂ a₂').symm e₂ |
|
|
| def square (s : TwoSquare R₁ H G R₂) : TwoSquare R₁' H G R₂' := |
| (s.whiskerTop e₁.inv).whiskerBottom e₂.hom |
|
|
| lemma square_refl (s : TwoSquare R₁ H G R₂) : |
| square (Iso.refl R₁) (Iso.refl R₂) s = s := by |
| ext M |
| simp [square, TwoSquare.whiskerTop, TwoSquare.whiskerBottom] |
|
|
| lemma mate_transport (s : TwoSquare R₁ H G R₂) : |
| (mateEquiv a₁' a₂').symm (square e₁ e₂ s) = |
| (((mateEquiv a₁ a₂).symm s).whiskerLeft (left₁ a₁ a₁' e₁).inv).whiskerRight |
| (left₂ a₂ a₂' e₂).hom := by |
| apply (mateEquiv a₁' a₂').injective |
| rw [Equiv.apply_symm_apply, mateEquiv_conjugateEquiv_vcomp, |
| conjugateEquiv_mateEquiv_vcomp, Equiv.apply_symm_apply] |
| simp only [left₁, left₂, conjugateIsoEquiv, Equiv.symm_mk, Equiv.coe_fn_mk, |
| Equiv.apply_symm_apply, square] |
|
|
| lemma mate_transport_app (s : TwoSquare R₁ H G R₂) (M : A) : |
| ((mateEquiv a₁' a₂').symm (square e₁ e₂ s)).natTrans.app M = |
| (left₂ a₂ a₂' e₂).hom.app (G.obj M) ≫ |
| ((mateEquiv a₁ a₂).symm s).natTrans.app M ≫ |
| H.map ((left₁ a₁ a₁' e₁).inv.app M) := by |
| rw [mate_transport] |
| rfl |
|
|
| lemma mate_transport_isIso (s : TwoSquare R₁ H G R₂) (M : A) |
| [IsIso (((mateEquiv a₁ a₂).symm s).natTrans.app M)] : |
| IsIso (((mateEquiv a₁' a₂').symm (square e₁ e₂ s)).natTrans.app M) := by |
| rw [mate_transport_app a₁ a₂ a₁' a₂' e₁ e₂ s M] |
| infer_instance |
| end ActualMateTransport |
| namespace ActualMateTransport |
| universe u₁ u₂ u₃ u₄ v₁ v₂ v₃ v₄ |
| variable {A : Type u₁} {B : Type u₂} {C : Type u₃} {D : Type u₄} |
| [Category.{v₁} A] [Category.{v₂} B] [Category.{v₃} C] [Category.{v₄} D] |
| {G : A ⥤ C} {H : B ⥤ D} |
| {L₁ L₁' : A ⥤ B} {R₁ R₁' : B ⥤ A} |
| {L₂ L₂' : C ⥤ D} {R₂ R₂' : D ⥤ C} |
| (a₁ : L₁ ⊣ R₁) (a₂ : L₂ ⊣ R₂) (a₁' : L₁' ⊣ R₁') (a₂' : L₂' ⊣ R₂') |
| (e₁ : R₁ ≅ R₁') (e₂ : R₂ ≅ R₂') |
| lemma mate_transport_isIso_iff (s : TwoSquare R₁ H G R₂) (M : A) : |
| IsIso (((mateEquiv a₁' a₂').symm (square e₁ e₂ s)).natTrans.app M) ↔ |
| IsIso (((mateEquiv a₁ a₂).symm s).natTrans.app M) := by |
| rw [mate_transport_app a₁ a₂ a₁' a₂' e₁ e₂ s M, |
| isIso_comp_left_iff, isIso_comp_right_iff] |
| end ActualMateTransport |
|
|
| end |
|
|
| /-! The canonical base-change mate for an open restriction is invertible. -/ |
| noncomputable section |
| open CategoryTheory CategoryTheory.Limits _root_.AlgebraicGeometry _root_.OAI.AlgebraicGeometry |
| namespace ActualSheafBaseChange |
| open Scheme.Modules |
| variable {X Y : Scheme.{0}} (f : X ⟶ Y) (U : Y.Opens) |
|
|
| lemma restrictMate_eq : |
| (mateEquiv (restrictAdjunction (f ⁻¹ᵁ U).ι) (restrictAdjunction U.ι)).symm |
| (TwoSquare.mk _ _ _ _ (rightIso f U.ι (f ⁻¹ᵁ U).ι (f ∣_ U) |
| (morphismRestrict_ι f U).symm).hom) = CoherentBaseChange.restrictSquare f U := by |
| apply (mateEquiv (restrictAdjunction (f ⁻¹ᵁ U).ι) (restrictAdjunction U.ι)).injective |
| rw [Equiv.apply_symm_apply] |
| change _ = CoherentBaseChange.rightSquare f U |
| exact (CoherentBaseChange.rightSquare_eq f U).symm |
|
|
| instance openMate_isIso (M : X.Modules) : |
| IsIso ((mate f U.ι (f ⁻¹ᵁ U).ι (f ∣_ U) (morphismRestrict_ι f U).symm).app M) := by |
| let s := TwoSquare.mk _ _ _ _ (rightIso f U.ι (f ⁻¹ᵁ U).ι (f ∣_ U) |
| (morphismRestrict_ι f U).symm).hom |
| have : IsIso (((mateEquiv (restrictAdjunction (f ⁻¹ᵁ U).ι) |
| (restrictAdjunction U.ι)).symm s).natTrans.app M) := by |
| dsimp only [s] |
| rw [restrictMate_eq] |
| exact inferInstanceAs (IsIso ((CoherentBaseChange.pushforwardRestrictNatIso f U).hom.app M)) |
| have H := ActualMateTransport.mate_transport_isIso |
| (restrictAdjunction (f ⁻¹ᵁ U).ι) (restrictAdjunction U.ι) |
| (pullbackPushforwardAdjunction (f ⁻¹ᵁ U).ι) (pullbackPushforwardAdjunction U.ι) |
| (Iso.refl _) (Iso.refl _) s M |
| rw [ActualMateTransport.square_refl] at H |
| exact H |
| end ActualSheafBaseChange |
|
|
| end |
|
|
| /-! Horizontal composition of right-adjoint squares and their mates. This is a necessary locality |
| device for the closed base change. -/ |
| noncomputable section |
| open CategoryTheory |
| open TwoSquare |
| namespace ActualMatePasting |
| universe u₁ u₂ u₃ u₄ u₅ u₆ v₁ v₂ v₃ v₄ v₅ v₆ |
| variable {A : Type u₁} {B : Type u₂} {C : Type u₃} {D : Type u₄} {E : Type u₅} {F : Type u₆} |
| [Category.{v₁} A] [Category.{v₂} B] [Category.{v₃} C] |
| [Category.{v₄} D] [Category.{v₅} E] [Category.{v₆} F] |
| {G : A ⥤ D} {H : B ⥤ E} {K : C ⥤ F} |
| {L₁ : A ⥤ B} {R₁ : B ⥤ A} {L₂ : D ⥤ E} {R₂ : E ⥤ D} |
| {L₃ : B ⥤ C} {R₃ : C ⥤ B} {L₄ : E ⥤ F} {R₄ : F ⥤ E} |
| (a₁ : L₁ ⊣ R₁) (a₂ : L₂ ⊣ R₂) (a₃ : L₃ ⊣ R₃) (a₄ : L₄ ⊣ R₄) |
| (s : TwoSquare R₁ H G R₂) (t : TwoSquare R₃ K H R₄) |
|
|
| lemma mate_app (M : A) : |
| ((mateEquiv a₁ a₂).symm s).natTrans.app M = |
| L₂.map (G.map (a₁.unit.app M)) ≫ L₂.map (s.natTrans.app (L₁.obj M)) ≫ |
| a₂.counit.app (H.obj (L₁.obj M)) := by |
| simp only [mateEquiv, Equiv.coe_fn_symm_mk, NatTrans.comp_app, Functor.leftUnitor_inv_app, Functor.whiskerRight_app, Functor.whiskerLeft_app, Functor.associator_hom_app, Functor.associator_inv_app, Functor.rightUnitor_hom_app, Functor.comp_map, Functor.comp_obj, Category.id_comp] |
| erw [L₂.map_id, L₂.map_id] |
| simp only [Category.id_comp] |
| erw [Category.comp_id] |
|
|
| lemma mate_hcomp : |
| (mateEquiv (a₁.comp a₃) (a₂.comp a₄)).symm (t ≫ₕ s) = |
| ((mateEquiv a₁ a₂).symm s) ≫ᵥ ((mateEquiv a₃ a₄).symm t) := by |
| apply (mateEquiv (a₁.comp a₃) (a₂.comp a₄)).injective |
| rw [Equiv.apply_symm_apply, mateEquiv_hcomp, Equiv.apply_symm_apply, |
| Equiv.apply_symm_apply] |
|
|
| lemma mate_hcomp_app (M : A) : |
| ((mateEquiv (a₁.comp a₃) (a₂.comp a₄)).symm (t ≫ₕ s)).natTrans.app M = |
| L₄.map (((mateEquiv a₁ a₂).symm s).natTrans.app M) ≫ |
| ((mateEquiv a₃ a₄).symm t).natTrans.app (L₁.obj M) := by |
| rw [mate_hcomp] |
| simp only [TwoSquare.vComp, NatTrans.comp_app, Functor.whiskerLeft_app, |
| Functor.whiskerRight_app, Functor.associator_hom_app, Functor.associator_inv_app, |
| Category.id_comp, Category.comp_id] |
|
|
| lemma mate_hcomp_isIso (M : A) |
| [IsIso (L₄.map (((mateEquiv a₁ a₂).symm s).natTrans.app M))] |
| [IsIso (((mateEquiv a₃ a₄).symm t).natTrans.app (L₁.obj M))] : |
| IsIso (((mateEquiv (a₁.comp a₃) (a₂.comp a₄)).symm (t ≫ₕ s)).natTrans.app M) := by |
| rw [mate_hcomp_app]; infer_instance |
|
|
| lemma map_mate_isIso (M : A) |
| [IsIso (((mateEquiv (a₁.comp a₃) (a₂.comp a₄)).symm (t ≫ₕ s)).natTrans.app M)] |
| [IsIso (((mateEquiv a₃ a₄).symm t).natTrans.app (L₁.obj M))] : |
| IsIso (L₄.map (((mateEquiv a₁ a₂).symm s).natTrans.app M)) := by |
| have he := mate_hcomp_app a₁ a₂ a₃ a₄ s t M |
| have : IsIso (L₄.map (((mateEquiv a₁ a₂).symm s).natTrans.app M) ≫ |
| ((mateEquiv a₃ a₄).symm t).natTrans.app (L₁.obj M)) := he ▸ inferInstance |
| exact IsIso.of_isIso_comp_right _ |
| (((mateEquiv a₃ a₄).symm t).natTrans.app (L₁.obj M)) |
| end ActualMatePasting |
|
|
| end |
|
|
| /-! Open Cartesian squares, including the source's affine charts, have invertible canonical base- |
| change mates. -/ |
| noncomputable section |
| open CategoryTheory CategoryTheory.Limits _root_.AlgebraicGeometry _root_.OAI.AlgebraicGeometry Opposite |
| namespace ActualSheafBaseChange |
| open Scheme.Modules |
| variable {B C D E : Scheme.{0}} |
| (f : C ⟶ B) (z : D ⟶ B) (w : E ⟶ C) (q : E ⟶ D) |
| [IsOpenImmersion z] [IsOpenImmersion w] |
| (h : IsPullback w q f z) |
|
|
| lemma restrict_map_app {M N : B.Modules} (φ : M ⟶ N) (U : D.Opens) : |
| ((restrictFunctor z).map φ).app U = φ.app (z ''ᵁ U) := rfl |
|
|
| def restrictMate : pushforward f ⋙ restrictFunctor z ⟶ restrictFunctor w ⋙ pushforward q := |
| ((mateEquiv (restrictAdjunction w) (restrictAdjunction z)).symm |
| (TwoSquare.mk _ _ _ _ (rightIso f z w q h.w).hom)).natTrans |
|
|
| lemma restrictMate_app_app (M : C.Modules) (U : D.Opens) : |
| ((restrictMate f z w q h).app M).app U = |
| M.presheaf.map (eqToHom |
| (IsOpenImmersion.image_preimage_eq_preimage_image_of_isPullback h.flip U)).op := by |
| unfold restrictMate |
| rw [ActualMatePasting.mate_app] |
| simp only [Scheme.Modules.Hom.comp_app, restrictAdjunction_counit_app_app] |
| dsimp only [TwoSquare.mk, TwoSquare.natTrans] |
| simp only [restrict_map_app, pushforward_map_app, restrictAdjunction_unit_app_app, rightIso, Iso.trans_hom, Iso.symm_hom, NatTrans.comp_app, Scheme.Modules.Hom.comp_app, pushforwardComp_hom_app_app, pushforwardComp_inv_app_app, pushforwardCongr_hom_app_app, restrict_map, pushforward_obj_presheaf_map] |
| erw [Category.id_comp, ← M.presheaf.map_comp, ← M.presheaf.map_comp] |
| congr 1 |
|
|
| lemma restrictMate_isIso (M : C.Modules) : IsIso ((restrictMate f z w q h).app M) := by |
| have HI : IsIso ((Scheme.Modules.toPresheaf D).map |
| ((restrictMate f z w q h).app M)) := by |
| apply (NatTrans.isIso_iff_isIso_app _).mpr |
| intro U |
| change IsIso (((restrictMate f z w q h).app M).app U.unop) |
| rw [restrictMate_app_app] |
| apply Functor.map_isIso |
| exact isIso_of_reflects_iso _ (Scheme.Modules.toPresheaf D) |
|
|
| lemma openCartesianMate_isIso (M : C.Modules) : IsIso ((mate f z w q h.w).app M) := by |
| let s := TwoSquare.mk _ _ _ _ (rightIso f z w q h.w).hom |
| have : IsIso (((mateEquiv (restrictAdjunction w) (restrictAdjunction z)).symm s).natTrans.app M) := |
| restrictMate_isIso f z w q h M |
| have H := ActualMateTransport.mate_transport_isIso |
| (restrictAdjunction w) (restrictAdjunction z) |
| (pullbackPushforwardAdjunction w) (pullbackPushforwardAdjunction z) |
| (Iso.refl _) (Iso.refl _) s M |
| rw [ActualMateTransport.square_refl] at H |
| exact H |
| end ActualSheafBaseChange |
|
|
| end |
|
|
| /-! Pasting the canonical scheme-module base-change mates with actual pullback along composite |
| scheme morphisms. -/ |
| noncomputable section |
| open CategoryTheory CategoryTheory.Limits _root_.AlgebraicGeometry _root_.OAI.AlgebraicGeometry |
| open TwoSquare |
| namespace ActualSheafBaseChange |
| open Scheme.Modules |
| variable {B C D E F G : Scheme.{0}} |
| (f : C ⟶ B) (z : D ⟶ B) (w : E ⟶ C) (q : E ⟶ D) |
| (h : w ≫ f = q ≫ z) |
| (z' : F ⟶ D) (w' : G ⟶ E) (q' : G ⟶ F) |
| (h' : w' ≫ q = q' ≫ z') |
|
|
| include h h' in |
| lemma paste_comm : (w' ≫ w) ≫ f = q' ≫ (z' ≫ z) := by |
| rw [Category.assoc, h, ← Category.assoc w', h', Category.assoc] |
|
|
| def square := TwoSquare.mk _ _ _ _ (rightIso f z w q h).hom |
|
|
| lemma right_square_paste : |
| ActualMateTransport.square (pushforwardComp w' w) (pushforwardComp z' z) |
| ((square q z' w' q' h') ≫ₕ (square f z w q h)) = |
| square f (z' ≫ z) (w' ≫ w) q' (paste_comm f z w q h z' w' q' h') := by |
| apply TwoSquare.ext |
| intro M |
| apply Scheme.Modules.hom_ext |
| intro U |
| simp only [ActualMateTransport.square, TwoSquare.whiskerTop, TwoSquare.whiskerBottom, |
| TwoSquare.hComp, square, rightIso, Iso.trans_hom, Iso.symm_hom, |
| NatTrans.comp_app, Functor.whiskerLeft_app, Functor.whiskerRight_app, |
| Functor.associator_hom_app, Functor.associator_inv_app, |
| Category.id_comp, Category.comp_id, Scheme.Modules.Hom.comp_app, |
| pushforwardComp_hom_app_app, pushforwardComp_inv_app_app, |
| pushforwardCongr_hom_app_app, pushforward_map_app] |
| change 𝟙 _ ≫ ((𝟙 _ ≫ M.presheaf.map _ ≫ 𝟙 _) ≫ |
| (𝟙 _ ≫ M.presheaf.map _ ≫ 𝟙 _)) ≫ 𝟙 _ = |
| 𝟙 _ ≫ M.presheaf.map _ ≫ 𝟙 _ |
| simp only [Category.id_comp, Category.comp_id] |
| erw [← M.presheaf.map_comp] |
| congr 1 |
|
|
| lemma pasted_mate_isIso (M : C.Modules) |
| [IsIso ((Scheme.Modules.pullback z').map ((mate f z w q h).app M))] |
| [IsIso ((mate q z' w' q' h').app ((Scheme.Modules.pullback w).obj M))] : |
| IsIso ((mate f (z' ≫ z) (w' ≫ w) q' |
| (paste_comm f z w q h z' w' q' h')).app M) := by |
| have : IsIso (((mateEquiv |
| ((pullbackPushforwardAdjunction w).comp (pullbackPushforwardAdjunction w')) |
| ((pullbackPushforwardAdjunction z).comp (pullbackPushforwardAdjunction z'))).symm |
| ((square q z' w' q' h') ≫ₕ (square f z w q h))).natTrans.app M) := |
| by |
| have H₁ : IsIso ((Scheme.Modules.pullback z').map |
| (((mateEquiv (pullbackPushforwardAdjunction w) (pullbackPushforwardAdjunction z)).symm |
| (square f z w q h)).natTrans.app M)) := ‹IsIso ((Scheme.Modules.pullback z').map ((mate f z w q h).app M))› |
| have H₂ : IsIso (((mateEquiv (pullbackPushforwardAdjunction w') (pullbackPushforwardAdjunction z')).symm |
| (square q z' w' q' h')).natTrans.app ((Scheme.Modules.pullback w).obj M)) := |
| ‹IsIso ((mate q z' w' q' h').app ((Scheme.Modules.pullback w).obj M))› |
| exact ActualMatePasting.mate_hcomp_isIso _ _ _ _ _ _ M |
| have H := ActualMateTransport.mate_transport_isIso |
| ((pullbackPushforwardAdjunction w).comp (pullbackPushforwardAdjunction w')) |
| ((pullbackPushforwardAdjunction z).comp (pullbackPushforwardAdjunction z')) |
| (pullbackPushforwardAdjunction (w' ≫ w)) (pullbackPushforwardAdjunction (z' ≫ z)) |
| (pushforwardComp w' w) (pushforwardComp z' z) |
| ((square q z' w' q' h') ≫ₕ (square f z w q h)) M |
| rw [right_square_paste] at H |
| exact H |
| lemma mate_isIso_congr (M : C.Modules) {z₂ : D ⟶ B} {w₂ : E ⟶ C} |
| (hz : z = z₂) (hw : w = w₂) (h₂ : w₂ ≫ f = q ≫ z₂) : |
| IsIso ((mate f z w q h).app M) ↔ IsIso ((mate f z₂ w₂ q h₂).app M) := by |
| subst z₂; subst w₂; rfl |
|
|
| lemma map_mate_of_pasted_isIso (M : C.Modules) |
| [IsIso ((mate f (z' ≫ z) (w' ≫ w) q' |
| (paste_comm f z w q h z' w' q' h')).app M)] |
| [IsIso ((mate q z' w' q' h').app ((Scheme.Modules.pullback w).obj M))] : |
| IsIso ((Scheme.Modules.pullback z').map ((mate f z w q h).app M)) := by |
| have he := ActualMateTransport.mate_transport_isIso_iff |
| ((pullbackPushforwardAdjunction w).comp (pullbackPushforwardAdjunction w')) |
| ((pullbackPushforwardAdjunction z).comp (pullbackPushforwardAdjunction z')) |
| (pullbackPushforwardAdjunction (w' ≫ w)) (pullbackPushforwardAdjunction (z' ≫ z)) |
| (pushforwardComp w' w) (pushforwardComp z' z) |
| ((square q z' w' q' h') ≫ₕ (square f z w q h)) M |
| rw [right_square_paste] at he |
| have HI : IsIso (((mateEquiv |
| ((pullbackPushforwardAdjunction w).comp (pullbackPushforwardAdjunction w')) |
| ((pullbackPushforwardAdjunction z).comp (pullbackPushforwardAdjunction z'))).symm |
| ((square q z' w' q' h') ≫ₕ (square f z w q h))).natTrans.app M) := he.mp |
| ‹IsIso ((mate f (z' ≫ z) (w' ≫ w) q' |
| (paste_comm f z w q h z' w' q' h')).app M)› |
| have H₂ : IsIso (((mateEquiv (pullbackPushforwardAdjunction w') (pullbackPushforwardAdjunction z')).symm |
| (square q z' w' q' h')).natTrans.app ((Scheme.Modules.pullback w).obj M)) := |
| ‹IsIso ((mate q z' w' q' h').app ((Scheme.Modules.pullback w).obj M))› |
| exact ActualMatePasting.map_mate_isIso |
| (pullbackPushforwardAdjunction w) (pullbackPushforwardAdjunction z) |
| (pullbackPushforwardAdjunction w') (pullbackPushforwardAdjunction z') |
| (square f z w q h) (square q z' w' q' h') M |
| end ActualSheafBaseChange |
|
|
| end |
|
|
| end OAI |
|
|
