QUICK_START.md

# 🚀 Quick Start Guide

## Get Started in 3 Steps

### 1. Install Dependencies
```bash
pip install -r requirements.txt
```

### 2. Load the Model
```python
from transformers import AutoModelForCausalLM, AutoTokenizer

model = AutoModelForCausalLM.from_pretrained("9x25dillon/LFM2-8B-A1B-Dimensional-Entanglement")
tokenizer = AutoTokenizer.from_pretrained("9x25dillon/LFM2-8B-A1B-Dimensional-Entanglement")
```

### 3. Generate with Dimensional Awareness
```python
prompt = "Explain how consciousness emerges from quantum processes"
inputs = tokenizer(prompt, return_tensors="pt")
outputs = model.generate(**inputs, max_length=512, temperature=0.7)
response = tokenizer.decode(outputs[0], skip_special_tokens=True)
print(response)
```

## 🌌 Advanced Usage

### Explore Dimensional Entanglements
```python
import sqlite3

# Connect to the dimensional database
conn = sqlite3.connect("dimensional_entanglement.db")

# Find high-strength entanglements
cursor = conn.cursor()
cursor.execute("""
    SELECT n1.metadata, n2.metadata, e.strength 
    FROM entanglements e
    JOIN dimensional_nodes n1 ON e.node_i = n1.node_id
    JOIN dimensional_nodes n2 ON e.node_j = n2.node_id
    ORDER BY e.strength DESC LIMIT 5
""")

for concept1, concept2, strength in cursor.fetchall():
    print(f"{concept1} ↔ {concept2} (strength: {strength:.3f})")
```

### Generate Training Data
```python
from dimensional_entanglement_database import DimensionalDatabase, TrainingDataGenerator

# Load database and generate new training examples
db = DimensionalDatabase("dimensional_entanglement.db")
generator = TrainingDataGenerator(db)
examples = generator.generate_training_data(num_examples=100)
```

## 📊 What You Get

- **25 dimensional nodes** across 5 domains
- **124 entanglement relationships** 
- **Cross-dimensional reasoning** capabilities
- **Holographic memory** integration
- **Emergent pattern recognition**

## 🔗 Repository Structure

```
├── README.md                              # Complete documentation
├── dimensional_entanglement_database.py   # Core framework
├── luimennua.md                          # Theoretical foundation (3,725 lines)
├── luimennua_llm_bridge.py               # Holographic memory bridge
├── dimensional_entanglement.db            # SQLite knowledge base
├── training_data_emergent.jsonl          # Generated training data
├── config_dimensional_entanglement.json  # Model configuration
├── example_usage.py                      # Usage examples
└── requirements.txt                      # Dependencies
```

## 🎯 Next Steps

1. **Explore the database**: Query entanglements and discover cross-domain connections
2. **Generate more data**: Add your own concepts and create training examples
3. **Fine-tune**: Use the training data to enhance your own models
4. **Research**: Apply to your specific domain (physics, biology, AI, etc.)

## 🌟 Key Features

- **Quantum-inspired learning**: Based on entanglement and superposition principles
- **Multi-dimensional reasoning**: Concepts connected across domains
- **Emergent intelligence**: Learns patterns that emerge from interactions
- **Holographic processing**: Each part contains information about the whole

---

*Ready to explore the dimensional entanglement framework? Start with the examples in `example_usage.py`!*