Tree view

Pieter Belmans introduced tree view pages to the Stacks project. For example the tree view for Chapter 8: Brauer groups (link and click expand) looks like this:

  • Tag 073X points to Section 8.1: Introduction
  • Tag 073Y points to Section 8.2: Noncommutative algebras
  • Tag 0744 points to Section 8.3: Wedderburn’s theorem
  • and so on

This tree view shows in particular that we have tags for sections, and it allows you to quickly find those tags. The tree view of chapter n is at

The depth of the trees is at the moment at most 3. Since we don’t allow nested environments in the stacks project (exception: equations), I think the maximal depth we can ever get is 5.

The tree view hints at browsing the stacks project online. When eventually mathjax (or whatever will be the next math rendering tool) matures enough to have good support for xypic (and better font size handling), we’ll go and actually set this up.

Searching the Stacks project

In the post I will discuss some features of the full text search we have available in the Stacks project website.

Basic usage: Just type in some keywords and hit return.

Notational convention: |search&*^term| means you typed exactly “search&*^term” into the search bar and hit return.

  1. By default search looks for what you typed case insensitive in statements of lemmas, propositions, theorems, remarks, equations, examples, and situations.
  2. It looks for words exactly how you typed them. So |stack| does not find occurrences of “stacks”. The solution is to put a wildcard at the end |stack*|.
  3. Non-alphanumeric characters have special meaning, so try to avoid them. For example |quasi-compact| searches for statements which include the word “quasi” but do not have the word “compact”.
  4. Using double quotes is special: For example |”quasi-compact”| will find statements including the hyphenated word “quasi-compact”.
  5. If you check the box “Include proofs” it will also look in proofs.
  6. If you check the box “Include sections”, then it will look in the text of sections, as well as the statements as above. This will return duplicate results, but if you did not have success with searching in statements this can be useful.

Advanced usage: There are other things you can do. I haven’t figured out all of them yet, and I’ll document more here over time. Leave a comment if you found a useful feature I haven’t mentioned. Here it goes (with more useful searches listed first):

  1. The OR operator works: |”smooth morphism” OR “etale morphism”| will search for statemens containing either “smooth morphism” or “etale morphism”.
  2. There is an AND operator which you can combine with the OR operator: |Noetherian AND “ring map” OR “etale morphism”|.
  3. Precedence of set operators: “-“, “OR”, “AND”.
  4. There is a NEAR operator: |locally NEAR/0 finite| and |locally NEAR/1 finite|. This finds occurrences of “locally” and “finite” 0 respectively 1 words apart in either order. You can also combine this with a wildcard, so |locally NEAR/1 finite*| finds both “locally of finite” and “locally finitely” which is useful.
  5. Try |”\text{.*}”| or |”\label{.*}”|. This works, but I don’t know why. Do you?
  6. Double quotes work across lines: |”ordinal whose cofinality”| finds a proposition whose statement has “ordinal” on one line and “whose cofinality” on the second.
  7. Wildcards do not work at the beginning of words.

Of course, I should go and read the documentation. And so should you!

Conclusion. Search is a very useful tool to quickly find results containing some given keywords.

However the Stacks project is a text written by humans and not computer generated. Thus it doesn’t contain all possible true statements… Example: suppose you wanted to find the result “a finite morphism is separated” or “a finite morphism is universally closed”. The obvious searches wouldn’t find these. Namely, the first is in the text directly following the definition of a finite morphism, in Section Tag 01WG. The second is an immediate consequence of either Lemma Tag 01WM or Lemma Tag 01WN.

This brings up a whole other topic, namely, to what extend we should add lemmas stating formal consequences of previous lemmas. This turns out to be quite useful, especially for results earlier in the Stacks project. What do you think?

Comments and the Stacks project

As discussed here the new Stacks project website allows you to leave comments. In this blog post I’d like to advertise this as a fun activity and as well discuss what kind of comments I’d like to encourage. Before we start a disclaimer:

Comments are not part of the Stacks project. When you leave a comment, it is just a comment and nothing else. Don’t worry about correctness, etc. It is just a hope that occasionally comments will be useful and the material will find its way back into the Stacks project, but we’ll see.

Comments pointing out mistakes: Perhaps the most obvious way to use the comment system to this is that it is real easy to point out mistakes. For example I just left two comments pointing out silly mistakes. While reading the Stacks project in pdf form, if you encounter a mistake no matter how silly, just click on the embedded link to the tags’s page in the pdf and leave a comment. Any misspellings, typos, latex bloopers, mathematical mistakes (of course there aren’t any!), etc are very welcome.

Comments giving references: Another type of comments would be one where you leave references to papers, books, mimiographed notes, and whatnot that contain results similar to the one contained in the tag. Here are two examples.

Historical comments: Part of the idea of the comments system was to have people put in comments like: “This result was first shown in 1966 by so and so.”

Sign-off: Another idea for the comment system was to have mathematicians sign-off on some of the results: “I solemnly declare this mathematical result to be correct”.

Typographical comments: You are very welcome to leave typographical comments. Usually these are easy to implement. However, there are a lot of peculiarities in the LaTeX coding which I for better or worse decided on when first introducing certain symbols and mathematical notation. We eventually have to drastically improve the handling of these in the Stacks project, and Pieter Belmans and I have some ideas about how to proceed. I’ll discuss this in a future blog post.

Comments on how to improve exposition and results: I’d love to hear your suggestions on how to improve the Stacks project.

If you’ve read this far, then I’m sure you see what I’m trying to say. But to give some impetus I am going to challenge you to find mistakes:

T-shirts for mathematical errors: If you leave a comment pointing out an actual mathematical error in a statement or a proof of a lemma, proposition, theorem, or a mistake in the text of a section or remark, then I will send you a Stacks project T-shirt while supplies last (currently I have 1 large and 3 medium T-shirts — I’ll update this until I reach zero). Make sure to leave a working email address so I can reach you to get your address.

Happy hunting!

A new website

Please visit the new website for the stacks project. It was written from scratch by Pieter Belmans. Huge thanks to Pieter for all the hard work he has done!

There is a lot more functionality on the site now than there was with the old version:

  1. You can search the stacks project. The default is to search for multiple keywords in statements of lemmas, propositions, etc. (Note that you need to explicitly add a wildcard to search for different endings of words — as explained on the site.)
  2. You can leave comments on each and every result of the stacks project. For the moment feel free to leave any comments you like; in the future I’ll lay some ground rules for what kind of comments are useful, what to avoid and so on.
  3. You can “browse” the project online. What this means will be clear only by doing it. So I suggest you start with the chapter on morphisms of schemes and go from there.

I’ll talk more about this in forthcoming blog posts, but for now I am just going to enjoy the fact that it is all there. Enjoy!

The new website is located at We’ve set things up so that the links pointing to the old version are redirected to the new website.

A final word. In some sense the new website is a beta version. We’ve done testing (thanks to all testers here) and we’ve found lots of bugs, but there may be some left. Please let us know if you find any problems with the site. You can leave a comment to this blog post, email me, or email the general stacks project email address. Thanks!

Fork it!

This post assumes you are somewhat familiar with version control systems. But, it is entirely possible to contribute to the stacks project without knowing what such a thing is at all. So this post is aimed at people who’d like to experiment with version control, git, etc.

So with the move to github it becomes easier for you to do things.

Recall that git is a distributed version control system. This means that anytime you clone the stacks project repository (as explained here) your local version is an exact copy of the stacks project. When you work on it you are literally working on the stacks project. After you’ve made some changes you ask the maintainer of the stacks project (that would be me right now) to incorporate this into the online version. The documentation for the stacks project suggests to email patches to the maintainer.

Now there is another way to proceed: You can fork the project on github.

The procedure for doing this is roughly as follows. Get an account on This is ridiculously easy to do. Log in. Then just fork the stacks-project. Instead of cloning the stacks project, you clone the fork you just made (as explained on the github page above). Edit you local copy. Push your changes back into the fork. Now your work is visible to the world! Finally, if you like, you can make a pull request to have your changes incorporated back into the official stacks project.

In fact, it is so easy to do this, I can imagine creating a clone for every single change; after you’re all done just delete the fork.

Stacks project on github

So the server (at I was using for the logs (via gitweb) as well as for the git repostory of the stacks project finally died an hour ago. It served me faithfully for about 8 years which isn’t bad.

So I decided to move the git repository to github. You can find it here at github. You can find the logs there too. It is kind of disconcerting how easy it is to set this up. It literally took me 1 minute to do. The new way to pull in the stacks project using git is

git clone git://

or if that doesn’t work please try

git clone

If you were previously tracking the repository at, then you can edit .git/config and point it at either address above, or just wipe out the directory and issue one of the two commands above. Please let me know if there are any issues with this.

It will take me some time to adjust some of the links on the blog and in the stacks project itself, but I wanted to let you know what was up now.

Edit: OK, I now removed most of the links to In particular I went back and edited all the posts on the blog linking to paard for 2011 and 2012. Unfortunately the repository viewer on github isn’t as good as the gitweb viewer we used to have on paard (in my opinion). Anyway is no substitute for clone the project onto you own machine, right?

An example

Let k = F_2. Let A = ∏_n k, i.e., the product of copies of F_2 indexed by the integers. Today, I am going to make a local ring R with a nonzerodivisor t in the maximal ideal such that R[1/t] is isomorphic to k((t)) ⊗_k A.

Namely, choose a basis B of A as a k-vector space such that some element b_0 ∈ B corresponds to 1 in A. Thus every element of A can be uniquely written as a finite sum of elements of B without repetitions. In particular, given b, b’ ∈ B we can write bb’ = ∑_{b” ∈ C(b, b’)} b” for a finite subset C(b, b’) of B. Then A has the presentation A = k[b]/(b_0 – 1, bb’ – ∑_{b” ∈ C(b, b’)} b”). Consider the ring

R = k[[t]][x_b]/(x_{b_0} – t, x_bx_{b’} – t ∑_{b” ∈ C(b, b’)} x_{b”})

If we invert t then we can replace x_b by x_b/t and we get a presentation of k((t)) ⊗_k A. I claim that t is a nonzero divisor in R. To show this you show that {x_b} is a basis of the quotient ring over k[[t]] (this takes a bit of work). Observe that the quotient of R by t is the ring k[x_b]/(x_{b_0}, x_bx_{b’}) whose spectrum is a singleton. A bit more work shows every prime ideal of R is contained in the ideal (t, x_b) which implies that R is local.

Let I_{fin} ⊂ A be the ideal of elements of A = ∏_n k consisting of sequences (a_n) such that all but a finite number of a_n are zero. Note that A/I_{fin} is a flat A-module as I_{fin} is generated by idempotents (every element of A is an idempotent). Let I be the unique radical ideal of R such that I[1/t] = k((t)) ⊗_k I_{fin} via the isomorphism above. Then we see that M = R/I is an R-module which is flat over the principal open U defined by t.

I constructed M to illustrate Raynaud-Gruson 5.2.2: Namely, with X = S = Spec(R) and U the open given above there is no finite type blow-up of S such that the strict transform of M becomes flat. The theorem only applies when M restricted to U is of finite presentation; an assumption which our M fails.

My reasoning is as follows. Note that the zero set of I_{fin} is nowhere dense in Spec(A). Hence also V(I) ∩ U is nowhere dense in U because U is homeomorphic to Spec(A). But if the strict transform of M becomes flat on some finite type blow up X’ of Spec(R), then M gets rank 1 over a connected component of the exceptional fibre of X’ —> X. I think this implies that M has rank 1 over a nonempty open of U as well. I haven’t check all the details so I could be wrong… let me know if so! Also, an easier example would be appreciated as well.

Hilbert Skeem

So in the near future I want to write a bit more about Hilbert schemes in the stacks project. Now it feels a bit wrong to say “Hilbert space” for the… uh… Hilbert space of an algebraic space. My promethean colleague Davesh Maulik suggests using “Hilbert skeem” so that typographically at least we make the reader aware that the… uh… Hilbert skeem may not be a scheme. What do you think?

A correction

This is about example 4 from this post. It turns out that you can repair what I said there to make it work. The mistake was pointed out by David Rydh in the comments of that post. Thanks for Bhargav Bhatt for explaning how to repair it. Any mistakes are mine (please tell me if there are any).

Let X be an algebraic space over a base S (not necessarily flat). Consider diagrams

Y ---> X
|      |
v      v
T ---> S

where f : Y —> T is proper and flat. In this situation let C’ ∈ D(Y) be the cone of the map

L_{X/S} ⊗ O_Y —> L_{Y/T}.

Then I claim there is a canonical map C’ —> f^*L_{T/S}[1] which controls the deformation theory of the diagram (i.e., we look at first order thickenings T’ of T over S and flat deformations of Y to T’ mapping into S).

This is much better than the original suggestion in the post but it works for the same reason and the obstruction group doesn’t depend on the thickening T’ only on the ideal I defining T in T’.

The “real” reason this works is the following observation: We can think of the cone C’ as the cotangent complex of Y over the derived base change of X to T. Hence it is clear that EXt(C’, f^*I) computes obstructions, infinitesimal deformations, infinitesimal automorphisms of the morphism of Y into the derived base change. But since Y is a usual scheme and flat over T any (flat) deformation of Y to T’ is still a usual scheme, and morphisms from a usual scheme to a derived scheme map through pi_0(the derived scheme).

Jason Starr has privately emailed me something similar for the Quot scheme, which I haven’t fully understood yet.


Since the last update we have added the following material:

  1. results on limits of algebraic spaces (including results on quasi-coherent modules),
  2. results on coherent modules on locally Noetherian algebraic spaces, see
    Section Tag 07U9 and Section Tag 07UI,
  3. devissage of coherent modules on Noetherian algebraic spaces, see Section Tag 07UN
  4. a decent singleton algebraic space is a scheme (Lemma Tag 047Z),
  5. a qc + qs algebraic space such that H^1 is zero on any quasi-coherent module is an affine scheme (Proposition Tag 07V6),
  6. if X —> Y is a surjective integral morphism, X is an affine scheme, and Y an algebraic space, then Y is an affine scheme (as far as I know this result is due to David Rydh), see Proposition Tag 07VT,
  7. the previous result in particular implies that if an algebraic space has a reduction which is a scheme then it is a scheme (you can find this in a paper by Conrad, Lieblich, and Olsson). This allowed us to significantly improve the exposition on thickenings of algebraic spaces which leads into the next item,
  8. pushouts of algebraic spaces, see Section Tag 07SW,
  9. this is applied to get a very general version of the Rim-Schlessinger condition for algebraic stacks, see Section Tag 07WM,
  10. a section about what happens with deformation theory when you have a finite extension of residue fields (possibly inseparable), see Section Tag 07WW,
  11. a (partial) solution to question 04PZ thanks to Philipp Hartwig, see Lemma Tag 07VM,
  12. a bunch more stuff in the chapter on Artin’s Axioms including an approach to checking openness of versality which works exactly as explained here and here.

A short term goal is now to apply the results of the chapter on Artin’s Axioms to show that some natural moduli problems (in restricted generality) are representable by algebraic stacks or algebraic spaces. For example: Picard stacks, moduli of curves, moduli of canonically polarized smooth projective varieties, Hilbert schemes/spaces, Quot schemes/spaces, etc.

A longer term goal would be to get the most general results of this type, for example the stack (of flat families) of finite covers of P^n (this is a made up example). For the longer term goal I see no way around working with the full cotangent complex (and not the naive one). Do you?

[Edit July 5, 2012: Jason Starr points out that in his preprint on “Artin’s Axioms” in Remark 4.5 he proves the stack mentioned above is an algebraic stack without using the full cotangent complex.]