A framework for defining logics
Journal of the ACM (JACM)
Proceedings of the 24th ACM SIGPLAN-SIGACT symposium on Principles of programming languages
Mode and Termination Checking for Higher-Order Logic Programs
ESOP '96 Proceedings of the 6th European Symposium on Programming Languages and Systems
System Description: Twelf - A Meta-Logical Framework for Deductive Systems
CADE-16 Proceedings of the 16th International Conference on Automated Deduction: Automated Deduction
Verifying Termination and Reduction Properties about Higher-Order Logic Programs
Journal of Automated Reasoning
Tabled higher-order logic programming
Tabled higher-order logic programming
Proceedings of the 35th annual ACM SIGPLAN-SIGACT symposium on Principles of programming languages
Two-Level Hybrid: A System for Reasoning Using Higher-Order Abstract Syntax
Electronic Notes in Theoretical Computer Science (ENTCS)
Programming with proofs and explicit contexts
Proceedings of the 10th international ACM SIGPLAN conference on Principles and practice of declarative programming
The Abella Interactive Theorem Prover (System Description)
IJCAR '08 Proceedings of the 4th international joint conference on Automated Reasoning
System Description: Delphin -- A Functional Programming Language for Deductive Systems
Electronic Notes in Theoretical Computer Science (ENTCS)
Case Analysis of Higher-Order Data
Electronic Notes in Theoretical Computer Science (ENTCS)
Programming inductive proofs: a new approach based on contextual types
Verification, induction termination analysis
Programming inductive proofs: a new approach based on contextual types
Verification, induction termination analysis
Higher-order dynamic pattern unification for dependent types and records
TLCA'11 Proceedings of the 10th international conference on Typed lambda calculi and applications
Proceedings of the 16th ACM SIGPLAN international conference on Functional programming
Programming with binders and indexed data-types
POPL '12 Proceedings of the 39th annual ACM SIGPLAN-SIGACT symposium on Principles of programming languages
Reasoning with higher-order abstract syntax and contexts: a comparison
ITP'10 Proceedings of the First international conference on Interactive Theorem Proving
LFP: a logical framework with external predicates
Proceedings of the seventh international workshop on Logical frameworks and meta-languages, theory and practice
Compiling contextual objects: bringing higher-order abstract syntax to programmers
PLPV '13 Proceedings of the 7th workshop on Programming languages meets program verification
Proof pearl: abella formalization of λ-calculus cube property
CPP'12 Proceedings of the Second international conference on Certified Programs and Proofs
First-class substitutions in contextual type theory
Proceedings of the Eighth ACM SIGPLAN international workshop on Logical frameworks & meta-languages: theory & practice
25 years of formal proof cultures: some problems, some philosophy, bright future
Proceedings of the Eighth ACM SIGPLAN international workshop on Logical frameworks & meta-languages: theory & practice
Reasoning about higher-order relational specifications
Proceedings of the 15th Symposium on Principles and Practice of Declarative Programming
Hi-index | 0.00 |
Beluga is an environment for programming and reasoning about formal systems given by axioms and inference rules. It implements the logical framework LF for specifying and prototyping formal systems via higher-order abstract syntax. It also supports reasoning: the user implements inductive proofs about formal systems as dependently typed recursive functions. A distinctive feature of Beluga is that it not only represents binders using higher-order abstract syntax, but directly supports reasoning with contexts. Contextual objects represent hypothetical and parametric derivations, leading to compact and elegant proofs. Our test suite includes standard examples such as the Church-Rosser theorem, type uniqueness, proofs about compiler transformations, and preservation and progress for various ML-like languages. We also implemented proofs of structural properties of expressions and paths in expressions. Stating these properties requires nesting of quantifiers and implications, demonstrating the expressive power of Beluga.