Computable functions

This file contains the definition of a Turing machine with some finiteness conditions (bundling the definition of TM2 in TuringMachine.lean), a definition of when a TM gives a certain output (in a certain time), and the definition of computability (in polynomial time or any time function) of a function between two types that have an encoding (as in Encoding.lean).

Main theorems

• idComputableInPolyTime : a TM + a proof it computes the identity on a type in polytime.
• idComputable : a TM + a proof it computes the identity on a type.

Implementation notes

To count the execution time of a Turing machine, we have decided to count the number of times the step function is used. Each step executes a statement (of type Stmt); this is a function, and generally contains multiple "fundamental" steps (pushing, popping, and so on). However, as functions only contain a finite number of executions and each one is executed at most once, this execution time is up to multiplication by a constant the amount of fundamental steps.

structure Turing.FinTM2 : Type 1

A bundled TM2 (an equivalent of the classical Turing machine, defined starting from the namespace Turing.TM2 in TuringMachine.lean), with an input and output stack, a main function, an initial state and some finiteness guarantees.

• K : Type

  index type of stacks

• kDecidableEq : DecidableEq self.K
• kFin : Fintype self.K

  A TM2 machine has finitely many stacks.

• k₀ : self.K

  input resp. output stack

• k₁ : self.K

  input resp. output stack

• Γ : self.K → Type

  type of stack elements

• Λ : Type

  type of function labels

• main : self.Λ

  a main function: the initial function that is executed, given by its label

• ΛFin : Fintype self.Λ

  A TM2 machine has finitely many function labels.

• σ : Type

  type of states of the machine

• initialState : self.σ

  the initial state of the machine

• σFin : Fintype self.σ

  a TM2 machine has finitely many internal states.

• Γk₀Fin : Fintype (self.Γ self.k₀)

  Each internal stack is finite.

• m : self.Λ → TM2.Stmt self.Γ self.Λ self.σ

  the program itself, i.e. one function for every function label

instance Turing.FinTM2.decidableEqK (tm : FinTM2) : DecidableEq tm.K

Equations

• tm.decidableEqK = tm.kDecidableEq

instance Turing.FinTM2.inhabitedσ (tm : FinTM2) : Inhabited tm.σ

Equations

• tm.inhabitedσ = { default := tm.initialState }

def Turing.FinTM2.Stmt (tm : FinTM2) : Type

The type of statements (functions) corresponding to this TM.

Equations

• tm.Stmt = Turing.TM2.Stmt tm.Γ tm.Λ tm.σ

instance Turing.FinTM2.inhabitedStmt (tm : FinTM2) : Inhabited tm.Stmt

Equations

• tm.inhabitedStmt = inferInstanceAs (Inhabited (Turing.TM2.Stmt tm.Γ tm.Λ tm.σ))

def Turing.FinTM2.Cfg (tm : FinTM2) : Type

The type of configurations (functions) corresponding to this TM.

Equations

• tm.Cfg = Turing.TM2.Cfg tm.Γ tm.Λ tm.σ

instance Turing.FinTM2.inhabitedCfg (tm : FinTM2) : Inhabited tm.Cfg

Equations

• tm.inhabitedCfg = Turing.TM2.Cfg.inhabited tm.Γ tm.Λ tm.σ

def Turing.FinTM2.step (tm : FinTM2) : tm.Cfg → Option tm.Cfg

The step function corresponding to this TM.

Equations

• tm.step = Turing.TM2.step tm.m

def Turing.initList (tm : FinTM2) (s : List (tm.Γ tm.k₀)) : tm.Cfg

The initial configuration corresponding to a list in the input alphabet.

Equations

• Turing.initList tm s = { l := some tm.main, var := tm.initialState, stk := fun (k : tm.K) => if h : k = tm.k₀ then ⋯.mpr s else [] }

def Turing.haltList (tm : FinTM2) (s : List (tm.Γ tm.k₁)) : tm.Cfg

The final configuration corresponding to a list in the output alphabet.

Equations

• Turing.haltList tm s = { l := none, var := tm.initialState, stk := fun (k : tm.K) => if h : k = tm.k₁ then ⋯.mpr s else [] }

structure Turing.EvalsTo {σ : Type u_1} (f : σ → Option σ) (a : σ) (b : Option σ) : Type

A "proof" of the fact that f eventually reaches b when repeatedly evaluated on a, remembering the number of steps it takes.

• steps : ℕ

  number of steps taken

• evals_in_steps : (flip bind f)^[self.steps] (some a) = b

structure Turing.EvalsToInTime {σ : Type u_1} (f : σ → Option σ) (a : σ) (b : Option σ) (m : ℕ) extends Turing.EvalsTo f a b : Type

A "proof" of the fact that f eventually reaches b in at most m steps when repeatedly evaluated on a, remembering the number of steps it takes.

• steps : ℕ
• evals_in_steps : (flip bind f)^[self.steps] (some a) = b
• steps_le_m : self.steps ≤ m

def Turing.EvalsTo.refl {σ : Type u_1} (f : σ → Option σ) (a : σ) : EvalsTo f a (some a)

Reflexivity of EvalsTo in 0 steps.

Equations

• Turing.EvalsTo.refl f a = { steps := 0, evals_in_steps := ⋯ }

def Turing.EvalsTo.trans {σ : Type u_1} (f : σ → Option σ) (a b : σ) (c : Option σ) (h₁ : EvalsTo f a (some b)) (h₂ : EvalsTo f b c) : EvalsTo f a c

Transitivity of EvalsTo in the sum of the numbers of steps.

Equations

• Turing.EvalsTo.trans f a b c h₁ h₂ = { steps := h₂.steps + h₁.steps, evals_in_steps := ⋯ }

def Turing.EvalsToInTime.refl {σ : Type u_1} (f : σ → Option σ) (a : σ) : EvalsToInTime f a (some a) 0

Reflexivity of EvalsToInTime in 0 steps.

Equations

• Turing.EvalsToInTime.refl f a = { toEvalsTo := Turing.EvalsTo.refl f a, steps_le_m := Turing.EvalsToInTime.refl.proof_1 }

def Turing.EvalsToInTime.trans {σ : Type u_1} (f : σ → Option σ) (m₁ m₂ : ℕ) (a b : σ) (c : Option σ) (h₁ : EvalsToInTime f a (some b) m₁) (h₂ : EvalsToInTime f b c m₂) : EvalsToInTime f a c (m₂ + m₁)

Transitivity of EvalsToInTime in the sum of the numbers of steps.

Equations

• Turing.EvalsToInTime.trans f m₁ m₂ a b c h₁ h₂ = { toEvalsTo := Turing.EvalsTo.trans f a b c h₁.toEvalsTo h₂.toEvalsTo, steps_le_m := ⋯ }

def Turing.TM2Outputs (tm : FinTM2) (l : List (tm.Γ tm.k₀)) (l' : Option (List (tm.Γ tm.k₁))) : Type

A proof of tm outputting l' when given l.

Equations

• Turing.TM2Outputs tm l l' = Turing.EvalsTo tm.step (Turing.initList tm l) (Option.map (Turing.haltList tm) l')

def Turing.TM2OutputsInTime (tm : FinTM2) (l : List (tm.Γ tm.k₀)) (l' : Option (List (tm.Γ tm.k₁))) (m : ℕ) : Type

A proof of tm outputting l' when given l in at most m steps.

Equations

• Turing.TM2OutputsInTime tm l l' m = Turing.EvalsToInTime tm.step (Turing.initList tm l) (Option.map (Turing.haltList tm) l') m

def Turing.TM2OutputsInTime.toTM2Outputs {tm : FinTM2} {l : List (tm.Γ tm.k₀)} {l' : Option (List (tm.Γ tm.k₁))} {m : ℕ} (h : TM2OutputsInTime tm l l' m) : TM2Outputs tm l l'

The forgetful map, forgetting the upper bound on the number of steps.

Equations

• h.toTM2Outputs = h.toEvalsTo

structure Turing.TM2ComputableAux (Γ₀ Γ₁ : Type) : Type 1

A (bundled TM2) Turing machine with input alphabet equivalent to Γ₀ and output alphabet equivalent to Γ₁.

• tm : FinTM2

  the underlying bundled TM2

• inputAlphabet : self.tm.Γ self.tm.k₀ ≃ Γ₀

  the input alphabet is equivalent to Γ₀

• outputAlphabet : self.tm.Γ self.tm.k₁ ≃ Γ₁

  the output alphabet is equivalent to Γ₁

structure Turing.TM2Computable {α β : Type} (ea : Computability.FinEncoding α) (eb : Computability.FinEncoding β) (f : α → β) extends Turing.TM2ComputableAux ea.Γ eb.Γ : Type 1

A Turing machine + a proof it outputs f.

• tm : FinTM2
• inputAlphabet : self.tm.Γ self.tm.k₀ ≃ ea.Γ
• outputAlphabet : self.tm.Γ self.tm.k₁ ≃ eb.Γ
• outputsFun (a : α) : TM2Outputs self.tm (List.map self.inputAlphabet.invFun (ea.encode a)) (some (List.map self.outputAlphabet.invFun (eb.encode (f a))))

  a proof this machine outputs f

structure Turing.TM2ComputableInTime {α β : Type} (ea : Computability.FinEncoding α) (eb : Computability.FinEncoding β) (f : α → β) extends Turing.TM2ComputableAux ea.Γ eb.Γ : Type 1

A Turing machine + a time function + a proof it outputs f in at most time(input.length) steps.

• tm : FinTM2
• inputAlphabet : self.tm.Γ self.tm.k₀ ≃ ea.Γ
• outputAlphabet : self.tm.Γ self.tm.k₁ ≃ eb.Γ
• time : ℕ → ℕ

  a time function

• outputsFun (a : α) : TM2OutputsInTime self.tm (List.map self.inputAlphabet.invFun (ea.encode a)) (some (List.map self.outputAlphabet.invFun (eb.encode (f a)))) (self.time (ea.encode a).length)

  proof this machine outputs f in at most time(input.length) steps

structure Turing.TM2ComputableInPolyTime {α β : Type} (ea : Computability.FinEncoding α) (eb : Computability.FinEncoding β) (f : α → β) extends Turing.TM2ComputableAux ea.Γ eb.Γ : Type 1

A Turing machine + a polynomial time function + a proof it outputs f in at most time(input.length) steps.

• tm : FinTM2
• inputAlphabet : self.tm.Γ self.tm.k₀ ≃ ea.Γ
• outputAlphabet : self.tm.Γ self.tm.k₁ ≃ eb.Γ
• time : Polynomial ℕ

  a polynomial time function

• outputsFun (a : α) : TM2OutputsInTime self.tm (List.map self.inputAlphabet.invFun (ea.encode a)) (some (List.map self.outputAlphabet.invFun (eb.encode (f a)))) (Polynomial.eval (ea.encode a).length self.time)

  proof that this machine outputs f in at most time(input.length) steps

def Turing.TM2ComputableInTime.toTM2Computable {α β : Type} {ea : Computability.FinEncoding α} {eb : Computability.FinEncoding β} {f : α → β} (h : TM2ComputableInTime ea eb f) : TM2Computable ea eb f

A forgetful map, forgetting the time bound on the number of steps.

Equations

• h.toTM2Computable = { toTM2ComputableAux := h.toTM2ComputableAux, outputsFun := fun (a : α) => (h.outputsFun a).toTM2Outputs }

def Turing.TM2ComputableInPolyTime.toTM2ComputableInTime {α β : Type} {ea : Computability.FinEncoding α} {eb : Computability.FinEncoding β} {f : α → β} (h : TM2ComputableInPolyTime ea eb f) : TM2ComputableInTime ea eb f

A forgetful map, forgetting that the time function is polynomial.

Equations

• h.toTM2ComputableInTime = { toTM2ComputableAux := h.toTM2ComputableAux, time := fun (n : ℕ) => Polynomial.eval n h.time, outputsFun := h.outputsFun }

def Turing.idComputer {α : Type} (ea : Computability.FinEncoding α) : FinTM2

A Turing machine computing the identity on α.

Equations

• Turing.idComputer ea = Turing.FinTM2.mk PUnit.unit PUnit.unit (fun (x : Unit) => ea.Γ) Unit PUnit.unit Unit PUnit.unit fun (x : Unit) => Turing.TM2.Stmt.halt

instance Turing.inhabitedFinTM2 : Inhabited FinTM2

Equations

• Turing.inhabitedFinTM2 = { default := Turing.idComputer default }

def Turing.idComputableInPolyTime {α : Type} (ea : Computability.FinEncoding α) : TM2ComputableInPolyTime ea ea id

A proof that the identity map on α is computable in polytime.

Equations

• One or more equations did not get rendered due to their size.

instance Turing.inhabitedTM2ComputableInPolyTime : Inhabited (TM2ComputableInPolyTime default default id)

Equations

• Turing.inhabitedTM2ComputableInPolyTime = { default := Turing.idComputableInPolyTime default }

instance Turing.inhabitedTM2OutputsInTime : Inhabited (TM2OutputsInTime (idComputer Computability.finEncodingBoolBool) (List.map (Equiv.cast ⋯).invFun [false]) (some (List.map (Equiv.cast ⋯).invFun [false])) (Polynomial.eval 1 1))

Equations

• Turing.inhabitedTM2OutputsInTime = { default := (Turing.idComputableInPolyTime Computability.finEncodingBoolBool).outputsFun false }

instance Turing.inhabitedTM2Outputs : Inhabited (TM2Outputs (idComputer Computability.finEncodingBoolBool) (List.map (Equiv.cast ⋯).invFun [false]) (some (List.map (Equiv.cast ⋯).invFun [false])))

Equations

• Turing.inhabitedTM2Outputs = { default := default.toTM2Outputs }

instance Turing.inhabitedEvalsToInTime : Inhabited (EvalsToInTime (fun (x : Unit) => some PUnit.unit) PUnit.unit (some PUnit.unit) 0)

Equations

• Turing.inhabitedEvalsToInTime = { default := Turing.EvalsToInTime.refl (fun (x : Unit) => some PUnit.unit) PUnit.unit }

instance Turing.inhabitedTM2EvalsTo : Inhabited (EvalsTo (fun (x : Unit) => some PUnit.unit) PUnit.unit (some PUnit.unit))

Equations

• Turing.inhabitedTM2EvalsTo = { default := Turing.EvalsTo.refl (fun (x : Unit) => some PUnit.unit) PUnit.unit }

def Turing.idComputableInTime {α : Type} (ea : Computability.FinEncoding α) : TM2ComputableInTime ea ea id

A proof that the identity map on α is computable in time.

Equations

• Turing.idComputableInTime ea = (Turing.idComputableInPolyTime ea).toTM2ComputableInTime

instance Turing.inhabitedTM2ComputableInTime : Inhabited (TM2ComputableInTime Computability.finEncodingBoolBool Computability.finEncodingBoolBool id)

Equations

• Turing.inhabitedTM2ComputableInTime = { default := Turing.idComputableInTime default }

def Turing.idComputable {α : Type} (ea : Computability.FinEncoding α) : TM2Computable ea ea id

A proof that the identity map on α is computable.

Equations

• Turing.idComputable ea = (Turing.idComputableInTime ea).toTM2Computable

instance Turing.inhabitedTM2Computable : Inhabited (TM2Computable Computability.finEncodingBoolBool Computability.finEncodingBoolBool id)

Equations

• Turing.inhabitedTM2Computable = { default := Turing.idComputable default }

instance Turing.inhabitedTM2ComputableAux : Inhabited (TM2ComputableAux Bool Bool)

Equations

• Turing.inhabitedTM2ComputableAux = { default := default.toTM2ComputableAux }