1. Procesos discretos en el tiempo

Un proceso aleatorio discreto en el tiempo es una familia de variables aleatorias {X_n}, donde a partir de n se define en un subgrupo de enteros.

Por ejemplo:

{X_n, n=1, 2, ...}

{X_n, n=0, 1, 2, ...}

{X_n, n=0, ± 1 , ± 2 ...}

Recordando que las variables aleatorias son funciones definidas en un espacio muestral S, se puede pensar en X_n(ω) en dos formas:

• Para n fijos, X_n(ω) es función de ω y por lo tanto una variable aleatoria.
• Para ω fija, se obtiene una secuencia de números X₁(ω), X₂(ω), X₃(ω), ... . Secuencia que se denomina una realización, camino muestral, o función muestral del proceso aleatorio.

1.1 Ejemplo: Envío de bits sobre un canal con ruido

Referencia: Gubner 10.1 pdf/p.383

Enviar una secuencia de bits sobre un canal con ruido , los bits se invierten de forma independiente con probabilidad p.

Sea:

• X_n(ω)=0 de otra forma.
• X_n(ω)=1 si se invierte el n-ésimo bit y

entonces {X_n(ω), n= 1, 2, ...} es una secuencia Bernoulli(p) i.i.d .

Tres realizaciones del ruido se representan en la gráfica del ejercicio anterior. Sin embargo, el resultado de la señal X_n afectada por el Ruido_n como se vería en el receptor se muestra a continuación.

# Ejercicio: Envío de bits sobre un canal con ruido
# Gubner 10.1 
# propuesta: edelros@espol.edu.ec
import numpy as np
import matplotlib.pyplot as plt
import scipy.stats as stats

# INGRESO
n = 25 
pcanal = 0.5
p = 0.2 # error o inversión de bit

# PROCEDIMIENTO
# muestras k
k  = np.arange(1, n+1)

# transmisor
x     = stats.bernoulli.rvs(pcanal, size=n)
# ruido del canal
ruido = stats.bernoulli.rvs(p, size=n)

# En el receptor
receptor = np.zeros(len(x), dtype = int)
for i in range(0,len(x)):
    if (ruido[i] == 0):
        receptor[i] = x[i]
    if (ruido[i] == 1):
        # invierte el bit
        if (x[i] == 1):
            receptor[i] = 0
        if (x[i] == 0):
            receptor[i] = 1

# SALIDA
plt.suptitle('Bernoulli rango hasta n='+str(n))

# trama de bits en transmisor
plt.subplot(311)
plt.stem(k,x)
plt.ylabel('x')
plt.margins(0.05)

# ruido del canal
plt.subplot(312)
plt.stem(k,ruido,markerfmt='or')
plt.ylabel('ruido')
plt.margins(0.05)

# Señal recibida en receptor
plt.subplot(313)
plt.stem(k,receptor)
plt.ylabel('receptor')
plt.margins(0.05)

plt.xlabel('k')
plt.show()

2. Procesos contínuos en el tiempo

Un proceso aleatorio contínuo en el tiempo es una familia de variables aleatorias {X_t} donde t esta definido en un intervalo de tiempo.

{X_t, t ≥ 0}
{X_t, 0 ≤ t ≤ T}
{X_t, -∞ ≤ t ≤ ∞}

2.1 Ejemplo: Portadora con fase aleatoria

Referencia: Gubner 10.5 pdf/p.386

En radio comunicación, una señal portadora se modela como una sinusoide con fase aleatoria. La razón para usar una fase aleatoria es que en receptor no se conoce cuando se encendió el transmisor o la distancia entre el transmisor y receptor, que son factores que afectan a la fase.

El modelo matemático para éste caso es el proceso aleatorio contínuo en el tiempo, definido por:

x_t = cos(2πft + θ)

donde f es la frecuencia de la portadora y θ es una variable aleatoria uniforme [-π, π].

Tres realizaciones del proceso que dan tres valrores dirferenctes de θ y su efecto en la portadora se obtienen como:

# Gubner 10.5 Portadora con fase aleatoria
# propuesta: edelros@espol.edu.ec
import numpy as np
import matplotlib.pyplot as plt
import scipy.stats as stats

# ingreso
n = 5
f = 1

# PROCEDIMIENTO
# muestras ti
t = np.arange(0,n,0.1)

# genera muestras aleatorias con f: uniforme
theta = stats.uniform.rvs(loc=-np.pi, scale=2*np.pi ,size=3)

# selales desfasadas
xt0 = np.cos(2*np.pi*f*t + theta[0])
xt1 = np.cos(2*np.pi*f*t + theta[1])
xt2 = np.cos(2*np.pi*f*t + theta[2])

# SALIDA
print('theta: ',theta)

# grafica
plt.suptitle('Portadora')
# grafica x0
plt.subplot(311)
plt.plot(t,xt0)
plt.ylabel('x0')
plt.margins(0.05)

# grafica x1
plt.subplot(312)
plt.plot(t,xt1)
plt.ylabel('x1')
plt.margins(0.05)

# grafica x2
plt.subplot(313)
plt.plot(t,xt2)
plt.ylabel('x2')
plt.margins(0.05)

plt.xlabel('k')
plt.show()

Referencia: Gubner 10 pdf/p.383, León-García 9.1 pdf/p.488

3. Proceso aleatorio - Secuencia de bits Tx

Un proceso aleatorio o proceso estocástico es una familia de variables aleatorias.

Por ejemplo, al enviar una secuencia de bits sobre un canal inalámbrico, no existe un grupo predeterminado de bits a transmitir, que para modelar se usa una secuencia infinita de variables aleatorias.

Tres realizaciones de X₁, X₂, ... se obtienen como:

Algoritmo en Python

# secuencia de bits (trama)
# propuesta: edelros@espol.edu.ec
import numpy as np
import matplotlib.pyplot as plt
import scipy.stats as stats

# ingreso
n = 25 
p = 0.5

# PROCEDIMIENTO
# indice k
k  = np.arange(1, n+1)

# genera muestras de variable aleatoria con bernoulli
x1 = stats.bernoulli.rvs(p, size=n)
x2 = stats.bernoulli.rvs(p, size=n)
x3 = stats.bernoulli.rvs(p, size=n)

# SALIDA
plt.suptitle('bernoulli rango hasta n='+str(n))

# grafica X1
plt.subplot(311)
plt.stem(k,x1)
plt.ylabel('x1')
plt.margins(0.05)

# grafica X2
plt.subplot(312)
plt.stem(k,x2)
plt.ylabel('x2')
plt.margins(0.05)

# grafica X3
plt.subplot(313)
plt.stem(k,x3)
plt.ylabel('x3')
plt.margins(0.05)

plt.xlabel('k')
plt.show()

La forma mas simple de un proceso aleatorio - independiente, con secuencias idénticamente distribuidas (iid).

4. Procesos aleatorios iid

La secuencia X_n de un proceso aleatorio iid consiste en una secuencia de variables independientes, idénticamente distribuidas con cdf F_x(x), media m y varianza σ² .

m_X(n) = E[X_n] = m para todo n

lo que indica que su media es constante.

La función de autocovarianza , si n₁ ≠ n₂ :

C_x(n₁, n₂) = E[(X_n1 - m)(X_n2 - m)] =
= E[(X_n1 - m)] E[(X_n2 - m)] = 0

dado que X_n1 y X_n2 son variables independientes y si n₁ = n₂ = n:

C_x(n₁, n₂) = E[(X_n - m)²] = σ²

lo que permite expresarla como:

C_x(n₁, n₂) = σ² δ_n1n2

donde δ_n1n2 = 1 si n₁ = n₂ y 0 para cualquier otro caso, que también expresa que su autocovarianza es cero en cualquier lugar exceptuando n₁ = n₂.

La función de autocorrelación de un proceso iid es:

Rx(n1, n2) = Cx(n1, n2) + m2

5. Ejemplo: Proceso aleatorio Bernoulli

Referencia: León-García E9.13 pdf/p.499

La secuencia I_n es una secuencia de variable aleatoria independiente tipo Bernoulli. Una ejecución se muestra en a figura. Se puede interpretar como el evento que un foco falle y se reemplace en un día n.

tiene media y varianza:

m1 = p     VAR[In] = p(1-p)

permite realizar cálculos de forma muy sencilla, por ejemplo, la probabilidad que los primeros cuatro bits tengan la secuencia 1001

p[I1=1,I2=0,I3=0,I4=1] = 
= p[I1=1]p[I2=0]P[I3=0]P[I4=1]=
= p2(1-p)2

o que la probabilidad de que el segundo bit sea 0 y el séptimo sea 1

P[I₂=0, I₇=1] = P[I₂=0]P[I₇=1] = p(1-p)

Algoritmo en Python

El código Python para generar el proceso Bernoulli usado es:

# Generar numeros aleatorios con distribución bernoulli
# Leon-Garcia E9.13 Proceso aleatorioBernoulli 
# propuesta: edelros@espol.edu.ec
import numpy as np
import matplotlib.pyplot as plt
import scipy.stats as stats

# INGRESO
# n=int(input('cuantos aleatorios: '))
# p=float(input('probabilidad p: '))
n=20
p=0.5

# Procedimiento
pasos=np.zeros(n, dtype=int)
camina=np.zeros(n, dtype=int)

# procesa los datos
s=0
for i in range(0,n):
    pasos[i]=stats.binom.rvs(1,p)
    s=s+pasos[i]
    camina[i]=s

# SALIDA
plt.subplot(211)
plt.stem(pasos)
plt.ylabel('bernoulli In')
plt.margins(0.05)

plt.subplot(212)
plt.stem(camina)
plt.ylabel('Sn')
plt.margins(0.05)
plt.show()

6. Proceso aleatorios - pasos, caminata aleatoria

Ejemplo: Caminata de pasos aleatorios o Random Step Process

Referencia: León-García. E9.14 p.500

Un contador "up-down" o "sube-baja" genera pulsos +1 ó -1. La entrada del contador está dada por D_n = 2 I_n-1, donde I_n es un proceso aleatorio tipo Bernoulli.

Por ejemplo D_n representaría el cambio en la posición de una partícula que se mueve a lo largo de una linea recta, y cambia entre ±1 cada unidad de tiempo. Ej: n=20, p=0.5

La media de D_n es:

m_D(n) = E[D_n]
= E[ 2I_n -1] = 2E[I_n]-1
= 2p - 1
La varianza de D_n se encuentra como:

VAR[D_n] = VAR[2I_n - 1]
= 2² VAR[I_n]
= 4p(1 - p)

Las probabilidades de los eventos de D_n se calculan como en el ejemplo del tema de la Binomial.

Algoritmo en Python para caminata aleatoria

# Proceso caminata de pasos aleatorios
# Leon-Garcia E 9.14 p.500
# propuesta: edelros@espol.edu.ec
import numpy as np
import matplotlib.pyplot as plt
import scipy.stats as stats

# INGRESO
# n=int(input('cuantos aleatorios: '))
# p=float(input('probabilidad p: '))
n = 20
p = 0.5

# PROCEDIMIENTO

# inicializa vectores
pasos  = np.zeros(n, dtype=int)
camina = np.zeros(n, dtype=int)
ejex   = np.zeros(n, dtype=int)

s = 0 
for i in range(0,n):
    # genera aleatorio con binomial
    pasos[i] = 2*(stats.binom.rvs(1,p))-1
    s = s+pasos[i]
    camina[i] = s
    ejex[i]   = i

# SALIDA
# grafica pasos 
plt.subplot(211)
plt.stem(ejex,pasos)
plt.ylabel('Pasos Dn')
plt.margins(0.05)

# grafica caminata aleatoria
plt.subplot(212)
plt.stem(ejex,camina)
plt.ylabel('Caminata Sn')
plt.margins(0.05)
plt.xlabel('n')

plt.show()

Referencia: León-García 9.14 p.500-501