λProlog: Logic programming in higher-order logic - The World's First Language with Native Higher-Order Abstract Syntax

λProlog is a logic programming language based on higher-order intuitionistic logic that pioneered direct support for higher-order abstract syntax in the late 1980s. Developed by Dale Miller and Gopalan Nadathur, it extends Prolog with lambda terms, modular programming, and sophisticated type systems for reasoning about syntax with bindings. This curated collection provides essential resources for understanding and working with this influential language.

Overview

λProlog represents a significant evolution in logic programming, building on Church's Simple Theory of Types to provide a solid logical foundation. Unlike traditional Prolog, λProlog offers polymorphic typing, higher-order unification, and lambda-tree syntax—an approach that maps object-level bindings to programming language bindings, eliminating the need to manage bound variable names explicitly. The language remains actively developed through multiple implementations including ELPI, Teyjus, and Makam, with recent updates as of December 2025.

Top Recommended Resources

1. λProlog: Logic programming in higher-order logic - LIX

• Comprehensive overview of all three active implementations (ELPI 3.4.5, Teyjus 2.1.1, and Makam) with links to documentation and downloads
• Historical context tracing λProlog's origins to the late 1980s and its status as the world's first language to support higher-order abstract syntax directly
• Curated learning materials including the authoritative 2012 textbook by Miller and Nadathur, video tutorials, and course materials spanning decades of teaching experience
• Information about related tools like Abella, an interactive theorem prover with native λ-tree syntax support
• Last updated December 2025, ensuring current and relevant information

2. Teyjus

• Efficient virtual machine design leveraging pattern unification techniques for high-performance execution
• Complete development environment with downloadable source code, comprehensive user manual, and active issue tracking
• Support for lambda terms as data representation with logical primitives for probing term structures
• Extensive use of higher-order unification, making it suitable for applications requiring complex term manipulation
• Recommended companion textbook "Programming with Higher-Order Logic" provides structured learning path
• NSF-funded development (grant CCF-0429572) indicating academic rigor and ongoing support

3. Examples of Lambda Prolog code - Teyjus

• Four major example categories: formula manipulation, program manipulation, interactive theorem proving, and logic programming language implementations
• Examples drawn from authoritative sources including the "Higher-Order Logic Programming" textbook and research by Amy Felty and Jeff Polakow
• Demonstrates advanced features like ordered linear logic programming and theorem-proving tactics in real implementations
• Emphasizes the use of the Teyjus version specifically, ensuring compatibility and practical applicability
• Actively solicits community contributions, indicating an engaged user base and evolving resource

4. Programming with Higher-Order Logic - Brief description

• Clear exposition of foundational concepts including sequent calculus-based frameworks, proof search methodology, and polymorphic type systems
• Focus on practical applications, particularly "computations that manipulate bindings in syntax"—a core use case for λProlog
• Extended examples addressing proof system implementation, functional program computation, and π-calculus encoding
• Direct links to experimentation tools (Teyjus compiler and ELPI interpreter) enabling readers to try concepts immediately
• Supplementary sections on reviews, errata, table of contents, and related resources for comprehensive understanding

5. PLE lecture notes -- Lambda-Prolog

• Systematic coverage of the three major distinguishing features: static type-checking with partial inference, support for lambda abstractions with unification, and local declarations using implication and quantification
• Detailed explanation of unification mechanics with extensive examples showing how bidirectional pattern-matching works
• Clarification of predicates as relations rather than functions, enabling multi-directional usage—a concept that often confuses newcomers
• Type system comparison with Haskell while highlighting support for type-functions
• Critical perspective on Prolog's "logical ideology," arguing that unification complements rather than opposes functional programming—helpful for understanding the broader context

Summary

These five resources provide a complete learning path for λProlog, from theoretical foundations to practical implementation. Start with the official homepage and lecture notes to understand what makes λProlog unique, then dive into Teyjus for hands-on experimentation with the code examples. The book website offers deeper theoretical grounding when you're ready to explore advanced applications. Together, these resources represent decades of research and teaching by the language's creators and their collaborators, making them the definitive references for anyone serious about higher-order logic programming.