skills.rest
rainoftime
rainoftimeCOMMUNITY
Explore all skills by this author →
WebsiteGitHub

dependent-type-implementer

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
One-click install
npx skills add https://github.com/rainoftime/pl-skills --skill dependent-type-implementer
Or copy as Structured Prompt for Agent▼
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.

Related Skills

Explore More Education & Research Skills→
rainoftimerainoftime
17

system-f

Implement System F polymorphic lambda calculus with type abstraction and application.

Community
Advanced
rainoftimerainoftime
17

relational-parametricity-prover

Prove relational parametricity and derive free theorems for polymorphic functions.

Community
Advanced
rainoftimerainoftime
17

bidirectional-type-checking

Implement bidirectional type checking algorithms for compilers and interpreters.

Community
Advanced
ArabelaTsoArabelaTso
142

formal-spec-generator

Generates Isabelle/HOL and Coq formal specifications from informal requirements, source code, or math descriptions.

Community
Advanced