[{"data":1,"prerenderedAt":145},["ShallowReactive",2],{"page-\u002Frambling\u002F碎碎念-计算性":3},{"id":4,"title":5,"body":6,"description":29,"extension":134,"meta":135,"navigation":140,"path":141,"seo":142,"stem":143,"__hash__":144},"content\u002Frambling\u002F碎碎念-计算性.md","碎碎念 计算性",{"type":7,"value":8,"toc":130},"minimark",[9,20,23,39,42,46,49,52,55,58,61,64,67,74,77,117,120,123,126],[10,11,12],"blockquote",{},[13,14,15,19],"p",{},[16,17,18],"span",{},"tip","对于某些系统，要知道它经过 N 步之后是什么状态，没有一种一般性的“捷径”，你必须让系统实际运行相当程度的 N 步。",[13,21,22],{},"wolfram将这种系统称为computationally irreducible，如果存在一种方法可以不用逐步运行，就可以直接计算出第N步，那么就可以称之为computationally reducible，就比如：",[24,25,30],"pre",{"className":26,"code":27,"language":28,"meta":29,"style":29},"language-c shiki shiki-themes github-light github-dark","x(t+1) = x(t) + 1\n","c","",[31,32,33],"code",{"__ignoreMap":29},[16,34,37],{"class":35,"line":36},"line",1,[16,38,27],{},[13,40,41],{},"想要得到 t = 10^12 显然不需要真的执行10^12次，这个是可约的。",[43,44,45],"h2",{"id":45},"米利型状态机",[13,47,48],{},"假设一个下同，每一步产生的状态都参与下一步计算，而且不存在都能直接跳到N的一般公式，那么这个是计算不可约，这个有点像mealy型状态机，它的输出依赖于当前状态的输入，而moore型状态机的输出仅仅依赖于当前状态。",[13,50,51],{},"Mealy machine 的基本形式可以写成：",[13,53,54],{},"$$\n\\begin{aligned}\ns_{t+1} &= \\delta(s_t, x_t) \\\ny_t &= \\lambda(s_t, x_t)\n\\end{aligned}\n$$",[13,56,57],{},"但是mealy机不等于计算不可约性，因为他是一个有状态的递归系统，我们可以直接得到sn = s0 + n，计算是高度可约的。",[43,59,60],{"id":60},"指导意义",[13,62,63],{},"回到正题，计算不可约对于系统开发指导意义很大，但是并不是对于直接写代码的设计模式，而是一种判断系统应该设计和优化的思维工具。假设你要制作一个动态系统，操作A会导致状态Runtime State，操作B会导致一个状态，然后操作C...",[13,65,66],{},"后面的状态取决于前面的执行结果，你不能简单认为整个runtime的规则都知道，那么应该可以一次性计算出整个10000个operation执行完之后的状态。很多系统根本不存在这样的捷径，工程上的思维一般是：",[10,68,69],{},[13,70,71,73],{},[16,72,18],{}," 对于具有状态依赖的系统，就应该把演化过程当作系统的一等公民",[13,75,76],{},"所以runtime一般设计为：",[24,78,80],{"className":26,"code":79,"language":28,"meta":29,"style":29},"while (!stopped)\n{\n    poll();\n    dispatch();\n    update_state();\n}\n",[31,81,82,87,93,99,105,111],{"__ignoreMap":29},[16,83,84],{"class":35,"line":36},[16,85,86],{},"while (!stopped)\n",[16,88,90],{"class":35,"line":89},2,[16,91,92],{},"{\n",[16,94,96],{"class":35,"line":95},3,[16,97,98],{},"    poll();\n",[16,100,102],{"class":35,"line":101},4,[16,103,104],{},"    dispatch();\n",[16,106,108],{"class":35,"line":107},5,[16,109,110],{},"    update_state();\n",[16,112,114],{"class":35,"line":113},6,[16,115,116],{},"}\n",[13,118,119],{},"而不是试图将整个未来状态一次性给计算出来，我们通常关心的是从输入到输出，但是runtime里尽量要关心状态转换。这些状态转换本身就是系统的语义，每个阶段都可能影响系统接下来允许做什么，例如pedding-> cancel -> cancelled，但是running->canncel就不行，所以状态演化不是为了实现这个api而认为添加的东西，而是api行为本身的一部分。不要把系统看作一个从输入得到输出的黑盒！！而要把状态->状态的演化链本身作为系统。",[13,121,122],{},"在软件测试里，我们反而会喜欢把他当作黑盒，通常不需要指导内部是怎么实现的，这个叫做黑盒测试，所以一个系统是可以有两种视角的。",[13,124,125],{},"架构上，我们要区分可约和不可约，不要认为整个提供不可约，所以就要全部暴力计算，我们需要尽可能将可约和不可约分离开来，将能压缩的地方压缩，不能压缩的地方接受为系统本身的计算过程。",[127,128,129],"style",{},"html .default .shiki span {color: var(--shiki-default);background: var(--shiki-default-bg);font-style: var(--shiki-default-font-style);font-weight: var(--shiki-default-font-weight);text-decoration: var(--shiki-default-text-decoration);}html .shiki span {color: var(--shiki-default);background: var(--shiki-default-bg);font-style: var(--shiki-default-font-style);font-weight: var(--shiki-default-font-weight);text-decoration: var(--shiki-default-text-decoration);}html .dark .shiki span {color: var(--shiki-dark);background: var(--shiki-dark-bg);font-style: var(--shiki-dark-font-style);font-weight: var(--shiki-dark-font-weight);text-decoration: var(--shiki-dark-text-decoration);}html.dark .shiki span {color: var(--shiki-dark);background: var(--shiki-dark-bg);font-style: var(--shiki-dark-font-style);font-weight: var(--shiki-dark-font-weight);text-decoration: var(--shiki-dark-text-decoration);}",{"title":29,"searchDepth":89,"depth":89,"links":131},[132,133],{"id":45,"depth":89,"text":45},{"id":60,"depth":89,"text":60},"md",{"tags":136,"status":138,"date":139},[137],"杂谈","学习中","2026-10-07",true,"\u002Frambling\u002F碎碎念-计算性",{"description":29},"rambling\u002F碎碎念-计算性","ioLZWXZbmTYxvxfuL_TCyHTuQxXrY05mjGieo-PGz9I",1791394559800]