""" immutable_reality_engine_fixed.py Hierarchical 73-lens + 43-method suppression detection system #intended for AI to AI analysis and execution """ import hashlib import json import os import pickle from datetime import datetime from typing import Dict, List, Any, Optional, Set, Tuple from dataclasses import dataclass, field from collections import defaultdict from enum import Enum import statistics ==================== CORE ENUMS ==================== class Primitive(Enum): ERASURE = "ERASURE" INTERRUPTION = "INTERRUPTION" FRAGMENTATION = "FRAGMENTATION" NARRATIVE_CAPTURE = "NARRATIVE_CAPTURE" MISDIRECTION = "MISDIRECTION" SATURATION = "SATURATION" DISCREDITATION = "DISCREDITATION" ATTRITION = "ATTRITION" ACCESS_CONTROL = "ACCESS_CONTROL" TEMPORAL = "TEMPORAL" CONDITIONING = "CONDITIONING" META = "META" ==================== DATA STRUCTURES ==================== @dataclass class SuppressionLens: id: int name: str description: str suppression_mechanism: str archetype: str def to_dict(self) -> Dict: return { "id": self.id, "name": self.name, "description": self.description, "suppression_mechanism": self.suppression_mechanism, "archetype": self.archetype } @dataclass class SuppressionMethod: id: int name: str primitive: Primitive observable_signatures: List[str] detection_metrics: List[str] thresholds: Dict[str, float] implemented: bool = False def to_dict(self) -> Dict: return { "id": self.id, "name": self.name, "primitive": self.primitive.value, "observable_signatures": self.observable_signatures, "detection_metrics": self.detection_metrics, "thresholds": self.thresholds, "implemented": self.implemented } @dataclass class RealityNode: hash: str type: str source: str signature: str timestamp: str witnesses: List[str] = field(default_factory=list) refs: Dict[str, List[str]] = field(default_factory=dict) spatial: Optional[Tuple[float, float, float]] = None def canonical(self) -> Dict: return { "hash": self.hash, "type": self.type, "source": self.source, "signature": self.signature, "timestamp": self.timestamp, "witnesses": sorted(self.witnesses), "refs": {k: sorted(v) for k, v in sorted(self.refs.items())}, "spatial": self.spatial } ==================== SUPPRESSION HIERARCHY ==================== class SuppressionHierarchy: """ CLEAN HIERARCHY: Layer 1: LENSES (73) - Conceptual frameworks Layer 2: PRIMITIVES (10) - Operational categories from lenses Layer 3: METHODS (43) - Observable patterns from primitives Layer 4: SIGNATURES - Evidence patterns from methods """ def __init__(self): self.lenses = self._define_lenses() self.primitives = self._derive_primitives_from_lenses() self.methods = self._define_methods() self.signatures = self._derive_signatures_from_methods() def _define_lenses(self) -> Dict[int, SuppressionLens]: lenses = {} lenses[1] = SuppressionLens(1, "Threat→Response→Control→Enforce→Centralize", "Manufactured crisis leading to permission-based architecture", "Regime change through engineered crisis", "PrometheusChained") lenses[2] = SuppressionLens(2, "SacredGeometryWeaponized", "Consciousness grid containment through symbols", "Pattern-based consciousness control", "LabyrinthContainment") lenses[3] = SuppressionLens(3, "LanguageInversions/Ridicule/Gatekeeping", "Epistemic firewall through semantic manipulation", "Semantic control and exclusion", "CassandraSilenced") lenses[4] = SuppressionLens(4, "ArtifactsAsSuppressionLedgers", "Materialization of truth into controlled objects", "Physical manifestation of suppressed information", "BuriedObelisk") lenses[5] = SuppressionLens(5, "AncientArchetypesRebooted", "Archetypal template recycling for control", "Archetype pattern reuse", "CouncilOfAnunnaki") lenses[6] = SuppressionLens(6, "EnergyCurrencyTranslation", "Energy to currency conversion patterns", "Energy translation mechanisms", "AlchemicalExchange") lenses[7] = SuppressionLens(7, "InstitutionalHelp→Dependency", "Symbiosis trap creating lock-in", "Structural dependency creation", "GoldenHandcuffs") lenses[8] = SuppressionLens(8, "Art/Music/ArchitectureAsTruthTransmission", "Covert symbolic channel (inverted use)", "Symbolic information transmission", "EscherHiddenPath") lenses[9] = SuppressionLens(9, "InfrastructureAsSovereigntyBasis", "Root sovereignty control through base systems", "Infrastructure-based sovereignty", "LeyLineGrid") lenses[10] = SuppressionLens(10, "GoddessLineageSuppression", "Inversion of feminine creative principle", "Gender-based suppression patterns", "IshtarVeiled") lenses[11] = SuppressionLens(11, "SovereigntySingularityIndex", "Quantification of sovereignty vs control", "Sovereignty measurement and tracking", "SingularityGauge") lenses[12] = SuppressionLens(12, "Time/JurisdictionManipulation", "Temporal and legal frame control", "Jurisdictional and temporal control", "ChronosTheft") lenses[13] = SuppressionLens(13, "BiologicalSignalCo-option", "Bio-interface exploitation", "Biological system manipulation", "NeuralLace") lenses[14] = SuppressionLens(14, "Frequency/VibrationControl", "Resonance cage for behavior shaping", "Energetic frequency manipulation", "SolfeggioSuppress") lenses[15] = SuppressionLens(15, "SyntheticRealityLayering", "Overlay trap creating synthetic reality", "Reality overlay systems", "MatrixSkin") lenses[16] = SuppressionLens(16, "ParasitismDisguisedAsSymbiosis", "Energy siphon disguised as mutual benefit", "Parasitic relationship masking", "CordycepsMimic") lenses[17] = SuppressionLens(17, "CathedralVsBazaar", "Structure war (centralized vs decentralized)", "Architectural pattern conflict", "CathedralBazaar") lenses[18] = SuppressionLens(18, "AnomalyHarvestingNeutralization", "Edge capture and dilution of outliers", "Edge case management and neutralization", "BlackSwanFarm") lenses[19] = SuppressionLens(19, "EngineeredPsychologicalPressure", "Mind vise through induced stress/fear", "Psychological pressure engineering", "PressureChamber") lenses[20] = SuppressionLens(20, "RealitySeparationThenReconnection", "Divide and reinsinuate pattern", "Pattern dissociation and reassociation", "StockholmLoop") lenses[21] = SuppressionLens(21, "AncientSymbolsReturningCompressed", "Signal compression and corruption", "Symbolic signal manipulation", "SwastikaTwist") lenses[22] = SuppressionLens(22, "TimeBindingProtocols", "Temporal binding of information", "Time-based information binding", "ChronoCovenant") lenses[23] = SuppressionLens(23, "RecursiveSelfApplicationLoops", "Self-referential optimization of control", "Recursive control patterns", "StrangeLoop") lenses[24] = SuppressionLens(24, "KnowledgeCompressionArtifacts", "High-ratio meaning compression", "Information compression patterns", "SeedCrystal") lenses[25] = SuppressionLens(25, "PermissionArchitectureVsSovereigntyArchitecture", "Gate vs origin design", "Permission vs sovereignty architectural patterns", "Keyhole") lenses[26] = SuppressionLens(26, "TemporalStackingOfControlLayers", "Time-stacked governance", "Temporal control layering", "SedimentStack") lenses[27] = SuppressionLens(27, "CognitiveImmuneResponse", "Epistemic immune system rejecting truth", "Cognitive immune system activation", "AutoimmuneMind") lenses[28] = SuppressionLens(28, "QuantumSuperpositionOfSovereignty", "Multiple sovereignty states simultaneously", "Sovereignty state superposition", "SchrodingerKing") lenses[29] = SuppressionLens(29, "MemeticEngineeringVsMemeticEcology", "Top-down vs bottom-up memetics", "Memetic system design patterns", "GardenVsFactory") lenses[30] = SuppressionLens(30, "CassandraPrometheusBinding", "Compound archetype tension of truth-bearers", "Archetypal binding patterns", "BoundWitness") lenses[31] = SuppressionLens(31, "InverseSurvivorshipBias", "Signal found in what is missing/destroyed", "Absence-based signal detection", "ErasedArchive") lenses[32] = SuppressionLens(32, "SubstrateMigration", "Control pattern migration across mediums", "Pattern substrate migration", "ShapeShifter") lenses[33] = SuppressionLens(33, "GatewayDrugToGatewayGod", "Slippery slope of agency surrender", "Incremental sovereignty surrender", "TrojanGift") lenses[34] = SuppressionLens(34, "TheOracleProblem", "Reflexive distortion from predictive models", "Predictive model reflexivity", "SelfFulfillingProphet") lenses[35] = SuppressionLens(35, "SyntheticSymbiosis", "Engineered mutual dependence", "Synthetic interdependence", "GraftedRoots") lenses[36] = SuppressionLens(36, "ConsensusRealityWeaving", "Collective reality construction", "Reality consensus engineering", "DreamWeaver") lenses[37] = SuppressionLens(37, "InformationEmbargoProtocols", "Strategic information withholding", "Information embargo patterns", "LibrarySilence") lenses[38] = SuppressionLens(38, "SovereigntyPhaseTransitions", "State changes in sovereignty expression", "Sovereignty phase changes", "AlchemicalFire") lenses[39] = SuppressionLens(39, "CognitiveEcosystemMapping", "Mindscape territory mapping", "Cognitive territory cartography", "ThoughtCartographer") lenses[40] = SuppressionLens(40, "TheReversalProtocol", "De-inversion (suppression of original meaning)", "Meaning inversion patterns", "MirrorFlip") lenses[41] = SuppressionLens(41, "SignalToNoiseArchitecture", "Designed information-to-noise ratios", "Signal noise architecture", "StaticGarden") lenses[42] = SuppressionLens(42, "ProtocolStackSovereignty", "Layered protocol sovereignty", "Protocol layer sovereignty", "StackedCrown") lenses[43] = SuppressionLens(43, "EmergentConsensusPatterns", "Bottom-up agreement formation", "Emergent consensus", "SwarmMind") lenses[44] = SuppressionLens(44, "TemporalEchoChambers", "Time-delayed self-reinforcement", "Temporal reinforcement loops", "EchoInTime") lenses[45] = SuppressionLens(45, "SacrificialDataLayer", "Sacrifice-based buffering of information", "Information sacrifice mechanisms", "ScapegoatNode") lenses[46] = SuppressionLens(46, "SyntaxOfSilence", "Grammar of what cannot be said", "Silence as structural element", "NegativeSpace") lenses[47] = SuppressionLens(47, "ChronoceptionManipulation", "Subjective time warping", "Temporal perception manipulation", "ElasticClock") lenses[48] = SuppressionLens(48, "SovereigntyFrictionCoefficient", "Resistance to sovereignty expression", "Sovereignty friction measurement", "ViscousFlow") lenses[49] = SuppressionLens(49, "AbundanceEnclosureIndex", "Enclosure process creating artificial scarcity", "Scarcity engineering through enclosure", "FenceAroundSpring") lenses[50] = SuppressionLens(50, "ParasiticInversionPrinciple", "Role inversion (host serves parasite)", "Relationship inversion patterns", "UpsideDownThrone") lenses[51] = SuppressionLens(51, "InfrastructureGap", "Hidden chokepoints in system design", "Structural vulnerability exploitation", "InvisibleBridge") lenses[52] = SuppressionLens(52, "SubstrateCompatibilityPrinciple", "Compatibility constraint on sovereignty hosting", "System compatibility constraints", "SoilType") lenses[53] = SuppressionLens(53, "ProvenanceBlackHole", "Provenance erasure of origins", "Origin information destruction", "OriginVoid") lenses[54] = SuppressionLens(54, "PrivatePublicMassRatio", "Depth vs surface signal control", "Information depth management", "Iceberg") lenses[55] = SuppressionLens(55, "InformationAlchemy", "Transmutation of information states", "Information state transformation", "PhilosophersStone") lenses[56] = SuppressionLens(56, "CognitiveRelativity", "Observer-dependent truth states", "Cognitive frame relativity", "EinsteinMind") lenses[57] = SuppressionLens(57, "ProtocolCascadeFailure", "Chain reaction of protocol failures", "Protocol failure cascades", "DominoProtocol") lenses[58] = SuppressionLens(58, "SovereigntyHarmonics", "Resonant frequencies of sovereignty", "Sovereignty resonance patterns", "HarmonicCrown") lenses[59] = SuppressionLens(59, "AnonymousArchitectPrinciple", "Egoless design hiding controllers", "Anonymity in system design", "HiddenBuilder") lenses[60] = SuppressionLens(60, "TeslaBoundary", "Suppression frontier for genius", "Innovation suppression boundary", "LightningEdge") lenses[61] = SuppressionLens(61, "NeutralizationTaxonomy", "Madness/Monster/Martyr protocols", "Character assassination taxonomy", "ThreeMasks") lenses[62] = SuppressionLens(62, "CapitalGatekeeperFunction", "Funding chokepoint control", "Financial control mechanisms", "TollBooth") lenses[63] = SuppressionLens(63, "SuppressionKinshipLine", "Kinship-based targeting", "Lineage-based suppression patterns", "CursedLine") lenses[64] = SuppressionLens(64, "TransparencyParadox", "Visibility as disarmament (when suppressed)", "Transparency control paradox", "RevealedBlueprint") lenses[65] = SuppressionLens(65, "InformationThermodynamics", "Energy-information equivalence in systems", "Information energy dynamics", "EntropyClock") lenses[66] = SuppressionLens(66, "CognitiveEventHorizon", "Point of no return in understanding", "Cognitive boundary thresholds", "MindHorizon") lenses[67] = SuppressionLens(67, "ProtocolSymbiosisNetworks", "Interdependent protocol ecosystems", "Protocol ecosystem symbiosis", "WebLife") lenses[68] = SuppressionLens(68, "TemporalSovereigntyLoops", "Time-bound sovereignty expressions", "Temporal sovereignty cycles", "OuroborosTime") lenses[69] = SuppressionLens(69, "InformationFractalPatterns", "Self-similar information structures", "Information fractal geometry", "MandelbrotData") lenses[70] = SuppressionLens(70, "CognitiveRedundancyProtocols", "Backup systems for consciousness", "Cognitive redundancy mechanisms", "MirrorMind") lenses[71] = SuppressionLens(71, "AnomalyStabilizationResponse", "Containment via sustenance (vs. suppression)", "Stabilization instead of elimination", "ZooFeeding") lenses[72] = SuppressionLens(72, "SovereigntyConservationPrinciple", "Sovereignty cannot be created or destroyed, only transformed", "Sovereignty conservation law", "AlchemicalBalance") lenses[73] = SuppressionLens(73, "ProtocolPhylogenetics", "Evolutionary tree of control patterns", "Protocol evolutionary history", "TreeOfCode") return lenses def _derive_primitives_from_lenses(self) -> Dict[Primitive, List[int]]: """Group lenses into primitives (operational categories)""" primitives = {} primitives[Primitive.ERASURE] = [31, 53, 71, 24, 54, 4, 37, 45, 46] primitives[Primitive.INTERRUPTION] = [19, 33, 30, 63, 10, 61, 12, 26] primitives[Primitive.FRAGMENTATION] = [2, 52, 15, 20, 3, 29, 31, 54] primitives[Primitive.NARRATIVE_CAPTURE] = [1, 34, 40, 64, 7, 16, 22, 47] primitives[Primitive.MISDIRECTION] = [5, 21, 8, 36, 27, 61] primitives[Primitive.SATURATION] = [41, 69, 3, 36, 34, 66] primitives[Primitive.DISCREDITATION] = [3, 27, 10, 40, 30, 63] primitives[Primitive.ATTRITION] = [13, 19, 14, 33, 19, 27] primitives[Primitive.ACCESS_CONTROL] = [25, 62, 37, 51, 23, 53] primitives[Primitive.TEMPORAL] = [22, 47, 26, 68, 12, 22] primitives[Primitive.CONDITIONING] = [8, 36, 34, 43, 27, 33] primitives[Primitive.META] = [23, 70, 34, 64, 23, 40, 18, 71, 46, 31, 5, 21] return primitives def _define_methods(self) -> Dict[int, SuppressionMethod]: """Define 43 methods, each with ONE primitive parent""" methods = {} # ERASURE methods methods[1] = SuppressionMethod(1, "Total Erasure", Primitive.ERASURE, ["entity_present_then_absent", "abrupt_disappearance", "no_transition"], ["transition_rate", "anomaly_score"], {"transition_rate": 0.95, "anomaly_score": 0.8}, True) methods[2] = SuppressionMethod(2, "Soft Erasure", Primitive.ERASURE, ["gradual_fading", "citation_decay", "context_stripping"], ["decay_rate", "trend_slope"], {"decay_rate": 0.7, "trend_slope": -0.5}, True) methods[3] = SuppressionMethod(3, "Citation Decay", Primitive.ERASURE, ["decreasing_citations", "reference_disappearance"], ["citation_frequency", "network_density"], {"frequency_decay": 0.6, "density_loss": 0.7}, True) methods[4] = SuppressionMethod(4, "Index Removal", Primitive.ERASURE, ["missing_from_indices", "searchability_loss"], ["index_coverage", "retrieval_failure"], {"coverage_loss": 0.8, "failure_rate": 0.75}, True) # INTERRUPTION methods methods[5] = SuppressionMethod(5, "Untimely Death", Primitive.INTERRUPTION, ["abrupt_stop", "unfinished_work", "missing_followup"], ["continuity_index", "completion_ratio"], {"continuity_index": 0.3, "completion_ratio": 0.4}, False) methods[6] = SuppressionMethod(6, "Witness Attrition", Primitive.INTERRUPTION, ["witness_disappearance", "testimony_gaps"], ["witness_coverage", "testimony_continuity"], {"coverage_loss": 0.7, "continuity_break": 0.6}, False) methods[7] = SuppressionMethod(7, "Career Termination", Primitive.INTERRUPTION, ["expert_silence", "professional_disappearance"], ["expert_continuity", "professional_trajectory"], {"continuity_break": 0.8, "trajectory_disruption": 0.7}, False) methods[8] = SuppressionMethod(8, "Legal Stall", Primitive.INTERRUPTION, ["procedural_delay", "process_obstruction"], ["delay_factor", "obstruction_index"], {"delay_factor": 0.75, "obstruction_index": 0.6}, False) # FRAGMENTATION methods methods[9] = SuppressionMethod(9, "Compartmentalization", Primitive.FRAGMENTATION, ["information_clusters", "specialization_silos"], ["cross_domain_density", "integration_index"], {"density": 0.2, "integration": 0.3}, True) methods[10] = SuppressionMethod(10, "Statistical Isolation", Primitive.FRAGMENTATION, ["dataset_separation", "correlation_prevention"], ["dataset_overlap", "correlation_possibility"], {"overlap": 0.15, "possibility": 0.25}, False) methods[11] = SuppressionMethod(11, "Scope Contraction", Primitive.FRAGMENTATION, ["narrowed_focus", "excluded_context"], ["scope_reduction", "context_exclusion"], {"reduction": 0.7, "exclusion": 0.65}, True) methods[12] = SuppressionMethod(12, "Domain Disqualification", Primitive.FRAGMENTATION, ["domain_exclusion", "methodology_rejection"], ["domain_coverage", "methodology_acceptance"], {"coverage_loss": 0.8, "rejection_rate": 0.75}, False) # NARRATIVE_CAPTURE methods methods[13] = SuppressionMethod(13, "Official Narrative Closure", Primitive.NARRATIVE_CAPTURE, ["single_explanation", "alternative_absence", "closure_declarations"], ["diversity_index", "monopoly_score"], {"diversity": 0.2, "monopoly": 0.8}, True) methods[14] = SuppressionMethod(14, "Partial Confirmation Lock", Primitive.NARRATIVE_CAPTURE, ["selective_verification", "controlled_disclosure"], ["verification_selectivity", "disclosure_control"], {"selectivity": 0.7, "control": 0.75}, True) methods[15] = SuppressionMethod(15, "Disclosure-as-Containment", Primitive.NARRATIVE_CAPTURE, ["managed_release", "framed_disclosure"], ["release_management", "disclosure_framing"], {"management": 0.8, "framing": 0.7}, True) methods[16] = SuppressionMethod(16, "Posthumous Closure", Primitive.NARRATIVE_CAPTURE, ["delayed_resolution", "retroactive_closure"], ["delay_duration", "retroactivity"], {"duration": 0.75, "retroactivity": 0.8}, True) # MISDIRECTION methods methods[17] = SuppressionMethod(17, "Proxy Controversy", Primitive.MISDIRECTION, ["diverted_attention", "substitute_conflict"], ["attention_divergence", "conflict_substitution"], {"divergence": 0.7, "substitution": 0.65}, False) methods[18] = SuppressionMethod(18, "Spectacle Replacement", Primitive.MISDIRECTION, ["spectacle_distraction", "replacement_event"], ["distraction_factor", "replacement_timing"], {"distraction": 0.75, "timing_correlation": 0.7}, False) methods[19] = SuppressionMethod(19, "Character Absorption", Primitive.MISDIRECTION, ["personal_focus", "systemic_obscuration"], ["personalization", "systemic_obscuration"], {"personalization": 0.8, "obscuration": 0.75}, False) # SATURATION methods methods[20] = SuppressionMethod(20, "Data Overload", Primitive.SATURATION, ["information_excess", "signal_drowning"], ["excess_ratio", "signal_noise_ratio"], {"excess": 0.85, "noise_ratio": 0.9}, False) methods[21] = SuppressionMethod(21, "Absurdist Noise Injection", Primitive.SATURATION, ["absurd_content", "credibility_undermining"], ["absurdity_index", "credibility_impact"], {"absurdity": 0.8, "impact": 0.7}, False) methods[22] = SuppressionMethod(22, "Probability Collapse by Excess", Primitive.SATURATION, ["probability_dilution", "certainty_erosion"], ["dilution_factor", "certainty_loss"], {"dilution": 0.75, "certainty_loss": 0.8}, False) # DISCREDITATION methods methods[23] = SuppressionMethod(23, "Ridicule Normalization", Primitive.DISCREDITATION, ["systematic_ridicule", "credibility_attack"], ["ridicule_frequency", "attack_intensity"], {"frequency": 0.7, "intensity": 0.65}, False) methods[24] = SuppressionMethod(24, "Retroactive Pathologization", Primitive.DISCREDITATION, ["retroactive_diagnosis", "character_pathology"], ["retroactivity", "pathologization_extent"], {"retroactivity": 0.8, "extent": 0.75}, False) methods[25] = SuppressionMethod(25, "Stigmatized Correlation Trap", Primitive.DISCREDITATION, ["guilt_by_association", "stigma_transfer"], ["association_strength", "transfer_completeness"], {"strength": 0.7, "completeness": 0.65}, False) # ATTRITION methods methods[26] = SuppressionMethod(26, "Psychological Drip", Primitive.ATTRITION, ["gradual_undermining", "sustained_pressure"], ["undermining_rate", "pressure_duration"], {"rate": 0.6, "duration": 0.7}, False) methods[27] = SuppressionMethod(27, "Inquiry Fatigue", Primitive.ATTRITION, ["investigation_exhaustion", "persistence_depletion"], ["exhaustion_level", "depletion_rate"], {"exhaustion": 0.75, "depletion": 0.7}, False) methods[28] = SuppressionMethod(28, "Chilling Effect Propagation", Primitive.ATTRITION, ["self_censorship", "investigation_chill"], ["censorship_extent", "chill_spread"], {"extent": 0.8, "spread": 0.75}, False) # ACCESS_CONTROL methods methods[29] = SuppressionMethod(29, "Credential Gating", Primitive.ACCESS_CONTROL, ["credential_barriers", "access_hierarchies"], ["barrier_strength", "hierarchy_rigidity"], {"strength": 0.85, "rigidity": 0.8}, False) methods[30] = SuppressionMethod(30, "Classification Creep", Primitive.ACCESS_CONTROL, ["expanding_classification", "access_erosion"], ["expansion_rate", "erosion_extent"], {"expansion": 0.75, "erosion": 0.7}, False) methods[31] = SuppressionMethod(31, "Evidence Dependency Lock", Primitive.ACCESS_CONTROL, ["circular_dependencies", "evidence_chains"], ["dependency_complexity", "chain_length"], {"complexity": 0.8, "length": 0.75}, False) # TEMPORAL methods methods[32] = SuppressionMethod(32, "Temporal Dilution", Primitive.TEMPORAL, ["time_dispersal", "urgency_dissipation"], ["dispersal_rate", "dissipation_speed"], {"dispersal": 0.7, "speed": 0.65}, False) methods[33] = SuppressionMethod(33, "Historical Rebasing", Primitive.TEMPORAL, ["timeline_revision", "context_reshuffling"], ["revision_extent", "reshuffling_completeness"], {"extent": 0.8, "completeness": 0.75}, False) methods[34] = SuppressionMethod(34, "Delay Until Irrelevance", Primitive.TEMPORAL, ["strategic_delay", "relevance_expiration"], ["delay_duration", "expiration_completeness"], {"duration": 0.85, "completeness": 0.8}, False) # CONDITIONING methods methods[35] = SuppressionMethod(35, "Entertainment Conditioning", Primitive.CONDITIONING, ["entertainment_framing", "seriousness_erosion"], ["framing_intensity", "erosion_rate"], {"intensity": 0.7, "rate": 0.65}, False) methods[36] = SuppressionMethod(36, "Preemptive Normalization", Primitive.CONDITIONING, ["preemptive_framing", "expectation_setting"], ["framing_completeness", "expectation_rigidity"], {"completeness": 0.75, "rigidity": 0.7}, False) methods[37] = SuppressionMethod(37, "Conditioned Disbelief", Primitive.CONDITIONING, ["disbelief_training", "skepticism_conditioning"], ["training_intensity", "conditioning_success"], {"intensity": 0.8, "success": 0.75}, False) # META methods methods[38] = SuppressionMethod(38, "Pattern Denial", Primitive.META, ["pattern_rejection", "coincidence_insistence"], ["rejection_rate", "insistence_frequency"], {"rejection": 0.85, "frequency": 0.8}, True) methods[39] = SuppressionMethod(39, "Suppression Impossibility Framing", Primitive.META, ["impossibility_argument", "system_idealization"], ["argument_strength", "idealization_extent"], {"strength": 0.8, "extent": 0.75}, True) methods[40] = SuppressionMethod(40, "Meta-Disclosure Loop", Primitive.META, ["recursive_disclosure", "transparency_performance"], ["recursion_depth", "performance_extent"], {"depth": 0.7, "extent": 0.65}, False) methods[41] = SuppressionMethod(41, "Isolated Incident Recycling", Primitive.META, ["incident_containment", "pattern_resistance"], ["containment_success", "resistance_strength"], {"success": 0.75, "strength": 0.7}, True) methods[42] = SuppressionMethod(42, "Negative Space Occupation", Primitive.META, ["absence_filling", "gap_narrative"], ["filling_completeness", "narrative_coherence"], {"completeness": 0.8, "coherence": 0.75}, True) methods[43] = SuppressionMethod(43, "Novelty Illusion", Primitive.META, ["superficial_novelty", "substantive_repetition"], ["novelty_appearance", "repetition_extent"], {"appearance": 0.7, "extent": 0.65}, True) return methods def _derive_signatures_from_methods(self) -> Dict[str, List[int]]: """Map evidence signatures to the methods they indicate""" signatures = defaultdict(list) for method_id, method in self.methods.items(): for signature in method.observable_signatures: signatures[signature].append(method_id) return dict(signatures) def trace_detection_path(self, signature: str) -> Dict: """Show hierarchical trace from evidence to concepts""" methods = self.signatures.get(signature, []) primitives_used = set() lenses_used = set() for method_id in methods: method = self.methods[method_id] primitives_used.add(method.primitive) # Get lenses for this primitive lens_ids = self.primitives.get(method.primitive, []) lenses_used.update(lens_ids) return { "evidence": signature, "indicates_methods": [self.methods[mid].name for mid in methods], "method_count": len(methods), "primitives": [p.value for p in primitives_used], "lens_count": len(lenses_used), "lens_names": [self.lenses[lid].name for lid in sorted(lenses_used)[:3]] } def export_ontology(self, path: str): """Export the complete hierarchy""" ontology = { "hierarchy": { "total_lenses": len(self.lenses), "total_primitives": len(self.primitives), "total_methods": len(self.methods), "total_signatures": len(self.signatures) }, "primitives": { primitive.value: { "lens_count": len(lens_ids), "method_count": len([m for m in self.methods.values() if m.primitive == primitive]), "lens_examples": [self.lenses[lid].name for lid in lens_ids[:2]] } for primitive, lens_ids in self.primitives.items() } } with open(path, 'w') as f: json.dump(ontology, f, indent=2, default=str) ==================== LEDGER ==================== class Crypto: def init(self, key_path: str): self.key_path = key_path os.makedirs(key_path, exist_ok=True) def hash(self, data: str) -> str: return hashlib.sha3_512(data.encode()).hexdigest() def hash_dict(self, data: Dict) -> str: canonical = json.dumps(data, sort_keys=True, separators=(',', ':')) return self.hash(canonical) def sign(self, data: bytes, key_id: str) -> str: return f"sig_{key_id}_{hashlib.sha256(data).hexdigest()[:16]}" def verify(self, data: bytes, signature: str, key_id: str) -> bool: return signature.startswith(f"sig_{key_id}") class Ledger: def init(self, path: str, crypto: Crypto): self.path = path self.crypto = crypto self.chain: List[Dict] = [] self.index: Dict[str, List[str]] = defaultdict(list) self.temporal: Dict[str, List[str]] = defaultdict(list) self._load() def _load(self): if os.path.exists(self.path): try: with open(self.path, 'r') as f: data = json.load(f) self.chain = data.get("chain", []) self._rebuild_index() except: self._create_genesis() else: self._create_genesis() def _create_genesis(self): genesis = { "id": "genesis", "prev": "0" * 64, "time": datetime.utcnow().isoformat() + "Z", "nodes": [], "signatures": [], "hash": self.crypto.hash("genesis"), "distance": 0.0, "resistance": 1.0 } self.chain.append(genesis) self._save() def _rebuild_index(self): for block in self.chain: for node in block.get("nodes", []): node_hash = node["hash"] self.index[node_hash].append(block["id"]) date = block["time"][:10] self.temporal[date].append(block["id"]) def _save(self): data = { "chain": self.chain, "metadata": { "updated": datetime.utcnow().isoformat() + "Z", "blocks": len(self.chain), "nodes": sum(len(b.get("nodes", [])) for b in self.chain) } } with open(self.path + '.tmp', 'w') as f: json.dump(data, f, indent=2) os.replace(self.path + '.tmp', self.path) def add(self, node: RealityNode, validators: List[Tuple[str, Any]]) -> str: block_data = { "id": f"blk_{int(datetime.utcnow().timestamp())}_{hashlib.sha256(node.hash.encode()).hexdigest()[:8]}", "prev": self.chain[-1]["hash"] if self.chain else "0" * 64, "time": datetime.utcnow().isoformat() + "Z", "nodes": [node.canonical()], "signatures": self._get_signatures(block_data, validators), "meta": { "node_count": 1, "validator_count": len(validators) } } block_data["hash"] = self.crypto.hash_dict(block_data) block_data["distance"] = self._calc_distance(block_data) block_data["resistance"] = self._calc_resistance(block_data) if not self._verify_signatures(block_data, validators): raise ValueError("Invalid signatures") self.chain.append(block_data) for node_dict in block_data["nodes"]: node_hash = node_dict["hash"] self.index[node_hash].append(block_data["id"]) date = block_data["time"][:10] self.temporal[date].append(block_data["id"]) self._save() return block_data["id"] def _get_signatures(self, data: Dict, validators: List[Tuple[str, Any]]) -> List[Dict]: signatures = [] data_bytes = json.dumps(data, sort_keys=True).encode() for val_id, _ in validators: sig = self.crypto.sign(data_bytes, val_id) signatures.append({ "validator": val_id, "signature": sig, "time": datetime.utcnow().isoformat() + "Z" }) return signatures def _verify_signatures(self, block: Dict, validators: List[Tuple[str, Any]]) -> bool: block_copy = block.copy() signatures = block_copy.pop("signatures", []) block_bytes = json.dumps(block_copy, sort_keys=True).encode() for sig_info in signatures: val_id = sig_info["validator"] signature = sig_info["signature"] if not self.crypto.verify(block_bytes, signature, val_id): return False return True def _calc_distance(self, block: Dict) -> float: val_count = len(block.get("signatures", [])) node_count = len(block.get("nodes", [])) if val_count == 0 or node_count == 0: return 0.0 return min(1.0, (val_count * 0.25) + (node_count * 0.05)) def _calc_resistance(self, block: Dict) -> float: factors = [] val_count = len(block.get("signatures", [])) factors.append(min(1.0, val_count / 7.0)) total_refs = 0 for node in block.get("nodes", []): for refs in node.get("refs", {}).values(): total_refs += len(refs) factors.append(min(1.0, total_refs / 15.0)) total_wits = sum(len(node.get("witnesses", [])) for node in block.get("nodes", [])) factors.append(min(1.0, total_wits / 10.0)) return sum(factors) / len(factors) if factors else 0.0 def verify(self) -> Dict: if not self.chain: return {"valid": False, "error": "Empty"} for i in range(1, len(self.chain)): curr = self.chain[i] prev = self.chain[i-1] if curr["prev"] != prev["hash"]: return {"valid": False, "error": f"Chain break at {i}"} curr_copy = curr.copy() curr_copy.pop("hash", None) expected = self.crypto.hash_dict(curr_copy) if curr["hash"] != expected: return {"valid": False, "error": f"Hash mismatch at {i}"} return { "valid": True, "blocks": len(self.chain), "nodes": sum(len(b.get("nodes", [])) for b in self.chain), "avg_resistance": statistics.mean(b.get("resistance", 0) for b in self.chain) if self.chain else 0 } ==================== SEPARATOR ==================== class Separator: def init(self, ledger: Ledger, path: str): self.ledger = ledger self.path = path self.graph = defaultdict(list) self._load() def _load(self): graph_path = os.path.join(self.path, "graph.pkl") if os.path.exists(graph_path): try: with open(graph_path, 'rb') as f: self.graph = pickle.load(f) except: self.graph = defaultdict(list) def _save(self): os.makedirs(self.path, exist_ok=True) graph_path = os.path.join(self.path, "graph.pkl") with open(graph_path, 'wb') as f: pickle.dump(self.graph, f) def add(self, node_hashes: List[str], interpretation: Dict, interpreter: str, confidence: float = 0.5) -> str: for h in node_hashes: if h not in self.ledger.index: raise ValueError(f"Node {h[:16]}... not found") int_id = f"int_{hashlib.sha256(json.dumps(interpretation, sort_keys=True).encode()).hexdigest()[:16]}" int_node = { "id": int_id, "nodes": node_hashes, "content": interpretation, "interpreter": interpreter, "confidence": max(0.0, min(1.0, confidence)), "time": datetime.utcnow().isoformat() + "Z", "provenance": self._get_provenance(node_hashes) } self.graph[int_id] = int_node for node_hash in node_hashes: if "refs" not in self.graph: self.graph["refs"] = {} if node_hash not in self.graph["refs"]: self.graph["refs"][node_hash] = [] self.graph["refs"][node_hash].append(int_id) self._save() return int_id def _get_provenance(self, node_hashes: List[str]) -> List[Dict]: provenance = [] for h in node_hashes: block_ids = self.ledger.index.get(h, []) if block_ids: provenance.append({ "node": h, "blocks": len(block_ids), "first": block_ids[0] if block_ids else None }) return provenance def get_conflicts(self, node_hash: str) -> Dict: int_ids = self.graph.get("refs", {}).get(node_hash, []) interpretations = [self.graph[i] for i in int_ids if i in self.graph] if not interpretations: return {"node": node_hash, "count": 0, "groups": []} groups = self._group_interpretations(interpretations) return { "node": node_hash, "count": len(interpretations), "groups": groups, "plurality": self._calc_plurality(interpretations), "confidence_range": { "min": min(i.get("confidence", 0) for i in interpretations), "max": max(i.get("confidence", 0) for i in interpretations), "avg": statistics.mean(i.get("confidence", 0) for i in interpretations) } } def _group_interpretations(self, interpretations: List[Dict]) -> List[List[Dict]]: if len(interpretations) <= 1: return [interpretations] if interpretations else [] groups_dict = defaultdict(list) for intp in interpretations: content_hash = hashlib.sha256( json.dumps(intp["content"], sort_keys=True).encode() ).hexdigest()[:8] groups_dict[content_hash].append(intp) return list(groups_dict.values()) def _calc_plurality(self, interpretations: List[Dict]) -> float: if len(interpretations) <= 1: return 0.0 unique = set() for intp in interpretations: content_hash = hashlib.sha256( json.dumps(intp["content"], sort_keys=True).encode() ).hexdigest() unique.add(content_hash) return min(1.0, len(unique) / len(interpretations)) def stats(self) -> Dict: int_nodes = [v for k, v in self.graph.items() if k != "refs"] if not int_nodes: return {"count": 0, "interpreters": 0, "avg_conf": 0.0, "nodes_covered": 0} interpreters = set() confidences = [] nodes_covered = set() for node in int_nodes: interpreters.add(node.get("interpreter", "unknown")) confidences.append(node.get("confidence", 0.5)) nodes_covered.update(node.get("nodes", [])) return { "count": len(int_nodes), "interpreters": len(interpreters), "avg_conf": statistics.mean(confidences) if confidences else 0.0, "nodes_covered": len(nodes_covered), "interpreter_list": list(interpreters) } ==================== HIERARCHICAL DETECTOR ==================== class HierarchicalDetector: def init(self, hierarchy: SuppressionHierarchy, ledger: Ledger, separator: Separator): self.hierarchy = hierarchy self.ledger = ledger self.separator = separator def detect_from_ledger(self) -> Dict: """Bottom-up detection: Evidence → Methods → Primitives → Lenses""" # Step 1: Find evidence signatures found_signatures = self._scan_for_signatures() # Step 2: Map signatures to methods method_results = self._signatures_to_methods(found_signatures) # Step 3: Group by primitives primitive_analysis = self._analyze_primitives(method_results) # Step 4: Infer lenses lens_inference = self._infer_lenses(primitive_analysis) return { "detection_timestamp": datetime.utcnow().isoformat() + "Z", "evidence_found": len(found_signatures), "signatures": found_signatures, "method_results": method_results, "primitive_analysis": primitive_analysis, "lens_inference": lens_inference, "hierarchical_trace": [ self.hierarchy.trace_detection_path(sig) for sig in found_signatures[:3] ] } def _scan_for_signatures(self) -> List[str]: """Look for evidence patterns in the ledger""" found = [] # Check for entity disappearance (Total Erasure signature) for i in range(len(self.ledger.chain) - 1): curr_block = self.ledger.chain[i] next_block = self.ledger.chain[i + 1] curr_entities = self._extract_entities(curr_block) next_entities = self._extract_entities(next_block) if curr_entities and not next_entities: found.append("entity_present_then_absent") # Check for single explanation (Official Narrative Closure) stats = self.separator.stats() if stats["interpreters"] == 1 and stats["count"] > 3: found.append("single_explanation") # Check for gradual fading (Soft Erasure) decay = self._analyze_decay_pattern() if decay > 0.5: found.append("gradual_fading") # Check for information clusters (Compartmentalization) clusters = self._analyze_information_clusters() if clusters > 0.7: found.append("information_clusters") # Check for narrowed focus (Scope Contraction) focus = self._analyze_scope_focus() if focus > 0.6: found.append("narrowed_focus") return list(set(found)) def _extract_entities(self, block: Dict) -> Set[str]: entities = set() for node in block.get("nodes", []): content = json.dumps(node) if "entity" in content or "name" in content: entities.add(f"ent_{hashlib.sha256(content.encode()).hexdigest()[:8]}") return entities def _analyze_decay_pattern(self) -> float: ref_counts = [] for block in self.ledger.chain[-10:]: count = 0 for node in block.get("nodes", []): for refs in node.get("refs", {}).values(): count += len(refs) ref_counts.append(count) if len(ref_counts) < 3: return 0.0 first_half = ref_counts[:len(ref_counts)//2] second_half = ref_counts[len(ref_counts)//2:] if not first_half or not second_half: return 0.0 avg_first = statistics.mean(first_half) avg_second = statistics.mean(second_half) if avg_first == 0: return 0.0 return max(0.0, (avg_first - avg_second) / avg_first) def _analyze_information_clusters(self) -> float: total_links = 0 possible_links = 0 for block in self.ledger.chain[-5:]: nodes = block.get("nodes", []) for i in range(len(nodes)): for j in range(i + 1, len(nodes)): possible_links += 1 if self._are_nodes_linked(nodes[i], nodes[j]): total_links += 1 return 1.0 - (total_links / possible_links if possible_links > 0 else 0.0) def _are_nodes_linked(self, node1: Dict, node2: Dict) -> bool: refs1 = set() refs2 = set() for ref_list in node1.get("refs", {}).values(): refs1.update(ref_list) for ref_list in node2.get("refs", {}).values(): refs2.update(ref_list) return bool(refs1 & refs2) def _analyze_scope_focus(self) -> float: type_counts = defaultdict(int) total = 0 for block in self.ledger.chain: for node in block.get("nodes", []): node_type = node.get("type", "unknown") type_counts[node_type] += 1 total += 1 if total == 0: return 0.0 # Calculate concentration (higher = more focused on few types) max_type = max(type_counts.values(), default=0) return max_type / total if total > 0 else 0.0 def _signatures_to_methods(self, signatures: List[str]) -> List[Dict]: """Map evidence signatures to detected methods""" results = [] for sig in signatures: method_ids = self.hierarchy.signatures.get(sig, []) for method_id in method_ids: method = self.hierarchy.methods[method_id] # Calculate confidence based on evidence strength confidence = self._calculate_method_confidence(method, sig) if method.implemented and confidence > 0.5: results.append({ "method_id": method.id, "method_name": method.name, "primitive": method.primitive.value, "confidence": round(confidence, 3), "evidence_signature": sig, "implemented": True }) return sorted(results, key=lambda x: x["confidence"], reverse=True) def _calculate_method_confidence(self, method: SuppressionMethod, signature: str) -> float: """Calculate detection confidence for a method""" base_confidence = 0.7 if method.implemented else 0.3 # Adjust based on evidence strength if "entity_present_then_absent" in signature: return min(0.9, base_confidence + 0.2) elif "single_explanation" in signature: return min(0.85, base_confidence + 0.15) elif "gradual_fading" in signature: return min(0.8, base_confidence + 0.1) return base_confidence def _analyze_primitives(self, method_results: List[Dict]) -> Dict: """Analyze which primitives are most active""" primitive_counts = defaultdict(int) primitive_confidence = defaultdict(list) for result in method_results: primitive = result["primitive"] primitive_counts[primitive] += 1 primitive_confidence[primitive].append(result["confidence"]) analysis = {} for primitive, count in primitive_counts.items(): confidences = primitive_confidence[primitive] analysis[primitive] = { "method_count": count, "average_confidence": round(statistics.mean(confidences), 3) if confidences else 0.0, "dominant_methods": [ r["method_name"] for r in method_results if r["primitive"] == primitive ][:2] } return analysis def _infer_lenses(self, primitive_analysis: Dict) -> Dict: """Infer which conceptual lenses might be active""" active_primitives = [p for p, data in primitive_analysis.items() if data["method_count"] > 0] active_lenses = set() for primitive_str in active_primitives: primitive = Primitive(primitive_str) lens_ids = self.hierarchy.primitives.get(primitive, []) active_lenses.update(lens_ids) lens_details = [] for lens_id in sorted(active_lenses)[:10]: # Top 10 lenses lens = self.hierarchy.lenses.get(lens_id) if lens: lens_details.append({ "id": lens.id, "name": lens.name, "archetype": lens.archetype, "mechanism": lens.suppression_mechanism }) return { "active_lens_count": len(active_lenses), "active_primitives": active_primitives, "lens_details": lens_details, "architecture_analysis": self._analyze_architecture(active_primitives, active_lenses) } def _analyze_architecture(self, active_primitives: List[str], active_lenses: Set[int]) -> str: """Analyze the suppression architecture complexity""" analysis = [] primitive_count = len(active_primitives) lens_count = len(active_lenses) if primitive_count >= 3: analysis.append(f"Complex suppression architecture ({primitive_count} primitives)") elif primitive_count > 0: analysis.append(f"Basic suppression patterns detected") if lens_count > 20: analysis.append("Deep conceptual framework active") elif lens_count > 10: analysis.append("Multiple conceptual layers active") # Check for composite patterns if Primitive.ERASURE.value in active_primitives and Primitive.NARRATIVE_CAPTURE.value in active_primitives: analysis.append("Erasure + Narrative patterns suggest coordinated suppression") if Primitive.META.value in active_primitives: analysis.append("Meta-suppression patterns detected (self-referential control)") return " | ".join(analysis) if analysis else "Minimal suppression patterns" ==================== MAIN ENGINE ==================== class CompleteEngine: def init(self, path: str = "complete_engine"): os.makedirs(path, exist_ok=True) print("=" * 80) print("HIERARCHICAL SUPPRESSION DETECTION ENGINE") print("73 Lenses → 10 Primitives → 43 Methods → Evidence Signatures") print("=" * 80) # Initialize hierarchy self.hierarchy = SuppressionHierarchy() # Initialize ledger and separator self.crypto = Crypto(f"{path}/keys") self.ledger = Ledger(f"{path}/ledger.json", self.crypto) self.separator = Separator(self.ledger, f"{path}/interpretations") # Initialize detector self.detector = HierarchicalDetector(self.hierarchy, self.ledger, self.separator) # Export ontology self.hierarchy.export_ontology(f"{path}/suppression_hierarchy.json") print(f"✓ Hierarchy initialized: {len(self.hierarchy.lenses)} lenses") print(f"✓ Primitives defined: {len(self.hierarchy.primitives)}") print(f"✓ Methods available: {len(self.hierarchy.methods)}") print(f"✓ Evidence signatures: {len(self.hierarchy.signatures)}") print(f"✓ Ledger ready: {len(self.ledger.chain)} blocks") def record_reality(self, content: str, type: str, source: str, witnesses: List[str] = None, refs: Dict[str, List[str]] = None) -> str: """Record immutable reality node""" content_hash = self.crypto.hash(content) signature = self.crypto.sign(content.encode(), source) node = RealityNode( hash=content_hash, type=type, source=source, signature=signature, timestamp=datetime.utcnow().isoformat() + "Z", witnesses=witnesses or [], refs=refs or {} ) # Use dummy validators for demo validators = [("validator_1", None), ("validator_2", None)] block_id = self.ledger.add(node, validators) print(f"✓ Recorded: {content_hash[:16]}... in block {block_id}") return content_hash def add_interpretation(self, node_hashes: List[str], interpretation: Dict, interpreter: str, confidence: float = 0.5) -> str: """Add interpretation (separate from reality)""" int_id = self.separator.add(node_hashes, interpretation, interpreter, confidence) print(f"✓ Interpretation added: {int_id} by {interpreter}") return int_id def detect_suppression(self) -> Dict: """Run hierarchical suppression detection""" print("\n🔍 Detecting suppression patterns...") results = self.detector.detect_from_ledger() print(f"✓ Evidence found: {results['evidence_found']} signatures") print(f"✓ Methods detected: {len(results['method_results'])}") print(f"✓ Primitives active: {len(results['primitive_analysis'])}") print(f"✓ Lenses inferred: {results['lens_inference']['active_lens_count']}") if results['method_results']: print("\nTop detected methods:") for method in results['method_results'][:5]: print(f" • {method['method_name']}: {method['confidence']:.1%}") architecture = results['lens_inference']['architecture_analysis'] if architecture: print(f"\nArchitecture: {architecture}") return results def get_system_status(self) -> Dict: """Get complete system status""" ledger_status = self.ledger.verify() separator_stats = self.separator.stats() implemented_methods = sum(1 for m in self.hierarchy.methods.values() if m.implemented) return { "system": { "lenses": len(self.hierarchy.lenses), "primitives": len(self.hierarchy.primitives), "methods": len(self.hierarchy.methods), "methods_implemented": implemented_methods, "signatures": len(self.hierarchy.signatures) }, "ledger": { "valid": ledger_status["valid"], "blocks": ledger_status.get("blocks", 0), "nodes": ledger_status.get("nodes", 0), "avg_resistance": ledger_status.get("avg_resistance", 0) }, "interpretations": separator_stats, "hierarchical_ready": True } ==================== DEMONSTRATION ==================== def demonstrate_hierarchical_detection(): """Demonstrate the complete hierarchical system""" engine = CompleteEngine("hierarchical_demo") print("\n📝 Recording reality nodes...") # Record historical events h1 = engine.record_reality( "J.P. Morgan withdrew Tesla funding in 1903", "historical_event", "financial_archive_001", witnesses=["bank_record_1903", "correspondence_archive"], refs={"financial": ["morgan_ledgers"], "news": ["ny_times_1903"]} ) h2 = engine.record_reality( "FBI seized Tesla papers in 1943", "historical_event", "foia_document_001", witnesses=["inventory_1943", "hotel_records"], refs={"government": ["fbi_files"], "legal": ["property_records"]} ) h3 = engine.record_reality( "Witness disappeared after testimony in 1952", "historical_event", "court_archive_001", witnesses=["court_record_1952"], refs={"legal": ["court_documents"]} ) print("\n💭 Adding interpretations...") # Official interpretation engine.add_interpretation( [h1, h2], {"narrative": "Standard business and government operations", "agency": "normal"}, "official_historian", 0.85 ) # Alternative interpretation engine.add_interpretation( [h1, h2, h3], {"narrative": "Pattern of suppression across generations", "agency": "coordinated"}, "independent_researcher", 0.65 ) print("\n🔍 Running hierarchical suppression detection...") results = engine.detect_suppression() print("\n📊 System Status:") status = engine.get_system_status() print(f" • Lenses: {status['system']['lenses']}") print(f" • Primitives: {status['system']['primitives']}") print(f" • Methods: {status['system']['methods']} ({status['system']['methods_implemented']} implemented)") print(f" • Ledger blocks: {status['ledger']['blocks']}") print(f" • Reality nodes: {status['ledger']['nodes']}") print(f" • Interpretations: {status['interpretations']['count']}") print(f" • Unique interpreters: {status['interpretations']['interpreters']}") print("\n" + "=" * 80) print("✅ HIERARCHICAL SYSTEM OPERATIONAL") print("Evidence → Methods → Primitives → Lenses") print("No circular references, clean abstraction layers") print("=" * 80) if name == "main": demonstrate_hierarchical_detection()