Docstoc

Logic

Document Sample
Logic Powered By Docstoc
					Logic

Bram
What is Logic?
             What is logic?
• Logic is the study of valid reasoning.
• That is, logic tries to establish criteria to
  decide whether some piece of reasoning is
  valid or invalid.
• OK, so then what do we mean by ‘valid
  reasoning’?
               Reasoning
• When we reason, we infer something (Y)
  from something else (X).
• That is, when we reason, we go like: “Well,
  if such-and-such-and-so (X) is the case,
  then this-and-that-and-the-other-thing (Y)
  must also be the case ”
• X and Y are thus things-that-can-be-the-
  case-or-not-be-the-case

            Reasoning Diagram:   XY
      Good vs Bad Reasoning
• What is the purpose of reasoning? Well, through
  reasoning, we try to gain new knowledge.
• ‘Good’ reasoning is a piece of reasoning that
  successfully fulfills this purpose, i.e. that indeed
  gives us a new piece of knowledge.
• ‘Bad’ reasoning is a piece of reasoning that, for
  some reason or other, is unsuccessful in this
  purpose.
• What can go wrong?
   – Reasoning is invalid
   – Reasoning is unsound
   – Reasoning is circular
            Valid Reasoning
• While in every piece of reasoning something is
  believed to follow from something else, this may
  in fact not be so.
• Example: “If I win the lottery, then I’m happy.
  However, I did not win the lottery. Therefore, I
  am not happy.”
• A piece of reasoning in which Y is believed to
  follow from X is valid if Y does indeed follow
  from X. Otherwise, the reasoning is said to be
  invalid.
            Sound Reasoning
• Not all valid reasoning is good reasoning.
• Example: “If I win the lottery, then I’ll be poor.
  So, since I did win the lottery, I am poor.”
• This piece of reasoning is valid, but not very
  good, since part of what it assumed is absurd (‘If
  I win the lottery, I’ll be poor.’ Huh??) (also, I did
  not win the lottery  )
• A piece of reasoning where Y is believed to
  follow from X is sound if a) it is valid, and b) X is
  true (or at least acceptable/plausible).
        Truth and Implication
• Logic studies the validity of reasoning.
• Logic does not study soundness.
• Therefore, logic alone cannot tell us
  whether an argument is good. Hence,
  logic alone is not a guide to truth.
• Instead, logic can tell us, assuming certain
  things to be true, what else will be true as
  well. Thus, logic is a guide to implication.
              Arguments
• A piece of reasoning consists of a
  sequence of statements, some of which
  are claimed to follow from previous ones.
  That is, some are claimed to be inferred
  from others.
• Example: “Either the housemaid or the
  butler killed Mr. X. However, if the
  housemaid would have done it, the alarm
  would have gone off, and the alarm did not
  go off. Therefore, the butler did it.”
     Arguments, Premises and
           Conclusion
• In logic, pieces of reasoning are analyzed using
  the notion of an argument
• An argument consists of any number of
  premises, and one conclusion
• Again, in logic, we are merely interested in
  whether the conclusion follows from the
  premises: we are not interested in whether those
  premises are true or acceptable.
• If you want to study all aspects of good
  reasoning, take my class Methods of Reasoning.
         Deductive Validity vs
          Inductive Validity
• An argument is said to be deductively valid if,
  assuming the premises to be true, the
  conclusion must be true as well.
• An argument is said to be inductively valid if,
  assuming the premises to be true, the
  conclusion is likely to be true as well.
• For now, we will limit ourselves to deductive
  validity only!
• If you want to study non-deductive reasoning,
  take my Methods of Reasoning class.
            Argument Forms
• “If I win the lottery, then I am poor. I win the
  lottery. Hence, I am poor.”
• This argument has the following abstract
  structure or form: “If P then Q. P. Hence, Q”
• Any argument of the above form is valid,
  including “If flubbers are gook, then trugs are
  brig. Flubbers are gook. Hence, trugs are brig.”!
• Hence, we can look at the abstract form of an
  argument, and tell whether it is valid without
  even knowing what the argument is about!!
              Formal Logic
• Formal logic studies the validity of
  arguments by looking at the abstract form
  of arguments.
• Formal logic always works in 2 steps:
  – Step 1: Use certain symbols to express the
    abstract form of premises and conclusion.
  – Step 2: Use a certain procedure to figure out
    whether the conclusion follows from the
    premises based on their symbolized form
    alone.
Example Step 1: Symbolization
• Use symbols to represent simple propositions:
  – H: The housemaid did it
  – B: The butler did it
  – A: The alarm went off
• Use further symbols to represent complex
  claims:
  – H  B: The housemaid or the butler did it
  – HA: If the housemaid did it, the alarm would go off
  – ~A: The alarm did not go off
Example Step 2: Evaluation
• One possible technique is to transform the
  symbolic representations using basic rules that
  reflect elementary valid inferences:

   1.   HB     A.
   2. HA       A.
   3.   A      A.         Since every step along the way
                           is an instance of an obviously
   4.   H      2, 3 MT    valid inference, the conclusion
   5.   B       1, 4 DS    does indeed follow from the
                           premises. So, valid argument!
           Propositional Logic
• Propositional Logic studies validity at the level of
  simple and compound propositions.
• Simple proposition: An expression that has a
  truth value (a claim or a statement). E.g. “John is
  tall”
• Compound proposition: An expression that
  combines simple propositions using truth-
  functional connectives like ‘and’, ‘or’, ‘not’, and ‘if
  … then’. E.g. “John is tall and Mary is smart”
           Predicate Logic
• Predicate Logic extends Propositional
  Logic by adding individuals, predicates,
  and quantifiers
• Individuals: ‘John’, ‘Mary’
• Predicates: ‘tall’, ‘smart’
• Quantifiers: ‘all’, ‘some’
         Just to Put Things in
             Perspective
     All arguments



All deductive arguments



 All deductive arguments that
 can be analyzed using the formal
 logics we cover in class           (And I’m probably
                                    optimistic here!)
         Uses of Formal Logic
• Evaluation/Checking:
   – Formal logic can be used to evaluate the validity of
     arguments.
• Clarification/Specification:
   – Formal logic can be used to express things in a
     precise and unambiguous way.
• Demonstration/Proof:
   – Formal logic can be used to figure out what follows
     from a set of assumptions.
• Computation/Automated Reasoning:
   – Formal logic can be used for machine reasoning.
     Logic, Computers, and AI
• Formal logic has many connections to
  computers:
  – Computation: Formal logic played a crucial role in the
    development of the notion of ‘computation’ (See my
    class PHIL 4420 Computability and Logic)
  – Circuit Design: Formal logic can be used for circuit
    design (See CSCI 2500 Computer Organization)
  – Artificial Intelligence: Formal logic is central to many
    AI applications (See CSCI 4150 Artificial Intelligence)
Boolean Connectives
         Propositional Logic
• Propositional Logic is the logic involving
  complex claims as constructed from
  atomic claims and connectives.
• Propositional Logic is not as powerful as
  Predicate Logic, but it has some powerful
  applications already.
 Truth-Functional Connectives and
       Boolean Connectives
• Connectives are usually called truth-functional
  connectives:
  – This is because the truth value of a complex claim
    that has been constructed using a truth-functional
    connective is considered to be a function of the truth
    values of the claims that are being connected by that
    connective.
  – This is also why propositional logic is also called
    truth-functional logic.
• For now, we will focus on three connectives:
  and, or, not; these are called the Boolean
  connectives.
                   Negation
• The claim “a is not to the right of b” is a complex
  claim. It consists of the atomic claim “a is to the
  right of b” and the truth-functional connective
  “not”.
• We will call the above statement a negation.
• To express negations, we use the symbol ‘’
• ‘’ should be put in front of what you want to be
  negated.
• If we symbolize the atomic claim “a is to the right
  of b” as P, then the original claim will be
  symbolized as: P
     Truth-Table for Negation
• ‘’ is truth-functional, since the truth-value
  of a negation is the exact opposite of the
  truth-value of the statement it negates.
• We can express this using a truth table:

                 P P
                 T F
                 F T
               Conjunction
• The claim “a is to the right of b, and a is in
  front of b” is called a conjunction.
• The two claims that are being conjuncted
  in a conjunction are called its conjuncts.
• To express conjunctions, we will use the
  symbol ‘’
• ‘’ should be put between the two claims.
• Thus, the above statement can be
  symbolized as: P  Q
   Truth-Table for Conjunction
• ‘’ is truth-functional, since a conjunction
  is true when both conjuncts are true, and it
  is false otherwise.
• Again, we can show this using a truth
  table:
             P   Q PQ
             T   T  T
             T   F  F
             F   T  F
             F   F  F
               Disjunction
• The claim “a is to the right of b, or a is in
  front of b” is called a disjunction.
• The two claims that are being disjuncted in
  a disjunction are called its disjuncts.
• To express disjunctions, we will use the
  symbol ‘’
• ‘’ should be put between the two claims.
• Thus, the above statement can be
  symbolized as: P  Q
    Truth-Table for Disjunction
• ‘’ is truth-functional, since a disjunction is
  true when at least one of its disjuncts is
  true, and it is false otherwise.
• Again, we can show this using a truth
  table:
              P   Q PQ
              T   T  T
              T   F  T
              F   T  T
              F   F  F
  Combining Complex Claims:
        Parentheses
• Using the truth-functional connectives, we
  can combine complex claims to make
  even more complex claims.
• We are going to use parentheses to
  indicate the exact order in which claims
  are being combined.
• Example: (P  Q)  (R  S) is a
  conjunction of two disjunctions.
   Parentheses and Ambiguity
• An ambiguous statements is a statement whose
  meaning is not clear due to its syntax. Example :
  ”P or Q and R”
• In formal systems, an expression like P  Q  R
  is simply not allowed and considered
  unsyntactical.
• Claims in our formal language are therefore
  never ambiguous.
• One important application of the use of formal
  languages is exactly this: to avoid ambiguities!
      Exclusive Disjunction vs
       Inclusive Disjunction
• Notice that the disjunction as defined by
  ‘’ is considered to be true if both disjuncts
  are true. This is called an inclusive
  disjunction.
• However, when I say “a natural number is
  either even or odd”, I mean to make a
  claim that would be considered false if a
  number turned out to be both even and
  odd. Thus, I am trying to express an
  exclusive disjunction.
     How to express Exclusive
           Disjunctions
• We could define a separate symbol for exclusive
  disjunctions, but we are not going to do that.
• Fortunately, exclusive disjunctions can be
  expressed using the symbols we already have:
  (PQ)  (PQ)

              P   Q (P  Q)  (PQ)
              T   T    T F F T
              T   F    T T T F
              F   T    T T T F
              F   F    F F T F
                              !
Conditionals
      The Material Conditional
• Let us define the binary truth-functional
  connective ‘’ according to the truth-table
  below.
• The expression P  Q is called a conditional. In
  here, P is the antecedent, and Q the
  consequent.
              P   Q PQ
              T   T  T
              T   F  F
              F   T  T
              F   F  T
      ‘If … then …’ Statements

• The conditional is used to capture ‘if … then …’ statements.
• However, the match isn’t perfect. For example, we don’t want to
  say that the claim “If grass is green then elephants are big” is
  true just because grass is green and elephants are big, nor that
  any ‘if … then’ statement is automatically true once the ‘if’ part is
  false or the ‘then part true. The problem is that most English
  ‘if…then’ expressions aren’t meant to make a claim that is truth-
  functional in nature.
• Still, any ‘if … then …’ statement will be false if the ‘if’ part is
  true, but the ‘then’ part false, and the conditional captures at
  least this important truth-functional aspect of any ‘if … then …’
  statement.
• So, while we will from now on refer to the conditional as an ‘if …
  then’ statement, we must be careful about the use of this, just as
  care must be taken when applying Newtonian physics to some
  situation.
      Necessary and Sufficient
            Conditions
• Conditionals can be used to express necessary
  and sufficient conditions:
• Sufficient Condition: Something (P) is a sufficient
  condition for something else (Q) iff P being the
  case guarantees Q being the case. Hence, if we
  know that P is true, we know that Q is true: P 
  Q
• Necessary Condition: Something (P) is a
  necessary condition for something else (Q) iff P
  being the case is required for Q being the case.
  Thus, while P may be true without Q being true,
  we do know that if Q is true, P is true: Q  P
              ‘If’ vs ‘Only if’
• Sufficient conditions are expressed in
  English using ‘if’, while necessary
  conditions are expressed using ‘only if’.
• Thus:
  – ‘If P then Q’: P  Q
  – ‘P if Q’: Q  P
  – ‘P only if Q’: P  Q
  – ‘Only if P, Q’: Q  P
         ‘If and only if’ and the
         Material Biconditional
• A statement of the form ‘P if and only if Q’ (or ‘P
  iff Q’) is short for ‘P if Q, and P only if Q’. Hence,
  we could translate this as (P  Q)  (Q  P).
  However, since this is a common expression, we
  define a new connective ‘’:

                P   Q PQ
                T   T  T
                T   F  F
                F   T  F
                F   F  T
Logical Properties
               Truth Tables
• Truth-tables can be used for:
  – defining the truth-conditions of truth-functional
    connectives
  – evaluating the truth-conditions of any complex
    statement
              Tautologies
• A tautology is a statement that is
  necessarily true.
• Example: P  P



                P P  P
                T TT F T
                F F T TF
             Contradictions
• A contradiction is a statement that is
  necessarily false.
• Example: P  P



                P P  P
                T TF F T
                F F F TF
            Contingencies
• A contingency is a statement that can be
  true as well as false
• Example: P



               P P
               T T
               F F
            Equivalences
• Two statements are equivalent if they
  have the exact same truth-conditions.
• Example: P and P



               P P P
               T T TF T
               F F F TF
            Contradictories
• Two statements are contradictories if one
  of them is false whenever the other one is
  true and vice versa.
• Example: P and P

               P P P
               T T FT
               F F TF
                 Implication
• One statement implies a second statement
  if it is impossible for the second statement
  to be false whenever the first statement is
  true.
• Example: P implies P  Q
             P   Q   P   PQ
             T   T   T    T
             T   F   T    T
             F   T   F    T
             F   F   F    F
              Consistency
• A set of statements is consistent if it is
  possible for all of them to be true at the
  same time.
• Example: {P, P  Q, Q}

              P   Q   P   PQ   Q
              T   T   T    T    F
              T   F   T    T    T
              F   T   F    T    F
              F   F   F    F    T
             Consequence
• A statement is a consequence of a set of
  statements if it is impossible for the
  statement to be false while each statement
  in the set of statements is true.
• Example: P is a consequence of {PQ, Q}
             P   Q   PQ   Q   P
             T   T    T    F    T
             T   F    T    T    T
             F   T    T    F    F
             F   F    F    T    F
                      Validity
• An argument is valid if it is impossible for
  the conclusion to be false whenever all of
  its premises are true.
• Example: P  Q, Q  P


              P   Q    PQ   Q   P
              T   T     T    F    T
              T   F     T    T    T
              F   T     T    F    F
              F   F     F    T    F
Implication, Consequence, Validity
• The notions of implication, consequence, and
  validity are very closely related:
• A statement  implies a statement  if and only
  if  is a consequence of the set of statements
  {}
• For implication and consequence we use the
  symbol ‘’:
  – If statement  implies statement  we write   
  – If statement  is a consequence of a set of
    statements {1, …, n}, we write {1, …, n}  
• An argument consisting of premises 1, …, n
  and conclusion  is valid iff {1, …, n}  
• The terms implication, consequence and validity
  can therefore be used interchangeably.
                                Summary
•   Logical properties of a single statement:
     – Tautology: cannot be false
     – Contradiction: cannot be true
     – Contingent: can be true and can be false
•   Logical properties of 2 statements:
     –   Equivalent: always the same truth-value
     –   Contradictory: always opposite truth-values
     –   Contrary: cannot be both true
     –   Subcontrary: cannot be both false
     –   Implication: implied statement cannot be false while the implying statement is
         true
•   Logical properties of a set of statements:
     – Consistent: can be all true at the same time
•   Logical properties of a set of statements in relation to a single statement:
     – Consequence: statement cannot be false if all of the statements of the set are
       true
•   Logical properties of an argument:
     – Valid: conclusion cannot be false if all premises are true
               But Wait!
• Consider the statement ‘a=a’
• This statement is a tautology, since it
  is always true.
• However, since this statement does
  not involve any truth-functions,
  propositional logic considers this an
  atomic statement, and symbolizes it
  as ‘P’. But ‘P’ is a contingency.
• What is going on??
   Truth-Functional Tautologies
• What is going on is that truth-tables only capture
  the truth-functional aspects of sentences.
• So, a statement may be a tautology for reasons
  other than truth-functional reasons. ‘a=a’ is an
  example.
• A statement that is a tautology because of truth-
  functional considerations is called a truth-
  functional tautology.
• Notice that while every truth-functional tautology
  is a tautology, not every tautology is a truth-
  functional tautology (again, ‘a=a’ is a tautology,
  but not a truth-functional tautology)
   Normal Forms and
Expressive Completeness
Logically Equivalent Statements
• To express that two statements P and Q
  are logically equivalent, we will write:
  PQ
• ‘’ is not a symbol of F!!
 Some Important Equivalences
• Double Negation:
   – PP
• DeMorgan:
   – (P  Q)  P  Q
   – (P  Q)  P  Q
• Distribution:
   –   P  (Q  R)  (P  Q)  (P  R)
   –   P  (Q  R)  (P  Q)  (P  R)
   –   (Q  R)  P  (Q  P)  (R  P)
   –   (Q  R)  P  (Q  P)  (R  P)
            More Equivalences
• Commutation:
   – PQQP
   – PQQP
• Association:
   – P  (Q  R)  (P  Q)  R
   – P  (Q  R)  (P  Q)  R
• Idempotence:
   – PPP
   – PPP
• Subsumption:
   – P  (P  Q)  P
   – P  (P  Q)  P
      Even More Equivalences
• Implication:
  – P  Q  P  Q
  – (P  Q)  P  Q
• Transposition:
  – P  Q  Q  P
• Exportation:
  – P  (Q  R)  (P  Q)  R
• Absorption:
  – P  Q  P  (P  Q)
• Equivalence:
  – P  Q  (P  Q)  (Q  P)
  – P  Q  (P  Q)  (P  Q)
      Simplifying Statements I
• Using the principle of substitution of logical
  equivalents, and using the logical equivalences
  that we saw before (Double Negation,
  Association, Commutation, Idempotence,
  DeMorgan, Distribution, and Subsumption), we
  can often simplify statements.
• Example:
               (A  B)  A  (Commutation)
               (B  A)  A  (Association)
               B  (A  A)  (Idempotence)
               BA
    Generalized Conjunctions and
      Generalized Disjunctions
• Recall the Association equivalences:
  – P  (Q  R)  (P  Q)  R
  – P  (Q  R)  (P  Q)  R
• Because of this, we’ll allow to drop brackets:
  – PQR
  – PQR
• Thus we can generalize conjunctions and
  disjunctions
  – A generalized conjunction (disjunction) can have any
    number of conjuncts (disjuncts)
     Simplifying Statements II
• The conjuncts (disjuncts) of a generalized
  conjunction (disjunction) can be switched
  around in any way you want. This really
  helps with simplifying statements.
  Example:


       C  (A  (B  C))  (Distribution)
       C  (A  B)  (A  C)  (Subsumption)
       C  (A  B)
                ‘⊤’ and ‘⊥’
• A generalized conjunction is false if it has
  at least one false conjunct, otherwise it is
  true.
  – So, a generalized conjunction with 0
    conjuncts cannot have a false conjunct, and
    hence cannot be false. Therefore, it is a
    tautology! We will write this as ‘⊤’.
• A generalized disjunction is true if it has at
  least one true disjunct, otherwise it is
  false.
  – Hence, a generalized disjunction with 0
    disjuncts can never be true, and is therefore a
    contradiction! We will write this as ‘⊥’.
    Some equivalences involving ‘⊤’
               and ‘⊥’
•   ⊥  ⊤
•   ⊤  ⊥
•   P⊥⊥
•   P⊤⊤
•   P⊤P
•   P⊥P
•   P  P  ⊥
•   P  P  ⊤
    Simplifying Statements III
• Using ‘⊤’ and ‘⊥’, we can simplify
  statements even more. Example:


      (A  (B  (A  B))  (DeMorgan)
      A  (B  (A  B))  (Double Neg.)
      A  B  (A  B)  (Distribution)
      (A  B  A)  (A  B  B) 
      ⊥⊥
      ⊥
       Negation Normal Form
• Literals: Atomic Sentences or negations thereof.
• Negation Normal Form: An expression built up
  with ‘’, ‘’, and literals.
• Using repeated DeMorgan and Double
  Negation, we can transform any truth-functional
  expression built up with ‘’, ‘’, and ‘’ into an
  expression that is in Negation Normal Form.
• Example:
               ((A  B)  C)  (DeMorgan)
               (A  B)  C  (Double Neg, DeM)
               (A  B)  C
      Disjunctive Normal Form
• Disjunctive Normal Form: A disjunction of
  conjunctions of literals.
• Using repeated distribution of  over , any
  statement in Negation Normal Form can be
  written in Disjunctive Normal Form.
• Example:

       (AB)  (CD)  (Distribution)
       [(AB)C]  [(AB)D]  (Distribution (2x))
       (AC)  (BC)  (AD)  (BD)
     Conjunctive Normal Form
• Conjunctive Normal Form: A conjunction of
  disjunctions of literals.
• Using repeated distribution of  over , any
  statement in Negation Normal Form can be
  written in Conjunctive Normal Form.
• Example:

      (AB)  (CD)  (Distribution)
      [(AB)  C]  [(AB)  D]  (Distribution (2x))
      (AC)  (BC)  (AD)  (BD)
  Truth-Functional Connectives
• So far, we have seen one unary truth-functional
  connective (‘’), and two binary truth-functional
  connectives (‘’, ‘’).
• Later, we will see two more binary connectives
  (‘’, ‘’)
• However, there are many more truth-functional
  connectives possible:
  – First of all, a connective can take any number of
    arguments: 3 (ternary), 4, 5, etc.
  – Second, there are unary and binary connectives other
    than the ones listed above.
            Unary Connectives
• What other unary connectives are there
  besides ‘’?
• Thinking about this in terms of truth tables,
  we see that there are 4 different unary
  connectives:


    P   *P     P   *P     P   *P    P   *P
    T   T      T   T      T   F     T   F
    F   T      F   F      F   T     F   F
        Binary Connectives
• The truth table below shows that there are
  24 = 16 binary connectives:

           P Q   P*Q
                         In general:
           T T   T/F     n sentences 
           T F   T/F     2n truth value combinations
           F T   T/F     (i.e. 2n rows in truth table) 

           F F   T/F
                          2n
                         2 different n-ary connectives!
  Expressing other connectives
    using ‘and’, ‘or’, and ‘not’
• We saw that we can express the exclusive
  disjunction using ‘and’, ‘or’, and ‘not’.
• Q: Can we express all other connectives as
  well?
• A: Yes! We can generalize from this example:
    P Q    P*Q
                  Step 1:   Step 2:
    T T     F
    T F     T     PQ
                             (PQ)  (PQ)
    F T     T     PQ
    F F     F
   Truth-Functional Expressive
          Completeness
• Since I can express any truth function using ‘’,
  ‘’, and ‘’, we say that the set of operators {,
  , } is (truth-functionally) expressively
  complete.
• DeMorgan Laws:
   – (P  Q)  P  Q
   – (P  Q)  P  Q
• Hence, by the principle of substitution of logical
  equivalents, since {, , } is expressively
  complete, the sets {, } and {, } are
  expressively complete as well!
     Applications: Computer
     Hardware and Software
• The results that we have seen on the
  previous slides have important
  applications in both computer hardware
  and software:
  – Digital Circuits
  – Machine Reasoning
Logic and Computer Circuitry
                  1’s and 0’s
• All what modern digital computers do is
  transform strings of 1’s and 0’s, called bitstrings.
• Information is represented using 1’s and 0’s, and
  information is processed through the
  manipulation of those bitstrings.
• The 1’s and 0’s can be physically realized using
  any kind of physical dichotomy. We can
  therefore use pure mechanics (levers, pulleys,
  punchcards, etc.), electronics, optics, DNA,
  quantum physics, toilet paper and pennies, or
  just about anything else to physically implement
  the 1’s and 0’s.
                Logic Gates
• To process information, bitstrings need to be
  manipulated.
• Thus, depending on whatever way the 1’s and
  0’s are physically implemented, there needs to
  be a device to change those physical
  representations.
• But, we are not going to be interested in the
  physical nature of these devices, since this is
  just an issue of implementation.
• Rather, we are going to think of these devices as
  logic gates: thingamabobs that transform
  bitstrings into other bitstrings.
      ‘And’, ‘Or’, and ‘Not’ Gates
                         In1   In2   Out
                         1     1      1
In1
                  Out    1     0      0
In2                      0     1      0
                         0     0      0


                         In1   In2   Out
In1                      1     1      1
                  Out    1     0      1
In2                      0     1      1
                         0     0      0


                               In    Out
In                Out          1     0
                               0     1
      Representing Numbers
• We normally represent numbers using the
  decimal system. That is, we take 10 as our
  base number to represent numbers.
• Example:

        53627
                7*100 =     7*1 =     7
                2*101 =    2*10 =    20
                6*102 = 6*100 = 600
                3*103 = 3*1000 = 3000
                5*104 = 5*10000 = 50000
                                  53627
           Binary Numbers
• Binary numbers take 2 as their base.
• Example:



        10110
                0*20 = 0*1 = 0
                1*21 = 1*2 = 2
                1*22 = 1*4 = 4
                0*23 = 0*8 = 0
                1*24 = 1*16 = 16
                              22
Adding Binary Numbers



     111   1 1
     11010110
     10110011
    110001001
   Computing Binary Addition
• To compute the addition of two binary
  numbers, we need to implement the
  following architecture:

                 In10            Out0
                        +
                 In20       Carry1
                 In11            Out1
                        +
                 In21       Carry2
                 In12           Out2
                        +
                 In22
                        
        2 Bit and Carry Adder

       Carryn              In1n   In2n Carryn   Outn   Carryn+1
In1n            Outn       1      1      1       1       1
                           1      1      0       0       1

In2n
            +   Carryn+1
                           1      0      1       0       1
                           1      0      0       1       0
                           0      1      1       0       1
                           0      1      0       1       0
                           0      0      1       1       0
                           0      0      0       0       0
Circuitry for the 2 Bit and Carry
       Adder (output bit)


In1n


In2n                          Outn


Carryn
Circuitry for the 2 Bit and Carry
        Adder (carry bit)


In1n


In2n                          Carryn+1


Carryn
               Simplifying
• While the Disjunctive Normal Form
  provides us with a working circuitry (and
  thus guarantees us of one!), this circuitry
  may not be the most efficient one.
• Carryn+1 = (In1n  In2n)  (In1n  Carryn) 
  (In2n  Carryn)
• Outn = (In1n XOR In2n) XOR Carryn
  – where P XOR Q = (P  Q)  (P  Q)
     An Interesting Trade-Off
• To keep production costs down:
  – Use as few gates as possible
  – Use as few different kinds of gates as
    possible
• However, there is a trade-off between
  these two objectives: The fewer the
  number of kinds of gates one uses, the
  more gates of those kinds are needed.
     Example of the Trade-Off
• The Disjunctive Normal Form tells us that we
  can build any circuit using only 3 kinds of gates.
• With more types of gates (e.g. the XOR), we
  could have saved on the total number of gates.
• On the other hand, because of the DeMorgan’s
  Law, we know that we can express any
  expression using only ‘and’ and ‘not’. Thus, we
  can also try and cut down on the number of
  types of gates, but this will mean an increase in
  the number of gates.
                  The NAND
• Let us define the binary truth-functional
  connective ‘NAND’ according to the truth-table
  below.
• Obviously, P NAND Q  (P  Q) (hence the
  name!)


              P   Q P NAND Q
              T   T     F
              T   F     T
              F   T     T
              F   F     T
Expressive Completeness of the
            NAND
• The NAND has a very interesting property, in
  that it can express any truth-functional
  connective, i.e. {NAND} is expressively
  complete!
• Proof: We already know that we can express
  every truth-functional connective using only 
  and . Furthermore:
  – P NAND P  (P  P)  P
  – (P NAND P) NAND (Q NAND Q)  ((P NAND P) 
    (Q NAND Q))  (P  Q)  P  Q
• In other words, we can build circuitry using only
  one kind of logic gate!! Of course, the drawback
  is that we need many of those gates.
                The Miniac
• Behold! The world’s most powerful computer
  that fits in the palm of your hand: a penny!!
• Instructions: Ask any question with a yes or no
  answer. Flip the coin. Tails means ‘yes’ and
  heads means ‘no’. To see whether the Miniac’s
  answer is correct or incorrect, flip the coin a
  second time, asking: “Is your answer to this
  question just as correct as your answer to the
  previous question?”
• Question: How does this work?
Formal Proofs
      Demonstrating Invalidity
• To demonstrate invalidity one has to show
  that it is possible for all premises to be true
  and the conclusion to be false all at the
  same time.
• One way to do this is to come up with a
  possible scenario (or possible world) in
  which all premises are true and the
  conclusion false (Tarski’s World). This is
  called a counterexample.
        Demonstrating Validity
• To demonstrate validity, we have to show that there is no
  possible way for all premises to be true and the
  conclusion false all at the same time.
• Showing a scenario in which all premises are true, and in
  which the conclusion is true as well, does not
  demonstrate validity, b/c there may still be a different
  scenario in which all premises are true and the
  conclusion false.
• Of course, we could try and generate all possible worlds,
  but this method is either impractical (b/c there are too
  many possible worlds), or simply impossible (b/c there
  are infinitely many possible worlds).
                    Proofs
• OK, so what do we do? Well, we can do what we
  do in everyday reasoning: we start with the
  premises, and we gradually work our way to the
  conclusion: “Either the housemaid or the butler
  killed Mr. X. Now, we know that if the housemaid
  would have done it, the alarm would have gone
  off. But, the alarm did not go off. Therefore, the
  housemaid did not do it. So, since it was either
  the housemaid or the butler, it must have been
  the butler.”
         Intermediate Results
• The previous argument had 3 premises:
  – 1. Either the housemaid or the butler did it.
  – 2. If the housemaid did it, the alarm would have gone
    off.
  – 3. The alarm did not go off.
• The conclusion was: The butler did it.
• We combined premises 2 and 3 to get an
  intermediate result: The housemaid did not do it.
• We then combined the intermediate result with
  premise 1 to get the conclusion.
• We use intermediate conclusions because
  without them, the inference from the premises to
  the conclusion may not be obvious, but with
  them, each of the steps does become obvious.
                   ‘Obvious’
• In formal proofs, we try and formalize this step-
  by-step inference process, where each inference
  is obvious.
• OK, but ‘obvious’ is a bit of a vague term, as
  what is obvious to some, may not be obvious to
  others. So, what are going to count as ‘obvious’?
• We are going to play it safe: In formal proofs, we
  are only going to allow steps that are about as
  obvious as we can get. Thus, we are only going
  to allow ‘baby inferences’.
• So, in formal proofs, bigger inferences, which
  may still be obvious to many (if not all of us), will
  still have to be broken up into smaller ones!
            Inference Rules
• Formal systems of logic come with a finite
  set of inference rules that reflect ‘baby
  inferences’.
• There are many formal systems of logic,
  each with their own set of inference rules:
  – The nature of the inference rules depends on
    the symbols that the system uses to express
    statements.
  – However, even if two systems use the same
    symbols, they may still have different
    inference rules.
                   F:
  A ‘Fitch’-style Deductive System
• The formal system that our book uses is called
  F.
• F has 2 inference rules for each connective:
   – Introduction: A rule to infer a statement with that
     connective as its main connective
   – Elimination: A rule to infer something from a
     statement with that connective as its main connective.
• Formal systems with these two types of
  inference rules are called ‘Fitch’-style systems.
• Warning: While Fitch-style systems are
  mathematically elegant, they are not always very
  user-friendly. In particular, it does not contain
  inference rules that reflect some ‘obviously’ valid
  inferences!
   The Structure of Proofs in F
• A formal proof in F will look like this:

     1    P1
          
     n    Pn
    n+1   I1   Justification 1

          

  n+m     Im    Justification m

n+m+1     C     Justification m+1
                   Justification
• In a formal proof, you have to indicate from which
  premises or intermediate results you infer the new
  statement. Thus, each step needs to have its own
  justification.
• Inference rules may need any number of statements
  from which the new statement is inferred (though with
  too many statements, the rule may no longer be
  considered ‘obvious’).
• Most inference rules require one or two statements.
• Some inference rules require no statements at all. This is
  when the inferred statement is unconditionally true.
• To help refer to previous statements, we are going to
  number the statements.
                    Elim
• Conjunction Elimination ( Elim) allows
  one to infer any conjunct from a
  conjunction.


          P1  P2  …  Pn

          

          Pi
                     Intro
• Conjunction Introduction ( Intro) allows
  one to conjunct any number of previously
  established statements in any order.


           P1
           
           Pn
           P1  P2  …  Pn
                     Intro
• Disjunction Introduction ( Intro) allows
  one to construct any disjunction using a
  previous result as one of its disjuncts.


           Pi

           

           P1  …  Pi  …  Pn
                  Elim
• Negation Elimination ( Elim) allows one
  to infer P from  P:



          P

          

          P
      Do we Have Free Will?
• Either determinism is true or not. Now, if
  determinism is true, then my actions
  cannot be otherwise from what they are,
  i.e. I don’t any freedom to exert my will. On
  the other hand, if indeterminism is true,
  then my actions are partly determined by
  pure randomness, so there is no such
  thing as a will that is in total control of my
  actions. Either way, I don’t have free will.
             Proof by Cases
• The proof we just saw follows a certain pattern:
  ‘Either P is the case or Q is the case. However,
  if P is the case, then S is the case, and if Q is
  the case, then S is the case as well. Either way,
  S is therefore the case. Hence, S is the case.’
• This pattern of reasoning is called Proof by
  Cases
• Obviously, the above pattern can be generalized
  to disjunctions with any number of disjuncts.
• However, a very common form is to start with:
  ‘Either P is the case or P is not the case’.
        Is Space Continuous?
• Suppose space is continuous.
• Then between any two (different) points A and B
  there exist infinitely many other points.
• Thus, in order to move from any point A to any
  other point B, you have to completely go through
  a sequence of infinitely many points. But, you
  can never reach the end of an infinite sequence.
  Hence, motion is impossible.
• But, things do move.
• Contradiction!
• So, space is not continuous. (thanks to Zeno!)
       Proof by Contradiction
• The proof we just saw relied on the
  following pattern: ‘Assuming P to be the
  case, then I get some kind of impossibility
  or contradiction. Hence, contrary to my
  assumption, P cannot be the case.’
• This pattern of reasoning is called Proof by
  Contradiction (or Indirect Proof or
  Reductio ad Absurdum or simply
  Reductio).
        Proof by Cases and
       Proofs by Contradiction
• Proof by cases and proof by contradiction are
  two important proof techniques that we would
  like to formalize.
• But, these proof techniques do not work by
  inferring some statement from some other
  statement(s).
• Rather, they work by pointing to the fact that I
  am able to infer something from something else.
                 Subproofs
• At any time during a proof, a subproof may be
  started by making an additional assumption
  which can then be used to draw further
  inferences.
• The subproof may be ended at any time. When it
  is ended, the individual statements from the
  subproof can no longer be used to infer others.
• Subproofs demonstrate that certain statements
  can be inferred when an additional assumption
  is made, and this result can be used in the proof
  itself. That is, the subproof as a whole can be
  used to infer other statements.
 Formalizing Proof by Cases using
        Subproofs and ‘’
• Using subproofs, we can now formalize the
  Proof by Cases technique:
  – You have a disjunction P1  …  Pi  …  Pn
     • These are the possible cases
  – You start a subproof for each of the possible disjuncts
     • This is going through each of the cases (what if P1 is the
       case?; what if P2 is the case?, etc.)
  – You infer the same statement (Q) in all subproofs
     • This show that in all cases, the same thing (‘Q’) can be
       inferred
  – You now point to the initial disjunction and all the
    relevant subproofs to conclude Q
                     Elim
• Disjunction Elimination ( Elim) is the
  formal counterpart of Proof by Cases:

           P1  …  Pi  …  Pn
            P1
            
            S
           
            Pn
            
            S
           S
        Subproofs and Scope
• An additional line is used to indicate the start
  and end of the subproof.
• The line can also be seen as the scope of the
  additional assumption made at the start of the
  subproof: every statement within that scope is
  inferred from the truth of that assumption and all
  previous assumptions.
• The line of the proof itself can be seen in exactly
  this way as well. Therefore, there is no real
  difference between subproofs and proofs.
   Subproofs within Subproofs
• Within any subproof, another subproof can
  be started.
• Subproofs within subproofs must be ended
  before the original subproof is ended.
• The general rule is: one can use as
  justification all and only statements that is
  either one of the assumptions whose
  scope one is working in, or some
  statement inferred from those.
Formalizing Proof by Contradiction
    using subproofs and ‘’
• We can now formalize the Proof by
  Contradiction
  – Start a subproof, and assume P
    • All proofs by contradiction start by assuming
      something, and this is the opposite of what you
      want to prove!
  – In the subproof, derive 
    • This shows that assuming P leads to a
      contradiction
  – Point to the subproof, and conclude P
                   Intro
• Negation Introduction ( Intro) is the
  formal counterpart of Proof by
  Contradiction:


            P

            
            
           P
                   Intro
•  Introduction ( Intro) allows one to infer
   from a pair of statements P and P:



           P
           
           P
           
           
       More on contradictions
• Theorem: For any statement P:   P
• Proof: It is impossible for  to be true, so it
  is impossible for  to be true and P to be
  false, and hence for any P:   P
• In other words: Anything is a logical
  consequence from a logical contradiction!
                   Elim
•  Elimination ( Elim) allows one to infer
  any statement P from :



           

           

           P
                  Elim
• Conditional Elimination ( Elim) allows
  one to infer the consequent of a
  conditional, given the truth of its
  antecedent:

          PQ          This pattern is better known as
                      Modus Ponens
          P
          
          Q
           Conditional Proof
• We have seen two uses of subproofs: for Proofs
  by Contradiction, and for Proofs by Cases.
• A third use for subproofs is to do a Conditional
  Proof.
• A Conditional Proof infers some kind of
  conditional P  Q from a given set of
  statements by making P an extra assumption,
  and trying to infer Q from the given statements
  and the additional assumption P.
                   Intro
• Conditional Introduction ( Intro) is the
  formal counterpart of Conditional Proof:



            P

            
            Q
           PQ
           Modus Tollens
Pattern:     Proof:
          1.   
           2.   

           3.       
             4.          1,3  Elim
             5.          2,4  Intro
             6.         3-5  Intro
     Disjunctive Syllogism
Pattern:   Proof:
        1.   
         2.   

          3.       
           4.          2,3  Intro
           5.          4  Elim
           6.       

           7.          1,3-5,6-6  Elim
                    Fitch
• Fitch is the program that allows the user to
  construct formal proofs in F.
• Fitch has a number of additional features:
  – Checks whether a rule is applied correctly
  – Allows shortcuts that are not allowed in F
  – Provides CON rules
Metalogic
            Logic and Metalogic
• Metalogic is the study of logic. That is, where logic
  has no specific subject matter (logic can be applied in
  any field where reasoning takes place), the subject
  matter of metalogic is logic itself.
• Metalogic makes claims about logical properties and
  relationships. For example: “A statement is a
  tautology if and only if its negation is a contradiction”
  is a metalogical claim.
• Of course, the paradox of metalogic is that it needs
  logic to support the claims it makes about logic!
  Hmmm…
    A Central Metalogical Result:
   Consequence as a Central Notion
• Many interesting logical properties can be
  expressed in terms of logical consequence. For
  example:
  – Tautology: A statement  is a tautology iff {}  
  – Contradiction: A statement  is a contradiction iff
    ⊥
  – Equivalence: Two statements  and  are
    equivalent iff    and   
  – Inconsistency: A set of statements {1, …, n} is
    logically inconsistent iff {1, …, n}  
   Consequence and Formal Proof
• Since formal proofs can be used to demonstrate consequence,
  and since consequence can be used to demonstrate other
  logical properties, formal proofs can be used to demonstrate
  these other logical properties:
   – Tautology:
       • To prove that something is a tautology, derive that statement from an
         empty set of premises.
   – Contradiction:
       • To prove that a statement is a contradiction, derive  from that statement
         as a premise.
   – Equivalence:
       • To prove that two statements P and Q are equivalent, do two proofs:
            – First, assume P as a premise, and derive Q.
            – Second, assume Q as a premise, and derive P.
   – Inconsistency:
       • To prove that a set of statements is inconsistent, assume all those
         statements as premises, and derive .
         Talking about Proofs …
• How do we know if a formal proof does what it is
  supposed to do? That is, if I can derive a sentence 
  from a set of sentences {1, …, n}, does that really
  mean that  is a truth-functional consequence of {1,
  …, n}?
• Notice that this is a metalogical questions: it asks
  something about formal proofs in relation to a logical
  property. But of course, we want to settle this
  question through the use of a rigorous proof, i.e. we
  want to prove something about formal proofs!?!
                 Modus Bogus
• In order to demonstrate that the question on the
  previous slide is an interesting and meaningful
  question, consider the following rule:
            PQ
            
                        Obviously, a formal proof system that would
            P          contain this rule would be able to ‘prove’
                       things that just don’t follow!

            Q
                         TF
• Recall:  is a truth-functional consequence of {1,
  …, n} iff according to truth-functional properties it
  is impossible for  to be false if each i is true.
• Let us use the symbol TF to indicate truth-
  functional consequence:  TF  iff  is a truth-
  functional consequence of .
• Remember: If  TF  then   , but not vice
  versa. E.g. LeftOf(a,b)  RightOf(b,a), but not
  LeftOf(a,b) TF RightOf(b,a).
     Truth-functional Provability
• Let us define truth-functional provability with
  regard to some formal deductive logic system
  S (e.g F) as follows: Q is truth-functionally
  provable from a set of premises {P1, …, Pn} in
  the system S iff there exists a formal proof in S
  going from P1, …, Pn as premises and Q as the
  conclusion using the rules for ‘’, ‘’, ‘’,
  ‘’, ‘’, and ‘’ (or any other truth-
  functional connective defined by S).
                     TF(S)
• Let us use the symbol TF(S) to indicate truth-
  functional provability in S:  TF(S)  iff  is
  truth-functionally provable from  in the
  system S.
• The subscript TF(S) indicates that we restrict
  our proofs to the truth-functional rules of S.
   Two Very Important Properties
• For every deductive system of formal logic S
  we can define the following 2 properties:
  – 1. Truth-Functional Deductive Soundness: A
    system S is truth-functionally deductively sound iff
    for any  and :
     • if  TF(S)  then  TF 
  – 2. Truth-Functional Deductive Completeness: A
    system S is truth-functionally deductively
    complete iff for any  and  :
     • if  TF  then  TF(S) 
                 F is Sound
• Q: Is F truth-functionally deductively sound?
• A: Yes!
• If you want the full proof, take ‘Intermediate
  Logic’.
       A Trivially Sound System
• Let S be a logic system that has no inference
  rules. Then, trivially, all inference rules of S
  are sound. Hence S is deductively sound as
  well.
• In other words, it is trivial to make a
  deductively sound logic system: just don’t
  define any inference rules!
        Deductive Completeness
• Q: Why is truth-functional deductive completeness
  important?
• A: If a logic system S is not complete, then for certain
   and ,  TF  but not   TF(S) . So, although
   is a truth-functional consequence of , the rules do
  not allow one to prove  from !
• Q: How is that possible?
• A: Easy. While P TF P, the system S will not
  be able to prove this. Hence, S is not a truth-
  functionally deductively complete system!
 Proving Deductive Completeness
• Proving completeness for some logic system S can be
  very difficult. This is not hard to understand: one
  needs to prove that for every  and  such that  
  , there exists a proof in S going from  to . But,
  there are an infinite number of pairs  and  such
  that   , and the proofs don’t seem to follow any
  kind of systematic pattern.
• Note: If we already know a certain system S’ to be
  complete, we can try to prove S to be complete by
  demonstrating how S can prove anything that S’ is
  able to prove.
              F is Complete
• Q: Is F truth-functionally deductively
  complete?
• A: Yes, but the proof for this is rather
  complicated and outside the scope of this
  class. Again, if you’re interested, take
  ‘Intermediate Logic’.
               An Algorithm for
            Producing Formal Proofs
• Restricting ourselves to , , , and  only:
   – Start a proof by contradiction (assume negation of
     conclusion). Let  be the set of statements you have. Then
     go through the following loop to obtain  (keep adding
     results to ):
      •   If  : stop
      •   If    and   : get  by  Intro
      •   If   : get  by  Elim
      •   If (1  …  n )  : get 1  …  n by DeMorgan pattern
      •   If (1  …  n )  : get 1  …  n by DeMorgan pattern
      •   If 1  …  n  : get 1, … , n by  Elim
      •   If 1  …  n  : set up subproof for each 1 and derive  from
           {1} / {1  …  n} with this same method. Then get  with
           Elim
              Hokus Ponens
• The logic system B (‘Bram’) contains only one
  inference rule, called Hokus Ponens:

          
                  Woohoo!
          P
                  One line proofs!

                  This system is going to make me famous!

                  (Only one small problem …)
Automated Theorem Proving
       Systematic Procedures
• A systematic procedure is a procedure that
  follows a certain step-by-step algorithm to
  perform a certain task.
• Examples are cookbook recipes and computer
  programs.
• A systematic procedure will either stop after a
  finite amount of time, or never stop (e.g.
  because it goes into an infinite loop).
• The truth-table method is a systematic
  procedure.
• The method of formal proof is not a systematic
  procedure (though it can be used to make one).
 Positive Tests, Negative Tests,
          and Full Tests
• A positive test is a systematic procedure that tries to
  figure out whether certain things have a certain property.
• A negative test is a systematic procedure that tries to
  figure out whether certain things do not have a certain
  property.
• A full test is a systematic procedure that tries to figure
  out whether certain things do or do not have a certain
  property.
• The truth table method is a full test. It can answer that
  something is or is not a logical consequence of
  something else.
• The formal proof method, even if it were systematic, is
  not a full test, but only a positive test. It can answer that
  something is a logical consequence of something else,
  but it never concludes that it isn’t a logical consequence.
 Soundness and Completeness for
  Tests and Decision Procedures
• A test (positive, negative, or full) is sound
  iff:
  – if the test claims that something has (not) a
   certain property, then it has (not) that
   property.
• A test (positive, negative, or full) is
  complete iff:
  – If something has (not) a certain property, then
    the test claims that it has (not) that property.
         Decision Procedures
• A full test that is both sound and complete is
  called a decision procedure.
• The truth-table method is a decision procedure
  for truth-functional consequence.
• The Taut Con ‘rule’ (mechanism!) is also a
  decision procedure for truth-functional
  consequence.
• Questions: Is there a decision procedure for TF
  consequence that is more efficient than the
  truth-table method. In fact, how does Taut Con
  work?
Truth-Trees
             Logical Possibility
• All logically interesting claims can be reduced to
  questions about logical possibility:
   – Logical Consistency: Is it possible for all statements
     to be true?
   – Logical Validity: Is it possible for all premises to be
     true and the conclusion false?
   – Logical Consequence: Is it possible for the implying
     statements to be true and the implied statement to be
     false?
   – Logical Equivalence: Is it possible for the two
     statements to have a different truth value?
   – Logical Tautology: Is it possible for the statement to
     be false?
          Truth Table Method
• The truth table method systematically exhausts
  all possible truth value combinations of the
  statements involved.
• In the truth-table we look for a row that reflects a
  certain possibility, and that will tell us the answer
  to whatever question we had (e.g. if there is no
  row where statement is false, then it is not
  possible for that statement to be false, and
  hence it is a tautology).
      Drawback and Room for
            Solution
• A drawback of the truth table method is that the
  number of rows grows exponentially.
• Fortunately, there is room for a solution to this
  problem. Since all we are interested in, is the
  existence of a specific combination of truth
  values of the statements involved, all we need to
  find is one example of such a case. Once we
  have found such a case, there is no need to
  exhaust all other cases.
Simple Solution: Stopping Early
• One solution to the problem of big truth tables is
  therefore to simply stop once you have found a
  row that represents the combination of truth
  values you are interested in.
• Thus, rather than working out a truth table
  column by column, you may want to do it row by
  row, so that you can stop as soon as you have
  found a row of the kind you are looking for.
• A big drawback of this approach is that if no row
  of the kind you are looking for exists, then you
  have to complete the whole truth table after all.
      A More Focused Search
• Consider the following argument:
     P  (Q  R)
     R  Q
     R
• We are interested in whether all premises can be
  true and the conclusion false:
  – In order for the conclusion to be false, R must be false.
  – In order for the second premise to be true while R is
    false, Q must be false.
  – In order for the first premise to be true while Q and R
    are both false, P must be false.
 The Short Truth Table Method
• The Short Truth Table Method assigns truth
  values to the involved atomic and complex
  statements in order to try and obtain a certain
  combination of truth values:

      P  (Q  R)    RQ        /   R
      F T F FF       F TTF            F

 • The Short Truth Table Method thus tries to
   generate one row of the truth table that has
   the combination of truth values you are
   interested in.
 Short Truth Table Method and
         Indirect Proof
• As you assign truth values to certain statements,
  the truth values of other statements can be
  forced.
• If you are forced to make a statement both true
  and false, then you know that the combination of
  truth values you are looking for does not exist:
      P  (Q  P)    Contradiction, so the
      TF TF F       statement is a tautology!
• The short truth table method is therefore a kind
  of indirect proof (proof by contradiction), except
  that you don’t always get a contradiction.
   Drawback of the Short Truth
         Table Method
• A drawback of the short truth table method is
  that you are not always forced to assign any
  further truth values:

    R  (Q  P)   (Q  R)  P   RP      Q
      T T           T       T       T       T
 • At this point, you can choose to assign certain
   truth values, but if your choice does not lead
   to the row you are looking for, then you need
   to try a different option, and the short truth
   table method has no tools to do go through all
   of your options in a systematic way.
                  Truth Trees
• The obvious solution to the drawback of the
  short truth table method is to incorporate tools to
  systematically keep track of multiple options.
• One method that does so is the truth tree
  method:
   – The truth tree method tests for the consistency of a
     set of statements and, as such, can be used to
     determine validity, tautologies, equivalence, etc.
   – Like the short table method, it infers which other
     statements are forced to be true under this
     assumption.
   – When nothing is forced, then the tree branches into
     the possible options.
   Truth Tree Example
      (((PQ)R)  (P(QR))) 

    (PQ)R             ((PQ)R) 
    (P(QR))         P(QR) 
    P                    PQ 
    (QR)             R    All branches close
                                the original
    Q                    P
                               statement cannot be
    R                   Q
                               false  tautology!
(PQ)  R          P      Q  R 
         ×          ×
P Q                      Q     R
 ×  ×                       ×     ×
Decomposition Rules for Truth
           Trees

  P           PQ     (PQ) 
  P              P
                 Q       P   Q

  PQ           PQ     (PQ) 
                          P
 P    Q      P     Q
                          Q

  (PQ)        PQ     (PQ) 

     P      P      P   P      P
     Q      Q      Q   Q     Q
     Truth Trees as Decision
           Procedures
• The truth tree method can easily be made
  into a systematic procedure.
• As such, the truth tree method becomes a
  decision procedure for truth-functional
  consequence that is, on average, quite a
  bit more efficient than the truth-table
  method.
Resolution
          Running Example
• As a running example, let us consider the
  following argument with premises:
  – Horned(a)
  – Horned(a)  Elusive(a)
  – Dangerous(a)  Horned(a)
  – (Elusive(a)  Mythical(a))  Rare(a)
  – Dangerous(a)  (Elusive(a)  Rare(a))
• And conclusion:
  – Rare(a)
              Horn Clauses
• A Horn clause is a disjunction of literals
  with at most one positive literal (i.e. atomic
  statement).
• We can differentiate between 3 types of
  Horn Clauses:
  –Q
  – P1  …  Pn
  – P1  …  Pn  Q
  – (Q and each of Pi is atomic)
 Efficient Check of Consistency
    of a Set of Horn Clauses
• Horn Clauses form an important class of
  statements, since the consistency of a set
  of Horn clauses can be checked in a
  systematic and efficient manner. E.g. the
  short truth table method will always work:
  – 1. Write ‘T’ under all clauses.
  – 2. Make all forced moves until:
     • A. You get a contradiction: The set is inconsistent.
     • B. Nothing is forced anymore: The set is
       consistent.
                    Example
  Putting into Horn Clauses:
    Horned(a)  H
    Horned(a)  Elusive(a)  H  E
    Dangerous(a)  Horned(a)  D  H
    (Elusive(a)  Mythical(a))  Rare(a)  E  M  R
    Dangerous(a)  (Elusive(a)  Rare(a))  D  E  R

  Negating Conclusion: Rare(a)  R
  Short Truth Table:
H   H  E D  H        E  M  R   D  E  R   R
T   F T T T T T FT       FTTTFTF       FTTFTTF       TF
   Horn Clauses in Conditional
             Form
• Horn clauses can be written in conditional
  form:
  –Q
  – (P1  …  Pn)  
  – (P1  …  Pn)  Q
  Algorithm for Horn Clauses in
         Conditional Form
• To check the consistency of a set S of
  Horn Clauses in conditional form:
  – 1. Make a new set of statements T, starting
    with the set of all atomic statements Q.
  – 2. If there is a statement (P1  …  Pn)   in
    S, and each Pi is in T, then you can stop: S is
    inconsistent. Otherwise, go to 3.
  – 3. If there is a statement (P1  …  Pn)  Q in
    S, and each Pi is in T, then add Q to T, and go
    to 2. Otherwise stop: S is consistent.
                  Example
Putting into conditional form Horn:
 H  H
 H  E  H  E
 D  H  H  D
 E  M  R  (E  M)  R
 D  E  R  (D  E)  R
 R  R  

{H}  {H,E}  {H,E,D}  {H,E,D,R}  
                     Prolog
• The programming language Prolog is based on
  Horn clauses.
• A Prolog program consists of 2 types of lines:
  – Facts: These are Horn clauses of type Q. In Prolog:
    P.
  – Rules: These are Horn clauses of the form (P1  … 
    Pn)  Q. In Prolog: P :- P1 , … , Pn.
• A Prolog program is run by asking whether some
  atomic statement Q follows from the facts and
  rules. In Prolog: Q?
• The Prolog program will answer ‘Yes’ or ‘No’.
       The Prolog Algorithm

• Prolog checks whether Q follows from the facts
  or rules as follows:
  – 1. Make a set of goals G, starting with Q.
  – 2. If G is empty, stop with answer ‘Yes’.
  – 3. If a statement P is in G that is a fact, remove P
    from G.
  – 4. If P is in G and there is a rule P :- P1 , … , Pn, then
    remove P from G, and add each Pi to G.
  – 5. If you get stuck, try a different rule P :- P1 , … , Pn.
  – 6. If all options fail, stop with answer ‘No’.
                 Prolog Example
Putting into Prolog:         Query: R?
  H  H                             {R}
  H  E  E :- H.
                              {E, M}      {D, E}
  H  D  D :- H.
  (E  M)  R  R :- E, M.    {H, M}      {H, E}
  (D  E)  R  R :- D, E.
                              {M}         {E}

                                          {H}

                                          {} ‘Yes’!
                Resolution
• While the consistency of a set of Horn Clauses
  can be checked systematically and efficiently,
  not all statements are Horn Clauses, nor can
  they always be transformed into Horn Clauses.
• However, all sentences can be put into
  Conjunctive Normal Form (CNF).
• Horn Clauses are a special case of claims in
  CNF.
• The algorithms for Horn Clauses are a special
  case of the more general method of resolution
  as defined over any set of statements in CNF.
      The Rule of Resolution
• The Rule of Resolution is defined over
  disjunctions of one or more literals:

        P1  …  Pi-1  X  Pi+1  …  Pm

        Q1  …  Qi-1  X  Qi+1  …  Qn

        P1  …  Pi-1  Pi+1  …  Pm 
        Q1  …  Qi-1  Qi+1  …  Qn

       (each of Pi and Qi are literals; X is atomic)
                       Clauses
• A clause is a set of literals.
• Assuming a clause to represent a disjunction of
  all literals that are in that clause, we can resolve
  two clauses as follows:

          {P1 , … , Pi-1 , X , Pi+1 , … , Pm}
          {Q1 , … , Qi-1 , X , Qi+1 , … , Qn}

          {P1 , … , Pi-1 , Pi+1 , … , Pm ,
          Q1 , … , Qi-1 , Qi+1 , … , Qn}

         (each of Pi and Qi are literals; X is atomic)
    The Method of Resolution
• The method of resolution checks whether
  some set of statements S is consistent. It
  does this as follows:
  – 1. Make a set T of clauses representing all
    conjuncts of the CNF of each statement in S.
  – 2. Resolve any two clauses from T that can be
    resolved, and add the result to T.
  – 3. If two clauses resolve to the empty set,
    stop: the original set of statements was
    inconsistent.
              Resolution Example
(Elusive(a)  Dangerous(a))  (Elusive(a)  Rare(a))

(Rare(a)  Dangerous(a))  Horned(a)
Horned(a)  Magical(a)
                                  Negate Conclusion
Magical(a)                        and put into CNF

(E  D)  (E  R)         (E  D)  (E  R)

(R  D)  H      (R  D)  H         (R  D)  H

HM          H  M                     (R  H)  (D  H)
M
     Resolution Example (Cont’d)

 (E  D)  (E  R)        (R  H)  (D  H)     H  M         M

 {E, D}    {E, R}         {R, H}     {D, H}     {H, M}        {M}

           {E, H}      {E, H}                            {H}


                      {H}
From CNF to
clauses and resolve
                                  {}
                                        Inconsistent, so valid!
 Soundness and Completeness
        of Resolution
• The method of Resolution is sound and
  complete with regard to truth-functional
  consistency in the sense that:
  – If the method finds a set of statements to be
    inconsistent, then that set of statements is
    indeed inconsistent (soundness).
  – If a set of statements is inconsistent, then the
    method can find that set of statements to be
    inconsistent by deriving the empty clause
    (completeness).
    Algorithms for Resolution and
                ATP’s
• Algorithms for resolution will differ in the
  order in which clauses get resolved.
• Many ATP’s are based on some such
  algorithm:
  – Snark
  – Otter
  – Taut Con in Fitch

				
DOCUMENT INFO
Shared By:
Categories:
Tags:
Stats:
views:4
posted:12/18/2012
language:English
pages:180