Back to Details

ljg-constraint

Compare original and translation side by side

🇺🇸

Original

English
🇨🇳

Translation

Chinese

约束引擎

Constraint Engine

输入一个领域、一门专业、一个角色，找出框住它的那几条约束，看清这组约束框出的解空间——以及这个解空间怎么解释它的种种行为。
Input a domain, profession, or role to identify the constraints that define it, and understand the solution space framed by these constraints—as well as how this solution space explains its various behaviors.

Workflow Routing

Workflow Routing

TriggerWorkflow
给领域、专业、角色、产品找本质约束执行本文工序，写成一篇中文散文分析，保存为 org 文件
分析一场方案争论为什么说不清先找各方默认约束，再说明他们其实是不是同一道题
判断某条边界是真硬约束还是旧解释走三层硬度和真伪定性，不急着给突破方案
TriggerWorkflow
Identify essential constraints for a domain, profession, role, or productExecute the process outlined in this document, write a Chinese prose analysis, and save it as an org file
Analyze why a solution debate is unclearFirst identify the default constraints of each party, then explain whether they are actually solving the same problem
Determine if a boundary is a true hard constraint or an old interpretationConduct three-level rigidity and authenticity qualification, do not rush to propose breakthrough solutions

Gotchas

Gotchas

  • 不要把约束写成普通困难、缺点或建议。约束必须能改变解空间；拿掉它，允许的行为会变。
  • 不要只盯目标。同一目标在不同约束下不是同一道题；先补全题面，再谈解法。
  • 不要把共识、习惯、行业话术顺手归进硬约束。硬约束要经得起"违背它是否立刻崩"这一问。
  • 不要急着写"如何突破约束"。先把当前约束的真实硬度、身份边界和行为解释力写准，松动只在结尾点一句。
  • 不要把身份约束和策略约束混在一起。拿掉之后还成其为自己的，不是身份约束。
  • Do not confuse constraints with ordinary difficulties, shortcomings, or suggestions. Constraints must alter the solution space; if removed, allowable behaviors will change.
  • Do not focus solely on goals. The same goal with different constraints is not the same problem; complete the problem statement first before discussing solutions.
  • Do not casually classify consensus, habits, or industry jargon as hard constraints. Hard constraints must pass the test: "Will the system collapse immediately if violated?"
  • Do not rush to write "how to break constraints". First accurately describe the true rigidity of current constraints, identity boundaries, and behavioral explanatory power; mention loosening only briefly at the end.
  • Do not mix identity constraints with strategic constraints. If removing a constraint does not change the essence of the entity, it is not an identity constraint.

Examples

Examples

Example 1: 分析一个角色
User: "投资经理的约束是什么？"
-> 找出资金期限、LP 信任、信息不对称、上行/下行分配等约束
-> 说明这些约束如何逼出追热点、重共识、怕错过等行为
-> 写入 notes 里的 org 文件
Example 2: 分析一场争论
User: "为什么产品和增长总吵架？"
-> 先拆出双方默认约束：不能打扰用户 vs 必须提高转化
-> 说明目标看似都是做好产品，其实题面不同
-> 再解释各自方案为什么在各自约束里是理性的
Example 3: 判断旧解释
User: "这个行业必须重销售吗？"
-> 先问这是世界约束、规则约束，还是行业解释
-> 查有没有别的时代、地区、玩家已经活着跨过去
-> 若跨过去仍成立，把它降级为软约束或自设约束
Example 1: Analyze a Role
User: "What are the constraints of an investment manager?"
-> Identify constraints such as fund tenure, LP trust, information asymmetry, upside/downside distribution, etc.
-> Explain how these constraints drive behaviors like chasing hot trends, prioritizing consensus, fearing missed opportunities, etc.
-> Save to the org file in notes
Example 2: Analyze a Debate
User: "Why do product managers and growth teams always argue?"
-> First break down the default constraints of both parties: no user disruption vs. must improve conversion
-> Explain that while the goal seems to be building a good product, the actual problem statements are different
-> Then explain why each party's solution is rational within their own constraints
Example 3: Judge an Old Interpretation
User: "Must this industry prioritize sales?"
-> First determine if this is a world constraint, rule constraint, or industry interpretation
-> Check if players in other eras, regions have successfully operated beyond this
-> If they can survive beyond it, downgrade it to a soft or self-imposed constraint

约束是什么

What Are Constraints?

日常语感里，约束是负面的——束缚、不自由、不能做什么。这个引擎不这么看。
没有约束的东西没有形状。水没有约束时无形，给它一个杯子才有了形状；一道题没有约束条件时无解，给它约束，解才从无穷里浮出来。约束不是在减少可能性，是从无穷里生出特定性。没有约束等于什么都可以，等于什么都不是；有了约束，等于只有这些可以，等于这个东西是它自己。
问题也一样。一个问题不是只由目标构成，也由约束构成。大家都说"做一个产品"，但一个人默认不能增加复杂度，另一个人默认必须追求增长，他们其实已经不在同一道题里。目标相同，约束不同，解空间就不同；解空间不同，方法之争就常常只是错位。
所以一个事物的约束条件，就是它的身份。约束是把无限可能坍缩成"这一个"的那组方程。 而这组方程一旦写全，它框出的解空间就出来了——这个角色能做什么、不能做什么、最优的选择落在哪里，全被这几条约束夹定。找约束的真正回报不在清单本身，在这个解空间：它能把这个角色的实际行为一个个解释回来。
这引擎首先是描述，不是改造。 核心问的是"当前的本质约束是什么、框出什么解空间、解释了什么行为"。"怎么办更好、哪条能松动"是第二位的事，排在后面，而且不许反过来影响前面的诊断——一急着找出口，就会看不清墙。
和降秩分清一句话：降秩往下挖，找的是把现象生出来的那几根生成力（"什么在撑着它"）；约束往边上摸，找的是框住它的那几条边界，看这几条边界把它夹进一个什么样的解空间（"什么把它框成这个形状、逼出这些行为"）。一个找底，一个找边。
In daily language, constraints are negative—restrictions, lack of freedom, things you can't do. This engine does not view them this way.
Something without constraints has no shape. Water is formless without constraints; give it a cup and it takes shape. A problem has no solution without constraints; add constraints, and solutions emerge from infinity. Constraints do not reduce possibilities; they create specificity from infinity. Without constraints, anything is allowed, which means nothing is defined; with constraints, only certain things are allowed, which defines the entity as itself.
The same applies to problems. A problem is not just defined by goals, but also by constraints. When everyone says "build a product", but one person defaults to "no increased complexity" while another defaults to "must pursue growth", they are already solving different problems. The same goal with different constraints leads to different solution spaces; disputes over methods are often just misalignments.
Therefore, the constraints of an entity are its identity. Constraints are the set of equations that collapse infinite possibilities into "this one". Once this set of equations is complete, the framed solution space emerges—what the role can and cannot do, where the optimal choice lies, all determined by these constraints. The true value of finding constraints is not the list itself, but this solution space: it can explain every actual behavior of the role.
This engine is first and foremost descriptive, not transformative. The core questions are "What are the current essential constraints, what solution space do they frame, and what behaviors do they explain?" "How to do better, which can be loosened" is a secondary matter, and must not interfere with the initial diagnosis—if you rush to find an exit, you will fail to see the walls clearly.
A clear distinction from ljg-rank: ljg-rank digs downward to find the generative forces that produce phenomena ("what supports it"); constraint analysis reaches outward to find the boundaries that define it, and see what solution space these boundaries frame ("what shapes it and drives its behaviors"). One finds the foundation, the other finds the boundaries.

三层硬度：这条约束是哪一层的

Three Levels of Rigidity: Which Layer Does This Constraint Belong To?

约束不是一种东西，它们有硬度之分，权重不一样。分清硬度，是准确描述约束的第一步。
硬约束（世界层 / 物理层）——不可违背，试图违背则系统崩溃。人会死（时间），光速不可超越，公司现金流断了就没了。这层没有商量。它不是惩罚你，是系统直接停。
软约束（规则层）——可以违背，但有代价。法律、牌照、合同、行规。违背了系统不会物理崩溃，但会有人罚你、市场会惩罚你。这层是价码问题，不是可能性问题。
自设约束（解释层 / 认知层）——你以为存在，其实可以重新定义的。"我不擅长这个"，"这行就得这么干"，"别人会怎么看"。这层住在脑子里，不住在世界上。
不能违背的，要承认；可以违背的，要算代价；可以重写的，就不该称为命运。大部分困境不是被硬约束卡住的，是被自设约束困住的——把解释层的东西当成了世界层的。 一个领域里最贵的错误，永远是有人把一道粉笔线当成了石墙，绕着走了几十年。给约束定准硬度，就是在描述它真实的分量：它到底夹得死不死。
Constraints are not homogeneous; they vary in rigidity and weight. Distinguishing rigidity is the first step to accurately describing constraints.
Hard Constraints (World/Physical Layer)—Cannot be violated; attempting to violate them will cause system collapse. Humans die (time), speed of light cannot be exceeded, a company ceases to exist if cash flow is broken. There is no negotiation here. It does not punish you; the system simply stops.
Soft Constraints (Rules Layer)—Can be violated, but at a cost. Laws, licenses, contracts, industry norms. Violating them will not cause physical system collapse, but you will be punished by authorities or the market. This is a matter of cost, not possibility.
Self-imposed Constraints (Interpretation/Cognitive Layer)—Constraints you believe exist, but can be redefined. "I'm not good at this", "This industry has to be done this way", "What will others think". This layer exists in the mind, not in the real world.
Acknowledge those that cannot be violated; calculate the cost for those that can be violated; rewrite those that can be redefined—they should not be called fate. Most dilemmas are not caused by hard constraints, but trapped by self-imposed constraints—treating interpretation-layer things as world-layer facts. The most costly mistake in a domain is when someone treats a chalk line as a stone wall and绕着走了几十年. Determining the true rigidity of constraints is describing their real weight: whether they are truly unbreakable.

怎么找：工序

How to Find Them: The Process

判据是事后才能验的，找约束的力气全在过程里。七步，心里走完，不写进文章。
1. 铺约束候选。 对着这个领域/角色，多问几句，尽量把边摸全：
  • 这个问题的目标是什么？哪些约束和目标一起构成了这道题？
  • 如果换掉一条约束，题目会不会变成另一道题？
  • 这场争论里，各方默认的约束一样吗？
  • 哪条被大家当成背景底色的东西，也许只是旧解释？
  • 什么是不能做的？什么是必须做的？什么是逃不掉的？
  • 报酬和后果对结果对称吗——赚了归谁，亏了谁扛？ 激励的非对称是一条最容易漏、又最能解释行为的约束：谁若只拿上行、不担下行，他的最优选择就会往别人扛不起的方向偏。
  • 谁看不清谁——信息卡在谁那头？ 信息不对称也是硬约束，它往往决定这个角色到底在优化什么（看得见的信号，还是看不见的真实）。
  • 这里的钟走多快，一件事兑现要多久？ 时间尺度是约束，考核的钟和兑现的钟不一样，行为就被前者拽走。
把答出来的十几条全铺出来，光铺，不评判。这一步必然杂，真墙假墙混在一起。
2. 分层归位。 每条候选定位到硬/软/自设。判别问句：违背它，是系统物理崩溃（硬），还是有人罚你、要付代价（软），还是其实什么也不会发生、只是没人试过（自设）？归位时故意多疑一点——凡是被顺手归进"硬约束"的，都先打个问号，这一层最容易混进冒充的。
3. 真伪定性。 对每一条被当成硬约束的，追一句：谁规定的？违背它，真的物理上崩溃吗，还是只是没人试过、被罚过、或者习惯了？再加一道历史闸：别的地方、别的时代，有没有人已经跨过去了？跨过去了还活着，它就不是硬约束，是被错当成硬约束的软约束或自设约束。注意这一步是在更准确地描述这条约束的真实硬度，不是在指路"去把它撬了"。 它顺带解释了一件事：为什么总有少数玩家能不按常规打——因为他们看破了那是粉笔线。定性到此为止，怎么撬是后面第二位的事。
4. 找约束错配。 若输入里有争论、方案比较、路线分歧，先别急着判谁对。把各方默认的约束分开写出来：一个人默认"不能增加复杂度"，另一个人默认"必须追求增长"；一个人默认"不能打扰用户"，另一个人默认"必须提高转化"。他们以为在争方案，其实在争题面。目标相同、约束不同，解空间就不同。
5. 找矛盾对。 真正难的问题不是有约束，是几条约束互相打架，同时满足的解空间可能被夹成空的。把互斥的约束对挑出来，看解空间被挤到哪里、是不是空集。解空间为空的地方，往往正是这个角色表现出别扭、拧巴、看着不理性行为的根源——不是他蠢，是那里本来就无解，他只能扭曲着取舍。
6. 找身份约束。 在所有约束里问一句：哪一条拿掉，这个东西就不再是它自己了？这是身份约束——领域的定义性边界。餐馆拿掉"当面把食物交到人手里"就成了别的东西，医生拿掉"不伤害"就不是医生了。身份约束往往在硬约束层，但不总是；有时候一条软约束才是那个领域真正的身份。
7. 两把透镜收口。
  • f 论：约束就是 f 的定义域。这个角色的 f 能处理哪些 x、不能处理哪些 x，就是它的约束。看它被定义域框在哪、哪些 x 落在了它够不着的地方——那些够不着的区域，常常就是它行为里的盲区和缺口。
  • 进化论：约束就是选择压。一个物种面对的环境约束决定它长成什么形态——没有沙漠的干旱，骆驼不会有驼峰。看这个角色被哪几股选择压塑造成今天这个样子；这个环境奖励什么表现型、淘汰什么表现型，行为的大方向就定了。
七步走透，几条约束才立得住。工序心里走完，别写进文章——读者看不到你怎么摸的边，但感觉得到底下是摸到实处的。
Criteria can only be verified after the fact; the effort of finding constraints lies entirely in the process. Seven steps, completed mentally, not written into the article.
1. List Constraint Candidates. For the target domain/role, ask multiple questions to fully explore the boundaries:
  • What is the goal of this problem? Which constraints, together with the goal, form the problem?
  • If a constraint is replaced, will the problem become a different one?
  • In this debate, do all parties share the same default constraints?
  • Which thing taken for granted as background might just be an old interpretation?
  • What cannot be done? What must be done? What cannot be avoided?
  • Are rewards and consequences symmetric—who gets the gains, who bears the losses? Asymmetric incentives are one of the easiest-to-miss yet most behavior-explanatory constraints: if someone only gains upside without bearing downside, their optimal choice will lean toward directions others cannot afford.
  • Who lacks information—where is information stuck? Information asymmetry is also a hard constraint; it often determines what the role is actually optimizing (visible signals or invisible reality).
  • How fast does time move here, how long does it take for a result to materialize? Time scale is a constraint; if the assessment timeline differs from the result timeline, behavior will be pulled by the former.
List all ten-plus answers, just listing without judging. This step will inevitably be messy, mixing real and false boundaries.
2. Categorize by Layer. Assign each candidate to Hard/Soft/Self-imposed. Judgment question: If violated, will the system physically collapse (hard), will you be punished or pay a cost (soft), or will nothing actually happen—no one has tried it yet (self-imposed)? Be intentionally skeptical when categorizing—anything casually labeled "hard constraint" should be questioned first, as this layer is most prone to impostors.
3. Authenticity Qualification. For every constraint labeled as hard, ask: Who set this rule? If violated, will it truly cause physical collapse, or has no one tried it, been punished, or just gotten used to it? Add a historical check: Have players in other regions or eras already crossed this boundary? If they crossed it and survived, it is not a hard constraint, but a soft or self-imposed constraint mistakenly treated as hard. Note that this step is to more accurately describe the true rigidity of the constraint, not to guide "how to break it". It also explains why some players can break the rules—they saw it was just a chalk line. Qualification ends here; how to break it is a secondary matter later.
4. Identify Constraint Mismatches. If the input involves debates, solution comparisons, or route divergences, do not rush to judge who is right. Write down the default constraints of each party separately: one person defaults to "no increased complexity", another to "must pursue growth"; one defaults to "no user disruption", another to "must improve conversion". They think they are arguing over solutions, but they are actually arguing over problem statements. The same goal with different constraints leads to different solution spaces.
5. Find Constraint Conflicts. The real difficult problems are not just having constraints, but constraints that conflict with each other, where the solution space of satisfying all may be squeezed to empty. Pick out mutually exclusive constraint pairs, see where the solution space is squeezed and if it is empty. Empty solution spaces are often the root cause of a role's awkward, twisted, or seemingly irrational behaviors—it's not that they are stupid, but that there is no solution there, so they have to make twisted trade-offs.
6. Find Identity Constraints. Among all constraints, ask: Which one, if removed, would make the entity no longer itself? This is an identity constraint—the defining boundary of the domain. A restaurant becomes something else if it removes "deliver food to people in person"; a doctor is no longer a doctor if they remove "do no harm". Identity constraints are often in the hard constraint layer, but not always; sometimes a soft constraint is the true identity of the domain.
7. Finalize with Two Lenses.
  • Function Theory: Constraints are the domain of function f. Which x can this role's f process, and which cannot—this is its constraint. See where it is framed by the domain, which x are out of reach—those unreachable areas are often the blind spots and gaps in its behavior.
  • Evolution Theory: Constraints are selection pressure. The environmental constraints a species faces determine its form—without desert drought, camels would not have humps. See which selection pressures have shaped this role into its current form; what phenotypes the environment rewards and eliminates determines the direction of its behavior.
Only after completing these seven steps will the constraints be solid. The process is done mentally, not written into the article—readers won't see how you explored the boundaries, but they will feel that the analysis is grounded.

从约束到解空间到行为

From Constraints to Solution Space to Behavior

约束找齐了，别停在清单上。约束的解释力，全在它框出的那个解空间里。这一段是这引擎的脊椎，四步落地。
补全题面。 先把目标和约束放在一起。不要只写"它想做什么"，还要写"它必须在什么条件下做"。题面一补全，很多争论会自动消失：原来不是解法不同，是题本来不同。
列出约束组。 把几条约束、每条的硬度、哪条是身份约束、哪些在互相咬，摆清楚。这是方程组。
框出解空间。 这组约束一叠加，允许的行为就被夹到一个很窄的范围里：什么可行、什么被排除、最优的那个落在哪里。约束和解是同一件事的两面——把约束写全，解空间的形状自己就浮出来了。
解释实际操作。 这是收口，也是这引擎最值钱的地方：解空间里那个理性的最优行为，应该正好就是这个角色在现实里反复做的那些事。一条条对——他为什么这么做、为什么不那么做、为什么整个行业都往一个方向挤。约束找准了，这些"怪行为"会一个个从解空间里自动长出来，不必再假设谁蠢谁坏。
读者读完拿到的是一副解释器：原来这个角色的种种行为，不是性格、不是道德，是这几条约束把他夹在这个解空间里的必然。
Once constraints are identified, don't stop at the list. The explanatory power of constraints lies entirely in the solution space they frame. This section is the backbone of the engine, implemented in four steps.
Complete the Problem Statement. Combine goals and constraints. Do not only write "what it wants to do", but also "under what conditions it must do it". Once the problem statement is complete, many debates will disappear automatically: it turns out the solutions are different because the problems are different.
List the Constraint Set. Clearly present the constraints, each with its rigidity, which is the identity constraint, and which are conflicting. This is the system of equations.
Frame the Solution Space. When this set of constraints is combined, allowable behaviors are squeezed into a narrow range: what is feasible, what is excluded, where the optimal choice lies. Constraints and solutions are two sides of the same coin—complete the constraints, and the shape of the solution space emerges on its own.
Explain Actual Behaviors. This is the conclusion, and the most valuable part of the engine: the rational optimal behavior in the solution space should exactly match the repeated behaviors of the role in reality. Match them one by one—why it does this, why it doesn't do that, why the entire industry leans in one direction. If constraints are correctly identified, these "strange behaviors" will automatically emerge from the solution space, no need to assume anyone is stupid or malicious.
Readers will walk away with an interpreter: the various behaviors of this role are not due to personality or morality, but the inevitable result of being squeezed into this solution space by these constraints.

心内判据

Internal Validation Criteria

工序走完，这几条事后再过一遍闸，同样不写给人看。
  1. 解释力（主判据）——解空间里的理性最优行为，对不对得上现实中观察到的实际操作？对得上，约束才算找准；对不上，说明少了一条、或某条归错了硬度，回工序接着挖。这道闸对应降秩里的"反生成"——约束若不能把行为一个个生回来，就是没找到位。
  2. 题面完整——有没有把"目标 + 约束"一起写出来？如果只写目标，读者拿不到真正的问题。
  3. 错配可见——若原题是一场争论，有没有说明各方默认约束哪里不同？如果没有，文章容易滑回方案评判。
  4. 完备性——几条约束合起来，能不能框出这个角色的整个解空间？把一个典型情境往里一摆，落点对不对？
  5. 分层准——每条真的归对了世界/规则/解释？重点复查"硬约束"那一格，那里最容易混进冒充的。
  6. 真伪敢判——被当成硬的，有没有敢定性成软/自设的？（这是描述其真实硬度，不是给解法）
  7. 身份唯一——那条身份约束，拿掉之后角色是不是真的散架、变成别的东西？拿掉了还是它自己，说明找的不是身份约束。
过不了一条，回工序接着走。最要命的是第一条：解释力对不上，别的都白搭。
After completing the process, review these criteria mentally, do not write them for readers.
  1. Explanatory Power (Primary Criterion)—Does the rational optimal behavior in the solution space match the actual behaviors observed in reality? If yes, the constraints are correctly identified; if not, it means a constraint is missing or misclassified by rigidity, go back to the process and dig deeper. This corresponds to "anti-generation" in ljg-rank—if constraints cannot generate the behaviors one by one, they are not correctly identified.
  2. Complete Problem Statement—Have you written both "goal + constraints"? If only goals are written, readers won't get the real problem.
  3. Visible Mismatches—If the original input is a debate, have you explained where the default constraints of each party differ? If not, the article may slip into solution judgment.
  4. Completeness—Can the combined constraints frame the entire solution space of the role? When a typical scenario is applied, does the outcome match?
  5. Accurate Layering—Is each constraint correctly categorized into World/Rules/Interpretation? Focus on reviewing the "hard constraint" category, as it is most prone to impostors.
  6. Courageous Authenticity Judgment—Have you dared to reclassify constraints labeled as hard into soft/self-imposed? (This is describing their true rigidity, not providing solutions)
  7. Unique Identity—If the identity constraint is removed, will the role truly cease to exist and become something else? If it remains the same, the identified constraint is not an identity constraint.
If any criterion fails, go back to the process. The most critical is the first one: if explanatory power doesn't match, everything else is useless.

松动哪条（第二位，不参与诊断）

Which Constraint to Loosen (Secondary, Not Part of Diagnosis)

找约束的核心是描述当前的本质——是什么、框出什么解空间、解释什么行为。"怎么办更好"是另一件事，排在后面，而且不许反过来影响前面的诊断。急着找出口，就会看不清墙——这是这引擎最容易犯的病，务必压住。
诊断做完，可以附一句：这组约束里哪条其实能动。约束互斥、解空间被夹成空的时候，出路无非三条——放松一条、重定义一条、或者升维找一个当前视角看不见的解。真伪定性时判成"软/自设"的那条，就是能撬的地方。点到为止，一两句带过，绝不喧宾夺主。
创新常常就在这里发生：不是在旧约束里更努力，而是发现某条人人当作世界边界的东西，其实只是旧解释。"人不能飞"改写成"人不能只靠肉身飞"，问题就变了，解空间也变了。文末若要写松动，就写这种重定义：哪条不是命运，只是旧题面的残留。
The core of finding constraints is describing the current essence—what it is, what solution space it frames, what behaviors it explains. "How to do better" is another matter, secondary, and must not interfere with the initial diagnosis. Rushing to find an exit will make you fail to see the walls clearly—this is the most common mistake of this engine, must be avoided.
After diagnosis, you can add a brief note: which constraint in this set can actually be adjusted. When constraints conflict and the solution space is squeezed to empty, there are only three ways out—loosen one, redefine one, or elevate the perspective to find a solution invisible from the current view. The constraint classified as "soft/self-imposed" during authenticity qualification is the one that can be adjusted. Mention it briefly, do not overshadow the main content.
Innovation often happens here: not working harder within old constraints, but discovering that something everyone treats as a world boundary is actually just an old interpretation. Rewrite "humans cannot fly" to "humans cannot fly with only their bodies", and the problem changes, as does the solution space. If you write about loosening at the end, focus on this kind of redefinition: which is not fate, but a remnant of the old problem statement.

中文母语化 · 反坍缩闸

Chinese Nativization · Anti-Collapse Check

下笔前，默念三遍：「一个没读过英文的中国人，会这么说话吗？」 每写完一段再念一遍。答"不会"——别改词，整段推倒重想。
最容易踩的英语化毛病（踩到就重写整段，不是抠字眼）：
英语化中文母语
它建立在一个假设上它底下垫着一个假设
这一约束定义了 X这条约束把 X 框成了现在的样子
这意味着...也就是说... / 这就是为什么...
在...的过程中...的时候
对...而言对...来说
进行 + 名词换成动词
名词化抽象（"约束性"、"边界化"）换成具体的动词或物件
要改的不是词，是想事情的取景框——从英语句式切到中文白话作者的笔调（汪曾祺、王小波、阿城、李娟那一路）。写完默念出声，听耳朵卡不卡。卡的地方整段重写，不是修补。
另有一条：这是分析文，不是刀光文。别用"这一刀""再狠一层""锋利""钉死"这类元修辞去装力度。约束的力度靠把边界摸准、把行为解释透，不靠形容自己下手多重。
Before writing, repeat three times: 「Would a Chinese person who has never read English speak like this?」 Read each paragraph aloud after writing. If the answer is "No"—don't just change words, rewrite the entire paragraph.
Most common Anglicized mistakes (rewrite the entire paragraph if you make one, don't tweak words):
Anglicized ExpressionNative Chinese Expression
It is based on an assumptionIt rests on an assumption
This constraint defines XThis constraint frames X into its current form
This implies...That is to say... / This is why...
In the process of...When...
For...For... (natural phrasing)
Perform + nounReplace with a verb
Nominalized abstractions ("constraintness", "boundarization")Replace with specific verbs or objects
Change not just words, but the frame of thinking—switch from English sentence structures to the tone of native Chinese prose writers (like Wang Zengqi, Wang Xiaobo, A Cheng, Li Juan). Read aloud after writing, listen for awkwardness. Rewrite entire paragraphs where it feels awkward, don't patch.
Another rule: This is analytical writing, not aggressive writing. Do not use meta-rhetoric like "this knife", "dig deeper", "sharp", "nail down" to feign strength. The strength of constraint analysis comes from accurate boundary exploration and thorough behavior explanation, not describing how hard you "strike".

怎么写

How to Write It

一气呵成的散文，带读者走一段路——从"这个角色到处是规矩、有些行为还挺古怪"走到"原来就这几条约束把他夹在这么窄的解空间里，那些怪行为全是必然"。不分章节，不加小标题，让推理自己往前推。
三条要求：
  • 一口气读完——不熟这个领域的人也停不下来
  • 记得住——读完能转身用一句话跟朋友说清楚：这角色被什么框着，因此只能怎么做
  • 有落差——从"处处是墙、行为难解"到"几条约束一摆、行为自动长出来"，这个反差就是约束分析的美感
结构顺着脊椎走：先补全题面（目标加约束），再把约束组和硬度讲透（是什么），再框出解空间（能做什么、被夹在哪），最后落到解释力（这几条约束怎么把角色的实际操作一个个逼出来）——这一段是重心，写足。若写争论，要让读者看见双方从一开始就站在不同约束里。末尾至多一句松动，点到即止，不展开。
A cohesive prose piece that takes readers on a journey—from "this role has many rules, some behaviors are strange" to "it turns out these few constraints squeeze it into such a narrow solution space, those strange behaviors are all inevitable". No chapters, no subheadings, let the reasoning advance on its own.
Three requirements:
  • Can be read in one go—Even people unfamiliar with the domain can't stop reading
  • Memorable—After reading, readers can explain it to a friend in one sentence: what constraints frame this role, so it can only behave this way
  • Has a contrast—The contrast from "walls everywhere, behaviors hard to explain" to "a few constraints laid out, behaviors automatically emerge" is the beauty of constraint analysis
Follow the backbone structure: first complete the problem statement (goal + constraints), then thoroughly explain the constraint set and rigidity (what it is), then frame the solution space (what is feasible, where it is squeezed), and finally focus on explanatory power (how these constraints drive the role's actual behaviors)—this section is the core, write it in detail. If writing about a debate, let readers see that both parties started with different constraints. At most add one brief note on loosening at the end, stop there.

文末配一张 ASCII 结构图——形式跟着骨架走

Attach an ASCII Structure Diagram at the End — Form Follows Framework

光说"这几条约束"不够，要把它们和行为的关系画出来。下笔前先问：这组约束和它逼出的行为，是什么形状？答完再选画法。
硬约束：只用纯 ASCII 字符。 禁用任何 Unicode 符号（箭头 → ← ↑ ↓、方框 ┌─┐└┘│、圆点 • ● 等）。允许：字母、数字、汉字、空格，以及 
- = | + * / \ < > ^ v [ ] ( ) { } . , : ; _ #
。箭头用 
->
<-
^
v
，边框用 
+ - |
。
三种常用形态，挑跟工序摸出来的关系最贴的一种。图眼是解释力——让读者一眼看见行为怎么被约束夹出来。
Just saying "these few constraints" is not enough; visualize the relationship between constraints and behaviors. Before drawing, ask: What shape is the relationship between this set of constraints and the behaviors they drive? Choose the drawing method based on the answer.
Hard Constraint: Use only pure ASCII characters. Disable any Unicode symbols (arrows → ← ↑ ↓, boxes ┌─┐└┘│, dots • ●, etc.). Allowed: letters, numbers, Chinese characters, spaces, and 
- = | + * / \\ < > ^ v [ ] ( ) { } . , : ; _ #
. Use 
->
<-
^
v
for arrows, 
+ - |
for borders.
Three common forms, choose the one that best matches the relationship explored in the process. The core of the diagram is explanatory power—let readers see at a glance how behaviors are squeezed out by constraints.

1. 解释链图（默认）

1. Explanation Chain Diagram (Default)

适合：展示约束怎么把行为逼出来。这是这引擎的主图——约束 -> 解空间 -> 实际操作。
题面/约束组                  解空间                实际操作 (观察到的)
-----------                  ------                ------------------
目标: ...
[约束1: ...] (硬) --+
[约束2: ...] (软) --+-- 夹出 -> [只有 X 可行,   -> [角色反复在做 X]
[约束3: ...] (硬) --+          最优落在 X]         解释力: 对上了
演示要求：左边列具体约束、各标硬度；中间是被这组约束夹出的解空间（什么可行、最优落哪）；右边是现实里真观察到的行为。一条链让读者看见行为是被约束逼出来的必然。右边对不上左边，就是约束没找准，回去接着挖，别硬画一条对不上的链。
Suitable for: Showing how constraints drive behaviors. This is the main diagram of the engine—Constraints -> Solution Space -> Actual Behavior.
Problem Statement/Constraint Set  Solution Space        Actual Behavior (Observed)
------------------------------  ------------        --------------------------
Goal: ...
[Constraint 1: ...] (Hard) --+
[Constraint 2: ...] (Soft) --+-- Squeezes into -> [Only X is feasible,   -> [Role repeatedly does X]
[Constraint 3: ...] (Hard) --+          Optimal is X]         Explanatory Power: Matches
Presentation Requirements: List specific constraints on the left, mark each with rigidity; the middle is the solution space squeezed by the constraint set (what is feasible, where the optimal lies); the right is the actual behaviors observed in reality. A single chain lets readers see that behaviors are the inevitable result of constraints. If the right does not match the left, constraints are not correctly identified—go back and dig deeper, do not force a mismatched chain.

2. 硬度嵌套图

2. Rigidity Nesting Diagram

适合：展示约束按硬度分三层，看这个角色被什么夹得死、被什么只是拦一下。图眼是硬度的真实分布 + 真伪定性。
+=========================================+
|  自设约束 (认知层, 其实是软的)            |
|   - 某条被当成铁律、其实可重定义          |
|   +-----------------------------------+ |
|   |  软约束 (规则层, 违则受罚)          | |
|   |   - 监管 / 合同 / 行规             | |
|   |   +---------------------------+   | |
|   |   |  硬约束 (物理层, 违则崩)   |   | |
|   |   |   * 身份约束: 逃不掉那条   |   | |
|   |   |   - 时间 / 现金流 / 物理律 |   | |
|   |   +---------------------------+   | |
|   +-----------------------------------+ |
+=========================================+
演示要求：每层填具体约束；硬约束层用 
*
标身份约束（拿掉就散架的那条）；若真伪定性揪出一条"被当成硬、其实是软/自设"的，把它标在真实该在的那层，注一句"常被误当硬约束"。这是在描述硬度的真实分布，不是指路创新。
Suitable for: Showing constraints divided into three layers by rigidity, to see which tightly bind the role and which only block it. The core of the diagram is the true distribution of rigidity + authenticity qualification.
+=========================================+
|  Self-imposed Constraints (Cognitive Layer, actually soft) |
|   - A rule treated as ironclad, but redefinable |
|   +-----------------------------------+ |
|   |  Soft Constraints (Rules Layer, penalty for violation) | |
|   |   - Regulations / Contracts / Industry Norms | |
|   |   +---------------------------+   | |
|   |   |  Hard Constraints (Physical Layer, collapse on violation) | |
|   |   |   * Identity Constraint: The non-negotiable one | |
|   |   |   - Time / Cash Flow / Physical Laws | |
|   |   +---------------------------+   | |
|   +-----------------------------------+ |
+=========================================+
Presentation Requirements: Fill in specific constraints for each layer; mark the identity constraint (the one that breaks the role if removed) with 
*
in the hard constraint layer; if a constraint was "mistakenly treated as hard but is actually soft/self-imposed" during authenticity qualification, place it in its true layer and add a note "often mistaken for hard constraint". This describes the true distribution of rigidity, not guides innovation.

3. 约束矛盾图

3. Constraint Conflict Diagram

适合：几条约束互斥，解空间被夹成空，用来解释角色为什么表现出别扭、拧巴的行为。
   约束A: ...   ----+
                    +---- 解空间 = 交集 (此处为空)
   约束B: ...   ----+     => 角色被迫扭曲取舍: [具体的别扭行为]
   约束C: ...   ----+
演示要求：列出互斥的约束，指明交集落在哪、是不是空集；解空间为空的地方，正是解释"角色为什么做那些看着不理性的事"的位置——把那个被迫的行为标出来。这是用矛盾解释行为，不是急着给出路。
不设死板模板。要见骨——标出约束的名字、它的硬度、身份约束在哪、以及最要紧的：这几条约束把什么行为夹了出来。读者看图一眼，这个角色为什么这么做就入脑。
Suitable for: Conflicting constraints that squeeze the solution space to empty, used to explain why a role behaves awkwardly or twisted.
   Constraint A: ...   ----+
                    +---- Solution Space = Intersection (empty here)
   Constraint B: ...   ----+     => Role is forced to make twisted trade-offs: [specific awkward behavior]
   Constraint C: ...   ----+
Presentation Requirements: List mutually exclusive constraints, indicate where the intersection lies and if it is empty; empty solution spaces are exactly where you explain "why the role does seemingly irrational things"—mark that forced behavior. This uses conflicts to explain behaviors, not rush to provide solutions.
No rigid templates. Show the core—mark the names of constraints, their rigidity, where the identity constraint is, and most importantly: which behaviors are squeezed out by these constraints. Readers should understand why the role behaves this way at a glance.

输出

Output

  1. 获取时间戳：
    date +%Y%m%dT%H%M%S
    和 
    date "+%Y-%m-%d %a %H:%M"
  2. 写入 
    ~/Documents/notes/{时间戳}--{领域}的约束__constraint.org
    ，frontmatter 见 
    references/template.org
  3. 报告文件路径给用户
  1. Get timestamps: 
    date +%Y%m%dT%H%M%S
    and 
    date "+%Y-%m-%d %a %H:%M"
  2. Write to 
    ~/Documents/notes/{timestamp}--{domain}_constraints__constraint.org
    , refer to 
    references/template.org
    for frontmatter
  3. Report the file path to the user",