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:

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

atau

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\}$.

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\}$.

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.

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:

A.union(B)

atau

A | B

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

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:

A.intersection(B)

atau

A & B

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

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:

A.difference(B)

atau

A - B

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

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$:

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

Output dari kode di atas:

{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***

"""
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


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.


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$.

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$.

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

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`.

p = True
print(not p)

Kode berikut mencetak tabel kebenaran untuk operasi negasi:

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

#### Tambahan

"""
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

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`

def AND(a, b):

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

Output:

p    a
True False
False True