This is CpMackeyFunctors.info, produced by Macaulay2, version 1.25.11

CpMackeyFunctors -- for Cp-Mackey functor computations
******************************************************

Description
===========

This Macaulay2 package implements basic homological algebra for Mackey functors
of a cyclic group $C_p$ of prime order. Some highlights of our functionality
include:

  * free resolutions, of
    $C_p$-Mackey functors
  * Ext, and Tor, computations for (cohomological) Mackey
    functors
  * the box product, and internal hom,
  * constructions, of various
    common examples of Mackey functors
  * the ability to generate random Mackey functors,
    over $C_p$
  * explicit examples,
    from the equivariant algebra literature

See also
========

  * background on Mackey functors -- a
    brief mathematical intro to the theory of Mackey functors
  * the abelian category of Mackey functors
    -- background on the category of Mackey functors and how
    to code within it
  * constructing examples of Mackey functors
    -- info about how to construct explicit Mackey functors
  * list of common Mackey functors -- a
    list of common Cp-Mackey functors
  * explicit applications of the CpMackeyFunctors package
    -- info about how this
    package can be applied to real-life examples

Authors
=======

  * Thomas Brazelton (see https://tbrazel.github.io/ )
    <brazelton@math.harvard.edu>
  * David Chan (see https://sites.google.com/view/davidchanmath )
    <chandav2@msu.edu>
  * Benjamin Mudrak (see https://benjaminmudrak.github.io )
    <bmudrak@purdue.edu>
  * Ben Spitz (see https://benspitz.com/ ) <benspitz@virginia.edu>
  * Chase Vogeli (see https://chasevoge.li ) <cpv29@cornell.edu>
  * Chenglu Wang (see https://chengluw.github.io ) <cwang@math.harvard.edu>
  * Michael R. Zeng (see https://sites.google.com/uw.edu/zengrf/ )
    <zengrf@uw.edu>
  * Sasha Zotine (see https://sites.google.com/view/szotine/home )
    <sashahbc@gmail.com>

Version
=======

This documentation describes version 1.0 of CpMackeyFunctors, released July 4,
2025.

Citation
========

If you have used this package in your research, please cite it as follows:

+-----------------------------------------------------------------------------+
|@misc{CpMackeyFunctorsSource,                                                |
|  title = {{CpMackeyFunctors: A \emph{Macaulay2} package. Version~1.0}},     |
|  author = {Thomas Brazelton and David Chan and Benjamin Mudrak and Ben Spitz|
|  howpublished = {A \emph{Macaulay2} package available at                    |
|    \url{https://github.com/Macaulay2/M2/tree/stable/M2/Macaulay2/packages}} |
|}                                                                            |
|-----------------------------------------------------------------------------|
|and Chase Vogeli and Chenglu Wang and Michael R. Zeng and Sasha Zotine},     |
+-----------------------------------------------------------------------------+

Exports
=======

  * Types
      * CpMackeyFunctor -- The type of Cp Mackey
        functors
      * MackeyFunctorHomomorphism -- the
        class of Mackey functor homomorphisms
  * Functions and commands
      * boxProduct -- box product of Cp-Mackey functors
      * complexLinearizationMap -- returns the
        complex linearization map for the prime p
      * drawVerticalCpMackeyFunctor, --
        reorients the net of a Mackey functor vertically
      * ExtCoh -- computes Ext of two cohomological Cp-Mackey
        fuctors
      * internalHom -- returns the internal hom Mackey
        functor between two Mackey functors.
      * isCohomological -- checks if a CpMackeyFunctor
        is cohomological
      * isTrivialMackeyFunctor -- checks if a
        Mackey functor is trivial or not
      * makeBurnsideMackeyFunctor, --
        constructs the Burnside Mackey functor
      * makeComplexRepresentationMackeyFunctor
        -- constructs the complex
        representation Mackey functor
      * makeCpMackeyFunctor -- make a Cp Mackey
        functor
      * makeFixedPointMackeyFunctor, --
        constructs the fixed-point Mackey functor of a C_p-module
      * makeFixedSignMackeyFunctor, --
        constructs the fixed-point Mackey functor for the sign action of $C_2$
        on $\mathbb{Z}$
      * makeFixedTrivMackeyFunctor, --
        constructs the fixed-point Mackey functor for the trivial action of
        $C_p$ on $\mathbb{Z}/p$
      * makeKGroupMackeyFunctor -- constructs
        the $K$-group Mackey functor
      * makeOrbitMackeyFunctor -- constructs the
        orbit Mackey functor of a C_p-module
      * makeRandomCpMackeyFunctor -- generate
        a random Cp-Mackey functor
      * makeRandomMackeyFunctorHomomorphism
        -- generate a random Cp-Mackey
        functor homomorphism
      * makeRealRepresentationMackeyFunctor
        -- constructs the real
        representation Mackey functor
      * makeUnderlyingFreeMackeyFunctor,
        -- constructs the free Mackey functor on an underlying generator
      * makeZeroMackeyFunctor -- constructs the
        zero Mackey functor for the group
      * makeZeroOnUnderlyingMackeyFunctor
        -- constructs a Mackey functor which
        is zero on underlying
      * realLinearizationMap -- returns the real
        linearization map for the prime p
      * resolutionCohomological -- constructs a
        free resolution in cohomological Mackey functors of specified length
      * TorCoh -- computes Tor of two cohomological Cp-Mackey
        fuctors
  * Methods
      * "boxProduct(CpMackeyFunctor,CpMackeyFunctor)" -- see boxProduct,
        -- box product of Cp-Mackey functors
      * "CpMackeyFunctor ** CpMackeyFunctor" -- see boxProduct,
        -- box product of Cp-Mackey functors
      * "CpMackeyFunctor ⊠ CpMackeyFunctor" -- see boxProduct,
        -- box product of Cp-Mackey functors
      * "boxProduct(CpMackeyFunctor,MackeyFunctorHomomorphism)" -- see
        boxProduct(MackeyFunctorHomomorphism,CpMackeyFunctor),
        -- induced
        maps on box products
      * boxProduct(MackeyFunctorHomomorphism,CpMackeyFunctor)
        -- induced
        maps on box products
      * "CpMackeyFunctor ** MackeyFunctorHomomorphism" -- see
        boxProduct(MackeyFunctorHomomorphism,CpMackeyFunctor),
        -- induced
        maps on box products
      * "CpMackeyFunctor ⊠ MackeyFunctorHomomorphism" -- see
        boxProduct(MackeyFunctorHomomorphism,CpMackeyFunctor),
        -- induced
        maps on box products
      * "MackeyFunctorHomomorphism ** CpMackeyFunctor" -- see
        boxProduct(MackeyFunctorHomomorphism,CpMackeyFunctor),
        -- induced
        maps on box products
      * "MackeyFunctorHomomorphism ⊠ CpMackeyFunctor" -- see
        boxProduct(MackeyFunctorHomomorphism,CpMackeyFunctor),
        -- induced
        maps on box products
      * cokernel(MackeyFunctorHomomorphism)
        -- cokernel of a Mackey
        functor homomorphism
      * "complexLinearizationMap(ZZ)" -- see complexLinearizationMap,
        -- returns the complex linearization map for
        the prime p
      * "CpMackeyFunctor == CpMackeyFunctor" -- see CpMackeyFunctor,
        -- The type of Cp Mackey functors
      * "directSum(CpMackeyFunctor)" -- see CpMackeyFunctor,
        -- The type of Cp Mackey functors
      * "net(CpMackeyFunctor)" -- see CpMackeyFunctor,
        -- The type of Cp Mackey functors
      * CpMackeyFunctor ++ CpMackeyFunctor
        -- direct sum of Cp-Mackey functors
      * degree(MackeyFunctorHomomorphism) (missing documentation)
      * "drawVerticalCpMackeyFunctor(CpMackeyFunctor)" -- see
        drawVerticalCpMackeyFunctor, -- reorients
        the net of a Mackey functor vertically
      * "Ext^ZZ(CpMackeyFunctor,CpMackeyFunctor)" -- see Ext, --
        computes Ext of two Cp-Mackey fuctors
      * "ExtCoh(ZZ,CpMackeyFunctor,CpMackeyFunctor)" -- see ExtCoh,
        -- computes Ext of two cohomological Cp-Mackey fuctors
      * freeResolution(CpMackeyFunctor,ZZ)
        -- constructs a free Mackey
        functor resolution of specified length
      * Hom(CpMackeyFunctor,CpMackeyFunctor)
        -- computes the Hom group
        between two Cp Mackey functors
      * Hom(CpMackeyFunctor,MackeyFunctorHomomorphism)
        -- computes the
        induced map on Hom groups
      * "Hom(MackeyFunctorHomomorphism,CpMackeyFunctor)" -- see
        Hom(CpMackeyFunctor,MackeyFunctorHomomorphism),
        -- computes the
        induced map on Hom groups
      * inducedMap(CpMackeyFunctor,CpMackeyFunctor)
        -- tries to induce a
        natural map between two Mackey functors
      * "inducedMap(CpMackeyFunctor,CpMackeyFunctor,MackeyFunctorHomomorphism)"
        -- see inducedMap(CpMackeyFunctor,CpMackeyFunctor),
        -- tries to induce a
        natural map between two Mackey functors
      * "inducedMap(CpMackeyFunctor,CpMackeyFunctor,Matrix,Matrix)" -- see
        inducedMap(CpMackeyFunctor,CpMackeyFunctor),
        -- tries to induce a
        natural map between two Mackey functors
      * "internalHom(CpMackeyFunctor,CpMackeyFunctor)" -- see
        internalHom, -- returns the internal hom Mackey functor
        between two Mackey functors.
      * internalHom(CpMackeyFunctor,MackeyFunctorHomomorphism),
        --
        returns the induced map on an internal hom.
      * "internalHom(MackeyFunctorHomomorphism,CpMackeyFunctor)" -- see
        internalHom(CpMackeyFunctor,MackeyFunctorHomomorphism),
        --
        returns the induced map on an internal hom.
      * "isCohomological(CpMackeyFunctor)" -- see isCohomological,
        -- checks if a CpMackeyFunctor is cohomological
      * isIsomorphism(MackeyFunctorHomomorphism)
        -- checks if a Mackey
        functor homomorphism is an isomorphism
      * "isTrivialMackeyFunctor(CpMackeyFunctor)" -- see
        isTrivialMackeyFunctor, -- checks if a Mackey
        functor is trivial or not
      * kernel(MackeyFunctorHomomorphism)
        -- kernel of a Mackey functor
        homomorphism
      * "- MackeyFunctorHomomorphism" -- see MackeyFunctorHomomorphism,
        -- the class of Mackey functor homomorphisms
      * "directSum(MackeyFunctorHomomorphism)" -- see
        MackeyFunctorHomomorphism, -- the class of
        Mackey functor homomorphisms
      * "inverse(MackeyFunctorHomomorphism)" -- see
        MackeyFunctorHomomorphism, -- the class of
        Mackey functor homomorphisms
      * "MackeyFunctorHomomorphism + MackeyFunctorHomomorphism" -- see
        MackeyFunctorHomomorphism, -- the class of
        Mackey functor homomorphisms
      * "MackeyFunctorHomomorphism ++ MackeyFunctorHomomorphism" -- see
        MackeyFunctorHomomorphism, -- the class of
        Mackey functor homomorphisms
      * "MackeyFunctorHomomorphism - MackeyFunctorHomomorphism" -- see
        MackeyFunctorHomomorphism, -- the class of
        Mackey functor homomorphisms
      * "MackeyFunctorHomomorphism == MackeyFunctorHomomorphism" -- see
        MackeyFunctorHomomorphism, -- the class of
        Mackey functor homomorphisms
      * "MackeyFunctorHomomorphism ^ ZZ" -- see
        MackeyFunctorHomomorphism, -- the class of
        Mackey functor homomorphisms
      * "net(MackeyFunctorHomomorphism)" -- see
        MackeyFunctorHomomorphism, -- the class of
        Mackey functor homomorphisms
      * "prune(MackeyFunctorHomomorphism)" -- see
        MackeyFunctorHomomorphism, -- the class of
        Mackey functor homomorphisms
      * "ZZ * MackeyFunctorHomomorphism" -- see
        MackeyFunctorHomomorphism, -- the class of
        Mackey functor homomorphisms
      * MackeyFunctorHomomorphism * MackeyFunctorHomomorphism
        -- composition
        of Mackey functor homomorphisms
      * MackeyFunctorHomomorphism | MackeyFunctorHomomorphism
        -- Horizontal
        concatenation of Mackey functor homomorphisms
      * MackeyFunctorHomomorphism || MackeyFunctorHomomorphism
        -- Vertical
        concatenation of Mackey functor homomorphisms
      * "makeBurnsideMackeyFunctor(ZZ)" -- see makeBurnsideMackeyFunctor,
        -- constructs the Burnside Mackey functor
      * "makeComplexRepresentationMackeyFunctor(ZZ)" -- see
        makeComplexRepresentationMackeyFunctor,
        -- constructs the complex
        representation Mackey functor
      * "makeCpMackeyFunctor(ZZ,Matrix,Matrix,Matrix)" -- see
        makeCpMackeyFunctor, -- make a Cp Mackey functor
      * "makeFixedPointMackeyFunctor(ZZ,Matrix)" -- see
        makeFixedPointMackeyFunctor, -- constructs
        the fixed-point Mackey functor of a C_p-module
      * "makeFixedSignMackeyFunctor(Sequence)" -- see
        makeFixedSignMackeyFunctor, -- constructs
        the fixed-point Mackey functor for the sign action of $C_2$ on
        $\mathbb{Z}$
      * "makeFixedTrivMackeyFunctor(ZZ)" -- see
        makeFixedTrivMackeyFunctor, -- constructs
        the fixed-point Mackey functor for the trivial action of $C_p$ on
        $\mathbb{Z}/p$
      * "makeKGroupMackeyFunctor(ZZ,ZZ,ZZ)" -- see
        makeKGroupMackeyFunctor, -- constructs the
        $K$-group Mackey functor
      * "makeOrbitMackeyFunctor(ZZ,Matrix)" -- see
        makeOrbitMackeyFunctor, -- constructs the orbit
        Mackey functor of a C_p-module
      * "makeRandomCpMackeyFunctor(ZZ)" -- see makeRandomCpMackeyFunctor,
        -- generate a random Cp-Mackey functor
      * "makeRandomCpMackeyFunctor(ZZ,List)" -- see
        makeRandomCpMackeyFunctor, -- generate a
        random Cp-Mackey functor
      * "makeRandomMackeyFunctorHomomorphism(CpMackeyFunctor,CpMackeyFunctor)"
        -- see makeRandomMackeyFunctorHomomorphism,
        -- generate a random Cp-Mackey
        functor homomorphism
      * "makeRealRepresentationMackeyFunctor(ZZ)" -- see
        makeRealRepresentationMackeyFunctor,
        -- constructs the real
        representation Mackey functor
      * "makeUnderlyingFreeMackeyFunctor(ZZ)" -- see
        makeUnderlyingFreeMackeyFunctor, --
        constructs the free Mackey functor on an underlying generator
      * "makeZeroMackeyFunctor(ZZ)" -- see makeZeroMackeyFunctor,
        -- constructs the zero Mackey functor for the
        group
      * "makeZeroOnUnderlyingMackeyFunctor(ZZ,Module)" -- see
        makeZeroOnUnderlyingMackeyFunctor,
        -- constructs a Mackey functor which is zero on underlying
      * map(CpMackeyFunctor,CpMackeyFunctor,Matrix,Matrix),
        --
        constructs a map between two Mackey functors
      * map(CpMackeyFunctor,CpMackeyFunctor,ZZ)
        -- constructs the zero
        map between two Mackey functors, or a multiple of the identity map
      * prune(CpMackeyFunctor) -- prune a
        CpMackeyFunctor
      * "realLinearizationMap(ZZ)" -- see realLinearizationMap,
        -- returns the real linearization map for the
        prime p
      * "resolutionCohomological(CpMackeyFunctor,ZZ)" -- see
        resolutionCohomological, -- constructs a free
        resolution in cohomological Mackey functors of specified length
      * source(MackeyFunctorHomomorphism)
        -- returns the source of a
        Mackey functor homomorphism
      * target(MackeyFunctorHomomorphism)
        -- returns the target of a
        Mackey functor homomorphism
      * "Tor_ZZ(CpMackeyFunctor,CpMackeyFunctor)" -- see Tor, --
        computes Tor of two Cp-Mackey fuctors
      * "TorCoh(ZZ,CpMackeyFunctor,CpMackeyFunctor)" -- see TorCoh,
        -- computes Tor of two cohomological Cp-Mackey fuctors
  * Symbols
      * Conj -- the conjugation homomorphism in a Mackey functor
      * Fixed -- the fixed module of a Mackey functor
      * FixedMap -- the fixed-point level of a Mackey functor
        homomorphism
      * GenBound -- optional input for generating random
        Mackey functors
      * PrimeOrder -- the prime order of the group over
        which a Mackey functor is defined
      * Res -- the restriction homomorphism in a Mackey functor
      * Trans -- the transfer homomorphism in a Mackey functor
      * Underlying -- the underlying module of a Mackey
        functor
      * UnderlyingMap -- the underlying level of a Mackey
        functor homomorphism
  * Mutable symbols
      * assertLevel -- controls whether constructors check
        for well-definedness
  * Other things
      * assertLevel -- controls whether constructors check
        for well-definedness

For the programmer
==================

The object CpMackeyFunctors, is a package (Macaulay2Doc),
defined in CpMackeyFunctors.m2, with auxiliary files in
CpMackeyFunctors/.

-------------------------------------------------------------------------------

The source of this document is in
CpMackeyFunctors/Documentation/MainPageDoc.m2:27:0.

assertLevel -- controls whether constructors check for well-definedness
***********************************************************************

Description
===========

This global variable controls whether the makeCpMackeyFunctor,
and
map(CpMackeyFunctor,CpMackeyFunctor,Matrix,Matrix),
methods check
whether the input data yields a well-defined object. If assertLevel,
is set to 0 or lower, then no checks are made, and the methods
will return a Mackey functor or homomorphism (which may be malformed)
regardless of the input data. If assertLevel, is set to 1 or
higher, then the methods will check whether the input data yields a
well-defined Mackey functor or homomorphism, and if not, they will throw an
error.

The default value is 1.

For the programmer
==================

The object assertLevel, is an integer (Macaulay2Doc).

-------------------------------------------------------------------------------

The source of this document is in
CpMackeyFunctors/Documentation/AssertLevelDoc.m2:11:0.

background on Mackey functors -- a brief mathematical intro to the theory of Mackey functors
********************************************************************************************

Mackey functors were introduced by Andreas Dress [D71] as a way to encode a
system of abelian groups indexed along conjugacy classes of a subgroup, with
homomorphisms between them behaving analogously to restriction and induction of
representations. They are ubiquitous in mathematics, appearing in
representation theory, group cohomology, equivariant cohomology of $G$-spaces,
algebraic $K$-theory of group rings, algebraic number theory (where they go by
the name modulations), and many other contexts.

Assumption: In this package, we will work with cyclic groups of prime order.
The reason for this reduction is the simple subgroup structure of $C_p$, which
reduces our data structure dramatically. Furthermore, the theory of
$C_p$-Mackey functors is already highly complicated - for example no
classification result is known.

Definition: Let $p$ be a prime. A $C_p$-Mackey functor is the data of two
abelian groups $M(C_p/e)$ (called the underlying) and $M(C_p/C_p)$ (called the
fixed), together with three abelian group homomorphisms, called restriction,
transfer, and conjugation, respectively:

\[\text{res} \colon M(C_p/C_p) \to M(C_p/e),\] \[\text{tr} \colon M(C_p/e) \to
M(C_p/C_p),\] \[\text{conj} \colon M(C_p/e) \to M(C_p/e)\]

subject to the following axioms:

  0. $\text{conj}$ is an automorphism of order dividing $p$ (encoding an action
     of the cyclic group $C_p$ on $M(C_p/e)$)
  1. $\text{conj}\circ\text{res} = \text{res}$ and $\text{tr}\circ\text{conj} =
     \text{tr}$
  2. $\text{res}(\text{tr}(x)) = \sum_{i=0}^{p-1}\text{conj}^{i}(x)$ for every
     $x\in M(C_p/e)$

Example: The easiest example is when all the abelian groups are the trivial
group, and hence all maps are trivial. This is called the zero Mackey functor.

Example: A prototypical example has underlying module $\ZZ$ (i.e. the complex
representation ring of the trivial group) and fixed module given by the complex
representation ring of $C_p$, with transfer and restriction coming from
restriction and transfer of $C_p$-representations. This is called the
representation Mackey functor.

Note: For general examples and their constructors, see constructing examples of Mackey functors,
and for
some common Mackey functors used over the group $C_p$, see list of common Mackey functors.

We frequently use $M$ as shorthand for all the data $(M(C_p/e), M(C_p/C_p),
\text{res},\text{tr},\text{conj})$.

Definition: If $M$ and $N$ are both $C_p$-Mackey functors, a Mackey functor homomorphism,
$f \colon M \to N$ is the data
of a morphism $f_{C_p/e} \colon M(C_p/e) \to N(C_p/e)$ and $f_{C_p/C_p} \colon
M(C_p/C_p) \to N(C_p/C_p)$ which commute with transfer, restriction, and
conjugation. Explicitly (if we decorate things like $\text{res}$ with a
subscript to indicate which Mackey functor they are coming from) we mean that
the following relations must hold:

  0. $\text{res}_N\circ f_{C_p/C_p} = f_{C_p/e}\circ \text{res}_M$
  1. $\text{tr}_N \circ f_{C_p/e} = f_{C_p/C_p} \circ \text{tr}_M$
  2. $\text{conj}_N\circ f_{C_p/e} = f_{C_p/e} \circ \text{conj}_M$

References:

  * [D71] A. Dress, Notes on the theory of representations of finite groups.
    Part I: The Burnside ring of a finite group and some AGN-applications.
    Bielefeld.
  * [W00] P. Webb, A guide to mackey functors Handbook of Algebra, 2000.

See also
========

  * the abelian category of Mackey functors
    -- background on the category of Mackey functors and how
    to code within it
  * constructing examples of Mackey functors
    -- info about how to construct explicit Mackey functors
  * list of common Mackey functors -- a
    list of common Cp-Mackey functors
  * explicit applications of the CpMackeyFunctors package
    -- info about how this
    package can be applied to real-life examples
-------------------------------------------------------------------------------

The source of this document is in
CpMackeyFunctors/Documentation/BackgroundDoc.m2:55:0.

boxProduct -- box product of Cp-Mackey functors
***********************************************

  * Usage:
        M ⊠ N
        boxProduct(M,N)
        M ** N
  * Inputs:
      * M, a C_p Mackey Functor,
      * N, a C_p Mackey Functor,
  * Outputs:
      * a C_p Mackey Functor, the box product of $M$
        and $N$

Description
===========

Given two Cp-Mackey functors, $M$ and $N$, we can form
their box product, which creates another Mackey functor. This new Mackey
functor is defined by the following data:

  * underlying module: defined as $M(C_p/e) \otimes N(C_p/e)$
  * fixed module: defined as $(M(C_p/C_p)\otimes N(C_p/C_p)) \oplus (M(C_p/e)
    \otimes N(C_p/e))/ \sim$ where the equivalence relation is generated by $$(
    \text{tr}(x)\otimes b,0 ) \sim ( 0,
    x\otimes\text{res}(b))$$$$(a\otimes\text{tr}(y),0)\sim(0,\text{res}(a)\
    otimes y)$$ and $$(0, x\otimes y)\sim(0, c(x)\otimes c(y))$$
  * restriction: defined by the formula $$[a\otimes b, x\otimes y] \mapsto
    \text{res}(a) \otimes \text{res}(b) + \sum_{i=0}^{p-1} c^i(x) \otimes
    c^i(y).$$
  * transfer: defined by the formula$$x\otimes y \mapsto [0,x \otimes y]$$
  * conjugation: defined by $c\otimes c$.

The box product makes $\text{Mack}_{C_p}$ into a symmetric monoidal category,
which is closed symmetric monoidal due to the internal hom.

+-----------------------------------------------------------------------------+
|i1 : M= makeUnderlyingFreeMackeyFunctor(2);                                  |
+-----------------------------------------------------------------------------+
|i2 : M**M                                                                    |
|                                                                             |
|o2 =                                         Res : | 1 1 0 0 1 |             |
|                                                   | 1 0 1 1 0 |             |
|                                                   | 1 0 1 1 0 |             |
|                                                   | 1 1 0 0 1 |             |
|     cokernel | 1  1  1  1  0  0  0  0  |  ----------------------->   4  -┐  |
|              | -1 0  -1 0  1  0  0  -1 | <-----------------------  ZZ   <┘  |
|              | -1 0  0  -1 0  1  -1 0  |    Tr : | 0 1  1  0 |              |
|              | 0  -1 -1 0  0  -1 1  0  |         | 1 -1 -1 1 |              |
|              | 0  -1 0  -1 -1 0  0  1  |         | 0 0  0  0 |              |
|                                                  | 0 0  0  0 |              |
|                                                  | 0 0  0  0 |              |
|                                                                             |
|o2 : CpMackeyFunctor                                                         |
|-----------------------------------------------------------------------------|
|Conj : | 0 0 0 1 |                                                           |
|       | 0 0 1 0 |                                                           |
|       | 0 1 0 0 |                                                           |
|       | 1 0 0 0 |                                                           |
+-----------------------------------------------------------------------------+

See also
========

  * the abelian category of Mackey functors
    -- background on the category of Mackey functors and how
    to code within it
  * internalHom(CpMackeyFunctor,CpMackeyFunctor) -- returns
    the internal hom Mackey functor between two Mackey functors.

Ways to use boxProduct:
=======================

  * "boxProduct(CpMackeyFunctor,CpMackeyFunctor)"
  * "boxProduct(CpMackeyFunctor,MackeyFunctorHomomorphism)" -- see
    boxProduct(MackeyFunctorHomomorphism,CpMackeyFunctor),
    -- induced
    maps on box products
  * boxProduct(MackeyFunctorHomomorphism,CpMackeyFunctor)
    -- induced
    maps on box products

For the programmer
==================

The object boxProduct, is a method function (Macaulay2Doc).

-------------------------------------------------------------------------------

The source of this document is in
CpMackeyFunctors/Documentation/BoxProductDoc.m2:40:0.

boxProduct(MackeyFunctorHomomorphism,CpMackeyFunctor) -- induced maps on box products
*************************************************************************************

  * Function: boxProduct,
  * Usage:
        F ⊠ M
        boxProduct(F,M)
        F ** M
        M ⊠ F
        boxProduct(M,F)
        M ** F
  * Inputs:
      * F, a Mackey Functor homomorphism,
      * M, a C_p Mackey Functor,
  * Outputs:
      * a Mackey Functor homomorphism, the
        map induced by taking the box product of M with a morphism F.

Description
===========

A map $F\colon P\to Q$ of Mackey functors can be tesnored with a Mackey functor
$M$ to form a map $M ⊠ F\colon M ⊠ P\to M ⊠ Q$.

+-----------------------------------------------------------------------------+
|i1 : boxProduct(makeUnderlyingFreeMackeyFunctor(3),                          |
|                                                                             |
|o1 =                                                                         |
|                                                                             |
|                                                                             |
|                                                                             |
|                                                                             |
|                                                                             |
|     cokernel | 1  0  0  1  0  0  1  0  0  1  0  0                           |
|              | 0  1  0  0  1  0  0  1  0  1  0  0                           |
|              | 0  0  1  0  0  1  0  0  1  1  0  0                           |
|              | -1 -1 -1 0  0  0  0  0  0  -1 1  0                           |
|              | 0  0  0  -1 -1 -1 0  0  0  -1 -1 1                           |
|              | 0  0  0  0  0  0  -1 -1 -1 -1 0  -1                          |
|                             ^ |                                             |
|                             | |                                             |
|                             | v                                             |
|                                3                                            |
|                              ZZ                                             |
|                             ^ |                                             |
|                             └-┘                                             |
|                                                                             |
|o1 : MackeyFunctorHomomorphism                                               |
|-----------------------------------------------------------------------------|
|complexLinearizationMap(3))                                                  |
|                                                                             |
|         fix : | 1 3 1 1 1 |                                                 |
|               | 0 0 0 0 0 |                                                 |
|               | 0 0 0 0 0 |                                                 |
|               | 0 0 0 0 0 |                                                 |
|               | 0 0 0 0 0 |                                                 |
|               | 0 0 0 0 0 |                                                 |
| 0  | <----------------------- cokernel | 1  0  1  0  1  0  0  0  0  0  |    |
| 0  |                                   | 0  1  0  1  0  1  1  0  0  0  |    |
| 0  |                                   | -1 -3 0  0  0  0  -1 1  0  -1 |    |
| -1 |                                   | 0  0  -1 -3 0  0  -1 -1 1  0  |    |
| 0  |                                   | 0  0  0  0  -1 -3 -1 0  -1 1  |    |
| 1  |                                              ^ |                       |
|                                                   | |                       |
|                                                   | |                       |
|                                                   | v                       |
|      <-----------------------                       3                       |
|         und : | 1 0 0 |                           ZZ                        |
|               | 0 1 0 |                           ^ |                       |
|               | 0 0 1 |                           └-┘                       |
+-----------------------------------------------------------------------------+

See also
========

  * the abelian category of Mackey functors
    -- background on the category of Mackey functors and how
    to code within it
  * boxProduct -- box product of Cp-Mackey functors

Ways to use this method:
========================

  * "boxProduct(CpMackeyFunctor,MackeyFunctorHomomorphism)"
  * boxProduct(MackeyFunctorHomomorphism,CpMackeyFunctor)
    -- induced
    maps on box products
-------------------------------------------------------------------------------

The source of this document is in
CpMackeyFunctors/Documentation/BoxProductDoc.m2:73:0.

cokernel(MackeyFunctorHomomorphism) -- cokernel of a Mackey functor homomorphism
********************************************************************************

  * Function: cokernel (Macaulay2Doc),
  * Usage:
        cokernel f
  * Inputs:
      * f, a Mackey Functor homomorphism,
  * Outputs:
      * a C_p Mackey Functor, the cokernel of the
        homomorphism f

See also
========

  * the abelian category of Mackey functors
    -- background on the category of Mackey functors and how
    to code within it
  * MackeyFunctorHomomorphism -- the class of
    Mackey functor homomorphisms

Ways to use this method:
========================

  * cokernel(MackeyFunctorHomomorphism)
    -- cokernel of a Mackey functor
    homomorphism
-------------------------------------------------------------------------------

The source of this document is in
CpMackeyFunctors/Documentation/AbelianCategoryDoc.m2:147:0.

complexLinearizationMap -- returns the complex linearization map for the prime p
********************************************************************************

  * Usage:
        complexLinearizationMap(p)
  * Inputs:
      * p, an integer (Macaulay2Doc),
  * Outputs:
      * a Mackey Functor homomorphism, the
        linearization map from the Burnside Mackey functor to the complex
        representation functor for the prime p.

Description
===========

Every $G$-set $X$ determines a complex representation with basis $X$, called
the permutation representation of $X$.  This induces a map from the
Burnside Mackey functor, to the complex representation Mackey functor,
called
the linearization map.

+---------------------------------+
|i1 : complexLinearizationMap(5)  |
|                                 |
|o1 =         fix : | 1 1 |       |
|                   | 0 1 |       |
|                   | 0 1 |       |
|                   | 0 1 |       |
|                   | 0 1 |       |
|       5  <-----------------   2 |
|     ZZ                      ZZ  |
|     ^ |                     ^ | |
|     | |                     | | |
|     | v                     | v |
|       1  <-----------------   1 |
|     ZZ      und : | 1 |     ZZ  |
|     ^ |                     ^ | |
|     └-┘                     └-┘ |
|                                 |
|o1 : MackeyFunctorHomomorphism   |
+---------------------------------+

See also
========

  * MackeyFunctorHomomorphism -- the class of
    Mackey functor homomorphisms
  * realLinearizationMap -- returns the real
    linearization map for the prime p

Ways to use complexLinearizationMap:
====================================

  * "complexLinearizationMap(ZZ)"

For the programmer
==================

The object complexLinearizationMap, is a
method function (Macaulay2Doc).

-------------------------------------------------------------------------------

The source of this document is in
CpMackeyFunctors/Documentation/HomomorphismsDoc.m2:207:0.

Conj -- the conjugation homomorphism in a Mackey functor
********************************************************

  * Usage:
        M.Conj

See also
========

  * background on Mackey functors -- a
    brief mathematical intro to the theory of Mackey functors
  * CpMackeyFunctor -- The type of Cp Mackey functors

For the programmer
==================

The object Conj, is a symbol (Macaulay2Doc).

-------------------------------------------------------------------------------

The source of this document is in
CpMackeyFunctors/Documentation/MackeyFunctorDoc.m2:222:0.

constructing examples of Mackey functors -- info about how to construct explicit Mackey functors
************************************************************************************************

The general constructor: New Mackey functors can be built using
makeCpMackeyFunctor, which constructs a Mackey functor
out of a restriction, transfer, and conjugation matrix (Macaulay2Doc),
in that order. It takes as input a prime, and three
matrices. For example, we can construct $\mathbb{F}_4$ as a $C_2$-Galois Mackey
functor as follows:

+-----------------------------------------------------------------------------+
|i1 : U:=cokernel(matrix({{2,0},{0,2}}));                                     |
+-----------------------------------------------------------------------------+
|i2 : C:=inducedMap(U,U,matrix({{1,1},{0,1}}));                               |
|                                                                             |
|o2 : Matrix                                                                  |
+-----------------------------------------------------------------------------+
|i3 : F:=kernel(C - id_U);                                                    |
+-----------------------------------------------------------------------------+
|i4 : R:=inducedMap(U,F,matrix({{1,0},{0,1}}));                               |
|                                                                             |
|o4 : Matrix                                                                  |
+-----------------------------------------------------------------------------+
|i5 : T:=inducedMap(F,U,matrix({{0,1},{0,0}}));                               |
|                                                                             |
|o5 : Matrix                                                                  |
+-----------------------------------------------------------------------------+
|i6 : M:=makeCpMackeyFunctor(2,R,T,C)                                         |
|                                                                             |
|o6 =                                   Res : | 1 0 |                         |
|                                             | 0 0 |                         |
|     subquotient (| 1 0 |, | 2 0 |)  -----------------> cokernel | 2 0 |  -┐ |
|                  | 0 2 |  | 0 2 |  <-----------------           | 0 2 |  <┘ |
|                                       Tr : | 0 1 |                          |
|                                            | 0 0 |                          |
|                                                                             |
|o6 : CpMackeyFunctor                                                         |
|-----------------------------------------------------------------------------|
|Conj : | 1 1 |                                                               |
|       | 0 1 |                                                               |
+-----------------------------------------------------------------------------+

The output of the makeCpMackeyFunctor, method is a
CpMackeyFunctor, which is a new type (Macaulay2Doc),
implemented in this package. Under the hood it is a
hash table (Macaulay2Doc), encoding all the data of the Mackey
functor. The underlying and fixed modules can be recovered with the
Underlying, and Fixed, keys, and the homomorphisms in
the data can be recovered from Res, Trans, and
Conj, keys.

Pruning: Any time we might need a nicer, more readable form of a Mackey
functor, we can use the prune, method to
simplify the presentation of the underlying/fixed modules.

Algebraic constructors: We provide specific methods for constructing common
examples of $C_p$-Mackey functors coming from algebra and representation
theory. The Burnside Mackey functor, is a
prototypical example -- its underlying module is $\ZZ$ with trivial conjugation
action, and its fixed module is the Burnside ring $A(C_p)$, which is the group
completion of the monoid of isomorphism classes of finite $C_p$-sets.

Another example from algebra are the real,
and complex representation,
Mackey functors. Similarly to the
Burnside Mackey functor, their underlying module is $\ZZ$, however their fixed
module is the representation ring of $C_p$. Any finite $C_p$-set has an
associated permutation representation, which induces what are called the
real, and complex linearization maps,
from the Burnside Mackey functor to the representation
Mackey functor.

Fixed point and orbit Mackey functors: If $M$ is a $\ZZ[C_p]$-module, the
fixed point Mackey functor, of $M$ has $M$ as its
underlying module and the fixed points $M^{C_p}$ as its fixed module. The
conjugation action on $M$ is the $C_p$-action, and the transfer sums along the
orbits of an element.

+-------------------------------------------------------------------+
|i7 : makeFixedPointMackeyFunctor(2,matrix{{0,1,0},{1,0,0},{0,0,1}})|
|                                                                   |
|o7 =                  Res : | 1 0 |                                |
|                            | 1 0 |                                |
|                            | 0 1 |                                |
|     image | 1 0 |  ------------------->   3  -┐ Conj : | 0 1 0 |  |
|           | 1 0 | <-------------------  ZZ   <┘        | 1 0 0 |  |
|           | 0 1 |    Tr : | 1 1 0 |                    | 0 0 1 |  |
|                           | 0 0 2 |                               |
|                                                                   |
|o7 : CpMackeyFunctor                                               |
+-------------------------------------------------------------------+

Similarly, given a $\ZZ[C_p]$-module $M$, we can form the orbit Mackey functor,
whose underlying module is again $M$ with
$C_p$-action yielding conjugation. The fixed point module is now the quotient
module $M/C_p$, transfer is the quotient map, and now restriction is defined by
summing along the orbits.

+------------------------------------------------------------------------+
|i8 : makeOrbitMackeyFunctor(2,matrix{{0,1,0},{1,0,0},{0,0,1}})          |
|                                                                        |
|o8 =                         Res : | 1 1 0 |                            |
|                                   | 1 1 0 |                            |
|                                   | 0 0 2 |                            |
|     cokernel | 1  -1 0 |  ------------------->   3  -┐ Conj : | 0 1 0 ||
|              | -1 1  0 | <-------------------  ZZ   <┘        | 1 0 0 ||
|              | 0  0  0 |    Tr : | 1 1 0 |                    | 0 0 1 ||
|                                  | 0 0 0 |                             |
|                                  | 0 0 1 |                             |
|                                                                        |
|o8 : CpMackeyFunctor                                                    |
+------------------------------------------------------------------------+

Free constructors: Analogous to how a free module can be constructed on a
generator or set of generators, we can construct free Mackey functors. For
$C_p$-Mackey functors, there are two modules, which lead to two different ideas
of a "free" Mackey functor, namely a free $C_p$-Mackey functor on a generator
in the underlying module, and a free $C_p$-Mackey functor on a generator in the
fixed module. The free Mackey functor on a single underlying generator,
can be accessed as follows:

+-------------------------------------------------------+
|i9 : makeUnderlyingFreeMackeyFunctor(3)                |
|                                                       |
|o9 =        Res : | 1 |                                |
|                  | 1 |                                |
|                  | 1 |                                |
|       1  ------------------->   3  -┐ Conj : | 0 0 1 ||
|     ZZ  <-------------------  ZZ   <┘        | 1 0 0 ||
|            Tr : | 1 1 1 |                    | 0 1 0 ||
|                                                       |
|o9 : CpMackeyFunctor                                   |
+-------------------------------------------------------+

We often call this $\underline{B}$. Trying to construct a free Mackey functor
on a single generator in the fixed module, we can verify that it recovers a
similar construction, namely the Burnside Mackey functor,
which we often denote by $\underline{A}$.

+--------------------------------------------------+
|i10 : makeBurnsideMackeyFunctor(5)                |
|                                                  |
|o10 =        Res : | 1 5 |                        |
|        2  ----------------->   1  -┐ Conj : | 1 ||
|      ZZ  <-----------------  ZZ   <┘             |
|             Tr : | 0 |                           |
|                  | 1 |                           |
|                                                  |
|o10 : CpMackeyFunctor                             |
+--------------------------------------------------+

These two Mackey functors $\underline{A}$ and $\underline{B}$ are very special
- they are the projective generators of the category $\text{Mack}_G$, and they
play an important role in constructing resolutions.

Random constructor: Furthermore we have a random constructor which allow us to
build a random Mackey functor, over the group
$C_p$. To implement this, we recall that we have projective generators
$\underline{A}$ and $\underline{B}$, hence any Mackey functor $M$ can be
written as a cokernel of some map,
of the form

\[ \underline{A}^k \oplus \underline{B}^\ell \to \underline{A}^n \oplus
\underline{B}^m \to M \to 0.\]

We can specify $k$, $\ell$, $n$, and $m$ if we want, as the following example
over $C_7$ shows:

+--------------------------------------------+
|i11 : makeRandomCpMackeyFunctor(7,{2,2,3,3})|
|                                            |
|o11 =      Res : 0                          |
|      0  -----------> 0  -┐ Conj : 0        |
|        <-----------     <┘                 |
|           Tr : 0                           |
|                                            |
|o11 : CpMackeyFunctor                       |
+--------------------------------------------+

If we don't want to specify this data, $n$ and $m$ will be chosen randomly
between 1 and 10. To randomly choose between 1 and a higher number, we can use
the GenBound option.

+-----------------------------------------------------------------------------+
|i12 : makeRandomCpMackeyFunctor(3)                                           |
|                                                                             |
|o12 =                    Res : | 3 -5  6 |                                   |
|                               | 0 333 3 |                                   |
|      cokernel | 10 |  ---------------------> cokernel | 15 |  -┐ Conj : | 1 |
|               | 0  | <---------------------           | 0  |  <┘        | 0 |
|               | 0  |    Tr : | -4 3 |                                       |
|                              | 0  0 |                                       |
|                              | 0  1 |                                       |
|                                                                             |
|o12 : CpMackeyFunctor                                                        |
|-----------------------------------------------------------------------------|
|5 |                                                                          |
|1 |                                                                          |
+-----------------------------------------------------------------------------+
|i13 : prune makeRandomCpMackeyFunctor(3,GenBound=>20)                        |
|                                                                             |
|o13 =      Res : 0                                                           |
|      0  -----------> 0  -┐ Conj : 0                                         |
|        <-----------     <┘                                                  |
|           Tr : 0                                                            |
|                                                                             |
|o13 : CpMackeyFunctor                                                        |
+-----------------------------------------------------------------------------+

Remark: What makes this possible is the fact that it is computationally very
easy to cook up a random map $\underline{A}^k \oplus \underline{B}^\ell \to
\underline{A}^n \oplus \underline{B}^m$ using the universal properties of the
functors $\underline{A}$ and $\underline{B}$. Since $\underline{A}$
corepresents the fixed module, functor and $\underline{B}$
corepresents the underlying module, functor, we can determine
random maps of the form $\underline{A}^k \oplus \underline{B}^\ell \to M$ by
picking a random list of elements (Macaulay2Doc),
from the fixed and underlying modules
of any $M$.

See also
========

  * background on Mackey functors -- a
    brief mathematical intro to the theory of Mackey functors
  * the abelian category of Mackey functors
    -- background on the category of Mackey functors and how
    to code within it
  * list of common Mackey functors -- a
    list of common Cp-Mackey functors
  * explicit applications of the CpMackeyFunctors package
    -- info about how this
    package can be applied to real-life examples
-------------------------------------------------------------------------------

The source of this document is in
CpMackeyFunctors/Documentation/ConstructorsDoc.m2:78:0.

CpMackeyFunctor -- The type of Cp Mackey functors
*************************************************

Description
===========

This documents the type (Macaulay2Doc), of $C_p$-Mackey functors. A
$C_p$-Mackey functor is encoded as a hash table (Macaulay2Doc),
with keys through which we can pull various parts of the data.

The keys available (internally) in the hash table are as follows, together with
their external get methods:

  * .PrimeOrder yields the order (Macaulay2Doc), of the cyclic group
    over which we're working. See PrimeOrder,
  * .Underlying encodes the module (Macaulay2Doc), $M(C_p/e)$. See
    Underlying,
  * .Fixed encodes the module (Macaulay2Doc), $M(C_p/C_p)$. See
    Fixed,
  * .Res encodes the restriction homomorphism (Macaulay2Doc),
    $M(C_p/C_p) \to M(C_p/e)$. See Res,
  * .Trans encodes the transfer homomorphism (Macaulay2Doc),
    $M(C_p/e) \to M(C_p/C_p)$. See Trans,
  * .Conj encodes the conjugation homomorphism (Macaulay2Doc),
    $M(C_p/e) \to M(C_p/e)$. See Conj,

Constructing new Mackey functors: See constructing examples of Mackey functors.

Operations with Mackey functor types: One of the first operations to know about
is pruning, a $C_p$-Mackey functor. This
basically takes the data of a Mackey functor and attempts to simplify it and
make it more reader-friendly. Pruning is the only unary operation on
$C_p$-Mackey functors that we consider. The $0$-ary (see Boolean (Macaulay2Doc),
-valued) operations are

  * isTrivialMackeyFunctor, checks if a Mackey
    functor is trivial
  * isCohomological, checks if a Mackey functor is
    cohomological

For binary (and $n$-ary) operations, there are a few, including:

  * equality (Macaulay2Doc), of two Mackey functors, via M==N
  * the box product, of two Mackey functors, via  M**N
  * the direct sum (Macaulay2Doc), of two Mackey functors, as
    M++N
  * the internal hom, of two Mackey functors

Well-definedness: The global variable assertLevel, controls
whether the methods that construct Mackey functors will check whether the input
data is well-defined. If assertLevel, is set to 0 or lower,
then no checks are made, and the methods will return a Mackey functor (which
may be malformed) regardless of the input data. If assertLevel,
is set to 1 or higher, then the methods will check whether the
input data yields a well-defined Mackey functor, and if not, they will throw an
error.

See also
========

  * background on Mackey functors -- a
    brief mathematical intro to the theory of Mackey functors
  * list of common Mackey functors -- a
    list of common Cp-Mackey functors
  * MackeyFunctorHomomorphism -- the class of
    Mackey functor homomorphisms

Functions and methods returning a C_p Mackey Functor:
=====================================================

  * "boxProduct(CpMackeyFunctor,CpMackeyFunctor)" -- see boxProduct,
    -- box product of Cp-Mackey functors
  * cokernel(MackeyFunctorHomomorphism)
    -- cokernel of a Mackey functor
    homomorphism
  * "directSum(CpMackeyFunctor)"
  * CpMackeyFunctor ++ CpMackeyFunctor
    -- direct sum of Cp-Mackey functors
  * "Ext^ZZ(CpMackeyFunctor,CpMackeyFunctor)" -- see Ext, --
    computes Ext of two Cp-Mackey fuctors
  * "ExtCoh(ZZ,CpMackeyFunctor,CpMackeyFunctor)" -- see ExtCoh,
    -- computes Ext of two cohomological Cp-Mackey fuctors
  * "internalHom(CpMackeyFunctor,CpMackeyFunctor)" -- see internalHom,
    -- returns the internal hom Mackey functor between two Mackey
    functors.
  * kernel(MackeyFunctorHomomorphism)
    -- kernel of a Mackey functor
    homomorphism
  * "makeBurnsideMackeyFunctor(ZZ)" -- see makeBurnsideMackeyFunctor,
    -- constructs the Burnside Mackey functor
  * "makeComplexRepresentationMackeyFunctor(ZZ)" -- see
    makeComplexRepresentationMackeyFunctor,
    -- constructs the complex
    representation Mackey functor
  * "makeCpMackeyFunctor(ZZ,Matrix,Matrix,Matrix)" -- see
    makeCpMackeyFunctor, -- make a Cp Mackey functor
  * "makeFixedPointMackeyFunctor(ZZ,Matrix)" -- see
    makeFixedPointMackeyFunctor, -- constructs the
    fixed-point Mackey functor of a C_p-module
  * "makeFixedTrivMackeyFunctor(ZZ)" -- see makeFixedTrivMackeyFunctor,
    -- constructs the fixed-point Mackey functor
    for the trivial action of $C_p$ on $\mathbb{Z}/p$
  * "makeKGroupMackeyFunctor(ZZ,ZZ,ZZ)" -- see makeKGroupMackeyFunctor,
    -- constructs the $K$-group Mackey functor
  * "makeOrbitMackeyFunctor(ZZ,Matrix)" -- see makeOrbitMackeyFunctor,
    -- constructs the orbit Mackey functor of a
    C_p-module
  * "makeRandomCpMackeyFunctor(ZZ)" -- see makeRandomCpMackeyFunctor,
    -- generate a random Cp-Mackey functor
  * "makeRandomCpMackeyFunctor(ZZ,List)" -- see
    makeRandomCpMackeyFunctor, -- generate a random
    Cp-Mackey functor
  * "makeRealRepresentationMackeyFunctor(ZZ)" -- see
    makeRealRepresentationMackeyFunctor,
    -- constructs the real representation Mackey functor
  * "makeUnderlyingFreeMackeyFunctor(ZZ)" -- see
    makeUnderlyingFreeMackeyFunctor, --
    constructs the free Mackey functor on an underlying generator
  * "makeZeroMackeyFunctor(ZZ)" -- see makeZeroMackeyFunctor,
    -- constructs the zero Mackey functor for the group
  * "makeZeroOnUnderlyingMackeyFunctor(ZZ,Module)" -- see
    makeZeroOnUnderlyingMackeyFunctor, --
    constructs a Mackey functor which is zero on underlying
  * prune(CpMackeyFunctor) -- prune a
    CpMackeyFunctor
  * source(MackeyFunctorHomomorphism)
    -- returns the source of a Mackey
    functor homomorphism
  * target(MackeyFunctorHomomorphism)
    -- returns the target of a Mackey
    functor homomorphism
  * "Tor_ZZ(CpMackeyFunctor,CpMackeyFunctor)" -- see Tor, --
    computes Tor of two Cp-Mackey fuctors
  * "TorCoh(ZZ,CpMackeyFunctor,CpMackeyFunctor)" -- see TorCoh,
    -- computes Tor of two cohomological Cp-Mackey fuctors

Methods that use a C_p Mackey Functor:
======================================

  * "CpMackeyFunctor ** CpMackeyFunctor" -- see boxProduct,
    -- box product of Cp-Mackey functors
  * "CpMackeyFunctor ⊠ CpMackeyFunctor" -- see boxProduct, --
    box product of Cp-Mackey functors
  * "boxProduct(CpMackeyFunctor,MackeyFunctorHomomorphism)" -- see
    boxProduct(MackeyFunctorHomomorphism,CpMackeyFunctor),
    -- induced
    maps on box products
  * boxProduct(MackeyFunctorHomomorphism,CpMackeyFunctor)
    -- induced
    maps on box products
  * "CpMackeyFunctor ** MackeyFunctorHomomorphism" -- see
    boxProduct(MackeyFunctorHomomorphism,CpMackeyFunctor),
    -- induced
    maps on box products
  * "CpMackeyFunctor ⊠ MackeyFunctorHomomorphism" -- see
    boxProduct(MackeyFunctorHomomorphism,CpMackeyFunctor),
    -- induced
    maps on box products
  * "MackeyFunctorHomomorphism ** CpMackeyFunctor" -- see
    boxProduct(MackeyFunctorHomomorphism,CpMackeyFunctor),
    -- induced
    maps on box products
  * "MackeyFunctorHomomorphism ⊠ CpMackeyFunctor" -- see
    boxProduct(MackeyFunctorHomomorphism,CpMackeyFunctor),
    -- induced
    maps on box products
  * "CpMackeyFunctor == CpMackeyFunctor"
  * "net(CpMackeyFunctor)"
  * "drawVerticalCpMackeyFunctor(CpMackeyFunctor)" -- see
    drawVerticalCpMackeyFunctor, -- reorients the
    net of a Mackey functor vertically
  * freeResolution(CpMackeyFunctor,ZZ)
    -- constructs a free Mackey
    functor resolution of specified length
  * Hom(CpMackeyFunctor,CpMackeyFunctor)
    -- computes the Hom group
    between two Cp Mackey functors
  * Hom(CpMackeyFunctor,MackeyFunctorHomomorphism)
    -- computes the
    induced map on Hom groups
  * "Hom(MackeyFunctorHomomorphism,CpMackeyFunctor)" -- see
    Hom(CpMackeyFunctor,MackeyFunctorHomomorphism),
    -- computes the
    induced map on Hom groups
  * inducedMap(CpMackeyFunctor,CpMackeyFunctor)
    -- tries to induce a
    natural map between two Mackey functors
  * "inducedMap(CpMackeyFunctor,CpMackeyFunctor,MackeyFunctorHomomorphism)" --
    see inducedMap(CpMackeyFunctor,CpMackeyFunctor),
    -- tries to induce a
    natural map between two Mackey functors
  * "inducedMap(CpMackeyFunctor,CpMackeyFunctor,Matrix,Matrix)" -- see
    inducedMap(CpMackeyFunctor,CpMackeyFunctor),
    -- tries to induce a
    natural map between two Mackey functors
  * internalHom(CpMackeyFunctor,MackeyFunctorHomomorphism)
    -- returns
    the induced map on an internal hom.
  * "internalHom(MackeyFunctorHomomorphism,CpMackeyFunctor)" -- see
    internalHom(CpMackeyFunctor,MackeyFunctorHomomorphism),
    -- returns
    the induced map on an internal hom.
  * "isCohomological(CpMackeyFunctor)" -- see isCohomological,
    -- checks if a CpMackeyFunctor is cohomological
  * "isTrivialMackeyFunctor(CpMackeyFunctor)" -- see
    isTrivialMackeyFunctor, -- checks if a Mackey
    functor is trivial or not
  * "makeRandomMackeyFunctorHomomorphism(CpMackeyFunctor,CpMackeyFunctor)" --
    see makeRandomMackeyFunctorHomomorphism,
    -- generate a random Cp-Mackey functor
    homomorphism
  * map(CpMackeyFunctor,CpMackeyFunctor,Matrix,Matrix)
    -- constructs
    a map between two Mackey functors
  * map(CpMackeyFunctor,CpMackeyFunctor,ZZ)
    -- constructs the zero map
    between two Mackey functors, or a multiple of the identity map
  * "resolutionCohomological(CpMackeyFunctor,ZZ)" -- see
    resolutionCohomological, -- constructs a free
    resolution in cohomological Mackey functors of specified length

For the programmer
==================

The object CpMackeyFunctor, is a type (Macaulay2Doc),
with ancestor classes HashTable (Macaulay2Doc),
< Thing (Macaulay2Doc).

-------------------------------------------------------------------------------

The source of this document is in
CpMackeyFunctors/Documentation/MackeyFunctorDoc.m2:55:0.

CpMackeyFunctor ++ CpMackeyFunctor -- direct sum of Cp-Mackey functors
**********************************************************************

  * Operator: ++ (Macaulay2Doc),
  * Usage:
        M ++ N
  * Inputs:
      * M, a C_p Mackey Functor,
      * N, a C_p Mackey Functor,
  * Outputs:
      * a C_p Mackey Functor, the direct sum of $M$ and
        $N$

Description
===========

Given two Cp-Mackey Functors, $M$ and $N$, we can form
their direct sum, defined by taking the levelwise direct sum of the underlying
and fixed modules.

See also
========

  * the abelian category of Mackey functors
    -- background on the category of Mackey functors and how
    to code within it
  * MackeyFunctorHomomorphism -- the class of
    Mackey functor homomorphisms

Ways to use this method:
========================

  * CpMackeyFunctor ++ CpMackeyFunctor
    -- direct sum of Cp-Mackey functors
-------------------------------------------------------------------------------

The source of this document is in
CpMackeyFunctors/Documentation/AbelianCategoryDoc.m2:110:0.

drawVerticalCpMackeyFunctor -- reorients the net of a Mackey functor vertically
*******************************************************************************

  * Usage:
        drawVerticalCpMackeyFunctor M
  * Inputs:
      * M, a C_p Mackey Functor,
  * Outputs:
      * a net (Macaulay2Doc),

Description
===========

Reorients the net (Macaulay2Doc), of a Mackey functor vertically

+-----------------------------------------------------------------------------+
|i1 : M = makeRandomCpMackeyFunctor(2)                                        |
|                                                                             |
|o1 =                     Res : | 1 0 |                                       |
|                               | 0 0 |                                       |
|                               | 0 0 |                                       |
|                               | 0 1 |                                       |
|     cokernel | 6 0 |  ---------------------------> cokernel | 2 |  -┐ Conj :|
|              | 0 0 | <---------------------------           | 0 |  <┘       |
|                         Tr : | 0 3    0    0 |              | 0 |           |
|                              | 0 1671 2347 2 |              | 0 |           |
|                                                                             |
|o1 : CpMackeyFunctor                                                         |
|-----------------------------------------------------------------------------|
|| 1 1    0    0 |                                                            |
|| 0 -1   0    0 |                                                            |
|| 0 0    -1   0 |                                                            |
|| 0 1671 2347 1 |                                                            |
+-----------------------------------------------------------------------------+
|i2 : drawVerticalCpMackeyFunctor M                                           |
|                                                                             |
|o2 =          cokernel | 6 0 |                                               |
|                       | 0 0 |                                               |
|                     ^ |                                                     |
|      Res            | |         Tr                                          |
|     | 1 0 |         | |        | 0 3    0    0 |                            |
|     | 0 0 |         | |        | 0 1671 2347 2 |                            |
|     | 0 0 |         | |                                                     |
|     | 0 1 |         | |                                                     |
|                     | V                                                     |
|               cokernel | 2 |                                                |
|                        | 0 |                                                |
|                        | 0 |                                                |
|                        | 0 |                                                |
|                       ^                                                     |
|                     └-┘                                                     |
|                      c                                                      |
|              | 1 1    0    0 |                                              |
|              | 0 -1   0    0 |                                              |
|              | 0 0    -1   0 |                                              |
|              | 0 1671 2347 1 |                                              |
+-----------------------------------------------------------------------------+

See also
========

  * background on Mackey functors -- a
    brief mathematical intro to the theory of Mackey functors
  * CpMackeyFunctor -- The type of Cp Mackey functors

Ways to use drawVerticalCpMackeyFunctor:
========================================

  * "drawVerticalCpMackeyFunctor(CpMackeyFunctor)"

For the programmer
==================

The object drawVerticalCpMackeyFunctor, is a
method function (Macaulay2Doc).

-------------------------------------------------------------------------------

The source of this document is in
CpMackeyFunctors/Documentation/MackeyFunctorDoc.m2:150:0.

explicit applications of the CpMackeyFunctors package -- info about how this package can be applied to real-life examples
*************************************************************************************************************************

This package can be used to perform Tor and Ext computations for $C_p$-Mackey
functors.  It also implements Tor and Ext in the abelian subcategory of
cohomological $C_p$-Mackey functors. Computations of Tor and Ext groups for
(cohomological) Mackey functors are important for work in equivariant homotopy
theory.  As a demonstration, we present some computations which appear in the
work of Mingcong Zeng [Zeng18]. As setup, let $B_1$ be the $C_p$-Mackey functor
with fixed module $\mathbb{Z}/p$ and underlying module $0$.  Let $Z$ denote the
fixed point Mackey functor, for $\ZZ$ as a
trivial $C_p$-module (called $\square$ on the list here).

Proposition: For any prime number $p$ we have \[ \mathrm{Ext}^i_{Z}(B_1,Z) =
\begin{cases} B_1 & i=3 \\ 0. & \textrm{else.} \end{cases} \] Note that by a
theorem of Arnold (see [Arn] and also [BSW]) the category of cohomological
Mackey functors has global dimension $3$, so it suffices to compute the first
four Ext Mackey functors. For concreteness, we will do the computation at the
prime 11.

+--------------------------------------------------+
|i1 : B = cokernel(matrix({{11}}));                |
+--------------------------------------------------+
|i2 : B1 = makeZeroOnUnderlyingMackeyFunctor(11,B) |
|                                                  |
|o2 =                    Res : 0                   |
|     cokernel | 11 |  -----------> 0  -┐ Conj : 0 |
|                     <-----------     <┘          |
|                        Tr : 0                    |
|                                                  |
|o2 : CpMackeyFunctor                              |
+--------------------------------------------------+
|i3 : Z = makeFixedPointMackeyFunctor(11,id_(ZZ^1))|
|                                                  |
|o3 =        Res : | 1 |                           |
|       1  ---------------->   1  -┐ Conj : | 1 |  |
|     ZZ  <----------------  ZZ   <┘               |
|            Tr : | 11 |                           |
|                                                  |
|o3 : CpMackeyFunctor                              |
+--------------------------------------------------+
|i4 : for i to 3 do (print (prune ExtCoh(i,B1,Z))) |
|     Res : 0                                      |
|0  -----------> 0  -┐ Conj : 0                    |
|  <-----------     <┘                             |
|     Tr : 0                                       |
|     Res : 0                                      |
|0  -----------> 0  -┐ Conj : 0                    |
|  <-----------     <┘                             |
|     Tr : 0                                       |
|     Res : 0                                      |
|0  -----------> 0  -┐ Conj : 0                    |
|  <-----------     <┘                             |
|     Tr : 0                                       |
|                   Res : 0                        |
|cokernel | 11 |  -----------> 0  -┐ Conj : 0      |
|                <-----------     <┘               |
|                   Tr : 0                         |
+--------------------------------------------------+

We can also recover some Tor computations which appear in Zeng's work.  Let
$DZ$ denote the Mackey functor which is $\mathbb{Z}$ at fixed and underlying,
transfer and conjugation are the identity, and restriction is multiplication by
$p$.

Proposition: For any prime number $p$ we have \[ \mathrm{Tor}^{Z}_i(B_1,B_1) =
\begin{cases} B_1 & i=0,3 \\ 0 & \textrm{else.} \end{cases} \] and \[
\mathrm{Tor}^{Z}_i(DZ,DZ) = \begin{cases} DZ & i=0 \\ B_1 & i=1 \\ 0 &
\textrm{else.} \end{cases} \] Again, we will perform these computations at the
prime $p=11$.

+-----------------------------------------------------------------------------+
|i5 : B = cokernel(matrix({{11}}));                                           |
+-----------------------------------------------------------------------------+
|i6 : B1 = makeZeroOnUnderlyingMackeyFunctor(11,B)                            |
|                                                                             |
|o6 =                    Res : 0                                              |
|     cokernel | 11 |  -----------> 0  -┐ Conj : 0                            |
|                     <-----------     <┘                                     |
|                        Tr : 0                                               |
|                                                                             |
|o6 : CpMackeyFunctor                                                         |
+-----------------------------------------------------------------------------+
|i7 : DZ = makeOrbitMackeyFunctor(11,id_(ZZ^1))                               |
|                                                                             |
|o7 =        Res : | 11 |                                                     |
|       1  ---------------->   1  -┐ Conj : | 1 |                             |
|     ZZ  <----------------  ZZ   <┘                                          |
|            Tr : | 1 |                                                       |
|                                                                             |
|o7 : CpMackeyFunctor                                                         |
+-----------------------------------------------------------------------------+
|i8 : for i to 3 do (print (prune TorCoh(i,B1,B1)))                           |
|                       Res : 0                                               |
|cokernel | 11 0 0 |  -----------> 0  -┐ Conj : 0                             |
|                    <-----------     <┘                                      |
|                       Tr : 0                                                |
|     Res : 0                                                                 |
|0  -----------> 0  -┐ Conj : 0                                               |
|  <-----------     <┘                                                        |
|     Tr : 0                                                                  |
|     Res : 0                                                                 |
|0  -----------> 0  -┐ Conj : 0                                               |
|  <-----------     <┘                                                        |
|     Tr : 0                                                                  |
|                                             Res : 0                         |
|cokernel | 11 0 0 0 0 0 0 0 0 0 0 0 0 0 |  -----------> 0  -┐ Conj : 0       |
|                                          <-----------     <┘                |
|                                             Tr : 0                          |
+-----------------------------------------------------------------------------+
|i9 : for i to 3 do (print (prune TorCoh(i,DZ,DZ)))                           |
|       Res : | 11 |                                                          |
|  1  ---------------->   1  -┐ Conj : | 1 |                                  |
|ZZ  <----------------  ZZ   <┘                                               |
|       Tr : | 1 |                                                            |
|                                                                             |
|cokernel | 11 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 |            |
|                                                                             |
|                                                                             |
|     Res : 0                                                                 |
|0  -----------> 0  -┐ Conj : 0                                               |
|  <-----------     <┘                                                        |
|     Tr : 0                                                                  |
|     Res : 0                                                                 |
|0  -----------> 0  -┐ Conj : 0                                               |
|  <-----------     <┘                                                        |
|     Tr : 0                                                                  |
|-----------------------------------------------------------------------------|
|   Res : 0                                                                   |
| -----------> 0  -┐ Conj : 0                                                 |
|<-----------     <┘                                                          |
|   Tr : 0                                                                    |
+-----------------------------------------------------------------------------+
  * [Arn] J.E. Arnold, The permutation projective dimension of odd p-groups.
    Comm. Algebra 13, 387-397 (1985).
  * [BSW] S. Bouc, R. Stancu, P. Webb, On the projective dimensions of Mackey
    functors Algebr. Represent. Theory 20 (2017), no. 6, 1467-1481.
  * [Zen] M. Zeng, Mackey functors, equviariant Eilenberg-Mac Lane Spectra and
    their slices. PhD. Thesis

See also
========

  * background on Mackey functors -- a
    brief mathematical intro to the theory of Mackey functors
  * the abelian category of Mackey functors
    -- background on the category of Mackey functors and how
    to code within it
  * constructing examples of Mackey functors
    -- info about how to construct explicit Mackey functors
  * list of common Mackey functors -- a
    list of common Cp-Mackey functors
-------------------------------------------------------------------------------

The source of this document is in
CpMackeyFunctors/Documentation/ApplicationsDoc.m2:52:0.

Ext -- computes Ext of two Cp-Mackey fuctors
********************************************

  * Usage:
        Ext^i(M,N)
  * Inputs:
      * i, an integer (Macaulay2Doc),
      * M, a C_p Mackey Functor,
      * N, a C_p Mackey Functor,
  * Outputs:
      * a C_p Mackey Functor, the $i$th Ext Cp-Mackey
        Functor of $M$ and $N$

Description
===========

Given two Cp-Mackey functors, $M$ and $N$, we can
compute their $i$th Ext.

+----------------------------------------------------+
|i1 : RU = makeComplexRepresentationMackeyFunctor(3);|
+----------------------------------------------------+
|i2 : prune Ext^4(RU,RU)                             |
|                                                    |
|o2 =                     Res : 0                    |
|     cokernel | 3 0 |  -----------> 0  -┐ Conj : 0  |
|                      <-----------     <┘           |
|                         Tr : 0                     |
|                                                    |
|o2 : CpMackeyFunctor                                |
+----------------------------------------------------+

Ways to use Ext:
================

  * "Ext^ZZ(CpMackeyFunctor,CpMackeyFunctor)"
  * "Ext(Ideal,Ideal)" -- see Ext(Module,Module) (Macaulay2Doc),
    -- total Ext module
  * "Ext(Ideal,Module)" -- see Ext(Module,Module) (Macaulay2Doc),
    -- total Ext module
  * "Ext(Ideal,Ring)" -- see Ext(Module,Module) (Macaulay2Doc),
    -- total Ext module
  * "Ext(Module,Ideal)" -- see Ext(Module,Module) (Macaulay2Doc),
    -- total Ext module
  * Ext(Module,Module) (Macaulay2Doc) -- total
    Ext module
  * "Ext(Module,Ring)" -- see Ext(Module,Module) (Macaulay2Doc),
    -- total Ext module
  * "Ext(Ring,Ideal)" -- see Ext(Module,Module) (Macaulay2Doc),
    -- total Ext module
  * "Ext(Ring,Module)" -- see Ext(Module,Module) (Macaulay2Doc),
    -- total Ext module
  * "Ext(Ring,Ring)" -- see Ext(Module,Module) (Macaulay2Doc),
    -- total Ext module
  * "Ext^ZZ(Matrix,Ideal)" -- see Ext^ZZ(Matrix,Module) (Macaulay2Doc),
    -- map between Ext modules
  * Ext^ZZ(Matrix,Module) (Macaulay2Doc), --
    map between Ext modules
  * "Ext^ZZ(Matrix,Ring)" -- see Ext^ZZ(Matrix,Module) (Macaulay2Doc),
    -- map between Ext modules
  * "Ext^ZZ(Ideal,Matrix)" -- see Ext^ZZ(Module,Matrix) (Macaulay2Doc),
    -- map between Ext modules
  * Ext^ZZ(Module,Matrix) (Macaulay2Doc), --
    map between Ext modules
  * "Ext^ZZ(Ring,Matrix)" -- see Ext^ZZ(Module,Matrix) (Macaulay2Doc),
    -- map between Ext modules
  * "Ext^ZZ(Ideal,Ideal)" -- see Ext^ZZ(Module,Module) (Macaulay2Doc),
    -- Ext module
  * "Ext^ZZ(Ideal,Module)" -- see Ext^ZZ(Module,Module) (Macaulay2Doc),
    -- Ext module
  * "Ext^ZZ(Ideal,Ring)" -- see Ext^ZZ(Module,Module) (Macaulay2Doc),
    -- Ext module
  * "Ext^ZZ(Module,Ideal)" -- see Ext^ZZ(Module,Module) (Macaulay2Doc),
    -- Ext module
  * Ext^ZZ(Module,Module) (Macaulay2Doc), --
    Ext module
  * "Ext^ZZ(Module,Ring)" -- see Ext^ZZ(Module,Module) (Macaulay2Doc),
    -- Ext module
  * "Ext^ZZ(Ring,Ideal)" -- see Ext^ZZ(Module,Module) (Macaulay2Doc),
    -- Ext module
  * "Ext^ZZ(Ring,Module)" -- see Ext^ZZ(Module,Module) (Macaulay2Doc),
    -- Ext module
  * "Ext^ZZ(Ring,Ring)" -- see Ext^ZZ(Module,Module) (Macaulay2Doc),
    -- Ext module

For the programmer
==================

The object Ext (Macaulay2Doc), is a scripted functor (Macaulay2Doc).

-------------------------------------------------------------------------------

The source of this document is in
CpMackeyFunctors/Documentation/HomAlgDoc.m2:92:0.

ExtCoh -- computes Ext of two cohomological Cp-Mackey fuctors
*************************************************************

  * Usage:
        Ext(i,M,N)
  * Inputs:
      * i, an integer (Macaulay2Doc),
      * M, a C_p Mackey Functor,
      * N, a C_p Mackey Functor,
  * Outputs:
      * a C_p Mackey Functor, the $i$th cohomological
        Ext Cp-Mackey Functor of $M$ and $N$

Description
===========

Given two cohomological Cp-Mackey functors, $M$ and $N$,
we can compute their $i$th Ext Mackey functor in cohomological Mackey functors.

+-------------------------------------------------+
|i1 : N = cokernel(matrix({{3}}));                |
+-------------------------------------------------+
|i2 : M = makeZeroOnUnderlyingMackeyFunctor (3,N);|
+-------------------------------------------------+
|i3 : prune ExtCoh(3,M,M)                         |
|                                                 |
|o3 =                   Res : 0                   |
|     cokernel | 3 |  -----------> 0  -┐ Conj : 0 |
|                    <-----------     <┘          |
|                       Tr : 0                    |
|                                                 |
|o3 : CpMackeyFunctor                             |
+-------------------------------------------------+

Ways to use ExtCoh:
===================

  * "ExtCoh(ZZ,CpMackeyFunctor,CpMackeyFunctor)"

For the programmer
==================

The object ExtCoh, is a method function (Macaulay2Doc).

-------------------------------------------------------------------------------

The source of this document is in
CpMackeyFunctors/Documentation/HomAlgDoc.m2:92:0.

Fixed -- the fixed module of a Mackey functor
*********************************************

  * Usage:
        M.Fixed

See also
========

  * background on Mackey functors -- a
    brief mathematical intro to the theory of Mackey functors
  * CpMackeyFunctor -- The type of Cp Mackey functors

For the programmer
==================

The object Fixed, is a symbol (Macaulay2Doc).

-------------------------------------------------------------------------------

The source of this document is in
CpMackeyFunctors/Documentation/MackeyFunctorDoc.m2:187:0.

FixedMap -- the fixed-point level of a Mackey functor homomorphism
******************************************************************

  * Usage:
        F.FixedMap

See also
========

  * background on Mackey functors -- a
    brief mathematical intro to the theory of Mackey functors
  * MackeyFunctorHomomorphism -- the class of
    Mackey functor homomorphisms

For the programmer
==================

The object FixedMap, is a symbol (Macaulay2Doc).

-------------------------------------------------------------------------------

The source of this document is in
CpMackeyFunctors/Documentation/HomomorphismsDoc.m2:76:0.

freeResolution(CpMackeyFunctor,ZZ) -- constructs a free Mackey functor resolution of specified length
*****************************************************************************************************

  * Function: freeResolution (Complexes),
  * Usage:
        res(M,n)
  * Inputs:
      * M, a C_p Mackey Functor, a Mackey functor to be
        resolved
      * n, an integer (Macaulay2Doc), length of desired free
        resolution
  * Optional inputs (Macaulay2Doc),:
      * DegreeLimit => ..., default value infinity
      * HardDegreeLimit => ..., default value {}
      * LengthLimit => ..., default value infinity
      * PairLimit => ..., default value infinity
      * ParallelizeByDegree => ..., default value false
      * SortStrategy => ..., default value 0
      * StopBeforeComputation => ..., default value false
      * Strategy => ..., default value null
      * SyzygyLimit => ..., default value infinity
  * Outputs:
      * a list (Macaulay2Doc), a list containing the morphisms in
        the free resolution

Description
===========

This method returns a free resolution of the Mackey functor $M$ up to the $n$th
term.  The resolution is implemented as a list of Mackey functor homomorphisms.

+-----------------------------------------------------------------------------+
|i1 : M = makeZeroOnUnderlyingMackeyFunctor(3,ZZ^1);                          |
+-----------------------------------------------------------------------------+
|i2 : res(M,3)                                                                |
|                                                                             |
|o2 = {        fix : | 1 0 |       ,         fix : | 0 |           ,          |
|        1  <-----------------   2                 | 1 |               1      |
|      ZZ                      ZZ      2  <-------------------   1   ZZ       |
|      ^ |                     ^ |   ZZ                        ZZ    ^ |      |
|      | |                     | |   ^ |                       ^ |   | |      |
|      | v                     | v   | |                       | |   | v      |
|        0  <-----------------   1   | v                       | v     3      |
|      ^ |     und : 0         ZZ      1  <-------------------   3   ZZ       |
|      └-┘                     ^ |   ZZ      und : | 1 1 1 |   ZZ    ^ |      |
|                              └-┘   ^ |                       ^ |   └-┘      |
|                                    └-┘                       └-┘            |
|     ------------------------------------------------------------------------|
|        fix : 0                  ,         fix : | 3 1 3 |         }         |
|     <----------------------   1     1  <---------------------   3           |
|                             ZZ    ZZ                          ZZ            |
|                             ^ |   ^ |                         ^ |           |
|                             | |   | |                         | |           |
|                             | v   | v                         | v           |
|     <----------------------   3     3  <---------------------   4           |
|        und : | -1 0  1  |   ZZ    ZZ      und : | 1 1 1 1 |   ZZ            |
|              | 1  -1 0  |   ^ |   ^ |           | 1 1 1 1 |   ^ |           |
|              | 0  1  -1 |   └-┘   └-┘           | 1 1 1 1 |   └-┘           |
|                                                                             |
|o2 : List                                                                    |
+-----------------------------------------------------------------------------+

Caveat
======

The optional inputs listed on this page are coming from overloading the
resolution (OldChainComplexes), method, and don't have any effect on
computing resolutions for Mackey functors.

See also
========

  * the abelian category of Mackey functors
    -- background on the category of Mackey functors and how
    to code within it
  * resolutionCohomological -- constructs a
    free resolution in cohomological Mackey functors of specified length

Ways to use this method:
========================

  * freeResolution(CpMackeyFunctor,ZZ)
    -- constructs a free Mackey
    functor resolution of specified length
-------------------------------------------------------------------------------

The source of this document is in
CpMackeyFunctors/Documentation/ResolutionsDoc.m2:67:0.

GenBound -- optional input for generating random Mackey functors
****************************************************************

See also
========

  * makeRandomCpMackeyFunctor -- generate a
    random Cp-Mackey functor

Functions with optional argument named GenBound:
================================================

  * "makeRandomCpMackeyFunctor(...,GenBound=>...)" -- see
    makeRandomCpMackeyFunctor, -- generate a random
    Cp-Mackey functor

For the programmer
==================

The object GenBound, is a symbol (Macaulay2Doc).

-------------------------------------------------------------------------------

The source of this document is in
CpMackeyFunctors/Documentation/RandomMackeyFunctorDoc.m2:52:0.

Hom(CpMackeyFunctor,CpMackeyFunctor) -- computes the Hom group between two Cp Mackey functors
*********************************************************************************************

  * Function: Hom (Macaulay2Doc),
  * Usage:
        Hom(M,N)
  * Inputs:
      * M, a C_p Mackey Functor,
      * N, a C_p Mackey Functor,
  * Optional inputs (Macaulay2Doc),:
      * DegreeLimit => ..., default value null
      * MinimalGenerators => ..., default value true
      * Strategy => ..., default value null
  * Outputs:
      * a module (Macaulay2Doc), the abelian group of
        homomorphisms $\text{Hom}_{\text{Mack}_{C_p}}(M,N)$

Description
===========

Given two Mackey functors $M$ and $N$, the set of Mackey functor homomorphisms
from $M$ to $N$ forms an abelian group under pointwise addition.

+--------------------------------------------+
|i1 : M = makeBurnsideMackeyFunctor(2);      |
+--------------------------------------------+
|i2 : N = makeUnderlyingFreeMackeyFunctor(2);|
+--------------------------------------------+
|i3 : Hom(M,N)                               |
|                                            |
|o3 = image | 1 |                            |
|           | 1 |                            |
|           | 1 |                            |
|           | 2 |                            |
|                                            |
|                               4            |
|o3 : ZZ-module, submodule of ZZ             |
+--------------------------------------------+

See also
========

  * the abelian category of Mackey functors
    -- background on the category of Mackey functors and how
    to code within it
  * MackeyFunctorHomomorphism -- the class of
    Mackey functor homomorphisms
  * Hom(CpMackeyFunctor,MackeyFunctorHomomorphism)
    -- computes the
    induced map on Hom groups
  * Hom(MackeyFunctorHomomorphism,CpMackeyFunctor)
    -- computes the
    induced map on Hom groups
  * internalHom -- returns the internal hom Mackey functor
    between two Mackey functors.

Ways to use this method:
========================

  * Hom(CpMackeyFunctor,CpMackeyFunctor)
    -- computes the Hom group
    between two Cp Mackey functors
-------------------------------------------------------------------------------

The source of this document is in
CpMackeyFunctors/Documentation/HomGroupDoc.m2:60:0.

Hom(CpMackeyFunctor,MackeyFunctorHomomorphism) -- computes the induced map on Hom groups
****************************************************************************************

  * Function: Hom (Macaulay2Doc),
  * Usage:
        Hom(M, f)
        Hom(f, N)
  * Inputs:
      * M, a C_p Mackey Functor,
      * f, a Mackey Functor homomorphism,
  * Optional inputs (Macaulay2Doc),:
      * DegreeLimit, => ...,
        default value null, computes the Hom group between two Cp Mackey
        functors
      * MinimalGenerators, =>
        ..., default value true, computes the Hom group between two Cp Mackey
        functors
      * Strategy, => ...,
        default value null, computes the Hom group between two Cp Mackey
        functors
  * Outputs:
      * a matrix (Macaulay2Doc), the induced map on Hom groups
        $\mathrm{Hom}(M,f)$ or $\mathrm{Hom}(f,N)$

Description
===========

$\mathrm{Hom}$ is a functor which is contravariant in the first argument and
covariant in the second argument. This method implements the functoriality on
morphisms.

+--------------------------------------------------+
|i1 : M = makeBurnsideMackeyFunctor(2);            |
+--------------------------------------------------+
|i2 : N = makeUnderlyingFreeMackeyFunctor(2);      |
+--------------------------------------------------+
|i3 : f = makeRandomMackeyFunctorHomomorphism(M,N);|
+--------------------------------------------------+
|i4 : Hom(M,f)                                     |
|                                                  |
|o4 = | 0 8 |                                      |
|                                                  |
|o4 : Matrix                                       |
+--------------------------------------------------+
|i5 : Hom(f,N)                                     |
|                                                  |
|o5 = | 8 8 |                                      |
|                                                  |
|o5 : Matrix                                       |
+--------------------------------------------------+

See also
========

  * the abelian category of Mackey functors
    -- background on the category of Mackey functors and how
    to code within it
  * MackeyFunctorHomomorphism -- the class of
    Mackey functor homomorphisms
  * Hom(CpMackeyFunctor,CpMackeyFunctor)
    -- computes the Hom group
    between two Cp Mackey functors
  * internalHom -- returns the internal hom Mackey functor
    between two Mackey functors.

Ways to use this method:
========================

  * Hom(CpMackeyFunctor,MackeyFunctorHomomorphism)
    -- computes the
    induced map on Hom groups
  * "Hom(MackeyFunctorHomomorphism,CpMackeyFunctor)"
-------------------------------------------------------------------------------

The source of this document is in
CpMackeyFunctors/Documentation/HomGroupDoc.m2:60:0.

inducedMap(CpMackeyFunctor,CpMackeyFunctor) -- tries to induce a natural map between two Mackey functors
********************************************************************************************************

  * Function: inducedMap (Macaulay2Doc),
  * Usage:
        inducedMap(N,M)
        inducedMap(N,M,F)
        inducedMap(N,M,u,f)
  * Inputs:
      * N, a C_p Mackey Functor, target
      * M, a C_p Mackey Functor, source
  * Optional inputs (Macaulay2Doc),:
      * Degree => ..., default value null
      * Verify => ..., default value true
  * Outputs:
      * a Mackey Functor homomorphism, a
        Mackey functor homomorphism from M to N

Description
===========

If a homomorphism is given (either as a MackeyFunctorHomomorphism,
or as a pair of matrices), this method will try to
induce a map between the provided Mackey functors. If no homomorphism is given,
the identity morphism on the source,
is used. A common use for this method to
produce the natural inclusion of a subobject or the natural projection to a
quotient object.

+------------------------------------------------+
|i1 : f := complexLinearizationMap(3);           |
+------------------------------------------------+
|i2 : inducedMap(coker f, target f)              |
|                                                |
|o2 =                     fix : | 0 0 0  |       |
|                               | 0 1 -1 |       |
|                               | 0 0 0  |       |
|     cokernel | 1 1 | <--------------------   3 |
|              | 0 1 |                       ZZ  |
|              | 0 1 |                       ^ | |
|            ^ |                             | | |
|            | |                             | | |
|            | v                             | v |
|       cokernel | 1 | <--------------------   1 |
|            ^ |          und : 0            ZZ  |
|            └-┘                             ^ | |
|                                            └-┘ |
|                                                |
|o2 : MackeyFunctorHomomorphism                  |
+------------------------------------------------+

See also
========

  * MackeyFunctorHomomorphism -- the class of
    Mackey functor homomorphisms
  * inducedMap (Macaulay2Doc) -- compute an induced map

Ways to use this method:
========================

  * inducedMap(CpMackeyFunctor,CpMackeyFunctor)
    -- tries to induce a
    natural map between two Mackey functors
  * "inducedMap(CpMackeyFunctor,CpMackeyFunctor,MackeyFunctorHomomorphism)"
  * "inducedMap(CpMackeyFunctor,CpMackeyFunctor,Matrix,Matrix)"
-------------------------------------------------------------------------------

The source of this document is in
CpMackeyFunctors/Documentation/HomomorphismsDoc.m2:352:0.

internalHom -- returns the internal hom Mackey functor between two Mackey functors.
***********************************************************************************

  * Usage:
        internalHom(N,M)
  * Inputs:
      * M, a C_p Mackey Functor,
      * N, a C_p Mackey Functor,
  * Outputs:
      * a C_p Mackey Functor, the internal hom Mackey
        functor from M to N.

Description
===========

Given any two Mackey functors $M$ and $N$, we can form their internal hom,
which is a Mackey functor which we denote by $\underline{\text{Hom}}(M,N)$. For
example:

+-----------------------------------------------------------------------------+
|i1 : internalHom(makeRealRepresentationMackeyFunctor                         |
|                                                                             |
|o1 =                       Res : | 0 0 -1 |                                  |
|     image | 0  0  -1 |  --------------------> image                         |
|           | -1 1  -1 | <--------------------                                |
|           | 1  0  1  |    Tr : | 4  |                                       |
|           | 0  -1 -1 |         | 2  |                                       |
|           | 1  -1 0  |         | -3 |                                       |
|           | -1 0  -2 |                                                      |
|           | 0  1  0  |                                                      |
|           | 0  0  -1 |                                                      |
|           | 0  0  -1 |                                                      |
|           | 0  0  -1 |                                                      |
|           | 0  0  -2 |                                                      |
|           | 0  0  -2 |                                                      |
|           | 0  0  -2 |                                                      |
|           | 0  0  -1 |                                                      |
|           | 0  0  -1 |                                                      |
|           | 0  0  -1 |                                                      |
|                                                                             |
|                                                                             |
|                                                                             |
|o1 : CpMackeyFunctor                                                         |
|-----------------------------------------------------------------------------|
|3, makeComplexRepresentationMackeyFunctor 3)                                 |
|                                                                             |
|                                                                             |
|| 1 |  -┐ Conj : | 1 |                                                       |
|| 1 |  <┘                                                                    |
|| 1 |                                                                        |
|| 1 |                                                                        |
|| 1 |                                                                        |
|| 1 |                                                                        |
|| 2 |                                                                        |
|| 2 |                                                                        |
|| 2 |                                                                        |
|| 1 |                                                                        |
|| 1 |                                                                        |
|| 1 |                                                                        |
|| 1 |                                                                        |
|| 1 |                                                                        |
|| 1 |                                                                        |
|| 1 |                                                                        |
|| 1 |                                                                        |
|| 1 |                                                                        |
+-----------------------------------------------------------------------------+

The underlying group of homomorphisms,
between any two Mackey functors can
be recovered as the fixed module, key of the internal hom.

See also
========

  * the abelian category of Mackey functors
    -- background on the category of Mackey functors and how
    to code within it
  * boxProduct -- box product of Cp-Mackey functors

Ways to use internalHom:
========================

  * "internalHom(CpMackeyFunctor,CpMackeyFunctor)"
  * internalHom(CpMackeyFunctor,MackeyFunctorHomomorphism)
    -- returns
    the induced map on an internal hom.
  * "internalHom(MackeyFunctorHomomorphism,CpMackeyFunctor)" -- see
    internalHom(CpMackeyFunctor,MackeyFunctorHomomorphism),
    -- returns
    the induced map on an internal hom.

For the programmer
==================

The object internalHom, is a method function (Macaulay2Doc).

-------------------------------------------------------------------------------

The source of this document is in
CpMackeyFunctors/Documentation/InternalHomDoc.m2:26:0.

internalHom(CpMackeyFunctor,MackeyFunctorHomomorphism) -- returns the induced map on an internal hom.
*****************************************************************************************************

  * Function: internalHom,
  * Usage:
        internalHom(F,M)
        internalHom(M,F)
  * Inputs:
      * M, a C_p Mackey Functor,
      * F, a Mackey Functor homomorphism,
  * Outputs:
      * a Mackey Functor homomorphism, the
        induced map on internal hom Mackey functors

Description
===========

The internal hom of Mackey functors is functorial in each variable.  This
method returns the induced maps.

+-----------------------------------------------------------------------------+
|i1 : prune internalHom(makeRealRepresentationMackeyFunctor(3),               |
|                                                                             |
|o1 =         fix : | 1  -2 |                                                 |
|                   | -1 0  |                                                 |
|                   | 0  1  |                                                 |
|       3  <-------------------   2                                           |
|     ZZ                        ZZ                                            |
|     ^ |                       ^ |                                           |
|     | |                       | |                                           |
|     | v                       | v                                           |
|       1  <-------------------   1                                           |
|     ZZ      und : | 1 |       ZZ                                            |
|     ^ |                       ^ |                                           |
|     └-┘                       └-┘                                           |
|                                                                             |
|o1 : MackeyFunctorHomomorphism                                               |
|-----------------------------------------------------------------------------|
|complexLinearizationMap(3))                                                  |
+-----------------------------------------------------------------------------+

See also
========

  * the abelian category of Mackey functors
    -- background on the category of Mackey functors and how
    to code within it
  * internalHom -- returns the internal hom Mackey functor
    between two Mackey functors.

Ways to use this method:
========================

  * internalHom(CpMackeyFunctor,MackeyFunctorHomomorphism)
    -- returns
    the induced map on an internal hom.
  * "internalHom(MackeyFunctorHomomorphism,CpMackeyFunctor)"
-------------------------------------------------------------------------------

The source of this document is in
CpMackeyFunctors/Documentation/InternalHomDoc.m2:51:0.

isCohomological -- checks if a CpMackeyFunctor is cohomological
***************************************************************

  * Usage:
        isCohomological M
  * Inputs:
      * M, a C_p Mackey Functor,
  * Outputs:
      * a Boolean value (Macaulay2Doc), whether $M$ is
        cohomological or not

Description
===========

A Mackey functor $M$ defined over $C_p$ is said to be cohomological if the
composite of restriction followed by transfer is identical to multiplication by
$p$ as a map from the fixed module, of $M$ to itself. We consider
the category of cohomological Mackey functors to be the full subcategory on
cohomological Mackey functors. An important result is the following:

Theorem: [TW95, 16.3] Every cohomological Mackey functor is a module over the
fixed point Mackey functor,
$\underline{\ZZ}$, and every homomorphism,
between cohomological Mackey functors is a $\underline{\ZZ}$-module
homomorphism.

Another way to say this is that the category of cohomological Mackey functors
is the abelian subcategory $\text{Mod}_{\underline{\ZZ}}\subseteq
\text{Mack}_{C_p}$. Carrying out computations (for instance Ext and Tor)
internal to the abelian subcategory $\text{Mod}_{\underline{\ZZ}}$ leads to
what are called cohomological Ext, and cohomological Tor.

References:

  * [TW95] J. Thevenaz & P. Webb, The structure of Mackey functors Trans. Amer.
    Math. Soc., 1995.

See also
========

  * background on Mackey functors -- a
    brief mathematical intro to the theory of Mackey functors
  * CpMackeyFunctor -- The type of Cp Mackey functors

Ways to use isCohomological:
============================

  * "isCohomological(CpMackeyFunctor)"

For the programmer
==================

The object isCohomological, is a method function (Macaulay2Doc).

-------------------------------------------------------------------------------

The source of this document is in
CpMackeyFunctors/Documentation/MackeyFunctorDoc.m2:127:0.

isIsomorphism(MackeyFunctorHomomorphism) -- checks if a Mackey functor homomorphism is an isomorphism
*****************************************************************************************************

  * Function: isIsomorphism (Macaulay2Doc),
  * Usage:
        isIsomorphism F
  * Inputs:
      * F, a Mackey Functor homomorphism,
  * Outputs:
      * a Boolean value (Macaulay2Doc), whether $F$ is an
        isomorphism

Description
===========

Checks whether a Mackey functor homomorphism,
is an isomorphism.

See also
========

  * background on Mackey functors -- a
    brief mathematical intro to the theory of Mackey functors
  * MackeyFunctorHomomorphism -- the class of
    Mackey functor homomorphisms

Ways to use this method:
========================

  * isIsomorphism(MackeyFunctorHomomorphism)
    -- checks if a Mackey functor
    homomorphism is an isomorphism
-------------------------------------------------------------------------------

The source of this document is in
CpMackeyFunctors/Documentation/HomomorphismsDoc.m2:298:0.

isTrivialMackeyFunctor -- checks if a Mackey functor is trivial or not
**********************************************************************

  * Usage:
        isTrivialMackeyFunctor M
  * Inputs:
      * M, a C_p Mackey Functor,
  * Outputs:
      * a Boolean value (Macaulay2Doc), whether $M$ is trivial
        or not

Description
===========

Checks whether $M$ is trivial (meaning isomorphic to the zero Mackey functor).

See also
========

  * background on Mackey functors -- a
    brief mathematical intro to the theory of Mackey functors
  * makeZeroMackeyFunctor -- constructs the zero
    Mackey functor for the group

Ways to use isTrivialMackeyFunctor:
===================================

  * "isTrivialMackeyFunctor(CpMackeyFunctor)"

For the programmer
==================

The object isTrivialMackeyFunctor, is a
method function (Macaulay2Doc).

-------------------------------------------------------------------------------

The source of this document is in
CpMackeyFunctors/Documentation/HomomorphismsDoc.m2:321:0.

kernel(MackeyFunctorHomomorphism) -- kernel of a Mackey functor homomorphism
****************************************************************************

  * Function: kernel (Macaulay2Doc),
  * Usage:
        kernel f
  * Inputs:
      * f, a Mackey Functor homomorphism,
  * Optional inputs (Macaulay2Doc),:
      * DegreeLimit => ..., default value {}
      * Strategy => ..., default value {}
      * SubringLimit => ..., default value infinity
  * Outputs:
      * a C_p Mackey Functor, the kernel of the
        homomorphism f

See also
========

  * the abelian category of Mackey functors
    -- background on the category of Mackey functors and how
    to code within it
  * MackeyFunctorHomomorphism -- the class of
    Mackey functor homomorphisms

Ways to use this method:
========================

  * kernel(MackeyFunctorHomomorphism)
    -- kernel of a Mackey functor
    homomorphism
-------------------------------------------------------------------------------

The source of this document is in
CpMackeyFunctors/Documentation/AbelianCategoryDoc.m2:130:0.

list of common Mackey functors -- a list of common Cp-Mackey functors
*********************************************************************

Here we include a table of common Mackey functors for the group $C_p$. The
Lewis diagrams have to be formatted in \substack in order to compile, apologies
for their appearance.

+------------------+---------------------------------------------------------------------------+-------------------------------------------------------------+-------------------------------------------------------+
|  Ravenel symbol  |  Lewis diagram                                                            |  Description                                                |  Implementation                                       |
+------------------+---------------------------------------------------------------------------+-------------------------------------------------------------+-------------------------------------------------------+
|$\square$         |$$\substack{\ZZ \\ p\uparrow\downarrow 1\\ \ZZ \\ \circlearrowleft \\ 1}$$ |fixed point Mackey functor of $\ZZ$ as a trivial $C_p$-module|makeFixedPointMackeyFunctor(p,id_(ZZ^1))               |
+------------------+---------------------------------------------------------------------------+-------------------------------------------------------------+-------------------------------------------------------+
|$\circ$           |$$\substack{\ZZ/p \\ 0\uparrow\downarrow 0\\ 0 \\ \circlearrowleft \\ 1}$$ |the zero-on-bottom Mackey functor associated to $\ZZ/p$      |makeZeroOnUnderlyingMackeyFunctor(p,coker(matrix{{p}}))|
+------------------+---------------------------------------------------------------------------+-------------------------------------------------------------+-------------------------------------------------------+
|⧄                 |$$\substack{\ZZ \\ 1\uparrow\downarrow p\\ \ZZ \\ \circlearrowleft \\ 1}$$ |the orbit Mackey functor of $\Z$                             |makeOrbitMackeyFunctor(p,id_(ZZ^1))                    |
+------------------+---------------------------------------------------------------------------+-------------------------------------------------------------+-------------------------------------------------------+
|$\ominus^n$       |$$\substack{\ZZ / (q^n-1) \\ 1\uparrow\downarrow \sum_{j=0}^{p-1} q^{nj} \\|the fixed point Mackey functor of the algebraic $K$-group    |makeKGroupMackeyFunctor(p,q,n)                         |
|                  |\ZZ/ (q^{np} - 1) \\ \circlearrowleft \\ q^n}$$                            |$K_{2n-1}(\mathbb{F}_{q^p})$ for a prime power $q$           |                                                       |
+------------------+---------------------------------------------------------------------------+-------------------------------------------------------------+-------------------------------------------------------+
-------------------------------------------------------------------------------

The source of this document is in
CpMackeyFunctors/Documentation/ListOfCommonMFsDoc.m2:17:0.

MackeyFunctorHomomorphism -- the class of Mackey functor homomorphisms
**********************************************************************

Description
===========

The type (Macaulay2Doc), of a Mackey functor homomorphism (for
definitions, see background on Mackey functors).
A Mackey functor homomorphism can be constructed with an
implementation of the map,
method in this
package. Given a Mackey functor homomorphism f, the data for this type can be
accessed in the following way:

  * target f -- yields the codomain/target of the homomorphism. See
    target,
  * source f -- yields the domain/source of the homomorphism. See source,
  * f.UnderlyingMap -- yields the induced homomorphism (Macaulay2Doc),
    on the underlying modules.
    See UnderlyingMap,
  * f.FixedMap -- yields the induced homomorphism (Macaulay2Doc),
    on the fixed modules. See
    FixedMap,

(Warning: the following method makeRandomMackeyFunctorHomomorphism,
takes (source,target) as input, which
follows the Hom (Macaulay2Doc), convention rather than the map (Macaulay2Doc),
convention):

+---------------------------------------------------------------------------+
|i1 : M = makeRandomCpMackeyFunctor(2);                                     |
+---------------------------------------------------------------------------+
|i2 : N = makeRandomCpMackeyFunctor(2);                                     |
+---------------------------------------------------------------------------+
|i3 : f = makeRandomMackeyFunctorHomomorphism(M,N)                          |
|                                                                           |
|o3 =                                   fix : 0                             |
|                    0               <--------------------- cokernel | 6 0 ||
|                   ^ |                                              | 0 0 ||
|                   | |                                            ^ |      |
|                   | |                                            | |      |
|                   | v                                            | v      |
|     cokernel | 2 0 0 0 0 0 0 0 0 | <---------------------   cokernel | 2 ||
|                   ^ |                 und : | 0 1 1 0 |              | 0 ||
|                   └-┘                                                | 0 ||
|                                                                      | 0 ||
|                                                                  ^ |      |
|                                                                  └-┘      |
|                                                                           |
|o3 : MackeyFunctorHomomorphism                                             |
+---------------------------------------------------------------------------+

There are a few ways to build Mackey functor homomorphisms, for example we can
take the identity (Macaulay2Doc), on any Mackey functor

+-------------------------------------------------------------+
|i4 : id_(M)                                                  |
|                                                             |
|o4 =                     fix : | 1 0 |                       |
|                               | 0 1 |                       |
|     cokernel | 6 0 | <--------------------- cokernel | 6 0 ||
|              | 0 0 |                                 | 0 0 ||
|            ^ |                                     ^ |      |
|            | |                                     | |      |
|            | v                                     | v      |
|       cokernel | 2 | <---------------------   cokernel | 2 ||
|                | 0 |    und : | 1 0 0 0 |              | 0 ||
|                | 0 |          | 0 1 0 0 |              | 0 ||
|                | 0 |          | 0 0 1 0 |              | 0 ||
|            ^ |                | 0 0 0 1 |          ^ |      |
|            └-┘                                     └-┘      |
|                                                             |
|o4 : MackeyFunctorHomomorphism                               |
+-------------------------------------------------------------+

The only $0$-ary operation implemented for Mackey functor homomorphisms is:

  * isIsomorphism, checking
    if a morphism is an isomorphism

The unary, binary, and $n$-ary operations are as follows:

  * inversion: if $f$ is an isomorphism,
    we can invert it via f^-1 or
    using inverse(f)
  * negating: we can take the negative of any Mackey functor homomorphism as -f
  * equality (Macaulay2Doc), of two Mackey functors homomorphisms, via
    f==g
  * powers: given an endomorphism of a Mackey functor $f\colon M \to M$ we can
    take iterated composition of it as f^n
  * addition: we can add two Mackey functor homomorphisms with the same domain
    and codomain via f+g
  * subtraction: we can subtract two Mackey functor homomorphisms with the same
    domain and codomain via f-g
  * iterated addition: we can add a Mackey functor homomorphism f with itself n
    times via n*f
  * composition: we can compose two composable Mackey functor homomorphisms via
    g*f
  * block sum: given two Mackey functor homomorphisms $f\colon M_1 \to N_1$ and
    $g\colon M_2 \to N_2$ we can obtain their block sum $f\oplus g \colon M_1
    \oplus M_2 \to N_1 \oplus N_2$ as f++g

See also
========

  * background on Mackey functors -- a
    brief mathematical intro to the theory of Mackey functors
  * CpMackeyFunctor -- The type of Cp Mackey functors

Functions and methods returning a Mackey Functor homomorphism:
==============================================================

  * "boxProduct(CpMackeyFunctor,MackeyFunctorHomomorphism)" -- see
    boxProduct(MackeyFunctorHomomorphism,CpMackeyFunctor),
    -- induced
    maps on box products
  * boxProduct(MackeyFunctorHomomorphism,CpMackeyFunctor)
    -- induced
    maps on box products
  * "complexLinearizationMap(ZZ)" -- see complexLinearizationMap,
    -- returns the complex linearization map for the
    prime p
  * inducedMap(CpMackeyFunctor,CpMackeyFunctor)
    -- tries to induce a
    natural map between two Mackey functors
  * "inducedMap(CpMackeyFunctor,CpMackeyFunctor,MackeyFunctorHomomorphism)" --
    see inducedMap(CpMackeyFunctor,CpMackeyFunctor),
    -- tries to induce a
    natural map between two Mackey functors
  * "inducedMap(CpMackeyFunctor,CpMackeyFunctor,Matrix,Matrix)" -- see
    inducedMap(CpMackeyFunctor,CpMackeyFunctor),
    -- tries to induce a
    natural map between two Mackey functors
  * internalHom(CpMackeyFunctor,MackeyFunctorHomomorphism)
    -- returns
    the induced map on an internal hom.
  * "- MackeyFunctorHomomorphism"
  * "directSum(MackeyFunctorHomomorphism)"
  * "inverse(MackeyFunctorHomomorphism)"
  * "MackeyFunctorHomomorphism + MackeyFunctorHomomorphism"
  * "MackeyFunctorHomomorphism ++ MackeyFunctorHomomorphism"
  * "MackeyFunctorHomomorphism - MackeyFunctorHomomorphism"
  * "MackeyFunctorHomomorphism ^ ZZ"
  * "prune(MackeyFunctorHomomorphism)"
  * "ZZ * MackeyFunctorHomomorphism"
  * MackeyFunctorHomomorphism * MackeyFunctorHomomorphism
    -- composition of
    Mackey functor homomorphisms
  * MackeyFunctorHomomorphism | MackeyFunctorHomomorphism
    -- Horizontal
    concatenation of Mackey functor homomorphisms
  * MackeyFunctorHomomorphism || MackeyFunctorHomomorphism
    -- Vertical
    concatenation of Mackey functor homomorphisms
  * "makeRandomMackeyFunctorHomomorphism(CpMackeyFunctor,CpMackeyFunctor)" --
    see makeRandomMackeyFunctorHomomorphism,
    -- generate a random Cp-Mackey functor
    homomorphism
  * map(CpMackeyFunctor,CpMackeyFunctor,Matrix,Matrix)
    -- constructs
    a map between two Mackey functors
  * map(CpMackeyFunctor,CpMackeyFunctor,ZZ)
    -- constructs the zero map
    between two Mackey functors, or a multiple of the identity map
  * "realLinearizationMap(ZZ)" -- see realLinearizationMap,
    -- returns the real linearization map for the prime p

Methods that use a Mackey Functor homomorphism:
===============================================

  * "CpMackeyFunctor ** MackeyFunctorHomomorphism" -- see
    boxProduct(MackeyFunctorHomomorphism,CpMackeyFunctor),
    -- induced
    maps on box products
  * "CpMackeyFunctor ⊠ MackeyFunctorHomomorphism" -- see
    boxProduct(MackeyFunctorHomomorphism,CpMackeyFunctor),
    -- induced
    maps on box products
  * "MackeyFunctorHomomorphism ** CpMackeyFunctor" -- see
    boxProduct(MackeyFunctorHomomorphism,CpMackeyFunctor),
    -- induced
    maps on box products
  * "MackeyFunctorHomomorphism ⊠ CpMackeyFunctor" -- see
    boxProduct(MackeyFunctorHomomorphism,CpMackeyFunctor),
    -- induced
    maps on box products
  * cokernel(MackeyFunctorHomomorphism)
    -- cokernel of a Mackey functor
    homomorphism
  * degree(MackeyFunctorHomomorphism) (missing documentation)
  * Hom(CpMackeyFunctor,MackeyFunctorHomomorphism)
    -- computes the
    induced map on Hom groups
  * "Hom(MackeyFunctorHomomorphism,CpMackeyFunctor)" -- see
    Hom(CpMackeyFunctor,MackeyFunctorHomomorphism),
    -- computes the
    induced map on Hom groups
  * "internalHom(MackeyFunctorHomomorphism,CpMackeyFunctor)" -- see
    internalHom(CpMackeyFunctor,MackeyFunctorHomomorphism),
    -- returns
    the induced map on an internal hom.
  * isIsomorphism(MackeyFunctorHomomorphism)
    -- checks if a Mackey functor
    homomorphism is an isomorphism
  * kernel(MackeyFunctorHomomorphism)
    -- kernel of a Mackey functor
    homomorphism
  * "MackeyFunctorHomomorphism == MackeyFunctorHomomorphism"
  * "net(MackeyFunctorHomomorphism)"
  * source(MackeyFunctorHomomorphism)
    -- returns the source of a Mackey
    functor homomorphism
  * target(MackeyFunctorHomomorphism)
    -- returns the target of a Mackey
    functor homomorphism

For the programmer
==================

The object MackeyFunctorHomomorphism, is a
type (Macaulay2Doc), with ancestor classes HashTable (Macaulay2Doc),
< Thing (Macaulay2Doc).

-------------------------------------------------------------------------------

The source of this document is in
CpMackeyFunctors/Documentation/HomomorphismsDoc.m2:63:0.

MackeyFunctorHomomorphism * MackeyFunctorHomomorphism -- composition of Mackey functor homomorphisms
****************************************************************************************************

  * Operator: * (Macaulay2Doc),
  * Usage:
        f * g
  * Inputs:
      * f, a Mackey Functor homomorphism,
      * g, a Mackey Functor homomorphism,
  * Outputs:
      * a Mackey Functor homomorphism, the
        composition $f \circ g$

Description
===========

Given two Mackey functor homomorphisms, $f$
and $g$, we can form their composition, which is a new Mackey functor homomorphism.

See also
========

  * background on Mackey functors -- a
    brief mathematical intro to the theory of Mackey functors
  * MackeyFunctorHomomorphism -- the class of
    Mackey functor homomorphisms

Ways to use this method:
========================

  * MackeyFunctorHomomorphism * MackeyFunctorHomomorphism
    -- composition of
    Mackey functor homomorphisms
-------------------------------------------------------------------------------

The source of this document is in
CpMackeyFunctors/Documentation/AbelianCategoryDoc.m2:88:0.

MackeyFunctorHomomorphism | MackeyFunctorHomomorphism -- Horizontal concatenation of Mackey functor homomorphisms
*****************************************************************************************************************

  * Operator: | (Macaulay2Doc),
  * Usage:
        f | g
  * Inputs:
      * f, a Mackey Functor homomorphism,
      * g, a Mackey Functor homomorphism,
  * Outputs:
      * a Mackey Functor homomorphism, the
        horizontal concatenation of the homomorphisms $f$ and $g$.

Description
===========

Given two Mackey functor homomorphisms $f : A \to C$ and $g : B \to C$ with the
same codomain, $f | g$ is the homomorphism $(f,g) : A \oplus B \to C$.

+-------------------------------------+
|i1 : A = makeBurnsideMackeyFunctor 2;|
+-------------------------------------+
|i2 : id_A | id_A                     |
|                                     |
|o2 =         fix : | 1 0 1 0 |       |
|                   | 0 1 0 1 |       |
|       2  <---------------------   4 |
|     ZZ                          ZZ  |
|     ^ |                         ^ | |
|     | |                         | | |
|     | v                         | v |
|       1  <---------------------   2 |
|     ZZ      und : | 1 1 |       ZZ  |
|     ^ |                         ^ | |
|     └-┘                         └-┘ |
|                                     |
|o2 : MackeyFunctorHomomorphism       |
+-------------------------------------+

See also
========

  * MackeyFunctorHomomorphism -- the class of
    Mackey functor homomorphisms
  * MackeyFunctorHomomorphism || MackeyFunctorHomomorphism
    -- Vertical
    concatenation of Mackey functor homomorphisms

Ways to use this method:
========================

  * MackeyFunctorHomomorphism | MackeyFunctorHomomorphism
    -- Horizontal
    concatenation of Mackey functor homomorphisms
-------------------------------------------------------------------------------

The source of this document is in
CpMackeyFunctors/Documentation/HomomorphismsDoc.m2:254:0.

MackeyFunctorHomomorphism || MackeyFunctorHomomorphism -- Vertical concatenation of Mackey functor homomorphisms
****************************************************************************************************************

  * Operator: || (Macaulay2Doc),
  * Usage:
        f || g
  * Inputs:
      * f, a Mackey Functor homomorphism,
      * g, a Mackey Functor homomorphism,
  * Outputs:
      * a Mackey Functor homomorphism, the
        vertical concatenation of the homomorphisms $f$ and $g$.

Description
===========

Given two Mackey functor homomorphisms $f : A \to B$ and $g : A \to C$ with the
same domain, $f || g$ is the homomorphism $(f,g) : A \to B \oplus C$.

+-------------------------------------+
|i1 : A = makeBurnsideMackeyFunctor 2;|
+-------------------------------------+
|i2 : id_A || id_A                    |
|                                     |
|o2 =         fix : | 1 0 |           |
|                   | 0 1 |           |
|                   | 1 0 |           |
|                   | 0 1 |           |
|       4  <-----------------   2     |
|     ZZ                      ZZ      |
|     ^ |                     ^ |     |
|     | |                     | |     |
|     | v                     | v     |
|       2  <-----------------   1     |
|     ZZ      und : | 1 |     ZZ      |
|     ^ |           | 1 |     ^ |     |
|     └-┘                     └-┘     |
|                                     |
|o2 : MackeyFunctorHomomorphism       |
+-------------------------------------+

See also
========

  * MackeyFunctorHomomorphism -- the class of
    Mackey functor homomorphisms
  * MackeyFunctorHomomorphism | MackeyFunctorHomomorphism
    -- Horizontal
    concatenation of Mackey functor homomorphisms

Ways to use this method:
========================

  * MackeyFunctorHomomorphism || MackeyFunctorHomomorphism
    -- Vertical
    concatenation of Mackey functor homomorphisms
-------------------------------------------------------------------------------

The source of this document is in
CpMackeyFunctors/Documentation/HomomorphismsDoc.m2:278:0.

makeBurnsideMackeyFunctor -- constructs the Burnside Mackey functor
*******************************************************************

  * Usage:
        makeBurnsideMackeyFunctor(p)
  * Inputs:
      * p, an integer (Macaulay2Doc), a prime number $p$
  * Outputs:
      * a C_p Mackey Functor, the $C_p$-Mackey functor
        $\underline{A}$

Description
===========

The Burnside Mackey functor of a group $G$ is defined by sending $G/H$ to the
Burnside ring $A(H)$, with transfer and restriction coming from transfer and
restriction of finite $G$-sets. When $G$ is a cyclic group of prime order,
these maps admit a particularly nice form. The underlying module is given by
$\mathbb{Z}$, with trivial conjugation action, while the fixed module is
$\mathbb{Z}\{1,t\}$. Restriction is defined as $$\text{res}_e^{C_p} \colon
\mathbb{Z}\{1,t\} \to \mathbb{Z}$$ by sending $t\mapsto p$. Transfer is of the
form $$\text{tr}_e^{C_p} \colon \mathbb{Z} \to \mathbb{Z}\{1,t\}$$ by sending
$x\mapsto xt$.

+-------------------------------------------------+
|i1 : makeBurnsideMackeyFunctor(5)                |
|                                                 |
|o1 =        Res : | 1 5 |                        |
|       2  ----------------->   1  -┐ Conj : | 1 ||
|     ZZ  <-----------------  ZZ   <┘             |
|            Tr : | 0 |                           |
|                 | 1 |                           |
|                                                 |
|o1 : CpMackeyFunctor                             |
+-------------------------------------------------+

See also
========

  * constructing examples of Mackey functors
    -- info about how to construct explicit Mackey functors

Ways to use makeBurnsideMackeyFunctor:
======================================

  * "makeBurnsideMackeyFunctor(ZZ)"

For the programmer
==================

The object makeBurnsideMackeyFunctor, is a
method function (Macaulay2Doc).

-------------------------------------------------------------------------------

The source of this document is in
CpMackeyFunctors/Documentation/ConstructorsDoc.m2:101:0.

makeComplexRepresentationMackeyFunctor -- constructs the complex representation Mackey functor
**********************************************************************************************

  * Usage:
        makeComplexRepresentationMackeyFunctor(p)
  * Inputs:
      * p, an integer (Macaulay2Doc), a prime number $p$
  * Outputs:
      * a C_p Mackey Functor, the complex
        representation Mackey functor for the group $C_p$.

Description
===========

The complex representation Mackey functor of a group $G$ is defined by sending
$G/H$ to the Grothendieck group of complex $G$-representations. The transfer
and restriction come from induction and restriction of $G$-representations.
When $G$ is a cyclic group of prime order, this admits a nice form. The
underlying module is given by $\ZZ$ with trivial conjugation action, while the
fixed module is $\mathbb{Z}\{\lambda_{0},\lambda_1,\dots,\lambda_{p-1}\}$. The
element $\lambda_i$ represents the one dimensional complex representation given
by multiplication by $e^{2\pi i/p}$. Restriction is defined as",
\[\text{res}_e^{C_p} \colon
\mathbb{Z}\{\lambda_{0},\lambda_1,\dots,\lambda_{p-1}\} \to \mathbb{Z}\] by
sending $\lambda_i\mapsto 1$. The transfer \[\text{tr}_e^{C_p} \colon
\mathbb{Z} \to \mathbb{Z}\{\lambda_{0},\lambda_1,\dots,\lambda_{p-1}\}\] sends
$x\mapsto x\cdot \left(\sum^{p-1}_{0} \lambda_i\right)$.

+-------------------------------------------------------+
|i1 : makeComplexRepresentationMackeyFunctor(5)         |
|                                                       |
|o1 =        Res : | 1 1 1 1 1 |                        |
|       5  ----------------------->   1  -┐ Conj : | 1 ||
|     ZZ  <-----------------------  ZZ   <┘             |
|            Tr : | 1 |                                 |
|                 | 1 |                                 |
|                 | 1 |                                 |
|                 | 1 |                                 |
|                 | 1 |                                 |
|                                                       |
|o1 : CpMackeyFunctor                                   |
+-------------------------------------------------------+

See also
========

  * constructing examples of Mackey functors
    -- info about how to construct explicit Mackey functors
  * makeRealRepresentationMackeyFunctor
    -- constructs the real representation
    Mackey functor

Ways to use makeComplexRepresentationMackeyFunctor:
===================================================

  * "makeComplexRepresentationMackeyFunctor(ZZ)"

For the programmer
==================

The object makeComplexRepresentationMackeyFunctor,
is a method function (Macaulay2Doc).

-------------------------------------------------------------------------------

The source of this document is in
CpMackeyFunctors/Documentation/ConstructorsDoc.m2:233:0.

makeCpMackeyFunctor -- make a Cp Mackey functor
***********************************************

  * Usage:
        makeCpMackeyFunctor(p,R,T,C)
  * Inputs:
      * p, an integer (Macaulay2Doc), a prime number
      * R, a matrix (Macaulay2Doc), a restriction homomorphim
      * T, a matrix (Macaulay2Doc), a transfer homomorphim
      * C, a matrix (Macaulay2Doc), a conjugation homomorphim
  * Outputs:
      * a C_p Mackey Functor,

Description
===========

Builds an instance of the CpMackeyFunctor, type from the
data of a prime number and three matrices, encoding restriction, transfer, and
conjugation, respectively. If assertLevel, is greater than
0, the method will verify whether the input data yields a valid Mackey functor.

See also
========

  * background on Mackey functors -- a
    brief mathematical intro to the theory of Mackey functors
  * CpMackeyFunctor -- The type of Cp Mackey functors

Ways to use makeCpMackeyFunctor:
================================

  * "makeCpMackeyFunctor(ZZ,Matrix,Matrix,Matrix)"

For the programmer
==================

The object makeCpMackeyFunctor, is a method function (Macaulay2Doc).

-------------------------------------------------------------------------------

The source of this document is in
CpMackeyFunctors/Documentation/MackeyFunctorDoc.m2:82:0.

makeFixedPointMackeyFunctor -- constructs the fixed-point Mackey functor of a C_p-module
****************************************************************************************

  * Usage:
        makeFixedPointMackeyFunctor(p,C)
  * Inputs:
      * p, an integer (Macaulay2Doc), a prime number $p$
      * C, a matrix (Macaulay2Doc), an order $p$ automorphism $c$
  * Outputs:
      * a C_p Mackey Functor, the fixed-point Mackey
        functor of the $C_p$-module specified by $\text{c}$.

Description
===========

Given a module $M$ with $C_p$-action specified by an automorphism
$\text{c}\colon M\to M$, there is a naturally associated fixed-point Mackey
functor $\text{FP}(M)$. The underlying module is the module $M$ with
conjugation given by $\text{c}$. The fixed module is the module $M^{C_p}$ of
fixed points of the action, represented as the kernel of $1-\text{c}$. The
restriction is the map $$\text{res}_e^{C_p} \colon M^{C_p} \to M$$ induced by
the inclusion of fixed-points. The transfer is the map $$\text{tr}_e^{C_p}
\colon M\to M^{C_p}$$ given by $1+\text{c}+\text{c}^2+\cdots+\text{c}^{p-1}$.

+-------------------------------------------------------------------+
|i1 : makeFixedPointMackeyFunctor(2,matrix{{0,1,0},{1,0,0},{0,0,1}})|
|                                                                   |
|o1 =                  Res : | 1 0 |                                |
|                            | 1 0 |                                |
|                            | 0 1 |                                |
|     image | 1 0 |  ------------------->   3  -┐ Conj : | 0 1 0 |  |
|           | 1 0 | <-------------------  ZZ   <┘        | 1 0 0 |  |
|           | 0 1 |    Tr : | 1 1 0 |                    | 0 0 1 |  |
|                           | 0 0 2 |                               |
|                                                                   |
|o1 : CpMackeyFunctor                                               |
+-------------------------------------------------------------------+

See also
========

  * constructing examples of Mackey functors
    -- info about how to construct explicit Mackey functors
  * makeOrbitMackeyFunctor -- constructs the
    orbit Mackey functor of a C_p-module

Ways to use makeFixedPointMackeyFunctor:
========================================

  * "makeFixedPointMackeyFunctor(ZZ,Matrix)"

For the programmer
==================

The object makeFixedPointMackeyFunctor, is a
method function (Macaulay2Doc).

-------------------------------------------------------------------------------

The source of this document is in
CpMackeyFunctors/Documentation/ConstructorsDoc.m2:154:0.

makeFixedSignMackeyFunctor -- constructs the fixed-point Mackey functor for the sign action of $C_2$ on $\mathbb{Z}$
********************************************************************************************************************

  * Usage:
        makeFixedSignMackeyFunctor()

Description
===========

+------------------------------------------------+
|i1 : makeFixedSignMackeyFunctor()               |
|                                                |
|o1 =            Res : 0                         |
|     image 0  ----------->   1  -┐ Conj : | -1 ||
|             <-----------  ZZ   <┘              |
|                Tr : 0                          |
|                                                |
|o1 : CpMackeyFunctor                            |
+------------------------------------------------+

See also
========

  * constructing examples of Mackey functors
    -- info about how to construct explicit Mackey functors

Ways to use makeFixedSignMackeyFunctor:
=======================================

  * "makeFixedSignMackeyFunctor(Sequence)"

For the programmer
==================

The object makeFixedSignMackeyFunctor, is a
method function with a single argument (Macaulay2Doc).

-------------------------------------------------------------------------------

The source of this document is in
CpMackeyFunctors/Documentation/ConstructorsDoc.m2:300:0.

makeFixedTrivMackeyFunctor -- constructs the fixed-point Mackey functor for the trivial action of $C_p$ on $\mathbb{Z}/p$
*************************************************************************************************************************

  * Usage:
        makeFixedTrivMackeyFunctor(p)
  * Inputs:
      * p, an integer (Macaulay2Doc), a prime number $p$
  * Outputs:
      * a C_p Mackey Functor, the fixed-point Mackey
        functor for the trivial action of $C_p$ on $\mathbb{Z}/p$

Description
===========

+---------------------------------------------------------------------+
|i1 : makeFixedTrivMackeyFunctor(5)                                   |
|                                                                     |
|o1 =                   Res : | 1 |                                   |
|     cokernel | 5 |  ---------------> cokernel | 5 |  -┐ Conj : | 1 ||
|                    <---------------                  <┘             |
|                       Tr : 0                                        |
|                                                                     |
|o1 : CpMackeyFunctor                                                 |
+---------------------------------------------------------------------+

See also
========

  * constructing examples of Mackey functors
    -- info about how to construct explicit Mackey functors

Ways to use makeFixedTrivMackeyFunctor:
=======================================

  * "makeFixedTrivMackeyFunctor(ZZ)"

For the programmer
==================

The object makeFixedTrivMackeyFunctor, is a
method function (Macaulay2Doc).

-------------------------------------------------------------------------------

The source of this document is in
CpMackeyFunctors/Documentation/ConstructorsDoc.m2:285:0.

makeKGroupMackeyFunctor -- constructs the $K$-group Mackey functor
******************************************************************

  * Usage:
        makeKGroupMackeyFunctor(p,q,n)
  * Inputs:
      * p, an integer (Macaulay2Doc), a prime number $p$
      * q, an integer (Macaulay2Doc), a prime power $q$
      * n, an integer (Macaulay2Doc), a positive integer $n$
  * Outputs:
      * a C_p Mackey Functor, the fixed point
        $C_p$-Mackey functor of the algebraic $K$-group
        $K_{2n-1}(\mathbb{F}_{q^p})$.

Description
===========

+-----------------------------------------------------------------------------+
|i1 : makeKGroupMackeyFunctor(5,9,4)                                          |
|                                                                             |
|o1 =                      Res : | 1853302661441605 |                         |
|     cokernel | 6560 |  ------------------------------> cokernel |           |
|                       <------------------------------                       |
|                          Tr : | 1 |                                         |
|                                                                             |
|o1 : CpMackeyFunctor                                                         |
|-----------------------------------------------------------------------------|
|12157665459056928800 |  -┐ Conj : | 6561 |                                   |
|                        <┘                                                   |
+-----------------------------------------------------------------------------+

See also
========

  * list of common Mackey functors -- a
    list of common Cp-Mackey functors

Ways to use makeKGroupMackeyFunctor:
====================================

  * "makeKGroupMackeyFunctor(ZZ,ZZ,ZZ)"

For the programmer
==================

The object makeKGroupMackeyFunctor, is a
method function (Macaulay2Doc).

-------------------------------------------------------------------------------

The source of this document is in
CpMackeyFunctors/Documentation/ConstructorsDoc.m2:351:0.

makeOrbitMackeyFunctor -- constructs the orbit Mackey functor of a C_p-module
*****************************************************************************

  * Usage:
        makeOrbitMackeyFunctor(p,C)
  * Inputs:
      * p, an integer (Macaulay2Doc), a prime number $p$
      * C, a matrix (Macaulay2Doc), an order $p$ automorphism
        $\text{c}$
  * Outputs:
      * a C_p Mackey Functor, the orbit Mackey functor
        of the $C_p$-module specified by $\text{c}$

Description
===========

Given a module $M$ with $C_p$-action specified by an automorphism
$\text{c}\colon M\to M$, there is a naturally associated orbit Mackey functor
$\text{O}(M)$. The underlying module is the module $M$ with conjugation given
by $\text{c}$. The fixed module is the quotient module $M_{C_p}$ of the action,
represented as the cokernel of $1-\text{c}$. The restriction is the map
$$\text{res}_e^{C_p} \colon M_{C_p} \to M$$ given by
$1+\text{c}+\text{c}^2+\cdots+\text{c}^{p-1}$. The transfer is the map
$$\text{tr}_e^{C_p} \colon M\to M_{C_p}$$ induced by the projection to the
quotient.

+------------------------------------------------------------------------+
|i1 : makeOrbitMackeyFunctor(2,matrix{{0,1,0},{1,0,0},{0,0,1}})          |
|                                                                        |
|o1 =                         Res : | 1 1 0 |                            |
|                                   | 1 1 0 |                            |
|                                   | 0 0 2 |                            |
|     cokernel | 1  -1 0 |  ------------------->   3  -┐ Conj : | 0 1 0 ||
|              | -1 1  0 | <-------------------  ZZ   <┘        | 1 0 0 ||
|              | 0  0  0 |    Tr : | 1 1 0 |                    | 0 0 1 ||
|                                  | 0 0 0 |                             |
|                                  | 0 0 1 |                             |
|                                                                        |
|o1 : CpMackeyFunctor                                                    |
+------------------------------------------------------------------------+

See also
========

  * constructing examples of Mackey functors
    -- info about how to construct explicit Mackey functors
  * makeFixedPointMackeyFunctor, --
    constructs the fixed-point Mackey functor of a C_p-module

Ways to use makeOrbitMackeyFunctor:
===================================

  * "makeOrbitMackeyFunctor(ZZ,Matrix)"

For the programmer
==================

The object makeOrbitMackeyFunctor, is a
method function (Macaulay2Doc).

-------------------------------------------------------------------------------

The source of this document is in
CpMackeyFunctors/Documentation/ConstructorsDoc.m2:181:0.

makeRandomCpMackeyFunctor -- generate a random Cp-Mackey functor
****************************************************************

  * Usage:
        makeRandomCpMackeyFunctor(p)
        makeRandomCpMackeyFunctor(p, {n,m,k,l})
  * Inputs:
      * p, an integer (Macaulay2Doc), a prime number $p$
      * {n,m,k,l}, a list (Macaulay2Doc), a list of four integers,
        where $n$ is the number of underlying generators, $m$ is the number of
        fixed generators, $k$ is the number of underlying relations, and $l$ is
        the number of fixed relations
  * Optional inputs (Macaulay2Doc),:
      * GenBound => ..., default value 5

Description
===========

Generates a Cp-Mackey Functor, $M$ of prime $p$ with at
most GenBound, underlying generators.

See also
========

  * constructing examples of Mackey functors
    -- info about how to construct explicit Mackey functors
  * makeRandomMackeyFunctorHomomorphism
    -- generate a random Cp-Mackey functor
    homomorphism

Ways to use makeRandomCpMackeyFunctor:
======================================

  * "makeRandomCpMackeyFunctor(ZZ)"
  * "makeRandomCpMackeyFunctor(ZZ,List)"

For the programmer
==================

The object makeRandomCpMackeyFunctor, is a
method function with options (Macaulay2Doc).

-------------------------------------------------------------------------------

The source of this document is in
CpMackeyFunctors/Documentation/RandomMackeyFunctorDoc.m2:24:0.

makeRandomMackeyFunctorHomomorphism -- generate a random Cp-Mackey functor homomorphism
***************************************************************************************

  * Usage:
        makeRandomMackeyFunctorHomomorphism(M,N)
  * Inputs:
      * M, a C_p Mackey Functor,
      * N, a C_p Mackey Functor,

Description
===========

Generates a Mackey functor homomorphism, $f$
between two Cp-Mackey Functors, $M$ and $N$ (for the
same prime $p$)

See also
========

  * constructing examples of Mackey functors
    -- info about how to construct explicit Mackey functors
  * makeRandomCpMackeyFunctor -- generate a
    random Cp-Mackey functor

Ways to use makeRandomMackeyFunctorHomomorphism:
================================================

  * "makeRandomMackeyFunctorHomomorphism(CpMackeyFunctor,CpMackeyFunctor)"

For the programmer
==================

The object makeRandomMackeyFunctorHomomorphism,
is a method function (Macaulay2Doc).

-------------------------------------------------------------------------------

The source of this document is in
CpMackeyFunctors/Documentation/RandomMackeyFunctorDoc.m2:43:0.

makeRealRepresentationMackeyFunctor -- constructs the real representation Mackey functor
****************************************************************************************

  * Usage:
        makeRealRepresentationMackeyFunctor(p)
  * Inputs:
      * p, an integer (Macaulay2Doc), a prime number $p$
  * Outputs:
      * a C_p Mackey Functor, the real representation
        Mackey functor for the group $C_p$

Description
===========

The real representation Mackey functor of a group $G$ is defined by sending
$G/H$ to the Grothendieck group of real orthogonal $G$-representations. The
transfer and restriction come from induction and restriction of
$G$-representations. When $G$ is a cyclic group of prime order p, with p odd,
this admits a nice form. The underlying module is given by $\ZZ$ with trivial
conjugation action, while the fixed module is
$\mathbb{Z}\{\lambda_{0},\lambda_1,\dots,\lambda_{(p-1)/2}\}$. The element
$\lambda_i$ for $i>0$ represents the two dimensional real representation given
by rotation by $(2\pi i)/p$ radians. The element $\lambda_0$ represents the
trivial one dimensional representation.  Restriction is defined as
\[\text{res}_e^{C_p} \colon
\mathbb{Z}\{\lambda_{0},\lambda_1,\dots,\lambda_{(p-1)/2}\} \to \mathbb{Z}\] by
sending \[\lambda_i\mapsto \begin{cases} 2 & i>0 \\ 1 & i=0. \end{cases} \]
Transfer is of the form \[\text{tr}_e^{C_p} \colon \mathbb{Z} \to
\mathbb{Z}\{\lambda_{0},\lambda_1,\dots,\lambda_{(p-1)/2}\}\] by sending
$x\mapsto x\cdot \left(\sum^{(p-1)/2}_{0} \lambda_i\right)$.

+---------------------------------------------------+
|i1 : makeRealRepresentationMackeyFunctor(5)        |
|                                                   |
|o1 =        Res : | 1 2 2 |                        |
|       3  ------------------->   1  -┐ Conj : | 1 ||
|     ZZ  <-------------------  ZZ   <┘             |
|            Tr : | 1 |                             |
|                 | 1 |                             |
|                 | 1 |                             |
|                                                   |
|o1 : CpMackeyFunctor                               |
+---------------------------------------------------+

See also
========

  * constructing examples of Mackey functors
    -- info about how to construct explicit Mackey functors
  * makeComplexRepresentationMackeyFunctor
    -- constructs the complex
    representation Mackey functor

Ways to use makeRealRepresentationMackeyFunctor:
================================================

  * "makeRealRepresentationMackeyFunctor(ZZ)"

For the programmer
==================

The object makeRealRepresentationMackeyFunctor,
is a method function (Macaulay2Doc).

-------------------------------------------------------------------------------

The source of this document is in
CpMackeyFunctors/Documentation/ConstructorsDoc.m2:264:0.

makeUnderlyingFreeMackeyFunctor -- constructs the free Mackey functor on an underlying generator
************************************************************************************************

  * Usage:
        makeUnderlyingFreeMackeyFunctor(p)
  * Inputs:
      * p, an integer (Macaulay2Doc), a prime number $p$
  * Outputs:
      * a C_p Mackey Functor, the free Mackey functor
        on an underlying generator

Description
===========

The free $C_p$-Mackey functor on an underlying generator represents the functor
$\text{Mack}_{C_p} \to \text{Ab}$ which sends a Mackey functor $M$ to its
underlying, level $M(C_p/e)$. This means there is a natural
isomorphism $$\text{Hom}_{\text{Mack}_{C_p}}\left(\underline{B},M \right) \cong
M(C_p/e).$$

In components, the underlying, module is the free module on
the $C_p$-set  $C_p/e=\{1,\gamma,\gamma^2,\ldots,\gamma^{p-1}\}$, with
conjugation induced by the $C_p$-action of left multiplication. The
fixed, module is the module $\ZZ$. Restriction is the map
$$\text{res}_e^{C_p} \colon \ZZ \to \ZZ\{1,\gamma,\ldots,\gamma^{p-1}\}$$ by
sending $1\mapsto 1+\gamma+\cdots+\gamma^{p-1}$. The transfer is the map
$$\text{tr}_e^{C_p} \colon \ZZ\{1,\gamma,\ldots,\gamma^{p-1}\} \to \ZZ$$ by
sending $\gamma^i\mapsto 1$ for all $i$.

+---------------------------------------------------------------+
|i1 : makeUnderlyingFreeMackeyFunctor(5)                        |
|                                                               |
|o1 =        Res : | 1 |                                        |
|                  | 1 |                                        |
|                  | 1 |                                        |
|                  | 1 |                                        |
|                  | 1 |                                        |
|       1  ----------------------->   5  -┐ Conj : | 0 0 0 0 1 ||
|     ZZ  <-----------------------  ZZ   <┘        | 1 0 0 0 0 ||
|            Tr : | 1 1 1 1 1 |                    | 0 1 0 0 0 ||
|                                                  | 0 0 1 0 0 ||
|                                                  | 0 0 0 1 0 ||
|                                                               |
|o1 : CpMackeyFunctor                                           |
+---------------------------------------------------------------+

See also
========

  * constructing examples of Mackey functors
    -- info about how to construct explicit Mackey functors
  * makeBurnsideMackeyFunctor -- constructs
    the Burnside Mackey functor

Ways to use makeUnderlyingFreeMackeyFunctor:
============================================

  * "makeUnderlyingFreeMackeyFunctor(ZZ)"

For the programmer
==================

The object makeUnderlyingFreeMackeyFunctor,
is a method function (Macaulay2Doc).

-------------------------------------------------------------------------------

The source of this document is in
CpMackeyFunctors/Documentation/ConstructorsDoc.m2:127:0.

makeZeroMackeyFunctor -- constructs the zero Mackey functor for the group
*************************************************************************

  * Usage:
        makeZeroMackeyFunctor(p)
  * Inputs:
      * p, an integer (Macaulay2Doc), a prime number $p$
  * Outputs:
      * a C_p Mackey Functor, the zero Mackey functor
        for $C_p$

Description
===========

Perhaps the easiest Mackey functor is the zero Mackey functor which has the
zero-module as both the underlying, and fixed,
modules. This is the zero object in the abelian category of Mackey functors,
and is therefore important
to implement for homological algebra computations.

+-----------------------------------+
|i1 : makeZeroMackeyFunctor(2)      |
|                                   |
|o1 =      Res : 0                  |
|     0  -----------> 0  -┐ Conj : 0|
|       <-----------     <┘         |
|          Tr : 0                   |
|                                   |
|o1 : CpMackeyFunctor               |
+-----------------------------------+

See also
========

  * constructing examples of Mackey functors
    -- info about how to construct explicit Mackey functors
  * isTrivialMackeyFunctor -- checks if a Mackey
    functor is trivial or not

Ways to use makeZeroMackeyFunctor:
==================================

  * "makeZeroMackeyFunctor(ZZ)"

For the programmer
==================

The object makeZeroMackeyFunctor, is a
method function (Macaulay2Doc).

-------------------------------------------------------------------------------

The source of this document is in
CpMackeyFunctors/Documentation/ConstructorsDoc.m2:205:0.

makeZeroOnUnderlyingMackeyFunctor -- constructs a Mackey functor which is zero on underlying
********************************************************************************************

  * Usage:
        makeZeroOnUnderlyingMackeyFunctor(p,M)
  * Inputs:
      * p, an integer (Macaulay2Doc), a prime number $p$
      * M, a module (Macaulay2Doc), An abelian group
  * Outputs:
      * a C_p Mackey Functor, A Mackey functor with
        underlying level 0 and fixed level M.

Description
===========

Every abelian group $M$ determines a $C_p$-Mackey functor which is zero on
underlying and $M$ on fixed level.

+----------------------------------------------+
|i1 : makeZeroOnUnderlyingMackeyFunctor(5,ZZ^3)|
|                                              |
|o1 =        Res : 0                           |
|       3  -----------> 0  -┐ Conj : 0         |
|     ZZ  <-----------     <┘                  |
|            Tr : 0                            |
|                                              |
|o1 : CpMackeyFunctor                          |
+----------------------------------------------+

See also
========

  * constructing examples of Mackey functors
    -- info about how to construct explicit Mackey functors

Ways to use makeZeroOnUnderlyingMackeyFunctor:
==============================================

  * "makeZeroOnUnderlyingMackeyFunctor(ZZ,Module)"

For the programmer
==================

The object makeZeroOnUnderlyingMackeyFunctor,
is a method function (Macaulay2Doc).

-------------------------------------------------------------------------------

The source of this document is in
CpMackeyFunctors/Documentation/ConstructorsDoc.m2:326:0.

map(CpMackeyFunctor,CpMackeyFunctor,Matrix,Matrix) -- constructs a map between two Mackey functors
**************************************************************************************************

  * Function: map (Macaulay2Doc),
  * Usage:
        map(N,M,U,F)
  * Inputs:
      * N, a C_p Mackey Functor,
      * M, a C_p Mackey Functor,
      * U, a matrix (Macaulay2Doc),
      * F, a matrix (Macaulay2Doc),
  * Optional inputs (Macaulay2Doc),:
      * Degree => ..., default value null
      * DegreeLift => ..., default value null
      * DegreeMap => ..., default value null
  * Outputs:
      * a Mackey Functor homomorphism, the
        morphism of Mackey functors which is F at the fixed point level and U
        at the underlying level.

Description
===========

A morphisms of $C_p$-Mackey functors consists of a group homomorphism on the
fixed and underlying levels which commutes with the transfer, restriction, and
conjugation morphisms. If assertLevel, is greater than 0,
this method will check if the input data yields a well-defined homomorphism
(and will throw an error if not).

+-----------------------------------------------------------------------------+
|i1 : map(makeComplexRepresentationMackeyFunctor 3, makeBurnsideMackeyFunctor |
|                                                                             |
|o1 =         fix : | 1 1 |                                                   |
|                   | 0 1 |                                                   |
|                   | 0 1 |                                                   |
|       3  <-----------------   2                                             |
|     ZZ                      ZZ                                              |
|     ^ |                     ^ |                                             |
|     | |                     | |                                             |
|     | v                     | v                                             |
|       1  <-----------------   1                                             |
|     ZZ      und : | 1 |     ZZ                                              |
|     ^ |                     ^ |                                             |
|     └-┘                     └-┘                                             |
|                                                                             |
|o1 : MackeyFunctorHomomorphism                                               |
|-----------------------------------------------------------------------------|
|3, matrix {{1}}, matrix {{1,1},{0,1},{0,1}})                                 |
+-----------------------------------------------------------------------------+

See also
========

  * background on Mackey functors -- a
    brief mathematical intro to the theory of Mackey functors
  * MackeyFunctorHomomorphism -- the class of
    Mackey functor homomorphisms

Ways to use this method:
========================

  * map(CpMackeyFunctor,CpMackeyFunctor,Matrix,Matrix)
    -- constructs
    a map between two Mackey functors
-------------------------------------------------------------------------------

The source of this document is in
CpMackeyFunctors/Documentation/HomomorphismsDoc.m2:116:0.

map(CpMackeyFunctor,CpMackeyFunctor,ZZ) -- constructs the zero map between two Mackey functors, or a multiple of the identity map
*********************************************************************************************************************************

  * Function: map (Macaulay2Doc),
  * Usage:
        map(N,M,0)
        map(M,M,n)
  * Inputs:
      * N, a C_p Mackey Functor, target
      * M, a C_p Mackey Functor, source
      * n, an integer (Macaulay2Doc),
  * Optional inputs (Macaulay2Doc),:
      * Degree,
        => ..., default value null, constructs a map between two Mackey
        functors
      * DegreeLift,
        => ..., default value null, constructs a map between two
        Mackey functors
      * DegreeMap,
        => ..., default value null, constructs a map between two
        Mackey functors
  * Outputs:
      * a Mackey Functor homomorphism, the
        map $n*\mathrm{id}$ from M to N, if such a thing exists.

See also
========

  * background on Mackey functors -- a
    brief mathematical intro to the theory of Mackey functors
  * MackeyFunctorHomomorphism -- the class of
    Mackey functor homomorphisms
  * map(CpMackeyFunctor,CpMackeyFunctor,Matrix,Matrix)
    -- constructs
    a map between two Mackey functors

Ways to use this method:
========================

  * map(CpMackeyFunctor,CpMackeyFunctor,ZZ)
    -- constructs the zero map
    between two Mackey functors, or a multiple of the identity map
-------------------------------------------------------------------------------

The source of this document is in
CpMackeyFunctors/Documentation/HomomorphismsDoc.m2:139:0.

PrimeOrder -- the prime order of the group over which a Mackey functor is defined
*********************************************************************************

  * Usage:
        M.PrimeOrder

See also
========

  * background on Mackey functors -- a
    brief mathematical intro to the theory of Mackey functors
  * CpMackeyFunctor -- The type of Cp Mackey functors

For the programmer
==================

The object PrimeOrder, is a symbol (Macaulay2Doc).

-------------------------------------------------------------------------------

The source of this document is in
CpMackeyFunctors/Documentation/MackeyFunctorDoc.m2:163:0.

prune(CpMackeyFunctor) -- prune a CpMackeyFunctor
*************************************************

  * Function: prune (Macaulay2Doc),

Description
===========

Outputs a more user-friendly version of a Mackey functor.

See also
========

  * background on Mackey functors -- a
    brief mathematical intro to the theory of Mackey functors
  * CpMackeyFunctor -- The type of Cp Mackey functors

Ways to use this method:
========================

  * prune(CpMackeyFunctor) -- prune a
    CpMackeyFunctor
-------------------------------------------------------------------------------

The source of this document is in
CpMackeyFunctors/Documentation/MackeyFunctorDoc.m2:95:0.

realLinearizationMap -- returns the real linearization map for the prime p
**************************************************************************

  * Usage:
        realLinearizationMap(p)
  * Inputs:
      * p, an integer (Macaulay2Doc),
  * Outputs:
      * a Mackey Functor homomorphism, the
        linearization map from the Burnside Mackey functor to the real
        representation functor for the prime p.

Description
===========

Every $G$-set $X$ determines a real representation with basis $X$, called the
permutation representation of $X$.  This induces a map from the Burnside Mackey
functor to the real representation Mackey functor called the linearization map.

+---------------------------------+
|i1 : realLinearizationMap(5)     |
|                                 |
|o1 =         fix : | 1 1 |       |
|                   | 0 1 |       |
|                   | 0 1 |       |
|       3  <-----------------   2 |
|     ZZ                      ZZ  |
|     ^ |                     ^ | |
|     | |                     | | |
|     | v                     | v |
|       1  <-----------------   1 |
|     ZZ      und : | 1 |     ZZ  |
|     ^ |                     ^ | |
|     └-┘                     └-┘ |
|                                 |
|o1 : MackeyFunctorHomomorphism   |
+---------------------------------+

See also
========

  * MackeyFunctorHomomorphism -- the class of
    Mackey functor homomorphisms
  * complexLinearizationMap -- returns the
    complex linearization map for the prime p

Ways to use realLinearizationMap:
=================================

  * "realLinearizationMap(ZZ)"

For the programmer
==================

The object realLinearizationMap, is a method function (Macaulay2Doc).

-------------------------------------------------------------------------------

The source of this document is in
CpMackeyFunctors/Documentation/HomomorphismsDoc.m2:230:0.

Res -- the restriction homomorphism in a Mackey functor
*******************************************************

  * Usage:
        M.Res

See also
========

  * background on Mackey functors -- a
    brief mathematical intro to the theory of Mackey functors
  * CpMackeyFunctor -- The type of Cp Mackey functors

For the programmer
==================

The object Res, is a symbol (Macaulay2Doc).

-------------------------------------------------------------------------------

The source of this document is in
CpMackeyFunctors/Documentation/MackeyFunctorDoc.m2:199:0.

resolutionCohomological -- constructs a free resolution in cohomological Mackey functors of specified length
************************************************************************************************************

  * Usage:
        resolutionCohomological(M,n)
  * Inputs:
      * M, a C_p Mackey Functor, a cohomological Mackey
        functor to be resolved
      * n, an integer (Macaulay2Doc), length of desired free
        resolution
  * Outputs:
      * a list (Macaulay2Doc), a list containing the morphisms in
        the free resolution

Description
===========

This method returns a free resolution of a cohomological,
Mackey functor by free cohomological Mackey functors.  The
resolution is implemented as a list of Mackey functor homomorphisms.

+-----------------------------------------------------------------------------+
|i1 : N = cokernel(matrix({{3}}));                                            |
+-----------------------------------------------------------------------------+
|i2 : M = makeZeroOnUnderlyingMackeyFunctor (3,N);                            |
+-----------------------------------------------------------------------------+
|i3 : resolutionCohomological(M,4)                                            |
|                                                                             |
|o3 = {                  fix : | 1 |       ,         fix : | 3 |           ,  |
|      cokernel | 3 | <---------------   1     1  <-------------------   1    |
|            ^ |                       ZZ    ZZ                        ZZ     |
|            | |                       ^ |   ^ |                       ^ |    |
|            | |                       | |   | |                       | |    |
|            | v                       | v   | v                       | v    |
|             0       <---------------   1     1  <-------------------   3    |
|            ^ |         und : 0       ZZ    ZZ      und : | 1 1 1 |   ZZ     |
|            └-┘                       ^ |   ^ |                       ^ |    |
|                                      └-┘   └-┘                       └-┘    |
|                                                                             |
|                                                                             |
|     ------------------------------------------------------------------------|
|             fix : 0                  ,         fix : | 3 1 |           ,    |
|       1  <----------------------   1     1  <---------------------   2      |
|     ZZ                           ZZ    ZZ                          ZZ      2|
|     ^ |                          ^ |   ^ |                         ^ |   ZZ |
|     | |                          | |   | |                         | |   ^ ||
|     | v                          | v   | v                         | v   | ||
|       3  <----------------------   3     3  <---------------------   4   | v|
|     ZZ      und : | -1 0  1  |   ZZ    ZZ      und : | 1 1 1 1 |   ZZ      4|
|     ^ |           | 1  -1 0  |   ^ |   ^ |           | 1 1 1 1 |   ^ |   ZZ |
|     └-┘           | 0  1  -1 |   └-┘   └-┘           | 1 1 1 1 |   └-┘   ^ ||
|                                                                          └-┘|
|                                                                             |
|     ------------------------------------------------------------------------|
|        fix : | -1 |             }                                           |
|              | 3  |                                                         |
|     <----------------------   1                                             |
|                             ZZ                                              |
|                             ^ |                                             |
|                             | |                                             |
|                             | v                                             |
|     <----------------------   3                                             |
|        und : | -1 0  0  |   ZZ                                              |
|              | 0  -1 0  |   ^ |                                             |
|              | 0  0  -1 |   └-┘                                             |
|              | 1  1  1  |                                                   |
|                                                                             |
|o3 : List                                                                    |
+-----------------------------------------------------------------------------+

See also
========

  * the abelian category of Mackey functors
    -- background on the category of Mackey functors and how
    to code within it
  * freeResolution(CpMackeyFunctor,ZZ)
    -- constructs a free Mackey
    functor resolution of specified length

Ways to use resolutionCohomological:
====================================

  * "resolutionCohomological(CpMackeyFunctor,ZZ)"

For the programmer
==================

The object resolutionCohomological, is a
method function (Macaulay2Doc).

-------------------------------------------------------------------------------

The source of this document is in
CpMackeyFunctors/Documentation/ResolutionsDoc.m2:67:0.

source(MackeyFunctorHomomorphism) -- returns the source of a Mackey functor homomorphism
****************************************************************************************

  * Function: source (Macaulay2Doc),
  * Usage:
        source(F)
  * Inputs:
      * F, a Mackey Functor homomorphism,
  * Outputs:
      * a C_p Mackey Functor, the source of the
        homomorphism F.

Description
===========

A homomorphism between Mackey functors has a source and a target. This method
returns the source.

+-------------------------------------------------+
|i1 : source(complexLinearizationMap(5))          |
|                                                 |
|o1 =        Res : | 1 5 |                        |
|       2  ----------------->   1  -┐ Conj : | 1 ||
|     ZZ  <-----------------  ZZ   <┘             |
|            Tr : | 0 |                           |
|                 | 1 |                           |
|                                                 |
|o1 : CpMackeyFunctor                             |
+-------------------------------------------------+

See also
========

  * background on Mackey functors -- a
    brief mathematical intro to the theory of Mackey functors
  * MackeyFunctorHomomorphism -- the class of
    Mackey functor homomorphisms

Ways to use this method:
========================

  * source(MackeyFunctorHomomorphism)
    -- returns the source of a Mackey
    functor homomorphism
-------------------------------------------------------------------------------

The source of this document is in
CpMackeyFunctors/Documentation/HomomorphismsDoc.m2:162:0.

target(MackeyFunctorHomomorphism) -- returns the target of a Mackey functor homomorphism
****************************************************************************************

  * Function: target (Macaulay2Doc),
  * Usage:
        target(F)
  * Inputs:
      * F, a Mackey Functor homomorphism,
  * Outputs:
      * a C_p Mackey Functor, the target of the
        homomorphism F.

Description
===========

A homomorphism between Mackey functors has a source and a target. This method
returns the target.

+-------------------------------------------------------+
|i1 : target(complexLinearizationMap(5))                |
|                                                       |
|o1 =        Res : | 1 1 1 1 1 |                        |
|       5  ----------------------->   1  -┐ Conj : | 1 ||
|     ZZ  <-----------------------  ZZ   <┘             |
|            Tr : | 1 |                                 |
|                 | 1 |                                 |
|                 | 1 |                                 |
|                 | 1 |                                 |
|                 | 1 |                                 |
|                                                       |
|o1 : CpMackeyFunctor                                   |
+-------------------------------------------------------+

See also
========

  * background on Mackey functors -- a
    brief mathematical intro to the theory of Mackey functors
  * MackeyFunctorHomomorphism -- the class of
    Mackey functor homomorphisms

Ways to use this method:
========================

  * target(MackeyFunctorHomomorphism)
    -- returns the target of a Mackey
    functor homomorphism
-------------------------------------------------------------------------------

The source of this document is in
CpMackeyFunctors/Documentation/HomomorphismsDoc.m2:184:0.

the abelian category of Mackey functors -- background on the category of Mackey functors and how to code within it
******************************************************************************************************************

The category of Mackey functors: Fixing a finite group $G$ (always cyclic of
prime order in this package), we obtain a category $\text{Mack}_G$, whose
objects are Mackey functors, and whose morphisms are
Mackey functor homomorphisms. Given any
Mackey functor $M$ we can take its identity homomorphism as follows:

+-----------------------------------------------------------+
|i1 : M = makeRandomCpMackeyFunctor(3,GenBound=>2);         |
+-----------------------------------------------------------+
|i2 : id_M                                                  |
|                                                           |
|o2 =                       fix : | 1 |                     |
|     cokernel | 6 0 0 | <--------------- cokernel | 6 0 0 ||
|             ^ |                                 ^ |       |
|             | |                                 | |       |
|             | v                                 | v       |
|     cokernel | 126 0 | <--------------- cokernel | 126 0 ||
|             ^ |           und : | 1 |           ^ |       |
|             └-┘                                 └-┘       |
|                                                           |
|o2 : MackeyFunctorHomomorphism                             |
+-----------------------------------------------------------+

See Composition,  of
Mackey functor homomorphisms is done exactly the same as for composition of
maps. If $f\colon M \to N$ and $g \colon N \to Q$ are two Mackey functor
homomorphisms, their composite $g\circ f \colon M \to Q$ can be accessed as
g*f.

The abelian category structure: Given any two Mackey functors $M$ and $N$, we
can form the set $\text{Hom}_{\text{Mack}_G}(M,N)$ of homomorphisms from $M$ to
$N$. Since we can add, any two homomorphisms,
we have that $\text{Hom}_{\text{Mack}_G}(M,N)$ is really an abelian group of homomorphisms.
Composition is
moreover $\ZZ$-linear, hence we can say that the category $\text{Mack}_G$ is
pre-additive.

+-----------------------------------------------------------------------------+
|i3 : Hom(makeRandomCpMackeyFunctor(2,GenBound=>2),makeRandomCpMackeyFunctor(2|
|                                                                             |
|o3 = 0                                                                       |
|                                                                             |
|o3 : ZZ-module                                                               |
|-----------------------------------------------------------------------------|
|,GenBound=>2))                                                               |
+-----------------------------------------------------------------------------+
|i4 : prune oo                                                                |
|                                                                             |
|o4 = 0                                                                       |
|                                                                             |
|o4 : ZZ-module                                                               |
+-----------------------------------------------------------------------------+

Given any two Mackey functors, we can take their direct sum (Macaulay2Doc),
and obtain another Mackey functor. This is a finite
biproduct on the category $\text{Mack}_G$, in other words it is both a product
and a coproduct. There is a zero object for this biproduct, namely the
zero Mackey functor. This gives $\text{Mack}_G$ what is
often called a semiadditive structure.

Moreover, any Mackey functor homomorphism admits a kernel,
and a cokernel.
All this data we've collected so far
is often called a pre-abelian structure. Finally, one can prove that images and
coimages agree, hence $\text{Mack}_G$ is an abelian category.

Enough projectives: The category $\text{Mack}_{G}$ has exactly two projective
objects, which we denote by $\underline{A}$ and $\underline{B}$. These are the
Burnside Mackey functor, and the
underlying free Mackey functor, respectively.
The category $\text{Mack}_G$ has enough projectives, meaning in particular that
we can take projective resolutions in order to compute ext and tor groups.

Free resolutions: Given any Mackey functor we can take its free resolution. The
projective dimension of an object of $\text{Mack}_G$ is generally infinite, so
we cannot provide all of the data of a resolution -- nevertheless we can
provide a computation that holds in a range. This is accomplished using the
freeResolution (Complexes), (aka freeResolution (Complexes))
method, which inputs a Mackey functor $M$ and an
integer $n$, and outputs a free resolution of the form \[M \leftarrow F_0
\leftarrow F_1 \leftarrow \cdots \leftarrow F_n\]

+--------------------------------------------------------+
|i5 : M = prune makeRandomCpMackeyFunctor(3,GenBound=>2);|
+--------------------------------------------------------+
|i6 : class res(M,2)                                     |
|                                                        |
|o6 = List                                               |
|                                                        |
|o6 : Type                                               |
+--------------------------------------------------------+
|i7 : length resolution(M,2)                             |
|                                                        |
|o7 = 3                                                  |
+--------------------------------------------------------+

In the notation above, the element res(M,2) will be a list (Macaulay2Doc),
of differentials $(M \leftarrow F_0, F_0 \leftarrow F_1,
F_1 \leftarrow F_2)$, where each entry in the list is a Mackey functor homomorphism.

When a resolution is computed, this is cached (Macaulay2Doc), in
the Mackey functor itself, and can be accessed as M.ProjRes. This makes
computations less costly, and moreover the cache helps us expand resolutions.
For instance if we have already computed res(M,10) and want to compute
res(M,20), it will access the cached 10-term resolution to shorten the
computation for the 20-term resolution.

The monoidal structure: The category $\text{Mack}_G$ furthermore has a
symmetric monoidal structure, given by the box product, of
two Mackey functors. Taking the box product admits a right adjoint, in other
words there is an internal hom, which is a functor

\[\underline{\text{Hom}} \colon \text{Mack}_G^{\text{op}} \times \text{Mack}_G
\to \text{Mack}_G,\]

whose fixed point module, is the abelian group of homomorphisms,
from $M$ to $N$. The
category $\text{Mack}_G$ is closed symmetric monoidal, meaning the internal hom
and box product fit together into a natural isomorphism of abelian groups,
natural in any three Mackey functors $M$, $N$, and $P$:
\[\text{Hom}_{\text{Mack}_G}(M \square N, P) \cong
\text{Hom}_{\text{Mack}_G}(M, \underline{\text{Hom}}(N,P)).\]

Ext and Tor: With free resolutions in mind, we can define internal ext,
and tor, groups as the derived functors of the internal hom and
box product, respectively:

\[\underline{\text{Ext}}^i(-,M):= \mathbf{R}^i
\underline{\text{Hom}}_{\text{Mack}_G}(-,M),\]

\[\underline{\text{Tor}}^i(-,M) := \mathbf{L}_i (- \square M).\]

These are internal incarnations of $\text{Ext}$ and $\text{Tor}$. We can
recover the abelian groups $\text{Ext}^i(M,N)$ and $\text{Tor}_i(M,N)$ as the
fixed point module, of the internal Ext and Tor.

See also
========

  * background on Mackey functors -- a
    brief mathematical intro to the theory of Mackey functors
  * constructing examples of Mackey functors
    -- info about how to construct explicit Mackey functors
  * list of common Mackey functors -- a
    list of common Cp-Mackey functors
  * explicit applications of the CpMackeyFunctors package
    -- info about how this
    package can be applied to real-life examples
-------------------------------------------------------------------------------

The source of this document is in
CpMackeyFunctors/Documentation/AbelianCategoryDoc.m2:67:0.

Tor -- computes Tor of two Cp-Mackey fuctors
********************************************

  * Usage:
        Tor_i(M,N)
  * Inputs:
      * i, an integer (Macaulay2Doc),
      * M, a C_p Mackey Functor,
      * N, a C_p Mackey Functor,
  * Outputs:
      * a C_p Mackey Functor, the $i$th Tor Cp-Mackey
        Functor of $M$ and $N$

Description
===========

Given two Cp-Mackey functors, $M$ and $N$, we can
compute their $i$th Tor.

+----------------------------------------------------------------------+
|i1 : RU = makeComplexRepresentationMackeyFunctor(3);                  |
+----------------------------------------------------------------------+
|i2 : prune Tor_3(RU,RU)                                               |
|                                                                      |
|o2 =                                         Res : 0                  |
|     cokernel | 3 0 0 0 0 0 0 0 0 0 0 0 |  -----------> 0  -┐ Conj : 0|
|                                          <-----------     <┘         |
|                                             Tr : 0                   |
|                                                                      |
|o2 : CpMackeyFunctor                                                  |
+----------------------------------------------------------------------+

Ways to use Tor:
================

  * "Tor_ZZ(CpMackeyFunctor,CpMackeyFunctor)"
  * "Tor_ZZ(Ideal,Ideal)" -- see Tor_ZZ(Module,Module) (Macaulay2Doc),
    -- compute a Tor module
  * "Tor_ZZ(Ideal,Module)" -- see Tor_ZZ(Module,Module) (Macaulay2Doc),
    -- compute a Tor module
  * "Tor_ZZ(Ideal,Ring)" -- see Tor_ZZ(Module,Module) (Macaulay2Doc),
    -- compute a Tor module
  * "Tor_ZZ(Module,Ideal)" -- see Tor_ZZ(Module,Module) (Macaulay2Doc),
    -- compute a Tor module
  * Tor_ZZ(Module,Module) (Macaulay2Doc),
    -- compute a Tor module
  * "Tor_ZZ(Module,Ring)" -- see Tor_ZZ(Module,Module) (Macaulay2Doc),
    -- compute a Tor module
  * "Tor_ZZ(Ring,Ideal)" -- see Tor_ZZ(Module,Module) (Macaulay2Doc),
    -- compute a Tor module
  * "Tor_ZZ(Ring,Module)" -- see Tor_ZZ(Module,Module) (Macaulay2Doc),
    -- compute a Tor module
  * "Tor_ZZ(Ring,Ring)" -- see Tor_ZZ(Module,Module) (Macaulay2Doc),
    -- compute a Tor module

For the programmer
==================

The object Tor (Macaulay2Doc), is a scripted functor (Macaulay2Doc).

-------------------------------------------------------------------------------

The source of this document is in
CpMackeyFunctors/Documentation/HomAlgDoc.m2:46:0.

TorCoh -- computes Tor of two cohomological Cp-Mackey fuctors
*************************************************************

  * Usage:
        TorCoh(i,M,N)
  * Inputs:
      * i, an integer (Macaulay2Doc),
      * M, a C_p Mackey Functor,
      * N, a C_p Mackey Functor,
  * Outputs:
      * a C_p Mackey Functor, the $i$th cohomological
        Tor Cp-Mackey Functor of $M$ and $N$

Description
===========

Given two cohomological Cp-Mackey functors, $M$ and $N$,
we can compute their $i$th Tor in the category of cohomological Mackey
functors.

+----------------------------------------------------------+
|i1 : N = cokernel(matrix({{3}}));                         |
+----------------------------------------------------------+
|i2 : M = makeZeroOnUnderlyingMackeyFunctor (3,N);         |
+----------------------------------------------------------+
|i3 : prune TorCoh(3,M,M)                                  |
|                                                          |
|o3 =                             Res : 0                  |
|     cokernel | 3 0 0 0 0 0 |  -----------> 0  -┐ Conj : 0|
|                              <-----------     <┘         |
|                                 Tr : 0                   |
|                                                          |
|o3 : CpMackeyFunctor                                      |
+----------------------------------------------------------+

Ways to use TorCoh:
===================

  * "TorCoh(ZZ,CpMackeyFunctor,CpMackeyFunctor)"

For the programmer
==================

The object TorCoh, is a method function (Macaulay2Doc).

-------------------------------------------------------------------------------

The source of this document is in
CpMackeyFunctors/Documentation/HomAlgDoc.m2:46:0.

Trans -- the transfer homomorphism in a Mackey functor
******************************************************

  * Usage:
        M.Trans

See also
========

  * background on Mackey functors -- a
    brief mathematical intro to the theory of Mackey functors
  * CpMackeyFunctor -- The type of Cp Mackey functors

For the programmer
==================

The object Trans, is a symbol (Macaulay2Doc).

-------------------------------------------------------------------------------

The source of this document is in
CpMackeyFunctors/Documentation/MackeyFunctorDoc.m2:211:0.

Underlying -- the underlying module of a Mackey functor
*******************************************************

  * Usage:
        M.Underlying

See also
========

  * background on Mackey functors -- a
    brief mathematical intro to the theory of Mackey functors
  * CpMackeyFunctor -- The type of Cp Mackey functors

For the programmer
==================

The object Underlying, is a symbol (Macaulay2Doc).

-------------------------------------------------------------------------------

The source of this document is in
CpMackeyFunctors/Documentation/MackeyFunctorDoc.m2:175:0.

UnderlyingMap -- the underlying level of a Mackey functor homomorphism
**********************************************************************

  * Usage:
        F.UnderlyingMap

See also
========

  * background on Mackey functors -- a
    brief mathematical intro to the theory of Mackey functors
  * MackeyFunctorHomomorphism -- the class of
    Mackey functor homomorphisms

For the programmer
==================

The object UnderlyingMap, is a symbol (Macaulay2Doc).

-------------------------------------------------------------------------------

The source of this document is in
CpMackeyFunctors/Documentation/HomomorphismsDoc.m2:88:0.