| import OAI.Probability.InvariantIsing.Arrays.NSpinTensorBackwardDerivative |
|
|
| namespace OAI |
|
|
| /-! Collapse the two independent residual paths to actual backward gradients. -/ |
|
|
| noncomputable section |
|
|
| open MeasureTheory ProbabilityTheory IsingPerceptron |
| open scoped BigOperators NNReal ENNReal |
|
|
| namespace InvariantIsing |
|
|
| def tensorPairCoordinatePayoff {N m k : ℕ} |
| (eig : Fin N → ℝ) (U : Rotation N) (c : Fin N → ℝ) |
| (I : Fin m → Finset (Fin N)) (degree : Fin k → Fin m → ℕ) (amplitude : Fin k → ℝ) |
| (q : ℕ) (z₁ z₂ : SpinTensorIndex I degree → ℝ) (j₁ j₂ : SpinTensorIndex I degree) |
| (w : Fin q → (SpinTensorIndex I degree → ℝ) × (SpinTensorIndex I degree → ℝ)) : ℝ := |
| tensorTerminalCoordinateMean eig U c I degree amplitude (z₁ + ∑ i, (w i).1) j₁ * |
| tensorTerminalCoordinateMean eig U c I degree amplitude (z₂ + ∑ i, (w i).2) j₂ |
|
|
| lemma tensorPairCoordinatePayoff_cons {N m k : ℕ} |
| (eig : Fin N → ℝ) (U : Rotation N) (c : Fin N → ℝ) |
| (I : Fin m → Finset (Fin N)) (degree : Fin k → Fin m → ℕ) (amplitude : Fin k → ℝ) |
| (q : ℕ) (z₁ z₂ a₁ a₂ : SpinTensorIndex I degree → ℝ) (j₁ j₂ : SpinTensorIndex I degree) |
| (w : Fin q → (SpinTensorIndex I degree → ℝ) × (SpinTensorIndex I degree → ℝ)) : |
| tensorPairCoordinatePayoff eig U c I degree amplitude (q + 1) z₁ z₂ j₁ j₂ (Fin.cons (a₁, a₂) w) = |
| tensorPairCoordinatePayoff eig U c I degree amplitude q (z₁ + a₁) (z₂ + a₂) j₁ j₂ w := by |
| simp only [tensorPairCoordinatePayoff, Fin.sum_univ_succ, Fin.cons_zero, Fin.cons_succ, add_assoc] |
|
|
| lemma tensorPairCoordinatePayoff_abs_le {N m k : ℕ} |
| (eig : Fin N → ℝ) (U : Rotation N) (c : Fin N → ℝ) |
| (I : Fin m → Finset (Fin N)) (degree : Fin k → Fin m → ℕ) (amplitude : Fin k → ℝ) |
| (q : ℕ) (z₁ z₂ : SpinTensorIndex I degree → ℝ) (j₁ j₂ : SpinTensorIndex I degree) |
| (w : Fin q → (SpinTensorIndex I degree → ℝ) × (SpinTensorIndex I degree → ℝ)) : |
| |tensorPairCoordinatePayoff eig U c I degree amplitude q z₁ z₂ j₁ j₂ w| ≤ |
| tensorFeatureCoordinateCap U I degree amplitude j₁ * tensorFeatureCoordinateCap U I degree amplitude j₂ := by |
| rw [tensorPairCoordinatePayoff, abs_mul] |
| exact mul_le_mul (tensorTerminalCoordinateMean_abs_le eig U c I degree amplitude _ j₁) |
| (tensorTerminalCoordinateMean_abs_le eig U c I degree amplitude _ j₂) (abs_nonneg _) |
| (Finset.sum_nonneg fun _ _ => abs_nonneg _) |
|
|
| /-- Once the two paths have branched, each terminal gradient averages |
| independently to its actual backward gradient. -/ |
| theorem tensorAncestorPairPathMean_independent_coordinates {N m k : ℕ} (hN : 0 < N) |
| (eig : Fin N → ℝ) (U : Rotation N) (c : Fin N → ℝ) |
| (I : Fin m → Finset (Fin N)) (degree : Fin k → Fin m → ℕ) (amplitude : Fin k → ℝ) |
| (n : ℕ) (b : ℕ → ℝ) (v : ℕ → SpinTensorIndex I degree → ℝ≥0) |
| (hb : CascadeExponents n b) (d q i : ℕ) (hqi : i + q = n) (hdi : d ≤ i) |
| (z₁ z₂ : SpinTensorIndex I degree → ℝ) (j₁ j₂ : SpinTensorIndex I degree) : |
| tensorAncestorPairPathMean eig U c I degree amplitude n b v d q i z₁ z₂ |
| (tensorPairCoordinatePayoff eig U c I degree amplitude q z₁ z₂ j₁ j₂) = |
| tensorBackwardCoordinateMean eig U c I degree amplitude n b v i z₁ j₁ * |
| tensorBackwardCoordinateMean eig U c I degree amplitude n b v i z₂ j₂ := by |
| induction q generalizing i z₁ z₂ with |
| | zero => |
| have hi : i = n := by omega |
| subst i |
| simp only [tensorAncestorPairPathMean, tensorPairCoordinatePayoff, Finset.univ_eq_empty, |
| Finset.sum_empty, add_zero, tensorBackwardCoordinateMean, Nat.sub_self, tensorCascadeCoordinateMean] |
| | succ q ih => |
| have hi : i < n := by omega |
| have hqi' : i + 1 + q = n := by omega |
| have hdi' : d ≤ i + 1 := by omega |
| dsimp only [tensorAncestorPairPathMean] |
| rw [ite_eq_right (by omega : ¬i < d)] |
| calc |
| _ = ∫ a₁, ∫ a₂, |
| tensorBackwardCoordinateMean eig U c I degree amplitude n b v (i + 1) (z₁ + a₁) j₁ * |
| tensorBackwardCoordinateMean eig U c I degree amplitude n b v (i + 1) (z₂ + a₂) j₂ |
| ∂tensorAncestorMarkKernel eig U c I degree amplitude n b v i z₂ |
| ∂tensorAncestorMarkKernel eig U c I degree amplitude n b v i z₁ := by |
| apply integral_congr_ae |
| apply ae_of_all |
| intro a₁ |
| apply integral_congr_ae |
| apply ae_of_all |
| intro a₂ |
| dsimp only |
| have hF : (fun w => tensorPairCoordinatePayoff eig U c I degree amplitude (q + 1) |
| z₁ z₂ j₁ j₂ (Fin.cons (a₁, a₂) w)) = |
| tensorPairCoordinatePayoff eig U c I degree amplitude q (z₁ + a₁) (z₂ + a₂) j₁ j₂ := |
| funext (tensorPairCoordinatePayoff_cons eig U c I degree amplitude q z₁ z₂ a₁ a₂ j₁ j₂) |
| rw [hF] |
| exact ih (i + 1) hqi' hdi' (z₁ + a₁) (z₂ + a₂) |
| _ = (∫ a₁, tensorBackwardCoordinateMean eig U c I degree amplitude n b v (i + 1) (z₁ + a₁) j₁ |
| ∂tensorAncestorMarkKernel eig U c I degree amplitude n b v i z₁) * |
| (∫ a₂, tensorBackwardCoordinateMean eig U c I degree amplitude n b v (i + 1) (z₂ + a₂) j₂ |
| ∂tensorAncestorMarkKernel eig U c I degree amplitude n b v i z₂) := by |
| simp_rw [integral_const_mul] |
| rw [integral_mul_const] |
| _ = _ := by |
| rw [← tensorBackwardCoordinateMean_step hN eig U c I degree amplitude n b v hb i hi z₁ j₁, |
| ← tensorBackwardCoordinateMean_step hN eig U c I degree amplitude n b v hb i hi z₂ j₂] |
|
|
| /-- Only the shared ancestor increments remain after the independent |
| suffixes have been integrated. At the branching level the integrand is |
| the product of actual backward gradients. -/ |
| def tensorSharedCoordinateProduct {N m k : ℕ} |
| (eig : Fin N → ℝ) (U : Rotation N) (c : Fin N → ℝ) |
| (I : Fin m → Finset (Fin N)) (degree : Fin k → Fin m → ℕ) (amplitude : Fin k → ℝ) |
| (n : ℕ) (b : ℕ → ℝ) (v : ℕ → SpinTensorIndex I degree → ℝ≥0) (d : ℕ) |
| (j₁ j₂ : SpinTensorIndex I degree) : |
| (q : ℕ) → ℕ → (SpinTensorIndex I degree → ℝ) → (SpinTensorIndex I degree → ℝ) → ℝ |
| | 0, i, z₁, z₂ => |
| tensorBackwardCoordinateMean eig U c I degree amplitude n b v i z₁ j₁ * |
| tensorBackwardCoordinateMean eig U c I degree amplitude n b v i z₂ j₂ |
| | q + 1, i, z₁, z₂ => |
| if i < d then |
| ∫ a, tensorSharedCoordinateProduct eig U c I degree amplitude n b v d j₁ j₂ q |
| (i + 1) (z₁ + a) (z₂ + a) ∂tensorAncestorMarkKernel eig U c I degree amplitude n b v i z₁ |
| else |
| tensorBackwardCoordinateMean eig U c I degree amplitude n b v i z₁ j₁ * |
| tensorBackwardCoordinateMean eig U c I degree amplitude n b v i z₂ j₂ |
|
|
| lemma tensorSharedCoordinateProduct_nonneg {N m k : ℕ} |
| (eig : Fin N → ℝ) (U : Rotation N) (c : Fin N → ℝ) |
| (I : Fin m → Finset (Fin N)) (degree : Fin k → Fin m → ℕ) (amplitude : Fin k → ℝ) |
| (n : ℕ) (b : ℕ → ℝ) (v : ℕ → SpinTensorIndex I degree → ℝ≥0) |
| (d : ℕ) (j : SpinTensorIndex I degree) (q i : ℕ) (z : SpinTensorIndex I degree → ℝ) : |
| 0 ≤ tensorSharedCoordinateProduct eig U c I degree amplitude n b v d j j q i z z := by |
| induction q generalizing i z with |
| | zero => exact mul_self_nonneg _ |
| | succ q ih => |
| dsimp only [tensorSharedCoordinateProduct] |
| split_ifs |
| · exact integral_nonneg fun a => ih (i + 1) (z + a) |
| · exact mul_self_nonneg _ |
|
|
| /-- The finite pair-path expectation is an expectation over the common |
| ancestor path of the backward gradient product at branching. -/ |
| theorem tensorAncestorPairPathMean_coordinates {N m k : ℕ} (hN : 0 < N) |
| (eig : Fin N → ℝ) (U : Rotation N) (c : Fin N → ℝ) |
| (I : Fin m → Finset (Fin N)) (degree : Fin k → Fin m → ℕ) (amplitude : Fin k → ℝ) |
| (n : ℕ) (b : ℕ → ℝ) (v : ℕ → SpinTensorIndex I degree → ℝ≥0) |
| (hb : CascadeExponents n b) (d q i : ℕ) (hqi : i + q = n) |
| (z₁ z₂ : SpinTensorIndex I degree → ℝ) (j₁ j₂ : SpinTensorIndex I degree) : |
| tensorAncestorPairPathMean eig U c I degree amplitude n b v d q i z₁ z₂ |
| (tensorPairCoordinatePayoff eig U c I degree amplitude q z₁ z₂ j₁ j₂) = |
| tensorSharedCoordinateProduct eig U c I degree amplitude n b v d j₁ j₂ q i z₁ z₂ := by |
| induction q generalizing i z₁ z₂ with |
| | zero => |
| have hi : i = n := by omega |
| subst i |
| simp only [tensorAncestorPairPathMean, tensorPairCoordinatePayoff, Finset.univ_eq_empty, |
| Finset.sum_empty, add_zero, tensorSharedCoordinateProduct, tensorBackwardCoordinateMean, |
| Nat.sub_self, tensorCascadeCoordinateMean] |
| | succ q ih => |
| by_cases hid : i < d |
| · dsimp only [tensorAncestorPairPathMean, tensorSharedCoordinateProduct] |
| rw [ite_eq_left hid, ite_eq_left hid] |
| apply integral_congr_ae |
| apply ae_of_all |
| intro a |
| dsimp only |
| have hF : (fun w => tensorPairCoordinatePayoff eig U c I degree amplitude (q + 1) |
| z₁ z₂ j₁ j₂ (Fin.cons (a, a) w)) = |
| tensorPairCoordinatePayoff eig U c I degree amplitude q (z₁ + a) (z₂ + a) j₁ j₂ := |
| funext (tensorPairCoordinatePayoff_cons eig U c I degree amplitude q z₁ z₂ a a j₁ j₂) |
| rw [hF] |
| exact ih (i + 1) (by omega) (z₁ + a) (z₂ + a) |
| · rw [tensorSharedCoordinateProduct, ite_eq_right hid] |
| exact tensorAncestorPairPathMean_independent_coordinates hN eig U c I degree amplitude |
| n b v hb d (q + 1) i hqi (by omega) z₁ z₂ j₁ j₂ |
|
|
| lemma tensorAncestorPairPathMean_const_mul {N m k : ℕ} |
| (eig : Fin N → ℝ) (U : Rotation N) (c : Fin N → ℝ) |
| (I : Fin m → Finset (Fin N)) (degree : Fin k → Fin m → ℕ) (amplitude : Fin k → ℝ) |
| (n : ℕ) (b : ℕ → ℝ) (v : ℕ → SpinTensorIndex I degree → ℝ≥0) |
| (d q i : ℕ) (z₁ z₂ : SpinTensorIndex I degree → ℝ) |
| (F : (Fin q → (SpinTensorIndex I degree → ℝ) × (SpinTensorIndex I degree → ℝ)) → ℝ) (C : ℝ) : |
| tensorAncestorPairPathMean eig U c I degree amplitude n b v d q i z₁ z₂ (fun w => C * F w) = |
| C * tensorAncestorPairPathMean eig U c I degree amplitude n b v d q i z₁ z₂ F := by |
| induction q generalizing i z₁ z₂ with |
| | zero => rfl |
| | succ q ih => |
| dsimp only [tensorAncestorPairPathMean] |
| split_ifs <;> simp_rw [ih, integral_const_mul] |
|
|
| lemma tensorPairPathSpinMean_features {N m k : ℕ} |
| (eig : Fin N → ℝ) (U : Rotation N) (c : Fin N → ℝ) |
| (I : Fin m → Finset (Fin N)) (degree : Fin k → Fin m → ℕ) (amplitude : Fin k → ℝ) |
| (n : ℕ) (z : SpinTensorIndex I degree → ℝ) (j₁ j₂ : SpinTensorIndex I degree) |
| (w : Fin n → (SpinTensorIndex I degree → ℝ) × (SpinTensorIndex I degree → ℝ)) : |
| tensorPairPathSpinMean eig U c I degree amplitude n (z, w) |
| (fun σ => spinTensorFeature U I degree amplitude (σ 0) j₁ * |
| spinTensorFeature U I degree amplitude (σ 1) j₂) = |
| tensorPairCoordinatePayoff eig U c I degree amplitude n z z j₁ j₂ w := by |
| let μ := fun j : Fin 2 => gibbsProbability (uniformSpinPrior N : Measure (Spin N)) |
| (tensorSpinBaseEnergy eig U c I degree amplitude (tensorPairPathState I degree n (z, w) j)) |
| change (∫ σ : Fin 2 → Spin N, spinTensorFeature U I degree amplitude (σ 0) j₁ * |
| spinTensorFeature U I degree amplitude (σ 1) j₂ ∂Measure.pi μ) = _ |
| have h := integral_fin_nat_prod_eq_prod (μ := μ) |
| (fun j σ => spinTensorFeature U I degree amplitude σ (if j = 0 then j₁ else j₂)) |
| have h10 : (1 : Fin 2) ≠ 0 := by decide |
| simpa only [Fin.prod_univ_two, ite_eq_left rfl, ite_true, ite_eq_right h10, μ, |
| integral_uniformSpinGibbs_eq, tensorTerminalCoordinateMean, tensorPairCoordinatePayoff, |
| tensorPairPathState] using h |
|
|
| /-- Actual finite tensor feature pair tests are expectations of backward |
| gradient products along the shared ancestor path. -/ |
| theorem tensorFeaturePair_backward_identity (hpub : PanchenkoTalagrandTensorPairInput) |
| {N m k : ℕ} (hN : 0 < N) |
| (eig : Fin N → ℝ) (U : Rotation N) (c : Fin N → ℝ) |
| (I : Fin m → Finset (Fin N)) (degree : Fin k → Fin m → ℕ) (amplitude : Fin k → ℝ) |
| (n : ℕ) (b : ℕ → ℝ) (v : ℕ → SpinTensorIndex I degree → ℝ≥0) |
| (hb : CascadeExponents n b) (z : SpinTensorIndex I degree → ℝ) |
| (ψ : ℕ → ℝ) {B : ℝ} (hB : 0 ≤ B) (hψ : ∀ d, |ψ d| ≤ B) |
| (j₁ j₂ : SpinTensorIndex I degree) : |
| tensorSpinPairAverage eig U c I degree amplitude n b v z ψ |
| (fun σ => spinTensorFeature U I degree amplitude (σ 0) j₁ * |
| spinTensorFeature U I degree amplitude (σ 1) j₂) = |
| ∫ α : ℕ → LabeledLeaf n, ψ (labeledCommonDepth n (α 0) (α 1)) * |
| tensorSharedCoordinateProduct eig U c I degree amplitude n b v |
| (labeledCommonDepth n (α 0) (α 1)) j₁ j₂ n 0 z z ∂cascadeReplicaLaw n b := by |
| have hf (σ : Spin N) (j : SpinTensorIndex I degree) : |
| |spinTensorFeature U I degree amplitude σ j| ≤ tensorFeatureCoordinateCap U I degree amplitude j := by |
| exact Finset.single_le_sum (fun τ _ => abs_nonneg (spinTensorFeature U I degree amplitude τ j)) |
| (Finset.mem_univ σ) |
| rw [tensorSpinPair_markov_identity hpub hN eig U c I degree amplitude n b v hb z ψ _ hB hψ |
| (C := tensorFeatureCoordinateCap U I degree amplitude j₁ * tensorFeatureCoordinateCap U I degree amplitude j₂) |
| (fun σ => by |
| rw [abs_mul] |
| exact mul_le_mul (hf (σ 0) j₁) (hf (σ 1) j₂) (abs_nonneg _) |
| (Finset.sum_nonneg fun _ _ => abs_nonneg _))] |
| apply integral_congr_ae |
| apply ae_of_all |
| intro α |
| simp only [tensorPairSpinPathPayoff, tensorPairPathSpinMean_features] |
| rw [tensorAncestorPairPathMean_const_mul, |
| tensorAncestorPairPathMean_coordinates hN eig U c I degree amplitude n b v hb _ n 0 (by omega)] |
|
|
| theorem tensorFeaturePair_nonneg (hpub : PanchenkoTalagrandTensorPairInput) |
| {N m k : ℕ} (hN : 0 < N) |
| (eig : Fin N → ℝ) (U : Rotation N) (c : Fin N → ℝ) |
| (I : Fin m → Finset (Fin N)) (degree : Fin k → Fin m → ℕ) (amplitude : Fin k → ℝ) |
| (n : ℕ) (b : ℕ → ℝ) (v : ℕ → SpinTensorIndex I degree → ℝ≥0) |
| (hb : CascadeExponents n b) (z : SpinTensorIndex I degree → ℝ) |
| (ψ : ℕ → ℝ) {B : ℝ} (hB : 0 ≤ B) (hψ : ∀ d, |ψ d| ≤ B) (hψ0 : ∀ d, 0 ≤ ψ d) |
| (j : SpinTensorIndex I degree) : |
| 0 ≤ tensorSpinPairAverage eig U c I degree amplitude n b v z ψ |
| (fun σ => spinTensorFeature U I degree amplitude (σ 0) j * |
| spinTensorFeature U I degree amplitude (σ 1) j) := by |
| rw [tensorFeaturePair_backward_identity hpub hN eig U c I degree amplitude n b v hb z ψ hB hψ j j] |
| exact integral_nonneg fun α => mul_nonneg (hψ0 _) |
| (tensorSharedCoordinateProduct_nonneg eig U c I degree amplitude n b v _ j n 0 z) |
|
|
| end InvariantIsing |
|
|
| end |
|
|
| end OAI |
|
|
