\hzSSKJrJrJrJrJrJr SSKJr SSK J r J r J r SSK Jr "SS\ 5r"SS\5r"S S \5r"S S \5r"S S\5r"SS\5r"SS\5r"SS\5rg))SBasicDictSymbolTuplesympify)Str)Set FiniteSetEmptySet)iterablec\rSrSrSrSrSrg)Classa The base class for any kind of class in the set-theoretic sense. Explanation =========== In axiomatic set theories, everything is a class. A class which can be a member of another class is a set. A class which is not a member of another class is a proper class. The class `\{1, 2\}` is a set; the class of all sets is a proper class. This class is essentially a synonym for :class:`sympy.core.Set`. The goal of this class is to assure easier migration to the eventual proper implementation of set theory. FN)__name__ __module__ __qualname____firstlineno____doc__ is_proper__static_attributes__rT/var/www/auris/envauris/lib/python3.13/site-packages/sympy/categories/baseclasses.pyrrsIrrc\rSrSrSrSrg)Objectz The base class for any kind of object in an abstract category. Explanation =========== While technically any instance of :class:`~.Basic` will do, this class is the recommended way to create abstract objects in abstract categories. rN)rrrrrrrrrrrs rrcJ\rSrSrSrSr\S5r\S5rSr Sr Sr g ) Morphism'ae The base class for any morphism in an abstract category. Explanation =========== In abstract categories, a morphism is an arrow between two category objects. The object where the arrow starts is called the domain, while the object where the arrow ends is called the codomain. Two morphisms between the same pair of objects are considered to be the same morphisms. To distinguish between morphisms between the same objects use :class:`NamedMorphism`. It is prohibited to instantiate this class. Use one of the derived classes instead. See Also ======== IdentityMorphism, NamedMorphism, CompositeMorphism c[S5e)Nz:Cannot instantiate Morphism. Use derived classes instead.NotImplementedError)clsdomaincodomains r__new__Morphism.__new__?s! HJ Krc URS$)z Returns the domain of the morphism. Examples ======== >>> from sympy.categories import Object, NamedMorphism >>> A = Object("A") >>> B = Object("B") >>> f = NamedMorphism(A, B, "f") >>> f.domain Object("A") rargsselfs rr%Morphism.domainC yy|rc URS$)z Returns the codomain of the morphism. Examples ======== >>> from sympy.categories import Object, NamedMorphism >>> A = Object("A") >>> B = Object("B") >>> f = NamedMorphism(A, B, "f") >>> f.codomain Object("B") r*r,s rr&Morphism.codomainUr/rc[X5$)a! Composes self with the supplied morphism. The order of elements in the composition is the usual order, i.e., to construct `g\circ f` use ``g.compose(f)``. Examples ======== >>> from sympy.categories import Object, NamedMorphism >>> A = Object("A") >>> B = Object("B") >>> C = Object("C") >>> f = NamedMorphism(A, B, "f") >>> g = NamedMorphism(B, C, "g") >>> g * f CompositeMorphism((NamedMorphism(Object("A"), Object("B"), "f"), NamedMorphism(Object("B"), Object("C"), "g"))) >>> (g * f).domain Object("A") >>> (g * f).codomain Object("C") )CompositeMorphismr-others rcomposeMorphism.composegs2!--rc$URU5$)z Composes self with the supplied morphism. The semantics of this operation is given by the following equation: ``g * f == g.compose(f)`` for composable morphisms ``g`` and ``f``. See Also ======== compose )r7r5s r__mul__Morphism.__mul__s||E""rrN) rrrrrr'propertyr%r&r7r:rrrrrr's?.K"".6 #rrc.\rSrSrSrSr\S5rSrg)IdentityMorphisma Represents an identity morphism. Explanation =========== An identity morphism is a morphism with equal domain and codomain, which acts as an identity with respect to composition. Examples ======== >>> from sympy.categories import Object, NamedMorphism, IdentityMorphism >>> A = Object("A") >>> B = Object("B") >>> f = NamedMorphism(A, B, "f") >>> id_A = IdentityMorphism(A) >>> id_B = IdentityMorphism(B) >>> f * id_A == f True >>> id_B * f == f True See Also ======== Morphism c.[R"X5$N)rr')r$r%s rr'IdentityMorphism.__new__s}}S))rcUR$rA)r%r,s rr&IdentityMorphism.codomains {{rrN) rrrrrr'r<r&rrrrr>r>s 8*rr>c.\rSrSrSrSr\S5rSrg) NamedMorphisma Represents a morphism which has a name. Explanation =========== Names are used to distinguish between morphisms which have the same domain and codomain: two named morphisms are equal if they have the same domains, codomains, and names. Examples ======== >>> from sympy.categories import Object, NamedMorphism >>> A = Object("A") >>> B = Object("B") >>> f = NamedMorphism(A, B, "f") >>> f NamedMorphism(Object("A"), Object("B"), "f") >>> f.name 'f' See Also ======== Morphism cU(d [S5e[U[5(d [U5n[R"XX#5$)Nz!Empty morphism names not allowed.) ValueError isinstancer rr')r$r%r&names rr'NamedMorphism.__new__s8@A A$$$t9D}}S(99rc4URSR$)z Returns the name of the morphism. Examples ======== >>> from sympy.categories import Object, NamedMorphism >>> A = Object("A") >>> B = Object("B") >>> f = NamedMorphism(A, B, "f") >>> f.name 'f' r+rKr,s rrKNamedMorphism.names yy|   rrN) rrrrrr'r<rKrrrrrFrFs 6:!!rrFcd\rSrSrSr\S5rSr\S5r \S5r \S5r Sr S r g ) r4a7 Represents a morphism which is a composition of other morphisms. Explanation =========== Two composite morphisms are equal if the morphisms they were obtained from (components) are the same and were listed in the same order. The arguments to the constructor for this class should be listed in diagram order: to obtain the composition `g\circ f` from the instances of :class:`Morphism` ``g`` and ``f`` use ``CompositeMorphism(f, g)``. Examples ======== >>> from sympy.categories import Object, NamedMorphism, CompositeMorphism >>> A = Object("A") >>> B = Object("B") >>> C = Object("C") >>> f = NamedMorphism(A, B, "f") >>> g = NamedMorphism(B, C, "g") >>> g * f CompositeMorphism((NamedMorphism(Object("A"), Object("B"), "f"), NamedMorphism(Object("B"), Object("C"), "g"))) >>> CompositeMorphism(f, g) == g * f True c[U[5(aXR-$[U[5(aU$U[ U5-$)a Intelligently adds ``morphism`` to tuple ``t``. Explanation =========== If ``morphism`` is a composite morphism, its components are added to the tuple. If ``morphism`` is an identity, nothing is added to the tuple. No composability checks are performed. )rJr4 componentsr>r)tmorphisms r _add_morphismCompositeMorphism._add_morphismsE h 1 2 2*** * "2 3 3HuX& &rc0U(a2[US[5(d[R"U/USQ76$[ 5n[ XSS5Htup4[U[5(a[U[5(d [ S5eURUR:wa [S5e[RX#5nMv [RX!S5nU(dUS$[U5S:XaUS$[R"X5$)Nrr1z!All components must be morphisms.zUncomposable morphisms.) rJrr4r'rzip TypeErrorr&r%rIrWlenr)r$rTnormalised_componentscurrent followings rr'CompositeMorphism.__new__'s jAAA%,,SA:a=A A %"%jQR."A Ggx00"9h77 CDD9#3#33 !:;;$5$C$C%%0 !#B!2 ? ? !b>!3%a= & '1 ,(+ +}}S88rc URS$)ar Returns the components of this composite morphism. Examples ======== >>> from sympy.categories import Object, NamedMorphism >>> A = Object("A") >>> B = Object("B") >>> C = Object("C") >>> f = NamedMorphism(A, B, "f") >>> g = NamedMorphism(B, C, "g") >>> (g * f).components (NamedMorphism(Object("A"), Object("B"), "f"), NamedMorphism(Object("B"), Object("C"), "g")) rr*r,s rrTCompositeMorphism.componentsJs&yy|rc4URSR$)ae Returns the domain of this composite morphism. The domain of the composite morphism is the domain of its first component. Examples ======== >>> from sympy.categories import Object, NamedMorphism >>> A = Object("A") >>> B = Object("B") >>> C = Object("C") >>> f = NamedMorphism(A, B, "f") >>> g = NamedMorphism(B, C, "g") >>> (g * f).domain Object("A") r)rTr%r,s rr%CompositeMorphism.domain_s*q!(((rc4URSR$)al Returns the codomain of this composite morphism. The codomain of the composite morphism is the codomain of its last component. Examples ======== >>> from sympy.categories import Object, NamedMorphism >>> A = Object("A") >>> B = Object("B") >>> C = Object("C") >>> f = NamedMorphism(A, B, "f") >>> g = NamedMorphism(B, C, "g") >>> (g * f).codomain Object("C") rZ)rTr&r,s rr&CompositeMorphism.codomainvs*r"+++rcD[URURU5$)a Forgets the composite structure of this morphism. Explanation =========== If ``new_name`` is not empty, returns a :class:`NamedMorphism` with the supplied name, otherwise returns a :class:`Morphism`. In both cases the domain of the new morphism is the domain of this composite morphism and the codomain of the new morphism is the codomain of this composite morphism. Examples ======== >>> from sympy.categories import Object, NamedMorphism >>> A = Object("A") >>> B = Object("B") >>> C = Object("C") >>> f = NamedMorphism(A, B, "f") >>> g = NamedMorphism(B, C, "g") >>> (g * f).flatten("h") NamedMorphism(Object("A"), Object("C"), "h") )rFr%r&)r-new_names rflattenCompositeMorphism.flattens4T[[$--BBrrN)rrrrr staticmethodrWr'r<rTr%r&rjrrrrr4r4sc>''.!9F()),,,,Crr4cb\rSrSrSr\\4Sjr\S5r\S5r \S5r Sr Sr S r g ) Categoryia An (abstract) category. Explanation =========== A category [JoyOfCats] is a quadruple `\mbox{K} = (O, \hom, id, \circ)` consisting of * a (set-theoretical) class `O`, whose members are called `K`-objects, * for each pair `(A, B)` of `K`-objects, a set `\hom(A, B)` whose members are called `K`-morphisms from `A` to `B`, * for a each `K`-object `A`, a morphism `id:A\rightarrow A`, called the `K`-identity of `A`, * a composition law `\circ` associating with every `K`-morphisms `f:A\rightarrow B` and `g:B\rightarrow C` a `K`-morphism `g\circ f:A\rightarrow C`, called the composite of `f` and `g`. Composition is associative, `K`-identities are identities with respect to composition, and the sets `\hom(A, B)` are pairwise disjoint. This class knows nothing about its objects and morphisms. Concrete cases of (abstract) categories should be implemented as classes derived from this one. Certain instances of :class:`Diagram` can be asserted to be commutative in a :class:`Category` by supplying the argument ``commutative_diagrams`` in the constructor. Examples ======== >>> from sympy.categories import Object, NamedMorphism, Diagram, Category >>> from sympy import FiniteSet >>> A = Object("A") >>> B = Object("B") >>> C = Object("C") >>> f = NamedMorphism(A, B, "f") >>> g = NamedMorphism(B, C, "g") >>> d = Diagram([f, g]) >>> K = Category("K", commutative_diagrams=[d]) >>> K.commutative_diagrams == FiniteSet(d) True See Also ======== Diagram cU(d [S5e[U[5(d [U5n[U[5(d [U5n[R "XU[ U65nU$)Nz%A Category cannot have an empty name.)rIrJr rrr'r )r$rKobjectscommutative_diagrams new_categorys rr'Category.__new__s_DE E$$$t9D'5))GnG}}S%.0D%EG rc4URSR$)z Returns the name of this category. Examples ======== >>> from sympy.categories import Category >>> K = Category("K") >>> K.name 'K' rrOr,s rrK Category.namesyy|   rc URS$)a Returns the class of objects of this category. Examples ======== >>> from sympy.categories import Object, Category >>> from sympy import FiniteSet >>> A = Object("A") >>> B = Object("B") >>> K = Category("K", FiniteSet(A, B)) >>> K.objects Class({Object("A"), Object("B")}) r1r*r,s rrpCategory.objectss"yy|rc URS$)a Returns the :class:`~.FiniteSet` of diagrams which are known to be commutative in this category. Examples ======== >>> from sympy.categories import Object, NamedMorphism, Diagram, Category >>> from sympy import FiniteSet >>> A = Object("A") >>> B = Object("B") >>> C = Object("C") >>> f = NamedMorphism(A, B, "f") >>> g = NamedMorphism(B, C, "g") >>> d = Diagram([f, g]) >>> K = Category("K", commutative_diagrams=[d]) >>> K.commutative_diagrams == FiniteSet(d) True rNr*r,s rrqCategory.commutative_diagramss,yy|rc[S5e)Nz)hom-sets are not implemented in Category.r")r-ABs rhom Category.hom*s! 79 9rc[S5e)Nz@Obtaining the class of morphisms is not implemented in Category.r"r,s r all_morphismsCategory.all_morphisms.s! NP PrrN)rrrrrr r'r<rKrprqr}rrrrrrnrns[5l$,(  ! !$.9Prrnc\rSrSrSr\S5r\SSj5rSr\ S5r \ S5r \ S5r S r S rS rS rg )Diagrami3a Represents a diagram in a certain category. Explanation =========== Informally, a diagram is a collection of objects of a category and certain morphisms between them. A diagram is still a monoid with respect to morphism composition; i.e., identity morphisms, as well as all composites of morphisms included in the diagram belong to the diagram. For a more formal approach to this notion see [Pare1970]. The components of composite morphisms are also added to the diagram. No properties are assigned to such morphisms by default. A commutative diagram is often accompanied by a statement of the following kind: "if such morphisms with such properties exist, then such morphisms which such properties exist and the diagram is commutative". To represent this, an instance of :class:`Diagram` includes a collection of morphisms which are the premises and another collection of conclusions. ``premises`` and ``conclusions`` associate morphisms belonging to the corresponding categories with the :class:`~.FiniteSet`'s of their properties. The set of properties of a composite morphism is the intersection of the sets of properties of its components. The domain and codomain of a conclusion morphism should be among the domains and codomains of the morphisms listed as the premises of a diagram. No checks are carried out of whether the supplied object and morphisms do belong to one and the same category. Examples ======== >>> from sympy.categories import Object, NamedMorphism, Diagram >>> from sympy import pprint, default_sort_key >>> A = Object("A") >>> B = Object("B") >>> C = Object("C") >>> f = NamedMorphism(A, B, "f") >>> g = NamedMorphism(B, C, "g") >>> d = Diagram([f, g]) >>> premises_keys = sorted(d.premises.keys(), key=default_sort_key) >>> pprint(premises_keys, use_unicode=False) [g*f:A-->C, id:A-->A, id:B-->B, id:C-->C, f:A-->B, g:B-->C] >>> pprint(d.premises, use_unicode=False) {g*f:A-->C: EmptySet, id:A-->A: EmptySet, id:B-->B: EmptySet, id:C-->C: EmptySet, f:A-->B: EmptySet, g:B-->C: EmptySet} >>> d = Diagram([f, g], {g * f: "unique"}) >>> pprint(d.conclusions,use_unicode=False) {g*f:A-->C: {unique}} References ========== [Pare1970] B. Pareigis: Categories and functors. Academic Press, 1970. c*X;a XU-X'gX U'g)z If ``key`` is in ``dictionary``, set the new value of ``key`` to be the union between the old value and ``value``. Otherwise, set the value of ``key`` to ``value. Returns ``True`` if the key already was in the dictionary and ``False`` otherwise. TFr) dictionarykeyvalues r_set_dict_unionDiagram._set_dict_unionps%  (o5JO#sOrc[RXU5(Gdj[U[5(aU(a [ S5egU(a\[ n[UR 5n[UR5n[RXU5 [RXU5 [UR55HsupX-n UR UR:XaX-n [RX U 5 URUR :XdMYX-n [RX U 5 Mu [U[5(a9U(a1[ nURHn [RX UU5 M gggg)z Adds a morphism and its attributes to the supplied dictionary ``morphisms``. If ``add_identities`` is True, also adds the identity morphisms for the domain and the codomain of ``morphism``. z5Instances of IdentityMorphism cannot have properties.N) rrrJr>rIr r%r&listitemsr4rT_add_morphism_closure) morphismsrVpropsadd_identitiesrecurse_compositesemptyid_domid_codexisting_morphismexisting_props new_propsleftright components rrDiagram._add_morphism_closuresR&&yEBB($455 %OQQ )(//:)(*;*;<'' 5A'' 5A59)//:K5L1!*2 ??&7&@&@@#7D++IYG$$(9(@(@@-8E++IiH6M($566;M!!)!4!4I11)2@B"5 O[U[[45(asUR5H_upxU[ UR UR 5-n[RX'[U5(a[ U6O [ U55 Ma [U5S:Ga=USn [U [5(a[nU Hn[URUR 55[R LdM:[URUR 55[R LdMq[RX7USSS9 M O[U [[45(atU R5H`upxUR U;dMUR U;dM)[RX7[U5(a[ U6O [ U5SSS9 Mb ["R$"U[U5[U5U5$)a Construct a new instance of Diagram. Explanation =========== If no arguments are supplied, an empty diagram is created. If at least an argument is supplied, ``args[0]`` is interpreted as the premises of the diagram. If ``args[0]`` is a list, it is interpreted as a list of :class:`Morphism`'s, in which each :class:`Morphism` has an empty set of properties. If ``args[0]`` is a Python dictionary or a :class:`Dict`, it is interpreted as a dictionary associating to some :class:`Morphism`'s some properties. If at least two arguments are supplied ``args[1]`` is interpreted as the conclusions of the diagram. The type of ``args[1]`` is interpreted in exactly the same way as the type of ``args[0]``. If only one argument is supplied, the diagram has no conclusions. Examples ======== >>> from sympy.categories import Object, NamedMorphism >>> from sympy.categories import IdentityMorphism, Diagram >>> A = Object("A") >>> B = Object("B") >>> C = Object("C") >>> f = NamedMorphism(A, B, "f") >>> g = NamedMorphism(B, C, "g") >>> d = Diagram([f, g]) >>> IdentityMorphism(A) in d.premises.keys() True >>> g * f in d.premises.keys() True >>> d = Diagram([f, g], {g * f: "unique"}) >>> d.conclusions[g * f] {unique} r1rrNF)rr)r r]rJrr r%r&rrdictrrr rcontainsrtruerr') r$r+premises conclusionsrp premises_argrrVrconclusions_args rr'Diagram.__new__sV  t9>7L,--! ,Hy(:K:KLLG11(eL!-L4,77(4'9'9';OHy(:K:KLLG11 %Iu,=V_`eVfh(< t9>"1gO/400! /H !1!1(//!BCqvvM !1!1(2C2C!DEO 55'5/466 !0OdD\::(7'<'<'>OH 72 ))W4 55'QV9e3D]fgl]m+0U6L (?}}S$x.${2CWMMrc URS$)a Returns the premises of this diagram. Examples ======== >>> from sympy.categories import Object, NamedMorphism >>> from sympy.categories import IdentityMorphism, Diagram >>> from sympy import pretty >>> A = Object("A") >>> B = Object("B") >>> f = NamedMorphism(A, B, "f") >>> id_A = IdentityMorphism(A) >>> id_B = IdentityMorphism(B) >>> d = Diagram([f]) >>> print(pretty(d.premises, use_unicode=False)) {id:A-->A: EmptySet, id:B-->B: EmptySet, f:A-->B: EmptySet} rr*r,s rrDiagram.premisess*yy|rc URS$)a Returns the conclusions of this diagram. Examples ======== >>> from sympy.categories import Object, NamedMorphism >>> from sympy.categories import IdentityMorphism, Diagram >>> from sympy import FiniteSet >>> A = Object("A") >>> B = Object("B") >>> C = Object("C") >>> f = NamedMorphism(A, B, "f") >>> g = NamedMorphism(B, C, "g") >>> d = Diagram([f, g]) >>> IdentityMorphism(A) in d.premises.keys() True >>> g * f in d.premises.keys() True >>> d = Diagram([f, g], {g * f: "unique"}) >>> d.conclusions[g * f] == FiniteSet("unique") True r1r*r,s rrDiagram.conclusions0s4yy|rc URS$)ak Returns the :class:`~.FiniteSet` of objects that appear in this diagram. Examples ======== >>> from sympy.categories import Object, NamedMorphism, Diagram >>> A = Object("A") >>> B = Object("B") >>> C = Object("C") >>> f = NamedMorphism(A, B, "f") >>> g = NamedMorphism(B, C, "g") >>> d = Diagram([f, g]) >>> d.objects {Object("A"), Object("B"), Object("C")} rNr*r,s rrpDiagram.objectsLs(yy|rcl[n[nURR5H5nURU:XdMURU:XdM'U[ U5-nM7 UR R5H5nURU:XdMURU:XdM'U[ U5-nM7 X44$)a3 Returns a 2-tuple of sets of morphisms between objects ``A`` and ``B``: one set of morphisms listed as premises, and the other set of morphisms listed as conclusions. Examples ======== >>> from sympy.categories import Object, NamedMorphism, Diagram >>> from sympy import pretty >>> A = Object("A") >>> B = Object("B") >>> C = Object("C") >>> f = NamedMorphism(A, B, "f") >>> g = NamedMorphism(B, C, "g") >>> d = Diagram([f, g], {g * f: "unique"}) >>> print(pretty(d.hom(A, C), use_unicode=False)) ({g*f:A-->C}, {g*f:A-->C}) See Also ======== Object, Morphism )r rkeysr%r&r r)r-r{r|rrrVs rr} Diagram.hombs0  **,H1$8+<+<+AIh//-((--/H1$8+<+<+Ay22 0&&rc^^[UU4SjTR55nU(dg[UU4SjTR55nU$)aw Checks whether ``diagram`` is a subdiagram of ``self``. Diagram `D'` is a subdiagram of `D` if all premises (conclusions) of `D'` are contained in the premises (conclusions) of `D`. The morphisms contained both in `D'` and `D` should have the same properties for `D'` to be a subdiagram of `D`. Examples ======== >>> from sympy.categories import Object, NamedMorphism, Diagram >>> A = Object("A") >>> B = Object("B") >>> C = Object("C") >>> f = NamedMorphism(A, B, "f") >>> g = NamedMorphism(B, C, "g") >>> d = Diagram([f, g], {g * f: "unique"}) >>> d1 = Diagram([f]) >>> d.is_subdiagram(d1) True >>> d1.is_subdiagram(d) False c3># UH:nUTR;=(a TRUTRU:Hv M< g7frA)r.0mdiagramr-s r (Diagram.is_subdiagram..sI2 01T]]*A((+t}}Q/??A 0AAFc3># UH:nUTR;=(a TRUTRU:Hv M< g7frA)rrs rrrsM8#6a 0 00J"..q1T5E5Ea5HHJ#6r)allrr)r-rrrs`` r is_subdiagramDiagram.is_subdiagramsO22 ' 0 0228#*#6#688 rcURUR5(d [S5e0nURR 5Hwup4[ UR UR55[RLdM<[ UR UR55[RLdMsXBU'My 0nURR 5Hwup4[ UR UR55[RLdM<[ UR UR55[RLdMsXEU'My [X%5$)ar If ``objects`` is a subset of the objects of ``self``, returns a diagram which has as premises all those premises of ``self`` which have a domains and codomains in ``objects``, likewise for conclusions. Properties are preserved. Examples ======== >>> from sympy.categories import Object, NamedMorphism, Diagram >>> from sympy import FiniteSet >>> A = Object("A") >>> B = Object("B") >>> C = Object("C") >>> f = NamedMorphism(A, B, "f") >>> g = NamedMorphism(B, C, "g") >>> d = Diagram([f, g], {f: "unique", g*f: "veryunique"}) >>> d1 = d.subdiagram_from_objects(FiniteSet(A, B)) >>> d1 == Diagram([f], {f: "unique"}) True z2Supplied objects should all belong to the diagram.) is_subsetrprIrrrrr%rrr&rr)r-rp new_premisesrVrnew_conclusionss rsubdiagram_from_objectsDiagram.subdiagram_from_objectss,  ..DF F #}}224OH))(//:;qvvE))(*;*;<=G).X& 5 #//557OH))(//:;qvvE))(*;*;<=G,1) 8 |55rrN)TT)rrrrrrlrrr'r<rrrpr}rrrrrrrr3s;x IM15.B.B`eNN,6*"'H$L&6rrN) sympy.corerrrrrrsympy.core.symbolr sympy.setsr r r sympy.utilities.iterablesr rrrr>rFr4rnrrrrrs==!//.C& V h#uh#V"x"J5!H5!pxCxCvFPuFPR_6e_6r