A representacaox de um circuito é de extrema importancia para o simulador.
Uma representacaox complexa e detalhada torna a ferramente menos acessivel a novos usuarios.
Sendo assim, a representacaox feita tentou ser simples e familiar, pois modela circuitos de maneira analoga ao apresentado nas literaturas.

Definir a representação foi o primeiro passo do processo criativo pois ela define a interface do codígo.
A interface definida passou por uma série de iterações até chegar em um resultado que o autor considerou agradável e entendivel.
Como um objetivo é desenvolver uma ferramenta amigavel, primeiramente será demonstrado snippets de código do modelo implementado.

O codígo abaixo criou uma porta do tipo AND e alterou os sinais de entrada dessa porta.
Percebe-se que a porta foi criada usando a notação familiar de construcaox de objetos em linguagens orientada a objetos.
A porta AND possui duas entradas (A e B) e uma saída (Y), e como foi visto anteriormente cada uma dessas conexões é um terminal.
A interação com os terminais é feita a partir do operador ponto (usado para acessar atributos), no codigo acessamos a bus ligada ao terminal 'A' da porta lógica e em seguida modificamos o valor do sinal da bus.
Essa operação foi executada de maneira enxuta e legivel, sem dificuldades para o usuário.
O mesmo procedimento é executado na porta 'B' e finalmente executa-se a função print para verificar o sinal no terminal Y.
Também é possível chamar print na porta como um todo e é impresso todas as informações referentes ao circuito.

\begin{lslisting}
  porta = AND() #cria porta do tipo AND e armezena referencia à variável porta
  porta.a.signal = 1 #modifica o sinal presente na Bus conectada ao terminal A
  porta.b = 1
  print(porta.y) #imprime informacão do terminal Y
  print(porta) #impreme informacao do circuito
\end{lslisting}

A composição de circuitos também é feita a partir de operações nos objetos.
O código abaixo cria duas portas AND, p1 e p2, e conecta a saída de p1 na entrada de p2.
A conexão dos circuitos é feita a partir do método "connect".
Esse método faz uso de argumentos do tipo chave-valor.
O método recebe um conjunto chave-valor onde a chave é o nome de um terminal do circuito e o valor é uma bus que será ligada ao terminal.
A conexaox entre os dois circuitos foi feita em uma linha de código de maneira clara e simples.

\begin{lslisting}
  p1, p2 = AND(), AND()
  p2.connect(a=p1.y) #Liga saída de p1 na entrada 'a' de p2
\end{lslisting}

O snippet final utiliza os conceitos apresentados até agora e aplica modularidade ao processo.
O código a seguir define um novo circuito, ou seja uma classe, e a ele damos o nome "NovoCircuito".
NovoCircuito herda de uma classe pai disponibilizada pela ferramenta e o circuito implementado é o mesmo circuito descrto acima (duas portas AND conectadas).
A vantagem de criar uma classe para esse circuito é que ele fica reutilizavel, caso precisamos dele novamente basta instancialo novamente; outra vantagem é que aplicamos o conceito de hierarquia, ou seja, construimos um circuito mais complexo a partir de circuitos simples.
A nova classe deve definir o nome dos terminais de entrada e saida e o método "make", esse processo é feito sempre que construimos uma nova classe.
Os atributos 'input_labels' e 'output_labels' esperam uma lista de strings que definem os nomes dos terminais de entrada e saída, respectivamente.
O metodo make é aonde o circuito as conexões entre sub circuitos são definidas.
Algo de grande importante no método make é que o usuário deve chamar o método self.get_inputs().
Esse método retorna uma estrutura similar a um struct com as buses que pertencem ao circuito sendo construído.
Esse passo é essencial, pois é a partir dessas buses que é feita a conexão do NovoCircuito com os subcircuitos presentes nele.
Sem os objetos retornados pelo get_inputs, NovoCircuito seria uma caixa preta com terminais porém esses terminais não estariam ligados a nada.

\begin{lslisting}
class NovoCircuito(BaseCircuit):
    input_labels = ['a', 'b', 'c'] #lista de nomes dos terminais de entrada
    output_labels = ['y'] #lista de nomes dos terminais de saida

    def make(self):
        i = self.get_inputs() #objeto que contem as buses internas ao circuito NovoCircuito.
        and_1 = AND()
        and_1.connect(a=i.a, b=i.b) #Conecta as buses de entrada a e b ao circuito and_1
        and_2 = AND(a=and_1.y)
        self.set_outputs(y=and_2.y) #Conecta a saida do circuito and_2 a saida 'Y' do NovoCircuito
\end{lslisting}

Os três snippets acima são curtos porém eles, de certa forma, são tudo o que é preciso entender sobre a ferramenta.
Eles introduzem a "linguagem" da ferramenta, com essa linguagem o usuário pode modelar qualquer circuito que ele queira.
A simples representação escolhida é o diferencial da ferramenta, a partir dela pode-se criar circuitos de complexidade incremental usando modularidade e hierarquia, e tudo isso com uma interface de código consistente.