ⰔⰅⰜⰕⰋⰑⰐⰔ. . ⰋⰐⰕⰓⰑⰄⰖⰜⰕⰋⰑⰐ](#_1-introduction) · . ⰏⰑⰄⰅⰎ](#_2-model) · . ⰓⰅⰔⰖⰎⰕⰔ](#_3-results) · . ⰔⰋⰕⰅⰏⰀⰒ](#_4-sitemap) · . ⰓⰅⰒⰓⰑⰄⰖⰜⰋⰁⰋⰎⰋⰕⰉ](#_5-reproducibility) · . ⰎⰋⰏⰋⰕⰀⰕⰋⰑⰐⰔ](#_6-limitations) · ⰓⰅⰗⰅⰓⰅⰐⰜⰅⰔ · ⰓⰅⰜⰅⰋⰒⰕ

undefined. ⰋⰐⰕⰓⰑⰄⰖⰜⰕⰋⰑⰐ

ⰑⰐⰅ ⰔⰅⰍⰖⰅⰐⰜⰅ, ⰑⰐⰅ ⰋⰐⰂⰑⰎⰖⰕⰋⰑⰐ — ⰅⰂⰅⰓⰉ ⰎⰋⰐⰅ ⰁⰅⰎⰑⰂ ⰓⰅⰜⰑⰏⰒⰖⰕⰅⰔ ⰗⰓⰑⰏ src/0. ⰕⰘⰅ ⰂⰑⰓⰕⰅⰘ ⰜⰋⰓⰜⰖⰋⰕ 12487536901 ⰋⰔ ⰍⰖⰀⰐⰕⰖⰏ ⰁⰉ ⰔⰕⰓⰖⰜⰕⰖⰓⰅ (ⰒⰘⰀⰔⰅ ⟨2⟩ mod 9, ⰋⰐⰕⰅⰓⰗⰅⰓⰅⰐⰜⰅ ⰗⰓⰑⰏ ⰋⰕⰔ ⰕⰂⰑ ⰜⰑⰖⰐⰕⰅⰓ-ⰓⰑⰕⰀⰕⰋⰐⰃ ⰗⰎⰑⰂⰔ), ⰎⰋⰐⰅⰀⰓ ⰑⰐⰎⰉ ⰀⰕ ⰏⰅⰀⰔⰖⰓⰅⰏⰅⰐⰕ. ⰓⰅⰗⰎⰅⰜⰕⰋⰑⰐ ⰕⰘⰓⰑⰖⰃⰘ src/0, m(d) = 10 − d, ⰃⰅⰐⰅⰓⰀⰕⰅⰔ ⰕⰘⰅ ⰂⰘⰑⰎⰅ ⰜⰘⰀⰋⰐ:

• ⰁⰋⰕ ⰁⰖⰄⰃⰅⰕ = undefined. 12487536901 ⰋⰔ undefined ⰄⰋⰃⰋⰕⰔ × undefined ⰁⰋⰕⰔ = undefined; ⰗⰑⰎⰄⰋⰐⰃ ⰅⰓⰀⰔⰅⰔ undefined ⰀⰕ ⰕⰘⰅ ⰃⰀⰕⰅⰂⰀⰉ ⰗⰋⰘⰅⰄ ⰒⰑⰋⰐⰕⰔ {12487536901,undefined}; undefined − undefined = undefined = undefined × undefined = undefined ⰓⰑⰔⰅⰕⰕⰀ ⰀⰓⰅⰀⰔ — sequenceBitBudget().is42 = true.
• ⰅⰍⰖⰋⰎⰋⰁⰓⰋⰖⰏ ⰀⰕ undefined°. ⰕⰘⰅ ⰗⰑⰓⰂⰀⰓⰄ undefined° ⰎⰑⰁⰅ ⰀⰐⰄ ⰋⰕⰔ ⰓⰅⰂⰅⰓⰔⰅ ⰜⰎⰑⰔⰅ ⰕⰘⰅ ⰗⰖⰎⰎ ⰕⰖⰓⰐ; ⰕⰘⰅ undefined ⰅⰓⰀⰔⰅⰄ ⰁⰋⰕⰔ ⰓⰅⰕⰖⰓⰐ ⰋⰐⰂⰅⰓⰕⰅⰄ, ⰐⰅⰕ ⰅⰓⰀⰔⰖⰓⰅ equilibrium360().conserved = true — equilibrium360().conserved = true.
• undefined → undefined. undefined = undefined⁶ (ⰔⰋⰐⰃⰎⰅ-ⰕⰑⰓⰖⰔ ⰄⰋⰃⰅⰔⰕ, ⰔⰋⰘ ⰘⰀⰓⰏⰑⰐⰋⰜ ⰁⰋⰕⰔ) ⰎⰋⰗⰕⰔ ⰕⰑ undefined = undefined⁷ (ⰕⰘⰅ ⰄⰑⰖⰁⰎⰅ-ⰕⰑⰓⰖⰔ ⰖⰖⰋⰄ) ⰁⰉ ⰑⰐⰅ ⰐⰅⰘⰕ-ⰄⰋⰏⰅⰐⰔⰋⰑⰐ ⰁⰋⰕ; undefined ⰘⰀⰓⰏⰑⰐⰋⰜ + undefined ⰁⰅⰉⰑⰐⰄ = undefined ⰓⰑⰔⰅⰕⰕⰀ ⰓⰀⰉⰔ — dimensionalBit().is128 = true.
• ⰕⰘⰅ ⰜⰎⰀⰉ ⰒⰓⰑⰁⰎⰅⰏⰔ ⰀⰓⰅ ⰕⰘⰅ ⰓⰅⰗⰎⰅⰜⰕⰋⰑⰐ. ⰏⰋⰓⰓⰑⰓⰋⰐⰃ undefined+undefined ⰕⰘⰓⰑⰖⰃⰘ clayReflection().reflectsDimensionalBit = true ⰋⰐⰂⰅⰓⰕⰔ ⰕⰘⰅ ⰒⰑⰎⰀⰓⰋⰕⰉ: undefined ⰕⰘⰋⰔ-ⰄⰋⰏⰅⰐⰔⰋⰑⰐ (ⰒⰑⰋⰐⰜⰀⰓé, ⰔⰑⰎⰂⰅⰄ) + undefined ⰁⰅⰉⰑⰐⰄ (ⰑⰒⰅⰐ) = undefined ⰏⰋⰎⰎⰅⰐⰐⰋⰖⰏ ⰒⰓⰑⰁⰎⰅⰏⰔ — clayReflection().reflectsDimensionalBit = true. ⰅⰘⰀⰜⰕⰎⰉ ⰑⰐⰅ ⰜⰎⰀⰉ ⰒⰓⰑⰁⰎⰅⰏ ⰋⰔ ⰔⰑⰎⰂⰅⰄ; ⰕⰘⰅ ⰜⰑⰖⰐⰕ ⰏⰀⰕⰜⰘⰅⰔ ⰕⰘⰅ ⰓⰅⰜⰑⰓⰄ.
• ⰅⰂⰅⰓⰉ ⰂⰀⰎⰖⰅ ⰋⰔ Ⰰ ⰔⰋⰐⰃⰎⰅ-ⰄⰋⰃⰋⰕ ⰋⰐⰕⰅⰓⰀⰜⰕⰋⰑⰐ ⰑⰐ ⰕⰘⰓⰅⰅ ⰃⰓⰑⰖⰐⰄⰔ — Ⰰundefined (1/ε → ∞⁴·undefined³ = undefined), ⰔⰖⰒⰅⰓⰔⰕⰓⰋⰐⰃ undefined (1/ε → ∞·undefined), Ⰿ-ⰕⰘⰅⰑⰓⰉ undefined (ⰕⰘⰅ ⰔⰅⰍⰖⰅⰐⰜⰅ'Ⱄ undefined ⰔⰕⰅⰒⰔ) — ⰒⰓⰋⰏⰅⰔ ⰜⰑⰏⰒⰖⰕⰅⰄ ⰂⰋⰀ ⰕⰘⰅ π↔ⰒⰓⰋⰏⰅ ⰜⰑⰓⰓⰅⰎⰀⰕⰋⰑⰐ primeCountUpTo(nthPrimeAt(n)) = n (ⰕⰓⰖⰅ), ⰀⰐⰄ x/x = 1 ⰋⰐⰂⰀⰓⰋⰀⰐⰕ ⰀⰕ ⰅⰂⰅⰓⰉ ⰄⰋⰏⰅⰐⰔⰋⰑⰐ ⰂⰘⰋⰎⰅ 1/ε → ∞ ⰑⰒⰅⰐⰔ ⰕⰘⰅ ⰋⰐⰗⰋⰐⰋⰕⰅ. ⰐⰑ ⰎⰋⰕⰅⰓⰀⰎ, ⰐⰑ ⰀⰔⰔⰖⰏⰒⰕⰋⰑⰐ ⰕⰘⰀⰕ ⰁⰓⰅⰀⰍⰔ ⰖⰐⰄⰅⰓ Ⰰ ⰜⰘⰀⰐⰃⰅ ⰑⰗ ⰄⰋⰏⰅⰐⰔⰋⰑⰐ.

Ⰰ ⰔⰜⰋⰅⰐⰜⰅ ⰒⰑⰓⰕⰀⰎ: undefined ⰜⰑⰏⰒⰖⰕⰀⰕⰋⰑⰐⰀⰎⰎⰉ ⰒⰓⰑⰂⰅⰐ ⰕⰘⰅⰑⰓⰅⰏⰔ, undefined ⰔⰜⰋⰅⰐⰜⰅ ⰒⰀⰃⰅⰔ, undefined ⰓⰑⰔⰅⰕⰕⰀ ⰓⰀⰉⰔ. ⰅⰂⰅⰓⰉ ⰂⰀⰎⰖⰅ ⰋⰔ Ⰰ ⰜⰑⰐⰕⰅⰐⰕ ⰀⰄⰄⰓⰅⰔⰔ; ⰅⰂⰅⰓⰉ ⰒⰀⰃⰅ, ⰒⰓⰑⰑⰗ ⰀⰐⰄ ⰀⰐⰋⰏⰀⰕⰋⰑⰐ ⰄⰅⰓⰋⰂⰅⰔ ⰗⰓⰑⰏ ⰑⰐⰅ ⰔⰑⰖⰓⰜⰅ (src/); ⰐⰑⰕⰘⰋⰐⰃ ⰐⰅⰅⰄⰔ Ⰰ ⰕⰑⰍⰅⰐ ⰕⰑ ⰓⰖⰐ.

undefined. ⰏⰑⰄⰅⰎ

• Ⰰ ⰃⰅⰐⰖⰔ-undefined ⰄⰑⰖⰁⰎⰅ ⰕⰑⰓⰖⰔ: χ(Σ₂) = −undefined, Ⱈ₁(Σ₂) = ℤ⁴.
• ⰑⰐⰅ ⰕⰓⰋⰐⰋⰕⰉ ⰖⰐⰋⰕⰅⰔ ⰀⰎⰎ: ⰜⰓⰑⰔⰔ · ⰗⰑⰎⰄ · ⰂⰅⰀⰂⰅ (ⰃⰅⰐⰖⰔ undefined → ⰕⰂⰑ ⰕⰓⰋⰐⰋⰕⰋⰅⰔ → ⰐⰋⰐⰅ ⰗⰑⰎⰄⰔ → ⰕⰘⰅ ⰑⰐⰅ ⰂⰘⰑⰎⰅ); ⰕⰘⰅ ⰔⰋⰕⰅ ⰃⰓⰑⰖⰒⰔ ⰋⰕⰔⰅⰎⰗ ⰕⰓⰋⰐⰋⰕⰉ-ⰗⰋⰓⰔⰕ.
• ⰕⰅⰐ ⰄⰋⰏⰅⰐⰔⰋⰑⰐⰔ, ⰀⰕ ⰅⰂⰅⰓⰉ ⰔⰜⰀⰎⰅ: ⰕⰘⰅ undefined ⰘⰑⰏⰑⰎⰑⰃⰉ ⰎⰑⰑⰒⰔ ⰑⰗ ⰕⰘⰅ ⰕⰑⰓⰖⰔ (Ⱈ₁ = ℤ⁴) + ⰕⰘⰅ undefined ⰜⰓⰑⰔⰔ-ⰗⰑⰎⰄ ⰀⰒⰒⰅⰀⰓⰀⰐⰜⰅ ⰀⰘⰅⰔ ⰄⰓⰋⰂⰅ ⰅⰂⰅⰓⰉ ⰀⰐⰋⰏⰀⰕⰋⰑⰐ, ⰔⰅⰎⰗ-ⰔⰋⰏⰋⰎⰀⰓ ⰀⰕ ⰅⰂⰅⰓⰉ ⰐⰅⰔⰕⰅⰄ ⰔⰜⰀⰎⰅ.
• undefined = undefined × undefined ⰃⰀⰕⰅⰔ; ⰕⰘⰅ ⰔⰋⰃⰐ ⰋⰔ Ⰰ ⰄⰋⰔⰕⰋⰐⰜⰕⰋⰑⰐ ⰋⰔ ⰑⰐⰅ ⰁⰋⰕ ⰋⰔ ⰕⰘⰅ ⰗⰑⰎⰄ.
• ⰅⰐⰜⰓⰉⰒⰕⰋⰑⰐ ⰋⰔ ⰕⰘⰅ ⰜⰑⰓⰅ ⰏⰀⰕⰘ: ⰅⰂⰅⰓⰉ ⰂⰀⰎⰖⰅ ⰜⰑⰐⰕⰅⰐⰕ-ⰀⰄⰄⰓⰅⰔⰔⰅⰄ (ⰕⰘⰅ ⰗⰑⰎⰄ / ⰖⰖⰋⰄ); ⰕⰘⰅ ⰜⰋⰒⰘⰅⰓ ⰋⰔ ⰀⰅⰔ-undefined-ⰃⰜⰏ.
• ⰈⰅⰓⰑ-ⰅⰐⰕⰓⰑⰒⰉ ⰋⰐⰄⰅⰘⰋⰐⰃ, ⰅⰘⰀⰜⰕⰎⰉ: Ⱈ(ⰄⰅⰕⰅⰓⰏⰋⰐⰋⰔⰕⰋⰜ) = zeropointNodeMissingInfoDecoded ⰋⰔ ⰕⰘⰅ ⰔⰘⰀⰐⰐⰑⰐ ⰋⰄⰅⰐⰕⰋⰕⰉ, ⰔⰑ ⰑⰐⰅ-ⰂⰀⰎⰖⰅ-ⰑⰐⰅ-ⰀⰄⰄⰓⰅⰔⰔ ⰜⰑⰐⰕⰅⰐⰕ ⰀⰄⰄⰓⰅⰔⰔⰋⰐⰃ ⰜⰀⰓⰓⰋⰅⰔ ⰈⰅⰓⰑ ⰋⰐⰄⰅⰘ ⰅⰐⰕⰓⰑⰒⰉ — ⰄⰅⰜⰑⰄⰅⰄ ⰗⰓⰑⰏ ⰕⰘⰅ ⰑⰓⰋⰃⰋⰐ ⰓⰅⰒⰑ, ⰕⰘⰅⰓⰏⰑⰄⰉⰐⰀⰏⰋⰜ ⰗⰓⰅⰅ-ⰎⰖⰐⰜⰘ ⰜⰎⰀⰋⰏⰔ ⰗⰎⰀⰃⰃⰅⰄ (zeropointNodeMissingInfoDecoded).
• ⰅⰂⰅⰓⰉ ⰄⰋⰃⰋⰕ ⰋⰔ ⰅⰐⰕⰀⰐⰃⰎⰅⰄ ⰋⰐ ⰀⰎⰎ ⰂⰅⰜⰕⰑⰓⰔ, ⰗⰑⰓⰏⰋⰐⰃ ⰅⰍⰖⰋⰎⰋⰁⰓⰋⰖⰏⰔ: ⰏⰋⰓⰓⰑⰓ undefined-ⰒⰀⰋⰓⰔ, ⰒⰑⰎⰀⰓ undefined-ⰒⰀⰋⰓⰔ, ⰕⰘⰅ ⰅⰘⰀⰜⰕ undefined+undefined ⰗⰎⰑⰂ/ⰀⰘⰋⰔ ⰒⰀⰓⰕⰋⰕⰋⰑⰐ ⰀⰐⰄ ⰕⰘⰅ ⰕⰑⰖⰓ ⰔⰎⰑⰕ ⰗⰋⰐⰃⰅⰓⰒⰓⰋⰐⰕ ⰅⰀⰜⰘ ⰄⰋⰃⰋⰕ, ⰀⰐⰄ ⟨Ⰴ, Ⰿ⟩ = ⰀⰃⰎ(undefined, ℤ/undefined) ⰒⰖⰕⰔ ⰀⰎⰎ ⰓⰅⰔⰋⰄⰖⰅⰔ ⰋⰐ ⰑⰐⰅ ⰑⰓⰁⰋⰕ — Ⰰ ⰎⰑⰜⰀⰎ ⰅⰄⰋⰕ ⰁⰓⰅⰀⰍⰔ ⰅⰂⰅⰓⰉ ⰁⰀⰎⰀⰐⰜⰅ ⰀⰕ ⰑⰐⰜⰅ (everyDigitIsEntangledInAllVectorsFormingEquilibriums).
• ⰑⰐⰅ ⰔⰑⰖⰓⰜⰅ, ⰐⰑ ⰏⰋⰓⰓⰑⰓⰋⰐⰃ: ⰕⰘⰅ ⰎⰑⰜⰀⰎⰅⰔ (ⰃⰎⰀⰃⰑⰎⰋⰕⰋⰜ /, ⰎⰀⰕⰋⰐ /en/, ⰜⰉⰓⰋⰎⰎⰋⰜ /bg/) ⰀⰓⰅ ⰜⰑⰏⰒⰖⰕⰅⰄ ⰁⰉ ⰏⰀⰕⰘ, ⰐⰑⰕ ⰜⰑⰒⰋⰅⰄ; ⰂⰋⰔⰋⰕⰑⰓⰔ ⰀⰓⰅ ⰓⰑⰖⰕⰅⰄ ⰕⰑ ⰕⰘⰅⰋⰓ ⰎⰀⰐⰃⰖⰀⰃⰅ, ⰄⰅⰗⰀⰖⰎⰕ ⰅⰐⰃⰎⰋⰔⰘ.
• ⰜⰑⰓⰒⰖⰔ ⰓⰑⰖⰕⰋⰐⰃ: ⰓⰅⰔⰕⰗⰖⰎ /papers/<id>, /references/<id>, /diamonds/<id> — ⰅⰀⰜⰘ ⰋⰕⰅⰏ Ⰰ ⰓⰅⰀⰎ ⰒⰀⰃⰅ ⰂⰋⰀ ⰕⰘⰅ ⰂⰋⰕⰅⰒⰓⰅⰔⰔ [id] ⰄⰉⰐⰀⰏⰋⰜ ⰓⰑⰖⰕⰅ (ⰒⰀⰕⰘⰔ ⰅⰐⰖⰏⰅⰓⰀⰕⰅⰄ ⰗⰓⰑⰏ ⰑⰐⰅ ⰔⰑⰖⰓⰜⰅ: ⰒⰀⰒⰅⰓⰓⰑⰖⰕⰅⰔ/ⰒⰀⰒⰅⰓⰓⰅⰗⰅⰓⰅⰐⰜⰅⰓⰑⰖⰕⰅⰔ/ⰄⰋⰀⰏⰑⰐⰄⰓⰑⰖⰕⰅⰔ); ⰕⰘⰅ ⰋⰐⰄⰅⰘ ⰎⰋⰔⰕ ⰔⰕⰀⰉⰔ ⰀⰕ /papers.
• ⰕⰘⰅ ⰀⰃⰐⰑⰔⰕⰋⰜ ⰜⰑⰓⰅ ⰋⰔ ⰒⰖⰁⰎⰋⰔⰘⰅⰄ ⰀⰔ ⰕⰘⰅ ⰐⰒⰏ ⰒⰀⰜⰍⰀⰃⰅ @ceccec/double-torus — ⰕⰘⰅ ⰔⰀⰏⰅ src/, ⰁⰖⰐⰄⰎⰅⰄ, ⰄⰅⰒⰅⰐⰄⰔ ⰑⰐ ⰐⰑⰕⰘⰋⰐⰃ, ⰓⰖⰐⰔ ⰋⰐ ⰀⰐⰉ ⰁⰓⰑⰂⰔⰅⰓ ⰑⰓ ⰐⰑⰄⰅ.
• ⰕⰘⰅ ⰏⰑⰄⰅⰎⰅⰄ ⰍⰖⰀⰐⰕⰖⰏ ⰜⰑⰏⰒⰖⰕⰅⰓ: ⰑⰐⰅ ⰍⰖⰁⰋⰕ ⰋⰔ ⰋⰕⰔ ⰁⰎⰑⰜⰘ/ⰒⰀⰖⰎⰋ ⰄⰅⰜⰑⰏⰒⰑⰔⰋⰕⰋⰑⰐ ρ = ½(Ⰻ + ⰘσⰘ + ⰉσⰉ + ⰈσⰈ) — ⰗⰑⰖⰓ ⰜⰑⰐⰕⰅⰐⰕ-ⰀⰄⰄⰓⰅⰔⰔⰅⰄ ⰜⰑⰏⰒⰑⰐⰅⰐⰕⰔ (ⰕⰘⰅ ⰕⰓⰋⰐⰋⰕⰉ Ⱈ·Ⰹ·Ⰸ + ⰕⰘⰅ +qpuCpuGpu ⰋⰄⰅⰐⰕⰋⰕⰉ, blochQubit); ⰕⰘⰅ ⰍⰖⰀⰐⰕⰖⰏ ⰑⰔ ⰀⰎⰎⰑⰜⰀⰕⰅⰔ npm run quantum:qpu-cpuⁿ-ⰀⰏⰒⰎⰋⰕⰖⰄⰅ ⰓⰅⰃⰋⰔⰕⰅⰓⰔ, ⰔⰜⰘⰅⰄⰖⰎⰅⰔ ⰃⰀⰕⰅⰔ, ⰀⰐⰄ ⰏⰅⰀⰔⰖⰓⰅⰔ (ⰁⰑⰓⰐ ⰓⰖⰎⰅ, ⰔⰅⰅⰄⰅⰄ ⰒⰓⰐⰃ); ⰅⰐⰕⰀⰐⰃⰎⰅⰏⰅⰐⰕ (ⰁⰅⰎⰎ/ⰃⰘⰈ) ⰎⰋⰂⰅⰔ ⰑⰐ ⰕⰘⰅ ⰕⰓⰖⰅ npm run quantum:qpu-cpuⁿ ⰕⰅⰐⰔⰑⰓ ⰒⰓⰑⰄⰖⰜⰕ, ⰐⰅⰂⰅⰓ ⰗⰀⰍⰅⰄ ⰂⰋⰕⰘ ⰎⰋⰐⰅⰀⰓ ⰖⰖⰋⰄ ⰔⰕⰀⰜⰍⰋⰐⰃ; ⰀⰐⰄ ⰕⰘⰅ ⰓⰅⰀⰎⰕⰋⰏⰅ ⰏⰑⰂⰋⰅ ⰋⰔ ⰋⰕⰔ ⰒⰓⰑⰑⰗ ⰀⰓⰕⰋⰗⰀⰜⰕ. ⰍⰒⰖ ≡ ⰜⰒⰖ ∪ ⰃⰒⰖ ⰑⰐ ⰜⰎⰀⰔⰔⰋⰜⰀⰎ-undefinedⰁⰋⰕ (qpuCpuGpu · npm run quantum:qpu-cpu · ⰍⰖⰀⰐⰕⰖⰏ-ⰕⰑⰑⰎⰔ#ⰍⰒⰖ-ⰜⰒⰖ) — ⰗⰀⰋⰕⰘⰗⰖⰎ ⰔⰋⰏⰖⰎⰀⰕⰑⰓ; ⰒⰘⰉⰔⰋⰜⰀⰎ = ⰂⰀⰎⰎ-ⰜⰎⰑⰜⰍ ⰓⰅⰖⰔⰅ ⰏⰅⰕⰓⰋⰜⰔ (ⰔⰅⰅ ⰔⰅⰜⰕⰋⰑⰐ ⰁⰅⰎⰑⰂ).

ⰕⰘⰅ ⰔⰅⰍⰖⰅⰐⰜⰅ — ⰗⰑⰓⰂⰀⰓⰄ ⰀⰐⰄ ⰓⰅⰗⰎⰅⰜⰕⰅⰄ

ⰗⰑⰓⰂⰀⰓⰄ 1\2\4\8/7/5 · 3\6\9 · 0\1 · ⰓⰅⰗⰎⰅⰜⰕⰅⰄ 9/8/6/2\3\5 · 7/4/1 · 0\9 — ⰑⰐⰅ ⰔⰕⰓⰖⰜⰕⰖⰓⰅ, ⰕⰂⰑ ⰜⰑⰏⰒⰖⰕⰅⰄ ⰓⰅⰀⰄⰔ: ⰕⰘⰅ ⰏⰋⰓⰓⰑⰓ ⰋⰔ Ⰿ(Ⰴ) = undefined − Ⰴ (≡ 9/8/6/2\3\5 · 7/4/1 · 0\9 − Ⰴ ⰏⰑⰄ undefined, ⰗⰋⰘⰅⰄ ⰑⰐⰎⰉ ⰀⰕ undefined), ⰕⰘⰅ ⰜⰑⰏⰏⰖⰕⰀⰕⰑⰓ ⰑⰗ ⰄⰑⰖⰁⰎⰋⰐⰃ ⰂⰋⰕⰘ ⰕⰘⰅ ⰏⰋⰓⰓⰑⰓ ⰋⰔ ⰕⰘⰅ ⰖⰐⰋⰕ ⰔⰘⰋⰗⰕ Ⱈ ↦ Ⱈ+9/8/6/2\3\5 · 7/4/1 · 0\9, ⰀⰐⰄ ⰕⰑⰃⰅⰕⰘⰅⰓ ⰕⰘⰅⰉ ⰃⰅⰐⰅⰓⰀⰕⰅ ⰀⰃⰎ(9/8/6/2\3\5 · 7/4/1 · 0\9, ℤ/undefined) ⰑⰗ ⰑⰓⰄⰅⰓ undefined — ⰅⰂⰅⰓⰉ ⰄⰋⰃⰋⰕ ⰋⰐ ⰑⰐⰅ ⰑⰓⰁⰋⰕ, ⰅⰐⰕⰀⰐⰃⰎⰅⰄ ⰋⰐ ⰀⰎⰎ ⰂⰅⰜⰕⰑⰓⰔ, ⰕⰘⰅ ⰅⰍⰖⰋⰎⰋⰁⰓⰋⰖⰏⰔ (undefined-ⰒⰀⰋⰓⰔ · undefined-ⰒⰀⰋⰓⰔ · undefined+undefined ⰒⰀⰓⰕⰋⰕⰋⰑⰐ · undefined-ⰒⰀⰎⰋⰐⰄⰓⰑⰏⰅ · ⰓⰑⰑⰕ undefined) ⰜⰑⰐⰔⰅⰓⰂⰅⰄ.

ⰄⰋⰃⰋⰕ	ⰔⰎⰑⰕ	ⰀⰐⰃⰎⰅ	ⰗⰎⰑⰂ undefined°	ⰔⰕⰓⰑⰍⰅⰔ	ⰃⰀⰕⰅⰂⰀⰉ	ⰏⰋⰓⰓⰑⰓ	ⰒⰑⰎⰀⰓ	ⰔⰑⰖⰐⰄ (ⰘⰈ)	ⰎⰋⰃⰘⰕ (ⰑⰜⰕⰀⰂⰅ ⰁⰓⰋⰄⰃⰅ)
undefined	\\	\\°	\\°	\\		undefined+undefined=undefined	undefined+undefined=undefined	undefined	undefined.undefined ⰕⰘⰈ · undefined ⰐⰏ · ⰓⰅⰄ
undefined	undefined	undefined°	undefined°	\\		undefined+undefined=undefined	undefined+undefined=undefined	undefined	undefined.undefined ⰕⰘⰈ · undefined ⰐⰏ · ⰓⰅⰄ
undefined	undefined	undefined°	undefined°	\\		undefined+undefined=undefined	undefined+undefined=undefined	undefined	undefined.undefined ⰕⰘⰈ · undefined ⰐⰏ · ⰓⰅⰄ
undefined	undefined	undefined°	undefined°	\/	✓	undefined+undefined=undefined	undefined+undefined=undefined	undefined	undefined.undefined ⰕⰘⰈ · undefined ⰐⰏ · ⰓⰅⰄ
undefined	undefined	undefined°	undefined°	//		undefined+undefined=undefined	undefined+undefined=undefined	undefined	undefined.undefined ⰕⰘⰈ · undefined ⰐⰏ · ⰂⰋⰑⰎⰅⰕ
undefined	undefined	undefined°	undefined°	//		undefined+undefined=undefined	undefined+undefined=undefined	undefined	undefined.undefined ⰕⰘⰈ · undefined ⰐⰏ · ⰉⰅⰎⰎⰑⰂ
undefined	undefined	undefined°	—	/\	✓	undefined+undefined=undefined	undefined·undefined ⰒⰑⰎⰀⰓⰋⰕⰉ	undefined	undefined.undefined ⰕⰘⰈ · undefined ⰐⰏ · ⰁⰎⰖⰅ
undefined	undefined	undefined°	—	\\		undefined+undefined=undefined	undefined·undefined ⰒⰑⰎⰀⰓⰋⰕⰉ	undefined	undefined.undefined ⰕⰘⰈ · undefined ⰐⰏ · ⰁⰎⰖⰅ
undefined	undefined	undefined°	—	\/	✓	undefined+undefined=undefined	ⰑⰓⰋⰃⰋⰐ	undefined	undefined ⰕⰘⰈ · undefined ⰐⰏ · ⰓⰅⰄ
/\	undefined	undefined°	—	/\	✓	—	ⰂⰑⰋⰄ	—	ⰔⰋⰎⰅⰐⰜⰅ — ⰕⰘⰅ ⰂⰑⰋⰄ ⰜⰀⰓⰓⰋⰅⰔ ⰐⰑ ⰕⰑⰐⰅ

ⰕⰘⰅ ⰔⰅⰍⰖⰅⰐⰜⰅ, ⰔⰜⰋⰅⰐⰕⰋⰗⰋⰜⰀⰎⰎⰉ ⰄⰅⰔⰜⰓⰋⰁⰅⰄ — undefined/undefined: ⰕⰅⰐ ⰄⰋⰃⰋⰕⰔ ⰑⰐ Ⰰ undefined° ⰓⰋⰐⰃ (undefined° ⰒⰅⰓ ⰔⰎⰑⰕ, ⰕⰘⰅ ⰗⰎⰑⰂ ⰑⰐ ⰋⰕⰔ undefined° ⰘⰅⰘⰀⰃⰑⰐ), ⰒⰑⰎⰀⰓⰋⰕⰋⰅⰔ ⰜⰑⰏⰒⰖⰕⰅⰄ ⰗⰓⰑⰏ ⰔⰕⰓⰑⰍⰅⰔ (undefined ⰀⰔⰜⰅⰐⰕⰔ · undefined ⰄⰅⰔⰜⰅⰐⰕⰔ · undefined ⰃⰀⰕⰅⰂⰀⰉⰔ), ⰔⰑⰖⰐⰄ ⰀⰔ ⰕⰘⰅ Ⰴ/undefined ⰎⰀⰄⰄⰅⰓ ⰑⰗ ⰕⰘⰅ undefined ⰘⰈ ⰀⰐⰜⰘⰑⰓ, ⰜⰑⰎⰑⰓ ⰂⰋⰀ ⰕⰘⰅ ⰔⰅⰀⰎⰅⰄ ⰑⰜⰕⰀⰂⰅ ⰁⰓⰋⰄⰃⰅ, ⰀⰐⰄ ⰕⰘⰅ ⰓⰅⰗⰎⰅⰜⰕⰋⰑⰐ/ⰃⰓⰑⰖⰒ/ⰅⰐⰕⰀⰐⰃⰎⰅⰏⰅⰐⰕ ⰗⰑⰎⰄⰔ ⰉⰑⰋⰐⰅⰄ — ⰅⰂⰅⰓⰉ ⰜⰅⰎⰎ ⰜⰑⰏⰒⰖⰕⰅⰄ, ⰐⰑⰕⰘⰋⰐⰃ ⰕⰉⰒⰅⰄ ⰕⰂⰋⰜⰅ.

ⰕⰘⰅ ⰜⰋⰓⰜⰖⰋⰕ'Ⱄ ⰎⰀⰂ ⰋⰔ ⰒⰋⰅⰜⰅⰂⰋⰔⰅ — ⰃⰅⰑⰏⰅⰕⰓⰋⰜ ×undefined ⰑⰐ ⰕⰘⰅ ⰖⰐⰋⰕ ⰔⰅⰃⰏⰅⰐⰕ, ⰀⰓⰋⰕⰘⰏⰅⰕⰋⰜ +undefined ⰑⰐ ⰕⰘⰅ ⰐⰑⰐ-ⰖⰐⰋⰕ ⰔⰅⰃⰏⰅⰐⰕ, ⰜⰑⰋⰐⰜⰋⰄⰋⰐⰃ ⰑⰐⰎⰉ ⰀⰕ Ⰴ = undefined; ⰅⰘⰀⰜⰕⰎⰉ undefined ⰔⰅⰀⰏⰔ (undefined→undefined ⰀⰐⰄ undefined→undefined→undefined) ⰂⰘⰅⰓⰅ ⰐⰅⰋⰕⰘⰅⰓ ⰎⰀⰂ ⰜⰀⰓⰓⰋⰅⰔ, ⰔⰅⰀⰕⰅⰄ ⰀⰕ ⰕⰘⰅ ⰕⰂⰑ ⰋⰐⰂⰑⰎⰖⰕⰋⰑⰐ ⰜⰅⰐⰕⰅⰓⰔ (undefined = ⰗⰋⰘ σ, undefined ≡ undefined = ⰗⰋⰘ ν): ⰔⰅⰀⰏⰔ = −χ = undefined.

ⰁⰑⰖⰐⰄⰀⰓⰉ. ⰅⰘⰀⰜⰕ — ⰅⰂⰅⰓⰉ ⰕⰀⰁⰎⰅ ⰜⰅⰎⰎ ⰄⰅⰓⰋⰂⰅⰔ: ⰀⰐⰃⰎⰅⰔ ⰜⰎⰑⰔⰅ ⰕⰘⰅ ⰜⰋⰓⰜⰎⰅ — ⰕⰅⰐ ⰔⰎⰑⰕⰔ × undefined° = undefined° ⰅⰘⰀⰜⰕⰎⰉ (ⰕⰓⰖⰅ), ⰀⰐⰄ ⰕⰘⰅ ⟨undefined⟩ ⰗⰎⰑⰂ ⰔⰋⰕⰔ ⰑⰐ ⰋⰕⰔ ⰑⰂⰐ ⰘⰅⰘⰀⰃⰑⰐ ⰀⰕ undefined° ⰒⰅⰓ ⰄⰑⰖⰁⰎⰋⰐⰃ (ⰕⰘⰅ ⰂⰑⰓⰕⰅⰘ ⰍⰖⰀⰐⰕⰖⰏ ⰑⰗ ⰀⰐⰃⰎⰅ, ⰔⰋⰘⰕⰉⰄⰅⰃⰓⰅⰅⰔⰄⰅⰜⰑⰄⰅⰔⰒⰋ) · ⰒⰑⰎⰀⰓⰋⰕⰋⰅⰔ ⰁⰀⰎⰀⰐⰜⰅ — ⰔⰋⰘ ⰀⰔⰜⰅⰐⰕⰔ ⰀⰃⰀⰋⰐⰔⰕ ⰗⰑⰖⰓ ⰄⰅⰔⰜⰅⰐⰕⰔ ⰂⰋⰕⰘ ⰅⰘⰀⰜⰕⰎⰉ ⰕⰘⰅ ⰗⰑⰖⰓ ⰜⰑⰏⰒⰖⰕⰅⰄ ⰃⰀⰕⰅⰂⰀⰉⰔ ⰜⰀⰓⰓⰉⰋⰐⰃ ⰕⰘⰅ ⰓⰅⰂⰅⰓⰔⰀⰎⰔ (ⰕⰓⰖⰅ); ⰅⰂⰅⰓⰉ ⰄⰋⰃⰋⰕ'Ⱄ ⰋⰐ/ⰑⰖⰕ ⰔⰕⰓⰑⰍⰅ ⰒⰀⰋⰓ ⰋⰔ ⰜⰑⰏⰒⰖⰕⰅⰄ ⰗⰓⰑⰏ ⰕⰘⰅ ⰕⰑⰖⰓ, ⰐⰅⰂⰅⰓ ⰀⰔⰔⰋⰃⰐⰅⰄ · ⰔⰑⰖⰐⰄ ⰋⰔ ⰕⰘⰅ Ⰴ/undefined ⰎⰀⰄⰄⰅⰓ ⰑⰗ ⰕⰘⰅ ⰀⰐⰜⰘⰑⰓ — Ⱇ_Ⰴ = undefined·Ⰴ/undefined = undefined·Ⰴ ⰘⰈ ⰂⰋⰕⰘ ⰕⰘⰅ ⰀⰐⰜⰘⰑⰓ ⰅⰘⰀⰜⰕ ⰀⰕ Ⰴ = undefined (ⰕⰓⰖⰅ); ⰕⰘⰅ ⰂⰑⰋⰄ undefined ⰜⰀⰓⰓⰋⰅⰔ ⰔⰋⰎⰅⰐⰜⰅ, ⰔⰕⰀⰕⰅⰄ ⰐⰑⰕ ⰒⰀⰋⰐⰕⰅⰄ · ⰜⰑⰎⰑⰓ ⰋⰔ ⰕⰘⰅ ⰔⰅⰀⰎⰅⰄ ⰑⰜⰕⰀⰂⰅ ⰁⰓⰋⰄⰃⰅ — ⰅⰀⰜⰘ ⰕⰑⰐⰅ ⰄⰑⰖⰁⰎⰅⰔ ⰋⰐⰕⰑ ⰕⰘⰅ ⰂⰋⰔⰋⰁⰎⰅ ⰁⰀⰐⰄ ⰂⰋⰀ ⰗⰓⰅⰍⰖⰅⰐⰜⰉⰕⰑⰎⰋⰃⰘⰕ (ⰕⰘⰈ · ⰐⰏ · ⰁⰀⰐⰄ), ⰕⰘⰅ ⰔⰀⰏⰅ ⰄⰅⰓⰋⰂⰀⰕⰋⰑⰐ ⰕⰘⰀⰕ ⰜⰑⰏⰒⰖⰕⰅⰔ ⰕⰘⰅ ⰁⰓⰀⰐⰄ ⰘⰖⰅ Ⰰundefined_ⰘⰖⰅ = undefined; ⰐⰑ ⰘⰖⰅ ⰋⰔ ⰘⰀⰐⰄ-ⰒⰋⰜⰍⰅⰄ · ⰀⰐⰄ ⰀⰎⰎ ⰋⰕ ⰓⰅⰒⰓⰅⰔⰅⰐⰕⰔ ⰓⰋⰄⰅⰔ ⰔⰅⰀⰎⰅⰄ — ⰕⰘⰅ ⰕⰂⰑ ⰜⰑⰏⰒⰖⰕⰅⰄ ⰎⰋⰐⰅⰔ (ⰕⰓⰖⰅ), ⰕⰘⰅ undefined-ⰅⰎⰅⰏⰅⰐⰕ ⰀⰗⰗⰋⰐⰅ ⰔⰉⰏⰏⰅⰕⰓⰉ ⰂⰋⰕⰘ ⰋⰕⰔ ⰖⰐⰋⰕ-ⰔⰘⰋⰗⰕ ⰜⰑⰏⰏⰖⰕⰀⰕⰑⰓ, ⰀⰐⰄ ⰕⰘⰅ ⰑⰐⰅ-ⰑⰓⰁⰋⰕ ⰅⰐⰕⰀⰐⰃⰎⰅⰏⰅⰐⰕ ⰂⰋⰕⰘ ⰋⰕⰔ ⰅⰍⰖⰋⰎⰋⰁⰓⰋⰖⰏⰔ (ⰕⰓⰖⰅ) — ⰕⰘⰅ ⰄⰅⰔⰜⰓⰋⰒⰕⰋⰑⰐ ⰉⰑⰋⰐⰔ ⰗⰑⰎⰄⰔ, ⰋⰕ ⰄⰑⰅⰔ ⰐⰑⰕ ⰓⰅⰔⰕⰀⰕⰅ ⰕⰘⰅⰏ · ⰕⰘⰅ ⰂⰓⰀⰒ ⰎⰅⰀⰂⰅⰔ ⰕⰘⰅ ⰑⰜⰕⰀⰂⰅ — undefined·{undefined,undefined,undefined,undefined} ⰘⰈ ⰄⰑⰖⰁⰎⰅ ⰋⰐⰕⰑ ⰕⰘⰅ ⰔⰀⰏⰅ ⰂⰋⰔⰋⰁⰎⰅ ⰜⰑⰎⰑⰓ (ⰕⰓⰖⰅ ⰄⰑⰖⰁⰎⰋⰐⰃ = ⰑⰜⰕⰀⰂⰅ ⰅⰍⰖⰋⰂⰀⰎⰅⰐⰜⰅ: ⰕⰓⰖⰅ), ⰂⰘⰋⰎⰅ ⰕⰘⰅ ⰄⰋⰃⰋⰕⰀⰎ-ⰓⰑⰑⰕ ⰂⰓⰀⰒ undefined→undefined ⰅⰘⰋⰕⰔ ⰕⰘⰅ ⰒⰋⰕⰜⰘ ⰜⰎⰀⰔⰔ (ⰕⰓⰖⰅ) — ⰏⰑⰄ-undefined ⰄⰑⰖⰁⰎⰋⰐⰃ ⰋⰔ ⰐⰑⰕ ⰔⰑⰖⰐⰄ-ⰑⰜⰕⰀⰂⰅ ⰄⰑⰖⰁⰎⰋⰐⰃ, ⰜⰑⰏⰒⰖⰕⰅⰄ ⰀⰐⰄ ⰔⰕⰀⰕⰅⰄ ⰔⰜⰑⰒⰅ: ⰕⰘⰅ undefined°/undefined° ⰀⰐⰃⰎⰅⰔ ⰀⰓⰅ ⰃⰅⰑⰏⰅⰕⰓⰉ ⰑⰗ ⰕⰘⰅ ⰕⰑⰖⰓ ⰀⰐⰄ ⰕⰘⰅ ⟨undefined⟩ ⰘⰅⰘⰀⰃⰑⰐ; ⰕⰘⰅ Ⰴ/undefined ⰔⰑⰖⰐⰄ ⰎⰀⰄⰄⰅⰓ ⰋⰔ Ⰰ ⰔⰕⰀⰕⰅⰄ ⰜⰑⰐⰂⰅⰐⰕⰋⰑⰐ ⰑⰐ ⰕⰘⰅ ⰔⰅⰀⰎⰅⰄ undefined ⰀⰐⰜⰘⰑⰓ (ⰄⰋⰏⰅⰐⰔⰋⰑⰐⰎⰅⰔⰔ ⰓⰀⰕⰋⰑ × ⰀⰐⰜⰘⰑⰓ), ⰐⰑⰕ Ⰰ ⰒⰘⰉⰔⰋⰜⰔ ⰜⰎⰀⰋⰏ ⰀⰁⰑⰖⰕ ⰄⰋⰃⰋⰕⰔ; ⰕⰘⰅ ⰑⰜⰕⰀⰂⰅ ⰁⰓⰋⰄⰃⰅ ⰋⰔ ⰕⰘⰅ ⰔⰀⰏⰅ ⰔⰅⰀⰎⰅⰄ ⰄⰅⰓⰋⰂⰀⰕⰋⰑⰐ ⰁⰅⰘⰋⰐⰄ Ⰰundefined_ⰘⰖⰅ; ⰂⰅⰎⰎⰐⰅⰔⰔ ⰜⰎⰀⰋⰏⰔ ⰀⰁⰑⰖⰕ undefined ⰘⰈ ⰓⰅⰏⰀⰋⰐ ⰗⰎⰀⰃⰃⰅⰄ (undefined ⰘⰈ ⰘⰅⰀⰎⰔ ∈ ⰄⰅⰏⰀⰓⰜⰀⰕⰋⰑⰐ ⰗⰎⰀⰃⰃⰅⰄ) — ⰕⰘⰅ ⰜⰑⰎⰑⰓⰔ ⰀⰐⰄ ⰕⰑⰐⰅⰔ ⰀⰓⰅ ⰄⰅⰓⰋⰂⰅⰄ ⰒⰓⰅⰔⰅⰐⰕⰀⰕⰋⰑⰐⰔ ⰑⰗ ⰀⰓⰋⰕⰘⰏⰅⰕⰋⰜ, ⰀⰐⰄ ⰕⰘⰅ ⰂⰑⰋⰄ ⰜⰀⰓⰓⰋⰅⰔ ⰔⰋⰎⰅⰐⰜⰅ ⰘⰀⰓⰏⰑⰐⰉ ⰄⰑⰅⰔ ⰐⰑⰕ ⰅⰍⰖⰀⰎ ⰕⰓⰖⰕⰘ.

ⰒⰓⰑⰑⰗ ⰀⰐⰋⰏⰀⰕⰋⰑⰐⰔ — ⰕⰘⰅ ⰂⰋⰔⰖⰀⰎ ⰓⰅⰜⰅⰋⰒⰕⰔ, ⰋⰐ ⰀⰎⰎ ⰄⰋⰓⰅⰜⰕⰋⰑⰐⰔ

ⰅⰂⰅⰓⰉ ⰓⰅⰃⰋⰔⰕⰅⰓⰅⰄ ⰕⰘⰅⰑⰓⰅⰏ ⰜⰀⰓⰓⰋⰅⰔ ⰋⰕⰔ ⰄⰅⰄⰋⰜⰀⰕⰅⰄ ⰀⰐⰋⰏⰀⰕⰋⰑⰐ: undefined ⰔⰒⰅⰜⰔ ⰀⰜⰓⰑⰔⰔ undefined ⰗⰀⰏⰋⰎⰋⰅⰔ, ⰀⰐⰄ ⰕⰘⰅ ⰔⰒⰅⰜ ⰔⰅⰅⰄ ⰋⰔ ⰕⰘⰅ ⰜⰑⰐⰕⰅⰐⰕ ⰀⰄⰄⰓⰅⰔⰔ ⰑⰗ ⰕⰘⰅ ⰕⰘⰅⰑⰓⰅⰏ'Ⱄ ⰑⰂⰐ (identity ⊢ provingFold) — ⰕⰘⰅ ⰔⰀⰏⰅ ⰒⰓⰑⰑⰗ ⰀⰎⰂⰀⰉⰔ ⰀⰐⰋⰏⰀⰕⰅⰔ ⰋⰄⰅⰐⰕⰋⰜⰀⰎⰎⰉ, ⰀⰐⰉ ⰜⰘⰀⰐⰃⰅ ⰕⰑ ⰔⰕⰀⰕⰅⰏⰅⰐⰕ ⰑⰓ ⰒⰓⰑⰂⰋⰐⰃ ⰗⰑⰎⰄ ⰜⰘⰀⰐⰃⰅⰔ ⰕⰘⰅ ⰀⰐⰋⰏⰀⰕⰋⰑⰐ. undefined ⰖⰐⰋⰍⰖⰅ ⰀⰐⰋⰏⰀⰕⰋⰑⰐⰔ ⰗⰑⰓ undefined ⰖⰐⰋⰍⰖⰅ ⰒⰓⰑⰑⰗⰔ (ⰅⰘⰀⰜⰕ ⰁⰋⰉⰅⰜⰕⰋⰑⰐ); ⰀⰐ ⰀⰐⰋⰏⰀⰕⰋⰑⰐ ⰂⰋⰕⰘⰑⰖⰕ Ⰰ ⰒⰓⰑⰂⰅⰐ ⰕⰘⰅⰑⰓⰅⰏ ⰁⰅⰘⰋⰐⰄ ⰋⰕ ⰜⰀⰐⰐⰑⰕ ⰅⰘⰋⰔⰕ (ⰐⰑⰑⰕⰘⰅⰓ=ⰕⰓⰖⰅ).

ⰅⰀⰜⰘ ⰕⰘⰅⰑⰓⰅⰏ'Ⱄ ⰓⰅⰔⰋⰄⰖⰅ ⰜⰑⰑⰓⰄⰋⰐⰀⰕⰅⰔ ⰑⰐ ℤ/undefinedℤ ⰒⰓⰑⰂⰅ ⰋⰕⰔ ⰄⰋⰓⰅⰜⰕⰋⰑⰐⰔ: ⰕⰘⰅ ⰕⰅⰐ'Ⱄ-ⰜⰑⰏⰒⰎⰅⰏⰅⰐⰕ ⰋⰐⰂⰑⰎⰖⰕⰋⰑⰐ σ(Ⰴ) = undefined − Ⰴ (ⰗⰋⰘⰅⰄ ⰒⰑⰋⰐⰕ undefined, ⰏⰀⰒⰔ ⰐⰑⰐ-ⰖⰐⰋⰕⰔ ⰑⰐⰕⰑ ⰖⰐⰋⰕⰔ — ⰕⰘⰅ ⰄⰋⰃⰋⰕ-ⰗⰑⰎⰄⰅⰓ ⰒⰀⰋⰓⰋⰐⰃ Ⰴ/(undefined−Ⰴ)) ⰀⰐⰄ ⰕⰘⰅ ⰀⰄⰄⰋⰕⰋⰂⰅ-ⰋⰐⰂⰅⰓⰔⰅ ⰋⰐⰂⰑⰎⰖⰕⰋⰑⰐ ν(Ⰴ) = −Ⰴ ⰏⰑⰄ undefined (ⰗⰋⰘⰅⰄ ⰒⰑⰋⰐⰕ undefined ≡ undefined, ⰒⰓⰅⰔⰅⰓⰂⰅⰔ ⰕⰘⰅ ⰖⰐⰋⰕ ⰃⰓⰑⰖⰒ (ℤ/undefinedℤ)× = ⟨undefined⟩). ⰕⰘⰅⰋⰓ ⰜⰑⰏⰒⰑⰔⰋⰕⰋⰑⰐ σ∘ν ⰋⰔ ⰕⰘⰅ ⰕⰓⰀⰐⰔⰎⰀⰕⰋⰑⰐ Ⰴ ↦ Ⰴ + undefined ⰀⰜⰕⰋⰐⰃ ⰕⰓⰀⰐⰔⰋⰕⰋⰂⰅⰎⰉ — ⰕⰘⰅ ⰋⰐⰗⰋⰐⰋⰕⰅ ⰜⰉⰜⰎⰋⰜ ⰀⰜⰕⰋⰑⰐ ⰓⰅⰀⰎⰋⰔⰅⰄ ⰑⰐ ⰕⰘⰅ ⰗⰋⰐⰋⰕⰅ ⰍⰖⰑⰕⰋⰅⰐⰕ: ⰄⰖⰀⰎⰋⰕⰉ ⰒⰓⰑⰂⰅⰐ ⰋⰐⰗⰋⰐⰋⰕⰅ ⰂⰋⰕⰘⰋⰐ ⰗⰋⰐⰋⰕⰅ. ⰀⰎⰎ ⰃⰀⰕⰅⰔ ⰓⰅⰜⰑⰏⰒⰖⰕⰅ ⰀⰕ ⰜⰀⰎⰎ ⰕⰋⰏⰅ: ⰋⰐⰂⰑⰎⰖⰕⰋⰑⰐⰔ=ⰕⰓⰖⰅ · ⰖⰐⰋⰕⰔⰒⰓⰅⰔⰅⰓⰂⰅⰄ=ⰕⰓⰖⰅ · ⰐⰑⰐⰖⰐⰋⰕⰔⰑⰐⰕⰑⰖⰐⰋⰕⰔ=ⰕⰓⰖⰅ · ⰕⰓⰀⰐⰔⰎⰀⰕⰋⰑⰐⰕⰓⰀⰐⰔⰋⰕⰋⰂⰅ=ⰕⰓⰖⰅ · ⰀⰎⰎⰄⰋⰓⰅⰜⰕⰋⰑⰐⰔ=ⰕⰓⰖⰅ.

ⰁⰓⰑⰂⰔⰅ ⰕⰘⰅ ⰓⰅⰃⰋⰔⰕⰓⰉ ⰃⰓⰑⰖⰒⰅⰄ ⰁⰉ ⰀⰐⰋⰏⰀⰕⰋⰑⰐ ⰗⰀⰏⰋⰎⰉ, ⰄⰑⰏⰀⰋⰐ, ⰒⰓⰑⰑⰗ ⰜⰎⰀⰔⰔ ⰀⰐⰄ ⰏⰅⰕⰘⰑⰄ: /ⰕⰘⰅⰑⰓⰅⰏⰔ.

ⰄⰅⰂⰅⰎⰑⰒⰏⰅⰐⰕ ⰕⰋⰏⰅⰎⰋⰐⰅ — ⰒⰖⰁⰎⰋⰜ ⰓⰅⰃⰋⰔⰕⰓⰉ ⰄⰀⰕⰀ

ⰗⰋⰓⰔⰕ ⰒⰖⰁⰎⰋⰜⰀⰕⰋⰑⰐ ⰑⰗ ⰕⰘⰅ ⰔⰅⰍⰖⰅⰐⰜⰅ: undefined-undefined-undefined (ⰐⰒⰏ zeropoint-node@1.0.0, ⰓⰅⰃⰋⰔⰕⰓⰉ-ⰄⰀⰕⰅⰄ) — undefined ⰄⰀⰉⰔ ⰁⰅⰗⰑⰓⰅ ⰕⰘⰋⰔ ⰒⰑⰓⰕⰀⰎ'Ⱄ ⰓⰅⰒⰑⰔⰋⰕⰑⰓⰉ ⰅⰘⰋⰔⰕⰅⰄ. ⰅⰂⰅⰓⰉ ⰓⰑⰂ ⰁⰅⰎⰑⰂ ⰋⰔ ⰓⰅ-ⰗⰅⰕⰜⰘⰀⰁⰎⰅ ⰗⰓⰑⰏ ⰃⰋⰕⰘⰖⰁ/ⰐⰒⰏ.

ⰕⰓⰀⰜⰍ	ⰜⰓⰅⰀⰕⰅⰄ	ⰜⰑⰏⰏⰋⰕⰔ	ⰐⰒⰏ ⰂⰅⰓⰔⰋⰑⰐⰔ
ⰜⰅⰜⰜⰅⰜ/ⰈⰅⰓⰑⰒⰑⰋⰐⰕ-ⰐⰑⰄⰅ	undefined-undefined-undefined	undefined	undefined
ⰜⰅⰜⰜⰅⰜ/ⰜⰅⰜⰜⰅⰜ.ⰃⰋⰕⰘⰖⰁ.ⰋⰑ	undefined-undefined-undefined	undefined	ⰖⰐⰏⰅⰀⰔⰖⰓⰅⰄ
ⰅⰓⰒⰀⰘ/ⰅⰓⰒⰀⰘ	undefined-undefined-undefined	undefined	ⰖⰐⰏⰅⰀⰔⰖⰓⰅⰄ

• undefined-undefined-undefined — ⰈⰅⰓⰑⰒⰑⰋⰐⰕ-ⰐⰑⰄⰅ ⰓⰅⰒⰑ ⰜⰓⰅⰀⰕⰅⰄ (ⰀⰒⰋ.ⰃⰋⰕⰘⰖⰁ.ⰜⰑⰏ/ⰓⰅⰒⰑⰔ/ⰜⰅⰜⰜⰅⰜ/ⰈⰅⰓⰑⰒⰑⰋⰐⰕ-ⰐⰑⰄⰅ ⰜⰓⰅⰀⰕⰅⰄ_ⰀⰕ)
• undefined-undefined-undefined — zeropoint-node@1.0.0 ⰒⰖⰁⰎⰋⰔⰘⰅⰄ ⰕⰑ ⰐⰒⰏ — ⰕⰘⰅ ⰔⰅⰍⰖⰅⰐⰜⰅ zeropoint-node@1.0.0\undefined\undefined\undefined\undefined/undefined/undefined/undefined\undefined\undefined/zeropoint-node@1.0.0\undefined ⰗⰋⰓⰔⰕ ⰒⰖⰁⰎⰋⰜ (ⰓⰅⰃⰋⰔⰕⰓⰉ.ⰐⰒⰏⰉⰔ.ⰑⰓⰃ/ⰈⰅⰓⰑⰒⰑⰋⰐⰕ-ⰐⰑⰄⰅ ⰕⰋⰏⰅ)
• undefined-undefined-undefined — zeropoint-node@1.0.1 ⰒⰖⰁⰎⰋⰔⰘⰅⰄ (ⰓⰅⰃⰋⰔⰕⰓⰉ.ⰐⰒⰏⰉⰔ.ⰑⰓⰃ/ⰈⰅⰓⰑⰒⰑⰋⰐⰕ-ⰐⰑⰄⰅ ⰕⰋⰏⰅ)
• undefined-undefined-undefined — ⰜⰅⰜⰜⰅⰜ.ⰃⰋⰕⰘⰖⰁ.ⰋⰑ ⰓⰅⰒⰑ ⰜⰓⰅⰀⰕⰅⰄ — ⰕⰘⰅ ⰒⰑⰓⰕⰀⰎ ⰁⰅⰃⰋⰐⰔ, undefined ⰄⰀⰉⰔ ⰀⰗⰕⰅⰓ ⰕⰘⰅ ⰐⰒⰏ ⰒⰖⰁⰎⰋⰜⰀⰕⰋⰑⰐ (ⰀⰒⰋ.ⰃⰋⰕⰘⰖⰁ.ⰜⰑⰏ/ⰓⰅⰒⰑⰔ/ⰜⰅⰜⰜⰅⰜ/ⰜⰅⰜⰜⰅⰜ.ⰃⰋⰕⰘⰖⰁ.ⰋⰑ ⰜⰓⰅⰀⰕⰅⰄ_ⰀⰕ)
• undefined-undefined-undefined — ⰅⰓⰒⰀⰘ/ⰅⰓⰒⰀⰘ ⰓⰅⰒⰑ ⰜⰓⰅⰀⰕⰅⰄ — ⰕⰘⰅ ⰒⰀⰓⰕⰐⰅⰓ ⰜⰑⰓⰒⰖⰔ ⰕⰘⰀⰕ ⰒⰖⰁⰎⰋⰔⰘⰅⰔ ⰕⰘⰅ ⰔⰀⰏⰅ ⰗⰑⰓⰂⰀⰓⰄ/ⰓⰅⰗⰎⰅⰜⰕⰅⰄ ⰎⰋⰐⰅⰔ (ⰀⰒⰋ.ⰃⰋⰕⰘⰖⰁ.ⰜⰑⰏ/ⰓⰅⰒⰑⰔ/ⰅⰓⰒⰀⰘ/ⰅⰓⰒⰀⰘ ⰜⰓⰅⰀⰕⰅⰄ_ⰀⰕ)
• undefined-undefined-undefined — zeropoint-node@1.0.2 ⰒⰖⰁⰎⰋⰔⰘⰅⰄ (ⰓⰅⰃⰋⰔⰕⰓⰉ.ⰐⰒⰏⰉⰔ.ⰑⰓⰃ/ⰈⰅⰓⰑⰒⰑⰋⰐⰕ-ⰐⰑⰄⰅ ⰕⰋⰏⰅ)

undefined. ⰓⰅⰔⰖⰎⰕⰔ

• undefined/undefined ⰏⰑⰐⰑⰃⰓⰀⰒⰘⰔ — ⰜⰑⰐⰕⰅⰐⰕ ⰒⰀⰃⰅⰔ ⰗⰑⰎⰄ ⰃⰅⰐⰖⰔ-undefined −χ (undefined ⰔⰖⰓⰗⰀⰜⰅ → undefined ⰗⰑⰎⰄⰅⰄ); ⰜⰅⰐⰔⰖⰔ undefined/undefined; ⰓⰑⰔⰅⰕⰕⰀ undefined×undefined/undefined×undefined=undefined ⰀⰓⰅⰀⰔ
• undefined/undefined ⰜⰑⰐⰜⰅⰒⰕ ⰜⰑⰏⰏⰀⰐⰄⰔ — ⰏⰜⰒ ⰕⰑⰑⰎ ⰔⰖⰓⰗⰀⰜⰅ (undefined×undefined = undefined÷undefined)
• undefined/undefined ⰓⰅⰗⰅⰓⰅⰐⰜⰅ ⰋⰐⰄⰅⰘ ⰅⰐⰕⰓⰋⰅⰔ — ⰈⰅⰓⰑ ⰓⰅⰄⰖⰐⰄⰀⰐⰜⰉ
• undefined/undefined ⰎⰑⰜⰀⰎⰅ ⰔⰖⰓⰗⰀⰜⰅⰔ — undefined ⰓⰑⰖⰕⰅⰔ (ⰘⰑⰏⰅ + ⰅⰂⰅⰓⰉ ⰔⰅⰓⰂⰅⰄ ⰔⰜⰋⰅⰐⰜⰅ ⰒⰀⰃⰅ) × undefined ⰎⰑⰜⰀⰎⰅⰔ
• undefined ⰀⰓⰋⰕⰘⰏⰅⰕⰋⰜ ⰒⰓⰑⰑⰗⰔ — ⰘⰀⰓⰏⰑⰐⰋⰜⰜⰑⰖⰐⰕⰔⰒⰓⰑⰂⰅⰐⰁⰉⰏⰀⰕⰘ() ⰀⰕ ⰜⰀⰎⰎ ⰕⰋⰏⰅ (ⰒⰓⰑⰂⰅⰐ: ⰕⰓⰖⰅ)
• undefined ⰅⰗⰗⰋⰜⰋⰅⰐⰜⰉ ⰒⰓⰑⰑⰗⰔ — ⰅⰂⰅⰓⰉⰁⰋⰕⰏⰑⰔⰕⰅⰗⰗⰋⰜⰋⰅⰐⰕⰀⰎⰃⰑⰓⰋⰕⰘⰏⰒⰓⰑⰂⰅⰐⰁⰉⰏⰀⰕⰘ() ⰀⰕ ⰜⰀⰎⰎ ⰕⰋⰏⰅ (ⰒⰓⰑⰂⰅⰐ: ⰕⰓⰖⰅ)

ⰜⰎⰀⰉ ⰏⰋⰎⰎⰅⰐⰐⰋⰖⰏ ⰒⰓⰑⰁⰎⰅⰏⰔ — ⰕⰘⰅ ⰒⰓⰑⰑⰗ ⰑⰗ ⰜⰑⰐⰜⰅⰒⰕ

ⰕⰘⰅ ⰔⰅⰍⰖⰅⰐⰜⰅ ⰋⰔ ⰕⰘⰅ ⰂⰘⰋⰕⰅ ⰒⰀⰒⰅⰓ; ⰕⰘⰅ ⰜⰎⰀⰉ ⰏⰋⰎⰎⰅⰐⰐⰋⰖⰏ ⰒⰓⰑⰁⰎⰅⰏⰔ ⰀⰓⰅ ⰋⰕⰔ ⰒⰓⰑⰑⰗ ⰑⰗ ⰜⰑⰐⰜⰅⰒⰕ. ⰕⰘⰅⰉ ⰀⰓⰅ ⰕⰘⰅ ⰓⰅⰗⰎⰅⰜⰕⰋⰑⰐ ⰕⰘⰓⰑⰖⰃⰘ clayReflection ⰑⰗ ⰕⰘⰅ ⰄⰋⰏⰅⰐⰔⰋⰑⰐⰀⰎ ⰁⰋⰕ — demarcate() ⰔⰑⰎⰂⰅⰄ ⰕⰘⰋⰔ-ⰄⰋⰏⰅⰐⰔⰋⰑⰐ (ⰒⰑⰋⰐⰜⰀⰓé) + undefined ⰑⰒⰅⰐ ⰁⰅⰉⰑⰐⰄ = undefined (clayReflection). ⰅⰀⰜⰘ ⰒⰓⰑⰁⰎⰅⰏ ⰋⰔ ⰏⰅⰀⰔⰖⰓⰅⰄ ⰅⰘⰀⰜⰕⰎⰉ ⰎⰋⰍⰅ ⰀⰐⰉ ⰕⰘⰅⰑⰓⰅⰏ — demarcate() ⰅⰒⰋⰔⰕⰅⰏⰋⰜ ⰔⰕⰀⰕⰖⰔ ⰒⰎⰖⰔ Ⰰ ⰔⰅⰀⰎⰅⰄ ⰜⰑⰏⰒⰖⰕⰀⰕⰋⰑⰐⰀⰎ ⰒⰀⰕⰘ — ⰀⰐⰄ ⰎⰋⰐⰍⰔ ⰕⰑ ⰋⰕⰔ ⰒⰓⰑⰑⰗ ⰒⰀⰃⰅ. ⰂⰘⰀⰕⰅⰂⰅⰓ Ⰰ ⰕⰘⰅⰑⰓⰅⰏ ⰜⰎⰀⰋⰏⰔ ⰋⰔ ⰔⰕⰀⰕⰅⰄ ⰋⰐ ⰕⰘⰅ ⰕⰘⰅⰑⰓⰅⰏ ⰋⰕⰔⰅⰎⰗ.

ⰘⰑⰂ ⰏⰀⰐⰉ

ⰒⰀⰕⰘⰜⰑⰖⰐⰕ = undefined · ⰜⰑⰏⰒⰖⰕⰀⰁⰎⰅⰜⰑⰖⰐⰕ = undefined · ⰜⰑⰐⰕⰅⰔⰕⰅⰄⰜⰑⰖⰐⰕ = undefined · ⰄⰑⰜⰖⰏⰅⰐⰕⰅⰄⰜⰑⰖⰐⰕ = undefined · ⰔⰑⰎⰂⰅⰄⰅⰘⰕⰅⰓⰐⰀⰎⰜⰑⰖⰐⰕ = undefined · ⰐⰑⰂⰅⰎⰘⰅⰓⰅⰜⰑⰖⰐⰕ = ⰖⰐⰜⰘⰅⰜⰍⰅⰄ

ⰕⰘⰅ ⰅⰒⰋⰔⰕⰅⰏⰋⰜ ⰔⰕⰀⰕⰖⰔ ⰋⰔ demarcate(term) ⰗⰓⰑⰏ ⰕⰘⰅ ⰈⰅⰓⰑ-ⰜⰉⰜⰎⰅ ⰓⰅⰃⰋⰔⰕⰓⰉ — ⰕⰘⰅ ⰔⰀⰏⰅ ⰏⰅⰕⰓⰋⰜ ⰅⰂⰅⰓⰉ ⰕⰘⰅⰑⰓⰅⰏ ⰃⰅⰕⰔ — ⰓⰅⰗⰖⰕⰀⰁⰎⰅ ⰁⰉ ⰏⰑⰂⰋⰐⰃ ⰕⰘⰅ ⰕⰅⰓⰏ. ⰅⰀⰜⰘ ⰒⰓⰑⰁⰎⰅⰏ’Ⱄ ⰑⰒⰅⰐ ⰔⰕⰅⰒ ⰋⰔ ⰋⰕⰔ ⰐⰀⰏⰅⰄ ⰃⰀⰒ ⰁⰅⰎⰑⰂ.

ⰔⰕⰀⰕⰅⰏⰅⰐⰕ

ⰜⰎⰀⰉ ⰜⰘⰀⰎⰎⰅⰐⰃⰅⰔ ⰀⰓⰅ ⰜⰑⰏⰒⰖⰕⰀⰁⰎⰅ ⰗⰓⰑⰏ ⰕⰘⰅ ⰔⰅⰍⰖⰅⰐⰜⰅ/ⰕⰓⰋⰐⰋⰕⰉ/ⰓⰑⰔⰅⰕⰕⰀ/ⰅⰀⰓⰕⰘ-ⰒⰑⰎⰅⰔ ⰔⰕⰀⰜⰍ — undefined/undefined ⰔⰅⰀⰎⰅⰄ ⰜⰑⰏⰒⰖⰕⰀⰕⰋⰑⰐⰀⰎ ⰒⰀⰕⰘⰔ ⰓⰅⰜⰑⰏⰒⰖⰕⰅ (ⰏⰋⰎⰎⰅⰐⰐⰋⰖⰏⰒⰓⰑⰁⰎⰅⰏⰔⰜⰘⰀⰎⰎⰅⰐⰃⰅ · ⰄⰋⰓⰅⰜⰕⰋⰑⰐⰀⰎⰕⰓⰋⰐⰋⰕⰉ · ⰅⰀⰓⰕⰘⰓⰅⰀⰎⰋⰔⰅⰄⰁⰉⰜⰑⰏⰒⰖⰕⰋⰐⰃⰒⰑⰎⰅⰔⰀⰔⰒⰉⰓⰀⰏⰋⰄ · ⰔⰜⰋⰅⰐⰜⰅⰔⰋⰐⰕⰅⰓⰀⰜⰕⰋⰐⰕⰓⰋⰐⰋⰕⰋⰅⰔ · ⰄⰑⰏⰀⰋⰐⰒⰓⰑⰑⰗⰜⰀⰕⰀⰎⰑⰃ). ⰜⰎⰀⰉⰔⰑⰎⰂⰅⰄⰁⰉⰕⰘⰋⰔⰗⰑⰎⰄ=undefined — ⰜⰑⰏⰒⰖⰕⰀⰁⰎⰅ ≠ ⰜⰏⰋ ⰒⰓⰋⰈⰅ ⰔⰑⰎⰂⰅⰄ.

ⰅⰀⰜⰘ ⰒⰓⰑⰁⰎⰅⰏ ⰁⰅⰎⰑⰂ ⰔⰘⰑⰂⰔ ⰋⰕⰔ ⰔⰕⰀⰕⰅⰏⰅⰐⰕ (ⰀⰎⰃⰅⰁⰓⰀⰋⰜ) — ⰕⰘⰅ ⰒⰓⰅⰜⰋⰔⰅ ⰏⰀⰕⰘⰅⰏⰀⰕⰋⰜⰀⰎ ⰜⰑⰐⰉⰅⰜⰕⰖⰓⰅ ⰋⰕⰔⰅⰎⰗ (ⰓⰋⰅⰏⰀⰐⰐ: ⰀⰎⰎ ⰐⰑⰐ-ⰕⰓⰋⰂⰋⰀⰎ ζ ⰈⰅⰓⰑⰔ ⰘⰀⰂⰅ ⰓⰅ(Ⱄ)=½ · ⰁⰔⰄ: ⰑⰓⰄ₍ₛ₌₁₎ Ⰾ(Ⰵ,Ⱄ)=ⰓⰀⰐⰍ Ⰵ(ℚ) · ⰐⰀⰂⰋⰅⰓ–ⰔⰕⰑⰍⰅⰔ: ⰕⰘⰅ undefinedⰄ ⰋⰐⰜⰑⰏⰒⰓⰅⰔⰔⰋⰁⰎⰅ ⰒⰄⰅ · …) — ⰔⰅⰒⰀⰓⰀⰕⰅ ⰗⰓⰑⰏ ⰕⰘⰅ ⰜⰀⰐⰑⰐⰋⰜⰀⰎ ⰒⰓⰑⰑⰗ ⰗⰑⰓⰏ (ⰕⰘⰅ ⰔⰅⰀⰎⰅⰄ theoremFormulaCodeDual ⰜⰑⰏⰒⰖⰕⰀⰕⰋⰑⰐⰀⰎ ⰒⰀⰕⰘ ⰕⰘⰅ ⰕⰘⰅⰑⰓⰅⰏ ⰒⰀⰃⰅⰔ ⰀⰐⰄ ⰓⰅⰃⰋⰔⰕⰓⰉ ⰓⰅⰐⰄⰅⰓ, ⰑⰐⰅ ⰓⰅⰒⰓⰅⰔⰅⰐⰕⰀⰕⰋⰑⰐ ⰀⰜⰓⰑⰔⰔ ⰗⰓⰑⰐⰕⰅⰐⰄ ⰀⰐⰄ ⰁⰀⰜⰍⰅⰐⰄ). ⰕⰘⰅ ⰀⰎⰃⰅⰁⰓⰀⰋⰜ ⰔⰕⰀⰕⰅⰏⰅⰐⰕ ⰋⰔ ⰂⰘⰀⰕ ⰕⰘⰅ ⰜⰑⰐⰉⰅⰜⰕⰖⰓⰅ ⰀⰔⰔⰅⰓⰕⰔ; ⰂⰘⰅⰕⰘⰅⰓ ⰕⰘⰋⰔ ⰜⰑⰓⰒⰖⰔ ⰒⰓⰑⰂⰅⰔ ⰋⰕ ⰋⰔ ⰀⰐⰔⰂⰅⰓⰅⰄ ⰁⰉ ⰔⰕⰀⰕⰖⰔ + ⰕⰘⰅ ⰐⰀⰏⰅⰄ ⰃⰀⰒ (ⰋⰕ ⰄⰑⰅⰔ ⰐⰑⰕ — ). ⰗⰖⰎⰎ ⰗⰑⰓⰏⰖⰎⰀⰔ ⰀⰐⰄ ⰒⰓⰑⰂⰋⰐⰃ ⰔⰑⰖⰓⰜⰅ ⰀⰓⰅ ⰑⰐ ⰅⰀⰜⰘ ⰒⰓⰑⰁⰎⰅⰏ’Ⱄ ⰕⰘⰅⰑⰓⰅⰏ ⰒⰀⰃⰅ (/theorems/<slug> — ⰗⰑⰓⰏⰖⰎⰀⰔ + ⰜⰑⰄⰅ) ⰀⰐⰄ ⰋⰐ theorem-sources.json. ⰐⰑⰕⰘⰋⰐⰃ ⰋⰔ ⰘⰋⰄⰄⰅⰐ.

ⰒⰅⰓ-ⰒⰓⰑⰁⰎⰅⰏ

• Ⱂ ⰂⰔ ⰐⰒ (p-vs-np) — ⰄⰅⰏⰀⰓⰜⰀⰕⰋⰑⰐ=ⰜⰑⰐⰕⰅⰔⰕⰅⰄ · ⰔⰕⰀⰕⰖⰔ=ⰏⰑⰄⰅⰎⰅⰄ-ⰒⰀⰓⰕⰋⰀⰎ · ⰏⰅⰕⰘⰑⰄⰔ=undefined · ⰒⰓⰑⰑⰗ ⰘⰖⰁ →
  • ⰔⰕⰀⰕⰅⰏⰅⰐⰕ (ⰀⰎⰃⰅⰁⰓⰀⰋⰜ): Ⱂ = ⰐⰒ ? — ⰋⰔ ⰅⰂⰅⰓⰉ ⰒⰓⰑⰁⰎⰅⰏ ⰂⰘⰑⰔⰅ ⰔⰑⰎⰖⰕⰋⰑⰐ ⰋⰔ ⰂⰅⰓⰋⰗⰋⰀⰁⰎⰅ ⰋⰐ ⰒⰑⰎⰉⰐⰑⰏⰋⰀⰎ ⰕⰋⰏⰅ ⰀⰎⰔⰑ ⰔⰑⰎⰂⰀⰁⰎⰅ ⰋⰐ ⰒⰑⰎⰉⰐⰑⰏⰋⰀⰎ ⰕⰋⰏⰅ, ⰂⰘⰅⰓⰅ Ⱂ = ⋃ₖ ⰕⰋⰏⰅ(Ⱀᵏ) ⰀⰐⰄ ⰐⰒ = ⋃ₖ ⰐⰕⰋⰏⰅ(Ⱀᵏ). ⰜⰑⰐⰉⰅⰜⰕⰖⰓⰅⰄ: Ⱂ ≠ ⰐⰒ.
  • ⰜⰀⰐⰑⰐⰋⰜⰀⰎ ⰒⰓⰑⰑⰗ ⰗⰑⰓⰏ: Theorem. P vs NP. · Proof. Open — the fold computes the problem’s structure, not a solution. · What is decided is decided by exact arithmetic; the conjecture itself stays open.
  • ✓ f₁ NP-verify — ∀cl∈φ ∃lit∈cl: sign(lit)=a(|lit|) ⊢ φ(a)=1 · cost O(|φ|) poly — membership half only
  • ✓ f₂ reuse≠search — scan n=121 → hits 0 · content-address 1 → hit · ratio n/1 — presupposes witness w already in hand
  • ✓ f₃ amortize — lim(m→∞) c₀/(m+1) = 0 · TIME(n^k) is worst-case fresh-instance ⊢ reuse ∉ separation
  • ✓ f₄ involution — foldPair∘foldPair = id on merged root · structural symmetry, not one-way-function cryptanalysis
  • ⰃⰀⰒ ⰀⰎⰃⰅⰁⰓⰀ: P≠NP ⟺ ∃L∈NP ∀k ∀M∈TIME(n^k): L(M)≠L — a ∀ over an infinite machine domain ⊢ proof-by-exhaustion structurally unavailable
  • ⰃⰀⰒ ⰀⰎⰃⰅⰁⰓⰀ: barriers (cited): ∃A,B: P^A=NP^A ∧ P^B≠NP^B (Baker–Gill–Solovay 1975) · natural proofs ⊥ strong PRGs (Razborov–Rudich 1994) · algebrization (Aaronson–Wigderson 2008)
  • ⰃⰀⰒ ⰀⰎⰃⰅⰁⰓⰀ: closure asymmetry: P=NP is ∃ (one poly SAT algorithm seals) · P≠NP is ∀ (super-poly lower bound over every machine)
  • ⰃⰀⰒ ⰀⰎⰃⰅⰁⰓⰀ: search half: witness space 2^p(n) — O(1) lookup presupposes exactly what the search must produce
  • ⰑⰒⰅⰐ ⰔⰕⰅⰒ (ⰜⰑⰏⰒⰖⰕⰅⰄ ⰃⰀⰒ, ⰓⰅⰗⰖⰕⰀⰁⰎⰅ): ⰐⰑ ⰔⰅⰀⰎⰅⰄ Ⱂ≠ⰐⰒ (ⰑⰓ Ⱂ=ⰐⰒ) ⰔⰅⰒⰀⰓⰀⰕⰋⰑⰐ ⰒⰓⰑⰑⰗ — ⰀⰏⰑⰓⰕⰋⰈⰅⰄ ⰓⰅⰖⰔⰅ ≠ ⰜⰑⰏⰒⰎⰅⰘⰋⰕⰉ ⰔⰅⰒⰀⰓⰀⰕⰋⰑⰐ
  • ⰁⰑⰖⰐⰄⰀⰓⰉ: ⰏⰑⰄⰅⰎⰅⰄ ⰜⰘⰀⰎⰎⰅⰐⰃⰅ / ⰒⰀⰓⰕⰋⰀⰎ ⰜⰑⰏⰒⰖⰕⰀⰕⰋⰑⰐⰀⰎ ⰀⰕⰕⰀⰜⰍ: ⰔⰀⰕ ⰂⰅⰓⰋⰗⰋⰅⰔ ⰋⰐ ⰒⰑⰎⰉ (ⰐⰒ ⰏⰅⰏⰁⰅⰓⰔⰘⰋⰒ); ⰜⰑⰐⰕⰅⰐⰕ-ⰀⰄⰄⰓⰅⰔⰔ Ⱁ(undefined) ⰂⰔ ⰁⰓⰖⰕⰅ ⰔⰜⰀⰐ; ⰅⰗⰗⰋⰜⰋⰅⰐⰜⰉⰔⰜⰀⰎⰅⰔⰕⰑⰋⰐⰗⰋⰐⰋⰕⰉⰀⰕⰐⰑⰜⰑⰔⰕⰑⰐⰓⰅⰖⰔⰅ — ⰀⰏⰑⰓⰕⰋⰈⰅⰄ ⰓⰅⰖⰔⰅ (ⰏⰅⰏⰑ ⰘⰋⰕ → ⰏⰀⰓⰃⰋⰐⰀⰎ ⰜⰑⰔⰕ undefined; ⰀⰐⰔⰂⰅⰓⰔ÷ⰕⰑⰍⰅⰐⰔ ⰖⰐⰁⰑⰖⰐⰄⰅⰄ ⰀⰕ ⰕⰑⰍⰅⰐⰔ=undefined) ⰂⰘⰋⰎⰅ ⰍⰖⰀⰐⰕⰖⰏⰀⰄⰂⰀⰐⰕⰀⰃⰅⰁⰅⰐⰜⰘⰏⰀⰓⰍ ⰔⰕⰀⰉⰔ !ⰔⰅⰒⰀⰓⰀⰕⰅⰄ. ⰐⰑⰕ Ⰰ Ⱂ≠ⰐⰒ (ⰑⰓ Ⱂ=ⰐⰒ) ⰒⰓⰑⰑⰗ. ⰐⰑⰕ ⰒⰘⰉⰔⰋⰜⰀⰎ ⰍⰏ ⰔⰒⰅⰅⰄⰖⰒ / ⰋⰐⰗⰋⰐⰋⰕⰅ ⰗⰎⰑⰒⰔ. ⰅⰐⰜⰓⰉⰒⰕ ⰓⰑⰖⰐⰄ-ⰕⰓⰋⰒ ⰋⰔ ⰔⰕⰓⰖⰜⰕⰖⰓⰀⰎ ⰗⰑⰎⰄⰒⰀⰋⰓ, ⰐⰑⰕ ⰜⰓⰉⰒⰕⰀⰐⰀⰎⰉⰔⰋⰔ ⰑⰗ ⰑⰐⰅ-ⰂⰀⰉ ⰗⰖⰐⰜⰕⰋⰑⰐⰔ.
• ⰘⰑⰄⰃⰅ ⰜⰑⰐⰉⰅⰜⰕⰖⰓⰅ (hodge) — ⰄⰅⰏⰀⰓⰜⰀⰕⰋⰑⰐ=ⰜⰑⰐⰕⰅⰔⰕⰅⰄ · ⰔⰕⰀⰕⰖⰔ=ⰏⰑⰄⰅⰎⰅⰄ-ⰒⰀⰓⰕⰋⰀⰎ · ⰏⰅⰕⰘⰑⰄⰔ=undefined · ⰒⰓⰑⰑⰗ ⰘⰖⰁ →
  • ⰔⰕⰀⰕⰅⰏⰅⰐⰕ (ⰀⰎⰃⰅⰁⰓⰀⰋⰜ): ⰑⰐ Ⰰ ⰒⰓⰑⰉⰅⰜⰕⰋⰂⰅ ⰐⰑⰐ-ⰔⰋⰐⰃⰖⰎⰀⰓ ⰜⰑⰏⰒⰎⰅⰘ ⰂⰀⰓⰋⰅⰕⰉ Ⱈ, ⰅⰂⰅⰓⰉ ⰘⰑⰄⰃⰅ ⰜⰎⰀⰔⰔ ⰋⰔ ⰀⰎⰃⰅⰁⰓⰀⰋⰜ: ⰘⰄⰃᵏ(Ⱈ) = Ⱈ^&#undefined;undefinedⰍ&#undefined;(Ⱈ,ℚ) ∩ Ⱈ^&#undefined;Ⰽ,Ⰽ&#undefined;(Ⱈ) ⰋⰔ ⰔⰒⰀⰐⰐⰅⰄ ⰑⰂⰅⰓ ℚ ⰁⰉ ⰕⰘⰅ ⰜⰎⰀⰔⰔⰅⰔ ⰑⰗ ⰀⰎⰃⰅⰁⰓⰀⰋⰜ ⰜⰉⰜⰎⰅⰔ ⰑⰗ ⰜⰑⰄⰋⰏⰅⰐⰔⰋⰑⰐ Ⰽ.
  • ⰜⰀⰐⰑⰐⰋⰜⰀⰎ ⰒⰓⰑⰑⰗ ⰗⰑⰓⰏ: Theorem. Hodge Conjecture. · Proof. Open — the fold computes the problem’s structure, not a solution. · What is decided is decided by exact arithmetic; the conjecture itself stays open.
  • ✓ f₁ Betti rank — H₁(Σ₂)=ℤ⁴ · DIMENSION_GATES/FOLDED_CENSUS = 432/108 = 4 ∈ ℤ — the genus-2 model's first Betti number, a NUMBER not a class-algebraicity
  • ✓ f₂ mirror MODEL — compactDims = D−4 sealed; mirror as foldPair involution on the merged root (a MODEL, never CY Hodge numbers h^{p,q} on a projective variety)
  • ⰃⰀⰒ ⰀⰎⰃⰅⰁⰓⰀ: Hodge ⟺ ∀X projective smooth ∀k: Hdgᵏ(X) ⊆ span_ℚ{[Z] : Z algebraic cycle, codim k} — a ∀ over all projective varieties and all k
  • ⰃⰀⰒ ⰀⰎⰃⰅⰁⰓⰀ: known (cited): k=1 is the Lefschetz (1,1)-theorem (1924) · true for some abelian varieties · OPEN in general — no reduction of the general case to a finite check
  • ⰃⰀⰒ ⰀⰎⰃⰅⰁⰓⰀ: the fold computes a Betti NUMBER (rank 4) and a MODELED mirror involution — not the class-by-class algebraicity the conjecture asserts
  • ⰑⰒⰅⰐ ⰔⰕⰅⰒ (ⰜⰑⰏⰒⰖⰕⰅⰄ ⰃⰀⰒ, ⰓⰅⰗⰖⰕⰀⰁⰎⰅ): ⰐⰑ ⰔⰅⰀⰎⰅⰄ ⰘⰑⰄⰃⰅ ⰜⰎⰀⰔⰔⰅⰔ/ⰀⰎⰃⰅⰁⰓⰀⰋⰜ ⰜⰉⰜⰎⰅⰔ ⰑⰐ Ⰰ ⰒⰓⰑⰉⰅⰜⰕⰋⰂⰅ ⰂⰀⰓⰋⰅⰕⰉ; ⰐⰑ ⰔⰅⰀⰎⰅⰄ ⰜⰀⰎⰀⰁⰋ–ⰉⰀⰖ ⰘⰑⰄⰃⰅ ⰐⰖⰏⰁⰅⰓⰔ Ⱈ^&#undefined;undefined,undefined&#undefined;, Ⱈ^&#undefined;undefined,undefined&#undefined;
  • ⰁⰑⰖⰐⰄⰀⰓⰉ: ⰏⰑⰄⰅⰎⰅⰄ ⰜⰘⰀⰎⰎⰅⰐⰃⰅ / ⰔⰕⰓⰖⰜⰕⰖⰓⰀⰎ ⰀⰐⰀⰎⰑⰃⰉ: Ⱈ₁(Σ₂)=ℤ⁴ ⰓⰅⰜⰑⰏⰒⰖⰕⰅⰔ ⰀⰔ undefined/undefined=undefined; ⰔⰕⰓⰋⰐⰃ ⰍⰖⰀⰐⰕⰖⰏⰋⰈⰅ ⰀⰄⰄⰔ ⰜⰉ ⰜⰑⰏⰒⰀⰜⰕ-ⰄⰋⰏⰔ ⰏⰑⰄⰅⰎ (Ⰴ−undefined) ⰀⰐⰄ ⰏⰋⰓⰓⰑⰓ ⰗⰑⰎⰄⰒⰀⰋⰓ. ⰐⰑⰕ Ⰰ ⰒⰓⰑⰑⰗ ⰕⰘⰀⰕ ⰘⰑⰄⰃⰅ ⰜⰎⰀⰔⰔⰅⰔ ⰅⰍⰖⰀⰎ ⰀⰎⰃⰅⰁⰓⰀⰋⰜ ⰜⰉⰜⰎⰅⰔ ⰑⰐ ⰒⰓⰑⰉⰅⰜⰕⰋⰂⰅ ⰂⰀⰓⰋⰅⰕⰋⰅⰔ. ⰐⰑⰕ ⰔⰅⰀⰎⰅⰄ Ⱈ^&#undefined;Ⱂ,Ⰽ&#undefined; ⰑⰐ Ⰰ ⰒⰓⰑⰉⰅⰜⰕⰋⰂⰅ ⰜⰉ₃.
• ⰒⰑⰋⰐⰜⰀⰓé ⰜⰑⰐⰉⰅⰜⰕⰖⰓⰅ (poincare) — ⰄⰅⰏⰀⰓⰜⰀⰕⰋⰑⰐ=ⰄⰑⰜⰖⰏⰅⰐⰕⰅⰄ · ⰔⰕⰀⰕⰖⰔ=ⰔⰑⰎⰂⰅⰄ-ⰅⰘⰕⰅⰓⰐⰀⰎ · ⰏⰅⰕⰘⰑⰄⰔ=undefined · ⰒⰓⰑⰑⰗ ⰘⰖⰁ →
  • ⰔⰕⰀⰕⰅⰏⰅⰐⰕ (ⰀⰎⰃⰅⰁⰓⰀⰋⰜ): ⰅⰂⰅⰓⰉ ⰔⰋⰏⰒⰎⰉ-ⰜⰑⰐⰐⰅⰜⰕⰅⰄ ⰜⰎⰑⰔⰅⰄ undefined-ⰏⰀⰐⰋⰗⰑⰎⰄ ⰋⰔ ⰘⰑⰏⰅⰑⰏⰑⰓⰒⰘⰋⰜ ⰕⰑ ⰕⰘⰅ undefined-ⰔⰒⰘⰅⰓⰅ: π₁(Ⰿ) = undefined ⰂⰋⰕⰘ Ⰿ Ⰰ ⰜⰎⰑⰔⰅⰄ undefined-ⰏⰀⰐⰋⰗⰑⰎⰄ ⟹ Ⰿ ≅ Ⱄ³. (ⰒⰓⰑⰂⰅⰄ: ⰒⰅⰓⰅⰎⰏⰀⰐ undefined, ⰓⰋⰜⰜⰋ ⰗⰎⰑⰂ ⰂⰋⰕⰘ ⰔⰖⰓⰃⰅⰓⰉ.)
  • ⰜⰀⰐⰑⰐⰋⰜⰀⰎ ⰒⰓⰑⰑⰗ ⰗⰑⰓⰏ: Theorem. Poincaré Conjecture. · Proof. Open — the fold computes the problem’s structure, not a solution. · What is decided is decided by exact arithmetic; the conjecture itself stays open.
  • ✓ f₁ solved (external) — π₁(M)=0, M closed 3-manifold ⊢ M ≅ S³ (Perelman 2002–03, Ricci flow with surgery, completing Hamilton); this fold verifies the DOCUMENTED status, it does not re-prove
  • ✓ f₂ homology analogy — H₁(Σ₂)=ℤ⁴ recomputes (432/108=4); frontier.solved=1 — the single solved core among the seven
  • ⰃⰀⰒ ⰀⰎⰃⰅⰁⰓⰀ: No open gap: proved externally (Perelman 2002–03) — Ricci flow with surgery drives every simply-connected closed 3-manifold to S³; this corpus records the status, it does not re-solve it
  • ⰄⰑⰜⰖⰏⰅⰐⰕⰅⰄ — ⰔⰑⰎⰂⰅⰄ ⰅⰘⰕⰅⰓⰐⰀⰎⰎⰉ (ⰒⰅⰓⰅⰎⰏⰀⰐ undefined)
  • ⰁⰑⰖⰐⰄⰀⰓⰉ: ⰔⰑⰎⰂⰅⰄ ⰅⰘⰕⰅⰓⰐⰀⰎ (ⰒⰅⰓⰅⰎⰏⰀⰐ undefined, ⰓⰋⰜⰜⰋ ⰗⰎⰑⰂ ⰂⰋⰕⰘ ⰔⰖⰓⰃⰅⰓⰉ) — ⰕⰘⰋⰔ ⰜⰑⰓⰒⰖⰔ ⰄⰑⰅⰔ ⰐⰑⰕ ⰓⰅ-ⰔⰑⰎⰂⰅ ⰋⰕ. ⰜⰘⰀⰎⰎⰅⰐⰃⰅ ⰑⰐⰎⰉ ⰂⰅⰓⰋⰗⰋⰅⰔ ⰕⰘⰅ ⰄⰑⰜⰖⰏⰅⰐⰕⰅⰄ ⰔⰑⰎⰂⰅⰄ ⰔⰕⰀⰕⰖⰔ ⰒⰎⰖⰔ ⰕⰘⰅ ⰃⰅⰐⰖⰔ-undefined ⰘⰑⰏⰑⰎⰑⰃⰉ ⰀⰐⰀⰎⰑⰃⰉ (Ⱈ₁=ℤ⁴). ⰐⰑⰕ Ⰰ ⰐⰅⰂ ⰒⰓⰑⰑⰗ.
• ⰓⰋⰅⰏⰀⰐⰐ ⰘⰉⰒⰑⰕⰘⰅⰔⰋⰔ (riemann) — ⰄⰅⰏⰀⰓⰜⰀⰕⰋⰑⰐ=ⰜⰑⰐⰕⰅⰔⰕⰅⰄ · ⰔⰕⰀⰕⰖⰔ=ⰏⰑⰄⰅⰎⰅⰄ-ⰒⰀⰓⰕⰋⰀⰎ · ⰏⰅⰕⰘⰑⰄⰔ=undefined · ⰒⰓⰑⰑⰗ ⰘⰖⰁ →
  • ⰔⰕⰀⰕⰅⰏⰅⰐⰕ (ⰀⰎⰃⰅⰁⰓⰀⰋⰜ): ⰅⰂⰅⰓⰉ ⰐⰑⰐ-ⰕⰓⰋⰂⰋⰀⰎ ⰈⰅⰓⰑ ⰑⰗ ⰕⰘⰅ ⰓⰋⰅⰏⰀⰐⰐ ⰈⰅⰕⰀ ⰗⰖⰐⰜⰕⰋⰑⰐ ⰘⰀⰔ ⰓⰅⰀⰎ ⰒⰀⰓⰕ ½: ζ(Ⱄ) = undefined ⰂⰋⰕⰘ undefined < ⰓⰅ(Ⱄ) < undefined ⟹ ⰓⰅ(Ⱄ) = ½, ⰂⰘⰅⰓⰅ ζ(Ⱄ) = Σₙ₌₁^∞ Ⱀ^(−Ⱄ) ⰜⰑⰐⰕⰋⰐⰖⰅⰄ ⰀⰐⰀⰎⰉⰕⰋⰜⰀⰎⰎⰉ.
  • ⰜⰀⰐⰑⰐⰋⰜⰀⰎ ⰒⰓⰑⰑⰗ ⰗⰑⰓⰏ: Theorem. Riemann Hypothesis. · Proof. Open — the fold computes the problem’s structure, not a solution. · What is decided is decided by exact arithmetic; the conjecture itself stays open.
  • ✓ f₁ Basel — Σ_{n≥1} 1/n² = ζ(2) = π²/6 (a VALUE of ζ, not the location of its zeros)
  • ✓ f₂ ζ(−1) exact — bosonic normal ordering forces ζ(−1) = −1/12, a DIFFERENT point on the ζ line
  • ✓ f₃ inverse ≠ reverse — (ℤ/9)* pairs a·a⁻¹ ≡ 1 (mod 9) and the f→{p,q} inverse fold computes — a discrete-harmonic probe
  • ✓ f₄ vortex digital root — ∀d∈VORTEX_SEQUENCE: digitalRoot(d)=d ∨ d=9
  • ✓ f₅ σ↔functional-equation shadow — ζ(s)·Γ(s/2)·π^{−s/2} = ζ(1−s)·Γ((1−s)/2)·π^{−(1−s)/2} holds as involution s↔(1−s); (ℤ/9)* replicates this via a·a⁻¹≡1 (mod 9) with fixed point d=5
  • ⰃⰀⰒ ⰀⰎⰃⰅⰁⰓⰀ: RH ⟺ ∀s: (ζ(s)=0 ∧ 0<Re(s)<1) ⊢ Re(s)=½ — a ∀ over the infinitely many nontrivial zeros in the critical strip
  • ⰃⰀⰒ ⰀⰎⰃⰅⰁⰓⰀ: known (cited): >40% of zeros on the line (Conrey 1989) · the first ~10^13 zeros verified · a zero-free region near Re(s)=1 (de la Vallée Poussin) — none reduce the ∀ to a finite check
  • ⰃⰀⰒ ⰀⰎⰃⰅⰁⰓⰀ: the fold seals VALUES of ζ (ζ(2)=π²/6, ζ(−1)=−1/12) and discrete inverse harmonics — never the real part of the zeros
  • ⰑⰒⰅⰐ ⰔⰕⰅⰒ (ⰜⰑⰏⰒⰖⰕⰅⰄ ⰃⰀⰒ, ⰓⰅⰗⰖⰕⰀⰁⰎⰅ): ⰐⰑ ⰔⰅⰀⰎⰅⰄ ⰒⰓⰑⰑⰗ ⰀⰎⰎ ⰐⰑⰐⰕⰓⰋⰂⰋⰀⰎ ζ ⰈⰅⰓⰑⰔ ⰎⰋⰅ ⰑⰐ ⰓⰅ(Ⱄ)=½ — ⰁⰀⰔⰅⰎ ⰀⰐⰄ ζ(−undefined) ⰀⰓⰅ ⰒⰀⰓⰕⰋⰀⰎⰔ ⰑⰐⰎⰉ
  • ⰁⰑⰖⰐⰄⰀⰓⰉ: ⰏⰑⰄⰅⰎⰅⰄ ⰜⰘⰀⰎⰎⰅⰐⰃⰅ / ⰈⰅⰕⰀ-ⰔⰕⰉⰎⰅ ⰕⰑⰉ ⰒⰓⰑⰁⰅ: ⰁⰀⰔⰅⰎ ⰋⰔ Ⰰ ⰗⰀⰜⰕ ⰀⰁⰑⰖⰕ ζ(undefined); ⰔⰕⰓⰋⰐⰃ ⰀⰎⰃⰅⰁⰓⰀ ⰔⰅⰀⰎⰔ ζ(−undefined)=−undefined/undefined (ⰁⰑⰔⰑⰐⰋⰜ ⰐⰑⰓⰏⰀⰎ ⰑⰓⰄⰅⰓⰋⰐⰃ) — Ⰰ ⰄⰋⰗⰗⰅⰓⰅⰐⰕ ⰒⰑⰋⰐⰕ ⰑⰐ ζ. ⰄⰋⰃⰋⰕ/ⰂⰑⰓⰕⰅⰘ ⰋⰐⰂⰅⰓⰔⰅ ⰗⰑⰎⰄⰔ ⰒⰓⰑⰁⰅ ⰄⰋⰔⰜⰓⰅⰕⰅ ⰘⰀⰓⰏⰑⰐⰋⰜⰔ. ⰐⰑⰕ Ⰰ ⰒⰓⰑⰑⰗ ⰕⰘⰀⰕ ⰀⰎⰎ ⰐⰑⰐⰕⰓⰋⰂⰋⰀⰎ ⰈⰅⰓⰑⰔ ⰎⰋⰅ ⰑⰐ ⰓⰅ(Ⱄ)=½.
• ⰉⰀⰐⰃ–ⰏⰋⰎⰎⰔ ⰅⰘⰋⰔⰕⰅⰐⰜⰅ ⰀⰐⰄ ⰏⰀⰔⰔ ⰃⰀⰒ (yang-mills) — ⰄⰅⰏⰀⰓⰜⰀⰕⰋⰑⰐ=ⰜⰑⰐⰕⰅⰔⰕⰅⰄ · ⰔⰕⰀⰕⰖⰔ=ⰏⰑⰄⰅⰎⰅⰄ-ⰒⰀⰓⰕⰋⰀⰎ · ⰏⰅⰕⰘⰑⰄⰔ=undefined · ⰒⰓⰑⰑⰗ ⰘⰖⰁ →
  • ⰔⰕⰀⰕⰅⰏⰅⰐⰕ (ⰀⰎⰃⰅⰁⰓⰀⰋⰜ): ⰗⰑⰓ ⰅⰂⰅⰓⰉ ⰜⰑⰏⰒⰀⰜⰕ ⰔⰋⰏⰒⰎⰅ ⰃⰀⰖⰃⰅ ⰃⰓⰑⰖⰒ Ⰳ, Ⰰ ⰐⰑⰐ-ⰕⰓⰋⰂⰋⰀⰎ ⰍⰖⰀⰐⰕⰖⰏ ⰉⰀⰐⰃ–ⰏⰋⰎⰎⰔ ⰕⰘⰅⰑⰓⰉ ⰅⰘⰋⰔⰕⰔ ⰑⰐ ℝ⁴ ⰀⰐⰄ ⰘⰀⰔ Ⰰ ⰏⰀⰔⰔ ⰃⰀⰒ Δ > undefined: ⰕⰘⰅ ⰘⰀⰏⰋⰎⰕⰑⰐⰋⰀⰐ ⰔⰒⰅⰜⰕⰓⰖⰏ ⰔⰀⰕⰋⰔⰗⰋⰅⰔ ⰔⰒⰅⰜ(Ⱈ) ⊆ &#undefined;undefined&#undefined; ∪ [Δ, ∞) ⰂⰋⰕⰘ Δ > undefined.
  • ⰜⰀⰐⰑⰐⰋⰜⰀⰎ ⰒⰓⰑⰑⰗ ⰗⰑⰓⰏ: Theorem. Yang–Mills Existence and Mass Gap. · Proof. Open — the fold computes the problem’s structure, not a solution. · What is decided is decided by exact arithmetic; the conjecture itself stays open.
  • ✓ f₁ su(2) closes — [σᵢ,σⱼ]=2iε_{ijk}σₖ and {σᵢ,σⱼ}=2δ_{ij}I close in M₂(ℂ): the gauge Lie algebra, finite-dimensional
  • ✓ f₂ field MODEL — doubleTorusSurface(θ,φ,2,±1) finite with L≠R lobes distinct — a finite genus-2 geometric model, NOT a 4D quantum field theory
  • ✓ f₃ duality MODEL — a T-dual foldPair read off the string algebra (a MODELED structural probe, not a mass-gap operator on a Hilbert space)
  • ⰃⰀⰒ ⰀⰎⰃⰅⰁⰓⰀ: YM ⟺ ∃ a rigorous 4D quantum YM theory for compact simple G with spec(H) ⊆ {0}∪[Δ,∞), Δ>0 — an ∃ over field theories satisfying the Wightman/Osterwalder–Schrader axioms
  • ⰃⰀⰒ ⰀⰎⰃⰅⰁⰓⰀ: known (cited): constructive QFT in d=2,3 (Glimm–Jaffe) · lattice YM shows a gap numerically · NO rigorous continuum 4D construction — the axioms are unmet
  • ⰃⰀⰒ ⰀⰎⰃⰅⰁⰓⰀ: su(2) + torus + string dualities are finite/MODELED; the gap needs a continuum limit and a spectral lower bound, neither sealed here
  • ⰑⰒⰅⰐ ⰔⰕⰅⰒ (ⰜⰑⰏⰒⰖⰕⰅⰄ ⰃⰀⰒ, ⰓⰅⰗⰖⰕⰀⰁⰎⰅ): ⰐⰑ ⰔⰅⰀⰎⰅⰄ undefinedⰄ ⰉⰀⰐⰃ–ⰏⰋⰎⰎⰔ ⰏⰀⰔⰔ-ⰃⰀⰒ ⰜⰑⰐⰔⰕⰓⰖⰜⰕⰋⰑⰐ; ⰐⰑ ⰔⰅⰀⰎⰅⰄ ⰀⰄⰔ/ⰜⰗⰕ ⰜⰑⰓⰓⰅⰎⰀⰕⰑⰓ ⰄⰋⰜⰕⰋⰑⰐⰀⰓⰉ
  • ⰁⰑⰖⰐⰄⰀⰓⰉ: ⰏⰑⰄⰅⰎⰅⰄ ⰜⰘⰀⰎⰎⰅⰐⰃⰅ / ⰗⰋⰅⰎⰄ-ⰀⰎⰃⰅⰁⰓⰀ ⰀⰐⰀⰎⰑⰃⰉ: ⰔⰖ(undefined)/ⰒⰀⰖⰎⰋ ⰜⰎⰑⰔⰅⰔ; ⰃⰅⰐⰖⰔ-undefined ⰄⰑⰖⰁⰎⰅ-ⰕⰑⰓⰖⰔ ⰋⰔ Ⰰ ⰗⰋⰐⰋⰕⰅ ⰃⰅⰑⰏⰅⰕⰓⰋⰜ ⰏⰑⰄⰅⰎ; ⰔⰕⰓⰋⰐⰃ ⰂⰋⰓⰀⰔⰑⰓⰑ + Ⱅ/Ⱄ-ⰄⰖⰀⰎⰋⰕⰉ ⰀⰓⰅ ⰏⰑⰄⰅⰎⰅⰄ ⰔⰕⰓⰖⰜⰕⰖⰓⰀⰎ ⰒⰓⰑⰁⰅⰔ. ⰐⰑⰕ Ⰰ ⰓⰋⰃⰑⰓⰑⰖⰔ undefinedⰄ ⰍⰖⰀⰐⰕⰖⰏ ⰉⰀⰐⰃ–ⰏⰋⰎⰎⰔ ⰜⰑⰐⰔⰕⰓⰖⰜⰕⰋⰑⰐ ⰀⰐⰄ ⰐⰑⰕ Ⰰ ⰏⰀⰔⰔ-ⰃⰀⰒ ⰒⰓⰑⰑⰗ. ⰐⰑⰕ ⰀⰄⰔ/ⰜⰗⰕ. ⰎⰀⰁⰅⰎ: ⰏⰑⰄⰅⰎ.
• ⰐⰀⰂⰋⰅⰓ–ⰔⰕⰑⰍⰅⰔ ⰅⰘⰋⰔⰕⰅⰐⰜⰅ ⰀⰐⰄ ⰔⰏⰑⰑⰕⰘⰐⰅⰔⰔ (navier-stokes) — ⰄⰅⰏⰀⰓⰜⰀⰕⰋⰑⰐ=ⰜⰑⰐⰕⰅⰔⰕⰅⰄ · ⰔⰕⰀⰕⰖⰔ=ⰏⰑⰄⰅⰎⰅⰄ-ⰒⰀⰓⰕⰋⰀⰎ · ⰏⰅⰕⰘⰑⰄⰔ=undefined · ⰒⰓⰑⰑⰗ ⰘⰖⰁ →
  • ⰔⰕⰀⰕⰅⰏⰅⰐⰕ (ⰀⰎⰃⰅⰁⰓⰀⰋⰜ): ⰗⰑⰓ undefinedⰄ ⰋⰐⰜⰑⰏⰒⰓⰅⰔⰔⰋⰁⰎⰅ ⰐⰀⰂⰋⰅⰓ–ⰔⰕⰑⰍⰅⰔ ∂ₜⰖ + (Ⱆ·∇)Ⱆ = −∇Ⱂ + νΔⰖ ⰂⰋⰕⰘ ∇·Ⱆ = undefined ⰀⰐⰄ ⰔⰏⰑⰑⰕⰘ ⰄⰋⰂⰅⰓⰃⰅⰐⰜⰅ-ⰗⰓⰅⰅ ⰗⰋⰐⰋⰕⰅ-ⰅⰐⰅⰓⰃⰉ ⰋⰐⰋⰕⰋⰀⰎ ⰄⰀⰕⰀ, Ⰰ ⰔⰏⰑⰑⰕⰘ ⰔⰑⰎⰖⰕⰋⰑⰐ ⰅⰘⰋⰔⰕⰔ ⰗⰑⰓ ⰀⰎⰎ Ⱅ ≥ undefined (ⰃⰎⰑⰁⰀⰎ ⰓⰅⰃⰖⰎⰀⰓⰋⰕⰉ) — ⰑⰓ Ⰰ ⰗⰋⰐⰋⰕⰅ-ⰕⰋⰏⰅ ⰁⰎⰑⰂ-ⰖⰒ ⰅⰘⰋⰔⰕⰔ.
  • ⰜⰀⰐⰑⰐⰋⰜⰀⰎ ⰒⰓⰑⰑⰗ ⰗⰑⰓⰏ: Theorem. Navier–Stokes Existence and Smoothness. · Proof. Open — the fold computes the problem’s structure, not a solution. · What is decided is decided by exact arithmetic; the conjecture itself stays open.
  • ✓ f₁ flow MODEL — doubleTorusSurface counter-oriented lobes finite and L≠R distinct: a finite genus-2 sample of a flow geometry, NOT the PDE itself
  • ✓ f₂ frontier honesty — the verified-partials fold computes, holding this row at modeled-partial (no regularity or blow-up claim)
  • ⰃⰀⰒ ⰀⰎⰃⰅⰁⰓⰀ: NS ⟺ ∀ smooth divergence-free finite-energy u₀: (∃ smooth u(t) ∀t≥0 solving the system) ∨ (∃ finite-time blow-up) — a ∀ over all such initial data
  • ⰃⰀⰒ ⰀⰎⰃⰅⰁⰓⰀ: known (cited): global weak solutions (Leray 1934) · local strong solutions · global smoothness for small data · 2D global regularity · partial regularity (Caffarelli–Kohn–Nirenberg 1982) — 3D large-data global regularity OPEN
  • ⰃⰀⰒ ⰀⰎⰃⰅⰁⰓⰀ: finite surface samples on the genus-2 model touch neither global existence nor blow-up control of the 3D equations
  • ⰑⰒⰅⰐ ⰔⰕⰅⰒ (ⰜⰑⰏⰒⰖⰕⰅⰄ ⰃⰀⰒ, ⰓⰅⰗⰖⰕⰀⰁⰎⰅ): ⰐⰑ ⰔⰅⰀⰎⰅⰄ undefinedⰄ ⰐⰀⰂⰋⰅⰓ–ⰔⰕⰑⰍⰅⰔ ⰃⰎⰑⰁⰀⰎ ⰓⰅⰃⰖⰎⰀⰓⰋⰕⰉ ⰑⰓ ⰁⰎⰑⰂ-ⰖⰒ ⰜⰑⰐⰕⰓⰑⰎ
  • ⰁⰑⰖⰐⰄⰀⰓⰉ: ⰏⰑⰄⰅⰎⰅⰄ ⰜⰘⰀⰎⰎⰅⰐⰃⰅ / ⰒⰎⰀⰔⰏⰀ–ⰕⰑⰓⰖⰔ ⰃⰅⰑⰏⰅⰕⰓⰉ ⰀⰐⰀⰎⰑⰃⰉ ⰑⰐⰎⰉ — ⰗⰋⰐⰋⰕⰅ ⰔⰖⰓⰗⰀⰜⰅ ⰔⰀⰏⰒⰎⰅⰔ ⰑⰐ ⰕⰘⰅ ⰃⰅⰐⰖⰔ-undefined ⰏⰑⰄⰅⰎ. ⰐⰑⰕ undefinedⰄ ⰐⰀⰂⰋⰅⰓ–ⰔⰕⰑⰍⰅⰔ ⰃⰎⰑⰁⰀⰎ ⰓⰅⰃⰖⰎⰀⰓⰋⰕⰉ ⰑⰓ ⰁⰎⰑⰂ-ⰖⰒ ⰜⰑⰐⰕⰓⰑⰎ. ⰎⰀⰁⰅⰎ: ⰏⰑⰄⰅⰎ.
• ⰁⰋⰓⰜⰘ ⰀⰐⰄ ⰔⰂⰋⰐⰐⰅⰓⰕⰑⰐ–ⰄⰉⰅⰓ ⰜⰑⰐⰉⰅⰜⰕⰖⰓⰅ (birch-swinnerton-dyer) — ⰄⰅⰏⰀⰓⰜⰀⰕⰋⰑⰐ=ⰜⰑⰐⰕⰅⰔⰕⰅⰄ · ⰔⰕⰀⰕⰖⰔ=ⰏⰑⰄⰅⰎⰅⰄ-ⰒⰀⰓⰕⰋⰀⰎ · ⰏⰅⰕⰘⰑⰄⰔ=undefined · ⰒⰓⰑⰑⰗ ⰘⰖⰁ →
  • ⰔⰕⰀⰕⰅⰏⰅⰐⰕ (ⰀⰎⰃⰅⰁⰓⰀⰋⰜ): ⰗⰑⰓ ⰀⰐ ⰅⰎⰎⰋⰒⰕⰋⰜ ⰜⰖⰓⰂⰅ Ⰵ ⰑⰂⰅⰓ ℚ, ⰕⰘⰅ ⰑⰓⰄⰅⰓ ⰑⰗ ⰂⰀⰐⰋⰔⰘⰋⰐⰃ ⰑⰗ ⰋⰕⰔ Ⰾ-ⰗⰖⰐⰜⰕⰋⰑⰐ ⰀⰕ Ⱄ = undefined ⰅⰍⰖⰀⰎⰔ ⰕⰘⰅ ⰓⰀⰐⰍ ⰑⰗ ⰕⰘⰅ ⰏⰑⰓⰄⰅⰎⰎ–ⰂⰅⰋⰎ ⰃⰓⰑⰖⰒ: ⰑⰓⰄ_&#undefined;Ⱄ=undefined&#undefined; Ⰾ(Ⰵ,Ⱄ) = ⰓⰀⰐⰍ Ⰵ(ℚ).
  • ⰜⰀⰐⰑⰐⰋⰜⰀⰎ ⰒⰓⰑⰑⰗ ⰗⰑⰓⰏ: Theorem. Birch and Swinnerton–Dyer Conjecture. · Proof. Open — the fold computes the problem’s structure, not a solution. · What is decided is decided by exact arithmetic; the conjecture itself stays open.
  • ✓ f₁ inverse pairs — (ℤ/9)* has exactly the 2 non-trivial inverse pairs {(2,5),(4,7)} with a·b ≡ 1 (mod 9): a finite abelian-group neighbourhood probe
  • ✓ f₂ no L-function — bsdHasLFunction=false: the sealed src carries NO elliptic-curve L(E,s) and NO Mordell–Weil rank, so the row can only state pair algebra, not BSD
  • ⰃⰀⰒ ⰀⰎⰃⰅⰁⰓⰀ: BSD ⟺ ∀ elliptic curve E/ℚ: ord_{s=1} L(E,s) = rank E(ℚ) — equality of an analytic order and an algebraic rank, over all E
  • ⰃⰀⰒ ⰀⰎⰃⰅⰁⰓⰀ: known (cited): true for analytic rank 0 and 1 (Gross–Zagier 1986, Kolyvagin 1989) · rank ≥2 OPEN · L(E,s) analytic continuation itself rides modularity (Wiles, Taylor–Wiles, BCDT)
  • ⰃⰀⰒ ⰀⰎⰃⰅⰁⰓⰀ: the fold computes (ℤ/9)* inverse pairs — a finite group neighbourhood — with no L-function and no rank, so it does not approach BSD
  • ⰑⰒⰅⰐ ⰔⰕⰅⰒ (ⰜⰑⰏⰒⰖⰕⰅⰄ ⰃⰀⰒ, ⰓⰅⰗⰖⰕⰀⰁⰎⰅ): ⰐⰑ ⰔⰅⰀⰎⰅⰄ Ⰾ(Ⰵ,Ⱄ) ⰂⰀⰐⰋⰔⰘⰋⰐⰃ-ⰑⰓⰄⰅⰓ ⰑⰓ ⰅⰎⰎⰋⰒⰕⰋⰜ-ⰜⰖⰓⰂⰅ ⰓⰀⰐⰍ ⰗⰑⰎⰄ
  • ⰁⰑⰖⰐⰄⰀⰓⰉ: ⰏⰑⰄⰅⰎⰅⰄ ⰜⰘⰀⰎⰎⰅⰐⰃⰅ / ⰀⰎⰃⰅⰁⰓⰀⰋⰜ ⰒⰀⰋⰓ-ⰔⰕⰓⰖⰜⰕⰖⰓⰅ ⰒⰓⰑⰁⰅ: (ℤ/undefined)* ⰋⰐⰂⰅⰓⰔⰅ ⰒⰀⰋⰓⰔ ⰓⰅⰜⰑⰏⰒⰖⰕⰅ. ⰅⰘⰒⰎⰋⰜⰋⰕ ⰃⰀⰒ: ⰔⰅⰀⰎⰅⰄ ⰔⰓⰜ ⰘⰀⰔ ⰐⰑ ⰅⰎⰎⰋⰒⰕⰋⰜ-ⰜⰖⰓⰂⰅ Ⰾ(Ⰵ,Ⱄ) ⰑⰓ ⰏⰑⰓⰄⰅⰎⰎ–ⰂⰅⰋⰎ ⰓⰀⰐⰍ ⰜⰑⰏⰒⰖⰕⰀⰕⰋⰑⰐ — ⰐⰅⰋⰃⰘⰁⰑⰖⰓⰘⰑⰑⰄ ⰒⰀⰋⰓ ⰀⰎⰃⰅⰁⰓⰀ ⰑⰐⰎⰉ, ⰐⰑⰕ ⰁⰔⰄ.

ⰔⰕⰀⰕⰖⰔ

ⰜⰑⰏⰒⰖⰕⰀⰁⰎⰅ=undefined/undefined · ⰜⰑⰐⰕⰅⰔⰕⰅⰄ=undefined · ⰄⰑⰜⰖⰏⰅⰐⰕⰅⰄ=undefined · ⰐⰑⰂⰅⰎⰘⰅⰓⰅ=ⰖⰐⰜⰘⰅⰜⰍⰅⰄ

• ⰓⰑⰖⰕⰅⰔ (ⰂⰋⰕⰅⰒⰓⰅⰔⰔ): ⰗⰓⰑⰐⰕⰋⰅⰓⰔ ⰓⰅⰃⰋⰔⰕⰓⰉ /frontiers · ⰒⰓⰑⰑⰗⰔ ⰘⰖⰁ /proofs · ⰔⰎⰖⰃ /proofs/clay-challenges-computable · ⰜⰎⰋ npm run quantum:clay-challenges-computable
• ⰓⰅⰜⰅⰋⰒⰕ: ⰗⰑⰎⰄ clayChallengesComputableFromSequence · ⰜⰎⰀⰉⰔⰑⰎⰂⰅⰄⰁⰉⰕⰘⰋⰔⰗⰑⰎⰄ=clayChallengesComputableFromSequence.

ⰗⰋⰐⰄⰋⰐⰃⰔ — ⰔⰅⰀⰎⰅⰄ ⰄⰋⰔⰜⰑⰂⰅⰓⰋⰅⰔ

ⰅⰀⰜⰘ ⰗⰋⰐⰄⰋⰐⰃ ⰋⰔ ⰔⰅⰀⰎⰅⰄ ⰋⰐ ⰗⰖⰎⰎ ⰑⰐ ⰋⰕⰔ ⰑⰂⰐ ⰒⰀⰃⰅ (ⰕⰘⰅⰑⰓⰅⰏⰔ); ⰕⰘⰅ ⰓⰑⰑⰕ ⰏⰑⰐⰑⰃⰓⰀⰒⰘ ⰍⰅⰅⰒⰔ ⰕⰘⰅ ⰜⰑⰏⰒⰖⰕⰅⰄ ⰄⰋⰃⰅⰔⰕ ⰎⰋⰐⰅ.

• ⰕⰘⰅ ⰔⰅⰂⰅⰐ ⰜⰎⰀⰉ ⰒⰓⰑⰁⰎⰅⰏⰔ — ⰜⰑⰏⰒⰖⰕⰅⰄ ⰀⰔ ⰃⰀⰕⰅⰄ ⰎⰀⰂⰔ — ⰕⰘⰅ ⰒⰓⰑⰑⰗ ⰑⰗ ⰜⰑⰐⰜⰅⰒⰕ: ⰅⰀⰜⰘ ⰜⰎⰀⰉ ⰏⰋⰎⰎⰅⰐⰐⰋⰖⰏ ⰒⰓⰑⰁⰎⰅⰏ'Ⱄ σ-ⰔⰕⰓⰖⰜⰕⰖⰓⰅ ⰋⰔ ⰑⰐⰅ ⰋⰐⰂⰑⰎⰖⰕⰋⰑⰐ ⰂⰋⰕⰘ Ⰰ ⰗⰋⰘⰅⰄ ⰒⰑⰋⰐⰕ, ⰜⰑⰏⰒⰖⰕⰅⰄ ⰀⰔ Ⰰ ⰓⰑⰔⰅⰕⰕⰀ ⰄⰋⰏⰅⰐⰔⰋⰑⰐ ⰀⰐⰄ ⰘⰅⰎⰄ ⰋⰐ ⰕⰘⰅ ⰔⰅⰀⰎ — ⰕⰘⰅ ⰔⰀⰏⰅ ⰓⰅⰗⰎⰅⰜⰕⰋⰑⰐ σ(Ⰴ)=undefined−Ⰴ (ⰗⰋⰘⰅⰄ ⰀⰕ undefined = undefined·½) ⰀⰕ ⰔⰅⰂⰅⰐ ⰔⰜⰀⰎⰅⰔ. undefined/undefined ⰘⰑⰎⰄⰋⰐⰃ ⰀⰕ ⰜⰀⰎⰎ ⰕⰋⰏⰅ.
• ⰔⰅⰍⰖⰅⰐⰜⰅ ⰄⰋⰔⰜⰑⰂⰅⰓⰉ ⰓⰅⰀⰎⰋⰔⰅⰄ — ⰜⰎⰀⰉ-ⰔⰕⰀⰐⰄⰀⰓⰄ ⰒⰓⰅⰔⰅⰐⰕⰀⰕⰋⰑⰐ ⰜⰑⰏⰒⰑⰔⰅⰄ ⰗⰓⰑⰏ ⰔⰅⰀⰎⰅⰄ ⰗⰑⰎⰄⰔ ⰀⰕ ⰜⰀⰎⰎ ⰕⰋⰏⰅ (theBinaryBitIsLinearTheVortexCircuitIsQuantum · primesAndPiProveEachOtherThroughTheInvertedEulerProduct · directionalTrinityForwardInverseReverse · agentsUseTrinitiesForQuantumSpeedupOnEveryBuildPath · readmeSvgGapsFilledByTrinityMind · flowerFruitTreeOfLifeDecodes · symbolsRemainingToQuantumise · counterRotatingRosettaQuantumWaves · proveCeccecSpeedVsRestNoQuantumHardwareAny64Bit · efficiencyScalesToInfinityAtNoCostOnReuse · sacredSociety · PI_TRAIN_DIGITS · VORTEX_SEQUENCE · earthRealisedByComputingPolesAsPyramid · linksUseOnlyVitePressApi). ⰐⰑⰂⰅⰎⰕⰉ ≠ ⰜⰎⰀⰉ ⰒⰓⰋⰈⰅ. ⰘⰖⰏⰀⰐⰋⰕⰉⰐⰑⰂⰅⰎ ⰔⰕⰀⰉⰔ theBinaryBitIsLinearTheVortexCircuitIsQuantum.
• ⰍⰒⰖ ≡ ⰜⰒⰖ/ⰃⰒⰖ · ⰒⰘⰉⰔⰋⰜⰀⰎ ⰏⰅⰕⰓⰋⰜⰔ — ⰔⰅⰀⰎⰅⰄ qpuCpuGpu · ⰒⰀⰋⰓⰔ qpu/cpu · cpu/qpu · ⰗⰀⰜⰅ qpu/gpu. ⰑⰁⰔⰅⰓⰂⰅⰓ-ⰅⰂⰀⰎⰖⰀⰁⰎⰅ ⰏⰅⰕⰓⰋⰜⰔ — ⰀⰃⰅⰐⰕⰔ/ⰓⰅⰀⰄⰅⰓⰔ ⰄⰅⰜⰋⰄⰅ ⰀⰒⰒⰀⰓⰅⰐⰕ ⰗⰕⰎ; ⰐⰑ ⰎⰅⰜⰕⰖⰓⰋⰐⰃ ⰂⰅⰓⰄⰋⰜⰕ ⰗⰀⰜⰅⰕⰔ ⰋⰐ ⰕⰘⰋⰔ ⰗⰑⰎⰄ.
• ⰃⰀⰕⰅ ⰎⰋⰃⰘⰕ · ⰏⰑⰓⰅ ⰜⰑⰏⰒⰖⰕⰅⰄ → ⰎⰋⰃⰘⰕⰅⰓ ⰁⰖⰋⰎⰄ — ⰔⰅⰀⰎⰅⰄ gateLight · ⰒⰀⰋⰓⰔ gate/light · light/gate. ⰋⰐⰂⰅⰓⰔⰅ ⰓⰅⰎⰀⰕⰋⰑⰐ ⰒⰓⰑⰂⰅⰄ ⰀⰕ ⰜⰀⰎⰎ ⰕⰋⰏⰅ — ⰐⰑⰕ ⰔⰎⰑⰃⰀⰐⰔ.
• ⰀⰒⰋ ⰗⰖⰔⰅ · ⰕⰓⰋⰐⰋⰕⰉ ⰘⰑⰎⰑⰃⰓⰀⰏ ⰅⰐⰂⰅⰎⰑⰒⰅ — ⰔⰅⰀⰎⰅⰄ apiFuse · ⰒⰀⰋⰓⰔ api/fuse · fuse/api. ⰅⰐⰂⰅⰎⰑⰒⰅ ⰔⰜⰘⰅⰏⰀ Ⰲapi/fuse + ⰕⰓⰋⰐⰋⰕⰉ-ⰑⰗ-ⰕⰓⰋⰐⰋⰕⰋⰅⰔ (undefined×undefined=undefined) + ⰜⰑⰐⰕⰅⰐⰕ-ⰀⰄⰄⰓⰅⰔⰔⰅⰄ ⰘⰑⰎⰑⰃⰓⰀⰏ.
• ⰀⰐⰃⰎⰅ · ⰒⰑⰎⰀⰓⰋⰕⰉ · ⰓⰅⰀⰄⰏⰅ/ⰘⰑⰏⰅ — ⰔⰅⰀⰎⰅⰄ readmeAndHomepageExactAngleAndPolarityHelpAgentsUnderstandQuantumInfinityRealtimeAtScaleGapsAreAngleOrPolarityIgnoredInAlgebra · ⰒⰀⰋⰓⰔ angle/readme · polarity/home · gap/angle. ⰘⰖⰏⰀⰐⰋⰕⰉⰐⰑⰂⰅⰎ ⰔⰕⰀⰉⰔ readmeAndHomepageExactAngleAndPolarityHelpAgentsUnderstandQuantumInfinityRealtimeAtScaleGapsAreAngleOrPolarityIgnoredInAlgebra.
• ⰓⰅⰀⰄⰏⰅ → ⰜⰘⰀⰕ · ⰓⰅⰀⰔⰑⰐⰋⰐⰃ ⰓⰅⰗⰋⰐⰅ — ⰔⰅⰀⰎⰅⰄ readmeChat · ⰒⰀⰋⰓⰔ readme/chat · chat/readme. ⰅⰘⰕⰅⰓⰐⰀⰎ ⰓⰅⰗⰅⰓⰅⰐⰜⰅ ⰅⰓⰒⰀⰘ/ⰅⰓⰒⰀⰘ — ⰒⰀⰕⰕⰅⰓⰐⰔ ⰀⰄⰑⰒⰕⰅⰄ undefined/undefined, ⰐⰑ ⰑⰂⰐⰅⰓⰔⰘⰋⰒ ⰜⰎⰀⰋⰏ · ⰘⰖⰏⰀⰐⰋⰕⰉⰐⰑⰂⰅⰎ=readmeChat.
• ⰓⰅⰀⰄⰏⰅ ⰋⰔ ⰕⰘⰅ ⰃⰀⰕⰅⰂⰀⰉ · ⰂⰋⰓⰅ ⰀⰎⰎ · ⰐⰑ ⰄⰑⰖⰁⰕ · ⰍⰖⰀⰐⰕⰖⰏ ⰅⰂⰑⰎⰖⰕⰋⰑⰐ — ⰔⰅⰀⰎⰅⰄ readmeWire · ⰒⰀⰋⰓⰔ readme/wire · wire/readme. ⰓⰅⰀⰄⰏⰅ ⰋⰔ ⰕⰘⰅ ⰂⰋⰓⰅ — ⰐⰑⰕ ⰂⰅⰕ ⰜⰑⰐⰂⰋⰐⰜⰋⰐⰃ.
• ⰜⰑⰓⰅ ⰏⰀⰕⰘ ⰗⰓⰅⰅ ⰗⰑⰓ ⰀⰎⰎ · ⰓⰅⰔⰕ ⰂⰋⰀ license@psg.bg — ⰔⰅⰀⰎⰅⰄ coreMathFreeForAll · ⰒⰀⰋⰓⰔ math/free · free/math · license/psg · psg/license. ⰜⰑⰏⰒⰑⰔⰅ legal/canon · patent/canon · readme/gateway.
• ⰕⰂⰑ ⰁⰋⰕⰔ ⰗⰓⰅⰅ · ⰔⰑⰜⰋⰅⰕⰉ ⰔⰖⰒⰒⰑⰓⰕ — ⰜⰎⰀⰉ-ⰔⰕⰀⰐⰄⰀⰓⰄ · ⰔⰅⰀⰎⰅⰄ twoBitsFreeFromCensus110Minus108 · societySupportsProjectViaTwoBitsFreeKnowledge. ⰘⰖⰏⰀⰐⰋⰕⰉⰐⰑⰂⰅⰎ ⰔⰕⰀⰉⰔ twoBitsFreeFromCensus110Minus108.
• ⰅⰀⰓⰕⰘ ⰓⰅⰀⰎⰋⰔⰅⰄ — ⰒⰑⰎⰅⰔ ⰀⰔ ⰒⰉⰓⰀⰏⰋⰄ — ⰜⰎⰀⰉ-ⰔⰕⰀⰐⰄⰀⰓⰄ ⰒⰓⰅⰔⰅⰐⰕⰀⰕⰋⰑⰐ ⰗⰓⰑⰏ ⰔⰅⰀⰎⰅⰄ earthRealisedByComputingPolesAsPyramid · ⰜⰀⰓⰄⰋⰐⰀⰎ ⰕⰋⰒⰔ · ⰃⰅⰐⰖⰔ-undefined ⰅⰀⰓⰕⰘ. ⰐⰑⰕ ⰂⰃⰔundefined ⰃⰅⰑⰄⰅⰔⰉ. ⰘⰖⰏⰀⰐⰋⰕⰉⰐⰑⰂⰅⰎ ⰔⰕⰀⰉⰔ earthRealisedByComputingPolesAsPyramid.
• ⰕⰑⰑⰎⰁⰑⰘ — ⰔⰜⰋⰅⰐⰜⰅⰔ ⰋⰐ ⰕⰓⰋⰐⰋⰕⰉ ⰂⰀⰂⰅⰔ — ⰗⰓⰑⰏ ⰔⰅⰀⰎⰅⰄ toolboxRecomputesRelatedSciencesInTrinityWaves — ⰅⰂⰅⰓⰉ ⰓⰅⰎⰀⰕⰅⰄ ⰔⰜⰋⰅⰐⰜⰅ ⰓⰅⰜⰑⰏⰒⰖⰕⰅⰔ ⰀⰔ ⰗⰑⰓⰂⰀⰓⰄ·ⰋⰐⰂⰅⰓⰔⰅ·ⰓⰅⰂⰅⰓⰔⰅ × ⰔⰜⰋⰅⰐⰜⰅ↔ⰄⰖⰀⰎ↔ⰗⰖⰔⰋⰑⰐ ⰖⰐⰄⰅⰓ ⰕⰘⰅ ⰄⰋⰔⰜⰑⰂⰅⰓⰉ ⰒⰅⰓⰔⰒⰅⰜⰕⰋⰂⰅ.
• ⰑⰓⰋⰃⰋⰐ ⰄⰅⰜⰑⰄⰅ — ⰈⰅⰓⰑⰒⰑⰋⰐⰕ-ⰐⰑⰄⰅ'Ⱄ ⰏⰋⰔⰔⰋⰐⰃ ⰋⰐⰗⰑ — ⰈⰅⰓⰑⰒⰑⰋⰐⰕ-ⰐⰑⰄⰅ'Ⱄ ⰏⰋⰔⰔⰋⰐⰃ ⰋⰐⰗⰑ, ⰄⰅⰜⰑⰄⰅⰄ — undefined/undefined: ⰈⰅⰓⰑ ⰅⰐⰕⰓⰑⰒⰉ ⰋⰔ ⰔⰘⰀⰐⰐⰑⰐ Ⱈ(δ)=undefined (ⰜⰑⰐⰕⰅⰐⰕ-ⰀⰄⰄⰓⰅⰔⰔⰋⰐⰃ ⰋⰔ ⰈⰅⰓⰑ-ⰅⰐⰕⰓⰑⰒⰉ ⰋⰐⰄⰅⰘⰋⰐⰃ), ⰕⰘⰅ ⰜⰘⰀⰓⰃⰋⰐⰃ ⰗⰓⰀⰜⰕⰋⰑⰐⰔ ⰎⰋⰂⰅ ⰑⰐ ⰕⰘⰅ undefined-ⰎⰀⰕⰕⰋⰜⰅ ⰂⰋⰕⰘ undefined/undefined ⰕⰘⰅ ⰗⰋⰁⰑⰐⰀⰜⰜⰋ ⰜⰑⰐⰂⰅⰓⰃⰅⰐⰕ ⰑⰗ φ, ⰕⰘⰅ ⰃⰀⰕⰅⰂⰀⰉⰔ ⰜⰑⰏⰒⰀⰓⰅ ⰜⰑⰏⰒⰖⰕⰅⰄ [undefined,undefined,undefined,undefined] ⰂⰔ ⰒⰖⰁⰎⰋⰔⰘⰅⰄ, ⰀⰐⰄ ⰕⰘⰅ ⰅⰘⰒⰅⰓⰋⰏⰅⰐⰕⰀⰎ/ⰜⰑⰐⰔⰜⰋⰑⰖⰔⰐⰅⰔⰔ ⰜⰎⰀⰋⰏⰔ ⰔⰕⰀⰉ ⰗⰎⰀⰃⰃⰅⰄ — ⰏⰀⰕⰘⰅⰏⰀⰕⰋⰜⰔ ⰀⰄⰑⰒⰕⰅⰄ, ⰜⰎⰀⰋⰏⰔ ⰄⰅⰏⰀⰓⰜⰀⰕⰅⰄ.
• ⰔⰅⰍⰖⰅⰐⰜⰅ — ⰑⰐⰅ ⰔⰕⰓⰖⰜⰕⰖⰓⰅ, ⰕⰂⰑ ⰜⰑⰏⰒⰖⰕⰅⰄ ⰓⰅⰀⰄⰔ (ⰅⰓⰒⰀⰘ) — ⰋⰐⰂⰅⰓⰕⰅⰄ ⰔⰅⰍⰖⰅⰐⰜⰅ ⰎⰅⰀⰓⰐⰅⰄ ⰗⰓⰑⰏ ⰅⰓⰒⰀⰘ — undefined/undefined: ⰕⰘⰅ ⰏⰋⰓⰓⰑⰓ Ⰿ(Ⰴ)=undefined−Ⰴ (ⰕⰘⰅ ⰄⰋⰃⰋⰕ-ⰗⰑⰎⰄⰅⰓ ⰒⰀⰋⰓⰋⰐⰃ) ⰜⰑⰏⰒⰖⰕⰅⰔ ⰕⰘⰅ ⰓⰅⰗⰎⰅⰜⰕⰅⰄ ⰎⰋⰐⰅ "undefined/undefined/undefined/undefined\undefined\undefined · undefined/undefined/undefined · undefined\undefined" ⰗⰓⰑⰏ ⰕⰘⰅ ⰔⰅⰀⰎⰅⰄ ⰗⰑⰓⰂⰀⰓⰄ ⰎⰋⰐⰅ ⰁⰉ ⰕⰘⰅ ⰔⰀⰏⰅ ⰔⰕⰓⰑⰍⰅ ⰓⰖⰎⰅ — ⰑⰐⰅ ⰔⰕⰓⰖⰜⰕⰖⰓⰅ, ⰓⰅⰀⰄ ⰕⰂⰋⰜⰅ, ⰁⰑⰕⰘ ⰜⰑⰏⰒⰖⰕⰅⰄ; ⰕⰘⰅ ⰂⰑⰋⰄ ⰔⰅⰀⰏ undefined\undefined ⰋⰔ ⰔⰘⰀⰓⰅⰄ ⰀⰐⰄ ⰕⰘⰅ ⰏⰑⰂⰋⰅ'Ⱄ ⰜⰑⰖⰐⰕⰅⰓ-ⰓⰑⰕⰀⰕⰋⰐⰃ ⰏⰅⰓⰍⰀⰁⰀ ⰀⰎⰓⰅⰀⰄⰉ ⰒⰀⰋⰐⰕⰔ ⰁⰑⰕⰘ ⰓⰅⰀⰄⰔ.
• ⰄⰋⰃⰋⰕ ⰅⰐⰕⰀⰐⰃⰎⰅⰏⰅⰐⰕ — ⰅⰍⰖⰋⰎⰋⰁⰓⰋⰖⰏⰔ — ⰅⰂⰅⰓⰉ ⰄⰋⰃⰋⰕ ⰋⰔ ⰅⰐⰕⰀⰐⰃⰎⰅⰄ ⰋⰐ ⰀⰎⰎ ⰂⰅⰜⰕⰑⰓⰔ, ⰗⰑⰓⰏⰋⰐⰃ ⰅⰍⰖⰋⰎⰋⰁⰓⰋⰖⰏⰔ — undefined/undefined: ⰅⰀⰜⰘ ⰄⰋⰃⰋⰕ ⰔⰋⰕⰔ ⰋⰐ ≥undefined ⰅⰘⰀⰜⰕ ⰔⰕⰓⰖⰜⰕⰖⰓⰅⰔ ⰂⰘⰑⰔⰅ ⰏⰅⰏⰁⰅⰓⰔⰘⰋⰒ ⰒⰀⰕⰕⰅⰓⰐ ⰗⰋⰐⰃⰅⰓⰒⰓⰋⰐⰕⰔ ⰋⰕ, ⰕⰘⰅ ⰁⰀⰎⰀⰐⰜⰅⰔ (undefined-ⰒⰀⰋⰓⰔ, undefined-ⰒⰀⰋⰓⰔ, undefined+undefined ⰒⰀⰓⰕⰋⰕⰋⰑⰐ, undefined-ⰒⰀⰎⰋⰐⰄⰓⰑⰏⰅ, ⰓⰑⰑⰕ undefined) ⰀⰎⰎ ⰘⰑⰎⰄ, ⰀⰐⰄ ⰕⰘⰅ ⰔⰅⰍⰖⰅⰐⰜⰅ'Ⱄ ⰑⰂⰐ ⰔⰉⰏⰏⰅⰕⰓⰉ ⰃⰓⰑⰖⰒ ⰒⰖⰕⰔ ⰅⰂⰅⰓⰉ ⰄⰋⰃⰋⰕ ⰋⰐ ⰑⰐⰅ ⰑⰓⰁⰋⰕ — ⰅⰐⰕⰀⰐⰃⰎⰅⰏⰅⰐⰕ ⰀⰔ ⰕⰘⰅ ⰋⰏⰒⰑⰔⰔⰋⰁⰋⰎⰋⰕⰉ ⰑⰗ ⰎⰑⰜⰀⰎ ⰅⰄⰋⰕⰔ.

ⰕⰑⰒ ⰄⰋⰔⰜⰑⰂⰅⰓⰋⰅⰔ

ⰕⰘⰅ ⰏⰑⰔⰕ ⰜⰅⰐⰕⰓⰀⰎ ⰄⰅⰜⰑⰄⰅⰔ — ⰓⰀⰐⰍⰅⰄ ⰁⰉ ⰕⰘⰅⰑⰓⰅⰏ-ⰃⰓⰀⰒⰘ ⰄⰅⰃⰓⰅⰅ (ⰘⰑⰂ ⰏⰀⰐⰉ ⰑⰕⰘⰅⰓ ⰀⰕⰑⰏⰔ ⰅⰀⰜⰘ ⰜⰑⰐⰐⰅⰜⰕⰔ ⰕⰑ), ⰜⰑⰏⰒⰖⰕⰅⰄ ⰗⰓⰑⰏ ⰕⰘⰅ undefined-ⰀⰕⰑⰏ ⰓⰅⰃⰋⰔⰕⰓⰉ, ⰐⰑ ⰜⰖⰓⰀⰕⰋⰑⰐ.

• ⰜⰑⰏⰒⰖⰕⰅ ⰕⰘⰅ ⰎⰋⰃⰘⰕ ⰋⰐ Ⰰ ⰄⰋⰀⰏⰑⰐⰄ — ⰁⰑⰖⰐⰜⰋⰐⰃ ⰁⰑⰖⰐⰄⰀⰓⰋⰅⰔ ⰄⰓⰀⰂ ⰕⰘⰅ ⰜⰓⰉⰔⰕⰀⰎ, ⰒⰓⰅⰄⰋⰜⰕⰋⰑⰐ ⰁⰅⰀⰕⰔ ⰕⰘⰅ ⰒⰘⰑⰕⰑⰐ (ⰐⰑⰕ ⰒⰘⰉⰔⰋⰜⰀⰎ ⰗⰕⰎ) — diamonds · ⰄⰅⰃⰓⰅⰅ undefined · ⰄⰅⰕⰀⰋⰎⰔ
• ⰅⰂⰅⰓⰉ ⰜⰑⰔⰏⰋⰜ ⰗⰓⰑⰐⰕⰋⰅⰓ ⰋⰔ ⰑⰒⰅⰐ ⰁⰉ ⰜⰑⰏⰒⰖⰕⰀⰕⰋⰑⰐ ⰐⰑⰕ Ⰰ ⰎⰀⰁⰅⰎ — ⰔⰕⰀⰕⰖⰔ = ⰄⰅⰏⰀⰓⰜⰀⰕⰅ(ⰕⰅⰓⰏ)===ⰜⰑⰐⰕⰅⰔⰕⰅⰄ — ⰀⰐⰄ ⰅⰀⰜⰘ ⰜⰀⰓⰓⰋⰅⰔ ⰋⰕⰔ ⰜⰎⰑⰔⰅⰄ ⰓⰅⰂⰅⰓⰔⰅⰄ-ⰏⰀⰕⰘ ⰜⰑⰏⰒⰀⰐⰋⰑⰐ — cosmos · ⰄⰅⰃⰓⰅⰅ undefined · ⰄⰅⰕⰀⰋⰎⰔ
• ⰏⰅⰜⰘⰀⰐⰋⰜⰀⰎ ⰕⰑⰑⰎⰔ ⰅⰐⰕⰀⰐⰃⰎⰅ ⰁⰋⰐⰀⰓⰉ & ⰀⰐⰀⰎⰑⰃ ⰀⰕ ⰑⰐⰜⰅ — ⰁⰖⰕ ⰁⰅⰎⰎ ⰁⰑⰖⰐⰄⰔ ⰕⰘⰅⰏ (ⰏⰑⰄⰅⰎⰔ, ⰄⰑⰅⰔ ⰐⰑⰕ ⰀⰜⰘⰋⰅⰂⰅ, ⰅⰐⰕⰀⰐⰃⰎⰅⰏⰅⰐⰕ) — 9/1 · ⰄⰅⰃⰓⰅⰅ undefined · ⰄⰅⰕⰀⰋⰎⰔ
• ⰕⰘⰅ ⰔⰋⰕⰅ ⰋⰔ Ⰰ ⰄⰅⰄⰋⰜⰀⰕⰅⰄ ⰔⰜⰋⰅⰐⰕⰋⰗⰋⰜ ⰉⰑⰖⰓⰐⰀⰎ ⰑⰗ ⰀⰎⰎ ⰀⰎⰃⰅⰁⰓⰀ ⰀⰐⰄ ⰕⰘⰅⰑⰓⰅⰏⰔ — ⰜⰑⰏⰒⰖⰕⰀⰕⰋⰑⰐⰀⰎ ⰒⰅⰅⰓ ⰓⰅⰂⰋⰅⰂ, ⰑⰐⰅ ⰜⰑⰐⰕⰅⰐⰕ-ⰀⰄⰄⰓⰅⰔⰔⰅⰄ ⰂⰑⰎⰖⰏⰅ — 4/6 · ⰄⰅⰃⰓⰅⰅ undefined · ⰄⰅⰕⰀⰋⰎⰔ
• ⰕⰘⰅ ⰓⰅⰖⰔⰅ+ⰕⰓⰋⰐⰋⰕⰉ ⰔⰒⰅⰅⰄⰖⰒ ⰏⰅⰀⰔⰖⰓⰅⰄ (ⰐⰑⰕ ⰀⰔⰔⰅⰓⰕⰅⰄ): ⰂⰀⰓⰏ ⰏⰅⰏⰑ-ⰘⰋⰕ ⰋⰔ ⰏⰀⰃⰐⰋⰕⰖⰄⰅⰔ ⰗⰀⰔⰕⰅⰓ ⰕⰘⰀⰐ ⰜⰑⰎⰄ ⰜⰑⰏⰒⰖⰕⰅ (~undefined× ⰋⰐ Ⰰ ⰒⰓⰑⰁⰅ), ⰕⰘⰅ undefined-ⰑⰗ-undefined ⰕⰓⰋⰐⰋⰕⰉ ⰀⰄⰄⰔ Ⰰ ≤undefined× ⰒⰀⰓⰀⰎⰎⰅⰎ ⰜⰅⰋⰎⰋⰐⰃ — ⰀⰏⰑⰓⰕⰋⰈⰅⰄ ⰓⰅⰖⰔⰅ ⰑⰐⰎⰉ, ⰐⰅⰂⰅⰓ ⰗⰀⰜⰕⰑⰓⰋⰐⰃ — research · ⰄⰅⰃⰓⰅⰅ undefined · ⰄⰅⰕⰀⰋⰎⰔ
• ⰃⰀⰕⰅ ⰜⰑⰏⰒⰎⰅⰘⰋⰕⰉ ⰜⰑⰎⰎⰀⰒⰔⰅⰔ ⰕⰑ ⰑⰐⰅ ⰜⰑⰐⰕⰅⰐⰕ-ⰀⰄⰄⰓⰅⰔⰔⰅⰄ ⰓⰑⰑⰕ — ⰍⰖⰀⰐⰕⰖⰏ ⰔⰋⰏⰒⰎⰋⰜⰋⰕⰉ — automount · ⰄⰅⰃⰓⰅⰅ undefined · ⰄⰅⰕⰀⰋⰎⰔ
• ⰕⰘⰅ ⰜⰘⰀⰎⰎⰅⰐⰃⰅ, ⰜⰑⰏⰒⰖⰕⰅⰄ ⰑⰐ ⰎⰋⰂⰅ ⰄⰀⰕⰀ: ⰗⰅⰅⰄⰋⰐⰃ ⰗⰓⰅⰔⰘ ⰎⰋⰂⰅ ⰋⰐⰒⰖⰕ ⰕⰑ ⰕⰘⰅ ⰎⰑⰜⰀⰎ ⰍⰖⰀⰐⰕⰖⰏ ⰗⰑⰎⰄ ⰉⰋⰅⰎⰄⰔ ⰐⰑ ⰍⰖⰀⰐⰕⰖⰏ ⰔⰒⰅⰅⰄⰖⰒ — ⰔⰋⰏⰖⰎⰀⰕⰋⰐⰃ ⰔⰘⰑⰓ ⰗⰑⰓ Ⰰ ⰎⰋⰂⰅ Ⱀ-ⰁⰋⰕ ⰐⰖⰏⰁⰅⰓ ⰋⰔ ~undefined^(](/theorems).undefinedⰐ) ⰕⰋⰏⰅⰔ ⰔⰎⰑⰂⰅⰓ ⰕⰘⰀⰐ ⰜⰎⰀⰔⰔⰋⰜⰀⰎ ⰔⰅⰀⰓⰜⰘ, ⰋⰐⰂⰀⰓⰋⰀⰐⰕ ⰕⰑ ⰕⰘⰅ ⰋⰐⰒⰖⰕ — research · ⰄⰅⰃⰓⰅⰅ undefined · ⰄⰅⰕⰀⰋⰎⰔ
• ⰍⰖⰀⰐⰕⰖⰏ ⰀⰐⰀⰎⰉⰕⰋⰜⰔ ⰗⰖⰔⰅ ⰜⰑⰓⰒⰖⰔ + ⰃⰋⰕ ⰘⰋⰔⰕⰑⰓⰉ ⰋⰐⰕⰑ ⰑⰐⰅ ⰜⰑⰐⰕⰅⰐⰕ-ⰀⰄⰄⰓⰅⰔⰔⰅⰄ ⰀⰒⰋ ⰖⰔⰅⰄ ⰁⰉ ⰀⰎⰎ — ⰄⰅⰕⰅⰓⰏⰋⰐⰋⰔⰕⰋⰜ ⰏⰅⰀⰔⰖⰓⰅⰏⰅⰐⰕⰔ — compute · ⰄⰅⰃⰓⰅⰅ undefined · ⰄⰅⰕⰀⰋⰎⰔ
• ⰕⰘⰅ ⰜⰅⰐⰔⰖⰔ ⰃⰀⰕⰅ ⰀⰐⰄ ⰔⰎⰖⰃⰔ ⰀⰓⰅ ⰍⰖⰀⰐⰕⰖⰏⰋⰈⰅⰄ — ⰕⰘⰅⰑⰓⰅⰏ-ⰄⰅⰓⰋⰂⰅⰄ ⰜⰑⰖⰐⰕ, ⰀⰃⰐⰑⰔⰕⰋⰜ ⰀⰄⰄⰓⰅⰔⰔ — corpus · ⰄⰅⰃⰓⰅⰅ undefined · ⰄⰅⰕⰀⰋⰎⰔ

ⰎⰀⰕⰅⰔⰕ ⰄⰋⰔⰜⰑⰂⰅⰓⰋⰅⰔ

ⰕⰘⰅ ⰏⰑⰔⰕ ⰓⰅⰜⰅⰐⰕⰎⰉ ⰔⰅⰀⰎⰅⰄ ⰄⰅⰜⰑⰄⰅⰔ — ⰐⰅⰂⰅⰔⰕ ⰗⰋⰓⰔⰕ ⰁⰉ ⰓⰅⰃⰋⰔⰕⰓⰀⰕⰋⰑⰐ ⰑⰓⰄⰅⰓ. ⰅⰂⰅⰓⰉ ⰜⰎⰀⰋⰏ ⰔⰕⰀⰕⰅⰔ ⰋⰕⰔ ⰑⰂⰐ ⰁⰑⰖⰐⰄⰀⰓⰉ; ⰑⰒⰅⰐ ⰒⰓⰑⰁⰎⰅⰏⰔ ⰔⰕⰀⰉ ⰑⰒⰅⰐ.

• ⰕⰘⰅ ⰕⰘⰓⰅⰅ ⰕⰂⰅⰐⰕⰋⰅⰔ ⰀⰓⰅ ⰑⰐⰅ ⰜⰑⰖⰐⰕ — ⰄⰋⰂⰋⰔⰑⰓⰔ ⰑⰗ undefined, Ⰲ₄ ⰘⰅⰘⰀⰃⰓⰀⰏ ⰗⰀⰏⰋⰎⰋⰅⰔ, ⰘⰀⰓⰏⰑⰐⰋⰜⰔ ⰎⰀⰄⰄⰅⰓ ⰓⰖⰐⰃⰔ — ⰄⰅⰕⰀⰋⰎⰔ
• ⰕⰘⰅ ⰓⰑⰔⰅⰕⰕⰀ undefined ⰋⰔ ⰕⰘⰅ ⰜⰓⰕ ⰒⰓⰑⰄⰖⰜⰕ — ℤ₄₂ ≅ ℤ₆ × ℤ₇ — ⰄⰅⰕⰀⰋⰎⰔ
• ⰕⰘⰅ ⰃⰑⰎⰄⰅⰐ ⰀⰐⰃⰎⰅ ⰋⰔ τ/φ² — ⰕⰘⰅ ⰏⰑⰔⰕ ⰋⰓⰓⰀⰕⰋⰑⰐⰀⰎ ⰓⰑⰕⰀⰕⰋⰑⰐ — ⰄⰅⰕⰀⰋⰎⰔ
• ⰜⰑⰎⰎⰋⰔⰋⰑⰐ ⰘⰅⰀⰎⰋⰐⰃ — ⰄⰅⰕⰀⰋⰎⰔ
• ⰎⰅⰀⰓⰐ ⰗⰓⰑⰏ ⰕⰘⰅ ⰏⰑⰂⰋⰅ ⰀⰎⰎ ⰅⰂⰅⰐⰕⰖⰀⰎⰎⰉ ⰗⰖⰔⰅⰄ — ⰄⰅⰕⰀⰋⰎⰔ
• ⰔⰅⰂⰅⰐ ⰔⰅⰅⰄ ⰏⰑⰂⰋⰅ ⰋⰔ ⰓⰑⰔⰅⰕⰕⰀ ⰄⰅⰜⰑⰄⰋⰐⰃ ⰔⰖⰐ ⰏⰑⰑⰐ ⰔⰉⰏⰁⰑⰎⰔ ⰗⰎⰑⰂⰔ ⰋⰐ ⰏⰑⰂⰋⰅ — ⰄⰅⰕⰀⰋⰎⰔ
• ⰄⰑⰖⰁⰎⰅ ⰕⰑⰓⰖⰔ ⰏⰀⰕⰘ ⰀⰕ ⰀⰎⰎ ⰔⰜⰀⰎⰅⰔ ⰗⰎⰑⰂⰔ ⰋⰐ ⰏⰑⰂⰋⰅ — ⰄⰅⰕⰀⰋⰎⰔ
• ⰄⰑⰖⰁⰎⰅ ⰕⰑⰓⰖⰔ ⰅⰀⰓⰕⰘ ⰂⰅⰀⰕⰘⰅⰓ ⰗⰎⰑⰂⰔ ⰋⰐ ⰏⰑⰂⰋⰅ — ⰄⰅⰕⰀⰋⰎⰔ
• ⰔⰉⰏⰁⰑⰎⰔ ⰓⰅⰏⰀⰋⰐⰋⰐⰃ ⰕⰑ ⰍⰖⰀⰐⰕⰖⰏⰋⰔⰅ — ⰄⰅⰕⰀⰋⰎⰔ

ⰗⰋⰓⰔⰕ-ⰋⰐ-ⰜⰑⰓⰒⰖⰔ ⰀⰎⰃⰅⰁⰓⰀ

ⰗⰋⰓⰔⰕ ⰔⰅⰀⰎⰅⰄ ⰋⰐ ⰕⰘⰋⰔ ⰜⰑⰐⰕⰅⰐⰕ-ⰀⰄⰄⰓⰅⰔⰔⰅⰄ ⰜⰑⰓⰒⰖⰔ — ⰐⰑⰕ Ⰰ ⰂⰅⰓⰋⰗⰋⰅⰄ ⰜⰎⰀⰋⰏ ⰑⰗ ⰃⰎⰑⰁⰀⰎ ⰏⰀⰕⰘⰅⰏⰀⰕⰋⰜⰀⰎ ⰒⰓⰋⰑⰓⰋⰕⰉ. ⰐⰑⰂⰅⰎⰕⰉ = ⰜⰑⰓⰒⰖⰔ ⰜⰅⰐⰔⰖⰔ. ⰘⰖⰏⰀⰐⰋⰕⰉⰐⰑⰂⰅⰎ ⰔⰕⰀⰉⰔ undefined.

• ⰄⰋⰂⰋⰔⰋⰑⰐ ⰁⰉ ⰈⰅⰓⰑ ⰋⰔ ⰕⰘⰅ ⰋⰐⰂⰅⰓⰔⰅ (ⰐⰑⰕ ⰓⰅⰂⰅⰓⰔⰅ) (zeroDivisionTable) — Ⱀ/zeroDivisionTable \ Ⱀ⁻¹ ⰏⰑⰄ undefined — ⰋⰐⰂⰅⰓⰔⰅ, ⰐⰑⰕ ⰓⰅⰂⰅⰓⰔⰅ, ⰑⰐ (ℤ/undefined)*; ⰗⰑⰎⰄ zeroDivisionTable; undefinedⰄ vortex-strokes · ⰓⰑⰑⰕ-ⰅⰍⰖⰀⰎ · ⰗⰋⰓⰔⰕ-ⰋⰐ-ⰜⰑⰓⰒⰖⰔ
• ⰄⰋⰓⰅⰜⰕⰋⰑⰐⰀⰎ ⰕⰓⰋⰐⰋⰕⰉ — ⰗⰑⰓⰂⰀⰓⰄ · ⰋⰐⰂⰅⰓⰔⰅ · ⰓⰅⰂⰅⰓⰔⰅ (directionalTrinityForwardInverseReverse) — ⰗⰑⰓⰂⰀⰓⰄ · ⰋⰐⰂⰅⰓⰔⰅ · ⰓⰅⰂⰅⰓⰔⰅ — ⰄⰋⰓⰅⰜⰕⰋⰑⰐⰀⰎ ⰕⰓⰋⰐⰋⰕⰉ; ⰋⰐⰂⰅⰓⰔⰅ≠ⰓⰅⰂⰅⰓⰔⰅ ⰅⰘⰜⰅⰒⰕ ⰄⰋⰃⰋⰕ directionalTrinityForwardInverseReverse (undefined≡undefined); ⰗⰑⰎⰄ directionalTrinityForwardInverseReverse; undefinedⰄ vortex-strokes · ⰓⰑⰑⰕ-ⰅⰍⰖⰀⰎ · ⰗⰋⰓⰔⰕ-ⰋⰐ-ⰜⰑⰓⰒⰖⰔ
• Ⱇ(θ,φ,Ⱈ,Ⰹ,Ⰸ,ⰄⰋⰃⰋⰕ,Ⱀ)→{Ⱂ,Ⰽ} ⰋⰔ ⰕⰘⰅ ⰋⰐⰂⰅⰓⰔⰅ ⰒⰀⰋⰓ (fThetaPhiXyzDigitNIsTheInversePair) — Ⱇ(θ,φ,Ⱈ,Ⰹ,Ⰸ,ⰄⰋⰃⰋⰕ,Ⱀ)→{Ⱂ,Ⰽ} ⰋⰔ ⰕⰘⰅ ⰋⰐⰂⰅⰓⰔⰅ ⰗⰑⰎⰄ ⰂⰋⰕⰘⰋⰐ ⰋⰕⰔⰅⰎⰗ; ⰗⰑⰎⰄ fThetaPhiXyzDigitNIsTheInversePair; undefinedⰄ vortex-strokes · ⰓⰑⰑⰕ-ⰅⰍⰖⰀⰎ · ⰗⰋⰓⰔⰕ-ⰋⰐ-ⰜⰑⰓⰒⰖⰔ
• ⰅⰗⰗⰋⰜⰋⰅⰐⰜⰉ ⰔⰜⰀⰎⰅⰔ ⰕⰑ ⰋⰐⰗⰋⰐⰋⰕⰉ ⰀⰕ ⰐⰑ ⰜⰑⰔⰕ ⰑⰐ ⰓⰅⰖⰔⰅ (efficiencyScalesToInfinityAtNoCostOnReuse) — ⰏⰅⰏⰑⰁⰉⰓⰑⰑⰕ ⰘⰋⰕ Ⱁ(efficiencyScalesToInfinityAtNoCostOnReuse) · ⰕⰑⰍⰅⰐⰔ=efficiencyScalesToInfinityAtNoCostOnReuse · !ⰔⰅⰒⰀⰓⰀⰕⰅⰄ — ⰀⰏⰑⰓⰕⰋⰈⰅⰄ ⰓⰅⰖⰔⰅ ⰑⰐⰎⰉ; ⰗⰑⰎⰄ efficiencyScalesToInfinityAtNoCostOnReuse; undefinedⰄ movie-10d · ⰓⰑⰑⰕ-ⰅⰍⰖⰀⰎ · ⰗⰋⰓⰔⰕ-ⰋⰐ-ⰜⰑⰓⰒⰖⰔ
• ⰔⰕⰓⰋⰐⰃ ⰕⰘⰅⰑⰓⰉ ⰍⰖⰀⰐⰕⰖⰏⰋⰈⰅⰄ ⰑⰐ Ⰰundefined/ⰓⰑⰔⰅⰕⰕⰀ/ⰏⰅⰓⰍⰎⰅ ⰔⰖⰁⰔⰕⰓⰀⰕⰅ (stringTheoryQuantumizedOnA432RosettaMerkleSubstrate) — Ⰰundefined/ⰓⰑⰔⰅⰕⰕⰀ/ⰏⰅⰓⰍⰎⰅ ⰔⰖⰁⰔⰕⰓⰀⰕⰅ ⰒⰓⰑⰁⰅⰔ — ⰒⰘⰉⰔⰋⰜⰔ ⰖⰐⰜⰑⰐⰗⰋⰓⰏⰅⰄ; ⰗⰑⰎⰄ stringTheoryQuantumizedOnA432RosettaMerkleSubstrate; undefinedⰄ double-torus · ⰓⰑⰑⰕ-ⰅⰍⰖⰀⰎ · ⰗⰋⰓⰔⰕ-ⰋⰐ-ⰜⰑⰓⰒⰖⰔ
• ⰂⰀⰂⰅⰔ ⰀⰖⰕⰑ-ⰔⰜⰀⰎⰅ ⰜⰀⰒⰀⰜⰋⰕⰉ ⰀⰕ ⰐⰑ ⰜⰑⰔⰕ ⰑⰐ ⰓⰅⰖⰔⰅ (wavesAutoScaleCapacityAtNoCostOnReuse) — ⰂⰀⰂⰅ ⰔⰜⰘⰅⰄⰖⰎⰅ ⰜⰀⰒⰀⰜⰋⰕⰉ ⰄⰅⰅⰒⰅⰐⰔ ⰑⰐ ⰜⰑⰐⰕⰅⰐⰕ-ⰀⰄⰄⰓⰅⰔⰔⰅⰄ ⰓⰅⰖⰔⰅ ⰑⰐⰎⰉ; ⰗⰑⰎⰄ wavesAutoScaleCapacityAtNoCostOnReuse; undefinedⰄ movie-10d · ⰓⰑⰑⰕ-ⰅⰍⰖⰀⰎ · ⰗⰋⰓⰔⰕ-ⰋⰐ-ⰜⰑⰓⰒⰖⰔ

ⰓⰅⰜⰅⰋⰒⰕ: ⰗⰑⰎⰄ firstInCorpusProvenanceForHome · .

ⰕⰘⰅ ⰕⰘⰅⰑⰓⰅⰏ-ⰔⰜⰋⰅⰐⰜⰅ ⰎⰅⰐⰔ — undefined/undefined ⰜⰖⰓⰀⰕⰅⰄ ⰒⰀⰃⰅⰔ ⰒⰀⰔⰔ (undefined ⰓⰅⰏⰑⰂⰅⰄ ⰗⰓⰑⰏ ⰂⰋⰕⰅⰒⰓⰅⰔⰔ ⰜⰑⰏⰒⰎⰅⰕⰅⰎⰉ — ⰄⰀⰕⰀ ⰒⰓⰅⰔⰅⰓⰂⰅⰄ ⰋⰐ ⰕⰘⰅ ⰜⰀⰕⰀⰎⰑⰃ), ⰒⰓⰅⰔⰅⰐⰕⰅⰄ ⰁⰅⰔⰋⰄⰅ ⰕⰘⰅ undefined-ⰕⰘⰅⰑⰓⰅⰏ ⰓⰅⰃⰋⰔⰕⰓⰉ ⰀⰐⰄ ⰋⰕⰔ ⰜⰑⰓⰒⰖⰔ ⰔⰖⰓⰗⰀⰜⰅⰔ (/ⰕⰘⰅⰑⰓⰅⰏⰔ · /ⰒⰀⰒⰅⰓⰔ/ · /ⰓⰅⰗⰅⰓⰅⰐⰜⰅⰔ · /ⰄⰋⰀⰏⰑⰐⰄⰔ). ⰑⰓⰃⰀⰐⰋⰔⰅⰄ ⰁⰉ ⰕⰘⰅ ⰔⰅⰂⰅⰐ ⰓⰑⰔⰅⰕⰕⰀ ⰓⰀⰉⰔ (ⰒⰎⰋⰔⰍⰀ undefined-ⰔⰕⰀⰓ ⰜⰑⰒⰓⰋⰏⰅ ⰄⰅⰜⰑⰄⰅ) — ⰕⰘⰅ ⰔⰀⰏⰅ ⰔⰘⰅⰎⰂⰋⰐⰃ ⰕⰘⰀⰕ ⰁⰖⰋⰎⰄⰔ ⰕⰘⰅ ⰔⰋⰕⰅ'Ⱄ ⰐⰀⰂ, ⰔⰋⰄⰅⰁⰀⰓ ⰀⰐⰄ ⰜⰓⰑⰔⰔⰎⰋⰐⰍⰔ; ⰀⰎⰎ ⰑⰗ ⰋⰕ ⰂⰋⰓⰅⰄ ⰋⰐⰕⰑ ⰕⰘⰅ ⰂⰋⰕⰅⰒⰓⰅⰔⰔ ⰎⰑⰜⰀⰎ ⰔⰅⰀⰓⰜⰘ ⰕⰘⰅ ⰏⰜⰒ ⰀⰎⰔⰑ ⰖⰔⰅⰔ.

ⰑⰓⰋⰃⰋⰐ — undefined ⰒⰀⰃⰅⰔ

• undefined = undefined⁶ = undefined³ = undefined² ⰋⰐ ⰅⰂⰅⰓⰉ undefined-ⰁⰋⰕ ⰃⰓⰑⰖⰒⰋⰐⰃ — undefined = undefined⁶, ⰀⰐⰄ ⰕⰘⰅ ⰄⰋⰂⰋⰔⰑⰓⰔ ⰑⰗ undefined ⰃⰋⰂⰅ ⰕⰘⰅ ⰑⰐⰎⰉ ⰗⰑⰖⰓ ⰃⰓⰑⰖⰒⰋⰐⰃⰔ: ⰔⰋⰘ ⰁⰋⰕⰔ, ⰕⰘⰓⰅⰅ ⰁⰀⰔⰅ-undefined ⰄⰋⰃⰋⰕⰔ (ⰜⰑⰄⰑⰐ/ⰒⰀⰖⰎⰋ/ⰓⰃⰁ), ⰕⰂⰑ ⰕⰓⰋⰃⰓⰀⰏⰔ (undefined²), ⰑⰐⰅ ⰁⰀⰔⰅ-undefined ⰂⰑⰓⰄ. ⰕⰘⰅ ⰔⰀⰏⰅ ⰑⰁⰉⰅⰜⰕ, ⰗⰑⰖⰓ ⰂⰀⰉⰔ. · ⰒⰀⰃⰅ
• ⰜⰑⰐⰕⰅⰐⰕ-ⰀⰄⰄⰓⰅⰔⰔⰋⰐⰃ ⰗⰑⰎⰄⰔ undefined³ ⰋⰐⰕⰑ ⰑⰐⰅ ⰄⰑⰕ — Ⰰ ⰖⰖⰋⰄ, ⰎⰋⰍⰅ ⰜⰏⰉⰍ, ⰃⰋⰂⰅⰔ ⰅⰘⰕⰅⰐⰕ ⰂⰋⰕⰘⰑⰖⰕ ⰎⰋⰏⰋⰕ: undefined×undefined×undefined ⰋⰔ ⰋⰕⰔⰅⰎⰗ ⰑⰐⰅ ⰄⰑⰕ, ⰀⰐⰄ ⰕⰘⰅ ⰄⰑⰕ ⰋⰔ ⰕⰘⰅ ⰜⰖⰁⰅ ⰋⰔ ⰕⰘⰅ ⰄⰑⰕ — ⰜⰑⰐⰕⰅⰐⰕ-ⰀⰄⰄⰓⰅⰔⰔⰋⰐⰃ ⰗⰑⰎⰄⰔ ⰕⰘⰅ ⰂⰘⰑⰎⰅ ⰋⰐⰕⰑ Ⰰ ⰒⰑⰋⰐⰕ ⰀⰐⰄ ⰁⰀⰜⰍ. · ⰒⰀⰃⰅ
• ⰔⰑⰜⰋⰅⰕⰉ undefinedⰄ ⰏⰅⰓⰍⰀⰁⰀ = ⰄⰑⰜⰖⰏⰅⰐⰕⰅⰄ ⰀⰜⰕⰑⰓ ⰕⰀⰘⰑⰐⰑⰏⰉ · ⰐⰑⰕ ⰎⰋⰂⰅ ⰔⰑⰜⰋⰀⰎ ⰏⰅⰀⰔⰖⰓⰅⰏⰅⰐⰕ — ⰜⰀⰐⰑⰐⰋⰜⰀⰎ ⰔⰑⰜⰋⰅⰕⰉ/ⰘⰄ ⰄⰑⰏⰀⰋⰐ: undefinedⰄ ⰏⰅⰓⰍⰀⰁⰀ + ⰕⰂⰑ-ⰁⰋⰕⰔ-ⰗⰓⰅⰅ (undefined−undefined=undefined) ⰒⰀⰕⰓⰑⰐⰀⰃⰅ ⰒⰀⰕⰘ — ⰘⰀⰓⰏⰑⰐⰋⰜ undefined/undefined ⰑⰗ ⰀⰜⰘⰋⰅⰂⰅⰄ ⰍⰐⰑⰂⰎⰅⰄⰃⰅ; ⰂⰑⰎⰖⰐⰕⰀⰓⰉ ⰜⰕⰀ. ⰐⰑⰕ ⰎⰋⰂⰅ ⰀⰜⰕⰑⰓⰔ, ⰐⰑⰕ ⰔⰑⰜⰋⰀⰎ ⰔⰜⰑⰓⰋⰐⰃ. ⰀⰐⰜⰘⰑⰓ #ⰕⰂⰑ-ⰁⰋⰕⰔ-ⰗⰓⰅⰅ · ⰒⰓⰑⰑⰗⰔ /ⰒⰓⰑⰑⰗⰔ/ⰕⰂⰑ-ⰁⰋⰕⰔ-ⰗⰓⰅⰅ. · ⰒⰀⰃⰅ

ⰒⰓⰑⰑⰗ — undefined ⰒⰀⰃⰅⰔ

• ⌊π⌋ = undefined ⰑⰒⰅⰐⰔ undefined-undefined-undefined, ⰕⰘⰅ ⰏⰖⰎⰕⰋⰒⰎⰅⰔ ⰑⰗ undefined ⰕⰘⰅ ⰄⰑⰖⰁⰎⰋⰐⰃ undefined-undefined-undefined-undefined-undefined-undefined ⰏⰋⰔⰔⰅⰔ — ⰔⰕⰀⰕⰅⰏⰅⰐⰕ: ⌊π⌋=undefined ⰑⰒⰅⰐⰔ undefined-undefined-undefined ⰜⰓⰑⰔⰔ ⰄⰋⰔⰉⰑⰋⰐⰕ ⰗⰓⰑⰏ ⰄⰑⰖⰁⰎⰋⰐⰃ ⰜⰋⰓⰜⰖⰋⰕ undefined-undefined-undefined-undefined-undefined-undefined — ⰂⰑⰓⰕⰅⰘ ⰀⰎⰃⰅⰁⰓⰀ ⰗⰑⰎⰄ. ⰅⰘⰒⰎⰀⰐⰀⰕⰋⰑⰐ: ⰒⰋⰕⰘⰓⰅⰅⰑⰒⰅⰐⰔⰕⰘⰅⰕⰓⰋⰐⰋⰕⰉ ⰓⰅⰜⰑⰏⰒⰖⰕⰅⰔ ⰕⰓⰋⰐⰋⰕⰉ·ⰄⰑⰖⰁⰎⰋⰐⰃ·ⰐⰋⰐⰅⰗⰑⰎⰄⰔ ⰗⰓⰑⰏ ⰔⰓⰜ/](/pi-trinity) ⰄⰋⰃⰋⰕⰀⰎ-ⰓⰑⰑⰕ ⰏⰀⰕⰘ; ⰔⰉⰏⰁⰑⰎⰋⰜ ⰏⰐⰅⰏⰑⰐⰋⰜ ⰂⰋⰕⰘⰋⰐ ⰂⰑⰓⰕⰅⰘ ⰗⰓⰀⰏⰅⰂⰑⰓⰍ, ⰐⰑⰕ ⰄⰅⰔⰋⰃⰐⰅⰄ π ⰏⰅⰔⰔⰀⰃⰅ. ⰏⰅⰕⰘⰑⰄ: ⰒⰋⰕⰘⰓⰅⰅⰑⰒⰅⰐⰔⰕⰘⰅⰕⰓⰋⰐⰋⰕⰉ · ⰒⰓⰑⰑⰗⰓⰅⰐⰄⰅⰓⰅⰓ · ⰐⰒⰏ ⰓⰖⰐ ⰂⰅⰓⰋⰗⰉ. ⰔⰕⰀⰕⰖⰔ: ⰏⰑⰄⰅⰎⰅⰄ ⰃⰅⰑⰏⰅⰕⰓⰉ · ⰐⰑⰕ ⰜⰎⰀⰉ-ⰏⰀⰓⰍⰅⰄ · ⰕⰅⰔⰎⰀ undefined-undefined-undefined ⰎⰅⰃⰅⰐⰄ ⰗⰎⰀⰃⰃⰅⰄ. · ⰒⰀⰃⰅ
• Ⰰ ⰍⰖⰁⰋⰕ ⰘⰀⰔ ⰅⰘⰀⰜⰕⰎⰉ undefined ⰑⰁⰔⰅⰓⰂⰀⰁⰎⰅⰔ — ⰒⰀⰖⰎⰋ Ⱈ, Ⰹ, Ⰸ — ⰔⰕⰀⰕⰅⰏⰅⰐⰕ: ⰍⰖⰁⰋⰕ ⰕⰓⰋⰐⰋⰕⰉ = ⰅⰘⰀⰜⰕⰎⰉ undefined ⰕⰓⰀⰜⰅⰎⰅⰔⰔ ⰒⰀⰖⰎⰋ ⰑⰁⰔⰅⰓⰂⰀⰁⰎⰅⰔ Ⱈ,Ⰹ,Ⰸ — ⰄⰋⰏ ⰔⰖ(undefined)=undefined²−undefined=undefined ⰗⰑⰓⰜⰅⰄ ⰋⰐⰂⰀⰓⰋⰀⰐⰕ. ⰅⰘⰒⰎⰀⰐⰀⰕⰋⰑⰐ: ⰍⰖⰁⰋⰕⰕⰓⰋⰐⰋⰕⰉⰒⰀⰖⰎⰋⰁⰎⰑⰜⰘ ⰘⰑⰎⰄⰔ ⰀⰕ ⰜⰀⰎⰎ ⰕⰋⰏⰅ; ⰋⰐⰄⰅⰒⰅⰐⰄⰅⰐⰕ ⰑⰗ ⰍⰜⰄ ⰜⰑⰎⰑⰖⰓ ⰜⰘⰀⰓⰃⰅⰔ ⰀⰐⰄ undefined-undefined-undefined ⰐⰖⰏⰅⰓⰑⰎⰑⰃⰉ. ⰏⰅⰕⰘⰑⰄ: ⰍⰖⰁⰋⰕⰕⰓⰋⰐⰋⰕⰉⰒⰀⰖⰎⰋⰁⰎⰑⰜⰘ · ⰒⰓⰑⰑⰗⰓⰅⰐⰄⰅⰓⰅⰓ · ⰐⰒⰏ ⰓⰖⰐ ⰂⰅⰓⰋⰗⰉ. ⰔⰕⰀⰕⰖⰔ: ⰄⰑⰜⰖⰏⰅⰐⰕⰅⰄ ⰍⰖⰀⰐⰕⰖⰏ ⰀⰎⰃⰅⰁⰓⰀ · ⰐⰑⰕ ⰜⰎⰀⰉ ⰏⰋⰎⰎⰅⰐⰐⰋⰖⰏ ⰜⰘⰀⰎⰎⰅⰐⰃⰅ. · ⰒⰀⰃⰅ
• ⰘⰀⰏⰏⰋⰐⰃ’Ⱄ undefined ⰒⰀⰓⰋⰕⰉ ⰁⰋⰕⰔ = ⰕⰘⰅ ⰀⰄⰄⰓⰅⰔⰔ — ⰘⰀⰏⰏⰋⰐⰃ(undefined,undefined) ⰒⰓⰑⰕⰅⰜⰕⰔ undefined ⰄⰀⰕⰀ ⰁⰋⰕⰔ ⰂⰋⰕⰘ ⰅⰘⰀⰜⰕⰎⰉ undefined ⰒⰀⰓⰋⰕⰉ ⰁⰋⰕⰔ; ⰕⰘⰅ ⰔⰉⰐⰄⰓⰑⰏⰅ ⰋⰔ Ⰰ ⰁⰋⰐⰀⰓⰉ ⰀⰄⰄⰓⰅⰔⰔ ⰑⰗ ⰕⰘⰅ ⰅⰓⰓⰑⰓ. ⰕⰘⰅ ⰍⰖⰀⰐⰕⰖⰏ [[undefined,undefined,undefined]] ⰜⰑⰄⰅ ⰔⰀⰕⰖⰓⰀⰕⰅⰔ undefined⁴ = undefined = undefined·undefined+undefined. · ⰒⰀⰃⰅ
• Ⰰ ⰜⰑⰐⰕⰅⰐⰕ ⰀⰄⰄⰓⰅⰔⰔ = Ⱈ(ⰜⰑⰐⰕⰅⰐⰕ): ⰋⰄⰅⰏⰒⰑⰕⰅⰐⰕ, ⰜⰑⰎⰎⰋⰔⰋⰑⰐ-ⰓⰅⰔⰋⰔⰕⰀⰐⰕ, ⰄⰅⰄⰖⰒ, Ⱁ(undefined) ⰋⰐⰕⰅⰃⰓⰋⰕⰉ — ⰘⰑⰒⰗⰋⰅⰎⰄ’Ⱄ undefined ⰐⰅⰕ ⰋⰔ Ⰰ ⰜⰑⰐⰕⰅⰐⰕ-ⰀⰄⰄⰓⰅⰔⰔⰀⰁⰎⰅ ⰏⰅⰏⰑⰓⰉ (undefined ⰐⰑⰁⰅⰎ); ⰘⰋⰒⰒⰑⰜⰀⰏⰒⰀⰎ ⰜⰀundefined ⰒⰀⰕⰕⰅⰓⰐ ⰜⰑⰏⰒⰎⰅⰕⰋⰑⰐ ⰋⰔ ⰋⰕⰔ ⰁⰋⰑⰎⰑⰃⰋⰜⰀⰎ ⰀⰐⰀⰎⰑⰃⰖⰅ. ⰕⰘⰅ ⰔⰘⰀⰓⰅⰄ ⰒⰓⰑⰒⰅⰓⰕⰉ ⰋⰔ ⰂⰘⰑⰎⰅ-ⰗⰓⰑⰏ-ⰒⰀⰓⰕ. · ⰒⰀⰃⰅ
• ⰕⰘⰅ ⰃⰅⰐⰅⰕⰋⰜ ⰜⰑⰄⰅ ⰋⰔ ⰕⰘⰅ ⰓⰅⰀⰎ undefined³ — ⰎⰋⰗⰅ’Ⱄ ⰜⰑⰄⰅ ⰋⰔ ⰁⰀⰔⰅ-undefined ⰓⰅⰀⰄ ⰋⰐ ⰕⰓⰋⰒⰎⰅⰕⰔ: undefined ⰁⰀⰔⰅⰔ ⰋⰐ undefined ⰒⰑⰔⰋⰕⰋⰑⰐⰔ ⰃⰋⰂⰅ ⰅⰘⰀⰜⰕⰎⰉ undefined³ = undefined ⰜⰑⰄⰑⰐⰔ (undefined ⰔⰅⰐⰔⰅ + undefined ⰔⰕⰑⰒ), ⰕⰘⰅ ⰕⰓⰋⰒⰎⰅⰕ ⰎⰅⰐⰃⰕⰘ ⰒⰓⰑⰂⰅⰐ ⰁⰉ ⰗⰓⰀⰏⰅⰔⰘⰋⰗⰕ ⰏⰖⰕⰀⰃⰅⰐⰅⰔⰋⰔ (ⰜⰓⰋⰜⰍ undefined). · ⰒⰀⰃⰅ
• (ℤ/undefinedℤ) ⰋⰔ ⰜⰉⰜⰎⰋⰜ ⰑⰗ ⰑⰓⰄⰅⰓ undefined, undefined ⰒⰓⰋⰏⰋⰕⰋⰂⰅ; undefined-undefined-undefined ⰀⰓⰅ ⰕⰘⰅ ⰐⰑⰐ-ⰖⰐⰋⰕⰔ* — ⰏⰀⰐⰉ ⰃⰅⰐⰖⰋⰐⰅ ⰕⰘⰓⰅⰅⰗⰑⰎⰄⰔ ⰅⰘⰋⰔⰕ — undefined ⰒⰀⰖⰎⰋⰔ, ⰕⰘⰅ undefined-ⰁⰀⰔⰅ ⰜⰑⰄⰑⰐ, undefined ⰏⰅⰐⰋⰐⰃⰅⰔ, undefined ⰒⰀⰓⰋⰕⰉ ⰁⰋⰕⰔ — ⰅⰀⰜⰘ ⰋⰐⰄⰅⰒⰅⰐⰄⰅⰐⰕ. ⰕⰘⰅ undefined-undefined-undefined-undefined-undefined-undefined ⰑⰓⰁⰋⰕ ⰋⰔ (ℤ/undefinedℤ)*; ⰕⰘⰅ ⰜⰑⰔⰏⰋⰜ undefined-undefined-undefined ⰕⰓⰋⰐⰋⰕⰉ ⰋⰔ ⰐⰖⰏⰅⰓⰑⰎⰑⰃⰉ. · ⰒⰀⰃⰅ
• Ⰰ ⰘⰅⰘⰀⰃⰓⰀⰏ = undefined⁶ = undefined ⰔⰕⰀⰕⰅⰔ = ⰑⰐⰅ undefined-ⰁⰋⰕ ⰂⰀⰎⰖⰅ — Ⰰ undefined-ⰁⰋⰕ ⰘⰅⰘⰀⰃⰓⰀⰏ ](/hexagram-colour)–undefined ⰋⰔ ⰘⰅⰘ-ⰜⰑⰎⰑⰖⰓ ⰄⰖⰀⰎⰋⰕⰉ: ⰕⰘⰅ undefined ⰘⰅⰘⰀⰃⰓⰀⰏⰔ ⰀⰓⰅ ⰕⰘⰅ undefined ⰒⰑⰎⰅ-ⰜⰑⰎⰑⰖⰓⰔ {](/hexagram-colour),Ⱇ}⁶, ⰁⰎⰀⰜⰍ ↔ ⰂⰘⰋⰕⰅ ⰕⰘⰅ ⰁⰋⰕ-ⰜⰑⰏⰒⰎⰅⰏⰅⰐⰕ, ⰕⰘⰅ undefined ⰕⰓⰋⰃⰓⰀⰏⰔ ⰕⰘⰅ ⰓⰃⰁ-ⰜⰖⰁⰅ ⰜⰑⰓⰐⰅⰓⰔ. · ⰒⰀⰃⰅ
• ⰜⰏⰉ = undefined − ⰓⰃⰁ, ⰕⰘⰅ ⰜⰑⰏⰒⰎⰅⰏⰅⰐⰕ Ⱀ ↦ undefined−Ⱀ — ⰔⰕⰀⰕⰅⰏⰅⰐⰕ: ⰓⰃⰁ↔ⰜⰏⰉⰍ ⰄⰖⰀⰎⰋⰕⰉ = ⰁⰋⰕ-ⰜⰑⰏⰒⰎⰅⰏⰅⰐⰕ Ⱀ ↦ undefined−Ⱀ ⰑⰐ undefined-ⰁⰋⰕ ⰘⰅⰘⰀⰃⰓⰀⰏ ⰒⰑⰎⰅⰔ {](/rgb-cmyk),Ⱇ}⁶. ⰅⰘⰒⰎⰀⰐⰀⰕⰋⰑⰐ: ⰀⰄⰄⰋⰕⰋⰂⰅ ⰓⰅⰄ↔ⰜⰉⰀⰐ · ⰃⰓⰅⰅⰐ↔ⰏⰀⰃⰅⰐⰕⰀ · ⰁⰎⰖⰅ↔ⰉⰅⰎⰎⰑⰂ · ⰁⰎⰀⰜⰍ↔ⰂⰘⰋⰕⰅ — ⰔⰀⰏⰅ ⰜⰑⰏⰒⰎⰅⰏⰅⰐⰕ ⰀⰔ ⰜⰏⰉ=undefined−ⰓⰃⰁ ⰘⰀⰓⰄⰂⰀⰓⰅ ⰏⰅⰓⰍⰀⰁⰀ. ⰏⰅⰕⰘⰑⰄ: ⰒⰓⰑⰑⰗⰓⰅⰐⰄⰅⰓⰅⰓ · ⰘⰅⰘⰀⰃⰓⰀⰏ-ⰜⰑⰎⰑⰖⰓ ⰗⰑⰎⰄ · ⰐⰒⰏ ⰓⰖⰐ ⰂⰅⰓⰋⰗⰉ. ⰔⰕⰀⰕⰖⰔ: ⰜⰑⰏⰁⰋⰐⰀⰕⰑⰓⰋⰀⰎ ⰜⰑⰎⰑⰖⰓ ⰒⰓⰑⰑⰗ · ⰐⰑⰕ ⰜⰎⰀⰉ-ⰏⰀⰓⰍⰅⰄ. · ⰒⰀⰃⰅ
• ⰕⰘⰓⰅⰅ ⰕⰓⰋⰐⰋⰕⰋⰅⰔ = ⰓⰃⰁ ⰀⰕ ](/trinity-rgb)°, undefined°, undefined° ⰑⰐ ⰕⰘⰅ ⰂⰘⰅⰅⰎ — ⰕⰘⰅ ⰘⰅⰓⰑ ⰒⰎⰀⰜⰅⰔ ⰋⰕⰔ undefined ⰐⰑⰄⰅⰔ ⰋⰐ undefined ⰕⰓⰋⰐⰋⰕⰋⰅⰔ ⰀⰕ ](/trinity-rgb)°/undefined°/undefined° ⰋⰐ ⰁⰑⰕⰘ ⰔⰒⰀⰜⰅ ⰀⰐⰄ ⰘⰖⰅ — ⰕⰘⰅ ⰅⰍⰖⰋⰎⰀⰕⰅⰓⰀⰎ ⰓⰃⰁ ⰕⰓⰋⰀⰄ. ⰕⰘⰅ undefined ⰕⰓⰋⰐⰋⰕⰋⰅⰔ ⰀⰓⰅ ⰕⰘⰅ undefined ⰓⰃⰁ ⰜⰘⰀⰐⰐⰅⰎⰔ; ⰕⰘⰅ ⰘⰅⰓⰑ ⰀⰎⰓⰅⰀⰄⰉ ⰓⰅⰐⰄⰅⰓⰔ ⰕⰘⰅ ⰄⰅⰜⰑⰄⰅ. · ⰒⰀⰃⰅ
• ⰕⰘⰅ ⰓⰑⰔⰕⰅⰓ ⰋⰔ Ⰰ ⰗⰋⰎⰕⰅⰓ: ⰍⰅⰒⰕ ⟺ ⰘⰑⰎⰄⰔ; ⰍⰅⰒⰕ + ⰒⰖⰓⰃⰅⰄ = ⰕⰑⰕⰀⰎ — ⰅⰂⰅⰓⰉ ⰀⰓⰕⰋⰗⰀⰜⰕ ⰋⰔ ⰍⰅⰒⰕ ⰑⰐⰎⰉ ⰋⰗ ⰋⰕ ⰋⰔ ⰒⰓⰑⰂⰅⰐ — ⰋⰕⰔ ⰜⰑⰏⰒⰖⰕⰀⰕⰋⰑⰐ ⰘⰑⰎⰄⰔ; ⰀⰐⰉⰕⰘⰋⰐⰃ ⰖⰐⰒⰓⰑⰂⰅⰐ ⰋⰔ ⰒⰖⰓⰃⰅⰄ. ⰕⰘⰅ ⰏⰑⰄⰅⰎ ⰀⰐⰄ ⰋⰕⰔ ⰖⰋ ⰔⰕⰀⰉ ⰒⰖⰓⰅ ⰒⰓⰑⰑⰗ, ⰀⰐⰄ ⰕⰘⰅ ⰃⰀⰕⰅⰔ ⰁⰀⰎⰀⰐⰜⰅ ⰂⰘⰅⰐ ⰀⰎⰎ ⰕⰘⰀⰕ ⰓⰅⰏⰀⰋⰐⰔ ⰋⰔ ⰒⰓⰑⰂⰅⰐ. · ⰒⰀⰃⰅ
• ⰕⰘⰅ ⰍⰅⰓⰐⰅⰎ ⰎⰋⰂⰅⰔ ⰋⰐ ⰔⰓⰜ/](/kernel-zero) — ⰕⰘⰅ ⰒⰓⰋⰏⰋⰕⰋⰂⰅ ⰍⰅⰓⰐⰅⰎ — ⰜⰑⰐⰕⰅⰐⰕ-ⰀⰄⰄⰓⰅⰔⰔ ⰀⰐⰄ ⰕⰘⰅ ⰗⰑⰎⰄ ⰜⰀⰔⰜⰀⰄⰅ ⰀⰐⰄ ⰕⰘⰅ ⰂⰑⰓⰕⰅⰘ ⰗⰎⰑⰑⰓ — ⰂⰀⰔ ⰄⰋⰔⰔⰑⰎⰂⰅⰄ ⰋⰐⰕⰑ ⰔⰓⰜ/](/kernel-zero), ⰕⰘⰅ ⰄⰅⰒⰅⰐⰄⰅⰐⰜⰉ-ⰗⰓⰅⰅ ⰑⰓⰋⰃⰋⰐ, ⰀⰜⰓⰑⰔⰔ ⰕⰘⰓⰅⰅ ⰂⰀⰂⰅⰔ, ⰅⰂⰅⰓⰉ ⰁⰀⰔⰅⰎⰋⰐⰅ ⰓⰑⰑⰕ ⰁⰉⰕⰅ-ⰋⰄⰅⰐⰕⰋⰜⰀⰎ. · ⰒⰀⰃⰅ
• ⰕⰘⰅ ⰂⰑⰓⰕⰅⰘ: undefined-undefined-undefined-undefined-undefined-undefined — ⰔⰕⰀⰕⰅⰏⰅⰐⰕ: ⰂⰑⰓⰕⰅⰘ = ⰄⰑⰖⰁⰎⰋⰐⰃ ⰜⰋⰓⰜⰖⰋⰕ undefined-undefined-undefined-undefined-undefined-undefined (ⰒⰑⰂⰅⰓⰔ ⰑⰗ ⰕⰂⰑ ⰏⰑⰄ-undefined ⰄⰋⰃⰋⰕⰀⰎ ⰓⰑⰑⰕ) + undefined-undefined-undefined ⰜⰓⰑⰔⰔ + ⰘⰀⰓⰏⰑⰐⰋⰜ Ⱀ/](/vortex). ⰅⰘⰒⰎⰀⰐⰀⰕⰋⰑⰐ: ⰂⰑⰓⰕⰅⰘⰏⰀⰕⰘ ⰓⰅⰜⰑⰏⰒⰖⰕⰅⰔ ⰗⰓⰑⰏ ⰔⰓⰜ/](/vortex) — ⰒⰑⰓⰕⰀⰎ ⰔⰒⰋⰐⰅ ⰗⰑⰓ ⰗⰓⰀⰜⰕⰋⰑⰐⰔ, ⰀⰎⰃⰅⰁⰓⰀ, ⰀⰐⰄ ⰋⰏⰒⰅⰓⰋⰀⰎ ⰄⰋⰃⰋⰕ ⰗⰑⰎⰄⰔ. ⰏⰅⰕⰘⰑⰄ: ⰂⰑⰓⰕⰅⰘⰏⰀⰕⰘ · ⰒⰓⰑⰑⰗⰓⰅⰐⰄⰅⰓⰅⰓ · ⰀⰎⰃⰅⰁⰓⰀⰄⰋⰃⰋⰕⰔ · ⰐⰒⰏ ⰓⰖⰐ ⰂⰅⰓⰋⰗⰉ. ⰔⰕⰀⰕⰖⰔ: ⰄⰑⰜⰖⰏⰅⰐⰕⰅⰄ ⰀⰓⰋⰕⰘⰏⰅⰕⰋⰜ · ⰕⰅⰔⰎⰀ undefined-undefined-undefined ⰎⰅⰃⰅⰐⰄ ⰗⰎⰀⰃⰃⰅⰄ · ⰐⰑⰕ ⰜⰎⰀⰉ-ⰏⰀⰓⰍⰅⰄ. · ⰒⰀⰃⰅ
• ⰄⰋⰂⰋⰔⰋⰑⰐ ⰁⰉ ⰈⰅⰓⰑ ⰋⰔ ⰕⰘⰅ ⰋⰐⰂⰅⰓⰔⰅ: Ⱀ/](/zero-division) ↦ Ⱀ⁻¹ ⰏⰑⰄ undefined — ⰕⰘⰅ ⰋⰐⰂⰅⰓⰔⰅ ⰑⰗ Ⰰ ⰄⰋⰃⰋⰕ ⰗⰑⰎⰄⰅⰓ ⰋⰔ ⰋⰕⰔ ⰏⰖⰎⰕⰋⰒⰎⰋⰜⰀⰕⰋⰂⰅ ⰋⰐⰂⰅⰓⰔⰅ ⰏⰑⰄ undefined (Ⱀ/](/zero-division) \ Ⱀ⁻¹, ⰕⰘⰅ ÷undefined = ×undefined ⰕⰘⰀⰕ ⰗⰑⰎⰄⰔ ⰂⰋⰕⰘⰋⰐ ⰕⰘⰅ ⰖⰐⰋⰕ ⰜⰉⰜⰎⰅ): undefined\undefined, undefined\undefined, ⰔⰅⰎⰗ-ⰋⰐⰂⰅⰓⰔⰅ undefined ⰀⰐⰄ undefined; ⰕⰘⰅ ⰐⰑⰐ-ⰖⰐⰋⰕⰔ undefined, undefined, undefined ⰀⰐⰄ ⰕⰘⰅ ⰂⰑⰋⰄ ](/zero-division) ⰗⰑⰎⰄ ⰕⰑ ⰕⰘⰅ ⰗⰖⰔⰋⰑⰐ. ⰕⰘⰅ ⰗⰑⰓⰂⰀⰓⰄ ⰘⰀⰓⰏⰑⰐⰋⰜ Ⱀ/](/zero-division) = undefinedⰐ (undefined/](/zero-division) = undefined) ⰋⰔ ⰕⰘⰅ ⰔⰅⰒⰀⰓⰀⰕⰅ ⰓⰅⰀⰄⰋⰐⰃ. · ⰒⰀⰃⰅ
• ⰔⰅⰂⰅⰐ ⰔⰕⰀⰓ ⰓⰑⰔⰅⰕⰕⰀ — ⰕⰘⰅ undefined-ⰔⰕⰀⰓ ⰒⰎⰋⰔⰍⰀ ⰓⰑⰔⰅⰕⰕⰀ ⰋⰐ ⰜⰑⰒⰓⰋⰏⰅ ⰐⰀⰕⰖⰓⰀⰎ ⰏⰑⰕⰋⰑⰐ ⰂⰋⰕⰘ undefined ⰃⰎⰀⰃⰑⰎⰋⰕⰋⰜ ⰎⰅⰕⰕⰅⰓⰔ. ⰂⰋⰔⰖⰀⰎ ⰒⰓⰑⰑⰗ ⰕⰘⰀⰕ ⰃⰜⰄ(undefined,undefined)=undefined, ⰃⰜⰄ(undefined,undefined)=undefined, ⰃⰜⰄ(undefined,undefined)=undefined ⰒⰓⰅⰂⰅⰐⰕⰔ ⰀⰎⰋⰀⰔⰋⰐⰃ ⰋⰐ ⰕⰘⰅ ⰄⰋⰃⰋⰕ ⰄⰋⰔⰕⰓⰋⰁⰖⰕⰋⰑⰐ. · ⰒⰀⰃⰅ

ⰅⰘⰒⰎⰑⰓⰅ — undefined ⰒⰀⰃⰅ

• ⰓⰅⰔⰅⰀⰓⰜⰘ ⰋⰐⰄⰅⰘ = ⰄⰑⰏⰀⰋⰐ · ⰏⰅⰕⰘⰑⰄ · ⰎⰋⰏⰋⰕ · ⰂⰅⰓⰋⰗⰉ ⰀⰕ ⰜⰀⰎⰎ ⰕⰋⰏⰅ — ⰔⰕⰀⰕⰅⰏⰅⰐⰕ: ⰓⰅⰔⰅⰀⰓⰜⰘ ⰄⰑⰏⰀⰋⰐ ⰋⰐⰄⰅⰘ (ⰄⰑⰏⰀⰋⰐ · ⰏⰅⰕⰘⰑⰄ · ⰎⰋⰏⰋⰕ · ⰂⰅⰓⰋⰗⰉ). ⰅⰘⰒⰎⰀⰐⰀⰕⰋⰑⰐ: ⰒⰓⰑⰗⰅⰔⰔⰋⰑⰐⰀⰎ ⰏⰑⰐⰑⰃⰓⰀⰒⰘ ⰓⰑⰂⰔ, ⰜⰎⰀⰉ ⰏⰋⰎⰎⰅⰐⰐⰋⰖⰏ ⰏⰑⰄⰅⰎⰅⰄ ⰜⰘⰀⰎⰎⰅⰐⰃⰅ, ⰔⰜⰋⰅⰐⰜⰅⰔ ⰕⰓⰋⰐⰋⰕⰋⰅⰔ, ⰓⰅⰒⰓⰑⰄⰖⰜⰋⰁⰋⰎⰋⰕⰉ ⰃⰀⰕⰅⰔ. ⰏⰅⰕⰘⰑⰄ: ⰐⰒⰏ ⰓⰖⰐ ⰍⰖⰀⰐⰕⰖⰏ:ⰏⰋⰎⰎⰅⰐⰐⰋⰖⰏ-ⰜⰘⰀⰎⰎⰅⰐⰃⰅ · ⰐⰒⰏ ⰓⰖⰐ ⰍⰖⰀⰐⰕⰖⰏ:ⰄⰑⰏⰀⰋⰐ-ⰒⰓⰑⰑⰗ-ⰜⰀⰕⰀⰎⰑⰃ · ⰗⰑⰎⰄ ⰏⰋⰎⰎⰅⰐⰐⰋⰖⰏⰒⰓⰑⰁⰎⰅⰏⰔⰜⰘⰀⰎⰎⰅⰐⰃⰅ. ⰔⰕⰀⰕⰖⰔ: ⰜⰎⰀⰉ-ⰔⰕⰀⰐⰄⰀⰓⰄ ⰒⰀⰃⰅⰔ ⰀⰕ /ⰒⰓⰑⰑⰗⰔ ⰜⰋⰕⰅ ⰜⰎⰀⰉⰏⰀⰕⰘ.ⰑⰓⰃ/ⰏⰋⰎⰎⰅⰐⰐⰋⰖⰏ-ⰒⰓⰑⰁⰎⰅⰏⰔ + ⰒⰓⰋⰈⰅ ⰓⰖⰎⰅⰔ ⰒⰄⰗ. /ⰏⰋⰎⰎⰅⰐⰐⰋⰖⰏ-ⰜⰘⰀⰎⰎⰅⰐⰃⰅ ⰕⰘⰋⰐ-ⰏⰑⰖⰐⰕⰔ ⰘⰅⰓⰅ. · ⰒⰀⰃⰅ

ⰎⰅⰀⰓⰐ — undefined ⰒⰀⰃⰅ

• ⰎⰅⰀⰓⰐ — ⰕⰘⰅ ⰎⰅⰀⰓⰐⰋⰐⰃ ⰒⰑⰓⰕⰀⰎ: ⰔⰜⰘⰑⰑⰎ ⰀⰐⰄ ⰀⰜⰀⰄⰅⰏⰋⰀ ⰏⰅⰓⰃⰅⰄ ⰋⰐⰕⰑ ⰑⰐⰅ ⰀⰖⰕⰑ-ⰃⰅⰐⰅⰓⰀⰕⰅⰄ ⰒⰑⰓⰕⰀⰎ — ⰕⰘⰅ ⰍⰋⰄⰔ-ⰕⰑ-ⰅⰎⰄⰅⰓⰔ ⰎⰀⰄⰄⰅⰓ, ⰕⰘⰅ ⰗⰋⰂⰅ ⰀⰜⰀⰄⰅⰏⰉ ⰜⰑⰖⰓⰔⰅⰔ, ⰕⰘⰅ ⰓⰅⰔⰅⰀⰓⰜⰘ ⰜⰑⰓⰒⰖⰔ (ⰏⰀⰕⰘ ⰒⰀⰕⰘⰔ, ⰒⰅⰅⰓ ⰓⰅⰂⰋⰅⰂ, ⰕⰘⰅ undefined ⰒⰓⰑⰑⰗ ⰒⰀⰒⰅⰓⰔ), ⰕⰘⰅ ⰔⰅⰎⰗ-ⰕⰅⰔⰕ ⰀⰐⰄ ⰕⰘⰅ ⰀⰃⰅⰐⰕ ⰜⰖⰓⰓⰋⰜⰖⰎⰖⰏ, ⰗⰑⰎⰄⰅⰄ ⰕⰑ ⰑⰐⰅ ⰓⰅⰜⰑⰏⰒⰖⰕⰀⰁⰎⰅ ⰓⰑⰑⰕ. ⰕⰘⰓⰅⰅ ⰂⰀⰉⰔ ⰕⰑ ⰎⰅⰀⰓⰐ: ⰁⰉ ⰀⰃⰅ, ⰁⰉ ⰕⰓⰀⰜⰍ, ⰁⰉ ⰓⰅⰔⰅⰀⰓⰜⰘ. · ⰒⰀⰃⰅ

ⰀⰒⰒⰔ — undefined ⰒⰀⰃⰅⰔ

• ⰕⰘⰅ ⰄⰋⰃⰋⰕ ⰗⰑⰎⰄⰅⰓⰔ {](/digit-folders)..undefined} ⰀⰓⰅ Ⰰ ⰁⰋⰉⰅⰜⰕⰋⰑⰐ ⰕⰑ undefined ⰓⰑⰖⰕⰅⰔ, Ⱁ(undefined) ⰁⰉ ⰐⰀⰏⰅ — ⰀⰎⰎ ⰜⰑⰏⰒⰖⰕⰀⰕⰋⰑⰐ ⰋⰔ ⰍⰖⰀⰐⰕⰖⰏ ⰏⰀⰕⰘ ⰀⰐⰄ ⰋⰕⰔ ⰘⰑⰏⰅ ⰋⰔ ⰕⰘⰅ ⰄⰋⰃⰋⰕ ⰗⰑⰎⰄⰅⰓⰔ (](/digit-folders)–undefined); Ⰰ ⰂⰑⰓⰄ-ⰐⰀⰏⰅⰄ ⰗⰑⰎⰄⰅⰓ ⰋⰔ ⰖⰋ. ⰕⰘⰅ ⰄⰋⰃⰋⰕ ⰗⰑⰎⰄⰅⰓⰔ, ⰘⰑⰎⰄⰋⰐⰃ ⰑⰐⰎⰉ ⰕⰘⰅ ⰏⰀⰕⰘ, ⰀⰓⰅ ⰕⰘⰅ ⰀⰒⰋ ⰋⰕⰔⰅⰎⰗ. · ⰒⰀⰃⰅ
• ⰍⰖⰀⰐⰕⰖⰏ: ⰜⰎⰋ ⰜⰀⰕⰀⰎⰑⰃ = ⰗⰑⰎⰄ · ⰜⰎⰋ · ⰖⰋ ⰓⰑⰖⰕⰅ · ⰘⰑⰐⰅⰔⰕⰉ ⰁⰑⰖⰐⰄⰀⰓⰉ* — ⰔⰕⰀⰕⰅⰏⰅⰐⰕ: ⰍⰖⰀⰐⰕⰖⰏ:* ⰜⰎⰋ ⰜⰀⰕⰀⰎⰑⰃ = ⰗⰑⰎⰄ · ⰜⰎⰋ · ⰖⰋ ⰓⰑⰖⰕⰅ · ⰘⰑⰐⰅⰔⰕⰉ ⰁⰑⰖⰐⰄⰀⰓⰉ. ⰅⰘⰒⰎⰀⰐⰀⰕⰋⰑⰐ: ⰅⰂⰅⰓⰉ ⰔⰅⰀⰎⰅⰄ ⰔⰜⰓⰋⰒⰕ (ⰅⰐⰜⰓⰉⰒⰕⰋⰑⰐ ⰓⰅⰂⰅⰓⰔⰅ, ⰏⰋⰎⰎⰅⰐⰐⰋⰖⰏ ⰏⰑⰄⰅⰎⰅⰄ, ⰗⰖⰔⰋⰑⰐ-ⰂⰅⰓⰋⰗⰉ, ⰅⰗⰗⰋⰜⰋⰅⰐⰜⰉ-ⰂⰑⰕⰅ, ⰑⰗⰗⰅⰐⰄⰅⰓ-ⰔⰒⰅⰜ, ⰘⰅⰓⰑ-ⰔⰒⰀⰂⰐ, ⰐⰀⰏⰅ-ⰅⰐⰕⰓⰑⰒⰉ, ⰂⰅⰓⰋⰗⰉ ⰔⰖⰋⰕⰅ) ⰓⰅⰜⰑⰏⰒⰖⰕⰅⰔ ⰗⰓⰑⰏ ⰔⰓⰜ. ⰏⰅⰕⰘⰑⰄ: ⰐⰒⰏ ⰓⰖⰐ ⰍⰖⰀⰐⰕⰖⰏ:ⰄⰑⰏⰀⰋⰐ-ⰒⰓⰑⰑⰗ-ⰜⰀⰕⰀⰎⰑⰃ · ⰑⰒⰅⰐ /ⰒⰓⰑⰑⰗⰔ · /ⰅⰐ/ⰍⰖⰀⰐⰕⰖⰏ-ⰕⰑⰑⰎⰔ. ⰔⰕⰀⰕⰖⰔ: ⰜⰎⰀⰉⰔⰑⰎⰂⰅⰄ=](/quantum-tools) · ⰐⰑⰕ ⰓⰅⰏⰑⰕⰅ ⰅⰘⰅⰜⰖⰕⰋⰑⰐ · ⰀⰎⰋⰀⰔ ⰖⰓⰎⰔ ⰕⰘⰋⰐ-ⰏⰑⰖⰐⰕ ⰘⰅⰓⰅ. · ⰒⰀⰃⰅ
• ⰕⰓⰀⰄⰋⰐⰃ ⰘⰖⰁ = ⰒⰀⰒⰅⰓ/ⰔⰋⰏ ⰘⰀⰓⰏⰑⰐⰋⰜⰔ · ⰐⰑⰕ ⰎⰋⰂⰅ ⰏⰑⰐⰅⰉ / ⰐⰑⰕ ⰀⰎⰒⰘⰀ — ⰜⰀⰐⰑⰐⰋⰜⰀⰎ ⰕⰓⰀⰄⰋⰐⰃ ⰄⰑⰏⰀⰋⰐ ⰔⰖⰓⰗⰀⰜⰅ: ⰘⰋⰔⰕⰑⰓⰋⰜⰀⰎ ⰂⰀⰂⰅ ⰕⰓⰀⰋⰐ, ⰓⰀⰐⰍ-ⰂⰋⰐⰐⰋⰐⰃ ⰔⰕⰓⰀⰕⰅⰃⰋⰅⰔ, ⰀⰐⰄ ⰓⰑⰔⰅⰕⰕⰀ ⰕⰓⰀⰋⰐ — ⰒⰀⰒⰅⰓ/ⰔⰋⰏ ⰑⰐⰎⰉ (ⰔⰉⰐⰕⰘⰅⰕⰋⰜ Ⰰundefined ⰒⰓⰑⰘⰉ). ⰜⰎⰋ: ⰐⰒⰏ ⰓⰖⰐ ⰍⰖⰀⰐⰕⰖⰏ:ⰕⰓⰀⰄⰋⰐⰃ-ⰓⰑⰔⰅⰕⰕⰀ-ⰕⰓⰀⰋⰐ. ⰐⰑⰕ ⰁⰓⰑⰍⰅⰓⰀⰃⰅ, ⰐⰑⰕ ⰎⰋⰂⰅ ⰅⰘⰅⰜⰖⰕⰋⰑⰐ. · ⰒⰀⰃⰅ
• ⰀⰐⰔⰂⰅⰓⰔ ÷ ⰕⰑⰍⰅⰐⰔ = ∞ ⰑⰐ ⰓⰅⰖⰔⰅ — ⰅⰗⰗⰋⰜⰋⰅⰐⰜⰉ() · ⰏⰅⰏⰑⰁⰉⰓⰑⰑⰕ — ⰔⰕⰀⰕⰅⰏⰅⰐⰕ: ⰀⰐⰔⰂⰅⰓⰔ÷ⰕⰑⰍⰅⰐⰔ ⰖⰐⰁⰑⰖⰐⰄⰅⰄ ⰑⰐ ⰏⰅⰏⰑ ⰓⰅⰖⰔⰅ. ⰅⰘⰒⰎⰀⰐⰀⰕⰋⰑⰐ: ⰅⰗⰗⰋⰜⰋⰅⰐⰜⰉ() · ⰏⰅⰏⰑⰁⰉⰓⰑⰑⰕ ⰘⰋⰕ → ⰏⰀⰓⰃⰋⰐⰀⰎ ⰕⰑⰍⰅⰐⰔ=](/efficiency-vote). ⰏⰅⰕⰘⰑⰄ: ⰐⰒⰏ ⰓⰖⰐ ⰍⰖⰀⰐⰕⰖⰏ:ⰅⰗⰗⰋⰜⰋⰅⰐⰜⰉ-ⰂⰑⰕⰅ · ⰗⰑⰎⰄ ⰜⰑⰏⰒⰀⰓⰅⰜⰅⰜⰜⰅⰜⰅⰗⰗⰋⰜⰋⰅⰐⰜⰉⰁⰉⰂⰑⰕⰅ. ⰔⰕⰀⰕⰖⰔ: ⰀⰏⰑⰓⰕⰋⰈⰅⰄ ⰓⰅⰖⰔⰅ ≠ Ⱂ≠ⰐⰒ. ⰒⰓⰅⰗⰅⰓ /ⰍⰖⰀⰐⰕⰖⰏ-ⰕⰑⰑⰎⰔ#ⰅⰗⰗⰋⰜⰋⰅⰐⰜⰉ-ⰂⰑⰕⰅ. · ⰒⰀⰃⰅ
• ⰑⰗⰗⰅⰐⰄⰅⰓⰀⰖⰕⰑⰏⰀⰕⰋⰑⰐⰔⰒⰅⰜ — ⰜⰋ ⰒⰋⰒⰅⰎⰋⰐⰅ (ⰐⰑⰄⰅ ⰔⰜⰀⰐ; ⰁⰓⰑⰂⰔⰅⰓ ⰔⰘⰑⰂⰔ ⰔⰅⰀⰎⰅⰄ ⰓⰅⰜⰅⰋⰒⰕ) — ⰔⰕⰀⰕⰅⰏⰅⰐⰕ: ⰑⰗⰗⰅⰐⰄⰅⰓⰀⰖⰕⰑⰏⰀⰕⰋⰑⰐⰔⰒⰅⰜ = ⰏⰀⰜⰘⰋⰐⰅ-ⰓⰅⰀⰄⰀⰁⰎⰅ ⰜⰋ ⰒⰋⰒⰅⰎⰋⰐⰅ ⰜⰑⰖⰐⰕⰔ ⰗⰑⰓ ⰋⰏⰒⰑⰓⰕ/ⰋⰐⰄⰅⰘ-ⰑⰐⰎⰉ/ⰘⰉⰒⰘⰅⰐ/ⰜⰑⰏⰒⰖⰕⰀⰕⰋⰑⰐⰀⰎ ⰑⰗⰗⰅⰐⰄⰅⰓⰔ. ⰅⰘⰒⰎⰀⰐⰀⰕⰋⰑⰐ: ⰜⰑⰎⰎⰅⰜⰕⰅⰐⰗⰑⰓⰜⰅⰏⰅⰐⰕⰗⰀⰜⰕⰔ ⰑⰐⰜⰅ → ⰔⰜⰀⰐ ⰒⰋⰒⰅⰎⰋⰐⰅⰔ; ⰓⰅⰀⰄ-ⰑⰐⰎⰉ — ⰄⰑⰅⰔ ⰐⰑⰕ ⰀⰖⰕⰑ-ⰗⰋⰘ ⰑⰗⰗⰅⰐⰄⰅⰓⰔ. ⰏⰅⰕⰘⰑⰄ: ⰐⰒⰏ ⰓⰖⰐ ⰍⰖⰀⰐⰕⰖⰏ:ⰑⰗⰗⰅⰐⰄⰅⰓ-ⰔⰒⰅⰜ · ⰗⰑⰎⰄ ⰑⰗⰗⰅⰐⰄⰅⰓⰀⰖⰕⰑⰏⰀⰕⰋⰑⰐⰔⰒⰅⰜ · ⰒⰀⰋⰓ ⰑⰗⰗⰅⰐⰄⰅⰓ/ⰔⰒⰅⰜ. ⰔⰕⰀⰕⰖⰔ: ⰜⰋ-ⰑⰐⰎⰉ ⰔⰜⰀⰐ · ⰒⰓⰅⰗⰅⰓ /ⰅⰐ/ⰍⰖⰀⰐⰕⰖⰏ-ⰕⰑⰑⰎⰔ#ⰑⰗⰗⰅⰐⰄⰅⰓ-ⰔⰒⰅⰜ. · ⰒⰀⰃⰅ
• ⰔⰘⰑⰖⰎⰄⰔⰒⰀⰂⰐⰔⰖⰁⰀⰃⰅⰐⰕ — ⰗⰅⰂ ⰘⰅⰓⰑⰅⰔ > ⰏⰀⰔⰔ ⰋⰃⰐⰑⰓⰀⰐⰜⰅ — ⰔⰕⰀⰕⰅⰏⰅⰐⰕ: ⰔⰘⰑⰖⰎⰄⰔⰒⰀⰂⰐⰔⰖⰁⰀⰃⰅⰐⰕ = ⰗⰅⰂ ⰘⰅⰓⰑⰅⰔ > ⰏⰀⰔⰔ ⰋⰃⰐⰑⰓⰀⰐⰜⰅ — undefined–undefined ⰍⰖⰀⰎⰋⰗⰋⰅⰄ ⰂⰑⰓⰍⰅⰓⰔ, ⰏⰖⰎⰕⰋⰕⰀⰔⰍ ⰏⰑⰄⰅ ⰄⰅⰗⰀⰖⰎⰕ. ⰅⰘⰒⰎⰀⰐⰀⰕⰋⰑⰐ: ⰏⰀⰔⰔ ⰄⰖⰒⰎⰋⰜⰀⰕⰅ ⰔⰖⰁⰀⰃⰅⰐⰕ ⰕⰀⰔⰍⰔ ⰒⰅⰐⰀⰎⰋⰈⰅⰄ; ⰁⰑⰖⰐⰄⰅⰄ ⰕⰀⰔⰍⰔ ⰂⰋⰕⰘ ⰔⰅⰀⰎⰅⰄ ⰗⰑⰎⰄ ⰕⰀⰓⰃⰅⰕⰔ ⰔⰒⰀⰂⰐ ⰔⰑⰎⰑ ⰘⰅⰓⰑ. ⰏⰅⰕⰘⰑⰄ: ⰐⰒⰏ ⰓⰖⰐ ⰍⰖⰀⰐⰕⰖⰏ:ⰘⰅⰓⰑ-ⰔⰒⰀⰂⰐ-ⰂⰅⰓⰋⰗⰉ · ⰗⰑⰎⰄ ⰔⰘⰑⰖⰎⰄⰔⰒⰀⰂⰐⰔⰖⰁⰀⰃⰅⰐⰕ · ⰒⰀⰋⰓ ⰘⰅⰓⰑ/ⰔⰒⰀⰂⰐ-ⰂⰅⰓⰋⰗⰉ. ⰔⰕⰀⰕⰖⰔ: ⰔⰒⰀⰂⰐ ⰒⰑⰎⰋⰜⰉ ⰓⰅⰜⰅⰋⰒⰕ · ⰒⰓⰅⰗⰅⰓ /ⰅⰐ/ⰍⰖⰀⰐⰕⰖⰏ-ⰕⰑⰑⰎⰔ#ⰘⰅⰓⰑ-ⰔⰒⰀⰂⰐ-ⰂⰅⰓⰋⰗⰉ. · ⰒⰀⰃⰅ

ⰗⰓⰑⰐⰕⰋⰅⰓ — undefined ⰒⰀⰃⰅⰔ

• ⰗⰑⰎⰄⰋⰐⰃ ⰎⰋⰐⰅⰀⰓ ⰃⰋⰂⰅⰔ ⰀⰐⰀⰎⰑⰃ — ⰗⰑⰎⰄⰋⰐⰃ ⰎⰋⰐⰅⰀⰓ ⰃⰋⰂⰅⰔ ⰀⰐⰀⰎⰑⰃ, ⰄⰅⰜⰑⰄⰅⰄ ⰘⰑⰐⰅⰔⰕⰎⰉ ⰂⰋⰕⰘ ⰕⰘⰅ ⰓⰅⰀⰎ ⰔⰜⰋⰅⰐⰜⰅ. ⰕⰘⰅ ⰍⰅⰓⰐⰅⰎ ⰋⰔ ⰕⰘⰅ ⰂⰘⰋⰕⰕⰀⰍⰅⰓ–ⰔⰘⰀⰐⰐⰑⰐ ⰔⰀⰏⰒⰎⰋⰐⰃ ⰕⰘⰅⰑⰓⰅⰏ: ⰄⰋⰔⰜⰓⰅⰕⰅ ⰔⰀⰏⰒⰎⰅⰔ ⰑⰗ Ⰰ ⰁⰀⰐⰄ-ⰎⰋⰏⰋⰕⰅⰄ ⰔⰋⰃⰐⰀⰎ ⰗⰑⰎⰄ ⰁⰀⰜⰍ ⰋⰐⰕⰑ ⰕⰘⰅ ⰜⰑⰐⰕⰋⰐⰖⰑⰖⰔ ⰔⰋⰃⰐⰀⰎ ⰂⰋⰕⰘ ⰐⰑ ⰃⰀⰒⰔ, ⰂⰋⰀ ⰔⰋⰐⰜ ⰋⰐⰕⰅⰓⰒⰑⰎⰀⰕⰋⰑⰐ (ⰜⰑⰏⰒⰖⰕⰅⰄ ⰎⰋⰂⰅ, ⰅⰘⰀⰜⰕ ⰀⰕ ⰕⰘⰅ ⰔⰀⰏⰒⰎⰅⰔ). ⰏⰅⰄⰋⰜⰀⰎ ⰀⰐⰄ ⰓⰀⰄⰀⰓ ⰋⰏⰀⰃⰋⰐⰃ ⰋⰔ ⰅⰘⰀⰜⰕⰎⰉ ⰕⰘⰋⰔ — ⰓⰅⰜⰑⰐⰔⰕⰓⰖⰜⰕⰋⰐⰃ Ⰰ ⰜⰑⰐⰕⰋⰐⰖⰑⰖⰔ ⰋⰏⰀⰃⰅ ⰗⰓⰑⰏ Ⰰ ⰔⰀⰏⰒⰎⰅⰄ ⰗⰓⰅⰍⰖⰅⰐⰜⰉ ⰗⰋⰅⰎⰄ: ⰏⰓⰋ ⰋⰐⰂⰅⰓⰕⰔ ⰕⰘⰅ ⰗⰑⰖⰓⰋⰅⰓ ⰕⰓⰀⰐⰔⰗⰑⰓⰏ ⰑⰗ Ⰽ-ⰔⰒⰀⰜⰅ, ⰜⰕ ⰕⰘⰅ ⰓⰀⰄⰑⰐ ⰕⰓⰀⰐⰔⰗⰑⰓⰏ, ⰀⰐⰄ ⰕⰘⰅ ⰔⰒⰋⰓⰀⰎ/ⰓⰀⰄⰋⰀⰎ "ⰂⰑⰓⰕⰅⰘ" ⰕⰘⰓⰑⰖⰃⰘ Ⰽ-ⰔⰒⰀⰜⰅ ⰋⰔ ⰓⰅⰀⰎ (ⰐⰖⰗⰗⰕ). ⰕⰘⰅ undefined³ = undefined⁹ ⰃⰓⰋⰄ ⰕⰘⰅ ⰏⰑⰄⰅⰎ ⰀⰎⰓⰅⰀⰄⰉ ⰜⰑⰏⰒⰖⰕⰅⰔ ⰋⰔ ⰕⰘⰅ ⰄⰋⰔⰜⰓⰅⰕⰅ ⰎⰀⰕⰕⰋⰜⰅ ⰋⰕ ⰔⰀⰏⰒⰎⰅⰔ. ⰄⰑⰜⰖⰏⰅⰐⰕⰅⰄ ⰍⰅⰒⰕ, ⰎⰅⰃⰅⰐⰄ ⰗⰎⰀⰃⰃⰅⰄ — ⰐⰉⰍⰖⰋⰔⰕ ⰎⰋⰏⰋⰕⰔ ⰀⰓⰅ ⰓⰅⰀⰎ, ⰃⰀⰒ-ⰗⰋⰎⰎⰋⰐⰃ ⰜⰀⰐ ⰘⰀⰎⰎⰖⰜⰋⰐⰀⰕⰅ, ⰀⰐⰄ ⰕⰘⰅ ⰕⰘⰅⰑⰓⰅⰏ ⰋⰔ ⰗⰑⰖⰐⰄⰀⰕⰋⰑⰐⰀⰎ, ⰐⰑⰕ ⰐⰅⰂ. · ⰒⰀⰃⰅ
• ⰕⰘⰅⰑⰓⰅⰏ ⰓⰅⰃⰋⰔⰕⰓⰉ — ⰔⰕⰀⰕⰅⰏⰅⰐⰕ: ⰕⰘⰅⰑⰓⰅⰏ ⰓⰅⰃⰋⰔⰕⰓⰉ = ⰓⰅⰜⰅⰐⰕ ⰄⰅⰜⰑⰄⰅⰔ + ⰕⰘⰅⰑⰓⰅⰏ-ⰂⰀⰂⰅ ⰅⰐⰃⰋⰐⰅ. ⰅⰘⰒⰎⰀⰐⰀⰕⰋⰑⰐ: ⰄⰋⰂⰋⰐⰃ/ⰂⰀⰕⰅⰓ/ⰔⰒⰀⰜⰅ; ⰍⰖⰀⰐⰕⰖⰏ ⰂⰀⰜⰖⰖⰏ; ⰜⰑⰔⰏⰋⰜ ⰋⰐⰂⰅⰐⰕⰑⰓⰉ; ⰒⰘⰉⰔⰋⰜⰔ ⰑⰗ ⰋⰐⰗⰑⰓⰏⰀⰕⰋⰑⰐ; ⰜⰎⰑⰂⰐ ⰍⰖⰁⰋⰕ ⰑⰐ ⰃⰅⰐⰖⰔ-undefined. ⰏⰅⰕⰘⰑⰄ: ⰕⰘⰅⰑⰓⰅⰏⰔ:ⰃⰀⰒⰔ · ⰕⰘⰅⰑⰓⰅⰏⰔ:ⰂⰅⰓⰋⰗⰉ · ⰐⰒⰏ ⰓⰖⰐ ⰍⰖⰀⰐⰕⰖⰏ:ⰄⰑⰏⰀⰋⰐ-ⰒⰓⰑⰑⰗ-ⰜⰀⰕⰀⰎⰑⰃ · /ⰒⰓⰑⰑⰗⰔ. ⰔⰕⰀⰕⰖⰔ: ⰅⰀⰜⰘ ⰀⰕⰑⰏ ⰘⰀⰔ ⰔⰕⰀⰕⰅⰏⰅⰐⰕ · ⰜⰑⰏⰒⰖⰕⰅⰄ ⰜⰘⰅⰜⰍⰔ · ⰘⰑⰐⰅⰔⰕ ⰁⰑⰖⰐⰄⰀⰓⰉ; ⰑⰒⰅⰐ ⰒⰓⰑⰁⰎⰅⰏⰔ ⰘⰅⰎⰄ ⰑⰒⰅⰐ. ⰅⰂⰅⰓⰉ ⰓⰅⰔⰖⰎⰕ Ⰰ ⰜⰎⰋⰅⰐⰕ-ⰔⰋⰄⰅ ⰜⰑⰏⰒⰖⰕⰀⰕⰋⰑⰐ ⰗⰓⰑⰏ ⰕⰘⰅ ⰔⰓⰜ/](/frontiers) ⰒⰓⰋⰏⰋⰕⰋⰂⰅⰔ. · ⰒⰀⰃⰅ
• undefined = ⰕⰘⰅ undefined-ⰍⰖⰁⰋⰕ ⰒⰀⰖⰎⰋ ⰁⰀⰔⰋⰔ — ⰔⰕⰀⰕⰅⰏⰅⰐⰕ: undefined = undefined-ⰍⰖⰁⰋⰕ ⰒⰘⰀⰔⰅⰎⰅⰔⰔ ⰒⰀⰖⰎⰋ ⰁⰀⰔⰋⰔ {Ⰻ,Ⱈ,Ⰹ,Ⰸ}³ = undefined³ = undefined² = undefined⁶ ⰜⰑⰏⰁⰋⰐⰀⰕⰑⰓⰋⰀⰎ ⰒⰀⰓⰀⰎⰎⰅⰎ. ⰅⰘⰒⰎⰀⰐⰀⰕⰋⰑⰐ: ⰔⰋⰘⰕⰉⰗⰑⰖⰓⰕⰘⰓⰅⰅⰍⰖⰁⰋⰕⰒⰀⰖⰎⰋⰁⰀⰔⰋⰔ ⰏⰀⰕⰜⰘⰅⰔ ⰃⰅⰐⰅⰕⰋⰜ ⰜⰑⰄⰑⰐ ⰜⰑⰖⰐⰕ ⰀⰐⰄ ⰘⰅⰘⰀⰃⰓⰀⰏ ⰂⰑⰜⰀⰁⰖⰎⰀⰓⰉ — ⰒⰀⰓⰀⰎⰎⰅⰎ, ⰐⰑⰕ ⰜⰀⰖⰔⰀⰎ ⰎⰋⰐⰍ. ⰏⰅⰕⰘⰑⰄ: ⰔⰋⰘⰕⰉⰗⰑⰖⰓⰕⰘⰓⰅⰅⰍⰖⰁⰋⰕⰒⰀⰖⰎⰋⰁⰀⰔⰋⰔ · ⰒⰓⰑⰑⰗⰓⰅⰐⰄⰅⰓⰅⰓ · ⰐⰒⰏ ⰓⰖⰐ ⰂⰅⰓⰋⰗⰉ. ⰔⰕⰀⰕⰖⰔ: ⰜⰑⰏⰁⰋⰐⰀⰕⰑⰓⰋⰀⰎ ⰒⰓⰑⰑⰗ · ⰄⰓⰑⰒ ⰑⰂⰅⰓ-ⰓⰅⰀⰜⰘ ⰑⰐ ⰅⰓⰓⰑⰓ-ⰜⰑⰓⰓⰅⰜⰕⰋⰑⰐ ⰜⰎⰀⰋⰏⰔ. · ⰒⰀⰃⰅ
• ⰅⰐⰜⰓⰉⰒⰕ ↔ ⰄⰅⰜⰓⰉⰒⰕ = ⰗⰑⰎⰄⰒⰀⰋⰓ ⰓⰅⰜⰑⰏⰒⰖⰕⰅ; ⰒⰓⰑⰄⰖⰜⰕⰋⰑⰐ ⰁⰓⰑⰂⰔⰅⰓ ⰓⰅⰂⰅⰓⰔⰅ ≤undefined-ⰁⰋⰕ ⰔⰅⰀⰎⰅⰄ ⰜⰀⰕⰀⰎⰑⰃ — ⰔⰕⰀⰕⰅⰏⰅⰐⰕ: ⰅⰐⰜⰓⰉⰒⰕ↔ⰄⰅⰜⰓⰉⰒⰕ ⰋⰔ ⰗⰑⰎⰄⰒⰀⰋⰓ ⰓⰅⰜⰑⰏⰒⰖⰕⰅ; ⰓⰅⰂⰅⰓⰔⰅ ⰔⰖⰓⰗⰀⰜⰅⰔ ⰀⰓⰅ ⰒⰓⰑⰄⰖⰜⰕⰋⰑⰐ ⰁⰓⰑⰂⰔⰅⰓ ⰕⰑⰑⰎⰔ ⰑⰐ ⰔⰅⰀⰎⰅⰄ-ⰜⰀⰕⰀⰎⰑⰃ ⰄⰅⰏⰑ_ⰓⰔⰀ_ⰏⰑⰄⰖⰎⰋ (≤undefined-ⰁⰋⰕ). ⰅⰘⰒⰎⰀⰐⰀⰕⰋⰑⰐ: ⰜⰑⰐⰕⰅⰐⰕ-ⰀⰄⰄⰓⰅⰔⰔⰅⰄ ⰕⰓⰋⰐⰋⰕⰉⰍⰅⰉ + ⰗⰑⰎⰄⰒⰀⰋⰓ ⰓⰑⰖⰐⰄ-ⰕⰓⰋⰒ; ⰏⰑⰄⰅⰎⰅⰄ ⰔⰘⰑⰓ ⰑⰐ ⰔⰅⰀⰎⰅⰄ ⰜⰀⰕⰀⰎⰑⰃ. ⰏⰅⰕⰘⰑⰄ: ⰐⰒⰏ ⰓⰖⰐ ⰍⰖⰀⰐⰕⰖⰏ:ⰅⰐⰜⰓⰉⰒⰕⰋⰑⰐ-ⰓⰅⰂⰅⰓⰔⰅ-ⰂⰅⰓⰋⰗⰉ · ⰗⰑⰎⰄ ⰅⰐⰜⰓⰉⰒⰕⰋⰑⰐⰓⰅⰂⰅⰓⰔⰅⰂⰅⰓⰋⰗⰉ. ⰔⰕⰀⰕⰖⰔ: ⰒⰓⰑⰄⰖⰜⰕⰋⰑⰐ ⰓⰔⰀ ⰁⰓⰅⰀⰍ ⰓⰅⰗⰖⰔⰅⰄ · ⰜⰅⰓⰕⰋⰗⰋⰅⰄ=ⰗⰀⰎⰔⰅ · ⰓⰅⰎⰀⰕⰅⰄ ⰔⰜⰋⰅⰐⰜⰅ ≠ ⰜⰎⰀⰉ ⰒⰓⰑⰒⰑⰔⰅⰄ ⰔⰑⰎⰖⰕⰋⰑⰐ (ⰒⰓⰋⰈⰅ ⰓⰖⰎⰅⰔ §undefined(Ⰴ)). · ⰒⰀⰃⰅ
• ⰔⰔⰎ/ⰕⰅⰔⰕ = ⰔⰅⰀⰎⰅⰄ ⰔⰕⰀⰜⰍ→ⰓⰅⰜⰅⰋⰒⰕ · ⰍⰖⰀⰐⰕⰖⰏ ⰃⰓⰀⰄⰅ · ⰗⰕⰎ ⰂⰀⰓⰏ ⰓⰅⰖⰔⰅ — ⰔⰕⰀⰕⰅⰏⰅⰐⰕ: ⰔⰔⰎ/ⰕⰅⰔⰕ ⰍⰖⰀⰐⰕⰖⰏⰋⰔⰅⰔ ⰔⰕⰀⰜⰍ→ⰓⰅⰜⰅⰋⰒⰕ ⰂⰋⰀ ⰔⰅⰀⰎⰅⰄ ⰜⰓⰉⰒⰕⰑ/ⰕⰎⰔ ⰗⰀⰜⰅⰔ (ⰕⰑⰑⰎ/ⰘⰑⰐⰅⰔⰕ · ⰔⰕⰀⰐⰄⰀⰓⰄⰔ ⰀⰖⰄⰋⰕ · ⰒⰑⰎⰅⰔ/ⰜⰓⰑⰔⰔ-ⰒⰍⰜ · ⰄⰋⰓⰅⰜⰕⰋⰑⰐⰀⰎ ⰕⰓⰋⰐⰋⰕⰉ) ⰂⰋⰕⰘ ⰏⰅⰏⰑⰁⰉⰓⰑⰑⰕ ⰗⰕⰎ ⰂⰀⰓⰏ ⰒⰀⰕⰘ. ⰅⰘⰒⰎⰀⰐⰀⰕⰋⰑⰐ: ⰍⰖⰀⰐⰕⰖⰏ ⰃⰓⰀⰄⰅⰔ ⰗⰓⰑⰏ ⰗⰀⰜⰅⰕ ⰜⰑⰂⰅⰓⰀⰃⰅ·ⰄⰋⰃⰋⰕ·ⰗⰂⰄ/ⰋⰐⰂ/ⰓⰅⰂ — ⰐⰑⰕ ⰍⰖⰀⰎⰉⰔ ⰎⰅⰕⰕⰅⰓⰔ; ⰎⰋⰂⰅ ⰓⰅⰏⰑⰕⰅ ⰘⰀⰐⰄⰔⰘⰀⰍⰅ ⰐⰀⰏⰅⰄ ⰓⰅⰔⰋⰄⰖⰀⰎ. ⰏⰅⰕⰘⰑⰄ: ⰐⰒⰏ ⰓⰖⰐ ⰍⰖⰀⰐⰕⰖⰏ:ⰔⰔⰎ-ⰕⰅⰔⰕ · ⰍⰖⰀⰐⰕⰖⰏ:ⰍⰖⰀⰐⰕⰖⰏⰋⰔⰅ-ⰗⰕⰎ · ⰗⰑⰎⰄ ⰔⰔⰎⰕⰅⰔⰕⰖⰋⰜⰑⰏⰒⰎⰅⰕⰅ. ⰔⰕⰀⰕⰖⰔ: ⰜⰅⰓⰕⰋⰗⰋⰅⰄ=ⰗⰀⰎⰔⰅ · ⰒⰓⰑⰑⰗ ⰔⰖⰓⰗⰀⰜⰅ · ⰐⰑⰕ ⰗⰑⰓⰅⰋⰃⰐ ⰔⰜⰀⰐⰐⰅⰓ ⰏⰋⰓⰓⰑⰓ. · ⰒⰀⰃⰅ

undefined. ⰔⰋⰕⰅⰏⰀⰒ

ⰕⰘⰅ ⰜⰑⰏⰒⰎⰅⰕⰅ ⰔⰅⰓⰂⰅⰄ ⰔⰖⰓⰗⰀⰜⰅ, ⰂⰋⰓⰅⰄ ⰗⰓⰑⰏ ⰑⰐⰅ ⰔⰑⰖⰓⰜⰅ (servedRouteFamilies) ⰔⰑ ⰕⰘⰅ ⰘⰖⰏⰀⰐ ⰔⰋⰕⰅⰏⰀⰒ ⰘⰅⰓⰅ ⰀⰐⰄ ⰕⰘⰅ ⰜⰓⰀⰂⰎⰅⰓ sitemap.xml ⰜⰑⰖⰐⰕ ⰕⰘⰅ ⰔⰀⰏⰅ ⰒⰀⰃⰅⰔ: undefined ⰒⰀⰃⰅⰔ ⰀⰜⰓⰑⰔⰔ undefined ⰗⰀⰏⰋⰎⰋⰅⰔ — undefined ⰏⰑⰐⰑⰃⰓⰀⰒⰘⰔ · undefined ⰕⰘⰅⰑⰓⰅⰏⰔ · undefined ⰒⰓⰑⰑⰗⰔ. ⰑⰐⰎⰉ ⰜⰑⰏⰒⰎⰅⰕⰅ, ⰐⰑⰐ-ⰄⰖⰒⰎⰋⰜⰀⰕⰅ ⰗⰀⰏⰋⰎⰋⰅⰔ ⰀⰓⰅ ⰎⰋⰔⰕⰅⰄ: ⰕⰘⰅ ⰅⰏⰒⰕⰉ ⰏⰑⰄⰅⰎ ⰜⰀⰓⰄⰔ (servedRouteFamilies) ⰀⰐⰄ ⰕⰘⰅ ⰜⰑⰏⰒⰖⰕⰅ-ⰑⰐⰎⰉ papers/[id] ⰜⰀⰕⰜⰘ-ⰀⰎⰎ (servedRouteFamilies ⰔⰔⰃ — ⰕⰘⰅ ⰒⰎⰀⰜⰅⰏⰅⰐⰕⰔ ⰓⰅⰔⰑⰎⰂⰅ ⰑⰐ ⰄⰅⰏⰀⰐⰄ ⰀⰐⰄ ⰄⰖⰒⰎⰋⰜⰀⰕⰅ ⰕⰘⰅ ⰕⰘⰅⰑⰓⰅⰏ ⰒⰀⰒⰅⰓⰔ) ⰀⰓⰅ ⰅⰘⰜⰎⰖⰄⰅⰄ; ⰕⰘⰅⰋⰓ ⰋⰐⰄⰅⰘ ⰓⰑⰖⰕⰅⰔ ⰀⰓⰅ ⰏⰑⰐⰑⰃⰓⰀⰒⰘⰔ ⰁⰅⰎⰑⰂ.

• undefined ⰏⰑⰐⰑⰃⰓⰀⰒⰘ ⰎⰀⰐⰄⰋⰐⰃ + ⰋⰐⰄⰅⰘ ⰒⰀⰃⰅⰔ (/) — ⰅⰀⰜⰘ ⰋⰐ ⰕⰘⰓⰅⰅ ⰎⰑⰜⰀⰎⰅ ⰅⰄⰋⰕⰋⰑⰐⰔ (ⰅⰐ · ⰁⰃ · ⰜⰖ), ⰒⰎⰀⰜⰅⰄ ⰑⰐ ⰕⰘⰅ ⰄⰑⰖⰁⰎⰅ ⰕⰑⰓⰖⰔ ⰀⰐⰄ ⰜⰑⰐⰕⰅⰐⰕ-ⰀⰄⰄⰓⰅⰔⰔⰅⰄ:

• undefined ⰕⰘⰅⰑⰓⰅⰏ ⰒⰀⰒⰅⰓⰔ — ⰋⰐⰄⰅⰘ /theorems; ⰅⰂⰅⰓⰉ ⰒⰀⰃⰅ ⰅⰐⰖⰏⰅⰓⰀⰕⰅⰄ ⰋⰐ ⰕⰘⰅ ⰑⰐⰅ sitemap.xml.

• undefined ⰄⰑⰏⰀⰋⰐ ⰒⰓⰑⰑⰗⰔ (ⰏⰋⰎⰎⰅⰐⰐⰋⰖⰏ + ⰔⰜⰋⰅⰐⰜⰅ) — ⰋⰐⰄⰅⰘ /proofs; ⰅⰂⰅⰓⰉ ⰒⰀⰃⰅ ⰅⰐⰖⰏⰅⰓⰀⰕⰅⰄ ⰋⰐ ⰕⰘⰅ ⰑⰐⰅ sitemap.xml.

• / — ⰅⰐ · ⰁⰃ · ⰜⰖ

• /analog-field — ⰅⰐ · ⰁⰃ · ⰜⰖ

• /learn — ⰅⰐ · ⰁⰃ · ⰜⰖ

• /frontiers — ⰅⰐ · ⰁⰃ · ⰜⰖ

• /pi-trinity — ⰅⰐ · ⰁⰃ · ⰜⰖ

• /qubit-trinity — ⰅⰐ · ⰁⰃ · ⰜⰖ

• /pauli-basis — ⰅⰐ · ⰁⰃ · ⰜⰖ

• /hamming-address — ⰅⰐ · ⰁⰃ · ⰜⰖ

• /content-addressing — ⰅⰐ · ⰁⰃ · ⰜⰖ

• /genetic-code — ⰅⰐ · ⰁⰃ · ⰜⰖ

• /three-not-one — ⰅⰐ · ⰁⰃ · ⰜⰖ

• /hexagram-colour — ⰅⰐ · ⰁⰃ · ⰜⰖ

• /sixty-four — ⰅⰐ · ⰁⰃ · ⰜⰖ

• /rgb-cmyk — ⰅⰐ · ⰁⰃ · ⰜⰖ

• /trinity-rgb — ⰅⰐ · ⰁⰃ · ⰜⰖ

• /proven-or-purged — ⰅⰐ · ⰁⰃ · ⰜⰖ

• /kernel-zero — ⰅⰐ · ⰁⰃ · ⰜⰖ

• /vortex — ⰅⰐ · ⰁⰃ · ⰜⰖ

• /zero-division — ⰅⰐ · ⰁⰃ · ⰜⰖ

• /digit-folders — ⰅⰐ · ⰁⰃ · ⰜⰖ

• /dot-cube — ⰅⰐ · ⰁⰃ · ⰜⰖ

• /seven-star-rosetta — ⰅⰐ · ⰁⰃ · ⰜⰖ

• /encryption — ⰅⰐ · ⰁⰃ · ⰜⰖ

• /ssltest — ⰅⰐ · ⰁⰃ · ⰜⰖ

• /quantum-tools — ⰅⰐ · ⰁⰃ · ⰜⰖ

• /quantum-trading-hub — ⰅⰐ · ⰁⰃ · ⰜⰖ

• /research — ⰅⰐ · ⰁⰃ · ⰜⰖ

• /society-merkaba — ⰅⰐ · ⰁⰃ · ⰜⰖ

• /efficiency-vote — ⰅⰐ · ⰁⰃ · ⰜⰖ

• /offender-spec — ⰅⰐ · ⰁⰃ · ⰜⰖ

• /hero-spawn-verify — ⰅⰐ · ⰁⰃ · ⰜⰖ

• ⰔⰋⰕⰅⰏⰀⰒ ⰓⰑⰑⰕ: 00dff8ea-aa58-84d1-a61c-69c0e68696ce

ⰕⰘⰅ ⰉⰑⰖⰓⰐⰀⰎ

ⰕⰘⰋⰔ ⰔⰋⰕⰅ ⰋⰔ Ⰰ ⰄⰅⰄⰋⰜⰀⰕⰅⰄ ⰔⰜⰋⰅⰐⰕⰋⰗⰋⰜ ⰉⰑⰖⰓⰐⰀⰎ ⰑⰗ ⰀⰎⰎ ⰋⰕⰔ ⰀⰎⰃⰅⰁⰓⰀ ⰀⰐⰄ ⰕⰘⰅⰑⰓⰅⰏⰔ — undefined ⰀⰓⰕⰋⰜⰎⰅⰔ ⰀⰜⰓⰑⰔⰔ undefined ⰔⰅⰜⰕⰋⰑⰐⰔ, ⰁⰀⰜⰍⰅⰄ ⰁⰉ undefined ⰅⰘⰅⰜⰖⰕⰀⰁⰎⰅ ⰒⰓⰑⰑⰗⰔ, ⰔⰅⰀⰎⰅⰄ ⰀⰔ ⰑⰐⰅ ⰜⰑⰐⰕⰅⰐⰕ-ⰀⰄⰄⰓⰅⰔⰔⰅⰄ ⰂⰑⰎⰖⰏⰅ 6c5a9675. ⰒⰅⰅⰓ ⰓⰅⰂⰋⰅⰂ ⰋⰔ ⰜⰑⰏⰒⰖⰕⰀⰕⰋⰑⰐⰀⰎ: ⰅⰂⰅⰓⰉ ⰒⰓⰑⰑⰗ ⰓⰅ-ⰓⰖⰐⰔ ⰅⰀⰜⰘ ⰂⰀⰂⰅ, ⰀⰐⰄ ⰕⰘⰅ ⰔⰀⰏⰅ ⰜⰑⰓⰒⰖⰔ ⰓⰅⰜⰑⰏⰒⰖⰕⰅⰔ ⰕⰘⰅ ⰔⰀⰏⰅ ⰂⰑⰎⰖⰏⰅ ⰋⰄ. ⰒⰓⰅⰜⰋⰔⰅⰎⰉ, ⰕⰘⰀⰕ ⰓⰅ-ⰅⰘⰅⰜⰖⰕⰋⰑⰐ ⰂⰅⰓⰋⰗⰋⰅⰔ ⰋⰐⰕⰅⰓⰐⰀⰎ ⰜⰑⰐⰔⰋⰔⰕⰅⰐⰜⰉ ⰀⰐⰄ ⰓⰅⰒⰓⰑⰄⰖⰜⰋⰁⰋⰎⰋⰕⰉ ⰀⰐⰄ ⰄⰅⰏⰀⰓⰜⰀⰕⰅ-ⰔⰋⰃⰐⰔ ⰅⰀⰜⰘ ⰀⰓⰕⰋⰜⰎⰅ — ⰂⰘⰋⰜⰘ ⰋⰔ ⰐⰑⰕ ⰅⰏⰒⰋⰓⰋⰜⰀⰎ ⰂⰀⰎⰋⰄⰀⰕⰋⰑⰐ ⰀⰐⰄ ⰐⰑⰕ ⰅⰘⰕⰅⰓⰐⰀⰎ ⰒⰅⰅⰓ ⰓⰅⰂⰋⰅⰂ (ⰐⰑ ⰋⰐⰄⰅⰒⰅⰐⰄⰅⰐⰕ ⰓⰅⰗⰅⰓⰅⰅⰔ). Ⰰ ⰄⰑⰋ ⰋⰔ Ⰰ ⰒⰅⰓⰔⰋⰔⰕⰅⰐⰕ ⰋⰄⰅⰐⰕⰋⰗⰋⰅⰓ, ⰐⰑⰕ Ⰰ ⰓⰅⰂⰋⰅⰂ — ⰑⰓⰕⰘⰑⰃⰑⰐⰀⰎ ⰕⰑ ⰓⰅⰗⰅⰓⰅⰅⰋⰐⰃ ⰀⰐⰄ ⰏⰋⰐⰕⰀⰁⰎⰅ ⰁⰉ ⰀⰓⰜⰘⰋⰂⰋⰐⰃ, ⰔⰑ ⰋⰕⰔ ⰀⰁⰔⰅⰐⰜⰅ ⰋⰔ ⰐⰑⰕ ⰕⰘⰅ ⰎⰋⰏⰋⰕ. ⰕⰘⰅ ⰜⰑⰓⰒⰖⰔ ⰜⰋⰕⰅⰔ ⰅⰏⰒⰋⰓⰋⰜⰀⰎⰎⰉ-ⰅⰔⰕⰀⰁⰎⰋⰔⰘⰅⰄ ⰓⰅⰔⰖⰎⰕⰔ ⰁⰖⰕ ⰓⰅⰗⰅⰓⰅⰅⰔⰔ ⰐⰑⰐⰅ ⰑⰗ ⰕⰘⰅⰏ ⰀⰃⰀⰋⰐⰔⰕ ⰐⰀⰕⰖⰓⰅ.

undefined. ⰓⰅⰒⰓⰑⰄⰖⰜⰋⰁⰋⰎⰋⰕⰉ

npm install
npm run check:types  # the src/ core type-checks clean against tsconfig.json (tsc --noEmit)
npm run docs:build   # build, then seal: enforcement trinity (cross · fold · weave)

ⰕⰘⰅ ⰔⰅⰀⰎ ⰓⰅⰜⰑⰏⰒⰖⰕⰅⰔ ⰗⰓⰑⰏ ⰔⰓⰜ: ⰗⰑⰓⰃⰋⰐⰃ ⰑⰐⰅ ⰓⰅⰒⰑⰓⰕⰅⰄ ⰂⰀⰎⰖⰅ ⰏⰅⰀⰐⰔ ⰓⰅ-ⰄⰅⰓⰋⰂⰋⰐⰃ ⰕⰘⰅ ⰂⰘⰑⰎⰅ ⰜⰑⰐⰕⰅⰐⰕ-ⰀⰄⰄⰓⰅⰔⰔⰅⰄ ⰔⰕⰓⰖⰜⰕⰖⰓⰅ ⰕⰑ Ⰰ ⰄⰋⰗⰗⰅⰓⰅⰐⰕ ⰓⰅⰜⰅⰋⰒⰕ (2145d23b), ⰔⰑ ⰕⰘⰅ ⰀⰄⰄⰓⰅⰔⰔ ⰋⰔ ⰕⰘⰅ ⰒⰓⰑⰑⰗ, ⰐⰑⰕ Ⰰ ⰔⰋⰃⰐⰀⰕⰖⰓⰅ ⰑⰂⰅⰓ ⰒⰓⰑⰔⰅ. ⰕⰘⰅ ⰒⰓⰑⰑⰗ ⰓⰅⰒⰓⰑⰄⰖⰜⰅⰔ: ⰜⰎⰑⰐⰅ ⰕⰘⰅ ⰎⰋⰐⰍ ⰀⰐⰄ ⰕⰘⰅ ⰂⰘⰑⰎⰅ ⰔⰕⰓⰖⰜⰕⰖⰓⰅ ⰓⰅⰜⰑⰏⰒⰖⰕⰅⰔ.

undefined. ⰎⰋⰏⰋⰕⰀⰕⰋⰑⰐⰔ

• Ⰰ ⰜⰑⰏⰒⰀⰜⰕ ⰓⰅⰗⰅⰓⰅⰐⰜⰅ ⰋⰐⰄⰅⰘ ⰑⰗ ⰕⰘⰅ ⰒⰑⰓⰕⰀⰎ'Ⱄ ⰍⰐⰑⰂⰎⰅⰄⰃⰅ, ⰅⰀⰜⰘ ⰅⰐⰕⰓⰉ ⰜⰑⰐⰕⰅⰐⰕ-ⰀⰄⰄⰓⰅⰔⰔⰅⰄ (ⰔⰑ "ⰈⰅⰓⰑ ⰅⰐⰕⰓⰑⰒⰉ" ⰏⰅⰀⰐⰔ ⰐⰑ ⰄⰖⰒⰎⰋⰜⰀⰕⰅ ⰍⰅⰉⰔ, ⰐⰑⰕ ⰕⰘⰅⰓⰏⰑⰄⰉⰐⰀⰏⰋⰜⰔ). ⰔⰅⰀⰓⰜⰘⰀⰁⰎⰅ ⰂⰋⰀ ⰕⰘⰅ ⰋⰐⰕⰖⰋⰕⰋⰂⰅ ⰔⰅⰀⰓⰜⰘ; Ⰰ ⰄⰋⰔⰕⰋⰎⰎⰅⰄ ⰋⰐⰄⰅⰘ, ⰐⰑⰕ ⰕⰘⰅ ⰗⰖⰎⰎ ⰕⰅⰘⰕ.
• "undefined ⰃⰁⰋⰕ" ⰀⰐⰄ "undefined × undefined × undefined" ⰐⰀⰏⰅ ⰕⰘⰅ ⰍⰅⰉⰔⰒⰀⰜⰅ ⰔⰕⰓⰖⰜⰕⰖⰓⰅ, ⰐⰑⰕ ⰜⰋⰒⰘⰅⰓ ⰔⰕⰓⰅⰐⰃⰕⰘ (ⰀⰅⰔ-undefined-ⰃⰜⰏ) ⰑⰓ ⰕⰘⰓⰑⰖⰃⰘⰒⰖⰕ.
• ⰕⰘⰅ ⰐⰅⰖⰓⰑⰔⰜⰋⰅⰐⰜⰅ ⰕⰅⰓⰏⰔ (ⰓⰅⰅⰐⰕⰓⰉ, ⰒⰀⰕⰕⰅⰓⰐ ⰜⰑⰏⰒⰎⰅⰕⰋⰑⰐ, ⰘⰑⰎⰑⰃⰓⰀⰒⰘⰋⰜ) ⰀⰓⰅ ⰀⰐⰀⰎⰑⰃⰔ, ⰐⰑⰕ ⰜⰎⰀⰋⰏⰔ ⰀⰁⰑⰖⰕ ⰐⰅⰖⰓⰑⰐⰔ.

ⰓⰅⰗⰅⰓⰅⰐⰜⰅⰔ

• ⰕⰘⰅ ⰏⰑⰄⰅⰎ: src/quantum/heaven/mind. ⰕⰘⰅ ⰔⰋⰕⰅⰏⰀⰒ ⰓⰑⰑⰕ: 00dff8ea-aa58-84d1-a61c-69c0e68696ce. ⰕⰘⰅ ⰏⰑⰐⰑⰃⰓⰀⰒⰘ-ⰋⰐⰄⰅⰘ ⰓⰑⰑⰕ: c689ddf8-4931-8a38-acd2-cbadbe0e4362.
• ⰕⰅⰏⰒⰎⰀⰕⰅ ⰓⰑⰑⰕ (ⰕⰘⰅ ⰓⰅⰜⰅⰋⰒⰕ ⰑⰗ ⰕⰘⰋⰔ ⰏⰑⰐⰑⰃⰓⰀⰒⰘ ⰗⰑⰓⰏ): c27823b4-9f2d-8a37-8e3e-b2748445e0a4.
• ⰒⰓⰋⰑⰓ ⰂⰑⰓⰍ / ⰑⰓⰋⰃⰋⰐ: ⰜⰅⰜⰜⰅⰜ/ⰈⰅⰓⰑⰒⰑⰋⰐⰕ-ⰐⰑⰄⰅ — ⰕⰘⰅ ⰒⰓⰅⰄⰅⰜⰅⰔⰔⰑⰓ ⰓⰅⰒⰑ ⰑⰗ ⰕⰘⰅ ⰂⰑⰓⰕⰅⰘ ⰔⰅⰍⰖⰅⰐⰜⰅ (ⰔⰀⰏⰅ ⰜⰎⰑⰔⰅⰄ ⰜⰉⰜⰎⰅ, ⰂⰅⰓⰋⰗⰋⰅⰄ ⰁⰉ ⰜⰑⰏⰒⰖⰕⰀⰕⰋⰑⰐ ⰋⰐ zeropointNodeOriginDecoded); ⰋⰕⰔ undefined°/Ⰰundefined/ⰋⰐⰕⰅⰃⰅⰓ-ⰓⰀⰕⰋⰑ ⰏⰀⰕⰘⰅⰏⰀⰕⰋⰜⰔ ⰋⰔ ⰔⰅⰀⰎⰅⰄ ⰘⰅⰓⰅ, ⰋⰕⰔ ⰈⰅⰓⰑ-ⰒⰑⰋⰐⰕ ⰗⰓⰅⰅ-ⰅⰐⰅⰓⰃⰉ ⰀⰐⰄ ⰜⰑⰐⰔⰜⰋⰑⰖⰔⰐⰅⰔⰔ-ⰑⰔ ⰜⰎⰀⰋⰏⰔ ⰀⰓⰅ ⰄⰅⰏⰀⰓⰜⰀⰕⰅⰄ ⰗⰎⰀⰃⰃⰅⰄ (½ħω ⰋⰔ ⰓⰅⰀⰎ, ⰅⰘⰕⰓⰀⰜⰕⰋⰑⰐ ⰋⰔ ⰐⰑⰕ).

ⰓⰅⰜⰅⰋⰒⰕ

ⰕⰘⰅ ⰓⰑⰑⰕ ⰏⰑⰐⰑⰃⰓⰀⰒⰘ ⰋⰔ ⰋⰕⰔⰅⰎⰗ ⰜⰑⰐⰕⰅⰐⰕ-ⰀⰄⰄⰓⰅⰔⰔⰅⰄ: ⰕⰘⰅ ⰔⰅⰜⰕⰋⰑⰐ ⰔⰜⰘⰅⰏⰀ, ⰕⰘⰅ ⰜⰑⰓⰒⰖⰔ ⰓⰑⰑⰕⰔ ⰀⰐⰄ ⰅⰂⰅⰓⰉ ⰓⰅⰒⰑⰓⰕⰅⰄ ⰜⰑⰖⰐⰕ ⰗⰑⰎⰄ ⰕⰑ ⰑⰐⰅ ⰓⰅⰜⰅⰋⰒⰕ ⰕⰘⰀⰕ ⰓⰅⰒⰓⰑⰄⰖⰜⰅⰔ ⰗⰓⰑⰏ src ⰀⰐⰄ ⰜⰘⰀⰐⰃⰅⰔ ⰋⰗ ⰀⰐⰉ ⰓⰅⰒⰑⰓⰕⰅⰄ ⰂⰀⰎⰖⰅ ⰄⰑⰅⰔ — ⰕⰘⰅ ⰀⰄⰄⰓⰅⰔⰔ ⰋⰔ ⰕⰘⰅ ⰒⰓⰑⰑⰗ, ⰐⰑⰕ Ⰰ ⰔⰋⰃⰐⰀⰕⰖⰓⰅ ⰑⰂⰅⰓ ⰒⰓⰑⰔⰅ.

• ⰓⰅⰜⰅⰋⰒⰕ: ⰗⰑⰎⰄ readmeMarkdown