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]>
519 lines
26 KiB
HTML
519 lines
26 KiB
HTML
<!doctype html>
|
||
<html lang="en"><head>
|
||
<meta charset="utf-8"><meta name="viewport" content="width=device-width,initial-scale=1">
|
||
<title>topology-point-set</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="/topology-point-set.md">
|
||
|
||
<link rel="icon" href="/favicon.svg">
|
||
<link rel="canonical" href="https://hanzoskills.com/topology-point-set">
|
||
</head>
|
||
<!-- Reading this with a machine? Every page here is also plain markdown.
|
||
This one: https://hanzoskills.com/topology-point-set.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>topology-point-set</h1><p class="lede">Point-set topology, metric spaces, open/closed sets, continuity, compactness, separation axioms</p><h1>Point-Set Topology</h1>
|
||
<p><strong>Scope</strong>: General topology, metric spaces, topological properties, continuity <strong>Lines</strong>: ~400 <strong>Last Updated</strong>: 2025-10-25</p>
|
||
<h2>When to Use This Skill</h2>
|
||
<p>Activate this skill when:</p>
|
||
<ul><li>Understanding continuity and convergence in abstract spaces</li><li>Working with metric spaces and generalizations</li><li>Studying compactness and connectedness properties</li><li>Proving topological theorems (separation axioms, Urysohn's lemma)</li><li>Preparing for algebraic topology or differential geometry</li><li>Analyzing properties invariant under homeomorphisms</li></ul>
|
||
<h2>Core Concepts</h2>
|
||
<h3>Topological Spaces</h3>
|
||
<p><strong>Definition</strong>: A topological space (X, τ) consists of a set X and a collection τ of subsets (open sets) satisfying:</p>
|
||
<ul><li>∅ and X are in τ</li><li>Arbitrary unions of sets in τ are in τ</li><li>Finite intersections of sets in τ are in τ</li></ul>
|
||
<p><strong>Open and closed sets</strong>:</p>
|
||
<pre><code class="lang-python"># Conceptual Python representation
|
||
class TopologicalSpace:
|
||
def __init__(self, points, open_sets):
|
||
self.X = set(points)
|
||
self.tau = set(frozenset(s) for s in open_sets)
|
||
|
||
# Verify topology axioms
|
||
assert frozenset() in self.tau # Empty set
|
||
assert frozenset(self.X) in self.tau # Whole space
|
||
|
||
def is_open(self, subset):
|
||
return frozenset(subset) in self.tau
|
||
|
||
def is_closed(self, subset):
|
||
# Closed if complement is open
|
||
complement = self.X - set(subset)
|
||
return frozenset(complement) in self.tau
|
||
|
||
def interior(self, subset):
|
||
# Largest open set contained in subset
|
||
interior_pts = set()
|
||
for pt in subset:
|
||
# Check if pt has open neighborhood in subset
|
||
for open_set in self.tau:
|
||
if pt in open_set and open_set.issubset(subset):
|
||
interior_pts.add(pt)
|
||
break
|
||
return interior_pts
|
||
|
||
def closure(self, subset):
|
||
# Smallest closed set containing subset
|
||
# Intersection of all closed sets containing subset
|
||
closed_sets = []
|
||
for candidate in self._all_subsets():
|
||
if self.is_closed(candidate) and set(subset).issubset(candidate):
|
||
closed_sets.append(candidate)
|
||
return set.intersection(*closed_sets) if closed_sets else set()</code></pre>
|
||
<h3>Metric Spaces</h3>
|
||
<p><strong>Definition</strong>: A metric space (X, d) with distance function d: X × X → ℝ satisfying:</p>
|
||
<ul><li>d(x, y) ≥ 0, d(x, y) = 0 iff x = y</li><li>d(x, y) = d(y, x)</li><li>d(x, z) ≤ d(x, y) + d(y, z) (triangle inequality)</li></ul>
|
||
<p><strong>Metric induces topology</strong>:</p>
|
||
<pre><code class="lang-python">import numpy as np
|
||
|
||
class MetricSpace:
|
||
def __init__(self, points, metric):
|
||
"""
|
||
points: collection of points
|
||
metric: function (x, y) -> distance
|
||
"""
|
||
self.X = points
|
||
self.metric = metric
|
||
|
||
def open_ball(self, center, radius):
|
||
"""B_r(x) = {y ∈ X : d(x,y) < r}"""
|
||
return {y for y in self.X if self.metric(center, y) < radius}
|
||
|
||
def closed_ball(self, center, radius):
|
||
"""B̄_r(x) = {y ∈ X : d(x,y) ≤ r}"""
|
||
return {y for y in self.X if self.metric(center, y) <= radius}
|
||
|
||
def is_open(self, subset):
|
||
"""
|
||
Subset is open if for each point, there exists an open ball
|
||
centered at that point contained in the subset
|
||
"""
|
||
for pt in subset:
|
||
# Find if there's an epsilon ball around pt in subset
|
||
epsilon = 0.01 # Simplified check
|
||
ball = self.open_ball(pt, epsilon)
|
||
if not ball.issubset(subset):
|
||
# Try smaller balls...
|
||
found = False
|
||
for eps in [0.1, 0.01, 0.001]:
|
||
if self.open_ball(pt, eps).issubset(subset):
|
||
found = True
|
||
break
|
||
if not found:
|
||
return False
|
||
return True
|
||
|
||
# Example: Euclidean metric on ℝ²
|
||
def euclidean_metric(p1, p2):
|
||
return np.sqrt(sum((a - b)**2 for a, b in zip(p1, p2)))
|
||
|
||
points_2d = [(x, y) for x in range(-5, 6) for y in range(-5, 6)]
|
||
R2 = MetricSpace(points_2d, euclidean_metric)
|
||
|
||
# Open ball around origin with radius 2
|
||
ball = R2.open_ball((0, 0), 2)
|
||
print(f"Open ball B_2(0): {len(ball)} points")</code></pre>
|
||
<h3>Continuity</h3>
|
||
<p><strong>Definition</strong>: Function f: X → Y between topological spaces is continuous if:</p>
|
||
<ul><li>For every open set V in Y, the preimage f⁻¹(V) is open in X</li></ul>
|
||
<p><strong>Equivalent characterizations</strong>:</p>
|
||
<pre><code class="lang-python">class ContinuousMap:
|
||
def __init__(self, domain, codomain, func):
|
||
self.X = domain # TopologicalSpace
|
||
self.Y = codomain # TopologicalSpace
|
||
self.f = func
|
||
|
||
def preimage(self, subset_Y):
|
||
"""f⁻¹(V) = {x ∈ X : f(x) ∈ V}"""
|
||
return {x for x in self.X.X if self.f(x) in subset_Y}
|
||
|
||
def is_continuous(self):
|
||
"""Check if preimage of every open set is open"""
|
||
for open_Y in self.Y.tau:
|
||
preim = self.preimage(open_Y)
|
||
if not self.X.is_open(preim):
|
||
return False
|
||
return True
|
||
|
||
def is_continuous_at_point(self, x0, epsilon=0.01):
|
||
"""
|
||
For metric spaces: continuous at x0 if
|
||
∀ε>0 ∃δ>0: d_X(x,x0)<δ ⟹ d_Y(f(x),f(x0))<ε
|
||
"""
|
||
# Simplified epsilon-delta check
|
||
for delta in [0.1, 0.01, 0.001]:
|
||
neighborhood_x = self.X.open_ball(x0, delta)
|
||
images = {self.f(x) for x in neighborhood_x}
|
||
# Check if all images are within epsilon of f(x0)
|
||
if all(self.Y.metric(self.f(x0), y) < epsilon for y in images):
|
||
return True
|
||
return False
|
||
|
||
# Example: f(x) = x² on ℝ
|
||
def square(x):
|
||
return x * x
|
||
|
||
R = MetricSpace(range(-10, 11), lambda x, y: abs(x - y))
|
||
f = ContinuousMap(R, R, square)
|
||
print(f"f(x)=x² continuous at 0: {f.is_continuous_at_point(0)}")</code></pre>
|
||
<h3>Compactness</h3>
|
||
<p><strong>Definitions</strong>:</p>
|
||
<ul><li><strong>Cover</strong>: Collection of sets whose union contains the space</li><li><strong>Compact</strong>: Every open cover has a finite subcover</li><li><strong>Sequentially compact</strong>: Every sequence has a convergent subsequence</li></ul>
|
||
<p><strong>Heine-Borel Theorem</strong>: In ℝⁿ, compact ⟺ closed and bounded</p>
|
||
<pre><code class="lang-python">def is_compact_finite(space, subset):
|
||
"""
|
||
Check compactness for finite spaces (finite open covers)
|
||
Compact: every open cover has finite subcover
|
||
"""
|
||
# Generate all possible open covers
|
||
from itertools import combinations, chain
|
||
|
||
subset_frozen = frozenset(subset)
|
||
|
||
# All open sets that intersect subset
|
||
relevant_opens = [s for s in space.tau if s & subset_frozen]
|
||
|
||
# Check if any finite subcollection covers subset
|
||
for size in range(1, len(relevant_opens) + 1):
|
||
for cover_attempt in combinations(relevant_opens, size):
|
||
union = set().union(*cover_attempt)
|
||
if subset_frozen.issubset(union):
|
||
# Found finite subcover!
|
||
return True, cover_attempt
|
||
|
||
return False, None
|
||
|
||
# Example: [0, 1] is compact, (0, 1) is not
|
||
# Simplified discrete approximation
|
||
interval_closed = set(i/10 for i in range(0, 11)) # [0, 1]
|
||
interval_open = set(i/10 for i in range(1, 10)) # (0, 1) approximation</code></pre>
|
||
<h3>Connectedness</h3>
|
||
<p><strong>Definition</strong>: Space X is connected if it cannot be written as union of two disjoint non-empty open sets</p>
|
||
<p><strong>Path-connected</strong>: Any two points can be joined by a continuous path</p>
|
||
<pre><code class="lang-python">def is_connected(space):
|
||
"""
|
||
Space is connected if only clopen (closed and open) sets are ∅ and X
|
||
Equivalently: no separation into two disjoint non-empty open sets
|
||
"""
|
||
X = space.X
|
||
|
||
# Try to find separation
|
||
for A_candidate in space._all_subsets():
|
||
if not A_candidate or A_candidate == X:
|
||
continue
|
||
|
||
B_candidate = X - A_candidate
|
||
|
||
# Check if A and B are both open (separation)
|
||
if space.is_open(A_candidate) and space.is_open(B_candidate):
|
||
return False # Found separation, not connected
|
||
|
||
return True # No separation found
|
||
|
||
def is_path_connected(metric_space, path_finder):
|
||
"""
|
||
Check if any two points can be connected by continuous path
|
||
path_finder: function(p1, p2) -> path or None
|
||
"""
|
||
points_list = list(metric_space.X)
|
||
|
||
# Sample pairs of points
|
||
for i, p1 in enumerate(points_list[:5]): # Sample for efficiency
|
||
for p2 in points_list[i+1:i+6]:
|
||
path = path_finder(p1, p2)
|
||
if path is None:
|
||
return False
|
||
return True</code></pre>
|
||
<hr>
|
||
<h2>Patterns</h2>
|
||
<h3>Pattern 1: Separation Axioms</h3>
|
||
<p><strong>T0 (Kolmogorov)</strong>: For distinct points x, y, ∃ open set containing one but not other <strong>T1 (Fréchet)</strong>: For distinct points x, y, ∃ open sets separating each <strong>T2 (Hausdorff)</strong>: For distinct points x, y, ∃ disjoint open neighborhoods <strong>T3 (Regular)</strong>: T0 + point and closed set can be separated <strong>T4 (Normal)</strong>: T1 + disjoint closed sets can be separated</p>
|
||
<pre><code class="lang-python">def is_hausdorff(space):
|
||
"""T2: Distinct points have disjoint neighborhoods"""
|
||
for x in space.X:
|
||
for y in space.X:
|
||
if x == y:
|
||
continue
|
||
|
||
# Find disjoint open neighborhoods
|
||
found_separation = False
|
||
for U in space.tau:
|
||
if x not in U:
|
||
continue
|
||
for V in space.tau:
|
||
if y not in V:
|
||
continue
|
||
if U.isdisjoint(V):
|
||
found_separation = True
|
||
break
|
||
if found_separation:
|
||
break
|
||
|
||
if not found_separation:
|
||
return False
|
||
return True</code></pre>
|
||
<h3>Pattern 2: Bases and Subbases</h3>
|
||
<p><strong>Base</strong>: Collection β where every open set is union of sets in β</p>
|
||
<pre><code class="lang-python">def generates_topology(space, base):
|
||
"""Check if base generates the topology"""
|
||
# Every open set should be union of base elements
|
||
for open_set in space.tau:
|
||
if not open_set: # Empty set
|
||
continue
|
||
|
||
# Try to write open_set as union of base elements
|
||
union = set()
|
||
for B in base:
|
||
if B.issubset(open_set):
|
||
union |= B
|
||
|
||
if union != open_set:
|
||
return False
|
||
return True
|
||
|
||
# Standard base for ℝ: open intervals (a, b)</code></pre>
|
||
<h3>Pattern 3: Product Topology</h3>
|
||
<p><strong>Product</strong>: If (X, τ_X) and (Y, τ_Y) are topological spaces, product topology on X × Y has base {U × V : U ∈ τ_X, V ∈ τ_Y}</p>
|
||
<pre><code class="lang-python">def product_topology(space1, space2):
|
||
"""Construct product topology X × Y"""
|
||
# Cartesian product of underlying sets
|
||
product_points = {(x, y) for x in space1.X for y in space2.X}
|
||
|
||
# Base: products of open sets
|
||
base = set()
|
||
for U in space1.tau:
|
||
for V in space2.tau:
|
||
product_set = frozenset((x, y) for x in U for y in V)
|
||
base.add(product_set)
|
||
|
||
# Generate topology from base (all unions)
|
||
topology = set(base)
|
||
# Add arbitrary unions...
|
||
|
||
return TopologicalSpace(product_points, topology)</code></pre>
|
||
<hr>
|
||
<h2>Quick Reference</h2>
|
||
<h3>Key Definitions</h3>
|
||
<p>| Concept | Definition | Example | |---------|------------|---------| | Open set | Member of topology τ | (a, b) in ℝ | | Closed set | Complement is open | [a, b] in ℝ | | Interior | Largest open subset | int([0,1]) = (0,1) | | Closure | Smallest closed superset | cl((0,1)) = [0,1] | | Continuous | Preimage of open is open | f: ℝ → ℝ, f(x)=x² | | Compact | Every open cover has finite subcover | [0,1], S¹ | | Connected | No separation into disjoint opens | ℝ, intervals | | Hausdorff | Distinct points have disjoint nbhds | Metric spaces |</p>
|
||
<h3>Metric Space Properties</h3>
|
||
<pre><code class="lang-python"># Common metrics
|
||
euclidean = lambda p, q: np.sqrt(sum((a-b)**2 for a,b in zip(p,q)))
|
||
manhattan = lambda p, q: sum(abs(a-b) for a,b in zip(p,q))
|
||
discrete = lambda p, q: 0 if p == q else 1</code></pre>
|
||
<h3>Topological Invariants</h3>
|
||
<p>Properties preserved by homeomorphisms:</p>
|
||
<ul><li>Compactness</li><li>Connectedness</li><li>Path-connectedness</li><li>Separation axioms</li><li>Fundamental group (algebraic topology)</li></ul>
|
||
<hr>
|
||
<h2>Anti-Patterns</h2>
|
||
<p>❌ <strong>Confusing open/closed</strong>: Sets can be both (clopen), neither, or just one ✅ In ℝ: (0,1) is open; [0,1] is closed; [0,1) is neither; ℝ is clopen</p>
|
||
<p>❌ <strong>Assuming metric space properties</strong>: Not all topological spaces have metrics ✅ Indiscrete topology: τ = {∅, X} has no non-trivial metric</p>
|
||
<p>❌ <strong>Conflating compact and closed</strong>: In ℝⁿ compact ⟺ closed + bounded ✅ General spaces: (0,1) is bounded and not compact; ℝ is closed but not compact</p>
|
||
<p>❌ <strong>Ignoring sequential vs topological definitions</strong>: Not equivalent in general ✅ Sequential compactness ⟹ compactness in metric spaces only</p>
|
||
<hr>
|
||
<h2>Related Skills</h2>
|
||
<ul><li><code>topology-algebraic.md</code> - Fundamental groups, homology, homotopy theory</li><li><code>category-theory-foundations.md</code> - Topological spaces as category objects</li><li><code>linear-algebra-computation.md</code> - Metric spaces, norms on vector spaces</li><li><code>numerical-methods.md</code> - Convergence in topological spaces</li><li><code>formal/lean-mathlib4.md</code> - Formalizing topology 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="/topology-point-set.md">This page as plain text</a> · <a href="/llms.txt">Index for agents</a></div>
|
||
</footer>
|
||
</div></body></html> |