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
Manual Installation
- Download SKILL.md from GitHub
- Place it in
.claude/skills/proof-of-frog/SKILL.mdinside your project - Restart your AI agent β it will auto-discover the skill
How proof-of-frog Compares
| Feature / Agent | proof-of-frog | Standard Approach |
|---|---|---|
| Platform Support | Not specified | Limited / Varies |
| Context Awareness | High | Baseline |
| Installation Complexity | Unknown | N/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
Google's Wycheproof test vectors for cryptographic implementation testing.
paperproof-validator
Formal Proof Visualization and Verification for Lean 4
narya-proofs
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
Merkle Proof Validation Skill
lean-proof-walk
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
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
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
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
Proof General + Narya: Higher-dimensional type theory proof assistant with observational bridge types for version control.
zx-calculus
Coecke's ZX-calculus for quantum circuit reasoning via string diagrams with Z-spiders (green) and X-spiders (red)
zulip-cogen
Zulip Cogen Skill πΈβ‘
zls-integration
zls-integration skill