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.Data.Set.Pointwise.Basic
import Mathlib.Data.Set.MulAntidiagonal
#align_import data.finset.mul_antidiagonal from "leanprover-community/mathlib"@"0a0ec35061ed9960bf0e7ffb0335f44447b58977"
namespace Finset
open Pointwise
variable {Ξ± : Type*}
variable [OrderedCancelCommMonoid Ξ±] {s t : Set Ξ±} (hs : ... | Mathlib/Data/Finset/MulAntidiagonal.lean | 72 | 73 | theorem mem_mulAntidiagonal : x β mulAntidiagonal hs ht a β x.1 β s β§ x.2 β t β§ x.1 * x.2 = a := by |
simp only [mulAntidiagonal, Set.Finite.mem_toFinset, Set.mem_mulAntidiagonal]
| [
" x β mulAntidiagonal hs ht a β x.1 β s β§ x.2 β t β§ x.1 * x.2 = a"
] | [] |
import Mathlib.Analysis.SpecialFunctions.ImproperIntegrals
import Mathlib.Analysis.Calculus.ParametricIntegral
import Mathlib.MeasureTheory.Measure.Haar.NormedSpace
#align_import analysis.mellin_transform from "leanprover-community/mathlib"@"917c3c072e487b3cccdbfeff17e75b40e45f66cb"
open MeasureTheory Set Filter A... | Mathlib/Analysis/MellinTransform.lean | 64 | 75 | theorem MellinConvergent.comp_mul_left {f : β β E} {s : β} {a : β} (ha : 0 < a) :
MellinConvergent (fun t => f (a * t)) s β MellinConvergent f s := by |
have := integrableOn_Ioi_comp_mul_left_iff (fun t : β => (t : β) ^ (s - 1) β’ f t) 0 ha
rw [mul_zero] at this
have h1 : EqOn (fun t : β => (β(a * t) : β) ^ (s - 1) β’ f (a * t))
((a : β) ^ (s - 1) β’ fun t : β => (t : β) ^ (s - 1) β’ f (a * t)) (Ioi 0) := fun t ht β¦ by
simp only [ofReal_mul, mul_cpow_ofRea... | [
" MellinConvergent (fun t => c β’ f t) s",
" MellinConvergent (fun t => βt ^ a β’ f t) s β MellinConvergent f (s + a)",
" βt ^ (s - 1) β’ (fun t => βt ^ a β’ f t) t = βt ^ (s + a - 1) β’ f t",
" MellinConvergent (fun t => f t / a) s",
" MellinConvergent (fun t => f (a * t)) s β MellinConvergent f s",
" (fun t ... | [
" MellinConvergent (fun t => c β’ f t) s",
" MellinConvergent (fun t => βt ^ a β’ f t) s β MellinConvergent f (s + a)",
" βt ^ (s - 1) β’ (fun t => βt ^ a β’ f t) t = βt ^ (s + a - 1) β’ f t",
" MellinConvergent (fun t => f t / a) s"
] |
import Mathlib.RingTheory.HahnSeries.Multiplication
import Mathlib.RingTheory.PowerSeries.Basic
import Mathlib.Data.Finsupp.PWO
#align_import ring_theory.hahn_series from "leanprover-community/mathlib"@"a484a7d0eade4e1268f4fb402859b6686037f965"
set_option linter.uppercaseLean3 false
open Finset Function
open sco... | Mathlib/RingTheory/HahnSeries/PowerSeries.lean | 132 | 142 | theorem ofPowerSeries_X : ofPowerSeries Ξ R PowerSeries.X = single 1 1 := by |
ext n
simp only [single_coeff, ofPowerSeries_apply, RingHom.coe_mk]
split_ifs with hn
Β· rw [hn]
convert @embDomain_coeff β R _ _ Ξ _ _ _ 1 <;> simp
Β· rw [embDomain_notin_image_support]
simp only [not_exists, Set.mem_image, toPowerSeries_symm_apply_coeff, mem_support,
PowerSeries.coeff_X]
in... | [
" (fun f => { coeff := fun n => (PowerSeries.coeff R n) f, isPWO_support' := β― })\n ((fun f => PowerSeries.mk f.coeff) f) =\n f",
" ((fun f => { coeff := fun n => (PowerSeries.coeff R n) f, isPWO_support' := β― })\n ((fun f => PowerSeries.mk f.coeff) f)).coeff\n xβ =\n f.coeff xβ",
" (fu... | [
" (fun f => { coeff := fun n => (PowerSeries.coeff R n) f, isPWO_support' := β― })\n ((fun f => PowerSeries.mk f.coeff) f) =\n f",
" ((fun f => { coeff := fun n => (PowerSeries.coeff R n) f, isPWO_support' := β― })\n ((fun f => PowerSeries.mk f.coeff) f)).coeff\n xβ =\n f.coeff xβ",
" (fu... |
import Mathlib.Analysis.Complex.Basic
import Mathlib.FieldTheory.IntermediateField
import Mathlib.Topology.Algebra.Field
import Mathlib.Topology.Algebra.UniformRing
#align_import topology.instances.complex from "leanprover-community/mathlib"@"f0c8bf9245297a541f468be517f1bde6195105e9"
section ComplexSubfield
open... | Mathlib/Topology/Instances/Complex.lean | 50 | 116 | theorem Complex.uniformContinuous_ringHom_eq_id_or_conj (K : Subfield β) {Ο : K β+* β}
(hc : UniformContinuous Ο) : Ο.toFun = K.subtype β¨ Ο.toFun = conj β K.subtype := by |
letI : TopologicalDivisionRing β := TopologicalDivisionRing.mk
letI : TopologicalRing K.topologicalClosure :=
Subring.instTopologicalRing K.topologicalClosure.toSubring
set ΞΉ : K β K.topologicalClosure := β(Subfield.inclusion K.le_topologicalClosure)
have ui : UniformInducing ΞΉ :=
β¨by
erw [unifor... | [
" K = ofReal.fieldRange β¨ K = β€",
" βK = βofReal.fieldRange β¨ βK = ββ€",
" range ofReal' β βK",
" closure (range (ofReal' β Rat.cast)) β βK",
" closure (range (ofReal' β Rat.cast)) β closure βK",
" range (ofReal' β Rat.cast) β βK",
" (ofReal' β Rat.cast) wβ β βK",
" range ofReal' β closure (range (ofRe... | [
" K = ofReal.fieldRange β¨ K = β€",
" βK = βofReal.fieldRange β¨ βK = ββ€",
" range ofReal' β βK",
" closure (range (ofReal' β Rat.cast)) β βK",
" closure (range (ofReal' β Rat.cast)) β closure βK",
" range (ofReal' β Rat.cast) β βK",
" (ofReal' β Rat.cast) wβ β βK",
" range ofReal' β closure (range (ofRe... |
import Mathlib.Analysis.Convex.Side
import Mathlib.Geometry.Euclidean.Angle.Oriented.Rotation
import Mathlib.Geometry.Euclidean.Angle.Unoriented.Affine
#align_import geometry.euclidean.angle.oriented.affine from "leanprover-community/mathlib"@"46b633fd842bef9469441c0209906f6dddd2b4f5"
noncomputable section
open ... | Mathlib/Geometry/Euclidean/Angle/Oriented/Affine.lean | 65 | 65 | theorem oangle_self_right (pβ pβ : P) : β‘ pβ pβ pβ = 0 := by | simp [oangle]
| [
" ContinuousAt (fun y => β‘ y.1 y.2.1 y.2.2) x",
" (f x).1 β 0",
" (f x).2 β 0",
" β‘ pβ pβ pβ = 0",
" β‘ pβ pβ pβ = 0"
] | [
" ContinuousAt (fun y => β‘ y.1 y.2.1 y.2.2) x",
" (f x).1 β 0",
" (f x).2 β 0",
" β‘ pβ pβ pβ = 0"
] |
import Mathlib.Algebra.MvPolynomial.Derivation
import Mathlib.Algebra.MvPolynomial.Variables
#align_import data.mv_polynomial.pderiv from "leanprover-community/mathlib"@"2f5b500a507264de86d666a5f87ddb976e2d8de4"
noncomputable section
universe u v
namespace MvPolynomial
open Set Function Finsupp
variable {R : ... | Mathlib/Algebra/MvPolynomial/PDeriv.lean | 111 | 112 | theorem pderiv_monomial_single {i : Ο} {n : β} : pderiv i (monomial (single i n) a) =
monomial (single i (n - 1)) (a * n) := by | simp
| [
" pderiv i = mkDerivation R (Pi.single i 1)",
" mkDerivation R (Pi.single i 1) = mkDerivation R (Pi.single i 1)",
" (pderiv i) ((monomial s) a) = (monomial (s - single i 1)) (a * β(s i))",
" (s.sum fun a_1 b => (monomial (s - single a_1 1)) (a * βb) * Pi.single i 1 a_1) =\n (monomial (s - single i 1)) (a *... | [
" pderiv i = mkDerivation R (Pi.single i 1)",
" mkDerivation R (Pi.single i 1) = mkDerivation R (Pi.single i 1)",
" (pderiv i) ((monomial s) a) = (monomial (s - single i 1)) (a * β(s i))",
" (s.sum fun a_1 b => (monomial (s - single a_1 1)) (a * βb) * Pi.single i 1 a_1) =\n (monomial (s - single i 1)) (a *... |
import Mathlib.Data.Set.Prod
import Mathlib.Logic.Function.Conjugate
#align_import data.set.function from "leanprover-community/mathlib"@"996b0ff959da753a555053a480f36e5f264d4207"
variable {Ξ± Ξ² Ξ³ : Type*} {ΞΉ : Sort*} {Ο : Ξ± β Type*}
open Equiv Equiv.Perm Function
namespace Set
section Order
variable {s : Se... | Mathlib/Data/Set/Function.lean | 264 | 267 | theorem _root_.MonotoneOn.congr (hβ : MonotoneOn fβ s) (h : s.EqOn fβ fβ) : MonotoneOn fβ s := by |
intro a ha b hb hab
rw [β h ha, β h hb]
exact hβ ha hb hab
| [
" MonotoneOn fβ s",
" fβ a β€ fβ b",
" fβ a β€ fβ b"
] | [] |
import Mathlib.Data.Finset.Fin
import Mathlib.Data.Int.Order.Units
import Mathlib.GroupTheory.OrderOfElement
import Mathlib.GroupTheory.Perm.Support
import Mathlib.Logic.Equiv.Fintype
#align_import group_theory.perm.sign from "leanprover-community/mathlib"@"f694c7dead66f5d4c80f446c796a5aad14707f0e"
universe u v
o... | Mathlib/GroupTheory/Perm/Finite.lean | 111 | 129 | theorem perm_mapsTo_inl_iff_mapsTo_inr {m n : Type*} [Finite m] [Finite n] (Ο : Perm (Sum m n)) :
Set.MapsTo Ο (Set.range Sum.inl) (Set.range Sum.inl) β
Set.MapsTo Ο (Set.range Sum.inr) (Set.range Sum.inr) := by |
constructor <;>
( intro h
classical
rw [β perm_inv_mapsTo_iff_mapsTo] at h
intro x
cases' hx : Ο x with l r)
Β· rintro β¨a, rflβ©
obtain β¨y, hyβ© := h β¨l, rflβ©
rw [β hx, Ο.inv_apply_self] at hy
exact absurd hy Sum.inl_ne_inr
Β· rintro _; exact β¨r, rflβ©
Β· rintro _; exact... | [
" -1 β 1",
" fβ»ΒΉ y β s",
" fβ»ΒΉ y = y2",
" fβ»ΒΉ ((fun i x => f i) y2 hy2) = y2",
" Set.MapsTo (βfβ»ΒΉ) s s",
" Set.MapsTo (βΟ) (Set.range Sum.inl) (Set.range Sum.inl) β Set.MapsTo (βΟ) (Set.range Sum.inr) (Set.range Sum.inr)",
" Set.MapsTo (βΟ) (Set.range Sum.inl) (Set.range Sum.inl) β Set.MapsTo (βΟ) (Set.... | [
" -1 β 1",
" fβ»ΒΉ y β s",
" fβ»ΒΉ y = y2",
" fβ»ΒΉ ((fun i x => f i) y2 hy2) = y2",
" Set.MapsTo (βfβ»ΒΉ) s s"
] |
import Mathlib.Analysis.InnerProductSpace.Projection
import Mathlib.Geometry.Euclidean.PerpBisector
import Mathlib.Algebra.QuadraticDiscriminant
#align_import geometry.euclidean.basic from "leanprover-community/mathlib"@"2de9c37fa71dde2f1c6feff19876dd6a7b1519f0"
noncomputable section
open scoped Classical
open ... | Mathlib/Geometry/Euclidean/Basic.lean | 122 | 134 | theorem dist_smul_vadd_eq_dist {v : V} (pβ pβ : P) (hv : v β 0) (r : β) :
dist (r β’ v +α΅₯ pβ) pβ = dist pβ pβ β r = 0 β¨ r = -2 * βͺv, pβ -α΅₯ pββ« / βͺv, vβ« := by |
conv_lhs =>
rw [β mul_self_inj_of_nonneg dist_nonneg dist_nonneg, dist_smul_vadd_sq, β sub_eq_zero,
add_sub_assoc, dist_eq_norm_vsub V pβ pβ, β real_inner_self_eq_norm_mul_norm, sub_self]
have hvi : βͺv, vβ« β 0 := by simpa using hv
have hd : discrim βͺv, vβ« (2 * βͺv, pβ -α΅₯ pββ«) 0 = 2 * βͺv, pβ -α΅₯ pββ« * (2 ... | [
" dist p1 (midpoint β p1 p2) = dist p2 (midpoint β p1 p2)",
" βͺ(sβ.weightedVSub pβ) wβ, (sβ.weightedVSub pβ) wββ«_β =\n (-β iβ β sβ, β iβ β sβ, wβ iβ * wβ iβ * (dist (pβ iβ) (pβ iβ) * dist (pβ iβ) (pβ iβ))) / 2",
" (-β iβ β sβ,\n β iβ β sβ,\n wβ iβ * wβ iβ *\n (βpβ iβ -α΅₯ Class... | [
" dist p1 (midpoint β p1 p2) = dist p2 (midpoint β p1 p2)",
" βͺ(sβ.weightedVSub pβ) wβ, (sβ.weightedVSub pβ) wββ«_β =\n (-β iβ β sβ, β iβ β sβ, wβ iβ * wβ iβ * (dist (pβ iβ) (pβ iβ) * dist (pβ iβ) (pβ iβ))) / 2",
" (-β iβ β sβ,\n β iβ β sβ,\n wβ iβ * wβ iβ *\n (βpβ iβ -α΅₯ Class... |
import Mathlib.Analysis.Calculus.Deriv.Inv
import Mathlib.Analysis.Calculus.Deriv.Polynomial
import Mathlib.Analysis.SpecialFunctions.ExpDeriv
import Mathlib.Analysis.SpecialFunctions.PolynomialExp
#align_import analysis.calculus.bump_function_inner from "leanprover-community/mathlib"@"3bce8d800a6f2b8f63fe1e588fd76a9... | Mathlib/Analysis/SpecialFunctions/SmoothTransition.lean | 58 | 61 | theorem nonneg (x : β) : 0 β€ expNegInvGlue x := by |
cases le_or_gt x 0 with
| inl h => exact ge_of_eq (zero_of_nonpos h)
| inr h => exact le_of_lt (pos_of_pos h)
| [
" expNegInvGlue x = 0",
" 0 < expNegInvGlue x",
" 0 β€ expNegInvGlue x"
] | [
" expNegInvGlue x = 0",
" 0 < expNegInvGlue x"
] |
import Mathlib.Analysis.InnerProductSpace.Dual
import Mathlib.Analysis.InnerProductSpace.Orientation
import Mathlib.Data.Complex.Orientation
import Mathlib.Tactic.LinearCombination
#align_import analysis.inner_product_space.two_dim from "leanprover-community/mathlib"@"cd8fafa2fac98e1a67097e8a91ad9901cfde48af"
non... | Mathlib/Analysis/InnerProductSpace/TwoDim.lean | 105 | 105 | theorem areaForm_to_volumeForm (x y : E) : Ο x y = o.volumeForm ![x, y] := by | simp [areaForm]
| [
" E ββ[β] E ββ[β] β",
" (o.areaForm x) y = o.volumeForm ![x, y]"
] | [
" E ββ[β] E ββ[β] β"
] |
import Mathlib.Algebra.Polynomial.Roots
import Mathlib.Analysis.Asymptotics.AsymptoticEquivalent
import Mathlib.Analysis.Asymptotics.SpecificAsymptotics
#align_import analysis.special_functions.polynomials from "leanprover-community/mathlib"@"f2ce6086713c78a7f880485f7917ea547a215982"
open Filter Finset Asymptotic... | Mathlib/Analysis/SpecialFunctions/Polynomials.lean | 84 | 88 | theorem abs_tendsto_atTop (hdeg : 0 < P.degree) :
Tendsto (fun x => abs <| eval x P) atTop atTop := by |
rcases le_total 0 P.leadingCoeff with hP | hP
Β· exact tendsto_abs_atTop_atTop.comp (P.tendsto_atTop_of_leadingCoeff_nonneg hdeg hP)
Β· exact tendsto_abs_atBot_atTop.comp (P.tendsto_atBot_of_leadingCoeff_nonpos hdeg hP)
| [
" (fun x => eval x P) ~[atTop] fun x => P.leadingCoeff * x ^ P.natDegree",
" (fun x => β i β range P.natDegree, P.coeff i * x ^ i + P.coeff P.natDegree * x ^ P.natDegree) ~[atTop] fun x =>\n P.leadingCoeff * x ^ P.natDegree",
" Tendsto (fun x => eval x P) atTop atTop β 0 < P.degree β§ 0 β€ P.leadingCoeff",
"... | [
" (fun x => eval x P) ~[atTop] fun x => P.leadingCoeff * x ^ P.natDegree",
" (fun x => β i β range P.natDegree, P.coeff i * x ^ i + P.coeff P.natDegree * x ^ P.natDegree) ~[atTop] fun x =>\n P.leadingCoeff * x ^ P.natDegree",
" Tendsto (fun x => eval x P) atTop atTop β 0 < P.degree β§ 0 β€ P.leadingCoeff",
"... |
import Mathlib.RingTheory.Valuation.Basic
import Mathlib.NumberTheory.Padics.PadicNorm
import Mathlib.Analysis.Normed.Field.Basic
#align_import number_theory.padics.padic_numbers from "leanprover-community/mathlib"@"b9b2114f7711fec1c1e055d507f082f8ceb2c3b7"
noncomputable section
open scoped Classical
open Nat m... | Mathlib/NumberTheory/Padics/PadicNumbers.lean | 176 | 181 | theorem lift_index_left_left {f : PadicSeq p} (hf : Β¬f β 0) (v2 v3 : β) :
padicNorm p (f (stationaryPoint hf)) =
padicNorm p (f (max (stationaryPoint hf) (max v2 v3))) := by |
apply stationaryPoint_spec hf
Β· apply le_max_left
Β· exact le_rfl
| [
" padicNorm p (βf m) = padicNorm p (βf n)",
" False",
" f.norm = 0 β f β 0",
" f.norm = 0 β f β 0",
" f β 0",
" β i, β j β₯ i, padicNorm p (β(f - 0) j) < Ξ΅",
" β j β₯ stationaryPoint hf, padicNorm p (β(f - 0) j) < Ξ΅",
" padicNorm p (β(f - 0) j) < Ξ΅",
" f β 0 β f.norm = 0",
" f.norm = 0",
" padicNo... | [
" padicNorm p (βf m) = padicNorm p (βf n)",
" False",
" f.norm = 0 β f β 0",
" f.norm = 0 β f β 0",
" f β 0",
" β i, β j β₯ i, padicNorm p (β(f - 0) j) < Ξ΅",
" β j β₯ stationaryPoint hf, padicNorm p (β(f - 0) j) < Ξ΅",
" padicNorm p (β(f - 0) j) < Ξ΅",
" f β 0 β f.norm = 0",
" f.norm = 0",
" padicNo... |
import Mathlib.Algebra.Order.Floor
import Mathlib.Algebra.Order.Field.Power
import Mathlib.Data.Nat.Log
#align_import data.int.log from "leanprover-community/mathlib"@"1f0096e6caa61e9c849ec2adbd227e960e9dff58"
variable {R : Type*} [LinearOrderedSemifield R] [FloorSemiring R]
namespace Int
def log (b : β) (r : ... | Mathlib/Data/Int/Log.lean | 138 | 145 | theorem log_zpow {b : β} (hb : 1 < b) (z : β€) : log b ((b : R) ^ z : R) = z := by |
obtain β¨n, rfl | rflβ© := Int.eq_nat_or_neg z
Β· rw [log_of_one_le_right _ (one_le_zpow_of_nonneg _ <| Int.natCast_nonneg _), zpow_natCast, β
Nat.cast_pow, Nat.floor_natCast, Nat.log_pow hb]
exact mod_cast hb.le
Β· rw [log_of_right_le_one _ (zpow_le_one_of_nonpos _ <| neg_nonpos.mpr (Int.natCast_nonneg _)... | [
" log b r = -β(b.clog βrβ»ΒΉββ)",
" log b 1 = -β(b.clog β1β»ΒΉββ)",
" log b βn = β(b.log n)",
" log b β0 = β(b.log 0)",
" log b β(nβ + 1) = β(b.log (nβ + 1))",
" 1 β€ β(nβ + 1)",
" log b r = 0",
" βb ^ log b r β€ r",
" βb ^ β(b.log βrββ) β€ r",
" b ^ b.log βrββ β€ βrββ",
" (β(b ^ b.clog βrβ»ΒΉββ))β»ΒΉ β€ r",... | [
" log b r = -β(b.clog βrβ»ΒΉββ)",
" log b 1 = -β(b.clog β1β»ΒΉββ)",
" log b βn = β(b.log n)",
" log b β0 = β(b.log 0)",
" log b β(nβ + 1) = β(b.log (nβ + 1))",
" 1 β€ β(nβ + 1)",
" log b r = 0",
" βb ^ log b r β€ r",
" βb ^ β(b.log βrββ) β€ r",
" b ^ b.log βrββ β€ βrββ",
" (β(b ^ b.clog βrβ»ΒΉββ))β»ΒΉ β€ r",... |
import Mathlib.NumberTheory.NumberField.Basic
import Mathlib.RingTheory.FractionalIdeal.Norm
import Mathlib.RingTheory.FractionalIdeal.Operations
variable (K : Type*) [Field K] [NumberField K]
namespace NumberField
open scoped nonZeroDivisors
section Basis
open Module
-- This is necessary to avoid several time... | Mathlib/NumberTheory/NumberField/FractionalIdeal.lean | 87 | 90 | theorem mem_span_basisOfFractionalIdeal {I : (FractionalIdeal (π K)β° K)Λ£} {x : K} :
x β Submodule.span β€ (Set.range (basisOfFractionalIdeal K I)) β x β (I : Set K) := by |
rw [basisOfFractionalIdeal, (fractionalIdealBasis K I.1).ofIsLocalizedModule_span β β€β° _]
simp
| [
" Free β€ β₯βI",
" βI.den β 0",
" Module.Finite β€ β₯βI",
" IsUnit ((algebraMap β€ (End β€ K)) βx)",
" βx β 0",
" β x_1, x_1.2 β’ x = (ββ€ (ββI).subtype) x_1.1",
" β(Ideal.absNorm (βI).num) * (algebraMap (π K) K) a β (fun a => βa) β(βI).num",
" β(Ideal.absNorm (βI).num) * (algebraMap (π K) K) a β IsLocaliza... | [
" Free β€ β₯βI",
" βI.den β 0",
" Module.Finite β€ β₯βI",
" IsUnit ((algebraMap β€ (End β€ K)) βx)",
" βx β 0",
" β x_1, x_1.2 β’ x = (ββ€ (ββI).subtype) x_1.1",
" β(Ideal.absNorm (βI).num) * (algebraMap (π K) K) a β (fun a => βa) β(βI).num",
" β(Ideal.absNorm (βI).num) * (algebraMap (π K) K) a β IsLocaliza... |
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 | 206 | 211 | theorem prev_nat_zero : (ComplexShape.up β).prev 0 = 0 := by |
classical
refine dif_neg ?_
push_neg
intro
apply Nat.noConfusion
| [
" (ComplexShape.up β).prev 0 = 0",
" Β¬β i, (ComplexShape.up β).Rel i 0",
" β (i : β), Β¬(ComplexShape.up β).Rel i 0",
" Β¬(ComplexShape.up β).Rel iβ 0"
] | [] |
import Mathlib.LinearAlgebra.Contraction
#align_import linear_algebra.coevaluation from "leanprover-community/mathlib"@"d6814c584384ddf2825ff038e868451a7c956f31"
noncomputable section
section coevaluation
open TensorProduct FiniteDimensional
open TensorProduct
universe u v
variable (K : Type u) [Field K]
var... | Mathlib/LinearAlgebra/Coevaluation.lean | 47 | 54 | theorem coevaluation_apply_one :
(coevaluation K V) (1 : K) =
let bV := Basis.ofVectorSpace K V
β i : Basis.ofVectorSpaceIndex K V, bV i ββ[K] bV.coord i := by |
simp only [coevaluation, id]
rw [(Basis.singleton Unit K).constr_apply_fintype K]
simp only [Fintype.univ_punit, Finset.sum_const, one_smul, Basis.singleton_repr,
Basis.equivFun_apply, Basis.coe_ofVectorSpace, one_nsmul, Finset.card_singleton]
| [
" (coevaluation K V) 1 =\n let bV := Basis.ofVectorSpace K V;\n β i : β(Basis.ofVectorSpaceIndex K V), bV i ββ[K] bV.coord i",
" (((Basis.singleton Unit K).constr K) fun x =>\n β i : β(Basis.ofVectorSpaceIndex K V), (Basis.ofVectorSpace K V) i ββ[K] (Basis.ofVectorSpace K V).coord i)\n 1 =\n ... | [] |
import Mathlib.Order.Cover
import Mathlib.Order.Interval.Finset.Defs
#align_import data.finset.locally_finite from "leanprover-community/mathlib"@"442a83d738cb208d3600056c489be16900ba701d"
assert_not_exists MonoidWithZero
assert_not_exists Finset.sum
open Function OrderDual
open FinsetInterval
variable {ΞΉ Ξ± : T... | Mathlib/Order/Interval/Finset/Basic.lean | 67 | 68 | theorem nonempty_Ioc : (Ioc a b).Nonempty β a < b := by |
rw [β coe_nonempty, coe_Ioc, Set.nonempty_Ioc]
| [
" (Icc a b).Nonempty β a β€ b",
" (Ico a b).Nonempty β a < b",
" (Ioc a b).Nonempty β a < b"
] | [
" (Icc a b).Nonempty β a β€ b",
" (Ico a b).Nonempty β a < b"
] |
import Mathlib.Algebra.Order.ToIntervalMod
import Mathlib.Algebra.Ring.AddAut
import Mathlib.Data.Nat.Totient
import Mathlib.GroupTheory.Divisible
import Mathlib.Topology.Connected.PathConnected
import Mathlib.Topology.IsLocalHomeomorph
#align_import topology.instances.add_circle from "leanprover-community/mathlib"@"... | Mathlib/Topology/Instances/AddCircle.lean | 152 | 153 | theorem coe_eq_zero_iff {x : π} : (x : AddCircle p) = 0 β β n : β€, n β’ p = x := by |
simp [AddSubgroup.mem_zmultiples_iff]
| [
" βx = 0 β β n, n β’ p = x"
] | [] |
import Mathlib.Analysis.SpecialFunctions.ImproperIntegrals
import Mathlib.Analysis.Calculus.ParametricIntegral
import Mathlib.MeasureTheory.Measure.Haar.NormedSpace
#align_import analysis.mellin_transform from "leanprover-community/mathlib"@"917c3c072e487b3cccdbfeff17e75b40e45f66cb"
open MeasureTheory Set Filter A... | Mathlib/Analysis/MellinTransform.lean | 237 | 264 | theorem mellin_convergent_zero_of_isBigO {b : β} {f : β β β}
(hfc : AEStronglyMeasurable f <| volume.restrict (Ioi 0))
(hf : f =O[π[>] 0] (Β· ^ (-b))) {s : β} (hs : b < s) :
β c : β, 0 < c β§ IntegrableOn (fun t : β => t ^ (s - 1) * f t) (Ioc 0 c) := by |
obtain β¨d, _, hd'β© := hf.exists_pos
simp_rw [IsBigOWith, eventually_nhdsWithin_iff, Metric.eventually_nhds_iff, gt_iff_lt] at hd'
obtain β¨Ξ΅, hΞ΅, hΞ΅'β© := hd'
refine β¨Ξ΅, hΞ΅, integrableOn_Ioc_iff_integrableOn_Ioo.mpr β¨?_, ?_β©β©
Β· refine AEStronglyMeasurable.mul ?_ (hfc.mono_set Ioo_subset_Ioi_self)
refine (C... | [
" IntegrableOn (fun t => βt ^ (s - 1) β’ f t) T volume β IntegrableOn (fun t => t ^ (s.re - 1) * βf tβ) T volume",
" AEStronglyMeasurable (fun t => βt ^ (s - 1) β’ f t) (volume.restrict T)",
" β x β T, ContinuousAt (fun t => βt ^ (s - 1)) x",
" IntegrableOn (fun a => ββa ^ (s - 1) β’ f aβ) T volume β IntegrableO... | [
" IntegrableOn (fun t => βt ^ (s - 1) β’ f t) T volume β IntegrableOn (fun t => t ^ (s.re - 1) * βf tβ) T volume",
" AEStronglyMeasurable (fun t => βt ^ (s - 1) β’ f t) (volume.restrict T)",
" β x β T, ContinuousAt (fun t => βt ^ (s - 1)) x",
" IntegrableOn (fun a => ββa ^ (s - 1) β’ f aβ) T volume β IntegrableO... |
import Mathlib.Probability.Kernel.MeasurableIntegral
#align_import probability.kernel.composition from "leanprover-community/mathlib"@"3b92d54a05ee592aa2c6181a4e76b1bb7cc45d0b"
open MeasureTheory
open scoped ENNReal
namespace ProbabilityTheory
namespace kernel
variable {Ξ± Ξ² ΞΉ : Type*} {mΞ± : MeasurableSpace Ξ±}... | Mathlib/Probability/Kernel/Composition.lean | 93 | 96 | theorem compProdFun_empty (ΞΊ : kernel Ξ± Ξ²) (Ξ· : kernel (Ξ± Γ Ξ²) Ξ³) (a : Ξ±) :
compProdFun ΞΊ Ξ· a β
= 0 := by |
simp only [compProdFun, Set.mem_empty_iff_false, Set.setOf_false, measure_empty,
MeasureTheory.lintegral_const, zero_mul]
| [
" compProdFun ΞΊ Ξ· a β
= 0"
] | [] |
import Mathlib.Algebra.CharZero.Defs
import Mathlib.Algebra.Group.Hom.Defs
import Mathlib.Algebra.Order.Monoid.Canonical.Defs
import Mathlib.Algebra.Order.Monoid.OrderDual
import Mathlib.Algebra.Order.ZeroLEOne
import Mathlib.Data.Nat.Cast.Defs
import Mathlib.Order.WithBot
#align_import algebra.order.monoid.with_top ... | Mathlib/Algebra/Order/Monoid/WithTop.lean | 156 | 156 | theorem add_coe_eq_top_iff {x : WithTop Ξ±} {y : Ξ±} : x + y = β€ β x = β€ := by | simp
| [
" a + β€ = β€",
" β€ + β€ = β€",
" βaβ + β€ = β€",
" a + b = β€ β a = β€ β¨ b = β€",
" β€ + xβ = β€ β β€ = β€ β¨ xβ = β€",
" xβ + β€ = β€ β xβ = β€ β¨ β€ = β€",
" βa + βb = β€ β βa = β€ β¨ βb = β€",
" a + b < β€ β a < β€ β§ b < β€",
" β€ + b = βc β β a' b', βa' = β€ β§ βb' = b β§ a' + b' = c",
" βa + β€ = βc β β a' b', βa' = βa β§ βb... | [
" a + β€ = β€",
" β€ + β€ = β€",
" βaβ + β€ = β€",
" a + b = β€ β a = β€ β¨ b = β€",
" β€ + xβ = β€ β β€ = β€ β¨ xβ = β€",
" xβ + β€ = β€ β xβ = β€ β¨ β€ = β€",
" βa + βb = β€ β βa = β€ β¨ βb = β€",
" a + b < β€ β a < β€ β§ b < β€",
" β€ + b = βc β β a' b', βa' = β€ β§ βb' = b β§ a' + b' = c",
" βa + β€ = βc β β a' b', βa' = βa β§ βb... |
import Mathlib.CategoryTheory.Sites.Grothendieck
import Mathlib.CategoryTheory.Sites.Pretopology
import Mathlib.CategoryTheory.Limits.Lattice
import Mathlib.Topology.Sets.Opens
#align_import category_theory.sites.spaces from "leanprover-community/mathlib"@"b6fa3beb29f035598cf0434d919694c5e98091eb"
universe u
nam... | Mathlib/CategoryTheory/Sites/Spaces.lean | 92 | 95 | theorem pretopology_toGrothendieck :
Pretopology.toGrothendieck _ (Opens.pretopology T) = Opens.grothendieckTopology T := by |
rw [β pretopology_ofGrothendieck]
apply (Pretopology.gi (Opens T)).l_u_eq
| [
" β U f_1, (Sieve.pullback f S).arrows f_1 β§ y β U",
" (Sieve.pullback f S).arrows (homOfLE β―)",
" β U f, R.arrows f β§ x β U",
" β U f_1, Presieve.pullbackArrows f S f_1 β§ x β U",
" x β pullback g f",
" β U f, S.bind Ti f β§ x β U",
" Pretopology.ofGrothendieck (Opens T) (grothendieckTopology T) = pretop... | [
" β U f_1, (Sieve.pullback f S).arrows f_1 β§ y β U",
" (Sieve.pullback f S).arrows (homOfLE β―)",
" β U f, R.arrows f β§ x β U",
" β U f_1, Presieve.pullbackArrows f S f_1 β§ x β U",
" x β pullback g f",
" β U f, S.bind Ti f β§ x β U",
" Pretopology.ofGrothendieck (Opens T) (grothendieckTopology T) = pretop... |
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 | 33 | 35 | theorem range_coe : range (some : Ξ± β WithTop Ξ±) = Iio β€ := by |
ext x
rw [mem_Iio, WithTop.lt_top_iff_ne_top, mem_range, ne_top_iff_exists]
| [
" range some = Iio β€",
" x β range some β x β Iio β€"
] | [] |
import Mathlib.Algebra.Polynomial.Eval
#align_import data.polynomial.degree.lemmas from "leanprover-community/mathlib"@"728baa2f54e6062c5879a3e397ac6bac323e506f"
noncomputable section
open Polynomial
open Finsupp Finset
namespace Polynomial
universe u v w
variable {R : Type u} {S : Type v} {ΞΉ : Type w} {a b ... | Mathlib/Algebra/Polynomial/Degree/Lemmas.lean | 366 | 367 | theorem natDegree_mul_C (a0 : a β 0) : (p * C a).natDegree = p.natDegree := by |
simp only [natDegree, degree_mul_C a0]
| [
" (p * C a).degree = p.degree",
" (C a * p).degree = p.degree",
" (p * C a).natDegree = p.natDegree"
] | [
" (p * C a).degree = p.degree",
" (C a * p).degree = p.degree"
] |
import Mathlib.LinearAlgebra.Eigenspace.Basic
import Mathlib.FieldTheory.Minpoly.Field
#align_import linear_algebra.eigenspace.minpoly from "leanprover-community/mathlib"@"c3216069e5f9369e6be586ccbfcde2592b3cec92"
universe u v w
namespace Module
namespace End
open Polynomial FiniteDimensional
open scoped Poly... | Mathlib/LinearAlgebra/Eigenspace/Minpoly.lean | 46 | 51 | theorem ker_aeval_ring_hom'_unit_polynomial (f : End K V) (c : K[X]Λ£) :
LinearMap.ker (aeval f (c : K[X])) = β₯ := by |
rw [Polynomial.eq_C_of_degree_eq_zero (degree_coe_units c)]
simp only [aeval_def, evalβ_C]
apply ker_algebraMap_end
apply coeff_coe_units_zero_ne_zero c
| [
" f.eigenspace (-q.coeff 0 / q.leadingCoeff) =\n LinearMap.ker (q.leadingCoeff β’ f - (algebraMap K (End K V)) (-q.coeff 0))",
" q.leadingCoeff β 0",
" False",
" LinearMap.ker (q.leadingCoeff β’ f - (algebraMap K (End K V)) (-q.coeff 0)) =\n LinearMap.ker ((aeval f) (C q.leadingCoeff * X + C (q.coeff 0)))... | [
" f.eigenspace (-q.coeff 0 / q.leadingCoeff) =\n LinearMap.ker (q.leadingCoeff β’ f - (algebraMap K (End K V)) (-q.coeff 0))",
" q.leadingCoeff β 0",
" False",
" LinearMap.ker (q.leadingCoeff β’ f - (algebraMap K (End K V)) (-q.coeff 0)) =\n LinearMap.ker ((aeval f) (C q.leadingCoeff * X + C (q.coeff 0)))... |
import Mathlib.Algebra.Group.Hom.Defs
import Mathlib.Algebra.Group.Units
#align_import algebra.hom.units from "leanprover-community/mathlib"@"a07d750983b94c530ab69a726862c2ab6802b38c"
assert_not_exists MonoidWithZero
assert_not_exists DenselyOrdered
open Function
universe u v w
namespace Units
variable {Ξ± : Ty... | Mathlib/Algebra/Group/Units/Hom.lean | 94 | 94 | theorem map_id : map (MonoidHom.id M) = MonoidHom.id MΛ£ := by | ext; rfl
| [
" f βu * f u.inv = 1",
" f u.inv * f βu = 1",
" map (MonoidHom.id M) = MonoidHom.id MΛ£",
" β((map (MonoidHom.id M)) xβ) = β((MonoidHom.id MΛ£) xβ)"
] | [
" f βu * f u.inv = 1",
" f u.inv * f βu = 1"
] |
import Mathlib.MeasureTheory.Function.StronglyMeasurable.Basic
#align_import measure_theory.function.egorov from "leanprover-community/mathlib"@"f2ce6086713c78a7f880485f7917ea547a215982"
noncomputable section
open scoped Classical
open MeasureTheory NNReal ENNReal Topology
namespace MeasureTheory
open Set Filt... | Mathlib/MeasureTheory/Function/Egorov.lean | 50 | 52 | theorem mem_notConvergentSeq_iff [Preorder ΞΉ] {x : Ξ±} :
x β notConvergentSeq f g n j β β k β₯ j, 1 / (n + 1 : β) < dist (f k x) (g x) := by |
simp_rw [notConvergentSeq, Set.mem_iUnion, exists_prop, mem_setOf]
| [
" x β notConvergentSeq f g n j β β k β₯ j, 1 / (βn + 1) < dist (f k x) (g x)"
] | [] |
import Mathlib.MeasureTheory.Integral.SetToL1
#align_import measure_theory.integral.bochner from "leanprover-community/mathlib"@"48fb5b5280e7c81672afc9524185ae994553ebf4"
assert_not_exists Differentiable
noncomputable section
open scoped Topology NNReal ENNReal MeasureTheory
open Set Filter TopologicalSpace EN... | Mathlib/MeasureTheory/Integral/Bochner.lean | 181 | 182 | theorem weightedSMul_empty {m : MeasurableSpace Ξ±} (ΞΌ : Measure Ξ±) :
weightedSMul ΞΌ β
= (0 : F βL[β] F) := by | ext1 x; rw [weightedSMul_apply]; simp
| [
" (weightedSMul ΞΌ s) x = (ΞΌ s).toReal β’ x",
" weightedSMul 0 = 0",
" weightedSMul 0 xβ = 0 xβ",
" weightedSMul ΞΌ β
= 0",
" (weightedSMul ΞΌ β
) x = 0 x",
" (ΞΌ β
).toReal β’ x = 0 x"
] | [
" (weightedSMul ΞΌ s) x = (ΞΌ s).toReal β’ x",
" weightedSMul 0 = 0",
" weightedSMul 0 xβ = 0 xβ"
] |
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 IsSwap
va... | Mathlib/GroupTheory/Perm/Support.lean | 248 | 253 | theorem ne_and_ne_of_swap_mul_apply_ne_self {f : Perm Ξ±} {x y : Ξ±} (hy : (swap x (f x) * f) y β y) :
f y β y β§ y β x := by |
simp only [swap_apply_def, mul_apply, f.injective.eq_iff] at *
by_cases h : f y = x
Β· constructor <;> intro <;> simp_all only [if_true, eq_self_iff_true, not_true, Ne]
Β· split_ifs at hy with h h <;> try { simp [*] at * }
| [
" (ofSubtype (swap x y)) z = (swap βx βy) z",
" β((swap x y) β¨z, hzβ©) = if z = βx then βy else if z = βy then βx else z",
" β((swap x y) β¨z, hzβ©) = βy",
" β((swap x y) β¨z, hzβ©) = βx",
" β((swap x y) β¨z, hzβ©) = z",
" β¨z, hzβ© β x",
" β¨z, hzβ© β y",
" z β βx",
" False",
" p z",
" p βx",
" z β βy",... | [
" (ofSubtype (swap x y)) z = (swap βx βy) z",
" β((swap x y) β¨z, hzβ©) = if z = βx then βy else if z = βy then βx else z",
" β((swap x y) β¨z, hzβ©) = βy",
" β((swap x y) β¨z, hzβ©) = βx",
" β((swap x y) β¨z, hzβ©) = z",
" β¨z, hzβ© β x",
" β¨z, hzβ© β y",
" z β βx",
" False",
" p z",
" p βx",
" z β βy",... |
import Mathlib.Data.Rat.Cast.Defs
import Mathlib.Algebra.Field.Basic
#align_import data.rat.cast from "leanprover-community/mathlib"@"acebd8d49928f6ed8920e502a6c90674e75bd441"
namespace Rat
variable {Ξ± : Type*} [DivisionRing Ξ±]
-- Porting note: rewrote proof
@[simp]
theorem cast_inv_nat (n : β) : ((nβ»ΒΉ : β) : Ξ±... | Mathlib/Data/Rat/Cast/Lemmas.lean | 55 | 57 | theorem cast_ofScientific {K} [DivisionRing K] (m : β) (s : Bool) (e : β) :
(OfScientific.ofScientific m s e : β) = (OfScientific.ofScientific m s e : K) := by |
rw [β NNRat.cast_ofScientific (K := K), β NNRat.cast_ofScientific, cast_nnratCast]
| [
" β(βn)β»ΒΉ = (βn)β»ΒΉ",
" β(β0)β»ΒΉ = (β0)β»ΒΉ",
" β(β(n + 1))β»ΒΉ = (β(n + 1))β»ΒΉ",
" β(β(Int.ofNat n))β»ΒΉ = (β(Int.ofNat n))β»ΒΉ",
" β(β(Int.negSucc n))β»ΒΉ = (β(Int.negSucc n))β»ΒΉ",
" ββq = βq",
" β(βq.num / βq.den).num / β(βq.num / βq.den).den = βq.num / βq.den",
" 0 < βq.den",
" β(OfScientific.ofScientific m s... | [
" β(βn)β»ΒΉ = (βn)β»ΒΉ",
" β(β0)β»ΒΉ = (β0)β»ΒΉ",
" β(β(n + 1))β»ΒΉ = (β(n + 1))β»ΒΉ",
" β(β(Int.ofNat n))β»ΒΉ = (β(Int.ofNat n))β»ΒΉ",
" β(β(Int.negSucc n))β»ΒΉ = (β(Int.negSucc n))β»ΒΉ",
" ββq = βq",
" β(βq.num / βq.den).num / β(βq.num / βq.den).den = βq.num / βq.den",
" 0 < βq.den"
] |
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 | 117 | 123 | theorem normed_le_div_measure_closedBall_rIn (x : E) :
f.normed ΞΌ x β€ 1 / (ΞΌ (closedBall c f.rIn)).toReal := by |
rw [normed_def]
gcongr
Β· exact ENNReal.toReal_pos (measure_closedBall_pos _ _ f.rIn_pos).ne' measure_closedBall_lt_top.ne
Β· exact f.le_one
Β· exact f.measure_closedBall_le_integral ΞΌ
| [
" 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.Data.Fintype.Option
import Mathlib.Data.Fintype.Perm
import Mathlib.Data.Fintype.Prod
import Mathlib.GroupTheory.Perm.Sign
import Mathlib.Logic.Equiv.Option
#align_import group_theory.perm.option from "leanprover-community/mathlib"@"c3019c79074b0619edb4b27553a91b2e82242395"
open Equiv
@[simp]
theo... | Mathlib/GroupTheory/Perm/Option.lean | 76 | 77 | theorem Equiv.Perm.decomposeOption_symm_of_none_apply {Ξ± : Type*} [DecidableEq Ξ±] (e : Perm Ξ±)
(i : Option Ξ±) : Equiv.Perm.decomposeOption.symm (none, e) i = i.map e := by | simp
| [
" optionCongr (swap x y) = swap (some x) (some y)",
" aβ β (optionCongr (swap x y)) none β aβ β (swap (some x) (some y)) none",
" aβ β (optionCongr (swap x y)) (some i) β aβ β (swap (some x) (some y)) (some i)",
" Perm.sign (optionCongr e) = Perm.sign e",
" Perm.sign (optionCongr 1) = Perm.sign 1",
" β (f... | [
" optionCongr (swap x y) = swap (some x) (some y)",
" aβ β (optionCongr (swap x y)) none β aβ β (swap (some x) (some y)) none",
" aβ β (optionCongr (swap x y)) (some i) β aβ β (swap (some x) (some y)) (some i)",
" Perm.sign (optionCongr e) = Perm.sign e",
" Perm.sign (optionCongr 1) = Perm.sign 1",
" β (f... |
import Mathlib.Topology.Category.TopCat.Limits.Products
#align_import topology.category.Top.limits.pullbacks from "leanprover-community/mathlib"@"178a32653e369dce2da68dc6b2694e385d484ef1"
-- Porting note: every ML3 decl has an uppercase letter
set_option linter.uppercaseLean3 false
open TopologicalSpace
open Cat... | Mathlib/Topology/Category/TopCat/Limits/Pullbacks.lean | 103 | 105 | theorem pullbackIsoProdSubtype_inv_fst (f : X βΆ Z) (g : Y βΆ Z) :
(pullbackIsoProdSubtype f g).inv β« pullback.fst = pullbackFst f g := by |
simp [pullbackCone, pullbackIsoProdSubtype]
| [
" Continuous (Prod.fst β Subtype.val)",
" Continuous Prod.fst",
" Continuous Subtype.val",
" Continuous (Prod.snd β Subtype.val)",
" Continuous Prod.snd",
" pullbackFst f g β« f = pullbackSnd f g β« g",
" { toFun := fun x => (βx).1, continuous_toFun := β― } β« f = { toFun := fun x => (βx).2, continuous_toFu... | [
" Continuous (Prod.fst β Subtype.val)",
" Continuous Prod.fst",
" Continuous Subtype.val",
" Continuous (Prod.snd β Subtype.val)",
" Continuous Prod.snd",
" pullbackFst f g β« f = pullbackSnd f g β« g",
" { toFun := fun x => (βx).1, continuous_toFun := β― } β« f = { toFun := fun x => (βx).2, continuous_toFu... |
import Mathlib.Data.Finsupp.Basic
import Mathlib.Data.Finsupp.Order
#align_import data.finsupp.multiset from "leanprover-community/mathlib"@"59694bd07f0a39c5beccba34bd9f413a160782bf"
open Finset
variable {Ξ± Ξ² ΞΉ : Type*}
namespace Finsupp
def toMultiset : (Ξ± ββ β) β+ Multiset Ξ± where
toFun f := Finsupp.sum f... | Mathlib/Data/Finsupp/Multiset.lean | 71 | 79 | theorem toMultiset_map (f : Ξ± ββ β) (g : Ξ± β Ξ²) :
f.toMultiset.map g = toMultiset (f.mapDomain g) := by |
refine f.induction ?_ ?_
Β· rw [toMultiset_zero, Multiset.map_zero, mapDomain_zero, toMultiset_zero]
Β· intro a n f _ _ ih
rw [toMultiset_add, Multiset.map_add, ih, mapDomain_add, mapDomain_single,
toMultiset_single, toMultiset_add, toMultiset_single, β Multiset.coe_mapAddMonoidHom,
(Multiset.mapAd... | [
" toMultiset (single a n) = n β’ {a}",
" 0 β’ {a} = 0",
" toMultiset (β i β s, single i n) = n β’ s.val",
" Multiset.card (toMultiset f) = f.sum fun x => id",
" Multiset.map g (toMultiset f) = toMultiset (mapDomain g f)",
" Multiset.map g (toMultiset 0) = toMultiset (mapDomain g 0)",
" β (a : Ξ±) (b : β) (f... | [
" toMultiset (single a n) = n β’ {a}",
" 0 β’ {a} = 0",
" toMultiset (β i β s, single i n) = n β’ s.val",
" Multiset.card (toMultiset f) = f.sum fun x => id"
] |
import Mathlib.Data.Real.NNReal
import Mathlib.Tactic.GCongr.Core
#align_import analysis.normed.group.seminorm from "leanprover-community/mathlib"@"09079525fd01b3dda35e96adaa08d2f943e1648c"
open Set
open NNReal
variable {ΞΉ R R' E F G : Type*}
structure AddGroupSeminorm (G : Type*) [AddGroup G] where
-- Port... | Mathlib/Analysis/Normed/Group/Seminorm.lean | 148 | 150 | theorem map_sub_le_max : f (x - y) β€ max (f x) (f y) := by |
rw [sub_eq_add_neg, β NonarchAddGroupSeminormClass.map_neg_eq_map' f y]
exact map_add_le_max _ _ _
| [
" f (x - y) β€ max (f x) (f y)",
" f (x + -y) β€ max (f x) (f (-y))"
] | [] |
import Mathlib.Data.Complex.Module
import Mathlib.LinearAlgebra.Determinant
#align_import data.complex.determinant from "leanprover-community/mathlib"@"65ec59902eb17e4ab7da8d7e3d0bd9774d1b8b99"
namespace Complex
@[simp]
| Mathlib/Data/Complex/Determinant.lean | 24 | 26 | theorem det_conjAe : LinearMap.det conjAe.toLinearMap = -1 := by |
rw [β LinearMap.det_toMatrix basisOneI, toMatrix_conjAe, Matrix.det_fin_two_of]
simp
| [
" LinearMap.det conjAe.toLinearMap = -1",
" 1 * -1 - 0 * 0 = -1"
] | [] |
import Mathlib.Algebra.Associated
import Mathlib.Algebra.Order.Monoid.Unbundled.Pow
import Mathlib.Algebra.Ring.Int
import Mathlib.Data.Nat.Factorial.Basic
import Mathlib.Data.Nat.GCD.Basic
import Mathlib.Order.Bounds.Basic
#align_import data.nat.prime from "leanprover-community/mathlib"@"8631e2d5ea77f6c13054d9151d82... | Mathlib/Data/Nat/Prime.lean | 147 | 153 | theorem prime_of_coprime (n : β) (h1 : 1 < n) (h : β m < n, m β 0 β n.Coprime m) : Prime n := by |
refine prime_def_lt.mpr β¨h1, fun m mlt mdvd => ?_β©
have hm : m β 0 := by
rintro rfl
rw [zero_dvd_iff] at mdvd
exact mlt.ne' mdvd
exact (h m mlt hm).symm.eq_one_of_dvd mdvd
| [
" m = 1 β¨ m = p",
" n = 1 β m = p",
" m = p",
" p.Prime β 2 β€ p β§ β (m : β), m β£ p β m = 1 β¨ m = p",
" p.Prime",
" IsUnit a β¨ IsUnit b",
" a = 1 β¨ b = 1",
" a = p β b = 1",
" b = 1",
" a β£ p",
" a β£ a * b",
" 1 < 2",
" m = 1",
" 0 = 1",
" 2 β€ 0 β 0 = 1",
" 0 + 1 = 1",
" m + 1 + 1 = 1... | [
" m = 1 β¨ m = p",
" n = 1 β m = p",
" m = p",
" p.Prime β 2 β€ p β§ β (m : β), m β£ p β m = 1 β¨ m = p",
" p.Prime",
" IsUnit a β¨ IsUnit b",
" a = 1 β¨ b = 1",
" a = p β b = 1",
" b = 1",
" a β£ p",
" a β£ a * b",
" 1 < 2",
" m = 1",
" 0 = 1",
" 2 β€ 0 β 0 = 1",
" 0 + 1 = 1",
" m + 1 + 1 = 1... |
import Mathlib.Analysis.Analytic.Basic
import Mathlib.Analysis.Complex.Basic
import Mathlib.Analysis.Normed.Field.InfiniteSum
import Mathlib.Data.Nat.Choose.Cast
import Mathlib.Data.Finset.NoncommProd
import Mathlib.Topology.Algebra.Algebra
#align_import analysis.normed_space.exponential from "leanprover-community/ma... | Mathlib/Analysis/NormedSpace/Exponential.lean | 155 | 157 | theorem exp_unop [T2Space πΈ] (x : πΈα΅α΅α΅) :
exp π (MulOpposite.unop x) = MulOpposite.unop (exp π x) := by |
simp_rw [exp, expSeries_sum_eq, β MulOpposite.unop_pow, β MulOpposite.unop_smul, tsum_unop]
| [
" ((expSeries π πΈ n) fun x_1 => x) = (βn !)β»ΒΉ β’ x ^ n",
" ((expSeries π πΈ n) fun x => 0) = Pi.single 0 1 n",
" (βn !)β»ΒΉ β’ 0 ^ n = Pi.single 0 1 n",
" (β0!)β»ΒΉ β’ 0 ^ 0 = Pi.single 0 1 0",
" (β(n + 1)!)β»ΒΉ β’ 0 ^ (n + 1) = Pi.single 0 1 (n + 1)",
" exp π 0 = 1",
" exp π (MulOpposite.op x) = MulOpposite... | [
" ((expSeries π πΈ n) fun x_1 => x) = (βn !)β»ΒΉ β’ x ^ n",
" ((expSeries π πΈ n) fun x => 0) = Pi.single 0 1 n",
" (βn !)β»ΒΉ β’ 0 ^ n = Pi.single 0 1 n",
" (β0!)β»ΒΉ β’ 0 ^ 0 = Pi.single 0 1 0",
" (β(n + 1)!)β»ΒΉ β’ 0 ^ (n + 1) = Pi.single 0 1 (n + 1)",
" exp π 0 = 1",
" exp π (MulOpposite.op x) = MulOpposite... |
import Mathlib.LinearAlgebra.TensorProduct.Basic
import Mathlib.RingTheory.Finiteness
open scoped TensorProduct
open Submodule
variable {R M N : Type*}
variable [CommSemiring R] [AddCommMonoid M] [AddCommMonoid N] [Module R M] [Module R N]
variable {Mβ Mβ : Submodule R M} {Nβ Nβ : Submodule R N}
namespace Tens... | Mathlib/LinearAlgebra/TensorProduct/Finiteness.lean | 52 | 60 | theorem exists_multiset (x : M β[R] N) :
β S : Multiset (M Γ N), x = (S.map fun i β¦ i.1 ββ[R] i.2).sum := by |
induction x using TensorProduct.induction_on with
| zero => exact β¨0, by simpβ©
| tmul x y => exact β¨{(x, y)}, by simpβ©
| add x y hx hy =>
obtain β¨Sx, hxβ© := hx
obtain β¨Sy, hyβ© := hy
exact β¨Sx + Sy, by rw [Multiset.map_add, Multiset.sum_add, hx, hy]β©
| [
" β S, x = (Multiset.map (fun i => i.1 ββ[R] i.2) S).sum",
" β S, 0 = (Multiset.map (fun i => i.1 ββ[R] i.2) S).sum",
" 0 = (Multiset.map (fun i => i.1 ββ[R] i.2) 0).sum",
" β S, x ββ[R] y = (Multiset.map (fun i => i.1 ββ[R] i.2) S).sum",
" x ββ[R] y = (Multiset.map (fun i => i.1 ββ[R] i.2) {(x, y)}).sum",
... | [] |
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 | 132 | 144 | theorem preperfect_iff_perfect_closure [T1Space Ξ±] : Preperfect C β Perfect (closure C) := by |
constructor <;> intro h
Β· exact h.perfect_closure
intro x xC
have H : AccPt x (π (closure C)) := h.acc _ (subset_closure xC)
rw [accPt_iff_frequently] at *
have : β y, y β x β§ y β closure C β βαΆ z in π y, z β x β§ z β C := by
rintro y β¨hyx, yCβ©
simp only [β mem_compl_singleton_iff, and_comm, β fre... | [
" 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",
" Perfect (closure C)",
" IsClosed (closure C)",
" Preperfect (closure C)",
" AccPt x (π (closure C))",
" AccPt... |
import Mathlib.Algebra.Polynomial.Degree.Lemmas
open Polynomial
namespace Mathlib.Tactic.ComputeDegree
section recursion_lemmas
variable {R : Type*}
section semiring
variable [Semiring R]
theorem natDegree_C_le (a : R) : natDegree (C a) β€ 0 := (natDegree_C a).le
theorem natDegree_natCast_le (n : β) : natDeg... | Mathlib/Tactic/ComputeDegree.lean | 101 | 103 | theorem coeff_add_of_eq {n : β} {a b : R} {f g : R[X]}
(h_add_left : f.coeff n = a) (h_add_right : g.coeff n = b) :
(f + g).coeff n = a + b := by | subst βΉ_βΊ βΉ_βΊ; apply coeff_add
| [
" (f + g).coeff n = a + b",
" (f + g).coeff n = f.coeff n + g.coeff n"
] | [] |
import Mathlib.MeasureTheory.Constructions.Pi
import Mathlib.MeasureTheory.Constructions.Prod.Integral
open Fintype MeasureTheory MeasureTheory.Measure
variable {π : Type*} [RCLike π]
namespace MeasureTheory
theorem Integrable.fin_nat_prod {n : β} {E : Fin n β Type*}
[β i, MeasureSpace (E i)] [β i, SigmaF... | Mathlib/MeasureTheory/Integral/Pi.lean | 95 | 98 | theorem integral_fintype_prod_eq_pow {E : Type*} (ΞΉ : Type*) [Fintype ΞΉ] (f : E β π)
[MeasureSpace E] [SigmaFinite (volume : Measure E)] :
β« x : ΞΉ β E, β i, f (x i) = (β« x, f x) ^ (card ΞΉ) := by |
rw [integral_fintype_prod_eq_prod, Finset.prod_const, card]
| [
" Integrable (fun x => β i : Fin n, f i (x i)) volume",
" Integrable (fun x => β i : Fin 0, f i (x i)) volume",
" Integrable (fun x => β i : Fin (n + 1), f i (x i)) volume",
" Integrable ((fun x => β i : Fin (n + 1), f i (x i)) β β(MeasurableEquiv.piFinSuccAbove (fun i => E i) 0).symm)\n (volume.prod (Meas... | [
" Integrable (fun x => β i : Fin n, f i (x i)) volume",
" Integrable (fun x => β i : Fin 0, f i (x i)) volume",
" Integrable (fun x => β i : Fin (n + 1), f i (x i)) volume",
" Integrable ((fun x => β i : Fin (n + 1), f i (x i)) β β(MeasurableEquiv.piFinSuccAbove (fun i => E i) 0).symm)\n (volume.prod (Meas... |
import Mathlib.Analysis.Calculus.Deriv.Basic
import Mathlib.Analysis.Calculus.Deriv.Slope
import Mathlib.Analysis.NormedSpace.FiniteDimension
import Mathlib.MeasureTheory.Constructions.BorelSpace.ContinuousLinearMap
import Mathlib.MeasureTheory.Function.StronglyMeasurable.Basic
#align_import analysis.calculus.fderiv_... | Mathlib/Analysis/Calculus/FDeriv/Measurable.lean | 144 | 145 | theorem isOpen_B {K : Set (E βL[π] F)} {r s Ξ΅ : β} : IsOpen (B f K r s Ξ΅) := by |
simp [B, isOpen_biUnion, IsOpen.inter, isOpen_A]
| [
" IsOpen (A f L r Ξ΅)",
" β x β A f L r Ξ΅, β Ξ΅_1 > 0, ball x Ξ΅_1 β A f L r Ξ΅",
" β Ξ΅_1 > 0, ball x Ξ΅_1 β A f L r Ξ΅",
" r' - s > 0",
" β y β ball x' s, β z β ball x' s, βf z - f y - L (z - y)β < Ξ΅ * r",
" βf z - f y - L (z - y)β < Ξ΅ * r",
" IsOpen (B f K r s Ξ΅)"
] | [
" IsOpen (A f L r Ξ΅)",
" β x β A f L r Ξ΅, β Ξ΅_1 > 0, ball x Ξ΅_1 β A f L r Ξ΅",
" β Ξ΅_1 > 0, ball x Ξ΅_1 β A f L r Ξ΅",
" r' - s > 0",
" β y β ball x' s, β z β ball x' s, βf z - f y - L (z - y)β < Ξ΅ * r",
" βf z - f y - L (z - y)β < Ξ΅ * r"
] |
import Mathlib.Algebra.Polynomial.Degree.Definitions
import Mathlib.Algebra.Polynomial.Eval
import Mathlib.Algebra.Polynomial.Monic
import Mathlib.Algebra.Polynomial.RingDivision
import Mathlib.Tactic.Abel
#align_import ring_theory.polynomial.pochhammer from "leanprover-community/mathlib"@"53b216bcc1146df1c4a0a868778... | Mathlib/RingTheory/Polynomial/Pochhammer.lean | 326 | 329 | theorem descPochhammer_succ_eval {S : Type*} [Ring S] (n : β) (k : S) :
(descPochhammer S (n + 1)).eval k = (descPochhammer S n).eval k * (k - n) := by |
rw [descPochhammer_succ_right, mul_sub, eval_sub, eval_mul_X, β Nat.cast_comm, β C_eq_natCast,
eval_C_mul, Nat.cast_comm, β mul_sub]
| [
" descPochhammer R 1 = X",
" descPochhammer R (n + 1) = X * (descPochhammer R n).comp (X - 1)",
" (descPochhammer R n).Monic",
" (descPochhammer R 0).Monic",
" (descPochhammer R (n + 1)).Monic",
" map f (descPochhammer R n) = descPochhammer T n",
" map f (descPochhammer R 0) = descPochhammer T 0",
" m... | [
" descPochhammer R 1 = X",
" descPochhammer R (n + 1) = X * (descPochhammer R n).comp (X - 1)",
" (descPochhammer R n).Monic",
" (descPochhammer R 0).Monic",
" (descPochhammer R (n + 1)).Monic",
" map f (descPochhammer R n) = descPochhammer T n",
" map f (descPochhammer R 0) = descPochhammer T 0",
" m... |
import Mathlib.Data.Fintype.Basic
import Mathlib.Data.Finset.Card
import Mathlib.Data.List.NodupEquivFin
import Mathlib.Data.Set.Image
#align_import data.fintype.card from "leanprover-community/mathlib"@"bf2428c9486c407ca38b5b3fb10b87dad0bc99fa"
assert_not_exists MonoidWithZero
assert_not_exists MulAction
open Fu... | Mathlib/Data/Fintype/Card.lean | 126 | 130 | theorem card_of_subtype {p : Ξ± β Prop} (s : Finset Ξ±) (H : β x : Ξ±, x β s β p x)
[Fintype { x // p x }] : card { x // p x } = s.card := by |
rw [β subtype_card s H]
congr
apply Subsingleton.elim
| [
" Trunc (Ξ± β Fin (card Ξ±))",
" Trunc (Ξ± β Fin (Multiset.card univ.val))",
" Trunc { f // Bijective f }",
" card { x // p x } = s.card",
" card { x // p x } = card { x // p x }",
" instβ = Fintype.subtype s H"
] | [
" Trunc (Ξ± β Fin (card Ξ±))",
" Trunc (Ξ± β Fin (Multiset.card univ.val))",
" Trunc { f // Bijective f }"
] |
import Mathlib.NumberTheory.LegendreSymbol.QuadraticChar.Basic
import Mathlib.NumberTheory.GaussSum
#align_import number_theory.legendre_symbol.quadratic_char.gauss_sum from "leanprover-community/mathlib"@"5b2fe80501ff327b9109fb09b7cc8c325cd0d7d9"
section SpecialValues
open ZMod MulChar
variable {F : Type*} ... | Mathlib/NumberTheory/LegendreSymbol/QuadraticChar/GaussSum.lean | 119 | 125 | theorem quadraticChar_odd_prime [DecidableEq F] (hF : ringChar F β 2) {p : β} [Fact p.Prime]
(hpβ : p β 2) (hpβ : ringChar F β p) :
quadraticChar F p = quadraticChar (ZMod p) (Οβ (Fintype.card F) * Fintype.card F) := by |
rw [β quadraticChar_neg_one hF]
have h := quadraticChar_card_card hF (ne_of_eq_of_ne (ringChar_zmod_n p) hpβ)
(ne_of_eq_of_ne (ringChar_zmod_n p) hpβ.symm)
rwa [card p] at h
| [
" IsSquare 2 β Fintype.card F % 8 β 3 β§ Fintype.card F % 8 β 5",
" Fintype.card F % 8 β 3 β§ Fintype.card F % 8 β 5",
" (if Fintype.card F % 2 = 0 then 0 else if Fintype.card F % 8 = 1 β¨ Fintype.card F % 8 = 7 then 1 else -1) = 1 β\n Fintype.card F % 8 β 3 β§ Fintype.card F % 8 β 5",
" -1 β 1",
" Fintype.c... | [
" IsSquare 2 β Fintype.card F % 8 β 3 β§ Fintype.card F % 8 β 5",
" Fintype.card F % 8 β 3 β§ Fintype.card F % 8 β 5",
" (if Fintype.card F % 2 = 0 then 0 else if Fintype.card F % 8 = 1 β¨ Fintype.card F % 8 = 7 then 1 else -1) = 1 β\n Fintype.card F % 8 β 3 β§ Fintype.card F % 8 β 5",
" -1 β 1",
" Fintype.c... |
import Mathlib.MeasureTheory.Integral.Lebesgue
import Mathlib.Topology.MetricSpace.ThickenedIndicator
open MeasureTheory Topology Metric Filter Set ENNReal NNReal
open scoped Topology ENNReal NNReal BoundedContinuousFunction
section auxiliary
namespace MeasureTheory
variable {Ξ© : Type*} [TopologicalSpace Ξ©] [Mea... | Mathlib/MeasureTheory/Measure/HasOuterApproxClosed.lean | 95 | 105 | theorem measure_of_cont_bdd_of_tendsto_indicator [OpensMeasurableSpace Ξ©]
(ΞΌ : Measure Ξ©) [IsFiniteMeasure ΞΌ] {c : ββ₯0} {E : Set Ξ©} (E_mble : MeasurableSet E)
(fs : β β Ξ© βα΅ ββ₯0) (fs_bdd : β n Ο, fs n Ο β€ c)
(fs_lim : Tendsto (fun n Ο β¦ fs n Ο) atTop (π (indicator E fun _ β¦ (1 : ββ₯0)))) :
Tendsto (fun ... |
have fs_lim' :
β Ο, Tendsto (fun n : β β¦ (fs n Ο : ββ₯0)) atTop (π (indicator E (fun _ β¦ (1 : ββ₯0)) Ο)) := by
rw [tendsto_pi_nhds] at fs_lim
exact fun Ο β¦ fs_lim Ο
apply measure_of_cont_bdd_of_tendsto_filter_indicator ΞΌ E_mble fs
(eventually_of_forall fun n β¦ eventually_of_forall (fs_bdd n)) (event... | [
" Tendsto (fun i => β«β» (Ο : Ξ©), β((fs i) Ο) βΞΌ) L (π (β«β» (Ο : Ξ©), β(f Ο) βΞΌ))",
" βαΆ (n : ΞΉ) in L, βα΅ (a : Ξ©) βΞΌ, β((fs n) a) β€ (fun x => βc) a",
" βα΅ (a : Ξ©) βΞΌ, Tendsto (fun n => β((fs n) a)) L (π β(f a))",
" Tendsto (fun n => β«β» (Ο : Ξ©), β((fs n) Ο) βΞΌ) L (π (ΞΌ E))",
" ΞΌ E = β«β» (Ο : Ξ©), β(E.indicator ... | [
" Tendsto (fun i => β«β» (Ο : Ξ©), β((fs i) Ο) βΞΌ) L (π (β«β» (Ο : Ξ©), β(f Ο) βΞΌ))",
" βαΆ (n : ΞΉ) in L, βα΅ (a : Ξ©) βΞΌ, β((fs n) a) β€ (fun x => βc) a",
" βα΅ (a : Ξ©) βΞΌ, Tendsto (fun n => β((fs n) a)) L (π β(f a))",
" Tendsto (fun n => β«β» (Ο : Ξ©), β((fs n) Ο) βΞΌ) L (π (ΞΌ E))",
" ΞΌ E = β«β» (Ο : Ξ©), β(E.indicator ... |
import Mathlib.Order.Interval.Finset.Nat
import Mathlib.Data.PNat.Defs
#align_import data.pnat.interval from "leanprover-community/mathlib"@"1d29de43a5ba4662dd33b5cfeecfc2a27a5a8a29"
open Finset Function PNat
namespace PNat
variable (a b : β+)
instance instLocallyFiniteOrder : LocallyFiniteOrder β+ := Subtype.... | Mathlib/Data/PNat/Interval.lean | 94 | 99 | theorem card_Ioo : (Ioo a b).card = b - a - 1 := by |
rw [β Nat.card_Ioo]
-- Porting note: I had to change this to `erw` *and* provide the proof, yuck.
-- https://github.com/leanprover-community/mathlib4/issues/5164
erw [β Finset.map_subtype_embedding_Ioo _ a b (fun c x _ hx _ hc _ => hc.trans_le hx)]
rw [card_map]
| [
" (Icc a b).card = βb + 1 - βa",
" (Icc a b).card = (Icc βa βb).card",
" (Icc a b).card = (map (Embedding.subtype fun n => 0 < n) (Icc a b)).card",
" (Ico a b).card = βb - βa",
" (Ico a b).card = (Ico βa βb).card",
" (Ico a b).card = (map (Embedding.subtype fun n => 0 < n) (Ico a b)).card",
" (Ioc a b).... | [
" (Icc a b).card = βb + 1 - βa",
" (Icc a b).card = (Icc βa βb).card",
" (Icc a b).card = (map (Embedding.subtype fun n => 0 < n) (Icc a b)).card",
" (Ico a b).card = βb - βa",
" (Ico a b).card = (Ico βa βb).card",
" (Ico a b).card = (map (Embedding.subtype fun n => 0 < n) (Ico a b)).card",
" (Ioc a b).... |
import Mathlib.RepresentationTheory.Action.Limits
import Mathlib.RepresentationTheory.Action.Concrete
import Mathlib.CategoryTheory.Monoidal.FunctorCategory
import Mathlib.CategoryTheory.Monoidal.Transport
import Mathlib.CategoryTheory.Monoidal.Rigid.OfEquivalence
import Mathlib.CategoryTheory.Monoidal.Rigid.FunctorCa... | Mathlib/RepresentationTheory/Action/Monoidal.lean | 82 | 85 | theorem associator_hom_hom {X Y Z : Action V G} :
Hom.hom (Ξ±_ X Y Z).hom = (Ξ±_ X.V Y.V Z.V).hom := by |
dsimp
simp
| [
" (Ξ±_ X Y Z).hom.hom = (Ξ±_ X.V Y.V Z.V).hom",
" (π (X.V β Y.V) β π Z.V) β« (Ξ±_ X.V Y.V Z.V).hom β« (π X.V β π (Y.V β Z.V)) = (Ξ±_ X.V Y.V Z.V).hom"
] | [] |
import Mathlib.Data.Bundle
import Mathlib.Data.Set.Image
import Mathlib.Topology.PartialHomeomorph
import Mathlib.Topology.Order.Basic
#align_import topology.fiber_bundle.trivialization from "leanprover-community/mathlib"@"e473c3198bb41f68560cab68a0529c854b618833"
open TopologicalSpace Filter Set Bundle Function
... | Mathlib/Topology/FiberBundle/Trivialization.lean | 141 | 142 | theorem mem_target {x : B Γ F} : x β e.target β x.1 β e.baseSet := by |
rw [e.target_eq, prod_univ, mem_preimage]
| [
" e = e'",
" { toPartialEquiv := toPartialEquivβ, open_target := open_targetβ, baseSet := baseSetβ, open_baseSet := open_baseSetβ,\n source_eq := source_eqβ, target_eq := target_eqβ, proj_toFun := proj_toFunβ } =\n e'",
" { toPartialEquiv := toPartialEquivβΒΉ, open_target := open_targetβΒΉ, baseSet := bas... | [
" e = e'",
" { toPartialEquiv := toPartialEquivβ, open_target := open_targetβ, baseSet := baseSetβ, open_baseSet := open_baseSetβ,\n source_eq := source_eqβ, target_eq := target_eqβ, proj_toFun := proj_toFunβ } =\n e'",
" { toPartialEquiv := toPartialEquivβΒΉ, open_target := open_targetβΒΉ, baseSet := bas... |
import Mathlib.Algebra.Polynomial.Splits
#align_import algebra.cubic_discriminant from "leanprover-community/mathlib"@"930133160e24036d5242039fe4972407cd4f1222"
noncomputable section
@[ext]
structure Cubic (R : Type*) where
(a b c d : R)
#align cubic Cubic
namespace Cubic
open Cubic Polynomial
open Polynom... | Mathlib/Algebra/CubicDiscriminant.lean | 458 | 459 | theorem map_toPoly : (map Ο P).toPoly = Polynomial.map Ο P.toPoly := by |
simp only [map, toPoly, map_C, map_X, Polynomial.map_add, Polynomial.map_mul, Polynomial.map_pow]
| [
" C w * (X - C x) * (X - C y) * (X - C z) =\n { a := w, b := w * -(x + y + z), c := w * (x * y + x * z + y * z), d := w * -(x * y * z) }.toPoly",
" C w * (X - C x) * (X - C y) * (X - C z) =\n C w * X ^ 3 + C w * -(C x + C y + C z) * X ^ 2 + C w * (C x * C y + C x * C z + C y * C z) * X +\n C w * -(C x ... | [
" C w * (X - C x) * (X - C y) * (X - C z) =\n { a := w, b := w * -(x + y + z), c := w * (x * y + x * z + y * z), d := w * -(x * y * z) }.toPoly",
" C w * (X - C x) * (X - C y) * (X - C z) =\n C w * X ^ 3 + C w * -(C x + C y + C z) * X ^ 2 + C w * (C x * C y + C x * C z + C y * C z) * X +\n C w * -(C x ... |
import Mathlib.Algebra.Algebra.Spectrum
import Mathlib.LinearAlgebra.GeneralLinearGroup
import Mathlib.LinearAlgebra.FiniteDimensional
import Mathlib.RingTheory.Nilpotent.Basic
#align_import linear_algebra.eigenspace.basic from "leanprover-community/mathlib"@"6b0169218d01f2837d79ea2784882009a0da1aa1"
universe u v... | Mathlib/LinearAlgebra/Eigenspace/Basic.lean | 69 | 69 | theorem eigenspace_zero (f : End R M) : f.eigenspace 0 = LinearMap.ker f := by | simp [eigenspace]
| [
" f.eigenspace 0 = LinearMap.ker f"
] | [] |
import Mathlib.Algebra.Polynomial.Monic
#align_import algebra.polynomial.big_operators from "leanprover-community/mathlib"@"47adfab39a11a072db552f47594bf8ed2cf8a722"
open Finset
open Multiset
open Polynomial
universe u w
variable {R : Type u} {ΞΉ : Type w}
namespace Polynomial
variable (s : Finset ΞΉ)
sectio... | Mathlib/Algebra/Polynomial/BigOperators.lean | 92 | 111 | theorem coeff_list_prod_of_natDegree_le (l : List S[X]) (n : β) (hl : β p β l, natDegree p β€ n) :
coeff (List.prod l) (l.length * n) = (l.map fun p => coeff p n).prod := by |
induction' l with hd tl IH
Β· simp
Β· have hl' : β p β tl, natDegree p β€ n := fun p hp => hl p (List.mem_cons_of_mem _ hp)
simp only [List.prod_cons, List.map, List.length]
rw [add_mul, one_mul, add_comm, β IH hl', mul_comm tl.length]
have h : natDegree tl.prod β€ n * tl.length := by
refine (natDe... | [
" natDegree 0 β€ 0",
" β (a : List S[X]), (Multiset.sum β¦aβ§).natDegree β€ foldr max β― 0 (Multiset.map natDegree β¦aβ§)",
" (β i β s, f i).natDegree β€ Finset.fold max 0 (natDegree β f) s",
" 0 β€ n β§ β x β s, (natDegree β f) x β€ n",
" l.sum.degree β€ (List.map natDegree l).maximum",
" βl.sum.natDegree β€ (List.ma... | [
" natDegree 0 β€ 0",
" β (a : List S[X]), (Multiset.sum β¦aβ§).natDegree β€ foldr max β― 0 (Multiset.map natDegree β¦aβ§)",
" (β i β s, f i).natDegree β€ Finset.fold max 0 (natDegree β f) s",
" 0 β€ n β§ β x β s, (natDegree β f) x β€ n",
" l.sum.degree β€ (List.map natDegree l).maximum",
" βl.sum.natDegree β€ (List.ma... |
import Mathlib.Algebra.BigOperators.Fin
import Mathlib.Algebra.Order.BigOperators.Group.Finset
import Mathlib.Data.Finset.Sort
import Mathlib.Data.Set.Subsingleton
#align_import combinatorics.composition from "leanprover-community/mathlib"@"92ca63f0fb391a9ca5f22d2409a6080e786d99f7"
open List
variable {n : β}
... | Mathlib/Combinatorics/Enumerative/Composition.lean | 252 | 252 | theorem boundary_zero : c.boundary 0 = 0 := by | simp [boundary, Fin.ext_iff]
| [
" β i : Fin c.length, c.blocksFun i = n",
"n : β c : Composition n | n",
" c.length β€ n",
" c.length β€ c.blocks.sum",
" 0 < c.length",
" 0 < c.blocks.sum",
" c.blocks.sum = n",
" c.sizeUpTo 0 = 0",
" c.sizeUpTo i = n",
" (take i c.blocks).sum = n",
" take i c.blocks = c.blocks",
" c.sizeUpTo i... | [
" β i : Fin c.length, c.blocksFun i = n",
"n : β c : Composition n | n",
" c.length β€ n",
" c.length β€ c.blocks.sum",
" 0 < c.length",
" 0 < c.blocks.sum",
" c.blocks.sum = n",
" c.sizeUpTo 0 = 0",
" c.sizeUpTo i = n",
" (take i c.blocks).sum = n",
" take i c.blocks = c.blocks",
" c.sizeUpTo i... |
import Mathlib.Algebra.Polynomial.Degree.Definitions
#align_import ring_theory.polynomial.opposites from "leanprover-community/mathlib"@"63417e01fbc711beaf25fa73b6edb395c0cfddd0"
open Polynomial
open Polynomial MulOpposite
variable {R : Type*} [Semiring R]
noncomputable section
namespace Polynomial
def opRi... | Mathlib/RingTheory/Polynomial/Opposites.lean | 57 | 59 | theorem opRingEquiv_op_C_mul_X_pow (r : R) (n : β) :
opRingEquiv R (op (C r * X ^ n : R[X])) = C (op r) * X ^ n := by |
simp only [X_pow_mul, op_mul, op_pow, map_mul, map_pow, opRingEquiv_op_X, opRingEquiv_op_C]
| [
" (opRingEquiv R) (op ((monomial n) r)) = (monomial n) (op r)",
" (opRingEquiv R) (op (C r * X ^ n)) = C (op r) * X ^ n"
] | [
" (opRingEquiv R) (op ((monomial n) r)) = (monomial n) (op r)"
] |
import Mathlib.Analysis.Analytic.Basic
import Mathlib.Combinatorics.Enumerative.Composition
#align_import analysis.analytic.composition from "leanprover-community/mathlib"@"ce11c3c2a285bbe6937e26d9792fda4e51f3fe1a"
noncomputable section
variable {π : Type*} {E F G H : Type*}
open Filter List
open scoped Topol... | Mathlib/Analysis/Analytic/Composition.lean | 131 | 134 | theorem removeZero_applyComposition (p : FormalMultilinearSeries π E F) {n : β}
(c : Composition n) : p.removeZero.applyComposition c = p.applyComposition c := by |
ext v i
simp [applyComposition, zero_lt_one.trans_le (c.one_le_blocksFun i), removeZero_of_pos]
| [
" p.applyComposition (Composition.ones n) = fun v i => (p 1) fun x => v (Fin.castLE β― i)",
" p.applyComposition (Composition.ones n) v i = (p 1) fun x => v (Fin.castLE β― i)",
" β (i_1 : β) (him : i_1 < (Composition.ones n).blocksFun i),\n i_1 < 1 β (v β β((Composition.ones n).embedding i)) β¨i_1, himβ© = v (Fi... | [
" p.applyComposition (Composition.ones n) = fun v i => (p 1) fun x => v (Fin.castLE β― i)",
" p.applyComposition (Composition.ones n) v i = (p 1) fun x => v (Fin.castLE β― i)",
" β (i_1 : β) (him : i_1 < (Composition.ones n).blocksFun i),\n i_1 < 1 β (v β β((Composition.ones n).embedding i)) β¨i_1, himβ© = v (Fi... |
import Mathlib.CategoryTheory.Sites.Sheaf
#align_import category_theory.sites.canonical from "leanprover-community/mathlib"@"9e7c80f638149bfb3504ba8ff48dfdbfc949fb1a"
universe v u
namespace CategoryTheory
open scoped Classical
open CategoryTheory Category Limits Sieve
variable {C : Type u} [Category.{v} C]
na... | Mathlib/CategoryTheory/Sites/Canonical.lean | 125 | 150 | theorem isSheafFor_trans (P : Cα΅α΅ β₯€ Type v) (R S : Sieve X)
(hR : Presieve.IsSheafFor P (R : Presieve X))
(hR' : β β¦Yβ¦ β¦f : Y βΆ Xβ¦ (_ : S f), Presieve.IsSeparatedFor P (R.pullback f : Presieve Y))
(hS : β β¦Yβ¦ β¦f : Y βΆ Xβ¦ (_ : R f), Presieve.IsSheafFor P (S.pullback f : Presieve Y)) :
Presieve.IsSheafFor... |
have : (bind R fun Y f _ => S.pullback f : Presieve X) β€ S := by
rintro Z f β¨W, f, g, hg, hf : S _, rflβ©
apply hf
apply Presieve.isSheafFor_subsieve_aux P this
Β· apply isSheafFor_bind _ _ _ hR hS
intro Y f hf Z g
rw [β pullback_comp]
apply (hS (R.downward_closed hf _)).isSeparatedFor
Β· intr... | [
" Presieve.IsSheafFor P (Sieve.bind U.arrows B).arrows",
" β! t, s.IsAmalgamation t",
" β β¦Y : Cβ¦ β¦f : Y βΆ Xβ¦ (hf : U.arrows f), (y hf).Compatible",
" P.map gβ.op (y H fβ hfβ) = P.map gβ.op (y H fβ hfβ)",
" gβ β« fβ β« f = gβ β« fβ β« f",
" t.Compatible",
" t.SieveCompatible",
" t (h β« f) β― = P.map h.op (... | [
" Presieve.IsSheafFor P (Sieve.bind U.arrows B).arrows",
" β! t, s.IsAmalgamation t",
" β β¦Y : Cβ¦ β¦f : Y βΆ Xβ¦ (hf : U.arrows f), (y hf).Compatible",
" P.map gβ.op (y H fβ hfβ) = P.map gβ.op (y H fβ hfβ)",
" gβ β« fβ β« f = gβ β« fβ β« f",
" t.Compatible",
" t.SieveCompatible",
" t (h β« f) β― = P.map h.op (... |
import Mathlib.Algebra.Module.Zlattice.Basic
import Mathlib.NumberTheory.NumberField.Embeddings
import Mathlib.NumberTheory.NumberField.FractionalIdeal
#align_import number_theory.number_field.canonical_embedding from "leanprover-community/mathlib"@"60da01b41bbe4206f05d34fd70c8dd7498717a30"
variable (K : Type*) [F... | Mathlib/NumberTheory/NumberField/CanonicalEmbedding/Basic.lean | 290 | 293 | theorem normAtPlace_apply_isComplex {w : InfinitePlace K} (hw : IsComplex w) (x : E K) :
normAtPlace w x = βx.2 β¨w, hwβ©β := by |
rw [normAtPlace, MonoidWithZeroHom.coe_mk, ZeroHom.coe_mk,
dif_neg (not_isReal_iff_isComplex.mpr hw)]
| [
" Nontrivial (({ w // w.IsReal } β β) Γ ({ w // w.IsComplex } β β))",
" finrank β (({ w // w.IsReal } β β) Γ ({ w // w.IsComplex } β β)) = finrank β K",
" Function.Injective β(mixedEmbedding K)",
" (fun x => if hw : w.IsReal then βx.1 β¨w, hwβ©β else βx.2 β¨w, β―β©β) 0 = 0",
" { toFun := fun x => if hw : w.IsRea... | [
" Nontrivial (({ w // w.IsReal } β β) Γ ({ w // w.IsComplex } β β))",
" finrank β (({ w // w.IsReal } β β) Γ ({ w // w.IsComplex } β β)) = finrank β K",
" Function.Injective β(mixedEmbedding K)",
" (fun x => if hw : w.IsReal then βx.1 β¨w, hwβ©β else βx.2 β¨w, β―β©β) 0 = 0",
" { toFun := fun x => if hw : w.IsRea... |
import Mathlib.Algebra.BigOperators.Group.Finset
import Mathlib.Data.Finset.NatAntidiagonal
import Mathlib.Data.Nat.GCD.Basic
import Mathlib.Init.Data.Nat.Lemmas
import Mathlib.Logic.Function.Iterate
import Mathlib.Tactic.Ring
import Mathlib.Tactic.Zify
#align_import data.nat.fib from "leanprover-community/mathlib"@"... | Mathlib/Data/Nat/Fib/Basic.lean | 121 | 124 | theorem fib_add_two_strictMono : StrictMono fun n => fib (n + 2) := by |
refine strictMono_nat_of_lt_succ fun n => ?_
rw [add_right_comm]
exact fib_lt_fib_succ (self_le_add_left _ _)
| [
" (n + 2).fib = n.fib + (n + 1).fib",
" n.fib β€ (n + 1).fib",
" fib 0 β€ (0 + 1).fib",
" (nβ + 1).fib β€ (nβ + 1 + 1).fib",
" (n + 2).fib = 0 β n + 2 = 0",
" 0 < n.fib β 0 < n",
" (n + 2).fib - (n + 1).fib = n.fib",
" n.fib < (n + 1).fib",
" (2 + n).fib < (2 + n + 1).fib",
" 0 < n + 1",
" StrictMo... | [
" (n + 2).fib = n.fib + (n + 1).fib",
" n.fib β€ (n + 1).fib",
" fib 0 β€ (0 + 1).fib",
" (nβ + 1).fib β€ (nβ + 1 + 1).fib",
" (n + 2).fib = 0 β n + 2 = 0",
" 0 < n.fib β 0 < n",
" (n + 2).fib - (n + 1).fib = n.fib",
" n.fib < (n + 1).fib",
" (2 + n).fib < (2 + n + 1).fib",
" 0 < n + 1"
] |
import Mathlib.Computability.Halting
#align_import computability.reduce from "leanprover-community/mathlib"@"d13b3a4a392ea7273dfa4727dbd1892e26cfd518"
universe u v w
open Function
def ManyOneReducible {Ξ± Ξ²} [Primcodable Ξ±] [Primcodable Ξ²] (p : Ξ± β Prop) (q : Ξ² β Prop) :=
β f, Computable f β§ β a, p a β q (f a... | Mathlib/Computability/Reduce.lean | 131 | 136 | theorem computable_of_manyOneReducible {p : Ξ± β Prop} {q : Ξ² β Prop} (hβ : p β€β q)
(hβ : ComputablePred q) : ComputablePred p := by |
rcases hβ with β¨f, c, hfβ©
rw [show p = fun a => q (f a) from Set.ext hf]
rcases computable_iff.1 hβ with β¨g, hg, rflβ©
exact β¨by infer_instance, by simpa using hg.comp cβ©
| [
" β (a : Ξ±), p a β p (id a)",
" r ((g β f) a)",
" p a",
" q β€β (q β βe)",
" q = (q β βe) β βe.symm",
" q xβ = ((q β βe) β βe.symm) xβ",
" ComputablePred p",
" ComputablePred fun a => q (f a)",
" ComputablePred fun a => (fun a => g a = true) (f a)",
" DecidablePred fun a => (fun a => g a = true) (f... | [
" β (a : Ξ±), p a β p (id a)",
" r ((g β f) a)",
" p a",
" q β€β (q β βe)",
" q = (q β βe) β βe.symm",
" q xβ = ((q β βe) β βe.symm) xβ"
] |
import Mathlib.Algebra.MvPolynomial.Equiv
import Mathlib.Algebra.MvPolynomial.Supported
import Mathlib.LinearAlgebra.LinearIndependent
import Mathlib.RingTheory.Adjoin.Basic
import Mathlib.RingTheory.Algebraic
import Mathlib.RingTheory.MvPolynomial.Basic
#align_import ring_theory.algebraic_independent from "leanprove... | Mathlib/RingTheory/AlgebraicIndependent.lean | 103 | 106 | theorem algebraMap_injective : Injective (algebraMap R A) := by |
simpa [Function.comp] using
(Injective.of_comp_iff (algebraicIndependent_iff_injective_aeval.1 hx) MvPolynomial.C).2
(MvPolynomial.C_injective _ _)
| [
" AlgebraicIndependent R x β Injective β(algebraMap R A)",
" aeval x = (ofId R A).comp β(isEmptyAlgEquiv R ΞΉ)",
" (aeval x) (X i) = ((ofId R A).comp β(isEmptyAlgEquiv R ΞΉ)) (X i)",
" Injective β((ofId R A).comp β(isEmptyAlgEquiv R ΞΉ)) β Injective (β(algebraMap R A) β β(isEmptyAlgEquiv R ΞΉ))",
" Injective β(... | [
" AlgebraicIndependent R x β Injective β(algebraMap R A)",
" aeval x = (ofId R A).comp β(isEmptyAlgEquiv R ΞΉ)",
" (aeval x) (X i) = ((ofId R A).comp β(isEmptyAlgEquiv R ΞΉ)) (X i)",
" Injective β((ofId R A).comp β(isEmptyAlgEquiv R ΞΉ)) β Injective (β(algebraMap R A) β β(isEmptyAlgEquiv R ΞΉ))"
] |
import Mathlib.CategoryTheory.Limits.Shapes.Biproducts
import Mathlib.GroupTheory.EckmannHilton
import Mathlib.Tactic.CategoryTheory.Reassoc
#align_import category_theory.preadditive.of_biproducts from "leanprover-community/mathlib"@"061ea99a5610cfc72c286aa930d3c1f47f74f3d0"
noncomputable section
universe v u
op... | Mathlib/CategoryTheory/Preadditive/OfBiproducts.lean | 71 | 85 | theorem isUnital_rightAdd : EckmannHilton.IsUnital (Β· +α΅£ Β·) 0 := by |
have hβ : β f : X βΆ Y, biprod.desc (0 : X βΆ Y) f = biprod.snd β« f := by
intro f
ext
Β· aesop_cat
Β· simp only [biprod.inr_desc, BinaryBicone.inr_snd_assoc]
have hβ : β f : X βΆ Y, biprod.desc f (0 : X βΆ Y) = biprod.fst β« f := by
intro f
ext
Β· aesop_cat
Β· simp only [biprod.inr_desc, Bin... | [
" EckmannHilton.IsUnital (fun x x_1 => leftAdd X Y x x_1) 0",
" β (f : X βΆ Y), biprod.lift 0 f = f β« biprod.inr",
" biprod.lift 0 f = f β« biprod.inr",
" biprod.lift 0 f β« biprod.fst = (f β« biprod.inr) β« biprod.fst",
" biprod.lift 0 f β« biprod.snd = (f β« biprod.inr) β« biprod.snd",
" β (f : X βΆ Y), biprod.l... | [
" EckmannHilton.IsUnital (fun x x_1 => leftAdd X Y x x_1) 0",
" β (f : X βΆ Y), biprod.lift 0 f = f β« biprod.inr",
" biprod.lift 0 f = f β« biprod.inr",
" biprod.lift 0 f β« biprod.fst = (f β« biprod.inr) β« biprod.fst",
" biprod.lift 0 f β« biprod.snd = (f β« biprod.inr) β« biprod.snd",
" β (f : X βΆ Y), biprod.l... |
import Mathlib.MeasureTheory.Measure.Dirac
set_option autoImplicit true
open Set
open scoped ENNReal Classical
variable [MeasurableSpace Ξ±] [MeasurableSpace Ξ²] {s : Set Ξ±}
noncomputable section
namespace MeasureTheory.Measure
def count : Measure Ξ± :=
sum dirac
#align measure_theory.measure.count MeasureTheo... | Mathlib/MeasureTheory/Measure/Count.lean | 62 | 65 | theorem count_apply_finite' {s : Set Ξ±} (s_fin : s.Finite) (s_mble : MeasurableSet s) :
count s = s_fin.toFinset.card := by |
simp [β
@count_apply_finset' _ _ s_fin.toFinset (by simpa only [Finite.coe_toFinset] using s_mble)]
| [
" count s = β' (i : βs), 1",
" count β
= 0",
" β i β s, 1 = βs.card",
" count s = βs_fin.toFinset.card",
" MeasurableSet βs_fin.toFinset"
] | [
" count s = β' (i : βs), 1",
" count β
= 0",
" β i β s, 1 = βs.card"
] |
import Mathlib.Algebra.Order.Invertible
import Mathlib.Algebra.Order.Module.OrderedSMul
import Mathlib.LinearAlgebra.AffineSpace.Midpoint
import Mathlib.LinearAlgebra.Ray
import Mathlib.Tactic.GCongr
#align_import analysis.convex.segment from "leanprover-community/mathlib"@"c5773405394e073885e2a144c9ca14637e8eb963"
... | Mathlib/Analysis/Convex/Segment.lean | 68 | 71 | theorem openSegment_eq_imageβ (x y : E) :
openSegment π x y =
(fun p : π Γ π => p.1 β’ x + p.2 β’ y) '' { p | 0 < p.1 β§ 0 < p.2 β§ p.1 + p.2 = 1 } := by |
simp only [openSegment, image, Prod.exists, mem_setOf_eq, exists_prop, and_assoc]
| [
" [x-[π]y] = (fun p => p.1 β’ x + p.2 β’ y) '' {p | 0 β€ p.1 β§ 0 β€ p.2 β§ p.1 + p.2 = 1}",
" openSegment π x y = (fun p => p.1 β’ x + p.2 β’ y) '' {p | 0 < p.1 β§ 0 < p.2 β§ p.1 + p.2 = 1}"
] | [
" [x-[π]y] = (fun p => p.1 β’ x + p.2 β’ y) '' {p | 0 β€ p.1 β§ 0 β€ p.2 β§ p.1 + p.2 = 1}"
] |
import Mathlib.Geometry.Euclidean.Angle.Oriented.Affine
import Mathlib.Geometry.Euclidean.Angle.Unoriented.Affine
import Mathlib.Tactic.IntervalCases
#align_import geometry.euclidean.triangle from "leanprover-community/mathlib"@"46b633fd842bef9469441c0209906f6dddd2b4f5"
noncomputable section
open scoped Classica... | Mathlib/Geometry/Euclidean/Triangle.lean | 71 | 75 | theorem angle_sub_eq_angle_sub_rev_of_norm_eq {x y : V} (h : βxβ = βyβ) :
angle x (x - y) = angle y (y - x) := by |
refine Real.injOn_cos β¨angle_nonneg _ _, angle_le_pi _ _β© β¨angle_nonneg _ _, angle_le_pi _ _β© ?_
rw [cos_angle, cos_angle, h, β neg_sub, norm_neg, neg_sub, inner_sub_right, inner_sub_right,
real_inner_self_eq_norm_mul_norm, real_inner_self_eq_norm_mul_norm, h, real_inner_comm x y]
| [
" βx - yβ * βx - yβ = βxβ * βxβ + βyβ * βyβ - 2 * βxβ * βyβ * (angle x y).cos",
" 2 * βxβ * βyβ * (angle x y).cos = 2 * ((angle x y).cos * (βxβ * βyβ))",
" angle x (x - y) = angle y (y - x)",
" (angle x (x - y)).cos = (angle y (y - x)).cos"
] | [
" βx - yβ * βx - yβ = βxβ * βxβ + βyβ * βyβ - 2 * βxβ * βyβ * (angle x y).cos",
" 2 * βxβ * βyβ * (angle x y).cos = 2 * ((angle x y).cos * (βxβ * βyβ))"
] |
import Mathlib.Geometry.Manifold.MFDeriv.Basic
noncomputable section
open scoped Manifold
variable {π : Type*} [NontriviallyNormedField π] {E : Type*} [NormedAddCommGroup E]
[NormedSpace π E] {E' : Type*} [NormedAddCommGroup E'] [NormedSpace π E'] {f : E β E'}
{s : Set E} {x : E}
section MFDerivFderiv
t... | Mathlib/Geometry/Manifold/MFDeriv/FDeriv.lean | 84 | 87 | theorem mdifferentiableAt_iff_differentiableAt :
MDifferentiableAt π(π, E) π(π, E') f x β DifferentiableAt π f x := by |
simp only [mdifferentiableAt_iff, differentiableWithinAt_univ, mfld_simps]
exact β¨fun H => H.2, fun H => β¨H.continuousAt, Hβ©β©
| [
" UniqueMDiffWithinAt π(π, E) s x β UniqueDiffWithinAt π s x",
" UniqueMDiffOn π(π, E) s β UniqueDiffOn π s",
" HasMFDerivWithinAt π(π, E) π(π, E') f s x f' β HasFDerivWithinAt f f' s x",
" HasMFDerivAt π(π, E) π(π, E') f x f' β HasFDerivAt f f' x",
" MDifferentiableWithinAt π(π, E) π(π, E... | [
" UniqueMDiffWithinAt π(π, E) s x β UniqueDiffWithinAt π s x",
" UniqueMDiffOn π(π, E) s β UniqueDiffOn π s",
" HasMFDerivWithinAt π(π, E) π(π, E') f s x f' β HasFDerivWithinAt f f' s x",
" HasMFDerivAt π(π, E) π(π, E') f x f' β HasFDerivAt f f' x",
" MDifferentiableWithinAt π(π, E) π(π, E... |
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 | 126 | 128 | theorem coe_linearMapAt_of_mem (e : Pretrivialization F (Ο F E)) [e.IsLinear R] {b : B}
(hb : b β e.baseSet) : β(e.linearMapAt R b) = fun y => (e β¨b, yβ©).2 := by |
simp_rw [coe_linearMapAt, if_pos hb]
| [
" 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.Normed.Group.Basic
import Mathlib.Topology.ContinuousFunction.CocompactMap
open Filter Metric
variable {π E F π : Type*}
variable [NormedAddCommGroup E] [NormedAddCommGroup F] [ProperSpace E] [ProperSpace F]
variable {f : π}
theorem CocompactMapClass.norm_le [FunLike π E F] [Cocompact... | Mathlib/Analysis/Normed/Group/CocompactMap.lean | 41 | 53 | theorem Filter.tendsto_cocompact_cocompact_of_norm {f : E β F}
(h : β Ξ΅ : β, β r : β, β x : E, r < βxβ β Ξ΅ < βf xβ) :
Tendsto f (cocompact E) (cocompact F) := by |
rw [tendsto_def]
intro s hs
rcases closedBall_compl_subset_of_mem_cocompact hs 0 with β¨Ξ΅, hΞ΅β©
rcases h Ξ΅ with β¨r, hrβ©
apply mem_cocompact_of_closedBall_compl_subset 0
use r
intro x hx
simp only [Set.mem_compl_iff, Metric.mem_closedBall, dist_zero_right, not_le] at hx
apply hΞ΅
simp [hr x hx]
| [
" β r, β (x : E), r < βxβ β Ξ΅ < βf xβ",
" β (x : E), r < βxβ β Ξ΅ < βf xβ",
" Ξ΅ < βf xβ",
" x β βf β»ΒΉ' (closedBall 0 Ξ΅)αΆ",
" x β (closedBall 0 r)αΆ",
" Tendsto f (cocompact E) (cocompact F)",
" β s β cocompact F, f β»ΒΉ' s β cocompact E",
" f β»ΒΉ' s β cocompact E",
" β r, (closedBall 0 r)αΆ β f β»ΒΉ' s",
... | [
" β r, β (x : E), r < βxβ β Ξ΅ < βf xβ",
" β (x : E), r < βxβ β Ξ΅ < βf xβ",
" Ξ΅ < βf xβ",
" x β βf β»ΒΉ' (closedBall 0 Ξ΅)αΆ",
" x β (closedBall 0 r)αΆ"
] |
import Mathlib.Algebra.DirectSum.Module
import Mathlib.Analysis.Complex.Basic
import Mathlib.Analysis.Convex.Uniform
import Mathlib.Analysis.NormedSpace.Completion
import Mathlib.Analysis.NormedSpace.BoundedLinearMaps
#align_import analysis.inner_product_space.basic from "leanprover-community/mathlib"@"3f655f5297b030... | Mathlib/Analysis/InnerProductSpace/Basic.lean | 220 | 221 | theorem inner_add_right (x y z : F) : βͺx, y + zβ« = βͺx, yβ« + βͺx, zβ« := by |
rw [β inner_conj_symm, inner_add_left, RingHom.map_add]; simp only [inner_conj_symm]
| [
" 0 β€ re βͺx, xβ«_π",
" 0 β€ βxβ ^ 2",
" βxβ ^ 2 = 0",
" im βͺx, xβ«_π = 0",
" I * ((starRingEnd π) βͺx, xβ«_π - βͺx, xβ«_π) / 2 = β0",
" βͺx, y + zβ«_π = βͺx, yβ«_π + βͺx, zβ«_π",
" (starRingEnd π) βͺy, xβ«_π + (starRingEnd π) βͺz, xβ«_π = βͺx, yβ«_π + βͺx, zβ«_π"
] | [
" 0 β€ re βͺx, xβ«_π",
" 0 β€ βxβ ^ 2",
" βxβ ^ 2 = 0",
" im βͺx, xβ«_π = 0",
" I * ((starRingEnd π) βͺx, xβ«_π - βͺx, xβ«_π) / 2 = β0"
] |
import Mathlib.LinearAlgebra.Dual
import Mathlib.LinearAlgebra.Matrix.ToLin
#align_import linear_algebra.contraction from "leanprover-community/mathlib"@"657df4339ae6ceada048c8a2980fb10e393143ec"
suppress_compilation
-- Porting note: universe metavariables behave oddly
universe w u vβ vβ vβ vβ
variable {ΞΉ : Type... | Mathlib/LinearAlgebra/Contraction.lean | 122 | 128 | theorem comp_dualTensorHom (f : Module.Dual R M) (n : N) (g : Module.Dual R N) (p : P) :
dualTensorHom R N P (g ββ[R] p) ββ dualTensorHom R M N (f ββ[R] n) =
g n β’ dualTensorHom R M P (f ββ p) := by |
ext m
simp only [coe_comp, Function.comp_apply, dualTensorHom_apply, LinearMap.map_smul,
RingHom.id_apply, LinearMap.smul_apply]
rw [smul_comm]
| [
" Dual.transpose ((dualTensorHom R M M) (f ββ[R] m)) =\n (dualTensorHom R (Dual R M) (Dual R M)) ((Dual.eval R M) m ββ[R] f)",
" ((Dual.transpose ((dualTensorHom R M M) (f ββ[R] m))) f') m' =\n (((dualTensorHom R (Dual R M) (Dual R M)) ((Dual.eval R M) m ββ[R] f)) f') m'",
" f m' * f' m = f' m * f m'",
... | [
" Dual.transpose ((dualTensorHom R M M) (f ββ[R] m)) =\n (dualTensorHom R (Dual R M) (Dual R M)) ((Dual.eval R M) m ββ[R] f)",
" ((Dual.transpose ((dualTensorHom R M M) (f ββ[R] m))) f') m' =\n (((dualTensorHom R (Dual R M) (Dual R M)) ((Dual.eval R M) m ββ[R] f)) f') m'",
" f m' * f' m = f' m * f m'",
... |
import Mathlib.AlgebraicTopology.SplitSimplicialObject
import Mathlib.AlgebraicTopology.DoldKan.Degeneracies
import Mathlib.AlgebraicTopology.DoldKan.FunctorN
#align_import algebraic_topology.dold_kan.split_simplicial_object from "leanprover-community/mathlib"@"32a7e535287f9c73f2e4d2aef306a39190f0b504"
open Categ... | Mathlib/AlgebraicTopology/DoldKan/SplitSimplicialObject.lean | 91 | 95 | theorem cofan_inj_comp_PInfty_eq_zero {X : SimplicialObject C} (s : SimplicialObject.Splitting X)
{n : β} (A : SimplicialObject.Splitting.IndexSet (op [n])) (hA : Β¬A.EqId) :
(s.cofan _).inj A β« PInfty.f n = 0 := by |
rw [SimplicialObject.Splitting.IndexSet.eqId_iff_mono] at hA
rw [SimplicialObject.Splitting.cofan_inj_eq, assoc, degeneracy_comp_PInfty X n A.e hA, comp_zero]
| [
" s.N B.fst.unop.len βΆ s.N A.fst.unop.len",
" s.N B.fst.unop.len = s.N A.fst.unop.len",
" s.N B.fst.unop.len = s.N B.fst.unop.len",
" (s.cofan Ξ).inj A β« s.ΟSummand A = π (summand s.N Ξ A)",
" (s.cofan Ξ).inj A β« s.ΟSummand B = 0",
" ((s.cofan Ξ).inj A β« s.desc Ξ fun B_1 => if h : B_1 = B then eqToHom β― ... | [
" s.N B.fst.unop.len βΆ s.N A.fst.unop.len",
" s.N B.fst.unop.len = s.N A.fst.unop.len",
" s.N B.fst.unop.len = s.N B.fst.unop.len",
" (s.cofan Ξ).inj A β« s.ΟSummand A = π (summand s.N Ξ A)",
" (s.cofan Ξ).inj A β« s.ΟSummand B = 0",
" ((s.cofan Ξ).inj A β« s.desc Ξ fun B_1 => if h : B_1 = B then eqToHom β― ... |
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 | 67 | 75 | theorem cycleType_eq {Ο : Perm Ξ±} (l : List (Perm Ξ±)) (h0 : l.prod = Ο)
(h1 : β Ο : Perm Ξ±, Ο β l β Ο.IsCycle) (h2 : l.Pairwise Disjoint) :
Ο.cycleType = l.map (Finset.card β support) := by |
have hl : l.Nodup := nodup_of_pairwise_disjoint_cycles h1 h2
rw [cycleType_eq' l.toFinset]
Β· simp [List.dedup_eq_self.mpr hl, (Β· β Β·)]
Β· simpa using h1
Β· simpa [hl] using h2
Β· simp [hl, h0]
| [
" Ο.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 β― = Ο"
] |
import Mathlib.Analysis.InnerProductSpace.Calculus
import Mathlib.Analysis.InnerProductSpace.PiL2
#align_import analysis.inner_product_space.euclidean_dist from "leanprover-community/mathlib"@"9425b6f8220e53b059f5a4904786c3c4b50fc057"
open scoped Topology
open Set
variable {E : Type*} [AddCommGroup E] [Topologi... | Mathlib/Analysis/InnerProductSpace/EuclideanDist.lean | 108 | 110 | theorem nhds_basis_closedBall {x : E} : (π x).HasBasis (fun r : β => 0 < r) (closedBall x) := by |
rw [toEuclidean.toHomeomorph.nhds_eq_comap x]
exact Metric.nhds_basis_closedBall.comap _
| [
" closedBall x r = βtoEuclidean.symm '' Metric.closedBall (toEuclidean x) r",
" IsCompact (closedBall x r)",
" IsCompact (βtoEuclidean.symm '' Metric.closedBall (toEuclidean x) r)",
" closure (ball x r) = closedBall x r",
" β r β Ioo 0 R, s β ball x r",
" (π x).HasBasis (fun r => 0 < r) (closedBall x)",
... | [
" closedBall x r = βtoEuclidean.symm '' Metric.closedBall (toEuclidean x) r",
" IsCompact (closedBall x r)",
" IsCompact (βtoEuclidean.symm '' Metric.closedBall (toEuclidean x) r)",
" closure (ball x r) = closedBall x r",
" β r β Ioo 0 R, s β ball x r"
] |
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 | 129 | 129 | theorem neg_inv : -aβ»ΒΉ = (-a)β»ΒΉ := by | rw [inv_eq_one_div, inv_eq_one_div, div_neg_eq_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)",
" -(b / a) = -... |
import Mathlib.Algebra.BigOperators.Finprod
import Mathlib.SetTheory.Ordinal.Basic
import Mathlib.Topology.ContinuousFunction.Algebra
import Mathlib.Topology.Compactness.Paracompact
import Mathlib.Topology.ShrinkingLemma
import Mathlib.Topology.UrysohnsLemma
#align_import topology.partition_of_unity from "leanprover-... | Mathlib/Topology/PartitionOfUnity.lean | 188 | 190 | theorem mem_finsupport (xβ : X) {i} :
i β Ο.finsupport xβ β i β support fun i β¦ Ο i xβ := by |
simp only [finsupport, mem_support, Finite.mem_toFinset, mem_setOf_eq]
| [
" f = g",
" { toFun := toFunβ, locallyFinite' := locallyFinite'β, nonneg' := nonneg'β, sum_eq_one' := sum_eq_one'β,\n sum_le_one' := sum_le_one'β } =\n g",
" { toFun := toFunβΒΉ, locallyFinite' := locallyFinite'βΒΉ, nonneg' := nonneg'βΒΉ, sum_eq_one' := sum_eq_one'βΒΉ,\n sum_le_one' := sum_le_one'βΒΉ } ... | [
" f = g",
" { toFun := toFunβ, locallyFinite' := locallyFinite'β, nonneg' := nonneg'β, sum_eq_one' := sum_eq_one'β,\n sum_le_one' := sum_le_one'β } =\n g",
" { toFun := toFunβΒΉ, locallyFinite' := locallyFinite'βΒΉ, nonneg' := nonneg'βΒΉ, sum_eq_one' := sum_eq_one'βΒΉ,\n sum_le_one' := sum_le_one'βΒΉ } ... |
import Mathlib.RingTheory.Algebraic
import Mathlib.RingTheory.Localization.AtPrime
import Mathlib.RingTheory.Localization.Integral
#align_import ring_theory.ideal.over from "leanprover-community/mathlib"@"198cb64d5c961e1a8d0d3e219feb7058d5353861"
variable {R : Type*} [CommRing R]
namespace Ideal
open Polynomial... | Mathlib/RingTheory/Ideal/Over.lean | 101 | 109 | theorem quotient_mk_maps_eq (P : Ideal R[X]) :
((Quotient.mk (map (mapRingHom (Quotient.mk (P.comap (C : R β+* R[X])))) P)).comp C).comp
(Quotient.mk (P.comap (C : R β+* R[X]))) =
(Ideal.quotientMap (map (mapRingHom (Quotient.mk (P.comap (C : R β+* R[X])))) P)
(mapRingHom (Quotient.mk (P.c... |
refine RingHom.ext fun x => ?_
repeat' rw [RingHom.coe_comp, Function.comp_apply]
rw [quotientMap_mk, coe_mapRingHom, map_C]
| [
" p.coeff 0 β comap f I",
" evalβ f r p.divX * r β I",
" p β 0 β evalβ f r p = 0 β β i, p.coeff i β 0 β§ p.coeff i β comap f I",
" 0 β 0 β evalβ f r 0 = 0 β β i, coeff 0 i β 0 β§ coeff 0 i β comap f I",
" evalβ f r 0 = 0 β β i, coeff 0 i β 0 β§ coeff 0 i β comap f I",
" β (p : R[X]) (a : R),\n p.coeff 0 =... | [
" p.coeff 0 β comap f I",
" evalβ f r p.divX * r β I",
" p β 0 β evalβ f r p = 0 β β i, p.coeff i β 0 β§ p.coeff i β comap f I",
" 0 β 0 β evalβ f r 0 = 0 β β i, coeff 0 i β 0 β§ coeff 0 i β comap f I",
" evalβ f r 0 = 0 β β i, coeff 0 i β 0 β§ coeff 0 i β comap f I",
" β (p : R[X]) (a : R),\n p.coeff 0 =... |
import Mathlib.CategoryTheory.Monoidal.Mon_
#align_import category_theory.monoidal.Mod_ from "leanprover-community/mathlib"@"33085c9739c41428651ac461a323fde9a2688d9b"
universe vβ vβ uβ uβ
open CategoryTheory MonoidalCategory
variable (C : Type uβ) [Category.{vβ} C] [MonoidalCategory.{vβ} C]
variable {C}
struc... | Mathlib/CategoryTheory/Monoidal/Mod_.lean | 81 | 82 | theorem id_hom' (M : Mod_ A) : (π M : M βΆ M).hom = π M.X := by |
rfl
| [
" A.X β M.act β« M.act = (Ξ±_ A.X A.X M.X).inv β« A.mul β· M.X β« M.act",
" (π M).hom = π M.X"
] | [
" A.X β M.act β« M.act = (Ξ±_ A.X A.X M.X).inv β« A.mul β· M.X β« M.act"
] |
import Mathlib.Algebra.GradedMonoid
import Mathlib.Algebra.Order.Monoid.Canonical.Defs
import Mathlib.Algebra.MvPolynomial.Basic
#align_import ring_theory.mv_polynomial.weighted_homogeneous from "leanprover-community/mathlib"@"2f5b500a507264de86d666a5f87ddb976e2d8de4"
noncomputable section
open Set Function Fins... | Mathlib/RingTheory/MvPolynomial/WeightedHomogeneous.lean | 105 | 116 | theorem weightedTotalDegree_coe (w : Ο β M) (p : MvPolynomial Ο R) (hp : p β 0) :
weightedTotalDegree' w p = β(weightedTotalDegree w p) := by |
rw [Ne, β weightedTotalDegree'_eq_bot_iff w p, β Ne, WithBot.ne_bot_iff_exists] at hp
obtain β¨m, hmβ© := hp
apply le_antisymm
Β· simp only [weightedTotalDegree, weightedTotalDegree', Finset.sup_le_iff, WithBot.coe_le_coe]
intro b
exact Finset.le_sup
Β· simp only [weightedTotalDegree]
have hm' : weig... | [
" (weightedDegree w) f = f.sum fun i c => c β’ w i",
" weightedTotalDegree' w p = β₯ β p = 0",
" (β (s : Ο ββ β), coeff s p β 0 β False) β β (d : Ο ββ β), coeff d p = 0",
" weightedTotalDegree' w 0 = β₯",
" weightedTotalDegree' w p = β(weightedTotalDegree w p)",
" weightedTotalDegree' w p β€ β(weightedTotalDe... | [
" (weightedDegree w) f = f.sum fun i c => c β’ w i",
" weightedTotalDegree' w p = β₯ β p = 0",
" (β (s : Ο ββ β), coeff s p β 0 β False) β β (d : Ο ββ β), coeff d p = 0",
" weightedTotalDegree' w 0 = β₯"
] |
import Mathlib.Order.Filter.Bases
import Mathlib.Order.ConditionallyCompleteLattice.Basic
#align_import order.filter.lift from "leanprover-community/mathlib"@"8631e2d5ea77f6c13054d9151d82b83069680cb1"
open Set Classical Filter Function
namespace Filter
variable {Ξ± Ξ² Ξ³ : Type*} {ΞΉ : Sort*}
section lift
protect... | Mathlib/Order/Filter/Lift.lean | 106 | 108 | theorem tendsto_lift {m : Ξ³ β Ξ²} {l : Filter Ξ³} :
Tendsto m l (f.lift g) β β s β f, Tendsto m l (g s) := by |
simp only [Filter.lift, tendsto_iInf]
| [
" β€.lift g = g univ",
" s β f.lift g β β i, p i β§ β x, pg i x β§ sg i x β s",
" DirectedOn ((fun s => g s) β»ΒΉ'o fun x x_1 => x β₯ x_1) f.sets",
" β z β f.sets, ((fun s => g s) β»ΒΉ'o fun x x_1 => x β₯ x_1) tβ z β§ ((fun s => g s) β»ΒΉ'o fun x x_1 => x β₯ x_1) tβ z",
" (β i β f.sets, s β g i) β β i, p i β§ β x, pg i x... | [
" β€.lift g = g univ",
" s β f.lift g β β i, p i β§ β x, pg i x β§ sg i x β s",
" DirectedOn ((fun s => g s) β»ΒΉ'o fun x x_1 => x β₯ x_1) f.sets",
" β z β f.sets, ((fun s => g s) β»ΒΉ'o fun x x_1 => x β₯ x_1) tβ z β§ ((fun s => g s) β»ΒΉ'o fun x x_1 => x β₯ x_1) tβ z",
" (β i β f.sets, s β g i) β β i, p i β§ β x, pg i x... |
import Mathlib.Algebra.BigOperators.Intervals
import Mathlib.Algebra.BigOperators.Ring.List
import Mathlib.Data.Int.ModEq
import Mathlib.Data.Nat.Bits
import Mathlib.Data.Nat.Log
import Mathlib.Data.List.Indexes
import Mathlib.Data.List.Palindrome
import Mathlib.Tactic.IntervalCases
import Mathlib.Tactic.Linarith
impo... | Mathlib/Data/Nat/Digits.lean | 119 | 121 | theorem digits_add_two_add_one (b n : β) :
digits (b + 2) (n + 1) = ((n + 1) % (b + 2)) :: digits (b + 2) ((n + 1) / (b + 2)) := by |
simp [digits, digitsAux_def]
| [
" (invImage (fun x => x) instWellFoundedRelationOfSizeOf).1 ((n + 1) / b) n.succ",
" b.digitsAux h 0 = []",
" b.digitsAux h n = n % b :: b.digitsAux h (n / b)",
" b.digitsAux h 0 = 0 % b :: b.digitsAux h (0 / b)",
" b.digitsAux h (nβ + 1) = (nβ + 1) % b :: b.digitsAux h ((nβ + 1) / b)",
" 2 β€ b + 2",
" ... | [
" (invImage (fun x => x) instWellFoundedRelationOfSizeOf).1 ((n + 1) / b) n.succ",
" b.digitsAux h 0 = []",
" b.digitsAux h n = n % b :: b.digitsAux h (n / b)",
" b.digitsAux h 0 = 0 % b :: b.digitsAux h (0 / b)",
" b.digitsAux h (nβ + 1) = (nβ + 1) % b :: b.digitsAux h ((nβ + 1) / b)",
" 2 β€ b + 2",
" ... |
import Mathlib.CategoryTheory.EffectiveEpi.Basic
namespace CategoryTheory
open Limits Category
variable {C : Type*} [Category C]
noncomputable
def effectiveEpiFamilyStructCompOfEffectiveEpiSplitEpi' {Ξ± : Type*} {B : C} {X Y : Ξ± β C}
(f : (a : Ξ±) β X a βΆ B) (g : (a : Ξ±) β Y a βΆ X a) (i : (a : Ξ±) β X a βΆ Y a)
... | Mathlib/CategoryTheory/EffectiveEpi/Comp.lean | 104 | 112 | theorem effectiveEpiFamilyStructCompIso_aux
{W : C} (e : (a : Ξ±) β X a βΆ W)
(h : β {Z : C} (aβ aβ : Ξ±) (gβ : Z βΆ X aβ) (gβ : Z βΆ X aβ),
gβ β« Ο aβ β« i = gβ β« Ο aβ β« i β gβ β« e aβ = gβ β« e aβ)
{Z : C} (aβ aβ : Ξ±) (gβ : Z βΆ X aβ) (gβ : Z βΆ X aβ) (hg : gβ β« Ο aβ = gβ β« Ο aβ) :
gβ β« e aβ = gβ β« e aβ :=... |
apply h
rw [β Category.assoc, hg]
simp
| [
" gβ β« (fun a => i a β« e a) aβ = gβ β« (fun a => i a β« e a) aβ",
" (gβ β« i aβ) β« e aβ = (gβ β« i aβ) β« e aβ",
" (gβ β« i aβ) β« g aβ β« f aβ = (gβ β« i aβ) β« g aβ β« f aβ",
" (g a β« f a) β« (fun {W} e w => EffectiveEpiFamily.desc (fun a => X a) f (fun a => i a β« e a) β―) e β― = e a",
" g a β« i a β« e a = e a",
" ((g... | [
" gβ β« (fun a => i a β« e a) aβ = gβ β« (fun a => i a β« e a) aβ",
" (gβ β« i aβ) β« e aβ = (gβ β« i aβ) β« e aβ",
" (gβ β« i aβ) β« g aβ β« f aβ = (gβ β« i aβ) β« g aβ β« f aβ",
" (g a β« f a) β« (fun {W} e w => EffectiveEpiFamily.desc (fun a => X a) f (fun a => i a β« e a) β―) e β― = e a",
" g a β« i a β« e a = e a",
" ((g... |
import Mathlib.RingTheory.Noetherian
import Mathlib.Algebra.DirectSum.Module
import Mathlib.Algebra.DirectSum.Finsupp
import Mathlib.Algebra.Module.Projective
import Mathlib.Algebra.Module.Injective
import Mathlib.Algebra.Module.CharacterModule
import Mathlib.LinearAlgebra.DirectSum.TensorProduct
import Mathlib.Linear... | Mathlib/RingTheory/Flat/Basic.lean | 98 | 106 | theorem iff_rTensor_injective' :
Flat R M β β I : Ideal R, Function.Injective (rTensor M I.subtype) := by |
rewrite [Flat.iff_rTensor_injective]
refine β¨fun h I => ?_, fun h I _ => h Iβ©
rewrite [injective_iff_map_eq_zero]
intro x hxβ
obtain β¨J, hfg, hle, y, rflβ© := Submodule.exists_fg_le_eq_rTensor_inclusion x
rewrite [β rTensor_comp_apply] at hxβ
rw [(injective_iff_map_eq_zero _).mp (h hfg) y hxβ, LinearMap.m... | [
" β β¦I : Ideal Rβ¦, I.FG β Function.Injective β(lift (lsmul R R ββ Submodule.subtype I))",
" Function.Injective β(lift (lsmul R R ββ Submodule.subtype I))",
" Function.Injective (β(lift (lsmul R R ββ Submodule.subtype I)) β β(TensorProduct.rid R β₯I).symm.toEquiv)",
" β(lift (lsmul R R ββ Submodule.subtype I)) ... | [
" β β¦I : Ideal Rβ¦, I.FG β Function.Injective β(lift (lsmul R R ββ Submodule.subtype I))",
" Function.Injective β(lift (lsmul R R ββ Submodule.subtype I))",
" Function.Injective (β(lift (lsmul R R ββ Submodule.subtype I)) β β(TensorProduct.rid R β₯I).symm.toEquiv)",
" β(lift (lsmul R R ββ Submodule.subtype I)) ... |
import Mathlib.Topology.Order
#align_import topology.maps from "leanprover-community/mathlib"@"d91e7f7a7f1c7e9f0e18fdb6bde4f652004c735d"
open Set Filter Function
open TopologicalSpace Topology Filter
variable {X : Type*} {Y : Type*} {Z : Type*} {ΞΉ : Type*} {f : X β Y} {g : Y β Z}
section Inducing
variable [To... | Mathlib/Topology/Maps.lean | 152 | 153 | theorem isClosed_iff (hf : Inducing f) {s : Set X} :
IsClosed s β β t, IsClosed t β§ f β»ΒΉ' t = s := by | rw [hf.induced, isClosed_induced_iff]
| [
" instβΒ² = TopologicalSpace.induced (g β f) instβ",
" Inducing (g β f) β Inducing f",
" Inducing f",
" instβΒ² β€ induced f instβΒΉ",
" induced f instβΒΉ β€ instβΒ²",
" induced f instβΒΉ β€ induced f (induced g instβ)",
" πΛ’ s = comap f (πΛ’ (f '' s))",
" MapClusterPt (f x) l f β ClusterPt x l",
" (π (f x... | [
" instβΒ² = TopologicalSpace.induced (g β f) instβ",
" Inducing (g β f) β Inducing f",
" Inducing f",
" instβΒ² β€ induced f instβΒΉ",
" induced f instβΒΉ β€ instβΒ²",
" induced f instβΒΉ β€ induced f (induced g instβ)",
" πΛ’ s = comap f (πΛ’ (f '' s))",
" MapClusterPt (f x) l f β ClusterPt x l",
" (π (f x... |
import Mathlib.LinearAlgebra.ExteriorAlgebra.Basic
import Mathlib.LinearAlgebra.CliffordAlgebra.Fold
import Mathlib.LinearAlgebra.CliffordAlgebra.Conjugation
import Mathlib.LinearAlgebra.Dual
#align_import linear_algebra.clifford_algebra.contraction from "leanprover-community/mathlib"@"70fd9563a21e7b963887c9360bd29b2... | Mathlib/LinearAlgebra/CliffordAlgebra/Contraction.lean | 149 | 151 | theorem contractLeft_mul_algebraMap (a : CliffordAlgebra Q) (r : R) :
dβ(a * algebraMap _ _ r) = dβa * algebraMap _ _ r := by |
rw [β Algebra.commutes, contractLeft_algebraMap_mul, Algebra.commutes]
| [
" ((contractLeftAux Q d) v) ((ΞΉ Q) v * x, ((contractLeftAux Q d) v) (x, fx)) = Q v β’ fx",
" d v β’ ((ΞΉ Q) v * x) - (ΞΉ Q) v * (d v β’ x - (ΞΉ Q) v * fx) = Q v β’ fx",
" ((fun d => foldr' Q (contractLeftAux Q d) β― 0) (dβ + dβ)) x =\n ((fun d => foldr' Q (contractLeftAux Q d) β― 0) dβ + (fun d => foldr' Q (contractL... | [
" ((contractLeftAux Q d) v) ((ΞΉ Q) v * x, ((contractLeftAux Q d) v) (x, fx)) = Q v β’ fx",
" d v β’ ((ΞΉ Q) v * x) - (ΞΉ Q) v * (d v β’ x - (ΞΉ Q) v * fx) = Q v β’ fx",
" ((fun d => foldr' Q (contractLeftAux Q d) β― 0) (dβ + dβ)) x =\n ((fun d => foldr' Q (contractLeftAux Q d) β― 0) dβ + (fun d => foldr' Q (contractL... |
import Mathlib.Topology.Separation
import Mathlib.Algebra.BigOperators.Finprod
#align_import topology.algebra.infinite_sum.basic from "leanprover-community/mathlib"@"3b52265189f3fb43aa631edffce5d060fafaf82f"
noncomputable section
open Filter Function
open scoped Topology
variable {Ξ± Ξ² Ξ³ : Type*}
section HasP... | Mathlib/Topology/Algebra/InfiniteSum/Defs.lean | 166 | 170 | theorem Multipliable.hasProd (ha : Multipliable f) : HasProd f (β' b, f b) := by |
simp only [tprod_def, ha, dite_true]
by_cases H : (mulSupport f).Finite
Β· simp [H, hasProd_prod_of_ne_finset_one, finprod_eq_prod]
Β· simpa [H] using ha.choose_spec
| [
" β' (b : Ξ²), f b = 1",
" HasProd (f β g) a β HasProd f a",
" β x β Set.range fun a => βa, f x = 1",
" HasProd (f β Subtype.val) (β b β s, f b)",
" HasProd (f β Subtype.val) (β x β s.attach, f βx)",
" HasProd f (β' (b : Ξ²), f b)",
" HasProd f (if (mulSupport fun b => f b).Finite then βαΆ (b : Ξ²), f b els... | [
" β' (b : Ξ²), f b = 1",
" HasProd (f β g) a β HasProd f a",
" β x β Set.range fun a => βa, f x = 1",
" HasProd (f β Subtype.val) (β b β s, f b)",
" HasProd (f β Subtype.val) (β x β s.attach, f βx)"
] |
import Mathlib.Algebra.Polynomial.Degree.Lemmas
open Polynomial
namespace Mathlib.Tactic.ComputeDegree
section recursion_lemmas
variable {R : Type*}
section semiring
variable [Semiring R]
theorem natDegree_C_le (a : R) : natDegree (C a) β€ 0 := (natDegree_C a).le
theorem natDegree_natCast_le (n : β) : natDeg... | Mathlib/Tactic/ComputeDegree.lean | 105 | 115 | theorem coeff_mul_add_of_le_natDegree_of_eq_ite {d df dg : β} {a b : R} {f g : R[X]}
(h_mul_left : natDegree f β€ df) (h_mul_right : natDegree g β€ dg)
(h_mul_left : f.coeff df = a) (h_mul_right : g.coeff dg = b) (ddf : df + dg β€ d) :
(f * g).coeff d = if d = df + dg then a * b else 0 := by |
split_ifs with h
Β· subst h_mul_left h_mul_right h
exact coeff_mul_of_natDegree_le βΉ_βΊ βΉ_βΊ
Β· apply coeff_eq_zero_of_natDegree_lt
apply lt_of_le_of_lt ?_ (lt_of_le_of_ne ddf ?_)
Β· exact natDegree_mul_le_of_le βΉ_βΊ βΉ_βΊ
Β· exact ne_comm.mp h
| [
" (f + g).coeff n = a + b",
" (f + g).coeff n = f.coeff n + g.coeff n",
" (f * g).coeff d = if d = df + dg then a * b else 0",
" (f * g).coeff d = a * b",
" (f * g).coeff (df + dg) = f.coeff df * g.coeff dg",
" (f * g).coeff d = 0",
" (f * g).natDegree < d",
" (f * g).natDegree β€ df + dg",
" df + dg... | [
" (f + g).coeff n = a + b",
" (f + g).coeff n = f.coeff n + g.coeff n"
] |
import Mathlib.Data.Nat.Count
import Mathlib.Data.Nat.SuccPred
import Mathlib.Order.Interval.Set.Monotone
import Mathlib.Order.OrderIsoNat
#align_import data.nat.nth from "leanprover-community/mathlib"@"7fdd4f3746cb059edfdb5d52cba98f66fce418c0"
open Finset
namespace Nat
variable (p : β β Prop)
noncomputable d... | Mathlib/Data/Nat/Nth.lean | 71 | 73 | theorem nth_eq_orderEmbOfFin (hf : (setOf p).Finite) {n : β} (hn : n < hf.toFinset.card) :
nth p n = hf.toFinset.orderEmbOfFin rfl β¨n, hnβ© := by |
rw [nth_eq_getD_sort hf, Finset.orderEmbOfFin_apply, List.getD_eq_get]
| [
" β",
" nth p n = 0",
" (sort (fun x x_1 => x β€ x_1) hf.toFinset).length β€ n",
" nth p n = (hf.toFinset.orderEmbOfFin β―) β¨n, hnβ©"
] | [
" β",
" nth p n = 0",
" (sort (fun x x_1 => x β€ x_1) hf.toFinset).length β€ n"
] |
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 | 278 | 308 | theorem nodup_toList (p : Perm Ξ±) (x : Ξ±) : Nodup (toList p x) := by |
by_cases hx : p x = x
Β· rw [β not_mem_support, β toList_eq_nil_iff] at hx
simp [hx]
have hc : IsCycle (cycleOf p x) := isCycle_cycleOf p hx
rw [nodup_iff_nthLe_inj]
rintro n m hn hm
rw [length_toList, β hc.orderOf] at hm hn
rw [β cycleOf_apply_self, β Ne, β mem_support] at hx
rw [nthLe_toList, nthL... | [
" toList 1 x = []",
" p.toList x = [] β x β p.support",
" (p.toList x).length = (p.cycleOf x).support.card",
" p.toList x β [y]",
" False",
" 2 β€ (p.toList x).length β x β p.support",
" (p.toList x).get β¨n, hnβ© = (p ^ n) x",
" (p.toList x).get β¨0, β―β© = x",
" (p.toList x).nthLe n hn = (p ^ n) x",
"... | [
" toList 1 x = []",
" p.toList x = [] β x β p.support",
" (p.toList x).length = (p.cycleOf x).support.card",
" p.toList x β [y]",
" False",
" 2 β€ (p.toList x).length β x β p.support",
" (p.toList x).get β¨n, hnβ© = (p ^ n) x",
" (p.toList x).get β¨0, β―β© = x",
" (p.toList x).nthLe n hn = (p ^ n) x",
"... |
import Mathlib.Algebra.Algebra.Equiv
import Mathlib.Algebra.Algebra.NonUnitalHom
import Mathlib.Algebra.BigOperators.Finsupp
import Mathlib.Algebra.Module.BigOperators
import Mathlib.Data.Finsupp.Basic
import Mathlib.LinearAlgebra.Finsupp
#align_import algebra.monoid_algebra.basic from "leanprover-community/mathlib"@... | Mathlib/Algebra/MonoidAlgebra/Basic.lean | 202 | 210 | theorem liftNC_mul {g_hom : Type*} [FunLike g_hom G R] [MulHomClass g_hom G R]
(f : k β+* R) (g : g_hom) (a b : MonoidAlgebra k G)
(h_comm : β {x y}, y β a.support β Commute (f (b x)) (g y)) :
liftNC (f : k β+ R) g (a * b) = liftNC (f : k β+ R) g a * liftNC (f : k β+ R) g b := by |
conv_rhs => rw [β sum_single a, β sum_single b]
-- Porting note: `(liftNC _ g).map_finsupp_sum` β `map_finsupp_sum`
simp_rw [mul_def, map_finsupp_sum, liftNC_single, Finsupp.sum_mul, Finsupp.mul_sum]
refine Finset.sum_congr rfl fun y hy => Finset.sum_congr rfl fun x _hx => ?_
simp [mul_assoc, (h_comm hy).lef... | [
" f * g = sum f fun aβ bβ => sum g fun aβ bβ => single (aβ * aβ) (bβ * bβ)",
" f * (g + h) = f * g + f * h",
" (sum f fun aβ bβ => sum (g + h) fun aβ bβ => single (aβ * aβ) (bβ * bβ)) =\n (sum f fun aβ bβ => sum g fun aβ bβ => single (aβ * aβ) (bβ * bβ)) +\n sum f fun aβ bβ => sum h fun aβ bβ => single ... | [
" f * g = sum f fun aβ bβ => sum g fun aβ bβ => single (aβ * aβ) (bβ * bβ)",
" f * (g + h) = f * g + f * h",
" (sum f fun aβ bβ => sum (g + h) fun aβ bβ => single (aβ * aβ) (bβ * bβ)) =\n (sum f fun aβ bβ => sum g fun aβ bβ => single (aβ * aβ) (bβ * bβ)) +\n sum f fun aβ bβ => sum h fun aβ bβ => single ... |
import Mathlib.Analysis.Calculus.FDeriv.Prod
import Mathlib.Analysis.Calculus.InverseFunctionTheorem.FDeriv
import Mathlib.LinearAlgebra.Dual
#align_import analysis.calculus.lagrange_multipliers from "leanprover-community/mathlib"@"f2ce6086713c78a7f880485f7917ea547a215982"
open Filter Set
open scoped Topology Fi... | Mathlib/Analysis/Calculus/LagrangeMultipliers.lean | 84 | 97 | theorem IsLocalExtrOn.exists_multipliers_of_hasStrictFDerivAt_1d {f : E β β} {f' : E βL[β] β}
(hextr : IsLocalExtrOn Ο {x | f x = f xβ} xβ) (hf' : HasStrictFDerivAt f f' xβ)
(hΟ' : HasStrictFDerivAt Ο Ο' xβ) : β a b : β, (a, b) β 0 β§ a β’ f' + b β’ Ο' = 0 := by |
obtain β¨Ξ, Ξβ, hΞ, hfΞβ© := hextr.exists_linear_map_of_hasStrictFDerivAt hf' hΟ'
refine β¨Ξ 1, Ξβ, ?_, ?_β©
Β· contrapose! hΞ
simp only [Prod.mk_eq_zero] at hΞ β’
refine β¨LinearMap.ext fun x => ?_, hΞ.2β©
simpa [hΞ.1] using Ξ.map_smul x 1
Β· ext x
have Hβ : Ξ (f' x) = f' x * Ξ 1 := by
simpa only... | [
" LinearMap.range (f'.prod Ο') β β€",
" False",
" map Ο (π[f β»ΒΉ' {f xβ}] xβ) = π (Ο xβ)",
" map (Prod.snd β fΟ) (π[fΟ β»ΒΉ' {p | p.1 = f xβ}] xβ) = π (Ο xβ)",
" map Prod.snd (π (f xβ, Ο xβ) β π {p | p.1 = f xβ}) = π (Ο xβ)",
" β Ξ Ξβ, (Ξ, Ξβ) β 0 β§ β (x : E), Ξ (f' x) + Ξβ β’ Ο' x = 0",
" Ξ (f' x) + ... | [
" LinearMap.range (f'.prod Ο') β β€",
" False",
" map Ο (π[f β»ΒΉ' {f xβ}] xβ) = π (Ο xβ)",
" map (Prod.snd β fΟ) (π[fΟ β»ΒΉ' {p | p.1 = f xβ}] xβ) = π (Ο xβ)",
" map Prod.snd (π (f xβ, Ο xβ) β π {p | p.1 = f xβ}) = π (Ο xβ)",
" β Ξ Ξβ, (Ξ, Ξβ) β 0 β§ β (x : E), Ξ (f' x) + Ξβ β’ Ο' x = 0",
" Ξ (f' x) + ... |
import Mathlib.Analysis.SpecialFunctions.Log.Base
import Mathlib.MeasureTheory.Measure.MeasureSpaceDef
#align_import measure_theory.measure.doubling from "leanprover-community/mathlib"@"5f6e827d81dfbeb6151d7016586ceeb0099b9655"
noncomputable section
open Set Filter Metric MeasureTheory TopologicalSpace ENNReal NN... | Mathlib/MeasureTheory/Measure/Doubling.lean | 132 | 136 | theorem eventually_measure_le_scaling_constant_mul (K : β) :
βαΆ r in π[>] 0, β x, ΞΌ (closedBall x (K * r)) β€ scalingConstantOf ΞΌ K * ΞΌ (closedBall x r) := by |
filter_upwards [Classical.choose_spec
(exists_eventually_forall_measure_closedBall_le_mul ΞΌ K)] with r hr x
exact (hr x K le_rfl).trans (mul_le_mul_right' (ENNReal.coe_le_coe.2 (le_max_left _ _)) _)
| [
" β C, βαΆ (Ξ΅ : β) in π[>] 0, β (x : Ξ±), β t β€ K, ΞΌ (closedBall x (t * Ξ΅)) β€ βC * ΞΌ (closedBall x Ξ΅)",
" β (n : β), βαΆ (Ξ΅ : β) in π[>] 0, β (x : Ξ±), ΞΌ (closedBall x (2 ^ n * Ξ΅)) β€ β(C ^ n) * ΞΌ (closedBall x Ξ΅)",
" βαΆ (Ξ΅ : β) in π[>] 0, β (x : Ξ±), ΞΌ (closedBall x (2 ^ n * Ξ΅)) β€ β(C ^ n) * ΞΌ (closedBall x Ξ΅)",
... | [
" β C, βαΆ (Ξ΅ : β) in π[>] 0, β (x : Ξ±), β t β€ K, ΞΌ (closedBall x (t * Ξ΅)) β€ βC * ΞΌ (closedBall x Ξ΅)",
" β (n : β), βαΆ (Ξ΅ : β) in π[>] 0, β (x : Ξ±), ΞΌ (closedBall x (2 ^ n * Ξ΅)) β€ β(C ^ n) * ΞΌ (closedBall x Ξ΅)",
" βαΆ (Ξ΅ : β) in π[>] 0, β (x : Ξ±), ΞΌ (closedBall x (2 ^ n * Ξ΅)) β€ β(C ^ n) * ΞΌ (closedBall x Ξ΅)",
... |
import Mathlib.Data.List.Nodup
import Mathlib.Data.List.Zip
import Mathlib.Data.Nat.Defs
import Mathlib.Data.List.Infix
#align_import data.list.rotate from "leanprover-community/mathlib"@"f694c7dead66f5d4c80f446c796a5aad14707f0e"
universe u
variable {Ξ± : Type u}
open Nat Function
namespace List
theorem rotate... | Mathlib/Data/List/Rotate.lean | 45 | 45 | theorem rotate_zero (l : List Ξ±) : l.rotate 0 = l := by | simp [rotate]
| [
" l.rotate (n % l.length) = l.rotate n",
" [].rotate n = []",
" l.rotate 0 = l"
] | [
" l.rotate (n % l.length) = l.rotate n",
" [].rotate n = []"
] |
import Mathlib.Analysis.Convex.Hull
#align_import analysis.convex.join from "leanprover-community/mathlib"@"951bf1d9e98a2042979ced62c0620bcfb3587cf8"
open Set
variable {ΞΉ : Sort*} {π E : Type*}
section OrderedSemiring
variable (π) [OrderedSemiring π] [AddCommMonoid E] [Module π E] {s t sβ sβ tβ tβ u : Set ... | Mathlib/Analysis/Convex/Join.lean | 75 | 75 | theorem convexJoin_singletons (x : E) : convexJoin π {x} {y} = segment π x y := by | simp
| [
" x β convexJoin π s t β β a β s, β b β t, x β segment π a b",
" β iβ β t, β iβ β s, segment π iβ iβ = convexJoin π t s",
" convexJoin π β
t = β
",
" convexJoin π s β
= β
",
" convexJoin π {x} t = β y β t, segment π x y",
" convexJoin π s {y} = β x β s, segment π x y",
" convexJoin π {x} {y} = ... | [
" x β convexJoin π s t β β a β s, β b β t, x β segment π a b",
" β iβ β t, β iβ β s, segment π iβ iβ = convexJoin π t s",
" convexJoin π β
t = β
",
" convexJoin π s β
= β
",
" convexJoin π {x} t = β y β t, segment π x y",
" convexJoin π s {y} = β x β s, segment π x y"
] |
import Mathlib.Control.Functor.Multivariate
import Mathlib.Data.PFunctor.Univariate.Basic
#align_import data.pfunctor.multivariate.basic from "leanprover-community/mathlib"@"e3d9ab8faa9dea8f78155c6c27d62a621f4c152d"
universe u v
open MvFunctor
@[pp_with_univ]
structure MvPFunctor (n : β) where
A : Type u
... | Mathlib/Data/PFunctor/Multivariate/Basic.lean | 148 | 149 | theorem comp.get_mk (x : P (fun i => Q i Ξ±)) : comp.get (comp.mk x) = x := by |
rfl
| [
" get (f <$$> x) = (fun i x => f <$$> x) <$$> get x",
" get (mk x) = x"
] | [
" get (f <$$> x) = (fun i x => f <$$> x) <$$> get x"
] |
import Mathlib.Geometry.Euclidean.Sphere.Basic
#align_import geometry.euclidean.sphere.second_inter from "leanprover-community/mathlib"@"46b633fd842bef9469441c0209906f6dddd2b4f5"
noncomputable section
open RealInnerProductSpace
namespace EuclideanGeometry
variable {V : Type*} {P : Type*} [NormedAddCommGroup V]... | Mathlib/Geometry/Euclidean/Sphere/SecondInter.lean | 54 | 55 | theorem Sphere.secondInter_mem {s : Sphere P} {p : P} (v : V) : s.secondInter p v β s β p β s := by |
simp_rw [mem_sphere, Sphere.secondInter_dist]
| [
" dist (s.secondInter p v) s.center = dist p s.center",
" dist ((-2 * βͺv, p -α΅₯ s.centerβ«_β / βͺv, vβ«_β) β’ v +α΅₯ p) s.center = dist p s.center",
" -2 * βͺv, p -α΅₯ s.centerβ«_β / βͺv, vβ«_β = 0 β¨ -2 * βͺv, p -α΅₯ s.centerβ«_β / βͺv, vβ«_β = -2 * βͺv, p -α΅₯ s.centerβ«_β / βͺv, vβ«_β",
" s.secondInter p v β s β p β s"
] | [
" dist (s.secondInter p v) s.center = dist p s.center",
" dist ((-2 * βͺv, p -α΅₯ s.centerβ«_β / βͺv, vβ«_β) β’ v +α΅₯ p) s.center = dist p s.center",
" -2 * βͺv, p -α΅₯ s.centerβ«_β / βͺv, vβ«_β = 0 β¨ -2 * βͺv, p -α΅₯ s.centerβ«_β / βͺv, vβ«_β = -2 * βͺv, p -α΅₯ s.centerβ«_β / βͺv, vβ«_β"
] |
import Mathlib.Algebra.Order.Ring.Abs
import Mathlib.Tactic.Ring
#align_import data.nat.hyperoperation from "leanprover-community/mathlib"@"f7fc89d5d5ff1db2d1242c7bb0e9062ce47ef47c"
def hyperoperation : β β β β β β β
| 0, _, k => k + 1
| 1, m, 0 => m
| 2, _, 0 => 0
| _ + 3, _, 0 => 1
| n + 1, m, k + 1 ... | Mathlib/Data/Nat/Hyperoperation.lean | 116 | 126 | theorem hyperoperation_ge_four_zero (n k : β) :
hyperoperation (n + 4) 0 k = if Even k then 1 else 0 := by |
induction' k with kk kih
Β· rw [hyperoperation_ge_three_eq_one]
simp only [Nat.zero_eq, even_zero, if_true]
Β· rw [hyperoperation_recursion]
rw [kih]
simp_rw [Nat.even_add_one]
split_ifs
Β· exact hyperoperation_ge_two_eq_self (n + 1) 0
Β· exact hyperoperation_ge_three_eq_one n 0
| [
" hyperoperation 0 m k = k.succ",
" hyperoperation (n + 3) m 0 = 1",
" hyperoperation (n + 1) m (k + 1) = hyperoperation n m (hyperoperation (n + 1) m k)",
" hyperoperation 1 = fun x x_1 => x + x_1",
" hyperoperation 1 m k = m + k",
" hyperoperation 1 m 0 = m + 0",
" hyperoperation 1 m (bn + 1) = m + (b... | [
" hyperoperation 0 m k = k.succ",
" hyperoperation (n + 3) m 0 = 1",
" hyperoperation (n + 1) m (k + 1) = hyperoperation n m (hyperoperation (n + 1) m k)",
" hyperoperation 1 = fun x x_1 => x + x_1",
" hyperoperation 1 m k = m + k",
" hyperoperation 1 m 0 = m + 0",
" hyperoperation 1 m (bn + 1) = m + (b... |
import Mathlib.Algebra.BigOperators.Group.Finset
import Mathlib.Data.Finsupp.Defs
import Mathlib.Data.Finset.Pairwise
#align_import data.finsupp.big_operators from "leanprover-community/mathlib"@"59694bd07f0a39c5beccba34bd9f413a160782bf"
variable {ΞΉ M : Type*} [DecidableEq ΞΉ]
theorem List.support_sum_subset [Add... | Mathlib/Data/Finsupp/BigOperators.lean | 55 | 57 | theorem Finset.support_sum_subset [AddCommMonoid M] (s : Finset (ΞΉ ββ M)) :
(s.sum id).support β Finset.sup s Finsupp.support := by |
classical convert Multiset.support_sum_subset s.1; simp
| [
" l.sum.support β foldr (fun x x_1 => x.support β x_1) β
l",
" [].sum.support β foldr (fun x x_1 => x.support β x_1) β
[]",
" (hd :: tl).sum.support β foldr (fun x x_1 => x.support β x_1) β
(hd :: tl)",
" (hd + tl.sum).support β foldr (fun x x_1 => x.support β x_1) β
(hd :: tl)",
" hd.support β hd.support",... | [
" l.sum.support β foldr (fun x x_1 => x.support β x_1) β
l",
" [].sum.support β foldr (fun x x_1 => x.support β x_1) β
[]",
" (hd :: tl).sum.support β foldr (fun x x_1 => x.support β x_1) β
(hd :: tl)",
" (hd + tl.sum).support β foldr (fun x x_1 => x.support β x_1) β
(hd :: tl)",
" hd.support β hd.support",... |
import Mathlib.Analysis.InnerProductSpace.Orientation
import Mathlib.MeasureTheory.Measure.Lebesgue.EqHaar
#align_import measure_theory.measure.haar.inner_product_space from "leanprover-community/mathlib"@"fd5edc43dc4f10b85abfe544b88f82cf13c5f844"
open FiniteDimensional MeasureTheory MeasureTheory.Measure Set
var... | Mathlib/MeasureTheory/Measure/Haar/InnerProductSpace.lean | 71 | 76 | theorem OrthonormalBasis.addHaar_eq_volume {ΞΉ F : Type*} [Fintype ΞΉ] [NormedAddCommGroup F]
[InnerProductSpace β F] [FiniteDimensional β F] [MeasurableSpace F] [BorelSpace F]
(b : OrthonormalBasis ΞΉ β F) :
b.toBasis.addHaar = volume := by |
rw [Basis.addHaar_eq_iff]
exact b.volume_parallelepiped
| [
" o.volumeForm.measure (parallelepiped βb) = 1",
" ΞΉ β Fin n",
" Fintype.card ΞΉ = n",
" βb = β(b.reindex e) β βe",
" b x = (β(b.reindex e) β βe) x",
" o.volumeForm.measure = volume",
" addHaarMeasure (stdOrthonormalBasis β F).toBasis.parallelepiped = volume",
" volume (parallelepiped βb) = 1",
" b.t... | [
" o.volumeForm.measure (parallelepiped βb) = 1",
" ΞΉ β Fin n",
" Fintype.card ΞΉ = n",
" βb = β(b.reindex e) β βe",
" b x = (β(b.reindex e) β βe) x",
" o.volumeForm.measure = volume",
" addHaarMeasure (stdOrthonormalBasis β F).toBasis.parallelepiped = volume",
" volume (parallelepiped βb) = 1"
] |
import Mathlib.Data.Finset.Basic
variable {ΞΉ : Sort _} {Ο : ΞΉ β Sort _} {x : β i, Ο i} [DecidableEq ΞΉ]
namespace Function
def updateFinset (x : β i, Ο i) (s : Finset ΞΉ) (y : β i : β₯s, Ο i) (i : ΞΉ) : Ο i :=
if hi : i β s then y β¨i, hiβ© else x i
open Finset Equiv
theorem updateFinset_def {s : Finset ΞΉ} {y} :
... | Mathlib/Data/Finset/Update.lean | 35 | 41 | theorem updateFinset_singleton {i y} :
updateFinset x {i} y = Function.update x i (y β¨i, mem_singleton_self iβ©) := by |
congr with j
by_cases hj : j = i
Β· cases hj
simp only [dif_pos, Finset.mem_singleton, update_same, updateFinset]
Β· simp [hj, updateFinset]
| [
" updateFinset x {i} y = update x i (y β¨i, β―β©)",
" updateFinset x {i} y j = update x i (y β¨i, β―β©) j",
" updateFinset x {i} y i = update x i (y β¨i, β―β©) i"
] | [] |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.