Computer Concept & Practice(์ปดํจํฐ ๊ฐ๋ ๋ฐ ์ค์ต)
์ปดํจํฐ์ ๋ํด์ ๋ฐฐ์ฐ๊ธฐ์ ์ ๊ฐ๋ก ์ ์ญํ ์ ํ๋ "Computer Concept & Practice(์ปดํจํฐ ๊ฐ๋
๋ฐ ์ค์ต)" ์์
.
์ปดํจํฐ๋ฅผ ์ฒ์ ์ ํ๋ ํ์๋ค์ ๋์์ผ๋ก ์ปดํจํฐ์ ๋ํ ์ผ๋ฐ์ ์ธ ๊ธฐ์ด๊ฐ๋
๋ฑ์ ์ค๋ช
ํ๊ณ , ํ๋ก๊ทธ๋จ์ด ์ํ๋๋ ๊ณผ์ ๊ณผ ํ๋ก๊ทธ๋จ ์์ฑ์ ์ํ ๋
ผ๋ฆฌ์ ์ธ ์ฌ๊ณ ์ ๋ํ์ฌ ๊ฐ์ํ๋ค.
์ค๋ ๊ฐ์์์๋ ์ ์ฒด์ ์ธ ํฐ ๊ทธ๋ฆผ๊ณผ 2๊ฐ์ง ์ ๋์ ์ฃผ์๊ฐ๋ ์ ์์๋ณด์.
์ฐ์ ํต์ฌ๊ฐ๋ ์ค ํ๋์ธ, Abstraction(๊ตณ์ด ๋ฒ์ญํ๋ฉด '์ถ์ํ'๊ฐ ์ ์ผ ๋์ ๊ฒ ๊ฐ๋ค. ํ์ง๋ง ๋จ์ด ๊ทธ์์ฒด๋ก ์๊ณ ์๋๊ฒ ์ข์ ๊ฒ ๊ฐ๋ค.)์ ๋ํด์ ๋ฐฐ์๋ณด์.
Abstraction
Abstraction์ ๊ฐ๋จํ๊ฒ ๋งํ๋ฉด ๋ณต์กํ ๊ตฌ์กฐ๋ค์ ๋ค๋ฃจ๊ธฐ ์ฝ๊ฒ ์ถ์ํํ๋ ๊ฒ์ด๋ค.
์๋ฅผ ๋ค๋ฉด, ์๋์ ๊ทธ๋ฆผ์ฒ๋ผ ์ฐ๋ฆฌ๋ ์ฐจ๊ฐ LPG์ด๋ , ๋์ ค์ด๋ , ์ ๊ธฐ์ฐจ์ด๋ ์๊ด์์ด ๊ทธ ์๋ฆฌ๋ฅผ ๋ชฐ๋ผ๋ interface๋ฅผ ํตํด ์ด์ ์ ํ ์ ์๋ค.
์๋ํ๋ฉด, ์๋์ฐจ๋ abstraction์ด ๋์ด์์ผ๋๊น.
์ธ๊ฐ์ด ํ์๊ฐ์ ๋ค๋ฃฐ ์ ์๋ ๋ฌธ์ ์ Complexity(๋ณต์ก๋)์๋ ์ ํ์ด ์๋ค.
ํธ๋ค๋ง ๋๋ฆฌ๋ฉด ์๋์ฐจ์ ๋ฐํด๊ฐ ๋ฐฉํฅ์ ์ ํํ์ง๋ง, ์ฐจ์ฒด์์ ์์คํ
์ ์ด์ฉํ๋ฉฐ ๋ฐํด๊ฐ ๋ฐฉํฅ์ ํ์ ํ๊ธฐ ์ํ ๊ณตํ์ ์ธ ์๋ฆฌ๋ฅผ ์๊ฐํ๊ณ ํ๋ฐ์ ๊ฐ ์์ง์์ ์ด์ฉ๋๋ฉฐ ๊ทธ ํ์ด ์ ๋ฌ๋๋ ๊ฒ ๋ฑ๋ฑ๋ฑ ํ๋ํ๋ ์ ๊ฒฝ์ธ๋ ค๋ฉด ๋์ด ์๋ค.
์ด๋ฌ๋ฉด ์๋ฌด๋ ์๋์ฐจ๋ฅผ ์ด์ ํ ์ ์์ ๊ฒ์ด๋ค.
ํ์ง๋ง ๊ทธ๋ฐ ๋ํ
์ผํ ๋ถ๋ถ๋ค์ด abstraction ๋๊ณ , ๋ abstraction๋์ด ์ฐ๋ฆฌ๋ ํธ๋ค๊ณผ ๊ธฐ์ด๋ด ๋ฑ์ ๋น๊ต์ ๊ฐ๋จํ interface๋ก ์ด์ ์ ํ ์ ์๋ค.
(ex: ์ฐ๋ฆฐ ์ ํ๋ธ์ ์๋ฆฌ๋ฅผ ๋ชฐ๋ผ๋, ์กฐ์ ์ด ๊ฐ๋ฅํ๋ค. ์ ํ๋ธ ์์ฒด์ ์๊ณ ๋ฆฌ์ฆ์ ์์ฒญ ๋ณต์กํ๊ฒ ์ง๋ง, abstraction๋๊ณ ๋ abstraction ๋์ด์, ์ฐ๋ฆฌ๋ ๊ฐ๋จํ interface๋ฅผ ํตํด ์ฝ๊ฒ ์ด์ฉ ํ ์ ์๋ค.)
๊ทธ๋์ ์ฐ๋ฆฌ๋ abstraction์ '์ด๋ค ์์คํ ์์ ๋ด๋ถ์ ์์ธํ ์ฌํญ๋ค์ interface๋ก ์ ์ํ์ฌ, ๊ทธ ์์คํ ์ ํ๋์ building block(๊ตฌ์ฑ์์)์ฌ์ฉ ๊ฐ๋ฅํ๊ฒ ํ๋ ๋ฉ์นด๋์ฆ'์ด๋ผ๊ณ ์๊ฐ ํ ์ ์๋ค.
๊ทธ๋ฆฌ๊ณ ์ด๋ฐ abstraction์ ์ธ๊ฐ์ด ๋ง๋ ๊ฒ(man-made)์ธ์๋ ์์ฐ์์๋ ์ฐพ์ ๋ณผ ์ ์๋ค.
๋ฐ์ ๊ทธ๋ฆผ์ฒ๋ผ ์ธ๊ฐ์ ํ์ฑ ๊ณผ์ ๋ abstraction์ด๋ผ๊ณ ํ ์์๋ค.
์๋ช
์ ๋ญ๊ฐ 1๊ฐ์ ๋จ์์ธ ๊ฒ ๊ฐ์ง๋ง, ๊ฒฐ๊ตญ ์์ ๋จ์์์ ๋ถํฐ abstraction๋ ๊ฒ์ด๋ค.
(๋ด ๋ถ์ผ์ ์ฐ๊ด์ง์ด ์ค๋ช
ํ์๋ฉด, ์ฐ๋ฆฌ๋ ๊ทผ์ก์ด ์ด๋ป๊ฒ ์์ง์ด๋์ง ๋ชจ๋ฅด์ง๋ง, action๊ณผ myosin์ด ์ด๋ค ๊ธฐ์ ์ผ๋ก ๊ฒฐํฉํ๋์ง ๋ชฐ๋ผ๋, ์ฐ๋ฆฌ๋ ๋๋ผ๋ ์ต๊ณ ์ interface๋ฅผ ํตํด ์กฐ์ ์ด ๊ฐ๋ฅํ๋ค)
*์๋ช
์ ํ์๊ณผ ์ฑ์ฅ ์์ฒด๊ฐ abstraction์ด๋ผ๋ ์๋ฏธ๊ฐ ์๋๋ผ, ์ ๋ ๊ฒ ๋ณต์กํ๊ณ ์์์์คํ
๋ค์ด ๊ฐ๋ตํ๋๊ณ ๋ ๊ฐ๋ตํ๋์ด์ ์ฐ๋ฆฌ๊ฐ ์์ง์ด๊ณ ์ด์๊ฐ๋ ๊ฒ์ด abstraction์ด๋ผ๋ ์๋ฏธ๋ผ๊ณ ๋ง์๋๋ฆฐ ๊ฒ์
๋๋ค.
๋ฏผ์๋ ฌ ๊ต์๋์ ๋ง์.
"์ ๋ ์ข ๊ต๊ฐ ์์ง๋ง, ์ฐฝ์กฐ์ฃผ๊ฐ ํ๋ ์์ ๋ฐ๋ผํ๋ฉด ์ต์ํ ์ค๊ฐ์ด์์ ๊ฐ๋ค๋ผ๊ณ ์๊ฐํฉ๋๋ค. ๊ทธ๋์ ์ฐฝ์กฐ์ฃผ๊ฐ ์ด๋ฐ ๊ณ์ธต์ ์ธ ๊ตฌ์กฐ๋ฅผ ๋ฐ๋์ผ๋ฉด, ์ฐ๋ฆฌ๋ abstraction์ ์ํค๋ฉด์ ๊ฑฐ๊ธฐ์ interface๋ฅผ ๋ง๋ค๋ฉด์ ๊ทธ component(์์)๋ฅผ ์ด์ฉํด์ ๋ ํฐ ์์คํ ์ ๊ตฌ์ถํ๋ ๊ทธ๋ฆฌ๊ณ ๊ทธ๋ฐ ๊ณผ์ ์ ๊ณ์ธต์ ์ผ๋ก ํ๋ ์ ๊ทผ๋ฐฉ์์ ๊ฐ์ง๋๊ฒ ์ข๋ค๊ณ ์๊ฐํฉ๋๋ค."
์ด์ฒ๋ผ ๊ฐ์ฅ ์์์ ๋ณด๋ฉด ์ด๋ค problems๋ฅผ ํ๊ณ ์ถ์ ๊ฒ์ด์ง๋ง, ๊ฐ์ฅ ์๋๋ก ํ๊ณ ๋ค์ด ๊ฐ๋ค๋ฉด ์ ์๊ฐ ์์ ๊ฒ์ด๋ค.
ex) electron๋ฅผ ๊ฐ์ง๊ณ transistor๋ฅผ ๋ง๋ค๊ณ , ๊ทธ๊ฑธ ์ด์ฉํด gate๋ฅผ ๋ง๋ค๊ณ , ๊ณ์ํด์ ๋ ๋ณต์กํ ๊ฒ์ ๋ง๋ค์ด๋๊ฐ๋ฉฐ ISA(Instruction Set Architecture)๋ฅผ ๋ง๋ค๊ฒ์ด๊ณ , language๋ฅผ ๋ง๋ค๊ณ algorithms๋ฅผ ๋ง๋ค์ด problems๋ฅผ ํด๊ฒฐ ํ ์ ์์ ๊ฒ์ด๋ค.
(*์ฌ๊ธฐ์ transistor๊ฐ ๋ฌด์์ธ์ง, gate๊ฐ ๋ฌด์์ธ์ง ๋ฑ์ ์์ง์ ์ ํ์ ์๋ค. ๋จ์ํ ์ปดํจํฐ๊ฐ ์ ๋ฐ ๊ฒ๋ค์ด abstraction๋์ด problem์ ํด๊ฒฐํ๋ค๋ ์ ๋๋ง ์๋ฉด๋๋ค. ์ ๋ฐ ๊ฒ๋ค์ด ๋ฌด์์ธ์ง๋ ๋ค์์ ์์ธํ ๋ฐฐ์ธ ์์ ์ด๋ค.)
Universal Computing Device
์ฐ๋ฆฌ๊ฐ ์ด๋ฒ์ ์์ผํ ๊ฒ์,
'๋ชจ๋ ์ปดํจํฐ์ ์ถฉ๋ถํ ์๊ฐ๊ณผ ๋ฉ๋ชจ๋ฆฌ๊ฐ ์ฃผ์ด์ง๋ค๋ฉด, ํ๋ฆผ์์ด ๋๊ฐ์ ๊ฒ์ ํด๋ผ ์ ์๋ค'๋ ์ฌ์ค์ด๋ค.
(All computers, given enough time and memory, are capabel of computing exactly the same things.)
๋น์ฐํ ์ด๋ค ๋ฌธ์ ๋ฅผ ์ค๋งํธํฐ์์ ํธ๋ ๊ฒ๊ณผ ์ํผ์ปดํจํฐ์์ ํธ๋ ๊ฒ์ ์ฐจ์ด๊ฐ ์๊ฒ ์ง๋ง,
๊ทธ๊ฒ ์์ฒด๋ฅผ ํธ๋ power์๋ ํฐ ์ฐจ์ด๊ฐ ์๋ค. ๊ทธ๋์ ์ถฉ๋ถํ ๋ฉ๋ชจ๋ฆฌ์ ์๊ฐ์ด ์๋ค๋ฉด ๋ฌธ์ ๋ฅผ ํด๊ฒฐ ํ ์ ์๋ค๋ ์ฌ์ค์ ๊ฐ๋ค๋ ์๋ฏธ์ด๋ค.
๊ทธ๋ ๋ค๋ฉด ๊ฐ์ฅ ์์ computing device๋ ๋ฌด์์ผ๊น?
๊ฐ์ฅ ์์ ๊ฒ์ A.M.turing๊ฐ ๊ณ ์ํด๋ธ ์ํ์ ๋ชจ๋ธ์ธ turing machine์ด๋ผ๊ณ ๋ณผ ์ ์๋ค.
๊ทธ๋ฆฌ๊ณ turing์ ์ด๋ ๊ฒ ๋งํ๊ธฐ๋ ํ์๋ค.
'Every computation can be performed by some Turing machine'
์ฆ, ์ค์ ์ปดํจํ
๋ ์ ์๋ ๊ฒ์ ์์ ์ด ๊ณ ์ํ turing machine๋ก๋ ํ ์์๋ค๊ณ ๋งํ์๋ค.
์ฐ๋ฆฌ๊ฐ ์์์ ์ค๋งํธํฐ๊ณผ ์ํผ์ปดํจํฐ์ ๋ฌธ์ ํด๊ฒฐpower์๋ ์ฐจ์ด๊ฐ ์๋ค๊ณ ๋ฐฐ์ ๋ฏ์ด, turing machine์ ์์ฃผ ๊ฐ๋จํ์ง๋ง ์ฐ๋ฆฌ๊ฐ ์ค์ ๋ก ๊ณ์ฐ๊ฐ๋ฅํ ์ด๋ค ๋ฌธ์ ๋ ํ ์ ์๋ค๊ณ ๋งํ์๋ค. (*๋ฌผ๋ก ์๊ฐ์ ๋ณ๊ฐ์ ๋ฌธ์ ์ง๋ง)
์ด turing machine์๋ ๊ธฐ๋ณธ ์ ์ ๊ฐ ์๋ค. (์๋์ ๊ทธ๋ฆผ์ ์ฐธ์กฐํ์)
1. ์์ tape์ ๊ธธ์ด๊ฐ ๋ฌดํํด์ผํ๋ค.
2. head๋ ์ผ์ชฝ์ด๋ ์ค๋ฅธ์ชฝ์ผ๋ก ์์ง์ผ ์ ์๋ค.
3. ํ์ฌ head๊ฐ ์์นํ ๊ณณ์ symbol ๊ฐ์ read ํ ์ ์๊ณ , write ํ ์ ์๋ค.
๊ทธ๋ฆฌ๊ณ ์ด๋ฌํ time step์ ๊ฑฐ์น๋ค๊ณ ์๊ฐํ๋ฉด ๋๋ค.(์์ ๊ทธ๋ฆผ ์ฐธ์กฐ)
head์ ์์น์์ read - write - move(left or right)
๊ทธ๋์ ์กฐ๊ธ ๋ ์ดํด๋ฅผ ๋๊ธฐ ์ํ์ฌ Example์ ์ดํด๋ณด๋ฉด,
head๊ฐ ์์ ์ ์์น์ ์๋ symbol์ธ a๋ฅผ readํ์๊ณ ,
๊ฑฐ๊ธฐ์ ๋ํด k๋ผ๋ ๊ฐ์ write ํ์ผ๋ฉฐ,
์ดํ ์ผ์ชฝ์ผ๋ก move ํ๋ค.
(*๊ฒฐ๊ตญ์ ์์ด์ ์ต์ํด์ ธ์ผ ํ์ ์ดํดํ ๋ ์ข๊ธฐ ๋๋ฌธ์, ์ต๋ํ ์์ด๋ก ์ ์์ต๋๋ค.)
๊ทธ๋ ๋ค๋ฉด ์ด๊ฒ์ผ๋ก ์ด๋ป๊ฒ computation์ ํ ์ ์์๊น?
์๋ฅผ ๋ค์ด Cmoputableํ ์๋์ ๊ฐ์ function(ํจ์)๊ฐ ์๋ค๊ณ ํด๋ณด์.
f(x,y) = x+y (*x,y๋ integers์ ์์ด๋ค)
Turing machine์์๋ ์ด๊ฒ์ unary(1์ง๋ฒ)์ผ๋ก ํํํ๋ค.
(*1์ง๋ฒ์ ์: 5 = 11111, 2 = 11, 3 = 111)
Input string: x0y
Output string: xy0
(*input์ผ๋ก x0y๊ฐ ๋ค์ด๊ฐ๋ฉด ์ผ๋ จ์ ๊ณผ์ ์ ๊ฑฐ์ณ output์ผ๋ก xy0์ด ๋์ค๋ ๊ฒ์ด๋ค.)
๋ ์์ธํ ์ดํด๋ฅผ ๋๊ธฐ์ํด, ์ด๋ฅผ ๊ทธ๋ฆผ์ผ๋ก ํํํ๋ฉด ์๋์ ๊ฐ๋ค.
*์ฌ๊ธฐ์ โ๋ ์์๊ณผ ๋์ ์๋ฆฌ๋ ์ญํ ์ด๋ผ๊ณ ๋ณด๋ฉด๋๋ค.
*head์ q์์ ์ซ์๋ ๋ช๋ฒ์งธ state์ธ์ง ์๋ฏธํ๋ค.
*์ฌ๊ธฐ์ state๋ ๋ฒ์ญํ์ฌ ์๊ฐํ๊ธฐ๋ณด๋จ ๊ทธ๋ฅ state ๊ทธ ์์ฒด๋ก ๋ฐ์๋ค์ด๋ ๊ฒ์ด ์ข์ ๊ฒ ๊ฐ๋ค.
๊ทธ๋ฆผ์์ start ๋ถ๋ถ์ ๋ณด๋ฉด,
initial state(์ฒ์ state)์์
head๊ฐ โ์์ ์์นํ๊ณ , x์ y์ฌ์ด์ 0์ด ์์นํ ๋ชจ์ต์ ๋ณผ ์ ์๋ค.
(0์ ๋ ์ซ์๋ฅผ ๋๋๋ delimiter(๊ตฌ๋ถ์)์ญํ ์ ํ๊ณ ์๋ค)
์ด ๋ชจ์ต์ด ์์์ ๋ณด์๋ input string์ธ
x0y
๊ทธ๋ฆฌ๊ณ Finish ๋ถ๋ถ์ ๋ณด๋ฉด,
final state(๋ง์ง๋ง state)์์
head๊ฐ ๋ค์ โ์์ ์์นํ๋ฉฐ, x๊ฐ๊ณผ y๊ฐ์ด ๋ถ์ด์๊ณ ๋ง์ง๋ง์ 0์ด ์จ ๋ชจ์ต์ ๋ณผ ์ ์๋ค.
์ด ๋ชจ์ต์ด ์์์ ๋ณด์๋ output string์ธ
xy0
unary์ ํน์ฑ์,
๋จ์ํ ๋ถ์ฌ์ ์ธ์ด์ฃผ๊ธฐ๋ง ํ๋ฉด๋๋ค๋ ํน์ฑ์ ์ด์ฉํ ๊ฒ์ด๋ค.
์์ Example๋ฅผ ์ดํด๋ณด๋ฉด,
x=2, y=2 ์ผ๋, unary์ผ๋ก x=11, y=11๋ก ํํํ ์ ์๋ค.
*unary๋ ๊ฐ๋จํ ์ค๋ช
ํ์๋ฉด 1์ด๋ผ๋ ๋ง๋๊ธฐ์ ๊ฐฏ์๋ก ์ซ์๋ฅผ ํํํ๋ ๊ฒ์ด๋ค.
2๋ 1์ด๋ ์๋๊ธฐ 2๊ฐ (2=unary 11)
5๋ 1์ด๋ ์๋๊ธฐ 5๊ฐ (5=unary 11111)
๊ทธ๋์ ์ฐ๋ฆฌ๋ ์์ ๊ฐ์ด add(๋ํ๊ธฐ)๋ฅผ ํ ๋,
๊ทธ๋ฅ 1์ด๋ ์๋๊ธฐ ์๋ฅผ ํฉ์ณ์ ์ธ์ด๋ฒ๋ฆฌ๋ฉด ๋๋ ๊ฒ์ด๋ค.
2+5 ->unary->11+11111=1111111 -> 7
๊ทธ๋์ ์ด turing machine์์๋
๋จ์ํ ๋ํ๊ณ ์ ํ๋ ๋ ๊ฐ์ 0์ผ๋ก ๊ตฌ๋ถํ๊ณ ,
๋ ๊ฐ ์ฌ์ด์ 0์ ๋์ผ๋ก ์น์๋ฒ๋ฆฌ๋ฉด,
unary๋ก ํํ๋ ๋ ๊ฐ์ด ์๋์ผ๋ก add๋์ด ๋ฒ๋ฆฌ๋ ๊ฒ์ด๋ค.
๊ทธ๋ ๋ค๋ฉด ๊ฒฐ๊ตญ ์ฐ๋ฆฌ๊ฐ turing machine์ ์ด์ฉํด add๋ฅผ ํ ๋ ํ์ํ ๊ณผ์ ์
head๊ฐ ์ฒ์์์น์์
1์ด read๋๋ฉด ์ค๋ฅธ์ชฝ์ผ๋ก move ๋ฐ๋ณต,
0์ด read๋๋ฉด 1์ write,
๋ค์ 1์ด read๋๋ฉด ์ค๋ฅธ์ชฝ์ผ๋ก move ๋ฐ๋ณต,
โ๊ฐ read๋๋ฉด ์ผ์ชฝ์ผ๋ก move,
์ดํ 1์ด read๋๋ฉด 0์ผ๋ก write,
์ด์ 1์ด read๋๋ฉด ์ผ์ชฝ์ผ๋ก move ๋ฐ๋ณต,
โ๊ฐ read๋๋ฉด ์ค๋ฅธ์ชฝ์ผ๋ก move
๊ฐ ๋ ๊ฒ์ด๋ค. (์์ ๊ทธ๋ฆผ ์ฐธ์กฐ)
*์ด์ ์๊ฐ์ ๋ฐฐ์ ๋ task๋ฅผ ์ฒ๋ฆฌํ๋ 3๊ฐ์ง ๋ฐฉ๋ฒ(sequential, conditional, iterative)๋ฅผ ํจ๊ป ์๊ฐํด๋ณด๋ฉด ์ข์ ๋ฏ ํ๋ค!
Universal Turing Machine
์ฐ๋ฆฌ๋ ์์์ turing machine์ ๊ฐ๋จํ ์๋ฅผ ์ดํด๋ณด์๋ค.
์ด๋ฒ์๋ ์ฌ๋ฌ๊ฐ์ง turing machine ์ค ๊ฐ์ฅ generalํ universal turing machine์ ๋ํด์ ์์๋ณด์.
์์ ๊ทธ๋ฆผ์ ๋ณด๋ฉด,
input(์
๋ ฅ)์ผ๋ก ๋ฐ๋ ๊ฒ์ด 2๊ฐ์ธ ๊ฒ์ ๋ณผ ์ ์๋ค.
T(add), T(mul)๊ณผ a, b, c
universal turing machine์์๋ input์ ํ๋๋ก
add๊ธฐ๋ฅ์ด๋ mul(multiply๊ณฑํ๊ธฐ)๊ธฐ๋ฅ์ ๊ฐ์ง turing machine์ ๋ฐ๋๋ค.
๊ทธ๋ฆฌ๊ณ ๋ค๋ฅธ input์ผ๋ก ์ค์ ๊ณ์ฐํ data(a,b,c ๊ฐ์ ๊ฒ๋ค)๋ฅผ ๋ฐ๋๋ค๊ณ ๋ณด๋ฉด ๋๋ค.
(*ex: ์ปดํจํฐ๋ก ์๊ฐํด๋ณด๋ฉด ์ดํดํ๊ธฐ ์ฝ๋ค. ์ปดํจํฐ๋ ๋จ์ํ ๊ฐ๋ง ์ค๋ค๊ณ ๋์๊ฐ๋๊ฒ ์๋๋ผ, ํ๋ก๊ทธ๋จ์ด ์์ด์ผ ๊ฐ์ ์ค ๋ ์๋ํ๋ ๊ฒ์ฒ๋ผ, turing machine์ด๋ ํ๋ก๊ทธ๋จ์ ๋ฐ์์ data๋ฅผ ์ฒ๋ฆฌํ๋ค๊ณ ์๊ฐํ๋ฉด ๋๋ค)
*์ด๋ ต๋ค๋ฉด turing machine์ ์ํํ๋ ๋ ํฐ? turing machine์ด๋ผ๊ณ ์๊ฐํด๋ ๋ ๋ฏ ํ๋ค.
A machine that can implement all Turing machines --this is also a Turing machine!
์ด์ฒ๋ผ Universal Turing machine์ ์์์ Turing machine(program์ผ๋ก ํด์ํ ์๋ ์๋)์ ๋ฐ์๋ค์ผ ์ ์์ผ๋ฏ๋ก,
computer์ ๊ฐ์ด programmableํ๋ค๊ณ ํ ์ ์์ผ๋ฉฐ, ์ด๋ก ์ ์ผ๋ก๋ ์ด๋ฐ turing machine์ ๊ณ์ํด์ ์กฐํฉํด ๋๊ฐ๋ฉด ํ์ฌ ์ฐ๋ฆฌ๊ฐ ์ฌ์ฉํ๋ computer์ ๊ฐ์ ๊ฒ๋ ๋ง๋ค ์ ์์ ๊ฒ์ด๋ค.
Universal Turing machin is programmable - so is a computer!
-program is part of the input data
-a computer can emulate a Universal Turing Machine and vice versa
Halting Problem
์ฐ๋ฆฌ๋ ์์์ turing machine์ ์ด์ฉํด computer๊ฐ ์ด๋ค ๋ฐฉ์์ผ๋ก ์ด๋ฃจ์ด์ก๋์ง ๋ฐฐ์ ๊ณ , ์ด๋ฅผ ํตํด ์ด๋ก ์ ์ผ๋ก๋ turing machine ๋ํ computer ๋ ๊ฒ์ ์ ์ ์์๋ค.
๊ทธ๋ ๋ค๋ฉด A.M.Turing์ด ๋งํ ๊ฒ์ฒ๋ผ computation์ด ๊ฐ๋ฅํ๋ค๋ฉด ๋ชจ๋ ๋ฌธ์ ๋ฅผ ํ ์ ์์๊น?
์ด์ ๋ํด์ ์ ๋ช
ํ Halting problem์ด๋ผ๋ ๊ฒ์ด ์๋ค.
์ฐ๋ฆฌ๊ฐ ๊ธฐ๊ณ์ฅ์น๋ค์ ์ด์ฉํ๋ค๋ณด๋ฉด, ๊ธฐ๊ณ์ ์ ์์๋์ ๋ฌด๊ฐ ์ค์ํ๋ค.
ํ ๋ง๋๋ก ๊ธฐ๊ณ๊ฐ ํ์ halting(๋ฉ์ถค)๋ ์ง ์๋ ์ง ๋ง์ด๋ค.
halting problem์ ์ฐ๋ฆฌ๊ฐ ํ์ '๋ชจ๋ ' ๊ธฐ๊ณ๋ฅผ halting ๋ ์ง ์๋ ์ง '์ ํํ' ํ์
ํ ์ ์๋ ๊ธฐ๊ณ๋ฅผ ๋ง๋ค ์ ์๋์ ๋ํ ๊ณ ๋ฏผ์ด๋ค.
์ด์ ๋ํ ๋ถ๋ถ์ ์ฌ๊ณ ์คํ์ ํตํด ๋
ผ๋ฆฌ์ ์ผ๋ก ๋ถ๊ฐ๋ฅ ํ๋ค๋ ๊ฒ์ด ๋ฐํ์ก๋๋ฐ, ์์ธํ ๋ด์ฉ์ ์์ ์์์ ์ฐธ์กฐํ๋ฉด ์ดํดํ ์ ์์ ๊ฒ์ด๋ค.
*๋์ ์๊ฐ
์์ฃผ ์ค์ํ ๊ฐ๋ ์ธ abstraction์ ๋ํด ๋ฐฐ์ธ ์ ์๋ ์ฅ์ด์๋ค.
์ด์ ์ ๋ณธ ๋งํ ์ค์ ํ์ฌ netflex์๋ ์๋ 'dr.stone'๋ผ๋ ๋งํ๊ฐ ์๋ค. (๋๋ต ์ง๊ตฌ๊ฐ ๋ฉธ๋งํ๊ณ , ๊ทธ ์ํ์ด ๋ฌ์ ์์ด์ ๊ณผํ์ฒ์ฌ๊ฐ ๊ตฌ์๊ธฐ ์๋ ๋ถํฐ ๊ณผํ์ ๋ฐ์ ์ ๊ฑฐ๋ญํด์ ๋ฌ๋ก ํฅํ๋ ค ํ๋ค๋ ๋ด์ฉ์ด๋ค.)
์ฌ๊ธฐ์ ์ปดํจํฐ๋ฅผ ๋ง๋๋ ๊ณผ์ ์ด ๋์จ๋ค. ์ฌ๊ธฐ์ ์ด๋ค์ ํ๋์ ์ปดํจํฐ๋ฅผ ํ๋ด๋ด๊ธฐ ์ํด ๋๊ณผ ์์ฐ์ ์์ ๊ธ์์ ์ ์ ์ ๊ฐ๋์์ผ๋ก parametron(์ปดํจํฐ์ ๊ธฐ์ต,์ฐ์ฐ ์์)์ ๋ง๋ค๊ณ , ๊ทธ์ธ ๋ค์ํ ๋ถํ์ ํตํด ๊ฐ๋จํ turing machine๋ฅผ ๋ง๋ค์ด๋ธ๋ค.
์ดํ abstraction์ ๊ณผ์ ์ด ๋์ค๋๋ฐ, ๊ฐ๋จํ ๊ณ์ฐ ๊ณผ์ ์ ์ํ ํ ์ ์๋ ์ด๋ฌํ turing machine๋ค์ ๋ชจ์ universal turing machine์ ๋ง๋ค๊ณ ๋ค์ ์ด๊ฒ์ ๋ช ๋ง๊ฐ์ฉ ๋ง๋ค์ด์ ํจ์ฌ ๋ ๋ณต์กํ ๊ณ์ฐ์ ํ ์ ์๋ turing machine, ํ๋์ ์ปดํจํฐ์ ๊ฐ๊น์ด ๊ฒ์ ๋ง๋ค์ด๋ธ๋ค.
์ด์ฒ๋ผ ์ด๋ค ๊ณผ์ ์ ํตํด turing machine์ด computation์ ํ ์ ์๋์ง, ๊ทธ๋ฆฌ๊ณ ๋จ์ํ ์ฌ๊ธฐ์ ๋์ด ์๋๋ผ ์ด๊ฒ์ด abstraction ๋๋ฉด ์ด๋ค ์ผ์ด ์ผ์ด๋ ์ ์๋์ง ๋ฐฐ์ธ ์ ์๋ ์ฅ์ด๋ผ๊ณ ์๊ฐํ๋ค.
+์๋ฌด๋๋ haltling problem ๊ฐ์ ์ฌ๊ณ ์คํ์ ํ ์ ์๋ ๋ ผ๋ฆฌ๋ ฅ์ ๊ฐ์ถ๋ค๋ฉด, ์ดํ ์ด๋ค problem์ ํด๊ฒฐํ๊ธฐ ์ํด programming ํ ๋, ์ด๋ค ๋ฐฉ์์ผ๋ก ์ ๊ทผํด์ผ ํ๋ฉฐ ๋ฌด์์ด ๊ฐ๋ฅํ๊ณ ๋ถ๊ฐ๋ฅํ์ง ๊ณํ์ ์ธ์ฐ๋๋ฐ ํฐ ๋์์ด ๋ ๊ฒ ๊ฐ๋ค.
+abstraction์ ๊ฐ๋ ์ผ๋ก, ์ธ๊ฐ์ด ๋๋ผ๋ interface๋ฅผ ์ด์ฉํ์ฌ motor control ํ๋ ๋ฐ ์์ด์(๋ฌผ๋ก ๋๋ง์ด ๋ด๋นํ๋ ๊ฒ์ ์๋์ง๋ง) ๋ ๋ง์ ์์ด๋์ด๋ฅผ ์ป์ ์ ์๋ ์ฅ์ด๊ธฐ๋ ํ๋ค.
+์ค๋์ ์๋จ์ด
complexity ๋ณต์ก๋
building block ๊ตฌ์ฑ์์
component ์์, ๋ถํ
capable of ~ํ ์ ์๋
exactly ํ๋ฆผ์์ด, ์ ํํ
computation ๊ณ์ฐ
transition ์ดํ
integer ์ ์
unary 1์ง๋ฒ
function ํจ์
delimiter ๊ตฌ๋ถ์
implement ์ํํ๋ค
description ์์ , ์ค๋ช
vice versa ๋ฐ๋๋ ๊ฐ๋ค, ๊ฑฐ๊พธ๋ก ํด๋ ๊ฐ๋ค
emulate ํ๋ด๋ด๋ค, ์ ์ฌํ ๊ธฐ๋ฅ์ ํ ์ ์๋ค
halt ์ค๋จ, ๋ฉ์ถค
'๐ปComputer > Computer concept&practice' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
4. The Von Neumann Model (0) | 2022.05.09 |
---|---|
3. Digital Logic Structures (0) | 2022.04.30 |
2. Bits, Data Types, and Operations (0) | 2022.04.27 |
0. Introduction (0) | 2022.04.19 |