Skip to content
Iowa Type Theory Commute cover art

All episodes

Iowa Type Theory Commute, 192 episodes. Page 2 of 2.

#
Title
101

Normal terms are typable with intersection types

102

Intersection Types Preserved Under Beta-Expansion

103

Introduction to Intersection Types

104

Deriving disjointness of constructor ranges in RelTT

105

Software Design and Intrinsic Identity

106

Identity Inclusion in Relational Type Theory

107

On the paper "The Girard-Reynolds Isomorphism" by Philip Wadler

108

Equivalence of inductive and parametric naturals in RelTT

109

Examples in Relational Type Theory

110

The Semantics of Relational Types

111

The Types of Relational Type Theory

112

Introducing Relational Type Theory

113

On the paper "Types, Abstraction, and Parametric Polymorphism"

114

Parametric models and representation independence

115

Explaining my encoding of a HOAS datatype, part 2

116

Explaining my encoding of a HOAS datatype, part 1

117

Term models for higher-order signatures

118

Lambda applicative structures and interpretations of lambda abstractions

119

The Basic Lemma

120

Logical relations are not closed under composition

121

The definition of a logical relation

122

Introduction to Logical Relations

123

Lamping's abstract algorithm

124

Examples showing non-optimality of Haskell

125

Lambda graphs with duplicators and start of Lamping's abstract algorithm

126

Duplicating redexes as the central problem of optimal reduction

127

Introduction to optimal beta reduction

128

Lexicographic termination

129

Mendler-style iteration

130

Well-founded recursion

131

Compositional termination checking with sized types

132

Noncompositionality of syntactic structural-recursion checks

133

Structural termination

134

Proving Confluence for Untyped Lambda Calculus II

135

Proving Confluence for Untyped Lambda Calculus I

136

Confluence, and its use for conversion checking

137

Normalization and logical consistency

138

Normalization in type theory: where it is needed, and where not

139

Introduction to normalization

140

Proving type safety; upcoming metatheoretic properties

141

The progress property and the problem of axioms in type theory

142

Introduction to type safety

143

Introduction to metatheory

144

Definition of the Mendler encoding

145

The Mendler encoding and the problem of explicit recursion

146

The Scott encoding

147

More on the Parigot encoding

148

Introduction to the Parigot encoding

149

Church-encoding natural numbers

150

Church encoding of lists

151

Church encoding of the booleans

152

Introduction to Church encoding

153

Functional encodings turning the world inside out

154

More benefits of lambda encodings

155

Introduction to lambda encodings

156

Adding a top type and allowing non-normalizing terms

157

Intersection types using Curry-style typing

158

Curry-style versus Church-style, and the nature of type annotations

159

More on Computation First, and Basic Idea of Realizability

160

Types should be erased for executing and reasoning about programs

161

Why go beyond GADTs?

162

GADTs for programming with representations of types

163

Using GADTs for typed subsetting of your language

164

Example of programming with indexed types: binary search trees

165

Programming with indexed types using singletons

166

Limitations of indexed types that are not truly dependent

167

Programming with Indexed Types

168

Program Termination and the Curry-Howard Isomorphism

169

Why Curry-Howard for classical proofs is a bad idea for programming

170

Curry-Howard for classical logic

171

Dependent types and design by contract

172

Indexed types and Curry-Howard for first-order quantifiers

173

The Curry-Howard Isomorphism for Propositional Logic

174

The Curry-Howard Isomorphism for Induction

175

Constructive proofs as programs

176

Introduction to the Curry-Howard Isomorphism

177

Functors and catamorphisms

178

Structured Recursion Schemes for Point-Free Recursion

179

More on point-free programming and category theory

180

Point-free programming and category theory

181

Concise code through point-free programming

182

More on FP and concise code

183

Functional Programming and Concise Code: Type Inference

184

Introduction to Functional Programming

185

Software Engineering Considerations for Formal Methods

186

Power of Computer-Checked Proofs for Software

187

Technical reasons for lack of adoption of computer-checked proofs

188

Why Computer-Checked Proofs are Not Used More in Mathematics

189

Computer-Checked Proofs in American Research

190

Computer-checked proofs about software

191

More on Computer-Checked Proofs

192

Computer-checked proofs