Typechecking is undecidable when 'type' is a type (1989) [pdf]

https://dspace.mit.edu/bitstream/handle/1721.1/149366/MIT-LCS-TR-458.pdf?sequence=6

by zem • 6 months ago

82 52 6 months ago

dspace.mit.edu

Animats• 6 months ago

This sounds close to Russell's "class of all classes" paradox. Is it?

enricozb2• 6 months ago

Yes the type theoretic analog to Russel's (set theoretic) paradox is Girard's (as mentioned in the abstract) paradox.

srcreigh• 6 months ago

This is incorrect. The set paradox it’s analogous to is the inability to make the set of all ordinals. Russel’s paradox is the inability to make the set of all sets.

hackandthink• 6 months ago

It is Burali-Forti 1897, predating Russel's paradox.

cwmoore• 6 months ago

Similar to the difficulty in finding Title Search companies on Indeed.

marcosdumay• 6 months ago

Hum... I'm getting 403, forbiden. Is it down?

zem• 6 months ago

still working for me

rerdavies5• 6 months ago

Working for me, but very very slow to load (which I assume is most of the way to 403).

moomin• 6 months ago

It feels like this is unsurprising, given we already have Goedel's theorems and halting theorems. Any system of self-describing complexity ends up in this territory.

randomNumber7• 6 months ago

And still this type system could be the base for a very interesting and powerfull programming language imo.

amelius• 6 months ago

Yeah we don't throw programming languages away because they are undecidable.

So why would we throw type systems away if they are undecidable?

ChadNauseam• 6 months ago

Decidability isn't even that useful. If typechecking takes a million years, that's also bad. What you want is guarantees that correct programs typecheck quickly. Without this, you end up in swift land, where you can write correct code that can't be typechecked quickly and the compiler has to choose between being slow or rejecting your code

BalinKing• 6 months ago

My 2¢ from an interactive theorem proving perspective: In so-called computational type theory, typechecking is indeed allowed to be undecidable, and you get a lot of cool expressive power (e.g. well-behaved quotients and subtypes) as a result. This was one of the big ideas behind NuPRL back in the day, and Istari[0] more recently.

[0] www.istarilogic.org

rerdavies5• 6 months ago

Presumably with the rather unpleasant side-effect of compiles that may never finish. :-P

lmm7• 6 months ago

Yes, but all practical programming languages have that problem anyway, in practice if not in theory.

solomonb• 6 months ago

This really isn't a big deal as it resolved via type universes.

noosphr5• 6 months ago

Type systems aren't magic. They do stop all incorrect programs from running, but also the majority of correct programs too.

anon291• 6 months ago

Luckily most everyday programs are typeable.

noosphr5• 6 months ago

And you don't need cut in logic either: https://philpapers.org/rec/BOODEC

It's just that your typeable program might take more data to store than there are bits in the universe.

I'm not saying that types are bad. They aren't.

I'm saying they aren't magic and they come with a trade off.

rerdavies5• 6 months ago

... for some spectactularly inconsistent and arbitrary definition of "correct program".

noosphr5• 6 months ago

Yes, like giving the correct result for every possible input.

rerdavies5• 6 months ago

Not getting it. Why would you want to do this? And why is no distinction made between `typeof(type)` and `type`? And doesn't the entire problem go away if you distinguish between `typeof(type)`, which is a value whose type is `type`?

lmm7• 6 months ago

Why would you want to do this?

It makes life much easier when you want to use fancier types. E.g. if you want to be able to have ListOfLength[4], it's much nicer to be able to use normal 4 which you can use normal arithmetic on (and therefore say that when you append ListOfLength[x] to ListOfLength[y] you get ListOfLength[x + y]), than to have to encode everything in types and make it some kind of ListOfLength[SpecialTypeLevel4] (and then when you append the two lists you get a ListOfLength[TypeLevelAdditionIsCommutative[TypeLevelAdd[x, y]]#Result] or something).

To make that work you have to be able to use values as type parameters, i.e. types, so you have to be able to have e.g. types of type int, as well as types of type type, and it all gets a lot simpler and easier to work with if you just say that types have type type.

And why is no distinction made between `typeof(type)` and `type`?

Well that's the whole point, to say that type is of type type.

And doesn't the entire problem go away if you distinguish between `typeof(type)`, which is a value whose type is `type`?

No, because why would you ever use it as a value? The whole point of typeof is that it gives you a type that you can use as a type.

pvillano2• 6 months ago

This stack exchange answer talks about the importance of decidability in type checking

https://langdev.stackexchange.com/a/2072

My interpretation

Decidability is of academic interest, and might be a hint if something is feasible.

But there are (1) ways of sidestepping undecidability, e.g. A valid C++/Rust program is one for which the typechecker terminates in x steps without overflowing the stack

And (2) things which are decidable, but physically impossible to calculate, e.g the last digit of the 10^10^10 th prime

What matters is being able to reject all incorrect programs, and accept most human written valid programs

penteract3• 6 months ago

Decidability of a type system is like well-typedness of a program. It doesn't guarantee it's sensible, but not having the property is an indicator of problems.

kingstnap• 6 months ago

I'm not entirely smart enough to connect all of these things together but I think there is a kind of subtlety here thats being stepped on.

1. Complete, Decidable, Well founded are all distinct things.

2. Zig (which allows types to be types) is Turing complete at compile time regardless. So the compiler isn't guaranteed to halt regardless and it doesn't practically matter.

3. The existance of a set x contains x is not enough by itself to create a paradox and prove false. All it does is violate the axiom of foundation, not create a russles paradox.

4. The axiom of foundation is a weird sort of arbitrariness in that it implies this sort of DAG nature to all sets under set membership operation.

5. This isn't nessesarily some axiomatically self evident fact. Aczel's anti foundation axiom works as well and you can make arbitrary sets with weird memberships if you adopt that. https://en.wikipedia.org/wiki/Aczel%27s_anti-foundation_axio...

6. The Axiom of Foundation exists to stop you from making weird cycles, but there is parallel to the axiom of choice, which directly asserts the existance of non computable sets using a non algorithmicly realizable oracle anyway....

pvillano2• 6 months ago

But like, of all the expressive power vs analyzability trade-offs you can make, there's a huge leap in expressive power when you give away decidability.

Undecidability is not a sign that the foundation has cracks (not well founded), but it might be a sign that you put the foundation on wheels so you can drive it at highway speeds, with all the dangers that entails.

It's not a trade everyone would make, but the languages I prefer do.

jeberle• 6 months ago

Does Rice's theorem cover this?

[ all non-trivial semantic properties of programs are undecidable ]

https://en.wikipedia.org/wiki/Rice's_theorem

Found here:

From Sumatra to Panama, from Babylon to Valhalla

https://www.youtube.com/watch?v=bE1bRbZzQ_k&t=48m27s

penteract3• 6 months ago

No. Being well typed is not a semantic property of of a program - in a language where it makes sense to talk about running badly typed code, a piece of code that starts with an infinite loop may be well or badly typed after that point with no observable difference in program behaviour.

There are decidable type systems for Turing complete languages (many try to have this property), and there are languages in which all well typed programs terminate for which type checking is undecidable (System F without all type annotations).

da_chicken2• 6 months ago

This seems strange to me, but it's hours past my bed time and I haven't tried reading lambda calculus or lambda-star calculus theory in about 20 years.

Many programming languages have a variant or object type. In C#, any instance of a class will also say that it is of type System.Object. That does nearly make that a type of all types.

There is some nuance and special cases. Like any null is considered a null instance of any nullable object, but you're also not permitted to ask a null value what type it is. It just is a null. Similarly, C# does differentiate between a class and an instance of a class. Both a class and an instance are of a given type, but a class is not an instance of a class.

Presumably the difference is either in one of those nuances, or else in some other axiomatic assertion in the language design that this paper is not making.

Or else I'm very much missing what the author is driving at, which at this time of the morning seems equally possible.

lalaithion• 6 months ago

System.Object is a type of all objects, NOT a type of all types. That is, all objects are System.Object. If one has a class Foo, then every object of type Foo is also of type System.Object. But what is the type of Foo itself? Not of an instance of Foo, but Foo itself. In the languages this paper is about, the type system can recurse upon itself, allowing types themselves to have type. It’s sort of like C#’s System.Type, except System.Type is a class that holds type information for runtime type inspection, whereas the type of types in this paper is for compile-time generics that can abstract over not just types but the types of types as well.

magicalhippo• 6 months ago

Similarly, C# does differentiate between a class and an instance of a class. Both a class and an instance are of a given type, but a class is not an instance of a class.

Incidentally one of the things I missed from Delphi in C#. In Delphi you can declare

  type TWidgetClass = class of TWidget;

Then you can declare variables of TWidgetClass, and assign TWidget or any subclass to such variables, and call class methods using it, like say the constructor.

  var widgetClass := TTextWidget;
  var myWidget := widgetClass.Create();

After which myWidget holds and instance of TTextWidget. Very handy for factory pattern code, but also other stuff. Of course after C# got generics it alleviated some of this.

lmm7• 6 months ago

Many programming languages have a variant or object type. In C#, any instance of a class will also say that it is of type System.Object. That does nearly make that a type of all types.

That's a type of all values, not a type of all types.

In richer programming languages, you can do operations on types much like you can do operations on values. E.g. in C# you can write "List<String>", but you can't do something like "var x = List; var y = String; x<y>". (Which might seem pointless, but it allows you to do things like write a conversion from x<Int> to x<String> that you can reuse with different x types). So then you need a type for x and y, which is conventionally type, and you have to ask what the type of type is. (And if it's type, then that's very natural and makes some things very easy - but at the cost of making typechecking undecidable, as per the article).

da_chicken2• 6 months ago

No, it's not that. You can actually do those things in C#.

You just can't do them at compile time. You have to use introspection or the dynamic keyword and do it at runtime.

In order to do what you're suggesting at compile time, you'd need a type of types, and then you'll run into the decidability paradox.

Typechecking is undecidable when 'type' is a type (1989) [pdf]

Related Stories