Let X be a scheme and let U be an open subscheme. The scheme theoretic closure of U in X is the smallest closed subscheme Z of X such that j : U —> X factors through Z. We say that U is scheme theoretically dense in X if the scheme theoretic closure of U ∩ V in V equals V for every open V of X. See Definition Tag 01RB. Then U is scheme theoretically dense in X if and only if O_X —> j_*O_U to be injective, see Lemma Tag 01RE.

If X is locally Noetherian, then U is scheme theoretically dense in X if and only if U is dense in X and contains all embedded points of X (Lemma Tag 083P).

For general schemes the situation isn’t as nice. For example, there exists a scheme with 1 point but no associated point (Lemma Tag 05AI). As a replacement for associated points, we sometimes use weakly associated primes (Definition Tag 0547) and the corresponding notion for schemes. This notion agrees with associated point for locally Noetherian schemes. There are enough weakly associated points: if U contains all the weakly associated points, then U is scheme theoretically dense (result not yet in the stacks project). But in some sense there are too many: there is an example of a scheme theoretically dense open subscheme U of a scheme X which does not contain all weakly associated points of X (Section Tag 084J).

We have the following result from Raynaud-Gruson: If X —> Y is an etale morphism and x ∈ X with image y ∈ Y then x is a weakly associated point of X if and only if y is a weakly associated point of Y (Lemma Tag 05FP).

What about scheme theoretic density? Given an etale morphism of schemes g : X’ —> X and a scheme theoretically dense open U ⊂ X the inverse image g^{-1}U is a scheme theoretically dense in X’ (Lemma Tag 0832). This was added recently in order to show that scheme theoretic density defined as above (and as in EGA IV 11.10.2) makes sense in the setting of algebraic spaces.

If you have trouble falling asleep tonight, try proving some of the results above.

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 073Z points to Definition 8.2.1
• Tag 0740 points to Definition 8.2.2
• Tag 0741 points to Definition 8.2.3
• Tag 0742 points to Definition 8.2.4
• Tag 0743 points to Definition 8.2.5
• Tag 0744 points to Section 8.3: Wedderburn’s theorem
• Tag 0745 points to Lemma 8.3.1
• Tag 0746 points to Lemma 8.3.2
• Tag 0747 points to Theorem 8.3.3
• 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

http://stacks.math.columbia.edu/chapter/n

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.

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?

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!

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 stacks.math.columbia.edu. 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!

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 github.com. 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.

So the server (at paard.math.columbia.edu) 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://github.com/stacks/stacks-project.git

or if that doesn’t work please try

git clone https://github.com/stacks/stacks-project.git

If you were previously tracking the repository at paard.math.columbia.edu, 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 paard.math.columbia.edu. 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?

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.

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?

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.