[proofplan] We first work in a fixed concrete effective machine model, where program codes are natural numbers and finite program assembly is a primitive computable operation on codes. The acceptability hypothesis supplies a concrete universal simulator for the given numbering $\varphi$, so the wrapper will simulate $\varphi_e$ on $(m+n)$ inputs rather than treating the index $e$ as concrete machine code. For fixed $m$ and $n$, a uniform code assembler builds an $n$-input wrapper machine that stores the numerals for $e,a_1,\dots,a_m$, calls this universal simulator on $(e,a_1,\dots,a_m,x_1,\dots,x_n)$, and returns exactly the simulated output. A total computable compiler then translates this concrete wrapper code into an index for the stated numbering without changing the computed partial function, giving the desired total computable parameterizing function. [/proofplan] [step:Construct the wrapper first in a concrete machine model and then compile it] Fix natural numbers $m,n \geq 1$. For each arity $k \geq 1$, let \begin{align*} \psi_{q,k}: \mathbb{N}^k \rightharpoonup \mathbb{N} \end{align*} denote the $k$-ary partial map computed by concrete machine code $q \in \mathbb{N}$ in a fixed standard effective machine model. By the [acceptability](/page/Acceptable%20Numbering) hypothesis on the Gödel numbering in the theorem statement, two standard effective translations are available. First, for each arity $k \geq 1$, there is a concrete code $u_k \in \mathbb{N}$ for a [universal function](/page/Universal%20Function) for the numbering $\varphi$, meaning \begin{align*} \psi_{u_k,k+1}(e,z) \simeq \varphi_e(z) \end{align*} for every index $e \in \mathbb{N}$ and every tuple $z \in \mathbb{N}^k$. Second, for each arity $k \geq 1$, there is a total computable compiler \begin{align*} \tau_k: \mathbb{N} &\to \mathbb{N} \end{align*} such that \begin{align*} \varphi_{\tau_k(q)}(z) \simeq \psi_{q,k}(z) \end{align*} for every concrete code $q \in \mathbb{N}$ and every tuple $z \in \mathbb{N}^k$. In the concrete machine model, finite instructions, numerals, and jumps are encoded by natural numbers using a fixed primitive recursive coding of finite strings. Hence, for the fixed pair $(m,n)$, there is a total computable assembler \begin{align*} A_{m,n}: \mathbb{N}^{m+1} &\to \mathbb{N} \end{align*} with this defining behaviour: $A_{m,n}(e,a_1,\dots,a_m)$ is the concrete code of the $n$-input machine which, on input $(x_1,\dots,x_n)$, writes the finite tuple $(e,a_1,\dots,a_m,x_1,\dots,x_n)$ on the simulated input tape, starts the concrete universal simulator with code $u_{m+n}$, and returns exactly the simulator's output if the simulation halts. The computability of $A_{m,n}$ follows from the [primitive recursive](/page/Primitive%20Recursive%20Function) coding of finite program strings: the assembler performs a bounded concatenation of a fixed wrapper template, the numerals for $e,a_1,\dots,a_m$, and the fixed instructions for invoking the universal simulator with code $u_{m+n}$. Define the constructor for the acceptable numbering by \begin{align*} C_{m,n}: \mathbb{N}^{m+1} &\to \mathbb{N} \\ (e,a_1,\dots,a_m) &\mapsto \tau_n(A_{m,n}(e,a_1,\dots,a_m)). \end{align*} Because $A_{m,n}$ and $\tau_n$ are total computable maps, their composition $C_{m,n}$ is total computable. [guided] Fix $m,n \geq 1$. The point that needs proof is not that a wrapper program exists informally, but that its index is obtained by one computable procedure from $(e,a_1,\dots,a_m)$. We therefore separate the construction into two formal operations: first assemble concrete machine code, then translate that code into the given acceptable numbering. For each arity $k \geq 1$, let \begin{align*} \psi_{q,k}: \mathbb{N}^k \rightharpoonup \mathbb{N} \end{align*} denote the $k$-ary partial function computed by concrete machine code $q \in \mathbb{N}$ in a fixed standard machine model. The hypothesis in the theorem statement that the displayed numbering $\varphi$ is [acceptable](/page/Acceptable%20Numbering) supplies two pieces of effective infrastructure. First, for each arity $k \geq 1$, there is a concrete code $u_k \in \mathbb{N}$ for a [universal function](/page/Universal%20Function) for $\varphi$, so that \begin{align*} \psi_{u_k,k+1}(e,z) \simeq \varphi_e(z) \end{align*} for every index $e \in \mathbb{N}$ and input tuple $z \in \mathbb{N}^k$. Second, there is a total computable compiler \begin{align*} \tau_k: \mathbb{N} &\to \mathbb{N} \end{align*} for each arity $k \geq 1$, with the preservation property \begin{align*} \varphi_{\tau_k(q)}(z) \simeq \psi_{q,k}(z) \end{align*} for all concrete codes $q \in \mathbb{N}$ and all input tuples $z \in \mathbb{N}^k$. The first fact is what lets a concrete wrapper run the program indexed by $e$ in the acceptable numbering; the second fact is what turns the resulting concrete wrapper code back into a $\varphi$-index. Now construct the concrete wrapper. In the fixed machine model, finite instruction strings are encoded by natural numbers, and the operations of writing a fixed instruction string, inserting a numeral, and concatenating finitely many encoded strings are primitive recursive operations on codes. For the fixed pair $(m,n)$, let \begin{align*} A_{m,n}: \mathbb{N}^{m+1} &\to \mathbb{N} \end{align*} be the assembler that sends $(e,a_1,\dots,a_m)$ to the code of the following $n$-input concrete machine: on input $(x_1,\dots,x_n)$, it writes the tuple $(e,a_1,\dots,a_m,x_1,\dots,x_n)$ as the input to the concrete simulator with code $u_{m+n}$, invokes that simulator, and returns the simulator's output if that simulation halts. This is a computable map because the template is fixed once $m$ and $n$ are fixed; the code $u_{m+n}$ is fixed for this arity; and the only variable operations are inserting the finitely many numerals $e,a_1,\dots,a_m$ and concatenating finitely many coded instruction blocks using [primitive recursive](/page/Primitive%20Recursive%20Function) string coding. Finally, we convert the concrete wrapper code into an index for the acceptable numbering by defining \begin{align*} C_{m,n}: \mathbb{N}^{m+1} &\to \mathbb{N} \\ (e,a_1,\dots,a_m) &\mapsto \tau_n(A_{m,n}(e,a_1,\dots,a_m)). \end{align*} The map $A_{m,n}$ is total computable by the explicit finite assembly construction, and $\tau_n$ is total computable by acceptability. Therefore $C_{m,n}$ is total computable as a composition of total computable maps. This proves the uniform computability claim rather than assuming it. [/guided] [/step] [step:Define the parameterizing function by the wrapper constructor] Define \begin{align*} s_{m,n}: \mathbb{N}^{m+1} &\to \mathbb{N} \\ (e,a_1,\dots,a_m) &\mapsto C_{m,n}(e,a_1,\dots,a_m). \end{align*} Since $C_{m,n}$ is total computable, the function $s_{m,n}$ is total computable. [/step] [step:Verify that the constructed index has the required computation] Let $e \in \mathbb{N}$, let $a = (a_1,\dots,a_m) \in \mathbb{N}^m$, and let $x = (x_1,\dots,x_n) \in \mathbb{N}^n$. By the definition of $s_{m,n}$, the index $s_{m,n}(e,a_1,\dots,a_m)$ denotes the compiled wrapper program constructed above. Therefore, on input $x$, this wrapper runs the concrete universal simulator with code $u_{m+n}$ on the tuple \begin{align*} (e,a_1,\dots,a_m,x_1,\dots,x_n). \end{align*} By the universal-simulation property of $u_{m+n}$, this concrete simulation is defined with value $y \in \mathbb{N}$ exactly when $\varphi_e(a_1,\dots,a_m,x_1,\dots,x_n)$ is defined with value $y$. If that simulated computation diverges, then the wrapper waits forever for the simulator and therefore also diverges. Hence \begin{align*} \varphi_{s_{m,n}(e,a_1,\dots,a_m)}(x_1,\dots,x_n) \simeq \varphi_e(a_1,\dots,a_m,x_1,\dots,x_n). \end{align*} Since $e$, $a$, and $x$ were arbitrary, this proves the required identity of partial computations for all indices, parameters, and inputs. [/step]