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.NormedSpace.OperatorNorm.Bilinear
import Mathlib.Analysis.NormedSpace.OperatorNorm.NNNorm
import Mathlib.Analysis.NormedSpace.Span
suppress_compilation
open Bornology
open Filter hiding map_smul
open scoped Classical NNReal Topology Uniformity
-- the `β` subscript variables are for special... | Mathlib/Analysis/NormedSpace/OperatorNorm/NormedSpace.lean | 52 | 64 | theorem bound_of_ball_bound {r : β} (r_pos : 0 < r) (c : β) (f : E ββ[π] Fβ)
(h : β z β Metric.ball (0 : E) r, βf zβ β€ c) : β C, β z : E, βf zβ β€ C * βzβ := by |
cases' @NontriviallyNormedField.non_trivial π _ with k hk
use c * (βkβ / r)
intro z
refine bound_of_shell _ r_pos hk (fun x hko hxo => ?_) _
calc
βf xβ β€ c := h _ (mem_ball_zero_iff.mpr hxo)
_ β€ c * (βxβ * βkβ / r) := le_mul_of_one_le_right ?_ ?_
_ = _ := by ring
Β· exact le_trans (norm_nonneg ... | [
" βf xβ β€ C * βxβ",
" β C, β (z : E), βf zβ β€ C * βzβ",
" β (z : E), βf zβ β€ c * (βkβ / r) * βzβ",
" βf zβ β€ c * (βkβ / r) * βzβ",
" βf xβ β€ c * (βkβ / r) * βxβ",
" c * (βxβ * βkβ / r) = c * (βkβ / r) * βxβ",
" 0 β€ c",
" 0 β ball 0 r",
" 1 β€ βxβ * βkβ / r"
] | [
" βf xβ β€ C * βxβ"
] |
import Mathlib.Data.Int.Bitwise
import Mathlib.Data.Int.Order.Lemmas
import Mathlib.Data.Set.Function
import Mathlib.Order.Interval.Set.Basic
#align_import data.int.lemmas from "leanprover-community/mathlib"@"09597669f02422ed388036273d8848119699c22f"
open Nat
namespace Int
theorem le_natCast_sub (m n : β) : (m ... | Mathlib/Data/Int/Lemmas.lean | 50 | 52 | theorem natAbs_lt_iff_sq_lt {a b : β€} : a.natAbs < b.natAbs β a ^ 2 < b ^ 2 := by |
rw [sq, sq]
exact natAbs_lt_iff_mul_self_lt
| [
" βm - βn β€ β(m - n)",
" 0 β€ βn",
" a.natAbs = b.natAbs β a ^ 2 = b ^ 2",
" a.natAbs = b.natAbs β a * a = b * b",
" a.natAbs < b.natAbs β a ^ 2 < b ^ 2",
" a.natAbs < b.natAbs β a * a < b * b"
] | [
" βm - βn β€ β(m - n)",
" 0 β€ βn",
" a.natAbs = b.natAbs β a ^ 2 = b ^ 2",
" a.natAbs = b.natAbs β a * a = b * b"
] |
import Mathlib.Algebra.MonoidAlgebra.Division
import Mathlib.Algebra.MvPolynomial.Basic
#align_import data.mv_polynomial.division from "leanprover-community/mathlib"@"72c366d0475675f1309d3027d3d7d47ee4423951"
variable {Ο R : Type*} [CommSemiring R]
namespace MvPolynomial
| Mathlib/Algebra/MvPolynomial/Division.lean | 221 | 240 | theorem monomial_dvd_monomial {r s : R} {i j : Ο ββ β} :
monomial i r β£ monomial j s β (s = 0 β¨ i β€ j) β§ r β£ s := by |
constructor
Β· rintro β¨x, hxβ©
rw [MvPolynomial.ext_iff] at hx
have hj := hx j
have hi := hx i
classical
simp_rw [coeff_monomial, if_pos] at hj hi
simp_rw [coeff_monomial_mul'] at hi hj
split_ifs at hi hj with hi hi
Β· exact β¨Or.inr hi, _, hjβ©
Β· exact β¨Or.inl hj, hj.symm ... | [
" (monomial i) r β£ (monomial j) s β (s = 0 β¨ i β€ j) β§ r β£ s",
" (monomial i) r β£ (monomial j) s β (s = 0 β¨ i β€ j) β§ r β£ s",
" (s = 0 β¨ i β€ j) β§ r β£ s",
" (s = 0 β¨ i β€ j) β§ r β£ s β (monomial i) r β£ (monomial j) s",
" (monomial i) r β£ (monomial j) (r * d)",
" (monomial j) (r * d) = (monomial i) r * (monomia... | [] |
import Mathlib.Init.Logic
import Mathlib.Init.Function
import Mathlib.Init.Algebra.Classes
import Batteries.Util.LibraryNote
import Batteries.Tactic.Lint.Basic
#align_import logic.basic from "leanprover-community/mathlib"@"3365b20c2ffa7c35e47e5209b89ba9abdddf3ffe"
#align_import init.ite_simp from "leanprover-communit... | Mathlib/Logic/Basic.lean | 611 | 612 | theorem heq_rec_iff_heq {C : Ξ± β Sort*} {x : Ξ²} {y : C a} {e : a = b} :
HEq x (e βΈ y) β HEq x y := by | subst e; rfl
| [
" h βΈ z = cast β― z",
" β― βΈ z = cast β― z",
" HEq (t βΈ p) p",
" HEq (β― βΈ p) p",
" HEq (e βΈ x) y",
" HEq (β― βΈ x) y",
" HEq (e βΈ x) y β HEq x y",
" HEq (β― βΈ x) y β HEq x y",
" HEq x (e βΈ y) β HEq x y",
" HEq x (β― βΈ y) β HEq x y"
] | [
" h βΈ z = cast β― z",
" β― βΈ z = cast β― z",
" HEq (t βΈ p) p",
" HEq (β― βΈ p) p",
" HEq (e βΈ x) y",
" HEq (β― βΈ x) y",
" HEq (e βΈ x) y β HEq x y",
" HEq (β― βΈ x) y β HEq x y"
] |
import Mathlib.Algebra.Quaternion
import Mathlib.Tactic.Ring
#align_import algebra.quaternion_basis from "leanprover-community/mathlib"@"3aa5b8a9ed7a7cabd36e6e1d022c9858ab8a8c2d"
open Quaternion
namespace QuaternionAlgebra
structure Basis {R : Type*} (A : Type*) [CommRing R] [Ring A] [Algebra R A] (cβ cβ : R) ... | Mathlib/Algebra/QuaternionBasis.lean | 89 | 90 | theorem k_mul_i : q.k * q.i = -cβ β’ q.j := by |
rw [β i_mul_j, mul_assoc, j_mul_i, mul_neg, i_mul_k, neg_smul]
| [
" qβ = qβ",
" { i := iβ, j := jβ, k := kβ, i_mul_i := i_mul_iβ, j_mul_j := j_mul_jβ, i_mul_j := i_mul_jβ, j_mul_i := j_mul_iβ } = qβ",
" { i := iβ, j := jβ, k := kβ, i_mul_i := i_mul_iβ, j_mul_j := j_mul_jβ, i_mul_j := qβ_i_mul_j, j_mul_i := j_mul_iβ } =\n qβ",
" { i := iβΒΉ, j := jβΒΉ, k := kβΒΉ, i_mul_i := ... | [
" qβ = qβ",
" { i := iβ, j := jβ, k := kβ, i_mul_i := i_mul_iβ, j_mul_j := j_mul_jβ, i_mul_j := i_mul_jβ, j_mul_i := j_mul_iβ } = qβ",
" { i := iβ, j := jβ, k := kβ, i_mul_i := i_mul_iβ, j_mul_j := j_mul_jβ, i_mul_j := qβ_i_mul_j, j_mul_i := j_mul_iβ } =\n qβ",
" { i := iβΒΉ, j := jβΒΉ, k := kβΒΉ, i_mul_i := ... |
import Mathlib.Data.List.Cycle
import Mathlib.GroupTheory.Perm.Cycle.Type
import Mathlib.GroupTheory.Perm.List
#align_import group_theory.perm.cycle.concrete from "leanprover-community/mathlib"@"00638177efd1b2534fc5269363ebf42a7871df9a"
open Equiv Equiv.Perm List
variable {Ξ± : Type*}
namespace Equiv.Perm
secti... | Mathlib/GroupTheory/Perm/Cycle/Concrete.lean | 225 | 225 | theorem toList_eq_nil_iff {p : Perm Ξ±} {x} : toList p x = [] β x β p.support := by | simp [toList]
| [
" toList 1 x = []",
" p.toList x = [] β x β p.support"
] | [
" toList 1 x = []"
] |
import Mathlib.Algebra.DirectSum.Internal
import Mathlib.Algebra.GradedMonoid
import Mathlib.Algebra.MvPolynomial.CommRing
import Mathlib.Algebra.MvPolynomial.Equiv
import Mathlib.Algebra.MvPolynomial.Variables
import Mathlib.RingTheory.MvPolynomial.WeightedHomogeneous
import Mathlib.Algebra.Polynomial.Roots
#align_i... | Mathlib/RingTheory/MvPolynomial/Homogeneous.lean | 150 | 153 | theorem isHomogeneous_X (i : Ο) : IsHomogeneous (X i : MvPolynomial Ο R) 1 := by |
apply isHomogeneous_monomial
rw [degree, Finsupp.support_single_ne_zero _ one_ne_zero, Finset.sum_singleton]
exact Finsupp.single_eq_same
| [
" (weightedDegree 1) d = degree d",
" weightedTotalDegree 1 Ο = Ο.totalDegree",
" (weightedDegree 1) c = n",
" coeff c a β 0 β¨ coeff c b β 0",
" coeff c a + coeff c b = 0",
" coeff c a β 0",
" False",
" r β’ coeff c a = 0",
" r β’ 0 = 0",
" homogeneousSubmodule Ο R n = Finsupp.supported R R {d | deg... | [
" (weightedDegree 1) d = degree d",
" weightedTotalDegree 1 Ο = Ο.totalDegree",
" (weightedDegree 1) c = n",
" coeff c a β 0 β¨ coeff c b β 0",
" coeff c a + coeff c b = 0",
" coeff c a β 0",
" False",
" r β’ coeff c a = 0",
" r β’ 0 = 0",
" homogeneousSubmodule Ο R n = Finsupp.supported R R {d | deg... |
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 | 98 | 109 | theorem snorm_add_le' {f g : Ξ± β E} (hf : AEStronglyMeasurable f ΞΌ) (hg : AEStronglyMeasurable g ΞΌ)
(p : ββ₯0β) : snorm (f + g) p ΞΌ β€ LpAddConst p * (snorm f p ΞΌ + snorm g p ΞΌ) := by |
rcases eq_or_ne p 0 with (rfl | hp)
Β· simp only [snorm_exponent_zero, add_zero, mul_zero, le_zero_iff]
rcases lt_or_le p 1 with (h'p | h'p)
Β· simp only [snorm_eq_snorm' hp (h'p.trans ENNReal.one_lt_top).ne]
convert snorm'_add_le_of_le_one hf ENNReal.toReal_nonneg _
Β· have : p β Set.Ioo (0 : ββ₯0β) 1 := ... | [
" (β«β» (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",
" snormEssSup (f + g) ΞΌ β€ snormEssSup f ΞΌ + snormEssSup g ΞΌ",
" (fun x => ββ(f + g) xββ) x β€ ((fun x => ββf xββ) + fun ... |
import Mathlib.Data.Vector.Basic
import Mathlib.Data.Vector.Snoc
set_option autoImplicit true
namespace Vector
section Fold
section Binary
variable (xs : Vector Ξ± n) (ys : Vector Ξ² n)
@[simp]
theorem mapAccumrβ_mapAccumr_left (fβ : Ξ³ β Ξ² β Οβ β Οβ Γ ΞΆ) (fβ : Ξ± β Οβ β Οβ Γ Ξ³) :
(mapAccumrβ fβ (mapAccumr fβ... | Mathlib/Data/Vector/MapLemmas.lean | 71 | 73 | theorem mapβ_map_left (fβ : Ξ³ β Ξ² β ΞΆ) (fβ : Ξ± β Ξ³) :
mapβ fβ (map fβ xs) ys = mapβ (fun x y => fβ (fβ x) y) xs ys := by |
induction xs, ys using Vector.revInductionOnβ <;> simp_all
| [
" mapAccumrβ fβ (mapAccumr fβ xs sβ).2 ys sβ =\n let m :=\n mapAccumrβ\n (fun x y s =>\n let rβ := fβ x s.2;\n let rβ := fβ rβ.2 y s.1;\n ((rβ.1, rβ.1), rβ.2))\n xs ys (sβ, sβ);\n (m.1.1, m.2)",
" mapAccumrβ fβ (mapAccumr fβ nil sβ).2 nil sβ =\n let m :=\n ... | [
" mapAccumrβ fβ (mapAccumr fβ xs sβ).2 ys sβ =\n let m :=\n mapAccumrβ\n (fun x y s =>\n let rβ := fβ x s.2;\n let rβ := fβ rβ.2 y s.1;\n ((rβ.1, rβ.1), rβ.2))\n xs ys (sβ, sβ);\n (m.1.1, m.2)",
" mapAccumrβ fβ (mapAccumr fβ nil sβ).2 nil sβ =\n let m :=\n ... |
import Mathlib.Data.ZMod.Basic
import Mathlib.Algebra.Group.Nat
import Mathlib.Tactic.IntervalCases
import Mathlib.GroupTheory.SpecificGroups.Dihedral
import Mathlib.GroupTheory.SpecificGroups.Cyclic
#align_import group_theory.specific_groups.quaternion from "leanprover-community/mathlib"@"879155bff5af618b9062cbb2915... | Mathlib/GroupTheory/SpecificGroups/Quaternion.lean | 189 | 192 | theorem a_one_pow_n : (a 1 : QuaternionGroup n) ^ (2 * n) = 1 := by |
rw [a_one_pow, one_def]
congr 1
exact ZMod.natCast_self _
| [
" β (a b c : QuaternionGroup n), a * b * c = a * (b * c)",
" a i * a j * a k = a i * (a j * a k)",
" a i * a j * xa k = a i * (a j * xa k)",
" a i * xa j * a k = a i * (xa j * a k)",
" a i * xa j * xa k = a i * (xa j * xa k)",
" xa i * a j * a k = xa i * (a j * a k)",
" xa i * a j * xa k = xa i * (a j *... | [
" β (a b c : QuaternionGroup n), a * b * c = a * (b * c)",
" a i * a j * a k = a i * (a j * a k)",
" a i * a j * xa k = a i * (a j * xa k)",
" a i * xa j * a k = a i * (xa j * a k)",
" a i * xa j * xa k = a i * (xa j * xa k)",
" xa i * a j * a k = xa i * (a j * a k)",
" xa i * a j * xa k = xa i * (a j *... |
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 | 45 | 49 | theorem contMDiffOn_model_symm : ContMDiffOn π(π, E) I n I.symm (range I) := by |
rw [contMDiffOn_iff]
refine β¨I.continuousOn_symm, fun x y => ?_β©
simp only [mfld_simps]
exact contDiffOn_id.congr fun x' => I.right_inv
| [
" 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.LinearAlgebra.Basis.VectorSpace
import Mathlib.LinearAlgebra.Dimension.Finite
import Mathlib.SetTheory.Cardinal.Subfield
import Mathlib.LinearAlgebra.Dimension.RankNullity
#align_import linear_algebra.dimension from "leanprover-community/mathlib"@"47a5f8186becdbc826190ced4312f8199f9db6a5"
noncomput... | Mathlib/LinearAlgebra/Dimension/DivisionRing.lean | 171 | 193 | theorem linearIndependent_iff_card_eq_finrank_span {ΞΉ : Type*} [Fintype ΞΉ] {b : ΞΉ β V} :
LinearIndependent K b β Fintype.card ΞΉ = (Set.range b).finrank K := by |
constructor
Β· intro h
exact (finrank_span_eq_card h).symm
Β· intro hc
let f := Submodule.subtype (span K (Set.range b))
let b' : ΞΉ β span K (Set.range b) := fun i =>
β¨b i, mem_span.2 fun p hp => hp (Set.mem_range_self _)β©
have hs : β€ β€ span K (Set.range b') := by
intro x
have h :... | [
" g i = 0",
" False",
" (b '' (Set.univ \\ {i})).toFinset.card < finrank K V",
" (b '' (Set.univ \\ {i})).toFinset.card = (Finset.image b (Set.univ \\ {i}).toFinset).card",
" β (a : ΞΉ), a β (Set.univ \\ {i}).toFinset β a β Finset.univ.erase i",
" β€ β€ span K (b '' (Set.univ \\ {i}))",
" range b β β(span ... | [
" g i = 0",
" False",
" (b '' (Set.univ \\ {i})).toFinset.card < finrank K V",
" (b '' (Set.univ \\ {i})).toFinset.card = (Finset.image b (Set.univ \\ {i}).toFinset).card",
" β (a : ΞΉ), a β (Set.univ \\ {i}).toFinset β a β Finset.univ.erase i",
" β€ β€ span K (b '' (Set.univ \\ {i}))",
" range b β β(span ... |
import Mathlib.Order.Interval.Finset.Nat
#align_import data.fin.interval from "leanprover-community/mathlib"@"1d29de43a5ba4662dd33b5cfeecfc2a27a5a8a29"
assert_not_exists MonoidWithZero
open Finset Fin Function
namespace Fin
variable (n : β)
instance instLocallyFiniteOrder : LocallyFiniteOrder (Fin n) :=
Orde... | Mathlib/Order/Interval/Finset/Fin.lean | 136 | 137 | theorem card_fintypeIco : Fintype.card (Set.Ico a b) = b - a := by |
rw [β card_Ico, Fintype.card_ofFinset]
| [
" map valEmbedding (Icc a b) = Icc βa βb",
" map valEmbedding (Ico a b) = Ico βa βb",
" map valEmbedding (Ioc a b) = Ioc βa βb",
" map valEmbedding (Ioo a b) = Ioo βa βb",
" (Icc a b).card = βb + 1 - βa",
" (Ico a b).card = βb - βa",
" (Ioc a b).card = βb - βa",
" (Ioo a b).card = βb - βa - 1",
" (u... | [
" map valEmbedding (Icc a b) = Icc βa βb",
" map valEmbedding (Ico a b) = Ico βa βb",
" map valEmbedding (Ioc a b) = Ioc βa βb",
" map valEmbedding (Ioo a b) = Ioo βa βb",
" (Icc a b).card = βb + 1 - βa",
" (Ico a b).card = βb - βa",
" (Ioc a b).card = βb - βa",
" (Ioo a b).card = βb - βa - 1",
" (u... |
import Mathlib.Algebra.Group.Commute.Basic
import Mathlib.Data.Fintype.Card
import Mathlib.GroupTheory.Perm.Basic
#align_import group_theory.perm.support from "leanprover-community/mathlib"@"9003f28797c0664a49e4179487267c494477d853"
open Equiv Finset
namespace Equiv.Perm
variable {Ξ± : Type*}
section Disjoint
... | Mathlib/GroupTheory/Perm/Support.lean | 104 | 106 | theorem disjoint_inv_left_iff : Disjoint fβ»ΒΉ g β Disjoint f g := by |
refine β¨fun h => ?_, Disjoint.inv_leftβ©
convert h.inv_left
| [
" f.Disjoint g β g.Disjoint f",
" (f * g) x = (g * f) x",
" f.Disjoint f β f = 1",
" f = 1",
" f x = 1 x",
" fβ»ΒΉ.Disjoint g",
" fβ»ΒΉ x = x β¨ g x = x",
" f x = x β¨ g x = x",
" fβ»ΒΉ.Disjoint g β f.Disjoint g",
" f.Disjoint g"
] | [
" f.Disjoint g β g.Disjoint f",
" (f * g) x = (g * f) x",
" f.Disjoint f β f = 1",
" f = 1",
" f x = 1 x",
" fβ»ΒΉ.Disjoint g",
" fβ»ΒΉ x = x β¨ g x = x",
" f x = x β¨ g x = x"
] |
import Mathlib.Data.ENNReal.Inv
#align_import data.real.ennreal from "leanprover-community/mathlib"@"c14c8fcde993801fca8946b0d80131a1a81d1520"
open Set NNReal ENNReal
namespace ENNReal
section iInf
variable {ΞΉ : Sort*} {f g : ΞΉ β ββ₯0β}
variable {a b c d : ββ₯0β} {r p q : ββ₯0}
theorem toNNReal_iInf (hf : β i, f ... | Mathlib/Data/ENNReal/Real.lean | 576 | 578 | theorem toReal_sInf (s : Set ββ₯0β) (hf : β r β s, r β β) :
(sInf s).toReal = sInf (ENNReal.toReal '' s) := by |
simp only [ENNReal.toReal, toNNReal_sInf s hf, NNReal.coe_sInf, Set.image_image]
| [
" (iInf f).toNNReal = β¨
i, (f i).toNNReal",
" (β¨
i, β(f i)).toNNReal = β¨
i, ((fun i => β(f i)) i).toNNReal",
" (sInf s).toNNReal = sInf (ENNReal.toNNReal '' s)",
" (iSup f).toNNReal = β¨ i, (f i).toNNReal",
" (β¨ i, β(f i)).toNNReal = β¨ i, ((fun i => β(f i)) i).toNNReal",
" (β¨ i, β(f i)).toNNReal = β¨ i, f i... | [
" (iInf f).toNNReal = β¨
i, (f i).toNNReal",
" (β¨
i, β(f i)).toNNReal = β¨
i, ((fun i => β(f i)) i).toNNReal",
" (sInf s).toNNReal = sInf (ENNReal.toNNReal '' s)",
" (iSup f).toNNReal = β¨ i, (f i).toNNReal",
" (β¨ i, β(f i)).toNNReal = β¨ i, ((fun i => β(f i)) i).toNNReal",
" (β¨ i, β(f i)).toNNReal = β¨ i, f i... |
import Mathlib.NumberTheory.Zsqrtd.GaussianInt
import Mathlib.NumberTheory.LegendreSymbol.Basic
import Mathlib.Analysis.Normed.Field.Basic
#align_import number_theory.zsqrtd.quadratic_reciprocity from "leanprover-community/mathlib"@"5b2fe80501ff327b9109fb09b7cc8c325cd0d7d9"
open Zsqrtd Complex
open scoped Comple... | Mathlib/NumberTheory/Zsqrtd/QuadraticReciprocity.lean | 86 | 93 | theorem prime_of_nat_prime_of_mod_four_eq_three (p : β) [hp : Fact p.Prime] (hp3 : p % 4 = 3) :
Prime (p : β€[i]) :=
irreducible_iff_prime.1 <|
by_contradiction fun hpi =>
let β¨a, b, habβ© := sq_add_sq_of_nat_prime_of_not_irreducible p hpi
have : β a b : ZMod 4, a ^ 2 + b ^ 2 β (p : ZMod 4) := by |
erw [β ZMod.natCast_mod p 4, hp3]; decide
this a b (hab βΈ by simp)
| [
" False",
" Β¬({ re := 1, im := 1 }.norm.natAbs = 1 β¨ { re := 1, im := -1 }.norm.natAbs = 1)",
" p % 4 = 1",
" 0 < 4",
" p % 4 % 2 = 1 β p % 4 β 3 β p % 4 < 4 β p % 4 = 1",
" m % 2 = 1 β m β 3 β m < 4 β m = 1",
" m = 1",
" 0 = 1",
" 1 = 1",
" 2 = 1",
" 3 = 1",
" p % 4 β 3",
" 1 β 3",
" β k'... | [
" False",
" Β¬({ re := 1, im := 1 }.norm.natAbs = 1 β¨ { re := 1, im := -1 }.norm.natAbs = 1)",
" p % 4 = 1",
" 0 < 4",
" p % 4 % 2 = 1 β p % 4 β 3 β p % 4 < 4 β p % 4 = 1",
" m % 2 = 1 β m β 3 β m < 4 β m = 1",
" m = 1",
" 0 = 1",
" 1 = 1",
" 2 = 1",
" 3 = 1",
" p % 4 β 3",
" 1 β 3",
" β k'... |
import Mathlib.CategoryTheory.ConcreteCategory.Basic
import Mathlib.CategoryTheory.Limits.Preserves.Basic
import Mathlib.CategoryTheory.Limits.TypesFiltered
import Mathlib.CategoryTheory.Limits.Yoneda
import Mathlib.Tactic.ApplyFun
#align_import category_theory.limits.concrete_category from "leanprover-community/math... | Mathlib/CategoryTheory/Limits/ConcreteCategory.lean | 76 | 83 | theorem Concrete.from_union_surjective_of_isColimit {D : Cocone F} (hD : IsColimit D) :
let ff : (Ξ£j : J, F.obj j) β D.pt := fun a => D.ΞΉ.app a.1 a.2
Function.Surjective ff := by |
intro ff x
let E : Cocone (F β forget C) := (forget C).mapCocone D
let hE : IsColimit E := isColimitOfPreserves (forget C) hD
obtain β¨j, y, hyβ© := Types.jointly_surjective_of_isColimit hE x
exact β¨β¨j, yβ©, hyβ©
| [
" let ff := fun a => (D.ΞΉ.app a.fst) a.snd;\n Function.Surjective ff",
" β a, ff a = x"
] | [] |
import Mathlib.Analysis.NormedSpace.BoundedLinearMaps
import Mathlib.Topology.FiberBundle.Basic
#align_import topology.vector_bundle.basic from "leanprover-community/mathlib"@"e473c3198bb41f68560cab68a0529c854b618833"
noncomputable section
open scoped Classical
open Bundle Set
open scoped Topology
variable (R : ... | Mathlib/Topology/VectorBundle/Basic.lean | 157 | 160 | theorem linearMapAt_symmβ (e : Pretrivialization F (Ο F E)) [e.IsLinear R] {b : B}
(hb : b β e.baseSet) (y : F) : e.linearMapAt R b (e.symmβ R b y) = y := by |
rw [e.linearMapAt_def_of_mem hb]
exact (e.linearEquivAt R b hb).right_inv y
| [
" F ββ[R] E b",
" IsLinearMap R (e.symm b)",
" IsLinearMap R 0",
" { toFun := fun y => (βe { proj := b, snd := y }).2, map_add' := β―, map_smul' := β― }.toFun (e.symm b v) = v",
" β(Pretrivialization.linearMapAt R e b) = fun y => if b β e.baseSet then (βe { proj := b, snd := y }).2 else 0",
" β(if hb : b β ... | [
" F ββ[R] E b",
" IsLinearMap R (e.symm b)",
" IsLinearMap R 0",
" { toFun := fun y => (βe { proj := b, snd := y }).2, map_add' := β―, map_smul' := β― }.toFun (e.symm b v) = v",
" β(Pretrivialization.linearMapAt R e b) = fun y => if b β e.baseSet then (βe { proj := b, snd := y }).2 else 0",
" β(if hb : b β ... |
import Mathlib.Analysis.Calculus.BumpFunction.Basic
import Mathlib.MeasureTheory.Integral.SetIntegral
import Mathlib.MeasureTheory.Measure.Lebesgue.EqHaar
#align_import analysis.calculus.bump_function_inner from "leanprover-community/mathlib"@"3bce8d800a6f2b8f63fe1e588fd76a9ff4adcebe"
noncomputable section
open F... | Mathlib/Analysis/Calculus/BumpFunction/Normed.lean | 111 | 115 | theorem measure_closedBall_le_integral : (ΞΌ (closedBall c f.rIn)).toReal β€ β« x, f x βΞΌ := by | calc
(ΞΌ (closedBall c f.rIn)).toReal = β« x in closedBall c f.rIn, 1 βΞΌ := by simp
_ = β« x in closedBall c f.rIn, f x βΞΌ := setIntegral_congr measurableSet_closedBall
(fun x hx β¦ (one_of_mem_closedBall f hx).symm)
_ β€ β« x, f x βΞΌ := setIntegral_le_integral f.integrable (eventually_of_forall (fun x β¦ f.non... | [
" f.normed ΞΌ (c - x) = f.normed ΞΌ (c + x)",
" f.normed ΞΌ (-x) = f.normed ΞΌ x",
" 0 < β« (x : E), βf x βΞΌ",
" 0 < ΞΌ (support fun i => βf i)",
" 0 < ΞΌ (ball c f.rOut)",
" β« (x : E), f.normed ΞΌ x βΞΌ = 1",
" (β« (x : E), βf x βΞΌ)β»ΒΉ β’ β« (x : E), βf x βΞΌ = 1",
" support (f.normed ΞΌ) = ball c f.rOut",
" (sup... | [
" f.normed ΞΌ (c - x) = f.normed ΞΌ (c + x)",
" f.normed ΞΌ (-x) = f.normed ΞΌ x",
" 0 < β« (x : E), βf x βΞΌ",
" 0 < ΞΌ (support fun i => βf i)",
" 0 < ΞΌ (ball c f.rOut)",
" β« (x : E), f.normed ΞΌ x βΞΌ = 1",
" (β« (x : E), βf x βΞΌ)β»ΒΉ β’ β« (x : E), βf x βΞΌ = 1",
" support (f.normed ΞΌ) = ball c f.rOut",
" (sup... |
import Mathlib.Analysis.SpecialFunctions.Gamma.Basic
import Mathlib.Analysis.SpecialFunctions.PolarCoord
import Mathlib.Analysis.Convex.Complex
#align_import analysis.special_functions.gaussian from "leanprover-community/mathlib"@"7982767093ae38cba236487f9c9dd9cd99f63c16"
noncomputable section
open Real Set Measu... | Mathlib/Analysis/SpecialFunctions/Gaussian/GaussianIntegral.lean | 31 | 43 | theorem exp_neg_mul_rpow_isLittleO_exp_neg {p b : β} (hb : 0 < b) (hp : 1 < p) :
(fun x : β => exp (- b * x ^ p)) =o[atTop] fun x : β => exp (-x) := by |
rw [isLittleO_exp_comp_exp_comp]
suffices Tendsto (fun x => x * (b * x ^ (p - 1) + -1)) atTop atTop by
refine Tendsto.congr' ?_ this
refine eventuallyEq_of_mem (Ioi_mem_atTop (0 : β)) (fun x hx => ?_)
rw [mem_Ioi] at hx
rw [rpow_sub_one hx.ne']
field_simp [hx.ne']
ring
apply Tendsto.atTop... | [
" (fun x => rexp (-b * x ^ p)) =o[atTop] fun x => rexp (-x)",
" Tendsto (fun x => -x - -b * x ^ p) atTop atTop",
" (fun x => x * (b * x ^ (p - 1) + -1)) =αΆ [atTop] fun x => -x - -b * x ^ p",
" x * (b * x ^ (p - 1) + -1) = -x - -b * x ^ p",
" x * (b * (x ^ p / x) + -1) = -x - -b * x ^ p",
" b * x ^ p + -x =... | [] |
import Mathlib.Analysis.InnerProductSpace.GramSchmidtOrtho
import Mathlib.LinearAlgebra.Orientation
#align_import analysis.inner_product_space.orientation from "leanprover-community/mathlib"@"bd65478311e4dfd41f48bf38c7e3b02fb75d0163"
noncomputable section
variable {E : Type*} [NormedAddCommGroup E] [InnerProduct... | Mathlib/Analysis/InnerProductSpace/Orientation.lean | 54 | 60 | theorem det_to_matrix_orthonormalBasis_of_same_orientation
(h : e.toBasis.orientation = f.toBasis.orientation) : e.toBasis.det f = 1 := by |
apply (e.det_to_matrix_orthonormalBasis_real f).resolve_right
have : 0 < e.toBasis.det f := by
rw [e.toBasis.orientation_eq_iff_det_pos] at h
simpa using h
linarith
| [
" e.toBasis.det βf = 1",
" Β¬e.toBasis.det βf = -1",
" 0 < e.toBasis.det βf"
] | [] |
import Mathlib.Algebra.MvPolynomial.Basic
#align_import data.mv_polynomial.rename from "leanprover-community/mathlib"@"2f5b500a507264de86d666a5f87ddb976e2d8de4"
noncomputable section
open Set Function Finsupp AddMonoidAlgebra
variable {Ο Ο Ξ± R S : Type*} [CommSemiring R] [CommSemiring S]
namespace MvPolynomial... | Mathlib/Algebra/MvPolynomial/Rename.lean | 67 | 72 | theorem map_rename (f : R β+* S) (g : Ο β Ο) (p : MvPolynomial Ο R) :
map f (rename g p) = rename g (map f p) := by |
apply MvPolynomial.induction_on p
(fun a => by simp only [map_C, rename_C])
(fun p q hp hq => by simp only [hp, hq, AlgHom.map_add, RingHom.map_add]) fun p n hp => by
simp only [hp, rename_X, map_X, RingHom.map_mul, AlgHom.map_mul]
| [
" (map f) ((rename g) p) = (rename g) ((map f) p)",
" (map f) ((rename g) (C a)) = (rename g) ((map f) (C a))",
" (map f) ((rename g) (p + q)) = (rename g) ((map f) (p + q))",
" (map f) ((rename g) (p * X n)) = (rename g) ((map f) (p * X n))"
] | [] |
import Mathlib.Analysis.InnerProductSpace.Spectrum
import Mathlib.Data.Matrix.Rank
import Mathlib.LinearAlgebra.Matrix.Diagonal
import Mathlib.LinearAlgebra.Matrix.Hermitian
#align_import linear_algebra.matrix.spectrum from "leanprover-community/mathlib"@"46b633fd842bef9469441c0209906f6dddd2b4f5"
namespace Matrix
... | Mathlib/LinearAlgebra/Matrix/Spectrum.lean | 114 | 119 | theorem eigenvalues_eq (i : n) :
(hA.eigenvalues i) = RCLike.re (Matrix.dotProduct (star β(hA.eigenvectorBasis i))
(A *α΅₯ β(hA.eigenvectorBasis i))):= by |
simp only [mulVec_eigenvectorBasis, dotProduct_smul,β EuclideanSpace.inner_eq_star_dotProduct,
inner_self_eq_norm_sq_to_K, RCLike.smul_re, hA.eigenvectorBasis.orthonormal.1 i,
mul_one, algebraMap.coe_one, one_pow, RCLike.one_re]
| [
" A *α΅₯ (WithLp.equiv 2 ((i : n) β (fun x => π) i)) (hA.eigenvectorBasis j) =\n hA.eigenvalues j β’ (WithLp.equiv 2 ((i : n) β (fun x => π) i)) (hA.eigenvectorBasis j)",
" βhA.eigenvectorUnitary *α΅₯ Pi.single j 1 = (WithLp.equiv 2 ((i : n) β (fun x => π) i)) (hA.eigenvectorBasis j)",
" star βhA.eigenvectorUn... | [
" A *α΅₯ (WithLp.equiv 2 ((i : n) β (fun x => π) i)) (hA.eigenvectorBasis j) =\n hA.eigenvalues j β’ (WithLp.equiv 2 ((i : n) β (fun x => π) i)) (hA.eigenvectorBasis j)",
" βhA.eigenvectorUnitary *α΅₯ Pi.single j 1 = (WithLp.equiv 2 ((i : n) β (fun x => π) i)) (hA.eigenvectorBasis j)",
" star βhA.eigenvectorUn... |
import Mathlib.Init.Data.Nat.Notation
import Mathlib.Init.Order.Defs
set_option autoImplicit true
structure UFModel (n) where
parent : Fin n β Fin n
rank : Nat β Nat
rank_lt : β i, (parent i).1 β i β rank i < rank (parent i)
structure UFNode (Ξ± : Type*) where
parent : Nat
value : Ξ±
rank : Nat
inductive... | Mathlib/Data/UnionFind.lean | 79 | 80 | theorem size_eq {arr : Array Ξ±} {m : Fin n β Ξ²} (H : Agrees arr f m) : n = arr.size := by |
cases H; rfl
| [
" Agrees arr f g",
" (fun i => f (arr.get i)) = g",
" f (arr.get β¨i, hβ©) = g β¨i, hβ©",
" Agrees arr f fun i => f (arr.get i)",
" n = arr.size",
" arr.size = arr.size"
] | [
" Agrees arr f g",
" (fun i => f (arr.get i)) = g",
" f (arr.get β¨i, hβ©) = g β¨i, hβ©",
" Agrees arr f fun i => f (arr.get i)"
] |
import Mathlib.Combinatorics.Quiver.Path
import Mathlib.Combinatorics.Quiver.Push
#align_import combinatorics.quiver.symmetric from "leanprover-community/mathlib"@"706d88f2b8fdfeb0b22796433d7a6c1a010af9f2"
universe v u w v'
namespace Quiver
-- Porting note: no hasNonemptyInstance linter yet
def Symmetrify (V : ... | Mathlib/Combinatorics/Quiver/Symmetric.lean | 208 | 219 | theorem lift_unique [HasReverse V'] (Ο : V β₯€q V') (Ξ¦ : Symmetrify V β₯€q V') (hΞ¦ : (of βq Ξ¦) = Ο)
(hΞ¦inv : β {X Y : Symmetrify V} (f : X βΆ Y),
Ξ¦.map (Quiver.reverse f) = Quiver.reverse (Ξ¦.map f)) :
Ξ¦ = Symmetrify.lift Ο := by |
subst_vars
fapply Prefunctor.ext
Β· rintro X
rfl
Β· rintro X Y f
cases f
Β· rfl
· exact hΦinv (Sum.inl _)
| [
" reverse (reverse f) = f",
" reverse f = reverse g β f = g",
" reverse f = reverse g β f = g",
" f = g",
" f = g β reverse f = reverse g",
" reverse f = reverse g",
" f = reverse g β reverse f = g",
" of βq lift Ο = Ο",
" β (X : V), (of βq lift Ο).obj X = Ο.obj X",
" (of βq lift Ο).obj X = Ο.obj ... | [
" reverse (reverse f) = f",
" reverse f = reverse g β f = g",
" reverse f = reverse g β f = g",
" f = g",
" f = g β reverse f = reverse g",
" reverse f = reverse g",
" f = reverse g β reverse f = g",
" of βq lift Ο = Ο",
" β (X : V), (of βq lift Ο).obj X = Ο.obj X",
" (of βq lift Ο).obj X = Ο.obj ... |
import Mathlib.Topology.UniformSpace.CompleteSeparated
import Mathlib.Topology.EMetricSpace.Lipschitz
import Mathlib.Topology.MetricSpace.Basic
import Mathlib.Topology.MetricSpace.Bounded
#align_import topology.metric_space.antilipschitz from "leanprover-community/mathlib"@"c8f305514e0d47dfaa710f5a52f0d21b588e6328"
... | Mathlib/Topology/MetricSpace/Antilipschitz.lean | 53 | 56 | theorem antilipschitzWith_iff_le_mul_nndist :
AntilipschitzWith K f β β x y, nndist x y β€ K * nndist (f x) (f y) := by |
simp only [AntilipschitzWith, edist_nndist]
norm_cast
| [
" AntilipschitzWith K f β β (x y : Ξ±), nndist x y β€ K * nndist (f x) (f y)",
" (β (x y : Ξ±), β(nndist x y) β€ βK * β(nndist (f x) (f y))) β β (x y : Ξ±), nndist x y β€ K * nndist (f x) (f y)"
] | [] |
import Mathlib.Data.Matrix.Invertible
import Mathlib.LinearAlgebra.Matrix.NonsingularInverse
import Mathlib.LinearAlgebra.Matrix.PosDef
#align_import linear_algebra.matrix.schur_complement from "leanprover-community/mathlib"@"a176cb1219e300e85793d44583dede42377b51af"
variable {l m n Ξ± : Type*}
namespace Matrix
... | Mathlib/LinearAlgebra/Matrix/SchurComplement.lean | 434 | 435 | theorem det_mul_add_one_comm (A : Matrix m n Ξ±) (B : Matrix n m Ξ±) :
det (A * B + 1) = det (B * A + 1) := by | rw [add_comm, det_one_add_mul_comm, add_comm]
| [
" A.fromBlocks B C D = fromBlocks 1 0 (C * β
A) 1 * A.fromBlocks 0 0 (D - C * β
A * B) * fromBlocks 1 (β
A * B) 0 1",
" (reindex (Equiv.sumComm l n) (Equiv.sumComm m n)) (A.fromBlocks B C D) =\n (reindex (Equiv.sumComm l n) (Equiv.sumComm m n))\n (fromBlocks 1 (B * β
D) 0 1 * (A - B * β
D * C).fromBlocks 0 0 D... | [
" A.fromBlocks B C D = fromBlocks 1 0 (C * β
A) 1 * A.fromBlocks 0 0 (D - C * β
A * B) * fromBlocks 1 (β
A * B) 0 1",
" (reindex (Equiv.sumComm l n) (Equiv.sumComm m n)) (A.fromBlocks B C D) =\n (reindex (Equiv.sumComm l n) (Equiv.sumComm m n))\n (fromBlocks 1 (B * β
D) 0 1 * (A - B * β
D * C).fromBlocks 0 0 D... |
import Mathlib.Dynamics.Ergodic.MeasurePreserving
import Mathlib.LinearAlgebra.Determinant
import Mathlib.LinearAlgebra.Matrix.Diagonal
import Mathlib.LinearAlgebra.Matrix.Transvection
import Mathlib.MeasureTheory.Group.LIntegral
import Mathlib.MeasureTheory.Integral.Marginal
import Mathlib.MeasureTheory.Measure.Stiel... | Mathlib/MeasureTheory/Measure/Lebesgue/Basic.lean | 100 | 104 | theorem volume_univ : volume (univ : Set β) = β :=
ENNReal.eq_top_of_forall_nnreal_le fun r =>
calc
(r : ββ₯0β) = volume (Icc (0 : β) r) := by | simp
_ β€ volume univ := measure_mono (subset_univ _)
| [
" volume = StieltjesFunction.id.measure",
" StieltjesFunction.id.measure (Ioo βp βq) = (Measure.map (fun x => a + x) StieltjesFunction.id.measure) (Ioo βp βq)",
" StieltjesFunction.id.measure β(stdOrthonormalBasis β β).toBasis.parallelepiped = 1",
" StieltjesFunction.id.measure (parallelepiped β(stdOrthonorma... | [
" volume = StieltjesFunction.id.measure",
" StieltjesFunction.id.measure (Ioo βp βq) = (Measure.map (fun x => a + x) StieltjesFunction.id.measure) (Ioo βp βq)",
" StieltjesFunction.id.measure β(stdOrthonormalBasis β β).toBasis.parallelepiped = 1",
" StieltjesFunction.id.measure (parallelepiped β(stdOrthonorma... |
import Mathlib.Computability.DFA
import Mathlib.Data.Fintype.Powerset
#align_import computability.NFA from "leanprover-community/mathlib"@"32253a1a1071173b33dc7d6a218cf722c6feb514"
open Set
open Computability
universe u v
-- Porting note: Required as `NFA` is used in mathlib3
set_option linter.uppercaseLean3 fa... | Mathlib/Computability/NFA.lean | 108 | 109 | theorem mem_accepts {x : List Ξ±} : x β M.accepts β β S β M.accept, S β M.evalFrom M.start x := by |
rfl
| [
" s β M.stepSet S a β β t β S, s β M.step t a",
" M.stepSet β
a = β
",
" M.evalFrom S (x ++ [a]) = M.stepSet (M.evalFrom S x) a",
" x β M.accepts β β S β M.accept, S β M.evalFrom M.start x"
] | [
" s β M.stepSet S a β β t β S, s β M.step t a",
" M.stepSet β
a = β
",
" M.evalFrom S (x ++ [a]) = M.stepSet (M.evalFrom S x) a"
] |
import Mathlib.RingTheory.JacobsonIdeal
#align_import ring_theory.nakayama from "leanprover-community/mathlib"@"f0c8bf9245297a541f468be517f1bde6195105e9"
variable {R M : Type*} [CommRing R] [AddCommGroup M] [Module R M]
open Ideal
namespace Submodule
theorem eq_smul_of_le_smul_of_le_jacobson {I J : Ideal R} {... | Mathlib/RingTheory/Nakayama.lean | 114 | 126 | theorem sup_eq_sup_smul_of_le_smul_of_le_jacobson {I J : Ideal R} {N N' : Submodule R M}
(hN' : N'.FG) (hIJ : I β€ jacobson J) (hNN : N' β€ N β I β’ N') : N β N' = N β J β’ N' := by |
have hNN' : N β N' = N β I β’ N' :=
le_antisymm (sup_le le_sup_left hNN)
(sup_le_sup_left (Submodule.smul_le.2 fun _ _ _ => Submodule.smul_mem _ _) _)
have h_comap := Submodule.comap_injective_of_surjective (LinearMap.range_eq_top.1 N.range_mkQ)
have : (I β’ N').map N.mkQ = N'.map N.mkQ := by
simpa onl... | [
" N = J β’ N",
" N β€ J β’ N",
" n β J β’ N",
" n = -(s * r - 1) β’ n",
" -(s * r - 1) β’ n β J β’ N",
" N = β₯",
" N β N' = N β J β’ N'",
" map N.mkQ (I β’ N') = map N.mkQ N'",
" map N.mkQ N' β€ I β’ map N.mkQ N'"
] | [
" N = J β’ N",
" N β€ J β’ N",
" n β J β’ N",
" n = -(s * r - 1) β’ n",
" -(s * r - 1) β’ n β J β’ N",
" N = β₯"
] |
import Mathlib.Combinatorics.SimpleGraph.Connectivity
import Mathlib.Data.Nat.Lattice
#align_import combinatorics.simple_graph.metric from "leanprover-community/mathlib"@"352ecfe114946c903338006dd3287cb5a9955ff2"
namespace SimpleGraph
variable {V : Type*} (G : SimpleGraph V)
noncomputable def dist (u v : V)... | Mathlib/Combinatorics/SimpleGraph/Metric.lean | 118 | 122 | theorem dist_comm {u v : V} : G.dist u v = G.dist v u := by |
by_cases h : G.Reachable u v
Β· apply le_antisymm (dist_comm_aux h) (dist_comm_aux h.symm)
Β· have h' : Β¬G.Reachable v u := fun h' => absurd h'.symm h
simp [h, h', dist_eq_zero_of_not_reachable]
| [
" G.dist u v = 0 β u = v β¨ Β¬G.Reachable u v",
" G.dist v v = 0",
" G.dist u v = 0 β u = v",
" G.dist u v β 0",
" False",
" G.dist u v = 0",
" Set.univ.Nonempty",
" G.dist u w β€ G.dist u v + G.dist v w",
" G.dist u w β€ (p.append q).length",
" G.dist u v β€ G.dist v u",
" G.dist u v β€ p.reverse.len... | [
" G.dist u v = 0 β u = v β¨ Β¬G.Reachable u v",
" G.dist v v = 0",
" G.dist u v = 0 β u = v",
" G.dist u v β 0",
" False",
" G.dist u v = 0",
" Set.univ.Nonempty",
" G.dist u w β€ G.dist u v + G.dist v w",
" G.dist u w β€ (p.append q).length",
" G.dist u v β€ G.dist v u",
" G.dist u v β€ p.reverse.len... |
import Mathlib.Algebra.Order.Ring.Nat
#align_import data.nat.dist from "leanprover-community/mathlib"@"d50b12ae8e2bd910d08a94823976adae9825718b"
namespace Nat
def dist (n m : β) :=
n - m + (m - n)
#align nat.dist Nat.dist
-- Should be aligned to `Nat.dist.eq_def`, but that is generated on demand and isn't pr... | Mathlib/Data/Nat/Dist.lean | 42 | 42 | theorem dist_eq_zero {n m : β} (h : n = m) : dist n m = 0 := by | rw [h, dist_self]
| [
" n.dist m = m.dist n",
" n.dist n = 0",
" n.dist m = 0"
] | [
" n.dist m = m.dist n",
" n.dist n = 0"
] |
import Mathlib.LinearAlgebra.Basis
import Mathlib.LinearAlgebra.Dual
import Mathlib.Data.Fin.FlagRange
open Set Submodule
namespace Basis
section Semiring
variable {R M : Type*} [Semiring R] [AddCommMonoid M] [Module R M] {n : β}
def flag (b : Basis (Fin n) R M) (k : Fin (n + 1)) : Submodule R M :=
.span R <... | Mathlib/LinearAlgebra/Basis/Flag.lean | 32 | 32 | theorem flag_zero (b : Basis (Fin n) R M) : b.flag 0 = β₯ := by | simp [flag]
| [
" b.flag 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 | 119 | 124 | theorem CancelCommMonoid.toCommMonoid_injective {M : Type u} :
Function.Injective (@CancelCommMonoid.toCommMonoid M) := by |
rintro @β¨@β¨@β¨β©β©β© @β¨@β¨@β¨β©β©β© h
congr <;> {
injection h with h'
injection h' }
| [
" 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β",
" Injective (@toMonoid M)",
" mk mul_commβΒΉ = mk mul_comm... |
import Mathlib.Geometry.Manifold.MFDeriv.SpecificFunctions
noncomputable section
open scoped Manifold
open Bundle Set Topology
variable {π : Type*} [NontriviallyNormedField π]
{E : Type*} [NormedAddCommGroup E] [NormedSpace π E] {H : Type*} [TopologicalSpace H]
(I : ModelWithCorners π E H) {M : Type*} [To... | Mathlib/Geometry/Manifold/MFDeriv/Atlas.lean | 89 | 106 | theorem mdifferentiableAt_atlas (h : e β atlas H M) {x : M} (hx : x β e.source) :
MDifferentiableAt I I e x := by |
rw [mdifferentiableAt_iff]
refine β¨(e.continuousOn x hx).continuousAt (e.open_source.mem_nhds hx), ?_β©
have mem :
I ((chartAt H x : M β H) x) β I.symm β»ΒΉ' ((chartAt H x).symm β«β e).source β© range I := by
simp only [hx, mfld_simps]
have : (chartAt H x).symm.trans e β contDiffGroupoid β I :=
HasGroup... | [
" MDifferentiableAt I I (βe) x",
" ContinuousAt (βe) x β§ DifferentiableWithinAt π (writtenInExtChartAt I I x βe) (range βI) (β(extChartAt I x) x)",
" DifferentiableWithinAt π (writtenInExtChartAt I I x βe) (range βI) (β(extChartAt I x) x)",
" βI (β(chartAt H x) x) β βI.symm β»ΒΉ' ((chartAt H x).symm β«β e).sou... | [] |
import Mathlib.LinearAlgebra.Matrix.ToLin
import Mathlib.LinearAlgebra.Quotient
import Mathlib.RingTheory.Ideal.Maps
import Mathlib.RingTheory.Nilpotent.Defs
#align_import ring_theory.nilpotent from "leanprover-community/mathlib"@"da420a8c6dd5bdfb85c4ced85c34388f633bc6ff"
universe u v
open Function Set
variable ... | Mathlib/RingTheory/Nilpotent/Lemmas.lean | 32 | 35 | theorem isRadical_iff_span_singleton [CommSemiring R] :
IsRadical y β (Ideal.span ({y} : Set R)).IsRadical := by |
simp_rw [IsRadical, β Ideal.mem_span_singleton]
exact forall_swap.trans (forall_congr' fun r => exists_imp.symm)
| [
" (ker f).IsRadical β IsReduced S",
" (ker f).IsRadical β β (x : R), (β n, x ^ n β ker f) β x β ker f",
" IsRadical y β (Ideal.span {y}).IsRadical",
" (β (n : β) (x : R), x ^ n β Ideal.span {y} β x β Ideal.span {y}) β (Ideal.span {y}).IsRadical"
] | [
" (ker f).IsRadical β IsReduced S",
" (ker f).IsRadical β β (x : R), (β n, x ^ n β ker f) β x β ker f"
] |
import Mathlib.Analysis.SpecialFunctions.Pow.Complex
import Qq
#align_import analysis.special_functions.pow.real from "leanprover-community/mathlib"@"4fa54b337f7d52805480306db1b1439c741848c8"
noncomputable section
open scoped Classical
open Real ComplexConjugate
open Finset Set
namespace Real
variable {x y z... | Mathlib/Analysis/SpecialFunctions/Pow/Real.lean | 56 | 57 | theorem rpow_def_of_pos {x : β} (hx : 0 < x) (y : β) : x ^ y = exp (log x * y) := by |
rw [rpow_def_of_nonneg (le_of_lt hx), if_neg (ne_of_gt hx)]
| [
" x ^ y = if x = 0 then if y = 0 then 1 else 0 else rexp (x.log * y)",
" (if βx = 0 then if βy = 0 then 1 else 0 else ((βx).log * βy).exp).re =\n if x = 0 then if y = 0 then 1 else 0 else rexp (x.log * y)",
" Complex.re 1 = 1",
" Complex.re 1 = 0",
" Complex.re 1 = rexp (x.log * y)",
" Complex.re 0 = 1... | [
" x ^ y = if x = 0 then if y = 0 then 1 else 0 else rexp (x.log * y)",
" (if βx = 0 then if βy = 0 then 1 else 0 else ((βx).log * βy).exp).re =\n if x = 0 then if y = 0 then 1 else 0 else rexp (x.log * y)",
" Complex.re 1 = 1",
" Complex.re 1 = 0",
" Complex.re 1 = rexp (x.log * y)",
" Complex.re 0 = 1... |
import Mathlib.Analysis.BoxIntegral.Partition.Split
import Mathlib.Analysis.NormedSpace.OperatorNorm.Mul
#align_import analysis.box_integral.partition.additive from "leanprover-community/mathlib"@"70fd9563a21e7b963887c9360bd29b2393e6225a"
noncomputable section
open scoped Classical
open Function Set
namespace B... | Mathlib/Analysis/BoxIntegral/Partition/Additive.lean | 113 | 115 | theorem map_split_add (f : ΞΉ βα΅α΅[Iβ] M) (hI : βI β€ Iβ) (i : ΞΉ) (x : β) :
(I.splitLower i x).elim' 0 f + (I.splitUpper i x).elim' 0 f = f I := by |
rw [β f.sum_partition_boxes hI (isPartitionSplit I i x), sum_split_boxes]
| [
" f = g",
" { toFun := toFunβ, sum_partition_boxes' := sum_partition_boxes'β } = g",
" { toFun := toFunβΒΉ, sum_partition_boxes' := sum_partition_boxes'βΒΉ } =\n { toFun := toFunβ, sum_partition_boxes' := sum_partition_boxes'β }",
" β Ji β Ο.boxes, (βf + βg) Ji = (βf + βg) I",
" β Ji β Ο.boxes, (r β’ βf) Ji... | [
" f = g",
" { toFun := toFunβ, sum_partition_boxes' := sum_partition_boxes'β } = g",
" { toFun := toFunβΒΉ, sum_partition_boxes' := sum_partition_boxes'βΒΉ } =\n { toFun := toFunβ, sum_partition_boxes' := sum_partition_boxes'β }",
" β Ji β Ο.boxes, (βf + βg) Ji = (βf + βg) I",
" β Ji β Ο.boxes, (r β’ βf) Ji... |
import Mathlib.SetTheory.Ordinal.FixedPoint
#align_import set_theory.ordinal.principal from "leanprover-community/mathlib"@"31b269b60935483943542d547a6dd83a66b37dc7"
universe u v w
noncomputable section
open Order
namespace Ordinal
-- Porting note: commented out, doesn't seem necessary
--local infixr:0 "^" => ... | Mathlib/SetTheory/Ordinal/Principal.lean | 77 | 81 | theorem op_eq_self_of_principal {op : Ordinal β Ordinal β Ordinal} {a o : Ordinal.{u}} (hao : a < o)
(H : IsNormal (op a)) (ho : Principal op o) (ho' : IsLimit o) : op a o = o := by |
refine le_antisymm ?_ (H.self_le _)
rw [β IsNormal.bsup_eq.{u, u} H ho', bsup_le_iff]
exact fun b hbo => (ho hao hbo).le
| [
" Principal op o β Principal (Function.swap op) o",
" Principal op o β Principal (Function.swap op) o",
" Principal (Function.swap op) o β Principal op o",
" Principal op 1 β op 0 0 = 0",
" op 0 0 = 0",
" op 0 0 < 1",
" op a b < 1",
" (op a)^[n] a < o",
" (op a)^[0] a < o",
" (op a)^[n + 1] a < o"... | [
" Principal op o β Principal (Function.swap op) o",
" Principal op o β Principal (Function.swap op) o",
" Principal (Function.swap op) o β Principal op o",
" Principal op 1 β op 0 0 = 0",
" op 0 0 = 0",
" op 0 0 < 1",
" op a b < 1",
" (op a)^[n] a < o",
" (op a)^[0] a < o",
" (op a)^[n + 1] a < o"... |
import Mathlib.Data.Matrix.Basis
import Mathlib.LinearAlgebra.Basis
import Mathlib.LinearAlgebra.Pi
#align_import linear_algebra.std_basis from "leanprover-community/mathlib"@"13bce9a6b6c44f6b4c91ac1c1d2a816e2533d395"
open Function Set Submodule
namespace LinearMap
variable (R : Type*) {ΞΉ : Type*} [Semiring R] ... | Mathlib/LinearAlgebra/StdBasis.lean | 55 | 57 | theorem stdBasis_apply' (i i' : ΞΉ) : (stdBasis R (fun _x : ΞΉ => R) i) 1 i' = ite (i = i') 1 0 := by |
rw [LinearMap.stdBasis_apply, Function.update_apply, Pi.zero_apply]
congr 1; rw [eq_iff_iff, eq_comm]
| [
" (stdBasis R (fun _x => R) i) 1 i' = if i = i' then 1 else 0",
" (if i' = i then 1 else 0) = if i = i' then 1 else 0",
" (i' = i) = (i = i')"
] | [] |
import Mathlib.LinearAlgebra.AffineSpace.AffineMap
import Mathlib.Tactic.FieldSimp
#align_import linear_algebra.affine_space.slope from "leanprover-community/mathlib"@"70fd9563a21e7b963887c9360bd29b2393e6225a"
open AffineMap
variable {k E PE : Type*} [Field k] [AddCommGroup E] [Module k E] [AddTorsor E PE]
def ... | Mathlib/LinearAlgebra/AffineSpace/Slope.lean | 102 | 116 | theorem sub_div_sub_smul_slope_add_sub_div_sub_smul_slope (f : k β PE) (a b c : k) :
((b - a) / (c - a)) β’ slope f a b + ((c - b) / (c - a)) β’ slope f b c = slope f a c := by |
by_cases hab : a = b
Β· subst hab
rw [sub_self, zero_div, zero_smul, zero_add]
by_cases hac : a = c
Β· simp [hac]
Β· rw [div_self (sub_ne_zero.2 <| Ne.symm hac), one_smul]
by_cases hbc : b = c;
Β· subst hbc
simp [sub_ne_zero.2 (Ne.symm hab)]
rw [add_comm]
simp_rw [slope, div_eq_inv_mul, mul... | [
" slope f a a = 0",
" (b - a) β’ slope f a b = f b -α΅₯ f a",
" (a - a) β’ slope f a a = f a -α΅₯ f a",
" (b - a) β’ slope f a b +α΅₯ f a = f b",
" (slope fun x => f x +α΅₯ c) = slope f",
" slope (fun x => f x +α΅₯ c) a b = slope f a b",
" slope (fun x => (x - a) β’ f x) a b = f b",
" f a = f b",
" slope (βf β g)... | [
" slope f a a = 0",
" (b - a) β’ slope f a b = f b -α΅₯ f a",
" (a - a) β’ slope f a a = f a -α΅₯ f a",
" (b - a) β’ slope f a b +α΅₯ f a = f b",
" (slope fun x => f x +α΅₯ c) = slope f",
" slope (fun x => f x +α΅₯ c) a b = slope f a b",
" slope (fun x => (x - a) β’ f x) a b = f b",
" f a = f b",
" slope (βf β g)... |
import Mathlib.NumberTheory.LegendreSymbol.QuadraticChar.Basic
#align_import number_theory.legendre_symbol.basic from "leanprover-community/mathlib"@"5b2fe80501ff327b9109fb09b7cc8c325cd0d7d9"
open Nat
section Euler
section Legendre
open ZMod
variable (p : β) [Fact p.Prime]
def legendreSym (a : β€) : β€ :=
... | Mathlib/NumberTheory/LegendreSymbol/Basic.lean | 294 | 296 | theorem legendreSym.at_neg_one (hp : p β 2) : legendreSym p (-1) = Οβ p := by |
simp only [legendreSym, card p, quadraticChar_neg_one ((ringChar_zmod_n p).substr hp),
Int.cast_neg, Int.cast_one]
| [
" legendreSym p (-1) = Οβ βp"
] | [] |
import Mathlib.Algebra.Algebra.Prod
import Mathlib.Algebra.Algebra.Subalgebra.Basic
#align_import algebra.algebra.subalgebra.basic from "leanprover-community/mathlib"@"b915e9392ecb2a861e1e766f0e1df6ac481188ca"
namespace Subalgebra
open Algebra
variable {R A B : Type*} [CommSemiring R] [Semiring A] [Algebra R A]... | Mathlib/Algebra/Algebra/Subalgebra/Prod.lean | 51 | 51 | theorem prod_top : (prod β€ β€ : Subalgebra R (A Γ B)) = β€ := by | ext; simp
| [
" β€.prod β€ = β€",
" xβ β β€.prod β€ β xβ β β€"
] | [] |
import Mathlib.GroupTheory.CoprodI
import Mathlib.GroupTheory.Coprod.Basic
import Mathlib.GroupTheory.QuotientGroup
import Mathlib.GroupTheory.Complement
namespace Monoid
open CoprodI Subgroup Coprod Function List
variable {ΞΉ : Type*} {G : ΞΉ β Type*} {H : Type*} {K : Type*} [Monoid K]
def PushoutI.con [β i, Mo... | Mathlib/GroupTheory/PushoutI.lean | 96 | 97 | theorem of_apply_eq_base (i : ΞΉ) (x : H) : of i (Ο i x) = base Ο x := by |
rw [β MonoidHom.comp_apply, of_comp_eq_base]
| [
" Mul (PushoutI Ο)",
" Mul (con Ο).Quotient",
" One (PushoutI Ο)",
" One (con Ο).Quotient",
" (of i).comp (Ο i) = base Ο",
" ((of i).comp (Ο i)) x = (base Ο) x",
" (con Ο) ((inl.comp CoprodI.of) ((Ο i) x)) (inr x)",
" β i_1 x', (inl.comp CoprodI.of) ((Ο i) x) = inl (CoprodI.of ((Ο i_1) x')) β§ inr x = ... | [
" Mul (PushoutI Ο)",
" Mul (con Ο).Quotient",
" One (PushoutI Ο)",
" One (con Ο).Quotient",
" (of i).comp (Ο i) = base Ο",
" ((of i).comp (Ο i)) x = (base Ο) x",
" (con Ο) ((inl.comp CoprodI.of) ((Ο i) x)) (inr x)",
" β i_1 x', (inl.comp CoprodI.of) ((Ο i) x) = inl (CoprodI.of ((Ο i_1) x')) β§ inr x = ... |
import Mathlib.Data.List.Chain
import Mathlib.Data.List.Enum
import Mathlib.Data.List.Nodup
import Mathlib.Data.List.Pairwise
import Mathlib.Data.List.Zip
#align_import data.list.range from "leanprover-community/mathlib"@"7b78d1776212a91ecc94cf601f83bdcc46b04213"
set_option autoImplicit true
universe u
open Nat... | Mathlib/Data/List/Range.lean | 66 | 67 | theorem nthLe_range'_1 {n m} (i) (H : i < (range' n m).length) :
nthLe (range' n m) i H = n + i := by | simp
| [
" (range' n m).nthLe i H = n + i"
] | [] |
import Mathlib.ModelTheory.Ultraproducts
import Mathlib.ModelTheory.Bundled
import Mathlib.ModelTheory.Skolem
#align_import model_theory.satisfiability from "leanprover-community/mathlib"@"d565b3df44619c1498326936be16f1a935df0728"
set_option linter.uppercaseLean3 false
universe u v w w'
open Cardinal CategoryTh... | Mathlib/ModelTheory/Satisfiability.lean | 212 | 224 | theorem exists_elementaryEmbedding_card_eq_of_le (M : Type w') [L.Structure M] [Nonempty M]
(ΞΊ : Cardinal.{w}) (h1 : β΅β β€ ΞΊ) (h2 : lift.{w} L.card β€ Cardinal.lift.{max u v} ΞΊ)
(h3 : lift.{w'} ΞΊ β€ Cardinal.lift.{w} #M) :
β N : Bundled L.Structure, Nonempty (N βͺβ[L] M) β§ #N = ΞΊ := by |
obtain β¨S, _, hSβ© := exists_elementarySubstructure_card_eq L β
ΞΊ h1 (by simp) h2 h3
have : Small.{w} S := by
rw [β lift_inj.{_, w + 1}, lift_lift, lift_lift] at hS
exact small_iff_lift_mk_lt_univ.2 (lt_of_eq_of_lt hS ΞΊ.lift_lt_univ')
refine
β¨(equivShrink S).bundledInduced L,
β¨S.subtype.comp (Eq... | [
" β N, Nonempty (βN βͺβ[L] M) β§ #βN = ΞΊ",
" lift.{w, w'} #ββ
β€ lift.{w', w} ΞΊ",
" Small.{w, w'} β₯S",
" lift.{w', w} #β(Equiv.bundledInduced L (equivShrink β₯S)) = lift.{w, w'} #β₯S"
] | [] |
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 | 241 | 256 | theorem isBounded_sup {p : ΞΉ β Seminorm π E} {q : ΞΉ' β Seminorm πβ F} {f : E βββ[Οββ] F}
(hf : IsBounded p q f) (s' : Finset ΞΉ') :
β (C : ββ₯0) (s : Finset ΞΉ), (s'.sup q).comp f β€ C β’ s.sup p := by |
classical
obtain rfl | _ := s'.eq_empty_or_nonempty
Β· exact β¨1, β
, by simp [Seminorm.bot_eq_zero]β©
choose fβ fC hf using hf
use s'.card β’ s'.sup fC, Finset.biUnion s' fβ
have hs : β i : ΞΉ', i β s' β (q i).comp f β€ s'.sup fC β’ (Finset.biUnion s' fβ).sup p := by
intro i hi
refine (hf i)... | [
" IsBounded p (fun x => q) f β β s C, q.comp f β€ C β’ s.sup p",
" IsBounded (fun x => p) q f β β (i : ΞΉ'), β C, (q i).comp f β€ C β’ p",
" IsBounded (fun x => p) q f β β (i : ΞΉ'), β C, (q i).comp f β€ C β’ p",
" (β (i : ΞΉ'), β C, (q i).comp f β€ C β’ p) β IsBounded (fun x => p) q f",
" β C, (q i).comp f β€ C β’ p",
... | [
" IsBounded p (fun x => q) f β β s C, q.comp f β€ C β’ s.sup p",
" IsBounded (fun x => p) q f β β (i : ΞΉ'), β C, (q i).comp f β€ C β’ p",
" IsBounded (fun x => p) q f β β (i : ΞΉ'), β C, (q i).comp f β€ C β’ p",
" (β (i : ΞΉ'), β C, (q i).comp f β€ C β’ p) β IsBounded (fun x => p) q f",
" β C, (q i).comp f β€ C β’ p",
... |
import Mathlib.Data.Set.Prod
import Mathlib.Logic.Equiv.Fin
import Mathlib.ModelTheory.LanguageMap
#align_import model_theory.syntax from "leanprover-community/mathlib"@"d565b3df44619c1498326936be16f1a935df0728"
universe u v w u' v'
namespace FirstOrder
namespace Language
variable (L : Language.{u, v}) {L' : L... | Mathlib/ModelTheory/Syntax.lean | 119 | 123 | theorem relabel_relabel (f : Ξ± β Ξ²) (g : Ξ² β Ξ³) (t : L.Term Ξ±) :
(t.relabel f).relabel g = t.relabel (g β f) := by |
induction' t with _ _ _ _ ih
Β· rfl
Β· simp [ih]
| [
" relabel id t = t",
" relabel id (var aβ) = var aβ",
" relabel id (func _fβ _tsβ) = func _fβ _tsβ",
" relabel g (relabel f t) = relabel (g β f) t",
" relabel g (relabel f (var aβ)) = relabel (g β f) (var aβ)",
" relabel g (relabel f (func _fβ _tsβ)) = relabel (g β f) (func _fβ _tsβ)"
] | [
" relabel id t = t",
" relabel id (var aβ) = var aβ",
" relabel id (func _fβ _tsβ) = func _fβ _tsβ"
] |
import Mathlib.RingTheory.Ideal.QuotientOperations
import Mathlib.RingTheory.Localization.Basic
#align_import ring_theory.localization.ideal from "leanprover-community/mathlib"@"e7f0ddbf65bd7181a85edb74b64bdc35ba4bdc74"
namespace IsLocalization
section CommSemiring
variable {R : Type*} [CommSemiring R] (M : Sub... | Mathlib/RingTheory/Localization/Ideal.lean | 53 | 64 | theorem mem_map_algebraMap_iff {I : Ideal R} {z} : z β Ideal.map (algebraMap R S) I β
β x : I Γ M, z * algebraMap R S x.2 = algebraMap R S x.1 := by |
constructor
Β· change _ β z β map_ideal M S I
refine fun h => Ideal.mem_sInf.1 h fun z hz => ?_
obtain β¨y, hyβ© := hz
let Z : { x // x β I } := β¨y, hy.leftβ©
use β¨Z, 1β©
simp [hy.right]
Β· rintro β¨β¨a, sβ©, hβ©
rw [β Ideal.unit_mul_mem_iff_mem _ (map_units S s), mul_comm]
exact h.symm βΈ Ideal... | [
" β {a b : S},\n a β {z | β x, z * (algebraMap R S) βx.2 = (algebraMap R S) βx.1} β\n b β {z | β x, z * (algebraMap R S) βx.2 = (algebraMap R S) βx.1} β\n a + b β {z | β x, z * (algebraMap R S) βx.2 = (algebraMap R S) βx.1}",
" a + b β {z | β x, z * (algebraMap R S) βx.2 = (algebraMap R S) βx.1}",
... | [
" β {a b : S},\n a β {z | β x, z * (algebraMap R S) βx.2 = (algebraMap R S) βx.1} β\n b β {z | β x, z * (algebraMap R S) βx.2 = (algebraMap R S) βx.1} β\n a + b β {z | β x, z * (algebraMap R S) βx.2 = (algebraMap R S) βx.1}",
" a + b β {z | β x, z * (algebraMap R S) βx.2 = (algebraMap R S) βx.1}",
... |
import Mathlib.Algebra.CharP.Invertible
import Mathlib.Algebra.Order.Invertible
import Mathlib.Algebra.Order.Module.OrderedSMul
import Mathlib.Algebra.Order.Group.Instances
import Mathlib.LinearAlgebra.AffineSpace.Slope
import Mathlib.LinearAlgebra.AffineSpace.Midpoint
import Mathlib.Tactic.FieldSimp
#align_import li... | Mathlib/LinearAlgebra/AffineSpace/Ordered.lean | 77 | 80 | theorem lineMap_strict_mono_endpoints (ha : a < a') (hb : b < b') (hβ : 0 β€ r) (hβ : r β€ 1) :
lineMap a b r < lineMap a' b' r := by |
rcases hβ.eq_or_lt with (rfl | hβ); Β· simpa
exact (lineMap_mono_left ha.le hβ).trans_lt (lineMap_strict_mono_right hb hβ)
| [
" (lineMap a b) r β€ (lineMap a' b) r",
" (1 - r) β’ a + r β’ b β€ (1 - r) β’ a' + r β’ b",
" (lineMap a b) r < (lineMap a' b) r",
" (1 - r) β’ a + r β’ b < (1 - r) β’ a' + r β’ b",
" (lineMap a b) r β€ (lineMap a b') r",
" (1 - r) β’ a + r β’ b β€ (1 - r) β’ a + r β’ b'",
" (lineMap a b) r < (lineMap a b') r",
" (1 ... | [
" (lineMap a b) r β€ (lineMap a' b) r",
" (1 - r) β’ a + r β’ b β€ (1 - r) β’ a' + r β’ b",
" (lineMap a b) r < (lineMap a' b) r",
" (1 - r) β’ a + r β’ b < (1 - r) β’ a' + r β’ b",
" (lineMap a b) r β€ (lineMap a b') r",
" (1 - r) β’ a + r β’ b β€ (1 - r) β’ a + r β’ b'",
" (lineMap a b) r < (lineMap a b') r",
" (1 ... |
import Mathlib.Data.List.Nodup
#align_import data.prod.tprod from "leanprover-community/mathlib"@"c227d107bbada5d0d9d20287e3282c0a7f1651a0"
open List Function
universe u v
variable {ΞΉ : Type u} {Ξ± : ΞΉ β Type v} {i j : ΞΉ} {l : List ΞΉ} {f : β i, Ξ± i}
namespace List
variable (Ξ±)
abbrev TProd (l : List ΞΉ) : Type v... | Mathlib/Data/Prod/TProd.lean | 94 | 95 | theorem elim_of_ne (hj : j β i :: l) (hji : j β i) (v : TProd Ξ± (i :: l)) :
v.elim hj = TProd.elim v.2 ((List.mem_cons.mp hj).resolve_left hji) := by | simp [TProd.elim, hji]
| [
" Ξ± j",
" v.elim β― = v.1",
" v.elim hj = TProd.elim v.2 β―"
] | [
" Ξ± j",
" v.elim β― = v.1"
] |
import Mathlib.Analysis.Calculus.Deriv.Basic
import Mathlib.Analysis.Calculus.FDeriv.Mul
import Mathlib.Analysis.Calculus.FDeriv.Add
#align_import analysis.calculus.deriv.mul from "leanprover-community/mathlib"@"3bce8d800a6f2b8f63fe1e588fd76a9ff4adcebe"
universe u v w
noncomputable section
open scoped Classical... | Mathlib/Analysis/Calculus/Deriv/Mul.lean | 58 | 60 | theorem hasDerivAt_of_bilinear (hu : HasDerivAt u u' x) (hv : HasDerivAt v v' x) :
HasDerivAt (fun x β¦ B (u x) (v x)) (B (u x) v' + B u' (v x)) x := by |
simpa using (B.hasFDerivAt_of_bilinear hu.hasFDerivAt hv.hasFDerivAt).hasDerivAt
| [
" HasDerivWithinAt (fun x => (B (u x)) (v x)) ((B (u x)) v' + (B u') (v x)) s x",
" HasDerivAt (fun x => (B (u x)) (v x)) ((B (u x)) v' + (B u') (v x)) x"
] | [
" HasDerivWithinAt (fun x => (B (u x)) (v x)) ((B (u x)) v' + (B u') (v x)) s x"
] |
import Mathlib.Order.Interval.Set.Image
import Mathlib.Order.CompleteLatticeIntervals
import Mathlib.Topology.Order.DenselyOrdered
import Mathlib.Topology.Order.Monotone
#align_import topology.algebra.order.intermediate_value from "leanprover-community/mathlib"@"4c19a16e4b705bf135cf9a80ac18fcc99c438514"
open Filt... | Mathlib/Topology/Order/IntermediateValue.lean | 115 | 124 | theorem IsPreconnected.intermediate_valueβ_eventuallyβ {s : Set X} (hs : IsPreconnected s)
{lβ lβ : Filter X} [NeBot lβ] [NeBot lβ] (hlβ : lβ β€ π s) (hlβ : lβ β€ π s) {f g : X β Ξ±}
(hf : ContinuousOn f s) (hg : ContinuousOn g s) (heβ : f β€αΆ [lβ] g) (heβ : g β€αΆ [lβ] f) :
β x β s, f x = g x := by |
rw [continuousOn_iff_continuous_restrict] at hf hg
obtain β¨b, hβ© :=
@intermediate_value_univβ_eventuallyβ _ _ _ _ _ _ (Subtype.preconnectedSpace hs) _ _
(comap_coe_neBot_of_le_principal hlβ) (comap_coe_neBot_of_le_principal hlβ) _ _ hf hg
(heβ.comap _) (heβ.comap _)
exact β¨b, b.prop, hβ©
| [
" β x, f x = g x",
" β x β s, f x = g x"
] | [
" β x, f x = g x",
" β x β s, f x = g x"
] |
import Mathlib.Algebra.Group.Subgroup.Basic
import Mathlib.Algebra.Group.Submonoid.Membership
import Mathlib.Data.Finite.Card
#align_import group_theory.subgroup.finite from "leanprover-community/mathlib"@"f93c11933efbc3c2f0299e47b8ff83e9b539cbf6"
variable {G : Type*} [Group G]
variable {A : Type*} [AddGroup A]
n... | Mathlib/Algebra/Group/Subgroup/Finite.lean | 195 | 226 | theorem pi_mem_of_mulSingle_mem_aux [DecidableEq Ξ·] (I : Finset Ξ·) {H : Subgroup (β i, f i)}
(x : β i, f i) (h1 : β i, i β I β x i = 1) (h2 : β i, i β I β Pi.mulSingle i (x i) β H) :
x β H := by |
induction' I using Finset.induction_on with i I hnmem ih generalizing x
Β· convert one_mem H
ext i
exact h1 i (Finset.not_mem_empty i)
Β· have : x = Function.update x i 1 * Pi.mulSingle i (x i) := by
ext j
by_cases heq : j = i
Β· subst heq
simp
Β· simp [heq]
rw [this]
... | [
" x β H",
" x = 1",
" x i = 1 i",
" x = Function.update x i 1 * Pi.mulSingle i (x i)",
" x j = (Function.update x i 1 * Pi.mulSingle i (x i)) j",
" x j = (Function.update x j 1 * Pi.mulSingle j (x j)) j",
" Function.update x i 1 * Pi.mulSingle i (x i) β H",
" Function.update x i 1 β H",
" β i_1 β I,... | [] |
import Mathlib.SetTheory.Ordinal.Arithmetic
import Mathlib.SetTheory.Ordinal.Exponential
#align_import set_theory.ordinal.cantor_normal_form from "leanprover-community/mathlib"@"991ff3b5269848f6dd942ae8e9dd3c946035dc8b"
noncomputable section
universe u
open List
namespace Ordinal
@[elab_as_elim]
noncomputabl... | Mathlib/SetTheory/Ordinal/CantorNormalForm.lean | 93 | 93 | theorem zero_CNF {o : Ordinal} (ho : o β 0) : CNF 0 o = [β¨0, oβ©] := by | simp [CNF_ne_zero ho]
| [
" C o",
" C 0",
" (invImage (fun x => x) wellFoundedRelation).1 (o % b ^ b.log o) o",
" b.CNFRec H0 H 0 = H0",
" β―.mpr H0 = H0",
" b.CNFRec H0 H o = H o ho (b.CNFRec H0 H (o % b ^ b.log o))",
" CNF 0 o = [(0, o)]"
] | [
" C o",
" C 0",
" (invImage (fun x => x) wellFoundedRelation).1 (o % b ^ b.log o) o",
" b.CNFRec H0 H 0 = H0",
" β―.mpr H0 = H0",
" b.CNFRec H0 H o = H o ho (b.CNFRec H0 H (o % b ^ b.log o))"
] |
import Mathlib.LinearAlgebra.AffineSpace.AffineMap
import Mathlib.Tactic.FieldSimp
#align_import linear_algebra.affine_space.slope from "leanprover-community/mathlib"@"70fd9563a21e7b963887c9360bd29b2393e6225a"
open AffineMap
variable {k E PE : Type*} [Field k] [AddCommGroup E] [Module k E] [AddTorsor E PE]
def ... | Mathlib/LinearAlgebra/AffineSpace/Slope.lean | 67 | 69 | theorem slope_vadd_const (f : k β E) (c : PE) : (slope fun x => f x +α΅₯ c) = slope f := by |
ext a b
simp only [slope, vadd_vsub_vadd_cancel_right, vsub_eq_sub]
| [
" slope f a a = 0",
" (b - a) β’ slope f a b = f b -α΅₯ f a",
" (a - a) β’ slope f a a = f a -α΅₯ f a",
" (b - a) β’ slope f a b +α΅₯ f a = f b",
" (slope fun x => f x +α΅₯ c) = slope f",
" slope (fun x => f x +α΅₯ c) a b = slope f a b"
] | [
" slope f a a = 0",
" (b - a) β’ slope f a b = f b -α΅₯ f a",
" (a - a) β’ slope f a a = f a -α΅₯ f a",
" (b - a) β’ slope f a b +α΅₯ f a = f b"
] |
import Mathlib.Algebra.Group.ConjFinite
import Mathlib.GroupTheory.Abelianization
import Mathlib.GroupTheory.GroupAction.ConjAct
import Mathlib.GroupTheory.GroupAction.Quotient
import Mathlib.GroupTheory.Index
import Mathlib.GroupTheory.SpecificGroups.Dihedral
import Mathlib.Tactic.FieldSimp
import Mathlib.Tactic.Line... | Mathlib/GroupTheory/CommutingProbability.lean | 119 | 128 | theorem Subgroup.commProb_quotient_le [H.Normal] : commProb (G β§Έ H) β€ commProb G * Nat.card H := by |
/- After rewriting with `commProb_def'`, we reduce to showing that `G` has at least as many
conjugacy classes as `G β§Έ H`. -/
rw [commProb_def', commProb_def', div_le_iff, mul_assoc, β Nat.cast_mul, β Subgroup.index,
H.card_mul_index, div_mul_cancelβ, Nat.cast_le]
Β· apply Finite.card_le_of_surjective
... | [
" commProb (M Γ M') = commProb M * commProb M'",
" β(Nat.card { p // (p.1 * p.2).1 = (p.2 * p.1).1 β§ (p.1 * p.2).2 = (p.2 * p.1).2 }) /\n (β(Nat.card M) ^ 2 * β(Nat.card M') ^ 2) =\n β(Nat.card ({ p // p.1 * p.2 = p.2 * p.1 } Γ { p // p.1 * p.2 = p.2 * p.1 })) /\n (β(Nat.card M) ^ 2 * β(Nat.card M') ... | [
" commProb (M Γ M') = commProb M * commProb M'",
" β(Nat.card { p // (p.1 * p.2).1 = (p.2 * p.1).1 β§ (p.1 * p.2).2 = (p.2 * p.1).2 }) /\n (β(Nat.card M) ^ 2 * β(Nat.card M') ^ 2) =\n β(Nat.card ({ p // p.1 * p.2 = p.2 * p.1 } Γ { p // p.1 * p.2 = p.2 * p.1 })) /\n (β(Nat.card M) ^ 2 * β(Nat.card M') ... |
import Mathlib.Data.Finset.Prod
import Mathlib.Data.Set.Finite
#align_import data.finset.n_ary from "leanprover-community/mathlib"@"eba7871095e834365616b5e43c8c7bb0b37058d0"
open Function Set
variable {Ξ± Ξ±' Ξ² Ξ²' Ξ³ Ξ³' Ξ΄ Ξ΄' Ξ΅ Ξ΅' ΞΆ ΞΆ' Ξ½ : Type*}
namespace Finset
variable [DecidableEq Ξ±'] [DecidableEq Ξ²'] [Decidabl... | Mathlib/Data/Finset/NAry.lean | 58 | 61 | theorem card_imageβ_iff :
(imageβ f s t).card = s.card * t.card β (s ΓΛ’ t : Set (Ξ± Γ Ξ²)).InjOn fun x => f x.1 x.2 := by |
rw [β card_product, β coe_product]
exact card_image_iff
| [
" c β imageβ f s t β β a β s, β b β t, f a b = c",
" (imageβ f s t).card = s.card * t.card β InjOn (fun x => f x.1 x.2) (βs ΓΛ’ βt)",
" (imageβ f s t).card = (s ΓΛ’ t).card β InjOn (fun x => f x.1 x.2) β(s ΓΛ’ t)"
] | [
" c β imageβ f s t β β a β s, β b β t, f a b = c"
] |
import Mathlib.Algebra.BigOperators.Ring
import Mathlib.Algebra.Field.Rat
import Mathlib.Algebra.Order.Field.Basic
import Mathlib.Algebra.Order.Field.Rat
import Mathlib.Combinatorics.Enumerative.DoubleCounting
import Mathlib.Combinatorics.SetFamily.Shadow
#align_import combinatorics.set_family.lym from "leanprover-co... | Mathlib/Combinatorics/SetFamily/LYM.lean | 149 | 163 | theorem slice_union_shadow_falling_succ : π # k βͺ β (falling (k + 1) π) = falling k π := by |
ext s
simp_rw [mem_union, mem_slice, mem_shadow_iff, mem_falling]
constructor
Β· rintro (h | β¨s, β¨β¨t, ht, hstβ©, hsβ©, a, ha, rflβ©)
Β· exact β¨β¨s, h.1, Subset.refl _β©, h.2β©
refine β¨β¨t, ht, (erase_subset _ _).trans hstβ©, ?_β©
rw [card_erase_of_mem ha, hs]
rfl
Β· rintro β¨β¨t, ht, hstβ©, hsβ©
by_cases... | [
" s β falling k π β (β t β π, s β t) β§ s.card = k",
" (β v β π, s β v β§ s.card = k) β (β t β π, s β t) β§ s.card = k",
" π # k βͺ β (falling (k + 1) π) = falling k π",
" s β π # k βͺ β (falling (k + 1) π) β s β falling k π",
" (s β π β§ s.card = k β¨ β s_1, ((β t β π, s_1 β t) β§ s_1.card = k + 1) β§ β... | [
" s β falling k π β (β t β π, s β t) β§ s.card = k",
" (β v β π, s β v β§ s.card = k) β (β t β π, s β t) β§ s.card = k"
] |
import Mathlib.MeasureTheory.Function.LpOrder
#align_import measure_theory.function.l1_space from "leanprover-community/mathlib"@"ccdbfb6e5614667af5aa3ab2d50885e0ef44a46f"
noncomputable section
open scoped Classical
open Topology ENNReal MeasureTheory NNReal
open Set Filter TopologicalSpace ENNReal EMetric Meas... | Mathlib/MeasureTheory/Function/L1Space.lean | 66 | 67 | theorem lintegral_nnnorm_eq_lintegral_edist (f : Ξ± β Ξ²) :
β«β» a, βf aββ βΞΌ = β«β» a, edist (f a) 0 βΞΌ := by | simp only [edist_eq_coe_nnnorm]
| [
" β«β» (a : Ξ±), ββf aββ βΞΌ = β«β» (a : Ξ±), edist (f a) 0 βΞΌ"
] | [] |
import Mathlib.Analysis.SpecialFunctions.Pow.Continuity
import Mathlib.Analysis.SpecialFunctions.Complex.LogDeriv
import Mathlib.Analysis.Calculus.FDeriv.Extend
import Mathlib.Analysis.Calculus.Deriv.Prod
import Mathlib.Analysis.SpecialFunctions.Log.Deriv
import Mathlib.Analysis.SpecialFunctions.Trigonometric.Deriv
#... | Mathlib/Analysis/SpecialFunctions/Pow/Deriv.lean | 321 | 326 | theorem _root_.HasStrictDerivAt.rpow {f g : β β β} {f' g' : β} (hf : HasStrictDerivAt f f' x)
(hg : HasStrictDerivAt g g' x) (h : 0 < f x) : HasStrictDerivAt (fun x => f x ^ g x)
(f' * g x * f x ^ (g x - 1) + g' * f x ^ g x * Real.log (f x)) x := by |
convert (hasStrictFDerivAt_rpow_of_pos ((fun x => (f x, g x)) x) h).comp_hasStrictDerivAt x
(hf.prod hg) using 1
simp [mul_assoc, mul_comm, mul_left_comm]
| [
" HasStrictFDerivAt (fun x => x.1 ^ x.2)\n ((p.2 * p.1 ^ (p.2 - 1)) β’ ContinuousLinearMap.fst β β β + (p.1 ^ p.2 * p.1.log) β’ ContinuousLinearMap.snd β β β) p",
" HasStrictFDerivAt (fun x => rexp (x.1.log * x.2))\n ((p.2 * p.1 ^ (p.2 - 1)) β’ ContinuousLinearMap.fst β β β + (p.1 ^ p.2 * p.1.log) β’ Continuous... | [
" HasStrictFDerivAt (fun x => x.1 ^ x.2)\n ((p.2 * p.1 ^ (p.2 - 1)) β’ ContinuousLinearMap.fst β β β + (p.1 ^ p.2 * p.1.log) β’ ContinuousLinearMap.snd β β β) p",
" HasStrictFDerivAt (fun x => rexp (x.1.log * x.2))\n ((p.2 * p.1 ^ (p.2 - 1)) β’ ContinuousLinearMap.fst β β β + (p.1 ^ p.2 * p.1.log) β’ Continuous... |
import Mathlib.LinearAlgebra.Span
import Mathlib.RingTheory.Ideal.IsPrimary
import Mathlib.RingTheory.Ideal.QuotientOperations
import Mathlib.RingTheory.Noetherian
#align_import ring_theory.ideal.associated_prime from "leanprover-community/mathlib"@"f0c8bf9245297a541f468be517f1bde6195105e9"
variable {R : Type*} [... | Mathlib/RingTheory/Ideal/AssociatedPrime.lean | 125 | 129 | theorem associatedPrimes.nonempty [IsNoetherianRing R] [Nontrivial M] :
(associatedPrimes R M).Nonempty := by |
obtain β¨x, hxβ© := exists_ne (0 : M)
obtain β¨P, hP, _β© := exists_le_isAssociatedPrime_of_isNoetherianRing R x hx
exact β¨P, hPβ©
| [
" IsAssociatedPrime I M'",
" IsAssociatedPrime (Submodule.span R {x}).annihilator M'",
" (Submodule.span R {x}).annihilator = (Submodule.span R {f x}).annihilator",
" r β (Submodule.span R {x}).annihilator β r β (Submodule.span R {f x}).annihilator",
" Β¬IsAssociatedPrime I M",
" False",
" I = β€",
" β ... | [
" IsAssociatedPrime I M'",
" IsAssociatedPrime (Submodule.span R {x}).annihilator M'",
" (Submodule.span R {x}).annihilator = (Submodule.span R {f x}).annihilator",
" r β (Submodule.span R {x}).annihilator β r β (Submodule.span R {f x}).annihilator",
" Β¬IsAssociatedPrime I M",
" False",
" I = β€",
" β ... |
import Mathlib.Algebra.Homology.ComplexShape
import Mathlib.CategoryTheory.Subobject.Limits
import Mathlib.CategoryTheory.GradedObject
import Mathlib.Algebra.Homology.ShortComplex.Basic
#align_import algebra.homology.homological_complex from "leanprover-community/mathlib"@"88bca0ce5d22ebfd9e73e682e51d60ea13b48347"
... | Mathlib/Algebra/Homology/HomologicalComplex.lean | 286 | 290 | theorem eqToHom_f {Cβ Cβ : HomologicalComplex V c} (h : Cβ = Cβ) (n : ΞΉ) :
HomologicalComplex.Hom.f (eqToHom h) n =
eqToHom (congr_fun (congr_arg HomologicalComplex.X h) n) := by |
subst h
rfl
| [
" f.f i β« B.d i j = A.d i j β« f.f j",
" f = g",
" f.f = g.f",
" f.f xβ = g.f xβ",
" (eqToHom h).f n = eqToHom β―",
" (eqToHom β―).f n = eqToHom β―"
] | [
" f.f i β« B.d i j = A.d i j β« f.f j",
" f = g",
" f.f = g.f",
" f.f xβ = g.f xβ"
] |
import Mathlib.Data.Set.Image
import Mathlib.Order.Interval.Set.Basic
#align_import data.set.intervals.with_bot_top from "leanprover-community/mathlib"@"d012cd09a9b256d870751284dd6a29882b0be105"
open Set
variable {Ξ± : Type*}
namespace WithTop
@[simp]
theorem preimage_coe_top : (some : Ξ± β WithTop Ξ±) β»ΒΉ' {β€} =... | Mathlib/Order/Interval/Set/WithBotTop.lean | 118 | 121 | theorem image_coe_Ioc : (some : Ξ± β WithTop Ξ±) '' Ioc a b = Ioc (a : WithTop Ξ±) b := by |
rw [β preimage_coe_Ioc, image_preimage_eq_inter_range, range_coe,
inter_eq_self_of_subset_left
(Subset.trans Ioc_subset_Iic_self <| Iic_subset_Iio.2 <| coe_lt_top b)]
| [
" range some = Iio β€",
" x β range some β x β Iio β€",
" some β»ΒΉ' Icc βa βb = Icc a b",
" some β»ΒΉ' Ico βa βb = Ico a b",
" some β»ΒΉ' Ioc βa βb = Ioc a b",
" some β»ΒΉ' Ioo βa βb = Ioo a b",
" some β»ΒΉ' Iio β€ = univ",
" some β»ΒΉ' Ico βa β€ = Ici a",
" some β»ΒΉ' Ioo βa β€ = Ioi a",
" some '' Ioi a = Ioo βa β€... | [
" range some = Iio β€",
" x β range some β x β Iio β€",
" some β»ΒΉ' Icc βa βb = Icc a b",
" some β»ΒΉ' Ico βa βb = Ico a b",
" some β»ΒΉ' Ioc βa βb = Ioc a b",
" some β»ΒΉ' Ioo βa βb = Ioo a b",
" some β»ΒΉ' Iio β€ = univ",
" some β»ΒΉ' Ico βa β€ = Ici a",
" some β»ΒΉ' Ioo βa β€ = Ioi a",
" some '' Ioi a = Ioo βa β€... |
import Mathlib.Algebra.Group.Basic
import Mathlib.Algebra.Group.Commute.Defs
import Mathlib.Algebra.Ring.Defs
import Mathlib.Data.Subtype
import Mathlib.Order.Notation
#align_import algebra.ring.idempotents from "leanprover-community/mathlib"@"655994e298904d7e5bbd1e18c95defd7b543eb94"
variable {M N S Mβ Mβ R G Gβ... | Mathlib/Algebra/Ring/Idempotents.lean | 66 | 67 | theorem one_sub {p : R} (h : IsIdempotentElem p) : IsIdempotentElem (1 - p) := by |
rw [IsIdempotentElem, mul_sub, mul_one, sub_mul, one_mul, h.eq, sub_self, sub_zero]
| [
" IsIdempotentElem (p * q)",
" IsIdempotentElem (1 - p)"
] | [
" IsIdempotentElem (p * q)"
] |
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 | 134 | 142 | theorem integrable_toReal_condDistrib (hX : AEMeasurable X ΞΌ) (hs : MeasurableSet s) :
Integrable (fun a => (condDistrib Y X ΞΌ (X a) s).toReal) ΞΌ := by |
refine integrable_toReal_of_lintegral_ne_top ?_ ?_
Β· exact Measurable.comp_aemeasurable (kernel.measurable_coe _ hs) hX
Β· refine ne_of_lt ?_
calc
β«β» a, condDistrib Y X ΞΌ (X a) s βΞΌ β€ β«β» _, 1 βΞΌ := lintegral_mono fun a => prob_le_one
_ = ΞΌ univ := lintegral_one
_ < β := measure_lt_top _ _
| [
" 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.Module.BigOperators
import Mathlib.Data.Fintype.Perm
import Mathlib.GroupTheory.Perm.Finite
import Mathlib.GroupTheory.Perm.List
#align_import group_theory.perm.cycle.basic from "leanprover-community/mathlib"@"e8638a0fcaf73e4500469f368ef9494e495099b3"
open Equiv Function Finset
variable {... | Mathlib/GroupTheory/Perm/Cycle/Basic.lean | 142 | 143 | theorem sameCycle_inv_apply_right : SameCycle f x (fβ»ΒΉ y) β SameCycle f x y := by |
rw [β sameCycle_apply_right, apply_inv_self]
| [
" f.SameCycle x y",
" (f ^ (-i)) y = x",
" (f ^ (j + i)) x = z",
" SameCycle 1 x y β x = y",
" (β b, (fβ»ΒΉ ^ (Equiv.symm (Equiv.neg β€)) b) x = y) β f.SameCycle x y",
" ((g * f * gβ»ΒΉ) ^ i) x = y β (f ^ i) (gβ»ΒΉ x) = gβ»ΒΉ y",
" f.SameCycle x y β (g * f * gβ»ΒΉ).SameCycle (g x) (g y)",
" f x = x β f y = y",
... | [
" f.SameCycle x y",
" (f ^ (-i)) y = x",
" (f ^ (j + i)) x = z",
" SameCycle 1 x y β x = y",
" (β b, (fβ»ΒΉ ^ (Equiv.symm (Equiv.neg β€)) b) x = y) β f.SameCycle x y",
" ((g * f * gβ»ΒΉ) ^ i) x = y β (f ^ i) (gβ»ΒΉ x) = gβ»ΒΉ y",
" f.SameCycle x y β (g * f * gβ»ΒΉ).SameCycle (g x) (g y)",
" f x = x β f y = y",
... |
import Mathlib.Algebra.Order.Archimedean
import Mathlib.Order.Filter.AtTopBot
import Mathlib.Tactic.GCongr
#align_import order.filter.archimedean from "leanprover-community/mathlib"@"8631e2d5ea77f6c13054d9151d82b83069680cb1"
variable {Ξ± R : Type*}
open Filter Set Function
@[simp]
theorem Nat.comap_cast_atTop [S... | Mathlib/Order/Filter/Archimedean.lean | 77 | 79 | theorem tendsto_intCast_atBot_iff [StrictOrderedRing R] [Archimedean R] {f : Ξ± β β€}
{l : Filter Ξ±} : Tendsto (fun n => (f n : R)) l atBot β Tendsto f l atBot := by |
rw [β @Int.comap_cast_atBot R, tendsto_comap_iff]; rfl
| [
" β(-βn) β€ r",
" Tendsto (fun n => β(f n)) l atTop β Tendsto f l atTop",
" Tendsto (fun n => β(f n)) l atTop β Tendsto (Int.cast β f) l atTop",
" Tendsto (fun n => β(f n)) l atBot β Tendsto f l atBot",
" Tendsto (fun n => β(f n)) l atBot β Tendsto (Int.cast β f) l atBot"
] | [
" β(-βn) β€ r",
" Tendsto (fun n => β(f n)) l atTop β Tendsto f l atTop",
" Tendsto (fun n => β(f n)) l atTop β Tendsto (Int.cast β f) l atTop"
] |
import Mathlib.Algebra.GCDMonoid.Multiset
import Mathlib.Combinatorics.Enumerative.Partition
import Mathlib.Data.List.Rotate
import Mathlib.GroupTheory.Perm.Cycle.Factors
import Mathlib.GroupTheory.Perm.Closure
import Mathlib.Algebra.GCDMonoid.Nat
import Mathlib.Tactic.NormNum.GCD
#align_import group_theory.perm.cycl... | Mathlib/GroupTheory/Perm/Cycle/Type.lean | 139 | 144 | theorem cycleType_conj {Ο Ο : Perm Ξ±} : (Ο * Ο * Οβ»ΒΉ).cycleType = Ο.cycleType := by |
induction Ο using cycle_induction_on with
| base_one => simp
| base_cycles Ο hΟ => rw [hΟ.cycleType, hΟ.conj.cycleType, card_support_conj]
| induction_disjoint Ο Ο hd _ hΟ hΟ =>
rw [β conj_mul, hd.cycleType, (hd.conj _).cycleType, hΟ, hΟ]
| [
" Ο.cycleType = Multiset.map (Finset.card β support) s.val",
" Multiset.map (Finset.card β support) Ο.cycleFactorsFinset.val = Multiset.map (Finset.card β support) s.val",
" Ο.cycleFactorsFinset = s",
" (β f β s, f.IsCycle) β§ β (h : (βs).Pairwise Disjoint), s.noncommProd id β― = Ο",
" Ο.cycleType = β(List.ma... | [
" Ο.cycleType = Multiset.map (Finset.card β support) s.val",
" Multiset.map (Finset.card β support) Ο.cycleFactorsFinset.val = Multiset.map (Finset.card β support) s.val",
" Ο.cycleFactorsFinset = s",
" (β f β s, f.IsCycle) β§ β (h : (βs).Pairwise Disjoint), s.noncommProd id β― = Ο",
" Ο.cycleType = β(List.ma... |
import Mathlib.Algebra.Order.Ring.Int
#align_import data.int.least_greatest from "leanprover-community/mathlib"@"3342d1b2178381196f818146ff79bc0e7ccd9e2d"
namespace Int
def leastOfBdd {P : β€ β Prop} [DecidablePred P] (b : β€) (Hb : β z : β€, P z β b β€ z)
(Hinh : β z : β€, P z) : { lb : β€ // P lb β§ β z : β€, P z... | Mathlib/Data/Int/LeastGreatest.lean | 106 | 111 | theorem coe_greatestOfBdd_eq {P : β€ β Prop} [DecidablePred P] {b b' : β€}
(Hb : β z : β€, P z β z β€ b) (Hb' : β z : β€, P z β z β€ b') (Hinh : β z : β€, P z) :
(greatestOfBdd b Hb Hinh : β€) = greatestOfBdd b' Hb' Hinh := by |
rcases greatestOfBdd b Hb Hinh with β¨n, hn, h2nβ©
rcases greatestOfBdd b' Hb' Hinh with β¨n', hn', h2n'β©
exact le_antisymm (h2n' _ hn) (h2n _ hn')
| [
" β lb, P lb β§ β (z : β€), P z β lb β€ z",
" β(b.leastOfBdd Hb Hinh) = β(b'.leastOfBdd Hb' Hinh)",
" ββ¨n, β―β© = β(b'.leastOfBdd Hb' Hinh)",
" ββ¨n, β―β© = ββ¨n', β―β©",
" P (- -elt)",
" P elt",
" P (- -z)",
" β ub, P ub β§ β (z : β€), P z β z β€ ub",
" β(b.greatestOfBdd Hb Hinh) = β(b'.greatestOfBdd Hb' Hinh)",... | [
" β lb, P lb β§ β (z : β€), P z β lb β€ z",
" β(b.leastOfBdd Hb Hinh) = β(b'.leastOfBdd Hb' Hinh)",
" ββ¨n, β―β© = β(b'.leastOfBdd Hb' Hinh)",
" ββ¨n, β―β© = ββ¨n', β―β©",
" P (- -elt)",
" P elt",
" P (- -z)",
" β ub, P ub β§ β (z : β€), P z β z β€ ub"
] |
import Mathlib.CategoryTheory.Subobject.Limits
#align_import algebra.homology.image_to_kernel from "leanprover-community/mathlib"@"618ea3d5c99240cd7000d8376924906a148bf9ff"
universe v u w
open CategoryTheory CategoryTheory.Limits
variable {ΞΉ : Type*}
variable {V : Type u} [Category.{v} V] [HasZeroMorphisms V]
o... | Mathlib/Algebra/Homology/ImageToKernel.lean | 101 | 105 | theorem imageToKernel_zero_right [HasImages V] {w} :
imageToKernel f (0 : B βΆ C) w =
(imageSubobject f).arrow β« inv (kernelSubobject (0 : B βΆ C)).arrow := by |
ext
simp
| [
" kernel.lift g f w β« kernel.ΞΉ g = f",
" Mono (imageToKernel f g w)",
" Mono ((imageSubobject f).ofLE (kernelSubobject g) β―)",
" imageToKernel f g w β« (kernelSubobject g).arrow = (imageSubobject f).arrow",
" (kernelSubobject g).arrow ((imageToKernel f g w) x) = (imageSubobject f).arrow x",
" factorThruIma... | [
" kernel.lift g f w β« kernel.ΞΉ g = f",
" Mono (imageToKernel f g w)",
" Mono ((imageSubobject f).ofLE (kernelSubobject g) β―)",
" imageToKernel f g w β« (kernelSubobject g).arrow = (imageSubobject f).arrow",
" (kernelSubobject g).arrow ((imageToKernel f g w) x) = (imageSubobject f).arrow x",
" factorThruIma... |
import Mathlib.Analysis.Calculus.Conformal.NormedSpace
import Mathlib.Analysis.InnerProductSpace.ConformalLinearMap
#align_import analysis.calculus.conformal.inner_product from "leanprover-community/mathlib"@"46b633fd842bef9469441c0209906f6dddd2b4f5"
noncomputable section
variable {E F : Type*}
variable [NormedA... | Mathlib/Analysis/Calculus/Conformal/InnerProduct.lean | 29 | 31 | theorem conformalAt_iff' {f : E β F} {x : E} : ConformalAt f x β
β c : β, 0 < c β§ β u v : E, βͺfderiv β f x u, fderiv β f x vβ« = c * βͺu, vβ« := by |
rw [conformalAt_iff_isConformalMap_fderiv, isConformalMap_iff]
| [
" ConformalAt f x β β c, 0 < c β§ β (u v : E), βͺ(fderiv β f x) u, (fderiv β f x) vβ«_β = c * βͺu, vβ«_β"
] | [] |
import Mathlib.Analysis.InnerProductSpace.PiL2
import Mathlib.LinearAlgebra.Matrix.ZPow
#align_import linear_algebra.matrix.hermitian from "leanprover-community/mathlib"@"caa58cbf5bfb7f81ccbaca4e8b8ac4bc2b39cc1c"
namespace Matrix
variable {Ξ± Ξ² : Type*} {m n : Type*} {A : Matrix n n Ξ±}
open scoped Matrix
local ... | Mathlib/LinearAlgebra/Matrix/Hermitian.lean | 74 | 76 | theorem IsHermitian.transpose {A : Matrix n n Ξ±} (h : A.IsHermitian) : Aα΅.IsHermitian := by |
rw [IsHermitian, conjTranspose, transpose_map]
exact congr_arg Matrix.transpose h
| [
" (β (i j : n), star (A j i) = A i j) β A.IsHermitian",
" A.IsHermitian",
" Aα΄΄ i j = A i j",
" Aα΅.IsHermitian",
" (Aα΅.map star)α΅ = Aα΅"
] | [
" (β (i j : n), star (A j i) = A i j) β A.IsHermitian",
" A.IsHermitian",
" Aα΄΄ i j = A i j"
] |
import Mathlib.SetTheory.Cardinal.Basic
import Mathlib.Tactic.Ring
#align_import data.nat.count from "leanprover-community/mathlib"@"dc6c365e751e34d100e80fe6e314c3c3e0fd2988"
open Finset
namespace Nat
variable (p : β β Prop)
section Count
variable [DecidablePred p]
def count (n : β) : β :=
(List.range n).... | Mathlib/Data/Nat/Count.lean | 65 | 66 | theorem count_succ (n : β) : count p (n + 1) = count p n + if p n then 1 else 0 := by |
split_ifs with h <;> simp [count, List.range_succ, h]
| [
" count p 0 = 0",
" Fintype { i // i < n β§ p i }",
" β (x : β), x β filter p (range n) β x β fun x => x < n β§ p x",
" x β filter p (range n) β x β fun x => x < n β§ p x",
" x < n β§ p x β x β fun x => x < n β§ p x",
" count p n = (filter p (range n)).card",
" (List.filter (fun b => decide (p b)) (List.rang... | [
" count p 0 = 0",
" Fintype { i // i < n β§ p i }",
" β (x : β), x β filter p (range n) β x β fun x => x < n β§ p x",
" x β filter p (range n) β x β fun x => x < n β§ p x",
" x < n β§ p x β x β fun x => x < n β§ p x",
" count p n = (filter p (range n)).card",
" (List.filter (fun b => decide (p b)) (List.rang... |
import Mathlib.LinearAlgebra.Dimension.Free
import Mathlib.LinearAlgebra.Dimension.Finite
import Mathlib.LinearAlgebra.FreeModule.StrongRankCondition
open FiniteDimensional
namespace Subalgebra
variable {R S : Type*} [CommRing R] [CommRing S] [Algebra R S]
(A B : Subalgebra R S) [Module.Free R A] [Module.Free R... | Mathlib/Algebra/Algebra/Subalgebra/Rank.lean | 30 | 41 | theorem rank_sup_eq_rank_left_mul_rank_of_free :
Module.rank R β₯(A β B) = Module.rank R A * Module.rank A (Algebra.adjoin A (B : Set S)) := by |
rcases subsingleton_or_nontrivial R with _ | _
Β· haveI := Module.subsingleton R S; simp
nontriviality S using rank_subsingleton'
letI : Algebra A (Algebra.adjoin A (B : Set S)) := Subalgebra.algebra _
letI : SMul A (Algebra.adjoin A (B : Set S)) := Algebra.toSMul
haveI : IsScalarTower R A (Algebra.adjoin A... | [
" Module.rank R β₯(A β B) = Module.rank R β₯A * Module.rank β₯A β₯(Algebra.adjoin β₯A βB)",
" Module.rank R β₯(A β B) = Module.rank R β₯(Algebra.adjoin β₯A βB)",
" Module.rank R β₯(A β B) = Module.rank R β₯(restrictScalars R (Algebra.adjoin β₯A βB))",
" Module.rank R β₯(A β B) = Module.rank R β₯(Algebra.adjoin R (βA βͺ βB)... | [] |
import Mathlib.Combinatorics.Quiver.Path
import Mathlib.Combinatorics.Quiver.Push
#align_import combinatorics.quiver.symmetric from "leanprover-community/mathlib"@"706d88f2b8fdfeb0b22796433d7a6c1a010af9f2"
universe v u w v'
namespace Quiver
-- Porting note: no hasNonemptyInstance linter yet
def Symmetrify (V : ... | Mathlib/Combinatorics/Quiver/Symmetric.lean | 61 | 62 | theorem reverse_reverse [h : HasInvolutiveReverse V] {a b : V} (f : a βΆ b) :
reverse (reverse f) = f := by | apply h.inv'
| [
" reverse (reverse f) = f"
] | [] |
import Mathlib.MeasureTheory.Measure.Haar.InnerProductSpace
import Mathlib.MeasureTheory.Measure.Lebesgue.EqHaar
import Mathlib.MeasureTheory.Integral.SetIntegral
#align_import measure_theory.measure.haar.normed_space from "leanprover-community/mathlib"@"b84aee748341da06a6d78491367e2c0e9f15e8a5"
noncomputable sect... | Mathlib/MeasureTheory/Measure/Haar/NormedSpace.lean | 135 | 137 | theorem integral_comp_mul_left (g : β β F) (a : β) :
(β« x : β, g (a * x)) = |aβ»ΒΉ| β’ β« y : β, g y := by |
simp_rw [β smul_eq_mul, Measure.integral_comp_smul, FiniteDimensional.finrank_self, pow_one]
| [
" NoAtoms ΞΌ",
" β« (x : E), f (R β’ x) βΞΌ = |(R ^ finrank β E)β»ΒΉ| β’ β« (x : E), f x βΞΌ",
" β« (x : E), f (0 β’ x) βΞΌ = |(0 ^ finrank β E)β»ΒΉ| β’ β« (x : E), f x βΞΌ",
" (ΞΌ univ).toReal β’ f 0 = |(0 ^ finrank β E)β»ΒΉ| β’ β« (x : E), f x βΞΌ",
" f = fun x => f 0",
" f x = f 0",
"E : Type u_1\ninstββ· : NormedAddCommGrou... | [
" NoAtoms ΞΌ",
" β« (x : E), f (R β’ x) βΞΌ = |(R ^ finrank β E)β»ΒΉ| β’ β« (x : E), f x βΞΌ",
" β« (x : E), f (0 β’ x) βΞΌ = |(0 ^ finrank β E)β»ΒΉ| β’ β« (x : E), f x βΞΌ",
" (ΞΌ univ).toReal β’ f 0 = |(0 ^ finrank β E)β»ΒΉ| β’ β« (x : E), f x βΞΌ",
" f = fun x => f 0",
" f x = f 0",
"E : Type u_1\ninstββ· : NormedAddCommGrou... |
import Mathlib.Analysis.NormedSpace.BoundedLinearMaps
import Mathlib.Topology.FiberBundle.Basic
#align_import topology.vector_bundle.basic from "leanprover-community/mathlib"@"e473c3198bb41f68560cab68a0529c854b618833"
noncomputable section
open scoped Classical
open Bundle Set
open scoped Topology
variable (R : ... | Mathlib/Topology/VectorBundle/Basic.lean | 131 | 133 | theorem linearMapAt_apply (e : Pretrivialization F (Ο F E)) [e.IsLinear R] {b : B} (y : E b) :
e.linearMapAt R b y = if b β e.baseSet then (e β¨b, yβ©).2 else 0 := by |
rw [coe_linearMapAt]
| [
" F ββ[R] E b",
" IsLinearMap R (e.symm b)",
" IsLinearMap R 0",
" { toFun := fun y => (βe { proj := b, snd := y }).2, map_add' := β―, map_smul' := β― }.toFun (e.symm b v) = v",
" β(Pretrivialization.linearMapAt R e b) = fun y => if b β e.baseSet then (βe { proj := b, snd := y }).2 else 0",
" β(if hb : b β ... | [
" F ββ[R] E b",
" IsLinearMap R (e.symm b)",
" IsLinearMap R 0",
" { toFun := fun y => (βe { proj := b, snd := y }).2, map_add' := β―, map_smul' := β― }.toFun (e.symm b v) = v",
" β(Pretrivialization.linearMapAt R e b) = fun y => if b β e.baseSet then (βe { proj := b, snd := y }).2 else 0",
" β(if hb : b β ... |
import Mathlib.Data.Matrix.Basis
import Mathlib.Data.Matrix.DMatrix
import Mathlib.LinearAlgebra.Matrix.Determinant.Basic
import Mathlib.LinearAlgebra.Matrix.Reindex
import Mathlib.Tactic.FieldSimp
#align_import linear_algebra.matrix.transvection from "leanprover-community/mathlib"@"0e2aab2b0d521f060f62a14d2cf2e2c54e... | Mathlib/LinearAlgebra/Matrix/Transvection.lean | 205 | 207 | theorem inv_mul (t : TransvectionStruct n R) : t.inv.toMatrix * t.toMatrix = 1 := by |
rcases t with β¨_, _, t_hijβ©
simp [toMatrix, transvection_mul_transvection_same, t_hij]
| [
" transvection i j 0 = 1",
" updateRow 1 i (1 i + c β’ 1 j) = transvection i j c",
" updateRow 1 i (1 i + c β’ 1 j) a b = transvection i j c a b",
" transvection i j c * transvection i j d = transvection i j (c + d)",
" (transvection i j c * M) i b = M i b + c * M j b",
" (M * transvection i j c) a j = M a ... | [
" transvection i j 0 = 1",
" updateRow 1 i (1 i + c β’ 1 j) = transvection i j c",
" updateRow 1 i (1 i + c β’ 1 j) a b = transvection i j c a b",
" transvection i j c * transvection i j d = transvection i j (c + d)",
" (transvection i j c * M) i b = M i b + c * M j b",
" (M * transvection i j c) a j = M a ... |
import Mathlib.Algebra.Field.Defs
import Mathlib.Algebra.GroupWithZero.Units.Lemmas
import Mathlib.Algebra.Ring.Commute
import Mathlib.Algebra.Ring.Invertible
import Mathlib.Order.Synonym
#align_import algebra.field.basic from "leanprover-community/mathlib"@"05101c3df9d9cfe9430edc205860c79b6d660102"
open Function ... | Mathlib/Algebra/Field/Basic.lean | 122 | 122 | theorem neg_div' (a b : K) : -(b / a) = -b / a := by | simp [neg_div]
| [
" -1 * -1 = 1",
" 1 / -a = 1 / (-1 * a)",
" 1 / (-1 * a) = 1 / a * (1 / -1)",
" 1 / a * (1 / -1) = 1 / a * -1",
" 1 / a * -1 = -(1 / a)",
" b / -a = b * (1 / -a)",
" b * (1 / -a) = b * -(1 / a)",
" b * -(1 / a) = -(b * (1 / a))",
" -(b * (1 / a)) = -(b / a)",
" -b / a = -(b / a)",
" -(b / a) = -... | [
" -1 * -1 = 1",
" 1 / -a = 1 / (-1 * a)",
" 1 / (-1 * a) = 1 / a * (1 / -1)",
" 1 / a * (1 / -1) = 1 / a * -1",
" 1 / a * -1 = -(1 / a)",
" b / -a = b * (1 / -a)",
" b * (1 / -a) = b * -(1 / a)",
" b * -(1 / a) = -(b * (1 / a))",
" -(b * (1 / a)) = -(b / a)",
" -b / a = -(b / a)"
] |
import Mathlib.FieldTheory.Finiteness
import Mathlib.LinearAlgebra.Dimension.FreeAndStrongRankCondition
import Mathlib.LinearAlgebra.Dimension.DivisionRing
#align_import linear_algebra.finite_dimensional from "leanprover-community/mathlib"@"e95e4f92c8f8da3c7f693c3ec948bcf9b6683f51"
universe u v v' w
open Cardina... | Mathlib/LinearAlgebra/FiniteDimensional.lean | 123 | 126 | theorem finite_of_finite [Finite K] [FiniteDimensional K V] : Finite V := by |
cases nonempty_fintype K
haveI := fintypeOfFintype K V
infer_instance
| [
" _root_.Finite V"
] | [] |
import Mathlib.Analysis.NormedSpace.Multilinear.Basic
import Mathlib.LinearAlgebra.PiTensorProduct
universe uΞΉ uπ uE uF
variable {ΞΉ : Type uΞΉ} [Fintype ΞΉ]
variable {π : Type uπ} [NontriviallyNormedField π]
variable {E : ΞΉ β Type uE} [β i, SeminormedAddCommGroup (E i)] [β i, NormedSpace π (E i)]
variable {F : ... | Mathlib/Analysis/NormedSpace/PiTensorProduct/ProjectiveSeminorm.lean | 66 | 71 | theorem projectiveSeminormAux_add_le (p q : FreeAddMonoid (π Γ Ξ i, E i)) :
projectiveSeminormAux (p + q) β€ projectiveSeminormAux p + projectiveSeminormAux q := by |
simp only [projectiveSeminormAux, Function.comp_apply, Multiset.map_coe, Multiset.sum_coe]
erw [List.map_append]
rw [List.sum_append]
rfl
| [
" 0 β€ projectiveSeminormAux p",
" 0 β€ (List.map (fun p => βp.1β * β x : ΞΉ, βp.2 xβ) p).sum",
" β x β List.map (fun p => βp.1β * β x : ΞΉ, βp.2 xβ) p, 0 β€ x",
" a β List.map (fun p => βp.1β * β x : ΞΉ, βp.2 xβ) p β 0 β€ a",
" β (x : π) (x_1 : (i : ΞΉ) β E i), (x, x_1) β p β βxβ * β x : ΞΉ, βx_1 xβ = a β 0 β€ a",
... | [
" 0 β€ projectiveSeminormAux p",
" 0 β€ (List.map (fun p => βp.1β * β x : ΞΉ, βp.2 xβ) p).sum",
" β x β List.map (fun p => βp.1β * β x : ΞΉ, βp.2 xβ) p, 0 β€ x",
" a β List.map (fun p => βp.1β * β x : ΞΉ, βp.2 xβ) p β 0 β€ a",
" β (x : π) (x_1 : (i : ΞΉ) β E i), (x, x_1) β p β βxβ * β x : ΞΉ, βx_1 xβ = a β 0 β€ a",
... |
import Mathlib.CategoryTheory.Comma.Over
import Mathlib.CategoryTheory.Limits.Shapes.Pullbacks
import Mathlib.CategoryTheory.Yoneda
import Mathlib.Data.Set.Lattice
import Mathlib.Order.CompleteLattice
#align_import category_theory.sites.sieves from "leanprover-community/mathlib"@"239d882c4fb58361ee8b3b39fb2091320edef... | Mathlib/CategoryTheory/Sites/Sieves.lean | 104 | 109 | theorem singleton_eq_iff_domain (f g : Y βΆ X) : singleton f g β f = g := by |
constructor
Β· rintro β¨a, rflβ©
rfl
Β· rintro rfl
apply singleton.mk
| [
" CompleteLattice (Presieve X)",
" CompleteLattice (β¦Y : Cβ¦ β Set (Y βΆ X))",
" singleton f g β f = g",
" singleton f g β f = g",
" f = f",
" f = g β singleton f g",
" singleton f f"
] | [
" CompleteLattice (Presieve X)",
" CompleteLattice (β¦Y : Cβ¦ β Set (Y βΆ X))"
] |
import Mathlib.Order.Filter.Cofinite
import Mathlib.Order.ZornAtoms
#align_import order.filter.ultrafilter from "leanprover-community/mathlib"@"8631e2d5ea77f6c13054d9151d82b83069680cb1"
universe u v
variable {Ξ± : Type u} {Ξ² : Type v} {Ξ³ : Type*}
open Set Filter Function
open scoped Classical
open Filter
inst... | Mathlib/Order/Filter/Ultrafilter.lean | 115 | 116 | theorem disjoint_iff_not_le {f : Ultrafilter Ξ±} {g : Filter Ξ±} : Disjoint (βf) g β Β¬βf β€ g := by |
rw [β inf_neBot_iff, neBot_iff, Ne, not_not, disjoint_iff]
| [
" { toFilter := f, neBot' := hβ, le_of_le := hβ } = { toFilter := g, neBot' := neBot'β, le_of_le := le_of_leβ }",
" (βf β g).NeBot",
" Disjoint (βf) g β Β¬βf β€ g"
] | [
" { toFilter := f, neBot' := hβ, le_of_le := hβ } = { toFilter := g, neBot' := neBot'β, le_of_le := le_of_leβ }",
" (βf β g).NeBot"
] |
import Mathlib.Analysis.Calculus.FDeriv.Basic
import Mathlib.Analysis.NormedSpace.OperatorNorm.NormedSpace
#align_import analysis.calculus.deriv.basic from "leanprover-community/mathlib"@"3bce8d800a6f2b8f63fe1e588fd76a9ff4adcebe"
universe u v w
noncomputable section
open scoped Classical Topology Filter ENNReal ... | Mathlib/Analysis/Calculus/Deriv/Basic.lean | 201 | 203 | theorem hasStrictFDerivAt_iff_hasStrictDerivAt {f' : π βL[π] F} :
HasStrictFDerivAt f f' x β HasStrictDerivAt f (f' 1) x := by |
simp [HasStrictDerivAt, HasStrictFDerivAt]
| [
" HasFDerivAtFilter f f' x L β HasDerivAtFilter f (f' 1) x L",
" HasStrictFDerivAt f f' x β HasStrictDerivAt f (f' 1) x"
] | [
" HasFDerivAtFilter f f' x L β HasDerivAtFilter f (f' 1) x L"
] |
import Mathlib.Topology.ContinuousOn
#align_import topology.algebra.order.left_right from "leanprover-community/mathlib"@"bcfa726826abd57587355b4b5b7e78ad6527b7e4"
open Set Filter Topology
section TopologicalSpace
variable {Ξ± Ξ² : Type*} [TopologicalSpace Ξ±] [LinearOrder Ξ±] [TopologicalSpace Ξ²]
theorem nhds_lef... | Mathlib/Topology/Order/LeftRight.lean | 115 | 116 | theorem nhds_left'_sup_nhds_right (a : Ξ±) : π[<] a β π[β₯] a = π a := by |
rw [β nhdsWithin_union, Iio_union_Ici, nhdsWithin_univ]
| [
" π[β€] a β π[β₯] a = π a",
" π[<] a β π[β₯] a = π a"
] | [
" π[β€] a β π[β₯] a = π a"
] |
import Mathlib.Algebra.CharP.Invertible
import Mathlib.Algebra.MvPolynomial.Variables
import Mathlib.Algebra.MvPolynomial.CommRing
import Mathlib.Algebra.MvPolynomial.Expand
import Mathlib.Data.Fintype.BigOperators
import Mathlib.Data.ZMod.Basic
#align_import ring_theory.witt_vector.witt_polynomial from "leanprover-c... | Mathlib/RingTheory/WittVector/WittPolynomial.lean | 170 | 181 | theorem wittPolynomial_vars [CharZero R] (n : β) : (wittPolynomial p R n).vars = range (n + 1) := by |
have : β i, (monomial (Finsupp.single i (p ^ (n - i))) ((p : R) ^ i)).vars = {i} := by
intro i
refine vars_monomial_single i (pow_ne_zero _ hp.1) ?_
rw [β Nat.cast_pow, Nat.cast_ne_zero]
exact pow_ne_zero i hp.1
rw [wittPolynomial, vars_sum_of_disjoint]
Β· simp only [this, biUnion_singleton_eq_sel... | [
" wittPolynomial p R n = β i β range (n + 1), C (βp ^ i) * X i ^ p ^ (n - i)",
" β x β range (n + 1), (monomial (single x (p ^ (n - x)))) (βp ^ x) = C (βp ^ x) * X x ^ p ^ (n - x)",
" (monomial (single i (p ^ (n - i)))) (βp ^ i) = C (βp ^ i) * X i ^ p ^ (n - i)",
" X i ^ 0 = 1",
" (map f) (W_ R n) = W_ S n"... | [
" wittPolynomial p R n = β i β range (n + 1), C (βp ^ i) * X i ^ p ^ (n - i)",
" β x β range (n + 1), (monomial (single x (p ^ (n - x)))) (βp ^ x) = C (βp ^ x) * X x ^ p ^ (n - x)",
" (monomial (single i (p ^ (n - i)))) (βp ^ i) = C (βp ^ i) * X i ^ p ^ (n - i)",
" X i ^ 0 = 1",
" (map f) (W_ R n) = W_ S n"... |
import Mathlib.Topology.Basic
#align_import topology.nhds_set from "leanprover-community/mathlib"@"f2ce6086713c78a7f880485f7917ea547a215982"
open Set Filter Topology
variable {X Y : Type*} [TopologicalSpace X] [TopologicalSpace Y] {f : Filter X}
{s t sβ sβ tβ tβ : Set X} {x : X}
theorem nhdsSet_diagonal (X) [T... | Mathlib/Topology/NhdsSet.lean | 60 | 61 | theorem disjoint_nhdsSet_principal : Disjoint (πΛ’ s) (π t) β Disjoint s (closure t) := by |
rw [disjoint_comm, disjoint_principal_nhdsSet, disjoint_comm]
| [
" πΛ’ (diagonal X) = β¨ x, π (x, x)",
" sSup (range (π β fun x => (x, x))) = β¨ x, π (x, x)",
" s β πΛ’ t β β x β t, s β π x",
" πΛ’ s β€ f β β x β s, π x β€ f",
" s β interior t β t β πΛ’ s",
" Disjoint (π s) (πΛ’ t) β Disjoint (closure s) t",
" Disjoint (πΛ’ s) (π t) β Disjoint s (closure t)"
] | [
" πΛ’ (diagonal X) = β¨ x, π (x, x)",
" sSup (range (π β fun x => (x, x))) = β¨ x, π (x, x)",
" s β πΛ’ t β β x β t, s β π x",
" πΛ’ s β€ f β β x β s, π x β€ f",
" s β interior t β t β πΛ’ s",
" Disjoint (π s) (πΛ’ t) β Disjoint (closure s) t"
] |
import Mathlib.Topology.Separation
open Topology Filter Set TopologicalSpace
section Basic
variable {Ξ± : Type*} [TopologicalSpace Ξ±] {C : Set Ξ±}
theorem AccPt.nhds_inter {x : Ξ±} {U : Set Ξ±} (h_acc : AccPt x (π C)) (hU : U β π x) :
AccPt x (π (U β© C)) := by
have : π[β ] x β€ π U := by
rw [le_princ... | Mathlib/Topology/Perfect.lean | 120 | 128 | theorem Preperfect.perfect_closure (hC : Preperfect C) : Perfect (closure C) := by |
constructor; Β· exact isClosed_closure
intro x hx
by_cases h : x β C <;> apply AccPt.mono _ (principal_mono.mpr subset_closure)
Β· exact hC _ h
have : {x}αΆ β© C = C := by simp [h]
rw [AccPt, nhdsWithin, inf_assoc, inf_principal, this]
rw [closure_eq_cluster_pts] at hx
exact hx
| [
" AccPt x (π (U β© C))",
" π[β ] x β€ π U",
" U β π[β ] x",
" (π[β ] x β π C).NeBot",
" Preperfect C β β x β C, β U β π x, β y β U β© C, y β x",
" Preperfect (U β© C)",
" U β π x",
" Perfect (closure C)",
" IsClosed (closure C)",
" Preperfect (closure C)",
" AccPt x (π (closure C))",
" AccPt... | [
" AccPt x (π (U β© C))",
" π[β ] x β€ π U",
" U β π[β ] x",
" (π[β ] x β π C).NeBot",
" Preperfect C β β x β C, β U β π x, β y β U β© C, y β x",
" Preperfect (U β© C)",
" U β π x"
] |
import Mathlib.Logic.Relation
import Mathlib.Data.List.Forall2
import Mathlib.Data.List.Lex
import Mathlib.Data.List.Infix
#align_import data.list.chain from "leanprover-community/mathlib"@"dd71334db81d0bd444af1ee339a29298bef40734"
-- Make sure we haven't imported `Data.Nat.Order.Basic`
assert_not_exists OrderedSu... | Mathlib/Data/List/Chain.lean | 62 | 65 | theorem chain_split {a b : Ξ±} {lβ lβ : List Ξ±} :
Chain R a (lβ ++ b :: lβ) β Chain R a (lβ ++ [b]) β§ Chain R b lβ := by |
induction' lβ with x lβ IH generalizing a <;>
simp only [*, nil_append, cons_append, Chain.nil, chain_cons, and_true_iff, and_assoc]
| [
" Chain (fun x y => x β a :: l β§ y β l β§ R x y) a l",
" Chain (fun x y => x β [aβ] β§ y β [] β§ R x y) aβ []",
" Chain (fun x y => x β a :: b :: l β§ y β b :: l β§ R x y) a (b :: l)",
" a β a :: b :: l β§ b β b :: l β§ R a b",
" Chain (fun x y => x β a :: b :: l β§ y β b :: l β§ R x y) b l",
" Chain R a [b] β R a... | [
" Chain (fun x y => x β a :: l β§ y β l β§ R x y) a l",
" Chain (fun x y => x β [aβ] β§ y β [] β§ R x y) aβ []",
" Chain (fun x y => x β a :: b :: l β§ y β b :: l β§ R x y) a (b :: l)",
" a β a :: b :: l β§ b β b :: l β§ R a b",
" Chain (fun x y => x β a :: b :: l β§ y β b :: l β§ R x y) b l",
" Chain R a [b] β R a... |
import Mathlib.Algebra.Module.Equiv
import Mathlib.Data.DFinsupp.Basic
import Mathlib.Data.Finsupp.Basic
#align_import data.finsupp.to_dfinsupp from "leanprover-community/mathlib"@"59694bd07f0a39c5beccba34bd9f413a160782bf"
variable {ΞΉ : Type*} {R : Type*} {M : Type*}
section Defs
def Finsupp.toDFinsupp [Zer... | Mathlib/Data/Finsupp/ToDFinsupp.lean | 97 | 99 | theorem toDFinsupp_support (f : ΞΉ ββ M) : f.toDFinsupp.support = f.support := by |
ext
simp
| [
" (single i m).toDFinsupp = DFinsupp.single i m",
" (single i m).toDFinsupp iβ = (DFinsupp.single i m) iβ",
" f.toDFinsupp.support = f.support",
" aβ β f.toDFinsupp.support β aβ β f.support"
] | [
" (single i m).toDFinsupp = DFinsupp.single i m",
" (single i m).toDFinsupp iβ = (DFinsupp.single i m) iβ"
] |
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 | 274 | 276 | theorem mapAlg_eq_map (p : R[X]) : mapAlg R S p = map (algebraMap R S) p := by |
simp only [mapAlg, aeval_def, evalβ_eq_sum, map, algebraMap_apply, RingHom.coe_comp]
ext; congr
| [
" 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.Data.Finset.Card
#align_import data.finset.option from "leanprover-community/mathlib"@"c227d107bbada5d0d9d20287e3282c0a7f1651a0"
variable {Ξ± Ξ² : Type*}
open Function
namespace Finset
def insertNone : Finset Ξ± βͺo Finset (Option Ξ±) :=
(OrderEmbedding.ofMapLEIff fun s => cons none (s.map Embeddi... | Mathlib/Data/Finset/Option.lean | 87 | 87 | theorem card_insertNone (s : Finset Ξ±) : s.insertNone.card = s.card + 1 := by | simp [insertNone]
| [
" none β map Embedding.some s",
" cons none (map Embedding.some s) β― β€ cons none (map Embedding.some t) β― β s β€ t",
" a β s",
" some a = none β¨ some a β (map Embedding.some s).val β β a_1 β some a, a_1 β s",
" (β a β insertNone s, p a) β p none β§ β a β s, p (some a)",
" some a β insertNone s β a β s",
"... | [
" none β map Embedding.some s",
" cons none (map Embedding.some s) β― β€ cons none (map Embedding.some t) β― β s β€ t",
" a β s",
" some a = none β¨ some a β (map Embedding.some s).val β β a_1 β some a, a_1 β s",
" (β a β insertNone s, p a) β p none β§ β a β s, p (some a)",
" some a β insertNone s β a β s",
"... |
import Mathlib.Algebra.GCDMonoid.Multiset
import Mathlib.Combinatorics.Enumerative.Partition
import Mathlib.Data.List.Rotate
import Mathlib.GroupTheory.Perm.Cycle.Factors
import Mathlib.GroupTheory.Perm.Closure
import Mathlib.Algebra.GCDMonoid.Nat
import Mathlib.Tactic.NormNum.GCD
#align_import group_theory.perm.cycl... | Mathlib/GroupTheory/Perm/Cycle/Type.lean | 94 | 98 | theorem two_le_of_mem_cycleType {Ο : Perm Ξ±} {n : β} (h : n β Ο.cycleType) : 2 β€ n := by |
simp only [cycleType_def, β Finset.mem_def, Function.comp_apply, Multiset.mem_map,
mem_cycleFactorsFinset_iff] at h
obtain β¨_, β¨hc, -β©, rflβ© := h
exact hc.two_le_card_support
| [
" Ο.cycleType = Multiset.map (Finset.card β support) s.val",
" Multiset.map (Finset.card β support) Ο.cycleFactorsFinset.val = Multiset.map (Finset.card β support) s.val",
" Ο.cycleFactorsFinset = s",
" (β f β s, f.IsCycle) β§ β (h : (βs).Pairwise Disjoint), s.noncommProd id β― = Ο",
" Ο.cycleType = β(List.ma... | [
" Ο.cycleType = Multiset.map (Finset.card β support) s.val",
" Multiset.map (Finset.card β support) Ο.cycleFactorsFinset.val = Multiset.map (Finset.card β support) s.val",
" Ο.cycleFactorsFinset = s",
" (β f β s, f.IsCycle) β§ β (h : (βs).Pairwise Disjoint), s.noncommProd id β― = Ο",
" Ο.cycleType = β(List.ma... |
import Mathlib.Order.ConditionallyCompleteLattice.Basic
import Mathlib.Order.RelIso.Basic
#align_import order.ord_continuous from "leanprover-community/mathlib"@"207cfac9fcd06138865b5d04f7091e46d9320432"
universe u v w x
variable {Ξ± : Type u} {Ξ² : Type v} {Ξ³ : Type w} {ΞΉ : Sort x}
open Function OrderDual Set
... | Mathlib/Order/OrdContinuous.lean | 135 | 137 | theorem map_iSup (hf : LeftOrdContinuous f) (g : ΞΉ β Ξ±) : f (β¨ i, g i) = β¨ i, f (g i) := by |
simp only [iSup, hf.map_sSup', β range_comp]
rfl
| [
" f (sSup s) = β¨ x β s, f x",
" f (β¨ i, g i) = β¨ i, f (g i)",
" sSup (range (f β fun i => g i)) = sSup (range fun i => f (g i))"
] | [
" f (sSup s) = β¨ x β s, f x"
] |
import Mathlib.Algebra.MvPolynomial.Basic
import Mathlib.RingTheory.Polynomial.Basic
import Mathlib.RingTheory.PrincipalIdealDomain
#align_import ring_theory.adjoin.fg from "leanprover-community/mathlib"@"c4658a649d216f57e99621708b09dcb3dcccbd23"
universe u v w
open Subsemiring Ring Submodule
open Pointwise
na... | Mathlib/RingTheory/Adjoin/FG.lean | 40 | 80 | theorem fg_trans (h1 : (adjoin R s).toSubmodule.FG) (h2 : (adjoin (adjoin R s) t).toSubmodule.FG) :
(adjoin R (s βͺ t)).toSubmodule.FG := by |
rcases fg_def.1 h1 with β¨p, hp, hp'β©
rcases fg_def.1 h2 with β¨q, hq, hq'β©
refine fg_def.2 β¨p * q, hp.mul hq, le_antisymm ?_ ?_β©
Β· rw [span_le, Set.mul_subset_iff]
intro x hx y hy
change x * y β adjoin R (s βͺ t)
refine Subalgebra.mul_mem _ ?_ ?_
Β· have : x β Subalgebra.toSubmodule (adjoin R s) :... | [
" (Subalgebra.toSubmodule (adjoin R (s βͺ t))).FG",
" span R (p * q) β€ Subalgebra.toSubmodule (adjoin R (s βͺ t))",
" β x β p, β y β q, x * y β β(Subalgebra.toSubmodule (adjoin R (s βͺ t)))",
" x * y β β(Subalgebra.toSubmodule (adjoin R (s βͺ t)))",
" x * y β adjoin R (s βͺ t)",
" x β adjoin R (s βͺ t)",
" x ... | [] |
import Mathlib.LinearAlgebra.Quotient
import Mathlib.Algebra.Category.ModuleCat.Basic
#align_import algebra.category.Module.epi_mono from "leanprover-community/mathlib"@"70fd9563a21e7b963887c9360bd29b2393e6225a"
universe v u
open CategoryTheory
namespace ModuleCat
variable {R : Type u} [Ring R] {X Y : ModuleCa... | Mathlib/Algebra/Category/ModuleCat/EpiMono.lean | 55 | 56 | theorem epi_iff_surjective : Epi f β Function.Surjective f := by |
rw [epi_iff_range_eq_top, LinearMap.range_eq_top]
| [
" Function.Injective βf",
" Mono f β Function.Injective βf",
" Epi f β Function.Surjective βf"
] | [
" Function.Injective βf",
" Mono f β Function.Injective βf"
] |
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 | 94 | 95 | theorem vonMangoldt_apply_prime {p : β} (hp : p.Prime) : Ξ p = Real.log p := by |
rw [vonMangoldt_apply, Prime.minFac_eq hp, if_pos hp.prime.isPrimePow]
| [
" (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"
] | [
" (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"
] |
import Mathlib.MeasureTheory.Function.SimpleFuncDenseLp
import Mathlib.MeasureTheory.Function.StronglyMeasurable.Basic
#align_import measure_theory.function.strongly_measurable.lp from "leanprover-community/mathlib"@"f2ce6086713c78a7f880485f7917ea547a215982"
open MeasureTheory Filter TopologicalSpace Function
op... | Mathlib/MeasureTheory/Function/StronglyMeasurable/Lp.lean | 40 | 54 | theorem Memβp.finStronglyMeasurable_of_stronglyMeasurable (hf : Memβp f p ΞΌ)
(hf_meas : StronglyMeasurable f) (hp_ne_zero : p β 0) (hp_ne_top : p β β) :
FinStronglyMeasurable f ΞΌ := by |
borelize G
haveI : SeparableSpace (Set.range f βͺ {0} : Set G) :=
hf_meas.separableSpace_range_union_singleton
let fs := SimpleFunc.approxOn f hf_meas.measurable (Set.range f βͺ {0}) 0 (by simp)
refine β¨fs, ?_, ?_β©
Β· have h_fs_Lp : β n, Memβp (fs n) p ΞΌ :=
SimpleFunc.memβp_approxOn_range hf_meas.meas... | [
" FinStronglyMeasurable f ΞΌ",
" 0 β Set.range f βͺ {0}",
" β (n : β), ΞΌ (support β(fs n)) < β€",
" β (x : Ξ±), Tendsto (fun n => β(fs n) x) atTop (π (f x))",
" Tendsto (fun n => β(fs n) x) atTop (π (f x))",
" f x β closure (Set.range f βͺ {0})",
" f x β Set.range f βͺ {0}"
] | [] |
import Mathlib.RingTheory.WittVector.Frobenius
import Mathlib.RingTheory.WittVector.Verschiebung
import Mathlib.RingTheory.WittVector.MulP
#align_import ring_theory.witt_vector.identities from "leanprover-community/mathlib"@"0798037604b2d91748f9b43925fb7570a5f3256c"
namespace WittVector
variable {p : β} {R : Typ... | Mathlib/RingTheory/WittVector/Identities.lean | 51 | 52 | theorem verschiebung_zmod (x : π (ZMod p)) : verschiebung x = x * p := by |
rw [β frobenius_verschiebung, frobenius_zmodp]
| [
" frobenius (verschiebung x) = x * βp",
" β (n : β), (ghostComponent n) (frobenius (verschiebung x)) = (ghostComponent n) (x * βp)",
" verschiebung x = x * βp"
] | [
" frobenius (verschiebung x) = x * βp",
" β (n : β), (ghostComponent n) (frobenius (verschiebung x)) = (ghostComponent n) (x * βp)"
] |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.