ticoAg/ChineseCorpus-Kaggle-fanti huggingface dataset:
*  Marvel Comics Database: Nova (Richard Rider)
新星軍團，是漫威漫畫中的虛構星際軍事／警察部隊組織，由創作。新星軍團首次於《驚奇4超人》#204中登場。
新星軍團原本是的一個宇宙民兵和探索組織，由500名士兵組成，軍階由部隊隊員到百夫長和領導新星至尊。新星軍團的力量被稱為「新星之力」，由名為「柴達星世界智慧」的生命電腦生成的無限能量。
新星軍團和柴達星曾三度被破壞：分別被外星人Zorr、宇宙海盜涅布拉和。新星軍團亦曾與史克魯爾人進行一場代價高昂的戰爭。
* 《銀河守護隊》：葛倫·克蘿絲飾演新星至尊，新星軍團的最高指揮官。約翰·C·萊利和飾演新星軍團隊員和高級軍官。力量寶石曾由新星軍團保管，後被薩諾斯奪去。被問到新星的個人電影，詹姆斯·岡恩說：「我認為總有一個機會給新星電影的。」
*  Nova Corps  漫畫書數據庫
*  Nova Corps  超級英雄數據庫
*  Marvel Comics Database: Nova Corps
込江海翔（，）是日本男演員，隸屬于。
當他們認真編織時
張祎，吳郡（治今江蘇省蘇州市）人，東晉末年官員。
張祎少年時就有操守。晉安帝末年，為瑯邪王司馬德文屬下的郎中令。司馬德文繼皇帝位為晉恭帝，劉裕以張祎是恭帝的故吏，平素就是恭帝的親信。于是封好毒酒給張祎，讓他毒殺皇帝。張祎受命嘆道：“毒死皇帝而為自己求生，我有何面目活著，不如死了！”于是自飲毒酒而死。
OBROJECT，是韓國Rainbow Bridge World於2014年推出的兄弟男子組合。於2014年9月17日發行數位單曲《OBroject’s Best Friend》正式出道。
Oh Tae Seok
yuNdAk
Yoon Dak
Oh Yun Seok
吳臺錫曾參加過2011年《K-pop Star 1》取得Top18的成績，2012年發行單曲《REBIRTH Part 3 – Why》，2014年《That's OK(?????)》參與專輯合唱。
吳潤錫曾參加KB國民銀行饒舌大會《我也是 Rapper》獲得第二季優勝，2012年發行首張mixtape《YUNDAK Dawn Cock MIXTAPE》，2014年發行mixtape《?? ???? ?????》。
《?????`s Best Friend》
* 唱片公司：Rainbow Bridge World
# Best Friend(Feat. ??? of ????)
# Best Friend (Inst.)
* 發行公司：CJ E&M MUSIC
# ??????(Feat. 李玹雨, Bromance)
# ?????? (Inst.)
* 發行公司：TSN COMPANY
# ??? ???(Feat. ?? of ??)
# ??? ??? (Inst.)(Feat. ?? of ??)
《Those Were The Days》
* 唱片公司：TSN COMPANY、Rainbow Bridge World
《甜心戰士》（、'）是2004年上映的日本特攝電影，改編自永井豪的同名漫畫，由庵野秀明執導、佐藤江梨子主演。
企畫從2000年就開始了，但選角一直陷入困境，企畫重啟時預算也少了很多。到完成影片耗時近4年，在此期間主演佐藤江梨子和主題曲演唱者倖田來未的人氣不斷上升。以及當時有多部真人化電影上映，引起不小的話題。但是票房卻慘敗，制作公司トワーニ也隨之倒閉。片中的動畫片段獲得了很高的評價，直接用于之后的OVA動畫《Re: 甜心戰士》。
“秘密結社?豹爪”四天王之一綁走宇津木博士，警視廳的秋夏子警部對其抓捕打擊，最后如月甜心變身為愛的戰士Cutie Honey方將其擊退。豹爪繼續大肆破壞，秋夏子和Cutie Honey聯合起來與之對抗。Cutie Honey的身世也逐漸浮出水面。最后在合作下將豹爪的頭目擊敗。
:; Cutie Honey
:: 作詞：巖崎富士男 / 作曲：渡辺岳夫 / 編曲：h-wonder / 演唱：倖田來未
:; Into your heart
:: 作詞?作曲：渡辺未來 / 編曲：h-wonder / 演唱：倖田來未
:; シスター?ジルのテーマ
:: 作詞：Sachi Bennett / 作曲：野田晴稔 / 編曲：斎藤修 / 演唱：倖田來未
:; 夜霧甜心
:: 作詞：伊藤皓 / 作曲：渡辺岳夫 / 編曲：西川玲生 / 演唱：倖田來未
:; ブラック?クロー參上
:: 作詞：庵野秀明 / 作?編曲：遠藤幹雄 / 演唱：及川光博
* 佐藤江梨子 — 如月甜心/Cutie Honey
* 松田龍平 (友情出演) — NSA委托人
* 京本政樹 (特別出演) — リョウ宇津木
* 吉田日出子 — 掃除的阿姨 (鬼谷京子)
* 井口昇、、三木俊一郎、轟木一騎、大崎章、出渕裕、山賀博之、神谷誠、金剛地武志、田中良、吉田瑞穗、橫山誠、しりあがり壽
* 導演助理：、摩砂雪、仁同正明
* 人物設定：寺田克也、安野夢洋子、出渕裕、すぎむらしんいち、貞本義行
* 制作人：甘木モリオ、川端基夫
* 製作者：加賀義二、加藤鉄也
* 發行?宣傳：華納兄弟 (日本)
* 制片商：トワーニ（東芝、華納兄弟、日本電視放送網）
* 製作：Cutie Honey製作委員會（トワーニ、VAP 、日本電視音樂、BANDAI、WOWOW、東急娛樂、LATERNA）
讓-安德烈·德呂克，瑞士地質學家、自然哲學家暨氣象學家，曾發明過一些測量儀器。
1727年2月8日，德呂克出生在日內瓦，其家族在15世紀從意大利盧卡遷至瑞士。他的父親雅克-弗朗索瓦·德呂克（Jacques-Fran?ois Deluc）曾寫過一些駁斥伯納德·曼德維爾及其他理性主義作家的文章，但卻是讓-雅克·盧梭的堅定支持者。
讓-安德烈·德呂克早年師從喬治-路易斯·雷薩吉（Georges-Louis Le Sage），接受過基本的數學和自然哲學教育。成年后除了在阿爾卑斯山做過一段時間的科學調查外，大部分時間主要經商。在他兄弟紀堯姆·安托因（Guillaume-Antoine）的幫助下，他收集了大量精美的礦物和化石。
德呂克也參與過政治，1768年他被派到巴黎舒瓦瑟爾公爵身邊，并很快取得了公爵的信任。1770年成為駐日內瓦的200位政務委員之一。
三年后，由于生意失敗，他被迫離鄉，此后僅短暫地回來過一次。這一改變使他放棄了對政治的追求，并遺憾地于1773年移居英國，在那里他被任命為夏洛特王后的侍講，在這一職位上一做就是44年，這也給他帶來了安逸的生活和穩定的收入。
盡管他宮職在身，但在此期間還是被允許到瑞士、法國、荷蘭和德國等地做過幾趟旅行。到德國之初（1798年-1804年），就獲得了有助于掩蓋喬治三世國王外交使命的哥廷根大學哲學和地質學榮譽教授職位。回到英國后，他進行了一次國家地質考察（1804年-1807年）。
1773年，德呂克入選為英國皇家學會會員，他也是法國科學院通訊院士及其他幾個學會成員。在從事研究工作近70年后，他于1817年11月7日在英國伯克郡溫莎去世。月球上的德呂克隕石坑就是以他的名字命名的。
德呂克的主要興趣是地質學和氣象學，喬治·居維葉曾提到他是前一學科的權威。他的主要地質著作-獻給夏洛特王后的《論山脈和地球及人類史的自然和道德之信》（1778年-1780年），他也發表過有關地質游記的著作：《在北歐》（1810年）、《在英國》（1811年）、《在法國、瑞士和德國》（1813年）。
德呂克注意到冰融化過程中熱量的消失，同一時間的約瑟夫·布萊克曾將其視作潛熱說的基礎。他查明水在華氏40度（攝氏4度）時的密度最大（而不是在冰點），他是這一理論的創始人，后被約翰·道爾頓進一步引伸為任何空間中的水蒸氣含量均獨立于空氣或其他任何彈性流體的密度。
他在寫給約翰·弗里德里希·布盧門巴赫《論地球自然史的信件》中（巴黎，1798年），依照六天創世之說將地球劃分為六個時期，其中還包含有一篇關于道德實在論的文章，并對伏爾泰與盧梭的對話給出了有趣的解釋。德呂克是弗蘭西斯·培根的忠實崇拜者，在他的兩部著作：1800年發表于柏林的《真實的培根》（Bacon tel qu'il est）中表現出法國譯者的不誠信，故意省略了許多有利于揭示宗教的片段；而在二卷八開，1802年在巴黎發表的《準確的培根哲學》中（Précis de la philosophie de Bacon），對自然科學的進步提出一種有趣的觀點。1803年發表于柏林和漢諾威的《基督教信件》（Lettres sur le christianisme）是與柏林的威廉·亞伯拉罕·泰勒（Wilhelm Abraham Teller）就摩西天體演化學進行爭議的通信；他的《地質學基礎論綱》（1809年發表于巴黎，同年由亨利·德拉·福特譯成英文版）主要是為了反駁詹姆斯·赫頓和約翰·普萊費爾的火成論，他們證明了地殼形成于內熱和侵蝕活動，但該學說地殼形成所需時間要比德呂克的摩西多樣性水成論認為的更長。
他還在《物理學報》、《自然科學會報》及《哲學雜志》上發表過許多其他的論文。
德呂克將大部分工作用于完善或發明測量儀器。
他曾設計了一種用于地質勘探的便攜式氣壓計。他的《大氣層變化研究》（Recherches sur les modifications de l'atmosphère，2卷4開，1772年發表于日內瓦；1784年在巴黎再版，4卷）包含了水分、蒸發試驗以及濕度計和溫度計說明。 他用氣壓表測定高度，《自然科學會報》曾報導過他的一種新濕度計，類似于水銀溫度計，有一個象牙球，受濕膨脹后，會使水銀柱下降。他后來又設計出一種鯨須濕度計，但引發了一場與奧拉斯-貝內迪克特·德索敘爾的激烈爭論，德索敘爾本人是毛發濕度計的發明者。他給出了借助氣壓計測量高度的第一條正確規則，德呂克主張在溫度計中使用汞而非酒精。
1809年，他給皇家學會寄去了一篇通過伏打電堆電效應分離化學物質，以及描述干式電堆和空氣驗電器的長篇論文，由于其中的觀點與當時最新發現相抵觸，因而，該論文未被《自然科學會報》采納。德呂克所描述的干式電堆是由各科學家所構造，他的改進被認為是他最重要的研究，盡管實際上他并不是它真正的發明者。德呂克是年輕的弗朗西斯·羅納茲（Francis Ronalds）的重要導師，羅納茲曾在1814年-1815年發表過數篇有關干電堆的重要論文。
德魯克最后幾十年的生活沉湎于對神學研究中，在與赫頓的爭論中，“雖然從沒有懷疑過赫頓是一名無神論者，但德魯克還是指責過他反無神論的觀點并不鮮明” 。
他專注于用觀測資料來證明圣經中的創世之說。在他《自然和道德之信》中，把創世六天解釋為地球的前紀元，并把洪水歸因于是對地球內部空穴的灌注。
瑪蒂娜·庫利巴利-埃伯特（Martina K?lbl-Ebert）在《地質與宗教》（Geology and Religion）曾對該問題作過詳細討論。
* 《一種新式濕度計》，《自然科學會報》，63/2, 1773年, 第404–460頁。
* 《哈茲礦井深度的氣壓觀測》，67/2, 1777年, 第401–550頁。
* 《地質學初論》(1809年);Google圖書,p.PR1 亨利·德拉·福特譯(1831年).
* 《地質游記》,倫敦, 1810年–1811年(共3卷): 《北歐游記》(第1卷); 《英格蘭游記》(第2-3卷).
* 《顯示物體間摩擦電效應的電機實驗:》, 倫敦, 1811年.
* 《法國、瑞士和德國部分地區地質游記》: 第1卷(1813年)；第2卷(1813年)；第3卷(1811年)， Google圖書
* 《致布盧門巴赫教授論地球自然史的信件》, 倫敦, 1831年(附有亨利·德拉·福特的導言和插圖).
* e-rara.ch 中的文獻列表
* 在自然科學會報中發表的文章
* 讓-安德烈·德呂克（1779年–1780年）《關于地球和人類歷史的物理和道德之信》, 5 卷.''–來自琳達霍爾圖書館的數字傳真
* 讓-安德烈·德呂克（1810年–1811年）《地質游記》. 3 卷.'' （英文）–來自琳達霍爾圖書館的數字傳真
* Heilbron, John L.; Sigrist, René (ed.). ''Jean-André Deluc, historian of earth and man''. Geneva: Slatkine 2011.
* Michaud, Joseph-Fran?ois; Michaud, Louis Gabriel. "Luc (Jean-André de)". ''Biographie universelle, ancienne et moderne'', vol.&nbsp;25. 1820
* Sigrist, René. "Deluc, Jean-André". ''Dictionnaire historique de la Suisse'' . Also available in German and Italian.
+ 民安鎮高車村
高車村位于中國廣西的東南部，高車村位于北流市東北面，與容縣交界，有洛湛鐵路、廣南高速路出口等交通優越，礦石資源豐富。全村管轄27個村民小組，現有人口7869人，農戶1634戶，耕地面積2895畝；村黨委下設3個支部，黨員112名。
互遞歸是數學與計算機科學中一種遞歸，指兩個數學或計算機對象如函數或數據類型互相定義。互遞歸在函數程式語言或某些問題域中非常常見，如，其中數據類型是自然地互相遞歸定義的。
采取互遞歸定義的最重要的基本數據類型是樹。這可以用于定義森林（樹的列表）:
t: v f
森林''f''由一棵樹的列表組成，同時一棵樹''t''由一對：值''v''與森林''f'' (子樹)構成。這種定義是精致的，易于工作的抽象性（如用于證明關于樹的屬性的定理），因為它用簡單術語表示一棵樹：一個類型的列表，兩個類型組成的一對。而且它匹配許多關于樹的算法，這些對值做一些事，對子樹做另外一些事。
這種互遞歸定義可以轉換為單個遞歸，這是通過森林定義內部化：
一顆樹''t''包含一對：值''v''與子樹的列表。這個定義更緊致，但是更難以處理：一棵樹是一種類型的值與另一種類型的列表組成的一對，這要求解析開以證明結果。
在Standard ML，樹與森林可互遞歸定義如下，允許空樹：
datatype 'a tree = Empty | Node of 'a * 'a forest
and      'a forest = Nil | Cons of 'a tree * 'a forest
如同在遞歸數據類型上的算法可以自然由遞歸函數給出，互遞歸數據結構上的算法可自然地由互遞歸函數給出。常見例子包括樹與遞歸下降解析器。如同直接遞歸，對遞歸深度很大或者是無窮的情形尾調用優化是必須的，如使用互遞歸的多任務。注意一般的尾調用優化比作為特例情況的尾遞歸調用優化更難實現，因此有效實現互尾遞歸未被很多語言考慮。對Pascal語言要求先聲明后使用，互遞歸要求前向聲明。
如同直接遞歸函數，包裝函數（wrapper function）對互遞歸函數是有用的作為包裝函數的作用域內的（如果支持的話）。這對跨多個函數共享狀態而不直接傳遞參數特別有用。
一個例子用于確定奇偶數。 C語言：
bool is_even(unsigned int n) {
return is_odd(n - 1);
bool is_odd(unsigned int n) {
return is_even(n - 1);
這套函數是基于對問題''4是偶數?''等價于''3是奇數?''，依次等價于''2是偶數?''，直到0. 這個例子是相互，很容易改寫為迭代。這個例子中的互遞歸是尾調用，尾調用優化是必須的以能在常量大小棧空間完成計算。C語言這要求''O''(''n'')棧空間，除非重寫用跳轉代替調用。
Python語言實現樹的例子:
def f_tree(tree):
f_value(tree.value)
f_forest(tree.children)
def f_forest(forest):
for tree in forest:
f_tree(tree)
遞歸下降解析器可以自然地實現為每個對應一個函數，就可以是互遞歸、多遞歸，因為產生式規則一般要組合多個部分。
互遞歸也可以實現有限狀態機，每個函數表示一個狀態，這要求尾遞歸優化因為狀態變遷可能是非常大或無限的。互遞歸可用于，以代替協程。
有些算法自然地分成兩個階段，如minimax算法，每個階段可以用一個函數實現。
數學上，是一對整數序列用互遞歸方式定義的例子。
分形可用遞歸函數計算。有時用互遞歸計算更為精致，如。
互遞歸在函數程式語言風格中是常用的，如Lisp, Scheme, ML語言等。Prolog中互遞歸是不可避免。
彼德·諾米格不提倡使用互遞歸：
互遞歸也稱，與相對。
數學上，一套互遞歸函數是原始遞歸函數, 可通過證明, 構造單個函數''F''依次列出單個遞歸函數的值: ，重寫互遞歸為原始遞歸。
任何兩個過程之間的互遞歸可以轉換為直接遞歸，這通過把一個過程內聯至另一個過程實現。
任何數量的互遞歸過程可以合并為單一過程，這通過標簽聯合 (一種)表示選擇過程與它的參數。這可以看作的有限應用.
*  Mutual recursion at Rosetta Code
* " Example demonstrating good use of mutual recursion", " Are there any example of Mutual recursion?", ''Stack Overflow''
張祎，字冠章，唐朝大臣。南陽（治今河南省南陽市）人，張正甫的孫子。
張祎出仕歷任汴州從事、戶部判官、藍田尉、集賢校理。趙隱擔任浙西觀察使，劉鄴擔任淮南節度使，都征辟他為賓佐。入朝為監察御史，轉任左補闕。乾符年間，唐僖宗下詔讓他入翰林為學士，官至中書舍人。中和元年，黃巢率領變民軍進攻長安，張祎隨僖宗逃往四川，拜為工部侍郎，判戶部事。奉命出使江淮回朝，和當權者不和，改任太子賓客、左散騎常侍，后來轉任吏部侍郎，歷任刑部尚書、兵部尚書。隨從唐昭宗在華州，被韓建陷害，貶為衡州司馬。唐昭宗還京，征張祎為禮部尚書、太常卿，充禮儀使，轉任兵部尚書。
張祎用心寫文章，年老更加勤奮。擔任刑部尚書時，劉鄴的兒子劉覃，當黃巢攻打長安時避禍在金吾將軍張直方家中，被害。唐僖宗還京，討厭劉覃的人說他依附逆黨，不是因為正義而死，皇帝命令三司審查他的罪行。張祎上書申辯，說劉覃父子都死在黃巢手中，怎么能說是附逆？劉覃家得到昭雪，劉覃被追贈官位。張祎行義自始至終，都像這樣。《全唐詩》存詩二首。
李術，汝南人，東漢末年人物。
199年，孫策駆逐廬江郡太守劉勛，孫策任命李術為廬江太守，給他士兵三千人鎮守。他截殺了曹操任命的揚州刺史嚴象。200年，孫策去世後，李術不服孫權，接納亡命叛孫之人。孫權寫信要求他扣留這些亡叛者。李術表示有德見歸，無德見叛，不應復還。孫權于是起兵派孫河、徐琨到皖城攻打李術。李術閉門自守，向曹操求救。曹操不救。糧食已盡，婦女或吞丸泥充饑。孫權屠其城，將李術梟首，遷徙他的部曲三萬余人。
*《三國志·孫策傳》注引《江表傳》
*《三國志·吳主傳》注引《江表傳》
共遞歸在計算機科學重視一類操作，與遞歸在范疇論上對偶。因而遞歸是分析地工作，把數據分解為更小的數據直至達到基本情況。共遞歸是合成地工作，從基本情況構造出數據。共遞歸的數據是自己一點一點構造出來的。一個類似但不同的概念是''生成式遞歸''（generative recursion）。
共遞歸常與惰性求值配合，產生一個潛在無窮結構的有限子集。
Corecursion can be understood by contrast with recursion, which is more familiar. While corecursion is primarily of interest in functional programming, it can be illustrated using imperative programming, which is done below using the generator facility in Python. In these examples local variables are used, and assigned values imperatively (destructively), though these are not necessary in corecursion in pure functional programming. In pure functional programming, rather than assigning to local variables, these computed values form an invariable sequence, and prior values are accessed by self-reference (later values in the sequence reference earlier values in the sequence to be computed). The assignments simply express this in the imperative paradigm and explicitly specify where the computations happen, which serves to clarify the exposition.
A classic example of recursion is computing the factorial, which is defined recursively as  and
To ''recursively'' compute its result on a given input, a recursive function calls (a copy of) ''itself'' with a different ("smaller" in some way) input and uses the result of this call to construct its result. The recursive call does the same, unless the ''base case'' has been reached. Thus a call stack develops in the process. For example, to compute ''fac(3)'', this recursively calls in turn ''fac(2)'', ''fac(1)'', ''fac(0)'' ("winding up" the stack), at which point recursion terminates with ''fac(0) = 1'', and then the stack unwinds in reverse order and the results are calculated on the way back along the call stack to the initial call frame ''fac(3)'', where the final result is calculated as ''3*2 =: 6'' and finally returned. In this example a function returns a single value.
This stack unwinding can be explicated, defining the factorial ''corecursively'', as an iterator, where one ''starts'' with the case of , then from this starting value constructs factorial values for increasing numbers ''1, 2, 3...'' as in the above recursive definition with "time arrow" reversed, as it were, by reading it ''backwards'' as  The corecursive algorithm thus defined produces a ''stream'' of ''all'' factorials. This may be concretely implemented as a generator. Symbolically, noting that computing next factorial value requires keeping track of both ''n'' and ''f'' (a previous factorial value), this can be represented as:
or in Haskell,
(\(n,f) -> (n+1, f*(n+1))) `iterate` (0,1)
meaning, "starting from , on each step the next values are calculated as ". This is mathematically equivalent and almost identical to the recursive definition, but the  emphasizes that the factorial values are being built ''up'', going forwards from the starting case, rather than being computed after first going backwards, ''down'' to the base case, with a  decrement. Note also that the direct output of the corecursive function does not simply contain the factorial  values, but also includes for each value the auxiliary data of its index ''n'' in the sequence, so that any one specific result can be selected among them all, as and when needed.
Note the connection with denotational semantics, where the denotations of recursive programs is built up corecursively in this way.
In Python, a recursive factorial function can be defined as:
def factorial(n):
if n == 0:
return n * factorial(n - 1)
This could then be called for example as factorial(5) to compute ''5!''.
A corresponding corecursive generator can be defined as:
def factorials:
n, f = 0, 1
yield f
n, f = n + 1, f * (n + 1)
This generates an infinite stream of factorials in order; a finite portion of it can be produced by:
def n_factorials(k):
while n
This could then be called to produce the factorials up to ''5!'' via:
for f in n_factorials(5):
print(f)
If we're only interested in a certain factorial, just the last value can be taken, or we can fuse the production and the access into one function,
def nth_factorial(k):
As can be readily seen here, this is practically equivalent (just by substituting return for the only yield there) to the accumulator argument technique for tail recursion, unwound into an explicit loop. Thus it can be said that the concept of corecursion is an explication of the embodiment of iterative computation processes by recursive definitions, where applicable.
In the same way, the Fibonacci sequence can be represented as:
Note that because the Fibonacci sequence is a recurrence relation of order 2, the corecursive relation must track two successive terms, with the  corresponding to shift forward by one step, and the  corresponding to computing the next term. This can then be implemented as follows (using parallel assignment):
def fibonacci_sequence:
In Haskell,  map fst ( (\(a,b) -> (b,a+b)) `iterate` (0,1) )
Tree traversal via a depth-first approach is a classic example of recursion. Dually, breadth-first traversal can very naturally be implemented via corecursion.
Without using recursion or corecursion, one may traverse a tree by starting at the root node, placing the child nodes in a data structure, then removing the nodes in the data structure in turn and iterating over its children. If the data structure is a stack (LIFO), this yields depth-first traversal, while if the data structure is a queue (FIFO), this yields breadth-first traversal.
Using recursion, a (post-order) depth-first traversal can be implemented by starting at the root node and recursively traversing each child subtree in turn (the subtree based at each child node) – the second child subtree does not start processing until the first child subtree is finished. Once a leaf node is reached or the children of a branch node have been exhausted, the node itself is visited (e.g., the value of the node itself is outputted). In this case, the call stack (of the recursive functions) acts as the stack that is iterated over.
Using corecursion, a breadth-first traversal can be implemented by starting at the root node, outputting its value, then breadth-first traversing the subtrees – i.e., passing on the ''whole list'' of subtrees to the next step (not a single subtree, as in the recursive approach) – at the next step outputting the value of all of their root nodes, then passing on their child subtrees, etc. In this case the generator function, indeed the output sequence itself, acts as the queue. As in the factorial example (above), where the auxiliary information of the index (which step one was at, ''n'') was pushed forward, in addition to the actual output of ''n''!, in this case the auxiliary information of the remaining subtrees is pushed forward, in addition to the actual output. Symbolically:
v,t = (, FullTree) : (RootValues, ChildTrees)
meaning that at each step, one outputs the list of values of root nodes, then proceeds to the child subtrees. Generating just the node values from this sequence simply requires discarding the auxiliary child tree data, then flattening the list of lists (values are initially grouped by level (depth); flattening (ungrouping) yields a flat linear list).
These can be compared as follows. The recursive traversal handles a ''leaf node'' (at the ''bottom'') as the base case (when there are no children, just output the value), and ''analyzes'' a tree into subtrees, traversing each in turn, eventually resulting in just leaf nodes – actual leaf nodes, and branch nodes whose children have already been dealt with (cut off ''below''). By contrast, the corecursive traversal handles a ''root node'' (at the ''top'') as the base case (given a node, first output the value), treats a tree as being ''synthesized'' of a root node and its children, then produces as auxiliary output a list of subtrees at each step, which are then the input for the next step – the child nodes of the original root are the root nodes at the next step, as their parents have already been dealt with (cut off ''above''). Note also that in the recursive traversal there is a distinction between leaf nodes and branch nodes, while in the corecursive traversal there is no distinction, as each node is treated as the root node of the subtree it defines.
Notably, given an infinite tree, the corecursive breadth-first traversal will traverse all nodes, just as for a finite tree, while the recursive depth-first traversal will go down one branch and not traverse all nodes, and indeed if traversing post-order, as in this example (or in-order), it will visit no nodes at all, because it never reaches a leaf. This shows the usefulness of corecursion rather than recursion for dealing with infinite data structures.
The usual post-order depth-first traversal can be defined as:
def df(node):
if node is not None:
df(node.left)
df(node.right)
print(node.value)
This can then be called by df(t) to print the values of the nodes of the tree in post-order depth-first order.
The breadth-first corecursive generator can be defined as:
def bf(tree):
tree_list = tree
while tree_list:
new_tree_list =
for tree in tree_list:
if tree is not None:
yield tree.value
new_tree_list.append(tree.left)
new_tree_list.append(tree.right)
tree_list = new_tree_list
This can then be called to print the values of the nodes of the tree in breadth-first order:
for i in bf(t):
Initial data types can be defined as being the least fixpoint (up to isomorphism) of some type equation; the isomorphism is then given by an initial algebra. Dually, final (or terminal) data types can be defined as being the greatest fixpoint of a type equation; the isomorphism is then given by a final coalgebra.
If the domain of discourse is the category of sets and total functions, then final data types may contain infinite, non-wellfounded values, whereas initial types do not. On the other hand, if the domain of discourse is the category of complete partial orders and continuous functions, which corresponds roughly to the Haskell programming language, then final types coincide with initial types, and the corresponding final coalgebra and initial algebra form an isomorphism.
Corecursion is then a technique for recursively defining functions whose range (codomain) is a final data type, dual to the way that ordinary recursion recursively defines functions whose domain is an initial data type.
The discussion below provides several examples in Haskell that distinguish corecursion. Roughly speaking, if one were to port these definitions to the category of sets, they would still be corecursive. This informal usage is consistent with existing textbooks about Haskell. Also note that the examples used in this article predate the attempts to define corecursion and explain what it is.
The rule for ''primitive corecursion'' on codata is the dual to that for primitive recursion on data. Instead of descending on the argument by pattern-matching on its constructors (that ''were called up before'', somewhere, so we receive a ready-made datum and get at its constituent sub-parts, i.e. "fields"), we ascend on the result by filling-in its "destructors" (or "observers", that ''will be called afterwards'', somewhere - so we're actually calling a constructor, creating another bit of the result to be observed later on). Thus corecursion ''creates'' (potentially infinite) codata, whereas ordinary recursion ''analyses'' (necessarily finite) data.  Ordinary recursion might not be applicable to the codata because it might not terminate.  Conversely, corecursion is not strictly necessary if the result type is data, because data must be finite.
In "Programming with streams in Coq: a case study: the Sieve of Eratosthenes" we find
hd (conc a s) = a
tl (conc a s) = s
(sieve p s) = if div p (hd s) then sieve p (tl s)
else conc (hd s) (sieve p (tl s))
hd (primes s) = (hd s)
tl (primes s) = primes (sieve (hd s) (tl s))
where primes "are obtained by applying the primes operation to the stream (Enu 2)". Following the above notation, the sequence of primes (with a throwaway 0 prefixed to it) and numbers streams being progressively sieved, can be represented as
(\(p, s@(h:t)) -> (h, sieve h t)) `iterate` (0, 2..)
The authors discuss how the definition of sieve is not guaranteed always to be ''productive'', and could become stuck e.g. if called with 5,10.. as the initial stream.
Here is another example in Haskell. The following definition produces the list of Fibonacci numbers in linear time:
This infinite list depends on lazy evaluation;  elements are computed on an as-needed basis, and only finite prefixes are ever explicitly represented in memory. This feature allows algorithms on parts of codata to terminate; such techniques are an important part of Haskell programming.
This can be done in Python as well:
from itertools import tee, chain, islice, imap
def add(x, y):
def fibonacci:
def deferred_output:
for i in output:
result, c1, c2 = tee(deferred_output, 3)
paired = imap(add, c1, islice(c2, 1, None))
output = chain(0, 1, paired)
for i in islice(fibonacci, 20):
The definition of zipWith can be inlined, leading to this:
fibs = 0 : 1 : next fibs
next (a: t@(b:_)) = (a+b):next t
This example employs a self-referential ''data structure''.   Ordinary recursion makes use of self-referential ''functions'',   but does not accommodate self-referential data.   However,  this is not essential to the Fibonacci example.    It can be rewritten as follows:
fibs = fibgen (0,1)
fibgen (x,y) = x : fibgen (y,x+y)
This employs only self-referential ''function'' to construct the result. If it were used with strict list constructor it would be an example of runaway recursion, but with non-strict list constructor this guarded recursion gradually produces an indefinitely defined list.
Corecursion need not produce an infinite object; a corecursive queue is a particularly good example of this phenomenon.   The following definition produces a breadth-first traversal of a binary tree in linear time:
data Tree a b = Leaf a
Branch b (Tree a b) (Tree a b)
bftrav :: Tree a b -> Tree a b
bftrav tree = queue
queue = tree : gen 1 queue
gen  0   p                 =
gen len (Leaf   _     : s) =         gen (len-1) s
gen len (Branch _ l r : s) = l : r : gen (len+1) s
This definition takes an initial tree and produces a list of subtrees.   This list serves dual purpose as both the queue and the result (''gen len p'' produces its output ''len'' notches after its input back-pointer, ''p'', along the ''queue'').  It is finite if and only if the initial tree is finite.  The length of the queue must be explicitly tracked in order to ensure termination;  this can safely be elided if this definition is applied only to infinite trees.
Another particularly good example gives a solution to the problem of breadth-first labeling. The function label visits every node in a binary tree in a breadth first fashion,  and replaces each label with an integer,  each subsequent integer is bigger than the last by one.   This solution employs a self-referential data structure,  and the binary tree can be finite or infinite.
label :: Tree a b -> Tree Int Int
label t = t′
(t′, ns) = go t (1:ns)
go :: Tree a b    -> Int  -> (Tree Int Int, Int)
go   (Leaf   _    ) (n:ns) = (Leaf   n       , n+1 : ns  )
go   (Branch _ l r) (n:ns) = (Branch n l′ r′ , n+1 : ns′′)
(l′, ns′ ) = go l ns
(r′, ns′′) = go r ns′
An apomorphism (such as an anamorphism, such as unfold) is a form of corecursion in the same way that a paramorphism (such as a catamorphism, such as fold) is a form of recursion.
The Coq proof assistant supports corecursion and coinduction using the CoFixpoint command.
Corecursion, referred to as ''circular programming,'' dates at least to , who credits John Hughes and Philip Wadler; more general forms were developed in . The original motivations included producing more efficient algorithms (allowing 1 pass over data in some cases, instead of requiring multiple passes) and implementing classical data structures, such as doubly linked lists and queues, in functional languages.
安徽安納達鈦業股份有限公司 （，英文：Anhui Annada Titanium Industry Co.,Ltd.，簡稱：安納達），是中國深圳證券交易所的一家上市公司，主要從事鈦白粉產品的生產和銷售。公司成立于2005年3月23日，2007年5月30日在深圳證券交易所上市。公司旗下“安納達”牌鈦白粉為“安徽名牌產品”，“安納達”商標為“安徽省著名商標”。
2016年，公司實現營業收入8.19億元，凈利潤0.43億。
*  安徽安納達鈦業股份有限公司
乙酰丙酮雙氧鉬是鉬的乙酰丙酮配合物之一，化學式為MoO2(acac)2。