Δ_1 bootstrapping

Δ

1

bootstrapping

This proves that a number of useful

relations

and

functions

are

Δ

1

in

first order

arithmetic

, providing a bootstrapping of parts of mathematical practice into any system including the

Δ

1

relations (since the

Δ

1

relations are exactly the recursive ones, this includes

Turing machines

).

First, we want to build a tupling relation which will allow a

finite sets

of numbers to be encoded by a single number. To do this we first show that

R

(

a

,

b

)

↔

a

|

b

is

Δ

1

. This is true since

a

|

b

↔

∃

c

≤

b

(

a

⋅

c

=

b

)

, a

formula

with only

bounded quantifiers

.

Next note that

P

⁢

(

x

)

↔

x is prime

is

Δ

1

since

P

(

x

)

↔

¬

∃

y

<

x

(

¬

y

=

1

∧

y

|

x

)

. Also

A

P

(

x

,

y

)

↔

P

(

x

)

∧

P

(

y

)

∧

∀

z

<

y

(

x

<

z

→

¬

P

(

x

)

)

.

These two can be used to define (the graph of) a

primality

function,

p

⁢

(

a

)

=

a

+

1

-th prime

. Let

p

(

a

,

b

)

=

∃

c

≤

b

a

2

(

¬

[

2

|

c

]

∧

[

∀

q

<

b

∀

r

≤

b

(

A

P

(

q

,

r

)

→

∀

j

<

c

[

q

j

|

c

↔

r

j

+

1

|

c

]

)

]

∧

[

b

a

|

c

]

∧

¬

[

b

a

+

1

|

c

]

)

.

This rather awkward looking formula is worth examining, since it illustrates a principle which will be used repeatedly.

c

is intended to be a function of the form

2

0

⋅

3

1

⋅

5

2

⁢

⋯

and so on. If it includes

b

a

but not

b

a

+

1

then we know that

b

must be the

a

+

1

-th prime. The definition is so complicated because we cannot just say, as we’d like to,

p

⁢

(

a

+

1

)

is the smallest prime greater than

p

⁢

(

a

)

(since we don’t allow recursive definitions). Instead we embed the series of values this

recursion

would take into a single number (

c

) and guarantee that the recursive relationship holds for at least

a

terms; then we just check if the

a

-th value is

b

.

Finally, we can define our tupling relation. Technically, since a given relation must have a fixed arity, we define for each

n

a function

⟨

x

0

,

…

,

x

n

⟩

=

∑

≤

n

p

i

x

i

+

1

. Then define

(

x

)

i

to be the

i

-th element of

x

when

x

is interpreted as a tuple, so

⟨

(

x

)

0

,

…

,

(

x

)

n

⟩

=

x

. Note that the tupling relation, even taken collectively, is not total. For

instance

5

is not a tuple (although it is sometimes convenient to view it as a tuple with “empty spaces”:

⟨

_

,

_

,

5

⟩

). In situations like this, and also when attempting to extract entries beyond the length,

(

x

)

i

=

0

(for instance,

(

5

)

0

=

0

). On the other hand there is a

0

-ary tupling relation,

⟨

⟩

=

1

.

Thanks to our definition of

p

, we have

⟨

x

0

,

…

,

x

n

⟩

=

x

↔

x

=

p

⁢

(

0

)

x

0

+

1

⋅

⋯

⋅

p

⁢

(

n

)

x

n

+

1

. This is clearly

Δ

1

. (Note that we don’t use the

∑

as above, since we don’t have that, but since we have a different tupling function for each

n

this isn’t a problem.)

For the reverse,

(

x

)

i

=

y

↔

(

[

p

(

i

)

y

+

1

|

x

]

∧

¬

[

p

(

i

)

y

+

2

|

x

]

)

∨

(

[

y

=

0

]

∧

¬

[

p

(

i

)

|

x

]

)

.

Also, define a

length function

by

len

(

x

)

=

y

↔

¬

[

p

(

y

+

1

)

|

x

]

∧

∀

z

≤

y

[

p

(

z

)

|

x

]

and a membership relation by

in

(

x

,

n

)

↔

∃

i

<

len

(

x

)

[

(

x

)

i

=

n

]

.

Armed with this, we can show that all

primitive recursive functions

are

Δ

1

. To see this, note that

x

=

0

, the zero function, is trivially recursive, as are

x

=

S

⁢

y

and

p

n

,

m

⁢

(

x

1

,

…

,

x

n

)

=

x

m

.

The

Δ

1

functions are

closed under

composition

, since if

ϕ

⁢

(

x

→

)

and

ψ

⁢

(

x

→

)

both have no

unbounded

quantifiers

,

ϕ

⁢

(

ψ

⁢

(

x

→

)

)

obviously doesn’t either.

Finally, suppose we have functions

f

⁢

(

x

→

)

and

g

⁢

(

x

→

,

m

,

n

)

in

Δ

1

. Then define the

primitive recursion

h

⁢

(

x

→

,

y

)

by first defining:

h

¯

(

x

→

,

y

)

=

z

↔

l

n

(

z

)

=

y

∧

∀

i

<

y

[

(

z

)

i

+

1

=

g

(

x

→

,

i

,

(

z

)

i

)

]

∧

[

l

n

(

z

)

=

0

∨

(

z

)

0

=

f

(

x

→

)

and then

h

⁢

(

x

→

,

y

)

=

(

h

¯

⁢

(

x

→

,

y

)

)

y

.

Δ

1

is also closed under minimization: if

R

⁢

(

x

→

,

y

)

is a

Δ

1

relation then

μ

⁢

y

.

f

⁢

(

x

→

,

y

)

is a function giving the least

y

satisfying

R

⁢

(

x

→

,

y

)

. To see this, note that

μ

y

.

f

(

x

→

,

y

)

=

z

↔

f

(

x

→

,

z

)

∧

∀

m

<

z

¬

f

(

x

→

,

m

)

.

Finally, using primitive recursion it is possible to concatenate

sequences

. First, to concatenate a single number, if

s

=

⟨

x

0

,

…

⁢

x

n

⟩

then

s

*

1

y

=

t

⋅

p

⁢

(

len

⁡

(

s

)

+

1

)

y

+

1

. Then we can define the

concatenation

of

s

with

t

=

⟨

y

0

,

…

,

y

m

⟩

by defining

f

⁢

(

s

,

t

)

=

s

and

g

⁢

(

s

,

t

,

j

,

i

)

=

j

*

1

(

t

)

i

, and by primitive recursion, there is a function

h

⁢

(

s

,

t

,

i

)

whose value is the first

j

elements of

t

appended to

s

. Then

s

*

t

=

h

(

s

,

t

,

len

(

t

)

.

We can also define

*

u

, which concatenates only elements of

t

not appearing in

s

. This just requires defining the graph of

g

to be

g

(

s

,

t

,

j

,

i

,

x

)

↔

[

in

(

s

,

(

t

)

i

)

∧

x

=

j

]

∨

[

¬

in

(

s

,

(

t

)

i

)

∧

x

=

j

*

1

(

t

)

i

]

Title

Δ

1

bootstrapping

Canonical name

Delta1Bootstrapping

Date of creation

2013-03-22 12:58:25

Last modified on

2013-03-22 12:58:25

Owner

Henry (455)

Last modified by

Henry (455)

Numerical id

10

Author

Henry (455)

Entry type

Example

Classification

msc 03B10

Generated on Thu Feb 8 19:26:43 2018 by

LaTeXML