| import Mathlib |
| import OAI.SetTheory.PartitionConsistency.Algebra.MergerCones |
| import OAI.SetTheory.PartitionConsistency.Construction.SaturatedMonoids |
|
|
| namespace OAI |
|
|
| /-! ## MergerPresentation -/ |
|
|
| namespace PartitionConsistency.MergerAlgebra.Word |
| universe u v w |
| noncomputable section |
| variable {M : Type u} {D : Type v} {N : Type w} |
| [Monoid M] [RightFreeAction M D] [Monoid N] |
|
|
| / |
| in their displayed order; the target is an arbitrary monoid. -/ |
| def evaluate (f : M →* N) (g : D → N) : Word M D → N |
| | old x => f x |
| | snoc x d => evaluate f g x * g d |
|
|
| variable (f : M →* N) (g : D → N) |
| (hg : ∀ d x, g (RightFreeAction.act d x) = g d * f x) |
|
|
| include hg in |
| theorem evaluate_act (w : Word M D) (x : M) : |
| evaluate f g (act w x) = evaluate f g w * f x := by |
| cases w with |
| | old y => exact f.map_mul y x |
| | snoc w d => |
| change evaluate f g w * g (RightFreeAction.act d x) = (evaluate f g w * g d) * f x |
| rw [hg,mul_assoc] |
|
|
| include hg in |
| theorem evaluate_mul (x y : Word M D) : |
| evaluate f g (x*y) = evaluate f g x * evaluate f g y := by |
| induction y with |
| | old y => exact evaluate_act f g hg x y |
| | snoc y d ih => |
| change evaluate f g (x*y) * g d = evaluate f g x * (evaluate f g y * g d) |
| rw [ih,mul_assoc] |
|
|
| / |
| of the quotient of copies. -/ |
| def liftHom : Word M D →* N where |
| toFun := evaluate f g |
| map_one' := f.map_one |
| map_mul' := evaluate_mul f g hg |
|
|
| @[simp] theorem liftHom_old (x : M) : liftHom f g hg (old x) = f x := rfl |
|
|
| @[simp] theorem liftHom_letter (d : D) : |
| liftHom f g hg (snoc (old 1) d) = g d := by |
| change f 1 * g d = g d |
| rw [f.map_one,one_mul] |
|
|
| / |
| This asserts uniqueness in arbitrary target monoids, not just conservative |
| ones. -/ |
| theorem hom_ext (F G : Word M D →* N) |
| (ho : ∀ x, F (old x) = G (old x)) |
| (hn : ∀ d, F (snoc (old 1) d) = G (snoc (old 1) d)) : F = G := by |
| apply MonoidHom.ext |
| intro w |
| induction w with |
| | old x => exact ho x |
| | snoc w d ih => |
| have he : snoc w d = w * snoc (old 1) d := by |
| change snoc w d = snoc (w * 1) d |
| rw [mul_one] |
| rw [he,F.map_mul,G.map_mul,ih,hn] |
|
|
| end |
| end PartitionConsistency.MergerAlgebra.Word |
|
|
| namespace PartitionConsistency.DiagramForcing.OverlapPrescription |
| universe u v |
| noncomputable section |
| variable {M : Type u} [LeftCancelMonoid M] {n : ℕ} |
| (P : OverlapPrescription M n) (hP : P.Valid) |
| {N : Type v} [Monoid N] (f : M →* N) (p : Fin n → N) |
|
|
| / |
| Diagonal entries of `start` are ignored, as in the definition of `Rel`. |
| Reflected joins, nonjoins or injectivity are not required in the target. -/ |
| def Satisfies : Prop := |
| ∀ i j a b, i ≠ j → P.start i j = some (a,b) → p i * f a = p j * f b |
|
|
| variable (hp : P.Satisfies f p) |
|
|
| include hp in |
| theorem satisfies_rel {z w : Fin n × M} (h : P.Rel z w) : |
| p z.1 * f z.2 = p w.1 * f w.2 := by |
| obtain ⟨i,x⟩ := z |
| obtain ⟨j,y⟩ := w |
| by_cases hij : i = j |
| · subst j |
| exact congrArg (fun t => p i * f t) ((P.rel_same_copy i x y).mp h) |
| · simp only [Rel,hij,↓reduceIte] at h |
| cases hs : P.start i j with |
| | none => simp only [hs] at h |
| | some ab => |
| obtain ⟨a,b⟩ := ab |
| rw [hs] at h |
| obtain ⟨t,rfl,rfl⟩ := h |
| change p i * f (a*t) = p j * f (b*t) |
| rw [f.map_mul,f.map_mul,← mul_assoc,← mul_assoc,hp i j a b hij hs] |
|
|
| / |
| collection of formal copies. -/ |
| def interpretedCopy : P.Copies hP → N := |
| Quotient.lift (fun z : Fin n × M => p z.1 * f z.2) |
| (fun _ _ h => P.satisfies_rel f p hp h) |
|
|
| @[simp] theorem interpretedCopy_copy (i : Fin n) (x : M) : |
| P.interpretedCopy hP f p hp (P.copy hP i x) = p i * f x := rfl |
|
|
| @[simp] theorem interpretedCopy_act (d : P.Copies hP) (x : M) : |
| P.interpretedCopy hP f p hp (MergerAlgebra.RightFreeAction.act d x) = |
| P.interpretedCopy hP f p hp d * f x := by |
| induction d using Quotient.inductionOn with |
| | h z => |
| change p z.1 * f (z.2*x) = (p z.1*f z.2)*f x |
| rw [f.map_mul,mul_assoc] |
|
|
| / |
| relative monoid presentation used in the countable-base rearrangement. -/ |
| def presentedLift : P.Merger hP →* N := |
| MergerAlgebra.Word.liftHom f (P.interpretedCopy hP f p hp) |
| (P.interpretedCopy_act hP f p hp) |
|
|
| @[simp] theorem presentedLift_old (x : M) : |
| P.presentedLift hP f p hp (.old x) = f x := rfl |
|
|
| @[simp] theorem presentedLift_root (i : Fin n) : |
| P.presentedLift hP f p hp (P.root hP i) = p i := by |
| change f 1 * (p i * f 1) = p i |
| rw [f.map_one,one_mul,mul_one] |
|
|
| / |
| many roots. This is the uniqueness part needed when comparing reordered |
| presentations. -/ |
| theorem presentedHom_ext (F G : P.Merger hP →* N) |
| (ho : ∀ x, F (.old x) = G (.old x)) |
| (hn : ∀ i, F (P.root hP i) = G (P.root hP i)) : F = G := by |
| apply MergerAlgebra.Word.hom_ext F G ho |
| intro d |
| induction d using Quotient.inductionOn with |
| | h z => |
| change F (.snoc (.old 1) (P.copy hP z.1 z.2)) = |
| G (.snoc (.old 1) (P.copy hP z.1 z.2)) |
| rw [← P.root_mul_old hP z.1 z.2,F.map_mul,G.map_mul,hn,ho] |
|
|
| include hp in |
| theorem existsUnique_presentedHom : |
| ∃! F : P.Merger hP →* N, |
| (∀ x, F (.old x) = f x) ∧ (∀ i, F (P.root hP i) = p i) := by |
| refine ⟨P.presentedLift hP f p hp, |
| ⟨P.presentedLift_old hP f p hp,P.presentedLift_root hP f p hp⟩,?_⟩ |
| intro F hF |
| apply P.presentedHom_ext hP |
| · intro x |
| exact (hF.1 x).trans (P.presentedLift_old hP f p hp x).symm |
| · intro i |
| exact (hF.2 i).trans (P.presentedLift_root hP f p hp i).symm |
|
|
| / |
| theorem roots_satisfy : P.Satisfies MergerAlgebra.Word.oldHom (P.root hP) := by |
| intro i j a b hij hab |
| apply (P.root_mul_eq_iff hP (i,a) (j,b)).mpr |
| simp only [Rel,hij,↓reduceIte,hab] |
| exact ⟨1,(mul_one a).symm,(mul_one b).symm⟩ |
|
|
| / |
| necessarily satisfies those relations. -/ |
| theorem map_roots_satisfy (F : P.Merger hP →* N) : |
| P.Satisfies (F.comp MergerAlgebra.Word.oldHom) (fun i => F (P.root hP i)) := by |
| intro i j a b hij hab |
| simpa only [MonoidHom.comp_apply,F.map_mul] using |
| congrArg F (P.roots_satisfy hP i j a b hij hab) |
|
|
| end |
| end PartitionConsistency.DiagramForcing.OverlapPrescription |
|
|
|
|
| /-! ## SimulationPushout -/ |
|
|
| /-! The conservative simulations are also categorical pushouts among *all* |
| monoids. This supplies the presentation comparison, which alone is not yet |
| a countable-base rearrangement. -/ |
| namespace PartitionConsistency.MonoidPushout |
| universe u |
| noncomputable section |
| variable {A B C D : Type u} [Monoid A] [Monoid B] [Monoid C] [Monoid D] |
|
|
| structure IsPushout (f : A →* B) (g : A →* C) (i : B →* D) (j : C →* D) : Prop where |
| comm : i.comp f = j.comp g |
| universal : ∀ {N : Type u} [Monoid N] (b : B →* N) (c : C →* N), |
| b.comp f = c.comp g → ∃! t : D →* N, t.comp i = b ∧ t.comp j = c |
|
|
| namespace IsPushout |
| variable {f : A →* B} {g : A →* C} {i : B →* D} {j : C →* D} |
| variable (h : IsPushout f g i j) |
|
|
| def lift {N : Type u} [Monoid N] (b : B →* N) (c : C →* N) |
| (hc : b.comp f = c.comp g) : D →* N := (h.universal b c hc).choose |
|
|
| @[simp] theorem lift_comp_left {N : Type u} [Monoid N] (b : B →* N) (c : C →* N) |
| (hc : b.comp f = c.comp g) : (h.lift b c hc).comp i = b := |
| (h.universal b c hc).choose_spec.1.1 |
|
|
| @[simp] theorem lift_comp_right {N : Type u} [Monoid N] (b : B →* N) (c : C →* N) |
| (hc : b.comp f = c.comp g) : (h.lift b c hc).comp j = c := |
| (h.universal b c hc).choose_spec.1.2 |
|
|
| include h in |
| theorem hom_ext {N : Type u} [Monoid N] (s t : D →* N) |
| (hb : s.comp i = t.comp i) (hc : s.comp j = t.comp j) : s = t := by |
| have hsq : (t.comp i).comp f = (t.comp j).comp g := by |
| rw [MonoidHom.comp_assoc,MonoidHom.comp_assoc,h.comm] |
| obtain ⟨l,hl,hu⟩ := h.universal (t.comp i) (t.comp j) hsq |
| exact (hu s ⟨hb,hc⟩).trans (hu t ⟨rfl,rfl⟩).symm |
|
|
| / |
| def equiv {E : Type u} [Monoid E] {i' : B →* E} {j' : C →* E} |
| (h' : IsPushout f g i' j') : D ≃* E := by |
| let F := h.lift i' j' h'.comm |
| let G := h'.lift i j h.comm |
| have hFG : F.comp G = MonoidHom.id E := by |
| apply h'.hom_ext |
| · rw [MonoidHom.comp_assoc,h'.lift_comp_left,h.lift_comp_left,MonoidHom.id_comp] |
| · rw [MonoidHom.comp_assoc,h'.lift_comp_right,h.lift_comp_right,MonoidHom.id_comp] |
| have hGF : G.comp F = MonoidHom.id D := by |
| apply h.hom_ext |
| · rw [MonoidHom.comp_assoc,h.lift_comp_left,h'.lift_comp_left,MonoidHom.id_comp] |
| · rw [MonoidHom.comp_assoc,h.lift_comp_right,h'.lift_comp_right,MonoidHom.id_comp] |
| exact |
| { F with |
| invFun := G |
| left_inv := fun x => DFunLike.congr_fun hGF x |
| right_inv := fun x => DFunLike.congr_fun hFG x } |
|
|
| @[simp] theorem equiv_comp_left {E : Type u} [Monoid E] {i' : B →* E} {j' : C →* E} |
| (h' : IsPushout f g i' j') : (h.equiv h').toMonoidHom.comp i = i' := |
| h.lift_comp_left i' j' h'.comm |
|
|
| @[simp] theorem equiv_comp_right {E : Type u} [Monoid E] {i' : B →* E} {j' : C →* E} |
| (h' : IsPushout f g i' j') : (h.equiv h').toMonoidHom.comp j = j' := |
| h.lift_comp_right i' j' h'.comm |
|
|
| end IsPushout |
| end |
| end PartitionConsistency.MonoidPushout |
|
|
| namespace PartitionConsistency.DiagramForcing.OverlapPrescription |
| universe u |
| noncomputable section |
| open DiagramOrder MonoidPushout MergerAlgebra |
| variable {A B : Type u} [LeftCancelMonoid A] [IsConical A] [LeftCancelMonoid B] |
| {n : ℕ} (P : OverlapPrescription A n) (hP : P.Valid) |
| (hA : HasConditionalJoins (LeftDivOrder A)) {f : A →* B} (hf : Conservative f) |
|
|
| @[simp] theorem mergerSimulation_root (i : Fin n) : |
| P.mergerSimulation hP hA hf (P.root hP i) = |
| (P.map f).root (P.valid_map hP hA hf) i := by |
| change Word.snoc (Word.old (f 1)) |
| ((P.map f).copy (P.valid_map hP hA hf) i (f 1)) = _ |
| rw [f.map_one] |
| rfl |
|
|
| omit [IsConical A] in |
| theorem satisfies_map_iff {N : Type u} [Monoid N] (g : B →* N) (p : Fin n → N) : |
| (P.map f).Satisfies g p ↔ P.Satisfies (g.comp f) p := by |
| constructor |
| · intro h i j a b hij hab |
| exact h i j (f a) (f b) hij (by simp only [map_start,hab,Option.map_some]) |
| · intro h i j a b hij hab |
| change (P.start i j).map _ = some (a,b) at hab |
| cases hs : P.start i j with |
| | none => simp only [hs,Option.map_none] at hab; cases hab |
| | some ab => |
| simp only [hs,Option.map_some,Option.some.injEq,Prod.mk.injEq] at hab |
| rcases hab with ⟨ha,hb⟩ |
| subst a; subst b |
| exact h i j ab.1 ab.2 hij hs |
|
|
| / |
| relative presentation. -/ |
| theorem mergerSimulation_pushout : |
| IsPushout (Word.oldHom : A →* P.Merger hP) f |
| (P.mergerSimulation hP hA hf) |
| (Word.oldHom : B →* (P.map f).Merger (P.valid_map hP hA hf)) where |
| comm := by ext x; rfl |
| universal s t hc := by |
| let p (i : Fin n) := s (P.root hP i) |
| have hp : (P.map f).Satisfies t p := by |
| apply (P.satisfies_map_iff t p).mpr |
| rw [← hc] |
| exact P.map_roots_satisfy hP s |
| let l := (P.map f).presentedLift (P.valid_map hP hA hf) t p hp |
| have hlold : l.comp Word.oldHom = t := by ext x; rfl |
| have hlnew : l.comp (P.mergerSimulation hP hA hf) = s := by |
| apply P.presentedHom_ext hP |
| · intro x |
| change t (f x) = s (Word.old x) |
| exact (DFunLike.congr_fun hc x).symm |
| · intro i |
| simp only [MonoidHom.comp_apply,mergerSimulation_root, |
| l,presentedLift_root,p] |
| refine ⟨l,⟨hlnew,hlold⟩,?_⟩ |
| intro k hk |
| apply (P.map f).presentedHom_ext (P.valid_map hP hA hf) |
| · intro x |
| exact (DFunLike.congr_fun hk.2 x).trans (DFunLike.congr_fun hlold x).symm |
| · intro i |
| have hki := DFunLike.congr_fun hk.1 (P.root hP i) |
| simpa only [MonoidHom.comp_apply,mergerSimulation_root, |
| l,presentedLift_root,p] using hki |
|
|
| end |
| end PartitionConsistency.DiagramForcing.OverlapPrescription |
|
|
| namespace PartitionConsistency.ProbeAlgebra.Path |
| universe u |
| noncomputable section |
| open DiagramOrder MonoidPushout |
| variable {A B : Type u} [LeftCancelMonoid A] [IsConical A] |
| [LeftCancelMonoid B] [IsConical B] {a e : A} (P : Path A a) |
| (he : e ≠ 1) {f : A →* B} (hf : Conservative f) (b : A) (hb : b ≠ 1) |
|
|
| include hb in |
| / |
| transition and exit presentation. No universal property is assumed. -/ |
| theorem simulation_pushout : |
| IsPushout (Word.oldHom (P.alphabet he) b) f (P.simulation he hf b) |
| (Word.oldHom ((P.map f).alphabet |
| (fun h => he (hf.injective (h.trans f.map_one.symm)))) (f b)) where |
| comm := by ext x; rfl |
| universal s t hc := by |
| let he' : f e ≠ 1 := fun h => he (hf.injective (h.trans f.map_one.symm)) |
| let hb' : f b ≠ 1 := fun h => hb (hf.injective (h.trans f.map_one.symm)) |
| let p (i : ℕ) := s (P.probe he b hb i) |
| have hco (x : A) : s (Word.old (P.alphabet he) b x) = t (f x) := |
| DFunLike.congr_fun hc x |
| have hp : ∀ i, t ((P.map f).factor i (i+1) (Nat.le_succ i)) * p (i+1) = p i := by |
| intro i |
| rw [map_factor] |
| change t (f (P.factor i (i+1) (Nat.le_succ i))) * s (P.probe he b hb (i+1)) = |
| s (P.probe he b hb i) |
| rw [← hco,← s.map_mul,P.probe_transition he b hb] |
| have hpexit : ∀ i, p i * t (f b) = t ((P.map f).terminal i * f e) := by |
| intro i |
| rw [map_terminal,← f.map_mul,← hco,← hco,← s.map_mul] |
| exact congrArg s (P.probe_mul_b he b hb i) |
| let l := (P.map f).presentedLift he' (f b) t p (fun i => (hp i).symm) hpexit |
| have hlold : l.comp (Word.oldHom ((P.map f).alphabet he') (f b)) = t := by |
| ext x; rfl |
| have hlnew : l.comp (P.simulation he hf b) = s := by |
| apply P.presentedHom_ext he b hb |
| · intro x |
| exact (hco x).symm |
| · intro i |
| simp only [MonoidHom.comp_apply,simulation_probe,l,presentedLift_probe,p] |
| refine ⟨l,⟨hlnew,hlold⟩,?_⟩ |
| intro k hk |
| apply (P.map f).presentedHom_ext he' (f b) hb' |
| · intro x |
| exact (DFunLike.congr_fun hk.2 x).trans (DFunLike.congr_fun hlold x).symm |
| · intro i |
| have hki := DFunLike.congr_fun hk.1 (P.probe he b hb i) |
| simpa only [MonoidHom.comp_apply,simulation_probe,l,presentedLift_probe,p] using hki |
|
|
| end |
| end PartitionConsistency.ProbeAlgebra.Path |
|
|
|
|
| /-! ## PushoutPasting -/ |
|
|
| /-! Universal-property bookkeeping for moving already selected cells before |
| omitted cells. These lemmas are about literal monoid pushouts; they do not |
| assert the existence of a selected subconstruction. -/ |
| namespace PartitionConsistency.MonoidPushout |
| universe u |
| noncomputable section |
| variable {A B C D E F : Type u} [Monoid A] [Monoid B] [Monoid C] |
| [Monoid D] [Monoid E] [Monoid F] |
|
|
| namespace IsPushout |
|
|
| / |
| theorem flip {f : A →* B} {g : A →* C} {i : B →* D} {j : C →* D} |
| (h : IsPushout f g i j) : IsPushout g f j i where |
| comm := h.comm.symm |
| universal b c hc := by |
| obtain ⟨t,ht,hu⟩ := h.universal c b hc.symm |
| exact ⟨t,⟨ht.2,ht.1⟩,fun k hk => hu k ⟨hk.2,hk.1⟩⟩ |
|
|
| / |
| `A → B → E`, `C → D → F`, the two vertical composites are unchanged. -/ |
| theorem paste {f : A →* B} {g : A →* C} {i : B →* D} {j : C →* D} |
| {k : B →* E} {l : D →* F} {m : E →* F} |
| (h : IsPushout f g i j) (h' : IsPushout k i m l) : |
| IsPushout (k.comp f) g m (l.comp j) where |
| comm := by |
| rw [← MonoidHom.comp_assoc,h'.comm,MonoidHom.comp_assoc,h.comm, |
| MonoidHom.comp_assoc] |
| universal b c hc := by |
| let d := h.lift (b.comp k) c (by simpa only [MonoidHom.comp_assoc] using hc) |
| have hd₁ : d.comp i = b.comp k := h.lift_comp_left _ _ _ |
| have hd₂ : d.comp j = c := h.lift_comp_right _ _ _ |
| let t := h'.lift b d hd₁.symm |
| have ht₁ : t.comp m = b := h'.lift_comp_left _ _ _ |
| have ht₂ : t.comp l = d := h'.lift_comp_right _ _ _ |
| refine ⟨t,⟨ht₁,by rw [← MonoidHom.comp_assoc,ht₂,hd₂]⟩,?_⟩ |
| intro s hs |
| apply h'.hom_ext |
| · exact hs.1.trans ht₁.symm |
| · rw [ht₂] |
| apply h.hom_ext |
| · rw [MonoidHom.comp_assoc,← h'.comm,← MonoidHom.comp_assoc,hs.1,hd₁] |
| · rw [MonoidHom.comp_assoc,hs.2,hd₂] |
| |
| /-- Conversely, if the left square and the outer rectangle are pushouts, |
| then the right square is a pushout. This is the cancellation used after the |
| selected future cells have been moved in front of one omitted cell. -/ |
| theorem cancel_left {f : A →* B} {g : A →* C} {i : B →* D} {j : C →* D} |
| {k : B →* E} {l : D →* F} {m : E →* F} |
| (h : IsPushout f g i j) (hc : m.comp k = l.comp i) |
| (ho : IsPushout (k.comp f) g m (l.comp j)) : IsPushout k i m l where |
| comm := hc |
| universal b d hd := by |
| have he : b.comp (k.comp f) = (d.comp j).comp g := by |
| rw [← MonoidHom.comp_assoc,hd,MonoidHom.comp_assoc,h.comm, |
| MonoidHom.comp_assoc] |
| let t := ho.lift b (d.comp j) he |
| have ht₁ : t.comp m = b := ho.lift_comp_left _ _ _ |
| have ht₂ : t.comp (l.comp j) = d.comp j := ho.lift_comp_right _ _ _ |
| have ht : t.comp l = d := by |
| apply h.hom_ext |
| · rw [MonoidHom.comp_assoc,← hc,← MonoidHom.comp_assoc,ht₁,hd] |
| · rw [MonoidHom.comp_assoc,ht₂] |
| refine ⟨t,⟨ht₁,ht⟩,?_⟩ |
| intro s hs |
| apply ho.hom_ext |
| · exact hs.1.trans ht₁.symm |
| · rw [← MonoidHom.comp_assoc,hs.2,← MonoidHom.comp_assoc,ht] |
| |
| /-- The degenerate cell is also a pushout; no generator is added. -/ |
| theorem of_id (f : A →* B) : |
| IsPushout (MonoidHom.id A) f f (MonoidHom.id B) where |
| comm := by simp only [MonoidHom.comp_id,MonoidHom.id_comp] |
| universal a b h := by |
| simp only [MonoidHom.comp_id] at h |
| refine ⟨b,⟨h.symm,MonoidHom.comp_id b⟩,?_⟩ |
| intro t ht |
| simpa only [MonoidHom.comp_id] using ht.2 |
| |
| /-- Postcomposing a pushout apex with a fixed monoid isomorphism preserves |
| its full universal property, not just its conservative embeddings. -/ |
| theorem map_apex {f : A →* B} {g : A →* C} {i : B →* D} {j : C →* D} |
| (h : IsPushout f g i j) (e : D ≃* E) : |
| IsPushout f g (e.toMonoidHom.comp i) (e.toMonoidHom.comp j) where |
| comm := by rw [MonoidHom.comp_assoc,h.comm,MonoidHom.comp_assoc] |
| universal b c hc := by |
| let t := (h.lift b c hc).comp e.symm.toMonoidHom |
| have he (x : D) : t (e x) = h.lift b c hc x := |
| congrArg (h.lift b c hc) (e.symm_apply_apply x) |
| have ht₁ : t.comp (e.toMonoidHom.comp i) = b := by |
| ext x |
| exact (he (i x)).trans (DFunLike.congr_fun (h.lift_comp_left b c hc) x) |
| have ht₂ : t.comp (e.toMonoidHom.comp j) = c := by |
| ext x |
| exact (he (j x)).trans (DFunLike.congr_fun (h.lift_comp_right b c hc) x) |
| refine ⟨t,⟨ht₁,ht₂⟩,?_⟩ |
| intro s hs |
| have hh : s.comp e.toMonoidHom = t.comp e.toMonoidHom := by |
| apply h.hom_ext |
| · simpa only [MonoidHom.comp_assoc] using hs.1.trans ht₁.symm |
| · simpa only [MonoidHom.comp_assoc] using hs.2.trans ht₂.symm |
| ext x |
| obtain ⟨y,rfl⟩ := e.surjective x |
| exact DFunLike.congr_fun hh y |
| |
| end IsPushout |
| end |
| end PartitionConsistency.MonoidPushout |
| |
| end OAI |
| |
