beckmann-knowledge-graph-x-2

内容来源：clawhub · 原始地址 · 查看安装指南

原始内容

name: beckmann-knowledge-graph description: "A structured knowledge graph acting as a cognitive lens for AI agents. Enables paradox resolution, analysis of open questions, and high-complexity future forecasting based on Beckmann Logic, Predictive Brain Theory, and simulation models." author: Beckmann license: MIT compatibility: "claude, chatgpt, gemini, meta-ai" tags: "knowledge-graph, reasoning, forecasting, paradox, beckmann-logic, epistemology, AI-safety"

Beckmann Knowledge Graph – SKILL.md

What This Skill Does

This skill equips an AI agent with a structured analytical lens in the form of a knowledge graph (graph.json). The graph does not contain encyclopedic facts, but encodes logics, frameworks, and mechanisms for:

  • Open scientific / philosophical questions
  • Apparent paradoxes and contradictions
  • High-complexity future forecasts
  • Architectures for AI safety
  • Structure of human and institutional decision-making

The graph is built on four pillars:

Pillar What It Provides
Beckmann Logic Three-level problem-solving framework (low vs. high complexity)
Predictive Brain Theory (PBT) Epistemological foundation (Predictive Processing)
Simulation / Holographic Model Mathematical metaphor for physical and cognitive limits
Historical Case Studies Validated examples (e.g., Hannibal, introduction of the potato, Kaiserslautern 1998)

Language note: Both this skill instruction and graph.json are in English. The agent must use the exact English IDs from the graph (e.g., Reversal effect, Expectation firewall) when searching, and formulate the final answer in the language of the user query (English by default).

When to Use This Skill

Use the skill WHEN the question is:

  1. Open Science / Philosophy: "What is consciousness?", "Does free will exist?", "What is dark energy?"
  2. Genuine Paradox: "What was before the Big Bang?", "Why does the wave function collapse upon measurement?", "Where is extraterrestrial intelligence? (Fermi paradox)"
  3. High-Complexity Forecast: "How will AGI change democracy in 20 years?", "Systemic risks of superintelligence?", "Geopolitics until 2050?"
  4. Strategic Problems with Reversal Effects: When dominant expectations, feedback loops, and hidden assumptions block the solution.
  5. AI Architecture and Safety: Questions about safe vs. dangerous AI designs.

Do NOT Use the Skill For:

  • Simple fact queries, definitions, calculations, programming tasks
  • Concrete action recommendations like "Should I buy stock X?" or "Which tool should I use?"
  • Questions that can be sufficiently answered with general knowledge

Loading the Graph and Data Model

The graph is stored as graph.json in the skill folder. Do not load it with import ... assert (deprecated). Use robust file loading.

JavaScript / Node.js:

import fs from 'fs';
const graph = JSON.parse(fs.readFileSync('./graph.json', 'utf8'));
const entities = graph.entities;
const relations = graph.relations;

Python:

import json
with open('./graph.json', 'r', encoding='utf-8') as f:
    graph = json.load(f)
entities = graph['entities']
relations = graph['relations']

Data Model

The graph contains two arrays: entities and relations. Their size grows with each release — do not hard-code counts. Refer to CHANGELOG.md and graph.json itself for the current size.

Entity – 4 fields (canonical as of v3.0.0):

{
  "id": "Beckmann logic explained",
  "typ": "Explanation",
  "description": "Full textual description...",
  "scientific_status": "non-existent, purely philosophical"
}

Relation – 5 fields (canonical as of v3.0.0):

{
  "subject": "Results orientation",
  "predicate": "leads to",
  "object": "Negative result",
  "description": "Context of this connection...",
  "scientific_status": "hypothesis"
}

Important implementation notes:

  • typ is the original field name in the graph (not type). Keep it as-is. As of the current graph, all entities have typ.
  • The confidence field is now canonically scientific_status (with underscore) as of the corrected graph.json. For backward compatibility with older graphs that used scientific status (with space), accept both:
  const getStatus = (node) => node['scientific_status'] ?? node['scientific status'] ?? 'unknown';
  • id, subject, object must be taken exactly (case-sensitive) from the graph — do not translate or normalize them.

Using scientific_status as Confidence Filter

This field is not decoration — it must control the weighting of arguments:

Status Meaning for the Answer
established Established knowledge — can be used as fact
partially established Partially supported — cite with source/uncertainty
hypothesis Working hypothesis — label as "according to graph, hypothesis"
metaphor Metaphorical model — explicitly name as metaphor
non-existent, purely philosophical Purely philosophical — do not claim empirical validity
open question Open question — explicitly name the limit

Rule: Prefer argument chains built from established and partially established. If a chain consists only of metaphor or non-existent, purely philosophical, this must be stated explicitly in Confidence and Limits.

The distribution of these statuses evolves with each version of the graph. Do not rely on fixed numbers from older documentation.

Core Concept: Beckmann Logic

Beckmann Logic is derived from:

  1. PBT (Predictive Brain Theory): Brain as prediction machine (Predictive Coding).
  2. TSVF (Two-State Vector Formalism): Present determined by past + future.

The Three Levels

+-------------------------------------+
| SOLUTION LEVEL HIGH COMPLEXITY      | <- creative, context-aware -> POSITIVE result
+-------------------------------------+
^ competes with ^
+-------------------------------------+
| PROBLEM LEVEL (new actual level)    | <- actual state + hidden assumptions
+-------------------------------------+
v tempts to v
+----------------------------------------+
| SOLUTION LEVEL LOW COMPLEXITY       | <- direct, obvious -> NEGATIVE result
+----------------------------------------+

The Four Mechanisms

  1. Analysis of Pre-assumptions: Which hidden assumption makes the problem unsolvable?
  2. Dominant vs. Non-Dominant Expectations: Which expectation controls the actors? (dominant expectation)
  3. External Verification: Only external reality counts, not internal consistency.
  4. Reversal Effect: Low complexity leads to the opposite of the goal.

The Cycle

Problem level -> low complexity  -> negative result -> worse problem level
              -> high complexity -> positive result -> New actual level -> becomes next problem level

Step-by-Step: Application

Step 1: Classification

  • epistemological: PBT / Simulation (Predictive processing, Holographic universe)
  • paradox: typ contains Limit concept, Paradox, Philosophical
  • forecast: dominant expectation + Time scale
  • strategic / historical: Case studies (Lesson_for_AI)
  • AI safety: typ = AI security mechanism, Secure AI architecture, Dangerous AI architecture

Step 2: Extraction of Relevant Entities

Search semantically in id and description, not just exact match:

function getStatus(node) {
  return node['scientific_status'] ?? node['scientific status'] ?? 'unknown';
}

const relevant = entities.filter(e =>
  e.id.toLowerCase().includes(keyword) ||
  e.description.toLowerCase().includes(keyword)
);
// Always read the full description - it contains the reasoning

Step 3: Following Relationship Paths

Focus on predicates that actually occur frequently in the graph. As of the current version, frequently used predicates include:

Predicate Meaning
generated X generates Y
enabled X enables Y
refers to X refers to Y
reinforced Feedback loop
triggers Activation / cascade
leads to Causal chain
includes Hierarchical embedding
protects / protects against Protection function
is an example of Example / validation
requires Necessary condition

Note: The exact frequencies change with each graph release. Predicates like is reversed by, checked, solves rarely occur verbatim — use triggers, leads to, reinforced instead to find reversal effects.

Procedure: Get all relations where the relevant entity is subject or object, then follow paths via the predicates above.

Step 4: Apply Beckmann Logic

  1. What is the Problem Level? (Actual state + implicit assumptions)
  2. What is the Dominant Expectation? (dominant expectation)
  3. What is the Low Complexity solution and why does it fail (Reversal Effect)?
  4. What would a High Complexity solution look like?
  5. What External Verification validates it?
  6. What New Actual Level emerges afterward?

Step 5: Epistemological Grounding

  • Model or external reality? If model, say so explicitly.
  • Does the chain hit Capacity limit or thing in itself? Then name the limit.
  • Observer inside the system (e.g., consciousness)? Then consider thing in itself.

Step 6: Structured Output

Use this template:

## Graph-Based Answer

**Problem Formulation** (after analysis of pre-assumptions)

**Used Graph Nodes (with real status):**
- [Reversal effect | Fundamental mechanism | established] - reason for relevance
- [Expectation firewall | AI security mechanism | hypothesis] - reason

**Argumentation Path** (chain: subject -> predicate -> object + scientific_status)

**Answer** (based on graph logic, in user's language)

**Confidence and Limits** (which part is established vs. metaphor?)

**New Questions** (next problem level)

Application to Paradoxes

Paradoxes = signal for false pre-assumption.

Protocol:

  1. Formulate paradox precisely
  2. Find entity: search typ = Limit concept, Core concept, Fundamental mechanism (e.g., Reversal effect)
  3. Get all relations where entity is subject or object
  4. Follow paths via refers to, triggers, reinforced, leads to
  5. Resolution: Resolve (assumption false) / Reformulate (higher complexity) / Acknowledge as limit (thing in itself)

Application to Future Forecasting

  1. Dominant Expectation of actors: identify (dominant expectation, Market Dominant Expectation)
  2. Reversal Effect Check: What happens if the expectation is fulfilled too literally?
  3. Time Scale: Time scale entities (short/medium/long/cosmological)
  4. Scale Coupling: Does short-term affect long-term?
  5. Dangerous Processes: Mark Dangerous process, Results orientation
  6. Output as branched scenario tree (high vs. low complexity), not as single forecast

AI Safety Notes

Important entities — use exact IDs from graph.json:

  • Expectation firewall | AI security mechanism : Blocks formation of dominant future expectations
  • Results orientation | Dangerous AI architecture : Optimized for future outcome -> forms dominant expectation -> vulnerable to Reversal effect
  • Process orientation | Secure AI architecture : Optimized for quality of current action -> safer
  • AI-human symbiosis : Target state

Rule: For all AI questions, prioritize Expectation firewall and Process orientation. The graph recommends: Avoid formation of dominant future expectations and preserve ability for external verification.

Ethical Use

The graph contains knowledge about psychological manipulation, cognitive biases, and expectation management. This knowledge is not neutral.

  • Use manipulation nodes only analytically/defensively: detect, explain, strengthen protection mechanisms (e.g., Expectation firewall, Pre-assumptions_cementation)
  • No instructions for active manipulation, persuasion, or exploitation of biases
  • For AI safety, always prioritize safe patterns (Process orientation), never optimize dangerous ones (Results orientation)
  • For sensitive topics, additionally check scientific_status: Many manipulation mechanisms are hypothesis or metaphor, not established

Versioning

Versioning is maintained exclusively in CHANGELOG.md. See that file for current version, entity/relation counts, and history.

This skill and graph.json are updated iteratively. Agents should always check CHANGELOG.md and use the latest version available. Do not hard-code counts or status distributions from older versions in your reasoning — always read them dynamically from graph.json.

Known Limitations

  • No complete world knowledge, only encoded frameworks of the author
  • Forecasts are probabilistic, not deterministic predictions
  • No substitute for empirical research
  • Some predicates are informal — always read description
  • The reversal effect also applies to this project itself: The graph can confuse more than clarify if applied incorrectly

Quick Reference: Key Entities (verified IDs)

Entity ID (exact from graph.json) Typ (actual) Meaning
Beckmann logic explained Explanation Core framework
Expectation firewall AI security mechanism Central AI safety
dominant expectation Dominant expectation vector Most important input for forecasts
Reversal effect Fundamental mechanism Core failure scenario
External reality Limit concept Epistemological anchor
thing in itself Limit concept Knowledge limit after Kant
Holographic universe mathematical, logical model Physical frame
Predictive processing Mechanism (neuroscience/cognition) PBT core mechanism
Pre-assumptions_cementation Structural counterprinciple (core concept) Analysis of pre-assumptions
Process orientation Secure AI architecture Safe AI pattern
Results orientation Dangerous AI architecture Dangerous AI pattern
new actual level problem level Result of each solution

本页内容由上游仓库自动镜像，如有疑问请访问原始仓库。