dependent-type-implementer

Name: dependent-type-implementer
Availability: InStock
Author: rainoftime

Implement dependently typed lambda calculus with Pi and Sigma types.

17|2|Updated Feb 16, 2026

Search Tags:#formal verification #lambda calculus #type systems #dependent types #type theory #proof assistants

Ready to run

npx skills add https://github.com/rainoftime/pl-skills --skill dependent-type-implementer

💬 Prompt for ChatGPT / Claude Chat▼

Please help me install this Agent Skill.
Skill: dependent-type-implementer
Source: https://github.com/rainoftime/pl-skills/tree/main/dependent-type-implementer
Command: npx skills add https://github.com/rainoftime/pl-skills --skill dependent-type-implementer

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes references (resource) components.

What problem does it solve?

This Skill addresses the complexity of implementing advanced type systems, specifically dependent types, which are crucial for formal verification and advanced programming language design.

Core Features & Use Cases

Π and Σ Types: Implements dependent function and pair types essential for expressive type theories.
Type Checking & Elaboration: Provides mechanisms for verifying type correctness and converting surface syntax to a core representation.
Use Case: Developing a proof assistant like Coq or Idris, formalizing mathematical theorems, or creating a verified programming language.

Quick Start

Implement the core syntax for dependent types, including Pi and Sigma types, and their associated typing rules.

Frequently Asked Questions about dependent-type-implementer

High-intent search queries and answers about installing and using this skill.

FAQPage Schema

How do I implement type checking for dependent types with Pi and Sigma?▼

Implementing dependent types requires type checking with conversion and unification for Pi and Sigma types. You must handle type correctness by evaluating expressions using normalization by evaluation and de Bruijn indices.

How does proof elaboration from surface to core syntax work in dependent type theory?▼

Proof elaboration in dependent type theory converts high-level surface syntax into a verified core representation. This process relies on normalization by evaluation to ensure type correctness before building proof assistants.

Do I need to understand de Bruijn indices and normalization by evaluation to build advanced type systems?▼

Yes, building advanced type systems with dependent types strictly requires understanding type theory, de Bruijn indices, and normalization by evaluation to successfully implement conversion and unification mechanisms.

What is the best way to start building a proof assistant for formal verification?▼

The best way to build a proof assistant is implementing core syntax for dependent types, including Pi and Sigma types. Start by defining their associated typing rules to support formal verification and verified programming languages.

Can I use lambda calculus to formalize mathematical theorems in a verified programming language?▼

Yes, you can formalize mathematical theorems using dependently typed lambda calculus. By implementing Pi and Sigma types, you achieve expressive type theories necessary for creating verified programming languages.