logic is the math of yes/no questions thats's it. That's the whole subject. Everything below is just formalizing something you already do instinctively when you write code.

Propositions - statement that are True or false that's it there is no uncertainties in this it holds one truth that's all

Examples:

• "7 is greater than 3" -> True.

• "Kathmandu is the capital of Nepal"-> True.

• "2 + 2 = 5" -> False.

Not propositions (because they're not statements with a fixed truth value)

• "What time is it?"(a question , not a statement)

• "close the command"(a command)

• "x + 5 = 10" ( depends on x - it's only a proposition once x has an actual value).

why should you care as a C Programmer?

Every single if condition you write is a proposition .

int x = 7;
if(x>5){ //this is a proposition
  printf("big\n"); //true
} 

In C, True is represented as 1 ( or more precisely "any non-zero value") , and false is 0. That's why this works

int result = (x>5) ; //result is literally 1 because proposition is True
printf("%d\n",result);

So basically we've been creating and evaluation propositions this whole time without naming them. Now you've the name.

2 . The operators - Combining propositions

You rarely have just one condition . You combine them . There are 4 you'll use constantly

AND( ^ ) -C : &&

OR ( V ) - C : ||

P  Q  P AND Q(both must be true)   P  Q  P OR Q (one must be true)
T  T   T                           T  T    T
F  F   F                           F  F    F
F  T   F                           T  F    T 
T  F   F                           F  T    T

P   !p(NOT)                        P   Q   P X-OR Q
T    F                             F   F    F
F    T                             T   T    F
                                   T   F    T
                                   F   T    T

3 . DE - MORGAN'S LAWS

>(P ^ Q) == >P V >Q - this means "NOT(P and Q)" == NOT(P) OR NOT(Q)

>(P V Q) == >P ^ >Q - this means "NOT(P OR Q)" == NOT(P) AND NOT(Q)

Why a C Programmer needs this : (DE MORGAN) ?

Validating input and the difference between "reject bad Input" and "accept good input"

int x = 50 , has_permission = 1;
//say you want to REJECT anything that isn't (in range AND has permission)

if(!(x >=0 && x<=100 && has_permission)){
    printf("Rejected\n");
}

This works , but nested (!) around a long && chain is genuinely hard to read when you're debugging . DE-MORGAN lets you write it.

if(x < 0 || x>100 || !has_permission){
   printf("Rejected\n");
}

Both version are 100% equivalent same truth value table but the second one reads naturally : " reject if too small , OR Too big , OR no permission"