Information to logical expression

Research
1

This is a try to convert information to input output circuit expression

import sympy as sp
import sys

def texto_a_binario(texto):
    # Codificar el texto en bytes
    bytes_texto = texto.encode()

    # Convertir cada byte a binario y almacenarlo en una lista
    binario_lista = [bin(byte)[2:].zfill(64) for byte in bytes_texto]

    return binario_lista

# Definir símbolos para las entradas y salidas
input_symbols = sp.symbols(' '.join([f'x{i}' for i in range(64)]))  # Entradas
output_symbols = sp.symbols(' '.join([f'y{i}' for i in range(64)]))  # Salidas

# Ejemplo de texto
texto=sys.argv[1]
print("Data Binary Graph")
print(texto)
binario_lista = texto_a_binario(texto)


# Generar tabla de verdad basada en el texto
truth_table = []
for i in range(len(binario_lista) - 1):
    input_bits = [int(bit) for bit in binario_lista[i]]
    output_bits = [int(bit) for bit in binario_lista[i + 1]]
    truth_table.append((input_bits, output_bits))
#print(truth_table)
# Convertir la tabla de verdad en una expresión lógica
expr_list = []
for input_bits, output_bits in truth_table:
    input_exprs = [input_symbols[i] if bit == 1 else ~input_symbols[i] for i, bit in enumerate(input_bits)]
    output_exprs = [output_symbols[i] if bit == 1 else ~output_symbols[i] for i, bit in enumerate(output_bits)]
    expr_list.append(sp.And(*input_exprs, *output_exprs))



# Combinar todas las expresiones en una sola expresión lógica
circuit_expr = sp.Or(*expr_list)
#print(circuit_expr)
# Simplificar el circuito lógico
simplified_circuit_expr = sp.simplify_logic(circuit_expr)
print(simplified_circuit_expr)
# Convertir la expresión lógica simplificada en CNF
#cnf_expr = sp.to_cnf(circuit_expr)

# Imprimir la expresión CNF simplificada
#print("Expresión CNF simplificada:")
#print(cnf_expr)

# Imprimir algunos ejemplos de la tabla de verdad

print("\nEjemplos de la tabla de verdad del futuro:")
for i, (inputs, outputs) in enumerate(truth_table):
    print(f"Ejemplo {i+1}: Entrada={inputs}, Salida={outputs}")




# Probar el circuito con el primer ejemplo
input_example = truth_table[0][0]
expected_output = truth_table[0][1]
input_subs = {input_symbols[i]: bit for i, bit in enumerate(input_example)}
satisfying_assignment = sp.satisfiable(simplified_circuit_expr.subs(input_subs))

# Obtener los valores de salida presentes en la asignación
output_values = {output_symbol: satisfying_assignment[output_symbol] for output_symbol in satisfying_assignment.keys() if output_symbol in output_symbols}

print("\nPrueba del circuito con el primer ejemplo:")
print("Entrada:")
print(input_example)
print("Salida esperada:")
print(expected_output)
print("Salida del circuito:")
out=[output_values[output_symbol] for output_symbol in output_symbols]
print(out)

binary_string = ''.join('1' if elem else '0' for elem in out)

# Convertir la cadena binaria en un carácter
result_char = chr(int(binary_string, 2))

print(result_char)

You can pass any information to convert to logical expression for circuits. Just a idea