Propositional Logic Identity - logic

How to show that 𝑝 ↔ π‘ž ≑ 𝑝 ∨ π‘ž β†’ (𝑝 ∧ π‘ž)
So far I've done this...
𝑝 ↔ π‘ž ≑(p β†’ q) ∧(q β†’ p) Law of Algebra
(p β†’ q) ∧ (q β†’ p) ≑(~p V q) ∧ (q β†’ p) Law of Conditional Proposition
(~p V q) ∧ (q β†’ p) ≑(~p V q) ∧ (~q V p) Law of Conditional Proposition


By identity laws:
p ↔ q Given
(p β†’ q) & (q β†’ p) ↔ Elimination
(~p ∨ q) & (~q ∨ p) Material implication
((~p ∨ q) & ~q) ∨ (((~p ∨ q) & p)) Distributive
~p & ~q ∨ q & ~q ∨ ~p & p ∨ q & p Distributive
~p & ~q ∨ F ∨ F ∨ q & p Complement
~p & ~q ∨ q & p Identity
~(p ∨ q) ∨ p & q De Morgan's law
(p ∨ q) β†’ (p & q) Material implication
By natural deduction:
To prove an identity by natural deduction, you have to conduct your proof in both directions. That is, you have to prove both that:
p ↔ q entails (p ∨ q) β†’ (p & q), and
(p ∨ q) β†’ (p & q) entails p ↔ q
{1} 1. p ↔ q Prem.
{1} 2. (p β†’ q) & (q β†’ p) 1 ↔E
{1} 3. p β†’ q 2 &E
{1} 4. q β†’ p 2 &E
{5} 5. p ∨ q Assum.
{6} 6. p Assum. (1st Disj.)
{1,6} 7. q 3,6 MP
{1,6} 8. p & q 6,7 &I (1st Conc.)
{9} 9. q Assum. (2nd Disj.)
{1,9} 10. p 4,9 MP
{1,9} 11. p & q 9,10 &I (2nd Conc.)
{1,5} 12. p & q 5,6,8,9,11 ∨E
{1} 14. (p ∨ q) β†’ (p & q) 5,12 CP
Here's the proof in the opposite direction:
{1} 1. (p ∨ q) β†’ (p & q) Prem.
{2} 2. p Assum.
{2} 3. p ∨ q 2 ∨I
{1,2} 4. p & q 1,3 MP
{1,2} 5. q 4 &E
{1} 6. p β†’ q 2,5 CP
{7} 7. q Assum.
{7} 8. p ∨ q 7 ∨I
{1,7} 9. p & q 1,8 MP
{1,7} 10. p 9 &E
{1} 11. q β†’ p 7,10 CP
{1} 12. (p β†’ q) & (q β†’ p) 6,12 &I
{1} 13. p ↔ q 12 ↔I
Abbreviations:
&I = Conjunction introduction
&E = Conjunction elimination
∨I = Disjunction introduction
∨E = Disjunction elimination
↔I = Double arrow introduction
↔E = Double arrow elimination
MP = Modus ponens
CP = Conditional proof (β†’ introduction)

Related

How to build a proof of correctness in coq for elements_tr

I want to build a proof of correctness for elements_tr...
It is actually related to some sort of reimplementation of BSTs with int keys.
Elements_tr is defined as follows:
Fixpoint elements_aux {V : Type} (t : tree V)
(acc : list (key * V)) : list (key * V) :=
match t with
| E => acc
| T l k v r => elements_aux l ((k, v) :: elements_aux r acc)
end.
Definition elements_tr {V : Type} (t : tree V) : list (key * V) :=
elements_aux t [].
However I am unable to build such proof as I continuously get false = true...
What Am I doing wrong?
Corollary elements_tr_correct :
forall (V : Type) (k : key) (v d : V) (t : tree V),
BST t ->
In (k, v) (elements_tr t) ->
bound k t = true /\ lookup d k t = v.
Proof.
intros.
split.
induction t.
- unfold elements_tr.
unfold elements. simpl.
admit.
- admit.
- admit.
Admitted.
Bellow is the full code to run...
From Coq Require Import String.
From Coq Require Export Arith.
From Coq Require Export Lia.
Notation "a >=? b" := (Nat.leb b a) (at level 70) : nat_scope.
Notation "a >? b" := (Nat.ltb b a) (at level 70) : nat_scope.
From Coq Require Export Lists.List.
Export ListNotations.
Definition key := nat.
Inductive tree (V : Type) : Type :=
| E
| T (l : tree V) (k : key) (v : V) (r : tree V).
Arguments E {V}.
Arguments T {V}.
Definition ex_tree : tree string :=
(T (T E 2 "two" E) 4 "four" (T E 5 "five" E))%string.
Definition empty_tree {V : Type} : tree V := E.
Fixpoint bound {V : Type} (x : key) (t : tree V) :=
match t with
| E => false
| T l y v r => if x <? y then bound x l
else if x >? y then bound x r
else true
end.
Fixpoint lookup {V : Type} (d : V) (x : key) (t : tree V) : V :=
match t with
| E => d
| T l y v r => if x <? y then lookup d x l
else if x >? y then lookup d x r
else v
end.
Fixpoint insert {V : Type} (x : key) (v : V) (t : tree V) : tree V :=
match t with
| E => T E x v E
| T l y v' r => if x <? y then T (insert x v l) y v' r
else if x >? y then T l y v' (insert x v r)
else T l x v r
end.
Fixpoint ForallT {V : Type} (P: key -> V -> Prop) (t: tree V) : Prop :=
match t with
| E => True
| T l k v r => P k v /\ ForallT P l /\ ForallT P r
end.
Inductive BST {V : Type} : tree V -> Prop :=
| BST_E : BST E
| BST_T : forall l x v r,
ForallT (fun y _ => y < x) l ->
ForallT (fun y _ => y > x) r ->
BST l ->
BST r ->
BST (T l x v r).
Hint Constructors BST.
Ltac inv H := inversion H; clear H; subst.
Inductive reflect (P : Prop) : bool -> Set :=
| ReflectT : P -> reflect P true
| ReflectF : ~ P -> reflect P false.
Theorem iff_reflect : forall P b, (P <-> b = true) -> reflect P b.
Proof.
intros P b H. destruct b.
- apply ReflectT. rewrite H. reflexivity.
- apply ReflectF. rewrite H. intros H'. inversion H'.
Qed.
Lemma eqb_reflect : forall x y, reflect (x = y) (x =? y).
Proof.
intros x y. apply iff_reflect. symmetry.
apply Nat.eqb_eq.
Qed.
Lemma ltb_reflect : forall x y, reflect (x < y) (x <? y).
Proof.
intros x y. apply iff_reflect. symmetry.
apply Nat.ltb_lt.
Qed.
Lemma leb_reflect : forall x y, reflect (x <= y) (x <=? y).
Proof.
intros x y. apply iff_reflect. symmetry.
apply Nat.leb_le.
Qed.
Hint Resolve ltb_reflect leb_reflect eqb_reflect : bdestruct.
Ltac bdestruct X :=
let H := fresh in let e := fresh "e" in
evar (e: Prop);
assert (H: reflect e X); subst e;
[eauto with bdestruct
| destruct H as [H|H];
[ | try first [apply not_lt in H | apply not_le in H]]].
Lemma ForallT_insert : forall (V : Type) (P : key -> V -> Prop) (t : tree V),
ForallT P t -> forall (k : key) (v : V),
P k v -> ForallT P (insert k v t).
Proof.
intros V P t.
induction t; intros H k' v' Pkv.
- simpl. auto.
- simpl in *.
destruct H as [H1 [H2 H3]].
bdestruct (k >? k').
+ simpl. repeat split.
* assumption.
* apply (IHt1 H2 k' v' Pkv).
* assumption.
+ bdestruct (k' >? k).
++ simpl. repeat split.
* assumption.
* assumption.
* apply (IHt2 H3 k' v' Pkv).
++ simpl. repeat split.
* assumption.
* assumption.
* assumption.
Qed.
Fixpoint elements {V : Type} (t : tree V) : list (key * V) :=
match t with
| E => []
| T l k v r => elements l ++ [(k, v)] ++ elements r
end.
Fixpoint elements_aux {V : Type} (t : tree V)
(acc : list (key * V)) : list (key * V) :=
match t with
| E => acc
| T l k v r => elements_aux l ((k, v) :: elements_aux r acc)
end.
Definition elements_tr {V : Type} (t : tree V) : list (key * V) :=
elements_aux t [].
Corollary elements_tr_correct :
forall (V : Type) (k : key) (v d : V) (t : tree V),
BST t ->
In (k, v) (elements_tr t) ->
bound k t = true /\ lookup d k t = v.
Proof.
intros.
split.
induction t.
- unfold elements_tr.
unfold elements. simpl.
admit.
- admit.
- admit.
Admitted.

How to define the range function on a relation in Agda (set theory)

I'm trying to find a way to prove a couple of set theory-based problems in Agda, but I'm having a hard time defining the function range.
I took the definition of Subset from Proving decidability of subset in Agda and built on top of it. This is what I got so far:
open import Data.Bool as Bool using (Bool; true; false; T; _∨_; _∧_)
open import Data.Unit using (⊀; tt)
open import Level using (Level; _βŠ”_; 0β„“) renaming (suc to lsuc)
open import Data.Product using (_Γ—_) renaming (_,_ to ⟨_,_⟩)
Subset : βˆ€ {Ξ±} (A : Set Ξ±) -> Set _
Subset A = A β†’ Bool
_∈_ : βˆ€ {Ξ±} {A : Set Ξ±} β†’ A β†’ Subset A β†’ Set
a ∈ p = T (p a)
Relation : βˆ€ {Ξ± Ξ²} (A : Set Ξ±) (B : Set Ξ²) β†’ Set (Ξ± βŠ” Ξ²)
Relation A B = Subset (A Γ— B)
Range : βˆ€ {A B : Set} β†’ Relation A B β†’ Subset B
Range = ?
_βŠ†_ : βˆ€ {A : Set} β†’ Subset A β†’ Subset A β†’ Set
A βŠ† B = βˆ€ x β†’ x ∈ A β†’ x ∈ B
wholeSet : βˆ€ (A : Set) β†’ Subset A
wholeSet _ = Ξ» _ β†’ true
βˆ€subsetβŠ†set : βˆ€ {A : Set} {sub : Subset A} β†’ sub βŠ† wholeSet A
βˆ€subsetβŠ†set = Ξ» _ _ β†’ tt
_∩_ : βˆ€ {A : Set} β†’ Subset A β†’ Subset A β†’ Subset A
A ∩ B = Ξ» x β†’ (A x) ∧ (B x)
βŠ†-range-∩ : βˆ€ {A B : Set}
(F G : Relation A B)
β†’ Range (F ∩ G) βŠ† (Range F ∩ Range G)
βŠ†-range-∩ f g = ?
The problem is that Range takes as an input a function of type A Γ— B β†’ Bool and must return a function B β†’ Bool such that a value B is true iff there exists a value A Γ— B which is true in the initial function. Basically, I would need to iterate through all values of A to know whether B is in the range of the relation. Something impossible to do, isn't it?
There must be surely a better way to implement Range, doesn't it?

Here is the implementation I suggest :
open import Data.Unit
open import Data.Product renaming (_,_ to ⟨_,_⟩)
open import Data.Sum
open import Function
Change the definition of Subset to go to Set instead of Bool. I know this might be controversial, but in my experience this has always been the way to go, and also this is how subsets are implemented in the standard library. (By the way, if you are interested to see the implementation in the standard library, it is in the file Relation/Unary.agda). I also removed the levels of universe since you didn't use them in your later definitions, which led me to clean up the types of the module.
Subset : Set β†’ Set₁
Subset A = A β†’ Set
The definition of membership is changed accordingly.
_∈_ : βˆ€ {A} β†’ A β†’ Subset A β†’ Set
a ∈ P = P a
Relation : βˆ€ A B β†’ Set₁
Relation A B = Subset (A Γ— B)
The range becomes then very natural : b is in the range of R if their exists an a such as R of a and b holds.
Range : βˆ€ {A B} β†’ Relation A B β†’ Subset B
Range R b = βˆƒ (R ∘ ⟨_, b ⟩) -- equivalent to βˆƒ \a β†’ R ⟨ a , b ⟩
_βŠ†_ : βˆ€ {A} β†’ Subset A β†’ Subset A β†’ Set
A βŠ† B = βˆ€ x β†’ x ∈ A β†’ x ∈ B
Not much to say about the wholeset
wholeSet : βˆ€ A β†’ Subset A
wholeSet _ _ = ⊀
βˆ€subsetβŠ†set : βˆ€ {A sub} β†’ sub βŠ† wholeSet A
βˆ€subsetβŠ†set _ _ = tt
_∩_ : βˆ€ {A} β†’ Subset A β†’ Subset A β†’ Subset A
(A ∩ B) x = x ∈ A Γ— x ∈ B
The proof of range inclusion is done very naturally with this definition.
βŠ†-range-∩ : βˆ€ {A B} {F G : Relation A B} β†’ Range (F ∩ G) βŠ† (Range F ∩ Range G)
βŠ†-range-∩ _ ⟨ a , ⟨ Fab , Gab ⟩ ⟩ = ⟨ ⟨ a , Fab ⟩ , ⟨ a , Gab ⟩ ⟩
I also took the liberty to add the corresponding property about union.
_⋃_ : βˆ€ {A} β†’ Subset A β†’ Subset A β†’ Subset A
(A ⋃ B) x = x ∈ A ⊎ x ∈ B
⋃-range-βŠ† : βˆ€ {A B} {F G : Relation A B} β†’ (Range F ⋃ Range G) βŠ† Range (F ⋃ G)
⋃-range-βŠ† _ (inj₁ ⟨ a , Fab ⟩) = ⟨ a , inj₁ Fab ⟩
⋃-range-βŠ† _ (injβ‚‚ ⟨ a , Gab ⟩) = ⟨ a , injβ‚‚ Gab ⟩

Proposition Logic : CNF Conversion

I'm trying to solve a simple exercise in which I have to convert a propositional sentence in CNF :
This is the sentence :
P => (Q <=> R)
According to the resolution rule the first thing I did is to eliminate the <=> symbol in this way :
P => (Q <=> R) ---> P => (Q V R) /\ (R V Q)
Then I removed the => symbol :
P => (Q V R) /\ (R V Q) ------> Β¬P V (Q V R) /\ (R V Q)
So my solution is : (Β¬P V Q V R) /\ (Β¬P V R V Q)
While the right one is : (Β¬P V Β¬Q V R) /\ (Β¬P V Β¬R V Q)
Can anyone help me to understand where I get wrong ?

StackOverflow is intended for programming questions, which rules this question off-topic. But since I've already typed that much let me add that your first step ...
P => (Q <=> R) ---> P => (Q V R) ^ (R V Q)
is incorrect.
You know that Q<=>R means by definition (Q=>R)^(R=>Q), right? So replacing that is the first step. Then you can use the equivalences (Q=>R) ---> (~QvR) and (R=>Q) ---> (~RvQ).
Putting that together you should get ...
P => (Q <=> R) ---> P => (~Q V R) ^ (~R V Q)
I think you can work out the rest.

Proving two propositions are logically equivalent (without truth table)

I have to prove that ~pβ†’(qβ†’r)≑ qβ†’(pvr)
This is what I've done so far:
q→(pvr)
≑(qβ†’p)v(qβ†’r)
≑ ~(qβ†’p)β†’(qβ†’r)
≑ (q^~p)β†’(qβ†’r)
≑ qβ†’(~qvr) v ~pβ†’(qβ†’r)
≑ ~qv(~qvr) v ~pβ†’(qβ†’r)
≑ (~qvr)v ~pβ†’(qβ†’r)
≑ (qβ†’r) v [~pβ†’(qβ†’r)]
How should i solve this?

~p→(q→r) <=> p v (q→r) <=> p v (~q v r) <=> p v ~q v r
q→(p v r) <=> ~q v (p v r) <=> ~q v p v r <=> p v ~q v r
Here I am using the rule that p→q <=> ~p v q and the fact that disjunction is associative and commutative.

Propositional logic [closed]

Closed. This question needs details or clarity. It is not currently accepting answers.
Want to improve this question? Add details and clarify the problem by editing this post.
Closed 7 years ago.
Improve this question
I am trying to get from (p→q) and (qr→s) to (pr→s), which is the same as ((not p) or q) and (not(q and r) or s) to (not(p and r) or s)

Theorem:
p β†’ q
= ¬p ∨ q -- 1
(q ∧ r) β†’ s
= ¬(q ∧ r) ∨ s
= ¬q ∨ ¬r ∨ s -- 2
¬p ∨ ¬r ∨ s -- from 1 and 2, q and ¬q cancel
= ¬(p ∧ r) ∨ s
= (p ∧ r) β†’ s
Qed.
Using Coq, we can prove this theorem as follows:
Coq < Theorem prop : forall p q r s : Prop, (p -> q) /\ (q /\ r -> s) -> p /\ r -> s.
1 subgoal
============================
forall p q r s : Prop, (p -> q) /\ (q /\ r -> s) -> p /\ r -> s
prop < intros.
1 subgoal
p : Prop
q : Prop
r : Prop
s : Prop
H : (p -> q) /\ (q /\ r -> s)
H0 : p /\ r
============================
s
prop < destruct H.
1 subgoal
p : Prop
q : Prop
r : Prop
s : Prop
H : p -> q
H1 : q /\ r -> s
H0 : p /\ r
============================
s
prop < destruct H0.
1 subgoal
p : Prop
q : Prop
r : Prop
s : Prop
H : p -> q
H1 : q /\ r -> s
H0 : p
H2 : r
============================
s
prop < apply H1.
1 subgoal
p : Prop
q : Prop
r : Prop
s : Prop
H : p -> q
H1 : q /\ r -> s
H0 : p
H2 : r
============================
q /\ r
prop < split.
2 subgoals
p : Prop
q : Prop
r : Prop
s : Prop
H : p -> q
H1 : q /\ r -> s
H0 : p
H2 : r
============================
q
subgoal 2 is:
r
prop < exact (H H0).
1 subgoal
p : Prop
q : Prop
r : Prop
s : Prop
H : p -> q
H1 : q /\ r -> s
H0 : p
H2 : r
============================
r
prop < exact H2.
No more subgoals.
prop < Qed.
intros.
destruct H.
destruct H0.
apply H1.
split.
exact (H H0).
exact H2.
prop is defined
Hope that helps.

Resources