# 用符号字体排逻辑与集合符号

> 一本逻辑小册子，所用字体都没有 ∀、∈、ℵ：symbolFont 指定 Noto Sans Math，由它在画布和 PDF 上画出这些符号和希腊字母。

- HTML版本: https://postext.dev/zh/cookbook/symbol-font-for-logic
- 食谱 No. 185 · 字体与文字 · 难度 2 (中级) · 输出: Canvas, PDF
- 体裁: 教科书
- 需要 postext ≥ 1.73.0, postext-pdf ≥ 1.73.0 · 已用 1.73.0, postext-pdf 1.73.0 测试，日期 2026-11-10
- 页面: [1](https://postext.dev/cookbook/symbol-font-for-logic/en/p01.webp?v=20f21fc7), [2](https://postext.dev/cookbook/symbol-font-for-logic/en/p02.webp?v=20f21fc7), [3](https://postext.dev/cookbook/symbol-font-for-logic/en/p03.webp?v=20f21fc7), [4](https://postext.dev/cookbook/symbol-font-for-logic/en/p04.webp?v=20f21fc7)
- PDF: https://postext.dev/cookbook/symbol-font-for-logic/en/symbol-font-for-logic.pdf?v=20f21fc7
- 在沙盒中打开: https://postext.dev/zh/sandbox#recipe=symbol-font-for-logic&lang=en (.postext: https://postext.dev/cookbook/symbol-font-for-logic/en/symbol-font-for-logic.postext)
- 最后更新: 2026-11-10
- 其他语言: [en](https://postext.dev/en/cookbook/symbol-font-for-logic.md), [es](https://postext.dev/es/cookbook/symbol-font-for-logic.md), [ca](https://postext.dev/ca/cookbook/symbol-font-for-logic.md), [de](https://postext.dev/de/cookbook/symbol-font-for-logic.md), [fr](https://postext.dev/fr/cookbook/symbol-font-for-logic.md), [it](https://postext.dev/it/cookbook/symbol-font-for-logic.md), [pt](https://postext.dev/pt/cookbook/symbol-font-for-logic.md), [ja](https://postext.dev/ja/cookbook/symbol-font-for-logic.md), [ar](https://postext.dev/ar/cookbook/symbol-font-for-logic.md)

## 简单来说

一个短章，教人读懂逻辑和集合论的符号。书里的字体没有这些符号，于是由第二种字体补上，屏幕上和打印的 PDF 里都一样。

## 成品一览

一本袖珍逻辑入门的第一章，页面 155 × 235 毫米：一条酒红色色带，上面用大字号排出本章的符号；接着四节逐个读出 ∀、∃、∈、∪、∅ 和 ℵ，公式既嵌在正文里，也在段落之间单独成行。正文用 Crimson Pro，标题用 Cormorant Garamond，标签用 IBM Plex Sans Condensed。Fontsource 提供的这三种字体文件里都没有 ∀、∈，也没有希腊字母。只需一项设置 `symbolFont`，就把 Noto Sans Math 放到每种字体后面：正文、标题、书眉和表格单元格里的符号都出自同一种字体，PDF 也把它们全部印出来。

**这份食谱回答的问题:**

- 字体里没有逻辑与集合符号（∀、∈、ℵ）和希腊字母，怎样打印出来而不出现空框？

## 简短回答

```js
// script.js, 行 34–47
// None of the three faces has ∀, ∈, ℵ or Greek. config.symbolFont (below) lists Noto Sans
// Math after every family the document names: what a face lacks is drawn from it, at the
// face's size and colour, in the canvas, the PDF, the HTML and the EPUB.
const SYMBOLS = 'Noto Sans Math';
// Fontsource serves Noto Sans Math whole in its "latin" file, and the kit would declare
// that file for the Latin range only. The screen and the PDF take it here with no range,
// so every glyph in it can be used.
const symbolFile = async () =>
  `${await fontsourceAt('noto-sans-math')}files/noto-sans-math-latin-400-normal.woff2`;
const resolve = async (family, ...face) =>
  (family === SYMBOLS ? [{ source: await symbolFile() }] : fontsourceResolver(family, ...face));
const pdfFonts = async (family, ...face) => (family !== SYMBOLS
  ? fontsourceProvider(family, ...face)
  : decompressWoff2(new Uint8Array(await (await fetch(await symbolFile())).arrayBuffer())));
```

## 用料

**讲解**

- [符号字体](https://postext.dev/zh/docs/configuration-fonts-colors-viewers.md#符号字体): symbolFont 指定一个字体族，在画布、PDF、HTML 和 EPUB 中绘制文档字体缺少的字符（逻辑与集合符号、希腊字母、箭头），而不是交给系统字体或印成空框。
- [嵌入PDF的字体](https://postext.dev/zh/docs/configuration-pdf-output.md#为什么需要字体提供函数): 字体提供者把版面测量过的每种字体的静态TrueType字节交给renderToPdf，使PDF排出完全相同的行。

**还用到**

- [排版前加载字体](https://postext.dev/zh/docs/configuration-programmatic-usage.md#排版前加载字体)
- [上标与下标](https://postext.dev/zh/docs/document-format-inline.md#行内格式)
- [段落样式](https://postext.dev/zh/docs/configuration-styles.md#段落样式)
- [由数据生成的表](https://postext.dev/zh/docs/document-format-resources.md#块级嵌入可选显式的行内放置)
- [表格样式](https://postext.dev/zh/docs/configuration-resources.md#表格样式)
- [设计过的章首页](https://postext.dev/zh/docs/configuration-headings.md#通栏与高级设计)
- [标题属性](https://postext.dev/zh/docs/document-format.md#标题属性)
- [书眉与页码](https://postext.dev/zh/docs/configuration-headers-footers.md#页眉与页脚)
- [对称页边距](https://postext.dev/zh/docs/configuration-page-layout.md#对称页边距)
- [语义调色板](https://postext.dev/zh/docs/configuration-fonts-colors-viewers.md#调色板)
- [导出PDF](https://postext.dev/zh/docs/configuration-pdf-output.md#生成pdf)
- [图就放在这里](https://postext.dev/zh/docs/document-format-resources.md#块级嵌入可选显式的行内放置)
- [用你的语言显示“图”和“表”](https://postext.dev/zh/docs/configuration-resources.md#资源类型)
- [按页面角色显示书眉](https://postext.dev/zh/docs/configuration-headers-footers.md#文本元素)
- [自定义资源类型](https://postext.dev/zh/docs/configuration-resources.md#资源类型)

**配置一览**

- [`bodyText`](https://postext.dev/zh/docs/configuration-text.md#正文), [`captionStyle`](https://postext.dev/zh/docs/configuration-resources.md#题注样式), [`colorPalette`](https://postext.dev/zh/docs/configuration-fonts-colors-viewers.md#调色板), [`footer`](https://postext.dev/zh/docs/configuration-headers-footers.md#页眉与页脚), [`header`](https://postext.dev/zh/docs/configuration-headers-footers.md#页眉与页脚), [`headings`](https://postext.dev/zh/docs/configuration-headings.md#标题), [`layout`](https://postext.dev/zh/docs/configuration-page-layout.md#版式), [`locale`](https://postext.dev/zh/docs/configuration-language.md#断词), [`page`](https://postext.dev/zh/docs/configuration-page-layout.md#页面), [`paragraphStyles`](https://postext.dev/zh/docs/configuration-styles.md#段落样式), [`resourceTypes`](https://postext.dev/zh/docs/configuration-resources.md#资源类型), [`symbolFont`](https://postext.dev/zh/docs/configuration-fonts-colors-viewers.md#符号字体), [`tableStyle`](https://postext.dev/zh/docs/configuration-resources.md#表格样式)

**API**

- [`buildDocumentWithFonts`](https://postext.dev/zh/docs/configuration-programmatic-usage.md#排版前加载字体), [`decompressWoff2`](https://postext.dev/zh/docs/configuration-pdf-output.md#浏览器字体提供函数fontsource--woff2), [`defaultResourceTypes`](https://postext.dev/zh/docs/configuration-resources.md#资源类型), `formatWarning`, [`parseTSV`](https://postext.dev/zh/docs/document-format-resources.md#块级嵌入可选显式的行内放置), [`renderPageToCanvas`](https://postext.dev/zh/docs/configuration-programmatic-usage.md#把页面渲染为位图), [`renderToPdf`](https://postext.dev/zh/docs/configuration-pdf-output.md#生成pdf)

**字体**

- Crimson Pro (OFL-1.1), Cormorant Garamond (OFL-1.1), IBM Plex Sans Condensed (OFL-1.1), Noto Sans Math (OFL-1.1)

## 做法

### 1 · 所有字体后面的一种符号字体

这一步的代码就是上面的简短回答。`symbolFont: 'Noto Sans Math'`（[符号字体](https://postext.dev/zh/docs/configuration-fonts-colors-viewers.md#符号字体)）把这个字族放到配置里提到的每个字族后面：字体缺的字符改用 Noto Sans Math 画，字号和颜色跟随原字体，这一行其余部分仍用原字体。Fontsource 把完整的 Noto Sans Math 放在 `latin` 文件里，共 3033 个字符，但工具包只为拉丁范围声明这个文件，浏览器不会向它要 ∀。本配方的 `resolve` 和 `pdfFonts` 把同一个文件不带范围地交出去，屏幕上交给画布，打印时交给 `renderToPdf`。只有缺的字符才换字体：Crimson Pro 有 ¬，所以正文里的否定号仍是 Crimson Pro。

### 2 · 先不用它排一遍，看看缺什么

```js
// script.js, 行 243–250
// Each paragraph that sets a character its face lacks is a glyphFallbackAt warning with its
// page; with no symbol font it names no family that draws them, and the PDF would print
// empty boxes. The pages shown are the second build's.
const fonts = { ...kitFonts(FONTS), resolve }; // the kit's resolver, with the symbol file
const bare = await buildDocumentWithFonts({ markdown, resources }, { ...config, symbolFont: '' },
  fonts);
console.info((bare.contentWarnings ?? []).filter((w) => w.kind === 'glyphFallbackAt')
  .map(formatWarning).join('\n'));
```

第一遍排版把 `symbolFont` 留空，打印出 `glyphFallbackAt` 警告：每个含有其字体缺字的段落、标题或表格各一条，写明页码和字符。英文版共十八条：十四个 Crimson Pro 段落、三个 Cormorant Garamond 标题，以及表 1.1 中 IBM Plex Sans Condensed 粗体的表头行。没有字族来画，画布会从读者系统里的某种字体借来这些符号，PDF 则每个都印成空框。第二遍用了符号字体，页面上看到的就是它；它的警告写明由 `"Noto Sans Math"` 来画这些字符。

### 3 · 开篇的符号是文字

```js
// script.js, 行 51–67
const BAND = 78; // mm from the trim to the foot of the band
const onBand = { color: col('paper'), align: 'left' };
const below = (id, y, width) => ({ anchor: { to: `#${id}`, edge: 'below' }, offset: { y: mm(y) },
  size: { width: mm(width) } });
const opener = { enabled: true, minHeight: mm(BAND - TOP + 2), slot: { elements: [
  { kind: 'box', id: 'band', style: { backgroundColor: col('accent') },
    placement: { anchor: { to: 'bleed', edge: 'top-left' }, size: { height: mm(BAND) } } },
  { kind: 'text', id: 'kicker', content: '{attr.kicker}', ...onBand, fontFamily: LABEL,
    fontWeight: 600, fontSize: pt(8.5), letterSpacing: pt(1.8), textTransform: 'uppercase',
    placement: { anchor: { to: 'container', edge: 'top-left' }, offset: { y: mm(2) } } },
  { kind: 'text', id: 'title', content: '{titleText}', ...onBand, fontFamily: DISPLAY,
    fontWeight: 600, fontSize: pt(38), lineHeight: 1.02, placement: below('kicker', 3, 110) },
  // The signs are text in Cormorant Garamond, which has none of them: Noto Sans Math draws
  // every one, at 30 pt, in the band's white.
  { kind: 'text', id: 'signs', content: '{attr.signs}', ...onBand, fontFamily: DISPLAY,
    fontSize: pt(30), lineHeight: 1, letterSpacing: pt(9), placement: below('title', 7, 114) },
] } };
```

标题下那行七个符号是一段设计文字，用 30 pt 的 Cormorant Garamond，内容来自标题的 `signs` 属性。Cormorant Garamond 一个都没有，所以七个都出自符号字体，在色带上以白色印出。9 pt 的字距把它们铺满版心宽度。

### 4 · 单元格和书眉用同一种字体

```js
// script.js, 行 212–230
const [T, F] = t({ en: ['T', 'F'], es: ['V', 'F'] });
const connectives = [['¬*p*', (p) => !p], ['*p* ∧ *q*', (p, q) => p && q],
  ['*p* ∨ *q*', (p, q) => p || q], ['*p* → *q*', (p, q) => !p || q],
  ['*p* ↔ *q*', (p, q) => p === q]];
const cell = (content, isHeader = false) => ({ content, align: 'center', isHeader });
const truth = [[true, true], [true, false], [false, true], [false, false]].map(([p, q]) =>
  [p, q, ...connectives.map(([, f]) => f(p, q))].map((v) => cell(v ? T : F)));
const table = (id, rows, columnWidths, caption, position) => ({ id, typeId: 'table',
  kind: 'table', caption, createdAt: 0, updatedAt: 0, placement: { position },
  table: { model: { headerRowCount: 1, columnWidths, rows } } });
const resources = [
  table('truth', [['*p*', '*q*', ...connectives.map(([s]) => s)].map((s) => cell(s, true)),
    ...truth],
    [1, 1, 1.3, 1.6, 1.6, 1.6, 1.6], t({ en: 'The five connectives, row by row.',
      es: 'Las cinco conectivas, fila a fila.' }), 'top'), // to the head of a page
  table('signs', parseTSV(signs.trim()).rows.map((row, r) => row.map(({ content }, c) => ({
    content, align: c === 0 ? 'center' : 'left', isHeader: r === 0 }))), [0.8, 2.1, 5.3],
  t({ en: 'Where the signs come from.', es: 'De dónde vienen los signos.' }), 'here'),
];
```

真值表由联结词本身生成：每列表头是公式，每个单元格是该公式在这一行的结果。表头单元格用 IBM Plex Sans Condensed 粗斜体，表身用 Crimson Pro，符号字体为两者供字。它只有一个正体，为所有字重和倾斜供字，所以粗体表头里的 ∧ 和斜体公式里的 ∈ 是同样的直立符号。奇数页书眉印出当前一节 `{firstMark.h2}`，第 3 页的 *SETS: ∈, ∪, ∩ AND ∅* 也从 Noto Sans Math 取符号。

![Page 3: Sets: ∈, ∪, ∩ and ∅.](https://postext.dev/cookbook/symbol-font-for-logic/en/p03.webp?v=20f21fc7)

*第 3 页：集合公式用 Crimson Pro 斜体，每个符号都来自 Noto Sans Math。*

## 完整食谱

一个文件，由食谱文件夹合成，示例文本和排版食谱的公共工具包都已内联；它自己排出页面。要运行它，把它放进空白页面的`<script type="module">`，或粘贴到新建CodePen的JS面板里（设为模块）。它从esm.sh导入postext，不需要安装或构建。

- 食谱文件夹: https://github.com/drnachio/postext/tree/main/cookbook/symbol-font-for-logic

### script.js

```js
// ═══ Postext Cookbook · Nº 185 · Logic signs from a symbol font ═════════════════════
// https://postext.dev/en/cookbook/symbol-font-for-logic
// Code: MIT · Text: original (CC BY 4.0) · Pictures: none
// Fonts: Crimson Pro, Cormorant Garamond, IBM Plex, Noto Sans Math (OFL) · Needs postext ≥ 1.73.0
// A primer of logical notation set in faces that have no ∀, no ∈, no ℵ and no Greek:
// symbolFont names Noto Sans Math, which draws those characters on the canvas and in the PDF.
import {
  buildDocumentWithFonts, renderPageToCanvas, defaultResourceTypes, parseTSV, formatWarning,
} from 'https://esm.sh/postext';
import { renderToPdf, decompressWoff2 } from 'https://esm.sh/postext-pdf';

const LANG = 'en'; // @lang: the language of the sample document ('en' | 'es')
const RECIPE = 'symbol-font-for-logic';

// ─── 1 · Design ─────────────────────────────────────────────────────────────
const palette = {
  ink: '#1f1c22', // text: a cool near-black
  accent: '#7b2a3b', // claret: the opener band, labels, the table heads
  tint: '#f4ece9', // the even rows of the truth table
  rule: '#c3b4b2', // hairlines
  muted: '#6a6064', // running heads, the colophon
  paper: '#ffffff',
};
const col = (id) => ({ hex: palette[id], model: 'hex', paletteId: id });
const colorPalette = [
  ...Object.entries(palette).map(([id, hex]) => ({ id, name: id, value: { hex, model: 'hex' } })),
  { id: 'main-color', name: 'accent (defaults)', value: { hex: palette.accent, model: 'hex' } },
];
const TEXT = 'Crimson Pro', DISPLAY = 'Cormorant Garamond', LABEL = 'IBM Plex Sans Condensed';
const TRIM = [155, 235], INNER = 20, OUTER = 21, TOP = 23; // mm: a trade-size primer
const LEAD = 15; // pt: the body leading

// #region answer: one symbol font behind every face, on the canvas and in the PDF
// None of the three faces has ∀, ∈, ℵ or Greek. config.symbolFont (below) lists Noto Sans
// Math after every family the document names: what a face lacks is drawn from it, at the
// face's size and colour, in the canvas, the PDF, the HTML and the EPUB.
const SYMBOLS = 'Noto Sans Math';
// Fontsource serves Noto Sans Math whole in its "latin" file, and the kit would declare
// that file for the Latin range only. The screen and the PDF take it here with no range,
// so every glyph in it can be used.
const symbolFile = async () =>
  `${await fontsourceAt('noto-sans-math')}files/noto-sans-math-latin-400-normal.woff2`;
const resolve = async (family, ...face) =>
  (family === SYMBOLS ? [{ source: await symbolFile() }] : fontsourceResolver(family, ...face));
const pdfFonts = async (family, ...face) => (family !== SYMBOLS
  ? fontsourceProvider(family, ...face)
  : decompressWoff2(new Uint8Array(await (await fetch(await symbolFile())).arrayBuffer())));
// #endregion

// #region opener: a claret band with the chapter's signs set large
const BAND = 78; // mm from the trim to the foot of the band
const onBand = { color: col('paper'), align: 'left' };
const below = (id, y, width) => ({ anchor: { to: `#${id}`, edge: 'below' }, offset: { y: mm(y) },
  size: { width: mm(width) } });
const opener = { enabled: true, minHeight: mm(BAND - TOP + 2), slot: { elements: [
  { kind: 'box', id: 'band', style: { backgroundColor: col('accent') },
    placement: { anchor: { to: 'bleed', edge: 'top-left' }, size: { height: mm(BAND) } } },
  { kind: 'text', id: 'kicker', content: '{attr.kicker}', ...onBand, fontFamily: LABEL,
    fontWeight: 600, fontSize: pt(8.5), letterSpacing: pt(1.8), textTransform: 'uppercase',
    placement: { anchor: { to: 'container', edge: 'top-left' }, offset: { y: mm(2) } } },
  { kind: 'text', id: 'title', content: '{titleText}', ...onBand, fontFamily: DISPLAY,
    fontWeight: 600, fontSize: pt(38), lineHeight: 1.02, placement: below('kicker', 3, 110) },
  // The signs are text in Cormorant Garamond, which has none of them: Noto Sans Math draws
  // every one, at 30 pt, in the band's white.
  { kind: 'text', id: 'signs', content: '{attr.signs}', ...onBand, fontFamily: DISPLAY,
    fontSize: pt(30), lineHeight: 1, letterSpacing: pt(9), placement: below('title', 7, 114) },
] } };
// #endregion

// #region running-heads: the book on the verso, the section on the recto
const head = (id, content, parity, edge, x, extra = {}) => ({
  kind: 'text', id, content, parity, pages: 'body', fontFamily: LABEL, fontSize: pt(7.5),
  fontWeight: 500, letterSpacing: pt(1.2), textTransform: 'uppercase', color: col('muted'),
  placement: { anchor: { to: 'page', edge }, offset: { x: mm(x), y: mm(13) } }, ...extra });
const folio = { fontWeight: 600, color: col('ink') };
const header = { elements: [
  head('verso-folio', '{pageNumber}', 'even', 'top-left', OUTER, folio),
  head('verso-title', '{title}', 'even', 'top-left', OUTER + 8),
  // A section title such as "Quantifiers: ∀ and ∃" takes its signs from the symbol font too.
  head('recto-title', '{firstMark.h2}', 'odd', 'top-right', -(OUTER + 8)),
  head('recto-folio', '{pageNumber}', 'odd', 'top-right', -OUTER, folio),
] };
const footer = { elements: [head('drop-folio', '{pageNumber}', 'all', 'top', 0, {
  ...folio, pages: 'opener',
  placement: { anchor: { to: 'container', edge: 'top' }, offset: { y: mm(9) } } })] };
// #endregion

const config = {
  locale: t({ en: 'en-us', es: 'es' }),
  symbolFont: SYMBOLS,
  resourceTypes: defaultResourceTypes(LANG),
  colorPalette,
  page: { sizePreset: 'custom', width: mm(TRIM[0]), height: mm(TRIM[1]), dpi: 150,
    margins: { top: mm(TOP), bottom: mm(22), left: mm(INNER), right: mm(OUTER), mirror: true } },
  layout: { layoutType: 'single' },
  bodyText: {
    fontFamily: TEXT, fontSize: pt(11), lineHeight: pt(LEAD), color: col('ink'),
    boldColor: col('ink'), italicColor: col('ink'), referenceColor: col('ink'),
    textAlign: 'justify', firstLineIndent: mm(4.5), indentAfterHeading: false,
    hyphenation: { enabled: true }, optimalLineBreaking: true,
    avoidWidows: true, avoidOrphans: true, avoidRunts: true,
  },
  headings: { fontFamily: DISPLAY, color: col('ink'), fontWeight: 600,
    levels: [
      { level: 1, fontSize: pt(38), breakBefore: { parity: 'odd' }, advancedDesign: opener,
        marginBottom: pt(0) },
      { level: 2, fontSize: pt(16), lineHeight: pt(LEAD * 1.2), color: col('accent'),
        marginTop: pt(LEAD), marginBottom: pt(LEAD * 0.3) },
    ] },
  paragraphStyles: [
    // Displayed formulas: centred, in the text face, a size up; the signs still come from
    // the symbol font, the italic variables from Crimson Pro.
    { id: 'formula', fontSize: pt(12), lineHeight: pt(LEAD * 1.2), textAlign: 'center',
      firstLineIndent: pt(0), hyphenation: { enabled: false } },
    { id: 'colophon', fontFamily: LABEL, fontSize: pt(7.5), lineHeight: pt(10),
      color: col('muted'), textAlign: 'left', firstLineIndent: pt(0), marginTop: pt(LEAD) },
  ],
  tableStyle: { rules: 'horizontal', borderColor: col('rule'), borderWidth: pt(0.5),
    headerBackground: col('accent'), headerColor: col('paper'), headerBold: true,
    headerFontFamily: LABEL, headerFontSize: pt(8.5), bodyFontFamily: TEXT,
    bodyFontSize: pt(10), bodyColor: col('ink'), cellPadding: mm(1.1) },
  captionStyle: { fontFamily: LABEL, fontSize: pt(8), color: col('ink'), labelBold: true,
    labelColor: col('accent'), note: { color: col('muted') } },
  header,
  footer,
};

// ─── 2 · Content ────────────────────────────────────────────────────────────
const markdown = String.raw`---
title: "A Pocket Primer of Logic"
author: "Ignacio Ferro"
---

# Reading the Signs {kicker="A pocket primer of logic · Chapter 1" signs="∀ ∃ → ∈ ∪ ∅ ℵ"}

A page of logic looks like a page of algebra that has lost its numbers. Its letters stand for sentences, for objects and for collections of objects, and a dozen signs hold them together. Most of those signs are younger than the telephone: Giuseppe Peano printed the first of the modern ones in 1889, and Gerhard Gentzen added the last of the common ones in 1935. This chapter reads them one at a time, in the order a first course meets them, and gives each its name in words, so that any formula can be read aloud as a sentence.

## Sentences and connectives

A letter such as *p* or *q* stands for a whole sentence that is either true or false: *it is raining*, *the train is late*. Five signs build longer sentences out of shorter ones. ¬*p* reads “not *p*” and is true exactly when *p* is false. *p* ∧ *q*, “*p* and *q*”, is true when both are. *p* ∨ *q*, “*p* or *q*”, is true when at least one is; the sign is a stylised *v*, for the Latin *vel*, the “or” that allows both. *p* → *q*, “if *p* then *q*”, is false in one case only, when *p* is true and *q* is false. *p* ↔ *q*, “*p* if and only if *q*”, is true when the two sides agree.

Table 1.1 sets the five side by side. Each row is one way the world could be, and each column is one sentence, read off from the two letters on the left.

::resource{id="truth"}

The table settles questions that intuition gets wrong. The third and fourth rows show that *p* → *q* is true whenever *p* is false, whatever *q* says: a promise whose condition was never met has not been broken. The table also proves De Morgan’s laws, which turn the negation of an “or” into an “and” of negations, and the other way round:

:::paragraphs{style="formula"}
¬(*p* ∨ *q*) ↔ (¬*p* ∧ ¬*q*) \
¬(*p* ∧ *q*) ↔ (¬*p* ∨ ¬*q*)
:::

## Quantifiers: ∀ and ∃

Sentence letters cannot see inside a sentence. *All humans are mortal* and *Socrates is human* share no letter, and yet together they give *Socrates is mortal*. Predicate logic splits a sentence into a predicate and the things it is said of: *Hx* for “*x* is human”, *Mx* for “*x* is mortal”, *s* for Socrates. Two quantifiers then say how many things a predicate holds of. ∀*x*, “for every *x*”, is an A turned upside down; ∃*x*, “there is an *x*”, is an E turned back to front.

:::paragraphs{style="formula"}
∀*x* (*Hx* → *Mx*) \
*Hs* → *Ms*
:::

The first line is the major premise of the oldest syllogism in the textbooks, and the second is what it says of Socrates in particular. The two quantifiers are tied together by negation. To deny that everything has a property is to say that something lacks it, and to deny that something has it is to say that everything lacks it:

:::paragraphs{style="formula"}
¬∀*x* φ ↔ ∃*x* ¬φ \
¬∃*x* φ ↔ ∀*x* ¬φ
:::

The Greek letters φ and ψ are not part of the formula language. Each stands for any formula at all, so each line above is a pattern with infinitely many instances. Logicians keep the Greek alphabet for this talk about formulas and the Latin one for the formulas themselves. A capital gamma, Γ, usually names a set of premises, and Γ ⊢ φ says that φ can be derived from them.

## Sets: ∈, ∪, ∩ and ∅

A set is a collection taken as one object. *a* ∈ *A* says that *a* is a member of *A*, and *a* ∉ *A* that it is not. *A* ⊆ *B* says that every member of *A* is a member of *B*; *A* ⊂ *B* adds that *B* has some member more. With the connectives and the quantifiers, each of these comes down to a sentence about members:

:::paragraphs{style="formula"}
*A* ⊆ *B* ↔ ∀*x* (*x* ∈ *A* → *x* ∈ *B*) \
*x* ∈ *A* ∪ *B* ↔ (*x* ∈ *A* ∨ *x* ∈ *B*) \
*x* ∈ *A* ∩ *B* ↔ (*x* ∈ *A* ∧ *x* ∈ *B*)
:::

The union ∪ is built on the “or” and the intersection ∩ on the “and”, and the shapes keep the kinship in view: ∪ opens upward like ∨, ∩ downward like ∧. The empty set ∅ has no members, ∀*x* (*x* ∉ ∅), and it is a subset of every set *A*, because the condition of ∀*x* (*x* ∈ ∅ → *x* ∈ *A*) is never met.

Not every condition defines a set. In June 1902 Bertrand Russell wrote to Gottlob Frege about the collection of all sets that are not members of themselves. Call it *R*. If *R* ∈ *R*, then *R* fails its own condition, so *R* ∉ *R*; if *R* ∉ *R*, it meets the condition, so *R* ∈ *R*. Frege’s system allowed *R*, and with it *R* ∈ *R* ↔ *R* ∉ *R*, a contradiction. The set theories taught today do not let such a collection be a set.

## Counting the infinite: ℵ

Two sets have the same size when their members can be paired off one to one. The natural numbers, ℕ, and the even numbers pair off by sending each *n* to 2*n*, so an infinite set can be as large as a part of itself. Georg Cantor denoted the size of ℕ by ℵ~0~, aleph-null, from the first letter of the Hebrew alphabet, and showed in 1891 that the real numbers cannot be paired off with ℕ: any list of them leaves one out. There are therefore at least two infinite sizes, and his alephs ℵ~0~, ℵ~1~, ℵ~2~ name them in order.

## Where the signs come from

The signs in this chapter came into print one at a time, from different hands; Table 1.2 names who put each of them into general use.

::resource{id="signs"}

:::paragraphs{style="colophon"}
Set in Crimson Pro, Cormorant Garamond and IBM Plex Sans Condensed, with the signs from Noto Sans Math (SIL Open Font License) · Text: original, CC BY 4.0.
:::
`; // content.<lang>.md, inlined by the Cookbook
const signs = String.raw`Sign	Read as	Put into use by
∈	is a member of	Giuseppe Peano, *Arithmetices principia*, 1889, as ε, for Greek *esti*, “is”
∪ ∩	union, intersection	Peano, *Calcolo geometrico*, 1888
∃	there is	Peano, *Formulaire de mathématiques*, volume II, 1897
ℵ	aleph	Georg Cantor, *Mathematische Annalen*, 1895
∨	or	Whitehead and Russell, *Principia Mathematica*, 1910
→	if … then	Hilbert and Ackermann, *Grundzüge der theoretischen Logik*, 1928
¬	not	Arend Heyting, on intuitionistic logic, 1930
∀	for every	Gerhard Gentzen, *Mathematische Zeitschrift*, 1935
∅	the empty set	André Weil, for Nicolas Bourbaki, 1939
`; // TSV: sign, read as, made current by

// #region tables: the truth table from the connectives themselves, the signs from TSV
const [T, F] = t({ en: ['T', 'F'], es: ['V', 'F'] });
const connectives = [['¬*p*', (p) => !p], ['*p* ∧ *q*', (p, q) => p && q],
  ['*p* ∨ *q*', (p, q) => p || q], ['*p* → *q*', (p, q) => !p || q],
  ['*p* ↔ *q*', (p, q) => p === q]];
const cell = (content, isHeader = false) => ({ content, align: 'center', isHeader });
const truth = [[true, true], [true, false], [false, true], [false, false]].map(([p, q]) =>
  [p, q, ...connectives.map(([, f]) => f(p, q))].map((v) => cell(v ? T : F)));
const table = (id, rows, columnWidths, caption, position) => ({ id, typeId: 'table',
  kind: 'table', caption, createdAt: 0, updatedAt: 0, placement: { position },
  table: { model: { headerRowCount: 1, columnWidths, rows } } });
const resources = [
  table('truth', [['*p*', '*q*', ...connectives.map(([s]) => s)].map((s) => cell(s, true)),
    ...truth],
    [1, 1, 1.3, 1.6, 1.6, 1.6, 1.6], t({ en: 'The five connectives, row by row.',
      es: 'Las cinco conectivas, fila a fila.' }), 'top'), // to the head of a page
  table('signs', parseTSV(signs.trim()).rows.map((row, r) => row.map(({ content }, c) => ({
    content, align: c === 0 ? 'center' : 'left', isHeader: r === 0 }))), [0.8, 2.1, 5.3],
  t({ en: 'Where the signs come from.', es: 'De dónde vienen los signos.' }), 'here'),
];
// #endregion

// ─── 3 · Fonts ──────────────────────────────────────────────────────────────
const FONTS = {
  'Crimson Pro': ['400', '400i', '600'],
  'Cormorant Garamond': ['400', '600'], // 400: the line of signs, all of it from the symbol font
  'IBM Plex Sans Condensed': ['400', '500', '600', '700', '700i'],
  'Noto Sans Math': ['400'], // the symbol font: one upright regular for every face
};

// ─── 4 · Build & show ───────────────────────────────────────────────────────
// #region without: one build without the symbol font, to read what it reports
// Each paragraph that sets a character its face lacks is a glyphFallbackAt warning with its
// page; with no symbol font it names no family that draws them, and the PDF would print
// empty boxes. The pages shown are the second build's.
const fonts = { ...kitFonts(FONTS), resolve }; // the kit's resolver, with the symbol file
const bare = await buildDocumentWithFonts({ markdown, resources }, { ...config, symbolFont: '' },
  fonts);
console.info((bare.contentWarnings ?? []).filter((w) => w.kind === 'glyphFallbackAt')
  .map(formatWarning).join('\n'));
// #endregion
const doc = await buildDocumentWithFonts({ markdown, resources }, config, fonts);
showPages(doc, { title: t({ en: 'A pocket primer of logic', es: 'Cartilla de lógica' }) });
offerPdf(() => renderToPdf(doc, { fontProvider: pdfFonts }), `${RECIPE}.pdf`);

// ─── Kit ── helpers shared by every Cookbook recipe · postext.dev/cookbook ─────

// ─── Kit · core v1 ── the same in every recipe · postext.dev/cookbook
function mm(value) { return { value, unit: 'mm' }; }
function pt(value) { return { value, unit: 'pt' }; }
function em(value) { return { value, unit: 'em' }; }
/** The sample language's string: t({ en: 'Figure', es: 'Figura' }). */
function t(strings) { return strings[LANG] ?? Object.values(strings)[0]; }
/** A file in this recipe's assets folder, served from the Postext repo by jsDelivr. */
function asset(file) { return `https://cdn.jsdelivr.net/gh/drnachio/postext@main/cookbook/${RECIPE}/assets/${file}`; }

// ─── Kit · fonts v3 ── the same in every recipe · postext.dev/cookbook
// Postext loads the faces a config asks for before layout and asks the kit
// for Fontsource's files, the ones the PDF embeds too.

/** buildDocumentWithFonts' options: the resolver, and FONTS' faces loaded
 *  with the config's. FONTS = { 'Family Name': ['400', '400i', '700'] }. */
function kitFonts(FONTS = {}) {
  const faces = Object.entries(FONTS).flatMap(([family, specs]) => specs.map((spec) =>
    ({ family, weight: parseInt(spec, 10), style: spec.endsWith('i') ? 'italic' : 'normal' })));
  return { resolve: fontsourceResolver, faces };
}

/** A face's files with their ranges: latin, then latin-ext and greek when
 *  `text` needs them (kitSubsetsFor). Null for a face Fontsource lacks. */
async function fontsourceResolver(family, weight, style, { text = '' } = {}) {
  const id = fontsourceId(family);
  const meta = await fontsourceMeta(family);
  if (meta && !(await fontsourceWeights(family, style)).includes(weight)) return null;
  kitStatus('Loading fonts…');
  const at = await fontsourceAt(id);
  return ['latin', ...kitSubsetsFor(text, meta)].map((subset) => ({
    source: `${at}files/${id}-${subset}-${weight}-${style}.woff2`,
    unicodeRange: kitRanges()[subset],
  }));
}

/** Each file's unicode-range (a function: the kit runs after the pen's code). */
function kitRanges() {
  return {
    latin: 'U+0000-00FF,U+0131,U+0152-0153,U+02BB-02BC,U+02C6,U+02DA,U+02DC,U+0304,U+0308,U+0329,'
      + 'U+2000-206F,U+20AC,U+2122,U+2191,U+2193,U+2212,U+2215,U+FEFF,U+FFFD',
    'latin-ext': 'U+0100-02BA,U+02BD-02C5,U+02C7-02CC,U+02CE-02D7,U+02DD-02FF,U+0304,U+0308,U+0329,'
      + 'U+1D00-1DBF,U+1E00-1E9F,U+1EF2-1EFF,U+2020,U+20A0-20AB,U+20AD-20C0,U+2113,U+2C60-2C7F,U+A720-A7FF',
    greek: 'U+0370-03FF',
  };
}

/** For the cjk, arabic and comics blocks: loads `faces` (as FONTS) for the
 *  sample `text`; `optional` skips a face Fontsource lacks. Files are added in
 *  the order asked, the last winning a shared character. Resolves to the count. */
async function loadFonts(faces, text = '', { optional = false } = {}) {
  kitStatus('Loading fonts…');
  const ranges = kitRanges();
  const jobs = [];
  for (const [family, specs] of Object.entries(faces)) {
    const id = fontsourceId(family);
    const todo = [...new Set(specs)].map((spec) => [parseInt(spec, 10), spec.endsWith('i') ? 'italic' : 'normal'])
      .filter(([weight, style]) => !hasFace(family, weight, style)); // before any await
    const at = fontsourceAt(id);
    const meta = optional || /[^\0-ÿ]/u.test(text) ? await fontsourceMeta(family) : null;
    const subsets = ['latin', ...kitSubsetsFor(text, meta)];
    for (const [weight, style] of todo) {
      if (optional && !(meta && (await fontsourceWeights(family, style)).includes(weight))) continue;
      for (const subset of subsets) {
        const url = `${await at}files/${id}-${subset}-${weight}-${style}.woff2`;
        const face = new FontFace(family, `url(${url}) format('woff2')`,
          { weight: String(weight), style, unicodeRange: ranges[subset] });
        jobs.push(face.load().catch(() => {
          if (subset === 'latin' && !optional) throw new Error(`Fontsource has no ${family} ${weight} ${style}`);
        }));
      }
    }
  }
  const ready = await Promise.all(jobs).catch((error) => { kitFail(error); throw error; });
  return ready.filter((face) => face && document.fonts.add(face)).length;
}

/** A loaded FontFace covers this face (fonts.check() says yes to any family). */
function hasFace(family, weight, style) {
  for (const face of document.fonts) {
    if (face.status !== 'loaded' || face.style !== style) continue;
    if (face.family.replace(/^["']|["']$/g, '') !== family) continue;
    const [low, high = low] = face.weight.split(' ').map(Number);
    if (weight >= low && weight <= high) return true;
  }
  return false;
}

/** The files beyond latin `text` needs that `meta`'s family ships. */
function kitSubsetsFor(text, meta) {
  return [[/[Ā-˿ᴀ-ᶿḀ-ỿ†ℓⱠ-Ɀ꜠-ꟿ]/u, 'latin-ext'], [/[Ͱ-Ͽ]/u, 'greek']]
    .filter(([re, x]) => re.test(text) && meta?.subsets?.includes(x)).map(([, x]) => x);
}

/** Fontsource's id for a family: 'Source Serif 4' → 'source-serif-4'. */
function fontsourceId(family) { return family.toLowerCase().replace(/\s+/g, '-'); }

/** A package's folder at the one version @5 names now (#766). */
function fontsourceAt(id, u = `https://cdn.jsdelivr.net/npm/@fontsource/${id}@`) {
  return (fontsourceAt.c ??= {})[id] ??= fetch(u + '5/package.json').then((r) => r.json())
    .then((p) => p.version || 5, () => 5).then((v) => `${u}${v}/`);
}

/** The family's Fontsource metadata (weights, styles, subsets), or null. */
function fontsourceMeta(family, id = fontsourceId(family)) {
  return (fontsourceMeta.c ??= {})[id] ??= fetch(`https://api.fontsource.org/v1/fonts/${id}`)
    .then((res) => (res.ok ? res.json() : null), () => null);
}

/** The weights the package ships in `style`: the API pairs none (no Libre
 *  Caslon 700 italic file), so italics are read from latin-italic.css. */
function fontsourceWeights(family, style, id = fontsourceId(family)) {
  return (fontsourceWeights.c ??= {})[id + style] ??= fontsourceMeta(family).then(async (m) => {
    if (!m?.styles.includes(style)) return m ? [] : [400, 700];
    const css = style === 'italic' ? await fetch(`${await fontsourceAt(id)}latin-italic.css`).then((r) => (r.ok ? r.text() : ''), () => '') : '';
    const w = [...css.matchAll(/weight: (\d+)/g)].map((x) => +x[1]);
    return w.length ? w : m.weights;
  });
}

// ─── Kit · viewer v2 ── the same in every recipe · postext.dev/cookbook
/** The pages as spreads on a dark desk, page 1 alone, then verso | recto,
 *  each painted when it scrolls near. Other options go to renderPageToCanvas. */
function showPages(docs, { title, width = 460, ...render } = {}) {
  const root = viewer(title);
  const pages = [docs].flat().flatMap((doc) =>
    doc.pages.map((page) => ({ doc, page, n: (doc.pageIndexOffset ?? 0) + page.index })));
  const spreads = [];
  let verso = null;
  for (const p of pages) {
    if (p.n % 2 === 1) { if (verso) spreads.push([verso, null]); verso = p; }
    else { spreads.push([verso, p]); verso = null; }
  }
  if (verso) spreads.push([verso, null]);
  const density = Math.min(window.devicePixelRatio || 1, 2);
  showPages.painter?.disconnect();
  const painter = new IntersectionObserver((entries) => {
    for (const { isIntersecting, target } of entries) {
      if (!isIntersecting) continue;
      painter.unobserve(target);
      const { doc, page } = target.postext;
      renderPageToCanvas(page, doc, target, { ...render, scale: (width * density) / page.width });
    }
  }, { rootMargin: '800px' });
  showPages.painter = painter;
  root.replaceChildren(...spreads.map((pair) => {
    const spread = document.createElement('div');
    spread.className = 'pt-spread';
    for (const p of pair) {
      const figure = document.createElement('figure');
      if (p) {
        const label = p.page.pageLabel || String(p.n + 1);
        const canvas = document.createElement('canvas');
        canvas.postext = p;
        canvas.style.aspectRatio = `${p.page.width} / ${p.page.height}`;
        canvas.setAttribute('role', 'img');
        canvas.setAttribute('aria-label', `Page ${label}`);
        const folio = document.createElement('figcaption');
        folio.textContent = label;
        figure.append(canvas, folio);
        painter.observe(canvas);
      } else figure.className = 'pt-blank';
      spread.append(figure);
    }
    return spread;
  }));
  kitStatus(`${pages.length} ${pages.length === 1 ? 'page' : 'pages'}`);
  document.documentElement.dataset.postext = 'ready';
  return pages.length;
}

/** The desk, the bar and the error reporting, created once. */
function viewer(title) {
  if (!document.getElementById('pt-kit')) {
    document.head.insertAdjacentHTML('beforeend', `<style id="pt-kit">
      :root { color-scheme: dark; }
      body { margin: 0; background: #0e1014; color: #b9bcc4; font: 13px/1.45 system-ui, sans-serif; }
      #pt-bar { position: sticky; top: 0; z-index: 1; display: flex; flex-wrap: wrap; align-items: center;
        gap: 6px 16px; padding: 10px 16px; background: rgb(14 16 20 / .92); backdrop-filter: blur(6px);
        border-bottom: 1px solid #23262d; }
      #pt-bar strong { color: #f4f1ea; font-weight: 600; }
      #pt-actions { display: flex; gap: 12px; margin-left: auto; }
      #pt-actions a, #pt-actions button { color: #d8a21a; font: inherit; background: none; border: 0; padding: 0; cursor: pointer; }
      #pages { display: grid; justify-items: center; gap: 48px; padding: 32px 16px 72px; }
      .pt-spread { display: flex; }
      .pt-spread figure { margin: 0; width: min(460px, 44vw); }
      .pt-spread canvas { display: block; width: 100%; background: #fff;
        box-shadow: 0 1px 2px rgb(0 0 0 / .5), 0 22px 44px -16px rgb(0 0 0 / .8); }
      .pt-spread figure:first-child canvas { box-shadow: inset -14px 0 14px -14px rgb(0 0 0 / .18), 0 1px 2px rgb(0 0 0 / .5), 0 22px 44px -16px rgb(0 0 0 / .8); }
      .pt-spread figcaption { margin-top: 10px; text-align: center; font: 600 10px/1 system-ui, sans-serif;
        letter-spacing: .18em; text-transform: uppercase; color: #6c7079; }
      .pt-blank { visibility: hidden; }
      @media (max-width: 760px) {
        .pt-spread { flex-direction: column; gap: 32px; }
        .pt-spread figure { width: min(460px, 92vw); }
        .pt-blank { display: none; }
      }
    </style>`);
    document.body.insertAdjacentHTML('afterbegin',
      '<header id="pt-bar"><strong id="pt-title"></strong><span id="pt-status" role="status"></span><span id="pt-actions"></span></header>');
    document.getElementById('pt-title').textContent = document.title || 'Postext';
    addEventListener('error', (event) => kitFail(event.error ?? event.message));
    addEventListener('unhandledrejection', (event) => kitFail(event.reason));
  }
  if (title) document.getElementById('pt-title').textContent = title;
  return document.getElementById('pages')
    ?? document.body.appendChild(Object.assign(document.createElement('main'), { id: 'pages' }));
}

function kitStatus(text) {
  viewer();
  document.getElementById('pt-status').textContent = text;
}

function kitFail(error) {
  document.documentElement.dataset.postext = 'error';
  kitStatus(`Error: ${error?.message ?? error}`);
}

// ─── Kit · pdf v3 ── the same in every recipe that exports a PDF
/** The Fontsource files the screen used, as TrueType, with their range and
 *  place: the nearest weight the family ships in that style, upright with no italic;
 *  latin, then what its letters need (kitSubsetsFor). */
async function fontsourceProvider(family, weight, style, request) {
  const id = fontsourceId(family);
  const meta = await fontsourceMeta(family);
  const s = style === 'italic' && meta && !meta.styles.includes('italic') ? 'normal' : style;
  const shipped = meta ? await fontsourceWeights(family, s) : [];
  const weights = shipped.length ? shipped : [400, 700];
  const w = weights.reduce((a, b) => (Math.abs(b - weight) < Math.abs(a - weight) ? b : a));
  const text = String.fromCodePoint(...(request?.codePoints ?? []));
  const files = await Promise.all(['latin', ...kitSubsetsFor(text, meta)].map(async (subset, order) => {
    const res = await fetch(`${await fontsourceAt(id)}files/${id}-${subset}-${w}-${s}.woff2`);
    if (!res.ok) throw new Error(`Fontsource has no ${family} ${w} ${s} ${subset}`);
    return Object.assign(await decompressWoff2(new Uint8Array(await res.arrayBuffer())),
      { unicodeRange: kitRanges()[subset], order });
  }));
  return files.length === 1 ? files[0] : files;
}

/** A "Build the PDF" button; then "Open the PDF" (a new tab: CodePen's frame
 *  shows no PDFs) and a download link. */
function offerPdf(makePdf, filename) {
  viewer();
  const button = Object.assign(document.createElement('button'), { type: 'button', textContent: 'Build the PDF' });
  button.dataset.postextPdf = filename;
  button.addEventListener('click', async () => {
    button.disabled = true;
    button.textContent = 'Building the PDF…';
    try {
      const bytes = await makePdf();
      const url = URL.createObjectURL(new Blob([bytes], { type: 'application/pdf' }));
      const size = `${Math.max(1, Math.round(bytes.length / 1024))} KB`;
      button.replaceWith(
        Object.assign(document.createElement('a'), { href: url, target: '_blank', rel: 'noopener', textContent: 'Open the PDF ↗' }),
        Object.assign(document.createElement('a'), { href: url, download: filename, textContent: `Download ${filename} · ${size}` }));
    } catch (error) {
      button.disabled = false;
      button.textContent = 'Build the PDF';
      kitFail(error);
    }
  });
  document.getElementById('pt-actions').append(button);
}

// ─── /Kit ───────────────────────────────────────────────────────────────────────
```

## 变化

### 去掉第一遍排版

读过警告之后，排一遍就够了。

```diff
-const bare = await buildDocumentWithFonts({ markdown, resources }, { ...config, symbolFont: '' },
-  fonts);
-console.info((bare.contentWarnings ?? []).filter((w) => w.kind === 'glyphFallbackAt')
-  .map(formatWarning).join('\n'));
```

## 常见问题

- **排版警告: 此处字体缺少的字符** (`glyphFallbackAt`). 段落含有其正文字体缺字形的字符：数学字母和运算符（∪、ℵ）、拉丁字体中的希腊字母、箭头（glyphFallback 指明字体，此警告指明段落）。supplier 为绘制它们的字体族，通常是 symbolFont；没有时 PDF 将其印成空框。 解决办法: 指定包含它们的 symbolFont（Noto Sans Math 覆盖大部分数学符号），或选择包含它们的正文字体族。如果字符本身有误（作者想写补集却成了希伯来字母 alef），请改正文本。 ([文档](https://postext.dev/zh/docs/configuration-programmatic-usage.md#文档中的警告))

- 有些字体的 Fontsource 文件含希腊字母（Source Serif 4、Alegreya），会自己排 φ 和 Γ，正文有希腊字母时工具包会加载那个文件，这时只有符号交给符号字体。Crimson Pro 没有希腊文件，所以它的希腊字母来自 Noto Sans Math。
- 符号字体只有一个正体常规字重。粗体标题或斜体公式里的符号都用这个字重排，数学书一向就是这样印的。

## 致谢

- 食谱: Ignacio Ferro ([@drnachio](https://github.com/drnachio))
- 文字: The primer of logical notation, in English and Spanish: Ignacio Ferro, CC-BY-4.0
- 字体: Crimson Pro (OFL-1.1), Cormorant Garamond (OFL-1.1), IBM Plex Sans Condensed (OFL-1.1), Noto Sans Math (OFL-1.1)
- 代码: MIT · 示例内容: CC-BY-4.0

## 相关食谱

- [No. 180 · 学习读本里按颜色分类的高亮](https://postext.dev/zh/cookbook/colour-coded-study-highlights.md): 一本历史读本，关键词用三种颜色高亮：术语绿色、日期琥珀色、人名地名蓝色，三种样式都在 markStyles 里定义并链接到调色板。 · 难度 2 (中级) · 教科书
- [No. 077 · 专名号与书名号，竖排与横排](https://postext.dev/zh/cookbook/proper-name-marks.md): 用:name和:book标记《项羽本纪》，先排成右翻的竖排页，再排成横排页：竖排时线在专名左侧，横排时在专名下方。 · 难度 2 (中级) · 教科书
- [No. 122 · 带训点的汉文和它的训读](https://postext.dev/zh/cookbook/kanbun-kundoku.md): 按日本读本的排法排三则《论语》和一首唐人绝句：返り点和送り仮名用朱色，每段之下是假名书写的训读文。 · 难度 2 (中级) · 教科书
