Let be a poset and be the Cartesian product with Cartesian order which is induced by the product diagram. Note if and only if where . Therefore .  Finally, for every implies .

We can also prove some properties automatically from this form. To see , just replace with ; to see replace with itself.

給定一個等價類 ，事實上這個 relation 的性質跟等式一樣，因此作 quotient set 的意義實際上是替代原本的等式，換成這個 relation，所以就有 若且唯若 這件事情。實際上構造也很簡單，就是定義 .

接下來的問題是，我們要怎麼在 quotient set 上定義函數呢？事實上就跟一般函數的定義方式一樣，取 指定對應的對象就好了。但是既然 quotient set 可以寫成 ，我們是不是能根據 來定義呢？可以的，但是數學教科書都會寫，必須是良好定義的，也就是若 ，那麼 ，白話來講，原本被看作一樣的東西，對應過去也是要一樣的。

那為甚麼在一般的集合上定義不需要呢？若是根據 的 表示來定義，事實上我們定義的是一個從原本集合 為定義域的函數，而不是 這個新的集合，而為了要說這個函數可以沿用到 上，我們自然必須檢查是否還是個集合。

若是用範疇論的語言來解釋的話，考慮 其中箭頭代表兩個投影函數 分別對應成 和 的投影而已，那麼 quotient set 事實上是該 diagram 的 coequalizer ，那麼定義   用表示來定義的函數，若是對所有 都滿足 的話，那麼自然從 coequalizer 會有一個唯一的映射到 ，而那就是 quotient set 上的函數。

用箭頭語言講的好處是，我們清楚知道是哪些物件在作用，每個步驟都是 diagram 裡的一部分，但是我們又不限定多餘的東西：誰說 quotient set 一定要是 呢？因為與 quotient set 相等的集合有很多，只要有一對一且映成的函數連結起來就夠了。

Take the matrix theory as an example. We know that change of basis doesn’t affect the matrix essentially, and the change matrix is always invertible. Therefore, we usually identify (on some level) matrices by changes of basis, i.e. . They are said to be similar. Since there are different appearances of matrices of the same type, can we have a canonical form of each type and every matrix be described by that? Luckily the answer is positive. One of answers is Jordan form.

Now, here is a question for computer scientists. Transition systems are so common in computer science as a way to model automata, concurrent systems, and the behaviour of programming languages. It usually consists of this form where means an “action” and are states. It just tells us that from the state it gets the state after performing the action .

Image that we input a number into a calculator after switching on. Originally, it showed nothing but a zero, but immediately it shows the number you just typed. Regardless of the internal states,we can say it changes from the state to the state you just typed. This is what we can observe externally.

Without any prior knowledge and tools, we can only observe that something changed on the screen. It is reasonable to assume that it is impossible to change anything observable without internally or externally triggering any changes. It reminds same if we don’t touch it, but it may switch off by itself after few minutes. However, there is still something changed inside, e.g. “something” triggering an event to “switch off”. Usually, there is no need to have a timer, but it is going to power off while there is no energy.

Beware of the difference of internal states and external states. We can only observe that it turns on and off, but we cannot definitely tell the level of power. The former is the external state we can observe and the later is the internal state that we can’t observe. To be clear, we only consider states we can observe, but we can use internal states to describe a system which leads to a notion of equivalence, bisimilarity.

Bisimilarity is the best we can say to the equivalence of systems from observations. Since the only way to know the system is to observe the behaviour, we identity systems by their behaviour. To identify them is not only merely by the set of actions, but also the behaviour after every action.

We say is a bisimulation relation if implies every and , there is some reachable from via , i.e. with and vice versa for every . Thus, we say that is bisimilar to if there exists a bisimulaion such that .

Our question is

“Is there any canonical form under bisimilarity for transition systems?”

One of attempts is to model the states itself as sets. To be precise, an unlabelled transition system consists of a set of states and a transition function . The canonical form of systems should possess the property . For a simple system only consists of one state without any move, i.e. . Its canonical form is and . Also, it seems easy to find a canonical form of any given system by replacing each state with its successor set. Let us consider the following example.

So, we have and … !?

Obviously, it doesn’t work in general! Although we can prove that any two bisimiar systems have the same canonical system, and the canonical system is bisimilar to its original system, but it only works for a very limited kind of system. Because of axiom of regularity (or, axiom of foundation) in ZFC set theory, it results that there is no infinite -sequence, namely is always finite and it is not possible that (which is just a special case of an infinite -sequence). Therefore, not only a system with any infinite traces is not allowed but also a system with is not possible to have a canonical form.

One of the solutions is to weaken ZFC set theory to include more valid sets. The simplest answer for the above problem is to drop the axiom of foundation and to require a unique solution for the above equations! Using non-well-founded set theory, we can model every transition system as a set.

Of course, we shall explain on what we mean by equations and solutions, but it should be enough to see why non-well-founded set theory is useful.

Lemma. In Cartesian closed category, where is terminal.

Proof. for all objects . Hene .

It’s also quite easy to see that since .  Hence . It’s just like that we prvoe the equality in the Heyting algebra!

Lemma. if and only if .
Proof. If , then and which imply and . Hence . The converse is quite trivial.

First, we can prove it by brute force method.

Lemma. if and only if .
Proof. Consider the following diagrams,

by replacing with , we will see that and we will have the other isomorphism by replacing with and reversing the arrows.

However, the diagram above is exactly used in Yoneda lemma, and of course we can use Yoneda lemma to prove it.

First recall that Yoneda lemma states that where is a Set-valued functor and is an object in a locally small category . Let be the hom-set functor . It gives the isomorphism between . Hence, it indeed tells you that is fully faithful. Therefore, we have the second proof.

Proof2. Given that is fully faithful, thus the natural isomorphisms actually correspond to the isomorphism and vice verse. That’s it!

well … 在 call-by-need 代表有需要值才會被計算。所以如果有一個常數函數，總是回傳資料 0 ，那麼即使傳入的參數，在 imperative language 中的運算方式不會停止，但我們仍可以得到結果。因為我們不需要去計算參數的資料，就可以得到結果了。

但這跟無窮有什麼關係呢？因為這樣的特性，所以即便我們有無窮的資料，但我們總是可以看到有限的片段，而不需要將所有的資料算出來。例如底下的 Haskell 程式

from :: Nat -> [ Nat ]
from n = n : from (n + 1)

from 是一個函數從 Nat 到 Nat 的串列用 [ Nat ] 代表，他的開頭第一個元素是  n 接下來是 from (n + 1) 該串列，而展開 from (n + 1) 的定義，又會得到它開頭是 n + 1 並且串接一個 from (n + 2)，不斷展開下去，我們得到

from n = n : n + 1 : n +2 : … : n + k : …

一直下去沒完沒了，在 imperative language 中我們避免這樣的函數，因為會讓程式進入無窮迴圈。但是在 Haskell 這樣的函數並不會直接被計算，除非你要 Haskell 展開這個函數。而我們可以定義一個函數，取出至多前面 k 個元素形成新的串列如

take :: Nat -> [Nat] -> [ Nat ]
take n [] = []
take 0 xs = []
take n xs = (head x) : (take (n – 1) (tail xs))

前面兩個代表兩種情況，一個是給定的串列是空的話，那麼就傳回空串列，第二個則是說當要取的個數為零的話，我們也回傳空串列，最後當串列不是空的而且個數也不為零，那麼我們就取出第一個元素，並且接上 take (n – 1) (tail xs)。最後的 tail xs 代表是第一個之後的串列。

所以呢，我們可以寫 take 3 (from 4) 得到 4 : 5 : 6 : [] 這樣的串列，也就是依序是 4, 5, 6 的串列，最後的 [] 代表著串列的結束。為甚麼？take 3 (from 4) ，會先展開 from 4 成 4 : from 5，然後套用第三個敘述變成 4 : take 2 (from 5)，再來是 4 : 5 : take 1 (from 6) , 4 : 5 : 6 : []。中間跳了一些步驟，有興趣可以再從網路找找資料。

另外，我們也可以定義一個自己接自己的串列如

itself :: [Nat]
itself = 3 : itself

就寫程式的方便性而言，我們不寫一個函數產生 n 到 m ，而是結合前面兩個函數來得到 n 到 m，一來重複使用我們的函數，二來會比直接寫一個 n 到 m 來得直覺一些（如果習慣這樣的方式的話）。但我們也會注意到，from n 本身是無窮的資料，但我們仍然可以得到一些資訊。從這邊得到一個，即便是無限也是有限的估計，或者說無限其實是所有有限資訊的聯集。

雖然這些還不夠精確，但希望會有個概念，在程式裡頭仍然可以擁有概念上無限的資料結構，或者當作是有限資料的極限點。不過這有機會再說吧。

我第一個學的語言，嚴格講起來應該是小學二年級的 GW-Basic，姊姊正在念高職時，借她的課本來看，稍微玩一下。不過並沒有認真學，到最後電腦只是拿來玩電動而已。在那之後過很久，高中電子辭典有些內建 gw-basic，那時候還稍微記得上課會寫些東西打發時間，但就只是玩玩而已。

接下來因緣際會學了 Python 拿來寫些小東西，一路慢慢學到 C 跟 C++ (大一)，這時候對程式語言有個想法，反正會寫了 C 之後，大部分的語言都差不多。大三修程式語言時，雖然稍微提過 Scheme（無型別的 Functional Programming），但那時只覺得礙手礙腳，看不出來有什麼必要，老師也只是丟習題下來，沒解釋太多，而該堂課就一直介紹語言設計的原則，還有如 call-by-value, call-by-reference 這些。

令人驚訝的是，大學畢業等當兵的時期，玩一些 C++ template 的泛型程式設計，以及 meta-programming 的東西，漸漸發現這東西好像以前學的 Scheme，沒有 side-effect 副作用，程式展開的基本技巧是數學歸納法，一層一層的 template 實現，玩到 meta-programming 的時候有 type list 等等奇巧淫技，還可以在 template 裡頭再包一層 template，上網搜尋 functional programming (FP) 跟 C++ template 還真有關係，不過這時候也差不多結束去當兵了。

退伍之後進入中研院，穆信成老師實驗室工作，開始學習 Haskell 跟 Agda，邊看些跟 FP 有關的基礎知識，關於 FP 有幾點是 C\C++ 等 imperative language 等沒有的。

第一個是函數是 first-class object，函數在 Haskell 裡頭就跟其他型別如整數，浮點數等一樣，可以當作參數傳來傳去，所以要寫個函數合成的程序，不過就是

comp :: (a -> b) -> (b -> c) -> (a -> c)
comp f g x = g (f x)

看起來就跟數學函數差不多！

再來是 currying 的部份，正如前面說函數是 first-class object，除了傳參數以外，也可以當作回傳值傳回來，前面的例子的型別其實是

(a -> b) -> ( (b -> c) -> (a -> c))

也就是給定一個函數 f 從 a 到 b，回傳一個函數從 (b -> c) 到 (a -> c)，函數的定義域與值域是函數空間 b ->c 跟 a -> c！所以我們可以將原本取多個參數的函數如

(a x b) -> c

取「像是」集合的卡氏積為定義域，其值域是 c，這可以轉成

a -> (b -> c)

也是給定一個元素來自 a ，傳回函數 b ->c。在 C++ 這就沒辦法輕鬆作到了。

再來是沒有副作用，一開始把程式語言的函數看作是數學上的函數，這看起來好像沒什麼問題，但是副作用的存在不能保證每次呼叫的時候，傳回來的東西都會一樣，也就是程序本身，並不是獨立於程式語言其他的部份。所以當程式出錯的時候，得把所有碰到的部份走過一遍，才能確定是哪邊出來問題。我不擅於處理太複雜的東西，所以希望簡化整合程式，用各種方式讓他看起來更有結構些，但這點副作用讓我很為難。

FP 函數沒有副作用，即便要使用變數等，也必須用其他方式明確指出這件事情。所以每次呼叫函數的時候，總是可以確定傳回來的值不會變，也因此要寫對程式，也變得比較容易，或許比較難寫些，但相較於 C\C++ 好寫但容易錯比起來，我寧願多花點時間寫正確的程式。

再來一個優點，則是因為沒有副作用，所以可以把計算過的值記起來，以便下次再呼叫的時候直接拿來用，也就是 lazy evaluation 的精神。這使得在 C\C++ 必須自己做的事情，在程式語言方面可以幫你處理。

最後非常吸引人的是，algebraic data type。例如數學上自然數基本上是定義 0 (anyway, 有時候從 1 開始)，或者是其他數字的下一個，也就是一個函數 suc 從自然數到自然數。在 Haskell 中要定義這樣的結構，只要寫

data Nat = zero | suc Nat

中間的 | 代表或者，左邊 zero 只有給一個名稱屬於 Nat；右邊是一個函數 suc 取一個 Nat 當作元素，也是屬於 Nat。類似地，要定義一個串列結構只要寫

data List a = empty | cons a (List a)

小寫的 a 是一個變數，可以是任何的型別，而右邊的 cons 長得跟 suc 有點像，不過它取一個元素來自 a 以及令一個 List a 。這同時也說明了，在 Haskell 要作 C++ template 是非常簡單的，這樣的串列不限於任何型別。我們還有稱為 polymorphic type 的型別，可以對任意的型別操作。

其他有趣的特色，例如更豐富的型別系統，可以透過 Curry-Howard isomorphism 將型別當作邏輯述句，程式本身作為推演的證明。以及更深刻的理論將型別理論連結範疇論，作為範疇論的 internal language。或者給予數學結構，發展程式邏輯（program logic），以及如何說明什麼是正確的程式。而 functional programming 也比 imperative language 適合進行程式推導，說明如何利用之中的代數結構，將程式 A 推導成程式 B 等等。

這代表我以後去 Oxford 可以住 University College 了嗎？XD