What is the order of pattern matching?

[dglopes]

The code below is an attempt to go through a phrase and look for spans that match the patterns. I have many patterns to perform the search, but here I am only showing one group that inserts the label "COMPONENT" into the Span.
See that I'm storing the patterns in a dictionary with the "padroes" variable:

padroes = [
     {"label": "COMPONENT", "pattern": [
         [{"POS": "NOUN"},{"POS": "ADP"},{"POS": "NOUN"},{"POS": "ADJ"}],
         [{"POS": "NOUN"},{"POS": "ADP"},{"POS": "ADJ"}],
         [{"POS": "NOUN"},{"POS": "ADP"},{"POS": "NOUN"}],
         [{"POS": "NOUN", "DEP": "nsubj"},{"POS": "ADJ"},{"POS": "ADJ"}],
         [{"POS": "NOUN", "DEP":"nsubj"}],
         [{"POS": "NOUN"},{"POS": "ADJ"}]
     ]}
]

Given the text:
text = "Os edifícios multifamiliares devem ser providos de proteção contra descargas atmosféricas, atendendo ao estabelecido na ABNT NBR 5419 e demais Normas Brasileiras aplicáveis, nos casos previstos na legislação vigente."

The expected results is:

Semantic Object 4: proteção contra descargas atmosféricas (COMPONENT)
POS of each token: ['NOUN', 'ADP', 'NOUN', 'ADJ']

But it only returns:

Semantic Object 4: proteção contra descargas (COMPONENT)
POS of each token: ['NOUN', 'ADP', 'NOUN']

It is using the 3th pattern on the dictionary and as Im using a function to make a search in the pattern order, I expected the first pattern to be used was: [{"POS": "NOUN"},{"POS": "ADP"},{"POS": "NOUN"},{"POS": "ADJ"}]

Here the code Im using:

import spacy
from spacy.matcher import Matcher
!python -m spacy download pt_core_news_md

text = "Os edifícios multifamiliares devem ser providos de proteção contra descargas atmosféricas, atendendo ao estabelecido na ABNT NBR 5419 e demais Normas Brasileiras aplicáveis, nos casos previstos na legislação vigente."

nlp = spacy.load("pt_core_news_md")
doc = nlp(text)


#Patterns dictionary
padroes = [
     {"label": "COMPONENT", "pattern": [
         [{"POS": "NOUN"},{"POS": "ADP"},{"POS": "NOUN"},{"POS": "ADJ"}],
         [{"POS": "NOUN"},{"POS": "ADP"},{"POS": "ADJ"}],
         [{"POS": "NOUN"},{"POS": "ADP"},{"POS": "NOUN"}],
         [{"POS": "NOUN", "DEP": "nsubj"},{"POS": "ADJ"},{"POS": "ADJ"}],
         [{"POS": "NOUN", "DEP":"nsubj"}],
         [{"POS": "NOUN"},{"POS": "ADJ"}]
     ]}
]

#Function to process the sentence sequentially
#to avoid multiple matches of the same word

from spacy.matcher import Matcher
from spacy.tokens import Span

def buscar_padroes_sequencialmente(doc, padroes):
    resultados = []
    tokens_processados = set()

    for padrao in padroes:
        label = padrao["label"]
        matcher = Matcher(doc.vocab)
        
        for i, padrao_atual in enumerate(padrao["pattern"]):
            matcher.add(f"{label}", [padrao_atual])

        for padrao_id, inicio, fim in matcher(doc):
            rótulo = matcher.vocab.strings[padrao_id]

            # Checks if any pattern token has already been processed previously
            if any(token.i in tokens_processados for token in doc[inicio:fim]):
                continue

            # Adds the pattern tokens to the set of processed tokens
            tokens_processados.update(token.i for token in doc[inicio:fim])

            # Converts matching tokens to a Span and adds to the list
            span = Span(doc, inicio, fim, label=rótulo)
            resultados.append((rótulo, span))

    return resultados

#executing the function "buscar_padroes_sequencialmente"
resultados = buscar_padroes_sequencialmente(doc, padroes)

# Print results
print("Frase:", frase)
for i, (rotulo, span) in enumerate(resultados, start=1):
    
    pos_tokens = [token.pos_ for token in span]

    print(f"Semantic Object {i}:", span.text, f'({rotulo})')
    print("POS of each token:", pos_tokens)
    print()

My problem is that in the code above, even if I arrange the patterns in the order I want, the function to perform the match "skips" some patterns and seems to only return the result obtained by the pattern [{"POS": "NOUN"} ,{"POS": "ADP"},{"POS": "NOUN"}], even if the order of it and other patterns changes in the dictionary. Only when it is deleted does the first pattern participate in the search.

After some research I found the argument "greedy" and it resolve the problem.
BUT...
When using the "greedy" argument in matcher.add, I can change the result... in a strange way.
When using "greedy= "FIRST", it searches for the first match in the sentence, but also uses the largest (correct) pattern and does not repeat the mentioned error (!)
When using "greedy = "LONGEST", it searches for the largest match, that is, it solves my search.