# Sinais de lógica e de conjuntos com uma fonte de símbolos

> Uma cartilha de lógica em fontes sem ∀, ∈ nem ℵ: symbolFont nomeia Noto Sans Math, que desenha esses sinais e o grego na tela e no PDF.

- Versão HTML: https://postext.dev/pt/cookbook/symbol-font-for-logic
- Receita Nº 185 · Tipo e texto · Nível 2 (Intermediário) · Saídas: Canvas, PDF
- Gêneros: Livros didáticos
- Requer postext ≥ 1.73.0, postext-pdf ≥ 1.73.0 · testada com 1.73.0, postext-pdf 1.73.0 em 2026-11-10
- Páginas: [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
- Abrir no Sandbox: https://postext.dev/pt/sandbox#recipe=symbol-font-for-logic&lang=en (.postext: https://postext.dev/cookbook/symbol-font-for-logic/en/symbol-font-for-logic.postext)
- Última atualização: 2026-11-10
- Outros idiomas: [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), [zh](https://postext.dev/zh/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)

## Em poucas palavras

Um capítulo curto que ensina a ler os sinais da lógica e da teoria dos conjuntos. As fontes do livro não têm esses sinais, então uma segunda fonte os fornece, na tela e no PDF impresso.

## O que você vai compor

O primeiro capítulo de uma cartilha de lógica de bolso, numa página de 155 × 235 mm: uma faixa grená com os sinais do capítulo em corpo grande e depois quatro seções que leem em voz alta ∀, ∃, ∈, ∪, ∅ e ℵ, com as fórmulas no texto corrido e destacadas entre os parágrafos. O livro é composto em Crimson Pro, os títulos em Cormorant Garamond e os rótulos em IBM Plex Sans Condensed. Nenhuma das três tem ∀, ∈ ou letra grega nos arquivos que a Fontsource serve. Um único ajuste, `symbolFont`, coloca a Noto Sans Math atrás de cada uma, e assim todos os sinais saem da mesma fonte no texto, nos títulos, nos cabeços e nas células das tabelas, e o PDF imprime todos.

**Esta receita responde a:**

- Como imprimo os sinais de lógica e conjuntos (∀, ∈, ℵ) e o grego que minha fonte não tem, sem caixas vazias?

## A resposta curta

```js
// script.js, linhas 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())));
```

## Ingredientes

**Ensina**

- [Fonte de símbolos](https://postext.dev/pt/docs/configuration-fonts-colors-viewers.md#fonte-de-símbolos): symbolFont nomeia uma família que desenha os caracteres que faltam às fontes do documento (sinais de lógica e de conjuntos, grego, setas) na tela, no PDF, no HTML e no EPUB, em vez de uma fonte do sistema ou de uma caixa vazia.
- [Fontes incorporadas ao PDF](https://postext.dev/pt/docs/configuration-pdf-output.md#por-que-um-provedor-de-fontes): Um provedor de fontes entrega a renderToPdf os bytes TrueType estáticos de cada fonte que o layout mediu, para que o PDF componha exatamente as mesmas linhas.

**Também usa**

- [Fontes antes da diagramação](https://postext.dev/pt/docs/configuration-programmatic-usage.md#carregar-as-fontes-antes-da-diagramação)
- [Sobrescritos e subscritos](https://postext.dev/pt/docs/document-format-inline.md#formatação-em-linha)
- [Estilos de parágrafo](https://postext.dev/pt/docs/configuration-styles.md#estilos-de-parágrafo)
- [Tabelas a partir de dados](https://postext.dev/pt/docs/document-format-resources.md#inserção-em-bloco-opcional-posição-explícita-no-fluxo)
- [Estilo de tabela](https://postext.dev/pt/docs/configuration-resources.md#estilo-de-tabela)
- [Aberturas desenhadas](https://postext.dev/pt/docs/configuration-headings.md#largura-e-design-avançado)
- [Atributos de título](https://postext.dev/pt/docs/document-format.md#atributos-de-título)
- [Cabeços e fólios](https://postext.dev/pt/docs/configuration-headers-footers.md#cabeçalhos-e-rodapés)
- [Margens espelhadas](https://postext.dev/pt/docs/configuration-page-layout.md#margens-espelhadas)
- [Paleta de cores semântica](https://postext.dev/pt/docs/configuration-fonts-colors-viewers.md#paleta-de-cores)
- [Exportação para PDF](https://postext.dev/pt/docs/configuration-pdf-output.md#geração-de-pdf)
- [Figuras exatamente aqui](https://postext.dev/pt/docs/document-format-resources.md#inserção-em-bloco-opcional-posição-explícita-no-fluxo)
- [Figura e Tabela no seu idioma](https://postext.dev/pt/docs/configuration-resources.md#tipos-de-recurso)
- [Cabeços por tipo de página](https://postext.dev/pt/docs/configuration-headers-footers.md#elementos-de-texto)
- [Tipos de recurso personalizados](https://postext.dev/pt/docs/configuration-resources.md#tipos-de-recurso)

**A configuração em resumo**

- [`bodyText`](https://postext.dev/pt/docs/configuration-text.md#texto-do-corpo), [`captionStyle`](https://postext.dev/pt/docs/configuration-resources.md#estilo-de-legenda), [`colorPalette`](https://postext.dev/pt/docs/configuration-fonts-colors-viewers.md#paleta-de-cores), [`footer`](https://postext.dev/pt/docs/configuration-headers-footers.md#cabeçalhos-e-rodapés), [`header`](https://postext.dev/pt/docs/configuration-headers-footers.md#cabeçalhos-e-rodapés), [`headings`](https://postext.dev/pt/docs/configuration-headings.md#títulos), [`layout`](https://postext.dev/pt/docs/configuration-page-layout.md#diagramação), [`locale`](https://postext.dev/pt/docs/configuration-language.md#hifenização), [`page`](https://postext.dev/pt/docs/configuration-page-layout.md#página), [`paragraphStyles`](https://postext.dev/pt/docs/configuration-styles.md#estilos-de-parágrafo), [`resourceTypes`](https://postext.dev/pt/docs/configuration-resources.md#tipos-de-recurso), [`symbolFont`](https://postext.dev/pt/docs/configuration-fonts-colors-viewers.md#fonte-de-símbolos), [`tableStyle`](https://postext.dev/pt/docs/configuration-resources.md#estilo-de-tabela)

**API**

- [`buildDocumentWithFonts`](https://postext.dev/pt/docs/configuration-programmatic-usage.md#carregar-as-fontes-antes-da-diagramação), [`decompressWoff2`](https://postext.dev/pt/docs/configuration-pdf-output.md#provedor-de-fontes-no-navegador-fontsource--woff2), [`defaultResourceTypes`](https://postext.dev/pt/docs/configuration-resources.md#tipos-de-recurso), `formatWarning`, [`parseTSV`](https://postext.dev/pt/docs/document-format-resources.md#inserção-em-bloco-opcional-posição-explícita-no-fluxo), [`renderPageToCanvas`](https://postext.dev/pt/docs/configuration-programmatic-usage.md#renderizar-uma-página-como-bitmap), [`renderToPdf`](https://postext.dev/pt/docs/configuration-pdf-output.md#geração-de-pdf)

**Tipos**

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

## Preparo

### 1 · Uma fonte de símbolos atrás de todas

O código deste passo é a resposta curta, mais acima. `symbolFont: 'Noto Sans Math'` ([fonte de símbolos](https://postext.dev/pt/docs/configuration-fonts-colors-viewers.md#fonte-de-símbolos)) põe essa família atrás de todas as que a configuração nomeia: um caractere que a fonte não tem é desenhado com a Noto Sans Math, no corpo e na cor da fonte, e o resto da linha continua na dela. A Fontsource serve a Noto Sans Math inteira no arquivo `latin`, com 3.033 caracteres, mas o kit declara esse arquivo só para a faixa latina, e o navegador não pediria ∀ a ele. O `resolve` e o `pdfFonts` da receita entregam o mesmo arquivo sem faixa, na tela e ao `renderToPdf`. Só mudam de fonte os caracteres que faltam: a Crimson Pro tem ¬, então a negação no texto continua em Crimson Pro.

### 2 · Uma primeira composição sem ela mostra o que falta

```js
// script.js, linhas 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'));
```

A primeira composição deixa `symbolFont` vazio e imprime seus avisos `glyphFallbackAt`, um para cada parágrafo, título ou tabela que traz caracteres para os quais sua fonte não tem glifo, com a página e os caracteres. A edição em inglês dá dezoito: catorze parágrafos em Crimson Pro, três títulos em Cormorant Garamond e a linha de cabeçalho da tabela 1.1 em IBM Plex Sans Condensed negrito. Sem uma família que os desenhe, a tela toma os sinais de uma fonte do sistema do leitor e o PDF imprime uma caixa vazia para cada um. A segunda composição, com a fonte de símbolos, é a que aparece na página; seus avisos nomeiam `"Noto Sans Math"` como a família que os desenha.

### 3 · Os sinais da abertura são texto

```js
// script.js, linhas 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) },
] } };
```

A linha de sete sinais sob o título é um texto de design em Cormorant Garamond a 30 pt, alimentado pelo atributo `signs` do título. A Cormorant Garamond não tem nenhum deles, então os sete saem da fonte de símbolos, no branco da faixa. Um espacejamento de 9 pt os distribui pela largura da mancha.

### 4 · Células e cabeços usam a mesma fonte

```js
// script.js, linhas 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'),
];
```

A tabela-verdade é construída com os próprios conectivos: o cabeçalho de cada coluna é a fórmula, e cada célula, o que a fórmula dá naquela linha. As células de cabeçalho vão em IBM Plex Sans Condensed negrito itálico e as do corpo em Crimson Pro; a fonte de símbolos atende às duas. Seu único estilo redondo desenha para todos os pesos e inclinações, de modo que o ∧ do cabeçalho em negrito e o ∈ de uma fórmula em itálico são o mesmo sinal reto. O cabeço da página ímpar imprime a seção em curso, `{firstMark.h2}`, e *SETS: ∈, ∪, ∩ AND ∅*, na página 3, também tira seus sinais da Noto Sans Math.

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

*Página 3: as fórmulas de conjuntos, em Crimson Pro itálico, com todos os sinais da Noto Sans Math.*

## A receita completa

Um único arquivo, composto a partir da pasta da receita com o texto de exemplo e o kit comum das Receitas já incluídos; ele monta a própria página. Para executá-lo, coloque-o em um `<script type="module">` de uma página vazia ou cole-o no painel JS de um pen novo do CodePen (como módulo). Ele importa o postext do esm.sh, então não há nada para instalar nem compilar.

- Pasta da receita: 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 ───────────────────────────────────────────────────────────────────────
```

## Variações

### Tire a primeira composição

Lidos os avisos, uma composição basta.

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

## Erros comuns

- **Aviso de diagramação: Caracteres que a fonte não tem, aqui** (`glyphFallbackAt`). Um parágrafo tem caracteres que a fonte do seu texto não tem: letras e operadores matemáticos (∪, ℵ), grego numa fonte latina, setas (glyphFallback nomeia a fonte, este o parágrafo). supplier é a família que os desenha, normalmente a symbolFont; sem ela, o PDF imprime-os como caixas vazias. Solução: Indique uma symbolFont que os tenha (Noto Sans Math cobre quase toda a matemática) ou escolha uma família de texto que os tenha. Se o caractere estiver errado (um álef hebraico onde o autor queria um complemento), corrija o texto. ([Documentação](https://postext.dev/pt/docs/configuration-programmatic-usage.md#avisos-no-documento))

- Uma fonte cujos arquivos da Fontsource incluem o grego (Source Serif 4, Alegreya) compõe φ e Γ por conta própria, e o kit carrega esse arquivo quando o texto tem grego: nesse caso só os sinais vão para a fonte de símbolos. A Crimson Pro não tem arquivo grego, então o grego dela sai da Noto Sans Math.
- A fonte de símbolos tem um único estilo, redondo e regular. Um título em negrito ou uma fórmula em itálico compõe seus sinais nesse estilo, que é como a matemática os imprime.

## Créditos

- Receita: Ignacio Ferro ([@drnachio](https://github.com/drnachio))
- Texto: The primer of logical notation, in English and Spanish: Ignacio Ferro, CC-BY-4.0
- Tipos: Crimson Pro (OFL-1.1), Cormorant Garamond (OFL-1.1), IBM Plex Sans Condensed (OFL-1.1), Noto Sans Math (OFL-1.1)
- Código: MIT · Conteúdo de exemplo: CC-BY-4.0

## Relacionadas

- [Nº 180 · Destaques por cor em um livro de leituras](https://postext.dev/pt/cookbook/colour-coded-study-highlights.md): Um livro de leituras de história cujas palavras-chave levam três cores (verde para termos, âmbar para datas, azul para nomes) vindas de três markStyles. · Nível 2 (Intermediário) · Livros didáticos
- [Nº 077 · Marcas de nome e de título, na vertical e na horizontal](https://postext.dev/pt/cookbook/proper-name-marks.md): Os Anais básicos de Xiang Yu com marcas :name e :book, na vertical e na horizontal: as linhas ficam à esquerda dos nomes e depois embaixo deles. · Nível 2 (Intermediário) · Livros didáticos
- [Nº 122 · Kanbun com suas marcas de leitura e a leitura japonesa](https://postext.dev/pt/cookbook/kanbun-kundoku.md): Três ditos dos Analectos e uma quadra Tang como num livro escolar japonês: marcas de retorno e okurigana em vermelhão, e a leitura em kana sob cada trecho. · Nível 2 (Intermediário) · Livros didáticos
