openAI-math-dataset / lean /OAI /Computability /PerfectCompleteness /Construction /FactoredFunctionsLemmas.lean
| import Mathlib.LinearAlgebra.Pi | |
| import Mathlib.LinearAlgebra.Span.Basic | |
| namespace OAI | |
| namespace PerfectCompleteness.FactoredFunctions | |
| variable {𝕜 Ω Z I J : Type*} [Field 𝕜] | |
| def factoringSpace (other : Ω → Z) : Submodule 𝕜 (Ω → 𝕜) where | |
| carrier := {f | ∀ x y, other x = other y → f x = f y} | |
| zero_mem' := by intro x y _; rfl | |
| add_mem' := by | |
| intro f g hf hg x y h | |
| change f x + g x = f y + g y | |
| rw [hf x y h, hg x y h] | |
| smul_mem' := by | |
| intro c f hf x y h | |
| change c • f x = c • f y | |
| rw [hf x y h] | |
| @[simp] theorem mem_factoringSpace (other : Ω → Z) (f : Ω → 𝕜) : | |
| f ∈ factoringSpace other ↔ ∀ x y, other x = other y → f x = f y := Iff.rfl | |
| theorem mem_factoringSpace_iff_exists_factor (other : Ω → Z) (f : Ω → 𝕜) : | |
| f ∈ factoringSpace other ↔ ∃ g : Z → 𝕜, ∀ x, f x = g (other x) := by | |
| classical | |
| constructor | |
| · intro hf | |
| let g : Z → 𝕜 := fun z => | |
| if h : ∃ x, other x = z then f (Classical.choose h) else 0 | |
| refine ⟨g, ?_⟩ | |
| intro x | |
| have hx : ∃ y, other y = other x := ⟨x, rfl⟩ | |
| change f x = if h : ∃ y, other y = other x then f (Classical.choose h) else 0 | |
| rw [dite_eq_left hx] | |
| exact hf x _ (Classical.choose_spec hx).symm | |
| · rintro ⟨g, hg⟩ x y h | |
| rw [hg x, hg y, h] | |
| theorem const_mem_factoringSpace (other : Ω → Z) (c : 𝕜) : | |
| (fun _ : Ω => c) ∈ factoringSpace other := by | |
| intro x y _ | |
| rfl | |
| theorem one_mem_factoringSpace (other : Ω → Z) : | |
| (1 : Ω → 𝕜) ∈ factoringSpace other := | |
| const_mem_factoringSpace other 1 | |
| theorem mul_mem_factoringSpace (other : Ω → Z) {f g : Ω → 𝕜} | |
| (hf : f ∈ factoringSpace other) (hg : g ∈ factoringSpace other) : | |
| f * g ∈ factoringSpace other := by | |
| intro x y h | |
| change f x * g x = f y * g y | |
| rw [hf x y h, hg x y h] | |
| theorem coordinate_mem_factoringSpace (lower : Ω → I → J → 𝕜) (i : I) (t : J) : | |
| (fun x => lower x i t) ∈ factoringSpace lower := by | |
| intro x y h | |
| exact congrFun (congrFun h i) t | |
| def quadraticSpan (lower : Ω → I → J → 𝕜) : Submodule 𝕜 (Ω → 𝕜) := | |
| Submodule.span 𝕜 {f | f = 1 ∨ | |
| ∃ (i : I) (t u : J), f = fun x => lower x i t * lower x i u} | |
| theorem one_mem_quadraticSpan (lower : Ω → I → J → 𝕜) : | |
| (1 : Ω → 𝕜) ∈ quadraticSpan lower := | |
| Submodule.subset_span (Or.inl rfl) | |
| theorem product_mem_quadraticSpan (lower : Ω → I → J → 𝕜) (i : I) (t u : J) : | |
| (fun x => lower x i t * lower x i u) ∈ quadraticSpan lower := | |
| Submodule.subset_span (Or.inr ⟨i, t, u, rfl⟩) | |
| theorem quadraticSpan_le_factoringSpace (lower : Ω → I → J → 𝕜) : | |
| quadraticSpan lower ≤ factoringSpace lower := by | |
| apply Submodule.span_le.mpr | |
| intro f hf | |
| rcases hf with rfl | ⟨i, t, u, rfl⟩ | |
| · exact one_mem_factoringSpace lower | |
| · exact mul_mem_factoringSpace lower | |
| (coordinate_mem_factoringSpace lower i t) (coordinate_mem_factoringSpace lower i u) | |
| noncomputable section | |
| def realizer (other : Ω → Z) (z : Set.range other) : Ω := | |
| Classical.choose z.property | |
| theorem realizer_spec (other : Ω → Z) (z : Set.range other) : | |
| other (realizer other z) = z.val := | |
| Classical.choose_spec z.property | |
| def evaluation {other : Ω → Z} {B : Submodule 𝕜 (Ω → 𝕜)} | |
| (_hB : B ≤ factoringSpace other) (z : Set.range other) : B →ₗ[𝕜] 𝕜 := | |
| (LinearMap.proj (realizer other z)).comp B.subtype | |
| @[simp] theorem evaluation_apply {other : Ω → Z} {B : Submodule 𝕜 (Ω → 𝕜)} | |
| (hB : B ≤ factoringSpace other) (z : Set.range other) (b : B) : | |
| evaluation hB z b = b.val (realizer other z) := rfl | |
| theorem evaluation_apply_of_eq {other : Ω → Z} {B : Submodule 𝕜 (Ω → 𝕜)} | |
| (hB : B ≤ factoringSpace other) (z : Set.range other) (x : Ω) | |
| (hx : other x = z.val) (b : B) : evaluation hB z b = b.val x := | |
| hB b.property (realizer other z) x ((realizer_spec other z).trans hx.symm) | |
| theorem evaluation_eq_pointEvaluation {other : Ω → Z} {B : Submodule 𝕜 (Ω → 𝕜)} | |
| (hB : B ≤ factoringSpace other) (z : Set.range other) (x : Ω) | |
| (hx : other x = z.val) : | |
| evaluation hB z = (LinearMap.proj x).comp B.subtype := by | |
| apply LinearMap.ext | |
| intro b | |
| exact evaluation_apply_of_eq hB z x hx b | |
| @[simp] theorem evaluation_at_image {other : Ω → Z} {B : Submodule 𝕜 (Ω → 𝕜)} | |
| (hB : B ≤ factoringSpace other) (x : Ω) (b : B) : | |
| evaluation hB ⟨other x, ⟨x, rfl⟩⟩ b = b.val x := | |
| evaluation_apply_of_eq hB _ x rfl b | |
| theorem evaluation_one {other : Ω → Z} {B : Submodule 𝕜 (Ω → 𝕜)} | |
| (hB : B ≤ factoringSpace other) (z : Set.range other) (h1 : (1 : Ω → 𝕜) ∈ B) : | |
| evaluation hB z ⟨1, h1⟩ = 1 := rfl | |
| end | |
| end PerfectCompleteness.FactoredFunctions | |
| namespace PerfectCompleteness.FactoredFunctionsDependent | |
| open PerfectCompleteness.FactoredFunctions | |
| variable {𝕜 Ω I : Type*} [Field 𝕜] {J : I → Type*} | |
| theorem coordinate_mem_factoringSpace (lower : Ω → (i : I) → J i → 𝕜) | |
| (i : I) (t : J i) : | |
| (fun x => lower x i t) ∈ factoringSpace lower := by | |
| intro x y h | |
| exact congrFun (congrFun h i) t | |
| def dependentQuadraticSpan (lower : Ω → (i : I) → J i → 𝕜) : | |
| Submodule 𝕜 (Ω → 𝕜) := | |
| Submodule.span 𝕜 {f | f = 1 ∨ | |
| ∃ (i : I) (t u : J i), f = fun x => lower x i t * lower x i u} | |
| theorem one_mem_dependentQuadraticSpan (lower : Ω → (i : I) → J i → 𝕜) : | |
| (1 : Ω → 𝕜) ∈ dependentQuadraticSpan lower := | |
| Submodule.subset_span (Or.inl rfl) | |
| theorem product_mem_dependentQuadraticSpan (lower : Ω → (i : I) → J i → 𝕜) | |
| (i : I) (t u : J i) : | |
| (fun x => lower x i t * lower x i u) ∈ dependentQuadraticSpan lower := | |
| Submodule.subset_span (Or.inr ⟨i, t, u, rfl⟩) | |
| theorem dependentQuadraticSpan_le_factoringSpace (lower : Ω → (i : I) → J i → 𝕜) : | |
| dependentQuadraticSpan lower ≤ factoringSpace lower := by | |
| apply Submodule.span_le.mpr | |
| intro f hf | |
| rcases hf with rfl | ⟨i, t, u, rfl⟩ | |
| · exact one_mem_factoringSpace lower | |
| · exact mul_mem_factoringSpace lower | |
| (coordinate_mem_factoringSpace lower i t) (coordinate_mem_factoringSpace lower i u) | |
| end PerfectCompleteness.FactoredFunctionsDependent | |
| end OAI | |