# angel23213/lenguajes-y-aut-matas architecture

> Architecture diagram of the GitHub repository angel23213/lenguajes-y-aut-matas, generated by GitDiagram from its file tree, README and a sample of source files (last updated 2026-03-07). It is an AI-made overview: check details against the source.

- Interactive diagram: https://gitdiagram.com/angel23213/lenguajes-y-aut-matas
- Repository: https://github.com/angel23213/lenguajes-y-aut-matas

## Overview

##### Tipo y propósito del proyecto (a partir del árbol y README)
Este repositorio no es una “aplicación” desplegable tipo web; es un **repositorio educativo** con **múltiples mini‑proyectos de autómatas** (probablemente deterministas) implementados en **Python**, más documentación en PDF.

Indicadores claros:
- README: “proyectos de autómatas… para entender características”.
- Estructura: carpetas separadas, cada una con un `.py` principal y algunos PDFs de soporte/pruebas.
- No se observan dependencias, framework, ni empaquetado (no hay `requirements.txt`, `setup.py`, `src/`, etc.). Esto sugiere **scripts ejecutables** (CLI / ejecución directa) más que una librería.

##### Cómo leer la estructura (y qué implica para el diagrama)
Carpetas de primer nivel (cada una = un “sub-sistema”):
- `Automata moore-mealy/Automata-moore.py`
Implementación relacionada a **Máquinas de Moore/Mealy** (típicamente producen salida por estado o transición).
- `Automata1/automata.py` + `Pruebas de palabras V y NV.pdf`
Un autómata con pruebas de **palabras válidas y no válidas** (aceptación/rechazo).
- `Automatacar/car.py` + `Desarrollo de automata.pdf`
Un autómata aplicado a un “car” (posible simulación de estados de un carro o control).

En términos de arquitectura, esto se parece a:
- **Repo (contenedor)**
- **Proyecto A:** Moore/Mealy script
- **Proyecto B:** Automata1 script + documento de pruebas
- **Proyecto C:** Car automaton script + documento de diseño

##### Qué diagrama conviene: 2 niveles (recomendado)
Para “el mejor y más exacto” diagrama, dibuja **dos diagramas**:

##### Diagrama de contexto del repositorio (alto nivel)
Objetivo: mostrar que el repo es un conjunto de subproyectos independientes.

**Componentes a incluir**
- “Usuario/Estudiante” (actor)
- Cada subproyecto como caja separada:
- `Automata moore-mealy (Automata-moore.py)`
- `Automata1 (automata.py)`
- `Automatacar (car.py)`
- PDFs como “Documentación/Especificación/Pruebas” conectados al script correspondiente.

**Relaciones**
- Usuario ejecuta script → ingresa “palabra/secuencia/eventos” → recibe “acepta/rechaza/salida/simulación”.
- PDFs alimentan el diseño y/o casos de prueba (flecha punteada “referencia”).

Esto deja claro que no hay backend/frontend/db: es **procesamiento local**.

##### Diagrama interno por subproyecto (nivel de detalle)
Objetivo: capturar cómo funciona cada script como sistema (aunque sea un solo archivo).

Como no vemos el contenido de los `.py`, tu diagrama debe reflejar la **arquitectura típica de un autómata**, y tú lo ajustas cuando revises el código:
- Módulo/Script (p.ej. `automata.py`)
- Definición del autómata:
- conjunto de estados `Q`
- alfabeto `Σ`
- estado inicial `q0`
- estados de aceptación `F` (si aplica)
- función de transición `δ`
- (Moore/Mealy) función de salida `λ` o salidas por transición/estado
- Motor de ejecución (runner):
- lee entrada (palabra/secuencia)
- itera símbolos/eventos
- actualiza estado vía `δ`
- produce salida (Mealy/Moore) o decide aceptación (DFA)
- I/O:
- entrada por consola/argumentos/variables
- salida por consola/archivo (si aplica)

En el de `Automatacar`, el “alfabeto” podría ser **eventos** (acelerar/frenar/encender/apagar/cambiar marcha), y la salida podría ser “estado del carro”.

##### Componentes comunes (para los 3)
- **Actor:** Usuario/Estudiante
- **Entrada:** Palabra / Secuencia de símbolos / Eventos
- **Motor de Autómata:** ejecuta transiciones
- **Definición del Autómata:** estados + transiciones (+ salida)
- **Salida:** aceptación/rechazo o secuencia de salida (Moore/Mealy) o “estado simulado”
- **Documentación (PDF):** especificación y pruebas

##### Patrones/diseño a resaltar (aunque sea un script)
Aunque esté en un solo archivo, el diagrama debe separar “responsabilidades” como si fueran módulos:
- **“Declarativo” vs “Ejecutor”**
- Declarativo: tablas/diccionarios de transición, estados, etc.
- Ejecutor: algoritmo que recorre la entrada.
- **Máquina de estados finitos (FSM)** como patrón central.
- Para Moore/Mealy: resalta explícitamente dónde se genera la salida:
- **Moore:** salida depende del estado (λ: Q → O)
- **Mealy:** salida depende de (estado, símbolo) (λ: Q×Σ → O)

##### Tecnologías relevantes
- **Python** como runtime.
- No hay señales de frameworks, BD, red, contenedores. Por lo tanto:
- Diagrama “simple”: ejecución local (Laptop/PC) + scripts.

##### Elementos obligatorios en el diagrama
- **Etiquetas claras**: usa el nombre real del archivo:
- “Automata-moore.py”
- “automata.py”
- “car.py”
- **Flechas direccionales**:
- Entrada → Motor → Salida
- PDFs → (flecha punteada) → Script (como referencia)
- **Código de colores o formas** (mantén una convención)
- Actor (persona): gris
- Scripts/Módulos: azul
- Datos/Entradas/Salidas: verde
- Documentación/PDF: amarillo
- Dependencias “no ejecutables” (PDF) con línea punteada

##### Qué tan “detallado” debe ser aquí
Como pediste “muy detallado” y “separar en tantos componentes como sea posible”, incluso si el código está en un solo `.py`:
- Divide el script en 4–6 cajas internas (Definición FSM, Parser Input, Runner, Output Formatter, Validaciones, etc.).
- Añade los artefactos PDF como nodos del sistema (aunque no se ejecuten).

##### Diagrama 1: Contexto del repositorio
- Nodo: “Repositorio: proyectos de autómatas (Python)”
- Subnodo A: “Automata moore-mealy / Automata-moore.py”
- Doc: (si existiera, si no, omitir)
- Subnodo B: “Automata1 / automata.py”
- Doc: “Pruebas de palabras V y NV.pdf”
- Subnodo C: “Automatacar / car.py”
- Doc: “Desarrollo de automata.pdf”
- Actor “Usuario/Estudiante” con flechas a cada script.

##### Diagrama 2: Interno (ejemplo para Automata1)
- Usuario → [Input: palabra] → [Parser/Validador] → [Motor DFA]
- [Motor DFA] ↔ [Definición δ, Q, Σ, q0, F]
- [Motor DFA] → [Decisión: accept/reject] → Usuario
- “Pruebas de palabras V y NV.pdf” → (punteado) → [Casos de prueba] / [Definición]

Repite una variante para Moore/Mealy:
- Añade caja “Generador de salida λ (Moore/Mealy)” conectada al motor.

##### Qué revisar en el código para “cerrar” la exactitud
Antes de finalizar el diagrama, abre cada `.py` y confirma:
- ¿Entrada por consola (`input()`), por argumentos (`sys.argv`/`argparse`), o hardcoded?
- ¿Transiciones como diccionario, matriz, o if/else?
- ¿Hay clases (p.ej. `Automaton`) o solo funciones?
- ¿Qué salidas produce exactamente (print de estados, salida de Mealy, aceptación final, etc.)?

Con esos detalles, ajustas nombres de cajas y flechas para que el diagrama sea literalmente fiel al proyecto.

Si me pegas el contenido de `Automata-moore.py`, `automata.py` y `car.py`, te puedo proponer el diagrama “final” con componentes exactos (nombres de funciones/clases, tipos de datos usados para δ/λ, y flujos reales de entrada/salida).

## Diagram (Mermaid)

```mermaid
flowchart TD
    %% =========================================================
    %% CONTEXTO: Repositorio educativo con mini-proyectos (Python)
    %% =========================================================

    User["Usuario / Estudiante"]:::actor

    subgraph "Repositorio educativo: proyectos de autómatas (Python)"
        Readme["README (descripción del repositorio)"]:::doc

        subgraph "Subproyecto A: Máquinas Moore / Mealy"
            A_Script["Automata-moore.py (Script)"]:::script
        end

        subgraph "Subproyecto B: Automata1 (aceptación / rechazo)"
            B_Script["automata.py (Script)"]:::script
            B_PDF["Pruebas de palabras V y NV (PDF)"]:::doc
        end

        subgraph "Subproyecto C: Autómata de Carro (simulación / estados)"
            C_Script["car.py (Script)"]:::script
            C_PDF["Desarrollo de automata (PDF)"]:::doc
        end
    end

    User -->|"ejecuta"| A_Script
    User -->|"ejecuta"| B_Script
    User -->|"ejecuta"| C_Script

    B_PDF -.->|"referencia/casos_de_prueba"| B_Script
    C_PDF -.->|"referencia/especificación"| C_Script
    Readme -.->|"describe"| A_Script
    Readme -.->|"describe"| B_Script
    Readme -.->|"describe"| C_Script

    %% =========================================================
    %% DETALLE INTERNO: Arquitectura típica por script (FSM)
    %% =========================================================

    subgraph "Detalle interno A: Automata-moore.py (Moore/Mealy)"
        A_In["Entrada: secuencia de símbolos"]:::data
        A_Parse["Parser / Validador de entrada"]:::module
        A_Def["Definición FSM: Q, Σ, q0, δ, (λ)"]:::module
        A_Run["Motor de ejecución: iteración de transiciones (δ)"]:::engine
        A_OutGen["Generador de salida λ\nMoore: λ(Q→O)\nMealy: λ(Q×Σ→O)"]:::engine
        A_Format["Formateador de salida / impresión"]:::module
        A_Out["Salida: secuencia de salida / estados"]:::data

        A_In -->|"tokeniza/valida"| A_Parse
        A_Parse -->|"entrega_símbolos"| A_Run
        A_Def -->|"provee_δ/λ/estados"| A_Run
        A_Run -->|"produce_salida"| A_OutGen
        A_OutGen -->|"prepara_output"| A_Format
        A_Format -->|"muestra"| A_Out
    end

    User -->|"provee_input"| A_In
    A_Out -->|"resultado_visible"| User

    subgraph "Detalle interno B: Automata1/automata.py (DFA típico)"
        B_In["Entrada: palabra"]:::data
        B_Parse["Parser / Validador de palabra"]:::module
        B_Def["Definición DFA: Q, Σ, q0, δ, F"]:::module
        B_Run["Motor DFA: recorre símbolos y aplica δ"]:::engine
        B_Decide["Decisión final: estado ∈ F"]:::engine
        B_Format["Formateador: acepta/rechaza"]:::module
        B_Out["Salida: aceptación / rechazo"]:::data

        B_In -->|"valida"| B_Parse
        B_Parse -->|"símbolos"| B_Run
        B_Def -->|"provee_δ/estados/F"| B_Run
        B_Run -->|"estado_final"| B_Decide
        B_Decide -->|"decisión"| B_Format
        B_Format -->|"muestra"| B_Out
    end

    User -->|"provee_input"| B_In
    B_Out -->|"resultado_visible"| User
    B_PDF -.->|"guía_de_pruebas"| B_Parse
    B_PDF -.->|"casos_de_prueba"| B_Decide

    subgraph "Detalle interno C: Automatacar/car.py (FSM por eventos)"
        C_In["Entrada: eventos (acelerar/frenar/encender/...)"]:::data
        C_Parse["Parser / Validador de eventos"]:::module
        C_Def["Definición FSM del carro:\nEstados + Eventos + δ"]:::module
        C_Run["Motor FSM: aplica δ por evento"]:::engine
        C_State["Estado simulado / trazas"]:::engine
        C_Format["Formateador: imprime estado y/o log"]:::module
        C_Out["Salida: estado del carro / simulación"]:::data

        C_In -->|"valida"| C_Parse
        C_Parse -->|"eventos"| C_Run
        C_Def -->|"provee_δ/estados"| C_Run
        C_Run -->|"actualiza"| C_State
        C_State -->|"prepara_output"| C_Format
        C_Format -->|"muestra"| C_Out
    end

    User -->|"provee_input"| C_In
    C_Out -->|"resultado_visible"| User
    C_PDF -.->|"referencia_de_diseño"| C_Def

    %% =========================================================
    %% Click events (paths only; not shown in labels)
    %% =========================================================
    click Readme "https://github.com/angel23213/lenguajes-y-aut-matas/blob/main/README.md"
    click A_Script "https://github.com/angel23213/lenguajes-y-aut-matas/blob/main/Automata moore-mealy/Automata-moore.py"
    click B_Script "https://github.com/angel23213/lenguajes-y-aut-matas/blob/main/Automata1/automata.py"
    click B_PDF "https://github.com/angel23213/lenguajes-y-aut-matas/blob/main/Automata1/Pruebas de palabras V y NV.pdf"
    click C_Script "https://github.com/angel23213/lenguajes-y-aut-matas/blob/main/Automatacar/car.py"
    click C_PDF "https://github.com/angel23213/lenguajes-y-aut-matas/blob/main/Automatacar/Desarrollo de automata.pdf"

    %% =========================================================
    %% Styles (color is required)
    %% =========================================================
    classDef actor fill:#E5E7EB,stroke:#374151,stroke-width:1px,color:#111827;
    classDef script fill:#DBEAFE,stroke:#1D4ED8,stroke-width:1px,color:#0B1B3A;
    classDef module fill:#BFDBFE,stroke:#1E40AF,stroke-width:1px,color:#0B1B3A;
    classDef engine fill:#93C5FD,stroke:#1E3A8A,stroke-width:1px,color:#0B1B3A;
    classDef data fill:#DCFCE7,stroke:#166534,stroke-width:1px,color:#052E16;
    classDef doc fill:#FEF9C3,stroke:#A16207,stroke-width:1px,color:#3B2F00;
```
