---
# System prepended metadata

title: 1. Himpunan

---

Sumber utama: https://ggc-discrete-math.github.io/functions.html#_injective_surjective_bijective_and_inverse_functions

# 1. Himpunan

## 1.1 Mendefinisikan Himpunan
Untuk mendefinisikan himpunan dalam Python, kita menuliskan elemen-elemen himpunan dalam tanda kurung kurawal dan memisahkan setiap elemen dengan tanda koma. Sebagai contoh, untuk menuliskan himpunan:
$$ A = \{1, 2, 3, 4, 5\} $$
pada kode Python, kita menuliskan:

```python
A = {1, 2, 3, 4, 5}
```

atau

```python
A = set([1, 2, 3, 4, 5])
```

Untuk mengetahui keanggotaan suatu himpunan kita dapat membentuk sebuah ekspresi menggunakan operator `in`. Sebagai contoh, misalkan kita ingin mengetahui apakah 8 adalah anggota himpunan $A$, atau $8 \in A$ kita menuliskan:

```
8 in A
```

Ekspresi di atas akan menghasilkan nilai Boolean `False`, karena 8 bukanlah elemen dari himpunan $A$.

#### Contoh 1. Mengetahui Keanggotaan Himpunan Menggunakan Python
Kode Python berikut memeriksa apakah 5 dan 0 adalah elemen dari himpunan $A = \{-2, 0, 1, 4\}$. 

```python
A = {-2, 0, 1, 4}
print(5 in A)
print(0 in A)
```

Karena $5 \notin A$ dan $0 \in A$, maka kode di atas akan memberikan output:

```
False
True
```

#### Contoh 2. Menampilkan Semua Elemen-elemen dalam Sebuah Himpunan

Kode berikut menampilkan semua elemen-elemen dalam himpunan $A = \{-2, 0, 1, 4\}$.

```python
A = {-2, 0, 1, 4}
for x in A:
    print(x, "adalah elemen dari himpunan.")
```

Output dari kode di atas:

```
0 adalah elemen dari himpunan.
1 adalah elemen dari himpunan.
4 adalah elemen dari himpunan.
-2 adalah elemen dari himpunan.
```

#### Contoh 3. Menuliskan Notasi Set Builder dalam Python
Kode berikut mendefinisikan himpunan $B = \{x^2 \ | \ x \in \{1, 2, 3, 4, 5\}\}$ menggunakan set builder dan menampilkan semua elemen dari himpunan tersebut.

```python
B = {x**2 for x in {1, 2, 3, 4, 5}}
for y in B:
    print(y, "adalah elemen dari himpunan.")
```

## 1.2 Operasi pada Himpunan

#### Contoh 1. Union
Kita dapat menuliskan operasi union dalam Python dengan dua cara. Misalkan, operasi $A \cup B$, dapat dituliskan dengan dua cara berikut:

```python
A.union(B)
```

atau

```python
A | B
```

Kode berikut mencontohkan operasi union pada himpunan $A$ dan $B$:

```python
A = {-3, -1, 2, 5}
B = {-1, 0, 2}

print(A.union(B))
print(A | B)
```

Kode di atas akan memberikan output:

```
{0, 2, 5, -3, -1}
{0, 2, 5, -3, -1}
```

#### Contoh 2. Intersection (Irisan)
Intersection dari himpunan $A$ dan $B$ dinotasikan dengan $A \cap B$ dalam Python dituliskan dengan dua cara:

```python
A.intersection(B)
```

atau 

```python
A & B
```

Kode berikut mencontohkan operasi irisan pada himpunan $A$ dan $B$:

```python
A = {-3, -1, 2, 5}
B = {-1, 0, 2}

print(A.intersection(B))
print(A & B)
```

Kode di atas akan memberikan output:

```
{2, -1}
{2, -1}
```

#### Contoh 3. Selisih

Selisih dari himpunan $A$ dan $B$, dinotasikan dengan $A - B$ dalam Python dituliskan dengan dua cara:

```python
A.difference(B)
```

atau

```python
A - B
```

Kode berikut mencontohkan operasi selisih pada himpunan $A$ dan $B$:

```python
A = {-3, -1, 2, 5}
B = {-1, 0, 2}

print(A.difference(B))
print(B - A)
```

Kode di atas akan memberikan output:

```
{-3, 5}
{0}
```

#### Contoh 4. Komplemen

Komplemen dari suatu himpunan dalam Python dapat dicari dengan mencari selisih himpunan semesta dengan himpunan tersebut. Misalkan $S = \{1, 2, 3, 4, 5, 6, 7, 8, 9\}$ dan $A = \{1, 3, 7, 9\}$, kode berikut mencari $A^c$:

```python
S = {1, 2, 3, 4, 5, 6, 7, 8, 9}
A = {1, 3, 7, 9}
print(S - A)
```

Output dari kode di atas:
```python
{2, 4, 5, 6, 8}
```

# Relasi

Kode Python berikut adalah module (disimpan dalam file bernama sifat_relasi.py) yang berisikan fungsi-fungsi untuk menguji sifat-sifat relasi.


***sifat_relasi.py***
```python
"""
Sifat-sifat Relasi
"""

def is_reflexive(R, A):
    """Mengembalikan True jika relasi R pada himpunan A adalah reflektif, False sebaliknya."""
    for a in A:
        if (a, a) not in R:
            return False
    return True

def is_symmetric(R, A):
    """Mengembalikan True jika relasi R pada himpunan A adalah simetris, False sebaliknya."""
    for a, b in R:
        if (b, a) not in R:
            return False
    return True

def is_transitive(R, A):
    """Mengembalikan True jika relasi R pada himpunan A adalah transitif, False sebaliknya."""
    for a in A:
        for b in A:
            if (a, b) in R:
                for c in A:
                    if (b, c) in R and (a, c) not in R:
                        return False
    return True
```

Misalkan untuk 





```
if __name__ == "__main__":
    # see Example 7 on Page 576
    A = set([1, 2, 3, 4])
    R1 = [(1, 1), (1, 2), (2, 1), (2, 2), (3, 4), (4, 1), (4, 4)]
    R2 = [(1, 1), (1, 2), (2, 1)]
    R3 = [(1, 1), (1, 2), (1, 4), (2, 1), (2, 2), (3, 3), (4, 1), (4, 4)]
    R4 = [(2, 1), (3, 1), (3, 2), (4, 1), (4, 2), (4, 3)]
    R5 = [(1, 1), (1, 2), (1, 3), (1, 4), (2, 2), (2, 3), (2, 4), (3, 3), (3, 4), (4, 4)]
    R6 = [(3, 4)]
    for R in [R1, R2, R3, R4, R5, R6]:
        print R
        print "  reflexive: ", reflexive(R, A)
        print "  symmetric: ", symmetric(R, A)
        print "  transitive:", transitive(R, A)
        
```
https://w3.cs.jmu.edu/mayfiecs/cs228/python/

# Fungsi

Kita perlu mendownload module `sympy`.
Pertama install `pip` terlebih dahulu:

1. Download `get-pip.py` pada https://bootstrap.pypa.io/get-pip.py

![](https://i.imgur.com/V4b0DTQ.png)

2. Pada command prompt pindah ke directory tempat `get-pip.py` disimpan (dalam contoh ini kita menyimpannya pada folder Downloads)


3. Pada windows, klik Start dan ketikkan "Manage App Execution Aliases", klik icon tersebut dan matikan Python.

![](https://i.imgur.com/mixPcjM.png)

4. Tutup command prompt.

5. Ketikkan `pip install sympy` pada command prompt.


## Product Fungsi

#### Contoh 1. Produk Fungsi
Kode berikut mencontohkan hasil kali fungsi $f \circ g$  dan $g \circ f$ dimana $f(x) = x^2$ dan $g(x) = x + 3$.

```python=
import sympy

x = sympy.symbols('x')
f = x**2
g = x + 3
print(sympy.compose(f,g))    // Memberikan output f(g(x))
print(sympy.compose(g,f))    // Memberikan output g(f(x))
```

Output dari kode di atas:
```
x**2 + 6*x + 9
x**2 + 3
```


Penjelasan kode:
- Baris 1 mengimpor module `sympy`
- Baris 3 menyatakan bahwa `'x'` adalah simbol yang ditugaskan ke variabel `x`
- Baris 4 mendefinisikan `f` adalah fungsi $x^2$
- Baris 5 mendefinisikan `g` adalah fungsi $x + 3$
- Baris 6 mencetak hasil $f \circ g$ 
- Baris 7 mencetak hasil $g \circ f$

## Fungsi Invers

#### Contoh 2. Fungsi Invers
Kode berikut mencari fungsi invers dari $f(x) = 2x + 6$.

```python
import sympy

x, y = sympy.symbols('x y')
print(sympy.solve(2*x + 6 - y))
```

Output:

```
[{x: y/2 - 3}]
```

#### Contoh 3. Fungsi Invers dengan `Eq` dan `solve`
Selain menggunakan 

```python
print(sympy.solve(sympy.Eq(y, (4*x - 7)/(7*x + 3)), x))
[(-3*y - 7)/(7*y - 4)]
```

# Proposisi

#### Negasi
Untuk menadapatkan negasi, kita menggunakan operator `not`.

```python
p = True
print(not p)
```

Kode berikut mencetak tabel kebenaran untuk operasi negasi:

```python
print('p    a')
for p in [True, False]:
   a = not p
   print(p, a)
```




#### Tambahan

```python
"""
formula.py - propositional formulas for Python
by Robin Wellner
Hereby, I waive all rights to this library, as described at <http://creativecommons.org/publicdomain/zero/1.0/>
Examples:
foo = Atom('foo')
bar = Atom('bar')
disjuction = foo | bar
conjunction = foo & bar
implication = foo >> bar
if_and_only_if = foo << bar
inverse = ~foo
simple_tautology = foo | ~foo
simple_negative_tautology = foo & ~foo
#Valuation:
#Formula.v(true_set)
print(simple_tautology.v({foo}) # prints True
print(negative_tautology.v({foo}) # prints True
print(inverse.v({bar}) # prints True
#Tautology checking:
#Formula.t()
#returns a set of atoms which cause Formula.v to return False (a counterexample)
#or None if the formula is a tautology
print(simple_tautology.t()) # prints None
print(implication.t()) # prints {foo}
"""

class Formula:
	def __invert__(self):
		return Not(self)
	def __and__(self, other):
		return And(self, other)
	def __or__(self, other):
		return Or(self, other)
	def __rshift__(self, other):
		return Implies(self, other)
	def __lshift__(self, other):
		return Iff(self, other)
	def __eq__(self, other):
		return self.__class__ == other.__class__ and self.eq(other)
	def v(self, v):
		raise NotImplementedError("Plain formula can not be valuated")
	def _t(self, left, right):
		while True:
			found = True
			for item in left:
				if item in right:
					return None
				if not isinstance(item, Atom):
					left.remove(item)
					tup = item._tleft(left, right)
					left, right = tup[0]
					if len(tup) > 1:
						v = self._t(*tup[1])
						if v is not None:
							return v
					found = False
					break
			for item in right:
				if item in left:
					return None
				if not isinstance(item, Atom):
					right.remove(item)
					tup = item._tright(left, right)
					left, right = tup[0]
					if len(tup) > 1:
						v = self._t(*tup[1])
						if v is not None:
							return v
					found = False
					break
			if found:
				return set(left)
	def t(self):
		return self._t([], [self])

class BinOp(Formula):
	def __init__(self, lchild, rchild):
		self.lchild = lchild
		self.rchild = rchild
	def __str__(self):
		return '(' + str(self.lchild) + ' ' + self.op+ ' ' + str(self.rchild) + ')'
	def eq(self, other):
		return self.lchild == other.lchild and self.rchild == other.rchild

class And(BinOp):
	op = '∧'
	def v(self, v):
		return self.lchild.v(v) and self.rchild.v(v)
	def _tleft(self, left, right):
		return (left + [self.lchild, self.rchild], right),
	def _tright(self, left, right):
		return (left, right + [self.lchild]), (left, right + [self.rchild])

class Or(BinOp):
	op = '∨'
	def v(self, v):
		return self.lchild.v(v) or self.rchild.v(v)
	def _tleft(self, left, right):
		return (left + [self.lchild], right), (left + [self.rchild], right)
	def _tright(self, left, right):
		return (left, right + [self.lchild, self.rchild]),

class Implies(BinOp):
	op = '→'
	def v(self, v):
		return not self.lchild.v(v) or self.rchild.v(v)
	def _tleft(self, left, right):
		return (left + [self.rchild], right), (left, right + [self.lchild])
	def _tright(self, left, right):
		return (left + [self.lchild], right + [self.rchild]),

class Iff(BinOp):
	op = '↔'
	def v(self, v):
		return self.lchild.v(v) is self.rchild.v(v)
	def _tleft(self, left, right):
		return (left + [self.lchild, self.rchild], right), (left, right + [self.lchild, self.rchild])
	def _tright(self, left, right):
		return (left + [self.lchild], right + [self.rchild]), (left + [self.rchild], right + [self.lchild])

class Not(Formula):
	def __init__(self, child):
		self.child = child
	def v(self, v):
		return not self.child.v(v)
	def __str__(self):
		return '¬' + str(self.child)
	def eq(self, other):
		return self.child == other.child
	def _tleft(self, left, right):
		return (left, right + [self.child]),
	def _tright(self, left, right):
		return (left + [self.child], right),

class Atom(Formula):
	def __init__(self, name):
		self.name = name
	def __hash__(self):
		return hash(self.name)
	def v(self, v):
		return self in v
	def __str__(self):
		return str(self.name)
	__repr__ = __str__
	def eq(self, other):
		return self.name == other.name
```

```python
from formula import Atom

a = Atom('a')
b = Atom('b')
c = Atom('c')

def dop(f, e):
	print("Formula: ", f)
	print("Valuation for", e, ": ", f.v(e))
	print("Counterexample: ", f.t())

dop(a | b, {a})
dop(a >> b, {a})
dop(a << b, {a})
dop(a & b, {a,b})
dop(a & b >> (c >> a), {b,c})
dop(a & b | b & c, {b,c})
dop(~a & ~~~b, {})
dop(a >> (b >> c), {a, b})
dop(a >> (b >> c), {a, b, c})
dop(a >> b >> c, {a, c})
dop(((c | ~b) >> (b | c)) >> (b | c), {a, c})
dop(a | ~a, {})
dop(a >> a, {a})
dop(a << a, {})
dop((a >> b) | (b >> a), {})
dop((~a | b) | (~b | a), {})
dop((~a | a) | (~b | b), {})
```

# Boolean Algebra
https://prutor.ai/logic-gates-in-python/
#### Contoh 1. Gate AND
Berikut adalah kode fungsi `AND`
```python
def AND(a, b):

    if a == 1 and b == 1:
        return True
    else:
        return False
```

Output:
```
p    a
True False
False True
```

