Matematikte, bir kümenin alt kümeleri (subsets), o kümenin içerdiği elemanların herhangi bir kombinasyonunu içerir. Bir küme A, başka bir küme B'nin alt kümesi ise, A'nın tüm elemanları B içinde de bulunur. Bu durumda, A⊆B olarak ifade edilir.

Örnek olarak, A={1,2} kümesinin alt kümeleri şunlardır:

Boş küme: ∅

{1}

{2}

{1,2}

Her kümenin kendisi ve boş küme dahil olmak üzere en az iki alt kümesi vardır.

Özellikler:

Yansıma Özelliği: Her küme kendi alt kümesidir, yani A⊆A.

Anti-Simetri Özelliği: Eğer A⊆B ve B⊆A, o zaman A=B.

Transitiflik Özelliği: Eğer A⊆B ve B⊆C, o zaman A⊆C.

Güç Kümesi:

Bir kümenin güç kümesi, o kümenin tüm alt kümelerinden oluşan bir kümedir. Eğer A'nın n elemanı varsa, güç kümesi 2^n eleman içerir. Güç kümesi, P(A) veya 2^A ile gösterilir.

Örnek (Python):

Bir kümenin alt kümelerini bulmak için Python'da aşağıdaki kodu kullanabilirsiniz:

from itertools import chain, combinations

A = {1, 2, 3}
subsets = list(chain.from_iterable(combinations(A, r) for r in range(len(A)+1)))
print(subsets)  # [(), (1,), (2,), (3,), (1, 2), (1, 3), (2, 3), (1, 2, 3)]

Karmaşık problemleri daha yönetilebilir parçalara bölmek gibi geniş bir uygulama yelpazesi sunar.

Python'da kümelerle kullanılabilecek başlıca operatörler şunlardır:

Birleşim (Union) - (|) Operatörü: İki kümenin birleşimini alır.

Kesişim (Intersection) - (&) Operatörü: İki kümenin kesişimini alır.

Fark (Difference) - (-) Operatörü: İlk kümeden ikinci kümenin elemanlarını çıkarır.

Simetrik Fark (Symmetric Difference) -( ^ ) Operatörü: İki kümenin simetrik farkını alır. Yani kesişimlerinin dışındakı elemanları

Alt Küme (Subset) -( <= ) Operatörü: Bir kümenin diğer bir kümenin alt kümesi olup olmadığını kontrol eder.

Gerçek Alt Küme (Proper Subset) - ( < ) Operatörü: Bir kümenin diğer bir kümenin gerçek alt kümesi olup olmadığını kontrol eder.

Üst Küme (Superset) -( >= ) Operatörü: Bir kümenin diğer bir kümenin üst kümesi olup olmadığını kontrol eder.

Gerçek Üst Küme (Proper Superset) -( > )Operatörü: Bir kümenin diğer bir kümenin gerçek üst kümesi olup olmadığını kontrol eder.

A = {1, 2, 3}
B = {3, 4, 5}

print("A | B:", A | B)  # Birleşim
print("A & B:", A & B)  # Kesişim
print("A - B:", A - B)  # Fark
print("A ^ B:", A ^ B)  # Simetrik Fark
print("A <= B:", A <= B) # Alt Küme
print("A < B:", A < B)   # Gerçek Alt Küme
print("A >= B:", A >= B) # Üst Küme
print("A > B:", A > B)   # Gerçek Üst Küme

A | B: {1, 2, 3, 4, 5}
A & B: {3}
A - B: {1, 2}
A ^ B: {1, 2, 4, 5}
A <= B: False
A < B: False
A >= B: False
A > B: False

Diziler Üzerinde Küme İşlemleri Gerçekleştirme:

NumPy kütüphanesi kümelerle doğrudan çalışmadığı için, bu işlemleri yaparken kümeler yerine dizilerle çalışmak gerekiyor. İşte NumPy ile gerçekleştirilebilecek bazı küme işlemleri:

import numpy as np

A = np.array([1, 2, 3])
B = np.array([3, 4, 5])

# Birleşim (Union)
union = np.union1d(A, B)
print("Birleşim (A | B):", union)

# Kesişim (Intersection)
intersection = np.intersect1d(A, B)
print("Kesişim (A & B):", intersection)

# Fark (Difference)
difference_A_B = np.setdiff1d(A, B)
print("Fark (A - B):", difference_A_B)

difference_B_A = np.setdiff1d(B, A)
print("Fark (B - A):", difference_B_A)

# Simetrik Fark (Symmetric Difference)
symmetric_difference = np.setxor1d(A, B)
print("Simetrik Fark (A ^ B):", symmetric_difference)

# Alt Küme (Subset)
is_subset = np.all(np.isin(A, B))
print("A, B'nin alt kümesi mi?", is_subset)

# Üst Küme (Superset)
is_superset = np.all(np.isin(B, A))
print("A, B'nin üst kümesi mi?", is_superset)

Çıktı:

Birleşim (A | B): [1 2 3 4 5]
Kesişim (A & B): [3]
Fark (A - B): [1 2]
Fark (B - A): [4 5]
Simetrik Fark (A ^ B): [1 2 4 5]
A, B'nin alt kümesi mi? False
A, B'nin üst kümesi mi? False

Üç ve Daha Fazla Küme İşlemleri:

A = {1, 2, 3}
B = {3, 4, 5}
C = {5, 6}

# Birleşim (Union)
union = A.union(B, C)
print("Birleşim (A | B | C):", union)

# Kesişim (Intersection)
intersection = A.intersection(B, C)
print("Kesişim (A & B & C):", intersection)

# Fark (Difference)
difference = A.difference(B, C)
print("Fark (A - B - C):", difference)

# Simetrik Fark (Symmetric Difference)
symmetric_difference_AB = A.symmetric_difference(B)
symmetric_difference = symmetric_difference_AB.symmetric_difference(C)
print("Simetrik Fark ((A ^ B) ^ C):", symmetric_difference)

# Kartezyen Çarpım (Cartesian Product)
from itertools import product
cartesian_product = set(product(A, B, C))
print("Kartezyen Çarpım (A x B x C):", cartesian_product)