A minimal representation for continuous functions

TL;DR

This paper refines the minimal information needed to evaluate continuous functions on the unit interval efficiently, removing length-monotonicity constraints and establishing a new lower bound for hyper-linear evaluation.

Contribution

It introduces a new representation that is minimal for hyper-linear evaluation and shows it is not polynomial-time equivalent to previous length-monotone based encodings.

Findings

The new representation allows hyper-linear time evaluation.

It is proven not to be polynomial-time equivalent to length-monotone encodings.

The work highlights the importance of modulus of continuity in computational complexity.

Abstract

Kawamura and Cook specified the least set of information about a continuous function on the unit interval which is needed for fast function evaluation. This paper presents a variation of their result. To make the above statement precise, one has to specify what a "set of information" is and what "fast" should mean. Kawamura and Cook use polynomial-time computability in the sense of second-order complexity theory to define what "fast" means but do not use the most general "sets of information" this framework is able to handle. Instead they require codes to be length-monotone. This paper removes the additional premise of length-monotonicity, and instead imposes further conditions on the speed of the evaluation: The operation should now be computable in "hyper-linear" time. This means that the running time can not contain any iterations of the length function and, while an arbitrary polynomial may be applied to its value, on the argument side at most a shift by a constant is allowed. This is a very restrictive notion, but one can check that the Kawamura and Cook representation allows for hyper-linear time evaluation. The paper proves that it is not minimal with this property by providing the minimal set of information necessary for hyper-linear evaluation and proving that it is not polynomial-time equivalent to any encoding using only length-monotone names. Ultimatively, this is due to a failure of polynomial-time computability of an upper bound to a modulus of continuity. Indeed this failure seems to reflect the behavior of software based on the ideas of computable analysis appropriately and was one of the reasons for a closer investigation in the first place.

Equations

$$⟨\phi ,\psi ⟩(\mathbf{a}):=\{\begin{array}{ll}\phi (\mathbf{b})& \text{if }\mathbf{a}=\text{0}\mathbf{b}\\ \psi (\mathbf{b})& \text{if }\mathbf{a}=\text{1}\mathbf{b}\\ \epsilon & \text{otherwise.}\end{array}$$

$$[x\pm ϵ]:=[x-ϵ,x+ϵ].$$

$$\phi (2^n)\in \mathbb{D}\text{ and }\left|\phi (2^n)-x\right|\le 2^{-n}.$$

$$\phi \in \mathrm{dom}({\xi }_X)\Rightarrow {\xi }_Y(F(\phi ))=f({\xi }_X(\phi )).$$

$$\mathrm{eval}:C([0,1])\times [0,1]\to \mathbb{R},(f,x)\mapsto f(x).$$

$$\left|\phi \right|(n):=\max \{\left|\phi (\mathbf{a})\right|\mid \left|\mathbf{a}\right|\le n\}.$$

$$\phi \in \mathrm{dom}(\xi )\Rightarrow {\xi }^{\prime }(F(\phi ))=\xi (\phi ).$$

$$H(l,n)\le p(l(n+C)+n)$$

$$F(\phi )(\mathbf{a}):=\phi (\phi (\mathbf{a}){)}_1\text{and}G(\phi )(\mathbf{a}):=\overline{\phi (\overline{\mathbf{a}})},$$

$$(F\circ G)(\phi )(\mathbf{a})=G(\phi )(G(\phi )(\mathbf{a}){)}_1={\overline{\phi (\phi (\overline{\mathbf{a}}))}}_1=\phi (\phi (\overline{\mathbf{a}}){)}_{|\phi (\phi (\mathbf{a}))|},$$

$${\psi }_i(\mathbf{a}):=\{\begin{array}{ll}{\text{1}}^{C+1}& \text{if }\mathbf{a}=\epsilon \\ {\text{1}}^{p(C+1)}i& \text{if }\mathbf{a}={\text{1}}^{C+1}.\\ \epsilon & \text{otherwise}\end{array}$$

$$(l,n)\mapsto p(l(q(n))+n).$$

$$\phi (2^n\#\#r)=2^m\#\#q\text{and}f([r\pm 2^{-m}]\cap [0,1])\subseteq [q\pm 2^{-n}].$$

$$\phi (2^n\#\#r)=2^m\#\#q\Rightarrow m\le \left|\phi \right|(n).$$

$$\forall x,y\in [0,1]:\left|x-y\right|\le 2^{\mu (n)}\Rightarrow \left|f(x)-f(y)\right|\le 2^{-n}.$$

$$\mathrm{eval}:C([0,1])\times [0,1]\to \mathbb{R},(f,x)\mapsto f(x)$$

$$f([1/2\pm 2^{-m}])\subseteq [q\pm 1].$$

$$f([0,1])\subseteq [q\pm (1+2^{|\phi |(1)-1})].$$

$$\mathrm{eval}:C([0,1])\times [0,1]\to \mathbb{R},(f,x)\mapsto f(x)$$

$$\mathrm{mod}:C([0,1])\rightrightarrows {\omega }^{\omega },f\mapsto \{\mu \mid \mu \text{ is mod. of cont. of }f\text{ (see lx@crefcreftype refnumeq:mod)}\}$$

$$\psi (\mathbf{a}):=\{\begin{array}{ll}{2}^n\#\#\text{0}\text{0}\#& \text{if }\mathbf{a}=2^{n+1}\#\#r\text{ for some }r\in \mathbb{D}\cap [0,1]\\ \epsilon & \text{otherwise.}\end{array}$$

$$\left|\mathbf{a}\right|\le \left|\mathbf{b}\right|\Rightarrow \left|\phi (\mathbf{a})\right|\le \left|\phi (\mathbf{b})\right|.$$

$$\left|f(r)-q\right|\le 2^{-n}.$$

$$\forall \phi \in \mathcal{B}.\forall n\in \omega :\left|F(\phi )\right|(n)\ge \left|\phi \right|(2n)$$

$$\left|\psi \right|(2N)\ge \left|\psi (\mathbf{b})\right|=\left|M^{\phi }\right|(N)+1=\left|M^{\psi }\right|(N)+1=\left|F(\psi )\right|(N)+1.$$

$$\forall \phi ,\psi \in \mathcal{B}.\forall n\in \omega :\left|F(⟨\phi ,\psi ⟩)\right|(n)\ge (\left|\phi \right|\circ \left|\psi \right|)(n).$$

$$\circ :C([0,1])\times C([0,1],[0,1])\to C([0,1]),(f,g)\mapsto f\circ g,$$

$$f(x):=\sum _{i=0}^{\infty }{2}^{-i}\max \left\{1-\left|2^{2i+2}x-3\right|,0\right\}.$$

$$\psi (\mathbf{a}):=\{\begin{array}{ll}{2}^n\#\#\text{0}\text{0}\#& \text{if }\mathbf{a}=2^{n+1}\#\#r\text{ for some }r\in \mathbb{D}\cap [0,1]\\ \epsilon & \text{otherwise.}\end{array}$$

Full text

1. 1 Introduction

2. 1.1 Notations

3. 1.2 Representations

4. 1.3 Second-order complexity theory

5. 1.4 Hyper-linear time

6. 2 A minimal representation

7. 2.1 A minimality property

8. 2.2 Comparison to second-order representations

9. 2.3 Composition

10. 3 Conclusion

1 Introduction

This paper discusses subjects that are from the field of real complexity theory; The resource sensitive refinement of computable analysis. The goals of computable analysis and real complexity theory are to broaden the scope of classical computability and complexity theory from discrete structures to continuous structures. Computable analysis originates from one of the papers that is considered foundational for computability theory itself [Tur36]. It branched of as a separate discipline in the 50’s [Grz55] and has been extended steadily since. Nowadays, most researchers in computable analysis use Weihrauch’s framework of representations [Wei00].

The complexity theory behind computable analysis was initiated by Friedman and Ko [Ko91] and has recently seen a lot of new developments due to advancements in the field of second-order complexity theory. Kawamura and Cook introduced a framework for complexity for operators in analysis [KC10] and kicked off a line of investigations in the past years [Kaw11, KO14, KP14, FGH14, KMRZ15, FZ15, Ste17, and many more]. One of the results that contributed to the popularity and acceptance of their framework is the following: Kawamura and Cook succeeded to provide a standard representation of the set of continuous functions on the unit interval. They proved that this representation contains the minimal information needed to make the evaluation operator polynomial-time computable. Where minimality is taken to mean that any other representation with this property can be translated to the standard representation in polynomial time. This paper provides a variation of Kawamura and Cook’s result.

The framework of Kawamura and Cook sits behind most complexity theoretical results in computable analysis. Still, there remains a gaps between the theory and applications: For a well-behaved complexity theory, Kawamura and Cook impose some additional assumptions on the representations they consider. In practice, these assumptions seem unnatural as they lead to extensive padding. Furthermore, some of the theoretical predictions seem to be out of sync with the behavior of efficient software based on the ideas from computable analysis: iRRAM is a framework for and implementation of error-free real arithmetic based on the ideas of real complexity theory [Mül01, Mül]. In iRRAM it is possible to implement functions and, as long as the implementation of the function is reasonable, evaluation of the function is fast. Computing an upper bound of the modulus of continuity of a function, on the other hand, does not seem to be possible in a reasonable amount of time. In contrast to that, within Kawamura and Cook’s framework one can prove that polynomial-time computability of evaluation implies polynomial-time computability of a modulus.

Due to the additional assumptions Kawamura and Cook impose, namely length monotonicity of names, Kawamura and Cook only employ a fragment of second-order complexity theory. This paper asks the question whether the discrepancies between theory and practice in the specific application of representations of continuous functions on the unit interval can be removed by omitting length monotonicity. It should be pointed out ahead of time that while the approach seems to lead to a success in the beginning, we only consider it to be partially successful. Technical difficulties are encountered when composing functions.

This paper provides a representation $\xi_{C}$ (Definition 2.12) such that a function can be evaluated quickly by using an algorithm for evaluation that is very similar to how iRRAM works internally (Theorem 2.13). It is proven that it is impossible to compute an upper bound to the modulus of continuity of a function in polynomial-time with respect to $\xi_{C}$ (Theorem 2.15) and this is used to compare $\xi_{C}$ to Kawamura and Cook’s minimal representation. While translatability in one direction follows from the minimality result proven by Kawamura and Cook, the representations are not polynomial-time equivalent (Corollary 2.19). It follows directly, that $\xi_{C}$ is not polynomial-time equivalent to any second-order representation (Corollary 2.21). Many of the more basic operations, like the arithmetical operations, are polynomial-time computable with respect to the representation $\xi_{C}$. However, in contrast to Kawamura and Cook’s representation, $\xi_{C}$ does not allow to extract an upper bound to the modulus of continuity in polynomial time. Furthermore, the final part of the paper proves composition of funcitons fails to be polynomial-time computable with respect to $\xi_{C}$ (Theorem 2.23).

The paper also proves that for any other representation such that evaluation is fast, there is a fast translation to $\xi_{C}$ (Theorem 2.14). Here, the condition for being ‘fast’ (Definition 1.10) is more restrictive than polynomial-time computable and is given the name hyper-linear time computability. This notion leads to some technical difficulties. The use of a different notion of being ‘fast’ is necessary for the proofs, but can also be justified by other means: In the past of real complexity theory there has been a lot of discussion about whether or not iteration of the length function in the running time should be considered feasible. Thus, one of the restrictions we use, namely forbidding iterations of the size function, is justifiable. The restriction, however, goes further to only allow a constant instead of the more usual polynomial lookahead. This seems to be a real restriction, and is only done since it seems unavoidable for the proofs. It should be noted that already the restriction to one iteration of the length function leads to a complexity class that is dependent on small changes in the model of computation. In the model that we pick, a consequence of this is that the class of operators that are considered ‘fast’ is not closed under composition.

1.1 Notations

Fix the finite alphabet $\Sigma:=\{\textup{{0}},\textup{{1}},\#\}$. Denote the set of finite words over $\Sigma$ by $\Sigma^{*}$. The empty string is denoted by $\varepsilon$.

For convenience of notation, this paper considers some sets from mathematics as subsets of $\Sigma^{*}$: Let $\mathbb{N}$ denote the set $\{\textup{{1}},\textup{{1}}\textup{{0}},\textup{{1}}\textup{{1}},\textup{{1}}\textup{{0}}\textup{{0}},\textup{{1}}\textup{{0}}\textup{{1}},\ldots\}$ of positive integers in binary notation. Let $\omega=\{\varepsilon,\textup{{1}},\textup{{1}}\textup{{1}},\ldots\}$ denote the non-negative integers in unary notation. To avoid notational confusion this paper uses $2^{n}$ instead of $n$ if an integer in unary notation is handed to a machine. The length function $\left|\cdot\right|\colon\Sigma^{*}\to\omega$ assigns to a string $\mathbf{a}$ its number of bits. Since $\omega$ are the integers in unary, this operation can also be regarded to replace all digits of the string by 1. Let $\mathbb{Z}$ denote the set $\textup{{0}}\textup{{0}}\mathbb{N}\cup\textup{{0}}\textup{{1}}\mathbb{N}\cup\{\textup{{0}}\textup{{0}}\}$, where 00 is interpreted as [math], $\textup{{0}}\textup{{0}}n$ is interpreted as $n$ and $\textup{{0}}\textup{{1}}n$ is interpreted as $-n$. Finally, interpret a string $\mathbf{c}$ that has a single $\#$ and starts in either 01, 11 or $\textup{{0}}\textup{{0}}\#$ as the binary expansion of a rational number. I.e. identify $\mathbf{c}$ with the rational number $(-1)^{c_{0}}(\sum_{i=1}^{m-1}c_{i}2^{i-(m-1)}+\sum_{i=m+1}^{\left|\mathbf{c}\right|-1}c_{i}2^{i-m})$, where $m$ is the position of the $\#$. The set of numbers that have a code as above is called dyadic numbers and denoted by $\mathbb{D}$. Note that this does not provide $\mathbb{D}\subseteq\Sigma^{*}$ but only defines partial a surjective mapping from $\Sigma^{*}$ to $\mathbb{D}$, a so-called notation. Furthermore it holds that for any $n$ the $m+n$ initial segment of a dyadic number is again a dyadic number (where $m$ is the position of $\#$) and a $2^{-n}$-approximation to the original number. The above sets $\mathbb{N},\mathbb{Z},\mathbb{D}\subseteq\Sigma^{*}$ are pair-wise disjoint.

The Baire space $\mathcal{B}$ is the space of all string functions $\varphi:\Sigma^{*}\to\Sigma^{*}$. The reader is assumed to be familiar with the definitions of computability and complexity of string functions. The above can be used to talk about computability and complexity of functions between natural and dyadic numbers. Note that all string functions are required to be total, however, usually only the values of the functions on natural or rational inputs are required to fulfill some conditions. As a consequence it is possible to consider multivariate functions by just separating the arguments with $\#\#$. This paper uses the following pairing function on string functions:

[TABLE]

Throughout this paper $C([0,1])$ denotes the set of continuous real valued functions on the unit interval. The following short notation for intervals is used:

[TABLE]

1.2 Representations

Computability theory encodes discrete structures by strings. Since the set of all strings $\Sigma^{*}$ is countable, this can only work for countable structures. To compute on structures of continuum cardinality one has to encode the elements by string functions instead of strings.

Definition 1.1

A representation $\xi$ of a space $X$ is a partial surjective mapping $\xi:\subseteq\mathcal{B}\to X$ from the Baire space to $X$.

An element of $\xi^{-1}(x)$ is called a $\xi$-name or simply a name of $x$. An element of a space with a distinguished representation is called computable resp. polynomial-time computable if it has a name which is computable resp. polynomial-time computable.

Example 1.2

Throughout this paper, the real numbers are equipped with the following representation: A string function $\varphi$ is a name of $x\in\mathbb{R}$ if and only if it holds for all $n\in\omega$ that

[TABLE]

That is: a name of a real number encodes dyadic approximations of arbitrary precision. This paper adopts the convention to encode precision requirements as integers in unary, which is standard in the field of real complexity theory. One could have equivalently used an integer in binary as input and replaced the right hand side by $\frac{1}{n+1}$ or a strictly positive rational $\epsilon$ that would then appear on the right hand side.

Definition 1.3

Let $\xi_{X}$ and $\xi_{Y}$ be representations of spaces $X$ and $Y$. A realizer of a function $f\colon X\to Y$ is a function $F\colon\mathcal{B}\to\mathcal{B}$ such that for all $\varphi\in\mathcal{B}$

[TABLE]

That is: $F$ translates $\xi_{X}$-names of $x$ into $\xi_{Y}$-names of $f(x)$. Computability of operators on Baire space can be defined using oracle Turing machines: An operator $F:\subseteq\mathcal{B}\to\mathcal{B}$ is called computable if there is an oracle Turing machine $M^{?}$ such that the run of $M^{?}$ on input $\mathbf{a}$ and with oracle $\varphi\in\mathrm{dom}(F)$ halts with output $M^{\varphi}(\mathbf{a})=F(\varphi)(\mathbf{a})$. For more details about the exact model of oracle machines to use we point to [KC10].

A function $f:X\to Y$ between spaces with distinguished representations is called computable if it has a computable realizer.

Finally, this paper needs the product construction. Recall that a pairing $\langle\cdot,\cdot\rangle$ of string functions was fixed in the introduction.

Definition 1.4

Let $\xi_{X}$ and $\xi_{Y}$ be representations of spaces $X$ and $Y$. Define a representation $\xi_{X\times Y}$ of the Cartesian product $X\times Y$ as follows: A string function $\varphi$ is a name of an element $(x,y)\in X\times Y$ if and only if there exist string functions $\psi\in\xi_{X}^{-1}(x)$ and $\psi^{\prime}\in\xi_{Y}^{-1}(y)$ such that $\varphi=\langle\psi,\psi^{\prime}\rangle$.

Recall that an element of a represented spaces is called computable resp. polynomial time computable if it has such a name. It is true that an element $(x,y)$ of the product is computable resp. polynomial-time computable if and only if both $x$ and $y$ are computable resp. polynomial-time computable.

Example 1.5

For a given representation $\xi$ of the continuous functions on the unit interval $C([0,1])$, the above definitions together with the standard representation of the reals from Example 1.2 allow to discuss computability and polynomial-time computability of the operator

[TABLE]

1.3 Second-order complexity theory

For complexity considerations this paper uses second-order complexity theory which goes back to a definition by Mehlhorn [Meh76]. However, just like the framework of Kawamura and Cook does, we replace the original definition by a characterization due to Kapron and Cook [KC96]. This characterization is based on resource restricted oracle Turing machines and considerably more accessible than the original definition that was based on limited recursion on notation scheme. Recall that $\mathcal{B}:=\Sigma^{*}\to\Sigma^{*}$ denotes the Baire space, i.e. the space of all string functions. Oracle machines compute operators on Baire space and therefore take elements of Baire space as inputs. When bounding the running time of such a machine, the size of the functional input should be taken into consideration.

Definition 1.6

For a string function $\varphi\in\mathcal{B}$ define its length $\left|\varphi\right|:\omega\to\omega$ to be the function

[TABLE]

That is: the length of $\varphi$ is the worst case increase in string-size from input to output. A running time bound $T$ should be an object of the type $\omega^{\omega}\times\omega\to\omega$: It takes a size of an oracle function, a size of an input string and returns a number of steps $T(\left|\varphi\right|,\left|\mathbf{a}\right|)$ the machine is allowed to take on inputs $\varphi$ and $\mathbf{a}$. The subclass of running times that are considered polynomial, i.e. the second-order polynomials, are recursively defined as follows:

• •

Whenever $p$ is a polynomial with natural number coefficients, then the function $(l,n)\mapsto p(n)$ is a second-order polynomial.

• •

Whenever $P$ is a second-order polynomial, the function $(l,n)\mapsto l(P(l,n))$ is also a second-order polynomial.

• •

Whenever $P$ and $Q$ are second-order polynomials, then so are their point-wise sum and product.

Definition 1.7

An oracle Turing machine $M^{?}$ is said to run in polynomial time on $A\subseteq\mathcal{B}$ if there is a second-order polynomial $P$ such that on oracle $\varphi\in A$ with input $\mathbf{a}$ it halts after at most $P(\left|\varphi\right|,\left|\mathbf{a}\right|)$ computation steps.

A functional $F:\subseteq\mathcal{B}\to\mathcal{B}$ is called polynomial-time computable if there is an oracle Turing machine $M^{?}$ that runs in polynomial time on $\mathrm{dom}(F)$ and such that for all $\varphi\in\mathrm{dom}(F)$ and strings $\mathbf{a}$ it holds that $M^{\varphi}(\mathbf{a})=F(\varphi)(\mathbf{a})$. A function between spaces with distinguished representations is called polynomial-time computable if it has a polynomial time computable realizer.

It should be pointed out, that the characterization provided by Kapron and Cook only applies to the case where additional properties of the set $A$ are known. The definition stated here is a proper generalization in the sense that the operators we consider polynomial-time computable need not have polynomial-time computable total extensions. However, this seems to be a reasonable and necessary extension.

An important special case where one is interested in computability or complexity of an operation are comparisons of different representations a space.

Definition 1.8

Let $\xi$ and $\xi^{\prime}$ be representations of some space $X$. A translation from $\xi$ to $\xi^{\prime}$ is a realizer of the identity, i.e. a mapping $F:\subseteq\mathcal{B}\to\mathcal{B}$ such that for all $\varphi\in\mathcal{B}$ it holds that

[TABLE]

The representation $\xi$ is called topologically, computably or polynomial-time translatable to $\xi^{\prime}$ if there exists a continuous, computable or polynomial-time computable translation. The representations $\xi$ and $\xi^{\prime}$ are called topologically, computably or polynomial-time equivalent if there exist continuous, computable or polynomial-time computable translations in both directions.

In literature the corresponding relation is usually called reducibility and denoted by $\preceq$. This terminology is taken from the discrete setting and can sometimes be confusing in the context of representations, as intuitively ‘$\xi$ is reducible to $\xi^{\prime}$’ should mean that there is a reduction mapping from $\xi^{\prime}$ to $\xi$.

Example 1.9

The different versions of the representation of the real numbers discussed in Example 1.2 lead to polynomial-time equivalent representations. Computability of functions is preserved under change to computably equivalent representations on both the input and output spaces. Polynomial-time computability is preserved under change of polynomial-time equivalent representations. These properties follow from the closure of computable and of polynomial-time computable operators under composition. A proof that the later remains true in our setting can for instance be found in [KS17].

1.4 Hyper-linear time

Due to the use of general representations, this paper imposes the following more restrictive condition than polynomial-time computability on the evaluation operator:

Definition 1.10

A second-order polynomial $H$ is called hyper-linear, if there exists some integer polynomial $p$ and a constant $C\in\omega$ such that

[TABLE]

A polynomial-time computable function between represented spaces is called computable in hyper-linear time if it is computed by a machine whose running time is bounded by a hyper-linear second-order polynomial.

One should keep in mind that this definition is tailored for the application at hand. No care about complexity theoretical well-behavedness was taken. Indeed, the class of hyper-linear time computable operators may change with subtle changes in the model of computation. To make the above definition meaningful, more details about the model of computation have to be fixed: From now on assume that the position of the reading head resp. writing heads on the oracle tapes do not change during oracle queries and that oracle calls take one time step.

Example 1.11

Consider the two operators $F$ and $G$ defined by

[TABLE]

where $\mathbf{a}_{i}$ is the $i$-th bit of the string and $\overline{\mathbf{a}}:=\mathbf{a}_{\left|\mathbf{a}\right|}\ldots\mathbf{a}_{1}$ is the mirrored string. The straight forward oracle machines that compute these operators run in time $\mathcal{O}(n+l(n))$. For $F$ this is due to our convention, that only reading the oracle tape is accounted for in the time consumption of the machine: While the return value might be very long, writing it to the output tape is done by the oracle and copying the first bit to the output tape takes constant time. Thus both $F$ and $G$ are hyper-linear-time computable. The composition $F\circ G$ of these operators is given by

[TABLE]

and should intuitively not be hyper-linear-time computable.

Indeed, it is not to difficult to give a proof that $F\circ G$ is not hyper-linear time computable: Assume that $M^{?}$ is a machine that computes $(F\circ G)$ in hyper-linear time $(l,n)\mapsto p(l(n+C)+n)$. Construct a pair of oracles $\psi_{\textup{{0}}}$ and $\psi_{\textup{{1}}}$ such that $M^{\psi_{\textup{{0}}}}(\varepsilon)=M^{\psi_{\textup{{1}}}}(\varepsilon)$ but $(F\circ G)(\psi_{\textup{{0}}})(\varepsilon)\neq(F\circ G)(\psi_{\textup{{1}}})(\varepsilon)$. Let $\psi_{i}$ return the empty string on all arguments but $\varepsilon$, where it returns $\textup{{1}}^{C+1}$, and on the argument $\textup{{1}}^{C+1}$, where it returns $\textup{{1}}^{p(C+1)}i$:

[TABLE]

To see that $M^{?}(\varepsilon)$ returns identical results on both $\psi_{i}$ note that for all $n\leq C$ it holds that $\left|\psi_{i}\right|(n)=C+1$. Thus, the time the machine is granted of either of the oracles $\psi_{i}$ and input $\varepsilon$ is $p(|\psi|(0+C)+0)=p(C+1)$ and the run does only rely on what is written in the first $p(C+1)$ cells of the oracle answer tape at any point in the computation. The content of this part of the oracle answer tape is identical for all possible answers of $\psi_{\textup{{1}}}$ and $\psi_{\textup{{0}}}$. Thus the runs of the machine are identical and so is the return value. On the other hand, obviously $(F\circ G)(\psi_{\textup{{0}}})(\varepsilon)=\textup{{0}}\neq\textup{{1}}=(F\circ G)(\psi_{\textup{{1}}})(\varepsilon)$, thus the machine does not compute $F\circ G$.

As the machine was arbitrary it follows that $F\circ G$ is not hyper-linear time computable.

This example shows that the hyper-linear-time computable operators are not closed under composition in the model of computation that we chose. The class is also not stable under rather minor changes in the model of computation. For instance, the alternate convention of counting one time step for each digit of the return value in an oracle query is fairly common throughout second-order complexity theory and leads to the same class of polynomial-time computable operators. We consider it to be less natural as it leads to doubled counting of steps when composing machines and more technical difficulties overall. Making sense of hyper-linear time restrictions under this changed convention of time counting has to be done very carefully: Whether or not a machine is allowed to abort an oracle query matters. If abort is disallowed, then being hyper-linear-time computable implies a polynomial lookahead which is too restrictive for the applications this paper is interested in. If aborting is allowed one has to ask again how this is done: aborting with an initial segment written to the answer tape leads to the same class of hyper-linear-time computable operators we work with. The convention where no information about the answer is available in case of an abort leads to again a different class not containing the operator $F$ from the previous example.

All of the above difficulties equally apply to the class of machines that have a runtime bound of the form

[TABLE]

The class of operators computed by a machine allowing a running time bound of this form has been discussed as the right class for capturing feasibility in computable analysis. This justifies looking at hyper-linear time computation regardless of the model-dependence.

2 A minimal representation

Recall that this paper simulates multivariate input and output from $\mathbb{N}$ or $\mathbb{D}$ by separating the different arguments by $\#\#$ and uses the abbreviation $[r\pm\epsilon]$ for $[r-\epsilon,r+\epsilon]$. This chapter proves the following representation to be the minimal representation such that evaluation is hyper-linear-time computable:

Definition 2.12

Define the representation $\xi_{C}$ of $C([0,1])$: A string function $\varphi$ is a $\xi_{C}$-name of a function $f\in C([0,1])$ if and only if both of the following hold:

For all $r\in\mathbb{D}\cap[0,1]$ and $n\in\omega$ there are $q\in\mathbb{D}$ and $m\in\omega$ such that

[TABLE] 2. 2.

For all $r,q\in\mathbb{D}\cap[0,1]$ it holds that

[TABLE]

The first condition guarantees that on input $r$ and accuracy requirement $2^{n}$, a name of a function $f$ returns a $2^{-n}$-approximation $q$ of the value $f(r)$ of the function as well as an estimate $\delta:=2^{-m}$ of how much $r$ can be varied without the approximation $q$ becoming invalid. The second condition implies that $\left|\varphi\right|$ is a modulus of continuity of $\xi_{C}(\varphi)$ in the following sense: A function $\mu:\omega\to\omega$ is called modulus of continuity of $f\in C([0,1])$ if it fulfills

[TABLE]

The above is automatically fulfilled for $\mu(n):=\left|\varphi\right|(n+1)$ and $f:=\xi_{C}(\varphi)$. The length of a name can be increased arbitrarily without interfering with the other condition by changing the values of the string function on strings that do not contain any $\#$. Using this and the fact that any continuous function on the unit interval has a uniform modulus of continuity it is quite easy to see that the above indeed defines a representation, i.e. that any continuous function has a name.

Theorem 2.13

The evaluation operator

[TABLE]

*is hyper-linear-time computable with respect to $\xi_{C}$. *

Proof

A machine computing the evaluation operator can be described as follows: When given a pair $\langle\varphi,\psi\rangle$ of a $\xi_{C}$-name $\varphi$ of a function $f\in C([0,1])$ and a name $\psi$ of a real number $x\in[0,1]$ and an precision requirement $2^{n}$ as input, the machine carries out the following loop for increasing $i$: First it obtains an encoding of a dyadic $2^{-i}$-approximation $x_{i}$ of $x$ by evaluating $\psi(2^{i})$. Then it evaluates $\varphi(2^{n}\#\#x_{i})$ to obtain an encoding of a dyadic number $q_{i}$ and an integer $m_{i}$ such that $f([x_{i}\pm 2^{m_{i}}])\subseteq[q_{i}\pm 2^{n}]$. It checks if $m_{i}\leq i$. If this is not the case, it increases $i$ and restarts the loop. If it is the case it exits the loop and returns $q_{i}$.

It should be clear that if the machine exits the loop at some point, then the return value is a valid approximation to $f(x)$. Therefore, it remains to prove that the machine always terminates and runs in polynomial time. Note that by the second condition of the definition of the representation $\xi_{C}$, the length of the name is a modulus of continuity. Claim that whenever $i\geq\left|\varphi\right|(n)$, then the machine exits the loop. Indeed, in this case by the second condition of the definition of the representation $\xi_{C}$, it holds that $m_{i}\leq\left|\varphi\right|(n)\leq i$. Thus, the loop is carried out at most $\left|\varphi\right|(n)$ times.

As the number $i$ is smaller than $\left|\varphi\right|(n)$, going through the loop once takes hyper-linear time: The loop also needs to copy $2^{n}$, which takes $\mathcal{O}(n)$ steps. To see that copying the second argument $q_{i}$ of $\varphi(2^{n}\#\#x_{i})$ is possible within the specified time bound, it is necessary to extract a bound on the integer part of $q_{i}$. This can be done as follows: The string $\textup{{0}}\textup{{0}}\#\textup{{1}}$ encodes the dyadic number $\frac{1}{2}$. Thus, by the first condition of the definition of $\xi_{C}$ it holds that $\varphi(\textup{{1}}\#\#\textup{{0}}\textup{{0}}\#\textup{{1}})=2^{m}\#\#q$ and $q$ and $m$ fulfill

[TABLE]

In addition to this, $\mu(n):=\left|\varphi\right|(n+1)$ is a modulus of continuity of $f$ and by dividing the distance to any $x\in[0,1]$ to $\frac{1}{2}$ into $2^{\left|\varphi\right|(1)-1}$ steps of size less than $2^{-\left|\varphi\right|(1)}$ it follows that

[TABLE]

This finally implies that the integer part of the second argument of the return value of $\varphi(2^{n}\#\#r)$ is smaller than $2^{\left|\varphi\right|(1)}+2^{\left|\varphi\right|(7)}$, where the second term is a bound on the integer part of $q$ that follows from how $q$ was found. Since $\left|\varphi\right|(1)\leq\left|\varphi\right|(7)$, such integers have codes that are of length less than $\left|\varphi\right|(7)+3$.

Therefore, the loop can be carried out in $\mathcal{O}(\max\{\left|\varphi\right|(7),\left|\varphi\right|(n),n\})\subseteq\mathcal{O}(n+\left|\varphi\right|(n+7))$ steps and all of the computation takes less than $\mathcal{O}((n+\left|\varphi\right|(n+7))^{2})$. This time bound is hyper-linear. ■

2.1 A minimality property

With respect to the representation $\xi_{C}$ it is possible to evaluate in polynomial time. To prove that the representation is minimal with this property we need to provide a fast translation to $\xi_{C}$ for any other representation of the continuous functions on the unit interval that allows fast evaluation.

Theorem 2.14

Let $\xi$ be a representation of $C([0,1])$. If the operator

[TABLE]

*is hyper-linear-time computable with respect to $\xi$, then there exists a hyper-linear-time translation from $\xi$ to $\xi_{C}$. *

Proof

Assume the evaluation operator is computable in hyper-linear time. To build a machine that translates $\xi$ into $\xi_{C}$ proceed as follows: Given input of the form $2^{n}\#\#r$ (i.e. input for a $\xi_{C}$-name such that the first condition of Definition 2.12 applies) and a $\xi$-name $\varphi$ as oracle, execute a modified version of the source code of the evaluation operator on $2^{n}$: Note that the evaluation operator expects to be handed a pair $\langle\psi,\psi^{\prime}\rangle$ of a $\xi$-name for the function and a name of a real number $x$. Thus, whenever there is a leading 0 on the query tape and a query command is issued, the machine first removes the leading 0, and then queries the oracle. Whenever there is a leading 1 on the query tape, the oracle query command in the code of the evaluation are replaced with a code snippet that notes the maximum precision that was asked to the memory tape and then copies an appropriate initial segment of the encoding of the rational number $r$ to the oracle answer band. This produces an encoding of a dyadic number $q$ on the output tape. Finally the machine adds $2^{m}\#\#$ in front of the encoding, where $m$ is the highest precision that was required of the oracle for the real number and terminates.

This produces a valid output of a $\xi_{C}$-name of $f$ on $2^{n}\#\#r$: The output is valid, as any $x\in[r\pm 2^{-m}]$ has a name that returns the exact same initial segments of $r$ on queries less than $2^{m}$. The run of the evaluation operator on this oracle is identical to the run simulated above. Thus the return value is a valid approximation to $f(x)$ for each of these $x$. I.e. $f([r\pm 2^{-m}])\subseteq[q\pm 2^{-n}]$.

To guarantee that the second condition from Definition 2.12 holds, recall that the evaluation operator being hyper-linear-time computable means that there is an integer polynomial $p$ and a natural number $C$ such that the run of the machine computing $\mathrm{eval}$ with oracle $\varphi$ on input $\mathbf{a}$ takes at most $p(\left|\varphi\right|(n+C)+n)$ steps. Let the machine proceed on inputs $\mathbf{a}$ that are not of the form $2^{n}\#\#r$ as follows: For any of the $3^{C}$ strings $\mathbf{c}$ of length $C$ it queries the oracle $\varphi$ on $\mathbf{c}\mathbf{a}$ and $\mathbf{c}\mathbf{a}^{\prime}$, where $\mathbf{a}^{\prime}$ is the string where the first symbol after the first $\#$ is replaced by a $\#$ (and $\mathbf{a}=\mathbf{a}^{\prime}$ if there is no $\#$ or the only one is the last symbol). It takes the maximum $m$ of the lengths of the oracle answers and returns the string consisting only of 1s and of length $p(m+n)$.

The above guarantees that the string function produced by the machine has length bigger than $p(\left|\varphi\right|(n+C)+n)$: Let $\mathbf{b}$ be a string of length $n+C$ such that $\left|\varphi(\mathbf{b})\right|=\left|\varphi\right|(n+C)$. Let $\mathbf{a}$ be the last $n$ bits of $\mathbf{b}$ where in the first occurrence of $\#\#$ the second $\#$ is replaced by 0. Then the machine described above carries out the previous paragraph on input $\mathbf{a}$. By the procedure described there it is guaranteed that the query $\mathbf{b}$ is posed to the oracle and that the return value is longer than $p(\left|\varphi(\mathbf{b})\right|+n)=p(\left|\varphi\right|(n+C)+n)$.

The final thing to verify is that the second condition of the Definition 2.12 of $\xi_{C}$ is fulfilled by the function produced by the above procedure: Let $\psi$ be the string function produced by the machine above. By the previous it is clear that $\left|\psi\right|(n)\geq p(\left|\varphi\right|(n+C)+n)$. Since $(l,n)\mapsto p(l(n+C)+n)$ is a running time of the evaluation operator, which is simulated on an oracle of length $\left|\varphi\right|$ and input $2^{n}$, it is clear that the number $m$ produced in the second paragraph of the proof is smaller than $p(\left|\varphi\right|(n+C)+n)$ and therefore also as $\left|\psi\right|(n)$. ■

It should be noted, that the failure of closure under composition of hyper-linear-time computable operators has consequences for the applicability of the theorem. For instance, one would expect that the existence of a fast translation to the representation $\xi_{C}$ should imply that there exists an algorithm for fast evaluation. To obtain an algorithm for evaluation one has to first translate to $\xi_{C}$ and then use the algorithm for evaluation over $\xi_{C}$. As the class of hyper-liner time algorithms is not closed under composition, the algorithm obtained in this way need not run in hyper-linear time. It does run in polynomial time though.

2.2 Comparison to second-order representations

This chapter presents a hardness result for an operation with respect to the representation $\xi_{C}$: It is impossible to compute a modulus of continuity of a function in polynomial time with respect to $\xi_{C}$. This restriction is welcome as it seems to reflect the behavior of functions in iRRAM. It should be noted that this result does not use the stronger notion of being ‘fast’ that was previously used in this paper but really proves failure of polynomial-time computability.

Computing a modulus of continuity is an inherently multivalued operation. Recall that a multivalued mapping $f:X\rightrightarrows Y$ is an assignment of elements of $x$ to non-empty sets $f(x)\subseteq Y$. The elements of $f(x)$ are interpreted as the ‘acceptable return values’. Definition 1.3 of a realizer can straight-forwardly be extended to apply to multivalued mappings and thus it makes sense to talk about computability and complexity of multivalued mappings.

Theorem 2.15

The modulus function

[TABLE]

*is not polynomial-time computable with respect to $\xi_{C}$. *

Proof

Towards a contradiction assume that there was a machine that computes a modulus of continuity in polynomial time. That is: There is a second-order polynomial $P$ such that the machine, when given a $\xi_{C}$-name $\varphi$ of a function $f$ and an input $2^{n}$ produces $2^{\mu(n)}$ on the output tape within $P(\left|\varphi\right|,n)$ steps and the function $\mu$ is a modulus of continuity of $f$. Consider the following name $\psi$ of the constant zero function:

[TABLE]

Obviously $\left|\psi\right|(n)=n+1$. The function $p(n):=P(\cdot+1,n)$ is a polynomial and bounds the number of steps until the machine returns some value $m$ of $\mu(n)$. Choose some $N$ such that $3p(N)<2^{N}$. Consider the run of the machine on input $2^{N}$. Think of $[0,1]$ as the union of $2^{N}$ closed intervals of equal length $2^{-N}$. Since the $2^{-N-1}$ neighborhood of a rational number can at most intersect three such intervals, and the machine can at most ask $p(N)$ queries, at least one closed interval $I$ is such that no rational number in its $2^{-N-1}$ neighborhood is queried. Let $f^{\prime}$ be the function that is zero everywhere but in $I$, where it takes the value $\frac{3}{2}2^{-N}$ in the middle and then goes linearly to zero with slope $3\cdot 2^{\max\{\mu(N)-N,0\}}$. Note that any modulus of continuity of $f^{\prime}$ at $N$ is strictly larger than $\max\{\mu(N),N\}$.

To change the name $\psi$ of the zero function to a name $\psi^{\prime}$ of $f^{\prime}$ without changing any of the values the machine looked at during the computation, first note that due to the choice of the interval $I$ each query the machine makes is either a query with a precision such that zero is a valid approximation to the value of $f^{\prime}$ or the name only returns information about the values on an interval disjoint from $I$. Therefore, it is possible to change the values of $\psi$ at strings the machine does not query to obtain a string function $\tilde{\psi}$ that fulfills the first condition of being a name of $f^{\prime}$. Where the values the machine has not asked for can be chosen to be the exact values of $f^{\prime}$ and the intervals can be chosen optimal.

Furthermore, there are at least $2^{M}$ strings of length $M$ that do not represent any pair of a natural number and a dyadic number, for instance the binary strings. Thus, for any $M\geq N$ there is at least one such string $\mathbf{a}_{M}$ the machine does not query. To obtain a valid name $\psi^{\prime}$ of $f^{\prime}$ change the values of $\tilde{\psi}$ on the string $\mathbf{a}_{M}$ to have length according to a modulus of continuity of $f^{\prime}$.

As the machine behaves deterministically, and $\psi^{\prime}$ and $\psi$ coincide on the values that are asked in the run with oracle $\psi$ and input $N$, the run of the machine on input $N$ with oracle $\psi^{\prime}$ is identical and returns $\mu(N)$. However, by construction, $\mu(N)$ is not a value of any modulus of continuity of $f^{\prime}$ in $N$. Therefore, no polynomial-time machine computing a modulus function exists. ■

Kawamura and Cook introduced a framework for complexity considerations in analysis. For a well-behaved second-order complexity theory they impose an additional condition on the names:

Definition 2.16** ([KC12])**

A string function $\varphi\in\mathcal{B}$ is called length-monotone if for all strings $\mathbf{a}$ and $\mathbf{b}$ it holds that

[TABLE]

The set of all length-monotone string functions is denoted by $\Sigma^{**}$.

The condition they impose is that any name in a representation is length-monotone. To distinguish their representations from the ones used in this paper we use their original terminology.

Definition 2.17** ([KC12])**

A representation is a second-order representation if its domain is contained in $\Sigma^{**}$.

In this special case it is irrelevant whether time constraints are imposed on all of Baire-space or only for oracles from $\Sigma^{**}$. This may be attributed to the existence of a polynomial-time computable retraction from the Baire space to $\Sigma^{**}$ [KS17] or verified directly. In particular, we may stick with the definition of polynomial-time computability used in the rest of this paper.

Definition 2.18** ([KC12])**

Define a second-order representation $\delta_{\square}$ of $C([0,1])$ as follows: A length-monotone string function $\varphi$ is a name of a function $f\in C([0,1])$ if $\varphi=\langle\psi,\psi^{\prime}\rangle$ for string functions $\psi$ and $\psi^{\prime}$ that fulfill both of the following:

$n\mapsto\left|\psi(2^{n})\right|$ is a modulus of continuity of $f$. 2. 2.

for any encoding $r$ of a dyadic number in $[0,1]$ and $n\in\omega$ it holds that $\psi^{\prime}(2^{n}\#\#r)$ is an encoding of a dyadic number $q$ and

[TABLE]

A polynomial-time translation of $\delta_{\square}$ to $\xi_{C}$ is readily written down. The modulus function as defined in Theorem 2.15 is obviously polynomial-time computable with respect to $\delta_{\square}$. With respect to $\xi_{C}$ the modulus function is not polynomial-time computable as proven in Theorem 2.15. Therefore, the representations $\delta_{\square}$ and $\xi_{C}$ are not polynomial-time equivalent.

Corollary 2.19

$\xi_{C}$* can not be translated to $\delta_{\square}$ in polynomial time. *

Kawamura and Cook succeeded to prove the following:

Theorem 2.20** (Lemma 4.9 in [KC12])**

For a second-order representation $\delta$ of $C([0,1])$ the following are equivalent

• •

The evaluation operator from example 1.5 is polynomial-time computable.

• •

$\delta$* is polynomial-time translatable to $\delta_{\square}$.*

Since the hyper-linear-time computability implies polynomial-time computability this entails the following:

Corollary 2.21

$\xi_{C}$* is not polynomial-time equivalent to any second-order representation. *

2.3 Composition

This final chapter presents a major flaw of the representation $\xi_{C}$: It does not render the composition of functions polynomial-time computable. This makes it improbable that the representation $\xi_{C}$ is of value in applications. We believe that its study is of value nonetheless as its properties closely reflect well-known quirks of second-order complexity theory. It therefore outlines what can and cannot be done in real complexity theory when relying on second-order complexity theory. We like to believe that it provides evidence that one should either stick with the framework of Kawamura and Cook or go beyond the scope of second-order complexity theory.

As a preparation note that an easy counting argument proves the following:

Theorem 2.22

There does not exist any polynomial-time computable operator $F:\mathcal{B}\to\mathcal{B}$ such that

[TABLE]

Proof

Assume $M^{?}$ was a machine that computes an operator $F$ with the above property in time bounded by some second-order polynomial $P$. Consider the constant string function $\varphi(\mathbf{a})\equiv\varepsilon$. The length of this function is the constant zero function, thus $p(n):=P(\left|\varphi\right|,n)$ is a polynomial. Since $P$ is a running time of $M^{?}$, the computation of $M^{\varphi}(\mathbf{a})$ takes at most $p(\left|\mathbf{a}\right|)$ many steps for any input string $\mathbf{a}$. Choose $N$ big enough such that $p(N)<2^{N}$. Note that there are $2^{2N}$ strings of length $2N$. The number of oracle queries $M^{?}$ asks for at least one input $\mathbf{a}$ of length $N$ is bounded by $p(N)2^{N}<2^{2N}$. Thus, there exists at least one string $\mathbf{b}$ of length $2N$ that is not queried during the computation of $M^{\varphi}(\mathbf{a})$ for any string $\mathbf{a}$ of length less than $N$. Let $\psi$ be the function such that $\psi(\mathbf{b})=\textup{{0}}^{\left|M^{\varphi}\right|(N)+1}$ and returns the empty string on all other values. The machine $M^{?}$ is deterministic and does not query $\mathbf{b}$. Therefore it returns the same values with oracles $\varphi$ and $\psi$ and any input of length less or equal $N$. It follows that

[TABLE]

This contradicts that the operator $F$ computed by $M^{?}$ has the desired property. ■

This is in contrast to the situation in classical complexity theory, where for any polynomial $p\in\mathbb{N}[X]$ there exists a polynomial-time computable function $\varphi$ such that $\left|\varphi(\mathbf{a})\right|\geq p(\left|\mathbf{a}\right|)$ for all input strings. The above proves that the straight forward translation of this statement to second-order complexity theory fails for the simplest second-order polynomials that are not hyper-linear. That the statement still holds true if the second-order polynomial is hyper-linear is what was made it possible to provide the minimality result for the representation $\xi_{C}$ from Theorem 2.14.

Also note that this theorem implies that there is no polynomial-time computable functional $F$ such that

[TABLE]

As such an operator would provide an operator as in the theorem by fixing $\psi$ to be the function $\psi(\mathbf{a}):=\mathbf{a}\mathbf{a}$. From this perspective it is not surprising that composition with respect to $\xi_{C}$ is not polynomial-time computable: Just like the failure of polynomial-time computability from Theorem 2.15 lifted that the length function is not polynomial-time computable, the above can be lifted to infeasibility of composition.

Let $C([0,1],[0,1])$ denote the set of all continuous functions whose image is contained in the unit interval. We consider this space a subspace of $C([0,1])$ and equip it with the range restriction of the representation $\xi_{C}$. The composition operator is defined as follows:

[TABLE]

where $(f\circ g)(x):=f(g(x))$.

Theorem 2.23** (Composition)**

*The composition operator is not polynomial-time computable with respect to the representation $\xi_{C}$. *

Proof

Towards a contradiction, assume that there exists a machine $M^{?}$ that runs in time bounded by a second-order polynomial $P$ and that when given a pair $\langle\varphi,\psi\rangle$ of $\xi_{C}$-names of functions $f\colon[0,1]\to\mathbb{R}$ and $g\colon[0,1]\to[0,1]$ computes a $\xi_{C}$-name of $f\circ g$.

Let $f$ be the following function:

[TABLE]

Since $f$ is polynomial-time computable, it has a name $\varphi$ of polynomial length. Note that $f(0)=0$ and $f(\frac{3}{4}2^{-2i})=2^{-i}$, in particular $f$ has no modulus smaller than $m\mapsto 2m$.

Consider the following name $\psi$ of the constant zero function $g$:

[TABLE]

Obviously $\left|\psi\right|(n)=n+1$. The function $p(n):=P(\left|\varphi\right|+\left|\psi\right|+1,n)$ is a polynomial and bounds the number of steps until the machine returns some value. Choose some $N$ such that $3p(N)<2^{N}$.

Think of $[0,1]$ as the union of $2^{2N}$ closed intervals of equal length $2^{-2N}$. Since the $2^{2N-1}$ neighborhood of a rational number can at most intersect three such intervals, and the machine can at most ask $p(N)$ queries on each input $\mathbf{a}$ of length $N$, there is at least one interval $I$ such that no query is asked in the $2^{2N-1}$ neighborhood of $I$. Let $g^{\prime}$ be the function that is zero everywhere but in $I$, where it takes the value $\frac{3}{4}2^{-2N}$ in the middle and then goes linearly to zero with slope $3\cdot 2^{\max\{p(N)-N,0\}}$. The argument that there is a valid name $\psi^{\prime}$ of $g^{\prime}$ such that the machine cannot distinguish it from $\psi$ can be copied from the proof of Theorem 2.15.

Note that any modulus of continuity of $f\circ g^{\prime}$ at $N$ is strictly larger than $\max\{p(N),N\}$ and that the runs of the machine on input $\mathbf{a}$ of length less than $N$ are identical when the oracle $\langle\varphi,\psi\rangle$ is replaced by $\langle\varphi,\psi^{\prime}\rangle$. Thus, the machine may not take more than $p(N)$ steps and can not produce a function whose length is a modulus of continuity of $f\circ g^{\prime}$.

This is a contradiction and thus no machine that computes the composition operator in polynomial time exists. ■

3 Conclusion

The representation $\xi_{C}$ was invented in an attempt to model the behavior of iRRAM within the framework of second-order complexity theory. There is empirical evidence that within iRRAM function evaluation is fast but computing a modulus of continuity is slow. The representation $\xi_{C}$ reflects this: It renders evaluation polynomial-time computable but does not allow to extract a modulus of continuity in polynomial time. It is remarkable that it is possible to do this within the framework of second-order complexity theory as previous results seemed to indicate that this is not possible. These very results forced us to leave the familiar setting of the framework for operators in analysis provided by Kawamura and Cook.

However, the correspondence between $\xi_{C}$ and iRRAM is imperfect: The running time of the straight forward algorithm for computing a modulus of continuity in iRRAM is still way worse than that with respect to the representation $\xi_{C}$: Due to the possibility to brute force the length function, there is a cut of in the running time for functions with fast growing moduli that does not have an analogue in iRRAM. It is improbable that this can be fully overcome as fast evaluation seems to necessitate the length to be comparable to a modulus of continuity. Furthermore, the representation $\xi_{C}$ has an undesirable property that is not reflected in the behavior of iRRAM: Composition of functions is not polynomial-time computable with respect to $\xi_{C}$.

In the proof of the hyper-linear-time computability of the evaluation operator with respect to $\xi_{C}$ in Theorem 2.13 the precision in each try is increased by one. This may lead to many useless queries. One could instead use the precision that the name requires the input approximation to have as next precision. However, this may lead to unnecessary high precision. Both approaches lead to comparable worst case complexities. The later, however, seems to be empirically superior as it is the approach that iRRAM takes.

Definition 1.10 of hyper-linear time could be slightly relaxed: The construction in Theorem 2.14 still works if the constant $C$ depends polynomially on the logarithm of $n$. If $C$ were allowed to depend on $n$ polynomially, the class would coincide with a class that some authors argue should be used to define polynomial-time computability anyway [Ret13]. However, with respect to the convention of time consumption of oracle machines used in this paper, this bigger class is still not closed under composition. Furthermore, the technique used in Theorem 2.14 to prove the minimality of $\xi_{C}$ does not generalize. We think that it is unlikely that the proof can be recovered and believe that an argument similar to the one from the proof of the failure of the polynomial-time computability of the length function in Theorem 2.22 can be used to prove this. We did not attempt to carry this thought out as the rest of the paper is not concerned with this notion of polynomial-time computability.