I'm taking my first steps in the language of stacks, and would like something cleared up. The intuitive idea of moduli spaces is that each point corresponds to an object of what we're trying to classify (smooth curves of genus g over ℂ, for example). Fine moduli spaces are defined to be the objects that represent the functor that takes an object and gives you the [set, for schemes; groupoid, as I understand it, for stacks] of ways that that object parametrizes families of the object we want to classify. Now, for schemes - this makes sense in the following way:
Let that functor be F, and let it be represented by M. Then F(Spec ℂ) are the families of (desired) objects parametrized by Spec ℂ (a point), so it corresponds to all desired objects (the ones we want to classify). But F(Spec ℂ) is also Hom(Spec ℂ, M), and so corresponds to the closed points of M. Thus M really does, intuitively, have as points the objects it wishes to classify.
Does this idea go through to moduli stacks? Of course, it probably does, and this is all probably trivial - but I feel like I need someone to assure me that I'm not crazy. So let me put the question like this: Can you formulate how to think of a fine moduli stack (as an object that represents an F as above; also: how would you define this F in the category of stacks?) in a way that makes it clear that it parametrizes the desired objects?







Different interpretations of moduli stacks
I'll assure you that you're not crazy. Not only does the idea go through for stacks, but it's impossible (or at least very hard) to make sense of stacks without that idea.


If you're trying to parameterize wigits, you can build a functor F(T)={flat families of wigits over T}. If there is a space M that deserves to be called the moduli space of wigits, it should represent F. It's not just that the points of M must correspond to isomorphism classes of wigits, so we must have F(Spec ℂ)=Hom(Spec ℂ,M). The points are also connected up in the right way. For example, a family of widits over a curve should correspond to a choice of wigit for every point in the curve in a continuous way, so it should correspond to a morphism from the curve to M.


It happens that if wigits have automorphisms, there's no hope of finding a geometric object M so that maps to M are the same thing as flat (read "continuous") families of wigits. The reason is that any geometric object should have the property that maps to it can be determined locally. That is, if U and V cover T, specifying a map from T to M is the same as specifying maps from U and V to M which agree on U∩V. The jargon for this is "representable functors are sheaves." If a wigit X has an automorphism, then you can imagine a family of wigits over a circle so that all the fibers are X, but as you move around the circle, it gets "twisted" by the automorphism (if you want to think purely algebro-geometrically, use a circular chain of ℙ1s instead of a circle). Locally, you have a trivial family of wigits, so the map should correspond to a constant map to the moduli space M, but that would correspond to the trivial family globally, which this isn't. Oh dear!


Instead of giving up hope entirely, the trick is to replace the functor F by a "groupoid-valued functor" (fibered category), so the automorphisms of objects are recorded. Now of course there won't be a space representing F, since any space represents a set-valued functor, but it turns out that this sometimes revives the hope that F is represented by some mythical "geometric object" M in the sense that objects in F(T) (which should correspond to maps to M) can be determined locally. If this is true, we say that "F is a *stack*" or that "M is a *stack*." Part of what makes your question tricky is that as things get stacky, the line between M and F becomes more blurred. M isn't really anything other than F. We just call it M and treat it as a geometric object because it satisfies this gluing condition. We usually want M to be more geometric than that; we want it to have a cover (in some precise sense) by an honest space. If it does, then we say "M (or F) is an *algebraic* stack" and it turns out you can do real geometry on it.


