Chapter 14 — Conditional Statements and Logic

# --- Visualization: Four forms of a conditional ---
import matplotlib.pyplot as plt
import matplotlib.patches as patches
import numpy as np
plt.style.use('seaborn-v0_8-whitegrid')

fig, axes = plt.subplots(2, 2, figsize=(12, 8))

forms = [
    ('Original: P → Q', 'P', 'Q', '→', True, True),
    ('Converse: Q → P', 'Q', 'P', '→', True, False),
    ('Inverse: ¬P → ¬Q', '¬P', '¬Q', '→', True, False),
    ('Contrapositive: ¬Q → ¬P', '¬Q', '¬P', '→', True, True),
]

from itertools import product as iproduct

for ax, (title, ant, con, op, _, equiv) in zip(axes.flat, forms):
    ax.set_xlim(0, 4); ax.set_ylim(0, 3)
    ax.axis('off')
    ax.set_title(title, fontsize=11, color='darkgreen' if equiv else 'darkred',
                  fontweight='bold')
    
    # Draw the conditional as arrow
    color = '#2ecc71' if equiv else '#e74c3c'
    ax.add_patch(patches.FancyArrow(0.8, 1.5, 1.8, 0, width=0.15,
                                     head_width=0.3, head_length=0.2,
                                     facecolor=color, edgecolor='black'))
    ax.text(0.3, 1.5, ant, ha='center', va='center', fontsize=14, fontweight='bold',
             bbox=dict(boxstyle='round', facecolor='lightyellow', edgecolor='gray'))
    ax.text(3.3, 1.5, con, ha='center', va='center', fontsize=14, fontweight='bold',
             bbox=dict(boxstyle='round', facecolor='lightyellow', edgecolor='gray'))
    
    equiv_text = '✓ Equivalent to original' if equiv else '✗ NOT equivalent to original'
    ax.text(2.0, 0.4, equiv_text, ha='center', va='center', fontsize=9,
             color='darkgreen' if equiv else 'darkred')

plt.suptitle('Four Forms of a Conditional: Only Contrapositive is Equivalent', fontsize=12)
plt.tight_layout()
plt.show()

# --- Implementation: Conditional analyzer ---
from itertools import product

def analyze_conditional(P_fn, Q_fn, var_names=['A', 'B']):
    """
    Given Boolean functions P and Q over the same variables,
    analyze the relationship between P and Q.
    """
    n = len(var_names)
    assignments = list(product([False, True], repeat=n))
    
    p_implies_q = all((not P_fn(*a) or Q_fn(*a)) for a in assignments)
    q_implies_p = all((not Q_fn(*a) or P_fn(*a)) for a in assignments)
    
    result = {
        'P → Q (P sufficient for Q)': p_implies_q,
        'Q → P (P necessary for Q)': q_implies_p,
        'P ↔ Q (equivalent)': p_implies_q and q_implies_p,
    }
    
    # Find counterexamples if not holding
    if not p_implies_q:
        ce = next(a for a in assignments if P_fn(*a) and not Q_fn(*a))
        result['Counterexample (P true, Q false)'] = dict(zip(var_names, ce))
    if not q_implies_p:
        ce = next(a for a in assignments if Q_fn(*a) and not P_fn(*a))
        result['Counterexample (Q true, P false)'] = dict(zip(var_names, ce))
    
    return result

# Example 1: P = 'divisible by 4', Q = 'divisible by 2'
# P ⊂ Q: every multiple of 4 is a multiple of 2, but not vice versa
print('Example: divisible by 4 vs divisible by 2 (over integers 1-30)')
P = lambda n: n % 4 == 0
Q = lambda n: n % 2 == 0
domain = range(1, 31)
p_imp_q = all(not P(n) or Q(n) for n in domain)
q_imp_p = all(not Q(n) or P(n) for n in domain)
print(f'  P→Q (mult of 4 → mult of 2): {p_imp_q}  (4 is sufficient for 2)')
print(f'  Q→P (mult of 2 → mult of 4): {q_imp_p}  (2 is NOT sufficient for 4)')
print(f'  Counterexample: n=2 is divisible by 2 but not 4')
print()

# Example 2: Two Boolean conditions
print('Example 2: P = (A and B), Q = (A or B)')
result = analyze_conditional(
    P_fn=lambda A,B: A and B,
    Q_fn=lambda A,B: A or B,
)
for k, v in result.items():
    print(f'  {k}: {v}')

# --- Experiment: Common logical errors in code ---
# Hypothesis: Conditional logic errors (converse/inverse confusion) are common
# in real conditions. Demonstrate with typical programming scenarios.

def test_condition_logic():
    # Bug pattern: asserting converse when original was intended
    
    # WRONG: if sorted, then valid (converse of 'if valid, then sorted')
    def is_sorted(lst):
        return all(lst[i] <= lst[i+1] for i in range(len(lst)-1))
    
    def is_valid_data(lst):
        """A list is 'valid' if it has no negative numbers and is sorted."""        
        return all(x >= 0 for x in lst) and is_sorted(lst)
    
    test_cases = [
        [1, 2, 3, 4],      # valid AND sorted
        [1, 3, 2, 4],      # valid but NOT sorted
        [-1, 0, 1, 2],     # sorted but NOT valid (negative)
        [3, 1, 4, 1, 5],   # neither
    ]
    
    print('Condition analysis for list validation:')
    print(f'{"List":<25} {"valid":>7} {"sorted":>8} {"valid→sorted":>14} {"sorted→valid":>14}')
    print('-'*72)
    for lst in test_cases:
        v = is_valid_data(lst)
        s = is_sorted(lst)
        v_imp_s = not v or s
        s_imp_v = not s or v
        print(f'{str(lst):<25} {str(v):>7} {str(s):>8} {str(v_imp_s):>14} {str(s_imp_v):>14}')
    
    print()
    print('Conclusion: valid→sorted always holds (valid implies sorted by definition)')
    print('But sorted→valid does NOT (a sorted list can have negatives)')

test_condition_logic()

# --- Mini Project: Theorem structure analyzer ---
# Many mathematical theorems are conditionals: IF [conditions] THEN [conclusion].
# Build a tool that decomposes theorem statements and checks their logical structure.

class TheoremAnalyzer:
    """
    Analyzes the logical structure of theorem-like statements.
    Stores hypotheses and conclusion, checks consistency.
    """
    def __init__(self, name):
        self.name = name
        self.hypotheses = []
        self.conclusion = None
    
    def add_hypothesis(self, desc, pred):
        self.hypotheses.append((desc, pred))
        return self
    
    def set_conclusion(self, desc, pred):
        self.conclusion = (desc, pred)
        return self
    
    def verify(self, domain, verbose=True):
        """Check if theorem holds on given domain."""        
        if self.conclusion is None:
            raise ValueError('No conclusion set')
        
        conc_desc, conc_pred = self.conclusion
        
        counterexamples = []
        for x in domain:
            hyps_hold = all(pred(x) for _, pred in self.hypotheses)
            if hyps_hold and not conc_pred(x):
                counterexamples.append(x)
        
        if verbose:
            print(f'Theorem: {self.name}')
            print(f'  Hypotheses: {[h for h,_ in self.hypotheses]}')
            print(f'  Conclusion: {conc_desc}')
            if counterexamples:
                print(f'  FAILS: counterexamples = {counterexamples[:5]}')
            else:
                print(f'  HOLDS on all {len(list(domain))} domain elements')
        return len(counterexamples) == 0

# Example: Theorem about even squares
t = TheoremAnalyzer('Square of even integer is divisible by 4')
t.add_hypothesis('n is even', lambda n: n % 2 == 0)
t.set_conclusion('n² is divisible by 4', lambda n: (n*n) % 4 == 0)
t.verify(range(-50, 51))
print()

# Example: A false theorem
t2 = TheoremAnalyzer('Square of odd integer is odd (true) then also prime?')
t2.add_hypothesis('n is odd', lambda n: n % 2 == 1)
t2.set_conclusion('n² is prime', lambda n: all(n*n % i != 0 for i in range(2, n*n)) and n*n > 1)
t2.verify(range(1, 30))