-- 并集
SELECT name FROM table1 UNION SELECT name FROM table2;

-- 交集
SELECT name FROM table1 INTERSECT SELECT name FROM table2;

-- 差集
SELECT name FROM table1 EXCEPT SELECT name FROM table2;

# 错误：未处理 x = 0 的情况
def reciprocal(x):
    return 1 / x

# 正确：处理边界情况
def safe_reciprocal(x):
    if x == 0:
        raise ValueError("Cannot compute reciprocal of zero")
    return 1 / x

"""
集合运算的实现与演示
使用Python内置set类型，但展示底层原理
"""

class SetOperations:
    """集合运算工具类"""
    
    @staticmethod
    def union(set_a, set_b):
        """并集：A ∪ B"""
        result = set(set_a)  # 复制A
        result.update(set_b)  # 添加B的元素
        return result
    
    @staticmethod
    def intersection(set_a, set_b):
        """交集：A ∩ B"""
        result = set()
        for elem in set_a:
            if elem in set_b:
                result.add(elem)
        return result
    
    @staticmethod
    def difference(set_a, set_b):
        """差集：A - B"""
        result = set()
        for elem in set_a:
            if elem not in set_b:
                result.add(elem)
        return result
    
    @staticmethod
    def symmetric_difference(set_a, set_b):
        """对称差：A ⊕ B"""
        return SetOperations.difference(
            SetOperations.union(set_a, set_b),
            SetOperations.intersection(set_a, set_b)
        )
    
    @staticmethod
    def is_subset(subset, superset):
        """判断是否为子集：subset ⊆ superset"""
        for elem in subset:
            if elem not in superset:
                return False
        return True
    
    @staticmethod
    def power_set(original_set):
        """幂集：P(A)，返回所有子集的列表"""
        elements = list(original_set)
        n = len(elements)
        result = []
        
        # 使用位掩码枚举所有子集
        for mask in range(2 ** n):
            subset = set()
            for i in range(n):
                if mask & (1 << i):
                    subset.add(elements[i])
            result.append(subset)
        
        return result
    
    @staticmethod
    def cartesian_product(set_a, set_b):
        """笛卡尔积：A × B"""
        result = set()
        for a in set_a:
            for b in set_b:
                result.add((a, b))
        return result


def demonstrate_set_operations():
    """演示集合运算"""
    A = {1, 2, 3, 4, 5}
    B = {4, 5, 6, 7, 8}
    
    print(f"A = {A}")
    print(f"B = {B}")
    print(f"A ∪ B = {SetOperations.union(A, B)}")
    print(f"A ∩ B = {SetOperations.intersection(A, B)}")
    print(f"A - B = {SetOperations.difference(A, B)}")
    print(f"B - A = {SetOperations.difference(B, A)}")
    print(f"A ⊕ B = {SetOperations.symmetric_difference(A, B)}")
    print(f"A ⊆ B? {SetOperations.is_subset(A, B)}")
    print(f"{{1, 2}} ⊆ A? {SetOperations.is_subset({1, 2}, A)}")
    
    print("\n幂集 P({{1, 2, 3}}):")
    for subset in SetOperations.power_set({1, 2, 3}):
        print(f"  {subset}")
    
    print(f"\n笛卡尔积 {{1, 2}} × {{'a', 'b'}}:")
    for pair in SetOperations.cartesian_product({1, 2}, {'a', 'b'}):
        print(f"  {pair}")


if __name__ == "__main__":
    demonstrate_set_operations()

"""
检查函数的单射性、满射性和双射性
"""

def is_injective(func, domain, codomain):
    """
    检查函数是否为单射
    
    参数:
        func: 函数，接受domain中的元素，返回codomain中的元素
        domain: 定义域（可迭代对象）
        codomain: 陪域（可迭代对象）
    
    返回:
        bool: 是否为单射
    """
    images = []
    for x in domain:
        fx = func(x)
        if fx in images:
            return False  # 找到两个不同元素映射到同一值
        images.append(fx)
    return True


def is_surjective(func, domain, codomain):
    """
    检查函数是否为满射
    
    参数:
        func: 函数
        domain: 定义域
        codomain: 陪域
    
    返回:
        bool: 是否为满射
    """
    codomain_set = set(codomain)
    image_set = set(func(x) for x in domain)
    return codomain_set.issubset(image_set)


def is_bijective(func, domain, codomain):
    """检查函数是否为双射"""
    return is_injective(func, domain, codomain) and \
           is_surjective(func, domain, codomain)


def find_inverse(func, domain, codomain):
    """
    寻找双射函数的逆函数
    
    返回:
        dict: 逆映射，或None如果函数不是双射
    """
    if not is_bijective(func, domain, codomain):
        return None
    
    inverse = {}
    for x in domain:
        inverse[func(x)] = x
    return inverse


def demonstrate_function_properties():
    """演示函数性质检查"""
    
    # 示例1: f(x) = 2x, 从 {1,2,3} 到 {2,4,6,8}
    domain1 = [1, 2, 3]
    codomain1 = [2, 4, 6, 8]
    func1 = lambda x: 2 * x
    
    print("函数 f(x) = 2x, 定义域={1,2,3}, 陪域={2,4,6,8}")
    print(f"  单射: {is_injective(func1, domain1, codomain1)}")
    print(f"  满射: {is_surjective(func1, domain1, codomain1)}")
    print(f"  双射: {is_bijective(func1, domain1, codomain1)}")
    
    # 示例2: f(x) = x^2, 从 {-2,-1,0,1,2} 到 {0,1,2,3,4}
    domain2 = [-2, -1, 0, 1, 2]
    codomain2 = [0, 1, 2, 3, 4]
    func2 = lambda x: x ** 2
    
    print("\n函数 f(x) = x², 定义域={-2,-1,0,1,2}, 陪域={0,1,2,3,4}")
    print(f"  单射: {is_injective(func2, domain2, codomain2)}")
    print(f"  满射: {is_surjective(func2, domain2, codomain2)}")
    print(f"  双射: {is_bijective(func2, domain2, codomain2)}")
    
    # 示例3: f(x) = x + 1, 从 {0,1,2} 到 {1,2,3}
    domain3 = [0, 1, 2]
    codomain3 = [1, 2, 3]
    func3 = lambda x: x + 1
    
    print("\n函数 f(x) = x+1, 定义域={0,1,2}, 陪域={1,2,3}")
    print(f"  单射: {is_injective(func3, domain3, codomain3)}")
    print(f"  满射: {is_surjective(func3, domain3, codomain3)}")
    print(f"  双射: {is_bijective(func3, domain3, codomain3)}")
    
    inverse = find_inverse(func3, domain3, codomain3)
    if inverse:
        print(f"  逆函数: {inverse}")


if __name__ == "__main__":
    demonstrate_function_properties()

"""
序列求和与收敛性分析
"""

import math


def arithmetic_sum(a, d, n):
    """
    算术序列求和
    
    参数:
        a: 首项
        d: 公差
        n: 项数
    
    返回:
        float: 前n项和
    """
    return n * (2 * a + (n - 1) * d) / 2


def geometric_sum(a, r, n):
    """
    几何序列求和
    
    参数:
        a: 首项
        r: 公比
        n: 项数
    
    返回:
        float: 前n项和
    """
    if r == 1:
        return a * n
    return a * (1 - r ** n) / (1 - r)


def infinite_geometric_sum(a, r):
    """
    无穷几何级数求和（仅当|r| < 1时收敛）
    
    参数:
        a: 首项
        r: 公比
    
    返回:
        float or None: 和，如果不收敛则返回None
    """
    if abs(r) >= 1:
        return None
    return a / (1 - r)


def harmonic_sum(n):
    """
    调和序列求和
    
    参数:
        n: 项数
    
    返回:
        float: 前n项和
    """
    return sum(1.0 / i for i in range(1, n + 1))


def fibonacci_sequence(n):
    """
    生成斐波那契序列的前n项
    
    参数:
        n: 项数
    
    返回:
        list: 斐波那契数列
    """
    if n <= 0:
        return []
    if n == 1:
        return [0]
    
    fib = [0, 1]
    for i in range(2, n):
        fib.append(fib[-1] + fib[-2])
    return fib


def demonstrate_sequences():
    """演示序列求和"""
    
    # 算术序列: 2, 5, 8, 11, ...
    print("算术序列: 2, 5, 8, 11, ...")
    print(f"  前10项和: {arithmetic_sum(2, 3, 10)}")
    print(f"  验证: {sum(2 + 3*i for i in range(10))}")
    
    # 几何序列: 3, 6, 12, 24, ...
    print("\n几何序列: 3, 6, 12, 24, ...")
    print(f"  前10项和: {geometric_sum(3, 2, 10)}")
    print(f"  验证: {sum(3 * 2**i for i in range(10))}")
    
    # 无穷几何级数: 1 + 1/2 + 1/4 + 1/8 + ...
    print("\n无穷几何级数: 1 + 1/2 + 1/4 + 1/8 + ...")
    print(f"  理论和: {infinite_geometric_sum(1, 0.5)}")
    print(f"  前20项和: {geometric_sum(1, 0.5, 20)}")
    
    # 调和序列
    print("\n调和序列: 1 + 1/2 + 1/3 + 1/4 + ...")
    for n in [10, 100, 1000, 10000]:
        print(f"  前{n}项和: {harmonic_sum(n):.6f}")
    print("  注意: 调和级数发散（趋向无穷）")
    
    # 斐波那契序列
    print("\n斐波那契序列:")
    fib = fibonacci_sequence(15)
    print(f"  前15项: {fib}")
    print(f"  前15项和: {sum(fib)}")
    
    # 黄金比例与斐波那契
    print("\n斐波那契比值趋近黄金比例:")
    for i in range(2, 15):
        ratio = fib[i] / fib[i-1] if fib[i-1] != 0 else float('inf')
        print(f"  F({i})/F({i-1}) = {fib[i]}/{fib[i-1]} ≈ {ratio:.6f}")
    print(f"  黄金比例 φ = {(1 + math.sqrt(5)) / 2:.6f}")


if __name__ == "__main__":
    demonstrate_sequences()