GoQubitSim

Uma biblioteca Go para simulação de computação quântica e criptografia quântica

Sobre • Funcionalidades • Tecnologias • Instalação • Como Usar • Estrutura • Documentação • Contribuir

QubitSim é uma biblioteca JavaScript moderna que implementa conceitos fundamentais de computação quântica e criptografia quântica. Projetada para ser intuitiva e educacional, permite aos desenvolvedores e pesquisadores:

• Simular operações com qubits
• Implementar algoritmos quânticos clássicos
• Explorar protocolos de criptografia quântica
• Visualizar estados quânticos
• Monitorar e otimizar performance
• Desenvolver interfaces acessíveis e internacionalizadas

Ideal para estudantes, educadores e entusiastas que desejam explorar o fascinante mundo da computação quântica sem a necessidade de hardware quântico real.

• Manipulação de qubits: Criação, transformação e medição de qubits
• Portas quânticas: Implementação de portas fundamentais (H, X, Y, Z, CNOT)
• Emaranhamento quântico: Simulação de estados emaranhados
• Medição quântica: Colapso de superposições e obtenção de resultados clássicos
• Visualização avançada: Interface gráfica interativa para circuitos quânticos

• Geração de chaves quânticas: Criação segura de chaves usando princípios quânticos
• Protocolo BB84: Implementação do primeiro protocolo de distribuição quântica de chaves
• Criptografia e descriptografia: Proteção de mensagens usando chaves quânticas
• Detecção de interferência: Identificação de tentativas de espionagem
• Autenticação quântica: Verificação segura de identidades
• Validação de segurança: Verificações automáticas de vulnerabilidades

• Deutsch-Jozsa: Determinação de propriedades de funções booleanas
• Grover: Busca em bases de dados não estruturadas
• Shor: Fatoração de números inteiros
• Bernstein-Vazirani: Descoberta de strings ocultas
• Visualização de algoritmos: Interface interativa para acompanhamento de execução

• Métricas em tempo real: Monitoramento de uso de recursos
• Profiling: Análise detalhada de performance
• Otimização automática: Cache inteligente e lazy loading
• Rastreamento: Logs estruturados e análise de erros
• Dashboards: Visualização de métricas e alertas

• Interface responsiva: Adaptação a diferentes dispositivos
• Internacionalização: Suporte a múltiplos idiomas (pt-BR, en, es)
• Acessibilidade: Conformidade com WCAG 2.1
• Temas personalizáveis: Suporte a temas claros e escuros
• Componentes reutilizáveis: Biblioteca de componentes React

• Pipeline automatizado: Testes, build e deploy automáticos
• Controle de qualidade: Linting e análise estática
• Monitoramento: Integração com ferramentas de APM
• Backup automático: Rotinas de backup e recuperação
• Segurança: Verificações automáticas de vulnerabilidades

# Instalação básica
npm install qubitsim

# Instalação com suporte a internacionalização
npm install qubitsim i18next react-i18next

# Instalação com todas as dependências opcionais
npm install qubitsim i18next react-i18next @sentry/react @sentry/tracing redis

package main

import (
	"fmt"
	"math"
	"math/rand"
	"time"

	"github.com/suissa/goqubitsim/core"
	"github.com/suissa/goqubitsim/crypto"
)

func main() {
	rand.Seed(time.Now().UnixNano())

	fmt.Println("=== Demonstração do Sistema Quântico GoQubitSim ===")

	// 1. Criação de Qubits Básicos
	fmt.Println("\n1. Criando Qubits Básicos:")
	q0 := core.NewQubit([]float64{1, 0}) // |0⟩
	q1 := core.NewQubit([]float64{0, 1}) // |1⟩
	fmt.Printf("Qubit 0 Estado Inicial: %v\n", q0.Coefficients)
	fmt.Printf("Qubit 1 Estado Inicial: %v\n", q1.Coefficients)

	// 2. Operações Quânticas
	fmt.Println("\n2. Aplicando Portas Quânticas:")
	q0.RotateX(math.Pi / 2)
	q1.RotateY(math.Pi / 4)
	fmt.Printf("Qubit 0 após Rotação X: %v\n", q0.Coefficients)
	fmt.Printf("Qubit 1 após Rotação Y: %v\n", q1.Coefficients)

	// 3. Entrelaçamento Quântico
	fmt.Println("\n3. Entrelaçando Qubits:")
	q0.Entangle(q1)
	fmt.Println("Qubits Entrelaçados:")
	fmt.Printf("Estado Combinado: %v\n", q0.Coefficients)

	// 4. Geração de Chave Quântica
	fmt.Println("\n4. Gerando Chave Quântica:")
	keyConfig := crypto.GenerateQuantumKey(128)
	fmt.Printf("Chave Gerada: %v...\n", keyConfig.SiftedKey[:16])
	fmt.Printf("Tamanho da Chave: %d bits\n", len(keyConfig.SiftedKey))

	// 5. Criptografia de Mensagem
	fmt.Println("\n5. Criptografando Mensagem:")
	message := []int{0, 1, 0, 0, 1, 1, 0, 1} // "01001101"
	encrypted := crypto.EncryptMessage(message)
	fmt.Printf("Paridade da Mensagem: %d\n", encrypted.Parity)
	fmt.Printf("Qubits Transmitidos: %d\n", len(encrypted.Qubits))

	// 6. Simulação de Transmissão com Interferência
	fmt.Println("\n6. Simulando Transmissão:")
	if rand.Float32() < 0.3 { // 30% chance de interferência
		fmt.Println(">>> Interferência Detectada! <<<")
		encrypted.Qubits[2].RotateX(math.Pi / 4) // Altera um qubit
	}

	// 7. Decriptação da Mensagem
	fmt.Println("\n7. Decifrando Mensagem:")
	decrypted, err := crypto.DecryptMessage(encrypted.Qubits, encrypted.Parity)

	if err != nil {
		fmt.Println("Erro na Decriptação:", err)
	} else {
		fmt.Printf("Mensagem Decifrada: %s\n", decrypted)
		fmt.Printf("Mensagem Original:  %v\n", message)
	}

	// 8. Verificação Quântica de Segurança
	fmt.Println("\n8. Verificação de Segurança:")
	errorRate := keyConfig.CheckEavesdropping(50)
	fmt.Printf("Taxa de Erro Detectada: %.2f%%\n", errorRate*100)
	if errorRate < 0.1 {
		fmt.Println("Status: Sistema Seguro!")
	} else {
		fmt.Println("Status: Possível Ataque Detectado!")
	}
}

goqubitsim/
├── src/
│   ├── core/           # Componentes fundamentais
│   │   ├── qubit.go
│   │   ├── quantumRegister.go
│   │   └── measurement.go
│   ├── crypto/         # Funcionalidades de criptografia
│   │   ├── generateKey.go
│   │   ├── encryptMessage.go
│   │   └── decryptMessage.go
│   ├── gates/          # Portas quânticas
│   │   ├── hadamard.js
│   │   ├── pauli.js
│   │   └── cnot.js
│   ├── algorithms/     # Algoritmos quânticos
│   │   ├── deutschJozsa.js
│   │   ├── grover.js
│   │   ├── shor.js
│   │   └── bernsteinVazirani.js
│   ├── ui/            # Interface do usuário
│   │   ├── components/
│   │   ├── hooks/
│   │   └── themes/
│   ├── monitoring/    # Sistema de monitoramento
│   │   ├── metrics/
│   │   ├── profiling/
│   │   └── alerts/
│   ├── i18n/         # Internacionalização
│   │   ├── locales/
│   │   └── config.js
│   └── index.js
├── tests/              # Testes unitários
├── docs/              # Documentação da API
├── examples/          # Exemplos de uso
└── package.json

A documentação completa da API está disponível em docs/. Para gerar a documentação localmente:

npm run docs

Após a geração, abra docs/index.html no seu navegador para explorar a documentação interativa.

• Visão Geral
• Guia de Início Rápido
• Referência da API
• Guia de Desenvolvimento
• Guia de Segurança
• Guia de Performance
• Guia de Acessibilidade
• Guia de Internacionalização
• Guia de Monitoramento
• Guia de CI/CD
• FAQ

Para garantir a qualidade e confiabilidade, o QubitSim possui uma suíte abrangente de testes:

# Executar todos os testes
npm test

# Executar testes com cobertura
npm run test:coverage

# Executar testes específicos
npm test -- --testPathPattern=qubit

# Executar testes de performance
npm run test:performance

# Executar testes de acessibilidade
npm run test:a11y

# Executar testes de integração
npm run test:integration

Contribuições são bem-vindas e muito apreciadas! Siga estes passos:

1. 🍴 Faça um fork do projeto
2. 🌿 Crie uma branch para sua feature (git checkout -b feature/AmazingFeature)
3. 💾 Commit suas mudanças (git commit -m 'feat(scope): add some AmazingFeature')
4. 📤 Push para a branch (git push origin feature/AmazingFeature)
5. 🔍 Abra um Pull Request

Consulte nossos guias detalhados:

• Guia de Contribuição
• Guia de Estilo
• Guia de Desenvolvimento
• Guia de Testes

O QubitSim leva a segurança a sério. Implementamos:

• Validação rigorosa de inputs
• Criptografia de dados sensíveis
• Proteção contra ataques comuns (XSS, CSRF)
• Auditoria automática de dependências
• Monitoramento de vulnerabilidades

Para reportar vulnerabilidades de segurança, por favor envie um email para security@qubitsim.com.

Consulte nosso Guia de Segurança para mais detalhes.

O QubitSim é otimizado para:

• Execução eficiente de algoritmos quânticos
• Renderização rápida de interfaces
• Gerenciamento inteligente de memória
• Cache automático de resultados
• Carregamento lazy de componentes

Recursos de monitoramento incluem:

• Métricas em tempo real
• Profiling detalhado
• Alertas automáticos
• Dashboards personalizáveis
• Logs estruturados

Consulte nosso Guia de Performance para mais detalhes.

O QubitSim suporta múltiplos idiomas:

• 🇧🇷 Português (Brasil)
• 🇺🇸 English
• 🇪🇸 Español

Para adicionar um novo idioma ou melhorar traduções existentes, consulte nosso Guia de Internacionalização.

O QubitSim segue as diretrizes WCAG 2.1:

• Navegação por teclado
• Suporte a leitores de tela
• Alto contraste
• Textos redimensionáveis
• Legendas e descrições

Consulte nosso Guia de Acessibilidade para mais detalhes.

Este projeto está licenciado sob a Licença MIT - veja o arquivo LICENSE para detalhes.

A licença MIT é uma licença de software permissiva que coloca poucas restrições de uso, modificação e distribuição. Ela permite:

• ✅ Uso comercial
• ✅ Modificação
• ✅ Distribuição
• ✅ Uso privado

A única exigência é manter o aviso de copyright e a licença em qualquer cópia do software/código fonte.

Suissa Desenvolvimento inicial

Este é um projeto educacional para estudo e simulação de conceitos de computação quântica. Não deve ser usado para criptografia em produção sem uma revisão de segurança adequada.

• Fase Atual: 3 - Funcionalidades Core
• Progresso: 80%
• Próximos Passos:
  1. Implementação do algoritmo de Shor
  2. Melhorias na visualização de circuitos
  3. Otimizações de performance
  4. Expansão da documentação