Eta-conversion is sometimes called “weak extensionality” while “ext” is called “strong extensionality”. To my knowledge, Zhaohui Luo uses this terminology in his thesis of ECC.

>Proof irrelevence doesn’t appear necessary, AC and extensional equality seem to suffice.

If I don’t overlook the axiom ExtAC you defined, this is equivalent to the one introduced in the article “100 years of Zermelo’s axiom of choice: what was the problem with it?” by Martin-Löf. According to this, the variant of AC which is used here can be proved without any postulate, but the ExtAC cannot. Furthermore, the excluded middle is implied by ExtAC according to Diaconescu’s theorem and the constructive type theory with ExtAC (W-operation, and an universe) could interprete all of ZFC.

They are two different variants of axiom of choice, so are their strengths. Thus, that might be the reason that constructive AC and extensional equality are not strong enough to prove the law of excluded middle ?

Proof irrelevence doesn’t appear necessary, AC and extensional equality seem to suffice. Some Agda code which might be relevant: http://www.mdstud.chalmers.se/~danko/

Yes, it has a type called Prop and a proof-irrelevant option, but they don’t work by now as far as I know. Maybe things are changed ?

> By the way, since you appear to be a Coq user… :) “Proof irrelevance” seems to mean something different in Coq. My impression is that it just means that the computational portion of a program cannot inspect the inside of a Prop. Is it so?
Coq implements every aspect of proof irrelevence except the one I really want. I mean it is prepared for it but it doesn’t allow values of sort Prop to be convertible (only beta conversion and so on).
The main thing about it is that you can’t pattern match (eliminate) on Prop to produce an object in Set (unless that object in Set has zero or one constructors). It’s exactly what I used to prove _|_, but I think your proof did not make any uses of that. I guess Agda has Prop as well now, but I didn’t know how to use it…

Thanks for the reply!

Thanks for the comment. You illustrated a tricky bit using a shorter example. There are two proofs for TT ∨ TT: inj₁ tt and inj₂ tt. The irr postulate claims that we can see them as if they are equal (indeed, test-3 : inj₁ tt ≅ inj₂ tt). However, in Agda nothing stops you from inspecting and discriminating them (like in which), which allows you to prove X ≅ Y.

As far as I know, in OTT it is a rule that one cannot inspect proofs (things having type † A) like which did (I cannot recall how it is enforced). Therefore they may have irr (in fact irr is provable). The construction given by SEP and Werner, which I showed in the post, was perhaps interesting in that they showed even if we are not allowed to inspect proofs, there is still a way to get around that and extract some evil information. To prevent that, OTT does not have disjunction either.

Also, if I remember right, extensional equality for functions in OTT refers to something like the ext rule: functions are considered equal if they map equal inputs to equal results. Inconsistency is avoided by the mechanism I mentioned above. But I may not be the best person to answer that… :)

By the way, since you appear to be a Coq user… :) “Proof irrelevance” seems to mean something different in Coq. My impression is that it just means that the computational portion of a program cannot inspect the inside of a Prop. Is it so?

I think that this irr postulate is inconsistent:

postulate irr : ∀ {A} (P Q : † A) → (p : ⌈ P ⌉)(q : ⌈ Q ⌉) → (P ≡ Q) → p ≅ q

test-1 : ∀ {A} (P Q : † A) -> _
test-1 P Q = irr ((P ∧ Q) ⇒ (P ∨ Q)) ((P ∧ Q) ⇒ (P ∨ Q))
                     (\pq -> inj₁ (proj₁ pq)) (\pq -> inj₂ (proj₂ pq)) refl

test-2 : (\(pq : ⊤ × ⊤) -> inj₁ (proj₁ pq)) ≅ (\pq -> inj₂ (proj₂ pq))
test-2 = test-1 {⊤} TT TT

use : ∀ {A B : Set} {f g : A -> B} -> f ≅ g -> ∀ x -> f x ≅ g x
use refl = \_ -> refl

use' : ∀ {A B : Set} {x y : A} -> x ≅ y -> ∀ (f : A -> B) -> f x ≅ f y
use' refl = \_ -> refl

test-3 = use test-2 ( tt , tt )

data XY : Set where
 X : XY
 Y : XY

discr : X ≅ Y -> ⊥
discr ()

which :  ∀ {A B} -> (A ⊎ B) -> XY
which (inj₁ _) = X
which (inj₂ _) = Y

test-4 = use' test-3 which

inconsist : ⊥
inconsist = discr test-4

I am not 100% sure if this was intended or not though?
Also I have a question about OTT, I think there are two kinds of ‘extensional equality’ one being eta-conversion and the other being the ext postulate you used. Maybe this distinction is why OTT is still consistent?