Poset
==========

A partially ordered set (poset) is a set equipped with a partial order relation. This relation must satisfy three properties: reflexivity (every element is related to itself), antisymmetry (if two elements are mutually related, they must be equal), and transitivity (if element *a* is related to *b*, and *b* is related to *c*, then *a* is related to *c*).

Definition
---------

A **Poset** (Partially ordered set) is defined as a directed graph possessing the following property:

- If :math:`ab` and :math:`bc` are edges of this graph, then :math:`ac` must also be an edge of this graph.

Since many mathematical concepts can be represented as posets, their study proves particularly useful.

.. rst:
The First Problem
~~~~~~~~~~~~~~~~~~~~~

Suppose we have a set of natural numbers denoted as :math:`A`, and we want to find the largest subset :math:`B` such that for any two members of :math:`B`, one is divisible by the other.

We can model this problem with a graph as follows: For each member of :math:`A`, create a vertex in the graph. For any two vertices :math:`x` and :math:`y` where :math:`x|y` (x divides y), draw a directed edge from :math:`x` to :math:`y`. Now, the problem is equivalent to finding the longest path in this graph!

.. _chain-antichain:

Chain and Antichain
~~~~~~~~~~~~~~~~~~

A sequence of distinct vertices such as :math:`u_1,...,u_k`, where for every :math:`i<j`, there is an edge from :math:`u_i` to :math:`u_j`, is called a **chain**. Note that due to the poset property, it suffices for :math:`u_1, ..., u_k` to form a path.

A subset of vertices where no two vertices are connected by an edge is called an **antichain**.

Later, we will examine partitioning a graph into chains or antichains (vertex partitioning is intended here).

Note that these definitions are exclusively used in posets.

Maximum Chain = Minimum Partition into Antichains
---------------------------------------------

Assume the size of the maximum chain is :math:`L`. Consider a maximum chain such as :math:`A`.

Any antichain can include at most one vertex from :math:`A`. Thus, the minimum partition into antichains is at least :math:`L`. Now we prove that equality is achievable.

Assign to each vertex :math:`u` a number :math:`a_i`, which equals the size of the largest chain ending at :math:`u`. Observe that if :math:`a_i = a_j`, there cannot be an edge between :math:`i` and :math:`j`. For example, if there is an edge from :math:`i` to :math:`j`, then :math:`a_j \geq a_i+1`.

For each vertex :math:`u`, we call :math:`a_u` the **color** of :math:`u`. According to the above proof, vertices with the same color form an antichain. The number of colors equals :math:`L` (why?). Thus, we can partition the graph into :math:`L` antichains.

This theorem is known as **Mirsky’s theorem** and was proposed in 1971. Interestingly, this theorem had already been recognized in 1940 by Dilworth, Gallai, Fulkerson, and others. Their sole reason for not publishing it was considering it "too obvious"!

Maximum Antichain = Minimum Partition into Chains
----------------------------------------------

Similar to before, we can first conclude that the minimum partition into chains is at least the size of the maximum antichain (since each chain can contain at most one vertex from the maximum antichain). Now we aim to demonstrate an example where equality holds.

We discussed the problem of partitioning graph vertices into a minimum number of paths in section 4. It sufficed to represent the graph as a bipartite graph and find a maximum matching. Now we know that in posets, every chain corresponds to a path. Thus, the problem of minimum partition into chains is solved by finding the minimum vertex partition into paths.

.. code-block:: python

    # This is a sample code block, comments remain in Finglish
    def test_function():
        print("Hello World")  # Another Finglish comment


Augmenting-like Path
~~~~~~~~~~~~~~~~~~~~~~~~~

Now suppose our poset is a directed graph named :math:`P`. Let :math:`G` be its equivalent bipartite graph. Consider a minimal path decomposition in :math:`P`. Let :math:`M` be the set of directed edges present in our paths. We know that the edges of :math:`M` correspond to the edges of a maximum matching in :math:`G`. The necessary and sufficient condition for a matching to be maximum was the absence of an augmenting path. We examine what the equivalent of an augmenting path would be in our directed graph. A free vertex in the first partition of :math:`G` corresponds to a vertex in :math:`P` that is the end of a path. A free vertex in the second partition of :math:`G` corresponds to a vertex in :math:`P` that is the start of a path.

Thus, we want to understand the equivalent of an augmenting path in :math:`G` (which starts in the first partition and ends in the second partition) within the graph :math:`P`. We define an **augmenting-like path** in :math:`P` as follows:

A sequence of vertices :math:`u_1,u_2,...,u_{2k+1}` such that :math:`u_1` is the start and :math:`u_{2k+1}` is the end of a chosen path in the minimal decomposition. Additionally:
- For each :math:`u_{2i-1},u_{2i}` in :math:`P`, the edge :math:`u_{2i-1}u_{2i}` exists and does **not** belong to :math:`M`.
- For each :math:`u_{2i},u_{2i+1}`, the edge :math:`u_{2i+1}u_{2i}` belongs to :math:`M`! (Note the reversal of direction).

Therefore, we can assume that the vertices of :math:`P` have been partitioned into the minimal number of paths such that no augmenting-like path exists in :math:`P`.

.. image:: /images/path-decomposition.png
    :alt: Minimal path decomposition diagram

.. _algorithm:

Algorithm
~~~~~~~~~~~~~~~~~~~~~~

Our goal now is to select exactly one vertex from each chain such that the selected vertices form an antichain. In this case, we can achieve equality (i.e., meet the Dilworth number).

Consider the following algorithm:

- Take the first vertices of all paths. If there are no edges between them, simply select them. Otherwise, there exists an edge like :math:`uv` where :math:`u` and :math:`v` are the first vertices of two paths in our decomposition.
- Now, we must eliminate vertex :math:`u`. Since :math:`u` has an edge to :math:`v`, and :math:`v` is the first vertex of a path, by the poset property, we can conclude that :math:`u` has edges to all vertices in :math:`v`'s path. Therefore, if we include :math:`u` in the antichain, we cannot select any vertex from the path starting with :math:`v`, preventing us from achieving our goal of choosing one vertex from each path. Hence, eliminate :math:`u`.

Continue this process until there are no edges between the first vertices of the remaining paths (after eliminations), yielding an antichain of size equal to the number of paths. The only scenario that disrupts our process is when an entire path is eliminated (in this case, the antichain will not have the same size as the initial number of paths).

No Path is Completely Removed
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

We now prove that no path is entirely removed during the algorithm. The idea of the proof is to assume, for contradiction, that a path is completely removed, and then find a quasi-augmenting path in the original graph, which will contradict the minimality of our partition.

For each vertex :math:`a`, we call a vertex :math:`b` the **parent** of :math:`a` if in the algorithm, :math:`a` was removed due to the edge :math:`ab`. That is, at some stage of the algorithm, both :math:`a` and :math:`b` belonged to two paths, the edge :math:`ab` was part of :math:`P`, and according to the algorithm, we removed vertex :math:`a`.

For each vertex :math:`a`, consider the path containing :math:`a`, and call the vertex preceding :math:`a` in this path (such as :math:`b`) the **chief** of :math:`a`. (This means the edge :math:`ba` belongs to :math:`M`).

Note that for every vertex :math:`a`, the time of :math:`a`'s removal occurs after the removal time of the chief of its parent. This is because when :math:`a` is removed by its parent, the parent must first belong to a path. Hence, the chief of the parent (if it exists) is removed before this deletion.

Now suppose at some stage, a vertex :math:`a` is removed, which is the endpoint of a path in our partition. Start from vertex :math:`a` and place a marker on :math:`a`. At each step, if the marker is on :math:`u`, first move it to the parent of :math:`u`. If the parent of :math:`u` was originally part of one of the paths, we have found our quasi-augmenting path. Otherwise, move the marker to the chief of the parent of :math:`u`. Note two key points:

- The process terminates because, as stated earlier, after each step, the marker moves to a vertex with an earlier removal time in the algorithm.
- At every step, the vertex where the marker resides has a parent. This is because, in our algorithm, this vertex was removed (since its removal time is earlier than :math:`a`'s, and we assumed :math:`a` was removed).

Thus, we have found a quasi-augmenting path. As argued earlier, the resulting contradiction shows that no path is completely removed!