Cómo usar GaiaBasic

Estado

Instalación

GaiaBasic será un paquete escrito íntegramente en Python (Python 3.10+), con NumPy como única dependencia obligatoria. Los gráficos y los cuadernos son extras opcionales.

# cuando se publique la primera versión
pip install gaiabasic

# hasta entonces, desde el código fuente
git clone https://github.com/manuherran/GaiaBasic
cd GaiaBasic
pip install -e .

Arquitectura

El paquete se divide en módulos pequeños, de modo que cada teoría es un componente independiente y comprobable.

El mundo (World)

Un World lo contiene todo: los elementos, los componentes de teoría y el reloj. Cada una de sus cuatro ranuras (ontología, sintiencia, identidad, física) puede sustituirse de forma independiente.

import gaiabasic as gb

world = gb.World("My world", seed=1, size=(100, 100))
world.ontology  = gb.Dualism(gb.Matter, gb.Experience)
world.sentience = gb.Emergentism(threshold=gb.Complexity(min_neurons=1_000), causal=True)
world.identity  = gb.ClosedIndividualism()

world.describe()   # describe la teoría en lenguaje natural
world.map_code()   # p. ej. "A5-B1-C2-D4-E1-F3-G1-H1-I3"

Elementos

Cada elemento tiene un tipo, una posición (en el espacio, en el espacio de las ideas o en ninguna parte) y atributos. Las experiencias tienen una valencia (de −1, máximo sufrimiento, a +1, máximo placer) y una intensidad.

pain = gb.Experience(valence=-0.8, intensity=3.0, quality="burn")
two  = gb.Idea("number:2")
me   = gb.Identity("frog-17")

world.add(pain, holder=me)          # quién la tiene depende del modelo de identidad
gb.copy(pain, to=gb.Idea)           # trascendencia: copiar una experiencia al espacio de las ideas

Componentes de teoría

Un componente de teoría es una clase con unos pocos puntos de enganche. El mundo los llama en cada paso:

• arises(entity): ¿tiene esta entidad experiencias ahora? ¿Cuáles?
• holder(experience): ¿qué identidad tiene esta experiencia?
• effect(experience, entity): ¿cambia la experiencia lo que hace la entidad? (Las teorías epifenoménicas no devuelven nada).
• cost(experience): ¿cuesta energía tener la experiencia?

Los parámetros comunes se comparten entre modelos, para poder compararlos directamente: causal, threshold, intensity_scale (por ejemplo, según el número de neuronas), valence_model (placer y dolor, solo dolor, solo placer) y p_zombies (posibles o imposibles).

El bucle de simulación

Cada paso de world.run() hace lo siguiente:

1. Física. La materia se actualiza según las reglas físicas del mundo.
2. Percepción. Los organismos perciben su entorno y su propio cuerpo.
3. Experiencia. El modelo de sintiencia decide qué experiencias surgen, y el modelo de identidad las asigna a sujetos.
4. Decisión. Las reglas de comportamiento se disparan, mediante la voluntad y la motivación. Si la experiencia es causal, aquí modifica las probabilidades.
5. Evolución. Los organismos comen, se reproducen, mutan y mueren. La escasez selecciona.
6. Auditoría. Se ejecutan las comprobaciones de coherencia. Cada contradicción se registra, y las graves terminan con el mundo.

Escribir tu propia teoría

Crea una subclase de gb.SentienceModel e implementa los puntos de enganche que necesites. Este ejemplo es una teoría sencilla de «partícula»: la experiencia solo aparece en organismos que contienen un componente especial.

class SoulParticle(gb.SentienceModel):
    """La experiencia requiere una partícula especial unida a tres unidades A seguidas."""

    def arises(self, entity):
        if entity.contains_pattern("AAA") and entity.has(gb.Particle("psi")):
            return [gb.Experience(valence=entity.wellbeing(), intensity=1.0)]
        return []

    def effect(self, experience, entity):
        # interacción dualista: la experiencia desplaza la motivación
        entity.motivation.bias(toward=experience.valence)

world.sentience = SoulParticle()

La partícula es una suposición del modelo, no una afirmación de que tal partícula exista. De eso se trata: GaiaBasic te permite escribir cualquier suposición y ver qué se sigue de ella.

El lenguaje .gaia

No todo el que quiere poner a prueba una teoría escribe Python. GaiaBasic incluye también un pequeño lenguaje de descripción de mundos, fácil de leer, en el espíritu de BASIC. Un archivo .gaia se traduce a los mismos objetos de Python.

WORLD "Frog pond" SEED 42

SUBSTANCE monism OF matter
SENTIENCE emergent WHEN neurons > 10000 CAUSAL no
IDENTITY closed

POPULATE frog 200
POPULATE fly 5000

RUN 50000 STEPS
REPORT coherence, valence_balance, selection("sentience")

gb.run_file("frog_pond.gaia")   # o, desde la terminal:  gaiabasic run frog_pond.gaia

Informes

world.run() devuelve un Report. Los informes de distintos mundos pueden ponerse uno al lado del otro.

report.coherence              # 0.0 – 1.0
report.contradictions         # lista de conflictos entre reglas encontrados
report.valence_balance        # placer total menos sufrimiento total
report.valence_by("species")  # desglosado por especie, por identidad, por tiempo
report.rule_breaks            # comportamiento no previsto por las reglas físicas
report.selection_pressure("sentience")
report.plot()                 # requiere el extra opcional [plot]

gb.compare([report_a, report_b, report_c]).table()

Juegos y torneos

GaiaBasic también está pensado para jugar. Hay dos formatos previstos:

• Juego de construcción de mundos. Los jugadores configuran los parámetros iniciales de un mundo. Los mundos se ejecutan en paralelo. Ganan los mundos coherentes que más duran; los incoherentes se desintegran.
• Torneos dialécticos. Los jugadores (o modelos de IA) defienden a personajes que creen en el monismo, el dualismo, el emergentismo o el epifenomenalismo. Sus afirmaciones se comprueban ejecutando los mundos correspondientes.

Cómo contribuir

Las contribuciones son bienvenidas, tanto de programadores como de filósofos. Una teoría escrita con claridad, con sus suposiciones enumeradas, es tan útil como el código. Abre una incidencia o una discusión en GitHub.