Practici Interzise:
  - Manipulare sublimala:
      Example: "AI systems that deploy subliminal techniques
               to distort behavior and cause harm"
 
  - Exploatarea vulnerabilitatilor:
      Example: "AI targeting children or disabled persons
               to distort their behavior"
 
  - Scor social:
      Example: "Public authority systems that evaluate or
               classify people based on social behavior"
 
  - Identificare biometrica in timp real:
      Example: "Remote biometric identification in public
               spaces for law enforcement (with exceptions)"
 
  - Recunoasterea emotiilor la locul de munca/in educatie:
      Example: "Systems inferring emotions of employees
               or students (with exceptions)"
 
  - Categorizare biometrica:
      Example: "Categorizing people by race, political
               opinions, or sexual orientation"
 
  - Extragerea bazelor de date de recunoastere faciala:
      Example: "Creating facial recognition databases
               through untargeted internet scraping"

Categorii de Risc Ridicat:
 
  Infrastructura Critica:
    - Managementul apei, gazului, incalzirii, electricitatii
    - Trafic rutier si transport
 
  Educatie:
    - AI care determina accesul la educatie
    - Evaluarea rezultatelor invatarii
    - Evaluarea nivelului adecvat de educatie
 
  Angajare:
    - Recrutare si filtrarea candidatilor
    - Decizii de promovare si concediere
    - Alocarea sarcinilor pe baza trasaturilor de personalitate
    - Monitorizarea performantei
 
  Servicii Esentiale:
    - Scor de credit si decizii de creditare
    - Prioritizarea dispecerizarii serviciilor de urgenta
    - Evaluarea riscului in asigurarile de sanatate si viata
 
  Aplicarea Legii:
    - Evaluari individuale de risc
    - Detectoare de minciuni si detectia emotiilor
    - Evaluarea fiabilitatii probelor
    - Predictia infractiunilor (profilare)
 
  Migratie si Control Frontalier:
    - Procesarea cererilor de viza
    - Evaluarea cererilor de azil
    - Evaluarea riscului la frontiere
 
  Justitie si Democratie:
    - Asistarea judecatorilor in cercetarea juridica
    - Influentarea rezultatelor alegerilor

class AIRiskManagementSystem:
    """
    Article 9: Risk Management Requirements
    """
 
    def __init__(self, ai_system_id: str):
        self.system_id = ai_system_id
        self.risk_register = []
        self.mitigation_measures = []
 
    def identify_risks(self) -> list:
        """
        Identify and analyze known and foreseeable risks
        throughout the AI system lifecycle.
        """
        risk_categories = [
            'safety_risks',           # Physical harm potential
            'fundamental_rights',      # Impact on rights
            'bias_discrimination',     # Unfair outcomes
            'security_vulnerabilities', # Attack vectors
            'misuse_potential',        # Foreseeable misuse
            'environmental_impact',    # Resource consumption
        ]
 
        identified_risks = []
        for category in risk_categories:
            risks = self._analyze_risk_category(category)
            identified_risks.extend(risks)
 
        return identified_risks
 
    def implement_mitigations(self, risks: list) -> dict:
        """
        Implement measures to mitigate identified risks.
        Must reduce risk to acceptable level considering
        state of the art.
        """
        mitigations = {}
        for risk in risks:
            mitigation = {
                'risk_id': risk['id'],
                'measure': self._design_mitigation(risk),
                'residual_risk': self._calculate_residual_risk(risk),
                'review_schedule': self._set_review_schedule(risk),
            }
            mitigations[risk['id']] = mitigation
 
        return mitigations
 
    def continuous_monitoring(self):
        """
        Risk management must be continuous throughout
        the AI system's lifecycle.
        """
        monitoring_plan = {
            'frequency': 'continuous',
            'metrics': self._define_risk_metrics(),
            'thresholds': self._define_alert_thresholds(),
            'escalation': self._define_escalation_procedures(),
        }
        return monitoring_plan

class DataGovernanceFramework:
    """
    Article 10: Data and Data Governance
    """
 
    def validate_training_data(self, dataset: Dataset) -> dict:
        """
        Training, validation, and testing datasets must
        meet quality criteria.
        """
        validation_results = {
            'relevance': self._check_relevance(dataset),
            'representativeness': self._check_representativeness(dataset),
            'completeness': self._check_completeness(dataset),
            'bias_assessment': self._assess_bias(dataset),
            'error_rate': self._calculate_error_rate(dataset),
        }
 
        # Document any gaps and measures taken
        if not all(validation_results.values()):
            validation_results['gaps'] = self._identify_gaps(validation_results)
            validation_results['mitigation'] = self._document_mitigations()
 
        return validation_results
 
    def document_data_provenance(self, dataset: Dataset) -> dict:
        """
        Full documentation of data origin, collection,
        and processing required.
        """
        provenance = {
            'origin': dataset.source,
            'collection_date': dataset.collection_date,
            'collection_method': dataset.collection_method,
            'processing_operations': dataset.processing_log,
            'data_subjects': self._identify_data_subjects(dataset),
            'legal_basis': self._document_legal_basis(dataset),
            'retention_period': dataset.retention_policy,
        }
        return provenance
 
    def assess_bias(self, dataset: Dataset) -> dict:
        """
        Examine datasets for possible biases that could
        lead to discrimination.
        """
        bias_assessment = {
            'demographic_analysis': self._analyze_demographics(dataset),
            'representation_gaps': self._find_representation_gaps(dataset),
            'historical_bias': self._detect_historical_bias(dataset),
            'measurement_bias': self._detect_measurement_bias(dataset),
            'mitigation_applied': self._document_bias_mitigation(),
        }
        return bias_assessment

# Documentatie Tehnica Obligatorie
 
## 1. Descriere Generala
- Scopul prevazut si functionalitatea
- Identificarea dezvoltatorului/furnizorului
- Versiunea si data sistemului AI
- Cum interactioneaza sistemul AI cu hardware/software
 
## 2. Specificatii de Design
- Arhitectura sistemului si alegeri de design
- Algoritmii principali si logica lor
- Alegeri cheie de design si justificare
- Cerinte computationale
 
## 3. Procesul de Dezvoltare
- Metodologiile de dezvoltare utilizate
- Cerinte si surse de date
- Proceduri si parametri de antrenare
- Proceduri de validare si testare
 
## 4. Monitorizare si Performanta
- Metrici de performanta si benchmark-uri
- Limitari si conditii cunoscute
- Capabilitati de logare
- Masuri de supraveghere umana
 
## 5. Evaluarea Riscurilor
- Procesul de management al riscurilor
- Riscuri identificate si masuri de atenuare
- Scenarii previzibile de utilizare abuziva
- Riscuri reziduale dupa atenuare
 
## 6. Managementul Schimbarilor
- Proceduri de versionare
- Urmarirea actualizarilor si modificarilor
- Procesul de evaluare a impactului

class AISystemLogger:
    """
    Article 12: Record-Keeping Requirements
    """
 
    def __init__(self, system_id: str, retention_period_years: int = 10):
        self.system_id = system_id
        self.retention_period = retention_period_years
 
    def log_operation(self, operation: dict) -> str:
        """
        Log all operations for traceability.
        Logs must enable monitoring throughout lifecycle.
        """
        log_entry = {
            'log_id': self._generate_log_id(),
            'timestamp': datetime.utcnow().isoformat(),
            'system_id': self.system_id,
            'operation_type': operation['type'],
            'input_data_reference': operation.get('input_ref'),
            'output_data_reference': operation.get('output_ref'),
            'user_id': operation.get('user_id'),
            'duration_ms': operation.get('duration'),
            'resource_usage': operation.get('resources'),
            'errors': operation.get('errors', []),
        }
 
        self._store_log(log_entry)
        return log_entry['log_id']
 
    def enable_audit_trail(self) -> dict:
        """
        Logs must support post-market monitoring
        and incident investigation.
        """
        audit_config = {
            'automatic_logging': True,
            'immutable_logs': True,
            'log_integrity_verification': True,
            'access_logging': True,
            'retention_policy': f'{self.retention_period} years',
            'deletion_protection': True,
        }
        return audit_config

class TransparencyRequirements:
    """
    Article 13: Transparency and Provision of Information
    """
 
    def generate_user_documentation(self, ai_system: AISystem) -> dict:
        """
        Clear, comprehensive information for deployers.
        """
        documentation = {
            'provider_info': {
                'name': ai_system.provider_name,
                'contact': ai_system.provider_contact,
                'address': ai_system.provider_address,
            },
 
            'system_description': {
                'intended_purpose': ai_system.intended_purpose,
                'capabilities': ai_system.capabilities,
                'limitations': ai_system.known_limitations,
                'performance_levels': ai_system.performance_metrics,
            },
 
            'usage_instructions': {
                'intended_use': ai_system.intended_use_cases,
                'prohibited_use': ai_system.prohibited_uses,
                'input_requirements': ai_system.input_specifications,
                'output_interpretation': ai_system.output_guidelines,
            },
 
            'human_oversight': {
                'oversight_measures': ai_system.oversight_requirements,
                'intervention_points': ai_system.intervention_mechanisms,
                'override_procedures': ai_system.override_instructions,
            },
 
            'maintenance': {
                'update_procedures': ai_system.update_process,
                'technical_support': ai_system.support_contact,
                'expected_lifetime': ai_system.expected_lifetime,
            }
        }
        return documentation

class HumanOversightMeasures:
    """
    Article 14: Human Oversight Requirements
    """
 
    def design_oversight_interface(self, ai_system: AISystem) -> dict:
        """
        Systems must be designed for effective human oversight.
        """
        oversight_design = {
            'interpretability': {
                'explanation_available': True,
                'confidence_scores': True,
                'key_factors_displayed': True,
            },
 
            'intervention_capabilities': {
                'can_override_decisions': True,
                'can_halt_operation': True,
                'can_request_human_review': True,
                'override_mechanism': 'physical_button_and_software',
            },
 
            'monitoring_tools': {
                'real_time_dashboard': True,
                'anomaly_alerts': True,
                'performance_degradation_alerts': True,
            },
 
            'competency_requirements': {
                'training_required': True,
                'certification_needed': ai_system.risk_level == 'high',
                'regular_refresher': 'annual',
            }
        }
        return oversight_design
 
    def ensure_not_over_reliance(self) -> list:
        """
        Prevent automation bias and over-reliance on AI.
        """
        measures = [
            'Display confidence levels with all outputs',
            'Require human confirmation for high-stakes decisions',
            'Regular accuracy audits comparing AI vs human decisions',
            'Training on AI limitations and failure modes',
            'Periodic manual processing to maintain human skills',
            'Clear escalation paths for uncertain cases',
        ]
        return measures

class TechnicalRequirements:
    """
    Article 15: Accuracy, Robustness, and Cybersecurity
    """
 
    def accuracy_requirements(self, ai_system: AISystem) -> dict:
        """
        AI systems must achieve appropriate accuracy levels.
        """
        return {
            'accuracy_metrics': ai_system.defined_metrics,
            'accuracy_targets': ai_system.accuracy_thresholds,
            'measurement_methodology': ai_system.evaluation_procedure,
            'conditions_for_accuracy': ai_system.operating_conditions,
            'accuracy_communication': 'Clearly stated in documentation',
        }
 
    def robustness_requirements(self, ai_system: AISystem) -> dict:
        """
        AI systems must be resilient to errors, faults, and
        attempts to alter use or performance.
        """
        return {
            'error_handling': {
                'graceful_degradation': True,
                'fallback_mechanisms': ai_system.fallback_procedures,
                'error_notification': True,
            },
            'fault_tolerance': {
                'redundancy_measures': ai_system.redundancy_design,
                'self_healing_capabilities': ai_system.recovery_mechanisms,
            },
            'adversarial_robustness': {
                'attack_resistance_tested': True,
                'adversarial_training_applied': ai_system.uses_adversarial_training,
                'known_vulnerabilities_addressed': True,
            },
        }
 
    def cybersecurity_requirements(self, ai_system: AISystem) -> dict:
        """
        AI systems must be resilient against unauthorized access
        and manipulation.
        """
        return {
            'access_control': {
                'authentication_required': True,
                'authorization_model': 'role_based',
                'audit_logging': True,
            },
            'data_protection': {
                'encryption_at_rest': True,
                'encryption_in_transit': True,
                'secure_key_management': True,
            },
            'integrity_protection': {
                'model_integrity_verification': True,
                'data_integrity_checks': True,
                'tamper_detection': True,
            },
            'vulnerability_management': {
                'regular_security_testing': 'quarterly',
                'penetration_testing': 'annual',
                'patch_management_process': True,
            },
        }

Faza 1 - 2 Februarie 2025:
  Status: ACTIV
  Cerinte:
    - Obligatii de alfabetizare AI pentru personal
    - Practicile interzise intra in vigoare
 
Faza 2 - 2 August 2025:
  Status: SE APROPIE
  Cerinte:
    - Cerinte pentru modele GPAI
    - Cerinte privind structura de guvernanta
    - Penalitatile devin aplicabile
    - Desemnarea organismelor notificate
 
Faza 3 - 2 August 2026:
  Status: VIITOR
  Cerinte:
    - Cerinte pentru sisteme AI cu risc ridicat (Anexa III)
    - Proceduri de evaluare a conformitatii
    - Sisteme de management al calitatii
    - Cerinte de inregistrare
 
Faza 4 - 2 August 2027:
  Status: VIITOR
  Cerinte:
    - Cerinte de risc ridicat pentru sisteme din Anexa I
    - Aplicare completa

# Lista de Verificare pentru Conformitate AI Act
 
## Actiuni Imediate (pana in Feb 2025)
- [ ] Inventariaza toate sistemele AI utilizate
- [ ] Clasifica fiecare sistem dupa nivelul de risc
- [ ] Identifica orice practici interzise
- [ ] Incepe programul de alfabetizare AI
- [ ] Stabileste comitetul de guvernanta AI
 
## Actiuni pe Termen Scurt (pana in Aug 2025)
- [ ] Finalizeaza clasificarile de risc
- [ ] Documenteaza modelele GPAI utilizate
- [ ] Stabileste sistemul de management al calitatii
- [ ] Desemneaza responsabilul de conformitate AI
- [ ] Creeaza proceduri de raspuns la incidente
 
## Actiuni pe Termen Mediu (pana in Aug 2026)
- [ ] Finalizeaza documentatia tehnica
- [ ] Implementeaza sisteme de logare
- [ ] Realizeaza evaluarile de conformitate
- [ ] Inregistreaza sistemele AI cu risc ridicat
- [ ] Implementeaza masuri de supraveghere umana
- [ ] Finalizeaza audituri de bias si echitate
 
## Cerinte Continue
- [ ] Monitorizare continua a riscurilor
- [ ] Evaluari periodice de acuratete
- [ ] Testare periodica de securitate
- [ ] Actualizarea documentatiei la schimbari
- [ ] Mentinerea inregistrarilor de instruire
- [ ] Raportarea incidentelor grave