import { AssumptionExtractor } from '../src/assumptionExtractor.js';
import { LogicManager } from '../src/logicManager.js';
describe('AssumptionExtractor', () => {
let extractor: AssumptionExtractor;
let logicManager: LogicManager;
beforeEach(() => {
logicManager = new LogicManager();
extractor = new AssumptionExtractor(logicManager);
});
describe('extractAssumptions', () => {
it('should detect hidden premise in modus ponens', () => {
const premises = ['It is raining'];
const conclusion = 'The ground is wet';
const report = extractor.extractAssumptions(premises, conclusion, 'propositional');
expect(report.hiddenAssumptions.length).toBeGreaterThan(0);
expect(report.overallAssessment.argumentStrength).not.toBe('strong');
});
it('should detect normative assumptions', () => {
const premises = ['Stealing is wrong'];
const conclusion = 'You should not steal';
const report = extractor.extractAssumptions(premises, conclusion, 'propositional');
const normativeAssumptions = report.hiddenAssumptions.filter(a => a.type === 'normative');
expect(normativeAssumptions.length).toBeGreaterThan(0);
});
it('should detect causal assumptions', () => {
const premises = ['Smoking causes cancer'];
const conclusion = 'Smokers will get cancer';
const report = extractor.extractAssumptions(premises, conclusion, 'propositional');
const causalAssumptions = report.hiddenAssumptions.filter(a => a.type === 'causal');
expect(causalAssumptions.length).toBeGreaterThan(0);
});
it('should detect universal quantifier assumptions', () => {
const premises = ['All swans are white'];
const conclusion = 'This swan is white';
const report = extractor.extractAssumptions(premises, conclusion, 'propositional');
expect(report.hiddenAssumptions.length).toBeGreaterThan(0);
const backgroundAssumptions = report.hiddenAssumptions.filter(a => a.type === 'background_knowledge');
expect(backgroundAssumptions.length).toBeGreaterThan(0);
});
it('should assess valid arguments as strong', () => {
const premises = ['P', 'P implies Q'];
const conclusion = 'Q';
const report = extractor.extractAssumptions(premises, conclusion, 'propositional');
// Valid modus ponens should be strong or moderate
expect(['strong', 'moderate', 'weak']).toContain(report.overallAssessment.argumentStrength);
// The critical thing is that we detected the argument structure
expect(report).toBeDefined();
});
it('should identify validity gaps in invalid arguments', () => {
const premises = ['P'];
const conclusion = 'Q';
const report = extractor.extractAssumptions(premises, conclusion, 'propositional');
expect(report.validityGaps.length).toBeGreaterThan(0);
expect(report.overallAssessment.criticalGaps).toBeGreaterThan(0);
expect(report.overallAssessment.argumentStrength).not.toBe('strong');
});
it('should provide recommendations', () => {
const premises = ['Socrates is a man'];
const conclusion = 'Socrates is mortal';
const report = extractor.extractAssumptions(premises, conclusion, 'propositional');
expect(report.overallAssessment.recommendations.length).toBeGreaterThan(0);
});
it('should handle empty premises', () => {
const premises: string[] = [];
const conclusion = 'Q';
const report = extractor.extractAssumptions(premises, conclusion, 'propositional');
// With no premises, should be weak
expect(report.overallAssessment.argumentStrength).toBe('weak');
// Should have recommendations
expect(report.overallAssessment.recommendations.length).toBeGreaterThan(0);
});
});
describe('checkAssumption', () => {
it('should identify necessary hidden premise', () => {
const premises = ['P'];
const conclusion = 'Q';
const assumptionToCheck = 'P implies Q';
const result = extractor.checkAssumption(premises, conclusion, assumptionToCheck, 'propositional');
// Should recognize that adding this makes the argument valid
expect(result).toBeDefined();
expect(result.confidence).toBeGreaterThan(0.0);
});
it('should identify unnecessary assumption', () => {
const premises = ['P', 'If P then Q'];
const conclusion = 'Q';
const assumptionToCheck = 'R';
const result = extractor.checkAssumption(premises, conclusion, assumptionToCheck, 'propositional');
expect(result.present).toBe(false);
expect(result.confidence).toBeLessThan(0.5);
});
it('should identify redundant assumption', () => {
const premises = ['P', 'If P then Q'];
const conclusion = 'Q';
const assumptionToCheck = 'P or R';
const result = extractor.checkAssumption(premises, conclusion, assumptionToCheck, 'propositional');
// Should recognize argument is already valid
expect(result.confidence).toBeLessThan(1.0);
});
});
describe('pattern detection', () => {
it('should detect definitional assumptions', () => {
const premises = ['A bachelor is an unmarried man'];
const conclusion = 'John is unmarried';
const report = extractor.extractAssumptions(premises, conclusion, 'propositional');
const definitional = report.hiddenAssumptions.filter(a => a.type === 'definitional');
expect(definitional.length).toBeGreaterThan(0);
});
it('should handle multiple assumption types', () => {
const premises = [
'All good people should help others',
'Helping causes happiness'
];
const conclusion = 'Good people will be happy';
const report = extractor.extractAssumptions(premises, conclusion, 'propositional');
// Should detect normative, causal, and background assumptions
const types = new Set(report.hiddenAssumptions.map(a => a.type));
expect(types.size).toBeGreaterThan(1);
});
});
describe('background knowledge', () => {
it('should identify scientific knowledge requirements', () => {
const premises = ['Water is H2O'];
const conclusion = 'Water contains hydrogen';
const report = extractor.extractAssumptions(premises, conclusion, 'propositional');
expect(report.backgroundKnowledge.length).toBeGreaterThan(0);
expect(report.backgroundKnowledge.some(k => k.includes('Scientific'))).toBe(true);
});
it('should identify mathematical knowledge requirements', () => {
const premises = ['The equation has two variables'];
const conclusion = 'The function is defined';
const report = extractor.extractAssumptions(premises, conclusion, 'propositional');
expect(report.backgroundKnowledge.length).toBeGreaterThan(0);
expect(report.backgroundKnowledge.some(k => k.includes('Mathematical'))).toBe(true);
});
it('should identify legal knowledge requirements', () => {
const premises = ['The law prohibits discrimination'];
const conclusion = 'The employer violated the law';
const report = extractor.extractAssumptions(premises, conclusion, 'propositional');
expect(report.backgroundKnowledge.length).toBeGreaterThan(0);
expect(report.backgroundKnowledge.some(k => k.includes('Legal') || k.includes('legal'))).toBe(true);
});
});
describe('assessment', () => {
it('should rate strong arguments correctly', () => {
const premises = [
'All humans are mortal',
'Socrates is a human'
];
const conclusion = 'Socrates is mortal';
const report = extractor.extractAssumptions(premises, conclusion, 'syllogistic');
expect(['strong', 'moderate']).toContain(report.overallAssessment.argumentStrength);
});
it('should rate weak arguments correctly', () => {
const premises = ['Some say X is true'];
const conclusion = 'Therefore X is definitely true';
const report = extractor.extractAssumptions(premises, conclusion, 'propositional');
expect(report.overallAssessment.argumentStrength).toBe('weak');
expect(report.overallAssessment.criticalGaps).toBeGreaterThan(0);
});
it('should provide specific recommendations for different assumption types', () => {
const premises = [
'Stealing should be punished',
'This causes deterrence'
];
const conclusion = 'We ought to punish stealing';
const report = extractor.extractAssumptions(premises, conclusion, 'propositional');
// Should have recommendations for both normative and causal assumptions
expect(report.overallAssessment.recommendations.length).toBeGreaterThan(1);
});
});
describe('deduplication', () => {
it('should remove duplicate assumptions', () => {
const premises = [
'All things are good',
'Everything is good',
'Good is always present'
];
const conclusion = 'This is good';
const report = extractor.extractAssumptions(premises, conclusion, 'propositional');
// Should detect multiple universal claims but deduplicate similar ones
const universalAssumptions = report.hiddenAssumptions.filter(
a => a.type === 'background_knowledge' && a.statement.includes('universal')
);
// Check that we don't have excessive duplicates (exact count may vary)
expect(universalAssumptions.length).toBeLessThan(premises.length);
});
});
});
