Un alfabet ([latex]\Sigma[/latex]) és un conjunt finit d’elements (símbols), habitualment caràcters alfanumèrics.

Un mot és una llista de símbols d’un alfabet. El mot buit (llista de longitud 0) el denotarem amb el meta-símbol [latex]\lambda[/latex]. Utilitzarem [latex]u[/latex], [latex]v[/latex], [latex]w[/latex], [latex]u_1[/latex], … per denominar paraules.

[latex]\Sigma = \{a, b\}[/latex]
Paraules: ab, bbb, a, [latex]\lambda[/latex]
Longituds: |ab|=2, |bbb|=3, |a|=1, |[latex]\lambda[/latex]|=0

Extenem la notació de les longituds per a occurències d’un mot dins d’un altre: [latex]|u|_w[/latex]

[latex]|ab|_a=1[/latex], [latex]|bbb|_b=3[/latex], [latex]|bbb|_{bb}=2[/latex]

Per referir-nos al símbol i-éssim del mot u utilitzarem: u[i]

ab[1] = a, ab[2] = b

Amb la operació producte ([latex]u\cdot v[/latex] o [latex]uv[/latex]) representem la concatenació de dues paraules. Per exemple:

[latex](ab)\cdot(bbb) = abbbb[/latex]
Element neutre: [latex]u\cdot\lambda=\lambda\cdot u=u[/latex]
Associativitat: [latex]u\cdot(v\cdot w)=(u\cdot v)\cdot w[/latex]

Amb [latex]\Sigma^*[/latex] representem el conjunt de tots els mots possibles que podem construir amb l’alfabet [latex]\Sigma[/latex]. Exemple per a [latex]\Sigma = \{a, b\}[/latex]:

[latex]\Sigma^*={\lambda, a, b, aa, ab, ba, bb, …}[/latex]

Un llenguatge sobre l’alfabet [latex]\Sigma[/latex] és un subconjunt qualsevol [latex]L^* \subseteq \Sigma^*[/latex]. Per exemple:

  • Paraules sobre l’alfabet {a, b} i de longituds múltiples de 2:
       [latex]\{w \in \{a, b\}^* / |w| \in \dot{2}\} = \{\lambda, aa, ab, ba, bb, aaaa, …\}[/latex]
  • Paraules amb algun símbol «a»:
       [latex]\{w \in \{a,b\}^* / \exists w_1,w_2 : w = w_1aw_2\} = \{w \in \{a, b\}^* / |w|_a \ge 1\}[/latex]
  • Paraules tals que tota ocurrència d’«a» ve seguida d’una occurència de «b»:
       [latex]\{w \in \{a,b\}^* / \forall w_1, w_2 : (w=w_1aw_2 \Rightarrow \exists w_2^1 : w_2 = bw_2^1) = [/latex]
       [latex] = \{w \in \{a, b\}^* / |w|_{aa}=0\land(w=\lambda \lor \exists w’ : w=w’b)\}[/latex]

  • Denotem el llenguatge que conté només el mot buit amb [latex]\Lambda=\{\lambda\}[/latex] ([latex]\Lambda \neq \emptyset[/latex]).

    Definim la concatenació de dos llenguatges:

    [latex]L_1\cdot L_2 = \{w_1\cdot w_2 / w_1 \in L_1 \land w_2 \in L_2\}=[/latex] [latex]\{w / \exists w_1 \in L_1, w_2 \in L_2 : (w=w_1w_2)\}[/latex]

    Exemples:

    [latex]\{a,bb\}\cdot\{b,ba\} = \{ab, aba, bbb, bba\}[/latex]
    Element neutre: [latex]\Lambda\cdot L = L \cdot \Lambda = L[/latex]
    No funciona amb el conjunt buit: [latex]\emptyset\cdot L=L\cdot \emptyset = \emptyset[/latex]
    Associativitat: [latex]L_1(L_2L_3)=(L_1L_2)L_3[/latex]

    Definim l’exponenciació de paraules:

    [latex]w^n=w\cdot w\cdot \cdot\cdot\cdot \cdot w[/latex]

    Exemples:

    [latex]w^2=ww[/latex] [latex]w^1=w[/latex] [latex]w^0=\lambda[/latex]

    Es compleix que: [latex]w^n=w\cdot w^{n-1}[/latex], [latex]n\ge 1[/latex].

    Ídem per a l’exponenciació de llenguatges.

    Definim també l’operació [latex]L^*[/latex] (clausura de Kleene) d’un llenguatge. Aquesta dóna com a resultat un nou llenguatge que conté aquelles paraules que es poden obtenir a base d’escollir un nombre finit de paraules d’L i concatenar-les.

    [latex]
    \begin{array}{ll}L^*
    & = \{w_1\cdot w_2\cdot \cdot\cdot\cdot \cdot w_n / w_1, w_2, …, w_n \in L\} \\
    & = \{L^0\cup L^1\cup L^2\cup …\}\\
    & = \prod_{n=0}^{\infty}L^n\\
    \end{array}
    [/latex]
    (Les paraules d'[latex]L^*[/latex] són concatencions de 0, 1, 2, … paraules d’L.)

    Per exemple:

    [latex]\{a\}^* = \{\lambda, a, aa, aaa, …\}[/latex]
    [latex]\{ab\}^* = \{\lambda, ab, abab, ababab, …\}[/latex]
    [latex]\{a, bb\}^* = \{\lambda, a, bb, aa, abb, bba, bbbb, …\}[/latex]
    [latex]\{w\in\{a,b\}^* / |w| \in \dot{2}\}^* = \{w\in\{a,b\}^* / |w| \in \dot{2}\}[/latex]

    De forma semblant definim l’operació [latex]L^+[/latex], la qual no obliga a incloure el mot buit.

    [latex]L^+ = L^1\cup L^2\cup…[/latex]
    [latex]L^* = L^+ \cup \{\lambda\}[/latex]
    [latex]\lambda \in L^+ \Leftrightarrow \lambda \in L[/latex]


    Denominem el revessat d’un mot [latex]w[/latex]: [latex]w^R[/latex]. Exemple:

    [latex](aabab)^R=babaa[/latex]

    El revessat de la concatenació de dues paraules correspon al revessat de les dues paraules:

    [latex](uv)^R=v^Ru^R[/latex]

    També tenim el revessat d’un llenguatge:

    [latex]L^R = \{w^R / w \in L\} = \{w | w^R \in L\}[/latex]
    [latex](L_1L_2)^R=L_2^RL_1^R[/latex]

    Per exemple:

    [latex]\{aw | w \in \{a, b\}^*\}^R = \{wa | w \in \{a,b\}^*\}[/latex]

    Definim un morfisme com una funció que transforma paraules d’un alfabet a un altre:

    [latex]\sigma: \Sigma_1^* \rightarrow \Sigma_2^*[/latex]
    Commutativa amb la concatenació: [latex]\sigma(uv) = \sigma(u)\sigma(v)[/latex]

    [latex]\sigma(a_1a_2\cdot\cdot\cdot a_n)=\sigma(a_1)\sigma(a_2)\cdot\cdot\cdot\sigma(a_n)[/latex]
    [latex]\sigma(\lambda)=\lambda[/latex]

    Gràcies a la commutativitat, tenim prou per definir un morfisme amb definir la imatge dels símbols de l’alfabet, ja que llavors l’imatge de qualsevol mot es pot calcular en termes de les imatges dels símbols.

    Per exemple:

    [latex]\sigma: \{a, b, c\}^* \rightarrow \{0, 1\}^*[/latex]
    [latex]\sigma(a) = 0[/latex], [latex]\sigma(b)=11[/latex], [latex]\sigma(c)=\lambda[/latex]

    [latex]\begin{array}{ll}
    \sigma(accbacb)
    & = \sigma(a)\sigma(c)\sigma(c)\sigma(b)\sigma(a)\sigma(c)\sigma(b) \\
    & = 0\lambda\lambda110\lambda11 \\
    & = 011011
    \end{array}
    [/latex]

    Per a un llenguatge L:

    [latex]\sigma: \Sigma_1^* \rightarrow \Sigma_2^*[/latex]
    [latex]L \subseteq \Sigma_1^*[/latex]   [latex]\sigma(L)=\{\sigma(w) / w \in L\}[/latex]
    [latex]L \subseteq \Sigma_2^*[/latex]   [latex]\sigma^{-1}(L) = \{w / \sigma(w) \in L\}[/latex]
    [latex]\sigma(L_1L_2) = \sigma(L_1)\sigma(L_2)[/latex]

    Una regla de reescriptura (o substitució) és un parell de paraules [latex]u\rightarrow v[/latex]. Per exemple, la regla [latex]ab \rightarrow bba[/latex] substitueix tota ocurrència d’«ab» per «bba».

    Representem una substitució de la forma [latex]w_1uw_2 \rightarrow_{u\rightarrow v} w_1vw_2[/latex]. Per exemple:

    [latex]a\underline{ab}ab \rightarrow_{ab\rightarrow bba} a\underline{bba}ab[/latex]

    Si R és un conjunt de regles, podem indicar que [latex]w[/latex] es transforma en [latex]w'[/latex]…

    [latex]w\rightarrow_R w'[/latex] [latex]w\rightarrow_R^* w'[/latex] [latex]w\rightarrow_R^+ w'[/latex] [latex]w\rightarrow_R^i w'[/latex]
    aplicant 1 regla d’R aplicant 0 o mes substitucions amb regles d’R aplicant 1 o més substitucions amb regles d’R aplicant [latex]i[/latex] substitucions amb regles d’R

    Aquests apunts estan basats en els vídeos de Teoria de la Computació de Guillem Godoy (UPC).