PROPOSTA DE UM ALGORITMO DE ENUMERAÇÃO DE VÉRTICES DE UM

POLIEDRO BASEADO EM PIVOTAMENTOS

CAIO LOPES ASSAD

UNIVERSIDADE ESTADUAL DO NORTE FLUMINENSE DARCY RIBEIRO -

UENF

CAMPOS DOS GOYTACAZES - RJ

2019
PROPOSTA DE UM ALGORITMO DE ENUMERAÇÃO DE VÉRTICES DE UM
POLIEDRO BASEADO EM PIVOTAMENTOS

CAIO LOPES ASSAD

Dissertação apresentada ao Centro de Ciência

e Tecnologia (CCT) da Universidade Estadual
do Norte Fluminense Darcy Ribeiro (UENF),
como parte dos requisitos necessários à
obtenção do título de Mestre em Engenharia de
Produção.

Orientadora: Prof. Gudelia Morales de Arica, D. Sc.

Coorientador: Prof. Jose Arica, D. Sc.

UNIVERSIDADE ESTADUAL DO NORTE FLUMINENSE DARCY RIBEIRO -

UENF

CAMPOS DOS GOYTACAZES - RJ

2019
 RESUMO

Este trabalho apresenta uma proposta de algoritmo, baseado em pivotamentos

das tabelas Simplex Primal, para resolver o problema de enumeração de
vértices de um poliedro. Saber se esta enumeração dos vértices, que definem
um poliedro convexo limitado, conhecido como polítopo, pode ser feita em
tempo polinomial é ainda um problema aberto da teoria poliedral, da geometria
computacional e da otimização combinatória. O problema consiste em
enumerar os vértices de um poliedro 𝑃 = {𝑥 ∈ ℜ : 𝐴𝑥 ≤ 𝑏, 𝑥 ≥ 0}, onde 𝐴 ∈
×
ℜ e 𝑏 ∈ ℜ , com 𝑚 ≥ 𝑛. A ideia principal do algoritmo proposto é converter
o problema original num problema de programação linear de maximização
equivalente e, para sair de alguma degeneração, usar as mudanças de bases
lexicográficas. O algoritmo proposto é ilustrado por seu pseudocódigo
programado em ambiente MATLAB. A verificação numérica é e comparada
com um algoritmo existente na biblioteca do sistema computacional utilizado.

Palavras chave: enumeração de vértices; politopos; simplex lexicográfico;

otimização linear
 Abstract
This paper presents an algorithm proposal based on Simplex Primal’s tables
pivots, to solve the polyhedron vertex enumeration problem. Know if this vertex
enumeration, which define a limited convex polyhedron, known as a polytope,
can be done at a polynomial time, still is an open problem of the polyhedral
theory and combinatory optimization. The problem consists in enumerate the
×
vertices of a polyhedron 𝑃 = {𝑥 ∈ ℜ : 𝐴𝑥 ≤ 𝑏, 𝑥 ≥ 0}, where 𝐴 ∈ ℜ and 𝑏 ∈
ℜ , with 𝑚 ≥ 𝑛. The main idea of the proposed algorithm is to convert the
original problem into an equivalent maximization linear programming problem
and, to leave the degenerations, use the lexicographic bases changes. The
proposed algorithm is illustrated by its pseudocode programmed in the Matlab
program. The numerical verification is illustrated via a numerical examples and
compared with an existing algorithm in the used computer system library.

Keywords: Vertex enumeration; polytopes; lexicographic Simplex; linear

optimization
 Agradecimentos
Em primeiro lugar agradeço a Deus por essa oportunidade, pois todas as
minhas conquistas foram graças a todas as bençãos que recebo em minha
vida.
Agradeço à minha família, principalmente, meus pais Marcelo e Débora, minha
esposa Bárbara por todo amor, carinho e paciência comigo e com meus
problemas da pesquisa e meu irmão Lucas por estarem sempre ao meu lado
cuidando de mim e me ajudando a tomar as decisões certas para minha vida.
Também todos meus avós, tios e primos que me inspiram e me ajudam de
diversas formas.
Agradeço também a todos os meus professores, principalmente aos meus
professores orientadores Jose e Gudelia Arica por toda a paciência e atenção
que tiveram comigo durante essa jornada.
Por último, mas não menos importante, agradeço à CAPES por ter financiado
essa pesquisa, e continuar acreditando na importância da ciência para a nossa
nação.
 Índice
Índice de Figuras ........................................................................................................ viii
Capítulo 1 - Introdução ................................................................................................. 1
1.1 Contextualização ................................................................................................. 1
1.2 Objetivos da pesquisa ......................................................................................... 2
1.2.1 Objetivo geral................................................................................................ 2
1.2.2 Objetivos específicos .................................................................................... 2
Capítulo 2 – Revisão Teórica ........................................................................................ 4
2.1 Poliedros e Definições ......................................................................................... 4
2.2 Enumeração dos vértices .................................................................................... 7
2.2.1 Método Lexicográfico .................................................................................... 8
2.3 Grafo Dirigido associado aos vértices do programa linear ................................. 10
Capítulo 3 - Metodologia ............................................................................................. 14
3.1 Tipo de pesquisa ............................................................................................... 14
3.2 Algoritmo proposto para enumeração dos vértices ............................................ 14
Capítulo 4 – Exemplos Numéricos .............................................................................. 17
Capítulo 5 – Programação em Matlab ......................................................................... 22
5.1 Exemplo Numérico ............................................................................................ 22
5.2 Exemplos complementares ............................................................................... 30
5.2.1 Exemplo 1 ................................................................................................... 30
5.2.2 Exemplo 2 ................................................................................................... 34
5.3 Dificuldades Encontradas .................................................................................. 37
5.4 Comparação com o con2vert.m ......................................................................... 39
5.4.1 Comparação com o exemplo principal ........................................................ 39
5.4.2 Comparação com o exemplo complementar 1 ............................................ 40
5.4.2 Comparação com o exemplo complementar2 ............................................. 41
Capítulo 6 - Conclusões.............................................................................................. 43
Referências ................................................................................................................ 45
anexo A – Mapeamento completo do poliedro (12) ..................................................... 47
Apêndice..................................................................................................................... 48
 ÍNDICE DE FIGURAS
Figura 1 - Vértices e aresta definidos pelas bases viáveis ℋ e ℱ do programa linear
(5), onde 𝑞 ∈ ℋ, 𝑝 ∉ ℋ, ℱ = ℋ ∪ 𝑝\{𝑞} e 𝑧ℋ < 𝑧ℱ. ................................................... 10
Figura 2 - Vértices e aresta definidos pelas bases ℋ e ℱ do programa linear (5), onde
𝑞 ∈ ℋ, 𝑝 ∉ ℋ, ℱ = ℋ ∪ 𝑝\{𝑞} e 𝑧ℋ = 𝑧ℱ. .................................................................. 11
Figura 3 - Obtenção das tabelas 𝑇(𝑟; 𝑘, 𝑠), 𝑇(𝑘; 𝑟, 𝑠) e 𝑇(𝑠; 𝑘, 𝑟), por mudança de
bases, umas a partir das outras, por uma única variável. ........................................... 12
Figura 4 - Ilustração do poliedro (12), mostrando vértices relevantes (note que a
pirâmide EFIJK de base EFIJ não pertence ao poliedro definido pelas restrições em
(12)). ........................................................................................................................... 18
Figura 5 - Ilustração do poliedro (12), mostrando os seus vértices, o vértice inicial I e
as sequências de vértices encontrados pelo algoritmo (na ordem: vermelho, azul,
verde). ........................................................................................................................ 20
Figura 6 - Sequencias de vértices do poliedro (12) encontradas pelo algoritmo, a partir
do vértice 𝐼0: {9,11,12}. ............................................................................................... 21
Figura 7 - Dados necessários para execução do programa na linguagem Matlab ...... 23
Figura 8 - Tabela simplex do vértice I, vértice inicial necessário para o algoritmo
proposto. (saída do Matlab) ........................................................................................ 24
Figura 9 - Tabela simplex organizada para representar o vértice I inicial, no algoritmo
proposto...................................................................................................................... 25
Figura 10 - Tabela dos valores organizados lexicograficamente. Primeira iteração do
algoritmo proposto ...................................................................................................... 26
Figura 11 -“TabelaTrocas” após permutar as variáveis 9 e 10 .................................... 26
Figura 12 - Última "tabelaTrocas" para a base (1,2,3,4,5,6,7,8,10) do algoritmo
proposto...................................................................................................................... 27
Figura 13 - Matriz dos vértices encontrados pelas iterações do algoritmo proposto.... 28
Figura 14 - Matriz dos vértices encontrados pelo algoritmo proposto.......................... 29
Figura 15 - Tempo de execução do algoritmo proposto extraído de relatório fornecido
pelo Matlab ................................................................................................................. 30
Figura 16 – Gráfico do Poliedro definido por (13), exemplo complementar 1 .............. 31
Figura 17 - Dados para o exemplo complementar 1 na linguagem do Matlab ............. 32
Figura 18 - Matriz dos vértices encontrados para o exemplo complementar 1 ............ 33
Figura 19 - Matriz dos vértices do poliedro do exemplo complementar 1 .................... 33
Figura 20 - Tempo de execução do programa para o exemplo complementar 1,
extraído de relatório fornecido pelo Matlab ................................................................. 34
Figura 21 - Dados para o exemplo complementar 2 na linguagem do Matlab ............. 35
Figura 22 - Matriz dos vértices encontrados para o exemplo complementar 2, extraído
do relatório fornecido pelo Matlab ............................................................................... 36
Figura 23 - Matriz dos vértices do poliedro do exemplo complementar 2, extraído do
relatório fornecido pelo Matlab .................................................................................... 36
Figura 24 - Tempo de execução do programa para o exemplo complementar 2,
extraído do relatório fornecido pelo Matlab ................................................................. 37
Figura 25 - Tempo de execução do con2vert.m para o exemplo principal, extraído do
relatório fornecido pelo Matlab .................................................................................... 40
Figura 26 - Tempo de execução do con2vert.m para o exemplo complementar 1,
extraído do relatório fornecido pelo Matlab ................................................................. 41
Figura 27 - Vértices encontrados pelo con2vert.m no exemplo complementar 2,
extraído do relatório fornecido pelo Matlab e associados aos vértices manualmente.. 41
Figura 28 - Tempo de execução do con2vert para o exemplo complementar 2, extraído
do relatório fornecido pelo Matlab ............................................................................... 42
Figura 29 – Mapeamento completo do Poliedro (12)................................................... 47
Figura 30 - O desenho da esquerda mostra o fecho convexo de um conjunto Ω_1, de
pontos discretos (representado pelos pontos em preto), e o desenho da direita mostra
o fecho convexo de Ω_2 formado pelas duas elipses em cinza. ................................. 48
Figura 31 - Mostram-se as configurações de 1-simplex em R, 2-simplex (um triângulo)
em R^2, e um 3-simplex (tetraedro em ℜ3) ................................................................ 49
 CAPÍTULO 1

INTRODUÇÃO

1.1 CONTEXTUALIZAÇÃO
O problema de enumeração de vértices de um poliedro convexo limitado
(descrito por um conjunto de restrições lineares), denominado politopo, é uma
questão bastante abordada na literatura. Reimers e Stougie (2016)
estabelecem “O problema aberto é provar ou mostrar que existe uma forma de
enumeração dos vértices de um poliedro via um algoritmo de complexidade
polinomial”. Esse problema é dividido em diversas classificações, como
problemas com um tempo de execução limitado polinomialmente “com relação
ao número de vértices do politopo”. Para algoritmos baseados em poliedros
que não apresentam degeneração nos seus vértices, existem algoritmos que
rodam em tempo polinomial em relação ao número de vértices, mas a
existência de algoritmos de tempo polinomial para o caso geral não está
resolvida.

A enumeração de vértices é um problema conhecido na literatura.

Khachiyan et al. (2008) e Avis e Fakuda enumeram alguns trabalhos
importantes abordando a enumeração de faces da envoltória convexa de um
conjunto de pontos (Avis e Fakuda) e a geração de todos os ciclos, de custo
negativo, de um grafo ponderado (Khachiyan et al.). Existem
fundamentalmente duas abordagens de métodos para enumeração de vértices:
baseados em pivotamentos e baseados na “descrição dupla” (double
decription) de um poliedro, que enumera os raios extremos de um cone
poliédrico. Na primeira abordagem, inicia-se a partir de um vértice dado através
de pivotamentos do tipo simplex da programação linear. Existe uma dificuldade
associada a determinar se um dado vértice já foi ou não encontrado, visto que
os vértices se armazenam numa determinada árvore. Diversas implementações
de complexidade polinomial se encontram na literatura (cf. Dyer, 1983). A
segunda abordagem, baseia-se no método da “descrição dupla” de Motzkin et
al. (1953), na qual o poliedro se constrói sequencialmente, adicionando uma

1
restrição a cada vez e onde os novos vértices produzidos estão no hiperplano
definido pela restrição que entra.
Neste trabalho é apresentada uma proposta baseada na abordagem que
utiliza os pivotamentos e mudanças de base do método Simplex-primal da
Programação Linear. A ideia principal do algoritmo proposto é converter as
equações que definem um poliedro num problema de maximização de
programação linear equivalente. Sob a hipótese de conhecer um dado vértice
do poliedro, determinam-se diversos caminhos compostos por arestas e
vértices do poliedro original. Convertendo as equações do poliedro em
restrições de um problema de maximização linear, foi utilizada a abordagem do
método Simplex, para encontrar os pontos onde podemos mudar de base.
Enquanto o método Simplex escolhe apenas o valor mais negativo nos
coeficientes associados à função objetivo, na tabela do Simplex (para encontrar
um ponto melhor ao anterior), na abordagem proposta serão buscados todos
os possíveis pontos para mudança de base. Por conta desta estratégia,
podem-se encontrar diversas bases degeneradas. Sabendo disso, o algoritmo
é baseado na abordagem Lexicográfica do método Simplex, evitando assim,
problemas de ciclagem no algoritmo proposto.
Em relação à programação de algoritmos de busca de vértices, pode-se
mencionar o código da função em Matlab “con2vert” criada por Kleder (2005),
em que utiliza uma abordagem do Simplex primal-dual. Ao final deste trabalho
o algoritmo proposto foi comparado com esse código em relação ao tempo de
execução.

1.2 OBJETIVOS DA PESQUISA

1.2.1 Objetivo geral

O objetivo deste trabalho é apresentar um algoritmo que resolva o problema
de enumeração de vértices de um poliedro convexo, baseado em pivotamentos
da tabela Simplex-Primal competitivo em relação a sua complexidade.

1.2.2 Objetivos específicos

2
 Os objetivos específicos do presente estudo encontram-se relacionados nos
itens a seguir:
 Analisar a abordagem teórica do assunto, fornecendo base suficiente
para comprovar a possibilidade o algoritmo proposto funcionar
corretamente;
 Programar o algoritmo proposto para qualquer tipo de poliedro
convexo limitado (polítopo) baseado nos fundamentos teóricos
apresentados;
 Comprovar a efetividade do algoritmo em enumerar os vértices de
um poliedro;
 Apresentar o funcionamento do algoritmo com exemplos numéricos.

Este trabalho segue a seguinte conformação: No Capítulo 1, é apresentada

a introdução e os objetivos da pesquisa. No Capítulo 2, é apresentada a
revisão teórica utilizada para a elaboração da pesquisa, como a definição do
Poliedro e a abordagem lexicográfica. No Capítulo 3 é discutida a Metodologia
empregada e é apresentado o pseudocódigo do algoritmo elaborado. No
Capítulo 4 é apresentado um exemplo numérico, resolvido sem utilizar o
programa elaborado em MATLAB, que servirá como referência do código de
programação computacional. No Capítulo 5 é discutido a programação do
algoritmo em MATLAB, assim como as dificuldades encontradas e o seu
funcionamento passo a passo. Por fim, no Capítulo 6 são discutidas as
conclusões da pesquisa.
Além da conformação utilizada, é importante mencionar que quando as
figuras estiverem sem a fonte especificada abaixo da imagem, significa que são
de autoria própria.

3
 CAPÍTULO 2

REVISÃO TEÓRICA

2.1 POLIEDROS E DEFINIÇÕES

No contexto desse trabalho, define-se um poliedro 𝑃 como o conjunto
solução do sistema de 𝑚 desigualdades lineares em 𝑛 variáveis não negativas,
como:

𝑃 = {𝑥 ∈ ℜ : 𝐴𝑥 ≤ 𝑏, 𝑥 ≥ 0} (1)

×
onde 𝐴 ∈ ℜ e 𝑏 ∈ ℜ , com 𝑚 ≥ 𝑛. Assume-se, também aqui, que 𝑃 é
limitado (i.e., que é um polítopo).
Um vértice de um poliedro 𝑃 é um elemento 𝑥 ∗ ∈ 𝑃 que satisfaz, como
igualdades, um conjunto linearmente independente de 𝑛 das (𝑚 + 𝑛)
desigualdades que definem o poliedro 𝑃.
Um problema de otimização linear, ou de programação linear formula-se como
segui: OL ou PL: 𝑀𝑎𝑥𝑖𝑚𝑖𝑧𝑎𝑟 𝑓(𝑥) = 𝑐 𝑥

𝐴𝑥 ≤ 𝑏
𝑥≥0
Onde o conjunto de restrições está definido pelo poliedro P e tem como
objetivo maximizar a função linear 𝑐 𝑥.
O método simplex, DANTZIG e THAPA (1997); TAHA (2008), é o
algoritmo que resolve problemas de otimização linear, encontrando um vértice
ótimo pesquisando apenas um subconjunto dos K vértices do poliedro P, com
estratégias de melhora a cada iteração.
A estratégia do algoritmo simplex, que resolve um problema de PL,
responde a duas perguntas que devem ser feitas ao encontrar cada novo
vértice (ou, como se verá na Proposição 1, uma nova solução básica viável)
1. Esse vértice (ou solução básica) encontrado(a) é ótimo(a)?
2. Caso o vértice não seja ótimo, como determinar outro (ou outra
solução básica viável) melhor?
Isto, seguindo o critério de decisão ou função objetivo do problema PL, definido
pela função 𝑓(𝑥) = 𝑐 𝑥.

4
 Assume-se, neste trabalho, que se conhece um vértice 𝑥 ∗ ∈ 𝑃. Para o
algoritmo a ser proposto, não é necessário assumir que todos os vértices de P
são simples.
Em Otimização Linear um vértice se chamará de simples quando uma
solução básica do problema de PL está associada a uma única base. Quando
existem bases diferentes definindo um mesmo vértice o vértice é chamado de
vértice que apresenta degeneração,
O conjunto de pontos do poliedro 𝑃 ou soluções das desigualdades em (1),
podem-se escrever como soluções do sistema,
𝑥
[𝐴 𝐼] 𝑠 = 𝑏
, (2)
𝑥 ≥ 0, 𝑠 ≥ 0
× 𝑥
onde 𝐼 ∈ ℜ denota a matriz identidade, e o vetor ∈ℜ , solução de
𝑠
(2), é vértice do poliedro 𝑃 se é solução única de 𝑛 das igualdades que
determinam (2).
𝑥
Seja ℬ ⊆ {1, … , 𝑛, 𝑛 + 1, … 𝑛 + 𝑚} e 𝑦 = ∈ℜ , denota-se por 𝑦 o
𝑠
subvector de 𝑦 e por B a submatriz de [𝐴 𝐼 ] que consistem das componentes
e das colunas indexadas por ℬ, respectivamente. Se o posto da submatriz B é
|B| = 𝑚 e a matriz B é não singular, diz-se que B é uma base de [A I].
𝑦
Considere a solução de (2) associada a uma base 𝐵, dada por 𝑦 = 𝑦 =

𝐵 𝑏 . O vetor 𝑦 = 𝐵 𝑏 é denominado solução básica de (2) e se 𝑦 =

0
𝐵 𝑏 ≥ 0, diz-se que a base 𝐵 é viável. Desde que, por hipótese, supõe-se
conhecido um vértice 𝑥 ∈ 𝑃, assume-se que se conhece uma base viável 𝐵 de
[𝐴 𝐼 ] que o determina. O vértice 𝑥 ∈ 𝑃 se diz associado à base 𝐵.

Permutando adequadamente as colunas da matriz [𝐴 𝐼 ] e os índices do

vetor determinado pelo vértice 𝑥 ∈ 𝑃, a base 𝐵 pode ser decomposta em
vetores coluna da matriz 𝐴 e da matriz 𝐼, como ℬ = ℬ ∪ ℬ , com ℬ ⊆ {1, … , 𝑛},
ℬ ⊆ {𝑛 + 1, … 𝑛 + 𝑚}, |ℬ | = 𝑛 ≤ 𝑛, |ℬ | = 𝑛 ≤ 𝑚 e 𝑛 + 𝑛 = 𝑚, de forma
𝑥 𝑥 𝑥 𝑠 0
que soluciona (1), para 𝑥 = 𝑥 = e𝑠= 𝑠 = 𝑠 , onde 𝑥 e
𝑠 0

5
𝑠 são os subvetores de 𝑥 e 𝑠 cujos índices não estão em ℬ nem em ℬ ,
𝑥
respectivamente; i.e., soluciona o sistema:
𝑠
𝑠 0 𝑏
𝐵𝑥 +𝑁 𝑥 + + 𝑠 =
0 𝑏 (3)
𝑥 ≥ 0, 𝑥 ≥ 0, 𝑠 ≥ 0, 𝑠 ≥ 0

É importante ressaltar que a matriz 𝐵 pode ser decomposta em

𝐵 𝑥
submatrizes , de forma a que 𝑠 soluciona o sistema:
𝐵
𝐵 0 𝑥 𝑏
𝑠 = ,𝑥 ≥ 0, 𝑠 ≥0 (4)
𝐵 𝐼 𝑏

𝐵 0
Sendo 𝐵 = 𝐵 𝐼 não singular, resulta que 𝐵 é não singular, e de (4),

×
𝑥 =𝐵 𝑏 ≥0 e 𝑠 =𝑏 −𝐵 𝐵 𝑏 ≥ 0, onde 𝐼 ∈ℜ é uma matriz
𝑥 𝐵 𝑏
identidade. O vetor 𝑠 = ≥ 0 é solução básica viável de
𝑏 −𝐵 𝐵 𝑏
(2) associada à base 𝐵.
Note que outros vértices do poliedro 𝑃 podem ser encontrados
determinando outras bases viáveis da matriz [𝐴 𝐼 ].

Proposição 1. Sejam P um poliedro não-vazio e 𝑥 ∗ ∈ P. Então, as

seguintes afirmações são equivalentes:
(a) 𝑥 ∗ é um vértice.
(b) 𝑥 ∗ é uma solução básica viável.
Prova: Ver o Teorema 2.3 do livro de Bertsimas e Tsilsiklis (1997), pag. 50-51.
Proposição 2. Considere o sistema (2) e 𝐵 = [𝐵 𝐵 ] uma base viável da
matriz [𝐴 𝐼 ], com 𝐵 submatriz de 𝐴 e 𝐵 submatriz de 𝐼. Se a solução básica
𝑥 𝑥 𝑥
associada à base 𝐵 é 𝑠 , então 𝑥 = 𝑥 = é vértice do poliedro 𝑃.
0
Prova:
Segue imediatamente da definição de vértice do poliedro 𝑃.

6
 Da proposição 1 está mostrando que todo vértice de um poliedro está
associado a uma solução básica e vice-versa, o que forma parte do sustento
algébrico e geométrico do método Simplex

2.2 ENUMERAÇÃO DOS VÉRTICES

As bases da matriz [𝐴 𝐼 ] que interessam para determinar vértices do
poliedro 𝑃 podem ser encontradas, considerando o seguinte programa linear,
associado à relação (3):

𝑚𝑎𝑥𝑖𝑚𝑖𝑧𝑎𝑟 𝑧= 𝑠
∈
𝑥
𝐵 𝑁 𝐼 0 𝑥 𝑏 (5)
𝑠 =
𝐵 𝑁 0 𝐼 𝑏
𝑠
𝑥 ≥ 0, 𝑥 ≥ 0, 𝑠 ≥ 0, 𝑠 ≥ 0

𝑥 𝐵 𝑏 𝑠 0
Nota-se que 𝑥 = 𝑥 = e 𝑠= 𝑠 = 𝑏 −𝐵 𝐵 𝑏 é uma
0
𝑥
solução viável para o programa linear (5), com variáveis básicas 𝑠 ,

𝐵 0
associadas à base 𝐵 𝐼 .
𝐵 0
Assim, a tabela do Método Simplex associada à base 𝐵 𝐼 para o

programa linear (5) está determinada, permutando as colunas se necessário,

pela seguinte matriz denotada por 𝑇:

𝑇= 𝑇 =

𝑥 𝑠 𝑥 𝑠 𝑑
⎡ ⎤
⎛ 0 0 0 0 −1 … − 1⎞ ⎢ 𝑑 ⎥ (6)
⎜ 𝐵 𝑏 𝐼 0 𝐵 𝑁 𝐵 ⎟=⎢ ⋮ ⎥

⎝𝑏 −𝐵 𝐵 𝑏 0 𝐼 𝑁 −𝐵 𝐵 𝑁 −𝐵 𝐵 ⎠ ⎣𝑑 ⎦

Na parte superior da matriz 𝑇, relação (6), a partir da segunda coluna,

mostra-se a associação das colunas com as variáveis básicas (𝑥 e 𝑠 ) e não
básicas (𝑥 e 𝑠 ) correspondentes a 𝑥 e a 𝑠, respectivamente. Nota-se que a

7
primeira coluna de 𝑇, [𝑇 ] , corresponde, respectivamente, ao valor da
função objetivo do programa linear (5), 𝑇 = 𝑧 = 0, avaliada na solução atual,
𝑥
, e às variáveis básicas, [𝑇 ] ∈ℬ = 𝑥 = 𝐵 𝑏 ≥ 0 e [𝑇 ] ∈ℬ = 𝑠 =
𝑠
𝑏 −𝐵 𝐵 𝑏 ≥ 0. As entradas da primeira linha de 𝑇, a partir da segunda
componente, 𝑇 , correspondem aos custos reduzidos das variáveis

básicas e não básicas associadas à base atual, identificadas na relação (5).

A tabela 𝑇 é viável, mas não é ótima para o programa linear (5). Pode-
se, portanto, eventualmente, melhorar o valor da função objetivo mudando a
base atual, substituindo uma das variáveis básicas por outra não básica. Dado
que pode existir degeneração na tabela 𝑇, a mudança de base pode ser
realizada usando regras que asseguram a terminação finita do Método
Simplex, como, por exemplo, o critério lexicográfico (cf. Blum e Oettli, 1975,
Capítulo 2) ou a regra de Bland (Bland, 1977). Assim, a geração de novas
bases viáveis, a partir da matriz 𝑇, determinará novos vértices do poliedro 𝑃.
Ambas as regras citadas para a terminação finita do Método Simplex
(critério lexicográfico e a regra de Bland) são usadas na literatura para tratar
com degeneração, possuindo vantagens e desvantagens: “Regra de Bland (...)
sua desvantagem é que a escolha da coluna de entrada pode não ser uma boa
escolha” (Dantzing e Thapa, 1997, p. 160; tradução livre); “A primeira e mais
utilizada ferramenta [para garantir a terminação finita de métodos simplex] é a
regra simplex lexicográfica” (Terlaky, 2001; tradução livre); “Apesar [da regra
de Bland] ser muito mais simples do que a regra lexicográfica, normalmente
também demora muito mais para o algoritmo Simplex convergir” (Lewis, 2008,
p. 37; tradução livre). Baseado nessas afirmações, este trabalho utilizará o
método lexicográfico.

2.2.1 Método Lexicográfico

Definição 1. Dados 𝑑, 𝑓 ∈ ℜ , tem-se que 𝑑 é lexicograficamente positivo,
denotado por 𝑑 ≻ 0, se 𝑑 ≠ 0 e a primeira componente não nula for positiva.
𝑑 ≽ 0, se 𝑑 ≻ 0 𝑜𝑢 𝑑 = 0.
𝑑 ≻ 𝑓, se 𝑑 − 𝑓 ≻ 0.
Desde que (ℜ , ≽) é um conjunto totalmente ordenado, tem-se como
consequência que qualquer conjunto finito {𝑑 } ∈ ⊂ ℜ , com todos os

8
elementos diferentes, tem um único elemento 𝑑 , tal que 𝑑 ≺ 𝑑 , ∀𝑖 ∈ 𝐽. 𝑑 é
chamado mínimo lexicográfico de {𝑑 } ∈ , denotado por 𝑑 = 𝑚𝑖𝑛 𝑙𝑒𝑥 {𝑑 , 𝑖 ∈ 𝐽}.

Note queas linhas da matriz 𝑇, da segunda em diante, são

𝑥
lexicograficamente positivas (i.e., 𝑑 ≻ 0, 1 ≤ 𝑖 ≤ 𝑚), pois [𝑇 ] = 𝑠 ≥

0.
𝑥
Desde que as variáveis básicas atuais correspondem as variáveis 𝑠 ,

que na matriz 𝑇 constituem o vetor [𝑇 ] , e os custos reduzidos das

variáveis não básicas correspondem a 𝑥 e 𝑠 , que na matriz 𝑇 fazem parte
do vetor 𝑇 = (0 , −1, … , −1), o pivotamento lexicográfico está

determinado da seguinte forma:

(PivLex1): Regra para determinar a variável não básica que entra na

base: Considere como variável não básica que entra na base qualquer índice 𝑝,
tal que 𝑇 ≤ 0, 𝑚 + 1 ≤ 𝑝 ≤ 𝑛 + 𝑚
(correspondente a uma das variáveis não básicas 𝑥 , 𝑠 ).

(PivLex2): Regra para determinar a variável básica que sai da base:

Sai da base o índice 𝑞 determinado pelo pivotamentos lexicográfico, dado por:
𝑑 𝑑
= 𝑚𝑖𝑛 𝑙𝑒𝑥 : 𝑇 > 0; 1 ≤ 𝑖 ≤ 𝑚 . (7)
𝑇 𝑇

Gera-se, assim, uma nova matriz, 𝑇, que se diferencia unicamente numa

variável básica da matriz 𝑇. Denotando o conjunto de índices básicos
associados à tabela 𝑇 por ℬ , tem-se que ℬ = ℬ ∪ ℬ = ℬ ∪ {𝑝}\{𝑞}, onde ℬ
corresponde às colunas de 𝐴 e ℬ às colunas de 𝐼 na base. Aplicando,
sucessivamente, as regras do pivotamento lexicográfico ao programa linear (5),
assegura-se que o método simplex é finito (mesmo no caso de degeneração)
(Blum e Oettli, 1975, Capítulo 2).
A tabela

9
 𝑑̅
⎡ ⎤
̅
𝑇= 𝑇 = ⎢𝑑 ⎥, (8)
⎢ ⋮ ⎥
⎣𝑑̅ ⎦
obtida da tabela 𝑇, tem o seguinte formato

𝑑̅ = 𝑑 − 𝑑 ,𝑖 ≠ 𝑞
, (9)
𝑑̅ = 𝑑

Note que, como na matriz 𝑇, 𝑑̅ ≻ 0, 1 ≤ 𝑖 ≤ 𝑚; i.e., 𝑇 também é uma tabela

viável para o programa linear (4) e o vértice do poliedro 𝑃 associado a ela é 𝑥̅ =
𝑥 [𝑇 ] ∈ℬ
𝑥 = , com 𝑧 = 𝑑̅ ≥ 0.
0

2.3 GRAFO DIRIGIDO ASSOCIADO AOS VÉRTICES DO PROGRAMA

LINEAR
Considera-se um grafo dirigido cujos vértices são soluções viáveis
associadas a bases viáveis do programa linear (5), onde dois vértices são
adjacentes se as bases correspondentes se diferenciam apenas num único
índice e a direção das arestas está determinada no sentido em que a função
objetivo é não decrescente. Assim, considerando ℋ e ℱ bases que se
diferenciam num único índice e o valor da função objetivo é 𝑧ℋ e 𝑧ℱ ,
respectivamente, com 𝑧ℋ ≤ 𝑧ℱ , os vértices associados são adjacentes. Se
𝑧ℋ < 𝑧ℱ , a aresta está dirigida de ℋ para ℱ, como na Figura 1. Analogamente,
se 𝑧ℋ = 𝑧ℱ , a aresta é bidirecional, como na Figura 2.

Figura 1 - Vértices e aresta definidos pelas bases viáveis ℋ e ℱ do programa linear (5), onde 𝑞 ∈ ℋ, 𝑝 ∉
ℋ, ℱ = ℋ ∪ {𝑝}\{𝑞} e 𝑧ℋ < 𝑧ℱ .

10
Figura 2 - Vértices e aresta definidos pelas bases ℋ e ℱ do programa linear (5), onde 𝑞 ∈ ℋ, 𝑝 ∉ ℋ, ℱ =
ℋ ∪ {𝑝}\{𝑞} e 𝑧ℋ = 𝑧ℱ .

Observação 1. Se 𝛺ℋ e 𝛺ℱ denotam os conjuntos de vértices obtidos por

mudanças de base com função objetivo crescente, com as bases ℋ e ℱ como
na Figura 1, logo 𝛺ℋ ⊃ 𝛺ℱ .
Considerando a matriz viável degenerada 𝑇 ( ; , )
, onde (𝑟; 𝑘, 𝑠) indica que a
variável 𝑟 é não básica e as variáveis 𝑘 e 𝑠 são básicas que causam
degeneração quando substituídas pela primeira. A relação (10) mostra o
formato da matriz 𝑇 ( ; , )
, onde se destacam as colunas básicas 𝑘 e 𝑠 e a
coluna não básica 𝑟.
𝑘 𝑟 𝑠
( ; , ) ( ; , )
⎛𝑇 0 𝑇 0⎞
⎜ ⋮ ⋮ ⋮ ⋮⎟
𝑇 ( ; , )
= ⎜𝑇 , )
( ;
1 𝑇
( ; , )
0⎟ (10)
⎜ ⎟
⎜ ⋮ ⋮ ⋮ ⋮⎟
( ; , ) ( ; , )
𝑇 0 𝑇 1
⎝ ⋮ ⋮ ⋮ ⋮⎠

( ; , ) ( ; , )
Se 𝑇 >0 e 𝑇 > 0, cálculos simples mostram que introduzindo a
variável não básica 𝑟 na base e tirando da base as variáveis 𝑘 ou 𝑠,
respectivamente, na tabela 𝑇 ( ; , )
, geram-se as tabelas viáveis degeneradas
𝑇( ; , )
e 𝑇( ; , )
. Além disso, é possível gerar, a partir de 𝑇 ( ; , )
a tabela 𝑇 ( ; , )

e vice-versa. Portanto, pode se obter qualquer uma das três tabelas a partir de
qualquer outra. É possível notar que em todos os casos o valor da função
objetivo é o mesmo. A Figura 4 ilustra a participação no grafo das tabelas
(bases) indicadas.

11
Figura 3 - Obtenção das tabelas 𝑇 ( ; , ), 𝑇 ( ; , ) e 𝑇 ( ; , ) , por mudança de bases, umas a partir das outras,
por uma única variável.

Como consequência, os conjuntos de vértices do poliedro 𝑃, obtidos a partir

da base 𝑇 ( ; , )
ou da base 𝑇 ( ; , )
são iguais. Portanto, para a determinação
dos vértices do poliedro 𝑃 é suficiente considerar, no grafo, unicamente uma
das sequencias 𝑇 ( ; , )
e 𝑇( ; , )
ou 𝑇 ( ; , )
e 𝑇( ; , )
.

Proposição 3: Se a matriz 𝑇, dada em (6), gera a tabela 𝑇, a partir do

programa linear de maximização (5), pelas regras de pivotamento lexicográfico
e pelas relações (8) e (9), então 𝑇 pode ser gerada de 𝑇 a partir do programa
linear (5), substituindo o processo de maximização pelo de minimização, pelas
regras de pivotamento lexicográfico e pelas relações (8) e (9).

Prova:
Considerando que a tabela 𝑇 se obtém da tabela 𝑇 pela entrada da variável
não básica 𝑠 e a saída da variável básica 𝑟. Assim, 𝑇 é gerada de 𝑇
substituindo as colunas correspondentes às variáveis 𝑠 e 𝑟 pelas respectivas
colunas transformadas segundo as regras de pivotamento lexicográfico e as
relações (8) e (9); i.e.,
𝑇 𝑇 −𝑇 ⁄𝑇
⎡ ⎤ ⎡0⎤ ⎡ ⎤ ⎡ ⎤
⎢𝑇 ⎥ ⎢0⎥ ⎢𝑇 ⎥ ⎢ −𝑇 ⁄𝑇 ⎥
⎥ = ⎢ ⋮ ⎥ e [𝑇 ] ⋮
[𝑇 ] =⎢ ⋮ =⎢ ⋮ ⎥=⎢ ⎥. (11)
⎢𝑇 ⎥ ⎢1⎥ ⎢𝑇 ⎥ ⎢ 1 ⁄𝑇 ⎥
⎢ ⋮ ⎥ ⎢⋮⎥ ⎢ ⋮ ⎥ ⎢ ⋮ ⎥
⎣𝑇 ⎦ ⎣0⎦ ⎣𝑇 ⎦ ⎣−𝑇 ⁄𝑇 ⎦

12
 Nota-se que, pelas regras de transformação, 𝑇 ≤ 0, = 𝑚𝑖𝑛 𝑙𝑒𝑥 :𝑇 >

0,1 ≤ 𝑖 ≤ 𝑚 , 𝑑̅ = 𝑑 e 𝑑̅ = 𝑑 − 𝑑 , 𝑖 ≠ 𝑟. Além disso, percebe-se que

a coluna [𝑇 ] corresponde à variável básica 𝑠 e que a coluna [𝑇 ] à

variável não básica 𝑟.
Considerando, agora, o programa linear (5) como um problema de
minimização, é possível notar que a tabela 𝑇 não é ótima para este programa,
pois 𝑇 = −𝑇 ⁄𝑇 ≥ 0. Assim, a variável não básica 𝑟, correspondente à
coluna [𝑇 ] , pode entrar na base, eventualmente diminuindo o valor da
função objetivo.
Por outro lado, definida a variável que entra na base, deve ser determinada
a variável que saí da base pelas regras de pivotamento lexicográfico; i.e., o
índice da variável que saí da base corresponde àquela que determine

𝑚𝑖𝑛 𝑙𝑒𝑥 : 𝑇 > 0,1 ≤ 𝑖 ≤ 𝑚 .

Assim, considerando para 𝑖 ≠ 𝑟 e 𝑇 = −𝑇 ⁄𝑇 > 0, = ⁄

𝑑 −

𝑑 , tem-se que =− 𝑑 + 𝑑 . Assim, desde que − > 0, resulta que

≻ 𝑑 . Por outro lado, desse que = ⁄

= 𝑑 , tem-se que =

𝑚𝑖𝑛 𝑙𝑒𝑥 : 𝑇 > 0,1 ≤ 𝑖 ≤ 𝑚 .

Portanto, a variável que saí da base é a variável 𝑟. Assim, a nova base

corresponde à tabela 𝑇.

Observação 2: A proposição 3 estabelece que se, no processo de

maximização, o vértice 𝑣 (correspondente à tabela 𝑇) é obtido do vértice 𝑣
(correspondente à tabela 𝑇), pela troca da variável não básica 𝑠 pela variável
básica 𝑟, então, reciprocamente, o vértice 𝑣 pode ser obtido do vértice 𝑣 ,
mudando a maximização por minimização, considerando (na tabela 𝑇) como
variável não básica que entra a variável 𝑟 e usando as regras de pivotamento
lexicográfico. Nesse sentido, a proposição 3 estabelece que um vértice,
diferente do inicial, pertence ao grafo se, e somente se, tem um antecessor que
pertence ao grafo.

13
 CAPÍTULO 3

METODOLOGIA

3.1 TIPO DE PESQUISA

A natureza desta pesquisa pode ser classificada como aplicada, já que ela
tem o objetivo de gerar conhecimento na resolução de um problema, ainda
aberto, o da enumeração de vértices de um poliedro convexo.
Em relação à classificação dos objetivos, a pesquisa tem uma característica
exploratória, porque busca maior familiaridade com o sustento algébrico-
geométrico do método simplex amplamente abordado e foram levantadas
novas hipóteses e aplicações, que culminaram na elaboração do algoritmo
proposto.
Quando se fala sobre as abordagens o trabalho tem uma característica mais
quantitativa. Apesar de não utilizar de ferramentas estatísticas, a pesquisa
trabalhou com a programação de um código computacional que gera uma
quantidade de vértices em tempo competitivo.
Por fim, em relação aos procedimentos, a pesquisa tem um caráter
experimental, já que foi trabalhado um novo algoritmo que precisou ser
aprimorado e reestruturado no decorrer da pesquisa, experimentando sempre
novas abordagens, até ter chegado a um possível ponto ótimo.

3.2 ALGORITMO PROPOSTO PARA ENUMERAÇÃO DOS VÉRTICES

O algoritmo proposto para a enumeração dos vértices do poliedro 𝑃 =
{𝑥 ∈ ℜ : 𝐴𝑥 ≤ 𝑏, 𝑥 ≥ 0} está descrito a seguir. Trabalha-se em relação ao
programa linear (5) e, como indicado na seção 2.2, assume-se conhecido um
𝑥 𝐵𝑏 𝐵 0
vértice inicial 𝑥 = 𝑥 = , associado à base 𝐵 𝐼 da matriz
0
𝑥 𝑠 0
[𝐴 𝐼 ]. Sendo 𝑠 , com 𝑠 = 𝑠 = 𝑏 −𝐵 𝐵 𝑏 , solução de (5). Para

efeitos de desenvolvimento do algoritmo, trabalha-se coma a matriz 𝑇, da

relação (6).

Algoritmo 1. {Enumeração dos vértices de um poliedro 𝑃 convexo e limitado}

Passo 0.

14
Fazer
𝑘 ≔ 1; 𝑥 : = 𝑥; 𝑉é𝑟𝑡𝑖𝑐𝑒𝑠 ≔ {𝑥 };
ℬ ≔ {í𝑛𝑑𝑖𝑐𝑒𝑠 𝑏á𝑠𝑖𝑐𝑜𝑠 𝑑𝑒𝑡𝑒𝑟𝑚𝑖𝑛𝑎𝑑𝑜𝑠 𝑝𝑒𝑙𝑜 𝑣é𝑟𝑡𝑖𝑐𝑒 𝑥 };
ℵ ≔ 𝑁 ∪ 𝑁 ≔ {í𝑛𝑑𝑖𝑐𝑒𝑠 𝑛ã𝑜 𝑏á𝑠𝑖𝑐𝑜𝑠 𝑑𝑎𝑠 𝑣𝑎𝑟𝑖á𝑣𝑒𝑖𝑠 𝑥 e 𝑠};
𝑇 ≔ tabela associada ao vértice 𝑥 , dada em (5);
ℬ ∶= ℬ; ℵ: = ℵ; 𝐵𝑎𝑠𝑒𝑠: = {ℬ }; 𝐸𝑛𝑡𝑟𝑎𝐵𝑎𝑠𝑒: = 0; ℳ ∶= ∅.

Passo 1. (Determinação da variável não básica que entra na base)

Se ℵ = ∅, PARAR. Caso contrário, escolher o índice que entra na base 𝑝 ∈ ℵ
Fazer 𝑘 ≔ 𝑘 + 1 e ℵ: = ℵ ∖ {𝑝}. Continuar.

Passo 2. (Determinação da variável básica de índice 𝑞 que sai da base –

Determinação de um novo vértice)
Aplicar a regra de pivotamento lexicográfico (PivLex2) para determinar a
variável 𝑞 que sai da base. Fazer ℬ ≔ ℬ ∪ {𝑝}\{𝑞}. Se a base ℬ ∈ 𝐵𝑎𝑠𝑒𝑠, ir ao
Passo 3. Caso contrário, fazer 𝐵𝑎𝑠𝑒𝑠 ≔ 𝐵𝑎𝑠𝑒𝑠 ∪ ℬ , gerar a tabela 𝑇 associada
à base ℬ e gerar o vértice 𝑥 associado à base ℬ .
Se 𝑥 ∉ 𝑉é𝑟𝑡𝑖𝑐𝑒𝑠, fazer 𝑉é𝑟𝑡𝑖𝑐𝑒𝑠 ≔ 𝑉é𝑟𝑡𝑖𝑐𝑒𝑠 ∪ {𝑥 } e 𝑘 ≔ 𝑘 + 1. Caso contrário,
gerar ℵ (índices não básicos associados à base ℬ ) e ℵ ≔ {𝑗 ∈ ℵ: 𝑇 ≤ 0}. Se
|ℵ | ≥ 2, fazer 𝐸𝑛𝑡𝑟𝑎𝐵𝑎𝑠𝑒 ∶= 𝐸𝑛𝑡𝑟𝑎𝐵𝑎𝑠𝑒 + 1, ℳ ≔ ℵ , ℳ: = ℳ ∪
ℳ e continuar.

Passo 3. Se ℳ = ∅, fazer 𝐸𝑛𝑡𝑟𝑎𝐵𝑎𝑠𝑒 ≔ 𝐸𝑛𝑡𝑟𝑎𝐵𝑎𝑠𝑒 − 1. Se ℳ = ∅, ir

ao Passo 1.
Caso contrário, escolher 𝑝 ∈ ℳ e fazer ℳ ≔ℳ ∖ {𝑝}.

Passo 4. Se 𝑘 = 1, encontrar, se existirem, todos os vértices viáveis com o

mesmo nível que o último vértice encontrado (que corresponde a uma solução
ótima do programa linear (4)). Caso contrário, Ir ao Passo 2.

Teorema 1. O Algoritmo 1 é finito e encontra todos os vértices de um

poliedro 𝑃 convexo e não vazio.

Prova:

15
 Desde que o poliedro 𝑃 é convexo e limitado, o Algoritmo 1 determina, para
cada variável não básica que entra na base, no Passo 1, uma sequência de
pontos que irá terminar ou em uma solução de (5) ou em um vértice já
encontrado numa sequência anterior. Assim, sendo ℵ ≔ 𝑁 ∪ 𝑁 , conjunto
inicial de índices não básicos, no Passo 0, finito, tem-se que o Algoritmo é
finito.
Por outro lado, para provar que todos os vértices do poliedro 𝑃 são
encontrados, suponha que existe um vértice 𝑣 do poliedro que não foi
encontrado pelo Algoritmo 1. Então, de acordo à proposição 3 e à Observação
2, existe uma sequência de vértices que vai de 𝑣 , até o vértice inicial, onde
nenhum desses vértices foi encontrado pelo Algoritmo. O que contradiz o fato
de que do vértice inicial só pode sair através de um vértice que o Algoritmo 1
encontra. Portanto, todos os vértices do poliedro 𝑃 são encontrados.

16
 CAPÍTULO 4

EXEMPLOS NUMÉRICOS

Foi trabalhado um exemplo baseado no problema apresentado no artigo de

Campêlo e Scheimberg (2005). O exemplo original tratou de um problema de
programação linear de dois níveis, onde a função objetivo do líder, ou problema
do primeiro nível, foi 𝐹 (𝑥, 𝑦 , 𝑦 ) = 𝑥 − 2𝑦 + 20𝑦 . As restrições do problema
do seguidor, ou problema de segundo nível, compuseram as restrições
adicionando a função objetivo, anterior. Assim, formou-se o poliedro do qual se
buscaram todos os vértices. Então, o poliedro deste exemplo consistiu-se, das
restrições indicadas, às quais se adicionou mais uma, correspondente ao
semiespaço determinado pelos níveis menores que o plano originado pela
função do líder num vértice, chamado neste trabalho de vértice 𝐼 = (1, 1, 0,45);
i.e., 𝐹 (𝑥, 𝑦 , 𝑦 ) ≤ 8. Assim, o poliedro 𝑃 ⊂ ℜ está dado pelo conjunto de
desigualdades mostrado em (12) (onde a última restrição, EFIJ, corresponde à
restrição 𝐹 (𝑥, 𝑦 , 𝑦 ) ≤ 𝐹 (𝐼), eliminando a pirâmide de base quadrangular
KEFIJ, com a que constituiu o poliedro viável no exemplo original). A Figura 5
ilustra o poliedro 𝑃, formado pelas restrições das desigualdades na relação
(12).

𝑥 + 𝑥 + 𝑥 ≤ 3 ← 𝐵𝐶𝐺𝐹
𝑥 + 𝑥 − 𝑥 ≥ 1 ← 𝐴𝐷𝐻𝐾
−𝑥 + 𝑥 + 𝑥 ≤ 1 ← 𝐴𝐵𝐹𝐾
𝑥 − 𝑥 + 𝑥 ≤ 1 ← 𝐷𝐶𝐺𝐻
16𝑥 − 6𝑥 + 60𝑥 ≤ 37 ← 𝐹𝐼𝐺
(12)
6𝑥 − 16𝑥 + 60𝑥 ≤ 17 ← 𝐾𝐼𝐻
6𝑥 − 6𝑥 + 60𝑥 ≤ 27 ← 𝐾𝐼𝐹
16𝑥 − 16𝑥 + 60𝑥 ≤ 27 ← 𝐺𝐼𝐻
𝑥 − 2𝑥 + 20𝑥 ≤ 8 ← 𝐸𝐹𝐼𝐽
𝑥 ≥ 0, 𝑥 ≥ 0, 𝑥 ≥ 0

Para efeitos da aplicação do algoritmo, considerou--se o poliedro definido

pela relação (12) dado como um conjunto de desigualdades com variáveis
positivas (acrescentando as respectivas variáveis de folga). Assim, o poliedro

17
dado resulta um conjunto determinado por 12 restrições de desigualdade e 12
variáveis não negativas, onde as primeiras 3 variáveis correspondem a 𝑥 , 𝑥 e
𝑥 e as últimas 9 às variáveis de folga das respectivas desigualdades (𝑠 , … , 𝑠 )
correspondem a 𝑥 , … , 𝑥 .
Figura 4 - Ilustração do poliedro (12), mostrando vértices relevantes (note que a pirâmide EFIJK de base
EFIJ não pertence ao poliedro definido pelas restrições em (12)).

Para ilustrar como o algoritmo proposto, utilizando o método Simplex-Primal,

percorre os vértices do poliedro, a partir do vértice I mostrando os percursos de
identificação dos vértices sobre o poliedro, ver Figura 5. Foram apresentados
na Figura 6, numa árvore, os itinerários de identificação dos vértices do
poliedro, denotados pelas variáveis não básicas (que correspondem à
respectiva base que define o vértice) e o valor da função objetivo do problema
de programação linear nesse vértice, conforme foi apresentado na relação (5)
do capítulo 2,. Assim, por exemplo, 𝐼 : {9, 11, 12} informa que o vértice I tem
como suas variáveis não básicas associadas as variáveis numeradas por
{9, 11, 12} (quer dizer, o vértice I foi determinado pelas variáveis básicas
{1, 2, 3, 4, 5, 6, 7, 8, 10}) e que o valor da função objetivo no vértice I é 𝑧 =
∑∈ 𝑠 = 0, indicado no índice superior do vértice I.
A partir das variáveis não básicas, aplica-se o algoritmo simplex
lexicográfico para executar mudanças de base, alcançando outro vértice
adjacente (ou não, caso este seja degenerado).

18
 Portanto, a Figura 6 mostra o mapeamento realizado pelo algoritmo. O
primeiro ponto, ou o ponto de partida, é o ponto 𝐼 , com as variáveis não
básicas {9,11,12}. Na tabela simplex desse vértice (Figura 8, pag. 24) é
possível realizar a mudança de base em qualquer uma das 3 variáveis não
básicas (todas do mesmo valor, -1). Logo, têm-se 3 caminhos iniciais
diferentes: o primeiro, quando a variável 9 entra na base (mostrado em
vermelho na Figura 6); o segundo, quando a variável 11 entra na base
(mostrado em azul na Figura 6); e o terceiro, quando a variável 12 entra na
base (mostrado em verde na Figura 6). Cada caminho complementa os vértices
encontrados pelos outros caminhos, como ilustra a Figura 6. É possível
observar, portanto, que o vértice I, apresenta degeneração, pois possuí 4
planos que o definem (mais de um caminho sai dele) como pode ser observado
na Figura 5.
O algoritmo identifica as variáveis a sair e entrar na base, realizando os
respectivos pivotamentos. Por exemplo, no primeiro retângulo da Figura 6, se
encontra o ponto 𝐼 , seguindo a linha vermelha, entra à base a variável 9. No
retângulo seguinte é possível notar que a variável 8 se tornou não básica, no
lugar da variável 9. Nesse segundo retângulo ainda estamos no ponto 𝐼 , mas
associado a uma base diferente em relação ao retângulo anterior, onde as
variáveis não básicas atuais são {8,11,12}. Neste caso, verifica-se que tanto as
variáveis não básicas 11 quanto a 12, podem aumentar o valor objetivo da
função 𝑧, do programa linear (5) associado (pois ambos seus custos reduzidos
resultam negativos). Assim, ao introduzir as variáveis não básicas 11 e 12 se
geram os ramos vermelhos da esquerda e da direita, respectivamente, com os
,
vértices 𝐹 e 𝐺, indicados na Figura 6 como 𝐹 : {4,8,12} e 𝐺 : {4,8,11}.
Continuando dessa forma, chega-se à solução ótima 𝐵 : {3,4,6} e o ramo
vermelho é encerrado. Foram gerados sequencialmente os novos vértices 𝐹, 𝐵,
𝐺 e 𝐶. Analogamente, geram-se os ramos azul e verde da Figura 6,
encontrando os novos vértices 𝐽, 𝐸 e 𝐴 e 𝐻 e 𝐷, respectivamente. É possível
notar que o ramo verde finaliza em, além do vértice ótimo 𝐵, nos vértices 𝐽, 𝐶 e
𝐺, já encontrados exatamente com as mesmas bases. Observando a Figura 6 é
possível perceber que todos os vértices, do poliedro exemplo na relação (12),
foram encontrados.

19
 No Anexo A, Figura 29 (pag. 47), apresenta-se o mapeamento completo do
problema utilizando apenas o algoritmo Simplex-Primal, sem a incorporação do
código do algoritmo lexicográfico. Comparando a Figura 6 com a Figura 29 do
Anexo A, é possível notar uma significativa redução de pivotamentos para
encontrar todos os vértices. Isso ocorre principalmente pela implementação da
abordagem lexicográfica, que seleciona os melhores pontos para a realização
dos pivotamentos na tabela simplex, mesmo em bases degeneradas, como foi
encontrado diversas vezes neste exemplo. Este mapeamento ainda foi
simplificado, pois encontrando valores de bases que já haviam sido calculados,
foi determinado não continuar com o mapeamento, pois provavelmente seriam
encontrados problemas de ciclagem.

Figura 5 - Ilustração do poliedro (12), mostrando os seus vértices, o vértice inicial I e as sequências de
vértices encontrados pelo algoritmo (na ordem: vermelho, azul, verde).

20
Figura 6 - Sequencias de vértices do poliedro (12) encontradas pelo algoritmo, a partir do vértice
𝐼 : {9,11,12}.

21
 CAPÍTULO 5

PROGRAMAÇÃO EM MATLAB

5.1 EXEMPLO NUMÉRICO

Como foi dito anteriormente, o algoritmo foi programado na linguagem do
ambiente computacional do software MATLAB, e neste capítulo será
apresentado o funcionamento do código e o resultado obtido por ele. Nesse
exemplo, foram utilizados os dados do problema encontrado em Campêlo e
Scheimberg (2005), apresentado na relação (12) do Capítulo 4. Para facilitar a
compreensão do andamento do programa, serão definidos passos no início de
alguns parágrafos.
É importante mencionar que todos os exemplos foram testados na mesma
máquina e na versão do Matlab 2015a.

Passo 1: O primeiro procedimento necessário para o código encontrar os

vértices do poliedro é inserir as restrições que formam o poliedro, assim como
o resultado das suas restrições. Esses dados são inseridos separadamente,
pois serão utilizados separadamente. Para o exemplo no capítulo 4, as
restrições foram inseridas nas linhas 4 e 5, ilustrado no código da Figura 7, e
os resultados das desigualdades foram inseridos na linha 6. É importante
lembrar que no MATLAB cria-se uma matriz colocando os elementos dentro de
colchetes e que as colunas são separadas por vírgulas e as linhas por ponto e
vírgula.
Vale ressaltar que deve-se, como discutido na seção 3.1, assumir
𝑥 𝐵 𝑏
conhecido um vértice inicial 𝑥 = 𝑥 = , que é associado a uma
0
𝐵 0
base 𝐵 𝐼 da matriz [𝐴 𝐼 ]. Além disso, como foi mencionado no capítulo

4, para efeitos da aplicação do algoritmo, considera-se o poliedro (12) escrito

como um conjunto de igualdades com variáveis não-negativas (acrescentando
as respectivas variáveis de folga, segundo a relação (2) no capítulo 2), para
aplicar o método de pivotamentos do algoritmo Simplex, como foi mencionado
na relação (2) da página 5.

22
 Figura 7 - Dados necessários para execução do programa na linguagem Matlab

Portanto, segundo a Figura 7, a entrada de dados para o software, teremos

para as variáveis (𝑥 , 𝑥 , 𝑥 ) os índices (1, 2, 3), respectivamente. Além das
variáveis das desigualdades no espaço ℜ , porque foi necessário adicionar as
variáveis de folga. Pelo fato que, o problema tratado estar composto por 9
desigualdades, foi necessário adicionar 9 variáveis de folga, denotadas pelos
índices restantes (4, 5, 6, 7, 8, 9, 10, 11, 12). Esses índices são essenciais para
montar a tabela Simplex do problema. Já o ponto inicial será o ponto 𝐼 do
poliedro (ver Figura 6), considerando seus índices básicos iniciais as variáveis
(1,2,3,4,5,6,7,8,10), essas necessárias informações dos dados estão mostradas
na Figura 7.

Passo 2: Após algumas especificações, que não precisam ser ilustradas,

como calcular o número de restrições e variáveis e a definição de variáveis
para execução do programa, o próximo grande passo do algoritmo é montar a
Tabela Simplex do problema no ponto inicial 𝐼. Para realizar essa montagem,
foi criada uma função (código), denominada de tabelaSimplex.m. O programa
então, montará a tabela e a armazenará como está mostrada na Figura 8.
Na primeira linha e coluna da tabela, Figura 8, os valores correspondem aos
índices das variáveis, sendo o índice 𝑎 um elemento neutro. Esses índices
não foram inseridos em forma de legenda pois serão importantes
posteriormente para a execução do código e a realização de operações e
manipulações da tabela. A segunda linha (destacada pelo retângulo vermelho)
corresponde aos valores associados à função objetivo, ou seja, nesta linha as
variáveis dos índices básicos terão o valor 0 e as variáveis dos índices não

23
básicos terão valores diferentes de 0, neste caso {−1, −1, −1} para as variáveis
9, 11 e 12, respectivamente, na Figura 8.
Figura 8 - Tabela simplex do vértice I, vértice inicial necessário para o algoritmo proposto. (saída do
Matlab)

Em geral, os custos reduzidos negativos1 indicam que podem melhorar a

função objetivo, ou seja, uma coluna a qual será utilizada para uma mudança
de base posteriormente. Ainda é importante mencionar, em relação a esta
segunda linha, o valor do coeficiente que aparece na última coluna
corresponde ao valor da função objetivo, ou seja, o valor de 𝑧. Esse valor se
utiliza como indicador, sendo de grande importância, pois ele irá determinar em
qual vértice do poliedro se encontra a execução do procedimento proposto.
Portanto, o vértice 𝐼 terá sempre o valor 0 associado a ele, ou seja, qualquer
iteração que encontrar esse indicador igual a zero, é possível saber que a
tabela é relacionada ao ponto 𝐼. Os coeficientes seguintes, na última coluna da
tabela, correspondem aos valores das variáveis básicas no vértice encontrado,
(lembrar que, na prática, as únicas variáveis que terão utilidade neste exemplo
são as 3 primeiras) sendo elas (𝑥 , 𝑥 , 𝑥 ) = (1.0, 1.0, 0.45). Visualizando as
Figuras 5 e 6, é possível confirmar que se trata do vértice 𝐼. Essa formatação
da tabela é de grande importância e deve ser compreendida, pois, diversas
outras tabelas seguirão esse padrão de formatação.
É importante mencionar também, que foram realizadas aproximações para 6
dígitos de precisão após a virgula. Portanto, qualquer número menor do que

1
Custo Reduzido é o nome dado aos coeficientes da segunda linha da matriz da tabela do
algoritmo simplex. Utilizado para orientar as melhoras da função objetivo de um problema de
programação linear.

24
10 será considerado como o número 0. Esse critério foi implementado para
evitar que o programa encontrasse o mesmo vértice, porém considerasse ele
como diferente do outro.

Passo 3: Após armazenar a tabela do vértice, o programa arruma a tabela

para a realização do algoritmo lexicográfico, conforme descrito na seção 2.2
(pag. 7) e ilustrado pela Figura 9. Esse é um passo de extrema importância,
pois se a tabela estiver configurada fora da ordem necessária, a organização
lexicográfica pode falhar.
Figura 9 - Tabela simplex organizada para representar o vértice I inicial, no algoritmo proposto

Essa tabela segue o padrão definido na seção 2.2, na equação (6). Perceba
que nessa tabela os três índices que não estão na base (9, 11, 12) podem
entrar na base, pois todos possuem índices negativos na segunda linha. O
método simplex tradicional deveria escolher apenas um ponto para continuar
suas iterações, porém, como o foco do algoritmo proposto é a enumeração de
vértices, e não somente a otimização da função objetivo z do problema
proposto, o código preparado irá realizar a mudança de base para todas as
variáveis que possuem o índice negativo, tanto nessa tabela, quanto em
tabelas futuras. Além disso, o programa já armazena os índices e os vértices
encontrados. Nesse caso, ele armazena um vetor valendo [0 1.0 1.0 0.45],
sendo o primeiro elemento o valor da função objetivo ao índice associado (para
o ponto 𝐼, sempre será 0), e os restantes valores as coordenadas das variáveis
(𝑥 , 𝑥 , 𝑥 ) no vértice I.

25
 Passo 4: O programa verifica quais elementos da segunda linha (que são
os valores dos custos reduzidos do método Simplex associados à função
objetivo) são negativos. Ao encontrar um valor negativo (na Figura 9, ele
encontraria primeiro a variável 9) o programa começa realizar as operações de
pivotamento lexicográfico, conforme descrito na seção 2.2.1, para determinar
qual deverá sair da base. Os resultados são organizados em uma matriz,
chamada de candidatosMinLex, na qual a primeira linha é o menor índice
lexicográfico. O número da variável não está em evidência nessa matriz, porém
o programa armazenou anteriormente o valor do índice das variáveis,
informando abaixo da matriz, a variável que sai da base (Figura 11).

Figura 10 - Tabela dos valores organizados lexicograficamente. Primeira iteração do algoritmo proposto

Passo 5: Assim que o programa define quem sai da base, ele já realiza a
permutação e armazena os índices básicos e não básicos novos na
“tabelaTrocas”, conforme mostra a Figura 11. Vale ressaltar que a primeira
linha já foi criada automaticamente, ao definir o ponto inicial.

Figura 11 -“TabelaTrocas” após permutar as variáveis 9 e 10

Nessa tabela cada linha corresponde aos elementos da base e os de fora

da base. Como o problema possuí 9 variáveis básicas e 3 não básicas, os 9

26
primeiros índices em cada linha, corresponde às variáveis básicas para a
montagem de novas tabelas Simplex, enquanto os 3 últimos correspondem às
variáveis não básicas. Após o armazenamento da permutação encontrada, o
programa volta para o passo 4, onde ele vai realizar agora o pivotamento
lexicográfico para o índice 11 e armazenar a permutação encontrada na nova
“tabelaTrocas”. Novamente, ele volta ao passo 4, onde existe último elemento
negativo da linha associada à função objetivo. Dessa vez com a variável 12,
realizando os mesmos procedimentos, encontrado, finalmente, a nova e última
“tabelaTrocas” (Figura 12) da tabela para as variáveis básicas
(1,2,3,4,5,6,7,8,10). Portanto, é possível concluir, observando a “tabelaTrocas”
que a primeira permutação foi da variável 9 pela 10, a segunda permutação, da
variável 11 pela 5, e a terceira iteração, da variável 12 pela 7.
Figura 12 - Última "tabelaTrocas" para a base (1,2,3,4,5,6,7,8,10) do algoritmo proposto

Passo 6 Conforme mencionado anteriormente, a primeira linha da

“tabelaTrocas” foi o ponto de partida do problema. O programa irá continuar
sua busca, saindo da primeira linha da “tabelaTrocas”, indo para a segunda
linha. A partir disso, o programa volta para o passo 2 para realizar uma nova
iteração, encontrando uma nova tabela Simplex e realizando todos os passos
novamente. Outro detalhe importante a ser mencionado, é que caso o
programa encontre no passo 5 uma permutação que deixe os índices básicos e
não básicos iguais a alguma linha já inserida na “tabelaTrocas”, essa linha não
será adicionada, portanto, não haverá repetições de elementos básicos e não
básicos. Assim que o programa não conseguir adicionar mais nenhuma linha
na “tabelaTrocas” ele realiza as iterações das linhas restantes. Quando ele
termina de realizar as iterações e não houver nenhuma linha restante na
“tabelaTrocas”, é iniciado o último passo.

27
 Passo 7: Nesse último passo o programa utiliza a tabela dos
“verticesEncontrados” (Figura 13) atualizada pelo passo 2 de cada iteração e
excluí os vértices iguais.
É possível notar observando a Figura 13 que foram encontrados várias
vezes alguns pontos, por exemplo o ponto 𝐼(1.0, 1.0, 0.45) que foi encontrado 3
vezes, ou o ponto 𝐺(1.75, 1.0, 0.25), encontrado 4 vezes. Isso ocorre pelo fato
de existirem fortes degenerações no problema. Isso afirma o que foi
mencionado no Capítulo 2, principalmente sobre a escolha do algoritmo
lexicográfico implementado. Embora trabalhando com o código que implementa
o método lexicográfico, não foi possível escapar dos problemas causados pela
degeneração, porém esse método se mostrou eficiente, evitando numerosos
passos indesejáveis, como pode-se ver na Figura 29 no Anexo 1, pag. 47, e
evitando a formação de ciclos infinitos, conhecido como problema da ciclagem.

Figura 13 - Matriz dos vértices encontrados pelas iterações do algoritmo proposto

É importante notar que apesar dos vértices foram repetidos, mantém-se os

valores associados à função objetivo. Observando a Figura 13, por exemplo, o
valor de 𝑧 = 10,75, destacado na Figura 13, correspondeu sempre às mesmas
coordenadas (𝑥 , 𝑥 , 𝑥 ), com uma precisão de 10 , que nesse caso
correspondem ao vértice G, ver Figura 5. Isso afirma o que foi dito
28
anteriormente, que mudando de base, porém mantendo o valor de 𝑧, o vértice
se mantém igual, que é um indicativo de degeneração, pois bases diferentes
definem o mesmo vértice G.
Assim que o programa monta a tabela dos vértices encontrados (Figura 13),
ele excluí as linhas (dos vértices) que se repetem, formando a matriz final dos
VérticesDoPoliedro (Figura 14). Nessa matriz a primeira coluna corresponde
aos valores da função objetivo para o determinado ponto. As outras colunas
correspondem aos valores dos vértices do problema que, nesse exemplo,
corresponde a (𝑥 , 𝑥 , 𝑥 ), respectivamente.
Além disso, analisando a figura do poliedro do problema (Figura 5), é
possível confirmar os vértices encontrados, conforme ilustra a Figura 14. É
importante ressaltar que as letras referentes aos vértices foram obtidas
observando o poliedro do problema, e não pelo programa.

Figura 14 - Matriz dos vértices encontrados pelo algoritmo proposto

A Figura 15 exibe o tempo de execução do programa para o exemplo

utilizado, que foi de menos de 0,1 segundo de tempo total. Essa tabela é
gerada automaticamente pelo MATLAB, utilizando a opção “Run and Time”,
que executa o programa cronometrando precisamente o tempo de execução do
programa.

29
 Figura 15 - Tempo de execução do algoritmo proposto extraído de relatório fornecido pelo Matlab

Nota-se que o programa proposto conseguiu concluir seus objetivos para

esse problema, além de apresentar um excelente tempo de execução.

5.2 EXEMPLOS COMPLEMENTARES

5.2.1 Exemplo 1
Como primeiro exemplo complementar, será utilizado o mesmo problema de
Campêlo e Scheimberg (2005), porém será excluída a última restrição, que
consistia na função objetivo do líder, conforme mencionado na pag. 17, cap. 4.
A última restrição da relação (12), EFIJ, correspondente à restrição
𝐹 (𝑥, 𝑦 , 𝑦 ) ≤ 𝐹 (𝐼), ela eliminava a pirâmide KEFIJ, que pode ser visualizado
na Figura 5, pag. 20. Porém eliminando essa restrição do problema, o
programa deverá conseguir encontrar todos os vértices do poliedro original aqui
referenciado, sem que tenha sido realizado esse corte, ou seja, ele não
encontrará os pontos 𝐸 e 𝐽, porém deverá encontrar o ponto 𝐾 (Figura 16).
Portanto, o novo problema tem a seguinte forma:

30
 𝑥 + 𝑥 + 𝑥 ≤ 3 ← 𝐵𝐶𝐺𝐹
𝑥 + 𝑥 − 𝑥 ≥ 1 ← 𝐴𝐷𝐻𝐾
−𝑥 + 𝑥 + 𝑥 ≤ 1 ← 𝐴𝐵𝐹𝐾
𝑥 − 𝑥 + 𝑥 ≤ 1 ← 𝐷𝐶𝐺𝐻
16𝑥 − 6𝑥 + 60𝑥 ≤ 37 ← 𝐹𝐼𝐺 (13)
6𝑥 − 16𝑥 + 60𝑥 ≤ 17 ← 𝐾𝐼𝐻
6𝑥 − 6𝑥 + 60𝑥 ≤ 27 ← 𝐾𝐼𝐹
16𝑥 − 16𝑥 + 60𝑥 ≤ 27 ← 𝐺𝐼𝐻
𝑥 ≥ 0, 𝑥 ≥ 0, 𝑥 ≥ 0

Figura 16 – Gráfico do Poliedro definido por (13), exemplo complementar 1

Como foi dito no exemplo anterior, as únicas informações necessárias ao

programa para encontrar os vértices são as equações de restrição do
problema, o lado direito das restrições (chamado “resultadoRestricoes”) e a
definição de um vértice inicial, que para esse exemplo, será utilizado o mesmo
ponto 𝐼, conforme ilustrado pela Figura 17.

31
 Figura 17 - Dados para o exemplo complementar 1 na linguagem do Matlab

É possível diferenciar os dados da Figura 17 pelos dados da Figura 7 da

seguinte maneira: na matriz de restrições, a última linha, referente à restrição
𝐹 (𝑥, 𝑦 , 𝑦 ) ≥ 𝐹 (𝐼) foi excluída. Já no vetor dos resultados das restrições, foi
excluído o último elemento, referente à restrição retirada. Já nos índices
básicos e não básicos iniciais, foi preciso retirar a variável 12, pois ela
correspondia à variável de folga da restrição excluída. Portanto os novos
índices básicos iniciais tiveram de ser levemente alterados, incluindo a variável
11 como índice não básico inicial (porém mantendo o ponto 𝐼 como ponto de
partida).
O algoritmo aqui proposto realiza todos os passos descritos no exemplo
anterior e retorna a matriz de todos os vértices encontrados pelo programa,
conforme ilustra a Figura 18. Novamente, é possível observar que o programa
encontrou alguns vértices mais do que uma vez, porém os valores das
variáveis (𝑥 , 𝑥 , 𝑥 ) se mantém constantes.
A Figura 19 mostra a matriz dos Vértices do Poliedro, após o programa
excluir as linhas com vértices iguais da matriz da Figura 18. Analisando os
vértices encontrados com a Figura 16, é possível confirmar que o programa
novamente encontrou todos os vértices do poliedro e realizou novamente 17
iterações.

32
 Figura 18 - Matriz dos vértices encontrados para o exemplo complementar 1

Figura 19 - Matriz dos vértices do poliedro do exemplo complementar 1

Outro fato importante a ser mencionado ao observar a Figura 19 é que os

valores de 𝑧 da função objetivo foram diferentes dos que foram obtidos pela
matriz da Figura 14, porque se tratou de outra função objetivo onde tinha
somente 8 variáveis de folga. Porém, os vértices encontrados, que são os
valores que realmente importam, foram os mesmos, com exceção dos vértices
que foram excluídos do problema (os vértices E e J) e a adição do vértice 𝐾
aos vértices do poliedro de exemplo 1.

Em relação ao tempo de execução, houve uma grande redução do tempo,

porém não tão significativas, como mostra a Figura 11, já que o programa
33
continuou com sua execução abaixo de 0,1 segundo. Como foi excluída uma
restrição do problema, o tempo de execução foi inferior ao do exemplo anterior
porque se buscou menos vértices e consequentemente menos degenerações
ao definir esses vértices.

Figura 20 - Tempo de execução do programa para o exemplo complementar 1, extraído de relatório

fornecido pelo Matlab

5.2.2 Exemplo 2
Como segundo exemplo complementar, foi adicionada uma nova variável 𝑥
ao exemplo principal, na relação (12). O novo exemplo, portanto, é definido por:
𝑥 +𝑥 +𝑥 +𝑥 ≤3
𝑥 +𝑥 −𝑥 −𝑥 ≥1
−𝑥 + 𝑥 + 𝑥 + 𝑥 ≤ 1
𝑥 −𝑥 +𝑥 +𝑥 ≤1
16𝑥 − 6𝑥 + 60𝑥 + 𝑥 ≤ 37
(14)
6𝑥 − 16𝑥 + 60𝑥 + 𝑥 ≤ 17
6𝑥 − 6𝑥 + 60𝑥 + 𝑥 ≤ 27
16𝑥 − 16𝑥 + 60𝑥 + 𝑥 ≤ 27
𝑥 − 2𝑥 + 20𝑥 + 𝑥 ≤ 8
𝑥 ≥ 0, 𝑥 ≥ 0, 𝑥 ≥ 0, 𝑥 ≥ 0

Vale ressaltar que é um problema definido em ℜ , portanto, não é possível

ilustrá-lo por um gráfico. A Figura 21 exibe como ficaram as sentenças de
entrada das novas restrições no programa. É possível notar que cada restrição
recebeu 𝑥 em suas linhas e que foi necessário adicionar uma nova variável
aos índices não básicos iniciais.

34
 Figura 21 - Dados para o exemplo complementar 2 na linguagem do Matlab

Como foi mencionado anteriormente, apenas esses dados são suficientes

para que o programa encontre os vértices do problema. Todos os passos do
programa serão executados de forma similar aos exemplos anteriores. A única
diferença é que agora os vértices serão definidos pelas quatro variáveis
principais do problema. Portanto, os vértices encontrados pelo algoritmo
proposto nesta dissertação são ilustrados pela Figura 22.
É importante observar na Figura 22, que agora a matriz de vértices é
formada por 5 colunas. A primeira continua sendo o valor associado à função
objetivo e as outras 4 colunas são os valores de (𝑥 , 𝑥 , 𝑥 , 𝑥 ),
respectivamente. Assim como nos exemplos anteriores, é possível perceber
que cada valor associado à função objetivo corresponde a um vértice
específico. Portanto, os vértices encontrados, são definidos pela Figura 23.
Observando os vértices encontrados, é possível perceber que todos os
vértices anteriores foram encontrados novamente. Além disso, 4 novos vértices
foram encontrados, denominados de 𝐾, 𝐿, 𝑀 𝑒 𝑁. Como as desigualdades que
definem o poliedro foram alteradas apenas adicionando uma variável 𝑥 , já era
de se esperar que os mesmos pontos fossem encontrados, o que comprova
que o algoritmo proposto está funcionando corretamente.

35
 Figura 22 - Matriz dos vértices encontrados para o exemplo complementar 2, extraído do relatório
fornecido pelo Matlab

Figura 23 - Matriz dos vértices do poliedro do exemplo complementar 2, extraído do relatório fornecido
pelo Matlab

36
 Em relação ao tempo de execução, o programa ainda tem sua execução
abaixo de 0,1s. Mesmo adicionando uma nova variável e realizando mais
iterações o programa teve um tempo de execução menor que o exemplo
principal, conforme ilustra a Figura 24.

Figura 24 - Tempo de execução do programa para o exemplo complementar 2, extraído do relatório

fornecido pelo Matlab

5.3 DIFICULDADES ENCONTRADAS

O início da programação foi o passo mais complicado. Como existia a falta
de familiaridade com o estilo de programação do MATLAB, foi necessário
estudar sua linguagem e modelagem de programação para conseguir uma
programação funcional do algoritmo. Esse processo levou alguns meses, até
que fosse possível iniciar a programação. Enquanto o programa não estava
pronto, foram realizados testes manuais com auxílio de outros programas para
a realização do mapeamento completo (Anexo A) do problema e o
mapeamento com o algoritmo proposto (Figura 6).
Após essa fase de estudos, foi possível iniciar a programação em MATLAB.
A primeira dificuldade da programação foi a ordenação para a execução do
algoritmo lexicográfico. Como foi dito no Capítulo 2, a matriz da tabela Simplex
deve seguir a formatação exibida na equação (6). O desafio aqui foi a
necessidade de realizar permutações de colunas da tabela, alterando seus
índices. Por exemplo, ao encontrar a variável 2 na coluna 3, com um valor
diferente de 0 associado à função objetivo, é necessário colocá-la como as
últimas colunas da matriz. Porém, era importante que essa matriz, mesmo com
a troca de posição, continuasse sendo a variável 2. Esse problema foi

37
facilmente solucionado deixando os índices na matriz, como se mostrou na
Figura 9. A primeira linha da matriz é composta pelos índices das variáveis, e
para que as mudanças fossem realizadas corretamente, eles tiveram de ser
mantidos dessa forma.
A segunda principal dificuldade da programação foi conseguir definir uma
ordem para a realização das mudanças de base. Na execução manual do
algoritmo era escolhido um caminho e realizado a mudança para ele. Na Figura
6, por exemplo, o primeiro caminho poderia ser a coluna em vermelho. A partir
disso, eram realizadas as mudanças a partir desse caminho. Caso o próximo
passo criasse mais de um caminho, esse passo era marcado, um caminho era
escolhido, até que se chegasse a um fim. Chegando no final, voltar-se-ia pelo
caminho andado, procurando os caminhos marcados por bifurcações. Essas
bifurcações eram resolvidas, até que todo o caminho vermelho fosse traçado.
Após isso, outro caminho foi selecionado (o azul, por exemplo), até que todos
os caminhos principais fossem resolvidos. Porém na programação em
MATLAB, tal programação não seria possível em uma ordem tão exata. Para a
solução desse problema foi a criação da “tabelaTrocas” (Figuras 12 e 13).
Nessa tabela são registradas todas as bases que podem ser trocadas. Em um
passo que encontra 4 mudanças possíveis, serão adicionadas essas 4 novas
bases na “tabelaTrocas”. Como cada base só pode ser executada sozinha, o
programa vai adicionando as linhas da “tabelaTrocas” e resolvendo elas na
ordem adicionada. Caso uma execução tente adicionar uma linha de bases que
já foi adicionada anteriormente, a “tabelaTrocas” rejeita essa linha, pois se não
o fizesse, o programa nunca iria parar. Ao chegar na última linha, e não for
possível adicionar mais nenhuma, significa que o programa rodou por todas as
bases possíveis, mesmo não sendo na ordem da Figura 6.
Esses foram os maiores problemas durante a programação do algoritmo.
Alguns problemas pequenos foram também encontrados, mas rapidamente
resolvidos, como: a criação do critério de parada, criada para que quando não
fosse possível mais adicionar linhas na “tabelaTrocas” a partir da última linha, o
programa parasse de executar as iterações; a criação da matriz
“VerticesDoPoliedro” (Figuras 14, 19 e 23), armazenando somente um vértice
de cada valor associado à função objetivo; problemas na programação do

38
pivotamento lexicográfico, que consistiu somente na dificuldade da
programação propriamente dita.

5.4 COMPARAÇÃO COM O CON2VERT.M

Como mencionado anteriormente, o problema da enumeração de vértices

não é um problema novo. Uma função (ou código) em matlab foi encontrada
que também soluciona o problema tratado neste pesquisa é o con2vert.m,
desenvolvido por Kleder (2005). Apesar de usar outra abordagem, a sua
execução também é simples, apenas precisando das desigualdades que
formam o polítopo sem considerar restrições de sinal para seus vértices. Um
detalhe importante é que para que o algoritmo executasse os exemplos
propostos sem erros, portanto, foi necessário implementar as restrições de que
as variáveis não podem ser negativas. No algoritmo proposto não foi
necessário implementar essa parte, pois como foi utilizado as tabelas do
método simplex primal, ele já considerava que as variáveis não poderiam ser
negativas.

5.4.1 Comparação com o exemplo principal

Nesta primeira parte foi implementado na função con2vert.m no problema
definido na relação (12). Os vértices encontrados foram os mesmos
encontrados pelo algoritmo proposto, conforme já ilustrado pela Figura 24. Já o
tempo de execução se encontra na Figura 25.
Comparando com a Figura 25, é possível notar que os tempos de execução
foram muito similares, já que no algoritmo proposto o tempo foi de 0.061s e
usando o con2vert foi de 0.059s.

39
 Figura 25 - Tempo de execução do con2vert.m para o exemplo principal, extraído do relatório fornecido
pelo Matlab

5.4.2 Comparação com o exemplo complementar 1

Nessa segunda comparação, foi implementada a função con2vert no
exemplo complementar 1, definido pela equação (13). Nesse problema os
vértices encontrados também foram os mesmos (Figura 9). Já o tempo do
con2vert.m é ilustrado abaixo na Figura 26.

Comparando com o resultado obtido pelo algoritmo proposto, é possível

perceber que ele obteve um tempo bem menor em relação ao con2vert, já que
foi executado em 0,023s contra os 0,057s do con2vert.

40
 Figura 26 - Tempo de execução do con2vert.m para o exemplo complementar 1, extraído do relatório
fornecido pelo Matlab

5.4.2 Comparação com o exemplo complementar2

Nessa terceira comparação, foi implementada a função con2vert no
exemplo complementar 2, definido pela equação (14). Nesse problema os
vértices encontrados foram iguais, porém o con2vert apresentou algumas
anomalias, ilustradas pela Figura 27.

Figura 27 - Vértices encontrados pelo con2vert.m no exemplo complementar 2, extraído do relatório

fornecido pelo Matlab e associados aos vértices manualmente.

41
 Comparando a Figura 27 com a Figura 23, é possível perceber que o
con2vert.m conseguiu encontrar os mesmos vértices que o algoritmo proposto.
Porém, foram marcadas com um “?” as anomalias encontradas no resultado
dos vértices. A quarta linha da matriz, é semelhante à terceira linha, ambas
correspondendo ao vértice I. Porém na 4 linha foi encontrado um -0.0000, uma
aproximação para −1,0 . 10 . Por esse motivo, foi implementado no algoritmo
proposto a aproximação de 6 dígitos de precisão, conforme mencionado no
Passo 2 no início do capítulo 5.
Outra linha que chama atenção na Figura 27 é a 12ª linha, onde foram
encontrados os erros NaN e Inf. No Matlab, o erro NaN corresponde a
expressão “Not-a-Number”, ou seja, não é um número, já o Inf corresponde a
“Infinite”, ou seja, infinito. Não é possível ter certeza do motivo desse erro,
porém, provavelmente, ele encontrou alguma divisão por 0 nesse passo, o que
pode ter acarretado erros de arredondamento, o que retornou essas
mensagens de erro.
Anomalias a parte, o con2vert.m consegue encontrar os vértices que foram
propostos. O tempo de execução é ilustrado na Figura 28. O algoritmo aqui
proposto executou o problema em 0,042s, enquanto o con2vert.m levou
0,063s.

Figura 28 - Tempo de execução do con2vert para o exemplo complementar 2, extraído do relatório

fornecido pelo Matlab

42
 CAPÍTULO 6

CONCLUSÕES

De acordo com o que foi apresentado, foi possível concluir que os objetivos
deste trabalho foram completados. O novo algoritmo proposto foi testado e
funcionou corretamente tanto manualmente, como discutido no capítulo 4,
quanto em sua programação em linguagem MATLAB.
O algoritmo proposto é baseado em pivotamentos do método Simplex
primal evitando degeneração via a implementação lexicográfica. Pelas
dificuldades encontradas na implementação, espera-se que funcione para
qualquer poliedro, mas a complexidade de tempo polinomial em termos do
número de bases só será garantida para polítopos, segundo Reimers e Stougie
(2016).
O MATLAB como ferramenta de programação foi de grande ajuda,
principalmente pelo fato do trabalho utilizar diversas matrizes para a
implementação do algoritmo. Além de ser uma ferramenta excelente de
programação de matrizes, o programa se mostrou simples de ser utilizado,
apresentando poucos problemas durante a codificação do algoritmo proposto.
Em relação ao novo algoritmo apresentado, ele pode ser facilmente
implementado para problemas de enumeração de vértices de um poliedro
definido por 𝑃 = {𝑥 ∈ ℜ : 𝐴𝑥 ≤ 𝑏, 𝑥 ≥ 0}. Usando o programa codificado, basta
inserir as restrições do problema e o ponto inicial, conforme realizado nos
exemplos do Capítulo 5.
A abordagem por pivotamentos da tabela Simplex permitiu que o algoritmo
se mantivesse com a facilidade de implementação, porém sempre eficiente.
Além disso, a implementação da abordagem lexicográfica também foi
essencial, principalmente pelo fato de que o algoritmo proposto trabalha com
mudanças de bases fortemente degeneradas, como as bases encontradas
pelos exemplos do capítulo 5, em que foram encontrados os mesmos vértices
mudando as bases. Com a implementação dessa abordagem lexicográfica, o
programa se mantém seguro em relação aos problemas de ciclagem.
A comparação com outra função de enumeração de vértices demonstrou
que o tempo de execução está no mesmo nível, superando a outra função em

43
alguns exemplos. É importante lembrar que o con2vert.m é um programa já
estabelecido na biblioteca do Matlab, portanto é uma função mais otimizada na
sua implementação computacional do que a do algoritmo aqui proposto. E
mesmo com essa diferença de otimização, os tempos ficaram muito similares.
Como trabalho futuro, recomenda-se a pesquisa mais aprofundada da
complexidade do algoritmo proposto. Recomenda-se também a realização de
testes em mais problemas numéricos, para estudar o comportamento do
algoritmo e o tempo de execução do programa.

44
REFERÊNCIAS

ABDULLAHI, S.D. Vertex Enumeration and Counting for Certain Classes of

Polyhedra. PhD thesis, Computing (compute algorithms) Leeds University,
2003.

AVIS, D; FUKUDA, K. A Pivoting for Convex Hulls and Vertex Enumeration of

Arrangements and Polyhedra. Discrete & Computational Geometry, 8, p.
295-313, 1992.

BERTSIMAS, D; TSITSIKLIS,J.N. Introduction to Linear Optimization. Athena

Scientific, 1997

BALINSKI, M.L. An algorithm for finding all vertices of convex polyhedral sets.
SIAM Journal on Applied Mathematics, 9:72-81, 1961.

BLAND, R.G. New finite pivoting rules for the simplex method. Mathematics of
Operations Research, p. 103–107, 1977.

BLUM, E.; OETTLI, W. Mathematische Optimierung. Grundlagen und

Verfahren. Okonometrie und Unternehmensforschung, 20. Springer-Verlag,
Berlin-Heidelberg-New York, 1975

BOROS, E.; ELBASSIONI, K.; GURVICH, V.; KHACHIYAN, L. Enumerating

minimal dicuts and strongly connected subgraphs and related geometric
problems. In D. Bienstock and G. Nemhauser, editors, Integer Programming
and Combinatorial Optimization, 10th International IPCO Conference, volume
3064 of Lecture Notes in Computer Science, p. 152-162. New York, 2004.

CAMPÊLO, M.; SCHEIMBERG, S. A Simplex Approach for Finding Local

Solutions of a Linear Bilevel Program by Equilibrium Points. Annals of
Operations Research v. 138, n. 1, p. 143–157, 2005.

CARREIRA-PERPIÑÁN, M. Á. Simplex Method. MathWorld--A Wolfram Web

Resource. Disponível em:
<http://mathworld.wolfram.com/SimplexMethod.html>. Acesso em: 15 jun. 2019.

DANTZIG, G. B., THAPA, M. N. Linear Programming 2: Theory and Extensions

(Springer Series in Operations Research and Financial Engineering). Springer-
Verlag, Berlin-Heidelberg-New York, 1997.

DYER, M. E. The Complexity of Vertex Enumeration Methods. Mathematics of

Operations Research 8(3), p. 381-402, 1983.

GURUNG, A.; RAY, R. An Efficient Algorithm for Vertex Enumeration of Two-

Dimensional Projection of Polytopes. ArXiv preprint arXiv>1611.10059, nov
2016.

45
KHACHIYAN, L.; BOROS, E.; BORYS, K.; ELBASSIONI, K; GURVICH, V.
Generating All Vertices of a Polyhedron is Hard. Discrete and Computational
Geometry. 39(1-3): 174-190. 2008.

KLEDER, M. con2vert – constraints to vertices. Convert convex constraint

inequalities into a set of vertices. MathWorks. Jun de 2005. Disponível em <
https://www.mathworks.com/matlabcentral/fileexchange/7894-con2vert-
constraints-to-vertices>. Acessado em outubro de 2019

LEWIS, C. Linear Programming: Theory and Application. Whitman College,

2008.

MOTZKIN, T. S.; RAIFFA, H.; THOMPSON, G.L. The double description

method, in: Contributions to the Theory of Games, Vol. If, H. W. Kuhn and A. W.
Tacker (eds). Princeton University Press, Princeton, N.J., p. 51-73, 1953.

REIMERS, A.; STOUGIE, L. Polynomial time vertex enumeration of convex

polytopes of bounded branch-width. arXiv preprint arXiv:1404.5584, Jul 2016.

SKIENA, S. S.; REVILLA, M. A. Programming Challenges - The Programming

Contest Training Manual – Pagina 313, Chapter 14. Springer, 2003

TAHA, H. A. Pesquisa Operacional. Pearson Education. 8a ed. P. 81-150,

2008.

TERLAKY T. Lexicographic Pivoting Rules. In: Floudas C.A., Pardalos P.M.

(eds) Encyclopedia of Optimization. Springer, Boston, MA, 2001.

46
 ANEXO A – MAPEAMENTO COMPLETO DO POLIEDRO (12)

Figura 29 – Mapeamento completo do Poliedro (12)

𝐹10 𝐹10
𝐺 10,75 𝐺 10,75
𝐺 10,75 𝑁 = {4, 𝟖, 𝟏𝟎} ∗ 𝑁 = {4,10,12}
𝑁 = {4,7, 8} 𝑁 = {4, 8,11}
𝑁 = {7, 8,11}
𝐹10 𝐹10 𝐵97
𝐼 0 𝑁 = {6,8,10} 𝑁 = {4,6,10}
10,75 𝑁 = {3,4,6}
𝐺 𝑁 = {8, 𝟏𝟎, 𝟏𝟏} ∗
𝑁 = {4, 8,11}
Usa-se * para denotar base degenerada e a cor laranja para bases
10 0 𝟎 com vários custos não básicos negativos.
𝐹 𝐼 𝑰
𝑁 = {4, 10,12} 𝑁 = {10, 𝟏𝟏, 𝟏𝟐} ∗ 𝑁 = {𝟗, 11,12} ∗
𝐼0 𝑮𝟏𝟎,𝟕𝟓
𝑁 = {8, 𝟏𝟏, 𝟏𝟐} 𝑁 = {4,8, 11}

𝐹10 𝐹10 𝐹10

𝑁 = {4,6,12} 𝑁 = {6,10,12} 𝑁 = {6,8,10} 𝑭𝟏𝟎 𝐺 10,75
𝑁 = {4,8,12} 𝑁 = {4,7, 11}

𝐹10 𝐵97
𝐹10 𝑪𝟒𝟎
𝑁 = {4, 𝟔, 𝟖} 𝑁 = {3,4,6}
𝑁 = {4,6,12} 𝑁 = {3,4,7}

𝐶 40 𝐺 10,75 𝑩𝟗𝟕
𝑁 = {3,4,7} 𝑁 = {4,7,8} 𝑁 = {3,4,6}
𝐼0
𝑁 = {9,11,12}
Vértices encontrados: I, F, B, G, C
𝑱𝟒,𝟏𝟔𝟔𝟕
𝑁 = {5,9,12}

𝐹10 𝑬𝟖,𝟑𝟖𝟏𝟎
𝐹 10 𝑁 = {𝟓, 6, 𝟏𝟐} ∗ 𝑨𝟖𝟔 𝐴86
𝑁 = {6,8,12} 𝑁 = {1,3,6}
𝑁 = {4,6,12} 𝑁 = {1, 𝟓, 𝟔}

𝐹10 𝐴86
𝐹10 𝐴86
𝑁 = {6,10,12} 𝑁 = {3,5,6} ∗ 𝐵97
𝑁 = {4,6,8} 𝐵 97 𝑁 = {1,3,5}
𝑁 = {3,4,6}
𝑁 = {3,4,6}

𝐸𝐻𝑒𝐶𝑜𝑟𝑡𝑒𝐼 4,1667
𝐻2,5 Vértices encontrados: I, F, B, G, C, 𝐽, E, A
𝑁 = {5,9,12}
𝑁 = {5, 𝟕, 𝟗} ∗
𝐼0 𝐺 10,75
𝐻2,5 𝑁 = {9,11,12} ∗ 𝑁 = {4,7,11}
𝑯𝟐,𝟓 𝐻2,5
𝑁 = {7, 𝟗, 𝟏𝟏} ∗
𝑁 = {5, 𝟗, 𝟏𝟏} 𝑁 = {𝟓, 7, 𝟏𝟏} ∗
𝐻2,5 𝐺 10,75
𝐷29 𝑁 = {5,9,12} 𝑁 = {7,8,11}
𝑁 = {3,5,7} 𝐷29 𝑫𝟐𝟗
𝐷 29 𝑁 = {2, 𝟓, 𝟕} ∗ 𝑁 = {3, 𝟓, 𝟕} ∗ 𝐺 10,75
𝐷29 𝑁 = {𝟐, 3, 𝟕} 𝑁 = {4,7,8}
10,75
𝑁 = {2,5,7} 𝐺
𝑁 = {4,7, 11}
𝐷29 𝐶 40
𝑁 = {2,3,5} ∗ 𝑁 = {3,4,7}
𝐺 10,75
𝑁 = {7,8,11}
𝐴86
40 𝑁 = {1,3,5}
𝐶
𝑁 = {3,4,7}

𝐷29 𝐴86 𝐴86

𝑁 = {2,3,5} 𝑁 = {3,5,6} 𝑁 = {3,5,6} ∗

Vértices encontrados: I, G, C, B, F, 𝐽, 𝐸, A, H, D

47
 APÊNDICE

Nesta seção define-se formalizações muito úteis para a computação

geométrica que “tornou-se cada vez mais importante em aplicativos como
computação gráfica, robótica e projetos de produto (design) assistido por
computador, porque a forma é uma propriedade inerente de objetos reais”
SKIENA e REVILLA (2003). Em particular é destaque a visão geométrica para
a construção de algoritmos de otimização combinatória.
Definição 1: Uma envoltória convexa ou fecho convexo de um conjunto
Ω em ℜ , é o conjunto de todos os pontos que podem ser representados como
uma combinação linear, de escalares não negativos, de pontos xi em Ω, isto é:

𝑐𝑜𝑛𝑣(Ω) = {𝑥 ∈ ℜ : 𝑥 = ∑ 𝛼𝑥 ;∑ 𝛼 = 1 , 𝛼 ≥ 0 𝑒 𝑥 ∈ Ω, ∀i}.
Figura 30 - O desenho da esquerda mostra o fecho convexo de um conjunto Ω_1, de pontos discretos
(representado pelos pontos em preto), e o desenho da direita mostra o fecho convexo de Ω_2 formado
pelas duas elipses em cinza.

Ω Ω

Fonte: Adaptado de: https://gis.stackexchange.com/questions/302107/defining-convex-hull-of-

clouds-of-points-using-r, o desenho a direita é de elaboração própria.

Definição 2: Um n-simplex é o fecho convexo ou envoltória convexa de n

vetores 𝑆, 𝑆 ⊂ ℜ , que são linear independentes. Isto é, um n-simplex é o fecho
convexo de n+1 pontos, chamados vértices, em um espaço euclidiano n-
dimensional.

Exemplos

1-Sejam os pontos 𝑋1 = {0,1} em ℜ. O 1-simplex de 𝑋1 é o fecho convexo

de 𝑋1, 𝑐𝑜𝑛𝑣(𝑋1)={𝑠𝑒𝑔𝑚𝑒𝑛𝑡𝑜 𝑑𝑒 𝑟𝑒𝑡𝑎 𝑑𝑒𝑓𝑖𝑛𝑖𝑑𝑜 𝑝𝑒𝑙𝑜𝑠 𝑝𝑜𝑛𝑡𝑜𝑠 0 𝑒 1}. Observar
que o vetor definido por 𝑢 = (1 − 0) é o um vetor linear independente, em ℜ.
Alguns autores o chamam de 1-simplex padrão em ℜ.

48
 2-Sejam os pontos 𝑋2 = {(0,0), (0,1), (1,0)} em ℜ . O 2-simplex definidos
por 𝑋2 está definida pela envoltória convexa, ou fecho convexo, de 𝑋2,
𝑐𝑜𝑛𝑣(𝑋2)={𝑜 𝑝𝑜𝑙𝑖𝑔𝑜𝑛𝑜 𝑡𝑟𝑖𝑎𝑛𝑔𝑢𝑙𝑎𝑟 𝑑𝑒𝑓𝑖𝑛𝑖𝑑𝑜 𝑝𝑒𝑙𝑜𝑠 𝑝𝑜𝑛𝑡𝑜𝑠 𝑒𝑚 𝑋2}. Observar que
os vetores definidos pelos pontos de 𝑋2, {𝑒 = (1,0) − (0,0), 𝑒 = (0,1) − (0,0)}
são linear independentes eles são os canônicos. É chamado 2-simplex padrão.
3- Sejam os pontos 𝑋3 = {(0,0,0), (0,0,1), (0,1,0)}, (1,1,1) em ℜ . O 3-simplex
definidos por 𝑋3 é a envoltória convexa ou fecho convexo de 𝑋3,
𝑐𝑜𝑛𝑣(𝑋3)={𝑜 𝑡𝑒𝑡𝑟𝑎𝑒𝑑𝑟𝑜 𝑑𝑒𝑓𝑖𝑛𝑖𝑑𝑜 𝑝𝑒𝑙𝑜𝑠 𝑝𝑜𝑛𝑡𝑜𝑠 𝑒𝑚 𝑋3}.
Na figura 31, se esboçam as representações de simplexes não
necessariamente n-simplexes padrões.
Figura 31 - Mostram-se as configurações de 1-simplex em R, 2-simplex (um triângulo) em R^2, e um 3-
simplex (tetraedro em ℜ )

Fonte: https://www.haroldserrano.com/blog/visualizing-the-gjk-collision-algorithm.

49