In this document, I describe how to use and configure VS Code to achieve the following:

• Compilation of LaTeX documents in VS Code with SyncTeX to jump between locations in the code and the PDF.
• Spell checking and grammar checking with support for LaTeX syntax.
• Pasting images into LaTeX documents.
• Collaboratively editing documents hosted on Overleaf.
• LaTeX “snippets” for actions like toggling between inline equations (i.e., $...$) and display equations (\[...\]).
• Custom linting tools for quickly identifying syntax errors (before compiling), and highlighting formatting or coding errors.

VS Code Settings

This section describes the VS Code settings I use, along with the VS Code Extensions described below, for my LaTeX editing environment.

To In my LaTeX projects, I use the following settings to help VS Code handle LaTeX-related file formats correctly.

  // Treat new files (before first save) as LaTeX files.
  "files.defaultLanguage": "latex",
  // Treat LaTeX package (.sty) and class (.cls) files as LaTeX files.
  "files.associations": {
      "*.sty": "latex",
      "*.cls": "latex"
  },
  // Hide the following file types from the VS Code folder list.
  "files.exclude": {
      "**/*.4ct": true,
      "**/*.4tc": true,
      "**/*.fdb_latexmk": true,
      "**/*.idv": true,
      "**/*.lg": true,
      "**/*.lof": true,
      "**/*.synctex.gz": true,
      "**/*.synctex(busy)": true,
      "**/*.tmp": true,
      "**/*.xref": true,
      "**/*.fls": true,
      "**/*.loc": true,
      "**/*.run.xml": true,
      "**/*.soc": true,
      "**/*.snm": true,
      "**/*.blg": true,
      "**/*-SAVE-ERROR": true
  },

VS Code Extensions

VS Code has many excellent extensions for writing LaTeX documents. My favorites are listed here, with descriptions of my settings for each extension included in the subsections below.

• LaTeX Workshop: Comprehensive support for LaTeX projects, including auto-completion, document compiling, syntax highlighting, and PDF preview.
• LTeX+: Grammar and spell-checking with support for LaTeX syntax.
• Paste Image: Simplifies inserting images into your project, allowing images to be directly pasted into LaTeX documents.
• Overleaf Workshop: Allows editing Overleaf Projects in VS Code.
• Dryer Lint: Allows for defining custom linting rules to highlighting writing errors that are specific to your context.

LaTeX Workshop

The LaTeX Workshop extension is the backbone of editing LaTeX in VS Code. I’ve listed the most useful features below—see the documentation for a full list of features and usage directions.

LaTeX Compilation

Automatic PDF compilation on edits or saves.

By default, LaTeX Workshop rebuilds each time a build fails. This is horrendously annoying, in my experience, since a build failure almost always requires manual intervention. To turn of auto re-building, use the following setting:

"latex-workshop.latex.autoBuild.cleanAndRetry.enabled": false,

LaTeX Workshop recompiles your document each time it is saved. By default, VS Code saves only when you do so manually. I prefer more frequent saves, namely each time I move my cursor out of the code editor:

  "files.autoSave": "onFocusChange",

In addition to compiling on saves, I also use the following VS Code keybinding to compile when I hit CTRL+Enter:

{
  "key": "ctrl+enter",
  "command": "latex-workshop.build",
  "when": "editorLangId =~ /latex/"
}

By default, LaTeX builds with LaTeX Workshop puts output files in the directory containing your .tex file. This quickly creates a cluttered mess, due to the numerous auxiliary files generated by the LaTeX build process. To avoid clutter and allow for build files to be quickly deleted, change the out directory. I use the following setting:

"latex-workshop.latex.outDir": "%DIR%/out_dir",

After changing "latex-workshop.latex.outDir", LaTeX Workshop’s "Clean up auxiliary files" command no longer deletes auxiliary files unless you also change this setting:

  "latex-workshop.latex.clean.subfolder.enabled": true,

(Note: The “Clean up auxiliary files” command misses some file types, so for a full clean you should just delete all of the files in the folder manually.)

PDF Viewing and Syncing

For viewing PDFs, I configure LaTeX Workshop to open PDFs in a VS Code tab.

"latex-workshop.view.pdf.viewer": "tab",

The built-in PDF viewer supports SyncTeX that for navigating back and forth between locations source code and the matching location in the PDF. If you are compiling a document that uses some specialized PDF features, such as animations in a Beamer animation, you may want to change "latex-workshop.view.pdf.viewer" to use an appropriate viewer.

By default, CTRL+Clicking (CMD+Clicking on macOS) on a PDF activates SyncTeX to navigate select the location in the code that was clicked on the document. I change the setting to make the behaviors match Overleaf, which uses double-clicking to jump to the code location:

"latex-workshop.view.pdf.internal.synctex.keybinding": "double-click",

To jump from the Code to the PDF, open the command pallet (CTRL+SHIFT+P) and run LaTeX Workshop: SyncTeX from cursor.

I also make some aesthetic changes to the PDF viewer. In particular, I change the background color beyond the border of pages to a shade of green that I find relaxing and make the page border the same color so it does not appear as a line (this helps prevent actual lines in the document from being overlooked if they happen to be at the edge of the page):

  "latex-workshop.view.pdf.color.dark.backgroundColor": "#809080",
  "latex-workshop.view.pdf.color.light.backgroundColor": "#809080",
  "latex-workshop.view.pdf.color.dark.pageBorderColor": "#809080",
  "latex-workshop.view.pdf.color.light.pageBorderColor": "#809080",

You can also display PDFs in “dark mode” by setting "latex-workshop.view.pdf.color.dark.pageColorsForeground" and "latex-workshop.view.pdf.color.dark.pageColorsBackground", but I find the resulting appearance hard to read.

Code Editor and Autocompletion

LaTeX Workshop has many built-in snippets that can be used for autocompletion, and enables syntax-aware autocompletion using VS Code’s IntelliSense feature.

For IntelliSense to work on LaTeX non-standard packages you have downloaded or written, you need to tell LaTeX Workshop where to find the packages.

  "latex-workshop.intellisense.package.dirs": [
    // List any folders that contain additional LaTeX package (.sty) 
    // or class (.cls) files, so that intellisense will use them 
    // for auto-complete suggestions.
    "packages",
    "%WORKSPACE_FOLDER%/packages"
  ],
  "latex-workshop.intellisense.package.extra": [
    "examplepackage1",
    "examplepackage2"
  ]

To make IntelliSense to update more frequently, enable this setting:

  "latex-workshop.intellisense.update.aggressive.enabled": true,

In the code editor, LaTeX Workshop displays equation previews by default when you hover over an equation. I dislike these previews so I disable them.

  "latex-workshop.hover.preview.cursor.enabled": false,
  "latex-workshop.hover.preview.enabled": false,

LTeX+: Spell-checking and Grammar Checking for LaTeX

In LaTeX documents, standard document spell checkers and grammar checkers don’t work well due to the presence of non-text content, like equations and macros. For example, the sentence “The function $f : \mathbb{R} \to \mathbb{R}$ are \emph{continuous}.” will confuse most checkers, which will show false positive for $f, \mathbb, etc., and will likely not identify the mismatched pluralization of “The function … are continuous”.

Fortunately, there is a checker called LTeX+ that is built specifically to handle LaTeX documents (LTeX+ is based on the now deprecated extension LTeX). In VS Code, the LTeX+ extension performs spell checking and grammar checking that is (mostly) aware of LaTeX syntax. LTeX+ does a pretty good job of catching mistakes “out of the box”, with its default settings, but adjusting the settings can allow it to catch more mistakes and have less false-positives.

Increase LTeX+ Pickiness

By default, LTeX+ only highlights spelling and grammar errors, but it also can provide a broader range of suggestions for “picky” rules. Many of the picky rules regard writing style, such as alerting you to sentences that are too long, or when several sentences in a row start with the same word. The following setting enables “picky” rules:

 "ltex.additionalRules.enablePickyRules": true

Using picky rules produces more false-positives. To resolve false positives, you can disable specific rules by selecting text that violates the rule and selecting “Disable Rule” from the quick suggestions panel:

Alternatively, you can select “hide false positive”, as described below (see below), although I rarely use this feature.

Adjusting Severity Levels

By default, LTeX+ displays all problems using VS Code’s “Information” formatting, which results in serious issues, such as misspelled words, being lost in the shuffle of minor problems, like using a passive voice. The severity of type of issue is set via the "ltex.diagnosticSeverity" setting. I keep the default as "information", increase spelling errors to a "warning" level, and decrease the severity of some stylistic suggestions to “hints”. For spelling, the name of the rule is "MORFOLOGIK_RULE_EN_US". I use the following values for my "ltex.diagnosticSeverity" setting:

"ltex.diagnosticSeverity": {
        "default": "information", 
        "MORFOLOGIK_RULE_EN_US": "warning", // Spelling errors.
        "PASSIVE_VOICE": "hint",
        "ENGLISH_WORD_REPEAT_BEGINNING_RULE": "hint",
        "TOO_LONG_SENTENCE": "hint"
    },

A full list of LTeX rules is available here.

Defining How LTeX+ Parses User-Defined LaTeX Commands

LTeX has built-in knowledge of some LaTeX macros or environments, but for LTeX+ to correctly check code with less common or user-defined macros or environments, we need to provide additional information via the "ltex.latex.commands" and “ltex.latex.environments” settings.

"ltex.latex.commands": {
  "\\tableofcontents[]": "ignore", 
  "\\@ifclassloaded{}{}{}": "ignore",
  "\\includeonly{}": "ignore",  
  "\\texttt{}": "dummy", // Inline formatting for code.
  "\\newbool{}": "ignore",  
  "\\setbool{}": "ignore",
  "\\setbool{}{}": "ignore",
  // Macros and environments definitions
  "\\newcommand{}{}": "ignore",  
  "\\renewcommand{}{}": "ignore", 
  "\\newenvironment{}[][]{}{}": "ignore", 
  "\\newenvironment{}[]{}{}": "ignore", 
  "\\newenvironment{}": "ignore",  
  "\\NewDocumentCommand{}{}{}": "ignore",  
  "\\NewEnviron{}[]{}": "ignore",  
  "\\newtheoremstyle{}{}{}{}{}{}{}{}{}": "ignore",  
  "\\DeclarePairedDelimiterX{}[]{}{}": "ignore", 
  "\\DeclarePairedDelimiter{}{}{}": "ignore", 
  // Beamer
  "\\setbeamertemplate{}[]{}": "ignore", 
  "\\setbeamercolor{}{}": "ignore",  
  "\\setbeamerfont{}{}": "ignore", 
  "\\usebeamercolor[]{}": "ignore", 
  "\\usebeamertemplate{}[]": "ignore",
  "\\setbeamertemplate{}{}": "ignore", 
  "\\setbeamertemplate{}[]": "ignore", 
  "\\usebeamertemplate{}[]{}": "ignore",
  "\\setbeamerfont{}": "ignore", 
  "\\addtolength{}{}": "ignore", 
  "\\movie{}{}": "ignore",
  "\\movie[]{}{}": "ignore",
  // Citations and references
  "\\cite{}": "dummy",
  "\\nocite{}": "ignore",
  "\\cref[]{}": "dummy", 
  "\\crefformat{}{}": "ignore",  
  "\\Crefformat{}{}": "ignore", 
  "\\crefmultiformat{}{}{}{}{}": "ignore",  
  "\\Crefmultiformat{}{}{}{}{}": "ignore", 
  "\\crtcrefreference{}": "dummy",  
  // Changes annotations
  "\\deleted{}": "ignore",
  "\\todo{}": "ignore",
  "\\todo[]{}": "ignore",
  // ...
}

Hiding False Positives

LTeX+ has a mechanism for hiding false positives, but it is fragile, requiring you to either re-mark each false positive whenever any part of the sentence changes or try to write a regular expression to match the false positive. I don’t recommend either of those methods. Instead, I define several dummy LaTeX macros to the values "ignore", "dummy", and "voweldummy" from the "that I include in the “ltex.latex.commands”` setting:

% Definitions for telling LTeX to ignore certain parts of the LaTeX code.
% Example: "This is a \ltexdummy{miskate}."
\newcommand{\ltexignore}[1]{#1}
\newcommand{\ltexdummy}[1]{#1}
\newcommand{\ltexvoweldummy}[1]{#1}

Then, I mark each macro in "ltex.latex.commands" as follows:

"ltex.latex.commands": {
  // ... 
  // Macros to hide LTeX false-positive
  "\\ltexignore{}": "ignore",
  "\\ltexdummy{}": "dummy",
  "\\ltexvoweldummy{}": "vowelDummy"
}

It is also sometimes useful to include text that LTeX reads but is not included in the output.

% Insert a piece of hidden text that is parsed by LTex but is not displayed.
\newcommand{\ltexhidden}[1]{}

Ignoring Irrelevant BibTeX Fields

In BibTeX files, I typically have entries automatically generated by Zotero. Typically, each entry has an abstract and these tend to have a lot of false positives but are not included in the output. Instead of handling each issue individually, I use the "ltex.bibtex.fields" setting to disable LTeX+-checking of bibliography abstracts.

 "ltex.bibtex.fields": {
    # Abstracts in bibliography entries typically are not 
    # typed by the user and are rarely inserted into the 
    # document, but tend to have a lot of LTeX+ warnings, 
    # so I disable warnings for the abstracts.
    "abstract": false
  }

Paste Image: Image Pasting into LaTeX Code

One of my biggest complaints about using LaTeX used to be the difficulty of doing some basic tasks, such as adding an image to a document, that can be done immediately in other document editors. Adding a picture required saving the file to a particular location, creating a figure environment with \includegraphics inside, and typing or copy/pasting the path to the image. That’s no longer the case! In my current setup I can copy-and-paste an image into a LaTeX document using the Paste Image extension. This extension is not designed for LaTeX in particular, however, so you need to do some specific configuration so that pasted images are placed in a reasonable directory and are properly referenced and formatted within the .tex file.

// In .vscode/settings.json or /path/to/global/settings/settings.json
...
// Where to place the files for pasted images.
"pasteImage.path": "${currentFileDir}/pasted-images",
// The code to insert into LaTeX. (Since the images are placed in 
// a directory named pasted-images/ that is in the same directory 
// as the current TeX file, the relative path to the file is 
// pasted-images/${imageFileName}.)
"pasteImage.insertPattern": 
  "\\begin{center}\n\t\t\\includegraphics[width=\\linewidth]{pasted-images/${imageFileName}}\n\t\\end{center}",
// Make Paste Images ask you what to name the file so you don't 
// end up with a bunch of files named things like "12-03-2024-12-44-23.png"
"pasteImage.showFilePathConfirmInputBox": true,
// Only ask for the name of the created file, instead of the full path.
"pasteImage.filePathConfirmInputBoxMode": "onlyName",
// Default name.
"pasteImage.defaultName": "${currentFileNameWithoutExt}-HH-mm-ss",
// Don't encode the path for HTML. 
"pasteImage.encodePath": "none",
// I don't remember what this does 
"pasteImage.basePath": "${currentFileDir}",
...

Pasting Images into LaTeX

The Paste Images extension simplifies inserting images into LaTeX documents. In particular, you can insert images from your clipboard into a LaTeX documents and Paste Images will create an image file in a specified directory and insert LaTeX code that references it.

Since the Paste Image extension is not designed for LaTeX, specifically, you need to modify the configuration to make to it work correctly.

  {
    "pasteImage.insertPattern": "\\begin{center}\n\t\t\\includegraphics[width=\\linewidth]{pasted-images/${imageFileName}}\n\t\\end{center}",
    "pasteImage.filePathConfirmInputBoxMode": "onlyName",
    "pasteImage.encodePath": "none",
    "pasteImage.basePath": "${currentFileDir}",
    "pasteImage.showFilePathConfirmInputBox": true,
    "pasteImage.defaultName": "${currentFileNameWithoutExt}-HH-mm-ss",
    "pasteImage.path": "${currentFileDir}/pasted-images",
  }

Dryer Lint Extension

The Dryer Lint extension allows you to define custom linting patterns using regular expressions. I created the Dryer Lint based on the relint by Ryan Blonna. In the subsections below, I list the lint rules that I developed to 1) identify syntax errors before compiling, 2) highlight formatting faux pas, and 3) enforce my preferred coding style. Some other uses you might consider on a project-by-project basis are rules to check for

• A word that should not appear in your document but is similar to a word that you use.
• Check for expressions that you commonly mix up, such as $\distA{z}$ instead of $\distA{x}$
• Check that you use a semantically important macro instead of its definition.

All Dryer Lint rules are defined by JavaScript style regular expressions. They should be placed in your settings.json file, in the following entry:

  "dryer-lint": {
      "language": "latex",
      "rules": [
          {
            /// Place rules here...

          }
      ]
  }

For writing and testing regular expressions, I recommend using regex101.com.

When writing multi-line rules, the regular expression for line breaks varies between platforms. On Windows, a line break is \r\n and on Linux it is just \n. Thus, to get a platform-independent line break, use \r?\n.

Linting Rules for Syntax Errors

This section contains rules that check for syntax errors that will cause LaTeX builds to fail. Since linting happens much faster than compilation, this allows you to catch the mistake quicker.

Check that \cref{}, \cite{}, \ref{}, and \eqref{} do not occur without arguments. This is particularly helpful for \cref{} because a missing argument generates a cryptic compilation error message.

{
  // Check for \cref{}, \cite{}, \ref{}, or \eqref{} occurring without arguments.
  "name": "Empty Reference or Citation",
  "message": "Missing argument to \\cref, \\cite, \\ref, or \\eqref.",
  "pattern": "\\\\(cref|eqref|ref|cite)\\{\\s*\\}",
  "severity": "Error"
},

For \cite and \cref, which can take comma separated lists of labels, a space after a comma typically indicates a mistake, so the following rule checks that this does not occur:

{
  // Check that a comma-separated list of labels passed to 
  // \cref or \cite does have spaces after any commas.
  // Although a trailing space is permitted in labels, it 
  // would be better to revise the label by removing the space.
  "name": "Reference has a space after the comma",
  "message": "The argument to \\cref or \\cite has a comma followed by a space. This typically indicates an error because the space will be read as a part of the label.",
  "pattern": "(\\\\(?:cref|cite)\\{[^\\}]*)\\,\\ ",
  "severity": "Warning"
},

Putting a comma or backslash into a LaTeX label causes problems, so this rule checks that the argument to \label{...} does not contain “,” or “".

{
  // Check that \label{} does not contain a comma or a backslash.
  "name": "Illegal Character in \\label{}",
  "message": "\\label{...} must not contain \",\" or \"\\\".",
  // Unescaped Regex: \\label\{[^\}]*[,\\][^\}]*\}
  "pattern": "\\\\label\\{[^\\}]*[\\\\,][^\\}]*\\}",
  "severity": "Error"
},

The following two rules assume that you use $...$ for inline equations and \[...\] for display equations. One significant advantage of avoiding $$...$$ for display equations, is that we can define the following linting rule that immediately identifies $$ as an error—most likely an inline equation was intended, but the lack of code between the dollar signs cause them to be interpreted as the start of a display equation that inevitably leads to cascading errors through the rest of the document.

{
  // This rule assumes that you write display equations using "\[...\]", 
  // which means that "$$" should never appear in your document.
  "name": "Inline equation with empty contents: \"$$\".",
  "pattern": "\\$\\$",
  "severity": "Error",
  "fix": "$ $",
  "message": "\"$$\" should not be used. To insert a display equation, use \"\\[...\\]\"."
},

We also highlight when an inline equation is empty, since this typically indicates an omission.

{
  "name": "Inline equation with empty contents: \"$ $\".",
  "pattern": "\\$[ ]+\\$",
  "severity": "Warning",
  "message": "Inline equation with empty contents: \"$ $\"."
},

In LaTeX, every itemize or enumerate environment must begin with \item (not counting spaces or comments). The following rule displays an error when \item is missing or preceded by other code.

{
  "name": "Itemize must start with an item",
  // Regex101.com link: https://regex101.com/r/9Ck04q/2
  // Regular expression (unescaped):
  //      "\\begin\{itemize\}(?:[ \t]*(?:%[^\n]*)?\r?\n)*[ \t]*(\S(?<!%|\\).*|\\(?!item).*)"
  // Explanation:
  //  1. "\\begin\{(?:itemize|enumerate|description)\}" matches the start 
  //     of the itemize, enumerate, or description environment.
  //  2. "(?:[ \t]*(?:%[^\n]*)?\r?\n)*" matches any number of comment lines or empty lines.
  //  3. "[ \t]*(\S(?<!%|\\).*|\\(?!item).*)" matches the first non-empty 
  //     non-comment line unless it starts with \item. More precisely:
  //     3.1 "[ \t]*" matches any leading whitespace.
  //     3.2 "\S(?<!%|\\).*" matches the non-white space, expect for comment 
  //         tokens ("%") or the start of a command sequence ("\"). 
  //         The ".*" causes the error to be displayed extending to the end 
  //         of the line.
  //  4. "\\(?!item).*" matches a command sequence (i.e., starting with "\") except for "\item", 
  //     which is excluded by the negated lookbehind "(?!item)".
  "pattern": "\\\\begin\\{(?:itemize|enumerate|description)\\}(?:[ \\t]*(?:%[^\\n]*)?\\r?\\n)*[ \\t]*(\\S(?<!%|\\\\).*|\\\\(?!item).*)",
  "message": "List environments must start with \\item.",
  "severity": "Error",
  "maxLines": 5
},

Linting Rules for Document Style

These rules enforce syntax that affect the appearance of the rendered document.

The following rules check that non-breaking spaces are used before \cite{...}, \ref{}, and \eqref{}, and before \cref{} when referencing an equation. The \cite{} rule is suitable for numerical in-line citation formats, such as IEEE citations that look like “[12]”.

{
    "name": "Missing non-breaking space before \\cite",
    "message": "Use \"~\" (non-breaking space) before `\\cite` to prevent awkward line breaks.",
    "pattern": "[ ]\\\\cite\\{",
    "severity": "Information",
    "fix": "~\\cite\\{"
},

The \cref{} rule requires that you are using the cleveref package and label equations using labels starting with “eq:”. You should also have cleveref configured to reference equations using a number inside a parenthesis, e.g., “(12)” rather than “Eq. 12”.

{
    // Check for a space before the reference to an equation. 
    // This rule requires that you label all equations with a prefix "eq:".
    "name": "Missing non-breaking space before cleveref equation reference",
    "message": "Use \"~\" (non-breaking space) before referencing an equation to prevent awkward line breaks.",
    "pattern": "[ ]\\\\cref\\{eq:",
    "severity": "Information",
    "fix": "~\\cref{eq:"
},
{
    "name": "Missing non-breaking space before references",
    "message": "Use \"~\" (non-breaking space) before \"\\eqref{}\" and \"\\ref{}\" to prevent awkward line breaks before the inserted number.",
    "pattern": "[ ]\\\\(eqref|ref)\\{",
    "severity": "Information",
    "fix": "~\\$1{:"
},

The punctuation at the end of a display equation should be placed inside the equation delimiters (“\[...\]”). Otherwise, the punctuation will be displayed incorrectly below the equation:

\[a^2 + b^2 = c^2\].

{
    "name": "Punctuation outside Display Equation",
    "pattern": "\\\\][.,;]",
    "severity": "Warning",
    "message": "Place punctuation inside display equation, before \"\\]\"."
},

The following rule checks for extra line breaks at the end of align, aligned, and cases environments.

{
    "name": "Multiline equation environment has extra line at end",
    "pattern": "(?:\\\\){2}[ \\t]*\\r?\\n[ \\t]*\\\\end{(?:align[*]?|aligned|cases)}",
    "severity": "Warning", 
    "message": "Extra line break at the end of environment.",
    "maxLines": 2
},

Linting Rules for Code Style

This section has linting rules I use to enforce my preferred LaTeX code style. Adapt them to match your preferences.

{
    "name": "Display equation starts on new line unless the preceding line is short",
    "message": "Display equations (\"\\[....\\]\") should start on a new line unless the preceding text is shorter than 15 characters.",
    // The length of the non-leading-whitespace string is 15 or more because 
    // "[^ \\t%]" is 1 character and ".{14,}" is 14 or more characters.
    "pattern": "^([ \\t]*)([^ \\t%].{14,}) \\\\\\[",
    "fix": "$1$2\n$1\\[", 
    "severity": "Information"
},
{
    "name": "Display equations should be followed by a new line",
    "message": "Display equations (\"\\[....\\]\") should be followed by a new line.",
    "pattern": "\\\\\\][ \\t]*(\\S)",
    "severity": "Information"
},
{
    "name": "Use spaces for indentation",
    "pattern": "^[ ]*[\\t][\\t ]*",
    "severity": "Information",
    "message": "Use spaces for indentation instead of tabs. Run \"Convert indentation to spaces\" to fix.",
},
{
    // The pattern matches a line that contains a sentence that ends 
    // with a period and the next line starts with a word character. 
    // The fix inserts a newline between the two lines.
    "name": "Start each sentence on a new line",
    "message": "Code style: Start each sentence on a new line.",
    // Regex: ^([ \t]*)((?:[^%]|(?<=\\)%).*\w\.)[ ]+(\w)
    // Parts: 
    // 1. Leading whitespace: ^([ \t]*)
    // 2. Any character except an unescaped comment character 
    //    ("%" but not "\%"): (?:[^%]|(?<=\\)%)
    // 2. Check that the "period" is not preceded by \big or \Big, 
    //    indicating that it is actually 
    //    being used to increase the size of delimiters: (?<!\\big|\\Big)
    // 3. Sentence ending with a period, but not in a comment: ((?:[^%]|(?<=\\)%)*\.)
    // 4. Whitespace between sentences: [ ]+
    // 5. First letter of the next sentence: (\w)
    "pattern": "^([ \\t]*)((?:[^%]|(?<=\\\\)%)*(?<!\\\\big|\\\\Big)\\.)[ ]+(\\w)",
    "severity": "Information",
    "fix": "$1$2\n$1$3",
},

Overleaf Workshop Extension

The Overleaf Workshop extension allows editing Overleaf Projects in VS Code.

Once you have VS Code nicely set up, you may find that you are occasionally collaborating with coauthors who wish to use Overleaf. While Overleaf is great for synchronized editing, the loss of VS Code features can be jarring once you are accustomed to them.

The Overleaf Workshop extension bridges this gap by allowing you to sync Overleaf projects with VS Code, but it comes with some major caveats. Overleaf Workshop provides two methods for opening projects:

1. Open the project with a virtual workspace that continually syncs with Overleaf, or
2. “Open Project Locally”, which creates a local copy.

Both methods have major drawbacks. The virtual workspace approach does not support LaTeX Workshop, so you lose all the nice features from that extension. On the other hand,

Alternative: Syncing with Overleaf Projects with Git

If you have a premium Overleaf account, you can use Git integration to sync an Overleaf project to your computer, allowing you to safely modify the project and then push the changes back to Overleaf.

Using Git incurs some overhead with pushing, pushing, and (possibly) merging, but it may be worth the upsides of editing Overleaf documents with the exact same tools as any of your local LaTeX documents.

Code Formatting

In any programming languages, adopting a sensible and consistent coding style improves readability and maintainability, and sometimes highlights errors that would otherwise go unnoticed.

Previous sources have written at length about LaTeX coding style (see “Towards LATEX coding standards” by Didier Verna). I will add my two cents for a piece of code style that substantially improves tracking changes in Git. When I first started writing LaTeX, I would put entire paragraphs on a single line of code, with line wrapping turned on in the editor. While editing, this was …fine, but caused difficulties in version control. In particular, when I was committing or merging changes in Git, it would be difficult to see where in a line changes were made. Later, I switched to adding line breaks after every 80 characters or so (without regards to sentences), so that the entirety of each line code would be visible line wrapping off. This fixed the difficulty with seeing diff’s, but required a lot of effort to keep each line roughly my desired width.

To fix both problems, I now write every sentence on its own line. As an added benefit, having a one sentence per line allows for easily checking the lengths of sentence to see if any are too long and if there is a nice variation lengths.

To make word-wrapping appear nicely in the editor, I use the following settings:

  "editor.wordWrap": "on",
  "editor.wrappingIndent": "indent"

Sometimes, word wrap in the editor makes certain tasks more difficult (especially when using multi-cursors on aligned text), in which case you can use the command pallet (or the shortcut shown therein) to toggle word wrap:

1. Open command pallet (CTRL+SHIFT+P on Windows)
2. Select View: Toggle Word Wrap (CTRL+SHIRT+P on Windows)

I published the Dryer Lint extension, described above, to help (among other things) enforce a consistent code style.

VS Code Snippets

The following code contains snippets I’ve developed for LaTeX. For a description of VS Code snippets, see here. I have provided the snippets largely without explanation, here, except for some documentation of the more complicated regular expressions. For experimenting with regular expressions, I recommend regex101.com. You can find all of my snippets in a GitHub repository here.

To add these snippets to your VS Code environment,

1. Open the Command Pallet
2. Run Snippets: Configure Snippets
3. Select latex.json (for global snippets) or latex.code-snippets (for workspace snippets). In my setup, latex.code-snippets says “global” after it, but it actually is only for defining snippets in the current workspace.

Equations

...
// Equations
"Display Equation":{
  "prefix": ["\\["],
  "body": [
    // If the current line is not empty, then insert an empty line.
    "${TM_CURRENT_LINE/(?:^(\\s*)\\S.*$|(^\\s*$))/${1:+\n}$1/}\\[",
      "\t$TM_SELECTED_TEXT$1",
    "\\] $0"
  ],
  "description": "Insert block equation with line-breaks and indentation."
},
"Inline Equation":{
  "body": [
    "$$TM_SELECTED_TEXT$1$$0"
  ],
  "description": "Insert inline equation."
},
"Equation Environment":{
  "prefix": ["\\equation"],
  "body": [
    "\\begin{equation}",
      "\t\\label{eq:$RANDOM_HEX}",
      // Regex (unescaped): \s*(?:\\\[\s*((?:.(?:\s*)??)*)\s*\\\]|((?:.|\s)+))\s*
      //   Match either "  \[ \n .... \] " or just the entire contents and insert it as the body of the equation.
      //   Explanation:
      //      (?:\s*)??: Match any number of spaces *including line breaks* but 
      //								 only if needed to allow for subsequent non-space characters.
      "\t${TM_SELECTED_TEXT/\\s*(?:\\s*\\\\\\[\\s*((?:.(?:\\s*\\S)?)*)\\s*\\\\\\]\\s*|((?:.|\\s)+))\\s*/$1$2/}$1$0",
    "\\end{equation}",
    ""
  ],
  "description": "Insert equation environment with a random hexadecimal label."
},
"Generate Equation Label":{
  "prefix": ["\\eqlabel"],
  "body": [
    // Automatically generate a label from the contents of the equation, deleting any backslashes or ambersands.
    "\\label{eq:${TM_SELECTED_TEXT/[\\\\&,]//g}${1/[\\\\&,]//g}$1}",
    "$TM_SELECTED_TEXT$0"
  ],
  "description": "Create an equation label that is automatically generated from the selected text."
},
"Display Equation to Equation Environment":{
  "body": [
    // Group 1: Before text. "(.*?)"
    // Group 2: Tab spaces before equation delimiter. "(\\h*)"
    // Group 3: Equation contents "(.*?)"
    // Group 4: After text "(.*)"
    "${TM_SELECTED_TEXT/(.*?)(\\h*)\\\\\\[\\s*(.*?)\\s*\\\\\\](.*)/$1$2\\begin{equation}\n$2\t$3\n$2\\end{equation}\n/s}"
  ],
  "description": "Convert a display equation to an equation environment."
},
"Convert inline to display equation":{
  "body": [
    // Unescaped RegEx: ([\S\s]*)\$\s*(.*?)\s*\$([,.]{0,1})([\S\s]*)
    // Group 1: Content before equation. ("[\S\s]" matches any character)
    // Group 2: Contents of equation, stripping white space.
    // Group 3: Punctuation after equation ("[,.]{0,1}" matches "," or "." zero or one times)
    // Group 4: Content after equation
    // We duplicate the Regex for each line so that VS code automatically inserts the correct indentation for us, instead of handling it in the regex.
    "${TM_SELECTED_TEXT/([\\S\\s]*)\\$\\s*(.*?)\\s*\\$([,.]{0,1})\\s*([\\S\\s]*)/$1/s}",
    "\\[",
    // It's important to put "\t" before "${TM_SELECTED_TEXT...}" instead of inside it so that VS code inserts tabs or spaces according to you configuration. If it's inside the regex, then it inserts a tab character.
    "\t${TM_SELECTED_TEXT/([\\S\\s]*)\\$\\s*(.*?)\\s*\\$([,.]{0,1})\\s*([\\S\\s]*)/$2$3/s}",
    "\\]",
    "${TM_SELECTED_TEXT/([\\S\\s]*)\\$\\s*(.*?)\\s*\\$([,.]{0,1})\\s*([\\S\\s]*)/$4/s}",
  ],
  "description": "Convert an inline equation to a display equation."
},
"Convert display to inline equation":{
  "body": [
    // Regular expression (unescaped): (.*)\\\[\s*\n*\s*(.*?)\s*\n*\s*\\\](.*)
    // - "\s*" matches any number of spaces and line breaks around it.
    // - "[\s\S]" matches any character, including line breaks and spaces.
    // - "\\\[" Matches "\[" (there are three backslashes because "\\" matches "\" and "\[" matches "[").
    // Group 1: All the content before the equation.
    // Group 2: All the content in the equation, except for final punctuation  
    // Group 3: Final punctuation ("[,.]{0,1}").
    // Group 4: All the content after the equation.
    "${TM_SELECTED_TEXT/([\\S\\s]*)\\\\\\[\\s*([\\S\\s]*?)\\s*([,.]{0,1})\\s*\\\\\\]([\\S\\s]*)/$1$$2$$3$4/s}",
    
  ],
  "description": "Convert a display equation to an inline equation."
},

"Subequations":{
  "prefix": ["\\subequations", "\\begin{subequations}", "equations group", "equation group"],
  "description": "Insert a group of equations that share the number, e.g., (3a), (3b), (3c).",
  "body": [
    "\\begin{subequations}",
    "\t\\label{eq:${1:equation block label}}",
    "\t\\begin{align}",
    "\t\t$0",
    "\t\\end{align}",
    "\\end{subequations}"
  ]
}
...

Lists

...
// Lists: Enumerate, Itemize, and Description
"Add \\item after each line break":{
  "prefix": ["\\itemafterlines"],
  "body": [
    "${TM_SELECTED_TEXT/(\\n)(\\s*)/$1$2\\item /g}"
  ],
  "description": "Insert a citation."
},
"Itemize with \\item after each line":{
  "prefix": ["\\itemize"],
  "body": [
    "\\begin{itemize}",
    "\t\\item ${TM_SELECTED_TEXT/(\\n)(\\s*)/$1$2\\item /g}",
    "\\end{itemize}",
    ""
  ]
}
...

Section Headers

...
"Section Labeled":{
  // "prefix": ["\\sectionlabeled"],
  "prefix": ["\\section"],
  "body": [
    "",
    "%===================================",
    "%===================================",
    "\\section{$TM_SELECTED_TEXT${1:Header}}",
    "\\label{sec:${TM_SELECTED_TEXT/[\\\\&\\v\\{\\}\\[\\]$]//g}${1/[\\\\&\\\\{\\}\\[\\]$]//g}}",
    "$0"
  ]
},
"Subsection":{
  "prefix": ["\\subsection"],
  "body": [
    "",
    "%================================",
    "\\subsection{$TM_SELECTED_TEXT${1:Header}}",
    "\\label{sec:${TM_SELECTED_TEXT/[\\\\&\\v\\{\\}\\[\\]$]//g}${1/[\\\\&\\v\\{\\}\\[\\]$]//g}}",
    "$0"
  ]
},
"Subsubsction":{
  "prefix": ["\\subsubsection"],
  "body": [
    "",
    "\\subsubsection{$TM_SELECTED_TEXT${1:Header}}",
    "\\label{sec:${TM_SELECTED_TEXT/[\\\\&\\v\\{\\}\\[\\]$]//g}${1/[\\\\&\\v\\{\\}\\[\\]$]//g}}",
    "$0"
  ]
}
...

Math Function Macros with Arguments

...
"Inner product":{
  "prefix": ["\\ip"],
  "body": [
    "\\ip{$TM_SELECTED_TEXT$1}{$2}$0 "
  ]
},
"Absolute value":{
  "prefix": ["\\abs"],
  "body": [
    "\\abs{$TM_SELECTED_TEXT$1}$0 "
  ]
},
"Norm":{
  "prefix": ["\\norm"],
  "body": [
    "\\norm{$TM_SELECTED_TEXT$1}$0 "
  ]
}
...

Text formatting

...
"Emphasis":{
  "prefix": ["epmh","\\emph"],
  "body": [
    "\\emph{$TM_SELECTED_TEXT$1}$0"
  ]
},
"Bold":{
  "prefix": ["bold","\\bold"],
  "body": [
    "\\textbf{$TM_SELECTED_TEXT$1}$0"
  ]
},
"Teletype":{
  "prefix": ["t","\\tt"],
  "body": [
    "\\texttt{$TM_SELECTED_TEXT$1}$0"
  ]
},
    "Hyperlink (includes link)":{
  "prefix": ["\\href","\\hyperlink", "\\url"],
  "body": [
    "\\href{${1:url}}{$TM_SELECTED_TEXT$2}$0"
  ]
},
"Hyperlink (no link)":{
  "prefix": ["\\url"],
  "body": [
    "\\url{$TM_SELECTED_TEXT$2}$0"
  ]
}
...

Environments

...
"Definition (labeled)":{
  "prefix": ["\\definition (labeled)"],
  "body": [
    "\\begin{definition}[${1:Name of Defined Term}]",
    "\t\\label{def:${1:label}}",
    "\t$TM_SELECTED_TEXT$0",
    "\\end{definition}"
  ]
},
"Example (labeled)":{
  "prefix": ["\\example (labeled)"],
  "body": [
    "\\begin{example}[${2:Example Name}]",
      "\t\\label{example:${1:Example Name}}",
      "\t$TM_SELECTED_TEXT$0",
    "\\end{example}"
  ]
}
...

Changes Annotations

...
"Added":{
  "prefix": ["\\added"],
  "body": [
    "\\added{$TM_SELECTED_TEXT$1}$0"
  ]
},
"Added Multi-line":{
  "prefix": ["\\added%"],
  "body": [
    "\\added{%%%%%%%%%% ADDED %%%%%",
    "$TM_SELECTED_TEXT$0",
    "}%%%% END ADDED %%%%"
    // "" // Ensure there is a new line at end
  ]
},
"Deleted":{
  "prefix": ["\\deleted"],
  "body": [
    "\\deleted{$TM_SELECTED_TEXT$1}$0"
  ]
},
"Deleted Multiline":{
  "prefix": ["\\deleted%"],
  "body": [
    "\\deleted{%%%%%%%%%% DELETED %%%%%",
    "\t$TM_SELECTED_TEXT$0",
    "}%%%%%%%%%% END DELETED %%%%%",
    // "" // Ensure there is a new line at end
  ]
},
"Replaced":{
  "prefix": ["\\replaced"],
  "body": [
    "\\replaced{$TM_SELECTED_TEXT$1}{$TM_SELECTED_TEXT}$0"
  ]
},
"Replaced Multiline":{
  "prefix": ["\\replaced%", "\\replaced (block)"],
  "body": [
    "\\replaced{% New Text",
    "$TM_SELECTED_TEXT$0",
    "}{% Old Text",
    "\t$TM_SELECTED_TEXT",
    "}% End \\replaced block",
    // "" // Ensure there is a new line at end
  ]
}

Tables and Columns

...
// ======== COLUMNS =========
"Inline Table":{
  "prefix": ["table", "tabular"],
  "body": [
    "\\begin{center}",
        "\t\\begin{tabular}{$1}",
            "\t\t$TM_SELECTED_TEXT$0",
        "\t\\end{tabular}",
    "\\end{center}"
  ]
},
"Two Columns":{
  "prefix": ["\\columns (2)","\\twocolumns"],
  "body": [
    "\\begin{columns}",
      "\t\\begin{column}[T]{0.48\\textwidth}",
        "\t\t$TM_SELECTED_TEXT$1",
      "\t\\end{column}",
      "\t\\hfill",
      "\t\\begin{column}[T]{0.48\\textwidth}",
        "\t\t$2",
      "\t\\end{column}",
    "\\end{columns}",
    "$0"
  ]
},
"Three Columns":{
  "prefix": ["\\columns (3)", "\\threecolumns"],
  "body": [
    "\\begin{columns}",
      "\t\\begin{column}[T]{0.31\\textwidth}",
        "\t\t$TM_SELECTED_TEXT$1",
      "\t\\end{column}",
      "\t\\hfill",
      "\t\\begin{column}[T]{0.31\\textwidth}",
        "\t\t$2",
      "\t\\end{column}",
      "\t\\hfill",
      "\t\\begin{column}[T]{0.31\\textwidth}",
        "\t\t$3",
      "\t\\end{column}",
    "\\end{columns}",
    "$0"
  ]
},
"Four Columns":{
  "prefix": ["\\columns (4)", "\\fourcolumns"],
  "body": [
    "\\begin{columns}",
      "\t\\begin{column}[T]{0.23\\textwidth}",
        "\t\t$TM_SELECTED_TEXT$1",
      "\t\\end{column}",
      "\t\\hfill",
      "\t\\begin{column}[T]{0.23\\textwidth}",
        "\t\t$2",
      "\t\\end{column}",
      "\t\\hfill",
      "\t\\begin{column}[T]{0.23\\textwidth}",
        "\t\t$3",
      "\t\\end{column}",
      "\t\\hfill",
      "\t\\begin{column}[T]{0.23\\textwidth}",
        "\t\t$4",
      "\t\\end{column}",
    "\\end{columns}",
    "$0"
  ]
},
"Full-width Minipage (no page breaks)":{
  "prefix": ["\\minipage", "\\nopagebreak"],
  "body": [
    "\\begin{minipage}{\\linewidth}%",
      "\t\\centering",
      "\t$TM_SELECTED_TEXT$0",
    "\\end{minipage}%"
  ]
},
// Insert columns
"Two Columns (Minipages)":{
  "prefix": ["\\minipage columns (2)","\\twominipages"],
  "body": [
    "\\begin{minipage}{0.49\\linewidth}%",
      "\t\\centering",
      "\t$TM_SELECTED_TEXT$1",
    "\\end{minipage}%",
    "\\hfill",
    "\\begin{minipage}{0.49\\linewidth}%",
        "\t\\centering",
        "\t$2",
    "\\end{minipage}%",
    "$0"
  ]
},
"Two Columns (Table)":{
  "prefix": ["\\table columns (2)","\\twocolumntable"],
  "body": [
    "\\begin{center}",
        "\t\\begin{tabular}{p{0.47\\linewidth}p{0.47\\linewidth}}",
          "\t\t$TM_SELECTED_TEXT$1 & $0",
        "\t\\end{tabular}",
    "\\end{center}"
  ]
},
"Three Columns (Table)":{
  "prefix": ["\\table columns (3)","\\threecolumntable"],
  "body": [
    "\\begin{center}",
        "\t\\begin{tabular}{p{0.31\\linewidth}p{0.31\\linewidth}p{0.31\\linewidth}}",
          "\t\t$TM_SELECTED_TEXT$1 & $2 & $0",
        "\t\\end{tabular}",
    "\\end{center}"
  ]
},
"Four Columns (Table)":{
  "prefix": ["\\table columns (4)","\\fourcolumntable"],
  "body": [
    "\\begin{center}",
      "\t\\begin{tabular}{p{0.23\\linewidth}p{0.23\\linewidth}p{0.23\\linewidth}p{0.23\\linewidth}}",
          "\t\t$TM_SELECTED_TEXT$1 & $2 & $3 & $0",
        "\t\\end{tabular}",
    "\\end{center}"
  ]
}
...

Beamer Slides

...
// ======== BEAMER ==========
"Beamer Frame":{
  "prefix": ["\\frame", "\\begin{frame}"],
  "body": [
    "\\begin{frame}{${1:title}}",
    "\t$TM_SELECTED_TEXT$0",
    "\\end{frame}"
  ]
},
"Beamer Frame (Top aligned)":{
  "prefix": ["\\frametop", "\\begin{frame}[t]", "frame top"],
  "body": [
    "\\begin{frame}[t]{${1:title}}",
    "\t$TM_SELECTED_TEXT$0",
    "\\end{frame}"
  ]
},
"Structure":{
  "prefix": ["\\structure"],
  "body": [
    "\\structure{$TM_SELECTED_TEXT$1}$0"
  ]
},
"Structure (Math)":{
  // Requires "\newcommand{\mstructure}[1]{{\color{structure} #1}}"
  "prefix": ["\\mstructure", "\\structure (math)"],
  "body": [
    "\\mstructure{$TM_SELECTED_TEXT$1}$0"
  ]
},
"Only Exist on Slide":{
  "prefix": "\\only",
  "body": "\\only<${1:overlay specification}>{$TM_SELECTED_TEXT$0}"
},
"Only Exist on Slide (Block)":{
  "prefix": "\\onlyblock",
  "body": [
    "\\only<${1:overlay specification}>{%",
      "\t$TM_SELECTED_TEXT$0", 
    "}% End only block"
  ]
},
"Only Shown on Slide":{
  "prefix": "\\onslide",
  "body": "\\onslide<${1:overlay specification}>{$TM_SELECTED_TEXT$0}"
},
"Only Shown on Slide (Block)":{
  "prefix": "\\onslideblock",
  "body": [
    "\\onslide<${1:overlay specification}>{%",
      "\t$TM_SELECTED_TEXT$0", 
    "}% End only block"
  ]
},
"Pause After Itemize or <+->":{
  "prefix": ["\\pauseafter<+->", "\\pauseAfterItemize"],
  "body": [
    "\\pause[\\thebeamerpauses]",
    "$0"
  ]
}

Snippets for VS Code Multi-cursor

One feature of VS Code that includes Here are some snippets that can be used in any language.

To set global snippets, for all languages:

1. Open the command pallet (CTRL+SHIFT+P by default on Windows).
2. Type and select Snippets: Configure Snippets.
3. Select all_languages.json.code-snippets (global).

I have two groups of snippets. One group contains snippets for inserting enumerations when using multi-cursors and the other group has snippets for inserting duplicated information (producing multi-cursors).

"Cursor index (starts at 0)":{
  "prefix": ["\\cursorindex", "\\ndx"],
  "body" : ["$CURSOR_INDEX"]
},
"Cursor number (starts at 1)":{
  "prefix": ["\\cursornum", "\\num"],
  "body" : ["$CURSOR_NUMBER"]
},
"Cursor uppercase Alphabet (A, B, C, ..., I)":{
  "prefix": ["\\cursorAlph", "\\Alph"],
  "body" : ["${CURSOR_NUMBER/(^1$)?(^2$)?(^3$)?(^4$)?(^5$)?(^6$)?(^7$)?(^8$)?(^9$)?(^10$)?(^11$)?(^12$)?(^13$)?(^14$)?(^15$)?(^16$)?(^17$)?(^18$)?(^19$)?(^20$)?(^21$)?(^22$)?(^23$)?(^24$)?(^25$)?(^26$)?/${1:+A}${2:+B}${3:+C}${4:+D}${5:+E}${6:+F}${7:+G}${8:+H}${9:+I}${10:+J}${11:+K}${12:+L}${13:+M}${14:+N}${15:+O}${16:+P}${17:+Q}${18:+R}${19:+S}${20:+T}${21:+U}${22:+V}${23:+W}${24:+X}${25:+Y}${26:+Z}/}"]
},
"Cursor lowercase alphabet (a, b, c, ..., i)":{
  "prefix": ["\\cursoralph", "\\alph"],
  "body" : ["${CURSOR_NUMBER/(^1$)?(^2$)?(^3$)?(^4$)?(^5$)?(^6$)?(^7$)?(^8$)?(^9$)?(^10$)?(^11$)?(^12$)?(^13$)?(^14$)?(^15$)?(^16$)?(^17$)?(^18$)?(^19$)?(^20$)?(^21$)?(^22$)?(^23$)?(^24$)?(^25$)?(^26$)?/${1:+a}${2:+b}${3:+c}${4:+d}${5:+e}${6:+f}${7:+g}${8:+h}${9:+i}${10:+j}${11:+k}${12:+l}${13:+m}${14:+n}${15:+o}${16:+p}${17:+q}${18:+r}${19:+s}${20:+t}${21:+u}${22:+v}${23:+w}${24:+x}${25:+y}${26:+z}/}"]
},
"Cursor lowercase Roman (i, ii, iii, ..., xx)":{
  "prefix": ["\\roman", "\\cursorroman"],
  "body" : ["${CURSOR_NUMBER/(^1$)?(^2$)?(^3$)?(^4$)?(^5$)?(^6$)?(^7$)?(^8$)?(^9$)?(^10$)?(^11$)?(^12$)?(^13$)?(^14$)?(^15$)?(^16$)?(^17$)?(^18$)?(^19$)?(^20$)?/${1:+i}${2:+ii}${3:+iii}${4:+iv}${5:+v}${6:+vi}${7:+vii}${8:+viii}${9:+ix}${10:+x}${11:+xi}${12:+xii}${13:+xiii}${14:+xiv}${15:+xv}${16:+xvi}${17:+xvii}${18:+xviii}${19:+xix}${20:+xx}/}"]
},
"Cursor uppercase Roman (I, II, III, ..., XX)":{
  "prefix": ["\\Roman", "\\cursorRoman"],
  "body" : ["${CURSOR_NUMBER/(^1$)?(^2$)?(^3$)?(^4$)?(^5$)?(^6$)?(^7$)?(^8$)?(^9$)?(^10$)?(^11$)?(^12$)?(^13$)?(^14$)?(^15$)?(^16$)?(^17$)?(^18$)?(^19$)?(^20$)?/${1:+I}${2:+II}${3:+III}${4:+IV}${5:+V}${6:+VI}${7:+VII}${8:+VIII}${9:+IX}${10:+X}${11:+XI}${12:+XII}${13:+XIII}${14:+XIV}${15:+XV}${16:+XVI}${17:+XVII}${18:+XVIII}${19:+XIX}${20:+XX}/}"]
}

// Duplicated text entry with multi-cursors.
"2x":{
  "prefix": ["\\2x"],
  "body" : ["${1:$TM_SELECTED_TEXT}${4:, }$1$0"]
},
"3x":{
  "prefix": ["\\3x"],
  "body" : ["${1:$TM_SELECTED_TEXT}${2:, }$1${2:, }$1$0"]
},
"4x":{
  "prefix": ["\\4x"],
  "body" : ["${1:$TM_SELECTED_TEXT}${2:, }$1${2:, }$1${2:, }$1$0"]
},
"5x":{
  "prefix": ["\\5x"],
  "body" : ["${1:$TM_SELECTED_TEXT}${2:, }$1${2:, }$1${2:, }$1${2:, }$1$0"]
},
"6x":{
  "prefix": ["\\6x"],
  "body" : ["${1:$TM_SELECTED_TEXT}${2:, }$1${2:, }$1${2:, }$1${2:, }$1${2:, }$1$0"]
},
"7x":{
  "prefix": ["\\7x"],
  "body" : ["${1:$TM_SELECTED_TEXT}${2:, }$1${2:, }$1${2:, }$1${2:, }$1${2:, }$1${2:, }$1$0"]
},
"nx":{
  "prefix": ["\\nx"],
  "body" : ["${1:$TM_SELECTED_TEXT}1${5:, }${1}2${5}${2|\\cdots,\\vdots,\\dots|}${5}${1}${6:n}$0"]
}

LaTeX Development

This section contains info about setting up VS Code for development of LaTeX packages or classes. I don’t expect the suggestions to be useful if you are just writing documents in LaTeX without writing your own packages or classes.

Code Spell Extension

When writing LaTeX packages or classes, it is nice to have a spell checker that is designed for code rather than documents. The Code Spell extension serves this purpose. In contrast to LTeX+, Code Spell will check variable names that are formed from the conjunction of multiple words such as is_ready or MyVariable, and allows for defining language specific dictionaries to avoid false positives when you use predefined names such as includegraphics in LaTeX.

My LaTeX dictionary (incomplete) is available here. To create the dictionary file, you can use the Command Spell: Create a Custom Dictionary in the VS Code Command Pallet (CTRL + SHIFT + P or CMD + SHIFT + P, by default).

My Code Spell settings in settings.json are shown here:

"cSpell.customDictionaries": {
  "latex": {
      "addWords": true,
      "name": "latex",
      "path": "C:/path/to/dictionary/latex.txt",
      "scope": "user"
  },
  "custom": true, // Enable the `custom` dictionary
},
"cSpell.languageSettings": [
  {
    "dictionaries": [
        "latex"
    ],
    "languageId": ["tex", "latex-expl3"]
  },
],
// Add names and other words to the dictionary 
// that are specific to your work, but not language specific.
"cSpell.userWords": [
  "Wintz",
  // ...
]

Conclusion

Using VS Code for LaTeX development can be highly efficient with the right tools and configurations. By integrating extensions like LaTeX Workshop, LTeX+, and Paste Image, alongside structured project organization, you can significantly streamline your workflow. Explore these configurations to tailor a setup that works best for you!

In this post, I will describe the setup I use for theorem-type environments in LaTeX (includes theorems, definitions, etc.).

A basic example of the code and output for a Theorem in a LaTeX document is shown here:

\begin{theorem}[Pythagorean]
  For a right triangle with sides $a$ and $b$, 
  and hypotenuse $c,$
  \[ a^2 + b^2 = c^2. \]
\end{theorem}

The remainder of this document shows how to

• Setup the amsthm, hyperref, and cleveref packages for inserting and referencing Theorems, Definitions, and the like.
• Modify the style of Theorem environments to use slanted text instead of italics to improve readability in certain fonts (most notably, Times New Roman).
• Modify the QED mark or “Halmos Tombstone” (i.e., “$\square$”) that appears at the end of proofs and other environments.
• Define new theorem-like environments.
• Change the Theorem numbering scheme to include the chapter numbers.
• Create unnumbered theorem environments.
• Insert proofs, including modifying the introductory “Proof.” and moving the QED mark.

Packages

amsthm Package

The amsthm package defines macros and environments for creating theorem-like environments.

\usepackage{amsthm}

hyperref Package

The hyperref package provides hyperlinking. When hyperref is loaded, all references to theorem-like environments (inserted using \ref or \cref) automatically include links to the location where the environment is displayed. You will likely want to modify some of the hyperref options.

% Enable hyperlinks
\usepackage{hyperref}
\hypersetup{
    final,                   % Include links even if document is in 'draft' mode.
    hidelinks,               % Prevent boxes from being drawn around links in some viewers.
    breaklinks=true,         % Allow line breaks in the middle of links
    colorlinks=true,
    linkcolor=black,         % TOC, links to labeled equations and environments
    urlcolor=black!30!blue,  % URLS including links in references  
    anchorcolor=blue,        % I'm not sure what this does.
    citecolor=black!30!blue, % In-line citations  
}

cleveref Package

The cleveref package defines the \cref macro for inserting internal references to labeled object. In contrast to \ref, \cref inserts the type of environment referenced, so a reference \cref{my first theorem} will appear as “Theorem 1”, whereas \ref{my first theorem} only appears as “1”.

% Display "Theorem 1", "Lemma 2", etc. in cross references.  
% It's important to load this last after all the other packages!
\usepackage[
    noabbrev,   % E.g., "Figure" instead of "Fig."
    capitalise, % E.g., "Figure" instead of "figure"
    nameinlink  % Make "Figure 1" linked instead of just "1".
  ]{cleveref} 

Changing Theorem Body Text From Italic To Slanted

By default, the body amsthm theorem environments are italicized. I find large chunks of italic text hard to read, so I create and use a different theorem style that uses slanted text instead. This way, theorems are differentiated from surrounding text without compromising readability.

% Create a new amsthm theorem style that uses slanted text 
% instead of italics. I find this makes the text easier to read.
% See https://tex.stackexchange.com/a/417959/153678.
\usepackage{amssymb} % Provides \slshape
\newtheoremstyle{sltheorem}
                {}          % Space above
                {}          % Space below
                {\slshape}  % Body font
                {}          % Indent amount
                {\bfseries} % Head font
                {.}         % Punctuation after head
                { }         % Space after theorem head
                {}          % Theorem head spec
% Enable the new "sltheorem" theorem style.
\theoremstyle{sltheorem}

Discouraging Page Breaks in Theorems

By default, LaTeX will insert page breaks into the middle of a theorem statement just as readily as anywhere else in the document. This leads to unfortunate cases where one or two lines are on a separate page. LaTeX visual processor decides where to insert page breaks by a collection of penalties, with the goal of total minimizing the sum of the penalties. Thus, to discourage LaTeX from putting page breaks in a theorem, we can increase the penalties for page breaks between lines, and before and after display equations, which are stored in these macros:

\interlinepenalty   % Page break between lines.
\predisplaypenalty  % Page breaks before a display equation.
\postdisplaypenalty % Page break after equations.

To check the default values of these penalties, you can print them in your document by prefixing each macro with \the, such as,

  interlinepenalty=\the\interlinepenalty  \\
 predisplaypenalty=\the\predisplaypenalty \\
postdisplaypenalty=\the\postdisplaypenalty

For the document I used to the above code, the results were interlinepenalty=0, predisplaypenalty=10000, and postdisplaypenalty=0.

To modify the penalties use the syntax \interlinepenalty=<whole number>. You don’t want to manually set the penalties within in each theorem, however, so use a theorem style to set the values, as follows:

\newtheoremstyle{breakResistantTheorem}
     {}          % Space above
     {}          % Space below
     {%          % Theorem body font (default is "\upshape")
         \interlinepenalty=100%    Discourage breaking between lines.
         \predisplaypenalty=10000% Never break right before a display equation.
         \postdisplaypenalty=100%  Discourage breaking after equations.
         \slshape% Use slanted font for Theorem body
     }           
     {}          % Indent amount
     {\bfseries} % Theorem head font % (default is \mdseries)
     {.}         % Punctuation after theorem head % default: no punctuation
     { }         % Space after theorem head
     {}          % Theorem head spec

My initial testing has shown that these penalties value seem to work well, but you can increase them if you find LaTeX is still inserting page breaks in theorems more often then you like or decrease them if your document ends up with a lot of extra vertical space. The range of valid penalties are 0 (no penalty) to 10000 (max penalty).

After creating the new theorem style, you must enable it before using \newtheorem, namely,

\theoremstyle{breakResistantTheorem}
\newtheorem{theorem}{Theorem}
\newtheorem{lemma}{Lemma}
% etc...

Custom QED Marks at End of Environments

For long environments that are in upright font, I prefer to include a mark at the end of the environment to notify readers where the section ends. The following command, \setEnvironmentQed allows for defining the QED-like symbol to automatically insert at the end of all environments of a given type. For example, \setEnvironmentQed{definition}{\ensuremath{\blacksquare}} causes a black square to be inserted at the end of every definition environment.

% Define a macro for changing the QED symbol at the
% end of environments. This command allows for the
% use of \qedhere to insert the QED into, e.g., 
% equations or lists. 
\newcommand{\setEnvironmentQed}[2]{
  % #1: Environment name
  % #2: QED Symbol. Must be OK in text or math mode. 
  %     Use \ensuremath, if math is desired.
  \AtBeginEnvironment{#1}{%
    \pushQED{\qed}\renewcommand{\qedsymbol}{#2}%
  }
  \AtEndEnvironment{#1}{\popQED}
}

Here are several options for symbols that can be used to end environments:

Environment Definitions

\providetheorem definition

In my LaTeX setup, I prefer to use the same preamble file for all of my documents, but I’ve found that some document classes or packages define the theorem environment and other related environments, which causes compilation errors. To avoid errors when trying to define to new theorem-like environments, \providetheorem first checks whether the environment is defined.

% Create a new macro analogous to "\providecommand", which 
% defines the given amsthm theorem-like environment only if 
% it does not already exist.
\newcommand{\providetheorem}[2]{
  % #1: Environment name.
  % #2: Display name
  \ifcsdef{#1}{
    % The #1 environment is already defined. 
    \ifcsdef{end#1}{}{
      \PackageError{providetheorem}{%
        % Error message:
        The command "#1" was already defined, but "#1end" was 
        undefined, indicating that "#1" is not an environment.
      }{}
    }
  }{
    % The #1 environment is not defined, yet, so we define it.
    \newtheorem{#1}{#2}
  }
}

Theorem Style

There are three default theorem styles: plain, definition, and remark, but I have replaced the plain style with sltheorem to use slanted text instead of italics.

The sltheorem (or plain) style displays a boldface label and slanted (or italic) body text.

\begin{theorem}[Pythagorean Theorem]
  \label{result:pythagorean}
  The sum of the squares of the legs of a right 
  triangle equals the square of the hypotenuse.
\end{theorem}

I use the theorem style for any environments that make truth claims, namely theorem, proposition, lemma, corollary, and conjecture.

%%--------------------------------------------------%%
%| Define environments that use the sltheorem style |%
%%--------------------------------------------------%%
\theoremstyle{sltheorem}%

%%% Define theorem environment %%%
\providetheorem{theorem}{Theorem}
\crefname{theorem}{Theorem}{Theorems}%

%%% Define proposition environment %%%
\providetheorem{proposition}{Proposition}
\crefname{proposition}{Proposition}{Propositions}%

%%% Define lemma environment %%%
\providetheorem{lemma}{Lemma}
\crefname{lemma}{Lemma}{Lemmas}%

%%% Define corollary environment %%%
\providetheorem{corollary}{Corollary}
\crefname{corollary}{Corollary}{Corollaries}%

%%% Define conjecture environment %%%
\providetheorem{conjecture}{Conjecture}
\crefname{conjecture}{Conjecture}{Conjectures}%

Definition Style

The definition style displays a boldface label and upright body text.

\begin{definition}
  \label{def:ring center}
  Let $R$ be a ring.
  The \emph{center} of $R$ is the subring of $R$ 
  that contains all elements $c \in R$ such that 
  $c x = x c$ for every $x$ in $R$.
\end{definition}

I use the definition style define the following environments: definition, problem, example, and assumption.

%%---------------------------------------------------%%
%| Define environments that use the definition style |%
%%---------------------------------------------------%%
\theoremstyle{definition}%

%%% Define definition environment %%%
\providetheorem{definition}{Definition}
\crefname{definition}{Definition}{Definitions}%

%%% Define problem environment %%%
\providetheorem{problem}{Problem}
\crefname{problem}{Problem}{Problems}%

%%% Define example environment %%%
\providetheorem{example}{Example}

% Add a mark at the end of each example.
\setEnvironmentQed{example}{\ensuremath{\blacksquare}}

%%% Define assumption environment %%%
% Note: We use singular "Assumption" even when there are 
% multiple assumptions within a particular block.
\providetheorem{assumption}{Assumption}
\crefname{assumption}{Assumption}{Assumptions}

% Add a mark at the end of each assumption.
\setEnvironmentQed{assumption}{\ensuremath{\blacksquare}}

In definitions, you should emphasize the defined term to make it stand out. The preferred way to do this is to surround the term with \emph{}, which will typically typeset the text in italics. Unlike \textit{}, however, the \emph macro will switch to upright text if the surrounding text is already italicized, ensuring that the term highlighted even if you use italic text in your definition environments.

Remark Style

The remark style displays an italic label and upright body text.

\begin{remark}
  Here is a remark.
\end{remark}

I use the remark style only for the remark environment.

%%-----------------------------------------------%%
%| Define environments that use the remark style |%
%%-----------------------------------------------%%
\theoremstyle{remark}%

%%% Define remark environment %%%
\providetheorem{remark}{Remark}

Theorem-like Environment Numbering

This section describes how to modify the automatic numbering of Theorem-like environments, such as using unified numbering for multiple types of environments, chapter-based numbering, and using no numbering at all.

Unified Numbering of Different Environment Types

Some authors prefer to use one counter for all the results in their document, so instead of

• Theorem 1
• Theorem 2
• Lemma 1
• Theorem 3
• Proposition 1

the numbering would be

• Theorem 1
• Theorem 2
• Lemma 3
• Theorem 4
• Proposition 5

The benefit of this method is that it is easier for the reader navigate to a particular result via bisection, but it may confuse readers who try to find “Lemma 1” and “Lemma 2”.

To make LaTeX use a unified numbering, you create the first environment, such as theorem, and then pass the name theorem as an optional argument when creating the other environments:

\newtheorem{theorem}{Theorem}
\newtheorem{lemma}[theorem]{Lemma}
\newtheorem{proposition}[theorem]{Proposition}
%                          ^--- optional argument.

Chapter-based Numbering

For document classes that use chapters, I prefer to number the theorem-like environments on a chapter-by-chapter basis (e.g., “Theorem 1.1”, “Theorem 1.2” in Chapter 1 and “Theorem 2.1”, “Theorem 2.2” in Chapter 2.) The following code automatically enables chapter-based numbering when the chapter counter is defined.

\ifcsname thechapter\endcsname
    % If the document class uses chapters, 
    % then update numbering to use chapters.
    \numberwithin{assumption}{chapter}
    \numberwithin{definition}{chapter}
    \numberwithin{remark}{chapter}
    \numberwithin{example}{chapter}
    \numberwithin{proposition}{chapter}
    \numberwithin{theorem}{chapter}
    \numberwithin{lemma}{chapter}
    \numberwithin{corollary}{chapter}
    \numberwithin{conjecture}{chapter}
    \numberwithin{application}{chapter}
\fi

Unnumbered Environments

In some contexts, such as presentations, you may wish to use unnumbered environments (e.g., “Theorem” instead “Theorem 1”). To omit theorem numbering, define theorem environments using \newtheorem* macro instead of \newtheorem. If you already have theorem defined, you must use a different name for the unnumbered theorem environment, such as theorem*.

\newtheorem*{theorem*}{Theorem}

It is a bad idea, however, to have mixture of numbered and unnumbered theorems in the same document, so you may wish to simply replace \newtheorem{theorem}{Theorem} with \newtheorem*{theorem}{Theorem} so that \begin{theorem}...\end{theorem} inserts unnumbered theorems.

Proof Environment

The amsthm package also defines a proof environment. I’ve found the default definition to be exactly how I want it, with a white square inserted at the end of the proof.

The usage is as follows:

\begin{proof}
  It is true because I say so.
\end{proof}

You can change the “proof” label by using an optional environment argument.

\begin{proof}[Proof Sketch]
  This example is too small to contain the proof.
\end{proof}

Using the optional argument is particularly useful if a theorem and its proof are separated by other text:

\begin{proof}[Proof of \cref{result:an earlier theorem}]
  This proof does not occur immediately 
  after \cref{result:an earlier theorem}.
\end{proof}

Note that the QED symbol in above example appears at the end of the next line because the first line fills the text width.

If the proof ends with an equation or a list, then the QED symbol will be placed below the equation or list, even if there is space to the side, which wastes space and looks bad:

\begin{proof}
  The conclusion follow directly from this equation:
  \[
    1 + 1 = 2.
  \] 
\end{proof}

To fix this problem, place \qedhere inside the equation or list (at the end) to display the QED symbol at the correct location:

\begin{proof}
  The conclusion follow directly from this equation:
  \[
    1 + 1 = 2. \qedhere
  \] 
\end{proof}

Displaying Environment Labels in the Margin

When working on a draft, it is convenient to have the labels assigned to an theorem-like environment (via \label) in the document itself.
To show these labels, along with labels for equations, figures, tables, and whatnot, use the showlabels package. By default, showlabels displays each label in the right margin with somewhat unfortunate formatting. In particular, labels use inconsistent text weight (some labels are bold while others are not)and long labels extend off the page, without line breaks, even between words.

The following configuration fixes all of these problems by showing each label using a small teletype font in a box that is the width of the right margin, with line breaks after words, as needed. Some extra care is taken to avoid warnings from underfull and overfull boxes.

\usepackage[right]{showlabels}
% Using "\upshape" ensures that the label is displayed without italics (e.g., if inside a theorem), and "\ttfamily" displays label with a    font, since it is essentially code.
\renewcommand{\showlabelfont}{\scriptsize\upshape\ttfamily}
\renewcommand{\showlabelsetlabel}[1]{%
  % We use 95% of the marginparwidth because it looks slightly nicer to not have the box extend to the edge of the page.
  % "\raggedright" prevents underfull hbox warnings when the label doesn't fit nicely in a line.
  \fbox{\parbox{0.95\marginparwidth}{%
    \raggedright% Prevent underfull box warnings.
    \hfuzz=1000em% Prevent overfull box warnings (unless more than 1000em too wide!) 
    \showlabelfont #1}}%
}

The result looks like this:

Of course, the labels should typically be hidden from the final version of the document (e.g., before publication). Fortunately, showlabels automatically hides the labels when the document is compiled with the final option passed to the document class, such as

\documentclass[final]{article}

Even simple equations can be difficult to put into words accurately. One example is the use of parentheses to indicate grouping. Consider the equation,

A naive translation into English would lose the groupings imposed by the parentheses: “a times b plus c equals one over b plus c”. Indeed, this sentence erroneous translation indicates a different equation:

This example illustrates how a speaker must be careful to indicate the groupings in their speech. It is not self-evident how to do this and the remainder of this document describes how to translate specific mathematical expressions into English. For this example, a precise translation is “a times the sum of b plus c equals one over the sum of b plus c”.

Math to English Translation Recipes

This section contains recipes for how to translate from various mathematical expressions into English. Since any mathematical expression can be translated multiple ways, several translations are given in the right column of each table.

Parentheses and Grouping

Sets

Calculus

Linear Algebra

This is document is a work in progress that will continue to grow as I find examples that are worthy of inclusion. If you have suggestions, please contact me.

For more on this topic, see “How can we speak math?” by Richard Fateman.

In dynamical systems and mathematical control theory, it is often useful to show that a given function has a particular sign for all inputs in given sets. For example, given $f : \realsn \to \reals$ and $S\subset \realsn$, we may want to show $f(x) \geq 0$ for all $x \in S$. Prominent examples include Lyapunov functions, which are used to prove stability, and barrier functions which are used to prove set invariance.

As a simple example, consider a dynamical system with state vector \(x \in \realsn\), vector field \(f : \realsn \to \realsn\), and dynamics given by

\begin{equation} \label{eq:ode} \dot x = f(x). \end{equation}

Suppose we want to show that the origin \(0 \in \realsn\) is stable for (\ref{eq:ode}). Roughly speaking, this means that all solutions that start near the origin remain near it for all time. A common approach to show stability is to pick a neighborhood \(U\) of the origin and construct a differentiable function $V : U \to \reals$, called a Lypunov function that satisfies the following criteria:

1. $V(0) = 0$
2. $V(x) > 0 $ for all $x \in U $ such that $x \neq 0 $
3. $\dot V(0) = 0$
4. $\dot V(x) \leq 0$ for all $x \in U $ such that $x \neq 0 $

where \(\dot V(x)\) is the rate of change of \(V(x(t))\) as \(t \mapsto x(t)\) evolves according to (\ref{eq:ode}). The existence of a Lyapunov function proves that the origin is stable [1, Theorem 4.1].

Constructing a Lyapunov is often difficult because it requires finding a function that satisfies multiple inequalities at every point in a set, and the inequalities depend on the function itself, its derivative, and the dynamics of the system. The purpose of this page is to introduce sum-of-squares (SOS) programming, which can be used to automatically generate Lyapunov functions and solve other similar problems.

Remark. There are actually many different variants of Lyapunov functions for showing…

• …different types of stability (asymptotic, input-to-state, global, etc.),
• …the stability of some set \(\mathcal A \subset \realsn\) rather than the single point at the origin
• …stability in continuous-time, discrete-time, and hybrid systems.

Most of these variants can be handled by SOS programming, so long as the data of the system are given in terms of polynomials.

Mathematical Fundamentals

The basis for SOS programming lies in the following fact: For any function $f : \realsn \to \reals,$ let $f^2$ indicate the function $x \mapsto (f(x))^2$. Then, for any choice of functions \(f_1,\ f_2,\ \dots,\ f_N : \realsn \to \reals\),

and the sum is zero if and only if \(f_1(x) = f_2(x) = \cdots = f_N(x) = 0.\)

Working with general functions is difficult, so we restrict the choices for \(f_1,\ f_2,\ \dots,\ f_N\) to polynomials. In particular, we allow for multivariate polynomials, such as $(x, y) \mapsto x^2 + xy + 3y^2 $ or $(x, y, z) \mapsto 1 + x^3 - 2xyz^2$.

We say that a polynomial \(p : \reals^n \to \reals\) is a sum of squares if there exist polynomials \(p_1, p_2, \dots, p_m : \reals^n \to \reals\) such that

\begin{equation} \label{eq:sos} p(x) = \sum_{i=1}^m p_i^2(x). \end{equation}

Note that the argument $x$ for $p$ is a vector $x \in \realsn$, so we may write it as $x = (x_1, x_2, \dots, x_n)$. We denote the set of all SOS polynomials over $x$ by $\SOSpolys[x]$ or $\SOSpolys[x_1, x_2, \dots, x_n]$. (This notation is used in [2], but there does not appear to be a prevailing standard. Other notations used in the literature include $\mathscr{P}^{\mathup{SOS}}$ [3], and simply $\mathup{SOS}$.)

To solve problems using SOS polynomials, we need to put problems into a standard problem format, described in the next section, which can be solved algorithmically using a computer.

SOS Optimization Problem Formulation

In general, an SOS optimization problem (also called an SOS program) has a linear cost function and one or more SOS constraints—that is, the constraints of the optimization problem require that certain polynomials are sums of squares.

To give a general formulation of an SOS problem, we denote the decision variables as $u = (u_1, u_2, \dots, u_n) \in \reals^m$. The linear cost function is defined by $c^\top u$ for some vector $c\in \reals^m$. To specify an SOS problem with $N$ constraints requires picking $N(m+1)$ polynomials, which we write $p_{i,j}$ for $i = 1, 2, \dots, N$ and $j = 0, 1, \dots, m$. An SOS problem is then written

Thus, a solution to (\ref{eq:sos program}) is a vector $u^*\in\reals^m$ that minimizes $c^\top u^*$ while satisfying the requirement that for each $i = 1, 2, \dots, N$, the function

is a sum of squares.

Remark. At this point, you might be concerned about how to compute a solution to (\ref{eq:sos program}). It turns out that (\ref{eq:sos program}) can be reformulated into a semidefinite program (SDP), which is a type of convex optimization problem that can be efficiently and reliably solved using numerical solvers (assuming a solution exists). We plan to describe how to solve SOS problems in a later post.

Example: Lyapunov Function

Consider a 2D continuous-time dynamical system with state vector $x = (x_1, x_2) \in \reals^2$ and dynamics given by

We can guess the form of a Lyapunov function to be

where each $p_i$ is a polynomial function. Picking $m$ and each $p_i$ is typically a process of trial and error using intuitive guesses based on the structure and complexity of the problem. We will use $m = 3$ and

Therefore, the general form of $V$ is \(V(x) = u_1 x_1^2 + u_2 x_2^2 + u_3 x_1x_2.\) Calculating $\dot V,$ we find

We want $V$ to be positive definite relative to the origin, so it is necessary that $V(x) \in \SOSpolys[x]$, but this is not sufficient because an SOS polynomial can be only positive semidefinite rather than positive definite. You can add constraints on $u_1$, $u_2$, and $u_3$ to ensure $V$ is positive definite. The simplest choice is to require that $u_1$ and $u_2$ are positive and $u_3$ is zero, so $V$ is a bowl shaped function:

The constraints are then,

For numerical reasons, strict inequalities don’t work well in optimization problems, we instead pick some $\epsilon > 0$ and change the constraints to

Rewriting these constraints using matrices, we have

Becuase we won’t know a good choice of $\epsilon$ beforehand, we can make it one of the decision variables and make the cost function $(u, \epsilon) \mapsto \epsilon$ so that the optimizer tries to find the largest value of $\epsilon$ such that the problem has solution. We must check the value of $\epsilon$ for the solution to the optmization problem to ensure $\epsilon > 0$.

An unfortunate side effect of this choice is that it removes a degree of freedom by setting $u_3=0$. This can be avoided by instead partitioning $V$ into the sum of a positive semidefinite function and a positive definite function, such as

The corresponding constraints are then

Conversely, we want $\dot V$ to be negative semidefinite relative to the origin. Thus,

Therefore, the SOS problem formulation is

Definitions of positive definite and positive semidefinite functions.

A function \(f : \realsn \to \reals\) is said to be positive semi-definite if

and \(f(0) = 0.\)

A function \(f : \realsn \to \reals\) is said to be positive definite if

and \(f(0) = 0.\)

Negative semidefinite and negative definite functions are defined similarly, except with the inequality signs flipped.

Example. The parabola \(x \mapsto x^2\) is positive definite.

Non-example. The parabola \(x \mapsto x^2 + 1\) is not positive definite because the value at \(x=0\) is \(1\).

Non-example. In two variables, the function \((x, y) \mapsto x^2\) is not positive definite because the value at \((0, 1)\) is \(0\).

Further Reading

• [4] gives an introduction to SOS programming targeted at a non-technical audience.
• [5] provides a way to generate control barrier functions for control-affine feedback systems.
• [6] describes how to use sum of squares programming to generate barrier functions barrier functions for hybrid systems.
• [7] introduces a way to simplify complicated systems with multiple components so that barrier functions can be found for individual subcomponents separately.
• [3] introduces techniques that allow for synthesizing better barrier functions.
• [8] contains links to various tools for working with SOS’s in various programming languages.

Bibliography

1. [1] H. K. Khalil, Nonlinear Systems, Third. Pearson, 2014.
2. [2] M. M. Tobenkin, I. R. Manchester, and R. Tedrake, “Invariant Funnels around Trajectories using Sum-of-Squares Programming,” IFAC Proceedings Volumes, vol. 44, no. 1, pp. 9218–9223, Jan. 2011, doi: 10.3182/20110828-6-IT-1002.03098.
3. [3] L. Wang, D. Han, and M. Egerstedt, “Permissive barrier certificates for safe stabilization using sum-of-squares,” in Proceedings of the 2018 American Control Conference, Jun. 2018, pp. 585–590. doi: 10.23919/ACC.2018.8431617.
4. [4] Kevin Hartnett, “A Classical Math Problem Gets Pulled Into the Modern World,” Quanta Magazine, May 2018, Accessed: August 28, 2023. [Online ]. Available at: https://www.quantamagazine.org/a-classical-math-problem-gets-pulled-into-the-modern-world-20180523/
5. [5] Y. Duan and X. Zeng, “Computational synthesis of control barrier functions with applications in automotive lane keeping supervisory control,” IET Control Theory & Applications, vol. n/a, no. n/a, 2023, doi: 10.1049/cth2.12422.
6. [6] S. Prajna and A. Jadbabaie, “Safety verification of hybrid systems using barrier certificates,” in Hybrid Systems: Computation and Control, R. Alur and G. J. Pappas, Eds., in Lecture Notes in Computer Science. Berlin, Heidelberg: Springer, 2004, pp. 477–492. doi: 10.1007/978-3-540-24743-2_32.
7. [7] C. Sloth, R. Wisniewski, and G. J. Pappas, “On the existence of compositional barrier certificates,” in Proceedings of the 51st IEEE Conference on Decision and Control, Dec. 2012, pp. 4580–4585. doi: 10.1109/CDC.2012.6426178.
8. [8] “Getting started with Sum of Squares.” Accessed: March 13, 2023. [Online ]. Available at: https://sums-of-squares.github.io/sos/

Example:

Here is \added{added}, \deleted{deleted} 
and \replaced{replaced}{replaysed} text.
\comment{Maybe I shouldn't have written this?}
\todo[inline]{To-do: Write something worthwhile.}

Output:

Workflow

In order for annotations to be useful they must be up-to-date. This raises the question of when to remove annotations. The best workflow depends on the way your reviewer gives feedback. If your reviewer will read the entire document, then you can delete annotations immediately after sending them a draft. In my case, however, my advisor only reads a portion of each draft I send, so I leave annotations until he has given feedback. To this motivates the following workflow:

1. Annotate each change to the PDF.
2. Compile PDF and share with reviewer.
3. Commit changes to the source code into Git or another source control management software. (If you aren’t tracking the changes to your source code, then start!)
4. Wait for reviewer to give comments or continue editing the document (as in step 1).

Once the reviewer gives you comments:

1. Commit current version to Git.
2. Delete the annotations only from the sections of the document that were reviewed.
3. Commit the new version, without the deleted annotations.

Annotating Blocks of Text

When annotating a sentence or more, I format my LaTeX code with \added{ and } on their own lines. Including % immediately after \added{ and after } prevents LaTeX from inserting extra spaces (LaTeX treats a new line in the code the same as a space).

\added{%
  Lorem ipsum dolor sit amet, consectetur 
  adipiscing elit, sed do eiusmod tempor 
  incididunt ut labore et dolore magna aliqua. 
}% End \added block

If you use Visual Studio Code, see below for snippets that will wrap selected text in annotation commands.

The commands \added, \deleted, and \replaced cannot contain a paragraph break. This precludes empty lines, such as

\added{  
  % Paragraph 1
  Lorem ipsum dolor sit amet, consectetur 
  adipiscing elit, sed do eiusmod tempor 
  incididunt ut labore et dolore magna aliqua. 

  % Paragraph 2 (Causes error!)
  Duis aute irure dolor in reprehenderit 
  in voluptate velit esse cillum dolore 
  eu fugiat nulla pariatur.
}

To mark multiple paragraphs as changed, I define a new color called added using the xcolor package

\usepackage{xcolor}
\colorlet{added}{blue!80!black} 

Then, add \color{added} before a multiple paragraph change, and add \color{black} afterward.

\color{added} 
% Paragraph 1 (Added)
Lorem ipsum dolor sit amet, consectetur 
adipiscing elit, sed do eiusmod tempor 
incididunt ut labore et dolore magna aliqua. 

% Paragraph 2 (Added)
Duis aute irure dolor in reprehenderit 
in voluptate velit esse cillum dolore 
eu fugiat nulla pariatur.
\color{black} 

% Paragraph 3 (No change)
Excepteur sint occaecat cupidatat non 
proident, sunt in culpa qui officia 
deserunt mollit anim id est laborum.

Output:

Package Configuration

There are various package options. For my documents, I use the following:

\usepackage[ % import "changes" package
    % If any of the changes commands are already defined, then the option "commandnameprefix=ifneeded" 
    % tells changes to append "ch" to the name of the changes command in order to avoid a name collision.
    % Commonly, "\comment" will be changed to "\chcomment".
    commandnameprefix=ifneeded, 
    % Changes imports the "todo" package. The following options are passed to the "todo" package.
    todonotes={colorinlistoftodos,
                prependcaption,
                textsize=small,
                backgroundcolor=orange!10,
                textcolor=black,
                linecolor=orange,
                bordercolor=orange} % 
    % draft, % <- enable line to show annotations regardless of the document being in 'final' mode.
    % final, % <- enable line to hide annotations regardless of the document being in 'draft' mode.
]{changes}

For comments in the margin, the margin size for many document classes is too narrow, so it is necessary to adjust it. One way to this is with the geometry package. In the following snippet, we also use the ifdraft package so that our changes to the margins only apply in draft mode.

% Create \ifdraft{}{} conditional 
% that switches based on whether "draft" 
% is passed to document class.
\usepackage{ifdraft} 
\ifdraft{
    % Adjust spacing to fit margin notes.
    \usepackage[inner=20mm, outer=40mm,
            marginparwidth=34mm]{geometry} 
}{}

My full LaTeX configuration file is available here.

Resolve Name Conflict For \comment Command

There are several packages that define a \comment command that would clash with the one defined by changes. If the prependcaption is included in the options for changes, then \comment is automatically renamed to \chcomment and a warning is shown. I would prefer to use \comment for the changes command, however. To do this, you can redefine the existing \comment command. If comment is an environment, as is defined by the verbatim package, then you must redefine both \comment and \endcomment, prior to importing changes, as follows:

% Redefine "comment" environment (from "verbatim" package) 
% to "commentsection" so that \comments{} can be defined 
% by the `changes` package.
\makeatletter
\let\commentsection\comment
\let\endcommentsection\endcomment
\let\comment\@undefined
\let\endcomment\@undefined
\makeatother

Defining Added/Deleted Environment Blocks

The changes package only defines macros for added, deleted, and replaced text, but not environments. Although macros are fine for short text, they have downsides for long blocks of text. For example, you cannot put empty lines of code, e.g., to write multiple paragraphs, in the argument of \added{} (the result is a cryptic Paragraph ended before \addcontentsline was complete. error). Furthermore, any errors that occur with the argument of \added{} are marked at the end of \added{}, making it difficult the source of errors if the text inside \added{} is long, possibly including several sentences or equations. Similarly, SyncTeX does not locate specific code with an \added{} macro, making it more difficult to navigate between your code and PDF.

To fix all of these problems, I define environment versions of \added{} and \deleted{} as follows:

% Define environments for blocks of deleted text. 
\usepackage{ifdraft}% Provides macros for testing if in draft or final mode. 
\usepackage{xcolor}% 
% We use \NewEnviron from environ to create environments that do not show their contents.
\RequirePackage{environ}
\definecolor{deletedColor}{rgb}{0.760, 0.000, 0.000}% Hex: #C20000FF (dark red)
\definecolor{addedColor}  {rgb}{0.169, 0.243, 0.714}% Hex: #2B3EB6FF (dark blue)
\NewEnviron{addedblock}{%
    \ifoptionfinal{%
        \BODY% Added content is inserted without modification in final version.
    }{% If not final, then show color
        {\color{addedColor}\BODY}%
    }%
}
\NewEnviron{deletedblock}{%
    \ifoptionfinal{%
        % Deleted content is omitted in final version.
    }{% If not final, then show color
        {\color{deletedColor}\BODY}%
    }%
}

An example of the usage is

\begin{addedblock}%
    Here is some text. 

		Here is a new paragraph. 
\end{addedblock}

I have not defined a replacedblock environment because there is not a straightforward way to give the added and deleted text. To indicate deleted text, I simply combine an addedblock and a `deletedblock:

\begin{addedblock}% Start of replacement text
This is new text.
\end{addedblock}% End of replacement text
\begin{deletedblock}% Start of replaced text
    This is old text.
\end{deletedblock}% End of replaced text

I wrote the several snippets to make these environments easy to use in VS Code. See the section on “Visual Studio Configuration”, below for more info about defining snippets.

"Added Block Environment":{
	"prefix": ["\\addedblock"],
	"body": [
		"\\begin{addedblock}%",
		// Do not indent the added text because we want to 
		// eventually delete \begin{added} and \end{added} 
		// without needing to reformat the code.
		"${0:$TM_SELECTED_TEXT}", 
		"\\end{addedblock}%"
	]
},
"Deleted Block Environment":{
	"prefix": ["\\deletedblock"],
	"body": [
		"\\begin{deletedblock}%",
		"\t$TM_SELECTED_TEXT",
		"\\end{deletedblock}%", 
		"$0"
	]
},
"Replaced Block Environment":{
	"prefix": ["\\replacedblock"],
	"body": [
		"\\begin{addedblock}% Start of replacement text",
		// Do not indent the added text because we want to 
		// eventually delete \begin{added} and \end{added} 
		// without needing to reformat the code.
		"${0:$TM_SELECTED_TEXT}",
		"\\end{addedblock}% End of replacement text",
		"\\begin{deletedblock}% Start of replaced text",
		"\t$TM_SELECTED_TEXT",
		"\\end{deletedblock}% End of replaced text"
	]
},

Visual Studio Configuration

When writing LaTeX with Visual Studio Code, you can define snippets that are automatically inserted when you type particular text. To set up snippets, type CTRL+SHIFT+P, type Preferences: Configure User Snippets, and select latex.json. Add the following code to latex.json:

{
	"Added":{
		"prefix": ["\\added"],
		"body": [
			"\\added{$TM_SELECTED_TEXT$1}$0"
		]
	},
	"Added Block":{
		"prefix": ["\\added%", "\\addedblock"],
		"body": [
			"\\added{%",
			"\t$TM_SELECTED_TEXT$0",
			"}% End \\added block",
			"" // Ensure there is a new line at end
		]
	},
	"Deleted":{
		"prefix": ["\\deleted"],
		"body": [
			"\\deleted{$TM_SELECTED_TEXT$1}$0"
		]
	},
	"Deleted Block":{
		"prefix": ["\\deleted%", "\\deletedblock"],
		"body": [
			"\\deleted{%",
			"\t$TM_SELECTED_TEXT$0",
			"}% End \\deleted block",
			"" // Ensure there is a new line at end
		]
	},
	"Replaced":{
		"prefix": ["\\replaced"],
		"body": [
			"\\replaced{$TM_SELECTED_TEXT$1}{$TM_SELECTED_TEXT}$0"
		]
	},
	"Replaced Block":{
		"prefix": ["\\replaced%", "\\replacedblock"],
		"body": [
			"\\replaced{% New Text",
			"\t$TM_SELECTED_TEXT$0",
			"}{% Old Text",
			"\t$TM_SELECTED_TEXT",
			"}% End \\replaced block",
			"" // Ensure there is a new line at end
		]
	}
}

For each command \added, \deleted, and \replaced, there are two versions of snippets an “inline” version and a “block” version. To use the block version append % or block. For example, to add a \replaced block:

1. Select the text you are replacing.
2. Type \replaced% or \replacedblock. The selected text will temporarily disappear as you type.
3. Select “Replaced Block” from the drop-down menu. At this point, the text you had selected reappears in both arguments of \replaced.
4. Modify the first argument to the new version.

I find the \replaced block snippet particularly useful because the comments % New Text and % Old Text remind me of the order of the arguments, which I always forget.

In order to understand control theory, it’s helpful to first introduce the concept of a dynamical system. A dynamical system is a system that changes over time. Some examples of dynamical systems are a pendulum (mechanical), a power transformer (electronic), a stock market (economic), and populations of predators and prey (ecological). A dynamical system is described using a list of numbers that change over time. We call the list of numbers the state of the system. The main questions we ask about a dynamical system is how it behaves over time.

• Is the state attracted to a particular point?
• Does state periodically return to the same point?
• Does the state remain in a particular region?

Consider, for example, an ecosystem with a population of a predator species and the population of its prey. The state of the system has two values at each moment in time: the population of the predator and the population of the prey. If either of these values goes to zero, then that species goes extinct.

In some dynamical systems, there are inputs that affect the behavior of the system. An input is a value that can be directly chosen at each moment in time. For a car, the inputs are the throttle (gas pedal), the brake, and the steering wheel. The position and velocity of the car cannot be controlled directly—to move the car to a new location, one must use the throttle and steering wheel to maneuver there. A dynamical system with inputs is a control system and the study of how to pick the inputs achieve various goals is called control theory. In general, our goal is to design the inputs so that the system

• goes where we want it,
• avoids obstacles, and
• minimizes energy use.

• Avoid using numbers, if possible
• Provide a yardstick that people are familiar with to compare quantities to (e.g., the Empire State Building, for length).
• Focus on one item or event at a time (e.g., state the number of points scored by a player per game instead of over entire career).
• Describe a representative case study instead of presenting statistics. The presented case could be fictional, in which case it is called a prototype.
• Round aggressively. Prefer simple fractions (people will remember 1/2 longer—and therefore more accurately—than 9/17).
• Use whole numbers if possible. It’s easy for people to understand “1 out of 3” than “33.3%”.
• If you can make a number “human scale”, then your audience will be able to picture it. Example: to give people a sense of the height of Mt. Everest, scale it down to a size we can understand: “If you were the height of a stack of six cards, Mt. Everest would be the height of a 2-story building.”
• To give exceptionally large or small values an emotional kick, give a comparison to a value that you would expect to be a totally different ballpark. For example, compare the size of California’s economy with the size of the world’s largest countries’ economies.
• Make numbers personal to the audience. Tell a story that includes each audience member as a (possibly hypothetical) participant. Example: if presenting the share of income that an average Kenyan spends on food, state how much that would equal scaled to the income of a typical person in the audience.
• Present your numbers with physical demonstrations in the room. Pick people in the room to represent population statistics (“Look to the two people next to you. It is statistically most likely that one of you will die of heart disease”).
• Convert numbers into periods of time. How long would it take to reach X at a rate that the audience can picture?
• To make exceptional numbers pack a stronger emotional punch, present them as a (surprise) encore. Begin by describing the number in a way that makes them sound significant, then add a modification that shows that the number is actually more extreme than the initial description.
• Set up a pattern then break it. Example: present the thickness of the thinnest laptops on the market, then show your company’s new laptop that is half as thin.

When choosing symbols for mathematical objects (variables, sets, etc.), the best choices are

• descriptive
• consistent with conventions
• easily distinguished from other notation in use

Regarding the choice of symbols, Paul R. Halmos wrote [1]:

Good notation has a kind of alphabetical harmony and avoids dissonance. Example: either $a x+b y$ or $a_1 x_1+a_2 x_2$ is preferable to $a x_1+b x_1.$ Or: if you must use $\Sigma$ for an index set, make sure you don’t run into $\sum_{\sigma \in \Sigma} \sigma.$

This document contains guidelines for picking good symbols and examples to shorten the process.

Choosing a Symbol Based on the Starting Sound

When choosing a symbol, it is helpful to choose it such that there is a connection between the symbol and its meaning. The most basic approach is to use the Latin character that starts a word related to the symbol’s meaning, such as $g$ or $G$ for gravity. After exhausting the Latin alphabet, the Greek alphabet can be used. The name of each Greek letter generally starts with the sound it makes. For instance, gamma ($\gamma$ and $\Gamma$) makes a “g” sound, so it would be a reasonable choice for a gravity symbol if $g$ and $G$ are already used elsewhere. In the following table, the second column lists possible choices of symbols to represent a object that has a name or description that starts with the sound or letter given in the first column.

Modifying a Symbol to Create a New, Related Symbol

Suppose we are using the symbol $x$ and want to introduce a second symbol that is strongly related to $x.$ The following modifications can be used to create a new symbol.

Using Different Fonts

In addition to the default capital Latin characters ($A$, $B$, $C$), etc., LaTeX provides script (\mathscr) characters $\mathscr{A}$, $\mathscr{B}$, $\mathscr{C}$; calligraphy (\mathcal) characters ($\mathcal{A}$, $\mathcal{B}$, $\mathcal{C}$); and Fraktur (\mathfrak) characters $\mathfrak{A}$, $\mathfrak{B}$, $\mathfrak{C}$. Many letters are different enough in each style that readers can be expected to recognize them as distinct symbols. For example, one can safely use $L, \mathcal{L}$, and $\mathfrak{L}$ in the same document without much risk of confusion (although, if you are writing these characters by hand, that is a different story!). However, many of the Fraktur characters are easily confused with each other so care should be used to avoid mixing, say $\mathfrak{I}$ and $\mathfrak{J}$ in the same document.

Placing Modifiers Over $i$ and $j$

When placing modifiers over $i$ and $j$, such as $\hat{i}$ or $\bar{j}$, the dots in the letters creates a crowded appearance with the modifier. To fix this, replace i and j with \imath and \jmath, which renders the respective letters without dots, e.g., $\imath$ and $\jmath$. The resulting combination with hats and bars is more pleasing: $\hat{\imath}$ (\hat{\imath}) and $\bar{\jmath}$ (\bar{\jmath}).

In this context, I prefer \bar{\jmath}, which is rendered as $\bar{\jmath}$, instead of \overline{\jmath}, which is rendered as $\overline{\jmath}$, because the line is better aligned with the top of the character.

Choosing Symbols Based on Type of Mathematical Object

There are conventions for notating certain types of mathematical objects. The following rules are not universally accepted, but are merely taken from my personal observations.

Real Numbers

Typically, lowercase Latin or Greek letters are used to represent real numbers. Less commonly, uppercase letters are used as well.

Several symbols, namely $\pi$ and $e$, have well-established meanings, so they should be avoided when there is any risk of ambiguity. The letters $\varepsilon$ and $\delta$ are frequently used to represent small positive numbers and capital letters such as $M$ or $R$ are sometimes used for large values.

For Latin letters, note that $e$ has a well-established usage as Euler’s constant. Be judicious in the use of $f, g, h$, which are commonly used for functions.

Avoid $i, j, k, m, n$ because they are commonly used for integers and avoid $l, o$ due to potential confusion with $1$ and $0$—the symbol $\ell$ can be used instead of $l$.

Integers (and Natural Numbers)

Typically, lowercase and (less frequently) uppercase Latin letters are used to represent integers. The letters $i, j, k, m, n$ are common choices, especially for indices. Choosing one of them offers a hint to the reader that the variable is an integer when they encounter it after its introduction. In some contexts, $i$ or $j$ is reserved for the imaginary unit $\sqrt{-1}$. The letters $a, b, c, d, p, q$ are also commonly used for integers but are also used as real numbers. Avoid $l, o$ (due to potential confusion with $1$ and $0$—$\ell$ can be used instead of $l$). A capital letter is useful to convey that an integer will be “large”, e.g., defining a sequence $x_i$ in $\mathbb{R}$ to be unbounded if “for every $M > 0$, there exists $i \in \mathbb{N}$ such that $x_i > M$.”

Variables vs. Constants

When it comes to variables and constants, I prefer to use the beginning of the alphabet for constants and the end for variables. In particular, I tend to use $a,$ $b,$ $c,$ $d,$ $p,$ $q,$ $r$ for constants and $t,$ $u,$ $v,$ $w,$ $x,$ $y,$ $z$ are for variables.

Example: Picking Notation for Upper and Lower Bounds

In this section we present a case study of picking symbols for the upper and lower bounds on a real number $x$. At first, we can simply take the first two letter of the alphabet.

Using $a$ and $b$ is fine, but the connection of $a$ and $b$ with $x$ is not implied symbolically. We also have to pick two new symbols if we need to set bounds on another value, say $y$. To show the connection between $x$ and the bounds, we might instead pick

The use of italicized text for $lb$ and $ub$ is bad form, however. A better choice is

This choice is pretty good, but writing letter subscripts can get tedious and makes equations somewhat messy. y For this reason, I prefer to simply underline $x$ for the lower bound and overline $x$ for the upper bound.

This notation is (1) simple, (2) visually descriptive, and (3) does not require choosing new symbols for every upper and lower bound that is introduced. There are cases where $\overline{x}$ can cause confusing, however. Namely, if $x$ is a complex number, then $\overline{x}$ could be read as the complex conjugate.

Finding Symbols Based on Appearance

There are far too many symbols to possibly know all of them. In cases when you know how symbol looks and wish to recover the LaTeX code, you can use Detexify and the Mathpix Snipping Tool. To browse through available symbols, the Comprehensive Latex Symbol List provides a massive list of symbols.

References

[1] Norman E. Steenrod, Paul R. Halmos, Menahem M. Schiffer, and Jean A. Dieudonné, How to Write Mathematics. 1973. [2] N. J. Higham, Handbook of writing for the mathematical sciences, 2nd ed. Philadelphia: Society for Industrial and Applied Mathematics, 1998.