Is there a standard for storing and displaying Pratt certificates of primality? Is there a standard using XML tags or something else for storing a Pratt certificate of primality?
What is the standard for the display? 
I am aware that one would need the prime $p$, a primitive root $a$ and the factorization of $p-1$ along with a certificate for each prime in the factorization of $p-1$.  I just don't know how this is expected to be stored or displayed.
 A: To the best of my knowledge, there is no standard in use.  Every program uses their own method, with varying levels of documentation.
I came up with my own format, described here, along with a verifier (used by factordb) and proof software that generates these forms.  The documentation could be improved.  It covers ECPP (with simple n-1 and n+1) as well as BLS75 (T3, T5, T15) and Lucas.
My code doesn't generate strict Pratt certificates (e.g. using type Lucas) because BLS75 theorem 5 is much more efficient, not to mention ECPP.  But the certificate allows them and the verifiers handle it.
A small example using the Lucas type (as used for a Pratt certificate) would look like:

[MPU - Primality Certificate]
Version 1.0

Proof for:
N 8087094497428743437627091507362881

Type Lucas
N  8087094497428743437627091507362881
Q[1]  6360775529
Q[2]  1237110551
Q[3]  98277749
Q[4]  3631
Q[5]  5
Q[6]  3
Q[7]  2
A     13

Any Q[i] larger than $2^{64}$ would need its own entry as well (which for a Pratt certificate would also be of type Lucas, but the verifiers will accept any type).  Without that, the certificate will not verify.  I chose $2^{64}$ since we can run BPSW on anything smaller and have a verified result.  Primo chose $34 * 10^{13}$ as its cutoff (the BPSW result was not known when Primo chose its format).  [Update: Just two days ago he released a new "format 4" certificate that uses the BPSW result]

Addendum for certificates:


*

*Primo, the gold standard of free primality provers, defined its own format for ECPP certificates.  It is well defined, will verify its own certificates, and there are two independent open source tools that also verify them.

*Perl/ntheory is what I describe above (MPU certificates).  I believe it is well defined, it has proof software in Perl and C+GMP, and verifiers in Perl and C+GMP.  ECPP as well as BLS75-T5 and some other methods.

*Pari/GP will produce a $p-1$ certificate with isprime(p,1).  It looks like BLS75 theorem 5 using the BPSW ($2^{64}$) cutoff (technically it's C&P's theorem 4.1.5 based on BLS75-T5).  Its documentation is very brief but basically is a matrix with rows of "Q A x" where x is either 1 (Q < 2^{64}) or another matrix.  Factorization only is done to $p^{1/3}$ which is what BLS75-T5 needs.

*Mathematica's PrimeQCertificate[n] will produce certificates.  It doesn't seem to have any documentation on how to parse them.  It will verify its own certificates.  For small inputs it generates Pratt certificates, while larger inputs use a "Atkin-Goldwasser-Kilian-Morain" certificate.

*Morain's very old ecpp program will output ECPP certificates.  I have not attempted to decipher them.

*I wrote a Perl program to turn the output of GMP-ECPP into MPU certificates, which can then run through its verifier.  GMP-ECPP is significantly slower than ecpp-dj or Primo however.

*I also wrote a Perl program that converts ECPP certificates produced by SAGE's ecpp function (which AFAIK never got merged into master) to MPU certificates, which can then run through its verifier.  It's a neat small implementation that's good for not-very-large inputs.

*MuPAD, related to MATLAB, seems to generate ECPP certificates.  I haven't looked closely since I don't have their software, but it looks like converting to MPU certificates would be straightforward.

