Mathlib.Analysis.FixedPoint.Banach

import Std.Logic.Eq
import Mathlib.Topology.Metric.Basic
import Mathlib.LinearAlgebra.VectorSpace
import Mathlib.Analysis.NormedSpace.Basic

def CauchySeq.{s,u,v} :
  forall (Scalar : Sort u), forall (zero : Scalar), forall (one : Scalar), forall (add : forall (a : Scalar), forall (b : Scalar), Scalar), forall (neg : forall (a : Scalar), Scalar), forall (sub : forall (a : Scalar), forall (b : Scalar), Scalar), forall (mul : forall (a : Scalar), forall (b : Scalar), Scalar), forall (le_rel : forall (a : Scalar), forall (b : Scalar), Prop), forall (Vector : Sort v), forall (vzero : Vector), forall (vadd : forall (x : Vector), forall (y : Vector), Vector), forall (vneg : forall (x : Vector), Vector), forall (smul : forall (a : Scalar), forall (x : Vector), Vector), forall (norm : forall (x : Vector), Scalar), forall (CauchySmall : forall (Sequence : Sort s), forall (seq : forall (n : Sequence), Vector), forall (eps : Scalar), Prop), forall (Sequence : Sort s), forall (seq : forall (n : Sequence), Vector), Prop :=
  fun Scalar => fun zero => fun one => fun add => fun neg => fun sub => fun mul => fun le_rel => fun Vector => fun vzero => fun vadd => fun vneg => fun smul => fun norm => fun CauchySmall => fun Sequence => fun seq => forall (eps : Scalar), CauchySmall Sequence seq eps

def ConvergesTo.{s,u,v} :
  forall (Scalar : Sort u), forall (zero : Scalar), forall (one : Scalar), forall (add : forall (a : Scalar), forall (b : Scalar), Scalar), forall (neg : forall (a : Scalar), Scalar), forall (sub : forall (a : Scalar), forall (b : Scalar), Scalar), forall (mul : forall (a : Scalar), forall (b : Scalar), Scalar), forall (le_rel : forall (a : Scalar), forall (b : Scalar), Prop), forall (Vector : Sort v), forall (vzero : Vector), forall (vadd : forall (x : Vector), forall (y : Vector), Vector), forall (vneg : forall (x : Vector), Vector), forall (smul : forall (a : Scalar), forall (x : Vector), Vector), forall (norm : forall (x : Vector), Scalar), forall (ConvergesSmall : forall (Sequence : Sort s), forall (seq : forall (n : Sequence), Vector), forall (limit : Vector), forall (eps : Scalar), Prop), forall (Sequence : Sort s), forall (seq : forall (n : Sequence), Vector), forall (limit : Vector), Prop :=
  fun Scalar => fun zero => fun one => fun add => fun neg => fun sub => fun mul => fun le_rel => fun Vector => fun vzero => fun vadd => fun vneg => fun smul => fun norm => fun ConvergesSmall => fun Sequence => fun seq => fun limit => forall (eps : Scalar), ConvergesSmall Sequence seq limit eps

def CompleteMetricArgs.{s,u,v} :
  forall (Scalar : Sort u), forall (zero : Scalar), forall (one : Scalar), forall (add : forall (a : Scalar), forall (b : Scalar), Scalar), forall (neg : forall (a : Scalar), Scalar), forall (sub : forall (a : Scalar), forall (b : Scalar), Scalar), forall (mul : forall (a : Scalar), forall (b : Scalar), Scalar), forall (le_rel : forall (a : Scalar), forall (b : Scalar), Prop), forall (Vector : Sort v), forall (vzero : Vector), forall (vadd : forall (x : Vector), forall (y : Vector), Vector), forall (vneg : forall (x : Vector), Vector), forall (smul : forall (a : Scalar), forall (x : Vector), Vector), forall (norm : forall (x : Vector), Scalar), forall (CauchySmall : forall (Sequence : Sort s), forall (seq : forall (n : Sequence), Vector), forall (eps : Scalar), Prop), forall (ConvergesSmall : forall (Sequence : Sort s), forall (seq : forall (n : Sequence), Vector), forall (limit : Vector), forall (eps : Scalar), Prop), Prop :=
  fun Scalar => fun zero => fun one => fun add => fun neg => fun sub => fun mul => fun le_rel => fun Vector => fun vzero => fun vadd => fun vneg => fun smul => fun norm => fun CauchySmall => fun ConvergesSmall => forall (Sequence : Sort s), forall (seq : forall (n : Sequence), Vector), forall (cauchy : @CauchySeq.{s,u,v} Scalar zero one add neg sub mul le_rel Vector vzero vadd vneg smul norm CauchySmall Sequence seq), forall (P : Prop), forall (choose : forall (limit : Vector), forall (converges : @ConvergesTo.{s,u,v} Scalar zero one add neg sub mul le_rel Vector vzero vadd vneg smul norm ConvergesSmall Sequence seq limit), P), P

def SelfMapOn.{u,v} :
  forall (Scalar : Sort u), forall (zero : Scalar), forall (one : Scalar), forall (add : forall (a : Scalar), forall (b : Scalar), Scalar), forall (neg : forall (a : Scalar), Scalar), forall (sub : forall (a : Scalar), forall (b : Scalar), Scalar), forall (mul : forall (a : Scalar), forall (b : Scalar), Scalar), forall (le_rel : forall (a : Scalar), forall (b : Scalar), Prop), forall (Vector : Sort v), forall (vzero : Vector), forall (vadd : forall (x : Vector), forall (y : Vector), Vector), forall (vneg : forall (x : Vector), Vector), forall (smul : forall (a : Scalar), forall (x : Vector), Vector), forall (norm : forall (x : Vector), Scalar), forall (domain : forall (x : Vector), Prop), forall (T : forall (x : Vector), Vector), Prop :=
  fun Scalar => fun zero => fun one => fun add => fun neg => fun sub => fun mul => fun le_rel => fun Vector => fun vzero => fun vadd => fun vneg => fun smul => fun norm => fun domain => fun T => forall (x : Vector), forall (hx : domain x), domain (T x)

def ContractiveOn.{u,v} :
  forall (Scalar : Sort u), forall (zero : Scalar), forall (one : Scalar), forall (add : forall (a : Scalar), forall (b : Scalar), Scalar), forall (neg : forall (a : Scalar), Scalar), forall (sub : forall (a : Scalar), forall (b : Scalar), Scalar), forall (mul : forall (a : Scalar), forall (b : Scalar), Scalar), forall (le_rel : forall (a : Scalar), forall (b : Scalar), Prop), forall (Vector : Sort v), forall (vzero : Vector), forall (vadd : forall (x : Vector), forall (y : Vector), Vector), forall (vneg : forall (x : Vector), Vector), forall (smul : forall (a : Scalar), forall (x : Vector), Vector), forall (norm : forall (x : Vector), Scalar), forall (domain : forall (x : Vector), Prop), forall (T : forall (x : Vector), Vector), forall (k : Scalar), Prop :=
  fun Scalar => fun zero => fun one => fun add => fun neg => fun sub => fun mul => fun le_rel => fun Vector => fun vzero => fun vadd => fun vneg => fun smul => fun norm => fun domain => fun T => fun k => forall (x : Vector), forall (y : Vector), forall (hx : domain x), forall (hy : domain y), le_rel (@NormDist.{u,v} Scalar zero one add neg sub mul le_rel Vector vzero vadd vneg smul norm (T x) (T y)) (mul k (@NormDist.{u,v} Scalar zero one add neg sub mul le_rel Vector vzero vadd vneg smul norm x y))

def FixedPoint.{u,v} :
  forall (Scalar : Sort u), forall (zero : Scalar), forall (one : Scalar), forall (add : forall (a : Scalar), forall (b : Scalar), Scalar), forall (neg : forall (a : Scalar), Scalar), forall (sub : forall (a : Scalar), forall (b : Scalar), Scalar), forall (mul : forall (a : Scalar), forall (b : Scalar), Scalar), forall (le_rel : forall (a : Scalar), forall (b : Scalar), Prop), forall (Vector : Sort v), forall (vzero : Vector), forall (vadd : forall (x : Vector), forall (y : Vector), Vector), forall (vneg : forall (x : Vector), Vector), forall (smul : forall (a : Scalar), forall (x : Vector), Vector), forall (norm : forall (x : Vector), Scalar), forall (domain : forall (x : Vector), Prop), forall (T : forall (x : Vector), Vector), forall (fixed : Vector), Prop :=
  fun Scalar => fun zero => fun one => fun add => fun neg => fun sub => fun mul => fun le_rel => fun Vector => fun vzero => fun vadd => fun vneg => fun smul => fun norm => fun domain => fun T => fun fixed => @Eq.{v} Vector (T fixed) fixed

def FixedPointStability.{u,v} :
  forall (Scalar : Sort u), forall (zero : Scalar), forall (one : Scalar), forall (add : forall (a : Scalar), forall (b : Scalar), Scalar), forall (neg : forall (a : Scalar), Scalar), forall (sub : forall (a : Scalar), forall (b : Scalar), Scalar), forall (mul : forall (a : Scalar), forall (b : Scalar), Scalar), forall (le_rel : forall (a : Scalar), forall (b : Scalar), Prop), forall (Vector : Sort v), forall (vzero : Vector), forall (vadd : forall (x : Vector), forall (y : Vector), Vector), forall (vneg : forall (x : Vector), Vector), forall (smul : forall (a : Scalar), forall (x : Vector), Vector), forall (norm : forall (x : Vector), Scalar), forall (domain : forall (x : Vector), Prop), forall (T : forall (x : Vector), Vector), forall (stable : forall (x : Vector), Prop), Prop :=
  fun Scalar => fun zero => fun one => fun add => fun neg => fun sub => fun mul => fun le_rel => fun Vector => fun vzero => fun vadd => fun vneg => fun smul => fun norm => fun domain => fun T => fun stable => @LocalPred.{v} Vector domain stable

def FixedPointEvidence.{u,v} :
  forall (Scalar : Sort u), forall (zero : Scalar), forall (one : Scalar), forall (add : forall (a : Scalar), forall (b : Scalar), Scalar), forall (neg : forall (a : Scalar), Scalar), forall (sub : forall (a : Scalar), forall (b : Scalar), Scalar), forall (mul : forall (a : Scalar), forall (b : Scalar), Scalar), forall (le_rel : forall (a : Scalar), forall (b : Scalar), Prop), forall (Vector : Sort v), forall (vzero : Vector), forall (vadd : forall (x : Vector), forall (y : Vector), Vector), forall (vneg : forall (x : Vector), Vector), forall (smul : forall (a : Scalar), forall (x : Vector), Vector), forall (norm : forall (x : Vector), Scalar), forall (domain : forall (x : Vector), Prop), forall (T : forall (x : Vector), Vector), forall (fixed : Vector), forall (stable : forall (x : Vector), Prop), Prop :=
  fun Scalar => fun zero => fun one => fun add => fun neg => fun sub => fun mul => fun le_rel => fun Vector => fun vzero => fun vadd => fun vneg => fun smul => fun norm => fun domain => fun T => fun fixed => fun stable => forall (P : Prop), forall (mk : forall (point_mem_law : domain fixed), forall (fixed_law : @FixedPoint.{u,v} Scalar zero one add neg sub mul le_rel Vector vzero vadd vneg smul norm domain T fixed), forall (unique_law : forall (other : Vector), forall (other_mem : domain other), forall (other_fixed : @FixedPoint.{u,v} Scalar zero one add neg sub mul le_rel Vector vzero vadd vneg smul norm domain T other), @Eq.{v} Vector other fixed), forall (stable_law : @FixedPointStability.{u,v} Scalar zero one add neg sub mul le_rel Vector vzero vadd vneg smul norm domain T stable), P), P

def FixedPointResult.{u,v} :
  forall (Scalar : Sort u), forall (zero : Scalar), forall (one : Scalar), forall (add : forall (a : Scalar), forall (b : Scalar), Scalar), forall (neg : forall (a : Scalar), Scalar), forall (sub : forall (a : Scalar), forall (b : Scalar), Scalar), forall (mul : forall (a : Scalar), forall (b : Scalar), Scalar), forall (le_rel : forall (a : Scalar), forall (b : Scalar), Prop), forall (Vector : Sort v), forall (vzero : Vector), forall (vadd : forall (x : Vector), forall (y : Vector), Vector), forall (vneg : forall (x : Vector), Vector), forall (smul : forall (a : Scalar), forall (x : Vector), Vector), forall (norm : forall (x : Vector), Scalar), forall (domain : forall (x : Vector), Prop), forall (T : forall (x : Vector), Vector), forall (stable : forall (x : Vector), Prop), Prop :=
  fun Scalar => fun zero => fun one => fun add => fun neg => fun sub => fun mul => fun le_rel => fun Vector => fun vzero => fun vadd => fun vneg => fun smul => fun norm => fun domain => fun T => fun stable => forall (P : Prop), forall (mk : forall (fixed : Vector), forall (evidence : @FixedPointEvidence.{u,v} Scalar zero one add neg sub mul le_rel Vector vzero vadd vneg smul norm domain T fixed stable), P), P

def BanachFixedPointArgs.{s,u,v} :
  forall (Scalar : Sort u), forall (zero : Scalar), forall (one : Scalar), forall (add : forall (a : Scalar), forall (b : Scalar), Scalar), forall (neg : forall (a : Scalar), Scalar), forall (sub : forall (a : Scalar), forall (b : Scalar), Scalar), forall (mul : forall (a : Scalar), forall (b : Scalar), Scalar), forall (le_rel : forall (a : Scalar), forall (b : Scalar), Prop), forall (Vector : Sort v), forall (vzero : Vector), forall (vadd : forall (x : Vector), forall (y : Vector), Vector), forall (vneg : forall (x : Vector), Vector), forall (smul : forall (a : Scalar), forall (x : Vector), Vector), forall (norm : forall (x : Vector), Scalar), forall (domain : forall (x : Vector), Prop), forall (T : forall (x : Vector), Vector), forall (CauchySmall : forall (Sequence : Sort s), forall (seq : forall (n : Sequence), Vector), forall (eps : Scalar), Prop), forall (ConvergesSmall : forall (Sequence : Sort s), forall (seq : forall (n : Sequence), Vector), forall (limit : Vector), forall (eps : Scalar), Prop), forall (k : Scalar), forall (stable : forall (x : Vector), Prop), Prop :=
  fun Scalar => fun zero => fun one => fun add => fun neg => fun sub => fun mul => fun le_rel => fun Vector => fun vzero => fun vadd => fun vneg => fun smul => fun norm => fun domain => fun T => fun CauchySmall => fun ConvergesSmall => fun k => fun stable => forall (complete_args : @CompleteMetricArgs.{s,u,v} Scalar zero one add neg sub mul le_rel Vector vzero vadd vneg smul norm CauchySmall ConvergesSmall), forall (strict_k : Prop), forall (strict_k_holds : strict_k), forall (self_map : @SelfMapOn.{u,v} Scalar zero one add neg sub mul le_rel Vector vzero vadd vneg smul norm domain T), forall (contractive : @ContractiveOn.{u,v} Scalar zero one add neg sub mul le_rel Vector vzero vadd vneg smul norm domain T k), @FixedPointResult.{u,v} Scalar zero one add neg sub mul le_rel Vector vzero vadd vneg smul norm domain T stable

theorem cauchy_seq_intro.{s,u,v} :
  forall (Scalar : Sort u), forall (zero : Scalar), forall (one : Scalar), forall (add : forall (a : Scalar), forall (b : Scalar), Scalar), forall (neg : forall (a : Scalar), Scalar), forall (sub : forall (a : Scalar), forall (b : Scalar), Scalar), forall (mul : forall (a : Scalar), forall (b : Scalar), Scalar), forall (le_rel : forall (a : Scalar), forall (b : Scalar), Prop), forall (Vector : Sort v), forall (vzero : Vector), forall (vadd : forall (x : Vector), forall (y : Vector), Vector), forall (vneg : forall (x : Vector), Vector), forall (smul : forall (a : Scalar), forall (x : Vector), Vector), forall (norm : forall (x : Vector), Scalar), forall (CauchySmall : forall (Sequence : Sort s), forall (seq : forall (n : Sequence), Vector), forall (eps : Scalar), Prop), forall (Sequence : Sort s), forall (seq : forall (n : Sequence), Vector), forall (h : forall (eps : Scalar), CauchySmall Sequence seq eps), @CauchySeq.{s,u,v} Scalar zero one add neg sub mul le_rel Vector vzero vadd vneg smul norm CauchySmall Sequence seq :=
  fun Scalar => fun zero => fun one => fun add => fun neg => fun sub => fun mul => fun le_rel => fun Vector => fun vzero => fun vadd => fun vneg => fun smul => fun norm => fun CauchySmall => fun Sequence => fun seq => fun h => h

theorem cauchy_seq_apply.{s,u,v} :
  forall (Scalar : Sort u), forall (zero : Scalar), forall (one : Scalar), forall (add : forall (a : Scalar), forall (b : Scalar), Scalar), forall (neg : forall (a : Scalar), Scalar), forall (sub : forall (a : Scalar), forall (b : Scalar), Scalar), forall (mul : forall (a : Scalar), forall (b : Scalar), Scalar), forall (le_rel : forall (a : Scalar), forall (b : Scalar), Prop), forall (Vector : Sort v), forall (vzero : Vector), forall (vadd : forall (x : Vector), forall (y : Vector), Vector), forall (vneg : forall (x : Vector), Vector), forall (smul : forall (a : Scalar), forall (x : Vector), Vector), forall (norm : forall (x : Vector), Scalar), forall (CauchySmall : forall (Sequence : Sort s), forall (seq : forall (n : Sequence), Vector), forall (eps : Scalar), Prop), forall (Sequence : Sort s), forall (seq : forall (n : Sequence), Vector), forall (cauchy : @CauchySeq.{s,u,v} Scalar zero one add neg sub mul le_rel Vector vzero vadd vneg smul norm CauchySmall Sequence seq), forall (eps : Scalar), CauchySmall Sequence seq eps :=
  fun Scalar => fun zero => fun one => fun add => fun neg => fun sub => fun mul => fun le_rel => fun Vector => fun vzero => fun vadd => fun vneg => fun smul => fun norm => fun CauchySmall => fun Sequence => fun seq => fun cauchy => fun eps => cauchy eps

theorem converges_to_intro.{s,u,v} :
  forall (Scalar : Sort u), forall (zero : Scalar), forall (one : Scalar), forall (add : forall (a : Scalar), forall (b : Scalar), Scalar), forall (neg : forall (a : Scalar), Scalar), forall (sub : forall (a : Scalar), forall (b : Scalar), Scalar), forall (mul : forall (a : Scalar), forall (b : Scalar), Scalar), forall (le_rel : forall (a : Scalar), forall (b : Scalar), Prop), forall (Vector : Sort v), forall (vzero : Vector), forall (vadd : forall (x : Vector), forall (y : Vector), Vector), forall (vneg : forall (x : Vector), Vector), forall (smul : forall (a : Scalar), forall (x : Vector), Vector), forall (norm : forall (x : Vector), Scalar), forall (ConvergesSmall : forall (Sequence : Sort s), forall (seq : forall (n : Sequence), Vector), forall (limit : Vector), forall (eps : Scalar), Prop), forall (Sequence : Sort s), forall (seq : forall (n : Sequence), Vector), forall (limit : Vector), forall (h : forall (eps : Scalar), ConvergesSmall Sequence seq limit eps), @ConvergesTo.{s,u,v} Scalar zero one add neg sub mul le_rel Vector vzero vadd vneg smul norm ConvergesSmall Sequence seq limit :=
  fun Scalar => fun zero => fun one => fun add => fun neg => fun sub => fun mul => fun le_rel => fun Vector => fun vzero => fun vadd => fun vneg => fun smul => fun norm => fun ConvergesSmall => fun Sequence => fun seq => fun limit => fun h => h

theorem converges_to_apply.{s,u,v} :
  forall (Scalar : Sort u), forall (zero : Scalar), forall (one : Scalar), forall (add : forall (a : Scalar), forall (b : Scalar), Scalar), forall (neg : forall (a : Scalar), Scalar), forall (sub : forall (a : Scalar), forall (b : Scalar), Scalar), forall (mul : forall (a : Scalar), forall (b : Scalar), Scalar), forall (le_rel : forall (a : Scalar), forall (b : Scalar), Prop), forall (Vector : Sort v), forall (vzero : Vector), forall (vadd : forall (x : Vector), forall (y : Vector), Vector), forall (vneg : forall (x : Vector), Vector), forall (smul : forall (a : Scalar), forall (x : Vector), Vector), forall (norm : forall (x : Vector), Scalar), forall (ConvergesSmall : forall (Sequence : Sort s), forall (seq : forall (n : Sequence), Vector), forall (limit : Vector), forall (eps : Scalar), Prop), forall (Sequence : Sort s), forall (seq : forall (n : Sequence), Vector), forall (limit : Vector), forall (converges : @ConvergesTo.{s,u,v} Scalar zero one add neg sub mul le_rel Vector vzero vadd vneg smul norm ConvergesSmall Sequence seq limit), forall (eps : Scalar), ConvergesSmall Sequence seq limit eps :=
  fun Scalar => fun zero => fun one => fun add => fun neg => fun sub => fun mul => fun le_rel => fun Vector => fun vzero => fun vadd => fun vneg => fun smul => fun norm => fun ConvergesSmall => fun Sequence => fun seq => fun limit => fun converges => fun eps => converges eps

theorem complete_metric_limit_from_args.{s,u,v} :
  forall (Scalar : Sort u), forall (zero : Scalar), forall (one : Scalar), forall (add : forall (a : Scalar), forall (b : Scalar), Scalar), forall (neg : forall (a : Scalar), Scalar), forall (sub : forall (a : Scalar), forall (b : Scalar), Scalar), forall (mul : forall (a : Scalar), forall (b : Scalar), Scalar), forall (le_rel : forall (a : Scalar), forall (b : Scalar), Prop), forall (Vector : Sort v), forall (vzero : Vector), forall (vadd : forall (x : Vector), forall (y : Vector), Vector), forall (vneg : forall (x : Vector), Vector), forall (smul : forall (a : Scalar), forall (x : Vector), Vector), forall (norm : forall (x : Vector), Scalar), forall (CauchySmall : forall (Sequence : Sort s), forall (seq : forall (n : Sequence), Vector), forall (eps : Scalar), Prop), forall (ConvergesSmall : forall (Sequence : Sort s), forall (seq : forall (n : Sequence), Vector), forall (limit : Vector), forall (eps : Scalar), Prop), forall (complete_args : @CompleteMetricArgs.{s,u,v} Scalar zero one add neg sub mul le_rel Vector vzero vadd vneg smul norm CauchySmall ConvergesSmall), forall (Sequence : Sort s), forall (seq : forall (n : Sequence), Vector), forall (cauchy : @CauchySeq.{s,u,v} Scalar zero one add neg sub mul le_rel Vector vzero vadd vneg smul norm CauchySmall Sequence seq), forall (P : Prop), forall (choose : forall (limit : Vector), forall (converges : @ConvergesTo.{s,u,v} Scalar zero one add neg sub mul le_rel Vector vzero vadd vneg smul norm ConvergesSmall Sequence seq limit), P), P :=
  fun Scalar => fun zero => fun one => fun add => fun neg => fun sub => fun mul => fun le_rel => fun Vector => fun vzero => fun vadd => fun vneg => fun smul => fun norm => fun CauchySmall => fun ConvergesSmall => fun complete_args => fun Sequence => fun seq => fun cauchy => fun P => fun choose => complete_args Sequence seq cauchy P choose

theorem self_map_on_apply.{u,v} :
  forall (Scalar : Sort u), forall (zero : Scalar), forall (one : Scalar), forall (add : forall (a : Scalar), forall (b : Scalar), Scalar), forall (neg : forall (a : Scalar), Scalar), forall (sub : forall (a : Scalar), forall (b : Scalar), Scalar), forall (mul : forall (a : Scalar), forall (b : Scalar), Scalar), forall (le_rel : forall (a : Scalar), forall (b : Scalar), Prop), forall (Vector : Sort v), forall (vzero : Vector), forall (vadd : forall (x : Vector), forall (y : Vector), Vector), forall (vneg : forall (x : Vector), Vector), forall (smul : forall (a : Scalar), forall (x : Vector), Vector), forall (norm : forall (x : Vector), Scalar), forall (domain : forall (x : Vector), Prop), forall (T : forall (x : Vector), Vector), forall (self_map : @SelfMapOn.{u,v} Scalar zero one add neg sub mul le_rel Vector vzero vadd vneg smul norm domain T), forall (x : Vector), forall (hx : domain x), domain (T x) :=
  fun Scalar => fun zero => fun one => fun add => fun neg => fun sub => fun mul => fun le_rel => fun Vector => fun vzero => fun vadd => fun vneg => fun smul => fun norm => fun domain => fun T => fun self_map => fun x => fun hx => self_map x hx

theorem contractive_on_apply.{u,v} :
  forall (Scalar : Sort u), forall (zero : Scalar), forall (one : Scalar), forall (add : forall (a : Scalar), forall (b : Scalar), Scalar), forall (neg : forall (a : Scalar), Scalar), forall (sub : forall (a : Scalar), forall (b : Scalar), Scalar), forall (mul : forall (a : Scalar), forall (b : Scalar), Scalar), forall (le_rel : forall (a : Scalar), forall (b : Scalar), Prop), forall (Vector : Sort v), forall (vzero : Vector), forall (vadd : forall (x : Vector), forall (y : Vector), Vector), forall (vneg : forall (x : Vector), Vector), forall (smul : forall (a : Scalar), forall (x : Vector), Vector), forall (norm : forall (x : Vector), Scalar), forall (domain : forall (x : Vector), Prop), forall (T : forall (x : Vector), Vector), forall (k : Scalar), forall (contractive : @ContractiveOn.{u,v} Scalar zero one add neg sub mul le_rel Vector vzero vadd vneg smul norm domain T k), forall (x : Vector), forall (y : Vector), forall (hx : domain x), forall (hy : domain y), le_rel (@NormDist.{u,v} Scalar zero one add neg sub mul le_rel Vector vzero vadd vneg smul norm (T x) (T y)) (mul k (@NormDist.{u,v} Scalar zero one add neg sub mul le_rel Vector vzero vadd vneg smul norm x y)) :=
  fun Scalar => fun zero => fun one => fun add => fun neg => fun sub => fun mul => fun le_rel => fun Vector => fun vzero => fun vadd => fun vneg => fun smul => fun norm => fun domain => fun T => fun k => fun contractive => fun x => fun y => fun hx => fun hy => contractive x y hx hy

theorem fixed_point_def.{u,v} :
  forall (Scalar : Sort u), forall (zero : Scalar), forall (one : Scalar), forall (add : forall (a : Scalar), forall (b : Scalar), Scalar), forall (neg : forall (a : Scalar), Scalar), forall (sub : forall (a : Scalar), forall (b : Scalar), Scalar), forall (mul : forall (a : Scalar), forall (b : Scalar), Scalar), forall (le_rel : forall (a : Scalar), forall (b : Scalar), Prop), forall (Vector : Sort v), forall (vzero : Vector), forall (vadd : forall (x : Vector), forall (y : Vector), Vector), forall (vneg : forall (x : Vector), Vector), forall (smul : forall (a : Scalar), forall (x : Vector), Vector), forall (norm : forall (x : Vector), Scalar), forall (domain : forall (x : Vector), Prop), forall (T : forall (x : Vector), Vector), forall (fixed : Vector), @Eq.{1} Prop (@FixedPoint.{u,v} Scalar zero one add neg sub mul le_rel Vector vzero vadd vneg smul norm domain T fixed) (@Eq.{v} Vector (T fixed) fixed) :=
  fun Scalar => fun zero => fun one => fun add => fun neg => fun sub => fun mul => fun le_rel => fun Vector => fun vzero => fun vadd => fun vneg => fun smul => fun norm => fun domain => fun T => fun fixed => @Eq.refl.{1} Prop (@FixedPoint.{u,v} Scalar zero one add neg sub mul le_rel Vector vzero vadd vneg smul norm domain T fixed)

theorem fixed_point_stability_apply.{u,v} :
  forall (Scalar : Sort u), forall (zero : Scalar), forall (one : Scalar), forall (add : forall (a : Scalar), forall (b : Scalar), Scalar), forall (neg : forall (a : Scalar), Scalar), forall (sub : forall (a : Scalar), forall (b : Scalar), Scalar), forall (mul : forall (a : Scalar), forall (b : Scalar), Scalar), forall (le_rel : forall (a : Scalar), forall (b : Scalar), Prop), forall (Vector : Sort v), forall (vzero : Vector), forall (vadd : forall (x : Vector), forall (y : Vector), Vector), forall (vneg : forall (x : Vector), Vector), forall (smul : forall (a : Scalar), forall (x : Vector), Vector), forall (norm : forall (x : Vector), Scalar), forall (domain : forall (x : Vector), Prop), forall (T : forall (x : Vector), Vector), forall (stable : forall (x : Vector), Prop), forall (stability : @FixedPointStability.{u,v} Scalar zero one add neg sub mul le_rel Vector vzero vadd vneg smul norm domain T stable), forall (x : Vector), forall (hx : domain x), stable x :=
  fun Scalar => fun zero => fun one => fun add => fun neg => fun sub => fun mul => fun le_rel => fun Vector => fun vzero => fun vadd => fun vneg => fun smul => fun norm => fun domain => fun T => fun stable => fun stability => fun x => fun hx => stability x hx

theorem fixed_point_evidence_intro.{u,v} :
  forall (Scalar : Sort u), forall (zero : Scalar), forall (one : Scalar), forall (add : forall (a : Scalar), forall (b : Scalar), Scalar), forall (neg : forall (a : Scalar), Scalar), forall (sub : forall (a : Scalar), forall (b : Scalar), Scalar), forall (mul : forall (a : Scalar), forall (b : Scalar), Scalar), forall (le_rel : forall (a : Scalar), forall (b : Scalar), Prop), forall (Vector : Sort v), forall (vzero : Vector), forall (vadd : forall (x : Vector), forall (y : Vector), Vector), forall (vneg : forall (x : Vector), Vector), forall (smul : forall (a : Scalar), forall (x : Vector), Vector), forall (norm : forall (x : Vector), Scalar), forall (domain : forall (x : Vector), Prop), forall (T : forall (x : Vector), Vector), forall (fixed : Vector), forall (stable : forall (x : Vector), Prop), forall (point_mem_law : domain fixed), forall (fixed_law : @FixedPoint.{u,v} Scalar zero one add neg sub mul le_rel Vector vzero vadd vneg smul norm domain T fixed), forall (unique_law : forall (other : Vector), forall (other_mem : domain other), forall (other_fixed : @FixedPoint.{u,v} Scalar zero one add neg sub mul le_rel Vector vzero vadd vneg smul norm domain T other), @Eq.{v} Vector other fixed), forall (stable_law : @FixedPointStability.{u,v} Scalar zero one add neg sub mul le_rel Vector vzero vadd vneg smul norm domain T stable), @FixedPointEvidence.{u,v} Scalar zero one add neg sub mul le_rel Vector vzero vadd vneg smul norm domain T fixed stable :=
  fun Scalar => fun zero => fun one => fun add => fun neg => fun sub => fun mul => fun le_rel => fun Vector => fun vzero => fun vadd => fun vneg => fun smul => fun norm => fun domain => fun T => fun fixed => fun stable => fun point_mem_law => fun fixed_law => fun unique_law => fun stable_law => fun (P : Prop) => fun (mk : forall (point_mem_law : domain fixed), forall (fixed_law : @FixedPoint.{u,v} Scalar zero one add neg sub mul le_rel Vector vzero vadd vneg smul norm domain T fixed), forall (unique_law : forall (other : Vector), forall (other_mem : domain other), forall (other_fixed : @FixedPoint.{u,v} Scalar zero one add neg sub mul le_rel Vector vzero vadd vneg smul norm domain T other), @Eq.{v} Vector other fixed), forall (stable_law : @FixedPointStability.{u,v} Scalar zero one add neg sub mul le_rel Vector vzero vadd vneg smul norm domain T stable), P) => mk point_mem_law fixed_law unique_law stable_law

theorem fixed_point_evidence_elim.{u,v} :
  forall (Scalar : Sort u), forall (zero : Scalar), forall (one : Scalar), forall (add : forall (a : Scalar), forall (b : Scalar), Scalar), forall (neg : forall (a : Scalar), Scalar), forall (sub : forall (a : Scalar), forall (b : Scalar), Scalar), forall (mul : forall (a : Scalar), forall (b : Scalar), Scalar), forall (le_rel : forall (a : Scalar), forall (b : Scalar), Prop), forall (Vector : Sort v), forall (vzero : Vector), forall (vadd : forall (x : Vector), forall (y : Vector), Vector), forall (vneg : forall (x : Vector), Vector), forall (smul : forall (a : Scalar), forall (x : Vector), Vector), forall (norm : forall (x : Vector), Scalar), forall (domain : forall (x : Vector), Prop), forall (T : forall (x : Vector), Vector), forall (fixed : Vector), forall (stable : forall (x : Vector), Prop), forall (evidence : @FixedPointEvidence.{u,v} Scalar zero one add neg sub mul le_rel Vector vzero vadd vneg smul norm domain T fixed stable), forall (P : Prop), forall (mk : forall (point_mem_law : domain fixed), forall (fixed_law : @FixedPoint.{u,v} Scalar zero one add neg sub mul le_rel Vector vzero vadd vneg smul norm domain T fixed), forall (unique_law : forall (other : Vector), forall (other_mem : domain other), forall (other_fixed : @FixedPoint.{u,v} Scalar zero one add neg sub mul le_rel Vector vzero vadd vneg smul norm domain T other), @Eq.{v} Vector other fixed), forall (stable_law : @FixedPointStability.{u,v} Scalar zero one add neg sub mul le_rel Vector vzero vadd vneg smul norm domain T stable), P), P :=
  fun Scalar => fun zero => fun one => fun add => fun neg => fun sub => fun mul => fun le_rel => fun Vector => fun vzero => fun vadd => fun vneg => fun smul => fun norm => fun domain => fun T => fun fixed => fun stable => fun evidence => fun P => fun mk => evidence P mk

theorem fixed_point_mem_from_evidence.{u,v} :
  forall (Scalar : Sort u), forall (zero : Scalar), forall (one : Scalar), forall (add : forall (a : Scalar), forall (b : Scalar), Scalar), forall (neg : forall (a : Scalar), Scalar), forall (sub : forall (a : Scalar), forall (b : Scalar), Scalar), forall (mul : forall (a : Scalar), forall (b : Scalar), Scalar), forall (le_rel : forall (a : Scalar), forall (b : Scalar), Prop), forall (Vector : Sort v), forall (vzero : Vector), forall (vadd : forall (x : Vector), forall (y : Vector), Vector), forall (vneg : forall (x : Vector), Vector), forall (smul : forall (a : Scalar), forall (x : Vector), Vector), forall (norm : forall (x : Vector), Scalar), forall (domain : forall (x : Vector), Prop), forall (T : forall (x : Vector), Vector), forall (fixed : Vector), forall (stable : forall (x : Vector), Prop), forall (evidence : @FixedPointEvidence.{u,v} Scalar zero one add neg sub mul le_rel Vector vzero vadd vneg smul norm domain T fixed stable), domain fixed :=
  fun Scalar => fun zero => fun one => fun add => fun neg => fun sub => fun mul => fun le_rel => fun Vector => fun vzero => fun vadd => fun vneg => fun smul => fun norm => fun domain => fun T => fun fixed => fun stable => fun evidence => evidence (domain fixed) (fun (point_mem_arg : domain fixed) => fun (fixed_eq_arg : @FixedPoint.{u,v} Scalar zero one add neg sub mul le_rel Vector vzero vadd vneg smul norm domain T fixed) => fun (unique_arg : forall (other : Vector), forall (other_mem : domain other), forall (other_fixed : @FixedPoint.{u,v} Scalar zero one add neg sub mul le_rel Vector vzero vadd vneg smul norm domain T other), @Eq.{v} Vector other fixed) => fun (stable_arg : @FixedPointStability.{u,v} Scalar zero one add neg sub mul le_rel Vector vzero vadd vneg smul norm domain T stable) => point_mem_arg)

theorem fixed_point_eq_from_evidence.{u,v} :
  forall (Scalar : Sort u), forall (zero : Scalar), forall (one : Scalar), forall (add : forall (a : Scalar), forall (b : Scalar), Scalar), forall (neg : forall (a : Scalar), Scalar), forall (sub : forall (a : Scalar), forall (b : Scalar), Scalar), forall (mul : forall (a : Scalar), forall (b : Scalar), Scalar), forall (le_rel : forall (a : Scalar), forall (b : Scalar), Prop), forall (Vector : Sort v), forall (vzero : Vector), forall (vadd : forall (x : Vector), forall (y : Vector), Vector), forall (vneg : forall (x : Vector), Vector), forall (smul : forall (a : Scalar), forall (x : Vector), Vector), forall (norm : forall (x : Vector), Scalar), forall (domain : forall (x : Vector), Prop), forall (T : forall (x : Vector), Vector), forall (fixed : Vector), forall (stable : forall (x : Vector), Prop), forall (evidence : @FixedPointEvidence.{u,v} Scalar zero one add neg sub mul le_rel Vector vzero vadd vneg smul norm domain T fixed stable), @FixedPoint.{u,v} Scalar zero one add neg sub mul le_rel Vector vzero vadd vneg smul norm domain T fixed :=
  fun Scalar => fun zero => fun one => fun add => fun neg => fun sub => fun mul => fun le_rel => fun Vector => fun vzero => fun vadd => fun vneg => fun smul => fun norm => fun domain => fun T => fun fixed => fun stable => fun evidence => evidence (@FixedPoint.{u,v} Scalar zero one add neg sub mul le_rel Vector vzero vadd vneg smul norm domain T fixed) (fun (point_mem_arg : domain fixed) => fun (fixed_eq_arg : @FixedPoint.{u,v} Scalar zero one add neg sub mul le_rel Vector vzero vadd vneg smul norm domain T fixed) => fun (unique_arg : forall (other : Vector), forall (other_mem : domain other), forall (other_fixed : @FixedPoint.{u,v} Scalar zero one add neg sub mul le_rel Vector vzero vadd vneg smul norm domain T other), @Eq.{v} Vector other fixed) => fun (stable_arg : @FixedPointStability.{u,v} Scalar zero one add neg sub mul le_rel Vector vzero vadd vneg smul norm domain T stable) => fixed_eq_arg)

theorem fixed_point_unique_from_evidence.{u,v} :
  forall (Scalar : Sort u), forall (zero : Scalar), forall (one : Scalar), forall (add : forall (a : Scalar), forall (b : Scalar), Scalar), forall (neg : forall (a : Scalar), Scalar), forall (sub : forall (a : Scalar), forall (b : Scalar), Scalar), forall (mul : forall (a : Scalar), forall (b : Scalar), Scalar), forall (le_rel : forall (a : Scalar), forall (b : Scalar), Prop), forall (Vector : Sort v), forall (vzero : Vector), forall (vadd : forall (x : Vector), forall (y : Vector), Vector), forall (vneg : forall (x : Vector), Vector), forall (smul : forall (a : Scalar), forall (x : Vector), Vector), forall (norm : forall (x : Vector), Scalar), forall (domain : forall (x : Vector), Prop), forall (T : forall (x : Vector), Vector), forall (fixed : Vector), forall (stable : forall (x : Vector), Prop), forall (evidence : @FixedPointEvidence.{u,v} Scalar zero one add neg sub mul le_rel Vector vzero vadd vneg smul norm domain T fixed stable), forall (other : Vector), forall (other_mem : domain other), forall (other_fixed : @FixedPoint.{u,v} Scalar zero one add neg sub mul le_rel Vector vzero vadd vneg smul norm domain T other), @Eq.{v} Vector other fixed :=
  fun Scalar => fun zero => fun one => fun add => fun neg => fun sub => fun mul => fun le_rel => fun Vector => fun vzero => fun vadd => fun vneg => fun smul => fun norm => fun domain => fun T => fun fixed => fun stable => fun evidence => fun other => fun other_mem => fun other_fixed => evidence (@Eq.{v} Vector other fixed) (fun (point_mem_arg : domain fixed) => fun (fixed_eq_arg : @FixedPoint.{u,v} Scalar zero one add neg sub mul le_rel Vector vzero vadd vneg smul norm domain T fixed) => fun (unique_arg : forall (other : Vector), forall (other_mem : domain other), forall (other_fixed : @FixedPoint.{u,v} Scalar zero one add neg sub mul le_rel Vector vzero vadd vneg smul norm domain T other), @Eq.{v} Vector other fixed) => fun (stable_arg : @FixedPointStability.{u,v} Scalar zero one add neg sub mul le_rel Vector vzero vadd vneg smul norm domain T stable) => unique_arg other other_mem other_fixed)

theorem fixed_point_stability_from_evidence.{u,v} :
  forall (Scalar : Sort u), forall (zero : Scalar), forall (one : Scalar), forall (add : forall (a : Scalar), forall (b : Scalar), Scalar), forall (neg : forall (a : Scalar), Scalar), forall (sub : forall (a : Scalar), forall (b : Scalar), Scalar), forall (mul : forall (a : Scalar), forall (b : Scalar), Scalar), forall (le_rel : forall (a : Scalar), forall (b : Scalar), Prop), forall (Vector : Sort v), forall (vzero : Vector), forall (vadd : forall (x : Vector), forall (y : Vector), Vector), forall (vneg : forall (x : Vector), Vector), forall (smul : forall (a : Scalar), forall (x : Vector), Vector), forall (norm : forall (x : Vector), Scalar), forall (domain : forall (x : Vector), Prop), forall (T : forall (x : Vector), Vector), forall (fixed : Vector), forall (stable : forall (x : Vector), Prop), forall (evidence : @FixedPointEvidence.{u,v} Scalar zero one add neg sub mul le_rel Vector vzero vadd vneg smul norm domain T fixed stable), @FixedPointStability.{u,v} Scalar zero one add neg sub mul le_rel Vector vzero vadd vneg smul norm domain T stable :=
  fun Scalar => fun zero => fun one => fun add => fun neg => fun sub => fun mul => fun le_rel => fun Vector => fun vzero => fun vadd => fun vneg => fun smul => fun norm => fun domain => fun T => fun fixed => fun stable => fun evidence => evidence (@FixedPointStability.{u,v} Scalar zero one add neg sub mul le_rel Vector vzero vadd vneg smul norm domain T stable) (fun (point_mem_arg : domain fixed) => fun (fixed_eq_arg : @FixedPoint.{u,v} Scalar zero one add neg sub mul le_rel Vector vzero vadd vneg smul norm domain T fixed) => fun (unique_arg : forall (other : Vector), forall (other_mem : domain other), forall (other_fixed : @FixedPoint.{u,v} Scalar zero one add neg sub mul le_rel Vector vzero vadd vneg smul norm domain T other), @Eq.{v} Vector other fixed) => fun (stable_arg : @FixedPointStability.{u,v} Scalar zero one add neg sub mul le_rel Vector vzero vadd vneg smul norm domain T stable) => stable_arg)

theorem fixed_point_result_intro.{u,v} :
  forall (Scalar : Sort u), forall (zero : Scalar), forall (one : Scalar), forall (add : forall (a : Scalar), forall (b : Scalar), Scalar), forall (neg : forall (a : Scalar), Scalar), forall (sub : forall (a : Scalar), forall (b : Scalar), Scalar), forall (mul : forall (a : Scalar), forall (b : Scalar), Scalar), forall (le_rel : forall (a : Scalar), forall (b : Scalar), Prop), forall (Vector : Sort v), forall (vzero : Vector), forall (vadd : forall (x : Vector), forall (y : Vector), Vector), forall (vneg : forall (x : Vector), Vector), forall (smul : forall (a : Scalar), forall (x : Vector), Vector), forall (norm : forall (x : Vector), Scalar), forall (domain : forall (x : Vector), Prop), forall (T : forall (x : Vector), Vector), forall (stable : forall (x : Vector), Prop), forall (fixed : Vector), forall (evidence : @FixedPointEvidence.{u,v} Scalar zero one add neg sub mul le_rel Vector vzero vadd vneg smul norm domain T fixed stable), @FixedPointResult.{u,v} Scalar zero one add neg sub mul le_rel Vector vzero vadd vneg smul norm domain T stable :=
  fun Scalar => fun zero => fun one => fun add => fun neg => fun sub => fun mul => fun le_rel => fun Vector => fun vzero => fun vadd => fun vneg => fun smul => fun norm => fun domain => fun T => fun stable => fun fixed => fun evidence => fun (P : Prop) => fun (mk : forall (fixed : Vector), forall (evidence : @FixedPointEvidence.{u,v} Scalar zero one add neg sub mul le_rel Vector vzero vadd vneg smul norm domain T fixed stable), P) => mk fixed evidence

theorem fixed_point_result_elim.{u,v} :
  forall (Scalar : Sort u), forall (zero : Scalar), forall (one : Scalar), forall (add : forall (a : Scalar), forall (b : Scalar), Scalar), forall (neg : forall (a : Scalar), Scalar), forall (sub : forall (a : Scalar), forall (b : Scalar), Scalar), forall (mul : forall (a : Scalar), forall (b : Scalar), Scalar), forall (le_rel : forall (a : Scalar), forall (b : Scalar), Prop), forall (Vector : Sort v), forall (vzero : Vector), forall (vadd : forall (x : Vector), forall (y : Vector), Vector), forall (vneg : forall (x : Vector), Vector), forall (smul : forall (a : Scalar), forall (x : Vector), Vector), forall (norm : forall (x : Vector), Scalar), forall (domain : forall (x : Vector), Prop), forall (T : forall (x : Vector), Vector), forall (stable : forall (x : Vector), Prop), forall (result : @FixedPointResult.{u,v} Scalar zero one add neg sub mul le_rel Vector vzero vadd vneg smul norm domain T stable), forall (P : Prop), forall (mk : forall (fixed : Vector), forall (evidence : @FixedPointEvidence.{u,v} Scalar zero one add neg sub mul le_rel Vector vzero vadd vneg smul norm domain T fixed stable), P), P :=
  fun Scalar => fun zero => fun one => fun add => fun neg => fun sub => fun mul => fun le_rel => fun Vector => fun vzero => fun vadd => fun vneg => fun smul => fun norm => fun domain => fun T => fun stable => fun result => fun P => fun mk => result P mk

theorem banach_fixed_point_from_args.{s,u,v} :
  forall (Scalar : Sort u), forall (zero : Scalar), forall (one : Scalar), forall (add : forall (a : Scalar), forall (b : Scalar), Scalar), forall (neg : forall (a : Scalar), Scalar), forall (sub : forall (a : Scalar), forall (b : Scalar), Scalar), forall (mul : forall (a : Scalar), forall (b : Scalar), Scalar), forall (le_rel : forall (a : Scalar), forall (b : Scalar), Prop), forall (Vector : Sort v), forall (vzero : Vector), forall (vadd : forall (x : Vector), forall (y : Vector), Vector), forall (vneg : forall (x : Vector), Vector), forall (smul : forall (a : Scalar), forall (x : Vector), Vector), forall (norm : forall (x : Vector), Scalar), forall (domain : forall (x : Vector), Prop), forall (T : forall (x : Vector), Vector), forall (CauchySmall : forall (Sequence : Sort s), forall (seq : forall (n : Sequence), Vector), forall (eps : Scalar), Prop), forall (ConvergesSmall : forall (Sequence : Sort s), forall (seq : forall (n : Sequence), Vector), forall (limit : Vector), forall (eps : Scalar), Prop), forall (k : Scalar), forall (stable : forall (x : Vector), Prop), forall (args : @BanachFixedPointArgs.{s,u,v} Scalar zero one add neg sub mul le_rel Vector vzero vadd vneg smul norm domain T CauchySmall ConvergesSmall k stable), forall (complete_args : @CompleteMetricArgs.{s,u,v} Scalar zero one add neg sub mul le_rel Vector vzero vadd vneg smul norm CauchySmall ConvergesSmall), forall (strict_k : Prop), forall (strict_k_holds : strict_k), forall (self_map : @SelfMapOn.{u,v} Scalar zero one add neg sub mul le_rel Vector vzero vadd vneg smul norm domain T), forall (contractive : @ContractiveOn.{u,v} Scalar zero one add neg sub mul le_rel Vector vzero vadd vneg smul norm domain T k), @FixedPointResult.{u,v} Scalar zero one add neg sub mul le_rel Vector vzero vadd vneg smul norm domain T stable :=
  fun Scalar => fun zero => fun one => fun add => fun neg => fun sub => fun mul => fun le_rel => fun Vector => fun vzero => fun vadd => fun vneg => fun smul => fun norm => fun domain => fun T => fun CauchySmall => fun ConvergesSmall => fun k => fun stable => fun args => fun complete_args => fun strict_k => fun strict_k_holds => fun self_map => fun contractive => args complete_args strict_k strict_k_holds self_map contractive