| import Mathlib.CategoryTheory.Localization.CalculusOfFractions |
| import Mathlib.CategoryTheory.Linear.LinearFunctor |
|
|
| namespace OAI |
| namespace LittleFinitistic.DiagramLifting |
| open CategoryTheory CategoryTheory.Category CategoryTheory.Limits |
|
|
| variable {C D : Type*} [Category C] [Category D] |
| variable (L : C ⥤ D) (W : MorphismProperty C) [L.IsLocalization W] |
| variable [W.HasRightCalculusOfFractions] |
|
|
| /-- Finitely many localized arrows admit one common source denominator. -/ |
| theorem finite_roof (n : ℕ) (X : C) (Y : Fin n → C) |
| (f : ∀ i, L.obj X ⟶ L.obj (Y i)) : |
| ∃ (Z : C) (u : Z ⟶ X), W u ∧ |
| ∃ (g : ∀ i, Z ⟶ Y i), ∀ i, L.map u ≫ f i = L.map (g i) := by |
| induction n generalizing X with |
| | zero => exact ⟨X,𝟙 X,W.id_mem X,(fun i => Fin.elim0 i),fun i => Fin.elim0 i⟩ |
| | succ n ih => |
| obtain ⟨φ,hφ⟩ := Localization.exists_rightFraction L W (f 0) |
| obtain ⟨Z,u,hu,g,hg⟩ := ih φ.X' (fun i => Y i.succ) |
| (fun i => L.map φ.s ≫ f i.succ) |
| refine ⟨Z,u ≫ φ.s,W.comp_mem _ _ hu φ.hs,Fin.cases (u ≫ φ.f) g,?_⟩ |
| intro i |
| refine Fin.cases ?_ (fun j => ?_) i |
| · simp only [Fin.cases_zero,Functor.map_comp,assoc,hφ,φ.map_s_comp_map] |
| · simpa only [Fin.cases_succ,Functor.map_comp,assoc] using hg j |
|
|
| section Zero |
| variable [HasZeroMorphisms C] [HasZeroMorphisms D] [L.PreservesZeroMorphisms] |
|
|
| /-- A finite family vanishing after localization is annihilated by one source denominator. -/ |
| theorem finite_zero_refinement (n : ℕ) (X : C) (Y : Fin n → C) |
| (f : ∀ i, X ⟶ Y i) (hf : ∀ i, L.map (f i) = 0) : |
| ∃ (Z : C) (u : Z ⟶ X), W u ∧ ∀ i, u ≫ f i = 0 := by |
| induction n generalizing X with |
| | zero => exact ⟨X,𝟙 X,W.id_mem X,fun i => Fin.elim0 i⟩ |
| | succ n ih => |
| have h0 : L.map (f 0) = L.map (0 : X ⟶ Y 0) := by simpa using hf 0 |
| obtain ⟨X',u,hu,he⟩ := (MorphismProperty.map_eq_iff_precomp L W (f 0) 0).mp h0 |
| have he0 : u ≫ f 0 = 0 := by simpa using he |
| obtain ⟨Z,v,hv,hg⟩ := ih X' (fun i => Y i.succ) (fun i => u ≫ f i.succ) |
| (fun i => by simp [hf]) |
| refine ⟨Z,v ≫ u,W.comp_mem _ _ hv hu,?_⟩ |
| intro i |
| refine Fin.cases ?_ (fun j => ?_) i |
| · simp [assoc,he0] |
| · simpa only [assoc] using hg j |
|
|
| end Zero |
|
|
| open scoped BigOperators |
| variable {k : Type*} [CommRing k] [Preadditive C] [Preadditive D] |
| variable [Linear k C] [Linear k D] [L.Additive] [L.Linear k] |
|
|
| /-- A finite three-vertex diagram with arbitrary homogeneous quadratic relations |
| lifts along a right-fraction localization. The displayed denominator maps give |
| an isomorphism from the localized lift to the original entire diagram. -/ |
| theorem quadratic_diagram_lift (na nb nr : ℕ) (X₀ X₁ X₂ : C) |
| (a : Fin na → (L.obj X₀ ⟶ L.obj X₁)) |
| (b : Fin nb → (L.obj X₁ ⟶ L.obj X₂)) |
| (r : Fin nr → Fin na → Fin nb → k) |
| (hr : ∀ ρ, ∑ i, ∑ j, r ρ i j • (a i ≫ b j) = 0) : |
| ∃ (D₀ D₁ : C) (u₀ : D₀ ⟶ X₀) (u₁ : D₁ ⟶ X₁), W u₀ ∧ W u₁ ∧ |
| ∃ (f : Fin na → (D₀ ⟶ D₁)) (g : Fin nb → (D₁ ⟶ X₂)), |
| (∀ i, L.map u₀ ≫ a i = L.map (f i) ≫ L.map u₁) ∧ |
| (∀ j, L.map u₁ ≫ b j = L.map (g j)) ∧ |
| (∀ ρ, ∑ i, ∑ j, r ρ i j • (f i ≫ g j) = 0) := by |
| classical |
| obtain ⟨D₁,u₁,hu₁,g,hg⟩ := finite_roof L W nb X₁ (fun _ => X₂) b |
| have : IsIso (L.map u₁) := Localization.inverts L W _ hu₁ |
| obtain ⟨D₀,u₀,hu₀,f,hf⟩ := finite_roof L W na X₀ (fun _ => D₁) |
| (fun i => a i ≫ inv (L.map u₁)) |
| have hpath (i : Fin na) (j : Fin nb) : |
| L.map (f i ≫ g j) = L.map u₀ ≫ (a i ≫ b j) := by |
| rw [Functor.map_comp,← hf i,← hg j] |
| simp only [assoc,IsIso.inv_hom_id_assoc] |
| let relations : Fin nr → (D₀ ⟶ X₂) := fun ρ => ∑ i, ∑ j, r ρ i j • (f i ≫ g j) |
| have hrel (ρ : Fin nr) : L.map (relations ρ) = 0 := by |
| dsimp [relations] |
| simp only [Functor.map_sum,Functor.map_smul,hpath] |
| have h := congrArg (fun t => L.map u₀ ≫ t) (hr ρ) |
| simpa only [Preadditive.comp_sum,Linear.comp_smul,comp_zero] using h |
| obtain ⟨D₀',v,hv,hvrel⟩ := finite_zero_refinement L W nr D₀ (fun _ => X₂) relations hrel |
| refine ⟨D₀',D₁,v ≫ u₀,u₁,W.comp_mem _ _ hv hu₀,hu₁, |
| (fun i => v ≫ f i),g,?_,hg,?_⟩ |
| · intro i |
| have hi := congrArg (fun t => t ≫ L.map u₁) (hf i) |
| simp only [assoc,IsIso.inv_hom_id,comp_id] at hi |
| simp only [Functor.map_comp,assoc] |
| rw [← hi] |
| · intro ρ |
| have h := hvrel ρ |
| dsimp [relations] at h |
| simpa only [Preadditive.comp_sum,Linear.comp_smul,assoc] using h |
|
|
| include W in |
| /-- Every finite three-level quadratic diagram in the localized category, |
| including objects not literally presented as functor images, has an isomorphic lift. -/ |
| theorem finite_quadratic_diagram_lifting (na nb nr : ℕ) (Y₀ Y₁ Y₂ : D) |
| (a : Fin na → (Y₀ ⟶ Y₁)) (b : Fin nb → (Y₁ ⟶ Y₂)) |
| (r : Fin nr → Fin na → Fin nb → k) |
| (hr : ∀ ρ, ∑ i, ∑ j, r ρ i j • (a i ≫ b j) = 0) : |
| ∃ (X₀ X₁ X₂ : C) (e₀ : L.obj X₀ ≅ Y₀) (e₁ : L.obj X₁ ≅ Y₁) |
| (e₂ : L.obj X₂ ≅ Y₂) (f : Fin na → (X₀ ⟶ X₁)) (g : Fin nb → (X₁ ⟶ X₂)), |
| (∀ i, L.map (f i) ≫ e₁.hom = e₀.hom ≫ a i) ∧ |
| (∀ j, L.map (g j) ≫ e₂.hom = e₁.hom ≫ b j) ∧ |
| (∀ ρ, ∑ i, ∑ j, r ρ i j • (f i ≫ g j) = 0) := by |
| classical |
| have := Localization.essSurj L W |
| let X₀ := L.objPreimage Y₀ |
| let X₁ := L.objPreimage Y₁ |
| let X₂ := L.objPreimage Y₂ |
| let e₀ : L.obj X₀ ≅ Y₀ := L.objObjPreimageIso Y₀ |
| let e₁ : L.obj X₁ ≅ Y₁ := L.objObjPreimageIso Y₁ |
| let e₂ : L.obj X₂ ≅ Y₂ := L.objObjPreimageIso Y₂ |
| let a' := fun i => e₀.hom ≫ a i ≫ e₁.inv |
| let b' := fun j => e₁.hom ≫ b j ≫ e₂.inv |
| have hr' (ρ : Fin nr) : ∑ i, ∑ j, r ρ i j • (a' i ≫ b' j) = 0 := by |
| dsimp [a',b'] |
| simp only [assoc,Iso.inv_hom_id_assoc] |
| have h := congrArg (fun t => e₀.hom ≫ t ≫ e₂.inv) (hr ρ) |
| simpa only [Preadditive.comp_sum,Preadditive.sum_comp,Linear.comp_smul, |
| Linear.smul_comp,assoc,comp_zero,zero_comp] using h |
| obtain ⟨D₀,D₁,u₀,u₁,hu₀,hu₁,f,g,hf,hg,hrel⟩ := |
| quadratic_diagram_lift L W na nb nr X₀ X₁ X₂ a' b' r hr' |
| refine ⟨D₀,D₁,X₂,(Localization.isoOfHom L W u₀ hu₀) ≪≫ e₀, |
| (Localization.isoOfHom L W u₁ hu₁) ≪≫ e₁,e₂,f,g,?_,?_,hrel⟩ |
| · intro i |
| have h := congrArg (fun t => t ≫ e₁.hom) (hf i) |
| simpa only [a',Iso.trans_hom,Localization.isoOfHom_hom,assoc, |
| Iso.inv_hom_id,comp_id] using h.symm |
| · intro j |
| have h := congrArg (fun t => t ≫ e₂.hom) (hg j) |
| simpa only [b',Iso.trans_hom,Localization.isoOfHom_hom,assoc, |
| Iso.inv_hom_id,comp_id] using h.symm |
| end LittleFinitistic.DiagramLifting |
|
|
| end OAI |
|
|
