Statistical test

The homework is now testing my random key that I created the last week.

I have selected some random testing that I have used in this post.

First I generated 10 keys and created a file with all the keys, this file will be the input for the tests. This capture don't show all the file because this is very long.

I apply the monobit test and my 4 files passed, and this means that the secuency in that the 0 and 1 repeat are not predictable:

	#!/usr/bin/python
	import sys, random, math
	import time
	from scipy import stats
	def monobit(lista):
	sn = 0
	for i in range(len(lista)):
	if int(lista[i]) == 1:
	sn = sn + 1
	else:
	sn = sn - 1
	sobs = math.fabs(sn)/math.sqrt(len(lista))
	p_value = math.erfc(sobs/math.sqrt(2))
	if(p_value > 0.01):
	print 'Teste de frecuencia Monobit pasado ' + str(p_value)
	else:
	print 'Test de frecuencia Monobit no pasado ' + str(p_value)
	def main():
	f = open("Aqui_no_hay_claves", "r")
	texto = f.read()
	monobit(texto)
	main()

view raw gistfile1.py hosted with ❤ by GitHub

And then I applied the run test but, this didn't pass the test:

	def rachas(lista):
	total_pi = 0
	for i in range(len(lista)):
	total_pi = (int(lista[i]) + total_pi)/float(len(lista))
	if abs(total_pi - .5) <= (2/math.sqrt(len(lista))):
	print "no necesitamos correr el test"
	else:
	r = 0
	v = 0
	for i in range(len(lista) - 1):
	if int(lista[i]) == int(lista[i + 1]):
	r = 0
	else:
	r = 1
	v = v +r
	l = len(lista)
	pValue1 = abs(v - (2.0*l*total_pi*(1-total_pi)))
	pValue2 = 2*sqrt(2*l)*total_pi*(1-total_pi)
	pValue = erfc(pValue1 / pValue2)
	if pValue >= 0.01:
	print "Si son randoms"
	else:
	print "No son randoms"
	return
	def main():
	f = open("Aqui_no_hay_claves", "r")
	texto = f.read()
	rachas(texto)
	main()

view raw gistfile1.py hosted with ❤ by GitHub

The next test is I made a compress my file, and this is the result:

So, we don't have security keys, because the file is compressed 16%.


In conclusion we can say that my keys are not secure because only passed 1 test of 3.

Mapa de Karnaugh

Mapa de Karnaugh es un procedimiento directo para optimizar funciones booleanas con un máximo de 4 variables. Se pueden también hacer mapas con 5 o 6 variables pero estas son muy incómodas de usar.

El mapa es un diagrama que esta hecho con cuadros, cada cuadrado representa un mini-termino de la función.

Reconociendo diferentes patrones podemos derivar expresiones algebraicas alternativas para la misma función, de las cuales se puede seleccionar la más sencilla.

Las expresiones optimizadas que el mapa produce siempre se expresan en forma de suma de productos o producto de sumas.

Ahora si vamos a lo bueno, resolvamos algunos ejemplos que inventé con diferente número de variables:

Mapa de dos variables

F = ¬XY + ¬Y¬X + XY 

Lo primero que hay que hacer es construir la tabla de verdad:

Entonces hay que empezar a crear el Mapa-K, para esto creamos un 4 cuadros ya que teniendo dos variables son 4 las combinaciones posibles 2^2 = 4, los renglones representaran la X y las columnas la Y. De la siguiente manera:

Llenamos los cuadrantes de adentro con la respuesta correspondiente que obtuvimos en la tabla de verdad para la combinación indicada.

Tenemos que armar grupos de 1, solo podemos unir de manera vertical y horizontal, no en diagonal, y también nuestros grupos deben del tamaño correspondiente a una potencia de 2 (2, 4, 8, 16).

Entonces nos queda de la siguiente manera:

Lo siguiente es ahora si formar nuestra nueva expresión booleana:

Se hace así:

Tomamos la que esta encerrada en rojo, y queda solamente la X ya que la Y cambia de valores de 0 a 1, y como la X se mantiene constante solo tendremos X, pero como la X esta en 0 tenemos que ponerla negativa para que sea 1 entonces ya tenemos la ¬X.

Ahora de la que esta encerrada en azul vemos que la X cambia de valores entonces se queda la Y sola positiva.

La expresión final es: ¬X + Y. 

De tener al principio F = ¬XY + ¬Y¬X + XY ahora tenemos algo más pequeño F = ¬X + Y

Mapa de tres variables

Aquí tenemos que utilizar 3 variables por lo tanto este problema será un poquito más largo, he creado la siguiente función para mostrar el método:

F = ABC + A¬BC + AB¬C + ¬A¬B¬C + ¬A¬BC

Aquí esta la tabla de verdad:

a:
F = AB + CD

Ahora formamos el mapa-K, en este ejemplo de 3 variables tendremos 8 cuadrantes ya que hay 8 combinaciones posibles 2^3 = 8. La manera de distribuir las combinaciones es teniendo la A en los renglones y la B y C en las columnas, mostrando ahi todas las combinaciones posibles entre estas dos variables, el primer valor que aparece en el renglón como encabezado del mismo es el valor de la B, el segundo es el de la C.

A continuación empezamos a encerrar los grupos que más nos convengan, podemos ver que encerraremos en el primer renglón el grupo de unos, y en el segundo renglón tenemos un grupo de unos de 3 unos, lo que no es posible debido a que 3 no es potencia de dos por lo que tendremos que repetir algún termino que ya este en grupo lo cual es totalmente válido y nos quedara de la siguiente manera:

Entonces podemos ver del grupo rojo la expresión queda ¬A¬B (la C no debido a que cambia de 0 a 1), del grupo azul queda ¬BC (la A no porque cambia de 0 a 1) y del grupo azul vemos AB (la C no porque cambia). 

Y el resultado es de tener la expresión así: F = ABC + A¬BC + AB¬C + ¬A¬B¬C + ¬A¬BC

la hemos minimizado a: F = ¬A¬B + ¬BC + AB.

Mapa de cuatro variables

Ahora una función con 4 variables, usaremos esta expresión que se me ocurrió para mostrar el ejemplo:

F = ABCD + ¬ABCD + A¬BCD + AB¬CD + ABC¬D + ¬A¬BCD + AB¬C¬D

Tabla de verdad:

Lo que sigue es formar el mapa de 4x4 osea 16 cuadrantes que se forman de las combinaciones 2^4 = 16, ahora los renglones los forman A y B con todas sus combinaciones posibles, y las columnas C y D también con todas las combinaciones:

Ahora formamos los grupos de unos, recordemos que tienen que ser potencias de 2, nos quedó bastante cómodo el ejemplo, en la siguiente imagen les muestro como es que podemos resolver nuestro mapa:

Podemos empezar a formar la expresión simplificada tomando el circulo que queramos, yo elegí el rojo, entonces nos queda AB (C y D no porque cambian de valores) y del circulo azul nos queda CD (A y B no porque cambian de valores).
Nuestra expresión paso de ser así:
F = ABCD + ¬ABCD + A¬BCD + AB¬CD + ABC¬D + ¬A¬BCD + AB¬C¬D
a:
F = AB + CD

Y finalmente les muestro como es que compruebo las expresiones, no crean que lo hago manualmente, uso un programita muy sencillo de python, y es así como me puedo dar cuenta que lo optimicé correctamente.

	#!/usr/bin/python
	lista = [[1,1,1,1], [1,1,1,0], [1,1,0,1],
	[1,1,0,0], [1,0,1,1], [1,0,1,0],
	[1,0,0,1], [1,0,0,0], [0,1,1,1],
	[0,1,1,0], [0,1,0,1], [0,1,0,0],
	[0,0,1,1], [0,0,1,0], [0,0,0,1],
	[0,0,0,0]]
	for i in range(16):
	A = lista[i][0]
	B = lista[i][1]
	C = lista[i][2]
	D = lista[i][3]
	expresion = (A and B and C and D) or (not(A) and B and C and D) or \
	(A and not(B) and C and D) or\
	(A and B and not(C) and D) or\
	(A and B and C and not(D)) or\
	(not(A) and not(B) and C and D) or\
	(A and B and not(C) and not(D))
	funcion = (A and B) or (C and D)
	original = " original"
	optimizada = "optimizada"
	print original, A, B, C, D, bool(funcion)
	print optimizada, A, B, C, D, bool(expresion)

view raw gistfile1.py hosted with ❤ by GitHub

La ejecución:

Referencias

Ejemplo sencillo mapa-karnaugh

Aplicación de la lógica proposicional

Lógica proposicional

Es una parte de la lógica que se encarga de estudiar la formación de proposiciones complejas partiendo de proposiciones simples.
Es un sistema formal en donde los elementos más simples representan proposiciones, y los conectivos representan operaciones entre las proposiciones, y asi se forman proposiciones de mayor complejidad.

La tarea asignada para esta semana es la siguiente:
"Investiguen aplicaciones de la lógica proposicional y documenten uno en su tercera tarea."

Yo elegí documentar la aplicación de la lógica proposicional en el diseño de los circuitos digitales.

[1]

Puertas lógicas

Podemos pensar en un circuito digital como una caja negra, en donde podemos crear relaciones entre las entradas y la salida.

La operación del circuito la podemos especificar al construir una tabla de entradas y salidas, en donde mostremos todos los posibles valores de entrada y de salida.

Para describir como operan los circuitos digitales es necesario introducir nociones matemáticas que especifica la operación de cada puerta y que es usado para diseñar y analizar circuitos.

Para representar una oración de lógica proposicional como circuito digital usamos las compuertas lógicas.
Las puertas lógicas son circuitos electrónicos que toman una o más señales de entrada para producir una señal de salida. Las señales eléctricas como voltaje o corriente existen en los sistemas digitales. Los circuitos que usan los voltajes tienen dos rangos separados de voltajes que representan valores binarios igual a 1 lógico o 0 lógico.
Como podemos ver que es posible representar estos valores con una tabla de verdad, es correcto decir entonces que los circuitos digitales los podemos representar con lógica proposicional.

[2]

Las compuertas lógicas aceptan señales entre 0 y 1 osea dentro del rango permitido y responden a los terminales de salida con señales binarias también. Las regiones entre 0 y 1 o 1 y 0 se llaman regiones de transito y este cambio se le llama transición.

Los simbolos usados para representar los tipos de compuertas los muestro a continuación:

[3]

Las puertas son circuitos electrónicos que producen como salida 0 o 1 de acuerdo a la tabla de verdad y los valores de entrada.

[4]

Actualmente TODOS los circuitos lógicos utilizados en los diseños electrónicos se pueden construir a partir de componentes electrónicos encapsulados en un chip, muchas veces se agrupan las compuertas en  uno solo, aunque posiblemente aun podamos encontrar solo la función lógica que necesitamos en un chip. Los elementos básicos de los circuitos digitales son las compuertas lógicas.

Les dejo un ejemplo de un circuito digital que inventé F = (¬X^Y) | (X^Z) utiliza compuertas lógicas, realizado con el Software Qucs:

Tabla de entrada/salida:

Refrencias

[1], [4] Puertas Lógicas
[2] AND, OR, NOT
[3] Símbolos puertas lógicas
Lógica proposicional, Elisa Schaeffer

Convolución

Convolución es el operador matemático que convierte dos funciones f y g en una tercera función que representa la magnitud en la que se superponen f y una versión trasladada e invertida de g.

Es decir convolución nos da la magnitud del recorrido que hace una funcion f desplazandose en otra funcion g.

Exactamente como la siguiente imagen:

Se representa f(t)*g(t) y la definimos como la integral del producto de ambas funciones después de desplazar alguna de ellas una distancia n.



Una vez entendida esta definición ahora si estoy lista para comenzar a hacer un ejemplo, que yo misma inventé.
Necesitamos recordar una fórmula básica de integración:

Para escribir las ecuaciones utilicé la herramienta en línea de LATEX.

Así comenzamos definiendo f(t) y g(t):


Ahora sustituimos:



Ahora elevamos al cuadrado y multiplicamos :



Separamos para integrar:



Y ahora saco las constantes:



Integramos:



Y el resultado:



Entonces la convolución es la magnitud de el recorrido que hace una función cuando se desplaza sobre la otra, para tener una idea más clara les dejo dos gráficas de las funciones:

La función f(t) = t

La función f(t) = t ** 2

Les dejo un vídeo que me ayudo a entender la definición de la convolución:




Uso de la convolución

• En estadística, como un promedio móvil ponderado.
• En teoría de la probabilidad, la distribución de probabilidad de la suma de variables aleatorias independientes, es la convolución de sus distribuciones de probabilidad.
• Muchas manchas se describen con convoluciones, en óptica.
• En acústica, un eco es la convolución del sonido original con una función que represente los objetos variados que lo reflejan.

Tipos de convolución

Convolución discreta

Se trata de hacer un procesamiento digital de señal, ya que no tiene mucho sentido hablar de convoluciones aplicando estrictamente la definición ya que solo contamos con valores en instantes discretos de tiempo. Entonces es necesario, la aproximación numérica.

En convolución discreta usamos la siguiente fórmula:

Hay en numpy una función que nos permite obtener la convolución discreta, numpy.convolve(a, v, mode='full'), en donde "a" y "v" son listas que contienen los valores de "y", es decir en vez de tener dos funciones tenemos dos arreglos con los puntos en y. Y nos regresa el arreglo con la convolución discreta de las dos secuencias que pusimos de entradas.

Aquí dos pequeños ejemplos:

Gráfica de la primer lista de los argmentos:

Gráfica de la segunda lista:

Referencias:

Convolución

Numpy

One-time pad

For this hw I have created a program that first reads a message from a file called "Message" then convert it to numbers, and then to binary.
Then I create a random key with the length of the binary string (that is saved in a file), and I apply XOR.
The result is encrypted message, now I created decrypt functions, and you can read the original message.
The code is all commented to understand him better.
I leave screenshot of several runs to see how it changes the encrypted message can fit the key.

Code:

	#!/usr/bin/python
	import random
	import sys
	import os
	def desencriptar(encriptado):
	"""desencriptar, toma el mensaje encriptado
	y lee la clave del archivo correspondiente
	"""
	f = open('Aqui_no_hay_claves', "r")
	print "**Desencriptando ..."
	print "**Abro el archivo para leer la clave"
	k = f.read() #leo el archivo con la clave
	ant = "" #me sirve para ir agregando a la cadena
	for i in range(len(encriptado)): #con este for puedo obtener la frase
	a = int(encriptado[i]) #original aunque aun en binario
	b = int(k[i])
	c = bool(a) != bool(b)
	c = int(c)
	c = ant + str(c)
	ant = c
	original = ant
	iteraciones = len(original)/7 #con esto divido entre 7 la cadena
	lista = [] #de caracteres para poder obtener el numero
	cont = 0 #entero correspondiente al binario
	separados = []
	numeros = []
	texto = ''
	for i in range(iteraciones): #aqui obtengo el caracter que
	m = original[cont:cont + 7] #corresponde al numero entero
	cont = cont + 7
	separados.append(m)
	numeros.append(int(m, 2))
	texto = texto + chr(numeros[i])
	texto = texto.replace('zzz', ' ')
	print "**Este es el texto cifrado"
	print texto
	print "**Ahora elimino la clave para que nadie mas pueda leer mi mensaje"
	os.remove('Aqui_no_hay_claves')#paranoicamente elimino la clave
	return texto #regreso el texto original desencriptado
	def convertir_binario(texto):
	"""esta funcion recibe una cadena de texto
	y la convierte a binario
	"""
	ant = ''
	for i in texto:
	numero = ord(i)
	binario = bin(numero)
	binario = str(binario)
	binario = binario.split('b')
	binario = binario[1]
	binario = ant + binario
	ant = binario
	binario = ant
	return binario
	def leer_archivo(archivo):
	"""esta funcion se encarga de leer el
	archivo que contiene el mensaje
	"""
	f = open(archivo, "r")
	texto = f.read()
	original = texto
	texto = texto.replace(' ', 'zzz')
	return texto, original
	def escribir_archivo(k):
	"""escribir en un archivo
	"""
	f = open('Aqui_no_hay_claves', 'w')
	f.write(k)
	def clave(tamano):
	"""esta funcion se encarga de crear una clave
	unica para el mensaje
	"""
	clave = ''
	for i in range(tamano):
	clave = str(random.randint(0, 1)) + clave
	return clave
	def encriptar(binario, k, tamano):
	"""toma como entrada la cadena binaria, la clave
	y el tamano para aplicar un xor logico y retornar
	el mensaje cifrado
	"""
	ant = ''
	for i in range(tamano):
	a = int(binario[i])
	b = int(k[i])
	c = bool(a) != bool(b)
	c = int(c)
	c = ant + str(c)
	ant = c
	cifrado = ant
	return cifrado
	def main():
	archivo_entrada = "mensaje"
	texto, original = leer_archivo(archivo_entrada)
	binario = convertir_binario(texto)
	tamano = len(binario)
	k = clave(tamano)
	print "El mensaje original es:"
	print original
	print "\n"
	escribir_archivo(k)
	mensaje_encri = encriptar(binario, k, tamano)
	print "Mi mensaje encriptado"
	print mensaje_encri
	print "\n"
	desencriptar(mensaje_encri)
	main()

view raw gistfile1.py hosted with ❤ by GitHub

Results:

	El mensaje original es:
	Hola esta es la primer tarea de la materia de criptografia one time pad consiste en crear alguna clave para un texto aleatoriamente y guardarlo en archivos el mensaje original y la clave una vez que fue descifrado puede generar una nueva clave y eliminarla cuando ya fue descifrado
	Mi mensaje encriptado
	11110010011111010001001001110011000011010011010011100101011011101001101011100001001110110111011000000010110110111101111001001001010011110111110000010100010010110001111101111011101011011111001000110000110110011000111100111111101101101001100101101110010010100010001000001001011110110110011010101011011010101101111100100001011000000110000111001111101000111100111110101001010111000101011101101001111101000001110101000001000101110101110001010001100110111000111011010101010011110101110110101100000001001111101000001110000001100001100110000000011011011100010001110000001100011001001111011110011011001011111100011111100010100000111010110000110000000001011011110011110001110001010111100101110110100111100111010000111100001101111100010111001001001010110100110010001100100000110101010000101010000100101111001001010000011000110110010110101011100011100100100110100111101111000101011101101011000100101100000010101001001010010010011010100001110010101011111110001010111101001000111010011101011000100010111010111111000101111100011000001011010110000000001110001000100001000100010100010111001000011100111001111011101100011100011010000100011010000000100000000110111000001100110110101010010000001000110101001001101000000100001001100010111010101101001000110101110101100100011101100101011110000110101010010010101101110100011111010000110000110111110111100110101010101100101011110000111001011110011100110011100111110110001110100011011110101101101010111110010100000111110110000011101001011011000011100111001001010100011011010111001111010000110110000001000010101000001110001000011001101011101111011000000000101101100010101010100100011010101110010000010111110101001100101011000110010010000111000011001001100110100111001000000110101000111111001011001001000011001101101010110000011001100110101000100111010010011111010111000000110000100000000000010010000110111110011100010100100100101110101110101001010100011101011111001010010111110110100010011100110101100001001101100110001111101111111111010010110111111101000000011011111001010101000100000011111011110000100011010111100001001011000100110110111000110111011010111111010000011001100010011010010110100001010000001110001011110101101100101000100001010101000111010100001001100011010011010000000001000100101111011000000001001110000110100000110100001110101011010111010010000011001000010000110101011110100101111100101000000000000111001111011011011101111111110001101110101000000111100000100111011111110011000001101111111110111000111100000011000110010010010111101011010110010100010010000101001011011111101101001110011110001110100011100011010100000101110100001000110000110011011101100100110111101001100001110110100100100001101000001100000110011010011001
	**Desencriptando ...
	**Abro el archivo para leer la clave
	**Este es el texto cifrado
	Hola esta es la primer tarea de la materia de criptografia one time pad consiste en crear alguna clave para un texto aleatoriamente y guardarlo en archivos el mensaje original y la clave una ve zque fue descifrado puede generar una nueva clave y eliminarla cuando ya fue descifrado
	**Ahora elimino la clave para que nadie mas pueda leer mi mensaje

view raw gistfile1.sh hosted with ❤ by GitHub

	El mensaje original es:
	Hola esta es la primer tarea de la materia de criptografia one time pad consiste en crear alguna clave para un texto aleatoriamente y guardarlo en archivos el mensaje original y la clave una vez que fue descifrado puede generar una nueva clave y eliminarla cuando ya fue descifrado
	Mi mensaje encriptado
	11001001110110100000110111101110110001101100010010000101100110111101100000111010100001111101010100111001111010100001000001001100010010100010110000100100111010111000011011101111110100110000000101111111100000110001000101011101000000110001001010110101000011111010000111001011001101100001010100010100001011110100001110100110110001101110101000010111101010100000001001111011001110011111110001110100101101001111010101000010110010000110101111001011100101100000000010100010010111101011111010001111000001110111011010010000010010011011010100110100000110010010110011000100100111100010110110111111100011110010011110110110100010001111100011001011001011111001101110010000000111101011011111111001011010010010011001111010011000110101100010011111011001000000101010000011111100100001011001111001010110001000000011100111010001001111101011011001000000100011111111000100101010111100110111010101001110111011001110011011011011110100010000011010010100000011110000110101110100001000100001011000100101011000101000111111000010000000111110101001111111011101000111111001111010101000101101101000001001001011100001000011111010001001110000110001101100100110100111001110110100111111110010111000101011100010101011101010001011001000000110010010110000101100000101101011011100101010001000011101000000101101110010101100100000001110010110011011100000011011001001000010101101001000010010000000101011010100101010011101011000011010110011101000011010111101111010011010011011100000111000100111100111000100011110010100111011001010111011111001011110111111111100100101001110101100011000001011000000001010010001000111000000010111011101010111001111111110001110101000110001110100101000000010111110010001100000000001111010110010110011001110111000000111011000001111001101100010111010010010011100010111111111111111100100011011011100101111011100011011000010011001010110001000101010101001011010001110100011101011011010010100100111010010101001110101010100111110101110000111110001100011001000101110001100011001001011011000110000001010111100110011111010111110000010101110111111000101111011100000101110010100010011100001001000110101011110011010011110000101001111110011100001000010010011011011101000110100111100010000101110001101111000101001010000110111100111110011100111111100010100000111100111000000110101011111100001111101101110110100101110111100110110000100010110101000100110000001000001000110100001000000001010011100010110111100111110000000011111100001101110101001101100001010010110101111111111111111100000111010000100111001101001000011000000010110010010101011000011110011110011101110001011010000010010010101100000111001000111111110010110011101111000011000000000000011100110101010000110010101110001101111101001010001
	**Desencriptando ...
	**Abro el archivo para leer la clave
	**Este es el texto cifrado
	Hola esta es la primer tarea de la materia de criptografia one time pad consiste en crear alguna clave para un texto aleatoriamente y guardarlo en archivos el mensaje original y la clave una ve zque fue descifrado puede generar una nueva clave y eliminarla cuando ya fue descifrado
	**Ahora elimino la clave para que nadie mas pueda leer mi mensaje

view raw gistfile1.txt hosted with ❤ by GitHub

Función sigmoidal

Para no olvidar, aquí dejo una entrada con una gráfica sigmoidal en GNUPLOT.
En gnuplot:

 La gráfica

Tautología

Tautología

La palabra tautología quiere decir “decir lo mismo”, es una fórmula de un sistema de lógica proposicional que resulta ser verdadero para cualquier combinación.

El siguiente ejercicio consiste en hacer una tautología con las siguientes características:

• 3 variables
• Por lo menos cuatro ocurrencias de conectivos
• Por lo menos usar una vez or, and y negación.

Para comenzar hice la tabla con los posibles valores de mis tres variables, y comencé por usar cualquier conector decidí “or” a las letras A y C.

A	B	C	A or C
1	1	1	1
1	1	0	1
1	0	1	1
1	0	0	1
0	1	1	1
0	1	0	0
0	0	1	1
0	0	0	0

Después tomé otras dos letras “B” y “C” con el conector “and”

A	B	C	A or C	B and C
1	1	1	1	1
1	1	0	1	0
1	0	1	1	0
1	0	0	1	0
0	1	1	1	1
0	1	0	0	0
0	0	1	1	0
0	0	0	0	0

Y cree otra combinación ahora con el conector “->” y las letras B y A

A	B	C	A or C	B and C	B -> A
1	1	1	1	1	1
1	1	0	1	0	1
1	0	1	1	0	1
1	0	0	1	0	1
0	1	1	1	1	0
0	1	0	0	0	0
0	0	1	1	0	1
0	0	0	0	0	1

Y ahora sí llegó el momento de pensar un poquito para poder hacer que todas las combinaciones nos den como resultado puros valores positivos, pero hay otra cosa que considerar aún no he usado la negación “¬” , he decidido usarla en alguna combinación de las que ya hice que me dio menos valores positivos (B and C)

A	B	C	A or C	B and C	B -> A	not (B and C )
1	1	1	1	1	1	0
1	1	0	1	0	1	1
1	0	1	1	0	1	1
1	0	0	1	0	1	1
0	1	1	1	1	0	0
0	1	0	0	0	0	1
0	0	1	1	0	1	1
0	0	0	0	0	1	1

Después utilicé un and para conectar (A or C) and ¬(B and C), porque ya noté que si utilizo el conector de “implicación” con (B -> A) podré obtener valores positivos.

A	B	C	A or C	B and C	B -> A	not (B and C )	(A orC) and ¬(B and C)
1	1	1	1	1	1	0	0
1	1	0	1	0	1	1	1
1	0	1	1	0	1	1	1
1	0	0	1	0	1	1	1
0	1	1	1	1	0	0	0
0	1	0	0	0	0	1	0
0	0	1	1	0	1	1	1
0	0	0	0	0	1	1	0

Y ahora si puedo conectar la combinación que aun no relaciono (B -> A) con mi última combinación.

A	B	C	A or C	B and C	B -> A	not (B and C )	(A orC) and ¬(B and C)	((A orC) and ¬(B and C)) -> (B->A)
1	1	1	1	1	1	0	0	1
1	1	0	1	0	1	1	1	1
1	0	1	1	0	1	1	1	1
1	0	0	1	0	1	1	1	1
0	1	1	1	1	0	0	0	1
0	1	0	0	0	0	1	0	1
0	0	1	1	0	1	1	1	1
0	0	0	0	0	1	1	0	1

Y he logrado hacer una tautología, es fácil hacerla si nos vamos paso por paso con la tabla de verdad.

Y por último les muestro el árbol de mi tautología: