Para fazer a função eu praticamente tive que escrever carta por carta no código. Quem quiser programar a função no próprio computador para calcular as chances de qualquer conjunto de atributos, segue o código que eu fiz para as chances de conseguir todas as recompensas menos as que dão um feitiço:

edit: os símbolos de "maior que" e "menor que" estão sendo deletados pelo editor de texto do site, não sei por que.

#include math.h

double f(double x) { // Essa é a função principal do código, calcula a chance de tirar ao menos um 5 ou 6 jogando x dados
    if (x "menor ou igual a" 1.0)
        return 1.0 / 3.0;
    else
        return (1.0 - pow(2. / 3., x));
}

double maior(double a, double b) {
    if (a "maior que" b)
        return a;
    return b;
}

double tamanhoDoDeck = 54.;

double cartasAmazonia(double a, double b, double c, double d, double e) {

    return (
        f(d) + (1 - f(d)) * f(c-1)+                // recuar a Perdição em 1
        f(c) * f(a) + (1 - f(c)) * f(d - 1)+    // Artefato ou 2 pistas
        f(d) + (1 - f(d)) * f(b) +                // Artefato(+1pista) ou Artefato
        f(c-1)*f(b) +                            // *CP*  2 pistas...
        f(c)*f(b)+(1-f(c))*f(d)+                // *SaP* (1pista+)Avançar o Mistério em 1 ou Recuar a Perdição em 1
        f(maior(c - 1, d - 1))                    // *CeR* Artefato
        ) / tamanhoDoDeck;
}
double cartasAntartida(double a, double b, double c, double d, double e) {

    return (
        f(d) + (1 - f(d)) * f(c - 1) +            // recuar a Perdição em 1
        f(c) * f(e) + (1 - f(c)) * f(d - 1) +    // Artefato ou 2 pistas
        f(d) + (1 - f(d)) * f(b) +                // Artefato ou Artefato
        f(e) * f(a) +                            // *CP* Recua a Perdição em 1 ou um feitiço...
        f(maior(e, d)) +                        // *SaP* Artefato ou Artefato
        f(c)*f(e)+(1-f(c))*f(d)                    // *CeR* Avança Mistério ou Recua Perdição
        ) / tamanhoDoDeck;
}
double cartasCoracaodaAfrica(double a, double b, double c, double d, double e) {

    return (
        f(d) + (1 - f(d)) * f(c - 1) +            // recuar a Perdição em 1
        f(c) * f(a) + (1 - f(c)) * f(d - 1) +    // Artefato ou 2 pistas
        f(d) + (1 - f(d)) * f(b) +                // Artefato ou Artefato
        f(a-1) * f(c-1) + (1 - f(a-1)) * f(d)+     // *CP* Artefato ou 2 pistas
        f(e) * f(d) + (1 - f(e)) * f(a)+        // *SaP* Avança Mistério ou Recua Perdição
        f(maior(d - 1, a - 1))                    // *CeR* Artefato ou Artefato
        ) / tamanhoDoDeck;
}
double cartasPiramides(double a, double b, double c, double d, double e) {

    return (
        f(d) + (1 - f(d)) * f(c - 1) +            // recuar a Perdição em 1
        f(c) * f(a) + (1 - f(c)) * f(d - 1) +    // Artefato ou 2 pistas
        f(d) + (1 - f(d)) * f(b) +                // Artefato ou Artefato
        f(d - 1) * f(a)+                         // *CP* Artefato
        f(d) * f(c) + (1 - f(d)) * f(e) +        // *SaP* Avança Mistério ou Recua Perdição
        f(maior(a - 1, c - 1))                    // *CeR* Artefato ou Artefato
        ) / tamanhoDoDeck;
}
double cartasHimalaia(double a, double b, double c, double d, double e) {

    return (
        f(c) +            // desconsiderando enfrentar um monstro aleatório e derrotar, recuar a Perdição em 1
        f(c) * f(e) + (1 - f(c)) * f(d - 1) +        // Artefato ou 2 pistas
        f(d) + (1 - f(d)) * f(b) +                    // Artefato ou Artefato
        f(d) * f(a - 1) + (1 - f(d)) * f(e - 1) +    // *CP* 2 feitiços ou 2 pistas
        f(maior(c, e)) +                            // *SaP* Artefato ou Artefato
        f(e) * f(d) + (1 - f(e)) * f(c)                // *CeR* Avança Mistério ou Recua Perdição
        ) / tamanhoDoDeck;
}
double cartasTunguska(double a, double b, double c, double d, double e) {

    return (
        f(d) * f(a) + (1 - f(d)) * f(c - 1) +        // recuar a Perdição em 1
        f(c) * f(e) + (1 - f(c)) * f(d - 1) +        // Artefato ou 2 pistas
        f(d) + (1 - f(d)) * f(b) +                    // Artefato ou Artefato
        f(c) * f(e - 1) + (1 - f(c)) * f(d - 1) +    // *CP* recue DT ou recue DT
        f(maior(b, c)) +                            // *SaP* Artefato ou Artefato
        f(d) * f(c) + (1 - f(d)) * f(b)                // *CeR* Avança Mistério ou Recua Perdição
        ) / tamanhoDoDeck;
}

double cartasArkham(double a, double b, double c, double d, double e) {

    return (
        f(c) * f(a-1) + (1 - f(c)) * f(b) +        // *MdL* AM ou recuar DT
        f(maior(b, c))                             // *MdL* Artefato magico ou Artefato magico
        ) /tamanhoDoDeck;
}
double cartasRoma(double a, double b, double c, double d, double e) {

    return (
        f(c) * f(b - 1) + (1 - f(c)) * f(d) +        // *MdL* AM ou recuar DT
        f(maior(b, c))                             // *MdL* Artefato magico ou Artefato magico
        ) / tamanhoDoDeck;
}
double cartasSydney(double a, double b, double c, double d, double e) {

    return (
        f(c) * f(b - 1) + (1 - f(c)) * f(d) +        // *MdL* AM ou recuar DT
        f(maior(b, d))                             // *MdL* Artefato magico ou Artefato magico
        ) / tamanhoDoDeck;
}

double cartasBuenosAires(double a, double b, double c, double d, double e) {

    return (
        f(d) * f(c) + (1 - f(d)) * f(e) +        // *SaP* AM ou recuar DT
        f(maior(b, c))                             // *SaP* Artefato magico ou Artefato magico
        ) / tamanhoDoDeck;
}
double cartasIstambul(double a, double b, double c, double d, double e) {

    return (
        f(c) * f(a) + (1 - f(c)) * f(d) +        // *SaP* AM ou recuar DT
        f(maior(c, e))                             // *SaP* RecExc Pers
        ) / tamanhoDoDeck;
}
double cartasToquio(double a, double b, double c, double d, double e) {

    return (
        f(d) * f(e) + (1 - f(d)) * f(b) +        //*SaP* AM ou recuar DT
        f(maior(d, c))                             // *SaP* [A]Reliq
        ) / tamanhoDoDeck;
}

double cartasLondres(double a, double b, double c, double d, double e) {

    return (
        f(b) * f(c) + (1 - f(b)) * f(e) +            // *CeR* AM ou recuar DT
        f(maior(b-1, d-1))                             // *CeR* [A]
        ) / tamanhoDoDeck;
}
double cartasXangai(double a, double b, double c, double d, double e) {

    return (
        f(e) * f(c) + (1 - f(e)) * f(b) +        // *CeR* AM ou recuar DT
        f(maior(c-1, d-1))                         // *CeR* [A]
        ) / tamanhoDoDeck;
}
double cartasSaoFrancisco(double a, double b, double c, double d, double e) {

    return (
        f(b) * f(d) + (1 - f(b)) * f(c) +        // *CeR*AM ou recuar DT
        f(maior(b-1, d-1))                         // *CeR* [A]
        ) / tamanhoDoDeck;
}

No caso da função que retorna só os valores das chances que interessam (avançar mistério e receber artefato)

double cartasAmazoniaS(double a, double b, double c, double d, double e) {

    return (
        0 +                                            // recuar a Perdição em 1
        f(c) * f(a) +                                // Artefato ou 2 pistas
        f(d) + (1 - f(d)) * f(b) +                    // Artefato(+1pista) ou Artefato
        0 +                                            // *CP*  2 pistas...
        f(c) * f(b) +                                // *SaP* (1pista+)Avançar o Mistério em 1 ou Recuar a Perdição em 1
        f(maior(c - 1, d - 1))                        // *CeR* Artefato
        ) / tamanhoDoDeck;
}
double cartasAntartidaS(double a, double b, double c, double d, double e) {

    return (
        0 +                                        // recuar a Perdição em 1
        f(c) * f(e) +                            // Artefato ou 2 pistas
        f(d) + (1 - f(d)) * f(b) +                // Artefato ou Artefato
        0 +                                        // *CP* Recua a Perdição em 1 ou um feitiço...
        f(maior(e, d)) +                        // *SaP* Artefato ou Artefato
        f(c) * f(e)                                // *CeR* Avança Mistério ou Recua Perdição
        ) / tamanhoDoDeck;
}
double cartasCoracaodaAfricaS(double a, double b, double c, double d, double e) {

    return (
        0 +                                                // recuar a Perdição em 1
        f(c) * f(a) +                                    // Artefato ou 2 pistas
        f(d) + (1 - f(d)) * f(b) +                        // Artefato ou Artefato
        f(a - 1) * f(c - 1) +                            // *CP* Artefato ou 2 pistas
        f(e) * f(d) +                                    // *SaP* Avança Mistério ou Recua Perdição
        f(maior(d - 1, a - 1))                            // *CeR* Artefato ou Artefato
        ) / tamanhoDoDeck;
}
double cartasPiramidesS(double a, double b, double c, double d, double e) {

    return (
        0 +                                        // recuar a Perdição em 1
        f(c) * f(a) +                            // Artefato ou 2 pistas
        f(d) + (1 - f(d)) * f(b) +                // Artefato ou Artefato
        f(d - 1) * f(a) +                         // *CP* Artefato
        f(d) * f(c) +                            // *SaP* Avança Mistério ou Recua Perdição
        f(maior(a - 1, c - 1))                    // *CeR* Artefato ou Artefato
        ) / tamanhoDoDeck;
}
double cartasHimalaiaS(double a, double b, double c, double d, double e) {

    return (
        0 +            // desconsiderando enfrentar um monstro aleatório e derrotar, recuar a Perdição em 1
        f(c) * f(e) +                                // Artefato ou 2 pistas
        f(d) + (1 - f(d)) * f(b) +                    // Artefato ou Artefato
        0 +                                            // *CP* 2 feitiços ou 2 pistas
        f(maior(c, e)) +                            // *SaP* Artefato ou Artefato
        f(e) * f(d)                                    // *CeR* Avança Mistério ou Recua Perdição
        ) / tamanhoDoDeck;
}
double cartasTunguskaS(double a, double b, double c, double d, double e) {

    return (
        0 +                                            // recuar a Perdição em 1
        f(c) * f(e) + (1 - f(c)) * f(d - 1) +        // Artefato ou 2 pistas
        f(d) + (1 - f(d)) * f(b) +                    // Artefato ou Artefato
        0 +                                            // *CP* recue DT ou recue DT
        f(maior(b, c)) +                            // *SaP* Artefato ou Artefato
        f(d) * f(c) + (1 - f(d)) * f(b)                // *CeR* Avança Mistério ou Recua Perdição
        ) / tamanhoDoDeck;
}

double cartasArkhamS(double a, double b, double c, double d, double e) {

    return (
        f(c) * f(a - 1) +         // *MdL* AM ou recuar DT
        f(maior(b, c))                             //  *MdL* Artefato magico ou Artefato magico
        ) / tamanhoDoDeck;
}
double cartasRomaS(double a, double b, double c, double d, double e) {

    return (
        f(c) * f(b - 1) +         //  *MdL* AM ou recuar DT
        f(maior(b, c))                             //  *MdL* Artefato magico ou Artefato magico
        ) / tamanhoDoDeck;
}
double cartasSydneyS(double a, double b, double c, double d, double e) {

    return (
        f(c) * f(b - 1) +         // *MdL* AM ou recuar DT
        f(maior(b, d))                             //  *MdL* Artefato magico ou Artefato magico
        ) / tamanhoDoDeck;
}

double cartasBuenosAiresS(double a, double b, double c, double d, double e) {

    return (
        f(d) * f(c) +         // *SaP* AM ou recuar DT
        f(maior(b, c))                             // *SaP* Artefato magico ou Artefato magico
        ) / tamanhoDoDeck;
}
double cartasIstambulS(double a, double b, double c, double d, double e) {

    return (
        f(c) * f(a) +         // AM ou recuar DT
        f(maior(c, e))                             // *SaP* RecExc Pers
        ) / tamanhoDoDeck;
}
double cartasToquioS(double a, double b, double c, double d, double e) {

    return (
        f(d) * f(e) +        // AM ou recuar DT
        f(maior(d, c))                             // *SaP* [A]Reliq
        ) / tamanhoDoDeck;
}

double cartasLondresS(double a, double b, double c, double d, double e) {

    return (
        f(b) * f(c) +                                    // *CeR* AM ou recuar DT
        f(maior(b - 1, d - 1))                             // *CeR* [A]
        ) / tamanhoDoDeck;
}
double cartasXangaiS(double a, double b, double c, double d, double e) {

    return (
        f(e) * f(c) +                                // *CeR* AM ou recuar DT
        f(maior(c - 1, d - 1))                         // *CeR* [A]
        ) / tamanhoDoDeck;
}
double cartasSaoFranciscoS(double a, double b, double c, double d, double e) {

    return (
        f(b) * f(d) +         // *CeR*AM ou recuar DT
        f(maior(b - 1, d - 1))                         // *CeR* [A]
        ) / tamanhoDoDeck;
}


double probExpedicaoS(double a, double b, double c, double d, double e) { // recebe os valores de conhec, obs, inf, forca e det do investigador
    return
        cartasAmazoniaS(a, b, c, d, e) +
        cartasAntartidaS(a, b, c, d, e) +
        cartasPiramidesS(a, b, c, d, e) +
        cartasCoracaodaAfricaS(a, b, c, d, e) +
        cartasHimalaiaS(a, b, c, d, e) +
        cartasTunguskaS(a, b, c, d, e) +

        cartasArkhamS(a, b, c, d, e) +
        cartasRomaS(a, b, c, d, e) +
        cartasSydneyS(a, b, c, d, e) +

        cartasBuenosAiresS(a, b, c, d, e) +
        cartasIstambulS(a, b, c, d, e) +
        cartasToquioS(a, b, c, d, e) +

        cartasLondresS(a, b, c, d, e) +
        cartasXangaiS(a, b, c, d, e) +
        cartasSaoFranciscoS(a, b, c, d, e);
}