// Notes...
// Diamonds are used to describe mappings between elements.

digraph G {
    compound=true;
    subgraph cluster1 {
        label="Categories of Ideas";

        Domain;
        Domain -> AbstractGenus [lhead=cluster11]
        Domain -> ConcreteGenus [lhead=cluster12]

        subgraph cluster11 {
            node [style=filled,fillcolor=white,color=black];
            label="Abstract";
            style=filled;
            color=gray;
            AbstractEntity [label="Entity"];
            AbstractSpecies [label="Species"];
            AbstractGenus [label="Genus"];
            AbstractGenus -> AbstractSpecies -> AbstractEntity
        }
        subgraph cluster12 {
            node [style=filled,fillcolor=white,color=black];
            label="Concrete";
            style=filled;
            color=gray;
            ConcreteEntity [label="Entity"];
            ConcreteSpecies [label="Species"];
            ConcreteGenus [label="Genus"];
            ConcreteGenus -> ConcreteSpecies -> ConcreteEntity
        }

        ConcreteEntity -> Identity;

        Attribute [shape=diamond];
        Attribute -> ConcreteEntity [dir=none];
        Attribute -> AbstractEntity [dir=none];
        // Identity -> Attribute [constraint=false]

        Snapshot [shape=diamond];
        Snapshot -> ConcreteEntity [dir=none];
        Snapshot -> Attribute [dir=none];

        Function [shape=diamond, rank=min];
        Function -> AbstractEntity [dir=none];
        Function -> AbstractEntity [dir=none];

        { rank=same; Domain }
        { rank=same; cluster11; cluster12; }
        { rank=same; Identity; Attribute; Snapshot; Function; }
    }


    /*
    subgraph cluster21 {
        label = "Values"
        Datum;
        ValueType;
        Value;
        Representation;
        Interpretation;
        WellFormedValueType;
        ProperlyPartialValueType;
        TotalValueType;
        UniquelyRepresentedValueType
        AmbiguousValueType;
        UnambiguousValueType;
    }
    */

    /*Function;
    RegularFunction;
    Memory;
    Object;
    State;
    Resources;
    ObjectType;
    IdentityToken;
    Procedure;
    ComputationalBasis;
    RegularType;
    Equality;
    Assignment;
    Destructor;
    Constructor;
    DefaultConstructor;
    CopyConstructor;
    RegularProcedure;
    FunctionalProcedure;
    HomogenousFunction;
    DefinitionSpace;
    ResultSpace;
    Codomain;
    Concept;
    TypeAttribute;
    TypeFunction;
    IndexedTypeFunction;
    TypeConstructor;
    Model;
    Refines;
    Weakens;
    AbstractProcedure;
    Preconditions;
    */
}