qsymflow


Nameqsymflow JSON
Version 0.1.2 PyPI version JSON
download
home_pagehttps://github.com/Mateusdang/qsymflow
SummaryQuantum Symbolic Flow Language – DSL simbólica para computação quântica em Python
upload_time2025-07-20 12:16:16
maintainerNone
docs_urlNone
authorMateus Dang
requires_python>=3.7
licenseNone
keywords
VCS
bugtrack_url
requirements logicflowengine
Travis-CI No Travis.
coveralls test coverage No coveralls.
            QSymFlow – Quantum Symbolic Flow Language

## 📖 Descrição

QSymFlow é uma linguagem simbólica de domínio específico (DSL) implementada em Python para modelagem e simulação de sistemas quânticos utilizando expressões lógicas e regras simbólicas.

Utilizando a biblioteca logicflowengine, o QSymFlow permite representar estados de qubits, entrelaçamento (entanglement) e fluxos de decisão quântica através de expressões booleanas interpretáveis.

Esse projeto é voltado para pesquisadores, estudantes e desenvolvedores nas áreas de:

Computação quântica simbólica e lógica

Sistemas de decisão inteligente com lógica formal

Ensino e visualização de fenômenos quânticos

Pesquisas em AI híbrida com regras simbólicas

## ⚙️ Funcionalidades

Inicialização simbólica de sistemas quânticos

Definição de regras lógicas para estados e decisões

Simulação de medições quânticas simbólicas

Integração transparente com a biblioteca logicflowengine

Estrutura modular para expansão e customização


## 🚀 Instalação

**Requer Python 3.7+.**


Instale via pip:


``` python
pip install qsymflow
```

Ou, para instalação local em modo editável (desenvolvimento):

```bash
git clone https://github.com/Mateusdang/qsymflow.git
cd qsymflow
pip install -e .
```

## 🔬 Exemplos Práticos de Computação Quântica Simbólica

**🔁 1. Simulação de Entrelaçamento (Bell State)**

```python
# Arquivo: examples/bell_state.py
from qsymflow.core import qinit, qrule, qmeasure

# Inicializa o sistema simbólico
qinit()

# Regra representando entrelaçamento: se q0 é 1, q1 também deve ser 1
qrule("(q0 and q1) or (not q0 and not q1)")

# Simulação de um estado entrelaçado (Bell)
estado = {"q0": True, "q1": True}
resultado = qmeasure(estado)
print("Resultado entrelaçado:", resultado)

```
💡 Neste exemplo, simulamos um estado Bell onde q0 e q1 devem sempre estar em sincronia. Isso representa o entrelaçamento quântico de forma simbólica e lógica. 

**🎯 2. Colapso de Estado após Medição**
```python
# Arquivo: examples/measure_collapse.py
from qsymflow.core import qinit, qrule, qmeasure

qinit()

# Regra que simula o colapso de um qubit ao ser medido
qrule("spin == 'up' or spin == 'down'")

# Simulando leitura com spin indefinido
estado = {"spin": "up"}
print("Estado medido:", qmeasure(estado))

```
💡 Aqui mostramos como simular a medição quântica: ao observar o sistema, ele assume um valor definido — uma abstração simbólica do colapso da função de onda.

**🧠 3. Sistema de Decisão Quântico-Simbólico**

```python
# Arquivo: examples/quantum_decision.py
from qsymflow.core import qinit, qrule, qmeasure

qinit()

# Regras que representam decisões baseadas em condições
qrule("risco_alto and not backup_ativo")

entrada = {"risco_alto": True, "backup_ativo": False}
decisao = qmeasure(entrada)

print("Ação necessária:", decisao)  # True = risco sem backup

```
💡 Este exemplo ilustra como sistemas inteligentes podem usar lógica simbólica inspirada na incerteza quântica para tomar decisões sob ambiguidade.

## 📁 Estrutura do Projeto

**Arduino**
```bash
qsymflow/
├── __init__.py
├── core.py
├── logic_engine.py
├── main.py
├── qsymflow/
└── examples/
    ├── bell_state.py
    ├── measure_collapse.py
    └── quantum_decision.py
README.md
setup.py
requirements.txt
pyproject.toml
```

## ⚙️ Executando o projeto

**Após a instalação, você pode rodar o simulador interativo:**

```bash
python -m qsymflow.main

Para executar o exemplo Bell State:


# Entrelaçamento Bell
python -m qsymflow.examples.bell_state

# Medição simbólica
python -m qsymflow.examples.measure_collapse

# Decisão baseada em risco
python -m qsymflow.examples.quantum_decision

```

## 📦 Deploy & Distribuição

1. Preparar o ambiente
Ter Python 3.7+

Criar ambiente virtual (opcional, recomendado):

```bash
python -m venv venv
source venv/bin/activate  # Linux/Mac
venv\\Scripts\\activate     # Windows
```
2. Instalar dependências

```bash
pip install -r requirements.txt
```
3. Instalar pacote localmente

```bash
pip install -e .
```

4. Testar execução local

```bash
python -m qsymflow.main
```



## 👨‍💻 Autor

Mateus Dang
https://github.com/Mateusdang

📄 Licença
Distribuído sob a licença MIT. Veja LICENSE para mais informações.


**⭐ Agradecimentos**

Este projeto utiliza a biblioteca logicflowengine para avaliação lógica de expressões.

https://pypi.org/project/logicflowengine/

            

Raw data

            {
    "_id": null,
    "home_page": "https://github.com/Mateusdang/qsymflow",
    "name": "qsymflow",
    "maintainer": null,
    "docs_url": null,
    "requires_python": ">=3.7",
    "maintainer_email": null,
    "keywords": null,
    "author": "Mateus Dang",
    "author_email": "mteus2030lol@gmail.com",
    "download_url": "https://files.pythonhosted.org/packages/2f/c6/87b4a0263d28ed116e3005b90d10bdb6b4476eb1ea4dad8cba9e34dc8d97/qsymflow-0.1.2.tar.gz",
    "platform": null,
    "description": "QSymFlow \u2013 Quantum Symbolic Flow Language\r\n\r\n## \ud83d\udcd6 Descri\u00e7\u00e3o\r\n\r\nQSymFlow \u00e9 uma linguagem simb\u00f3lica de dom\u00ednio espec\u00edfico (DSL) implementada em Python para modelagem e simula\u00e7\u00e3o de sistemas qu\u00e2nticos utilizando express\u00f5es l\u00f3gicas e regras simb\u00f3licas.\r\n\r\nUtilizando a biblioteca logicflowengine, o QSymFlow permite representar estados de qubits, entrela\u00e7amento (entanglement) e fluxos de decis\u00e3o qu\u00e2ntica atrav\u00e9s de express\u00f5es booleanas interpret\u00e1veis.\r\n\r\nEsse projeto \u00e9 voltado para pesquisadores, estudantes e desenvolvedores nas \u00e1reas de:\r\n\r\nComputa\u00e7\u00e3o qu\u00e2ntica simb\u00f3lica e l\u00f3gica\r\n\r\nSistemas de decis\u00e3o inteligente com l\u00f3gica formal\r\n\r\nEnsino e visualiza\u00e7\u00e3o de fen\u00f4menos qu\u00e2nticos\r\n\r\nPesquisas em AI h\u00edbrida com regras simb\u00f3licas\r\n\r\n## \u2699\ufe0f Funcionalidades\r\n\r\nInicializa\u00e7\u00e3o simb\u00f3lica de sistemas qu\u00e2nticos\r\n\r\nDefini\u00e7\u00e3o de regras l\u00f3gicas para estados e decis\u00f5es\r\n\r\nSimula\u00e7\u00e3o de medi\u00e7\u00f5es qu\u00e2nticas simb\u00f3licas\r\n\r\nIntegra\u00e7\u00e3o transparente com a biblioteca logicflowengine\r\n\r\nEstrutura modular para expans\u00e3o e customiza\u00e7\u00e3o\r\n\r\n\r\n## \ud83d\ude80 Instala\u00e7\u00e3o\r\n\r\n**Requer Python 3.7+.**\r\n\r\n\r\nInstale via pip:\r\n\r\n\r\n``` python\r\npip install qsymflow\r\n```\r\n\r\nOu, para instala\u00e7\u00e3o local em modo edit\u00e1vel (desenvolvimento):\r\n\r\n```bash\r\ngit clone https://github.com/Mateusdang/qsymflow.git\r\ncd qsymflow\r\npip install -e .\r\n```\r\n\r\n## \ud83d\udd2c Exemplos Pr\u00e1ticos de Computa\u00e7\u00e3o Qu\u00e2ntica Simb\u00f3lica\r\n\r\n**\ud83d\udd01 1. Simula\u00e7\u00e3o de Entrela\u00e7amento (Bell State)**\r\n\r\n```python\r\n# Arquivo: examples/bell_state.py\r\nfrom qsymflow.core import qinit, qrule, qmeasure\r\n\r\n# Inicializa o sistema simb\u00f3lico\r\nqinit()\r\n\r\n# Regra representando entrela\u00e7amento: se q0 \u00e9 1, q1 tamb\u00e9m deve ser 1\r\nqrule(\"(q0 and q1) or (not q0 and not q1)\")\r\n\r\n# Simula\u00e7\u00e3o de um estado entrela\u00e7ado (Bell)\r\nestado = {\"q0\": True, \"q1\": True}\r\nresultado = qmeasure(estado)\r\nprint(\"Resultado entrela\u00e7ado:\", resultado)\r\n\r\n```\r\n\ud83d\udca1 Neste exemplo, simulamos um estado Bell onde q0 e q1 devem sempre estar em sincronia. Isso representa o entrela\u00e7amento qu\u00e2ntico de forma simb\u00f3lica e l\u00f3gica. \r\n\r\n**\ud83c\udfaf 2. Colapso de Estado ap\u00f3s Medi\u00e7\u00e3o**\r\n```python\r\n# Arquivo: examples/measure_collapse.py\r\nfrom qsymflow.core import qinit, qrule, qmeasure\r\n\r\nqinit()\r\n\r\n# Regra que simula o colapso de um qubit ao ser medido\r\nqrule(\"spin == 'up' or spin == 'down'\")\r\n\r\n# Simulando leitura com spin indefinido\r\nestado = {\"spin\": \"up\"}\r\nprint(\"Estado medido:\", qmeasure(estado))\r\n\r\n```\r\n\ud83d\udca1 Aqui mostramos como simular a medi\u00e7\u00e3o qu\u00e2ntica: ao observar o sistema, ele assume um valor definido \u2014 uma abstra\u00e7\u00e3o simb\u00f3lica do colapso da fun\u00e7\u00e3o de onda.\r\n\r\n**\ud83e\udde0 3. Sistema de Decis\u00e3o Qu\u00e2ntico-Simb\u00f3lico**\r\n\r\n```python\r\n# Arquivo: examples/quantum_decision.py\r\nfrom qsymflow.core import qinit, qrule, qmeasure\r\n\r\nqinit()\r\n\r\n# Regras que representam decis\u00f5es baseadas em condi\u00e7\u00f5es\r\nqrule(\"risco_alto and not backup_ativo\")\r\n\r\nentrada = {\"risco_alto\": True, \"backup_ativo\": False}\r\ndecisao = qmeasure(entrada)\r\n\r\nprint(\"A\u00e7\u00e3o necess\u00e1ria:\", decisao)  # True = risco sem backup\r\n\r\n```\r\n\ud83d\udca1 Este exemplo ilustra como sistemas inteligentes podem usar l\u00f3gica simb\u00f3lica inspirada na incerteza qu\u00e2ntica para tomar decis\u00f5es sob ambiguidade.\r\n\r\n## \ud83d\udcc1 Estrutura do Projeto\r\n\r\n**Arduino**\r\n```bash\r\nqsymflow/\r\n\u251c\u2500\u2500 __init__.py\r\n\u251c\u2500\u2500 core.py\r\n\u251c\u2500\u2500 logic_engine.py\r\n\u251c\u2500\u2500 main.py\r\n\u251c\u2500\u2500 qsymflow/\r\n\u2514\u2500\u2500 examples/\r\n    \u251c\u2500\u2500 bell_state.py\r\n    \u251c\u2500\u2500 measure_collapse.py\r\n    \u2514\u2500\u2500 quantum_decision.py\r\nREADME.md\r\nsetup.py\r\nrequirements.txt\r\npyproject.toml\r\n```\r\n\r\n## \u2699\ufe0f Executando o projeto\r\n\r\n**Ap\u00f3s a instala\u00e7\u00e3o, voc\u00ea pode rodar o simulador interativo:**\r\n\r\n```bash\r\npython -m qsymflow.main\r\n\r\nPara executar o exemplo Bell State:\r\n\r\n\r\n# Entrela\u00e7amento Bell\r\npython -m qsymflow.examples.bell_state\r\n\r\n# Medi\u00e7\u00e3o simb\u00f3lica\r\npython -m qsymflow.examples.measure_collapse\r\n\r\n# Decis\u00e3o baseada em risco\r\npython -m qsymflow.examples.quantum_decision\r\n\r\n```\r\n\r\n## \ud83d\udce6 Deploy & Distribui\u00e7\u00e3o\r\n\r\n1. Preparar o ambiente\r\nTer Python 3.7+\r\n\r\nCriar ambiente virtual (opcional, recomendado):\r\n\r\n```bash\r\npython -m venv venv\r\nsource venv/bin/activate  # Linux/Mac\r\nvenv\\\\Scripts\\\\activate     # Windows\r\n```\r\n2. Instalar depend\u00eancias\r\n\r\n```bash\r\npip install -r requirements.txt\r\n```\r\n3. Instalar pacote localmente\r\n\r\n```bash\r\npip install -e .\r\n```\r\n\r\n4. Testar execu\u00e7\u00e3o local\r\n\r\n```bash\r\npython -m qsymflow.main\r\n```\r\n\r\n\r\n\r\n## \ud83d\udc68\u200d\ud83d\udcbb Autor\r\n\r\nMateus Dang\r\nhttps://github.com/Mateusdang\r\n\r\n\ud83d\udcc4 Licen\u00e7a\r\nDistribu\u00eddo sob a licen\u00e7a MIT. Veja LICENSE para mais informa\u00e7\u00f5es.\r\n\r\n\r\n**\u2b50 Agradecimentos**\r\n\r\nEste projeto utiliza a biblioteca logicflowengine para avalia\u00e7\u00e3o l\u00f3gica de express\u00f5es.\r\n\r\nhttps://pypi.org/project/logicflowengine/\r\n",
    "bugtrack_url": null,
    "license": null,
    "summary": "Quantum Symbolic Flow Language \u2013 DSL simb\u00f3lica para computa\u00e7\u00e3o qu\u00e2ntica em Python",
    "version": "0.1.2",
    "project_urls": {
        "Homepage": "https://github.com/Mateusdang/qsymflow"
    },
    "split_keywords": [],
    "urls": [
        {
            "comment_text": null,
            "digests": {
                "blake2b_256": "93ed58380fa61618cedd17aa534d56fc51c6cd0ff52c5a720740e70910227d55",
                "md5": "274ef935b5a8030fb50154f14c2f1d63",
                "sha256": "bd952b7224a35383625677b3758fcfbcb4ef54b47e7003a5de1533f2485027ef"
            },
            "downloads": -1,
            "filename": "qsymflow-0.1.2-py3-none-any.whl",
            "has_sig": false,
            "md5_digest": "274ef935b5a8030fb50154f14c2f1d63",
            "packagetype": "bdist_wheel",
            "python_version": "py3",
            "requires_python": ">=3.7",
            "size": 4464,
            "upload_time": "2025-07-20T12:16:15",
            "upload_time_iso_8601": "2025-07-20T12:16:15.622415Z",
            "url": "https://files.pythonhosted.org/packages/93/ed/58380fa61618cedd17aa534d56fc51c6cd0ff52c5a720740e70910227d55/qsymflow-0.1.2-py3-none-any.whl",
            "yanked": false,
            "yanked_reason": null
        },
        {
            "comment_text": null,
            "digests": {
                "blake2b_256": "2fc687b4a0263d28ed116e3005b90d10bdb6b4476eb1ea4dad8cba9e34dc8d97",
                "md5": "99d1686d4c9d6f4474dabac37d073ac5",
                "sha256": "39af0821bbcff003fd38d976e28a4d56026cdcd9033c820f77a047dded469ba2"
            },
            "downloads": -1,
            "filename": "qsymflow-0.1.2.tar.gz",
            "has_sig": false,
            "md5_digest": "99d1686d4c9d6f4474dabac37d073ac5",
            "packagetype": "sdist",
            "python_version": "source",
            "requires_python": ">=3.7",
            "size": 4323,
            "upload_time": "2025-07-20T12:16:16",
            "upload_time_iso_8601": "2025-07-20T12:16:16.858933Z",
            "url": "https://files.pythonhosted.org/packages/2f/c6/87b4a0263d28ed116e3005b90d10bdb6b4476eb1ea4dad8cba9e34dc8d97/qsymflow-0.1.2.tar.gz",
            "yanked": false,
            "yanked_reason": null
        }
    ],
    "upload_time": "2025-07-20 12:16:16",
    "github": true,
    "gitlab": false,
    "bitbucket": false,
    "codeberg": false,
    "github_user": "Mateusdang",
    "github_project": "qsymflow",
    "travis_ci": false,
    "coveralls": false,
    "github_actions": false,
    "requirements": [
        {
            "name": "logicflowengine",
            "specs": [
                [
                    ">=",
                    "0.1.2"
                ]
            ]
        }
    ],
    "lcname": "qsymflow"
}
        
Elapsed time: 1.50652s