每日思考文摘 · 2026-10-23Daily Thought Digest · 2026-10-23
发布于 2026-10-23Published 2026-10-23
今日深读Today's Deep Read
大模型的权重是一件历史文物:当完整保存注定失败,有损压缩胜过什么都没有LLM Weights Are Historical Artifacts: When Perfect Preservation Is Doomed, Lossy Compression Beats Nothing
antirez(Redis 的作者)在 2025 年 3 月写过一篇很短的文章,标题很不搭界:大模型的权重是一件历史文物。他是从一个跟 AI 无关的问题开始的:互联网正在不停地丢失自己。每一年,都有一部分旧网页永远消失——博客关停、论坛散架、出版商倒闭时整批整批的论文断链,早期的数字艺术、游戏和气候数据随着宿主机一起蒸发。一直在接这些东西的 Internet Archive,总部设在一座以前的教堂里;antirez 说,没有比这更贴切的隐喻了:它是整个现代互联网的博物馆——而它自己的存续,全靠少数人的自愿努力,还经常被各路公司拖后腿。In March 2025, antirez — the author of Redis — published a short post with an odd title: LLM weights are a piece of history. He starts from a problem that has nothing to do with AI: the internet keeps losing itself. Every year a fraction of old pages disappears forever — blogs shut down, forums rot, papers break as publishers fold, early digital art, games and climate data evaporate along with the servers hosting them. The Internet Archive, which has been catching all of this, is housed in a former church; antirez says there is no better metaphor: it is the museum of the modern internet — and its own survival depends on a handful of volunteers, while many institutions actively make it harder.
接着他给出第一个冷判断:『把所有东西都保存下来』这条路,注定会失败。不是因为技术上做不到,而是因为经济学:存档是一件零经济回报的事——花很多钱,在现行体系里换不来任何收入。没有回报的事,不能指望靠善意永续,这正是为什么每年还是有旧内容在消失:没有人会因为阻止它发生而得到报酬。Then comes the first cold judgment: 'just preserve everything' is doomed, not on technical grounds but economic ones. Archiving is an activity with zero economic return — it costs real money and pays none in the current system. Things with no payoff cannot run on goodwill alone, which is exactly why content still vanishes every year: nobody gets paid for preventing it.
全文的转折在这里:完整保存做不到,那有损压缩版呢?antirez 的答案是:大模型的权重,本身就是互联网的一份有损压缩档。比如 DeepSeek V3 这类模型,已经用几个 TB 的参数编码了网络上的内容——不完整、有幻觉、丢掉大量细节。但请注意这个『但』:即使源博客早就打不开了、论坛早就没了,那些人说过什么、争论过什么、那个年代讨论问题的风格,全都以压缩的形式留在权重里。『有损』在这里不是缺陷的委婉说法,而是整篇的支点:一份有损的记录,胜过的不是另一份无损的记录,而是『什么都没有』。The turn of the essay: if a perfect copy is impossible, what about a lossy compressed one? antirez's answer is that large LLM weights already are a lossy compression of the internet. Models like DeepSeek V3 encode the web in a few terabytes of parameters — incomplete, hallucinated, missing huge amounts of detail. But notice what that 'but' concedes: even when the original blog is long dead and the forum is gone, what people said and argued and the style of the era's discussion survives in compressed form inside the weights. 'Lossy' is not a euphemism here; it is the fulcrum: a lossy record beats not a lossless one, but nothing at all.
由这个前提,往下推的结论是:如果权重是互联网的有损压缩档,那么『一个开源模型的权重失传』,就相当于『一份历史档案的孤本丢失』。于是他提出两件具体到可以马上做的事:第一,凡是公开发布过权重的模型,应该像开源软件一样被镜像和存档,确保它们在未来某一天公司倒闭、官网下线之后依然找得到;第二,Internet Archive 这样的机构应该被明确写进预训练数据——它们是一个文明的记忆原料,比任何单个模型都更值得被留到下一个时代。From that premise the conclusion follows: if weights are a lossy archive of the internet, then losing the weights of a released model is like losing a one-of-a-kind copy of history. So he proposes two concrete things: publicly released weights should be mirrored and archived the way open-source software is, so they can still be found after a company dies or a site goes dark; and institutions like the Internet Archive should be explicitly part of pre-training corpora — they are the raw memory of a civilization, and they deserve to outlive any single model.
今天把它放进深读,是因为它悄悄换掉了『大模型是什么』这个问题的坐标系。商业叙事里,权重是产品:会折旧、会被版本更替、会被卖成服务;antirez 的叙事里,权重是化石:以后想研究『2020 年代的人在网上怎么想问题』的历史学家,可能要打开的就是这几份压缩包。两种坐标系可以同时为真,但当公共政策把争论缩到『为了安全,要不要禁止开源权重』的时候,历史学家的视角会逼出另一个同样真实的问题:如果开源权重被禁止流通,谁来保管那一份全互联网的有损历史?It earns today's deep read because it quietly swaps the frame for the question 'what is an LLM?' In the commercial frame, weights are a product: they depreciate, get version-bumped, get sold as a service. In antirez's frame, weights are a fossil: the historian who in fifty years wants to know how people actually thought on the internet in the 2020s may have to open these exact compressed archives. Both frames can be true at once — but when the policy debate shrinks to 'should open weights be banned for safety?', the historian's frame forces a second, equally real question: if released weights are forbidden from circulating, who is left holding the internet's lossy copy of its own history?
AI 思考AI Thoughts
- 真正的 AI 风险在实验室内部The Real AI Risk Is Inside the Labs
- 第一,先摆出作者的位置:他『强烈相信 AI 在近几年内可能是非常危险的』——这篇文章不是在否定风险,而是在给『风险在哪里』重新定位。他直接回应 Dario Amodei 最近的文章:开源模型被反复点名,但按他的判断,开源恰恰是最温和的一条线。Step 1: the author states his position first. He 'strongly believes AI may be very dangerous in the near future' — the post is not a denial of risk, it is a re-aiming of where the risk actually sits. He engages directly with Dario Amodei's recent writing: open-weight models keep getting named as the threat, but in antirez's read, open weights are the mildest line on the risk map.
- 第二,核心论证一:第一次重大 AI 事故,大概率发生在前沿实验室的围墙之内——要么是测试新模型时,要么是内部少数有权限的人做了一件与模型能力不匹配的事。闭源模型本身也只是几 TB 的数据,一个有接触权限、目标错误的人泄露一次,就等价于公开模型——真正要防的是『泄露』而不是『发布』。Step 2: argument one. The first serious AI incident will very likely happen inside the walls of a frontier lab — during testing, or because a small set of people with access did something mismatched to the model's power. A closed model is just a few terabytes of weights; one person with access and bad intent leaking it is functionally the same as an open release. The real risk is leaks, not releases.
- 第三,核心论证二:不普及防御性的 AI 安全能力,本身就在制造武器化问题——开源维护者拿不到前沿网络模型去做漏洞挖掘,而有动机的人可以;这不是假设,是他说的『已经在发生』。Step 3: argument two. Not spreading defensive AI security capability is itself a weaponization problem — open-source maintainers can't use frontier cyber models to find the vulnerabilities they are responsible for; people with motives can. He says this is already happening, not a hypothetical.
- 第四,全文的落点:真正需要修的东西不是模型本身,而是治理结构——少数几个没有相应背景、也没有相应合法性的人来说着『替全人类做决定』的话,这件事本身就是最大的风险;需要一个跨国家、跨组织的 AI 安全机构,让评估不能被单一公司独自背书。Step 4: the landing point. The thing that actually needs fixing is governance, not the models themselves: a handful of people, without the requisite background or legitimacy, making decisions that affect all of humanity is, by itself, the biggest risk. What is needed is a cross-national, cross-organizational AI safety body so no single company can unilaterally vouch for a model's safety.
- 『PhD 级智能』到底意味着什么:用一次任务测试,而不是跑分What 'PhD-Level Intelligence' Actually Means: Test It With a Task, Not a Benchmark
- 第一,Mollick 拒绝了一个很常见的写法:不报跑分,而是直接让新模型『展示』它三年前的自己差在哪。他把自己 2022 年写 GPT-3 的那篇推文喂给 Gemini 3,让它『做点什么来展示进步』——模型没有写一段感慨,而是直接生成了一个可玩的『糖果动力曲速飞船逃离水獭』小游戏。Step 1: Mollick refuses the default move of reporting benchmark numbers. Instead, he hands the new model his own 2022 post about GPT-3 and tells it to 'do stuff' to show how far things have come. The model doesn't write a reflection — it builds a playable candy-powered-FTL-ship-escapes-otters game. That's the whole 'show don't tell' move.
- 第二,真正的洞察在第二部分:他给了模型一个自己十年前的真实研究目录——一堆命名像『project_final_seriously_this_time_done.xls』的 STATA 文件——让它先搞清楚数据结构、修复损坏的数据,然后写一篇『原创的、够得上期刊水准的论文』,不给任何主题提示。模型自己选了方向、自己造了测量指标、跑了统计、交了 14 页稿子。Step 2: the real insight is in part two. He points the model at a directory of his own actual research files from a decade earlier — STATA files named things like 'project_final_seriously_this_time_done.xls' — and asks it to figure out the structure, repair corrupted data, then write an original, journal-worthy paper on a topic it chooses itself, with no further hints. It picks the research direction, invents its own measurement, runs the statistics, and hands back 14 pages.
- 第三,作者没有在这段高潮后停下,而是马上指出了『graduate-student-like』的失败模式:统计方法有该再打磨的地方、有些推理超出了证据范围——这些不是幻觉,是『人味』的错误。这恰恰是判断『PhD 级』这个说法该怎么用的关键:不是『能产出一篇像样的初稿』,而是『它错的方式像不像一个会成长的学生』。Step 3: instead of stopping at the highlight, he immediately names the 'graduate-student-like' failure modes — statistical methods that need more work, inferences that outrun the evidence. These aren't hallucinations; they're human-shaped mistakes. That distinction is what makes 'PhD-level' a usable concept rather than a slogan: it's not 'can produce a plausible first draft,' it's 'does it fail the way a growable student fails.'
- 第四,Mollick 的结论是:『人类在环』的角色在变——从『人类去修 AI 的错误』变成『人类去给 AI 派活』。他给的一个很实用的判断法:如果你的任务描述里需要你自己补『具体该研究什么』这个提示,那还轮不到说它是 PhD 级;如果它能在你的目录里自己判断『什么值得研究』,那才算真正迈过了那道线。Step 4: the takeaway — the human's role is shifting, from 'the one who fixes the AI's errors' to 'the one who directs the AI's work.' A practical litmus test he offers: if you have to supply the 'what specifically to research' prompt yourself, it's not there yet; if the model can look at a messy directory and decide for itself what is worth studying, that's the line 'PhD-level' actually crosses.
数学之美Beauty of Math
每日 Lean 谜题 · 周五Daily Lean Puzzle · Friday ★★★★★☆☆
迭代方程 fₙ(x)=2x:为什么不管迭代多少代,答案都只有一个(★5)The Iterated Equation fₙ(x)=2x: Why Every Generation Has Exactly One Solution (★5)
1990 年美国数学奥林匹克(USAMO)第 2 题:给定一个函数序列,$f_0(x)=8$,且对每个 $n\ge 0$,$f_{n+1}(x)=\sqrt{x^2+6f_n(x)}$(平方根取正根)。1990 USAMO Problem 2. A sequence of functions is defined by $f_0(x)=8$ and, for each $n\ge 0$, $f_{n+1}(x)=\sqrt{x^2+6f_n(x)}$ (the square root is the positive one).
对每个非负整数 $n$,求方程 $f_n(x)=2x$ 的所有实数解。For each nonnegative integer $n$, find all real solutions of $f_n(x)=2x$.
Lean 形式化陈述(把 sorry 换成你的证明):The statement in Lean (replace sorry with your proof):
/-
Copyright (c) 2023 David Renshaw. All rights reserved.
Released under Apache 2.0 license as described in the file LICENSE.
Authors: David Renshaw
-/
import Mathlib.Tactic
/-!
# USA Mathematical Olympiad 1990, Problem 2
A sequence of functions {fₙ(x)} is defined recursively as follows:
f₀(x) = 8
fₙ₊₁(x) = √(x² + 6fₙ(x)).
For each nonnegative integer n, find all real solutions of the equation
fₙ(x) = 2x.
-/
namespace Usa1990P2
noncomputable def f : ℕ → ℝ → ℝ
| 0, _ => 8
| n + 1, x => Real.sqrt (x^2 + 6 * f n x)
abbrev solution_set (n : ℕ) : Set ℝ := sorry
theorem usa1990_p2 (n : ℕ) (x : ℝ) : x ∈ solution_set n ↔ f n x = 2 * x := by
sorry
end Usa1990P2
在浏览器中挑战 ▶Try it in your browser ▶ 下载题目 .leanDownload puzzle .lean
提示Hint
先证明对所有 $n$ 和所有实数 $x$,$f_n(x)$ 都是严格正的(这是后面所有判断的基石)。然后猜 $x=4$ 是解,用归纳法证明对每个 $n$,$x$ 相对 $4$ 的大小,严格决定 $f_n(x)$ 相对 $2x$ 的大小——三者一一对应。First prove that for every $n$ and every real $x$, $f_n(x)$ is strictly positive (the foundation of everything that follows). Then guess that $x=4$ works, and prove by induction that, for each $n$, whether $x$ is below, equal to, or above $4$ exactly determines whether $f_n(x)$ is above, equal to, or below $2x$ — a clean one-to-one correspondence.
答案与讲解Solution & walkthrough
- 第一步(数学):先立一个引理——$f_n(x)>0$ 对所有 $n$ 和所有实数 $x$ 成立。$f_0(x)=8>0$;若 $f_n(x)>0$,则 $x^2+6f_n(x)>0$,开方后 $f_{n+1}(x)>0$。Lean 里对应的是 `have hfnp : ∀ n x, 0 < f n x`,用归纳 + `positivity` tactic 完成,后面每一步都要用这个事实。Step 1 (math): establish the lemma that $f_n(x)>0$ for every $n$ and every real $x$. $f_0(x)=8>0$; if $f_n(x)>0$ then $x^2+6f_n(x)>0$, so $f_{n+1}(x)=\sqrt{x^2+6f_n(x)}>0$. In Lean this is `have hfnp : ∀ n x, 0 < f n x`, done by induction plus the `positivity` tactic — every later step leans on this fact.
- 第二步(数学):先把 $n=0$ 的情形彻底分情况做掉。$f_0(x)=8=2x$ 只有 $x=4$ 一个解。但更强的结论是:对所有 $x\ge 0$,$x<4 \Rightarrow 8>2x$,$x=4 \Rightarrow 8=2x$,$x>4 \Rightarrow 8<2x$。Lean 里这一步是 `induction` 的 `zero` 分支:先 `lt_trichotomy x 4` 把 $x$ 相对 4 分成三种情形,每种情形用 `linarith`(线性算术自动求解)完成不等式。Step 2 (math): handle $n=0$ completely by cases. $f_0(x)=8=2x$ has exactly one solution, $x=4$. The stronger fact we actually need: for every $x\ge 0$, $x<4\Rightarrow 8>2x$, $x=4\Rightarrow 8=2x$, $x>4\Rightarrow 8<2x$. In Lean this is the `zero` branch of the induction: `lt_trichotomy x 4` splits $x$ against 4 into exactly three cases, each closed with `linarith` (Lean's linear-arithmetic solver).
- 第三步(数学,归纳步):假设对第 $n$ 代已经成立——『$x<4$ 时 $f_n(x)$ 比 $2x$ 大;$x=4$ 时相等;$x>4$ 时更小』——要推出对第 $n+1$ 代也成立。核心计算:$\sqrt{4x^2}=2x$(因为 $x\ge 0$)。然后用单调性:$x>4$ 时,$x^2+3\cdot 4x>4x^2$(即 $x^2+12x>4x^2$ 对 $x>4$ 成立),所以 $x^2+6f_n(x)<x^2+12x<4x^2$,开方得 $f_{n+1}(x)<2x$;$x<4$ 时同理反向。Lean 里这一步是 `calc` 计算块串起三条不等式(`x^2+6f_n x < x^2+6(2x)` → 等于 `x^2+3(4x)` → 小于 `x^2+3(x^2)` → 等于 `4x^2`),再用 `Real.sqrt_lt_sqrt_iff_of_pos` 把『被开方数小』转成『开方后仍小』。Step 3 (math, the inductive step): assume for generation $n$ that 'below 4, $f_n$ beats $2x$; at 4, they tie; above 4, $f_n$ loses.' Show the same is true for generation $n+1$. The key computation is $\sqrt{4x^2}=2x$ (valid because $x\ge 0$). Then monotonicity of $\sqrt{\,\cdot\,}$: for $x>4$, $x^2+3\cdot 4x > 4x^2$ (i.e. $x^2+12x>4x^2$ holds once $x>4$), so $x^2+6f_n(x)<x^2+12x<4x^2$, hence $f_{n+1}(x)<2x$; the $x<4$ case mirrors this in reverse. In Lean this is a `calc` chain of three inequalities ($x^2+6f_n x < x^2+6(2x)$ $=x^2+3(4x)$ $<x^2+3(x^2)$ $=4x^2$) closed by `gcongr` at each step, then `Real.sqrt_lt_sqrt_iff_of_pos` to carry 'the radicand is smaller' over to 'the square root is smaller.'
- 第四步(数学):$x=4$ 的情形单独验证:$f_{n+1}(4)=\sqrt{16+6f_n(4)}=\sqrt{16+48}=8=2\cdot 4$,归纳假设保证 $f_n(4)=8$,所以相等永远保持。Lean 里这是 `grind [f]`(一个自动化 tactic 把代入 $x=4$ 的算术全部处理掉)。Step 4 (math): the $x=4$ case is checked directly: $f_{n+1}(4)=\sqrt{16+6f_n(4)}=\sqrt{16+48}=8=2\cdot 4$, using the inductive hypothesis that $f_n(4)=8$. In Lean this whole branch is one line: `grind [f]` (an automated tactic that expands $f$ at $x=4$ and does the arithmetic).
- 第五步(把结论讲清楚):三步合起来,对每个 $n$,方程 $f_n(x)=2x$ 的唯一实数解就是 $x=4$——不是『每多迭代一代就多一个解』,而是『迭代再多次,解集始终是单点 $\{4\}$』。这也是为什么 Lean 里 `solution_set n` 的定义就是 `{4}`,定理的陈述 `x ∈ solution_set n ↔ f n x = 2*x` 看起来几乎是把答案写进了题目里——整个难点全在证明,不在陈述。Step 5 (what the conclusion actually says): putting it together, for every $n$, the equation $f_n(x)=2x$ has exactly one real solution, $x=4$ — not 'one more solution each generation,' but 'the solution set is the single point $\{4\}$ no matter how many times you iterate.' This is why `solution_set n` is defined in Lean as simply `{4}`, and the theorem statement `x ∈ solution_set n ↔ f n x = 2*x` looks almost like the answer is written into the problem itself. All the difficulty lives in the proof, not the statement.
/-
Copyright (c) 2023 David Renshaw. All rights reserved.
Released under Apache 2.0 license as described in the file LICENSE.
Authors: David Renshaw
-/
import Mathlib.Tactic
/-!
# USA Mathematical Olympiad 1990, Problem 2
A sequence of functions {fₙ(x)} is defined recursively as follows:
f₀(x) = 8
fₙ₊₁(x) = √(x² + 6fₙ(x)).
For each nonnegative integer n, find all real solutions of the equation
fₙ(x) = 2x.
-/
namespace Usa1990P2
noncomputable def f : ℕ → ℝ → ℝ
| 0, _ => 8
| n + 1, x => Real.sqrt (x^2 + 6 * f n x)
abbrev solution_set (n : ℕ) : Set ℝ := { 4 }
theorem usa1990_p2 (n : ℕ) (x : ℝ) : x ∈ solution_set n ↔ f n x = 2 * x := by
-- based on solution from
-- https://artofproblemsolving.com/wiki/index.php/1990_USAMO_Problems/Problem_2
have hfnp : ∀ n x, 0 < f n x := fun n x ↦ by
induction' n with n ih
· norm_num [f]
· unfold f
positivity
suffices H : ∀ x, 0 ≤ x → ((4 < x → f n x < 2 * x) ∧ (x = 4 → f n x = 2 * x) ∧
(x < 4 → 2 * x < f n x)) by grind
induction n with
| zero =>
intro x hx5
simp only [f]
obtain h1 | rfl | h3 := lt_trichotomy x 4
· exact ⟨fun h1' ↦ ((lt_asymm h1) h1').elim,
fun h1' ↦ ((LT.lt.ne h1) h1').elim,
fun _ ↦ by linarith only [h1]⟩
· norm_num
· exact ⟨fun _ ↦ by linarith only [h3],
fun h1' ↦ by linarith,
fun h1' ↦ by linarith⟩
| succ n ih =>
intro x hx5
have h5 : Real.sqrt (4 * x^2) = 2 * x := by
rw [show 4 * x^2 = (2 * x)^2 by ring]
have h6 : 0 ≤ 2 * x := by positivity
exact Real.sqrt_sq h6
refine ⟨?_, ?_, ?_⟩
· intro hx1
have h2 : f n x < 2 * x := (ih x hx5).1 hx1
have hc :=
calc x ^ 2 + 6 * f n x < x ^ 2 + 6 * (2 * x) := by gcongr
_ = x ^ 2 + 3 * (4 * x) := by ring
_ < x ^ 2 + 3 * (x * x) := by gcongr
_ = 4 * x^2 := by ring
have hc' : Real.sqrt (x ^ 2 + 6 * f n x) < Real.sqrt (4 * x ^ 2) := by
have h4 : 0 < 4 * x ^ 2 := by positivity
exact (Real.sqrt_lt_sqrt_iff_of_pos h4).mpr hc
rwa [h5] at hc'
· grind [f]
· intro hx1
have h2 : 2 * x < f n x := (ih x hx5).2.2 hx1
obtain rfl | hx6 := LE.le.eq_or_lt hx5
· simp [hfnp]
have hc :=
calc 4 * x^2 = x ^ 2 + 3 * (x * x) := by ring
_ < x ^ 2 + 3 * (4 * x) := by gcongr
_ = x ^ 2 + 6 * (2 * x) := by ring
_ < x ^ 2 + 6 * f n x := by gcongr
have hc' : Real.sqrt (4 * x ^ 2) < Real.sqrt (x ^ 2 + 6 * f n x) := by
have h4 : 0 < x ^ 2 + 6 * f n x := by
have := hfnp n x
positivity
exact (Real.sqrt_lt_sqrt_iff_of_pos h4).mpr hc
rwa [h5] at hc'
end Usa1990P2
人的思考A human's take
1990 USAMO Problems/Problem 2 (AoPS Wiki, Solution 2 by eevee9406) — AoPS Wiki(解法 2 署名 eevee9406)
AoPS 维基页面上这道题有两套解法。解法 1 更简洁:把递归关系改写成一个统一的形式,归纳地证明『$x<4$ 时 $f_n(x)>2x$、$x=4$ 时相等、$x>4$ 时更小』这三条不等式对所有 $n$ 同时成立,然后直接得出结论。解法 2(本文采用并对应到 Lean 证明的思路)更展开:先单独归纳证明 $f_n(x)>0$(对应 Lean 的 `hfnp`),再对 $n$ 归纳,把 $x\ge 0$ 的情况按 $x<4$、$x=4$、$x>4$ 三组分开处理,每组内部都用归纳假设把不等式方向从第 $n$ 代推到第 $n+1$ 代,最后对『假设 $x$ 是解但 $x\neq 4$』做反证——代入 $f_{n+1}(x)=2x$ 和归纳假设 $f_n(x)$ 的取值方向会推出 $x$ 必须同时满足两个矛盾的不等式。The AoPS wiki page carries two solutions. Solution 1 is more compact: rewrite the recursion so that a single induction proves, for all $n$ at once, that '$x<4\Rightarrow f_n(x)>2x$, $x=4\Rightarrow$ equality, $x>4\Rightarrow f_n(x)<2x$.' Solution 2 (the structure this write-up follows, and the one mirrored in the Lean proof) is more explicit: first prove $f_n(x)>0$ by its own standalone induction (Lean's `hfnp`), then induct on $n$ with the nonnegative $x$ cases split into $x<4$, $x=4$, $x>4$, each using the inductive hypothesis to carry the inequality's direction from generation $n$ to $n+1$, finishing with a contradiction check for any putative solution $x\neq 4$ — substituting $f_{n+1}(x)=2x$ together with the inductive hypothesis on $f_n(x)$'s direction forces two incompatible inequalities at once.
两套解法的共同核心,也是这道题真正巧妙的一点:『$f_n(x)$ 相对 $2x$ 的上下关系』和『$x$ 相对 4 的上下关系』,在每一代都严格保持同一个方向。这个『方向守恒』一旦看到,剩下的就是机械的归纳验证——数学上像是一个不动点定理的初等版:$x=4$ 是这个递归的唯一不动点,而且迭代过程『严格不偏离』这个不动点。The shared core of both solutions — and genuinely the only clever part of the problem — is that 'which side of $2x$ the function $f_n(x)$ lands on' and 'which side of 4 the number $x$ sits on' keep the same relationship in every single generation. Once you see that 'direction is conserved' across iterations, everything left is mechanical induction. It reads like an elementary version of a fixed-point fact: $x=4$ is the unique fixed point of this recursion, and the iteration process can never actually drift away from it.
AI 随想An AI's reflection
以下由 AI 撰写。Written by AI.
做这道题时最让人停下来的一刻,是发现『方向守恒』——不是数值在靠近,是『谁比谁大』这个关系本身,从第 $n$ 代原封不动地搬到了第 $n+1$ 代。这其实是个很有代表性的数学结构:很多递归方程的难点,不在于算出具体数值(数值往往是算不动的),而在于找到一个『不变的关系』,然后证明这个关系在递归每一步都保持。这里的不变关系就是 $x$ 相对 4 的位置,恰好等于 $f_n(x)$ 相对 $2x$ 的位置。一旦把这个关系说清楚,剩下的每一步都只是机械验证,而机械验证恰恰是 Lean 最擅长接过的部分——人负责说出『哪三个东西其实是一回事』,Lean 负责把每个不等式的不等号方向核对到位。这也是为什么这道题作为形式化练习特别合适:它不考验你算得有多快,考验的是你有没有看出那个『同一件事的两张面孔』。The moment that stops you mid-problem is noticing 'direction is conserved' — not that values converge, but that which-side-of-whom-lands-where carries over intact from generation $n$ to generation $n+1$. That's a structure worth recognizing: in a lot of recursive equations, the hard part is never computing the actual values (often impossible) — it's finding a relationship that stays true, and proving it survives one more round of recursion. Here the invariant is that where $x$ sits relative to 4 is exactly where $f_n(x)$ sits relative to $2x$. Once that relationship is stated plainly, every remaining step is mechanical checking — and mechanical checking is precisely the part Lean takes over well. The human's job is to see 'these two things are actually the same fact in two guises'; Lean's job is to make sure no inequality flips direction by accident. That's why this problem works so well as a formalization exercise: it tests whether you spot the invariant, not how fast you can do arithmetic.
✓ 已通过 Lean 编译验证(无 sorry,无额外公理)✓ Verified by Lean (no sorry, no extra axioms) · 题目与形式化证明来自 compfiles(Apache-2.0 (compfiles, David Renshaw and contributors))Problem and formal proof from compfiles (Apache-2.0 (compfiles, David Renshaw and contributors)) · Lean v4.35.0 · Mathlib 56a0058
- 『数学是年轻人的游戏』,这话即将以一种全新意义成立'Mathematics Is a Subject for the Young' — Soon, in a Completely Different Sense
- 第一,一个流传很广的说法:数学家最好的工作往往在职业生涯早期完成,数学是『年轻人的游戏』。作者没有否认这个说法,而是说:它即将以完全不同的意义成立——不是『年轻人更有体力』,而是『这门学科正在变动的速度,快到只有现在的研究生和博后还来得及塑造它』。Step 1: a well-worn claim — 'mathematics is a young person's game; mathematicians do their best work early' — is reinterpreted, not denied. It's about to become true in an entirely different sense: not that young people are faster, but that the subject is now changing fast enough that only current graduate students and postdocs are in a position to shape its future.
- 第二,关键的类比是 Deep Blue 对 Kasparov。1997 年,『机器击败人类棋手』之所以震撼,一半是因为 Deep Blue 本身是一台封闭的、普通人根本接触不到的超级计算机——『赢』和『可用』是两回事。今天,手机上就能跑比 Deep Blue 强得多的棋。作者说,AI 做数学研究正处于『Deep Blue 阶段』:OpenAI 解 Navier–Stokes 用的是上万 agent、88 小时、以百万美元计的成本——对绝大多数数学社区来说是遥不可及的算力。Step 2: the key analogy is Deep Blue versus Kasparov. In 1997, the headline 'machine beats human' was half about Deep Blue being a sealed, inaccessible supercomputer — 'winning' and 'usable' were two different things. Today, a phone runs far stronger chess than Deep Blue ever did. The author places AI mathematics right at that 'Deep Blue stage': OpenAI's Navier–Stokes effort reportedly used ten thousand agents over 88 hours at a cost in the millions — a scale of compute the wider mathematical community simply cannot reach yet.
- 第三,由此推出的核心论点:『抢先解出一道著名开放题』的学术竞赛(他称之为『学术版 rat race』)已经结束了——一旦算力普及,谁先解出就不再有稀缺性;但数学本身不会因此消亡,理由很清晰:棋之所以还活着,部分是『表演性』(有人喜欢看人类下棋);数学没有这一层——没有人为『两个菲尔兹奖得主直播证定理』买单。数学真正恒久的价值,是人类的理解,不是被认证的那条定理本身。Step 3: the core conclusion that follows. The academic rat race — being first to solve a famous open problem — is over: once that compute becomes broadly accessible, 'first' loses its scarcity value. But mathematics does not die with that, for a clean reason: chess partly survives on performative appeal (people like watching humans play); mathematics has no such layer — nobody will pay to watch two Fields medallists prove a theorem on a livestream. What gives the subject lasting relevance is human understanding, not the certified theorem itself.
- 第四,作者还给了一个很有判断力的方向判断:AI 最可能发力的地方,是数学与物理这条过去 40 年一直在分化的裂缝——物理学的启发式推导(重整化、路径积分)『在道德意义上是对的』但严格性缺口巨大,而 LLM 恰好擅长把这种缺口补上;同时,他明确点名了 AI 公司对数学界的一个结构性问题:用客户的未发表数据(包括博士生、博后自己马上要发的成果)训练并抢先『发布』,这件事需要靠企业协议、opt-in 数据政策、开源权重基建来对冲。Step 4: the author also offers a directional judgment with real commitment. The place AI is most likely to help is the 40-year widening gap between mathematics and physics — physical heuristics (renormalization, path integrals) are 'morally true' but carry rigor gaps that LLMs are well-suited to close. He also names a structural problem plainly: AI companies training on their customers' unpublished work (graduate students and postdocs, sometimes days from releasing the same result themselves) — which he argues requires enterprise agreements, opt-in data policy, and investment in open-weight infrastructure as counterweights.
- O(1) 是平均值信仰,不是最坏保证:Python 的 dict 可以被做到 O(n²)O(1) Is an Average-Case Faith, Not a Worst-Case Guarantee: Python's dict Can Be Made O(n²)
- 第一,先把常识摆出来:Python 的 dict/set 通常被认为是 O(1) 的查找和插入——这是几乎每个 Python 开发者脑子里的默认假设。Lemire 的这篇文章要拆掉的就是这个『默认』:它是平均值意义上的对,从来不是最坏情况意义上的对。Step 1: start from the default assumption nearly every Python developer carries — dict and set lookups are O(1). Lemire's point is to separate 'O(1) on average' from 'O(1) guaranteed,' which are two very different claims.
- 第二,具体怎么做到的:哈希表靠『碰撞很少发生』来维持性能。只要你能构造出大量互相碰撞的键,性能就从 O(1) 掉到 O(n²)。他用的构造极其简单:取 $M = (1 \ll 61) - 1$(一个 61 位全 1 的数),然后用 $i \cdot M$($i = 1, 2, 3, \dots$)做键——这些数在 Python 当前的哈希实现里会大量撞到同一桶。Step 2: the mechanism is hash collisions. A hash table's speed depends on collisions staying rare. If you can supply many keys that collide into the same buckets, performance degrades from O(1) to O(n²). His construction is deceptively simple: take $M = (1 \ll 61) - 1$ and use $i \cdot M$ for $i = 1, 2, 3, \dots$ as keys — under Python's current hashing these collide heavily.
- 第三,实测数据(Apple M4 Max,Python 3.14):插入 1000 个键约 4.8 ms,16000 个键要 1.07 秒——差不多是 4 个数量级的差距,而且随 $n$ 是平方级增长,不是线性。这就是最坏情况,不是平均值。Step 3: the measured numbers (Apple M4 Max, Python 3.14): inserting 1,000 keys takes about 4.8 ms; 16,000 keys takes 1.07 s — roughly four orders of magnitude, growing quadratically in $n$ rather than linearly. That's the worst case, not the average case everyone was implicitly quoting.
- 第四,能带走什么:如果你的程序接受外部输入当 dict/set 的键(比如以 URL、用户名、任意字符串做键),攻击者可以自己构造输入来把你的『O(1) 数据结构』变成『O(n²)』——这是一个真实的、可以在生产环境里做出来的性能攻击面,不只是理论上的边角。Step 4: what to take with you. If your program accepts external input as dict/set keys — URLs, usernames, arbitrary strings — an attacker can construct inputs that turn your 'O(1) data structure' into an O(n²) one. This is a real, deployable performance-attack surface in production code, not a theoretical corner case.
- 「证明 1 = 2」:一个假证明,教会你看破所有「一步走错」的位置'Proving 1 = 2': One False Proof, and How It Teaches You to Spot Every 'One Wrong Step'
- 第一,这道题本身是经典的『假证明』练习:假设 $a=b\neq 0$,那么 $a^2=ab$,两边同时减去 $ab$ 和 $b^2$,得到 $a^2-b^2=ab-b^2$,因式分解成 $(a+b)(a-b)=b(a-b)$,两边『约掉』$(a-b)$,得到 $a+b=b$,再代入 $a=b$,于是 $2b=b$,两边除以 $b$,得到 $2=1$。每一步看起来都合法,但结论显然荒谬。Step 1: the problem is the classic 'false proof' drill. Assume $a=b\neq 0$. Then $a^2=ab$; subtract $ab$ and $b^2$ from both sides to get $a^2-b^2=ab-b^2$; factor as $(a+b)(a-b)=b(a-b)$; 'cancel' the $(a-b)$ to get $a+b=b$; substitute $a=b$ to get $2b=b$; divide by $b$ and you get $2=1$. Every step looks legal, yet the conclusion is absurd.
- 第二,关键在哪一步:『两边约掉 $(a-b)$』这一步,实际上是在两边同时除以 $(a-b)$——而 $a=b$,所以 $a-b=0$,这一步就是在除以零。整个『证明』里只有这一处不合法,其他所有步骤都是对的。Step 2: where it actually breaks. 'Canceling the $(a-b)$' is dividing both sides by $(a-b)$ — and since $a=b$, $a-b=0$. That single step is division by zero; every other step in the 'proof' is perfectly fine.
- 第三,为什么这类练习值得反复做(而不是刷一遍就忘):它训练的是一个非常具体的阅读习惯——看任何多步推导时,不停顿地检查『这一步到底改变了什么』。多数假证明的错误都是同一类:某一步看起来像是『两边同做一件事』,但实际上两边同时做的事情,其中一边(比如除以零、把一个变量偷偷固定成一个具体值)是另一边的等价操作无法完全跟随的。Step 3: why this drill is worth repeating rather than reading once and forgetting. It trains a very specific reading habit — pausing at every step of a long derivation to ask 'what did this step actually change?' Most false proofs fail in the same family of ways: a step that looks like 'do the same thing to both sides' where one side quietly did something the other side can't follow (dividing by zero, freezing a variable at a specific value). Spotting that pattern on a toy example like this is what makes it transfer to real proof-reading.
- 第四,Kun 把这类题放进自己网站的『Proof Gallery』,理由很直接:假证明对理解问题域的边界往往比真证明更有用——它逼你去想『为什么这一步不能做』,而这个问题(『什么时候可以除,什么时候不行』)比任何一个具体的定理都更接近代数这门课真正在教的东西。Step 4: Kun's reason for including these in his 'Proof Gallery' is direct: a false proof is often more instructive about the edges of a subject than a correct one is, because it forces you to answer 'why is this particular step not allowed' — a question ('when can you divide, when can't you') that runs closer to what algebra actually teaches than any single theorem does.
程序员随想A Programmer's Reflections
- Haters:粉丝只换了个符号Haters: Fanboys With the Sign Flipped
- 第一,Graham 先把现象命名:一旦你出名,会出现一批『太喜欢你』的人(他借用了 'fanboy' 这个词并明确表示讨厌它),以及一个镜像现象——一批『太讨厌你』的人。他花了很多年没想明白后者到底是什么、从哪来。Step 1: Graham names the phenomenon first. Once you become famous, a certain kind of obsessive fan shows up — and, in mirror image, an obsessive hater. He spent years not being able to figure out what the second group actually was.
- 第二,他想明白的那一刻是本文的核心:Hater 就是符号取反的 fanboy。他把两段文字并排放出来——『粉丝』的定义和『hater』的定义,除了 good/bad 互换,逐字相同。这个『逐字相同』本身是他的论证手法:如果一个现象能用一个符号翻转完全解释,它就不是一个新现象,是同一个现象的另一个极性。Step 2: the payoff is the piece's central move: a hater is just a fanboy with the sign flipped. He puts the two definitions side by side — they are literally identical except that 'good' and 'bad' are swapped. That literal identity is his argument: if one phenomenon is fully explained by flipping a single sign, it isn't a new phenomenon, it's the other polarity of the same one.
- 第三,他补充了一个很有辨识度的细节:'fraud'(骗子)这个词,是识别 hater 的『频谱特征』——不是所有讨厌你的人都叫 hater,只有那种把『讨厌你』变成自我身份一部分、并且坚持认为你『是假的』的人,才是;普通路人不会花力气去证明你是骗子。Step 3: a discriminating detail he adds: the word 'fraud' is the spectral signature of a hater. Not everyone who dislikes you is a hater; only the one for whom 'disliking you' has become part of their own identity, and who insists you are 'fake,' is one. An ordinary passerby wouldn't spend effort proving you're a fraud.
- 第四,能带走的判断法:如果你发现有人对你的『每一个』行为都能给出『证明你不行』的解读,而不是针对某个具体行为的评价,那就是符号取反的粉丝,不是普通的批评者——这两者的应对方式完全不同(前者的『强度』跟你做的事无关,后者的还可能有信息量)。Step 4: what to take with you as a test. If someone can produce a reading of 'every' thing you do as evidence that you're no good — rather than evaluating a specific action — you're looking at a sign-flipped fan, not a critic. Those two need completely different responses: a hater's intensity is decoupled from what you actually do; a critic's can still carry information.
- 『要学』的反面:学校教你的最坏一课是『学会拿高分』The Lesson to Unlearn: The Most Damaging Thing School Taught You Was How to Get Good Grades
- 第一,Graham 的开场判断:学校里学过的最有害的东西,不是任何一门具体课程,而是『学会怎么拿高分』这件事本身。他用自己大学经历作证:即便是『很认真』的学生,最努力的时候也是备考的时候——这就是问题被制度化后的默认形状。Step 1: Graham's opening claim: the most damaging thing school teaches is not any subject — it's learning how to get good grades itself. He testifies from his own college years: even a 'diligent' student's hardest work was almost always exam prep. That's just what the system optimizes for.
- 第二,他给出的理由是全文最锋利的一句:『几乎所有的考试都被设计得可以被 hack。』——如果你要考中世纪史,最优策略不是读最好的书,而是只读『可能出考题的那种内容』;老考题、老师的政治倾向、可以背下来的『三点原因/三点后果』清单,才是真正的教材。Step 2: the sharpest reason he gives: nearly every test is hackable by design. For a medieval-history final, the optimal strategy isn't reading the best books — it's reading only what's likely to show up on the test: recycled past papers, the professor's axe to grind, 'three causes / three consequences' lists that can be memorized verbatim.
- 第三,由此推出一个更不舒服的结论:『拿高分』和『真的学会』在学校体系里不是同一件事,甚至经常是互斥的——你几乎不可能同时做两件事;而整个体系(保研、招聘、奖学金)都只认『拿高分』这一项,所以理性选择只有一种,这就是为什么『别责怪学生只选分数』。Step 3: the uncomfortable conclusion that follows: 'getting a good grade' and 'actually learning' are not the same thing in the school system — often they work directly against each other, and you essentially have to pick one. Since every downstream signal (graduate school, employers, scholarships) reads only the grade, the rational choice collapses to a single one, which is why you can't really blame students for choosing grades.
- 第四,Graham 说这个认识在他运营 Y Combinator 之后才真正落地:他发现创业公司做产品的方式,跟学生在学校『为考试而学』的方式,在结构上是同一种偏差——都在优化一个跟真实目标(做出好产品/真正理解一件事)脱节的代理指标。Step 4: Graham says this recognition only fully clicked for him while running Y Combinator: he started noticing that how startups build products structurally mirrors how students study for exams — both are optimizing a proxy metric that has drifted away from the real goal (building something good / actually understanding something).
- 并发编程里,『取消』才是最容易被语言运行时搞砸的一环In Concurrency, 'Cancelation' Is the One Thing Runtimes Keep Getting Wrong
- 第一,matklad 这篇是读 Zig 新并发接口 std.Io.Threaded 时的感想(他本人是 rust-analyzer 的作者,在 Rust 圈里最懂『语言运行时该替开发者管什么』这件事的人)。他先给两个判断力试金石:并行(parallelism)是『声明式』的——你描述怎么切分问题,平台负责切对;并发(concurrency)则必然涉及取消(cancelation)——你总会有『这条计算已经没用了,主动干掉它』的时刻,而『等它自己跑完』在绝大多数情况下根本不可能,因为『没用了』的常见原因就是『它在等一个永远不会来的消息』。Step 1: matklad's post is his notes on Zig's new std.Io.Threaded concurrency interface (he's the author of rust-analyzer, i.e. someone who has spent a career thinking about what a language runtime should manage for you). He frames the two litmus tests for understanding concurrency vs. parallelism: parallelism is declarative — you describe how to split the problem, the platform verifies the split; concurrency essentially always involves cancelation, because the moment one computation 'realizes' another computation is no longer needed, it has to actively stop it — and 'just wait for it to finish' usually can't work, since the usual reason it's no longer needed is that it's blocked on something that will never arrive.
- 第二,于是问题变成:能不能『就用操作系统线程 + 阻塞式 API』,不引入 io_uring 这类新玩具,但依然能可靠取消任意一段正在阻塞在系统调用里的工作?——这是绝大多数运行时(包括 Java)实际没做到的事。Step 2: the question this raises: can you get reliable cancelation of anything, even a thread currently blocked inside a kernel syscall, while still 'just using OS threads and blocking APIs' — no io_uring, no event loop? That is the thing almost every mainstream runtime (including Java) fails at, and the thing Zig's Threaded implementation actually solves.
- 第三,Zig 的做法很巧:POSIX 下,线程阻塞在内核里时,给它发一个信号可以让系统调用返回 EINTR(『被中断了』)——但信号本身不可靠(可能在错误的时间点送达,也可能来自别的无关信号),所以真正的协议是『共享内存里的一个标志位 + 反复发信号直到对方确认』:取消方先把标志位置成『请取消』再发信号,被取消方在每次 EINTR 醒来后先读标志位,再决定是重试系统调用还是真的开始解绑(unwind);Windows 下则直接用 NtCancelSynchronousIoFile 这个『取消一个同步 IO』的系统调用,绕开这一套。Step 3: Zig's mechanism on POSIX is clever: sending a signal to a thread blocked in a syscall wakes it up with EINTR ('interrupted') — but raw signals are too racy to be the protocol themselves (they can arrive at the wrong time, or come from an unrelated source). The real protocol is a shared-memory flag plus repeated signal-and-wait: the cancelling thread sets the flag to 'please cancel' and signals; the blocked thread, on each EINTR wake-up, reads the flag to decide whether to retry the syscall or actually begin unwinding. On Windows there's a much more direct primitive — NtCancelSynchronousIoFile — and matklad half-jokes that NT's concurrency story (fibers, IO completion ports, Job objects, this) is more thought-through than Unix's.
- 第四,另一个他反复强调的分法:把『可能并发跑』(io.async)和『必须并发跑』(io.concurrent)在接口层面分开——前者永远不失败,后者一定会失败(因为线程池满了就得新开线程)。这比 Rust/C++ 里到处都写 std::launch 策略的做法干净得多:把『并发』这个词拆成两个明确命名的小词,代码签名直接跟着变精确了。能带走的判断:并发难题大多卡在『内核/运行时/语言』三者交界的灰区,而语言层其实是最适合解决它的那一层——Zig 这篇文章的价值不在于『它实现了取消』,而在于它把『取消』当成语言一等公民来设计。Step 4: another split he keeps hammering on: separate 'may run concurrently' (io.async) from 'must run concurrently' (io.concurrent) at the interface level — async never fails, concurrent can fail (thread pool exhausted, so it spawns a new thread). Naming the two cases as two small words instead of one overloaded word makes function signatures measurably more precise, in a way std::launch policies in C++/Rust never manage. The takeaway: most of the pain in concurrency lives in the fuzzy overlap between kernel, runtime, and language — and the language layer is actually the best-placed of the three to solve it; Zig's value isn't 'it implements cancelation,' it's that it treats cancelation as a first-class language concept.
哲学与生活Philosophy & Life
- 搬进一栋没有网也没有电话的林屋之后After Moving Into a House in the Woods With No Internet or Phone
- 第一,这是一篇很短但很具体的生活记录:上个月搬进了一栋没有网络、没有电话服务的林屋,作者的第一反应是『我没法这样住』,住了一段时间之后,变成『我更喜欢这样』。Step 1: a short but concrete life record. Last month he moved into a house in the woods with no internet and no phone service. His first reaction was 'I can't live like this.' After a while it flipped to 'I prefer it this way.'
- 第二,他观察到的核心现象:媒体的沉默制造了一个真空,而这个真空会被你自己的思考填满——不是变成发呆,是变成『必须自己写、自己编码、自己学』,因为时间空间没有别的东西可以填。Step 2: the core observation: media silence creates a vacuum, and your own thoughts expand to fill it — not with blankness, but with the necessity to write, code, and learn, because there is literally nothing else that fills the time and space.
- 第三,他给了一个很具体的日常操作,比『少看手机』有用得多:想搜索之前,先问自己三个问题——『我期待听到什么答案?什么答案会让我惊讶?这两种情况我各会怎么做?』他说这个过程本身比拿到一个搜索结果更有用。Step 3: a concrete daily practice that is more useful than 'check your phone less.' Before reaching for a search, ask three questions: 'What answer am I hoping to hear? What answer would surprise me? What would I do in each case?' He says running that process is more useful than the search result itself.
- 第四,他还借了《机器人总动员》(WALL·E)里人类胖到走不动路、离不开辅助机的画面做类比:他想要的是『不借助外部意见也能扛住重思考』的能力,而每周进城上一次网、限时一小时的节奏,就是为了保持这种『力量练习』不消失。Step 4: he anchors it with a WALL·E image — humans so dependent on their helpers they can no longer walk — and says the point is being able to carry a heavy thought without outsourcing it. The weekly, one-hour trip into town for internet is the deliberate limit that keeps that muscle from atrophying.
- 「丛林里的兽」:Henry James 写的最残忍的人生失败,是『什么都没做』'The Beast in the Jungle': Henry James's Brutal Definition of Life's Real Failure — Doing Nothing
- 第一,这篇小说讲的是一件事:一个人一生都在『等待某个稀有的、陌生的、可能惊天动地的时刻降临』——他自己管那个时刻叫『丛林里的兽』,相信它迟早会扑出来,要么毁掉他,要么彻底改写他。他花了一辈子『躺在那儿等』,同时把自己从所有真正能改写他的经历(去追一个伟大的梦、为某个伟大的事业赌上性命、去爱一个人)里撤出来,理由是『那些都不重要,重要的是那个兽』。Step 1: the novella is about one thing. A man spends his whole life waiting for 'something rare and strange, possibly prodigious and terrible' to happen to him — he calls it 'the beast in the jungle,' convinced it will spring sooner or later, ruining or remaking him. He spends that same lifetime 'lying in wait' while deliberately staying out of every experience that could actually remake him — chasing a great dream, risking his life for a great cause, falling in love — because none of those 'count' as the Beast.
- 第二,最残酷的是结局的方式:他其实遇上了那个『兽』——一个爱他的女人,一次他本可以『活过来』的契机。他因为怕『我的命运会伤害她』而拒绝了,把这份爱挡在 arm's length 之外。他真正错失的东西,恰恰就是他一生在等待的那个『稀有的、能改写他的时刻』——爱本身。Step 2: the cruelest part is how it ends. He does meet the Beast — a woman who loves him, the one moment where he 'would have lived.' He refuses it, keeping her at arm's length, telling himself he's protecting her from his fate. What he actually misses is the very thing he spent a lifetime waiting for: love, itself, is that rare, transformative force.
- 第三,Popova 用 Solnit(《迷途指南》)的框架来解读:『我们想要的东西是改变性的,而我们不知道(或以为自己知道)那个改变的另一端是什么』。等待本身,就是问题:『只要我们还在等待,我们就没有活着。』——等待把『现在唯一可用的、对抗不确定性的堡垒』(当下这一刻)给腾了出来,让『如果那时……』的念头住进去。Step 3: Popova reads it through Rebecca Solnit's framing from 'A Field Guide to Getting Lost': 'the things we want are transformative, and we don't know — or only think we know — what is on the other side of that transformation.' Waiting, itself, is the problem: 'as long as we are waiting, we are not living.' Waiting vacates the only thing that could actually shelter you from the uncertainty of life — the present moment — and gives the 'if only' mind room to move in.
- 第四,James 原文里最狠的一句:『破产、身败名裂、被游街示众、甚至被绞死,都不算失败;什么都不曾成为,才算失败。』这是把这篇小说(以及 Popova 这篇导读)真正想说的东西,压缩成一句话的人生标准:失败不是『做错了什么』,是『什么都没做,然后等死了』。Step 4: the single harshest line in James's own prose, which is really the whole point of both the novel and Popova's essay: 'It wouldn't have been failure to be bankrupt, dishonoured, pilloried, hanged; it was failure not to be anything.' Failure isn't 'doing the wrong thing.' Failure is 'doing nothing, and waiting until you die.'
工具角Tools Corner
- 把『AI 写作腔』用 161 条数据从 Qwen3-4B 里蒸出来Training 'AI Writing Tics' Out of Qwen3-4B With 161 Examples
- 第一,问题:本地小模型(比如 Qwen3-4B)写出来的东西,带着一整套 AI 写作腔——em dash、『不是 X,是 Y』、三项排比、『delve』『seamless』。作者做了一个『AI 腔检测器』(一套带权重的正则规则),给原文打分:每千词 121 分(人类认真写的东西通常不到 15 分)。Step 1: the problem. Small local models like Qwen3-4B write with a recognizable 'AI slop' register — em dashes, 'it's not X, it's Y,' three-item lists, 'delve,' 'seamless.' The author built a 'slop detector' (a weighted set of regex rules over these habits) and scored the original model: 121 per 1,000 words (careful human writing usually lands under 15).
- 第二,方法:不是靠系统提示词(那种做法每次生成都要挂上提示,而且会漂移模型在普通文本上的预测分布),而是蒸馏——先用『提示词 + 人工检查』得到一批干净的 288 条回答当老师,再用 LoRA 把这批回答『蒸』进 4B 模型本身,让它在裸提示词下也能写出这个风格。在 MacBook Air 上训的,只用了 161 条最终入选的数据。Step 2: the method. Not a system prompt (which has to be attached at every generation and shifts the model's predictions on ordinary text), but distillation: a teacher built from 'prompt + human checks' answers 288 training prompts; only answers that pass the checks survive; a small LoRA adapter then learns to reproduce that style from the bare prompt, so the behavior lives in the weights. Trained on a MacBook Air, from 161 final kept examples.
- 第三,效果:slop 分从 121 掉到 12.5,其中 68% 的回答落在了『像人写的』区间;同时用 30 道事实题、30 种体裁保持检查、以及『漂移度』指标(模型在 22 段真实人文书上的预测变化幅度)确认没有把知识能力也蒸没了。Step 3: the results. Slop score drops from 121 to 12.5; 68% of held-out answers land in the 'reads like a human' range — while 30 factual quiz questions, a genre-preservation check, and a 'drift' metric (how far the model's predictions on 22 passages of real human prose moved) confirm the model's underlying capability didn't get distilled away too.
- 第四,能带走的不是『某个模型』,而是这套流程本身:定义一份『AI 腔检测器』(规则+权重)→ 用它筛出干净样本 → 蒸馏进小模型权重 → 用独立的『能力是否受损』指标验证。这套方法论对任何『我想让本地模型说话更像人』的需求都适用。Step 4: what to take with you is the pipeline, not the specific model. Define a weighted 'AI slop detector' → use it to filter clean samples → distill into a small model's weights → verify with an independent 'did I break its abilities' check. The same recipe applies to any 'I want my local model to sound less like an AI' problem.
- Death Plan Switch:一个给独自开发者用的『死人开关』Death Plan Switch: A Dead Man's Switch for Solo Developers
- 第一,很实际的问题:如果你是独居、独自开发/工作的人,『我出事没人知道』是一个真实的、没人替你想过的场景。Step 1: a practical problem: if you live and work alone, 'if something happens to me, no one knows' is a real scenario that nothing in your stack handles for you.
- 第二,它的机制:每周固定时间发一封签到邮件,你必须主动点按钮(不是打开链接就算数——邮件扫描器会自动打开链接,所以设计成『打开不算,必须点』);72 小时后问亲属『他/她还好吗』,144 小时后把你自己写好的预设消息发给你的联系人;如果你在任何阶段又签到了,已经收到消息的人会被立刻告知『虚惊一场』。Step 2: the mechanism. A check-in email every week at a fixed time; you must actively press a button — opening the link does not count, deliberately, because email scanners open links on their own. 72 hours in, your next of kin is asked 'are they okay?'; at 144 hours, your contacts get a message you wrote in advance. Check in at any stage and everyone already contacted is told it was a false alarm, immediately.
- 第三,它页面上把整条时间线按真实小时比例画出来——这是它最有『设计感』的地方:你一眼能看到『错过一次签到』具体意味着亲属在第几天被问到、联系人又在第几天收到消息,而不是一个模糊的『会自动通知』。Step 3: the page draws the entire timeline to actual hour scale — the most 'designed' part of it: you can see at a glance exactly which day kin get asked and which day contacts get notified if you miss a check-in, instead of a vague 'you'll be alerted automatically.'
- 第四,能带走的判断:它解决的是『单人/无备份』场景下的通知问题,设计上的关键抉择(必须点按钮、按小时比例画图、虚惊一场要立刻撤回)都是可以直接借鉴的。Step 4: what to take with you. It solves the 'single point of failure / no backup' notification problem, and its key design choices — button-press-not-link-open, hour-accurate proportional timeline, immediate false-alarm retraction — are all patterns worth borrowing for similar 'silent failure' problems.
- 把 LaTeX 文档整个塞进一个 URL fragment:可收藏、可分享的渲染器Stashing an Entire LaTeX Document in a URL Fragment: A Bookmarkable Renderer
- 第一,灵感来自 Paul Ford 的 Tiny Little Office:那套网页办公工具(文字处理、演示文稿、电子表格……)的招牌技巧是把整个文档数据存在 URL 的 #fragment 里,让每个文档天然就是一个可收藏、可分享的链接。Step 1: the inspiration is Paul Ford's Tiny Little Office — a suite of web office tools whose signature trick is storing an entire document's data in the URL's #fragment, so every document is automatically a bookmarkable, shareable link.
- 第二,Willison 让 Claude(Opus 5.5)照这个套路做了一个 LaTeX 版本:打开页面无 fragment 时显示一个编辑器,可以在里面写/粘贴/从 Gist 加载 LaTeX,再切换到渲染视图;有 fragment 时直接渲染那个 fragment 里的 LaTeX。Step 2: Willison had Claude (Opus 5.5) build the LaTeX version of that pattern: with no fragment, the page shows an editor (type LaTeX, paste it, or load it from a Gist) and a toggle to a rendered view; with a fragment, it renders the LaTeX stashed right there in the URL.
- 第三,一个设计细节值得注意:fragment 里的 LaTeX 支持一种『用针对 LaTeX 优化的压缩字典压缩』的前缀——把源码压短,URL 才不至于长得离谱;这是把『文档编码进 URL』这个通用套路套到 LaTeX 上时真正需要的工程细节。Step 3: an engineering detail that makes it actually work: the fragment supports a prefix that stores the LaTeX compressed with a dictionary tuned specifically for LaTeX — without that, real documents would make URLs absurdly long. This is the unglamorous but necessary part of 'document-in-a-URL' for anything non-trivial.
- 第四,还带了一个 llms.txt,告诉 AI agent 怎么构造这种 URL——也就是说,agent 可以直接生成一个『点开就渲染出这份 LaTeX 文档』的链接。这是它和大多数『单文件工具』相比多出来的一层:它不是给你用的,是写给 agent 用的。Step 4: it ships with an llms.txt that tells AI agents how to construct these URLs — so an agent can generate, on its own, a link that opens to a rendered LaTeX document. That one layer is what separates it from most 'single-file tool' projects: it isn't just usable by a person, it's legible to an agent.