mirror of
https://github.com/hanzoai/skills.git
synced 2026-11-19 00:47:36 +00:00
hanzoskills.com/llms.txt now opens with the install line, the API reference index and the company index, so an agent that lands on any one of the three can find the rest. robots.txt claimed 537 documents while llms.txt counts 920. The number is gone from robots.txt; llms.txt derives it. public/ is regenerated from scripts/site.py, which it had fallen behind: the copy-prompt menu and agent bar were in the generator and not in the committed pages. tests/site.mjs passes against the result. Co-authored-by: Hanzo Dev <[email protected]>
611 lines
29 KiB
HTML
611 lines
29 KiB
HTML
<!doctype html>
|
||
<html lang="en"><head>
|
||
<meta charset="utf-8"><meta name="viewport" content="width=device-width,initial-scale=1">
|
||
<title>set-theory</title>
|
||
<meta name="color-scheme" content="dark">
|
||
<style>
|
||
/* Committed to one visual world: a dark instrument panel. No light variant —
|
||
the dot field and the hairline rules only read on black, and a naive
|
||
inversion would wash both out. Every colour is painted explicitly so the page
|
||
never borrows a host background. */
|
||
@font-face{font-family:'Zen';src:url('/fonts/Zen-Variable.woff2') format('woff2');font-weight:100 900;font-style:normal;font-display:swap}
|
||
@font-face{font-family:'Zen';src:url('/fonts/Zen-Italic-Variable.woff2') format('woff2');font-weight:100 900;font-style:italic;font-display:swap}
|
||
@font-face{font-family:'Zen Mono';src:url('/fonts/ZenMono-Variable.woff2') format('woff2');font-weight:100 900;font-style:normal;font-display:swap}
|
||
@font-face{font-family:'Zen Mono';src:url('/fonts/ZenMono-Italic-Variable.woff2') format('woff2');font-weight:100 900;font-style:italic;font-display:swap}
|
||
@font-face{font-family:'Zen Pixel Square';src:url('/fonts/ZenPixel-Square.woff2') format('woff2');font-style:normal;font-display:swap}
|
||
|
||
:root{
|
||
--ink:#f4f4f2; --soft:#9c9c98; --faint:#6a6a66; --ground:#000; --panel:#0a0a0a;
|
||
--line:#232323; --line-hi:#3a3a3a; --accent:#f4f4f2;
|
||
--font-zen-sans:'Zen',-apple-system,BlinkMacSystemFont,"Segoe UI",Helvetica,Arial,sans-serif;
|
||
--font-zen-mono:'Zen Mono',ui-monospace,"SF Mono",SFMono-Regular,Menlo,Consolas,monospace;
|
||
--font-zen-pixel-square:'Zen Pixel Square',monospace;
|
||
--mono:var(--font-zen-mono);
|
||
--sans:var(--font-zen-sans);
|
||
/* Controls are pills and surfaces are soft, as on hanzo.ai. */
|
||
--r:999px; --r-soft:14px;
|
||
}
|
||
*{box-sizing:border-box}
|
||
html{-webkit-text-size-adjust:100%}
|
||
body{margin:0;background:var(--ground);color:var(--ink);font-family:var(--sans);
|
||
font-size:16px;line-height:1.65;-webkit-font-smoothing:antialiased}
|
||
.wrap{max-width:60rem;margin:0 auto;padding:0 1.75rem}
|
||
|
||
/* The dot field. A halftone made of one repeating radial-gradient, faded out
|
||
along the diagonal by a mask so it reads as a wave rather than wallpaper. */
|
||
/* No overflow clip here: the dot field is inset to the box already, and a clip
|
||
would cut off the copy-prompt menu. */
|
||
.hero{position:relative;border-bottom:1px solid var(--line)}
|
||
.hero::before{content:"";position:absolute;inset:0;
|
||
background-image:radial-gradient(var(--line-hi) 1px, transparent 1px);
|
||
background-size:7px 7px;
|
||
-webkit-mask-image:linear-gradient(115deg,#000 0%,rgba(0,0,0,.55) 38%,transparent 72%);
|
||
mask-image:linear-gradient(115deg,#000 0%,rgba(0,0,0,.55) 38%,transparent 72%);
|
||
pointer-events:none}
|
||
.hero .wrap{position:relative;padding-top:5.5rem;padding-bottom:4rem}
|
||
|
||
nav{border-bottom:1px solid var(--line)}
|
||
nav .in{max-width:60rem;margin:0 auto;padding:1.1rem 1.75rem;display:flex;
|
||
justify-content:space-between;align-items:center;gap:1rem}
|
||
.brand{font-family:var(--mono);font-size:.85rem;letter-spacing:.14em;
|
||
text-transform:uppercase;color:var(--ink);text-decoration:none;
|
||
display:inline-flex;align-items:center;gap:.6rem}
|
||
.brand i{font-style:normal;color:var(--faint)}
|
||
.mark{width:1.15em;height:1.15em;display:block;flex:0 0 auto}
|
||
nav a.up{font-family:var(--mono);font-size:.72rem;letter-spacing:.14em;
|
||
text-transform:uppercase;color:var(--soft);text-decoration:none}
|
||
nav a.up:hover{color:var(--ink)}
|
||
|
||
h1{font-family:var(--mono);font-size:clamp(2rem,5.4vw,3.4rem);line-height:1.12;
|
||
letter-spacing:-.02em;margin:0 0 1.1rem;font-weight:500;text-wrap:balance}
|
||
h1 em{font-style:normal;color:var(--faint)}
|
||
.lede{color:var(--soft);font-size:1.05rem;max-width:52ch;margin:0 0 2.25rem}
|
||
|
||
.btns{display:flex;flex-wrap:wrap;gap:.7rem;margin:0 0 .5rem;align-items:center}
|
||
.btn{display:inline-flex;align-items:center;gap:.5rem;font-family:var(--mono);
|
||
font-size:.72rem;letter-spacing:.14em;text-transform:uppercase;
|
||
padding:.8rem 1.4rem;border:1px solid var(--line-hi);border-radius:var(--r);
|
||
color:var(--ink);text-decoration:none;background:transparent;cursor:pointer;
|
||
line-height:1.2;font-weight:400}
|
||
.btn:hover{background:#141414;text-decoration:none;border-color:var(--soft)}
|
||
.btn.solid{background:var(--ink);color:#000;border-color:var(--ink)}
|
||
.btn.solid:hover{background:#d8d8d4}
|
||
.btn .chev{width:.7em;height:.7em;flex:0 0 auto;transition:transform .15s ease}
|
||
.btn[aria-expanded="true"] .chev{transform:rotate(180deg)}
|
||
|
||
/* Copy-prompt selector. Each row copies the prompt for its own target. */
|
||
.copy{position:relative;display:inline-flex}
|
||
.menu{position:absolute;top:calc(100% + .5rem);left:0;z-index:20;min-width:21rem;
|
||
background:var(--panel);border:1px solid var(--line-hi);border-radius:var(--r-soft);
|
||
padding:.4rem;display:flex;flex-direction:column;
|
||
box-shadow:0 12px 32px rgba(0,0,0,.75)}
|
||
.menu[hidden]{display:none}
|
||
.mi{display:flex;align-items:center;gap:.7rem;width:100%;text-align:left;
|
||
padding:.62rem .8rem;border:0;border-radius:calc(var(--r-soft) - .35rem);
|
||
background:transparent;color:var(--ink);font-family:var(--mono);font-size:.76rem;
|
||
letter-spacing:.04em;text-decoration:none;cursor:pointer;line-height:1.3;
|
||
white-space:nowrap}
|
||
.mi:hover,.mi:focus-visible{background:#181818;outline:none}
|
||
.mi .mark{width:1.05rem;height:1.05rem;color:var(--soft)}
|
||
.mi:hover .mark{color:var(--ink)}
|
||
.mi u{margin-left:auto;color:var(--faint);text-decoration:none;font-size:.68rem;
|
||
letter-spacing:.1em;text-transform:uppercase}
|
||
|
||
/* Works-with bar: one scrolling row, name and mark per agent. */
|
||
.strip{border-bottom:1px solid var(--line);background:var(--panel)}
|
||
.strip .in{max-width:60rem;margin:0 auto;padding:.9rem 1.75rem;display:flex;
|
||
align-items:center;gap:1.25rem;font-family:var(--mono);font-size:.72rem;
|
||
letter-spacing:.1em;text-transform:uppercase;color:var(--faint)}
|
||
.strip b{color:var(--soft);font-weight:400;flex:0 0 auto;
|
||
border-right:1px solid var(--line);padding-right:1.25rem;align-self:stretch;
|
||
display:flex;align-items:center}
|
||
.bar{display:flex;align-items:center;gap:.5rem;flex:1 1 auto;min-width:0;
|
||
overflow-x:auto;scrollbar-width:none;scroll-snap-type:x proximity;
|
||
-webkit-overflow-scrolling:touch;
|
||
-webkit-mask-image:linear-gradient(90deg,#000 calc(100% - 3rem),transparent);
|
||
mask-image:linear-gradient(90deg,#000 calc(100% - 3rem),transparent)}
|
||
.bar::-webkit-scrollbar{display:none}
|
||
.agent{display:inline-flex;align-items:center;gap:.45rem;flex:0 0 auto;
|
||
padding:.4rem .85rem;border:1px solid var(--line);border-radius:var(--r);
|
||
color:var(--soft);white-space:nowrap;scroll-snap-align:start;
|
||
text-decoration:none;background:var(--ground)}
|
||
.agent:hover{color:var(--ink);border-color:var(--line-hi);text-decoration:none}
|
||
.agent .mark{width:.95rem;height:.95rem}
|
||
|
||
h2{font-family:var(--mono);font-size:1.1rem;letter-spacing:-.01em;margin:2.75rem 0 .75rem;font-weight:500}
|
||
h3{font-size:1rem;margin:2rem 0 .5rem;font-weight:600}
|
||
h4,h5,h6{font-size:.94rem;margin:1.5rem 0 .5rem;font-weight:600}
|
||
p{margin:0 0 1rem;max-width:70ch}
|
||
ul,ol{margin:0 0 1rem;padding-left:1.35rem;max-width:70ch}
|
||
li{margin:.22rem 0}
|
||
a{color:var(--ink);text-decoration:underline;text-underline-offset:3px;
|
||
text-decoration-color:var(--line-hi)}
|
||
a:hover{text-decoration-color:var(--ink)}
|
||
a:focus-visible{outline:1px solid var(--ink);outline-offset:3px}
|
||
code{font-family:var(--mono);font-size:.85em;background:var(--panel);
|
||
border:1px solid var(--line);border-radius:5px;padding:.1em .36em}
|
||
pre{background:var(--panel);border:1px solid var(--line);padding:1rem 1.1rem;
|
||
border-radius:var(--r-soft);overflow-x:auto;margin:0 0 1.25rem}
|
||
pre code{background:none;border:0;padding:0;font-size:.82rem;line-height:1.7}
|
||
blockquote{margin:0 0 1rem;padding-left:1rem;border-left:1px solid var(--line-hi);color:var(--soft)}
|
||
hr{border:0;border-top:1px solid var(--line);margin:2.5rem 0}
|
||
table{border-collapse:collapse;width:100%;margin:0 0 1.25rem;font-size:.92rem;
|
||
display:block;overflow-x:auto}
|
||
th,td{border:1px solid var(--line);padding:.5rem .7rem;text-align:left}
|
||
|
||
.curl{display:block;background:var(--panel);border:1px solid var(--line);
|
||
border-radius:var(--r-soft);padding:.95rem 1.1rem;font-family:var(--mono);
|
||
font-size:.8rem;color:var(--soft);overflow-x:auto;margin:0 0 2.5rem;
|
||
white-space:pre;line-height:1.9}
|
||
.curl b{color:var(--ink);font-weight:400}
|
||
.curl i{font-style:normal;color:var(--faint)}
|
||
|
||
/* index */
|
||
#q{width:100%;padding:.85rem 1.2rem;font-family:var(--mono);font-size:.85rem;color:var(--ink);
|
||
background:var(--panel);border:1px solid var(--line);border-radius:var(--r);margin:0 0 .6rem}
|
||
#q::placeholder{color:var(--faint);text-transform:uppercase;letter-spacing:.1em;font-size:.72rem}
|
||
#q:focus{outline:none;border-color:var(--soft)}
|
||
#count{color:var(--faint);font-family:var(--mono);font-size:.72rem;letter-spacing:.1em;
|
||
text-transform:uppercase;margin:0 0 2rem}
|
||
.cat{margin:2.5rem 0 .5rem;font-family:var(--mono);font-size:.7rem;letter-spacing:.16em;
|
||
text-transform:uppercase;color:var(--faint);border-bottom:1px solid var(--line);
|
||
padding-bottom:.45rem}
|
||
.row{display:block;padding:.6rem .9rem;margin:0 -.9rem;border-bottom:1px solid var(--line);
|
||
border-radius:var(--r-soft);text-decoration:none}
|
||
.row:hover{background:#0a0a0a}
|
||
.nm{font-family:var(--mono);font-size:.84rem;color:var(--ink);display:block}
|
||
.ds{color:var(--soft);font-size:.9rem;display:block;margin-top:.12rem}
|
||
footer{margin-top:4rem;padding:2rem 0 4rem;border-top:1px solid var(--line);
|
||
color:var(--faint);font-size:.85rem}
|
||
footer a{color:var(--soft)}
|
||
.fmap{display:grid;gap:1.75rem;grid-template-columns:repeat(auto-fit,minmax(11rem,1fr));
|
||
margin:0 0 2rem;font-size:.85rem}
|
||
.fmap b{display:block;font-family:var(--mono);font-size:.68rem;letter-spacing:.16em;
|
||
text-transform:uppercase;color:var(--faint);font-weight:400;margin:0 0 .6rem;
|
||
border-bottom:1px solid var(--line);padding-bottom:.4rem}
|
||
.fmap a{display:inline-block;color:var(--ink);text-decoration:none;margin:.3rem .35rem 0 0}
|
||
.fmap a:hover{text-decoration:underline}
|
||
.fmap div{color:var(--faint);line-height:1.5}
|
||
.fend{border-top:1px solid var(--line);padding-top:1.25rem;font-size:.82rem}
|
||
|
||
@media (max-width:640px){
|
||
.hero .wrap{padding-top:3.25rem;padding-bottom:2.75rem}
|
||
.btns{gap:.5rem}
|
||
.btn{padding:.75rem 1.15rem;font-size:.68rem}
|
||
.copy,.copy .btn{width:100%;justify-content:center}
|
||
.menu{left:0;right:0;min-width:0}
|
||
.strip .in{flex-direction:column;align-items:flex-start;gap:.6rem;padding:.9rem 1.75rem}
|
||
.strip b{border-right:0;padding-right:0}
|
||
.bar{width:100%}
|
||
}
|
||
</style>
|
||
<link rel="alternate" type="text/markdown" href="/set-theory.md">
|
||
|
||
<link rel="icon" href="/favicon.svg">
|
||
<link rel="canonical" href="https://hanzoskills.com/set-theory">
|
||
</head>
|
||
<!-- Reading this with a machine? Every page here is also plain markdown.
|
||
This one: https://hanzoskills.com/set-theory.md
|
||
Index: https://hanzoskills.com/llms.txt
|
||
Corpus: https://hanzoskills.com/all.md
|
||
Append .md to any path for the markdown twin. -->
|
||
<body>
|
||
<nav><div class="in">
|
||
<a class="brand" href="/"><svg class="mark" viewBox="0 0 67 67" fill="currentColor" aria-hidden="true"><path d="M22.21 67V44.6369H0V67H22.21Z"/><path d="M66.7038 22.3184H22.2534L0.0878906 44.6367H44.4634L66.7038 22.3184Z"/><path d="M22.21 0H0V22.3184H22.21V0Z"/><path d="M66.7198 0H44.5098V22.3184H66.7198V0Z"/><path d="M66.7198 67V44.6369H44.5098V67H66.7198Z"/></svg> HANZO<i>SKILLS</i></a>
|
||
<a class="up" href="/">All skills</a>
|
||
</div></nav>
|
||
|
||
<div class="wrap">
|
||
<h1>set-theory</h1><p class="lede">Set theory including ZFC axioms, ordinals, cardinals, axiom of choice, and forcing</p><h1>Set Theory</h1>
|
||
<p><strong>Scope</strong>: ZFC axioms, ordinal and cardinal arithmetic, axiom of choice, transfinite induction, forcing <strong>Lines</strong>: ~380 <strong>Last Updated</strong>: 2025-10-25</p>
|
||
<h2>When to Use This Skill</h2>
|
||
<p>Activate this skill when:</p>
|
||
<ul><li>Understanding foundations of mathematics</li><li>Working with infinite sets and cardinalities</li><li>Proving results using transfinite induction</li><li>Studying independence results (CH, AC)</li><li>Formalizing mathematics in set-theoretic foundations</li><li>Constructing mathematical objects via ordinals</li></ul>
|
||
<h2>Core Concepts</h2>
|
||
<h3>ZFC Axioms</h3>
|
||
<p><strong>Zermelo-Fraenkel Set Theory with Choice</strong>:</p>
|
||
<pre><code class="lang-python"># Conceptual representation of ZFC axioms
|
||
|
||
class ZFC:
|
||
"""
|
||
ZFC Axioms (informal Python representation):
|
||
1. Extensionality: Sets equal iff same elements
|
||
2. Empty Set: ∃ set with no elements
|
||
3. Pairing: {a, b} exists for any a, b
|
||
4. Union: ⋃ S exists for any set S
|
||
5. Power Set: 𝒫(S) exists for any S
|
||
6. Infinity: ∃ infinite set (ℕ)
|
||
7. Replacement: Image of set under function is set
|
||
8. Foundation: ∈-minimal element exists (no infinite ∈-descent)
|
||
9. Choice: ∃ choice function for any family of non-empty sets
|
||
"""
|
||
|
||
@staticmethod
|
||
def extensionality(A: set, B: set) -> bool:
|
||
"""A = B iff ∀x: x ∈ A ↔ x ∈ B"""
|
||
return A == B
|
||
|
||
@staticmethod
|
||
def empty_set() -> set:
|
||
"""∃ ∅: ∀x: x ∉ ∅"""
|
||
return set()
|
||
|
||
@staticmethod
|
||
def pairing(a, b) -> set:
|
||
"""{a, b} exists"""
|
||
return {a, b}
|
||
|
||
@staticmethod
|
||
def union(S: set) -> set:
|
||
"""⋃ S = {x : ∃A ∈ S: x ∈ A}"""
|
||
result = set()
|
||
for subset in S:
|
||
if isinstance(subset, (set, frozenset)):
|
||
result |= set(subset)
|
||
return result
|
||
|
||
@staticmethod
|
||
def power_set(S: set) -> set:
|
||
"""𝒫(S) = {A : A ⊆ S}"""
|
||
from itertools import chain, combinations
|
||
s_list = list(S)
|
||
return set(
|
||
frozenset(combo)
|
||
for combo in chain.from_iterable(
|
||
combinations(s_list, r) for r in range(len(s_list) + 1)
|
||
)
|
||
)
|
||
|
||
@staticmethod
|
||
def natural_numbers() -> set:
|
||
"""
|
||
Infinity axiom: ∃ inductive set
|
||
ℕ = {∅, {∅}, {∅, {∅}}, ...}
|
||
In practice, finite representation
|
||
"""
|
||
# von Neumann ordinals: 0={}, 1={0}, 2={0,1}, etc.
|
||
omega = set()
|
||
current = frozenset()
|
||
for _ in range(10): # Finite approximation
|
||
omega.add(current)
|
||
current = frozenset(omega)
|
||
return omega
|
||
|
||
# Example usage
|
||
zfc = ZFC()
|
||
empty = zfc.empty_set()
|
||
pair = zfc.pairing(1, 2)
|
||
union_result = zfc.union({frozenset({1, 2}), frozenset({2, 3})})
|
||
print(f"∪ {{{{1,2}}, {{2,3}}}} = {union_result}") # {1, 2, 3}
|
||
|
||
power = zfc.power_set({1, 2})
|
||
print(f"𝒫({{1,2}}) = {power}") # {∅, {1}, {2}, {1,2}}</code></pre>
|
||
<h3>Ordinals</h3>
|
||
<p><strong>Definition</strong>: Well-ordered set where every element equals set of predecessors</p>
|
||
<p><strong>von Neumann ordinals</strong>: α = {β : β < α}</p>
|
||
<ul><li>0 = ∅</li><li>1 = {0} = {∅}</li><li>2 = {0, 1} = {∅, {∅}}</li><li>ω = {0, 1, 2, ...} (first infinite ordinal)</li></ul>
|
||
<pre><code class="lang-python">class Ordinal:
|
||
"""Ordinal number implementation"""
|
||
|
||
def __init__(self, value):
|
||
"""
|
||
For finite ordinals: integer value
|
||
For ω and beyond: special representation
|
||
"""
|
||
self.value = value
|
||
|
||
def __lt__(self, other):
|
||
if isinstance(other.value, int) and isinstance(self.value, int):
|
||
return self.value < other.value
|
||
elif self.value == 'omega':
|
||
return isinstance(other.value, int) # ω > all finite ordinals
|
||
else:
|
||
# General ordinal comparison
|
||
return self._compare(other) < 0
|
||
|
||
def __eq__(self, other):
|
||
return self.value == other.value
|
||
|
||
def successor(self):
|
||
"""S(α) = α ∪ {α}"""
|
||
if isinstance(self.value, int):
|
||
return Ordinal(self.value + 1)
|
||
else:
|
||
return Ordinal(f"{self.value}+1")
|
||
|
||
def __repr__(self):
|
||
return f"Ordinal({self.value})"
|
||
|
||
# Ordinal arithmetic
|
||
def ordinal_addition(alpha: Ordinal, beta: Ordinal):
|
||
"""
|
||
α + β defined by transfinite recursion:
|
||
- α + 0 = α
|
||
- α + S(β) = S(α + β)
|
||
- α + λ = sup{α + β : β < λ} for limit λ
|
||
"""
|
||
if beta.value == 0:
|
||
return alpha
|
||
elif isinstance(beta.value, int) and beta.value > 0:
|
||
# Finite case
|
||
return Ordinal(alpha.value + beta.value) if isinstance(alpha.value, int) else alpha
|
||
else:
|
||
# Limit case (simplified)
|
||
return Ordinal(f"{alpha.value}+{beta.value}")
|
||
|
||
def ordinal_multiplication(alpha: Ordinal, beta: Ordinal):
|
||
"""
|
||
α · β defined by transfinite recursion:
|
||
- α · 0 = 0
|
||
- α · S(β) = (α · β) + α
|
||
- α · λ = sup{α · β : β < λ} for limit λ
|
||
"""
|
||
if beta.value == 0:
|
||
return Ordinal(0)
|
||
elif isinstance(alpha.value, int) and isinstance(beta.value, int):
|
||
return Ordinal(alpha.value * beta.value)
|
||
else:
|
||
return Ordinal(f"{alpha.value}·{beta.value}")
|
||
|
||
# Examples
|
||
omega = Ordinal('omega')
|
||
one = Ordinal(1)
|
||
print(f"1 + ω = {ordinal_addition(one, omega)}") # ω (NOT ω+1!)
|
||
print(f"ω + 1 = {ordinal_addition(omega, one)}") # ω+1
|
||
print(f"2 · ω = {ordinal_multiplication(Ordinal(2), omega)}") # ω
|
||
print(f"ω · 2 = {ordinal_multiplication(omega, Ordinal(2))}") # ω+ω = ω·2</code></pre>
|
||
<h3>Cardinals</h3>
|
||
<p><strong>Definition</strong>: Cardinality |A| measures "size" of set A</p>
|
||
<p><strong>Finite cardinals</strong>: |A| = n for some n ∈ ℕ</p>
|
||
<p><strong>Infinite cardinals</strong>:</p>
|
||
<ul><li>ℵ₀ = |ℕ| (countable)</li><li>ℵ₁ = next infinite cardinal</li><li>2^ℵ₀ = |ℝ| (continuum)</li></ul>
|
||
<pre><code class="lang-python">class Cardinal:
|
||
"""Cardinal number representation"""
|
||
|
||
def __init__(self, name, value=None):
|
||
self.name = name
|
||
self.value = value # Ordinal representation
|
||
|
||
def __lt__(self, other):
|
||
"""κ < λ if ∃ injection but no bijection"""
|
||
# Simplified for demonstration
|
||
cardinal_order = {'aleph_0': 0, '2^aleph_0': 1, 'aleph_1': 2}
|
||
return cardinal_order.get(self.name, float('inf')) < cardinal_order.get(other.name, float('inf'))
|
||
|
||
def __eq__(self, other):
|
||
return self.name == other.name
|
||
|
||
def __repr__(self):
|
||
return f"Cardinal({self.name})"
|
||
|
||
# Cardinal arithmetic
|
||
def cardinal_addition(kappa: Cardinal, lambda_: Cardinal):
|
||
"""
|
||
κ + λ = max(κ, λ) for infinite cardinals
|
||
"""
|
||
if kappa.name == 'aleph_0' and lambda_.name == 'aleph_0':
|
||
return Cardinal('aleph_0')
|
||
else:
|
||
return max(kappa, lambda_, key=lambda c: (c < kappa, c < lambda_))
|
||
|
||
def cardinal_multiplication(kappa: Cardinal, lambda_: Cardinal):
|
||
"""
|
||
κ · λ = max(κ, λ) for infinite cardinals (assuming AC)
|
||
"""
|
||
return cardinal_addition(kappa, lambda_)
|
||
|
||
def cardinal_exponentiation(kappa: Cardinal, lambda_: Cardinal):
|
||
"""
|
||
κ^λ = |{f : λ → κ}|
|
||
Special case: 2^ℵ₀ = continuum
|
||
"""
|
||
if kappa.name == '2' and lambda_.name == 'aleph_0':
|
||
return Cardinal('2^aleph_0')
|
||
else:
|
||
return Cardinal(f"{kappa.name}^{lambda_.name}")
|
||
|
||
# Examples
|
||
aleph_0 = Cardinal('aleph_0')
|
||
continuum = Cardinal('2^aleph_0')
|
||
print(f"ℵ₀ + ℵ₀ = {cardinal_addition(aleph_0, aleph_0)}") # ℵ₀
|
||
print(f"ℵ₀ · ℵ₀ = {cardinal_multiplication(aleph_0, aleph_0)}") # ℵ₀
|
||
print(f"2^ℵ₀ = {cardinal_exponentiation(Cardinal('2'), aleph_0)}") # continuum</code></pre>
|
||
<h3>Axiom of Choice</h3>
|
||
<p><strong>Axiom of Choice (AC)</strong>: For any family {A_i}_{i∈I} of non-empty sets, ∃ choice function f: I → ⋃A_i with f(i) ∈ A_i</p>
|
||
<p><strong>Equivalent formulations</strong>:</p>
|
||
<ul><li>Zorn's Lemma: Every chain in poset has maximal element</li><li>Well-Ordering Theorem: Every set can be well-ordered</li></ul>
|
||
<pre><code class="lang-python">def choice_function(family: dict) -> dict:
|
||
"""
|
||
Given family {A_i : i ∈ I}, construct choice function
|
||
f: I → ⋃ A_i with f(i) ∈ A_i
|
||
|
||
In constructive math, may not exist without AC
|
||
"""
|
||
choice = {}
|
||
for index, set_i in family.items():
|
||
if not set_i:
|
||
raise ValueError(f"Set A_{index} is empty")
|
||
# Choose arbitrary element (requires AC in general)
|
||
choice[index] = next(iter(set_i))
|
||
return choice
|
||
|
||
# Example: Product of non-empty sets is non-empty
|
||
def cartesian_product_nonempty(sets: list[set]) -> bool:
|
||
"""
|
||
∏ A_i ≠ ∅ iff ∀i: A_i ≠ ∅
|
||
Requires AC for infinite products
|
||
"""
|
||
if not sets:
|
||
return True
|
||
|
||
# Use choice function
|
||
family = {i: s for i, s in enumerate(sets)}
|
||
try:
|
||
choice = choice_function(family)
|
||
return True
|
||
except ValueError:
|
||
return False</code></pre>
|
||
<h3>Transfinite Induction</h3>
|
||
<p><strong>Principle</strong>: To prove P(α) for all ordinals α:</p>
|
||
<ol><li>Base case: P(0)</li><li>Successor: P(α) ⟹ P(α+1)</li><li>Limit: (∀β < λ: P(β)) ⟹ P(λ) for limit ordinal λ</li></ol>
|
||
<pre><code class="lang-python">def transfinite_induction(property_P, ordinal_limit):
|
||
"""
|
||
Verify property P for all ordinals up to limit
|
||
|
||
property_P: function taking ordinal, returning bool
|
||
ordinal_limit: maximum ordinal to check
|
||
"""
|
||
|
||
# Base case
|
||
if not property_P(Ordinal(0)):
|
||
return False
|
||
|
||
# Successor case (check finite ordinals)
|
||
for alpha in range(ordinal_limit):
|
||
if not property_P(Ordinal(alpha)):
|
||
return False
|
||
# Verify successor step
|
||
if not property_P(Ordinal(alpha + 1)):
|
||
return False
|
||
|
||
# Limit case would check supremum property
|
||
# (simplified for finite case)
|
||
|
||
return True
|
||
|
||
# Example: Prove every ordinal is well-ordered
|
||
def is_well_ordered(alpha: Ordinal) -> bool:
|
||
"""Check if α is well-ordered"""
|
||
# Every ordinal is well-ordered by construction
|
||
return True
|
||
|
||
# Verify by transfinite induction
|
||
result = transfinite_induction(is_well_ordered, ordinal_limit=100)
|
||
print(f"All ordinals up to 100 are well-ordered: {result}")</code></pre>
|
||
<hr>
|
||
<h2>Patterns</h2>
|
||
<h3>Pattern 1: Cantor's Diagonal Argument</h3>
|
||
<p><strong>Theorem</strong>: ℕ and ℝ have different cardinalities (|ℕ| < |ℝ|)</p>
|
||
<pre><code class="lang-python">def cantors_diagonal():
|
||
"""
|
||
Prove no bijection ℕ → (0,1)
|
||
Given any sequence of reals, construct real not in sequence
|
||
"""
|
||
# Suppose f: ℕ → (0,1) is surjective
|
||
# Represent reals as infinite decimals
|
||
sequence = [
|
||
"0.1234567890...",
|
||
"0.9876543210...",
|
||
"0.5555555555...",
|
||
# ... infinite sequence
|
||
]
|
||
|
||
# Construct diagonal real differing at each position
|
||
diagonal = "0."
|
||
for i, real_str in enumerate(sequence[:10]): # Finite approximation
|
||
digit = real_str[2 + i] # i-th digit after decimal
|
||
# Choose different digit
|
||
new_digit = '5' if digit != '5' else '7'
|
||
diagonal += new_digit
|
||
|
||
print(f"Diagonal real: {diagonal}")
|
||
print("This real differs from every real in sequence")
|
||
print("Therefore, no surjection ℕ → (0,1) exists")
|
||
|
||
return diagonal</code></pre>
|
||
<h3>Pattern 2: Continuum Hypothesis</h3>
|
||
<p><strong>CH</strong>: There is no cardinality strictly between ℵ₀ and 2^ℵ₀</p>
|
||
<p><strong>Statement</strong>: 2^ℵ₀ = ℵ₁ (continuum equals first uncountable cardinal)</p>
|
||
<p><strong>Status</strong>: Independent of ZFC (neither provable nor disprovable)</p>
|
||
<pre><code class="lang-python">def continuum_hypothesis():
|
||
"""
|
||
CH: 2^ℵ₀ = ℵ₁
|
||
|
||
Results:
|
||
- Gödel (1940): CH consistent with ZFC (using L, constructible universe)
|
||
- Cohen (1963): ¬CH consistent with ZFC (using forcing)
|
||
- Therefore: CH independent of ZFC
|
||
"""
|
||
return {
|
||
'statement': '2^ℵ₀ = ℵ₁',
|
||
'status': 'independent of ZFC',
|
||
'models': {
|
||
'L (constructible universe)': 'CH holds',
|
||
'forcing extensions': '¬CH can hold (e.g., 2^ℵ₀ = ℵ₂)'
|
||
}
|
||
}</code></pre>
|
||
<h3>Pattern 3: Borel Hierarchy</h3>
|
||
<p><strong>Σ⁰_n, Π⁰_n</strong>: Levels of definability for subsets of ℝ</p>
|
||
<pre><code class="lang-python">class BorelHierarchy:
|
||
"""
|
||
Borel sets hierarchy:
|
||
- Σ⁰₁ = open sets
|
||
- Π⁰₁ = closed sets (complements of Σ⁰₁)
|
||
- Σ⁰₂ = countable unions of Π⁰₁
|
||
- Π⁰₂ = countable intersections of Σ⁰₁
|
||
- ...
|
||
"""
|
||
|
||
@staticmethod
|
||
def is_sigma_0_1(description: str) -> bool:
|
||
"""Check if set is Σ⁰₁ (open)"""
|
||
return 'union of open intervals' in description
|
||
|
||
@staticmethod
|
||
def is_pi_0_1(description: str) -> bool:
|
||
"""Check if set is Π⁰₁ (closed)"""
|
||
return 'complement of open set' in description or 'closed' in description
|
||
|
||
@staticmethod
|
||
def is_sigma_0_2(description: str) -> bool:
|
||
"""Check if set is Σ⁰₂"""
|
||
return 'countable union of closed sets' in description</code></pre>
|
||
<hr>
|
||
<h2>Quick Reference</h2>
|
||
<h3>Cardinality Comparisons</h3>
|
||
<p>| Set | Cardinality | Symbol | |-----|------------|--------| | ℕ | Countable | ℵ₀ | | ℤ | Countable | ℵ₀ | | ℚ | Countable | ℵ₀ | | ℝ | Continuum | 2^ℵ₀ | | 𝒫(ℕ) | Continuum | 2^ℵ₀ | | ℝ^ℕ | Uncountable | 2^ℵ₀ |</p>
|
||
<h3>Ordinal Arithmetic</h3>
|
||
<pre><code>Addition (not commutative):
|
||
1 + ω = ω
|
||
ω + 1 = ω + 1 (≠ ω)
|
||
|
||
Multiplication (not commutative):
|
||
2 · ω = ω
|
||
ω · 2 = ω + ω (≠ ω)
|
||
|
||
Exponentiation:
|
||
ω^2 = ω · ω
|
||
2^ω = sup{2^n : n < ω} = ω</code></pre>
|
||
<h3>ZFC Independence Results</h3>
|
||
<p>| Statement | Status | |-----------|--------| | Continuum Hypothesis (CH) | Independent | | Axiom of Choice (AC) | Independent of ZF | | Generalized CH (GCH) | Independent |</p>
|
||
<hr>
|
||
<h2>Anti-Patterns</h2>
|
||
<p>❌ <strong>Treating ordinals like cardinals</strong>: ω + 1 ≠ 1 + ω as ordinals ✅ Ordinal arithmetic is not commutative</p>
|
||
<p>❌ <strong>Assuming CH is provable</strong>: CH independent of ZFC ✅ Some models satisfy CH, others don't</p>
|
||
<p>❌ <strong>Confusing ∈ and ⊆</strong>: For ordinals, α ∈ β iff α ⊂ β (proper subset) ✅ In von Neumann ordinals, ∈ and < coincide</p>
|
||
<p>❌ <strong>Assuming all sets are countable</strong>: ℝ is uncountable by Cantor's theorem ✅ Use diagonal argument to prove uncountability</p>
|
||
<hr>
|
||
<h2>Related Skills</h2>
|
||
<ul><li><code>abstract-algebra.md</code> - Algebraic structures built on sets</li><li><code>number-theory.md</code> - Properties of specific sets (ℕ, ℤ, ℚ)</li><li><code>topology-point-set.md</code> - Topological spaces on sets</li><li><code>category-theory-foundations.md</code> - Category of sets</li><li><code>formal/lean-mathlib4.md</code> - Formalizing set theory in Lean</li></ul>
|
||
<hr>
|
||
<p><strong>Last Updated</strong>: 2025-10-25 <strong>Format Version</strong>: 1.0 (Atomic)</p>
|
||
<footer>
|
||
<div class="fmap">
|
||
<div><b>Build</b>
|
||
<a href="https://hanzo.app">hanzo.app</a> app builder
|
||
<a href="https://hanzo.codes">hanzo.codes</a> code with an agent
|
||
<a href="https://hanzoskills.com">hanzoskills.com</a> what an agent reads</div>
|
||
<div><b>Run</b>
|
||
<a href="https://console.hanzo.ai">console.hanzo.ai</a> cloud console
|
||
<a href="https://api.hanzo.ai">api.hanzo.ai</a> the API</div>
|
||
<div><b>Account</b>
|
||
<a href="https://hanzo.id">hanzo.id</a> sign in
|
||
<a href="https://pay.hanzo.ai">pay.hanzo.ai</a> top up
|
||
<a href="https://billing.hanzo.ai">billing.hanzo.ai</a> invoices and usage</div>
|
||
<div><b>Company</b>
|
||
<a href="https://hanzo.ai">hanzo.ai</a> canonical
|
||
<a href="https://hanzo.ventures">hanzo.ventures</a> ventures</div>
|
||
</div>
|
||
<div class="fend"><a href="/set-theory.md">This page as plain text</a> · <a href="/llms.txt">Index for agents</a></div>
|
||
</footer>
|
||
</div></body></html> |