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.Algebra.MvPolynomial.Basic
import Mathlib.Data.Finset.PiAntidiagonal
import Mathlib.LinearAlgebra.StdBasis
import Mathlib.Tactic.Linarith
#align_import ring_theory.power_series.basic from "leanprover-community/mathlib"@"2d5739b61641ee4e7e53eca5688a08f66f2e6a60"
noncomputable section
open Finset (... | Mathlib/RingTheory/MvPowerSeries/Basic.lean | 134 | 140 | theorem coeff_monomial [DecidableEq Ο] (m n : Ο ββ β) (a : R) :
coeff R m (monomial R n a) = if m = n then a else 0 := by |
-- This used to be `rw`, but we need `erw` after leanprover/lean4#2644
erw [coeff, monomial_def, LinearMap.proj_apply (i := m)]
dsimp only
-- This used to be `rw`, but we need `erw` after leanprover/lean4#2644
erw [LinearMap.stdBasis_apply, Function.update_apply, Pi.zero_apply]
| [
" monomial R n = LinearMap.stdBasis R (fun x => R) n",
" LinearMap.stdBasis R (fun x => R) n = LinearMap.stdBasis R (fun x => R) n",
" (coeff R m) ((monomial R n) a) = if m = n then a else 0",
" (LinearMap.stdBasis R (fun x => R) n) a m = if m = n then a else 0"
] | [
" monomial R n = LinearMap.stdBasis R (fun x => R) n",
" LinearMap.stdBasis R (fun x => R) n = LinearMap.stdBasis R (fun x => R) n"
] |
import Mathlib.Tactic.Ring.Basic
import Mathlib.Tactic.TryThis
import Mathlib.Tactic.Conv
import Mathlib.Util.Qq
set_option autoImplicit true
-- In this file we would like to be able to use multi-character auto-implicits.
set_option relaxedAutoImplicit true
namespace Mathlib.Tactic
open Lean hiding Rat
open Qq Me... | Mathlib/Tactic/Ring/RingNF.lean | 118 | 118 | theorem mul_neg {R} [Ring R] (a b : R) : a * -b = -(a * b) := by | simp
| [
" a * -b = -(a * b)"
] | [] |
import Mathlib.Probability.ProbabilityMassFunction.Constructions
import Mathlib.Tactic.FinCases
namespace PMF
open ENNReal
noncomputable
def binomial (p : ββ₯0β) (h : p β€ 1) (n : β) : PMF (Fin (n + 1)) :=
.ofFintype (fun i => p^(i : β) * (1-p)^((Fin.last n - i) : β) * (n.choose i : β)) (by
convert (add_pow ... | Mathlib/Probability/ProbabilityMassFunction/Binomial.lean | 53 | 55 | theorem binomial_one_eq_bernoulli (p : ββ₯0β) (h : p β€ 1) :
binomial p h 1 = (bernoulli p h).map (cond Β· 1 0) := by |
ext i; fin_cases i <;> simp [tsum_bool, binomial_apply]
| [
" β a : Fin (n + 1), (fun i => p ^ βi * (1 - p) ^ (β(Fin.last n) - βi) * β(n.choose βi)) a = 1",
" β a : Fin (n + 1), (fun i => p ^ βi * (1 - p) ^ (β(Fin.last n) - βi) * β(n.choose βi)) a =\n β m β Finset.range (n + 1), p ^ m * (1 - p) ^ (n - m) * β(n.choose m)",
" (β i β Finset.range (n + 1),\n if h : ... | [
" β a : Fin (n + 1), (fun i => p ^ βi * (1 - p) ^ (β(Fin.last n) - βi) * β(n.choose βi)) a = 1",
" β a : Fin (n + 1), (fun i => p ^ βi * (1 - p) ^ (β(Fin.last n) - βi) * β(n.choose βi)) a =\n β m β Finset.range (n + 1), p ^ m * (1 - p) ^ (n - m) * β(n.choose m)",
" (β i β Finset.range (n + 1),\n if h : ... |
import Mathlib.SetTheory.Ordinal.Arithmetic
import Mathlib.Tactic.TFAE
import Mathlib.Topology.Order.Monotone
#align_import set_theory.ordinal.topology from "leanprover-community/mathlib"@"740acc0e6f9adf4423f92a485d0456fc271482da"
noncomputable section
universe u v
open Cardinal Order Topology
namespace Ordina... | Mathlib/SetTheory/Ordinal/Topology.lean | 60 | 61 | theorem nhds_left'_eq_nhds_ne (a : Ordinal) : π[<] a = π[β ] a := by |
rw [β nhds_left'_sup_nhds_right', nhds_right', sup_bot_eq]
| [
" IsOpen {a} β Β¬a.IsLimit",
" False",
" IsOpen {a}",
" IsOpen {0}",
" IsOpen (Set.Iio (succ β₯))",
" IsOpen {succ b}",
" IsOpen (Set.Ioo b (succ (succ b)))",
" π[<] a = π[β ] a"
] | [
" IsOpen {a} β Β¬a.IsLimit",
" False",
" IsOpen {a}",
" IsOpen {0}",
" IsOpen (Set.Iio (succ β₯))",
" IsOpen {succ b}",
" IsOpen (Set.Ioo b (succ (succ b)))"
] |
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 | 93 | 105 | theorem integerLattice.inter_ball_finite [NumberField K] (r : β) :
((integerLattice K : Set ((K β+* β) β β)) β© Metric.closedBall 0 r).Finite := by |
obtain hr | _ := lt_or_le r 0
Β· simp [Metric.closedBall_eq_empty.2 hr]
Β· have heq : β x, canonicalEmbedding K x β Metric.closedBall 0 r β
β Ο : K β+* β, βΟ xβ β€ r := by
intro x; rw [β norm_le_iff, mem_closedBall_zero_iff]
convert (Embeddings.finite_of_norm_le K β r).image (canonicalEmbedding K)... | [
" (starRingEnd β) (x Ο) = x (ComplexEmbedding.conjugate Ο)",
" β x β Set.range β(canonicalEmbedding K), (starRingEnd β) (x Ο) = x (ComplexEmbedding.conjugate Ο)",
" (starRingEnd β) ((canonicalEmbedding K) x Ο) = (canonicalEmbedding K) x (ComplexEmbedding.conjugate Ο)",
" (starRingEnd β) (0 Ο) = 0 (ComplexEmbe... | [
" (starRingEnd β) (x Ο) = x (ComplexEmbedding.conjugate Ο)",
" β x β Set.range β(canonicalEmbedding K), (starRingEnd β) (x Ο) = x (ComplexEmbedding.conjugate Ο)",
" (starRingEnd β) ((canonicalEmbedding K) x Ο) = (canonicalEmbedding K) x (ComplexEmbedding.conjugate Ο)",
" (starRingEnd β) (0 Ο) = 0 (ComplexEmbe... |
import Mathlib.Data.Vector.Basic
#align_import data.vector.mem from "leanprover-community/mathlib"@"509de852e1de55e1efa8eacfa11df0823f26f226"
namespace Vector
variable {Ξ± Ξ² : Type*} {n : β} (a a' : Ξ±)
@[simp]
theorem get_mem (i : Fin n) (v : Vector Ξ± n) : v.get i β v.toList := by
rw [get_eq_get]
exact List.... | Mathlib/Data/Vector/Mem.lean | 70 | 73 | theorem mem_of_mem_tail (v : Vector Ξ± n) (ha : a β v.tail.toList) : a β v.toList := by |
induction' n with n _
Β· exact False.elim (Vector.not_mem_zero a v.tail ha)
Β· exact (mem_succ_iff a v).2 (Or.inr ha)
| [
" v.get i β v.toList",
" v.toList.get (Fin.cast β― i) β v.toList",
" a β v.toList β β i, v.get i = a",
" (β i, β (h : i < v.toList.length), v.toList.get β¨i, hβ© = a) β β i, β (h : i < n), v.toList.get (Fin.cast β― β¨i, hβ©) = a",
" i < n",
" i < v.toList.length",
" a β nil.toList",
" a β toList β¨[], β―β©",
... | [
" v.get i β v.toList",
" v.toList.get (Fin.cast β― i) β v.toList",
" a β v.toList β β i, v.get i = a",
" (β i, β (h : i < v.toList.length), v.toList.get β¨i, hβ© = a) β β i, β (h : i < n), v.toList.get (Fin.cast β― β¨i, hβ©) = a",
" i < n",
" i < v.toList.length",
" a β nil.toList",
" a β toList β¨[], β―β©",
... |
import Mathlib.Control.Bitraversable.Basic
#align_import control.bitraversable.lemmas from "leanprover-community/mathlib"@"58581d0fe523063f5651df0619be2bf65012a94a"
universe u
variable {t : Type u β Type u β Type u} [Bitraversable t]
variable {Ξ² : Type u}
namespace Bitraversable
open Functor LawfulApplicative
... | Mathlib/Control/Bitraversable/Lemmas.lean | 87 | 91 | theorem tsnd_tfst {Ξ±β Ξ±β Ξ²β Ξ²β} (f : Ξ±β β F Ξ±β) (f' : Ξ²β β G Ξ²β) (x : t Ξ±β Ξ²β) :
Comp.mk (tsnd f' <$> tfst f x)
= bitraverse (Comp.mk β map pure β f) (Comp.mk β pure β f') x := by |
rw [β comp_bitraverse]
simp only [Function.comp, map_pure]
| [
" Comp.mk (tfst f' <$> tfst f x) = tfst (Comp.mk β map f' β f) x",
" bitraverse (Comp.mk β map f' β f) (Comp.mk β map pure β pure) x = tfst (Comp.mk β map f' β f) x",
" Comp.mk (tfst f <$> tsnd f' x) = bitraverse (Comp.mk β pure β f) (Comp.mk β map pure β f') x",
" bitraverse (Comp.mk β map f β pure) (Comp.mk... | [
" Comp.mk (tfst f' <$> tfst f x) = tfst (Comp.mk β map f' β f) x",
" bitraverse (Comp.mk β map f' β f) (Comp.mk β map pure β pure) x = tfst (Comp.mk β map f' β f) x",
" Comp.mk (tfst f <$> tsnd f' x) = bitraverse (Comp.mk β pure β f) (Comp.mk β map pure β f') x",
" bitraverse (Comp.mk β map f β pure) (Comp.mk... |
import Mathlib.Algebra.Homology.Homotopy
import Mathlib.Algebra.Homology.Linear
import Mathlib.CategoryTheory.MorphismProperty.IsInvertedBy
import Mathlib.CategoryTheory.Quotient.Linear
import Mathlib.CategoryTheory.Quotient.Preadditive
#align_import algebra.homology.homotopy_category from "leanprover-community/mathl... | Mathlib/Algebra/Homology/HomotopyCategory.lean | 138 | 139 | theorem quotient_map_out_comp_out {C D E : HomotopyCategory V c} (f : C βΆ D) (g : D βΆ E) :
(quotient V c).map (Quot.out f β« Quot.out g) = f β« g := by | simp
| [
" Category.{?u.1707, max (max u v) u_2} (HomotopyCategory V c)",
" Category.{?u.1707, max (max u v) u_2} (CategoryTheory.Quotient (homotopic V c))",
" β β¦X Y : HomologicalComplex V cβ¦ (fβ fβ gβ gβ : X βΆ Y),\n homotopic V c fβ fβ β homotopic V c gβ gβ β homotopic V c (fβ + gβ) (fβ + gβ)",
" homotopic V c (f... | [
" Category.{?u.1707, max (max u v) u_2} (HomotopyCategory V c)",
" Category.{?u.1707, max (max u v) u_2} (CategoryTheory.Quotient (homotopic V c))",
" β β¦X Y : HomologicalComplex V cβ¦ (fβ fβ gβ gβ : X βΆ Y),\n homotopic V c fβ fβ β homotopic V c gβ gβ β homotopic V c (fβ + gβ) (fβ + gβ)",
" homotopic V c (f... |
import Mathlib.Data.Fin.Tuple.Basic
import Mathlib.Data.List.Join
#align_import data.list.of_fn from "leanprover-community/mathlib"@"bf27744463e9620ca4e4ebe951fe83530ae6949b"
universe u
variable {Ξ± : Type u}
open Nat
namespace List
#noalign list.length_of_fn_aux
@[simp]
theorem length_ofFn_go {n} (f : Fin n ... | Mathlib/Data/List/OfFn.lean | 44 | 45 | theorem length_ofFn {n} (f : Fin n β Ξ±) : length (ofFn f) = n := by |
simp [ofFn, length_ofFn_go]
| [
" (ofFn.go f i j h).length = i",
" (ofFn.go f 0 j h).length = 0",
" (ofFn.go f (nβ + 1) j h).length = nβ + 1",
" (ofFn f).length = n"
] | [
" (ofFn.go f i j h).length = i",
" (ofFn.go f 0 j h).length = 0",
" (ofFn.go f (nβ + 1) j h).length = nβ + 1"
] |
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 | 94 | 95 | theorem Ioo_eq_empty_iff [DenselyOrdered Ξ±] : Ioo a b = β
β Β¬a < b := by |
rw [β coe_eq_empty, coe_Ioo, Set.Ioo_eq_empty_iff]
| [
" (Icc a b).Nonempty β a β€ b",
" (Ico a b).Nonempty β a < b",
" (Ioc a b).Nonempty β a < b",
" (Ioo a b).Nonempty β a < b",
" Icc a b = β
β Β¬a β€ b",
" Ico a b = β
β Β¬a < b",
" Ioc a b = β
β Β¬a < b",
" Ioo a b = β
β Β¬a < b"
] | [
" (Icc a b).Nonempty β a β€ b",
" (Ico a b).Nonempty β a < b",
" (Ioc a b).Nonempty β a < b",
" (Ioo a b).Nonempty β a < b",
" Icc a b = β
β Β¬a β€ b",
" Ico a b = β
β Β¬a < b",
" Ioc a b = β
β Β¬a < b"
] |
import Mathlib.Data.Vector.Basic
import Mathlib.Data.Vector.Snoc
set_option autoImplicit true
namespace Vector
section Fold
section Comm
variable (xs ys : Vector Ξ± n)
| Mathlib/Data/Vector/MapLemmas.lean | 369 | 371 | theorem mapβ_comm (f : Ξ± β Ξ± β Ξ²) (comm : β aβ aβ, f aβ aβ = f aβ aβ) :
mapβ f xs ys = mapβ f ys xs := by |
induction xs, ys using Vector.inductionOnβ <;> simp_all
| [
" mapβ f xs ys = mapβ f ys xs",
" mapβ f nil nil = mapβ f nil nil",
" mapβ f (aβΒΉ ::α΅₯ xβ) (bβ ::α΅₯ yβ) = mapβ f (bβ ::α΅₯ yβ) (aβΒΉ ::α΅₯ xβ)"
] | [] |
import Mathlib.Data.Set.Lattice
#align_import data.set.intervals.disjoint from "leanprover-community/mathlib"@"207cfac9fcd06138865b5d04f7091e46d9320432"
universe u v w
variable {ΞΉ : Sort u} {Ξ± : Type v} {Ξ² : Type w}
open Set
open OrderDual (toDual)
namespace Set
section Preorder
variable [Preorder Ξ±] {a b c... | Mathlib/Order/Interval/Set/Disjoint.lean | 92 | 93 | theorem iUnion_Ioc_right (a : Ξ±) : β b, Ioc a b = Ioi a := by |
simp only [β Ioi_inter_Iic, β inter_iUnion, iUnion_Iic, inter_univ]
| [
" Disjoint (Ici a) (Iic b) β Β¬a β€ b",
" β b, Icc a b = Ici a",
" β b, Ioc a b = Ioi a"
] | [
" Disjoint (Ici a) (Iic b) β Β¬a β€ b",
" β b, Icc a b = Ici a"
] |
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 | 69 | 72 | theorem Inducing.of_comp_iff (hg : Inducing g) :
Inducing (g β f) β Inducing f := by |
refine β¨fun h β¦ ?_, hg.compβ©
rw [inducing_iff, hg.induced, induced_compose, h.induced]
| [
" instβΒ² = TopologicalSpace.induced (g β f) instβ",
" Inducing (g β f) β Inducing f",
" Inducing f"
] | [
" instβΒ² = TopologicalSpace.induced (g β f) instβ"
] |
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 | 116 | 121 | theorem areaForm_swap (x y : E) : Ο x y = -Ο y x := by |
simp only [areaForm_to_volumeForm]
convert o.volumeForm.map_swap ![y, x] (_ : (0 : Fin 2) β 1)
Β· ext i
fin_cases i <;> rfl
Β· norm_num
| [
" E ββ[β] E ββ[β] β",
" (o.areaForm x) y = o.volumeForm ![x, y]",
" (o.areaForm x) x = 0",
" o.volumeForm ![x, x] = 0",
" ![x, x] 0 = ![x, x] 1",
" 0 β 1",
" (o.areaForm x) y = -(o.areaForm y) x",
" o.volumeForm ![x, y] = -o.volumeForm ![y, x]",
" ![x, y] = ![y, x] β β(Equiv.swap 0 1)",
" ![x, y] ... | [
" E ββ[β] E ββ[β] β",
" (o.areaForm x) y = o.volumeForm ![x, y]",
" (o.areaForm x) x = 0",
" o.volumeForm ![x, x] = 0",
" ![x, x] 0 = ![x, x] 1",
" 0 β 1"
] |
import Mathlib.Analysis.SpecialFunctions.JapaneseBracket
import Mathlib.Analysis.SpecialFunctions.Integrals
import Mathlib.MeasureTheory.Group.Integral
import Mathlib.MeasureTheory.Integral.IntegralEqImproper
import Mathlib.MeasureTheory.Measure.Lebesgue.Integral
#align_import analysis.special_functions.improper_inte... | Mathlib/Analysis/SpecialFunctions/ImproperIntegrals.lean | 62 | 73 | theorem integrableOn_Ioi_rpow_of_lt {a : β} (ha : a < -1) {c : β} (hc : 0 < c) :
IntegrableOn (fun t : β => t ^ a) (Ioi c) := by |
have hd : β x β Ici c, HasDerivAt (fun t => t ^ (a + 1) / (a + 1)) (x ^ a) x := by
intro x hx
-- Porting note: helped `convert` with explicit arguments
convert (hasDerivAt_rpow_const (p := a + 1) (Or.inl (hc.trans_le hx).ne')).div_const _ using 1
field_simp [show a + 1 β 0 from ne_of_lt (by linarith)... | [
" IntegrableOn rexp (Iic c) volume",
" β« (x : β) in id y..c, βrexp xβ β€ rexp c",
" 0 β€ rexp (id y)",
" β« (x : β) in Iic c, rexp x = rexp c",
" Tendsto (fun i => β« (x : β) in id i..c, rexp x) atBot (π (rexp c))",
" π (rexp c) = π (rexp c - 0)",
" Tendsto (fun i => rexp c - rexp (id i)) atBot (π (rexp... | [
" IntegrableOn rexp (Iic c) volume",
" β« (x : β) in id y..c, βrexp xβ β€ rexp c",
" 0 β€ rexp (id y)",
" β« (x : β) in Iic c, rexp x = rexp c",
" Tendsto (fun i => β« (x : β) in id i..c, rexp x) atBot (π (rexp c))",
" π (rexp c) = π (rexp c - 0)",
" Tendsto (fun i => rexp c - rexp (id i)) atBot (π (rexp... |
import Mathlib.Analysis.NormedSpace.Star.Spectrum
import Mathlib.Analysis.Normed.Group.Quotient
import Mathlib.Analysis.NormedSpace.Algebra
import Mathlib.Topology.ContinuousFunction.Units
import Mathlib.Topology.ContinuousFunction.Compact
import Mathlib.Topology.Algebra.Algebra
import Mathlib.Topology.ContinuousFunct... | Mathlib/Analysis/NormedSpace/Star/GelfandDuality.lean | 99 | 105 | theorem WeakDual.CharacterSpace.exists_apply_eq_zero {a : A} (ha : Β¬IsUnit a) :
β f : characterSpace β A, f a = 0 := by |
obtain β¨M, hM, haMβ© := (span {a}).exists_le_maximal (span_singleton_ne_top ha)
exact
β¨M.toCharacterSpace,
M.toCharacterSpace_apply_eq_zero_of_mem
(haM (mem_span_singleton.mpr β¨1, (mul_one a).symmβ©))β©
| [
" I.toCharacterSpace a = 0",
" (CharacterSpace.equivAlgHom.symm ((β(NormedRing.algEquivComplexOfComplete β―).symm).comp (Quotient.mkβ β I))) a = 0",
" β―.some = 0",
" β f, f a = 0"
] | [
" I.toCharacterSpace a = 0",
" (CharacterSpace.equivAlgHom.symm ((β(NormedRing.algEquivComplexOfComplete β―).symm).comp (Quotient.mkβ β I))) a = 0",
" β―.some = 0"
] |
import Mathlib.Data.Matroid.Restrict
variable {Ξ± : Type*} {M : Matroid Ξ±} {E B I X R J : Set Ξ±}
namespace Matroid
open Set
section EmptyOn
def emptyOn (Ξ± : Type*) : Matroid Ξ± where
E := β
Base := (Β· = β
)
Indep := (Β· = β
)
indep_iff' := by simp [subset_empty_iff]
exists_base := β¨β
, rflβ©
base_exchange... | Mathlib/Data/Matroid/Constructions.lean | 71 | 73 | theorem eq_emptyOn [IsEmpty Ξ±] (M : Matroid Ξ±) : M = emptyOn Ξ± := by |
rw [β ground_eq_empty_iff]
exact M.E.eq_empty_of_isEmpty
| [
" β β¦I : Set Ξ±β¦, (fun x => x = β
) I β β B, (fun x => x = β
) B β§ I β B",
" ExchangeProperty fun x => x = β
",
" (fun x => x = β
) Yβ β β a β β
\\ Yβ, β b β Yβ \\ β
, (fun x => x = β
) (insert b (β
\\ {a}))",
" β X β β
, ExistsMaximalSubsetProperty (fun x => x = β
) X",
" (maximals (fun x x_1 => x β x_1) {Y | (fun ... | [
" β β¦I : Set Ξ±β¦, (fun x => x = β
) I β β B, (fun x => x = β
) B β§ I β B",
" ExchangeProperty fun x => x = β
",
" (fun x => x = β
) Yβ β β a β β
\\ Yβ, β b β Yβ \\ β
, (fun x => x = β
) (insert b (β
\\ {a}))",
" β X β β
, ExistsMaximalSubsetProperty (fun x => x = β
) X",
" (maximals (fun x x_1 => x β x_1) {Y | (fun ... |
import Mathlib.CategoryTheory.Limits.Shapes.WideEqualizers
import Mathlib.CategoryTheory.Limits.Shapes.Products
import Mathlib.CategoryTheory.Limits.Shapes.Terminal
#align_import category_theory.limits.constructions.weakly_initial from "leanprover-community/mathlib"@"239d882c4fb58361ee8b3b39fb2091320edef10a"
univ... | Mathlib/CategoryTheory/Limits/Constructions/WeaklyInitial.lean | 46 | 64 | theorem hasInitial_of_weakly_initial_and_hasWideEqualizers [HasWideEqualizers.{v} C] {T : C}
(hT : β X, Nonempty (T βΆ X)) : HasInitial C := by |
let endos := T βΆ T
let i := wideEqualizer.ΞΉ (id : endos β endos)
haveI : Nonempty endos := β¨π _β©
have : β X : C, Unique (wideEqualizer (id : endos β endos) βΆ X) := by
intro X
refine β¨β¨i β« Classical.choice (hT X)β©, fun a => ?_β©
let E := equalizer a (i β« Classical.choice (hT _))
let e : E βΆ wide... | [
" HasInitial C",
" (X : C) β Unique (wideEqualizer id βΆ X)",
" Unique (wideEqualizer id βΆ X)",
" a = default",
" ((i β« h) β« e) β« i = i β« π T",
" i β« h β« e β« i = i β« π T",
" e β« a = e β« default"
] | [] |
import Mathlib.Data.Set.Defs
import Mathlib.Order.Heyting.Basic
import Mathlib.Order.RelClasses
import Mathlib.Order.Hom.Basic
import Mathlib.Lean.Thunk
set_option autoImplicit true
class EstimatorData (a : Thunk Ξ±) (Ξ΅ : Type*) where
bound : Ξ΅ β Ξ±
improve : Ξ΅ β Option Ξ΅
class Estimator [Preorder Ξ±] (a... | Mathlib/Order/Estimator.lean | 126 | 142 | theorem Estimator.improveUntilAux_spec (a : Thunk Ξ±) (p : Ξ± β Bool)
[Estimator a Ξ΅] [WellFoundedGT (range (bound a : Ξ΅ β Ξ±))] (e : Ξ΅) (r : Bool) :
match Estimator.improveUntilAux a p e r with
| .error _ => Β¬ p a.get
| .ok e' => p (bound a e') := by |
rw [Estimator.improveUntilAux]
by_cases h : p (bound a e)
Β· simp only [h]; exact h
Β· simp only [h]
match improve a e, improve_spec e with
| none, eq =>
simp only [Bool.not_eq_true]
rw [eq] at h
exact Bool.bool_eq_false h
| some e', _ =>
exact Estimator.improveUntilAux_spec a... | [
" match improveUntilAux a p e r with\n | Except.error a_1 => Β¬p a.get = true\n | Except.ok e' => p (bound a e') = true",
" match\n if p (bound a e) = true then pure e\n else\n match improve a e, β― with\n | none, x => Except.error (if r = true then none else some e)\n | some e', x => improve... | [] |
import Mathlib.Data.Nat.Prime
#align_import data.int.nat_prime from "leanprover-community/mathlib"@"422e70f7ce183d2900c586a8cda8381e788a0c62"
open Nat
namespace Int
theorem not_prime_of_int_mul {a b : β€} {c : β} (ha : a.natAbs β 1) (hb : b.natAbs β 1)
(hc : a * b = (c : β€)) : Β¬Nat.Prime c :=
not_prime_mul... | Mathlib/Data/Int/NatPrime.lean | 24 | 33 | theorem succ_dvd_or_succ_dvd_of_succ_sum_dvd_mul {p : β} (p_prime : Nat.Prime p) {m n : β€}
{k l : β} (hpm : β(p ^ k) β£ m) (hpn : β(p ^ l) β£ n) (hpmn : β(p ^ (k + l + 1)) β£ m * n) :
β(p ^ (k + 1)) β£ m β¨ β(p ^ (l + 1)) β£ n :=
have hpm' : p ^ k β£ m.natAbs := Int.natCast_dvd_natCast.1 <| Int.dvd_natAbs.2 hpm
ha... |
rw [β Int.natAbs_mul]; apply Int.natCast_dvd_natCast.1 <| Int.dvd_natAbs.2 hpmn
let hsd := Nat.succ_dvd_or_succ_dvd_of_succ_sum_dvd_mul p_prime hpm' hpn' hpmn'
hsd.elim (fun hsd1 => Or.inl (by apply Int.dvd_natAbs.1; apply Int.natCast_dvd_natCast.2 hsd1))
fun hsd2 => Or.inr (by apply Int.dvd_natAbs.1; appl... | [
" p ^ (k + l + 1) β£ m.natAbs * n.natAbs",
" p ^ (k + l + 1) β£ (m * n).natAbs",
" β(p ^ (k + 1)) β£ m",
" β(p ^ (k + 1)) β£ βm.natAbs",
" β(p ^ (l + 1)) β£ n",
" β(p ^ (l + 1)) β£ βn.natAbs"
] | [] |
import Mathlib.MeasureTheory.Integral.IntervalIntegral
import Mathlib.Order.Filter.IndicatorFunction
open MeasureTheory
section DominatedConvergenceTheorem
open Set Filter TopologicalSpace ENNReal
open scoped Topology
namespace MeasureTheory
variable {Ξ± E G: Type*}
[NormedAddCommGroup E] [NormedSpace β E] [C... | Mathlib/MeasureTheory/Integral/DominatedConvergence.lean | 66 | 75 | theorem tendsto_integral_filter_of_dominated_convergence {ΞΉ} {l : Filter ΞΉ} [l.IsCountablyGenerated]
{F : ΞΉ β Ξ± β G} {f : Ξ± β G} (bound : Ξ± β β) (hF_meas : βαΆ n in l, AEStronglyMeasurable (F n) ΞΌ)
(h_bound : βαΆ n in l, βα΅ a βΞΌ, βF n aβ β€ bound a) (bound_integrable : Integrable bound ΞΌ)
(h_lim : βα΅ a βΞΌ, Ten... |
by_cases hG : CompleteSpace G
Β· simp only [integral, hG, L1.integral]
exact tendsto_setToFun_filter_of_dominated_convergence (dominatedFinMeasAdditive_weightedSMul ΞΌ)
bound hF_meas h_bound bound_integrable h_lim
Β· simp [integral, hG, tendsto_const_nhds]
| [
" Tendsto (fun n => β« (a : Ξ±), F n a βΞΌ) atTop (π (β« (a : Ξ±), f a βΞΌ))",
" Tendsto\n (fun n =>\n if h : True then\n if hf : Integrable (fun a => F n a) ΞΌ then L1.integralCLM (Integrable.toL1 (fun a => F n a) hf) else 0\n else 0)\n atTop\n (π\n (if h : True then\n if hf : In... | [
" Tendsto (fun n => β« (a : Ξ±), F n a βΞΌ) atTop (π (β« (a : Ξ±), f a βΞΌ))",
" Tendsto\n (fun n =>\n if h : True then\n if hf : Integrable (fun a => F n a) ΞΌ then L1.integralCLM (Integrable.toL1 (fun a => F n a) hf) else 0\n else 0)\n atTop\n (π\n (if h : True then\n if hf : In... |
import Mathlib.Algebra.EuclideanDomain.Basic
import Mathlib.RingTheory.PrincipalIdealDomain
import Mathlib.Algebra.GCDMonoid.Nat
#align_import ring_theory.int.basic from "leanprover-community/mathlib"@"e655e4ea5c6d02854696f97494997ba4c31be802"
namespace Int
theorem gcd_eq_one_iff_coprime {a b : β€} : Int.gcd a b ... | Mathlib/RingTheory/Int/Basic.lean | 54 | 56 | theorem gcd_ne_one_iff_gcd_mul_right_ne_one {a : β€} {m n : β} :
a.gcd (m * n) β 1 β a.gcd m β 1 β¨ a.gcd n β 1 := by |
simp only [gcd_eq_one_iff_coprime, β not_and_or, not_iff_not, IsCoprime.mul_right_iff]
| [
" a.gcd b = 1 β IsCoprime a b",
" a.gcd b = 1 β IsCoprime a b",
" IsCoprime a b",
" a.natAbs.gcdA b.natAbs * ua * a + a.natAbs.gcdB b.natAbs * ub * b = 1",
" IsCoprime a b β a.gcd b = 1",
" a.gcd b = 1",
" False",
" p β£ 1",
" βp β£ r * a + s * b",
" IsCoprime a b β a.natAbs.Coprime b.natAbs",
" a... | [
" a.gcd b = 1 β IsCoprime a b",
" a.gcd b = 1 β IsCoprime a b",
" IsCoprime a b",
" a.natAbs.gcdA b.natAbs * ua * a + a.natAbs.gcdB b.natAbs * ub * b = 1",
" IsCoprime a b β a.gcd b = 1",
" a.gcd b = 1",
" False",
" p β£ 1",
" βp β£ r * a + s * b",
" IsCoprime a b β a.natAbs.Coprime b.natAbs"
] |
import Mathlib.Order.Filter.Basic
#align_import order.filter.prod from "leanprover-community/mathlib"@"d6fad0e5bf2d6f48da9175d25c3dc5706b3834ce"
open Set
open Filter
namespace Filter
variable {Ξ± Ξ² Ξ³ Ξ΄ : Type*} {ΞΉ : Sort*}
section Prod
variable {s : Set Ξ±} {t : Set Ξ²} {f : Filter Ξ±} {g : Filter Ξ²}
protected ... | Mathlib/Order/Filter/Prod.lean | 131 | 135 | theorem eventually_prod_iff {p : Ξ± Γ Ξ² β Prop} :
(βαΆ x in f ΓΛ’ g, p x) β
β pa : Ξ± β Prop, (βαΆ x in f, pa x) β§ β pb : Ξ² β Prop, (βαΆ y in g, pb y) β§
β {x}, pa x β β {y}, pb y β p (x, y) := by |
simpa only [Set.prod_subset_iff] using @mem_prod_iff Ξ± Ξ² p f g
| [
" s β f ΓΛ’ g β β tβ β f, β tβ β g, tβ ΓΛ’ tβ β s",
" s β comap Prod.fst f β comap Prod.snd g β β tβ β f, β tβ β g, tβ.prod tβ β s",
" s β comap Prod.fst f β comap Prod.snd g β β tβ β f, β tβ β g, tβ.prod tβ β s",
" β tβ_1 β f, β tβ_1 β g, tβ_1.prod tβ_1 β tβ β© tβ",
" (β tβ β f, β tβ β g, tβ.prod tβ β s) β s ... | [
" s β f ΓΛ’ g β β tβ β f, β tβ β g, tβ ΓΛ’ tβ β s",
" s β comap Prod.fst f β comap Prod.snd g β β tβ β f, β tβ β g, tβ.prod tβ β s",
" s β comap Prod.fst f β comap Prod.snd g β β tβ β f, β tβ β g, tβ.prod tβ β s",
" β tβ_1 β f, β tβ_1 β g, tβ_1.prod tβ_1 β tβ β© tβ",
" (β tβ β f, β tβ β g, tβ.prod tβ β s) β s ... |
import Mathlib.Topology.Order.IsLUB
open Set Filter TopologicalSpace Topology Function
open OrderDual (toDual ofDual)
variable {Ξ± Ξ² Ξ³ : Type*}
section DenselyOrdered
variable [TopologicalSpace Ξ±] [LinearOrder Ξ±] [OrderTopology Ξ±] [DenselyOrdered Ξ±] {a b : Ξ±}
{s : Set Ξ±}
theorem closure_Ioi' {a : Ξ±} (h : (Io... | Mathlib/Topology/Order/DenselyOrdered.lean | 106 | 108 | theorem Icc_mem_nhds_iff [NoMinOrder Ξ±] [NoMaxOrder Ξ±] {a b x : Ξ±} :
Icc a b β π x β x β Ioo a b := by |
rw [β interior_Icc, mem_interior_iff_mem_nhds]
| [
" closure (Ioi a) = Ici a",
" closure (Ioi a) β Ici a",
" Ici a β closure (Ioi a)",
" a β closure (Ioi a)",
" closure (Ioo a b) = Icc a b",
" closure (Ioo a b) β Icc a b",
" Icc a b β closure (Ioo a b)",
" {a, b} β closure (Ioo a b)",
" a β closure (Ioo a b) β§ b β closure (Ioo a b)",
" β
β closure... | [
" closure (Ioi a) = Ici a",
" closure (Ioi a) β Ici a",
" Ici a β closure (Ioi a)",
" a β closure (Ioi a)",
" closure (Ioo a b) = Icc a b",
" closure (Ioo a b) β Icc a b",
" Icc a b β closure (Ioo a b)",
" {a, b} β closure (Ioo a b)",
" a β closure (Ioo a b) β§ b β closure (Ioo a b)",
" β
β closure... |
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 | 259 | 262 | theorem normAtPlace_nonneg (w : InfinitePlace K) (x : E K) :
0 β€ normAtPlace w x := by |
rw [normAtPlace, MonoidWithZeroHom.coe_mk, ZeroHom.coe_mk]
split_ifs <;> exact norm_nonneg _
| [
" 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.LinearAlgebra.Matrix.Charpoly.Coeff
import Mathlib.LinearAlgebra.Matrix.ToLin
#align_import linear_algebra.matrix.charpoly.linear_map from "leanprover-community/mathlib"@"62c0a4ef1441edb463095ea02a06e87f3dfe135c"
variable {ΞΉ : Type*} [Fintype ΞΉ]
variable {M : Type*} [AddCommGroup M] (R : Type*) [Co... | Mathlib/LinearAlgebra/Matrix/Charpoly/LinearMap.lean | 141 | 144 | theorem Matrix.Represents.smul {A : Matrix ΞΉ ΞΉ R} {f : Module.End R M} (h : A.Represents b f)
(r : R) : (r β’ A).Represents b (r β’ f) := by |
delta Matrix.Represents at h β’
rw [_root_.map_smul, _root_.map_smul, h]
| [
" ((fromMatrix R b) A) (Pi.single j 1) = β i : ΞΉ, A i j β’ b i",
" β i : ΞΉ, (fun i => A i j * 1) i β’ b i = β i : ΞΉ, A i j β’ b i",
" ((fromEnd R b) f) (Pi.single i 1) = f (b i)",
" f (((Fintype.total R R) b) (Pi.single i 1)) = f (b i)",
" ((Fintype.total R R) b) (Pi.single i 1) = b i",
" b i = 1 β’ b i",
"... | [
" ((fromMatrix R b) A) (Pi.single j 1) = β i : ΞΉ, A i j β’ b i",
" β i : ΞΉ, (fun i => A i j * 1) i β’ b i = β i : ΞΉ, A i j β’ b i",
" ((fromEnd R b) f) (Pi.single i 1) = f (b i)",
" f (((Fintype.total R R) b) (Pi.single i 1)) = f (b i)",
" ((Fintype.total R R) b) (Pi.single i 1) = b i",
" b i = 1 β’ b i",
"... |
import Mathlib.Topology.MetricSpace.Basic
#align_import topology.metric_space.infsep from "leanprover-community/mathlib"@"5316314b553dcf8c6716541851517c1a9715e22b"
variable {Ξ± Ξ² : Type*}
namespace Set
section Einfsep
open ENNReal
open Function
noncomputable def einfsep [EDist Ξ±] (s : Set Ξ±) : ββ₯0β :=
β¨
(x... | Mathlib/Topology/MetricSpace/Infsep.lean | 340 | 341 | theorem infsep_pos : 0 < s.infsep β 0 < s.einfsep β§ s.einfsep < β := by |
simp_rw [infsep, ENNReal.toReal_pos_iff]
| [
" s.infsep = 0 β s.einfsep = 0 β¨ s.einfsep = β€",
" 0 < s.infsep β 0 < s.einfsep β§ s.einfsep < β€"
] | [
" s.infsep = 0 β s.einfsep = 0 β¨ s.einfsep = β€"
] |
import Mathlib.Algebra.Group.Semiconj.Defs
import Mathlib.Init.Algebra.Classes
#align_import algebra.group.commute from "leanprover-community/mathlib"@"05101c3df9d9cfe9430edc205860c79b6d660102"
assert_not_exists MonoidWithZero
assert_not_exists DenselyOrdered
variable {G M S : Type*}
@[to_additive "Two elements... | Mathlib/Algebra/Group/Commute/Defs.lean | 262 | 263 | theorem mul_inv_cancel_assoc (h : Commute a b) : a * (b * aβ»ΒΉ) = b := by |
rw [β mul_assoc, h.mul_inv_cancel]
| [
" a * b * aβ»ΒΉ = b",
" a * (b * aβ»ΒΉ) = b"
] | [
" a * b * aβ»ΒΉ = b"
] |
import Mathlib.Analysis.MeanInequalities
import Mathlib.Analysis.MeanInequalitiesPow
import Mathlib.Analysis.SpecialFunctions.Pow.Continuity
import Mathlib.Data.Set.Image
import Mathlib.Topology.Algebra.Order.LiminfLimsup
#align_import analysis.normed_space.lp_space from "leanprover-community/mathlib"@"de83b43717abe3... | Mathlib/Analysis/NormedSpace/lpSpace.lean | 117 | 127 | theorem memβp_gen' {C : β} {f : β i, E i} (hf : β s : Finset Ξ±, β i β s, βf iβ ^ p.toReal β€ C) :
Memβp f p := by |
apply memβp_gen
use β¨ s : Finset Ξ±, β i β s, βf iβ ^ p.toReal
apply hasSum_of_isLUB_of_nonneg
Β· intro b
exact Real.rpow_nonneg (norm_nonneg _) _
apply isLUB_ciSup
use C
rintro - β¨s, rflβ©
exact hf s
| [
" Memβp f 0 β {i | f i β 0}.Finite",
" (if 0 = 0 then {i | Β¬f i = 0}.Finite\n else if 0 = β€ then BddAbove (Set.range fun i => βf iβ) else Summable fun i => βf iβ ^ 0) β\n {i | Β¬f i = 0}.Finite",
" Memβp f β€ β BddAbove (Set.range fun i => βf iβ)",
" (if β€ = 0 then {i | Β¬f i = 0}.Finite\n else if β€ = β€... | [
" Memβp f 0 β {i | f i β 0}.Finite",
" (if 0 = 0 then {i | Β¬f i = 0}.Finite\n else if 0 = β€ then BddAbove (Set.range fun i => βf iβ) else Summable fun i => βf iβ ^ 0) β\n {i | Β¬f i = 0}.Finite",
" Memβp f β€ β BddAbove (Set.range fun i => βf iβ)",
" (if β€ = 0 then {i | Β¬f i = 0}.Finite\n else if β€ = β€... |
import Mathlib.Algebra.MonoidAlgebra.Basic
import Mathlib.Algebra.Group.UniqueProds
#align_import algebra.monoid_algebra.no_zero_divisors from "leanprover-community/mathlib"@"3e067975886cf5801e597925328c335609511b1a"
open Finsupp
variable {R A : Type*} [Semiring R]
namespace MonoidAlgebra
| Mathlib/Algebra/MonoidAlgebra/NoZeroDivisors.lean | 68 | 79 | theorem mul_apply_mul_eq_mul_of_uniqueMul [Mul A] {f g : MonoidAlgebra R A} {a0 b0 : A}
(h : UniqueMul f.support g.support a0 b0) :
(f * g) (a0 * b0) = f a0 * g b0 := by |
classical
simp_rw [mul_apply, sum, β Finset.sum_product']
refine (Finset.sum_eq_single (a0, b0) ?_ ?_).trans (if_pos rfl) <;> simp_rw [Finset.mem_product]
Β· refine fun ab hab hne => if_neg (fun he => hne <| Prod.ext ?_ ?_)
exacts [(h hab.1 hab.2 he).1, (h hab.1 hab.2 he).2]
Β· refine fun hnmem => ite_eq_r... | [
" (f * g) (a0 * b0) = f a0 * g b0",
" (β x β f.support ΓΛ’ g.support, if x.1 * x.2 = a0 * b0 then f x.1 * g x.2 else 0) = f a0 * g b0",
" β b β f.support ΓΛ’ g.support, b β (a0, b0) β (if b.1 * b.2 = a0 * b0 then f b.1 * g b.2 else 0) = 0",
" (a0, b0) β f.support ΓΛ’ g.support β (if (a0, b0).1 * (a0, b0).2 = a0 ... | [] |
import Mathlib.Data.Vector.Basic
import Mathlib.Data.Vector.Snoc
set_option autoImplicit true
namespace Vector
section Fold
section Binary
variable (xs : Vector Ξ± n) (ys : Vector Ξ² n)
@[simp]
theorem mapAccumrβ_mapAccumr_left (fβ : Ξ³ β Ξ² β Οβ β Οβ Γ ΞΆ) (fβ : Ξ± β Οβ β Οβ Γ Ξ³) :
(mapAccumrβ fβ (mapAccumr fβ... | Mathlib/Data/Vector/MapLemmas.lean | 145 | 154 | theorem mapAccumrβ_mapAccumrβ_right_right (fβ : Ξ² β Ξ³ β Οβ β Οβ Γ Ο) (fβ : Ξ± β Ξ² β Οβ β Οβ Γ Ξ³) :
(mapAccumrβ fβ ys (mapAccumrβ fβ xs ys sβ).snd sβ)
= let m := mapAccumrβ (fun x y (sβ, sβ) =>
let rβ := fβ x y sβ
let rβ := fβ y rβ.snd sβ
((rβ.fst, rβ.fst), rβ.snd)
... |
induction xs, ys using Vector.revInductionOnβ generalizing sβ sβ <;> simp_all
| [
" mapAccumrβ fβ (mapAccumr fβ xs sβ).2 ys sβ =\n let m :=\n mapAccumrβ\n (fun x y s =>\n let rβ := fβ x s.2;\n let rβ := fβ rβ.2 y s.1;\n ((rβ.1, rβ.1), rβ.2))\n xs ys (sβ, sβ);\n (m.1.1, m.2)",
" mapAccumrβ fβ (mapAccumr fβ nil sβ).2 nil sβ =\n let m :=\n ... | [
" mapAccumrβ fβ (mapAccumr fβ xs sβ).2 ys sβ =\n let m :=\n mapAccumrβ\n (fun x y s =>\n let rβ := fβ x s.2;\n let rβ := fβ rβ.2 y s.1;\n ((rβ.1, rβ.1), rβ.2))\n xs ys (sβ, sβ);\n (m.1.1, m.2)",
" mapAccumrβ fβ (mapAccumr fβ nil sβ).2 nil sβ =\n let m :=\n ... |
import Mathlib.Algebra.BigOperators.Group.Finset
import Mathlib.Order.SupIndep
import Mathlib.Order.Atoms
#align_import order.partition.finpartition from "leanprover-community/mathlib"@"d6fad0e5bf2d6f48da9175d25c3dc5706b3834ce"
open Finset Function
variable {Ξ± : Type*}
@[ext]
structure Finpartition [Lattice Ξ±]... | Mathlib/Order/Partition/Finpartition.lean | 178 | 182 | theorem ne_bot {b : Ξ±} (hb : b β P.parts) : b β β₯ := by |
intro h
refine P.not_bot_mem (?_)
rw [h] at hb
exact hb
| [
" xβ β€ β₯",
" (βe).symm xβΒΉ β Finset.map (βe).symm.toEmbedding u",
" e.symm xβ β€ (Finset.map (βe).symm.toEmbedding u).sup id",
" (Finset.map (βe).symm.toEmbedding u).sup id = e.symm (u.sup id)",
" u.sup (id β β(βe).symm.toEmbedding) = u.sup (βe.symm β id)",
" (Finset.map (βe).toEmbedding P.parts).sup id = ... | [
" xβ β€ β₯",
" (βe).symm xβΒΉ β Finset.map (βe).symm.toEmbedding u",
" e.symm xβ β€ (Finset.map (βe).symm.toEmbedding u).sup id",
" (Finset.map (βe).symm.toEmbedding u).sup id = e.symm (u.sup id)",
" u.sup (id β β(βe).symm.toEmbedding) = u.sup (βe.symm β id)",
" (Finset.map (βe).toEmbedding P.parts).sup id = ... |
import Mathlib.Data.Complex.Basic
import Mathlib.Data.Real.Cardinality
#align_import data.complex.cardinality from "leanprover-community/mathlib"@"1c4e18434eeb5546b212e830b2b39de6a83c473c"
-- Porting note: the lemmas `mk_complex` and `mk_univ_complex` should be in the namespace `Cardinal`
-- like their real counter... | Mathlib/Data/Complex/Cardinality.lean | 25 | 26 | theorem mk_complex : #β = π := by |
rw [mk_congr Complex.equivRealProd, mk_prod, lift_id, mk_real, continuum_mul_self]
| [
" #β = π "
] | [] |
import Mathlib.FieldTheory.RatFunc.Defs
import Mathlib.RingTheory.EuclideanDomain
import Mathlib.RingTheory.Localization.FractionRing
import Mathlib.RingTheory.Polynomial.Content
#align_import field_theory.ratfunc from "leanprover-community/mathlib"@"bf9bbbcf0c1c1ead18280b0d010e417b10abb1b6"
universe u v
noncompu... | Mathlib/FieldTheory/RatFunc/Basic.lean | 209 | 211 | theorem ofFractionRing_smul [SMul R (FractionRing K[X])] (c : R) (p : FractionRing K[X]) :
ofFractionRing (c β’ p) = c β’ ofFractionRing p := by |
simp only [SMul.smul, HSMul.hSMul, RatFunc.smul]
| [
" { toFractionRing := 0 } = 0",
" { toFractionRing := p + q } = { toFractionRing := p } + { toFractionRing := q }",
" { toFractionRing := p - q } = { toFractionRing := p } - { toFractionRing := q }",
" { toFractionRing := -p } = -{ toFractionRing := p }",
" { toFractionRing := 1 } = 1",
" { toFractionRing... | [
" { toFractionRing := 0 } = 0",
" { toFractionRing := p + q } = { toFractionRing := p } + { toFractionRing := q }",
" { toFractionRing := p - q } = { toFractionRing := p } - { toFractionRing := q }",
" { toFractionRing := -p } = -{ toFractionRing := p }",
" { toFractionRing := 1 } = 1",
" { toFractionRing... |
import Mathlib.Topology.Connected.Basic
open Set Topology
universe u v
variable {Ξ± : Type u} {Ξ² : Type v} {ΞΉ : Type*} {Ο : ΞΉ β Type*} [TopologicalSpace Ξ±]
{s t u v : Set Ξ±}
section LocallyConnectedSpace
class LocallyConnectedSpace (Ξ± : Type*) [TopologicalSpace Ξ±] : Prop where
open_connected_basis : β x,... | Mathlib/Topology/Connected/LocallyConnected.lean | 89 | 101 | theorem locallyConnectedSpace_iff_connectedComponentIn_open :
LocallyConnectedSpace Ξ± β
β F : Set Ξ±, IsOpen F β β x β F, IsOpen (connectedComponentIn F x) := by |
constructor
Β· intro h
exact fun F hF x _ => hF.connectedComponentIn
Β· intro h
rw [locallyConnectedSpace_iff_open_connected_subsets]
refine fun x U hU =>
β¨connectedComponentIn (interior U) x,
(connectedComponentIn_subset _ _).trans interior_subset, h _ isOpen_interior x ?_,
... | [
" LocallyConnectedSpace Ξ± β β (x : Ξ±), β U β π x, β V β U, IsOpen V β§ x β V β§ IsConnected V",
" (β (x : Ξ±), (π x).HasBasis (fun s => IsOpen s β§ x β s β§ IsConnected s) id) β\n β (x : Ξ±), β U β π x, β V β U, IsOpen V β§ x β V β§ IsConnected V",
" (π xβ).HasBasis (fun s => IsOpen s β§ xβ β s β§ IsConnected s) i... | [
" LocallyConnectedSpace Ξ± β β (x : Ξ±), β U β π x, β V β U, IsOpen V β§ x β V β§ IsConnected V",
" (β (x : Ξ±), (π x).HasBasis (fun s => IsOpen s β§ x β s β§ IsConnected s) id) β\n β (x : Ξ±), β U β π x, β V β U, IsOpen V β§ x β V β§ IsConnected V",
" (π xβ).HasBasis (fun s => IsOpen s β§ xβ β s β§ IsConnected s) i... |
import Mathlib.Data.Set.Prod
import Mathlib.Logic.Equiv.Fin
import Mathlib.ModelTheory.LanguageMap
#align_import model_theory.syntax from "leanprover-community/mathlib"@"d565b3df44619c1498326936be16f1a935df0728"
universe u v w u' v'
namespace FirstOrder
namespace Language
variable (L : Language.{u, v}) {L' : L... | Mathlib/ModelTheory/Syntax.lean | 107 | 110 | theorem relabel_id (t : L.Term Ξ±) : t.relabel id = t := by |
induction' t with _ _ _ _ ih
Β· rfl
Β· simp [ih]
| [
" relabel id t = t",
" relabel id (var aβ) = var aβ",
" relabel id (func _fβ _tsβ) = func _fβ _tsβ"
] | [] |
import Mathlib.Analysis.Analytic.Constructions
import Mathlib.Analysis.Calculus.Dslope
import Mathlib.Analysis.Calculus.FDeriv.Analytic
import Mathlib.Analysis.Analytic.Uniqueness
#align_import analysis.analytic.isolated_zeros from "leanprover-community/mathlib"@"a3209ddf94136d36e5e5c624b10b2a347cc9d090"
open sco... | Mathlib/Analysis/Analytic/IsolatedZeros.lean | 83 | 87 | theorem has_fpower_series_iterate_dslope_fslope (n : β) (hp : HasFPowerSeriesAt f p zβ) :
HasFPowerSeriesAt ((swap dslope zβ)^[n] f) (fslope^[n] p) zβ := by |
induction' n with n ih generalizing f p
Β· exact hp
Β· simpa using ih (has_fpower_series_dslope_fslope hp)
| [
" HasFPowerSeriesAt (dslope f zβ) p.fslope zβ",
" βαΆ (z : π) in π 0, HasSum (fun n => z ^ n β’ p.coeff (n + 1)) (dslope f zβ (zβ + z))",
" HasSum (fun n => x ^ n β’ p.coeff (n + 1)) (dslope f zβ (zβ + x))",
" dslope f zβ (zβ + x) = x ^ 0 β’ p.coeff (0 + 1)",
" β (b' : β), b' β 0 β x ^ b' β’ p.coeff (b' + 1) =... | [
" HasFPowerSeriesAt (dslope f zβ) p.fslope zβ",
" βαΆ (z : π) in π 0, HasSum (fun n => z ^ n β’ p.coeff (n + 1)) (dslope f zβ (zβ + z))",
" HasSum (fun n => x ^ n β’ p.coeff (n + 1)) (dslope f zβ (zβ + x))",
" dslope f zβ (zβ + x) = x ^ 0 β’ p.coeff (0 + 1)",
" β (b' : β), b' β 0 β x ^ b' β’ p.coeff (b' + 1) =... |
import Mathlib.Probability.Kernel.Composition
#align_import probability.kernel.invariance from "leanprover-community/mathlib"@"3b92d54a05ee592aa2c6181a4e76b1bb7cc45d0b"
open MeasureTheory
open scoped MeasureTheory ENNReal ProbabilityTheory
namespace ProbabilityTheory
variable {Ξ± Ξ² Ξ³ : Type*} {mΞ± : MeasurableSp... | Mathlib/Probability/Kernel/Invariance.lean | 83 | 84 | theorem Invariant.comp_const (hΞΊ : Invariant ΞΊ ΞΌ) : ΞΊ ββ const Ξ± ΞΌ = const Ξ± ΞΌ := by |
rw [β const_bind_eq_comp_const ΞΊ ΞΌ, hΞΊ.def]
| [
" (ΞΌ + Ξ½).bind βΞΊ = ΞΌ.bind βΞΊ + Ξ½.bind βΞΊ",
" ((ΞΌ + Ξ½).bind βΞΊ) s = (ΞΌ.bind βΞΊ + Ξ½.bind βΞΊ) s",
" (r β’ ΞΌ).bind βΞΊ = r β’ ΞΌ.bind βΞΊ",
" ((r β’ ΞΌ).bind βΞΊ) s = (r β’ ΞΌ.bind βΞΊ) s",
" const Ξ± (ΞΌ.bind βΞΊ) = ΞΊ ββ const Ξ± ΞΌ",
" ((const Ξ± (ΞΌ.bind βΞΊ)) a) s = ((ΞΊ ββ const Ξ± ΞΌ) a) s",
" (ΞΊ ββ const Ξ± ΞΌ) a = ΞΌ.bind ... | [
" (ΞΌ + Ξ½).bind βΞΊ = ΞΌ.bind βΞΊ + Ξ½.bind βΞΊ",
" ((ΞΌ + Ξ½).bind βΞΊ) s = (ΞΌ.bind βΞΊ + Ξ½.bind βΞΊ) s",
" (r β’ ΞΌ).bind βΞΊ = r β’ ΞΌ.bind βΞΊ",
" ((r β’ ΞΌ).bind βΞΊ) s = (r β’ ΞΌ.bind βΞΊ) s",
" const Ξ± (ΞΌ.bind βΞΊ) = ΞΊ ββ const Ξ± ΞΌ",
" ((const Ξ± (ΞΌ.bind βΞΊ)) a) s = ((ΞΊ ββ const Ξ± ΞΌ) a) s",
" (ΞΊ ββ const Ξ± ΞΌ) a = ΞΌ.bind ... |
import Mathlib.Data.Nat.Choose.Basic
import Mathlib.Data.Sym.Sym2
namespace List
variable {Ξ± : Type*}
section Sym
protected def sym : (n : β) β List Ξ± β List (Sym Ξ± n)
| 0, _ => [.nil]
| _, [] => []
| n + 1, x :: xs => ((x :: xs).sym n |>.map fun p => x ::β p) ++ xs.sym (n + 1)
variable {xs ys : List Ξ±} ... | Mathlib/Data/List/Sym.lean | 165 | 169 | theorem sym_one_eq : xs.sym 1 = xs.map (Β· ::β .nil) := by |
induction xs with
| nil => simp only [List.sym, Nat.succ_eq_add_one, Nat.reduceAdd, map_nil]
| cons x xs ih =>
rw [map_cons, β ih, List.sym, List.sym, map_singleton, singleton_append]
| [
" List.sym 1 xs = map (fun x => x ::β Sym.nil) xs",
" List.sym 1 [] = map (fun x => x ::β Sym.nil) []",
" List.sym 1 (x :: xs) = map (fun x => x ::β Sym.nil) (x :: xs)"
] | [] |
import Mathlib.Data.Matrix.Block
import Mathlib.Data.Matrix.Notation
import Mathlib.LinearAlgebra.StdBasis
import Mathlib.RingTheory.AlgebraTower
import Mathlib.Algebra.Algebra.Subalgebra.Tower
#align_import linear_algebra.matrix.to_lin from "leanprover-community/mathlib"@"0e2aab2b0d521f060f62a14d2cf2e2c54e8491d6"
... | Mathlib/LinearAlgebra/Matrix/ToLin.lean | 112 | 123 | theorem Matrix.vecMul_injective_iff {R : Type*} [CommRing R] {M : Matrix m n R} :
Function.Injective M.vecMul β LinearIndependent R (fun i β¦ M i) := by |
rw [β coe_vecMulLinear]
simp only [β LinearMap.ker_eq_bot, Fintype.linearIndependent_iff, Submodule.eq_bot_iff,
LinearMap.mem_ker, vecMulLinear_apply]
refine β¨fun h c h0 β¦ congr_fun <| h c ?_, fun h c h0 β¦ funext <| h c ?_β©
Β· rw [β h0]
ext i
simp [vecMul, dotProduct]
Β· rw [β h0]
ext j
sim... | [
" ((LinearMap.stdBasis R (fun x => R) i) 1 α΅₯* M) j = M i j",
" β i' : m, (if i = i' then 1 else 0) * M i' j = M i j",
" β x : m, (LinearMap.stdBasis R (fun x => R) i) 1 x * M x j = M i j",
" (LinearMap.stdBasis R (fun x => R) i) 1 xβ = if i = xβ then 1 else 0",
" (LinearMap.stdBasis R (fun x => R) i) 1 xβ =... | [
" ((LinearMap.stdBasis R (fun x => R) i) 1 α΅₯* M) j = M i j",
" β i' : m, (if i = i' then 1 else 0) * M i' j = M i j",
" β x : m, (LinearMap.stdBasis R (fun x => R) i) 1 x * M x j = M i j",
" (LinearMap.stdBasis R (fun x => R) i) 1 xβ = if i = xβ then 1 else 0",
" (LinearMap.stdBasis R (fun x => R) i) 1 xβ =... |
import Mathlib.Data.Set.Subsingleton
import Mathlib.Algebra.Order.BigOperators.Group.Finset
import Mathlib.Algebra.Group.Nat
import Mathlib.Data.Set.Basic
#align_import data.set.equitable from "leanprover-community/mathlib"@"8631e2d5ea77f6c13054d9151d82b83069680cb1"
variable {Ξ± Ξ² : Type*}
namespace Set
def Equ... | Mathlib/Data/Set/Equitable.lean | 42 | 54 | theorem equitableOn_iff_exists_le_le_add_one {s : Set Ξ±} {f : Ξ± β β} :
s.EquitableOn f β β b, β a β s, b β€ f a β§ f a β€ b + 1 := by |
refine β¨?_, fun β¨b, hbβ© x y hx hy => (hb x hx).2.trans (add_le_add_right (hb y hy).1 _)β©
obtain rfl | β¨x, hxβ© := s.eq_empty_or_nonempty
Β· simp
intro hs
by_cases h : β y β s, f x β€ f y
Β· exact β¨f x, fun y hy => β¨h _ hy, hs hy hxβ©β©
push_neg at h
obtain β¨w, hw, hwxβ© := h
refine β¨f w, fun y hy => β¨Nat.le... | [
" s.EquitableOn f β β b, β a β s, b β€ f a β§ f a β€ b + 1",
" s.EquitableOn f β β b, β a β s, b β€ f a β§ f a β€ b + 1",
" β
.EquitableOn f β β b, β a β β
, b β€ f a β§ f a β€ b + 1",
" β b, β a β s, b β€ f a β§ f a β€ b + 1",
" (f w).succ β€ (f y).succ",
" f x β€ (f y).succ"
] | [] |
import Mathlib.Data.Matrix.Block
import Mathlib.Data.Matrix.Notation
import Mathlib.Data.Matrix.RowCol
import Mathlib.GroupTheory.GroupAction.Ring
import Mathlib.GroupTheory.Perm.Fin
import Mathlib.LinearAlgebra.Alternating.Basic
#align_import linear_algebra.matrix.determinant from "leanprover-community/mathlib"@"c30... | Mathlib/LinearAlgebra/Matrix/Determinant/Basic.lean | 68 | 69 | theorem det_apply' (M : Matrix n n R) : M.det = β Ο : Perm n, Ξ΅ Ο * β i, M (Ο i) i := by |
simp [det_apply, Units.smul_def]
| [
" M.det = β Ο : Perm n, ββ(sign Ο) * β i : n, M (Ο i) i"
] | [] |
import Mathlib.Analysis.Analytic.Basic
import Mathlib.Analysis.Analytic.CPolynomial
import Mathlib.Analysis.Calculus.Deriv.Basic
import Mathlib.Analysis.Calculus.ContDiff.Defs
import Mathlib.Analysis.Calculus.FDeriv.Add
#align_import analysis.calculus.fderiv_analytic from "leanprover-community/mathlib"@"3bce8d800a6f2... | Mathlib/Analysis/Calculus/FDeriv/Analytic.lean | 449 | 458 | theorem derivSeries_apply_diag (n : β) (x : E) :
derivSeries p n (fun _ β¦ x) x = (n + 1) β’ p (n + 1) fun _ β¦ x := by |
simp only [derivSeries, compFormalMultilinearSeries_apply, changeOriginSeries,
compContinuousMultilinearMap_coe, ContinuousLinearEquiv.coe_coe, LinearIsometryEquiv.coe_coe,
Function.comp_apply, ContinuousMultilinearMap.sum_apply, map_sum, coe_sum', Finset.sum_apply,
continuousMultilinearCurryFin1_apply, ... | [
" ((p.derivSeries n) fun x_1 => x) x = (n + 1) β’ (p (n + 1)) fun x_1 => x",
" β x_1 : { s // s.card = n }, ((p.changeOriginSeriesTerm 1 n βx_1 β―) fun x_2 => x) (Fin.snoc ![] x) =\n (n + 1) β’ (p (n + 1)) fun x_1 => x",
" ((p.changeOriginSeriesTerm 1 n βxβ β―) fun x_1 => x) (Fin.snoc ![] x) = (p (n + 1)) fun x_... | [] |
import Mathlib.Analysis.Calculus.Deriv.Basic
import Mathlib.Analysis.Calculus.FDeriv.Mul
import Mathlib.Analysis.Calculus.FDeriv.Add
#align_import analysis.calculus.deriv.mul from "leanprover-community/mathlib"@"3bce8d800a6f2b8f63fe1e588fd76a9ff4adcebe"
universe u v w
noncomputable section
open scoped Classical... | Mathlib/Analysis/Calculus/Deriv/Mul.lean | 454 | 459 | theorem HasDerivWithinAt.clm_comp (hc : HasDerivWithinAt c c' s x)
(hd : HasDerivWithinAt d d' s x) :
HasDerivWithinAt (fun y => (c y).comp (d y)) (c'.comp (d x) + (c x).comp d') s x := by |
have := (hc.hasFDerivWithinAt.clm_comp hd.hasFDerivWithinAt).hasDerivWithinAt
rwa [add_apply, comp_apply, comp_apply, smulRight_apply, smulRight_apply, one_apply, one_smul,
one_smul, add_comm] at this
| [
" HasStrictDerivAt (fun y => (c y).comp (d y)) (c'.comp (d x) + (c x).comp d') x",
" HasDerivWithinAt (fun y => (c y).comp (d y)) (c'.comp (d x) + (c x).comp d') s x"
] | [
" HasStrictDerivAt (fun y => (c y).comp (d y)) (c'.comp (d x) + (c x).comp d') x"
] |
import Batteries.Data.Array.Lemmas
namespace ByteArray
@[ext] theorem ext : {a b : ByteArray} β a.data = b.data β a = b
| β¨_β©, β¨_β©, rfl => rfl
theorem getElem_eq_data_getElem (a : ByteArray) (h : i < a.size) : a[i] = a.data[i] := rfl
@[simp] theorem uset_eq_set (a : ByteArray) {i : USize} (h : i.toNat < a.size... | .lake/packages/batteries/Batteries/Data/ByteArray.lean | 102 | 105 | theorem get_extract_aux {a : ByteArray} {start stop} (h : i < (a.extract start stop).size) :
start + i < a.size := by |
apply Nat.add_lt_of_lt_sub'; apply Nat.lt_of_lt_of_le h
rw [size_extract, β Nat.sub_min_sub_right]; exact Nat.min_le_right ..
| [
" βi < (a.set i v).size",
" (a ++ b).data = a.data ++ b.data",
" (a.append b).data = a.data ++ b.data",
" a.data ++ b.data ++ a.data.extract (a.data.size + b.data.size) a.data.size = a.data ++ b.data",
" (a ++ b).size = a.size + b.size",
" (a.data ++ b.data).size = a.data.size + b.data.size",
" (a ++ b)... | [
" βi < (a.set i v).size",
" (a ++ b).data = a.data ++ b.data",
" (a.append b).data = a.data ++ b.data",
" a.data ++ b.data ++ a.data.extract (a.data.size + b.data.size) a.data.size = a.data ++ b.data",
" (a ++ b).size = a.size + b.size",
" (a.data ++ b.data).size = a.data.size + b.data.size",
" (a ++ b)... |
import Mathlib.Analysis.Normed.Order.Lattice
import Mathlib.MeasureTheory.Function.LpSpace
#align_import measure_theory.function.lp_order from "leanprover-community/mathlib"@"5dc275ec639221ca4d5f56938eb966f6ad9bc89f"
set_option linter.uppercaseLean3 false
open TopologicalSpace MeasureTheory
open scoped ENNReal
... | Mathlib/MeasureTheory/Function/LpOrder.lean | 41 | 42 | theorem coeFn_le (f g : Lp E p ΞΌ) : f β€α΅[ΞΌ] g β f β€ g := by |
rw [β Subtype.coe_le_coe, β AEEqFun.coeFn_le]
| [
" ββf β€αΆ [ae ΞΌ] ββg β f β€ g"
] | [] |
import Mathlib.Data.List.Defs
import Mathlib.Data.Option.Basic
import Mathlib.Data.Nat.Defs
import Mathlib.Init.Data.List.Basic
import Mathlib.Util.AssertExists
-- Make sure we haven't imported `Data.Nat.Order.Basic`
assert_not_exists OrderedSub
namespace List
universe u v
variable {Ξ± : Type u} {Ξ² : Type v} (l :... | Mathlib/Data/List/GetD.lean | 89 | 99 | theorem getD_append_right (l l' : List Ξ±) (d : Ξ±) (n : β) (h : l.length β€ n) :
(l ++ l').getD n d = l'.getD (n - l.length) d := by |
cases Nat.lt_or_ge n (l ++ l').length with
| inl h' =>
rw [getD_eq_get (l ++ l') d h', get_append_right, getD_eq_get]
Β· rw [length_append] at h'
exact Nat.sub_lt_left_of_lt_add h h'
Β· exact Nat.not_lt_of_le h
| inr h' =>
rw [getD_eq_default _ _ h', getD_eq_default]
rwa [Nat.le_sub_iff_a... | [
" l.getD n d = l.get β¨n, hnβ©",
" [].getD n d = [].get β¨n, hnβ©",
" (head :: tail).getD n d = (head :: tail).get β¨n, hnβ©",
" (head :: tail).getD 0 d = (head :: tail).get β¨0, hnβ©",
" (head :: tail).getD (nβ + 1) d = (head :: tail).get β¨nβ + 1, hnβ©",
" (map f l).getD n (f d) = f (l.getD n d)",
" (map f []).... | [
" l.getD n d = l.get β¨n, hnβ©",
" [].getD n d = [].get β¨n, hnβ©",
" (head :: tail).getD n d = (head :: tail).get β¨n, hnβ©",
" (head :: tail).getD 0 d = (head :: tail).get β¨0, hnβ©",
" (head :: tail).getD (nβ + 1) d = (head :: tail).get β¨nβ + 1, hnβ©",
" (map f l).getD n (f d) = f (l.getD n d)",
" (map f []).... |
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 | 513 | 538 | theorem mem_A_of_differentiable {Ξ΅ : β} (hΞ΅ : 0 < Ξ΅) {x : β}
(hx : DifferentiableWithinAt β f (Ici x) x) :
β R > 0, β r β Ioo (0 : β) R, x β A f (derivWithin f (Ici x) x) r Ξ΅ := by |
have := hx.hasDerivWithinAt
simp_rw [hasDerivWithinAt_iff_isLittleO, isLittleO_iff] at this
rcases mem_nhdsWithin_Ici_iff_exists_Ico_subset.1 (this (half_pos hΞ΅)) with β¨m, xm, hmβ©
refine β¨m - x, by linarith [show x < m from xm], fun r hr => ?_β©
have : r β Ioc (r / 2) r := β¨half_lt_self hr.1, le_rflβ©
refine... | [
" A f L r Ξ΅ β π[>] x",
" β u β Ioi x, Ioo x u β A f L r Ξ΅",
" x + r' - s β Ioi x",
" x < x + r' - s",
" β y β Icc x' (x' + s), β z β Icc x' (x' + s), βf z - f y - (z - y) β’ Lβ β€ Ξ΅ * r",
" Icc x' (x' + s) β Icc x (x + r')",
" x' + s β€ x + r'",
" βf z - f y - (z - y) β’ Lβ β€ Ξ΅ * r",
" B f K r s Ξ΅ β π... | [
" A f L r Ξ΅ β π[>] x",
" β u β Ioi x, Ioo x u β A f L r Ξ΅",
" x + r' - s β Ioi x",
" x < x + r' - s",
" β y β Icc x' (x' + s), β z β Icc x' (x' + s), βf z - f y - (z - y) β’ Lβ β€ Ξ΅ * r",
" Icc x' (x' + s) β Icc x (x + r')",
" x' + s β€ x + r'",
" βf z - f y - (z - y) β’ Lβ β€ Ξ΅ * r",
" B f K r s Ξ΅ β π... |
import Mathlib.Topology.MetricSpace.Isometry
#align_import topology.metric_space.gluing from "leanprover-community/mathlib"@"e1a7bdeb4fd826b7e71d130d34988f0a2d26a177"
noncomputable section
universe u v w
open Function Set Uniformity Topology
namespace Metric
namespace Sigma
variable {ΞΉ : Type*} {E : ΞΉ β Type... | Mathlib/Topology/MetricSpace/Gluing.lean | 358 | 361 | theorem fst_eq_of_dist_lt_one (x y : Ξ£i, E i) (h : dist x y < 1) : x.1 = y.1 := by |
cases x; cases y
contrapose! h
apply one_le_dist_of_ne h
| [
" E j = E i",
" dist β¨i, xβ© β¨i, yβ© = dist x y",
" 1 β€ dist β¨i, xβ© β¨j, yβ©",
" 1 β€ dist x β―.some + 1 + dist β―.some y",
" x.fst = y.fst",
" β¨fstβ, sndββ©.fst = y.fst",
" β¨fstβΒΉ, sndβΒΉβ©.fst = β¨fstβ, sndββ©.fst",
" 1 β€ dist β¨fstβΒΉ, sndβΒΉβ© β¨fstβ, sndββ©"
] | [
" E j = E i",
" dist β¨i, xβ© β¨i, yβ© = dist x y",
" 1 β€ dist β¨i, xβ© β¨j, yβ©",
" 1 β€ dist x β―.some + 1 + dist β―.some y"
] |
import Mathlib.Topology.Order.IsLUB
open Set Filter TopologicalSpace Topology Function
open OrderDual (toDual ofDual)
variable {Ξ± Ξ² Ξ³ : Type*}
section DenselyOrdered
variable [TopologicalSpace Ξ±] [LinearOrder Ξ±] [OrderTopology Ξ±] [DenselyOrdered Ξ±] {a b : Ξ±}
{s : Set Ξ±}
theorem closure_Ioi' {a : Ξ±} (h : (Io... | Mathlib/Topology/Order/DenselyOrdered.lean | 101 | 102 | theorem interior_Icc [NoMinOrder Ξ±] [NoMaxOrder Ξ±] {a b : Ξ±} : interior (Icc a b) = Ioo a b := by |
rw [β Ici_inter_Iic, interior_inter, interior_Ici, interior_Iic, Ioi_inter_Iio]
| [
" closure (Ioi a) = Ici a",
" closure (Ioi a) β Ici a",
" Ici a β closure (Ioi a)",
" a β closure (Ioi a)",
" closure (Ioo a b) = Icc a b",
" closure (Ioo a b) β Icc a b",
" Icc a b β closure (Ioo a b)",
" {a, b} β closure (Ioo a b)",
" a β closure (Ioo a b) β§ b β closure (Ioo a b)",
" β
β closure... | [
" closure (Ioi a) = Ici a",
" closure (Ioi a) β Ici a",
" Ici a β closure (Ioi a)",
" a β closure (Ioi a)",
" closure (Ioo a b) = Icc a b",
" closure (Ioo a b) β Icc a b",
" Icc a b β closure (Ioo a b)",
" {a, b} β closure (Ioo a b)",
" a β closure (Ioo a b) β§ b β closure (Ioo a b)",
" β
β closure... |
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 | 146 | 149 | theorem closure_eq_preimage_closure_image (hf : Inducing f) (s : Set X) :
closure s = f β»ΒΉ' closure (f '' s) := by |
ext x
rw [Set.mem_preimage, β closure_induced, hf.induced]
| [
" 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.RingTheory.TensorProduct.Basic
import Mathlib.Algebra.Module.ULift
#align_import ring_theory.is_tensor_product from "leanprover-community/mathlib"@"c4926d76bb9c5a4a62ed2f03d998081786132105"
universe u vβ vβ vβ vβ
open TensorProduct
section IsTensorProduct
variable {R : Type*} [CommSemiring R]
va... | Mathlib/RingTheory/IsTensorProduct.lean | 109 | 112 | theorem IsTensorProduct.map_eq (hf : IsTensorProduct f) (hg : IsTensorProduct g) (iβ : Mβ ββ[R] Nβ)
(iβ : Mβ ββ[R] Nβ) (xβ : Mβ) (xβ : Mβ) : hf.map hg iβ iβ (f xβ xβ) = g (iβ xβ) (iβ xβ) := by |
delta IsTensorProduct.map
simp
| [
" IsTensorProduct (mk R M N)",
" Function.Bijective β(lift (mk R M N))",
" lift (mk R M N) = LinearMap.id",
" β (x : M) (y : N), (lift (mk R M N)) (x ββ[R] y) = LinearMap.id (x ββ[R] y)",
" Function.Bijective βLinearMap.id",
" h.equiv.symm ((f xβ) xβ) = xβ ββ[R] xβ",
" h.equiv (h.equiv.symm ((f xβ) xβ))... | [
" IsTensorProduct (mk R M N)",
" Function.Bijective β(lift (mk R M N))",
" lift (mk R M N) = LinearMap.id",
" β (x : M) (y : N), (lift (mk R M N)) (x ββ[R] y) = LinearMap.id (x ββ[R] y)",
" Function.Bijective βLinearMap.id",
" h.equiv.symm ((f xβ) xβ) = xβ ββ[R] xβ",
" h.equiv (h.equiv.symm ((f xβ) xβ))... |
import Mathlib.Data.ZMod.Basic
import Mathlib.GroupTheory.Index
import Mathlib.GroupTheory.GroupAction.ConjAct
import Mathlib.GroupTheory.GroupAction.Quotient
import Mathlib.GroupTheory.Perm.Cycle.Type
import Mathlib.GroupTheory.SpecificGroups.Cyclic
import Mathlib.Tactic.IntervalCases
#align_import group_theory.p_gr... | Mathlib/GroupTheory/PGroup.lean | 74 | 77 | theorem of_injective {H : Type*} [Group H] (Ο : H β* G) (hΟ : Function.Injective Ο) :
IsPGroup p H := by |
simp_rw [IsPGroup, β hΟ.eq_iff, Ο.map_pow, Ο.map_one]
exact fun h => hG (Ο h)
| [
" g ^ p ^ k = 1",
" g ^ p ^ n = 1",
" card β₯β₯ = p ^ ?m.2806",
" IsPGroup p G β β n, card G = p ^ n",
" β n, card G = p ^ n",
" card G = p ^ (card G).factors.length",
" β q β (card G).factors, q = p",
" q = p",
" IsPGroup p H",
" β (g : H), β k, Ο g ^ p ^ k = 1"
] | [
" g ^ p ^ k = 1",
" g ^ p ^ n = 1",
" card β₯β₯ = p ^ ?m.2806",
" IsPGroup p G β β n, card G = p ^ n",
" β n, card G = p ^ n",
" card G = p ^ (card G).factors.length",
" β q β (card G).factors, q = p",
" q = p"
] |
import Mathlib.Analysis.SpecificLimits.Basic
import Mathlib.Data.Rat.Denumerable
import Mathlib.Data.Set.Pointwise.Interval
import Mathlib.SetTheory.Cardinal.Continuum
#align_import data.real.cardinality from "leanprover-community/mathlib"@"7e7aaccf9b0182576cabdde36cf1b5ad3585b70d"
open Nat Set
open Cardinal
no... | Mathlib/Data/Real/Cardinality.lean | 73 | 75 | theorem cantorFunctionAux_nonneg (h : 0 β€ c) : 0 β€ cantorFunctionAux c f n := by |
cases h' : f n <;> simp [h']
apply pow_nonneg h
| [
" cantorFunctionAux c f n = c ^ n",
" cantorFunctionAux c f n = 0",
" 0 β€ cantorFunctionAux c f n",
" 0 β€ c ^ n"
] | [
" cantorFunctionAux c f n = c ^ n",
" cantorFunctionAux c f n = 0"
] |
import Mathlib.Algebra.BigOperators.Intervals
import Mathlib.Topology.Algebra.InfiniteSum.Order
import Mathlib.Topology.Instances.Real
import Mathlib.Topology.Instances.ENNReal
#align_import topology.algebra.infinite_sum.real from "leanprover-community/mathlib"@"9a59dcb7a2d06bf55da57b9030169219980660cd"
open Filte... | Mathlib/Topology/Algebra/InfiniteSum/Real.lean | 73 | 75 | theorem summable_iff_not_tendsto_nat_atTop_of_nonneg {f : β β β} (hf : β n, 0 β€ f n) :
Summable f β Β¬Tendsto (fun n : β => β i β Finset.range n, f i) atTop atTop := by |
rw [β not_iff_not, Classical.not_not, not_summable_iff_tendsto_nat_atTop_of_nonneg hf]
| [
" CauchySeq f",
" β (n : β), edist (f n) (f n.succ) β€ β(d n)",
" Summable d",
" dist (f n) a β€ β' (m : β), d (n + m)",
" dist (f n) (f m) β€ β' (m : β), d (n + m)",
" β i β Ico n m, d i β€ β' (m : β), d (n + m)",
" β k β range (m - n), d (n + k) β€ β' (m : β), d (n + m)",
" Summable fun k => d (n + k)",
... | [
" CauchySeq f",
" β (n : β), edist (f n) (f n.succ) β€ β(d n)",
" Summable d",
" dist (f n) a β€ β' (m : β), d (n + m)",
" dist (f n) (f m) β€ β' (m : β), d (n + m)",
" β i β Ico n m, d i β€ β' (m : β), d (n + m)",
" β k β range (m - n), d (n + k) β€ β' (m : β), d (n + m)",
" Summable fun k => d (n + k)",
... |
import Mathlib.Algebra.Order.Monoid.OrderDual
import Mathlib.Tactic.Lift
import Mathlib.Tactic.Monotonicity.Attr
open Function
variable {Ξ² G M : Type*}
section Monoid
variable [Monoid M]
section Preorder
variable [Preorder M]
section Left
variable [CovariantClass M M (Β· * Β·) (Β· β€ Β·)] {x : M}
@[to_additive (... | Mathlib/Algebra/Order/Monoid/Unbundled/Pow.lean | 56 | 60 | theorem pow_le_pow_right' {a : M} {n m : β} (ha : 1 β€ a) (h : n β€ m) : a ^ n β€ a ^ m :=
let β¨k, hkβ© := Nat.le.dest h
calc
a ^ n β€ a ^ n * a ^ k := le_mul_of_one_le_right' (one_le_pow_of_one_le' ha _)
_ = a ^ m := by | rw [β hk, pow_add]
| [
" a ^ 0 β€ b ^ 0",
" a ^ (k + 1) β€ b ^ (k + 1)",
" a ^ k * a β€ b ^ k * b",
" 1 β€ a ^ 0",
" 1 β€ a ^ (k + 1)",
" 1 β€ a ^ k * a",
" a ^ n * a ^ k = a ^ m"
] | [
" a ^ 0 β€ b ^ 0",
" a ^ (k + 1) β€ b ^ (k + 1)",
" a ^ k * a β€ b ^ k * b",
" 1 β€ a ^ 0",
" 1 β€ a ^ (k + 1)",
" 1 β€ a ^ k * a"
] |
import Mathlib.Algebra.MvPolynomial.Variables
#align_import data.mv_polynomial.supported from "leanprover-community/mathlib"@"2f5b500a507264de86d666a5f87ddb976e2d8de4"
universe u v w
namespace MvPolynomial
variable {Ο Ο : Type*} {R : Type u} {S : Type v} {r : R} {e : β} {n m : Ο}
section CommSemiring
variable... | Mathlib/Algebra/MvPolynomial/Supported.lean | 59 | 62 | theorem supportedEquivMvPolynomial_symm_C (s : Set Ο) (x : R) :
(supportedEquivMvPolynomial s).symm (C x) = algebraMap R (supported R s) x := by |
ext1
simp [supportedEquivMvPolynomial, MvPolynomial.algebraMap_eq]
| [
" supported R s = (rename Subtype.val).range",
" (aeval fun x => X βx).range = (aeval (X β Subtype.val)).range",
" (supportedEquivMvPolynomial s).symm (C x) = (algebraMap R β₯(supported R s)) x",
" β((supportedEquivMvPolynomial s).symm (C x)) = β((algebraMap R β₯(supported R s)) x)"
] | [
" supported R s = (rename Subtype.val).range",
" (aeval fun x => X βx).range = (aeval (X β Subtype.val)).range"
] |
import Mathlib.Data.Set.Subsingleton
import Mathlib.Order.WithBot
#align_import data.set.image from "leanprover-community/mathlib"@"001ffdc42920050657fd45bd2b8bfbec8eaaeb29"
universe u v
open Function Set
namespace Set
variable {Ξ± Ξ² Ξ³ : Type*} {ΞΉ ΞΉ' : Sort*}
theorem powerset_insert (s : Set Ξ±) (a : Ξ±)... | Mathlib/Data/Set/Image.lean | 693 | 695 | theorem image_univ {f : Ξ± β Ξ²} : f '' univ = range f := by |
ext
simp [image, range]
| [
" π« insert a s = π« s βͺ insert a '' π« s",
" t β π« insert a s β t β π« s βͺ insert a '' π« s",
" t β insert a s β t β s β¨ β x β s, insert a x = t",
" t β insert a s β t β s β¨ β x β s, insert a x = t",
" t β s β¨ β x β s, insert a x = t",
" β x β s, insert a x = t",
" t \\ {a} β s",
" t β insert a s",
... | [
" π« insert a s = π« s βͺ insert a '' π« s",
" t β π« insert a s β t β π« s βͺ insert a '' π« s",
" t β insert a s β t β s β¨ β x β s, insert a x = t",
" t β insert a s β t β s β¨ β x β s, insert a x = t",
" t β s β¨ β x β s, insert a x = t",
" β x β s, insert a x = t",
" t \\ {a} β s",
" t β insert a s",
... |
import Mathlib.Control.Functor.Multivariate
import Mathlib.Data.PFunctor.Multivariate.Basic
import Mathlib.Data.PFunctor.Multivariate.M
import Mathlib.Data.QPF.Multivariate.Basic
#align_import data.qpf.multivariate.constructions.cofix from "leanprover-community/mathlib"@"f694c7dead66f5d4c80f446c796a5aad14707f0e"
... | Mathlib/Data/QPF/Multivariate/Constructions/Cofix.lean | 64 | 66 | theorem corecF_eq {Ξ± : TypeVec n} {Ξ² : Type u} (g : Ξ² β F (Ξ±.append1 Ξ²)) (x : Ξ²) :
M.dest q.P (corecF g x) = appendFun id (corecF g) <$$> repr (g x) := by |
rw [corecF, M.dest_corec]
| [
" M.dest (P F) (corecF g x) = (TypeVec.id ::: corecF g) <$$> repr (g x)"
] | [] |
import Mathlib.Data.Set.Pointwise.SMul
#align_import algebra.add_torsor from "leanprover-community/mathlib"@"9003f28797c0664a49e4179487267c494477d853"
class AddTorsor (G : outParam Type*) (P : Type*) [AddGroup G] extends AddAction G P,
VSub G P where
[nonempty : Nonempty P]
vsub_vadd' : β pβ pβ : P, (pβ ... | Mathlib/Algebra/AddTorsor.lean | 117 | 119 | theorem vadd_vsub_assoc (g : G) (pβ pβ : P) : g +α΅₯ pβ -α΅₯ pβ = g + (pβ -α΅₯ pβ) := by |
apply vadd_right_cancel pβ
rw [vsub_vadd, add_vadd, vsub_vadd]
| [
" gβ = gβ",
" g +α΅₯ pβ -α΅₯ pβ = g + (pβ -α΅₯ pβ)",
" g +α΅₯ pβ -α΅₯ pβ +α΅₯ pβ = g + (pβ -α΅₯ pβ) +α΅₯ pβ"
] | [
" gβ = gβ"
] |
import Mathlib.RingTheory.PowerSeries.Trunc
import Mathlib.RingTheory.PowerSeries.Inverse
import Mathlib.RingTheory.Derivation.Basic
namespace PowerSeries
open Polynomial Derivation Nat
section CommutativeSemiring
variable {R} [CommSemiring R]
noncomputable def derivativeFun (f : Rβ¦Xβ§) : Rβ¦Xβ§ := mk fun n β¦ coef... | Mathlib/RingTheory/PowerSeries/Derivative.lean | 77 | 85 | theorem derivativeFun_mul (f g : Rβ¦Xβ§) :
derivativeFun (f * g) = f β’ g.derivativeFun + g β’ f.derivativeFun := by |
ext n
have hβ : n < n + 1 := lt_succ_self n
have hβ : n < n + 1 + 1 := Nat.lt_add_right _ hβ
rw [coeff_derivativeFun, map_add, coeff_mul_eq_coeff_trunc_mul_trunc _ _ (lt_succ_self _),
smul_eq_mul, smul_eq_mul, coeff_mul_eq_coeff_trunc_mul_truncβ g f.derivativeFun hβ hβ,
coeff_mul_eq_coeff_trunc_mul_tru... | [
" (coeff R n) f.derivativeFun = (coeff R (n + 1)) f * (βn + 1)",
" (βf).derivativeFun = β(derivative f)",
" (coeff R nβ) (βf).derivativeFun = (coeff R nβ) β(derivative f)",
" (f + g).derivativeFun = f.derivativeFun + g.derivativeFun",
" (coeff R nβ) (f + g).derivativeFun = (coeff R nβ) (f.derivativeFun + g.... | [
" (coeff R n) f.derivativeFun = (coeff R (n + 1)) f * (βn + 1)",
" (βf).derivativeFun = β(derivative f)",
" (coeff R nβ) (βf).derivativeFun = (coeff R nβ) β(derivative f)",
" (f + g).derivativeFun = f.derivativeFun + g.derivativeFun",
" (coeff R nβ) (f + g).derivativeFun = (coeff R nβ) (f.derivativeFun + g.... |
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 | 198 | 199 | theorem map [MonoidHomClass F M N] (f : F) {x : M} (h : IsUnit x) : IsUnit (f x) := by |
rcases h with β¨y, rflβ©; exact (Units.map (f : M β* N) y).isUnit
| [
" 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β)",
" IsUnit (f x)",
" IsUnit (f βy)"
] | [
" 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β)"
] |
import Mathlib.Topology.GDelta
import Mathlib.MeasureTheory.Group.Arithmetic
import Mathlib.Topology.Instances.EReal
import Mathlib.Analysis.Normed.Group.Basic
#align_import measure_theory.constructions.borel_space.basic from "leanprover-community/mathlib"@"9f55d0d4363ae59948c33864cbc52e0b12e0e8ce"
noncomputable ... | Mathlib/MeasureTheory/Constructions/BorelSpace/Basic.lean | 63 | 69 | theorem borel_eq_top_of_countable [TopologicalSpace Ξ±] [T1Space Ξ±] [Countable Ξ±] : borel Ξ± = β€ := by |
refine top_le_iff.1 fun s _ => biUnion_of_singleton s βΈ ?_
apply MeasurableSet.biUnion s.to_countable
intro x _
apply MeasurableSet.of_compl
apply GenerateMeasurable.basic
exact isClosed_singleton.isOpen_compl
| [
" borel Ξ± = β€",
" MeasurableSet (β x β s, {x})",
" β b β s, MeasurableSet {b}",
" MeasurableSet {x}",
" MeasurableSet {x}αΆ",
" {x}αΆ β {s | IsOpen s}"
] | [] |
import Mathlib.Algebra.Group.Basic
import Mathlib.Algebra.Group.Pi.Basic
import Mathlib.Order.Fin
import Mathlib.Order.PiLex
import Mathlib.Order.Interval.Set.Basic
#align_import data.fin.tuple.basic from "leanprover-community/mathlib"@"ef997baa41b5c428be3fb50089a7139bf4ee886b"
assert_not_exists MonoidWithZero
un... | Mathlib/Data/Fin/Tuple/Basic.lean | 92 | 104 | theorem cons_update : cons x (update p i y) = update (cons x p) i.succ y := by |
ext j
by_cases h : j = 0
Β· rw [h]
simp [Ne.symm (succ_ne_zero i)]
Β· let j' := pred j h
have : j'.succ = j := succ_pred j h
rw [β this, cons_succ]
by_cases h' : j' = i
Β· rw [h']
simp
Β· have : j'.succ β i.succ := by rwa [Ne, succ_inj]
rw [update_noteq h', update_noteq this, co... | [
" Unique ((i : Fin 0) β Ξ± i)",
" tail (cons x p) = p",
" cons x p i.succ = p i",
" cons x p 0 = x",
" cons x p 1 = p 0",
" cons x p 1 = cons x p (succ 0)",
" cons x (update p i y) = update (cons x p) i.succ y",
" cons x (update p i y) j = update (cons x p) i.succ y j",
" cons x (update p i y) 0 = up... | [
" Unique ((i : Fin 0) β Ξ± i)",
" tail (cons x p) = p",
" cons x p i.succ = p i",
" cons x p 0 = x",
" cons x p 1 = p 0",
" cons x p 1 = cons x p (succ 0)"
] |
import Mathlib.MeasureTheory.Integral.IntervalIntegral
import Mathlib.Analysis.Calculus.Deriv.ZPow
import Mathlib.Analysis.NormedSpace.Pointwise
import Mathlib.Analysis.SpecialFunctions.NonIntegrable
import Mathlib.Analysis.Analytic.Basic
#align_import measure_theory.integral.circle_integral from "leanprover-communit... | Mathlib/MeasureTheory/Integral/CircleIntegral.lean | 114 | 114 | theorem abs_circleMap_zero (R : β) (ΞΈ : β) : abs (circleMap 0 R ΞΈ) = |R| := by | simp [circleMap]
| [
" circleMap c R (ΞΈ + 2 * Ο) = circleMap c R ΞΈ",
" circleMap c R ΞΈ - c = circleMap 0 R ΞΈ",
" Complex.abs (circleMap 0 R ΞΈ) = |R|"
] | [
" circleMap c R (ΞΈ + 2 * Ο) = circleMap c R ΞΈ",
" circleMap c R ΞΈ - c = circleMap 0 R ΞΈ"
] |
import Mathlib.Topology.MetricSpace.Basic
#align_import topology.metric_space.infsep from "leanprover-community/mathlib"@"5316314b553dcf8c6716541851517c1a9715e22b"
variable {Ξ± Ξ² : Type*}
namespace Set
section Einfsep
open ENNReal
open Function
noncomputable def einfsep [EDist Ξ±] (s : Set Ξ±) : ββ₯0β :=
β¨
(x... | Mathlib/Topology/MetricSpace/Infsep.lean | 84 | 86 | theorem nontrivial_of_einfsep_lt_top (hs : s.einfsep < β) : s.Nontrivial := by |
rcases einfsep_lt_top.1 hs with β¨_, hx, _, hy, hxy, _β©
exact β¨_, hx, _, hy, hxyβ©
| [
" d β€ s.einfsep β β x β s, β y β s, x β y β d β€ edist x y",
" s.einfsep = 0 β β C > 0, β x β s, β y β s, x β y β§ edist x y < C",
" 0 < s.einfsep β β C > 0, β x β s, β y β s, x β y β C β€ edist x y",
" (Β¬β C > 0, β x β s, β y β s, x β y β§ edist x y < C) β β C > 0, β x β s, β y β s, x β y β C β€ edist x y",
" s... | [
" d β€ s.einfsep β β x β s, β y β s, x β y β d β€ edist x y",
" s.einfsep = 0 β β C > 0, β x β s, β y β s, x β y β§ edist x y < C",
" 0 < s.einfsep β β C > 0, β x β s, β y β s, x β y β C β€ edist x y",
" (Β¬β C > 0, β x β s, β y β s, x β y β§ edist x y < C) β β C > 0, β x β s, β y β s, x β y β C β€ edist x y",
" s... |
import Mathlib.RingTheory.Localization.FractionRing
import Mathlib.RingTheory.Localization.Ideal
import Mathlib.RingTheory.Noetherian
#align_import ring_theory.localization.submodule from "leanprover-community/mathlib"@"1ebb20602a8caef435ce47f6373e1aa40851a177"
variable {R : Type*} [CommRing R] (M : Submonoid R) ... | Mathlib/RingTheory/Localization/Submodule.lean | 94 | 96 | theorem isNoetherianRing (h : IsNoetherianRing R) : IsNoetherianRing S := by |
rw [isNoetherianRing_iff, isNoetherian_iff_wellFounded] at h β’
exact OrderEmbedding.wellFounded (IsLocalization.orderEmbedding M S).dual h
| [
" coeSubmodule S β₯ = β₯",
" coeSubmodule S β€ = 1",
" coeSubmodule S (Ideal.span s) = Submodule.span R (β(algebraMap R S) '' s)",
" Submodule.span R (β(Algebra.linearMap R S) '' s) = Submodule.span R (β(algebraMap R S) '' s)",
" coeSubmodule S (Ideal.span {x}) = Submodule.span R {(algebraMap R S) x}",
" IsN... | [
" coeSubmodule S β₯ = β₯",
" coeSubmodule S β€ = 1",
" coeSubmodule S (Ideal.span s) = Submodule.span R (β(algebraMap R S) '' s)",
" Submodule.span R (β(Algebra.linearMap R S) '' s) = Submodule.span R (β(algebraMap R S) '' s)",
" coeSubmodule S (Ideal.span {x}) = Submodule.span R {(algebraMap R S) x}"
] |
import Mathlib.Analysis.Calculus.Deriv.ZPow
import Mathlib.Analysis.SpecialFunctions.Sqrt
import Mathlib.Analysis.SpecialFunctions.Log.Deriv
import Mathlib.Analysis.SpecialFunctions.Trigonometric.Deriv
import Mathlib.Analysis.Convex.Deriv
#align_import analysis.convex.specific_functions.deriv from "leanprover-communi... | Mathlib/Analysis/Convex/SpecificFunctions/Deriv.lean | 40 | 44 | theorem strictConvexOn_pow {n : β} (hn : 2 β€ n) : StrictConvexOn β (Ici 0) fun x : β => x ^ n := by |
apply StrictMonoOn.strictConvexOn_of_deriv (convex_Ici _) (continuousOn_pow _)
rw [deriv_pow', interior_Ici]
exact fun x (hx : 0 < x) y _ hxy => mul_lt_mul_of_pos_left
(pow_lt_pow_left hxy hx.le <| Nat.sub_ne_zero_of_lt hn) (by positivity)
| [
" StrictConvexOn β (Ici 0) fun x => x ^ n",
" StrictMonoOn (deriv fun x => x ^ n) (interior (Ici 0))",
" StrictMonoOn (fun x => βn * x ^ (n - 1)) (Ioi 0)",
" 0 < βn"
] | [] |
import Mathlib.Analysis.SpecialFunctions.Complex.Arg
import Mathlib.Analysis.SpecialFunctions.Log.Basic
#align_import analysis.special_functions.complex.log from "leanprover-community/mathlib"@"f2ce6086713c78a7f880485f7917ea547a215982"
noncomputable section
namespace Complex
open Set Filter Bornology
open scop... | Mathlib/Analysis/SpecialFunctions/Complex/Log.lean | 65 | 67 | theorem exp_inj_of_neg_pi_lt_of_le_pi {x y : β} (hxβ : -Ο < x.im) (hxβ : x.im β€ Ο) (hyβ : -Ο < y.im)
(hyβ : y.im β€ Ο) (hxy : exp x = exp y) : x = y := by |
rw [β log_exp hxβ hxβ, β log_exp hyβ hyβ, hxy]
| [
" x.log.re = (abs x).log",
" x.log.im = x.arg",
" -Ο < x.log.im",
" x.log.im β€ Ο",
" cexp x.log = x",
" x β Set.range cexp β x β {0}αΆ",
" cexp x β {0}αΆ",
" (cexp x).log = x",
" x = y"
] | [
" x.log.re = (abs x).log",
" x.log.im = x.arg",
" -Ο < x.log.im",
" x.log.im β€ Ο",
" cexp x.log = x",
" x β Set.range cexp β x β {0}αΆ",
" cexp x β {0}αΆ",
" (cexp x).log = x"
] |
import Mathlib.Data.Matrix.Basis
import Mathlib.Data.Matrix.DMatrix
import Mathlib.LinearAlgebra.Matrix.Determinant.Basic
import Mathlib.LinearAlgebra.Matrix.Reindex
import Mathlib.Tactic.FieldSimp
#align_import linear_algebra.matrix.transvection from "leanprover-community/mathlib"@"0e2aab2b0d521f060f62a14d2cf2e2c54e... | Mathlib/LinearAlgebra/Matrix/Transvection.lean | 94 | 108 | theorem updateRow_eq_transvection [Finite n] (c : R) :
updateRow (1 : Matrix n n R) i ((1 : Matrix n n R) i + c β’ (1 : Matrix n n R) j) =
transvection i j c := by |
cases nonempty_fintype n
ext a b
by_cases ha : i = a
Β· by_cases hb : j = b
Β· simp only [updateRow_self, transvection, ha, hb, Pi.add_apply, StdBasisMatrix.apply_same,
one_apply_eq, Pi.smul_apply, mul_one, Algebra.id.smul_eq_mul, add_apply]
Β· simp only [updateRow_self, transvection, ha, hb, StdB... | [
" transvection i j 0 = 1",
" updateRow 1 i (1 i + c β’ 1 j) = transvection i j c",
" updateRow 1 i (1 i + c β’ 1 j) a b = transvection i j c a b"
] | [
" transvection i j 0 = 1"
] |
import Mathlib.Data.Set.Finite
import Mathlib.GroupTheory.GroupAction.FixedPoints
import Mathlib.GroupTheory.Perm.Support
open Equiv List MulAction Pointwise Set Subgroup
variable {G Ξ± : Type*} [Group G] [MulAction G Ξ±] [DecidableEq Ξ±]
theorem finite_compl_fixedBy_closure_iff {S : Set G} :
(β g β closure S, ... | Mathlib/GroupTheory/Perm/ClosureSwap.lean | 92 | 114 | theorem mem_closure_isSwap {S : Set (Perm Ξ±)} (hS : β f β S, f.IsSwap) {f : Perm Ξ±} :
f β closure S β (fixedBy Ξ± f)αΆ.Finite β§ β x, f x β orbit (closure S) x := by |
refine β¨fun hf β¦ β¨?_, fun x β¦ mem_orbit_iff.mpr β¨β¨f, hfβ©, rflβ©β©, ?_β©
Β· exact finite_compl_fixedBy_closure_iff.mpr (fun f hf β¦ (hS f hf).finite_compl_fixedBy) _ hf
rintro β¨fin, hfβ©
set supp := (fixedBy Ξ± f)αΆ with supp_eq
suffices h : (fixedBy Ξ± f)αΆ β supp β f β closure S from h supp_eq.symm.subset
clear_val... | [
" (fixedBy Ξ± g)αΆ.Finite",
" (fixedBy Ξ± 1)αΆ.Finite",
" β (x : G), (fixedBy Ξ± x)αΆ.Finite β (fixedBy Ξ± xβ»ΒΉ)αΆ.Finite",
" (fixedBy Ξ± (g * g'))αΆ β (fixedBy Ξ± g)αΆ βͺ (fixedBy Ξ± g')αΆ",
" {x, y}.Finite",
" z β fixedBy Ξ± (swap x y)",
" z β x",
" z β y",
" False",
" (fixedBy Ξ± Ο)αΆ.Finite",
" (fixedBy Ξ± (swa... | [
" (fixedBy Ξ± g)αΆ.Finite",
" (fixedBy Ξ± 1)αΆ.Finite",
" β (x : G), (fixedBy Ξ± x)αΆ.Finite β (fixedBy Ξ± xβ»ΒΉ)αΆ.Finite",
" (fixedBy Ξ± (g * g'))αΆ β (fixedBy Ξ± g)αΆ βͺ (fixedBy Ξ± g')αΆ",
" {x, y}.Finite",
" z β fixedBy Ξ± (swap x y)",
" z β x",
" z β y",
" False",
" (fixedBy Ξ± Ο)αΆ.Finite",
" (fixedBy Ξ± (swa... |
import Mathlib.Analysis.NormedSpace.Multilinear.Curry
#align_import analysis.calculus.formal_multilinear_series from "leanprover-community/mathlib"@"f2ce6086713c78a7f880485f7917ea547a215982"
noncomputable section
open Set Fin Topology
-- Porting note: added explicit universes to fix compile
universe u u' v w x
... | Mathlib/Analysis/Calculus/FormalMultilinearSeries.lean | 119 | 124 | theorem congr (p : FormalMultilinearSeries π E F) {m n : β} {v : Fin m β E} {w : Fin n β E}
(h1 : m = n) (h2 : β (i : β) (him : i < m) (hin : i < n), v β¨i, himβ© = w β¨i, hinβ©) :
p m v = p n w := by |
subst n
congr with β¨i, hiβ©
exact h2 i hi hi
| [
" p.removeZero n = p n",
" p.removeZero n.pred.succ = p n.pred.succ",
" (p m) v = (p n) w",
" (p m) v = (p m) w",
" v β¨i, hiβ© = w β¨i, hiβ©"
] | [
" p.removeZero n = p n",
" p.removeZero n.pred.succ = p n.pred.succ"
] |
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 | 54 | 68 | theorem isUnital_leftAdd : EckmannHilton.IsUnital (Β· +β Β·) 0 := by |
have hr : β f : X βΆ Y, biprod.lift (0 : X βΆ Y) f = f β« biprod.inr := by
intro f
ext
Β· aesop_cat
Β· simp [biprod.lift_fst, Category.assoc, biprod.inr_fst, comp_zero]
have hl : β f : X βΆ Y, biprod.lift f (0 : X βΆ Y) = f β« biprod.inl := by
intro f
ext
Β· aesop_cat
Β· simp [biprod.lift_snd... | [
" 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.Algebra.Group.Semiconj.Defs
import Mathlib.Algebra.Ring.Defs
#align_import algebra.ring.semiconj from "leanprover-community/mathlib"@"70d50ecfd4900dd6d328da39ab7ebd516abe4025"
universe u v w x
variable {Ξ± : Type u} {Ξ² : Type v} {Ξ³ : Type w} {R : Type x}
open Function
namespace SemiconjBy
@[simp... | Mathlib/Algebra/Ring/Semiconj.lean | 39 | 41 | theorem add_left [Distrib R] {a b x y : R} (ha : SemiconjBy a x y) (hb : SemiconjBy b x y) :
SemiconjBy (a + b) x y := by |
simp only [SemiconjBy, left_distrib, right_distrib, ha.eq, hb.eq]
| [
" SemiconjBy a (x + x') (y + y')",
" SemiconjBy (a + b) x y"
] | [
" SemiconjBy a (x + x') (y + y')"
] |
import Mathlib.Analysis.NormedSpace.Basic
import Mathlib.Topology.Algebra.Module.Basic
#align_import analysis.normed_space.basic from "leanprover-community/mathlib"@"bc91ed7093bf098d253401e69df601fc33dde156"
open Metric Set Function Filter
open scoped NNReal Topology
instance Real.punctured_nhds_module_neBot {E ... | Mathlib/Analysis/NormedSpace/Real.lean | 106 | 107 | theorem interior_sphere (x : E) {r : β} (hr : r β 0) : interior (sphere x r) = β
:= by |
rw [β frontier_closedBall x hr, interior_frontier isClosed_ball]
| [
" βxββ»ΒΉ β’ x β closedBall 0 1",
" βt β’ xβ = t * βxβ",
" dist (r β’ x + (1 - r) β’ y) x = β1 - rβ * βx - yβ",
" β1 - rβ * βx - yβ = (1 - r) * dist y x",
" (1 - r) * dist y x β€ (1 - 0) * dist y x",
" 0 β€ r",
" (1 - 0) * dist y x = dist y x",
" closure (ball x r) = closedBall x r",
" y β closure (ball x r... | [
" βxββ»ΒΉ β’ x β closedBall 0 1",
" βt β’ xβ = t * βxβ",
" dist (r β’ x + (1 - r) β’ y) x = β1 - rβ * βx - yβ",
" β1 - rβ * βx - yβ = (1 - r) * dist y x",
" (1 - r) * dist y x β€ (1 - 0) * dist y x",
" 0 β€ r",
" (1 - 0) * dist y x = dist y x",
" closure (ball x r) = closedBall x r",
" y β closure (ball x r... |
import Mathlib.Topology.ContinuousFunction.ZeroAtInfty
open Topology Filter
variable {E F π : Type*}
variable [SeminormedAddGroup E] [SeminormedAddCommGroup F]
variable [FunLike π E F] [ZeroAtInftyContinuousMapClass π E F]
theorem ZeroAtInftyContinuousMapClass.norm_le (f : π) (Ξ΅ : β) (hΞ΅ : 0 < Ξ΅) :
β (r ... | Mathlib/Analysis/Normed/Group/ZeroAtInfty.lean | 38 | 49 | theorem zero_at_infty_of_norm_le (f : E β F)
(h : β (Ξ΅ : β) (_hΞ΅ : 0 < Ξ΅), β (r : β), β (x : E) (_hx : r < βxβ), βf xβ < Ξ΅) :
Tendsto f (cocompact E) (π 0) := by |
rw [tendsto_zero_iff_norm_tendsto_zero]
intro s hs
rw [mem_map, Metric.mem_cocompact_iff_closedBall_compl_subset 0]
rw [Metric.mem_nhds_iff] at hs
rcases hs with β¨Ξ΅, hΞ΅, hsβ©
rcases h Ξ΅ hΞ΅ with β¨r, hrβ©
use r
intro
aesop
| [
" β r, β (x : E), r < βxβ β βf xβ < Ξ΅",
" β (x : E), r < βxβ β βf xβ < Ξ΅",
" βf xβ < Ξ΅",
" x β (fun x => βf xβ) β»ΒΉ' Metric.ball 0 Ξ΅",
" x β (Metric.closedBall 0 r)αΆ",
" Tendsto f (cocompact E) (π 0)",
" Tendsto (fun x => βf xβ) (cocompact E) (π 0)",
" s β map (fun x => βf xβ) (cocompact E)",
" β r... | [
" β r, β (x : E), r < βxβ β βf xβ < Ξ΅",
" β (x : E), r < βxβ β βf xβ < Ξ΅",
" βf xβ < Ξ΅",
" x β (fun x => βf xβ) β»ΒΉ' Metric.ball 0 Ξ΅",
" x β (Metric.closedBall 0 r)αΆ"
] |
import Mathlib.Algebra.Group.Units
import Mathlib.Algebra.GroupWithZero.Basic
import Mathlib.Logic.Equiv.Defs
import Mathlib.Tactic.Contrapose
import Mathlib.Tactic.Nontriviality
import Mathlib.Tactic.Spread
import Mathlib.Util.AssertExists
#align_import algebra.group_with_zero.units.basic from "leanprover-community/... | Mathlib/Algebra/GroupWithZero/Units/Basic.lean | 126 | 127 | theorem mul_inverse_cancel_left (x y : Mβ) (h : IsUnit x) : x * (inverse x * y) = y := by |
rw [β mul_assoc, mul_inverse_cancel x h, one_mul]
| [
" 0 = 1",
" inverse βu = βuβ»ΒΉ",
" x * inverse x = 1",
" βu * inverse βu = 1",
" inverse x * x = 1",
" inverse βu * βu = 1",
" y * x * inverse x = y",
" y * inverse x * x = y",
" x * (inverse x * y) = y"
] | [
" 0 = 1",
" inverse βu = βuβ»ΒΉ",
" x * inverse x = 1",
" βu * inverse βu = 1",
" inverse x * x = 1",
" inverse βu * βu = 1",
" y * x * inverse x = y",
" y * inverse x * x = y"
] |
import Mathlib.RingTheory.AdjoinRoot
import Mathlib.FieldTheory.Minpoly.Field
import Mathlib.RingTheory.Polynomial.GaussLemma
#align_import field_theory.minpoly.is_integrally_closed from "leanprover-community/mathlib"@"f0c8bf9245297a541f468be517f1bde6195105e9"
open scoped Classical Polynomial
open Polynomial Set... | Mathlib/FieldTheory/Minpoly/IsIntegrallyClosed.lean | 75 | 92 | theorem isIntegrallyClosed_dvd {s : S} (hs : IsIntegral R s) {p : R[X]}
(hp : Polynomial.aeval s p = 0) : minpoly R s β£ p := by |
let K := FractionRing R
let L := FractionRing S
let _ : Algebra K L := FractionRing.liftAlgebra R L
have := FractionRing.isScalarTower_liftAlgebra R L
have : minpoly K (algebraMap S L s) β£ map (algebraMap R K) (p %β minpoly R s) := by
rw [map_modByMonic _ (minpoly.monic hs), modByMonic_eq_sub_mul_div]
... | [
" minpoly K ((algebraMap S L) s) = map (algebraMap R K) (minpoly R s)",
" Irreducible (map (algebraMap R K) (minpoly R s))",
" (Polynomial.aeval ((algebraMap S L) s)) (map (algebraMap R K) (minpoly R s)) = 0",
" (map (algebraMap R K) (minpoly R s)).Monic",
" minpoly K s = map (algebraMap R K) (minpoly R s)"... | [
" minpoly K ((algebraMap S L) s) = map (algebraMap R K) (minpoly R s)",
" Irreducible (map (algebraMap R K) (minpoly R s))",
" (Polynomial.aeval ((algebraMap S L) s)) (map (algebraMap R K) (minpoly R s)) = 0",
" (map (algebraMap R K) (minpoly R s)).Monic",
" minpoly K s = map (algebraMap R K) (minpoly R s)"... |
import Mathlib.Analysis.Convex.Hull
import Mathlib.LinearAlgebra.AffineSpace.Independent
#align_import analysis.convex.simplicial_complex.basic from "leanprover-community/mathlib"@"70fd9563a21e7b963887c9360bd29b2393e6225a"
open Finset Set
variable (π E : Type*) {ΞΉ : Type*} [OrderedRing π] [AddCommGroup E] [Mod... | Mathlib/Analysis/Convex/SimplicialComplex/Basic.lean | 91 | 93 | theorem convexHull_subset_space (hs : s β K.faces) : convexHull π βs β K.space := by |
convert subset_biUnion_of_mem hs
rfl
| [
" x β K.space β β s β K.faces, x β (convexHull π) βs",
" (convexHull π) βs β K.space",
" (convexHull π) βs = (convexHull π) βs"
] | [
" x β K.space β β s β K.faces, x β (convexHull π) βs"
] |
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 | 115 | 117 | theorem pderiv_mul {i : Ο} {f g : MvPolynomial Ο R} :
pderiv i (f * g) = pderiv i f * g + f * pderiv i g := by |
simp only [(pderiv i).leibniz f g, smul_eq_mul, mul_comm, add_comm]
| [
" 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.Analysis.Convex.StrictConvexSpace
#align_import analysis.convex.uniform from "leanprover-community/mathlib"@"17ef379e997badd73e5eabb4d38f11919ab3c4b3"
open Set Metric
open Convex Pointwise
class UniformConvexSpace (E : Type*) [SeminormedAddCommGroup E] : Prop where
uniform_convex : β β¦Ξ΅ : ββ¦,
... | Mathlib/Analysis/Convex/Uniform.lean | 115 | 126 | theorem exists_forall_closed_ball_dist_add_le_two_mul_sub (hΞ΅ : 0 < Ξ΅) (r : β) :
β Ξ΄, 0 < Ξ΄ β§ β β¦x : Eβ¦, βxβ β€ r β β β¦yβ¦, βyβ β€ r β Ξ΅ β€ βx - yβ β βx + yβ β€ 2 * r - Ξ΄ := by |
obtain hr | hr := le_or_lt r 0
Β· exact β¨1, one_pos, fun x hx y hy h => (hΞ΅.not_le <|
h.trans <| (norm_sub_le _ _).trans <| add_nonpos (hx.trans hr) (hy.trans hr)).elimβ©
obtain β¨Ξ΄, hΞ΄, hβ© := exists_forall_closed_ball_dist_add_le_two_sub E (div_pos hΞ΅ hr)
refine β¨Ξ΄ * r, mul_pos hΞ΄ hr, fun x hx y hy hxy => ... | [
" β Ξ΄, 0 < Ξ΄ β§ β β¦x : Eβ¦, βxβ β€ 1 β β β¦y : Eβ¦, βyβ β€ 1 β Ξ΅ β€ βx - yβ β βx + yβ β€ 2 - Ξ΄",
" βx + yβ β€ 2 - Ξ΄'",
" βx + yβ β€ 1 + 1 - Ξ΄'",
" β (z : E), 1 - Ξ΄' < βzβ β ββzββ»ΒΉ β’ zβ = 1",
" ββzββ»ΒΉ β’ zβ = 1",
" β (z : E), βzβ β€ 1 β 1 - Ξ΄' β€ βzβ β ββzββ»ΒΉ β’ z - zβ β€ Ξ΄'",
" ββzββ»ΒΉ β’ z - zβ β€ Ξ΄'",
" ββzββ»ΒΉ β’ z - ... | [
" β Ξ΄, 0 < Ξ΄ β§ β β¦x : Eβ¦, βxβ β€ 1 β β β¦y : Eβ¦, βyβ β€ 1 β Ξ΅ β€ βx - yβ β βx + yβ β€ 2 - Ξ΄",
" βx + yβ β€ 2 - Ξ΄'",
" βx + yβ β€ 1 + 1 - Ξ΄'",
" β (z : E), 1 - Ξ΄' < βzβ β ββzββ»ΒΉ β’ zβ = 1",
" ββzββ»ΒΉ β’ zβ = 1",
" β (z : E), βzβ β€ 1 β 1 - Ξ΄' β€ βzβ β ββzββ»ΒΉ β’ z - zβ β€ Ξ΄'",
" ββzββ»ΒΉ β’ z - zβ β€ Ξ΄'",
" ββzββ»ΒΉ β’ z - ... |
import Mathlib.Algebra.GeomSum
import Mathlib.Order.Filter.Archimedean
import Mathlib.Order.Iterate
import Mathlib.Topology.Algebra.Algebra
import Mathlib.Topology.Algebra.InfiniteSum.Real
#align_import analysis.specific_limits.basic from "leanprover-community/mathlib"@"57ac39bd365c2f80589a700f9fbb664d3a1a30c2"
n... | Mathlib/Analysis/SpecificLimits/Basic.lean | 39 | 41 | theorem tendsto_const_div_atTop_nhds_zero_nat (C : β) :
Tendsto (fun n : β β¦ C / n) atTop (π 0) := by |
simpa only [mul_zero] using tendsto_const_nhds.mul tendsto_inverse_atTop_nhds_zero_nat
| [
" Tendsto (fun n => C / βn) atTop (π 0)"
] | [] |
import Mathlib.LinearAlgebra.Ray
import Mathlib.Analysis.NormedSpace.Real
#align_import analysis.normed_space.ray from "leanprover-community/mathlib"@"92ca63f0fb391a9ca5f22d2409a6080e786d99f7"
open Real
variable {E : Type*} [SeminormedAddCommGroup E] [NormedSpace β E] {F : Type*}
[NormedAddCommGroup F] [NormedSp... | Mathlib/Analysis/NormedSpace/Ray.lean | 32 | 35 | theorem norm_add (h : SameRay β x y) : βx + yβ = βxβ + βyβ := by |
rcases h.exists_eq_smul with β¨u, a, b, ha, hb, -, rfl, rflβ©
rw [β add_smul, norm_smul_of_nonneg (add_nonneg ha hb), norm_smul_of_nonneg ha,
norm_smul_of_nonneg hb, add_mul]
| [
" βx + yβ = βxβ + βyβ",
" βa β’ u + b β’ uβ = βa β’ uβ + βb β’ uβ"
] | [] |
import Mathlib.Algebra.Module.BigOperators
import Mathlib.Data.Fintype.BigOperators
import Mathlib.LinearAlgebra.AffineSpace.AffineMap
import Mathlib.LinearAlgebra.AffineSpace.AffineSubspace
import Mathlib.LinearAlgebra.Finsupp
import Mathlib.Tactic.FinCases
#align_import linear_algebra.affine_space.combination from ... | Mathlib/LinearAlgebra/AffineSpace/Combination.lean | 86 | 91 | theorem weightedVSubOfPoint_congr {wβ wβ : ΞΉ β k} (hw : β i β s, wβ i = wβ i) {pβ pβ : ΞΉ β P}
(hp : β i β s, pβ i = pβ i) (b : P) :
s.weightedVSubOfPoint pβ b wβ = s.weightedVSubOfPoint pβ b wβ := by |
simp_rw [weightedVSubOfPoint_apply]
refine sum_congr rfl fun i hi => ?_
rw [hw i hi, hp i hi]
| [
" univ = {0, 1}",
" x β univ β x β {0, 1}",
" β¨0, β―β© β univ β β¨0, β―β© β {0, 1}",
" β¨1, β―β© β univ β β¨1, β―β© β {0, 1}",
" (s.weightedVSubOfPoint p b) w = β i β s, w i β’ (p i -α΅₯ b)",
" (s.weightedVSubOfPoint (fun x => p) b) w = (β i β s, w i) β’ (p -α΅₯ b)",
" (s.weightedVSubOfPoint pβ b) wβ = (s.weightedVSubOf... | [
" univ = {0, 1}",
" x β univ β x β {0, 1}",
" β¨0, β―β© β univ β β¨0, β―β© β {0, 1}",
" β¨1, β―β© β univ β β¨1, β―β© β {0, 1}",
" (s.weightedVSubOfPoint p b) w = β i β s, w i β’ (p i -α΅₯ b)",
" (s.weightedVSubOfPoint (fun x => p) b) w = (β i β s, w i) β’ (p -α΅₯ b)"
] |
import Mathlib.Analysis.InnerProductSpace.PiL2
import Mathlib.Combinatorics.Additive.AP.Three.Defs
import Mathlib.Combinatorics.Pigeonhole
import Mathlib.Data.Complex.ExponentialBounds
#align_import combinatorics.additive.behrend from "leanprover-community/mathlib"@"4fa54b337f7d52805480306db1b1439c741848c8"
open N... | Mathlib/Combinatorics/Additive/AP/Three/Behrend.lean | 101 | 101 | theorem card_box : (box n d).card = d ^ n := by | simp [box]
| [
" ThreeAPFree (frontier s)",
" a = b",
" (1 / 2) β’ a + (1 / 2) β’ c = b",
" 2 β 0",
" a = (1 / 2) β’ a + (1 / 2) β’ c",
" c = (2β»ΒΉ + 2β»ΒΉ) β’ c",
" c = 1 β’ c",
" ThreeAPFree (sphere x r)",
" ThreeAPFree (sphere x 0)",
" ThreeAPFree {x}",
" sphere x r = frontier (closedBall x r)",
" x β box n d β β ... | [
" ThreeAPFree (frontier s)",
" a = b",
" (1 / 2) β’ a + (1 / 2) β’ c = b",
" 2 β 0",
" a = (1 / 2) β’ a + (1 / 2) β’ c",
" c = (2β»ΒΉ + 2β»ΒΉ) β’ c",
" c = 1 β’ c",
" ThreeAPFree (sphere x r)",
" ThreeAPFree (sphere x 0)",
" ThreeAPFree {x}",
" sphere x r = frontier (closedBall x r)",
" x β box n d β β ... |
import Mathlib.Analysis.Calculus.Deriv.Basic
import Mathlib.Analysis.Calculus.FDeriv.Comp
import Mathlib.Analysis.Calculus.FDeriv.RestrictScalars
#align_import analysis.calculus.deriv.comp from "leanprover-community/mathlib"@"3bce8d800a6f2b8f63fe1e588fd76a9ff4adcebe"
universe u v w
open scoped Classical
open Top... | Mathlib/Analysis/Calculus/Deriv/Comp.lean | 118 | 120 | theorem HasStrictDerivAt.scomp (hg : HasStrictDerivAt gβ gβ' (h x)) (hh : HasStrictDerivAt h h' x) :
HasStrictDerivAt (gβ β h) (h' β’ gβ') x := by |
simpa using ((hg.restrictScalars π).comp x hh).hasStrictDerivAt
| [
" HasDerivAtFilter (gβ β h) (h' β’ gβ') x L",
" HasDerivAt (gβ β h) (h' β’ gβ') x",
" HasDerivWithinAt (gβ β h) (h' β’ gβ') s x",
" HasStrictDerivAt (gβ β h) (h' β’ gβ') x"
] | [
" HasDerivAtFilter (gβ β h) (h' β’ gβ') x L",
" HasDerivAt (gβ β h) (h' β’ gβ') x",
" HasDerivWithinAt (gβ β h) (h' β’ gβ') s x"
] |
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 | 79 | 104 | theorem norm_eq_of_angle_sub_eq_angle_sub_rev_of_angle_ne_pi {x y : V}
(h : angle x (x - y) = angle y (y - x)) (hpi : angle x y β Ο) : βxβ = βyβ := by |
replace h := Real.arccos_injOn (abs_le.mp (abs_real_inner_div_norm_mul_norm_le_one x (x - y)))
(abs_le.mp (abs_real_inner_div_norm_mul_norm_le_one y (y - x))) h
by_cases hxy : x = y
Β· rw [hxy]
Β· rw [β norm_neg (y - x), neg_sub, mul_comm, mul_comm βyβ, div_eq_mul_inv, div_eq_mul_inv,
mul_inv_rev, mul_... | [
" β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β",
" βyβ = βxβ",
" False"
] | [
" β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"
] |
import Mathlib.Data.Set.Basic
#align_import order.well_founded from "leanprover-community/mathlib"@"2c84c2c5496117349007d97104e7bbb471381592"
variable {Ξ± Ξ² Ξ³ : Type*}
namespace WellFounded
variable {r r' : Ξ± β Ξ± β Prop}
#align well_founded_relation.r WellFoundedRelation.rel
protected theorem isAsymm (h : Well... | Mathlib/Order/WellFounded.lean | 82 | 89 | theorem wellFounded_iff_has_min {r : Ξ± β Ξ± β Prop} :
WellFounded r β β s : Set Ξ±, s.Nonempty β β m β s, β x β s, Β¬r x m := by |
refine β¨fun h => h.has_min, fun h => β¨fun x => ?_β©β©
by_contra hx
obtain β¨m, hm, hm'β© := h {x | Β¬Acc r x} β¨x, hxβ©
refine hm β¨_, fun y hy => ?_β©
by_contra hy'
exact hm' y hy' hy
| [
" WellFounded r β β (s : Set Ξ±), s.Nonempty β β m β s, β x β s, Β¬r x m",
" Acc r x",
" False",
" Acc r y"
] | [] |
import Mathlib.CategoryTheory.Abelian.Opposite
import Mathlib.CategoryTheory.Limits.Preserves.Shapes.Zero
import Mathlib.CategoryTheory.Limits.Preserves.Shapes.Kernels
import Mathlib.CategoryTheory.Preadditive.LeftExact
import Mathlib.CategoryTheory.Adjunction.Limits
import Mathlib.Algebra.Homology.Exact
import Mathli... | Mathlib/CategoryTheory/Abelian/Exact.lean | 115 | 120 | theorem exact_epi_comp_iff {W : C} (h : W βΆ X) [Epi h] : Exact (h β« f) g β Exact f g := by |
refine β¨fun hfg => ?_, fun h => exact_epi_comp hβ©
let hc := isCokernelOfComp _ _ (colimit.isColimit (parallelPair (h β« f) 0))
(by rw [β cancel_epi h, β Category.assoc, CokernelCofork.condition, comp_zero]) rfl
refine (exact_iff' _ _ (limit.isLimit _) hc).2 β¨?_, ((exact_iff _ _).1 hfg).2β©
exact zero_of_epi_... | [
" Exact f g β imageSubobject f = kernelSubobject g",
" Exact f g β imageSubobject f = kernelSubobject g",
" imageSubobject f = kernelSubobject g",
" (asIso (imageToKernel f g β―)).hom β« (kernelSubobject g).arrow = (imageSubobject f).arrow",
" imageSubobject f = kernelSubobject g β Exact f g",
" Exact f g β... | [
" Exact f g β imageSubobject f = kernelSubobject g",
" Exact f g β imageSubobject f = kernelSubobject g",
" imageSubobject f = kernelSubobject g",
" (asIso (imageToKernel f g β―)).hom β« (kernelSubobject g).arrow = (imageSubobject f).arrow",
" imageSubobject f = kernelSubobject g β Exact f g",
" Exact f g β... |
import Mathlib.Algebra.Lie.CartanSubalgebra
import Mathlib.Algebra.Lie.Weights.Basic
suppress_compilation
open Set
variable {R L : Type*} [CommRing R] [LieRing L] [LieAlgebra R L]
(H : LieSubalgebra R L) [LieAlgebra.IsNilpotent R H]
{M : Type*} [AddCommGroup M] [Module R M] [LieRingModule L M] [LieModule R L ... | Mathlib/Algebra/Lie/Weights/Cartan.lean | 135 | 141 | theorem mapsTo_toEnd_weightSpace_add_of_mem_rootSpace (Ξ± Ο : H β R)
{x : L} (hx : x β rootSpace H Ξ±) :
MapsTo (toEnd R L M x) (weightSpace M Ο) (weightSpace M (Ξ± + Ο)) := by |
intro m hm
let x' : rootSpace H Ξ± := β¨x, hxβ©
let m' : weightSpace M Ο := β¨m, hmβ©
exact (rootSpaceWeightSpaceProduct R L H M Ξ± Ο (Ξ± + Ο) rfl (x' ββ m')).property
| [
" β
x, mβ β weightSpace M (Οβ + Οβ)",
" β (i : β₯H), β
x, mβ β weightSpaceOf M ((Οβ + Οβ) i) i",
" β
x, mβ β weightSpaceOf M ((Οβ + Οβ) y) y",
" x β weightSpaceOf L (Οβ y) y",
" m β weightSpaceOf M (Οβ y) y",
" ((toEnd R L M) x ^ n) m β weightSpace M (n β’ Οβ + Οβ)",
" ((toEnd R L M) x ^ 0) m β weightSpace M... | [
" β
x, mβ β weightSpace M (Οβ + Οβ)",
" β (i : β₯H), β
x, mβ β weightSpaceOf M ((Οβ + Οβ) i) i",
" β
x, mβ β weightSpaceOf M ((Οβ + Οβ) y) y",
" x β weightSpaceOf L (Οβ y) y",
" m β weightSpaceOf M (Οβ y) y",
" ((toEnd R L M) x ^ n) m β weightSpace M (n β’ Οβ + Οβ)",
" ((toEnd R L M) x ^ 0) m β weightSpace M... |
import Mathlib.GroupTheory.Coxeter.Length
import Mathlib.Data.ZMod.Parity
namespace CoxeterSystem
open List Matrix Function
variable {B : Type*}
variable {W : Type*} [Group W]
variable {M : CoxeterMatrix B} (cs : CoxeterSystem M W)
local prefix:100 "s" => cs.simple
local prefix:100 "Ο" => cs.wordProd
local prefi... | Mathlib/GroupTheory/Coxeter/Inversion.lean | 61 | 61 | theorem isReflection_simple (i : B) : cs.IsReflection (s i) := by | use 1, i; simp
| [
" cs.IsReflection (cs.simple i)",
" cs.simple i = 1 * cs.simple i * 1β»ΒΉ"
] | [] |
import Mathlib.Topology.Baire.Lemmas
import Mathlib.Topology.Algebra.Group.Basic
open scoped Topology Pointwise
open MulAction Set Function
variable {G X : Type*} [TopologicalSpace G] [TopologicalSpace X]
[Group G] [TopologicalGroup G] [MulAction G X]
[SigmaCompactSpace G] [BaireSpace X] [T2Space X]
[Contin... | Mathlib/Topology/Algebra/Group/OpenMapping.lean | 37 | 88 | theorem smul_singleton_mem_nhds_of_sigmaCompact
{U : Set G} (hU : U β π 1) (x : X) : U β’ {x} β π x := by |
/- Consider a small closed neighborhood `V` of the identity. Then the group is covered by
countably many translates of `V`, say `gα΅’ V`. Let also `Kβ` be a sequence of compact sets covering
the space. Then the image of `Kβ β© gα΅’ V` in the orbit is compact, and their unions covers the
space. By Baire, one of them... | [
" U β’ {x} β π x",
" β s, s.Countable β§ β g β s, g β’ V = univ",
" g β’ V β π g",
" g = g β’ 1",
" β i, (interior (F i)).Nonempty",
" β (i : β Γ βs), IsClosed (F i)",
" IsClosed (F (n, β¨g, hgβ©))",
" IsCompact (F (n, β¨g, hgβ©))",
" IsCompact ((fun g => g β’ x) '' (K n β© g β’ V))",
" IsCompact (K n β© g β’... | [] |
import Mathlib.MeasureTheory.Measure.Lebesgue.EqHaar
import Mathlib.MeasureTheory.Measure.Haar.Quotient
import Mathlib.MeasureTheory.Constructions.Polish
import Mathlib.MeasureTheory.Integral.IntervalIntegral
import Mathlib.Topology.Algebra.Order.Floor
#align_import measure_theory.integral.periodic from "leanprover-c... | Mathlib/MeasureTheory/Integral/Periodic.lean | 267 | 274 | theorem intervalIntegral_add_eq (hf : Periodic f T) (t s : β) :
β« x in t..t + T, f x = β« x in s..s + T, f x := by |
rcases lt_trichotomy (0 : β) T with (hT | rfl | hT)
Β· exact hf.intervalIntegral_add_eq_of_pos hT t s
Β· simp
Β· rw [β neg_inj, β integral_symm, β integral_symm]
simpa only [β sub_eq_add_neg, add_sub_cancel_right] using
hf.neg.intervalIntegral_add_eq_of_pos (neg_pos.2 hT) (t + T) (s + T)
| [
" IsAddFundamentalDomain (β₯(zmultiples T)) (Ioc t (t + T)) ΞΌ",
" β! g, g +α΅₯ x β Ioc t (t + T)",
" β! x_1, codRestrict (fun n => n β’ T) β(zmultiples T) β― x_1 +α΅₯ x β Ioc t (t + T)",
" IsAddFundamentalDomain (β₯(zmultiples T).op) (Ioc t (t + T)) ΞΌ",
" β! x_1, (β(zmultiples T).equivOp β codRestrict (fun n => n β’... | [
" IsAddFundamentalDomain (β₯(zmultiples T)) (Ioc t (t + T)) ΞΌ",
" β! g, g +α΅₯ x β Ioc t (t + T)",
" β! x_1, codRestrict (fun n => n β’ T) β(zmultiples T) β― x_1 +α΅₯ x β Ioc t (t + T)",
" IsAddFundamentalDomain (β₯(zmultiples T).op) (Ioc t (t + T)) ΞΌ",
" β! x_1, (β(zmultiples T).equivOp β codRestrict (fun n => n β’... |
import Mathlib.Analysis.Normed.Group.Hom
import Mathlib.Analysis.Normed.Group.Completion
#align_import analysis.normed.group.hom_completion from "leanprover-community/mathlib"@"17ef379e997badd73e5eabb4d38f11919ab3c4b3"
noncomputable section
open Set NormedAddGroupHom UniformSpace
section Completion
variable {G... | Mathlib/Analysis/Normed/Group/HomCompletion.lean | 107 | 113 | theorem NormedAddGroupHom.completion_comp (f : NormedAddGroupHom G H) (g : NormedAddGroupHom H K) :
g.completion.comp f.completion = (g.comp f).completion := by |
ext x
rw [NormedAddGroupHom.coe_comp, NormedAddGroupHom.completion_def,
NormedAddGroupHom.completion_coe_to_fun, NormedAddGroupHom.completion_coe_to_fun,
Completion.map_comp g.uniformContinuous f.uniformContinuous]
rfl
| [
" (id G).completion = id (Completion G)",
" (id G).completion x = (id (Completion G)) x",
" _root_.id x = (id (Completion G)) x",
" g.completion.comp f.completion = (g.comp f).completion",
" (g.completion.comp f.completion) x = (g.comp f).completion x",
" Completion.map (βg β βf) x = Completion.map (β(g.c... | [
" (id G).completion = id (Completion G)",
" (id G).completion x = (id (Completion G)) x",
" _root_.id x = (id (Completion G)) x"
] |
import Mathlib.Combinatorics.SimpleGraph.Coloring
#align_import combinatorics.simple_graph.partition from "leanprover-community/mathlib"@"2303b3e299f1c75b07bceaaac130ce23044d1386"
universe u v
namespace SimpleGraph
variable {V : Type u} (G : SimpleGraph V)
structure Partition where
parts : Set (Set V)
... | Mathlib/Combinatorics/SimpleGraph/Partition.lean | 93 | 95 | theorem mem_partOfVertex (v : V) : v β P.partOfVertex v := by |
obtain β¨β¨_, hβ©, _β© := (P.isPartition.2 v).choose_spec
exact h
| [
" P.partOfVertex v β P.parts",
" v β P.partOfVertex v"
] | [
" P.partOfVertex v β P.parts"
] |
import Mathlib.Algebra.GroupPower.IterateHom
import Mathlib.Algebra.Module.Defs
import Mathlib.Algebra.Order.Archimedean
import Mathlib.Algebra.Order.Group.Instances
import Mathlib.GroupTheory.GroupAction.Pi
open Function Set
structure AddConstMap (G H : Type*) [Add G] [Add H] (a : G) (b : H) where
protected... | Mathlib/Algebra/AddConstMap/Basic.lean | 112 | 114 | theorem map_nat' [AddMonoidWithOne G] [AddMonoid H] [AddConstMapClass F G H 1 b]
(f : F) (n : β) : f n = f 0 + n β’ b := by |
simpa using map_add_nat' f 0 n
| [
" f (x + n β’ a) = f x + n β’ b",
" f (x + βn) = f x + n β’ b",
" f (x + βn) = f x + βn",
" f a = f 0 + b",
" f (n β’ a) = f 0 + n β’ b",
" f βn = f 0 + n β’ b"
] | [
" f (x + n β’ a) = f x + n β’ b",
" f (x + βn) = f x + n β’ b",
" f (x + βn) = f x + βn",
" f a = f 0 + b",
" f (n β’ a) = f 0 + n β’ b"
] |
import Mathlib.NumberTheory.Liouville.Basic
#align_import number_theory.liouville.liouville_number from "leanprover-community/mathlib"@"04e80bb7e8510958cd9aacd32fe2dc147af0b9f1"
noncomputable section
open scoped Nat
open Real Finset
def liouvilleNumber (m : β) : β :=
β' i : β, 1 / m ^ i !
#align liouville_n... | Mathlib/NumberTheory/Liouville/LiouvilleNumber.lean | 84 | 86 | theorem remainder_summable {m : β} (hm : 1 < m) (k : β) :
Summable fun i : β => 1 / m ^ (i + (k + 1))! := by |
convert (summable_nat_add_iff (k + 1)).2 (LiouvilleNumber.summable hm)
| [
" Summable fun i => 1 / m ^ (i + (k + 1))!"
] | [] |
import Mathlib.AlgebraicGeometry.AffineScheme
import Mathlib.RingTheory.Nilpotent.Lemmas
import Mathlib.Topology.Sheaves.SheafCondition.Sites
import Mathlib.Algebra.Category.Ring.Constructions
import Mathlib.RingTheory.LocalProperties
#align_import algebraic_geometry.properties from "leanprover-community/mathlib"@"88... | Mathlib/AlgebraicGeometry/Properties.lean | 84 | 93 | theorem isReducedOfOpenImmersion {X Y : Scheme} (f : X βΆ Y) [H : IsOpenImmersion f]
[IsReduced Y] : IsReduced X := by |
constructor
intro U
have : U = (Opens.map f.1.base).obj (H.base_open.isOpenMap.functor.obj U) := by
ext1; exact (Set.preimage_image_eq _ H.base_open.inj).symm
rw [this]
exact isReduced_of_injective (inv <| f.1.c.app (op <| H.base_open.isOpenMap.functor.obj U))
(asIso <| f.1.c.app (op <| H.base_open.i... | [
" T0Space ββX.toPresheafedSpace",
" β s, x β s β§ IsOpen s β§ T0Space βs",
" QuasiSober ββX.toPresheafedSpace",
" β (s : β(Set.range fun x => Set.range β(X.affineCover.map x).val.base)), IsOpen βs",
" IsOpen ββ¨(fun x => Set.range β(X.affineCover.map x).val.base) i, β―β©",
" β (s : β(Set.range fun x => Set.ran... | [
" T0Space ββX.toPresheafedSpace",
" β s, x β s β§ IsOpen s β§ T0Space βs",
" QuasiSober ββX.toPresheafedSpace",
" β (s : β(Set.range fun x => Set.range β(X.affineCover.map x).val.base)), IsOpen βs",
" IsOpen ββ¨(fun x => Set.range β(X.affineCover.map x).val.base) i, β―β©",
" β (s : β(Set.range fun x => Set.ran... |
import Mathlib.Algebra.Star.Basic
import Mathlib.Algebra.Order.CauSeq.Completion
#align_import data.real.basic from "leanprover-community/mathlib"@"cb42593171ba005beaaf4549fcfe0dece9ada4c9"
assert_not_exists Finset
assert_not_exists Module
assert_not_exists Submonoid
assert_not_exists FloorRing
structure Real w... | Mathlib/Data/Real/Basic.lean | 130 | 132 | theorem ofCauchy_sub (a b) : (β¨a - bβ© : β) = β¨aβ© - β¨bβ© := by |
rw [sub_eq_add_neg, ofCauchy_add, ofCauchy_neg]
rfl
| [
" { cauchy := a } = { cauchy := b } β { cauchy := a }.cauchy = { cauchy := b }.cauchy",
" { cauchy := a - b } = { cauchy := a } - { cauchy := b }",
" { cauchy := a } + -{ cauchy := b } = { cauchy := a } - { cauchy := b }"
] | [
" { cauchy := a } = { cauchy := b } β { cauchy := a }.cauchy = { cauchy := b }.cauchy"
] |
import Mathlib.Algebra.DirectSum.Internal
import Mathlib.Algebra.GradedMonoid
import Mathlib.Algebra.MvPolynomial.CommRing
import Mathlib.Algebra.MvPolynomial.Equiv
import Mathlib.Algebra.MvPolynomial.Variables
import Mathlib.RingTheory.MvPolynomial.WeightedHomogeneous
import Mathlib.Algebra.Polynomial.Roots
#align_i... | Mathlib/RingTheory/MvPolynomial/Homogeneous.lean | 57 | 61 | theorem weightedTotalDegree_one (Ο : MvPolynomial Ο R) :
weightedTotalDegree (1 : Ο β β) Ο = Ο.totalDegree := by |
simp only [totalDegree, weightedTotalDegree, weightedDegree, LinearMap.toAddMonoidHom_coe,
Finsupp.total, Pi.one_apply, Finsupp.coe_lsum, LinearMap.coe_smulRight, LinearMap.id_coe,
id, Algebra.id.smul_eq_mul, mul_one]
| [
" (weightedDegree 1) d = degree d",
" weightedTotalDegree 1 Ο = Ο.totalDegree"
] | [
" (weightedDegree 1) d = degree d"
] |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.