UFCG IQuanta DSC. Cheyenne R. G. Isidro Bernardo Lula Júnior

Um Algoritmo para Transformar

Autômatos Finitos

Não-Determinísticos em Autômatos Finitos

Quânticos Preservando o Número de

Estados e a Linguagem Reconhecida

Cheyenne R. G. Isidro

cha@dsc.ufcg.edu.br

Bernardo Lula Júnior



Motivação



Situação e Problema abordado



Autômatos Finitos



Notação Vetorial



Autômato Finito Quântico



Algoritmo de Transformação



Circuito Quântico para AFQ ancilla



Conclusão



Bibliografia

Motivação



Estudar a Teoria da Computação Clássica no

contexto quântico



Iniciar com conceitos simples



Mostrar vantagens ao utilizar modelo

quântico



Buscar solução “quântica” para problemas

não resolvidos satisfatoriamente no contexto

clássico

Situação



Implementar soluções construídas a partir de

um AF

 1. Construir um AFN que resolve o problema

 Descrição de aplicações

 Tratamento formal (prova de teoremas)

 2. Transformar o AFN em um AFD equivalente  3. Implementar o AFD

Problema



Transformação pode levar à uma explosão

do número de estados (no pior caso)

 AFN – n estados  AFD – 2n estados

Contexto quântico



Com as futuras máquina quânticas,

queremos evitar esse problema

 Transformar AFN em AFQ diretamente sem

aumento exponencial no número de estados



Solução

 Algoritmo de transformação AFN para AFQ que

preserva a linguagem reconhecida e o número de estados do autômato original

 Autômatos Finitos são elementos essenciais tanto

na teoria como na prática computacional.

 Um Autômato Finito (AF) é uma 5-tupla

A = (Q, Σ, δ, q_init, Q_ac), onde:

 Q é um conjunto finito de estados;  Σ é um alfabeto de entrada;

 δ : Q x Σ → Q é uma função de transição;  q_init ∈ Q é o estado inicial;

 Q_ac ⊆ Q é um conjunto de estados de aceitação.

Autômatos Finitos - computação

 Inicia em q_init , A lê símbolo por símbolo da palavra

w = w₁w₂...w_n

 No i-ésimo passo, estando A no estado q, A lê o

símbolo w_i e atualiza seu estado para δ(q, w_i) = q’

 A aceita w se o autômato pára em um estado de

aceitação.

 A reconhece a linguagem formada pelas palavras

aceitas.

 A classe de linguagens reconhecidas por AFs é a

Autômatos Finitos - tipos



Autômato Finito Determinístico (AFD)

 δ(q_i, a) = q_j



Autômato Finito Não-Determinístico (AFN)

 δ : Q x Σ → 2Q

 δ(q_i, a) = { q_j1, ...,q_jk }

 Um AFN aceita a palavra w se há um caminho

Autômatos Finitos - equivalência



AFD e AFN reconhecem a mesma classe de

linguagens.



Problema ao transformar um AFN em um

Notação Vetorial



Seja um AF A (AFD ou AFN) com n estados.

 δ é descrita por matrizes de transição M_a , de

dimensão n x n, uma para cada a

∈

Σ.

 (M_a)_ij = 1, sse existe a transição δ(q_i, a) = q_j  (M_a)_ij = 0, caso contrário

 q_init é um vetor coluna de dimensão n onde:  (q_init)_i = 1, se q_i = q_init

Notação Vetorial

 Q_ac é o vetor coluna onde:  (Q_ac)_i = 1, se q_i ∈ Q_ac

 (Q_ac)_i = 0, se q_i ∉ Q_ac

 A quantidade de caminhos de aceitação para

uma palavra w é dada por:

f(w) = q_initT . M

w1. Mw2. ... . Mwn. Qac

Notação Vetorial - exemplo

 Exemplo: Autômato A  Notação matricial de A       =       =       =       = 1 0 1 0 M e 1 0 1 1 M , 1 0 Q , 0 1 q_{init ac 0 1}

 Computando a palavra w = 01, temos:

[

]

2 1 0 1 0 1 0 1 0 1 1 0 1 Q M M q ) 01 ( f T_{init 0 1 ac } =      ⋅       ⋅       ⋅ = ⋅ ⋅ ⋅ = δ(q₂, 0) = {q₂} δ(q₂, 1) = {q₂} q_init = {q₁} Q_ac = {q₂} δ(q₁, 0) = {q_1, q₂} δ(q₁, 1) = {q₂} Q = {q₁,q₂} Σ = {0, 1}

Autômato Finito Quântico



AFQ é uma 5 tupla B = (Q,

Σ

,

δ

, q

_init

, Q

_ac

),

onde:

 Q é um conjunto finito de estados;  Σ é um alfabeto de entrada;

 δ : Q x Σ x Q → C é uma função de transição;  q_init ∈ Q é o estado inicial;

 Q_ac ⊆ Q é um conjunto de estados de

Autômato Finito Quântico

 Os estados do AFQ podem estar em superposição!

 Superposição é representada por

∑

∈ α = Q i q i i q q

onde α_i é a amplitude do estado q_i e 1

Q i 2 i = α

∑

∈

 A função de transição é definida por δ : Q x Σ x Q → C

 O valor de δ(q₁, a, q₂) é a amplitude de |q₂〉 na superposição de estados que B assume ao ler o símbolo a, estando em |q₁〉.

Autômato Finito Quântico

 Para a∈Σ, U_a é a matriz complexa, de dimensão

|Q|x|Q|, definida por:

( )

_∑

(

)

∈ δ = Q ' q i i a q q ,a,q' q' U

 O operador deve ser unitário, logo, deve satisfazer:

∑

∈   = = δ ⋅ δ ∑ ∈ ∈ ∀ Q q j i j i * j i contrário caso 0 q q se 1 ) q , a , q ( ) q , a , q ( : a , Q q , q

 Para cada símbolo lido da palavra, B aplica a

AFQ – modelo MO-AFQ



MO-AFQ

 Modelo de Moore e Crutchfield define uma

única medição no final da computação da palavra  Palavra é aceita se 0 q U ) w ( f_Q = Q_ac⋅ _w⋅ _init 2 >

AFQ – modelo MM-AFQ



MM-AFQ

 Modelo de Kondacs e Watrous define múltiplas

medições, uma a cada leitura de símbolo da palavra

 Introduz um sexto elemento na tupla, o conjunto de

estados de rejeição Q_rej.

 Q_ac e Q_rej são conjuntos de estados de parada

 Autômato aceita a palavra, se pára em um dos estados do conjunto Q_ac com

AFQ – MO-AFQ e MM-AFQ



Modelos não reconhecem a classe das

linguagens regulares

 Limitação quanto à unitariedade das matrizes.



MM-AFQ são “mais poderosos” que MO-AFQ

 MM-AFQ reconhece todas as linguagem que o

AFQ – modelo AFQ ancilla



AFQ ancilla

 Modelo de Paschen utiliza qubits auxiliares para tornar

as transformações unitárias.

 AFQ ancilla B é uma 6-tupla B = (Q, Σ, Ω, δ, q_init, Q_ac),

onde:

 Q, Σ, q_init e Q_ac são semelhantes ao modelo MO-QFA;

 Ω é um alfabeto auxiliar;

 δ é estendida para δ:Q x Σ x Q x Ω → C[0,1] com a seguinte

restrição:

∑

   = = δ δ ∑ ∈ ∈ ∀ _{i j} * _{i j} i j trário caso con 0 q se q 1 ) y , q , a , q ( ). y , q , a , q ( : a , Q q , q

AFQ – modelo AFQ ancilla

 Toda linguagem regular pode ser reconhecida por

um AFQ ancilla

 Paschen prova partindo de um AFD mínimo e construindo um AFQ equivalente.

 Queremos transformar diretamente um AFN em

um AFQ equivalente, preservando o número de estados e a linguagem reconhecida!

Algoritmo

 Seja A = (Q, Σ, δ, q_init, Q_ac) um AFN qualquer.

Definimos um AFQ ancilla B = (Q’, Σ, Ω, δ’, q’_init, Q’_ac), como segue:

1. 2.

3. Para cada entrada da função δ’ definir:  , para todo d, 1 ≤ d ≤ k, e  , para todo

{

q : q Q

}

' Q = ∈ } q , ... , q { ) a , q ( _i = _{j1 jk} δ k 1 ) 0 , q , a , q ( ' _{i j d} = δ 0 ) 0 , q , a , q ( ' _{i s} = δ q _s ∈ Q − {q_j1,...,q_jk } } 1 , 0 { = Ω

Algoritmo

 4.

 5.

 6. Para cada a ∈ ∑, definir a matriz U_a como

segue:

As outras entradas são preenchidas com vetores ortonormais arbitrários de forma que a U seja

unitária.

(

)

_∑

= ) ( δ = k 1 d i j j i i a q 0 q ' q ,a,q _d,0 q _d U

{

ac

}

ac span q : q Q ' Q = ∈ init init

q

'

q

=

Exemplo

 AFN A U₀(|0〉|0〉) = |0〉1/√2(|0〉+|1〉) U₀(|0〉|1〉) = |0〉1/√2(|0〉−|1〉) U₀(|1〉|0〉) = |1〉|0〉 U₀(|1〉|1〉) = |1〉|1〉 Q' = {|0〉, |1〉} Σ = {|0〉, |1〉} q_init = {|0〉} Q_ac = {|1〉} U ₀₌

[

1/2 1/2 0 0 1/2 −1 /2 0 0 0 0 0 1

]

U 1=

[

0 1 0 0 1 0 0 0 0 0 0 1

]

 AFQ B equivalente δ(q₁, 0) = {q₁} δ(q₁, 1) = {q₁} q_init = {q₀} Q_ac = {q₁} δ(q₀, 0) = {q₀ ,q₁} δ(q₀, 1) = {q₁} Q = {q₀,q₁} Σ = {0, 1} U₁(|0〉|0〉) = |0〉|1〉 U₁(|0〉|1〉) = |0〉|0〉 U₁(|1〉|0〉) = |1〉|1〉 U₁(|1〉|1〉) = |1〉|0〉

Circuito Quântico para

AFQ ancilla

Circuito Quântico para

AFQ ancilla

Circuito Quântico para

AFQ ancilla

 Para |w| = n e Σ = {0,1}

Usa 2k qubits para as entradas das

portas Us Usa n qubits para

Circuito Quântico para

AFQ ancilla

 Para |w| = n e Σ = {0,1}

Usa 2k qubits para as entradas das

portas Us Usa n qubits para

representar w

Usa k qubits extras no estado |0〉 para cada

Circuito Quântico para

AFQ ancilla

 Para |w| = n e Σ = {0,1}

Usa 2k qubits para as entradas das

portas Us Usa n qubits para

representar w

Usa k qubits extras no estado |0〉 para cada

símbolo da entrada w

O número de qubits necessários é

h = (k+1). n + 2k

Circuito Quântico para

AFQ ancilla

Circuito Quântico para

AFQ ancilla

 Para |w| = n e Σ = {0,1}

Usa 2 portas X para

cada símbolo da

Circuito Quântico para

AFQ ancilla

 Para |w| = n e Σ = {0,1}

Usa 2 portas X para

cada símbolo da

entrada

Usa 2 portas U para

cada símbolo da

Circuito Quântico para

AFQ ancilla

 Para |w| = n e Σ = {0,1}

Usa 2 portas X para

cada símbolo da

entrada

Usa 2 portas U para

cada símbolo da

entrada

Usa 2 portas SWAP para cada n - 1 símbolos da entrada

Circuito Quântico para

AFQ ancilla

 Para |w| = n e Σ = {0,1}

Usa 2 portas X para

cada símbolo da

entrada

Usa 2 portas U para

cada símbolo da

entrada

Usa 2 portas SWAP para cada n - 1 símbolos da entrada

O número de portas necessárias é

p = (2.X + 2.U). n + 2.SWAP.(n - 1)

Conclusão

 Introduzimos didaticamente a computação

quântica a partir de referências da teoria da computação clássica.

 Mostramos uma das vantagens no uso de

Autômatos Quânticos

 Um AFN pode ser implementado diretamente em

hardware quântico sem levar a uma explosão de estados, como acontecia no caso clássico.

 O modelo de AFQ com qubits auxiliares preserva a

linguagem reconhecida e pode ser implementado com custo em escala polinomial ao tamanho da entrada.

Bibliografia

 Ambainis, A. and Freivalds, R. (1998) “1-Way

Quantum Finite Automata: Strengths, Weaknesses and Generalizations”, FOCS 1998 Proceedings of the 39 Annual Symposium on Foundations of

Computer Science: 332-341

 Kondacs, A and Watrous, J. (1997) “On the Power

of Quantum Finite State Automata”, FOCS 1997: 66-75

 Moore, C and Crutchfield, J. P. (2000) “Quantum

automata and quantum grammars”, In: Theor. Comput. Sci 237(1-2): 275-30

Bibliografia

 Nielsen, M. A. and Chuang, I. L. (2000) Quantum

Computation and Quantum Information. Cambridge University Press

 Paschen, K. (2000) “Quantum finite automata

using ancilla qubits”, University of Karlsruhe, Technical report

 Hopcroft, J. E., Motwani, R. and Ullman, J. D.

(2001) Introduction to Automata Theory,

Languages and Computation. Addison-Wesley Publishing Company