Created
September 2, 2024 16:36
-
-
Save CoolOppo/d5b135907448237cb628b5cb862f0f4c to your computer and use it in GitHub Desktop.
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
/* | |
* Human Cognitive Thinking Patterns | |
* ================================= | |
* | |
* This cheatsheet outlines various cognitive thinking patterns observed in human cognition, | |
* represented through TypeScript code analogies. The patterns covered include: | |
* | |
* 1. Association and Memory Retrieval | |
* 2. Decision Making and Problem Solving | |
* 3. Emotional Processing | |
* 4. Attention and Focus | |
* 5. Learning and Adaptation | |
* 6. Creativity and Imagination | |
* 7. Social Cognition | |
* 8. Metacognition | |
* | |
* Each pattern is explained in detail, including its purpose, pros and cons, and related patterns. | |
* Code examples are provided to illustrate the conceptual representation of these thinking processes. | |
*/ | |
// Basic types and interfaces used throughout the examples | |
type Emotion = 'happy' | 'sad' | 'angry' | 'fearful' | 'disgusted' | 'surprised'; | |
type Stimulus = any; | |
type Memory = any; | |
type Thought = any; | |
type Action = any; | |
type Belief = any; | |
type Skill = any; | |
interface Brain { | |
processStimulus(stimulus: Stimulus): void; | |
retrieveMemory(cue: any): Memory | null; | |
makeDecision(options: any[]): any; | |
learn(experience: any): void; | |
focus(target: any): void; | |
imagine(concept: any): Thought; | |
reflect(): void; | |
} | |
/* | |
* 1. Association and Memory Retrieval | |
* =================================== | |
* | |
* This pattern represents how humans associate ideas and retrieve memories based on cues. | |
* It's fundamental to many cognitive processes, including learning and problem-solving. | |
* | |
* Pros: | |
* - Enables quick recall of relevant information | |
* - Facilitates learning through connection of new and existing knowledge | |
* - Supports creative thinking by linking seemingly unrelated concepts | |
* | |
* Cons: | |
* - Can lead to biased thinking if associations are overly rigid | |
* - May result in false memories or incorrect recall | |
* - Can be influenced by emotional states, potentially distorting recall | |
* | |
* Related Patterns: | |
* - Closely linked to Learning and Adaptation | |
* - Supports Decision Making and Problem Solving | |
* - Influences Creativity and Imagination | |
*/ | |
class AssociativeMemory { | |
private memories: Map<string, Memory> = new Map(); | |
// Store a new memory with associated keywords | |
storeMemory(memory: Memory, keywords: string[]): void { | |
keywords.forEach(keyword => { | |
if (!this.memories.has(keyword)) { | |
this.memories.set(keyword, []); | |
} | |
this.memories.get(keyword)!.push(memory); | |
}); | |
} | |
// Retrieve memories based on a cue (keyword) | |
retrieveMemories(cue: string): Memory[] { | |
return this.memories.get(cue) || []; | |
} | |
// Associate two concepts by linking their keywords | |
associate(concept1: string, concept2: string): void { | |
const memories1 = this.retrieveMemories(concept1); | |
const memories2 = this.retrieveMemories(concept2); | |
// Cross-associate memories | |
memories1.forEach(memory => this.storeMemory(memory, [concept2])); | |
memories2.forEach(memory => this.storeMemory(memory, [concept1])); | |
} | |
} | |
// Example usage | |
const associativeMemory = new AssociativeMemory(); | |
// Storing memories | |
associativeMemory.storeMemory("The sky is blue", ["sky", "blue", "color"]); | |
associativeMemory.storeMemory("The ocean is blue", ["ocean", "blue", "water"]); | |
// Retrieving memories | |
console.log(associativeMemory.retrieveMemories("blue")); | |
// Output: ["The sky is blue", "The ocean is blue"] | |
// Associating concepts | |
associativeMemory.associate("sky", "ocean"); | |
/* | |
* 2. Decision Making and Problem Solving | |
* ====================================== | |
* | |
* This pattern represents how humans make decisions and solve problems by evaluating | |
* options, considering consequences, and applying heuristics or algorithms. | |
* | |
* Pros: | |
* - Enables navigation of complex situations | |
* - Supports goal-directed behavior | |
* - Can be optimized through experience and learning | |
* | |
* Cons: | |
* - Susceptible to cognitive biases | |
* - May be influenced by emotional states | |
* - Can be computationally expensive for complex problems | |
* | |
* Related Patterns: | |
* - Utilizes Association and Memory Retrieval for accessing relevant information | |
* - Influenced by Emotional Processing | |
* - Can be improved through Metacognition | |
*/ | |
class DecisionMaker { | |
private goals: string[] = []; | |
private beliefs: Map<string, number> = new Map(); // Belief strength from 0 to 1 | |
constructor(private brain: Brain) {} | |
// Add a goal to the decision-maker | |
addGoal(goal: string): void { | |
this.goals.push(goal); | |
} | |
// Update a belief and its strength | |
updateBelief(belief: string, strength: number): void { | |
this.beliefs.set(belief, Math.max(0, Math.min(1, strength))); | |
} | |
// Make a decision based on current goals, beliefs, and available options | |
makeDecision(options: Action[]): Action { | |
const scoredOptions = options.map(option => ({ | |
option, | |
score: this.evaluateOption(option) | |
})); | |
// Sort options by score in descending order | |
scoredOptions.sort((a, b) => b.score - a.score); | |
return scoredOptions[0].option; | |
} | |
private evaluateOption(option: Action): number { | |
let score = 0; | |
// Evaluate how well the option aligns with current goals | |
this.goals.forEach(goal => { | |
const alignment = this.assessAlignment(option, goal); | |
score += alignment; | |
}); | |
// Factor in beliefs | |
this.beliefs.forEach((strength, belief) => { | |
const relevance = this.assessRelevance(option, belief); | |
score += strength * relevance; | |
}); | |
// Retrieve relevant memories to inform the decision | |
const relevantMemories = this.brain.retrieveMemory(option); | |
if (relevantMemories) { | |
score += this.evaluateMemories(relevantMemories); | |
} | |
return score; | |
} | |
private assessAlignment(option: Action, goal: string): number { | |
// Implementation of assessing how well an option aligns with a goal | |
// This would involve complex logic based on the nature of the goal and option | |
return Math.random(); // Placeholder implementation | |
} | |
private assessRelevance(option: Action, belief: string): number { | |
// Implementation of assessing how relevant a belief is to an option | |
// This would involve analyzing the relationship between the belief and the option | |
return Math.random(); // Placeholder implementation | |
} | |
private evaluateMemories(memories: Memory): number { | |
// Implementation of evaluating memories to inform the decision | |
// This would involve analyzing past experiences related to the current decision | |
return Math.random(); // Placeholder implementation | |
} | |
} | |
// Example usage | |
const brain: Brain = { | |
// ... implementation of Brain interface methods | |
} as Brain; | |
const decisionMaker = new DecisionMaker(brain); | |
decisionMaker.addGoal("Stay healthy"); | |
decisionMaker.updateBelief("Exercise is good", 0.9); | |
decisionMaker.updateBelief("Junk food is bad", 0.8); | |
const options: Action[] = [ | |
"Go for a run", | |
"Watch TV", | |
"Eat a salad", | |
"Order fast food" | |
]; | |
const decision = decisionMaker.makeDecision(options); | |
console.log("Decided action:", decision); | |
/* | |
* 3. Emotional Processing | |
* ======================= | |
* | |
* This pattern represents how humans process and respond to emotions, which play a | |
* crucial role in decision-making, memory formation, and social interactions. | |
* | |
* Pros: | |
* - Provides rapid assessment of situations | |
* - Enhances memory formation and recall | |
* - Facilitates social bonding and communication | |
* | |
* Cons: | |
* - Can lead to irrational decision-making if unchecked | |
* - May cause cognitive biases | |
* - Can be difficult to regulate in some individuals | |
* | |
* Related Patterns: | |
* - Influences Decision Making and Problem Solving | |
* - Affects Association and Memory Retrieval | |
* - Plays a role in Social Cognition | |
*/ | |
class EmotionalProcessor { | |
private currentEmotion: Emotion | null = null; | |
private emotionalMemories: Map<Emotion, Memory[]> = new Map(); | |
// Process a stimulus and generate an emotional response | |
processStimulus(stimulus: Stimulus): Emotion { | |
const emotion = this.evaluateStimulus(stimulus); | |
this.currentEmotion = emotion; | |
this.storeEmotionalMemory(stimulus, emotion); | |
return emotion; | |
} | |
// Regulate the current emotional state | |
regulateEmotion(desiredIntensity: number): void { | |
if (this.currentEmotion) { | |
// Implementation of emotion regulation techniques | |
// This could involve cognitive reappraisal, mindfulness, etc. | |
console.log(`Regulating ${this.currentEmotion} to intensity ${desiredIntensity}`); | |
} | |
} | |
// Retrieve memories associated with a specific emotion | |
retrieveEmotionalMemories(emotion: Emotion): Memory[] { | |
return this.emotionalMemories.get(emotion) || []; | |
} | |
private evaluateStimulus(stimulus: Stimulus): Emotion { | |
// Complex logic to evaluate the emotional significance of a stimulus | |
// This would involve assessing various aspects of the stimulus and context | |
return ['happy', 'sad', 'angry', 'fearful', 'disgusted', 'surprised'][Math.floor(Math.random() * 6)] as Emotion; | |
} | |
private storeEmotionalMemory(stimulus: Stimulus, emotion: Emotion): void { | |
if (!this.emotionalMemories.has(emotion)) { | |
this.emotionalMemories.set(emotion, []); | |
} | |
this.emotionalMemories.get(emotion)!.push(stimulus); | |
} | |
} | |
// Example usage | |
const emotionalProcessor = new EmotionalProcessor(); | |
const stimulus = "Received a promotion at work"; | |
const emotion = emotionalProcessor.processStimulus(stimulus); | |
console.log(`Emotional response to "${stimulus}": ${emotion}`); | |
emotionalProcessor.regulateEmotion(0.5); | |
const happyMemories = emotionalProcessor.retrieveEmotionalMemories('happy'); | |
console.log("Happy memories:", happyMemories); | |
/* | |
* 4. Attention and Focus | |
* ====================== | |
* | |
* This pattern represents how humans direct and maintain attention on specific | |
* stimuli or tasks, filtering out irrelevant information. | |
* | |
* Pros: | |
* - Allows for deep concentration on important tasks | |
* - Enhances information processing and learning | |
* - Helps in achieving goals by prioritizing relevant stimuli | |
* | |
* Cons: | |
* - Limited capacity; can lead to overlooking important information | |
* - Susceptible to distractions and interruptions | |
* - Can be depleted over time, leading to mental fatigue | |
* | |
* Related Patterns: | |
* - Supports Learning and Adaptation by focusing on relevant information | |
* - Influences Decision Making and Problem Solving by directing cognitive resources | |
* - Can be improved through Metacognition | |
*/ | |
class AttentionManager { | |
private focusTarget: any | null = null; | |
private distractions: any[] = []; | |
private attentionSpan: number = 100; // Arbitrary units | |
// Focus attention on a specific target | |
focus(target: any): void { | |
this.focusTarget = target; | |
console.log(`Focusing on: ${target}`); | |
} | |
// Process incoming stimuli, filtering based on current focus | |
processStimulus(stimulus: Stimulus): void { | |
if (this.isRelevantToFocus(stimulus)) { | |
this.attendToStimulus(stimulus); | |
} else { | |
this.distractions.push(stimulus); | |
} | |
} | |
// Shift focus to a new target | |
shiftFocus(newTarget: any): void { | |
console.log(`Shifting focus from ${this.focusTarget} to ${newTarget}`); | |
this.focus(newTarget); | |
} | |
// Attempt to resist a distraction | |
resistDistraction(distraction: any): boolean { | |
const resistanceStrength = this.calculateResistanceStrength(); | |
const distractionStrength = this.evaluateDistractionStrength(distraction); | |
if (resistanceStrength > distractionStrength) { | |
console.log(`Successfully resisted distraction: ${distraction}`); | |
return true; | |
} else { | |
console.log(`Failed to resist distraction: ${distraction}`); | |
this.shiftFocus(distraction); | |
return false; | |
} | |
} | |
private isRelevantToFocus(stimulus: Stimulus): boolean { | |
// Implementation to determine if a stimulus is relevant to the current focus | |
// This would involve comparing properties of the stimulus to the focus target | |
return Math.random() > 0.5; // Placeholder implementation | |
} | |
private attendToStimulus(stimulus: Stimulus): void { | |
// Process the attended stimulus | |
console.log(`Attending to stimulus: ${stimulus}`); | |
this.attentionSpan -= 10; // Decrease attention span as we process stimuli | |
} | |
private calculateResistanceStrength(): number { | |
// Calculate the current strength of focus based on various factors | |
return this.attentionSpan * Math.random(); | |
} | |
private evaluateDistractionStrength(distraction: any): number { | |
// Evaluate how strong or compelling a distraction is | |
return Math.random() * 100; | |
} | |
} | |
// Example usage | |
const attentionManager = new AttentionManager(); | |
attentionManager.focus("Reading a book"); | |
attentionManager.processStimulus("Words on the page"); | |
attentionManager.processStimulus("Phone notification"); | |
attentionManager.resistDistraction("Loud noise outside"); | |
/* | |
* 5. Learning and Adaptation | |
* ========================== | |
* | |
* This pattern represents how humans acquire new knowledge, skills, and behaviors | |
* through experience and adapt to changing environments. | |
* | |
* Pros: | |
* - Enables continuous improvement and growth | |
* - Allows for adaptation to new situations and environments | |
* - Enhances problem-solving abilities over time | |
* | |
* Cons: | |
* - Can be slow and require significant effort | |
* - May lead to overlearning or overfitting to specific contexts | |
* - Can be influenced by biases and misconceptions | |
* | |
* Related Patterns: | |
* - Utilizes Association and Memory Retrieval for integrating new information | |
* - Influences Decision Making and Problem Solving by improving knowledge and skills | |
* - Can be enhanced through Metacognition | |
*/ | |
class LearningSystem { | |
private knowledge: Map<string, any> = new Map(); | |
private skills: Map<string, number> = new Map(); // Skill levels from 0 to 1 | |
// Learn new information or update existing knowledge | |
learnKnowledge(concept: string, information: any): void { | |
if (this.knowledge.has(concept)) { | |
this.integrateNewInformation(concept, information); | |
} else { | |
this.knowledge.set(concept, information); | |
} | |
console.log(`Learned about: ${concept}`); | |
} | |
// Practice a skill to improve proficiency | |
practiceSkill(skill: string, duration: number): void { | |
const currentLevel = this.skills.get(skill) || 0; | |
const improvement = this.calculateImprovement(currentLevel, duration); | |
this.skills.set(skill, Math.min(1, currentLevel + improvement)); | |
console.log(`Practiced ${skill}. New level: ${this.skills.get(skill)}`); | |
} | |
// Apply learned knowledge and skills to a new situation | |
applyLearning(situation: any): any { | |
const relevantKnowledge = this.retrieveRelevantKnowledge(situation); | |
const applicableSkills = this.identifyApplicableSkills(situation); | |
// Combine knowledge and skills to generate a response | |
const response = this.synthesizeResponse(relevantKnowledge, applicableSkills); | |
// Learn from the application | |
this.reflectOnApplication(situation, response); | |
return response; | |
} | |
private integrateNewInformation(concept: string, newInfo: any): void { | |
const existingInfo = this.knowledge.get(concept); | |
// Complex logic to merge existing and new information, resolving conflicts | |
this.knowledge.set(concept, { ...existingInfo, ...newInfo }); | |
} | |
private calculateImprovement(currentLevel: number, duration: number): number { | |
// Implementation of a learning curve algorithm | |
// This could factor in current level, practice duration, and other variables | |
return Math.min(1 - currentLevel, duration * 0.01 * (1 - currentLevel)); | |
} | |
private retrieveRelevantKnowledge(situation: any): any[] { | |
// Implementation to identify and retrieve knowledge relevant to the situation | |
return Array.from(this.knowledge.entries()) | |
.filter(([concept, _]) => this.isRelevantToConcept(situation, concept)) | |
.map(([_, info]) => info); | |
} | |
private identifyApplicableSkills(situation: any): [string, number][] { | |
// Implementation to identify skills applicable to the situation | |
return Array.from(this.skills.entries()) | |
.filter(([skill, _]) => this.isSkillApplicable(situation, skill)); | |
} | |
private synthesizeResponse(knowledge: any[], skills: [string, number][]): any { | |
// Complex logic to combine knowledge and skills into a response | |
// This would involve weighing different factors and making decisions | |
return { knowledge, skills }; // Placeholder implementation | |
} | |
private reflectOnApplication(situation: any, response: any): void { | |
// Implementation to learn from the application of knowledge and skills | |
// This could involve updating knowledge or adjusting skill levels | |
console.log(`Reflected on application to situation: ${JSON.stringify(situation)}`); | |
} | |
private isRelevantToConcept(situation: any, concept: string): boolean { | |
// Implementation to determine if a concept is relevant to a situation | |
return Math.random() > 0.5; // Placeholder implementation | |
} | |
private isSkillApplicable(situation: any, skill: string): boolean { | |
// Implementation to determine if a skill is applicable to a situation | |
return Math.random() > 0.5; // Placeholder implementation | |
} | |
} | |
// Example usage | |
const learningSystem = new LearningSystem(); | |
learningSystem.learnKnowledge("Python", { syntax: "...", paradigm: "Object-oriented" }); | |
learningSystem.practiceSkill("Coding", 2); | |
const codingProblem = { type: "Algorithm", difficulty: "Medium" }; | |
const solution = learningSystem.applyLearning(codingProblem); | |
console.log("Solution:", solution); | |
/* | |
* 6. Creativity and Imagination | |
* ============================= | |
* | |
* This pattern represents how humans generate novel ideas, combine concepts in unique ways, | |
* and imagine hypothetical scenarios. | |
* | |
* Pros: | |
* - Enables problem-solving through novel approaches | |
* - Supports innovation and artistic expression | |
* - Allows for mental simulation of future scenarios | |
* | |
* Cons: | |
* - Can lead to impractical or unrealistic ideas if unchecked | |
* - May be limited by existing knowledge and experiences | |
* - Can be influenced by biases and preconceptions | |
* | |
* Related Patterns: | |
* - Utilizes Association and Memory Retrieval for combining existing concepts | |
* - Supports Decision Making and Problem Solving by generating alternative solutions | |
* - Can be enhanced through Learning and Adaptation | |
*/ | |
class CreativeEngine { | |
private concepts: Set<string> = new Set(); | |
private associations: Map<string, Set<string>> = new Map(); | |
// Add a new concept to the creative engine | |
addConcept(concept: string): void { | |
this.concepts.add(concept); | |
} | |
// Create an association between two concepts | |
associate(concept1: string, concept2: string): void { | |
if (!this.associations.has(concept1)) { | |
this.associations.set(concept1, new Set()); | |
} | |
if (!this.associations.has(concept2)) { | |
this.associations.set(concept2, new Set()); | |
} | |
this.associations.get(concept1)!.add(concept2); | |
this.associations.get(concept2)!.add(concept1); | |
} | |
// Generate a new idea by combining existing concepts | |
generateIdea(): string { | |
const conceptArray = Array.from(this.concepts); | |
const concept1 = conceptArray[Math.floor(Math.random() * conceptArray.length)]; | |
const concept2 = conceptArray[Math.floor(Math.random() * conceptArray.length)]; | |
return this.combineConceptsCreatively(concept1, concept2); | |
} | |
// Imagine a hypothetical scenario | |
imagineScenario(baseContext: string): string { | |
const relatedConcepts = this.getRelatedConcepts(baseContext); | |
return this.constructScenario(baseContext, relatedConcepts); | |
} | |
private combineConceptsCreatively(concept1: string, concept2: string): string { | |
// Implementation of creative combination of concepts | |
// This could involve analyzing properties, functions, or metaphorical relationships | |
return `A ${concept1} that ${concept2}s`; // Simplified example | |
} | |
private getRelatedConcepts(concept: string): string[] { | |
return Array.from(this.associations.get(concept) || []); | |
} | |
private constructScenario(baseContext: string, relatedConcepts: string[]): string { | |
// Implementation to construct a hypothetical scenario | |
// This would involve weaving together the base context and related concepts | |
const randomConcept = relatedConcepts[Math.floor(Math.random() * relatedConcepts.length)]; | |
return `Imagine a world where ${baseContext} is influenced by ${randomConcept}...`; | |
} | |
} | |
// Example usage | |
const creativeEngine = new CreativeEngine(); | |
creativeEngine.addConcept("tree"); | |
creativeEngine.addConcept("computer"); | |
creativeEngine.addConcept("music"); | |
creativeEngine.associate("tree", "computer"); | |
creativeEngine.associate("computer", "music"); | |
const newIdea = creativeEngine.generateIdea(); | |
console.log("New idea:", newIdea); | |
const scenario = creativeEngine.imagineScenario("technology"); | |
console.log("Imagined scenario:", scenario); | |
/* | |
* 7. Social Cognition | |
* =================== | |
* | |
* This pattern represents how humans understand and interact with others, including | |
* theory of mind, empathy, and social norm processing. | |
* | |
* Pros: | |
* - Enables effective communication and collaboration | |
* - Supports prediction of others' behaviors and intentions | |
* - Facilitates social bonding and group cohesion | |
* | |
* Cons: | |
* - Can lead to biases and stereotyping | |
* - May be inaccurate due to misinterpretation of social cues | |
* - Can be cognitively demanding in complex social situations | |
* | |
* Related Patterns: | |
* - Influenced by Emotional Processing | |
* - Utilizes Theory of Mind (a specific aspect of social cognition) | |
* - Supports Decision Making in social contexts | |
*/ | |
class SocialCognitionModule { | |
private socialNorms: Map<string, (action: string) => boolean> = new Map(); | |
private relationships: Map<string, number> = new Map(); // Relationship strength from -1 to 1 | |
// Interpret social cues from another person | |
interpretSocialCues(person: string, cues: string[]): Map<string, string> { | |
const interpretations = new Map<string, string>(); | |
cues.forEach(cue => { | |
const interpretation = this.analyzeCue(cue, person); | |
interpretations.set(cue, interpretation); | |
}); | |
return interpretations; | |
} | |
// Predict another person's behavior or intention | |
predictBehavior(person: string, context: string): string { | |
const relationshipStrength = this.relationships.get(person) || 0; | |
const possibleBehaviors = this.generatePossibleBehaviors(context); | |
return this.selectMostLikelyBehavior(possibleBehaviors, relationshipStrength); | |
} | |
// Update relationship status with another person | |
updateRelationship(person: string, event: string): void { | |
const currentStrength = this.relationships.get(person) || 0; | |
const impact = this.evaluateEventImpact(event); | |
this.relationships.set(person, Math.max(-1, Math.min(1, currentStrength + impact))); | |
} | |
// Add or update a social norm | |
defineSocialNorm(context: string, normChecker: (action: string) => boolean): void { | |
this.socialNorms.set(context, normChecker); | |
} | |
// Check if an action adheres to social norms | |
checkSocialNorm(context: string, action: string): boolean { | |
const normChecker = this.socialNorms.get(context); | |
return normChecker ? normChecker(action) : true; // Assume adherence if norm not defined | |
} | |
private analyzeCue(cue: string, person: string): string { | |
// Implementation of cue analysis based on type of cue and relationship with person | |
return `${person} might be feeling ${['happy', 'sad', 'angry'][Math.floor(Math.random() * 3)]}`; | |
} | |
private generatePossibleBehaviors(context: string): string[] { | |
// Implementation to generate possible behaviors based on the context | |
return ["help", "ignore", "confront", "collaborate"]; | |
} | |
private selectMostLikelyBehavior(behaviors: string[], relationshipStrength: number): string { | |
// Implementation to select behavior based on relationship strength and other factors | |
return behaviors[Math.floor(Math.random() * behaviors.length)]; | |
} | |
private evaluateEventImpact(event: string): number { | |
// Implementation to evaluate the impact of an event on a relationship | |
return Math.random() * 0.2 - 0.1; // Random impact between -0.1 and 0.1 | |
} | |
} | |
// Example usage | |
const socialCognition = new SocialCognitionModule(); | |
socialCognition.defineSocialNorm("greeting", (action) => action.includes("hello") || action.includes("hi")); | |
const cueInterpretations = socialCognition.interpretSocialCues("Alice", ["smile", "crossed arms"]); | |
console.log("Cue interpretations:", cueInterpretations); | |
const predictedBehavior = socialCognition.predictBehavior("Bob", "group project"); | |
console.log("Predicted behavior:", predictedBehavior); | |
socialCognition.updateRelationship("Charlie", "helped with moving"); | |
const isNormAdherent = socialCognition.checkSocialNorm("greeting", "Hello, how are you?"); | |
console.log("Adheres to greeting norm:", isNormAdherent); | |
/* | |
* 8. Metacognition | |
* ================ | |
* | |
* This pattern represents how humans think about their own thinking processes, | |
* including self-reflection, cognitive monitoring, and strategy selection. | |
* | |
* Pros: | |
* - Enhances learning and problem-solving through self-awareness | |
* - Supports better decision-making by evaluating thought processes | |
* - Facilitates personal growth and cognitive development | |
* | |
* Cons: | |
* - Can lead to overthinking or analysis paralysis | |
* - May be inaccurate due to biases in self-perception | |
* - Requires cognitive resources that could be used for primary tasks | |
* | |
* Related Patterns: | |
* - Influences all other cognitive patterns through monitoring and regulation | |
* - Particularly important for Learning and Adaptation | |
* - Supports Decision Making and Problem Solving by evaluating strategies | |
*/ | |
class MetacognitionModule { | |
private cognitiveStrategies: Map<string, () => void> = new Map(); | |
private performanceHistory: Map<string, number[]> = new Map(); | |
// Monitor current cognitive performance | |
monitorPerformance(task: string, performanceMetric: number): void { | |
if (!this.performanceHistory.has(task)) { | |
this.performanceHistory.set(task, []); | |
} | |
this.performanceHistory.get(task)!.push(performanceMetric); | |
this.evaluatePerformance(task); | |
} | |
// Reflect on thought processes | |
reflect(): string[] { | |
const insights = []; | |
for (const [task, metrics] of this.performanceHistory.entries()) { | |
const averagePerformance = metrics.reduce((a, b) => a + b, 0) / metrics.length; | |
insights.push(`Average performance on ${task}: ${averagePerformance.toFixed(2)}`); | |
} | |
return insights; | |
} | |
// Add or update a cognitive strategy | |
defineStrategy(name: string, strategy: () => void): void { | |
this.cognitiveStrategies.set(name, strategy); | |
} | |
// Select and apply an appropriate cognitive strategy | |
applyStrategy(task: string): void { | |
const strategy = this.selectBestStrategy(task); | |
if (strategy) { | |
console.log(`Applying strategy ${strategy} for task: ${task}`); | |
this.cognitiveStrategies.get(strategy)!(); | |
} else { | |
console.log(`No suitable strategy found for task: ${task}`); | |
} | |
} | |
private evaluatePerformance(task: string): void { | |
const metrics = this.performanceHistory.get(task)!; | |
if (metrics.length > 1) { | |
const recentPerformance = metrics[metrics.length - 1]; | |
const previousPerformance = metrics[metrics.length - 2]; | |
if (recentPerformance < previousPerformance) { | |
console.log(`Performance on ${task} has decreased. Consider changing strategy.`); | |
} | |
} | |
} | |
private selectBestStrategy(task: string): string | null { | |
// Implementation to select the best strategy based on task and past performance | |
// This could involve analyzing the performance history and characteristics of the task | |
const strategies = Array.from(this.cognitiveStrategies.keys()); | |
return strategies.length > 0 ? strategies[Math.floor(Math.random() * strategies.length)] : null; | |
} | |
} | |
// Example usage | |
const metacognition = new MetacognitionModule(); | |
metacognition.defineStrategy("visualization", () => { | |
console.log("Applying visualization strategy"); | |
}); | |
metacognition.defineStrategy("verbalization", () => { | |
console.log("Applying verbalization strategy"); | |
}); | |
metacognition.monitorPerformance("problem-solving", 0.7); | |
metacognition.monitorPerformance("problem-solving", 0.8); | |
metacognition.applyStrategy("problem-solving"); | |
const reflections = metacognition.reflect(); | |
console.log("Reflections:", reflections); |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment