sexta-feira, 11 de novembro de 2016

Matemática: conjuntos, computação e um Automato para testes

Abordarei os seguintes assuntos:

Um pouco da historia da computação;
Algoritmos;

Axiomas;
Relação;
Elementos;
Conjuntos;
Verdade;
Falsidade;
indecidibilidade;

Quantificadores;
Recursividade e poda;
negação;
pertence;
todo;

Laços de repetição - Autômato para a verificações vindas com quantificador todos;

Autômatos para testes.


Sugestão de Pesquisa na Internete
(Google?):

 Aprendendo JavaScript;
 javascript introdução;

 Tutorial javascript (http://www.w3schools.com/js/default.asp);

 http://www.w3schools.com/TAgs/ref_canvas.asp







Relações



"Um dos conceitos mais importantes para o desenvolvimento deste estudo é o de "Relações" (Encontradas (ou/e) estabelecidas)."

Num livro de matemática sobre lógica, conjuntos e funções, um dos que mais gosto, dedicou apenas 10 páginas sobre Relações. Algo que poderia ser bem melhor explorado. Isso ocorreu porque o livro era dedicado a funções.
 
Como tornar a forma de ensino mais instrutiva e mais compacta sem deixar de transmitir todas os requisitos? Simplificar sem deixar passar os pré-requisitos importantes, como o filosófico por exemplo, é dificílimo, talvez impossível 100% de eficiência, mas é um caminho a se buscar. Uma busca a se seguir na compreensão é reduzirmos estas buscar por valores verdades em fórmulas.

Uma proposta é criar um sistema de testes para estas formulas. Uma caixa onde pudéssemos jogar com uma parcela do que aprendemos.


O computador e a internet é uma das ferramentas de aprendizado mais poderosas que dispomos. Hoje, tendo todos nós essa chance de absorver e multiplicar a quantidade de conhecimento, fica difícil, as vezes absorver tanta informação. Por isso, instintivamente, nós, (Talvez somente os seres humanos se especializaram em poupar recursos), buscamos as explicações mais simples, óbvias e selecionando-se as soluções mais próximas de 100% de acerto, estabelece-se tal modelo como o padrão.

O computador não é um item obrigatório de nosso estudo, mas uma sugestão para testes práticos e nos aprofundarmos mais rapidamente.


Introdução

Para dominarmos bem a Lógica, construção de Teoremas e suas Notações é necessário nos aprofundarmos no estudo de forma até filosófica. Algo que é bem trabalhoso e que consome muito tempo. Aqui, escrevi minhas perguntas e tendo encontrar uma conexão (Relação) entre vários campos da matemática para me aperfeiçoar. Faço uma uma pequena revisão, de forma não tão técnica, mas um pouco esmiuçada de alguns temas que, ao meu ver, se interconectam, alguns deles, como Relações, por exemplo, que são, geralmente, pouco abordados antes de uma faculdade. As vezes abusarei das metáforas, mas será com o intuito de poupar explicações e muitos exemplos.


Primórdios da computação - uma Relação entre Circuitos e álgebra de Boole

Por volta de 1937 e 1938 Claude Elwood Shannon quando, com 21 anos de idade e aluno de mestrado no MIT, escreveu uma tese demonstrando que uma aplicação elétrica utilizando álgebra de Boole podia simplificar circuitos e reduzir drasticamente o número de relês utilizados. Inicialmente as companhias telefônicas da época foram as maiores beneficiadas, mas logo, Shannon percebe que ele poderia utilizar suas descobertas para resolver problemas de lógica. Um circuito fechado representando o valor verdade como 1 e o circuito aberto representando o valor falso ou 0. A descoberta desta relação entre circuitos e lógica de Boole fundamentou os conceitos mais importantes da computação. Além da elétrica, através de portas lógicas, fios elétricos e baterias, a própria lógica também passou a ser mais explorada com auxílio da Álgebra de Boole e com o apoio de tecnologias elétricas. Para quem tiver maior interesse, também sugiro a pesquisa sobre Maquina de Turing.

Estabelecendo uma Relação entre "Relação matemática" e "Funções em computadores" - Algoritmos
Atualmente, é comum utilizamos autômatos (computadores) para solucionar problemas ou tirarmos algum proveito. Ou para o nosso caso, como ferramenta de estudos.

As vantagens de um autômato são muitas. Vão além da precisão e velocidade com a qual conseguem chegar aos resultados que desejamos. Alguns destes autômatos podem ser reprogramados através de um protocolo de comunicação (codificação – Algoritmo) em que se convencionou as relações entre os símbolos e a forma de trabalharmos com eles com as formas que a máquina pode trabalhar.

Um algoritmo é uma lista de instruções logicamente ordenadas que podem ser executadas (processas ou operadas – sugestão de pesquisa: operadores) por um autômato (ou mesmo humano). Autômato é aquele que o recebe através de Inputs (entradas - Teclado - Mouse), e que, após o processamento, podem, dependendo da forma em que foi escrita, interpretam e desenvolvem ou não uma resposta para devolver por seus Outputs (saídas - Tela - Impressora, registradores de computadores). Ou seja, como uma receita de bolo, representam instruções a serem executadas para se ter algumas respostas. Assim, utilizando a capacidade computacional do meio, podemos faze-la trabalhar por nós.


Exemplificando rapidamente o que seja um algoritmo
 
Imagine uma instrução qualquer. Um a instrução imperativa do tipo:

"faça isso" ou "faça aquilo". Algo como "Bote o lixo pra fora", "vá tomar banho"...

Supondo a instrução:Escreva de 1 até 10.
Para que possamos chamar uma instrução de qualquer lugar, daremos um titulo para uma função. Dessa forma, se dermos o nome da função de "Execute" poderemos chamar a instrução assim:

Execute();

Dentro desse titulo, que poderá ser referenciado de qualquer lugar que queiramos, deverá existir nossa instrução a ser executada. Algo semelhante a isso:

Execute()
{
  
Escreva de 1 até 10
}





Tente algo assim (Receita de Bolo - É um algoritmo):

<script> 


// Bara barra é uma forma de comentário valido somente par auma linha. A outra é o seguinte:
/*

To
das as linhas entre estas barras e asteriscos

Todas as linhas entre estas barras e asteriscos

Todas as linhas entre estas barras e asteriscos

Todas as linhas entre estas barras e asteriscos

*/
// escreva tudo isso em vermelho no bloco de notas e salve com o nome de script.html
// Atenção! Não é pra salvar com o nome de script.html.txt
// se vc ver o símbolo do navegador no arquivo é pq deu certo.
// Se vc ver o símbolo do bloco de notas é pq vc não sabe mudar a
// extensão do arquivo.
// se não souber como faz pra mudar a extensão do arquivo: procura no google
// lembre-se dos espaços e das quebras de linha.



// criando a função:
function Execute()
{

     // Pesquise sobre o que seja laço de repetição em javascript
     for( var i=1; i<=10; i++ )
     document.write(i + ", ");
}

// chamando a função:

Execute();

</script>


Isso significa que se em algum lugar do código aparecer a frase "Execute()", uma sequencia de um até dez deverá ser escrita na tela. Tal titulo também poderá ser chamada de função. Da mesma forma que temos as funções em matemática, também poderemos realizar ações utilizando elas dentro da computação.


Aridade e o número de parâmetros de uma função


As vezes a função não precisa de nenhum valor exterior para executarmos. Por exemplo a instrução acima, "Executar()". Entre os parênteses, nada. Se quisermos trabalhar com algum dado a mais, vindo de outro lugar qualquer, podemos injetar esse valor dentro da função, para que as instruções internas a esta função possam enxerga-las e trabalhar com elas.

O número de parâmetros (objetos necessários) para uma operação, método ou função matemática, chama-se "aridade". Assim, uma função soma, por exemplo, pode ser construida assim:

Soma(a, b)
{
   retorne a+b;
}



os valores a e b entre parênteses é o que chamamos de parâmetros e a quantidade de parâmetros que um método, operação ou função exige, podemos chamar de aridade



Tente algo assim:


<script>

// escreva tudo isso em vermelho no bloco de notas e salve com o nome de script.html
// Atenção! Não é pra salvar com o nome de script.html.txt
// se vc ver o símbolo do navegador no arquivo é pq deu certo.
// Se vc ver o símbolo do bloco de notas é pq vc não sabe mudar a
// extensão do arquivo.
// se não souber como faz pra mudar a extensão do arquivo: procura no google
// lembre-se dos espaços e das quebras de linha.

// criando a função:
function soma(a, b)
{
     document.write(a+b);
}

// chamando a função:
soma(7, 11);

</script>



Assim podemos classificar as Relações, operações, métodos ou funções de forma que:

A aridade de uma Relação binaria é 2. Precisamos de 2 parâmetros para ser estabelecida a relação binária xRy. Lê-se: x relação y, onde x e y são os parâmetros.

A aridade da operação soma é 2. Precisa de 2 parâmetros numéricos para ser executada. a + b. Lê-se a mais b. Os argumentos a e b demonstram que a aridade da operação é 2;

A aridade de uma operação de negação tem aridade igual a 1. Ou seja, é unária. Negar exige uma única proposição como parâmetro. Supondo que o sinal de negação seja "~": ~p. Lê-se "não p", onde "p" é o argumento.

Uma simples proposição (p) ou uma constante (um valor numérico qualquer), tem aridade igual a 0, por não precisar de parâmetros. Ou seja, é uma operação nulária.

Podemos entender que uma Relação é qualquer vínculo, qualquer ligação, ou estabelecimento de uma associação, uma correspondência que só se pode fazer ou encontrar entre no mínimo duas coisas (ou dois objetos ou mesmo entre outras duas relações). Assim as Relações podem ser:

a) ou entre uma coisa e ela mesma. É uma Relação unaria, pois podemos resumir a quantidade de parâmetros necessários a um. Ou seja, só existe um parâmetro para se estabelecer essa relação, exemplo a negação;

b) ou entre uma coisa e outra coisa. É uma Relação binaria, ou seja, entre 2 objetos. Geralmente a que utilizaremos será uma relação binária;

c) ou entre umas coisas e outras coisas. Não é uma Relação binaria, ou seja, existe mais de 2 objetos envolvidos na relação.

Uma relação que tem n parâmetros é considerada "n-ária" (Enaria);

Na programação, podemos ter algumas vantagens, como criar a de métodos genéricos que possam receber um único tipo de elemento (Aridade igual a um?): Uma lista de Objetos (Array). É no interior da função ou método se Escolhe a forma de como se trabalhar com a informação recebida atraves deste único parâmetro dado.





Resumo do que se deve entender por orientação a objetos para esta leitura

Inicialmente começamos estudando matemática já sabendo uma linguagem. A nossa língua: O português (No caso do Brasil). Mas estamos tão pouco acostumados a entender os fragmentos importantes da linguagem, que somente poucos tem a oportunidade de se surpreender com ela. Muitos simplesmente deixam as coisas correrem frouxamente e poucos fazem um exame mais profundo da relação entre os fatos da realidade, a linguagem e seus significados nos resultados finais. Poucos levam isso para a linguagem matemática, e se levarmos podem nos surpreender.



 
Recursividade

Falávamos agora a pouco sobre algoritmos. As frases de um algoritmo são imperativas. Supondo que podemos ter uma função do tipo "Execute()", o que aconteceria se dentro da construção desta função, existisse um comando para que ela chamasse a si mesma?


 

Cuidados com a máquina


A linguagem de computação e a matemática permite que possamos representar e executar instruções infinitamente chamando a si mesma. Isso não é algo que seja interessante, pois loops infinitos e sem respostas finais podem ocupar processos da maquia de forma desnecessária. Ou seja, devem ser evitados.

Assim, será de se esperar que uma função escrita como a abaixo, escreva infinitamente "olá" na tela e nunca termine (A não ser que feche a janela, matando o processo). Exemplo:

Execute()
{
   Escreva "olá" ;
   Execute();
}

Algo assim fará escrever
"olá" na tela sem parar. Veja como é chato...
Tente algo assim:

<script>
// escreva tudo isso em vermelho no bloco de notas e salve com o nome de script.html
// Atenção! Não é pra salvar com o nome de script.html.txt
// se vc ver o símbolo do navegador no arquivo é pq deu certo.
// Se vc ver o símbolo do bloco de notas é pq vc não sabe mudar a
// extensão do arquivo.
// se não souber como faz pra mudar a extensão do arquivo: procura no google
// lembre-se dos espaços e das quebras de linha.

function Execute()
{
    alert("Olá");
    Execute();
}

Execute();
</script>


 


Para evitarmos que deixemos loops infinitos na memória, é recomendável deixarmos uma forma de podar a recursão. Exemplo:
<script>
// escreva tudo isso em vermelho no bloco de notas e salve com o nome de script.html
// Atenção! Não é pra salvar com o nome de script.html.txt
// se vc ver o símbolo do navegador no arquivo é pq deu certo.
// Se vc ver o símbolo do bloco de notas é pq vc não sabe mudar a
// extensão do arquivo.
// se não souber como faz pra mudar a extensão do arquivo: procura no google
// lembre-se dos espaços e das quebras de linha.

function Execute(n)
{
    alert("Olá");

    if(n>1) // limite da poda
    Execute(n-1); // decremento do limite antes de aprofundar na recursividade
}

Execute(5);
</script>


Escolhendo o nível do detalhe de observação do universo

Para delimitarmos qualquer elemento, precisaremos de referências. Assim, são exigidos, por exemplo, que se dê:

a) medida de referência (base): por exemplo a medida de um metro, grama, kg… alguma que possuamos referência.

b) numérica (quantidades dessa base): comparada com a medida dada acima: 1, 2, 3, 3.1415...

A combinação das duas forma, por exemplo:
Distancia: 2m
Peso: 5kg
Volume:1L
.
.
E assim por diante


Exemplo em javascript:




<html>
<head>
<script>

    // se o valor numerico dado for maior que 360, refaz o angulo dado  
    manterLimites = function(angulo)
    {
        while(angulo>=360)
        {
            angulo=angulo-360;
        }
        while(angulo<0)
        {
            angulo=angulo+360;
        }
        return angulo;
    }

    // pega a coordenada (x,y) equivalente do angulo
    getSenCos = function(angulo)
    { 
        angulo = manterLimites(angulo);
        seno =  Math.sin(angulo * Math.PI / 180);
        cose =  Math.cos(angulo * Math.PI / 180);
        return [cose, seno];
    }




    galho0 = function(ctx, x1, y1, tamanho, angulo, poda)
    {
        var senCos= getSenCos(angulo) 
        var tx = x1+tamanho*senCos[0]
        var ty = y1+tamanho*senCos[1]
        ctx.lineWidth = 4*poda/8;//*poda;
        ctx.beginPath();

        //verde - green
        ctx.strokeStyle="#808000";

        // pontos iniciais e finais que devem ser desenhados Pi(x, y) e Pf(x, y)
        ctx.moveTo(x1,y1);
        ctx.lineTo(tx,ty);

        ctx.stroke();
        if( poda>1 )
        {
            galho0(ctx, tx, ty, tamanho*0.55, angulo+(poda*5),poda-1 )
            galho0(ctx, tx, ty, tamanho*0.95, angulo, poda-1 )
            galho0(ctx, tx, ty, tamanho*0.55, angulo-(poda*5),poda-1 )
        }
    }



    galho1 = function(ctx, x1, y1, tamanho, angulo, poda)
    {
        var senCos= getSenCos(angulo) 
        var tx = x1+tamanho*senCos[0]
        var ty = y1+tamanho*senCos[1]
        ctx.lineWidth = 4*poda/8;//*poda;
        ctx.beginPath();

        //verde - green
        ctx.strokeStyle="#808000";

        // pontos iniciais e finais que devem ser desenhados Pi(x, y) e Pf(x, y)
        ctx.moveTo(x1,y1);
        ctx.lineTo(tx,ty);

        ctx.stroke();
        if( poda>1 )
        {
            galho1(ctx, tx, ty, tamanho*0.55, angulo+30,poda-1 )
            galho1(ctx, tx, ty, tamanho*0.95, angulo, poda-1 )
            galho1(ctx, tx, ty, tamanho*0.55, angulo-30,poda-1 )
        }
    }


    galho2 = function(ctx, x1, y1, tamanho, angulo, poda)
    {
        var senCos= getSenCos(angulo) 
        var tx = x1+tamanho*senCos[0]
        var ty = y1+tamanho*senCos[1]
        ctx.lineWidth = 2*poda/8;//*poda;
        ctx.beginPath();

        //verde - green
        ctx.strokeStyle="#808000";

        // pontos iniciais e finais que devem ser desenhados Pi(x, y) e Pf(x, y)
        ctx.moveTo(x1,y1);
        ctx.lineTo(tx,ty);

        ctx.stroke();
        if(  poda>1 )
        {
            galho2(ctx, tx, ty, tamanho*0.75, angulo+(poda*3.5 ), poda*0.5)
            galho2(ctx, tx, ty, tamanho*0.75, angulo, poda*0.5 )
            galho2(ctx, tx, ty, tamanho*0.75, angulo-(poda*3.5 ), poda*0.5 )
        }
    }




    galho4 = function(ctx, x1, y1, tamanho, angulo, poda)
    {
        var senCos= getSenCos(angulo) 
        var tx = x1+tamanho*senCos[0]
        var ty = y1+tamanho*senCos[1]
        ctx.lineWidth = 4*poda/8;//*poda;
        ctx.beginPath();

        //verde - green
        ctx.strokeStyle="#808000";

        // pontos iniciais e finais que devem ser desenhados Pi(x, y) e Pf(x, y)
        ctx.moveTo(x1,y1);
        ctx.lineTo(tx,ty);

        ctx.stroke();
        if( poda>1 )
        {
            galho4(ctx, tx, ty, tamanho*0.85, angulo+(poda*4),poda-1 )
            galho4(ctx, tx, ty, tamanho*0.85, angulo-(poda*4),poda-1 )
        }
    }



    load = function()
    {
        var c = document.getElementById("myCanvas");
        var ctx = c.getContext("2d");
        galho0(ctx, 100, 250, 45,   0-90, 6);
        galho1(ctx, 250, 250, 45,   0-90, 6);
        galho2(ctx, 500, 250, 75,   -90, 20);
        galho4(ctx, 100, 450, 45,   0-90, 6);
        //galho(ctx, 250, 250, 45,  90+45, 4);
        //galho(ctx, 250, 250, 45, 180+45, 4);
          //galho(ctx, 250, 250, 45, 270+45, 4);
    }
</script>
</head>
<body onload="load();">
<canvas id="myCanvas" width="800" height="500" style="border:1px solid #000000;">
</canvas>
</body>
</html>


Sugestão para leitura:

http://tivideotutoriais.blogspot.com.br/2013/07/recursividade.html
http://tivideotutoriais.blogspot.com.br/2015/10/javascript-movimento-canvas-seno.html
http://tivideotutoriais.blogspot.com.br/2015/11/javascript-movimento-canvas-seno.html




 Regras básicas da orientação a objetos (Conjuntos)

Regras:

Para afirmar que um(s) elemento(s) possui(em) ou não uma determinada Relação deveremos seguir as regras da operação dada. Nossas regras, são inicialmente, uma forma que permitirá a nós ou a um autômato executar uma instrução qualquer. Algo como:

a) Definir que um elemento pertence ou não a um conjunto ou possua a propriedade de um conjunto (estabelecer uma relação e aceitar como verdade);

b) Verificar se é verdade que, apresentando todos os parâmetros necessários a uma função, a função dê uma resposta lógica;

c) Mostrar alguma informação desejada, naquele momento, para ou uma função, ou método ou  outro autômato superior.




Relação de Pertinência e o Tudo


Relação de pertinência

 

Tudo
no universo
é composto de alguma coisa (e o vazio).

Estas são as formas mais simples de se dizer qual é a relação de pertinência ou continência de um conjunto ou objeto (elemento) para com um outro conjunto de objetos:

Exemplo 1: Um carro, por exemplo, é composto por no mínimo 1 acento, 4 rodas, 2 portas, 1 motor, 1 chassi, latarias. (Para qualquer coisa semelhante com isso, mas faltando algum dos itens dados, é dito que o carro está quebrado.)

Exemplo 2: Uma casa pode ser considerada composta por tijolos, telhas, vergalhões e cimento e que formem compartimentos com portas e janelas.

Exemplo 3: A molécula de água é composta por 2 átomos de hidrogênio e um de oxigênio.

Exemplo 4: a pertence A

Exemplo 5: A contem B




A partir de agora, começarei a falar das relações simbólicas matemáticas e as relações que elas terão com o a máquina de testes que apresentarei em javaScript.

Estabelecer uma relação entre o símbolo de "pertencer" ao seu significado exige, implicitamente, os conceitos de "elemento", "conjunto" e de "para todo" (limite da busca – O autômato tem que verifica item por item do conjunto - Arrays de Objetos que o compõem). Pelo menos para que se possa responder se existe ou não alguma relação entre um "elemento" e "algum elemento" do conjunto. Caso da busca como por exemplo de se é verdade que 'a' pertence a 'A'. Para saber se isso é verdade um autômato do array deve verificar isso e a resposta deve ser um empilhado dos objetos que conferem com nossa pesquisa. Percorre-se todos os elementos de 'A' para comparar com 'a'.

Estabelecer uma relação entre o significado de "para todo" com o símbolo "para todo" exige, implicitamente, o conceito de pertinência, pois se , para qualquer que seja ele, então este encontrado pertence àquele conjunto.


Veja essa regra:
Tudo no universo é composto de alguma coisa (e algum vazio).
 

Se seguirmos a regra acima para tudo. Mesmo para as coisas que compõem o universo. Também poderemos analisar o universo em qualquer escala e aqui, teríamos então que aceitar que:

podem existir 2 tipos de universos, tais que:

 Um universo com um superconjunto inicial;
 Ou um universo sem superconjunto inicial.

Desta forma diferenciaremos um universo de outro, mas mantendo a mesma lógica. 


Por hora, consideraremos como o da matemática (Com um superconjunto inicial):
Que se U engloba todos os conjuntos, então ele é considerado o maior em tamanho e em hierarquia em relação a todos os outros conjuntos. Ou seja, visualmente ele é o ultimo superconjunto. O primeiro do topo hierárquico.


O universo é o conjunto de todos os conjuntos 

será o mesmo que: U contem Todos os Conjuntos.



Quantificadores e Relação de pertinência

É uma estratégia lógica fragmentarmos os problemas em partes menores para a sua solução (Dividir pra conquistar), particionar o mundo, para compreendê-lo até seus limites. Por isso, aparentemente, o mundo se constrói com o encadeamento de objetos menores e, preferencialmente, buscando os que são incontestáveis. Ou seja, as menores unidades que possuem significado e é a base de todas as construções maiores. Para a química, algo do nível dos átomos, se compararmos com as moléculas. No caso, o átomo, para a lógica, chama-se de axioma. E a molécula, no caso da lógica, é chamado de teorema. Os axiomas são os tijolos para o encadeamento de conceitos maiores que fazem sentido. Ou seja, são teoremas.

Dentro do conjunto descrito pelos axiomas de Peano, o um (1) é o átomo do conjunto, enquanto que, visto de dentro do conjunto da operação de multiplicação, os números primos são os átomos dos números compostos (Não primo).

A busca por axiomas e valores verdade baseando-se no conhecimentos que temos sobre a teoria dos conjuntos e dos números (que podem ser os tijolos de Teoremas - e mesmo de decisões), pode nos fazer crer que tudo pode ser finitamente divisível. Por exemplo a forma discreta dos números (Conjunto dos naturais).

Mas existe realmente um axioma básico e inicial que pudesse formar tudo? OU toda a existência pode ser abarcada por ela mesma, como na suposição de um universo como o conjunto de todos os conjuntos? É possível que todos os teoremas sejam compostos por outros teoremas e que seja assim infinitamente? A química, se limita ao átomo, mas a compreensão da química é limitado ao nível atômico. Menores que isso passa a ser do campo da mecânica quântica, onde cálculos newtonianos (Clássicos) não podem nos ajudar.

Alguns dias atrás, conversando com uma pessoa sobre a natureza do universo, tal pessoa me disse que não suportaria saber se a natureza pode ser explicada e demonstrada através de uma série simples de axiomas e regras, ou se tal tentativa é, na verdade, uma coleção infinitamente complexa de axiomas e regras. Qualquer que fosse a resposta, ela não suportaria saber. O infinito e indeterminado ou o finito e determinado possuem ambos seus lados sombrios.

É compreensível que tenhamos medo de entender as coisas. Nem sempre, nossas expectativas nos correspondem, pois se pelas teorias de conjunto podemos ter infinitos subconjuntos, não se sabe sobre a natureza da matéria. Ainda podemos encontrar surpresas. Por exemplo, alguns que "cabalisticamente" (sonham com mágica) e acreditam que podemos encontrar um único axioma e uma única regra para explicar tudo, de repente chega ao entendimento lógico de que isso talvez não seja possível. Algo, que dependendo da importância, pode deixá-lo chocado.

Sugestão de vídeo sobre como a regra do octeto não explica bem a natureza das ligações químicas:

https://www.youtube.com/watch?v=M71wqjf4SuE




Axiomas:
1) elemento:

Um Elemento, na matemática, é o mesmo que um objeto na computação. A diferença é que consideraremos como Elemento, se as propriedades do objeto tiverem sido definidas e possam ser acessíveis às nossas comparações. No caso de um elemento, uma propriedade que ele poderá ter, por exemplo, é um valor numérico.

2) conjunto:

Um conjunto, na matemática, é o mesmo que uma Lista (ou array) na computação. Uma lista, assim como os conjuntos, podem conter Objetos ou outras listas. Mesmo para elementos e subconjuntos. Podemos construir conjuntos e comparar conjuntos e seus conteúdos com elementos por meio do estabelecimento de relações.

3) Relação:

Será para, nos, o que é uma função na computação. Atenção! Apesar de estarmos correlacionando os conceitos da computação e matemáticos, o conceito de "função" da computação não pode ser confundido com o de "função" da matemática. Por enquanto fizemos uma comparação como o que é apresentado na matemática para o entendimento do que seja a aridade.

Diferença entre função e método
Na computação, podemos ter uma função, que retorna valor e um método que executa, geralmente, instruções que ou levam informação diretamente para o usuário, ou que são visíveis somente ao processo. Não retornam valor. As funções diferenciam-se do método por ter no seu final algo semelhante a um "return" :


<script>
// escreva tudo isso em vermelho no bloco de notas e salve com o nome de script.html
// Atenção! Não é pra salvar com o nome de script.html.txt
// se vc ver o símbolo do navegador no arquivo é pq deu certo.
// Se vc ver o símbolo do bloco de notas é pq vc não sabe mudar a
// extensão do arquivo.
// se não souber como faz pra mudar a extensão do arquivo: procura no google
// lembre-se dos espaços e das quebras de linha.

function sou_uma_funcao(n)
{
    return 11*n;
}
 function sou_um_metodo(n)
{
    alert(
sou_uma_funcao(n));
}

sou_um_metodo(7);
</script>


poderemos determinar, medir, operar, parâmetros, fornecidos ou não, modificando algum estado ou propriedade, ou mostrando o resultado de suas operações.

3.1) Valor verdade e Conceitos de Verdade e Falsidade.

As proposições verdadeiras possuem valores verdade verdadeiro e estarão colocadas dentro do conjunto das verdades. As proposições falsas possuirão valores verdade falsos e estarão colocadas no conjunto das falsidades.

Somente poderão existir estes 2 estados: verdadeiro ou falso, para as proposições que podemos utilizar na maquina. Mas devemos estar atentos à indecidibilidade de certas verificações. Ou seja, serão consideradas questões "indecidíveis". Este último caso, criaremos quando alguma análise ir além da capacidade da máquina. Isso é uma medida de segurança, para evitarmos os loops infinitos e pouparmos a máquina. E para que tudo funcione, aceitemos todos os axiomas dados agora como verdadeiros.

Veja selagem e sistemas de chave e fechadura:
http://tivideotutoriais.blogspot.com.br/2016/08/verdade-x-falsidade-certo-x-errado.html


3.2) pertence ou Relação de pertinência:

Relação mais simples possível de se estabelecer.   
Uma Relação de Pertinência é verificada ou estabelecida entre um(s) elemento(s) e um(s) conjunto(s), e será considerada como verdadeira se e somente se o(s) elemento(s) pertencer(em) ao(s) conjunto(s). Ela deverá ser pré-escrita, como a relação mínima a ser possível de ser estabelecida, ou seja, a primeira e a base, para todo o resto dos testes.
No fundo o que o autômato deverá realizar é a busca se um objeto pertence ou não à sua lista de objetos.


3.3) negação:

Uma forma de negar uma proposição. Por exemplo, o elemento pode pertencer a um conjunto ou não e poderemos escrever estas duas opções como:

a) x não pertence a A
b) x pertence a A


4) todos:

É uma relação que significa que deve-se trazer a quantidade máxima de elementos referentes a um conjunto para contexto. Ou seja, todos os elementos de um Array. Com ele, poderemos estruturar ou deduzir outras relações, tais como o conceito de continência. É a instrução que diz ao Autômato para percorrer toda a lista de objetos do conjunto.

Outras propriedades importantes

Para tudo funcionar, precisaremos de uma forma de identificar cada elemento, conjunto, relação, proposição que tenhamos criado. Para isso cada um deles precisará ter um nome identificador que chamaremos de ID. Cada definição poderá ter a propriedade que desejarmos. O nome é uma delas.

Outra coisa que poderemos encontrar nas definições são as forma de descrição. Somente existirão duas formas para se descrever um elemento ou mesmo todos os elementos de um conjunto, um conjunto ou mesmo relações.

Por exemplo, um conjunto pode ser descrito por uma lista de elementos ou por uma fórmula que determine quais são seus elementos levando-se em consideração a propriedade "valor". De posse ou dos elementos do conjunto ou da fórmula de geração destes elementos, deve-se ser possível realizar verificações de pertinência:

a) comparando o valor do (ou de cada) elemento procurado com todos os elementos do conjunto ou;

b) 1º - calcula-se se os parâmetros de busca dos dados estão dentro dos limites fornecidos pela fórmula, e se sim, 2º - comparar o valor do (ou de cada) elemento com a fórmula (definição) de classificação dos elementos.


Portanto tudo o que for definido por nós deverá:

Conter uma lista de propriedades.

Exemplo: Para o caso do conjunto suas propriedades são:

a) Um nome para identificação;

b) Uma lista de elementos ou fórmula de geração de seus elementos.


'Algo pertence (ou não) a algum lugar'. O verbo pertence é transitivo indireto no português (ver exemplo o negritado) e direto usando-se a notação matemática.


Exemplo em português:

O vermelho pertence ao conjunto das cores.


Exemplo em matemática:

v ∈ C


Então, no nosso caso, não consideraremos como importante para a linguagem que criaremos se existe ou não algum conectivo para ligar os parâmetros ao verbo. O que vem do português não poderá afetar nossa linguagem. Como o exemplo do verbo pertencer é uma relação binária, ou seja, tem aridade igual a 2 (Verifica se um elemento pertence a um  conjunto), serão necessários que cada um dos elementos, conjuntos, ou mesmo outra relação, tenham um nome de identificação. Isso nos ajudará a analisarmos qualquer relação entre elementos, conjuntos ou mesmo outras relações sem enganos. Além disso, podemos criar contextos e muitos outros detalhes que de agora em diante deixarei à escolha do leitor.

Falamos um pouco sobre o que é uma relação, temos que estabelecer um protocolo de comunicação. Por enquanto tudo o que falamos é de informação que poderá ser transmitida. Mas não de quem a interpretará. Nos podemos ler e entender a linguagem matemática. Autômatos programados também podem interpretar e executar ações seguindo uma lista de instruções.

Como chamaremos e como trabalharemos com as coisas em cada campo? Alguns campos possuem Relações. Conforme dito, as Relações, assim como alguns métodos (ou função – parte de um algoritmo), também podem pedir parâmetros para trabalhar. A diferença, basicamente, está nos nomes que utilizamos de um campo de estudo para o outro, mas que pelas semelhanças poderemos estabelecer as correspondências. Por exemplo álgebra de Boole e conjuntos. Desta forma, se um algoritmo precisa de Objetos ou Listas de Objetos como parâmetros para ser executado, uma Relação (não sendo nulária) também precisa de Objetos ou Listas de Objetos para ter um significado. Se podemos estabelecer regras para trabalharmos com os símbolos, então um autômato (computador) também deverá. Assim, para que um programa possa nos apoiar em nosso estudo sobre matemática e lógica, ele deve ser capaz de trabalhar com os mesmos símbolos (relações estabelecidas com os significados) e regras, com os quais somos capazes de trabalhar com a mente, o papel e o lápis. Deste modo, podemos presumir que um programa como o que buscamos deve nos permitir, inicialmente, a execução de 3 tipos de ações (regras – ações ou modificações permitidas e não permitidas).
Nossa maquina de testes deve portanto ser capaz de:
Definir
   Novas Regras (Relações ou funções, podendo ser composições que incluam ou não outras relações, como a de pertinência);
    Novas Verdades;
    Novos Objetos;
    Novas Listas.

Mostrar
    Os nomes, as propriedades, os tipos de parâmetros e parâmetros necessários em uma relação definida;
    As instruções e os tipos de parâmetros exigidos de uma regra definida;
    O valor verdade definido em uma proposição;
    Os nomes e as propriedades de um objeto definido;

Verificar
    Se uma proposição dada é verdadeira, baseado-se nas premissas definidas.


Resumindo, falamos sobre:

Axiomas:
1) Elemento
2) Conjunto
3) Relação
3.1) Valor verdade
3.2) Pertinência
3.3) Negação
4) conceito de todo

Autômato possuirá as seguintes propriedades:
1) Definir;
2) Verificar;
3) Mostrar dados desejados

Regras:
Todo objeto definido:
1) terá um nome;
2) será descrito por valores ou fórmulas em javascript.

Aceitando estes conceitos, tente a prática - Teste pratico em javaScript:

<!DOCTYPE html>
<html>
 <meta http-equiv="Content-Type" content="text/html;charset=ISO-8859-8">
<body>
<table width="100%" height="100%">
    <tr><td ><svg id="mySVG" style="width:100%; height:300px; background: FloralWhite ;" ></svg></td></tr>
    <tr><td ><div id="btns_source" ></div></td></tr>
    <tr><td ><div id="codigo" style="width:100%; height:100%; overflow-y:scroll;" ></div></td></tr>
</table>

<textarea id="codigo_inicial"  style="display:none; ">
definir Elemento Elemento_k = { Valor = 7 , p = 8 }
definir Elemento Elemento_l = { Valor = 31 }
definir Elemento Elemento_x = { Valor = 8 }
definir Elemento Elemento_y = { Valor = 9 }
definir Elemento Elemento_z = { Valor = 11 }
definir Conjunto Conjunto_A = { Elementos = [ Elemento_k , Elemento_x , Elemento_y ] }
definir Verdade p = [ Elemento_k ] PERTENCE [ Conjunto_A ]
definir Verdade q = NEGAR( [ Elemento_x ] PERTENCE [ Conjunto_A ] )
definir Relação Pertinencia = Pertence(array_a_procurar, Conjunto_de_busca) 
verificar [ Elemento_k , Elemento_x ] PERTENCE [ Conjunto_A ]
verificar [ Elemento_x , Elemento_z ] PERTENCE [ Conjunto_A ]
verificar [ Elemento_l , Elemento_z ] PERTENCE [ Conjunto_A ]
definir Relação sucessor = Sucessor(n) 
definir Elemento x[] = |  x[0] = { Valor = 0 }  AND [ TODO x ] IMPLICA  [ x[sucessor(n)] = sucessor(x[n]) ]
definir [ TODO x ] PERTENCE [Conjunto_A]
definir Elemento y[] = [ TODO Elementos DE Conjunto_A ] PERTENCE [ Conjunto_B ]
definir [Conjunto_A] CONTEM [ TODOs Elementos x ]
Mostrar Conjunto_A ;

//Comentario
//definir Elemento Elemento1 = { valor = 7 }
//definir Conjunto Conjunto1 = { valor = [ 7 , 11 , 13 , 17 ] }
//definir regra PERTENCE = (Elementos=[Elemento||Lista], Conjunto=[Lista]){}
//definir tipo Universo = { TODO (x,y) | PERTENCE([x,y],R) }
//definir Elemento Objeto1 = New( Elementos = "{ELEMENTO PERTENCENTE NATURAIS}" )
</textarea>

</body>

<script>

    //**********************************************************************************************************************************
    //**********************************************************************************************************************************
    //**********************************************************************************************************************************
    //**********************************************************************************************************************************
    Selector = function()
    {
        if (window.getSelection)
        {
            return window.getSelection();
        }

        else if (document.getSelection)
        {
            return document.getSelection();
        } 
    }

    createRange = function (cell)
    {
        var rng=null;
        if(cell.createRange)
        {
            rng=cell.createRange();
        }
        else if(cell.getRangeAt)
        {
            rng=cell.getRangeAt(0);
            if(rng.toString()=="") rng=null;
        }
        return rng;
    }

    getTextNodesIn = function (node)
    { 
        var textNodes = [];
        if (node!=undefined && node.nodeType !=undefined && node.nodeType == Node.TEXT_NODE )
        {
            textNodes.push(node);
        }
        else
        {
            var children = node.childNodes;
            for (var i = 0, len = children.length; i < len; ++i)
            {
                textNodes = textNodes.concat( getTextNodesIn(children[i]) );
            }
        }
        return textNodes;
    }

        getCursorPosition = function (div)
        {
            var se = Selector (); 
            var range = se.getRangeAt(0);  
            textNodes = getTextNodesIn(div);
            countChar=0;
            for (var i = 0; i<textNodes.length; i++ )
            {
                if ( range.startContainer==textNodes[i] )
                {
                    return countChar+range.startOffset
                } 
                countChar += textNodes[i].textContent.length
            }
            return null;
        }

        getStartContainer = function (div)
        {
            var se = Selector ();
            var range = se.getRangeAt(0);  
            textNodes = getTextNodesIn(div);
            return range.startContainer;
        }   

        getSelectionPosition = function (div)
        {
            var se = Selector (); 
            var range = se.getRangeAt(0);  
            textNodes = getTextNodesIn(div);
            endCharCount = 0;
            Int=null
            end=null
            for (var i = 0; i<textNodes.length; i++ )
            {
                if ( range.startContainer==textNodes[i] )
                {
                    Int = endCharCount+range.startOffset
                } 

                if ( range.endContainer==textNodes[i] )
                {
                    end = endCharCount+range.endOffset
                    break;
                }
                endCharCount += textNodes[i].textContent.length
            } 
            return [Int, end];
        }

        setSelectionPosition = function (div, start, end)
        {
            range = createRange(document);
            range.selectNodeContents(div);
            var foundStart = false;
            var charCount=0;
            textNodes = getTextNodesIn(div);
            var aa=0
            var bb=0
            for (var i = 0; i<textNodes.length; i++ )
            {  
                velhoCount = charCount;
                charCount += textNodes[i].textContent.length
                if (!foundStart && velhoCount <= start && start <= charCount   )
                {
                    aa = textNodes[i].textContent.length  - (charCount - start );
                    range.setStart(textNodes[i], aa );
                    foundStart = true;
                }

                if (foundStart && end <= charCount)
                {
                    bb = textNodes[i].textContent.length - (charCount - end) ;
                    range.setEnd(textNodes[i], bb );
                    break;
                }

            }
            var sel = Selector();
            sel.removeAllRanges();
            sel.addRange(range);
            div.focus();
        }

        setCursorPosition = function (div, position)
        {
            range = createRange(document);
            range.selectNodeContents(div);
            var charCount = 0
            var endCharCount;
            textNodes = getTextNodesIn(div);
            for (var i = 0; i<textNodes.length; i++ )
            {
                textNode = textNodes[i];
                endCharCount = charCount + textNode.length;
                if (position >= charCount && position <= endCharCount )
                {
                    range.setStart(textNode, position - charCount);
                    range.setEnd(textNode, position - charCount);
                    range.collapse(false);
                    break;
                }
                charCount = endCharCount;
            }
            var sel = Selector();
            sel.removeAllRanges();
            sel.addRange(range);
            div.focus();
        }

    function isArraycontainsStr(array, str)
    {
        var i = array.length;
        while (i--)
        {
            if (array[i] == str)
            {
                return true;
            }   
            }
            return false;
    }

    function removeAll(arr, item)
    {
        for(var i = arr.length; i--;)
        {
            if(arr[i] == item)
            {
                arr.splice(i, 1);
                  }
              }
        return arr;
      }



    //**********************************************************************************************************************************
    //**********************************************************************************************************************************
    //**********************************************************************************************************************************
    //**********************************************************************************************************************************


    function replace_color_by_comentario(string, color_3)
    {
        var abrir_comentario    = "<span style=\"font-size:120%; font-weight: bold; color:"+color_3+"\">";
        var fechar         = "</span>"
        var qt_bracos = [];
        var fim_de_linha=0;
        var pode_adicionar = true;
   
        for( var posicao_caractere = string.length-1; posicao_caractere>=0; posicao_caractere--)
        {
            if(string[posicao_caractere]=='\n')
            {
                fim_de_linha = posicao_caractere;
            }
           
            if(posicao_caractere>=1 && string[posicao_caractere]=='\/' && string[posicao_caractere-1]=='\/' )
            {       
                var div = document.createElement("div") ;
                var txt_html = string.substring(posicao_caractere-1, fim_de_linha );
                var quantidade_caracteres_inicial = txt_html.length ;

                div.innerHTML = txt_html
                txt_html   = txt_html.replace(/<span ([^>]|[\d\-\%;])*>/g, "");   
                quantidade_caracteres_inicial -= quantidade_caracteres_inicial-txt_html.length
                txt_html   = txt_html.replace(/<\/span>/g,"");

                quantidade_caracteres_inicial -= quantidade_caracteres_inicial-txt_html.length
                var temp =  abrir_comentario + txt_html + fechar ;
                string =  string.substring(0,posicao_caractere-1) + temp + string.substring(fim_de_linha, string.length)
                fim_de_linha-=txt_html.length-div.textContent.length-abrir_comentario.length-fechar.length ;       
            }
        }       
        return string;
    }
   
    function replace_color_by_delimiters(string, color_1, color_2)
    {
        var delimiters         = [  '(',  ')',  '[',  ']',  '{',  '}']
        var aspas              = [  '\'',  '\"' ]
        var valores            = [   1,    -1,    2,   -2,    3,   -3]

        var abrir_delimiters    = "<span style=\"color:"+color_1+"\">";
        var abrir_aspas        = "<span style=\"color:"+color_2+"\">";
        var fechar         = "</span>"
       
        var temp_string = string;
       
        var qt_bracos = [];
        var fim_de_linha=0;
        var pode_adicionar = true;
       
        for( var posicao_caractere = string.length-1; posicao_caractere>=0; posicao_caractere--)
        {
            if(string[posicao_caractere]=='\n')
            {
                fim_de_linha = posicao_caractere;
            }

            if(posicao_caractere>=1  && string[posicao_caractere]==aspas[1] && string[posicao_caractere-1]!='\\' )
            {
                var ultima_aspas = posicao_caractere+1;
                posicao_caractere--;
                while(posicao_caractere>1 && string[posicao_caractere]!=aspas[1]  && string[posicao_caractere-1]!='\\' )
                {
                    posicao_caractere--;
                }
                var div = document.createElement("div");
                var txt_html = string.substring(posicao_caractere, ultima_aspas);
                div.innerHTML = txt_html
                var temp = abrir_aspas + div.textContent + fechar;
                string =  string.substring(0,posicao_caractere) + temp + string.substring(ultima_aspas, string.length)
                fim_de_linha-=txt_html.length-div.textContent.length-abrir_aspas.length-fechar.length;                       
            }   
            else
            {
                for(var posicao_delimitador=0; posicao_delimitador<delimiters.length; posicao_delimitador++)
                {
                    if( posicao_delimitador%2==0 && string[posicao_caractere]==delimiters[posicao_delimitador] && string[posicao_caractere-1]!='\\')
                    {
                        if(qt_bracos[qt_bracos.length-1]==-valores[posicao_delimitador])
                        {
                            qt_bracos.pop();
                            string =  string.substring(0,posicao_caractere) + abrir_delimiters + string.substring(posicao_caractere, string.length)
                            fim_de_linha+=abrir_delimiters.length;
                        }
                        else if(qt_bracos[qt_bracos.length-1]!=-valores[posicao_delimitador])
                        {
                            qt_bracos.push(valores[posicao_delimitador])
                        }                   
                        break
                    }
                    else if(posicao_delimitador%2==1 && string[posicao_caractere]==delimiters[posicao_delimitador] && string[posicao_caractere-1]!='\\' )
                    {
                        qt_bracos.push(valores[posicao_delimitador])
                        string =  string.substring(0,posicao_caractere+1) + fechar + string.substring(posicao_caractere+1, string.length)
                        fim_de_linha+=fechar.length;
                        break
                    }
                    else if( string[posicao_caractere]==aspas[0] && string[posicao_caractere-1]!='\\' )
                    {
                        if(qt_bracos[qt_bracos.length-1]== 7)
                        {
                            qt_bracos.pop(7)
                            string =  string.substring(0,posicao_caractere) + abrir_aspas + string.substring(posicao_caractere, string.length)
                            fim_de_linha+=abrir_aspas.length;
                            break
                        }
                        else
                        {
                            qt_bracos.push(7)
                            string =  string.substring(0,posicao_caractere+1) + fechar + string.substring(posicao_caractere+1, string.length)
                            fim_de_linha+=fechar.length;
                            break
                        }
                    }
                }
            }
        }
       
        if(qt_bracos.length==0) return string;
        else return temp_string  ;
    }
   
    function replace_color_by_regex(string, delimitador, color)
    {
        var res = string.match(delimitador);
        var array = [];
        for(var i=0; res!=null && i<res.length; i++)
        {
            if( !isArraycontainsStr(array, res[i]) )
            {
                // replace all regex
                  string = string.replace(new RegExp(res[i], "gim"), "<span style=\"color:"+color+";\">"+res[i]+"</span>");
                array.push(res[i]);
            }
        }
        return string;
    }

    var regex_numeros     =  /[\s](((\d)+[\.|\d](\d)+)|\d+)[\s\;]/g
    var words_classes = ["Tipo", "Relação", "verdade", "falsidade", "Elemento", "Conjunto" ]
    var words_functions = ["definir", "verificar", "mostrar"]
    var words_booleans     = ["true", "false"]

    //função muito boa. Melhor. Troca apenas por experiencia
    function replace_color_by_words(string, words, color)
    {
        if(words!="undefined")
        for(var i=0; i<words.length; i++)
        {
            var bb = new RegExp("([^\t\n\v\f\r\=\+ \.])?("+words[i]+")(?![a-z0-9_\-])", "gim");
            string = string.replace(bb, function($0,$1){ return $1?$0:"<span style=\"font-weight:bold; color:"+color+"\">"+$0+"</span>" ;})
        }
        return string;
    }


    //**********************************************************************************************************************************
    //**********************************************************************************************************************************
    //**********************************************************************************************************************************
    //**********************************************************************************************************************************

    function setStyle(tag, atributo, valor)
    {
        tag.style[atributo] = valor;
    }

    function press(event)
    {
                var position = getCursorPosition (this)
        if (event.keyCode == 13)
        {
                    event.preventDefault();       
        }

        else if(event.keyCode === 9)
        {
                    event.preventDefault();   
        }
    }

    function up(event)
    {
                var position = getCursorPosition (this)
        if (event.keyCode == 13)
        {
            this.innerHTML = "<span>"+replaceColor( this.textContent.substring(0, position) + "\n"+ this.textContent.substring( position, this.textContent.length) )+"</span>"
                    setCursorPosition (this, position+1)
        }
        else if(event.keyCode === 9)
        {
            this.innerHTML = "<span>"+replaceColor( this.textContent.substring(0, position) + "\t"+ this.textContent.substring( position, this.textContent.length) ) +"</span>"
                    setCursorPosition (this, position+1)
        }
        else
        {
            this.innerHTML = "<span>"+replaceColor( this.textContent )+"</span>"
                    setCursorPosition (this, position)
        }
    }

    //**********************************************************************************************************************************
    //**********************************************************************************************************************************
    //**********************************************************************************************************************************
    //**********************************************************************************************************************************


    function create_window_source()
    {
        var input         = document.createElement("div");
        input.id         = "txt_codigo"    
        input.style.whiteSpace    = "pre";
        //input.style.fontFamily     = "Courier New"
        input.style.fontFamily     = "Lucida Console"
        //input.style.fontFamily     = "Lucida Sans Unicode"
        input.style.fontSize     = "14px";
        //input.style.fontWeight    = "800"
        input.style.color     = "Silver";
        input.spellcheck    = false 
        input.contentEditable    = true;   
        input.onkeypress    = press;
        input.onkeyup        = up;
        input.onclick        = up;   

         input.style.width    = "100%";
        input.style.height    = "100%";

        input.style.backgroundColor    = "black";
        input.innerHTML = replaceColor( document.getElementById("codigo_inicial").value )
        document.getElementById("codigo").appendChild(input);
        var button_salvar = document.createElement("button");
        button_salvar.id = "save_source"
        button_salvar.innerHTML ="Testar"
            button_salvar.disabled = false;
        button_salvar.onclick = function()
        {
            var texto = document.getElementById("txt_codigo").textContent;

            executarLogica(texto) ;
        }
        document.getElementById("btns_source").appendChild(button_salvar);
    }

    var svgNS = "http://www.w3.org/2000/svg";
    function createCircle(id_name, r, px, py, color)
    {
        var myCircle = document.createElementNS(svgNS,"circle");
        myCircle.id= id_name;
        myCircle.setAttributeNS(null,"id","mycircle");
        myCircle.setAttributeNS(null,"cx",px);
        myCircle.setAttributeNS(null,"cy",py);
        myCircle.setAttributeNS(null,"r",r);
        myCircle.setAttributeNS(null,"fill","none");
        myCircle.setAttributeNS(null,"stroke", color );
   
        document.getElementById("mySVG").appendChild(myCircle);
    }
    //**********************************************************************************************************************************
    //**********************************************************************************************************************************
    //**********************************************************************************************************************************
    //**********************************************************************************************************************************

    create_window_source()
    createCircle("conjunto_vermelho", 40, 100, 100, "red");

    //**********************************************************************************************************************************
    //**********************************************************************************************************************************
    //**********************************************************************************************************************************
    //**********************************************************************************************************************************
   



   
    function Pertence(lista_de_objetos, conjunto, negar_ou_nao, afirmando_ou_perguntando)
    {
        if( afirmando_ou_perguntando == "perguntando" )
        {
            // se o numero de objetos no conjunto é maior que zero, ou seja, diferente de vazio, ou seja: tem ao menos um conjunto
            if(conjunto.Elementos.length>0)
            {
                //testando o primeiro objeto
                for( var posicao_na_lista_de_objetos=0; posicao_na_lista_de_objetos<lista_de_objetos.length; posicao_na_lista_de_objetos++)
                {
                    var posicao_leitor = 0;
                    var exite_objeto = false;
                    //se um elemento não pertencer ao conjunto, então a proposicao é falsa
                    while( posicao_leitor < conjunto.Elementos.length )
                    {
                        if( conjunto.Elementos[posicao_leitor]!=undefined && lista_de_objetos[posicao_na_lista_de_objetos].Valor == conjunto.Elementos[posicao_leitor].Valor  )
                        {
                            // objeto na posicao_objeto_na_lista existe
                            exite_objeto = lista_de_objetos[posicao_na_lista_de_objetos].Valor == conjunto.Elementos[posicao_leitor].Valor;
                            break;
                        }
                        posicao_leitor++;
                    }
                   
                    if( !exite_objeto )
                    {                   
                        return false;
                    }
                }
                return (negar_ou_nao=="negar"?false:true);
            }
            else
            {
                // se não tem nenhum elemento no conjunto
                return (negar_ou_nao=="negar"?true:false);
            }
        }
        else if( afirmando_ou_perguntando == "afirmando" )
        {
            for( var posicao_na_lista_de_objetos=0; posicao_na_lista_de_objetos<lista_de_objetos.length; posicao_na_lista_de_objetos++)
            {
                if(conjunto.Elementos.length>0)
                {
                    var posicao_leitor = 0;
                    while( posicao_leitor < conjunto.Elementos.length )
                    {
                        if( conjunto.Elementos[posicao_leitor]!=undefined && lista_de_objetos[posicao_na_lista_de_objetos].Valor == conjunto.Elementos[posicao_leitor].Valor )
                        {
                            return "OK!";
                        }
                        posicao_leitor++;
                    }
                    if(conjunto.Elementos==null) conjunto.Elementos = []
                    conjunto.Elementos[posicao_leitor].push(lista_de_objetos[posicao_na_lista_de_objetos]);
                    return "OK!";
                }
                else if(conjunto.Elementos_Formula != "vazio")
                {
                    conjunto.Elementos_Formula+=" ^ "+ identificador_do_objeto+" PERTENCE "+ lista_de_objetos[posicao_na_lista_de_objetos].id
                    return "OK!";
                }
                else
                {
                    conjunto.Elementos.push(lista_de_objetos[posicao_na_lista_de_objetos])
                    return "OK!";
                }
            }
            return "erro";
        }
    }




    function replaceColor( string )
    {
        string = replace_color_by_delimiters(string, "red", "Orange");   
        string = replace_color_by_regex(string, regex_numeros, "Yellow");
        string = replace_color_by_words(string, words_booleans, "Yellow");
        string = replace_color_by_words(string, words_functions, "lime");
        string = replace_color_by_words(string, words_classes, "DeepSkyBlue");
        string = replace_color_by_comentario(string, "white");   

        return string;
    }

    var context = new Object();

    function Elemento(nome_str, propriedades)
    {
        context[nome_str] = new Object();
        eval("context[nome_str]  = " + propriedades );
        context[nome_str].id = nome_str;       
        //alert(" props = " + context[nome_str].id + " valor = " + context[nome_str].Valor + " " + propriedades)       
        return context[nome_str];
    }
   
    function Conjunto(nome_str, elementos)
    {
        context[nome_str] = new Object();
        elementos = elementos.replace(new RegExp(/{Elementos:\[/, 'g'),"")
        elementos = elementos.replace(new RegExp(/\]}/, 'g'),"")
        var elems = elementos.split(",");       
        context[nome_str].id = nome_str;
        context[nome_str].Elementos_Formula = "vazio";       
        resp = "context[\""+nome_str+"\"].Elementos = [";
        for(var i=0; i<elems.length; i++)
        {
            resp += "context[\""+ elems[i] +"\"],"
            if(i==elems.length-1) resp = resp.substring(0, resp.length-1)
           
        }
        resp+="]";

        eval(resp)
       
        return context[nome_str];
    }

    function createObjeto(simbolos)
    {
        var resp = "";
        if(simbolos[3]=='=' && simbolos[4]=='{' && simbolos[simbolos.length-1]=='}' )
        {
            resp += "var "+simbolos[2]+" = Elemento(\""+simbolos[2]+"\", \"{"
            var pos=0
            while(pos+5<simbolos.length-1 )
            {
                resp += simbolos[5+pos]+":"+simbolos[7+pos]+","
                pos+=4;
            }
            resp=resp.substring(0, resp.length-1);
            resp+= "}\" );"
        }
        return resp+" " ;
    }

    function createLista(simbolos)
    {
        var resp = "";
        if(simbolos[3]=='=' && simbolos[4]=='{' && simbolos[simbolos.length-1]=='}' )
        {
            resp += "var "+simbolos[2]+" = Conjunto(\""+simbolos[2]+"\", \"{"
            var pos=0
            while(pos+5<simbolos.length-1 )
            {
               
                resp += (simbolos[5+pos]=='='?":":simbolos[5+pos])+""
                pos+=1;
            }
            resp+= "}\" );"
        }
        return resp+" " ;
    }





    var simbolos;
    function executarLogica(texto)
    {
        var linhas = texto.split("\n");
        var resp = "";
        for(var pos_linha=0; pos_linha<9;  pos_linha++)
        {
            simbolos = linhas[pos_linha].split(" ");
            var pos = 0;
            while(pos<simbolos.length)
            {
                if(simbolos[pos] == '' || simbolos[pos] == "" )
                {
                    simbolos.splice(pos, 1);
                    pos--;
                }
                pos++
            }

            var expression_definir = new RegExp(/definir/, "gim");
            var expression_objeto = new RegExp(/Elemento/, "gim");
            var expression_lista = new RegExp(/Conjunto/, "gim");
            var expression_verificar = new RegExp(/Verificar/, "gim");


            expressao_definir   = expression_definir.test(simbolos[0])
            expressao_verificar = expression_verificar.test(simbolos[0])
            expressao_objeto    = expression_objeto.test(simbolos[1])
            expressao_lista     =  expression_lista.test(simbolos[1])


            if( expressao_definir )
            {
                if( expressao_objeto )
                {
                    eval( createObjeto(simbolos)  );
                }

                else if( expressao_lista )
                { 
                    eval( createLista(simbolos)  );
                }
            }
            else if( expressao_verificar )
            {
                if( simbolos[1]=="[" )
                {
                    //alert("g")
                    var parametro1 = "";
                    var parametro2 = "";
                    var tipo_relacao = "";
                    var i=2;
                    while(simbolos[i]!="]" && i<simbolos.length )
                    {
                        if(simbolos[i]!=",")
                        {
                            parametro1+=simbolos[i]+","
                        }                       
                        i++;
                    }

                    var expression_pertence = new RegExp(/Pertence/, "gim");
                    if( i<simbolos.length && expression_pertence.test(simbolos[i+1]))
                    {
                        tipo_relacao = "Pertence"
                    }

                    while(simbolos[i]!="[" && i<simbolos.length ){i++}i++
                     while(simbolos[i]!="]" && i<simbolos.length )
                    {
                        if(simbolos[i]!=",")
                        {
                            parametro2+=simbolos[i]+","
                        }                       
                        i++;
                    }

                    if(parametro1.length>0)parametro1=parametro1.substring(0,parametro1.length-1)
                    if(parametro2.length>0)parametro2=parametro2.substring(0,parametro2.length-1)


                    eval( "alert( Pertence(["+parametro1+"],"+parametro2+", \"\" , \"perguntando\" ) )" )
                }

               
            }
        }
    }

</script>
</html>

Nenhum comentário:

Postar um comentário