I actually wanted to write an introductory note on the basic Gromov–Witten invariant
counting the number of rational curves passing through
points in a general position, and how the recursive formula
![]()
is obtained (the main reference is the classic Fulton–Pandharipande). But yes, again, I haven’t sufficiently understood the objects there, and my advisor also suggested me to try to work with stacks instead of coarse moduli spaces as schemes, so in this post I’ll try to build the notion of a stack from ground up. My main reference is Stacks for Everybody by Fantechi, and I studied Grothendieck topology from Wikipedia.
Why Stacks? And what are Moduli Spaces?
I’m not really qualified to say much about the motivation, since I haven’t really learned much about moduli spaces, but let me give an attempt.
A moduli functor is a functor
.
For a scheme
, we define the functor
by sending object
to
and sending morphism
to function
defined by
.
A moduli functor
is representable if there exists
such that
(natural isomorphism of functors). In such case we say
is a fine moduli space for
.
The motivation of introducing moduli spaces is the attempt to classify geometric objects up to isomorphism. For example, we may want to parametrize the lines in
passing through the origin. In this case,
is the moduli space of such lines. We may want to parametrize the curves of degree
in
, obtaining the Chow variety
, etc. These basic objects forming some kind of a configuration space are the basic building blocks. But now we ask further: can the configuration space be viewed as an algebro-geometric object as well? For natural problems with direct solutions, we can grab this object (and it turns out to be a scheme) and we’re done. But for some other problems, there seems to be some obstruction to the existence of such an algebro-geometric object describing the configuration space.
Moreover, oftentimes we’re not directly interested in working with the configuration spaces, but we’re more interested in working with a family of objects in the configuration space, parametrized by another object. That is, perhaps we’re interested in a family
of objects
, parametrized by
. The way we formalize this is that the collection
should correspond to a morphism
sending
to
. In this sense, we want to say that “family of objects in
parametrized by
” should be
, and this is why we defined
that way.
Now, the problem is there is no such scheme
representing the configuration space. This happens particularly when there are nontrivial automorphisms of objects we’re interested in, and so we give up the ideal dream of getting a fine moduli space and step back a bit, getting a coarse moduli space instead. Instead of trying to grab
so that
, we look for a pair
with
being a natural transformation of functors, such that:
(a) The pair is initial among other possible pairs, that is, if
is another pair, then there exists a unique natural transformation
such that this commutes:

(b) The natural transformation
induces a bijection on
, i.e.,
is a bijection.
This is how we accept losing some data and study the coarse moduli spaces as schemes in their own rights. This works, in some sense, but since this loses the precision, my advisor suggested me to work with stacks instead, so now I’ll be introducing the notion of a stack and consider how it fits into the theory of moduli spaces.
Grothendieck Topologies
The Development of Topology
In the beginning (Bachelor Year 1), I was taught about topology in
in this way (if I remember correctly):
- The open sets are sets
such that for all
there exists some
such that
. - The closed sets are sets
such that for all sequences
in
, if it has a limit
, then
. - The compact sets are sets
such that for all sequences
in
, there exists a subsequence which converges to some limit in
.
And when I grew up a bit (Bachelor Year 2), they taught us the topology of finite dimensional normed vector spaces: for a
-vector space
with norm
(
or
), there is the notion of open balls:
, closed balls, and so on, etc, etc. The open sets are the sets that all points inside them admit an open ball contained in the set. The closed sets are the sets whose complement is an open set. Compact sets are still defined by sequential compactness in the above sense, but then we quickly show the Heine–Borel theorem and established the equivalence in terms of closed and bounded set.
And then (Bachelor Year 3), we began the general point-set topology. For a set
, a topology
on
is a collection of subsets of
, i.e.
, such that the following axioms are satisfied:
.- For an arbitrary collection
where each
is in
, the union
is also in
. - For a finite collection
where each
is in
, the intersection
is also in
.
The elements of
are called open sets. Closed sets are those whose complement is open. Compactness is defined by the “open covers has a finite subcover” definition. And so on.
This general point-set topology works surprisingly well even in later courses during my Master’s studies. It defined a sufficient and elegant ground towards more sophisticated definitions of manifolds (in differential geometry), Zariski topology (in algebraic geometry), weak topologies (in functional analysis), and others. I learned a bit more (in Master Year 2) about the Hausdorff axiom, and the local compactness property, and these are already pretty useful enough to work with other things in representation theory and in Lie groups.
Presheaves and Sheaves
Things start to get a bit more complicated (and at the same time, easier), when we look at the category
whose objects are the open subsets (i.e.
) and the morphisms are inclusions (i.e.
, where
is the inclusion of sets). I don’t know how other people call this category, but here I’d call it
for a topological space
.
In this way, a presheaf of
on
is a functor
.
A sheaf is then a presheaf
that satisfies the sheaf gluing axiom:
For all collection
of objects from
, and for all collection
where
for each
, suppose for all
,
, then, defining
, there exists a unique
such that for each
,
.
This is intuitively clear when we talk in differential geometric terms and see explicit examples. Of course, in practice, we write
instead of
. Some people use another syntax for restriction, which I like it very much: write
for
.
Now, a Grothendieck topology is a generalization in place of
. We work with a category
, and think of it as “the category of open sets”, but now we don’t require the three topological axioms above (see what I wrote on Bachelor Year 3), and we instead focus on characterizing the notion of an open cover. Usually, we say that a collection
of items in
is an open cover of
if
. In Grothendieck topologies this notion is relaxed, and this allows the definition of other kinds of topologies, such as the étale topology or the Nisnevich topology, apart from the usual Zariski topology. We begin this by looking at sieves.
Sieves
Let
be a category. Let
be an object. A sieve on
is a functor
such that
- For all
,
. - For all morphisms
in
,
is the restriction of the usual pullback
to
. Equivalently, this means the following diagram commutes:

This may sound like some abstract nonsense, but it has an intuitive interpretation in the case
. A sieve
on
assigns each
with a subset of
. If
then sure, there exists one morphism from
to
, namely the inclusion
. If
then there is no morphism from
to
, so the sieve must send
to
(there is no choice to be made here). In this sense, the sieve
is bitmasking each open subset of
whether we will collect it or not. Now, this implies that this bitmasking must be downward-closed, i.e., if
and
is enabled, then
must also be enabled as well. Why? Using the morphism
![]()
we can pass these into
to get
![]()
Since
is nonempty, and
is a morphism of sets (i.e. function
), we can grab the only element of
and push it through
to land somewhere in
, by definition, and then this means
is nonempty, i.e.,
is enabled.
In this sense, reinterpreting in the original category
, a sieve on
is nothing but a downward-closed collection of open subsets of
.
Covering Sieves
The main idea of a Grothendieck topology is (roughly) to assign a criterion to check whether a collection
is a special kind of collection (called “covering family” of
) or not. We first go through the construction using sieves, and we try to define whether a sieve is a covering sieve or not. Formally, for a category
, a Grothendieck topology is a collection
where
is a collection of sieves on
, subject to some additional axioms. The sieves in
are called covering sieves on
. The axioms that we require are the following:
- (Base change) Let
. If
, and
, then
, where
is the pullback sieve of
by
(it is what you think it is). - (Local character) Let
. Let
. Let
be any sieve on
. Suppose for all
and all
in
the pullback sieve
is in
, then
. - (Identity) For each
, the functor
, which forms a sieve, is in
.
Once such axioms hold, we say that
is a Grothendieck topology on
. The pair
is called a site.
Now, suppose we have a collection
of morphisms in
going into
, its corresponding sieve on
is defined as
. This sieve is called the sieve generated by
, and we say that the family
is a covering family (with respect to
) whenever the sieve generated by itself is a covering sieve (with respect to
).
Categories over Categories
Let
be our base category. A category
over
is a (covariant) functor
. I will often write this situation as
.
We define what it means to be a category fibered in groupoids. Basically we recall the following commutative diagram, where
;
, and
.

A pullback (or a fiber product) for this diagram is a completion of the diagram above to the top-left (i.e. it is a pair
with
and
which makes the following diagram commutes and that
)

such that it is final in the following sense, for any
with
and any
with
, there exists a unique morphism
such that
.
Such pullback may or may not exist (I don’t know!). But we can require that it exists and is unique up to unique isomorphism. We give this condition precisely in the following definition.
Definition. A category
is said to be fibered in groupoids over
if for any
in
and for any
in
, there exists a pullback
and this pullback is unique up to unique isomorphism, that is, if
is another pullback, then there exists a unique isomorphism
with
such that
. This situation looks (in a sense) like the following diagram.

Informally, this fibered in groupoids condition tells us that it “pulls back like bundles”.
Since such pullback is essentially unique (i.e. unique up to unique isomorphism), for each
and each
in
we may write such pullback
as
whenever
is clear from context.
Descent (i.e. Gluing)
What does it mean to glue things? Informally, for objects
and
(imagine, say, two sheets of paper), to glue
to
roughly means:
- Paste the glue on a part
of
. - Paste the glue on a part
of
. - Place the part
directly on
in some way, i.e., find an isomorphism
and let the two parts stick together. - The resulting object is
.

![]()

How about when there are multiple objects? Suppose we have a collection of objects
, and we wish to glue them together. To do so, we must prescribe how object
glues with object
, that is, for each pair
we must prescribe a part
of
, a part
of
, and an isomorphism
.
Furthermore, the prescription must satisfies the following conditions in order for it to make sense:
and
for all
(and so we can discard the data of
entirely, i.e., just prescribe
and
).
and
on
, for each
.
And then the glued space is ![]()
The main idea of the second condition is the cocycle condition which is stated generally as
. The gluing mechanism above is a helpful tool to define varieties obtained by gluing affine varieties.
We now go back to our situation of a category fibered in groupoids
and proceed similarly about gluing objects. Suppose a Grothendieck topology
is prescribed on
and is fixed throughout the situation. We also assume that the category
admits fiber products.
Definition (Descent data). A descent datum for
over
consists of the following data:
- A covering family
in
(with respect to
). - A collection
of objects in
such that for each
,
. - A collection of isomorphisms
such that
for each
and such that this collection satisfies the cocycle condition
over
, where we define
as the fiber product, and
similarly.
We say that a descent datum is effective if it glues successfully, i.e., if there exists
such that
together with isomorphisms
, each morphism
mapping to
by
, such that
for each
.
Isomorphisms being a sheaf
At this point everyone knows what is a sheaf. But now we can talk about our situation of a category fibered in groupoids
and talk about objects
of
over the same fiber
, i.e.
. Suppose we partially know that
is isomorphic over each piece
, and we also know that the pieces
‘s cover
, then the sheaf property is precisely that this glues to a unique isomorphism
over
. We give a formulation in the following.
Definition (Isomorphisms are a sheaf). Let
be a category fibered in groupoids and let
be a Grothendieck topology for
. We say that isomorphisms are a sheaf for
if, for any
and any
with
, for any covering family
with respect to
, and for every collection of isomorphisms
with
for each
, such that
, there exists a unique isomorphism
in
with
such that
for each
.
Now we’re ready to define a stack (finally!!!).
Definition (Stack). A stack is a category fibered in groupoids
with a Grothendieck topology
on
such that isomorphisms are a sheaf and every descent datum is effective.
Moduli Stacks
If we have two categories
and
, then it makes sense to talk about morphisms between them. A morphism from
to
is a (covariant) functor
commuting with the projections, i.e. making the following diagram commutes (both on objects and on morphisms):

An isomorphism is a morphism that is also an equivalence of categories.
This allows us to fix
and
, and consider the category of stacks over
with respect to
. I’ll denote this category by
.
Now we can revisit the notion of a moduli functor, which is a functor
.
Recall that we defined
as
, and we looked for
so that a specified
is naturally isomorphic to
.
Now, we change the definition of a moduli functor (in order to remember the forgotten information during passing into coarse moduli spaces) to be a functor
.
We can now define the notion of a moduli stack. A stack
is said to be a moduli stack for
if
(natural isomorphism), where the functor
is defined by
where the stack
is the category described by:
(i.e. it is what you think it is…)
For reinterpreting “the set of morphisms” into “the groupoid of morphisms”, we define the groupoid to be the category whose objects are the morphisms, and morphisms between objects are 2-morphisms. This is a bit vague and I don’t have enough mastery to get into the details, but the intuition is that in this way the automorphisms and information we usually “forget” when seeing
as a set is retained when we see it as a groupoid.
Oftentimes, even if we fail to construct a fine moduli space, we can still construct a moduli stack to represent our moduli functor we’re interested in. I’m still a pure beginner in this topic, and so tomorrow (and beyond) I’ll start attempting to interpret
in terms of stacks and I’ll keep this blog updated whenever I progress learning about stable maps and quantum cohomology!
Comments