Question Theory
#core-framework #computational-lens
What It Is
Questions are compulsory computational operations that hijack the brain's search machinery and force it to generate answers. Unlike statements that trigger resistance or agreement evaluation, and unlike intentions that merely simulate futures, questions create obligatory search processes that cannot be ignored. When posed with a question, your brain automatically enters search mode, binds attention to the query structure, and continues executing until an answer is produced.
This is not metaphor. Questions function identically to database queries in graph databases—they specify start nodes, traversal patterns, constraints, and stopping conditions. Every question maps directly to a Cypher query with measurable computational cost.
Example - Bounded Question:
// Natural: "What's the next action on highest-priority task?"
MATCH (me)-[:HAS_TASK]->(task)
WHERE task.status = "active"
RETURN task.next_action
ORDER BY task.priority DESC
LIMIT 1
Cost: O(n log n), returns single concrete action
Example - Unbounded Question:
// Natural: "How can I be better?"
MATCH (anything)
WHERE anything.might_help_me = true
RETURN anything
Cost: O(∞), never completes or returns random result
Understanding questions as computational operations transforms question-asking from intuitive art to systematic engineering. Poor questions impose exponential computational costs while generating vague abstractions. Optimized questions perform bounded searches that return immediately actionable answers.
Questions as Reality Programming
Questions are not neutral inquiry tools—they are programs that execute to create future reality. When you ask yourself a question, you initiate a search process that shapes subsequent attention, action, and outcomes. The question determines what your brain searches for, what patterns it recognizes, and what solutions it generates. This makes questions powerful reality-programming tools.
"What's wrong with me?" programs your attention to search for deficiencies, primes pattern recognition for failures, and generates explanations framed as character flaws. This question executes to create future reality where you continue seeing yourself as flawed. Not because the question reveals truth, but because the search process it initiates shapes what you notice and how you interpret it.
"What mechanism prevents work launch?" programs your attention to search for causal chains, primes pattern recognition for system behavior, and generates mechanistic explanations. This question executes to create future reality where you debug and improve systems. The question type determines the reality compiled.
This is self-fulfilling prophecy at the computational level. Questions are prophecies disguised as neutral inquiry. The prophecy fulfills because the search process initiated by the question shapes subsequent cognition and action. Asking "What's the next action?" repeatedly programs execution-oriented reality. Asking "Why can't I do this?" repeatedly programs limitation-oriented reality. Same person, different questions, different futures compiled through different search processes.
The Forcing Function Property
Questions differ fundamentally from other language forms because they compel computation:
| Language Form | Brain Response | Willpower Cost | Example |
|---|---|---|---|
| Statement | Resistance/agreement evaluation | 2-3 units | "I should eat healthier" |
| Intention | Future simulation (no action) | 0 units | "I will eat healthy" |
| Command | Can be resisted | 2-3 units to comply | "Start working" |
| Question | Automatic search (cannot be ignored) | 0 units | "What prevents me from eating the predetermined meal?" |
The question "What's the mechanism that prevents work launch?" establishes a type constraint through the word "mechanism"—character-based answers like "you're lazy" are automatically rejected. The question must return a causal chain.
// Moralistic question (accepts character traits)
MATCH (me)-[:HAS_CHARACTER_FLAW]->(flaw)
RETURN flaw
// No such property exists in reality
// Mechanistic question (requires causal chain)
MATCH (work_launch {status: "failed"})<-[:PREVENTS]-(cause)
RETURN cause.mechanism
// Returns actual debuggable mechanism
This is zero-cost error prevention through type systems. If you habitually ask "What's the mechanism?" instead of "What's wrong with me?", you prevent moralistic thinking without requiring Willpower to resist it.
Four Properties of Effective Questions
Property 1: Search Space Specificity
Search space specificity determines whether a question completes at all.
| Question Type | Example | Cypher Equivalent | Cost | Completes? |
|---|---|---|---|---|
| Unbounded | "How can I be better?" | MATCH (anything) RETURN anything |
O(∞) | Never |
| Domain-bounded | "How can work launch improve?" | MATCH (work_launch)-[:HAS_IMPROVEMENT]->(i) RETURN i |
O(n) | Yes |
| Time-bounded | "What's next 25-min action?" | MATCH (task)-[:NEXT_ACTION]->(a {duration: 25}) RETURN a LIMIT 1 |
O(1) | Yes |
| Fully-bounded | "What's next action on highest-priority task?" | MATCH (task {priority: "highest"})-[:NEXT_ACTION]->(a) RETURN a |
O(1) | Yes |
Unbounded example:
graph TD
Q[What should I do?]
Q --> A[Option A]
Q --> B[Option B]
Q --> C[Option C]
Q --> D[...]
Q --> E[Option N]
A --> A1[Sub-option A1]
A --> A2[...]
B --> B1[...]
C --> C1[...]
style Q fill:#ff9999
style E fill:#ff9999
// "What should I do?"
MATCH (current_state_of_entire_world)
MATCH (current_state)-[:CAN_TRANSITION_TO]->(next_state)
RETURN next_state
// Returns: infinite branches, no way to choose, never completes
Bounded example:
graph TD
Q[What's next action on<br/>highest-priority task?]
Q --> P[Get priority task]
P --> A[Get next action]
A --> R[Return: specific action]
style R fill:#99ff99
// "Given lounge state, what's the transition to work state?"
MATCH (lounge_state)-[:TRANSITIONS_TO {trigger: X}]->(work_state)
RETURN trigger
// Returns: specific mechanism, completes immediately
Property 2: Framing Constraint
Questions specify what constitutes a valid answer through type constraints:
| Moralistic Framing | Mechanistic Framing |
|---|---|
| "Why am I lazy?" | "What mechanism prevents work launch?" |
| "Why do I lack discipline?" | "What's the activation energy for this behavior?" |
| "Why can't I focus?" | "What competes for attention right now?" |
| "Why am I weak-willed?" | "How many willpower units were spent before this decision point?" |
// Moralistic framing
MATCH (me)-[:HAS_CHARACTER_FLAW]->(flaw)
RETURN flaw
// Type: Character trait (unactionable)
// Mechanistic framing
MATCH (behavior)-[:PREVENTED_BY]->(mechanism)-[:CAUSES]->(root_cause)
RETURN mechanism, root_cause
// Type: Causal chain (debuggable)
Property 3: Observability
Observable questions ground answers in checkable reality:
| Unobservable | Observable |
|---|---|
| "Am I making progress?" | "What's the 30-day delta in tracked metrics?" |
| "Do I work hard?" | "How many hours logged vs planned this week?" |
| "Am I disciplined?" | "How many times did predetermined sequence execute?" |
| "Is this relationship healthy?" | "What does HRV trend show over 14 days?" |
// Unobservable
MATCH (me)-[:HAS_PROPERTY]->(discipline)
RETURN discipline.level
// Returns: ERROR - no such property exists
// Observable
MATCH (whiteboard)-[:DISPLAYS]->(data {date: today()})
RETURN data.weight, data.calories, data.gym_attendance
// Returns: Actual numbers from whiteboard
Property 4: Action Relevance
Good questions generate answers executable within 5 minutes:
| Abstract (Not Actionable) | Concrete (Actionable) |
|---|---|
| "How do I eat healthier?" | "What forcing function eliminates breakfast decision point?" |
| "How do I be more productive?" | "What's the next 25-minute work chunk?" |
| "What's my purpose?" | "What's the next action on highest-priority task?" |
| "How do I succeed?" | "What metric needs to improve this week?" |
Descending the abstraction ladder:
// Level 1: Too abstract
MATCH (abstract_goal {name: "eat healthier"})
RETURN abstract_goal
// No path to implementation
// Level 2: More specific
MATCH (meals)-[:IS_PROBLEMATIC]->(breakfast)
RETURN breakfast
// Still requires decomposition
// Level 3: Mechanistic
MATCH (breakfast)-[:PREVENTED_BY]->(decision_point)
RETURN decision_point
// Getting closer
// Level 4: Actionable forcing function
MATCH (decision_point)-[:ELIMINATED_BY]->(forcing_function)
WHERE forcing_function.type = "prevention_architecture"
RETURN forcing_function.implementation
// Returns: "No outside breakfast policy - only home meals allowed"
Computational Cost Framework
Every question has computational cost and utility:
High Utility
|
Q3 | Q1
(Medium) | (Ideal)
|
──────────────┼──────────────── High Cost
|
Q4 | Q2
(Worst) | (Useless)
|
Low Utility
Cost Categories
| Complexity | Example Question | Cypher Pattern | When to Use |
|---|---|---|---|
| O(1) Constant | "What's on the whiteboard?" | MATCH (node {id: "specific"}) RETURN node.property |
Checking current state |
| O(n) Linear | "What are today's tasks?" | MATCH (today)-[:HAS_TASK]->(tasks) RETURN tasks |
Enumerating direct relationships |
| O(n log n) Logarithmic | "What's highest-priority task?" | MATCH (tasks) RETURN tasks ORDER BY priority DESC LIMIT 1 |
Finding optimal values |
| O(n²) Quadratic | "What factors interact?" | MATCH (a), (b) WHERE a.relates_to = b RETURN a, b, relationship(a,b) |
System analysis |
| O(2ⁿ) Exponential | "What are all possible strategies?" | MATCH paths = (start)-[*]->(end) RETURN paths |
Almost never - reformulate |
Cost Reduction Patterns
| Before (Expensive) | After (Optimized) | Reduction |
|---|---|---|
| "What are my options?" | "What's the next action on highest-priority task?" | O(2ⁿ) → O(log n) |
| "How can I improve?" | "What's one improvement to work launch sequence?" | O(n²) → O(n) |
| "What should I do?" | "Given lounge state, what's the transition to work state?" | Unbounded → Bounded |
| "Tell me about X" | "What are the three key factors in X?" | O(n) → O(1) |
The Nine Question Pathologies
Pathology 1: Unbounded Search Space
Symptoms: Mind goes blank, analysis paralysis, overwhelming feeling
Examples:
- ❌ "What should I do?"
- ❌ "How can I be better?"
- ❌ "What are all my options?"
// Attempts to return EVERYTHING
MATCH (anything)
RETURN anything
// Never completes
Fix Protocol:
// Add constraints progressively
// Step 1: Domain
MATCH (work_tasks)
WHERE work_tasks.domain = "work_launch"
// Step 2: Timeframe
AND work_tasks.timeframe = "next_25_minutes"
// Step 3: Priority
RETURN work_tasks
ORDER BY work_tasks.priority DESC
LIMIT 1
// Now completes in O(log n)
Pathology 2: Moralistic Framing
| Moralistic (Bad) | Mechanistic (Good) |
|---|---|
| "Why am I so lazy?" | "What mechanism prevents work launch?" |
| "Why do I lack discipline?" | "What's the activation energy for this behavior?" |
| "What's wrong with my willpower?" | "How many willpower units were spent before this decision point?" |
| "Why can't I just start?" | "What's the activation energy for starting?" |
// Moralistic framing
MATCH (me)-[:HAS_CHARACTER_FLAW]->(flaw)
RETURN flaw
// No such property exists in reality, only generates guilt
// Mechanistic framing
MATCH (work_launch {status: "failed"})<-[:PREVENTS]-(cause)
RETURN cause.mechanism
// Returns debuggable causal chain
Pathology 3: Unobservable Target
Conversion table:
| Unobservable | Observable | Measurement Device |
|---|---|---|
| "Am I making progress?" | "What's the 30-day delta in tracked metrics?" | Tracking log |
| "Do I work hard?" | "How many hours logged vs planned this week?" | Time tracker |
| "Am I disciplined?" | "How many times did predetermined sequence execute?" | Execution log |
| "Is this healthy?" | "What does HRV trend show over 14 days?" | Whoop device |
Pathology 4: Abstract Non-Actionable
The abstraction ladder (descend until actionable):
Level 1: "How do I eat healthier?" ← Too abstract
↓
Level 2: "What specific meal is problematic?" ← More specific
↓
Level 3: "What mechanism causes off-plan eating?" ← Mechanistic
↓
Level 4: "What forcing function eliminates decision point?" ← Actionable
↓
Level 5: "Implement no-outside-breakfast policy" ← Executable
Pathology 5: No Stopping Condition
| No Boundary | With Boundary |
|---|---|
| "Tell me about willpower" | "What are three ways willpower depletes?" |
| "What are the factors?" | "What's the highest-leverage factor?" |
| "Explain this concept" | "What's the key property that makes it useful?" |
// No stopping condition
MATCH (nodes)-[:RELATED_TO]->(topic)
RETURN nodes
// Returns everything, overflows working memory
// With explicit boundary
MATCH (nodes)-[:RELATED_TO]->(topic)
RETURN nodes
ORDER BY impact DESC
LIMIT 3
// Returns focused, complete answer
Pathology 6: Missing Start Node
// Missing start node
MATCH (???)-[:LEADS_TO]->(goal)
RETURN ???
// No starting point specified, multiple possible interpretations
// With start node
MATCH (lounge_state)-[:TRANSITIONS_TO {via: X}]->(work_state)
WHERE lounge_state.current = true
RETURN X
// Clear start node enables deterministic traversal
Pathology 7: Cartesian Product
// Cartesian product - compares everything to everything
MATCH (a), (b)
RETURN a, b, relationship(a,b)
// O(n²) exponential cost
// Constrained join
MATCH (a)-[:DIRECTLY_CAUSES]->(b)
WHERE impact > 0.2
RETURN a, b
// O(n) linear cost with specific relationship
Pathology 8: Future Simulation
| Future Simulation (Bad) | Current Reality (Good) |
|---|---|
| "What will I do tomorrow?" | "What prevents execution right now?" |
| "How will I handle this?" | "What's the immediate next action?" |
| "What's my plan?" | "What's actually on today's schedule?" |
| "When will I start?" | "What makes start not happen right now?" |
Pathology 9: Rhetorical Non-Questions
| Rhetorical | Genuine |
|---|---|
| "Don't you think you should work?" | "What prevents work launch right now?" |
| "Isn't it obvious that X?" | "What's the mechanism here?" |
| "Why don't you just start?" | "What's the activation energy for starting?" |
Search Algorithms Questions Trigger
Algorithm Comparison Table
| Algorithm | Triggered By | Cost | Use Case | Cypher Pattern |
|---|---|---|---|---|
| Depth-First Causal | "What caused X?" | O(d) to O(b^d) | Debugging failures | MATCH (effect)<-[:CAUSES*]-(root) |
| Breadth-First Enum | "What are all X?" | O(n) | Complete inventories | MATCH (start)-[:REL]->(neighbors) |
| Greedy Local | "What's highest priority?" | O(n) | Decision-making | MATCH (options) RETURN max(value) |
| Pattern Matching | "Is this pattern X?" | O(m×n) | Classification | MATCH (current) WHERE matches(pattern) |
| Backward Chaining | "How do I get to X?" | O(d) | Planning | MATCH (goal)<-[:REQUIRES*]-(current) |
| Forward Simulation | "What happens if X?" | O(s^d) | Risk assessment | MATCH (decision)-[:LEADS_TO*]->(outcome) |
Backward Chaining Example
// Question: "How do I get work launched?"
// Step 1: Start at goal
MATCH (goal {state: "work_launched"})
// Step 2: Find what requires this
MATCH (goal)<-[:REQUIRES]-(prerequisite1)
RETURN prerequisite1
// Returns: "work sequence executed"
// Step 3: Find what requires that
MATCH (prerequisite1)<-[:REQUIRES]-(prerequisite2)
RETURN prerequisite2
// Returns: "morning mantra + braindump completed"
// Step 4: Continue backward
MATCH (prerequisite2)<-[:REQUIRES]-(prerequisite3)
RETURN prerequisite3
// Returns: "wake at 5am"
// Step 5: Final step
MATCH (prerequisite3)<-[:REQUIRES]-(prerequisite4)
RETURN prerequisite4
// Returns: "sleep by 10pm"
// Complete path: sleep 10pm → wake 5am → mantra → braindump → work launches
The Forward/Backward Asymmetry
Why Forward Search Fails
// "Work forwards": What should I do next?
MATCH (current_state_of_entire_world)
├── All nodes (every fact, concept, possibility)
├── All edges (every relationship)
├── All properties (every attribute)
└── Infinite possible transitions
// Attempt:
MATCH (current_state)-[:CAN_TRANSITION_TO]->(next_state)
RETURN next_state
// Returns: infinite branches, no way to choose, never completes
// Cost: O(∞)
Why Backward Search Works
// "Work backwards": What requires work launched?
MATCH (goal_state {id: "work_launched"})
// Step backward:
MATCH (goal_state)<-[:REQUIRES]-(step1)
RETURN step1
// Returns: "work sequence executed"
// Continue:
MATCH path = (current_state)-[:LEADS_TO*]->(goal_state)
WHERE goal_state.id = "work_launched"
RETURN path
ORDER BY length(path) ASC
LIMIT 1
// Cost: O(d) where d = depth to goal
Comparison Table
| Dimension | Forward Search | Backward Search |
|---|---|---|
| Start node | Unbounded (entire world) | Bounded (specific goal) |
| Question | "What can I do?" | "What requires this?" |
| Answer space | Infinite options | Finite path |
| Stopping condition | None | Current state reached |
| Branching | Exponential | Limited (few prerequisites per node) |
| Cost | O(∞) | O(d) |
| Result | Paralysis or random | Clear path |
Diagnostic Protocol
Five-step checklist for evaluating question quality:
| Step | Check | Red Flags | Green Flags | Fix |
|---|---|---|---|---|
| 1. Search Space | Is it bounded? | "all", "everything", "best possible" | Domain, timeframe, scope specified | Add constraints |
| 2. Framing | What answer types allowed? | Moralistic, character-based, vague | Mechanistic, causal, numerical | Reframe to require mechanism |
| 3. Observability | Can answer be verified? | Mood-dependent, no measurement | Measurable, checkable against log | Convert to observable metric |
| 4. Actionability | Executable in 5 min? | Requires further planning, abstract | Specifies exact steps | Descend abstraction ladder |
| 5. Cost/Utility | Worth the search cost? | High cost, low utility | Low cost, high utility | Add constraints or increase specificity |
Query Optimization Patterns
Pattern 1: Indexed Lookup vs Full Scan
// Bad: Full scan
MATCH (n)
WHERE n.property = value
RETURN n
// Cost: O(n) - must check every node
// Good: Indexed lookup
MATCH (n:Label {property: value})
RETURN n
// Cost: O(1) - direct access via index
Question equivalent:
- ❌ "What was that thing I did?"
- ✅ "What task did I complete on December 15th?"
Pattern 2: Limit Early vs Limit Late
// Bad: Limit late
MATCH (n)-[:REL*]->(m)
RETURN m
ORDER BY m.value DESC
LIMIT 1
// Cost: Explores entire graph, then filters
// Good: Limit early
MATCH (n)-[:REL]->(m)
WHERE m.value > threshold
RETURN m
ORDER BY m.value DESC
LIMIT 1
// Cost: Prunes during traversal
Pattern 3: Specific vs Any Relationship
// Bad: Any relationship
MATCH (a)-->(b)
RETURN a, b
// Cost: Follows all edge types
// Good: Specific relationship
MATCH (a)-[:CAUSES]->(b)
RETURN a, b
// Cost: Follows only causal edges
Question equivalent:
- ❌ "How does this relate to anything?"
- ✅ "What directly causes this?"
Practical Examples
Example 1: Work Launch Failure
| Bad Sequence | Good Sequence |
|---|---|
| "Why didn't I work today?" (moralistic) | "What was the actual sequence of events?" (reality check) |
| "What's wrong with me?" (unbounded, moralistic) | "What script executed instead of work script?" (diagnostic) |
| "How do I be more disciplined?" (abstract) | "What made tool exploration more salient than work?" (mechanism) |
| "What should I do differently?" (simulation) | "What's the earliest intervention point?" (intervention) |
Diagnostic question execution:
// Question: "What script executed instead of work script?"
MATCH (me)-[:EXECUTED]->(script {time: "morning"})
WHERE script.type = "default"
AND script.name != "work_script"
RETURN script
// Returns: {
// name: "tool_exploration_script",
// trigger: "Anytype visible",
// activation_cost: 2,
// reward: "novelty dopamine + visible progress"
// }
// Mechanism identified: Lower activation cost (2 vs 6) + immediate reward
// Intervention: Tab blocker to prevent Anytype access during work hours
Example 2: Feeling "Unmotivated"
// Question: "Which variable in expected value calculation changed?"
// Formula: EV = (reward × probability) / (effort × time_distance)
MATCH (task)-[:HAS_REWARD]->(r {value: current})
MATCH (task)-[:HAS_PROBABILITY]->(p {value: current})
MATCH (task)-[:HAS_EFFORT]->(e {value: current})
MATCH (task)-[:HAS_TIME_DISTANCE]->(t {value: current})
WITH r.value as reward,
p.value as probability,
e.value as effort,
t.value as time_distance,
t.previous_value as time_distance_prev
RETURN
(reward * probability) / (effort * time_distance) as EV_current,
(reward * probability) / (effort * time_distance_prev) as EV_previous,
CASE
WHEN time_distance > time_distance_prev THEN "time_distance increased"
END as diagnosis
// Returns: {
// EV_current: 0.3,
// EV_previous: 2.1,
// diagnosis: "time_distance increased (90 days to Julius arrival)"
// }
// Intervention: Create intermediate milestones at 30 days
Integration with Other Concepts
| Concept | How Question Theory Connects |
|---|---|
| Moralizing vs Mechanistic | "What's the mechanism?" prevents moralistic thinking through type constraints |
| Working Memory | Bounded questions respect 4-7 item limit; unbounded questions overflow capacity |
| State Machines | Diagnostic questions debug state: "What script is running?" "What prevents transition?" |
| Activation Energy | Backward chaining reduces startup costs by eliminating "where to start" ambiguity |
| Prevention Architecture | "What forcing function prevents this?" generates architectural solutions |
| Tracking | Observable questions require measurement devices to convert narrative to data |
Related Concepts
- Moralizing vs Mechanistic - Questions as the operational manifestation of paradigm shift
- Working Memory - Why question design must respect 4-7 item capacity limits
- State Machines - Diagnostic questions for debugging state and transitions
- Activation Energy - Concrete questions reduce startup costs
- Prevention Architecture - Intervention design questions generate forcing functions
- Tracking - Measurement enables reality check questions
- The Braindump - Question structure determines clarity versus confusion
- Discretization - Specific bounded questions versus abstract continuous ones
- Expected Value - Mechanism questions identify which variable changed
- Pedagogical Magnification - Resolution determines search complexity and compute cost
Key Principle
Engineer your questions to engineer your thinking - Questions are compulsory computational operations that determine what searches your brain runs. Poor questions impose exponential costs and generate vague abstractions. Optimized questions perform bounded searches returning actionable answers. Install "What's the mechanism?" as default to prevent moralistic thinking through type constraints. Use backward chaining from specific goals instead of forward planning from unbounded current state. Add constraints until search space fits in working memory. Convert unobservable to observable, abstract to concrete, simulation to reality. The question determines the answer—design questions carefully.
Questions are not optional prompts. They are forcing functions that hijack search machinery and compel execution. Understanding this transforms question-asking from intuitive art to systematic engineering. Install the right questions as defaults, and right thinking follows automatically.