Download data/lean/OAI/Dynamics/StandardMap/BiCocycle.lean from introvoyz045/math: direct link, hf CLI and curl.
- Browser
- Download file 5.64 kB
-
https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Dynamics/StandardMap/BiCocycle.lean
- Command line
-
hf download hf://datasets/introvoyz045/math/data/lean/OAI/Dynamics/StandardMap/BiCocycle.lean
-
curl -L -o BiCocycle.lean https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Dynamics/StandardMap/BiCocycle.lean
5.64 kB
| import OAI.Dynamics.StandardMap.FourPoint | |
| namespace OAI | |
| open MeasureTheory Set | |
| open scoped ENNReal BigOperators | |
| open MeasureTheory Set Filter Metric | |
| open scoped ENNReal Topology | |
| namespace StandardMapEntropy | |
| noncomputable def transferStepEquiv (v : β) : β βL[β] β := | |
| { toLinearEquiv := | |
| { toLinearMap := (transferStep v).toLinearMap | |
| invFun := transferStepInv v | |
| left_inv := transferStepInv_inv v | |
| right_inv := transferStep_inv v } | |
| continuous_toFun := (transferStep v).continuous | |
| continuous_invFun := (transferStepInv v).continuous } | |
| @[simp] lemma transferStepEquiv_apply (v : β) (u : β) : transferStepEquiv v u=transferStep v u := rfl | |
| @[simp] lemma transferStepEquiv_symm_apply (v : β) (u : β) : (transferStepEquiv v).symm u=transferStepInv v u := rfl | |
| noncomputable def positivePrefix (G : β€ β (β βL[β] β)) : β β (β βL[β] β) | |
| | 0 => ContinuousLinearEquiv.refl β β | |
| | n+1 => (positivePrefix G n).trans (G (n:β€)) | |
| noncomputable def negativePrefix (G : β€ β (β βL[β] β)) : β β (β βL[β] β) | |
| | 0 => ContinuousLinearEquiv.refl β β | |
| | n+1 => (negativePrefix G n).trans (G (-((n:β€)+1))).symm | |
| noncomputable def integerPrefix (G : β€ β (β βL[β] β)) : β€ β (β βL[β] β) | |
| | .ofNat n => positivePrefix G n | |
| | .negSucc n => negativePrefix G (n+1) | |
| @[simp] lemma integerPrefix_nat (G : β€ β (β βL[β] β)) (n : β) : integerPrefix G (n:β€)=positivePrefix G n := rfl | |
| @[simp] lemma integerPrefix_neg_nat (G : β€ β (β βL[β] β)) (n : β) : integerPrefix G (-(n:β€))=negativePrefix G n := by | |
| cases n <;> rfl | |
| lemma integerPrefix_step (G : β€ β (β βL[β] β)) (i : β€) (u : β) : | |
| integerPrefix G (i+1) u=G i (integerPrefix G i u) := by | |
| cases i with | |
| | ofNat n => rfl | |
| | negSucc n => | |
| change integerPrefix G (-((n:β€)+1)+1) u=G (-((n:β€)+1)) (negativePrefix G (n+1) u) | |
| rw [show -((n:β€)+1)+1=-(n:β€) by ring,integerPrefix_neg_nat] | |
| simp only [negativePrefix,ContinuousLinearEquiv.trans_apply,ContinuousLinearEquiv.apply_symm_apply] | |
| lemma equiv_area_symm (A : β βL[β] β) (hA : PlaneAreaPreserving A.toContinuousLinearMap) : | |
| PlaneAreaPreserving A.symm.toContinuousLinearMap := by | |
| intro u v | |
| have h := hA (A.symm u) (A.symm v) | |
| simpa using h.symm | |
| lemma equiv_area_trans (A B : β βL[β] β) | |
| (hA : PlaneAreaPreserving A.toContinuousLinearMap) (hB : PlaneAreaPreserving B.toContinuousLinearMap) : | |
| PlaneAreaPreserving (A.trans B).toContinuousLinearMap := by | |
| intro u v | |
| exact (hB (A u) (A v)).trans (hA u v) | |
| lemma integerPrefix_area (G : β€ β (β βL[β] β)) | |
| (hG : β i, PlaneAreaPreserving (G i).toContinuousLinearMap) (i : β€) : | |
| PlaneAreaPreserving (integerPrefix G i).toContinuousLinearMap := by | |
| have hp : β n, PlaneAreaPreserving (positivePrefix G n).toContinuousLinearMap := by | |
| intro n | |
| induction n with | |
| | zero => exact fun _ _ => rfl | |
| | succ n ih => exact equiv_area_trans _ _ ih (hG _) | |
| have hm : β n, PlaneAreaPreserving (negativePrefix G n).toContinuousLinearMap := by | |
| intro n | |
| induction n with | |
| | zero => exact fun _ _ => rfl | |
| | succ n ih => exact equiv_area_trans _ _ ih (equiv_area_symm _ (hG _)) | |
| cases i with | |
| | ofNat n => exact hp n | |
| | negSucc n => exact hm (n+1) | |
| noncomputable def torusPrefix (k : β) (z : Torus) (i : β€) : β βL[β] β := | |
| integerPrefix (fun a => transferStepEquiv (torusPotential k (torusIter k a z).1)) i | |
| noncomputable def torusTransfer (k : β) (z : Torus) (i j : β€) : β βL[β] β := | |
| (torusPrefix k z i).symm.trans (torusPrefix k z j) | |
| lemma torusTransfer_apply (k : β) (z : Torus) (i j : β€) (u : β) : | |
| torusTransfer k z i j u=torusPrefix k z j ((torusPrefix k z i).symm u) := rfl | |
| lemma torusTransfer_comp (k : β) (z : Torus) (i j l : β€) (u : β) : | |
| torusTransfer k z j l (torusTransfer k z i j u)=torusTransfer k z i l u := by | |
| simp only [torusTransfer_apply,ContinuousLinearEquiv.symm_apply_apply] | |
| lemma torusTransfer_self (k : β) (z : Torus) (i : β€) : | |
| (torusTransfer k z i i).toContinuousLinearMap=ContinuousLinearMap.id β β := by | |
| ext u | |
| exact ContinuousLinearEquiv.apply_symm_apply _ _ | |
| lemma torusTransfer_area (k : β) (z : Torus) (i j : β€) : | |
| PlaneAreaPreserving (torusTransfer k z i j).toContinuousLinearMap := by | |
| apply equiv_area_trans | |
| Β· apply equiv_area_symm | |
| exact integerPrefix_area (fun a => transferStepEquiv (torusPotential k (torusIter k a z).1)) | |
| (fun a => transferStep_area _) i | |
| Β· exact integerPrefix_area (fun a => transferStepEquiv (torusPotential k (torusIter k a z).1)) | |
| (fun a => transferStep_area _) j | |
| lemma torusTransfer_forward (k : β) (z : Torus) (a : β€) (n : β) : | |
| (torusTransfer k z a (a+(n:β€))).toContinuousLinearMap=torusSegmentTransfer k z a n := by | |
| induction n with | |
| | zero => simpa only [Nat.cast_zero,add_zero,torusSegmentTransfer,transferProduct] using torusTransfer_self k z a | |
| | succ n ih => | |
| ext u | |
| change torusPrefix k z (a+((n+1:β):β€)) ((torusPrefix k z a).symm u)=_ | |
| rw [show a+((n+1:β):β€)=(a+(n:β€))+1 by omega] | |
| change integerPrefix _ ((a+(n:β€))+1) _=_ | |
| rw [integerPrefix_step] | |
| change transferStep (torusPotential k (torusIter k (a+(n:β€)) z).1) | |
| ((torusTransfer k z a (a+(n:β€))).toContinuousLinearMap u)=_ | |
| rw [ih] | |
| simp only [torusSegmentTransfer,transferProduct,ContinuousLinearMap.comp_apply,torusSegmentCoefficient] | |
| congr 1 | |
| exact congrArg (fun t : β€ => transferStep (torusPotential k (torusIter k t z).1)) (by omega) | |
| end StandardMapEntropy | |
| end OAI | |