Make Diagram only capable of storing one set of morphisms.

This commit removes the notions of premises and conclusions in view of
the future addition of Implication (see next commits).  This commit also
fixes the drawing code, the printing code, as well as the doctests.
Note that no essential changes to tests are introduced.
Increase the flexibility of how Diagram treats its arguments.

This commit makes it possible to create the diagram Diagram([f, g])
using the syntax Diagram(f, g) and uses this new (nicer) syntax wherever
possible in the docstrings.
Diagram._add_morphism_closure: Remove extra flags.

Previously, when Diagram would contain both premises and conclusions, it
would use slightly different logic for computing the closure of premises
and conclusions.  The behaviour was controlled by the two arguments:
recurse_composites and add_identities.  Now that Diagram only stores a
set of morphisms, it is not necessary to have this difference.
Diagram: Add a dict-like interface.

This commit makes Diagram implicitly behave like a dictionary mapping
morphisms to their properties.  It also adds the corresponding tests and
takes advantage of the easier syntax in the docstrings.
Diagram: Have _add_morphism_closure update the set of objects.

Previously, the set of objects was updated in the constructor of
Diagram, which resulted in a bug when adding composite morphisms: only
the domain and the codomain of a composite morphism were added to the
set of objects, while the domains and the codomains of the components
were not registered.
Add class Implication.

Implication is the class which should be used to represent category
theory implications written in diagrammatic form.  This commit also adds
the necessary docstrings, tests, and printing methods.
Start the commutativity module.

This commit adds the commutativity module, the function
subdiagram_embeddings, and some tests for this function, which currently
fail.  The tests for subdiagram_embeddings are not exhaustive at the
moment; I will add the necessary tests as I go.
Embeddings: Transition to simple graphs.

Diagrams are multigraphs.  To be able to list all embeddings, we will
need to first convert both the pattern and the model to a simple graph,
then apply Ullman's algorithm (see references in the code) to generate
all subgraph embeddings, and then, from these embeddings, generate the
multigraph embeddings.

To apply Ullman's algorithm, we will need to do matrix multiplication
with adjacency matrices, this is why we set up bidirectional mappings
between the objects of the diagrams and their indices.
Embeddings: Compute the input and output degrees.

Note that the degrees of the vertices are computed as they are in the
original multigraph of the diagram.  The comment in the code gives a
little bit more details.
Embeddings: Initialise M_0.

This is the first stage of the matrix M which will eventually represent
subgraph isomorphisms.  For more details, see the references in the
code.
Embeddings: Implement Ullman's algorithm.

This implementation follows [Ullm1976] as closely as it would make
sense.  Note, however, that since we are actually dealing with directed
multigraphs, there are deviations.  The code abounds in comments,
though.
Embeddings: Construct actual subdiagram embeddings.

This commit enables the function ``subdiagram_embeddings`` to actually
produce subdiagram embeddings basing on graph embeddings produced by the
previously implemented Ullman's algorithm.
Embeddings: Test embeddings with properties.

Previously, there were only a test for embeddings without properties.
This commit essentially repeats that test, and adds morphism properties.