# Ejercicio 3: FNDP y FNCP

## Integrantes:
#### Maria Daniela Martinez Oliveros, 1126827322 
#### Daniel Loaiza Noreña, 1214747273 
#### Tatiana Herrera Restrepo ,1017270764
#### Alejandro Mesa Gómez , 1017228006 

A partir de las proposiciones dadas en el Ejercicio 1, encontrar la FNDP y
FNCP usando Wolfram Mathematica o Wolfram Alpha. A partir del resultado
encontrado, demostrar teóricamente la FNDP y FNCP, indicando que ley o
regla de inferencia se utilizó en cada paso de la demostración.

### lenguaje y versión: python 2.7, IDE: Jupyter

# Librerías a usar


```python
from sympy import *
from sympy.abc import P,Q,R,S,T
from sympy.logic.boolalg import Not, And, Or
from sympy.logic.boolalg import to_cnf, to_dnf
from truths import Truths

init_printing()
```

en este programa se usará la librería sympy, la cual permite realizar matemáticas simbólicas en python

# primera proposición: 



```python
(And(Equivalent(P,Q),Equivalent(R,P)))>>(Equivalent(And(P,R),And(Q,S)))
```

las formas normales conjuntivas para esta proposición son:



```python
to_cnf((And(Equivalent(P,Q),Equivalent(R,P)))>>(Equivalent(And(P,R),And(Q,S))),false)
```

La cantidad de formas normales que crea el sistema no es muy clara ya que en algunas repite proposiciónes, por este motivo se le solicita que simplifíque el resultado


```python
to_cnf((And(Equivalent(P,Q),Equivalent(R,P)))>>(Equivalent(And(P,R),And(Q,S))),true)
```

Aquí se observa que sólo se obtiene una Forma Normal Conjuntiva Principal.

Ahora se obtendrán las formas normales disyuntivas:


```python
to_dnf((And(Equivalent(P,Q),Equivalent(R,P)))>>(Equivalent(And(P,R),And(Q,S))),false)
```

Nuevamente el resultado no es claro, por lo cual es necesario simplificar nuevamente 


```python
to_dnf((And(Equivalent(P,Q),Equivalent(R,P)))>>(Equivalent(And(P,R),And(Q,S))),true)
```

En este caso la solución es exactamente la misma que en la FNCP, con la salvedad de que en este caso la proposición sería una FND no principal, por lo tanto se decide tomarla como una FNCP, por lo cual para saber el valor de verdad de la forma normal, se usará una tabla de verdad:


```python
print Truths(['P','Q','R','S'],['S or not P or not Q or not R'])
```

    +---+---+---+---+------------------------------+
    | P | Q | R | S | S or not P or not Q or not R |
    +---+---+---+---+------------------------------+
    | 0 | 0 | 0 | 0 |              1               |
    | 0 | 0 | 0 | 1 |              1               |
    | 0 | 0 | 1 | 0 |              1               |
    | 0 | 0 | 1 | 1 |              1               |
    | 0 | 1 | 0 | 0 |              1               |
    | 0 | 1 | 0 | 1 |              1               |
    | 0 | 1 | 1 | 0 |              1               |
    | 0 | 1 | 1 | 1 |              1               |
    | 1 | 0 | 0 | 0 |              1               |
    | 1 | 0 | 0 | 1 |              1               |
    | 1 | 0 | 1 | 0 |              1               |
    | 1 | 0 | 1 | 1 |              1               |
    | 1 | 1 | 0 | 0 |              1               |
    | 1 | 1 | 0 | 1 |              1               |
    | 1 | 1 | 1 | 0 |              0               |
    | 1 | 1 | 1 | 1 |              1               |
    +---+---+---+---+------------------------------+


#### en este caso se ha obtenido una contingencia, lo cual es concordante con el desarrollo de los dos puntos anteriores

# Segunda proposición: 


la segunda proposición es:


```python
Equivalent((Implies(P,Equivalent(Q,R))),(Equivalent((P&Q),(P&R))))
```

para este ejercicio las FNC son:


```python
to_cnf(Equivalent((Implies(P,Equivalent(Q,R))),(Equivalent((P&Q),(P&R)))),false)
```

por la misma razón del punto anterior, se simplifica el resultado


```python
to_cnf(Equivalent((Implies(P,Equivalent(Q,R))),(Equivalent((P&Q),(P&R)))),true)
```

#### Ya que el resultado es "True" se puede concluir directamente que la proposición es una tautología y no es necesario buscar sus FNDP, ya que $FNCP \Leftrightarrow FNDP \Leftrightarrow 1$

# Tercera proposición:

la segunda proposición es:


```python
Implies((Q>>R),((Implies(~Q,~P))>>(Implies(P,R))))
```

Sus Formas Normales Conjuntivas son:


```python
to_cnf(Implies((Q>>R),((Implies(~Q,~P))>>(Implies(P,R)))),false)
```

nuevamente, se simplifica:


```python
to_cnf(Implies((Q>>R),((Implies(~Q,~P))>>(Implies(P,R)))),true)
```

#### Al igual que en la segunda proposición, el resultado es "True" por lo cual (nuevamente) se puede concluir directamente que la proposición es una tautología y no es necesario buscar sus FNDP, ya que $FNCP \Leftrightarrow FNDP \Leftrightarrow 1$

744e5bcfa0421593bdd7217220a45f6b229a9f34
ipynb
Jupyter Notebook
Formas_Normales_Principales.ipynb
cosmolejo/Discretas
23ff8d2e8c1741080c623581528ccb69e12bff7f
Apache-2.0
Formas_Normales_Principales.ipynb
cosmolejo/Discretas
23ff8d2e8c1741080c623581528ccb69e12bff7f
Apache-2.0
Formas_Normales_Principales.ipynb
cosmolejo/Discretas
23ff8d2e8c1741080c623581528ccb69e12bff7f
Apache-2.0
Qwen/Qwen-72B
1. YES
2. YES