如果有一個人依照波利亞 Pólya 的思考方法去『了解問題』，

【問題】
有一個農民到集市買了一隻狐狸、一隻鵝和一袋豆子，回家時要渡過一條河。河中有一條船，但是只能裝一樣東西。而且，如果沒有人看管，狐狸會吃掉鵝，而鵝又很喜歡吃豆子。問：怎樣才能讓這些東西都安全過河？

甚至這個人還能將此問題作語文的翻譯︰

《 Fox, goose and bag of beans puzzle 》

Once upon a time a farmer went to market and purchased a fox, a goose, and a bag of beans. On his way home, the farmer came to the bank of a river and rented a boat. But in crossing the river by boat, the farmer could carry only himself and a single one of his purchases – the fox, the goose, or the bag of beans.

If left together, the fox would eat the goose, or the goose would eat the beans.

The farmer’s challenge was to carry himself and his purchases to the far bank of the river, leaving each purchase intact. How did he do it?

假使有人問此人如何求解這個問題，他還能毫不猶豫的說出答案與推導過程︰

【解答】

第一步、帶鵝過河；
第二步、空手回來；
第三步、帶狐狸〔或豆子〕過河；
第四步、帶鵝回來；
第五步、帶豆子〔或狐狸〕過河；
第六步、空手回來；
第七步、帶鵝過河。

然而他也許未必可以用 pyDatalog 語言來作『表達』！這卻又是『為什麼』的呢？難道說，波利亞的方法不管用，或是我們並不『明白』它的用法，還是我們尚且不『了解』 pyDatalog 語言，以至於無法『思考』那個『表達』之法的哩？？

如果此時我們想想那位『塞萬提斯』用長篇小說來『反騎士』，卻被『讀』成了擁有『阿 Q 精神』的『夢幻騎士』，也許該讚揚那些為『受壓迫』者發聲之人吧！或許須細思『非理性』和『不理性』概念之差別的吖！！

──

有些長期從事科學的教育者，發現數理學習的困難度，可以排列成『邏輯』<『數學』<『機率』這樣的次序。這可讓人覺得十分有意思，難道是說『必然的』<『抽象的』<『不確定』？或許人們不能輕易覺察之『無意識』的『參照點』就是對事物觀點『兩極化』的由來。就好像在《改不改？？變不變！！》一文中所談到的一些『悖論』彷彿是『腦筋急轉彎』的一般！

── 引自《物理哲學·下中………》──

 

如是如實『理解』

─── 《字詞網絡︰ WordNet 《二》 勞動離正義多遠？！》

所以 WordNet 重要性在於『概念』間的『意義聯繫』，可以用來『追跡』一個『文化』中，『概念』之『語意』的『親疏遠近』以及『階級上下』，如此構成了錯綜複雜之『語意關係』網絡。在幾何學中，兩點間的『距離』可以用『商高定理』── 也就是西方的『畢氏定理』 ── 來計算；那麼兩個『概念』之『親疏』可不可以定義『△△ 距離』的呢？有一種稱為『 Semantic Similarity 』語意相似性的『度量』，仿效『檔案系統』裡找到兩個『檔案路徑』的『共同資料夾』，再計算那『上上下下』的『階層』的『通達』路徑。如是就可以用 NLTK 算算

『勞動階級』 labor 與『正義』justice 的『語意相似度』 Semantic Similarity 是幾何？？

『字詞』表現也是一種『呈現方式』，除了它字典『意義』之外，或攜著『訴者』的『情感』，或暗示『說者』的『情緒』，也可能潛藏『講者』之『心態企圖』，或許可以藉著 WordNet 多種不同的『資料呈現』方式，作個品嚐！！

試著查察『 labor 』一字

‧ WordNet Search – 3.1

‧ Omnilexica
For all your dictionary needs!

‧ WordVis

‧ a2zdefined

‧ The Web’s Largest Resource for
Synonyms & Antonyms
A Member Of The STANDS4 Network

去感受『字詞』之表達，如何影響『讀者情意』，時而喧囂有如『鳴的鑼，響的鈸』，時而彷彿『居心叵測』般的『脣槍舌劍』。就像說

《瞧！那個人寫了這篇『可笑的』的文章》；

卻為了

《一日三大笑！健康樂逍遙》的嘛。───

 

，你將會發現這個無形的『字詞網絡』框住了人們的『思維』，此正所以換個『概念體系』常常會覺得寸步難行的吧？！故而所謂的『改寫重述』多半得是『跳脫框架』的『創造性』活動。最後就讓我們歸結到俗話所講︰一圖勝千言的耶！？

【邏輯網】

 

 

 

 

 

 

 

 

有時候『問』一個『好問題』，勝過『讀』萬卷『答案書』。就讓我們從了解什麼是『好問題』開始吧︰

已故的英國哲學家菲利帕‧福特 Philippa Foot，她於一九六七年發表了一篇名為《堕胎問题和教條雙重影響》論文，當中提出了『電車問題』，用來『批判』時下倫理哲學中之主流思想，尤其是功利主義的觀點︰

大部分之道德判斷都是依據『為最多的人謀取最大之利益』的『原则』而決定的。

她的原文引用如下︰

這個倫理學之『難題』現今有許多不同的類似之『版本』，也許是因為它是這個領域中最為知名的『思想實驗』之一的罷！！

我們就跟隨波利亞的『金科玉律』，先了解這個問題是什麼？…… ── 出自《電車問題 ── Thue 改寫系統之補充《一》》 ──

『豆鵝狐人』之問題就是

《狐狸、鵝、豆子問題》
狐狸、鵝、豆子問題〔又稱狼、羊、菜問題〕是一則古老的智力遊戲題。

【問題】
有一個農民到集市買了一隻狐狸、一隻鵝和一袋豆子，回家時要渡過一條河。河中有一條船，但是只能裝一樣東西。而且，如果沒有人看管，狐狸會吃掉鵝，而鵝又很喜歡吃豆子。問：怎樣才能讓這些東西都安全過河？

【解答】

第一步、帶鵝過河；
第二步、空手回來；
第三步、帶狐狸〔或豆子〕過河；
第四步、帶鵝回來；
第五步、帶豆子〔或狐狸〕過河；
第六步、空手回來；
第七步、帶鵝過河。

在此『問』的『問題』是︰

如何將之用 pyDatalog 語言『改寫重述』，使得可以用『程式』來執行『推理』，得到『答案』的呢？

 

 

 

 

 

 

 

 

一本老舊的書 ── 《易經》 ── ，道出了『九』的智慧與禁忌︰

乾 ䷀ ：元，亨，利，貞。

初九：潛龍，勿用。
九二：見龍再田，利見大人。
九三：君子終日乾乾，夕惕若，厲無咎。
九四：或躍在淵，無咎。
九五：飛龍在天，利見大人。
上九：亢龍有悔。
用九：見群龍無首，吉。

彖曰：大哉乾元，萬物資始，乃統天。云行雨施，品物流形。大明始終，六位時成，時乘六龍以御天。乾道變化，各正性命，保合大和，乃利貞。首出庶物，萬國咸寧。

象曰：天行健，君子以自強不息。潛龍勿用，陽在下也。 見龍再田 ，德施普也。 終日乾乾，反復道也。 或躍在淵，進無咎也。飛龍在天，大人造也。 亢龍有悔，盈不可久也。 用九，天德不可為首也。

文言曰：『元者，善之長也，亨者，嘉之會也，利者，義之和也，貞者，事之干也。 君子體仁，足以長人﹔嘉會，足以合禮﹔利物，足以和義﹔貞固，足以干事。 君子行此四者，故曰：乾：元亨利貞。』

一段考古之史 ── 《玉龜》 ── ，吟唱著『八』之起源和知識︰

【摘自《媒體中心──思創》】

 

一個聰明的人 ── 《楊輝》 ── ，著作《續古摘奇算法》，欲探『幻方』之奧秘︰

而今卻成了爭議之事，到底誰發明了《數字推盤遊戲》 ︰

如果說︰『創作』出於『人』，而『人』出於『自然』。而且講︰『自然』不出於『人』。那麼『理則』能得到『創作者』是誰的嗎？這樣看來，當下人類的智慧比『亞伯蘭』之時又真的『高明』了多少的哩！

『創世紀』第十三章『亞伯蘭』以起先『築壇的地方』分別了『左‧右』，讓『羅得』來『選擇』。這就是今天稱之為『一分‧一擇』 I cut,  you choose 的『公平分享』規範。舉例說，一人以他所認為的『公平』切蛋糕，讓另一人先作『選擇』。這也就是 Bruno de Finetti 所講的︰由此方來設定輸贏『前提』之『賠率』和『賭注』，讓彼方決定購買『前提』之『正反方』一樣。

自己跟『莫內同星座』的也許以為 ；還有一個上網『谷歌』 Google 的說『機率是零』。所謂的『客觀機率』真的是存在的嗎？因此 Bruno de Finetti 的論點，自有不可忽視的重要性，更由於『量子力學』的『量測理論』將『觀察者』放進了『不確定性』框架中，這個『主‧客觀』的爭論，目前勢將持續進行下去的吧！在此僅用『亂數產生器』的『擬似』 Pseudo 與『真實』 Real 之說來看，人們真的有『判準』來『區分』這兩者的嗎？比方講，現今所相信的『真實』之『亂數產生器』來自於那些『隨機性』的『物理現象』；常用之『擬似』的『亂數產生器』可以從某種『計算式』 裡得到。雖然說『已知』之『演算法』在『夠長的產生序列』後，難免於『重複再現』，要是真存在一個『演算法』，它的『再現所需時間』是『千百億年』的呢？那我們能『發現』它是有『公式』的嗎？？

所謂『重排九宮』的數學， pchu 先生已在

《回忆经典，讲述滑块游戏背后的数学故事》

文章中說了，於此就不再饒口多講。反倒指出『HASHTAG**』之『演算法』可以用來求解

123          4□ 2

456   →   357

78 □            816

。請讀者細細推敲背後的『邏輯法則』，好好思索『 9 留白』 □ 的『作用』，一旦領悟，也許將會心一笑耶！

【※可能在樹莓派 2B 上需要跑幾個小時】

>>> print((solution['12345678*', '4*2357816']==(Steps,Path)) >= Steps)6-9,5-6,2-5,2-3,3-6,5-6,4-5,1-4,1-2,2-5,4-5,4-7,7-8,5-8,4-5,1-4,1-2,2-3,3-6,5-6,2-5,
>>> Steps.data[0]
'6-9,5-6,2-5,2-3,3-6,5-6,4-5,1-4,1-2,2-5,4-5,4-7,7-8,5-8,4-5,1-4,1-2,2-3,3-6,5-6,2-5,'
>>> len(Steps.data[0])
84
>>> 

 

 

 

 

 

 

 

 

 

假使我們換個『觀點』來考察『HASHTAG**』的問題，也許能體會同一『抽象關係』可以擁有『眾多詮釋』，或將可以『觸類旁通』的吧。

在新的『觀點』下，我們將『所有』由『HAAHS*T*G』之『字串』依據合法移動產生的『字串』構成一個『集合』。由於『九宮格』最多不超過 9! 的『排列數』，所以這個『字串集合』也是有限的。在新的『詮釋』裡，那些『字串集合』稱之為『地名集合』，如此所謂的『合法移動』 valid movement ，就是連接兩個『可通達地』之間的『交通網』 。雖說此『交通網』是有限的，然而用著之前

《勇闖新世界︰ 《 pyDatalog 》 導引《七》》文本中所講之

『台北捷運網』的『連接』述詞來定義︰

連接( □, ○) 代表 □ 捷運站，僅經過 □ 站，直通 ○ 捷運站，方向是 □ → ○。

，顯然是有些不切實際的哩！因此我們用著『有車』── 兩地間有『 * 』 ── 這樣的述詞來『捕捉』這個『交通網』的『性質』︰

有車(X地, N1月台, N2月台)  <=  (X地[N1月台] == ‘*’)
有車(X地, N1月台, N2月台)  <=  (X地[N2月台] == ‘*’)

於是『坐上車』者，或將能由此地『直達』彼地，或者尋路『能通 』另一處的 吧！如是把 Pcarbonn 先生的程式『再譯』如下︰

 

from pyDatalog import pyDatalog, pyEngine
import time

pyDatalog.create_terms('有車, 直達,能通,X地,Y地,N月台,N1月台,N2月台')
pyDatalog.create_terms('X1,X2,X3,X4,X5,X6,X7,X8,X9')
pyDatalog.create_terms('Z1,Z2,Z3,Z4,Z5,Z6,Z7,Z8,Z9')
pyDatalog.create_terms('P1月台,P2月台')

# X地在 N1月台 或 N2月台處有一顆星 "*"
有車(X地,N1月台,N2月台) <= (X地[N1月台]=='*')
有車(X地,N1月台,N2月台) <= (X地[N2月台]=='*')

# 可能的直達法 1<->2, 1<->4, ... 
X處 = (X1,X2,X3,X4,X5,X6,X7,X8,X9) # short hand
直達(X處, 1, 2, Y地) <= 有車(X處, 0, 1) & (Y地 == (X2,X1,X3,X4,X5,X6,X7,X8,X9))
直達(X處, 1, 4, Y地) <= 有車(X處, 0, 3) & (Y地 == (X4,X2,X3,X1,X5,X6,X7,X8,X9))

直達(X處, 2, 3, Y地) <= 有車(X處, 1, 2) & (Y地 == (X1,X3,X2,X4,X5,X6,X7,X8,X9))
直達(X處, 2, 5, Y地) <= 有車(X處, 1, 4) & (Y地 == (X1,X5,X3,X4,X2,X6,X7,X8,X9))

直達(X處, 3, 6, Y地) <= 有車(X處, 2, 5) & (Y地 == (X1,X2,X6,X4,X5,X3,X7,X8,X9))

直達(X處, 4, 5, Y地) <= 有車(X處, 3, 4) & (Y地 == (X1,X2,X3,X5,X4,X6,X7,X8,X9))
直達(X處, 4, 7, Y地) <= 有車(X處, 3, 6) & (Y地 == (X1,X2,X3,X7,X5,X6,X4,X8,X9))

直達(X處, 5, 6, Y地) <= 有車(X處, 4, 5) & (Y地 == (X1,X2,X3,X4,X6,X5,X7,X8,X9))
直達(X處, 5, 8, Y地) <= 有車(X處, 4, 7) & (Y地 == (X1,X2,X3,X4,X8,X6,X7,X5,X9))

直達(X處, 6, 9, Y地) <= 有車(X處, 5, 8) & (Y地 == (X1,X2,X3,X4,X5,X9,X7,X8,X6))

直達(X處, 7, 8, Y地) <= 有車(X處, 6, 7) & (Y地 == (X1,X2,X3,X4,X5,X6,X8,X7,X9))
直達(X處, 8, 9, Y地) <= 有車(X處, 7, 8) & (Y地 == (X1,X2,X3,X4,X5,X6,X7,X9,X8))

# 能通之法或 X地 到 Y地 直達， 
# 或先經由若干 Z處，再由 Z處 往 Y地 直達。
Z處 = (Z1,Z2,Z3,Z4,Z5,Z6,Z7,Z8,Z9)
(能通[X地, Y地] == N月台) <= 直達(X地, P1月台, P2月台, Y地) & (N月台 == [(P1月台, P2月台)])
(能通[X地, Y地] == N月台) <= (能通[X地, Z處] == N1月台) & 直達(Z處, P1月台, P2月台, Y地) & (N月台 == N1月台 + [(P1月台, P2月台)])

# ?? 到底要花多少時間計算！！
pyDatalog.create_terms('所有路徑, P路徑甲, P路徑乙')
所有路徑(X地, Y地, P路徑甲) <= 直達(X地, P1月台, P2月台, Y地) & (P路徑甲 == [(P1月台, P2月台)])

所有路徑(X地, Y地, P路徑甲) <= 所有路徑(X地, Z處, P路徑乙) & 直達(Z處, P1月台, P2月台, Y地) & (X地 != Y地) & (P路徑甲 == P路徑乙 + [(P1月台, P2月台)])

start_time = time.time()

print((所有路徑[list('HAAHS*T*G'), list('HASHTAG**')] == N月台) >= N月台)
# prints 5-6,2-5,2-3,3-6,5-6,7-8,5-8,8-9,7-8,
print("Computed in %f seconds" % (time.time() - start_time))

 

看來想要搭上車，還得先『計算』出這車之『起』至『止』路徑中之『地名』的呢！在此我們將略為探討一下這個『演算』的性質，歸結到 Pcarbonn 先生選擇『邏輯函式』 Logic Functions 來建置的原因。因而我們將用

表達

直達(X處,  Pα月台, Pβ月台, Y地)

這個事實。可以推導出如果

，那麼

，這也是最小的『循環路徑』。事實上這個『交通網』有多個循環路徑，舉例說可以發生在九宮格『1, 2, 5, 4,1』、『1,2,3,6,5,4,1』、『1,2,3,6,9,8,7,4,1』……等處，只要其中一個『位置』上『有星』。因此從『此地』往『彼處』的路徑，就可能不只有『一種』走法，要是考察『多個』循環路徑之情況，我們將如何『限制』最長路徑的呢？由於一個最小的『循環路徑』 ── 比方講 ( P1, P4 )  ──，可以藉著 『1, 2, 5, 4,1』來作『表達』，那麼一個『一般路徑』可能是難以想像的『長』吧！如此『所有路徑』『演算法』，只靠著『頭尾』之『不同』── X地 != Y地 ── 可不可能『中止』計算的呢？？

在數學上『有沒有』解答是一種『存在性』的問題。『找到』一個『解答』，可以『證明』了那個『存在性』的問題有解！那要怎麼證明『無解』的呢？意味『所有』的解都『不存在』！就像證明 不是『有理數』一般，我們必須要證明沒有一個『有理數』是 。所以 Pcarbonn 先生選擇『邏輯函式』大概是想先『找到一個解』吧，畢竟『函式』在『定義』上，就只有『唯一值』的啊。更不要說 pyDatalog 語言『最佳化』之『推理引擎』運作方法是怎樣哩！那麼『HAAHS*T*G』裡有『兩顆星』，難到不意味著『至少有兩個 』解嘛！！

 

 

 

 

 

 

 

人們如何從『程式範例』中學習？？程式是否能說話，展現想表達的意義！！

【改寫能不能了解更多？】

from pyDatalog import pyDatalog, pyEngine
import time

pyDatalog.create_terms('有星, 穿越,求解,X地,Y地,N星門,N1星門,N2星門')
pyDatalog.create_terms('X1,X2,X3,X4,X5,X6,X7,X8,X9')
pyDatalog.create_terms('Z1,Z2,Z3,Z4,Z5,Z6,Z7,Z8,Z9')
pyDatalog.create_terms('P1星門,P2星門')

# X地在 N1星門 或 N2星門處有一顆星 "*"
有星(X地, N1星門, N2星門) <= (X地[N1星門] == '*')
有星(X地, N1星門, N2星門) <= (X地[N2星門] == '*')

# 合法的穿越法 1 <-> 2, 1 <-> 4, ... 
X處 = (X1,X2,X3,X4,X5,X6,X7,X8,X9) # 簡記
穿越(X處, 1, 2, Y地) <= 有星(X處, 0, 1) & (Y地 == (X2,X1,X3,X4,X5,X6,X7,X8,X9))
穿越(X處, 1, 4, Y地) <= 有星(X處, 0, 3) & (Y地 == (X4,X2,X3,X1,X5,X6,X7,X8,X9))

穿越(X處, 2, 3, Y地) <= 有星(X處, 1, 2) & (Y地 == (X1,X3,X2,X4,X5,X6,X7,X8,X9))
穿越(X處, 2, 5, Y地) <= 有星(X處, 1, 4) & (Y地 == (X1,X5,X3,X4,X2,X6,X7,X8,X9))

穿越(X處, 3, 6, Y地) <= 有星(X處, 2, 5) & (Y地 == (X1,X2,X6,X4,X5,X3,X7,X8,X9))

穿越(X處, 4, 5, Y地) <= 有星(X處, 3, 4) & (Y地 == (X1,X2,X3,X5,X4,X6,X7,X8,X9))
穿越(X處, 4, 7, Y地) <= 有星(X處, 3, 6) & (Y地 == (X1,X2,X3,X7,X5,X6,X4,X8,X9))

穿越(X處, 5, 6, Y地) <= 有星(X處, 4, 5) & (Y地 == (X1,X2,X3,X4,X6,X5,X7,X8,X9))
穿越(X處, 5, 8, Y地) <= 有星(X處, 4, 7) & (Y地 == (X1,X2,X3,X4,X8,X6,X7,X5,X9))

穿越(X處, 6, 9, Y地) <= 有星(X處, 5, 8) & (Y地 == (X1,X2,X3,X4,X5,X9,X7,X8,X6))

穿越(X處, 7, 8, Y地) <= 有星(X處, 6, 7) & (Y地 == (X1,X2,X3,X4,X5,X6,X8,X7,X9))
穿越(X處, 8, 9, Y地) <= 有星(X處, 7, 8) & (Y地 == (X1,X2,X3,X4,X5,X6,X7,X9,X8))

# 求解之法或 X地 到 Y地 直接穿越，
# 或先經由若干 Z處，再由 Z處 往 Y地 直接穿越。
Z處 = (Z1,Z2,Z3,Z4,Z5,Z6,Z7,Z8,Z9)
(求解[X地, Y地] == N星門) <= 穿越(X地, P1星門, P2星門, Y地) & (N星門 == [(P1星門, P2星門)])
(求解[X地, Y地] == N星門) <= (求解[X地, Z處] == N1星門) & 穿越(Z處, P1星門, P2星門, Y地) & (N星門 == N1星門 + [(P1星門, P2星門)])

start_time = time.time()

print((求解[list('HAAHS*T*G'), list('HASHTAG**')] == N星門) >= N星門)
# prints 5-6,2-5,2-3,3-6,5-6,7-8,5-8,8-9,7-8,
print("Computed in %f seconds" % (time.time() - start_time))

# 執行結果

>>> start_time = time.time()
>>> print((求解[list('HAAHS*T*G'), list('HASHTAG**')] == N星門) >= N星門)
((7, 8), (5, 6), (2, 5), (2, 3), (3, 6), (5, 6), (5, 8), (8, 9), (7, 8))
>>> print("Computed in %f seconds" % (time.time() - start_time))
Computed in 96.248452 seconds
>>> 

 

【線上可不可試驗未知？】

#
>>> dir(Y地)
['_UserList__cast', '__abstractmethods__', '__add__', '__call__', '__class__', '__cmp__', '__contains__', '__delattr__', '__delitem__', '__delslice__', '__dict__', '__div__', '__doc__', '__eq__', '__floordiv__', '__format__', '__ge__', '__getattr__', '__getattribute__', '__getitem__', '__gt__', '__hash__', '__iadd__', '__imul__', '__init__', '__iter__', '__le__', '__len__', '__lt__', '__module__', '__mul__', '__ne__', '__neg__', '__new__', '__pos__', '__pow__', '__radd__', '__rdiv__', '__reduce__', '__reduce_ex__', '__repr__', '__reversed__', '__rfloordiv__', '__rmul__', '__rpow__', '__rsub__', '__rtruediv__', '__setattr__', '__setitem__', '__setslice__', '__sizeof__', '__str__', '__sub__', '__subclasshook__', '__truediv__', '__unicode__', '__weakref__', '_abc_cache', '_abc_negative_cache', '_abc_negative_cache_version', '_abc_registry', '_data', '_in', '_not_in', '_pyD_atomized', '_pyD_for', '_pyD_lua', '_pyD_name', '_pyD_negated', '_pyD_precalculations', '_pyD_type', '_pyD_value', '_pyD_variables', '_value', 'append', 'count', 'data', 'extend', 'in_', 'index', 'insert', 'is_variable', 'make_for_prefix', 'not_in_', 'pop', 'remove', 'reverse', 'sort', 'todo', 'v']
>>> 

>>> help(Y地)

>>> print(Y地.__doc__)

 can be constant, list, tuple, variable or predicate name
 ask() creates a query
 

 

【逐步驗證有沒有好處？】

#
>>> print(穿越(list('HAAHS*T*G'), 7, 8, Y地))
Y地                                           
---------------------------------------------
('H', 'A', 'A', 'H', 'S', '*', '*', 'T', 'G')

>>> Y地.data[0]
('H', 'A', 'A', 'H', 'S', '*', '*', 'T', 'G')

>>> print(穿越(list(Y地.data[0]), 5, 6, Y地))
Y地                                           
---------------------------------------------
('H', 'A', 'A', 'H', '*', 'S', '*', 'T', 'G')

>>> print(穿越(list(Y地.data[0]), 2, 5, Y地))
Y地                                           
---------------------------------------------
('H', '*', 'A', 'H', 'A', 'S', '*', 'T', 'G')

>>> print(穿越(list(Y地.data[0]), 2, 3, Y地))
Y地                                           
---------------------------------------------
('H', 'A', '*', 'H', 'A', 'S', '*', 'T', 'G')

>>> print(穿越(list(Y地.data[0]), 3, 6, Y地))
Y地                                           
---------------------------------------------
('H', 'A', 'S', 'H', 'A', '*', '*', 'T', 'G')

>>> print(穿越(list(Y地.data[0]), 5, 6, Y地))
Y地                                           
---------------------------------------------
('H', 'A', 'S', 'H', '*', 'A', '*', 'T', 'G')

>>> print(穿越(list(Y地.data[0]), 5, 8, Y地))
Y地                                           
---------------------------------------------
('H', 'A', 'S', 'H', 'T', 'A', '*', '*', 'G')

>>> print(穿越(list(Y地.data[0]), 8, 9, Y地))
Y地                                           
---------------------------------------------
('H', 'A', 'S', 'H', 'T', 'A', '*', 'G', '*')

>>> print(穿越(list(Y地.data[0]), 7, 8, Y地))
Y地                                           
---------------------------------------------
('H', 'A', 'S', 'H', 'T', 'A', 'G', '*', '*')
>>> 

 

#
>>> print(穿越(list('HAAHS*T*G'), 5, 6, Y地))
Y地 
---------------------------------------------
('H', 'A', 'A', 'H', '*', 'S', 'T', '*', 'G')

>>> print(穿越(list(Y地.data[0]), 2, 5, Y地))
Y地 
---------------------------------------------
('H', '*', 'A', 'H', 'A', 'S', 'T', '*', 'G')

>>> print(穿越(list(Y地.data[0]), 2, 3, Y地))
Y地 
---------------------------------------------
('H', 'A', '*', 'H', 'A', 'S', 'T', '*', 'G')

>>> print(穿越(list(Y地.data[0]), 3, 6, Y地))
Y地                                           
---------------------------------------------
('H', 'A', 'S', 'H', 'A', '*', 'T', '*', 'G')

>>> print(穿越(list(Y地.data[0]), 5, 6, Y地))
Y地                                           
---------------------------------------------
('H', 'A', 'S', 'H', '*', 'A', 'T', '*', 'G')

>>> print(穿越(list(Y地.data[0]), 7, 8, Y地))
Y地                                           
---------------------------------------------
('H', 'A', 'S', 'H', '*', 'A', '*', 'T', 'G')

>>> print(穿越(list(Y地.data[0]), 5, 8, Y地))
Y地                                           
---------------------------------------------
('H', 'A', 'S', 'H', 'T', 'A', '*', '*', 'G')

>>> print(穿越(list(Y地.data[0]), 8, 9, Y地))
Y地                                           
---------------------------------------------
('H', 'A', 'S', 'H', 'T', 'A', '*', 'G', '*')

>>> print(穿越(list(Y地.data[0]), 7, 8, Y地))
Y地                                           
---------------------------------------------
('H', 'A', 'S', 'H', 'T', 'A', 'G', '*', '*')
>>> 

 

【怎樣追跡計算過程？】

#
# 注意 print 述詞攔截 python 語言之 print() 函式
>>> pyDatalog.create_terms('追跡, P啞元, print')

>>> (追跡[X地, Y地] == N星門) <= 穿越(X地, P1星門, P2星門, Y地) & (N星門 == [(P1星門, P2星門)]) & (P啞元 == print("穿越: ", N星門))

追跡[2]==(*,X地,Y地,N星門) <= 穿越(X地,P1星門,P2星門,Y地)&==(N星門

>>> (追跡[X地, Y地] == N星門) <= (求解[X地, Z處] == N1星門) & 穿越(Z處, P1星門, P2星門, Y地) & (N星門 == N1星門 + [(P1星門, P2星門)]) & (P啞元 == print("經由: ", N1星門, "再穿越: ", (P1星門, P2星門)))

追跡[2]==(*,X地,Y地,N星門) <= 求解[2]==(*,X地,'["('f', 'Z1'

# 追跡 ((7, 8), (5, 6), (2, 5), (2, 3), (3, 6), (5, 6), (5, 8), (8, 9), (7, 8)) 解，注意記憶效應。
>>> print((追跡[list('HAAHS*T*G'), list('HAAHS**TG')] == N星門) >= N星門)
經由:  ((7, 8), (3, 6)) 再穿越:  (3, 6)
((7, 8), (3, 6), (3, 6))

>>> print((追跡[list('HAAHS*T*G'), list('HAAH*S*TG')] == N星門) >= N星門)
經由:  ((5, 6),) 再穿越:  (7, 8)
((5, 6), (7, 8))

>>> print((追跡[list('HAAHS*T*G'), list('H*AHAS*TG')] == N星門) >= N星門)
經由:  ((5, 6), (2, 5)) 再穿越:  (7, 8)
((5, 6), (2, 5), (7, 8))

>>> print((追跡[list('HAAHS*T*G'), list('HA*HAS*TG')] == N星門) >= N星門)
經由:  ((5, 6), (2, 5), (2, 3)) 再穿越:  (7, 8)
((5, 6), (2, 5), (2, 3), (7, 8))

>>> print((追跡[list('HAAHS*T*G'), list('HASHA**TG')] == N星門) >= N星門)
經由:  ((5, 6), (2, 5), (2, 3), (3, 6)) 再穿越:  (7, 8)
((5, 6), (2, 5), (2, 3), (3, 6), (7, 8))

>>> print((追跡[list('HAAHS*T*G'), list('HASH*A*TG')] == N星門) >= N星門)
經由:  ((5, 6), (2, 5), (2, 3), (3, 6), (5, 6)) 再穿越:  (7, 8)
((5, 6), (2, 5), (2, 3), (3, 6), (5, 6), (7, 8))

>>> print((追跡[list('HAAHS*T*G'), list('HASHTA**G')] == N星門) >= N星門)
經由:  ((7, 8), (5, 6), (2, 5), (2, 3), (3, 6), (5, 6)) 再穿越:  (5, 8)
((7, 8), (5, 6), (2, 5), (2, 3), (3, 6), (5, 6), (5, 8))

>>> print((追跡[list('HAAHS*T*G'), list('HASHTAG**')] == N星門) >= N星門)
經由:  ((7, 8), (5, 6), (2, 5), (2, 3), (3, 6), (5, 6), (5, 8), (8, 9)) 再穿越:  (7, 8)
((7, 8), (5, 6), (2, 5), (2, 3), (3, 6), (5, 6), (5, 8), (8, 9), (7, 8))

# 追跡 5-6,2-5,2-3,3-6,5-6,7-8,5-8,8-9,7-8, 解，注意計算轉折處。
>>> print((追跡[list('HAAHS*T*G'), list('HAAH*ST*G')] == N星門) >= N星門)
經由:  ((5, 6),) 再穿越:  (5, 8)
((5, 6), (5, 8))

>>> print((追跡[list('HAAHS*T*G'), list('H*AHAST*G')] == N星門) >= N星門)
經由:  ((5, 6),) 再穿越:  (2, 5)
((5, 6), (2, 5))

>>> print((追跡[list('HAAHS*T*G'), list('HA*HAST*G')] == N星門) >= N星門)
經由:  ((5, 6), (2, 5)) 再穿越:  (2, 3)
((5, 6), (2, 5), (2, 3))

>>> print((追跡[list('HAAHS*T*G'), list('HASHA*T*G')] == N星門) >= N星門)
經由:  ((5, 6), (2, 5), (2, 3)) 再穿越:  (3, 6)
((5, 6), (2, 5), (2, 3), (3, 6))

>>> print((追跡[list('HAAHS*T*G'), list('HASH*AT*G')] == N星門) >= N星門)
經由:  ((5, 6), (2, 5), (2, 3), (3, 6)) 再穿越:  (5, 6)
((5, 6), (2, 5), (2, 3), (3, 6), (5, 6))

>>> print((追跡[list('HAAHS*T*G'), list('HASH*A*TG')] == N星門) >= N星門)
經由:  ((5, 6), (2, 5), (2, 3), (3, 6), (5, 6)) 再穿越:  (7, 8)
((5, 6), (2, 5), (2, 3), (3, 6), (5, 6), (7, 8))

>>> print((追跡[list('HAAHS*T*G'), list('HASHTA**G')] == N星門) >= N星門)
經由:  ((7, 8), (5, 6), (2, 5), (2, 3), (3, 6), (5, 6)) 再穿越:  (5, 8)
((7, 8), (5, 6), (2, 5), (2, 3), (3, 6), (5, 6), (5, 8))

>>> print((追跡[list('HAAHS*T*G'), list('HASHTA*G*')] == N星門) >= N星門)
經由:  ((7, 8), (5, 6), (2, 5), (2, 3), (3, 6), (5, 6), (5, 8)) 再穿越:  (8, 9)
((7, 8), (5, 6), (2, 5), (2, 3), (3, 6), (5, 6), (5, 8), (8, 9))

>>> print((追跡[list('HAAHS*T*G'), list('HASHTAG**')] == N星門) >= N星門)
經由:  ((7, 8), (5, 6), (2, 5), (2, 3), (3, 6), (5, 6), (5, 8), (8, 9)) 再穿越:  (7, 8)
((7, 8), (5, 6), (2, 5), (2, 3), (3, 6), (5, 6), (5, 8), (8, 9), (7, 8))
>>> 

 

【意圖與邏輯是不是同意的耶？】

上面程式中這個子句有道理嗎

(追跡[X地, Y地] == N星門) <= (求解[X地, Z處] == N1星門) & 穿越(Z處, P1星門, P2星門, Y地) & (N星門 == N1星門 + [(P1星門, P2星門)]) & (P啞元 == print(“經由: “, N1星門, “再穿越: “, (P1星門, P2星門)))

或許應該改作

(追跡[X地, Y地] == N星門) <= (追跡[X地, Z處] == N1星門) & 穿越(Z處, P1星門, P2星門, Y地) & (N星門 == N1星門 + [(P1星門, P2星門)]) & (P啞元 == print(“經由: “, N1星門, “再穿越: “, (P1星門, P2星門)))

 

如是走過了一番，算不算是學會了一種『方法學』

吃著魚釣魚，有何不可

的呢？？！！