| import Mathlib |
| import OAI.Probability.SKBarriers.Replicas.MatrixSKGuerra |
| import OAI.Probability.SKBarriers.Scalar.VectorBlocks |
| import OAI.Probability.SKBarriers.SpinGlass.FinitePrefix |
|
|
| namespace OAI |
|
|
| section |
|
|
| noncomputable section |
| open scoped BigOperators |
| open MeasureTheory ProbabilityTheory Set |
| namespace SK.Analytic |
|
|
| def replicaSpinMap (d : ℕ) : (Fin d → ℝ) →L[ℝ] (Config d → ℝ) := |
| ContinuousLinearMap.pi (fun s => ∑ i, spin (s i) • ContinuousLinearMap.proj i) |
|
|
| @[simp] theorem replicaSpinMap_apply (d : ℕ) (x : Fin d → ℝ) (s : Config d) : |
| replicaSpinMap d x s=∑ i, spin (s i)*x i := by |
| simp [replicaSpinMap] |
|
|
| theorem replicaSpin_terminal (d : ℕ) : |
| siteValueTerminal (fun _ : Config d => 0) ∘ replicaSpinMap d= |
| fun x => ∑ i, scalarSpinTerminal (x i) := by |
| funext x |
| have H := congrFun (affineLogPartition_product d |
| (fun (_ : Fin d) (_ : Bool) => (0:ℝ)) |
| (fun i b => spin b • (ContinuousLinearMap.proj i : (Fin d → ℝ) →L[ℝ] ℝ))) x |
| simp only [affineLogPartition_bool,ContinuousLinearMap.proj_apply] at H |
| simpa only [Function.comp_def,siteValueTerminal,affineLogPartition, |
| Finset.sum_const_zero,zero_add,replicaSpinMap_apply,sum_apply, |
| smul_apply,smul_eq_mul,ContinuousLinearMap.proj_apply,scalarSpinTerminal] using H |
|
|
| section Vector |
| variable {E : Type} [NormedAddCommGroup E] [NormedSpace ℝ E] |
| theorem vectorBlockHierarchy_one (n : ℕ) (m : Fin n → ℝ) (v : Fin n → E) (f : E → ℝ) : |
| vectorBlockHierarchy 1 n m (fun i _ => v i) f=vectorHierarchy n m v f := by |
| induction n generalizing f with |
| | zero => rfl |
| | succ n ih => |
| change vectorBlockHierarchy 1 n _ _ (vectorStep (m (Fin.last n)) (v (Fin.last n)) f)=_ |
| exact ih _ _ _ |
| end Vector |
|
|
| def rankOnePath {n : ℕ} (d : ℕ) (b : Fin n → Fin d → ℝ) (j : Fin n) : Fin d → Fin d → ℝ := |
| fun u v => ∑ i, if i ≤ j then b i u*b i v else 0 |
|
|
| theorem factorPath_rankOne {k : ℕ} (d : ℕ) (b : Fin (k+1) → Fin d → ℝ) (j : Fin (k+1)) : |
| factorPath d 1 k (fun i _ => b i) j=rankOnePath d b j := by |
| funext u v |
| simp [factorPath,factorCovariance,rankOnePath] |
|
|
| theorem rankOne_siteValue {k : ℕ} (d : ℕ) (β : ℝ) (m : Fin (k+1) → ℝ) (hm : m 0=0) |
| (b : Fin (k+1) → Fin d → ℝ) : |
| vectorHierarchy ((k+1)*1) (siteBlockMass 1 k (zeroInitialAtoms k m)) |
| (matrixSiteVector β (fun i _ => b i) (fun (s : Config d) u => spin (s u))) |
| (siteValueTerminal (fun _ : Config d => 0)) 0= |
| vectorHierarchy (k+1) m (fun i => β • b i) (fun x => ∑ u, scalarSpinTerminal (x u)) 0 := by |
| rw [funext (siteBlockMass_zeroInitial m hm)] |
| have hev : matrixSiteVector β (fun i (_ : Fin 1) => b i) (fun (s : Config d) u => spin (s u))= |
| replicaSpinMap d ∘ (fun i => β • b (finProdFinEquiv.symm i).1) := by |
| funext i s |
| simp only [matrixSiteVector,Function.comp_apply,replicaSpinMap_apply,Pi.smul_apply,smul_eq_mul,Finset.mul_sum] |
| apply Finset.sum_congr rfl |
| intro u _ |
| ring |
| rw [hev] |
| have H := congrFun (vectorHierarchy_pullback (replicaSpinMap d) ((k+1)*1) |
| (fun i => m (finProdFinEquiv.symm i).1) |
| (fun i => β • b (finProdFinEquiv.symm i).1) |
| (siteValueTerminal (fun _ : Config d => 0))) (0 : Fin d → ℝ) |
| simp only [Function.comp_apply,map_zero] at H |
| rw [← H,replicaSpin_terminal] |
| rw [vectorHierarchy_blocks (k+1) 1 m (fun i _ => β • b i),vectorBlockHierarchy_one] |
|
|
| theorem matrixConstrainedPressure_rankOne {N d k : ℕ} (hN : 0<N) (β : ℝ) |
| (D : Fin d → Fin d → ℝ) (hD : Nonempty (MatrixStates N d D)) |
| (m : Fin (k+1) → ℝ) (hm0 : m 0=0) (hm : ∀ i,m i∈Icc (0:ℝ) 1) (hmono : Monotone m) |
| (b : Fin (k+1) → Fin d → ℝ) : |
| matrixConstrainedPressure N d β D ≤ |
| vectorHierarchy (k+1) m (fun i => β • b i) (fun x => ∑ u,scalarSpinTerminal (x u)) 0+ |
| β^2/4*matrixSquare d (fun i j => D i j-rankOnePath d b (Fin.last k) i j)- |
| β^2/4*∑ i : Fin k,m i.succ*(matrixSquare d (rankOnePath d b i.succ)- |
| matrixSquare d (rankOnePath d b i.castSucc)) := by |
| have H := matrixConstrainedPressure_le hN (by norm_num : 0<1) β D (fun _ _ => 0) hD |
| (fun i (_ : Fin 1) => b i) (zeroInitialAtoms k m) |
| (zeroInitialAtoms_nonneg m hm hmono) (zeroInitialAtoms_sum m) |
| have hz : matrixSiteWeight (fun (_ _ : Fin d) => (0:ℝ)) (fun (s : Config d) u => spin (s u))=fun _ => 0 := by |
| funext s; simp [matrixSiteWeight] |
| rw [hz,rankOne_siteValue d β m hm0 b] at H |
| simp only [matrixInner,zero_mul,Finset.sum_const_zero,sub_zero] at H |
| simp_rw [factorPath_rankOne] at H |
| rw [zeroInitialAtoms_sum_mul_parts] at H |
| rw [matrixSquare_sub] |
| unfold matrixInner |
| convert H using 1 |
| ring |
|
|
| end SK.Analytic |
|
|
| end |
| end |
|
|
| end OAI |
|
|
