Log structure

In algebraic geometry, a log structure provides an abstract context to study semistable schemes, and in particular the notion of logarithmic differential form and the related Hodge-theoretic concepts. This idea has applications in the theory of moduli spaces, in deformation theory and Fontaine's p-adic Hodge theory, among others.

YouTube Encyclopedic

1/3
Views:
4 119
602
828

Transcription

That brings me to another background technology that I have to explain to you and which is called log structured file system. The idea here is that when I make a change to file y meaning I either append to the file or make some modifications to it. What I'm going to do is rather than writing the file as is, I'm going to write the change that I made to the file as a log record. So, I have a log record that says, what are the changes I made to this file x. Similarly, I have a log record of all the changes I made to this file y. And this is being done in a data structure which I'll call log segment. And I'll keep this log segment data structure in memory, of course, to make it fast in terms of the file system operation. So with this log segment data structure, what I can do is, buffer the changes to multiple files in one contiguous log segment data structure. So this log segment data structure, I can write it out as a file, and when I write it out, I'm not writing a single file, but I'm actually writing a log segment which contains all the changes made to multiple files. And because the log segment is contiguous, I can write it sequentially on the disk and sequential writes are good in the disk subsystem. And what we want to do is, we want to gather these changes to files that are happening in my system in the log segment in memory, and every once in a while, flush the log segment to disk, once the log segment fills up to a certain extent, or periodically. And the reason, of course, is the fact that if it is in memory, you have to worry about reliability of your file system, if, in fact, the node crashes. And therefore, what we want to do is, we want to either write out these log segments periodically or when a lot of file activity is happening and the log segment fills up very rapidly. After it passes of threshold, then you write it out to the desk. So in other words, we use a space metric or a time metric to figure out when to flush the changes from the log segment into the disk. And this solves the small write problem because if y happens to be a small file. No problem, because we are not writing y as-is on to the disk. But what we are writing is this log segment that contains changes that have been made to y in addition to changes that have been made to a number of other files. And therefore, this log segment is going to be a big file. And therefore, we can use the RAID technology to stripe the log segments across multiple disks. And give the benefit of the parallel IO that's possible with the RAID technology. So this log structured file system solves the small write problem. And in log structured file system, there are only logs. No data files. You'll never write any data files. All the things that you're writing are these append only logs to the disk. And when you have a read of a file, the read of a file, if it has to go to the disk and fetch that file, then the file system has to reconstruct the file from the logs that it has stored on the disk. Of course, once it comes into the memory of the server, then in the file cache the file is going to remain as a file. But, if at any point, the server has to fetch the file from the disk, it's actually fetching the log segments. And then reconstructing the file from the log segments. That's important. Which means that, in a log structured file system, there could be latency associated with reading a file for the first time from the disk. Of course, once it is read from the disk and reconstructed, it is in memory. In the file cache of the server, then everything is fine. But the first time, you have to read it from the disk, it's going to take some time because you have to read all these log segments and reconstruct it and that's where parallel RAID technology can be very helpful, because you're aggregating all the bandwidth that's available for reading the log segments from multiple disks at the same time. And the other thing that you have to worry about, when you have a log structured file system, is that these logs represent changes that have been made to the files. So, for instance, I may have written a particular block of y and that may be the change sitting here. Next time, what I'm doing is perhaps I'm writing the same block of the file. In which case, the first strike that I did, that is invalid. I have got a new write of that same block. So, you see that over time, the logs are going to have lots of holes created by overwriting the same block of a particular file. So in a log structured file system, one of the things that has to happen is that the logs have to be cleaned periodically to ensure that the disk is not cluttered with wasted logs that have empty holes in them because of old writes to parts of a file that are no longer relevant. Because those parts of the file have been rewritten, overwritten by subsequent writes to the same file. So logs, as I've introduced you, is similar to the disks that you've seen in the DSM system with the multiple writer protocol that we talked about in a previous lecture. You may have also heard the term, journalling file system, there is a difference between log structured file system, and journalling file system. Journalling file systems has both log files as well as data files, and what a journalling file system does, is it applies the log files to the data files and discards the log files. The goal is similar in a journaling file system, and the goal is to solve the small write problem, but in a journaling file system, the logs are there only for a short duration of time before the logs are committed to the data files themselves. Whereas in a log structured file system, you don't have data files at all, all that you have are log files and reads have to deconstruct the data from the log files.

Motivation

The idea is to study some algebraic variety (or scheme) U which is smooth but not necessarily proper by embedding it into X, which is proper, and then looking at certain sheaves on X. The problem is that the subsheaf of ${\mathcal {O}}_{X}$ consisting of functions whose restriction to U is invertible is not a sheaf of rings (as adding two non-vanishing functions could provide one which vanishes), and we only get a sheaf of submonoids of ${\mathcal {O}}_{X}$ , multiplicatively. Remembering this additional structure on X corresponds to remembering the inclusion $j\colon U\to X$ , which likens X with this extra structure to a variety with boundary (corresponding to $D=X-U$ ).^[1]

Definition

Let X be a scheme. A pre-log structure on X consists of a sheaf of (commutative) monoids ${\mathcal {M}}$ on X together with a homomorphism of monoids $\alpha \colon {\mathcal {M}}\to {\mathcal {O}}_{X}$ , where ${\mathcal {O}}_{X}$ is considered as a monoid under multiplication of functions.

A pre-log structure $({\mathcal {M}},\alpha )$ is a log structure if in addition $\alpha$ induces an isomorphism $\alpha \colon \alpha ^{-1}({\mathcal {O}}_{X}^{\times })\to {\mathcal {O}}_{X}^{\times }$ .

A morphism of (pre-)log structures consists in a homomorphism of sheaves of monoids commuting with the associated homomorphisms into ${\mathcal {O}}_{X}$ .

A log scheme is simply a scheme furnished with a log structure.

Examples

For any scheme X, one can define the trivial log structure on X by taking ${\mathcal {M}}={\mathcal {O}}_{X}^{\times }$ and $\alpha$ to be the inclusion.
The motivating example for the definition of log structure comes from semistable schemes. Let X be a scheme, $j\colon U\to X$ the inclusion of an open subscheme of X, with complement $D=X-U$ a divisor with normal crossings. Then there is a log structure associated to this situation, which is ${\mathcal {M}}={\mathcal {O}}_{X}\cap j_{*}{\mathcal {O}}_{U}^{\times }$ , with $\alpha$ simply the inclusion morphism into ${\mathcal {O}}_{X}$ . This is called the canonical (or standard) log structure on X associated to D.
Let R be a discrete valuation ring, with residue field k and fraction field K. Then the canonical log structure on $\mathrm {Spec} (R)$ consists of the inclusion of $R\setminus \{0\}$ (and not $R^{\times }$ !) inside $R$ . This is in fact an instance of the previous construction, but taking $j\colon \mathrm {Spec} (K)\to \mathrm {Spec} (R)$ .
With R as above, one can also define the hollow log structure on $\mathrm {Spec} (R)$ by taking the same sheaf of monoids as previously, but instead sending the maximal ideal of R to 0.

Applications

One application of log structures is the ability to define logarithmic forms (also called differential forms with log poles) on any log scheme. From this, one can for instance define log-smoothness and log-étaleness, generalizing the notions of smooth morphisms and étale morphisms. This then allows the study of deformation theory.

In addition, log structures serve to define the mixed Hodge structure on any smooth complex variety X, by taking a compactification with boundary a normal crossings divisor D, and writing down the corresponding logarithmic de Rham complex.^[2]

Log objects also naturally appear as the objects at the boundary of moduli spaces, i.e. from degenerations.

Log geometry also allows the definition of log-crystalline cohomology, an analogue of crystalline cohomology which has good behaviour for varieties that are not necessarily smooth, only log smooth. This then has application to the theory of Galois representations, and particularly semistable Galois representations.

References

^ Arthur Ogus (2011). Lectures on Logarithmic Algebraic Geometry.
^ Chris A.M. Peters; Joseph H.M. Steenbrink (2008). Mixed Hodge Structures. Springer. ISBN 978-3-540-77015-2

This page was last edited on 28 July 2023, at 17:02

From Wikipedia, the free encyclopedia