proof-of-frog

Proof-of-Frog Skill 🐸

16 stars

Best use case

proof-of-frog is best used when you need a repeatable AI agent workflow instead of a one-off prompt.

Proof-of-Frog Skill 🐸

Teams using proof-of-frog should expect a more consistent output, faster repeated execution, less prompt rewriting.

When to use this skill

  • You want a reusable workflow that can be run more than once with consistent structure.

When not to use this skill

  • You only need a quick one-off answer and do not need a reusable workflow.
  • You cannot install or maintain the underlying files, dependencies, or repository context.

Installation

Claude Code / Cursor / Codex

$curl -o ~/.claude/skills/proof-of-frog/SKILL.md --create-dirs "https://raw.githubusercontent.com/plurigrid/asi/main/plugins/asi/skills/proof-of-frog/SKILL.md"

Manual Installation

  1. Download SKILL.md from GitHub
  2. Place it in .claude/skills/proof-of-frog/SKILL.md inside your project
  3. Restart your AI agent β€” it will auto-discover the skill

How proof-of-frog Compares

Feature / Agentproof-of-frogStandard Approach
Platform SupportNot specifiedLimited / Varies
Context Awareness High Baseline
Installation ComplexityUnknownN/A

Frequently Asked Questions

What does this skill do?

Proof-of-Frog Skill 🐸

Where can I find the source code?

You can find the source code on GitHub using the link provided at the top of the page.

SKILL.md Source

# Proof-of-Frog Skill 🐸

**Trit**: 0 (ERGODIC - Coordinator)
**GF(3) Triad**: `proof-chain (-1) βŠ— proof-of-frog (0) βŠ— alife (+1) = 0`

## Overview

Society merge protocol implementing Block Science KOI patterns with frog lifecycle metaphor.

"Eat that frog first thing in the morning" - Brian Tracy

## Frog Lifecycle (GF(3) States)

| Stage | Trit | Role |
|-------|------|------|
| πŸ₯’ TADPOLE | -1 | Learning, absorbing |
| 🐸 FROGLET | 0 | Transitioning, coordinating |
| 🦎 MATURE FROG | +1 | Generating, executing |

## Core Concepts

### Reference IDs (Block Science KOI)
```move
struct ReferenceID {
    local_name: String,      // How THIS society refers to it
    canonical_hash: vector<u8>,  // Universal content hash
    society_origin: address,     // Which pond it came from
}
```

### Knowledge Nugget (The Frog to Eat)
```move
struct KnowledgeNugget {
    rid: ReferenceID,
    trit: i8,           // GF(3) lifecycle stage
    eaten: bool,        // Has this frog been eaten?
    leap_count: u64,    // How many hops to get here
}
```

### Society Merge
Two ponds can merge when:
1. Both are GF(3) balanced
2. Shared RIDs exist (common reference points)
3. Ribbit votes reach quorum

## Usage

```bash
# Deploy society merge
aptos move publish --named-addresses zubyul=default

# Initialize pond
aptos move run --function-id zubyul::proof_of_frog::spawn_pond

# Eat a frog (process knowledge)
aptos move run --function-id zubyul::proof_of_frog::eat_frog --args u64:0

# Propose merger
aptos move run --function-id zubyul::proof_of_frog::propose_merge --args u64:0 u64:1
```

## WEV Comparison

| System | WEV Formula | Result |
|--------|-------------|--------|
| Legacy | V - 0.5V - costs | 0.4V |
| GF(3) | V + 0.1V - 0.01 | 1.09V |
| **Advantage** | | **2.7x** |

## Frog Puns

- "Hop to it!" - Start processing
- "Toadally awesome!" - Merge complete
- "Ribbit-ing progress!" - Verification passed
- "Leap of faith!" - Cross-world navigation
- "Pond-ering success!" - Knowledge integrated

## Neighbors

### High Affinity
- `proof-chain` (-1): ZK proof chaining
- `alife` (+1): Emergent behavior
- `world-hopping` (0): Cross-world navigation

### Example Triad
```yaml
skills: [proof-of-frog, proof-chain, alife]
sum: (0) + (-1) + (+1) = 0 βœ“ TOADALLY BALANCED
```

## References

- [Block Science KOI](https://blog.block.science/a-language-for-knowledge-networks/) - @maboroz @ilanbenmeir
- [LPSCRYPT proof_chain](https://github.com/LPSCRYPT/proof_chain) - @lpscrypt
- Brian Tracy - "Eat That Frog!" (productivity)



## Scientific Skill Interleaving

This skill connects to the K-Dense-AI/claude-scientific-skills ecosystem:

### Graph Theory
- **networkx** [β—‹] via bicomodule
  - Universal graph hub

### Bibliography References

- `cryptography`: 1 citations in bib.duckdb

## Cat# Integration

This skill maps to **Cat# = Comod(P)** as a bicomodule in the equipment structure:

```
Trit: 0 (ERGODIC)
Home: Prof
Poly Op: βŠ—
Kan Role: Adj
Color: #26D826
```

### GF(3) Naturality

The skill participates in triads satisfying:
```
(-1) + (0) + (+1) ≑ 0 (mod 3)
```

This ensures compositional coherence in the Cat# equipment structure.

Related Skills

wycheproof

16
from plurigrid/asi

Google's Wycheproof test vectors for cryptographic implementation testing.

paperproof-validator

16
from plurigrid/asi

Formal Proof Visualization and Verification for Lean 4

narya-proofs

16
from plurigrid/asi

Mechanically verified proofs from Narya event logs. Verifies queue consistency, replay determinism, non-leakage, and GF(3) conservation. Use for proving system invariants, audit trails, or formal verification of event-sourced systems.

merkle-proof-validation

16
from plurigrid/asi

Merkle Proof Validation Skill

lean-proof-walk

16
from plurigrid/asi

GF(3)-balanced random walk through Lean proof states. Use when generating formal proof chains with parallel triad verification. Invokes 3 agents (Generator +1, Coordinator 0, Validator -1) to traverse proof space via prime geodesics.

implementing-zero-knowledge-proof-for-authentication

16
from plurigrid/asi

Zero-Knowledge Proofs (ZKPs) allow a prover to demonstrate knowledge of a secret (such as a password or private key) without revealing the secret itself. This skill implements the Schnorr identificati

implementing-proofpoint-email-security-gateway

16
from plurigrid/asi

Deploy and configure Proofpoint Email Protection as a secure email gateway to detect and block phishing, malware, BEC, and spam before messages reach user inboxes.

implementing-email-sandboxing-with-proofpoint

16
from plurigrid/asi

Email sandboxing detonates suspicious attachments and URLs in isolated environments to detect zero-day malware and evasive phishing payloads. Proofpoint Targeted Attack Protection (TAP) is an industry

proofgeneral-narya

16
from plurigrid/asi

Proof General + Narya: Higher-dimensional type theory proof assistant with observational bridge types for version control.

zx-calculus

16
from plurigrid/asi

Coecke's ZX-calculus for quantum circuit reasoning via string diagrams with Z-spiders (green) and X-spiders (red)

zulip-cogen

16
from plurigrid/asi

Zulip Cogen Skill 🐸⚑

zls-integration

16
from plurigrid/asi

zls-integration skill