范畴论#

介绍#

SymPy的范畴理论模块将允许在一个类别中操作图表，包括在TikZ中绘制它们并决定它们是否交换。

本模块尝试遵循的一般参考工作是

[JoyOfCats]

阿达梅克，H.赫利希。G、斯特雷克：抽象和具体的范畴。猫的快乐。

这本书的最新版本可从

katmat.math.uni-bremen.de/acc/acc.pdf

该模块仍处于胚胎前期。

基类引用#

本节列出了实现范畴理论中一些基本概念的类：对象、态射、范畴和图。

class sympy.categories.Object(name, **assumptions)[源代码]#

抽象类别中任何类型对象的基类。

解释

从技术上讲 Basic 可以，这个类是在抽象类别中创建抽象对象的推荐方法。

class sympy.categories.Morphism(domain, codomain)[源代码]#

抽象范畴中任何态射的基类。

解释

在抽象范畴中，态射是两个范畴对象之间的箭头。箭头开始的对象称为域，而箭头结束的对象称为codomain。

同一对对象之间的两个态射被认为是同一个态射。要区分相同对象之间的变形，请使用 NamedMorphism .

禁止实例化此类。请改用其中一个派生类。

参见

IdentityMorphism, NamedMorphism, CompositeMorphism

property codomain#

返回态射的密码域。

实例

>>> from sympy.categories import Object, NamedMorphism
>>> A = Object("A")
>>> B = Object("B")
>>> f = NamedMorphism(A, B, "f")
>>> f.codomain
Object("B")

compose(other)[源代码]#

用所提供的态射组成自我。

构图中元素的顺序是通常的顺序，即构图 \(g\circ f\) 使用 g.compose(f) .

实例

>>> 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")

property domain#

返回态射的域。

实例

>>> from sympy.categories import Object, NamedMorphism
>>> A = Object("A")
>>> B = Object("B")
>>> f = NamedMorphism(A, B, "f")
>>> f.domain
Object("A")

class sympy.categories.NamedMorphism(domain, codomain, name)[源代码]#

表示具有名称的变形。

解释

名称用于区分具有相同域和相同余域的态射：如果两个命名态射具有相同的域、余域和名称，则它们是相等的。

实例

>>> 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'

参见

Morphism

property name#

返回变形的名称。

实例

>>> from sympy.categories import Object, NamedMorphism
>>> A = Object("A")
>>> B = Object("B")
>>> f = NamedMorphism(A, B, "f")
>>> f.name
'f'

class sympy.categories.CompositeMorphism(*components)[源代码]#

表示由其他态射组成的态射。

解释

两个复合态射是相等的，如果它们从（组件）获得的态射相同，并且以相同的顺序列出。

此类的构造函数的参数应按图表顺序列出：以获取组合 \(g\circ f\) 从 Morphism g 和 f 使用 CompositeMorphism(f, g) .

实例

>>> 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

property codomain#

返回此复合态射的密码域。

复合态射的余域是其最后一个分量的余域。

实例

>>> 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")

property components#

返回此复合态射的组件。

实例

>>> 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"))

property domain#

返回此复合态射的域。

复合态射的域是其第一个分量的域。

实例

>>> 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")

flatten(new_name)[源代码]#

忘记了这个态射的复合结构。

解释

如果 new_name 不为空，返回 NamedMorphism 使用提供的名称，否则返回 Morphism . 在这两种情况下，新态射的域是这个复合态射的域，而新态射的余域就是这个复合态射的余域。

实例

>>> 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")

class sympy.categories.IdentityMorphism(domain)[源代码]#

表示同一态射。

解释

同一态射是具有相等域和余域的态射，它在合成方面充当同一性。

实例

>>> 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

参见

Morphism

class sympy.categories.Category(name, objects=EmptySet, commutative_diagrams=EmptySet)[源代码]#

一个（抽象的）范畴。

解释

A类 [JoyOfCats] 是四倍的 \(\mbox{{K}} = (O, \hom, id, \circ)\) 组成的

（集合理论）课 \(O\) ，其成员被称为 \(K\) -对象，
对于每对 \((A, B)\) 属于 \(K\) -对象，集合 \(\hom(A, B)\) 其成员被称为 \(K\) -态射 \(A\) 到 \(B\) ，
每人一个 \(K\) -对象 \(A\) ，一个态射 \(id:A\rightarrow A\) ，称为 \(K\) -同一性 \(A\) ，
合成法 \(\circ\) 与每一个 \(K\) -态射 \(f:A\rightarrow B\) 和 \(g:B\rightarrow C\) 一 \(K\) -态射 \(g\circ f:A\rightarrow C\) ，称为 \(f\) 和 \(g\) .

构图是结合的， \(K\) -恒等式是关于组合和集合的恒等式 \(\hom(A, B)\) 成对不相交。

这个类对它的对象和变形一无所知。（抽象）类别的具体情况应该实现为派生自这个类别的类。

某些实例 Diagram 在 Category 通过提供论据 commutative_diagrams 在构造函数中。

实例

>>> 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

参见

Diagram

property commutative_diagrams#

返回 FiniteSet 在这个范畴中已知的可交换的图。

实例

>>> 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

property name#

返回此类别的名称。

实例

>>> from sympy.categories import Category
>>> K = Category("K")
>>> K.name
'K'

property objects#

返回此类别的对象的类。

实例

>>> 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")})

class sympy.categories.Diagram(*args)[源代码]#

表示某个类别中的图表。

解释

非正式地说，图是一个类别的对象和它们之间的某种态射的集合。就态射合成而言，图仍然是幺半群；也就是说，同一态射以及图中包含的所有态射的合成都属于图。关于这个概念的更正式的方法，请参见 [1970年] .

复合态射的组成部分也被添加到图中。默认情况下，不会为此类变形指定属性。

交换图通常伴随着这样一种陈述：“如果具有这种性质的态射存在，那么具有这种性质的这种态射存在并且图是可交换的”。为了表示这个，一个 Diagram 包括作为前提的态射集合和另一个结论集合。 premises 和 conclusions 将属于相应范畴的态射与 FiniteSet 他们的财产。

复合态射的属性集是其组件的属性集的交集。结论态射的域和余域应该在作为图的前提的态射的域和余域之间。

不检查所提供的对象和变形是否属于同一类别。

实例

>>> 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: EmptyS >

> et, 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}}

工具书类

[1970年] B、 Pareigis：范畴和函子。学术出版社，1970年。

property conclusions#

返回此关系图的结论。

实例

>>> 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

hom(A, B)[源代码]#

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.

实例

>>> 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})

参见

Object, Morphism

is_subdiagram(diagram)[源代码]#

检查是否 diagram 是的子图 self . 图表 \(D'\) 是的子图 \(D\) 如果所有前提（结论） \(D'\) 包含在 \(D\) . 包含在 \(D'\) 和 \(D\) 应该具有相同的属性 \(D'\) 作为 \(D\) .

实例

>>> 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

property objects#

返回 FiniteSet 此关系图中显示的对象。

实例

>>> 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")}

property premises#

返回此关系图的前提。

实例

>>> 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}

subdiagram_from_objects(objects)[源代码]#

如果 objects 对象的一个子集 self ，返回一个关系图，其中包含 self 其中有一个域和密码子 objects ，结论也是如此。属性将被保留。

实例

>>> 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

图表绘制#

本节列出了允许自动绘制图表的类。

class sympy.categories.diagram_drawing.DiagramGrid(diagram, groups=None, **hints)[源代码]#

构造并保持图表与网格的拟合。

解释

这个类的任务是分析所提供的图的结构，并将它的对象放在一个网格上，这样，当对象和态射被实际绘制时，这个图将是“可读的”，在这个意义上，不会有很多moprhism的交叉点。此类不执行任何实际绘图。尽管如此，它还是努力提供足够的元数据来绘制图表。

考虑下面的简单图表。

>>> from sympy.categories import Object, NamedMorphism
>>> from sympy.categories import Diagram, DiagramGrid
>>> from sympy import pprint
>>> A = Object("A")
>>> B = Object("B")
>>> C = Object("C")
>>> f = NamedMorphism(A, B, "f")
>>> g = NamedMorphism(B, C, "g")
>>> diagram = Diagram([f, g])

绘制图表的最简单方法如下：

>>> grid = DiagramGrid(diagram)
>>> (grid.width, grid.height)
(2, 2)
>>> pprint(grid)
A  B

   C

有时，人们会把图看作是由逻辑组组成的。你可以给我建议 DiagramGrid 通过雇佣 groups 关键字参数。

考虑下图：

>>> D = Object("D")
>>> f = NamedMorphism(A, B, "f")
>>> g = NamedMorphism(B, C, "g")
>>> h = NamedMorphism(D, A, "h")
>>> k = NamedMorphism(D, B, "k")
>>> diagram = Diagram([f, g, h, k])

用通用布局布局布局：

>>> grid = DiagramGrid(diagram)
>>> pprint(grid)
A  B  D

   C

现在，我们可以对对象进行分组 \(A\) 和 \(D\) 让它们彼此靠近：

>>> grid = DiagramGrid(diagram, groups=[[A, D], B, C])
>>> pprint(grid)
B     C

A  D

注意其他对象的位置是如何变化的。

进一步的指示可以提供给 DiagramGrid 使用关键字参数。下面几段将解释当前支持的提示。

DiagramGrid 不会自动猜测哪个布局更适合所提供的图表。例如，考虑以下线性图：

>>> E = Object("E")
>>> f = NamedMorphism(A, B, "f")
>>> g = NamedMorphism(B, C, "g")
>>> h = NamedMorphism(C, D, "h")
>>> i = NamedMorphism(D, E, "i")
>>> diagram = Diagram([f, g, h, i])

使用常规布局布局时，它不会看起来是线性的：

>>> grid = DiagramGrid(diagram)
>>> pprint(grid)
A  B

   C  D

      E

为了把它排成一行，使用 layout="sequential" ：

>>> grid = DiagramGrid(diagram, layout="sequential")
>>> pprint(grid)
A  B  C  D  E

有时可能需要转换生成的布局。虽然这总是可以手工完成的， DiagramGrid 为此提供了一个提示：

>>> grid = DiagramGrid(diagram, layout="sequential", transpose=True)
>>> pprint(grid)
A

B

C

D

E

也可以为每个组提供单独的提示。有关示例，请参阅 tests/test_drawing.py ，看看五个引理的不同方式 [FiveLemma] 可以布置。

参见

Diagram

工具书类

[FiveLemma]

https://en.wikipedia.org/wiki/Five_lemma

property height#

返回此关系图布局中的行数。

实例

>>> from sympy.categories import Object, NamedMorphism
>>> from sympy.categories import Diagram, DiagramGrid
>>> A = Object("A")
>>> B = Object("B")
>>> C = Object("C")
>>> f = NamedMorphism(A, B, "f")
>>> g = NamedMorphism(B, C, "g")
>>> diagram = Diagram([f, g])
>>> grid = DiagramGrid(diagram)
>>> grid.height
2

property morphisms#

返回那些足够有意义的态射（及其属性）。

实例

>>> from sympy.categories import Object, NamedMorphism
>>> from sympy.categories import Diagram, DiagramGrid
>>> A = Object("A")
>>> B = Object("B")
>>> C = Object("C")
>>> f = NamedMorphism(A, B, "f")
>>> g = NamedMorphism(B, C, "g")
>>> diagram = Diagram([f, g])
>>> grid = DiagramGrid(diagram)
>>> grid.morphisms
{NamedMorphism(Object("A"), Object("B"), "f"): EmptySet,
NamedMorphism(Object("B"), Object("C"), "g"): EmptySet}

property width#

返回此关系图布局中的列数。

实例

>>> from sympy.categories import Object, NamedMorphism
>>> from sympy.categories import Diagram, DiagramGrid
>>> A = Object("A")
>>> B = Object("B")
>>> C = Object("C")
>>> f = NamedMorphism(A, B, "f")
>>> g = NamedMorphism(B, C, "g")
>>> diagram = Diagram([f, g])
>>> grid = DiagramGrid(diagram)
>>> grid.width
2

class sympy.categories.diagram_drawing.ArrowStringDescription(unit, curving, curving_amount, looping_start, looping_end, horizontal_direction, vertical_direction, label_position, label)[源代码]#

存储生成箭头Xy pic描述所需的信息。

这个类的主要目标是抽象出箭头的字符串表示，并提供生成实际Xy pic字符串的功能。

unit 设置将用于指定弯曲量和其他距离的单位。 horizontal_direction 应该是一串 "r" 或 "l" 指定箭头的目标单元格相对于当前单元格的水平偏移。 vertical_direction 应使用一系列 "d" 或 "u" . label_position 应该是 "^" ， "_" 或 "|" 指定标签应位于箭头上方、箭头下方或刚好位于箭头上方。注意，“上面”和“下面”的概念是相对于箭头方向的。 label 存储变形标签。

其工作原理如下（忽略尚未解释的论据）：

>>> from sympy.categories.diagram_drawing import ArrowStringDescription
>>> astr = ArrowStringDescription(
... unit="mm", curving=None, curving_amount=None,
... looping_start=None, looping_end=None, horizontal_direction="d",
... vertical_direction="r", label_position="_", label="f")
>>> print(str(astr))
\ar[dr]_{f}

curving 应该是 "^" ， "_" 指定箭头将沿哪个方向弯曲。 curving_amount 是一个数字描述了多少 unit 的变形将弯曲：

>>> astr = ArrowStringDescription(
... unit="mm", curving="^", curving_amount=12,
... looping_start=None, looping_end=None, horizontal_direction="d",
... vertical_direction="r", label_position="_", label="f")
>>> print(str(astr))
\ar@/^12mm/[dr]_{f}

looping_start 和 looping_end 目前只用于循环态射，那些具有相同的域和密码域。这两个属性应存储一个有效的Xy pic方向，并相应地指定箭头指向的方向和箭头返回的方向：

>>> astr = ArrowStringDescription(
... unit="mm", curving=None, curving_amount=None,
... looping_start="u", looping_end="l", horizontal_direction="",
... vertical_direction="", label_position="_", label="f")
>>> print(str(astr))
\ar@(u,l)[]_{f}

label_displacement 控制箭头标签距箭头末端的距离。例如，要将箭头标签放在箭头附近，请使用“>”：

>>> astr = ArrowStringDescription(
... unit="mm", curving="^", curving_amount=12,
... looping_start=None, looping_end=None, horizontal_direction="d",
... vertical_direction="r", label_position="_", label="f")
>>> astr.label_displacement = ">"
>>> print(str(astr))
\ar@/^12mm/[dr]_>{f}

最后， arrow_style 用于指定箭头样式。例如，要获取虚线箭头，请使用“{-->}”作为箭头样式：

>>> astr = ArrowStringDescription(
... unit="mm", curving="^", curving_amount=12,
... looping_start=None, looping_end=None, horizontal_direction="d",
... vertical_direction="r", label_position="_", label="f")
>>> astr.arrow_style = "{-->}"
>>> print(str(astr))
\ar@/^12mm/@{-->}[dr]_{f}

笔记

实例 ArrowStringDescription 将由 XypicDiagramDrawer 并提供给格式化程序进一步使用。用户不应构造 ArrowStringDescription 他们自己。

为了能够正确地使用这个类，我们鼓励读者阅读Xy pic用户指南，网址为 [Xypic公司] .

参见

XypicDiagramDrawer

工具书类

[Xypic]

https://xy-pic.sourceforge.net/

class sympy.categories.diagram_drawing.XypicDiagramDrawer[源代码]#

给出了一个 Diagram 以及相应的 DiagramGrid ，生成图表的Xy pic表示。

这个类中最重要的方法是 draw . 考虑以下三角形图：

>>> from sympy.categories import Object, NamedMorphism, Diagram
>>> from sympy.categories import DiagramGrid, XypicDiagramDrawer
>>> A = Object("A")
>>> B = Object("B")
>>> C = Object("C")
>>> f = NamedMorphism(A, B, "f")
>>> g = NamedMorphism(B, C, "g")
>>> diagram = Diagram([f, g], {g * f: "unique"})

要绘制这个图表，它的对象需要用 DiagramGrid ：：

>>> grid = DiagramGrid(diagram)

最后，图纸：

>>> drawer = XypicDiagramDrawer()
>>> print(drawer.draw(diagram, grid))
\xymatrix{
A \ar[d]_{g\circ f} \ar[r]^{f} & B \ar[ld]^{g} \\
C &
}

有关详细信息，请参阅此方法的docstring。

箭头是用来控制外观的。字典 arrow_formatters 将变形映射到格式化程序函数。格式化程序接受 ArrowStringDescription 并允许修改由此公开的任何箭头属性。例如，要使所有变形都具有属性 unique 显示为虚线箭头，并在其名称前面加上 \(\exists !\) ，应执行以下操作：

>>> def formatter(astr):
...   astr.label = r"\exists !" + astr.label
...   astr.arrow_style = "{-->}"
>>> drawer.arrow_formatters["unique"] = formatter
>>> print(drawer.draw(diagram, grid))
\xymatrix{
A \ar@{-->}[d]_{\exists !g\circ f} \ar[r]^{f} & B \ar[ld]^{g} \\
C &
}

要修改图表中所有箭头的外观，请设置 default_arrow_formatter . 例如，要将所有变形标签放置在距离箭头稍远一点的位置，以便它们看起来更居中，请执行以下操作：

>>> def default_formatter(astr):
...   astr.label_displacement = "(0.45)"
>>> drawer.default_arrow_formatter = default_formatter
>>> print(drawer.draw(diagram, grid))
\xymatrix{
A \ar@{-->}[d]_(0.45){\exists !g\circ f} \ar[r]^(0.45){f} & B \ar[ld]^(0.45){g} \\
C &
}

在一些图中，一些态射被画成曲线箭头。考虑下图：

>>> D = Object("D")
>>> E = Object("E")
>>> h = NamedMorphism(D, A, "h")
>>> k = NamedMorphism(D, B, "k")
>>> diagram = Diagram([f, g, h, k])
>>> grid = DiagramGrid(diagram)
>>> drawer = XypicDiagramDrawer()
>>> print(drawer.draw(diagram, grid))
\xymatrix{
A \ar[r]_{f} & B \ar[d]^{g} & D \ar[l]^{k} \ar@/_3mm/[ll]_{h} \\
& C &
}

要控制默认情况下变形的弯曲程度，可以使用 unit 和 default_curving_amount 属性：

>>> drawer.unit = "cm"
>>> drawer.default_curving_amount = 1
>>> print(drawer.draw(diagram, grid))
\xymatrix{
A \ar[r]_{f} & B \ar[d]^{g} & D \ar[l]^{k} \ar@/_1cm/[ll]_{h} \\
& C &
}

在某些图中，同一两个对象之间存在多个曲线态射。若要控制两个连续的变形之间的曲线变化量，请使用 default_curving_step ：

>>> drawer.default_curving_step = 1
>>> h1 = NamedMorphism(A, D, "h1")
>>> diagram = Diagram([f, g, h, k, h1])
>>> grid = DiagramGrid(diagram)
>>> print(drawer.draw(diagram, grid))
\xymatrix{
A \ar[r]_{f} \ar@/^1cm/[rr]^{h_{1}} & B \ar[d]^{g} & D \ar[l]^{k} \ar@/_2cm/[ll]_{h} \\
& C &
}

默认值为 default_curving_step 是4个单位。

参见

draw, ArrowStringDescription

draw(diagram, grid, masked=None, diagram_format='')[源代码]#

返回的Xy pic表示形式 diagram 布置在 grid .

考虑下面的简单三角形图。

>>> from sympy.categories import Object, NamedMorphism, Diagram
>>> from sympy.categories import DiagramGrid, XypicDiagramDrawer
>>> A = Object("A")
>>> B = Object("B")
>>> C = Object("C")
>>> f = NamedMorphism(A, B, "f")
>>> g = NamedMorphism(B, C, "g")
>>> diagram = Diagram([f, g], {g * f: "unique"})

要绘制这个图表，它的对象需要用 DiagramGrid ：：

>>> grid = DiagramGrid(diagram)

最后，图纸：

>>> drawer = XypicDiagramDrawer()
>>> print(drawer.draw(diagram, grid))
\xymatrix{
A \ar[d]_{g\circ f} \ar[r]^{f} & B \ar[ld]^{g} \\
C &
}

争论 masked 可用于跳过图表表示中的变形：

>>> print(drawer.draw(diagram, grid, masked=[g * f]))
\xymatrix{
A \ar[r]^{f} & B \ar[ld]^{g} \\
C &
}

最后， diagram_format 参数可用于指定图表的格式字符串。例如，要将间距增加1 cm，请执行以下操作：

>>> print(drawer.draw(diagram, grid, diagram_format="@+1cm"))
\xymatrix@+1cm{
A \ar[d]_{g\circ f} \ar[r]^{f} & B \ar[ld]^{g} \\
C &
}

sympy.categories.diagram_drawing.xypic_draw_diagram(diagram, masked=None, diagram_format='', groups=None, **hints)[源代码]#

提供快捷组合 DiagramGrid 和 XypicDiagramDrawer . 返回的Xy pic表示形式 diagram . 争论 masked 是将不绘制的变形列表。争论 diagram_format 是在“xymatrix”后面插入的格式字符串。 groups 应该是一组逻辑组。这个 hints 将直接传递给 DiagramGrid .

有关参数的详细信息，请参见 DiagramGrid 和 XypicDiagramDrawer.draw .

实例

>>> from sympy.categories import Object, NamedMorphism, Diagram
>>> from sympy.categories import xypic_draw_diagram
>>> A = Object("A")
>>> B = Object("B")
>>> C = Object("C")
>>> f = NamedMorphism(A, B, "f")
>>> g = NamedMorphism(B, C, "g")
>>> diagram = Diagram([f, g], {g * f: "unique"})
>>> print(xypic_draw_diagram(diagram))
\xymatrix{
A \ar[d]_{g\circ f} \ar[r]^{f} & B \ar[ld]^{g} \\
C &
}

参见

XypicDiagramDrawer, DiagramGrid

sympy.categories.diagram_drawing.preview_diagram(diagram, masked=None, diagram_format='', groups=None, output='png', viewer=None, euler=True, **hints)[源代码]#

结合了 xypic_draw_diagram 和 sympy.printing.preview . 论点 masked ， diagram_format ， groups 和 hints 被传递给 xypic_draw_diagram ，同时 output ， viewer, and `` euler``传递给 ``preview .

实例

>>> from sympy.categories import Object, NamedMorphism, Diagram
>>> from sympy.categories import preview_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"})
>>> preview_diagram(d)

参见

XypicDiagramDrawer