| import OAI.Computability.FourierCircuit.InventoryValidity |
|
|
| namespace OAI |
|
|
| section |
| noncomputable section |
| namespace ExactFourier.Packing |
| open scoped Pointwise |
|
|
| /-- Finite comparison alternative, exactly the separator needed for no-win prices. -/ |
| theorem finite_separator {ρ τ : Type} [Fintype ρ] [Fintype τ] [Nonempty τ] |
| (Δ : ρ→τ→ℝ) |
| (hn : ¬∃ lam : ρ→ℝ,(∀ r,0≤lam r) ∧ ∀ t,0<∑ r,lam r*Δ r t) : |
| ∃ v : τ→ℝ,(∀ t,0≤v t) ∧ (∃ t,0<v t) ∧ ∀ r,∑ t,v t*Δ r t≤0 := by |
| classical |
| let C : Set (τ→ℝ) := {x | ∃ lam : ρ→ℝ,(∀ r,0≤lam r) ∧ x=∑ r,lam r • Δ r} |
| let O : Set (τ→ℝ) := {x | ∀ t,0<x t} |
| have hC : Convex ℝ C := by |
| intro x hx y hy a b ha hb hab |
| obtain ⟨lam,hl,rfl⟩ := hx |
| obtain ⟨mu,hm,rfl⟩ := hy |
| refine ⟨fun r=>a*lam r+b*mu r,fun r=>add_nonneg (mul_nonneg ha (hl r)) (mul_nonneg hb (hm r)),?_⟩ |
| simp [Finset.smul_sum,add_smul,smul_smul,Finset.sum_add_distrib] |
| have hO : Convex ℝ O := by |
| intro x hx y hy a b ha hb hab t |
| change 0<a*x t+b*y t |
| have h1 := mul_nonneg ha (hx t).le |
| have h2 := mul_nonneg hb (hy t).le |
| rcases lt_or_eq_of_le ha with hp|hp |
| · exact add_pos_of_pos_of_nonneg (mul_pos hp (hx t)) h2 |
| · have hb' : b=1 := by linarith |
| simp [← hp,hb',hy t] |
| have ho : IsOpen O := by |
| rw [show O=⋂ t : τ,{x : τ→ℝ | 0<x t} by ext x; simp [O]] |
| exact isOpen_iInter_of_finite (fun t=>isOpen_lt continuous_const (continuous_apply t)) |
| have hzC : (0 : τ→ℝ)∈C := ⟨0,fun _=>le_rfl,by simp⟩ |
| have hzero : (0 : τ→ℝ)∉O-C := by |
| rintro ⟨x,hx,y,⟨lam,hl,hy⟩,he⟩ |
| have heq : x=y := sub_eq_zero.mp he |
| apply hn |
| refine ⟨lam,hl,?_⟩ |
| intro t |
| have hh := hx t |
| rw [heq,hy] at hh |
| simpa using hh |
| obtain ⟨f,hf⟩ := geometric_hahn_banach_point_open (hO.sub hC) (ho.sub_right) hzero |
| have hfone : 0<f (fun _ : τ=>1) := by |
| simpa only [map_zero] using hf _ (show (fun _ : τ=>1)∈O-C from ⟨_,fun _=>zero_lt_one,0,hzC,by simp⟩) |
| have hrep : ∀ x : τ→ℝ,f x=∑ t,x t*f (Pi.single t 1) := by |
| intro x |
| have he : x=∑ t,x t • Pi.single t (1 : ℝ) := by ext i; simp [Pi.single_apply] |
| calc |
| f x=f (∑ t,x t • Pi.single t (1 : ℝ)) := congrArg f he |
| _ = _ := by simp only [map_sum,map_smul,smul_eq_mul] |
| let v : τ→ℝ := fun t=>f (Pi.single t 1) |
| have hval : ∀ t,0≤v t := by |
| intro t |
| by_contra hn |
| have hv : v t<0 := lt_of_not_ge hn |
| let e := -v t/(2*f (fun _ : τ=>1)) |
| have he : 0<e := div_pos (neg_pos.mpr hv) (mul_pos (by norm_num) hfone) |
| have hp : Pi.single t (1 : ℝ)+e • (fun _ : τ=>1)∈O := by |
| intro i |
| change 0<(Pi.single t (1 : ℝ) : τ→ℝ) i+e*1 |
| have hh : 0≤(Pi.single t (1 : ℝ) : τ→ℝ) i := by simp only [Pi.single_apply]; split_ifs <;> norm_num |
| simpa only [mul_one] using add_pos_of_nonneg_of_pos hh he |
| have hh := hf _ (show Pi.single t (1 : ℝ)+e • (fun _ : τ=>1)∈O-C from ⟨_,hp,0,hzC,by simp⟩) |
| simp only [map_zero,map_add,map_smul,smul_eq_mul] at hh |
| have heq : e*f (fun _ : τ=>1)= -v t/2 := by dsimp [e]; field_simp |
| rw [heq] at hh |
| change 0<v t+(-v t/2) at hh |
| linarith |
| have hnonzero : ∃ t,0<v t := by |
| by_contra hn |
| push Not at hn |
| have hv : ∀ t,v t=0 := fun t=>le_antisymm (hn t) (hval t) |
| rw [hrep] at hfone |
| change ∀ t,f (Pi.single t 1)=0 at hv |
| simp only [hv,mul_zero,Finset.sum_const_zero] at hfone |
| exact lt_irrefl _ hfone |
| refine ⟨v,hval,hnonzero,?_⟩ |
| intro r |
| have hr : Δ r∈C := by |
| refine ⟨Pi.single r 1,fun i=>by simp only [Pi.single_apply]; split_ifs <;> norm_num,?_⟩ |
| simp [Pi.single_apply] |
| have hle : f (Δ r)≤0 := by |
| by_contra hn |
| have hd : 0<f (Δ r) := lt_of_not_ge hn |
| let e := f (Δ r)/(2*f (fun _ : τ=>1)) |
| have he : 0<e := div_pos hd (mul_pos (by norm_num) hfone) |
| have hp : e • (fun _ : τ=>1)∈O := by intro t; simpa using he |
| have hh := hf _ (show e • (fun _ : τ=>1)-Δ r∈O-C from ⟨_,hp,_,hr,rfl⟩) |
| simp only [map_zero,map_sub,map_smul,smul_eq_mul] at hh |
| have heq : e*f (fun _ : τ=>1)= f (Δ r)/2 := by dsimp [e]; field_simp |
| rw [heq] at hh |
| linarith |
| rw [hrep] at hle |
| simpa only [v,mul_comm] using hle |
|
|
| end ExactFourier.Packing |
|
|
| end |
| end |
|
|
| section |
| noncomputable section |
| namespace ExactFourier.Packing |
| variable {τ : Type} [Fintype τ] [DecidableEq τ] |
| {D : τ→Type} [∀ t,Fintype (D t)] [∀ t,DecidableEq (D t)] |
| {A : ∀ t,Matrix (D t) (D t) ℂ} |
| {ρ : Type} [Fintype ρ] [DecidableEq ρ] |
|
|
| theorem no_win_separator (hno : ¬FiniteWinStatement) (hA : ∀ t,IsUnit (A t)) |
| (u : τ) (hn : ¬MonomialMatrix (A u)) (c : ρ→PairComparison (A := A)) : |
| ∃ v : τ→ℝ,(∀ t,0≤v t) ∧ (∃ t,0<v t) ∧ |
| ∀ r,pairPrice (D := D) v (c r).pair≤(c r).word.weight v := by |
| let : Nonempty τ := ⟨u⟩ |
| obtain ⟨v,hv,hvn,hc⟩ := finite_separator (fun r t=>((c r).delta t : ℝ)) (by |
| rintro ⟨lam,hl,hp⟩ |
| exact hno (positive_comparison_win hA u hn c lam hl hp)) |
| exact ⟨v,hv,hvn,fun r=>(comparison_ineq v (c r)).mp (hc r)⟩ |
|
|
| theorem finite_prices (hno : ¬FiniteWinStatement) (hA : ∀ t,IsUnit (A t)) |
| (u : τ) (hn : ¬MonomialMatrix (A u)) (c : ρ→PairComparison (A := A)) |
| (C : τ→ℕ) (upper : ∀ t,Word D A (D t)) (hu : ∀ t,(upper t).matrix=A t) |
| (hcost : ∀ t (p : τ→ℝ),(upper t).weight p=(C t : ℝ)*p u) : |
| ∃ p : τ→ℝ,(∀ t,0≤p t ∧ p t≤C t) ∧ p u=1 ∧ |
| ∀ r,pairPrice (D := D) p (c r).pair≤(c r).word.weight p := by |
| let cc : ρ⊕τ→PairComparison (A := A) := Sum.elim c (fun t=>singleComparison t (upper t) (hu t)) |
| obtain ⟨v,hv,⟨t,ht⟩,hc⟩ := no_win_separator hno hA u hn cc |
| have hub : ∀ t,v t≤(C t : ℝ)*v u := by |
| intro t |
| have hh := hc (Sum.inr t) |
| change pairPrice (D := D) v (singleComparison t (upper t) (hu t)).pair≤ |
| (singleComparison t (upper t) (hu t)).word.weight v at hh |
| rw [singleComparison_price,singleComparison_weight,hcost] at hh |
| exact hh |
| have hvu : 0<v u := by |
| by_contra hh |
| have he : v u=0 := le_antisymm (le_of_not_gt hh) (hv u) |
| have h := hub t |
| rw [he,mul_zero] at h |
| exact (not_lt_of_ge h) ht |
| let p : τ→ℝ := fun t=>v t/v u |
| refine ⟨p,?_,by dsimp [p]; exact div_self hvu.ne',?_⟩ |
| · intro t |
| refine ⟨div_nonneg (hv t) hvu.le,?_⟩ |
| exact (div_le_iff₀ hvu).mpr (hub t) |
| · intro r |
| apply (comparison_ineq p (c r)).mp |
| simp only [p,div_mul_eq_mul_div,← Finset.sum_div] |
| exact div_nonpos_of_nonpos_of_nonneg ((comparison_ineq v (c r)).mpr (hc (Sum.inl r))) hvu.le |
|
|
| end ExactFourier.Packing |
|
|
| end |
| end |
|
|
| section |
| noncomputable section |
| namespace ExactFourier.Packing |
|
|
| theorem finite_global_prices (hno : ¬FiniteWinStatement) (Q : Finset GlobalComparison) : |
| ∃ p : GMatrix→ℝ,(∀ g,0≤p g ∧ p g≤g.upperCost) ∧ p shearG=1 ∧ |
| ∀ c∈Q,c.holds p := by |
| classical |
| let s : Finset GMatrix := insert shearG (Q.biUnion fun c=>Finset.univ.image c.family) |
| have hs : ∀ c∈Q,∀ t,c.family t∈s := by |
| intro c hc t |
| apply Finset.mem_insert_of_mem |
| exact Finset.mem_biUnion.mpr ⟨c,hc,Finset.mem_image.mpr ⟨t,Finset.mem_univ _,rfl⟩⟩ |
| let D : s→Type := fun g=>g.val.domain |
| let A : ∀ g,Matrix (D g) (D g) ℂ := fun g=>g.val.mat |
| let u : s := ⟨shearG,Finset.mem_insert_self _ _⟩ |
| let f : ∀ c : Q,Fin c.val.num→s := fun c t=>⟨c.val.family t,hs c.val c.property t⟩ |
| let cmp : Q→PairComparison (A := A) := fun c=>c.val.comparison.rename (f c) |
| (fun _=>Equiv.refl _) (fun _=>rfl) |
| let upper : ∀ g : s,Word D A (D g) := fun g=>g.val.upperWord.rename (fun _:Unit=>u) (fun _=>Equiv.refl _) |
| have hu : ∀ g,(upper g).matrix=A g := by |
| intro g |
| exact (Word.matrix_rename (D := fun _:Unit=>Fin 2) (A := fun _=>shearU) |
| (E := D) (B := A) (fun _:Unit=>u) (fun _=>Equiv.refl _) |
| (fun _=>rfl) g.val.upperWord).trans g.val.upperWord_matrix |
| have hcost : ∀ g (p : s→ℝ),(upper g).weight p=(g.val.upperCost : ℝ)*p u := by |
| intro g p |
| exact (Word.weight_rename (D := fun _:Unit=>Fin 2) (A := fun _=>shearU) |
| (E := D) (B := A) (fun _:Unit=>u) (fun _=>Equiv.refl _) p g.val.upperWord).trans |
| (g.val.upperWord_weight (p∘fun _:Unit=>u)) |
| obtain ⟨v,hv,hvu,hc⟩ := finite_prices hno (fun g : s=>g.val.unit) u shearU_not_monomial |
| cmp (fun g=>g.val.upperCost) upper hu hcost |
| let p : GMatrix→ℝ := fun g=>if hg:g∈s then v ⟨g,hg⟩ else 0 |
| have hp : ∀ g : s,p g.val=v g := by intro g; simp [p,g.property] |
| refine ⟨p,?_,?_,?_⟩ |
| · intro g |
| by_cases hg:g∈s |
| · simpa [p,hg] using hv ⟨g,hg⟩ |
| · simp [p,hg] |
| · exact (hp u).trans hvu |
| · intro c hcQ |
| let c' : Q := ⟨c,hcQ⟩ |
| have hh := (PairComparison.rename_ineq (E := D) (B := A) (f c') |
| (fun _=>Equiv.refl _) (fun _=>rfl) c'.val.comparison v).mp (hc c') |
| have hf : p∘c.family=v∘f c' := by |
| funext t |
| exact hp (f c' t) |
| change pairPrice (p∘c.family) c.comparison.pair≤c.comparison.word.weight (p∘c.family) |
| rw [hf] |
| exact hh |
|
|
| theorem global_prices_exist (hno : ¬FiniteWinStatement) : |
| ∃ p : GMatrix→ℝ,(∀ g,0≤p g ∧ p g≤g.upperCost) ∧ p shearG=1 ∧ GlobalConstraints p := by |
| let K : Set (GMatrix→ℝ) := {p|(∀ g,0≤p g ∧ p g≤g.upperCost) ∧ p shearG=1} |
| have hK : IsCompact K := by |
| have hP : IsCompact {p : GMatrix→ℝ|∀ g,p g∈Set.Icc 0 (g.upperCost : ℝ)} := |
| isCompact_pi_infinite (fun _=>isCompact_Icc) |
| exact hP.inter_right (isClosed_eq (continuous_apply shearG) continuous_const) |
| have hh := hK.inter_iInter_nonempty (fun c : GlobalComparison=>{p|c.holds p}) |
| (fun c=>c.closed) (by |
| intro Q |
| obtain ⟨p,hp,hu,hc⟩ := finite_global_prices hno Q |
| refine ⟨p,⟨hp,hu⟩,?_⟩ |
| simpa only [Set.mem_iInter,Set.mem_ofPred_eq] using hc) |
| obtain ⟨p,hp,hc⟩ := hh |
| exact ⟨p,hp.1,hp.2,by intro c; exact Set.mem_iInter.mp hc c⟩ |
| end ExactFourier.Packing |
|
|
| end |
| end |
|
|
| section |
| noncomputable section |
| namespace ExactFourier.Packing |
|
|
| theorem GlobalConstraints.reindex_le {p : GMatrix→ℝ} (hp : GlobalConstraints p) |
| (a b : GMatrix) (e : a.domain≃b.domain) (he : Matrix.reindex e e a.mat=b.mat) : |
| p b≤p a := by |
| let f : Bool→GMatrix := fun t=>cond t b a |
| let D : Bool→Type := fun t=>(f t).domain |
| let A : ∀ t,Matrix (D t) (D t) ℂ := fun t=>(f t).mat |
| let W : Word D A (D true) := callWord false e.toEmbedding |
| have hW : W.matrix=A true := by |
| rw [matrix_callWord,Embedded.matrix_equiv] |
| exact he |
| have hh := hp.apply f (singleComparison true W hW) |
| rw [singleComparison_price,singleComparison_weight] at hh |
| change p b≤Word.weight (p∘f) W at hh |
| simpa [W,Word.weight,f] using hh |
|
|
| theorem GlobalConstraints.reindex {p : GMatrix→ℝ} (hp : GlobalConstraints p) |
| (a b : GMatrix) (e : a.domain≃b.domain) (he : Matrix.reindex e e a.mat=b.mat) : |
| p b=p a := by |
| apply le_antisymm (hp.reindex_le a b e he) |
| apply hp.reindex_le b a e.symm |
| rw [← he,ExactFourier.reindex_inverse] |
| end ExactFourier.Packing |
|
|
| end |
| end |
|
|
| section |
| noncomputable section |
| namespace ExactFourier.Packing |
|
|
| def GMatrix.of {α : Type} [Fintype α] [DecidableEq α] (M : Matrix α α ℂ) (hM : IsUnit M) : GMatrix := |
| ⟨Fintype.card α,Matrix.reindex (Fintype.equivFin α) (Fintype.equivFin α) M, |
| TensorTools.unit_reindex _ _ hM⟩ |
| def rawValue (p : GMatrix→ℝ) {α : Type} [Fintype α] [DecidableEq α] (M : Matrix α α ℂ) : ℝ := by |
| classical |
| exact if h:IsUnit M then p (GMatrix.of M h) else 0 |
|
|
| theorem rawValue_unit (p : GMatrix→ℝ) {α : Type} [Fintype α] [DecidableEq α] |
| (M : Matrix α α ℂ) (hM : IsUnit M) : rawValue p M=p (GMatrix.of M hM) := by |
| simp only [rawValue,dite_eq_left hM] |
|
|
| structure RawPrice where |
| value : ∀ {α : Type} [Fintype α] [DecidableEq α],Matrix α α ℂ→ℝ |
| nonneg : ∀ {α : Type} [Fintype α] [DecidableEq α] (M : Matrix α α ℂ),IsUnit M→0≤value M |
| comparison : ∀ {τ : Type} [Fintype τ] [DecidableEq τ] |
| {D : τ→Type} [∀ t,Fintype (D t)] [∀ t,DecidableEq (D t)] |
| {A : ∀ t,Matrix (D t) (D t) ℂ},(∀ t,IsUnit (A t))→ |
| ∀ c : PairComparison (A := A),pairPrice (D := D) (fun t=>value (A t)) c.pair≤ |
| c.word.weight (fun t=>value (A t)) |
| normalized : value shearU=1 |
|
|
| theorem rawPrice_exists (hno : ¬FiniteWinStatement) : Nonempty RawPrice := by |
| obtain ⟨p,hp,hu,hc⟩ := global_prices_exist hno |
| refine ⟨{value:=rawValue p,nonneg:=?_,comparison:=?_,normalized:=?_}⟩ |
| · intro α _ _ M hM |
| rw [rawValue_unit p M hM] |
| exact (hp _).1 |
| · intro τ _ _ D _ _ A hA c |
| let f : τ→GMatrix := fun t=>GMatrix.of (A t) (hA t) |
| let cc : PairComparison (D := fun t=>(f t).domain) (A := fun t=>(f t).mat) := |
| c.rename id (fun t=>Fintype.equivFin (D t)) (fun _=>rfl) |
| have hh := (PairComparison.rename_ineq (E := fun t=>(f t).domain) |
| (B := fun t=>(f t).mat) id (fun t=>Fintype.equivFin (D t)) |
| (fun _=>rfl) c (p∘f)).mp (hc.apply f cc) |
| have he : (fun t=>rawValue p (A t))=(p∘f)∘id := by |
| funext t; exact rawValue_unit p _ _ |
| rw [he] |
| exact hh |
| · rw [rawValue_unit p shearU shearU_unit] |
| exact (hc.reindex shearG (GMatrix.of shearU shearU_unit) (Fintype.equivFin (Fin 2)) rfl).trans hu |
|
|
| end ExactFourier.Packing |
|
|
| end |
| end |
|
|
| section |
| noncomputable section |
| namespace ExactFourier |
| namespace Embedded |
| variable {α β : Type} [Fintype α] [Fintype β] [DecidableEq α] [DecidableEq β] |
| theorem matrix_inl (M : Matrix α α ℂ) : |
| matrix (Function.Embedding.inl : α ↪ α⊕β) M=Matrix.fromBlocks M 0 0 1 := by |
| ext i j |
| cases i with |
| | inl i => cases j with |
| | inl j => exact matrix_on Function.Embedding.inl M i j |
| | inr j => |
| rw [matrix_off_col _ _ _ _ (by rintro ⟨a,h⟩; cases h)] |
| simp |
| | inr i => |
| rw [matrix_off_row _ _ _ _ (by rintro ⟨a,h⟩; cases h)] |
| cases j <;> simp [Matrix.one_apply] |
| theorem matrix_inr (M : Matrix β β ℂ) : |
| matrix (Function.Embedding.inr : β ↪ α⊕β) M=Matrix.fromBlocks 1 0 0 M := by |
| ext i j |
| cases i with |
| | inr i => cases j with |
| | inr j => exact matrix_on Function.Embedding.inr M i j |
| | inl j => |
| rw [matrix_off_col _ _ _ _ (by rintro ⟨a,h⟩; cases h)] |
| simp |
| | inl i => |
| rw [matrix_off_row _ _ _ _ (by rintro ⟨a,h⟩; cases h)] |
| cases j <;> simp [Matrix.one_apply] |
| @[simp] theorem matrix_refl (M : Matrix α α ℂ) : matrix (Function.Embedding.refl α) M=M := by |
| ext i j; exact matrix_on (Function.Embedding.refl _) _ i j |
| end Embedded |
| namespace Packing |
| variable {τ : Type} {D : τ→Type} [∀ t,Fintype (D t)] [∀ t,DecidableEq (D t)] |
| {A : ∀ t,Matrix (D t) (D t) ℂ} |
| {α β : Type} [Fintype α] [Fintype β] [DecidableEq α] [DecidableEq β] |
|
|
| def Word.sum (W : Word D A α) (V : Word D A β) : Word D A (α⊕β) := |
| W.embed Function.Embedding.inl++V.embed Function.Embedding.inr |
| @[simp] theorem Word.matrix_sum (W : Word D A α) (V : Word D A β) : |
| (W.sum V).matrix=Matrix.fromBlocks W.matrix 0 0 V.matrix := by |
| rw [Word.sum,Word.matrix_append,Word.matrix_embed,Word.matrix_embed,Embedded.matrix_inl,Embedded.matrix_inr] |
| simp [Matrix.fromBlocks_multiply] |
| @[simp] theorem Word.weight_sum (p : τ→ℝ) (W : Word D A α) (V : Word D A β) : |
| (W.sum V).weight p=W.weight p+V.weight p := by |
| rw [Word.sum,Word.weight_append,Word.weight_embed,Word.weight_embed] |
|
|
| theorem Word.weight_kronecker [Fintype τ] [DecidableEq τ] (p : τ→ℝ) (W : Word D A α) (V : Word D A β) : |
| (W.kronecker V).weight p=(Fintype.card β : ℝ)*W.weight p+(Fintype.card α : ℝ)*V.weight p := by |
| rw [Word.weight_count,Word.weight_count,Word.weight_count] |
| simp only [Word.count_kronecker,Nat.cast_add,Nat.cast_mul,add_mul,Finset.sum_add_distrib,mul_assoc,Finset.mul_sum] |
| end Packing |
| end ExactFourier |
|
|
| end |
| end |
|
|
| end OAI |
|
|
