Let's think about logical rules AND and OR as if they are just procedures which "implements" the logical rules.
Let's denote Truth as 1 ans Falsehood as 0
So logical AND is in some sense same as multiplication by 0. Anything multiplied by 0 is zero, anything multiplied by 1 is just whatever it is, except zero.
If there is at least one False, then the whole thing is False, only True AND True is True
0 AND 0 is 0 0 AND 1 is 0 1 AND 0 is 0 1 AND 1 is 1
If there is at least one Truth then the whole thing is True, only False OR False is False
0 OR 0 is 0 0 OR 1 is 1 1 OR 0 is 1 1 OR 1 is 1
There are definitions of such rules, which, by magic, happen to be a procedure definitions:
Something AND True is something, whatever it is, BUT, Something AND False is indeed False (something times 1 is something, except for 0, anything times 0 is 0)
(&&) :: Bool -> Bool -> Bool -- let's ignore this clutter for a while. True && x = x False && _ = False
Something OR True is True, only False OR False is False
(||) :: Bool -> Bool -> Bool True || _ = True False || x = x
What is NOT True is False, what is NOT False is True.
not :: Bool -> Bool not True = False not False = True
Whole books could be written about the beauty of pattern matching, some day, perhaps.
There are recursive procedures defined for Lists in a beautiful foreign language
and :: [Bool] -> Bool and  = True and (x:xs) = x && and xs
which must be posted on walls.
or :: [Bool] -> Bool or  = False or (x:xs) = x || or xs
And there is another two pieces of an incredible beauty
and = foldr (&&) True
worth to be printed and framed
or = foldr (||) False
OK, let's leave foreign lands and return back to the world of Lisps.