Sumber utama: https://ggc-discrete-math.github.io/functions.html#_injective_surjective_bijective_and_inverse_functions
Python
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:
pada kode Python, kita menuliskan:
atau
Untuk mengetahui keanggotaan suatu himpunan kita dapat membentuk sebuah ekspresi menggunakan operator in
. Sebagai contoh, misalkan kita ingin mengetahui apakah 8 adalah anggota himpunan , atau kita menuliskan:
Ekspresi di atas akan menghasilkan nilai Boolean False
, karena 8 bukanlah elemen dari himpunan .
Contoh 1. Mengetahui Keanggotaan Himpunan Menggunakan Python
Kode Python berikut memeriksa apakah 5 dan 0 adalah elemen dari himpunan .
Karena dan , maka kode di atas akan memberikan output:
Contoh 2. Menampilkan Semua Elemen-elemen dalam Sebuah Himpunan
Kode berikut menampilkan semua elemen-elemen dalam himpunan .
Output dari kode di atas:
Kode berikut mendefinisikan himpunan menggunakan set builder dan menampilkan semua elemen dari himpunan tersebut.
1.2 Operasi pada Himpunan
Contoh 1. Union
Kita dapat menuliskan operasi union dalam Python dengan dua cara. Misalkan, operasi , dapat dituliskan dengan dua cara berikut:
atau
Kode berikut mencontohkan operasi union pada himpunan dan :
Kode di atas akan memberikan output:
Contoh 2. Intersection (Irisan)
Intersection dari himpunan dan dinotasikan dengan dalam Python dituliskan dengan dua cara:
atau
Kode berikut mencontohkan operasi irisan pada himpunan dan :
Kode di atas akan memberikan output:
Contoh 3. Selisih
Selisih dari himpunan dan , dinotasikan dengan dalam Python dituliskan dengan dua cara:
atau
Kode berikut mencontohkan operasi selisih pada himpunan dan :
Kode di atas akan memberikan output:
Contoh 4. Komplemen
Komplemen dari suatu himpunan dalam Python dapat dicari dengan mencari selisih himpunan semesta dengan himpunan tersebut. Misalkan dan , kode berikut mencari :
Output dari kode di atas:
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
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)
Akan menghasilkan output
[(1, 1), (1, 2), (2, 1), (2, 2), (3, 4), (4, 1), (4, 4)]
reflexive: False
symmetric: False
transitive: False
[(1, 1), (1, 2), (2, 1)]
reflexive: False
symmetric: True
transitive: False
[(1, 1), (1, 2), (1, 4), (2, 1), (2, 2), (3, 3), (4, 1), (4, 4)]
reflexive: True
symmetric: True
transitive: False
[(2, 1), (3, 1), (3, 2), (4, 1), (4, 2), (4, 3)]
reflexive: False
symmetric: False
transitive: True
[(1, 1), (1, 2), (1, 3), (1, 4), (2, 2), (2, 3), (2, 4), (3, 3), (3, 4), (4, 4)]
reflexive: True
symmetric: False
transitive: True
[(3, 4)]
reflexive: False
symmetric: False
transitive: True

https://w3.cs.jmu.edu/mayfiecs/cs228/python/
Mencari Domain, Range, Invers
- Misalkan A = {1, 2, 3, 4, 5, 6, 7}, B = {4, 5, 6, 7, 8, 9} dan relasi R dari A ke B diberikan oleh R = {(1,5),(4,5),(1,4),(4,6),(3,7),(7,6)} carilah: Domain, Range, dan Invers dari R
OUTPUT
Membuat himpunan pasangan terurut
2. Suatu relasi R dari himpunan A ={1, 2, 3, 4} ke himpunan B = {1, 3, 5}, yang didefinisikan oleh "x lebih kecil dari y"
- Tulis R sebagai himpunan pasangan terurut
- Tentukan relasi invers dari R
OUTPUT
- Suatu relasi R yang didefinisikan sebagai "x habis membagi y" dari himpunan C ={2, 3, 4, 5} ke himpunan D = {3, 6, 7, 10}
- Tentukan R sebagai himpunan pasangan terurut
- Tentukan relasi invers dari R
OUTPUT
Sumber = https://www.youtube.com/watch?v=wk-oxGzqxSQ
Fungsi
Kita perlu mendownload module sympy
,numpy
.
Pertama install pip
terlebih dahulu:
- Download
get-pip.py
pada https://bootstrap.pypa.io/get-pip.py

-
Pada command prompt pindah ke directory tempat get-pip.py
disimpan (dalam contoh ini kita menyimpannya pada folder Downloads)
-
Pada windows, klik Start dan ketikkan "Manage App Execution Aliases", klik icon tersebut dan matikan Python.

-
Tutup command prompt.
-
Ketikkan pip install sympy numpy
pada command prompt.
Terdapat beberapa library yang kita butuhkan untuk program fungsi pada Python. Maka kita perlu mendownload module sympy
,numpy
. sympy
merupakan python library untuk symbolic mathematics, numpy
adalah library python yang digunakan untuk bekerja dengan array dan juga memiliki fungsi yang bekerja dalam domain aljabar linier, transformasi fourier, dan matriks.
Jika sudah mengikuti langkah-langkah pada video tutorial install dan konfigurasi Python3.10 selanjutnya lakukan install untuk library numpy
-
Pertama buka folder Python3.10 :

-
Pada Address bar ketikan cmd untuk membuka jendela command prompt


-
Selanjutnya, ketikan pip install sympy numpy
pada jendela command prompt untuk menginstall library simpy
dan numpy
.

Mencari domain, range dari suatu fungsi
Contoh 1. Mencari domain, range
Diketahui Himpunan A = {1, 2, 3, 4, 5, 6, 7} dan B = {4, 5, 6, 7, 8, 9, 10}, membentuk suatu relasi fungsi dengan F = {(1,4), (2,5), (3,6), (4,7), (5,8), (6,9), (7,10)}, carilah domain dan range dari relasi fungsi F tersebut
OUTPUT
Membuat Grafik fungsi dengan python
Contoh 2.Membuat grafik fungsi y = 2x+1
- Grafik fungsi 2x+1 dimana x={-5,0,1,2,3,4,5}
Penjelasan program
- Baris 1 Import library
numpy
untuk membuat data imaginer dan menamakan ulang dengan np
- Baris 2 mengimport fungsi
pyplot
yang berada dalam module library matplotlib.pyplot
dan menamakan ulang fungsi tersebut sebagai plt
digunakan untuk impor fungsi pyplot
- Baris 4 membuat data imaginer yang dibentuk menggunakan
np.linspace()
digunakan untuk membuat array dengan nilai dalam interval.
- Baris 5 mendefinisikan nilai "y" dimana "y" adalah 2x+1
- Baris 7 untuk memvisualisasikan datanya dengan fungsi
Plt.plot
- Baris 8 memberikan keterangan pada visualisasi diagram untuk koordinat x
- Baris 9 memberikan keterangan pada visualisasi diagram untuk koordinat y
- Baris 10 memberikan keterangan pada visualisasi judul diagram
- Baris 11 menampilkan diagram pada data yang divisualisasikan.
OUTPUT

Contoh 3. Membuat grafik fungsi
- Misal carilah grafik fungsi dari dimana x={-5,0,1,2,3,4,5}
Penjelasan program
- Baris 1 Import library
numpy
untuk membuat data imaginer dan menamakan ulang dengan np
- Baris 2 mengimport fungsi
pyplot
yang berada dalam module library matplotlib.pyplot
dan menamakan ulang fungsi tersebut sebagai plt
digunakan untuk impor fungsi pyplot
- Baris 4 membuat data imaginer yang dibentuk menggunakan
np.linspace()
digunakan untuk membuat array dengan nilai dalam interval.
- Baris 5 mendefinisikan nilai "y" dimana "y" adalah x pangkat 2 dikurangi 5
- Baris 7 untuk memvisualisasikan datanya dengan fungsi
Plt.plot
- Baris 8 memberikan keterangan pada visualisasi diagram untuk koordinat x
- Baris 9 memberikan keterangan pada visualisasi diagram untuk koordinat y
- Baris 10 memberikan keterangan pada visualisasi judul diagram
- Baris 11 menampilkan diagram pada data yang divisualisasikan.
OUTPUT

Contoh 4. Membuat grafik fungsi
- Grafik fungsi dimana x={2, 3, 4, 5, 6, 7, 8, 9, 10}
Penjelasan program
- Baris 1 Import library
numpy
untuk membuat data imaginer dan menamakan ulang dengan np
- Baris 2 mengimport fungsi
pyplot
yang berada dalam module library matplotlib.pyplot
dan menamakan ulang fungsi tersebut sebagai plt
digunakan untuk impor fungsi pyplot
- Baris 4 membuat data imaginer yang dibentuk menggunakan
np.linspace()
digunakan untuk membuat array dengan nilai dalam interval.
- Baris 5 mendefinisikan nilai "y" dimana "y" adalah pangkat 2 dari X
- Baris 7 untuk memvisualisasikan datanya dengan fungsi
Plt.plot
- Baris 8 memberikan keterangan pada visualisasi diagram untuk koordinat x
- Baris 9 memberikan keterangan pada visualisasi diagram untuk koordinat y
- Baris 10 memberikan keterangan pada visualisasi judul diagram
- Baris 11 menampilkan diagram pada data yang divisualisasikan.
OUTPUT

sumber = https://alvinburhani.wordpress.com/2020/10/06/membuat-grafik-fungsi-dengan-python/
https://www.dqlab.id/belajar-python-untuk-hasilkan-visualisasi-data
Product Fungsi
Contoh 5. Produk Fungsi
Kode berikut mencontohkan hasil kali fungsi dan dimana dan .
Output dari kode di atas:
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
- Baris 5 mendefinisikan
g
adalah fungsi
- Baris 6 mencetak hasil
- Baris 7 mencetak hasil
Fungsi Invers
Contoh 6. Fungsi Invers
Kode berikut mencari fungsi invers dari .
Output:
Contoh 7. Fungsi Invers dengan Eq
dan solve
Selain menggunakan
Fungsi floor() dan ceil() pada python
Program dibawah ini mencari bilangan bulat dari 1.4
Contoh 9. Mencari bilangan bulat dengan floor()
OUTPUT
Contoh 8. Mencari bilangan bulat dengan ceil()
OUTPUT
sumber = https://dosenit.com/python/fungsi-matematika-di-python
Fungsi Faktorial
Contoh 10. Mencari nilai faktorial
program dibawah ini mencari nilai faktorial dari 6!
output
Proposisi
Negasi
Untuk menadapatkan negasi, kita menggunakan operator not
.
Kode berikut mencetak tabel kebenaran untuk operasi negasi:
Conjunction
Untuk mencari konjungsi pada python, kita menggunakan operator and
.Kode berikut mencetak tabel kebenaran untuk operasi konjungsi
OUTPUT
Disjungsi
Untuk mencari disjungsi pada python, kita menggunakan operator or
.Kode berikut mencetak tabel kebenaran untuk operasi disjungsi
OUTPUT
Implikasi
Banyak pernyataan, khususnya dalam matematika, berbentuk "jika p maka q".Pernyataan demikian disebut statemen kondisional yang dinyatakan dengan tanda "→"
Untuk mencari implikasi pada python, kita menggunakan operator =>
atau not(p) or q
.Kode berikut mencetak tabel kebenaran untuk operasi implikasi
OUTPUT
Biimplikasi
Bentuk proposisi: “p jika dan hanya jika q”. Aturan Bikondisional Semantik: sebuah Bikondisional bernilai benar jika dan hanya jika pernyataan pada kedua komponen di kedua sisinya bernilai benar atau dikedua sisinya bernilai salah. Notasi/tanda“↔”. Bikondisional, secara logik sama dengan sebuah konjungsi dari dua proposisi kondisi.
Untuk mencari bimplikasi pada python, kita menggunakan (p and q) or not(p or q)
.Kode berikut mencetak tabel kebenaran untuk operasi biimplikasi
OUTPUT
Membuat Tabel kebenaran
Contoh: Buatlah tabel kebenaran dari
- Ketikan program berikut dan simpan dengan nama logic.py
def exactly_one(S):
return len([ s for s in S if s ]) == 1
def in_order(L):
return all( L[i] <= L[i+1] for i in range(0, len(L)-1) )
def set_to_predicate(S):
return lambda x: x in S
def truth_table_rows(variables):
if len(variables) == 0:
return [dict()]
variables = list(variables)
P = variables[0]
R = truth_table_rows(variables[1:])
add_P = lambda v: [ dict([(P,v)] + list(r.items())) for r in R ]
return add_P(True) + add_P(False)
def vars(*var_names):
return ( Variable(name) for name in var_names )
def cast_to_proposition(p):
if isinstance(p, Proposition):
return p
elif isinstance(p, str):
return Variable(p)
elif isinstance(p, bool):
return Constant(p)
else:
raise ValueError()
class Proposition:
symbol = ''
empty_str = ''
def __init__(self, *children):
self.children = [ cast_to_proposition(c) for c in children ]
def __str__(self):
if len(self.children) == 0: return self.empty_str
return self.symbol.join( c.child_str() for c in self.children )
def evaluate(self, **assignments):
raise NotImplementedError()
def variables(self):
if len(self.children) == 0:
return frozenset()
else:
return frozenset.union(*[ c.variables() for c in self.children ])
def __repr__(self):
return 'Proposition( {0} )'.format(self)
def child_str(self):
return ('{0}' if isinstance(self, (Constant,Variable,Not)) else '({0})').format(self)
def print_truth_table(self):
vars = sorted( self.variables() )
rows = truth_table_rows(vars)
formula_header = str(self)
formula_len = max(5,len(formula_header))
header = '{0} # {1: ^{2}}'.format(' '.join('{0: ^5}'.format(v) for v in vars), formula_header, formula_len)
print(header)
print('#'*len(header))
for r in rows:
var_cols = ' '.join('{0: ^{1}}'.format(str(r[v]), max(5,len(v))) for v in vars)
result_col = '{0: ^{1}}'.format(str(self.evaluate(**r)), formula_len)
print('{0} # {1}'.format(var_cols, result_col))
print()
def to_tree(self):
from trees import ListTree
result = ListTree(value=str(self))
for c in self.children:
result.add_child_node(c.to_tree())
return result
def __and__(self,other):
v = self.children if isinstance(self,And) else [self]
w = other.children if isinstance(other,And) else [other]
return And(*(v+w))
def __rand__(self,other):
return cast_to_proposition(other) & self
def __or__(self,other):
v = self.children if isinstance(self,Or) else [self]
w = other.children if isinstance(other,Or) else [other]
return Or(*(v+w))
def __ror__(self,other):
return cast_to_proposition(other) | self
def __invert__(self):
return Not(self)
def __rshift__(self,other):
return Implies(self,other)
def __rrshift__(self,other):
return Implies(other,self)
def __lshift__(self,other):
return ImpliedBy(self,other)
def __rlshift__(self,other):
return ImpliedBy(other,self)
def disjunction(self,other):
return self | other
def conjunction(self,other):
return self & other
def negation(self):
return ~self
def implies(self,other):
return self >> other
def impliedby(self,other):
return self << other
def iff(self,other):
return Iff(self,other)
def is_tautology(self):
return all( self.evaluate(**r) for r in truth_table_rows(self.variables()) )
def is_contradiction(self):
return all( not self.evaluate(**r) for r in truth_table_rows(self.variables()) )
def is_contingency(self):
return not self.is_tautology() and not self.is_contradiction()
def __eq__(self,other):
return self.is_equivalent(other)
def is_equivalent(self,other):
other = cast_to_proposition(other)
return all( self.evaluate(**r) == other.evaluate(**r) for r in truth_table_rows(self.variables() | other.variables()) )
def is_identical(self,other):
return self.__class__ == other.__class__ \
and len(self.children) == len(other.children) \
and all( c.is_identical(d) for (c,d) in zip(self.children,other.children) )
def substitute(self, e1, e2):
if self.is_identical(e1):
return e2
else:
return self.__class__( *[c.substitute(e1,e2) for c in self.children] )
class Constant(Proposition):
def __init__(self,value):
self.children = []
self.value = bool(value)
def substitute(self, e1, e2):
return Constant(self.value)
def __str__(self):
return str(self.value)
def evaluate(self, **assignments):
return self.value
def is_identical(self,other):
return isinstance(other, Constant) and self.value == other.value
class Variable(Proposition):
def __init__(self,name):
self.children = []
self.name = name
def substitute(self, e1, e2):
if self.is_identical(e1):
return e2
else:
return Variable(self.name)
def variables(self):
return frozenset({ self.name })
def __str__(self):
return self.name
def evaluate(self, **assignments):
return assignments[self.name]
def is_identical(self,other):
return isinstance(other, Variable) and self.name == other.name
class Not(Proposition):
def __init__(self,child):
Proposition.__init__(self,child)
def __str__(self):
return u'¬{0}'.format(self.children[0].child_str())
def evaluate(self, **assignments):
return not self.children[0].evaluate(**assignments)
class And(Proposition):
symbol = ' ^ '
empty_str = 'True'
def evaluate(self, **assignments):
return all( child.evaluate(**assignments) for child in self.children )
class Or(Proposition):
symbol = ' v '
empty_str = 'False'
def evaluate(self, **assignments):
return any( child.evaluate(**assignments) for child in self.children )
class Implies(Proposition):
symbol = ' => '
def __init__(self,child1,child2):
Proposition.__init__(self,child1,child2)
def evaluate(self, **assignments):
if self.children[0].evaluate(**assignments):
return self.children[1].evaluate(**assignments)
else:
return True
class ImpliedBy(Proposition):
symbol = ' <= '
def __init__(self,child1,child2):
Proposition.__init__(self,child1,child2)
def evaluate(self, **assignments):
if self.children[1].evaluate(**assignments):
return self.children[0].evaluate(**assignments)
else:
return True
class Iff(Proposition):
symbol = ' <=> '
def __init__(self,child1,child2):
Proposition.__init__(self,child1,child2)
def evaluate(self, **assignments):
return self.children[0].evaluate(**assignments) == self.children[1].evaluate(**assignments)
class ArgumentForm:
def __init__(self, *premises, conclusion):
self.premises = [ cast_to_proposition(c) for c in premises ]
self.conclusion = cast_to_proposition(conclusion)
def variables(self):
return frozenset.union(self.conclusion.variables(), *[ c.variables() for c in self.premises ])
def __repr__(self):
return 'ArgumentForm( {0} )'.format(self)
def __str__(self):
return ((', '.join(str(c) for c in self.premises) + ', ') if self.premises else '') + 'conclusion = ' + str(self.conclusion)
def print_truth_table(self):
vars = sorted( self.variables() )
rows = truth_table_rows(vars)
var_strings = [ '{0: ^5}'.format(v) for v in vars ]
premise_strings = [ '{0: ^6}'.format(str(c)) for c in self.premises ]
conclusion_string = '{0: ^10}'.format(str(self.conclusion))
vars_header = ' '.join(var_strings)
premises_header = '{0: ^8}'.format(' '.join(premise_strings))
print('{0} # {1: ^{2}} # {3: ^{4}}'.format(' '*len(vars_header), 'premises', len(premises_header), 'conclusion', len(conclusion_string)))
header = '{0} # {1: ^8} # {2}'.format(vars_header, premises_header, conclusion_string)
print(header)
print('#'*len(header))
for r in rows:
premise_values = [ c.evaluate(**r) for c in self.premises ]
conclusion_value = self.conclusion.evaluate(**r)
star = '*' if all( v for v in premise_values ) else ''
var_cols = ' '.join( '{0: ^{1}}'.format(str(r[v]), len(k)) for (k,v) in zip(var_strings, vars) )
premise_cols = ' '.join( '{0: ^{1}}'.format(str(v)+star, len(k)) for (k,v) in zip(premise_strings, premise_values) )
conclusion_col = '{0: ^{1}}'.format(str(conclusion_value)+star, len(conclusion_string))
print('{0} # {1: ^8} # {2}'.format(var_cols, premise_cols, conclusion_col))
print()
def is_valid(self):
vars = (frozenset.union(*[ c.variables() for c in self.premises ]) if self.premises else frozenset()) | self.conclusion.variables()
return all( self.conclusion.evaluate(**r) for r in truth_table_rows(vars) if all( c.evaluate(**r) for c in self.premises ) )
def substitute(self, e1, e2):
return ArgumentForm( *[ c.substitute(e1,e2) for c in self.premises ], conclusion = self.conclusion.substitute(e1,e2) )
- Selanjutnya jalankan program tersebut,pada jendela console ketikan program dibawah ini

Penjelasan:
- Baris 1 digunakan untuk import module logic yang sebelumnya sudah dibuat.
- Baris 2, mendefinisikan variabel P,Q,R,S,T
- Baris 3, untuk memeriksa apakah variabel sudah terdefinisi atau belum
- Baris 4, mencetak tabel kebenaran dari dengan method.
(P & ~P).print_truth_table()
Sumber:
- https://bitbucket.org/Andrew-Kay/dcaa/src/master/logic.py
- https://www.youtube.com/watch?v=fW-9YLHBH3E&t=229s
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
OUTPUT
https://github.com/minubae/python_mathematics/blob/master/logic.py
Boolean Algebra
https://booleanpy.readthedocs.io/en/latest/index.html
Contoh 1. Gate AND
Berikut adalah kode fungsi AND
Output:
https://prutor.ai/logic-gates-in-python/
Bolean algebra pada python
Aljabar Boolean adalah cabang dari aljabar yang berhubungan dengan operasi logika dan variabel biner.
Berikut ini adalah cara mendefinisikan Algebra Boolean pada Python
Mencari nilai dari suatu ekspresi boolean pada python
Contoh:
Cari nilai dari menggunakan python
Output
Cara diatas dilakukan dengan mencetak langsung nilai yang dicari dari , selain dengan cara tersebut untuk mencari nilai dari suatu ekspresi boolean pada python dapat dilakukan dengan cara:
Output
Penjelasan:
- Baris 2 dan 3 mendefinisikan ekspresi boolean 1 dan 0 dengan variabel a dan b
- Baris 4 digunakan untuk mencetak ekspresi dari
Mengevaluasi Ekspresi Boolean pada Python
contoh:
Evaluasi ekspresi Boolean jika , dan dengan Python.
Output
Penjelasan:
- Baris 1 sampai 3 inisialiasi variabel
- Baris 4 inisialisasi variabel
x
dimana berupa ekspresi boolean
- kondisi dimana jika bernilai
True
atau ketika bernilai 1 + 1 akan mencetak 1
, sebaliknya jika bernilai False
akan mencetak 0
Fungsi Boolean pada Python
Program berikut ini digunakan untuk mencari nilai dari fungsi boolean pada Python
Contoh:
Cari nilai fungsi Boolean
jika dan pada python
OUTPUT
Penjelasan:
- Baris 1 sampai 3 Inisialisasi variabel x = 1, y = 0, z = 1
- Baris 4 inisialisasi variabel fxyz yang berisi fungsi boolean dan dilakukan cetak pada variabel tersebut
- baris 5 sampai 8 kondisi dimana jika bernilai
True
atau ketika bernilai 1 + 1 akan mencetak 1
, sebaliknya jika bernilai False
akan mencetak 0
14 DESEMBER 2022
boolean.py pada python digunakan untuk implementasi boolean algebra. Ini mengimplementasikan 2 elemen dasar yaitu TRUE dan FALSE, dan sebuah kelas symbol
untuk variabel. Ekspresi dibangun dengan menyusun simbol dan elemen dengan AND, OR, dan NOT. komposisi lainya seperti XOR dan NAND tidak di terapkan.
Untuk menggunakan fungsi yang berada pada boolean.py sebelumnya dilakukan installasi dengan
pip install boolean.py
Membuat ekspresi boolean
Ada tiga cara untuk membuat ekspresi boolean. Semuanya dimulai dengan membuat aljabar, lalu menggunakan atribut dan metode aljabar untuk membangun ekspresi.
Kita dapat membuat ekspresi dari string:
OUTPUT:
Kita dapat membuat ekspresi dari ekspresi Python:
OUTPUT
Kita dapat membuat ekspresi dengan menggunakan fungsi aljabar:
Evaluasi dari Ekspresi
Secara default, ekspresi tidak dievaluasi. Anda perlu memanggil metode simplifikasi() secara eksplisit sebuah ekspresi untuk melakukan beberapa penyederhanaan minimal untuk mengevaluasi sebuah ekspresi:
OUTPUT
Saat simplify()
dipanggil, hukum logika boolean berikut digunakan secara rekursif pada setiap sub-term ekspresi:
- Asosiatif
- Identitas
- Idempoten
- Identitas
- Komplemen
- Eliminasi
- Absorpsi
- Negatif Absorpsi
- Komutatif
Ekspresi yang disederhanakan adalah pengembalian dan mungkin tidak sepenuhnya dievaluasi atau minimal:
OUTPUT
Mencari ekualitas dari ekspresi
Ekualitas dari ekspresi dapat diuji dengan method__eq__()
dan karenanya output dari expr1 == expr2
tidak sama dengan persamaan matematis.
Dua ekspresi sama jika struktur dan simbolnya sama.
OUTPUT
Ekualitas dari simbol
Simbol dianggap sama jika sama atau objek terkaitnya sama.
OUTPUT
Ekualitas dari struktur
Berikut adalah beberapa contoh struktur yang sama dan tidak sama:
Analisis Ekspresi boolean
Mendapatkan sub-terms
Semua ekspresi memiliki properti args
yang merupakan tupel dari istilahnya. Untuk simbol dan elemen dasar, tuple ini kosong, untuk fungsi boolean berisi satu atau lebih simbol, elemen, atau sub-ekspresi.
Mendapatkan seluruh simbol
Untuk mendapatkan satu set() dari semua symbol
unik dalam sebuah ekspresi, gunakan atribut simbolnya
Untuk mendapatkan daftar semua simbol dalam ekspresi, gunakan metode get_symbols
literal
Simbol dan negasi dari simbol disebut literal. Anda dapat menguji apakah suatu ekspresi adalah literal:
Atau dapatkan set() atau daftar semua literal yang terkandung dalam ekspresi:
Untuk menghapus negasi kecuali dalam literal gunakan literalize()
:
Substitusi
Untuk mengganti bagian ekspresi, gunakan metode subs()
:
SUMBER: https://booleanpy.readthedocs.io/en/latest/users_guide.html
15 DESEMBER 2022
Fungsi bool() memungkinkan Anda untuk mengevaluasi nilai apa pun, dan memberi Anda True
atau False
sebagai gantinya.
Contoh:
Cari nilai dari menggunakan python
Output
https://www.w3schools.com/python/python_booleans.asp
Prove the absorption law
OUTPUT
We display steps used to derives this identity and the law used in each step:
Sumber: Discrete Mathematics Kenneth H. Rosen Ch 12 ex.10 p 816
Contoh: 5.3.4
Cari nilai-nilai dari fungsi Boolean .
Solusi:
Nilai-nilai fungsi ini ditampilkan pada tabel berikut.
OUTPUT
19 DESEMBER 2022
Sumber lainnya:
- https://cs.stanford.edu/people/nick/py/python-boolean.html
- https://pyeda.readthedocs.io/en/latest/boolalg.html
- https://docs.sympy.org/latest/modules/logic.html
Gate AND
Gate OR
Gate Not
Gate NAND
Gate NOR
Gate XOR
EX-NOR