Welcome to Dojo, a curated repository of foundational scripts designed for rapid implementation, conceptual clarity, and academic study. This repository serves as a personal "training hall" where complex mathematical, computational, and quantum theories are distilled into clean, executable Python code.
Dojo was created with a clear philosophy: theory becomes meaningful through implementation. Each script in this repository transforms abstract concepts from textbooks and research papers into tangible, executable code that you can run, modify, and understand.
The core principles guiding this project are:
- Learn by Doing: Reading about algorithms is valuable, but implementing them solidifies understanding
- Quick Experimentation: All scripts are self-contained and ready to run with minimal setup
- Educational Focus: Code is written for clarity and learning, not just performance
- Conceptual Depth: Each implementation tackles fundamental concepts that form the building blocks of advanced topics
Whether you're a student studying quantum computing, a developer exploring numerical methods, or a researcher needing quick reference implementations, Dojo provides you with clean, working code to accelerate your learning journey.
The goal of this project is to provide high-quality "boilerplate" scripts that allow users to:
- Rapidly Implement: Core algorithms in diverse technical domains without starting from scratch
- Understand Concepts: Through practical, hands-on code interaction rather than passive reading
- Edit & Experiment: With parameters and inputs to study algorithmic behavior and outcomes
- Reference Implementations: Use as templates or starting points for your own projects
The Dojo is organized into specialized directories covering the pillars of modern science and engineering:
Focuses on numerical methods and abstract mathematical structures.
- Algebra_Abstrata: Exploring Galois extensions, group theory, and field theory
- Metodos_Numericos: Robust implementations including Newton-Raphson for root finding
- Geometria & Calculo: Scripts covering Spherical Geometry and Jacobian matrix calculations
- Estatistica: Probability theory foundations including Expected Value and Variance
- Teoria_dos_Numeros: Number theory concepts and algorithms
- Historia_da_Matematica: Historical mathematical developments
- Ensino_Medio: High school level mathematics implementations
Implementations using quantum frameworks (such as Qiskit) to demonstrate quantum computing principles.
- Simon's Algorithm: Quantum period-finding algorithm showcasing quantum advantage
- Quantum gates and circuit implementations
- Demonstrations of quantum supremacy concepts
Practical explorations into privacy, security, and cryptographic primitives.
- k-Anonimidade: Algorithms for data anonymization and privacy preservation
- Lattice-based Cryptography: Post-quantum secure implementations including Kyber
- Modern cryptographic protocols and cypherpunk philosophy implementations
Foundational algorithms, data structures, and complexity theory.
- Complexity (Big O): Scripts demonstrating performance scaling and algorithmic efficiency
- Topological Sorting: Implementations for dependency resolution and graph theory
- Classic CS algorithms with clear complexity analysis
High-performance computing focusing on CUDA and GPU programming concepts.
- Bank Conflicts: Demonstrations of shared memory optimization techniques
- GPU architecture-aware implementations
- Performance optimization patterns
-
Clone the repository:
git clone https://github.com/PauloAAlmeida/Dojo.git cd Dojo -
Install dependencies:
pip install numpy scipy qiskit pycryptodome
-
Choose your area of interest and navigate to the corresponding directory:
# For mathematics cd Matematica/Metodos_Numericos # For quantum algorithms cd Dojo/Quantum_algo # For cryptography cd Dojo/Criptography_Cypherpunk
Most scripts are standalone Python files that can be executed directly:
python script_name.pycd Matematica/Metodos_Numericos
python newton_raphson.pyThis will demonstrate root finding for a predefined function. Open the script to modify:
- The target function
- Initial guess value
- Convergence tolerance
- Maximum iterations
- Explore a topic directory
- Read the script comments to understand the concept
- Run the script to see it in action
- Modify parameters to experiment with different scenarios
- Study how changes affect the output
- Python 3.10+
- NumPy: For numerical computations and array operations
- SciPy: For scientific and technical computing algorithms
- Qiskit: Required for quantum algorithm scripts
- PyCryptodome: For cryptographic implementations
- python-oqs: For post-quantum cryptography examples
# Install all common dependencies
pip install numpy scipy matplotlib
# Install quantum computing dependencies
pip install qiskit qiskit-aer
# Install cryptography dependencies
pip install pycryptodome liboqs-python- Start with topics you're currently studying in class
- Run examples to see concepts in action
- Modify parameters to test your understanding
- Use scripts as study aids and reference implementations
- Browse implementations to understand algorithms before integrating them into your projects
- Use scripts as starting templates for your own work
- Study code structure and patterns for best practices
- Quickly prototype ideas using existing implementations
- Reference implementations for algorithm verification
- Build upon existing scripts to test new hypotheses
Contributions are welcome! If you'd like to add new implementations or improve existing ones:
- Fork this repository
- Create a branch for your contribution:
git checkout -b feature/add-new-algorithm
- Add your implementation following the repository structure
- Write clear comments explaining the concept and implementation
- Include usage examples in the script docstring
- Test your code to ensure it runs correctly
- Submit a pull request with a clear description of your addition
- Keep scripts self-contained and focused on a single concept
- Write clear, educational code with explanatory comments
- Include docstrings with mathematical background when applicable
- Follow Python PEP 8 style guidelines
- Add your script to the appropriate topic directory
- Start with Matematica/Ensino_Medio for foundational concepts
- Move to Matematica/Metodos_Numericos for numerical implementations
- Explore CS/Complexity to understand algorithm efficiency
- Dive into Matematica/Algebra_Abstrata for theoretical depth
- Experiment with Criptography_Cypherpunk for practical security
- Try Quantum_algo for quantum computing basics
- Study GPU_nvidia for high-performance computing
- Implement custom variations of existing algorithms
- Combine concepts from multiple directories to create new implementations
This project is open source and available for educational purposes. Please check individual scripts for specific licensing information.
Developed by Paulo Abreu — AI Engineer & Quantum Computing Enthusiast.
This repository reflects a passion for making complex technical concepts accessible through practical implementation. Each script represents hours of study, distillation, and refinement to create clear, educational code.
- Open an issue for questions or bug reports
- Contributions and suggestions are always welcome
- Star this repository if you find it useful!
Happy Learning! 🚀