Mathematics for AI Engineers

def classify_number(n):
    """Classify a number into its number system categories"""
    categories = []

    if isinstance(n, int) and n > 0:
        categories.append("Natural (ℕ)")
    if isinstance(n, int) and n >= 0:
        categories.append("Whole (W)")
    if isinstance(n, int):
        categories.append("Integer (ℤ)")

    # Check rational (all ints are rational, and finite decimals)
    try:
        from fractions import Fraction
        Fraction(n)
        categories.append("Rational (ℚ)")
    except (ValueError, TypeError):
        categories.append("Irrational")

    categories.append("Real (ℝ)")
    return categories

# Examples
for num in [5, -3, 0, 0.75]:
    print(f"{num}: {classify_number(num)}")

# Python follows PEMDAS automatically
result1 = 2 + 3 * 4 ** 2     # = 2 + 3 * 16 = 2 + 48 = 50
result2 = (2 + 3) * 4 ** 2   # = 5 * 16 = 80
result3 = 12 / 4 * 3          # = 3 * 3 = 9 (left to right)
result4 = 10 - 3 + 2          # = 7 + 2 = 9 (left to right)

print(f"2 + 3 × 4² = {result1}")       # 50
print(f"(2 + 3) × 4² = {result2}")     # 80
print(f"12 ÷ 4 × 3 = {result3}")       # 9.0
print(f"10 - 3 + 2 = {result4}")       # 9

from fractions import Fraction

# Fraction operations
a = Fraction(3, 4)
b = Fraction(1, 6)

print(f"{a} + {b} = {a + b}")       # 3/4 + 1/6 = 11/12
print(f"{a} × {b} = {a * b}")       # 3/4 × 1/6 = 1/8
print(f"{a} ÷ {b} = {a / b}")       # 3/4 ÷ 1/6 = 9/2

# Conversions
frac = Fraction(3, 8)
decimal_val = float(frac)
percentage = decimal_val * 100

print(f"Fraction: {frac}")           # 3/8
print(f"Decimal:  {decimal_val}")     # 0.375
print(f"Percent:  {percentage}%")     # 37.5%

# Percentage problems
total = 800
discount_pct = 15
discount_amt = total * discount_pct / 100
print(f"{discount_pct}% of {total} = {discount_amt}")  # 120
print(f"Price after discount = {total - discount_amt}") # 680

# Direct proportion: cost ∝ quantity
price_per_kg = 50
quantities = [2, 5, 10]
for q in quantities:
    print(f"{q} kg costs ₹{price_per_kg * q}")

# Inverse proportion: workers × time = constant
# 6 workers take 12 days. How many days for 9 workers?
workers1, days1 = 6, 12
workers2 = 9
days2 = (workers1 * days1) / workers2
print(f"\n{workers1} workers → {days1} days")
print(f"{workers2} workers → {days2:.0f} days")  # 8 days

# Dividing in a ratio
# Divide 120 in the ratio 3:5
total = 120
a, b = 3, 5
part_a = total * a / (a + b)
part_b = total * b / (a + b)
print(f"\n120 in ratio 3:5 → {part_a:.0f} and {part_b:.0f}")  # 45 and 75

import math

# Built-in HCF/GCD
a, b = 36, 48
hcf = math.gcd(a, b)
lcm = (a * b) // hcf  # or math.lcm(a, b) in Python 3.9+

print(f"HCF({a}, {b}) = {hcf}")    # 12
print(f"LCM({a}, {b}) = {lcm}")    # 144
print(f"Verify: {hcf} × {lcm} = {hcf * lcm} = {a} × {b} = {a * b}")

# Prime factorization
def prime_factors(n):
    factors = {}
    d = 2
    while d * d <= n:
        while n % d == 0:
            factors[d] = factors.get(d, 0) + 1
            n //= d
        d += 1
    if n > 1:
        factors[n] = factors.get(n, 0) + 1
    return factors

for num in [36, 48, 60]:
    pf = prime_factors(num)
    factored = " × ".join(f"{p}^{e}" if e > 1 else str(p) for p, e in sorted(pf.items()))
    print(f"{num} = {factored}")

def check_divisibility(n):
    """Check divisibility by 2-11 with rule explanations"""
    results = []
    digits = [int(d) for d in str(abs(n))]

    # Rule for 2
    results.append(("2", n % 2 == 0, f"last digit {digits[-1]} {'is' if digits[-1] % 2 == 0 else 'is not'} even"))
    # Rule for 3
    digit_sum = sum(digits)
    results.append(("3", n % 3 == 0, f"digit sum = {digit_sum}"))
    # Rule for 5
    results.append(("5", n % 5 == 0, f"last digit is {digits[-1]}"))
    # Rule for 9
    results.append(("9", n % 9 == 0, f"digit sum = {digit_sum}"))
    # Rule for 11
    alt_sum = sum(d * (-1)**i for i, d in enumerate(digits))
    results.append(("11", n % 11 == 0, f"alternating sum = {alt_sum}"))

    print(f"Divisibility of {n}:")
    for divisor, is_div, reason in results:
        status = "✓" if is_div else "✗"
        print(f"  By {divisor}: {status} ({reason})")

check_divisibility(132)
print()
check_divisibility(729)

import math

# Area and perimeter calculations
def rectangle(l, w):
    return {"area": l * w, "perimeter": 2 * (l + w)}

def circle(r):
    return {"area": math.pi * r**2, "circumference": 2 * math.pi * r}

def triangle_area(base, height):
    return 0.5 * base * height

# Examples
rect = rectangle(8, 5)
print(f"Rectangle 8×5: Area = {rect['area']}, Perimeter = {rect['perimeter']}")

circ = circle(7)
print(f"Circle r=7: Area = {circ['area']:.2f}, Circumference = {circ['circumference']:.2f}")

print(f"Triangle (base=10, height=6): Area = {triangle_area(10, 6)}")

# Pythagoras theorem
a, b = 3, 4
c = math.sqrt(a**2 + b**2)
print(f"\nPythagoras: {a}² + {b}² = {a**2} + {b**2} = {a**2 + b**2}")
print(f"Hypotenuse = √{a**2 + b**2} = {c}")

# Verify common triplets
triplets = [(3,4,5), (5,12,13), (8,15,17), (7,24,25)]
for a, b, c in triplets:
    valid = a**2 + b**2 == c**2
    print(f"({a},{b},{c}): {a}²+{b}²={a**2+b**2}, {c}²={c**2} → {'✓' if valid else '✗'}")

# Solving linear inequality: 3x - 7 < 8
# Step 1: Add 7 to both sides
# 3x < 15
# Step 2: Divide by 3
# x < 5

def solve_linear_inequality(a, b, c, inequality_type='<'):
    """
    Solve ax + b < c (or >, <=, >=)
    Returns solution boundary and direction
    """
    boundary = (c - b) / a
    
    if a > 0:
        direction = '<' if inequality_type in ['<', '<='] else '>'
    else:
        direction = '>' if inequality_type in ['<', '<='] else '<'
    
    return f"x {direction} {boundary}"

print(f"3x - 7 < 8 → {solve_linear_inequality(3, -7, 8, '<')}")  # x < 5.0
print(f"-2x + 4 ≥ 10 → {solve_linear_inequality(-2, 4, 10, '>=')}")  # x <= -3.0

def interval_to_set(interval_str):
    """Parse interval notation (simplified)"""
    examples = {
        "(2, 5)": "2 < x < 5",
        "[2, 5]": "2 ≤ x ≤ 5",
        "(2, 5]": "2 < x ≤ 5",
        "[2, 5)": "2 ≤ x < 5",
        "(-∞, 3)": "x < 3",
        "[3, ∞)": "x ≥ 3",
        "(-∞, -2) ∪ (3, ∞)": "x < -2 or x > 3"
    }
    return examples.get(interval_str, "Unknown format")

for interval in ["(2, 5)", "[-1, 4)", "(-∞, 0)"]:
    print(f"{interval} means: {interval_to_set(interval)}")

import numpy as np

def solve_quadratic_inequality(a, b, c, inequality_type='>'):
    """
    Solve ax² + bx + c > 0 (or <, >=, <=)
    Returns intervals where inequality holds
    """
    # Find roots using quadratic formula
    discriminant = b**2 - 4*a*c
    
    if discriminant < 0:
        # No real roots - parabola doesn't cross x-axis
        if a > 0:
            return "All real numbers" if inequality_type in ['>', '>='] else "No solution"
        else:
            return "No solution" if inequality_type in ['>', '>='] else "All real numbers"
    
    sqrt_d = np.sqrt(discriminant)
    x1 = (-b - sqrt_d) / (2*a)
    x2 = (-b + sqrt_d) / (2*a)
    
    critical_points = sorted([x1, x2])
    return f"Critical points: x = {critical_points[0]}, {critical_points[1]}"

# Example: x² - 5x + 6 > 0
# Factors: (x - 2)(x - 3) > 0
print(f"x² - 5x + 6 > 0")
print(solve_quadratic_inequality(1, -5, 6, '>'))
print("Solution: x < 2 or x > 3, i.e., (-∞, 2) ∪ (3, ∞)")

# Example: x² - 4x + 4 ≤ 0
# Factors: (x - 2)² ≤ 0
print(f"\nx² - 4x + 4 ≤ 0")
print("Solution: x = 2 only (single point)")

def analyze_rational_inequality():
    """
    Solve: (x - 1)(x + 2) / ((x - 3)(x + 1)) > 0
    
    Critical points:
    - Numerator zeros: x = 1, x = -2 (open circles since >)
    - Denominator zeros: x = 3, x = -1 (always open - undefined)
    
    Sign chart (right to left):
    Interval          | Sign | Satisfies > 0?
    x > 3             |  +   | ✓
    1 < x < 3         |  -   | ✗
    -1 < x < 1        |  +   | ✓
    -2 < x < -1       |  -   | ✗
    x < -2            |  +   | ✓
    """
    
    print("Solve: (x - 1)(x + 2) / ((x - 3)(x + 1)) > 0")
    print()
    print("Critical Points:")
    print("  Numerator zeros: x = -2, 1 (open circles)")
    print("  Denominator zeros: x = -1, 3 (undefined)")
    print()
    print("Sign Chart (right to left):")
    print("  x > 3:           +  ✓")
    print("  1 < x < 3:       -  ✗")
    print("  -1 < x < 1:      +  ✓")
    print("  -2 < x < -1:     -  ✗")
    print("  x < -2:          +  ✓")
    print()
    print("Solution: (-∞, -2) ∪ (-1, 1) ∪ (3, ∞)")

analyze_rational_inequality()

import numpy as np

def solve_abs_inequality(a, inequality_type='<'):
    """
    Solve |x| < a or |x| > a
    """
    if a <= 0:
        if inequality_type in ['<', '<=']:
            return "No solution" if a < 0 else "x = 0"
        else:
            return "All real numbers except 0" if a == 0 else "All real numbers"
    
    if inequality_type == '<':
        return f"-{a} < x < {a}, i.e., (-{a}, {a})"
    elif inequality_type == '<=':
        return f"-{a} ≤ x ≤ {a}, i.e., [-{a}, {a}]"
    elif inequality_type == '>':
        return f"x < -{a} or x > {a}, i.e., (-∞, -{a}) ∪ ({a}, ∞)"
    else:  # >=
        return f"x ≤ -{a} or x ≥ {a}, i.e., (-∞, -{a}] ∪ [{a}, ∞)"

print(f"|x| < 5 → {solve_abs_inequality(5, '<')}")
print(f"|x| ≥ 3 → {solve_abs_inequality(3, '>=')}")

# More complex: |x - 3| < 7
print(f"\n|x - 3| < 7")
print("Rewrite: -7 < x - 3 < 7")
print("Add 3: -4 < x < 10")
print("Solution: (-4, 10)")

def find_integral_solutions(inequality_solution, interval_type='open'):
    """
    Find integer solutions in a given interval
    """
    # Example: Find integers in (-2, 5]
    if interval_type == '(-2, 5]':
        integers = [-1, 0, 1, 2, 3, 4, 5]
    elif interval_type == '[-3, 4)':
        integers = [-3, -2, -1, 0, 1, 2, 3]
    elif interval_type == '(-∞, 3)':
        integers = "All integers < 3"
    else:
        integers = []
    
    return integers

print(f"Integers in (-2, 5]: {find_integral_solutions('ineq', '(-2, 5]')}")
print(f"Count: {len(find_integral_solutions('ineq', '(-2, 5]'))}")
print(f"Sum: {sum(find_integral_solutions('ineq', '(-2, 5]'))}")

# Example: Largest integer in (-∞, 7)
print(f"\nLargest integer in (-∞, 7): 6")
print(f"Smallest integer in (2, ∞): 3")

def paper_fold_thickness(num_folds: int, base_thickness_mm: float = 0.1) -> float:
    # Calculates thickness in meters after n folds
    thickness_meters = (base_thickness_mm / 1000.0) * (2 ** num_folds)
    return thickness_meters

for folds in [10, 20, 30, 42, 51]:
    m = paper_fold_thickness(folds)
    km = m / 1000.0
    print(f"Folds: {folds:2d} | Layers: 2^{folds:<2d} | Thickness: {km:,.2f} km")

Standard 52-card deck:
52! ≈ 80,658,175,170,943,878,571,660,636,856,403,766,975,289,505,440,883,277,824,000,000,000,000
Every time you thoroughly shuffle a deck of cards, it is virtually 100% certain
that exact sequence of 52 cards has NEVER existed in human history.

def calculate_search_space(charset_size: int, length: int) -> int:
    return charset_size ** length

lower_only = calculate_search_space(26, 8)      # 26^8
alphanumeric = calculate_search_space(62, 8)    # 62^8
full_ascii = calculate_search_space(94, 8)      # 94^8

print(f"Lowercase (26^8):    {lower_only:,}")
print(f"Alphanumeric (62^8): {alphanumeric:,}")
print(f"Full ASCII (94^8):   {full_ascii:,}")

import math

def catalan_number(n: int) -> int:
    # Computes the n-th Catalan number C_n = (2n)! / ((n+1)! * n!)
    return math.comb(2 * n, n) // (n + 1)

print("First 10 Catalan Numbers:")
for i in range(10):
    print(f"C_{i} = {catalan_number(i)}")

import math
from itertools import permutations, combinations

# 1. Rule of Sum & Product Demo
departments = {"Engineering": 120, "Science": 85, "Arts": 60}
print("Total single reps (Rule of Sum):", sum(departments.values()))
print("Total committee pairs (Eng x Sci):", 120 * 85)

# 2. Permutations vs Combinations
items = ['A', 'B', 'C', 'D']
r = 2
perms = list(permutations(items, r))
combs = list(combinations(items, r))

print(f"
P({len(items)}, {r}) = {len(perms)} arrangements:")
print(perms)

print(f"
C({len(items)}, {r}) = {len(combs)} selections:")
print(combs)

# 3. Pigeonhole Principle Function
def min_pigeons_per_hole(total_items: int, total_holes: int) -> int:
    # Returns the guaranteed minimum items in the fullest container.
    return math.ceil(total_items / total_holes)

print(f"
100 students distributed into 12 grades guarantees at least: {min_pigeons_per_hole(100, 12)} students in one grade.")