System Metacognition

Overview: How It All Connects

┌─────────────────────────────────────────────────────────────────┐
│                      Sys2DSL Script                             │
│  @var COMMAND subject VERB complement                           │
└───────────────────────────┬─────────────────────────────────────┘
                            │
                            ▼
┌─────────────────────────────────────────────────────────────────┐
│                    DSL Engine (dsl_engine.js)                   │
│  ┌──────────────┐  ┌──────────────┐  ┌──────────────┐          │
│  │   Parser     │─▶│  Topological │─▶│   Command    │          │
│  │              │  │    Sorter    │  │   Executor   │          │
│  └──────────────┘  └──────────────┘  └──────────────┘          │
└───────────────────────────┬─────────────────────────────────────┘
                            │
        ┌───────────────────┼───────────────────┐
        ▼                   ▼                   ▼
┌───────────────┐   ┌───────────────┐   ┌───────────────┐
│ Concept Store │   │ Theory Stack  │   │   Reasoner    │
│ (knowledge)   │   │ (layers)      │   │ (inference)   │
└───────┬───────┘   └───────┬───────┘   └───────┬───────┘
        │                   │                   │
        ▼                   ▼                   ▼
┌─────────────────────────────────────────────────────────────────┐
│                    Vector Space (1024 dims)                     │
│  ┌─────────────────────┐  ┌─────────────────────────────────┐  │
│  │  Ontology (0-255)   │  │  Axiology (256-383) + Extended  │  │
│  │  Facts, categories  │  │  Values, norms, context         │  │
│  └─────────────────────┘  └─────────────────────────────────┘  │
└─────────────────────────────────────────────────────────────────┘
      

1. Knowledge Layer: Concept Store

The Concept Store maintains all known concepts, facts, and their relationships.

Introspection Commands

Example: Self-Assessment of Knowledge

# How much do we know about animals?
@animalFacts FACTS_MATCHING ? IS_A animal
@animalCount COUNT $animalFacts

# What concepts are most used?
@dogUsage GET_USAGE Dog
@catUsage GET_USAGE Cat

# Check knowledge coverage
@hasTemperature NONEMPTY FACTS_MATCHING ? BOILS_AT ?
@text TO_NATURAL $hasTemperature

2. Theory Layer: Context Management

The Theory Stack enables hypothetical reasoning and context switching.

Theory Commands

Example: What-If Exploration

# Base knowledge
@f1 ASSERT Ice IS_A solid
@f2 ASSERT Water IS_A liquid

# Explore hypothetical: what if ice was a liquid?
@_ THEORY_PUSH name="hypothetical_ice"
@h1 ASSERT Ice IS_A liquid

# Query in this context
@q1 ASK Ice IS_A solid  # FALSE in this layer

# Check theory stack
@stack LIST_THEORIES
# Returns: ["base", "hypothetical_ice"]

# Discard hypothetical
@_ THEORY_POP

# Back to base
@q2 ASK Ice IS_A solid  # TRUE again

3. Reasoning Layer: Inference Introspection

Understand how conclusions are reached, not just what they are.

Reasoning Commands

Example: Explanation Chain

# Establish knowledge
@f1 ASSERT Dog IS_A mammal
@f2 ASSERT mammal IS_A animal

# Prove a transitive conclusion
@proof PROVE Dog IS_A animal

# Get human-readable explanation
@explanation EXPLAIN $proof
# Returns: "Dog IS_A animal because:
#   1. Dog IS_A mammal (direct fact)
#   2. mammal IS_A animal (direct fact)
#   3. IS_A is transitive, so Dog IS_A animal"

Example: Full Inference with Forward Chaining

# Establish knowledge with inference rules
@f1 ASSERT Dog IS_A mammal
@f2 ASSERT mammal IS_A animal
@f3 ASSERT animal HAS_PROPERTY needs_food

# Define a custom inference rule
@r1 DEFINE_RULE "inheritance" | ?X IS_A ?Y ; ?Y HAS_PROPERTY ?P => ?X HAS_PROPERTY ?P

# Forward chain to derive all conclusions
@derived FORWARD_CHAIN

# Query derived facts
@result INFER Dog HAS_PROPERTY needs_food
# Returns: { truth: "TRUE_INFERRED", method: "inheritance", chain: [...] }

# Understand why
@why WHY Dog HAS_PROPERTY needs_food

3.1 Contradiction Detection: Knowledge Consistency

The system actively monitors for logical contradictions and can prevent inconsistent facts from being added.

Contradiction Types

Contradiction Commands

Example: Consistency Checking

# Establish type disjointness
@d1 ASSERT Cat DISJOINT_WITH Dog
@d2 ASSERT mammal DISJOINT_WITH reptile

# Add some facts
@f1 ASSERT Fluffy IS_A Cat
@f2 ASSERT Rex IS_A Dog

# Check consistency
@report CHECK_CONTRADICTION
# Returns: { consistent: true, contradictions: [] }

# Test hypothetical addition
@test CHECK_WOULD_CONTRADICT Fluffy IS_A Dog
# Returns: { wouldContradict: true, reason: "DISJOINT_VIOLATION",
#            details: "Fluffy cannot be both Cat and Dog" }

# Set up functional constraints
@_ REGISTER_FUNCTIONAL BORN_IN

# This would be flagged:
@f3 ASSERT Alice BORN_IN Paris
@f4 ASSERT Alice BORN_IN London  # WARNING: functional violation

# Check again
@report2 CHECK_CONTRADICTION
# Returns: { consistent: false, contradictions: [
#   { type: "FUNCTIONAL_VIOLATION", subject: "Alice", relation: "BORN_IN", values: ["Paris", "London"] }
# ]}

4. Memory Management: Self-Optimization

The system tracks usage and can selectively forget low-value knowledge.

Memory Commands

Example: Memory Maintenance

# Check what's rarely used
@lowUsage FACTS_MATCHING ? usage_count LessThan 3

# Protect critical concepts
@_ PROTECT Water
@_ PROTECT fundamental_axiom

# Boost important domain concepts
@_ BOOST CustomerData 100

# Clean up (dry run first)
@preview FORGET threshold=5 dryRun=true

# Actually forget
@result FORGET threshold=5

5. Dimension Masks: Attention Focus

Masks control which dimensions participate in reasoning – a form of selective attention.

Mask Commands

Example: Bias Control

# Create mask that ignores value judgments
@fairMask MASK_PARTITIONS ontology

# Query without axiological bias
@result ASK_MASKED $fairMask Candidate QUALIFIES_FOR Position

# Compare with full query
@fullResult ASK Candidate QUALIFIES_FOR Position

# Explain the difference
@diff EXPLAIN_DIFFERENCE $result $fullResult

6. Relation Introspection

Query and understand the relation system itself.

Relation Introspection Commands

# List all known relations
@rels LIST_RELATIONS

# Get properties of a relation
@info GET_RELATION_INFO IS_A
# Returns: { symmetric: false, transitive: true, inverse: null }

# Find relations between concepts
@links GET_RELATIONS_BETWEEN Dog mammal
# Returns: ["IS_A"]

7. Script Evaluation: Understanding Execution

The DSL engine itself can be introspected.

Evaluation Model

Scripts are evaluated in topological order based on variable dependencies:

# These can appear in any order in the file
@b BOOL_AND $a $a    # Depends on @a
@a NONEMPTY $list    # Depends on @list
@list FACTS_MATCHING dog IS_A ?  # No dependencies

# Execution order:
# 1. @list (no deps)
# 2. @a (depends on @list)
# 3. @b (depends on @a)

Variable Composition

Variables enable metacognitive composition:

# Store a concept reference
@subject BIND_CONCEPT Water
@relation BIND_RELATION BOILS_AT
@value BIND_CONCEPT Celsius100

# Compose dynamically
@fact ASSERT $subject $relation $value

# The system "knows" it asserted Water BOILS_AT Celsius100
@reflection GET_LAST_ASSERTION
# Returns: { subject: "Water", relation: "BOILS_AT", object: "Celsius100" }

8. The Four Use Cases of Sys2DSL

Understanding the system's metacognitive purpose:

9. Full Metacognitive Example

# === Domain Setup ===
@r1 DEFINE_RELATION SYMPTOM_OF inverse=HAS_SYMPTOM
@r2 DEFINE_RELATION TREATS inverse=TREATED_BY

@f1 ASSERT Fever SYMPTOM_OF Infection
@f2 ASSERT Headache SYMPTOM_OF Stress
@f3 ASSERT Aspirin TREATS Headache

# === Self-Assessment ===
@symptoms FACTS_MATCHING ? SYMPTOM_OF ?
@treatments FACTS_MATCHING ? TREATS ?
@symptomCount COUNT $symptoms
@treatmentCount COUNT $treatments

# === Hypothetical Reasoning ===
@_ THEORY_PUSH name="new_symptom_hypothesis"
@h1 ASSERT Fatigue SYMPTOM_OF Infection
@newSymptoms FACTS_MATCHING ? SYMPTOM_OF Infection
@_ THEORY_POP

# === Consistency Check ===
@valid VALIDATE

# === Explanation ===
@report TO_NATURAL "We know $symptomCount symptoms and $treatmentCount treatments"

Technical References

• DS(/theory/dsl_engine.js) – DSL interpreter
• DS(/knowledge/concept_store.js) – Knowledge persistence
• DS(/knowledge/theory_stack.js) – Theory layering
• DS(/reason/reasoner.js) – Basic reasoner
• DS(/reason/contradiction_detection) – Contradiction detection specification
• DS(/reason/inference_engine) – Complete inference engine specification
• Wiki: Memory Management
• Wiki: Theory Layers