A Functional Language for Logarithmic Space

More than being just a tool for expressing algorithms, a well-designed programming language allows the user to express her ideas efficiently. The design choices however effect the efficiency of the algorithms written in the languages. It is therefore important to understand how such choices effect t...

Ausführliche Beschreibung

Gespeichert in:
Bibliographische Detailangaben
1. Verfasser: Neergaard, Peter Møller
Format: Buchkapitel
Sprache:eng
Schlagworte:
Online-Zugang:Volltext
Tags: Tag hinzufügen
Keine Tags, Fügen Sie den ersten Tag hinzu!
container_end_page 326
container_issue
container_start_page 311
container_title
container_volume 3302
creator Neergaard, Peter Møller
description More than being just a tool for expressing algorithms, a well-designed programming language allows the user to express her ideas efficiently. The design choices however effect the efficiency of the algorithms written in the languages. It is therefore important to understand how such choices effect the expressibility of programming languages. The paper pursues the very low complexity programs by presenting a first-order function algebra BC\documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{mathrsfs} \usepackage{upgreek} \setlength{\oddsidemargin}{-69pt} \begin{document}$^{\rm -}_{\epsilon}$\end{document} that captures exactly lf, the functions computable in logarithmic space. This gives insights into the expressiveness of recursion. The important technical features of BC\documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{mathrsfs} \usepackage{upgreek} \setlength{\oddsidemargin}{-69pt} \begin{document}$^{\rm -}_{\epsilon}$\end{document} are (1) a separation of variables into safe and normal variables where recursion can only be done over the latter; (2) linearity of the recursive call; and (3) recursion with a variable step length (course-of-value recursion). Unlike formulations of LF via Turing machines, BC\documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{mathrsfs} \usepackage{upgreek} \setlength{\oddsidemargin}{-69pt} \begin{document}$^{\rm -}_{\epsilon}$\end{document} makes no references to outside resource measures, e.g., the size of the memory used. This appears to be the first such characterization of LF-computable functions (not just predicates). The proof that all BC\documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{mathrsfs} \usepackage{upgreek} \setlength{\oddsidemargin}{-69pt} \begin{document}$^{\rm -}_{\epsilon}$\end{document}-programs can be evaluated in lf is of separate interest to programmers: it trades space for time and evaluates recursion with at most one recursive call without a call stack.
doi_str_mv 10.1007/978-3-540-30477-7_21
format Book Chapter
fullrecord <record><control><sourceid>proquest_pasca</sourceid><recordid>TN_cdi_pascalfrancis_primary_16335515</recordid><sourceformat>XML</sourceformat><sourcesystem>PC</sourcesystem><sourcerecordid>EBC3087772_28_321</sourcerecordid><originalsourceid>FETCH-LOGICAL-p272t-cc13ccc5c156b1f631ef9ac257f742bfa2ee5048759d70bf4bac31beb5fd7dd93</originalsourceid><addsrcrecordid>eNotkLtOwzAUhs1VhNI3YMjChAy2jx3XI6ooIEViAGbLcew0kCbBTgfeHvdyliP9t-FD6JaSB0qIfFRygQELTjAQLiWWmtETNE8yJHGvyVOU0YJSDMDVGbreGQwk4-QcZSnCsJIcLlGmki9VKl6heYzfJB0woRhk6P4pX217O7VDb7q8NH2zNY3L_RDycmhMaKf1prX5x2isu0EX3nTRzY9_hr5Wz5_LV1y-v7wtn0o8MskmbC0Fa62wVBQV9QVQ55WxTEgvOau8Yc4JwhdSqFqSyvPKWKCVq4SvZV0rmKG7w-5oojWdD6a3bdRjaDcm_GlaAAhBRcqxQy4mq29c0NUw_ERNid4h1ImVBp2g6D0uvUOYSnAcD8Pv1sVJu13Lun4KprNrM04uxNRYJMBMszSRWv91Lm4q</addsrcrecordid><sourcetype>Index Database</sourcetype><iscdi>true</iscdi><recordtype>book_chapter</recordtype><pqid>EBC3087772_28_321</pqid></control><display><type>book_chapter</type><title>A Functional Language for Logarithmic Space</title><source>Springer Books</source><creator>Neergaard, Peter Møller</creator><contributor>Chin, Wei-Ngan ; Chin, Wei-Ngan</contributor><creatorcontrib>Neergaard, Peter Møller ; Chin, Wei-Ngan ; Chin, Wei-Ngan</creatorcontrib><description>More than being just a tool for expressing algorithms, a well-designed programming language allows the user to express her ideas efficiently. The design choices however effect the efficiency of the algorithms written in the languages. It is therefore important to understand how such choices effect the expressibility of programming languages. The paper pursues the very low complexity programs by presenting a first-order function algebra BC\documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{mathrsfs} \usepackage{upgreek} \setlength{\oddsidemargin}{-69pt} \begin{document}$^{\rm -}_{\epsilon}$\end{document} that captures exactly lf, the functions computable in logarithmic space. This gives insights into the expressiveness of recursion. The important technical features of BC\documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{mathrsfs} \usepackage{upgreek} \setlength{\oddsidemargin}{-69pt} \begin{document}$^{\rm -}_{\epsilon}$\end{document} are (1) a separation of variables into safe and normal variables where recursion can only be done over the latter; (2) linearity of the recursive call; and (3) recursion with a variable step length (course-of-value recursion). Unlike formulations of LF via Turing machines, BC\documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{mathrsfs} \usepackage{upgreek} \setlength{\oddsidemargin}{-69pt} \begin{document}$^{\rm -}_{\epsilon}$\end{document} makes no references to outside resource measures, e.g., the size of the memory used. This appears to be the first such characterization of LF-computable functions (not just predicates). The proof that all BC\documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{mathrsfs} \usepackage{upgreek} \setlength{\oddsidemargin}{-69pt} \begin{document}$^{\rm -}_{\epsilon}$\end{document}-programs can be evaluated in lf is of separate interest to programmers: it trades space for time and evaluates recursion with at most one recursive call without a call stack.</description><identifier>ISSN: 0302-9743</identifier><identifier>ISBN: 3540237240</identifier><identifier>ISBN: 9783540237242</identifier><identifier>EISSN: 1611-3349</identifier><identifier>EISBN: 9783540304777</identifier><identifier>EISBN: 3540304770</identifier><identifier>DOI: 10.1007/978-3-540-30477-7_21</identifier><identifier>OCLC: 934979835</identifier><identifier>LCCallNum: QA76.76.C65</identifier><language>eng</language><publisher>Germany: Springer Berlin / Heidelberg</publisher><subject>Applied sciences ; Complexity Class ; Computer science; control theory; systems ; Exact sciences and technology ; Logarithmic Space ; Normal Argument ; Programming languages ; Recursive Call ; Software ; Turing Machine</subject><ispartof>Lecture notes in computer science, 2004, Vol.3302, p.311-326</ispartof><rights>Springer-Verlag Berlin Heidelberg 2004</rights><rights>2005 INIST-CNRS</rights><lds50>peer_reviewed</lds50><woscitedreferencessubscribed>false</woscitedreferencessubscribed><relation>Lecture Notes in Computer Science</relation></display><links><openurl>$$Topenurl_article</openurl><openurlfulltext>$$Topenurlfull_article</openurlfulltext><thumbnail>$$Uhttps://ebookcentral.proquest.com/covers/3087772-l.jpg</thumbnail><linktopdf>$$Uhttps://link.springer.com/content/pdf/10.1007/978-3-540-30477-7_21$$EPDF$$P50$$Gspringer$$H</linktopdf><linktohtml>$$Uhttps://link.springer.com/10.1007/978-3-540-30477-7_21$$EHTML$$P50$$Gspringer$$H</linktohtml><link.rule.ids>309,310,777,778,782,787,788,791,4038,4039,27908,38238,41425,42494</link.rule.ids><backlink>$$Uhttp://pascal-francis.inist.fr/vibad/index.php?action=getRecordDetail&amp;idt=16335515$$DView record in Pascal Francis$$Hfree_for_read</backlink></links><search><contributor>Chin, Wei-Ngan</contributor><contributor>Chin, Wei-Ngan</contributor><creatorcontrib>Neergaard, Peter Møller</creatorcontrib><title>A Functional Language for Logarithmic Space</title><title>Lecture notes in computer science</title><description>More than being just a tool for expressing algorithms, a well-designed programming language allows the user to express her ideas efficiently. The design choices however effect the efficiency of the algorithms written in the languages. It is therefore important to understand how such choices effect the expressibility of programming languages. The paper pursues the very low complexity programs by presenting a first-order function algebra BC\documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{mathrsfs} \usepackage{upgreek} \setlength{\oddsidemargin}{-69pt} \begin{document}$^{\rm -}_{\epsilon}$\end{document} that captures exactly lf, the functions computable in logarithmic space. This gives insights into the expressiveness of recursion. The important technical features of BC\documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{mathrsfs} \usepackage{upgreek} \setlength{\oddsidemargin}{-69pt} \begin{document}$^{\rm -}_{\epsilon}$\end{document} are (1) a separation of variables into safe and normal variables where recursion can only be done over the latter; (2) linearity of the recursive call; and (3) recursion with a variable step length (course-of-value recursion). Unlike formulations of LF via Turing machines, BC\documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{mathrsfs} \usepackage{upgreek} \setlength{\oddsidemargin}{-69pt} \begin{document}$^{\rm -}_{\epsilon}$\end{document} makes no references to outside resource measures, e.g., the size of the memory used. This appears to be the first such characterization of LF-computable functions (not just predicates). The proof that all BC\documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{mathrsfs} \usepackage{upgreek} \setlength{\oddsidemargin}{-69pt} \begin{document}$^{\rm -}_{\epsilon}$\end{document}-programs can be evaluated in lf is of separate interest to programmers: it trades space for time and evaluates recursion with at most one recursive call without a call stack.</description><subject>Applied sciences</subject><subject>Complexity Class</subject><subject>Computer science; control theory; systems</subject><subject>Exact sciences and technology</subject><subject>Logarithmic Space</subject><subject>Normal Argument</subject><subject>Programming languages</subject><subject>Recursive Call</subject><subject>Software</subject><subject>Turing Machine</subject><issn>0302-9743</issn><issn>1611-3349</issn><isbn>3540237240</isbn><isbn>9783540237242</isbn><isbn>9783540304777</isbn><isbn>3540304770</isbn><fulltext>true</fulltext><rsrctype>book_chapter</rsrctype><creationdate>2004</creationdate><recordtype>book_chapter</recordtype><recordid>eNotkLtOwzAUhs1VhNI3YMjChAy2jx3XI6ooIEViAGbLcew0kCbBTgfeHvdyliP9t-FD6JaSB0qIfFRygQELTjAQLiWWmtETNE8yJHGvyVOU0YJSDMDVGbreGQwk4-QcZSnCsJIcLlGmki9VKl6heYzfJB0woRhk6P4pX217O7VDb7q8NH2zNY3L_RDycmhMaKf1prX5x2isu0EX3nTRzY9_hr5Wz5_LV1y-v7wtn0o8MskmbC0Fa62wVBQV9QVQ55WxTEgvOau8Yc4JwhdSqFqSyvPKWKCVq4SvZV0rmKG7w-5oojWdD6a3bdRjaDcm_GlaAAhBRcqxQy4mq29c0NUw_ERNid4h1ImVBp2g6D0uvUOYSnAcD8Pv1sVJu13Lun4KprNrM04uxNRYJMBMszSRWv91Lm4q</recordid><startdate>2004</startdate><enddate>2004</enddate><creator>Neergaard, Peter Møller</creator><general>Springer Berlin / Heidelberg</general><general>Springer Berlin Heidelberg</general><general>Springer</general><scope>FFUUA</scope><scope>IQODW</scope></search><sort><creationdate>2004</creationdate><title>A Functional Language for Logarithmic Space</title><author>Neergaard, Peter Møller</author></sort><facets><frbrtype>5</frbrtype><frbrgroupid>cdi_FETCH-LOGICAL-p272t-cc13ccc5c156b1f631ef9ac257f742bfa2ee5048759d70bf4bac31beb5fd7dd93</frbrgroupid><rsrctype>book_chapters</rsrctype><prefilter>book_chapters</prefilter><language>eng</language><creationdate>2004</creationdate><topic>Applied sciences</topic><topic>Complexity Class</topic><topic>Computer science; control theory; systems</topic><topic>Exact sciences and technology</topic><topic>Logarithmic Space</topic><topic>Normal Argument</topic><topic>Programming languages</topic><topic>Recursive Call</topic><topic>Software</topic><topic>Turing Machine</topic><toplevel>peer_reviewed</toplevel><toplevel>online_resources</toplevel><creatorcontrib>Neergaard, Peter Møller</creatorcontrib><collection>ProQuest Ebook Central - Book Chapters - Demo use only</collection><collection>Pascal-Francis</collection></facets><delivery><delcategory>Remote Search Resource</delcategory><fulltext>fulltext</fulltext></delivery><addata><au>Neergaard, Peter Møller</au><au>Chin, Wei-Ngan</au><au>Chin, Wei-Ngan</au><format>book</format><genre>bookitem</genre><ristype>CHAP</ristype><atitle>A Functional Language for Logarithmic Space</atitle><btitle>Lecture notes in computer science</btitle><seriestitle>Lecture Notes in Computer Science</seriestitle><date>2004</date><risdate>2004</risdate><volume>3302</volume><spage>311</spage><epage>326</epage><pages>311-326</pages><issn>0302-9743</issn><eissn>1611-3349</eissn><isbn>3540237240</isbn><isbn>9783540237242</isbn><eisbn>9783540304777</eisbn><eisbn>3540304770</eisbn><abstract>More than being just a tool for expressing algorithms, a well-designed programming language allows the user to express her ideas efficiently. The design choices however effect the efficiency of the algorithms written in the languages. It is therefore important to understand how such choices effect the expressibility of programming languages. The paper pursues the very low complexity programs by presenting a first-order function algebra BC\documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{mathrsfs} \usepackage{upgreek} \setlength{\oddsidemargin}{-69pt} \begin{document}$^{\rm -}_{\epsilon}$\end{document} that captures exactly lf, the functions computable in logarithmic space. This gives insights into the expressiveness of recursion. The important technical features of BC\documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{mathrsfs} \usepackage{upgreek} \setlength{\oddsidemargin}{-69pt} \begin{document}$^{\rm -}_{\epsilon}$\end{document} are (1) a separation of variables into safe and normal variables where recursion can only be done over the latter; (2) linearity of the recursive call; and (3) recursion with a variable step length (course-of-value recursion). Unlike formulations of LF via Turing machines, BC\documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{mathrsfs} \usepackage{upgreek} \setlength{\oddsidemargin}{-69pt} \begin{document}$^{\rm -}_{\epsilon}$\end{document} makes no references to outside resource measures, e.g., the size of the memory used. This appears to be the first such characterization of LF-computable functions (not just predicates). The proof that all BC\documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{mathrsfs} \usepackage{upgreek} \setlength{\oddsidemargin}{-69pt} \begin{document}$^{\rm -}_{\epsilon}$\end{document}-programs can be evaluated in lf is of separate interest to programmers: it trades space for time and evaluates recursion with at most one recursive call without a call stack.</abstract><cop>Germany</cop><pub>Springer Berlin / Heidelberg</pub><doi>10.1007/978-3-540-30477-7_21</doi><oclcid>934979835</oclcid><tpages>16</tpages></addata></record>
fulltext fulltext
identifier ISSN: 0302-9743
ispartof Lecture notes in computer science, 2004, Vol.3302, p.311-326
issn 0302-9743
1611-3349
language eng
recordid cdi_pascalfrancis_primary_16335515
source Springer Books
subjects Applied sciences
Complexity Class
Computer science
control theory
systems
Exact sciences and technology
Logarithmic Space
Normal Argument
Programming languages
Recursive Call
Software
Turing Machine
title A Functional Language for Logarithmic Space
url https://sfx.bib-bvb.de/sfx_tum?ctx_ver=Z39.88-2004&ctx_enc=info:ofi/enc:UTF-8&ctx_tim=2025-01-16T13%3A12%3A19IST&url_ver=Z39.88-2004&url_ctx_fmt=infofi/fmt:kev:mtx:ctx&rfr_id=info:sid/primo.exlibrisgroup.com:primo3-Article-proquest_pasca&rft_val_fmt=info:ofi/fmt:kev:mtx:book&rft.genre=bookitem&rft.atitle=A%20Functional%20Language%20for%20Logarithmic%20Space&rft.btitle=Lecture%20notes%20in%20computer%20science&rft.au=Neergaard,%20Peter%20M%C3%B8ller&rft.date=2004&rft.volume=3302&rft.spage=311&rft.epage=326&rft.pages=311-326&rft.issn=0302-9743&rft.eissn=1611-3349&rft.isbn=3540237240&rft.isbn_list=9783540237242&rft_id=info:doi/10.1007/978-3-540-30477-7_21&rft_dat=%3Cproquest_pasca%3EEBC3087772_28_321%3C/proquest_pasca%3E%3Curl%3E%3C/url%3E&rft.eisbn=9783540304777&rft.eisbn_list=3540304770&disable_directlink=true&sfx.directlink=off&sfx.report_link=0&rft_id=info:oai/&rft_pqid=EBC3087772_28_321&rft_id=info:pmid/&rfr_iscdi=true