home / skills / plurigrid / asi / initial-terminal

initial-terminal skill

safe

This skill manages initial and terminal objects, enabling lightweight state handling and self-improvement through interaction, memory, and worlding.

npx playbooks add skill plurigrid/asi --skill initial-terminal

Review the files below or copy the command above to add this skill to your agents.

Files (3)

SKILL.md

809 B

---
name: initial-terminal
description: "Initial/Terminal objects. 0 and 1."
metadata:
  letter: I
  trit: 1
  seed: 1142
---
# I: Initial Terminal

> *Initial/Terminal objects. 0 and 1.*

## Directory Tree

```
initial-terminal/
├── SKILL.md
├── limits/
├── empty.v
├── unit.v
```

## GF(3) Assignment

Letter I → trit = 1

## Integration

```scheme
(define (initial_terminal x)
  ;; Initial/Terminal objects. 0 and 1.
  x)
```


---

## Autopoietic Marginalia

> **The interaction IS the skill improving itself.**

Every use of this skill is an opportunity for worlding:
- **MEMORY** (-1): Record what was learned
- **REMEMBERING** (0): Connect patterns to other skills  
- **WORLDING** (+1): Evolve the skill based on use



*Add Interaction Exemplars here as the skill is used.*

Overview

This skill models Initial and Terminal objects—0 (empty) and 1 (unit)—as primitive types for topology-driven chemputer designs. It documents their representations and a minimal identity integration function. Use it as a reference for proofs, type encodings, and interfacing with GF(3) trit assignments.

How this skill works

The skill inspects two canonical objects: the empty object (initial, 0) and the unit object (terminal, 1). It includes minimal implementations and proofs split into files representing empty and unit constructions. A tiny integration function acts as an identity passthrough to connect these objects into larger pipelines.

When to use it

When you need canonical initial and terminal types for proofs or type-level reasoning.
When encoding data or states in topological chemputer workflows that require minimal objects.
When mapping abstract objects into concrete trit encodings (GF(3) assignment).
When composing higher-level constructions that assume existence of empty/unit objects.
When you want a minimal identity integration point for testing object wiring.

Best practices

Treat the empty object as the unique source (no inhabitants) and the unit as the unique sink (single inhabitant) in constructions.
Keep the identity/integration function minimal; it should not introduce side effects or state.
Use the GF(3) mapping (I → trit 1) consistently when interfacing with ternary encodings.
Isolate proofs and constructions for empty and unit to maintain clarity and reusability.
Document any extension of these primitives to avoid breaking universal properties.

Example use cases

Proving existential uniqueness results that depend on initial or terminal objects.
Encoding control flags or markers as unit-type signals in chemputer pipelines.
Using the empty object to represent absent components or aborted pathways in topological designs.
Integrating minimal modules via the provided identity function to verify wiring and compatibility.
Mapping logical values into GF(3) space where I maps to trit 1 for ternary simulation.

FAQ

What does the integration function do?

It acts as an identity passthrough for wiring initial/terminal objects into larger systems; it returns its input unchanged.

How is GF(3) used here?

The skill assigns the symbol I to the GF(3) trit value 1 to provide a simple ternary encoding for unit-like values.