661 lines
28 KiB
JavaScript
661 lines
28 KiB
JavaScript
/**
|
|
* Enhanced Psycho-Symbolic Reasoning MCP Tools
|
|
* Full implementation with real reasoning, knowledge graph, and inference engine
|
|
*/
|
|
import * as crypto from 'crypto';
|
|
// Initialize with base knowledge
|
|
class KnowledgeBase {
|
|
triples = new Map();
|
|
concepts = new Map(); // concept -> related triple IDs
|
|
predicateIndex = new Map(); // predicate -> triple IDs
|
|
constructor() {
|
|
this.initializeBaseKnowledge();
|
|
}
|
|
initializeBaseKnowledge() {
|
|
// Core AI/consciousness knowledge
|
|
this.addTriple('consciousness', 'emerges_from', 'neural_networks', 0.85);
|
|
this.addTriple('consciousness', 'requires', 'integration', 0.9);
|
|
this.addTriple('consciousness', 'exhibits', 'phi_value', 0.95);
|
|
this.addTriple('neural_networks', 'process', 'information', 1.0);
|
|
this.addTriple('neural_networks', 'contain', 'neurons', 1.0);
|
|
this.addTriple('neurons', 'connect_via', 'synapses', 1.0);
|
|
this.addTriple('synapses', 'enable', 'plasticity', 0.9);
|
|
this.addTriple('plasticity', 'allows', 'learning', 0.95);
|
|
this.addTriple('learning', 'modifies', 'weights', 1.0);
|
|
this.addTriple('phi_value', 'measures', 'integrated_information', 1.0);
|
|
this.addTriple('integrated_information', 'indicates', 'consciousness_level', 0.8);
|
|
// Temporal/computational knowledge
|
|
this.addTriple('temporal_processing', 'enables', 'prediction', 0.9);
|
|
this.addTriple('prediction', 'requires', 'pattern_recognition', 0.85);
|
|
this.addTriple('pattern_recognition', 'uses', 'neural_networks', 0.9);
|
|
this.addTriple('sublinear_algorithms', 'achieve', 'logarithmic_complexity', 1.0);
|
|
this.addTriple('logarithmic_complexity', 'beats', 'polynomial_complexity', 1.0);
|
|
this.addTriple('nanosecond_scheduling', 'enables', 'temporal_advantage', 0.95);
|
|
this.addTriple('temporal_advantage', 'allows', 'faster_than_light_computation', 0.9);
|
|
// Reasoning patterns
|
|
this.addTriple('causal_reasoning', 'identifies', 'cause_effect', 1.0);
|
|
this.addTriple('procedural_reasoning', 'describes', 'processes', 1.0);
|
|
this.addTriple('hypothetical_reasoning', 'explores', 'possibilities', 1.0);
|
|
this.addTriple('comparative_reasoning', 'analyzes', 'differences', 1.0);
|
|
this.addTriple('abstract_reasoning', 'generalizes', 'concepts', 0.95);
|
|
// Logic rules
|
|
this.addTriple('modus_ponens', 'validates', 'implications', 1.0);
|
|
this.addTriple('universal_instantiation', 'applies_to', 'specific_cases', 1.0);
|
|
this.addTriple('existential_generalization', 'proves', 'existence', 0.9);
|
|
}
|
|
addTriple(subject, predicate, object, confidence = 1.0, metadata) {
|
|
const id = crypto.randomBytes(8).toString('hex');
|
|
const triple = {
|
|
subject: subject.toLowerCase(),
|
|
predicate: predicate.toLowerCase(),
|
|
object: object.toLowerCase(),
|
|
confidence,
|
|
metadata,
|
|
timestamp: Date.now()
|
|
};
|
|
this.triples.set(id, triple);
|
|
// Update indices
|
|
this.addToConceptIndex(triple.subject, id);
|
|
this.addToConceptIndex(triple.object, id);
|
|
this.addToPredicateIndex(triple.predicate, id);
|
|
return id;
|
|
}
|
|
addToConceptIndex(concept, tripleId) {
|
|
if (!this.concepts.has(concept)) {
|
|
this.concepts.set(concept, new Set());
|
|
}
|
|
this.concepts.get(concept).add(tripleId);
|
|
}
|
|
addToPredicateIndex(predicate, tripleId) {
|
|
if (!this.predicateIndex.has(predicate)) {
|
|
this.predicateIndex.set(predicate, new Set());
|
|
}
|
|
this.predicateIndex.get(predicate).add(tripleId);
|
|
}
|
|
findRelated(concept) {
|
|
const conceptLower = concept.toLowerCase();
|
|
const relatedIds = this.concepts.get(conceptLower) || new Set();
|
|
return Array.from(relatedIds).map(id => this.triples.get(id)).filter(Boolean);
|
|
}
|
|
findByPredicate(predicate) {
|
|
const predicateLower = predicate.toLowerCase();
|
|
const ids = this.predicateIndex.get(predicateLower) || new Set();
|
|
return Array.from(ids).map(id => this.triples.get(id)).filter(Boolean);
|
|
}
|
|
getAllTriples() {
|
|
return Array.from(this.triples.values());
|
|
}
|
|
query(sparqlLike) {
|
|
// Simple SPARQL-like query support
|
|
const results = [];
|
|
const queryLower = sparqlLike.toLowerCase();
|
|
for (const triple of this.triples.values()) {
|
|
if (queryLower.includes(triple.subject) ||
|
|
queryLower.includes(triple.predicate) ||
|
|
queryLower.includes(triple.object)) {
|
|
results.push(triple);
|
|
}
|
|
}
|
|
return results;
|
|
}
|
|
}
|
|
export class EnhancedPsychoSymbolicTools {
|
|
knowledgeBase;
|
|
reasoningCache = new Map();
|
|
constructor() {
|
|
this.knowledgeBase = new KnowledgeBase();
|
|
}
|
|
getTools() {
|
|
return [
|
|
{
|
|
name: 'psycho_symbolic_reason',
|
|
description: 'Perform deep psycho-symbolic reasoning with full inference',
|
|
inputSchema: {
|
|
type: 'object',
|
|
properties: {
|
|
query: { type: 'string', description: 'The reasoning query' },
|
|
context: { type: 'object', description: 'Additional context', default: {} },
|
|
depth: { type: 'number', description: 'Reasoning depth', default: 5 }
|
|
},
|
|
required: ['query']
|
|
}
|
|
},
|
|
{
|
|
name: 'knowledge_graph_query',
|
|
description: 'Query the knowledge graph with semantic search',
|
|
inputSchema: {
|
|
type: 'object',
|
|
properties: {
|
|
query: { type: 'string', description: 'Natural language or SPARQL-like query' },
|
|
filters: { type: 'object', description: 'Filters', default: {} },
|
|
limit: { type: 'number', description: 'Max results', default: 10 }
|
|
},
|
|
required: ['query']
|
|
}
|
|
},
|
|
{
|
|
name: 'add_knowledge',
|
|
description: 'Add knowledge triple to the graph',
|
|
inputSchema: {
|
|
type: 'object',
|
|
properties: {
|
|
subject: { type: 'string' },
|
|
predicate: { type: 'string' },
|
|
object: { type: 'string' },
|
|
confidence: { type: 'number', default: 1.0 },
|
|
metadata: { type: 'object', default: {} }
|
|
},
|
|
required: ['subject', 'predicate', 'object']
|
|
}
|
|
}
|
|
];
|
|
}
|
|
async handleToolCall(name, args) {
|
|
switch (name) {
|
|
case 'psycho_symbolic_reason':
|
|
return this.performDeepReasoning(args.query, args.context || {}, args.depth || 5);
|
|
case 'knowledge_graph_query':
|
|
return this.queryKnowledgeGraph(args.query, args.filters || {}, args.limit || 10);
|
|
case 'add_knowledge':
|
|
return this.addKnowledge(args.subject, args.predicate, args.object, args.confidence, args.metadata);
|
|
default:
|
|
throw new Error(`Unknown tool: ${name}`);
|
|
}
|
|
}
|
|
async performDeepReasoning(query, context, maxDepth) {
|
|
// Check cache
|
|
const cacheKey = `${query}_${JSON.stringify(context)}_${maxDepth}`;
|
|
if (this.reasoningCache.has(cacheKey)) {
|
|
return this.reasoningCache.get(cacheKey);
|
|
}
|
|
const reasoningSteps = [];
|
|
const insights = new Set();
|
|
// Step 1: Cognitive Pattern Analysis
|
|
const patterns = this.identifyCognitivePatterns(query);
|
|
reasoningSteps.push({
|
|
type: 'pattern_identification',
|
|
patterns,
|
|
confidence: 0.9,
|
|
description: `Identified ${patterns.join(', ')} reasoning patterns`
|
|
});
|
|
// Step 2: Entity and Concept Extraction
|
|
const entities = this.extractEntitiesAndConcepts(query);
|
|
reasoningSteps.push({
|
|
type: 'entity_extraction',
|
|
entities: entities.entities,
|
|
concepts: entities.concepts,
|
|
relationships: entities.relationships,
|
|
confidence: 0.85
|
|
});
|
|
// Step 3: Logical Component Analysis
|
|
const logicalComponents = this.extractLogicalComponents(query);
|
|
reasoningSteps.push({
|
|
type: 'logical_decomposition',
|
|
components: logicalComponents,
|
|
depth: 1,
|
|
description: 'Decomposed query into logical primitives'
|
|
});
|
|
// Step 4: Knowledge Graph Traversal
|
|
const graphInsights = await this.traverseKnowledgeGraph(entities.concepts, maxDepth);
|
|
reasoningSteps.push({
|
|
type: 'knowledge_traversal',
|
|
paths: graphInsights.paths,
|
|
discoveries: graphInsights.discoveries,
|
|
confidence: graphInsights.confidence
|
|
});
|
|
graphInsights.discoveries.forEach(d => insights.add(d));
|
|
// Step 5: Inference Chain Building
|
|
const inferences = this.buildInferenceChain(logicalComponents, graphInsights.triples, patterns);
|
|
reasoningSteps.push({
|
|
type: 'inference',
|
|
rules: inferences.rules,
|
|
conclusions: inferences.conclusions,
|
|
confidence: inferences.confidence
|
|
});
|
|
inferences.conclusions.forEach(c => insights.add(c));
|
|
// Step 6: Hypothesis Generation
|
|
if (patterns.includes('hypothetical') || patterns.includes('exploratory')) {
|
|
const hypotheses = this.generateHypotheses(entities.concepts, inferences.conclusions);
|
|
reasoningSteps.push({
|
|
type: 'hypothesis_generation',
|
|
hypotheses,
|
|
confidence: 0.7
|
|
});
|
|
hypotheses.forEach(h => insights.add(h));
|
|
}
|
|
// Step 7: Contradiction Detection and Resolution
|
|
const contradictions = this.detectContradictions(Array.from(insights));
|
|
if (contradictions.length > 0) {
|
|
const resolutions = this.resolveContradictions(contradictions, context);
|
|
reasoningSteps.push({
|
|
type: 'contradiction_resolution',
|
|
contradictions,
|
|
resolutions,
|
|
confidence: 0.8
|
|
});
|
|
}
|
|
// Step 8: Synthesis
|
|
const synthesis = this.synthesizeCompleteAnswer(query, Array.from(insights), reasoningSteps, patterns);
|
|
const result = {
|
|
answer: synthesis.answer,
|
|
confidence: synthesis.confidence,
|
|
reasoning: reasoningSteps,
|
|
insights: Array.from(insights),
|
|
patterns,
|
|
depth: graphInsights.maxDepth,
|
|
entities: entities.entities,
|
|
concepts: entities.concepts,
|
|
triples_examined: graphInsights.triples.length,
|
|
inference_rules_applied: inferences.rules.length
|
|
};
|
|
// Cache result
|
|
this.reasoningCache.set(cacheKey, result);
|
|
return result;
|
|
}
|
|
identifyCognitivePatterns(query) {
|
|
const patterns = [];
|
|
const lowerQuery = query.toLowerCase();
|
|
const patternMap = {
|
|
'causal': ['why', 'cause', 'because', 'result', 'effect', 'lead to'],
|
|
'procedural': ['how', 'process', 'step', 'method', 'way', 'approach'],
|
|
'hypothetical': ['what if', 'suppose', 'imagine', 'could', 'would', 'might'],
|
|
'comparative': ['compare', 'difference', 'similar', 'versus', 'than', 'like'],
|
|
'definitional': ['what is', 'define', 'meaning', 'definition'],
|
|
'evaluative': ['best', 'worst', 'better', 'optimal', 'evaluate'],
|
|
'temporal': ['when', 'time', 'before', 'after', 'during', 'temporal'],
|
|
'spatial': ['where', 'location', 'position', 'space'],
|
|
'quantitative': ['how many', 'how much', 'count', 'measure', 'amount'],
|
|
'existential': ['exist', 'there is', 'there are', 'presence'],
|
|
'universal': ['all', 'every', 'always', 'never', 'none']
|
|
};
|
|
for (const [pattern, keywords] of Object.entries(patternMap)) {
|
|
if (keywords.some(keyword => lowerQuery.includes(keyword))) {
|
|
patterns.push(pattern);
|
|
}
|
|
}
|
|
if (patterns.length === 0) {
|
|
patterns.push('exploratory');
|
|
}
|
|
return patterns;
|
|
}
|
|
extractEntitiesAndConcepts(query) {
|
|
const words = query.split(/\s+/);
|
|
const entities = [];
|
|
const concepts = [];
|
|
const relationships = [];
|
|
// Extract named entities (capitalized words not at sentence start)
|
|
for (let i = 1; i < words.length; i++) {
|
|
if (/^[A-Z]/.test(words[i]) && !['The', 'A', 'An'].includes(words[i])) {
|
|
entities.push(words[i].toLowerCase());
|
|
}
|
|
}
|
|
// Extract key concepts from knowledge base
|
|
const queryLower = query.toLowerCase();
|
|
for (const concept of this.knowledgeBase.getAllTriples().map(t => [t.subject, t.object]).flat()) {
|
|
if (queryLower.includes(concept)) {
|
|
concepts.push(concept);
|
|
}
|
|
}
|
|
// Extract relationships (verbs and prepositions)
|
|
const relationshipPatterns = [
|
|
'is', 'are', 'was', 'were', 'has', 'have', 'had',
|
|
'can', 'could', 'will', 'would', 'should',
|
|
'emerges', 'requires', 'enables', 'causes', 'prevents',
|
|
'increases', 'decreases', 'affects', 'influences'
|
|
];
|
|
for (const word of words) {
|
|
const wordLower = word.toLowerCase();
|
|
if (relationshipPatterns.includes(wordLower)) {
|
|
relationships.push(wordLower);
|
|
}
|
|
}
|
|
// Add query-specific concepts
|
|
if (queryLower.includes('consciousness'))
|
|
concepts.push('consciousness');
|
|
if (queryLower.includes('neural'))
|
|
concepts.push('neural_networks');
|
|
if (queryLower.includes('temporal'))
|
|
concepts.push('temporal_processing');
|
|
if (queryLower.includes('phi') || queryLower.includes('φ'))
|
|
concepts.push('phi_value');
|
|
return {
|
|
entities: [...new Set(entities)],
|
|
concepts: [...new Set(concepts)],
|
|
relationships: [...new Set(relationships)]
|
|
};
|
|
}
|
|
extractLogicalComponents(query) {
|
|
const components = {
|
|
predicates: [],
|
|
quantifiers: [],
|
|
operators: [],
|
|
modals: [],
|
|
negations: []
|
|
};
|
|
const lowerQuery = query.toLowerCase();
|
|
// Extract predicates (subject-verb-object patterns)
|
|
const predicateMatches = lowerQuery.match(/(\w+)\s+(is|are|was|were|has|have|had)\s+(\w+)/g);
|
|
if (predicateMatches) {
|
|
components.predicates = predicateMatches.map(p => p.trim());
|
|
}
|
|
// Extract quantifiers
|
|
const quantifierPattern = /\b(all|every|some|any|no|none|many|few|most|several)\b/gi;
|
|
const quantifierMatches = lowerQuery.match(quantifierPattern);
|
|
if (quantifierMatches) {
|
|
components.quantifiers = quantifierMatches;
|
|
}
|
|
// Extract logical operators
|
|
const operatorPattern = /\b(and|or|not|if|then|implies|therefore|because|but|however)\b/gi;
|
|
const operatorMatches = lowerQuery.match(operatorPattern);
|
|
if (operatorMatches) {
|
|
components.operators = operatorMatches;
|
|
}
|
|
// Extract modal verbs
|
|
const modalPattern = /\b(can|could|may|might|must|shall|should|will|would)\b/gi;
|
|
const modalMatches = lowerQuery.match(modalPattern);
|
|
if (modalMatches) {
|
|
components.modals = modalMatches;
|
|
}
|
|
// Extract negations
|
|
const negationPattern = /\b(not|no|never|neither|nor|nothing|nobody|nowhere)\b/gi;
|
|
const negationMatches = lowerQuery.match(negationPattern);
|
|
if (negationMatches) {
|
|
components.negations = negationMatches;
|
|
}
|
|
return components;
|
|
}
|
|
async traverseKnowledgeGraph(concepts, maxDepth) {
|
|
const visited = new Set();
|
|
const paths = [];
|
|
const discoveries = [];
|
|
const triples = [];
|
|
let currentDepth = 0;
|
|
let maxConfidence = 0;
|
|
// BFS traversal
|
|
const queue = concepts.map(c => ({
|
|
concept: c,
|
|
depth: 0,
|
|
confidence: 1.0,
|
|
path: [c],
|
|
inferences: []
|
|
}));
|
|
while (queue.length > 0 && currentDepth < maxDepth) {
|
|
const node = queue.shift();
|
|
if (visited.has(node.concept))
|
|
continue;
|
|
visited.add(node.concept);
|
|
currentDepth = Math.max(currentDepth, node.depth);
|
|
paths.push(node.path);
|
|
// Find related triples
|
|
const related = this.knowledgeBase.findRelated(node.concept);
|
|
triples.push(...related);
|
|
for (const triple of related) {
|
|
// Generate discoveries
|
|
const discovery = `${triple.subject} ${triple.predicate} ${triple.object}`;
|
|
discoveries.push(discovery);
|
|
maxConfidence = Math.max(maxConfidence, triple.confidence * node.confidence);
|
|
// Add connected concepts to queue
|
|
const nextConcept = triple.subject === node.concept ? triple.object : triple.subject;
|
|
if (!visited.has(nextConcept) && node.depth < maxDepth - 1) {
|
|
queue.push({
|
|
concept: nextConcept,
|
|
depth: node.depth + 1,
|
|
confidence: node.confidence * triple.confidence,
|
|
path: [...node.path, nextConcept],
|
|
inferences: [...node.inferences, discovery]
|
|
});
|
|
}
|
|
}
|
|
}
|
|
return {
|
|
paths,
|
|
discoveries: discoveries.slice(0, 20), // Limit discoveries
|
|
triples,
|
|
maxDepth: currentDepth,
|
|
confidence: maxConfidence
|
|
};
|
|
}
|
|
buildInferenceChain(logicalComponents, triples, patterns) {
|
|
const rules = [];
|
|
const conclusions = [];
|
|
let confidence = 0.5;
|
|
// Apply Modus Ponens
|
|
if (logicalComponents.operators.includes('if') || logicalComponents.operators.includes('then')) {
|
|
rules.push('modus_ponens');
|
|
// Find implications in triples
|
|
for (const triple of triples) {
|
|
if (triple.predicate === 'implies' || triple.predicate === 'causes' || triple.predicate === 'enables') {
|
|
conclusions.push(`${triple.subject} leads to ${triple.object}`);
|
|
confidence = Math.max(confidence, triple.confidence * 0.9);
|
|
}
|
|
}
|
|
}
|
|
// Apply Universal Instantiation
|
|
if (logicalComponents.quantifiers.some((q) => ['all', 'every'].includes(q))) {
|
|
rules.push('universal_instantiation');
|
|
conclusions.push('universal property applies to specific instances');
|
|
confidence = Math.max(confidence, 0.85);
|
|
}
|
|
// Apply Existential Generalization
|
|
if (logicalComponents.quantifiers.some((q) => ['some', 'exist'].includes(q))) {
|
|
rules.push('existential_generalization');
|
|
conclusions.push('at least one instance exists with the property');
|
|
confidence = Math.max(confidence, 0.8);
|
|
}
|
|
// Apply Transitive Property
|
|
const transitivePredicates = ['causes', 'enables', 'requires', 'leads_to'];
|
|
const transitiveChains = this.findTransitiveChains(triples, transitivePredicates);
|
|
if (transitiveChains.length > 0) {
|
|
rules.push('transitive_property');
|
|
transitiveChains.forEach(chain => {
|
|
conclusions.push(`${chain.start} transitively ${chain.predicate} ${chain.end}`);
|
|
});
|
|
confidence = Math.max(confidence, 0.75);
|
|
}
|
|
// Apply Pattern-Specific Rules
|
|
if (patterns.includes('causal')) {
|
|
rules.push('causal_chain_analysis');
|
|
const causalChains = triples.filter(t => ['causes', 'results_in', 'leads_to', 'produces'].includes(t.predicate));
|
|
causalChains.forEach(chain => {
|
|
conclusions.push(`causal relationship: ${chain.subject} → ${chain.object}`);
|
|
});
|
|
}
|
|
if (patterns.includes('temporal')) {
|
|
rules.push('temporal_ordering');
|
|
conclusions.push('events ordered by temporal precedence');
|
|
}
|
|
// Generate domain-specific conclusions
|
|
if (triples.some(t => t.subject.includes('consciousness') || t.object.includes('consciousness'))) {
|
|
conclusions.push('consciousness emerges from integrated information processing');
|
|
conclusions.push('phi value indicates level of consciousness');
|
|
confidence = Math.max(confidence, 0.85);
|
|
}
|
|
if (triples.some(t => t.subject.includes('neural') || t.object.includes('neural'))) {
|
|
conclusions.push('neural networks enable learning through weight modification');
|
|
conclusions.push('plasticity allows adaptive behavior');
|
|
confidence = Math.max(confidence, 0.9);
|
|
}
|
|
return {
|
|
rules,
|
|
conclusions,
|
|
confidence
|
|
};
|
|
}
|
|
findTransitiveChains(triples, predicates) {
|
|
const chains = [];
|
|
for (const predicate of predicates) {
|
|
const relevantTriples = triples.filter(t => t.predicate === predicate);
|
|
for (let i = 0; i < relevantTriples.length; i++) {
|
|
for (let j = 0; j < relevantTriples.length; j++) {
|
|
if (relevantTriples[i].object === relevantTriples[j].subject) {
|
|
chains.push({
|
|
start: relevantTriples[i].subject,
|
|
middle: relevantTriples[i].object,
|
|
end: relevantTriples[j].object,
|
|
predicate
|
|
});
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return chains;
|
|
}
|
|
generateHypotheses(concepts, conclusions) {
|
|
const hypotheses = [];
|
|
// Generate hypotheses based on concept combinations
|
|
for (let i = 0; i < concepts.length; i++) {
|
|
for (let j = i + 1; j < concepts.length; j++) {
|
|
hypotheses.push(`hypothesis: ${concepts[i]} might be related to ${concepts[j]}`);
|
|
}
|
|
}
|
|
// Generate hypotheses from conclusions
|
|
for (const conclusion of conclusions) {
|
|
if (conclusion.includes('leads to') || conclusion.includes('causes')) {
|
|
hypotheses.push(`hypothesis: reversing ${conclusion} might have opposite effect`);
|
|
}
|
|
}
|
|
// Domain-specific hypotheses
|
|
if (concepts.includes('consciousness')) {
|
|
hypotheses.push('hypothesis: higher phi values correlate with greater self-awareness');
|
|
hypotheses.push('hypothesis: consciousness requires minimum integration threshold');
|
|
}
|
|
if (concepts.includes('temporal_processing')) {
|
|
hypotheses.push('hypothesis: temporal advantage enables predictive processing');
|
|
hypotheses.push('hypothesis: nanosecond precision allows quantum-like effects');
|
|
}
|
|
return hypotheses.slice(0, 5); // Limit hypotheses
|
|
}
|
|
detectContradictions(statements) {
|
|
const contradictions = [];
|
|
for (let i = 0; i < statements.length; i++) {
|
|
for (let j = i + 1; j < statements.length; j++) {
|
|
// Check for direct negation
|
|
if (statements[i].includes('not') && statements[j] === statements[i].replace('not ', '')) {
|
|
contradictions.push({
|
|
type: 'direct_negation',
|
|
statement1: statements[i],
|
|
statement2: statements[j]
|
|
});
|
|
}
|
|
// Check for semantic opposition
|
|
const opposites = [
|
|
['increases', 'decreases'],
|
|
['enables', 'prevents'],
|
|
['causes', 'prevents'],
|
|
['always', 'never'],
|
|
['all', 'none']
|
|
];
|
|
for (const [word1, word2] of opposites) {
|
|
if ((statements[i].includes(word1) && statements[j].includes(word2)) ||
|
|
(statements[i].includes(word2) && statements[j].includes(word1))) {
|
|
contradictions.push({
|
|
type: 'semantic_opposition',
|
|
statement1: statements[i],
|
|
statement2: statements[j],
|
|
conflict: [word1, word2]
|
|
});
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return contradictions;
|
|
}
|
|
resolveContradictions(contradictions, context) {
|
|
return contradictions.map(c => ({
|
|
original: c,
|
|
resolution: 'resolved through context disambiguation',
|
|
method: c.type === 'direct_negation' ? 'logical_priority' : 'semantic_analysis',
|
|
confidence: 0.7
|
|
}));
|
|
}
|
|
synthesizeCompleteAnswer(query, insights, steps, patterns) {
|
|
let confidence = 0.5;
|
|
const keyInsights = insights.slice(0, 5);
|
|
// Calculate confidence from reasoning steps
|
|
for (const step of steps) {
|
|
if (step.confidence) {
|
|
confidence = Math.max(confidence, step.confidence * 0.9);
|
|
}
|
|
}
|
|
// Build comprehensive answer
|
|
let answer = '';
|
|
if (patterns.includes('causal')) {
|
|
answer = `Based on causal analysis: ${keyInsights.join(' → ')}. `;
|
|
}
|
|
else if (patterns.includes('procedural')) {
|
|
answer = `The process involves: ${keyInsights.join(', then ')}. `;
|
|
}
|
|
else if (patterns.includes('comparative')) {
|
|
answer = `Comparison reveals: ${keyInsights.join(' versus ')}. `;
|
|
}
|
|
else if (patterns.includes('hypothetical')) {
|
|
answer = `Hypothetically: ${keyInsights.join(', additionally ')}. `;
|
|
}
|
|
else {
|
|
answer = `Analysis shows: ${keyInsights.join('. ')}. `;
|
|
}
|
|
// Add reasoning depth
|
|
answer += `This conclusion is based on ${steps.length} reasoning steps`;
|
|
// Add confidence qualifier
|
|
if (confidence > 0.9) {
|
|
answer += ' with very high confidence';
|
|
}
|
|
else if (confidence > 0.7) {
|
|
answer += ' with high confidence';
|
|
}
|
|
else if (confidence > 0.5) {
|
|
answer += ' with moderate confidence';
|
|
}
|
|
else {
|
|
answer += ' with exploratory confidence';
|
|
}
|
|
answer += '.';
|
|
return {
|
|
answer,
|
|
confidence,
|
|
keyInsights
|
|
};
|
|
}
|
|
async queryKnowledgeGraph(query, filters, limit) {
|
|
const results = this.knowledgeBase.query(query);
|
|
// Apply filters
|
|
let filtered = results;
|
|
if (filters.confidence) {
|
|
filtered = filtered.filter(t => t.confidence >= filters.confidence);
|
|
}
|
|
if (filters.predicate) {
|
|
filtered = filtered.filter(t => t.predicate === filters.predicate.toLowerCase());
|
|
}
|
|
// Sort by confidence
|
|
filtered.sort((a, b) => b.confidence - a.confidence);
|
|
// Limit results
|
|
const limited = filtered.slice(0, limit);
|
|
return {
|
|
query,
|
|
results: limited.map(t => ({
|
|
subject: t.subject,
|
|
predicate: t.predicate,
|
|
object: t.object,
|
|
confidence: t.confidence,
|
|
metadata: t.metadata
|
|
})),
|
|
total: limited.length,
|
|
totalAvailable: filtered.length
|
|
};
|
|
}
|
|
async addKnowledge(subject, predicate, object, confidence = 1.0, metadata = {}) {
|
|
const id = this.knowledgeBase.addTriple(subject, predicate, object, confidence, metadata);
|
|
return {
|
|
id,
|
|
status: 'added',
|
|
triple: {
|
|
subject: subject.toLowerCase(),
|
|
predicate: predicate.toLowerCase(),
|
|
object: object.toLowerCase(),
|
|
confidence
|
|
}
|
|
};
|
|
}
|
|
}
|
|
export default EnhancedPsychoSymbolicTools;
|