 This lecture is part of an online course on commutative algebra and will be about stock-wise locally free modules. This is a somewhat technical topic. So they're closely related to other sorts of modules. We have locally free modules that we talked about a couple of lectures ago and we have projective modules. And we have stock-wise locally free modules. And projective modules are sort of bracketed between locally free modules and stock-wise locally free modules. So all three of these sorts of modules are the same for finitely presented modules. And in a previous lecture, we discussed the relation between locally free modules and projective modules. And what we're going to concentrate on this lecture is the relation between projective modules and stock-wise locally free modules. So first of all, we'll give an example of a stock-wise locally free module that isn't projective. So for this one, we just take the ring R to be the integers and we take the module to be all numbers a over b with b square free. Then you can easily check that for any prime in the spectrum of z, we have m localised at the prime is just isomorphic to z localised at the prime. So you can think of all stalks of m are one-dimensional free modules. However, m is obviously not projective or free over the integers, projective modules are the same as free modules and m obviously isn't a free module. This gives a counter example to one of the attempts to define invertible modules. So we say module m is invertible if m is locally free of rank one. And this example shows that you can't replace locally free with the concept stock-wise locally free because this module m is stock-wise locally free of rank one, but it's not free but it's not locally free of rank one. Well this module m is not finitely generated. So you might think that maybe for finitely generated modules stock-wise locally free modules might be projective. So the next example shows that this fails too. So for this example you recall that we had this ring r which was functions from x to z modulo 2z where x was some infinite set and we had the ideal i which was functions of finite support and i was an example of an ideal or rather a module which was projective but not locally free which we discussed one or two lectures ago. Instead of the module i we're now going to take the module m to be r over i and we're going to show this is stock-wise locally free but not projective. It's also finitely generated in fact it's generated by one element but not finitely presented because the ideal i is not finitely generated. Now to see that all the stalks are free we notice that any localization rp is isomorphic to z modulo 2z and this is because r and r over p is boolean which means x squared equals x for all x. Now if you've got a boolean ring that's local this implies the ring is just z modulo 2z because if it's local then any element not in the maximal ideal must be a unit so as its square is equal to itself it must be either one or zero and it can't be zero so it must be one so one is the only element not in the maximal ideal which means that the ring is just c over 2z so this means that all modules over r or over any boolean ring have all stalks free because their modules over the field with two elements and must therefore be free. On the other hand m is not projective this is because we've got the exact sequence nought goes to i goes to r goes to m goes to zero and if m was projective it would mean this exact sequence would split which would mean that i but that r is the sum of i and m which would mean that i was also finitely generated but since i is not finitely generated it's not split. Well I mentioned that this module is not finitely generated and we're now going to show that a finitely presented plus stalkwise locally free implies projective and go through this proof is kind of a little bit technical and actually won't lose very much just by skipping it so what we're going to do is we're going to assume we've got a sequence nought goes to k goes to f goes to a goes to zero where a is stalkwise locally free now stalkwise locally free modules are always flat because you can check whether something is flat by just looking at the stalks and if the stalks are free then the stalks are flat and we're going to take f to be free and we're going to take i to be any ideal and we first note that k intersection f i is equal to k i and this is where we use the fact that a is flat because what we do is we compare the following two sequences we've got nought goes to k tensor i goes to f tensor i goes to a tensor i goes to zero and we can compare this with nought goes to k intersection f i goes to f i goes to a i so that should be a tensor sign goes to zero so these are the same because f is free and a is flat which means that these two modules here are actually the same under the natural isomorphism which easily implies that these two modules are the same and the second step is we note that if u is in k we can find a homomorphism f from f to k fixing u and this follows from step one because we just write u is equal to the sum of r i times f i for f i a basis of f remember f is free and we let i be the ideal r one r two and so on generated by the r's and u is in k intersection f i which is equal to k i so u is equal to the sum of k i r i for sum k i and now we can just define the homomorphism f by making f of f i equals r i step three says that if u1 up to u n are in k we can find f to k fixing all the u i and this follows from step two by using induction which i feeling too lazy to give the details of and anyone want to leave room for the final step and fourthly we notice that if k is finitely generated then a is projective and this follows from step three because if k is finitely generated then we can find a map from f onto k fixing all elements of k so this sequence splits what keeps doing that so a is a direct summand of a free module and is therefore projective so this is an example where you've got a subtle difference between finitely presented modules and finitely generated modules so you know over a notarian ring anything finitely generated is finitely presented so this doesn't really matter but here finitely presented modules that are stored wise locally free are projective but finitely generated modules that are stored wise locally free are not projective anyway i think that's quite enough on this rather technical topic so next lecture will be on flat modules which are probably the single most important class of modules