Context stringlengths 57 6.04k | file_name stringlengths 21 79 | start int64 14 1.49k | end int64 18 1.5k | theorem stringlengths 25 1.55k | proof stringlengths 5 7.36k | goals listlengths 0 224 | goals_before listlengths 0 220 |
|---|---|---|---|---|---|---|---|
import Mathlib.Analysis.InnerProductSpace.Projection
import Mathlib.Geometry.Euclidean.PerpBisector
import Mathlib.Algebra.QuadraticDiscriminant
#align_import geometry.euclidean.basic from "leanprover-community/mathlib"@"2de9c37fa71dde2f1c6feff19876dd6a7b1519f0"
noncomputable section
open scoped Classical
open ... | Mathlib/Geometry/Euclidean/Basic.lean | 71 | 73 | theorem dist_left_midpoint_eq_dist_right_midpoint (p1 p2 : P) :
dist p1 (midpoint ℝ p1 p2) = dist p2 (midpoint ℝ p1 p2) := by |
rw [dist_left_midpoint (𝕜 := ℝ) p1 p2, dist_right_midpoint (𝕜 := ℝ) p1 p2]
| [
" dist p1 (midpoint ℝ p1 p2) = dist p2 (midpoint ℝ p1 p2)"
] | [] |
import Mathlib.RingTheory.AdjoinRoot
import Mathlib.FieldTheory.Minpoly.Field
import Mathlib.RingTheory.Polynomial.GaussLemma
#align_import field_theory.minpoly.is_integrally_closed from "leanprover-community/mathlib"@"f0c8bf9245297a541f468be517f1bde6195105e9"
open scoped Classical Polynomial
open Polynomial Set... | Mathlib/FieldTheory/Minpoly/IsIntegrallyClosed.lean | 50 | 55 | theorem isIntegrallyClosed_eq_field_fractions [IsDomain S] {s : S} (hs : IsIntegral R s) :
minpoly K (algebraMap S L s) = (minpoly R s).map (algebraMap R K) := by |
refine (eq_of_irreducible_of_monic ?_ ?_ ?_).symm
· exact ((monic hs).irreducible_iff_irreducible_map_fraction_map).1 (irreducible hs)
· rw [aeval_map_algebraMap, aeval_algebraMap_apply, aeval, map_zero]
· exact (monic hs).map _
| [
" minpoly K ((algebraMap S L) s) = map (algebraMap R K) (minpoly R s)",
" Irreducible (map (algebraMap R K) (minpoly R s))",
" (Polynomial.aeval ((algebraMap S L) s)) (map (algebraMap R K) (minpoly R s)) = 0",
" (map (algebraMap R K) (minpoly R s)).Monic"
] | [] |
import Mathlib.Analysis.LocallyConvex.BalancedCoreHull
import Mathlib.LinearAlgebra.FreeModule.Finite.Matrix
import Mathlib.Topology.Algebra.Module.Simple
import Mathlib.Topology.Algebra.Module.Determinant
import Mathlib.RingTheory.Ideal.LocalRing
#align_import topology.algebra.module.finite_dimension from "leanprove... | Mathlib/Topology/Algebra/Module/FiniteDimension.lean | 132 | 173 | theorem LinearMap.continuous_of_isClosed_ker (l : E →ₗ[𝕜] 𝕜)
(hl : IsClosed (LinearMap.ker l : Set E)) :
Continuous l := by |
-- `l` is either constant or surjective. If it is constant, the result is trivial.
by_cases H : finrank 𝕜 (LinearMap.range l) = 0
· rw [Submodule.finrank_eq_zero, LinearMap.range_eq_bot] at H
rw [H]
exact continuous_zero
· -- In the case where `l` is surjective, we factor it as `φ : (E ⧸ l.ker) ≃ₗ[𝕜]... | [
" t = UniformSpace.toTopologicalSpace",
" nhds 0 ≤ nhds 0",
" ∀ (i' : ℝ), 0 < i' → Metric.closedBall 0 i' ∈ nhds 0",
" Metric.closedBall 0 ε ∈ nhds 0",
" ξ ∈ Metric.closedBall 0 ε",
" 0 ∈ Metric.closedBall 0 ε",
" ‖ξ‖ ≤ ε",
" False",
" (ξ₀ * ξ⁻¹) • ξ ∈ balancedCore 𝕜 {ξ₀}ᶜ",
" ‖ξ₀ * ξ⁻¹‖ ≤ 1",
... | [
" t = UniformSpace.toTopologicalSpace",
" nhds 0 ≤ nhds 0",
" ∀ (i' : ℝ), 0 < i' → Metric.closedBall 0 i' ∈ nhds 0",
" Metric.closedBall 0 ε ∈ nhds 0",
" ξ ∈ Metric.closedBall 0 ε",
" 0 ∈ Metric.closedBall 0 ε",
" ‖ξ‖ ≤ ε",
" False",
" (ξ₀ * ξ⁻¹) • ξ ∈ balancedCore 𝕜 {ξ₀}ᶜ",
" ‖ξ₀ * ξ⁻¹‖ ≤ 1",
... |
import Mathlib.MeasureTheory.Function.LpSeminorm.Basic
import Mathlib.MeasureTheory.Integral.MeanInequalities
#align_import measure_theory.function.lp_seminorm from "leanprover-community/mathlib"@"c4015acc0a223449d44061e27ddac1835a3852b9"
open Filter
open scoped ENNReal Topology
namespace MeasureTheory
variable ... | Mathlib/MeasureTheory/Function/LpSeminorm/TriangleInequality.lean | 47 | 51 | theorem snormEssSup_add_le {f g : α → E} :
snormEssSup (f + g) μ ≤ snormEssSup f μ + snormEssSup g μ := by |
refine le_trans (essSup_mono_ae (eventually_of_forall fun x => ?_)) (ENNReal.essSup_add_le _ _)
simp_rw [Pi.add_apply, ← ENNReal.coe_add, ENNReal.coe_le_coe]
exact nnnorm_add_le _ _
| [
" (∫⁻ (a : α), ↑‖(f + g) a‖₊ ^ q ∂μ) ^ (1 / q) ≤\n (∫⁻ (a : α), ((fun a => ↑‖f a‖₊) + fun a => ↑‖g a‖₊) a ^ q ∂μ) ^ (1 / q)",
" ↑‖(f + g) a‖₊ ≤ ((fun a => ↑‖f a‖₊) + fun a => ↑‖g a‖₊) a",
" snormEssSup (f + g) μ ≤ snormEssSup f μ + snormEssSup g μ",
" (fun x => ↑‖(f + g) x‖₊) x ≤ ((fun x => ↑‖f x‖₊) + fun ... | [
" (∫⁻ (a : α), ↑‖(f + g) a‖₊ ^ q ∂μ) ^ (1 / q) ≤\n (∫⁻ (a : α), ((fun a => ↑‖f a‖₊) + fun a => ↑‖g a‖₊) a ^ q ∂μ) ^ (1 / q)",
" ↑‖(f + g) a‖₊ ≤ ((fun a => ↑‖f a‖₊) + fun a => ↑‖g a‖₊) a"
] |
namespace Nat
@[reducible] def Coprime (m n : Nat) : Prop := gcd m n = 1
instance (m n : Nat) : Decidable (Coprime m n) := inferInstanceAs (Decidable (_ = 1))
theorem coprime_iff_gcd_eq_one : Coprime m n ↔ gcd m n = 1 := .rfl
theorem Coprime.gcd_eq_one : Coprime m n → gcd m n = 1 := id
theorem Coprime.symm ... | .lake/packages/batteries/Batteries/Data/Nat/Gcd.lean | 49 | 51 | theorem Coprime.gcd_mul_left_cancel_right (n : Nat)
(H : Coprime k m) : gcd m (k * n) = gcd m n := by |
rw [gcd_comm m n, gcd_comm m (k * n), H.gcd_mul_left_cancel n]
| [
" k ∣ m",
" k ∣ n * m",
" ((k * m).gcd n).Coprime k",
" (m * k).gcd n = m.gcd n",
" m.gcd (k * n) = m.gcd n"
] | [
" k ∣ m",
" k ∣ n * m",
" ((k * m).gcd n).Coprime k",
" (m * k).gcd n = m.gcd n"
] |
import Mathlib.CategoryTheory.NatTrans
import Mathlib.CategoryTheory.Iso
#align_import category_theory.functor.category from "leanprover-community/mathlib"@"63721b2c3eba6c325ecf8ae8cca27155a4f6306f"
namespace CategoryTheory
-- declare the `v`'s first; see note [CategoryTheory universes].
universe v₁ v₂ v₃ u₁ u₂ u... | Mathlib/CategoryTheory/Functor/Category.lean | 121 | 122 | theorem hcomp_id_app {H : D ⥤ E} (α : F ⟶ G) (X : C) : (α ◫ 𝟙 H).app X = H.map (α.app X) := by |
simp
| [
" α.app X = β.app X",
" g = h",
" g.app X = h.app X",
" (F ⋙ H).map f ≫ (fun X => β.app (F.obj X) ≫ I.map (α.app X)) Y =\n (fun X => β.app (F.obj X) ≫ I.map (α.app X)) X ≫ (G ⋙ I).map f",
" (α ◫ 𝟙 H).app X = H.map (α.app X)"
] | [
" α.app X = β.app X",
" g = h",
" g.app X = h.app X",
" (F ⋙ H).map f ≫ (fun X => β.app (F.obj X) ≫ I.map (α.app X)) Y =\n (fun X => β.app (F.obj X) ≫ I.map (α.app X)) X ≫ (G ⋙ I).map f"
] |
import Mathlib.Order.Filter.AtTopBot
import Mathlib.Order.Filter.Subsingleton
open Set
variable {α β γ δ : Type*} {l : Filter α} {f : α → β}
namespace Filter
def EventuallyConst (f : α → β) (l : Filter α) : Prop := (map f l).Subsingleton
theorem HasBasis.eventuallyConst_iff {ι : Sort*} {p : ι → Prop} {s : ι → S... | Mathlib/Order/Filter/EventuallyConst.lean | 145 | 147 | theorem mulIndicator_const_iff :
EventuallyConst (s.mulIndicator fun _ ↦ c) l ↔ c = 1 ∨ EventuallyConst s l := by |
rcases eq_or_ne c 1 with rfl | hc <;> simp [mulIndicator_const_iff_of_ne, *]
| [
" (∃ i, p i ∧ (f '' s i).Subsingleton) ↔ ∃ i, p i ∧ ∀ x ∈ s i, ∀ y ∈ s i, f x = f y",
" EventuallyConst p l ↔ (p =ᶠ[l] fun x => False) ∨ p =ᶠ[l] fun x => True",
" EventuallyConst p l ↔ (∀ᶠ (x : α) in l, p x) ∨ ∀ᶠ (x : α) in l, ¬p x",
" EventuallyConst f l ↔ EventuallyConst g l",
" EventuallyConst s l",
" ... | [
" (∃ i, p i ∧ (f '' s i).Subsingleton) ↔ ∃ i, p i ∧ ∀ x ∈ s i, ∀ y ∈ s i, f x = f y",
" EventuallyConst p l ↔ (p =ᶠ[l] fun x => False) ∨ p =ᶠ[l] fun x => True",
" EventuallyConst p l ↔ (∀ᶠ (x : α) in l, p x) ∨ ∀ᶠ (x : α) in l, ¬p x",
" EventuallyConst f l ↔ EventuallyConst g l",
" EventuallyConst s l",
" ... |
import Mathlib.MeasureTheory.OuterMeasure.Induced
import Mathlib.MeasureTheory.OuterMeasure.AE
import Mathlib.Order.Filter.CountableInter
#align_import measure_theory.measure.measure_space_def from "leanprover-community/mathlib"@"c14c8fcde993801fca8946b0d80131a1a81d1520"
noncomputable section
open scoped Classic... | Mathlib/MeasureTheory/Measure/MeasureSpaceDef.lean | 148 | 149 | theorem outerMeasure_le_iff {m : OuterMeasure α} : m ≤ μ.1 ↔ ∀ s, MeasurableSet s → m s ≤ μ s := by |
simpa only [μ.trimmed] using OuterMeasure.le_trim_iff (m₂ := μ.1)
| [
" (inducedOuterMeasure m ⋯ m0) (iUnion f) = ∑' (i : ℕ), (inducedOuterMeasure m ⋯ m0) (f i)",
" ∑' (i : ℕ), m (f i) ⋯ = ∑' (i : ℕ), (inducedOuterMeasure m ⋯ m0) (f i)",
" (fun i => m (f i) ⋯) = fun i => (inducedOuterMeasure m ⋯ m0) (f i)",
" m (f n) ⋯ = (inducedOuterMeasure m ⋯ m0) (f n)",
" (inducedOuterMea... | [
" (inducedOuterMeasure m ⋯ m0) (iUnion f) = ∑' (i : ℕ), (inducedOuterMeasure m ⋯ m0) (f i)",
" ∑' (i : ℕ), m (f i) ⋯ = ∑' (i : ℕ), (inducedOuterMeasure m ⋯ m0) (f i)",
" (fun i => m (f i) ⋯) = fun i => (inducedOuterMeasure m ⋯ m0) (f i)",
" m (f n) ⋯ = (inducedOuterMeasure m ⋯ m0) (f n)",
" (inducedOuterMea... |
import Mathlib.CategoryTheory.Opposites
#align_import category_theory.eq_to_hom from "leanprover-community/mathlib"@"dc6c365e751e34d100e80fe6e314c3c3e0fd2988"
universe v₁ v₂ v₃ u₁ u₂ u₃
-- morphism levels before object levels. See note [CategoryTheory universes].
namespace CategoryTheory
open Opposite
variable ... | Mathlib/CategoryTheory/EqToHom.lean | 174 | 176 | theorem eqToHom_op {X Y : C} (h : X = Y) : (eqToHom h).op = eqToHom (congr_arg op h.symm) := by |
cases h
rfl
| [
" X ⟶ Y",
" Y ⟶ Y",
" eqToHom p ≫ eqToHom q = eqToHom ⋯",
" eqToHom ⋯ ≫ eqToHom q = eqToHom ⋯",
" eqToHom ⋯ ≫ eqToHom ⋯ = eqToHom ⋯",
" f = (f ≫ eqToHom p) ≫ eqToHom ⋯",
" f ≫ eqToHom p = g",
" g = eqToHom ⋯ ≫ eqToHom p ≫ g",
" eqToHom p ≫ eqToHom ⋯ ≫ f = f",
" g j = g j'",
" f j = f j'",
" z ... | [
" X ⟶ Y",
" Y ⟶ Y",
" eqToHom p ≫ eqToHom q = eqToHom ⋯",
" eqToHom ⋯ ≫ eqToHom q = eqToHom ⋯",
" eqToHom ⋯ ≫ eqToHom ⋯ = eqToHom ⋯",
" f = (f ≫ eqToHom p) ≫ eqToHom ⋯",
" f ≫ eqToHom p = g",
" g = eqToHom ⋯ ≫ eqToHom p ≫ g",
" eqToHom p ≫ eqToHom ⋯ ≫ f = f",
" g j = g j'",
" f j = f j'",
" z ... |
import Mathlib.Data.List.Basic
import Mathlib.Data.Sigma.Basic
#align_import data.list.prod_sigma from "leanprover-community/mathlib"@"dd71334db81d0bd444af1ee339a29298bef40734"
variable {α β : Type*}
namespace List
@[simp]
theorem nil_product (l : List β) : (@nil α) ×ˢ l = [] :=
rfl
#align list.nil_product... | Mathlib/Data/List/ProdSigma.lean | 45 | 48 | theorem mem_product {l₁ : List α} {l₂ : List β} {a : α} {b : β} :
(a, b) ∈ l₁ ×ˢ l₂ ↔ a ∈ l₁ ∧ b ∈ l₂ := by |
simp_all [SProd.sprod, product, mem_bind, mem_map, Prod.ext_iff, exists_prop, and_left_comm,
exists_and_left, exists_eq_left, exists_eq_right]
| [
" (head✝ :: l) ×ˢ [] = []",
" (a, b) ∈ l₁ ×ˢ l₂ ↔ a ∈ l₁ ∧ b ∈ l₂"
] | [
" (head✝ :: l) ×ˢ [] = []"
] |
import Mathlib.MeasureTheory.Constructions.Prod.Integral
import Mathlib.MeasureTheory.Integral.CircleIntegral
#align_import measure_theory.integral.torus_integral from "leanprover-community/mathlib"@"fd5edc43dc4f10b85abfe544b88f82cf13c5f844"
variable {n : ℕ}
variable {E : Type*} [NormedAddCommGroup E]
noncomputa... | Mathlib/MeasureTheory/Integral/TorusIntegral.lean | 160 | 163 | theorem torusIntegral_radius_zero (hn : n ≠ 0) (f : ℂⁿ → E) (c : ℂⁿ) :
(∯ x in T(c, 0), f x) = 0 := by |
simp only [torusIntegral, Pi.zero_apply, ofReal_zero, mul_zero, zero_mul, Fin.prod_const,
zero_pow hn, zero_smul, integral_zero]
| [
" torusMap c R θ - c = torusMap 0 R θ",
" (torusMap c R θ - c) i = torusMap 0 R θ i",
" torusMap c R θ = c ↔ R = 0",
" (∯ (x : Fin n → ℂ) in T(c, 0), f x) = 0"
] | [
" torusMap c R θ - c = torusMap 0 R θ",
" (torusMap c R θ - c) i = torusMap 0 R θ i",
" torusMap c R θ = c ↔ R = 0"
] |
import Mathlib.CategoryTheory.Monoidal.Braided.Basic
import Mathlib.CategoryTheory.Monoidal.Discrete
import Mathlib.CategoryTheory.Monoidal.CoherenceLemmas
import Mathlib.CategoryTheory.Limits.Shapes.Terminal
import Mathlib.Algebra.PUnitInstances
#align_import category_theory.monoidal.Mon_ from "leanprover-community/... | Mathlib/CategoryTheory/Monoidal/Mon_.lean | 75 | 76 | theorem one_mul_hom {Z : C} (f : Z ⟶ M.X) : (M.one ⊗ f) ≫ M.mul = (λ_ Z).hom ≫ f := by |
rw [tensorHom_def'_assoc, M.one_mul, leftUnitor_naturality]
| [
" 𝟙_ C ◁ 𝟙 (𝟙_ C) ≫ (λ_ (𝟙_ C)).hom = (ρ_ (𝟙_ C)).hom",
" (λ_ (𝟙_ C)).hom ▷ 𝟙_ C ≫ (λ_ (𝟙_ C)).hom = (α_ (𝟙_ C) (𝟙_ C) (𝟙_ C)).hom ≫ 𝟙_ C ◁ (λ_ (𝟙_ C)).hom ≫ (λ_ (𝟙_ C)).hom",
" (M.one ⊗ f) ≫ M.mul = (λ_ Z).hom ≫ f"
] | [
" 𝟙_ C ◁ 𝟙 (𝟙_ C) ≫ (λ_ (𝟙_ C)).hom = (ρ_ (𝟙_ C)).hom",
" (λ_ (𝟙_ C)).hom ▷ 𝟙_ C ≫ (λ_ (𝟙_ C)).hom = (α_ (𝟙_ C) (𝟙_ C) (𝟙_ C)).hom ≫ 𝟙_ C ◁ (λ_ (𝟙_ C)).hom ≫ (λ_ (𝟙_ C)).hom"
] |
import Mathlib.CategoryTheory.EqToHom
import Mathlib.CategoryTheory.Bicategory.Basic
#align_import category_theory.bicategory.strict from "leanprover-community/mathlib"@"dc6c365e751e34d100e80fe6e314c3c3e0fd2988"
namespace CategoryTheory
open Bicategory
universe w v u
variable (B : Type u) [Bicategory.{w, v} B]... | Mathlib/CategoryTheory/Bicategory/Strict.lean | 78 | 81 | theorem whiskerLeft_eqToHom {a b c : B} (f : a ⟶ b) {g h : b ⟶ c} (η : g = h) :
f ◁ eqToHom η = eqToHom (congr_arg₂ (· ≫ ·) rfl η) := by |
cases η
simp only [whiskerLeft_id, eqToHom_refl]
| [
" f ◁ eqToHom η = eqToHom ⋯",
" f ◁ eqToHom ⋯ = eqToHom ⋯"
] | [] |
import Mathlib.Algebra.Order.Module.OrderedSMul
import Mathlib.Algebra.Order.Module.Pointwise
import Mathlib.Data.Real.Archimedean
#align_import data.real.pointwise from "leanprover-community/mathlib"@"dde670c9a3f503647fd5bfdf1037bad526d3397a"
open Set
open Pointwise
variable {ι : Sort*} {α : Type*} [LinearOrde... | Mathlib/Data/Real/Pointwise.lean | 75 | 84 | theorem Real.sInf_smul_of_nonpos (ha : a ≤ 0) (s : Set ℝ) : sInf (a • s) = a • sSup s := by |
obtain rfl | hs := s.eq_empty_or_nonempty
· rw [smul_set_empty, Real.sInf_empty, Real.sSup_empty, smul_zero]
obtain rfl | ha' := ha.eq_or_lt
· rw [zero_smul_set hs, zero_smul]
exact csInf_singleton 0
by_cases h : BddAbove s
· exact ((OrderIso.smulRightDual ℝ ha').map_csSup' hs h).symm
· rw [Real.sInf... | [
" sInf (a • s) = a • sSup s",
" sInf (a • ∅) = a • sSup ∅",
" sInf (0 • s) = 0 • sSup s",
" sInf 0 = 0"
] | [] |
import Mathlib.MeasureTheory.Integral.SetIntegral
#align_import measure_theory.integral.average from "leanprover-community/mathlib"@"c14c8fcde993801fca8946b0d80131a1a81d1520"
open ENNReal MeasureTheory MeasureTheory.Measure Metric Set Filter TopologicalSpace Function
open scoped Topology ENNReal Convex
variable... | Mathlib/MeasureTheory/Integral/Average.lean | 365 | 366 | theorem setAverage_congr (h : s =ᵐ[μ] t) : ⨍ x in s, f x ∂μ = ⨍ x in t, f x ∂μ := by |
simp only [setAverage_eq, setIntegral_congr_set_ae h, measure_congr h]
| [
" ⨍ (x : α), 0 ∂μ = 0",
" ⨍ (x : α), f x ∂0 = 0",
" ⨍ (x : α), f x ∂μ = (μ univ).toReal⁻¹ • ∫ (x : α), f x ∂μ",
" ⨍ (x : α), f x ∂μ = ∫ (x : α), f x ∂μ",
" (μ univ).toReal • ⨍ (x : α), f x ∂μ = ∫ (x : α), f x ∂μ",
" (μ univ).toReal ≠ 0",
" μ univ ≠ 0",
" ⨍ (x : α) in s, f x ∂μ = (μ s).toReal⁻¹ • ∫ (x ... | [
" ⨍ (x : α), 0 ∂μ = 0",
" ⨍ (x : α), f x ∂0 = 0",
" ⨍ (x : α), f x ∂μ = (μ univ).toReal⁻¹ • ∫ (x : α), f x ∂μ",
" ⨍ (x : α), f x ∂μ = ∫ (x : α), f x ∂μ",
" (μ univ).toReal • ⨍ (x : α), f x ∂μ = ∫ (x : α), f x ∂μ",
" (μ univ).toReal ≠ 0",
" μ univ ≠ 0",
" ⨍ (x : α) in s, f x ∂μ = (μ s).toReal⁻¹ • ∫ (x ... |
import Mathlib.Geometry.Manifold.ContMDiff.Basic
open Set ChartedSpace SmoothManifoldWithCorners
open scoped Manifold
variable {𝕜 : Type*} [NontriviallyNormedField 𝕜]
-- declare a smooth manifold `M` over the pair `(E, H)`.
{E : Type*}
[NormedAddCommGroup E] [NormedSpace 𝕜 E] {H : Type*} [TopologicalSpace... | Mathlib/Geometry/Manifold/ContMDiff/Atlas.lean | 105 | 110 | theorem contMDiffOn_extend_symm (he : e ∈ maximalAtlas I M) :
ContMDiffOn 𝓘(𝕜, E) I n (e.extend I).symm (I '' e.target) := by |
refine (contMDiffOn_symm_of_mem_maximalAtlas he).comp
(contMDiffOn_model_symm.mono <| image_subset_range _ _) ?_
simp_rw [image_subset_iff, PartialEquiv.restr_coe_symm, I.toPartialEquiv_coe_symm,
preimage_preimage, I.left_inv, preimage_id']; rfl
| [
" ContMDiff I 𝓘(𝕜, E) n ↑I",
" ContMDiffAt I 𝓘(𝕜, E) n (↑I) x",
" ContDiffWithinAt 𝕜 n (↑(extChartAt 𝓘(𝕜, E) (↑I x)) ∘ ↑I ∘ ↑(extChartAt I x).symm) (range ↑I) (↑(extChartAt I x) x)",
" ContDiffWithinAt 𝕜 n (↑I ∘ ↑I.symm) (range ↑I) (↑I x)",
" ↑I ∘ ↑I.symm =ᶠ[nhdsWithin (↑I x) (range ↑I)] id",
" (↑... | [
" ContMDiff I 𝓘(𝕜, E) n ↑I",
" ContMDiffAt I 𝓘(𝕜, E) n (↑I) x",
" ContDiffWithinAt 𝕜 n (↑(extChartAt 𝓘(𝕜, E) (↑I x)) ∘ ↑I ∘ ↑(extChartAt I x).symm) (range ↑I) (↑(extChartAt I x) x)",
" ContDiffWithinAt 𝕜 n (↑I ∘ ↑I.symm) (range ↑I) (↑I x)",
" ↑I ∘ ↑I.symm =ᶠ[nhdsWithin (↑I x) (range ↑I)] id",
" (↑... |
import Mathlib.MeasureTheory.Function.AEEqFun.DomAct
import Mathlib.MeasureTheory.Function.LpSpace
set_option autoImplicit true
open MeasureTheory Filter
open scoped ENNReal
namespace DomMulAct
variable {M N α E : Type*} [MeasurableSpace M] [MeasurableSpace N]
[MeasurableSpace α] [NormedAddCommGroup E] {μ : Me... | Mathlib/MeasureTheory/Function/LpSpace/DomAct/Basic.lean | 78 | 79 | theorem smul_Lp_neg (c : Mᵈᵐᵃ) (f : Lp E p μ) : c • (-f) = -(c • f) := by |
rcases f with ⟨⟨_⟩, _⟩; rfl
| [
" ∀ (f g : ↥(Lp E p μ)), c • (f + g) = c • f + c • g",
" c • (⟨Quot.mk Setoid.r a✝¹, property✝¹⟩ + ⟨Quot.mk Setoid.r a✝, property✝⟩) =\n c • ⟨Quot.mk Setoid.r a✝¹, property✝¹⟩ + c • ⟨Quot.mk Setoid.r a✝, property✝⟩",
" c • -f = -(c • f)",
" c • -⟨Quot.mk Setoid.r a✝, property✝⟩ = -(c • ⟨Quot.mk Setoid.r a✝... | [
" ∀ (f g : ↥(Lp E p μ)), c • (f + g) = c • f + c • g",
" c • (⟨Quot.mk Setoid.r a✝¹, property✝¹⟩ + ⟨Quot.mk Setoid.r a✝, property✝⟩) =\n c • ⟨Quot.mk Setoid.r a✝¹, property✝¹⟩ + c • ⟨Quot.mk Setoid.r a✝, property✝⟩"
] |
import Mathlib.Algebra.IsPrimePow
import Mathlib.NumberTheory.ArithmeticFunction
import Mathlib.Analysis.SpecialFunctions.Log.Basic
#align_import number_theory.von_mangoldt from "leanprover-community/mathlib"@"c946d6097a6925ad16d7ec55677bbc977f9846de"
namespace ArithmeticFunction
open Finset Nat
open scoped Arit... | Mathlib/NumberTheory/VonMangoldt.lean | 144 | 160 | theorem sum_moebius_mul_log_eq {n : ℕ} : (∑ d ∈ n.divisors, (μ d : ℝ) * log d) = -Λ n := by |
simp only [← log_mul_moebius_eq_vonMangoldt, mul_comm log, mul_apply, log_apply, intCoe_apply, ←
Finset.sum_neg_distrib, neg_mul_eq_mul_neg]
rw [sum_divisorsAntidiagonal fun i j => (μ i : ℝ) * -Real.log j]
have : (∑ i ∈ n.divisors, (μ i : ℝ) * -Real.log (n / i : ℕ)) =
∑ i ∈ n.divisors, ((μ i : ℝ) * Rea... | [
" (fun n => (↑n).log) 0 = 0",
" Λ 1 = 0",
" 0 ≤ Λ n",
" 0 ≤ if IsPrimePow n then (↑n.minFac).log else 0",
" 0 ≤ (↑n.minFac).log",
" 0 ≤ 0",
" Λ (n ^ k) = Λ n",
" Λ p = (↑p).log",
" Λ n ≠ 0 ↔ IsPrimePow n",
" Λ 1 ≠ 0 ↔ IsPrimePow 1",
" ∑ i ∈ n.divisors, Λ i = (↑n).log",
" ∑ i ∈ divisors 0, Λ i ... | [
" (fun n => (↑n).log) 0 = 0",
" Λ 1 = 0",
" 0 ≤ Λ n",
" 0 ≤ if IsPrimePow n then (↑n.minFac).log else 0",
" 0 ≤ (↑n.minFac).log",
" 0 ≤ 0",
" Λ (n ^ k) = Λ n",
" Λ p = (↑p).log",
" Λ n ≠ 0 ↔ IsPrimePow n",
" Λ 1 ≠ 0 ↔ IsPrimePow 1",
" ∑ i ∈ n.divisors, Λ i = (↑n).log",
" ∑ i ∈ divisors 0, Λ i ... |
import Mathlib.Analysis.NormedSpace.Banach
import Mathlib.Analysis.NormedSpace.OperatorNorm.NormedSpace
import Mathlib.Topology.PartialHomeomorph
#align_import analysis.calculus.inverse from "leanprover-community/mathlib"@"2c1d8ca2812b64f88992a5294ea3dba144755cd1"
open Function Set Filter Metric
open scoped Topolo... | Mathlib/Analysis/Calculus/InverseFunctionTheorem/ApproximatesLinearOn.lean | 101 | 105 | theorem approximatesLinearOn_iff_lipschitzOnWith {f : E → F} {f' : E →L[𝕜] F} {s : Set E}
{c : ℝ≥0} : ApproximatesLinearOn f f' s c ↔ LipschitzOnWith c (f - ⇑f') s := by |
have : ∀ x y, f x - f y - f' (x - y) = (f - f') x - (f - f') y := fun x y ↦ by
simp only [map_sub, Pi.sub_apply]; abel
simp only [this, lipschitzOnWith_iff_norm_sub_le, ApproximatesLinearOn]
| [
" ApproximatesLinearOn f f' ∅ c",
" ApproximatesLinearOn f f' s c ↔ LipschitzOnWith c (f - ⇑f') s",
" f x - f y - f' (x - y) = (f - ⇑f') x - (f - ⇑f') y",
" f x - f y - (f' x - f' y) = f x - f' x - (f y - f' y)"
] | [
" ApproximatesLinearOn f f' ∅ c"
] |
import Mathlib.LinearAlgebra.CliffordAlgebra.Basic
import Mathlib.LinearAlgebra.Alternating.Basic
#align_import linear_algebra.exterior_algebra.basic from "leanprover-community/mathlib"@"b8d2eaa69d69ce8f03179a5cda774fc0cde984e4"
universe u1 u2 u3 u4 u5
variable (R : Type u1) [CommRing R]
variable (M : Type u2) [... | Mathlib/LinearAlgebra/ExteriorAlgebra/Basic.lean | 97 | 98 | theorem comp_ι_sq_zero (g : ExteriorAlgebra R M →ₐ[R] A) (m : M) : g (ι R m) * g (ι R m) = 0 := by |
rw [← AlgHom.map_mul, ι_sq_zero, AlgHom.map_zero]
| [
" g ((ι R) m) * g ((ι R) m) = 0"
] | [] |
import Mathlib.Algebra.Group.Hom.Defs
#align_import algebra.group.ext from "leanprover-community/mathlib"@"e574b1a4e891376b0ef974b926da39e05da12a06"
assert_not_exists MonoidWithZero
assert_not_exists DenselyOrdered
open Function
universe u
@[to_additive (attr := ext)]
theorem Monoid.ext {M : Type u} ⦃m₁ m₂ : Mo... | Mathlib/Algebra/Group/Ext.lean | 56 | 59 | theorem CommMonoid.toMonoid_injective {M : Type u} :
Function.Injective (@CommMonoid.toMonoid M) := by |
rintro ⟨⟩ ⟨⟩ h
congr
| [
" m₁ = m₂",
" Monoid.npow = Monoid.npow",
" Monoid.npow n x = Monoid.npow n x",
" mk one_mul✝ mul_one✝ npow✝ npow_zero✝ npow_succ✝ = m₂",
" mk one_mul✝¹ mul_one✝¹ npow✝¹ npow_zero✝¹ npow_succ✝¹ = mk one_mul✝ mul_one✝ npow✝ npow_zero✝ npow_succ✝",
" Injective (@toMonoid M)",
" mk mul_comm✝¹ = mk mul_comm... | [
" m₁ = m₂",
" Monoid.npow = Monoid.npow",
" Monoid.npow n x = Monoid.npow n x",
" mk one_mul✝ mul_one✝ npow✝ npow_zero✝ npow_succ✝ = m₂",
" mk one_mul✝¹ mul_one✝¹ npow✝¹ npow_zero✝¹ npow_succ✝¹ = mk one_mul✝ mul_one✝ npow✝ npow_zero✝ npow_succ✝"
] |
import Mathlib.LinearAlgebra.FiniteDimensional
import Mathlib.LinearAlgebra.FreeModule.Finite.Basic
import Mathlib.LinearAlgebra.FreeModule.StrongRankCondition
import Mathlib.LinearAlgebra.Projection
import Mathlib.LinearAlgebra.SesquilinearForm
import Mathlib.RingTheory.TensorProduct.Basic
import Mathlib.RingTheory.I... | Mathlib/LinearAlgebra/Dual.lean | 303 | 305 | theorem toDual_apply (i j : ι) : b.toDual (b i) (b j) = if i = j then 1 else 0 := by |
erw [constr_basis b, constr_basis b]
simp only [eq_comm]
| [
" (b.toDual (b i)) (b j) = if i = j then 1 else 0",
" (if j = i then 1 else 0) = if i = j then 1 else 0"
] | [] |
import Mathlib.CategoryTheory.Limits.Shapes.Pullbacks
import Mathlib.CategoryTheory.Limits.Preserves.Basic
#align_import category_theory.limits.preserves.shapes.pullbacks from "leanprover-community/mathlib"@"f11e306adb9f2a393539d2bb4293bf1b42caa7ac"
noncomputable section
universe v₁ v₂ u₁ u₂
-- Porting note: ne... | Mathlib/CategoryTheory/Limits/Preserves/Shapes/Pullbacks.lean | 138 | 140 | theorem PreservesPullback.iso_inv_snd :
(PreservesPullback.iso G f g).inv ≫ G.map pullback.snd = pullback.snd := by |
simp [PreservesPullback.iso, Iso.inv_comp_eq]
| [
" G.map h ≫ G.map f = G.map k ≫ G.map g",
" ∀ (j : WalkingCospan),\n ((Cones.postcompose (diagramIsoCospan (cospan f g ⋙ G)).hom).obj (G.mapCone (PullbackCone.mk h k comm))).π.app j =\n (Iso.refl\n ((Cones.postcompose (diagramIsoCospan (cospan f g ⋙ G)).hom).obj\n (G.mapCone (Pul... | [
" G.map h ≫ G.map f = G.map k ≫ G.map g",
" ∀ (j : WalkingCospan),\n ((Cones.postcompose (diagramIsoCospan (cospan f g ⋙ G)).hom).obj (G.mapCone (PullbackCone.mk h k comm))).π.app j =\n (Iso.refl\n ((Cones.postcompose (diagramIsoCospan (cospan f g ⋙ G)).hom).obj\n (G.mapCone (Pul... |
import Mathlib.Data.Finset.Lattice
import Mathlib.Data.Multiset.Powerset
#align_import data.finset.powerset from "leanprover-community/mathlib"@"9003f28797c0664a49e4179487267c494477d853"
namespace Finset
open Function Multiset
variable {α : Type*} {s t : Finset α}
section Powerset
def powerset (s : Finset... | Mathlib/Data/Finset/Powerset.lean | 99 | 113 | theorem powerset_insert [DecidableEq α] (s : Finset α) (a : α) :
powerset (insert a s) = s.powerset ∪ s.powerset.image (insert a) := by |
ext t
simp only [exists_prop, mem_powerset, mem_image, mem_union, subset_insert_iff]
by_cases h : a ∈ t
· constructor
· exact fun H => Or.inr ⟨_, H, insert_erase h⟩
· intro H
cases' H with H H
· exact Subset.trans (erase_subset a t) H
· rcases H with ⟨u, hu⟩
rw [← hu.2]
... | [
" s ∈ t.powerset ↔ s ⊆ t",
" { val := val✝, nodup := nodup✝ } ∈ t.powerset ↔ { val := val✝, nodup := nodup✝ } ⊆ t",
" ↑s.powerset = toSet ⁻¹' 𝒫↑s",
" x✝ ∈ ↑s.powerset ↔ x✝ ∈ toSet ⁻¹' 𝒫↑s",
" s.powerset = {∅} ↔ s = ∅",
" a ∉ t",
" a ∈ t → a ∈ s",
" (insert a s).powerset = s.powerset ∪ image (insert ... | [
" s ∈ t.powerset ↔ s ⊆ t",
" { val := val✝, nodup := nodup✝ } ∈ t.powerset ↔ { val := val✝, nodup := nodup✝ } ⊆ t",
" ↑s.powerset = toSet ⁻¹' 𝒫↑s",
" x✝ ∈ ↑s.powerset ↔ x✝ ∈ toSet ⁻¹' 𝒫↑s",
" s.powerset = {∅} ↔ s = ∅",
" a ∉ t",
" a ∈ t → a ∈ s"
] |
import Mathlib.NumberTheory.LegendreSymbol.Basic
import Mathlib.NumberTheory.LegendreSymbol.QuadraticChar.GaussSum
#align_import number_theory.legendre_symbol.quadratic_reciprocity from "leanprover-community/mathlib"@"5b2fe80501ff327b9109fb09b7cc8c325cd0d7d9"
open Nat
section Values
variable {p : ℕ} [Fact p.Pri... | Mathlib/NumberTheory/LegendreSymbol/QuadraticReciprocity.lean | 121 | 133 | theorem quadratic_reciprocity (hp : p ≠ 2) (hq : q ≠ 2) (hpq : p ≠ q) :
legendreSym q p * legendreSym p q = (-1) ^ (p / 2 * (q / 2)) := by |
have hp₁ := (Prime.eq_two_or_odd <| @Fact.out p.Prime _).resolve_left hp
have hq₁ := (Prime.eq_two_or_odd <| @Fact.out q.Prime _).resolve_left hq
have hq₂ : ringChar (ZMod q) ≠ 2 := (ringChar_zmod_n q).substr hq
have h :=
quadraticChar_odd_prime ((ringChar_zmod_n p).substr hp) hq ((ringChar_zmod_n p).subst... | [
" legendreSym q ↑p * legendreSym p ↑q = (-1) ^ (p / 2 * (q / 2))",
" ↑↑n = ↑n",
" ↑((-1) ^ (p / 2)) = (-1) ^ (p / 2)"
] | [] |
import Mathlib.Algebra.Polynomial.AlgebraMap
import Mathlib.Algebra.Polynomial.Reverse
import Mathlib.Algebra.Polynomial.Inductions
import Mathlib.RingTheory.Localization.Basic
#align_import data.polynomial.laurent from "leanprover-community/mathlib"@"831c494092374cfe9f50591ed0ac81a25efc5b86"
open Polynomial Func... | Mathlib/Algebra/Polynomial/Laurent.lean | 185 | 187 | theorem T_add (m n : ℤ) : (T (m + n) : R[T;T⁻¹]) = T m * T n := by |
-- Porting note: was `convert single_mul_single.symm`
simp [T, single_mul_single]
| [
" (C t) n = if n = 0 then t else 0",
" (if 0 = n then t else 0) = if n = 0 then t else 0",
" T (m + n) = T m * T n"
] | [
" (C t) n = if n = 0 then t else 0",
" (if 0 = n then t else 0) = if n = 0 then t else 0"
] |
import Mathlib.Algebra.Polynomial.AlgebraMap
import Mathlib.Algebra.Polynomial.Monic
#align_import data.polynomial.lifts from "leanprover-community/mathlib"@"63417e01fbc711beaf25fa73b6edb395c0cfddd0"
open Polynomial
noncomputable section
namespace Polynomial
universe u v w
section Semiring
variable {R : Type... | Mathlib/Algebra/Polynomial/Lifts.lean | 280 | 282 | theorem mem_lifts_iff_mem_alg (R : Type u) [CommSemiring R] {S : Type v} [Semiring S] [Algebra R S]
(p : S[X]) : p ∈ lifts (algebraMap R S) ↔ p ∈ AlgHom.range (@mapAlg R _ S _ _) := by |
simp only [coe_mapRingHom, lifts, mapAlg_eq_map, AlgHom.mem_range, RingHom.mem_rangeS]
| [
" p ∈ lifts f ↔ ∃ q, map f q = p",
" p ∈ lifts f ↔ p ∈ Set.range (map f)",
" p ∈ lifts f ↔ p ∈ (mapRingHom f).rangeS",
" p ∈ lifts f ↔ ∀ (n : ℕ), p.coeff n ∈ Set.range ⇑f",
" (∀ (n : ℕ), p.coeff n ∈ f.rangeS) ↔ ∀ (n : ℕ), p.coeff n ∈ Set.range ⇑f",
" (mapRingHom f) (C r) = C (f r)",
" C s ∈ lifts f",
... | [
" p ∈ lifts f ↔ ∃ q, map f q = p",
" p ∈ lifts f ↔ p ∈ Set.range (map f)",
" p ∈ lifts f ↔ p ∈ (mapRingHom f).rangeS",
" p ∈ lifts f ↔ ∀ (n : ℕ), p.coeff n ∈ Set.range ⇑f",
" (∀ (n : ℕ), p.coeff n ∈ f.rangeS) ↔ ∀ (n : ℕ), p.coeff n ∈ Set.range ⇑f",
" (mapRingHom f) (C r) = C (f r)",
" C s ∈ lifts f",
... |
import Mathlib.Algebra.Order.Ring.Abs
import Mathlib.Algebra.Polynomial.Derivative
import Mathlib.Data.Nat.Factorial.DoubleFactorial
#align_import ring_theory.polynomial.hermite.basic from "leanprover-community/mathlib"@"938d3db9c278f8a52c0f964a405806f0f2b09b74"
noncomputable section
open Polynomial
namespace P... | Mathlib/RingTheory/Polynomial/Hermite/Basic.lean | 92 | 99 | theorem coeff_hermite_of_lt {n k : ℕ} (hnk : n < k) : coeff (hermite n) k = 0 := by |
obtain ⟨k, rfl⟩ := Nat.exists_eq_add_of_lt hnk
clear hnk
induction' n with n ih generalizing k
· apply coeff_C
· have : n + k + 1 + 2 = n + (k + 2) + 1 := by ring
rw [coeff_hermite_succ_succ, add_right_comm, this, ih k, ih (k + 2),
mul_zero, sub_zero]
| [
" hermite (n + 1) = X * hermite n - derivative (hermite n)",
" hermite n = (fun p => X * p - derivative p)^[n] 1",
" hermite 0 = (fun p => X * p - derivative p)^[0] 1",
" hermite (n + 1) = (fun p => X * p - derivative p)^[n + 1] 1",
" hermite 1 = X",
" X * C 1 - derivative (C 1) = X",
" (hermite (n + 1)... | [
" hermite (n + 1) = X * hermite n - derivative (hermite n)",
" hermite n = (fun p => X * p - derivative p)^[n] 1",
" hermite 0 = (fun p => X * p - derivative p)^[0] 1",
" hermite (n + 1) = (fun p => X * p - derivative p)^[n + 1] 1",
" hermite 1 = X",
" X * C 1 - derivative (C 1) = X",
" (hermite (n + 1)... |
import Mathlib.CategoryTheory.Galois.Basic
import Mathlib.RepresentationTheory.Action.Basic
import Mathlib.RepresentationTheory.Action.Concrete
import Mathlib.RepresentationTheory.Action.Limits
import Mathlib.CategoryTheory.Limits.FintypeCat
import Mathlib.CategoryTheory.Limits.Shapes.Types
import Mathlib.Logic.Equiv.... | Mathlib/CategoryTheory/Galois/Examples.lean | 104 | 124 | theorem Action.pretransitive_of_isConnected (X : Action FintypeCat (MonCat.of G))
[IsConnected X] : MulAction.IsPretransitive G X.V where
exists_smul_eq x y := by |
/- We show that the `G`-orbit of `x` is a non-initial subobject of `X` and hence by
connectedness, the orbit equals `X.V`. -/
let T : Set X.V := MulAction.orbit G x
have : Fintype T := Fintype.ofFinite T
letI : MulAction G (FintypeCat.of T) := inferInstanceAs <| MulAction G ↑(MulAction.orbit G x)
... | [
" FintypeCat",
" Y.ρ g ↑y ∈ (Set.range f.hom)ᶜ",
" False",
" ↑y ∈ Set.range f.hom",
" f.hom (X.ρ g⁻¹ x) = ↑y",
" (X.ρ g⁻¹ ≫ f.hom) x = (Y.ρ g⁻¹ * Y.ρ g) ↑y",
" Y.ρ g⁻¹ (Y.ρ g ↑y) = (Y.ρ g⁻¹ * Y.ρ g) ↑y",
" (Y.ρ g⁻¹ * Y.ρ g) ↑y = ↑y",
" (fun g y => ⟨Y.ρ g ↑y, ⋯⟩) 1 = 1",
" (fun y => ⟨𝟙 Y.V ↑y, ⋯⟩)... | [
" FintypeCat",
" Y.ρ g ↑y ∈ (Set.range f.hom)ᶜ",
" False",
" ↑y ∈ Set.range f.hom",
" f.hom (X.ρ g⁻¹ x) = ↑y",
" (X.ρ g⁻¹ ≫ f.hom) x = (Y.ρ g⁻¹ * Y.ρ g) ↑y",
" Y.ρ g⁻¹ (Y.ρ g ↑y) = (Y.ρ g⁻¹ * Y.ρ g) ↑y",
" (Y.ρ g⁻¹ * Y.ρ g) ↑y = ↑y",
" (fun g y => ⟨Y.ρ g ↑y, ⋯⟩) 1 = 1",
" (fun y => ⟨𝟙 Y.V ↑y, ⋯⟩)... |
import Mathlib.Algebra.Polynomial.AlgebraMap
import Mathlib.Data.Matrix.Basis
import Mathlib.Data.Matrix.DMatrix
import Mathlib.RingTheory.MatrixAlgebra
#align_import ring_theory.polynomial_algebra from "leanprover-community/mathlib"@"565eb991e264d0db702722b4bde52ee5173c9950"
universe u v w
open Polynomial Tensor... | Mathlib/RingTheory/PolynomialAlgebra.lean | 80 | 82 | theorem toFunLinear_mul_tmul_mul_aux_1 (p : R[X]) (k : ℕ) (h : Decidable ¬p.coeff k = 0) (a : A) :
ite (¬coeff p k = 0) (a * (algebraMap R A) (coeff p k)) 0 =
a * (algebraMap R A) (coeff p k) := by | classical split_ifs <;> simp [*]
| [
" ((toFunBilinear R A) a) p = p.sum fun n r => (monomial n) (a * (algebraMap R A) r)",
" ∑ x ∈ p.support, a • ((algebraMap R A[X]) (p.coeff x) * X ^ x) =\n ∑ x ∈ p.support, (monomial x) (a * (algebraMap R A) (p.coeff x))",
" a • ((algebraMap R A[X]) (p.coeff i) * X ^ i) = (monomial i) (a * (algebraMap R A) (... | [
" ((toFunBilinear R A) a) p = p.sum fun n r => (monomial n) (a * (algebraMap R A) r)",
" ∑ x ∈ p.support, a • ((algebraMap R A[X]) (p.coeff x) * X ^ x) =\n ∑ x ∈ p.support, (monomial x) (a * (algebraMap R A) (p.coeff x))",
" a • ((algebraMap R A[X]) (p.coeff i) * X ^ i) = (monomial i) (a * (algebraMap R A) (... |
import Mathlib.CategoryTheory.EqToHom
import Mathlib.CategoryTheory.Bicategory.Basic
#align_import category_theory.bicategory.strict from "leanprover-community/mathlib"@"dc6c365e751e34d100e80fe6e314c3c3e0fd2988"
namespace CategoryTheory
open Bicategory
universe w v u
variable (B : Type u) [Bicategory.{w, v} B]... | Mathlib/CategoryTheory/Bicategory/Strict.lean | 85 | 88 | theorem eqToHom_whiskerRight {a b c : B} {f g : a ⟶ b} (η : f = g) (h : b ⟶ c) :
eqToHom η ▷ h = eqToHom (congr_arg₂ (· ≫ ·) η rfl) := by |
cases η
simp only [id_whiskerRight, eqToHom_refl]
| [
" f ◁ eqToHom η = eqToHom ⋯",
" f ◁ eqToHom ⋯ = eqToHom ⋯",
" eqToHom η ▷ h = eqToHom ⋯",
" eqToHom ⋯ ▷ h = eqToHom ⋯"
] | [
" f ◁ eqToHom η = eqToHom ⋯",
" f ◁ eqToHom ⋯ = eqToHom ⋯"
] |
import Mathlib.Probability.Kernel.Disintegration.Unique
import Mathlib.Probability.Notation
#align_import probability.kernel.cond_distrib from "leanprover-community/mathlib"@"00abe0695d8767201e6d008afa22393978bb324d"
open MeasureTheory Set Filter TopologicalSpace
open scoped ENNReal MeasureTheory ProbabilityTheo... | Mathlib/Probability/Kernel/CondDistrib.lean | 209 | 213 | theorem set_lintegral_condDistrib_of_measurableSet (hX : Measurable X) (hY : AEMeasurable Y μ)
(hs : MeasurableSet s) {t : Set α} (ht : MeasurableSet[mβ.comap X] t) :
∫⁻ a in t, condDistrib Y X μ (X a) s ∂μ = μ (t ∩ Y ⁻¹' s) := by |
obtain ⟨t', ht', rfl⟩ := ht
rw [set_lintegral_preimage_condDistrib hX hY hs ht']
| [
" IsMarkovKernel (condDistrib Y X μ)",
" IsMarkovKernel (Measure.map (fun a => (X a, Y a)) μ).condKernel",
" ((condDistrib Y X μ) x) s = ((Measure.map X μ) {x})⁻¹ * (Measure.map (fun a => (X a, Y a)) μ) ({x} ×ˢ s)",
" ((Measure.map (fun a => (X a, Y a)) μ).fst {x})⁻¹ * (Measure.map (fun a => (X a, Y a)) μ) ({... | [
" IsMarkovKernel (condDistrib Y X μ)",
" IsMarkovKernel (Measure.map (fun a => (X a, Y a)) μ).condKernel",
" ((condDistrib Y X μ) x) s = ((Measure.map X μ) {x})⁻¹ * (Measure.map (fun a => (X a, Y a)) μ) ({x} ×ˢ s)",
" ((Measure.map (fun a => (X a, Y a)) μ).fst {x})⁻¹ * (Measure.map (fun a => (X a, Y a)) μ) ({... |
import Mathlib.Algebra.ContinuedFractions.Computation.Basic
import Mathlib.Algebra.ContinuedFractions.Translations
#align_import algebra.continued_fractions.computation.translations from "leanprover-community/mathlib"@"a7e36e48519ab281320c4d192da6a7b348ce40ad"
namespace GeneralizedContinuedFraction
open Generali... | Mathlib/Algebra/ContinuedFractions/Computation/Translations.lean | 226 | 234 | theorem IntFractPair.exists_succ_get?_stream_of_gcf_of_get?_eq_some {gp_n : Pair K}
(s_nth_eq : (of v).s.get? n = some gp_n) :
∃ ifp : IntFractPair K, IntFractPair.stream v (n + 1) = some ifp ∧ (ifp.b : K) = gp_n.b := by |
obtain ⟨ifp, stream_succ_nth_eq, gp_n_eq⟩ :
∃ ifp, IntFractPair.stream v (n + 1) = some ifp ∧ Pair.mk 1 (ifp.b : K) = gp_n := by
unfold of IntFractPair.seq1 at s_nth_eq
simpa [Stream'.Seq.get?_tail, Stream'.Seq.map_get?] using s_nth_eq
cases gp_n_eq
simp_all only [Option.some.injEq, exists_eq_left']
| [
" ∃ ifp, IntFractPair.stream v (n + 1) = some ifp ∧ ↑ifp.b = gp_n.b",
" ∃ ifp, IntFractPair.stream v (n + 1) = some ifp ∧ { a := 1, b := ↑ifp.b } = gp_n",
" ∃ ifp_1, IntFractPair.stream v (n + 1) = some ifp_1 ∧ ↑ifp_1.b = { a := 1, b := ↑ifp.b }.b"
] | [] |
import Mathlib.Analysis.InnerProductSpace.Projection
import Mathlib.Dynamics.BirkhoffSum.NormedSpace
open Filter Finset Function Bornology
open scoped Topology
variable {𝕜 E : Type*} [RCLike 𝕜] [NormedAddCommGroup E]
theorem LinearMap.tendsto_birkhoffAverage_of_ker_subset_closure [NormedSpace 𝕜 E]
(f : E ... | Mathlib/Analysis/InnerProductSpace/MeanErgodic.lean | 84 | 103 | theorem ContinuousLinearMap.tendsto_birkhoffAverage_orthogonalProjection (f : E →L[𝕜] E)
(hf : ‖f‖ ≤ 1) (x : E) :
Tendsto (birkhoffAverage 𝕜 f _root_.id · x) atTop
(𝓝 <| orthogonalProjection (LinearMap.eqLocus f 1) x) := by |
/- Due to the previous theorem, it suffices to verify
that the range of `f - 1` is dense in the orthogonal complement
to the submodule of fixed points of `f`. -/
apply (f : E →ₗ[𝕜] E).tendsto_birkhoffAverage_of_ker_subset_closure (f.lipschitz.weaken hf)
· exact orthogonalProjection_mem_subspace_eq_self (K :... | [
" Tendsto (fun x_1 => birkhoffAverage 𝕜 (⇑f) _root_.id x_1 x) atTop (𝓝 ↑(g x))",
" g (x - ↑(g x)) = 0",
" x = x - ↑(g x) + ↑(g x)",
" Tendsto (fun x => birkhoffAverage 𝕜 (⇑f) _root_.id x (y + z)) atTop (𝓝 ↑(g (y + z)))",
" Tendsto (fun x => birkhoffAverage 𝕜 (⇑f) _root_.id x y) atTop (𝓝 0)",
" (f - ... | [
" Tendsto (fun x_1 => birkhoffAverage 𝕜 (⇑f) _root_.id x_1 x) atTop (𝓝 ↑(g x))",
" g (x - ↑(g x)) = 0",
" x = x - ↑(g x) + ↑(g x)",
" Tendsto (fun x => birkhoffAverage 𝕜 (⇑f) _root_.id x (y + z)) atTop (𝓝 ↑(g (y + z)))",
" Tendsto (fun x => birkhoffAverage 𝕜 (⇑f) _root_.id x y) atTop (𝓝 0)",
" (f - ... |
import Mathlib.GroupTheory.OrderOfElement
import Mathlib.Data.Finset.NoncommProd
import Mathlib.Data.Fintype.BigOperators
import Mathlib.Data.Nat.GCD.BigOperators
import Mathlib.Order.SupIndep
#align_import group_theory.noncomm_pi_coprod from "leanprover-community/mathlib"@"6f9f36364eae3f42368b04858fd66d6d9ae730d8"
... | Mathlib/GroupTheory/NoncommPiCoprod.lean | 282 | 285 | theorem commute_subtype_of_commute (i j : ι) (hne : i ≠ j) :
∀ (x : H i) (y : H j), Commute ((H i).subtype x) ((H j).subtype y) := by |
rintro ⟨x, hx⟩ ⟨y, hy⟩
exact hcomm hne x y hx hy
| [
" ∀ (x : ↥(H i)) (y : ↥(H j)), Commute ((H i).subtype x) ((H j).subtype y)",
" Commute ((H i).subtype ⟨x, hx⟩) ((H j).subtype ⟨y, hy⟩)"
] | [] |
import Mathlib.Data.Matrix.Basic
variable {l m n o : Type*}
universe u v w
variable {R : Type*} {α : Type v} {β : Type w}
namespace Matrix
def col (w : m → α) : Matrix m Unit α :=
of fun x _ => w x
#align matrix.col Matrix.col
-- TODO: set as an equation lemma for `col`, see mathlib4#3024
@[simp]
theorem col... | Mathlib/Data/Matrix/RowCol.lean | 67 | 69 | theorem col_smul [SMul R α] (x : R) (v : m → α) : col (x • v) = x • col v := by |
ext
rfl
| [
" col (v + w) = col v + col w",
" col (v + w) i✝ j✝ = (col v + col w) i✝ j✝",
" col (x • v) = x • col v",
" col (x • v) i✝ j✝ = (x • col v) i✝ j✝"
] | [
" col (v + w) = col v + col w",
" col (v + w) i✝ j✝ = (col v + col w) i✝ j✝"
] |
import Mathlib.Data.List.Basic
namespace List
variable {α β : Type*}
@[simp]
| Mathlib/Data/List/ReduceOption.lean | 19 | 21 | theorem reduceOption_cons_of_some (x : α) (l : List (Option α)) :
reduceOption (some x :: l) = x :: l.reduceOption := by |
simp only [reduceOption, filterMap, id, eq_self_iff_true, and_self_iff]
| [
" (some x :: l).reduceOption = x :: l.reduceOption"
] | [] |
import Mathlib.Algebra.MvPolynomial.Variables
#align_import data.mv_polynomial.supported from "leanprover-community/mathlib"@"2f5b500a507264de86d666a5f87ddb976e2d8de4"
universe u v w
namespace MvPolynomial
variable {σ τ : Type*} {R : Type u} {S : Type v} {r : R} {e : ℕ} {n m : σ}
section CommSemiring
variable... | Mathlib/Algebra/MvPolynomial/Supported.lean | 135 | 141 | theorem exists_restrict_to_vars (R : Type*) [CommRing R] {F : MvPolynomial σ ℤ}
(hF : ↑F.vars ⊆ s) : ∃ f : (s → R) → R, ∀ x : σ → R, f (x ∘ (↑) : s → R) = aeval x F := by |
rw [← mem_supported, supported_eq_range_rename, AlgHom.mem_range] at hF
cases' hF with F' hF'
use fun z ↦ aeval z F'
intro x
simp only [← hF', aeval_rename]
| [
" supported R s = (rename Subtype.val).range",
" (aeval fun x => X ↑x).range = (aeval (X ∘ Subtype.val)).range",
" (supportedEquivMvPolynomial s).symm (C x) = (algebraMap R ↥(supported R s)) x",
" ↑((supportedEquivMvPolynomial s).symm (C x)) = ↑((algebraMap R ↥(supported R s)) x)",
" ↑((supportedEquivMvPoly... | [
" supported R s = (rename Subtype.val).range",
" (aeval fun x => X ↑x).range = (aeval (X ∘ Subtype.val)).range",
" (supportedEquivMvPolynomial s).symm (C x) = (algebraMap R ↥(supported R s)) x",
" ↑((supportedEquivMvPolynomial s).symm (C x)) = ↑((algebraMap R ↥(supported R s)) x)",
" ↑((supportedEquivMvPoly... |
import Mathlib.MeasureTheory.Function.ConditionalExpectation.CondexpL1
#align_import measure_theory.function.conditional_expectation.basic from "leanprover-community/mathlib"@"d8bbb04e2d2a44596798a9207ceefc0fb236e41e"
open TopologicalSpace MeasureTheory.Lp Filter
open scoped ENNReal Topology MeasureTheory
names... | Mathlib/MeasureTheory/Function/ConditionalExpectation/Basic.lean | 106 | 106 | theorem condexp_of_not_le (hm_not : ¬m ≤ m0) : μ[f|m] = 0 := by | rw [condexp, dif_neg hm_not]
| [
" μ[f|m] = 0"
] | [] |
import Mathlib.RepresentationTheory.FdRep
import Mathlib.LinearAlgebra.Trace
import Mathlib.RepresentationTheory.Invariants
#align_import representation_theory.character from "leanprover-community/mathlib"@"55b3f8206b8596db8bb1804d8a92814a0b6670c9"
noncomputable section
universe u
open CategoryTheory LinearMap ... | Mathlib/RepresentationTheory/Character.lean | 64 | 65 | theorem char_tensor (V W : FdRep k G) : (V ⊗ W).character = V.character * W.character := by |
ext g; convert trace_tensorProduct' (V.ρ g) (W.ρ g)
| [
" V.character (h * g) = V.character (g * h)",
" V.character 1 = ↑(finrank k (CoeSort.coe V))",
" (V ⊗ W).character = V.character * W.character",
" (V ⊗ W).character g = (V.character * W.character) g"
] | [
" V.character (h * g) = V.character (g * h)",
" V.character 1 = ↑(finrank k (CoeSort.coe V))"
] |
import Mathlib.Data.Nat.Choose.Basic
import Mathlib.Data.Nat.GCD.Basic
import Mathlib.Tactic.Ring
import Mathlib.Tactic.Linarith
#align_import data.nat.choose.central from "leanprover-community/mathlib"@"0a0ec35061ed9960bf0e7ffb0335f44447b58977"
namespace Nat
def centralBinom (n : ℕ) :=
(2 * n).choose n
#alig... | Mathlib/Data/Nat/Choose/Central.lean | 131 | 138 | theorem succ_dvd_centralBinom (n : ℕ) : n + 1 ∣ n.centralBinom := by |
have h_s : (n + 1).Coprime (2 * n + 1) := by
rw [two_mul, add_assoc, coprime_add_self_right, coprime_self_add_left]
exact coprime_one_left n
apply h_s.dvd_of_dvd_mul_left
apply Nat.dvd_of_mul_dvd_mul_left zero_lt_two
rw [← mul_assoc, ← succ_mul_centralBinom_succ, mul_comm]
exact mul_dvd_mul_left _ (t... | [
" (2 * n).choose (2 * n / 2) = (2 * n).choose n",
" (2 * n + 2).choose (n + 1) * (n + 1) = (2 * n + 1).choose n * (2 * n + 2)",
" (2 * n + 1).choose n * (2 * n + 2) = 2 * ((2 * n + 1).choose n * (n + 1))",
" 2 * ((2 * n + 1).choose n * (n + 1)) = 2 * ((2 * n + 1).choose n * (2 * n + 1 - n))",
" 2 * ((2 * n ... | [
" (2 * n).choose (2 * n / 2) = (2 * n).choose n",
" (2 * n + 2).choose (n + 1) * (n + 1) = (2 * n + 1).choose n * (2 * n + 2)",
" (2 * n + 1).choose n * (2 * n + 2) = 2 * ((2 * n + 1).choose n * (n + 1))",
" 2 * ((2 * n + 1).choose n * (n + 1)) = 2 * ((2 * n + 1).choose n * (2 * n + 1 - n))",
" 2 * ((2 * n ... |
import Mathlib.Topology.Separation
import Mathlib.Topology.UniformSpace.Basic
import Mathlib.Topology.UniformSpace.Cauchy
#align_import topology.uniform_space.uniform_convergence from "leanprover-community/mathlib"@"2705404e701abc6b3127da906f40bae062a169c9"
noncomputable section
open Topology Uniformity Filter S... | Mathlib/Topology/UniformSpace/UniformConvergence.lean | 142 | 144 | theorem tendstoUniformly_iff_tendstoUniformlyOnFilter :
TendstoUniformly F f p ↔ TendstoUniformlyOnFilter F f p ⊤ := by |
rw [← tendstoUniformlyOn_univ, tendstoUniformlyOn_iff_tendstoUniformlyOnFilter, principal_univ]
| [
" TendstoUniformlyOn F f p s ↔ TendstoUniformlyOnFilter F f p (𝓟 s)",
" (∀ u ∈ 𝓤 β, ∀ᶠ (n : ι) in p, ∀ x ∈ s, (f x, F n x) ∈ u) ↔\n ∀ u ∈ 𝓤 β, ∀ᶠ (n : ι × α) in p ×ˢ 𝓟 s, (f n.2, F n.1 n.2) ∈ u",
" ∀ a ∈ 𝓤 β, (∀ᶠ (n : ι) in p, ∀ x ∈ s, (f x, F n x) ∈ a) ↔ ∀ᶠ (n : ι × α) in p ×ˢ 𝓟 s, (f n.2, F n.1 n.2) ... | [
" TendstoUniformlyOn F f p s ↔ TendstoUniformlyOnFilter F f p (𝓟 s)",
" (∀ u ∈ 𝓤 β, ∀ᶠ (n : ι) in p, ∀ x ∈ s, (f x, F n x) ∈ u) ↔\n ∀ u ∈ 𝓤 β, ∀ᶠ (n : ι × α) in p ×ˢ 𝓟 s, (f n.2, F n.1 n.2) ∈ u",
" ∀ a ∈ 𝓤 β, (∀ᶠ (n : ι) in p, ∀ x ∈ s, (f x, F n x) ∈ a) ↔ ∀ᶠ (n : ι × α) in p ×ˢ 𝓟 s, (f n.2, F n.1 n.2) ... |
import Mathlib.Analysis.InnerProductSpace.Adjoint
#align_import analysis.inner_product_space.positive from "leanprover-community/mathlib"@"caa58cbf5bfb7f81ccbaca4e8b8ac4bc2b39cc1c"
open InnerProductSpace RCLike ContinuousLinearMap
open scoped InnerProduct ComplexConjugate
namespace ContinuousLinearMap
variable... | Mathlib/Analysis/InnerProductSpace/Positive.lean | 71 | 74 | theorem isPositive_zero : IsPositive (0 : E →L[𝕜] E) := by |
refine ⟨isSelfAdjoint_zero _, fun x => ?_⟩
change 0 ≤ re ⟪_, _⟫
rw [zero_apply, inner_zero_left, ZeroHomClass.map_zero]
| [
" 0 ≤ re ⟪x, T x⟫_𝕜",
" 0 ≤ re ⟪T x, x⟫_𝕜",
" IsPositive 0",
" 0 ≤ reApplyInnerSelf 0 x",
" 0 ≤ re ⟪0 x, x⟫_𝕜"
] | [
" 0 ≤ re ⟪x, T x⟫_𝕜",
" 0 ≤ re ⟪T x, x⟫_𝕜"
] |
import Mathlib.Data.List.Nodup
import Mathlib.Data.List.Zip
import Mathlib.Data.Nat.Defs
import Mathlib.Data.List.Infix
#align_import data.list.rotate from "leanprover-community/mathlib"@"f694c7dead66f5d4c80f446c796a5aad14707f0e"
universe u
variable {α : Type u}
open Nat Function
namespace List
theorem rotate... | Mathlib/Data/List/Rotate.lean | 41 | 41 | theorem rotate_nil (n : ℕ) : ([] : List α).rotate n = [] := by | simp [rotate]
| [
" l.rotate (n % l.length) = l.rotate n",
" [].rotate n = []"
] | [
" l.rotate (n % l.length) = l.rotate n"
] |
import Mathlib.Algebra.BigOperators.Intervals
import Mathlib.Analysis.Normed.Group.Basic
import Mathlib.Topology.Instances.NNReal
#align_import analysis.normed.group.infinite_sum from "leanprover-community/mathlib"@"9a59dcb7a2d06bf55da57b9030169219980660cd"
open Topology NNReal
open Finset Filter Metric
variabl... | Mathlib/Analysis/Normed/Group/InfiniteSum.lean | 78 | 89 | theorem cauchySeq_range_of_norm_bounded {f : ℕ → E} (g : ℕ → ℝ)
(hg : CauchySeq fun n => ∑ i ∈ range n, g i) (hf : ∀ i, ‖f i‖ ≤ g i) :
CauchySeq fun n => ∑ i ∈ range n, f i := by |
refine Metric.cauchySeq_iff'.2 fun ε hε => ?_
refine (Metric.cauchySeq_iff'.1 hg ε hε).imp fun N hg n hn => ?_
specialize hg n hn
rw [dist_eq_norm, ← sum_Ico_eq_sub _ hn] at hg ⊢
calc
‖∑ k ∈ Ico N n, f k‖ ≤ ∑ k ∈ _, ‖f k‖ := norm_sum_le _ _
_ ≤ ∑ k ∈ _, g k := sum_le_sum fun x _ => hf x
_ ≤ ‖∑ k ... | [
" (CauchySeq fun s => ∑ i ∈ s, f i) ↔ ∀ ε > 0, ∃ s, ∀ (t : Finset ι), Disjoint t s → ‖∑ i ∈ t, f i‖ < ε",
" (∀ (i : ℝ), 0 < i → ∃ s, ∀ (t : Finset ι), Disjoint t s → ∑ b ∈ t, f b ∈ ball 0 i) ↔\n ∀ ε > 0, ∃ s, ∀ (t : Finset ι), Disjoint t s → ‖∑ i ∈ t, f i‖ < ε",
" ∀ ⦃s t : Set E⦄,\n s ⊆ t →\n (∃ s_1,... | [
" (CauchySeq fun s => ∑ i ∈ s, f i) ↔ ∀ ε > 0, ∃ s, ∀ (t : Finset ι), Disjoint t s → ‖∑ i ∈ t, f i‖ < ε",
" (∀ (i : ℝ), 0 < i → ∃ s, ∀ (t : Finset ι), Disjoint t s → ∑ b ∈ t, f b ∈ ball 0 i) ↔\n ∀ ε > 0, ∃ s, ∀ (t : Finset ι), Disjoint t s → ‖∑ i ∈ t, f i‖ < ε",
" ∀ ⦃s t : Set E⦄,\n s ⊆ t →\n (∃ s_1,... |
import Mathlib.Algebra.BigOperators.Group.Multiset
import Mathlib.Data.Multiset.Dedup
#align_import data.multiset.bind from "leanprover-community/mathlib"@"f694c7dead66f5d4c80f446c796a5aad14707f0e"
assert_not_exists MonoidWithZero
assert_not_exists MulAction
universe v
variable {α : Type*} {β : Type v} {γ δ : Ty... | Mathlib/Data/Multiset/Bind.lean | 130 | 130 | theorem singleton_bind : bind {a} f = f a := by | simp [bind]
| [
" (↑(List.map ofList (l :: L))).join = ↑(l :: L).join",
" a ∈ join 0 ↔ ∃ s ∈ 0, a ∈ s",
" ∀ (a_1 : Multiset α) (s : Multiset (Multiset α)),\n (a ∈ s.join ↔ ∃ s_1 ∈ s, a ∈ s_1) → (a ∈ (a_1 ::ₘ s).join ↔ ∃ s_1 ∈ a_1 ::ₘ s, a ∈ s_1)",
" card (join 0) = (map (⇑card) 0).sum",
" ∀ (a : Multiset α) (s : Multise... | [
" (↑(List.map ofList (l :: L))).join = ↑(l :: L).join",
" a ∈ join 0 ↔ ∃ s ∈ 0, a ∈ s",
" ∀ (a_1 : Multiset α) (s : Multiset (Multiset α)),\n (a ∈ s.join ↔ ∃ s_1 ∈ s, a ∈ s_1) → (a ∈ (a_1 ::ₘ s).join ↔ ∃ s_1 ∈ a_1 ::ₘ s, a ∈ s_1)",
" card (join 0) = (map (⇑card) 0).sum",
" ∀ (a : Multiset α) (s : Multise... |
import Mathlib.Data.List.Count
import Mathlib.Data.List.Dedup
import Mathlib.Data.List.InsertNth
import Mathlib.Data.List.Lattice
import Mathlib.Data.List.Permutation
import Mathlib.Data.Nat.Factorial.Basic
#align_import data.list.perm from "leanprover-community/mathlib"@"65a1391a0106c9204fe45bc73a039f056558cb83"
... | Mathlib/Data/List/Perm.lean | 142 | 146 | theorem perm_comp_perm : (Perm ∘r Perm : List α → List α → Prop) = Perm := by |
funext a c; apply propext
constructor
· exact fun ⟨b, hab, hba⟩ => Perm.trans hab hba
· exact fun h => ⟨a, Perm.refl a, h⟩
| [
" Perm ∘r Perm = Perm",
" (Perm ∘r Perm) a c = (a ~ c)",
" (Perm ∘r Perm) a c ↔ a ~ c",
" (Perm ∘r Perm) a c → a ~ c",
" a ~ c → (Perm ∘r Perm) a c"
] | [] |
import Mathlib.Analysis.Normed.Field.Basic
import Mathlib.LinearAlgebra.SesquilinearForm
import Mathlib.Topology.Algebra.Module.WeakDual
#align_import analysis.locally_convex.polar from "leanprover-community/mathlib"@"bcfa726826abd57587355b4b5b7e78ad6527b7e4"
variable {𝕜 E F : Type*}
open Topology
namespace Li... | Mathlib/Analysis/LocallyConvex/Polar.lean | 106 | 109 | theorem polar_zero : B.polar ({0} : Set E) = Set.univ := by |
refine Set.eq_univ_iff_forall.mpr fun y x hx => ?_
rw [Set.mem_singleton_iff.mp hx, map_zero, LinearMap.zero_apply, norm_zero]
exact zero_le_one
| [
" ‖(B x✝¹) 0‖ ≤ 1",
" B.polar s = ⋂ x ∈ s, {y | ‖(B x) y‖ ≤ 1}",
" x✝ ∈ B.polar s ↔ x✝ ∈ ⋂ x ∈ s, {y | ‖(B x) y‖ ≤ 1}",
" B.polar {0} = Set.univ",
" ‖(B x) y‖ ≤ 1",
" 0 ≤ 1"
] | [
" ‖(B x✝¹) 0‖ ≤ 1",
" B.polar s = ⋂ x ∈ s, {y | ‖(B x) y‖ ≤ 1}",
" x✝ ∈ B.polar s ↔ x✝ ∈ ⋂ x ∈ s, {y | ‖(B x) y‖ ≤ 1}"
] |
import Mathlib.Algebra.Algebra.Defs
import Mathlib.Algebra.CharP.ExpChar
import Mathlib.FieldTheory.Separable
#align_import field_theory.separable_degree from "leanprover-community/mathlib"@"d11893b411025250c8e61ff2f12ccbd7ee35ab15"
noncomputable section
namespace Polynomial
open scoped Classical
open Polynomial... | Mathlib/RingTheory/Polynomial/SeparableDegree.lean | 96 | 99 | theorem HasSeparableContraction.eq_degree {f : F[X]} (hf : HasSeparableContraction 1 f) :
hf.degree = f.natDegree := by |
let ⟨a, ha⟩ := hf.dvd_degree'
rw [← ha, one_pow a, mul_one]
| [
" ∃ m, g.natDegree * q ^ m = f.natDegree",
" ∃ m_1, g.natDegree * q ^ m_1 = ((expand F (q ^ m)) g).natDegree",
" g.natDegree * q ^ m = ((expand F (q ^ m)) g).natDegree",
" hf.degree = f.natDegree"
] | [
" ∃ m, g.natDegree * q ^ m = f.natDegree",
" ∃ m_1, g.natDegree * q ^ m_1 = ((expand F (q ^ m)) g).natDegree",
" g.natDegree * q ^ m = ((expand F (q ^ m)) g).natDegree"
] |
import Mathlib.Order.Antichain
import Mathlib.Order.UpperLower.Basic
import Mathlib.Order.Interval.Set.Basic
import Mathlib.Order.RelIso.Set
#align_import order.minimal from "leanprover-community/mathlib"@"59694bd07f0a39c5beccba34bd9f413a160782bf"
open Function Set
variable {α : Type*} (r r₁ r₂ : α → α → Prop) (s... | Mathlib/Order/Minimal.lean | 117 | 119 | theorem mem_maximals_iff_forall_lt_not_mem' (rlt : α → α → Prop) [IsNonstrictStrictOrder α r rlt] :
x ∈ maximals r s ↔ x ∈ s ∧ ∀ ⦃y⦄, rlt x y → y ∉ s := by |
simp [maximals, right_iff_left_not_left_of r rlt, not_imp_not, imp.swap (a := _ ∈ _)]
| [
" ∀ ⦃b : α⦄, b ∈ {a} → r a b → r b a",
" r b b → r b b",
" x ∈ maximals r s ↔ x ∈ s ∧ ∀ ⦃y : α⦄, y ∈ s → r x y → x = y",
" x ∈ s → ((∀ ⦃b : α⦄, b ∈ s → r x b → r b x) ↔ ∀ ⦃y : α⦄, y ∈ s → r x y → x = y)",
" r y x",
" y = x",
" x = y",
" x ∈ minimals r s ↔ x ∈ s ∧ ∀ ⦃y : α⦄, rlt y x → y ∉ s",
" x ∈ m... | [
" ∀ ⦃b : α⦄, b ∈ {a} → r a b → r b a",
" r b b → r b b",
" x ∈ maximals r s ↔ x ∈ s ∧ ∀ ⦃y : α⦄, y ∈ s → r x y → x = y",
" x ∈ s → ((∀ ⦃b : α⦄, b ∈ s → r x b → r b x) ↔ ∀ ⦃y : α⦄, y ∈ s → r x y → x = y)",
" r y x",
" y = x",
" x = y",
" x ∈ minimals r s ↔ x ∈ s ∧ ∀ ⦃y : α⦄, rlt y x → y ∉ s"
] |
import Mathlib.Order.UpperLower.Basic
import Mathlib.Data.Finset.Preimage
#align_import combinatorics.young.young_diagram from "leanprover-community/mathlib"@"59694bd07f0a39c5beccba34bd9f413a160782bf"
open Function
@[ext]
structure YoungDiagram where
cells : Finset (ℕ × ℕ)
isLowerSet : IsLowerSet (cel... | Mathlib/Combinatorics/Young/YoungDiagram.lean | 307 | 310 | theorem mem_iff_lt_rowLen {μ : YoungDiagram} {i j : ℕ} : (i, j) ∈ μ ↔ j < μ.rowLen i := by |
rw [rowLen, Nat.lt_find_iff]
push_neg
exact ⟨fun h _ hmj => μ.up_left_mem (by rfl) hmj h, fun h => h _ (by rfl)⟩
| [
" μ = ν",
" c ∈ μ.row i ↔ c ∈ μ ∧ c.1 = i",
" (i, j) ∈ μ.row i ↔ (i, j) ∈ μ",
" ∃ j, (i, j) ∉ μ",
" x✝³ = x✝¹",
" x✝² = x✝²",
" (i, j) ∈ μ ↔ j < μ.rowLen i",
" (i, j) ∈ μ ↔ ∀ m ≤ j, ¬(i, m) ∉ μ",
" (i, j) ∈ μ ↔ ∀ m ≤ j, (i, m) ∈ μ",
" i ≤ i",
" j ≤ j"
] | [
" μ = ν",
" c ∈ μ.row i ↔ c ∈ μ ∧ c.1 = i",
" (i, j) ∈ μ.row i ↔ (i, j) ∈ μ",
" ∃ j, (i, j) ∉ μ",
" x✝³ = x✝¹",
" x✝² = x✝²"
] |
import Mathlib.Data.ZMod.Basic
import Mathlib.GroupTheory.Exponent
#align_import group_theory.specific_groups.dihedral from "leanprover-community/mathlib"@"70fd9563a21e7b963887c9360bd29b2393e6225a"
inductive DihedralGroup (n : ℕ) : Type
| r : ZMod n → DihedralGroup n
| sr : ZMod n → DihedralGroup n
derivin... | Mathlib/GroupTheory/SpecificGroups/Dihedral.lean | 159 | 164 | theorem orderOf_sr (i : ZMod n) : orderOf (sr i) = 2 := by |
apply orderOf_eq_prime
· rw [sq, sr_mul_self]
· -- Porting note: Previous proof was `decide`
revert n
simp_rw [one_def, ne_eq, forall_const, not_false_eq_true]
| [
" ∀ (a b c : DihedralGroup n), a * b * c = a * (b * c)",
" r a * r b * r c = r a * (r b * r c)",
" r a * r b * sr c = r a * (r b * sr c)",
" r a * sr b * r c = r a * (sr b * r c)",
" r a * sr b * sr c = r a * (sr b * sr c)",
" sr a * r b * r c = sr a * (r b * r c)",
" sr a * r b * sr c = sr a * (r b * s... | [
" ∀ (a b c : DihedralGroup n), a * b * c = a * (b * c)",
" r a * r b * r c = r a * (r b * r c)",
" r a * r b * sr c = r a * (r b * sr c)",
" r a * sr b * r c = r a * (sr b * r c)",
" r a * sr b * sr c = r a * (sr b * sr c)",
" sr a * r b * r c = sr a * (r b * r c)",
" sr a * r b * sr c = sr a * (r b * s... |
import Mathlib.Topology.MetricSpace.PseudoMetric
#align_import topology.metric_space.basic from "leanprover-community/mathlib"@"c8f305514e0d47dfaa710f5a52f0d21b588e6328"
open Set Filter Bornology
open scoped NNReal Uniformity
universe u v w
variable {α : Type u} {β : Type v} {X ι : Type*}
variable [PseudoMetricS... | Mathlib/Topology/MetricSpace/Basic.lean | 87 | 88 | theorem dist_pos {x y : γ} : 0 < dist x y ↔ x ≠ y := by |
simpa only [not_le] using not_congr dist_le_zero
| [
" m = m'",
" mk eq_of_dist_eq_zero✝ = m'",
" mk eq_of_dist_eq_zero✝¹ = mk eq_of_dist_eq_zero✝",
" toPseudoMetricSpace✝¹ = toPseudoMetricSpace✝",
" PseudoMetricSpace.toDist = PseudoMetricSpace.toDist",
" 0 = dist x y ↔ x = y",
" dist x y ≠ 0 ↔ x ≠ y",
" dist x y ≤ 0 ↔ x = y",
" 0 < dist x y ↔ x ≠ y"
... | [
" m = m'",
" mk eq_of_dist_eq_zero✝ = m'",
" mk eq_of_dist_eq_zero✝¹ = mk eq_of_dist_eq_zero✝",
" toPseudoMetricSpace✝¹ = toPseudoMetricSpace✝",
" PseudoMetricSpace.toDist = PseudoMetricSpace.toDist",
" 0 = dist x y ↔ x = y",
" dist x y ≠ 0 ↔ x ≠ y",
" dist x y ≤ 0 ↔ x = y"
] |
import Mathlib.CategoryTheory.Sites.Spaces
import Mathlib.Topology.Sheaves.Sheaf
import Mathlib.CategoryTheory.Sites.DenseSubsite
#align_import topology.sheaves.sheaf_condition.sites from "leanprover-community/mathlib"@"d39590fc8728fbf6743249802486f8c91ffe07bc"
noncomputable section
set_option linter.uppercaseLe... | Mathlib/Topology/Sheaves/SheafCondition/Sites.lean | 103 | 107 | theorem mem_grothendieckTopology :
Sieve.generate (presieveOfCovering U) ∈ Opens.grothendieckTopology X (iSup U) := by |
intro x hx
obtain ⟨i, hxi⟩ := Opens.mem_iSup.mp hx
exact ⟨U i, Opens.leSupr U i, ⟨U i, 𝟙 _, Opens.leSupr U i, ⟨i, rfl⟩, Category.id_comp _⟩, hxi⟩
| [
" presieveOfCoveringAux (coveringOfPresieve Y R) Y = R",
" f ∈ presieveOfCoveringAux (coveringOfPresieve Y R) Y ↔ f ∈ R",
" f ∈ R",
" Sieve.generate (presieveOfCovering U) ∈ (Opens.grothendieckTopology ↑X).sieves (iSup U)",
" ∃ U_1 f, (Sieve.generate (presieveOfCovering U)).arrows f ∧ x ∈ U_1"
] | [
" presieveOfCoveringAux (coveringOfPresieve Y R) Y = R",
" f ∈ presieveOfCoveringAux (coveringOfPresieve Y R) Y ↔ f ∈ R",
" f ∈ R"
] |
import Mathlib.LinearAlgebra.Matrix.Basis
import Mathlib.LinearAlgebra.Matrix.Nondegenerate
import Mathlib.LinearAlgebra.Matrix.NonsingularInverse
import Mathlib.LinearAlgebra.Matrix.ToLinearEquiv
import Mathlib.LinearAlgebra.BilinearForm.Properties
import Mathlib.LinearAlgebra.Matrix.SesquilinearForm
#align_import l... | Mathlib/LinearAlgebra/Matrix/BilinearForm.lean | 88 | 93 | theorem toBilin'Aux_toMatrixAux [DecidableEq n] (B₂ : BilinForm R₂ (n → R₂)) :
-- Porting note: had to hint the base ring even though it should be clear from context...
Matrix.toBilin'Aux (BilinForm.toMatrixAux (R₂ := R₂)
(fun j => stdBasis R₂ (fun _ => R₂) j 1) B₂) = B₂ := by |
rw [BilinForm.toMatrixAux, Matrix.toBilin'Aux,
toLinearMap₂'Aux_toMatrix₂Aux]
| [
" ((BilinForm.toMatrixAux fun j => (LinearMap.stdBasis R₂ (fun x => R₂) j) 1) B₂).toBilin'Aux = B₂"
] | [] |
import Mathlib.Algebra.Polynomial.RingDivision
import Mathlib.RingTheory.Localization.FractionRing
#align_import data.polynomial.ring_division from "leanprover-community/mathlib"@"8efcf8022aac8e01df8d302dcebdbc25d6a886c8"
noncomputable section
namespace Polynomial
universe u v w z
variable {R : Type u} {S : Ty... | Mathlib/Algebra/Polynomial/Roots.lean | 55 | 61 | theorem roots_def [DecidableEq R] (p : R[X]) [Decidable (p = 0)] :
p.roots = if h : p = 0 then ∅ else Classical.choose (exists_multiset_roots h) := by |
-- porting noteL `‹_›` doesn't work for instance arguments
rename_i iR ip0
obtain rfl := Subsingleton.elim iR (Classical.decEq R)
obtain rfl := Subsingleton.elim ip0 (Classical.dec (p = 0))
rfl
| [
" p.roots = if h : p = 0 then ∅ else Classical.choose ⋯"
] | [] |
import Mathlib.Algebra.Order.Monoid.Unbundled.Basic
#align_import algebra.order.monoid.min_max from "leanprover-community/mathlib"@"de87d5053a9fe5cbde723172c0fb7e27e7436473"
open Function
variable {α β : Type*}
section CovariantClassMulLe
variable [LinearOrder α]
section Mul
variable [Mul α]
@[to_additive... | Mathlib/Algebra/Order/Monoid/Unbundled/MinMax.lean | 117 | 121 | theorem le_or_le_of_mul_le_mul [CovariantClass α α (· * ·) (· < ·)]
[CovariantClass α α (Function.swap (· * ·)) (· < ·)] {a₁ a₂ b₁ b₂ : α} :
a₁ * b₁ ≤ a₂ * b₂ → a₁ ≤ a₂ ∨ b₁ ≤ b₂ := by |
contrapose!
exact fun h => mul_lt_mul_of_lt_of_lt h.1 h.2
| [
" a₁ * b₁ < a₂ * b₂ → a₁ < a₂ ∨ b₁ < b₂",
" a₂ ≤ a₁ ∧ b₂ ≤ b₁ → a₂ * b₂ ≤ a₁ * b₁",
" a₁ * b₁ ≤ a₂ * b₂ → a₁ ≤ a₂ ∨ b₁ < b₂",
" a₂ < a₁ ∧ b₂ ≤ b₁ → a₂ * b₂ < a₁ * b₁",
" a₁ * b₁ ≤ a₂ * b₂ → a₁ < a₂ ∨ b₁ ≤ b₂",
" a₂ ≤ a₁ ∧ b₂ < b₁ → a₂ * b₂ < a₁ * b₁",
" a₁ * b₁ ≤ a₂ * b₂ → a₁ ≤ a₂ ∨ b₁ ≤ b₂",
" a₂ < a... | [
" a₁ * b₁ < a₂ * b₂ → a₁ < a₂ ∨ b₁ < b₂",
" a₂ ≤ a₁ ∧ b₂ ≤ b₁ → a₂ * b₂ ≤ a₁ * b₁",
" a₁ * b₁ ≤ a₂ * b₂ → a₁ ≤ a₂ ∨ b₁ < b₂",
" a₂ < a₁ ∧ b₂ ≤ b₁ → a₂ * b₂ < a₁ * b₁",
" a₁ * b₁ ≤ a₂ * b₂ → a₁ < a₂ ∨ b₁ ≤ b₂",
" a₂ ≤ a₁ ∧ b₂ < b₁ → a₂ * b₂ < a₁ * b₁"
] |
import Mathlib.MeasureTheory.OuterMeasure.Caratheodory
#align_import measure_theory.measure.outer_measure from "leanprover-community/mathlib"@"343e80208d29d2d15f8050b929aa50fe4ce71b55"
noncomputable section
open Set Function Filter
open scoped Classical NNReal Topology ENNReal
namespace MeasureTheory
open Outer... | Mathlib/MeasureTheory/OuterMeasure/Induced.lean | 49 | 49 | theorem extend_eq {s : α} (h : P s) : extend m s = m s h := by | simp [extend, h]
| [
" extend m s = m s h"
] | [] |
import Mathlib.Data.Stream.Init
import Mathlib.Tactic.ApplyFun
import Mathlib.Control.Fix
import Mathlib.Order.OmegaCompletePartialOrder
#align_import control.lawful_fix from "leanprover-community/mathlib"@"92ca63f0fb391a9ca5f22d2409a6080e786d99f7"
universe u v
open scoped Classical
variable {α : Type*} {β : α →... | Mathlib/Control/LawfulFix.lean | 57 | 60 | theorem approx_mono' {i : ℕ} : Fix.approx f i ≤ Fix.approx f (succ i) := by |
induction i with
| zero => dsimp [approx]; apply @bot_le _ _ _ (f ⊥)
| succ _ i_ih => intro; apply f.monotone; apply i_ih
| [
" approx (⇑f) i ≤ approx (⇑f) i.succ",
" approx (⇑f) 0 ≤ approx (⇑f) (Nat.succ 0)",
" ⊥ ≤ f ⊥",
" approx (⇑f) (n✝ + 1) ≤ approx (⇑f) (n✝ + 1).succ",
" approx (⇑f) (n✝ + 1) i✝ ≤ approx (⇑f) (n✝ + 1).succ i✝",
" approx (⇑f) n✝ ≤ approx (⇑f) (n✝ + 1)"
] | [] |
import Mathlib.Algebra.Module.DedekindDomain
import Mathlib.LinearAlgebra.FreeModule.PID
import Mathlib.Algebra.Module.Projective
import Mathlib.Algebra.Category.ModuleCat.Biproducts
import Mathlib.RingTheory.SimpleModule
#align_import algebra.module.pid from "leanprover-community/mathlib"@"cdc34484a07418af43daf8198b... | Mathlib/Algebra/Module/PID.lean | 89 | 98 | theorem Submodule.exists_isInternal_prime_power_torsion_of_pid [Module.Finite R M]
(hM : Module.IsTorsion R M) :
∃ (ι : Type u) (_ : Fintype ι) (_ : DecidableEq ι) (p : ι → R) (_ : ∀ i, Irreducible <| p i)
(e : ι → ℕ), DirectSum.IsInternal fun i => torsionBy R M <| p i ^ e i := by |
refine ⟨_, ?_, _, _, ?_, _, Submodule.isInternal_prime_power_torsion_of_pid hM⟩
· exact Finset.fintypeCoeSort _
· rintro ⟨p, hp⟩
have hP := prime_of_factor p (Multiset.mem_toFinset.mp hp)
haveI := Ideal.isPrime_of_prime hP
exact (IsPrincipal.prime_generator_of_isPrime p hP.ne_zero).irreducible
| [
" DirectSum.IsInternal fun p => torsionBy R M (IsPrincipal.generator ↑p ^ Multiset.count (↑p) (factors ⊤.annihilator))",
" torsionBy R M (IsPrincipal.generator ↑x✝ ^ Multiset.count (↑x✝) (factors ⊤.annihilator)) =\n torsionBySet R M ↑(↑x✝ ^ Multiset.count (↑x✝) (factors ⊤.annihilator))",
" p ∈ torsionBy R M ... | [
" DirectSum.IsInternal fun p => torsionBy R M (IsPrincipal.generator ↑p ^ Multiset.count (↑p) (factors ⊤.annihilator))",
" torsionBy R M (IsPrincipal.generator ↑x✝ ^ Multiset.count (↑x✝) (factors ⊤.annihilator)) =\n torsionBySet R M ↑(↑x✝ ^ Multiset.count (↑x✝) (factors ⊤.annihilator))",
" p ∈ torsionBy R M ... |
import Mathlib.Algebra.BigOperators.Intervals
import Mathlib.Algebra.Module.Defs
import Mathlib.Tactic.Abel
namespace Finset
variable {R M : Type*} [Ring R] [AddCommGroup M] [Module R M] (f : ℕ → R) (g : ℕ → M) {m n : ℕ}
-- The partial sum of `g`, starting from zero
local notation "G " n:80 => ∑ i ∈ range n, g i
... | Mathlib/Algebra/BigOperators/Module.lean | 63 | 69 | theorem sum_range_by_parts :
∑ i ∈ range n, f i • g i =
f (n - 1) • G n - ∑ i ∈ range (n - 1), (f (i + 1) - f i) • G (i + 1) := by |
by_cases hn : n = 0
· simp [hn]
· rw [range_eq_Ico, sum_Ico_by_parts f g (Nat.pos_of_ne_zero hn), sum_range_zero, smul_zero,
sub_zero, range_eq_Ico]
| [
" ∑ i ∈ Ico m n, f i • g i =\n f (n - 1) • ∑ i ∈ range n, g i - f m • ∑ i ∈ range m, g i -\n ∑ i ∈ Ico m (n - 1), (f (i + 1) - f i) • ∑ i ∈ range (i + 1), g i",
" ∑ i ∈ Ico (m + 1) n, f i • ∑ i ∈ range i, g i = ∑ i ∈ Ico m (n - 1), f (i + 1) • ∑ i ∈ range (i + 1), g i",
" ∑ x ∈ Ico m (n - 1), f (x + 1) ... | [
" ∑ i ∈ Ico m n, f i • g i =\n f (n - 1) • ∑ i ∈ range n, g i - f m • ∑ i ∈ range m, g i -\n ∑ i ∈ Ico m (n - 1), (f (i + 1) - f i) • ∑ i ∈ range (i + 1), g i",
" ∑ i ∈ Ico (m + 1) n, f i • ∑ i ∈ range i, g i = ∑ i ∈ Ico m (n - 1), f (i + 1) • ∑ i ∈ range (i + 1), g i",
" ∑ x ∈ Ico m (n - 1), f (x + 1) ... |
import Mathlib.Algebra.MvPolynomial.Rename
#align_import data.mv_polynomial.comap from "leanprover-community/mathlib"@"aba31c938d3243cc671be7091b28a1e0814647ee"
namespace MvPolynomial
variable {σ : Type*} {τ : Type*} {υ : Type*} {R : Type*} [CommSemiring R]
noncomputable def comap (f : MvPolynomial σ R →ₐ[R] M... | Mathlib/Algebra/MvPolynomial/Comap.lean | 90 | 92 | theorem comap_rename (f : σ → τ) (x : τ → R) : comap (rename f) x = x ∘ f := by |
funext
simp [rename_X, comap_apply, aeval_X]
| [
" comap (AlgHom.id R (MvPolynomial σ R)) x = x",
" comap (AlgHom.id R (MvPolynomial σ R)) x i = x i",
" comap (AlgHom.id R (MvPolynomial σ R)) = id",
" comap (AlgHom.id R (MvPolynomial σ R)) x = id x",
" comap (g.comp f) x = comap f (comap g x)",
" comap (g.comp f) x i = comap f (comap g x) i",
" comap ... | [
" comap (AlgHom.id R (MvPolynomial σ R)) x = x",
" comap (AlgHom.id R (MvPolynomial σ R)) x i = x i",
" comap (AlgHom.id R (MvPolynomial σ R)) = id",
" comap (AlgHom.id R (MvPolynomial σ R)) x = id x",
" comap (g.comp f) x = comap f (comap g x)",
" comap (g.comp f) x i = comap f (comap g x) i",
" comap ... |
import Mathlib.Algebra.Ring.Equiv
#align_import algebra.ring.comp_typeclasses from "leanprover-community/mathlib"@"207cfac9fcd06138865b5d04f7091e46d9320432"
variable {R₁ : Type*} {R₂ : Type*} {R₃ : Type*}
variable [Semiring R₁] [Semiring R₂] [Semiring R₃]
-- This at first seems not very useful. However we need ... | Mathlib/Algebra/Ring/CompTypeclasses.lean | 100 | 102 | theorem comp_apply_eq {x : R₁} : σ' (σ x) = x := by |
rw [← RingHom.comp_apply, comp_eq]
simp
| [
" σ' (σ x) = x",
" (RingHom.id R₁) x = x"
] | [] |
import Mathlib.Tactic.Ring.Basic
import Mathlib.Tactic.TryThis
import Mathlib.Tactic.Conv
import Mathlib.Util.Qq
set_option autoImplicit true
-- In this file we would like to be able to use multi-character auto-implicits.
set_option relaxedAutoImplicit true
namespace Mathlib.Tactic
open Lean hiding Rat
open Qq Me... | Mathlib/Tactic/Ring/RingNF.lean | 126 | 127 | theorem rat_rawCast_neg {R} [DivisionRing R] :
(Rat.rawCast (.negOfNat n) d : R) = Int.rawCast (.negOfNat n) / Nat.rawCast d := by | simp
| [
" a * -b = -(a * b)",
" Nat.rawCast 0 = 0",
" Nat.rawCast 1 = 1",
" (Int.negOfNat n).rawCast = -n.rawCast",
" Rat.rawCast (Int.ofNat n) d = n.rawCast / d.rawCast",
" Rat.rawCast (Int.negOfNat n) d = (Int.negOfNat n).rawCast / d.rawCast"
] | [
" a * -b = -(a * b)",
" Nat.rawCast 0 = 0",
" Nat.rawCast 1 = 1",
" (Int.negOfNat n).rawCast = -n.rawCast",
" Rat.rawCast (Int.ofNat n) d = n.rawCast / d.rawCast"
] |
import Mathlib.Algebra.ContinuedFractions.Translations
#align_import algebra.continued_fractions.continuants_recurrence from "leanprover-community/mathlib"@"5f11361a98ae4acd77f5c1837686f6f0102cdc25"
namespace GeneralizedContinuedFraction
variable {K : Type*} {g : GeneralizedContinuedFraction K} {n : ℕ} [Division... | Mathlib/Algebra/ContinuedFractions/ContinuantsRecurrence.lean | 42 | 46 | theorem continuants_recurrence {gp ppred pred : Pair K} (succ_nth_s_eq : g.s.get? (n + 1) = some gp)
(nth_conts_eq : g.continuants n = ppred) (succ_nth_conts_eq : g.continuants (n + 1) = pred) :
g.continuants (n + 2) = ⟨gp.b * pred.a + gp.a * ppred.a, gp.b * pred.b + gp.a * ppred.b⟩ := by |
rw [nth_cont_eq_succ_nth_cont_aux] at nth_conts_eq succ_nth_conts_eq
exact continuants_recurrenceAux succ_nth_s_eq nth_conts_eq succ_nth_conts_eq
| [
" g.continuantsAux (n + 2) = { a := gp.b * pred.a + gp.a * ppred.a, b := gp.b * pred.b + gp.a * ppred.b }",
" g.continuants (n + 1) = { a := gp.b * pred.a + gp.a * ppred.a, b := gp.b * pred.b + gp.a * ppred.b }",
" g.continuants (n + 2) = { a := gp.b * pred.a + gp.a * ppred.a, b := gp.b * pred.b + gp.a * ppred.... | [
" g.continuantsAux (n + 2) = { a := gp.b * pred.a + gp.a * ppred.a, b := gp.b * pred.b + gp.a * ppred.b }",
" g.continuants (n + 1) = { a := gp.b * pred.a + gp.a * ppred.a, b := gp.b * pred.b + gp.a * ppred.b }"
] |
import Mathlib.Algebra.IsPrimePow
import Mathlib.NumberTheory.ArithmeticFunction
import Mathlib.Analysis.SpecialFunctions.Log.Basic
#align_import number_theory.von_mangoldt from "leanprover-community/mathlib"@"c946d6097a6925ad16d7ec55677bbc977f9846de"
namespace ArithmeticFunction
open Finset Nat
open scoped Arit... | Mathlib/NumberTheory/VonMangoldt.lean | 111 | 122 | theorem vonMangoldt_sum {n : ℕ} : ∑ i ∈ n.divisors, Λ i = Real.log n := by |
refine recOnPrimeCoprime ?_ ?_ ?_ n
· simp
· intro p k hp
rw [sum_divisors_prime_pow hp, cast_pow, Real.log_pow, Finset.sum_range_succ', Nat.pow_zero,
vonMangoldt_apply_one]
simp [vonMangoldt_apply_pow (Nat.succ_ne_zero _), vonMangoldt_apply_prime hp]
intro a b ha' hb' hab ha hb
simp only [vonM... | [
" (fun n => (↑n).log) 0 = 0",
" Λ 1 = 0",
" 0 ≤ Λ n",
" 0 ≤ if IsPrimePow n then (↑n.minFac).log else 0",
" 0 ≤ (↑n.minFac).log",
" 0 ≤ 0",
" Λ (n ^ k) = Λ n",
" Λ p = (↑p).log",
" Λ n ≠ 0 ↔ IsPrimePow n",
" Λ 1 ≠ 0 ↔ IsPrimePow 1",
" ∑ i ∈ n.divisors, Λ i = (↑n).log",
" ∑ i ∈ divisors 0, Λ i ... | [
" (fun n => (↑n).log) 0 = 0",
" Λ 1 = 0",
" 0 ≤ Λ n",
" 0 ≤ if IsPrimePow n then (↑n.minFac).log else 0",
" 0 ≤ (↑n.minFac).log",
" 0 ≤ 0",
" Λ (n ^ k) = Λ n",
" Λ p = (↑p).log",
" Λ n ≠ 0 ↔ IsPrimePow n",
" Λ 1 ≠ 0 ↔ IsPrimePow 1"
] |
import Mathlib.MeasureTheory.Function.LpSeminorm.Basic
#align_import measure_theory.function.lp_seminorm from "leanprover-community/mathlib"@"c4015acc0a223449d44061e27ddac1835a3852b9"
namespace MeasureTheory
open Filter
open scoped ENNReal
variable {α E : Type*} {m m0 : MeasurableSpace α} {p : ℝ≥0∞} {q : ℝ} {μ :... | Mathlib/MeasureTheory/Function/LpSeminorm/Trim.lean | 59 | 65 | theorem snorm_trim (hm : m ≤ m0) {f : α → E} (hf : StronglyMeasurable[m] f) :
snorm f p (μ.trim hm) = snorm f p μ := by |
by_cases h0 : p = 0
· simp [h0]
by_cases h_top : p = ∞
· simpa only [h_top, snorm_exponent_top] using snormEssSup_trim hm hf
simpa only [snorm_eq_snorm' h0 h_top] using snorm'_trim hm hf
| [
" snorm' f q (μ.trim hm) = snorm' f q μ",
" (∫⁻ (a : α), ↑‖f a‖₊ ^ q ∂μ.trim hm) ^ (1 / q) = (∫⁻ (a : α), ↑‖f a‖₊ ^ q ∂μ) ^ (1 / q)",
" ∫⁻ (a : α), ↑‖f a‖₊ ^ q ∂μ.trim hm = ∫⁻ (a : α), ↑‖f a‖₊ ^ q ∂μ",
" Measurable fun a => ↑‖f a‖₊ ^ q",
" Measurable fun a => ‖f a‖₊",
" StronglyMeasurable fun a => ‖f a‖₊"... | [
" snorm' f q (μ.trim hm) = snorm' f q μ",
" (∫⁻ (a : α), ↑‖f a‖₊ ^ q ∂μ.trim hm) ^ (1 / q) = (∫⁻ (a : α), ↑‖f a‖₊ ^ q ∂μ) ^ (1 / q)",
" ∫⁻ (a : α), ↑‖f a‖₊ ^ q ∂μ.trim hm = ∫⁻ (a : α), ↑‖f a‖₊ ^ q ∂μ",
" Measurable fun a => ↑‖f a‖₊ ^ q",
" Measurable fun a => ‖f a‖₊",
" StronglyMeasurable fun a => ‖f a‖₊"... |
import Mathlib.Algebra.Polynomial.AlgebraMap
import Mathlib.FieldTheory.Minpoly.IsIntegrallyClosed
import Mathlib.RingTheory.PowerBasis
#align_import ring_theory.is_adjoin_root from "leanprover-community/mathlib"@"f7fc89d5d5ff1db2d1242c7bb0e9062ce47ef47c"
open scoped Polynomial
open Polynomial
noncomputable sec... | Mathlib/RingTheory/IsAdjoinRoot.lean | 158 | 158 | theorem aeval_root (h : IsAdjoinRoot S f) : aeval h.root f = 0 := by | rw [aeval_eq, map_self]
| [
" (algebraMap R S) x = h.map (C x)",
" p ∈ RingHom.ker h.map ↔ f ∣ p",
" h.map p = 0 ↔ f ∣ p",
" (aeval h.root) (C x) = h.map (C x)",
" (aeval h.root) (p + q) = h.map (p + q)",
" (aeval h.root) (C x * X ^ (n + 1)) = h.map (C x * X ^ (n + 1))",
" (aeval h.root) f = 0"
] | [
" (algebraMap R S) x = h.map (C x)",
" p ∈ RingHom.ker h.map ↔ f ∣ p",
" h.map p = 0 ↔ f ∣ p",
" (aeval h.root) (C x) = h.map (C x)",
" (aeval h.root) (p + q) = h.map (p + q)",
" (aeval h.root) (C x * X ^ (n + 1)) = h.map (C x * X ^ (n + 1))"
] |
import Mathlib.CategoryTheory.PathCategory
import Mathlib.CategoryTheory.Functor.FullyFaithful
import Mathlib.CategoryTheory.Bicategory.Free
import Mathlib.CategoryTheory.Bicategory.LocallyDiscrete
#align_import category_theory.bicategory.coherence from "leanprover-community/mathlib"@"f187f1074fa1857c94589cc653c786ca... | Mathlib/CategoryTheory/Bicategory/Coherence.lean | 148 | 157 | theorem normalizeAux_congr {a b c : B} (p : Path a b) {f g : Hom b c} (η : f ⟶ g) :
normalizeAux p f = normalizeAux p g := by |
rcases η with ⟨η'⟩
apply @congr_fun _ _ fun p => normalizeAux p f
clear p η
induction η' with
| vcomp _ _ _ _ => apply Eq.trans <;> assumption
| whisker_left _ _ ih => funext; apply congr_fun ih
| whisker_right _ _ ih => funext; apply congr_arg₂ _ (congr_fun ih _) rfl
| _ => funext; rfl
| [
" (preinclusion B).map₂ η = eqToHom ⋯",
" (preinclusion B).map₂ { down := { down := down✝ } } = eqToHom ⋯",
" ?m.3791.as = ?m.3792.as",
" normalizeAux p f = normalizeAux p g",
" (fun p => normalizeAux p f) = fun p => normalizeAux p g",
" (fun p => normalizeAux p f✝) = fun p => normalizeAux p h✝",
" (fun... | [
" (preinclusion B).map₂ η = eqToHom ⋯",
" (preinclusion B).map₂ { down := { down := down✝ } } = eqToHom ⋯",
" ?m.3791.as = ?m.3792.as"
] |
import Mathlib.Geometry.Manifold.ContMDiff.Product
import Mathlib.Analysis.NormedSpace.OperatorNorm.Prod
open Set ChartedSpace SmoothManifoldWithCorners
open scoped Topology Manifold
variable {𝕜 : Type*} [NontriviallyNormedField 𝕜]
-- declare a smooth manifold `M` over the pair `(E, H)`.
{E : Type*}
[Norme... | Mathlib/Geometry/Manifold/ContMDiff/NormedSpace.lean | 81 | 82 | theorem contMDiff_iff_contDiff {f : E → E'} : ContMDiff 𝓘(𝕜, E) 𝓘(𝕜, E') n f ↔ ContDiff 𝕜 n f := by |
rw [← contDiffOn_univ, ← contMDiffOn_univ, contMDiffOn_iff_contDiffOn]
| [
" ContMDiffWithinAt 𝓘(𝕜, E) 𝓘(𝕜, E') n f s x ↔ ContDiffWithinAt 𝕜 n f s x",
" ContDiffWithinAt 𝕜 n f s x → ContinuousWithinAt f s x",
" ContMDiffAt 𝓘(𝕜, E) 𝓘(𝕜, E') n f x ↔ ContDiffAt 𝕜 n f x",
" ∀ (a : E), a ∈ s → ContMDiffWithinAt 𝓘(𝕜, E) 𝓘(𝕜, E') n f s a ↔ a ∈ s → ContDiffWithinAt 𝕜 n f s a... | [
" ContMDiffWithinAt 𝓘(𝕜, E) 𝓘(𝕜, E') n f s x ↔ ContDiffWithinAt 𝕜 n f s x",
" ContDiffWithinAt 𝕜 n f s x → ContinuousWithinAt f s x",
" ContMDiffAt 𝓘(𝕜, E) 𝓘(𝕜, E') n f x ↔ ContDiffAt 𝕜 n f x",
" ∀ (a : E), a ∈ s → ContMDiffWithinAt 𝓘(𝕜, E) 𝓘(𝕜, E') n f s a ↔ a ∈ s → ContDiffWithinAt 𝕜 n f s a... |
import Mathlib.Data.List.Defs
import Mathlib.Data.Option.Basic
import Mathlib.Data.Nat.Defs
import Mathlib.Init.Data.List.Basic
import Mathlib.Util.AssertExists
-- Make sure we haven't imported `Data.Nat.Order.Basic`
assert_not_exists OrderedSub
namespace List
universe u v
variable {α : Type u} {β : Type v} (l :... | Mathlib/Data/List/GetD.lean | 38 | 44 | theorem getD_eq_get {n : ℕ} (hn : n < l.length) : l.getD n d = l.get ⟨n, hn⟩ := by |
induction l generalizing n with
| nil => simp at hn
| cons head tail ih =>
cases n
· exact getD_cons_zero
· exact ih _
| [
" l.getD n d = l.get ⟨n, hn⟩",
" [].getD n d = [].get ⟨n, hn⟩",
" (head :: tail).getD n d = (head :: tail).get ⟨n, hn⟩",
" (head :: tail).getD 0 d = (head :: tail).get ⟨0, hn⟩",
" (head :: tail).getD (n✝ + 1) d = (head :: tail).get ⟨n✝ + 1, hn⟩"
] | [] |
import Mathlib.Algebra.BigOperators.WithTop
import Mathlib.Algebra.GroupWithZero.Divisibility
import Mathlib.Data.ENNReal.Basic
#align_import data.real.ennreal from "leanprover-community/mathlib"@"c14c8fcde993801fca8946b0d80131a1a81d1520"
open Set NNReal ENNReal
namespace ENNReal
variable {a b c d : ℝ≥0∞} {r p q... | Mathlib/Data/ENNReal/Operations.lean | 246 | 252 | theorem mul_lt_top_iff {a b : ℝ≥0∞} : a * b < ∞ ↔ a < ∞ ∧ b < ∞ ∨ a = 0 ∨ b = 0 := by |
constructor
· intro h
rw [← or_assoc, or_iff_not_imp_right, or_iff_not_imp_right]
intro hb ha
exact ⟨lt_top_of_mul_ne_top_left h.ne hb, lt_top_of_mul_ne_top_right h.ne ha⟩
· rintro (⟨ha, hb⟩ | rfl | rfl) <;> [exact mul_lt_top ha.ne hb.ne; simp; simp]
| [
" (r₁ + r₂).toNNReal = r₁.toNNReal + r₂.toNNReal",
" (↑r₁ + r₂).toNNReal = (↑r₁).toNNReal + r₂.toNNReal",
" (↑r₁ + ↑r₂).toNNReal = (↑r₁).toNNReal + (↑r₂).toNNReal",
" ¬x < ⊤ ↔ x = ⊤",
" a + b ≠ ⊤ ↔ a ≠ ⊤ ∧ b ≠ ⊤",
" a * ⊤ = if a = 0 then 0 else ⊤",
" ⊤ * a = if a = 0 then 0 else ⊤",
" ⊤ ^ (m + 1) = ⊤"... | [
" (r₁ + r₂).toNNReal = r₁.toNNReal + r₂.toNNReal",
" (↑r₁ + r₂).toNNReal = (↑r₁).toNNReal + r₂.toNNReal",
" (↑r₁ + ↑r₂).toNNReal = (↑r₁).toNNReal + (↑r₂).toNNReal",
" ¬x < ⊤ ↔ x = ⊤",
" a + b ≠ ⊤ ↔ a ≠ ⊤ ∧ b ≠ ⊤",
" a * ⊤ = if a = 0 then 0 else ⊤",
" ⊤ * a = if a = 0 then 0 else ⊤",
" ⊤ ^ (m + 1) = ⊤"... |
import Mathlib.MeasureTheory.Integral.IntervalIntegral
import Mathlib.Analysis.Calculus.Deriv.ZPow
import Mathlib.Analysis.NormedSpace.Pointwise
import Mathlib.Analysis.SpecialFunctions.NonIntegrable
import Mathlib.Analysis.Analytic.Basic
#align_import measure_theory.integral.circle_integral from "leanprover-communit... | Mathlib/MeasureTheory/Integral/CircleIntegral.lean | 171 | 174 | theorem hasDerivAt_circleMap (c : ℂ) (R : ℝ) (θ : ℝ) :
HasDerivAt (circleMap c R) (circleMap 0 R θ * I) θ := by |
simpa only [mul_assoc, one_mul, ofRealCLM_apply, circleMap, ofReal_one, zero_add]
using (((ofRealCLM.hasDerivAt (x := θ)).mul_const I).cexp.const_mul (R : ℂ)).const_add c
| [
" circleMap c R (θ + 2 * π) = circleMap c R θ",
" circleMap c R θ - c = circleMap 0 R θ",
" Complex.abs (circleMap 0 R θ) = |R|",
" circleMap c R θ ∈ sphere c |R|",
" circleMap c R θ ∈ sphere c R",
" circleMap c R θ ∉ ball c R",
" range (circleMap c R) = c +ᵥ R • range fun θ => cexp (↑θ * I)",
" (c +ᵥ... | [
" circleMap c R (θ + 2 * π) = circleMap c R θ",
" circleMap c R θ - c = circleMap 0 R θ",
" Complex.abs (circleMap 0 R θ) = |R|",
" circleMap c R θ ∈ sphere c |R|",
" circleMap c R θ ∈ sphere c R",
" circleMap c R θ ∉ ball c R",
" range (circleMap c R) = c +ᵥ R • range fun θ => cexp (↑θ * I)",
" (c +ᵥ... |
import Mathlib.Data.Finsupp.Defs
#align_import data.list.to_finsupp from "leanprover-community/mathlib"@"06a655b5fcfbda03502f9158bbf6c0f1400886f9"
namespace List
variable {M : Type*} [Zero M] (l : List M) [DecidablePred (getD l · 0 ≠ 0)] (n : ℕ)
def toFinsupp : ℕ →₀ M where
toFun i := getD l i 0
support := ... | Mathlib/Data/List/ToFinsupp.lean | 128 | 136 | theorem toFinsupp_cons_eq_single_add_embDomain {R : Type*} [AddZeroClass R] (x : R) (xs : List R)
[DecidablePred (getD (x::xs) · 0 ≠ 0)] [DecidablePred (getD xs · 0 ≠ 0)] :
toFinsupp (x::xs) =
Finsupp.single 0 x + (toFinsupp xs).embDomain ⟨Nat.succ, Nat.succ_injective⟩ := by |
classical
convert toFinsupp_append [x] xs using 3
· exact (toFinsupp_singleton x).symm
· ext n
exact add_comm n 1
| [
" n ∈ Finset.filter (fun i => l.getD i 0 ≠ 0) (Finset.range l.length) ↔ (fun i => l.getD i 0) n ≠ 0",
" ¬l.getD n 0 = 0 → n < l.length",
" l.length ≤ n → l.getD n 0 = 0",
" [].toFinsupp = 0",
" [].toFinsupp a✝ = 0 a✝",
" [x].toFinsupp = Finsupp.single 0 x",
" [x].toFinsupp 0 = (Finsupp.single 0 x) 0",
... | [
" n ∈ Finset.filter (fun i => l.getD i 0 ≠ 0) (Finset.range l.length) ↔ (fun i => l.getD i 0) n ≠ 0",
" ¬l.getD n 0 = 0 → n < l.length",
" l.length ≤ n → l.getD n 0 = 0",
" [].toFinsupp = 0",
" [].toFinsupp a✝ = 0 a✝",
" [x].toFinsupp = Finsupp.single 0 x",
" [x].toFinsupp 0 = (Finsupp.single 0 x) 0",
... |
import Mathlib.Algebra.FreeMonoid.Basic
#align_import algebra.free_monoid.count from "leanprover-community/mathlib"@"a2d2e18906e2b62627646b5d5be856e6a642062f"
variable {α : Type*} (p : α → Prop) [DecidablePred p]
namespace FreeAddMonoid
def countP : FreeAddMonoid α →+ ℕ where
toFun := List.countP p
map_zero... | Mathlib/Algebra/FreeMonoid/Count.lean | 43 | 45 | theorem count_of [DecidableEq α] (x y : α) : count x (of y) = (Pi.single x 1 : α → ℕ) y := by |
simp [Pi.single, Function.update, count, countP, List.countP, List.countP.go,
Bool.beq_eq_decide_eq]
| [
" (countP p) (of x) = if p x = (true = true) then 1 else 0",
" (count x) (of y) = Pi.single x 1 y"
] | [
" (countP p) (of x) = if p x = (true = true) then 1 else 0"
] |
import Mathlib.Order.Filter.AtTopBot
import Mathlib.Order.Filter.Pi
#align_import order.filter.cofinite from "leanprover-community/mathlib"@"8631e2d5ea77f6c13054d9151d82b83069680cb1"
open Set Function
variable {ι α β : Type*} {l : Filter α}
namespace Filter
def cofinite : Filter α :=
comk Set.Finite finite_e... | Mathlib/Order/Filter/Cofinite.lean | 63 | 65 | theorem frequently_cofinite_iff_infinite {p : α → Prop} :
(∃ᶠ x in cofinite, p x) ↔ Set.Infinite { x | p x } := by |
simp only [Filter.Frequently, eventually_cofinite, not_not, Set.Infinite]
| [
" cofinite = ⊥ ↔ Finite α",
" (∃ᶠ (x : α) in cofinite, p x) ↔ {x | p x}.Infinite"
] | [
" cofinite = ⊥ ↔ Finite α"
] |
import Mathlib.RepresentationTheory.FdRep
import Mathlib.LinearAlgebra.Trace
import Mathlib.RepresentationTheory.Invariants
#align_import representation_theory.character from "leanprover-community/mathlib"@"55b3f8206b8596db8bb1804d8a92814a0b6670c9"
noncomputable section
universe u
open CategoryTheory LinearMap ... | Mathlib/RepresentationTheory/Character.lean | 59 | 60 | theorem char_one (V : FdRep k G) : V.character 1 = FiniteDimensional.finrank k V := by |
simp only [character, map_one, trace_one]
| [
" V.character (h * g) = V.character (g * h)",
" V.character 1 = ↑(finrank k (CoeSort.coe V))"
] | [
" V.character (h * g) = V.character (g * h)"
] |
import Mathlib.Topology.UniformSpace.UniformConvergence
import Mathlib.Topology.UniformSpace.UniformEmbedding
import Mathlib.Topology.UniformSpace.CompleteSeparated
import Mathlib.Topology.UniformSpace.Compact
import Mathlib.Topology.Algebra.Group.Basic
import Mathlib.Topology.DiscreteSubset
import Mathlib.Tactic.Abel... | Mathlib/Topology/Algebra/UniformGroup.lean | 89 | 92 | theorem UniformContinuous.inv [UniformSpace β] {f : β → α} (hf : UniformContinuous f) :
UniformContinuous fun x => (f x)⁻¹ := by |
have : UniformContinuous fun x => 1 / f x := uniformContinuous_const.div hf
simp_all
| [
" UniformContinuous fun p => p.1 / p.2",
" UniformContinuous fun x => (f x)⁻¹"
] | [
" UniformContinuous fun p => p.1 / p.2"
] |
import Mathlib.Algebra.BigOperators.WithTop
import Mathlib.Algebra.GroupWithZero.Divisibility
import Mathlib.Data.ENNReal.Basic
#align_import data.real.ennreal from "leanprover-community/mathlib"@"c14c8fcde993801fca8946b0d80131a1a81d1520"
open Set NNReal ENNReal
namespace ENNReal
variable {a b c d : ℝ≥0∞} {r p q... | Mathlib/Data/ENNReal/Operations.lean | 193 | 197 | theorem toNNReal_add {r₁ r₂ : ℝ≥0∞} (h₁ : r₁ ≠ ∞) (h₂ : r₂ ≠ ∞) :
(r₁ + r₂).toNNReal = r₁.toNNReal + r₂.toNNReal := by |
lift r₁ to ℝ≥0 using h₁
lift r₂ to ℝ≥0 using h₂
rfl
| [
" (r₁ + r₂).toNNReal = r₁.toNNReal + r₂.toNNReal",
" (↑r₁ + r₂).toNNReal = (↑r₁).toNNReal + r₂.toNNReal",
" (↑r₁ + ↑r₂).toNNReal = (↑r₁).toNNReal + (↑r₂).toNNReal"
] | [] |
import Mathlib.Data.Countable.Basic
import Mathlib.Data.Fin.VecNotation
import Mathlib.Order.Disjointed
import Mathlib.MeasureTheory.OuterMeasure.Defs
#align_import measure_theory.measure.outer_measure from "leanprover-community/mathlib"@"343e80208d29d2d15f8050b929aa50fe4ce71b55"
noncomputable section
open Set F... | Mathlib/MeasureTheory/OuterMeasure/Basic.lean | 93 | 94 | theorem measure_le_inter_add_diff (μ : F) (s t : Set α) : μ s ≤ μ (s ∩ t) + μ (s \ t) := by |
simpa using measure_union_le (s ∩ t) (s \ t)
| [
" μ (⋃ i, s i) ≤ ∑' (i : ι), μ (s i)",
" (fun x x_1 => x ≤ x_1) (μ (⨆ i, t i)) (∑' (i : ℕ), μ (t i))",
" μ (⋃ i, t i) = μ (⋃ i, disjointed t i)",
" ∑' (i : ℕ), μ (disjointed t i) ≤ ∑' (i : ℕ), μ (t i)",
" disjointed t a✝ ⊆ t a✝",
" μ (⋃ i ∈ I, s i) ≤ ∑' (i : ↑I), μ (s ↑i)",
" μ (⋃ x, s ↑x) ≤ ∑' (i : ↑I)... | [
" μ (⋃ i, s i) ≤ ∑' (i : ι), μ (s i)",
" (fun x x_1 => x ≤ x_1) (μ (⨆ i, t i)) (∑' (i : ℕ), μ (t i))",
" μ (⋃ i, t i) = μ (⋃ i, disjointed t i)",
" ∑' (i : ℕ), μ (disjointed t i) ≤ ∑' (i : ℕ), μ (t i)",
" disjointed t a✝ ⊆ t a✝",
" μ (⋃ i ∈ I, s i) ≤ ∑' (i : ↑I), μ (s ↑i)",
" μ (⋃ x, s ↑x) ≤ ∑' (i : ↑I)... |
set_option autoImplicit true
namespace Array
@[simp]
theorem extract_eq_nil_of_start_eq_end {a : Array α} :
a.extract i i = #[] := by
refine extract_empty_of_stop_le_start a ?h
exact Nat.le_refl i
| Mathlib/Data/Array/ExtractLemmas.lean | 21 | 27 | theorem extract_append_left {a b : Array α} {i j : Nat} (h : j ≤ a.size) :
(a ++ b).extract i j = a.extract i j := by |
apply ext
· simp only [size_extract, size_append]
omega
· intro h1 h2 h3
rw [get_extract, get_append_left, get_extract]
| [
" a.extract i i = #[]",
" i ≤ i",
" (a ++ b).extract i j = a.extract i j",
" ((a ++ b).extract i j).size = (a.extract i j).size",
" min j (a.size + b.size) - i = min j a.size - i",
" ∀ (i_1 : Nat) (hi₁ : i_1 < ((a ++ b).extract i j).size) (hi₂ : i_1 < (a.extract i j).size),\n ((a ++ b).extract i j)[i_1... | [
" a.extract i i = #[]",
" i ≤ i"
] |
import Mathlib.LinearAlgebra.Alternating.Basic
import Mathlib.LinearAlgebra.Multilinear.TensorProduct
import Mathlib.GroupTheory.GroupAction.Quotient
#align_import linear_algebra.alternating from "leanprover-community/mathlib"@"0c1d80f5a86b36c1db32e021e8d19ae7809d5b79"
suppress_compilation
open TensorProduct
vari... | Mathlib/LinearAlgebra/Alternating/DomCoprod.lean | 212 | 222 | theorem MultilinearMap.domCoprod_alternization_coe [DecidableEq ιa] [DecidableEq ιb]
(a : MultilinearMap R' (fun _ : ιa => Mᵢ) N₁) (b : MultilinearMap R' (fun _ : ιb => Mᵢ) N₂) :
MultilinearMap.domCoprod (MultilinearMap.alternatization a)
(MultilinearMap.alternatization b) =
∑ σa : Perm ιa, ∑ σb : P... |
simp_rw [← MultilinearMap.domCoprod'_apply, MultilinearMap.alternatization_coe]
simp_rw [TensorProduct.sum_tmul, TensorProduct.tmul_sum, _root_.map_sum,
← TensorProduct.smul_tmul', TensorProduct.tmul_smul]
rfl
| [
" (↑(alternatization a)).domCoprod ↑(alternatization b) =\n ∑ σa : Perm ιa, ∑ σb : Perm ιb, Perm.sign σa • Perm.sign σb • (domDomCongr σa a).domCoprod (domDomCongr σb b)",
" domCoprod' ((∑ σ : Perm ιa, Perm.sign σ • domDomCongr σ a) ⊗ₜ[R'] ∑ σ : Perm ιb, Perm.sign σ • domDomCongr σ b) =\n ∑ x : Perm ιa, ∑ x... | [] |
import Mathlib.Analysis.Asymptotics.AsymptoticEquivalent
import Mathlib.Analysis.Normed.Group.Lemmas
import Mathlib.Analysis.NormedSpace.AddTorsor
import Mathlib.Analysis.NormedSpace.AffineIsometry
import Mathlib.Analysis.NormedSpace.OperatorNorm.NormedSpace
import Mathlib.Analysis.NormedSpace.RieszLemma
import Mathli... | Mathlib/Analysis/NormedSpace/FiniteDimension.lean | 198 | 220 | theorem LipschitzOnWith.extend_finite_dimension {α : Type*} [PseudoMetricSpace α] {E' : Type*}
[NormedAddCommGroup E'] [NormedSpace ℝ E'] [FiniteDimensional ℝ E'] {s : Set α} {f : α → E'}
{K : ℝ≥0} (hf : LipschitzOnWith K f s) :
∃ g : α → E', LipschitzWith (lipschitzExtensionConstant E' * K) g ∧ EqOn f g s ... |
/- This result is already known for spaces `ι → ℝ`. We use a continuous linear equiv between
`E'` and such a space to transfer the result to `E'`. -/
let ι : Type _ := Basis.ofVectorSpaceIndex ℝ E'
let A := (Basis.ofVectorSpace ℝ E').equivFun.toContinuousLinearEquiv
have LA : LipschitzWith ‖A.toContinuousL... | [
" Continuous fun f => f.det",
" Continuous fun f => LinearMap.det ↑f",
" Continuous fun f => ((LinearMap.toMatrix b b) ↑f).det",
" Continuous fun f => (LinearMap.toMatrix b b) ↑f",
" Continuous fun f =>\n (if H : ∃ s, Nonempty (Basis { x // x ∈ s } 𝕜 E) then LinearMap.detAux (Trunc.mk ⋯.some) else 1) ↑f... | [
" Continuous fun f => f.det",
" Continuous fun f => LinearMap.det ↑f",
" Continuous fun f => ((LinearMap.toMatrix b b) ↑f).det",
" Continuous fun f => (LinearMap.toMatrix b b) ↑f",
" Continuous fun f =>\n (if H : ∃ s, Nonempty (Basis { x // x ∈ s } 𝕜 E) then LinearMap.detAux (Trunc.mk ⋯.some) else 1) ↑f... |
import Mathlib.RingTheory.FiniteType
import Mathlib.RingTheory.Localization.AtPrime
import Mathlib.RingTheory.Localization.Away.Basic
import Mathlib.RingTheory.Localization.Integer
import Mathlib.RingTheory.Localization.Submodule
import Mathlib.RingTheory.Nilpotent.Lemmas
import Mathlib.RingTheory.RingHomProperties
im... | Mathlib/RingTheory/LocalProperties.lean | 166 | 176 | theorem RingHom.ofLocalizationSpanTarget_iff_finite :
RingHom.OfLocalizationSpanTarget @P ↔ RingHom.OfLocalizationFiniteSpanTarget @P := by |
delta RingHom.OfLocalizationSpanTarget RingHom.OfLocalizationFiniteSpanTarget
apply forall₅_congr
-- TODO: Using `refine` here breaks `resetI`.
intros
constructor
· intro h s; exact h s
· intro h s hs hs'
obtain ⟨s', h₁, h₂⟩ := (Ideal.span_eq_top_iff_finite s).mp hs
exact h s' h₂ fun x => hs' ⟨_,... | [
" OfLocalizationSpan P ↔ OfLocalizationFiniteSpan P",
" (∀ ⦃R S : Type u⦄ [inst : CommRing R] [inst_1 : CommRing S] (f : R →+* S) (s : Set R),\n Ideal.span s = ⊤ → (∀ (r : ↑s), P (Localization.awayMap f ↑r)) → P f) ↔\n ∀ ⦃R S : Type u⦄ [inst : CommRing R] [inst_1 : CommRing S] (f : R →+* S) (s : Finset R)... | [
" OfLocalizationSpan P ↔ OfLocalizationFiniteSpan P",
" (∀ ⦃R S : Type u⦄ [inst : CommRing R] [inst_1 : CommRing S] (f : R →+* S) (s : Set R),\n Ideal.span s = ⊤ → (∀ (r : ↑s), P (Localization.awayMap f ↑r)) → P f) ↔\n ∀ ⦃R S : Type u⦄ [inst : CommRing R] [inst_1 : CommRing S] (f : R →+* S) (s : Finset R)... |
import Mathlib.Analysis.Seminorm
import Mathlib.Topology.Algebra.Equicontinuity
import Mathlib.Topology.MetricSpace.Equicontinuity
import Mathlib.Topology.Algebra.FilterBasis
import Mathlib.Topology.Algebra.Module.LocallyConvex
#align_import analysis.locally_convex.with_seminorms from "leanprover-community/mathlib"@"... | Mathlib/Analysis/LocallyConvex/WithSeminorms.lean | 79 | 81 | theorem basisSets_iff {U : Set E} :
U ∈ p.basisSets ↔ ∃ (i : Finset ι) (r : ℝ), 0 < r ∧ U = ball (i.sup p) 0 r := by |
simp only [basisSets, mem_iUnion, exists_prop, mem_singleton_iff]
| [
" U ∈ p.basisSets ↔ ∃ i r, 0 < r ∧ U = (i.sup p).ball 0 r"
] | [] |
import Mathlib.Analysis.Complex.Basic
import Mathlib.Topology.FiberBundle.IsHomeomorphicTrivialBundle
#align_import analysis.complex.re_im_topology from "leanprover-community/mathlib"@"468b141b14016d54b479eb7a0fff1e360b7e3cf6"
open Set
noncomputable section
namespace Complex
theorem isHomeomorphicTrivialFiber... | Mathlib/Analysis/Complex/ReImTopology.lean | 119 | 120 | theorem closure_setOf_im_lt (a : ℝ) : closure { z : ℂ | z.im < a } = { z | z.im ≤ a } := by |
simpa only [closure_Iio] using closure_preimage_im (Iio a)
| [
" interior {z | z.re ≤ a} = {z | z.re < a}",
" interior {z | z.im ≤ a} = {z | z.im < a}",
" interior {z | a ≤ z.re} = {z | a < z.re}",
" interior {z | a ≤ z.im} = {z | a < z.im}",
" closure {z | z.re < a} = {z | z.re ≤ a}",
" closure {z | z.im < a} = {z | z.im ≤ a}"
] | [
" interior {z | z.re ≤ a} = {z | z.re < a}",
" interior {z | z.im ≤ a} = {z | z.im < a}",
" interior {z | a ≤ z.re} = {z | a < z.re}",
" interior {z | a ≤ z.im} = {z | a < z.im}",
" closure {z | z.re < a} = {z | z.re ≤ a}"
] |
import Mathlib.Analysis.MeanInequalities
import Mathlib.Analysis.MeanInequalitiesPow
import Mathlib.Analysis.SpecialFunctions.Pow.Continuity
import Mathlib.Data.Set.Image
import Mathlib.Topology.Algebra.Order.LiminfLimsup
#align_import analysis.normed_space.lp_space from "leanprover-community/mathlib"@"de83b43717abe3... | Mathlib/Analysis/NormedSpace/lpSpace.lean | 99 | 103 | theorem memℓp_gen_iff (hp : 0 < p.toReal) {f : ∀ i, E i} :
Memℓp f p ↔ Summable fun i => ‖f i‖ ^ p.toReal := by |
rw [ENNReal.toReal_pos_iff] at hp
dsimp [Memℓp]
rw [if_neg hp.1.ne', if_neg hp.2.ne]
| [
" Memℓp f 0 ↔ {i | f i ≠ 0}.Finite",
" (if 0 = 0 then {i | ¬f i = 0}.Finite\n else if 0 = ⊤ then BddAbove (Set.range fun i => ‖f i‖) else Summable fun i => ‖f i‖ ^ 0) ↔\n {i | ¬f i = 0}.Finite",
" Memℓp f ⊤ ↔ BddAbove (Set.range fun i => ‖f i‖)",
" (if ⊤ = 0 then {i | ¬f i = 0}.Finite\n else if ⊤ = ⊤... | [
" Memℓp f 0 ↔ {i | f i ≠ 0}.Finite",
" (if 0 = 0 then {i | ¬f i = 0}.Finite\n else if 0 = ⊤ then BddAbove (Set.range fun i => ‖f i‖) else Summable fun i => ‖f i‖ ^ 0) ↔\n {i | ¬f i = 0}.Finite",
" Memℓp f ⊤ ↔ BddAbove (Set.range fun i => ‖f i‖)",
" (if ⊤ = 0 then {i | ¬f i = 0}.Finite\n else if ⊤ = ⊤... |
import Mathlib.Analysis.BoxIntegral.Partition.SubboxInduction
import Mathlib.Analysis.BoxIntegral.Partition.Split
#align_import analysis.box_integral.partition.filter from "leanprover-community/mathlib"@"92ca63f0fb391a9ca5f22d2409a6080e786d99f7"
open Set Function Filter Metric Finset Bool
open scoped Classical
o... | Mathlib/Analysis/BoxIntegral/Partition/Filter.lean | 280 | 280 | theorem henstock_le_mcShane : Henstock ≤ McShane := by | trivial
| [
" Henstock ≤ Riemann",
" Henstock ≤ McShane"
] | [
" Henstock ≤ Riemann"
] |
import Mathlib.Algebra.Polynomial.AlgebraMap
import Mathlib.Algebra.Polynomial.BigOperators
import Mathlib.Algebra.Polynomial.Degree.Lemmas
import Mathlib.Algebra.Polynomial.Div
#align_import data.polynomial.ring_division from "leanprover-community/mathlib"@"8efcf8022aac8e01df8d302dcebdbc25d6a886c8"
noncomputable ... | Mathlib/Algebra/Polynomial/RingDivision.lean | 319 | 320 | theorem root_mul : IsRoot (p * q) a ↔ IsRoot p a ∨ IsRoot q a := by |
simp_rw [IsRoot, eval_mul, mul_eq_zero]
| [
" Irreducible p ↔ ∀ (f g : R[X]), f.Monic → g.Monic → f * g = p → f = 1 ∨ g = 1",
" (g * C f.leadingCoeff).Monic",
" (f * C g.leadingCoeff).Monic",
" g * C f.leadingCoeff * (f * C g.leadingCoeff) = p",
" Irreducible p ↔ p ≠ 1 ∧ ∀ (f g : R[X]), f.Monic → g.Monic → f * g = p → f.natDegree = 0 ∨ g.natDegree = ... | [
" Irreducible p ↔ ∀ (f g : R[X]), f.Monic → g.Monic → f * g = p → f = 1 ∨ g = 1",
" (g * C f.leadingCoeff).Monic",
" (f * C g.leadingCoeff).Monic",
" g * C f.leadingCoeff * (f * C g.leadingCoeff) = p",
" Irreducible p ↔ p ≠ 1 ∧ ∀ (f g : R[X]), f.Monic → g.Monic → f * g = p → f.natDegree = 0 ∨ g.natDegree = ... |
import Mathlib.Topology.Separation
import Mathlib.Topology.NoetherianSpace
#align_import topology.quasi_separated from "leanprover-community/mathlib"@"5dc6092d09e5e489106865241986f7f2ad28d4c8"
open TopologicalSpace
variable {α β : Type*} [TopologicalSpace α] [TopologicalSpace β] {f : α → β}
def IsQuasiSeparate... | Mathlib/Topology/QuasiSeparated.lean | 99 | 103 | theorem isQuasiSeparated_iff_quasiSeparatedSpace (s : Set α) (hs : IsOpen s) :
IsQuasiSeparated s ↔ QuasiSeparatedSpace s := by |
rw [← isQuasiSeparated_univ_iff]
convert (hs.openEmbedding_subtype_val.isQuasiSeparated_iff (s := Set.univ)).symm
simp
| [
" IsQuasiSeparated Set.univ ↔ QuasiSeparatedSpace α",
" IsQuasiSeparated Set.univ ↔ ∀ (U V : Set α), IsOpen U → IsCompact U → IsOpen V → IsCompact V → IsCompact (U ∩ V)",
" IsQuasiSeparated (f '' s)",
" IsCompact (U ∩ V)",
" U ∩ V = f '' (f ⁻¹' U ∩ f ⁻¹' V)",
" f '' (f ⁻¹' U ∩ f ⁻¹' V) = U ∩ V",
" U ∩ V... | [
" IsQuasiSeparated Set.univ ↔ QuasiSeparatedSpace α",
" IsQuasiSeparated Set.univ ↔ ∀ (U V : Set α), IsOpen U → IsCompact U → IsOpen V → IsCompact V → IsCompact (U ∩ V)",
" IsQuasiSeparated (f '' s)",
" IsCompact (U ∩ V)",
" U ∩ V = f '' (f ⁻¹' U ∩ f ⁻¹' V)",
" f '' (f ⁻¹' U ∩ f ⁻¹' V) = U ∩ V",
" U ∩ V... |
import Mathlib.LinearAlgebra.Matrix.Determinant.Basic
#align_import linear_algebra.matrix.reindex from "leanprover-community/mathlib"@"1cfdf5f34e1044ecb65d10be753008baaf118edf"
namespace Matrix
open Equiv Matrix
variable {l m n o : Type*} {l' m' n' o' : Type*} {m'' n'' : Type*}
variable (R A : Type*)
section A... | Mathlib/LinearAlgebra/Matrix/Reindex.lean | 66 | 70 | theorem reindexLinearEquiv_trans (e₁ : m ≃ m') (e₂ : n ≃ n') (e₁' : m' ≃ m'') (e₂' : n' ≃ n'') :
(reindexLinearEquiv R A e₁ e₂).trans (reindexLinearEquiv R A e₁' e₂') =
(reindexLinearEquiv R A (e₁.trans e₁') (e₂.trans e₂') : _ ≃ₗ[R] _) := by |
ext
rfl
| [
" reindexLinearEquiv R A e₁ e₂ ≪≫ₗ reindexLinearEquiv R A e₁' e₂' = reindexLinearEquiv R A (e₁.trans e₁') (e₂.trans e₂')",
" (reindexLinearEquiv R A e₁ e₂ ≪≫ₗ reindexLinearEquiv R A e₁' e₂') x✝ i✝ j✝ =\n (reindexLinearEquiv R A (e₁.trans e₁') (e₂.trans e₂')) x✝ i✝ j✝"
] | [] |
import Mathlib.Algebra.BigOperators.Group.Finset
import Mathlib.Data.Finset.NatAntidiagonal
import Mathlib.Data.Nat.GCD.Basic
import Mathlib.Init.Data.Nat.Lemmas
import Mathlib.Logic.Function.Iterate
import Mathlib.Tactic.Ring
import Mathlib.Tactic.Zify
#align_import data.nat.fib from "leanprover-community/mathlib"@"... | Mathlib/Data/Nat/Fib/Basic.lean | 94 | 94 | theorem fib_le_fib_succ {n : ℕ} : fib n ≤ fib (n + 1) := by | cases n <;> simp [fib_add_two]
| [
" (n + 2).fib = n.fib + (n + 1).fib",
" n.fib ≤ (n + 1).fib",
" fib 0 ≤ (0 + 1).fib",
" (n✝ + 1).fib ≤ (n✝ + 1 + 1).fib"
] | [
" (n + 2).fib = n.fib + (n + 1).fib"
] |
import Mathlib.Geometry.Manifold.ContMDiff.Product
import Mathlib.Analysis.NormedSpace.OperatorNorm.Prod
open Set ChartedSpace SmoothManifoldWithCorners
open scoped Topology Manifold
variable {𝕜 : Type*} [NontriviallyNormedField 𝕜]
-- declare a smooth manifold `M` over the pair `(E, H)`.
{E : Type*}
[Norme... | Mathlib/Geometry/Manifold/ContMDiff/NormedSpace.lean | 63 | 65 | theorem contMDiffAt_iff_contDiffAt {f : E → E'} {x : E} :
ContMDiffAt 𝓘(𝕜, E) 𝓘(𝕜, E') n f x ↔ ContDiffAt 𝕜 n f x := by |
rw [← contMDiffWithinAt_univ, contMDiffWithinAt_iff_contDiffWithinAt, contDiffWithinAt_univ]
| [
" ContMDiffWithinAt 𝓘(𝕜, E) 𝓘(𝕜, E') n f s x ↔ ContDiffWithinAt 𝕜 n f s x",
" ContDiffWithinAt 𝕜 n f s x → ContinuousWithinAt f s x",
" ContMDiffAt 𝓘(𝕜, E) 𝓘(𝕜, E') n f x ↔ ContDiffAt 𝕜 n f x"
] | [
" ContMDiffWithinAt 𝓘(𝕜, E) 𝓘(𝕜, E') n f s x ↔ ContDiffWithinAt 𝕜 n f s x",
" ContDiffWithinAt 𝕜 n f s x → ContinuousWithinAt f s x"
] |
import Mathlib.Analysis.SpecificLimits.Basic
import Mathlib.RingTheory.Polynomial.Bernstein
import Mathlib.Topology.ContinuousFunction.Polynomial
import Mathlib.Topology.ContinuousFunction.Compact
#align_import analysis.special_functions.bernstein from "leanprover-community/mathlib"@"2c1d8ca2812b64f88992a5294ea3dba14... | Mathlib/Analysis/SpecialFunctions/Bernstein.lean | 109 | 114 | theorem probability (n : ℕ) (x : I) : (∑ k : Fin (n + 1), bernstein n k x) = 1 := by |
have := bernsteinPolynomial.sum ℝ n
apply_fun fun p => Polynomial.aeval (x : ℝ) p at this
simp? [AlgHom.map_sum, Finset.sum_range] at this says
simp only [Finset.sum_range, map_sum, Polynomial.coe_aeval_eq_eval, map_one] at this
exact this
| [
" (bernstein n ν) x = ↑(n.choose ν) * ↑x ^ ν * (1 - ↑x) ^ (n - ν)",
" Polynomial.eval (↑x) (↑(n.choose ν) * Polynomial.X ^ ν * (1 - Polynomial.X) ^ (n - ν)) =\n ↑(n.choose ν) * ↑x ^ ν * (1 - ↑x) ^ (n - ν)",
" 0 ≤ (bernstein n ν) x",
" 0 ≤ ↑(n.choose ν) * ↑x ^ ν * (1 - ↑x) ^ (n - ν)",
" 0 ≤ ↑x",
" 0 ≤ 1... | [
" (bernstein n ν) x = ↑(n.choose ν) * ↑x ^ ν * (1 - ↑x) ^ (n - ν)",
" Polynomial.eval (↑x) (↑(n.choose ν) * Polynomial.X ^ ν * (1 - Polynomial.X) ^ (n - ν)) =\n ↑(n.choose ν) * ↑x ^ ν * (1 - ↑x) ^ (n - ν)",
" 0 ≤ (bernstein n ν) x",
" 0 ≤ ↑(n.choose ν) * ↑x ^ ν * (1 - ↑x) ^ (n - ν)",
" 0 ≤ ↑x",
" 0 ≤ 1... |
import Mathlib.Order.Filter.Basic
import Mathlib.Data.Set.Countable
#align_import order.filter.countable_Inter from "leanprover-community/mathlib"@"b9e46fe101fc897fb2e7edaf0bf1f09ea49eb81a"
open Set Filter
open Filter
variable {ι : Sort*} {α β : Type*}
class CountableInterFilter (l : Filter α) : Prop where
... | Mathlib/Order/Filter/CountableInter.lean | 71 | 75 | theorem eventually_countable_ball {ι : Type*} {S : Set ι} (hS : S.Countable)
{p : α → ∀ i ∈ S, Prop} :
(∀ᶠ x in l, ∀ i hi, p x i hi) ↔ ∀ i hi, ∀ᶠ x in l, p x i hi := by |
simpa only [Filter.Eventually, setOf_forall] using
@countable_bInter_mem _ l _ _ _ hS fun i hi => { x | p x i hi }
| [
" ⋂ i, ⋂ (hi : i ∈ S), s i hi ∈ l ↔ ∀ (i : ι) (hi : i ∈ S), s i hi ∈ l",
" ⋂ x, s ↑x ⋯ ∈ l ↔ ∀ (i : ι) (hi : i ∈ S), s i hi ∈ l",
" (∀ᶠ (x : α) in l, ∀ (i : ι), p x i) ↔ ∀ (i : ι), ∀ᶠ (x : α) in l, p x i",
" (∀ᶠ (x : α) in l, ∀ (i : ι) (hi : i ∈ S), p x i hi) ↔ ∀ (i : ι) (hi : i ∈ S), ∀ᶠ (x : α) in l, p x i h... | [
" ⋂ i, ⋂ (hi : i ∈ S), s i hi ∈ l ↔ ∀ (i : ι) (hi : i ∈ S), s i hi ∈ l",
" ⋂ x, s ↑x ⋯ ∈ l ↔ ∀ (i : ι) (hi : i ∈ S), s i hi ∈ l",
" (∀ᶠ (x : α) in l, ∀ (i : ι), p x i) ↔ ∀ (i : ι), ∀ᶠ (x : α) in l, p x i"
] |
import Mathlib.LinearAlgebra.Pi
import Mathlib.LinearAlgebra.Quotient
#align_import linear_algebra.quotient_pi from "leanprover-community/mathlib"@"398f60f60b43ef42154bd2bdadf5133daf1577a4"
namespace Submodule
open LinearMap
variable {ι R : Type*} [CommRing R]
variable {Ms : ι → Type*} [∀ i, AddCommGroup (Ms i)... | Mathlib/LinearAlgebra/QuotientPi.lean | 50 | 60 | theorem piQuotientLift_single [Fintype ι] [DecidableEq ι] (p : ∀ i, Submodule R (Ms i))
(q : Submodule R N) (f : ∀ i, Ms i →ₗ[R] N) (hf : ∀ i, p i ≤ q.comap (f i)) (i)
(x : Ms i ⧸ p i) : piQuotientLift p q f hf (Pi.single i x) = mapQ _ _ (f i) (hf i) x := by |
simp_rw [piQuotientLift, lsum_apply, sum_apply, comp_apply, proj_apply]
rw [Finset.sum_eq_single i]
· rw [Pi.single_eq_same]
· rintro j - hj
rw [Pi.single_eq_of_ne hj, _root_.map_zero]
· intros
have := Finset.mem_univ i
contradiction
| [
" ((piQuotientLift p q f hf) fun i => Quotient.mk (x i)) = Quotient.mk (((lsum R (fun i => Ms i) R) f) x)",
" (∑ d : ι, ((p d).mapQ q (f d) ⋯ ∘ₗ proj d) fun i => Quotient.mk (x i)) = ∑ x_1 : ι, q.mkQ ((f x_1 ∘ₗ proj x_1) x)",
" (piQuotientLift p q f hf) (Pi.single i x) = ((p i).mapQ q (f i) ⋯) x",
" ∑ x_1 : ι... | [
" ((piQuotientLift p q f hf) fun i => Quotient.mk (x i)) = Quotient.mk (((lsum R (fun i => Ms i) R) f) x)",
" (∑ d : ι, ((p d).mapQ q (f d) ⋯ ∘ₗ proj d) fun i => Quotient.mk (x i)) = ∑ x_1 : ι, q.mkQ ((f x_1 ∘ₗ proj x_1) x)"
] |
import Mathlib.SetTheory.Ordinal.Arithmetic
namespace OrdinalApprox
universe u
variable {α : Type u}
variable [CompleteLattice α] (f : α →o α) (x : α)
open Function fixedPoints Cardinal Order OrderHom
set_option linter.unusedVariables false in
def lfpApprox (a : Ordinal.{u}) : α :=
sSup ({ f (lfpApprox b) | ... | Mathlib/SetTheory/Ordinal/FixedPointApproximants.lean | 116 | 133 | theorem lfpApprox_eq_of_mem_fixedPoints {a b : Ordinal} (h_init : x ≤ f x) (h_ab : a ≤ b)
(h: lfpApprox f x a ∈ fixedPoints f) : lfpApprox f x b = lfpApprox f x a := by |
rw [mem_fixedPoints_iff] at h
induction b using Ordinal.induction with | h b IH =>
apply le_antisymm
· conv => left; unfold lfpApprox
apply sSup_le
simp only [exists_prop, Set.union_singleton, Set.mem_insert_iff, Set.mem_setOf_eq,
forall_eq_or_imp, forall_exists_index, and_imp, forall_apply_eq_im... | [
" (invImage (fun x => x) Ordinal.wellFoundedRelation).1 b a",
" Monotone (lfpApprox f x)",
" ∀ ⦃a b : Ordinal.{u}⦄, a ≤ b → lfpApprox f x a ≤ lfpApprox f x b",
" lfpApprox f x a ≤ lfpApprox f x b",
" sSup ({x_1 | ∃ b, ∃ (_ : b < a), f (lfpApprox f x b) = x_1} ∪ {x}) ≤\n sSup ({x_1 | ∃ b_1, ∃ (_ : b_1 < b... | [
" (invImage (fun x => x) Ordinal.wellFoundedRelation).1 b a",
" Monotone (lfpApprox f x)",
" ∀ ⦃a b : Ordinal.{u}⦄, a ≤ b → lfpApprox f x a ≤ lfpApprox f x b",
" lfpApprox f x a ≤ lfpApprox f x b",
" sSup ({x_1 | ∃ b, ∃ (_ : b < a), f (lfpApprox f x b) = x_1} ∪ {x}) ≤\n sSup ({x_1 | ∃ b_1, ∃ (_ : b_1 < b... |
import Mathlib.Algebra.Lie.Abelian
import Mathlib.Algebra.Lie.Solvable
import Mathlib.LinearAlgebra.Dual
#align_import algebra.lie.character from "leanprover-community/mathlib"@"132328c4dd48da87adca5d408ca54f315282b719"
universe u v w w₁
namespace LieAlgebra
variable (R : Type u) (L : Type v) [CommRing R] [LieR... | Mathlib/Algebra/Lie/Character.lean | 49 | 50 | theorem lieCharacter_apply_lie' (χ : LieCharacter R L) (x y : L) : ⁅χ x, χ y⁆ = 0 := by |
rw [LieRing.of_associative_ring_bracket, mul_comm, sub_self]
| [
" χ ⁅x, y⁆ = 0",
" ⁅χ x, χ y⁆ = 0"
] | [
" χ ⁅x, y⁆ = 0"
] |
import Mathlib.Geometry.Manifold.Diffeomorph
import Mathlib.Geometry.Manifold.Instances.Real
import Mathlib.Geometry.Manifold.PartitionOfUnity
#align_import geometry.manifold.whitney_embedding from "leanprover-community/mathlib"@"86c29aefdba50b3f33e86e52e3b2f51a0d8f0282"
universe uι uE uH uM
variable {ι : Type u... | Mathlib/Geometry/Manifold/WhitneyEmbedding.lean | 83 | 98 | theorem comp_embeddingPiTangent_mfderiv (x : M) (hx : x ∈ s) :
((ContinuousLinearMap.fst ℝ E ℝ).comp
(@ContinuousLinearMap.proj ℝ _ ι (fun _ => E × ℝ) _ _ (fun _ => inferInstance)
(f.ind x hx))).comp
(mfderiv I 𝓘(ℝ, ι → E × ℝ) f.embeddingPiTangent x) =
mfderiv I I (chartAt H... |
set L :=
(ContinuousLinearMap.fst ℝ E ℝ).comp
(@ContinuousLinearMap.proj ℝ _ ι (fun _ => E × ℝ) _ _ (fun _ => inferInstance) (f.ind x hx))
have := L.hasMFDerivAt.comp x f.embeddingPiTangent.smooth.mdifferentiableAt.hasMFDerivAt
convert hasMFDerivAt_unique this _
refine (hasMFDerivAt_extChartAt I (f.m... | [
" InjOn (⇑f.embeddingPiTangent) s",
" x = y",
" ((ContinuousLinearMap.fst ℝ E ℝ).comp (ContinuousLinearMap.proj (f.ind x hx))).comp\n (mfderiv I 𝓘(ℝ, ι → E × ℝ) (⇑f.embeddingPiTangent) x) =\n mfderiv I I (↑(chartAt H (f.c (f.ind x hx)))) x",
" L.comp (mfderiv I 𝓘(ℝ, ι → E × ℝ) (⇑f.embeddingPiTangent... | [
" InjOn (⇑f.embeddingPiTangent) s",
" x = y"
] |
import Mathlib.Algebra.Algebra.Defs
import Mathlib.Algebra.Order.Group.Basic
import Mathlib.Algebra.Order.Ring.Basic
import Mathlib.RingTheory.Localization.Basic
import Mathlib.SetTheory.Game.Birthday
import Mathlib.SetTheory.Surreal.Basic
#align_import set_theory.surreal.dyadic from "leanprover-community/mathlib"@"9... | Mathlib/SetTheory/Surreal/Dyadic.lean | 116 | 117 | theorem powHalf_pos (n : ℕ) : 0 < powHalf n := by |
rw [← lf_iff_lt numeric_zero (numeric_powHalf n), zero_lf_le]; simp
| [
" (powHalf n).LeftMoves = PUnit.{u_1 + 1}",
" (powHalf 0).LeftMoves = PUnit.{u_1 + 1}",
" (powHalf (n✝ + 1)).LeftMoves = PUnit.{u_1 + 1}",
" (powHalf n).moveLeft i = 0",
" (powHalf 0).moveLeft i = 0",
" (powHalf (n✝ + 1)).moveLeft i = 0",
" (powHalf 0).moveLeft PUnit.unit = 0",
" (powHalf (n✝ + 1)).mo... | [
" (powHalf n).LeftMoves = PUnit.{u_1 + 1}",
" (powHalf 0).LeftMoves = PUnit.{u_1 + 1}",
" (powHalf (n✝ + 1)).LeftMoves = PUnit.{u_1 + 1}",
" (powHalf n).moveLeft i = 0",
" (powHalf 0).moveLeft i = 0",
" (powHalf (n✝ + 1)).moveLeft i = 0",
" (powHalf 0).moveLeft PUnit.unit = 0",
" (powHalf (n✝ + 1)).mo... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.