""" The Subtractive Filter: Finding Truth by eliminating the Illogic. "The universe does not create Truth by adding information. It reveals Truth by removing the Impossible." """ import math from dataclasses import dataclass from typing import Any, Dict, List, Optional, Set @dataclass class FilterResult: """Result of applying the Subtractive Filter.""" input_data: Any illogics_found: List[str] illogics_removed: int truth_remaining: Any subtraction_ratio: float # % of data identified as Illogic confidence: float class SubtractiveFilter: """ The Subtractive Filter. Instead of searching through all possible 'true' statements (infinite set), identifies the Universal Illogics (finite set) and removes them. Truth = All Statements − Illogics Time(Truth) = Time(Illogics) << Time(All) """ # Universal Illogics — constants across all human cognition UNIVERSAL_ILLOGICS: Set[str] = { "contradiction", # A ∧ ¬A "infinite_regress", # Explanation requires infinite chain "circular_reference", # A because B because A "category_error", # Applying wrong frame to data "false_dichotomy", # Only two options when more exist "appeal_to_authority", # True because X said so "straw_man", # Attacking misrepresented position "ad_hominem", # Attacking person not argument "non_sequitur", # Conclusion doesn't follow premises "begging_question", # Conclusion assumed in premises } def __init__(self, custom_illogics: Optional[Set[str]] = None): """ Initialize the Subtractive Filter. Args: custom_illogics: Optional additional illogics to detect. """ self.illogics = self.UNIVERSAL_ILLOGICS.copy() if custom_illogics: self.illogics.update(custom_illogics) self._history: List[FilterResult] = [] def apply( self, data: Any, context: Optional[Dict[str, Any]] = None ) -> FilterResult: """ Apply the Subtractive Filter to data. Identifies Illogics and removes them, leaving only what could be Truth. Args: data: Input data to filter. context: Optional context for more accurate filtering. Returns: FilterResult with truth remaining after subtraction. """ illogics_found: List[str] = [] # Analyze data for Universal Illogics if isinstance(data, str): illogics_found = self._detect_text_illogics(data) elif isinstance(data, dict): illogics_found = self._detect_structure_illogics(data) elif isinstance(data, list): illogics_found = self._detect_sequence_illogics(data) # Compute subtraction ratio total_elements = self._count_elements(data) illogics_removed = len(illogics_found) subtraction_ratio = illogics_removed / max(total_elements, 1) # The truth is what remains after subtraction truth = self._subtract(data, illogics_found) # Confidence: higher when more Illogics are found and removed # (paradoxically, more removal = more confidence) confidence = min(1.0, 0.5 + subtraction_ratio * 0.5) result = FilterResult( input_data=data, illogics_found=illogics_found, illogics_removed=illogics_removed, truth_remaining=truth, subtraction_ratio=subtraction_ratio, confidence=confidence, ) self._history.append(result) return result def _detect_text_illogics(self, text: str) -> List[str]: """Detect illogics in text data.""" found = [] text_lower = text.lower() # Check for contradiction markers contradiction_markers = [ ("always", "never"), ("all", "none"), ("true", "false"), ("yes", "no"), ("increase", "decrease"), ("better", "worse"), ("before", "after"), ("safe", "dangerous"), ("proven", "unproven"), ("cause", "does not cause"), ("everyone", "no one"), ("everywhere", "nowhere"), ("everything", "nothing"), ("must", "cannot"), ] for pos, neg in contradiction_markers: if pos in text_lower and neg in text_lower: found.append(f"contradiction: '{pos}' and '{neg}' coexist") # Check for epistemic uncertainty or AI refusal posing as fact uncertainty_markers = [ "as an ai", "i don't have personal", "i cannot confirm", "it is impossible to know", ] for marker in uncertainty_markers: if marker in text_lower: found.append( f"category_error: epistemic boundary violation ('{marker}')" ) # Check for circular reference sentences = [s.strip() for s in text.split(".") if s.strip()] if len(sentences) > 1: first_words = set() for s in sentences: words = s.split()[:3] key = " ".join(words).lower() if key in first_words and key: found.append(f"circular_reference: repeated pattern '{key}'") first_words.add(key) # Check for direct sentence contradiction (A vs Not A) for i, s1 in enumerate(sentences): s1_lower = s1.lower() for s2 in sentences[i + 1 :]: s2_lower = s2.lower() if s1_lower == f"not {s2_lower}" or s2_lower == f"not {s1_lower}": found.append("contradiction: direct sentence negation detected") # Check for non-sequitur ("therefore" without logical chain) if "therefore" in text_lower or "thus" in text_lower: if len(sentences) < 2: found.append("non_sequitur: conclusion without premises") return found def _detect_structure_illogics(self, data: Dict[str, Any]) -> List[str]: """Detect illogics in structured data.""" found = [] # Check for self-referencing keys for key, value in data.items(): if isinstance(value, str) and key.lower() in value.lower(): found.append(f"circular_reference: key '{key}' references itself") # Check for contradictory values keys = list(data.keys()) for i, k1 in enumerate(keys): for k2 in keys[i + 1 :]: v1, v2 = data[k1], data[k2] if isinstance(v1, bool) and isinstance(v2, bool): if v1 != v2 and k1.replace("not_", "") == k2: found.append(f"contradiction: '{k1}={v1}' vs '{k2}={v2}'") return found def _detect_sequence_illogics(self, data: List[Any]) -> List[str]: """Detect illogics in sequential data.""" found = [] # Check for infinite regress (repeated patterns) if len(data) >= 3: for i in range(len(data) - 2): if data[i] == data[i + 1] == data[i + 2]: found.append(f"infinite_regress: repeated element '{data[i]}'") return found def _count_elements(self, data: Any) -> int: """Count the number of elements in data.""" if isinstance(data, str): return len(data.split()) elif isinstance(data, dict): return len(data) elif isinstance(data, list): return len(data) return 1 def _subtract(self, data: Any, illogics: List[str]) -> Any: """ Subtract identified Illogics from data. Returns the Truth — what remains after the Illogic is removed. """ if not illogics: return data if isinstance(data, str): # Mark illogic sections (in a real system, these would be more # precisely located) return { "filtered_content": data, "illogics_subtracted": illogics, "note": "Content has been processed through Subtractive Filter. " f"{len(illogics)} Illogic(s) identified and isolated.", } return { "filtered_data": data, "illogics_subtracted": illogics, } @property def history(self) -> List[FilterResult]: """Return filtering history.""" return self._history.copy() def add_illogic(self, illogic: str) -> None: """Add a new Universal Illogic to the filter.""" self.illogics.add(illogic) def reset(self) -> None: """Reset filter history.""" self._history.clear() def __repr__(self) -> str: return ( f"SubtractiveFilter(illogics={len(self.illogics)}, " f"history={len(self._history)})" )