Datasets:

---

zipfit

/

leandojo_benchmark_4_corpus

like 0

Follow

ZIP-FIT - Compression-Based Data Selection For Code 1

[ "Mathlib/Analysis/Complex/UpperHalfPlane/Manifold.lean", ".lake/packages/lean4/src/lean/Init.lean", "Mathlib/NumberTheory/ModularForms/JacobiTheta/OneVariable.lean", "Mathlib/Geometry/Manifold/MFDeriv/FDeriv.lean" ]

[ { "full_name": "mdifferentiable_jacobiTheta", "code": "theorem mdifferentiable_jacobiTheta : MDifferentiable 𝓘(ℂ) 𝓘(ℂ) (jacobiTheta ∘ (↑) : ℍ → ℂ)", "start": [ 26, 1 ], "end": [ 27, 93 ], "kind": "commanddeclaration" } ]

[ ".lake/packages/lean4/src/lean/Init.lean", "Mathlib/Analysis/LocallyConvex/WithSeminorms.lean", "Mathlib/Topology/Algebra/Module/WeakDual.lean", "Mathlib/Analysis/Normed/Field/Basic.lean" ]

[ { "full_name": "LinearMap.toSeminorm", "code": "def toSeminorm (f : E →ₗ[𝕜] 𝕜) : Seminorm 𝕜 E :=\n (normSeminorm 𝕜 𝕜).comp f", "start": [ 53, 1 ], "end": [ 56, 28 ], "kind": "commanddeclaration" }, { "full_name": "LinearMap.coe_toSeminorm", "code": "theorem coe_toSeminorm {f : E →ₗ[𝕜] 𝕜} : ⇑f.toSeminorm = fun x => ‖f x‖", "start": [ 59, 1 ], "end": [ 60, 6 ], "kind": "commanddeclaration" }, { "full_name": "LinearMap.toSeminorm_apply", "code": "@[simp]\ntheorem toSeminorm_apply {f : E →ₗ[𝕜] 𝕜} {x : E} : f.toSeminorm x = ‖f x‖", "start": [ 63, 1 ], "end": [ 65, 6 ], "kind": "commanddeclaration" }, { "full_name": "LinearMap.toSeminorm_ball_zero", "code": "theorem toSeminorm_ball_zero {f : E →ₗ[𝕜] 𝕜} {r : ℝ} :\n Seminorm.ball f.toSeminorm 0 r = { x : E | ‖f x‖ < r }", "start": [ 68, 1 ], "end": [ 70, 54 ], "kind": "commanddeclaration" }, { "full_name": "LinearMap.toSeminorm_comp", "code": "theorem toSeminorm_comp (f : F →ₗ[𝕜] 𝕜) (g : E →ₗ[𝕜] F) :\n f.toSeminorm.comp g = (f.comp g).toSeminorm", "start": [ 73, 1 ], "end": [ 76, 83 ], "kind": "commanddeclaration" }, { "full_name": "LinearMap.toSeminormFamily", "code": "def toSeminormFamily (B : E →ₗ[𝕜] F →ₗ[𝕜] 𝕜) : SeminormFamily 𝕜 E F := fun y =>\n (B.flip y).toSeminorm", "start": [ 79, 1 ], "end": [ 81, 24 ], "kind": "commanddeclaration" }, { "full_name": "LinearMap.toSeminormFamily_apply", "code": "@[simp]\ntheorem toSeminormFamily_apply {B : E →ₗ[𝕜] F →ₗ[𝕜] 𝕜} {x y} : (B.toSeminormFamily y) x = ‖B x y‖", "start": [ 84, 1 ], "end": [ 86, 6 ], "kind": "commanddeclaration" }, { "full_name": "LinearMap.hasBasis_weakBilin", "code": "theorem LinearMap.hasBasis_weakBilin (B : E →ₗ[𝕜] F →ₗ[𝕜] 𝕜) :\n (𝓝 (0 : WeakBilin B)).HasBasis B.toSeminormFamily.basisSets _root_.id", "start": [ 99, 1 ], "end": [ 135, 16 ], "kind": "commanddeclaration" }, { "full_name": "LinearMap.weakBilin_withSeminorms", "code": "theorem LinearMap.weakBilin_withSeminorms (B : E →ₗ[𝕜] F →ₗ[𝕜] 𝕜) :\n WithSeminorms (LinearMap.toSeminormFamily B : F → Seminorm 𝕜 (WeakBilin B))", "start": [ 138, 1 ], "end": [ 140, 66 ], "kind": "commanddeclaration" }, { "full_name": "WeakBilin.locallyConvexSpace", "code": "instance WeakBilin.locallyConvexSpace {B : E →ₗ[𝕜] F →ₗ[𝕜] 𝕜} :\n LocallyConvexSpace ℝ (WeakBilin B) :=\n B.weakBilin_withSeminorms.toLocallyConvexSpace", "start": [ 150, 1 ], "end": [ 152, 49 ], "kind": "commanddeclaration" } ]

[ ".lake/packages/lean4/src/lean/Init.lean", ".lake/packages/lean4/src/lean/Lean/Meta/DiscrTree.lean" ]

[ { "full_name": "Lean.Meta.DiscrTree.getSubexpressionMatches", "code": "partial def getSubexpressionMatches (d : DiscrTree α) (e : Expr) (config : WhnfCoreConfig) :\n MetaM (Array α) := do\n match e with\n | .bvar _ => return #[]\n | .forallE _ _ _ _ => forallTelescope e (fun args body => do\n args.foldlM (fun acc arg => do\n pure <| acc ++ (← d.getSubexpressionMatches (← inferType arg) config))\n (← d.getSubexpressionMatches body config).reverse)\n | .lam _ _ _ _\n | .letE _ _ _ _ _ => lambdaLetTelescope e (fun args body => do\n args.foldlM (fun acc arg => do\n pure <| acc ++ (← d.getSubexpressionMatches (← inferType arg) config))\n (← d.getSubexpressionMatches body config).reverse)\n | _ =>\n e.foldlM (fun a f => do\n pure <| a ++ (← d.getSubexpressionMatches f config)) (← d.getMatch e config).reverse", "start": [ 16, 1 ], "end": [ 42, 91 ], "kind": "commanddeclaration" }, { "full_name": "Lean.Meta.DiscrTree.keysSpecific", "code": "def keysSpecific (keys : Array DiscrTree.Key) : Bool :=\n keys != #[Key.star] && keys != #[Key.const `Eq 3, Key.star, Key.star, Key.star]", "start": [ 44, 1 ], "end": [ 49, 82 ], "kind": "commanddeclaration" } ]

[ ".lake/packages/lean4/src/lean/Init.lean", "Mathlib/Algebra/MvPolynomial/Basic.lean", "Mathlib/Topology/Algebra/Ring/Basic.lean" ]

[ { "full_name": "MvPolynomial.continuous_eval", "code": "theorem MvPolynomial.continuous_eval : Continuous fun x ↦ eval x p", "start": [ 25, 1 ], "end": [ 26, 13 ], "kind": "commanddeclaration" } ]

[ ".lake/packages/lean4/src/lean/Init.lean", "Mathlib/Analysis/Calculus/Conformal/NormedSpace.lean", "Mathlib/Analysis/InnerProductSpace/ConformalLinearMap.lean" ]

[ { "full_name": "conformalAt_iff'", "code": "theorem conformalAt_iff' {f : E → F} {x : E} : ConformalAt f x ↔\n ∃ c : ℝ, 0 < c ∧ ∀ u v : E, ⟪fderiv ℝ f x u, fderiv ℝ f x v⟫ = c * ⟪u, v⟫", "start": [ 27, 1 ], "end": [ 31, 65 ], "kind": "commanddeclaration" }, { "full_name": "conformalAt_iff", "code": "theorem conformalAt_iff {f : E → F} {x : E} {f' : E →L[ℝ] F} (h : HasFDerivAt f f' x) :\n ConformalAt f x ↔ ∃ c : ℝ, 0 < c ∧ ∀ u v : E, ⟪f' u, f' v⟫ = c * ⟪u, v⟫", "start": [ 34, 1 ], "end": [ 38, 41 ], "kind": "commanddeclaration" }, { "full_name": "conformalFactorAt", "code": "def conformalFactorAt {f : E → F} {x : E} (h : ConformalAt f x) : ℝ :=\n Classical.choose (conformalAt_iff'.mp h)", "start": [ 41, 1 ], "end": [ 44, 43 ], "kind": "commanddeclaration" }, { "full_name": "conformalFactorAt_pos", "code": "theorem conformalFactorAt_pos {f : E → F} {x : E} (h : ConformalAt f x) : 0 < conformalFactorAt h", "start": [ 47, 1 ], "end": [ 48, 53 ], "kind": "commanddeclaration" }, { "full_name": "conformalFactorAt_inner_eq_mul_inner'", "code": "theorem conformalFactorAt_inner_eq_mul_inner' {f : E → F} {x : E} (h : ConformalAt f x) (u v : E) :\n ⟪(fderiv ℝ f x) u, (fderiv ℝ f x) v⟫ = (conformalFactorAt h : ℝ) * ⟪u, v⟫", "start": [ 51, 1 ], "end": [ 53, 57 ], "kind": "commanddeclaration" }, { "full_name": "conformalFactorAt_inner_eq_mul_inner", "code": "theorem conformalFactorAt_inner_eq_mul_inner {f : E → F} {x : E} {f' : E →L[ℝ] F}\n (h : HasFDerivAt f f' x) (H : ConformalAt f x) (u v : E) :\n ⟪f' u, f' v⟫ = (conformalFactorAt H : ℝ) * ⟪u, v⟫", "start": [ 56, 1 ], "end": [ 59, 88 ], "kind": "commanddeclaration" } ]

[ ".lake/packages/lean4/src/lean/Init.lean", "Mathlib/NumberTheory/LSeries/Basic.lean" ]

[ { "full_name": "LSeries.term_add", "code": "lemma LSeries.term_add (f g : ℕ → ℂ) (s : ℂ) : term (f + g) s = term f s + term g s := by\n ext ⟨- | n⟩\n · simp only [term_zero, Pi.add_apply, add_zero]\n · simp only [term_of_ne_zero (Nat.succ_ne_zero _), Pi.add_apply, add_div]", "start": [ 21, 1 ], "end": [ 24, 76 ], "kind": "lemma" }, { "full_name": "LSeries.term_add_apply", "code": "lemma LSeries.term_add_apply (f g : ℕ → ℂ) (s : ℂ) (n : ℕ) :\n term (f + g) s n = term f s n + term g s n := by\n rw [term_add, Pi.add_apply]", "start": [ 26, 1 ], "end": [ 28, 30 ], "kind": "lemma" }, { "full_name": "LSeriesHasSum.add", "code": "lemma LSeriesHasSum.add {f g : ℕ → ℂ} {s a b : ℂ} (hf : LSeriesHasSum f s a)\n (hg : LSeriesHasSum g s b) :\n LSeriesHasSum (f + g) s (a + b) := by\n simpa only [LSeriesHasSum, term_add] using HasSum.add hf hg", "start": [ 30, 1 ], "end": [ 33, 62 ], "kind": "lemma" }, { "full_name": "LSeriesSummable.add", "code": "lemma LSeriesSummable.add {f g : ℕ → ℂ} {s : ℂ} (hf : LSeriesSummable f s)\n (hg : LSeriesSummable g s) :\n LSeriesSummable (f + g) s := by\n simpa only [LSeriesSummable, ← term_add_apply] using Summable.add hf hg", "start": [ 35, 1 ], "end": [ 38, 74 ], "kind": "lemma" }, { "full_name": "LSeries_add", "code": "@[simp]\nlemma LSeries_add {f g : ℕ → ℂ} {s : ℂ} (hf : LSeriesSummable f s) (hg : LSeriesSummable g s) :\n LSeries (f + g) s = LSeries f s + LSeries g s := by\n simpa only [LSeries, term_add, Pi.add_apply] using tsum_add hf hg", "start": [ 40, 1 ], "end": [ 43, 68 ], "kind": "lemma" }, { "full_name": "LSeries.term_neg", "code": "lemma LSeries.term_neg (f : ℕ → ℂ) (s : ℂ) : term (-f) s = -term f s := by\n ext ⟨- | n⟩\n · simp only [Nat.zero_eq, term_zero, Pi.neg_apply, neg_zero]\n · simp only [term_of_ne_zero (Nat.succ_ne_zero _), Pi.neg_apply, Nat.cast_succ, neg_div]", "start": [ 50, 1 ], "end": [ 53, 91 ], "kind": "lemma" }, { "full_name": "LSeries.term_neg_apply", "code": "lemma LSeries.term_neg_apply (f : ℕ → ℂ) (s : ℂ) (n : ℕ) : term (-f) s n = -term f s n := by\n rw [term_neg, Pi.neg_apply]", "start": [ 55, 1 ], "end": [ 56, 30 ], "kind": "lemma" }, { "full_name": "LSeriesHasSum.neg", "code": "lemma LSeriesHasSum.neg {f : ℕ → ℂ} {s a : ℂ} (hf : LSeriesHasSum f s a) :\n LSeriesHasSum (-f) s (-a) := by\n simpa only [LSeriesHasSum, term_neg] using HasSum.neg hf", "start": [ 58, 1 ], "end": [ 60, 59 ], "kind": "lemma" }, { "full_name": "LSeriesSummable.neg", "code": "lemma LSeriesSummable.neg {f : ℕ → ℂ} {s : ℂ} (hf : LSeriesSummable f s) :\n LSeriesSummable (-f) s := by\n simpa only [LSeriesSummable, term_neg] using Summable.neg hf", "start": [ 62, 1 ], "end": [ 64, 63 ], "kind": "lemma" }, { "full_name": "LSeriesSummable.neg_iff", "code": "@[simp]\nlemma LSeriesSummable.neg_iff {f : ℕ → ℂ} {s : ℂ} :\n LSeriesSummable (-f) s ↔ LSeriesSummable f s :=\n ⟨fun H ↦ neg_neg f ▸ H.neg, .neg⟩", "start": [ 66, 1 ], "end": [ 69, 36 ], "kind": "lemma" }, { "full_name": "LSeries_neg", "code": "@[simp]\nlemma LSeries_neg (f : ℕ → ℂ) (s : ℂ) : LSeries (-f) s = -LSeries f s := by\n simp only [LSeries, term_neg_apply, tsum_neg]", "start": [ 71, 1 ], "end": [ 73, 48 ], "kind": "lemma" }, { "full_name": "LSeries.term_sub", "code": "lemma LSeries.term_sub (f g : ℕ → ℂ) (s : ℂ) : term (f - g) s = term f s - term g s := by\n simp_rw [sub_eq_add_neg, term_add, term_neg]", "start": [ 81, 1 ], "end": [ 82, 47 ], "kind": "lemma" }, { "full_name": "LSeries.term_sub_apply", "code": "lemma LSeries.term_sub_apply (f g : ℕ → ℂ) (s : ℂ) (n : ℕ) :\n term (f - g) s n = term f s n - term g s n := by\n rw [term_sub, Pi.sub_apply]", "start": [ 84, 1 ], "end": [ 86, 30 ], "kind": "lemma" }, { "full_name": "LSeriesHasSum.sub", "code": "lemma LSeriesHasSum.sub {f g : ℕ → ℂ} {s a b : ℂ} (hf : LSeriesHasSum f s a)\n (hg : LSeriesHasSum g s b) :\n LSeriesHasSum (f - g) s (a - b) := by\n simpa only [LSeriesHasSum, term_sub] using HasSum.sub hf hg", "start": [ 88, 1 ], "end": [ 91, 62 ], "kind": "lemma" }, { "full_name": "LSeriesSummable.sub", "code": "lemma LSeriesSummable.sub {f g : ℕ → ℂ} {s : ℂ} (hf : LSeriesSummable f s)\n (hg : LSeriesSummable g s) :\n LSeriesSummable (f - g) s := by\n simpa only [LSeriesSummable, ← term_sub_apply] using Summable.sub hf hg", "start": [ 93, 1 ], "end": [ 96, 74 ], "kind": "lemma" }, { "full_name": "LSeries_sub", "code": "@[simp]\nlemma LSeries_sub {f g : ℕ → ℂ} {s : ℂ} (hf : LSeriesSummable f s) (hg : LSeriesSummable g s) :\n LSeries (f - g) s = LSeries f s - LSeries g s := by\n simpa only [LSeries, term_sub, Pi.sub_apply] using tsum_sub hf hg", "start": [ 98, 1 ], "end": [ 101, 68 ], "kind": "lemma" }, { "full_name": "LSeries.term_smul", "code": "lemma LSeries.term_smul (f : ℕ → ℂ) (c s : ℂ) : term (c • f) s = c • term f s := by\n ext ⟨- | n⟩\n · simp only [Nat.zero_eq, term_zero, Pi.smul_apply, smul_eq_mul, mul_zero]\n · simp only [term_of_ne_zero (Nat.succ_ne_zero _), Pi.smul_apply, smul_eq_mul, Nat.cast_succ,\n mul_div_assoc]", "start": [ 107, 1 ], "end": [ 111, 21 ], "kind": "lemma" }, { "full_name": "LSeries.term_smul_apply", "code": "lemma LSeries.term_smul_apply (f : ℕ → ℂ) (c s : ℂ) (n : ℕ) :\n term (c • f) s n = c * term f s n := by\n rw [term_smul, Pi.smul_apply, smul_eq_mul]", "start": [ 113, 1 ], "end": [ 115, 45 ], "kind": "lemma" }, { "full_name": "LSeriesHasSum.smul", "code": "lemma LSeriesHasSum.smul {f : ℕ → ℂ} (c : ℂ) {s a : ℂ} (hf : LSeriesHasSum f s a) :\n LSeriesHasSum (c • f) s (c * a) := by\n simpa only [LSeriesHasSum, term_smul, smul_eq_mul] using hf.const_smul c", "start": [ 117, 1 ], "end": [ 119, 75 ], "kind": "lemma" }, { "full_name": "LSeriesSummable.smul", "code": "lemma LSeriesSummable.smul {f : ℕ → ℂ} (c : ℂ) {s : ℂ} (hf : LSeriesSummable f s) :\n LSeriesSummable (c • f) s := by\n simpa only [LSeriesSummable, term_smul, smul_eq_mul] using hf.const_smul c", "start": [ 121, 1 ], "end": [ 123, 77 ], "kind": "lemma" }, { "full_name": "LSeriesSummable.of_smul", "code": "lemma LSeriesSummable.of_smul {f : ℕ → ℂ} {c s : ℂ} (hc : c ≠ 0) (hf : LSeriesSummable (c • f) s) :\n LSeriesSummable f s := by\n simpa only [ne_eq, hc, not_false_eq_true, inv_smul_smul₀] using hf.smul (c⁻¹)", "start": [ 125, 1 ], "end": [ 127, 80 ], "kind": "lemma" }, { "full_name": "LSeriesSummable.smul_iff", "code": "lemma LSeriesSummable.smul_iff {f : ℕ → ℂ} {c s : ℂ} (hc : c ≠ 0) :\n LSeriesSummable (c • f) s ↔ LSeriesSummable f s :=\n ⟨of_smul hc, smul c⟩", "start": [ 129, 1 ], "end": [ 131, 23 ], "kind": "lemma" }, { "full_name": "LSeries_smul", "code": "@[simp]\nlemma LSeries_smul (f : ℕ → ℂ) (c s : ℂ) : LSeries (c • f) s = c * LSeries f s := by\n simp only [LSeries, term_smul_apply, tsum_mul_left]", "start": [ 133, 1 ], "end": [ 135, 54 ], "kind": "lemma" } ]

[ ".lake/packages/lean4/src/lean/Init.lean", "Mathlib/Analysis/SpecialFunctions/Integrals.lean", "Mathlib/MeasureTheory/Integral/Layercake.lean" ]

[ { "full_name": "MeasureTheory.lintegral_rpow_eq_lintegral_meas_le_mul", "code": "theorem lintegral_rpow_eq_lintegral_meas_le_mul :\n ∫⁻ ω, ENNReal.ofReal (f ω ^ p) ∂μ =\n ENNReal.ofReal p * ∫⁻ t in Ioi 0, μ {a : α | t ≤ f a} * ENNReal.ofReal (t ^ (p - 1))", "start": [ 43, 1 ], "end": [ 72, 37 ], "kind": "commanddeclaration" }, { "full_name": "MeasureTheory.lintegral_rpow_eq_lintegral_meas_lt_mul", "code": "theorem lintegral_rpow_eq_lintegral_meas_lt_mul :\n ∫⁻ ω, ENNReal.ofReal (f ω ^ p) ∂μ =\n ENNReal.ofReal p * ∫⁻ t in Ioi 0, μ {a : α | t < f a} * ENNReal.ofReal (t ^ (p - 1))", "start": [ 79, 1 ], "end": [ 94, 10 ], "kind": "commanddeclaration" } ]

[ ".lake/packages/lean4/src/lean/Init.lean", ".lake/packages/lean4/src/lean/Lean/Environment.lean", ".lake/packages/lean4/src/lean/Lean/Elab/Print.lean" ]

[]

[ "Mathlib/Data/Nat/Prime.lean", "Mathlib/ModelTheory/Algebra/Field/Basic.lean", "Mathlib/ModelTheory/Algebra/Ring/FreeCommRing.lean", "Mathlib/Algebra/CharP/Defs.lean", ".lake/packages/lean4/src/lean/Init.lean" ]

[ { "full_name": "FirstOrder.Field.eqZero", "code": "noncomputable def eqZero (n : ℕ) : Language.ring.Sentence :=\n Term.equal (termOfFreeCommRing n) 0", "start": [ 33, 1 ], "end": [ 36, 38 ], "kind": "commanddeclaration" }, { "full_name": "FirstOrder.Field.realize_eqZero", "code": "@[simp] theorem realize_eqZero [CommRing K] [CompatibleRing K] (n : ℕ)\n (v : Empty → K) : (Formula.Realize (eqZero n) v) ↔ ((n : K) = 0)", "start": [ 38, 1 ], "end": [ 40, 30 ], "kind": "commanddeclaration" }, { "full_name": "FirstOrder.Language.Theory.fieldOfChar", "code": "def _root_.FirstOrder.Language.Theory.fieldOfChar (p : ℕ) : Language.ring.Theory :=\n Theory.field ∪\n if p = 0\n then (fun q => ∼(eqZero q)) '' {q : ℕ | q.Prime}\n else if p.Prime then {eqZero p}\n else {⊥}", "start": [ 42, 1 ], "end": [ 48, 11 ], "kind": "commanddeclaration" }, { "full_name": "FirstOrder.Field.model_hasChar_of_charP", "code": "instance model_hasChar_of_charP [Field K] [CompatibleRing K] [CharP K p] :\n (Theory.fieldOfChar p).Model K := by\n refine Language.Theory.model_union_iff.2 ⟨inferInstance, ?_⟩\n cases CharP.char_is_prime_or_zero K p with\n | inl hp =>\n simp [hp.ne_zero, hp, Sentence.Realize]\n | inr hp =>\n subst hp\n simp only [ite_false, ite_true, Theory.model_iff, Set.mem_image, Set.mem_setOf_eq,\n Sentence.Realize, forall_exists_index, and_imp, forall_apply_eq_imp_iff₂,\n Formula.realize_not, realize_eqZero, ← CharZero.charZero_iff_forall_prime_ne_zero]\n exact CharP.charP_to_charZero K", "start": [ 50, 1 ], "end": [ 61, 36 ], "kind": "commanddeclaration" }, { "full_name": "FirstOrder.Field.charP_iff_model_fieldOfChar", "code": "theorem charP_iff_model_fieldOfChar [Field K] [CompatibleRing K] :\n (Theory.fieldOfChar p).Model K ↔ CharP K p", "start": [ 63, 1 ], "end": [ 78, 57 ], "kind": "commanddeclaration" }, { "full_name": "FirstOrder.Field.model_fieldOfChar_of_charP", "code": "instance model_fieldOfChar_of_charP [Field K] [CompatibleRing K]\n [CharP K p] : (Theory.fieldOfChar p).Model K :=\n charP_iff_model_fieldOfChar.2 inferInstance", "start": [ 80, 1 ], "end": [ 82, 46 ], "kind": "commanddeclaration" }, { "full_name": "FirstOrder.Field.charP_of_model_fieldOfChar", "code": "theorem charP_of_model_fieldOfChar [Field K] [CompatibleRing K]\n [h : (Theory.fieldOfChar p).Model K] : CharP K p", "start": [ 86, 1 ], "end": [ 88, 34 ], "kind": "commanddeclaration" } ]

[ "Mathlib/Analysis/Analytic/Linear.lean", "Mathlib/Geometry/Manifold/SmoothManifoldWithCorners.lean", "Mathlib/Analysis/Calculus/FDeriv/Analytic.lean", ".lake/packages/lean4/src/lean/Init.lean", "Mathlib/Analysis/Analytic/Composition.lean" ]

[ { "full_name": "analyticGroupoid", "code": "def analyticGroupoid : StructureGroupoid H :=\n (contDiffGroupoid ∞ I) ⊓ Pregroupoid.groupoid\n { property := fun f s => AnalyticOn 𝕜 (I ∘ f ∘ I.symm) (I.symm ⁻¹' s ∩ interior (range I)) ∧\n (I.symm ⁻¹' s ∩ interior (range I)).image (I ∘ f ∘ I.symm) ⊆ interior (range I)\n comp := fun {f g u v} hf hg _ _ _ => by\n simp only [] at hf hg ⊢\n have comp : I ∘ (g ∘ f) ∘ I.symm = (I ∘ g ∘ I.symm) ∘ I ∘ f ∘ I.symm := by ext x; simp\n apply And.intro\n · simp only [comp, preimage_inter]\n refine hg.left.comp (hf.left.mono ?_) ?_\n · simp only [subset_inter_iff, inter_subset_right]\n rw [inter_assoc]\n simp\n · intro x hx\n apply And.intro\n · rw [mem_preimage, comp_apply, I.left_inv]\n exact hx.left.right\n · apply hf.right\n rw [mem_image]\n exact ⟨x, ⟨⟨hx.left.left, hx.right⟩, rfl⟩⟩\n · simp only [comp]\n rw [image_comp]\n intro x hx\n rw [mem_image] at hx\n rcases hx with ⟨x', hx'⟩\n refine hg.right ⟨x', And.intro ?_ hx'.right⟩\n apply And.intro\n · have hx'1 : x' ∈ ((v.preimage f).preimage (I.symm)).image (I ∘ f ∘ I.symm) := by\n refine image_subset (I ∘ f ∘ I.symm) ?_ hx'.left\n rw [preimage_inter]\n refine Subset.trans ?_ (u.preimage I.symm).inter_subset_right\n apply inter_subset_left\n rcases hx'1 with ⟨x'', hx''⟩\n rw [hx''.right.symm]\n simp only [comp_apply, mem_preimage, I.left_inv]\n exact hx''.left\n · rw [mem_image] at hx'\n rcases hx'.left with ⟨x'', hx''⟩\n exact hf.right ⟨x'', ⟨⟨hx''.left.left.left, hx''.left.right⟩, hx''.right⟩⟩\n id_mem := by\n apply And.intro\n · simp only [preimage_univ, univ_inter]\n exact AnalyticOn.congr isOpen_interior\n (f := (1 : E →L[𝕜] E)) (fun x _ => (1 : E →L[𝕜] E).analyticAt x)\n (fun z hz => (I.right_inv (interior_subset hz)).symm)\n · intro x hx\n simp only [id_comp, comp_apply, preimage_univ, univ_inter, mem_image] at hx\n rcases hx with ⟨y, hy⟩\n rw [← hy.right, I.right_inv (interior_subset hy.left)]\n exact hy.left\n locality := fun {f u} _ h => by\n simp only [] at h\n simp only [AnalyticOn]\n apply And.intro\n · intro x hx\n rcases h (I.symm x) (mem_preimage.mp hx.left) with ⟨v, hv⟩\n exact hv.right.right.left x ⟨mem_preimage.mpr ⟨hx.left, hv.right.left⟩, hx.right⟩\n · apply mapsTo'.mp\n simp only [MapsTo]\n intro x hx\n rcases h (I.symm x) hx.left with ⟨v, hv⟩\n apply hv.right.right.right\n rw [mem_image]\n have hx' := And.intro hx (mem_preimage.mpr hv.right.left)\n rw [← mem_inter_iff, inter_comm, ← inter_assoc, ← preimage_inter, inter_comm v u] at hx'\n exact ⟨x, ⟨hx', rfl⟩⟩\n congr := fun {f g u} hu fg hf => by\n simp only [] at hf ⊢\n apply And.intro\n · refine AnalyticOn.congr (IsOpen.inter (hu.preimage I.continuous_symm) isOpen_interior)\n hf.left ?_\n intro z hz\n simp only [comp_apply]\n rw [fg (I.symm z) hz.left]\n · intro x hx\n apply hf.right\n rw [mem_image] at hx ⊢\n rcases hx with ⟨y, hy⟩\n refine ⟨y, ⟨hy.left, ?_⟩⟩\n rw [comp_apply, comp_apply, fg (I.symm y) hy.left.left] at hy\n exact hy.right }", "start": [ 45, 1 ], "end": [ 129, 27 ], "kind": "commanddeclaration" }, { "full_name": "ofSet_mem_analyticGroupoid", "code": "theorem ofSet_mem_analyticGroupoid {s : Set H} (hs : IsOpen s) :\n PartialHomeomorph.ofSet s hs ∈ analyticGroupoid I", "start": [ 131, 1 ], "end": [ 155, 24 ], "kind": "commanddeclaration" }, { "full_name": "symm_trans_mem_analyticGroupoid", "code": "theorem symm_trans_mem_analyticGroupoid (e : PartialHomeomorph M H) :\n e.symm.trans e ∈ analyticGroupoid I", "start": [ 157, 1 ], "end": [ 163, 90 ], "kind": "commanddeclaration" }, { "full_name": "mem_analyticGroupoid_of_boundaryless", "code": "theorem mem_analyticGroupoid_of_boundaryless [CompleteSpace E] [I.Boundaryless]\n (e : PartialHomeomorph H H) :\n e ∈ analyticGroupoid I ↔ AnalyticOn 𝕜 (I ∘ e ∘ I.symm) (I '' e.source) ∧\n AnalyticOn 𝕜 (I ∘ e.symm ∘ I.symm) (I '' e.target)", "start": [ 174, 1 ], "end": [ 190, 15 ], "kind": "commanddeclaration" } ]

[ ".lake/packages/lean4/src/lean/Init.lean", "Mathlib/Data/Fin/VecNotation.lean" ]

[ { "full_name": "liftFun_vecCons", "code": "theorem liftFun_vecCons {n : ℕ} (r : α → α → Prop) [IsTrans α r] {f : Fin (n + 1) → α} {a : α} :\n ((· < ·) ⇒ r) (vecCons a f) (vecCons a f) ↔ r a (f 0) ∧ ((· < ·) ⇒ r) f f", "start": [ 21, 1 ], "end": [ 24, 19 ], "kind": "commanddeclaration" }, { "full_name": "strictMono_vecCons", "code": "@[simp]\ntheorem strictMono_vecCons : StrictMono (vecCons a f) ↔ a < f 0 ∧ StrictMono f", "start": [ 29, 1 ], "end": [ 31, 26 ], "kind": "commanddeclaration" }, { "full_name": "monotone_vecCons", "code": "@[simp]\ntheorem monotone_vecCons : Monotone (vecCons a f) ↔ a ≤ f 0 ∧ Monotone f", "start": [ 34, 1 ], "end": [ 36, 79 ], "kind": "commanddeclaration" }, { "full_name": "monotone_vecEmpty", "code": "@[simp]\ntheorem monotone_vecEmpty : Monotone ![a]", "start": [ 39, 1 ], "end": [ 41, 35 ], "kind": "commanddeclaration" }, { "full_name": "strictMono_vecEmpty", "code": "@[simp]\ntheorem strictMono_vecEmpty : StrictMono ![a]", "start": [ 43, 1 ], "end": [ 45, 43 ], "kind": "commanddeclaration" }, { "full_name": "strictAnti_vecCons", "code": "@[simp]\ntheorem strictAnti_vecCons : StrictAnti (vecCons a f) ↔ f 0 < a ∧ StrictAnti f", "start": [ 47, 1 ], "end": [ 49, 26 ], "kind": "commanddeclaration" }, { "full_name": "antitone_vecCons", "code": "@[simp]\ntheorem antitone_vecCons : Antitone (vecCons a f) ↔ f 0 ≤ a ∧ Antitone f", "start": [ 52, 1 ], "end": [ 54, 32 ], "kind": "commanddeclaration" }, { "full_name": "antitone_vecEmpty", "code": "@[simp]\ntheorem antitone_vecEmpty : Antitone (vecCons a vecEmpty)", "start": [ 57, 1 ], "end": [ 59, 35 ], "kind": "commanddeclaration" }, { "full_name": "strictAnti_vecEmpty", "code": "@[simp]\ntheorem strictAnti_vecEmpty : StrictAnti (vecCons a vecEmpty)", "start": [ 61, 1 ], "end": [ 63, 43 ], "kind": "commanddeclaration" }, { "full_name": "StrictMono.vecCons", "code": "theorem StrictMono.vecCons (hf : StrictMono f) (ha : a < f 0) : StrictMono (vecCons a f)", "start": [ 65, 1 ], "end": [ 66, 32 ], "kind": "commanddeclaration" }, { "full_name": "StrictAnti.vecCons", "code": "theorem StrictAnti.vecCons (hf : StrictAnti f) (ha : f 0 < a) : StrictAnti (vecCons a f)", "start": [ 69, 1 ], "end": [ 70, 32 ], "kind": "commanddeclaration" }, { "full_name": "Monotone.vecCons", "code": "theorem Monotone.vecCons (hf : Monotone f) (ha : a ≤ f 0) : Monotone (vecCons a f)", "start": [ 73, 1 ], "end": [ 74, 30 ], "kind": "commanddeclaration" }, { "full_name": "Antitone.vecCons", "code": "theorem Antitone.vecCons (hf : Antitone f) (ha : f 0 ≤ a) : Antitone (vecCons a f)", "start": [ 77, 1 ], "end": [ 78, 30 ], "kind": "commanddeclaration" } ]

[ "Mathlib/Analysis/Calculus/Deriv/Inv.lean", ".lake/packages/lean4/src/lean/Init.lean", "Mathlib/Analysis/Calculus/MeanValue.lean" ]

[ { "full_name": "HasDerivAt.lhopital_zero_right_on_Ioo", "code": "theorem lhopital_zero_right_on_Ioo (hff' : ∀ x ∈ Ioo a b, HasDerivAt f (f' x) x)\n (hgg' : ∀ x ∈ Ioo a b, HasDerivAt g (g' x) x) (hg' : ∀ x ∈ Ioo a b, g' x ≠ 0)\n (hfa : Tendsto f (𝓝[>] a) (𝓝 0)) (hga : Tendsto g (𝓝[>] a) (𝓝 0))\n (hdiv : Tendsto (fun x => f' x / g' x) (𝓝[>] a) l) :\n Tendsto (fun x => f x / g x) (𝓝[>] a) l", "start": [ 51, 1 ], "end": [ 92, 20 ], "kind": "commanddeclaration" }, { "full_name": "HasDerivAt.lhopital_zero_right_on_Ico", "code": "theorem lhopital_zero_right_on_Ico (hff' : ∀ x ∈ Ioo a b, HasDerivAt f (f' x) x)\n (hgg' : ∀ x ∈ Ioo a b, HasDerivAt g (g' x) x) (hcf : ContinuousOn f (Ico a b))\n (hcg : ContinuousOn g (Ico a b)) (hg' : ∀ x ∈ Ioo a b, g' x ≠ 0) (hfa : f a = 0) (hga : g a = 0)\n (hdiv : Tendsto (fun x => f' x / g' x) (𝓝[>] a) l) :\n Tendsto (fun x => f x / g x) (𝓝[>] a) l", "start": [ 95, 1 ], "end": [ 104, 77 ], "kind": "commanddeclaration" }, { "full_name": "HasDerivAt.lhopital_zero_left_on_Ioo", "code": "theorem lhopital_zero_left_on_Ioo (hff' : ∀ x ∈ Ioo a b, HasDerivAt f (f' x) x)\n (hgg' : ∀ x ∈ Ioo a b, HasDerivAt g (g' x) x) (hg' : ∀ x ∈ Ioo a b, g' x ≠ 0)\n (hfb : Tendsto f (𝓝[<] b) (𝓝 0)) (hgb : Tendsto g (𝓝[<] b) (𝓝 0))\n (hdiv : Tendsto (fun x => f' x / g' x) (𝓝[<] b) l) :\n Tendsto (fun x => f x / g x) (𝓝[<] b) l", "start": [ 107, 1 ], "end": [ 129, 23 ], "kind": "commanddeclaration" }, { "full_name": "HasDerivAt.lhopital_zero_left_on_Ioc", "code": "theorem lhopital_zero_left_on_Ioc (hff' : ∀ x ∈ Ioo a b, HasDerivAt f (f' x) x)\n (hgg' : ∀ x ∈ Ioo a b, HasDerivAt g (g' x) x) (hcf : ContinuousOn f (Ioc a b))\n (hcg : ContinuousOn g (Ioc a b)) (hg' : ∀ x ∈ Ioo a b, g' x ≠ 0) (hfb : f b = 0) (hgb : g b = 0)\n (hdiv : Tendsto (fun x => f' x / g' x) (𝓝[<] b) l) :\n Tendsto (fun x => f x / g x) (𝓝[<] b) l", "start": [ 132, 1 ], "end": [ 141, 78 ], "kind": "commanddeclaration" }, { "full_name": "HasDerivAt.lhopital_zero_atTop_on_Ioi", "code": "theorem lhopital_zero_atTop_on_Ioi (hff' : ∀ x ∈ Ioi a, HasDerivAt f (f' x) x)\n (hgg' : ∀ x ∈ Ioi a, HasDerivAt g (g' x) x) (hg' : ∀ x ∈ Ioi a, g' x ≠ 0)\n (hftop : Tendsto f atTop (𝓝 0)) (hgtop : Tendsto g atTop (𝓝 0))\n (hdiv : Tendsto (fun x => f' x / g' x) atTop l) : Tendsto (fun x => f x / g x) atTop l", "start": [ 144, 1 ], "end": [ 174, 23 ], "kind": "commanddeclaration" }, { "full_name": "HasDerivAt.lhopital_zero_atBot_on_Iio", "code": "theorem lhopital_zero_atBot_on_Iio (hff' : ∀ x ∈ Iio a, HasDerivAt f (f' x) x)\n (hgg' : ∀ x ∈ Iio a, HasDerivAt g (g' x) x) (hg' : ∀ x ∈ Iio a, g' x ≠ 0)\n (hfbot : Tendsto f atBot (𝓝 0)) (hgbot : Tendsto g atBot (𝓝 0))\n (hdiv : Tendsto (fun x => f' x / g' x) atBot l) : Tendsto (fun x => f x / g x) atBot l", "start": [ 177, 1 ], "end": [ 199, 23 ], "kind": "commanddeclaration" }, { "full_name": "deriv.lhopital_zero_right_on_Ioo", "code": "theorem lhopital_zero_right_on_Ioo (hdf : DifferentiableOn ℝ f (Ioo a b))\n (hg' : ∀ x ∈ Ioo a b, deriv g x ≠ 0) (hfa : Tendsto f (𝓝[>] a) (𝓝 0))\n (hga : Tendsto g (𝓝[>] a) (𝓝 0))\n (hdiv : Tendsto (fun x => (deriv f) x / (deriv g) x) (𝓝[>] a) l) :\n Tendsto (fun x => f x / g x) (𝓝[>] a) l", "start": [ 206, 1 ], "end": [ 216, 57 ], "kind": "commanddeclaration" }, { "full_name": "deriv.lhopital_zero_right_on_Ico", "code": "theorem lhopital_zero_right_on_Ico (hdf : DifferentiableOn ℝ f (Ioo a b))\n (hcf : ContinuousOn f (Ico a b)) (hcg : ContinuousOn g (Ico a b))\n (hg' : ∀ x ∈ Ioo a b, (deriv g) x ≠ 0) (hfa : f a = 0) (hga : g a = 0)\n (hdiv : Tendsto (fun x => (deriv f) x / (deriv g) x) (𝓝[>] a) l) :\n Tendsto (fun x => f x / g x) (𝓝[>] a) l", "start": [ 219, 1 ], "end": [ 228, 77 ], "kind": "commanddeclaration" }, { "full_name": "deriv.lhopital_zero_left_on_Ioo", "code": "theorem lhopital_zero_left_on_Ioo (hdf : DifferentiableOn ℝ f (Ioo a b))\n (hg' : ∀ x ∈ Ioo a b, (deriv g) x ≠ 0) (hfb : Tendsto f (𝓝[<] b) (𝓝 0))\n (hgb : Tendsto g (𝓝[<] b) (𝓝 0))\n (hdiv : Tendsto (fun x => (deriv f) x / (deriv g) x) (𝓝[<] b) l) :\n Tendsto (fun x => f x / g x) (𝓝[<] b) l", "start": [ 231, 1 ], "end": [ 241, 57 ], "kind": "commanddeclaration" }, { "full_name": "deriv.lhopital_zero_atTop_on_Ioi", "code": "theorem lhopital_zero_atTop_on_Ioi (hdf : DifferentiableOn ℝ f (Ioi a))\n (hg' : ∀ x ∈ Ioi a, (deriv g) x ≠ 0) (hftop : Tendsto f atTop (𝓝 0))\n (hgtop : Tendsto g atTop (𝓝 0)) (hdiv : Tendsto (fun x => (deriv f) x / (deriv g) x) atTop l) :\n Tendsto (fun x => f x / g x) atTop l", "start": [ 244, 1 ], "end": [ 253, 61 ], "kind": "commanddeclaration" }, { "full_name": "deriv.lhopital_zero_atBot_on_Iio", "code": "theorem lhopital_zero_atBot_on_Iio (hdf : DifferentiableOn ℝ f (Iio a))\n (hg' : ∀ x ∈ Iio a, (deriv g) x ≠ 0) (hfbot : Tendsto f atBot (𝓝 0))\n (hgbot : Tendsto g atBot (𝓝 0)) (hdiv : Tendsto (fun x => (deriv f) x / (deriv g) x) atBot l) :\n Tendsto (fun x => f x / g x) atBot l", "start": [ 256, 1 ], "end": [ 265, 61 ], "kind": "commanddeclaration" }, { "full_name": "HasDerivAt.lhopital_zero_nhds_right", "code": "theorem lhopital_zero_nhds_right (hff' : ∀ᶠ x in 𝓝[>] a, HasDerivAt f (f' x) x)\n (hgg' : ∀ᶠ x in 𝓝[>] a, HasDerivAt g (g' x) x) (hg' : ∀ᶠ x in 𝓝[>] a, g' x ≠ 0)\n (hfa : Tendsto f (𝓝[>] a) (𝓝 0)) (hga : Tendsto g (𝓝[>] a) (𝓝 0))\n (hdiv : Tendsto (fun x => f' x / g' x) (𝓝[>] a) l) :\n Tendsto (fun x => f x / g x) (𝓝[>] a) l", "start": [ 280, 1 ], "end": [ 296, 68 ], "kind": "commanddeclaration" }, { "full_name": "HasDerivAt.lhopital_zero_nhds_left", "code": "theorem lhopital_zero_nhds_left (hff' : ∀ᶠ x in 𝓝[<] a, HasDerivAt f (f' x) x)\n (hgg' : ∀ᶠ x in 𝓝[<] a, HasDerivAt g (g' x) x) (hg' : ∀ᶠ x in 𝓝[<] a, g' x ≠ 0)\n (hfa : Tendsto f (𝓝[<] a) (𝓝 0)) (hga : Tendsto g (𝓝[<] a) (𝓝 0))\n (hdiv : Tendsto (fun x => f' x / g' x) (𝓝[<] a) l) :\n Tendsto (fun x => f x / g x) (𝓝[<] a) l", "start": [ 299, 1 ], "end": [ 314, 66 ], "kind": "commanddeclaration" }, { "full_name": "HasDerivAt.lhopital_zero_nhds'", "code": "theorem lhopital_zero_nhds' (hff' : ∀ᶠ x in 𝓝[≠] a, HasDerivAt f (f' x) x)\n (hgg' : ∀ᶠ x in 𝓝[≠] a, HasDerivAt g (g' x) x) (hg' : ∀ᶠ x in 𝓝[≠] a, g' x ≠ 0)\n (hfa : Tendsto f (𝓝[≠] a) (𝓝 0)) (hga : Tendsto g (𝓝[≠] a) (𝓝 0))\n (hdiv : Tendsto (fun x => f' x / g' x) (𝓝[≠] a) l) :\n Tendsto (fun x => f x / g x) (𝓝[≠] a) l", "start": [ 317, 1 ], "end": [ 326, 69 ], "kind": "commanddeclaration" }, { "full_name": "HasDerivAt.lhopital_zero_nhds", "code": "theorem lhopital_zero_nhds (hff' : ∀ᶠ x in 𝓝 a, HasDerivAt f (f' x) x)\n (hgg' : ∀ᶠ x in 𝓝 a, HasDerivAt g (g' x) x) (hg' : ∀ᶠ x in 𝓝 a, g' x ≠ 0)\n (hfa : Tendsto f (𝓝 a) (𝓝 0)) (hga : Tendsto g (𝓝 a) (𝓝 0))\n (hdiv : Tendsto (fun x => f' x / g' x) (𝓝 a) l) : Tendsto (fun x => f x / g x) (𝓝[≠] a) l", "start": [ 329, 1 ], "end": [ 336, 63 ], "kind": "commanddeclaration" }, { "full_name": "HasDerivAt.lhopital_zero_atTop", "code": "theorem lhopital_zero_atTop (hff' : ∀ᶠ x in atTop, HasDerivAt f (f' x) x)\n (hgg' : ∀ᶠ x in atTop, HasDerivAt g (g' x) x) (hg' : ∀ᶠ x in atTop, g' x ≠ 0)\n (hftop : Tendsto f atTop (𝓝 0)) (hgtop : Tendsto g atTop (𝓝 0))\n (hdiv : Tendsto (fun x => f' x / g' x) atTop l) : Tendsto (fun x => f x / g x) atTop l", "start": [ 339, 1 ], "end": [ 354, 87 ], "kind": "commanddeclaration" }, { "full_name": "HasDerivAt.lhopital_zero_atBot", "code": "theorem lhopital_zero_atBot (hff' : ∀ᶠ x in atBot, HasDerivAt f (f' x) x)\n (hgg' : ∀ᶠ x in atBot, HasDerivAt g (g' x) x) (hg' : ∀ᶠ x in atBot, g' x ≠ 0)\n (hfbot : Tendsto f atBot (𝓝 0)) (hgbot : Tendsto g atBot (𝓝 0))\n (hdiv : Tendsto (fun x => f' x / g' x) atBot l) : Tendsto (fun x => f x / g x) atBot l", "start": [ 357, 1 ], "end": [ 372, 87 ], "kind": "commanddeclaration" }, { "full_name": "deriv.lhopital_zero_nhds_right", "code": "theorem lhopital_zero_nhds_right (hdf : ∀ᶠ x in 𝓝[>] a, DifferentiableAt ℝ f x)\n (hg' : ∀ᶠ x in 𝓝[>] a, deriv g x ≠ 0) (hfa : Tendsto f (𝓝[>] a) (𝓝 0))\n (hga : Tendsto g (𝓝[>] a) (𝓝 0))\n (hdiv : Tendsto (fun x => (deriv f) x / (deriv g) x) (𝓝[>] a) l) :\n Tendsto (fun x => f x / g x) (𝓝[>] a) l", "start": [ 379, 1 ], "end": [ 392, 71 ], "kind": "commanddeclaration" }, { "full_name": "deriv.lhopital_zero_nhds_left", "code": "theorem lhopital_zero_nhds_left (hdf : ∀ᶠ x in 𝓝[<] a, DifferentiableAt ℝ f x)\n (hg' : ∀ᶠ x in 𝓝[<] a, deriv g x ≠ 0) (hfa : Tendsto f (𝓝[<] a) (𝓝 0))\n (hga : Tendsto g (𝓝[<] a) (𝓝 0))\n (hdiv : Tendsto (fun x => (deriv f) x / (deriv g) x) (𝓝[<] a) l) :\n Tendsto (fun x => f x / g x) (𝓝[<] a) l", "start": [ 395, 1 ], "end": [ 408, 70 ], "kind": "commanddeclaration" }, { "full_name": "deriv.lhopital_zero_nhds'", "code": "theorem lhopital_zero_nhds' (hdf : ∀ᶠ x in 𝓝[≠] a, DifferentiableAt ℝ f x)\n (hg' : ∀ᶠ x in 𝓝[≠] a, deriv g x ≠ 0) (hfa : Tendsto f (𝓝[≠] a) (𝓝 0))\n (hga : Tendsto g (𝓝[≠] a) (𝓝 0))\n (hdiv : Tendsto (fun x => (deriv f) x / (deriv g) x) (𝓝[≠] a) l) :\n Tendsto (fun x => f x / g x) (𝓝[≠] a) l", "start": [ 411, 1 ], "end": [ 420, 61 ], "kind": "commanddeclaration" }, { "full_name": "deriv.lhopital_zero_nhds", "code": "theorem lhopital_zero_nhds (hdf : ∀ᶠ x in 𝓝 a, DifferentiableAt ℝ f x)\n (hg' : ∀ᶠ x in 𝓝 a, deriv g x ≠ 0) (hfa : Tendsto f (𝓝 a) (𝓝 0)) (hga : Tendsto g (𝓝 a) (𝓝 0))\n (hdiv : Tendsto (fun x => (deriv f) x / (deriv g) x) (𝓝 a) l) :\n Tendsto (fun x => f x / g x) (𝓝[≠] a) l", "start": [ 423, 1 ], "end": [ 430, 63 ], "kind": "commanddeclaration" }, { "full_name": "deriv.lhopital_zero_atTop", "code": "theorem lhopital_zero_atTop (hdf : ∀ᶠ x : ℝ in atTop, DifferentiableAt ℝ f x)\n (hg' : ∀ᶠ x : ℝ in atTop, deriv g x ≠ 0) (hftop : Tendsto f atTop (𝓝 0))\n (hgtop : Tendsto g atTop (𝓝 0)) (hdiv : Tendsto (fun x => (deriv f) x / (deriv g) x) atTop l) :\n Tendsto (fun x => f x / g x) atTop l", "start": [ 433, 1 ], "end": [ 445, 70 ], "kind": "commanddeclaration" }, { "full_name": "deriv.lhopital_zero_atBot", "code": "theorem lhopital_zero_atBot (hdf : ∀ᶠ x : ℝ in atBot, DifferentiableAt ℝ f x)\n (hg' : ∀ᶠ x : ℝ in atBot, deriv g x ≠ 0) (hfbot : Tendsto f atBot (𝓝 0))\n (hgbot : Tendsto g atBot (𝓝 0)) (hdiv : Tendsto (fun x => (deriv f) x / (deriv g) x) atBot l) :\n Tendsto (fun x => f x / g x) atBot l", "start": [ 448, 1 ], "end": [ 460, 70 ], "kind": "commanddeclaration" } ]

[ "Mathlib/Analysis/Complex/CauchyIntegral.lean", "Mathlib/Analysis/Analytic/IsolatedZeros.lean", ".lake/packages/lean4/src/lean/Init.lean", "Mathlib/Analysis/Complex/AbsMax.lean" ]

[ { "full_name": "DiffContOnCl.ball_subset_image_closedBall", "code": "theorem DiffContOnCl.ball_subset_image_closedBall (h : DiffContOnCl ℂ f (ball z₀ r)) (hr : 0 < r)\n (hf : ∀ z ∈ sphere z₀ r, ε ≤ ‖f z - f z₀‖) (hz₀ : ∃ᶠ z in 𝓝 z₀, f z ≠ f z₀) :\n ball (f z₀) (ε / 2) ⊆ f '' closedBall z₀ r", "start": [ 42, 1 ], "end": [ 70, 82 ], "kind": "commanddeclaration" }, { "full_name": "AnalyticAt.eventually_constant_or_nhds_le_map_nhds_aux", "code": "theorem AnalyticAt.eventually_constant_or_nhds_le_map_nhds_aux (hf : AnalyticAt ℂ f z₀) :\n (∀ᶠ z in 𝓝 z₀, f z = f z₀) ∨ 𝓝 (f z₀) ≤ map f (𝓝 z₀)", "start": [ 73, 1 ], "end": [ 106, 65 ], "kind": "commanddeclaration" }, { "full_name": "AnalyticAt.eventually_constant_or_nhds_le_map_nhds", "code": "theorem AnalyticAt.eventually_constant_or_nhds_le_map_nhds {z₀ : E} (hg : AnalyticAt ℂ g z₀) :\n (∀ᶠ z in 𝓝 z₀, g z = g z₀) ∨ 𝓝 (g z₀) ≤ map g (𝓝 z₀)", "start": [ 109, 1 ], "end": [ 157, 30 ], "kind": "commanddeclaration" }, { "full_name": "AnalyticOn.is_constant_or_isOpen", "code": "theorem AnalyticOn.is_constant_or_isOpen (hg : AnalyticOn ℂ g U) (hU : IsPreconnected U) :\n (∃ w, ∀ z ∈ U, g z = w) ∨ ∀ s ⊆ U, IsOpen s → IsOpen (g '' s)", "start": [ 160, 1 ], "end": [ 172, 43 ], "kind": "commanddeclaration" } ]

[ "Mathlib/Algebra/GradedMulAction.lean", "Mathlib/Algebra/Module/BigOperators.lean", ".lake/packages/lean4/src/lean/Init.lean", "Mathlib/RingTheory/GradedAlgebra/Basic.lean", "Mathlib/Algebra/DirectSum/Decomposition.lean" ]

[ { "full_name": "DirectSum.GdistribMulAction", "code": "class GdistribMulAction [AddMonoid ιA] [VAdd ιA ιB] [GMonoid A] [∀ i, AddMonoid (M i)]\n extends GMulAction A M where\n smul_add {i j} (a : A i) (b c : M j) : smul a (b + c) = smul a b + smul a c\n smul_zero {i j} (a : A i) : smul a (0 : M j) = 0", "start": [ 36, 1 ], "end": [ 40, 51 ], "kind": "commanddeclaration" }, { "full_name": "DirectSum.Gmodule", "code": "class Gmodule [AddMonoid ιA] [VAdd ιA ιB] [∀ i, AddMonoid (A i)] [∀ i, AddMonoid (M i)] [GMonoid A]\n extends GdistribMulAction A M where\n add_smul {i j} (a a' : A i) (b : M j) : smul (a + a') b = smul a b + smul a' b\n zero_smul {i j} (b : M j) : smul (0 : A i) b = 0", "start": [ 43, 1 ], "end": [ 47, 51 ], "kind": "commanddeclaration" }, { "full_name": "DirectSum.GSemiring.toGmodule", "code": "instance GSemiring.toGmodule [AddMonoid ιA] [∀ i : ιA, AddCommMonoid (A i)]\n [h : GSemiring A] : Gmodule A A :=\n { GMonoid.toGMulAction A with\n smul_add := fun _ _ _ => h.mul_add _ _ _\n smul_zero := fun _ => h.mul_zero _\n add_smul := fun _ _ => h.add_mul _ _\n zero_smul := fun _ => h.zero_mul _ }", "start": [ 50, 1 ], "end": [ 57, 41 ], "kind": "commanddeclaration" }, { "full_name": "DirectSum.gsmulHom", "code": "@[simps]\ndef gsmulHom [GMonoid A] [Gmodule A M] {i j} : A i →+ M j →+ M (i +ᵥ j) where\n toFun a :=\n { toFun := fun b => GSMul.smul a b\n map_zero' := GdistribMulAction.smul_zero _\n map_add' := GdistribMulAction.smul_add _ }\n map_zero' := AddMonoidHom.ext fun a => Gmodule.zero_smul a\n map_add' _a₁ _a₂ := AddMonoidHom.ext fun _b => Gmodule.add_smul _ _ _", "start": [ 62, 1 ], "end": [ 70, 72 ], "kind": "commanddeclaration" }, { "full_name": "DirectSum.Gmodule.smulAddMonoidHom", "code": "def smulAddMonoidHom [DecidableEq ιA] [DecidableEq ιB] [GMonoid A] [Gmodule A M] :\n (⨁ i, A i) →+ (⨁ i, M i) →+ ⨁ i, M i :=\n toAddMonoid fun _i =>\n AddMonoidHom.flip <|\n toAddMonoid fun _j => AddMonoidHom.flip <| (of M _).compHom.comp <| gsmulHom A M", "start": [ 75, 1 ], "end": [ 81, 87 ], "kind": "commanddeclaration" }, { "full_name": "DirectSum.Gmodule.smul_def", "code": "@[simp]\ntheorem smul_def [DecidableEq ιA] [DecidableEq ιB] [GMonoid A] [Gmodule A M]\n (x : ⨁ i, A i) (y : ⨁ i, M i) :\n x • y = smulAddMonoidHom _ _ x y", "start": [ 92, 1 ], "end": [ 95, 44 ], "kind": "commanddeclaration" }, { "full_name": "DirectSum.Gmodule.smulAddMonoidHom_apply_of_of", "code": "@[simp]\ntheorem smulAddMonoidHom_apply_of_of [DecidableEq ιA] [DecidableEq ιB] [GMonoid A] [Gmodule A M]\n {i j} (x : A i) (y : M j) :\n smulAddMonoidHom A M (DirectSum.of A i x) (of M j y) = of M (i +ᵥ j) (GSMul.smul x y)", "start": [ 98, 1 ], "end": [ 102, 26 ], "kind": "commanddeclaration" }, { "full_name": "DirectSum.Gmodule.of_smul_of", "code": "theorem of_smul_of [DecidableEq ιA] [DecidableEq ιB] [GMonoid A] [Gmodule A M]\n {i j} (x : A i) (y : M j) :\n DirectSum.of A i x • of M j y = of M (i +ᵥ j) (GSMul.smul x y)", "start": [ 106, 1 ], "end": [ 109, 39 ], "kind": "commanddeclaration" }, { "full_name": "DirectSum.Gmodule.one_smul'", "code": "private theorem one_smul' [DecidableEq ιA] [DecidableEq ιB] [GMonoid A] [Gmodule A M]\n (x : ⨁ i, M i) :\n (1 : ⨁ i, A i) • x = x", "start": [ 116, 1 ], "end": [ 123, 95 ], "kind": "commanddeclaration" }, { "full_name": "DirectSum.Gmodule.mul_smul'", "code": "private theorem mul_smul' [DecidableEq ιA] [DecidableEq ιB] [GSemiring A] [Gmodule A M]\n (a b : ⨁ i, A i)\n (c : ⨁ i, M i) : (a * b) • c = a • b • c", "start": [ 127, 1 ], "end": [ 145, 89 ], "kind": "commanddeclaration" }, { "full_name": "DirectSum.Gmodule.module", "code": "instance module [DecidableEq ιA] [DecidableEq ιB] [GSemiring A] [Gmodule A M] :\n Module (⨁ i, A i) (⨁ i, M i) where\n smul := (· • ·)\n one_smul := one_smul' _ _\n mul_smul := mul_smul' _ _\n smul_add r := (smulAddMonoidHom A M r).map_add\n smul_zero r := (smulAddMonoidHom A M r).map_zero\n add_smul r s x := by simp only [smul_def, map_add, AddMonoidHom.add_apply]\n zero_smul x := by simp only [smul_def, map_zero, AddMonoidHom.zero_apply]", "start": [ 147, 1 ], "end": [ 156, 76 ], "kind": "commanddeclaration" }, { "full_name": "SetLike.gmulAction", "code": "instance gmulAction [AddMonoid M] [DistribMulAction A M] [SetLike σ M] [SetLike.GradedMonoid 𝓐]\n [SetLike.GradedSMul 𝓐 𝓜] : GradedMonoid.GMulAction (fun i => 𝓐 i) fun i => 𝓜 i :=\n { SetLike.toGSMul 𝓐 𝓜 with\n one_smul := fun ⟨_i, _m⟩ => Sigma.subtype_ext (zero_vadd _ _) (one_smul _ _)\n mul_smul := fun ⟨_i, _a⟩ ⟨_j, _a'⟩ ⟨_k, _b⟩ =>\n Sigma.subtype_ext (add_vadd _ _ _) (mul_smul _ _ _) }", "start": [ 176, 1 ], "end": [ 181, 60 ], "kind": "commanddeclaration" }, { "full_name": "SetLike.gdistribMulAction", "code": "instance gdistribMulAction [AddMonoid M] [DistribMulAction A M] [SetLike σ M]\n [AddSubmonoidClass σ M] [SetLike.GradedMonoid 𝓐] [SetLike.GradedSMul 𝓐 𝓜] :\n DirectSum.GdistribMulAction (fun i => 𝓐 i) fun i => 𝓜 i :=\n { SetLike.gmulAction 𝓐 𝓜 with\n smul_add := fun _a _b _c => Subtype.ext <| smul_add _ _ _\n smul_zero := fun _a => Subtype.ext <| smul_zero _ }", "start": [ 184, 1 ], "end": [ 189, 56 ], "kind": "commanddeclaration" }, { "full_name": "SetLike.gmodule", "code": "instance gmodule : DirectSum.Gmodule (fun i => 𝓐 i) fun i => 𝓜 i :=\n { SetLike.gdistribMulAction 𝓐 𝓜 with\n smul := fun x y => ⟨(x : A) • (y : M), SetLike.GradedSMul.smul_mem x.2 y.2⟩\n add_smul := fun _a _a' _b => Subtype.ext <| add_smul _ _ _\n zero_smul := fun _b => Subtype.ext <| zero_smul _ _ }", "start": [ 195, 1 ], "end": [ 201, 58 ], "kind": "commanddeclaration" }, { "full_name": "GradedModule.isModule", "code": "def isModule [DecidableEq ιA] [DecidableEq ιM] [GradedRing 𝓐] : Module A (⨁ i, 𝓜 i) :=\n { Module.compHom _ (DirectSum.decomposeRingEquiv 𝓐 : A ≃+* ⨁ i, 𝓐 i).toRingHom with\n smul := fun a b => DirectSum.decompose 𝓐 a • b }", "start": [ 211, 1 ], "end": [ 216, 53 ], "kind": "commanddeclaration" }, { "full_name": "GradedModule.linearEquiv", "code": "def linearEquiv [DecidableEq ιA] [DecidableEq ιM] [GradedRing 𝓐] [DirectSum.Decomposition 𝓜] :\n @LinearEquiv A A _ _ (RingHom.id A) (RingHom.id A) _ _ M (⨁ i, 𝓜 i) _\n _ _ (by letI := isModule 𝓐 𝓜; infer_instance) := by\n letI h := isModule 𝓐 𝓜\n refine ⟨⟨(DirectSum.decomposeAddEquiv 𝓜).toAddHom, ?_⟩,\n (DirectSum.decomposeAddEquiv 𝓜).symm.toFun, (DirectSum.decomposeAddEquiv 𝓜).left_inv,\n (DirectSum.decomposeAddEquiv 𝓜).right_inv⟩\n intro x y\n classical\n rw [AddHom.toFun_eq_coe, ← DirectSum.sum_support_decompose 𝓐 x, map_sum, Finset.sum_smul,\n AddEquiv.coe_toAddHom, map_sum, Finset.sum_smul]\n refine Finset.sum_congr rfl (fun i _hi => ?_)\n rw [RingHom.id_apply, ← DirectSum.sum_support_decompose 𝓜 y, map_sum, Finset.smul_sum, map_sum,\n Finset.smul_sum]\n refine Finset.sum_congr rfl (fun j _hj => ?_)\n rw [show (decompose 𝓐 x i : A) • (decomposeAddEquiv 𝓜 ↑(decompose 𝓜 y j) : (⨁ i, 𝓜 i)) =\n DirectSum.Gmodule.smulAddMonoidHom _ _ (decompose 𝓐 ↑(decompose 𝓐 x i))\n (decomposeAddEquiv 𝓜 ↑(decompose 𝓜 y j)) from DirectSum.Gmodule.smul_def _ _ _ _]\n simp only [decomposeAddEquiv_apply, Equiv.invFun_as_coe, Equiv.symm_symm, decompose_coe,\n Gmodule.smulAddMonoidHom_apply_of_of]\n convert DirectSum.decompose_coe 𝓜 _\n rfl", "start": [ 219, 1 ], "end": [ 243, 6 ], "kind": "commanddeclaration" } ]

[ ".lake/packages/lean4/src/lean/Init.lean", "Mathlib/Order/OmegaCompletePartialOrder.lean" ]

[ { "full_name": "CompletePartialOrder", "code": "class CompletePartialOrder (α : Type*) extends PartialOrder α, SupSet α where\n \n lubOfDirected : ∀ d, DirectedOn (· ≤ ·) d → IsLUB d (sSup d)", "start": [ 37, 1 ], "end": [ 42, 63 ], "kind": "commanddeclaration" }, { "full_name": "DirectedOn.isLUB_sSup", "code": "protected lemma DirectedOn.isLUB_sSup : DirectedOn (· ≤ ·) d → IsLUB d (sSup d) :=\nCompletePartialOrder.lubOfDirected _", "start": [ 46, 1 ], "end": [ 47, 37 ], "kind": "lemma" }, { "full_name": "DirectedOn.le_sSup", "code": "protected lemma DirectedOn.le_sSup (hd : DirectedOn (· ≤ ·) d) (ha : a ∈ d) : a ≤ sSup d :=\nhd.isLUB_sSup.1 ha", "start": [ 49, 1 ], "end": [ 50, 19 ], "kind": "lemma" }, { "full_name": "DirectedOn.sSup_le", "code": "protected lemma DirectedOn.sSup_le (hd : DirectedOn (· ≤ ·) d) (ha : ∀ b ∈ d, b ≤ a) : sSup d ≤ a :=\nhd.isLUB_sSup.2 ha", "start": [ 52, 1 ], "end": [ 53, 19 ], "kind": "lemma" }, { "full_name": "Directed.le_iSup", "code": "protected lemma Directed.le_iSup (hf : Directed (· ≤ ·) f) (i : ι) : f i ≤ ⨆ j, f j :=\nhf.directedOn_range.le_sSup <| Set.mem_range_self _", "start": [ 55, 1 ], "end": [ 56, 52 ], "kind": "lemma" }, { "full_name": "Directed.iSup_le", "code": "protected lemma Directed.iSup_le (hf : Directed (· ≤ ·) f) (ha : ∀ i, f i ≤ a) : ⨆ i, f i ≤ a :=\nhf.directedOn_range.sSup_le <| Set.forall_mem_range.2 ha", "start": [ 58, 1 ], "end": [ 59, 57 ], "kind": "lemma" }, { "full_name": "CompletePartialOrder.scottContinuous", "code": "lemma CompletePartialOrder.scottContinuous {f : α → β} :\n ScottContinuous f ↔\n ∀ ⦃d : Set α⦄, d.Nonempty → DirectedOn (· ≤ ·) d → IsLUB (f '' d) (f (sSup d)) := by\n refine ⟨fun h d hd₁ hd₂ ↦ h hd₁ hd₂ hd₂.isLUB_sSup, fun h d hne hd a hda ↦ ?_⟩\n rw [hda.unique hd.isLUB_sSup]\n exact h hne hd", "start": [ 63, 1 ], "end": [ 69, 17 ], "kind": "lemma" }, { "full_name": "CompletePartialOrder.toOmegaCompletePartialOrder", "code": "instance CompletePartialOrder.toOmegaCompletePartialOrder : OmegaCompletePartialOrder α where\n ωSup c := ⨆ n, c n\n le_ωSup c := c.directed.le_iSup\n ωSup_le c _ := c.directed.iSup_le", "start": [ 73, 1 ], "end": [ 77, 36 ], "kind": "commanddeclaration" }, { "full_name": "CompleteLattice.toCompletePartialOrder", "code": "instance CompleteLattice.toCompletePartialOrder [CompleteLattice α] : CompletePartialOrder α where\n sSup := sSup\n lubOfDirected _ _ := isLUB_sSup _", "start": [ 81, 1 ], "end": [ 84, 36 ], "kind": "commanddeclaration" } ]

[ ".lake/packages/lean4/src/lean/Init.lean", "Mathlib/CategoryTheory/Sites/Coherent/SheafComparison.lean", "Mathlib/CategoryTheory/Sites/Equivalence.lean" ]

[ { "full_name": "CategoryTheory.Equivalence.precoherent", "code": "theorem precoherent : Precoherent D", "start": [ 31, 1 ], "end": [ 32, 70 ], "kind": "commanddeclaration" }, { "full_name": "CategoryTheory.Equivalence.sheafCongrPrecoherent", "code": "@[simps!]\ndef sheafCongrPrecoherent : haveI := e.precoherent\n Sheaf (coherentTopology C) A ≌ Sheaf (coherentTopology D) A := e.sheafCongr _ _ _", "start": [ 43, 1 ], "end": [ 48, 86 ], "kind": "commanddeclaration" }, { "full_name": "CategoryTheory.Equivalence.precoherent_isSheaf_iff", "code": "theorem precoherent_isSheaf_iff (F : Cᵒᵖ ⥤ A) : haveI := e.precoherent\n IsSheaf (coherentTopology C) F ↔ IsSheaf (coherentTopology D) (e.inverse.op ⋙ F)", "start": [ 52, 1 ], "end": [ 60, 41 ], "kind": "commanddeclaration" }, { "full_name": "CategoryTheory.Equivalence.precoherent_isSheaf_iff_of_essentiallySmall", "code": "theorem precoherent_isSheaf_iff_of_essentiallySmall [EssentiallySmall C] (F : Cᵒᵖ ⥤ A) :\n IsSheaf (coherentTopology C) F ↔\n IsSheaf (coherentTopology (SmallModel C)) ((equivSmallModel C).inverse.op ⋙ F)", "start": [ 62, 1 ], "end": [ 69, 32 ], "kind": "commanddeclaration" }, { "full_name": "CategoryTheory.Equivalence.preregular", "code": "theorem preregular : Preregular D", "start": [ 77, 1 ], "end": [ 78, 67 ], "kind": "commanddeclaration" }, { "full_name": "CategoryTheory.Equivalence.sheafCongrPreregular", "code": "@[simps!]\ndef sheafCongrPreregular : haveI := e.preregular\n Sheaf (regularTopology C) A ≌ Sheaf (regularTopology D) A := e.sheafCongr _ _ _", "start": [ 89, 1 ], "end": [ 94, 84 ], "kind": "commanddeclaration" }, { "full_name": "CategoryTheory.Equivalence.preregular_isSheaf_iff", "code": "theorem preregular_isSheaf_iff (F : Cᵒᵖ ⥤ A) : haveI := e.preregular\n IsSheaf (regularTopology C) F ↔ IsSheaf (regularTopology D) (e.inverse.op ⋙ F)", "start": [ 98, 1 ], "end": [ 106, 41 ], "kind": "commanddeclaration" }, { "full_name": "CategoryTheory.Equivalence.preregular_isSheaf_iff_of_essentiallySmall", "code": "theorem preregular_isSheaf_iff_of_essentiallySmall [EssentiallySmall C] (F : Cᵒᵖ ⥤ A) :\n IsSheaf (regularTopology C) F ↔ IsSheaf (regularTopology (SmallModel C))\n ((equivSmallModel C).inverse.op ⋙ F)", "start": [ 108, 1 ], "end": [ 114, 73 ], "kind": "commanddeclaration" } ]

[ "Mathlib/Combinatorics/Additive/ETransform.lean", "Mathlib/GroupTheory/Order/Min.lean", ".lake/packages/lean4/src/lean/Init.lean" ]

[ { "full_name": "DevosMulRel", "code": "@[to_additive\n\"The relation we induct along in the proof by DeVos of the Cauchy-Davenport theorem.\n`(s₁, t₁) < (s₂, t₂)` iff\n* `|s₁ + t₁| < |s₂ + t₂|`\n* or `|s₁ + t₁| = |s₂ + t₂|` and `|s₂| + |t₂| < |s₁| + |t₁|`\n* or `|s₁ + t₁| = |s₂ + t₂|` and `|s₁| + |t₁| = |s₂| + |t₂|` and `|s₁| < |s₂|`.\"]\nprivate def DevosMulRel : Finset α × Finset α → Finset α × Finset α → Prop :=\n Prod.Lex (· < ·) (Prod.Lex (· > ·) (· < ·)) on fun x ↦\n ((x.1 * x.2).card, x.1.card + x.2.card, x.1.card)", "start": [ 62, 1 ], "end": [ 75, 54 ], "kind": "commanddeclaration" }, { "full_name": "devosMulRel_iff", "code": "@[to_additive]\nprivate lemma devosMulRel_iff :\n DevosMulRel x y ↔\n (x.1 * x.2).card < (y.1 * y.2).card ∨\n (x.1 * x.2).card = (y.1 * y.2).card ∧ y.1.card + y.2.card < x.1.card + x.2.card ∨\n (x.1 * x.2).card = (y.1 * y.2).card ∧\n x.1.card + x.2.card = y.1.card + y.2.card ∧ x.1.card < y.1.card := by\n simp [DevosMulRel, Prod.lex_iff, and_or_left]", "start": [ 77, 1 ], "end": [ 84, 48 ], "kind": "lemma" }, { "full_name": "devosMulRel_of_le", "code": "@[to_additive]\nprivate lemma devosMulRel_of_le (mul : (x.1 * x.2).card ≤ (y.1 * y.2).card)\n (hadd : y.1.card + y.2.card < x.1.card + x.2.card) : DevosMulRel x y :=\n devosMulRel_iff.2 <| mul.lt_or_eq.imp_right fun h ↦ Or.inl ⟨h, hadd⟩", "start": [ 86, 1 ], "end": [ 89, 71 ], "kind": "lemma" }, { "full_name": "devosMulRel_of_le_of_le", "code": "@[to_additive]\nprivate lemma devosMulRel_of_le_of_le (mul : (x.1 * x.2).card ≤ (y.1 * y.2).card)\n (hadd : y.1.card + y.2.card ≤ x.1.card + x.2.card) (hone : x.1.card < y.1.card) :\n DevosMulRel x y :=\n devosMulRel_iff.2 <|\n mul.lt_or_eq.imp_right fun h ↦ hadd.gt_or_eq.imp (And.intro h) fun h' ↦ ⟨h, h', hone⟩", "start": [ 91, 1 ], "end": [ 96, 90 ], "kind": "lemma" }, { "full_name": "wellFoundedOn_devosMulRel", "code": "@[to_additive]\nprivate lemma wellFoundedOn_devosMulRel :\n {x : Finset α × Finset α | x.1.Nonempty ∧ x.2.Nonempty}.WellFoundedOn\n (DevosMulRel : Finset α × Finset α → Finset α × Finset α → Prop) := by\n refine wellFounded_lt.onFun.wellFoundedOn.prod_lex_of_wellFoundedOn_fiber fun n ↦\n Set.WellFoundedOn.prod_lex_of_wellFoundedOn_fiber ?_ fun n ↦\n wellFounded_lt.onFun.wellFoundedOn\n exact wellFounded_lt.onFun.wellFoundedOn.mono' fun x hx y _ ↦ tsub_lt_tsub_left_of_le <|\n add_le_add ((card_le_card_mul_right _ hx.1.2).trans_eq hx.2) <|\n (card_le_card_mul_left _ hx.1.1).trans_eq hx.2", "start": [ 98, 1 ], "end": [ 107, 53 ], "kind": "lemma" }, { "full_name": "Finset.min_le_card_mul", "code": "@[to_additive \"A generalisation of the **Cauchy-Davenport theorem** to arbitrary groups. The size of\n`s + t` is lower-bounded by `|s| + |t| - 1` unless this quantity is greater than the size of the\nsmallest subgroup.\"]\nlemma Finset.min_le_card_mul (hs : s.Nonempty) (ht : t.Nonempty) :\n min (minOrder α) ↑(s.card + t.card - 1) ≤ (s * t).card := by\n set x := (s, t) with hx\n clear_value x\n simp only [Prod.ext_iff] at hx\n obtain ⟨rfl, rfl⟩ := hx\n refine wellFoundedOn_devosMulRel.induction (P := fun x : Finset α × Finset α ↦\n min (minOrder α) ↑(card x.1 + card x.2 - 1) ≤ card (x.1 * x.2)) ⟨hs, ht⟩ ?_\n clear! x\n rintro ⟨s, t⟩ ⟨hs, ht⟩ ih\n simp only [min_le_iff, tsub_le_iff_right, Prod.forall, Set.mem_setOf_eq, and_imp,\n Nat.cast_le] at *\n obtain hts | hst := lt_or_le t.card s.card\n · simpa only [← mul_inv_rev, add_comm, card_inv] using\n ih _ _ ht.inv hs.inv\n (devosMulRel_iff.2 <| Or.inr <| Or.inr <| by\n simpa only [← mul_inv_rev, add_comm, card_inv, true_and])\n obtain ⟨a, rfl⟩ | ⟨a, ha, b, hb, hab⟩ := hs.exists_eq_singleton_or_nontrivial\n · simp [add_comm]\n obtain ⟨g, hg, hgs⟩ : ∃ g : α, g ≠ 1 ∧ (s ∩ op g • s).Nonempty :=\n ⟨b⁻¹ * a, inv_mul_eq_one.not.2 hab.symm, _,\n mem_inter.2 ⟨ha, mem_smul_finset.2 ⟨_, hb, by simp⟩⟩⟩\n obtain hsg | hsg := eq_or_ne (op g • s) s\n · have hS : (zpowers g : Set α) ⊆ a⁻¹ • (s : Set α) := by\n refine forall_mem_zpowers.2 <| @zpow_induction_right _ _ _ (· ∈ a⁻¹ • (s : Set α))\n ⟨_, ha, inv_mul_self _⟩ (fun c hc ↦ ?_) fun c hc ↦ ?_\n · rw [← hsg, coe_smul_finset, smul_comm]\n exact Set.smul_mem_smul_set hc\n · simp only\n rwa [← op_smul_eq_mul, op_inv, ← Set.mem_smul_set_iff_inv_smul_mem, smul_comm,\n ← coe_smul_finset, hsg]\n refine Or.inl ((minOrder_le_natCard (zpowers_ne_bot.2 hg) <|\n s.finite_toSet.smul_set.subset hS).trans <| WithTop.coe_le_coe.2 <|\n ((Nat.card_mono s.finite_toSet.smul_set hS).trans_eq <| ?_).trans <|\n card_le_card_mul_right _ ht)\n rw [← coe_smul_finset]\n simp [-coe_smul_finset]\n replace hsg : (s ∩ op g • s).card < s.card := card_lt_card ⟨inter_subset_left, fun h ↦\n hsg <| eq_of_superset_of_card_ge (h.trans inter_subset_right) (card_smul_finset _ _).le⟩\n replace aux1 := card_mono <| mulETransformLeft.fst_mul_snd_subset g (s, t)\n replace aux2 := card_mono <| mulETransformRight.fst_mul_snd_subset g (s, t)\n obtain hgt | hgt := disjoint_or_nonempty_inter t (g⁻¹ • t)\n · rw [← card_smul_finset g⁻¹ t]\n refine Or.inr ((add_le_add_right hst _).trans ?_)\n rw [← card_union_of_disjoint hgt]\n exact (card_le_card_mul_left _ hgs).trans (le_add_of_le_left aux1)\n obtain hstg | hstg := le_or_lt_of_add_le_add (MulETransform.card g (s, t)).ge\n · exact (ih _ _ hgs (hgt.mono inter_subset_union) <| devosMulRel_of_le_of_le aux1 hstg hsg).imp\n (WithTop.coe_le_coe.2 aux1).trans' fun h ↦ hstg.trans <| h.trans <| add_le_add_right aux1 _\n · exact (ih _ _ (hgs.mono inter_subset_union) hgt <| devosMulRel_of_le aux2 hstg).imp\n (WithTop.coe_le_coe.2 aux2).trans' fun h ↦\n hstg.le.trans <| h.trans <| add_le_add_right aux2 _", "start": [ 109, 1 ], "end": [ 180, 60 ], "kind": "lemma" }, { "full_name": "Monoid.IsTorsionFree.card_add_card_sub_one_le_card_mul", "code": "@[to_additive \"The **Cauchy-Davenport theorem** for torsion-free groups. The size of `s + t` is\nlower-bounded by `|s| + |t| - 1`.\"]\nlemma Monoid.IsTorsionFree.card_add_card_sub_one_le_card_mul (h : IsTorsionFree α)\n (hs : s.Nonempty) (ht : t.Nonempty) : s.card + t.card - 1 ≤ (s * t).card := by\n simpa only [h.minOrder, min_eq_right, le_top, Nat.cast_le] using Finset.min_le_card_mul hs ht", "start": [ 182, 1 ], "end": [ 188, 96 ], "kind": "lemma" }, { "full_name": "ZMod.min_le_card_add", "code": "lemma ZMod.min_le_card_add {p : ℕ} (hp : p.Prime) {s t : Finset (ZMod p)} (hs : s.Nonempty)\n (ht : t.Nonempty) : min p (s.card + t.card - 1) ≤ (s + t).card := by\n simpa only [ZMod.minOrder_of_prime hp, min_le_iff, Nat.cast_le] using Finset.min_le_card_add hs ht", "start": [ 194, 1 ], "end": [ 198, 101 ], "kind": "lemma" }, { "full_name": "Finset.card_add_card_sub_one_le_card_mul", "code": "@[to_additive\n\"The **Cauchy-Davenport theorem** for linearly ordered additive cancellative semigroups. The size of\n`s + t` is lower-bounded by `|s| + |t| - 1`.\"]\nlemma Finset.card_add_card_sub_one_le_card_mul [LinearOrder α] [Semigroup α] [IsCancelMul α]\n [CovariantClass α α (· * ·) (· ≤ ·)] [CovariantClass α α (swap (· * ·)) (· ≤ ·)]\n {s t : Finset α} (hs : s.Nonempty) (ht : t.Nonempty) : s.card + t.card - 1 ≤ (s * t).card := by\n suffices s * {t.min' ht} ∩ ({s.max' hs} * t) = {s.max' hs * t.min' ht} by\n rw [← card_singleton_mul t (s.max' hs), ← card_mul_singleton s (t.min' ht),\n ← card_union_add_card_inter, ← card_singleton _, ← this, Nat.add_sub_cancel]\n exact card_mono (union_subset (mul_subset_mul_left <| singleton_subset_iff.2 <| min'_mem _ _) <|\n mul_subset_mul_right <| singleton_subset_iff.2 <| max'_mem _ _)\n refine eq_singleton_iff_unique_mem.2 ⟨mem_inter.2 ⟨mul_mem_mul (max'_mem _ _) <|\n mem_singleton_self _, mul_mem_mul (mem_singleton_self _) <| min'_mem _ _⟩, ?_⟩\n simp only [mem_inter, and_imp, mem_mul, mem_singleton, exists_and_left, exists_eq_left,\n forall_exists_index, and_imp, forall_apply_eq_imp_iff₂, mul_left_inj]\n exact fun a' ha' b' hb' h ↦ (le_max' _ _ ha').eq_of_not_lt fun ha ↦\n ((mul_lt_mul_right' ha _).trans_eq' h).not_le <| mul_le_mul_left' (min'_le _ _ hb') _", "start": [ 202, 1 ], "end": [ 220, 90 ], "kind": "lemma" } ]

[ "Mathlib/Data/Nat/ModEq.lean", ".lake/packages/lean4/src/lean/Init.lean", "Mathlib/Tactic/Zify.lean", "Mathlib/Algebra/Group/Submonoid/Membership.lean", "Mathlib/Tactic/Ring.lean" ]

[ { "full_name": "FrobeniusNumber", "code": "def FrobeniusNumber (n : ℕ) (s : Set ℕ) : Prop :=\n IsGreatest { k | k ∉ AddSubmonoid.closure s } n", "start": [ 44, 1 ], "end": [ 48, 50 ], "kind": "commanddeclaration" }, { "full_name": "frobeniusNumber_pair", "code": "theorem frobeniusNumber_pair (cop : Coprime m n) (hm : 1 < m) (hn : 1 < n) :\n FrobeniusNumber (m * n - m - n) {m, n}", "start": [ 53, 1 ], "end": [ 82, 40 ], "kind": "commanddeclaration" } ]

[ "Mathlib/Topology/Category/TopCat/Limits/Basic.lean", "Mathlib/AlgebraicTopology/TopologicalSimplex.lean", "Mathlib/AlgebraicTopology/SimplicialSet.lean", ".lake/packages/lean4/src/lean/Init.lean", "Mathlib/CategoryTheory/Limits/Presheaf.lean" ]

[ { "full_name": "TopCat.toSSet", "code": "noncomputable def TopCat.toSSet : TopCat ⥤ SSet :=\n ColimitAdj.restrictedYoneda SimplexCategory.toTop", "start": [ 40, 1 ], "end": [ 48, 52 ], "kind": "commanddeclaration" }, { "full_name": "SSet.toTop", "code": "noncomputable def SSet.toTop : SSet ⥤ TopCat :=\n ColimitAdj.extendAlongYoneda SimplexCategory.toTop", "start": [ 52, 1 ], "end": [ 57, 53 ], "kind": "commanddeclaration" }, { "full_name": "sSetTopAdj", "code": "noncomputable def sSetTopAdj : SSet.toTop ⊣ TopCat.toSSet :=\n ColimitAdj.yonedaAdjunction _", "start": [ 61, 1 ], "end": [ 63, 32 ], "kind": "commanddeclaration" }, { "full_name": "SSet.toTopSimplex", "code": "noncomputable def SSet.toTopSimplex :\n (yoneda : SimplexCategory ⥤ _) ⋙ SSet.toTop ≅ SimplexCategory.toTop :=\n ColimitAdj.isExtensionAlongYoneda _", "start": [ 67, 1 ], "end": [ 71, 38 ], "kind": "commanddeclaration" } ]

[ "Mathlib/SetTheory/Cardinal/Ordinal.lean", "Mathlib/Order/Filter/CountableInter.lean", "Mathlib/Order/Filter/Cofinite.lean", "Mathlib/SetTheory/Cardinal/Cofinality.lean", ".lake/packages/lean4/src/lean/Init.lean", "Mathlib/Order/Filter/Bases.lean", "Mathlib/Order/Filter/CardinalInter.lean" ]

[ { "full_name": "Filter.cocardinal", "code": "def cocardinal (hreg : c.IsRegular) : Filter α := by\n apply ofCardinalUnion {s | Cardinal.mk s < c} (lt_of_lt_of_le (nat_lt_aleph0 2) hreg.aleph0_le)\n · refine fun s hS hSc ↦ lt_of_le_of_lt (mk_sUnion_le _) <| mul_lt_of_lt hreg.aleph0_le hS ?_\n exact iSup_lt_of_isRegular hreg hS fun i ↦ hSc i i.property\n · exact fun _ hSc _ ht ↦ lt_of_le_of_lt (mk_le_mk_of_subset ht) hSc", "start": [ 32, 1 ], "end": [ 38, 70 ], "kind": "commanddeclaration" }, { "full_name": "Filter.mem_cocardinal", "code": "@[simp]\ntheorem mem_cocardinal {s : Set α} :\n s ∈ cocardinal α hreg ↔ Cardinal.mk (sᶜ : Set α) < c", "start": [ 40, 1 ], "end": [ 42, 68 ], "kind": "commanddeclaration" }, { "full_name": "Filter.cocardinal_aleph0_eq_cofinite", "code": "@[simp] lemma cocardinal_aleph0_eq_cofinite :\n cocardinal (α := α) isRegular_aleph0 = cofinite := by\n aesop", "start": [ 44, 1 ], "end": [ 46, 8 ], "kind": "lemma" }, { "full_name": "Filter.instCardinalInterFilter_cocardinal", "code": "instance instCardinalInterFilter_cocardinal : CardinalInterFilter (cocardinal (α := α) hreg) c where\n cardinal_sInter_mem S hS hSs := by\n rw [mem_cocardinal, Set.compl_sInter]\n apply lt_of_le_of_lt (mk_sUnion_le _)\n apply mul_lt_of_lt hreg.aleph0_le (lt_of_le_of_lt mk_image_le hS)\n apply iSup_lt_of_isRegular hreg <| lt_of_le_of_lt mk_image_le hS\n intro i\n aesop", "start": [ 48, 1 ], "end": [ 55, 10 ], "kind": "commanddeclaration" }, { "full_name": "Filter.eventually_cocardinal", "code": "@[simp]\ntheorem eventually_cocardinal {p : α → Prop} :\n (∀ᶠ x in cocardinal α hreg, p x) ↔ #{ x | ¬p x } < c", "start": [ 57, 1 ], "end": [ 59, 68 ], "kind": "commanddeclaration" }, { "full_name": "Filter.hasBasis_cocardinal", "code": "theorem hasBasis_cocardinal : HasBasis (cocardinal α hreg) {s : Set α | #s < c} compl", "start": [ 61, 1 ], "end": [ 68, 40 ], "kind": "commanddeclaration" }, { "full_name": "Filter.frequently_cocardinal", "code": "theorem frequently_cocardinal {p : α → Prop} :\n (∃ᶠ x in cocardinal α hreg, p x) ↔ c ≤ # { x | p x }", "start": [ 70, 1 ], "end": [ 72, 82 ], "kind": "commanddeclaration" }, { "full_name": "Filter.frequently_cocardinal_mem", "code": "lemma frequently_cocardinal_mem {s : Set α} :\n (∃ᶠ x in cocardinal α hreg, x ∈ s) ↔ c ≤ #s := frequently_cocardinal", "start": [ 74, 1 ], "end": [ 75, 73 ], "kind": "lemma" }, { "full_name": "Filter.cocardinal_inf_principal_neBot_iff", "code": "@[simp]\nlemma cocardinal_inf_principal_neBot_iff {s : Set α} :\n (cocardinal α hreg ⊓ 𝓟 s).NeBot ↔ c ≤ #s :=\n frequently_mem_iff_neBot.symm.trans frequently_cocardinal", "start": [ 77, 1 ], "end": [ 80, 60 ], "kind": "lemma" }, { "full_name": "Filter.compl_mem_cocardinal_of_card_lt", "code": "theorem compl_mem_cocardinal_of_card_lt {s : Set α} (hs : #s < c) :\n sᶜ ∈ cocardinal α hreg", "start": [ 82, 1 ], "end": [ 84, 48 ], "kind": "commanddeclaration" }, { "full_name": "Set.Finite.compl_mem_cocardinal", "code": "theorem _root_.Set.Finite.compl_mem_cocardinal {s : Set α} (hs : s.Finite) :\n sᶜ ∈ cocardinal α hreg", "start": [ 86, 1 ], "end": [ 88, 91 ], "kind": "commanddeclaration" }, { "full_name": "Filter.eventually_cocardinal_nmem_of_card_lt", "code": "theorem eventually_cocardinal_nmem_of_card_lt {s : Set α} (hs : #s < c) :\n ∀ᶠ x in cocardinal α hreg, x ∉ s", "start": [ 90, 1 ], "end": [ 92, 37 ], "kind": "commanddeclaration" }, { "full_name": "Finset.eventually_cocardinal_nmem", "code": "theorem _root_.Finset.eventually_cocardinal_nmem (s : Finset α) :\n ∀ᶠ x in cocardinal α hreg, x ∉ s", "start": [ 94, 1 ], "end": [ 96, 101 ], "kind": "commanddeclaration" }, { "full_name": "Filter.eventually_cocardinal_ne", "code": "theorem eventually_cocardinal_ne (x : α) : ∀ᶠ a in cocardinal α hreg, a ≠ x", "start": [ 98, 1 ], "end": [ 100, 22 ], "kind": "commanddeclaration" }, { "full_name": "Filter.cocountable", "code": "abbrev cocountable : Filter α := cocardinal α Cardinal.isRegular_aleph_one", "start": [ 102, 1 ], "end": [ 103, 75 ], "kind": "commanddeclaration" }, { "full_name": "Filter.mem_cocountable", "code": "theorem mem_cocountable {s : Set α} :\n s ∈ cocountable ↔ (sᶜ : Set α).Countable", "start": [ 105, 1 ], "end": [ 107, 59 ], "kind": "commanddeclaration" } ]

[ "Mathlib/Topology/ShrinkingLemma.lean", ".lake/packages/lean4/src/lean/Init.lean", "Mathlib/Topology/EMetricSpace/Paracompact.lean", "Mathlib/Topology/MetricSpace/Basic.lean", "Mathlib/Topology/MetricSpace/ProperSpace.lean" ]

[ { "full_name": "exists_subset_iUnion_ball_radius_lt", "code": "theorem exists_subset_iUnion_ball_radius_lt {r : ι → ℝ} (hs : IsClosed s)\n (uf : ∀ x ∈ s, { i | x ∈ ball (c i) (r i) }.Finite) (us : s ⊆ ⋃ i, ball (c i) (r i)) :\n ∃ r' : ι → ℝ, (s ⊆ ⋃ i, ball (c i) (r' i)) ∧ ∀ i, r' i < r i", "start": [ 34, 1 ], "end": [ 46, 52 ], "kind": "commanddeclaration" }, { "full_name": "exists_iUnion_ball_eq_radius_lt", "code": "theorem exists_iUnion_ball_eq_radius_lt {r : ι → ℝ} (uf : ∀ x, { i | x ∈ ball (c i) (r i) }.Finite)\n (uU : ⋃ i, ball (c i) (r i) = univ) :\n ∃ r' : ι → ℝ, ⋃ i, ball (c i) (r' i) = univ ∧ ∀ i, r' i < r i", "start": [ 49, 1 ], "end": [ 56, 33 ], "kind": "commanddeclaration" }, { "full_name": "exists_subset_iUnion_ball_radius_pos_lt", "code": "theorem exists_subset_iUnion_ball_radius_pos_lt {r : ι → ℝ} (hr : ∀ i, 0 < r i) (hs : IsClosed s)\n (uf : ∀ x ∈ s, { i | x ∈ ball (c i) (r i) }.Finite) (us : s ⊆ ⋃ i, ball (c i) (r i)) :\n ∃ r' : ι → ℝ, (s ⊆ ⋃ i, ball (c i) (r' i)) ∧ ∀ i, r' i ∈ Ioo 0 (r i)", "start": [ 59, 1 ], "end": [ 69, 49 ], "kind": "commanddeclaration" }, { "full_name": "exists_iUnion_ball_eq_radius_pos_lt", "code": "theorem exists_iUnion_ball_eq_radius_pos_lt {r : ι → ℝ} (hr : ∀ i, 0 < r i)\n (uf : ∀ x, { i | x ∈ ball (c i) (r i) }.Finite) (uU : ⋃ i, ball (c i) (r i) = univ) :\n ∃ r' : ι → ℝ, ⋃ i, ball (c i) (r' i) = univ ∧ ∀ i, r' i ∈ Ioo 0 (r i)", "start": [ 72, 1 ], "end": [ 80, 33 ], "kind": "commanddeclaration" }, { "full_name": "exists_locallyFinite_subset_iUnion_ball_radius_lt", "code": "theorem exists_locallyFinite_subset_iUnion_ball_radius_lt (hs : IsClosed s) {R : α → ℝ}\n (hR : ∀ x ∈ s, 0 < R x) :\n ∃ (ι : Type u) (c : ι → α) (r r' : ι → ℝ),\n (∀ i, c i ∈ s ∧ 0 < r i ∧ r i < r' i ∧ r' i < R (c i)) ∧\n (LocallyFinite fun i => ball (c i) (r' i)) ∧ s ⊆ ⋃ i, ball (c i) (r i)", "start": [ 83, 1 ], "end": [ 106, 91 ], "kind": "commanddeclaration" }, { "full_name": "exists_locallyFinite_iUnion_eq_ball_radius_lt", "code": "theorem exists_locallyFinite_iUnion_eq_ball_radius_lt {R : α → ℝ} (hR : ∀ x, 0 < R x) :\n ∃ (ι : Type u) (c : ι → α) (r r' : ι → ℝ),\n (∀ i, 0 < r i ∧ r i < r' i ∧ r' i < R (c i)) ∧\n (LocallyFinite fun i => ball (c i) (r' i)) ∧ ⋃ i, ball (c i) (r i) = univ", "start": [ 109, 1 ], "end": [ 125, 66 ], "kind": "commanddeclaration" } ]

[ "Mathlib/Dynamics/Ergodic/AddCircle.lean", ".lake/packages/lean4/src/lean/Init.lean", "Mathlib/MeasureTheory/Covering/LiminfLimsup.lean" ]

[ { "full_name": "approxOrderOf", "code": "@[to_additive \"In a seminormed additive group `A`, given `n : ℕ` and `δ : ℝ`,\n`approxAddOrderOf A n δ` is the set of elements within a distance `δ` of a point of order `n`.\"]\ndef approxOrderOf (A : Type*) [SeminormedGroup A] (n : ℕ) (δ : ℝ) : Set A :=\n thickening δ {y | orderOf y = n}", "start": [ 67, 1 ], "end": [ 72, 35 ], "kind": "commanddeclaration" }, { "full_name": "mem_approxOrderOf_iff", "code": "@[to_additive mem_approx_add_orderOf_iff]\ntheorem mem_approxOrderOf_iff {A : Type*} [SeminormedGroup A] {n : ℕ} {δ : ℝ} {a : A} :\n a ∈ approxOrderOf A n δ ↔ ∃ b : A, orderOf b = n ∧ a ∈ ball b δ", "start": [ 76, 1 ], "end": [ 79, 96 ], "kind": "commanddeclaration" }, { "full_name": "wellApproximable", "code": "@[to_additive addWellApproximable \"In a seminormed additive group `A`, given a sequence of\ndistances `δ₁, δ₂, ...`, `addWellApproximable A δ` is the limsup as `n → ∞` of the sets\n`approxAddOrderOf A n δₙ`. Thus, it is the set of points that lie in infinitely many of the sets\n`approxAddOrderOf A n δₙ`.\"]\ndef wellApproximable (A : Type*) [SeminormedGroup A] (δ : ℕ → ℝ) : Set A :=\n blimsup (fun n => approxOrderOf A n (δ n)) atTop fun n => 0 < n", "start": [ 83, 1 ], "end": [ 91, 66 ], "kind": "commanddeclaration" }, { "full_name": "mem_wellApproximable_iff", "code": "@[to_additive mem_add_wellApproximable_iff]\ntheorem mem_wellApproximable_iff {A : Type*} [SeminormedGroup A] {δ : ℕ → ℝ} {a : A} :\n a ∈ wellApproximable A δ ↔\n a ∈ blimsup (fun n => approxOrderOf A n (δ n)) atTop fun n => 0 < n", "start": [ 95, 1 ], "end": [ 99, 10 ], "kind": "commanddeclaration" }, { "full_name": "approxOrderOf.image_pow_subset_of_coprime", "code": "@[to_additive]\ntheorem image_pow_subset_of_coprime (hm : 0 < m) (hmn : n.Coprime m) :\n (fun (y : A) => y ^ m) '' approxOrderOf A n δ ⊆ approxOrderOf A n (m * δ)", "start": [ 107, 1 ], "end": [ 116, 51 ], "kind": "commanddeclaration" }, { "full_name": "approxOrderOf.image_pow_subset", "code": "@[to_additive]\ntheorem image_pow_subset (n : ℕ) (hm : 0 < m) :\n (fun (y : A) => y ^ m) '' approxOrderOf A (n * m) δ ⊆ approxOrderOf A n (m * δ)", "start": [ 120, 1 ], "end": [ 129, 27 ], "kind": "commanddeclaration" }, { "full_name": "approxOrderOf.smul_subset_of_coprime", "code": "@[to_additive]\ntheorem smul_subset_of_coprime (han : (orderOf a).Coprime n) :\n a • approxOrderOf A n δ ⊆ approxOrderOf A (orderOf a * n) δ", "start": [ 133, 1 ], "end": [ 142, 68 ], "kind": "commanddeclaration" }, { "full_name": "approxOrderOf.smul_eq_of_mul_dvd", "code": "@[to_additive vadd_eq_of_mul_dvd]\ntheorem smul_eq_of_mul_dvd (hn : 0 < n) (han : orderOf a ^ 2 ∣ n) :\n a • approxOrderOf A n δ = approxOrderOf A n δ", "start": [ 146, 1 ], "end": [ 166, 43 ], "kind": "commanddeclaration" }, { "full_name": "UnitAddCircle.mem_approxAddOrderOf_iff", "code": "theorem mem_approxAddOrderOf_iff {δ : ℝ} {x : UnitAddCircle} {n : ℕ} (hn : 0 < n) :\n x ∈ approxAddOrderOf UnitAddCircle n δ ↔ ∃ m < n, gcd m n = 1 ∧ ‖x - ↑((m : ℝ) / n)‖ < δ", "start": [ 174, 1 ], "end": [ 180, 77 ], "kind": "commanddeclaration" }, { "full_name": "UnitAddCircle.mem_addWellApproximable_iff", "code": "theorem mem_addWellApproximable_iff (δ : ℕ → ℝ) (x : UnitAddCircle) :\n x ∈ addWellApproximable UnitAddCircle δ ↔\n {n : ℕ | ∃ m < n, gcd m n = 1 ∧ ‖x - ↑((m : ℝ) / n)‖ < δ n}.Infinite", "start": [ 183, 1 ], "end": [ 191, 51 ], "kind": "commanddeclaration" }, { "full_name": "AddCircle.addWellApproximable_ae_empty_or_univ", "code": "theorem addWellApproximable_ae_empty_or_univ (δ : ℕ → ℝ) (hδ : Tendsto δ atTop (𝓝 0)) :\n (∀ᵐ x, ¬addWellApproximable 𝕊 δ x) ∨ ∀ᵐ x, addWellApproximable 𝕊 δ x", "start": [ 206, 1 ], "end": [ 332, 95 ], "kind": "commanddeclaration" }, { "full_name": "NormedAddCommGroup.exists_norm_nsmul_le", "code": "lemma _root_.NormedAddCommGroup.exists_norm_nsmul_le {A : Type*}\n [NormedAddCommGroup A] [CompactSpace A] [ConnectedSpace A]\n [MeasurableSpace A] [BorelSpace A] {μ : Measure A} [μ.IsAddHaarMeasure]\n (ξ : A) {n : ℕ} (hn : 0 < n) (δ : ℝ) (hδ : μ univ ≤ (n + 1) • μ (closedBall (0 : A) (δ/2))) :\n ∃ j ∈ Icc 1 n, ‖j • ξ‖ ≤ δ := by\n have : IsFiniteMeasure μ := CompactSpace.isFiniteMeasure\n let B : Icc 0 n → Set A := fun j ↦ closedBall ((j : ℕ) • ξ) (δ/2)\n have hB : ∀ j, IsClosed (B j) := fun j ↦ isClosed_ball\n suffices ¬ Pairwise (Disjoint on B) by\n obtain ⟨i, j, hij, x, hx⟩ := exists_lt_mem_inter_of_not_pairwise_disjoint this\n refine ⟨j - i, ⟨le_tsub_of_add_le_left hij, ?_⟩, ?_⟩\n · simpa only [tsub_le_iff_right] using j.property.2.trans le_self_add\n · rw [sub_nsmul _ (Subtype.coe_le_coe.mpr hij.le), ← sub_eq_add_neg, ← dist_eq_norm]\n exact (dist_triangle ((j : ℕ) • ξ) x ((i : ℕ) • ξ)).trans (by\n linarith [mem_closedBall.mp hx.1, mem_closedBall'.mp hx.2])\n by_contra h\n apply hn.ne'\n have h' : ⋃ j, B j = univ := by\n rw [← (isClosed_iUnion_of_finite hB).measure_eq_univ_iff_eq (μ := μ)]\n refine le_antisymm (μ.mono (subset_univ _)) ?_\n simp_rw [measure_iUnion h (fun _ ↦ measurableSet_closedBall), tsum_fintype,\n μ.addHaar_closedBall_center, Finset.sum_const, Finset.card_univ, Nat.card_fintypeIcc,\n tsub_zero]\n exact hδ\n replace hδ : 0 ≤ δ/2 := by\n by_contra contra\n suffices μ (closedBall 0 (δ/2)) = 0 by\n apply isOpen_univ.measure_ne_zero μ univ_nonempty <| le_zero_iff.mp <| le_trans hδ _\n simp [this]\n rw [not_le, ← closedBall_eq_empty (x := (0 : A))] at contra\n simp [contra]\n have h'' : ∀ j, (B j).Nonempty := by intro j; rwa [nonempty_closedBall]\n simpa using subsingleton_of_disjoint_isClosed_iUnion_eq_univ h'' h hB h'", "start": [ 335, 1 ], "end": [ 370, 75 ], "kind": "lemma" }, { "full_name": "AddCircle.exists_norm_nsmul_le", "code": "lemma exists_norm_nsmul_le (ξ : 𝕊) {n : ℕ} (hn : 0 < n) :\n ∃ j ∈ Icc 1 n, ‖j • ξ‖ ≤ T / ↑(n + 1) := by\n apply NormedAddCommGroup.exists_norm_nsmul_le (μ := volume) ξ hn\n rw [AddCircle.measure_univ, volume_closedBall, ← ENNReal.ofReal_nsmul,\n mul_div_cancel₀ _ two_ne_zero, min_eq_right (div_le_self hT.out.le <| by simp), nsmul_eq_mul,\n mul_div_cancel₀ _ (Nat.cast_ne_zero.mpr n.succ_ne_zero)]", "start": [ 372, 1 ], "end": [ 380, 61 ], "kind": "lemma" } ]

[ "Mathlib/Mathport/Rename.lean", ".lake/packages/lean4/src/lean/Init.lean", ".lake/packages/batteries/Batteries/Util/LibraryNote.lean" ]

[]

[ "Mathlib/Topology/Order/DenselyOrdered.lean", "Mathlib/MeasureTheory/Covering/BesicovitchVectorSpace.lean", ".lake/packages/lean4/src/lean/Init.lean", "Mathlib/Analysis/Normed/Order/UpperLower.lean" ]

[ { "full_name": "aux₀", "code": "private lemma aux₀\n (h : ∀ δ, 0 < δ →\n ∃ y, closedBall y (δ / 4) ⊆ closedBall x δ ∧ closedBall y (δ / 4) ⊆ interior s) :\n ¬Tendsto (fun r ↦ volume (closure s ∩ closedBall x r) / volume (closedBall x r)) (𝓝[>] 0)\n (𝓝 0) := by\n choose f hf₀ hf₁ using h\n intro H\n obtain ⟨ε, -, hε', hε₀⟩ := exists_seq_strictAnti_tendsto_nhdsWithin (0 : ℝ)\n refine not_eventually.2\n (frequently_of_forall fun _ ↦ lt_irrefl $ ENNReal.ofReal $ 4⁻¹ ^ Fintype.card ι)\n ((Filter.Tendsto.eventually_lt (H.comp hε₀) tendsto_const_nhds ?_).mono fun n ↦\n lt_of_le_of_lt ?_)\n swap\n calc\n ENNReal.ofReal (4⁻¹ ^ Fintype.card ι)\n = volume (closedBall (f (ε n) (hε' n)) (ε n / 4)) / volume (closedBall x (ε n)) := ?_\n _ ≤ volume (closure s ∩ closedBall x (ε n)) / volume (closedBall x (ε n)) := by\n gcongr; exact subset_inter ((hf₁ _ $ hε' n).trans interior_subset_closure) $ hf₀ _ $ hε' n\n dsimp\n have := hε' n\n rw [Real.volume_pi_closedBall, Real.volume_pi_closedBall, ← ENNReal.ofReal_div_of_pos, ← div_pow,\n mul_div_mul_left _ _ (two_ne_zero' ℝ), div_right_comm, div_self, one_div]\n all_goals positivity", "start": [ 55, 1 ], "end": [ 82, 23 ], "kind": "lemma" }, { "full_name": "aux₁", "code": "private lemma aux₁\n (h : ∀ δ, 0 < δ →\n ∃ y, closedBall y (δ / 4) ⊆ closedBall x δ ∧ closedBall y (δ / 4) ⊆ interior sᶜ) :\n ¬Tendsto (fun r ↦ volume (closure s ∩ closedBall x r) / volume (closedBall x r)) (𝓝[>] 0)\n (𝓝 1) := by\n choose f hf₀ hf₁ using h\n intro H\n obtain ⟨ε, -, hε', hε₀⟩ := exists_seq_strictAnti_tendsto_nhdsWithin (0 : ℝ)\n refine\n not_eventually.2\n (frequently_of_forall fun _ ↦ lt_irrefl $ 1 - ENNReal.ofReal (4⁻¹ ^ Fintype.card ι))\n ((Filter.Tendsto.eventually_lt tendsto_const_nhds (H.comp hε₀) $\n ENNReal.sub_lt_self ENNReal.one_ne_top one_ne_zero ?_).mono\n fun n ↦ lt_of_le_of_lt' ?_)\n swap\n calc\n volume (closure s ∩ closedBall x (ε n)) / volume (closedBall x (ε n))\n ≤ volume (closedBall x (ε n) \\ closedBall (f (ε n) $ hε' n) (ε n / 4)) /\n volume (closedBall x (ε n)) := by\n gcongr\n rw [diff_eq_compl_inter]\n refine inter_subset_inter_left _ ?_\n rw [subset_compl_comm, ← interior_compl]\n exact hf₁ _ _\n _ = 1 - ENNReal.ofReal (4⁻¹ ^ Fintype.card ι) := ?_\n dsimp\n have := hε' n\n rw [measure_diff (hf₀ _ _) _ ((Real.volume_pi_closedBall _ _).trans_ne ENNReal.ofReal_ne_top),\n Real.volume_pi_closedBall, Real.volume_pi_closedBall, ENNReal.sub_div fun _ _ ↦ _,\n ENNReal.div_self _ ENNReal.ofReal_ne_top, ← ENNReal.ofReal_div_of_pos, ← div_pow,\n mul_div_mul_left _ _ (two_ne_zero' ℝ), div_right_comm, div_self, one_div]\n all_goals\n first\n | positivity\n | measurability", "start": [ 84, 1 ], "end": [ 123, 20 ], "kind": "lemma" }, { "full_name": "IsUpperSet.null_frontier", "code": "theorem IsUpperSet.null_frontier (hs : IsUpperSet s) : volume (frontier s) = 0", "start": [ 125, 1 ], "end": [ 132, 74 ], "kind": "commanddeclaration" }, { "full_name": "IsLowerSet.null_frontier", "code": "theorem IsLowerSet.null_frontier (hs : IsLowerSet s) : volume (frontier s) = 0", "start": [ 135, 1 ], "end": [ 142, 74 ], "kind": "commanddeclaration" }, { "full_name": "Set.OrdConnected.null_frontier", "code": "theorem Set.OrdConnected.null_frontier (hs : s.OrdConnected) : volume (frontier s) = 0", "start": [ 145, 1 ], "end": [ 149, 74 ], "kind": "commanddeclaration" }, { "full_name": "Set.OrdConnected.nullMeasurableSet", "code": "protected theorem Set.OrdConnected.nullMeasurableSet (hs : s.OrdConnected) : NullMeasurableSet s", "start": [ 152, 1 ], "end": [ 153, 54 ], "kind": "commanddeclaration" }, { "full_name": "IsAntichain.volume_eq_zero", "code": "theorem IsAntichain.volume_eq_zero [Nonempty ι] (hs : IsAntichain (· ≤ ·) s) : volume s = 0", "start": [ 156, 1 ], "end": [ 159, 23 ], "kind": "commanddeclaration" } ]

[ ".lake/packages/lean4/src/lean/Init.lean", "Mathlib/Algebra/Homology/DerivedCategory/Basic.lean" ]

[ { "full_name": "CategoryTheory.Functor.mapDerivedCategory", "code": "noncomputable def mapDerivedCategory : DerivedCategory C₁ ⥤ DerivedCategory C₂ :=\n F.mapHomologicalComplexUpToQuasiIso (ComplexShape.up ℤ)", "start": [ 30, 1 ], "end": [ 33, 58 ], "kind": "commanddeclaration" }, { "full_name": "CategoryTheory.Functor.mapDerivedCategoryFactors", "code": "noncomputable def mapDerivedCategoryFactors :\n DerivedCategory.Q ⋙ F.mapDerivedCategory ≅\n F.mapHomologicalComplex (ComplexShape.up ℤ) ⋙ DerivedCategory.Q :=\n F.mapHomologicalComplexUpToQuasiIsoFactors _", "start": [ 35, 1 ], "end": [ 40, 47 ], "kind": "commanddeclaration" }, { "full_name": "CategoryTheory.Functor.mapDerivedCategoryFactorsh", "code": "noncomputable def mapDerivedCategoryFactorsh :\n DerivedCategory.Qh ⋙ F.mapDerivedCategory ≅\n F.mapHomotopyCategory (ComplexShape.up ℤ) ⋙ DerivedCategory.Qh :=\n F.mapHomologicalComplexUpToQuasiIsoFactorsh _", "start": [ 48, 1 ], "end": [ 53, 48 ], "kind": "commanddeclaration" } ]

[ "Mathlib/Condensed/Light/Basic.lean", ".lake/packages/lean4/src/lean/Init.lean", "Mathlib/CategoryTheory/Sites/Equivalence.lean", "Mathlib/CategoryTheory/Sites/LeftExact.lean", "Mathlib/CategoryTheory/Sites/ConstantSheaf.lean" ]

[ { "full_name": "LightCondensed.discrete", "code": "@[simps!]\nnoncomputable def LightCondensed.discrete : C ⥤ LightCondensed.{u} C := constantSheaf _ C", "start": [ 29, 1 ], "end": [ 33, 90 ], "kind": "commanddeclaration" }, { "full_name": "LightCondensed.underlying", "code": "@[simps!]\nnoncomputable def LightCondensed.underlying : LightCondensed.{u} C ⥤ C :=\n (sheafSections _ _).obj (op (LightProfinite.of PUnit))", "start": [ 35, 1 ], "end": [ 41, 57 ], "kind": "commanddeclaration" }, { "full_name": "LightCondensed.discreteUnderlyingAdj", "code": "noncomputable def LightCondensed.discreteUnderlyingAdj : discrete C ⊣ underlying C :=\n constantSheafAdj _ _ LightProfinite.isTerminalPUnit", "start": [ 43, 1 ], "end": [ 48, 54 ], "kind": "commanddeclaration" }, { "full_name": "LightCondSet.discrete", "code": "noncomputable abbrev LightCondSet.discrete := LightCondensed.discrete (Type u)", "start": [ 50, 1 ], "end": [ 51, 79 ], "kind": "commanddeclaration" }, { "full_name": "LightCondSet.underlying", "code": "noncomputable abbrev LightCondSet.underlying := LightCondensed.underlying (Type u)", "start": [ 53, 1 ], "end": [ 54, 83 ], "kind": "commanddeclaration" }, { "full_name": "LightCondSet.discreteUnderlyingAdj", "code": "noncomputable abbrev LightCondSet.discreteUnderlyingAdj : discrete ⊣ underlying :=\n LightCondensed.discreteUnderlyingAdj _", "start": [ 56, 1 ], "end": [ 58, 41 ], "kind": "commanddeclaration" } ]

[ "Mathlib/LinearAlgebra/CliffordAlgebra/Conjugation.lean", "Mathlib/Algebra/DualNumber.lean", "Mathlib/Data/Complex/Module.lean", ".lake/packages/lean4/src/lean/Init.lean", "Mathlib/Algebra/QuaternionBasis.lean", "Mathlib/LinearAlgebra/CliffordAlgebra/Star.lean", "Mathlib/LinearAlgebra/QuadraticForm/Prod.lean" ]

[ { "full_name": "CliffordAlgebraRing.ι_eq_zero", "code": "@[simp]\ntheorem ι_eq_zero : ι (0 : QuadraticForm R Unit) = 0", "start": [ 74, 1 ], "end": [ 76, 24 ], "kind": "commanddeclaration" }, { "full_name": "CliffordAlgebraRing.reverse_apply", "code": "theorem reverse_apply (x : CliffordAlgebra (0 : QuadraticForm R Unit)) :\n reverse (R := R) x = x", "start": [ 90, 1 ], "end": [ 96, 56 ], "kind": "commanddeclaration" }, { "full_name": "CliffordAlgebraRing.reverse_eq_id", "code": "@[simp]\ntheorem reverse_eq_id :\n (reverse : CliffordAlgebra (0 : QuadraticForm R Unit) →ₗ[R] _) = LinearMap.id", "start": [ 99, 1 ], "end": [ 102, 30 ], "kind": "commanddeclaration" }, { "full_name": "CliffordAlgebraRing.involute_eq_id", "code": "@[simp]\ntheorem involute_eq_id :\n (involute : CliffordAlgebra (0 : QuadraticForm R Unit) →ₐ[R] _) = AlgHom.id R _", "start": [ 105, 1 ], "end": [ 107, 100 ], "kind": "commanddeclaration" }, { "full_name": "CliffordAlgebraRing.equiv", "code": "protected def equiv : CliffordAlgebra (0 : QuadraticForm R Unit) ≃ₐ[R] R :=\n AlgEquiv.ofAlgHom\n (CliffordAlgebra.lift (0 : QuadraticForm R Unit) <|\n ⟨0, fun m : Unit => (zero_mul (0 : R)).trans (algebraMap R _).map_zero.symm⟩)\n (Algebra.ofId R _) (by ext)\n (by ext : 1; rw [ι_eq_zero, LinearMap.comp_zero, LinearMap.comp_zero])", "start": [ 110, 1 ], "end": [ 116, 75 ], "kind": "commanddeclaration" }, { "full_name": "CliffordAlgebraComplex.Q", "code": "def Q : QuadraticForm ℝ ℝ :=\n -QuadraticForm.sq (R := ℝ)", "start": [ 128, 1 ], "end": [ 130, 29 ], "kind": "commanddeclaration" }, { "full_name": "CliffordAlgebraComplex.Q_apply", "code": "@[simp]\ntheorem Q_apply (r : ℝ) : Q r = -(r * r)", "start": [ 134, 1 ], "end": [ 136, 6 ], "kind": "commanddeclaration" }, { "full_name": "CliffordAlgebraComplex.toComplex", "code": "def toComplex : CliffordAlgebra Q →ₐ[ℝ] ℂ :=\n CliffordAlgebra.lift Q\n ⟨LinearMap.toSpanSingleton _ _ Complex.I, fun r => by\n dsimp [LinearMap.toSpanSingleton, LinearMap.id]\n rw [mul_mul_mul_comm]\n simp⟩", "start": [ 140, 1 ], "end": [ 147, 12 ], "kind": "commanddeclaration" }, { "full_name": "CliffordAlgebraComplex.toComplex_ι", "code": "@[simp]\ntheorem toComplex_ι (r : ℝ) : toComplex (ι Q r) = r • Complex.I", "start": [ 150, 1 ], "end": [ 152, 37 ], "kind": "commanddeclaration" }, { "full_name": "CliffordAlgebraComplex.toComplex_involute", "code": "@[simp]\ntheorem toComplex_involute (c : CliffordAlgebra Q) :\n toComplex (involute c) = conj (toComplex c)", "start": [ 155, 1 ], "end": [ 164, 13 ], "kind": "commanddeclaration" }, { "full_name": "CliffordAlgebraComplex.ofComplex", "code": "def ofComplex : ℂ →ₐ[ℝ] CliffordAlgebra Q :=\n Complex.lift\n ⟨CliffordAlgebra.ι Q 1, by\n rw [CliffordAlgebra.ι_sq_scalar, Q_apply, one_mul, RingHom.map_neg, RingHom.map_one]⟩", "start": [ 167, 1 ], "end": [ 172, 92 ], "kind": "commanddeclaration" }, { "full_name": "CliffordAlgebraComplex.ofComplex_I", "code": "@[simp]\ntheorem ofComplex_I : ofComplex Complex.I = ι Q 1", "start": [ 175, 1 ], "end": [ 177, 38 ], "kind": "commanddeclaration" }, { "full_name": "CliffordAlgebraComplex.toComplex_comp_ofComplex", "code": "@[simp]\ntheorem toComplex_comp_ofComplex : toComplex.comp ofComplex = AlgHom.id ℝ ℂ", "start": [ 181, 1 ], "end": [ 185, 42 ], "kind": "commanddeclaration" }, { "full_name": "CliffordAlgebraComplex.toComplex_ofComplex", "code": "@[simp]\ntheorem toComplex_ofComplex (c : ℂ) : toComplex (ofComplex c) = c", "start": [ 188, 1 ], "end": [ 190, 46 ], "kind": "commanddeclaration" }, { "full_name": "CliffordAlgebraComplex.ofComplex_comp_toComplex", "code": "@[simp]\ntheorem ofComplex_comp_toComplex : ofComplex.comp toComplex = AlgHom.id ℝ (CliffordAlgebra Q)", "start": [ 193, 1 ], "end": [ 198, 42 ], "kind": "commanddeclaration" }, { "full_name": "CliffordAlgebraComplex.ofComplex_toComplex", "code": "@[simp]\ntheorem ofComplex_toComplex (c : CliffordAlgebra Q) : ofComplex (toComplex c) = c", "start": [ 201, 1 ], "end": [ 203, 46 ], "kind": "commanddeclaration" }, { "full_name": "CliffordAlgebraComplex.equiv", "code": "@[simps!]\nprotected def equiv : CliffordAlgebra Q ≃ₐ[ℝ] ℂ :=\n AlgEquiv.ofAlgHom toComplex ofComplex toComplex_comp_ofComplex ofComplex_comp_toComplex", "start": [ 206, 1 ], "end": [ 209, 90 ], "kind": "commanddeclaration" }, { "full_name": "CliffordAlgebraComplex.reverse_apply", "code": "theorem reverse_apply (x : CliffordAlgebra Q) : reverse (R := ℝ) x = x", "start": [ 222, 1 ], "end": [ 228, 56 ], "kind": "commanddeclaration" }, { "full_name": "CliffordAlgebraComplex.reverse_eq_id", "code": "@[simp]\ntheorem reverse_eq_id : (reverse : CliffordAlgebra Q →ₗ[ℝ] _) = LinearMap.id", "start": [ 231, 1 ], "end": [ 233, 30 ], "kind": "commanddeclaration" }, { "full_name": "CliffordAlgebraComplex.ofComplex_conj", "code": "@[simp]\ntheorem ofComplex_conj (c : ℂ) : ofComplex (conj c) = involute (ofComplex c)", "start": [ 236, 1 ], "end": [ 240, 96 ], "kind": "commanddeclaration" }, { "full_name": "CliffordAlgebraQuaternion.Q", "code": "def Q : QuadraticForm R (R × R) :=\n (c₁ • QuadraticForm.sq (R := R)).prod (c₂ • QuadraticForm.sq)", "start": [ 259, 1 ], "end": [ 262, 64 ], "kind": "commanddeclaration" }, { "full_name": "CliffordAlgebraQuaternion.Q_apply", "code": "@[simp]\ntheorem Q_apply (v : R × R) : Q c₁ c₂ v = c₁ * (v.1 * v.1) + c₂ * (v.2 * v.2)", "start": [ 266, 1 ], "end": [ 268, 6 ], "kind": "commanddeclaration" }, { "full_name": "CliffordAlgebraQuaternion.quaternionBasis", "code": "@[simps i j k]\ndef quaternionBasis : QuaternionAlgebra.Basis (CliffordAlgebra (Q c₁ c₂)) c₁ c₂ where\n i := ι (Q c₁ c₂) (1, 0)\n j := ι (Q c₁ c₂) (0, 1)\n k := ι (Q c₁ c₂) (1, 0) * ι (Q c₁ c₂) (0, 1)\n i_mul_i := by\n rw [ι_sq_scalar, Q_apply, ← Algebra.algebraMap_eq_smul_one]\n simp\n j_mul_j := by\n rw [ι_sq_scalar, Q_apply, ← Algebra.algebraMap_eq_smul_one]\n simp\n i_mul_j := rfl\n j_mul_i := by\n rw [eq_neg_iff_add_eq_zero, ι_mul_ι_add_swap, QuadraticForm.polar]\n simp", "start": [ 272, 1 ], "end": [ 287, 9 ], "kind": "commanddeclaration" }, { "full_name": "CliffordAlgebraQuaternion.toQuaternion", "code": "def toQuaternion : CliffordAlgebra (Q c₁ c₂) →ₐ[R] ℍ[R,c₁,c₂] :=\n CliffordAlgebra.lift (Q c₁ c₂)\n ⟨{ toFun := fun v => (⟨0, v.1, v.2, 0⟩ : ℍ[R,c₁,c₂])\n map_add' := fun v₁ v₂ => by simp\n map_smul' := fun r v => by dsimp; rw [mul_zero] }, fun v => by\n dsimp\n ext\n all_goals dsimp; ring⟩", "start": [ 292, 1 ], "end": [ 301, 29 ], "kind": "commanddeclaration" }, { "full_name": "CliffordAlgebraQuaternion.toQuaternion_ι", "code": "@[simp]\ntheorem toQuaternion_ι (v : R × R) :\n toQuaternion (ι (Q c₁ c₂) v) = (⟨0, v.1, v.2, 0⟩ : ℍ[R,c₁,c₂])", "start": [ 304, 1 ], "end": [ 307, 37 ], "kind": "commanddeclaration" }, { "full_name": "CliffordAlgebraQuaternion.toQuaternion_star", "code": "theorem toQuaternion_star (c : CliffordAlgebra (Q c₁ c₂)) :\n toQuaternion (star c) = star (toQuaternion c)", "start": [ 310, 1 ], "end": [ 322, 89 ], "kind": "commanddeclaration" }, { "full_name": "CliffordAlgebraQuaternion.ofQuaternion", "code": "def ofQuaternion : ℍ[R,c₁,c₂] →ₐ[R] CliffordAlgebra (Q c₁ c₂) :=\n (quaternionBasis c₁ c₂).liftHom", "start": [ 325, 1 ], "end": [ 327, 34 ], "kind": "commanddeclaration" }, { "full_name": "CliffordAlgebraQuaternion.ofQuaternion_mk", "code": "@[simp]\ntheorem ofQuaternion_mk (a₁ a₂ a₃ a₄ : R) :\n ofQuaternion (⟨a₁, a₂, a₃, a₄⟩ : ℍ[R,c₁,c₂]) =\n algebraMap R _ a₁ + a₂ • ι (Q c₁ c₂) (1, 0) + a₃ • ι (Q c₁ c₂) (0, 1) +\n a₄ • (ι (Q c₁ c₂) (1, 0) * ι (Q c₁ c₂) (0, 1))", "start": [ 330, 1 ], "end": [ 335, 6 ], "kind": "commanddeclaration" }, { "full_name": "CliffordAlgebraQuaternion.ofQuaternion_comp_toQuaternion", "code": "@[simp]\ntheorem ofQuaternion_comp_toQuaternion :\n ofQuaternion.comp toQuaternion = AlgHom.id R (CliffordAlgebra (Q c₁ c₂))", "start": [ 338, 1 ], "end": [ 348, 90 ], "kind": "commanddeclaration" }, { "full_name": "CliffordAlgebraQuaternion.ofQuaternion_toQuaternion", "code": "@[simp]\ntheorem ofQuaternion_toQuaternion (c : CliffordAlgebra (Q c₁ c₂)) :\n ofQuaternion (toQuaternion c) = c", "start": [ 351, 1 ], "end": [ 354, 52 ], "kind": "commanddeclaration" }, { "full_name": "CliffordAlgebraQuaternion.toQuaternion_comp_ofQuaternion", "code": "@[simp]\ntheorem toQuaternion_comp_ofQuaternion :\n toQuaternion.comp ofQuaternion = AlgHom.id R ℍ[R,c₁,c₂]", "start": [ 357, 1 ], "end": [ 360, 19 ], "kind": "commanddeclaration" }, { "full_name": "CliffordAlgebraQuaternion.toQuaternion_ofQuaternion", "code": "@[simp]\ntheorem toQuaternion_ofQuaternion (q : ℍ[R,c₁,c₂]) : toQuaternion (ofQuaternion q) = q", "start": [ 363, 1 ], "end": [ 365, 52 ], "kind": "commanddeclaration" }, { "full_name": "CliffordAlgebraQuaternion.equiv", "code": "@[simps!]\nprotected def equiv : CliffordAlgebra (Q c₁ c₂) ≃ₐ[R] ℍ[R,c₁,c₂] :=\n AlgEquiv.ofAlgHom toQuaternion ofQuaternion toQuaternion_comp_ofQuaternion\n ofQuaternion_comp_toQuaternion", "start": [ 368, 1 ], "end": [ 373, 35 ], "kind": "commanddeclaration" }, { "full_name": "CliffordAlgebraQuaternion.ofQuaternion_star", "code": "@[simp]\ntheorem ofQuaternion_star (q : ℍ[R,c₁,c₂]) : ofQuaternion (star q) = star (ofQuaternion q)", "start": [ 376, 1 ], "end": [ 381, 33 ], "kind": "commanddeclaration" }, { "full_name": "CliffordAlgebraDualNumber.ι_mul_ι", "code": "theorem ι_mul_ι (r₁ r₂) : ι (0 : QuadraticForm R R) r₁ * ι (0 : QuadraticForm R R) r₂ = 0", "start": [ 400, 1 ], "end": [ 403, 15 ], "kind": "commanddeclaration" }, { "full_name": "CliffordAlgebraDualNumber.equiv", "code": "protected def equiv : CliffordAlgebra (0 : QuadraticForm R R) ≃ₐ[R] R[ε] :=\n AlgEquiv.ofAlgHom\n (CliffordAlgebra.lift (0 : QuadraticForm R R) ⟨inrHom R _, fun m => inr_mul_inr _ m m⟩)\n (DualNumber.lift ⟨\n (Algebra.ofId _ _, ι (R := R) _ 1),\n ι_mul_ι (1 : R) 1,\n fun _ => (Algebra.commutes _ _).symm⟩)\n (by\n ext : 1\n simp only [QuadraticForm.zero_apply, AlgHom.coe_comp, Function.comp_apply, lift_apply_eps,\n AlgHom.coe_id, id_eq]\n erw [lift_ι_apply]\n simp)\n (by\n ext : 2\n simp only [QuadraticForm.zero_apply, AlgHom.comp_toLinearMap, LinearMap.coe_comp,\n Function.comp_apply, AlgHom.toLinearMap_apply, AlgHom.toLinearMap_id, LinearMap.id_comp]\n erw [lift_ι_apply]\n simp)", "start": [ 406, 1 ], "end": [ 428, 12 ], "kind": "commanddeclaration" }, { "full_name": "CliffordAlgebraDualNumber.equiv_ι", "code": "@[simp]\ntheorem equiv_ι (r : R) : CliffordAlgebraDualNumber.equiv (ι (R := R) _ r) = r • ε", "start": [ 431, 1 ], "end": [ 433, 49 ], "kind": "commanddeclaration" }, { "full_name": "CliffordAlgebraDualNumber.equiv_symm_eps", "code": "@[simp]\ntheorem equiv_symm_eps :\n CliffordAlgebraDualNumber.equiv.symm (eps : R[ε]) = ι (0 : QuadraticForm R R) 1", "start": [ 436, 1 ], "end": [ 440, 86 ], "kind": "commanddeclaration" } ]

[ "Mathlib/MeasureTheory/Function/AEEqFun.lean", ".lake/packages/lean4/src/lean/Init.lean", "Mathlib/Dynamics/Ergodic/Ergodic.lean" ]

[ { "full_name": "QuasiErgodic.ae_eq_const_of_ae_eq_comp_of_ae_range₀", "code": "theorem QuasiErgodic.ae_eq_const_of_ae_eq_comp_of_ae_range₀ [Nonempty X] [MeasurableSpace X]\n {s : Set X} [MeasurableSpace.CountablySeparated s] {f : α → α} {g : α → X}\n (h : QuasiErgodic f μ) (hs : ∀ᵐ x ∂μ, g x ∈ s) (hgm : NullMeasurable g μ)\n (hg_eq : g ∘ f =ᵐ[μ] g) :\n ∃ c, g =ᵐ[μ] const α c", "start": [ 23, 1 ], "end": [ 35, 55 ], "kind": "commanddeclaration" }, { "full_name": "PreErgodic.ae_eq_const_of_ae_eq_comp", "code": "theorem PreErgodic.ae_eq_const_of_ae_eq_comp (h : PreErgodic f μ) (hgm : Measurable g)\n (hg_eq : g ∘ f = g) : ∃ c, g =ᵐ[μ] const α c", "start": [ 42, 1 ], "end": [ 49, 82 ], "kind": "commanddeclaration" }, { "full_name": "QuasiErgodic.ae_eq_const_of_ae_eq_comp₀", "code": "theorem QuasiErgodic.ae_eq_const_of_ae_eq_comp₀ (h : QuasiErgodic f μ) (hgm : NullMeasurable g μ)\n (hg_eq : g ∘ f =ᵐ[μ] g) : ∃ c, g =ᵐ[μ] const α c", "start": [ 51, 1 ], "end": [ 57, 74 ], "kind": "commanddeclaration" }, { "full_name": "Ergodic.ae_eq_const_of_ae_eq_comp₀", "code": "theorem Ergodic.ae_eq_const_of_ae_eq_comp₀ (h : Ergodic f μ) (hgm : NullMeasurable g μ)\n (hg_eq : g ∘ f =ᵐ[μ] g) : ∃ c, g =ᵐ[μ] const α c", "start": [ 59, 1 ], "end": [ 65, 54 ], "kind": "commanddeclaration" }, { "full_name": "QuasiErgodic.ae_eq_const_of_ae_eq_comp_ae", "code": "theorem ae_eq_const_of_ae_eq_comp_ae {g : α → X} (h : QuasiErgodic f μ)\n (hgm : AEStronglyMeasurable g μ) (hg_eq : g ∘ f =ᵐ[μ] g) : ∃ c, g =ᵐ[μ] const α c", "start": [ 73, 1 ], "end": [ 82, 91 ], "kind": "commanddeclaration" }, { "full_name": "QuasiErgodic.eq_const_of_compQuasiMeasurePreserving_eq", "code": "theorem eq_const_of_compQuasiMeasurePreserving_eq (h : QuasiErgodic f μ) {g : α →ₘ[μ] X}\n (hg_eq : g.compQuasiMeasurePreserving f h.1 = g) : ∃ c, g = .const α c", "start": [ 84, 1 ], "end": [ 89, 62 ], "kind": "commanddeclaration" }, { "full_name": "Ergodic.ae_eq_const_of_ae_eq_comp_ae", "code": "theorem ae_eq_const_of_ae_eq_comp_ae {g : α → X} (h : Ergodic f μ) (hgm : AEStronglyMeasurable g μ)\n (hg_eq : g ∘ f =ᵐ[μ] g) : ∃ c, g =ᵐ[μ] const α c", "start": [ 95, 1 ], "end": [ 101, 56 ], "kind": "commanddeclaration" }, { "full_name": "Ergodic.eq_const_of_compMeasurePreserving_eq", "code": "theorem eq_const_of_compMeasurePreserving_eq (h : Ergodic f μ) {g : α →ₘ[μ] X}\n (hg_eq : g.compMeasurePreserving f h.1 = g) : ∃ c, g = .const α c", "start": [ 103, 1 ], "end": [ 105, 65 ], "kind": "commanddeclaration" } ]

[ "Mathlib/Geometry/Manifold/Diffeomorph.lean", ".lake/packages/lean4/src/lean/Init.lean", "Mathlib/Topology/IsLocalHomeomorph.lean" ]

[ { "full_name": "PartialDiffeomorph", "code": "structure PartialDiffeomorph extends PartialEquiv M N where\n open_source : IsOpen source\n open_target : IsOpen target\n contMDiffOn_toFun : ContMDiffOn I J n toFun source\n contMDiffOn_invFun : ContMDiffOn J I n invFun target", "start": [ 70, 1 ], "end": [ 77, 55 ], "kind": "commanddeclaration" }, { "full_name": "Diffeomorph.toPartialDiffeomorph", "code": "def Diffeomorph.toPartialDiffeomorph (h : Diffeomorph I J M N n) :\n PartialDiffeomorph I J M N n where\n toPartialEquiv := h.toHomeomorph.toPartialEquiv\n open_source := isOpen_univ\n open_target := isOpen_univ\n contMDiffOn_toFun x _ := h.contMDiff_toFun x\n contMDiffOn_invFun _ _ := h.symm.contMDiffWithinAt", "start": [ 87, 1 ], "end": [ 94, 53 ], "kind": "commanddeclaration" }, { "full_name": "PartialDiffeomorph.toPartialHomeomorph", "code": "def toPartialHomeomorph : PartialHomeomorph M N where\n toPartialEquiv := Φ.toPartialEquiv\n open_source := Φ.open_source\n open_target := Φ.open_target\n continuousOn_toFun := Φ.contMDiffOn_toFun.continuousOn\n continuousOn_invFun := Φ.contMDiffOn_invFun.continuousOn", "start": [ 100, 1 ], "end": [ 106, 59 ], "kind": "commanddeclaration" }, { "full_name": "PartialDiffeomorph.symm", "code": "protected def symm : PartialDiffeomorph J I N M n where\n toPartialEquiv := Φ.toPartialEquiv.symm\n open_source := Φ.open_target\n open_target := Φ.open_source\n contMDiffOn_toFun := Φ.contMDiffOn_invFun\n contMDiffOn_invFun := Φ.contMDiffOn_toFun", "start": [ 108, 1 ], "end": [ 114, 44 ], "kind": "commanddeclaration" }, { "full_name": "PartialDiffeomorph.contMDiffOn", "code": "protected theorem contMDiffOn : ContMDiffOn I J n Φ Φ.source", "start": [ 116, 1 ], "end": [ 117, 22 ], "kind": "commanddeclaration" }, { "full_name": "PartialDiffeomorph.mdifferentiableOn", "code": "protected theorem mdifferentiableOn : MDifferentiableOn I J Φ Φ.source", "start": [ 119, 1 ], "end": [ 120, 39 ], "kind": "commanddeclaration" }, { "full_name": "PartialDiffeomorph.mdifferentiableAt", "code": "protected theorem mdifferentiableAt {x : M} (hx : x ∈ Φ.source) : MDifferentiableAt I J Φ x", "start": [ 122, 1 ], "end": [ 123, 78 ], "kind": "commanddeclaration" }, { "full_name": "IsLocalDiffeomorphAt", "code": "def IsLocalDiffeomorphAt (f : M → N) (x : M) : Prop :=\n ∃ Φ : PartialDiffeomorph I J M N n, x ∈ Φ.source ∧ EqOn f Φ Φ.source", "start": [ 134, 1 ], "end": [ 137, 71 ], "kind": "commanddeclaration" }, { "full_name": "IsLocalDiffeomorphOn", "code": "def IsLocalDiffeomorphOn (f : M → N) (s : Set M) : Prop :=\n ∀ x : s, IsLocalDiffeomorphAt I J n f x", "start": [ 139, 1 ], "end": [ 142, 42 ], "kind": "commanddeclaration" }, { "full_name": "IsLocalDiffeomorph", "code": "def IsLocalDiffeomorph (f : M → N) : Prop :=\n ∀ x : M, IsLocalDiffeomorphAt I J n f x", "start": [ 144, 1 ], "end": [ 147, 42 ], "kind": "commanddeclaration" }, { "full_name": "isLocalDiffeomorphOn_iff", "code": "lemma isLocalDiffeomorphOn_iff {f : M → N} (s : Set M) :\n IsLocalDiffeomorphOn I J n f s ↔ ∀ x : s, IsLocalDiffeomorphAt I J n f x := by rfl", "start": [ 150, 1 ], "end": [ 151, 87 ], "kind": "lemma" }, { "full_name": "isLocalDiffeomorph_iff", "code": "lemma isLocalDiffeomorph_iff {f : M → N} :\n IsLocalDiffeomorph I J n f ↔ ∀ x : M, IsLocalDiffeomorphAt I J n f x := by rfl", "start": [ 154, 1 ], "end": [ 155, 83 ], "kind": "lemma" }, { "full_name": "isLocalDiffeomorph_iff_isLocalDiffeomorphOn_univ", "code": "theorem isLocalDiffeomorph_iff_isLocalDiffeomorphOn_univ {f : M → N} :\n IsLocalDiffeomorph I J n f ↔ IsLocalDiffeomorphOn I J n f Set.univ", "start": [ 158, 1 ], "end": [ 160, 48 ], "kind": "commanddeclaration" }, { "full_name": "IsLocalDiffeomorph.isLocalDiffeomorphOn", "code": "lemma IsLocalDiffeomorph.isLocalDiffeomorphOn\n {f : M → N} (hf : IsLocalDiffeomorph I J n f) (s : Set M) : IsLocalDiffeomorphOn I J n f s :=\n fun x ↦ hf x", "start": [ 163, 1 ], "end": [ 165, 15 ], "kind": "lemma" }, { "full_name": "IsLocalDiffeomorphAt.contMDiffAt", "code": "lemma IsLocalDiffeomorphAt.contMDiffAt (hf : IsLocalDiffeomorphAt I J n f x) :\n ContMDiffAt I J n f x := by\n choose Φ hx heq using hf\n exact ((Φ.contMDiffOn_toFun).congr heq).contMDiffAt (Φ.open_source.mem_nhds hx)", "start": [ 172, 1 ], "end": [ 177, 82 ], "kind": "lemma" }, { "full_name": "IsLocalDiffeomorphAt.mdifferentiableAt", "code": "lemma IsLocalDiffeomorphAt.mdifferentiableAt (hf : IsLocalDiffeomorphAt I J n f x) (hn : 1 ≤ n) :\n MDifferentiableAt I J f x :=\n hf.contMDiffAt.mdifferentiableAt hn", "start": [ 179, 1 ], "end": [ 182, 38 ], "kind": "lemma" }, { "full_name": "IsLocalDiffeomorphOn.contMDiffOn", "code": "lemma IsLocalDiffeomorphOn.contMDiffOn (hf : IsLocalDiffeomorphOn I J n f s) :\n ContMDiffOn I J n f s :=\n fun x hx ↦ (hf ⟨x, hx⟩).contMDiffAt.contMDiffWithinAt", "start": [ 184, 1 ], "end": [ 187, 56 ], "kind": "lemma" }, { "full_name": "IsLocalDiffeomorphOn.mdifferentiableOn", "code": "lemma IsLocalDiffeomorphOn.mdifferentiableOn (hf : IsLocalDiffeomorphOn I J n f s) (hn : 1 ≤ n) :\n MDifferentiableOn I J f s :=\n hf.contMDiffOn.mdifferentiableOn hn", "start": [ 189, 1 ], "end": [ 192, 38 ], "kind": "lemma" }, { "full_name": "IsLocalDiffeomorph.contMDiff", "code": "lemma IsLocalDiffeomorph.contMDiff (hf : IsLocalDiffeomorph I J n f) : ContMDiff I J n f :=\n fun x ↦ (hf x).contMDiffAt", "start": [ 194, 1 ], "end": [ 196, 29 ], "kind": "lemma" }, { "full_name": "IsLocalDiffeomorph.mdifferentiable", "code": "lemma IsLocalDiffeomorph.mdifferentiable (hf : IsLocalDiffeomorph I J n f) (hn : 1 ≤ n) :\n MDifferentiable I J f :=\n fun x ↦ (hf x).mdifferentiableAt hn", "start": [ 198, 1 ], "end": [ 201, 38 ], "kind": "lemma" }, { "full_name": "Diffeomorph.isLocalDiffeomorph", "code": "lemma Diffeomorph.isLocalDiffeomorph (Φ : M ≃ₘ^n⟮I, J⟯ N) : IsLocalDiffeomorph I J n Φ :=\n fun _x ↦ ⟨Φ.toPartialDiffeomorph, by trivial, eqOn_refl Φ _⟩", "start": [ 203, 1 ], "end": [ 205, 63 ], "kind": "lemma" }, { "full_name": "IsLocalDiffeomorphOn.isLocalHomeomorphOn", "code": "theorem IsLocalDiffeomorphOn.isLocalHomeomorphOn {s : Set M} (hf : IsLocalDiffeomorphOn I J n f s):\n IsLocalHomeomorphOn f s", "start": [ 209, 1 ], "end": [ 215, 37 ], "kind": "commanddeclaration" }, { "full_name": "IsLocalDiffeomorph.isLocalHomeomorph", "code": "theorem IsLocalDiffeomorph.isLocalHomeomorph (hf : IsLocalDiffeomorph I J n f) :\n IsLocalHomeomorph f", "start": [ 217, 1 ], "end": [ 222, 31 ], "kind": "commanddeclaration" }, { "full_name": "IsLocalDiffeomorph.isOpenMap", "code": "lemma IsLocalDiffeomorph.isOpenMap (hf : IsLocalDiffeomorph I J n f) : IsOpenMap f :=\n (hf.isLocalHomeomorph).isOpenMap", "start": [ 224, 1 ], "end": [ 226, 35 ], "kind": "lemma" }, { "full_name": "IsLocalDiffeomorph.isOpen_range", "code": "lemma IsLocalDiffeomorph.isOpen_range (hf : IsLocalDiffeomorph I J n f) : IsOpen (range f) :=\n (hf.isOpenMap).isOpen_range", "start": [ 228, 1 ], "end": [ 230, 30 ], "kind": "lemma" }, { "full_name": "IsLocalDiffeomorph.image", "code": "def IsLocalDiffeomorph.image (hf : IsLocalDiffeomorph I J n f) : Opens N :=\n ⟨range f, hf.isOpen_range⟩", "start": [ 232, 1 ], "end": [ 234, 29 ], "kind": "commanddeclaration" }, { "full_name": "IsLocalDiffeomorph.image_coe", "code": "lemma IsLocalDiffeomorph.image_coe (hf : IsLocalDiffeomorph I J n f) : hf.image.1 = range f :=\n rfl", "start": [ 236, 1 ], "end": [ 237, 6 ], "kind": "lemma" }, { "full_name": "IslocalDiffeomorph.diffeomorph_of_bijective", "code": "noncomputable def IslocalDiffeomorph.diffeomorph_of_bijective\n (hf : IsLocalDiffeomorph I J n f) (hf' : Function.Bijective f) : Diffeomorph I J M N n := by\n choose g hgInverse using (Function.bijective_iff_has_inverse).mp hf'\n choose Φ hyp using (fun x ↦ hf x)\n have aux (x) : EqOn g (Φ x).symm (Φ x).target :=\n eqOn_of_leftInvOn_of_rightInvOn (fun x' _ ↦ hgInverse.1 x')\n (LeftInvOn.congr_left ((Φ x).toPartialHomeomorph).rightInvOn\n ((Φ x).toPartialHomeomorph).symm_mapsTo (hyp x).2.symm)\n (fun _y hy ↦ (Φ x).map_target hy)\n exact {\n toFun := f\n invFun := g\n left_inv := hgInverse.1\n right_inv := hgInverse.2\n contMDiff_toFun := hf.contMDiff\n contMDiff_invFun := by\n intro y\n let x := g y\n obtain ⟨hx, hfx⟩ := hyp x\n apply ((Φ x).symm.contMDiffOn.congr (aux x)).contMDiffAt (((Φ x).open_target).mem_nhds ?_)\n have : y = (Φ x) x := ((hgInverse.2 y).congr (hfx hx)).mp rfl\n exact this ▸ (Φ x).map_source hx }", "start": [ 242, 1 ], "end": [ 269, 41 ], "kind": "commanddeclaration" } ]

[ ".lake/packages/lean4/src/lean/Init.lean", "Mathlib/Analysis/NormedSpace/Basic.lean", "Mathlib/MeasureTheory/Measure/WithDensity.lean" ]

[ { "full_name": "aemeasurable_withDensity_iff", "code": "theorem aemeasurable_withDensity_iff {E : Type*} [NormedAddCommGroup E] [NormedSpace ℝ E]\n [SecondCountableTopology E] [MeasurableSpace E] [BorelSpace E] {f : α → ℝ≥0}\n (hf : Measurable f) {g : α → E} :\n AEMeasurable g (μ.withDensity fun x => (f x : ℝ≥0∞)) ↔\n AEMeasurable (fun x => (f x : ℝ) • g x) μ", "start": [ 20, 1 ], "end": [ 47, 50 ], "kind": "commanddeclaration" } ]

[ ".lake/packages/lean4/src/lean/Init.lean", "Mathlib/Analysis/SpecialFunctions/Arsinh.lean", "Mathlib/Geometry/Euclidean/Inversion/Basic.lean", "Mathlib/Analysis/Complex/UpperHalfPlane/Topology.lean" ]

[ { "full_name": "UpperHalfPlane.dist_eq", "code": "theorem dist_eq (z w : ℍ) : dist z w = 2 * arsinh (dist (z : ℂ) w / (2 * √(z.im * w.im)))", "start": [ 41, 1 ], "end": [ 42, 6 ], "kind": "commanddeclaration" }, { "full_name": "UpperHalfPlane.sinh_half_dist", "code": "theorem sinh_half_dist (z w : ℍ) :\n sinh (dist z w / 2) = dist (z : ℂ) w / (2 * √(z.im * w.im))", "start": [ 45, 1 ], "end": [ 47, 73 ], "kind": "commanddeclaration" }, { "full_name": "UpperHalfPlane.cosh_half_dist", "code": "theorem cosh_half_dist (z w : ℍ) :\n cosh (dist z w / 2) = dist (z : ℂ) (conj (w : ℂ)) / (2 * √(z.im * w.im))", "start": [ 50, 1 ], "end": [ 57, 23 ], "kind": "commanddeclaration" }, { "full_name": "UpperHalfPlane.tanh_half_dist", "code": "theorem tanh_half_dist (z w : ℍ) :\n tanh (dist z w / 2) = dist (z : ℂ) w / dist (z : ℂ) (conj ↑w)", "start": [ 60, 1 ], "end": [ 63, 13 ], "kind": "commanddeclaration" }, { "full_name": "UpperHalfPlane.exp_half_dist", "code": "theorem exp_half_dist (z w : ℍ) :\n exp (dist z w / 2) = (dist (z : ℂ) w + dist (z : ℂ) (conj ↑w)) / (2 * √(z.im * w.im))", "start": [ 66, 1 ], "end": [ 68, 64 ], "kind": "commanddeclaration" }, { "full_name": "UpperHalfPlane.cosh_dist", "code": "theorem cosh_dist (z w : ℍ) : cosh (dist z w) = 1 + dist (z : ℂ) w ^ 2 / (2 * z.im * w.im)", "start": [ 71, 1 ], "end": [ 73, 97 ], "kind": "commanddeclaration" }, { "full_name": "UpperHalfPlane.sinh_half_dist_add_dist", "code": "theorem sinh_half_dist_add_dist (a b c : ℍ) : sinh ((dist a b + dist b c) / 2) =\n (dist (a : ℂ) b * dist (c : ℂ) (conj ↑b) + dist (b : ℂ) c * dist (a : ℂ) (conj ↑b)) /\n (2 * √(a.im * c.im) * dist (b : ℂ) (conj ↑b))", "start": [ 76, 1 ], "end": [ 84, 40 ], "kind": "commanddeclaration" }, { "full_name": "UpperHalfPlane.dist_comm", "code": "protected theorem dist_comm (z w : ℍ) : dist z w = dist w z", "start": [ 87, 1 ], "end": [ 88, 51 ], "kind": "commanddeclaration" }, { "full_name": "UpperHalfPlane.dist_le_iff_le_sinh", "code": "theorem dist_le_iff_le_sinh :\n dist z w ≤ r ↔ dist (z : ℂ) w / (2 * √(z.im * w.im)) ≤ sinh (r / 2)", "start": [ 91, 1 ], "end": [ 93, 75 ], "kind": "commanddeclaration" }, { "full_name": "UpperHalfPlane.dist_eq_iff_eq_sinh", "code": "theorem dist_eq_iff_eq_sinh :\n dist z w = r ↔ dist (z : ℂ) w / (2 * √(z.im * w.im)) = sinh (r / 2)", "start": [ 96, 1 ], "end": [ 98, 68 ], "kind": "commanddeclaration" }, { "full_name": "UpperHalfPlane.dist_eq_iff_eq_sq_sinh", "code": "theorem dist_eq_iff_eq_sq_sinh (hr : 0 ≤ r) :\n dist z w = r ↔ dist (z : ℂ) w ^ 2 / (4 * z.im * w.im) = sinh (r / 2) ^ 2", "start": [ 101, 1 ], "end": [ 105, 23 ], "kind": "commanddeclaration" }, { "full_name": "UpperHalfPlane.dist_triangle", "code": "protected theorem dist_triangle (a b c : ℍ) : dist a c ≤ dist a b + dist b c", "start": [ 108, 1 ], "end": [ 114, 23 ], "kind": "commanddeclaration" }, { "full_name": "UpperHalfPlane.dist_le_dist_coe_div_sqrt", "code": "theorem dist_le_dist_coe_div_sqrt (z w : ℍ) : dist z w ≤ dist (z : ℂ) w / √(z.im * w.im)", "start": [ 117, 1 ], "end": [ 119, 13 ], "kind": "commanddeclaration" }, { "full_name": "UpperHalfPlane.metricSpaceAux", "code": "def metricSpaceAux : MetricSpace ℍ where\n dist := dist\n dist_self z := by rw [dist_eq, dist_self, zero_div, arsinh_zero, mul_zero]\n dist_comm := UpperHalfPlane.dist_comm\n dist_triangle := UpperHalfPlane.dist_triangle\n eq_of_dist_eq_zero {z w} h := by\n simpa [dist_eq, Real.sqrt_eq_zero', (mul_pos z.im_pos w.im_pos).not_le, ext_iff] using h\n edist_dist _ _ := by exact ENNReal.coe_nnreal_eq _", "start": [ 122, 1 ], "end": [ 131, 53 ], "kind": "commanddeclaration" }, { "full_name": "UpperHalfPlane.cosh_dist'", "code": "theorem cosh_dist' (z w : ℍ) :\n Real.cosh (dist z w) = ((z.re - w.re) ^ 2 + z.im ^ 2 + w.im ^ 2) / (2 * z.im * w.im)", "start": [ 136, 1 ], "end": [ 139, 7 ], "kind": "commanddeclaration" }, { "full_name": "UpperHalfPlane.center", "code": "def center (z : ℍ) (r : ℝ) : ℍ :=\n ⟨⟨z.re, z.im * Real.cosh r⟩, by positivity⟩", "start": [ 142, 1 ], "end": [ 144, 46 ], "kind": "commanddeclaration" }, { "full_name": "UpperHalfPlane.center_re", "code": "@[simp]\ntheorem center_re (z r) : (center z r).re = z.re", "start": [ 147, 1 ], "end": [ 149, 6 ], "kind": "commanddeclaration" }, { "full_name": "UpperHalfPlane.center_im", "code": "@[simp]\ntheorem center_im (z r) : (center z r).im = z.im * Real.cosh r", "start": [ 152, 1 ], "end": [ 154, 6 ], "kind": "commanddeclaration" }, { "full_name": "UpperHalfPlane.center_zero", "code": "@[simp]\ntheorem center_zero (z : ℍ) : center z 0 = z", "start": [ 157, 1 ], "end": [ 159, 57 ], "kind": "commanddeclaration" }, { "full_name": "UpperHalfPlane.dist_coe_center_sq", "code": "theorem dist_coe_center_sq (z w : ℍ) (r : ℝ) : dist (z : ℂ) (w.center r) ^ 2 =\n 2 * z.im * w.im * (Real.cosh (dist z w) - Real.cosh r) + (w.im * Real.sinh r) ^ 2", "start": [ 162, 1 ], "end": [ 168, 7 ], "kind": "commanddeclaration" }, { "full_name": "UpperHalfPlane.dist_coe_center", "code": "theorem dist_coe_center (z w : ℍ) (r : ℝ) : dist (z : ℂ) (w.center r) =\n √(2 * z.im * w.im * (Real.cosh (dist z w) - Real.cosh r) + (w.im * Real.sinh r) ^ 2)", "start": [ 171, 1 ], "end": [ 173, 49 ], "kind": "commanddeclaration" }, { "full_name": "UpperHalfPlane.cmp_dist_eq_cmp_dist_coe_center", "code": "theorem cmp_dist_eq_cmp_dist_coe_center (z w : ℍ) (r : ℝ) :\n cmp (dist z w) r = cmp (dist (z : ℂ) (w.center r)) (w.im * Real.sinh r)", "start": [ 176, 1 ], "end": [ 187, 85 ], "kind": "commanddeclaration" }, { "full_name": "UpperHalfPlane.dist_eq_iff_dist_coe_center_eq", "code": "theorem dist_eq_iff_dist_coe_center_eq :\n dist z w = r ↔ dist (z : ℂ) (w.center r) = w.im * Real.sinh r", "start": [ 190, 1 ], "end": [ 192, 66 ], "kind": "commanddeclaration" }, { "full_name": "UpperHalfPlane.dist_self_center", "code": "@[simp]\ntheorem dist_self_center (z : ℍ) (r : ℝ) :\n dist (z : ℂ) (z.center r) = z.im * (Real.cosh r - 1)", "start": [ 195, 1 ], "end": [ 199, 91 ], "kind": "commanddeclaration" }, { "full_name": "UpperHalfPlane.dist_center_dist", "code": "@[simp]\ntheorem dist_center_dist (z w : ℍ) :\n dist (z : ℂ) (w.center (dist z w)) = w.im * Real.sinh (dist z w)", "start": [ 202, 1 ], "end": [ 205, 39 ], "kind": "commanddeclaration" }, { "full_name": "UpperHalfPlane.dist_lt_iff_dist_coe_center_lt", "code": "theorem dist_lt_iff_dist_coe_center_lt :\n dist z w < r ↔ dist (z : ℂ) (w.center r) < w.im * Real.sinh r", "start": [ 208, 1 ], "end": [ 210, 66 ], "kind": "commanddeclaration" }, { "full_name": "UpperHalfPlane.lt_dist_iff_lt_dist_coe_center", "code": "theorem lt_dist_iff_lt_dist_coe_center :\n r < dist z w ↔ w.im * Real.sinh r < dist (z : ℂ) (w.center r)", "start": [ 213, 1 ], "end": [ 215, 87 ], "kind": "commanddeclaration" }, { "full_name": "UpperHalfPlane.dist_le_iff_dist_coe_center_le", "code": "theorem dist_le_iff_dist_coe_center_le :\n dist z w ≤ r ↔ dist (z : ℂ) (w.center r) ≤ w.im * Real.sinh r", "start": [ 218, 1 ], "end": [ 220, 66 ], "kind": "commanddeclaration" }, { "full_name": "UpperHalfPlane.le_dist_iff_le_dist_coe_center", "code": "theorem le_dist_iff_le_dist_coe_center :\n r < dist z w ↔ w.im * Real.sinh r < dist (z : ℂ) (w.center r)", "start": [ 223, 1 ], "end": [ 225, 87 ], "kind": "commanddeclaration" }, { "full_name": "UpperHalfPlane.dist_of_re_eq", "code": "nonrec theorem dist_of_re_eq (h : z.re = w.re) : dist z w = dist (log z.im) (log w.im)", "start": [ 228, 1 ], "end": [ 239, 7 ], "kind": "commanddeclaration" }, { "full_name": "UpperHalfPlane.dist_log_im_le", "code": "theorem dist_log_im_le (z w : ℍ) : dist (log z.im) (log w.im) ≤ dist z w", "start": [ 241, 1 ], "end": [ 251, 65 ], "kind": "commanddeclaration" }, { "full_name": "UpperHalfPlane.im_le_im_mul_exp_dist", "code": "theorem im_le_im_mul_exp_dist (z w : ℍ) : z.im ≤ w.im * Real.exp (dist z w)", "start": [ 254, 1 ], "end": [ 256, 51 ], "kind": "commanddeclaration" }, { "full_name": "UpperHalfPlane.im_div_exp_dist_le", "code": "theorem im_div_exp_dist_le (z w : ℍ) : z.im / Real.exp (dist z w) ≤ w.im", "start": [ 259, 1 ], "end": [ 260, 57 ], "kind": "commanddeclaration" }, { "full_name": "UpperHalfPlane.dist_coe_le", "code": "theorem dist_coe_le (z w : ℍ) : dist (z : ℂ) w ≤ w.im * (Real.exp (dist z w) - 1)", "start": [ 263, 1 ], "end": [ 270, 94 ], "kind": "commanddeclaration" }, { "full_name": "UpperHalfPlane.le_dist_coe", "code": "theorem le_dist_coe (z w : ℍ) : w.im * (1 - Real.exp (-dist z w)) ≤ dist (z : ℂ) w", "start": [ 273, 1 ], "end": [ 280, 69 ], "kind": "commanddeclaration" }, { "full_name": "UpperHalfPlane.im_pos_of_dist_center_le", "code": "theorem im_pos_of_dist_center_le {z : ℍ} {r : ℝ} {w : ℂ}\n (h : dist w (center z r) ≤ z.im * Real.sinh r) : 0 < w.im", "start": [ 304, 1 ], "end": [ 310, 89 ], "kind": "commanddeclaration" }, { "full_name": "UpperHalfPlane.image_coe_closedBall", "code": "theorem image_coe_closedBall (z : ℍ) (r : ℝ) :\n ((↑) : ℍ → ℂ) '' closedBall (α := ℍ) z r = closedBall ↑(z.center r) (z.im * Real.sinh r)", "start": [ 313, 1 ], "end": [ 320, 67 ], "kind": "commanddeclaration" }, { "full_name": "UpperHalfPlane.image_coe_ball", "code": "theorem image_coe_ball (z : ℍ) (r : ℝ) :\n ((↑) : ℍ → ℂ) '' ball (α := ℍ) z r = ball ↑(z.center r) (z.im * Real.sinh r)", "start": [ 323, 1 ], "end": [ 330, 67 ], "kind": "commanddeclaration" }, { "full_name": "UpperHalfPlane.image_coe_sphere", "code": "theorem image_coe_sphere (z : ℍ) (r : ℝ) :\n ((↑) : ℍ → ℂ) '' sphere (α := ℍ) z r = sphere ↑(z.center r) (z.im * Real.sinh r)", "start": [ 333, 1 ], "end": [ 340, 67 ], "kind": "commanddeclaration" }, { "full_name": "UpperHalfPlane.isometry_vertical_line", "code": "theorem isometry_vertical_line (a : ℝ) : Isometry fun y => mk ⟨a, exp y⟩ (exp_pos y)", "start": [ 348, 1 ], "end": [ 351, 53 ], "kind": "commanddeclaration" }, { "full_name": "UpperHalfPlane.isometry_real_vadd", "code": "theorem isometry_real_vadd (a : ℝ) : Isometry (a +ᵥ · : ℍ → ℍ)", "start": [ 354, 1 ], "end": [ 355, 92 ], "kind": "commanddeclaration" }, { "full_name": "UpperHalfPlane.isometry_pos_mul", "code": "theorem isometry_pos_mul (a : { x : ℝ // 0 < x }) : Isometry (a • · : ℍ → ℍ)", "start": [ 358, 1 ], "end": [ 363, 63 ], "kind": "commanddeclaration" } ]

[ "Mathlib/RingTheory/Bialgebra/Equiv.lean", ".lake/packages/lean4/src/lean/Init.lean", "Mathlib/Algebra/Category/AlgebraCat/Basic.lean", "Mathlib/Algebra/Category/CoalgebraCat/Basic.lean" ]

[ { "full_name": "BialgebraCat", "code": "structure BialgebraCat extends Bundled Ring.{v} where\n [instBialgebra : Bialgebra R α]", "start": [ 26, 1 ], "end": [ 28, 34 ], "kind": "commanddeclaration" }, { "full_name": "BialgebraCat.of", "code": "@[simps]\ndef of (X : Type v) [Ring X] [Bialgebra R X] :\n BialgebraCat R where\n instBialgebra := (inferInstance : Bialgebra R X)", "start": [ 43, 1 ], "end": [ 47, 51 ], "kind": "commanddeclaration" }, { "full_name": "BialgebraCat.of_comul", "code": "@[simp]\nlemma of_comul {X : Type v} [Ring X] [Bialgebra R X] :\n Coalgebra.comul (A := of R X) = Coalgebra.comul (R := R) (A := X) := rfl", "start": [ 51, 1 ], "end": [ 53, 77 ], "kind": "lemma" }, { "full_name": "BialgebraCat.of_counit", "code": "@[simp]\nlemma of_counit {X : Type v} [Ring X] [Bialgebra R X] :\n Coalgebra.counit (A := of R X) = Coalgebra.counit (R := R) (A := X) := rfl", "start": [ 55, 1 ], "end": [ 57, 79 ], "kind": "lemma" }, { "full_name": "BialgebraCat.Hom", "code": "@[ext]\nstructure Hom (V W : BialgebraCat.{v} R) :=\n \n toBialgHom : V →ₐc[R] W", "start": [ 59, 1 ], "end": [ 64, 26 ], "kind": "commanddeclaration" }, { "full_name": "BialgebraCat.Hom.toBialgHom_injective", "code": "lemma Hom.toBialgHom_injective (V W : BialgebraCat.{v} R) :\n Function.Injective (Hom.toBialgHom : Hom V W → _) :=\n fun ⟨f⟩ ⟨g⟩ _ => by congr", "start": [ 66, 1 ], "end": [ 68, 28 ], "kind": "lemma" }, { "full_name": "BialgebraCat.category", "code": "instance category : Category (BialgebraCat.{v} R) where\n Hom X Y := Hom X Y\n id X := ⟨BialgHom.id R X⟩\n comp f g := ⟨BialgHom.comp g.toBialgHom f.toBialgHom⟩", "start": [ 70, 1 ], "end": [ 73, 56 ], "kind": "commanddeclaration" }, { "full_name": "BialgebraCat.hom_ext", "code": "@[ext]\nlemma hom_ext {X Y : BialgebraCat.{v} R} (f g : X ⟶ Y) (h : f.toBialgHom = g.toBialgHom) :\n f = g :=\n Hom.ext _ _ h", "start": [ 76, 1 ], "end": [ 79, 16 ], "kind": "lemma" }, { "full_name": "BialgebraCat.ofHom", "code": "abbrev ofHom {X Y : Type v} [Ring X] [Ring Y]\n [Bialgebra R X] [Bialgebra R Y] (f : X →ₐc[R] Y) :\n of R X ⟶ of R Y :=\n ⟨f⟩", "start": [ 81, 1 ], "end": [ 85, 6 ], "kind": "commanddeclaration" }, { "full_name": "BialgebraCat.toBialgHom_comp", "code": "@[simp] theorem toBialgHom_comp {X Y Z : BialgebraCat.{v} R} (f : X ⟶ Y) (g : Y ⟶ Z) :\n (f ≫ g).toBialgHom = g.toBialgHom.comp f.toBialgHom", "start": [ 87, 1 ], "end": [ 89, 6 ], "kind": "commanddeclaration" }, { "full_name": "BialgebraCat.toBialgHom_id", "code": "@[simp] theorem toBialgHom_id {M : BialgebraCat.{v} R} :\n Hom.toBialgHom (𝟙 M) = BialgHom.id _ _", "start": [ 91, 1 ], "end": [ 93, 6 ], "kind": "commanddeclaration" }, { "full_name": "BialgebraCat.concreteCategory", "code": "instance concreteCategory : ConcreteCategory.{v} (BialgebraCat.{v} R) where\n forget :=\n { obj := fun M => M\n map := fun f => f.toBialgHom }\n forget_faithful :=\n { map_injective := fun {M N} => DFunLike.coe_injective.comp <| Hom.toBialgHom_injective _ _ }", "start": [ 95, 1 ], "end": [ 100, 98 ], "kind": "commanddeclaration" }, { "full_name": "BialgebraCat.hasForgetToAlgebra", "code": "instance hasForgetToAlgebra : HasForget₂ (BialgebraCat R) (AlgebraCat R) where\n forget₂ :=\n { obj := fun X => AlgebraCat.of R X\n map := fun {X Y} f => (f.toBialgHom : X →ₐ[R] Y) }", "start": [ 102, 1 ], "end": [ 105, 57 ], "kind": "commanddeclaration" }, { "full_name": "BialgebraCat.forget₂_algebra_obj", "code": "@[simp]\ntheorem forget₂_algebra_obj (X : BialgebraCat R) :\n (forget₂ (BialgebraCat R) (AlgebraCat R)).obj X = AlgebraCat.of R X", "start": [ 107, 1 ], "end": [ 110, 6 ], "kind": "commanddeclaration" }, { "full_name": "BialgebraCat.forget₂_algebra_map", "code": "@[simp]\ntheorem forget₂_algebra_map (X Y : BialgebraCat R) (f : X ⟶ Y) :\n (forget₂ (BialgebraCat R) (AlgebraCat R)).map f = (f.toBialgHom : X →ₐ[R] Y)", "start": [ 112, 1 ], "end": [ 115, 6 ], "kind": "commanddeclaration" }, { "full_name": "BialgebraCat.hasForgetToCoalgebra", "code": "instance hasForgetToCoalgebra : HasForget₂ (BialgebraCat R) (CoalgebraCat R) where\n forget₂ :=\n { obj := fun X => CoalgebraCat.of R X\n map := fun {X Y} f => CoalgebraCat.ofHom f.toBialgHom }", "start": [ 117, 1 ], "end": [ 120, 62 ], "kind": "commanddeclaration" }, { "full_name": "BialgebraCat.forget₂_coalgebra_obj", "code": "@[simp]\ntheorem forget₂_coalgebra_obj (X : BialgebraCat R) :\n (forget₂ (BialgebraCat R) (CoalgebraCat R)).obj X = CoalgebraCat.of R X", "start": [ 122, 1 ], "end": [ 125, 6 ], "kind": "commanddeclaration" }, { "full_name": "BialgebraCat.forget₂_coalgebra_map", "code": "@[simp]\ntheorem forget₂_coalgebra_map (X Y : BialgebraCat R) (f : X ⟶ Y) :\n (forget₂ (BialgebraCat R) (CoalgebraCat R)).map f = CoalgebraCat.ofHom f.toBialgHom", "start": [ 127, 1 ], "end": [ 130, 6 ], "kind": "commanddeclaration" }, { "full_name": "BialgEquiv.toBialgebraCatIso", "code": "@[simps]\ndef toBialgebraCatIso (e : X ≃ₐc[R] Y) : BialgebraCat.of R X ≅ BialgebraCat.of R Y where\n hom := BialgebraCat.ofHom e\n inv := BialgebraCat.ofHom e.symm\n hom_inv_id := Hom.ext _ _ <| DFunLike.ext _ _ e.left_inv\n inv_hom_id := Hom.ext _ _ <| DFunLike.ext _ _ e.right_inv", "start": [ 142, 1 ], "end": [ 149, 60 ], "kind": "commanddeclaration" }, { "full_name": "BialgEquiv.toBialgebraCatIso_refl", "code": "@[simp] theorem toBialgebraCatIso_refl : toBialgebraCatIso (BialgEquiv.refl R X) = .refl _", "start": [ 151, 1 ], "end": [ 152, 6 ], "kind": "commanddeclaration" }, { "full_name": "BialgEquiv.toBialgebraCatIso_symm", "code": "@[simp] theorem toBialgebraCatIso_symm (e : X ≃ₐc[R] Y) :\n toBialgebraCatIso e.symm = (toBialgebraCatIso e).symm", "start": [ 154, 1 ], "end": [ 156, 6 ], "kind": "commanddeclaration" }, { "full_name": "BialgEquiv.toBialgebraCatIso_trans", "code": "@[simp] theorem toBialgebraCatIso_trans (e : X ≃ₐc[R] Y) (f : Y ≃ₐc[R] Z) :\n toBialgebraCatIso (e.trans f) = toBialgebraCatIso e ≪≫ toBialgebraCatIso f", "start": [ 158, 1 ], "end": [ 160, 6 ], "kind": "commanddeclaration" }, { "full_name": "CategoryTheory.Iso.toBialgEquiv", "code": "def toBialgEquiv (i : X ≅ Y) : X ≃ₐc[R] Y :=\n { i.hom.toBialgHom with\n invFun := i.inv.toBialgHom\n left_inv := fun x => BialgHom.congr_fun (congr_arg BialgebraCat.Hom.toBialgHom i.3) x\n right_inv := fun x => BialgHom.congr_fun (congr_arg BialgebraCat.Hom.toBialgHom i.4) x }", "start": [ 170, 1 ], "end": [ 176, 93 ], "kind": "commanddeclaration" }, { "full_name": "CategoryTheory.Iso.toBialgEquiv_toBialgHom", "code": "@[simp] theorem toBialgEquiv_toBialgHom (i : X ≅ Y) :\n (i.toBialgEquiv : X →ₐc[R] Y) = i.hom.1", "start": [ 178, 1 ], "end": [ 179, 51 ], "kind": "commanddeclaration" }, { "full_name": "CategoryTheory.Iso.toBialgEquiv_refl", "code": "@[simp] theorem toBialgEquiv_refl : toBialgEquiv (.refl X) = .refl _ _", "start": [ 181, 1 ], "end": [ 182, 6 ], "kind": "commanddeclaration" }, { "full_name": "CategoryTheory.Iso.toBialgEquiv_symm", "code": "@[simp] theorem toBialgEquiv_symm (e : X ≅ Y) :\n toBialgEquiv e.symm = (toBialgEquiv e).symm", "start": [ 184, 1 ], "end": [ 186, 6 ], "kind": "commanddeclaration" }, { "full_name": "CategoryTheory.Iso.toBialgEquiv_trans", "code": "@[simp] theorem toBialgEquiv_trans (e : X ≅ Y) (f : Y ≅ Z) :\n toBialgEquiv (e ≪≫ f) = e.toBialgEquiv.trans f.toBialgEquiv", "start": [ 188, 1 ], "end": [ 190, 6 ], "kind": "commanddeclaration" }, { "full_name": "BialgebraCat.forget_reflects_isos", "code": "instance BialgebraCat.forget_reflects_isos :\n (forget (BialgebraCat.{v} R)).ReflectsIsomorphisms where\n reflects {X Y} f _ := by\n let i := asIso ((forget (BialgebraCat.{v} R)).map f)\n let e : X ≃ₐc[R] Y := { f.toBialgHom, i.toEquiv with }\n exact ⟨e.toBialgebraCatIso.isIso_hom.1⟩", "start": [ 194, 1 ], "end": [ 199, 44 ], "kind": "commanddeclaration" } ]

[ ".lake/packages/lean4/src/lean/Init.lean", "Mathlib/GroupTheory/Congruence/BigOperators.lean", "Mathlib/RingTheory/Congruence/Basic.lean" ]

[ { "full_name": "RingCon.listSum", "code": "protected lemma listSum {ι S : Type*} [AddMonoid S] [Mul S]\n (t : RingCon S) (l : List ι) {f g : ι → S} (h : ∀ i ∈ l, t (f i) (g i)) :\n t (l.map f).sum (l.map g).sum :=\n t.toAddCon.list_sum h", "start": [ 18, 1 ], "end": [ 22, 24 ], "kind": "lemma" }, { "full_name": "RingCon.multisetSum", "code": "protected lemma multisetSum {ι S : Type*} [AddCommMonoid S] [Mul S] (t : RingCon S)\n (s : Multiset ι) {f g : ι → S} (h : ∀ i ∈ s, t (f i) (g i)) :\n t (s.map f).sum (s.map g).sum :=\n t.toAddCon.multiset_sum h", "start": [ 24, 1 ], "end": [ 28, 28 ], "kind": "lemma" }, { "full_name": "RingCon.finsetSum", "code": "protected lemma finsetSum {ι S : Type*} [AddCommMonoid S] [Mul S] (t : RingCon S) (s : Finset ι)\n {f g : ι → S} (h : ∀ i ∈ s, t (f i) (g i)) :\n t (s.sum f) (s.sum g) :=\n t.toAddCon.finset_sum s h", "start": [ 30, 1 ], "end": [ 34, 28 ], "kind": "lemma" } ]

[ "Mathlib/LinearAlgebra/Basis/VectorSpace.lean", "Mathlib/RingTheory/SimpleModule.lean", ".lake/packages/lean4/src/lean/Init.lean", "Mathlib/Algebra/MonoidAlgebra/Basic.lean" ]

[ { "full_name": "LinearMap.conjugate", "code": "def conjugate (g : G) : W →ₗ[k] V :=\n .comp (.comp (GroupSMul.linearMap k V g⁻¹) π) (GroupSMul.linearMap k W g)", "start": [ 68, 1 ], "end": [ 70, 76 ], "kind": "commanddeclaration" }, { "full_name": "LinearMap.conjugate_apply", "code": "theorem conjugate_apply (g : G) (v : W) :\n π.conjugate g v = MonoidAlgebra.single g⁻¹ (1 : k) • π (MonoidAlgebra.single g (1 : k) • v)", "start": [ 73, 1 ], "end": [ 75, 6 ], "kind": "commanddeclaration" }, { "full_name": "LinearMap.conjugate_i", "code": "theorem conjugate_i (g : G) (v : V) : (conjugate π g : W → V) (i v) = v", "start": [ 81, 1 ], "end": [ 83, 25 ], "kind": "commanddeclaration" }, { "full_name": "LinearMap.sumOfConjugates", "code": "def sumOfConjugates : W →ₗ[k] V :=\n ∑ g : G, π.conjugate g", "start": [ 90, 1 ], "end": [ 95, 25 ], "kind": "commanddeclaration" }, { "full_name": "LinearMap.sumOfConjugates_apply", "code": "lemma sumOfConjugates_apply (v : W) : π.sumOfConjugates G v = ∑ g : G, π.conjugate g v :=\n LinearMap.sum_apply _ _ _", "start": [ 98, 1 ], "end": [ 99, 28 ], "kind": "lemma" }, { "full_name": "LinearMap.sumOfConjugatesEquivariant", "code": "def sumOfConjugatesEquivariant : W →ₗ[MonoidAlgebra k G] V :=\n MonoidAlgebra.equivariantOfLinearOfComm (π.sumOfConjugates G) fun g v => by\n simp only [sumOfConjugates_apply, Finset.smul_sum, conjugate_apply]\n refine Fintype.sum_bijective (· * g) (Group.mulRight_bijective g) _ _ fun i ↦ ?_\n simp only [smul_smul, single_mul_single, mul_inv_rev, mul_inv_cancel_left, one_mul]", "start": [ 101, 1 ], "end": [ 107, 88 ], "kind": "commanddeclaration" }, { "full_name": "LinearMap.sumOfConjugatesEquivariant_apply", "code": "theorem sumOfConjugatesEquivariant_apply (v : W) :\n π.sumOfConjugatesEquivariant G v = ∑ g : G, π.conjugate g v", "start": [ 110, 1 ], "end": [ 112, 30 ], "kind": "commanddeclaration" }, { "full_name": "LinearMap.equivariantProjection", "code": "def equivariantProjection : W →ₗ[MonoidAlgebra k G] V :=\n ⅟(Fintype.card G : k) • π.sumOfConjugatesEquivariant G", "start": [ 118, 1 ], "end": [ 122, 57 ], "kind": "commanddeclaration" }, { "full_name": "LinearMap.equivariantProjection_apply", "code": "theorem equivariantProjection_apply (v : W) :\n π.equivariantProjection G v = ⅟(Fintype.card G : k) • ∑ g : G, π.conjugate g v", "start": [ 125, 1 ], "end": [ 127, 82 ], "kind": "commanddeclaration" }, { "full_name": "LinearMap.equivariantProjection_condition", "code": "theorem equivariantProjection_condition (v : V) : (π.equivariantProjection G) (i v) = v", "start": [ 129, 1 ], "end": [ 133, 41 ], "kind": "commanddeclaration" }, { "full_name": "MonoidAlgebra.exists_leftInverse_of_injective", "code": "theorem exists_leftInverse_of_injective (f : V →ₗ[MonoidAlgebra k G] W)\n (hf : LinearMap.ker f = ⊥) :\n ∃ g : W →ₗ[MonoidAlgebra k G] V, g.comp f = LinearMap.id", "start": [ 150, 1 ], "end": [ 161, 71 ], "kind": "commanddeclaration" }, { "full_name": "MonoidAlgebra.Submodule.exists_isCompl", "code": "theorem exists_isCompl (p : Submodule (MonoidAlgebra k G) V) :\n ∃ q : Submodule (MonoidAlgebra k G) V, IsCompl p q", "start": [ 166, 1 ], "end": [ 169, 78 ], "kind": "commanddeclaration" }, { "full_name": "MonoidAlgebra.Submodule.complementedLattice", "code": "instance complementedLattice : ComplementedLattice (Submodule (MonoidAlgebra k G) V) :=\n ⟨exists_isCompl⟩", "start": [ 172, 1 ], "end": [ 175, 19 ], "kind": "commanddeclaration" } ]

[ ".lake/packages/lean4/src/lean/Init.lean", "Mathlib/Analysis/Convex/Normed.lean", "Mathlib/Analysis/Convex/Gauge.lean" ]

[ { "full_name": "gaugeRescale", "code": "def gaugeRescale (s t : Set E) (x : E) : E := (gauge s x / gauge t x) • x", "start": [ 27, 1 ], "end": [ 33, 74 ], "kind": "commanddeclaration" }, { "full_name": "gaugeRescale_def", "code": "theorem gaugeRescale_def (s t : Set E) (x : E) :\n gaugeRescale s t x = (gauge s x / gauge t x) • x", "start": [ 35, 1 ], "end": [ 37, 6 ], "kind": "commanddeclaration" }, { "full_name": "gaugeRescale_zero", "code": "@[simp] theorem gaugeRescale_zero (s t : Set E) : gaugeRescale s t 0 = 0", "start": [ 39, 1 ], "end": [ 39, 88 ], "kind": "commanddeclaration" }, { "full_name": "gaugeRescale_smul", "code": "theorem gaugeRescale_smul (s t : Set E) {c : ℝ} (hc : 0 ≤ c) (x : E) :\n gaugeRescale s t (c • x) = c • gaugeRescale s t x", "start": [ 41, 1 ], "end": [ 44, 59 ], "kind": "commanddeclaration" }, { "full_name": "gaugeRescale_self_apply", "code": "theorem gaugeRescale_self_apply {s : Set E} (hsa : Absorbent ℝ s) (hsb : IsVonNBounded ℝ s)\n (x : E) : gaugeRescale s s x = x", "start": [ 48, 1 ], "end": [ 52, 39 ], "kind": "commanddeclaration" }, { "full_name": "gaugeRescale_self", "code": "theorem gaugeRescale_self {s : Set E} (hsa : Absorbent ℝ s) (hsb : IsVonNBounded ℝ s) :\n gaugeRescale s s = id", "start": [ 54, 1 ], "end": [ 56, 44 ], "kind": "commanddeclaration" }, { "full_name": "gauge_gaugeRescale'", "code": "theorem gauge_gaugeRescale' (s : Set E) {t : Set E} {x : E} (hx : gauge t x ≠ 0) :\n gauge t (gaugeRescale s t x) = gauge s x", "start": [ 58, 1 ], "end": [ 61, 39 ], "kind": "commanddeclaration" }, { "full_name": "gauge_gaugeRescale", "code": "theorem gauge_gaugeRescale (s : Set E) {t : Set E} (hta : Absorbent ℝ t) (htb : IsVonNBounded ℝ t)\n (x : E) : gauge t (gaugeRescale s t x) = gauge s x", "start": [ 63, 1 ], "end": [ 67, 63 ], "kind": "commanddeclaration" }, { "full_name": "gauge_gaugeRescale_le", "code": "theorem gauge_gaugeRescale_le (s t : Set E) (x : E) :\n gauge t (gaugeRescale s t x) ≤ gauge s x", "start": [ 69, 1 ], "end": [ 73, 40 ], "kind": "commanddeclaration" }, { "full_name": "gaugeRescale_gaugeRescale", "code": "theorem gaugeRescale_gaugeRescale {s t u : Set E} (hta : Absorbent ℝ t) (htb : IsVonNBounded ℝ t)\n (x : E) : gaugeRescale t u (gaugeRescale s t x) = gaugeRescale s u x", "start": [ 75, 1 ], "end": [ 80, 88 ], "kind": "commanddeclaration" }, { "full_name": "gaugeRescaleEquiv", "code": "def gaugeRescaleEquiv (s t : Set E) (hsa : Absorbent ℝ s) (hsb : IsVonNBounded ℝ s)\n (hta : Absorbent ℝ t) (htb : IsVonNBounded ℝ t) : E ≃ E where\n toFun := gaugeRescale s t\n invFun := gaugeRescale t s\n left_inv x := by rw [gaugeRescale_gaugeRescale, gaugeRescale_self_apply] <;> assumption\n right_inv x := by rw [gaugeRescale_gaugeRescale, gaugeRescale_self_apply] <;> assumption", "start": [ 82, 1 ], "end": [ 88, 91 ], "kind": "commanddeclaration" }, { "full_name": "mapsTo_gaugeRescale_interior", "code": "theorem mapsTo_gaugeRescale_interior (h₀ : t ∈ 𝓝 0) (hc : Convex ℝ t) :\n MapsTo (gaugeRescale s t) (interior s) (interior t)", "start": [ 92, 1 ], "end": [ 95, 83 ], "kind": "commanddeclaration" }, { "full_name": "mapsTo_gaugeRescale_closure", "code": "theorem mapsTo_gaugeRescale_closure {s t : Set E} (hsc : Convex ℝ s) (hs₀ : s ∈ 𝓝 0)\n (htc : Convex ℝ t) (ht₀ : 0 ∈ t) (hta : Absorbent ℝ t) :\n MapsTo (gaugeRescale s t) (closure s) (closure t)", "start": [ 97, 1 ], "end": [ 101, 48 ], "kind": "commanddeclaration" }, { "full_name": "continuous_gaugeRescale", "code": "theorem continuous_gaugeRescale {s t : Set E} (hs : Convex ℝ s) (hs₀ : s ∈ 𝓝 0)\n (ht : Convex ℝ t) (ht₀ : t ∈ 𝓝 0) (htb : IsVonNBounded ℝ t) :\n Continuous (gaugeRescale s t)", "start": [ 103, 1 ], "end": [ 114, 59 ], "kind": "commanddeclaration" }, { "full_name": "gaugeRescaleHomeomorph", "code": "def gaugeRescaleHomeomorph (s t : Set E)\n (hsc : Convex ℝ s) (hs₀ : s ∈ 𝓝 0) (hsb : IsVonNBounded ℝ s)\n (htc : Convex ℝ t) (ht₀ : t ∈ 𝓝 0) (htb : IsVonNBounded ℝ t) : E ≃ₜ E where\n toEquiv := gaugeRescaleEquiv s t (absorbent_nhds_zero hs₀) hsb (absorbent_nhds_zero ht₀) htb\n continuous_toFun := by apply continuous_gaugeRescale <;> assumption\n continuous_invFun := by apply continuous_gaugeRescale <;> assumption", "start": [ 116, 1 ], "end": [ 122, 71 ], "kind": "commanddeclaration" }, { "full_name": "image_gaugeRescaleHomeomorph_interior", "code": "theorem image_gaugeRescaleHomeomorph_interior {s t : Set E}\n (hsc : Convex ℝ s) (hs₀ : s ∈ 𝓝 0) (hsb : IsVonNBounded ℝ s)\n (htc : Convex ℝ t) (ht₀ : t ∈ 𝓝 0) (htb : IsVonNBounded ℝ t) :\n gaugeRescaleHomeomorph s t hsc hs₀ hsb htc ht₀ htb '' interior s = interior t", "start": [ 124, 1 ], "end": [ 130, 62 ], "kind": "commanddeclaration" }, { "full_name": "image_gaugeRescaleHomeomorph_closure", "code": "theorem image_gaugeRescaleHomeomorph_closure {s t : Set E}\n (hsc : Convex ℝ s) (hs₀ : s ∈ 𝓝 0) (hsb : IsVonNBounded ℝ s)\n (htc : Convex ℝ t) (ht₀ : t ∈ 𝓝 0) (htb : IsVonNBounded ℝ t) :\n gaugeRescaleHomeomorph s t hsc hs₀ hsb htc ht₀ htb '' closure s = closure t", "start": [ 132, 1 ], "end": [ 140, 66 ], "kind": "commanddeclaration" }, { "full_name": "exists_homeomorph_image_eq", "code": "theorem exists_homeomorph_image_eq {s t : Set E}\n (hsc : Convex ℝ s) (hsne : (interior s).Nonempty) (hsb : IsVonNBounded ℝ s)\n (hst : Convex ℝ t) (htne : (interior t).Nonempty) (htb : IsVonNBounded ℝ t) :\n ∃ e : E ≃ₜ E, e '' interior s = interior t ∧ e '' closure s = closure t ∧\n e '' frontier s = frontier t", "start": [ 142, 1 ], "end": [ 170, 89 ], "kind": "commanddeclaration" }, { "full_name": "exists_homeomorph_image_interior_closure_frontier_eq_unitBall", "code": "theorem exists_homeomorph_image_interior_closure_frontier_eq_unitBall {s : Set E}\n (hc : Convex ℝ s) (hne : (interior s).Nonempty) (hb : IsBounded s) :\n ∃ h : E ≃ₜ E, h '' interior s = ball 0 1 ∧ h '' closure s = closedBall 0 1 ∧\n h '' frontier s = sphere 0 1", "start": [ 176, 1 ], "end": [ 186, 97 ], "kind": "commanddeclaration" } ]

[ ".lake/packages/lean4/src/lean/Init.lean", "Mathlib/CategoryTheory/EffectiveEpi/Comp.lean", "Mathlib/Topology/Category/TopCat/Limits/Pullbacks.lean", "Mathlib/CategoryTheory/EffectiveEpi/RegularEpi.lean" ]

[ { "full_name": "TopCat.effectiveEpiStructOfQuotientMap", "code": "noncomputable\ndef effectiveEpiStructOfQuotientMap {B X : TopCat.{u}} (π : X ⟶ B) (hπ : QuotientMap π) :\n EffectiveEpiStruct π where\n \n desc e h := hπ.lift e fun a b hab ↦\n DFunLike.congr_fun (h ⟨fun _ ↦ a, continuous_const⟩ ⟨fun _ ↦ b, continuous_const⟩\n (by ext; exact hab)) a\n \n fac e h := (hπ.lift_comp e\n fun a b hab ↦ DFunLike.congr_fun (h ⟨fun _ ↦ a, continuous_const⟩ ⟨fun _ ↦ b, continuous_const⟩\n (by ext; exact hab)) a)\n \n uniq e h g hm := by\n suffices g = hπ.liftEquiv ⟨e,\n fun a b hab ↦ DFunLike.congr_fun\n (h ⟨fun _ ↦ a, continuous_const⟩ ⟨fun _ ↦ b, continuous_const⟩ (by ext; exact hab))\n a⟩ by assumption\n rw [← Equiv.symm_apply_eq hπ.liftEquiv]\n ext\n simp only [QuotientMap.liftEquiv_symm_apply_coe, ContinuousMap.comp_apply, ← hm]\n rfl", "start": [ 24, 1 ], "end": [ 50, 8 ], "kind": "commanddeclaration" }, { "full_name": "TopCat.effectiveEpi_iff_quotientMap", "code": "theorem effectiveEpi_iff_quotientMap {B X : TopCat.{u}} (π : X ⟶ B) :\n EffectiveEpi π ↔ QuotientMap π", "start": [ 52, 1 ], "end": [ 75, 8 ], "kind": "commanddeclaration" } ]

[ "Mathlib/RingTheory/Localization/Basic.lean", "Mathlib/Algebra/Category/Ring/Instances.lean", ".lake/packages/lean4/src/lean/Init.lean", "Mathlib/Algebra/Category/Ring/FilteredColimits.lean", "Mathlib/Topology/Sheaves/Stalks.lean" ]

[ { "full_name": "TopCat.Presheaf.SubmonoidPresheaf", "code": "structure SubmonoidPresheaf [∀ X : C, MulOneClass X] [∀ X Y : C, MonoidHomClass (X ⟶ Y) X Y]\n (F : X.Presheaf C) where\n obj : ∀ U, Submonoid (F.obj U)\n map : ∀ {U V : (Opens X)ᵒᵖ} (i : U ⟶ V), obj U ≤ (obj V).comap (F.map i)", "start": [ 41, 1 ], "end": [ 45, 75 ], "kind": "commanddeclaration" }, { "full_name": "TopCat.Presheaf.SubmonoidPresheaf.localizationPresheaf", "code": "protected noncomputable def SubmonoidPresheaf.localizationPresheaf : X.Presheaf CommRingCat where\n obj U := CommRingCat.of <| Localization (G.obj U)\n map {U V} i := CommRingCat.ofHom <| IsLocalization.map _ (F.map i) (G.map i)\n map_id U := by\n simp_rw [F.map_id]\n ext x\n exact IsLocalization.map_id (M := G.obj U) (S := Localization (G.obj U)) x\n map_comp {U V W} i j := by\n delta CommRingCat.ofHom CommRingCat.of Bundled.of\n simp_rw [F.map_comp, CommRingCat.comp_eq_ring_hom_comp]\n rw [IsLocalization.map_comp_map]", "start": [ 50, 1 ], "end": [ 62, 37 ], "kind": "commanddeclaration" }, { "full_name": "TopCat.Presheaf.SubmonoidPresheaf.toLocalizationPresheaf", "code": "@[simps app]\ndef SubmonoidPresheaf.toLocalizationPresheaf : F ⟶ G.localizationPresheaf where\n app U := CommRingCat.ofHom <| algebraMap (F.obj U) (Localization <| G.obj U)\n naturality {_ _} i := (IsLocalization.map_comp (G.map i)).symm", "start": [ 73, 1 ], "end": [ 77, 65 ], "kind": "commanddeclaration" }, { "full_name": "TopCat.Presheaf.epi_toLocalizationPresheaf", "code": "instance epi_toLocalizationPresheaf : Epi G.toLocalizationPresheaf :=\n @NatTrans.epi_of_epi_app _ _ _ _ _ _ G.toLocalizationPresheaf fun U => Localization.epi' (G.obj U)", "start": [ 80, 1 ], "end": [ 81, 101 ], "kind": "commanddeclaration" }, { "full_name": "TopCat.Presheaf.submonoidPresheafOfStalk", "code": "@[simps]\nnoncomputable def submonoidPresheafOfStalk (S : ∀ x : X, Submonoid (F.stalk x)) :\n F.SubmonoidPresheaf where\n obj U := ⨅ x : U.unop, Submonoid.comap (F.germ x) (S x)\n map {U V} i := by\n intro s hs\n simp only [Submonoid.mem_comap, Submonoid.mem_iInf] at hs ⊢\n intro x\n change (F.map i.unop.op ≫ F.germ x) s ∈ _\n rw [F.germ_res]\n exact hs _", "start": [ 85, 1 ], "end": [ 97, 15 ], "kind": "commanddeclaration" }, { "full_name": "TopCat.Presheaf.totalQuotientPresheaf", "code": "noncomputable def totalQuotientPresheaf : X.Presheaf CommRingCat.{w} :=\n (F.submonoidPresheafOfStalk fun x => (F.stalk x)⁰).localizationPresheaf", "start": [ 103, 1 ], "end": [ 105, 74 ], "kind": "commanddeclaration" }, { "full_name": "TopCat.Presheaf.toTotalQuotientPresheaf", "code": "noncomputable def toTotalQuotientPresheaf : F ⟶ F.totalQuotientPresheaf :=\n SubmonoidPresheaf.toLocalizationPresheaf _", "start": [ 108, 1 ], "end": [ 110, 45 ], "kind": "commanddeclaration" } ]

[ "Mathlib/ModelTheory/Semantics.lean", ".lake/packages/lean4/src/lean/Init.lean" ]

[ { "full_name": "FirstOrder.Language.order", "code": "protected def order : Language :=\n Language.mk₂ Empty Empty Empty Empty Unit", "start": [ 45, 1 ], "end": [ 47, 44 ], "kind": "commanddeclaration" }, { "full_name": "FirstOrder.Language.orderStructure", "code": "instance orderStructure [LE M] : Language.order.Structure M :=\n Structure.mk₂ Empty.elim Empty.elim Empty.elim Empty.elim fun _ => (· ≤ ·)", "start": [ 50, 1 ], "end": [ 51, 77 ], "kind": "commanddeclaration" }, { "full_name": "FirstOrder.Language.Order.Language.instIsRelational", "code": "instance Language.instIsRelational : IsRelational Language.order :=\n Language.isRelational_mk₂", "start": [ 56, 1 ], "end": [ 57, 28 ], "kind": "commanddeclaration" }, { "full_name": "FirstOrder.Language.Order.Language.instSubsingleton", "code": "instance Language.instSubsingleton : Subsingleton (Language.order.Relations n) :=\n Language.subsingleton_mk₂_relations", "start": [ 60, 1 ], "end": [ 61, 38 ], "kind": "commanddeclaration" }, { "full_name": "FirstOrder.Language.IsOrdered", "code": "class IsOrdered (L : Language.{u, v}) where\n leSymb : L.Relations 2", "start": [ 66, 1 ], "end": [ 68, 25 ], "kind": "commanddeclaration" }, { "full_name": "FirstOrder.Language.Term.le", "code": "def Term.le (t₁ t₂ : L.Term (Sum α (Fin n))) : L.BoundedFormula α n :=\n leSymb.boundedFormula₂ t₁ t₂", "start": [ 77, 1 ], "end": [ 79, 31 ], "kind": "commanddeclaration" }, { "full_name": "FirstOrder.Language.Term.lt", "code": "def Term.lt (t₁ t₂ : L.Term (Sum α (Fin n))) : L.BoundedFormula α n :=\n t₁.le t₂ ⊓ ∼(t₂.le t₁)", "start": [ 82, 1 ], "end": [ 84, 25 ], "kind": "commanddeclaration" }, { "full_name": "FirstOrder.Language.orderLHom", "code": "def orderLHom : Language.order →ᴸ L :=\n LHom.mk₂ Empty.elim Empty.elim Empty.elim Empty.elim fun _ => leSymb", "start": [ 89, 1 ], "end": [ 92, 71 ], "kind": "commanddeclaration" }, { "full_name": "FirstOrder.Language.orderLHom_leSymb", "code": "@[simp]\ntheorem orderLHom_leSymb [L.IsOrdered] :\n (orderLHom L).onRelation leSymb = (leSymb : L.Relations 2)", "start": [ 100, 1 ], "end": [ 103, 6 ], "kind": "commanddeclaration" }, { "full_name": "FirstOrder.Language.orderLHom_order", "code": "@[simp]\ntheorem orderLHom_order : orderLHom Language.order = LHom.id Language.order", "start": [ 106, 1 ], "end": [ 108, 62 ], "kind": "commanddeclaration" }, { "full_name": "FirstOrder.Language.sum.instIsOrdered", "code": "instance sum.instIsOrdered : IsOrdered (L.sum Language.order) :=\n ⟨Sum.inr IsOrdered.leSymb⟩", "start": [ 111, 1 ], "end": [ 112, 29 ], "kind": "commanddeclaration" }, { "full_name": "FirstOrder.Language.preorderTheory", "code": "def preorderTheory : L.Theory :=\n {leSymb.reflexive, leSymb.transitive}", "start": [ 119, 1 ], "end": [ 121, 40 ], "kind": "commanddeclaration" }, { "full_name": "FirstOrder.Language.partialOrderTheory", "code": "def partialOrderTheory : L.Theory :=\n {leSymb.reflexive, leSymb.antisymmetric, leSymb.transitive}", "start": [ 124, 1 ], "end": [ 126, 62 ], "kind": "commanddeclaration" }, { "full_name": "FirstOrder.Language.linearOrderTheory", "code": "def linearOrderTheory : L.Theory :=\n {leSymb.reflexive, leSymb.antisymmetric, leSymb.transitive, leSymb.total}", "start": [ 129, 1 ], "end": [ 131, 76 ], "kind": "commanddeclaration" }, { "full_name": "FirstOrder.Language.noTopOrderSentence", "code": "def noTopOrderSentence : L.Sentence :=\n ∀'∃'∼((&1).le &0)", "start": [ 134, 1 ], "end": [ 137, 20 ], "kind": "commanddeclaration" }, { "full_name": "FirstOrder.Language.noBotOrderSentence", "code": "def noBotOrderSentence : L.Sentence :=\n ∀'∃'∼((&0).le &1)", "start": [ 140, 1 ], "end": [ 143, 20 ], "kind": "commanddeclaration" }, { "full_name": "FirstOrder.Language.denselyOrderedSentence", "code": "def denselyOrderedSentence : L.Sentence :=\n ∀'∀'((&0).lt &1 ⟹ ∃'((&0).lt &2 ⊓ (&2).lt &1))", "start": [ 146, 1 ], "end": [ 149, 49 ], "kind": "commanddeclaration" }, { "full_name": "FirstOrder.Language.dlo", "code": "def dlo : L.Theory :=\n L.linearOrderTheory ∪ {L.noTopOrderSentence, L.noBotOrderSentence, L.denselyOrderedSentence}", "start": [ 152, 1 ], "end": [ 154, 95 ], "kind": "commanddeclaration" }, { "full_name": "FirstOrder.Language.OrderedStructure", "code": "abbrev OrderedStructure [IsOrdered L] [LE M] [L.Structure M] : Prop :=\n LHom.IsExpansionOn (orderLHom L) M", "start": [ 161, 1 ], "end": [ 163, 37 ], "kind": "commanddeclaration" }, { "full_name": "FirstOrder.Language.orderedStructure_iff", "code": "@[simp]\ntheorem orderedStructure_iff [IsOrdered L] [LE M] [L.Structure M] :\n L.OrderedStructure M ↔ LHom.IsExpansionOn (orderLHom L) M", "start": [ 168, 1 ], "end": [ 171, 10 ], "kind": "commanddeclaration" }, { "full_name": "FirstOrder.Language.orderedStructure_LE", "code": "instance orderedStructure_LE [LE M] : OrderedStructure Language.order M := by\n rw [orderedStructure_iff, orderLHom_order]\n exact LHom.id_isExpansionOn M", "start": [ 174, 1 ], "end": [ 176, 32 ], "kind": "commanddeclaration" }, { "full_name": "FirstOrder.Language.model_preorder", "code": "instance model_preorder [Preorder M] : M ⊨ Language.order.preorderTheory := by\n simp only [preorderTheory, Theory.model_iff, Set.mem_insert_iff, Set.mem_singleton_iff,\n forall_eq_or_imp, Relations.realize_reflexive, relMap_apply₂, forall_eq,\n Relations.realize_transitive]\n exact ⟨le_refl, fun _ _ _ => le_trans⟩", "start": [ 179, 1 ], "end": [ 183, 41 ], "kind": "commanddeclaration" }, { "full_name": "FirstOrder.Language.model_partialOrder", "code": "instance model_partialOrder [PartialOrder M] : M ⊨ Language.order.partialOrderTheory := by\n simp only [partialOrderTheory, Theory.model_iff, Set.mem_insert_iff, Set.mem_singleton_iff,\n forall_eq_or_imp, Relations.realize_reflexive, relMap_apply₂, Relations.realize_antisymmetric,\n forall_eq, Relations.realize_transitive]\n exact ⟨le_refl, fun _ _ => le_antisymm, fun _ _ _ => le_trans⟩", "start": [ 186, 1 ], "end": [ 190, 65 ], "kind": "commanddeclaration" }, { "full_name": "FirstOrder.Language.model_linearOrder", "code": "instance model_linearOrder [LinearOrder M] : M ⊨ Language.order.linearOrderTheory := by\n simp only [linearOrderTheory, Theory.model_iff, Set.mem_insert_iff, Set.mem_singleton_iff,\n forall_eq_or_imp, Relations.realize_reflexive, relMap_apply₂, Relations.realize_antisymmetric,\n Relations.realize_transitive, forall_eq, Relations.realize_total]\n exact ⟨le_refl, fun _ _ => le_antisymm, fun _ _ _ => le_trans, le_total⟩", "start": [ 193, 1 ], "end": [ 197, 75 ], "kind": "commanddeclaration" }, { "full_name": "FirstOrder.Language.relMap_leSymb", "code": "@[simp]\ntheorem relMap_leSymb [LE M] [L.OrderedStructure M] {a b : M} :\n RelMap (leSymb : L.Relations 2) ![a, b] ↔ a ≤ b", "start": [ 204, 1 ], "end": [ 208, 6 ], "kind": "commanddeclaration" }, { "full_name": "FirstOrder.Language.Term.realize_le", "code": "@[simp]\ntheorem Term.realize_le [LE M] [L.OrderedStructure M] {t₁ t₂ : L.Term (Sum α (Fin n))} {v : α → M}\n {xs : Fin n → M} :\n (t₁.le t₂).Realize v xs ↔ t₁.realize (Sum.elim v xs) ≤ t₂.realize (Sum.elim v xs)", "start": [ 211, 1 ], "end": [ 215, 17 ], "kind": "commanddeclaration" }, { "full_name": "FirstOrder.Language.Term.realize_lt", "code": "@[simp]\ntheorem Term.realize_lt [Preorder M] [L.OrderedStructure M] {t₁ t₂ : L.Term (Sum α (Fin n))}\n {v : α → M} {xs : Fin n → M} :\n (t₁.lt t₂).Realize v xs ↔ t₁.realize (Sum.elim v xs) < t₂.realize (Sum.elim v xs)", "start": [ 218, 1 ], "end": [ 222, 35 ], "kind": "commanddeclaration" }, { "full_name": "FirstOrder.Language.realize_noTopOrder_iff", "code": "theorem realize_noTopOrder_iff : M ⊨ Language.order.noTopOrderSentence ↔ NoTopOrder M", "start": [ 231, 1 ], "end": [ 237, 24 ], "kind": "commanddeclaration" }, { "full_name": "FirstOrder.Language.realize_noTopOrder", "code": "@[simp]\ntheorem realize_noTopOrder [h : NoTopOrder M] : M ⊨ Language.order.noTopOrderSentence", "start": [ 240, 1 ], "end": [ 242, 29 ], "kind": "commanddeclaration" }, { "full_name": "FirstOrder.Language.realize_noBotOrder_iff", "code": "theorem realize_noBotOrder_iff : M ⊨ Language.order.noBotOrderSentence ↔ NoBotOrder M", "start": [ 245, 1 ], "end": [ 251, 24 ], "kind": "commanddeclaration" }, { "full_name": "FirstOrder.Language.realize_noBotOrder", "code": "@[simp]\ntheorem realize_noBotOrder [h : NoBotOrder M] : M ⊨ Language.order.noBotOrderSentence", "start": [ 254, 1 ], "end": [ 256, 29 ], "kind": "commanddeclaration" }, { "full_name": "FirstOrder.Language.realize_denselyOrdered_iff", "code": "theorem realize_denselyOrdered_iff [Preorder M] :\n M ⊨ Language.order.denselyOrderedSentence ↔ DenselyOrdered M", "start": [ 261, 1 ], "end": [ 268, 26 ], "kind": "commanddeclaration" }, { "full_name": "FirstOrder.Language.realize_denselyOrdered", "code": "@[simp]\ntheorem realize_denselyOrdered [Preorder M] [h : DenselyOrdered M] :\n M ⊨ Language.order.denselyOrderedSentence", "start": [ 271, 1 ], "end": [ 274, 33 ], "kind": "commanddeclaration" }, { "full_name": "FirstOrder.Language.model_dlo", "code": "instance model_dlo [LinearOrder M] [DenselyOrdered M] [NoTopOrder M] [NoBotOrder M] :\n M ⊨ Language.order.dlo := by\n simp only [dlo, Set.union_insert, Set.union_singleton, Theory.model_iff, Set.mem_insert_iff,\n forall_eq_or_imp, realize_noTopOrder, realize_noBotOrder, realize_denselyOrdered,\n true_and_iff]\n rw [← Theory.model_iff]\n infer_instance", "start": [ 277, 1 ], "end": [ 283, 17 ], "kind": "commanddeclaration" } ]

[ "Mathlib/Control/Traversable/Instances.lean", ".lake/packages/lean4/src/lean/Init.lean", "Mathlib/Data/DList/Defs.lean", "Mathlib/Control/Traversable/Equiv.lean" ]

[ { "full_name": "Batteries.DList.listEquivDList", "code": "def DList.listEquivDList : List α ≃ DList α where\n toFun := DList.ofList\n invFun := DList.toList\n left_inv _ := DList.toList_ofList _\n right_inv _ := DList.ofList_toList _", "start": [ 26, 1 ], "end": [ 32, 39 ], "kind": "commanddeclaration" } ]

[ ".lake/packages/lean4/src/lean/Init.lean", "Mathlib/Algebra/BigOperators/Group/Finset.lean", "Mathlib/Data/Fintype/Card.lean" ]

[ { "full_name": "Multiset.ToType", "code": "def Multiset.ToType (m : Multiset α) : Type _ := (x : α) × Fin (m.count x)", "start": [ 40, 1 ], "end": [ 42, 75 ], "kind": "commanddeclaration" }, { "full_name": "Multiset.mkToType", "code": "@[reducible, match_pattern]\ndef Multiset.mkToType (m : Multiset α) (x : α) (i : Fin (m.count x)) : m :=\n ⟨x, i⟩", "start": [ 55, 1 ], "end": [ 59, 9 ], "kind": "commanddeclaration" }, { "full_name": "instCoeSortMultisetType.instCoeOutToType", "code": "instance instCoeSortMultisetType.instCoeOutToType : CoeOut m α :=\n ⟨fun x ↦ x.1⟩", "start": [ 62, 1 ], "end": [ 65, 16 ], "kind": "commanddeclaration" }, { "full_name": "Multiset.coe_mk", "code": "theorem Multiset.coe_mk {x : α} {i : Fin (m.count x)} : ↑(m.mkToType x i) = x", "start": [ 75, 1 ], "end": [ 76, 6 ], "kind": "commanddeclaration" }, { "full_name": "Multiset.coe_mem", "code": "@[simp] lemma Multiset.coe_mem {x : m} : ↑x ∈ m := Multiset.count_pos.mp (by have := x.2.2; omega)", "start": [ 79, 1 ], "end": [ 79, 99 ], "kind": "lemma" }, { "full_name": "Multiset.forall_coe", "code": "@[simp]\nprotected theorem Multiset.forall_coe (p : m → Prop) :\n (∀ x : m, p x) ↔ ∀ (x : α) (i : Fin (m.count x)), p ⟨x, i⟩", "start": [ 82, 1 ], "end": [ 85, 15 ], "kind": "commanddeclaration" }, { "full_name": "Multiset.exists_coe", "code": "@[simp]\nprotected theorem Multiset.exists_coe (p : m → Prop) :\n (∃ x : m, p x) ↔ ∃ (x : α) (i : Fin (m.count x)), p ⟨x, i⟩", "start": [ 88, 1 ], "end": [ 91, 15 ], "kind": "commanddeclaration" }, { "full_name": "Multiset.toEnumFinset", "code": "def Multiset.toEnumFinset (m : Multiset α) : Finset (α × ℕ) :=\n { p : α × ℕ | p.2 < m.count p.1 }.toFinset", "start": [ 104, 1 ], "end": [ 108, 45 ], "kind": "commanddeclaration" }, { "full_name": "Multiset.mem_toEnumFinset", "code": "@[simp]\ntheorem Multiset.mem_toEnumFinset (m : Multiset α) (p : α × ℕ) :\n p ∈ m.toEnumFinset ↔ p.2 < m.count p.1", "start": [ 111, 1 ], "end": [ 114, 19 ], "kind": "commanddeclaration" }, { "full_name": "Multiset.mem_of_mem_toEnumFinset", "code": "theorem Multiset.mem_of_mem_toEnumFinset {p : α × ℕ} (h : p ∈ m.toEnumFinset) : p.1 ∈ m", "start": [ 117, 1 ], "end": [ 118, 72 ], "kind": "commanddeclaration" }, { "full_name": "Multiset.toEnumFinset_mono", "code": "@[mono]\ntheorem Multiset.toEnumFinset_mono {m₁ m₂ : Multiset α} (h : m₁ ≤ m₂) :\n m₁.toEnumFinset ⊆ m₂.toEnumFinset", "start": [ 121, 1 ], "end": [ 126, 56 ], "kind": "commanddeclaration" }, { "full_name": "Multiset.toEnumFinset_subset_iff", "code": "@[simp]\ntheorem Multiset.toEnumFinset_subset_iff {m₁ m₂ : Multiset α} :\n m₁.toEnumFinset ⊆ m₂.toEnumFinset ↔ m₁ ≤ m₂", "start": [ 129, 1 ], "end": [ 141, 14 ], "kind": "commanddeclaration" }, { "full_name": "Multiset.coeEmbedding", "code": "@[simps]\ndef Multiset.coeEmbedding (m : Multiset α) : m ↪ α × ℕ where\n toFun x := (x, x.2)\n inj' := by\n intro ⟨x, i, hi⟩ ⟨y, j, hj⟩\n rintro ⟨⟩\n rfl", "start": [ 144, 1 ], "end": [ 152, 8 ], "kind": "commanddeclaration" }, { "full_name": "Multiset.coeEquiv", "code": "@[simps]\ndef Multiset.coeEquiv (m : Multiset α) : m ≃ m.toEnumFinset where\n toFun x :=\n ⟨m.coeEmbedding x, by\n rw [Multiset.mem_toEnumFinset]\n exact x.2.2⟩\n invFun x :=\n ⟨x.1.1, x.1.2, by\n rw [← Multiset.mem_toEnumFinset]\n exact x.2⟩\n left_inv := by\n rintro ⟨x, i, h⟩\n rfl\n right_inv := by\n rintro ⟨⟨x, i⟩, h⟩\n rfl", "start": [ 155, 1 ], "end": [ 172, 8 ], "kind": "commanddeclaration" }, { "full_name": "Multiset.toEmbedding_coeEquiv_trans", "code": "@[simp]\ntheorem Multiset.toEmbedding_coeEquiv_trans (m : Multiset α) :\n m.coeEquiv.toEmbedding.trans (Function.Embedding.subtype _) = m.coeEmbedding", "start": [ 175, 1 ], "end": [ 177, 99 ], "kind": "commanddeclaration" }, { "full_name": "Multiset.fintypeCoe", "code": "@[irreducible]\ninstance Multiset.fintypeCoe : Fintype m :=\n Fintype.ofEquiv m.toEnumFinset m.coeEquiv.symm", "start": [ 180, 1 ], "end": [ 182, 49 ], "kind": "commanddeclaration" }, { "full_name": "Multiset.map_univ_coeEmbedding", "code": "theorem Multiset.map_univ_coeEmbedding (m : Multiset α) :\n (Finset.univ : Finset m).map m.coeEmbedding = m.toEnumFinset", "start": [ 185, 1 ], "end": [ 191, 18 ], "kind": "commanddeclaration" }, { "full_name": "Multiset.toEnumFinset_filter_eq", "code": "theorem Multiset.toEnumFinset_filter_eq (m : Multiset α) (x : α) :\n (m.toEnumFinset.filter fun p ↦ x = p.1) =\n (Finset.range (m.count x)).map ⟨Prod.mk x, Prod.mk.inj_left x⟩", "start": [ 194, 1 ], "end": [ 202, 6 ], "kind": "commanddeclaration" }, { "full_name": "Multiset.map_toEnumFinset_fst", "code": "@[simp]\ntheorem Multiset.map_toEnumFinset_fst (m : Multiset α) : m.toEnumFinset.val.map Prod.fst = m", "start": [ 205, 1 ], "end": [ 209, 78 ], "kind": "commanddeclaration" }, { "full_name": "Multiset.image_toEnumFinset_fst", "code": "@[simp]\ntheorem Multiset.image_toEnumFinset_fst (m : Multiset α) :\n m.toEnumFinset.image Prod.fst = m.toFinset", "start": [ 212, 1 ], "end": [ 215, 51 ], "kind": "commanddeclaration" }, { "full_name": "Multiset.map_univ_coe", "code": "@[simp]\ntheorem Multiset.map_univ_coe (m : Multiset α) :\n (Finset.univ : Finset m).val.map (fun x : m ↦ (x : α)) = m", "start": [ 218, 1 ], "end": [ 224, 36 ], "kind": "commanddeclaration" }, { "full_name": "Multiset.map_univ", "code": "@[simp]\ntheorem Multiset.map_univ {β : Type*} (m : Multiset α) (f : α → β) :\n ((Finset.univ : Finset m).val.map fun (x : m) ↦ f (x : α)) = m.map f", "start": [ 227, 1 ], "end": [ 230, 50 ], "kind": "commanddeclaration" }, { "full_name": "Multiset.card_toEnumFinset", "code": "@[simp]\ntheorem Multiset.card_toEnumFinset (m : Multiset α) : m.toEnumFinset.card = Multiset.card m", "start": [ 233, 1 ], "end": [ 237, 31 ], "kind": "commanddeclaration" }, { "full_name": "Multiset.card_coe", "code": "@[simp]\ntheorem Multiset.card_coe (m : Multiset α) : Fintype.card m = Multiset.card m", "start": [ 240, 1 ], "end": [ 243, 50 ], "kind": "commanddeclaration" }, { "full_name": "Multiset.prod_eq_prod_coe", "code": "@[to_additive]\ntheorem Multiset.prod_eq_prod_coe [CommMonoid α] (m : Multiset α) : m.prod = ∏ x : m, (x : α)", "start": [ 246, 1 ], "end": [ 250, 21 ], "kind": "commanddeclaration" }, { "full_name": "Multiset.prod_eq_prod_toEnumFinset", "code": "@[to_additive]\ntheorem Multiset.prod_eq_prod_toEnumFinset [CommMonoid α] (m : Multiset α) :\n m.prod = ∏ x ∈ m.toEnumFinset, x.1", "start": [ 254, 1 ], "end": [ 258, 7 ], "kind": "commanddeclaration" }, { "full_name": "Multiset.prod_toEnumFinset", "code": "@[to_additive]\ntheorem Multiset.prod_toEnumFinset {β : Type*} [CommMonoid β] (m : Multiset α) (f : α → ℕ → β) :\n ∏ x ∈ m.toEnumFinset, f x.1 x.2 = ∏ x : m, f x x.2", "start": [ 262, 1 ], "end": [ 268, 8 ], "kind": "commanddeclaration" } ]

[ ".lake/packages/lean4/src/lean/Init.lean", "Mathlib/Topology/Category/TopCat/Basic.lean", "Mathlib/RepresentationTheory/Action/Basic.lean", "Mathlib/Topology/Algebra/MulAction.lean" ]

[ { "full_name": "Action.IsContinuous", "code": "abbrev IsContinuous (X : Action V G) : Prop :=\n ContinuousSMul G ((CategoryTheory.forget₂ _ TopCat).obj X)", "start": [ 53, 1 ], "end": [ 56, 61 ], "kind": "commanddeclaration" }, { "full_name": "ContAction", "code": "def ContAction : Type _ := FullSubcategory (IsContinuous (V := V) (G := G))", "start": [ 62, 1 ], "end": [ 64, 76 ], "kind": "commanddeclaration" }, { "full_name": "ContAction.IsDiscrete", "code": "abbrev IsDiscrete (X : ContAction V G) : Prop :=\n DiscreteTopology ((CategoryTheory.forget₂ _ TopCat).obj X)", "start": [ 88, 1 ], "end": [ 91, 61 ], "kind": "commanddeclaration" }, { "full_name": "DiscreteContAction", "code": "def DiscreteContAction : Type _ := FullSubcategory (IsDiscrete (V := V) (G := G))", "start": [ 97, 1 ], "end": [ 98, 82 ], "kind": "commanddeclaration" } ]

[ ".lake/packages/lean4/src/lean/Init.lean", "Mathlib/Order/Zorn.lean" ]

[ { "full_name": "extend_partialOrder", "code": "theorem extend_partialOrder {α : Type u} (r : α → α → Prop) [IsPartialOrder α r] :\n ∃ s : α → α → Prop, IsLinearOrder α s ∧ r ≤ s", "start": [ 24, 1 ], "end": [ 73, 44 ], "kind": "commanddeclaration" }, { "full_name": "LinearExtension", "code": "def LinearExtension (α : Type u) : Type u :=\n α", "start": [ 76, 1 ], "end": [ 78, 4 ], "kind": "commanddeclaration" }, { "full_name": "toLinearExtension", "code": "def toLinearExtension {α : Type u} [PartialOrder α] : α →o LinearExtension α where\n toFun x := x\n monotone' := (extend_partialOrder ((· ≤ ·) : α → α → Prop)).choose_spec.2", "start": [ 89, 1 ], "end": [ 92, 76 ], "kind": "commanddeclaration" } ]

[ "Mathlib/Algebra/Algebra/Subalgebra/Basic.lean", ".lake/packages/lean4/src/lean/Init.lean", "Mathlib/LinearAlgebra/DirectSum/Finsupp.lean", "Mathlib/Algebra/Algebra/Operations.lean" ]

[ { "full_name": "Submodule.mulMap", "code": "def mulMap : M ⊗[R] N →ₗ[R] S := TensorProduct.lift ((LinearMap.mul R S).domRestrict₁₂ M N)", "start": [ 58, 1 ], "end": [ 60, 92 ], "kind": "commanddeclaration" }, { "full_name": "Submodule.mulMap_tmul", "code": "@[simp]\ntheorem mulMap_tmul (m : M) (n : N) : mulMap M N (m ⊗ₜ[R] n) = m.1 * n.1", "start": [ 62, 1 ], "end": [ 63, 80 ], "kind": "commanddeclaration" }, { "full_name": "Submodule.mulMap_op", "code": "theorem mulMap_op :\n mulMap (equivOpposite.symm (MulOpposite.op M)) (equivOpposite.symm (MulOpposite.op N)) =\n (MulOpposite.opLinearEquiv R).toLinearMap ∘ₗ mulMap N M ∘ₗ\n (TensorProduct.congr\n (LinearEquiv.ofSubmodule' (MulOpposite.opLinearEquiv R).symm M)\n (LinearEquiv.ofSubmodule' (MulOpposite.opLinearEquiv R).symm N) ≪≫ₗ\n TensorProduct.comm R M N).toLinearMap", "start": [ 65, 1 ], "end": [ 72, 35 ], "kind": "commanddeclaration" }, { "full_name": "Submodule.mulMap_comm_of_commute", "code": "theorem mulMap_comm_of_commute (hc : ∀ (m : M) (n : N), Commute m.1 n.1) :\n mulMap N M = mulMap M N ∘ₗ TensorProduct.comm R N M", "start": [ 74, 1 ], "end": [ 78, 22 ], "kind": "commanddeclaration" }, { "full_name": "Submodule.mulMap_comp_rTensor", "code": "theorem mulMap_comp_rTensor {M' : Submodule R S} (hM : M' ≤ M) :\n mulMap M N ∘ₗ (inclusion hM).rTensor N = mulMap M' N", "start": [ 81, 1 ], "end": [ 83, 35 ], "kind": "commanddeclaration" }, { "full_name": "Submodule.mulMap_comp_lTensor", "code": "theorem mulMap_comp_lTensor {N' : Submodule R S} (hN : N' ≤ N) :\n mulMap M N ∘ₗ (inclusion hN).lTensor M = mulMap M N'", "start": [ 86, 1 ], "end": [ 88, 35 ], "kind": "commanddeclaration" }, { "full_name": "Submodule.mulMap_comp_map_inclusion", "code": "theorem mulMap_comp_map_inclusion {M' N' : Submodule R S} (hM : M' ≤ M) (hN : N' ≤ N) :\n mulMap M N ∘ₗ TensorProduct.map (inclusion hM) (inclusion hN) = mulMap M' N'", "start": [ 91, 1 ], "end": [ 93, 35 ], "kind": "commanddeclaration" }, { "full_name": "Submodule.mulMap_eq_mul'_comp_mapIncl", "code": "theorem mulMap_eq_mul'_comp_mapIncl : mulMap M N = .mul' R S ∘ₗ TensorProduct.mapIncl M N", "start": [ 95, 1 ], "end": [ 96, 35 ], "kind": "commanddeclaration" }, { "full_name": "Submodule.mulMap_range", "code": "theorem mulMap_range : LinearMap.range (mulMap M N) = M * N", "start": [ 98, 1 ], "end": [ 104, 62 ], "kind": "commanddeclaration" }, { "full_name": "Submodule.mulMap'", "code": "def mulMap' : M ⊗[R] N →ₗ[R] ↥(M * N) :=\n (LinearEquiv.ofEq _ _ (mulMap_range M N)).toLinearMap ∘ₗ (mulMap M N).rangeRestrict", "start": [ 106, 1 ], "end": [ 110, 86 ], "kind": "commanddeclaration" }, { "full_name": "Submodule.val_mulMap'_tmul", "code": "@[simp]\ntheorem val_mulMap'_tmul (m : M) (n : N) : (mulMap' M N (m ⊗ₜ[R] n) : S) = m.1 * n.1", "start": [ 113, 1 ], "end": [ 114, 92 ], "kind": "commanddeclaration" }, { "full_name": "Submodule.mulMap'_surjective", "code": "theorem mulMap'_surjective : Function.Surjective (mulMap' M N)", "start": [ 116, 1 ], "end": [ 118, 40 ], "kind": "commanddeclaration" }, { "full_name": "Submodule.lTensorOne'", "code": "def lTensorOne' : (⊥ : Subalgebra R S) ⊗[R] N →ₗ[R] N :=\n show (1 : Submodule R S) ⊗[R] N →ₗ[R] N from\n (LinearEquiv.ofEq _ _ (by rw [mulMap_range, one_mul])).toLinearMap ∘ₗ (mulMap _ N).rangeRestrict", "start": [ 120, 1 ], "end": [ 125, 101 ], "kind": "commanddeclaration" }, { "full_name": "Submodule.lTensorOne'_tmul", "code": "@[simp]\ntheorem lTensorOne'_tmul (y : R) (n : N) :\n N.lTensorOne' (algebraMap R _ y ⊗ₜ[R] n) = y • n", "start": [ 128, 1 ], "end": [ 133, 28 ], "kind": "commanddeclaration" }, { "full_name": "Submodule.lTensorOne'_one_tmul", "code": "@[simp]\ntheorem lTensorOne'_one_tmul (n : N) : N.lTensorOne' (1 ⊗ₜ[R] n) = n", "start": [ 136, 1 ], "end": [ 138, 35 ], "kind": "commanddeclaration" }, { "full_name": "Submodule.lTensorOne", "code": "def lTensorOne : (⊥ : Subalgebra R S) ⊗[R] N ≃ₗ[R] N :=\n LinearEquiv.ofLinear N.lTensorOne' (TensorProduct.mk R (⊥ : Subalgebra R S) N 1)\n (by ext; simp) <| TensorProduct.ext' fun r n ↦ by\n change 1 ⊗ₜ[R] lTensorOne' N _ = r ⊗ₜ[R] n\n obtain ⟨x, h⟩ := Algebra.mem_bot.1 r.2\n replace h : algebraMap R _ x = r := Subtype.val_injective h\n rw [← h, lTensorOne'_tmul, ← TensorProduct.smul_tmul, Algebra.smul_def, mul_one]", "start": [ 140, 1 ], "end": [ 149, 83 ], "kind": "commanddeclaration" }, { "full_name": "Submodule.lTensorOne_tmul", "code": "@[simp]\ntheorem lTensorOne_tmul (y : R) (n : N) : N.lTensorOne (algebraMap R _ y ⊗ₜ[R] n) = y • n", "start": [ 152, 1 ], "end": [ 154, 25 ], "kind": "commanddeclaration" }, { "full_name": "Submodule.lTensorOne_one_tmul", "code": "@[simp]\ntheorem lTensorOne_one_tmul (n : N) : N.lTensorOne (1 ⊗ₜ[R] n) = n", "start": [ 157, 1 ], "end": [ 159, 27 ], "kind": "commanddeclaration" }, { "full_name": "Submodule.lTensorOne_symm_apply", "code": "@[simp]\ntheorem lTensorOne_symm_apply (n : N) : N.lTensorOne.symm n = 1 ⊗ₜ[R] n", "start": [ 162, 1 ], "end": [ 163, 79 ], "kind": "commanddeclaration" }, { "full_name": "Submodule.mulMap_one_left_eq", "code": "theorem mulMap_one_left_eq : mulMap 1 N = N.subtype ∘ₗ N.lTensorOne.toLinearMap", "start": [ 165, 1 ], "end": [ 166, 35 ], "kind": "commanddeclaration" }, { "full_name": "Submodule.rTensorOne'", "code": "def rTensorOne' : M ⊗[R] (⊥ : Subalgebra R S) →ₗ[R] M :=\n show M ⊗[R] (1 : Submodule R S) →ₗ[R] M from\n (LinearEquiv.ofEq _ _ (by rw [mulMap_range, mul_one])).toLinearMap ∘ₗ (mulMap M _).rangeRestrict", "start": [ 168, 1 ], "end": [ 173, 101 ], "kind": "commanddeclaration" }, { "full_name": "Submodule.rTensorOne'_tmul", "code": "@[simp]\ntheorem rTensorOne'_tmul (y : R) (m : M) :\n M.rTensorOne' (m ⊗ₜ[R] algebraMap R _ y) = y • m", "start": [ 176, 1 ], "end": [ 182, 28 ], "kind": "commanddeclaration" }, { "full_name": "Submodule.rTensorOne'_tmul_one", "code": "@[simp]\ntheorem rTensorOne'_tmul_one (m : M) : M.rTensorOne' (m ⊗ₜ[R] 1) = m", "start": [ 185, 1 ], "end": [ 187, 35 ], "kind": "commanddeclaration" }, { "full_name": "Submodule.rTensorOne", "code": "def rTensorOne : M ⊗[R] (⊥ : Subalgebra R S) ≃ₗ[R] M :=\n LinearEquiv.ofLinear M.rTensorOne' ((TensorProduct.comm R _ _).toLinearMap ∘ₗ\n TensorProduct.mk R (⊥ : Subalgebra R S) M 1) (by ext; simp) <| TensorProduct.ext' fun n r ↦ by\n change rTensorOne' M _ ⊗ₜ[R] 1 = n ⊗ₜ[R] r\n obtain ⟨x, h⟩ := Algebra.mem_bot.1 r.2\n replace h : algebraMap R _ x = r := Subtype.val_injective h\n rw [← h, rTensorOne'_tmul, TensorProduct.smul_tmul, Algebra.smul_def, mul_one]", "start": [ 189, 1 ], "end": [ 198, 81 ], "kind": "commanddeclaration" }, { "full_name": "Submodule.rTensorOne_tmul", "code": "@[simp]\ntheorem rTensorOne_tmul (y : R) (m : M) : M.rTensorOne (m ⊗ₜ[R] algebraMap R _ y) = y • m", "start": [ 201, 1 ], "end": [ 203, 25 ], "kind": "commanddeclaration" }, { "full_name": "Submodule.rTensorOne_tmul_one", "code": "@[simp]\ntheorem rTensorOne_tmul_one (m : M) : M.rTensorOne (m ⊗ₜ[R] 1) = m", "start": [ 206, 1 ], "end": [ 208, 27 ], "kind": "commanddeclaration" }, { "full_name": "Submodule.rTensorOne_symm_apply", "code": "@[simp]\ntheorem rTensorOne_symm_apply (m : M) : M.rTensorOne.symm m = m ⊗ₜ[R] 1", "start": [ 211, 1 ], "end": [ 212, 79 ], "kind": "commanddeclaration" }, { "full_name": "Submodule.mulMap_one_right_eq", "code": "theorem mulMap_one_right_eq : mulMap M 1 = M.subtype ∘ₗ M.rTensorOne.toLinearMap", "start": [ 214, 1 ], "end": [ 215, 35 ], "kind": "commanddeclaration" }, { "full_name": "Submodule.comm_trans_lTensorOne", "code": "@[simp]\ntheorem comm_trans_lTensorOne :\n (TensorProduct.comm R _ _).trans M.lTensorOne = M.rTensorOne", "start": [ 217, 1 ], "end": [ 223, 17 ], "kind": "commanddeclaration" }, { "full_name": "Submodule.comm_trans_rTensorOne", "code": "@[simp]\ntheorem comm_trans_rTensorOne :\n (TensorProduct.comm R _ _).trans M.rTensorOne = M.lTensorOne", "start": [ 225, 1 ], "end": [ 231, 17 ], "kind": "commanddeclaration" }, { "full_name": "Submodule.mulLeftMap_eq_mulMap_comp", "code": "theorem mulLeftMap_eq_mulMap_comp {ι : Type*} [DecidableEq ι] (m : ι → M) :\n mulLeftMap N m = mulMap M N ∘ₗ LinearMap.rTensor N (Finsupp.total ι M R m) ∘ₗ\n (TensorProduct.finsuppScalarLeft R N ι).symm.toLinearMap", "start": [ 234, 1 ], "end": [ 237, 12 ], "kind": "commanddeclaration" }, { "full_name": "Submodule.mulRightMap_eq_mulMap_comp", "code": "theorem mulRightMap_eq_mulMap_comp {ι : Type*} [DecidableEq ι] (n : ι → N) :\n mulRightMap M n = mulMap M N ∘ₗ LinearMap.lTensor M (Finsupp.total ι N R n) ∘ₗ\n (TensorProduct.finsuppScalarRight R M ι).symm.toLinearMap", "start": [ 240, 1 ], "end": [ 243, 12 ], "kind": "commanddeclaration" }, { "full_name": "Submodule.mulMap_comm", "code": "theorem mulMap_comm : mulMap N M = (mulMap M N).comp (TensorProduct.comm R N M).toLinearMap", "start": [ 253, 1 ], "end": [ 254, 52 ], "kind": "commanddeclaration" } ]

[ "Mathlib/FieldTheory/IsAlgClosed/AlgebraicClosure.lean", ".lake/packages/lean4/src/lean/Init.lean", "Mathlib/FieldTheory/KrullTopology.lean", "Mathlib/Topology/Algebra/Group/TopologicalAbelianization.lean" ]

[ { "full_name": "Field.absoluteGaloisGroup", "code": "def absoluteGaloisGroup := AlgebraicClosure K ≃ₐ[K] AlgebraicClosure K", "start": [ 37, 1 ], "end": [ 39, 71 ], "kind": "commanddeclaration" }, { "full_name": "Field.absoluteGaloisGroup.commutator_closure_isNormal", "code": "instance absoluteGaloisGroup.commutator_closure_isNormal :\n (commutator (G_K K)).topologicalClosure.Normal :=\n Subgroup.is_normal_topologicalClosure (commutator (G_K K))", "start": [ 50, 1 ], "end": [ 52, 61 ], "kind": "commanddeclaration" }, { "full_name": "Field.absoluteGaloisGroupAbelianization", "code": "abbrev absoluteGaloisGroupAbelianization := TopologicalAbelianization (G_K K)", "start": [ 54, 1 ], "end": [ 56, 78 ], "kind": "commanddeclaration" } ]

[ ".lake/packages/lean4/src/lean/Init.lean", "Mathlib/CategoryTheory/Sites/LocallySurjective.lean", "Mathlib/CategoryTheory/Sites/Coherent/SheafComparison.lean", "Mathlib/CategoryTheory/Sites/Coherent/ExtensiveTopology.lean" ]

[ { "full_name": "CategoryTheory.regularTopology.isLocallySurjective_iff", "code": "lemma regularTopology.isLocallySurjective_iff [Preregular C] {F G : Cᵒᵖ ⥤ D} (f : F ⟶ G) :\n Presheaf.IsLocallySurjective (regularTopology C) f ↔\n ∀ (X : C) (y : G.obj ⟨X⟩), (∃ (X' : C) (φ : X' ⟶ X) (_ : EffectiveEpi φ) (x : F.obj ⟨X'⟩),\n f.app ⟨X'⟩ x = G.map ⟨φ⟩ y) := by\n constructor\n · intro ⟨h⟩ X y\n specialize h y\n rw [regularTopology.mem_sieves_iff_hasEffectiveEpi] at h\n obtain ⟨X', π, h, h'⟩ := h\n exact ⟨X', π, h, h'⟩\n · intro h\n refine ⟨fun y ↦ ?_⟩\n obtain ⟨X', π, h, h'⟩ := h _ y\n rw [regularTopology.mem_sieves_iff_hasEffectiveEpi]\n exact ⟨X', π, h, h'⟩", "start": [ 40, 1 ], "end": [ 54, 25 ], "kind": "lemma" }, { "full_name": "CategoryTheory.extensiveTopology.surjective_of_isLocallySurjective_sheafOfTypes", "code": "lemma extensiveTopology.surjective_of_isLocallySurjective_sheafOfTypes [FinitaryPreExtensive C]\n {F G : Cᵒᵖ ⥤ Type w} (f : F ⟶ G) [PreservesFiniteProducts F] [PreservesFiniteProducts G]\n (h : Presheaf.IsLocallySurjective (extensiveTopology C) f) {X : C} :\n Function.Surjective (f.app (op X)) := by\n intro x\n replace h := h.1 x\n rw [mem_sieves_iff_contains_colimit_cofan] at h\n obtain ⟨α, _, Y, π, h, h'⟩ := h\n let y : (a : α) → (F.obj ⟨Y a⟩) := fun a ↦ (h' a).choose\n let _ : Fintype α := Fintype.ofFinite _\n let ht := (Types.productLimitCone (fun a ↦ F.obj ⟨Y a⟩)).isLimit\n let ht' := (Functor.Initial.isLimitWhiskerEquiv (Discrete.opposite α).inverse\n (Cocone.op (Cofan.mk X π))).symm h.some.op\n let i : ((a : α) → (F.obj ⟨Y a⟩)) ≅ (F.obj ⟨X⟩) :=\n ht.conePointsIsoOfNatIso (isLimitOfPreserves F ht')\n (Discrete.natIso (fun _ ↦ (Iso.refl (F.obj ⟨_⟩))))\n refine ⟨i.hom y, ?_⟩\n apply Concrete.isLimit_ext _ (isLimitOfPreserves G ht')\n intro ⟨a⟩\n simp only [Functor.comp_obj, Discrete.opposite_inverse_obj, Functor.op_obj, Discrete.functor_obj,\n Functor.mapCone_pt, Cone.whisker_pt, Cocone.op_pt, Cofan.mk_pt, Functor.const_obj_obj,\n Functor.mapCone_π_app, Cone.whisker_π, Cocone.op_π, whiskerLeft_app, NatTrans.op_app,\n Cofan.mk_ι_app]\n have : f.app ⟨Y a⟩ (y a) = G.map (π a).op x := (h' a).choose_spec\n change _ = G.map (π a).op x\n erw [← this, ← NatTrans.naturality_apply (φ := f)]\n apply congrArg\n change (i.hom ≫ F.map (π a).op) y = _\n erw [IsLimit.map_π]\n rfl", "start": [ 56, 1 ], "end": [ 85, 6 ], "kind": "lemma" }, { "full_name": "CategoryTheory.extensiveTopology.presheafIsLocallySurjective_iff", "code": "lemma extensiveTopology.presheafIsLocallySurjective_iff [FinitaryPreExtensive C] {F G : Cᵒᵖ ⥤ D}\n (f : F ⟶ G) [PreservesFiniteProducts F] [PreservesFiniteProducts G]\n [PreservesFiniteProducts (forget D)] : Presheaf.IsLocallySurjective (extensiveTopology C) f ↔\n ∀ (X : C), Function.Surjective (f.app (op X)) := by\n constructor\n · rw [Presheaf.isLocallySurjective_iff_whisker_forget (J := extensiveTopology C)]\n exact fun h _ ↦ surjective_of_isLocallySurjective_sheafOfTypes (whiskerRight f (forget D)) h\n · intro h\n refine ⟨fun {X} y ↦ ?_⟩\n obtain ⟨x, hx⟩ := h X y\n convert (extensiveTopology C).top_mem' X\n rw [← Sieve.id_mem_iff_eq_top]\n simp [Presheaf.imageSieve]\n exact ⟨x, hx⟩", "start": [ 87, 1 ], "end": [ 100, 18 ], "kind": "lemma" }, { "full_name": "CategoryTheory.extensiveTopology.isLocallySurjective_iff", "code": "lemma extensiveTopology.isLocallySurjective_iff [FinitaryExtensive C]\n {F G : Sheaf (extensiveTopology C) D} (f : F ⟶ G)\n [PreservesFiniteProducts (forget D)] : IsLocallySurjective f ↔\n ∀ (X : C), Function.Surjective (f.val.app (op X)) :=\n extensiveTopology.presheafIsLocallySurjective_iff _ f.val", "start": [ 102, 1 ], "end": [ 106, 60 ], "kind": "lemma" }, { "full_name": "CategoryTheory.regularTopology.isLocallySurjective_sheafOfTypes", "code": "lemma regularTopology.isLocallySurjective_sheafOfTypes [Preregular C] [FinitaryPreExtensive C]\n {F G : Cᵒᵖ ⥤ Type w} (f : F ⟶ G) [PreservesFiniteProducts F] [PreservesFiniteProducts G]\n (h : Presheaf.IsLocallySurjective (coherentTopology C) f) :\n Presheaf.IsLocallySurjective (regularTopology C) f where\n imageSieve_mem y := by\n replace h := h.1 y\n rw [coherentTopology.mem_sieves_iff_hasEffectiveEpiFamily] at h\n obtain ⟨α, _, Z, π, h, h'⟩ := h\n rw [mem_sieves_iff_hasEffectiveEpi]\n let x : (a : α) → (F.obj ⟨Z a⟩) := fun a ↦ (h' a).choose\n let _ : Fintype α := Fintype.ofFinite _\n let i' : ((a : α) → (F.obj ⟨Z a⟩)) ≅ (F.obj ⟨∐ Z⟩) := (Types.productIso _).symm ≪≫\n (PreservesProduct.iso F _).symm ≪≫ F.mapIso (opCoproductIsoProduct _).symm\n refine ⟨∐ Z, Sigma.desc π, inferInstance, i'.hom x, ?_⟩\n have := preservesLimitsOfShapeOfEquiv (Discrete.opposite α).symm G\n apply Concrete.isLimit_ext _ (isLimitOfPreserves G (coproductIsCoproduct Z).op)\n intro ⟨⟨a⟩⟩\n simp only [Functor.comp_obj, Functor.op_obj, Discrete.functor_obj, Functor.mapCone_pt,\n Cocone.op_pt, Cofan.mk_pt, Functor.const_obj_obj, Functor.mapCone_π_app, Cocone.op_π,\n NatTrans.op_app, Cofan.mk_ι_app, Functor.mapIso_symm, Iso.symm_hom, Iso.trans_hom,\n Functor.mapIso_inv, types_comp_apply, i', ← NatTrans.naturality_apply]\n have : f.app ⟨Z a⟩ (x a) = G.map (π a).op y := (h' a).choose_spec\n convert this\n · change F.map _ (F.map _ _) = _\n rw [← FunctorToTypes.map_comp_apply, opCoproductIsoProduct_inv_comp_ι, ← piComparison_comp_π]\n change ((PreservesProduct.iso F _).hom ≫ _) _ = _\n have := Types.productIso_hom_comp_eval (fun a ↦ F.obj (op (Z a))) a\n rw [← Iso.eq_inv_comp] at this\n simp only [types_comp_apply, inv_hom_id_apply, congrFun this x]\n · change G.map _ (G.map _ _) = _\n simp only [← FunctorToTypes.map_comp_apply, ← op_comp, Sigma.ι_desc]", "start": [ 108, 1 ], "end": [ 138, 75 ], "kind": "lemma" }, { "full_name": "CategoryTheory.coherentTopology.presheafIsLocallySurjective_iff", "code": "lemma coherentTopology.presheafIsLocallySurjective_iff {F G : Cᵒᵖ ⥤ D} (f : F ⟶ G)\n [Preregular C] [FinitaryPreExtensive C] [PreservesFiniteProducts F] [PreservesFiniteProducts G]\n [PreservesFiniteProducts (forget D)] :\n Presheaf.IsLocallySurjective (coherentTopology C) f ↔\n Presheaf.IsLocallySurjective (regularTopology C) f := by\n constructor\n · rw [Presheaf.isLocallySurjective_iff_whisker_forget,\n Presheaf.isLocallySurjective_iff_whisker_forget (J := regularTopology C)]\n exact regularTopology.isLocallySurjective_sheafOfTypes _\n · refine Presheaf.isLocallySurjective_of_le (J := regularTopology C) ?_ _\n rw [← extensive_regular_generate_coherent]\n exact (Coverage.gi _).gc.monotone_l le_sup_right", "start": [ 140, 1 ], "end": [ 151, 53 ], "kind": "lemma" }, { "full_name": "CategoryTheory.coherentTopology.isLocallySurjective_iff", "code": "lemma coherentTopology.isLocallySurjective_iff [Preregular C] [FinitaryExtensive C]\n {F G : Sheaf (coherentTopology C) D} (f : F ⟶ G) [PreservesFiniteProducts (forget D)] :\n IsLocallySurjective f ↔ Presheaf.IsLocallySurjective (regularTopology C) f.val :=\n presheafIsLocallySurjective_iff _ f.val", "start": [ 153, 1 ], "end": [ 156, 42 ], "kind": "lemma" } ]

[ ".lake/packages/lean4/src/lean/Init.lean", "Mathlib/CategoryTheory/Limits/Opposites.lean", "Mathlib/CategoryTheory/Limits/Constructions/LimitsOfProductsAndEqualizers.lean" ]

[ { "full_name": "CategoryTheory.Limits.CoproductsFromFiniteFiltered.liftToFinset", "code": "@[simps!]\ndef liftToFinset [HasFiniteCoproducts C] (F : Discrete α ⥤ C) : Finset (Discrete α) ⥤ C where\n obj s := ∐ fun x : s => F.obj x\n map {_ Y} h := Sigma.desc fun y =>\n Sigma.ι (fun (x : { x // x ∈ Y }) => F.obj x) ⟨y, h.down.down y.2⟩", "start": [ 37, 1 ], "end": [ 43, 71 ], "kind": "commanddeclaration" }, { "full_name": "CategoryTheory.Limits.CoproductsFromFiniteFiltered.liftToFinsetColimitCocone", "code": "@[simps!]\ndef liftToFinsetColimitCocone [HasFiniteCoproducts C] [HasFilteredColimitsOfSize.{w, w} C]\n (F : Discrete α ⥤ C) : ColimitCocone F where\n cocone :=\n { pt := colimit (liftToFinset F)\n ι :=\n Discrete.natTrans fun j =>\n @Sigma.ι _ _ _ (fun x : ({j} : Finset (Discrete α)) => F.obj x) _ ⟨j, by simp⟩ ≫\n colimit.ι (liftToFinset F) {j} }\n isColimit :=\n { desc := fun s =>\n colimit.desc (liftToFinset F)\n { pt := s.pt\n ι := { app := fun t => Sigma.desc fun x => s.ι.app x } }\n uniq := fun s m h => by\n apply colimit.hom_ext\n rintro t\n dsimp [liftToFinset]\n apply colimit.hom_ext\n rintro ⟨⟨j, hj⟩⟩\n convert h j using 1\n · simp [← colimit.w (liftToFinset F) ⟨⟨Finset.singleton_subset_iff.2 hj⟩⟩]\n rfl\n · aesop_cat }", "start": [ 46, 1 ], "end": [ 72, 22 ], "kind": "commanddeclaration" }, { "full_name": "CategoryTheory.Limits.hasCoproducts_of_finite_and_filtered", "code": "theorem hasCoproducts_of_finite_and_filtered [HasFiniteCoproducts C]\n [HasFilteredColimitsOfSize.{w, w} C] : HasCoproducts.{w} C", "start": [ 79, 1 ], "end": [ 81, 73 ], "kind": "commanddeclaration" }, { "full_name": "CategoryTheory.Limits.has_colimits_of_finite_and_filtered", "code": "theorem has_colimits_of_finite_and_filtered [HasFiniteColimits C]\n [HasFilteredColimitsOfSize.{w, w} C] : HasColimitsOfSize.{w, w} C", "start": [ 84, 1 ], "end": [ 87, 49 ], "kind": "commanddeclaration" }, { "full_name": "CategoryTheory.Limits.hasProducts_of_finite_and_cofiltered", "code": "theorem hasProducts_of_finite_and_cofiltered [HasFiniteProducts C]\n [HasCofilteredLimitsOfSize.{w, w} C] : HasProducts.{w} C", "start": [ 90, 1 ], "end": [ 93, 26 ], "kind": "commanddeclaration" }, { "full_name": "CategoryTheory.Limits.has_limits_of_finite_and_cofiltered", "code": "theorem has_limits_of_finite_and_cofiltered [HasFiniteLimits C]\n [HasCofilteredLimitsOfSize.{w, w} C] : HasLimitsOfSize.{w, w} C", "start": [ 96, 1 ], "end": [ 99, 43 ], "kind": "commanddeclaration" } ]

[ ".lake/packages/lean4/src/lean/Init.lean", "Mathlib/Data/Set/Notation.lean", "Mathlib/Data/Matroid/Constructions.lean" ]

[ { "full_name": "Matroid.comap", "code": "def comap (N : Matroid β) (f : α → β) : Matroid α :=\n IndepMatroid.matroid <|\n { E := f ⁻¹' N.E\n Indep := fun I ↦ N.Indep (f '' I) ∧ InjOn f I\n indep_empty := by simp\n indep_subset := fun I J h hIJ ↦ ⟨h.1.subset (image_subset _ hIJ), InjOn.mono hIJ h.2⟩\n indep_aug := by\n rintro I B ⟨hI, hIinj⟩ hImax hBmax\n simp only [mem_maximals_iff, mem_setOf_eq, hI, hIinj, and_self, and_imp,\n true_and, not_forall, exists_prop, exists_and_left] at hImax hBmax\n\n obtain ⟨I', hI', hI'inj, hII', hne⟩ := hImax\n\n have h₁ : ¬(N ↾ range f).Base (f '' I) := by\n refine fun hB ↦ hne ?_\n have h_im := hB.eq_of_subset_indep (by simpa) (image_subset _ hII')\n rwa [hI'inj.image_eq_image_iff hII' Subset.rfl] at h_im\n\n have h₂ : (N ↾ range f).Base (f '' B) := by\n refine Indep.base_of_forall_insert (by simpa using hBmax.1.1) ?_\n rintro _ ⟨⟨e, heB, rfl⟩, hfe⟩ hi\n rw [restrict_indep_iff, ← image_insert_eq] at hi\n have hinj : InjOn f (insert e B) := by\n rw [injOn_insert (fun heB ↦ hfe (mem_image_of_mem f heB))]; exact ⟨hBmax.1.2, hfe⟩\n rw [hBmax.2 hi.1 hinj <| subset_insert _ _] at hfe; simp at hfe\n\n obtain ⟨_, ⟨⟨e, he, rfl⟩, he'⟩, hei⟩ := Indep.exists_insert_of_not_base (by simpa) h₁ h₂\n have heI : e ∉ I := fun heI ↦ he' (mem_image_of_mem f heI)\n rw [← image_insert_eq, restrict_indep_iff] at hei\n exact ⟨e, ⟨he, heI⟩, hei.1, (injOn_insert heI).2 ⟨hIinj, he'⟩⟩\n indep_maximal := by\n\n rintro X - I ⟨hI, hIinj⟩ hIX\n obtain ⟨J, hJ⟩ := (N ↾ range f).existsMaximalSubsetProperty_indep (f '' X) (by simp)\n (f '' I) (by simpa) (image_subset _ hIX)\n\n simp only [restrict_indep_iff, image_subset_iff, mem_maximals_iff, mem_setOf_eq, and_imp] at hJ\n\n obtain ⟨J₀, hIJ₀, hJ₀X, hbj⟩ := hIinj.bijOn_image.exists_extend_of_subset hIX\n (image_subset f hJ.1.2.1) (image_subset_iff.2 <| preimage_mono hJ.1.2.2)\n\n have him := hbj.image_eq; rw [image_preimage_eq_of_subset hJ.1.1.2] at him; subst him\n use J₀\n simp only [mem_maximals_iff, mem_setOf_eq, hJ.1.1.1, hbj.injOn, and_self, hIJ₀,\n hJ₀X, and_imp, true_and]\n intro K hK hinj hIK hKX hJ₀K\n rw [← hinj.image_eq_image_iff hJ₀K Subset.rfl, hJ.2 hK (image_subset_range _ _)\n (fun e he ↦ ⟨e, hIK he, rfl⟩) (image_subset _ hKX) (image_subset _ hJ₀K)]\n subset_ground := fun I hI e heI ↦ hI.1.subset_ground ⟨e, heI, rfl⟩ }", "start": [ 110, 1 ], "end": [ 162, 74 ], "kind": "commanddeclaration" }, { "full_name": "Matroid.comap_indep_iff", "code": "@[simp] lemma comap_indep_iff : (N.comap f).Indep I ↔ N.Indep (f '' I) ∧ InjOn f I := Iff.rfl", "start": [ 164, 1 ], "end": [ 164, 94 ], "kind": "lemma" }, { "full_name": "Matroid.comap_ground_eq", "code": "@[simp] lemma comap_ground_eq (N : Matroid β) (f : α → β) : (N.comap f).E = f ⁻¹' N.E := rfl", "start": [ 166, 1 ], "end": [ 166, 93 ], "kind": "lemma" }, { "full_name": "Matroid.comap_dep_iff", "code": "@[simp] lemma comap_dep_iff :\n (N.comap f).Dep I ↔ N.Dep (f '' I) ∨ (N.Indep (f '' I) ∧ ¬ InjOn f I) := by\n rw [Dep, comap_indep_iff, not_and, comap_ground_eq, Dep, image_subset_iff]\n refine ⟨fun ⟨hi, h⟩ ↦ ?_, ?_⟩\n · rw [and_iff_left h, ← imp_iff_not_or]\n exact fun hI ↦ ⟨hI, hi hI⟩\n rintro (⟨hI, hIE⟩ | hI)\n · exact ⟨fun h ↦ (hI h).elim, hIE⟩\n rw [iff_true_intro hI.1, iff_true_intro hI.2, implies_true, true_and]\n simpa using hI.1.subset_ground", "start": [ 168, 1 ], "end": [ 177, 33 ], "kind": "lemma" }, { "full_name": "Matroid.comap_id", "code": "@[simp] lemma comap_id (N : Matroid β) : N.comap id = N :=\n eq_of_indep_iff_indep_forall rfl <| by simp [injective_id.injOn]", "start": [ 179, 1 ], "end": [ 180, 67 ], "kind": "lemma" }, { "full_name": "Matroid.comap_indep_iff_of_injOn", "code": "lemma comap_indep_iff_of_injOn (hf : InjOn f (f ⁻¹' N.E)) :\n (N.comap f).Indep I ↔ N.Indep (f '' I) := by\n rw [comap_indep_iff, and_iff_left_iff_imp]\n refine fun hi ↦ hf.mono <| subset_trans ?_ (preimage_mono hi.subset_ground)\n apply subset_preimage_image", "start": [ 182, 1 ], "end": [ 186, 30 ], "kind": "lemma" }, { "full_name": "Matroid.comap_emptyOn", "code": "@[simp] lemma comap_emptyOn (f : α → β) : comap (emptyOn β) f = emptyOn α := by\n simp [← ground_eq_empty_iff]", "start": [ 188, 1 ], "end": [ 189, 31 ], "kind": "lemma" }, { "full_name": "Matroid.comap_loopyOn", "code": "@[simp] lemma comap_loopyOn (f : α → β) (E : Set β) : comap (loopyOn E) f = loopyOn (f ⁻¹' E) := by\n rw [eq_loopyOn_iff]; aesop", "start": [ 191, 1 ], "end": [ 192, 29 ], "kind": "lemma" }, { "full_name": "Matroid.comap_basis_iff", "code": "@[simp] lemma comap_basis_iff {I X : Set α} :\n (N.comap f).Basis I X ↔ N.Basis (f '' I) (f '' X) ∧ I.InjOn f ∧ I ⊆ X := by\n refine ⟨fun h ↦ ?_, fun h ↦ ?_⟩\n · obtain ⟨hI, hinj⟩ := comap_indep_iff.1 h.indep\n refine ⟨hI.basis_of_forall_insert (image_subset f h.subset) fun e he ↦ ?_, hinj, h.subset⟩\n simp only [mem_diff, mem_image, not_exists, not_and, and_imp, forall_exists_index,\n forall_apply_eq_imp_iff₂] at he\n obtain ⟨⟨e, heX, rfl⟩, he⟩ := he\n have heI : e ∉ I := fun heI ↦ (he e heI rfl)\n replace h := h.insert_dep ⟨heX, heI⟩\n simp only [comap_dep_iff, image_insert_eq, or_iff_not_imp_right, injOn_insert heI,\n hinj, mem_image, not_exists, not_and, true_and, not_forall, Classical.not_imp, not_not] at h\n exact h (fun _ ↦ he)\n refine Indep.basis_of_forall_insert ?_ h.2.2 fun e ⟨heX, heI⟩ ↦ ?_\n · simp [comap_indep_iff, h.1.indep, h.2]\n have hIE : insert e I ⊆ (N.comap f).E := by\n simp_rw [comap_ground_eq, ← image_subset_iff]\n exact (image_subset _ (insert_subset heX h.2.2)).trans h.1.subset_ground\n suffices N.Indep (insert (f e) (f '' I)) → ∃ x ∈ I, f x = f e\n by simpa [← not_indep_iff hIE, injOn_insert heI, h.2.1, image_insert_eq]\n exact h.1.mem_of_insert_indep (mem_image_of_mem f heX)", "start": [ 194, 1 ], "end": [ 214, 57 ], "kind": "lemma" }, { "full_name": "Matroid.comap_base_iff", "code": "@[simp] lemma comap_base_iff {B : Set α} :\n (N.comap f).Base B ↔ N.Basis (f '' B) (f '' (f ⁻¹' N.E)) ∧ B.InjOn f ∧ B ⊆ f ⁻¹' N.E := by\n rw [← basis_ground_iff, comap_basis_iff]; rfl", "start": [ 216, 1 ], "end": [ 218, 48 ], "kind": "lemma" }, { "full_name": "Matroid.comap_basis'_iff", "code": "@[simp] lemma comap_basis'_iff {I X : Set α} :\n (N.comap f).Basis' I X ↔ N.Basis' (f '' I) (f '' X) ∧ I.InjOn f ∧ I ⊆ X := by\n simp only [basis'_iff_basis_inter_ground, comap_ground_eq, comap_basis_iff, image_inter_preimage,\n subset_inter_iff, ← and_assoc, and_congr_left_iff, and_iff_left_iff_imp, and_imp]\n exact fun h _ _ ↦ (image_subset_iff.1 h.indep.subset_ground)", "start": [ 220, 1 ], "end": [ 224, 63 ], "kind": "lemma" }, { "full_name": "Matroid.comap_finitary", "code": "instance comap_finitary (N : Matroid β) [N.Finitary] (f : α → β) : (N.comap f).Finitary := by\n refine ⟨fun I hI ↦ ?_⟩\n rw [comap_indep_iff, indep_iff_forall_finite_subset_indep]\n simp only [forall_subset_image_iff]\n refine ⟨fun J hJ hfin ↦ ?_,\n fun x hx y hy ↦ (hI _ (pair_subset hx hy) (by simp)).2 (by simp) (by simp)⟩\n obtain ⟨J', hJ'J, hJ'⟩ := (surjOn_image f J).exists_bijOn_subset\n rw [← hJ'.image_eq] at hfin ⊢\n exact (hI J' (hJ'J.trans hJ) (hfin.of_finite_image hJ'.injOn)).1", "start": [ 226, 1 ], "end": [ 234, 67 ], "kind": "commanddeclaration" }, { "full_name": "Matroid.comap_finiteRk", "code": "instance comap_finiteRk (N : Matroid β) [N.FiniteRk] (f : α → β) : (N.comap f).FiniteRk := by\n obtain ⟨B, hB⟩ := (N.comap f).exists_base\n refine hB.finiteRk_of_finite ?_\n simp only [comap_base_iff] at hB\n exact (hB.1.indep.finite.of_finite_image hB.2.1)", "start": [ 236, 1 ], "end": [ 240, 51 ], "kind": "commanddeclaration" }, { "full_name": "Matroid.comapOn", "code": "def comapOn (N : Matroid β) (E : Set α) (f : α → β) : Matroid α := (N.comap f) ↾ E", "start": [ 248, 1 ], "end": [ 252, 83 ], "kind": "commanddeclaration" }, { "full_name": "Matroid.comapOn_preimage_eq", "code": "lemma comapOn_preimage_eq (N : Matroid β) (f : α → β) : N.comapOn (f ⁻¹' N.E) f = N.comap f := by\n rw [comapOn, restrict_eq_self_iff]; rfl", "start": [ 254, 1 ], "end": [ 255, 42 ], "kind": "lemma" }, { "full_name": "Matroid.comapOn_indep_iff", "code": "@[simp] lemma comapOn_indep_iff :\n (N.comapOn E f).Indep I ↔ (N.Indep (f '' I) ∧ InjOn f I ∧ I ⊆ E) := by\n simp [comapOn, and_assoc]", "start": [ 257, 1 ], "end": [ 259, 28 ], "kind": "lemma" }, { "full_name": "Matroid.comapOn_ground_eq", "code": "@[simp] lemma comapOn_ground_eq : (N.comapOn E f).E = E := rfl", "start": [ 261, 1 ], "end": [ 261, 63 ], "kind": "lemma" }, { "full_name": "Matroid.comapOn_base_iff", "code": "lemma comapOn_base_iff :\n (N.comapOn E f).Base B ↔ N.Basis' (f '' B) (f '' E) ∧ B.InjOn f ∧ B ⊆ E := by\n rw [comapOn, base_restrict_iff', comap_basis'_iff]", "start": [ 263, 1 ], "end": [ 265, 53 ], "kind": "lemma" }, { "full_name": "Matroid.comapOn_base_iff_of_surjOn", "code": "lemma comapOn_base_iff_of_surjOn (h : SurjOn f E N.E) :\n (N.comapOn E f).Base B ↔ (N.Base (f '' B) ∧ InjOn f B ∧ B ⊆ E) := by\n simp_rw [comapOn_base_iff, and_congr_left_iff, and_imp,\n basis'_iff_basis_inter_ground, inter_eq_self_of_subset_right h, basis_ground_iff, implies_true]", "start": [ 267, 1 ], "end": [ 270, 100 ], "kind": "lemma" }, { "full_name": "Matroid.comapOn_base_iff_of_bijOn", "code": "lemma comapOn_base_iff_of_bijOn (h : BijOn f E N.E) :\n (N.comapOn E f).Base B ↔ N.Base (f '' B) ∧ B ⊆ E := by\n rw [← and_iff_left_of_imp (Base.subset_ground (M := N.comapOn E f) (B := B)),\n comapOn_ground_eq, and_congr_left_iff]\n suffices h' : B ⊆ E → InjOn f B from fun hB ↦\n by simp [hB, comapOn_base_iff_of_surjOn h.surjOn, h']\n exact fun hBE ↦ h.injOn.mono hBE", "start": [ 272, 1 ], "end": [ 278, 35 ], "kind": "lemma" }, { "full_name": "Matroid.comapOn_dual_eq_of_bijOn", "code": "lemma comapOn_dual_eq_of_bijOn (h : BijOn f E N.E) :\n (N.comapOn E f)✶ = N✶.comapOn E f := by\n refine eq_of_base_iff_base_forall (by simp) (fun B hB ↦ ?_)\n rw [comapOn_base_iff_of_bijOn (by simpa), dual_base_iff, comapOn_base_iff_of_bijOn h,\n dual_base_iff _, comapOn_ground_eq, and_iff_left diff_subset, and_iff_left (by simpa),\n h.injOn.image_diff_subset (by simpa), h.image_eq]\n exact (h.mapsTo.mono_left (show B ⊆ E by simpa)).image_subset", "start": [ 280, 1 ], "end": [ 286, 64 ], "kind": "lemma" }, { "full_name": "Matroid.comapOn_finitary", "code": "instance comapOn_finitary [N.Finitary] : (N.comapOn E f).Finitary := by\n rw [comapOn]; infer_instance", "start": [ 288, 1 ], "end": [ 289, 31 ], "kind": "commanddeclaration" }, { "full_name": "Matroid.comapOn_finiteRk", "code": "instance comapOn_finiteRk [N.FiniteRk] : (N.comapOn E f).FiniteRk := by\n rw [comapOn]; infer_instance", "start": [ 291, 1 ], "end": [ 292, 31 ], "kind": "commanddeclaration" }, { "full_name": "Matroid.mapSetEmbedding", "code": "def mapSetEmbedding (M : Matroid α) (f : M.E ↪ β) : Matroid β := Matroid.ofExistsMatroid\n (E := range f)\n (Indep := fun I ↦ M.Indep ↑(f ⁻¹' I) ∧ I ⊆ range f)\n (hM := by\n classical\n obtain (rfl | ⟨⟨e,he⟩⟩) := eq_emptyOn_or_nonempty M\n · refine ⟨emptyOn β, ?_⟩\n simp only [emptyOn_ground] at f\n simp [range_eq_empty f, subset_empty_iff]\n have _ : Nonempty M.E := ⟨⟨e,he⟩⟩\n have _ : Nonempty α := ⟨e⟩\n refine ⟨M.comapOn (range f) (fun x ↦ ↑(invFunOn f univ x)), rfl, ?_⟩\n simp_rw [comapOn_indep_iff, ← and_assoc, and_congr_left_iff, subset_range_iff_exists_image_eq]\n rintro _ ⟨I, rfl⟩\n rw [← image_image, InjOn.invFunOn_image f.injective.injOn (subset_univ _),\n preimage_image_eq _ f.injective, and_iff_left_iff_imp]\n rintro - x hx y hy\n simp only [EmbeddingLike.apply_eq_iff_eq, Subtype.val_inj]\n exact (invFunOn_injOn_image f univ) (image_subset f (subset_univ I) hx)\n (image_subset f (subset_univ I) hy) )", "start": [ 297, 1 ], "end": [ 317, 44 ], "kind": "commanddeclaration" }, { "full_name": "Matroid.mapSetEmbedding_ground", "code": "@[simp] lemma mapSetEmbedding_ground (M : Matroid α) (f : M.E ↪ β) :\n (M.mapSetEmbedding f).E = range f := rfl", "start": [ 319, 1 ], "end": [ 320, 45 ], "kind": "lemma" }, { "full_name": "Matroid.mapSetEmbedding_indep_iff", "code": "@[simp] lemma mapSetEmbedding_indep_iff {f : M.E ↪ β} {I : Set β} :\n (M.mapSetEmbedding f).Indep I ↔ M.Indep ↑(f ⁻¹' I) ∧ I ⊆ range f := Iff.rfl", "start": [ 322, 1 ], "end": [ 323, 80 ], "kind": "lemma" }, { "full_name": "Matroid.Indep.exists_eq_image_of_mapSetEmbedding", "code": "lemma Indep.exists_eq_image_of_mapSetEmbedding {f : M.E ↪ β} {I : Set β}\n (hI : (M.mapSetEmbedding f).Indep I) : ∃ (I₀ : Set M.E), M.Indep I₀ ∧ I = f '' I₀ :=\n ⟨f ⁻¹' I, hI.1, Eq.symm <| image_preimage_eq_of_subset hI.2⟩", "start": [ 325, 1 ], "end": [ 327, 63 ], "kind": "lemma" }, { "full_name": "Matroid.mapSetEmbedding_indep_iff'", "code": "lemma mapSetEmbedding_indep_iff' {f : M.E ↪ β} {I : Set β} :\n (M.mapSetEmbedding f).Indep I ↔ ∃ (I₀ : Set M.E), M.Indep ↑I₀ ∧ I = f '' I₀ := by\n simp only [mapSetEmbedding_indep_iff, subset_range_iff_exists_image_eq]\n constructor\n · rintro ⟨hI, I, rfl⟩\n exact ⟨I, by rwa [preimage_image_eq _ f.injective] at hI, rfl⟩\n rintro ⟨I, hI, rfl⟩\n rw [preimage_image_eq _ f.injective]\n exact ⟨hI, _, rfl⟩", "start": [ 329, 1 ], "end": [ 337, 21 ], "kind": "lemma" }, { "full_name": "Matroid.map", "code": "def map (M : Matroid α) (f : α → β) (hf : InjOn f M.E) : Matroid β := Matroid.ofExistsMatroid\n (E := f '' M.E)\n (Indep := fun I ↦ ∃ I₀, M.Indep I₀ ∧ I = f '' I₀)\n (hM := by\n refine ⟨M.mapSetEmbedding ⟨_, hf.injective⟩, by simp, fun I ↦ ?_⟩\n simp_rw [mapSetEmbedding_indep_iff', Embedding.coeFn_mk, restrict_apply,\n ← image_image f Subtype.val, Subtype.exists_set_subtype (p := fun J ↦ M.Indep J ∧ I = f '' J)]\n exact ⟨fun ⟨I₀, _, hI₀⟩ ↦ ⟨I₀, hI₀⟩, fun ⟨I₀, hI₀⟩ ↦ ⟨I₀, hI₀.1.subset_ground, hI₀⟩⟩)", "start": [ 343, 1 ], "end": [ 353, 90 ], "kind": "commanddeclaration" }, { "full_name": "Matroid.map_ground", "code": "@[simp] lemma map_ground (M : Matroid α) (f : α → β) (hf) : (M.map f hf).E = f '' M.E := rfl", "start": [ 355, 1 ], "end": [ 355, 93 ], "kind": "lemma" }, { "full_name": "Matroid.map_indep_iff", "code": "@[simp] lemma map_indep_iff {hf} {I : Set β} :\n (M.map f hf).Indep I ↔ ∃ I₀, M.Indep I₀ ∧ I = f '' I₀ := Iff.rfl", "start": [ 357, 1 ], "end": [ 358, 69 ], "kind": "lemma" }, { "full_name": "Matroid.Indep.map", "code": "lemma Indep.map (hI : M.Indep I) (f : α → β) (hf) : (M.map f hf).Indep (f '' I) :=\n map_indep_iff.2 ⟨I, hI, rfl⟩", "start": [ 360, 1 ], "end": [ 361, 31 ], "kind": "lemma" }, { "full_name": "Matroid.Indep.exists_bijOn_of_map", "code": "lemma Indep.exists_bijOn_of_map {I : Set β} (hf) (hI : (M.map f hf).Indep I) :\n ∃ I₀, M.Indep I₀ ∧ BijOn f I₀ I := by\n obtain ⟨I₀, hI₀, rfl⟩ := hI\n exact ⟨I₀, hI₀, (hf.mono hI₀.subset_ground).bijOn_image⟩", "start": [ 363, 1 ], "end": [ 366, 59 ], "kind": "lemma" }, { "full_name": "Matroid.map_image_indep_iff", "code": "lemma map_image_indep_iff {hf} {I : Set α} (hI : I ⊆ M.E) :\n (M.map f hf).Indep (f '' I) ↔ M.Indep I := by\n rw [map_indep_iff]\n refine ⟨fun ⟨J, hJ, hIJ⟩ ↦ ?_, fun h ↦ ⟨I, h, rfl⟩⟩\n rw [hf.image_eq_image_iff hI hJ.subset_ground] at hIJ; rwa [hIJ]", "start": [ 368, 1 ], "end": [ 372, 67 ], "kind": "lemma" }, { "full_name": "Matroid.map_base_iff", "code": "@[simp] lemma map_base_iff (M : Matroid α) (f : α → β) (hf) {B : Set β} :\n (M.map f hf).Base B ↔ ∃ B₀, M.Base B₀ ∧ B = f '' B₀ := by\n rw [base_iff_maximal_indep]\n refine ⟨fun ⟨h, h'⟩ ↦ ?_, ?_⟩\n · obtain ⟨B₀, hB₀, hbij⟩ := h.exists_bijOn_of_map\n refine ⟨B₀, hB₀.base_of_maximal fun J hJ hB₀J ↦ ?_, hbij.image_eq.symm⟩\n rw [← hf.image_eq_image_iff hB₀.subset_ground hJ.subset_ground]\n exact hbij.image_eq ▸ h' _ (hJ.map f hf) (hbij.image_eq ▸ image_subset f hB₀J)\n rintro ⟨B, hB, rfl⟩\n refine ⟨hB.indep.map f hf, fun I hI hBI ↦ ?_⟩\n obtain ⟨I₀, hI₀, hbij⟩ := hI.exists_bijOn_of_map\n rw [← hbij.image_eq, hf.image_subset_image_iff hB.subset_ground hI₀.subset_ground] at hBI\n rw [hB.eq_of_subset_indep hI₀ hBI, hbij.image_eq]", "start": [ 374, 1 ], "end": [ 386, 52 ], "kind": "lemma" }, { "full_name": "Matroid.Base.map", "code": "lemma Base.map {B : Set α} (hB : M.Base B) {f : α → β} (hf) : (M.map f hf).Base (f '' B) := by\n rw [map_base_iff]; exact ⟨B, hB, rfl⟩", "start": [ 388, 1 ], "end": [ 389, 40 ], "kind": "lemma" }, { "full_name": "Matroid.map_dep_iff", "code": "lemma map_dep_iff {hf} {D : Set β} :\n (M.map f hf).Dep D ↔ ∃ D₀, M.Dep D₀ ∧ D = f '' D₀ := by\n simp only [Dep, map_indep_iff, not_exists, not_and, map_ground, subset_image_iff]\n constructor\n · rintro ⟨h, D₀, hD₀E, rfl⟩\n exact ⟨D₀, ⟨fun hd ↦ h _ hd rfl, hD₀E⟩, rfl⟩\n rintro ⟨D₀, ⟨hD₀, hD₀E⟩, rfl⟩\n refine ⟨fun I hI h_eq ↦ ?_, ⟨_, hD₀E, rfl⟩⟩\n rw [hf.image_eq_image_iff hD₀E hI.subset_ground] at h_eq\n subst h_eq; contradiction", "start": [ 391, 1 ], "end": [ 400, 28 ], "kind": "lemma" }, { "full_name": "Matroid.map_image_base_iff", "code": "lemma map_image_base_iff {hf} {B : Set α} (hB : B ⊆ M.E) :\n (M.map f hf).Base (f '' B) ↔ M.Base B := by\n rw [map_base_iff]\n refine ⟨fun ⟨J, hJ, hIJ⟩ ↦ ?_, fun h ↦ ⟨B, h, rfl⟩⟩\n rw [hf.image_eq_image_iff hB hJ.subset_ground] at hIJ; rwa [hIJ]", "start": [ 402, 1 ], "end": [ 406, 67 ], "kind": "lemma" }, { "full_name": "Matroid.Basis.map", "code": "lemma Basis.map {X : Set α} (hIX : M.Basis I X) {f : α → β} (hf) :\n (M.map f hf).Basis (f '' I) (f '' X) := by\n refine (hIX.indep.map f hf).basis_of_forall_insert (image_subset _ hIX.subset) ?_\n rintro _ ⟨⟨e,he,rfl⟩, he'⟩\n have hss := insert_subset (hIX.subset_ground he) hIX.indep.subset_ground\n rw [← not_indep_iff (by simpa [← image_insert_eq] using image_subset f hss)]\n simp only [map_indep_iff, not_exists, not_and]\n intro J hJ hins\n rw [← image_insert_eq, hf.image_eq_image_iff hss hJ.subset_ground] at hins\n obtain rfl := hins\n exact he' (mem_image_of_mem f (hIX.mem_of_insert_indep he hJ))", "start": [ 408, 1 ], "end": [ 418, 65 ], "kind": "lemma" }, { "full_name": "Matroid.map_basis_iff", "code": "lemma map_basis_iff {I X : Set α} (f : α → β) (hf) (hI : I ⊆ M.E) (hX : X ⊆ M.E) :\n (M.map f hf).Basis (f '' I) (f '' X) ↔ M.Basis I X := by\n refine ⟨fun h ↦ ?_, fun h ↦ h.map hf⟩\n obtain ⟨I', hI', hII'⟩ := map_indep_iff.1 h.indep\n rw [hf.image_eq_image_iff hI hI'.subset_ground] at hII'\n obtain rfl := hII'\n have hss := (hf.image_subset_image_iff hI hX).1 h.subset\n refine hI'.basis_of_maximal_subset hss (fun J hJ hIJ hJX ↦ ?_)\n have hIJ' := h.eq_of_subset_indep (hJ.map f hf) (image_subset f hIJ) (image_subset f hJX)\n rw [hf.image_eq_image_iff hI hJ.subset_ground] at hIJ'\n exact hIJ'.symm.subset", "start": [ 420, 1 ], "end": [ 430, 25 ], "kind": "lemma" }, { "full_name": "Matroid.map_basis_iff'", "code": "lemma map_basis_iff' {I X : Set β} {hf} :\n (M.map f hf).Basis I X ↔ ∃ I₀ X₀, M.Basis I₀ X₀ ∧ I = f '' I₀ ∧ X = f '' X₀ := by\n refine ⟨fun h ↦ ?_, ?_⟩\n · obtain ⟨I, hI, rfl⟩ := subset_image_iff.1 h.indep.subset_ground\n obtain ⟨X, hX, rfl⟩ := subset_image_iff.1 h.subset_ground\n rw [map_basis_iff _ _ hI hX] at h\n exact ⟨I, X, h, rfl, rfl⟩\n rintro ⟨I, X, hIX, rfl, rfl⟩\n exact hIX.map hf", "start": [ 432, 1 ], "end": [ 440, 19 ], "kind": "lemma" }, { "full_name": "Matroid.map_dual", "code": "@[simp] lemma map_dual {hf} : (M.map f hf)✶ = M✶.map f hf := by\n apply eq_of_base_iff_base_forall (by simp)\n simp only [dual_ground, map_ground, subset_image_iff, forall_exists_index, and_imp,\n forall_apply_eq_imp_iff₂, dual_base_iff']\n intro B hB\n simp_rw [← hf.image_diff_subset hB, map_image_base_iff diff_subset,\n map_image_base_iff (show B ⊆ M✶.E from hB), dual_base_iff hB, and_iff_left_iff_imp]\n exact fun _ ↦ ⟨B, hB, rfl⟩", "start": [ 442, 1 ], "end": [ 449, 29 ], "kind": "lemma" }, { "full_name": "Matroid.map_emptyOn", "code": "@[simp] lemma map_emptyOn (f : α → β) : (emptyOn α).map f (by simp) = emptyOn β := by\n simp [← ground_eq_empty_iff]", "start": [ 451, 1 ], "end": [ 452, 31 ], "kind": "lemma" }, { "full_name": "Matroid.map_loopyOn", "code": "@[simp] lemma map_loopyOn (f : α → β) (hf) : (loopyOn E).map f hf = loopyOn (f '' E) := by\n simp [eq_loopyOn_iff]", "start": [ 454, 1 ], "end": [ 455, 24 ], "kind": "lemma" }, { "full_name": "Matroid.map_freeOn", "code": "@[simp] lemma map_freeOn (f : α → β) (hf) : (freeOn E).map f hf = freeOn (f '' E) := by\n rw [← dual_inj]; simp", "start": [ 457, 1 ], "end": [ 458, 24 ], "kind": "lemma" }, { "full_name": "Matroid.map_id", "code": "@[simp] lemma map_id : M.map id (injOn_id M.E) = M := by\n simp [eq_iff_indep_iff_indep_forall]", "start": [ 460, 1 ], "end": [ 461, 39 ], "kind": "lemma" }, { "full_name": "Matroid.map_comap", "code": "lemma map_comap {f : α → β} (h_range : N.E ⊆ range f) (hf : InjOn f (f ⁻¹' N.E)) :\n (N.comap f).map f hf = N := by\n refine eq_of_indep_iff_indep_forall (by simpa [image_preimage_eq_iff]) ?_\n simp only [map_ground, comap_ground_eq, map_indep_iff, comap_indep_iff, forall_subset_image_iff]\n refine fun I hI ↦ ⟨fun ⟨I₀, ⟨hI₀, _⟩, hII₀⟩ ↦ ?_, fun h ↦ ⟨_, ⟨h, hf.mono hI⟩, rfl⟩⟩\n suffices h : I₀ ⊆ f ⁻¹' N.E by rw [InjOn.image_eq_image_iff hf hI h] at hII₀; rwa [hII₀]\n exact (subset_preimage_image f I₀).trans <| preimage_mono (f := f) hI₀.subset_ground", "start": [ 463, 1 ], "end": [ 469, 87 ], "kind": "lemma" }, { "full_name": "Matroid.comap_map", "code": "lemma comap_map {f : α → β} (hf : f.Injective) : (M.map f hf.injOn).comap f = M := by\n simp [eq_iff_indep_iff_indep_forall, preimage_image_eq _ hf, and_iff_left hf.injOn,\n image_eq_image hf]", "start": [ 471, 1 ], "end": [ 473, 23 ], "kind": "lemma" }, { "full_name": "Matroid.mapSetEquiv", "code": "def mapSetEquiv (M : Matroid α) {E : Set β} (e : M.E ≃ E) : Matroid β :=\n Matroid.ofExistsMatroid E (fun I ↦ (M.Indep ↑(e.symm '' (E ↓∩ I)) ∧ I ⊆ E))\n ⟨M.mapSetEmbedding (e.toEmbedding.trans <| Function.Embedding.subtype _), by\n have hrw : ∀ I : Set β, Subtype.val ∘ ⇑e ⁻¹' I = ⇑e.symm '' E ↓∩ I := fun I ↦ by ext; simp\n simp [Equiv.toEmbedding, Embedding.subtype, Embedding.trans, hrw]⟩", "start": [ 505, 1 ], "end": [ 511, 71 ], "kind": "commanddeclaration" }, { "full_name": "Matroid.mapSetEquiv_indep_iff", "code": "@[simp] lemma mapSetEquiv_indep_iff (M : Matroid α) {E : Set β} (e : M.E ≃ E) {I : Set β} :\n (M.mapSetEquiv e).Indep I ↔ M.Indep ↑(e.symm '' (E ↓∩ I)) ∧ I ⊆ E := Iff.rfl", "start": [ 513, 1 ], "end": [ 514, 81 ], "kind": "lemma" }, { "full_name": "Matroid.mapSetEquiv.ground", "code": "@[simp] lemma mapSetEquiv.ground (M : Matroid α) {E : Set β} (e : M.E ≃ E) :\n (M.mapSetEquiv e).E = E := rfl", "start": [ 516, 1 ], "end": [ 517, 35 ], "kind": "lemma" }, { "full_name": "Matroid.mapEmbedding", "code": "def mapEmbedding (M : Matroid α) (f : α ↪ β) : Matroid β := M.map f f.injective.injOn", "start": [ 521, 1 ], "end": [ 522, 86 ], "kind": "commanddeclaration" }, { "full_name": "Matroid.mapEmbedding_ground_eq", "code": "@[simp] lemma mapEmbedding_ground_eq (M : Matroid α) (f : α ↪ β) :\n (M.mapEmbedding f).E = f '' M.E := rfl", "start": [ 524, 1 ], "end": [ 525, 43 ], "kind": "lemma" }, { "full_name": "Matroid.mapEmbedding_indep_iff", "code": "@[simp] lemma mapEmbedding_indep_iff {f : α ↪ β} {I : Set β} :\n (M.mapEmbedding f).Indep I ↔ M.Indep (f ⁻¹' I) ∧ I ⊆ range f := by\n rw [mapEmbedding, map_indep_iff]\n refine ⟨?_, fun ⟨h,h'⟩ ↦ ⟨f ⁻¹' I, h, by rwa [eq_comm, image_preimage_eq_iff]⟩⟩\n rintro ⟨I, hI, rfl⟩\n rw [preimage_image_eq _ f.injective]\n exact ⟨hI, image_subset_range _ _⟩", "start": [ 527, 1 ], "end": [ 533, 37 ], "kind": "lemma" }, { "full_name": "Matroid.Indep.mapEmbedding", "code": "lemma Indep.mapEmbedding (hI : M.Indep I) (f : α ↪ β) : (M.mapEmbedding f).Indep (f '' I) := by\n simpa [preimage_image_eq I f.injective]", "start": [ 535, 1 ], "end": [ 536, 42 ], "kind": "lemma" }, { "full_name": "Matroid.Base.mapEmbedding", "code": "lemma Base.mapEmbedding {B : Set α} (hB : M.Base B) (f : α ↪ β) :\n (M.mapEmbedding f).Base (f '' B) := by\n rw [Matroid.mapEmbedding, map_base_iff]\n exact ⟨B, hB, rfl⟩", "start": [ 538, 1 ], "end": [ 541, 21 ], "kind": "lemma" }, { "full_name": "Matroid.Basis.mapEmbedding", "code": "lemma Basis.mapEmbedding {X : Set α} (hIX : M.Basis I X) (f : α ↪ β) :\n (M.mapEmbedding f).Basis (f '' I) (f '' X) := by\n apply hIX.map", "start": [ 543, 1 ], "end": [ 545, 16 ], "kind": "lemma" }, { "full_name": "Matroid.mapEquiv", "code": "def mapEquiv (M : Matroid α) (f : α ≃ β) : Matroid β := M.mapEmbedding f.toEmbedding", "start": [ 568, 1 ], "end": [ 569, 85 ], "kind": "commanddeclaration" }, { "full_name": "Matroid.mapEquiv_ground_eq", "code": "@[simp] lemma mapEquiv_ground_eq (M : Matroid α) (f : α ≃ β) :\n (M.mapEquiv f).E = f '' M.E := rfl", "start": [ 571, 1 ], "end": [ 572, 39 ], "kind": "lemma" }, { "full_name": "Matroid.mapEquiv_eq_map", "code": "lemma mapEquiv_eq_map (f : α ≃ β) : M.mapEquiv f = M.map f f.injective.injOn := rfl", "start": [ 574, 1 ], "end": [ 574, 84 ], "kind": "lemma" }, { "full_name": "Matroid.mapEquiv_indep_iff", "code": "@[simp] lemma mapEquiv_indep_iff {I : Set β} : (M.mapEquiv f).Indep I ↔ M.Indep (f.symm '' I) := by\n rw [mapEquiv_eq_map, map_indep_iff]\n exact ⟨by rintro ⟨I, hI, rfl⟩; simpa, fun h ↦ ⟨_, h, by simp⟩⟩", "start": [ 576, 1 ], "end": [ 578, 65 ], "kind": "lemma" }, { "full_name": "Matroid.mapEquiv_dep_iff", "code": "@[simp] lemma mapEquiv_dep_iff {D : Set β} : (M.mapEquiv f).Dep D ↔ M.Dep (f.symm '' D) := by\n rw [mapEquiv_eq_map, map_dep_iff]\n exact ⟨by rintro ⟨I, hI, rfl⟩; simpa, fun h ↦ ⟨_, h, by simp⟩⟩", "start": [ 580, 1 ], "end": [ 582, 65 ], "kind": "lemma" }, { "full_name": "Matroid.mapEquiv_base_iff", "code": "@[simp] lemma mapEquiv_base_iff {B : Set β} : (M.mapEquiv f).Base B ↔ M.Base (f.symm '' B) := by\n rw [mapEquiv_eq_map, map_base_iff]\n exact ⟨by rintro ⟨I, hI, rfl⟩; simpa, fun h ↦ ⟨_, h, by simp⟩⟩", "start": [ 584, 1 ], "end": [ 586, 65 ], "kind": "lemma" }, { "full_name": "Matroid.restrictSubtype", "code": "def restrictSubtype (M : Matroid α) (X : Set α) : Matroid X := (M ↾ X).comap (↑)", "start": [ 609, 1 ], "end": [ 612, 81 ], "kind": "commanddeclaration" }, { "full_name": "Matroid.restrictSubtype_ground", "code": "@[simp] lemma restrictSubtype_ground : (M.restrictSubtype X).E = univ := by\n simp [restrictSubtype]", "start": [ 614, 1 ], "end": [ 615, 25 ], "kind": "lemma" }, { "full_name": "Matroid.restrictSubtype_indep_iff", "code": "@[simp] lemma restrictSubtype_indep_iff {I : Set X} :\n (M.restrictSubtype X).Indep I ↔ M.Indep ((↑) '' I) := by\n simp [restrictSubtype, Subtype.val_injective.injOn]", "start": [ 617, 1 ], "end": [ 619, 54 ], "kind": "lemma" }, { "full_name": "Matroid.restrictSubtype_indep_iff_of_subset", "code": "lemma restrictSubtype_indep_iff_of_subset (hIX : I ⊆ X) :\n (M.restrictSubtype X).Indep (X ↓∩ I) ↔ M.Indep I := by\n rw [restrictSubtype_indep_iff, image_preimage_eq_iff.2]; simpa", "start": [ 621, 1 ], "end": [ 623, 65 ], "kind": "lemma" }, { "full_name": "Matroid.restrictSubtype_inter_indep_iff", "code": "lemma restrictSubtype_inter_indep_iff :\n (M.restrictSubtype X).Indep (X ↓∩ I) ↔ M.Indep (X ∩ I) := by\n simp [restrictSubtype, Subtype.val_injective.injOn]", "start": [ 625, 1 ], "end": [ 627, 54 ], "kind": "lemma" }, { "full_name": "Matroid.eq_of_restrictSubtype_eq", "code": "lemma eq_of_restrictSubtype_eq {N : Matroid α} (hM : M.E = E) (hN : N.E = E)\n (h : M.restrictSubtype E = N.restrictSubtype E) : M = N := by\n subst hM\n refine eq_of_indep_iff_indep_forall (by rw [hN]) (fun I hI ↦ ?_)\n rwa [← restrictSubtype_indep_iff_of_subset hI, h, restrictSubtype_indep_iff_of_subset]", "start": [ 629, 1 ], "end": [ 633, 89 ], "kind": "lemma" }, { "full_name": "Matroid.restrictSubtype_dual", "code": "@[simp] lemma restrictSubtype_dual : (M.restrictSubtype M.E)✶ = M✶.restrictSubtype M.E := by\n rw [restrictSubtype, ← comapOn_preimage_eq, comapOn_dual_eq_of_bijOn, restrict_ground_eq_self,\n ← dual_ground, comapOn_preimage_eq, restrictSubtype, restrict_ground_eq_self]\n exact ⟨by simp [MapsTo], Subtype.val_injective.injOn, by simp [SurjOn, Subset.rfl]⟩", "start": [ 635, 1 ], "end": [ 638, 86 ], "kind": "lemma" }, { "full_name": "Matroid.restrictSubtype_dual'", "code": "lemma restrictSubtype_dual' (hM : M.E = E) : (M.restrictSubtype E)✶ = M✶.restrictSubtype E := by\n rw [← hM, restrictSubtype_dual]", "start": [ 640, 1 ], "end": [ 641, 34 ], "kind": "lemma" }, { "full_name": "Matroid.map_val_restrictSubtype_eq", "code": "@[simp] lemma map_val_restrictSubtype_eq (M : Matroid α) (X : Set α) :\n (M.restrictSubtype X).map (↑) Subtype.val_injective.injOn = M ↾ X := by\n simp [restrictSubtype, map_comap, Subset.rfl]", "start": [ 643, 1 ], "end": [ 646, 48 ], "kind": "lemma" }, { "full_name": "Matroid.map_val_restrictSubtype_ground_eq", "code": "lemma map_val_restrictSubtype_ground_eq (M : Matroid α) :\n (M.restrictSubtype M.E).map (↑) Subtype.val_injective.injOn = M := by\n simp", "start": [ 648, 1 ], "end": [ 651, 7 ], "kind": "lemma" } ]

[ "Mathlib/Data/Sum/Order.lean", ".lake/packages/lean4/src/lean/Init.lean", "Mathlib/Order/Hom/Lattice.lean" ]

[ { "full_name": "Sum.Lex.instSemilatticeSup", "code": "instance instSemilatticeSup : SemilatticeSup (α ⊕ₗ β) where\n sup x y := match x, y with\n | inlₗ a₁, inlₗ a₂ => inl (a₁ ⊔ a₂)\n | inlₗ a₁, inrₗ b₂ => inr b₂\n | inrₗ b₁, inlₗ a₂ => inr b₁\n | inrₗ b₁, inrₗ b₂ => inr (b₁ ⊔ b₂)\n le_sup_left x y := match x, y with\n | inlₗ a₁, inlₗ a₂ => inl_le_inl_iff.2 le_sup_left\n | inlₗ a₁, inrₗ b₂ => inl_le_inr _ _\n | inrₗ b₁, inlₗ a₂ => le_rfl\n | inrₗ b₁, inrₗ b₂ => inr_le_inr_iff.2 le_sup_left\n le_sup_right x y := match x, y with\n | inlₗ a₁, inlₗ a₂ => inl_le_inl_iff.2 le_sup_right\n | inlₗ a₁, inrₗ b₂ => le_rfl\n | inrₗ b₁, inlₗ a₂ => inl_le_inr _ _\n | inrₗ b₁, inrₗ b₂ => inr_le_inr_iff.2 le_sup_right\n sup_le x y z hxz hyz := match x, y, z, hxz, hyz with\n | inlₗ a₁, inlₗ a₂, inlₗ a₃, Lex.inl h₁₃, Lex.inl h₂₃ => inl_le_inl_iff.2 <| sup_le h₁₃ h₂₃\n | inlₗ a₁, inlₗ a₂, inrₗ b₃, Lex.sep _ _, Lex.sep _ _ => Lex.sep _ _\n | inlₗ a₁, inrₗ b₂, inrₗ b₃, Lex.sep _ _, Lex.inr h₂₃ => inr_le_inr_iff.2 h₂₃\n | inrₗ b₁, inlₗ a₂, inrₗ b₃, Lex.inr h₁₃, Lex.sep _ _ => inr_le_inr_iff.2 h₁₃\n | inrₗ b₁, inrₗ b₂, inrₗ b₃, Lex.inr h₁₃, Lex.inr h₂₃ => inr_le_inr_iff.2 <| sup_le h₁₃ h₂₃", "start": [ 26, 1 ], "end": [ 47, 96 ], "kind": "commanddeclaration" }, { "full_name": "Sum.Lex.inl_sup", "code": "@[simp] lemma inl_sup (a₁ a₂ : α) : (inlₗ (a₁ ⊔ a₂) : α ⊕ β) = inlₗ a₁ ⊔ inlₗ a₂ := rfl", "start": [ 49, 1 ], "end": [ 49, 88 ], "kind": "lemma" }, { "full_name": "Sum.Lex.inr_sup", "code": "@[simp] lemma inr_sup (b₁ b₂ : β) : (inrₗ (b₁ ⊔ b₂) : α ⊕ β) = inrₗ b₁ ⊔ inrₗ b₂ := rfl", "start": [ 50, 1 ], "end": [ 50, 88 ], "kind": "lemma" }, { "full_name": "Sum.Lex.instSemilatticeInf", "code": "instance instSemilatticeInf : SemilatticeInf (α ⊕ₗ β) where\n inf x y := match x, y with\n | inlₗ a₁, inlₗ a₂ => inl (a₁ ⊓ a₂)\n | inlₗ a₁, inrₗ b₂ => inl a₁\n | inrₗ b₁, inlₗ a₂ => inl a₂\n | inrₗ b₁, inrₗ b₂ => inr (b₁ ⊓ b₂)\n inf_le_left x y := match x, y with\n | inlₗ a₁, inlₗ a₂ => inl_le_inl_iff.2 inf_le_left\n | inlₗ a₁, inrₗ b₂ => le_rfl\n | inrₗ b₁, inlₗ a₂ => inl_le_inr _ _\n | inrₗ b₁, inrₗ b₂ => inr_le_inr_iff.2 inf_le_left\n inf_le_right x y := match x, y with\n | inlₗ a₁, inlₗ a₂ => inl_le_inl_iff.2 inf_le_right\n | inlₗ a₁, inrₗ b₂ => inl_le_inr _ _\n | inrₗ b₁, inlₗ a₂ => le_rfl\n | inrₗ b₁, inrₗ b₂ => inr_le_inr_iff.2 inf_le_right\n le_inf x y z hzx hzy := match x, y, z, hzx, hzy with\n | inlₗ a₁, inlₗ a₂, inlₗ a₃, Lex.inl h₁₃, Lex.inl h₂₃ => inl_le_inl_iff.2 <| le_inf h₁₃ h₂₃\n | inlₗ a₁, inlₗ a₂, inrₗ b₃, Lex.inl h₁₃, Lex.sep _ _ => inl_le_inl_iff.2 h₁₃\n | inlₗ a₁, inrₗ b₂, inlₗ a₃, Lex.sep _ _, Lex.inl h₂₃ => inl_le_inl_iff.2 h₂₃\n | inlₗ a₁, inrₗ b₂, inrₗ b₃, Lex.sep _ _, Lex.sep _ _ => Lex.sep _ _\n | inrₗ b₁, inrₗ b₂, inrₗ b₃, Lex.inr h₁₃, Lex.inr h₂₃ => inr_le_inr_iff.2 <| le_inf h₁₃ h₂₃", "start": [ 59, 1 ], "end": [ 80, 96 ], "kind": "commanddeclaration" }, { "full_name": "Sum.Lex.inl_inf", "code": "@[simp] lemma inl_inf (a₁ a₂ : α) : (inlₗ (a₁ ⊓ a₂) : α ⊕ β) = inlₗ a₁ ⊓ inlₗ a₂ := rfl", "start": [ 82, 1 ], "end": [ 82, 88 ], "kind": "lemma" }, { "full_name": "Sum.Lex.inr_inf", "code": "@[simp] lemma inr_inf (b₁ b₂ : β) : (inrₗ (b₁ ⊓ b₂) : α ⊕ β) = inrₗ b₁ ⊓ inrₗ b₂ := rfl", "start": [ 83, 1 ], "end": [ 83, 88 ], "kind": "lemma" }, { "full_name": "Sum.Lex.instLattice", "code": "instance instLattice : Lattice (α ⊕ₗ β) := { instSemilatticeSup, instSemilatticeInf with }", "start": [ 90, 1 ], "end": [ 90, 91 ], "kind": "commanddeclaration" }, { "full_name": "Sum.Lex.inlLatticeHom", "code": "def inlLatticeHom : LatticeHom α (α ⊕ₗ β) where\n toFun := inlₗ\n map_sup' _ _ := rfl\n map_inf' _ _ := rfl", "start": [ 92, 1 ], "end": [ 96, 22 ], "kind": "commanddeclaration" }, { "full_name": "Sum.Lex.inrLatticeHom", "code": "def inrLatticeHom : LatticeHom β (α ⊕ₗ β) where\n toFun := inrₗ\n map_sup' _ _ := rfl\n map_inf' _ _ := rfl", "start": [ 98, 1 ], "end": [ 102, 22 ], "kind": "commanddeclaration" }, { "full_name": "Sum.Lex.instDistribLattice", "code": "instance instDistribLattice [DistribLattice α] [DistribLattice β] : DistribLattice (α ⊕ₗ β) where\n le_sup_inf := by\n simp only [Lex.forall, Sum.forall, ge_iff_le, inl_le_inl_iff, inr_le_inr_iff, sup_le_iff,\n le_sup_left, true_and, inl_le_inr, not_inr_le_inl, le_inf_iff, sup_of_le_right, and_self,\n inf_of_le_left, le_refl, implies_true, and_true, inf_of_le_right, sup_of_le_left, ← inl_sup,\n ← inr_sup, ← inl_inf, ← inr_inf, sup_inf_left, le_rfl]", "start": [ 106, 1 ], "end": [ 111, 61 ], "kind": "commanddeclaration" } ]

[ "Mathlib/NumberTheory/SumPrimeReciprocals.lean", "Mathlib/NumberTheory/VonMangoldt.lean", ".lake/packages/lean4/src/lean/Init.lean", "Mathlib/NumberTheory/LSeries/Deriv.lean", "Mathlib/NumberTheory/DirichletCharacter/Bounds.lean", "Mathlib/NumberTheory/LSeries/Convolution.lean", "Mathlib/NumberTheory/LSeries/RiemannZeta.lean" ]

[ { "full_name": "ArithmeticFunction.one_eq_delta", "code": "lemma ArithmeticFunction.one_eq_delta : ↗(1 : ArithmeticFunction ℂ) = δ := by\n ext\n simp only [one_apply, LSeries.delta]", "start": [ 36, 1 ], "end": [ 39, 39 ], "kind": "lemma" }, { "full_name": "ArithmeticFunction.not_LSeriesSummable_moebius_at_one", "code": "lemma not_LSeriesSummable_moebius_at_one : ¬ LSeriesSummable ↗μ 1 := by\n intro h\n refine not_summable_one_div_on_primes <| summable_ofReal.mp <| Summable.of_neg ?_\n simp only [← Pi.neg_def, Set.indicator_comp_of_zero ofReal_zero, ofReal_inv, ofReal_natCast]\n refine (h.indicator {n | n.Prime}).congr (fun n ↦ ?_)\n by_cases hn : n ∈ {p | p.Prime}\n · simp only [Pi.neg_apply, Set.indicator_of_mem hn, term_of_ne_zero hn.ne_zero,\n moebius_apply_prime hn, cpow_one, push_cast, neg_div]\n · simp only [one_div, Pi.neg_apply, Set.indicator_of_not_mem hn, ofReal_zero, neg_zero]", "start": [ 54, 1 ], "end": [ 62, 90 ], "kind": "lemma" }, { "full_name": "ArithmeticFunction.LSeriesSummable_moebius_iff", "code": "lemma LSeriesSummable_moebius_iff {s : ℂ} : LSeriesSummable ↗μ s ↔ 1 < s.re := by\n refine ⟨fun H ↦ ?_, LSeriesSummable_of_bounded_of_one_lt_re (m := 1) fun n _ ↦ ?_⟩\n · by_contra! h\n have h' : s.re ≤ (1 : ℂ).re := by simp only [one_re, h]\n exact not_LSeriesSummable_moebius_at_one <| LSeriesSummable.of_re_le_re h' H\n · rw [abs_intCast] norm_cast\n exact abs_moebius_le_one", "start": [ 64, 1 ], "end": [ 72, 29 ], "kind": "lemma" }, { "full_name": "ArithmeticFunction.abscissaOfAbsConv_moebius", "code": "lemma abscissaOfAbsConv_moebius : abscissaOfAbsConv ↗μ = 1 := by\n simpa only [abscissaOfAbsConv, LSeriesSummable_moebius_iff, ofReal_re, Set.Ioi_def,\n EReal.image_coe_Ioi, EReal.coe_one] using csInf_Ioo <| EReal.coe_lt_top _", "start": [ 74, 1 ], "end": [ 77, 78 ], "kind": "lemma" }, { "full_name": "ArithmeticFunction.const_one_eq_zeta", "code": "lemma ArithmeticFunction.const_one_eq_zeta {R : Type*} [Semiring R] {n : ℕ} (hn : n ≠ 0) :\n (1 : ℕ → R) n = (ζ ·) n := by\n simp only [Pi.one_apply, zeta_apply, hn, ↓reduceIte, cast_one]", "start": [ 91, 1 ], "end": [ 93, 65 ], "kind": "lemma" }, { "full_name": "LSeries.one_convolution_eq_zeta_convolution", "code": "lemma LSeries.one_convolution_eq_zeta_convolution {R : Type*} [Semiring R] (f : ℕ → R):\n (1 : ℕ → R) ⍟ f = ((ArithmeticFunction.zeta ·) : ℕ → R) ⍟ f :=\n convolution_congr ArithmeticFunction.const_one_eq_zeta fun _ ↦ rfl", "start": [ 95, 1 ], "end": [ 97, 69 ], "kind": "lemma" }, { "full_name": "LSeries.convolution_one_eq_convolution_zeta", "code": "lemma LSeries.convolution_one_eq_convolution_zeta {R : Type*} [Semiring R] (f : ℕ → R):\n f ⍟ (1 : ℕ → R) = f ⍟ ((ArithmeticFunction.zeta ·) : ℕ → R) :=\n convolution_congr (fun _ ↦ rfl) ArithmeticFunction.const_one_eq_zeta", "start": [ 99, 1 ], "end": [ 101, 71 ], "kind": "lemma" }, { "full_name": "DirichletCharacter.mul_convolution_distrib", "code": "lemma mul_convolution_distrib {R : Type*} [CommSemiring R] {n : ℕ} (χ : DirichletCharacter R n)\n (f g : ℕ → R) :\n (((χ ·) : ℕ → R) * f) ⍟ (((χ ·) : ℕ → R) * g) = ((χ ·) : ℕ → R) * (f ⍟ g) := by\n ext n\n simp only [Pi.mul_apply, LSeries.convolution_def, Finset.mul_sum]\n refine Finset.sum_congr rfl fun p hp ↦ ?_\n rw [(mem_divisorsAntidiagonal.mp hp).1.symm, cast_mul, map_mul]\n exact mul_mul_mul_comm ..", "start": [ 110, 1 ], "end": [ 118, 28 ], "kind": "lemma" }, { "full_name": "DirichletCharacter.mul_delta", "code": "lemma mul_delta {n : ℕ} (χ : DirichletCharacter ℂ n) : ↗χ * δ = δ :=\n LSeries.mul_delta <| by rw [cast_one, map_one]", "start": [ 120, 1 ], "end": [ 121, 49 ], "kind": "lemma" }, { "full_name": "DirichletCharacter.delta_mul", "code": "lemma delta_mul {n : ℕ} (χ : DirichletCharacter ℂ n) : δ * ↗χ = δ :=\n mul_comm δ _ ▸ mul_delta ..", "start": [ 123, 1 ], "end": [ 124, 30 ], "kind": "lemma" }, { "full_name": "DirichletCharacter.convolution_mul_moebius", "code": "lemma convolution_mul_moebius {n : ℕ} (χ : DirichletCharacter ℂ n) : ↗χ ⍟ (↗χ * ↗μ) = δ := by\n have : (1 : ℕ → ℂ) ⍟ (μ ·) = δ := by\n rw [one_convolution_eq_zeta_convolution, ← one_eq_delta]\n simp_rw [← natCoe_apply, ← intCoe_apply, coe_mul, coe_zeta_mul_coe_moebius]\n nth_rewrite 1 [← mul_one ↗χ]\n simpa only [mul_convolution_distrib χ 1 ↗μ, this] using mul_delta _", "start": [ 127, 1 ], "end": [ 134, 70 ], "kind": "lemma" }, { "full_name": "DirichletCharacter.modZero_eq_delta", "code": "lemma modZero_eq_delta {χ : DirichletCharacter ℂ 0} : ↗χ = δ := by\n ext n\n rcases eq_or_ne n 0 with rfl | hn\n · simp_rw [cast_zero, χ.map_nonunit not_isUnit_zero, delta, if_false]\n rcases eq_or_ne n 1 with rfl | hn'\n · simp only [cast_one, map_one, delta, ↓reduceIte]\n have : ¬ IsUnit (n : ZMod 0) := fun h ↦ hn' <| ZMod.eq_one_of_isUnit_natCast h\n simp only [χ.map_nonunit this, delta, hn', ↓reduceIte]", "start": [ 136, 1 ], "end": [ 144, 57 ], "kind": "lemma" }, { "full_name": "DirichletCharacter.modOne_eq_one", "code": "lemma modOne_eq_one {R : Type*} [CommSemiring R] {χ : DirichletCharacter R 1} :\n ((χ ·) : ℕ → R) = 1 := by\n ext\n rw [χ.level_one, MulChar.one_apply (isUnit_of_subsingleton _), Pi.one_apply]", "start": [ 146, 1 ], "end": [ 150, 79 ], "kind": "lemma" }, { "full_name": "DirichletCharacter.LSeries_modOne_eq", "code": "lemma LSeries_modOne_eq : L ↗χ₁ = L 1 :=\n congr_arg L modOne_eq_one", "start": [ 152, 1 ], "end": [ 153, 28 ], "kind": "lemma" }, { "full_name": "DirichletCharacter.not_LSeriesSummable_at_one", "code": "lemma not_LSeriesSummable_at_one {N : ℕ} (hN : N ≠ 0) (χ : DirichletCharacter ℂ N) :\n ¬ LSeriesSummable ↗χ 1 := by\n refine fun h ↦ (Real.not_summable_indicator_one_div_natCast hN 1) ?_\n refine h.norm.of_nonneg_of_le (fun m ↦ Set.indicator_apply_nonneg (fun _ ↦ by positivity))\n (fun n ↦ ?_)\n rw [norm_term_eq, one_re, Real.rpow_one, Set.indicator]\n split_ifs with h₁ h₂\n · rw [h₂, cast_zero, div_zero]\n · rw [h₁, χ.map_one, norm_one]\n all_goals positivity", "start": [ 155, 1 ], "end": [ 165, 23 ], "kind": "lemma" }, { "full_name": "DirichletCharacter.LSeriesSummable_of_one_lt_re", "code": "lemma LSeriesSummable_of_one_lt_re {N : ℕ} (χ : DirichletCharacter ℂ N) {s : ℂ} (hs : 1 < s.re) :\n LSeriesSummable ↗χ s :=\n LSeriesSummable_of_bounded_of_one_lt_re (fun _ _ ↦ χ.norm_le_one _) hs", "start": [ 167, 1 ], "end": [ 170, 73 ], "kind": "lemma" }, { "full_name": "DirichletCharacter.LSeriesSummable_iff", "code": "lemma LSeriesSummable_iff {N : ℕ} (hN : N ≠ 0) (χ : DirichletCharacter ℂ N) {s : ℂ} :\n LSeriesSummable ↗χ s ↔ 1 < s.re := by\n refine ⟨fun H ↦ ?_, LSeriesSummable_of_one_lt_re χ⟩\n by_contra! h\n exact not_LSeriesSummable_at_one hN χ <| LSeriesSummable.of_re_le_re (by simp only [one_re, h]) H", "start": [ 172, 1 ], "end": [ 178, 100 ], "kind": "lemma" }, { "full_name": "DirichletCharacter.absicssaOfAbsConv_eq_one", "code": "lemma absicssaOfAbsConv_eq_one {N : ℕ} (hn : N ≠ 0) (χ : DirichletCharacter ℂ N) :\n abscissaOfAbsConv ↗χ = 1 := by\n simpa only [abscissaOfAbsConv, LSeriesSummable_iff hn χ, ofReal_re, Set.Ioi_def,\n EReal.image_coe_Ioi, EReal.coe_one] using csInf_Ioo <| EReal.coe_lt_top _", "start": [ 180, 1 ], "end": [ 185, 78 ], "kind": "lemma" }, { "full_name": "DirichletCharacter.LSeriesSummable_mul", "code": "lemma LSeriesSummable_mul {N : ℕ} (χ : DirichletCharacter ℂ N) {f : ℕ → ℂ} {s : ℂ}\n (h : LSeriesSummable f s) :\n LSeriesSummable (↗χ * f) s := by\n refine .of_norm <| h.norm.of_nonneg_of_le (fun _ ↦ norm_nonneg _) fun n ↦ norm_term_le s ?_\n rw [Pi.mul_apply, norm_mul]\n exact mul_le_of_le_one_left (norm_nonneg _) <| norm_le_one ..", "start": [ 187, 1 ], "end": [ 194, 64 ], "kind": "lemma" }, { "full_name": "DirichletCharacter.LSeries.mul_mu_eq_one", "code": "lemma LSeries.mul_mu_eq_one {N : ℕ} (χ : DirichletCharacter ℂ N) {s : ℂ}\n (hs : 1 < s.re) : L ↗χ s * L (↗χ * ↗μ) s = 1 := by\n rw [← LSeries_convolution' (LSeriesSummable_of_one_lt_re χ hs) <|\n LSeriesSummable_mul χ <| ArithmeticFunction.LSeriesSummable_moebius_iff.mpr hs,\n convolution_mul_moebius, LSeries_delta, Pi.one_apply]", "start": [ 197, 1 ], "end": [ 203, 58 ], "kind": "lemma" }, { "full_name": "DirichletCharacter.LSeries_ne_zero_of_one_lt_re", "code": "lemma LSeries_ne_zero_of_one_lt_re {N : ℕ} (χ : DirichletCharacter ℂ N) {s : ℂ} (hs : 1 < s.re) :\n L ↗χ s ≠ 0 :=\n fun h ↦ by simpa only [h, zero_mul, zero_ne_one] using LSeries.mul_mu_eq_one χ hs", "start": [ 210, 1 ], "end": [ 213, 84 ], "kind": "lemma" }, { "full_name": "LSeries.abscissaOfAbsConv_one", "code": "lemma LSeries.abscissaOfAbsConv_one : abscissaOfAbsConv 1 = 1 :=\n modOne_eq_one (χ := χ₁) ▸ absicssaOfAbsConv_eq_one one_ne_zero χ₁", "start": [ 230, 1 ], "end": [ 232, 68 ], "kind": "lemma" }, { "full_name": "LSeriesSummable_one_iff", "code": "theorem LSeriesSummable_one_iff {s : ℂ} : LSeriesSummable 1 s ↔ 1 < s.re", "start": [ 234, 1 ], "end": [ 236, 63 ], "kind": "commanddeclaration" }, { "full_name": "ArithmeticFunction.LSeries_zeta_eq", "code": "lemma LSeries_zeta_eq : L ↗ζ = L 1 := by\n ext s\n exact (LSeries_congr s const_one_eq_zeta).symm", "start": [ 241, 1 ], "end": [ 245, 49 ], "kind": "lemma" }, { "full_name": "ArithmeticFunction.LSeriesSummable_zeta_iff", "code": "theorem LSeriesSummable_zeta_iff {s : ℂ} : LSeriesSummable (ζ ·) s ↔ 1 < s.re", "start": [ 247, 1 ], "end": [ 250, 84 ], "kind": "commanddeclaration" }, { "full_name": "ArithmeticFunction.abscissaOfAbsConv_zeta", "code": "lemma abscissaOfAbsConv_zeta : abscissaOfAbsConv ↗ζ = 1 := by\n rw [abscissaOfAbsConv_congr (g := 1) fun hn ↦ by simp [hn], abscissaOfAbsConv_one]", "start": [ 256, 1 ], "end": [ 258, 85 ], "kind": "lemma" }, { "full_name": "ArithmeticFunction.LSeries_zeta_eq_riemannZeta", "code": "lemma LSeries_zeta_eq_riemannZeta {s : ℂ} (hs : 1 < s.re) : L ↗ζ s = riemannZeta s := by\n simp only [LSeries, natCoe_apply, zeta_apply, cast_ite, cast_zero, cast_one,\n zeta_eq_tsum_one_div_nat_cpow hs]\n refine tsum_congr fun n ↦ ?_\n rcases eq_or_ne n 0 with rfl | hn\n · simp only [term_zero, cast_zero, zero_cpow (ne_zero_of_one_lt_re hs), div_zero]\n · simp only [term_of_ne_zero hn, hn, ↓reduceIte, one_div]", "start": [ 260, 1 ], "end": [ 268, 60 ], "kind": "lemma" }, { "full_name": "ArithmeticFunction.LSeriesHasSum_zeta", "code": "lemma LSeriesHasSum_zeta {s : ℂ} (hs : 1 < s.re) : LSeriesHasSum ↗ζ s (riemannZeta s) :=\n LSeries_zeta_eq_riemannZeta hs ▸ (LSeriesSummable_zeta_iff.mpr hs).LSeriesHasSum", "start": [ 270, 1 ], "end": [ 273, 83 ], "kind": "lemma" }, { "full_name": "ArithmeticFunction.LSeries_zeta_mul_Lseries_moebius", "code": "lemma LSeries_zeta_mul_Lseries_moebius {s : ℂ} (hs : 1 < s.re) : L ↗ζ s * L ↗μ s = 1 := by\n rw [← LSeries_convolution' (LSeriesSummable_zeta_iff.mpr hs)\n (LSeriesSummable_moebius_iff.mpr hs)]\n simp only [← natCoe_apply, ← intCoe_apply, coe_mul, coe_zeta_mul_coe_moebius, one_eq_delta,\n LSeries_delta, Pi.one_apply]", "start": [ 275, 1 ], "end": [ 280, 33 ], "kind": "lemma" }, { "full_name": "ArithmeticFunction.LSeries_zeta_ne_zero_of_one_lt_re", "code": "lemma LSeries_zeta_ne_zero_of_one_lt_re {s : ℂ} (hs : 1 < s.re) : L ↗ζ s ≠ 0 :=\n fun h ↦ by simpa only [h, zero_mul, zero_ne_one] using LSeries_zeta_mul_Lseries_moebius hs", "start": [ 282, 1 ], "end": [ 285, 93 ], "kind": "lemma" }, { "full_name": "LSeries_one_eq_riemannZeta", "code": "lemma LSeries_one_eq_riemannZeta {s : ℂ} (hs : 1 < s.re) : L 1 s = riemannZeta s :=\n LSeries_zeta_eq ▸ LSeries_zeta_eq_riemannZeta hs", "start": [ 291, 1 ], "end": [ 294, 51 ], "kind": "lemma" }, { "full_name": "LSeriesHasSum_one", "code": "lemma LSeriesHasSum_one {s : ℂ} (hs : 1 < s.re) : LSeriesHasSum 1 s (riemannZeta s) :=\n LSeries_one_eq_riemannZeta hs ▸ (LSeriesSummable_one_iff.mpr hs).LSeriesHasSum", "start": [ 296, 1 ], "end": [ 299, 81 ], "kind": "lemma" }, { "full_name": "LSeries_one_mul_Lseries_moebius", "code": "lemma LSeries_one_mul_Lseries_moebius {s : ℂ} (hs : 1 < s.re) : L 1 s * L ↗μ s = 1 :=\n LSeries_zeta_eq ▸ LSeries_zeta_mul_Lseries_moebius hs", "start": [ 301, 1 ], "end": [ 303, 56 ], "kind": "lemma" }, { "full_name": "LSeries_one_ne_zero_of_one_lt_re", "code": "lemma LSeries_one_ne_zero_of_one_lt_re {s : ℂ} (hs : 1 < s.re) : L 1 s ≠ 0 :=\n LSeries_zeta_eq ▸ LSeries_zeta_ne_zero_of_one_lt_re hs", "start": [ 305, 1 ], "end": [ 308, 57 ], "kind": "lemma" }, { "full_name": "riemannZeta_ne_zero_of_one_lt_re", "code": "lemma riemannZeta_ne_zero_of_one_lt_re {s : ℂ} (hs : 1 < s.re) : riemannZeta s ≠ 0 :=\n LSeries_one_eq_riemannZeta hs ▸ LSeries_one_ne_zero_of_one_lt_re hs", "start": [ 310, 1 ], "end": [ 312, 70 ], "kind": "lemma" }, { "full_name": "ArithmeticFunction.convolution_vonMangoldt_zeta", "code": "lemma convolution_vonMangoldt_zeta : ↗Λ ⍟ ↗ζ = ↗Complex.log := by\n ext n\n simpa only [zeta_apply, apply_ite, cast_zero, cast_one, LSeries.convolution_def, mul_zero,\n mul_one, mul_apply, natCoe_apply, ofReal_sum, ofReal_zero, log_apply, ofReal_log n.cast_nonneg]\n using congr_arg (ofReal' <| · n) vonMangoldt_mul_zeta", "start": [ 327, 1 ], "end": [ 333, 58 ], "kind": "lemma" }, { "full_name": "ArithmeticFunction.convolution_vonMangoldt_const_one", "code": "lemma convolution_vonMangoldt_const_one : ↗Λ ⍟ 1 = ↗Complex.log :=\n (convolution_one_eq_convolution_zeta _).trans convolution_vonMangoldt_zeta", "start": [ 335, 1 ], "end": [ 336, 77 ], "kind": "lemma" }, { "full_name": "ArithmeticFunction.LSeriesSummable_vonMangoldt", "code": "lemma LSeriesSummable_vonMangoldt {s : ℂ} (hs : 1 < s.re) : LSeriesSummable ↗Λ s := by\n have hf := LSeriesSummable_logMul_of_lt_re\n (show abscissaOfAbsConv 1 < s.re by rw [abscissaOfAbsConv_one]; exact_mod_cast hs)\n rw [LSeriesSummable, ← summable_norm_iff] at hf ⊢\n refine Summable.of_nonneg_of_le (fun _ ↦ norm_nonneg _) (fun n ↦ norm_term_le s ?_) hf\n have hΛ : ‖↗Λ n‖ ≤ ‖Complex.log n‖ := by\n simp only [norm_eq_abs, abs_ofReal, _root_.abs_of_nonneg vonMangoldt_nonneg,\n ← Complex.natCast_log, _root_.abs_of_nonneg <| Real.log_natCast_nonneg n]\n exact ArithmeticFunction.vonMangoldt_le_log\n exact hΛ.trans <| by simp only [norm_eq_abs, norm_mul, Pi.one_apply, norm_one, mul_one, le_refl]", "start": [ 338, 1 ], "end": [ 348, 99 ], "kind": "lemma" }, { "full_name": "DirichletCharacter.convolution_twist_vonMangoldt", "code": "lemma convolution_twist_vonMangoldt {N : ℕ} (χ : DirichletCharacter ℂ N) :\n (↗χ * ↗Λ) ⍟ ↗χ = ↗χ * ↗Complex.log := by\n rw [← convolution_vonMangoldt_const_one, ← χ.mul_convolution_distrib, mul_one]", "start": [ 354, 1 ], "end": [ 357, 81 ], "kind": "lemma" }, { "full_name": "DirichletCharacter.LSeriesSummable_twist_vonMangoldt", "code": "lemma LSeriesSummable_twist_vonMangoldt {N : ℕ} (χ : DirichletCharacter ℂ N) {s : ℂ}\n (hs : 1 < s.re) :\n LSeriesSummable (↗χ * ↗Λ) s :=\n LSeriesSummable_mul χ <| LSeriesSummable_vonMangoldt hs", "start": [ 359, 1 ], "end": [ 364, 58 ], "kind": "lemma" }, { "full_name": "DirichletCharacter.LSeries_twist_vonMangoldt_eq", "code": "lemma LSeries_twist_vonMangoldt_eq {N : ℕ} (χ : DirichletCharacter ℂ N) {s : ℂ} (hs : 1 < s.re) :\n L (↗χ * ↗Λ) s = - deriv (L ↗χ) s / L ↗χ s := by\n rcases eq_or_ne N 0 with rfl | hN\n · simpa only [modZero_eq_delta, delta_mul_eq_smul_delta, vonMangoldt_apply_one, ofReal_zero,\n zero_smul, LSeries_zero, Pi.zero_apply, LSeries_delta, Pi.one_apply, div_one, zero_eq_neg]\n using deriv_const s 1\n have hχ : LSeriesSummable ↗χ s := (LSeriesSummable_iff hN χ).mpr hs\n have hs' : abscissaOfAbsConv ↗χ < s.re := by\n rwa [absicssaOfAbsConv_eq_one hN, ← EReal.coe_one, EReal.coe_lt_coe_iff]\n have hΛ : LSeriesSummable (↗χ * ↗Λ) s := LSeriesSummable_twist_vonMangoldt χ hs\n rw [eq_div_iff <| LSeries_ne_zero_of_one_lt_re χ hs, ← LSeries_convolution' hΛ hχ,\n convolution_twist_vonMangoldt, LSeries_deriv hs', neg_neg]\n exact LSeries_congr s fun _ ↦ by simp only [Pi.mul_apply, mul_comm, logMul]", "start": [ 366, 1 ], "end": [ 381, 78 ], "kind": "lemma" }, { "full_name": "ArithmeticFunction.LSeries_vonMangoldt_eq", "code": "lemma LSeries_vonMangoldt_eq {s : ℂ} (hs : 1 < s.re) : L ↗Λ s = - deriv (L 1) s / L 1 s := by\n refine (LSeries_congr s fun {n} _ ↦ ?_).trans <|\n LSeries_modOne_eq ▸ LSeries_twist_vonMangoldt_eq χ₁ hs\n simp only [Subsingleton.eq_one (n : ZMod 1), map_one, Pi.mul_apply, one_mul]", "start": [ 388, 1 ], "end": [ 393, 79 ], "kind": "lemma" }, { "full_name": "ArithmeticFunction.LSeries_vonMangoldt_eq_deriv_riemannZeta_div", "code": "lemma LSeries_vonMangoldt_eq_deriv_riemannZeta_div {s : ℂ} (hs : 1 < s.re) :\n L ↗Λ s = - deriv riemannZeta s / riemannZeta s := by\n suffices deriv (L 1) s = deriv riemannZeta s by\n rw [LSeries_vonMangoldt_eq hs, ← LSeries_one_eq_riemannZeta hs, this]\n refine Filter.EventuallyEq.deriv_eq <| Filter.eventuallyEq_iff_exists_mem.mpr ?_\n exact ⟨{z | 1 < z.re}, (isOpen_lt continuous_const continuous_re).mem_nhds hs,\n fun _ ↦ LSeries_one_eq_riemannZeta⟩", "start": [ 395, 1 ], "end": [ 403, 40 ], "kind": "lemma" } ]

[ "Mathlib/Algebra/Category/ModuleCat/Presheaf.lean", ".lake/packages/lean4/src/lean/Init.lean", "Mathlib/Algebra/Category/ModuleCat/Differentials/Basic.lean" ]

[ { "full_name": "PresheafOfModules.Derivation", "code": "@[ext]\nstructure Derivation where\n \n d {X : Dᵒᵖ} : R.obj X →+ M.obj X\n d_mul {X : Dᵒᵖ} (a b : R.obj X) : d (a * b) = a • d b + b • d a := by aesop_cat\n d_map {X Y : Dᵒᵖ} (f : X ⟶ Y) (x : R.obj X) :\n d (R.map f x) = M.map f (d x) := by aesop_cat\n d_app {X : Cᵒᵖ} (a : S.obj X) : d (φ.app X a) = 0 := by aesop_cat", "start": [ 50, 1 ], "end": [ 59, 68 ], "kind": "commanddeclaration" }, { "full_name": "PresheafOfModules.Derivation.congr_d", "code": "lemma congr_d {d d' : M.Derivation φ} (h : d = d') {X : Dᵒᵖ} (b : R.obj X) :\n d.d b = d'.d b := by rw [h]", "start": [ 69, 1 ], "end": [ 70, 32 ], "kind": "lemma" }, { "full_name": "PresheafOfModules.Derivation.d_one", "code": "@[simp] lemma d_one (X : Dᵒᵖ) : d.d (X := X) 1 = 0 := by\n simpa using d.d_mul (X := X) 1 1", "start": [ 74, 1 ], "end": [ 75, 35 ], "kind": "lemma" }, { "full_name": "PresheafOfModules.Derivation.postcomp", "code": "@[simps! d_apply]\ndef postcomp (f : M ⟶ N) : N.Derivation φ where\n d := (f.app _).toAddMonoidHom.comp d.d\n d_map _ _ := by simp [naturality_apply]\n d_app {X} a := by\n dsimp\n erw [d_app, map_zero]", "start": [ 77, 1 ], "end": [ 84, 26 ], "kind": "commanddeclaration" }, { "full_name": "PresheafOfModules.Derivation.Universal", "code": "structure Universal where\n \n desc {M' : PresheafOfModules (R ⋙ forget₂ CommRingCat RingCat)}\n (d' : M'.Derivation φ) : M ⟶ M'\n fac {M' : PresheafOfModules (R ⋙ forget₂ CommRingCat RingCat)}\n (d' : M'.Derivation φ) : d.postcomp (desc d') = d' := by aesop_cat\n postcomp_injective {M' : PresheafOfModules (R ⋙ forget₂ CommRingCat RingCat)}\n (φ φ' : M ⟶ M') (h : d.postcomp φ = d.postcomp φ') : φ = φ' := by aesop_cat", "start": [ 86, 1 ], "end": [ 96, 80 ], "kind": "commanddeclaration" }, { "full_name": "PresheafOfModules.HasDifferentials", "code": "class HasDifferentials : Prop where\n exists_universal_derivation : ∃ (M : PresheafOfModules.{u} (R ⋙ forget₂ _ _))\n (d : M.Derivation φ), Nonempty d.Universal", "start": [ 115, 1 ], "end": [ 119, 49 ], "kind": "commanddeclaration" }, { "full_name": "PresheafOfModules.Derivation'", "code": "abbrev Derivation' : Type _ := M.Derivation (F := 𝟭 D) φ'", "start": [ 121, 1 ], "end": [ 123, 58 ], "kind": "commanddeclaration" }, { "full_name": "PresheafOfModules.Derivation'.d_app", "code": "@[simp]\nnonrec lemma d_app (d : M.Derivation' φ') {X : Dᵒᵖ} (a : S'.obj X) :\n d.d (φ'.app X a) = 0 :=\n d.d_app _", "start": [ 129, 1 ], "end": [ 132, 12 ], "kind": "lemma" }, { "full_name": "PresheafOfModules.Derivation'.app", "code": "noncomputable def app (d : M.Derivation' φ') (X : Dᵒᵖ) : (M.obj X).Derivation (φ'.app X) :=\n ModuleCat.Derivation.mk (fun b ↦ d.d b)", "start": [ 134, 1 ], "end": [ 137, 42 ], "kind": "commanddeclaration" }, { "full_name": "PresheafOfModules.Derivation'.app_apply", "code": "@[simp]\nlemma app_apply (d : M.Derivation' φ') {X : Dᵒᵖ} (b : R.obj X) :\n (d.app X).d b = d.d b := rfl", "start": [ 139, 1 ], "end": [ 141, 33 ], "kind": "lemma" }, { "full_name": "PresheafOfModules.Derivation'.mk", "code": "def mk : M.Derivation' φ' where\n d {X} := AddMonoidHom.mk' (d X).d (by simp)", "start": [ 149, 1 ], "end": [ 153, 46 ], "kind": "commanddeclaration" }, { "full_name": "PresheafOfModules.Derivation'.mk_app", "code": "@[simp]\nlemma mk_app (X : Dᵒᵖ) : (mk d d_map).app X = d X := rfl", "start": [ 155, 1 ], "end": [ 156, 57 ], "kind": "lemma" }, { "full_name": "PresheafOfModules.Derivation'.Universal.mk", "code": "def Universal.mk {d : M.Derivation' φ'}\n (desc : ∀ {M' : PresheafOfModules (R ⋙ forget₂ _ _)}\n (_ : M'.Derivation' φ'), M ⟶ M')\n (fac : ∀ {M' : PresheafOfModules (R ⋙ forget₂ _ _)}\n (d' : M'.Derivation' φ'), d.postcomp (desc d') = d')\n (postcomp_injective : ∀ {M' : PresheafOfModules (R ⋙ forget₂ _ _)}\n (α β : M ⟶ M'), d.postcomp α = d.postcomp β → α = β) : d.Universal where\n desc := desc\n fac := fac\n postcomp_injective := postcomp_injective", "start": [ 158, 1 ], "end": [ 168, 43 ], "kind": "commanddeclaration" }, { "full_name": "PresheafOfModules.DifferentialsConstruction.relativeDifferentials'BundledCore", "code": "noncomputable def relativeDifferentials'BundledCore :\n BundledCorePresheafOfModules.{u} (R ⋙ forget₂ _ _) where\n obj X := CommRingCat.KaehlerDifferential (φ'.app X)\n map f := CommRingCat.KaehlerDifferential.map (φ'.naturality f)", "start": [ 176, 1 ], "end": [ 180, 65 ], "kind": "commanddeclaration" }, { "full_name": "PresheafOfModules.DifferentialsConstruction.relativeDifferentials'", "code": "noncomputable def relativeDifferentials' :\n PresheafOfModules.{u} (R ⋙ forget₂ _ _) :=\n (relativeDifferentials'BundledCore φ').toPresheafOfModules", "start": [ 182, 1 ], "end": [ 186, 61 ], "kind": "commanddeclaration" }, { "full_name": "PresheafOfModules.DifferentialsConstruction.relativeDifferentials'_obj", "code": "@[simp]\nlemma relativeDifferentials'_obj (X : Dᵒᵖ) :\n (relativeDifferentials' φ').obj X =\n CommRingCat.KaehlerDifferential (φ'.app X) := rfl", "start": [ 188, 1 ], "end": [ 191, 56 ], "kind": "lemma" }, { "full_name": "PresheafOfModules.DifferentialsConstruction.relativeDifferentials'_map_apply", "code": "lemma relativeDifferentials'_map_apply {X Y : Dᵒᵖ} (f : X ⟶ Y)\n (x : CommRingCat.KaehlerDifferential (φ'.app X)) :\n (relativeDifferentials' φ').map f x =\n CommRingCat.KaehlerDifferential.map (φ'.naturality f) x := rfl", "start": [ 195, 1 ], "end": [ 198, 71 ], "kind": "lemma" }, { "full_name": "PresheafOfModules.DifferentialsConstruction.relativeDifferentials'_map_d", "code": "lemma relativeDifferentials'_map_d {X Y : Dᵒᵖ} (f : X ⟶ Y)\n (x : R.obj X) :\n (relativeDifferentials' φ').map f (CommRingCat.KaehlerDifferential.d x) =\n CommRingCat.KaehlerDifferential.d (R.map f x) := by\n rw [relativeDifferentials'_map_apply, CommRingCat.KaehlerDifferential.map_d]", "start": [ 200, 1 ], "end": [ 204, 79 ], "kind": "lemma" }, { "full_name": "PresheafOfModules.DifferentialsConstruction.derivation'", "code": "noncomputable def derivation' : (relativeDifferentials' φ').Derivation' φ' :=\n Derivation'.mk (fun X ↦ CommRingCat.KaehlerDifferential.D (φ'.app X)) (fun X Y f x ↦ by\n rw [relativeDifferentials'_map_apply, CommRingCat.KaehlerDifferential.map_d])", "start": [ 206, 1 ], "end": [ 209, 82 ], "kind": "commanddeclaration" }, { "full_name": "PresheafOfModules.DifferentialsConstruction.isUniversal'", "code": "noncomputable def isUniversal' : (derivation' φ').Universal :=\n Derivation'.Universal.mk\n (fun {M'} d' ↦ Hom.mk'' (fun X ↦ (d'.app X).desc) (fun X Y f ↦\n CommRingCat.KaehlerDifferential.ext (fun b ↦ by\n dsimp [ModuleCat.ofHom]\n erw [restrictionApp_apply, restrictionApp_apply]\n simp only [relativeDifferentials'_map_d, ModuleCat.Derivation.desc_d,\n d'.app_apply, d'.d_map])))\n (fun {M'} d' ↦ by\n ext X b\n apply ModuleCat.Derivation.desc_d)\n (fun {M} α β h ↦ by\n ext1 X\n exact CommRingCat.KaehlerDifferential.ext (Derivation.congr_d h))", "start": [ 211, 1 ], "end": [ 225, 72 ], "kind": "commanddeclaration" } ]

[ "Mathlib/RingTheory/PowerSeries/Inverse.lean", ".lake/packages/lean4/src/lean/Init.lean", "Mathlib/RingTheory/Derivation/Basic.lean", "Mathlib/RingTheory/PowerSeries/Trunc.lean" ]

[ { "full_name": "PowerSeries.derivativeFun", "code": "noncomputable def derivativeFun (f : R⟦X⟧) : R⟦X⟧ := mk fun n ↦ coeff R (n + 1) f * (n + 1)", "start": [ 34, 1 ], "end": [ 39, 92 ], "kind": "commanddeclaration" }, { "full_name": "PowerSeries.coeff_derivativeFun", "code": "theorem coeff_derivativeFun (f : R⟦X⟧) (n : ℕ) :\n coeff R n f.derivativeFun = coeff R (n + 1) f * (n + 1)", "start": [ 41, 1 ], "end": [ 43, 31 ], "kind": "commanddeclaration" }, { "full_name": "PowerSeries.derivativeFun_coe", "code": "theorem derivativeFun_coe (f : R[X]) : (f : R⟦X⟧).derivativeFun = derivative f", "start": [ 45, 1 ], "end": [ 47, 67 ], "kind": "commanddeclaration" }, { "full_name": "PowerSeries.derivativeFun_add", "code": "theorem derivativeFun_add (f g : R⟦X⟧) :\n derivativeFun (f + g) = derivativeFun f + derivativeFun g", "start": [ 49, 1 ], "end": [ 53, 34 ], "kind": "commanddeclaration" }, { "full_name": "PowerSeries.derivativeFun_C", "code": "theorem derivativeFun_C (r : R) : derivativeFun (C R r) = 0", "start": [ 55, 1 ], "end": [ 58, 73 ], "kind": "commanddeclaration" }, { "full_name": "PowerSeries.trunc_derivativeFun", "code": "theorem trunc_derivativeFun (f : R⟦X⟧) (n : ℕ) :\n trunc n f.derivativeFun = derivative (trunc (n + 1) f)", "start": [ 60, 1 ], "end": [ 68, 62 ], "kind": "commanddeclaration" }, { "full_name": "PowerSeries.derivativeFun_coe_mul_coe", "code": "private theorem derivativeFun_coe_mul_coe (f g : R[X]) : derivativeFun (f * g : R⟦X⟧) =\n f * derivative g + g * derivative f", "start": [ 71, 1 ], "end": [ 74, 70 ], "kind": "commanddeclaration" }, { "full_name": "PowerSeries.derivativeFun_mul", "code": "theorem derivativeFun_mul (f g : R⟦X⟧) :\n derivativeFun (f * g) = f • g.derivativeFun + g • f.derivativeFun", "start": [ 76, 1 ], "end": [ 85, 86 ], "kind": "commanddeclaration" }, { "full_name": "PowerSeries.derivativeFun_one", "code": "theorem derivativeFun_one : derivativeFun (1 : R⟦X⟧) = 0", "start": [ 87, 1 ], "end": [ 88, 48 ], "kind": "commanddeclaration" }, { "full_name": "PowerSeries.derivativeFun_smul", "code": "theorem derivativeFun_smul (r : R) (f : R⟦X⟧) : derivativeFun (r • f) = r • derivativeFun f", "start": [ 90, 1 ], "end": [ 92, 17 ], "kind": "commanddeclaration" }, { "full_name": "PowerSeries.derivative", "code": "noncomputable def derivative : Derivation R R⟦X⟧ R⟦X⟧ where\n toFun := derivativeFun\n map_add' := derivativeFun_add\n map_smul' := derivativeFun_smul\n map_one_eq_zero' := derivativeFun_one\n leibniz' := derivativeFun_mul", "start": [ 96, 1 ], "end": [ 102, 41 ], "kind": "commanddeclaration" }, { "full_name": "PowerSeries.derivative_C", "code": "@[simp] theorem derivative_C (r : R) : d⁄dX R (C R r) = 0", "start": [ 108, 1 ], "end": [ 108, 79 ], "kind": "commanddeclaration" }, { "full_name": "PowerSeries.coeff_derivative", "code": "theorem coeff_derivative (f : R⟦X⟧) (n : ℕ) :\n coeff R n (d⁄dX R f) = coeff R (n + 1) f * (n + 1)", "start": [ 110, 1 ], "end": [ 111, 82 ], "kind": "commanddeclaration" }, { "full_name": "PowerSeries.derivative_coe", "code": "theorem derivative_coe (f : R[X]) : d⁄dX R f = Polynomial.derivative f", "start": [ 113, 1 ], "end": [ 113, 94 ], "kind": "commanddeclaration" }, { "full_name": "PowerSeries.derivative_X", "code": "@[simp] theorem derivative_X : d⁄dX R (X : R⟦X⟧) = 1", "start": [ 115, 1 ], "end": [ 121, 8 ], "kind": "commanddeclaration" }, { "full_name": "PowerSeries.trunc_derivative", "code": "theorem trunc_derivative (f : R⟦X⟧) (n : ℕ) :\n trunc n (d⁄dX R f) = Polynomial.derivative (trunc (n + 1) f)", "start": [ 123, 1 ], "end": [ 125, 25 ], "kind": "commanddeclaration" }, { "full_name": "PowerSeries.trunc_derivative'", "code": "theorem trunc_derivative' (f : R⟦X⟧) (n : ℕ) :\n trunc (n-1) (d⁄dX R f) = Polynomial.derivative (trunc n f)", "start": [ 127, 1 ], "end": [ 133, 40 ], "kind": "commanddeclaration" }, { "full_name": "PowerSeries.derivative.ext", "code": "theorem derivative.ext {R} [CommRing R] [NoZeroSMulDivisors ℕ R] {f g} (hD : d⁄dX R f = d⁄dX R g)\n (hc : constantCoeff R f = constantCoeff R g) : f = g", "start": [ 141, 1 ], "end": [ 151, 70 ], "kind": "commanddeclaration" }, { "full_name": "PowerSeries.derivative_inv", "code": "@[simp] theorem derivative_inv {R} [CommRing R] (f : R⟦X⟧ˣ) :\n d⁄dX R ↑f⁻¹ = -(↑f⁻¹ : R⟦X⟧) ^ 2 * d⁄dX R f", "start": [ 153, 1 ], "end": [ 156, 7 ], "kind": "commanddeclaration" }, { "full_name": "PowerSeries.derivative_invOf", "code": "@[simp] theorem derivative_invOf {R} [CommRing R] (f : R⟦X⟧) [Invertible f] :\n d⁄dX R ⅟f = - ⅟f ^ 2 * d⁄dX R f", "start": [ 158, 1 ], "end": [ 160, 45 ], "kind": "commanddeclaration" }, { "full_name": "PowerSeries.derivative_inv'", "code": "@[simp] theorem derivative_inv' {R} [Field R] (f : R⟦X⟧) : d⁄dX R f⁻¹ = -f⁻¹ ^ 2 * d⁄dX R f", "start": [ 166, 1 ], "end": [ 172, 44 ], "kind": "commanddeclaration" } ]

[ ".lake/packages/lean4/src/lean/Init.lean", "Mathlib/Algebra/Group/Action/Defs.lean" ]

[ { "full_name": "Sigma.smul_def", "code": "@[to_additive]\ntheorem smul_def : a • x = x.map id fun _ => (a • ·)", "start": [ 35, 1 ], "end": [ 37, 6 ], "kind": "commanddeclaration" }, { "full_name": "Sigma.smul_mk", "code": "@[to_additive (attr := simp)]\ntheorem smul_mk : a • mk i b = ⟨i, a • b⟩", "start": [ 41, 1 ], "end": [ 43, 6 ], "kind": "commanddeclaration" }, { "full_name": "Sigma.instIsScalarTowerOfSMul", "code": "@[to_additive]\ninstance instIsScalarTowerOfSMul [SMul M N] [∀ i, IsScalarTower M N (α i)] :\n IsScalarTower M N (Σi, α i) :=\n ⟨fun a b x => by\n cases x\n rw [smul_mk, smul_mk, smul_mk, smul_assoc]⟩", "start": [ 47, 1 ], "end": [ 52, 48 ], "kind": "commanddeclaration" }, { "full_name": "Sigma.FaithfulSMul'", "code": "@[to_additive \"This is not an instance because `i` becomes a metavariable.\"]\nprotected theorem FaithfulSMul' [FaithfulSMul M (α i)] : FaithfulSMul M (Σi, α i)", "start": [ 66, 1 ], "end": [ 69, 89 ], "kind": "commanddeclaration" } ]

[ "Mathlib/Geometry/Manifold/DerivationBundle.lean", ".lake/packages/lean4/src/lean/Init.lean", "Mathlib/RingTheory/Derivation/Lie.lean" ]

[ { "full_name": "LeftInvariantDerivation", "code": "structure LeftInvariantDerivation extends Derivation 𝕜 C^∞⟮I, G; 𝕜⟯ C^∞⟮I, G; 𝕜⟯ where\n left_invariant'' :\n ∀ g, 𝒅ₕ (smoothLeftMul_one I g) (Derivation.evalAt 1 toDerivation) =\n Derivation.evalAt g toDerivation", "start": [ 39, 1 ], "end": [ 47, 39 ], "kind": "commanddeclaration" }, { "full_name": "LeftInvariantDerivation.toDerivation_injective", "code": "theorem toDerivation_injective :\n Function.Injective (toDerivation : LeftInvariantDerivation I G → _)", "start": [ 59, 1 ], "end": [ 61, 42 ], "kind": "commanddeclaration" }, { "full_name": "LeftInvariantDerivation.toFun_eq_coe", "code": "theorem toFun_eq_coe : X.toFun = ⇑X", "start": [ 75, 1 ], "end": [ 76, 6 ], "kind": "commanddeclaration" }, { "full_name": "LeftInvariantDerivation.coe_injective", "code": "theorem coe_injective :\n @Function.Injective (LeftInvariantDerivation I G) (_ → C^∞⟮I, G; 𝕜⟯) DFunLike.coe", "start": [ 84, 1 ], "end": [ 86, 25 ], "kind": "commanddeclaration" }, { "full_name": "LeftInvariantDerivation.ext", "code": "@[ext]\ntheorem ext (h : ∀ f, X f = Y f) : X = Y", "start": [ 89, 1 ], "end": [ 90, 63 ], "kind": "commanddeclaration" }, { "full_name": "LeftInvariantDerivation.coe_derivation", "code": "theorem coe_derivation :\n ⇑(X : Derivation 𝕜 C^∞⟮I, G; 𝕜⟯ C^∞⟮I, G; 𝕜⟯) = (X : C^∞⟮I, G; 𝕜⟯ → C^∞⟮I, G; 𝕜⟯)", "start": [ 95, 1 ], "end": [ 97, 6 ], "kind": "commanddeclaration" }, { "full_name": "LeftInvariantDerivation.left_invariant'", "code": "theorem left_invariant' :\n 𝒅ₕ (smoothLeftMul_one I g) (Derivation.evalAt (1 : G) ↑X) = Derivation.evalAt g ↑X", "start": [ 100, 1 ], "end": [ 103, 23 ], "kind": "commanddeclaration" }, { "full_name": "LeftInvariantDerivation.map_add", "code": "protected theorem map_add : X (f + f') = X f + X f'", "start": [ 107, 1 ], "end": [ 107, 70 ], "kind": "commanddeclaration" }, { "full_name": "LeftInvariantDerivation.map_zero", "code": "protected theorem map_zero : X 0 = 0", "start": [ 111, 1 ], "end": [ 111, 51 ], "kind": "commanddeclaration" }, { "full_name": "LeftInvariantDerivation.map_neg", "code": "protected theorem map_neg : X (-f) = -X f", "start": [ 115, 1 ], "end": [ 115, 57 ], "kind": "commanddeclaration" }, { "full_name": "LeftInvariantDerivation.map_sub", "code": "protected theorem map_sub : X (f - f') = X f - X f'", "start": [ 119, 1 ], "end": [ 119, 70 ], "kind": "commanddeclaration" }, { "full_name": "LeftInvariantDerivation.map_smul", "code": "protected theorem map_smul : X (r • f) = r • X f", "start": [ 123, 1 ], "end": [ 123, 67 ], "kind": "commanddeclaration" }, { "full_name": "LeftInvariantDerivation.leibniz", "code": "@[simp]\ntheorem leibniz : X (f * f') = f • X f' + f' • X f", "start": [ 126, 1 ], "end": [ 128, 17 ], "kind": "commanddeclaration" }, { "full_name": "LeftInvariantDerivation.coe_add", "code": "@[simp]\ntheorem coe_add : ⇑(X + Y) = X + Y", "start": [ 148, 1 ], "end": [ 150, 6 ], "kind": "commanddeclaration" }, { "full_name": "LeftInvariantDerivation.coe_zero", "code": "@[simp]\ntheorem coe_zero : ⇑(0 : LeftInvariantDerivation I G) = 0", "start": [ 153, 1 ], "end": [ 155, 6 ], "kind": "commanddeclaration" }, { "full_name": "LeftInvariantDerivation.coe_neg", "code": "@[simp]\ntheorem coe_neg : ⇑(-X) = -X", "start": [ 158, 1 ], "end": [ 160, 6 ], "kind": "commanddeclaration" }, { "full_name": "LeftInvariantDerivation.coe_sub", "code": "@[simp]\ntheorem coe_sub : ⇑(X - Y) = X - Y", "start": [ 163, 1 ], "end": [ 165, 6 ], "kind": "commanddeclaration" }, { "full_name": "LeftInvariantDerivation.lift_add", "code": "@[simp, norm_cast]\ntheorem lift_add : (↑(X + Y) : Derivation 𝕜 C^∞⟮I, G; 𝕜⟯ C^∞⟮I, G; 𝕜⟯) = X + Y", "start": [ 168, 1 ], "end": [ 170, 6 ], "kind": "commanddeclaration" }, { "full_name": "LeftInvariantDerivation.lift_zero", "code": "@[simp, norm_cast]\ntheorem lift_zero :\n (↑(0 : LeftInvariantDerivation I G) : Derivation 𝕜 C^∞⟮I, G; 𝕜⟯ C^∞⟮I, G; 𝕜⟯) = 0", "start": [ 173, 1 ], "end": [ 176, 6 ], "kind": "commanddeclaration" }, { "full_name": "LeftInvariantDerivation.hasNatScalar", "code": "instance hasNatScalar : SMul ℕ (LeftInvariantDerivation I G) where\n smul r X := ⟨r • X.1, fun g => by simp_rw [LinearMap.map_smul_of_tower _ r, left_invariant']⟩", "start": [ 179, 1 ], "end": [ 180, 96 ], "kind": "commanddeclaration" }, { "full_name": "LeftInvariantDerivation.hasIntScalar", "code": "instance hasIntScalar : SMul ℤ (LeftInvariantDerivation I G) where\n smul r X := ⟨r • X.1, fun g => by simp_rw [LinearMap.map_smul_of_tower _ r, left_invariant']⟩", "start": [ 183, 1 ], "end": [ 184, 96 ], "kind": "commanddeclaration" }, { "full_name": "LeftInvariantDerivation.coe_smul", "code": "@[simp]\ntheorem coe_smul : ⇑(r • X) = r • ⇑X", "start": [ 195, 1 ], "end": [ 197, 6 ], "kind": "commanddeclaration" }, { "full_name": "LeftInvariantDerivation.lift_smul", "code": "@[simp]\ntheorem lift_smul (k : 𝕜) : (k • X).1 = k • X.1", "start": [ 200, 1 ], "end": [ 202, 6 ], "kind": "commanddeclaration" }, { "full_name": "LeftInvariantDerivation.coeFnAddMonoidHom", "code": "@[simps]\ndef coeFnAddMonoidHom : LeftInvariantDerivation I G →+ C^∞⟮I, G; 𝕜⟯ → C^∞⟮I, G; 𝕜⟯ :=\n ⟨⟨DFunLike.coe, coe_zero⟩, coe_add⟩", "start": [ 207, 1 ], "end": [ 210, 38 ], "kind": "commanddeclaration" }, { "full_name": "LeftInvariantDerivation.evalAt", "code": "def evalAt : LeftInvariantDerivation I G →ₗ[𝕜] PointDerivation I g where\n toFun X := Derivation.evalAt g X.1\n map_add' _ _ := rfl\n map_smul' _ _ := rfl", "start": [ 218, 1 ], "end": [ 223, 23 ], "kind": "commanddeclaration" }, { "full_name": "LeftInvariantDerivation.evalAt_apply", "code": "theorem evalAt_apply : evalAt g X f = (X f) g", "start": [ 226, 1 ], "end": [ 227, 6 ], "kind": "commanddeclaration" }, { "full_name": "LeftInvariantDerivation.evalAt_coe", "code": "@[simp]\ntheorem evalAt_coe : Derivation.evalAt g ↑X = evalAt g X", "start": [ 230, 1 ], "end": [ 232, 6 ], "kind": "commanddeclaration" }, { "full_name": "LeftInvariantDerivation.left_invariant", "code": "theorem left_invariant : 𝒅ₕ (smoothLeftMul_one I g) (evalAt (1 : G) X) = evalAt g X", "start": [ 235, 1 ], "end": [ 236, 23 ], "kind": "commanddeclaration" }, { "full_name": "LeftInvariantDerivation.evalAt_mul", "code": "theorem evalAt_mul : evalAt (g * h) X = 𝒅ₕ (L_apply I g h) (evalAt h X)", "start": [ 239, 1 ], "end": [ 246, 68 ], "kind": "commanddeclaration" }, { "full_name": "LeftInvariantDerivation.comp_L", "code": "theorem comp_L : (X f).comp (𝑳 I g) = X (f.comp (𝑳 I g))", "start": [ 249, 1 ], "end": [ 252, 39 ], "kind": "commanddeclaration" }, { "full_name": "LeftInvariantDerivation.commutator_coe_derivation", "code": "@[simp]\ntheorem commutator_coe_derivation :\n ⇑⁅X, Y⁆ =\n (⁅(X : Derivation 𝕜 C^∞⟮I, G; 𝕜⟯ C^∞⟮I, G; 𝕜⟯), Y⁆ :\n Derivation 𝕜 C^∞⟮I, G; 𝕜⟯ C^∞⟮I, G; 𝕜⟯)", "start": [ 269, 1 ], "end": [ 274, 6 ], "kind": "commanddeclaration" }, { "full_name": "LeftInvariantDerivation.commutator_apply", "code": "theorem commutator_apply : ⁅X, Y⁆ f = X (Y f) - Y (X f)", "start": [ 277, 1 ], "end": [ 278, 6 ], "kind": "commanddeclaration" } ]

[ ".lake/packages/lean4/src/lean/Init.lean", "Mathlib/Data/Real/Pi/Wallis.lean", "Mathlib/Analysis/PSeries.lean", "Mathlib/Tactic/AdaptationNote.lean" ]

[ { "full_name": "Stirling.stirlingSeq", "code": "noncomputable def stirlingSeq (n : ℕ) : ℝ :=\n n ! / (√(2 * n : ℝ) * (n / exp 1) ^ n)", "start": [ 48, 1 ], "end": [ 52, 41 ], "kind": "commanddeclaration" }, { "full_name": "Stirling.stirlingSeq_zero", "code": "@[simp]\ntheorem stirlingSeq_zero : stirlingSeq 0 = 0", "start": [ 55, 1 ], "end": [ 57, 76 ], "kind": "commanddeclaration" }, { "full_name": "Stirling.stirlingSeq_one", "code": "@[simp]\ntheorem stirlingSeq_one : stirlingSeq 1 = exp 1 / √2", "start": [ 60, 1 ], "end": [ 62, 88 ], "kind": "commanddeclaration" }, { "full_name": "Stirling.log_stirlingSeq_formula", "code": "theorem log_stirlingSeq_formula (n : ℕ) :\n log (stirlingSeq n) = Real.log n ! - 1 / 2 * Real.log (2 * n) - n * log (n / exp 1)", "start": [ 65, 1 ], "end": [ 70, 21 ], "kind": "commanddeclaration" }, { "full_name": "Stirling.log_stirlingSeq_diff_hasSum", "code": "theorem log_stirlingSeq_diff_hasSum (m : ℕ) :\n HasSum (fun k : ℕ => (1 : ℝ) / (2 * ↑(k + 1) + 1) * ((1 / (2 * ↑(m + 1) + 1)) ^ 2) ^ ↑(k + 1))\n (log (stirlingSeq (m + 1)) - log (stirlingSeq (m + 2)))", "start": [ 74, 1 ], "end": [ 93, 9 ], "kind": "commanddeclaration" }, { "full_name": "Stirling.log_stirlingSeq'_antitone", "code": "theorem log_stirlingSeq'_antitone : Antitone (Real.log ∘ stirlingSeq ∘ succ)", "start": [ 96, 1 ], "end": [ 99, 83 ], "kind": "commanddeclaration" }, { "full_name": "Stirling.log_stirlingSeq_diff_le_geo_sum", "code": "theorem log_stirlingSeq_diff_le_geo_sum (n : ℕ) :\n log (stirlingSeq (n + 1)) - log (stirlingSeq (n + 2)) ≤\n ((1 : ℝ) / (2 * ↑(n + 1) + 1)) ^ 2 / (1 - ((1 : ℝ) / (2 * ↑(n + 1) + 1)) ^ 2)", "start": [ 102, 1 ], "end": [ 120, 56 ], "kind": "commanddeclaration" }, { "full_name": "Stirling.log_stirlingSeq_sub_log_stirlingSeq_succ", "code": "theorem log_stirlingSeq_sub_log_stirlingSeq_succ (n : ℕ) :\n log (stirlingSeq (n + 1)) - log (stirlingSeq (n + 2)) ≤ 1 / (4 * (↑(n + 1):ℝ) ^ 2)", "start": [ 127, 1 ], "end": [ 144, 8 ], "kind": "commanddeclaration" }, { "full_name": "Stirling.log_stirlingSeq_bounded_aux", "code": "theorem log_stirlingSeq_bounded_aux :\n ∃ c : ℝ, ∀ n : ℕ, log (stirlingSeq 1) - log (stirlingSeq (n + 1)) ≤ c", "start": [ 147, 1 ], "end": [ 166, 31 ], "kind": "commanddeclaration" }, { "full_name": "Stirling.log_stirlingSeq_bounded_by_constant", "code": "theorem log_stirlingSeq_bounded_by_constant : ∃ c, ∀ n : ℕ, c ≤ log (stirlingSeq (n + 1))", "start": [ 169, 1 ], "end": [ 172, 65 ], "kind": "commanddeclaration" }, { "full_name": "Stirling.stirlingSeq'_pos", "code": "theorem stirlingSeq'_pos (n : ℕ) : 0 < stirlingSeq (n + 1)", "start": [ 175, 1 ], "end": [ 176, 96 ], "kind": "commanddeclaration" }, { "full_name": "Stirling.stirlingSeq'_bounded_by_pos_constant", "code": "theorem stirlingSeq'_bounded_by_pos_constant : ∃ a, 0 < a ∧ ∀ n : ℕ, a ≤ stirlingSeq (n + 1)", "start": [ 179, 1 ], "end": [ 185, 12 ], "kind": "commanddeclaration" }, { "full_name": "Stirling.stirlingSeq'_antitone", "code": "theorem stirlingSeq'_antitone : Antitone (stirlingSeq ∘ succ)", "start": [ 188, 1 ], "end": [ 190, 94 ], "kind": "commanddeclaration" }, { "full_name": "Stirling.stirlingSeq_has_pos_limit_a", "code": "theorem stirlingSeq_has_pos_limit_a : ∃ a : ℝ, 0 < a ∧ Tendsto stirlingSeq atTop (𝓝 a)", "start": [ 193, 1 ], "end": [ 199, 59 ], "kind": "commanddeclaration" }, { "full_name": "Stirling.tendsto_self_div_two_mul_self_add_one", "code": "theorem tendsto_self_div_two_mul_self_add_one :\n Tendsto (fun n : ℕ => (n : ℝ) / (2 * n + 1)) atTop (𝓝 (1 / 2))", "start": [ 208, 1 ], "end": [ 218, 83 ], "kind": "commanddeclaration" }, { "full_name": "Stirling.stirlingSeq_pow_four_div_stirlingSeq_pow_two_eq", "code": "theorem stirlingSeq_pow_four_div_stirlingSeq_pow_two_eq (n : ℕ) (hn : n ≠ 0) :\n stirlingSeq n ^ 4 / stirlingSeq (2 * n) ^ 2 * (n / (2 * n + 1)) = Wallis.W n", "start": [ 221, 1 ], "end": [ 232, 10 ], "kind": "commanddeclaration" }, { "full_name": "Stirling.second_wallis_limit", "code": "theorem second_wallis_limit (a : ℝ) (hane : a ≠ 0) (ha : Tendsto stirlingSeq atTop (𝓝 a)) :\n Tendsto Wallis.W atTop (𝓝 (a ^ 2 / 2))", "start": [ 235, 1 ], "end": [ 247, 68 ], "kind": "commanddeclaration" }, { "full_name": "Stirling.tendsto_stirlingSeq_sqrt_pi", "code": "theorem tendsto_stirlingSeq_sqrt_pi : Tendsto stirlingSeq atTop (𝓝 (√π))", "start": [ 250, 1 ], "end": [ 255, 65 ], "kind": "commanddeclaration" }, { "full_name": "Stirling.factorial_isEquivalent_stirling", "code": "lemma factorial_isEquivalent_stirling :\n (fun n ↦ n ! : ℕ → ℝ) ~[atTop] fun n ↦ Real.sqrt (2 * n * π) * (n / exp 1) ^ n := by\n refine Asymptotics.isEquivalent_of_tendsto_one ?_ ?_\n · filter_upwards [eventually_ne_atTop 0] with n hn h\n exact absurd h (by positivity)\n · have : sqrt π ≠ 0 := by positivity\n nth_rewrite 2 [← div_self this]\n convert tendsto_stirlingSeq_sqrt_pi.div tendsto_const_nhds this using 1\n ext n\n field_simp [stirlingSeq, mul_right_comm]", "start": [ 258, 1 ], "end": [ 268, 45 ], "kind": "lemma" } ]

[ "Mathlib/CategoryTheory/Abelian/Opposite.lean", "Mathlib/CategoryTheory/Abelian/Subobject.lean", "Mathlib/CategoryTheory/Preadditive/Injective.lean", ".lake/packages/lean4/src/lean/Init.lean", "Mathlib/CategoryTheory/Limits/EssentiallySmall.lean", "Mathlib/CategoryTheory/Preadditive/Generator.lean" ]

[ { "full_name": "CategoryTheory.Abelian.has_injective_coseparator", "code": "theorem has_injective_coseparator [HasLimits C] [EnoughInjectives C] (G : C) (hG : IsSeparator G) :\n ∃ G : C, Injective G ∧ IsCoseparator G", "start": [ 35, 1 ], "end": [ 52, 38 ], "kind": "commanddeclaration" }, { "full_name": "CategoryTheory.Abelian.has_projective_separator", "code": "theorem has_projective_separator [HasColimits C] [EnoughProjectives C] (G : C)\n (hG : IsCoseparator G) : ∃ G : C, Projective G ∧ IsSeparator G", "start": [ 55, 1 ], "end": [ 58, 64 ], "kind": "commanddeclaration" } ]

[ "Mathlib/MeasureTheory/Covering/BesicovitchVectorSpace.lean", "Mathlib/MeasureTheory/Integral/Average.lean", ".lake/packages/lean4/src/lean/Init.lean", "Mathlib/Analysis/Convolution.lean", "Mathlib/MeasureTheory/Covering/Differentiation.lean", "Mathlib/Analysis/Calculus/BumpFunction/Normed.lean", "Mathlib/MeasureTheory/Measure/Haar/Unique.lean" ]

[ { "full_name": "ContDiffBump.convolution_eq_right", "code": "theorem convolution_eq_right {x₀ : G} (hg : ∀ x ∈ ball x₀ φ.rOut, g x = g x₀) :\n (φ ⋆[lsmul ℝ ℝ, μ] g : G → E') x₀ = integral μ φ • g x₀", "start": [ 52, 1 ], "end": [ 56, 93 ], "kind": "commanddeclaration" }, { "full_name": "ContDiffBump.normed_convolution_eq_right", "code": "theorem normed_convolution_eq_right {x₀ : G} (hg : ∀ x ∈ ball x₀ φ.rOut, g x = g x₀) :\n (φ.normed μ ⋆[lsmul ℝ ℝ, μ] g : G → E') x₀ = g x₀", "start": [ 63, 1 ], "end": [ 68, 40 ], "kind": "commanddeclaration" }, { "full_name": "ContDiffBump.dist_normed_convolution_le", "code": "theorem dist_normed_convolution_le {x₀ : G} {ε : ℝ} (hmg : AEStronglyMeasurable g μ)\n (hg : ∀ x ∈ ball x₀ φ.rOut, dist (g x) (g x₀) ≤ ε) :\n dist ((φ.normed μ ⋆[lsmul ℝ ℝ, μ] g : G → E') x₀) (g x₀) ≤ ε", "start": [ 73, 1 ], "end": [ 79, 72 ], "kind": "commanddeclaration" }, { "full_name": "ContDiffBump.convolution_tendsto_right", "code": "nonrec theorem convolution_tendsto_right {ι} {φ : ι → ContDiffBump (0 : G)} {g : ι → G → E'}\n {k : ι → G} {x₀ : G} {z₀ : E'} {l : Filter ι} (hφ : Tendsto (fun i => (φ i).rOut) l (𝓝 0))\n (hig : ∀ᶠ i in l, AEStronglyMeasurable (g i) μ) (hcg : Tendsto (uncurry g) (l ×ˢ 𝓝 x₀) (𝓝 z₀))\n (hk : Tendsto k l (𝓝 x₀)) :\n Tendsto (fun i => ((φ i).normed μ ⋆[lsmul ℝ ℝ, μ] g i) (k i)) l (𝓝 z₀)", "start": [ 82, 1 ], "end": [ 95, 11 ], "kind": "commanddeclaration" }, { "full_name": "ContDiffBump.convolution_tendsto_right_of_continuous", "code": "theorem convolution_tendsto_right_of_continuous {ι} {φ : ι → ContDiffBump (0 : G)} {l : Filter ι}\n (hφ : Tendsto (fun i => (φ i).rOut) l (𝓝 0)) (hg : Continuous g) (x₀ : G) :\n Tendsto (fun i => ((φ i).normed μ ⋆[lsmul ℝ ℝ, μ] g) x₀) l (𝓝 (g x₀))", "start": [ 98, 1 ], "end": [ 104, 58 ], "kind": "commanddeclaration" }, { "full_name": "ContDiffBump.ae_convolution_tendsto_right_of_locallyIntegrable", "code": "theorem ae_convolution_tendsto_right_of_locallyIntegrable\n {ι} {φ : ι → ContDiffBump (0 : G)} {l : Filter ι} {K : ℝ}\n (hφ : Tendsto (fun i ↦ (φ i).rOut) l (𝓝 0))\n (h'φ : ∀ᶠ i in l, (φ i).rOut ≤ K * (φ i).rIn) (hg : LocallyIntegrable g μ) : ∀ᵐ x₀ ∂μ,\n Tendsto (fun i ↦ ((φ i).normed μ ⋆[lsmul ℝ ℝ, μ] g) x₀) l (𝓝 (g x₀))", "start": [ 107, 1 ], "end": [ 139, 63 ], "kind": "commanddeclaration" } ]

[ ".lake/packages/lean4/src/lean/Init.lean", "Mathlib/Data/List/AList.lean", "Mathlib/Data/Finsupp/Basic.lean" ]

[ { "full_name": "Finsupp.toAList", "code": "@[simps]\nnoncomputable def toAList (f : α →₀ M) : AList fun _x : α => M :=\n ⟨f.graph.toList.map Prod.toSigma,\n by\n rw [List.NodupKeys, List.keys, List.map_map, Prod.fst_comp_toSigma, List.nodup_map_iff_inj_on]\n · rintro ⟨b, m⟩ hb ⟨c, n⟩ hc (rfl : b = c)\n rw [Finset.mem_toList, Finsupp.mem_graph_iff] at hb hc\n dsimp at hb hc\n rw [← hc.1, hb.1]\n · apply Finset.nodup_toList⟩", "start": [ 27, 1 ], "end": [ 37, 35 ], "kind": "commanddeclaration" }, { "full_name": "Finsupp.toAList_keys_toFinset", "code": "@[simp]\ntheorem toAList_keys_toFinset [DecidableEq α] (f : α →₀ M) :\n f.toAList.keys.toFinset = f.support", "start": [ 40, 1 ], "end": [ 44, 56 ], "kind": "commanddeclaration" }, { "full_name": "Finsupp.mem_toAlist", "code": "@[simp]\ntheorem mem_toAlist {f : α →₀ M} {x : α} : x ∈ f.toAList ↔ f x ≠ 0", "start": [ 47, 1 ], "end": [ 49, 93 ], "kind": "commanddeclaration" }, { "full_name": "AList.lookupFinsupp", "code": "noncomputable def lookupFinsupp (l : AList fun _x : α => M) : α →₀ M where\n support := by\n haveI := Classical.decEq α; haveI := Classical.decEq M\n exact (l.1.filter fun x => Sigma.snd x ≠ 0).keys.toFinset\n toFun a :=\n haveI := Classical.decEq α\n (l.lookup a).getD 0\n mem_support_toFun a := by\n classical\n simp_rw [@mem_toFinset _ _, List.mem_keys, List.mem_filter, ← mem_lookup_iff]\n cases lookup a l <;> simp", "start": [ 60, 1 ], "end": [ 72, 32 ], "kind": "commanddeclaration" }, { "full_name": "AList.lookupFinsupp_apply", "code": "@[simp]\ntheorem lookupFinsupp_apply [DecidableEq α] (l : AList fun _x : α => M) (a : α) :\n l.lookupFinsupp a = (l.lookup a).getD 0", "start": [ 75, 1 ], "end": [ 78, 23 ], "kind": "commanddeclaration" }, { "full_name": "AList.lookupFinsupp_support", "code": "@[simp]\ntheorem lookupFinsupp_support [DecidableEq α] [DecidableEq M] (l : AList fun _x : α => M) :\n l.lookupFinsupp.support = (l.1.filter fun x => Sigma.snd x ≠ 0).keys.toFinset", "start": [ 81, 1 ], "end": [ 86, 18 ], "kind": "commanddeclaration" }, { "full_name": "AList.lookupFinsupp_eq_iff_of_ne_zero", "code": "theorem lookupFinsupp_eq_iff_of_ne_zero [DecidableEq α] {l : AList fun _x : α => M} {a : α} {x : M}\n (hx : x ≠ 0) : l.lookupFinsupp a = x ↔ x ∈ l.lookup a", "start": [ 89, 1 ], "end": [ 92, 46 ], "kind": "commanddeclaration" }, { "full_name": "AList.lookupFinsupp_eq_zero_iff", "code": "theorem lookupFinsupp_eq_zero_iff [DecidableEq α] {l : AList fun _x : α => M} {a : α} :\n l.lookupFinsupp a = 0 ↔ a ∉ l ∨ (0 : M) ∈ l.lookup a", "start": [ 95, 1 ], "end": [ 98, 36 ], "kind": "commanddeclaration" }, { "full_name": "AList.empty_lookupFinsupp", "code": "@[simp]\ntheorem empty_lookupFinsupp : lookupFinsupp (∅ : AList fun _x : α => M) = 0", "start": [ 101, 1 ], "end": [ 105, 9 ], "kind": "commanddeclaration" }, { "full_name": "AList.insert_lookupFinsupp", "code": "@[simp]\ntheorem insert_lookupFinsupp [DecidableEq α] (l : AList fun _x : α => M) (a : α) (m : M) :\n (l.insert a m).lookupFinsupp = l.lookupFinsupp.update a m", "start": [ 108, 1 ], "end": [ 112, 34 ], "kind": "commanddeclaration" }, { "full_name": "AList.singleton_lookupFinsupp", "code": "@[simp]\ntheorem singleton_lookupFinsupp (a : α) (m : M) :\n (singleton a m).lookupFinsupp = Finsupp.single a m", "start": [ 115, 1 ], "end": [ 120, 99 ], "kind": "commanddeclaration" }, { "full_name": "Finsupp.toAList_lookupFinsupp", "code": "@[simp]\ntheorem _root_.Finsupp.toAList_lookupFinsupp (f : α →₀ M) : f.toAList.lookupFinsupp = f", "start": [ 123, 1 ], "end": [ 132, 20 ], "kind": "commanddeclaration" }, { "full_name": "AList.lookupFinsupp_surjective", "code": "theorem lookupFinsupp_surjective : Function.Surjective (@lookupFinsupp α M _)", "start": [ 135, 1 ], "end": [ 136, 39 ], "kind": "commanddeclaration" } ]

[ "Mathlib/Data/Set/Image.lean", "Mathlib/Data/List/InsertNth.lean", ".lake/packages/lean4/src/lean/Init.lean", "Mathlib/Init/Data/List/Lemmas.lean" ]

[ { "full_name": "List.injOn_insertNth_index_of_not_mem", "code": "theorem injOn_insertNth_index_of_not_mem (l : List α) (x : α) (hx : x ∉ l) :\n Set.InjOn (fun k => insertNth k x l) { n | n ≤ l.length }", "start": [ 23, 1 ], "end": [ 41, 46 ], "kind": "commanddeclaration" }, { "full_name": "List.foldr_range_subset_of_range_subset", "code": "theorem foldr_range_subset_of_range_subset {f : β → α → α} {g : γ → α → α}\n (hfg : Set.range f ⊆ Set.range g) (a : α) : Set.range (foldr f a) ⊆ Set.range (foldr g a)", "start": [ 44, 1 ], "end": [ 52, 24 ], "kind": "commanddeclaration" }, { "full_name": "List.foldl_range_subset_of_range_subset", "code": "theorem foldl_range_subset_of_range_subset {f : α → β → α} {g : α → γ → α}\n (hfg : (Set.range fun a c => f c a) ⊆ Set.range fun b c => g c b) (a : α) :\n Set.range (foldl f a) ⊆ Set.range (foldl g a)", "start": [ 55, 1 ], "end": [ 66, 49 ], "kind": "commanddeclaration" }, { "full_name": "List.foldr_range_eq_of_range_eq", "code": "theorem foldr_range_eq_of_range_eq {f : β → α → α} {g : γ → α → α} (hfg : Set.range f = Set.range g)\n (a : α) : Set.range (foldr f a) = Set.range (foldr g a)", "start": [ 69, 1 ], "end": [ 72, 50 ], "kind": "commanddeclaration" }, { "full_name": "List.foldl_range_eq_of_range_eq", "code": "theorem foldl_range_eq_of_range_eq {f : α → β → α} {g : α → γ → α}\n (hfg : (Set.range fun a c => f c a) = Set.range fun b c => g c b) (a : α) :\n Set.range (foldl f a) = Set.range (foldl g a)", "start": [ 75, 1 ], "end": [ 79, 50 ], "kind": "commanddeclaration" }, { "full_name": "List.mapAccumr_eq_foldr", "code": "theorem mapAccumr_eq_foldr {σ : Type*} (f : α → σ → σ × β) : ∀ (as : List α) (s : σ),\n mapAccumr f as s = List.foldr (fun a s =>\n let r := f a s.1\n (r.1, r.2 :: s.2)\n ) (s, []) as", "start": [ 90, 1 ], "end": [ 97, 58 ], "kind": "commanddeclaration" }, { "full_name": "List.mapAccumr₂_eq_foldr", "code": "theorem mapAccumr₂_eq_foldr {σ φ : Type*} (f : α → β → σ → σ × φ) :\n ∀ (as : List α) (bs : List β) (s : σ),\n mapAccumr₂ f as bs s = foldr (fun ab s =>\n let r := f ab.1 ab.2 s.1\n (r.1, r.2 :: s.2)\n ) (s, []) (as.zip bs)", "start": [ 99, 1 ], "end": [ 110, 8 ], "kind": "commanddeclaration" } ]

[ "Mathlib/Order/Filter/ListTraverse.lean", "Mathlib/Topology/Constructions.lean", "Mathlib/Tactic/AdaptationNote.lean", "Mathlib/Topology/Algebra/Monoid.lean", ".lake/packages/lean4/src/lean/Init.lean" ]

[ { "full_name": "nhds_list", "code": "theorem nhds_list (as : List α) : 𝓝 as = traverse 𝓝 as", "start": [ 28, 1 ], "end": [ 66, 80 ], "kind": "commanddeclaration" }, { "full_name": "nhds_nil", "code": "@[simp]\ntheorem nhds_nil : 𝓝 ([] : List α) = pure []", "start": [ 69, 1 ], "end": [ 71, 38 ], "kind": "commanddeclaration" }, { "full_name": "nhds_cons", "code": "theorem nhds_cons (a : α) (l : List α) : 𝓝 (a::l) = List.cons <$> 𝓝 a <*> 𝓝 l", "start": [ 74, 1 ], "end": [ 75, 52 ], "kind": "commanddeclaration" }, { "full_name": "List.tendsto_cons", "code": "theorem List.tendsto_cons {a : α} {l : List α} :\n Tendsto (fun p : α × List α => List.cons p.1 p.2) (𝓝 a ×ˢ 𝓝 l) (𝓝 (a::l))", "start": [ 78, 1 ], "end": [ 80, 57 ], "kind": "commanddeclaration" }, { "full_name": "Filter.Tendsto.cons", "code": "theorem Filter.Tendsto.cons {α : Type*} {f : α → β} {g : α → List β} {a : Filter α} {b : β}\n {l : List β} (hf : Tendsto f a (𝓝 b)) (hg : Tendsto g a (𝓝 l)) :\n Tendsto (fun a => List.cons (f a) (g a)) a (𝓝 (b::l))", "start": [ 83, 1 ], "end": [ 86, 49 ], "kind": "commanddeclaration" }, { "full_name": "List.tendsto_cons_iff", "code": "theorem tendsto_cons_iff {β : Type*} {f : List α → β} {b : Filter β} {a : α} {l : List α} :\n Tendsto f (𝓝 (a::l)) b ↔ Tendsto (fun p : α × List α => f (p.1::p.2)) (𝓝 a ×ˢ 𝓝 l) b", "start": [ 91, 1 ], "end": [ 97, 42 ], "kind": "commanddeclaration" }, { "full_name": "List.continuous_cons", "code": "theorem continuous_cons : Continuous fun x : α × List α => (x.1::x.2 : List α)", "start": [ 100, 1 ], "end": [ 101, 89 ], "kind": "commanddeclaration" }, { "full_name": "List.tendsto_nhds", "code": "theorem tendsto_nhds {β : Type*} {f : List α → β} {r : List α → Filter β}\n (h_nil : Tendsto f (pure []) (r []))\n (h_cons :\n ∀ l a,\n Tendsto f (𝓝 l) (r l) →\n Tendsto (fun p : α × List α => f (p.1::p.2)) (𝓝 a ×ˢ 𝓝 l) (r (a::l))) :\n ∀ l, Tendsto f (𝓝 l) (r l)", "start": [ 104, 1 ], "end": [ 113, 81 ], "kind": "commanddeclaration" }, { "full_name": "List.continuousAt_length", "code": "theorem continuousAt_length : ∀ l : List α, ContinuousAt List.length l", "start": [ 119, 1 ], "end": [ 126, 38 ], "kind": "commanddeclaration" }, { "full_name": "List.tendsto_insertNth'", "code": "theorem tendsto_insertNth' {a : α} :\n ∀ {n : ℕ} {l : List α},\n Tendsto (fun p : α × List α => insertNth n p.1 p.2) (𝓝 a ×ˢ 𝓝 l) (𝓝 (insertNth n a l))", "start": [ 129, 1 ], "end": [ 142, 98 ], "kind": "commanddeclaration" }, { "full_name": "List.tendsto_insertNth", "code": "theorem tendsto_insertNth {β} {n : ℕ} {a : α} {l : List α} {f : β → α} {g : β → List α}\n {b : Filter β} (hf : Tendsto f b (𝓝 a)) (hg : Tendsto g b (𝓝 l)) :\n Tendsto (fun b : β => insertNth n (f b) (g b)) b (𝓝 (insertNth n a l))", "start": [ 145, 1 ], "end": [ 148, 50 ], "kind": "commanddeclaration" }, { "full_name": "List.continuous_insertNth", "code": "theorem continuous_insertNth {n : ℕ} : Continuous fun p : α × List α => insertNth n p.1 p.2", "start": [ 151, 1 ], "end": [ 153, 62 ], "kind": "commanddeclaration" }, { "full_name": "List.tendsto_eraseIdx", "code": "theorem tendsto_eraseIdx :\n ∀ {n : ℕ} {l : List α}, Tendsto (eraseIdx · n) (𝓝 l) (𝓝 (eraseIdx l n))", "start": [ 156, 1 ], "end": [ 163, 70 ], "kind": "commanddeclaration" }, { "full_name": "List.continuous_eraseIdx", "code": "theorem continuous_eraseIdx {n : ℕ} : Continuous fun l : List α => eraseIdx l n", "start": [ 168, 1 ], "end": [ 169, 61 ], "kind": "commanddeclaration" }, { "full_name": "List.tendsto_prod", "code": "@[to_additive]\ntheorem tendsto_prod [Monoid α] [ContinuousMul α] {l : List α} :\n Tendsto List.prod (𝓝 l) (𝓝 l.prod)", "start": [ 174, 1 ], "end": [ 182, 43 ], "kind": "commanddeclaration" }, { "full_name": "List.continuous_prod", "code": "@[to_additive]\ntheorem continuous_prod [Monoid α] [ContinuousMul α] : Continuous (prod : List α → α)", "start": [ 186, 1 ], "end": [ 188, 57 ], "kind": "commanddeclaration" }, { "full_name": "Vector.tendsto_cons", "code": "theorem tendsto_cons {n : ℕ} {a : α} {l : Vector α n} :\n Tendsto (fun p : α × Vector α n => p.1 ::ᵥ p.2) (𝓝 a ×ˢ 𝓝 l) (𝓝 (a ::ᵥ l))", "start": [ 200, 1 ], "end": [ 203, 77 ], "kind": "commanddeclaration" }, { "full_name": "Vector.tendsto_insertNth", "code": "theorem tendsto_insertNth {n : ℕ} {i : Fin (n + 1)} {a : α} :\n ∀ {l : Vector α n},\n Tendsto (fun p : α × Vector α n => insertNth p.1 i p.2) (𝓝 a ×ˢ 𝓝 l) (𝓝 (insertNth a i l))", "start": [ 206, 1 ], "end": [ 212, 101 ], "kind": "commanddeclaration" }, { "full_name": "Vector.continuous_insertNth'", "code": "theorem continuous_insertNth' {n : ℕ} {i : Fin (n + 1)} :\n Continuous fun p : α × Vector α n => insertNth p.1 i p.2", "start": [ 215, 1 ], "end": [ 218, 61 ], "kind": "commanddeclaration" }, { "full_name": "Vector.continuous_insertNth", "code": "theorem continuous_insertNth {n : ℕ} {i : Fin (n + 1)} {f : β → α} {g : β → Vector α n}\n (hf : Continuous f) (hg : Continuous g) : Continuous fun b => insertNth (f b) i (g b)", "start": [ 221, 1 ], "end": [ 223, 49 ], "kind": "commanddeclaration" }, { "full_name": "Vector.continuousAt_eraseIdx", "code": "theorem continuousAt_eraseIdx {n : ℕ} {i : Fin (n + 1)} :\n ∀ {l : Vector α (n + 1)}, ContinuousAt (eraseIdx i) l", "start": [ 226, 1 ], "end": [ 231, 70 ], "kind": "commanddeclaration" }, { "full_name": "Vector.continuous_eraseIdx", "code": "theorem continuous_eraseIdx {n : ℕ} {i : Fin (n + 1)} :\n Continuous (eraseIdx i : Vector α (n + 1) → Vector α n)", "start": [ 236, 1 ], "end": [ 238, 72 ], "kind": "commanddeclaration" } ]

[ "Mathlib/Data/Set/Constructions.lean", "Mathlib/CategoryTheory/Monad/Types.lean", "Mathlib/CategoryTheory/Equivalence.lean", "Mathlib/Topology/Category/CompHaus/Basic.lean", ".lake/packages/lean4/src/lean/Init.lean", "Mathlib/CategoryTheory/Monad/Limits.lean", "Mathlib/Topology/Category/Profinite/Basic.lean" ]

[ { "full_name": "Compactum", "code": "def Compactum :=\n Monad.Algebra β deriving Category, Inhabited", "start": [ 84, 1 ], "end": [ 86, 47 ], "kind": "commanddeclaration" }, { "full_name": "Compactum.forget", "code": "def forget : Compactum ⥤ Type* :=\n Monad.forget _", "start": [ 91, 1 ], "end": [ 93, 17 ], "kind": "commanddeclaration" }, { "full_name": "Compactum.free", "code": "def free : Type* ⥤ Compactum :=\n Monad.free _", "start": [ 103, 1 ], "end": [ 105, 15 ], "kind": "commanddeclaration" }, { "full_name": "Compactum.adj", "code": "def adj : free ⊣ forget :=\n Monad.adj _", "start": [ 108, 1 ], "end": [ 110, 14 ], "kind": "commanddeclaration" }, { "full_name": "Compactum.str", "code": "def str (X : Compactum) : Ultrafilter X → X :=\n X.a", "start": [ 126, 1 ], "end": [ 128, 6 ], "kind": "commanddeclaration" }, { "full_name": "Compactum.join", "code": "def join (X : Compactum) : Ultrafilter (Ultrafilter X) → Ultrafilter X :=\n (β ).μ.app _", "start": [ 131, 1 ], "end": [ 133, 15 ], "kind": "commanddeclaration" }, { "full_name": "Compactum.incl", "code": "def incl (X : Compactum) : X → Ultrafilter X :=\n (β ).η.app _", "start": [ 136, 1 ], "end": [ 138, 15 ], "kind": "commanddeclaration" }, { "full_name": "Compactum.str_incl", "code": "@[simp]\ntheorem str_incl (X : Compactum) (x : X) : X.str (X.incl x) = x", "start": [ 141, 1 ], "end": [ 145, 6 ], "kind": "commanddeclaration" }, { "full_name": "Compactum.str_hom_commute", "code": "@[simp]\ntheorem str_hom_commute (X Y : Compactum) (f : X ⟶ Y) (xs : Ultrafilter X) :\n f (X.str xs) = Y.str (map f xs)", "start": [ 148, 1 ], "end": [ 153, 6 ], "kind": "commanddeclaration" }, { "full_name": "Compactum.join_distrib", "code": "@[simp]\ntheorem join_distrib (X : Compactum) (uux : Ultrafilter (Ultrafilter X)) :\n X.str (X.join uux) = X.str (map X.str uux)", "start": [ 156, 1 ], "end": [ 161, 6 ], "kind": "commanddeclaration" }, { "full_name": "Compactum.isClosed_iff", "code": "theorem isClosed_iff {X : Compactum} (S : Set X) :\n IsClosed S ↔ ∀ F : Ultrafilter X, S ∈ F → X.str F ∈ S", "start": [ 172, 1 ], "end": [ 184, 33 ], "kind": "commanddeclaration" }, { "full_name": "Compactum.basic", "code": "private def basic {X : Compactum} (A : Set X) : Set (Ultrafilter X) :=\n { F | A ∈ F }", "start": [ 196, 1 ], "end": [ 198, 16 ], "kind": "commanddeclaration" }, { "full_name": "Compactum.cl", "code": "private def cl {X : Compactum} (A : Set X) : Set X :=\n X.str '' basic A", "start": [ 200, 1 ], "end": [ 202, 19 ], "kind": "commanddeclaration" }, { "full_name": "Compactum.basic_inter", "code": "private theorem basic_inter {X : Compactum} (A B : Set X) : basic (A ∩ B) = basic A ∩ basic B", "start": [ 204, 1 ], "end": [ 211, 26 ], "kind": "commanddeclaration" }, { "full_name": "Compactum.subset_cl", "code": "private theorem subset_cl {X : Compactum} (A : Set X) : A ⊆ cl A", "start": [ 213, 1 ], "end": [ 214, 26 ], "kind": "commanddeclaration" }, { "full_name": "Compactum.cl_cl", "code": "private theorem cl_cl {X : Compactum} (A : Set X) : cl (cl A) ⊆ cl A", "start": [ 216, 1 ], "end": [ 273, 44 ], "kind": "commanddeclaration" }, { "full_name": "Compactum.isClosed_cl", "code": "theorem isClosed_cl {X : Compactum} (A : Set X) : IsClosed (cl A)", "start": [ 275, 1 ], "end": [ 278, 29 ], "kind": "commanddeclaration" }, { "full_name": "Compactum.str_eq_of_le_nhds", "code": "theorem str_eq_of_le_nhds {X : Compactum} (F : Ultrafilter X) (x : X) : ↑F ≤ 𝓝 x → X.str F = x", "start": [ 281, 1 ], "end": [ 349, 44 ], "kind": "commanddeclaration" }, { "full_name": "Compactum.le_nhds_of_str_eq", "code": "theorem le_nhds_of_str_eq {X : Compactum} (F : Ultrafilter X) (x : X) : X.str F = x → ↑F ≤ 𝓝 x", "start": [ 352, 1 ], "end": [ 353, 61 ], "kind": "commanddeclaration" }, { "full_name": "Compactum.lim_eq_str", "code": "theorem lim_eq_str {X : Compactum} (F : Ultrafilter X) : F.lim = X.str F", "start": [ 362, 1 ], "end": [ 365, 8 ], "kind": "commanddeclaration" }, { "full_name": "Compactum.cl_eq_closure", "code": "theorem cl_eq_closure {X : Compactum} (A : Set X) : cl A = closure A", "start": [ 368, 1 ], "end": [ 375, 44 ], "kind": "commanddeclaration" }, { "full_name": "Compactum.continuous_of_hom", "code": "theorem continuous_of_hom {X Y : Compactum} (f : X ⟶ Y) : Continuous f", "start": [ 378, 1 ], "end": [ 385, 10 ], "kind": "commanddeclaration" }, { "full_name": "Compactum.ofTopologicalSpace", "code": "noncomputable def ofTopologicalSpace (X : Type*) [TopologicalSpace X] [CompactSpace X]\n [T2Space X] : Compactum where\n A := X\n a := Ultrafilter.lim\n unit := by\n ext x\n exact lim_eq (pure_le_nhds _)\n assoc := by\n ext FF\n change Ultrafilter (Ultrafilter X) at FF\n set x := (Ultrafilter.map Ultrafilter.lim FF).lim with c1\n have c2 : ∀ (U : Set X) (F : Ultrafilter X), F.lim ∈ U → IsOpen U → U ∈ F := by\n intro U F h1 hU\n exact isOpen_iff_ultrafilter.mp hU _ h1 _ (Ultrafilter.le_nhds_lim _)\n have c3 : ↑(Ultrafilter.map Ultrafilter.lim FF) ≤ 𝓝 x := by\n rw [le_nhds_iff]\n intro U hx hU\n exact mem_coe.2 (c2 _ _ (by rwa [← c1]) hU)\n have c4 : ∀ U : Set X, x ∈ U → IsOpen U → { G : Ultrafilter X | U ∈ G } ∈ FF := by\n intro U hx hU\n suffices Ultrafilter.lim ⁻¹' U ∈ FF by\n apply mem_of_superset this\n intro P hP\n exact c2 U P hP hU\n exact @c3 U (IsOpen.mem_nhds hU hx)\n apply lim_eq\n rw [le_nhds_iff]\n exact c4", "start": [ 388, 1 ], "end": [ 416, 13 ], "kind": "commanddeclaration" }, { "full_name": "Compactum.homOfContinuous", "code": "def homOfContinuous {X Y : Compactum} (f : X → Y) (cont : Continuous f) : X ⟶ Y :=\n { f\n h := by\n rw [continuous_iff_ultrafilter] at cont\n ext (F : Ultrafilter X)\n specialize cont (X.str F) F (le_nhds_of_str_eq F (X.str F) rfl)\n simp only [types_comp_apply, ofTypeFunctor_map]\n exact str_eq_of_le_nhds (Ultrafilter.map f F) _ cont }", "start": [ 419, 1 ], "end": [ 427, 61 ], "kind": "commanddeclaration" }, { "full_name": "compactumToCompHaus", "code": "def compactumToCompHaus : Compactum ⥤ CompHaus where\n obj X := { toTop := { α := X } }\n map := @fun X Y f =>\n { toFun := f\n continuous_toFun := Compactum.continuous_of_hom _ }", "start": [ 432, 1 ], "end": [ 437, 58 ], "kind": "commanddeclaration" }, { "full_name": "compactumToCompHaus.full", "code": "instance full : compactumToCompHaus.{u}.Full where\n map_surjective f := ⟨Compactum.homOfContinuous f.1 f.2, rfl⟩", "start": [ 442, 1 ], "end": [ 444, 63 ], "kind": "commanddeclaration" }, { "full_name": "compactumToCompHaus.faithful", "code": "instance faithful : compactumToCompHaus.Faithful where\n map_injective := by\n intro _ _ _ _ h\n apply Monad.Algebra.Hom.ext\n apply congrArg (fun f => f.toFun) h", "start": [ 447, 1 ], "end": [ 454, 40 ], "kind": "commanddeclaration" }, { "full_name": "compactumToCompHaus.isoOfTopologicalSpace", "code": "def isoOfTopologicalSpace {D : CompHaus} :\n compactumToCompHaus.obj (Compactum.ofTopologicalSpace D) ≅ D where\n hom :=\n { toFun := id\n continuous_toFun :=\n continuous_def.2 fun _ h => by\n rw [isOpen_iff_ultrafilter'] at h\n exact h }\n inv :=\n { toFun := id\n continuous_toFun :=\n continuous_def.2 fun _ h1 => by\n rw [isOpen_iff_ultrafilter']\n intro _ h2\n exact h1 _ h2 }", "start": [ 457, 1 ], "end": [ 472, 26 ], "kind": "commanddeclaration" }, { "full_name": "compactumToCompHaus.essSurj", "code": "instance essSurj : compactumToCompHaus.EssSurj :=\n { mem_essImage := fun X => ⟨Compactum.ofTopologicalSpace X, ⟨isoOfTopologicalSpace⟩⟩ }", "start": [ 475, 1 ], "end": [ 477, 89 ], "kind": "commanddeclaration" }, { "full_name": "compactumToCompHaus.isEquivalence", "code": "instance isEquivalence : compactumToCompHaus.IsEquivalence where", "start": [ 480, 1 ], "end": [ 481, 65 ], "kind": "commanddeclaration" }, { "full_name": "compactumToCompHausCompForget", "code": "def compactumToCompHausCompForget :\n compactumToCompHaus ⋙ CategoryTheory.forget CompHaus ≅ Compactum.forget :=\n NatIso.ofComponents fun X => eqToIso rfl", "start": [ 486, 1 ], "end": [ 490, 43 ], "kind": "commanddeclaration" }, { "full_name": "CompHaus.forgetCreatesLimits", "code": "noncomputable instance CompHaus.forgetCreatesLimits : CreatesLimits (forget CompHaus) := by\n let e : forget CompHaus ≅ compactumToCompHaus.inv ⋙ Compactum.forget :=\n (((forget CompHaus).leftUnitor.symm ≪≫\n isoWhiskerRight compactumToCompHaus.asEquivalence.symm.unitIso (forget CompHaus)) ≪≫\n compactumToCompHaus.inv.associator compactumToCompHaus (forget CompHaus)) ≪≫\n isoWhiskerLeft _ compactumToCompHausCompForget\n exact createsLimitsOfNatIso e.symm", "start": [ 500, 1 ], "end": [ 506, 37 ], "kind": "commanddeclaration" }, { "full_name": "Profinite.forgetCreatesLimits", "code": "noncomputable instance Profinite.forgetCreatesLimits : CreatesLimits (forget Profinite) := by\n change CreatesLimits (profiniteToCompHaus ⋙ forget _)\n infer_instance", "start": [ 510, 1 ], "end": [ 512, 17 ], "kind": "commanddeclaration" } ]

[ ".lake/packages/lean4/src/lean/Init.lean", "Mathlib/RingTheory/Unramified/Basic.lean", "Mathlib/RingTheory/Kaehler/Basic.lean" ]

[ { "full_name": "Algebra.FormallyUnramified.subsingleton_kaehlerDifferential", "code": "instance FormallyUnramified.subsingleton_kaehlerDifferential [FormallyUnramified R S] :\n Subsingleton (Ω[S⁄R]) := by\n rw [← not_nontrivial_iff_subsingleton]\n intro h\n obtain ⟨f₁, f₂, e⟩ := (KaehlerDifferential.endEquiv R S).injective.nontrivial\n apply e\n ext1\n apply FormallyUnramified.lift_unique' _ _ _ _ (f₁.2.trans f₂.2.symm)\n rw [← AlgHom.toRingHom_eq_coe, AlgHom.ker_kerSquareLift]\n exact ⟨_, Ideal.cotangentIdeal_square _⟩", "start": [ 23, 1 ], "end": [ 32, 43 ], "kind": "commanddeclaration" }, { "full_name": "Algebra.FormallyUnramified.iff_subsingleton_kaehlerDifferential", "code": "theorem FormallyUnramified.iff_subsingleton_kaehlerDifferential :\n FormallyUnramified R S ↔ Subsingleton (Ω[S⁄R])", "start": [ 35, 1 ], "end": [ 47, 80 ], "kind": "commanddeclaration" } ]

[ "Mathlib/Combinatorics/Pigeonhole.lean", ".lake/packages/lean4/src/lean/Init.lean", "Mathlib/Dynamics/Ergodic/MeasurePreserving.lean", "Mathlib/MeasureTheory/Constructions/BorelSpace/Basic.lean" ]

[ { "full_name": "MeasureTheory.Conservative", "code": "structure Conservative (f : α → α) (μ : Measure α) extends QuasiMeasurePreserving f μ μ : Prop where\n \n exists_mem_iterate_mem : ∀ ⦃s⦄, MeasurableSet s → μ s ≠ 0 → ∃ x ∈ s, ∃ m ≠ 0, f^[m] x ∈ s", "start": [ 55, 1 ], "end": [ 61, 92 ], "kind": "commanddeclaration" }, { "full_name": "MeasureTheory.MeasurePreserving.conservative", "code": "protected theorem MeasurePreserving.conservative [IsFiniteMeasure μ] (h : MeasurePreserving f μ μ) :\n Conservative f μ", "start": [ 64, 1 ], "end": [ 67, 78 ], "kind": "commanddeclaration" }, { "full_name": "MeasureTheory.Conservative.id", "code": "protected theorem id (μ : Measure α) : Conservative id μ", "start": [ 72, 1 ], "end": [ 77, 36 ], "kind": "commanddeclaration" }, { "full_name": "MeasureTheory.Conservative.frequently_measure_inter_ne_zero", "code": "theorem frequently_measure_inter_ne_zero (hf : Conservative f μ) (hs : MeasurableSet s)\n (h0 : μ s ≠ 0) : ∃ᶠ m in atTop, μ (s ∩ f^[m] ⁻¹' s) ≠ 0", "start": [ 80, 1 ], "end": [ 106, 55 ], "kind": "commanddeclaration" }, { "full_name": "MeasureTheory.Conservative.exists_gt_measure_inter_ne_zero", "code": "theorem exists_gt_measure_inter_ne_zero (hf : Conservative f μ) (hs : MeasurableSet s)\n (h0 : μ s ≠ 0) (N : ℕ) : ∃ m > N, μ (s ∩ f^[m] ⁻¹' s) ≠ 0", "start": [ 109, 1 ], "end": [ 116, 15 ], "kind": "commanddeclaration" }, { "full_name": "MeasureTheory.Conservative.measure_mem_forall_ge_image_not_mem_eq_zero", "code": "theorem measure_mem_forall_ge_image_not_mem_eq_zero (hf : Conservative f μ) (hs : MeasurableSet s)\n (n : ℕ) : μ ({ x ∈ s | ∀ m ≥ n, f^[m] x ∉ s }) = 0", "start": [ 119, 1 ], "end": [ 130, 28 ], "kind": "commanddeclaration" }, { "full_name": "MeasureTheory.Conservative.ae_mem_imp_frequently_image_mem", "code": "theorem ae_mem_imp_frequently_image_mem (hf : Conservative f μ) (hs : MeasurableSet s) :\n ∀ᵐ x ∂μ, x ∈ s → ∃ᶠ n in atTop, f^[n] x ∈ s", "start": [ 133, 1 ], "end": [ 140, 7 ], "kind": "commanddeclaration" }, { "full_name": "MeasureTheory.Conservative.inter_frequently_image_mem_ae_eq", "code": "theorem inter_frequently_image_mem_ae_eq (hf : Conservative f μ) (hs : MeasurableSet s) :\n (s ∩ { x | ∃ᶠ n in atTop, f^[n] x ∈ s } : Set α) =ᵐ[μ] s", "start": [ 143, 1 ], "end": [ 145, 69 ], "kind": "commanddeclaration" }, { "full_name": "MeasureTheory.Conservative.measure_inter_frequently_image_mem_eq", "code": "theorem measure_inter_frequently_image_mem_eq (hf : Conservative f μ) (hs : MeasurableSet s) :\n μ (s ∩ { x | ∃ᶠ n in atTop, f^[n] x ∈ s }) = μ s", "start": [ 148, 1 ], "end": [ 150, 57 ], "kind": "commanddeclaration" }, { "full_name": "MeasureTheory.Conservative.ae_forall_image_mem_imp_frequently_image_mem", "code": "theorem ae_forall_image_mem_imp_frequently_image_mem (hf : Conservative f μ)\n (hs : MeasurableSet s) : ∀ᵐ x ∂μ, ∀ k, f^[k] x ∈ s → ∃ᶠ n in atTop, f^[n] x ∈ s", "start": [ 153, 1 ], "end": [ 162, 36 ], "kind": "commanddeclaration" }, { "full_name": "MeasureTheory.Conservative.frequently_ae_mem_and_frequently_image_mem", "code": "theorem frequently_ae_mem_and_frequently_image_mem (hf : Conservative f μ) (hs : MeasurableSet s)\n (h0 : μ s ≠ 0) : ∃ᵐ x ∂μ, x ∈ s ∧ ∃ᶠ n in atTop, f^[n] x ∈ s", "start": [ 165, 1 ], "end": [ 170, 34 ], "kind": "commanddeclaration" }, { "full_name": "MeasureTheory.Conservative.ae_frequently_mem_of_mem_nhds", "code": "theorem ae_frequently_mem_of_mem_nhds [TopologicalSpace α] [SecondCountableTopology α]\n [OpensMeasurableSpace α] {f : α → α} {μ : Measure α} (h : Conservative f μ) :\n ∀ᵐ x ∂μ, ∀ s ∈ 𝓝 x, ∃ᶠ n in atTop, f^[n] x ∈ s", "start": [ 173, 1 ], "end": [ 183, 47 ], "kind": "commanddeclaration" }, { "full_name": "MeasureTheory.Conservative.iterate", "code": "protected theorem iterate (hf : Conservative f μ) (n : ℕ) : Conservative f^[n] μ", "start": [ 186, 1 ], "end": [ 207, 17 ], "kind": "commanddeclaration" } ]

[ ".lake/packages/lean4/src/lean/Init.lean", "Mathlib/Data/PNat/Prime.lean", "Mathlib/Tactic/Ring.lean" ]

[ { "full_name": "PNat.XgcdType", "code": "structure XgcdType where\n \n wp : ℕ\n \n x : ℕ\n \n y : ℕ\n \n zp : ℕ\n \n ap : ℕ\n \n bp : ℕ\n deriving Inhabited", "start": [ 41, 1 ], "end": [ 59, 21 ], "kind": "commanddeclaration" }, { "full_name": "PNat.XgcdType.mk'", "code": "def mk' (w : ℕ+) (x : ℕ) (y : ℕ) (z : ℕ+) (a : ℕ+) (b : ℕ+) : XgcdType :=\n mk w.val.pred x y z.val.pred a.val.pred b.val.pred", "start": [ 77, 1 ], "end": [ 79, 53 ], "kind": "commanddeclaration" }, { "full_name": "PNat.XgcdType.w", "code": "def w : ℕ+ :=\n succPNat u.wp", "start": [ 82, 1 ], "end": [ 84, 16 ], "kind": "commanddeclaration" }, { "full_name": "PNat.XgcdType.z", "code": "def z : ℕ+ :=\n succPNat u.zp", "start": [ 87, 1 ], "end": [ 89, 16 ], "kind": "commanddeclaration" }, { "full_name": "PNat.XgcdType.a", "code": "def a : ℕ+ :=\n succPNat u.ap", "start": [ 92, 1 ], "end": [ 94, 16 ], "kind": "commanddeclaration" }, { "full_name": "PNat.XgcdType.b", "code": "def b : ℕ+ :=\n succPNat u.bp", "start": [ 97, 1 ], "end": [ 99, 16 ], "kind": "commanddeclaration" }, { "full_name": "PNat.XgcdType.r", "code": "def r : ℕ :=\n (u.ap + 1) % (u.bp + 1)", "start": [ 102, 1 ], "end": [ 104, 26 ], "kind": "commanddeclaration" }, { "full_name": "PNat.XgcdType.q", "code": "def q : ℕ :=\n (u.ap + 1) / (u.bp + 1)", "start": [ 107, 1 ], "end": [ 109, 26 ], "kind": "commanddeclaration" }, { "full_name": "PNat.XgcdType.qp", "code": "def qp : ℕ :=\n u.q - 1", "start": [ 112, 1 ], "end": [ 114, 10 ], "kind": "commanddeclaration" }, { "full_name": "PNat.XgcdType.vp", "code": "def vp : ℕ × ℕ :=\n ⟨u.wp + u.x + u.ap + u.wp * u.ap + u.x * u.bp, u.y + u.zp + u.bp + u.y * u.ap + u.zp * u.bp⟩", "start": [ 117, 1 ], "end": [ 123, 95 ], "kind": "commanddeclaration" }, { "full_name": "PNat.XgcdType.v", "code": "def v : ℕ × ℕ :=\n ⟨u.w * u.a + u.x * u.b, u.y * u.a + u.z * u.b⟩", "start": [ 126, 1 ], "end": [ 128, 49 ], "kind": "commanddeclaration" }, { "full_name": "PNat.XgcdType.succ₂", "code": "def succ₂ (t : ℕ × ℕ) : ℕ × ℕ :=\n ⟨t.1.succ, t.2.succ⟩", "start": [ 131, 1 ], "end": [ 133, 23 ], "kind": "commanddeclaration" }, { "full_name": "PNat.XgcdType.v_eq_succ_vp", "code": "theorem v_eq_succ_vp : u.v = succ₂ u.vp", "start": [ 136, 1 ], "end": [ 137, 55 ], "kind": "commanddeclaration" }, { "full_name": "PNat.XgcdType.IsSpecial", "code": "def IsSpecial : Prop :=\n u.wp + u.zp + u.wp * u.zp = u.x * u.y", "start": [ 140, 1 ], "end": [ 142, 40 ], "kind": "commanddeclaration" }, { "full_name": "PNat.XgcdType.IsSpecial'", "code": "def IsSpecial' : Prop :=\n u.w * u.z = succPNat (u.x * u.y)", "start": [ 145, 1 ], "end": [ 147, 35 ], "kind": "commanddeclaration" }, { "full_name": "PNat.XgcdType.isSpecial_iff", "code": "theorem isSpecial_iff : u.IsSpecial ↔ u.IsSpecial'", "start": [ 150, 1 ], "end": [ 156, 74 ], "kind": "commanddeclaration" }, { "full_name": "PNat.XgcdType.IsReduced", "code": "def IsReduced : Prop :=\n u.ap = u.bp", "start": [ 160, 1 ], "end": [ 165, 14 ], "kind": "commanddeclaration" }, { "full_name": "PNat.XgcdType.IsReduced'", "code": "def IsReduced' : Prop :=\n u.a = u.b", "start": [ 168, 1 ], "end": [ 170, 12 ], "kind": "commanddeclaration" }, { "full_name": "PNat.XgcdType.isReduced_iff", "code": "theorem isReduced_iff : u.IsReduced ↔ u.IsReduced'", "start": [ 173, 1 ], "end": [ 174, 20 ], "kind": "commanddeclaration" }, { "full_name": "PNat.XgcdType.flip", "code": "def flip : XgcdType where\n wp := u.zp\n x := u.y\n y := u.x\n zp := u.wp\n ap := u.bp\n bp := u.ap", "start": [ 177, 1 ], "end": [ 184, 13 ], "kind": "commanddeclaration" }, { "full_name": "PNat.XgcdType.flip_w", "code": "@[simp]\ntheorem flip_w : (flip u).w = u.z", "start": [ 187, 1 ], "end": [ 189, 6 ], "kind": "commanddeclaration" }, { "full_name": "PNat.XgcdType.flip_x", "code": "@[simp]\ntheorem flip_x : (flip u).x = u.y", "start": [ 192, 1 ], "end": [ 194, 6 ], "kind": "commanddeclaration" }, { "full_name": "PNat.XgcdType.flip_y", "code": "@[simp]\ntheorem flip_y : (flip u).y = u.x", "start": [ 197, 1 ], "end": [ 199, 6 ], "kind": "commanddeclaration" }, { "full_name": "PNat.XgcdType.flip_z", "code": "@[simp]\ntheorem flip_z : (flip u).z = u.w", "start": [ 202, 1 ], "end": [ 204, 6 ], "kind": "commanddeclaration" }, { "full_name": "PNat.XgcdType.flip_a", "code": "@[simp]\ntheorem flip_a : (flip u).a = u.b", "start": [ 207, 1 ], "end": [ 209, 6 ], "kind": "commanddeclaration" }, { "full_name": "PNat.XgcdType.flip_b", "code": "@[simp]\ntheorem flip_b : (flip u).b = u.a", "start": [ 212, 1 ], "end": [ 214, 6 ], "kind": "commanddeclaration" }, { "full_name": "PNat.XgcdType.flip_isReduced", "code": "theorem flip_isReduced : (flip u).IsReduced ↔ u.IsReduced", "start": [ 217, 1 ], "end": [ 219, 43 ], "kind": "commanddeclaration" }, { "full_name": "PNat.XgcdType.flip_isSpecial", "code": "theorem flip_isSpecial : (flip u).IsSpecial ↔ u.IsSpecial", "start": [ 222, 1 ], "end": [ 224, 50 ], "kind": "commanddeclaration" }, { "full_name": "PNat.XgcdType.flip_v", "code": "theorem flip_v : (flip u).v = u.v.swap", "start": [ 227, 1 ], "end": [ 233, 9 ], "kind": "commanddeclaration" }, { "full_name": "PNat.XgcdType.rq_eq", "code": "theorem rq_eq : u.r + (u.bp + 1) * u.q = u.ap + 1", "start": [ 236, 1 ], "end": [ 238, 40 ], "kind": "commanddeclaration" }, { "full_name": "PNat.XgcdType.qp_eq", "code": "theorem qp_eq (hr : u.r = 0) : u.q = u.qp + 1", "start": [ 241, 1 ], "end": [ 246, 65 ], "kind": "commanddeclaration" }, { "full_name": "PNat.XgcdType.start", "code": "def start (a b : ℕ+) : XgcdType :=\n ⟨0, 0, 0, 0, a - 1, b - 1⟩", "start": [ 249, 1 ], "end": [ 255, 29 ], "kind": "commanddeclaration" }, { "full_name": "PNat.XgcdType.start_isSpecial", "code": "theorem start_isSpecial (a b : ℕ+) : (start a b).IsSpecial", "start": [ 258, 1 ], "end": [ 259, 27 ], "kind": "commanddeclaration" }, { "full_name": "PNat.XgcdType.start_v", "code": "theorem start_v (a b : ℕ+) : (start a b).v = ⟨a, b⟩", "start": [ 262, 1 ], "end": [ 267, 18 ], "kind": "commanddeclaration" }, { "full_name": "PNat.XgcdType.finish", "code": "def finish : XgcdType :=\n XgcdType.mk u.wp ((u.wp + 1) * u.qp + u.x) u.y (u.y * u.qp + u.zp) u.bp u.bp", "start": [ 270, 1 ], "end": [ 272, 79 ], "kind": "commanddeclaration" }, { "full_name": "PNat.XgcdType.finish_isReduced", "code": "theorem finish_isReduced : u.finish.IsReduced", "start": [ 275, 1 ], "end": [ 277, 6 ], "kind": "commanddeclaration" }, { "full_name": "PNat.XgcdType.finish_isSpecial", "code": "theorem finish_isSpecial (hs : u.IsSpecial) : u.finish.IsSpecial", "start": [ 280, 1 ], "end": [ 283, 7 ], "kind": "commanddeclaration" }, { "full_name": "PNat.XgcdType.finish_v", "code": "theorem finish_v (hr : u.r = 0) : u.finish.v = u.v", "start": [ 286, 1 ], "end": [ 296, 9 ], "kind": "commanddeclaration" }, { "full_name": "PNat.XgcdType.step", "code": "def step : XgcdType :=\n XgcdType.mk (u.y * u.q + u.zp) u.y ((u.wp + 1) * u.q + u.x) u.wp u.bp (u.r - 1)", "start": [ 299, 1 ], "end": [ 302, 82 ], "kind": "commanddeclaration" }, { "full_name": "PNat.XgcdType.step_wf", "code": "theorem step_wf (hr : u.r ≠ 0) : SizeOf.sizeOf u.step < SizeOf.sizeOf u", "start": [ 305, 1 ], "end": [ 312, 30 ], "kind": "commanddeclaration" }, { "full_name": "PNat.XgcdType.step_isSpecial", "code": "theorem step_isSpecial (hs : u.IsSpecial) : u.step.IsSpecial", "start": [ 315, 1 ], "end": [ 318, 7 ], "kind": "commanddeclaration" }, { "full_name": "PNat.XgcdType.step_v", "code": "theorem step_v (hr : u.r ≠ 0) : u.step.v = u.v.swap", "start": [ 321, 1 ], "end": [ 331, 9 ], "kind": "commanddeclaration" }, { "full_name": "PNat.XgcdType.reduce", "code": "def reduce (u : XgcdType) : XgcdType :=\n dite (u.r = 0) (fun _ => u.finish) fun _h =>\n flip (reduce u.step)\ndecreasing_by apply u.step_wf _h", "start": [ 335, 1 ], "end": [ 345, 33 ], "kind": "commanddeclaration" }, { "full_name": "PNat.XgcdType.reduce_a", "code": "theorem reduce_a {u : XgcdType} (h : u.r = 0) : u.reduce = u.finish", "start": [ 348, 1 ], "end": [ 350, 17 ], "kind": "commanddeclaration" }, { "full_name": "PNat.XgcdType.reduce_b", "code": "theorem reduce_b {u : XgcdType} (h : u.r ≠ 0) : u.reduce = u.step.reduce.flip", "start": [ 353, 1 ], "end": [ 355, 17 ], "kind": "commanddeclaration" }, { "full_name": "PNat.XgcdType.reduce_isReduced", "code": "theorem reduce_isReduced : ∀ u : XgcdType, u.reduce.IsReduced", "start": [ 358, 1 ], "end": [ 367, 29 ], "kind": "commanddeclaration" }, { "full_name": "PNat.XgcdType.reduce_isReduced'", "code": "theorem reduce_isReduced' (u : XgcdType) : u.reduce.IsReduced'", "start": [ 370, 1 ], "end": [ 371, 42 ], "kind": "commanddeclaration" }, { "full_name": "PNat.XgcdType.reduce_isSpecial", "code": "theorem reduce_isSpecial : ∀ u : XgcdType, u.IsSpecial → u.reduce.IsSpecial", "start": [ 374, 1 ], "end": [ 383, 78 ], "kind": "commanddeclaration" }, { "full_name": "PNat.XgcdType.reduce_isSpecial'", "code": "theorem reduce_isSpecial' (u : XgcdType) (hs : u.IsSpecial) : u.reduce.IsSpecial'", "start": [ 386, 1 ], "end": [ 387, 47 ], "kind": "commanddeclaration" }, { "full_name": "PNat.XgcdType.reduce_v", "code": "theorem reduce_v : ∀ u : XgcdType, u.reduce.v = u.v", "start": [ 390, 1 ], "end": [ 394, 77 ], "kind": "commanddeclaration" }, { "full_name": "PNat.xgcd", "code": "def xgcd : XgcdType :=\n (XgcdType.start a b).reduce", "start": [ 403, 1 ], "end": [ 405, 30 ], "kind": "commanddeclaration" }, { "full_name": "PNat.gcdD", "code": "def gcdD : ℕ+ :=\n (xgcd a b).a", "start": [ 408, 1 ], "end": [ 410, 15 ], "kind": "commanddeclaration" }, { "full_name": "PNat.gcdW", "code": "def gcdW : ℕ+ :=\n (xgcd a b).w", "start": [ 413, 1 ], "end": [ 415, 15 ], "kind": "commanddeclaration" }, { "full_name": "PNat.gcdX", "code": "def gcdX : ℕ :=\n (xgcd a b).x", "start": [ 418, 1 ], "end": [ 420, 15 ], "kind": "commanddeclaration" }, { "full_name": "PNat.gcdY", "code": "def gcdY : ℕ :=\n (xgcd a b).y", "start": [ 423, 1 ], "end": [ 425, 15 ], "kind": "commanddeclaration" }, { "full_name": "PNat.gcdZ", "code": "def gcdZ : ℕ+ :=\n (xgcd a b).z", "start": [ 428, 1 ], "end": [ 430, 15 ], "kind": "commanddeclaration" }, { "full_name": "PNat.gcdA'", "code": "def gcdA' : ℕ+ :=\n succPNat ((xgcd a b).wp + (xgcd a b).x)", "start": [ 433, 1 ], "end": [ 435, 42 ], "kind": "commanddeclaration" }, { "full_name": "PNat.gcdB'", "code": "def gcdB' : ℕ+ :=\n succPNat ((xgcd a b).y + (xgcd a b).zp)", "start": [ 438, 1 ], "end": [ 440, 42 ], "kind": "commanddeclaration" }, { "full_name": "PNat.gcdA'_coe", "code": "theorem gcdA'_coe : (gcdA' a b : ℕ) = gcdW a b + gcdX a b", "start": [ 443, 1 ], "end": [ 445, 22 ], "kind": "commanddeclaration" }, { "full_name": "PNat.gcdB'_coe", "code": "theorem gcdB'_coe : (gcdB' a b : ℕ) = gcdY a b + gcdZ a b", "start": [ 448, 1 ], "end": [ 450, 17 ], "kind": "commanddeclaration" }, { "full_name": "PNat.gcd_props", "code": "theorem gcd_props :\n let d := gcdD a b\n let w := gcdW a b\n let x := gcdX a b\n let y := gcdY a b\n let z := gcdZ a b\n let a' := gcdA' a b\n let b' := gcdB' a b\n w * z = succPNat (x * y) ∧\n a = a' * d ∧\n b = b' * d ∧\n z * a' = succPNat (x * b') ∧\n w * b' = succPNat (y * a') ∧ (z * a : ℕ) = x * b + d ∧ (w * b : ℕ) = y * a + d", "start": [ 453, 1 ], "end": [ 503, 23 ], "kind": "commanddeclaration" }, { "full_name": "PNat.gcd_eq", "code": "theorem gcd_eq : gcdD a b = gcd a b", "start": [ 506, 1 ], "end": [ 516, 44 ], "kind": "commanddeclaration" }, { "full_name": "PNat.gcd_det_eq", "code": "theorem gcd_det_eq : gcdW a b * gcdZ a b = succPNat (gcdX a b * gcdY a b)", "start": [ 519, 1 ], "end": [ 520, 20 ], "kind": "commanddeclaration" }, { "full_name": "PNat.gcd_a_eq", "code": "theorem gcd_a_eq : a = gcdA' a b * gcd a b", "start": [ 523, 1 ], "end": [ 524, 35 ], "kind": "commanddeclaration" }, { "full_name": "PNat.gcd_b_eq", "code": "theorem gcd_b_eq : b = gcdB' a b * gcd a b", "start": [ 527, 1 ], "end": [ 528, 37 ], "kind": "commanddeclaration" }, { "full_name": "PNat.gcd_rel_left'", "code": "theorem gcd_rel_left' : gcdZ a b * gcdA' a b = succPNat (gcdX a b * gcdB' a b)", "start": [ 531, 1 ], "end": [ 532, 26 ], "kind": "commanddeclaration" }, { "full_name": "PNat.gcd_rel_right'", "code": "theorem gcd_rel_right' : gcdW a b * gcdB' a b = succPNat (gcdY a b * gcdA' a b)", "start": [ 535, 1 ], "end": [ 536, 28 ], "kind": "commanddeclaration" }, { "full_name": "PNat.gcd_rel_left", "code": "theorem gcd_rel_left : (gcdZ a b * a : ℕ) = gcdX a b * b + gcd a b", "start": [ 539, 1 ], "end": [ 540, 43 ], "kind": "commanddeclaration" }, { "full_name": "PNat.gcd_rel_right", "code": "theorem gcd_rel_right : (gcdW a b * b : ℕ) = gcdY a b * a + gcd a b", "start": [ 543, 1 ], "end": [ 544, 43 ], "kind": "commanddeclaration" } ]

[ "Mathlib/Order/UpperLower/Basic.lean", ".lake/packages/lean4/src/lean/Init.lean", "Mathlib/Topology/Separation.lean" ]

[ { "full_name": "PriestleySpace", "code": "class PriestleySpace (α : Type*) [Preorder α] [TopologicalSpace α] : Prop where\n priestley {x y : α} : ¬x ≤ y → ∃ U : Set α, IsClopen U ∧ IsUpperSet U ∧ x ∈ U ∧ y ∉ U", "start": [ 38, 1 ], "end": [ 41, 88 ], "kind": "commanddeclaration" }, { "full_name": "exists_isClopen_upper_of_not_le", "code": "theorem exists_isClopen_upper_of_not_le :\n ¬x ≤ y → ∃ U : Set α, IsClopen U ∧ IsUpperSet U ∧ x ∈ U ∧ y ∉ U", "start": [ 50, 1 ], "end": [ 52, 27 ], "kind": "commanddeclaration" }, { "full_name": "exists_isClopen_lower_of_not_le", "code": "theorem exists_isClopen_lower_of_not_le (h : ¬x ≤ y) :\n ∃ U : Set α, IsClopen U ∧ IsLowerSet U ∧ x ∉ U ∧ y ∈ U", "start": [ 55, 1 ], "end": [ 58, 56 ], "kind": "commanddeclaration" }, { "full_name": "exists_isClopen_upper_or_lower_of_ne", "code": "theorem exists_isClopen_upper_or_lower_of_ne (h : x ≠ y) :\n ∃ U : Set α, IsClopen U ∧ (IsUpperSet U ∨ IsLowerSet U) ∧ x ∈ U ∧ y ∉ U", "start": [ 67, 1 ], "end": [ 72, 38 ], "kind": "commanddeclaration" }, { "full_name": "PriestleySpace.toT2Space", "code": "instance (priority := 100) PriestleySpace.toT2Space : T2Space α :=\n ⟨fun _ _ h ↦\n let ⟨U, hU, _, hx, hy⟩ := exists_isClopen_upper_or_lower_of_ne h\n ⟨U, Uᶜ, hU.isOpen, hU.compl.isOpen, hx, hy, disjoint_compl_right⟩⟩", "start": [ 76, 1 ], "end": [ 79, 71 ], "kind": "commanddeclaration" } ]

[ ".lake/packages/lean4/src/lean/Init.lean", "Mathlib/Analysis/NormedSpace/Basic.lean" ]

[ { "full_name": "ENorm", "code": "structure ENorm (𝕜 : Type*) (V : Type*) [NormedField 𝕜] [AddCommGroup V] [Module 𝕜 V] where\n toFun : V → ℝ≥0∞\n eq_zero' : ∀ x, toFun x = 0 → x = 0\n map_add_le' : ∀ x y : V, toFun (x + y) ≤ toFun x + toFun y\n map_smul_le' : ∀ (c : 𝕜) (x : V), toFun (c • x) ≤ ‖c‖₊ * toFun x", "start": [ 42, 1 ], "end": [ 48, 67 ], "kind": "commanddeclaration" }, { "full_name": "ENorm.coeFn_injective", "code": "theorem coeFn_injective : Function.Injective ((↑) : ENorm 𝕜 V → V → ℝ≥0∞)", "start": [ 61, 1 ], "end": [ 64, 8 ], "kind": "commanddeclaration" }, { "full_name": "ENorm.ext", "code": "@[ext]\ntheorem ext {e₁ e₂ : ENorm 𝕜 V} (h : ∀ x, e₁ x = e₂ x) : e₁ = e₂", "start": [ 67, 1 ], "end": [ 69, 30 ], "kind": "commanddeclaration" }, { "full_name": "ENorm.ext_iff", "code": "theorem ext_iff {e₁ e₂ : ENorm 𝕜 V} : e₁ = e₂ ↔ ∀ x, e₁ x = e₂ x", "start": [ 72, 1 ], "end": [ 73, 28 ], "kind": "commanddeclaration" }, { "full_name": "ENorm.coe_inj", "code": "@[simp, norm_cast]\ntheorem coe_inj {e₁ e₂ : ENorm 𝕜 V} : (e₁ : V → ℝ≥0∞) = e₂ ↔ e₁ = e₂", "start": [ 76, 1 ], "end": [ 78, 25 ], "kind": "commanddeclaration" }, { "full_name": "ENorm.map_smul", "code": "@[simp]\ntheorem map_smul (c : 𝕜) (x : V) : e (c • x) = ‖c‖₊ * e x", "start": [ 81, 1 ], "end": [ 92, 22 ], "kind": "commanddeclaration" }, { "full_name": "ENorm.map_zero", "code": "@[simp]\ntheorem map_zero : e 0 = 0", "start": [ 95, 1 ], "end": [ 98, 11 ], "kind": "commanddeclaration" }, { "full_name": "ENorm.eq_zero_iff", "code": "@[simp]\ntheorem eq_zero_iff {x : V} : e x = 0 ↔ x = 0", "start": [ 101, 1 ], "end": [ 103, 47 ], "kind": "commanddeclaration" }, { "full_name": "ENorm.map_neg", "code": "@[simp]\ntheorem map_neg (x : V) : e (-x) = e x", "start": [ 106, 1 ], "end": [ 110, 23 ], "kind": "commanddeclaration" }, { "full_name": "ENorm.map_sub_rev", "code": "theorem map_sub_rev (x y : V) : e (x - y) = e (y - x)", "start": [ 113, 1 ], "end": [ 113, 86 ], "kind": "commanddeclaration" }, { "full_name": "ENorm.map_add_le", "code": "theorem map_add_le (x y : V) : e (x + y) ≤ e x + e y", "start": [ 116, 1 ], "end": [ 117, 20 ], "kind": "commanddeclaration" }, { "full_name": "ENorm.map_sub_le", "code": "theorem map_sub_le (x y : V) : e (x - y) ≤ e x + e y", "start": [ 120, 1 ], "end": [ 124, 39 ], "kind": "commanddeclaration" }, { "full_name": "ENorm.partialOrder", "code": "instance partialOrder : PartialOrder (ENorm 𝕜 V) where\n le e₁ e₂ := ∀ x, e₁ x ≤ e₂ x\n le_refl e x := le_rfl\n le_trans e₁ e₂ e₃ h₁₂ h₂₃ x := le_trans (h₁₂ x) (h₂₃ x)\n le_antisymm e₁ e₂ h₁₂ h₂₁ := ext fun x => le_antisymm (h₁₂ x) (h₂₁ x)", "start": [ 127, 1 ], "end": [ 131, 72 ], "kind": "commanddeclaration" }, { "full_name": "ENorm.top_map", "code": "theorem top_map {x : V} (hx : x ≠ 0) : (⊤ : ENorm 𝕜 V) x = ⊤", "start": [ 153, 1 ], "end": [ 154, 12 ], "kind": "commanddeclaration" }, { "full_name": "ENorm.coe_max", "code": "@[simp, norm_cast]\ntheorem coe_max (e₁ e₂ : ENorm 𝕜 V) : ⇑(e₁ ⊔ e₂) = fun x => max (e₁ x) (e₂ x)", "start": [ 176, 1 ], "end": [ 178, 6 ], "kind": "commanddeclaration" }, { "full_name": "ENorm.max_map", "code": "@[norm_cast]\ntheorem max_map (e₁ e₂ : ENorm 𝕜 V) (x : V) : (e₁ ⊔ e₂) x = max (e₁ x) (e₂ x)", "start": [ 181, 1 ], "end": [ 183, 6 ], "kind": "commanddeclaration" }, { "full_name": "ENorm.emetricSpace", "code": "abbrev emetricSpace : EMetricSpace V where\n edist x y := e (x - y)\n edist_self x := by simp\n eq_of_edist_eq_zero {x y} := by simp [sub_eq_zero]\n edist_comm := e.map_sub_rev\n edist_triangle x y z :=\n calc\n e (x - z) = e (x - y + (y - z)) := by rw [sub_add_sub_cancel]\n _ ≤ e (x - y) + e (y - z) := e.map_add_le (x - y) (y - z)", "start": [ 186, 1 ], "end": [ 195, 64 ], "kind": "commanddeclaration" }, { "full_name": "ENorm.finiteSubspace", "code": "def finiteSubspace : Subspace 𝕜 V where\n carrier := { x | e x < ⊤ }\n zero_mem' := by simp\n add_mem' {x y} hx hy := lt_of_le_of_lt (e.map_add_le x y) (ENNReal.add_lt_top.2 ⟨hx, hy⟩)\n smul_mem' c x (hx : _ < _) :=\n calc\n e (c • x) = ‖c‖₊ * e x := e.map_smul c x\n _ < ⊤ := ENNReal.mul_lt_top ENNReal.coe_ne_top hx.ne", "start": [ 198, 1 ], "end": [ 206, 59 ], "kind": "commanddeclaration" }, { "full_name": "ENorm.metricSpace", "code": "instance metricSpace : MetricSpace e.finiteSubspace := by\n letI := e.emetricSpace\n refine EMetricSpace.toMetricSpace fun x y => ?_\n change e (x - y) ≠ ⊤\n exact ne_top_of_le_ne_top (ENNReal.add_lt_top.2 ⟨x.2, y.2⟩).ne (e.map_sub_le x y)", "start": [ 209, 1 ], "end": [ 215, 84 ], "kind": "commanddeclaration" }, { "full_name": "ENorm.finite_dist_eq", "code": "theorem finite_dist_eq (x y : e.finiteSubspace) : dist x y = (e (x - y)).toReal", "start": [ 217, 1 ], "end": [ 218, 6 ], "kind": "commanddeclaration" }, { "full_name": "ENorm.finite_edist_eq", "code": "theorem finite_edist_eq (x y : e.finiteSubspace) : edist x y = e (x - y)", "start": [ 221, 1 ], "end": [ 222, 6 ], "kind": "commanddeclaration" }, { "full_name": "ENorm.normedAddCommGroup", "code": "instance normedAddCommGroup : NormedAddCommGroup e.finiteSubspace :=\n { e.metricSpace with\n norm := fun x => (e x).toReal\n dist_eq := fun _ _ => rfl }", "start": [ 225, 1 ], "end": [ 229, 32 ], "kind": "commanddeclaration" }, { "full_name": "ENorm.finite_norm_eq", "code": "theorem finite_norm_eq (x : e.finiteSubspace) : ‖x‖ = (e x).toReal", "start": [ 231, 1 ], "end": [ 232, 6 ], "kind": "commanddeclaration" }, { "full_name": "ENorm.normedSpace", "code": "instance normedSpace : NormedSpace 𝕜 e.finiteSubspace where\n norm_smul_le c x := le_of_eq <| by simp [finite_norm_eq, ENNReal.toReal_mul]", "start": [ 235, 1 ], "end": [ 237, 79 ], "kind": "commanddeclaration" } ]

[ ".lake/packages/lean4/src/lean/Init.lean", "Mathlib/GroupTheory/Transfer.lean", "Mathlib/GroupTheory/Sylow.lean" ]

[ { "full_name": "Subgroup.QuotientDiff", "code": "def QuotientDiff :=\n Quotient\n (Setoid.mk (fun α β => diff (MonoidHom.id H) α β = 1)\n ⟨fun α => diff_self (MonoidHom.id H) α, fun h => by rw [← diff_inv, h, inv_one],\n fun h h' => by rw [← diff_mul_diff, h, h', one_mul]⟩)", "start": [ 36, 1 ], "end": [ 41, 62 ], "kind": "commanddeclaration" }, { "full_name": "Subgroup.smul_diff_smul'", "code": "theorem smul_diff_smul' [hH : Normal H] (g : Gᵐᵒᵖ) :\n diff (MonoidHom.id H) (g • α) (g • β) =\n ⟨g.unop⁻¹ * (diff (MonoidHom.id H) α β : H) * g.unop,\n hH.mem_comm ((congr_arg (· ∈ H) (mul_inv_cancel_left _ _)).mpr (SetLike.coe_mem _))⟩", "start": [ 48, 1 ], "end": [ 62, 76 ], "kind": "commanddeclaration" }, { "full_name": "Subgroup.smul_diff'", "code": "theorem smul_diff' (h : H) :\n diff (MonoidHom.id H) α (op (h : G) • β) = diff (MonoidHom.id H) α β * h ^ H.index", "start": [ 82, 1 ], "end": [ 90, 69 ], "kind": "commanddeclaration" }, { "full_name": "Subgroup.eq_one_of_smul_eq_one", "code": "theorem eq_one_of_smul_eq_one (hH : Nat.Coprime (Nat.card H) H.index) (α : H.QuotientDiff)\n (h : H) : h • α = α → h = 1", "start": [ 93, 1 ], "end": [ 100, 77 ], "kind": "commanddeclaration" }, { "full_name": "Subgroup.exists_smul_eq", "code": "theorem exists_smul_eq (hH : Nat.Coprime (Nat.card H) H.index) (α β : H.QuotientDiff) :\n ∃ h : H, h • α = β", "start": [ 104, 1 ], "end": [ 113, 99 ], "kind": "commanddeclaration" }, { "full_name": "Subgroup.isComplement'_stabilizer_of_coprime", "code": "theorem isComplement'_stabilizer_of_coprime {α : H.QuotientDiff}\n (hH : Nat.Coprime (Nat.card H) H.index) : IsComplement' H (stabilizer G α)", "start": [ 116, 1 ], "end": [ 118, 95 ], "kind": "commanddeclaration" }, { "full_name": "Subgroup.exists_right_complement'_of_coprime_aux", "code": "private theorem exists_right_complement'_of_coprime_aux (hH : Nat.Coprime (Nat.card H) H.index) :\n ∃ K : Subgroup G, IsComplement' H K", "start": [ 121, 1 ], "end": [ 125, 76 ], "kind": "commanddeclaration" }, { "full_name": "Subgroup.SchurZassenhausInduction.step0", "code": "private theorem step0 : N ≠ ⊥", "start": [ 161, 1 ], "end": [ 164, 35 ], "kind": "commanddeclaration" }, { "full_name": "Subgroup.SchurZassenhausInduction.step1", "code": "private theorem step1 (K : Subgroup G) (hK : K ⊔ N = ⊤) : K = ⊤", "start": [ 166, 1 ], "end": [ 188, 58 ], "kind": "commanddeclaration" }, { "full_name": "Subgroup.SchurZassenhausInduction.step2", "code": "private theorem step2 (K : Subgroup G) [K.Normal] (hK : K ≤ N) : K = ⊥ ∨ K = N", "start": [ 190, 1 ], "end": [ 219, 35 ], "kind": "commanddeclaration" }, { "full_name": "Subgroup.SchurZassenhausInduction.step3", "code": "private theorem step3 (K : Subgroup N) [(K.map N.subtype).Normal] : K = ⊥ ∨ K = ⊤", "start": [ 221, 1 ], "end": [ 230, 38 ], "kind": "commanddeclaration" }, { "full_name": "Subgroup.SchurZassenhausInduction.step4", "code": "private theorem step4 : (Fintype.card N).minFac.Prime", "start": [ 232, 1 ], "end": [ 235, 74 ], "kind": "commanddeclaration" }, { "full_name": "Subgroup.SchurZassenhausInduction.step5", "code": "private theorem step5 {P : Sylow (Fintype.card N).minFac N} : P.1 ≠ ⊥", "start": [ 237, 1 ], "end": [ 240, 51 ], "kind": "commanddeclaration" }, { "full_name": "Subgroup.SchurZassenhausInduction.step6", "code": "private theorem step6 : IsPGroup (Fintype.card N).minFac N", "start": [ 242, 1 ], "end": [ 249, 56 ], "kind": "commanddeclaration" }, { "full_name": "Subgroup.SchurZassenhausInduction.step7", "code": "theorem step7 : IsCommutative N", "start": [ 251, 1 ], "end": [ 257, 70 ], "kind": "commanddeclaration" }, { "full_name": "Subgroup.exists_right_complement'_of_coprime_aux'", "code": "private theorem exists_right_complement'_of_coprime_aux' [Fintype G] (hG : Fintype.card G = n)\n {N : Subgroup G} [N.Normal] (hN : Nat.Coprime (Fintype.card N) N.index) :\n ∃ H : Subgroup G, IsComplement' N H", "start": [ 264, 1 ], "end": [ 274, 81 ], "kind": "commanddeclaration" }, { "full_name": "Subgroup.exists_right_complement'_of_coprime_of_fintype", "code": "theorem exists_right_complement'_of_coprime_of_fintype [Fintype G] {N : Subgroup G} [N.Normal]\n (hN : Nat.Coprime (Fintype.card N) N.index) : ∃ H : Subgroup G, IsComplement' N H", "start": [ 276, 1 ], "end": [ 281, 50 ], "kind": "commanddeclaration" }, { "full_name": "Subgroup.exists_right_complement'_of_coprime", "code": "theorem exists_right_complement'_of_coprime {N : Subgroup G} [N.Normal]\n (hN : Nat.Coprime (Nat.card N) N.index) : ∃ H : Subgroup G, IsComplement' N H", "start": [ 284, 1 ], "end": [ 304, 35 ], "kind": "commanddeclaration" }, { "full_name": "Subgroup.exists_left_complement'_of_coprime_of_fintype", "code": "theorem exists_left_complement'_of_coprime_of_fintype [Fintype G] {N : Subgroup G} [N.Normal]\n (hN : Nat.Coprime (Fintype.card N) N.index) : ∃ H : Subgroup G, IsComplement' H N", "start": [ 307, 1 ], "end": [ 312, 95 ], "kind": "commanddeclaration" }, { "full_name": "Subgroup.exists_left_complement'_of_coprime", "code": "theorem exists_left_complement'_of_coprime {N : Subgroup G} [N.Normal]\n (hN : Nat.Coprime (Nat.card N) N.index) : ∃ H : Subgroup G, IsComplement' H N", "start": [ 315, 1 ], "end": [ 320, 84 ], "kind": "commanddeclaration" } ]

[ "Mathlib/Data/Nat/Cast/Order.lean", ".lake/packages/lean4/src/lean/Init.lean", "Mathlib/Data/Nat/Choose/Basic.lean", "Mathlib/Algebra/Order/Field/Basic.lean" ]

[ { "full_name": "Nat.choose_le_pow", "code": "theorem choose_le_pow (r n : ℕ) : (n.choose r : α) ≤ (n ^ r : α) / r !", "start": [ 32, 1 ], "end": [ 37, 33 ], "kind": "commanddeclaration" }, { "full_name": "Nat.pow_le_choose", "code": "theorem pow_le_choose (r n : ℕ) : ((n + 1 - r : ℕ) ^ r : α) / r ! ≤ n.choose r", "start": [ 41, 1 ], "end": [ 46, 33 ], "kind": "commanddeclaration" } ]

[ "Mathlib/Probability/ProbabilityMassFunction/Basic.lean", ".lake/packages/lean4/src/lean/Init.lean", "Mathlib/Probability/Notation.lean" ]

[ { "full_name": "ProbabilityTheory.geometricPMFReal", "code": "noncomputable\ndef geometricPMFReal (p : ℝ) (n : ℕ) : ℝ := (1-p) ^ n * p", "start": [ 34, 1 ], "end": [ 36, 58 ], "kind": "commanddeclaration" }, { "full_name": "ProbabilityTheory.geometricPMFRealSum", "code": "lemma geometricPMFRealSum (hp_pos : 0 < p) (hp_le_one : p ≤ 1) :\n HasSum (fun n ↦ geometricPMFReal p n) 1 := by\n unfold geometricPMFReal\n have := hasSum_geometric_of_lt_one (sub_nonneg.mpr hp_le_one) (sub_lt_self 1 hp_pos)\n apply (hasSum_mul_right_iff (hp_pos.ne')).mpr at this\n simp only [sub_sub_cancel] at this\n rw [inv_mul_eq_div, div_self hp_pos.ne'] at this\n exact this", "start": [ 38, 1 ], "end": [ 45, 13 ], "kind": "lemma" }, { "full_name": "ProbabilityTheory.geometricPMFReal_pos", "code": "lemma geometricPMFReal_pos {n : ℕ} (hp_pos : 0 < p) (hp_lt_one : p < 1) :\n 0 < geometricPMFReal p n := by\n rw [geometricPMFReal]\n have : 0 < 1 - p := sub_pos.mpr hp_lt_one\n positivity", "start": [ 47, 1 ], "end": [ 52, 13 ], "kind": "lemma" }, { "full_name": "ProbabilityTheory.geometricPMFReal_nonneg", "code": "lemma geometricPMFReal_nonneg {n : ℕ} (hp_pos : 0 < p) (hp_le_one : p ≤ 1) :\n 0 ≤ geometricPMFReal p n := by\n rw [geometricPMFReal]\n have : 0 ≤ 1 - p := sub_nonneg.mpr hp_le_one\n positivity", "start": [ 54, 1 ], "end": [ 58, 13 ], "kind": "lemma" }, { "full_name": "ProbabilityTheory.geometricPMF", "code": "noncomputable\ndef geometricPMF (hp_pos : 0 < p) (hp_le_one : p ≤ 1) : PMF ℕ :=\n ⟨fun n ↦ ENNReal.ofReal (geometricPMFReal p n), by\n apply ENNReal.hasSum_coe.mpr\n rw [← toNNReal_one]\n exact (geometricPMFRealSum hp_pos hp_le_one).toNNReal\n (fun n ↦ geometricPMFReal_nonneg hp_pos hp_le_one)⟩", "start": [ 60, 1 ], "end": [ 67, 58 ], "kind": "commanddeclaration" }, { "full_name": "ProbabilityTheory.measurable_geometricPMFReal", "code": "@[measurability]\nlemma measurable_geometricPMFReal : Measurable (geometricPMFReal p) := by\n measurability", "start": [ 69, 1 ], "end": [ 72, 16 ], "kind": "lemma" }, { "full_name": "ProbabilityTheory.stronglyMeasurable_geometricPMFReal", "code": "@[measurability]\nlemma stronglyMeasurable_geometricPMFReal : StronglyMeasurable (geometricPMFReal p) :=\n stronglyMeasurable_iff_measurable.mpr measurable_geometricPMFReal", "start": [ 74, 1 ], "end": [ 76, 68 ], "kind": "lemma" }, { "full_name": "ProbabilityTheory.geometricMeasure", "code": "noncomputable\ndef geometricMeasure (hp_pos : 0 < p) (hp_le_one : p ≤ 1) : Measure ℕ :=\n (geometricPMF hp_pos hp_le_one).toMeasure", "start": [ 80, 1 ], "end": [ 83, 44 ], "kind": "commanddeclaration" }, { "full_name": "ProbabilityTheory.isProbabilityMeasureGeometric", "code": "lemma isProbabilityMeasureGeometric (hp_pos : 0 < p) (hp_le_one : p ≤ 1) :\n IsProbabilityMeasure (geometricMeasure hp_pos hp_le_one) :=\n PMF.toMeasure.isProbabilityMeasure (geometricPMF hp_pos hp_le_one)", "start": [ 85, 1 ], "end": [ 87, 69 ], "kind": "lemma" } ]

[ "Mathlib/Tactic/NormNum.lean", "Mathlib/Init/Data/Ordering/Lemmas.lean", "Mathlib/SetTheory/Ordinal/Principal.lean", "Mathlib/Algebra/Ring/Divisibility/Basic.lean", ".lake/packages/lean4/src/lean/Init.lean", "Mathlib/Data/PNat/Basic.lean" ]

[ { "full_name": "ONote", "code": "inductive ONote : Type\n | zero : ONote\n | oadd : ONote → ℕ+ → ONote → ONote\n deriving DecidableEq", "start": [ 36, 1 ], "end": [ 44, 23 ], "kind": "commanddeclaration" }, { "full_name": "ONote.zero_def", "code": "@[simp]\ntheorem zero_def : zero = 0", "start": [ 55, 1 ], "end": [ 57, 6 ], "kind": "commanddeclaration" }, { "full_name": "ONote.omega", "code": "def omega : ONote :=\n oadd 1 1 0", "start": [ 67, 1 ], "end": [ 69, 13 ], "kind": "commanddeclaration" }, { "full_name": "ONote.repr", "code": "@[simp]\nnoncomputable def repr : ONote → Ordinal.{0}\n | 0 => 0\n | oadd e n a => ω ^ repr e * n + repr a", "start": [ 72, 1 ], "end": [ 76, 42 ], "kind": "commanddeclaration" }, { "full_name": "ONote.toStringAux1", "code": "def toStringAux1 (e : ONote) (n : ℕ) (s : String) : String :=\n if e = 0 then toString n\n else (if e = 1 then \"ω\" else \"ω^(\" ++ s ++ \")\") ++ if n = 1 then \"\" else \"*\" ++ toString n", "start": [ 79, 1 ], "end": [ 82, 93 ], "kind": "commanddeclaration" }, { "full_name": "ONote.toString", "code": "def toString : ONote → String\n | zero => \"0\"\n | oadd e n 0 => toStringAux1 e n (toString e)\n | oadd e n a => toStringAux1 e n (toString e) ++ \" + \" ++ toString a", "start": [ 85, 1 ], "end": [ 89, 71 ], "kind": "commanddeclaration" }, { "full_name": "ONote.repr'", "code": "def repr' (prec : ℕ) : ONote → Format\n | zero => \"0\"\n | oadd e n a =>\n Repr.addAppParen\n (\"oadd \" ++ (repr' max_prec e) ++ \" \" ++ Nat.repr (n : ℕ) ++ \" \" ++ (repr' max_prec a))\n prec", "start": [ 93, 1 ], "end": [ 99, 11 ], "kind": "commanddeclaration" }, { "full_name": "ONote.lt_def", "code": "theorem lt_def {x y : ONote} : x < y ↔ repr x < repr y", "start": [ 115, 1 ], "end": [ 116, 10 ], "kind": "commanddeclaration" }, { "full_name": "ONote.le_def", "code": "theorem le_def {x y : ONote} : x ≤ y ↔ repr x ≤ repr y", "start": [ 119, 1 ], "end": [ 120, 10 ], "kind": "commanddeclaration" }, { "full_name": "ONote.ofNat", "code": "@[coe]\ndef ofNat : ℕ → ONote\n | 0 => 0\n | Nat.succ n => oadd 0 n.succPNat 0", "start": [ 126, 1 ], "end": [ 130, 38 ], "kind": "commanddeclaration" }, { "full_name": "ONote.ofNat_zero", "code": "@[simp] theorem ofNat_zero : ofNat 0 = 0", "start": [ 136, 1 ], "end": [ 137, 6 ], "kind": "commanddeclaration" }, { "full_name": "ONote.ofNat_succ", "code": "@[simp] theorem ofNat_succ (n) : ofNat (Nat.succ n) = oadd 0 n.succPNat 0", "start": [ 139, 1 ], "end": [ 140, 6 ], "kind": "commanddeclaration" }, { "full_name": "ONote.nat", "code": "instance nat (n : ℕ) : OfNat ONote n where\n ofNat := ofNat n", "start": [ 142, 1 ], "end": [ 143, 19 ], "kind": "commanddeclaration" }, { "full_name": "ONote.ofNat_one", "code": "@[simp 1200]\ntheorem ofNat_one : ofNat 1 = 1", "start": [ 145, 1 ], "end": [ 147, 6 ], "kind": "commanddeclaration" }, { "full_name": "ONote.repr_ofNat", "code": "@[simp]\ntheorem repr_ofNat (n : ℕ) : repr (ofNat n) = n", "start": [ 150, 1 ], "end": [ 151, 71 ], "kind": "commanddeclaration" }, { "full_name": "ONote.repr_one", "code": "theorem repr_one : repr (ofNat 1) = (1 : ℕ)", "start": [ 155, 1 ], "end": [ 155, 60 ], "kind": "commanddeclaration" }, { "full_name": "ONote.omega_le_oadd", "code": "theorem omega_le_oadd (e n a) : ω ^ repr e ≤ repr (oadd e n a)", "start": [ 158, 1 ], "end": [ 160, 96 ], "kind": "commanddeclaration" }, { "full_name": "ONote.oadd_pos", "code": "theorem oadd_pos (e n a) : 0 < oadd e n a", "start": [ 163, 1 ], "end": [ 164, 91 ], "kind": "commanddeclaration" }, { "full_name": "ONote.cmp", "code": "def cmp : ONote → ONote → Ordering\n | 0, 0 => Ordering.eq\n | _, 0 => Ordering.gt\n | 0, _ => Ordering.lt\n | _o₁@(oadd e₁ n₁ a₁), _o₂@(oadd e₂ n₂ a₂) =>\n (cmp e₁ e₂).orElse <| (_root_.cmp (n₁ : ℕ) n₂).orElse (cmp a₁ a₂)", "start": [ 167, 1 ], "end": [ 173, 70 ], "kind": "commanddeclaration" }, { "full_name": "ONote.eq_of_cmp_eq", "code": "theorem eq_of_cmp_eq : ∀ {o₁ o₂}, cmp o₁ o₂ = Ordering.eq → o₁ = o₂", "start": [ 176, 1 ], "end": [ 188, 9 ], "kind": "commanddeclaration" }, { "full_name": "ONote.zero_lt_one", "code": "protected theorem zero_lt_one : (0 : ONote) < 1", "start": [ 191, 1 ], "end": [ 193, 17 ], "kind": "commanddeclaration" }, { "full_name": "ONote.NFBelow", "code": "inductive NFBelow : ONote → Ordinal.{0} → Prop\n | zero {b} : NFBelow 0 b\n | oadd' {e n a eb b} : NFBelow e eb → NFBelow a (repr e) → repr e < b → NFBelow (oadd e n a) b", "start": [ 196, 1 ], "end": [ 200, 97 ], "kind": "commanddeclaration" }, { "full_name": "ONote.NF", "code": "class NF (o : ONote) : Prop where\n out : Exists (NFBelow o)", "start": [ 203, 1 ], "end": [ 214, 27 ], "kind": "commanddeclaration" }, { "full_name": "ONote.NF.zero", "code": "instance NF.zero : NF 0 :=\n ⟨⟨0, NFBelow.zero⟩⟩", "start": [ 217, 1 ], "end": [ 218, 22 ], "kind": "commanddeclaration" }, { "full_name": "ONote.NFBelow.oadd", "code": "theorem NFBelow.oadd {e n a b} : NF e → NFBelow a (repr e) → repr e < b → NFBelow (oadd e n a) b", "start": [ 221, 1 ], "end": [ 222, 32 ], "kind": "commanddeclaration" }, { "full_name": "ONote.NFBelow.fst", "code": "theorem NFBelow.fst {e n a b} (h : NFBelow (ONote.oadd e n a) b) : NF e", "start": [ 225, 1 ], "end": [ 226, 55 ], "kind": "commanddeclaration" }, { "full_name": "ONote.NF.fst", "code": "theorem NF.fst {e n a} : NF (oadd e n a) → NF e", "start": [ 229, 1 ], "end": [ 230, 22 ], "kind": "commanddeclaration" }, { "full_name": "ONote.NFBelow.snd", "code": "theorem NFBelow.snd {e n a b} (h : NFBelow (ONote.oadd e n a) b) : NFBelow a (repr e)", "start": [ 233, 1 ], "end": [ 234, 48 ], "kind": "commanddeclaration" }, { "full_name": "ONote.NF.snd'", "code": "theorem NF.snd' {e n a} : NF (oadd e n a) → NFBelow a (repr e)", "start": [ 237, 1 ], "end": [ 238, 22 ], "kind": "commanddeclaration" }, { "full_name": "ONote.NF.snd", "code": "theorem NF.snd {e n a} (h : NF (oadd e n a)) : NF a", "start": [ 241, 1 ], "end": [ 242, 16 ], "kind": "commanddeclaration" }, { "full_name": "ONote.NF.oadd", "code": "theorem NF.oadd {e a} (h₁ : NF e) (n) (h₂ : NFBelow a (repr e)) : NF (oadd e n a)", "start": [ 245, 1 ], "end": [ 246, 40 ], "kind": "commanddeclaration" }, { "full_name": "ONote.NF.oadd_zero", "code": "instance NF.oadd_zero (e n) [h : NF e] : NF (ONote.oadd e n 0) :=\n h.oadd _ NFBelow.zero", "start": [ 249, 1 ], "end": [ 250, 24 ], "kind": "commanddeclaration" }, { "full_name": "ONote.NFBelow.lt", "code": "theorem NFBelow.lt {e n a b} (h : NFBelow (ONote.oadd e n a) b) : repr e < b", "start": [ 253, 1 ], "end": [ 254, 48 ], "kind": "commanddeclaration" }, { "full_name": "ONote.NFBelow_zero", "code": "theorem NFBelow_zero : ∀ {o}, NFBelow o 0 ↔ o = 0", "start": [ 257, 1 ], "end": [ 260, 92 ], "kind": "commanddeclaration" }, { "full_name": "ONote.NF.zero_of_zero", "code": "theorem NF.zero_of_zero {e n a} (h : NF (ONote.oadd e n a)) (e0 : e = 0) : a = 0", "start": [ 263, 1 ], "end": [ 264, 40 ], "kind": "commanddeclaration" }, { "full_name": "ONote.NFBelow.repr_lt", "code": "theorem NFBelow.repr_lt {o b} (h : NFBelow o b) : repr o < ω ^ b", "start": [ 267, 1 ], "end": [ 275, 58 ], "kind": "commanddeclaration" }, { "full_name": "ONote.NFBelow.mono", "code": "theorem NFBelow.mono {o b₁ b₂} (bb : b₁ ≤ b₂) (h : NFBelow o b₁) : NFBelow o b₂", "start": [ 278, 1 ], "end": [ 280, 40 ], "kind": "commanddeclaration" }, { "full_name": "ONote.NF.below_of_lt", "code": "theorem NF.below_of_lt {e n a b} (H : repr e < b) :\n NF (ONote.oadd e n a) → NFBelow (ONote.oadd e n a) b", "start": [ 283, 1 ], "end": [ 285, 87 ], "kind": "commanddeclaration" }, { "full_name": "ONote.NF.below_of_lt'", "code": "theorem NF.below_of_lt' : ∀ {o b}, repr o < ω ^ b → NF o → NFBelow o b", "start": [ 288, 1 ], "end": [ 292, 88 ], "kind": "commanddeclaration" }, { "full_name": "ONote.nfBelow_ofNat", "code": "theorem nfBelow_ofNat : ∀ n, NFBelow (ofNat n) 1", "start": [ 295, 1 ], "end": [ 297, 64 ], "kind": "commanddeclaration" }, { "full_name": "ONote.nf_ofNat", "code": "instance nf_ofNat (n) : NF (ofNat n) :=\n ⟨⟨_, nfBelow_ofNat n⟩⟩", "start": [ 300, 1 ], "end": [ 301, 25 ], "kind": "commanddeclaration" }, { "full_name": "ONote.nf_one", "code": "instance nf_one : NF 1 := by rw [← ofNat_one]; infer_instance", "start": [ 304, 1 ], "end": [ 304, 62 ], "kind": "commanddeclaration" }, { "full_name": "ONote.oadd_lt_oadd_1", "code": "theorem oadd_lt_oadd_1 {e₁ n₁ o₁ e₂ n₂ o₂} (h₁ : NF (oadd e₁ n₁ o₁)) (h : e₁ < e₂) :\n oadd e₁ n₁ o₁ < oadd e₂ n₂ o₂", "start": [ 307, 1 ], "end": [ 310, 59 ], "kind": "commanddeclaration" }, { "full_name": "ONote.oadd_lt_oadd_2", "code": "theorem oadd_lt_oadd_2 {e o₁ o₂ : ONote} {n₁ n₂ : ℕ+} (h₁ : NF (oadd e n₁ o₁)) (h : (n₁ : ℕ) < n₂) :\n oadd e n₁ o₁ < oadd e n₂ o₂", "start": [ 313, 1 ], "end": [ 317, 95 ], "kind": "commanddeclaration" }, { "full_name": "ONote.oadd_lt_oadd_3", "code": "theorem oadd_lt_oadd_3 {e n a₁ a₂} (h : a₁ < a₂) : oadd e n a₁ < oadd e n a₂", "start": [ 320, 1 ], "end": [ 322, 49 ], "kind": "commanddeclaration" }, { "full_name": "ONote.cmp_compares", "code": "theorem cmp_compares : ∀ (a b : ONote) [NF a] [NF b], (cmp a b).Compares a b", "start": [ 325, 1 ], "end": [ 362, 27 ], "kind": "commanddeclaration" }, { "full_name": "ONote.repr_inj", "code": "theorem repr_inj {a b} [NF a] [NF b] : repr a = repr b ↔ a = b", "start": [ 365, 1 ], "end": [ 370, 17 ], "kind": "commanddeclaration" }, { "full_name": "ONote.NF.of_dvd_omega_opow", "code": "theorem NF.of_dvd_omega_opow {b e n a} (h : NF (ONote.oadd e n a))\n (d : ω ^ b ∣ repr (ONote.oadd e n a)) :\n b ≤ repr e ∧ ω ^ b ∣ repr a", "start": [ 373, 1 ], "end": [ 379, 66 ], "kind": "commanddeclaration" }, { "full_name": "ONote.NF.of_dvd_omega", "code": "theorem NF.of_dvd_omega {e n a} (h : NF (ONote.oadd e n a)) :\n ω ∣ repr (ONote.oadd e n a) → repr e ≠ 0 ∧ ω ∣ repr a", "start": [ 382, 1 ], "end": [ 384, 71 ], "kind": "commanddeclaration" }, { "full_name": "ONote.TopBelow", "code": "def TopBelow (b : ONote) : ONote → Prop\n | 0 => True\n | oadd e _ _ => cmp e b = Ordering.lt", "start": [ 387, 1 ], "end": [ 392, 40 ], "kind": "commanddeclaration" }, { "full_name": "ONote.decidableTopBelow", "code": "instance decidableTopBelow : DecidableRel TopBelow := by\n intro b o\n cases o <;> delta TopBelow <;> infer_instance", "start": [ 395, 1 ], "end": [ 397, 48 ], "kind": "commanddeclaration" }, { "full_name": "ONote.nfBelow_iff_topBelow", "code": "theorem nfBelow_iff_topBelow {b} [NF b] : ∀ {o}, NFBelow o (repr b) ↔ NF o ∧ TopBelow b o", "start": [ 400, 1 ], "end": [ 404, 65 ], "kind": "commanddeclaration" }, { "full_name": "ONote.decidableNF", "code": "instance decidableNF : DecidablePred NF\n | 0 => isTrue NF.zero\n | oadd e n a => by\n have := decidableNF e\n have := decidableNF a\n apply decidable_of_iff (NF e ∧ NF a ∧ TopBelow e a)\n rw [← and_congr_right fun h => @nfBelow_iff_topBelow _ h _]\n exact ⟨fun ⟨h₁, h₂⟩ => NF.oadd h₁ n h₂, fun h => ⟨h.fst, h.snd'⟩⟩", "start": [ 407, 1 ], "end": [ 414, 70 ], "kind": "commanddeclaration" }, { "full_name": "ONote.addAux", "code": "def addAux (e : ONote) (n : ℕ+) (o : ONote) : ONote :=\n match o with\n | 0 => oadd e n 0\n | o'@(oadd e' n' a') =>\n match cmp e e' with\n | Ordering.lt => o'\n | Ordering.eq => oadd e (n + n') a'\n | Ordering.gt => oadd e n o'", "start": [ 417, 1 ], "end": [ 425, 35 ], "kind": "commanddeclaration" }, { "full_name": "ONote.add", "code": "def add : ONote → ONote → ONote\n | 0, o => o\n | oadd e n a, o => addAux e n (add a o)", "start": [ 427, 1 ], "end": [ 430, 42 ], "kind": "commanddeclaration" }, { "full_name": "ONote.zero_add", "code": "@[simp]\ntheorem zero_add (o : ONote) : 0 + o = o", "start": [ 436, 1 ], "end": [ 438, 6 ], "kind": "commanddeclaration" }, { "full_name": "ONote.oadd_add", "code": "theorem oadd_add (e n a o) : oadd e n a + o = addAux e n (a + o)", "start": [ 441, 1 ], "end": [ 442, 6 ], "kind": "commanddeclaration" }, { "full_name": "ONote.sub", "code": "def sub : ONote → ONote → ONote\n | 0, _ => 0\n | o, 0 => o\n | o₁@(oadd e₁ n₁ a₁), oadd e₂ n₂ a₂ =>\n match cmp e₁ e₂ with\n | Ordering.lt => 0\n | Ordering.gt => o₁\n | Ordering.eq =>\n match (n₁ : ℕ) - n₂ with\n | 0 => if n₁ = n₂ then sub a₁ a₂ else 0\n | Nat.succ k => oadd e₁ k.succPNat a₁", "start": [ 445, 1 ], "end": [ 456, 44 ], "kind": "commanddeclaration" }, { "full_name": "ONote.add_nfBelow", "code": "theorem add_nfBelow {b} : ∀ {o₁ o₂}, NFBelow o₁ b → NFBelow o₂ b → NFBelow (o₁ + o₂) b", "start": [ 462, 1 ], "end": [ 475, 70 ], "kind": "commanddeclaration" }, { "full_name": "ONote.add_nf", "code": "instance add_nf (o₁ o₂) : ∀ [NF o₁] [NF o₂], NF (o₁ + o₂)\n | ⟨⟨b₁, h₁⟩⟩, ⟨⟨b₂, h₂⟩⟩ =>\n ⟨(le_total b₁ b₂).elim (fun h => ⟨b₂, add_nfBelow (h₁.mono h) h₂⟩) fun h =>\n ⟨b₁, add_nfBelow h₁ (h₂.mono h)⟩⟩", "start": [ 478, 1 ], "end": [ 481, 42 ], "kind": "commanddeclaration" }, { "full_name": "ONote.repr_add", "code": "@[simp]\ntheorem repr_add : ∀ (o₁ o₂) [NF o₁] [NF o₂], repr (o₁ + o₂) = repr o₁ + repr o₂", "start": [ 484, 1 ], "end": [ 505, 38 ], "kind": "commanddeclaration" }, { "full_name": "ONote.sub_nfBelow", "code": "theorem sub_nfBelow : ∀ {o₁ o₂ b}, NFBelow o₁ b → NF o₂ → NFBelow (o₁ - o₂) b", "start": [ 508, 1 ], "end": [ 524, 15 ], "kind": "commanddeclaration" }, { "full_name": "ONote.sub_nf", "code": "instance sub_nf (o₁ o₂) : ∀ [NF o₁] [NF o₂], NF (o₁ - o₂)\n | ⟨⟨b₁, h₁⟩⟩, h₂ => ⟨⟨b₁, sub_nfBelow h₁ h₂⟩⟩", "start": [ 527, 1 ], "end": [ 528, 48 ], "kind": "commanddeclaration" }, { "full_name": "ONote.repr_sub", "code": "@[simp]\ntheorem repr_sub : ∀ (o₁ o₂) [NF o₁] [NF o₂], repr (o₁ - o₂) = repr o₁ - repr o₂", "start": [ 531, 1 ], "end": [ 565, 80 ], "kind": "commanddeclaration" }, { "full_name": "ONote.mul", "code": "def mul : ONote → ONote → ONote\n | 0, _ => 0\n | _, 0 => 0\n | o₁@(oadd e₁ n₁ a₁), oadd e₂ n₂ a₂ =>\n if e₂ = 0 then oadd e₁ (n₁ * n₂) a₁ else oadd (e₁ + e₂) n₂ (mul o₁ a₂)", "start": [ 568, 1 ], "end": [ 573, 75 ], "kind": "commanddeclaration" }, { "full_name": "ONote.oadd_mul", "code": "theorem oadd_mul (e₁ n₁ a₁ e₂ n₂ a₂) :\n oadd e₁ n₁ a₁ * oadd e₂ n₂ a₂ =\n if e₂ = 0 then oadd e₁ (n₁ * n₂) a₁ else oadd (e₁ + e₂) n₂ (oadd e₁ n₁ a₁ * a₂)", "start": [ 585, 1 ], "end": [ 588, 6 ], "kind": "commanddeclaration" }, { "full_name": "ONote.oadd_mul_nfBelow", "code": "theorem oadd_mul_nfBelow {e₁ n₁ a₁ b₁} (h₁ : NFBelow (oadd e₁ n₁ a₁) b₁) :\n ∀ {o₂ b₂}, NFBelow o₂ b₂ → NFBelow (oadd e₁ n₁ a₁ * o₂) (repr e₁ + b₂)", "start": [ 591, 1 ], "end": [ 605, 20 ], "kind": "commanddeclaration" }, { "full_name": "ONote.mul_nf", "code": "instance mul_nf : ∀ (o₁ o₂) [NF o₁] [NF o₂], NF (o₁ * o₂)\n | 0, o, _, h₂ => by cases o <;> exact NF.zero\n | oadd e n a, o, ⟨⟨b₁, hb₁⟩⟩, ⟨⟨b₂, hb₂⟩⟩ => ⟨⟨_, oadd_mul_nfBelow hb₁ hb₂⟩⟩", "start": [ 608, 1 ], "end": [ 610, 79 ], "kind": "commanddeclaration" }, { "full_name": "ONote.repr_mul", "code": "@[simp]\ntheorem repr_mul : ∀ (o₁ o₂) [NF o₁] [NF o₂], repr (o₁ * o₂) = repr o₁ * repr o₂", "start": [ 613, 1 ], "end": [ 637, 62 ], "kind": "commanddeclaration" }, { "full_name": "ONote.split'", "code": "def split' : ONote → ONote × ℕ\n | 0 => (0, 0)\n | oadd e n a =>\n if e = 0 then (0, n)\n else\n let (a', m) := split' a\n (oadd (e - 1) n a', m)", "start": [ 640, 1 ], "end": [ 648, 29 ], "kind": "commanddeclaration" }, { "full_name": "ONote.split", "code": "def split : ONote → ONote × ℕ\n | 0 => (0, 0)\n | oadd e n a =>\n if e = 0 then (0, n)\n else\n let (a', m) := split a\n (oadd e n a', m)", "start": [ 651, 1 ], "end": [ 659, 23 ], "kind": "commanddeclaration" }, { "full_name": "ONote.scale", "code": "def scale (x : ONote) : ONote → ONote\n | 0 => 0\n | oadd e n a => oadd (x + e) n (scale x a)", "start": [ 662, 1 ], "end": [ 665, 45 ], "kind": "commanddeclaration" }, { "full_name": "ONote.mulNat", "code": "def mulNat : ONote → ℕ → ONote\n | 0, _ => 0\n | _, 0 => 0\n | oadd e n a, m + 1 => oadd e (n * m.succPNat) a", "start": [ 668, 1 ], "end": [ 672, 51 ], "kind": "commanddeclaration" }, { "full_name": "ONote.opowAux", "code": "def opowAux (e a0 a : ONote) : ℕ → ℕ → ONote\n | _, 0 => 0\n | 0, m + 1 => oadd e m.succPNat 0\n | k + 1, m => scale (e + mulNat a0 k) a + (opowAux e a0 a k m)", "start": [ 675, 1 ], "end": [ 680, 65 ], "kind": "commanddeclaration" }, { "full_name": "ONote.opowAux2", "code": "def opowAux2 (o₂ : ONote) (o₁ : ONote × ℕ) : ONote :=\n match o₁ with\n | (0, 0) => if o₂ = 0 then 1 else 0\n | (0, 1) => 1\n | (0, m + 1) =>\n let (b', k) := split' o₂\n oadd b' (m.succPNat ^ k) 0\n | (a@(oadd a0 _ _), m) =>\n match split o₂ with\n | (b, 0) => oadd (a0 * b) 1 0\n | (b, k + 1) =>\n let eb := a0 * b\n scale (eb + mulNat a0 k) a + opowAux eb a0 (mulNat a m) k m", "start": [ 683, 1 ], "end": [ 697, 66 ], "kind": "commanddeclaration" }, { "full_name": "ONote.opow", "code": "def opow (o₁ o₂ : ONote) : ONote := opowAux2 o₂ (split o₁)", "start": [ 699, 1 ], "end": [ 701, 59 ], "kind": "commanddeclaration" }, { "full_name": "ONote.opow_def", "code": "theorem opow_def (o₁ o₂ : ONote) : o₁ ^ o₂ = opowAux2 o₂ (split o₁)", "start": [ 707, 1 ], "end": [ 708, 6 ], "kind": "commanddeclaration" }, { "full_name": "ONote.split_eq_scale_split'", "code": "theorem split_eq_scale_split' : ∀ {o o' m} [NF o], split' o = (o', m) → split o = (scale 1 o', m)", "start": [ 711, 1 ], "end": [ 732, 25 ], "kind": "commanddeclaration" }, { "full_name": "ONote.nf_repr_split'", "code": "theorem nf_repr_split' : ∀ {o o' m} [NF o], split' o = (o', m) → NF o' ∧ repr o = ω * repr o' + m", "start": [ 735, 1 ], "end": [ 760, 45 ], "kind": "commanddeclaration" }, { "full_name": "ONote.scale_eq_mul", "code": "theorem scale_eq_mul (x) [NF x] : ∀ (o) [NF o], scale x o = oadd x 1 0 * o", "start": [ 763, 1 ], "end": [ 772, 53 ], "kind": "commanddeclaration" }, { "full_name": "ONote.nf_scale", "code": "instance nf_scale (x) [NF x] (o) [NF o] : NF (scale x o) := by\n rw [scale_eq_mul]\n infer_instance", "start": [ 775, 1 ], "end": [ 777, 17 ], "kind": "commanddeclaration" }, { "full_name": "ONote.repr_scale", "code": "@[simp]\ntheorem repr_scale (x) [NF x] (o) [NF o] : repr (scale x o) = ω ^ repr x * repr o", "start": [ 780, 1 ], "end": [ 782, 90 ], "kind": "commanddeclaration" }, { "full_name": "ONote.nf_repr_split", "code": "theorem nf_repr_split {o o' m} [NF o] (h : split o = (o', m)) : NF o' ∧ repr o = repr o' + m", "start": [ 785, 1 ], "end": [ 792, 17 ], "kind": "commanddeclaration" }, { "full_name": "ONote.split_dvd", "code": "theorem split_dvd {o o' m} [NF o] (h : split o = (o', m)) : ω ∣ repr o'", "start": [ 795, 1 ], "end": [ 799, 31 ], "kind": "commanddeclaration" }, { "full_name": "ONote.split_add_lt", "code": "theorem split_add_lt {o e n a m} [NF o] (h : split o = (oadd e n a, m)) :\n repr a + m < ω ^ repr e", "start": [ 802, 1 ], "end": [ 807, 69 ], "kind": "commanddeclaration" }, { "full_name": "ONote.mulNat_eq_mul", "code": "@[simp]\ntheorem mulNat_eq_mul (n o) : mulNat o n = o * ofNat n", "start": [ 810, 1 ], "end": [ 811, 89 ], "kind": "commanddeclaration" }, { "full_name": "ONote.nf_mulNat", "code": "instance nf_mulNat (o) [NF o] (n) : NF (mulNat o n) := by simp; exact ONote.mul_nf o (ofNat n)", "start": [ 814, 1 ], "end": [ 814, 95 ], "kind": "commanddeclaration" }, { "full_name": "ONote.nf_opowAux", "code": "instance nf_opowAux (e a0 a) [NF e] [NF a0] [NF a] : ∀ k m, NF (opowAux e a0 a k m) := by\n intro k m\n unfold opowAux\n cases' m with m m\n · cases k <;> exact NF.zero\n cases' k with k k\n · exact NF.oadd_zero _ _\n · haveI := nf_opowAux e a0 a k\n simp only [Nat.succ_ne_zero m, IsEmpty.forall_iff, mulNat_eq_mul]; infer_instance", "start": [ 817, 1 ], "end": [ 825, 86 ], "kind": "commanddeclaration" }, { "full_name": "ONote.nf_opow", "code": "instance nf_opow (o₁ o₂) [NF o₁] [NF o₂] : NF (o₁ ^ o₂) := by\n cases' e₁ : split o₁ with a m\n have na := (nf_repr_split e₁).1\n cases' e₂ : split' o₂ with b' k\n haveI := (nf_repr_split' e₂).1\n cases' a with a0 n a'\n · cases' m with m\n · by_cases o₂ = 0 <;> simp only [(· ^ ·), Pow.pow, pow, opow, opowAux2, *] <;> decide\n · by_cases m = 0\n · simp only [(· ^ ·), Pow.pow, pow, opow, opowAux2, *, zero_def]\n decide\n · simp only [(· ^ ·), Pow.pow, pow, opow, opowAux2, mulNat_eq_mul, ofNat, *]\n infer_instance\n · simp [(· ^ ·),Pow.pow,pow, opow, opowAux2, e₁, e₂, split_eq_scale_split' e₂]\n have := na.fst\n cases' k with k <;> simp\n · infer_instance\n · cases k <;> cases m <;> infer_instance", "start": [ 828, 1 ], "end": [ 845, 45 ], "kind": "commanddeclaration" }, { "full_name": "ONote.scale_opowAux", "code": "theorem scale_opowAux (e a0 a : ONote) [NF e] [NF a0] [NF a] :\n ∀ k m, repr (opowAux e a0 a k m) = ω ^ repr e * repr (opowAux 0 a0 a k m)", "start": [ 848, 1 ], "end": [ 860, 79 ], "kind": "commanddeclaration" }, { "full_name": "ONote.repr_opow_aux₁", "code": "theorem repr_opow_aux₁ {e a} [Ne : NF e] [Na : NF a] {a' : Ordinal} (e0 : repr e ≠ 0)\n (h : a' < (ω : Ordinal.{0}) ^ repr e) (aa : repr a = a') (n : ℕ+) :\n ((ω : Ordinal.{0}) ^ repr e * (n : ℕ) + a') ^ (ω : Ordinal.{0}) =\n (ω ^ repr e) ^ (ω : Ordinal.{0})", "start": [ 863, 1 ], "end": [ 885, 62 ], "kind": "commanddeclaration" }, { "full_name": "ONote.repr_opow_aux₂", "code": "theorem repr_opow_aux₂ {a0 a'} [N0 : NF a0] [Na' : NF a'] (m : ℕ) (d : ω ∣ repr a')\n (e0 : repr a0 ≠ 0) (h : repr a' + m < (ω ^ repr a0)) (n : ℕ+) (k : ℕ) :\n let R := repr (opowAux 0 a0 (oadd a0 n a' * ofNat m) k m)\n (k ≠ 0 → R < ((ω ^ repr a0) ^ succ (k : Ordinal))) ∧\n ((ω ^ repr a0) ^ (k : Ordinal)) * ((ω ^ repr a0) * (n : ℕ) + repr a') + R =\n ((ω ^ repr a0) * (n : ℕ) + repr a' + m) ^ succ (k : Ordinal)", "start": [ 892, 1 ], "end": [ 966, 47 ], "kind": "commanddeclaration" }, { "full_name": "ONote.repr_opow", "code": "theorem repr_opow (o₁ o₂) [NF o₁] [NF o₂] : repr (o₁ ^ o₂) = repr o₁ ^ repr o₂", "start": [ 971, 1 ], "end": [ 1015, 47 ], "kind": "commanddeclaration" }, { "full_name": "ONote.fundamentalSequence", "code": "def fundamentalSequence : ONote → Sum (Option ONote) (ℕ → ONote)\n | zero => Sum.inl none\n | oadd a m b =>\n match fundamentalSequence b with\n | Sum.inr f => Sum.inr fun i => oadd a m (f i)\n | Sum.inl (some b') => Sum.inl (some (oadd a m b'))\n | Sum.inl none =>\n match fundamentalSequence a, m.natPred with\n | Sum.inl none, 0 => Sum.inl (some zero)\n | Sum.inl none, m + 1 => Sum.inl (some (oadd zero m.succPNat zero))\n | Sum.inl (some a'), 0 => Sum.inr fun i => oadd a' i.succPNat zero\n | Sum.inl (some a'), m + 1 => Sum.inr fun i => oadd a m.succPNat (oadd a' i.succPNat zero)\n | Sum.inr f, 0 => Sum.inr fun i => oadd (f i) 1 zero\n | Sum.inr f, m + 1 => Sum.inr fun i => oadd a m.succPNat (oadd (f i) 1 zero)", "start": [ 1018, 1 ], "end": [ 1033, 83 ], "kind": "commanddeclaration" }, { "full_name": "ONote.exists_lt_add", "code": "private theorem exists_lt_add {α} [hα : Nonempty α] {o : Ordinal} {f : α → Ordinal}\n (H : ∀ ⦃a⦄, a < o → ∃ i, a < f i) {b : Ordinal} ⦃a⦄ (h : a < b + o) : ∃ i, a < b + f i", "start": [ 1036, 1 ], "end": [ 1043, 65 ], "kind": "commanddeclaration" }, { "full_name": "ONote.exists_lt_mul_omega'", "code": "private theorem exists_lt_mul_omega' {o : Ordinal} ⦃a⦄ (h : a < o * ω) :\n ∃ i : ℕ, a < o * ↑i + o", "start": [ 1045, 1 ], "end": [ 1049, 44 ], "kind": "commanddeclaration" }, { "full_name": "ONote.exists_lt_omega_opow'", "code": "private theorem exists_lt_omega_opow' {α} {o b : Ordinal} (hb : 1 < b) (ho : o.IsLimit)\n {f : α → Ordinal} (H : ∀ ⦃a⦄, a < o → ∃ i, a < f i) ⦃a⦄ (h : a < b ^ o) :\n ∃ i, a < b ^ f i", "start": [ 1051, 1 ], "end": [ 1055, 76 ], "kind": "commanddeclaration" }, { "full_name": "ONote.FundamentalSequenceProp", "code": "def FundamentalSequenceProp (o : ONote) : Sum (Option ONote) (ℕ → ONote) → Prop\n | Sum.inl none => o = 0\n | Sum.inl (some a) => o.repr = succ a.repr ∧ (o.NF → a.NF)\n | Sum.inr f =>\n o.repr.IsLimit ∧\n (∀ i, f i < f (i + 1) ∧ f i < o ∧ (o.NF → (f i).NF)) ∧ ∀ a, a < o.repr → ∃ i, a < (f i).repr", "start": [ 1057, 1 ], "end": [ 1067, 99 ], "kind": "commanddeclaration" }, { "full_name": "ONote.fundamentalSequenceProp_inl_none", "code": "theorem fundamentalSequenceProp_inl_none (o) :\n FundamentalSequenceProp o (Sum.inl none) ↔ o = 0", "start": [ 1070, 1 ], "end": [ 1072, 10 ], "kind": "commanddeclaration" }, { "full_name": "ONote.fundamentalSequenceProp_inl_some", "code": "theorem fundamentalSequenceProp_inl_some (o a) :\n FundamentalSequenceProp o (Sum.inl (some a)) ↔ o.repr = succ a.repr ∧ (o.NF → a.NF)", "start": [ 1074, 1 ], "end": [ 1076, 10 ], "kind": "commanddeclaration" }, { "full_name": "ONote.fundamentalSequenceProp_inr", "code": "theorem fundamentalSequenceProp_inr (o f) :\n FundamentalSequenceProp o (Sum.inr f) ↔\n o.repr.IsLimit ∧\n (∀ i, f i < f (i + 1) ∧ f i < o ∧ (o.NF → (f i).NF)) ∧\n ∀ a, a < o.repr → ∃ i, a < (f i).repr", "start": [ 1078, 1 ], "end": [ 1083, 10 ], "kind": "commanddeclaration" }, { "full_name": "ONote.fundamentalSequence_has_prop", "code": "theorem fundamentalSequence_has_prop (o) : FundamentalSequenceProp o (fundamentalSequence o)", "start": [ 1092, 1 ], "end": [ 1149, 26 ], "kind": "commanddeclaration" }, { "full_name": "ONote.fastGrowing", "code": "def fastGrowing : ONote → ℕ → ℕ\n | o =>\n match fundamentalSequence o, fundamentalSequence_has_prop o with\n | Sum.inl none, _ => Nat.succ\n | Sum.inl (some a), h =>\n have : a < o := by rw [lt_def, h.1]; apply lt_succ\n fun i => (fastGrowing a)^[i] i\n | Sum.inr f, h => fun i =>\n have : f i < o := (h.2.1 i).2.1\n fastGrowing (f i) i\n termination_by o => o", "start": [ 1152, 1 ], "end": [ 1168, 24 ], "kind": "commanddeclaration" }, { "full_name": "ONote.fastGrowing_def", "code": "@[nolint unusedHavesSuffices]\ntheorem fastGrowing_def {o : ONote} {x} (e : fundamentalSequence o = x) :\n fastGrowing o =\n match\n (motive := (x : Option ONote ⊕ (ℕ → ONote)) → FundamentalSequenceProp o x → ℕ → ℕ)\n x, e ▸ fundamentalSequence_has_prop o with\n | Sum.inl none, _ => Nat.succ\n | Sum.inl (some a), _ =>\n fun i => (fastGrowing a)^[i] i\n | Sum.inr f, _ => fun i =>\n fastGrowing (f i) i", "start": [ 1172, 1 ], "end": [ 1184, 19 ], "kind": "commanddeclaration" }, { "full_name": "ONote.fastGrowing_zero'", "code": "theorem fastGrowing_zero' (o : ONote) (h : fundamentalSequence o = Sum.inl none) :\n fastGrowing o = Nat.succ", "start": [ 1187, 1 ], "end": [ 1189, 25 ], "kind": "commanddeclaration" }, { "full_name": "ONote.fastGrowing_succ", "code": "theorem fastGrowing_succ (o) {a} (h : fundamentalSequence o = Sum.inl (some a)) :\n fastGrowing o = fun i => (fastGrowing a)^[i] i", "start": [ 1192, 1 ], "end": [ 1194, 25 ], "kind": "commanddeclaration" }, { "full_name": "ONote.fastGrowing_limit", "code": "theorem fastGrowing_limit (o) {f} (h : fundamentalSequence o = Sum.inr f) :\n fastGrowing o = fun i => fastGrowing (f i) i", "start": [ 1197, 1 ], "end": [ 1199, 25 ], "kind": "commanddeclaration" }, { "full_name": "ONote.fastGrowing_zero", "code": "@[simp]\ntheorem fastGrowing_zero : fastGrowing 0 = Nat.succ", "start": [ 1202, 1 ], "end": [ 1204, 26 ], "kind": "commanddeclaration" }, { "full_name": "ONote.fastGrowing_one", "code": "@[simp]\ntheorem fastGrowing_one : fastGrowing 1 = fun n => 2 * n", "start": [ 1207, 1 ], "end": [ 1211, 101 ], "kind": "commanddeclaration" }, { "full_name": "ONote.fastGrowing_two", "code": "@[simp]\ntheorem fastGrowing_two : fastGrowing 2 = fun n => (2 ^ n) * n", "start": [ 1216, 1 ], "end": [ 1221, 81 ], "kind": "commanddeclaration" }, { "full_name": "ONote.fastGrowingε₀", "code": "def fastGrowingε₀ (i : ℕ) : ℕ :=\n fastGrowing ((fun a => a.oadd 1 0)^[i] 0) i", "start": [ 1226, 1 ], "end": [ 1231, 46 ], "kind": "commanddeclaration" }, { "full_name": "ONote.fastGrowingε₀_zero", "code": "theorem fastGrowingε₀_zero : fastGrowingε₀ 0 = 1", "start": [ 1234, 1 ], "end": [ 1234, 76 ], "kind": "commanddeclaration" }, { "full_name": "ONote.fastGrowingε₀_one", "code": "theorem fastGrowingε₀_one : fastGrowingε₀ 1 = 2", "start": [ 1237, 1 ], "end": [ 1238, 53 ], "kind": "commanddeclaration" }, { "full_name": "ONote.fastGrowingε₀_two", "code": "theorem fastGrowingε₀_two : fastGrowingε₀ 2 = 2048", "start": [ 1241, 1 ], "end": [ 1243, 78 ], "kind": "commanddeclaration" }, { "full_name": "NONote", "code": "def NONote :=\n { o : ONote // o.NF }", "start": [ 1248, 1 ], "end": [ 1254, 24 ], "kind": "commanddeclaration" }, { "full_name": "NONote.NF", "code": "instance NF (o : NONote) : NF o.1 :=\n o.2", "start": [ 1263, 1 ], "end": [ 1264, 6 ], "kind": "commanddeclaration" }, { "full_name": "NONote.mk", "code": "def mk (o : ONote) [h : ONote.NF o] : NONote :=\n ⟨o, h⟩", "start": [ 1267, 1 ], "end": [ 1270, 9 ], "kind": "commanddeclaration" }, { "full_name": "NONote.repr", "code": "noncomputable def repr (o : NONote) : Ordinal :=\n o.1.repr", "start": [ 1273, 1 ], "end": [ 1280, 11 ], "kind": "commanddeclaration" }, { "full_name": "NONote.lt_wf", "code": "theorem lt_wf : @WellFounded NONote (· < ·)", "start": [ 1302, 1 ], "end": [ 1303, 33 ], "kind": "commanddeclaration" }, { "full_name": "NONote.ofNat", "code": "def ofNat (n : ℕ) : NONote :=\n ⟨ONote.ofNat n, ⟨⟨_, nfBelow_ofNat _⟩⟩⟩", "start": [ 1312, 1 ], "end": [ 1314, 42 ], "kind": "commanddeclaration" }, { "full_name": "NONote.cmp", "code": "def cmp (a b : NONote) : Ordering :=\n ONote.cmp a.1 b.1", "start": [ 1317, 1 ], "end": [ 1319, 20 ], "kind": "commanddeclaration" }, { "full_name": "NONote.cmp_compares", "code": "theorem cmp_compares : ∀ a b : NONote, (cmp a b).Compares a b", "start": [ 1322, 1 ], "end": [ 1327, 34 ], "kind": "commanddeclaration" }, { "full_name": "NONote.below", "code": "def below (a b : NONote) : Prop :=\n NFBelow a.1 (repr b)", "start": [ 1335, 1 ], "end": [ 1337, 23 ], "kind": "commanddeclaration" }, { "full_name": "NONote.oadd", "code": "def oadd (e : NONote) (n : ℕ+) (a : NONote) (h : below a e) : NONote :=\n ⟨_, NF.oadd e.2 n h⟩", "start": [ 1340, 1 ], "end": [ 1342, 23 ], "kind": "commanddeclaration" }, { "full_name": "NONote.recOn", "code": "@[elab_as_elim]\ndef recOn {C : NONote → Sort*} (o : NONote) (H0 : C 0)\n (H1 : ∀ e n a h, C e → C a → C (oadd e n a h)) : C o := by\n cases' o with o h; induction' o with e n a IHe IHa\n · exact H0\n · exact H1 ⟨e, h.fst⟩ n ⟨a, h.snd⟩ h.snd' (IHe _) (IHa _)", "start": [ 1345, 1 ], "end": [ 1353, 60 ], "kind": "commanddeclaration" }, { "full_name": "NONote.repr_add", "code": "theorem repr_add (a b) : repr (a + b) = repr a + repr b", "start": [ 1360, 1 ], "end": [ 1361, 25 ], "kind": "commanddeclaration" }, { "full_name": "NONote.repr_sub", "code": "theorem repr_sub (a b) : repr (a - b) = repr a - repr b", "start": [ 1368, 1 ], "end": [ 1369, 25 ], "kind": "commanddeclaration" }, { "full_name": "NONote.repr_mul", "code": "theorem repr_mul (a b) : repr (a * b) = repr a * repr b", "start": [ 1376, 1 ], "end": [ 1377, 25 ], "kind": "commanddeclaration" }, { "full_name": "NONote.opow", "code": "def opow (x y : NONote) :=\n mk (x.1 ^ y.1)", "start": [ 1380, 1 ], "end": [ 1382, 17 ], "kind": "commanddeclaration" }, { "full_name": "NONote.repr_opow", "code": "theorem repr_opow (a b) : repr (opow a b) = repr a ^ repr b", "start": [ 1385, 1 ], "end": [ 1386, 26 ], "kind": "commanddeclaration" } ]

[ "Mathlib/Combinatorics/SimpleGraph/Triangle/Removal.lean", "Mathlib/Combinatorics/Additive/AP/Three/Defs.lean", "Mathlib/Combinatorics/SimpleGraph/Triangle/Tripartite.lean", "Mathlib/Combinatorics/Additive/Corner/Defs.lean", ".lake/packages/lean4/src/lean/Init.lean" ]

[ { "full_name": "Corners.triangleIndices", "code": "private def triangleIndices (A : Finset (G × G)) : Finset (G × G × G) :=\n A.map ⟨fun (a, b) ↦ (a, b, a + b), by rintro ⟨x₁, x₂⟩ ⟨y₁, y₂⟩ ⟨⟩; rfl⟩", "start": [ 31, 1 ], "end": [ 33, 74 ], "kind": "commanddeclaration" }, { "full_name": "Corners.mk_mem_triangleIndices", "code": "@[simp]\nprivate lemma mk_mem_triangleIndices : (a, b, c) ∈ triangleIndices A ↔ (a, b) ∈ A ∧ c = a + b := by\n simp only [triangleIndices, Prod.ext_iff, mem_map, Embedding.coeFn_mk, exists_prop, Prod.exists,\n eq_comm]\n refine ⟨?_, fun h ↦ ⟨_, _, h.1, rfl, rfl, h.2⟩⟩\n rintro ⟨_, _, h₁, rfl, rfl, h₂⟩\n exact ⟨h₁, h₂⟩", "start": [ 35, 1 ], "end": [ 41, 17 ], "kind": "lemma" }, { "full_name": "Corners.card_triangleIndices", "code": "@[simp] private lemma card_triangleIndices : (triangleIndices A).card = A.card := card_map _", "start": [ 43, 1 ], "end": [ 43, 93 ], "kind": "lemma" }, { "full_name": "Corners.triangleIndices.instExplicitDisjoint", "code": "private instance triangleIndices.instExplicitDisjoint : ExplicitDisjoint (triangleIndices A) := by\n constructor\n all_goals\n simp only [mk_mem_triangleIndices, Prod.mk.inj_iff, exists_prop, forall_exists_index, and_imp]\n rintro a b _ a' - rfl - h'\n simp [Fin.val_eq_val, *] at * <;> assumption", "start": [ 45, 1 ], "end": [ 50, 49 ], "kind": "commanddeclaration" }, { "full_name": "Corners.noAccidental", "code": "private lemma noAccidental (hs : IsCornerFree (A : Set (G × G))) :\n NoAccidental (triangleIndices A) where\n eq_or_eq_or_eq a a' b b' c c' ha hb hc := by\n simp only [mk_mem_triangleIndices] at ha hb hc\n exact .inl $ hs ⟨hc.1, hb.1, ha.1, hb.2.symm.trans ha.2⟩", "start": [ 52, 1 ], "end": [ 56, 61 ], "kind": "lemma" }, { "full_name": "Corners.farFromTriangleFree_graph", "code": "private lemma farFromTriangleFree_graph [DecidableEq G] (hε : ε * card G ^ 2 ≤ A.card) :\n (graph <| triangleIndices A).FarFromTriangleFree (ε / 9) := by\n refine farFromTriangleFree _ ?_\n simp_rw [card_triangleIndices, mul_comm_div, Nat.cast_pow, Nat.cast_add]\n ring_nf\n simpa only [mul_comm] using hε", "start": [ 58, 1 ], "end": [ 63, 33 ], "kind": "lemma" }, { "full_name": "cornersTheoremBound", "code": "noncomputable def cornersTheoremBound (ε : ℝ) : ℕ := ⌊(triangleRemovalBound (ε / 9) * 27)⁻¹⌋₊ + 1", "start": [ 70, 1 ], "end": [ 74, 98 ], "kind": "commanddeclaration" }, { "full_name": "corners_theorem", "code": "theorem corners_theorem (ε : ℝ) (hε : 0 < ε) (hG : cornersTheoremBound ε ≤ card G)\n (A : Finset (G × G)) (hAε : ε * card G ^ 2 ≤ A.card) : ¬ IsCornerFree (A : Set (G × G))", "start": [ 76, 1 ], "end": [ 96, 15 ], "kind": "commanddeclaration" }, { "full_name": "corners_theorem_nat", "code": "theorem corners_theorem_nat (hε : 0 < ε) (hn : cornersTheoremBound (ε / 9) ≤ n)\n (A : Finset (ℕ × ℕ)) (hAn : A ⊆ range n ×ˢ range n) (hAε : ε * n ^ 2 ≤ A.card) :\n ¬ IsCornerFree (A : Set (ℕ × ℕ))", "start": [ 98, 1 ], "end": [ 133, 41 ], "kind": "commanddeclaration" }, { "full_name": "roth_3ap_theorem", "code": "theorem roth_3ap_theorem (ε : ℝ) (hε : 0 < ε) (hG : cornersTheoremBound ε ≤ card G)\n (A : Finset G) (hAε : ε * card G ≤ A.card) : ¬ ThreeAPFree (A : Set G)", "start": [ 135, 1 ], "end": [ 158, 41 ], "kind": "commanddeclaration" }, { "full_name": "roth_3ap_theorem_nat", "code": "theorem roth_3ap_theorem_nat (ε : ℝ) (hε : 0 < ε) (hG : cornersTheoremBound (ε / 3) ≤ n)\n (A : Finset ℕ) (hAn : A ⊆ range n) (hAε : ε * n ≤ A.card) : ¬ ThreeAPFree (A : Set ℕ)", "start": [ 160, 1 ], "end": [ 189, 20 ], "kind": "commanddeclaration" }, { "full_name": "rothNumberNat_isLittleO_id", "code": "theorem rothNumberNat_isLittleO_id :\n IsLittleO atTop (fun N ↦ (rothNumberNat N : ℝ)) (fun N ↦ (N : ℝ))", "start": [ 193, 1 ], "end": [ 202, 64 ], "kind": "commanddeclaration" } ]

[ ".lake/packages/lean4/src/lean/Init.lean", "Mathlib/Algebra/Group/Action/Defs.lean" ]

[ { "full_name": "Option.smul_def", "code": "@[to_additive]\ntheorem smul_def : a • x = x.map (a • ·)", "start": [ 37, 1 ], "end": [ 39, 6 ], "kind": "commanddeclaration" }, { "full_name": "Option.smul_none", "code": "@[to_additive (attr := simp)]\ntheorem smul_none : a • (none : Option α) = none", "start": [ 43, 1 ], "end": [ 45, 6 ], "kind": "commanddeclaration" }, { "full_name": "Option.smul_some", "code": "@[to_additive (attr := simp)]\ntheorem smul_some : a • some b = some (a • b)", "start": [ 49, 1 ], "end": [ 51, 6 ], "kind": "commanddeclaration" }, { "full_name": "Option.instIsScalarTowerOfSMul", "code": "@[to_additive]\ninstance instIsScalarTowerOfSMul [SMul M N] [IsScalarTower M N α] : IsScalarTower M N (Option α) :=\n ⟨fun a b x => by\n cases x\n exacts [rfl, congr_arg some (smul_assoc _ _ _)]⟩", "start": [ 55, 1 ], "end": [ 59, 53 ], "kind": "commanddeclaration" } ]

[ ".lake/packages/lean4/src/lean/Init.lean", "Mathlib/CategoryTheory/Sites/LocallyBijective.lean", "Mathlib/CategoryTheory/MorphismProperty/Concrete.lean" ]

[ { "full_name": "CategoryTheory.Sheaf.locallyInjective", "code": "def locallyInjective : MorphismProperty (Sheaf J A) :=\n fun _ _ f => IsLocallyInjective f", "start": [ 39, 1 ], "end": [ 41, 37 ], "kind": "commanddeclaration" }, { "full_name": "CategoryTheory.Sheaf.locallySurjective", "code": "def locallySurjective : MorphismProperty (Sheaf J A) :=\n fun _ _ f => IsLocallySurjective f", "start": [ 43, 1 ], "end": [ 45, 38 ], "kind": "commanddeclaration" }, { "full_name": "CategoryTheory.Sheaf.functorialLocallySurjectiveInjectiveFactorization", "code": "noncomputable def functorialLocallySurjectiveInjectiveFactorization :\n (locallySurjective J A).FunctorialFactorizationData (locallyInjective J A) where\n Z := (sheafToPresheaf J A).mapArrow ⋙ (data.functorCategory Cᵒᵖ).Z ⋙ presheafToSheaf J A\n i := whiskerLeft Arrow.leftFunc (inv (sheafificationAdjunction J A).counit) ≫\n whiskerLeft (sheafToPresheaf J A).mapArrow\n (whiskerRight (data.functorCategory Cᵒᵖ).i (presheafToSheaf J A))\n p := whiskerLeft (sheafToPresheaf J A).mapArrow\n (whiskerRight (data.functorCategory Cᵒᵖ).p (presheafToSheaf J A)) ≫\n whiskerLeft Arrow.rightFunc (sheafificationAdjunction J A).counit\n fac := by\n ext f : 2\n dsimp\n simp only [assoc, ← Functor.map_comp_assoc,\n MorphismProperty.FunctorialFactorizationData.fac_app,\n NatIso.isIso_inv_app, IsIso.inv_comp_eq]\n exact (sheafificationAdjunction J A).counit.naturality f.hom\n hi _ := by\n dsimp [locallySurjective]\n rw [← isLocallySurjective_sheafToPresheaf_map_iff, Functor.map_comp,\n Presheaf.comp_isLocallySurjective_iff, isLocallySurjective_sheafToPresheaf_map_iff,\n Presheaf.isLocallySurjective_presheafToSheaf_map_iff]\n apply Presheaf.isLocallySurjective_of_surjective\n apply (data.functorCategory Cᵒᵖ).hi\n hp _ := by\n dsimp [locallyInjective]\n rw [← isLocallyInjective_sheafToPresheaf_map_iff, Functor.map_comp,\n Presheaf.isLocallyInjective_comp_iff, isLocallyInjective_sheafToPresheaf_map_iff,\n Presheaf.isLocallyInjective_presheafToSheaf_map_iff]\n apply Presheaf.isLocallyInjective_of_injective\n apply (data.functorCategory Cᵒᵖ).hp", "start": [ 52, 1 ], "end": [ 84, 40 ], "kind": "commanddeclaration" }, { "full_name": "CategoryTheory.Sheaf.isLocallySurjective_iff_epi'", "code": "lemma isLocallySurjective_iff_epi' :\n IsLocallySurjective φ ↔ Epi φ := by\n constructor\n · intro\n infer_instance\n · intro\n let data := (locallySurjective J A).factorizationData (locallyInjective J A) φ\n have : IsLocallySurjective data.i := data.hi\n have : IsLocallyInjective data.p := data.hp\n have : Epi data.p := epi_of_epi_fac data.fac\n have := mono_of_isLocallyInjective data.p\n have := isIso_of_mono_of_epi data.p\n rw [← data.fac]\n infer_instance", "start": [ 121, 1 ], "end": [ 134, 19 ], "kind": "lemma" } ]

[ "Mathlib/FieldTheory/PolynomialGaloisGroup.lean", "Mathlib/GroupTheory/Solvable.lean", ".lake/packages/lean4/src/lean/Init.lean", "Mathlib/RingTheory/RootsOfUnity/Basic.lean" ]

[ { "full_name": "gal_zero_isSolvable", "code": "theorem gal_zero_isSolvable : IsSolvable (0 : F[X]).Gal", "start": [ 39, 1 ], "end": [ 39, 77 ], "kind": "commanddeclaration" }, { "full_name": "gal_one_isSolvable", "code": "theorem gal_one_isSolvable : IsSolvable (1 : F[X]).Gal", "start": [ 42, 1 ], "end": [ 42, 76 ], "kind": "commanddeclaration" }, { "full_name": "gal_C_isSolvable", "code": "theorem gal_C_isSolvable (x : F) : IsSolvable (C x).Gal", "start": [ 45, 1 ], "end": [ 45, 77 ], "kind": "commanddeclaration" }, { "full_name": "gal_X_isSolvable", "code": "theorem gal_X_isSolvable : IsSolvable (X : F[X]).Gal", "start": [ 49, 1 ], "end": [ 49, 74 ], "kind": "commanddeclaration" }, { "full_name": "gal_X_sub_C_isSolvable", "code": "theorem gal_X_sub_C_isSolvable (x : F) : IsSolvable (X - C x).Gal", "start": [ 53, 1 ], "end": [ 53, 87 ], "kind": "commanddeclaration" }, { "full_name": "gal_X_pow_isSolvable", "code": "theorem gal_X_pow_isSolvable (n : ℕ) : IsSolvable (X ^ n : F[X]).Gal", "start": [ 57, 1 ], "end": [ 57, 90 ], "kind": "commanddeclaration" }, { "full_name": "gal_mul_isSolvable", "code": "theorem gal_mul_isSolvable {p q : F[X]} (_ : IsSolvable p.Gal) (_ : IsSolvable q.Gal) :\n IsSolvable (p * q).Gal", "start": [ 61, 1 ], "end": [ 63, 66 ], "kind": "commanddeclaration" }, { "full_name": "gal_prod_isSolvable", "code": "theorem gal_prod_isSolvable {s : Multiset F[X]} (hs : ∀ p ∈ s, IsSolvable (Gal p)) :\n IsSolvable s.prod.Gal", "start": [ 66, 1 ], "end": [ 72, 43 ], "kind": "commanddeclaration" }, { "full_name": "gal_isSolvable_of_splits", "code": "theorem gal_isSolvable_of_splits {p q : F[X]}\n (_ : Fact (p.Splits (algebraMap F q.SplittingField))) (hq : IsSolvable q.Gal) :\n IsSolvable p.Gal", "start": [ 75, 1 ], "end": [ 79, 82 ], "kind": "commanddeclaration" }, { "full_name": "gal_isSolvable_tower", "code": "theorem gal_isSolvable_tower (p q : F[X]) (hpq : p.Splits (algebraMap F q.SplittingField))\n (hp : IsSolvable p.Gal) (hq : IsSolvable (q.map (algebraMap F p.SplittingField)).Gal) :\n IsSolvable q.Gal", "start": [ 82, 1 ], "end": [ 93, 72 ], "kind": "commanddeclaration" }, { "full_name": "gal_X_pow_sub_one_isSolvable", "code": "theorem gal_X_pow_sub_one_isSolvable (n : ℕ) : IsSolvable (X ^ n - 1 : F[X]).Gal", "start": [ 98, 1 ], "end": [ 114, 83 ], "kind": "commanddeclaration" }, { "full_name": "gal_X_pow_sub_C_isSolvable_aux", "code": "theorem gal_X_pow_sub_C_isSolvable_aux (n : ℕ) (a : F)\n (h : (X ^ n - 1 : F[X]).Splits (RingHom.id F)) : IsSolvable (X ^ n - C a).Gal", "start": [ 118, 1 ], "end": [ 153, 56 ], "kind": "commanddeclaration" }, { "full_name": "splits_X_pow_sub_one_of_X_pow_sub_C", "code": "theorem splits_X_pow_sub_one_of_X_pow_sub_C {F : Type*} [Field F] {E : Type*} [Field E]\n (i : F →+* E) (n : ℕ) {a : F} (ha : a ≠ 0) (h : (X ^ n - C a).Splits i) :\n (X ^ n - 1 : F[X]).Splits i", "start": [ 157, 1 ], "end": [ 194, 6 ], "kind": "commanddeclaration" }, { "full_name": "gal_X_pow_sub_C_isSolvable", "code": "theorem gal_X_pow_sub_C_isSolvable (n : ℕ) (x : F) : IsSolvable (X ^ n - C x).Gal", "start": [ 198, 1 ], "end": [ 209, 33 ], "kind": "commanddeclaration" }, { "full_name": "IsSolvableByRad", "code": "inductive IsSolvableByRad : E → Prop\n | base (α : F) : IsSolvableByRad (algebraMap F E α)\n | add (α β : E) : IsSolvableByRad α → IsSolvableByRad β → IsSolvableByRad (α + β)\n | neg (α : E) : IsSolvableByRad α → IsSolvableByRad (-α)\n | mul (α β : E) : IsSolvableByRad α → IsSolvableByRad β → IsSolvableByRad (α * β)\n | inv (α : E) : IsSolvableByRad α → IsSolvableByRad α⁻¹\n | rad (α : E) (n : ℕ) (hn : n ≠ 0) : IsSolvableByRad (α ^ n) → IsSolvableByRad α", "start": [ 217, 1 ], "end": [ 224, 83 ], "kind": "commanddeclaration" }, { "full_name": "solvableByRad", "code": "def solvableByRad : IntermediateField F E where\n carrier := IsSolvableByRad F\n zero_mem' := by\n change IsSolvableByRad F 0\n convert IsSolvableByRad.base (E := E) (0 : F); rw [RingHom.map_zero]\n add_mem' := by apply IsSolvableByRad.add\n one_mem' := by\n change IsSolvableByRad F 1\n convert IsSolvableByRad.base (E := E) (1 : F); rw [RingHom.map_one]\n mul_mem' := by apply IsSolvableByRad.mul\n inv_mem' := IsSolvableByRad.inv\n algebraMap_mem' := IsSolvableByRad.base", "start": [ 229, 1 ], "end": [ 241, 42 ], "kind": "commanddeclaration" }, { "full_name": "solvableByRad.induction", "code": "theorem induction (P : solvableByRad F E → Prop)\n (base : ∀ α : F, P (algebraMap F (solvableByRad F E) α))\n (add : ∀ α β : solvableByRad F E, P α → P β → P (α + β))\n (neg : ∀ α : solvableByRad F E, P α → P (-α))\n (mul : ∀ α β : solvableByRad F E, P α → P β → P (α * β))\n (inv : ∀ α : solvableByRad F E, P α → P α⁻¹)\n (rad : ∀ α : solvableByRad F E, ∀ n : ℕ, n ≠ 0 → P (α ^ n) → P α) (α : solvableByRad F E) :\n P α", "start": [ 248, 1 ], "end": [ 280, 76 ], "kind": "commanddeclaration" }, { "full_name": "solvableByRad.isIntegral", "code": "theorem isIntegral (α : solvableByRad F E) : IsIntegral F α", "start": [ 283, 1 ], "end": [ 298, 26 ], "kind": "commanddeclaration" }, { "full_name": "solvableByRad.P", "code": "def P (α : solvableByRad F E) : Prop :=\n IsSolvable (minpoly F α).Gal", "start": [ 301, 1 ], "end": [ 303, 31 ], "kind": "commanddeclaration" }, { "full_name": "solvableByRad.induction3", "code": "theorem induction3 {α : solvableByRad F E} {n : ℕ} (hn : n ≠ 0) (hα : P (α ^ n)) : P α", "start": [ 307, 1 ], "end": [ 331, 43 ], "kind": "commanddeclaration" }, { "full_name": "solvableByRad.induction2", "code": "theorem induction2 {α β γ : solvableByRad F E} (hγ : γ ∈ F⟮α, β⟯) (hα : P α) (hβ : P β) : P γ", "start": [ 334, 1 ], "end": [ 362, 34 ], "kind": "commanddeclaration" }, { "full_name": "solvableByRad.induction1", "code": "theorem induction1 {α β : solvableByRad F E} (hβ : β ∈ F⟮α⟯) (hα : P α) : P β", "start": [ 365, 1 ], "end": [ 367, 79 ], "kind": "commanddeclaration" }, { "full_name": "solvableByRad.isSolvable", "code": "theorem isSolvable (α : solvableByRad F E) : IsSolvable (minpoly F α).Gal", "start": [ 370, 1 ], "end": [ 380, 32 ], "kind": "commanddeclaration" }, { "full_name": "solvableByRad.isSolvable'", "code": "theorem isSolvable' {α : E} {q : F[X]} (q_irred : Irreducible q) (q_aeval : aeval α q = 0)\n (hα : IsSolvableByRad F α) : IsSolvable q.Gal", "start": [ 383, 1 ], "end": [ 394, 68 ], "kind": "commanddeclaration" } ]

[ "Mathlib/Algebra/Category/Grp/ZModuleEquivalence.lean", "Mathlib/Algebra/Category/Grp/EnoughInjectives.lean", "Mathlib/Algebra/Category/ModuleCat/ChangeOfRings.lean", "Mathlib/Logic/Equiv/TransferInstance.lean", ".lake/packages/lean4/src/lean/Init.lean" ]

[ { "full_name": "ModuleCat.enoughInjectives", "code": "lemma ModuleCat.enoughInjectives : EnoughInjectives (ModuleCat.{max v u} R) :=\n EnoughInjectives.of_adjunction (ModuleCat.restrictCoextendScalarsAdj.{max v u} (algebraMap ℤ R))", "start": [ 31, 1 ], "end": [ 32, 99 ], "kind": "lemma" } ]

[ "Mathlib/Control/EquivFunctor.lean", ".lake/packages/lean4/src/lean/Init.lean", "Mathlib/CategoryTheory/Groupoid.lean", "Mathlib/CategoryTheory/Whiskering.lean", "Mathlib/CategoryTheory/Types.lean" ]

[ { "full_name": "CategoryTheory.Core", "code": "def Core (C : Type u₁) := C", "start": [ 31, 1 ], "end": [ 36, 28 ], "kind": "commanddeclaration" }, { "full_name": "CategoryTheory.coreCategory", "code": "instance coreCategory : Groupoid.{v₁} (Core C) where\n Hom (X Y : C) := X ≅ Y\n id (X : C) := Iso.refl X\n comp f g := Iso.trans f g\n inv {X Y} f := Iso.symm f", "start": [ 41, 1 ], "end": [ 45, 28 ], "kind": "commanddeclaration" }, { "full_name": "CategoryTheory.Core.id_hom", "code": "@[simp]\n\ntheorem id_hom (X : C) : Iso.hom (coreCategory.id X) = @CategoryStruct.id C _ X", "start": [ 50, 1 ], "end": [ 53, 6 ], "kind": "commanddeclaration" }, { "full_name": "CategoryTheory.Core.comp_hom", "code": "@[simp]\ntheorem comp_hom {X Y Z : Core C} (f : X ⟶ Y) (g : Y ⟶ Z) : (f ≫ g).hom = f.hom ≫ g.hom", "start": [ 56, 1 ], "end": [ 58, 6 ], "kind": "commanddeclaration" }, { "full_name": "CategoryTheory.Core.inclusion", "code": "def inclusion : Core C ⥤ C where\n obj := id\n map f := f.hom", "start": [ 63, 1 ], "end": [ 66, 17 ], "kind": "commanddeclaration" }, { "full_name": "CategoryTheory.Core.functorToCore", "code": "def functorToCore (F : G ⥤ C) : G ⥤ Core C where\n obj X := F.obj X\n map f := ⟨F.map f, F.map (Groupoid.inv f), _, _⟩", "start": [ 79, 1 ], "end": [ 82, 51 ], "kind": "commanddeclaration" }, { "full_name": "CategoryTheory.Core.forgetFunctorToCore", "code": "def forgetFunctorToCore : (G ⥤ Core C) ⥤ G ⥤ C :=\n (whiskeringRight _ _ _).obj (inclusion C)", "start": [ 85, 1 ], "end": [ 89, 44 ], "kind": "commanddeclaration" }, { "full_name": "CategoryTheory.ofEquivFunctor", "code": "def ofEquivFunctor (m : Type u₁ → Type u₂) [EquivFunctor m] : Core (Type u₁) ⥤ Core (Type u₂) where\n obj := m\n map f := (EquivFunctor.mapEquiv m f.toEquiv).toIso\n map_id α := by apply Iso.ext; funext x; exact congr_fun (EquivFunctor.map_refl' _) x\n map_comp f g := by\n apply Iso.ext; funext x; dsimp\n erw [Iso.toEquiv_comp, EquivFunctor.map_trans']\n rw [Function.comp]", "start": [ 94, 1 ], "end": [ 104, 23 ], "kind": "commanddeclaration" } ]

[ ".lake/packages/lean4/src/lean/Init.lean", "Mathlib/MeasureTheory/Measure/Typeclasses.lean" ]

[ { "full_name": "MeasureTheory.hahn_decomposition", "code": "theorem hahn_decomposition [IsFiniteMeasure μ] [IsFiniteMeasure ν] :\n ∃ s,\n MeasurableSet s ∧\n (∀ t, MeasurableSet t → t ⊆ s → ν t ≤ μ t) ∧ ∀ t, MeasurableSet t → t ⊆ sᶜ → μ t ≤ ν t", "start": [ 36, 1 ], "end": [ 176, 59 ], "kind": "commanddeclaration" } ]

[ "Mathlib/Analysis/Complex/CauchyIntegral.lean", ".lake/packages/lean4/src/lean/Init.lean" ]

[ { "full_name": "Complex.hasSum_taylorSeries_on_ball", "code": "lemma hasSum_taylorSeries_on_ball :\n HasSum (fun n : ℕ ↦ (n ! : ℂ)⁻¹ • (z - c) ^ n • iteratedDeriv n f c) (f z) := by\n obtain ⟨r', hr', hr'₀, hzr'⟩ : ∃ r' < r, 0 < r' ∧ z ∈ Metric.ball c r' := by\n obtain ⟨r', h₁, h₂⟩ := exists_between (Metric.mem_ball'.mp hz)\n exact ⟨r', h₂, Metric.pos_of_mem_ball h₁, Metric.mem_ball'.mpr h₁⟩\n lift r' to NNReal using hr'₀.le\n have hz' : z - c ∈ EMetric.ball 0 r' := by\n rw [Metric.emetric_ball_nnreal]\n exact mem_ball_zero_iff.mpr hzr'\n have H := (hf.mono <| Metric.closedBall_subset_ball hr').hasFPowerSeriesOnBall hr'₀\n |>.hasSum_iteratedFDeriv hz'\n simp only [add_sub_cancel] at H\n convert H using 4 with n\n simpa only [iteratedDeriv_eq_iteratedFDeriv, smul_eq_mul, mul_one, Finset.prod_const,\n Finset.card_fin]\n using ((iteratedFDeriv ℂ n f c).map_smul_univ (fun _ ↦ z - c) (fun _ ↦ 1)).symm", "start": [ 38, 1 ], "end": [ 55, 84 ], "kind": "lemma" }, { "full_name": "Complex.taylorSeries_eq_on_ball", "code": "lemma taylorSeries_eq_on_ball :\n ∑' n : ℕ, (n ! : ℂ)⁻¹ • (z - c) ^ n • iteratedDeriv n f c = f z :=\n (hasSum_taylorSeries_on_ball hf hz).tsum_eq", "start": [ 57, 1 ], "end": [ 61, 46 ], "kind": "lemma" }, { "full_name": "Complex.taylorSeries_eq_on_ball'", "code": "lemma taylorSeries_eq_on_ball' {f : ℂ → ℂ} (hf : DifferentiableOn ℂ f (Metric.ball c r)) :\n ∑' n : ℕ, (n ! : ℂ)⁻¹ * iteratedDeriv n f c * (z - c) ^ n = f z := by\n convert taylorSeries_eq_on_ball hf hz using 3 with n\n rw [mul_right_comm, smul_eq_mul, smul_eq_mul, mul_assoc]", "start": [ 63, 1 ], "end": [ 68, 59 ], "kind": "lemma" }, { "full_name": "Complex.hasSum_taylorSeries_on_emetric_ball", "code": "lemma hasSum_taylorSeries_on_emetric_ball :\n HasSum (fun n : ℕ ↦ (n ! : ℂ)⁻¹ • (z - c) ^ n • iteratedDeriv n f c) (f z) := by\n obtain ⟨r', hzr', hr'⟩ := exists_between (EMetric.mem_ball'.mp hz)\n lift r' to NNReal using ne_top_of_lt hr'\n rw [← EMetric.mem_ball', Metric.emetric_ball_nnreal] at hzr'\n refine hasSum_taylorSeries_on_ball ?_ hzr'\n rw [← Metric.emetric_ball_nnreal]\n exact hf.mono <| EMetric.ball_subset_ball hr'.le", "start": [ 77, 1 ], "end": [ 86, 51 ], "kind": "lemma" }, { "full_name": "Complex.taylorSeries_eq_on_emetric_ball", "code": "lemma taylorSeries_eq_on_emetric_ball :\n ∑' n : ℕ, (n ! : ℂ)⁻¹ • (z - c) ^ n • iteratedDeriv n f c = f z :=\n (hasSum_taylorSeries_on_emetric_ball hf hz).tsum_eq", "start": [ 88, 1 ], "end": [ 92, 54 ], "kind": "lemma" }, { "full_name": "Complex.taylorSeries_eq_on_emetric_ball'", "code": "lemma taylorSeries_eq_on_emetric_ball' {f : ℂ → ℂ} (hf : DifferentiableOn ℂ f (EMetric.ball c r)) :\n ∑' n : ℕ, (n ! : ℂ)⁻¹ * iteratedDeriv n f c * (z - c) ^ n = f z := by\n convert taylorSeries_eq_on_emetric_ball hf hz using 3 with n\n rw [mul_right_comm, smul_eq_mul, smul_eq_mul, mul_assoc]", "start": [ 94, 1 ], "end": [ 99, 59 ], "kind": "lemma" }, { "full_name": "Complex.hasSum_taylorSeries_of_entire", "code": "lemma hasSum_taylorSeries_of_entire :\n HasSum (fun n : ℕ ↦ (n ! : ℂ)⁻¹ • (z - c) ^ n • iteratedDeriv n f c) (f z) :=\n hasSum_taylorSeries_on_emetric_ball hf.differentiableOn <| EMetric.mem_ball.mpr <|\n edist_lt_top ..", "start": [ 107, 1 ], "end": [ 112, 20 ], "kind": "lemma" }, { "full_name": "Complex.taylorSeries_eq_of_entire", "code": "lemma taylorSeries_eq_of_entire :\n ∑' n : ℕ, (n ! : ℂ)⁻¹ • (z - c) ^ n • iteratedDeriv n f c = f z :=\n (hasSum_taylorSeries_of_entire hf c z).tsum_eq", "start": [ 114, 1 ], "end": [ 118, 49 ], "kind": "lemma" }, { "full_name": "Complex.taylorSeries_eq_of_entire'", "code": "lemma taylorSeries_eq_of_entire' {f : ℂ → ℂ} (hf : Differentiable ℂ f) :\n ∑' n : ℕ, (n ! : ℂ)⁻¹ * iteratedDeriv n f c * (z - c) ^ n = f z := by\n convert taylorSeries_eq_of_entire hf c z using 3 with n\n rw [mul_right_comm, smul_eq_mul, smul_eq_mul, mul_assoc]", "start": [ 120, 1 ], "end": [ 125, 59 ], "kind": "lemma" } ]

[ ".lake/packages/lean4/src/lean/Init.lean", "Mathlib/CategoryTheory/Limits/Types.lean", "Mathlib/CategoryTheory/Limits/FunctorCategory.lean" ]

[ { "full_name": "CategoryTheory.FunctorToTypes.prod", "code": "def prod : C ⥤ Type w where\n obj a := F.obj a × G.obj a\n map f a := (F.map f a.1, G.map f a.2)", "start": [ 29, 1 ], "end": [ 32, 40 ], "kind": "commanddeclaration" }, { "full_name": "CategoryTheory.FunctorToTypes.prod.fst", "code": "@[simps]\ndef prod.fst : prod F G ⟶ F where\n app _ a := a.1", "start": [ 36, 3 ], "end": [ 39, 17 ], "kind": "commanddeclaration" }, { "full_name": "CategoryTheory.FunctorToTypes.prod.snd", "code": "@[simps]\ndef prod.snd : prod F G ⟶ G where\n app _ a := a.2", "start": [ 41, 1 ], "end": [ 44, 17 ], "kind": "commanddeclaration" }, { "full_name": "CategoryTheory.FunctorToTypes.prod.lift", "code": "@[simps]\ndef prod.lift {F₁ F₂ : C ⥤ Type w} (τ₁ : F ⟶ F₁) (τ₂ : F ⟶ F₂) :\n F ⟶ prod F₁ F₂ where\n app x y := ⟨τ₁.app x y, τ₂.app x y⟩\n naturality _ _ _ := by\n ext a\n simp only [types_comp_apply, FunctorToTypes.naturality]\n aesop", "start": [ 46, 1 ], "end": [ 55, 10 ], "kind": "commanddeclaration" }, { "full_name": "CategoryTheory.FunctorToTypes.prod.lift_fst", "code": "@[simp]\nlemma prod.lift_fst {F₁ F₂ : C ⥤ Type w} (τ₁ : F ⟶ F₁) (τ₂ : F ⟶ F₂) :\n prod.lift τ₁ τ₂ ≫ prod.fst = τ₁ := rfl", "start": [ 57, 1 ], "end": [ 59, 43 ], "kind": "lemma" }, { "full_name": "CategoryTheory.FunctorToTypes.prod.lift_snd", "code": "@[simp]\nlemma prod.lift_snd {F₁ F₂ : C ⥤ Type w} (τ₁ : F ⟶ F₁) (τ₂ : F ⟶ F₂) :\n prod.lift τ₁ τ₂ ≫ prod.snd = τ₂ := rfl", "start": [ 61, 1 ], "end": [ 63, 43 ], "kind": "lemma" }, { "full_name": "CategoryTheory.FunctorToTypes.binaryProductCone", "code": "@[simps!]\ndef binaryProductCone : BinaryFan F G :=\n BinaryFan.mk prod.fst prod.snd", "start": [ 67, 1 ], "end": [ 70, 33 ], "kind": "commanddeclaration" }, { "full_name": "CategoryTheory.FunctorToTypes.binaryProductLimit", "code": "@[simps]\ndef binaryProductLimit : IsLimit (binaryProductCone F G) where\n lift (s : BinaryFan F G) := prod.lift s.fst s.snd\n fac _ := fun ⟨j⟩ ↦ WalkingPair.casesOn j rfl rfl\n uniq _ _ h := by\n simp only [← h ⟨WalkingPair.right⟩, ← h ⟨WalkingPair.left⟩]\n congr", "start": [ 72, 1 ], "end": [ 79, 10 ], "kind": "commanddeclaration" }, { "full_name": "CategoryTheory.FunctorToTypes.binaryProductLimitCone", "code": "def binaryProductLimitCone : Limits.LimitCone (pair F G) :=\n ⟨_, binaryProductLimit F G⟩", "start": [ 81, 1 ], "end": [ 83, 30 ], "kind": "commanddeclaration" }, { "full_name": "CategoryTheory.FunctorToTypes.binaryProductIso", "code": "noncomputable def binaryProductIso : F ⨯ G ≅ prod F G :=\n limit.isoLimitCone (binaryProductLimitCone F G)", "start": [ 85, 1 ], "end": [ 87, 50 ], "kind": "commanddeclaration" }, { "full_name": "CategoryTheory.FunctorToTypes.binaryProductIso_hom_comp_fst", "code": "@[simp]\nlemma binaryProductIso_hom_comp_fst :\n (binaryProductIso F G).hom ≫ prod.fst = Limits.prod.fst := rfl", "start": [ 89, 1 ], "end": [ 91, 67 ], "kind": "lemma" }, { "full_name": "CategoryTheory.FunctorToTypes.binaryProductIso_hom_comp_snd", "code": "@[simp]\nlemma binaryProductIso_hom_comp_snd :\n (binaryProductIso F G).hom ≫ prod.snd = Limits.prod.snd := rfl", "start": [ 93, 1 ], "end": [ 95, 67 ], "kind": "lemma" }, { "full_name": "CategoryTheory.FunctorToTypes.binaryProductIso_inv_comp_fst", "code": "@[simp]\nlemma binaryProductIso_inv_comp_fst :\n (binaryProductIso F G).inv ≫ Limits.prod.fst = prod.fst := by\n simp [binaryProductIso, binaryProductLimitCone]", "start": [ 97, 1 ], "end": [ 100, 50 ], "kind": "lemma" }, { "full_name": "CategoryTheory.FunctorToTypes.binaryProductIso_inv_comp_fst_apply", "code": "@[simp]\nlemma binaryProductIso_inv_comp_fst_apply (a : C) (z : (prod F G).obj a) :\n (Limits.prod.fst (X := F)).app a ((binaryProductIso F G).inv.app a z) = z.1 :=\n congr_fun (congr_app (binaryProductIso_inv_comp_fst F G) a) z", "start": [ 102, 1 ], "end": [ 105, 64 ], "kind": "lemma" }, { "full_name": "CategoryTheory.FunctorToTypes.binaryProductIso_inv_comp_snd", "code": "@[simp]\nlemma binaryProductIso_inv_comp_snd :\n (binaryProductIso F G).inv ≫ Limits.prod.snd = prod.snd := by\n simp [binaryProductIso, binaryProductLimitCone]", "start": [ 107, 1 ], "end": [ 110, 50 ], "kind": "lemma" }, { "full_name": "CategoryTheory.FunctorToTypes.binaryProductIso_inv_comp_snd_apply", "code": "@[simp]\nlemma binaryProductIso_inv_comp_snd_apply (a : C) (z : (prod F G).obj a) :\n (Limits.prod.snd (X := F)).app a ((binaryProductIso F G).inv.app a z) = z.2 :=\n congr_fun (congr_app (binaryProductIso_inv_comp_snd F G) a) z", "start": [ 112, 1 ], "end": [ 115, 64 ], "kind": "lemma" }, { "full_name": "CategoryTheory.FunctorToTypes.prodMk", "code": "noncomputable\ndef prodMk {a : C} (x : F.obj a) (y : G.obj a) : (F ⨯ G).obj a :=\n ((binaryProductIso F G).inv).app a ⟨x, y⟩", "start": [ 119, 1 ], "end": [ 123, 44 ], "kind": "commanddeclaration" }, { "full_name": "CategoryTheory.FunctorToTypes.prodMk_fst", "code": "@[simp]\nlemma prodMk_fst {a : C} (x : F.obj a) (y : G.obj a) :\n (Limits.prod.fst (X := F)).app a (prodMk x y) = x := by\n simp only [prodMk, binaryProductIso_inv_comp_fst_apply]", "start": [ 125, 1 ], "end": [ 128, 58 ], "kind": "lemma" }, { "full_name": "CategoryTheory.FunctorToTypes.prodMk_snd", "code": "@[simp]\nlemma prodMk_snd {a : C} (x : F.obj a) (y : G.obj a) :\n (Limits.prod.snd (X := F)).app a (prodMk x y) = y := by\n simp only [prodMk, binaryProductIso_inv_comp_snd_apply]", "start": [ 130, 1 ], "end": [ 133, 58 ], "kind": "lemma" }, { "full_name": "CategoryTheory.FunctorToTypes.prod_ext", "code": "@[ext]\nlemma prod_ext {a : C} (z w : (prod F G).obj a) (h1 : z.1 = w.1) (h2 : z.2 = w.2) :\n z = w := Prod.ext h1 h2", "start": [ 135, 1 ], "end": [ 137, 28 ], "kind": "lemma" }, { "full_name": "CategoryTheory.FunctorToTypes.binaryProductEquiv", "code": "@[simps]\nnoncomputable\ndef binaryProductEquiv (a : C) : (F ⨯ G).obj a ≃ (F.obj a) × (G.obj a) where\n toFun z := ⟨((binaryProductIso F G).hom.app a z).1, ((binaryProductIso F G).hom.app a z).2⟩\n invFun z := prodMk z.1 z.2\n left_inv _ := by simp [prodMk]\n right_inv _ := by simp [prodMk]", "start": [ 141, 1 ], "end": [ 148, 34 ], "kind": "commanddeclaration" }, { "full_name": "CategoryTheory.FunctorToTypes.prod_ext'", "code": "@[ext]\nlemma prod_ext' (a : C) (z w : (F ⨯ G).obj a)\n (h1 : (Limits.prod.fst (X := F)).app a z = (Limits.prod.fst (X := F)).app a w)\n (h2 : (Limits.prod.snd (X := F)).app a z = (Limits.prod.snd (X := F)).app a w) :\n z = w := by\n apply Equiv.injective (binaryProductEquiv F G a)\n aesop", "start": [ 150, 1 ], "end": [ 156, 8 ], "kind": "lemma" }, { "full_name": "CategoryTheory.FunctorToTypes.coprod", "code": "def coprod : C ⥤ Type w where\n obj a := F.obj a ⊕ G.obj a\n map f x := by\n cases x with\n | inl x => exact .inl (F.map f x)\n | inr x => exact .inr (G.map f x)", "start": [ 162, 1 ], "end": [ 168, 38 ], "kind": "commanddeclaration" }, { "full_name": "CategoryTheory.FunctorToTypes.coprod.inl", "code": "@[simps]\ndef coprod.inl : F ⟶ coprod F G where\n app _ x := .inl x", "start": [ 172, 1 ], "end": [ 175, 20 ], "kind": "commanddeclaration" }, { "full_name": "CategoryTheory.FunctorToTypes.coprod.inr", "code": "@[simps]\ndef coprod.inr : G ⟶ coprod F G where\n app _ x := .inr x", "start": [ 177, 3 ], "end": [ 180, 20 ], "kind": "commanddeclaration" }, { "full_name": "CategoryTheory.FunctorToTypes.coprod.desc", "code": "@[simps]\ndef coprod.desc {F₁ F₂ : C ⥤ Type w} (τ₁ : F₁ ⟶ F) (τ₂ : F₂ ⟶ F) :\n coprod F₁ F₂ ⟶ F where\n app a x := by\n cases x with\n | inl x => exact τ₁.app a x\n | inr x => exact τ₂.app a x\n naturality _ _ _:= by\n ext x\n cases x with | _ => simp only [coprod, types_comp_apply, FunctorToTypes.naturality]", "start": [ 182, 1 ], "end": [ 193, 88 ], "kind": "commanddeclaration" }, { "full_name": "CategoryTheory.FunctorToTypes.coprod.desc_inl", "code": "@[simp]\nlemma coprod.desc_inl {F₁ F₂ : C ⥤ Type w} (τ₁ : F₁ ⟶ F) (τ₂ : F₂ ⟶ F) :\n coprod.inl ≫ coprod.desc τ₁ τ₂ = τ₁ := rfl", "start": [ 195, 1 ], "end": [ 197, 47 ], "kind": "lemma" }, { "full_name": "CategoryTheory.FunctorToTypes.coprod.desc_inr", "code": "@[simp]\nlemma coprod.desc_inr {F₁ F₂ : C ⥤ Type w} (τ₁ : F₁ ⟶ F) (τ₂ : F₂ ⟶ F) :\n coprod.inr ≫ coprod.desc τ₁ τ₂ = τ₂ := rfl", "start": [ 199, 1 ], "end": [ 201, 47 ], "kind": "lemma" }, { "full_name": "CategoryTheory.FunctorToTypes.binaryCoproductCocone", "code": "@[simps!]\ndef binaryCoproductCocone : BinaryCofan F G :=\n BinaryCofan.mk coprod.inl coprod.inr", "start": [ 205, 1 ], "end": [ 208, 39 ], "kind": "commanddeclaration" }, { "full_name": "CategoryTheory.FunctorToTypes.binaryCoproductColimit", "code": "@[simps]\ndef binaryCoproductColimit : IsColimit (binaryCoproductCocone F G) where\n desc (s : BinaryCofan F G) := coprod.desc s.inl s.inr\n fac _ := fun ⟨j⟩ ↦ WalkingPair.casesOn j rfl rfl\n uniq _ _ h := by\n ext _ x\n cases x with | _ => simp [← h ⟨WalkingPair.right⟩, ← h ⟨WalkingPair.left⟩]", "start": [ 210, 1 ], "end": [ 217, 79 ], "kind": "commanddeclaration" }, { "full_name": "CategoryTheory.FunctorToTypes.binaryCoproductColimitCocone", "code": "def binaryCoproductColimitCocone : Limits.ColimitCocone (pair F G) :=\n ⟨_, binaryCoproductColimit F G⟩", "start": [ 219, 1 ], "end": [ 221, 34 ], "kind": "commanddeclaration" }, { "full_name": "CategoryTheory.FunctorToTypes.binaryCoproductIso", "code": "noncomputable def binaryCoproductIso : F ⨿ G ≅ coprod F G :=\n colimit.isoColimitCocone (binaryCoproductColimitCocone F G)", "start": [ 223, 1 ], "end": [ 225, 62 ], "kind": "commanddeclaration" }, { "full_name": "CategoryTheory.FunctorToTypes.inl_comp_binaryCoproductIso_hom", "code": "@[simp]\nlemma inl_comp_binaryCoproductIso_hom :\n Limits.coprod.inl ≫ (binaryCoproductIso F G).hom = coprod.inl := by\n simp only [binaryCoproductIso]\n aesop", "start": [ 227, 1 ], "end": [ 231, 8 ], "kind": "lemma" }, { "full_name": "CategoryTheory.FunctorToTypes.inl_comp_binaryCoproductIso_hom_apply", "code": "@[simp]\nlemma inl_comp_binaryCoproductIso_hom_apply (a : C) (x : F.obj a) :\n (binaryCoproductIso F G).hom.app a ((Limits.coprod.inl (X := F)).app a x) = .inl x :=\n congr_fun (congr_app (inl_comp_binaryCoproductIso_hom F G) a) x", "start": [ 233, 1 ], "end": [ 236, 66 ], "kind": "lemma" }, { "full_name": "CategoryTheory.FunctorToTypes.inr_comp_binaryCoproductIso_hom", "code": "@[simp]\nlemma inr_comp_binaryCoproductIso_hom :\n Limits.coprod.inr ≫ (binaryCoproductIso F G).hom = coprod.inr := by\n simp [binaryCoproductIso]\n aesop", "start": [ 238, 1 ], "end": [ 242, 8 ], "kind": "lemma" }, { "full_name": "CategoryTheory.FunctorToTypes.inr_comp_binaryCoproductIso_hom_apply", "code": "@[simp]\nlemma inr_comp_binaryCoproductIso_hom_apply (a : C) (x : G.obj a) :\n (binaryCoproductIso F G).hom.app a ((Limits.coprod.inr (X := F)).app a x) = .inr x :=\n congr_fun (congr_app (inr_comp_binaryCoproductIso_hom F G) a) x", "start": [ 244, 1 ], "end": [ 247, 66 ], "kind": "lemma" }, { "full_name": "CategoryTheory.FunctorToTypes.inl_comp_binaryCoproductIso_inv", "code": "@[simp]\nlemma inl_comp_binaryCoproductIso_inv :\n coprod.inl ≫ (binaryCoproductIso F G).inv = (Limits.coprod.inl (X := F)) := rfl", "start": [ 249, 1 ], "end": [ 251, 84 ], "kind": "lemma" }, { "full_name": "CategoryTheory.FunctorToTypes.inl_comp_binaryCoproductIso_inv_apply", "code": "@[simp]\nlemma inl_comp_binaryCoproductIso_inv_apply (a : C) (x : F.obj a) :\n (binaryCoproductIso F G).inv.app a (.inl x) = (Limits.coprod.inl (X := F)).app a x := rfl", "start": [ 253, 1 ], "end": [ 255, 94 ], "kind": "lemma" }, { "full_name": "CategoryTheory.FunctorToTypes.inr_comp_binaryCoproductIso_inv", "code": "@[simp]\nlemma inr_comp_binaryCoproductIso_inv :\n coprod.inr ≫ (binaryCoproductIso F G).inv = (Limits.coprod.inr (X := F)) := rfl", "start": [ 257, 1 ], "end": [ 259, 84 ], "kind": "lemma" }, { "full_name": "CategoryTheory.FunctorToTypes.inr_comp_binaryCoproductIso_inv_apply", "code": "@[simp]\nlemma inr_comp_binaryCoproductIso_inv_apply (a : C) (x : G.obj a) :\n (binaryCoproductIso F G).inv.app a (.inr x) = (Limits.coprod.inr (X := F)).app a x := rfl", "start": [ 261, 1 ], "end": [ 263, 94 ], "kind": "lemma" }, { "full_name": "CategoryTheory.FunctorToTypes.coprodInl", "code": "noncomputable\nabbrev coprodInl {a : C} (x : F.obj a) : (F ⨿ G).obj a :=\n (binaryCoproductIso F G).inv.app a (.inl x)", "start": [ 267, 1 ], "end": [ 270, 46 ], "kind": "commanddeclaration" }, { "full_name": "CategoryTheory.FunctorToTypes.coprodInr", "code": "noncomputable\nabbrev coprodInr {a : C} (x : G.obj a) : (F ⨿ G).obj a :=\n (binaryCoproductIso F G).inv.app a (.inr x)", "start": [ 272, 1 ], "end": [ 275, 46 ], "kind": "commanddeclaration" }, { "full_name": "CategoryTheory.FunctorToTypes.binaryCoproductEquiv", "code": "@[simps]\nnoncomputable\ndef binaryCoproductEquiv (a : C) :\n (F ⨿ G).obj a ≃ (F.obj a) ⊕ (G.obj a) where\n toFun z := (binaryCoproductIso F G).hom.app a z\n invFun z := (binaryCoproductIso F G).inv.app a z\n left_inv _ := by simp only [hom_inv_id_app_apply]\n right_inv _ := by simp only [inv_hom_id_app_apply]", "start": [ 279, 1 ], "end": [ 287, 53 ], "kind": "commanddeclaration" } ]

[ "Mathlib/Order/RelSeries.lean", ".lake/packages/lean4/src/lean/Init.lean", "Mathlib/Order/WithBot.lean", "Mathlib/Data/Nat/Lattice.lean" ]

[ { "full_name": "krullDim", "code": "noncomputable def krullDim : WithBot (WithTop ℕ) :=\n ⨆ (p : LTSeries α), p.length", "start": [ 37, 1 ], "end": [ 44, 31 ], "kind": "commanddeclaration" }, { "full_name": "height", "code": "noncomputable def height (a : α) : WithBot (WithTop ℕ) := krullDim (Set.Iic a)", "start": [ 46, 1 ], "end": [ 49, 79 ], "kind": "commanddeclaration" }, { "full_name": "coheight", "code": "noncomputable def coheight (a : α) : WithBot (WithTop ℕ) := krullDim (Set.Ici a)", "start": [ 51, 1 ], "end": [ 54, 81 ], "kind": "commanddeclaration" }, { "full_name": "krullDim_nonneg_of_nonempty", "code": "lemma krullDim_nonneg_of_nonempty [Nonempty α] : 0 ≤ krullDim α :=\n le_sSup ⟨⟨0, fun _ ↦ @Nonempty.some α inferInstance, fun f ↦ f.elim0⟩, rfl⟩", "start": [ 64, 1 ], "end": [ 65, 78 ], "kind": "lemma" }, { "full_name": "krullDim_eq_bot_of_isEmpty", "code": "lemma krullDim_eq_bot_of_isEmpty [IsEmpty α] : krullDim α = ⊥ := WithBot.ciSup_empty _", "start": [ 67, 1 ], "end": [ 67, 87 ], "kind": "lemma" }, { "full_name": "krullDim_eq_top_of_infiniteDimensionalOrder", "code": "lemma krullDim_eq_top_of_infiniteDimensionalOrder [InfiniteDimensionalOrder α] :\n krullDim α = ⊤ :=\n le_antisymm le_top <| le_iSup_iff.mpr <| fun m hm ↦ match m, hm with\n | ⊥, hm => False.elim <| by\n haveI : Inhabited α := ⟨LTSeries.withLength _ 0 0⟩\n exact not_le_of_lt (WithBot.bot_lt_coe _ : ⊥ < (0 : WithBot (WithTop ℕ))) <| hm default\n | some ⊤, _ => le_refl _\n | some (some m), hm => by\n refine (not_lt_of_le (hm (LTSeries.withLength _ (m + 1))) ?_).elim\n erw [WithBot.coe_lt_coe, WithTop.coe_lt_coe]\n simp", "start": [ 69, 1 ], "end": [ 79, 9 ], "kind": "lemma" }, { "full_name": "krullDim_le_of_strictMono", "code": "lemma krullDim_le_of_strictMono (f : α → β) (hf : StrictMono f) : krullDim α ≤ krullDim β :=\n iSup_le <| fun p ↦ le_sSup ⟨p.map f hf, rfl⟩", "start": [ 81, 1 ], "end": [ 82, 47 ], "kind": "lemma" }, { "full_name": "height_mono", "code": "lemma height_mono {a b : α} (h : a ≤ b) : height α a ≤ height α b :=\n krullDim_le_of_strictMono (fun x ↦ ⟨x, le_trans x.2 h⟩) <| fun _ _ ↦ id", "start": [ 84, 1 ], "end": [ 85, 74 ], "kind": "lemma" }, { "full_name": "krullDim_eq_length_of_finiteDimensionalOrder", "code": "lemma krullDim_eq_length_of_finiteDimensionalOrder [FiniteDimensionalOrder α] :\n krullDim α = (LTSeries.longestOf α).length :=\n le_antisymm\n (iSup_le <| fun _ ↦ WithBot.coe_le_coe.mpr <| WithTop.coe_le_coe.mpr <|\n RelSeries.length_le_length_longestOf _ _) <|\n le_iSup (fun (i : LTSeries _) ↦ (i.length : WithBot (WithTop ℕ))) <| LTSeries.longestOf _", "start": [ 87, 1 ], "end": [ 92, 94 ], "kind": "lemma" }, { "full_name": "krullDim_eq_zero_of_unique", "code": "lemma krullDim_eq_zero_of_unique [Unique α] : krullDim α = 0 := by\n rw [krullDim_eq_length_of_finiteDimensionalOrder (α := α), Nat.cast_eq_zero]\n refine (LTSeries.longestOf_len_unique (default : LTSeries α) fun q ↦ show _ ≤ 0 from ?_).symm\n by_contra r\n exact ne_of_lt (q.step ⟨0, not_le.mp r⟩) <| Subsingleton.elim _ _", "start": [ 94, 1 ], "end": [ 98, 68 ], "kind": "lemma" }, { "full_name": "krullDim_le_of_strictComono_and_surj", "code": "lemma krullDim_le_of_strictComono_and_surj\n (f : α → β) (hf : ∀ ⦃a b⦄, f a < f b → a < b) (hf' : Function.Surjective f) :\n krullDim β ≤ krullDim α :=\n iSup_le fun p ↦ le_sSup ⟨p.comap _ hf hf', rfl⟩", "start": [ 100, 1 ], "end": [ 103, 50 ], "kind": "lemma" }, { "full_name": "krullDim_eq_of_orderIso", "code": "lemma krullDim_eq_of_orderIso (f : α ≃o β) : krullDim α = krullDim β :=\n le_antisymm (krullDim_le_of_strictMono _ f.strictMono) <|\n krullDim_le_of_strictMono _ f.symm.strictMono", "start": [ 105, 1 ], "end": [ 107, 50 ], "kind": "lemma" }, { "full_name": "krullDim_eq_iSup_height", "code": "lemma krullDim_eq_iSup_height : krullDim α = ⨆ (a : α), height α a :=\n le_antisymm\n (iSup_le fun i ↦ le_iSup_of_le (i ⟨i.length, lt_add_one _⟩) <|\n le_sSup ⟨⟨_, fun m ↦ ⟨i m, i.strictMono.monotone <| show m.1 ≤ i.length by omega⟩,\n i.step⟩, rfl⟩) <|\n iSup_le fun a ↦ krullDim_le_of_strictMono Subtype.val fun _ _ h ↦ h", "start": [ 109, 1 ], "end": [ 114, 72 ], "kind": "lemma" }, { "full_name": "krullDim_orderDual", "code": "@[simp] lemma krullDim_orderDual : krullDim αᵒᵈ = krullDim α :=\n le_antisymm (iSup_le fun i ↦ le_sSup ⟨i.reverse, rfl⟩) <|\n iSup_le fun i ↦ le_sSup ⟨i.reverse, rfl⟩", "start": [ 116, 1 ], "end": [ 118, 45 ], "kind": "lemma" } ]

[ ".lake/packages/lean4/src/lean/Init.lean", "Mathlib/MeasureTheory/Measure/Typeclasses.lean", "Mathlib/MeasureTheory/Constructions/Cylinders.lean" ]

[ { "full_name": "MeasureTheory.IsProjectiveMeasureFamily", "code": "def IsProjectiveMeasureFamily (P : ∀ J : Finset ι, Measure (∀ j : J, α j)) : Prop :=\n ∀ (I J : Finset ι) (hJI : J ⊆ I),\n P J = (P I).map (fun (x : ∀ i : I, α i) (j : J) ↦ x ⟨j, hJI j.2⟩)", "start": [ 39, 1 ], "end": [ 43, 70 ], "kind": "commanddeclaration" }, { "full_name": "MeasureTheory.IsProjectiveMeasureFamily.measure_univ_eq_of_subset", "code": "lemma measure_univ_eq_of_subset (hP : IsProjectiveMeasureFamily P) (hJI : J ⊆ I) :\n P I univ = P J univ := by\n classical\n have : (univ : Set (∀ i : I, α i)) =\n (fun x : ∀ i : I, α i ↦ fun i : J ↦ x ⟨i, hJI i.2⟩) ⁻¹' (univ : Set (∀ i : J, α i)) := by\n rw [preimage_univ]\n rw [this, ← Measure.map_apply _ MeasurableSet.univ]\n · rw [hP I J hJI]\n · exact measurable_pi_lambda _ (fun _ ↦ measurable_pi_apply _)", "start": [ 49, 1 ], "end": [ 58, 65 ], "kind": "lemma" }, { "full_name": "MeasureTheory.IsProjectiveMeasureFamily.measure_univ_eq", "code": "lemma measure_univ_eq (hP : IsProjectiveMeasureFamily P) (I J : Finset ι) :\n P I univ = P J univ := by\n classical\n rw [← hP.measure_univ_eq_of_subset I.subset_union_left,\n ← hP.measure_univ_eq_of_subset (I.subset_union_right (s₂:= J))]", "start": [ 60, 1 ], "end": [ 64, 68 ], "kind": "lemma" }, { "full_name": "MeasureTheory.IsProjectiveMeasureFamily.congr_cylinder_of_subset", "code": "lemma congr_cylinder_of_subset (hP : IsProjectiveMeasureFamily P)\n {S : Set (∀ i : I, α i)} {T : Set (∀ i : J, α i)} (hT : MeasurableSet T)\n (h_eq : cylinder I S = cylinder J T) (hJI : J ⊆ I) :\n P I S = P J T := by\n cases isEmpty_or_nonempty (∀ i, α i) with\n | inl h =>\n suffices ∀ I, P I univ = 0 by\n simp only [Measure.measure_univ_eq_zero] at this\n simp [this]\n intro I\n simp only [isEmpty_pi] at h\n obtain ⟨i, hi_empty⟩ := h\n rw [measure_univ_eq hP I {i}]\n have : (univ : Set ((j : {x // x ∈ ({i} : Finset ι)}) → α j)) = ∅ := by simp [hi_empty]\n simp [this]\n | inr h =>\n have : S = (fun f : ∀ i : I, α i ↦ fun j : J ↦ f ⟨j, hJI j.prop⟩) ⁻¹' T :=\n eq_of_cylinder_eq_of_subset h_eq hJI\n rw [hP I J hJI, Measure.map_apply _ hT, this]\n exact measurable_pi_lambda _ (fun _ ↦ measurable_pi_apply _)", "start": [ 66, 1 ], "end": [ 85, 65 ], "kind": "lemma" }, { "full_name": "MeasureTheory.IsProjectiveMeasureFamily.congr_cylinder", "code": "lemma congr_cylinder (hP : IsProjectiveMeasureFamily P)\n {S : Set (∀ i : I, α i)} {T : Set (∀ i : J, α i)} (hS : MeasurableSet S) (hT : MeasurableSet T)\n (h_eq : cylinder I S = cylinder J T) :\n P I S = P J T := by\n classical\n let U := (fun f : ∀ i : (I ∪ J : Finset ι), α i\n ↦ fun j : I ↦ f ⟨j, Finset.mem_union_left J j.prop⟩) ⁻¹' S ∩\n (fun f ↦ fun j : J ↦ f ⟨j, Finset.mem_union_right I j.prop⟩) ⁻¹' T\n suffices P (I ∪ J) U = P I S ∧ P (I ∪ J) U = P J T from this.1.symm.trans this.2\n constructor\n · have h_eq_union : cylinder I S = cylinder (I ∪ J) U := by\n rw [← inter_cylinder, h_eq, inter_self]\n exact hP.congr_cylinder_of_subset hS h_eq_union.symm Finset.subset_union_left\n · have h_eq_union : cylinder J T = cylinder (I ∪ J) U := by\n rw [← inter_cylinder, h_eq, inter_self]\n exact hP.congr_cylinder_of_subset hT h_eq_union.symm Finset.subset_union_right", "start": [ 87, 1 ], "end": [ 102, 83 ], "kind": "lemma" }, { "full_name": "MeasureTheory.IsProjectiveLimit", "code": "def IsProjectiveLimit (μ : Measure (∀ i, α i))\n (P : ∀ J : Finset ι, Measure (∀ j : J, α j)) : Prop :=\n ∀ I : Finset ι, (μ.map fun x : ∀ i, α i ↦ fun i : I ↦ x i) = P I", "start": [ 106, 1 ], "end": [ 110, 67 ], "kind": "commanddeclaration" }, { "full_name": "MeasureTheory.IsProjectiveLimit.measure_cylinder", "code": "lemma measure_cylinder (h : IsProjectiveLimit μ P)\n (I : Finset ι) {s : Set (∀ i : I, α i)} (hs : MeasurableSet s) :\n μ (cylinder I s) = P I s := by\n rw [cylinder, ← Measure.map_apply _ hs, h I]\n exact measurable_pi_lambda _ (fun _ ↦ measurable_pi_apply _)", "start": [ 116, 1 ], "end": [ 120, 63 ], "kind": "lemma" }, { "full_name": "MeasureTheory.IsProjectiveLimit.measure_univ_eq", "code": "lemma measure_univ_eq (hμ : IsProjectiveLimit μ P) (I : Finset ι) :\n μ univ = P I univ := by\n rw [← cylinder_univ I, hμ.measure_cylinder _ MeasurableSet.univ]", "start": [ 122, 1 ], "end": [ 124, 67 ], "kind": "lemma" }, { "full_name": "MeasureTheory.IsProjectiveLimit.isFiniteMeasure", "code": "lemma isFiniteMeasure [∀ i, IsFiniteMeasure (P i)] (hμ : IsProjectiveLimit μ P) :\n IsFiniteMeasure μ := by\n constructor\n rw [hμ.measure_univ_eq (∅ : Finset ι)]\n exact measure_lt_top _ _", "start": [ 126, 1 ], "end": [ 130, 27 ], "kind": "lemma" }, { "full_name": "MeasureTheory.IsProjectiveLimit.isProbabilityMeasure", "code": "lemma isProbabilityMeasure [∀ i, IsProbabilityMeasure (P i)] (hμ : IsProjectiveLimit μ P) :\n IsProbabilityMeasure μ := by\n constructor\n rw [hμ.measure_univ_eq (∅ : Finset ι)]\n exact measure_univ", "start": [ 132, 1 ], "end": [ 136, 21 ], "kind": "lemma" }, { "full_name": "MeasureTheory.IsProjectiveLimit.measure_univ_unique", "code": "lemma measure_univ_unique (hμ : IsProjectiveLimit μ P) (hν : IsProjectiveLimit ν P) :\n μ univ = ν univ := by\n rw [hμ.measure_univ_eq (∅ : Finset ι), hν.measure_univ_eq (∅ : Finset ι)]", "start": [ 138, 1 ], "end": [ 140, 76 ], "kind": "lemma" }, { "full_name": "MeasureTheory.IsProjectiveLimit.unique", "code": "theorem unique [∀ i, IsFiniteMeasure (P i)]\n (hμ : IsProjectiveLimit μ P) (hν : IsProjectiveLimit ν P) :\n μ = ν", "start": [ 142, 1 ], "end": [ 150, 58 ], "kind": "commanddeclaration" } ]

[ "Mathlib/Control/EquivFunctor.lean", "Mathlib/Data/Fintype/Basic.lean", ".lake/packages/lean4/src/lean/Init.lean" ]

[ { "full_name": "EquivFunctorUnique", "code": "instance EquivFunctorUnique : EquivFunctor Unique where\n map e := Equiv.uniqueCongr e\n map_refl' α := by simp [eq_iff_true_of_subsingleton]\n map_trans' := by simp [eq_iff_true_of_subsingleton]", "start": [ 20, 1 ], "end": [ 23, 54 ], "kind": "commanddeclaration" }, { "full_name": "EquivFunctorPerm", "code": "instance EquivFunctorPerm : EquivFunctor Perm where\n map e p := (e.symm.trans p).trans e\n map_refl' α := by ext; simp\n map_trans' _ _ := by ext; simp", "start": [ 26, 1 ], "end": [ 29, 33 ], "kind": "commanddeclaration" }, { "full_name": "EquivFunctorFinset", "code": "instance EquivFunctorFinset : EquivFunctor Finset where\n map e s := s.map e.toEmbedding\n map_refl' α := by ext; simp\n map_trans' k h := by\n ext _ a; simp; constructor <;> intro h'\n · let ⟨a, ha₁, ha₂⟩ := h'\n rw [← ha₂]; simp; apply ha₁\n · exists (Equiv.symm k) ((Equiv.symm h) a)\n simp [h']", "start": [ 34, 1 ], "end": [ 42, 16 ], "kind": "commanddeclaration" }, { "full_name": "EquivFunctorFintype", "code": "instance EquivFunctorFintype : EquivFunctor Fintype where\n map e s := Fintype.ofBijective e e.bijective\n map_refl' α := by ext; simp [eq_iff_true_of_subsingleton]\n map_trans' := by simp [eq_iff_true_of_subsingleton]", "start": [ 45, 1 ], "end": [ 48, 54 ], "kind": "commanddeclaration" } ]

[ "Mathlib/Data/Stream/Init.lean", "Mathlib/Order/OmegaCompletePartialOrder.lean", "Mathlib/Tactic/ApplyFun.lean", ".lake/packages/lean4/src/lean/Init.lean", "Mathlib/Control/Fix.lean" ]

[ { "full_name": "LawfulFix", "code": "class LawfulFix (α : Type*) [OmegaCompletePartialOrder α] extends Fix α where\n fix_eq : ∀ {f : α →o α}, Continuous f → Fix.fix f = f (Fix.fix f)", "start": [ 34, 1 ], "end": [ 41, 68 ], "kind": "commanddeclaration" }, { "full_name": "LawfulFix.fix_eq'", "code": "theorem LawfulFix.fix_eq' {α} [OmegaCompletePartialOrder α] [LawfulFix α] {f : α → α}\n (hf : Continuous' f) : Fix.fix f = f (Fix.fix f)", "start": [ 44, 1 ], "end": [ 46, 37 ], "kind": "commanddeclaration" }, { "full_name": "Part.Fix.approx_mono'", "code": "theorem approx_mono' {i : ℕ} : Fix.approx f i ≤ Fix.approx f (succ i)", "start": [ 57, 1 ], "end": [ 60, 55 ], "kind": "commanddeclaration" }, { "full_name": "Part.Fix.approx_mono", "code": "theorem approx_mono ⦃i j : ℕ⦄ (hij : i ≤ j) : approx f i ≤ approx f j", "start": [ 63, 1 ], "end": [ 68, 43 ], "kind": "commanddeclaration" }, { "full_name": "Part.Fix.mem_iff", "code": "theorem mem_iff (a : α) (b : β a) : b ∈ Part.fix f a ↔ ∃ i, b ∈ approx f i a", "start": [ 71, 1 ], "end": [ 91, 20 ], "kind": "commanddeclaration" }, { "full_name": "Part.Fix.approx_le_fix", "code": "theorem approx_le_fix (i : ℕ) : approx f i ≤ Part.fix f", "start": [ 94, 1 ], "end": [ 96, 16 ], "kind": "commanddeclaration" }, { "full_name": "Part.Fix.exists_fix_le_approx", "code": "theorem exists_fix_le_approx (x : α) : ∃ i, Part.fix f x ≤ approx f i x", "start": [ 99, 1 ], "end": [ 112, 20 ], "kind": "commanddeclaration" }, { "full_name": "Part.Fix.approxChain", "code": "def approxChain : Chain ((a : _) → Part <| β a) :=\n ⟨approx f, approx_mono f⟩", "start": [ 115, 1 ], "end": [ 117, 28 ], "kind": "commanddeclaration" }, { "full_name": "Part.Fix.le_f_of_mem_approx", "code": "theorem le_f_of_mem_approx {x} : x ∈ approxChain f → x ≤ f x", "start": [ 120, 1 ], "end": [ 123, 21 ], "kind": "commanddeclaration" }, { "full_name": "Part.Fix.approx_mem_approxChain", "code": "theorem approx_mem_approxChain {i} : approx f i ∈ approxChain f", "start": [ 126, 1 ], "end": [ 127, 28 ], "kind": "commanddeclaration" }, { "full_name": "Part.fix_eq_ωSup", "code": "theorem fix_eq_ωSup : Part.fix f = ωSup (approxChain f)", "start": [ 145, 1 ], "end": [ 159, 26 ], "kind": "commanddeclaration" }, { "full_name": "Part.fix_le", "code": "theorem fix_le {X : (a : _) → Part <| β a} (hX : f X ≤ X) : Part.fix f ≤ X", "start": [ 162, 1 ], "end": [ 172, 15 ], "kind": "commanddeclaration" }, { "full_name": "Part.fix_eq", "code": "theorem fix_eq : Part.fix f = f (Part.fix f)", "start": [ 178, 1 ], "end": [ 189, 18 ], "kind": "commanddeclaration" }, { "full_name": "Part.toUnitMono", "code": "@[simps]\ndef toUnitMono (f : Part α →o Part α) : (Unit → Part α) →o Unit → Part α where\n toFun x u := f (x u)\n monotone' x y (h : x ≤ y) u := f.monotone <| h u", "start": [ 196, 1 ], "end": [ 200, 51 ], "kind": "commanddeclaration" }, { "full_name": "Part.to_unit_cont", "code": "theorem to_unit_cont (f : Part α →o Part α) (hc : Continuous f) : Continuous (toUnitMono f)", "start": [ 203, 1 ], "end": [ 207, 34 ], "kind": "commanddeclaration" }, { "full_name": "Part.lawfulFix", "code": "instance lawfulFix : LawfulFix (Part α) :=\n ⟨fun {f : Part α →o Part α} hc ↦ show Part.fix (toUnitMono f) () = _ by\n rw [Part.fix_eq (to_unit_cont f hc)]; rfl⟩", "start": [ 210, 1 ], "end": [ 212, 47 ], "kind": "commanddeclaration" }, { "full_name": "Pi.lawfulFix", "code": "instance lawfulFix {β} : LawfulFix (α → Part β) :=\n ⟨fun {_f} ↦ Part.fix_eq⟩", "start": [ 221, 1 ], "end": [ 222, 27 ], "kind": "commanddeclaration" }, { "full_name": "Pi.monotoneCurry", "code": "@[simps]\ndef monotoneCurry [(x y : _) → Preorder <| γ x y] :\n (∀ x : Σa, β a, γ x.1 x.2) →o ∀ (a) (b : β a), γ a b where\n toFun := curry\n monotone' _x _y h a b := h ⟨a, b⟩", "start": [ 231, 1 ], "end": [ 236, 36 ], "kind": "commanddeclaration" }, { "full_name": "Pi.monotoneUncurry", "code": "@[simps]\ndef monotoneUncurry [(x y : _) → Preorder <| γ x y] :\n (∀ (a) (b : β a), γ a b) →o ∀ x : Σa, β a, γ x.1 x.2 where\n toFun := uncurry\n monotone' _x _y h a := h a.1 a.2", "start": [ 239, 1 ], "end": [ 244, 35 ], "kind": "commanddeclaration" }, { "full_name": "Pi.continuous_curry", "code": "theorem continuous_curry : Continuous <| monotoneCurry α β γ", "start": [ 251, 1 ], "end": [ 255, 6 ], "kind": "commanddeclaration" }, { "full_name": "Pi.continuous_uncurry", "code": "theorem continuous_uncurry : Continuous <| monotoneUncurry α β γ", "start": [ 258, 1 ], "end": [ 262, 6 ], "kind": "commanddeclaration" }, { "full_name": "Pi.hasFix", "code": "instance hasFix [Fix <| (x : Sigma β) → γ x.1 x.2] : Fix ((x : _) → (y : β x) → γ x y) :=\n ⟨fun f ↦ curry (fix <| uncurry ∘ f ∘ curry)⟩", "start": [ 269, 1 ], "end": [ 270, 47 ], "kind": "commanddeclaration" }, { "full_name": "Pi.uncurry_curry_continuous", "code": "theorem uncurry_curry_continuous :\n Continuous <| (monotoneUncurry α β γ).comp <| f.comp <| monotoneCurry α β γ", "start": [ 280, 1 ], "end": [ 282, 99 ], "kind": "commanddeclaration" }, { "full_name": "Pi.lawfulFix'", "code": "instance lawfulFix' [LawfulFix <| (x : Sigma β) → γ x.1 x.2] :\n LawfulFix ((x y : _) → γ x y) where\n fix_eq {_f} hc := by\n dsimp [fix]\n conv_lhs => erw [LawfulFix.fix_eq (uncurry_curry_continuous hc)]\n rfl", "start": [ 287, 1 ], "end": [ 292, 8 ], "kind": "commanddeclaration" } ]

[ "Mathlib/CategoryTheory/Types.lean", "Mathlib/Logic/UnivLE.lean", ".lake/packages/lean4/src/lean/Init.lean", "Mathlib/CategoryTheory/EssentialImage.lean" ]

[ { "full_name": "UnivLE.ofEssSurj", "code": "theorem UnivLE.ofEssSurj (w : (uliftFunctor.{u, v} : Type v ⥤ Type max u v).EssSurj) :\n UnivLE.{max u v, v}", "start": [ 22, 1 ], "end": [ 26, 57 ], "kind": "commanddeclaration" }, { "full_name": "EssSurj.ofUnivLE", "code": "instance EssSurj.ofUnivLE [UnivLE.{max u v, v}] :\n (uliftFunctor.{u, v} : Type v ⥤ Type max u v).EssSurj where\n mem_essImage α :=\n ⟨Shrink α, ⟨Equiv.toIso (Equiv.ulift.trans (equivShrink α).symm)⟩⟩", "start": [ 28, 1 ], "end": [ 31, 71 ], "kind": "commanddeclaration" }, { "full_name": "UnivLE_iff_essSurj", "code": "theorem UnivLE_iff_essSurj :\n UnivLE.{max u v, v} ↔ (uliftFunctor.{u, v} : Type v ⥤ Type max u v).EssSurj", "start": [ 33, 1 ], "end": [ 35, 56 ], "kind": "commanddeclaration" }, { "full_name": "UnivLE.witness", "code": "def UnivLE.witness [UnivLE.{max u v, v}] : Type u ⥤ Type v :=\n uliftFunctor.{v, u} ⋙ (uliftFunctor.{u, v}).inv", "start": [ 39, 1 ], "end": [ 40, 50 ], "kind": "commanddeclaration" } ]

[ ".lake/packages/lean4/src/lean/Init.lean", "Mathlib/CategoryTheory/Idempotents/Karoubi.lean" ]

[ { "full_name": "CategoryTheory.Idempotents.Karoubi.Biproducts.bicone", "code": "@[simps]\ndef bicone [HasFiniteBiproducts C] {J : Type} [Finite J] (F : J → Karoubi C) : Bicone F where\n pt :=\n { X := biproduct fun j => (F j).X\n p := biproduct.map fun j => (F j).p\n idem := by\n ext\n simp only [assoc, biproduct.map_π, biproduct.map_π_assoc, idem] }\n π j :=\n { f := (biproduct.map fun j => (F j).p) ≫ Bicone.π _ j\n comm := by\n simp only [assoc, biproduct.bicone_π, biproduct.map_π, biproduct.map_π_assoc, (F j).idem] }\n ι j :=\n { f := biproduct.ι (fun j => (F j).X) j ≫ biproduct.map fun j => (F j).p\n comm := by simp only [biproduct.ι_map, assoc, idem_assoc] }\n ι_π j j' := by\n split_ifs with h\n · subst h\n simp only [biproduct.ι_map, biproduct.bicone_π, biproduct.map_π, eqToHom_refl,\n id_eq, hom_ext_iff, comp_f, assoc, bicone_ι_π_self_assoc, idem]\n · dsimp\n simp only [biproduct.ι_map, biproduct.map_π, hom_ext_iff, comp_f,\n assoc, biproduct.ι_π_ne_assoc _ h, zero_comp, comp_zero, instZero_zero]", "start": [ 45, 1 ], "end": [ 69, 80 ], "kind": "commanddeclaration" }, { "full_name": "CategoryTheory.Idempotents.Karoubi.karoubi_hasFiniteBiproducts", "code": "theorem karoubi_hasFiniteBiproducts [HasFiniteBiproducts C] : HasFiniteBiproducts (Karoubi C)", "start": [ 74, 1 ], "end": [ 88, 60 ], "kind": "commanddeclaration" }, { "full_name": "CategoryTheory.Idempotents.Karoubi.complement", "code": "@[simps]\ndef complement (P : Karoubi C) : Karoubi C where\n X := P.X\n p := 𝟙 _ - P.p\n idem := idem_of_id_sub_idem P.p P.idem", "start": [ 93, 1 ], "end": [ 99, 41 ], "kind": "commanddeclaration" }, { "full_name": "CategoryTheory.Idempotents.Karoubi.decomposition", "code": "def decomposition (P : Karoubi C) : P ⊞ P.complement ≅ (toKaroubi _).obj P.X where\n hom := biprod.desc P.decompId_i P.complement.decompId_i\n inv := biprod.lift P.decompId_p P.complement.decompId_p\n hom_inv_id := by\n apply biprod.hom_ext'\n · rw [biprod.inl_desc_assoc, comp_id, biprod.lift_eq, comp_add, ← decompId_assoc,\n add_right_eq_self, ← assoc]\n refine (?_ =≫ _).trans zero_comp\n ext\n simp only [comp_f, toKaroubi_obj_X, decompId_i_f, decompId_p_f,\n complement_p, comp_sub, comp_id, idem, sub_self, instZero_zero]\n · rw [biprod.inr_desc_assoc, comp_id, biprod.lift_eq, comp_add, ← decompId_assoc,\n add_left_eq_self, ← assoc]\n refine (?_ =≫ _).trans zero_comp\n ext\n simp only [complement_X, comp_f, decompId_i_f, complement_p,\n decompId_p_f, sub_comp, id_comp, idem, sub_self, instZero_zero]\n inv_hom_id := by\n simp only [biprod.lift_desc, instAdd_add, toKaroubi_obj_X, comp_f,\n decompId_p_f, decompId_i_f, idem, complement_X, complement_p, comp_sub, comp_id,\n sub_comp, id_comp, sub_self, sub_zero, add_sub_cancel,\n id_eq, toKaroubi_obj_p]", "start": [ 124, 1 ], "end": [ 148, 30 ], "kind": "commanddeclaration" } ]

[ "Mathlib/RingTheory/Ideal/QuotientOperations.lean", "Mathlib/RingTheory/Valuation/Basic.lean", ".lake/packages/lean4/src/lean/Init.lean" ]

[ { "full_name": "Valuation.onQuotVal", "code": "def onQuotVal {J : Ideal R} (hJ : J ≤ supp v) : R ⧸ J → Γ₀ := fun q =>\n Quotient.liftOn' q v fun a b h =>\n calc\n v a = v (b + -(-a + b)) := by simp\n _ = v b :=\n v.map_add_supp b <| (Ideal.neg_mem_iff _).2 <| hJ <| QuotientAddGroup.leftRel_apply.mp h", "start": [ 26, 1 ], "end": [ 33, 97 ], "kind": "commanddeclaration" }, { "full_name": "Valuation.onQuot", "code": "def onQuot {J : Ideal R} (hJ : J ≤ supp v) : Valuation (R ⧸ J) Γ₀ where\n toFun := v.onQuotVal hJ\n map_zero' := v.map_zero\n map_one' := v.map_one\n map_mul' xbar ybar := Quotient.ind₂' v.map_mul xbar ybar\n map_add_le_max' xbar ybar := Quotient.ind₂' v.map_add xbar ybar", "start": [ 36, 1 ], "end": [ 42, 66 ], "kind": "commanddeclaration" }, { "full_name": "Valuation.onQuot_comap_eq", "code": "@[simp]\ntheorem onQuot_comap_eq {J : Ideal R} (hJ : J ≤ supp v) :\n (v.onQuot hJ).comap (Ideal.Quotient.mk J) = v", "start": [ 45, 1 ], "end": [ 48, 19 ], "kind": "commanddeclaration" }, { "full_name": "Valuation.self_le_supp_comap", "code": "theorem self_le_supp_comap (J : Ideal R) (v : Valuation (R ⧸ J) Γ₀) :\n J ≤ (v.comap (Ideal.Quotient.mk J)).supp", "start": [ 51, 1 ], "end": [ 54, 7 ], "kind": "commanddeclaration" }, { "full_name": "Valuation.comap_onQuot_eq", "code": "@[simp]\ntheorem comap_onQuot_eq (J : Ideal R) (v : Valuation (R ⧸ J) Γ₀) :\n (v.comap (Ideal.Quotient.mk J)).onQuot (v.self_le_supp_comap J) = v", "start": [ 57, 1 ], "end": [ 62, 8 ], "kind": "commanddeclaration" }, { "full_name": "Valuation.supp_quot", "code": "theorem supp_quot {J : Ideal R} (hJ : J ≤ supp v) :\n supp (v.onQuot hJ) = (supp v).map (Ideal.Quotient.mk J)", "start": [ 65, 1 ], "end": [ 74, 13 ], "kind": "commanddeclaration" }, { "full_name": "Valuation.supp_quot_supp", "code": "theorem supp_quot_supp : supp (v.onQuot le_rfl) = 0", "start": [ 77, 1 ], "end": [ 79, 34 ], "kind": "commanddeclaration" }, { "full_name": "AddValuation.onQuotVal", "code": "def onQuotVal {J : Ideal R} (hJ : J ≤ supp v) : R ⧸ J → Γ₀ :=\n Valuation.onQuotVal v hJ", "start": [ 92, 1 ], "end": [ 95, 27 ], "kind": "commanddeclaration" }, { "full_name": "AddValuation.onQuot", "code": "def onQuot {J : Ideal R} (hJ : J ≤ supp v) : AddValuation (R ⧸ J) Γ₀ :=\n Valuation.onQuot v hJ", "start": [ 98, 1 ], "end": [ 100, 24 ], "kind": "commanddeclaration" }, { "full_name": "AddValuation.onQuot_comap_eq", "code": "@[simp]\ntheorem onQuot_comap_eq {J : Ideal R} (hJ : J ≤ supp v) :\n (v.onQuot hJ).comap (Ideal.Quotient.mk J) = v", "start": [ 103, 1 ], "end": [ 106, 33 ], "kind": "commanddeclaration" }, { "full_name": "AddValuation.comap_supp", "code": "theorem comap_supp {S : Type*} [CommRing S] (f : S →+* R) :\n supp (v.comap f) = Ideal.comap f v.supp", "start": [ 109, 1 ], "end": [ 111, 27 ], "kind": "commanddeclaration" }, { "full_name": "AddValuation.self_le_supp_comap", "code": "theorem self_le_supp_comap (J : Ideal R) (v : AddValuation (R ⧸ J) Γ₀) :\n J ≤ (v.comap (Ideal.Quotient.mk J)).supp", "start": [ 114, 1 ], "end": [ 116, 35 ], "kind": "commanddeclaration" }, { "full_name": "AddValuation.comap_onQuot_eq", "code": "@[simp]\ntheorem comap_onQuot_eq (J : Ideal R) (v : AddValuation (R ⧸ J) Γ₀) :\n (v.comap (Ideal.Quotient.mk J)).onQuot (v.self_le_supp_comap J) = v", "start": [ 119, 1 ], "end": [ 122, 32 ], "kind": "commanddeclaration" }, { "full_name": "AddValuation.supp_quot", "code": "theorem supp_quot {J : Ideal R} (hJ : J ≤ supp v) :\n supp (v.onQuot hJ) = (supp v).map (Ideal.Quotient.mk J)", "start": [ 125, 1 ], "end": [ 128, 27 ], "kind": "commanddeclaration" }, { "full_name": "AddValuation.supp_quot_supp", "code": "theorem supp_quot_supp : supp ((Valuation.onQuot v) le_rfl) = 0", "start": [ 131, 1 ], "end": [ 132, 29 ], "kind": "commanddeclaration" } ]

[ "Mathlib/RingTheory/AdicCompletion/Functoriality.lean", ".lake/packages/lean4/src/lean/Init.lean", "Mathlib/Algebra/Exact.lean", "Mathlib/RingTheory/Filtration.lean" ]

[ { "full_name": "AdicCompletion.mapPreimageDelta", "code": "private noncomputable def mapPreimageDelta (x : AdicCauchySequence I N)\n {n : ℕ} {y yₙ : M} (hy : f y = x (n + 1)) (hyₙ : f yₙ = x n) :\n { d : (I ^ n • ⊤ : Submodule R M) | f d = f (yₙ - y) } :=\n have h : f (yₙ - y) ∈ Submodule.map f (I ^ n • ⊤ : Submodule R M) := by\n rw [Submodule.map_smul'', Submodule.map_top, LinearMap.range_eq_top.mpr hf, map_sub,\n hyₙ, hy, ← Submodule.neg_mem_iff, neg_sub, ← SModEq.sub_mem]\n exact AdicCauchySequence.mk_eq_mk (Nat.le_succ n) x\n ⟨⟨h.choose, h.choose_spec.1⟩, h.choose_spec.2⟩", "start": [ 46, 1 ], "end": [ 53, 49 ], "kind": "commanddeclaration" }, { "full_name": "AdicCompletion.mapPreimage", "code": "private noncomputable def mapPreimage (x : AdicCauchySequence I N) :\n (n : ℕ) → f ⁻¹' {x n}\n | .zero => ⟨(hf (x 0)).choose, (hf (x 0)).choose_spec⟩\n | .succ n =>\n let y := (hf (x (n + 1))).choose\n have hy := (hf (x (n + 1))).choose_spec\n let ⟨yₙ, (hyₙ : f yₙ = x n)⟩ := mapPreimage x n\n let ⟨⟨d, _⟩, (p : f d = f (yₙ - y))⟩ := mapPreimageDelta hf x hy hyₙ\n ⟨yₙ - d, by simpa [p]⟩", "start": [ 56, 1 ], "end": [ 64, 29 ], "kind": "commanddeclaration" }, { "full_name": "AdicCompletion.map_surjective", "code": "theorem map_surjective : Function.Surjective (map I f)", "start": [ 68, 1 ], "end": [ 76, 72 ], "kind": "commanddeclaration" }, { "full_name": "AdicCompletion.map_injective", "code": "theorem map_injective {f : M →ₗ[R] N} (hf : Function.Injective f) :\n Function.Injective (map I f)", "start": [ 90, 1 ], "end": [ 104, 79 ], "kind": "commanddeclaration" }, { "full_name": "AdicCompletion.mapExactAuxDelta", "code": "private noncomputable def mapExactAuxDelta {n : ℕ} {d : N}\n (hdmem : d ∈ (I ^ (k + n + 1) • ⊤ : Submodule R N)) {y yₙ : M}\n (hd : f y = x (k + n + 1) - d) (hyₙ : f yₙ - x (k + n) ∈ (I ^ (k + n) • ⊤ : Submodule R N)) :\n { d : (I ^ n • ⊤ : Submodule R M)\n | f (yₙ + d) - x (k + n + 1) ∈ (I ^ (k + n + 1) • ⊤ : Submodule R N) } :=\n have h : f (y - yₙ) ∈ (I ^ (k + n) • ⊤ : Submodule R N) := by\n simp only [map_sub, hd]\n convert_to x (k + n + 1) - x (k + n) - d - (f yₙ - x (k + n)) ∈ I ^ (k + n) • ⊤\n · abel\n · refine Submodule.sub_mem _ (Submodule.sub_mem _ ?_ ?_) hyₙ\n · rw [← Submodule.Quotient.eq]\n exact AdicCauchySequence.mk_eq_mk (by omega) _\n · exact (Submodule.smul_mono_left (Ideal.pow_le_pow_right (by omega))) hdmem\n have hincl : I ^ (k + n - k) • (I ^ k • ⊤ ⊓ range f) ≤ I ^ (k + n - k) • (range f) :=\n smul_mono_right _ inf_le_right\n have hyyₙ : y - yₙ ∈ (I ^ n • ⊤ : Submodule R M) := by\n convert_to y - yₙ ∈ (I ^ (k + n - k) • ⊤ : Submodule R M)\n · simp\n · rw [← Submodule.comap_map_eq_of_injective hf (I ^ (k + n - k) • ⊤ : Submodule R M),\n Submodule.map_smul'', Submodule.map_top]\n apply hincl\n rw [← hkn (k + n) (by omega)]\n exact ⟨h, ⟨y - yₙ, rfl⟩⟩\n ⟨⟨y - yₙ, hyyₙ⟩, by simpa [hd, Nat.succ_eq_add_one, Nat.add_assoc]⟩", "start": [ 123, 1 ], "end": [ 146, 70 ], "kind": "commanddeclaration" }, { "full_name": "AdicCompletion.mapExactAux", "code": "private noncomputable def mapExactAux :\n (n : ℕ) → { a : M | f a - x (k + n) ∈ (I ^ (k + n) • ⊤ : Submodule R N) }\n | .zero =>\n let d := (h2 0).choose\n let y := (h2 0).choose_spec.choose\n have hdy : f y = x (k + 0) - d := (h2 0).choose_spec.choose_spec.right\n have hdmem := (h2 0).choose_spec.choose_spec.left\n ⟨y, by simpa [hdy]⟩\n | .succ n =>\n let d := (h2 <| n + 1).choose\n let y := (h2 <| n + 1).choose_spec.choose\n have hdy : f y = x (k + (n + 1)) - d := (h2 <| n + 1).choose_spec.choose_spec.right\n have hdmem := (h2 <| n + 1).choose_spec.choose_spec.left\n let ⟨yₙ, (hyₙ : f yₙ - x (k + n) ∈ (I ^ (k + n) • ⊤ : Submodule R N))⟩ :=\n mapExactAux n\n let ⟨d, hd⟩ := mapExactAuxDelta hf hkn x hdmem hdy hyₙ\n ⟨yₙ + d, hd⟩\n where\n h1 (n : ℕ) : g (x (k + n)) ∈ Submodule.map g (I ^ (k + n) • ⊤ : Submodule R N) := by\n rw [map_smul'', Submodule.map_top, range_eq_top.mpr hg]\n exact hker (k + n)\n h2 (n : ℕ) : ∃ (d : N) (y : M),\n d ∈ (I ^ (k + n) • ⊤ : Submodule R N) ∧ f y = x (k + n) - d := by\n obtain ⟨d, hdmem, hd⟩ := h1 n\n obtain ⟨y, hdy⟩ := (hfg (x (k + n) - d)).mp (by simp [hd])\n exact ⟨d, y, hdmem, hdy⟩", "start": [ 151, 1 ], "end": [ 176, 29 ], "kind": "commanddeclaration" }, { "full_name": "AdicCompletion.map_exact", "code": "theorem map_exact : Function.Exact (map I f) (map I g)", "start": [ 180, 1 ], "end": [ 200, 31 ], "kind": "commanddeclaration" } ]

[ ".lake/packages/lean4/src/lean/Init.lean", "Mathlib/Topology/IsLocalHomeomorph.lean", "Mathlib/Topology/FiberBundle/Basic.lean" ]

[ { "full_name": "IsEvenlyCovered", "code": "def IsEvenlyCovered (x : X) (I : Type*) [TopologicalSpace I] :=\n DiscreteTopology I ∧ ∃ t : Trivialization I f, x ∈ t.baseSet", "start": [ 31, 1 ], "end": [ 33, 63 ], "kind": "commanddeclaration" }, { "full_name": "IsEvenlyCovered.toTrivialization", "code": "noncomputable def toTrivialization {x : X} {I : Type*} [TopologicalSpace I]\n (h : IsEvenlyCovered f x I) : Trivialization (f ⁻¹' {x}) f :=\n (Classical.choose h.2).transFiberHomeomorph\n ((Classical.choose h.2).preimageSingletonHomeomorph (Classical.choose_spec h.2)).symm", "start": [ 40, 1 ], "end": [ 44, 90 ], "kind": "commanddeclaration" }, { "full_name": "IsEvenlyCovered.mem_toTrivialization_baseSet", "code": "theorem mem_toTrivialization_baseSet {x : X} {I : Type*} [TopologicalSpace I]\n (h : IsEvenlyCovered f x I) : x ∈ h.toTrivialization.baseSet", "start": [ 47, 1 ], "end": [ 49, 28 ], "kind": "commanddeclaration" }, { "full_name": "IsEvenlyCovered.toTrivialization_apply", "code": "theorem toTrivialization_apply {x : E} {I : Type*} [TopologicalSpace I]\n (h : IsEvenlyCovered f (f x) I) : (h.toTrivialization x).2 = ⟨x, rfl⟩", "start": [ 52, 1 ], "end": [ 60, 22 ], "kind": "commanddeclaration" }, { "full_name": "IsEvenlyCovered.continuousAt", "code": "protected theorem continuousAt {x : E} {I : Type*} [TopologicalSpace I]\n (h : IsEvenlyCovered f (f x) I) : ContinuousAt f x", "start": [ 63, 1 ], "end": [ 66, 74 ], "kind": "commanddeclaration" }, { "full_name": "IsEvenlyCovered.to_isEvenlyCovered_preimage", "code": "theorem to_isEvenlyCovered_preimage {x : X} {I : Type*} [TopologicalSpace I]\n (h : IsEvenlyCovered f x I) : IsEvenlyCovered f x (f ⁻¹' {x})", "start": [ 69, 1 ], "end": [ 74, 39 ], "kind": "commanddeclaration" }, { "full_name": "IsCoveringMapOn", "code": "def IsCoveringMapOn :=\n ∀ x ∈ s, IsEvenlyCovered f x (f ⁻¹' {x})", "start": [ 79, 1 ], "end": [ 82, 43 ], "kind": "commanddeclaration" }, { "full_name": "IsCoveringMapOn.mk", "code": "theorem mk (F : X → Type*) [∀ x, TopologicalSpace (F x)] [hF : ∀ x, DiscreteTopology (F x)]\n (e : ∀ x ∈ s, Trivialization (F x) f) (h : ∀ (x : X) (hx : x ∈ s), x ∈ (e x hx).baseSet) :\n IsCoveringMapOn f s", "start": [ 87, 1 ], "end": [ 90, 69 ], "kind": "commanddeclaration" }, { "full_name": "IsCoveringMapOn.continuousAt", "code": "protected theorem continuousAt (hf : IsCoveringMapOn f s) {x : E} (hx : f x ∈ s) :\n ContinuousAt f x", "start": [ 95, 1 ], "end": [ 97, 29 ], "kind": "commanddeclaration" }, { "full_name": "IsCoveringMapOn.continuousOn", "code": "protected theorem continuousOn (hf : IsCoveringMapOn f s) : ContinuousOn f (f ⁻¹' s)", "start": [ 100, 1 ], "end": [ 101, 53 ], "kind": "commanddeclaration" }, { "full_name": "IsCoveringMapOn.isLocalHomeomorphOn", "code": "protected theorem isLocalHomeomorphOn (hf : IsCoveringMapOn f s) :\n IsLocalHomeomorphOn f (f ⁻¹' s)", "start": [ 104, 1 ], "end": [ 127, 44 ], "kind": "commanddeclaration" }, { "full_name": "IsCoveringMap", "code": "def IsCoveringMap :=\n ∀ x, IsEvenlyCovered f x (f ⁻¹' {x})", "start": [ 132, 1 ], "end": [ 135, 39 ], "kind": "commanddeclaration" }, { "full_name": "isCoveringMap_iff_isCoveringMapOn_univ", "code": "theorem isCoveringMap_iff_isCoveringMapOn_univ : IsCoveringMap f ↔ IsCoveringMapOn f Set.univ", "start": [ 140, 1 ], "end": [ 141, 77 ], "kind": "commanddeclaration" }, { "full_name": "IsCoveringMap.isCoveringMapOn", "code": "protected theorem IsCoveringMap.isCoveringMapOn (hf : IsCoveringMap f) :\n IsCoveringMapOn f Set.univ", "start": [ 144, 1 ], "end": [ 146, 47 ], "kind": "commanddeclaration" }, { "full_name": "IsCoveringMap.mk", "code": "theorem mk (F : X → Type*) [∀ x, TopologicalSpace (F x)] [∀ x, DiscreteTopology (F x)]\n (e : ∀ x, Trivialization (F x) f) (h : ∀ x, x ∈ (e x).baseSet) : IsCoveringMap f", "start": [ 153, 1 ], "end": [ 156, 70 ], "kind": "commanddeclaration" }, { "full_name": "IsCoveringMap.continuous", "code": "protected theorem continuous : Continuous f", "start": [ 162, 1 ], "end": [ 163, 71 ], "kind": "commanddeclaration" }, { "full_name": "IsCoveringMap.isLocalHomeomorph", "code": "protected theorem isLocalHomeomorph : IsLocalHomeomorph f", "start": [ 166, 1 ], "end": [ 167, 92 ], "kind": "commanddeclaration" }, { "full_name": "IsCoveringMap.isOpenMap", "code": "protected theorem isOpenMap : IsOpenMap f", "start": [ 170, 1 ], "end": [ 171, 33 ], "kind": "commanddeclaration" }, { "full_name": "IsCoveringMap.quotientMap", "code": "protected theorem quotientMap (hf' : Function.Surjective f) : QuotientMap f", "start": [ 174, 1 ], "end": [ 175, 48 ], "kind": "commanddeclaration" }, { "full_name": "IsCoveringMap.isSeparatedMap", "code": "protected theorem isSeparatedMap : IsSeparatedMap f", "start": [ 178, 1 ], "end": [ 188, 51 ], "kind": "commanddeclaration" }, { "full_name": "IsCoveringMap.eq_of_comp_eq", "code": "theorem eq_of_comp_eq [PreconnectedSpace A] (h₁ : Continuous g₁) (h₂ : Continuous g₂)\n (he : f ∘ g₁ = f ∘ g₂) (a : A) (ha : g₁ a = g₂ a) : g₁ = g₂", "start": [ 192, 1 ], "end": [ 194, 88 ], "kind": "commanddeclaration" }, { "full_name": "IsCoveringMap.eqOn_of_comp_eqOn", "code": "theorem eqOn_of_comp_eqOn (h₁ : ContinuousOn g₁ s) (h₂ : ContinuousOn g₂ s)\n (he : s.EqOn (f ∘ g₁) (f ∘ g₂)) {a : A} (has : a ∈ s) (ha : g₁ a = g₂ a) : s.EqOn g₁ g₂", "start": [ 196, 1 ], "end": [ 198, 97 ], "kind": "commanddeclaration" }, { "full_name": "IsCoveringMap.const_of_comp", "code": "theorem const_of_comp [PreconnectedSpace A] (cont : Continuous g)\n (he : ∀ a a', f (g a) = f (g a')) (a a') : g a = g a'", "start": [ 200, 1 ], "end": [ 202, 87 ], "kind": "commanddeclaration" }, { "full_name": "IsCoveringMap.constOn_of_comp", "code": "theorem constOn_of_comp (cont : ContinuousOn g s)\n (he : ∀ a ∈ s, ∀ a' ∈ s, f (g a) = f (g a'))\n {a a'} (ha : a ∈ s) (ha' : a' ∈ s) : g a = g a'", "start": [ 204, 1 ], "end": [ 207, 94 ], "kind": "commanddeclaration" }, { "full_name": "IsFiberBundle.isCoveringMap", "code": "protected theorem IsFiberBundle.isCoveringMap {F : Type*} [TopologicalSpace F] [DiscreteTopology F]\n (hf : ∀ x : X, ∃ e : Trivialization F f, x ∈ e.baseSet) : IsCoveringMap f", "start": [ 213, 1 ], "end": [ 216, 33 ], "kind": "commanddeclaration" }, { "full_name": "FiberBundle.isCoveringMap", "code": "protected theorem FiberBundle.isCoveringMap {F : Type*} {E : X → Type*} [TopologicalSpace F]\n [DiscreteTopology F] [TopologicalSpace (Bundle.TotalSpace F E)] [∀ x, TopologicalSpace (E x)]\n [FiberBundle F E] : IsCoveringMap (π F E)", "start": [ 219, 1 ], "end": [ 222, 100 ], "kind": "commanddeclaration" } ]

[ ".lake/packages/lean4/src/lean/Init.lean", "Mathlib/Geometry/Euclidean/Circumcenter.lean", "Mathlib/Geometry/Euclidean/Angle/Oriented/RightAngle.lean" ]

[ { "full_name": "Orientation.oangle_eq_two_zsmul_oangle_sub_of_norm_eq", "code": "theorem oangle_eq_two_zsmul_oangle_sub_of_norm_eq {x y z : V} (hxyne : x ≠ y) (hxzne : x ≠ z)\n (hxy : ‖x‖ = ‖y‖) (hxz : ‖x‖ = ‖z‖) : o.oangle y z = (2 : ℤ) • o.oangle (y - x) (z - x)", "start": [ 30, 1 ], "end": [ 48, 89 ], "kind": "commanddeclaration" }, { "full_name": "Orientation.oangle_eq_two_zsmul_oangle_sub_of_norm_eq_real", "code": "theorem oangle_eq_two_zsmul_oangle_sub_of_norm_eq_real {x y z : V} (hxyne : x ≠ y) (hxzne : x ≠ z)\n {r : ℝ} (hx : ‖x‖ = r) (hy : ‖y‖ = r) (hz : ‖z‖ = r) :\n o.oangle y z = (2 : ℤ) • o.oangle (y - x) (z - x)", "start": [ 51, 1 ], "end": [ 56, 88 ], "kind": "commanddeclaration" }, { "full_name": "Orientation.two_zsmul_oangle_sub_eq_two_zsmul_oangle_sub_of_norm_eq", "code": "theorem two_zsmul_oangle_sub_eq_two_zsmul_oangle_sub_of_norm_eq {x₁ x₂ y z : V} (hx₁yne : x₁ ≠ y)\n (hx₁zne : x₁ ≠ z) (hx₂yne : x₂ ≠ y) (hx₂zne : x₂ ≠ z) {r : ℝ} (hx₁ : ‖x₁‖ = r) (hx₂ : ‖x₂‖ = r)\n (hy : ‖y‖ = r) (hz : ‖z‖ = r) :\n (2 : ℤ) • o.oangle (y - x₁) (z - x₁) = (2 : ℤ) • o.oangle (y - x₂) (z - x₂)", "start": [ 59, 1 ], "end": [ 67, 77 ], "kind": "commanddeclaration" }, { "full_name": "EuclideanGeometry.Sphere.oangle_center_eq_two_zsmul_oangle", "code": "theorem oangle_center_eq_two_zsmul_oangle {s : Sphere P} {p₁ p₂ p₃ : P} (hp₁ : p₁ ∈ s)\n (hp₂ : p₂ ∈ s) (hp₃ : p₃ ∈ s) (hp₂p₁ : p₂ ≠ p₁) (hp₂p₃ : p₂ ≠ p₃) :\n ∡ p₁ s.center p₃ = (2 : ℤ) • ∡ p₁ p₂ p₃", "start": [ 81, 1 ], "end": [ 87, 24 ], "kind": "commanddeclaration" }, { "full_name": "EuclideanGeometry.Sphere.two_zsmul_oangle_eq", "code": "theorem two_zsmul_oangle_eq {s : Sphere P} {p₁ p₂ p₃ p₄ : P} (hp₁ : p₁ ∈ s) (hp₂ : p₂ ∈ s)\n (hp₃ : p₃ ∈ s) (hp₄ : p₄ ∈ s) (hp₂p₁ : p₂ ≠ p₁) (hp₂p₄ : p₂ ≠ p₄) (hp₃p₁ : p₃ ≠ p₁)\n (hp₃p₄ : p₃ ≠ p₄) : (2 : ℤ) • ∡ p₁ p₂ p₄ = (2 : ℤ) • ∡ p₁ p₃ p₄", "start": [ 90, 1 ], "end": [ 100, 38 ], "kind": "commanddeclaration" }, { "full_name": "EuclideanGeometry.Cospherical.two_zsmul_oangle_eq", "code": "theorem Cospherical.two_zsmul_oangle_eq {p₁ p₂ p₃ p₄ : P}\n (h : Cospherical ({p₁, p₂, p₃, p₄} : Set P)) (hp₂p₁ : p₂ ≠ p₁) (hp₂p₄ : p₂ ≠ p₄)\n (hp₃p₁ : p₃ ≠ p₁) (hp₃p₄ : p₃ ≠ p₄) : (2 : ℤ) • ∡ p₁ p₂ p₄ = (2 : ℤ) • ∡ p₁ p₃ p₄", "start": [ 105, 1 ], "end": [ 113, 89 ], "kind": "commanddeclaration" }, { "full_name": "EuclideanGeometry.Sphere.oangle_eq_pi_sub_two_zsmul_oangle_center_left", "code": "theorem oangle_eq_pi_sub_two_zsmul_oangle_center_left {s : Sphere P} {p₁ p₂ : P} (hp₁ : p₁ ∈ s)\n (hp₂ : p₂ ∈ s) (h : p₁ ≠ p₂) : ∡ p₁ s.center p₂ = π - (2 : ℤ) • ∡ s.center p₂ p₁", "start": [ 118, 1 ], "end": [ 123, 59 ], "kind": "commanddeclaration" }, { "full_name": "EuclideanGeometry.Sphere.oangle_eq_pi_sub_two_zsmul_oangle_center_right", "code": "theorem oangle_eq_pi_sub_two_zsmul_oangle_center_right {s : Sphere P} {p₁ p₂ : P} (hp₁ : p₁ ∈ s)\n (hp₂ : p₂ ∈ s) (h : p₁ ≠ p₂) : ∡ p₁ s.center p₂ = π - (2 : ℤ) • ∡ p₂ p₁ s.center", "start": [ 126, 1 ], "end": [ 131, 85 ], "kind": "commanddeclaration" }, { "full_name": "EuclideanGeometry.Sphere.two_zsmul_oangle_center_add_two_zsmul_oangle_eq_pi", "code": "theorem two_zsmul_oangle_center_add_two_zsmul_oangle_eq_pi {s : Sphere P} {p₁ p₂ p₃ : P}\n (hp₁ : p₁ ∈ s) (hp₂ : p₂ ∈ s) (hp₃ : p₃ ∈ s) (hp₂p₁ : p₂ ≠ p₁) (hp₂p₃ : p₂ ≠ p₃)\n (hp₁p₃ : p₁ ≠ p₃) : (2 : ℤ) • ∡ p₃ p₁ s.center + (2 : ℤ) • ∡ p₁ p₂ p₃ = π", "start": [ 134, 1 ], "end": [ 140, 82 ], "kind": "commanddeclaration" }, { "full_name": "EuclideanGeometry.Sphere.abs_oangle_center_left_toReal_lt_pi_div_two", "code": "theorem abs_oangle_center_left_toReal_lt_pi_div_two {s : Sphere P} {p₁ p₂ : P} (hp₁ : p₁ ∈ s)\n (hp₂ : p₂ ∈ s) : |(∡ s.center p₂ p₁).toReal| < π / 2", "start": [ 143, 1 ], "end": [ 147, 56 ], "kind": "commanddeclaration" }, { "full_name": "EuclideanGeometry.Sphere.abs_oangle_center_right_toReal_lt_pi_div_two", "code": "theorem abs_oangle_center_right_toReal_lt_pi_div_two {s : Sphere P} {p₁ p₂ : P} (hp₁ : p₁ ∈ s)\n (hp₂ : p₂ ∈ s) : |(∡ p₂ p₁ s.center).toReal| < π / 2", "start": [ 150, 1 ], "end": [ 154, 56 ], "kind": "commanddeclaration" }, { "full_name": "EuclideanGeometry.Sphere.tan_div_two_smul_rotation_pi_div_two_vadd_midpoint_eq_center", "code": "theorem tan_div_two_smul_rotation_pi_div_two_vadd_midpoint_eq_center {s : Sphere P} {p₁ p₂ : P}\n (hp₁ : p₁ ∈ s) (hp₂ : p₂ ∈ s) (h : p₁ ≠ p₂) :\n (Real.Angle.tan (∡ p₂ p₁ s.center) / 2) • o.rotation (π / 2 : ℝ) (p₂ -ᵥ p₁) +ᵥ\n midpoint ℝ p₁ p₂ = s.center", "start": [ 157, 1 ], "end": [ 171, 21 ], "kind": "commanddeclaration" }, { "full_name": "EuclideanGeometry.Sphere.inv_tan_div_two_smul_rotation_pi_div_two_vadd_midpoint_eq_center", "code": "theorem inv_tan_div_two_smul_rotation_pi_div_two_vadd_midpoint_eq_center {s : Sphere P}\n {p₁ p₂ p₃ : P} (hp₁ : p₁ ∈ s) (hp₂ : p₂ ∈ s) (hp₃ : p₃ ∈ s) (hp₁p₂ : p₁ ≠ p₂) (hp₁p₃ : p₁ ≠ p₃)\n (hp₂p₃ : p₂ ≠ p₃) :\n ((Real.Angle.tan (∡ p₁ p₂ p₃))⁻¹ / 2) • o.rotation (π / 2 : ℝ) (p₃ -ᵥ p₁) +ᵥ midpoint ℝ p₁ p₃ =\n s.center", "start": [ 174, 1 ], "end": [ 185, 91 ], "kind": "commanddeclaration" }, { "full_name": "EuclideanGeometry.Sphere.dist_div_cos_oangle_center_div_two_eq_radius", "code": "theorem dist_div_cos_oangle_center_div_two_eq_radius {s : Sphere P} {p₁ p₂ : P} (hp₁ : p₁ ∈ s)\n (hp₂ : p₂ ∈ s) (h : p₁ ≠ p₂) :\n dist p₁ p₂ / Real.Angle.cos (∡ p₂ p₁ s.center) / 2 = s.radius", "start": [ 188, 1 ], "end": [ 213, 23 ], "kind": "commanddeclaration" }, { "full_name": "EuclideanGeometry.Sphere.dist_div_cos_oangle_center_eq_two_mul_radius", "code": "theorem dist_div_cos_oangle_center_eq_two_mul_radius {s : Sphere P} {p₁ p₂ : P} (hp₁ : p₁ ∈ s)\n (hp₂ : p₂ ∈ s) (h : p₁ ≠ p₂) :\n dist p₁ p₂ / Real.Angle.cos (∡ p₂ p₁ s.center) = 2 * s.radius", "start": [ 216, 1 ], "end": [ 222, 100 ], "kind": "commanddeclaration" }, { "full_name": "EuclideanGeometry.Sphere.dist_div_sin_oangle_div_two_eq_radius", "code": "theorem dist_div_sin_oangle_div_two_eq_radius {s : Sphere P} {p₁ p₂ p₃ : P} (hp₁ : p₁ ∈ s)\n (hp₂ : p₂ ∈ s) (hp₃ : p₃ ∈ s) (hp₁p₂ : p₁ ≠ p₂) (hp₁p₃ : p₁ ≠ p₃) (hp₂p₃ : p₂ ≠ p₃) :\n dist p₁ p₃ / |Real.Angle.sin (∡ p₁ p₂ p₃)| / 2 = s.radius", "start": [ 225, 1 ], "end": [ 235, 66 ], "kind": "commanddeclaration" }, { "full_name": "EuclideanGeometry.Sphere.dist_div_sin_oangle_eq_two_mul_radius", "code": "theorem dist_div_sin_oangle_eq_two_mul_radius {s : Sphere P} {p₁ p₂ p₃ : P} (hp₁ : p₁ ∈ s)\n (hp₂ : p₂ ∈ s) (hp₃ : p₃ ∈ s) (hp₁p₂ : p₁ ≠ p₂) (hp₁p₃ : p₁ ≠ p₃) (hp₂p₃ : p₂ ≠ p₃) :\n dist p₁ p₃ / |Real.Angle.sin (∡ p₁ p₂ p₃)| = 2 * s.radius", "start": [ 238, 1 ], "end": [ 245, 40 ], "kind": "commanddeclaration" }, { "full_name": "Affine.Triangle.inv_tan_div_two_smul_rotation_pi_div_two_vadd_midpoint_eq_circumcenter", "code": "theorem inv_tan_div_two_smul_rotation_pi_div_two_vadd_midpoint_eq_circumcenter (t : Triangle ℝ P)\n {i₁ i₂ i₃ : Fin 3} (h₁₂ : i₁ ≠ i₂) (h₁₃ : i₁ ≠ i₃) (h₂₃ : i₂ ≠ i₃) :\n ((Real.Angle.tan (∡ (t.points i₁) (t.points i₂) (t.points i₃)))⁻¹ / 2) •\n o.rotation (π / 2 : ℝ) (t.points i₃ -ᵥ t.points i₁) +ᵥ\n midpoint ℝ (t.points i₁) (t.points i₃) = t.circumcenter", "start": [ 263, 1 ], "end": [ 273, 70 ], "kind": "commanddeclaration" }, { "full_name": "Affine.Triangle.dist_div_sin_oangle_div_two_eq_circumradius", "code": "theorem dist_div_sin_oangle_div_two_eq_circumradius (t : Triangle ℝ P) {i₁ i₂ i₃ : Fin 3}\n (h₁₂ : i₁ ≠ i₂) (h₁₃ : i₁ ≠ i₃) (h₂₃ : i₂ ≠ i₃) : dist (t.points i₁) (t.points i₃) /\n |Real.Angle.sin (∡ (t.points i₁) (t.points i₂) (t.points i₃))| / 2 = t.circumradius", "start": [ 276, 1 ], "end": [ 284, 37 ], "kind": "commanddeclaration" }, { "full_name": "Affine.Triangle.dist_div_sin_oangle_eq_two_mul_circumradius", "code": "theorem dist_div_sin_oangle_eq_two_mul_circumradius (t : Triangle ℝ P) {i₁ i₂ i₃ : Fin 3}\n (h₁₂ : i₁ ≠ i₂) (h₁₃ : i₁ ≠ i₃) (h₂₃ : i₂ ≠ i₃) : dist (t.points i₁) (t.points i₃) /\n |Real.Angle.sin (∡ (t.points i₁) (t.points i₂) (t.points i₃))| = 2 * t.circumradius", "start": [ 287, 1 ], "end": [ 295, 37 ], "kind": "commanddeclaration" }, { "full_name": "Affine.Triangle.circumsphere_eq_of_dist_of_oangle", "code": "theorem circumsphere_eq_of_dist_of_oangle (t : Triangle ℝ P) {i₁ i₂ i₃ : Fin 3} (h₁₂ : i₁ ≠ i₂)\n (h₁₃ : i₁ ≠ i₃) (h₂₃ : i₂ ≠ i₃) : t.circumsphere =\n ⟨((Real.Angle.tan (∡ (t.points i₁) (t.points i₂) (t.points i₃)))⁻¹ / 2) •\n o.rotation (π / 2 : ℝ) (t.points i₃ -ᵥ t.points i₁) +ᵥ midpoint ℝ (t.points i₁) (t.points i₃),\n dist (t.points i₁) (t.points i₃) /\n |Real.Angle.sin (∡ (t.points i₁) (t.points i₂) (t.points i₃))| / 2⟩", "start": [ 298, 1 ], "end": [ 308, 69 ], "kind": "commanddeclaration" }, { "full_name": "Affine.Triangle.circumsphere_eq_circumsphere_of_eq_of_eq_of_two_zsmul_oangle_eq", "code": "theorem circumsphere_eq_circumsphere_of_eq_of_eq_of_two_zsmul_oangle_eq {t₁ t₂ : Triangle ℝ P}\n {i₁ i₂ i₃ : Fin 3} (h₁₂ : i₁ ≠ i₂) (h₁₃ : i₁ ≠ i₃) (h₂₃ : i₂ ≠ i₃)\n (h₁ : t₁.points i₁ = t₂.points i₁) (h₃ : t₁.points i₃ = t₂.points i₃)\n (h₂ : (2 : ℤ) • ∡ (t₁.points i₁) (t₁.points i₂) (t₁.points i₃) =\n (2 : ℤ) • ∡ (t₂.points i₁) (t₂.points i₂) (t₂.points i₃)) :\n t₁.circumsphere = t₂.circumsphere", "start": [ 311, 1 ], "end": [ 322, 92 ], "kind": "commanddeclaration" }, { "full_name": "Affine.Triangle.mem_circumsphere_of_two_zsmul_oangle_eq", "code": "theorem mem_circumsphere_of_two_zsmul_oangle_eq {t : Triangle ℝ P} {p : P} {i₁ i₂ i₃ : Fin 3}\n (h₁₂ : i₁ ≠ i₂) (h₁₃ : i₁ ≠ i₃) (h₂₃ : i₂ ≠ i₃)\n (h : (2 : ℤ) • ∡ (t.points i₁) p (t.points i₃) =\n (2 : ℤ) • ∡ (t.points i₁) (t.points i₂) (t.points i₃)) : p ∈ t.circumsphere", "start": [ 325, 1 ], "end": [ 349, 37 ], "kind": "commanddeclaration" }, { "full_name": "EuclideanGeometry.cospherical_of_two_zsmul_oangle_eq_of_not_collinear", "code": "theorem cospherical_of_two_zsmul_oangle_eq_of_not_collinear {p₁ p₂ p₃ p₄ : P}\n (h : (2 : ℤ) • ∡ p₁ p₂ p₄ = (2 : ℤ) • ∡ p₁ p₃ p₄) (hn : ¬Collinear ℝ ({p₁, p₂, p₄} : Set P)) :\n Cospherical ({p₁, p₂, p₃, p₄} : Set P)", "start": [ 363, 1 ], "end": [ 379, 30 ], "kind": "commanddeclaration" }, { "full_name": "EuclideanGeometry.concyclic_of_two_zsmul_oangle_eq_of_not_collinear", "code": "theorem concyclic_of_two_zsmul_oangle_eq_of_not_collinear {p₁ p₂ p₃ p₄ : P}\n (h : (2 : ℤ) • ∡ p₁ p₂ p₄ = (2 : ℤ) • ∡ p₁ p₃ p₄) (hn : ¬Collinear ℝ ({p₁, p₂, p₄} : Set P)) :\n Concyclic ({p₁, p₂, p₃, p₄} : Set P)", "start": [ 382, 1 ], "end": [ 387, 96 ], "kind": "commanddeclaration" }, { "full_name": "EuclideanGeometry.cospherical_or_collinear_of_two_zsmul_oangle_eq", "code": "theorem cospherical_or_collinear_of_two_zsmul_oangle_eq {p₁ p₂ p₃ p₄ : P}\n (h : (2 : ℤ) • ∡ p₁ p₂ p₄ = (2 : ℤ) • ∡ p₁ p₃ p₄) :\n Cospherical ({p₁, p₂, p₃, p₄} : Set P) ∨ Collinear ℝ ({p₁, p₂, p₃, p₄} : Set P)", "start": [ 390, 1 ], "end": [ 412, 76 ], "kind": "commanddeclaration" }, { "full_name": "EuclideanGeometry.concyclic_or_collinear_of_two_zsmul_oangle_eq", "code": "theorem concyclic_or_collinear_of_two_zsmul_oangle_eq {p₁ p₂ p₃ p₄ : P}\n (h : (2 : ℤ) • ∡ p₁ p₂ p₄ = (2 : ℤ) • ∡ p₁ p₃ p₄) :\n Concyclic ({p₁, p₂, p₃, p₄} : Set P) ∨ Collinear ℝ ({p₁, p₂, p₃, p₄} : Set P)", "start": [ 415, 1 ], "end": [ 422, 20 ], "kind": "commanddeclaration" } ]

[ "Mathlib/CategoryTheory/Category/Basic.lean", "Mathlib/Combinatorics/Quiver/Symmetric.lean", ".lake/packages/lean4/src/lean/Init.lean", "Mathlib/CategoryTheory/PathCategory.lean", "Mathlib/CategoryTheory/Groupoid.lean", "Mathlib/Tactic/NthRewrite.lean", "Mathlib/CategoryTheory/Functor/Basic.lean", "Mathlib/CategoryTheory/Quotient.lean" ]

[ { "full_name": "Quiver.Hom.toPosPath", "code": "abbrev _root_.Quiver.Hom.toPosPath {X Y : V} (f : X ⟶ Y) :\n (CategoryTheory.Paths.categoryPaths <| Quiver.Symmetrify V).Hom X Y :=\n f.toPos.toPath", "start": [ 55, 1 ], "end": [ 58, 17 ], "kind": "commanddeclaration" }, { "full_name": "Quiver.Hom.toNegPath", "code": "abbrev _root_.Quiver.Hom.toNegPath {X Y : V} (f : X ⟶ Y) :\n (CategoryTheory.Paths.categoryPaths <| Quiver.Symmetrify V).Hom Y X :=\n f.toNeg.toPath", "start": [ 61, 1 ], "end": [ 64, 17 ], "kind": "commanddeclaration" }, { "full_name": "CategoryTheory.Groupoid.Free.redStep", "code": "inductive redStep : HomRel (Paths (Quiver.Symmetrify V))\n | step (X Z : Quiver.Symmetrify V) (f : X ⟶ Z) :\n redStep (𝟙 (Paths.of.obj X)) (f.toPath ≫ (Quiver.reverse f).toPath)", "start": [ 67, 1 ], "end": [ 70, 72 ], "kind": "commanddeclaration" }, { "full_name": "CategoryTheory.FreeGroupoid", "code": "def _root_.CategoryTheory.FreeGroupoid (V) [Q : Quiver V] :=\n Quotient (@redStep V Q)", "start": [ 73, 1 ], "end": [ 75, 26 ], "kind": "commanddeclaration" }, { "full_name": "CategoryTheory.Groupoid.Free.congr_reverse", "code": "theorem congr_reverse {X Y : Paths <| Quiver.Symmetrify V} (p q : X ⟶ Y) :\n Quotient.CompClosure redStep p q → Quotient.CompClosure redStep p.reverse q.reverse", "start": [ 81, 1 ], "end": [ 90, 39 ], "kind": "commanddeclaration" }, { "full_name": "CategoryTheory.Groupoid.Free.congr_comp_reverse", "code": "theorem congr_comp_reverse {X Y : Paths <| Quiver.Symmetrify V} (p : X ⟶ Y) :\n Quot.mk (@Quotient.CompClosure _ _ redStep _ _) (p ≫ p.reverse) =\n Quot.mk (@Quotient.CompClosure _ _ redStep _ _) (𝟙 X)", "start": [ 93, 1 ], "end": [ 117, 15 ], "kind": "commanddeclaration" }, { "full_name": "CategoryTheory.Groupoid.Free.congr_reverse_comp", "code": "theorem congr_reverse_comp {X Y : Paths <| Quiver.Symmetrify V} (p : X ⟶ Y) :\n Quot.mk (@Quotient.CompClosure _ _ redStep _ _) (p.reverse ≫ p) =\n Quot.mk (@Quotient.CompClosure _ _ redStep _ _) (𝟙 Y)", "start": [ 120, 1 ], "end": [ 124, 27 ], "kind": "commanddeclaration" }, { "full_name": "CategoryTheory.Groupoid.Free.quotInv", "code": "def quotInv {X Y : FreeGroupoid V} (f : X ⟶ Y) : Y ⟶ X :=\n Quot.liftOn f (fun pp => Quot.mk _ <| pp.reverse) fun pp qq con =>\n Quot.sound <| congr_reverse pp qq con", "start": [ 130, 1 ], "end": [ 133, 42 ], "kind": "commanddeclaration" }, { "full_name": "CategoryTheory.FreeGroupoid.instGroupoid", "code": "instance _root_.CategoryTheory.FreeGroupoid.instGroupoid : Groupoid (FreeGroupoid V) where\n inv := quotInv\n inv_comp p := Quot.inductionOn p fun pp => congr_reverse_comp pp\n comp_inv p := Quot.inductionOn p fun pp => congr_comp_reverse pp", "start": [ 136, 1 ], "end": [ 139, 67 ], "kind": "commanddeclaration" }, { "full_name": "CategoryTheory.Groupoid.Free.of", "code": "def of (V) [Quiver V] : V ⥤q FreeGroupoid V where\n obj X := ⟨X⟩\n map f := Quot.mk _ f.toPosPath", "start": [ 142, 1 ], "end": [ 145, 33 ], "kind": "commanddeclaration" }, { "full_name": "CategoryTheory.Groupoid.Free.of_eq", "code": "theorem of_eq :\n of V = (Quiver.Symmetrify.of ⋙q Paths.of).comp\n (Quotient.functor <| @redStep V _).toPrefunctor", "start": [ 148, 1 ], "end": [ 150, 61 ], "kind": "commanddeclaration" }, { "full_name": "CategoryTheory.Groupoid.Free.lift", "code": "def lift (φ : V ⥤q V') : FreeGroupoid V ⥤ V' :=\n Quotient.lift _ (Paths.lift <| Quiver.Symmetrify.lift φ) <| by\n rintro _ _ _ _ ⟨X, Y, f⟩\n erw [Paths.lift_nil, Paths.lift_cons, Quiver.Path.comp_nil, Paths.lift_toPath,\n Quiver.Symmetrify.lift_reverse]\n symm\n apply Groupoid.comp_inv", "start": [ 157, 1 ], "end": [ 165, 28 ], "kind": "commanddeclaration" }, { "full_name": "CategoryTheory.Groupoid.Free.lift_spec", "code": "theorem lift_spec (φ : V ⥤q V') : of V ⋙q (lift φ).toPrefunctor = φ", "start": [ 168, 1 ], "end": [ 171, 72 ], "kind": "commanddeclaration" }, { "full_name": "CategoryTheory.Groupoid.Free.lift_unique", "code": "theorem lift_unique (φ : V ⥤q V') (Φ : FreeGroupoid V ⥤ V') (hΦ : of V ⋙q Φ.toPrefunctor = φ) :\n Φ = lift φ", "start": [ 174, 1 ], "end": [ 186, 44 ], "kind": "commanddeclaration" }, { "full_name": "CategoryTheory.freeGroupoidFunctor", "code": "def _root_.CategoryTheory.freeGroupoidFunctor (φ : V ⥤q V') : FreeGroupoid V ⥤ FreeGroupoid V' :=\n lift (φ ⋙q of V')", "start": [ 195, 1 ], "end": [ 197, 20 ], "kind": "commanddeclaration" }, { "full_name": "CategoryTheory.Groupoid.Free.freeGroupoidFunctor_id", "code": "theorem freeGroupoidFunctor_id :\n freeGroupoidFunctor (Prefunctor.id V) = Functor.id (FreeGroupoid V)", "start": [ 200, 1 ], "end": [ 203, 25 ], "kind": "commanddeclaration" }, { "full_name": "CategoryTheory.Groupoid.Free.freeGroupoidFunctor_comp", "code": "theorem freeGroupoidFunctor_comp (φ : V ⥤q V') (φ' : V' ⥤q V'') :\n freeGroupoidFunctor (φ ⋙q φ') = freeGroupoidFunctor φ ⋙ freeGroupoidFunctor φ'", "start": [ 206, 1 ], "end": [ 209, 25 ], "kind": "commanddeclaration" } ]

[ ".lake/packages/lean4/src/lean/Lean/LocalContext.lean", ".lake/packages/lean4/src/lean/Init.lean" ]

[ { "full_name": "Lean.LocalContext.firstDeclM", "code": "@[specialize] def firstDeclM (lctx : LocalContext) (f : LocalDecl → m β) : m β :=\n do match (← lctx.findDeclM? (optional ∘ f)) with\n | none => failure\n | some b => pure b", "start": [ 14, 1 ], "end": [ 18, 21 ], "kind": "commanddeclaration" }, { "full_name": "Lean.LocalContext.lastDeclM", "code": "@[specialize] def lastDeclM (lctx : LocalContext) (f : LocalDecl → m β) : m β :=\n do match (← lctx.findDeclRevM? (optional ∘ f)) with\n | none => failure\n | some b => pure b", "start": [ 20, 1 ], "end": [ 24, 21 ], "kind": "commanddeclaration" } ]

[ ".lake/packages/lean4/src/lean/Init.lean", "Mathlib/Algebra/Homology/Additive.lean", "Mathlib/CategoryTheory/Abelian/InjectiveResolution.lean", "Mathlib/CategoryTheory/Abelian/Homology.lean" ]

[ { "full_name": "CategoryTheory.Functor.rightDerivedToHomotopyCategory", "code": "noncomputable def Functor.rightDerivedToHomotopyCategory (F : C ⥤ D) [F.Additive] :\n C ⥤ HomotopyCategory D (ComplexShape.up ℕ) :=\n injectiveResolutions C ⋙ F.mapHomotopyCategory _", "start": [ 61, 1 ], "end": [ 66, 51 ], "kind": "commanddeclaration" }, { "full_name": "CategoryTheory.InjectiveResolution.isoRightDerivedToHomotopyCategoryObj", "code": "noncomputable def InjectiveResolution.isoRightDerivedToHomotopyCategoryObj {X : C}\n (I : InjectiveResolution X) (F : C ⥤ D) [F.Additive] :\n F.rightDerivedToHomotopyCategory.obj X ≅\n (F.mapHomologicalComplex _ ⋙ HomotopyCategory.quotient _ _).obj I.cocomplex :=\n (F.mapHomotopyCategory _).mapIso I.iso ≪≫\n (F.mapHomotopyCategoryFactors _).app I.cocomplex", "start": [ 68, 1 ], "end": [ 76, 53 ], "kind": "commanddeclaration" }, { "full_name": "CategoryTheory.InjectiveResolution.isoRightDerivedToHomotopyCategoryObj_hom_naturality", "code": "@[reassoc]\nlemma InjectiveResolution.isoRightDerivedToHomotopyCategoryObj_hom_naturality\n {X Y : C} (f : X ⟶ Y) (I : InjectiveResolution X) (J : InjectiveResolution Y)\n (φ : I.cocomplex ⟶ J.cocomplex) (comm : I.ι.f 0 ≫ φ.f 0 = f ≫ J.ι.f 0)\n (F : C ⥤ D) [F.Additive] :\n F.rightDerivedToHomotopyCategory.map f ≫ (J.isoRightDerivedToHomotopyCategoryObj F).hom =\n (I.isoRightDerivedToHomotopyCategoryObj F).hom ≫\n (F.mapHomologicalComplex _ ⋙ HomotopyCategory.quotient _ _).map φ := by\n dsimp [Functor.rightDerivedToHomotopyCategory, isoRightDerivedToHomotopyCategoryObj]\n rw [← Functor.map_comp_assoc, iso_hom_naturality f I J φ comm, Functor.map_comp,\n assoc, assoc]\n erw [(F.mapHomotopyCategoryFactors (ComplexShape.up ℕ)).hom.naturality]\n rfl", "start": [ 78, 1 ], "end": [ 90, 6 ], "kind": "lemma" }, { "full_name": "CategoryTheory.InjectiveResolution.isoRightDerivedToHomotopyCategoryObj_inv_naturality", "code": "@[reassoc]\nlemma InjectiveResolution.isoRightDerivedToHomotopyCategoryObj_inv_naturality\n {X Y : C} (f : X ⟶ Y) (I : InjectiveResolution X) (J : InjectiveResolution Y)\n (φ : I.cocomplex ⟶ J.cocomplex) (comm : I.ι.f 0 ≫ φ.f 0 = f ≫ J.ι.f 0)\n (F : C ⥤ D) [F.Additive] :\n (I.isoRightDerivedToHomotopyCategoryObj F).inv ≫ F.rightDerivedToHomotopyCategory.map f =\n (F.mapHomologicalComplex _ ⋙ HomotopyCategory.quotient _ _).map φ ≫\n (J.isoRightDerivedToHomotopyCategoryObj F).inv := by\n rw [← cancel_epi (I.isoRightDerivedToHomotopyCategoryObj F).hom, Iso.hom_inv_id_assoc]\n dsimp\n rw [← isoRightDerivedToHomotopyCategoryObj_hom_naturality_assoc f I J φ comm F,\n Iso.hom_inv_id, comp_id]", "start": [ 92, 1 ], "end": [ 103, 31 ], "kind": "lemma" }, { "full_name": "CategoryTheory.Functor.rightDerived", "code": "noncomputable def Functor.rightDerived (F : C ⥤ D) [F.Additive] (n : ℕ) : C ⥤ D :=\n F.rightDerivedToHomotopyCategory ⋙ HomotopyCategory.homologyFunctor D _ n", "start": [ 105, 1 ], "end": [ 107, 76 ], "kind": "commanddeclaration" }, { "full_name": "CategoryTheory.InjectiveResolution.isoRightDerivedObj", "code": "noncomputable def InjectiveResolution.isoRightDerivedObj {X : C} (I : InjectiveResolution X)\n (F : C ⥤ D) [F.Additive] (n : ℕ) :\n (F.rightDerived n).obj X ≅\n (HomologicalComplex.homologyFunctor D _ n).obj\n ((F.mapHomologicalComplex _).obj I.cocomplex) :=\n (HomotopyCategory.homologyFunctor D _ n).mapIso\n (I.isoRightDerivedToHomotopyCategoryObj F) ≪≫\n (HomotopyCategory.homologyFunctorFactors D (ComplexShape.up ℕ) n).app _", "start": [ 110, 1 ], "end": [ 118, 76 ], "kind": "commanddeclaration" }, { "full_name": "CategoryTheory.InjectiveResolution.isoRightDerivedObj_hom_naturality", "code": "@[reassoc]\nlemma InjectiveResolution.isoRightDerivedObj_hom_naturality\n {X Y : C} (f : X ⟶ Y) (I : InjectiveResolution X) (J : InjectiveResolution Y)\n (φ : I.cocomplex ⟶ J.cocomplex) (comm : I.ι.f 0 ≫ φ.f 0 = f ≫ J.ι.f 0)\n (F : C ⥤ D) [F.Additive] (n : ℕ) :\n (F.rightDerived n).map f ≫ (J.isoRightDerivedObj F n).hom =\n (I.isoRightDerivedObj F n).hom ≫\n (F.mapHomologicalComplex _ ⋙ HomologicalComplex.homologyFunctor _ _ n).map φ := by\n dsimp [isoRightDerivedObj, Functor.rightDerived]\n rw [assoc, ← Functor.map_comp_assoc,\n InjectiveResolution.isoRightDerivedToHomotopyCategoryObj_hom_naturality f I J φ comm F,\n Functor.map_comp, assoc]\n erw [(HomotopyCategory.homologyFunctorFactors D (ComplexShape.up ℕ) n).hom.naturality]\n rfl", "start": [ 120, 1 ], "end": [ 133, 6 ], "kind": "lemma" }, { "full_name": "CategoryTheory.InjectiveResolution.isoRightDerivedObj_inv_naturality", "code": "@[reassoc]\nlemma InjectiveResolution.isoRightDerivedObj_inv_naturality\n {X Y : C} (f : X ⟶ Y) (I : InjectiveResolution X) (J : InjectiveResolution Y)\n (φ : I.cocomplex ⟶ J.cocomplex) (comm : I.ι.f 0 ≫ φ.f 0 = f ≫ J.ι.f 0)\n (F : C ⥤ D) [F.Additive] (n : ℕ) :\n (I.isoRightDerivedObj F n).inv ≫ (F.rightDerived n).map f =\n (F.mapHomologicalComplex _ ⋙ HomologicalComplex.homologyFunctor _ _ n).map φ ≫\n (J.isoRightDerivedObj F n).inv := by\n rw [← cancel_mono (J.isoRightDerivedObj F n).hom, assoc, assoc,\n InjectiveResolution.isoRightDerivedObj_hom_naturality f I J φ comm F n,\n Iso.inv_hom_id_assoc, Iso.inv_hom_id, comp_id]", "start": [ 135, 1 ], "end": [ 145, 51 ], "kind": "lemma" }, { "full_name": "CategoryTheory.Functor.isZero_rightDerived_obj_injective_succ", "code": "lemma Functor.isZero_rightDerived_obj_injective_succ\n (F : C ⥤ D) [F.Additive] (n : ℕ) (X : C) [Injective X] :\n IsZero ((F.rightDerived (n+1)).obj X) := by\n refine IsZero.of_iso ?_ ((InjectiveResolution.self X).isoRightDerivedObj F (n + 1))\n erw [← HomologicalComplex.exactAt_iff_isZero_homology]\n exact ShortComplex.exact_of_isZero_X₂ _ (F.map_isZero (by apply isZero_zero))", "start": [ 147, 1 ], "end": [ 153, 80 ], "kind": "lemma" }, { "full_name": "CategoryTheory.Functor.rightDerived_map_eq", "code": "theorem Functor.rightDerived_map_eq (F : C ⥤ D) [F.Additive] (n : ℕ) {X Y : C} (f : X ⟶ Y)\n {P : InjectiveResolution X} {Q : InjectiveResolution Y} (g : P.cocomplex ⟶ Q.cocomplex)\n (w : P.ι ≫ g = (CochainComplex.single₀ C).map f ≫ Q.ι) :\n (F.rightDerived n).map f =\n (P.isoRightDerivedObj F n).hom ≫\n (F.mapHomologicalComplex _ ⋙ HomologicalComplex.homologyFunctor _ _ n).map g ≫\n (Q.isoRightDerivedObj F n).inv", "start": [ 155, 1 ], "end": [ 169, 39 ], "kind": "commanddeclaration" }, { "full_name": "CategoryTheory.NatTrans.rightDerivedToHomotopyCategory", "code": "noncomputable def NatTrans.rightDerivedToHomotopyCategory\n {F G : C ⥤ D} [F.Additive] [G.Additive] (α : F ⟶ G) :\n F.rightDerivedToHomotopyCategory ⟶ G.rightDerivedToHomotopyCategory :=\n whiskerLeft _ (NatTrans.mapHomotopyCategory α (ComplexShape.up ℕ))", "start": [ 172, 1 ], "end": [ 178, 69 ], "kind": "commanddeclaration" }, { "full_name": "CategoryTheory.InjectiveResolution.rightDerivedToHomotopyCategory_app_eq", "code": "lemma InjectiveResolution.rightDerivedToHomotopyCategory_app_eq\n {F G : C ⥤ D} [F.Additive] [G.Additive] (α : F ⟶ G) {X : C} (P : InjectiveResolution X) :\n (NatTrans.rightDerivedToHomotopyCategory α).app X =\n (P.isoRightDerivedToHomotopyCategoryObj F).hom ≫\n (HomotopyCategory.quotient _ _).map\n ((NatTrans.mapHomologicalComplex α _).app P.cocomplex) ≫\n (P.isoRightDerivedToHomotopyCategoryObj G).inv := by\n rw [← cancel_mono (P.isoRightDerivedToHomotopyCategoryObj G).hom, assoc, assoc,\n Iso.inv_hom_id, comp_id]\n dsimp [isoRightDerivedToHomotopyCategoryObj, Functor.mapHomotopyCategoryFactors,\n NatTrans.rightDerivedToHomotopyCategory]\n rw [assoc]\n erw [id_comp, comp_id]\n obtain ⟨β, hβ⟩ := (HomotopyCategory.quotient _ _).map_surjective (iso P).hom\n rw [← hβ]\n dsimp\n simp only [← Functor.map_comp, NatTrans.mapHomologicalComplex_naturality]\n rfl", "start": [ 180, 1 ], "end": [ 197, 6 ], "kind": "lemma" }, { "full_name": "CategoryTheory.NatTrans.rightDerivedToHomotopyCategory_id", "code": "@[simp]\nlemma NatTrans.rightDerivedToHomotopyCategory_id (F : C ⥤ D) [F.Additive] :\n NatTrans.rightDerivedToHomotopyCategory (𝟙 F) = 𝟙 _ := rfl", "start": [ 199, 1 ], "end": [ 201, 63 ], "kind": "lemma" }, { "full_name": "CategoryTheory.NatTrans.rightDerivedToHomotopyCategory_comp", "code": "@[simp, reassoc]\nlemma NatTrans.rightDerivedToHomotopyCategory_comp {F G H : C ⥤ D} (α : F ⟶ G) (β : G ⟶ H)\n [F.Additive] [G.Additive] [H.Additive] :\n NatTrans.rightDerivedToHomotopyCategory (α ≫ β) =\n NatTrans.rightDerivedToHomotopyCategory α ≫\n NatTrans.rightDerivedToHomotopyCategory β := rfl", "start": [ 203, 1 ], "end": [ 208, 57 ], "kind": "lemma" }, { "full_name": "CategoryTheory.NatTrans.rightDerived", "code": "noncomputable def NatTrans.rightDerived\n {F G : C ⥤ D} [F.Additive] [G.Additive] (α : F ⟶ G) (n : ℕ) :\n F.rightDerived n ⟶ G.rightDerived n :=\n whiskerRight (NatTrans.rightDerivedToHomotopyCategory α) _", "start": [ 210, 1 ], "end": [ 215, 61 ], "kind": "commanddeclaration" }, { "full_name": "CategoryTheory.NatTrans.rightDerived_id", "code": "@[simp]\ntheorem NatTrans.rightDerived_id (F : C ⥤ D) [F.Additive] (n : ℕ) :\n NatTrans.rightDerived (𝟙 F) n = 𝟙 (F.rightDerived n)", "start": [ 218, 1 ], "end": [ 223, 6 ], "kind": "commanddeclaration" }, { "full_name": "CategoryTheory.NatTrans.rightDerived_comp", "code": "@[simp, reassoc]\ntheorem NatTrans.rightDerived_comp {F G H : C ⥤ D} [F.Additive] [G.Additive] [H.Additive]\n (α : F ⟶ G) (β : G ⟶ H) (n : ℕ) :\n NatTrans.rightDerived (α ≫ β) n = NatTrans.rightDerived α n ≫ NatTrans.rightDerived β n", "start": [ 226, 1 ], "end": [ 230, 31 ], "kind": "commanddeclaration" }, { "full_name": "CategoryTheory.InjectiveResolution.rightDerived_app_eq", "code": "lemma rightDerived_app_eq\n {F G : C ⥤ D} [F.Additive] [G.Additive] (α : F ⟶ G) {X : C} (P : InjectiveResolution X)\n (n : ℕ) : (NatTrans.rightDerived α n).app X =\n (P.isoRightDerivedObj F n).hom ≫\n (HomologicalComplex.homologyFunctor D (ComplexShape.up ℕ) n).map\n ((NatTrans.mapHomologicalComplex α _).app P.cocomplex) ≫\n (P.isoRightDerivedObj G n).inv := by\n dsimp [NatTrans.rightDerived, isoRightDerivedObj]\n rw [InjectiveResolution.rightDerivedToHomotopyCategory_app_eq α P,\n Functor.map_comp, Functor.map_comp, assoc]\n erw [← (HomotopyCategory.homologyFunctorFactors D (ComplexShape.up ℕ) n).hom.naturality_assoc\n ((NatTrans.mapHomologicalComplex α (ComplexShape.up ℕ)).app P.cocomplex)]\n simp only [Functor.comp_map, Iso.hom_inv_id_app_assoc]", "start": [ 235, 1 ], "end": [ 249, 57 ], "kind": "lemma" }, { "full_name": "CategoryTheory.InjectiveResolution.toRightDerivedZero'", "code": "noncomputable def toRightDerivedZero' {X : C}\n (P : InjectiveResolution X) (F : C ⥤ D) [F.Additive] :\n F.obj X ⟶ ((F.mapHomologicalComplex _).obj P.cocomplex).cycles 0 :=\n HomologicalComplex.liftCycles _ (F.map (P.ι.f 0)) 1 (by simp) (by\n dsimp\n rw [← F.map_comp, HomologicalComplex.Hom.comm, HomologicalComplex.single_obj_d,\n zero_comp, F.map_zero])", "start": [ 251, 1 ], "end": [ 260, 30 ], "kind": "commanddeclaration" }, { "full_name": "CategoryTheory.InjectiveResolution.toRightDerivedZero'_comp_iCycles", "code": "@[reassoc (attr := simp)]\nlemma toRightDerivedZero'_comp_iCycles {X : C}\n (P : InjectiveResolution X) (F : C ⥤ D) [F.Additive] :\n P.toRightDerivedZero' F ≫\n HomologicalComplex.iCycles _ _ = F.map (P.ι.f 0) := by\n simp [toRightDerivedZero']", "start": [ 262, 1 ], "end": [ 267, 29 ], "kind": "lemma" }, { "full_name": "CategoryTheory.InjectiveResolution.toRightDerivedZero'_naturality", "code": "@[reassoc]\nlemma toRightDerivedZero'_naturality {X Y : C} (f : X ⟶ Y)\n (P : InjectiveResolution X) (Q : InjectiveResolution Y)\n (φ : P.cocomplex ⟶ Q.cocomplex) (comm : P.ι.f 0 ≫ φ.f 0 = f ≫ Q.ι.f 0)\n (F : C ⥤ D) [F.Additive] :\n F.map f ≫ Q.toRightDerivedZero' F =\n P.toRightDerivedZero' F ≫\n HomologicalComplex.cyclesMap ((F.mapHomologicalComplex _).map φ) 0 := by\n simp only [← cancel_mono (HomologicalComplex.iCycles _ _),\n Functor.mapHomologicalComplex_obj_X, assoc, toRightDerivedZero'_comp_iCycles,\n CochainComplex.single₀_obj_zero, HomologicalComplex.cyclesMap_i,\n Functor.mapHomologicalComplex_map_f, toRightDerivedZero'_comp_iCycles_assoc,\n ← F.map_comp, comm]", "start": [ 269, 1 ], "end": [ 281, 24 ], "kind": "lemma" }, { "full_name": "CategoryTheory.Functor.toRightDerivedZero", "code": "noncomputable def Functor.toRightDerivedZero (F : C ⥤ D) [F.Additive] :\n F ⟶ F.rightDerived 0 where\n app X := (injectiveResolution X).toRightDerivedZero' F ≫\n (CochainComplex.isoHomologyπ₀ _).hom ≫\n (HomotopyCategory.homologyFunctorFactors D (ComplexShape.up ℕ) 0).inv.app _\n naturality {X Y} f := by\n dsimp [rightDerived]\n rw [assoc, assoc, InjectiveResolution.toRightDerivedZero'_naturality_assoc f\n (injectiveResolution X) (injectiveResolution Y)\n (InjectiveResolution.desc f _ _) (by simp),\n ← HomologicalComplex.homologyπ_naturality_assoc]\n erw [← NatTrans.naturality]\n rfl", "start": [ 295, 1 ], "end": [ 308, 8 ], "kind": "commanddeclaration" }, { "full_name": "CategoryTheory.InjectiveResolution.toRightDerivedZero_eq", "code": "lemma InjectiveResolution.toRightDerivedZero_eq\n {X : C} (I : InjectiveResolution X) (F : C ⥤ D) [F.Additive] :\n F.toRightDerivedZero.app X = I.toRightDerivedZero' F ≫\n (CochainComplex.isoHomologyπ₀ _).hom ≫ (I.isoRightDerivedObj F 0).inv := by\n dsimp [Functor.toRightDerivedZero, isoRightDerivedObj]\n have h₁ := InjectiveResolution.toRightDerivedZero'_naturality\n (𝟙 X) (injectiveResolution X) I (desc (𝟙 X) _ _) (by simp) F\n simp only [Functor.map_id, id_comp] at h₁\n have h₂ : (I.isoRightDerivedToHomotopyCategoryObj F).hom =\n (F.mapHomologicalComplex _ ⋙ HomotopyCategory.quotient _ _).map (desc (𝟙 X) _ _) :=\n comp_id _\n rw [← cancel_mono ((HomotopyCategory.homologyFunctor _ _ 0).map\n (I.isoRightDerivedToHomotopyCategoryObj F).hom),\n assoc, assoc, assoc, assoc, assoc, ← Functor.map_comp,\n Iso.inv_hom_id, Functor.map_id, comp_id,\n reassoc_of% h₁, h₂, ← HomologicalComplex.homologyπ_naturality_assoc]\n erw [← NatTrans.naturality]\n rfl", "start": [ 310, 1 ], "end": [ 327, 6 ], "kind": "lemma" }, { "full_name": "CategoryTheory.Functor.rightDerivedZeroIsoSelf", "code": "@[simps! inv]\nnoncomputable def rightDerivedZeroIsoSelf : F.rightDerived 0 ≅ F :=\n (asIso F.toRightDerivedZero).symm", "start": [ 353, 1 ], "end": [ 357, 36 ], "kind": "commanddeclaration" }, { "full_name": "CategoryTheory.Functor.rightDerivedZeroIsoSelf_hom_inv_id", "code": "@[reassoc (attr := simp)]\nlemma rightDerivedZeroIsoSelf_hom_inv_id :\n F.rightDerivedZeroIsoSelf.hom ≫ F.toRightDerivedZero = 𝟙 _ :=\n F.rightDerivedZeroIsoSelf.hom_inv_id", "start": [ 359, 1 ], "end": [ 362, 39 ], "kind": "lemma" }, { "full_name": "CategoryTheory.Functor.rightDerivedZeroIsoSelf_inv_hom_id", "code": "@[reassoc (attr := simp)]\nlemma rightDerivedZeroIsoSelf_inv_hom_id :\n F.toRightDerivedZero ≫ F.rightDerivedZeroIsoSelf.hom = 𝟙 _ :=\n F.rightDerivedZeroIsoSelf.inv_hom_id", "start": [ 364, 1 ], "end": [ 367, 39 ], "kind": "lemma" }, { "full_name": "CategoryTheory.Functor.rightDerivedZeroIsoSelf_hom_inv_id_app", "code": "@[reassoc (attr := simp)]\nlemma rightDerivedZeroIsoSelf_hom_inv_id_app (X : C) :\n F.rightDerivedZeroIsoSelf.hom.app X ≫ F.toRightDerivedZero.app X = 𝟙 _ :=\n F.rightDerivedZeroIsoSelf.hom_inv_id_app X", "start": [ 369, 1 ], "end": [ 372, 45 ], "kind": "lemma" }, { "full_name": "CategoryTheory.Functor.rightDerivedZeroIsoSelf_inv_hom_id_app", "code": "@[reassoc (attr := simp)]\nlemma rightDerivedZeroIsoSelf_inv_hom_id_app (X : C) :\n F.toRightDerivedZero.app X ≫ F.rightDerivedZeroIsoSelf.hom.app X = 𝟙 _ :=\n F.rightDerivedZeroIsoSelf.inv_hom_id_app X", "start": [ 374, 1 ], "end": [ 377, 45 ], "kind": "lemma" } ]

[ "Mathlib/Algebra/Algebra/Subalgebra/Basic.lean", ".lake/packages/lean4/src/lean/Init.lean", "Mathlib/Algebra/Ring/Subring/MulOpposite.lean" ]

[ { "full_name": "Subalgebra.op", "code": "@[simps toSubsemiring]\nprotected def op (S : Subalgebra R A) : Subalgebra R Aᵐᵒᵖ where\n toSubsemiring := S.toSubsemiring.op\n algebraMap_mem' := S.algebraMap_mem", "start": [ 24, 1 ], "end": [ 28, 38 ], "kind": "commanddeclaration" }, { "full_name": "Subalgebra.op_coe", "code": "@[simp, norm_cast]\ntheorem op_coe (S : Subalgebra R A) : S.op = MulOpposite.unop ⁻¹' (S : Set A)", "start": [ 30, 1 ], "end": [ 31, 85 ], "kind": "commanddeclaration" }, { "full_name": "Subalgebra.mem_op", "code": "@[simp]\ntheorem mem_op {x : Aᵐᵒᵖ} {S : Subalgebra R A} : x ∈ S.op ↔ x.unop ∈ S", "start": [ 33, 1 ], "end": [ 34, 82 ], "kind": "commanddeclaration" }, { "full_name": "Subalgebra.unop", "code": "@[simps toSubsemiring]\nprotected def unop (S : Subalgebra R Aᵐᵒᵖ) : Subalgebra R A where\n toSubsemiring := S.toSubsemiring.unop\n algebraMap_mem' := S.algebraMap_mem", "start": [ 36, 1 ], "end": [ 40, 38 ], "kind": "commanddeclaration" }, { "full_name": "Subalgebra.unop_coe", "code": "@[simp, norm_cast]\ntheorem unop_coe (S : Subalgebra R Aᵐᵒᵖ) : S.unop = MulOpposite.op ⁻¹' (S : Set Aᵐᵒᵖ)", "start": [ 42, 1 ], "end": [ 43, 93 ], "kind": "commanddeclaration" }, { "full_name": "Subalgebra.mem_unop", "code": "@[simp]\ntheorem mem_unop {x : A} {S : Subalgebra R Aᵐᵒᵖ} : x ∈ S.unop ↔ MulOpposite.op x ∈ S", "start": [ 45, 1 ], "end": [ 46, 96 ], "kind": "commanddeclaration" }, { "full_name": "Subalgebra.unop_op", "code": "@[simp]\ntheorem unop_op (S : Subalgebra R A) : S.op.unop = S", "start": [ 48, 1 ], "end": [ 49, 60 ], "kind": "commanddeclaration" }, { "full_name": "Subalgebra.op_unop", "code": "@[simp]\ntheorem op_unop (S : Subalgebra R Aᵐᵒᵖ) : S.unop.op = S", "start": [ 51, 1 ], "end": [ 52, 63 ], "kind": "commanddeclaration" }, { "full_name": "Subalgebra.op_le_iff", "code": "theorem op_le_iff {S₁ : Subalgebra R A} {S₂ : Subalgebra R Aᵐᵒᵖ} : S₁.op ≤ S₂ ↔ S₁ ≤ S₂.unop", "start": [ 56, 1 ], "end": [ 57, 35 ], "kind": "commanddeclaration" }, { "full_name": "Subalgebra.le_op_iff", "code": "theorem le_op_iff {S₁ : Subalgebra R Aᵐᵒᵖ} {S₂ : Subalgebra R A} : S₁ ≤ S₂.op ↔ S₁.unop ≤ S₂", "start": [ 59, 1 ], "end": [ 60, 35 ], "kind": "commanddeclaration" }, { "full_name": "Subalgebra.op_le_op_iff", "code": "@[simp]\ntheorem op_le_op_iff {S₁ S₂ : Subalgebra R A} : S₁.op ≤ S₂.op ↔ S₁ ≤ S₂", "start": [ 62, 1 ], "end": [ 64, 35 ], "kind": "commanddeclaration" }, { "full_name": "Subalgebra.unop_le_unop_iff", "code": "@[simp]\ntheorem unop_le_unop_iff {S₁ S₂ : Subalgebra R Aᵐᵒᵖ} : S₁.unop ≤ S₂.unop ↔ S₁ ≤ S₂", "start": [ 66, 1 ], "end": [ 68, 37 ], "kind": "commanddeclaration" }, { "full_name": "Subalgebra.opEquiv", "code": "@[simps]\ndef opEquiv : Subalgebra R A ≃o Subalgebra R Aᵐᵒᵖ where\n toFun := Subalgebra.op\n invFun := Subalgebra.unop\n left_inv := unop_op\n right_inv := op_unop\n map_rel_iff' := op_le_op_iff", "start": [ 70, 1 ], "end": [ 77, 31 ], "kind": "commanddeclaration" }, { "full_name": "Subalgebra.op_bot", "code": "@[simp]\ntheorem op_bot : (⊥ : Subalgebra R A).op = ⊥", "start": [ 79, 1 ], "end": [ 80, 64 ], "kind": "commanddeclaration" }, { "full_name": "Subalgebra.unop_bot", "code": "@[simp]\ntheorem unop_bot : (⊥ : Subalgebra R Aᵐᵒᵖ).unop = ⊥", "start": [ 82, 1 ], "end": [ 83, 76 ], "kind": "commanddeclaration" }, { "full_name": "Subalgebra.op_top", "code": "@[simp]\ntheorem op_top : (⊤ : Subalgebra R A).op = ⊤", "start": [ 85, 1 ], "end": [ 86, 64 ], "kind": "commanddeclaration" }, { "full_name": "Subalgebra.unop_top", "code": "@[simp]\ntheorem unop_top : (⊤ : Subalgebra R Aᵐᵒᵖ).unop = ⊤", "start": [ 88, 1 ], "end": [ 89, 76 ], "kind": "commanddeclaration" }, { "full_name": "Subalgebra.op_sup", "code": "theorem op_sup (S₁ S₂ : Subalgebra R A) : (S₁ ⊔ S₂).op = S₁.op ⊔ S₂.op", "start": [ 91, 1 ], "end": [ 92, 22 ], "kind": "commanddeclaration" }, { "full_name": "Subalgebra.unop_sup", "code": "theorem unop_sup (S₁ S₂ : Subalgebra R Aᵐᵒᵖ) : (S₁ ⊔ S₂).unop = S₁.unop ⊔ S₂.unop", "start": [ 94, 1 ], "end": [ 95, 27 ], "kind": "commanddeclaration" }, { "full_name": "Subalgebra.op_inf", "code": "theorem op_inf (S₁ S₂ : Subalgebra R A) : (S₁ ⊓ S₂).op = S₁.op ⊓ S₂.op", "start": [ 97, 1 ], "end": [ 97, 94 ], "kind": "commanddeclaration" }, { "full_name": "Subalgebra.unop_inf", "code": "theorem unop_inf (S₁ S₂ : Subalgebra R Aᵐᵒᵖ) : (S₁ ⊓ S₂).unop = S₁.unop ⊓ S₂.unop", "start": [ 99, 1 ], "end": [ 100, 27 ], "kind": "commanddeclaration" }, { "full_name": "Subalgebra.op_sSup", "code": "theorem op_sSup (S : Set (Subalgebra R A)) : (sSup S).op = sSup (.unop ⁻¹' S)", "start": [ 102, 1 ], "end": [ 103, 43 ], "kind": "commanddeclaration" }, { "full_name": "Subalgebra.unop_sSup", "code": "theorem unop_sSup (S : Set (Subalgebra R Aᵐᵒᵖ)) : (sSup S).unop = sSup (.op ⁻¹' S)", "start": [ 105, 1 ], "end": [ 106, 48 ], "kind": "commanddeclaration" }, { "full_name": "Subalgebra.op_sInf", "code": "theorem op_sInf (S : Set (Subalgebra R A)) : (sInf S).op = sInf (.unop ⁻¹' S)", "start": [ 108, 1 ], "end": [ 109, 43 ], "kind": "commanddeclaration" }, { "full_name": "Subalgebra.unop_sInf", "code": "theorem unop_sInf (S : Set (Subalgebra R Aᵐᵒᵖ)) : (sInf S).unop = sInf (.op ⁻¹' S)", "start": [ 111, 1 ], "end": [ 112, 48 ], "kind": "commanddeclaration" }, { "full_name": "Subalgebra.op_iSup", "code": "theorem op_iSup (S : ι → Subalgebra R A) : (iSup S).op = ⨆ i, (S i).op", "start": [ 114, 1 ], "end": [ 114, 93 ], "kind": "commanddeclaration" }, { "full_name": "Subalgebra.unop_iSup", "code": "theorem unop_iSup (S : ι → Subalgebra R Aᵐᵒᵖ) : (iSup S).unop = ⨆ i, (S i).unop", "start": [ 116, 1 ], "end": [ 117, 26 ], "kind": "commanddeclaration" }, { "full_name": "Subalgebra.op_iInf", "code": "theorem op_iInf (S : ι → Subalgebra R A) : (iInf S).op = ⨅ i, (S i).op", "start": [ 119, 1 ], "end": [ 119, 93 ], "kind": "commanddeclaration" }, { "full_name": "Subalgebra.unop_iInf", "code": "theorem unop_iInf (S : ι → Subalgebra R Aᵐᵒᵖ) : (iInf S).unop = ⨅ i, (S i).unop", "start": [ 121, 1 ], "end": [ 122, 26 ], "kind": "commanddeclaration" }, { "full_name": "Subalgebra.op_adjoin", "code": "theorem op_adjoin (s : Set A) :\n (Algebra.adjoin R s).op = Algebra.adjoin R (MulOpposite.unop ⁻¹' s)", "start": [ 124, 1 ], "end": [ 131, 76 ], "kind": "commanddeclaration" }, { "full_name": "Subalgebra.unop_adjoin", "code": "theorem unop_adjoin (s : Set Aᵐᵒᵖ) :\n (Algebra.adjoin R s).unop = Algebra.adjoin R (MulOpposite.op ⁻¹' s)", "start": [ 133, 1 ], "end": [ 138, 7 ], "kind": "commanddeclaration" }, { "full_name": "Subalgebra.linearEquivOp", "code": "@[simps!]\ndef linearEquivOp (S : Subalgebra R A) : S ≃ₗ[R] S.op where\n __ := S.toSubsemiring.addEquivOp\n map_smul' _ _ := rfl", "start": [ 140, 1 ], "end": [ 144, 23 ], "kind": "commanddeclaration" }, { "full_name": "Subalgebra.algEquivOpMop", "code": "@[simps!]\ndef algEquivOpMop (S : Subalgebra R A) : S ≃ₐ[R] (S.op)ᵐᵒᵖ where\n __ := S.toSubsemiring.ringEquivOpMop\n commutes' _ := rfl", "start": [ 146, 1 ], "end": [ 150, 21 ], "kind": "commanddeclaration" }, { "full_name": "Subalgebra.mopAlgEquivOp", "code": "@[simps!]\ndef mopAlgEquivOp (S : Subalgebra R A) : Sᵐᵒᵖ ≃ₐ[R] S.op where\n __ := S.toSubsemiring.mopRingEquivOp\n commutes' _ := rfl", "start": [ 152, 1 ], "end": [ 156, 21 ], "kind": "commanddeclaration" }, { "full_name": "Subalgebra.op_toSubring", "code": "@[simp]\ntheorem op_toSubring (S : Subalgebra R A) : S.op.toSubring = S.toSubring.op", "start": [ 164, 1 ], "end": [ 165, 83 ], "kind": "commanddeclaration" }, { "full_name": "Subalgebra.unop_toSubring", "code": "@[simp]\ntheorem unop_toSubring (S : Subalgebra R Aᵐᵒᵖ) : S.unop.toSubring = S.toSubring.unop", "start": [ 167, 1 ], "end": [ 168, 92 ], "kind": "commanddeclaration" } ]

[ "Mathlib/Data/Set/Function.lean", "Mathlib/Order/Interval/Set/Basic.lean", ".lake/packages/lean4/src/lean/Init.lean" ]

[ { "full_name": "surjOn_Ioo_of_monotone_surjective", "code": "theorem surjOn_Ioo_of_monotone_surjective (h_mono : Monotone f) (h_surj : Function.Surjective f)\n (a b : α) : SurjOn f (Ioo a b) (Ioo (f a) (f b))", "start": [ 26, 1 ], "end": [ 32, 68 ], "kind": "commanddeclaration" }, { "full_name": "surjOn_Ico_of_monotone_surjective", "code": "theorem surjOn_Ico_of_monotone_surjective (h_mono : Monotone f) (h_surj : Function.Surjective f)\n (a b : α) : SurjOn f (Ico a b) (Ico (f a) (f b))", "start": [ 35, 1 ], "end": [ 44, 27 ], "kind": "commanddeclaration" }, { "full_name": "surjOn_Ioc_of_monotone_surjective", "code": "theorem surjOn_Ioc_of_monotone_surjective (h_mono : Monotone f) (h_surj : Function.Surjective f)\n (a b : α) : SurjOn f (Ioc a b) (Ioc (f a) (f b))", "start": [ 47, 1 ], "end": [ 49, 89 ], "kind": "commanddeclaration" }, { "full_name": "surjOn_Icc_of_monotone_surjective", "code": "theorem surjOn_Icc_of_monotone_surjective (h_mono : Monotone f) (h_surj : Function.Surjective f)\n {a b : α} (hab : a ≤ b) : SurjOn f (Icc a b) (Icc (f a) (f b))", "start": [ 53, 1 ], "end": [ 60, 50 ], "kind": "commanddeclaration" }, { "full_name": "surjOn_Ioi_of_monotone_surjective", "code": "theorem surjOn_Ioi_of_monotone_surjective (h_mono : Monotone f) (h_surj : Function.Surjective f)\n (a : α) : SurjOn f (Ioi a) (Ioi (f a))", "start": [ 63, 1 ], "end": [ 67, 39 ], "kind": "commanddeclaration" }, { "full_name": "surjOn_Iio_of_monotone_surjective", "code": "theorem surjOn_Iio_of_monotone_surjective (h_mono : Monotone f) (h_surj : Function.Surjective f)\n (a : α) : SurjOn f (Iio a) (Iio (f a))", "start": [ 70, 1 ], "end": [ 72, 68 ], "kind": "commanddeclaration" }, { "full_name": "surjOn_Ici_of_monotone_surjective", "code": "theorem surjOn_Ici_of_monotone_surjective (h_mono : Monotone f) (h_surj : Function.Surjective f)\n (a : α) : SurjOn f (Ici a) (Ici (f a))", "start": [ 75, 1 ], "end": [ 80, 52 ], "kind": "commanddeclaration" }, { "full_name": "surjOn_Iic_of_monotone_surjective", "code": "theorem surjOn_Iic_of_monotone_surjective (h_mono : Monotone f) (h_surj : Function.Surjective f)\n (a : α) : SurjOn f (Iic a) (Iic (f a))", "start": [ 83, 1 ], "end": [ 85, 68 ], "kind": "commanddeclaration" } ]

[ "Mathlib/Algebra/DualNumber.lean", ".lake/packages/lean4/src/lean/Init.lean", "Mathlib/Algebra/Quaternion.lean" ]

[ { "full_name": "Quaternion.dualNumberEquiv", "code": "def dualNumberEquiv : Quaternion (DualNumber R) ≃ₐ[R] DualNumber (Quaternion R) where\n toFun q :=\n (⟨q.re.fst, q.imI.fst, q.imJ.fst, q.imK.fst⟩, ⟨q.re.snd, q.imI.snd, q.imJ.snd, q.imK.snd⟩)\n invFun d :=\n ⟨(d.fst.re, d.snd.re), (d.fst.imI, d.snd.imI), (d.fst.imJ, d.snd.imJ), (d.fst.imK, d.snd.imK)⟩\n left_inv := fun ⟨⟨r, rε⟩, ⟨i, iε⟩, ⟨j, jε⟩, ⟨k, kε⟩⟩ => rfl\n right_inv := fun ⟨⟨r, i, j, k⟩, ⟨rε, iε, jε, kε⟩⟩ => rfl\n map_mul' := by\n rintro ⟨⟨xr, xrε⟩, ⟨xi, xiε⟩, ⟨xj, xjε⟩, ⟨xk, xkε⟩⟩\n rintro ⟨⟨yr, yrε⟩, ⟨yi, yiε⟩, ⟨yj, yjε⟩, ⟨yk, ykε⟩⟩\n ext : 1\n · rfl\n · dsimp\n congr 1 <;> simp <;> ring\n map_add' := by\n rintro ⟨⟨xr, xrε⟩, ⟨xi, xiε⟩, ⟨xj, xjε⟩, ⟨xk, xkε⟩⟩\n rintro ⟨⟨yr, yrε⟩, ⟨yi, yiε⟩, ⟨yj, yjε⟩, ⟨yk, ykε⟩⟩\n rfl\n commutes' r := rfl", "start": [ 32, 1 ], "end": [ 54, 21 ], "kind": "commanddeclaration" }, { "full_name": "Quaternion.re_fst_dualNumberEquiv", "code": "@[simp]\ntheorem re_fst_dualNumberEquiv (q : Quaternion (DualNumber R)) :\n (dualNumberEquiv q).fst.re = q.re.fst", "start": [ 61, 1 ], "end": [ 64, 6 ], "kind": "commanddeclaration" }, { "full_name": "Quaternion.imI_fst_dualNumberEquiv", "code": "@[simp]\ntheorem imI_fst_dualNumberEquiv (q : Quaternion (DualNumber R)) :\n (dualNumberEquiv q).fst.imI = q.imI.fst", "start": [ 67, 1 ], "end": [ 70, 6 ], "kind": "commanddeclaration" }, { "full_name": "Quaternion.imJ_fst_dualNumberEquiv", "code": "@[simp]\ntheorem imJ_fst_dualNumberEquiv (q : Quaternion (DualNumber R)) :\n (dualNumberEquiv q).fst.imJ = q.imJ.fst", "start": [ 73, 1 ], "end": [ 76, 6 ], "kind": "commanddeclaration" }, { "full_name": "Quaternion.imK_fst_dualNumberEquiv", "code": "@[simp]\ntheorem imK_fst_dualNumberEquiv (q : Quaternion (DualNumber R)) :\n (dualNumberEquiv q).fst.imK = q.imK.fst", "start": [ 79, 1 ], "end": [ 82, 6 ], "kind": "commanddeclaration" }, { "full_name": "Quaternion.re_snd_dualNumberEquiv", "code": "@[simp]\ntheorem re_snd_dualNumberEquiv (q : Quaternion (DualNumber R)) :\n (dualNumberEquiv q).snd.re = q.re.snd", "start": [ 85, 1 ], "end": [ 88, 6 ], "kind": "commanddeclaration" }, { "full_name": "Quaternion.imI_snd_dualNumberEquiv", "code": "@[simp]\ntheorem imI_snd_dualNumberEquiv (q : Quaternion (DualNumber R)) :\n (dualNumberEquiv q).snd.imI = q.imI.snd", "start": [ 91, 1 ], "end": [ 94, 6 ], "kind": "commanddeclaration" }, { "full_name": "Quaternion.imJ_snd_dualNumberEquiv", "code": "@[simp]\ntheorem imJ_snd_dualNumberEquiv (q : Quaternion (DualNumber R)) :\n (dualNumberEquiv q).snd.imJ = q.imJ.snd", "start": [ 97, 1 ], "end": [ 100, 6 ], "kind": "commanddeclaration" }, { "full_name": "Quaternion.imK_snd_dualNumberEquiv", "code": "@[simp]\ntheorem imK_snd_dualNumberEquiv (q : Quaternion (DualNumber R)) :\n (dualNumberEquiv q).snd.imK = q.imK.snd", "start": [ 103, 1 ], "end": [ 106, 6 ], "kind": "commanddeclaration" }, { "full_name": "Quaternion.fst_re_dualNumberEquiv_symm", "code": "@[simp]\ntheorem fst_re_dualNumberEquiv_symm (d : DualNumber (Quaternion R)) :\n (dualNumberEquiv.symm d).re.fst = d.fst.re", "start": [ 109, 1 ], "end": [ 112, 6 ], "kind": "commanddeclaration" }, { "full_name": "Quaternion.fst_imI_dualNumberEquiv_symm", "code": "@[simp]\ntheorem fst_imI_dualNumberEquiv_symm (d : DualNumber (Quaternion R)) :\n (dualNumberEquiv.symm d).imI.fst = d.fst.imI", "start": [ 115, 1 ], "end": [ 118, 6 ], "kind": "commanddeclaration" }, { "full_name": "Quaternion.fst_imJ_dualNumberEquiv_symm", "code": "@[simp]\ntheorem fst_imJ_dualNumberEquiv_symm (d : DualNumber (Quaternion R)) :\n (dualNumberEquiv.symm d).imJ.fst = d.fst.imJ", "start": [ 121, 1 ], "end": [ 124, 6 ], "kind": "commanddeclaration" }, { "full_name": "Quaternion.fst_imK_dualNumberEquiv_symm", "code": "@[simp]\ntheorem fst_imK_dualNumberEquiv_symm (d : DualNumber (Quaternion R)) :\n (dualNumberEquiv.symm d).imK.fst = d.fst.imK", "start": [ 127, 1 ], "end": [ 130, 6 ], "kind": "commanddeclaration" }, { "full_name": "Quaternion.snd_re_dualNumberEquiv_symm", "code": "@[simp]\ntheorem snd_re_dualNumberEquiv_symm (d : DualNumber (Quaternion R)) :\n (dualNumberEquiv.symm d).re.snd = d.snd.re", "start": [ 133, 1 ], "end": [ 136, 6 ], "kind": "commanddeclaration" }, { "full_name": "Quaternion.snd_imI_dualNumberEquiv_symm", "code": "@[simp]\ntheorem snd_imI_dualNumberEquiv_symm (d : DualNumber (Quaternion R)) :\n (dualNumberEquiv.symm d).imI.snd = d.snd.imI", "start": [ 139, 1 ], "end": [ 142, 6 ], "kind": "commanddeclaration" }, { "full_name": "Quaternion.snd_imJ_dualNumberEquiv_symm", "code": "@[simp]\ntheorem snd_imJ_dualNumberEquiv_symm (d : DualNumber (Quaternion R)) :\n (dualNumberEquiv.symm d).imJ.snd = d.snd.imJ", "start": [ 145, 1 ], "end": [ 148, 6 ], "kind": "commanddeclaration" }, { "full_name": "Quaternion.snd_imK_dualNumberEquiv_symm", "code": "@[simp]\ntheorem snd_imK_dualNumberEquiv_symm (d : DualNumber (Quaternion R)) :\n (dualNumberEquiv.symm d).imK.snd = d.snd.imK", "start": [ 151, 1 ], "end": [ 154, 6 ], "kind": "commanddeclaration" } ]

[ ".lake/packages/lean4/src/lean/Init.lean", "Mathlib/Topology/StoneCech.lean", "Mathlib/Topology/Category/Stonean/Basic.lean", "Mathlib/Topology/Category/TopCat/Adjunctions.lean" ]

[ { "full_name": "Stonean.stoneCechObj", "code": "def stoneCechObj (X : Type u) : Stonean :=\n letI : TopologicalSpace X := ⊥\n haveI : DiscreteTopology X := ⟨rfl⟩\n haveI : ExtremallyDisconnected (StoneCech X) :=\n CompactT2.Projective.extremallyDisconnected StoneCech.projective\n of (StoneCech X)", "start": [ 24, 1 ], "end": [ 30, 19 ], "kind": "commanddeclaration" }, { "full_name": "Stonean.stoneCechEquivalence", "code": "noncomputable def stoneCechEquivalence (X : Type u) (Y : Stonean.{u}) :\n (stoneCechObj X ⟶ Y) ≃ (X ⟶ (forget Stonean).obj Y) := by\n letI : TopologicalSpace X := ⊥\n haveI : DiscreteTopology X := ⟨rfl⟩\n refine fullyFaithfulToCompHaus.homEquiv.trans ?_\n exact (_root_.stoneCechEquivalence (TopCat.of X) (toCompHaus.obj Y)).trans\n (TopCat.adj₁.homEquiv _ _)", "start": [ 32, 1 ], "end": [ 40, 31 ], "kind": "commanddeclaration" }, { "full_name": "typeToStonean", "code": "noncomputable def typeToStonean : Type u ⥤ Stonean.{u} :=\n leftAdjointOfEquiv Stonean.stoneCechEquivalence fun _ _ _ _ _ => rfl", "start": [ 44, 1 ], "end": [ 46, 71 ], "kind": "commanddeclaration" }, { "full_name": "Stonean.stoneCechAdjunction", "code": "noncomputable def stoneCechAdjunction : typeToStonean ⊣ (forget Stonean) :=\n adjunctionOfEquivLeft stoneCechEquivalence fun _ _ _ _ _ => rfl", "start": [ 50, 1 ], "end": [ 52, 66 ], "kind": "commanddeclaration" }, { "full_name": "Stonean.forget.preservesLimits", "code": "noncomputable instance forget.preservesLimits : Limits.PreservesLimits (forget Stonean) :=\n rightAdjointPreservesLimits stoneCechAdjunction", "start": [ 54, 1 ], "end": [ 56, 50 ], "kind": "commanddeclaration" }, { "full_name": "Stonean.mono_iff_injective", "code": "theorem mono_iff_injective {X Y : Stonean} (f : X ⟶ Y) : Mono f ↔ Function.Injective f", "start": [ 58, 1 ], "end": [ 59, 61 ], "kind": "commanddeclaration" } ]

[ "Mathlib/MeasureTheory/Measure/Count.lean", "Mathlib/Probability/ConditionalProbability.lean", ".lake/packages/lean4/src/lean/Init.lean" ]

[ { "full_name": "ProbabilityTheory.condCount", "code": "def condCount (s : Set Ω) : Measure Ω :=\n Measure.count[|s]", "start": [ 49, 1 ], "end": [ 55, 20 ], "kind": "commanddeclaration" }, { "full_name": "ProbabilityTheory.condCount_empty_meas", "code": "@[simp]\ntheorem condCount_empty_meas : (condCount ∅ : Measure Ω) = 0", "start": [ 58, 1 ], "end": [ 59, 84 ], "kind": "commanddeclaration" }, { "full_name": "ProbabilityTheory.condCount_empty", "code": "theorem condCount_empty {s : Set Ω} : condCount s ∅ = 0", "start": [ 62, 1 ], "end": [ 62, 67 ], "kind": "commanddeclaration" }, { "full_name": "ProbabilityTheory.finite_of_condCount_ne_zero", "code": "theorem finite_of_condCount_ne_zero {s t : Set Ω} (h : condCount s t ≠ 0) : s.Finite", "start": [ 65, 1 ], "end": [ 67, 64 ], "kind": "commanddeclaration" }, { "full_name": "ProbabilityTheory.condCount_univ", "code": "theorem condCount_univ [Fintype Ω] {s : Set Ω} :\n condCount Set.univ s = Measure.count s / Fintype.card Ω", "start": [ 70, 1 ], "end": [ 76, 59 ], "kind": "commanddeclaration" }, { "full_name": "ProbabilityTheory.condCount_isProbabilityMeasure", "code": "theorem condCount_isProbabilityMeasure {s : Set Ω} (hs : s.Finite) (hs' : s.Nonempty) :\n IsProbabilityMeasure (condCount s)", "start": [ 81, 1 ], "end": [ 86, 53 ], "kind": "commanddeclaration" }, { "full_name": "ProbabilityTheory.condCount_singleton", "code": "theorem condCount_singleton (ω : Ω) (t : Set Ω) [Decidable (ω ∈ t)] :\n condCount {ω} t = if ω ∈ t then 1 else 0", "start": [ 89, 1 ], "end": [ 95, 65 ], "kind": "commanddeclaration" }, { "full_name": "ProbabilityTheory.condCount_inter_self", "code": "theorem condCount_inter_self (hs : s.Finite) : condCount s (s ∩ t) = condCount s t", "start": [ 100, 1 ], "end": [ 101, 53 ], "kind": "commanddeclaration" }, { "full_name": "ProbabilityTheory.condCount_self", "code": "theorem condCount_self (hs : s.Finite) (hs' : s.Nonempty) : condCount s s = 1", "start": [ 104, 1 ], "end": [ 107, 47 ], "kind": "commanddeclaration" }, { "full_name": "ProbabilityTheory.condCount_eq_one_of", "code": "theorem condCount_eq_one_of (hs : s.Finite) (hs' : s.Nonempty) (ht : s ⊆ t) :\n condCount s t = 1", "start": [ 110, 1 ], "end": [ 115, 24 ], "kind": "commanddeclaration" }, { "full_name": "ProbabilityTheory.pred_true_of_condCount_eq_one", "code": "theorem pred_true_of_condCount_eq_one (h : condCount s t = 1) : s ⊆ t", "start": [ 118, 1 ], "end": [ 126, 91 ], "kind": "commanddeclaration" }, { "full_name": "ProbabilityTheory.condCount_eq_zero_iff", "code": "theorem condCount_eq_zero_iff (hs : s.Finite) : condCount s t = 0 ↔ s ∩ t = ∅", "start": [ 129, 1 ], "end": [ 131, 55 ], "kind": "commanddeclaration" }, { "full_name": "ProbabilityTheory.condCount_of_univ", "code": "theorem condCount_of_univ (hs : s.Finite) (hs' : s.Nonempty) : condCount s Set.univ = 1", "start": [ 134, 1 ], "end": [ 135, 43 ], "kind": "commanddeclaration" }, { "full_name": "ProbabilityTheory.condCount_inter", "code": "theorem condCount_inter (hs : s.Finite) :\n condCount s (t ∩ u) = condCount (s ∩ t) u * condCount s t", "start": [ 138, 1 ], "end": [ 148, 66 ], "kind": "commanddeclaration" }, { "full_name": "ProbabilityTheory.condCount_inter'", "code": "theorem condCount_inter' (hs : s.Finite) :\n condCount s (t ∩ u) = condCount (s ∩ u) t * condCount s u", "start": [ 151, 1 ], "end": [ 154, 27 ], "kind": "commanddeclaration" }, { "full_name": "ProbabilityTheory.condCount_union", "code": "theorem condCount_union (hs : s.Finite) (htu : Disjoint t u) :\n condCount s (t ∪ u) = condCount s t + condCount s u", "start": [ 157, 1 ], "end": [ 161, 82 ], "kind": "commanddeclaration" }, { "full_name": "ProbabilityTheory.condCount_compl", "code": "theorem condCount_compl (t : Set Ω) (hs : s.Finite) (hs' : s.Nonempty) :\n condCount s t + condCount s tᶜ = 1", "start": [ 164, 1 ], "end": [ 167, 58 ], "kind": "commanddeclaration" }, { "full_name": "ProbabilityTheory.condCount_disjoint_union", "code": "theorem condCount_disjoint_union (hs : s.Finite) (ht : t.Finite) (hst : Disjoint s t) :\n condCount s u * condCount (s ∪ t) s + condCount t u * condCount (s ∪ t) t =\n condCount (s ∪ t) u", "start": [ 170, 1 ], "end": [ 189, 42 ], "kind": "commanddeclaration" }, { "full_name": "ProbabilityTheory.condCount_add_compl_eq", "code": "theorem condCount_add_compl_eq (u t : Set Ω) (hs : s.Finite) :\n condCount (s ∩ u) t * condCount s u + condCount (s ∩ uᶜ) t * condCount s uᶜ =\n condCount s t", "start": [ 192, 1 ], "end": [ 202, 33 ], "kind": "commanddeclaration" } ]

[ ".lake/packages/lean4/src/lean/Init.lean", "Mathlib/Data/PFunctor/Multivariate/Basic.lean", "Mathlib/Data/QPF/Multivariate/Basic.lean" ]

[ { "full_name": "MvQPF.Sigma", "code": "def Sigma (v : TypeVec.{u} n) : Type u :=\n Σ α : A, F α v", "start": [ 25, 1 ], "end": [ 28, 17 ], "kind": "commanddeclaration" }, { "full_name": "MvQPF.Pi", "code": "def Pi (v : TypeVec.{u} n) : Type u :=\n ∀ α : A, F α v", "start": [ 31, 1 ], "end": [ 34, 17 ], "kind": "commanddeclaration" }, { "full_name": "MvQPF.Sigma.inhabited", "code": "instance Sigma.inhabited {α} [Inhabited A] [Inhabited (F default α)] : Inhabited (Sigma F α) :=\n ⟨⟨default, default⟩⟩", "start": [ 37, 1 ], "end": [ 38, 23 ], "kind": "commanddeclaration" }, { "full_name": "MvQPF.Pi.inhabited", "code": "instance Pi.inhabited {α} [∀ a, Inhabited (F a α)] : Inhabited (Pi F α) :=\n ⟨fun _a => default⟩", "start": [ 41, 1 ], "end": [ 42, 22 ], "kind": "commanddeclaration" }, { "full_name": "MvQPF.Sigma.P", "code": "protected def P : MvPFunctor n :=\n ⟨Σ a, (P (F a)).A, fun x => (P (F x.1)).B x.2⟩", "start": [ 53, 1 ], "end": [ 55, 49 ], "kind": "commanddeclaration" }, { "full_name": "MvQPF.Sigma.abs", "code": "protected def abs ⦃α⦄ : Sigma.P F α → Sigma F α\n | ⟨a, f⟩ => ⟨a.1, MvQPF.abs ⟨a.2, f⟩⟩", "start": [ 59, 1 ], "end": [ 61, 40 ], "kind": "commanddeclaration" }, { "full_name": "MvQPF.Sigma.repr", "code": "protected def repr ⦃α⦄ : Sigma F α → Sigma.P F α\n | ⟨a, f⟩ =>\n let x := MvQPF.repr f\n ⟨⟨a, x.1⟩, x.2⟩", "start": [ 64, 1 ], "end": [ 68, 20 ], "kind": "commanddeclaration" }, { "full_name": "MvQPF.Pi.P", "code": "protected def P : MvPFunctor n :=\n ⟨∀ a, (P (F a)).A, fun x i => Σ a, (P (F a)).B (x a) i⟩", "start": [ 87, 1 ], "end": [ 89, 58 ], "kind": "commanddeclaration" }, { "full_name": "MvQPF.Pi.abs", "code": "protected def abs ⦃α⦄ : Pi.P F α → Pi F α\n | ⟨a, f⟩ => fun x => MvQPF.abs ⟨a x, fun i y => f i ⟨_, y⟩⟩", "start": [ 93, 1 ], "end": [ 95, 62 ], "kind": "commanddeclaration" }, { "full_name": "MvQPF.Pi.repr", "code": "protected def repr ⦃α⦄ : Pi F α → Pi.P F α\n | f => ⟨fun a => (MvQPF.repr (f a)).1, fun _i a => (MvQPF.repr (f _)).2 _ a.2⟩", "start": [ 98, 1 ], "end": [ 100, 81 ], "kind": "commanddeclaration" } ]

[ "Mathlib/Analysis/Complex/Basic.lean", ".lake/packages/lean4/src/lean/Init.lean", "Mathlib/Analysis/NormedSpace/OperatorNorm/NormedSpace.lean", "Mathlib/Data/Complex/Determinant.lean" ]

[ { "full_name": "Complex.det_conjLIE", "code": "@[simp]\ntheorem det_conjLIE : LinearMap.det (conjLIE.toLinearEquiv : ℂ →ₗ[ℝ] ℂ) = -1", "start": [ 24, 1 ], "end": [ 27, 13 ], "kind": "commanddeclaration" }, { "full_name": "Complex.linearEquiv_det_conjLIE", "code": "@[simp]\ntheorem linearEquiv_det_conjLIE : LinearEquiv.det conjLIE.toLinearEquiv = -1", "start": [ 30, 1 ], "end": [ 33, 25 ], "kind": "commanddeclaration" }, { "full_name": "Complex.reCLM_norm", "code": "@[simp]\ntheorem reCLM_norm : ‖reCLM‖ = 1", "start": [ 36, 1 ], "end": [ 41, 50 ], "kind": "commanddeclaration" }, { "full_name": "Complex.reCLM_nnnorm", "code": "@[simp]\ntheorem reCLM_nnnorm : ‖reCLM‖₊ = 1", "start": [ 44, 1 ], "end": [ 46, 25 ], "kind": "commanddeclaration" }, { "full_name": "Complex.imCLM_norm", "code": "@[simp]\ntheorem imCLM_norm : ‖imCLM‖ = 1", "start": [ 49, 1 ], "end": [ 54, 50 ], "kind": "commanddeclaration" }, { "full_name": "Complex.imCLM_nnnorm", "code": "@[simp]\ntheorem imCLM_nnnorm : ‖imCLM‖₊ = 1", "start": [ 57, 1 ], "end": [ 59, 25 ], "kind": "commanddeclaration" }, { "full_name": "Complex.conjCLE_norm", "code": "@[simp]\ntheorem conjCLE_norm : ‖(conjCLE : ℂ →L[ℝ] ℂ)‖ = 1", "start": [ 62, 1 ], "end": [ 64, 54 ], "kind": "commanddeclaration" }, { "full_name": "Complex.conjCLE_nnorm", "code": "@[simp]\ntheorem conjCLE_nnorm : ‖(conjCLE : ℂ →L[ℝ] ℂ)‖₊ = 1", "start": [ 67, 1 ], "end": [ 69, 27 ], "kind": "commanddeclaration" }, { "full_name": "Complex.ofRealCLM_norm", "code": "@[simp]\ntheorem ofRealCLM_norm : ‖ofRealCLM‖ = 1", "start": [ 72, 1 ], "end": [ 74, 38 ], "kind": "commanddeclaration" }, { "full_name": "Complex.ofRealCLM_nnnorm", "code": "@[simp]\ntheorem ofRealCLM_nnnorm : ‖ofRealCLM‖₊ = 1", "start": [ 77, 1 ], "end": [ 79, 32 ], "kind": "commanddeclaration" } ]

[ ".lake/packages/lean4/src/lean/Init.lean", "Mathlib/Analysis/SpecialFunctions/Pow/Deriv.lean", "Mathlib/Analysis/Complex/PhragmenLindelof.lean" ]

[ { "full_name": "Complex.HadamardThreeLines.verticalStrip", "code": "def verticalStrip (a : ℝ) (b : ℝ) : Set ℂ := re ⁻¹' Ioo a b", "start": [ 61, 1 ], "end": [ 62, 60 ], "kind": "commanddeclaration" }, { "full_name": "Complex.HadamardThreeLines.verticalClosedStrip", "code": "def verticalClosedStrip (a : ℝ) (b : ℝ) : Set ℂ := re ⁻¹' Icc a b", "start": [ 64, 1 ], "end": [ 65, 66 ], "kind": "commanddeclaration" }, { "full_name": "Complex.HadamardThreeLines.sSupNormIm", "code": "noncomputable def sSupNormIm {E : Type*} [NormedAddCommGroup E]\n (f : ℂ → E) (x : ℝ) : ℝ :=\n sSup ((norm ∘ f) '' (re ⁻¹' {x}))", "start": [ 67, 1 ], "end": [ 71, 36 ], "kind": "commanddeclaration" }, { "full_name": "Complex.HadamardThreeLines.invInterpStrip", "code": "noncomputable def invInterpStrip (ε : ℝ) : ℂ :=\n (ε + sSupNormIm f 0) ^ (z - 1) * (ε + sSupNormIm f 1) ^ (-z)", "start": [ 77, 1 ], "end": [ 85, 63 ], "kind": "commanddeclaration" }, { "full_name": "Complex.HadamardThreeLines.F", "code": "noncomputable def F (ε : ℝ) := fun z ↦ invInterpStrip f z ε • f z", "start": [ 87, 1 ], "end": [ 88, 66 ], "kind": "commanddeclaration" }, { "full_name": "Complex.HadamardThreeLines.sSupNormIm_nonneg", "code": "lemma sSupNormIm_nonneg (x : ℝ) : 0 ≤ sSupNormIm f x := by\n apply Real.sSup_nonneg\n rintro y ⟨z1, _, hz2⟩\n simp only [← hz2, comp, norm_nonneg]", "start": [ 90, 1 ], "end": [ 94, 39 ], "kind": "lemma" }, { "full_name": "Complex.HadamardThreeLines.sSupNormIm_eps_pos", "code": "lemma sSupNormIm_eps_pos {ε : ℝ} (hε : ε > 0) (x : ℝ) : 0 < ε + sSupNormIm f x := by\n linarith [sSupNormIm_nonneg f x]", "start": [ 96, 1 ], "end": [ 99, 36 ], "kind": "lemma" }, { "full_name": "Complex.HadamardThreeLines.abs_invInterpStrip", "code": "lemma abs_invInterpStrip {ε : ℝ} (hε : ε > 0) :\n abs (invInterpStrip f z ε) =\n (ε + sSupNormIm f 0) ^ (z.re - 1) * (ε + sSupNormIm f 1) ^ (-z.re) := by\n simp only [invInterpStrip, map_mul]\n repeat rw [← ofReal_add]\n repeat rw [abs_cpow_eq_rpow_re_of_pos (sSupNormIm_eps_pos f hε _) _]\n simp only [sub_re, one_re, neg_re]", "start": [ 101, 1 ], "end": [ 108, 37 ], "kind": "lemma" }, { "full_name": "Complex.HadamardThreeLines.diffContOnCl_invInterpStrip", "code": "lemma diffContOnCl_invInterpStrip {ε : ℝ} (hε : ε > 0) :\n DiffContOnCl ℂ (fun z ↦ invInterpStrip f z ε) (verticalStrip 0 1) := by\n apply Differentiable.diffContOnCl\n apply Differentiable.mul\n · apply Differentiable.const_cpow (Differentiable.sub_const (differentiable_id') 1) _\n left\n rw [← ofReal_add, ofReal_ne_zero]\n simp only [ne_eq, ne_of_gt (sSupNormIm_eps_pos f hε 0), not_false_eq_true]\n · apply Differentiable.const_cpow (Differentiable.neg differentiable_id')\n apply Or.inl\n rw [← ofReal_add, ofReal_ne_zero]\n exact (ne_of_gt (sSupNormIm_eps_pos f hε 1))", "start": [ 110, 1 ], "end": [ 122, 49 ], "kind": "lemma" }, { "full_name": "Complex.HadamardThreeLines.norm_le_sSupNormIm", "code": "lemma norm_le_sSupNormIm (f : ℂ → E) (z : ℂ) (hD : z ∈ verticalClosedStrip 0 1)\n (hB : BddAbove ((norm ∘ f) '' (verticalClosedStrip 0 1))) :\n ‖f z‖ ≤ sSupNormIm f (z.re) := by\n refine le_csSup ?_ ?_\n · apply BddAbove.mono (image_subset (norm ∘ f) _) hB\n exact preimage_mono (singleton_subset_iff.mpr hD)\n · apply mem_image_of_mem (norm ∘ f)\n simp only [mem_preimage, mem_singleton]", "start": [ 124, 1 ], "end": [ 132, 44 ], "kind": "lemma" }, { "full_name": "Complex.HadamardThreeLines.norm_lt_sSupNormIm_eps", "code": "lemma norm_lt_sSupNormIm_eps (f : ℂ → E) (ε : ℝ) (hε : ε > 0) (z : ℂ)\n (hD : z ∈ verticalClosedStrip 0 1) (hB : BddAbove ((norm ∘ f) '' (verticalClosedStrip 0 1))) :\n ‖f z‖ < ε + sSupNormIm f (z.re) :=\n lt_add_of_pos_of_le hε (norm_le_sSupNormIm f z hD hB)", "start": [ 134, 1 ], "end": [ 138, 56 ], "kind": "lemma" }, { "full_name": "Complex.HadamardThreeLines.F_BddAbove", "code": "lemma F_BddAbove (f : ℂ → E) (ε : ℝ) (hε : ε > 0)\n (hB : BddAbove ((norm ∘ f) '' (verticalClosedStrip 0 1))) :\n BddAbove ((norm ∘ (F f ε)) '' (verticalClosedStrip 0 1)) := by\n simp only [F, image_congr, comp_apply, map_mul, invInterpStrip]\n rw [bddAbove_def] at *\n rcases hB with ⟨B, hB⟩\n use ((max 1 ((ε + sSupNormIm f 0) ^ (-(1 : ℝ)))) * max 1 ((ε + sSupNormIm f 1) ^ (-(1 : ℝ)))) * B\n simp only [mem_image, forall_exists_index, and_imp, forall_apply_eq_imp_iff₂]\n intros z hset\n specialize hB (‖f z‖) (by simpa [image_congr, mem_image, comp_apply] using ⟨z, hset, rfl⟩)\n simp only [norm_smul, norm_mul, ← ofReal_add]\n gcongr\n · by_cases hM0_one : 1 ≤ ε + sSupNormIm f 0\n · apply le_trans _ (le_max_left _ _)\n simp only [norm_eq_abs, abs_cpow_eq_rpow_re_of_pos (sSupNormIm_eps_pos f hε 0), sub_re,\n one_re, Real.rpow_le_one_of_one_le_of_nonpos hM0_one (sub_nonpos.mpr hset.2)]\n · rw [not_le] at hM0_one; apply le_trans _ (le_max_right _ _)\n simp only [norm_eq_abs, abs_cpow_eq_rpow_re_of_pos (sSupNormIm_eps_pos f hε 0), sub_re,\n one_re]\n apply Real.rpow_le_rpow_of_exponent_ge (sSupNormIm_eps_pos f hε 0) (le_of_lt hM0_one) _\n simp only [neg_le_sub_iff_le_add, le_add_iff_nonneg_left, hset.1]\n · by_cases hM1_one : 1 ≤ ε + sSupNormIm f 1\n · apply le_trans _ (le_max_left _ _)\n simp only [norm_eq_abs, abs_cpow_eq_rpow_re_of_pos (sSupNormIm_eps_pos f hε 1), sub_re,\n one_re, neg_re, Real.rpow_le_one_of_one_le_of_nonpos\n hM1_one (Right.neg_nonpos_iff.mpr hset.1)]\n · rw [not_le] at hM1_one; apply le_trans _ (le_max_right _ _)\n simp only [norm_eq_abs, abs_cpow_eq_rpow_re_of_pos (sSupNormIm_eps_pos f hε 1), sub_re,\n one_re, neg_re, Real.rpow_le_rpow_of_exponent_ge (sSupNormIm_eps_pos f hε 1)\n (le_of_lt hM1_one) (neg_le_neg_iff.mpr hset.2)]", "start": [ 140, 1 ], "end": [ 178, 56 ], "kind": "lemma" }, { "full_name": "Complex.HadamardThreeLines.F_edge_le_one", "code": "lemma F_edge_le_one (f : ℂ → E) (ε : ℝ) (hε : ε > 0) (z : ℂ)\n (hB : BddAbove ((norm ∘ f) '' (verticalClosedStrip 0 1))) (hz : z ∈ re ⁻¹' {0, 1}) :\n ‖F f ε z‖ ≤ 1 := by\n simp only [F, norm_smul, norm_eq_abs, map_mul, abs_cpow_eq_rpow_re_of_pos,\n abs_invInterpStrip f z hε, sSupNormIm_eps_pos f hε 1,\n sub_re, one_re, neg_re]\n rcases hz with hz0 | hz1\n · simp only [hz0, zero_sub, Real.rpow_neg_one, neg_zero, Real.rpow_zero, mul_one,\n inv_mul_le_iff (sSupNormIm_eps_pos f hε 0)]\n rw [← hz0]\n apply le_of_lt (norm_lt_sSupNormIm_eps f ε hε _ _ hB)\n simp only [verticalClosedStrip, mem_preimage, zero_le_one, left_mem_Icc, hz0]\n · rw [mem_singleton_iff] at hz1\n simp only [hz1, one_mul, Real.rpow_zero, sub_self, Real.rpow_neg_one,\n inv_mul_le_iff (sSupNormIm_eps_pos f hε 1), mul_one]\n rw [← hz1]\n apply le_of_lt (norm_lt_sSupNormIm_eps f ε hε _ _ hB)\n simp only [verticalClosedStrip, mem_preimage, zero_le_one, hz1, right_mem_Icc]", "start": [ 180, 1 ], "end": [ 200, 83 ], "kind": "lemma" }, { "full_name": "Complex.HadamardThreeLines.norm_mul_invInterpStrip_le_one_of_mem_verticalClosedStrip", "code": "theorem norm_mul_invInterpStrip_le_one_of_mem_verticalClosedStrip (f : ℂ → E) (ε : ℝ) (hε : 0 < ε)\n (z : ℂ) (hd : DiffContOnCl ℂ f (verticalStrip 0 1))\n (hB : BddAbove ((norm ∘ f) '' (verticalClosedStrip 0 1))) (hz : z ∈ verticalClosedStrip 0 1) :\n ‖F f ε z‖ ≤ 1", "start": [ 202, 1 ], "end": [ 224, 64 ], "kind": "commanddeclaration" }, { "full_name": "Complex.HadamardThreeLines.interpStrip", "code": "noncomputable def interpStrip (z : ℂ) : ℂ :=\n if (sSupNormIm f 0) = 0 ∨ (sSupNormIm f 1) = 0\n then 0\n else (sSupNormIm f 0) ^ (1-z) * (sSupNormIm f 1) ^ z", "start": [ 232, 1 ], "end": [ 242, 57 ], "kind": "commanddeclaration" }, { "full_name": "Complex.HadamardThreeLines.interpStrip_eq_of_pos", "code": "lemma interpStrip_eq_of_pos (z : ℂ) (h0 : 0 < sSupNormIm f 0) (h1 : 0 < sSupNormIm f 1) :\n interpStrip f z = (sSupNormIm f 0) ^ (1 - z) * (sSupNormIm f 1) ^ z := by\n simp only [ne_of_gt h0, ne_of_gt h1, interpStrip, if_false, or_false]", "start": [ 244, 1 ], "end": [ 247, 72 ], "kind": "lemma" }, { "full_name": "Complex.HadamardThreeLines.interpStrip_eq_of_zero", "code": "lemma interpStrip_eq_of_zero (z : ℂ) (h : sSupNormIm f 0 = 0 ∨ sSupNormIm f 1 = 0) :\n interpStrip f z = 0 :=\n if_pos h", "start": [ 249, 1 ], "end": [ 252, 11 ], "kind": "lemma" }, { "full_name": "Complex.HadamardThreeLines.interpStrip_eq_of_mem_verticalStrip", "code": "lemma interpStrip_eq_of_mem_verticalStrip (z : ℂ) (hz : z ∈ verticalStrip 0 1):\n interpStrip f z = (sSupNormIm f 0) ^ (1 - z) * (sSupNormIm f 1) ^ z := by\n by_cases h : sSupNormIm f 0 = 0 ∨ sSupNormIm f 1 = 0\n · rw [interpStrip_eq_of_zero _ z h]\n rcases h with h0 | h1\n · simp only [h0, ofReal_zero, zero_eq_mul, cpow_eq_zero_iff, ne_eq, true_and, ofReal_eq_zero]\n left\n rw [sub_eq_zero, eq_comm]\n simp only [ne_eq, ext_iff, one_re, ne_of_lt hz.2, or_iff_left, false_and, not_false_eq_true]\n · simp only [h1, ofReal_zero, zero_eq_mul, cpow_eq_zero_iff, ofReal_eq_zero, ne_eq, true_and]\n right\n rw [eq_comm]\n simp only [ne_eq, ext_iff, zero_re, ne_of_lt hz.1, or_iff_left, false_and, not_false_eq_true]\n · push_neg at h\n replace h : (0 < sSupNormIm f 0) ∧ (0 < sSupNormIm f 1) :=\n ⟨(lt_of_le_of_ne (sSupNormIm_nonneg f 0) (ne_comm.mp h.1)),\n (lt_of_le_of_ne (sSupNormIm_nonneg f 1) (ne_comm.mp h.2))⟩\n exact interpStrip_eq_of_pos f z h.1 h.2", "start": [ 254, 1 ], "end": [ 272, 44 ], "kind": "lemma" }, { "full_name": "Complex.HadamardThreeLines.diffContOnCl_interpStrip", "code": "lemma diffContOnCl_interpStrip :\n DiffContOnCl ℂ (interpStrip f) (verticalStrip 0 1) := by\n by_cases h : sSupNormIm f 0 = 0 ∨ sSupNormIm f 1 = 0\n · eta_expand; simp_rw [interpStrip_eq_of_zero f _ h]; exact diffContOnCl_const\n · push_neg at h\n rcases h with ⟨h0, h1⟩\n rw [ne_comm] at h0 h1\n apply Differentiable.diffContOnCl\n intro z\n eta_expand\n simp_rw [interpStrip_eq_of_pos f _ (lt_of_le_of_ne (sSupNormIm_nonneg f 0) h0)\n (lt_of_le_of_ne (sSupNormIm_nonneg f 1) h1)]\n refine DifferentiableAt.mul ?_ ?_\n · apply DifferentiableAt.const_cpow (DifferentiableAt.const_sub (differentiableAt_id') 1) _\n left; simp only [Ne, ofReal_eq_zero]; rwa [eq_comm]\n · refine DifferentiableAt.const_cpow ?_ ?_\n · apply differentiableAt_id'\n · left; simp only [Ne, ofReal_eq_zero]; rwa [eq_comm]", "start": [ 274, 1 ], "end": [ 293, 60 ], "kind": "lemma" }, { "full_name": "Complex.HadamardThreeLines.norm_le_interpStrip_of_mem_verticalClosedStrip_eps", "code": "lemma norm_le_interpStrip_of_mem_verticalClosedStrip_eps (ε : ℝ) (hε : ε > 0) (z : ℂ)\n (hB : BddAbove ((norm ∘ f) '' (verticalClosedStrip 0 1)))\n (hd : DiffContOnCl ℂ f (verticalStrip 0 1)) (hz : z ∈ verticalClosedStrip 0 1) :\n ‖f z‖ ≤ ‖((ε + sSupNormIm f 0) ^ (1-z) * (ε + sSupNormIm f 1) ^ z : ℂ)‖ := by\n simp only [F, abs_invInterpStrip _ _ hε, norm_smul, norm_mul, norm_eq_abs,\n ← ofReal_add, abs_cpow_eq_rpow_re_of_pos (sSupNormIm_eps_pos f hε _) _, sub_re, one_re]\n rw [← mul_inv_le_iff, ← one_mul (((ε + sSupNormIm f 1) ^ z.re)), ← mul_inv_le_iff',\n ← Real.rpow_neg_one, ← Real.rpow_neg_one]\n · simp only [← Real.rpow_mul (le_of_lt (sSupNormIm_eps_pos f hε _)),\n mul_neg, mul_one, neg_sub, mul_assoc]\n simpa [F, abs_invInterpStrip _ _ hε, norm_smul, mul_comm] using\n norm_mul_invInterpStrip_le_one_of_mem_verticalClosedStrip f ε hε z hd hB hz\n · simp only [Real.rpow_pos_of_pos (sSupNormIm_eps_pos f hε _) z.re]\n · simp only [Real.rpow_pos_of_pos (sSupNormIm_eps_pos f hε _) (1-z.re)]", "start": [ 295, 1 ], "end": [ 308, 74 ], "kind": "lemma" }, { "full_name": "Complex.HadamardThreeLines.eventuallyle", "code": "lemma eventuallyle (z : ℂ) (hB : BddAbove ((norm ∘ f) '' (verticalClosedStrip 0 1)))\n (hd : DiffContOnCl ℂ f (verticalStrip 0 1)) (hz : z ∈ verticalStrip 0 1) :\n (fun _ : ℝ ↦ ‖f z‖) ≤ᶠ[𝓝[>] 0]\n (fun ε ↦ ‖((ε + sSupNormIm f 0) ^ (1 - z) * (ε + sSupNormIm f 1) ^ z : ℂ)‖) := by\n filter_upwards [self_mem_nhdsWithin] with ε (hε : 0 < ε) using\n norm_le_interpStrip_of_mem_verticalClosedStrip_eps f ε hε z hB hd\n (mem_of_mem_of_subset hz (preimage_mono Ioo_subset_Icc_self))", "start": [ 310, 1 ], "end": [ 316, 68 ], "kind": "lemma" }, { "full_name": "Complex.HadamardThreeLines.norm_le_interpStrip_of_mem_verticalStrip_zero", "code": "lemma norm_le_interpStrip_of_mem_verticalStrip_zero (z : ℂ)\n (hd : DiffContOnCl ℂ f (verticalStrip 0 1))\n (hB : BddAbove ((norm ∘ f) '' (verticalClosedStrip 0 1))) (hz : z ∈ verticalStrip 0 1) :\n ‖f z‖ ≤ ‖interpStrip f z‖ := by\n apply tendsto_le_of_eventuallyLE _ _ (eventuallyle f z hB hd hz)\n · apply tendsto_inf_left\n simp only [tendsto_const_nhds_iff]\n · rw [interpStrip_eq_of_mem_verticalStrip _ _ hz]\n convert ContinuousWithinAt.tendsto _ using 2\n · simp only [ofReal_zero, zero_add]\n · simp_rw [← ofReal_add, norm_eq_abs]\n have : ∀ x ∈ Ioi 0, (x + sSupNormIm f 0) ^ (1 - z.re) * (x + (sSupNormIm f 1)) ^ z.re\n = abs (↑(x + sSupNormIm f 0) ^ (1 - z) * ↑(x + sSupNormIm f 1) ^ z) := by\n intro x hx\n simp only [map_mul]\n repeat rw [abs_cpow_eq_rpow_re_of_nonneg (le_of_lt (sSupNormIm_eps_pos f hx _)) _]\n · simp only [sub_re, one_re]\n · simpa using (ne_comm.mpr (ne_of_lt hz.1))\n · simpa [sub_eq_zero] using (ne_comm.mpr (ne_of_lt hz.2))\n apply tendsto_nhdsWithin_congr this _\n simp only [zero_add]\n rw [map_mul, abs_cpow_eq_rpow_re_of_nonneg (sSupNormIm_nonneg _ _) _,\n abs_cpow_eq_rpow_re_of_nonneg (sSupNormIm_nonneg _ _) _]\n · apply Tendsto.mul\n · apply Tendsto.rpow_const\n · nth_rw 2 [← zero_add (sSupNormIm f 0)]\n exact Tendsto.add_const (sSupNormIm f 0) (tendsto_nhdsWithin_of_tendsto_nhds\n (Continuous.tendsto continuous_id' _))\n · right; simp only [sub_nonneg, le_of_lt hz.2]\n · apply Tendsto.rpow_const\n · nth_rw 2 [← zero_add (sSupNormIm f 1)]\n exact Tendsto.add_const (sSupNormIm f 1) (tendsto_nhdsWithin_of_tendsto_nhds\n (Continuous.tendsto continuous_id' _))\n · right; simp only [sub_nonneg, le_of_lt hz.1]\n · simpa using (ne_comm.mpr (ne_of_lt hz.1))\n · simpa [sub_eq_zero] using (ne_comm.mpr (ne_of_lt hz.2))", "start": [ 318, 1 ], "end": [ 354, 64 ], "kind": "lemma" }, { "full_name": "Complex.HadamardThreeLines.norm_le_interpStrip_of_mem_verticalClosedStrip", "code": "lemma norm_le_interpStrip_of_mem_verticalClosedStrip (f : ℂ → E) {z : ℂ}\n (hz : z ∈ verticalClosedStrip 0 1) (hd : DiffContOnCl ℂ f (verticalStrip 0 1))\n (hB : BddAbove ((norm ∘ f) '' (verticalClosedStrip 0 1))) :\n ‖f z‖ ≤ ‖interpStrip f z‖ := by\n apply le_on_closure (fun w hw ↦ norm_le_interpStrip_of_mem_verticalStrip_zero f w hd hB hw)\n (Continuous.comp_continuousOn' continuous_norm hd.2)\n (Continuous.comp_continuousOn' continuous_norm (diffContOnCl_interpStrip f).2)\n rwa [verticalClosedStrip, ← closure_Ioo zero_ne_one, ← closure_preimage_re] at hz", "start": [ 356, 1 ], "end": [ 368, 84 ], "kind": "lemma" }, { "full_name": "Complex.HadamardThreeLines.norm_le_interp_of_mem_verticalClosedStrip'", "code": "lemma norm_le_interp_of_mem_verticalClosedStrip' (f : ℂ → E) {z : ℂ} {a b : ℝ}\n (hz : z ∈ verticalClosedStrip 0 1) (hd : DiffContOnCl ℂ f (verticalStrip 0 1))\n (hB : BddAbove ((norm ∘ f) '' (verticalClosedStrip 0 1)))\n (ha : ∀ z ∈ re ⁻¹' {0}, ‖f z‖ ≤ a) (hb : ∀ z ∈ re ⁻¹' {1}, ‖f z‖ ≤ b) :\n ‖f z‖ ≤ a ^ (1 - z.re) * b ^ z.re := by\n have : ‖interpStrip f z‖ ≤ (sSupNormIm f 0) ^ (1 - z.re) * (sSupNormIm f 1) ^ z.re := by\n by_cases h : sSupNormIm f 0 = 0 ∨ sSupNormIm f 1 = 0\n · rw [interpStrip_eq_of_zero f z h, norm_zero, mul_nonneg_iff]\n left\n exact ⟨Real.rpow_nonneg (sSupNormIm_nonneg f _) _,\n Real.rpow_nonneg (sSupNormIm_nonneg f _) _ ⟩\n · push_neg at h\n rcases h with ⟨h0, h1⟩\n rw [ne_comm] at h0 h1\n simp_rw [interpStrip_eq_of_pos f _ (lt_of_le_of_ne (sSupNormIm_nonneg f 0) h0)\n (lt_of_le_of_ne (sSupNormIm_nonneg f 1) h1)]\n simp only [norm_eq_abs, map_mul]\n rw [abs_cpow_eq_rpow_re_of_pos ((Ne.le_iff_lt h0).mp (sSupNormIm_nonneg f _)) _]\n rw [abs_cpow_eq_rpow_re_of_pos ((Ne.le_iff_lt h1).mp (sSupNormIm_nonneg f _)) _]\n simp only [sub_re, one_re, le_refl]\n apply (norm_le_interpStrip_of_mem_verticalClosedStrip f hz hd hB).trans (this.trans _)\n apply mul_le_mul_of_le_of_le _ _ (Real.rpow_nonneg (sSupNormIm_nonneg f _) _)\n · apply (Real.rpow_nonneg _ _)\n specialize hb 1\n simp only [mem_preimage, one_re, mem_singleton_iff, forall_true_left] at hb\n exact (norm_nonneg _).trans hb\n · apply Real.rpow_le_rpow (sSupNormIm_nonneg f _) _ (sub_nonneg.mpr hz.2)\n · rw [sSupNormIm]\n apply csSup_le _\n · simpa [comp_apply, mem_image, forall_exists_index,\n and_imp, forall_apply_eq_imp_iff₂] using ha\n · use ‖(f 0)‖, 0\n simp only [mem_preimage, zero_re, mem_singleton_iff, comp_apply,\n and_self]\n · apply Real.rpow_le_rpow (sSupNormIm_nonneg f _) _ hz.1\n · rw [sSupNormIm]\n apply csSup_le _\n · simpa [comp_apply, mem_image, forall_exists_index,\n and_imp, forall_apply_eq_imp_iff₂] using hb\n · use ‖(f 1)‖, 1\n simp only [mem_preimage, one_re, mem_singleton_iff, comp_apply,\n and_self]", "start": [ 370, 1 ], "end": [ 416, 20 ], "kind": "lemma" } ]

[ ".lake/packages/lean4/src/lean/Init.lean", "Mathlib/NumberTheory/Cyclotomic/Three.lean", "Mathlib/NumberTheory/FLT/Basic.lean" ]

[ { "full_name": "cube_of_castHom_ne_zero", "code": "private lemma cube_of_castHom_ne_zero {n : ZMod 9} :\n castHom (show 3 ∣ 9 by norm_num) (ZMod 3) n ≠ 0 → n ^ 3 = 1 ∨ n ^ 3 = 8 := by\n revert n; decide", "start": [ 25, 1 ], "end": [ 27, 19 ], "kind": "lemma" }, { "full_name": "cube_of_not_dvd", "code": "private lemma cube_of_not_dvd {n : ℤ} (h : ¬ 3 ∣ n) :\n (n : ZMod 9) ^ 3 = 1 ∨ (n : ZMod 9) ^ 3 = 8 := by\n apply cube_of_castHom_ne_zero\n rwa [map_intCast, Ne, ZMod.intCast_zmod_eq_zero_iff_dvd]", "start": [ 29, 1 ], "end": [ 32, 59 ], "kind": "lemma" }, { "full_name": "fermatLastTheoremThree_case_1", "code": "theorem fermatLastTheoremThree_case_1 {a b c : ℤ} (hdvd : ¬ 3 ∣ a * b * c) :\n a ^ 3 + b ^ 3 ≠ c ^ 3", "start": [ 34, 1 ], "end": [ 43, 29 ], "kind": "commanddeclaration" }, { "full_name": "three_dvd_b_of_dvd_a_of_gcd_eq_one_of_case2", "code": "private lemma three_dvd_b_of_dvd_a_of_gcd_eq_one_of_case2 {a b c : ℤ} (ha : a ≠ 0)\n (Hgcd: Finset.gcd {a, b, c} id = 1) (h3a : 3 ∣ a) (HF : a ^ 3 + b ^ 3 + c ^ 3 = 0)\n (H : ∀ a b c : ℤ, c ≠ 0 → ¬ 3 ∣ a → ¬ 3 ∣ b → 3 ∣ c → IsCoprime a b → a ^ 3 + b ^ 3 ≠ c ^ 3) :\n 3 ∣ b := by\n have hbc : IsCoprime (-b) (-c) := by\n refine IsCoprime.neg_neg ?_\n rw [add_comm (a ^ 3), add_assoc, add_comm (a ^ 3), ← add_assoc] at HF\n refine isCoprime_of_gcd_eq_one_of_FLT ?_ HF\n convert Hgcd using 2\n rw [Finset.pair_comm, Finset.Insert.comm]\n by_contra! h3b\n by_cases h3c : 3 ∣ c\n · apply h3b\n rw [add_assoc, add_comm (b ^ 3), ← add_assoc] at HF\n exact dvd_c_of_prime_of_dvd_a_of_dvd_b_of_FLT Int.prime_three h3a h3c HF\n · refine H (-b) (-c) a ha (by simp [h3b]) (by simp [h3c]) h3a hbc ?_\n rw [add_eq_zero_iff_eq_neg, ← (show Odd 3 by decide).neg_pow] at HF\n rw [← HF]\n ring", "start": [ 49, 1 ], "end": [ 67, 9 ], "kind": "lemma" }, { "full_name": "fermatLastTheoremThree_of_dvd_a_of_gcd_eq_one_of_case2", "code": "private lemma fermatLastTheoremThree_of_dvd_a_of_gcd_eq_one_of_case2 {a b c : ℤ} (ha : a ≠ 0)\n (h3a : 3 ∣ a) (Hgcd: Finset.gcd {a, b, c} id = 1)\n (H : ∀ a b c : ℤ, c ≠ 0 → ¬ 3 ∣ a → ¬ 3 ∣ b → 3 ∣ c → IsCoprime a b → a ^ 3 + b ^ 3 ≠ c ^ 3) :\n a ^ 3 + b ^ 3 + c ^ 3 ≠ 0 := by\n intro HF\n apply (show ¬(3 ∣ (1 : ℤ)) by decide)\n rw [← Hgcd]\n refine dvd_gcd (fun x hx ↦ ?_)\n simp only [mem_insert, mem_singleton] at hx\n have h3b : 3 ∣ b := by\n refine three_dvd_b_of_dvd_a_of_gcd_eq_one_of_case2 ha ?_ h3a HF H\n simp only [← Hgcd, gcd_insert, gcd_singleton, id_eq, ← Int.abs_eq_normalize, abs_neg]\n rcases hx with (hx | hx | hx)\n · exact hx ▸ h3a\n · exact hx ▸ h3b\n · simpa [hx] using dvd_c_of_prime_of_dvd_a_of_dvd_b_of_FLT Int.prime_three h3a h3b HF", "start": [ 70, 1 ], "end": [ 85, 88 ], "kind": "lemma" }, { "full_name": "fermatLastTheoremThree_of_three_dvd_only_c", "code": "theorem fermatLastTheoremThree_of_three_dvd_only_c\n (H : ∀ a b c : ℤ, c ≠ 0 → ¬ 3 ∣ a → ¬ 3 ∣ b → 3 ∣ c → IsCoprime a b → a ^ 3 + b ^ 3 ≠ c ^ 3) :\n FermatLastTheoremFor 3", "start": [ 88, 1 ], "end": [ 113, 99 ], "kind": "commanddeclaration" }, { "full_name": "FermatLastTheoremForThreeGen", "code": "def FermatLastTheoremForThreeGen : Prop :=\n ∀ a b c : 𝓞 K, ∀ u : (𝓞 K)ˣ, c ≠ 0 → ¬ λ ∣ a → ¬ λ ∣ b → λ ∣ c → IsCoprime a b →\n a ^ 3 + b ^ 3 ≠ u * c ^ 3", "start": [ 125, 1 ], "end": [ 130, 30 ], "kind": "commanddeclaration" }, { "full_name": "FermatLastTheoremForThree_of_FermatLastTheoremThreeGen", "code": "lemma FermatLastTheoremForThree_of_FermatLastTheoremThreeGen :\n FermatLastTheoremForThreeGen hζ → FermatLastTheoremFor 3 := by\n intro H\n refine fermatLastTheoremThree_of_three_dvd_only_c (fun a b c hc ha hb ⟨x, hx⟩ hcoprime h ↦ ?_)\n refine H a b c 1 (by simp [hc]) (fun hdvd ↦ ha ?_) (fun hdvd ↦ hb ?_) ?_ ?_ ?_\n · rwa [← Ideal.norm_dvd_iff (hζ.prime_norm_toInteger_sub_one_of_prime_ne_two' (by decide)),\n hζ.norm_toInteger_sub_one_of_prime_ne_two' (by decide)] at hdvd\n · rwa [← Ideal.norm_dvd_iff (hζ.prime_norm_toInteger_sub_one_of_prime_ne_two' (by decide)),\n hζ.norm_toInteger_sub_one_of_prime_ne_two' (by decide)] at hdvd\n · exact dvd_trans hζ.toInteger_sub_one_dvd_prime' ⟨x, by simp [hx]⟩\n · rw [show a = algebraMap _ (𝓞 K) a by simp, show b = algebraMap _ (𝓞 K) b by simp]\n exact hcoprime.map _\n · simp only [Units.val_one, one_mul]\n exact_mod_cast h", "start": [ 132, 1 ], "end": [ 146, 21 ], "kind": "lemma" }, { "full_name": "FermatLastTheoremForThreeGen.Solution'", "code": "structure Solution' where\n a : 𝓞 K\n b : 𝓞 K\n c : 𝓞 K\n u : (𝓞 K)ˣ\n ha : ¬ λ ∣ a\n hb : ¬ λ ∣ b\n hc : c ≠ 0\n coprime : IsCoprime a b\n hcdvd : λ ∣ c\n H : a ^ 3 + b ^ 3 = u * c ^ 3", "start": [ 150, 1 ], "end": [ 163, 32 ], "kind": "commanddeclaration" }, { "full_name": "FermatLastTheoremForThreeGen.Solution", "code": "structure Solution extends Solution' hζ where\n hab : λ ^ 2 ∣ a + b", "start": [ 169, 1 ], "end": [ 171, 22 ], "kind": "commanddeclaration" }, { "full_name": "FermatLastTheoremForThreeGen.Solution'.multiplicity_lambda_c_finite", "code": "lemma Solution'.multiplicity_lambda_c_finite :\n multiplicity.Finite (hζ.toInteger - 1) S'.c :=\n multiplicity.finite_of_not_isUnit hζ.zeta_sub_one_prime'.not_unit S'.hc", "start": [ 176, 1 ], "end": [ 179, 74 ], "kind": "lemma" }, { "full_name": "FermatLastTheoremForThreeGen.Solution'.multiplicity", "code": "def Solution'.multiplicity :=\n (_root_.multiplicity (hζ.toInteger - 1) S'.c).get (multiplicity_lambda_c_finite S')", "start": [ 181, 1 ], "end": [ 184, 86 ], "kind": "commanddeclaration" }, { "full_name": "FermatLastTheoremForThreeGen.Solution.multiplicity", "code": "def Solution.multiplicity := S.toSolution'.multiplicity", "start": [ 186, 1 ], "end": [ 188, 56 ], "kind": "commanddeclaration" }, { "full_name": "FermatLastTheoremForThreeGen.Solution.isMinimal", "code": "def Solution.isMinimal : Prop := ∀ (S₁ : Solution hζ), S.multiplicity ≤ S₁.multiplicity", "start": [ 190, 1 ], "end": [ 192, 88 ], "kind": "commanddeclaration" }, { "full_name": "FermatLastTheoremForThreeGen.Solution.exists_minimal", "code": "lemma Solution.exists_minimal : ∃ (S₁ : Solution hζ), S₁.isMinimal := by\n classical\n let T := {n | ∃ (S' : Solution hζ), S'.multiplicity = n}\n rcases Nat.find_spec (⟨S.multiplicity, ⟨S, rfl⟩⟩ : T.Nonempty) with ⟨S₁, hS₁⟩\n exact ⟨S₁, fun S'' ↦ hS₁ ▸ Nat.find_min' _ ⟨S'', rfl⟩⟩", "start": [ 194, 1 ], "end": [ 199, 57 ], "kind": "lemma" }, { "full_name": "FermatLastTheoremForThreeGen.a_cube_b_cube_congr_one_or_neg_one", "code": "lemma a_cube_b_cube_congr_one_or_neg_one :\n λ ^ 4 ∣ S'.a ^ 3 - 1 ∧ λ ^ 4 ∣ S'.b ^ 3 + 1 ∨ λ ^ 4 ∣ S'.a ^ 3 + 1 ∧ λ ^ 4 ∣ S'.b ^ 3 - 1 := by\n obtain ⟨z, hz⟩ := S'.hcdvd\n rcases lambda_pow_four_dvd_cube_sub_one_or_add_one_of_lambda_not_dvd hζ S'.ha with\n (⟨x, hx⟩ | ⟨x, hx⟩) <;>\n rcases lambda_pow_four_dvd_cube_sub_one_or_add_one_of_lambda_not_dvd hζ S'.hb with\n (⟨y, hy⟩ | ⟨y, hy⟩)\n · exfalso\n replace hζ : IsPrimitiveRoot ζ ((3 : ℕ+) ^ 1) := by rwa [pow_one]\n refine hζ.toInteger_sub_one_not_dvd_two (by decide) ⟨S'.u * λ ^ 2 * z ^ 3 - λ ^ 3 * (x + y), ?_⟩\n symm\n calc _ = S'.u * (λ * z) ^ 3 - λ ^ 4 * x - λ ^ 4 * y := by ring\n _ = (S'.a ^ 3 + S'.b ^ 3) - (S'.a ^ 3 - 1) - (S'.b ^ 3 - 1) := by rw [← hx, ← hy, ← hz, ← S'.H]\n _ = 2 := by ring\n · left\n exact ⟨⟨x, hx⟩, ⟨y, hy⟩⟩\n · right\n exact ⟨⟨x, hx⟩, ⟨y, hy⟩⟩\n · exfalso\n replace hζ : IsPrimitiveRoot ζ ((3 : ℕ+) ^ 1) := by rwa [pow_one]\n refine hζ.toInteger_sub_one_not_dvd_two (by decide) ⟨λ ^ 3 * (x + y) - S'.u * λ ^ 2 * z ^ 3, ?_⟩\n symm\n calc _ = λ ^ 4 * x + λ ^ 4 * y - S'.u * (λ * z) ^ 3 := by ring\n _ = (S'.a ^ 3 + 1) + (S'.b ^ 3 + 1) - (S'.a ^ 3 + S'.b ^ 3) := by rw [← hx, ← hy, ← hz, ← S'.H]\n _ = 2 := by ring", "start": [ 201, 1 ], "end": [ 227, 21 ], "kind": "lemma" }, { "full_name": "FermatLastTheoremForThreeGen.lambda_pow_four_dvd_c_cube", "code": "lemma lambda_pow_four_dvd_c_cube : λ ^ 4 ∣ S'.c ^ 3 := by\n rcases a_cube_b_cube_congr_one_or_neg_one S' with\n (⟨⟨x, hx⟩, ⟨y, hy⟩⟩ | ⟨⟨x, hx⟩, ⟨y, hy⟩⟩) <;>\n · refine ⟨S'.u⁻¹ * (x + y), ?_⟩\n symm\n calc _ = S'.u⁻¹ * (λ ^ 4 * x + λ ^ 4 * y) := by ring\n _ = S'.u⁻¹ * (S'.a ^ 3 + S'.b ^ 3) := by rw [← hx, ← hy]; ring\n _ = S'.u⁻¹ * (S'.u * S'.c ^ 3) := by rw [S'.H]\n _ = S'.c ^ 3 := by simp", "start": [ 229, 1 ], "end": [ 238, 28 ], "kind": "lemma" }, { "full_name": "FermatLastTheoremForThreeGen.lambda_sq_dvd_c", "code": "lemma lambda_sq_dvd_c : λ ^ 2 ∣ S'.c := by\n have hm := S'.multiplicity_lambda_c_finite\n suffices 2 ≤ (multiplicity ((hζ.toInteger - 1)) S'.c).get hm by\n obtain ⟨x, hx⟩ := multiplicity.pow_multiplicity_dvd hm\n refine ⟨λ ^ ((multiplicity ((hζ.toInteger - 1)) S'.c).get hm - 2) * x, ?_⟩\n rw [← mul_assoc, ← pow_add]\n convert hx using 3\n simp [this]\n have := lambda_pow_four_dvd_c_cube S'\n have hm1 : (multiplicity (hζ.toInteger - 1) (S'.c ^ 3)).get\n (multiplicity.finite_pow hζ.zeta_sub_one_prime' hm) =\n multiplicity (hζ.toInteger - 1) (S'.c ^ 3) := by simp\n rw [multiplicity.pow_dvd_iff_le_multiplicity, ← hm1, multiplicity.pow' hζ.zeta_sub_one_prime' hm,\n Nat.cast_ofNat, Nat.ofNat_le_cast] at this\n omega", "start": [ 240, 1 ], "end": [ 255, 8 ], "kind": "lemma" }, { "full_name": "FermatLastTheoremForThreeGen.Solution'.two_le_multiplicity", "code": "lemma Solution'.two_le_multiplicity : 2 ≤ S'.multiplicity := by\n simpa [← PartENat.coe_le_coe, Solution'.multiplicity] using\n multiplicity.le_multiplicity_of_pow_dvd (lambda_sq_dvd_c S')", "start": [ 257, 1 ], "end": [ 260, 65 ], "kind": "lemma" }, { "full_name": "FermatLastTheoremForThreeGen.Solution.two_le_multiplicity", "code": "lemma Solution.two_le_multiplicity : 2 ≤ S.multiplicity :=\n S.toSolution'.two_le_multiplicity", "start": [ 262, 1 ], "end": [ 264, 36 ], "kind": "lemma" }, { "full_name": "FermatLastTheoremForThreeGen.a_cube_add_b_cube_eq_mul", "code": "lemma a_cube_add_b_cube_eq_mul :\n S'.a ^ 3 + S'.b ^ 3 = (S'.a + S'.b) * (S'.a + η * S'.b) * (S'.a + η ^ 2 * S'.b) := by\n have := hζ.isRoot_cyclotomic (by decide)\n simp only [PNat.val_ofNat, Polynomial.cyclotomic_three, Polynomial.IsRoot.def,\n Polynomial.eval_add, Polynomial.eval_pow, Polynomial.eval_X, Polynomial.eval_one] at this\n symm\n calc _ = S'.a^3+S'.a^2*S'.b*(η^2+η+1)+S'.a*S'.b^2*(η^2+η+η^3)+η^3*S'.b^3 := by ring\n _ = S'.a^3+S'.a^2*S'.b*(η^2+η+1)+S'.a*S'.b^2*(η^2+η+1)+S'.b^3 := by\n simp [hζ.toInteger_cube_eq_one]\n _ = S'.a ^ 3 + S'.b ^ 3 := by ext; simp [this]", "start": [ 266, 1 ], "end": [ 276, 49 ], "kind": "lemma" }, { "full_name": "FermatLastTheoremForThreeGen.lambda_sq_dvd_or_dvd_or_dvd", "code": "lemma lambda_sq_dvd_or_dvd_or_dvd :\n λ ^ 2 ∣ S'.a + S'.b ∨ λ ^ 2 ∣ S'.a + η * S'.b ∨ λ ^ 2 ∣ S'.a + η ^ 2 * S'.b := by\n by_contra! h\n rcases h with ⟨h1, h2, h3⟩\n rw [← multiplicity.multiplicity_lt_iff_not_dvd] at h1 h2 h3\n have h1' : multiplicity.Finite (hζ.toInteger - 1) (S'.a + S'.b) :=\n multiplicity.ne_top_iff_finite.1 (fun ht ↦ by simp [ht] at h1)\n have h2' : multiplicity.Finite (hζ.toInteger - 1) (S'.a + η * S'.b) := by\n refine multiplicity.ne_top_iff_finite.1 (fun ht ↦ ?_)\n rw [coe_eta] at ht\n simp [ht] at h2\n have h3' : multiplicity.Finite (hζ.toInteger - 1) (S'.a + η ^ 2 * S'.b) := by\n refine multiplicity.ne_top_iff_finite.1 (fun ht ↦ ?_)\n rw [coe_eta] at ht\n simp [ht] at h3\n replace h1' : (multiplicity (hζ.toInteger - 1) (S'.a + S'.b)).get h1' =\n multiplicity (hζ.toInteger - 1) (S'.a + S'.b) := by simp\n replace h2' : (multiplicity (hζ.toInteger - 1) (S'.a + η * S'.b)).get h2' =\n multiplicity (hζ.toInteger - 1) (S'.a + η * S'.b) := by simp\n replace h3' : (multiplicity (hζ.toInteger - 1) (S'.a + η ^ 2 * S'.b)).get h3' =\n multiplicity (hζ.toInteger - 1) (S'.a + η ^ 2 * S'.b) := by simp\n rw [← h1', coe_lt_coe] at h1; rw [← h2', coe_lt_coe] at h2; rw [← h3', coe_lt_coe] at h3\n have := (pow_dvd_pow_of_dvd (lambda_sq_dvd_c S') 3).mul_left S'.u\n rw [← pow_mul, ← S'.H, a_cube_add_b_cube_eq_mul, multiplicity.pow_dvd_iff_le_multiplicity,\n multiplicity.mul hζ.zeta_sub_one_prime', multiplicity.mul hζ.zeta_sub_one_prime', ← h1', ← h2',\n ← h3', ← Nat.cast_add, ← Nat.cast_add, coe_le_coe] at this\n omega", "start": [ 279, 1 ], "end": [ 307, 8 ], "kind": "lemma" }, { "full_name": "FermatLastTheoremForThreeGen.ex_cube_add_cube_eq_and_isCoprime_and_not_dvd_and_dvd", "code": "lemma ex_cube_add_cube_eq_and_isCoprime_and_not_dvd_and_dvd :\n ∃ (a' b' : 𝓞 K), a' ^ 3 + b' ^ 3 = S'.u * S'.c ^ 3 ∧ IsCoprime a' b' ∧ ¬ λ ∣ a' ∧\n ¬ λ ∣ b' ∧ λ ^ 2 ∣ a' + b' := by\n rcases lambda_sq_dvd_or_dvd_or_dvd S' with (h | h | h)\n · exact ⟨S'.a, S'.b, S'.H, S'.coprime, S'.ha, S'.hb, h⟩\n · refine ⟨S'.a, η * S'.b, ?_, ?_, S'.ha, fun ⟨x, hx⟩ ↦ S'.hb ⟨η ^ 2 * x, ?_⟩, h⟩\n · simp [mul_pow, ← val_pow_eq_pow_val, hζ.toInteger_cube_eq_one, val_one, one_mul, S'.H]\n · refine (isCoprime_mul_unit_left_right (Units.isUnit η) _ _).2 S'.coprime\n · rw [mul_comm _ x, ← mul_assoc, ← hx, mul_comm _ S'.b, mul_assoc, ← pow_succ', coe_eta,\n hζ.toInteger_cube_eq_one, mul_one]\n · refine ⟨S'.a, η ^ 2 * S'.b, ?_, ?_, S'.ha, fun ⟨x, hx⟩ ↦ S'.hb ⟨η * x, ?_⟩, h⟩\n · rw [mul_pow, ← pow_mul, mul_comm 2, pow_mul, coe_eta, hζ.toInteger_cube_eq_one, one_pow,\n one_mul, S'.H]\n · exact (isCoprime_mul_unit_left_right ((Units.isUnit η).pow _) _ _).2 S'.coprime\n · rw [mul_comm _ x, ← mul_assoc, ← hx, mul_comm _ S'.b, mul_assoc, ← pow_succ, coe_eta,\n hζ.toInteger_cube_eq_one, mul_one]", "start": [ 310, 1 ], "end": [ 327, 43 ], "kind": "lemma" }, { "full_name": "FermatLastTheoremForThreeGen.exists_Solution_of_Solution'", "code": "lemma exists_Solution_of_Solution' : ∃ (S₁ : Solution hζ), S₁.multiplicity = S'.multiplicity := by\n obtain ⟨a, b, H, coprime, ha, hb, hab⟩ := ex_cube_add_cube_eq_and_isCoprime_and_not_dvd_and_dvd S'\n exact ⟨\n { a := a\n b := b\n c := S'.c\n u := S'.u\n ha := ha\n hb := hb\n hc := S'.hc\n coprime := coprime\n hcdvd := S'.hcdvd\n H := H\n hab := hab }, rfl⟩", "start": [ 329, 1 ], "end": [ 344, 23 ], "kind": "lemma" } ]