hott | Global hotkeys for Windows , with node

I am not completely sure, but it seems to me that what you are trying to prove is no different from forall a (p:a=a), p = eq_refl. If so, you cannot prove it in Coq, unless you know something about a, e.g., decidable equality. In that case, you can use the results on UIP (unicity of identity proofs) from the standard library.

nchar() is the function you want:

The ability to pattern-match on records in telescopes will be available in the (soon) upcoming version Agda 2.6.1.

Cf. the documentation of the development branch: https://agda.readthedocs.io/en/latest/language/telescopes.html#irrefutable-patterns-in-binding-positions

Today we know of a good reason for rejecting UIP: it is incompatible with the principle of univalence from homotopy type theory, which roughly says that isomorphic types can be identified. However, as far as I am aware, the reason that Coq's equality does not validate UIP is mostly a historical accident inherited from one of its ancestors: Martin-Löf's intensional type theory, which predates HoTT by many years.

The behavior of equality in ITT was originally motivated by the desire to keep type checking decidable. This is possible in ITT because it requires us to explicitly mark every rewriting step in a proof. (Formally, these rewriting steps correspond to the use of the equality eliminator eq_rect in Coq.) By contrast, Martin-Löf designed another system called extensional type theory where rewriting is implicit: whenever two terms a and b are equal, in the sense that we can prove that a = b, they can be used interchangeably. This relies on an equality reflection rule which says that propositionally equal elements are also definitionally equal. Unfortunately, there is a price to pay for this convenience: type checking becomes undecidable. Roughly speaking, the type-checking algorithm relies crucially on the explicit rewriting steps of ITT to guide its computation, whereas these hints are absent in ETT.

We can prove UIP easily in ETT because of the equality reflection rule; however, it was unknown for a long time whether UIP was provable in ITT. We had to wait until the 90's for the work of Hofmann and Streicher, which showed that UIP cannot be proved in ITT by constructing a model where UIP is not valid. (Check also these slides by Hofmann, which explain the issue from a historic perspective.)

This doesn' t mean that UIP is incompatible with decidable type checking: it was shown later that it can be derived in other decidable variants of Martin-Löf type theory (such as Agda), and it can be safely added as an axiom in a system like Coq.

See Saizan's answer for a solution along the original lines. Alternatively, there is a simple solution:

I think you are referring to the fact that the result type of path_induction mentions the path that is being destructed, whereas the one of eq_rect does not. This omission is the default for inductive propositions (as opposed to what happens with Type), because the extra argument is not usually used in proof-irrelevant developments. Nevertheless, you can instruct Coq to generate more complete induction principles with the Scheme command: https://coq.inria.fr/distrib/current/refman/user-extensions/proof-schemes.html?highlight=minimality. (The Minimality variant is the one used for propositions by default.)

Sure, ua is an equivalence, so it's injective. In the HoTT book, the inverse of ua is idtoeqv, so by congruence idtoeqv (ua f) ≡ idtoeqv (ua g) and then by inverses f ≡ g. I'm not familiar with the contents of cubical Agda prelude but this should be provable since it follows directly from the statement of univalence.

When you pattern match on p at refl in the definition of J, its type is refined from x ≡ y to x ≡ x (since the type of the constructor refl is ∀ {x} -> x ≡ x, i.e. it sets both indices to x), which means we can refine both the left- and the right-hand sides by x ~ y, which is both why the y in the pattern becomes x (or, alternatively, .x in Agda to make it explicit that it is an inaccessable pattern), and also why c x : C x x refl passes on the right-hand side for the result type C x y p.

In HoTT with univalence, it is indeed provable that list1 A is equal to list2 A for all A. Given a proof p : list1 A = list2 A, transport (or subst) gives you P (list1 A) -> P (list2 A) for any P. In cubical type theories, such transporting may also compute as expected. To my knowledge, cubical type theory (CCHM or cartesian) is the only setting where this currently works. cubicaltt is the most usable (but still not really practical) implementation.