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 221 |
|---|---|---|---|---|---|---|---|
import Mathlib.Data.Real.Sqrt
import Mathlib.Analysis.NormedSpace.Star.Basic
import Mathlib.Analysis.NormedSpace.ContinuousLinearMap
import Mathlib.Analysis.NormedSpace.Basic
#align_import data.is_R_or_C.basic from "leanprover-community/mathlib"@"baa88307f3e699fa7054ef04ec79fa4f056169cb"
section
local notation "οΏ½... | Mathlib/Analysis/RCLike/Basic.lean | 162 | 162 | theorem one_re : re (1 : K) = 1 := by | rw [β ofReal_one, ofReal_re]
| [
" r β’ x = βr β’ x",
" re 1 = 1"
] | [
" r β’ x = βr β’ x",
" re 1 = 1"
] |
import Mathlib.Analysis.NormedSpace.PiLp
import Mathlib.Analysis.InnerProductSpace.PiL2
#align_import analysis.matrix from "leanprover-community/mathlib"@"46b633fd842bef9469441c0209906f6dddd2b4f5"
noncomputable section
open scoped NNReal Matrix
namespace Matrix
variable {R l m n Ξ± Ξ² : Type*} [Fintype l] [Fintyp... | Mathlib/Analysis/Matrix.lean | 560 | 565 | theorem frobenius_nnnorm_def (A : Matrix m n Ξ±) :
βAββ = (β i, β j, βA i jββ ^ (2 : β)) ^ (1 / 2 : β) := by |
-- Porting note: added, along with `WithLp.equiv_symm_pi_apply` below
change β(WithLp.equiv 2 _).symm fun i => (WithLp.equiv 2 _).symm fun j => A i jββ = _
simp_rw [PiLp.nnnorm_eq_of_L2, NNReal.sq_sqrt, NNReal.sqrt_eq_rpow, NNReal.rpow_two,
WithLp.equiv_symm_pi_apply]
| [
" NormedAddCommGroup (PiLp 2 fun i => PiLp 2 fun j => Ξ±)",
" BoundedSMul R (PiLp 2 fun i => PiLp 2 fun j => Ξ±)",
" NormedSpace R (PiLp 2 fun i => PiLp 2 fun j => Ξ±)",
" βAββ = (β i : m, β j : n, βA i jββ ^ 2) ^ (1 / 2)",
" β(WithLp.equiv 2 (m β WithLp 2 (n β Ξ±))).symm fun i => (WithLp.equiv 2 (n β Ξ±)).symm ... | [
" NormedAddCommGroup (PiLp 2 fun i => PiLp 2 fun j => Ξ±)",
" BoundedSMul R (PiLp 2 fun i => PiLp 2 fun j => Ξ±)",
" NormedSpace R (PiLp 2 fun i => PiLp 2 fun j => Ξ±)",
" βAββ = (β i : m, β j : n, βA i jββ ^ 2) ^ (1 / 2)"
] |
import Mathlib.Data.Nat.Choose.Basic
import Mathlib.Data.List.Perm
import Mathlib.Data.List.Range
#align_import data.list.sublists from "leanprover-community/mathlib"@"ccad6d5093bd2f5c6ca621fc74674cce51355af6"
universe u v w
variable {Ξ± : Type u} {Ξ² : Type v} {Ξ³ : Type w}
open Nat
namespace List
@[simp]
theo... | Mathlib/Data/List/Sublists.lean | 120 | 129 | theorem sublistsAux_eq_array_foldl :
sublistsAux = fun (a : Ξ±) (r : List (List Ξ±)) =>
(r.toArray.foldl (init := #[])
fun r l => (r.push l).push (a :: l)).toList := by |
funext a r
simp only [sublistsAux, Array.foldl_eq_foldl_data, Array.mkEmpty]
have := foldl_hom Array.toList (fun r l => (r.push l).push (a :: l))
(fun (r : List (List Ξ±)) l => r ++ [l, a :: l]) r #[]
(by simp)
simpa using this
| [
" β (rβ rβ : List (List Ξ±)),\n sublists'Aux a rβ rβ = (Array.foldl (fun r l => r.push (a :: l)) (toArray rβ) (toArray rβ) 0).toList",
" sublists'Aux a rβ rβ = (Array.foldl (fun r l => r.push (a :: l)) (toArray rβ) (toArray rβ) 0).toList",
" foldl (fun r l => r ++ [a :: l]) rβ rβ = (foldl (fun r l => r.push (... | [
" β (rβ rβ : List (List Ξ±)),\n sublists'Aux a rβ rβ = (Array.foldl (fun r l => r.push (a :: l)) (toArray rβ) (toArray rβ) 0).toList",
" sublists'Aux a rβ rβ = (Array.foldl (fun r l => r.push (a :: l)) (toArray rβ) (toArray rβ) 0).toList",
" foldl (fun r l => r ++ [a :: l]) rβ rβ = (foldl (fun r l => r.push (... |
import Mathlib.CategoryTheory.Comma.Over
import Mathlib.CategoryTheory.Limits.Shapes.Pullbacks
import Mathlib.CategoryTheory.Yoneda
import Mathlib.Data.Set.Lattice
import Mathlib.Order.CompleteLattice
#align_import category_theory.sites.sieves from "leanprover-community/mathlib"@"239d882c4fb58361ee8b3b39fb2091320edef... | Mathlib/CategoryTheory/Sites/Sieves.lean | 141 | 148 | theorem ofArrows_pUnit : (ofArrows _ fun _ : PUnit => f) = singleton f := by |
funext Y
ext g
constructor
Β· rintro β¨_β©
apply singleton.mk
Β· rintro β¨_β©
exact ofArrows.mk PUnit.unit
| [
" CompleteLattice (Presieve X)",
" CompleteLattice (β¦Y : Cβ¦ β Set (Y βΆ X))",
" singleton f g β f = g",
" singleton f g β f = g",
" f = f",
" f = g β singleton f g",
" singleton f f",
" pullbackArrows f (singleton g) = singleton pullback.snd",
" h β pullbackArrows f (singleton g) β h β singleton pull... | [
" CompleteLattice (Presieve X)",
" CompleteLattice (β¦Y : Cβ¦ β Set (Y βΆ X))",
" singleton f g β f = g",
" singleton f g β f = g",
" f = f",
" f = g β singleton f g",
" singleton f f",
" pullbackArrows f (singleton g) = singleton pullback.snd",
" h β pullbackArrows f (singleton g) β h β singleton pull... |
import Mathlib.CategoryTheory.Sites.IsSheafFor
import Mathlib.CategoryTheory.Limits.Shapes.Types
import Mathlib.Tactic.ApplyFun
#align_import category_theory.sites.sheaf_of_types from "leanprover-community/mathlib"@"70fd9563a21e7b963887c9360bd29b2393e6225a"
universe w v u
namespace CategoryTheory
open Opposite ... | Mathlib/CategoryTheory/Sites/EqualizerSheafCondition.lean | 133 | 135 | theorem w : forkMap P (S : Presieve X) β« firstMap P S = forkMap P S β« secondMap P S := by |
ext
simp [firstMap, secondMap, forkMap]
| [
" zβ = zβ",
" β (j : Discrete ((Y : C) Γ { f // R f })),\n limit.Ο (Discrete.functor fun f => P.obj { unop := f.fst }) j zβ =\n limit.Ο (Discrete.functor fun f => P.obj { unop := f.fst }) j zβ",
" limit.Ο (Discrete.functor fun f => P.obj { unop := f.fst }) { as := β¨Y, β¨f, hfβ©β© } zβ =\n limit.Ο (Discr... | [
" zβ = zβ",
" β (j : Discrete ((Y : C) Γ { f // R f })),\n limit.Ο (Discrete.functor fun f => P.obj { unop := f.fst }) j zβ =\n limit.Ο (Discrete.functor fun f => P.obj { unop := f.fst }) j zβ",
" limit.Ο (Discrete.functor fun f => P.obj { unop := f.fst }) { as := β¨Y, β¨f, hfβ©β© } zβ =\n limit.Ο (Discr... |
import Mathlib.Init.Function
import Mathlib.Init.Order.Defs
#align_import data.bool.basic from "leanprover-community/mathlib"@"c4658a649d216f57e99621708b09dcb3dcccbd23"
namespace Bool
@[deprecated (since := "2024-06-07")] alias decide_True := decide_true_eq_true
#align bool.to_bool_true decide_true_eq_true
@[dep... | Mathlib/Data/Bool/Basic.lean | 57 | 57 | theorem dichotomy (b : Bool) : b = false β¨ b = true := by | cases b <;> simp
| [
" b = false β¨ b = true",
" false = false β¨ false = true",
" true = false β¨ true = true"
] | [
" b = false β¨ b = true"
] |
import Mathlib.Topology.GDelta
#align_import topology.metric_space.baire from "leanprover-community/mathlib"@"b9e46fe101fc897fb2e7edaf0bf1f09ea49eb81a"
noncomputable section
open scoped Topology
open Filter Set TopologicalSpace
variable {X Ξ± : Type*} {ΞΉ : Sort*}
section BaireTheorem
variable [TopologicalSpace... | Mathlib/Topology/Baire/Lemmas.lean | 123 | 126 | theorem Dense.inter_of_GΞ΄ {s t : Set X} (hs : IsGΞ΄ s) (ht : IsGΞ΄ t) (hsc : Dense s)
(htc : Dense t) : Dense (s β© t) := by |
rw [inter_eq_iInter]
apply dense_iInter_of_GΞ΄ <;> simp [Bool.forall_bool, *]
| [
" Dense (ββ S)",
" Dense (ββ range f)",
" Dense (β s β S, f s)",
" Dense (ββ ((fun s => f s) '' S))",
" β s β (fun s => f s) '' S, IsOpen s",
" β s β (fun s => f s) '' S, Dense s",
" s β residual X β β t β s, IsGΞ΄ t β§ Dense t",
" s β residual X β β t β s, IsGΞ΄ t β§ Dense t",
" (β S, (β t β S, IsOpen ... | [
" Dense (ββ S)",
" Dense (ββ range f)",
" Dense (β s β S, f s)",
" Dense (ββ ((fun s => f s) '' S))",
" β s β (fun s => f s) '' S, IsOpen s",
" β s β (fun s => f s) '' S, Dense s",
" s β residual X β β t β s, IsGΞ΄ t β§ Dense t",
" s β residual X β β t β s, IsGΞ΄ t β§ Dense t",
" (β S, (β t β S, IsOpen ... |
import Mathlib.Order.Interval.Set.UnorderedInterval
import Mathlib.Algebra.Order.Interval.Set.Monoid
import Mathlib.Data.Set.Pointwise.Basic
import Mathlib.Algebra.Order.Field.Basic
import Mathlib.Algebra.Order.Group.MinMax
#align_import data.set.pointwise.interval from "leanprover-community/mathlib"@"2196ab363eb097c... | Mathlib/Data/Set/Pointwise/Interval.lean | 152 | 153 | theorem preimage_const_add_Ico : (fun x => a + x) β»ΒΉ' Ico b c = Ico (b - a) (c - a) := by |
simp [β Ici_inter_Iio]
| [
" (fun x => a + x) β»ΒΉ' Icc b c = Icc (b - a) (c - a)",
" (fun x => a + x) β»ΒΉ' Ico b c = Ico (b - a) (c - a)"
] | [
" (fun x => a + x) β»ΒΉ' Icc b c = Icc (b - a) (c - a)",
" (fun x => a + x) β»ΒΉ' Ico b c = Ico (b - a) (c - a)"
] |
import Mathlib.Order.Interval.Set.OrdConnectedComponent
import Mathlib.Topology.Order.Basic
#align_import topology.algebra.order.t5 from "leanprover-community/mathlib"@"4c19a16e4b705bf135cf9a80ac18fcc99c438514"
open Filter Set Function OrderDual Topology Interval
variable {X : Type*} [LinearOrder X] [Topological... | Mathlib/Topology/Order/T5.lean | 74 | 79 | theorem compl_section_ordSeparatingSet_mem_nhds (hd : Disjoint s (closure t)) (ha : a β s) :
(ordConnectedSection <| ordSeparatingSet s t)αΆ β π a := by |
rw [β nhds_left_sup_nhds_right, mem_sup]
exact
β¨compl_section_ordSeparatingSet_mem_nhdsWithin_Iic hd ha,
compl_section_ordSeparatingSet_mem_nhdsWithin_Ici hd haβ©
| [
" s.ordConnectedComponent a β π a β s β π a",
" s.ordConnectedComponent a β π a",
" (s.ordSeparatingSet t).ordConnectedSectionαΆ β π[β₯] a",
" tαΆ β π[β₯] a",
" tαΆ β π a",
" a β (closure t)αΆ",
" False",
" [[x, c]] β s.ordSeparatingSet t",
" [[x, c]] β tαΆ.ordConnectedComponent a",
" [[x, c]] β β ... | [
" s.ordConnectedComponent a β π a β s β π a",
" s.ordConnectedComponent a β π a",
" (s.ordSeparatingSet t).ordConnectedSectionαΆ β π[β₯] a",
" tαΆ β π[β₯] a",
" tαΆ β π a",
" a β (closure t)αΆ",
" False",
" [[x, c]] β s.ordSeparatingSet t",
" [[x, c]] β tαΆ.ordConnectedComponent a",
" [[x, c]] β β ... |
import Mathlib.Algebra.GCDMonoid.Finset
import Mathlib.Algebra.Polynomial.CancelLeads
import Mathlib.Algebra.Polynomial.EraseLead
import Mathlib.Algebra.Polynomial.FieldDivision
#align_import ring_theory.polynomial.content from "leanprover-community/mathlib"@"7a030ab8eb5d99f05a891dccc49c5b5b90c947d3"
namespace Po... | Mathlib/RingTheory/Polynomial/Content.lean | 92 | 97 | theorem content_C {r : R} : (C r).content = normalize r := by |
rw [content]
by_cases h0 : r = 0
Β· simp [h0]
have h : (C r).support = {0} := support_monomial _ h0
simp [h]
| [
" p.content β£ p.coeff n",
" p.content β£ 0",
" (C r).content = normalize r",
" (C r).support.gcd (C r).coeff = normalize r"
] | [
" p.content β£ p.coeff n",
" p.content β£ 0",
" (C r).content = normalize r"
] |
import Mathlib.Data.Finset.Card
#align_import data.finset.option from "leanprover-community/mathlib"@"c227d107bbada5d0d9d20287e3282c0a7f1651a0"
variable {Ξ± Ξ² : Type*}
open Function
namespace Option
def toFinset (o : Option Ξ±) : Finset Ξ± :=
o.elim β
singleton
#align option.to_finset Option.toFinset
@[simp]
... | Mathlib/Data/Finset/Option.lean | 55 | 55 | theorem card_toFinset (o : Option Ξ±) : o.toFinset.card = o.elim 0 1 := by | cases o <;> rfl
| [
" a β o.toFinset β a β o",
" a β none.toFinset β a β none",
" a β (some valβ).toFinset β a β some valβ",
" o.toFinset.card = o.elim 0 1",
" none.toFinset.card = none.elim 0 1",
" (some valβ).toFinset.card = (some valβ).elim 0 1"
] | [
" a β o.toFinset β a β o",
" a β none.toFinset β a β none",
" a β (some valβ).toFinset β a β some valβ",
" o.toFinset.card = o.elim 0 1"
] |
import Mathlib.Algebra.CharP.Invertible
import Mathlib.Algebra.MvPolynomial.Variables
import Mathlib.Algebra.MvPolynomial.CommRing
import Mathlib.Algebra.MvPolynomial.Expand
import Mathlib.Data.Fintype.BigOperators
import Mathlib.Data.ZMod.Basic
#align_import ring_theory.witt_vector.witt_polynomial from "leanprover-c... | Mathlib/RingTheory/WittVector/WittPolynomial.lean | 81 | 86 | theorem wittPolynomial_eq_sum_C_mul_X_pow (n : β) :
wittPolynomial p R n = β i β range (n + 1), C ((p : R) ^ i) * X i ^ p ^ (n - i) := by |
apply sum_congr rfl
rintro i -
rw [monomial_eq, Finsupp.prod_single_index]
rw [pow_zero]
| [
" wittPolynomial p R n = β i β range (n + 1), C (βp ^ i) * X i ^ p ^ (n - i)",
" β x β range (n + 1), (monomial (single x (p ^ (n - x)))) (βp ^ x) = C (βp ^ x) * X x ^ p ^ (n - x)",
" (monomial (single i (p ^ (n - i)))) (βp ^ i) = C (βp ^ i) * X i ^ p ^ (n - i)",
" X i ^ 0 = 1"
] | [
" wittPolynomial p R n = β i β range (n + 1), C (βp ^ i) * X i ^ p ^ (n - i)"
] |
import Mathlib.Data.Nat.Defs
import Mathlib.Tactic.GCongr.Core
import Mathlib.Tactic.Common
import Mathlib.Tactic.Monotonicity.Attr
#align_import data.nat.factorial.basic from "leanprover-community/mathlib"@"d012cd09a9b256d870751284dd6a29882b0be105"
namespace Nat
def factorial : β β β
| 0 => 1
| succ n => s... | Mathlib/Data/Nat/Factorial/Basic.lean | 113 | 118 | theorem factorial_eq_one : n ! = 1 β n β€ 1 := by |
constructor
Β· intro h
rw [β not_lt, β one_lt_factorial, h]
apply lt_irrefl
Β· rintro (_|_|_) <;> rfl
| [
" m ! β£ n !",
" m ! β£ m !",
" m ! β£ n.succ !",
" m ! * (m + 1) ^ 0 β€ (m + 0)!",
" m ! * (m + 1) ^ (n + 1) β€ (m + (n + 1))!",
" m ! * (m + 1) ^ n * (m + 1) β€ (m + n)! * (m + n + 1)",
" n ! < m ! β n < m",
" n ! < m !",
" β {n : β}, 0 < n β n ! < (n + 1)!",
" k ! < (k + 1)!",
" 0 < k * k !",
" n... | [
" m ! β£ n !",
" m ! β£ m !",
" m ! β£ n.succ !",
" m ! * (m + 1) ^ 0 β€ (m + 0)!",
" m ! * (m + 1) ^ (n + 1) β€ (m + (n + 1))!",
" m ! * (m + 1) ^ n * (m + 1) β€ (m + n)! * (m + n + 1)",
" n ! < m ! β n < m",
" n ! < m !",
" β {n : β}, 0 < n β n ! < (n + 1)!",
" k ! < (k + 1)!",
" 0 < k * k !",
" n... |
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 | 40 | 43 | theorem inv_norm_smul_mem_closed_unit_ball (x : E) :
βxββ»ΒΉ β’ x β closedBall (0 : E) 1 := by |
simp only [mem_closedBall_zero_iff, norm_smul, norm_inv, norm_norm, β div_eq_inv_mul,
div_self_le_one]
| [
" βxββ»ΒΉ β’ x β closedBall 0 1"
] | [
" βxββ»ΒΉ β’ x β closedBall 0 1"
] |
import Mathlib.Algebra.Polynomial.AlgebraMap
import Mathlib.Algebra.Polynomial.Degree.Lemmas
import Mathlib.Algebra.Polynomial.HasseDeriv
#align_import data.polynomial.taylor from "leanprover-community/mathlib"@"70fd9563a21e7b963887c9360bd29b2393e6225a"
noncomputable section
namespace Polynomial
open Polynomial... | Mathlib/Algebra/Polynomial/Taylor.lean | 130 | 134 | theorem taylor_injective {R} [CommRing R] (r : R) : Function.Injective (taylor r) := by |
intro f g h
apply_fun taylor (-r) at h
simpa only [taylor_apply, comp_assoc, add_comp, X_comp, C_comp, C_neg, neg_add_cancel_right,
comp_X] using h
| [
" { toFun := fun f => f.comp (X + C r), map_add' := β― }.toFun (c β’ f) =\n (RingHom.id R) c β’ { toFun := fun f => f.comp (X + C r), map_add' := β― }.toFun f",
" (taylor r) X = X + C r",
" (taylor r) (C x) = C x",
" taylor 0 = LinearMap.id",
" ((taylor 0 ββ monomial nβΒΉ) 1).coeff nβ = ((LinearMap.id ββ mono... | [
" { toFun := fun f => f.comp (X + C r), map_add' := β― }.toFun (c β’ f) =\n (RingHom.id R) c β’ { toFun := fun f => f.comp (X + C r), map_add' := β― }.toFun f",
" (taylor r) X = X + C r",
" (taylor r) (C x) = C x",
" taylor 0 = LinearMap.id",
" ((taylor 0 ββ monomial nβΒΉ) 1).coeff nβ = ((LinearMap.id ββ mono... |
import Mathlib.Algebra.BigOperators.Fin
import Mathlib.Algebra.Polynomial.Degree.Lemmas
#align_import data.polynomial.erase_lead from "leanprover-community/mathlib"@"fa256f00ce018e7b40e1dc756e403c86680bf448"
noncomputable section
open Polynomial
open Polynomial Finset
namespace Polynomial
variable {R : Type*}... | Mathlib/Algebra/Polynomial/EraseLead.lean | 89 | 92 | theorem eraseLead_ne_zero (f0 : 2 β€ f.support.card) : eraseLead f β 0 := by |
rw [Ne, β card_support_eq_zero, eraseLead_support]
exact
(zero_lt_one.trans_le <| (tsub_le_tsub_right f0 1).trans Finset.pred_card_le_card_erase).ne.symm
| [
" f.eraseLead.support = f.support.erase f.natDegree",
" f.eraseLead.coeff i = if i = f.natDegree then 0 else f.coeff i",
" f.eraseLead.coeff f.natDegree = 0",
" f.eraseLead.coeff i = f.coeff i",
" eraseLead 0 = 0",
" f.eraseLead + C f.leadingCoeff * X ^ f.natDegree = f",
" f - C f.leadingCoeff * X ^ f.n... | [
" f.eraseLead.support = f.support.erase f.natDegree",
" f.eraseLead.coeff i = if i = f.natDegree then 0 else f.coeff i",
" f.eraseLead.coeff f.natDegree = 0",
" f.eraseLead.coeff i = f.coeff i",
" eraseLead 0 = 0",
" f.eraseLead + C f.leadingCoeff * X ^ f.natDegree = f",
" f - C f.leadingCoeff * X ^ f.n... |
import Mathlib.RingTheory.WittVector.IsPoly
#align_import ring_theory.witt_vector.mul_p from "leanprover-community/mathlib"@"7abfbc92eec87190fba3ed3d5ec58e7c167e7144"
namespace WittVector
variable {p : β} {R : Type*} [hp : Fact p.Prime] [CommRing R]
local notation "π" => WittVector p -- type as `\bbW`
open Mv... | Mathlib/RingTheory/WittVector/MulP.lean | 72 | 80 | theorem bindβ_wittMulN_wittPolynomial (n k : β) :
bindβ (wittMulN p n) (wittPolynomial p β€ k) = n * wittPolynomial p β€ k := by |
induction' n with n ih
Β· simp [wittMulN, Nat.cast_zero, zero_mul, bindβ_zero_wittPolynomial]
Β· rw [wittMulN, β bindβ_bindβ, wittAdd, wittStructureInt_prop]
simp only [AlgHom.map_add, Nat.cast_succ, bindβ_X_right]
rw [add_mul, one_mul, bindβ_rename, bindβ_rename]
simp only [ih, Function.uncurry, Funct... | [
" (x * βn).coeff k = (aeval x.coeff) (wittMulN p n k)",
" (x * β0).coeff k = (aeval x.coeff) (wittMulN p 0 k)",
" (x * β(n + 1)).coeff k = (aeval x.coeff) (wittMulN p (n + 1) k)",
" peval (wittAdd p k) ![(x * βn).coeff, x.coeff] =\n (aeval fun i => (aeval x.coeff) (Function.uncurry ![wittMulN p n, X] i)) (... | [
" (x * βn).coeff k = (aeval x.coeff) (wittMulN p n k)",
" (x * β0).coeff k = (aeval x.coeff) (wittMulN p 0 k)",
" (x * β(n + 1)).coeff k = (aeval x.coeff) (wittMulN p (n + 1) k)",
" peval (wittAdd p k) ![(x * βn).coeff, x.coeff] =\n (aeval fun i => (aeval x.coeff) (Function.uncurry ![wittMulN p n, X] i)) (... |
import Mathlib.Topology.Order.ProjIcc
import Mathlib.Topology.CompactOpen
import Mathlib.Topology.UnitInterval
#align_import topology.path_connected from "leanprover-community/mathlib"@"f2ce6086713c78a7f880485f7917ea547a215982"
noncomputable section
open scoped Classical
open Topology Filter unitInterval Set Fun... | Mathlib/Topology/Connected/PathConnected.lean | 188 | 190 | theorem refl_symm {a : X} : (Path.refl a).symm = Path.refl a := by |
ext
rfl
| [
" Ξ³β = Ξ³β",
" { toContinuousMap := toContinuousMapβ, source' := source'β, target' := target'β } = Ξ³β",
" { toContinuousMap := toContinuousMapβΒΉ, source' := source'βΒΉ, target' := target'βΒΉ } =\n { toContinuousMap := toContinuousMapβ, source' := source'β, target' := target'β }",
" Continuous βΞ³.toContinuousM... | [
" Ξ³β = Ξ³β",
" { toContinuousMap := toContinuousMapβ, source' := source'β, target' := target'β } = Ξ³β",
" { toContinuousMap := toContinuousMapβΒΉ, source' := source'βΒΉ, target' := target'βΒΉ } =\n { toContinuousMap := toContinuousMapβ, source' := source'β, target' := target'β }",
" Continuous βΞ³.toContinuousM... |
import Mathlib.Analysis.InnerProductSpace.Spectrum
import Mathlib.Data.Matrix.Rank
import Mathlib.LinearAlgebra.Matrix.Diagonal
import Mathlib.LinearAlgebra.Matrix.Hermitian
#align_import linear_algebra.matrix.spectrum from "leanprover-community/mathlib"@"46b633fd842bef9469441c0209906f6dddd2b4f5"
namespace Matrix
... | Mathlib/LinearAlgebra/Matrix/Spectrum.lean | 78 | 80 | theorem eigenvectorUnitary_mulVec (j : n) :
eigenvectorUnitary hA *α΅₯ Pi.single j 1 = β(hA.eigenvectorBasis j) := by |
simp only [mulVec_single, eigenvectorUnitary_apply, mul_one]
| [
" A *α΅₯ (WithLp.equiv 2 ((i : n) β (fun x => π) i)) (hA.eigenvectorBasis j) =\n hA.eigenvalues j β’ (WithLp.equiv 2 ((i : n) β (fun x => π) i)) (hA.eigenvectorBasis j)",
" βhA.eigenvectorUnitary *α΅₯ Pi.single j 1 = (WithLp.equiv 2 ((i : n) β (fun x => π) i)) (hA.eigenvectorBasis j)"
] | [
" A *α΅₯ (WithLp.equiv 2 ((i : n) β (fun x => π) i)) (hA.eigenvectorBasis j) =\n hA.eigenvalues j β’ (WithLp.equiv 2 ((i : n) β (fun x => π) i)) (hA.eigenvectorBasis j)",
" βhA.eigenvectorUnitary *α΅₯ Pi.single j 1 = (WithLp.equiv 2 ((i : n) β (fun x => π) i)) (hA.eigenvectorBasis j)"
] |
import Mathlib.Topology.Separation
import Mathlib.Topology.Bases
#align_import topology.dense_embedding from "leanprover-community/mathlib"@"148aefbd371a25f1cff33c85f20c661ce3155def"
noncomputable section
open Set Filter
open scoped Topology
variable {Ξ± : Type*} {Ξ² : Type*} {Ξ³ : Type*} {Ξ΄ : Type*}
structure D... | Mathlib/Topology/DenseEmbedding.lean | 65 | 72 | theorem closure_image_mem_nhds {s : Set Ξ±} {a : Ξ±} (di : DenseInducing i) (hs : s β π a) :
closure (i '' s) β π (i a) := by |
rw [di.nhds_eq_comap a, ((nhds_basis_opens _).comap _).mem_iff] at hs
rcases hs with β¨U, β¨haU, hUoβ©, sub : i β»ΒΉ' U β sβ©
refine mem_of_superset (hUo.mem_nhds haU) ?_
calc
U β closure (i '' (i β»ΒΉ' U)) := di.dense.subset_closure_image_preimage_of_isOpen hUo
_ β closure (i '' s) := closure_mono (image_subs... | [
" closure (i '' s) β π (i a)",
" U β closure (i '' s)"
] | [
" closure (i '' s) β π (i a)"
] |
import Mathlib.Algebra.Polynomial.AlgebraMap
import Mathlib.Algebra.Polynomial.Monic
import Mathlib.Algebra.Ring.Action.Basic
import Mathlib.GroupTheory.GroupAction.Hom
import Mathlib.GroupTheory.GroupAction.Quotient
#align_import algebra.polynomial.group_ring_action from "leanprover-community/mathlib"@"afad8e438d03f... | Mathlib/Algebra/Polynomial/GroupRingAction.lean | 71 | 73 | theorem eval_smul' [MulSemiringAction G S] (g : G) (f : S[X]) (x : S) :
f.eval (g β’ x) = g β’ (gβ»ΒΉ β’ f).eval x := by |
rw [β smul_eval_smul, smul_inv_smul]
| [
" HSMul.hSMul m = map (MulSemiringAction.toRingHom M R m)",
" m β’ r = map (MulSemiringAction.toRingHom M R m) r",
" DistribMulAction.toAddMonoidHom R[X] m = (mapRingHom (MulSemiringAction.toRingHom M R m)).toAddMonoidHom",
" ((DistribMulAction.toAddMonoidHom R[X] m).comp (monomial n).toAddMonoidHom) r =\n ... | [
" HSMul.hSMul m = map (MulSemiringAction.toRingHom M R m)",
" m β’ r = map (MulSemiringAction.toRingHom M R m) r",
" DistribMulAction.toAddMonoidHom R[X] m = (mapRingHom (MulSemiringAction.toRingHom M R m)).toAddMonoidHom",
" ((DistribMulAction.toAddMonoidHom R[X] m).comp (monomial n).toAddMonoidHom) r =\n ... |
import Mathlib.Algebra.BigOperators.Group.Finset
import Mathlib.Data.List.MinMax
import Mathlib.Algebra.Tropical.Basic
import Mathlib.Order.ConditionallyCompleteLattice.Finset
#align_import algebra.tropical.big_operators from "leanprover-community/mathlib"@"d6fad0e5bf2d6f48da9175d25c3dc5706b3834ce"
variable {R S :... | Mathlib/Algebra/Tropical/BigOperators.lean | 99 | 103 | theorem trop_sInf_image [ConditionallyCompleteLinearOrder R] (s : Finset S) (f : S β WithTop R) :
trop (sInf (f '' s)) = β i β s, trop (f i) := by |
rcases s.eq_empty_or_nonempty with (rfl | h)
Β· simp only [Set.image_empty, coe_empty, sum_empty, WithTop.sInf_empty, trop_top]
rw [β inf'_eq_csInf_image _ h, inf'_eq_inf, s.trop_inf]
| [
" trop l.sum = (map trop l).prod",
" trop [].sum = (map trop []).prod",
" trop (hd :: tl).sum = (map trop (hd :: tl)).prod",
" β (a : List R), trop (sum β¦aβ§) = (map trop β¦aβ§).prod",
" trop (β i β s, f i) = β i β s, trop (f i)",
" β i β s, trop (f i) = (Multiset.map trop (Multiset.map f s.val)).prod",
" ... | [
" trop l.sum = (map trop l).prod",
" trop [].sum = (map trop []).prod",
" trop (hd :: tl).sum = (map trop (hd :: tl)).prod",
" β (a : List R), trop (sum β¦aβ§) = (map trop β¦aβ§).prod",
" trop (β i β s, f i) = β i β s, trop (f i)",
" β i β s, trop (f i) = (Multiset.map trop (Multiset.map f s.val)).prod",
" ... |
import Mathlib.Order.Chain
#align_import order.zorn from "leanprover-community/mathlib"@"46a64b5b4268c594af770c44d9e502afc6a515cb"
open scoped Classical
open Set
variable {Ξ± Ξ² : Type*} {r : Ξ± β Ξ± β Prop} {c : Set Ξ±}
local infixl:50 " βΊ " => r
theorem exists_maximal_of_chains_bounded (h : β c, IsChain r c β β... | Mathlib/Order/Zorn.lean | 144 | 149 | theorem zorn_nonempty_Iciβ (a : Ξ±)
(ih : β c β Ici a, IsChain (Β· β€ Β·) c β β y β c, β ub, β z β c, z β€ ub)
(x : Ξ±) (hax : a β€ x) : β m, x β€ m β§ β z, m β€ z β z β€ m := by |
let β¨m, _, hxm, hmβ© := zorn_nonempty_preorderβ (Ici a) (fun c hca hc y hy β¦ ?_) x hax
Β· exact β¨m, hxm, fun z hmz => hm _ (hax.trans <| hxm.trans hmz) hmzβ©
Β· have β¨ub, hubβ© := ih c hca hc y hy; exact β¨ub, (hca hy).trans (hub y hy), hubβ©
| [
" a β maxChain r",
" a β insert a (maxChain r)",
" IsChain (fun x x_1 => x β€ x_1) (Subtype.val '' c)",
" (fun x x_1 => x β€ x_1) βp βq β¨ (fun x x_1 => x β€ x_1) βq βp",
" β m β s, x β€ m β§ β z β s, m β€ z β z β€ m",
" β ub β {y | y β s β§ x β€ y}, β z β c, z β€ ub",
" β ub β {y | y β s β§ x β€ y}, β z β β
, z β€ ub... | [
" a β maxChain r",
" a β insert a (maxChain r)",
" IsChain (fun x x_1 => x β€ x_1) (Subtype.val '' c)",
" (fun x x_1 => x β€ x_1) βp βq β¨ (fun x x_1 => x β€ x_1) βq βp",
" β m β s, x β€ m β§ β z β s, m β€ z β z β€ m",
" β ub β {y | y β s β§ x β€ y}, β z β c, z β€ ub",
" β ub β {y | y β s β§ x β€ y}, β z β β
, z β€ ub... |
import Mathlib.Data.List.Cycle
import Mathlib.GroupTheory.Perm.Cycle.Type
import Mathlib.GroupTheory.Perm.List
#align_import group_theory.perm.cycle.concrete from "leanprover-community/mathlib"@"00638177efd1b2534fc5269363ebf42a7871df9a"
open Equiv Equiv.Perm List
variable {Ξ± : Type*}
namespace List
variable [D... | Mathlib/GroupTheory/Perm/Cycle/Concrete.lean | 120 | 123 | theorem formPerm_apply_mem_eq_next (hl : Nodup l) (x : Ξ±) (hx : x β l) :
formPerm l x = next l x hx := by |
obtain β¨k, rflβ© := get_of_mem hx
rw [next_get _ hl, formPerm_apply_get _ hl]
| [
" l.formPerm.Disjoint l'.formPerm β l.Disjoint l'",
" (β (x : Ξ±), l.formPerm x = x β¨ l'.formPerm x = x) β β β¦a : Ξ±β¦, a β l β a β l' β False",
" (β (x : Ξ±), l.formPerm x = x β¨ l'.formPerm x = x) β β β¦a : Ξ±β¦, a β l β a β l' β False",
" False",
" (β β¦a : Ξ±β¦, a β l β a β l' β False) β β (x : Ξ±), l.formPerm x = ... | [
" l.formPerm.Disjoint l'.formPerm β l.Disjoint l'",
" (β (x : Ξ±), l.formPerm x = x β¨ l'.formPerm x = x) β β β¦a : Ξ±β¦, a β l β a β l' β False",
" (β (x : Ξ±), l.formPerm x = x β¨ l'.formPerm x = x) β β β¦a : Ξ±β¦, a β l β a β l' β False",
" False",
" (β β¦a : Ξ±β¦, a β l β a β l' β False) β β (x : Ξ±), l.formPerm x = ... |
import Mathlib.Algebra.Order.BigOperators.Ring.Finset
import Mathlib.Analysis.Convex.Hull
import Mathlib.LinearAlgebra.AffineSpace.Basis
#align_import analysis.convex.combination from "leanprover-community/mathlib"@"92bd7b1ffeb306a89f450bee126ddd8a284c259d"
open Set Function
open scoped Classical
open Pointwise
... | Mathlib/Analysis/Convex/Combination.lean | 70 | 71 | theorem Finset.centerMass_singleton (hw : w i β 0) : ({i} : Finset ΞΉ).centerMass w z = z i := by |
rw [centerMass, sum_singleton, sum_singleton, β mul_smul, inv_mul_cancel hw, one_smul]
| [
" β
.centerMass w z = 0",
" {i, j}.centerMass w z = (w i / (w i + w j)) β’ z i + (w j / (w i + w j)) β’ z j",
" (insert i t).centerMass w z =\n (w i / (w i + β j β t, w j)) β’ z i + ((β j β t, w j) / (w i + β j β t, w j)) β’ t.centerMass w z",
" (w i / (w i + β i β t, w i)) β’ z i + (w i + β i β t, w i)β»ΒΉ β’ β i ... | [
" β
.centerMass w z = 0",
" {i, j}.centerMass w z = (w i / (w i + w j)) β’ z i + (w j / (w i + w j)) β’ z j",
" (insert i t).centerMass w z =\n (w i / (w i + β j β t, w j)) β’ z i + ((β j β t, w j) / (w i + β j β t, w j)) β’ t.centerMass w z",
" (w i / (w i + β i β t, w i)) β’ z i + (w i + β i β t, w i)β»ΒΉ β’ β i ... |
import Mathlib.Data.DFinsupp.WellFounded
import Mathlib.Data.Finsupp.Lex
#align_import data.finsupp.well_founded from "leanprover-community/mathlib"@"5fd3186f1ec30a75d5f65732e3ce5e623382556f"
variable {Ξ± N : Type*}
namespace Finsupp
variable [Zero N] {r : Ξ± β Ξ± β Prop} {s : N β N β Prop} (hbot : β β¦nβ¦, Β¬s n 0)
... | Mathlib/Data/Finsupp/WellFounded.lean | 37 | 42 | theorem Lex.acc (x : Ξ± ββ N) (h : β a β x.support, Acc (rαΆ β (Β· β Β·)) a) :
Acc (Finsupp.Lex r s) x := by |
rw [lex_eq_invImage_dfinsupp_lex]
classical
refine InvImage.accessible toDFinsupp (DFinsupp.Lex.acc (fun _ => hbot) (fun _ => hs) _ ?_)
simpa only [toDFinsupp_support] using h
| [
" Acc (Finsupp.Lex r s) x",
" Acc (InvImage (DFinsupp.Lex r fun x => s) toDFinsupp) x",
" β i β x.toDFinsupp.support, Acc (rαΆ β fun x x_1 => x β x_1) i"
] | [
" Acc (Finsupp.Lex r s) x"
] |
import Mathlib.Algebra.Polynomial.Eval
#align_import data.polynomial.degree.lemmas from "leanprover-community/mathlib"@"728baa2f54e6062c5879a3e397ac6bac323e506f"
noncomputable section
open Polynomial
open Finsupp Finset
namespace Polynomial
universe u v w
variable {R : Type u} {S : Type v} {ΞΉ : Type w} {a b ... | Mathlib/Algebra/Polynomial/Degree/Lemmas.lean | 356 | 357 | theorem degree_mul_C (a0 : a β 0) : (p * C a).degree = p.degree := by |
rw [degree_mul, degree_C a0, add_zero]
| [
" (p * C a).degree = p.degree"
] | [
" (p * C a).degree = p.degree"
] |
import Mathlib.Order.Interval.Set.OrdConnected
import Mathlib.Data.Set.Lattice
#align_import data.set.intervals.ord_connected_component from "leanprover-community/mathlib"@"92ca63f0fb391a9ca5f22d2409a6080e786d99f7"
open Interval Function OrderDual
namespace Set
variable {Ξ± : Type*} [LinearOrder Ξ±] {s t : Set Ξ±}... | Mathlib/Order/Interval/Set/OrdConnectedComponent.lean | 77 | 79 | theorem ordConnectedComponent_inter (s t : Set Ξ±) (x : Ξ±) :
ordConnectedComponent (s β© t) x = ordConnectedComponent s x β© ordConnectedComponent t x := by |
simp [ordConnectedComponent, setOf_and]
| [
" toDual x β (βofDual β»ΒΉ' s).ordConnectedComponent (toDual xβ) β toDual x β βofDual β»ΒΉ' s.ordConnectedComponent xβ",
" βofDual β»ΒΉ' [[xβ, x]] β βofDual β»ΒΉ' s β toDual x β βofDual β»ΒΉ' s.ordConnectedComponent xβ",
" x β s.ordConnectedComponent x β x β s",
" s.ordConnectedComponent x = β
β x β s",
" univ.ordCon... | [
" toDual x β (βofDual β»ΒΉ' s).ordConnectedComponent (toDual xβ) β toDual x β βofDual β»ΒΉ' s.ordConnectedComponent xβ",
" βofDual β»ΒΉ' [[xβ, x]] β βofDual β»ΒΉ' s β toDual x β βofDual β»ΒΉ' s.ordConnectedComponent xβ",
" x β s.ordConnectedComponent x β x β s",
" s.ordConnectedComponent x = β
β x β s",
" univ.ordCon... |
import Mathlib.Analysis.InnerProductSpace.Dual
#align_import analysis.inner_product_space.lax_milgram from "leanprover-community/mathlib"@"46b633fd842bef9469441c0209906f6dddd2b4f5"
noncomputable section
open RCLike LinearMap ContinuousLinearMap InnerProductSpace
open LinearMap (ker range)
open RealInnerProduct... | Mathlib/Analysis/InnerProductSpace/LaxMilgram.lean | 65 | 71 | theorem antilipschitz (coercive : IsCoercive B) : β C : ββ₯0, 0 < C β§ AntilipschitzWith C Bβ― := by |
rcases coercive.bounded_below with β¨C, C_pos, below_boundβ©
refine β¨Cβ»ΒΉ.toNNReal, Real.toNNReal_pos.mpr (inv_pos.mpr C_pos), ?_β©
refine ContinuousLinearMap.antilipschitz_of_bound Bβ― ?_
simp_rw [Real.coe_toNNReal', max_eq_left_of_lt (inv_pos.mpr C_pos), β
inv_mul_le_iff (inv_pos.mpr C_pos)]
simpa using bel... | [
" β C, 0 < C β§ β (v : V), C * βvβ β€ β(continuousLinearMapOfBilin B) vβ",
" β (v : V), C * βvβ β€ β(continuousLinearMapOfBilin B) vβ",
" C * βvβ β€ β(continuousLinearMapOfBilin B) vβ",
" C * βvβ * βvβ β€ β(continuousLinearMapOfBilin B) vβ * βvβ",
" v = 0",
" β C, 0 < C β§ AntilipschitzWith C β(continuousLinear... | [
" β C, 0 < C β§ β (v : V), C * βvβ β€ β(continuousLinearMapOfBilin B) vβ",
" β (v : V), C * βvβ β€ β(continuousLinearMapOfBilin B) vβ",
" C * βvβ β€ β(continuousLinearMapOfBilin B) vβ",
" C * βvβ * βvβ β€ β(continuousLinearMapOfBilin B) vβ * βvβ",
" v = 0",
" β C, 0 < C β§ AntilipschitzWith C β(continuousLinear... |
import Mathlib.Algebra.Algebra.Tower
import Mathlib.Algebra.MvPolynomial.Basic
#align_import ring_theory.mv_polynomial.tower from "leanprover-community/mathlib"@"bb168510ef455e9280a152e7f31673cabd3d7496"
variable (R A B : Type*) {Ο : Type*}
namespace MvPolynomial
section Semiring
variable [CommSemiring R] [Com... | Mathlib/RingTheory/MvPolynomial/Tower.lean | 35 | 37 | theorem aeval_map_algebraMap (x : Ο β B) (p : MvPolynomial Ο R) :
aeval x (map (algebraMap R A) p) = aeval x p := by |
rw [aeval_def, aeval_def, evalβ_map, IsScalarTower.algebraMap_eq R A B]
| [
" (aeval x) ((map (algebraMap R A)) p) = (aeval x) p"
] | [
" (aeval x) ((map (algebraMap R A)) p) = (aeval x) p"
] |
import Mathlib.Algebra.Group.Pi.Lemmas
import Mathlib.Algebra.Module.Defs
import Mathlib.GroupTheory.Abelianization
import Mathlib.GroupTheory.FreeGroup.Basic
#align_import group_theory.free_abelian_group from "leanprover-community/mathlib"@"dc6c365e751e34d100e80fe6e314c3c3e0fd2988"
universe u v
variable (Ξ± : Ty... | Mathlib/GroupTheory/FreeAbelianGroup.lean | 129 | 135 | theorem map_hom {Ξ± Ξ² Ξ³} [AddCommGroup Ξ²] [AddCommGroup Ξ³] (a : FreeAbelianGroup Ξ±) (f : Ξ± β Ξ²)
(g : Ξ² β+ Ξ³) : g (lift f a) = lift (g β f) a := by |
show (g.comp (lift f)) a = lift (g β f) a
apply lift.unique
intro a
show g ((lift f) (of a)) = g (f a)
simp only [(Β· β Β·), lift.of]
| [
" Unique (FreeAbelianGroup Ξ±)",
" Unique (Additive (Abelianization (FreeGroup Ξ±)))",
" (lift f) (of x) = f x",
" f x = (FreeGroup.lift f) (FreeGroup.of x)",
" g ((lift f) a) = (lift (βg β f)) a",
" (g.comp (lift f)) a = (lift (βg β f)) a",
" β (x : Ξ±), (g.comp (lift f)) (of x) = (βg β f) x",
" (g.comp... | [
" Unique (FreeAbelianGroup Ξ±)",
" Unique (Additive (Abelianization (FreeGroup Ξ±)))",
" (lift f) (of x) = f x",
" f x = (FreeGroup.lift f) (FreeGroup.of x)",
" g ((lift f) a) = (lift (βg β f)) a"
] |
import Mathlib.Algebra.Polynomial.AlgebraMap
import Mathlib.Data.Complex.Exponential
import Mathlib.Data.Complex.Module
import Mathlib.RingTheory.Polynomial.Chebyshev
#align_import analysis.special_functions.trigonometric.chebyshev from "leanprover-community/mathlib"@"2c1d8ca2812b64f88992a5294ea3dba144755cd1"
set_... | Mathlib/Analysis/SpecialFunctions/Trigonometric/Chebyshev.lean | 34 | 35 | theorem aeval_U (x : A) (n : β€) : aeval x (U R n) = (U A n).eval x := by |
rw [aeval_def, evalβ_eq_eval_map, map_U]
| [
" (aeval x) (T R n) = eval x (T A n)",
" (aeval x) (U R n) = eval x (U A n)"
] | [
" (aeval x) (T R n) = eval x (T A n)",
" (aeval x) (U R n) = eval x (U A n)"
] |
import Mathlib.Order.CompleteLattice
import Mathlib.Order.Cover
import Mathlib.Order.Iterate
import Mathlib.Order.WellFounded
#align_import order.succ_pred.basic from "leanprover-community/mathlib"@"0111834459f5d7400215223ea95ae38a1265a907"
open Function OrderDual Set
variable {Ξ± Ξ² : Type*}
@[ext]
class SuccOr... | Mathlib/Order/SuccPred/Basic.lean | 290 | 295 | theorem succ_le_succ (h : a β€ b) : succ a β€ succ b := by |
by_cases hb : IsMax b
Β· by_cases hba : b β€ a
Β· exact (hb <| hba.trans <| le_succ _).trans (le_succ _)
Β· exact succ_le_of_lt ((h.lt_of_not_le hba).trans_le <| le_succ b)
Β· rwa [succ_le_iff_of_not_isMax fun ha => hb <| ha.mono h, lt_succ_iff_of_not_isMax hb]
| [
" β (a : Ξ±α΅α΅), (βtoDual β SuccOrder.succ β βofDual) a β€ a",
" IsMin aβ",
" β {a b : Ξ±α΅α΅}, a < b β a β€ (βtoDual β SuccOrder.succ β βofDual) b",
" a β€ (βtoDual β SuccOrder.succ β βofDual) b",
" β (a : Ξ±α΅α΅), a β€ (βtoDual β PredOrder.pred β βofDual) a",
" IsMax aβ",
" β {a b : Ξ±α΅α΅}, a < b β (βtoDual β PredO... | [
" β (a : Ξ±α΅α΅), (βtoDual β SuccOrder.succ β βofDual) a β€ a",
" IsMin aβ",
" β {a b : Ξ±α΅α΅}, a < b β a β€ (βtoDual β SuccOrder.succ β βofDual) b",
" a β€ (βtoDual β SuccOrder.succ β βofDual) b",
" β (a : Ξ±α΅α΅), a β€ (βtoDual β PredOrder.pred β βofDual) a",
" IsMax aβ",
" β {a b : Ξ±α΅α΅}, a < b β (βtoDual β PredO... |
import Mathlib.GroupTheory.GroupAction.Prod
import Mathlib.Algebra.Ring.Int
import Mathlib.Data.Nat.Cast.Basic
assert_not_exists DenselyOrdered
variable {M : Type*}
class NatPowAssoc (M : Type*) [MulOneClass M] [Pow M β] : Prop where
protected npow_add : β (k n: β) (x : M), x ^ (k + n) = x ^ k * x ^ n
... | Mathlib/Algebra/Group/NatPowAssoc.lean | 65 | 67 | theorem npow_mul_assoc (k m n : β) (x : M) :
(x ^ k * x ^ m) * x ^ n = x ^ k * (x ^ m * x ^ n) := by |
simp only [β npow_add, add_assoc]
| [
" x ^ k * x ^ m * x ^ n = x ^ k * (x ^ m * x ^ n)"
] | [
" x ^ k * x ^ m * x ^ n = x ^ k * (x ^ m * x ^ n)"
] |
import Mathlib.LinearAlgebra.Matrix.Determinant.Basic
#align_import linear_algebra.matrix.reindex from "leanprover-community/mathlib"@"1cfdf5f34e1044ecb65d10be753008baaf118edf"
namespace Matrix
open Equiv Matrix
variable {l m n o : Type*} {l' m' n' o' : Type*} {m'' n'' : Type*}
variable (R A : Type*)
section A... | Mathlib/LinearAlgebra/Matrix/Reindex.lean | 73 | 77 | theorem reindexLinearEquiv_comp (eβ : m β m') (eβ : n β n') (eβ' : m' β m'') (eβ' : n' β n'') :
reindexLinearEquiv R A eβ' eβ' β reindexLinearEquiv R A eβ eβ =
reindexLinearEquiv R A (eβ.trans eβ') (eβ.trans eβ') := by |
rw [β reindexLinearEquiv_trans]
rfl
| [
" reindexLinearEquiv R A eβ eβ βͺβ«β reindexLinearEquiv R A eβ' eβ' = reindexLinearEquiv R A (eβ.trans eβ') (eβ.trans eβ')",
" (reindexLinearEquiv R A eβ eβ βͺβ«β reindexLinearEquiv R A eβ' eβ') xβ iβ jβ =\n (reindexLinearEquiv R A (eβ.trans eβ') (eβ.trans eβ')) xβ iβ jβ",
" β(reindexLinearEquiv R A eβ' eβ') β β... | [
" reindexLinearEquiv R A eβ eβ βͺβ«β reindexLinearEquiv R A eβ' eβ' = reindexLinearEquiv R A (eβ.trans eβ') (eβ.trans eβ')",
" (reindexLinearEquiv R A eβ eβ βͺβ«β reindexLinearEquiv R A eβ' eβ') xβ iβ jβ =\n (reindexLinearEquiv R A (eβ.trans eβ') (eβ.trans eβ')) xβ iβ jβ",
" β(reindexLinearEquiv R A eβ' eβ') β β... |
import Mathlib.CategoryTheory.Sites.IsSheafFor
import Mathlib.CategoryTheory.Limits.Shapes.Types
import Mathlib.Tactic.ApplyFun
#align_import category_theory.sites.sheaf_of_types from "leanprover-community/mathlib"@"70fd9563a21e7b963887c9360bd29b2393e6225a"
universe w v u
namespace CategoryTheory
open Opposite ... | Mathlib/CategoryTheory/Sites/EqualizerSheafCondition.lean | 216 | 223 | theorem w : forkMap P R β« firstMap P R = forkMap P R β« secondMap P R := by |
dsimp
ext fg
simp only [firstMap, secondMap, forkMap]
simp only [limit.lift_Ο, limit.lift_Ο_assoc, assoc, Fan.mk_Ο_app]
haveI := Presieve.hasPullbacks.has_pullbacks fg.1.2.2 fg.2.2.2
rw [β P.map_comp, β op_comp, pullback.condition]
simp
| [
" zβ = zβ",
" β (j : Discrete ((Y : C) Γ { f // R f })),\n limit.Ο (Discrete.functor fun f => P.obj { unop := f.fst }) j zβ =\n limit.Ο (Discrete.functor fun f => P.obj { unop := f.fst }) j zβ",
" limit.Ο (Discrete.functor fun f => P.obj { unop := f.fst }) { as := β¨Y, β¨f, hfβ©β© } zβ =\n limit.Ο (Discr... | [
" zβ = zβ",
" β (j : Discrete ((Y : C) Γ { f // R f })),\n limit.Ο (Discrete.functor fun f => P.obj { unop := f.fst }) j zβ =\n limit.Ο (Discrete.functor fun f => P.obj { unop := f.fst }) j zβ",
" limit.Ο (Discrete.functor fun f => P.obj { unop := f.fst }) { as := β¨Y, β¨f, hfβ©β© } zβ =\n limit.Ο (Discr... |
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 | 120 | 120 | theorem nat_rawCast_0 : (Nat.rawCast 0 : R) = 0 := by | simp
| [
" a * -b = -(a * b)",
" Nat.rawCast 0 = 0"
] | [
" a * -b = -(a * b)",
" Nat.rawCast 0 = 0"
] |
import Mathlib.Order.CompleteLattice
import Mathlib.Data.Finset.Lattice
import Mathlib.CategoryTheory.Limits.Shapes.Pullbacks
import Mathlib.CategoryTheory.Category.Preorder
import Mathlib.CategoryTheory.Limits.Shapes.Products
import Mathlib.CategoryTheory.Limits.Shapes.FiniteLimits
#align_import category_theory.limi... | Mathlib/CategoryTheory/Limits/Lattice.lean | 99 | 107 | theorem finite_coproduct_eq_finset_sup [SemilatticeSup Ξ±] [OrderBot Ξ±] {ΞΉ : Type u} [Fintype ΞΉ]
(f : ΞΉ β Ξ±) : β f = Fintype.elems.sup f := by |
trans
Β· exact
(IsColimit.coconePointUniqueUpToIso (colimit.isColimit _)
(finiteColimitCocone (Discrete.functor f)).isColimit).to_eq
change Finset.univ.sup (f β discreteEquiv.toEmbedding) = Fintype.elems.sup f
simp only [β Finset.sup_map, Finset.univ_map_equiv_to_embedding]
rfl
| [
" β (J : Type) [π₯ : SmallCategory J] [inst : FinCategory J], HasLimitsOfShape J Ξ±",
" HasLimitsOfShape J Ξ±",
" β (J : Type) [π₯ : SmallCategory J] [inst : FinCategory J], HasColimitsOfShape J Ξ±",
" HasColimitsOfShape J Ξ±",
" βαΆ f = Fintype.elems.inf f",
" βαΆ f = ?m.21382",
" (finiteLimitCone (Discrete.... | [
" β (J : Type) [π₯ : SmallCategory J] [inst : FinCategory J], HasLimitsOfShape J Ξ±",
" HasLimitsOfShape J Ξ±",
" β (J : Type) [π₯ : SmallCategory J] [inst : FinCategory J], HasColimitsOfShape J Ξ±",
" HasColimitsOfShape J Ξ±",
" βαΆ f = Fintype.elems.inf f",
" βαΆ f = ?m.21382",
" (finiteLimitCone (Discrete.... |
import Mathlib.Topology.Separation
open Topology Filter Set TopologicalSpace
section Basic
variable {Ξ± : Type*} [TopologicalSpace Ξ±] {C : Set Ξ±}
theorem AccPt.nhds_inter {x : Ξ±} {U : Set Ξ±} (h_acc : AccPt x (π C)) (hU : U β π x) :
AccPt x (π (U β© C)) := by
have : π[β ] x β€ π U := by
rw [le_princ... | Mathlib/Topology/Perfect.lean | 147 | 153 | theorem Perfect.closure_nhds_inter {U : Set Ξ±} (hC : Perfect C) (x : Ξ±) (xC : x β C) (xU : x β U)
(Uop : IsOpen U) : Perfect (closure (U β© C)) β§ (closure (U β© C)).Nonempty := by |
constructor
Β· apply Preperfect.perfect_closure
exact hC.acc.open_inter Uop
apply Nonempty.closure
exact β¨x, β¨xU, xCβ©β©
| [
" AccPt x (π (U β© C))",
" π[β ] x β€ π U",
" U β π[β ] x",
" (π[β ] x β π C).NeBot",
" Preperfect C β β x β C, β U β π x, β y β U β© C, y β x",
" Preperfect (U β© C)",
" U β π x",
" Perfect (closure C)",
" IsClosed (closure C)",
" Preperfect (closure C)",
" AccPt x (π (closure C))",
" AccPt... | [
" AccPt x (π (U β© C))",
" π[β ] x β€ π U",
" U β π[β ] x",
" (π[β ] x β π C).NeBot",
" Preperfect C β β x β C, β U β π x, β y β U β© C, y β x",
" Preperfect (U β© C)",
" U β π x",
" Perfect (closure C)",
" IsClosed (closure C)",
" Preperfect (closure C)",
" AccPt x (π (closure C))",
" AccPt... |
import Mathlib.Init.Logic
import Mathlib.Tactic.AdaptationNote
import Mathlib.Tactic.Coe
set_option autoImplicit true
-- We align Lean 3 lemmas with lemmas in `Init.SimpLemmas` in Lean 4.
#align band_self Bool.and_self
#align band_tt Bool.and_true
#align band_ff Bool.and_false
#align tt_band Bool.true_and
#align f... | Mathlib/Init/Data/Bool/Lemmas.lean | 51 | 51 | theorem false_eq_true_eq_False : Β¬false = true := by | decide
| [
" Β¬true = false",
" Β¬false = true"
] | [
" Β¬true = false",
" Β¬false = true"
] |
import Mathlib.Analysis.NormedSpace.lpSpace
import Mathlib.Topology.Sets.Compacts
#align_import topology.metric_space.kuratowski from "leanprover-community/mathlib"@"95d4f6586d313c8c28e00f36621d2a6a66893aa6"
noncomputable section
set_option linter.uppercaseLean3 false
open Set Metric TopologicalSpace NNReal ENNR... | Mathlib/Topology/MetricSpace/Kuratowski.lean | 91 | 102 | theorem exists_isometric_embedding (Ξ± : Type u) [MetricSpace Ξ±] [SeparableSpace Ξ±] :
β f : Ξ± β β^β(β), Isometry f := by |
rcases (univ : Set Ξ±).eq_empty_or_nonempty with h | h
Β· use fun _ => 0; intro x; exact absurd h (Nonempty.ne_empty β¨x, mem_univ xβ©)
Β· -- We construct a map x : β β Ξ± with dense image
rcases h with β¨basepointβ©
haveI : Inhabited Ξ± := β¨basepointβ©
have : β s : Set Ξ±, s.Countable β§ Dense s := exists_count... | [
" (fun n => dist a (x n) - dist (x 0) (x n)) β lp (fun i => β) β€",
" BddAbove (range fun i => β(fun n => dist a (x n) - dist (x 0) (x n)) iβ)",
" dist a (x 0) β upperBounds (range fun i => β(fun n => dist a (x n) - dist (x 0) (x n)) iβ)",
" (fun i => β(fun n => dist a (x n) - dist (x 0) (x n)) iβ) n β€ dist a ... | [
" (fun n => dist a (x n) - dist (x 0) (x n)) β lp (fun i => β) β€",
" BddAbove (range fun i => β(fun n => dist a (x n) - dist (x 0) (x n)) iβ)",
" dist a (x 0) β upperBounds (range fun i => β(fun n => dist a (x n) - dist (x 0) (x n)) iβ)",
" (fun i => β(fun n => dist a (x n) - dist (x 0) (x n)) iβ) n β€ dist a ... |
import Mathlib.Algebra.Order.Kleene
import Mathlib.Algebra.Ring.Hom.Defs
import Mathlib.Data.List.Join
import Mathlib.Data.Set.Lattice
import Mathlib.Tactic.DeriveFintype
#align_import computability.language from "leanprover-community/mathlib"@"a239cd3e7ac2c7cde36c913808f9d40c411344f6"
open List Set Computability... | Mathlib/Computability/Language.lean | 104 | 104 | theorem mem_one (x : List Ξ±) : x β (1 : Language Ξ±) β x = [] := by | rfl
| [
" x β 1 β x = []"
] | [
" x β 1 β x = []"
] |
import Mathlib.Geometry.Manifold.ContMDiff.Basic
open Set ChartedSpace SmoothManifoldWithCorners
open scoped Manifold
variable {π : Type*} [NontriviallyNormedField π]
-- declare a smooth manifold `M` over the pair `(E, H)`.
{E : Type*}
[NormedAddCommGroup E] [NormedSpace π E] {H : Type*} [TopologicalSpace... | Mathlib/Geometry/Manifold/ContMDiff/Atlas.lean | 36 | 42 | theorem contMDiff_model : ContMDiff I π(π, E) n I := by |
intro x
refine (contMDiffAt_iff _ _).mpr β¨I.continuousAt, ?_β©
simp only [mfld_simps]
refine contDiffWithinAt_id.congr_of_eventuallyEq ?_ ?_
Β· exact Filter.eventuallyEq_of_mem self_mem_nhdsWithin fun xβ => I.right_inv
simp_rw [Function.comp_apply, I.left_inv, Function.id_def]
| [
" ContMDiff I π(π, E) n βI",
" ContMDiffAt I π(π, E) n (βI) x",
" ContDiffWithinAt π n (β(extChartAt π(π, E) (βI x)) β βI β β(extChartAt I x).symm) (range βI) (β(extChartAt I x) x)",
" ContDiffWithinAt π n (βI β βI.symm) (range βI) (βI x)",
" βI β βI.symm =αΆ [nhdsWithin (βI x) (range βI)] id",
" (β... | [
" ContMDiff I π(π, E) n βI"
] |
import Mathlib.Algebra.Order.Ring.Abs
#align_import data.int.order.units from "leanprover-community/mathlib"@"d012cd09a9b256d870751284dd6a29882b0be105"
namespace Int
theorem isUnit_iff_abs_eq {x : β€} : IsUnit x β abs x = 1 := by
rw [isUnit_iff_natAbs_eq, abs_eq_natAbs, β Int.ofNat_one, natCast_inj]
#align int.... | Mathlib/Data/Int/Order/Units.lean | 33 | 33 | theorem units_mul_self (u : β€Λ£) : u * u = 1 := by | rw [β sq, units_sq]
| [
" IsUnit x β |x| = 1",
" a ^ 2 = 1",
" u ^ 2 = 1",
" u * u = 1"
] | [
" IsUnit x β |x| = 1",
" a ^ 2 = 1",
" u ^ 2 = 1",
" u * u = 1"
] |
import Mathlib.Data.Matrix.Invertible
import Mathlib.LinearAlgebra.Matrix.NonsingularInverse
import Mathlib.LinearAlgebra.Matrix.PosDef
#align_import linear_algebra.matrix.schur_complement from "leanprover-community/mathlib"@"a176cb1219e300e85793d44583dede42377b51af"
variable {l m n Ξ± : Type*}
namespace Matrix
... | Mathlib/LinearAlgebra/Matrix/SchurComplement.lean | 506 | 519 | theorem IsHermitian.fromBlocksββ [Fintype m] [DecidableEq m] {A : Matrix m m π} (B : Matrix m n π)
(D : Matrix n n π) (hA : A.IsHermitian) :
(Matrix.fromBlocks A B Bα΄΄ D).IsHermitian β (D - Bα΄΄ * Aβ»ΒΉ * B).IsHermitian := by |
have hBAB : (Bα΄΄ * Aβ»ΒΉ * B).IsHermitian := by
apply isHermitian_conjTranspose_mul_mul
apply hA.inv
rw [isHermitian_fromBlocks_iff]
constructor
Β· intro h
apply IsHermitian.sub h.2.2.2 hBAB
Β· intro h
refine β¨hA, rfl, conjTranspose_conjTranspose B, ?_β©
rw [β sub_add_cancel D]
apply IsHerm... | [
" A.fromBlocks B C D = fromBlocks 1 0 (C * β
A) 1 * A.fromBlocks 0 0 (D - C * β
A * B) * fromBlocks 1 (β
A * B) 0 1",
" (reindex (Equiv.sumComm l n) (Equiv.sumComm m n)) (A.fromBlocks B C D) =\n (reindex (Equiv.sumComm l n) (Equiv.sumComm m n))\n (fromBlocks 1 (B * β
D) 0 1 * (A - B * β
D * C).fromBlocks 0 0 D... | [
" A.fromBlocks B C D = fromBlocks 1 0 (C * β
A) 1 * A.fromBlocks 0 0 (D - C * β
A * B) * fromBlocks 1 (β
A * B) 0 1",
" (reindex (Equiv.sumComm l n) (Equiv.sumComm m n)) (A.fromBlocks B C D) =\n (reindex (Equiv.sumComm l n) (Equiv.sumComm m n))\n (fromBlocks 1 (B * β
D) 0 1 * (A - B * β
D * C).fromBlocks 0 0 D... |
import Mathlib.Data.Set.Function
import Mathlib.Order.Interval.Set.OrdConnected
#align_import data.set.intervals.proj_Icc from "leanprover-community/mathlib"@"4e24c4bfcff371c71f7ba22050308aa17815626c"
variable {Ξ± Ξ² : Type*} [LinearOrder Ξ±]
open Function
namespace Set
def projIci (a x : Ξ±) : Ici a := β¨max a x,... | Mathlib/Order/Interval/Set/ProjIcc.lean | 128 | 128 | theorem projIic_coe (x : Iic b) : projIic b x = x := by | cases x; apply projIic_of_mem
| [
" projIcc a b h x = β¨a, β―β©",
" projIcc a b h x = β¨b, β―β©",
" projIci a x = β¨a, β―β© β x β€ a",
" projIic b x = β¨b, β―β© β b β€ x",
" projIcc a b β― x = β¨a, β―β© β x β€ a",
" projIcc a b β― x = β¨b, β―β© β b β€ x",
" projIci a x = β¨x, hxβ©",
" projIic b x = β¨x, hxβ©",
" projIcc a b h x = β¨x, hxβ©",
" projIci a βx = x... | [
" projIcc a b h x = β¨a, β―β©",
" projIcc a b h x = β¨b, β―β©",
" projIci a x = β¨a, β―β© β x β€ a",
" projIic b x = β¨b, β―β© β b β€ x",
" projIcc a b β― x = β¨a, β―β© β x β€ a",
" projIcc a b β― x = β¨b, β―β© β b β€ x",
" projIci a x = β¨x, hxβ©",
" projIic b x = β¨x, hxβ©",
" projIcc a b h x = β¨x, hxβ©",
" projIci a βx = x... |
import Mathlib.Algebra.MonoidAlgebra.Degree
import Mathlib.Algebra.MvPolynomial.Rename
import Mathlib.Algebra.Order.BigOperators.Ring.Finset
#align_import data.mv_polynomial.variables from "leanprover-community/mathlib"@"2f5b500a507264de86d666a5f87ddb976e2d8de4"
noncomputable section
open Set Function Finsupp Ad... | Mathlib/Algebra/MvPolynomial/Degrees.lean | 144 | 146 | theorem degrees_prod {ΞΉ : Type*} (s : Finset ΞΉ) (f : ΞΉ β MvPolynomial Ο R) :
(β i β s, f i).degrees β€ β i β s, (f i).degrees := by |
classical exact supDegree_prod_le (map_zero _) (map_add _)
| [
" p.degrees = p.support.sup fun s => toMultiset s",
" (p.support.sup fun s => toMultiset s) = p.support.sup fun s => toMultiset s",
" ((monomial s) a).degrees β€ toMultiset s",
" (if a = 0 then β₯ else toMultiset s) β€ toMultiset s",
" toMultiset s β€ toMultiset s",
" ((monomial s) a).degrees = toMultiset s",... | [
" p.degrees = p.support.sup fun s => toMultiset s",
" (p.support.sup fun s => toMultiset s) = p.support.sup fun s => toMultiset s",
" ((monomial s) a).degrees β€ toMultiset s",
" (if a = 0 then β₯ else toMultiset s) β€ toMultiset s",
" toMultiset s β€ toMultiset s",
" ((monomial s) a).degrees = toMultiset s",... |
import Mathlib.MeasureTheory.Integral.Lebesgue
import Mathlib.Analysis.MeanInequalities
import Mathlib.Analysis.MeanInequalitiesPow
import Mathlib.MeasureTheory.Function.SpecialFunctions.Basic
#align_import measure_theory.integral.mean_inequalities from "leanprover-community/mathlib"@"13bf7613c96a9fd66a81b9020a82cad9... | Mathlib/MeasureTheory/Integral/MeanInequalities.lean | 110 | 130 | theorem lintegral_mul_le_Lp_mul_Lq_of_ne_zero_of_ne_top {p q : β} (hpq : p.IsConjExponent q)
{f g : Ξ± β ββ₯0β} (hf : AEMeasurable f ΞΌ) (hf_nontop : (β«β» a, f a ^ p βΞΌ) β β€)
(hg_nontop : (β«β» a, g a ^ q βΞΌ) β β€) (hf_nonzero : (β«β» a, f a ^ p βΞΌ) β 0)
(hg_nonzero : (β«β» a, g a ^ q βΞΌ) β 0) :
(β«β» a, (f * g) a β... |
let npf := (β«β» c : Ξ±, f c ^ p βΞΌ) ^ (1 / p)
let nqg := (β«β» c : Ξ±, g c ^ q βΞΌ) ^ (1 / q)
calc
(β«β» a : Ξ±, (f * g) a βΞΌ) =
β«β» a : Ξ±, (funMulInvSnorm f p ΞΌ * funMulInvSnorm g q ΞΌ) a * (npf * nqg) βΞΌ := by
refine lintegral_congr fun a => ?_
rw [Pi.mul_apply, fun_eq_funMulInvSnorm_mul_snorm f h... | [
" β«β» (a : Ξ±), (f * g) a βΞΌ β€ 1",
" β«β» (a : Ξ±), f a ^ p / ENNReal.ofReal p + g a ^ q / ENNReal.ofReal q βΞΌ = 1",
" β«β» (a : Ξ±), f a ^ p * (ENNReal.ofReal p)β»ΒΉ + g a ^ q * (ENNReal.ofReal q)β»ΒΉ βΞΌ = 1",
" β«β» (a : Ξ±), f a ^ p * (ENNReal.ofReal p)β»ΒΉ βΞΌ + β«β» (a : Ξ±), g a ^ q * (ENNReal.ofReal q)β»ΒΉ βΞΌ = 1",
" (ENNR... | [
" β«β» (a : Ξ±), (f * g) a βΞΌ β€ 1",
" β«β» (a : Ξ±), f a ^ p / ENNReal.ofReal p + g a ^ q / ENNReal.ofReal q βΞΌ = 1",
" β«β» (a : Ξ±), f a ^ p * (ENNReal.ofReal p)β»ΒΉ + g a ^ q * (ENNReal.ofReal q)β»ΒΉ βΞΌ = 1",
" β«β» (a : Ξ±), f a ^ p * (ENNReal.ofReal p)β»ΒΉ βΞΌ + β«β» (a : Ξ±), g a ^ q * (ENNReal.ofReal q)β»ΒΉ βΞΌ = 1",
" (ENNR... |
import Mathlib.Data.PFunctor.Univariate.Basic
#align_import data.pfunctor.univariate.M from "leanprover-community/mathlib"@"8631e2d5ea77f6c13054d9151d82b83069680cb1"
universe u v w
open Nat Function
open List
variable (F : PFunctor.{u})
-- Porting note: the β― tactic is never used
-- local prefix:0 "β―" => cast... | Mathlib/Data/PFunctor/Univariate/M.lean | 128 | 134 | theorem P_corec (i : X) (n : β) : Agree (sCorec f i n) (sCorec f i (succ n)) := by |
induction' n with n n_ih generalizing i
constructor
cases' f i with y g
constructor
introv
apply n_ih
| [
" x = CofixA.intro (head' x) (children' x)",
" CofixA.intro aβΒΉ aβ = CofixA.intro (head' (CofixA.intro aβΒΉ aβ)) (children' (CofixA.intro aβΒΉ aβ))",
" Agree x y",
" Agree (children' x i) (children' y j)",
" Agree (children' (CofixA.intro aβ xβ) i) (children' (CofixA.intro aβ x'β) j)",
" Agree (children' (C... | [
" x = CofixA.intro (head' x) (children' x)",
" CofixA.intro aβΒΉ aβ = CofixA.intro (head' (CofixA.intro aβΒΉ aβ)) (children' (CofixA.intro aβΒΉ aβ))",
" Agree x y",
" Agree (children' x i) (children' y j)",
" Agree (children' (CofixA.intro aβ xβ) i) (children' (CofixA.intro aβ x'β) j)",
" Agree (children' (C... |
import Mathlib.Algebra.Algebra.Tower
import Mathlib.Algebra.Module.BigOperators
import Mathlib.LinearAlgebra.Basis
#align_import ring_theory.algebra_tower from "leanprover-community/mathlib"@"94825b2b0b982306be14d891c4f063a1eca4f370"
open Pointwise
universe u v w uβ
variable (R : Type u) (S : Type v) (A : Type ... | Mathlib/RingTheory/AlgebraTower.lean | 108 | 121 | theorem linearIndependent_smul {ΞΉ : Type vβ} {b : ΞΉ β S} {ΞΉ' : Type wβ} {c : ΞΉ' β A}
(hb : LinearIndependent R b) (hc : LinearIndependent S c) :
LinearIndependent R fun p : ΞΉ Γ ΞΉ' => b p.1 β’ c p.2 := by |
rw [linearIndependent_iff'] at hb hc; rw [linearIndependent_iff'']; rintro s g hg hsg β¨i, kβ©
by_cases hik : (i, k) β s
Β· have h1 : β i β s.image Prod.fst ΓΛ’ s.image Prod.snd, g i β’ b i.1 β’ c i.2 = 0 := by
rw [β hsg]
exact
(Finset.sum_subset Finset.subset_product fun p _ hp =>
show... | [
" LinearIndependent R fun p => b p.1 β’ c p.2",
" β (s : Finset (ΞΉ Γ ΞΉ')) (g : ΞΉ Γ ΞΉ' β R),\n (β i β s, g i = 0) β β i β s, g i β’ b i.1 β’ c i.2 = 0 β β (i : ΞΉ Γ ΞΉ'), g i = 0",
" g (i, k) = 0",
" β i β Finset.image Prod.fst s ΓΛ’ Finset.image Prod.snd s, g i β’ b i.1 β’ c i.2 = 0",
" β i β Finset.image Prod.f... | [
" LinearIndependent R fun p => b p.1 β’ c p.2"
] |
import Mathlib.Probability.Notation
import Mathlib.Probability.Density
import Mathlib.Probability.ConditionalProbability
import Mathlib.Probability.ProbabilityMassFunction.Constructions
open scoped Classical MeasureTheory NNReal ENNReal
-- TODO: We can't `open ProbabilityTheory` without opening the `ProbabilityThe... | Mathlib/Probability/Distributions/Uniform.lean | 66 | 75 | theorem aemeasurable {X : Ξ© β E} {s : Set E} (hns : ΞΌ s β 0) (hnt : ΞΌ s β β)
(hu : IsUniform X s β ΞΌ) : AEMeasurable X β := by |
dsimp [IsUniform, ProbabilityTheory.cond] at hu
by_contra h
rw [map_of_not_aemeasurable h] at hu
apply zero_ne_one' ββ₯0β
calc
0 = (0 : Measure E) Set.univ := rfl
_ = _ := by rw [hu, smul_apply, restrict_apply MeasurableSet.univ,
Set.univ_inter, smul_eq_mul, ENNReal.inv_mul_cancel hns hnt]
| [
" AEMeasurable X β",
" False",
" 0 = 1",
" 0 Set.univ = 1"
] | [
" AEMeasurable X β"
] |
import Mathlib.LinearAlgebra.FiniteDimensional
import Mathlib.LinearAlgebra.FreeModule.Finite.Basic
import Mathlib.LinearAlgebra.FreeModule.StrongRankCondition
import Mathlib.LinearAlgebra.Projection
import Mathlib.LinearAlgebra.SesquilinearForm
import Mathlib.RingTheory.TensorProduct.Basic
import Mathlib.RingTheory.I... | Mathlib/LinearAlgebra/Dual.lean | 226 | 231 | theorem LinearMap.dualMap_injective_of_surjective {f : Mβ ββ[R] Mβ} (hf : Function.Surjective f) :
Function.Injective f.dualMap := by |
intro Ο Ο h
ext x
obtain β¨y, rflβ© := hf x
exact congr_arg (fun g : Module.Dual R Mβ => g y) h
| [
" id.dualMap = id",
" (id.dualMap xβΒΉ) xβ = (id xβΒΉ) xβ",
" Function.Injective βf.dualMap",
" Ο = Ο",
" Ο x = Ο x",
" Ο (f y) = Ο (f y)"
] | [
" id.dualMap = id",
" (id.dualMap xβΒΉ) xβ = (id xβΒΉ) xβ",
" Function.Injective βf.dualMap"
] |
import Mathlib.Algebra.BigOperators.Fin
import Mathlib.Algebra.MvPolynomial.Rename
import Mathlib.Algebra.MvPolynomial.Degrees
import Mathlib.Algebra.Polynomial.AlgebraMap
import Mathlib.Data.Finsupp.Fin
import Mathlib.Logic.Equiv.Fin
#align_import data.mv_polynomial.equiv from "leanprover-community/mathlib"@"2f5b500... | Mathlib/Algebra/MvPolynomial/Equiv.lean | 143 | 147 | theorem mapAlgEquiv_trans (e : Aβ ββ[R] Aβ) (f : Aβ ββ[R] Aβ) :
(mapAlgEquiv Ο e).trans (mapAlgEquiv Ο f) = mapAlgEquiv Ο (e.trans f) := by |
ext
simp only [AlgEquiv.trans_apply, mapAlgEquiv_apply, map_map]
rfl
| [
" LeftInverse (Polynomial.evalβ C (X PUnit.unit)) (evalβ Polynomial.C fun x => Polynomial.X)",
" β (p : MvPolynomial PUnit.{?u.2415 + 1} R), (f.comp g) p = p",
" (f.comp g).comp C = C",
" coeff mβ (((f.comp g).comp C) a) = coeff mβ (C a)",
" coeff mβ (Polynomial.evalβ C (X PUnit.unit) (evalβ Polynomial.C (f... | [
" LeftInverse (Polynomial.evalβ C (X PUnit.unit)) (evalβ Polynomial.C fun x => Polynomial.X)",
" β (p : MvPolynomial PUnit.{?u.2415 + 1} R), (f.comp g) p = p",
" (f.comp g).comp C = C",
" coeff mβ (((f.comp g).comp C) a) = coeff mβ (C a)",
" coeff mβ (Polynomial.evalβ C (X PUnit.unit) (evalβ Polynomial.C (f... |
import Mathlib.RingTheory.Localization.Module
import Mathlib.RingTheory.Norm
import Mathlib.RingTheory.Discriminant
#align_import ring_theory.localization.norm from "leanprover-community/mathlib"@"2e59a6de168f95d16b16d217b808a36290398c0a"
open scoped nonZeroDivisors
variable (R : Type*) {S : Type*} [CommRing R] ... | Mathlib/RingTheory/Localization/NormTrace.lean | 50 | 56 | theorem Algebra.map_leftMulMatrix_localization {ΞΉ : Type*} [Fintype ΞΉ] [DecidableEq ΞΉ]
(b : Basis ΞΉ R S) (a : S) :
(algebraMap R Rβ).mapMatrix (leftMulMatrix b a) =
leftMulMatrix (b.localizationLocalization Rβ M Sβ) (algebraMap S Sβ a) := by |
ext i j
simp only [Matrix.map_apply, RingHom.mapMatrix_apply, leftMulMatrix_eq_repr_mul, β map_mul,
Basis.localizationLocalization_apply, Basis.localizationLocalization_repr_algebraMap]
| [
" (algebraMap R Rβ).mapMatrix ((leftMulMatrix b) a) =\n (leftMulMatrix (Basis.localizationLocalization Rβ M Sβ b)) ((algebraMap S Sβ) a)",
" (algebraMap R Rβ).mapMatrix ((leftMulMatrix b) a) i j =\n (leftMulMatrix (Basis.localizationLocalization Rβ M Sβ b)) ((algebraMap S Sβ) a) i j"
] | [
" (algebraMap R Rβ).mapMatrix ((leftMulMatrix b) a) =\n (leftMulMatrix (Basis.localizationLocalization Rβ M Sβ b)) ((algebraMap S Sβ) a)"
] |
import Mathlib.RingTheory.Valuation.Basic
import Mathlib.NumberTheory.Padics.PadicNorm
import Mathlib.Analysis.Normed.Field.Basic
#align_import number_theory.padics.padic_numbers from "leanprover-community/mathlib"@"b9b2114f7711fec1c1e055d507f082f8ceb2c3b7"
noncomputable section
open scoped Classical
open Nat m... | Mathlib/NumberTheory/Padics/PadicNumbers.lean | 121 | 135 | theorem norm_zero_iff (f : PadicSeq p) : f.norm = 0 β f β 0 := by |
constructor
Β· intro h
by_contra hf
unfold norm at h
split_ifs at h
Β· contradiction
apply hf
intro Ξ΅ hΞ΅
exists stationaryPoint hf
intro j hj
have heq := stationaryPoint_spec hf le_rfl hj
simpa [h, heq]
Β· intro h
simp [norm, h]
| [
" padicNorm p (βf m) = padicNorm p (βf n)",
" False",
" f.norm = 0 β f β 0",
" f.norm = 0 β f β 0",
" f β 0",
" β i, β j β₯ i, padicNorm p (β(f - 0) j) < Ξ΅",
" β j β₯ stationaryPoint hf, padicNorm p (β(f - 0) j) < Ξ΅",
" padicNorm p (β(f - 0) j) < Ξ΅",
" f β 0 β f.norm = 0",
" f.norm = 0"
] | [
" padicNorm p (βf m) = padicNorm p (βf n)",
" False",
" f.norm = 0 β f β 0"
] |
import Mathlib.Analysis.SpecialFunctions.Integrals
#align_import data.real.pi.wallis from "leanprover-community/mathlib"@"980755c33b9168bc82f774f665eaa27878140fac"
open scoped Real Topology Nat
open Filter Finset intervalIntegral
namespace Real
namespace Wallis
set_option linter.uppercaseLean3 false
noncomp... | Mathlib/Data/Real/Pi/Wallis.lean | 85 | 88 | theorem W_le (k : β) : W k β€ Ο / 2 := by |
rw [β div_le_one pi_div_two_pos, div_eq_inv_mul]
rw [W_eq_integral_sin_pow_div_integral_sin_pow, div_le_one (integral_sin_pow_pos _)]
apply integral_sin_pow_succ_le
| [
" 0 < W k",
" 0 < W 0",
" 0 < β i β range 0, (2 * βi + 2) / (2 * βi + 1) * ((2 * βi + 2) / (2 * βi + 3))",
" 0 < W (k + 1)",
" 0 < W k * ((2 * βk + 2) / (2 * βk + 1) * ((2 * βk + 2) / (2 * βk + 3)))",
" 0 < 2 * βk + 2",
" 0 < 2 * βk + 1",
" 0 < 2 * βk + 3",
" W n = 2 ^ (4 * n) * βn ! ^ 4 / (β(2 * n)... | [
" 0 < W k",
" 0 < W 0",
" 0 < β i β range 0, (2 * βi + 2) / (2 * βi + 1) * ((2 * βi + 2) / (2 * βi + 3))",
" 0 < W (k + 1)",
" 0 < W k * ((2 * βk + 2) / (2 * βk + 1) * ((2 * βk + 2) / (2 * βk + 3)))",
" 0 < 2 * βk + 2",
" 0 < 2 * βk + 1",
" 0 < 2 * βk + 3",
" W n = 2 ^ (4 * n) * βn ! ^ 4 / (β(2 * n)... |
import Aesop
import Mathlib.Algebra.Group.Defs
import Mathlib.Data.Nat.Defs
import Mathlib.Data.Int.Defs
import Mathlib.Logic.Function.Basic
import Mathlib.Tactic.Cases
import Mathlib.Tactic.SimpRw
import Mathlib.Tactic.SplitIfs
#align_import algebra.group.basic from "leanprover-community/mathlib"@"a07d750983b94c530a... | Mathlib/Algebra/Group/Basic.lean | 1,426 | 1,432 | theorem multiplicative_of_isTotal (p : Ξ± β Prop) (hswap : β {a b}, p a β p b β f a b * f b a = 1)
(hmul : β {a b c}, r a b β r b c β p a β p b β p c β f a c = f a b * f b c) {a b c : Ξ±}
(pa : p a) (pb : p b) (pc : p c) : f a c = f a b * f b c := by |
apply multiplicative_of_symmetric_of_isTotal (fun a b => p a β§ p b) r f fun _ _ => And.symm
Β· simp_rw [and_imp]; exact @hswap
Β· exact fun rab rbc pab _pbc pac => hmul rab rbc pab.1 pab.2 pac.2
exacts [β¨pa, pbβ©, β¨pb, pcβ©, β¨pa, pcβ©]
| [
" f a c = f a b * f b c",
" β {b c : Ξ±}, r b c β p a b β p b c β p a c β f a c = f a b * f b c",
" f a b * (f b a * f a c) = f a b * f b c",
" β {a b : Ξ±}, p a β§ p b β f a b * f b a = 1",
" β {a b : Ξ±}, p a β p b β f a b * f b a = 1",
" β {a b c : Ξ±}, r a b β r b c β p a β§ p b β p b β§ p c β p a β§ p c β f ... | [
" f a c = f a b * f b c",
" β {b c : Ξ±}, r b c β p a b β p b c β p a c β f a c = f a b * f b c",
" f a b * (f b a * f a c) = f a b * f b c"
] |
import Mathlib.Data.Multiset.Basic
#align_import data.multiset.range from "leanprover-community/mathlib"@"0a0ec35061ed9960bf0e7ffb0335f44447b58977"
open List Nat
namespace Multiset
-- range
def range (n : β) : Multiset β :=
List.range n
#align multiset.range Multiset.range
theorem coe_range (n : β) : β(List... | Mathlib/Data/Multiset/Range.lean | 73 | 75 | theorem range_add_eq_union (a b : β) : range (a + b) = range a βͺ (range b).map (a + Β·) := by |
rw [range_add, add_eq_union_iff_disjoint]
apply range_disjoint_map_add
| [
" range n.succ = n ::β range n",
" β[n] + β(List.range n) = n ::β range n",
" (range a).Disjoint (map (fun x => a + x) m)",
" False",
" range (a + b) = range a βͺ map (fun x => a + x) (range b)",
" (range a).Disjoint (map (fun x => a + x) (range b))"
] | [
" range n.succ = n ::β range n",
" β[n] + β(List.range n) = n ::β range n",
" (range a).Disjoint (map (fun x => a + x) m)",
" False",
" range (a + b) = range a βͺ map (fun x => a + x) (range b)"
] |
import Mathlib.Algebra.Order.EuclideanAbsoluteValue
import Mathlib.Algebra.Order.Group.Basic
import Mathlib.Algebra.Order.Ring.Basic
import Mathlib.Algebra.Polynomial.FieldDivision
#align_import data.polynomial.degree.card_pow_degree from "leanprover-community/mathlib"@"85d9f2189d9489f9983c0d01536575b0233bd305"
n... | Mathlib/Algebra/Polynomial/Degree/CardPowDegree.lean | 79 | 83 | theorem cardPowDegree_apply [DecidableEq Fq] (p : Fq[X]) :
cardPowDegree p = if p = 0 then 0 else (Fintype.card Fq : β€) ^ natDegree p := by |
rw [cardPowDegree]
dsimp
convert rfl
| [
" (fun p => if p = 0 then 0 else β(Fintype.card Fq) ^ p.natDegree) (p * q) =\n (fun p => if p = 0 then 0 else β(Fintype.card Fq) ^ p.natDegree) p *\n (fun p => if p = 0 then 0 else β(Fintype.card Fq) ^ p.natDegree) q",
" 0 β€ { toFun := fun p => if p = 0 then 0 else β(Fintype.card Fq) ^ p.natDegree, map_mu... | [
" (fun p => if p = 0 then 0 else β(Fintype.card Fq) ^ p.natDegree) (p * q) =\n (fun p => if p = 0 then 0 else β(Fintype.card Fq) ^ p.natDegree) p *\n (fun p => if p = 0 then 0 else β(Fintype.card Fq) ^ p.natDegree) q",
" 0 β€ { toFun := fun p => if p = 0 then 0 else β(Fintype.card Fq) ^ p.natDegree, map_mu... |
import Mathlib.Data.Opposite
import Mathlib.Tactic.Cases
#align_import combinatorics.quiver.basic from "leanprover-community/mathlib"@"56adee5b5eef9e734d82272918300fca4f3e7cef"
open Opposite
-- We use the same universe order as in category theory.
-- See note [CategoryTheory universes]
universe v vβ vβ u uβ uβ
... | Mathlib/Combinatorics/Quiver/Basic.lean | 138 | 140 | theorem congr_map {U V : Type*} [Quiver U] [Quiver V] (F : U β₯€q V) {X Y : U} {f g : X βΆ Y}
(h : f = g) : F.map f = F.map g := by |
rw [h]
| [
" F = G",
" { obj := F_obj, map := mapβ } = G",
" { obj := F_obj, map := mapβΒΉ } = { obj := G_obj, map := mapβ }",
" F_obj = G_obj",
" F_obj X = G_obj X",
" { obj := F_obj, map := mapβΒΉ } = { obj := F_obj, map := mapβ }",
" mapβΒΉ = mapβ",
" mapβΒΉ f = mapβ f",
" F.map f = F.map g"
] | [
" F = G",
" { obj := F_obj, map := mapβ } = G",
" { obj := F_obj, map := mapβΒΉ } = { obj := G_obj, map := mapβ }",
" F_obj = G_obj",
" F_obj X = G_obj X",
" { obj := F_obj, map := mapβΒΉ } = { obj := F_obj, map := mapβ }",
" mapβΒΉ = mapβ",
" mapβΒΉ f = mapβ f",
" F.map f = F.map g"
] |
import Mathlib.Algebra.BigOperators.NatAntidiagonal
import Mathlib.Algebra.Order.Ring.Abs
import Mathlib.Data.Nat.Choose.Sum
import Mathlib.RingTheory.PowerSeries.Basic
#align_import ring_theory.power_series.well_known from "leanprover-community/mathlib"@"8199f6717c150a7fe91c4534175f4cf99725978f"
namespace PowerS... | Mathlib/RingTheory/PowerSeries/WellKnown.lean | 218 | 220 | theorem map_cos : map f (cos A) = cos A' := by |
ext
simp [cos, apply_ite f]
| [
" (constantCoeff A) (exp A) = 1",
" (algebraMap β A) (1 / β0!) = 1",
" (coeff A (bit0 n)) (sin A) = 0",
" (coeff A (bit1 n)) (sin A) = (-1) ^ n * (coeff A (bit1 n)) (exp A)",
" (coeff A (bit0 n)) (cos A) = (-1) ^ n * (coeff A (bit0 n)) (exp A)",
" (coeff A (bit1 n)) (cos A) = 0",
" (map f) (exp A) = exp... | [
" (constantCoeff A) (exp A) = 1",
" (algebraMap β A) (1 / β0!) = 1",
" (coeff A (bit0 n)) (sin A) = 0",
" (coeff A (bit1 n)) (sin A) = (-1) ^ n * (coeff A (bit1 n)) (exp A)",
" (coeff A (bit0 n)) (cos A) = (-1) ^ n * (coeff A (bit0 n)) (exp A)",
" (coeff A (bit1 n)) (cos A) = 0",
" (map f) (exp A) = exp... |
import Mathlib.Geometry.RingedSpace.PresheafedSpace
import Mathlib.CategoryTheory.Limits.Final
import Mathlib.Topology.Sheaves.Stalks
#align_import algebraic_geometry.stalks from "leanprover-community/mathlib"@"d39590fc8728fbf6743249802486f8c91ffe07bc"
noncomputable section
universe v u v' u'
open Opposite Cate... | Mathlib/Geometry/RingedSpace/Stalks.lean | 108 | 121 | theorem restrictStalkIso_inv_eq_ofRestrict {U : TopCat} (X : PresheafedSpace.{_, _, v} C)
{f : U βΆ (X : TopCat.{v})} (h : OpenEmbedding f) (x : U) :
(X.restrictStalkIso h x).inv = stalkMap (X.ofRestrict h) x := by |
-- We can't use `ext` here due to https://github.com/leanprover/std4/pull/159
refine colimit.hom_ext fun V => ?_
induction V with | h V => ?_
let i : (h.isOpenMap.functorNhds x).obj ((OpenNhds.map f x).obj V) βΆ V :=
homOfLE (Set.image_preimage_subset f _)
erw [Iso.comp_inv_eq, colimit.ΞΉ_map_assoc, colimi... | [] | [
" Y.presheaf.germ β¨Ξ±.base βx, β―β© β« stalkMap Ξ± βx = Ξ±.c.app { unop := U } β« X.presheaf.germ x",
" X.presheaf.germ β¨f x, β―β© β« (X.restrictStalkIso h x).inv = (X.restrict h).presheaf.germ β¨x, hxβ©",
" (X.restrictStalkIso h x).inv = stalkMap (X.ofRestrict h) x"
] |
import Mathlib.Algebra.Group.Subsemigroup.Basic
#align_import group_theory.subsemigroup.membership from "leanprover-community/mathlib"@"6cb77a8eaff0ddd100e87b1591c6d3ad319514ff"
assert_not_exists MonoidWithZero
variable {ΞΉ : Sort*} {M A B : Type*}
section NonAssoc
variable [Mul M]
open Set
namespace Subsemigr... | Mathlib/Algebra/Group/Subsemigroup/Membership.lean | 109 | 112 | theorem mem_sSup_of_mem {S : Set (Subsemigroup M)} {s : Subsemigroup M} (hs : s β S) :
β {x : M}, x β s β x β sSup S := by |
have : s β€ sSup S := le_sSup hs
tauto
| [
" x β β¨ i, S i β β i, x β S i",
" x β β¨ i, S i β β i, x β S i",
" x β closure (β i, β(S i)) β β i, x β S i",
" β (x y : M), (β i, x β S i) β (β i, y β S i) β β i, x * y β S i",
" β i, x * y β S i",
" x β β(β¨ i, S i) β x β β i, β(S i)",
" x β sSup S β β s β S, x β s",
" x β β(sSup S) β x β β s β S, βs"... | [
" x β β¨ i, S i β β i, x β S i",
" x β β¨ i, S i β β i, x β S i",
" x β closure (β i, β(S i)) β β i, x β S i",
" β (x y : M), (β i, x β S i) β (β i, y β S i) β β i, x * y β S i",
" β i, x * y β S i",
" x β β(β¨ i, S i) β x β β i, β(S i)",
" x β sSup S β β s β S, x β s",
" x β β(sSup S) β x β β s β S, βs"... |
import Mathlib.Combinatorics.SetFamily.Shadow
#align_import combinatorics.set_family.compression.uv from "leanprover-community/mathlib"@"6f8ab7de1c4b78a68ab8cf7dd83d549eb78a68a1"
open Finset
variable {Ξ± : Type*}
theorem sup_sdiff_injOn [GeneralizedBooleanAlgebra Ξ±] (u v : Ξ±) :
{ x | Disjoint u x β§ v β€ x }.... | Mathlib/Combinatorics/SetFamily/Compression/UV.lean | 185 | 190 | theorem compress_mem_compression (ha : a β s) : compress u v a β π u v s := by |
rw [mem_compression]
by_cases h : compress u v a β s
Β· rw [compress_idem]
exact Or.inl β¨h, hβ©
Β· exact Or.inr β¨h, a, ha, rflβ©
| [
" Set.InjOn (fun x => (x β u) \\ v) {x | Disjoint u x β§ v β€ x}",
" a = b",
" ((a β u) \\ v) \\ u β v = ((b β u) \\ v) \\ u β v",
" compress u v ((a β v) \\ u) = a",
" compress u u a = a",
" (if Disjoint u a β§ u β€ a then (a β u) \\ u else a) = a",
" (a β u) \\ u = a",
" a = a",
" compress (a \\ b) (b... | [
" Set.InjOn (fun x => (x β u) \\ v) {x | Disjoint u x β§ v β€ x}",
" a = b",
" ((a β u) \\ v) \\ u β v = ((b β u) \\ v) \\ u β v",
" compress u v ((a β v) \\ u) = a",
" compress u u a = a",
" (if Disjoint u a β§ u β€ a then (a β u) \\ u else a) = a",
" (a β u) \\ u = a",
" a = a",
" compress (a \\ b) (b... |
import Mathlib.Analysis.LocallyConvex.Bounded
import Mathlib.Analysis.RCLike.Basic
#align_import analysis.locally_convex.continuous_of_bounded from "leanprover-community/mathlib"@"3f655f5297b030a87d641ad4e825af8d9679eb0b"
open TopologicalSpace Bornology Filter Topology Pointwise
variable {π π' E F : Type*}
var... | Mathlib/Analysis/LocallyConvex/ContinuousOfBounded.lean | 96 | 166 | theorem LinearMap.continuousAt_zero_of_locally_bounded (f : E βββ[Ο] F)
(hf : β s, IsVonNBounded π s β IsVonNBounded π' (f '' s)) : ContinuousAt f 0 := by |
-- Assume that f is not continuous at 0
by_contra h
-- We use a decreasing balanced basis for 0 : E and a balanced basis for 0 : F
-- and reformulate non-continuity in terms of these bases
rcases (nhds_basis_balanced π E).exists_antitone_subbasis with β¨b, bE1, bEβ©
simp only [_root_.id] at bE
have bE' : ... | [
" ContinuousAt (βf) 0",
" False",
" (π 0).HasBasis (fun x => x β 0) fun n => (βn)β»ΒΉ β’ b n",
" β (i : β), True β β i', i' β 0 β§ (βi')β»ΒΉ β’ b i' β b i",
" β i', i' β 0 β§ (βi')β»ΒΉ β’ b i' β b n",
" n + 1 β 0 β§ (β(n + 1))β»ΒΉ β’ b (n + 1) β b n",
" (βn + 1)β»ΒΉ β’ b (n + 1) β b n",
" n β€ n + 1",
" (βn + 1)β»ΒΉ β’ ... | [
" ContinuousAt (βf) 0"
] |
import Mathlib.Combinatorics.SimpleGraph.Finite
import Mathlib.Data.Finset.Sym
import Mathlib.Data.Matrix.Basic
#align_import combinatorics.simple_graph.inc_matrix from "leanprover-community/mathlib"@"bb168510ef455e9280a152e7f31673cabd3d7496"
open Finset Matrix SimpleGraph Sym2
open Matrix
namespace SimpleGraph... | Mathlib/Combinatorics/SimpleGraph/IncMatrix.lean | 85 | 89 | theorem incMatrix_apply_mul_incMatrix_apply_of_not_adj (hab : a β b) (h : Β¬G.Adj a b) :
G.incMatrix R a e * G.incMatrix R b e = 0 := by |
rw [incMatrix_apply_mul_incMatrix_apply, Set.indicator_of_not_mem]
rw [G.incidenceSet_inter_incidenceSet_of_not_adj h hab]
exact Set.not_mem_empty e
| [
" incMatrix R G a e = if e β G.incidenceSet a then 1 else 0",
" (if e β G.incidenceSet a then 1 e else 0) = if e β G.incidenceSet a then 1 else 0",
" incMatrix R G a e * incMatrix R G b e = (G.incidenceSet a β© G.incidenceSet b).indicator 1 e",
" incMatrix R G a e * incMatrix R G b e = 0",
" e β G.incidenceS... | [
" incMatrix R G a e = if e β G.incidenceSet a then 1 else 0",
" (if e β G.incidenceSet a then 1 e else 0) = if e β G.incidenceSet a then 1 else 0",
" incMatrix R G a e * incMatrix R G b e = (G.incidenceSet a β© G.incidenceSet b).indicator 1 e",
" incMatrix R G a e * incMatrix R G b e = 0"
] |
import Mathlib.Order.Filter.AtTopBot
#align_import order.filter.indicator_function from "leanprover-community/mathlib"@"8631e2d5ea77f6c13054d9151d82b83069680cb1"
variable {Ξ± Ξ² M E : Type*}
open Set Filter
@[to_additive]
theorem Monotone.mulIndicator_eventuallyEq_iUnion {ΞΉ} [Preorder ΞΉ] [One Ξ²] (s : ΞΉ β Set Ξ±)
... | Mathlib/Order/Filter/IndicatorFunction.lean | 89 | 94 | theorem mulIndicator_biUnion_finset_eventuallyEq {ΞΉ} [One Ξ²] (s : ΞΉ β Set Ξ±) (f : Ξ± β Ξ²) (a : Ξ±) :
(fun n : Finset ΞΉ => mulIndicator (β i β n, s i) f a) =αΆ [atTop]
fun _ β¦ mulIndicator (iUnion s) f a := by |
rw [iUnion_eq_iUnion_finset s]
apply Monotone.mulIndicator_eventuallyEq_iUnion
exact fun _ _ β¦ biUnion_subset_biUnion_left
| [
" (fun i => (s i).mulIndicator f a) =αΆ [atTop] fun x => (β i, s i).mulIndicator f a",
" (fun i => (s i).mulIndicator f a) =αΆ [atTop] fun x => (β i, s i).mulIndicator f a",
" (fun n => (β i β n, s i).mulIndicator f a) =αΆ [atTop] fun x => (iUnion s).mulIndicator f a",
" (fun n => (β i β n, s i).mulIndicator f a) =... | [
" (fun i => (s i).mulIndicator f a) =αΆ [atTop] fun x => (β i, s i).mulIndicator f a",
" (fun i => (s i).mulIndicator f a) =αΆ [atTop] fun x => (β i, s i).mulIndicator f a",
" (fun n => (β i β n, s i).mulIndicator f a) =αΆ [atTop] fun x => (iUnion s).mulIndicator f a"
] |
import Mathlib.Algebra.Bounds
import Mathlib.Algebra.Order.Field.Basic -- Porting note: `LinearOrderedField`, etc
import Mathlib.Data.Set.Pointwise.SMul
#align_import algebra.order.pointwise from "leanprover-community/mathlib"@"9003f28797c0664a49e4179487267c494477d853"
open Function Set
open Pointwise
variable ... | Mathlib/Algebra/Order/Pointwise.lean | 183 | 194 | theorem smul_Ioo : r β’ Ioo a b = Ioo (r β’ a) (r β’ b) := by |
ext x
simp only [mem_smul_set, smul_eq_mul, mem_Ioo]
constructor
Β· rintro β¨a, β¨a_h_left_left, a_h_left_rightβ©, rflβ©
constructor
Β· exact (mul_lt_mul_left hr).mpr a_h_left_left
Β· exact (mul_lt_mul_left hr).mpr a_h_left_right
Β· rintro β¨a_left, a_rightβ©
use x / r
refine β¨β¨(lt_div_iff' hr).mpr... | [
" r β’ Ioo a b = Ioo (r β’ a) (r β’ b)",
" x β r β’ Ioo a b β x β Ioo (r β’ a) (r β’ b)",
" (β y, (a < y β§ y < b) β§ r * y = x) β r * a < x β§ x < r * b",
" (β y, (a < y β§ y < b) β§ r * y = x) β r * a < x β§ x < r * b",
" r * aβ < r * a β§ r * a < r * b",
" r * aβ < r * a",
" r * a < r * b",
" r * a < x β§ x < r ... | [
" r β’ Ioo a b = Ioo (r β’ a) (r β’ b)"
] |
import Mathlib.Analysis.MeanInequalities
import Mathlib.Data.Fintype.Order
import Mathlib.LinearAlgebra.Matrix.Basis
import Mathlib.Analysis.NormedSpace.WithLp
#align_import analysis.normed_space.pi_Lp from "leanprover-community/mathlib"@"9d013ad8430ddddd350cff5c3db830278ded3c79"
set_option linter.uppercaseLean3 f... | Mathlib/Analysis/NormedSpace/PiLp.lean | 247 | 249 | theorem dist_eq_iSup (f g : PiLp β Ξ±) : dist f g = β¨ i, dist (f i) (g i) := by |
dsimp [dist]
exact if_neg ENNReal.top_ne_zero
| [
" dist f g = β¨ i, dist (f i) (g i)",
" (if β€ = 0 then ββ―.toFinset.card\n else if β€ = β€ then β¨ i, dist (f i) (g i) else (β i : ΞΉ, dist (f i) (g i) ^ 0) ^ (1 / 0)) =\n β¨ i, dist (f i) (g i)"
] | [
" dist f g = β¨ i, dist (f i) (g i)"
] |
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 | 88 | 93 | theorem length_mul_left_ne (w : W) : β (w * t) β β w := by |
suffices cs.lengthParity (w * t) β cs.lengthParity w by
contrapose! this
simp only [lengthParity_eq_ofAdd_length, this]
rcases ht with β¨w, i, rflβ©
simp [lengthParity_simple]
| [
" cs.IsReflection (cs.simple i)",
" cs.simple i = 1 * cs.simple i * 1β»ΒΉ",
" t ^ 2 = 1",
" (w * cs.simple i * wβ»ΒΉ) ^ 2 = 1",
" t * t = 1",
" w * cs.simple i * wβ»ΒΉ * (w * cs.simple i * wβ»ΒΉ) = 1",
" tβ»ΒΉ = t",
" (w * cs.simple i * wβ»ΒΉ)β»ΒΉ = w * cs.simple i * wβ»ΒΉ",
" cs.IsReflection tβ»ΒΉ",
" Odd (cs.leng... | [
" cs.IsReflection (cs.simple i)",
" cs.simple i = 1 * cs.simple i * 1β»ΒΉ",
" t ^ 2 = 1",
" (w * cs.simple i * wβ»ΒΉ) ^ 2 = 1",
" t * t = 1",
" w * cs.simple i * wβ»ΒΉ * (w * cs.simple i * wβ»ΒΉ) = 1",
" tβ»ΒΉ = t",
" (w * cs.simple i * wβ»ΒΉ)β»ΒΉ = w * cs.simple i * wβ»ΒΉ",
" cs.IsReflection tβ»ΒΉ",
" Odd (cs.leng... |
import Mathlib.LinearAlgebra.ExteriorAlgebra.Basic
import Mathlib.RingTheory.GradedAlgebra.Basic
#align_import linear_algebra.exterior_algebra.grading from "leanprover-community/mathlib"@"34020e531ebc4e8aac6d449d9eecbcd1508ea8d0"
namespace ExteriorAlgebra
variable {R M : Type*} [CommRing R] [AddCommGroup M] [Modu... | Mathlib/LinearAlgebra/ExteriorAlgebra/Grading.lean | 64 | 80 | theorem GradedAlgebra.liftΞΉ_eq (i : β) (x : β[R]^i M) :
GradedAlgebra.liftΞΉ R M x = DirectSum.of (fun i => β[R]^i M) i x := by |
cases' x with x hx
dsimp only [Subtype.coe_mk, DirectSum.lof_eq_of]
-- Porting note: original statement was
-- refine Submodule.pow_induction_on_left' _ (fun r => ?_) (fun x y i hx hy ihx ihy => ?_)
-- (fun m hm i x hx ih => ?_) hx
-- but it created invalid goals
induction hx using Submodule.pow_indu... | [
" (ΞΉ R) m β β[R]^1 M",
" (GradedAlgebra.ΞΉ R M) m * (GradedAlgebra.ΞΉ R M) m = 0",
" (DirectSum.of (fun i => β₯(β[R]^i M)) (1 + 1)) (GradedMonoid.GMul.mul β¨(ΞΉ R) m, β―β© β¨(ΞΉ R) m, β―β©) = 0",
" M ββ[R] β¨ (i : β), β₯(β[R]^i M)",
" (liftΞΉ R M) βx = (DirectSum.of (fun i => β₯(β[R]^i M)) i) x",
" (liftΞΉ R M) ββ¨x, hxβ© ... | [
" (ΞΉ R) m β β[R]^1 M",
" (GradedAlgebra.ΞΉ R M) m * (GradedAlgebra.ΞΉ R M) m = 0",
" (DirectSum.of (fun i => β₯(β[R]^i M)) (1 + 1)) (GradedMonoid.GMul.mul β¨(ΞΉ R) m, β―β© β¨(ΞΉ R) m, β―β©) = 0",
" M ββ[R] β¨ (i : β), β₯(β[R]^i M)",
" (liftΞΉ R M) βx = (DirectSum.of (fun i => β₯(β[R]^i M)) i) x"
] |
import Mathlib.Algebra.Category.Ring.FilteredColimits
import Mathlib.Geometry.RingedSpace.SheafedSpace
import Mathlib.Topology.Sheaves.Stalks
import Mathlib.Algebra.Category.Ring.Colimits
import Mathlib.Algebra.Category.Ring.Limits
#align_import algebraic_geometry.ringed_space from "leanprover-community/mathlib"@"5dc... | Mathlib/Geometry/RingedSpace/Basic.lean | 58 | 79 | theorem isUnit_res_of_isUnit_germ (U : Opens X) (f : X.presheaf.obj (op U)) (x : U)
(h : IsUnit (X.presheaf.germ x f)) :
β (V : Opens X) (i : V βΆ U) (_ : x.1 β V), IsUnit (X.presheaf.map i.op f) := by |
obtain β¨g', heqβ© := h.exists_right_inv
obtain β¨V, hxV, g, rflβ© := X.presheaf.germ_exist x.1 g'
let W := U β V
have hxW : x.1 β W := β¨x.2, hxVβ©
-- Porting note: `erw` can't write into `HEq`, so this is replaced with another `HEq` in the
-- desired form
replace heq : (X.presheaf.germ β¨x.val, hxWβ©) ((X.pres... | [
" β V i, β (_ : βx β V), IsUnit ((X.presheaf.map i.op) f)",
" (X.presheaf.germ β¨βx, hxWβ©) ((X.presheaf.map (U.infLELeft V).op) f * (X.presheaf.map (U.infLERight V).op) g) =\n (X.presheaf.germ β¨βx, hxWβ©) 1",
" (Limits.colimit.ΞΉ ((OpenNhds.inclusion βx).op β X.presheaf) { unop := { obj := W, property := β― } })... | [
" β V i, β (_ : βx β V), IsUnit ((X.presheaf.map i.op) f)"
] |
import Mathlib.Algebra.Module.Submodule.Ker
open Function Submodule
namespace LinearMap
variable {R N M : Type*} [Semiring R] [AddCommMonoid N] [Module R N]
[AddCommMonoid M] [Module R M] (f i : N ββ[R] M)
def iterateMapComap (n : β) := (fun K : Submodule R N β¦ (K.map i).comap f)^[n]
theorem iterateMapComap... | Mathlib/Algebra/Module/Submodule/IterateMapComap.lean | 65 | 79 | theorem iterateMapComap_eq_succ (K : Submodule R N)
(m : β) (heq : f.iterateMapComap i m K = f.iterateMapComap i (m + 1) K)
(hf : Surjective f) (hi : Injective i) (n : β) :
f.iterateMapComap i n K = f.iterateMapComap i (n + 1) K := by |
induction n with
| zero =>
contrapose! heq
induction m with
| zero => exact heq
| succ m ih =>
rw [iterateMapComap, iterateMapComap, iterate_succ', iterate_succ']
exact fun H β¦ ih (map_injective_of_injective hi (comap_injective_of_surjective hf H))
| succ n ih =>
rw [iterateMapCom... | [
" f.iterateMapComap i n K β€ f.iterateMapComap i (n + 1) K",
" f.iterateMapComap i n K β€ (fun K => comap f (map i K))^[n + 1] K",
" map f (f.iterateMapComap i n K) β€ map i (f.iterateMapComap i n K)",
" map f (f.iterateMapComap i 0 K) β€ map i (f.iterateMapComap i 0 K)",
" map f (f.iterateMapComap i (n + 1) K)... | [
" f.iterateMapComap i n K β€ f.iterateMapComap i (n + 1) K",
" f.iterateMapComap i n K β€ (fun K => comap f (map i K))^[n + 1] K",
" map f (f.iterateMapComap i n K) β€ map i (f.iterateMapComap i n K)",
" map f (f.iterateMapComap i 0 K) β€ map i (f.iterateMapComap i 0 K)",
" map f (f.iterateMapComap i (n + 1) K)... |
import Mathlib.Topology.UniformSpace.UniformEmbedding
import Mathlib.Topology.UniformSpace.Equiv
#align_import topology.uniform_space.abstract_completion from "leanprover-community/mathlib"@"dc6c365e751e34d100e80fe6e314c3c3e0fd2988"
noncomputable section
attribute [local instance] Classical.propDecidable
open F... | Mathlib/Topology/UniformSpace/AbstractCompletion.lean | 158 | 161 | theorem extend_unique (hf : UniformContinuous f) {g : hatΞ± β Ξ²} (hg : UniformContinuous g)
(h : β a : Ξ±, f a = g (ΞΉ a)) : pkg.extend f = g := by |
apply pkg.funext pkg.continuous_extend hg.continuous
simpa only [pkg.extend_coe hf] using h
| [
" pkg.extend f (pkg.coe a) = f a",
" β―.extend f (pkg.coe a) = f a",
" UniformContinuous (pkg.extend f)",
" UniformContinuous (β―.extend f)",
" UniformContinuous (if UniformContinuous f then β―.extend f else fun x => f (β―.some x))",
" UniformContinuous fun x => f (β―.some x)",
" f (β―.some a) = f (β―.some b)"... | [
" pkg.extend f (pkg.coe a) = f a",
" β―.extend f (pkg.coe a) = f a",
" UniformContinuous (pkg.extend f)",
" UniformContinuous (β―.extend f)",
" UniformContinuous (if UniformContinuous f then β―.extend f else fun x => f (β―.some x))",
" UniformContinuous fun x => f (β―.some x)",
" f (β―.some a) = f (β―.some b)"... |
import Mathlib.Data.List.Infix
#align_import data.list.rdrop from "leanprover-community/mathlib"@"26f081a2fb920140ed5bc5cc5344e84bcc7cb2b2"
-- Make sure we don't import algebra
assert_not_exists Monoid
variable {Ξ± : Type*} (p : Ξ± β Bool) (l : List Ξ±) (n : β)
namespace List
def rdrop : List Ξ± :=
l.take (l.leng... | Mathlib/Data/List/DropRight.lean | 166 | 174 | theorem rdropWhile_eq_self_iff : rdropWhile p l = l β β hl : l β [], Β¬p (l.getLast hl) := by |
simp only [rdropWhile, reverse_eq_iff, dropWhile_eq_self_iff, getLast_eq_get]
refine β¨fun h hl => ?_, fun h hl => ?_β©
Β· rw [β length_pos, β length_reverse] at hl
have := h hl
rwa [get_reverse'] at this
Β· rw [length_reverse, length_pos] at hl
have := h hl
rwa [get_reverse']
| [
" [].rdrop n = []",
" l.rdrop 0 = l",
" l.rdrop n = (drop n l.reverse).reverse",
" take (l.length - n) l = (drop n l.reverse).reverse",
" take ([].length - n) [] = (drop n [].reverse).reverse",
" take ((xs ++ [x]).length - n) (xs ++ [x]) = (drop n (xs ++ [x]).reverse).reverse",
" take ((xs ++ [x]).lengt... | [
" [].rdrop n = []",
" l.rdrop 0 = l",
" l.rdrop n = (drop n l.reverse).reverse",
" take (l.length - n) l = (drop n l.reverse).reverse",
" take ([].length - n) [] = (drop n [].reverse).reverse",
" take ((xs ++ [x]).length - n) (xs ++ [x]) = (drop n (xs ++ [x]).reverse).reverse",
" take ((xs ++ [x]).lengt... |
import Mathlib.Data.List.Basic
namespace List
variable {Ξ± Ξ² : Type*}
@[simp]
theorem reduceOption_cons_of_some (x : Ξ±) (l : List (Option Ξ±)) :
reduceOption (some x :: l) = x :: l.reduceOption := by
simp only [reduceOption, filterMap, id, eq_self_iff_true, and_self_iff]
#align list.reduce_option_cons_of_some... | Mathlib/Data/List/ReduceOption.lean | 59 | 61 | theorem reduceOption_length_le (l : List (Option Ξ±)) : l.reduceOption.length β€ l.length := by |
rw [length_eq_reduceOption_length_add_filter_none]
apply Nat.le_add_right
| [
" (some x :: l).reduceOption = x :: l.reduceOption",
" (none :: l).reduceOption = l.reduceOption",
" (map (Option.map f) l).reduceOption = map f l.reduceOption",
" (map (Option.map f) []).reduceOption = map f [].reduceOption",
" (map (Option.map f) (hd :: tl)).reduceOption = map f (hd :: tl).reduceOption",
... | [
" (some x :: l).reduceOption = x :: l.reduceOption",
" (none :: l).reduceOption = l.reduceOption",
" (map (Option.map f) l).reduceOption = map f l.reduceOption",
" (map (Option.map f) []).reduceOption = map f [].reduceOption",
" (map (Option.map f) (hd :: tl)).reduceOption = map f (hd :: tl).reduceOption",
... |
import Mathlib.Algebra.Lie.Matrix
import Mathlib.LinearAlgebra.Matrix.SesquilinearForm
import Mathlib.Tactic.NoncommRing
#align_import algebra.lie.skew_adjoint from "leanprover-community/mathlib"@"075b3f7d19b9da85a0b54b3e33055a74fc388dec"
universe u v w wβ
section SkewAdjointMatrices
open scoped Matrix
variabl... | Mathlib/Algebra/Lie/SkewAdjoint.lean | 103 | 112 | theorem Matrix.isSkewAdjoint_bracket {A B : Matrix n n R} (hA : A β skewAdjointMatricesSubmodule J)
(hB : B β skewAdjointMatricesSubmodule J) : β
A, Bβ β skewAdjointMatricesSubmodule J := by |
simp only [mem_skewAdjointMatricesSubmodule] at *
change β
A, Bβα΅ * J = J * (-β
A, Bβ)
change Aα΅ * J = J * (-A) at hA
change Bα΅ * J = J * (-B) at hB
rw [Matrix.lie_transpose, LieRing.of_associative_ring_bracket,
LieRing.of_associative_ring_bracket, sub_mul, mul_assoc, mul_assoc, hA, hB, β mul_assoc,
β ... | [
" (A * B - B * A)α΅ = Bα΅ * Aα΅ - Aα΅ * Bα΅",
" β
A, Bβ β skewAdjointMatricesSubmodule J",
" J.IsSkewAdjoint β
A, Bβ",
" β
A, Bβα΅ * J = J * -β
A, Bβ",
" J * -B * -A - J * -A * -B = J * -(A * B - B * A)"
] | [
" (A * B - B * A)α΅ = Bα΅ * Aα΅ - Aα΅ * Bα΅",
" β
A, Bβ β skewAdjointMatricesSubmodule J"
] |
import Mathlib.Data.ENNReal.Inv
#align_import data.real.ennreal from "leanprover-community/mathlib"@"c14c8fcde993801fca8946b0d80131a1a81d1520"
open Set NNReal ENNReal
namespace ENNReal
section iInf
variable {ΞΉ : Sort*} {f g : ΞΉ β ββ₯0β}
variable {a b c d : ββ₯0β} {r p q : ββ₯0}
theorem toNNReal_iInf (hf : β i, f ... | Mathlib/Data/ENNReal/Real.lean | 581 | 582 | theorem toReal_iSup (hf : β i, f i β β) : (iSup f).toReal = β¨ i, (f i).toReal := by |
simp only [ENNReal.toReal, toNNReal_iSup hf, NNReal.coe_iSup]
| [
" (iInf f).toNNReal = β¨
i, (f i).toNNReal",
" (β¨
i, β(f i)).toNNReal = β¨
i, ((fun i => β(f i)) i).toNNReal",
" (sInf s).toNNReal = sInf (ENNReal.toNNReal '' s)",
" (iSup f).toNNReal = β¨ i, (f i).toNNReal",
" (β¨ i, β(f i)).toNNReal = β¨ i, ((fun i => β(f i)) i).toNNReal",
" (β¨ i, β(f i)).toNNReal = β¨ i, f i... | [
" (iInf f).toNNReal = β¨
i, (f i).toNNReal",
" (β¨
i, β(f i)).toNNReal = β¨
i, ((fun i => β(f i)) i).toNNReal",
" (sInf s).toNNReal = sInf (ENNReal.toNNReal '' s)",
" (iSup f).toNNReal = β¨ i, (f i).toNNReal",
" (β¨ i, β(f i)).toNNReal = β¨ i, ((fun i => β(f i)) i).toNNReal",
" (β¨ i, β(f i)).toNNReal = β¨ i, f i... |
import Mathlib.LinearAlgebra.CliffordAlgebra.Grading
import Mathlib.LinearAlgebra.TensorProduct.Graded.Internal
import Mathlib.LinearAlgebra.QuadraticForm.Prod
suppress_compilation
variable {R Mβ Mβ N : Type*}
variable [CommRing R] [AddCommGroup Mβ] [AddCommGroup Mβ] [AddCommGroup N]
variable [Module R Mβ] [Module... | Mathlib/LinearAlgebra/CliffordAlgebra/Prod.lean | 101 | 104 | theorem map_mul_map_eq_neg_of_isOrtho_of_mem_evenOdd_one
(hmβ : mβ β evenOdd Qβ 1) (hmβ : mβ β evenOdd Qβ 1) :
map fβ mβ * map fβ mβ = - map fβ mβ * map fβ mβ := by |
simp [map_mul_map_of_isOrtho_of_mem_evenOdd _ _ hf _ _ hmβ hmβ]
| [
" (map fβ) mβ * (map fβ) mβ = (-1) ^ (iβ * iβ) β’ ((map fβ) mβ * (map fβ) mβ)",
" (map fβ) 0 * (map fβ) mβ = (-1) ^ (iβ * iβ) β’ ((map fβ) mβ * (map fβ) 0)",
" (map fβ) (xβ + yβ) * (map fβ) mβ = (-1) ^ (iβ * iβ) β’ ((map fβ) mβ * (map fβ) (xβ + yβ))",
" (map fβ) mβ' * (map fβ) mβ = (-1) ^ (iβ * iβ) β’ ((map fβ) m... | [
" (map fβ) mβ * (map fβ) mβ = (-1) ^ (iβ * iβ) β’ ((map fβ) mβ * (map fβ) mβ)",
" (map fβ) 0 * (map fβ) mβ = (-1) ^ (iβ * iβ) β’ ((map fβ) mβ * (map fβ) 0)",
" (map fβ) (xβ + yβ) * (map fβ) mβ = (-1) ^ (iβ * iβ) β’ ((map fβ) mβ * (map fβ) (xβ + yβ))",
" (map fβ) mβ' * (map fβ) mβ = (-1) ^ (iβ * iβ) β’ ((map fβ) m... |
import Mathlib.Algebra.BigOperators.NatAntidiagonal
import Mathlib.Algebra.GeomSum
import Mathlib.Data.Fintype.BigOperators
import Mathlib.RingTheory.PowerSeries.Inverse
import Mathlib.RingTheory.PowerSeries.WellKnown
import Mathlib.Tactic.FieldSimp
#align_import number_theory.bernoulli from "leanprover-community/mat... | Mathlib/NumberTheory/Bernoulli.lean | 78 | 80 | theorem bernoulli'_def (n : β) :
bernoulli' n = 1 - β k β range n, n.choose k / (n - k + 1) * bernoulli' k := by |
rw [bernoulli'_def', β Fin.sum_univ_eq_sum_range]
| [
" bernoulli' n = 1 - β k β range n, β(n.choose k) / (βn - βk + 1) * bernoulli' k"
] | [
" bernoulli' n = 1 - β k β range n, β(n.choose k) / (βn - βk + 1) * bernoulli' k"
] |
import Mathlib.Data.PFunctor.Multivariate.Basic
#align_import data.qpf.multivariate.basic from "leanprover-community/mathlib"@"dc6c365e751e34d100e80fe6e314c3c3e0fd2988"
universe u
open MvFunctor
class MvQPF {n : β} (F : TypeVec.{u} n β Type*) [MvFunctor F] where
P : MvPFunctor.{u} n
abs : β {Ξ±}, P Ξ± β F Ξ±
... | Mathlib/Data/QPF/Multivariate/Basic.lean | 164 | 177 | theorem mem_supp {Ξ± : TypeVec n} (x : F Ξ±) (i) (u : Ξ± i) :
u β supp x i β β a f, abs β¨a, fβ© = x β u β f i '' univ := by |
rw [supp]; dsimp; constructor
Β· intro h a f haf
have : LiftP (fun i u => u β f i '' univ) x := by
rw [liftP_iff]
refine β¨a, f, haf.symm, ?_β©
intro i u
exact mem_image_of_mem _ (mem_univ _)
exact h this
intro h p; rw [liftP_iff]
rintro β¨a, f, xeq, h'β©
rcases h a f xeq.symm with... | [
" TypeVec.id <$$> x = x",
" TypeVec.id <$$> abs (repr x) = abs (repr x)",
" TypeVec.id <$$> abs β¨a, fβ© = abs β¨a, fβ©",
" abs (TypeVec.id <$$> β¨a, fβ©) = abs β¨a, fβ©",
" (g β f) <$$> x = g <$$> f <$$> x",
" (g β f) <$$> abs (repr x) = g <$$> f <$$> abs (repr x)",
" (g β fβ) <$$> abs β¨a, fβ© = g <$$> fβ <$$> ... | [
" TypeVec.id <$$> x = x",
" TypeVec.id <$$> abs (repr x) = abs (repr x)",
" TypeVec.id <$$> abs β¨a, fβ© = abs β¨a, fβ©",
" abs (TypeVec.id <$$> β¨a, fβ©) = abs β¨a, fβ©",
" (g β f) <$$> x = g <$$> f <$$> x",
" (g β f) <$$> abs (repr x) = g <$$> f <$$> abs (repr x)",
" (g β fβ) <$$> abs β¨a, fβ© = g <$$> fβ <$$> ... |
import Mathlib.LinearAlgebra.Matrix.Gershgorin
import Mathlib.NumberTheory.NumberField.CanonicalEmbedding.ConvexBody
import Mathlib.NumberTheory.NumberField.Units.Basic
import Mathlib.RingTheory.RootsOfUnity.Basic
#align_import number_theory.number_field.units from "leanprover-community/mathlib"@"00f91228655eecdcd3ac... | Mathlib/NumberTheory/NumberField/Units/DirichletTheorem.lean | 100 | 106 | theorem mult_log_place_eq_zero {x : (π K)Λ£} {w : InfinitePlace K} :
mult w * Real.log (w x) = 0 β w x = 1 := by |
rw [mul_eq_zero, or_iff_right, Real.log_eq_zero, or_iff_right, or_iff_left]
Β· linarith [(apply_nonneg _ _ : 0 β€ w x)]
Β· simp only [ne_eq, map_eq_zero, coe_ne_zero x, not_false_eq_true]
Β· refine (ne_of_gt ?_)
rw [mult]; split_ifs <;> norm_num
| [
" (fun x w => β(βw).mult * (βw ((algebraMap (π K) K) β(Additive.toMul x))).log) 0 = 0",
" (fun w => 0) = 0",
" { toFun := fun x w => β(βw).mult * (βw ((algebraMap (π K) K) β(Additive.toMul x))).log, map_zero' := β― }.toFun\n (xβΒΉ + xβ) =\n { toFun := fun x w => β(βw).mult * (βw ((algebraMap (π K) K) β... | [
" (fun x w => β(βw).mult * (βw ((algebraMap (π K) K) β(Additive.toMul x))).log) 0 = 0",
" (fun w => 0) = 0",
" { toFun := fun x w => β(βw).mult * (βw ((algebraMap (π K) K) β(Additive.toMul x))).log, map_zero' := β― }.toFun\n (xβΒΉ + xβ) =\n { toFun := fun x w => β(βw).mult * (βw ((algebraMap (π K) K) β... |
import Mathlib.Topology.Connected.Basic
open Set Function
universe u v
variable {Ξ± : Type u} {Ξ² : Type v} {ΞΉ : Type*} {Ο : ΞΉ β Type*} [TopologicalSpace Ξ±]
{s t u v : Set Ξ±}
section TotallyDisconnected
def IsTotallyDisconnected (s : Set Ξ±) : Prop :=
β t, t β s β IsPreconnected t β t.Subsingleton
#align is_t... | Mathlib/Topology/Connected/TotallyDisconnected.lean | 123 | 128 | theorem totallyDisconnectedSpace_iff_connectedComponent_singleton :
TotallyDisconnectedSpace Ξ± β β x : Ξ±, connectedComponent x = {x} := by |
rw [totallyDisconnectedSpace_iff_connectedComponent_subsingleton]
refine forall_congr' fun x => ?_
rw [subsingleton_iff_singleton]
exact mem_connectedComponent
| [
" TotallyDisconnectedSpace (Ξ± β Ξ²)",
" s.Subsingleton",
" (Sum.inl '' t).Subsingleton",
" (Sum.inr '' t).Subsingleton",
" TotallyDisconnectedSpace ((i : ΞΉ) Γ Ο i)",
" β
.Subsingleton",
" (Sigma.mk a '' t).Subsingleton",
" IsTotallyDisconnected univ",
" S.Subsingleton",
" β β¦x : Xβ¦, x β S β β β¦y : X... | [
" TotallyDisconnectedSpace (Ξ± β Ξ²)",
" s.Subsingleton",
" (Sum.inl '' t).Subsingleton",
" (Sum.inr '' t).Subsingleton",
" TotallyDisconnectedSpace ((i : ΞΉ) Γ Ο i)",
" β
.Subsingleton",
" (Sigma.mk a '' t).Subsingleton",
" IsTotallyDisconnected univ",
" S.Subsingleton",
" β β¦x : Xβ¦, x β S β β β¦y : X... |
import Mathlib.Combinatorics.SetFamily.Shadow
#align_import combinatorics.set_family.compression.uv from "leanprover-community/mathlib"@"6f8ab7de1c4b78a68ab8cf7dd83d549eb78a68a1"
open Finset
variable {Ξ± : Type*}
theorem sup_sdiff_injOn [GeneralizedBooleanAlgebra Ξ±] (u v : Ξ±) :
{ x | Disjoint u x β§ v β€ x }.... | Mathlib/Combinatorics/SetFamily/Compression/UV.lean | 156 | 158 | theorem mem_compression :
a β π u v s β a β s β§ compress u v a β s β¨ a β s β§ β b β s, compress u v b = a := by |
simp_rw [compression, mem_union, mem_filter, mem_image, and_comm]
| [
" Set.InjOn (fun x => (x β u) \\ v) {x | Disjoint u x β§ v β€ x}",
" a = b",
" ((a β u) \\ v) \\ u β v = ((b β u) \\ v) \\ u β v",
" compress u v ((a β v) \\ u) = a",
" compress u u a = a",
" (if Disjoint u a β§ u β€ a then (a β u) \\ u else a) = a",
" (a β u) \\ u = a",
" a = a",
" compress (a \\ b) (b... | [
" Set.InjOn (fun x => (x β u) \\ v) {x | Disjoint u x β§ v β€ x}",
" a = b",
" ((a β u) \\ v) \\ u β v = ((b β u) \\ v) \\ u β v",
" compress u v ((a β v) \\ u) = a",
" compress u u a = a",
" (if Disjoint u a β§ u β€ a then (a β u) \\ u else a) = a",
" (a β u) \\ u = a",
" a = a",
" compress (a \\ b) (b... |
import Mathlib.Topology.Constructions
#align_import topology.continuous_on from "leanprover-community/mathlib"@"d4f691b9e5f94cfc64639973f3544c95f8d5d494"
open Set Filter Function Topology Filter
variable {Ξ± : Type*} {Ξ² : Type*} {Ξ³ : Type*} {Ξ΄ : Type*}
variable [TopologicalSpace Ξ±]
@[simp]
theorem nhds_bind_nhdsW... | Mathlib/Topology/ContinuousOn.lean | 104 | 107 | theorem diff_mem_nhdsWithin_diff {x : Ξ±} {s t : Set Ξ±} (hs : s β π[t] x) (t' : Set Ξ±) :
s \ t' β π[t \ t'] x := by |
rw [nhdsWithin, diff_eq, diff_eq, β inf_principal, β inf_assoc]
exact inter_mem_inf hs (mem_principal_self _)
| [
" (βαΆ (x : Ξ±) in π z, x β s β§ p x) β βαΆ (x : Ξ±) in π z, p x β§ x β s",
" z β closure (s \\ {z}) β βαΆ (x : Ξ±) in π[β ] z, x β s",
" (βαΆ (y : Ξ±) in π[s] a, βαΆ (x : Ξ±) in π[s] y, p x) β βαΆ (x : Ξ±) in π[s] a, p x",
" βαΆ (x : Ξ±) in π[s] a, p x",
" βαΆ (x : Ξ±) in π a, x β s β p x",
" π[univ] a = π a",
... | [
" (βαΆ (x : Ξ±) in π z, x β s β§ p x) β βαΆ (x : Ξ±) in π z, p x β§ x β s",
" z β closure (s \\ {z}) β βαΆ (x : Ξ±) in π[β ] z, x β s",
" (βαΆ (y : Ξ±) in π[s] a, βαΆ (x : Ξ±) in π[s] y, p x) β βαΆ (x : Ξ±) in π[s] a, p x",
" βαΆ (x : Ξ±) in π[s] a, p x",
" βαΆ (x : Ξ±) in π a, x β s β p x",
" π[univ] a = π a",
... |
import Mathlib.Data.Real.Irrational
import Mathlib.Data.Nat.Fib.Basic
import Mathlib.Data.Fin.VecNotation
import Mathlib.Algebra.LinearRecurrence
import Mathlib.Tactic.NormNum.NatFib
import Mathlib.Tactic.NormNum.Prime
#align_import data.real.golden_ratio from "leanprover-community/mathlib"@"2196ab363eb097c008d449712... | Mathlib/Data/Real/GoldenRatio.lean | 129 | 131 | theorem neg_one_lt_goldConj : -1 < Ο := by |
rw [neg_lt, β inv_gold]
exact inv_lt_one one_lt_gold
| [
" Οβ»ΒΉ = -Ο",
" 0 < 1",
" 0 < 5",
" 2 * 2 = 5 - 1",
" Οβ»ΒΉ = -Ο",
" -Ο = Οβ»ΒΉ",
" Ο * Ο = -1",
" (1 + β5) * (1 - β5) = -(2 * 2)",
" 1 ^ 2 - β5 ^ 2 = -(2 * 2)",
" Ο * Ο = -1",
" Ο + Ο = 1",
" (1 + β5) / 2 + (1 - β5) / 2 = 1",
" 1 - Ο = Ο",
" 1 - Ο = Ο",
" Ο - Ο = β5",
" Ο ^ (n + 2) - Ο ^ (... | [
" Οβ»ΒΉ = -Ο",
" 0 < 1",
" 0 < 5",
" 2 * 2 = 5 - 1",
" Οβ»ΒΉ = -Ο",
" -Ο = Οβ»ΒΉ",
" Ο * Ο = -1",
" (1 + β5) * (1 - β5) = -(2 * 2)",
" 1 ^ 2 - β5 ^ 2 = -(2 * 2)",
" Ο * Ο = -1",
" Ο + Ο = 1",
" (1 + β5) / 2 + (1 - β5) / 2 = 1",
" 1 - Ο = Ο",
" 1 - Ο = Ο",
" Ο - Ο = β5",
" Ο ^ (n + 2) - Ο ^ (... |
import Mathlib.Analysis.SpecialFunctions.Pow.Real
#align_import analysis.special_functions.pow.nnreal from "leanprover-community/mathlib"@"4fa54b337f7d52805480306db1b1439c741848c8"
noncomputable section
open scoped Classical
open Real NNReal ENNReal ComplexConjugate
open Finset Function Set
namespace NNReal
var... | Mathlib/Analysis/SpecialFunctions/Pow/NNReal.lean | 108 | 109 | theorem rpow_inv_rpow_self {y : β} (hy : y β 0) (x : ββ₯0) : (x ^ y) ^ (1 / y) = x := by |
field_simp [β rpow_mul]
| [
" x ^ y = 0 β x = 0 β§ y β 0",
" βx ^ y = β0 β βx = 0 β§ y β 0",
" x ^ w = x ^ y * x ^ z",
" y + z β 0",
" x ^ (-1) = xβ»ΒΉ",
" (x ^ y) ^ (1 / y) = x"
] | [
" x ^ y = 0 β x = 0 β§ y β 0",
" βx ^ y = β0 β βx = 0 β§ y β 0",
" x ^ w = x ^ y * x ^ z",
" y + z β 0",
" x ^ (-1) = xβ»ΒΉ",
" (x ^ y) ^ (1 / y) = x"
] |
import Mathlib.Data.Finset.Lattice
#align_import combinatorics.set_family.compression.down from "leanprover-community/mathlib"@"9003f28797c0664a49e4179487267c494477d853"
variable {Ξ± : Type*} [DecidableEq Ξ±] {π β¬ : Finset (Finset Ξ±)} {s : Finset Ξ±} {a : Ξ±}
open Finset
-- The namespace is here to distinguish fro... | Mathlib/Combinatorics/SetFamily/Compression/Down.lean | 258 | 261 | theorem erase_mem_compression_of_mem_compression : s β π a π β s.erase a β π a π := by |
simp_rw [mem_compression, erase_idem]
refine Or.imp (fun h => β¨h.2, h.2β©) fun h => ?_
rwa [erase_eq_of_not_mem (insert_ne_self.1 <| ne_of_mem_of_not_mem h.2 h.1)]
| [
" False",
" s β π a π β s β π β§ s.erase a β π β¨ s β π β§ insert a s β π",
" s β π β§ s.erase a β π β¨ (β a_1 β π, a_1.erase a = s) β§ s β π β s β π β§ s.erase a β π β¨ insert a s β π β§ s β π",
" (β a_1 β π, a_1.erase a = s) β insert a s β π",
" insert a (t.erase a) β π",
" s.erase a β π a π",... | [
" False",
" s β π a π β s β π β§ s.erase a β π β¨ s β π β§ insert a s β π",
" s β π β§ s.erase a β π β¨ (β a_1 β π, a_1.erase a = s) β§ s β π β s β π β§ s.erase a β π β¨ insert a s β π β§ s β π",
" (β a_1 β π, a_1.erase a = s) β insert a s β π",
" insert a (t.erase a) β π",
" s.erase a β π a π",... |
import Mathlib.Algebra.Algebra.Prod
import Mathlib.LinearAlgebra.Basic
import Mathlib.LinearAlgebra.Span
import Mathlib.Order.PartialSups
#align_import linear_algebra.prod from "leanprover-community/mathlib"@"cd391184c85986113f8c00844cfe6dda1d34be3d"
universe u v w x y z u' v' w' y'
variable {R : Type u} {K : Ty... | Mathlib/LinearAlgebra/Prod.lean | 148 | 155 | theorem range_inl : range (inl R M Mβ) = ker (snd R M Mβ) := by |
ext x
simp only [mem_ker, mem_range]
constructor
Β· rintro β¨y, rflβ©
rfl
Β· intro h
exact β¨x.fst, Prod.ext rfl h.symmβ©
| [
" Pi.prod (βf) (βg) (x + y) = Pi.prod (βf) (βg) x + Pi.prod (βf) (βg) y",
" { toFun := Pi.prod βf βg, map_add' := β― }.toFun (c β’ x) =\n (RingHom.id R) c β’ { toFun := Pi.prod βf βg, map_add' := β― }.toFun x",
" (fun f => (fst R Mβ Mβ ββ f, snd R Mβ Mβ ββ f))\n ({ toFun := fun f => f.1.prod f.2, map_add' :... | [
" Pi.prod (βf) (βg) (x + y) = Pi.prod (βf) (βg) x + Pi.prod (βf) (βg) y",
" { toFun := Pi.prod βf βg, map_add' := β― }.toFun (c β’ x) =\n (RingHom.id R) c β’ { toFun := Pi.prod βf βg, map_add' := β― }.toFun x",
" (fun f => (fst R Mβ Mβ ββ f, snd R Mβ Mβ ββ f))\n ({ toFun := fun f => f.1.prod f.2, map_add' :... |
import Mathlib.Algebra.Bounds
import Mathlib.Algebra.Order.Field.Basic -- Porting note: `LinearOrderedField`, etc
import Mathlib.Data.Set.Pointwise.SMul
#align_import algebra.order.pointwise from "leanprover-community/mathlib"@"9003f28797c0664a49e4179487267c494477d853"
open Function Set
open Pointwise
variable ... | Mathlib/Algebra/Order/Pointwise.lean | 167 | 169 | theorem csInf_div (hsβ : s.Nonempty) (hsβ : BddBelow s) (htβ : t.Nonempty) (htβ : BddAbove t) :
sInf (s / t) = sInf s / sSup t := by |
rw [div_eq_mul_inv, csInf_mul hsβ hsβ htβ.inv htβ.inv, csInf_inv htβ htβ, div_eq_mul_inv]
| [
" sSup sβ»ΒΉ = (sInf s)β»ΒΉ",
" sSup (Inv.inv '' s) = (sInf s)β»ΒΉ",
" sInf sβ»ΒΉ = (sSup s)β»ΒΉ",
" sInf (Inv.inv '' s) = (sSup s)β»ΒΉ",
" sSup (s / t) = sSup s / sInf t",
" sInf (s / t) = sInf s / sSup t"
] | [
" sSup sβ»ΒΉ = (sInf s)β»ΒΉ",
" sSup (Inv.inv '' s) = (sInf s)β»ΒΉ",
" sInf sβ»ΒΉ = (sSup s)β»ΒΉ",
" sInf (Inv.inv '' s) = (sSup s)β»ΒΉ",
" sSup (s / t) = sSup s / sInf t",
" sInf (s / t) = sInf s / sSup t"
] |
import Mathlib.Analysis.SpecialFunctions.Pow.Asymptotics
import Mathlib.NumberTheory.Liouville.Basic
import Mathlib.Topology.Instances.Irrational
#align_import number_theory.liouville.liouville_with from "leanprover-community/mathlib"@"0b9eaaa7686280fad8cce467f5c3c57ee6ce77f8"
open Filter Metric Real Set
open sc... | Mathlib/NumberTheory/Liouville/LiouvilleWith.lean | 99 | 110 | theorem frequently_lt_rpow_neg (h : LiouvilleWith p x) (hlt : q < p) :
βαΆ n : β in atTop, β m : β€, x β m / n β§ |x - m / n| < n ^ (-q) := by |
rcases h.exists_pos with β¨C, _hCβ, hCβ©
have : βαΆ n : β in atTop, C < n ^ (p - q) := by
simpa only [(Β· β Β·), neg_sub, one_div] using
((tendsto_rpow_atTop (sub_pos.2 hlt)).comp tendsto_natCast_atTop_atTop).eventually
(eventually_gt_atTop C)
refine (this.and_frequently hC).mono ?_
rintro n β¨hnC,... | [
" LiouvilleWith 1 x",
" βαΆ (n : β) in atTop, β m, x β βm / βn β§ |x - βm / βn| < 2 / βn ^ 1",
" β m, x β βm / βn β§ |x - βm / βn| < 2 / βn ^ 1",
" 0 < βn",
" x < β(βx * βnβ + 1) / βn",
" x * βn < ββx * βnβ + 1",
" |x - β(βx * βnβ + 1) / βn| < 2 / βn ^ 1",
" β(βx * βnβ + 1) / βn < (x * βn + 2) / βn",
"... | [
" LiouvilleWith 1 x",
" βαΆ (n : β) in atTop, β m, x β βm / βn β§ |x - βm / βn| < 2 / βn ^ 1",
" β m, x β βm / βn β§ |x - βm / βn| < 2 / βn ^ 1",
" 0 < βn",
" x < β(βx * βnβ + 1) / βn",
" x * βn < ββx * βnβ + 1",
" |x - β(βx * βnβ + 1) / βn| < 2 / βn ^ 1",
" β(βx * βnβ + 1) / βn < (x * βn + 2) / βn",
"... |
import Mathlib.Data.Sigma.Lex
import Mathlib.Order.BoundedOrder
import Mathlib.Mathport.Notation
import Mathlib.Data.Sigma.Basic
#align_import data.sigma.order from "leanprover-community/mathlib"@"1fc36cc9c8264e6e81253f88be7fb2cb6c92d76a"
namespace Sigma
variable {ΞΉ : Type*} {Ξ± : ΞΉ β Type*}
-- Porting note: I... | Mathlib/Data/Sigma/Order.lean | 89 | 96 | theorem lt_def [β i, LT (Ξ± i)] {a b : Ξ£i, Ξ± i} : a < b β β h : a.1 = b.1, h.rec a.2 < b.2 := by |
constructor
Β· rintro β¨i, a, b, hβ©
exact β¨rfl, hβ©
Β· obtain β¨i, aβ© := a
obtain β¨j, bβ© := b
rintro β¨rfl : i = j, hβ©
exact lt.fiber _ _ _ h
| [
" a β€ b β β h, h βΈ a.snd β€ b.snd",
" a β€ b β β h, h βΈ a.snd β€ b.snd",
" β h, h βΈ β¨i, aβ©.snd β€ β¨i, bβ©.snd",
" (β h, h βΈ a.snd β€ b.snd) β a β€ b",
" (β h, h βΈ β¨i, aβ©.snd β€ b.snd) β β¨i, aβ© β€ b",
" (β h, h βΈ β¨i, aβ©.snd β€ β¨j, bβ©.snd) β β¨i, aβ© β€ β¨j, bβ©",
" β¨i, aβ© β€ β¨i, bβ©",
" a < b β β h, h βΈ a.snd < b.snd",... | [
" a β€ b β β h, h βΈ a.snd β€ b.snd",
" a β€ b β β h, h βΈ a.snd β€ b.snd",
" β h, h βΈ β¨i, aβ©.snd β€ β¨i, bβ©.snd",
" (β h, h βΈ a.snd β€ b.snd) β a β€ b",
" (β h, h βΈ β¨i, aβ©.snd β€ b.snd) β β¨i, aβ© β€ b",
" (β h, h βΈ β¨i, aβ©.snd β€ β¨j, bβ©.snd) β β¨i, aβ© β€ β¨j, bβ©",
" β¨i, aβ© β€ β¨i, bβ©",
" a < b β β h, h βΈ a.snd < b.snd"
... |
import Mathlib.Data.List.Cycle
import Mathlib.GroupTheory.Perm.Cycle.Type
import Mathlib.GroupTheory.Perm.List
#align_import group_theory.perm.cycle.concrete from "leanprover-community/mathlib"@"00638177efd1b2534fc5269363ebf42a7871df9a"
open Equiv Equiv.Perm List
variable {Ξ± : Type*}
namespace List
variable [D... | Mathlib/GroupTheory/Perm/Cycle/Concrete.lean | 58 | 70 | theorem formPerm_disjoint_iff (hl : Nodup l) (hl' : Nodup l') (hn : 2 β€ l.length)
(hn' : 2 β€ l'.length) : Perm.Disjoint (formPerm l) (formPerm l') β l.Disjoint l' := by |
rw [disjoint_iff_eq_or_eq, List.Disjoint]
constructor
Β· rintro h x hx hx'
specialize h x
rw [formPerm_apply_mem_eq_self_iff _ hl _ hx, formPerm_apply_mem_eq_self_iff _ hl' _ hx'] at h
omega
Β· intro h x
by_cases hx : x β l
on_goal 1 => by_cases hx' : x β l'
Β· exact (h hx hx').elim
al... | [
" l.formPerm.Disjoint l'.formPerm β l.Disjoint l'",
" (β (x : Ξ±), l.formPerm x = x β¨ l'.formPerm x = x) β β β¦a : Ξ±β¦, a β l β a β l' β False",
" (β (x : Ξ±), l.formPerm x = x β¨ l'.formPerm x = x) β β β¦a : Ξ±β¦, a β l β a β l' β False",
" False",
" (β β¦a : Ξ±β¦, a β l β a β l' β False) β β (x : Ξ±), l.formPerm x = ... | [
" l.formPerm.Disjoint l'.formPerm β l.Disjoint l'"
] |
import Mathlib.Algebra.IsPrimePow
import Mathlib.NumberTheory.ArithmeticFunction
import Mathlib.Analysis.SpecialFunctions.Log.Basic
#align_import number_theory.von_mangoldt from "leanprover-community/mathlib"@"c946d6097a6925ad16d7ec55677bbc977f9846de"
namespace ArithmeticFunction
open Finset Nat
open scoped Arit... | Mathlib/NumberTheory/VonMangoldt.lean | 79 | 79 | theorem vonMangoldt_apply_one : Ξ 1 = 0 := by | simp [vonMangoldt_apply]
| [
" (fun n => (βn).log) 0 = 0",
" Ξ 1 = 0"
] | [
" (fun n => (βn).log) 0 = 0",
" Ξ 1 = 0"
] |
import Mathlib.Algebra.CharP.Invertible
import Mathlib.Algebra.Order.Interval.Set.Group
import Mathlib.Analysis.Convex.Segment
import Mathlib.LinearAlgebra.AffineSpace.FiniteDimensional
import Mathlib.Tactic.FieldSimp
#align_import analysis.convex.between from "leanprover-community/mathlib"@"571e13cacbed7bf042fd3058c... | Mathlib/Analysis/Convex/Between.lean | 133 | 135 | theorem mem_vsub_const_affineSegment {x y z : P} (p : P) :
z -α΅₯ p β affineSegment R (x -α΅₯ p) (y -α΅₯ p) β z β affineSegment R x y := by |
rw [β affineSegment_vsub_const_image, (vsub_left_injective p).mem_set_image]
| [
" affineSegment R x y = segment R x y",
" affineSegment R x y = affineSegment R y x",
" z β affineSegment R x y β z β affineSegment R y x",
" z β affineSegment R x y β z β affineSegment R y x",
" z β affineSegment R y x",
" 1 - t β Set.Icc 0 1",
" (lineMap y x) (1 - t) = z",
" z β affineSegment R y x ... | [
" affineSegment R x y = segment R x y",
" affineSegment R x y = affineSegment R y x",
" z β affineSegment R x y β z β affineSegment R y x",
" z β affineSegment R x y β z β affineSegment R y x",
" z β affineSegment R y x",
" 1 - t β Set.Icc 0 1",
" (lineMap y x) (1 - t) = z",
" z β affineSegment R y x ... |
import Mathlib.Algebra.BigOperators.Intervals
import Mathlib.Algebra.GeomSum
import Mathlib.Algebra.Order.Ring.Abs
import Mathlib.Data.Nat.Bitwise
import Mathlib.Data.Nat.Log
import Mathlib.Data.Nat.Prime
import Mathlib.Data.Nat.Digits
import Mathlib.RingTheory.Multiplicity
#align_import data.nat.multiplicity from "l... | Mathlib/Data/Nat/Multiplicity.lean | 61 | 77 | theorem multiplicity_eq_card_pow_dvd {m n b : β} (hm : m β 1) (hn : 0 < n) (hb : log m n < b) :
multiplicity m n = β((Finset.Ico 1 b).filter fun i => m ^ i β£ n).card :=
calc
multiplicity m n = β(Ico 1 <| (multiplicity m n).get (finite_nat_iff.2 β¨hm, hnβ©) + 1).card := by |
simp
_ = β((Finset.Ico 1 b).filter fun i => m ^ i β£ n).card :=
congr_arg _ <|
congr_arg card <|
Finset.ext fun i => by
rw [mem_filter, mem_Ico, mem_Ico, Nat.lt_succ_iff, β @PartENat.coe_le_coe i,
PartENat.natCast_get, β pow_dvd_iff_le_multiplicity, and_right_... | [
" multiplicity m n = β(Ico 1 ((multiplicity m n).get β― + 1)).card",
" i β Ico 1 ((multiplicity m n).get β― + 1) β i β filter (fun i => m ^ i β£ n) (Ico 1 b)",
" 1 β€ i β§ m ^ i β£ n β (1 β€ i β§ m ^ i β£ n) β§ i < b",
" i β€ m.log n",
" i β€ log 0 n",
" i β 0",
" i β€ (m + 1).log n"
] | [
" multiplicity m n = β(Ico 1 ((multiplicity m n).get β― + 1)).card"
] |
import Mathlib.Analysis.Complex.AbsMax
import Mathlib.Analysis.Complex.RemovableSingularity
#align_import analysis.complex.schwarz from "leanprover-community/mathlib"@"3f655f5297b030a87d641ad4e825af8d9679eb0b"
open Metric Set Function Filter TopologicalSpace
open scoped Topology
namespace Complex
section Space... | Mathlib/Analysis/Complex/Schwarz.lean | 65 | 88 | theorem schwarz_aux {f : β β β} (hd : DifferentiableOn β f (ball c Rβ))
(h_maps : MapsTo f (ball c Rβ) (ball (f c) Rβ)) (hz : z β ball c Rβ) :
βdslope f c zβ β€ Rβ / Rβ := by |
have hRβ : 0 < Rβ := nonempty_ball.1 β¨z, hzβ©
suffices βαΆ r in π[<] Rβ, βdslope f c zβ β€ Rβ / r by
refine ge_of_tendsto ?_ this
exact (tendsto_const_nhds.div tendsto_id hRβ.ne').mono_left nhdsWithin_le_nhds
rw [mem_ball] at hz
filter_upwards [Ioo_mem_nhdsWithin_Iio β¨hz, le_rflβ©] with r hr
have hrβ : ... | [
" βdslope f c zβ β€ Rβ / Rβ",
" Tendsto (fun c => Rβ / c) (π[<] Rβ) (π (Rβ / Rβ))",
" βαΆ (r : β) in π[<] Rβ, βdslope f c zβ β€ Rβ / r",
" βdslope f c zβ β€ Rβ / r",
" DiffContOnCl β (dslope f c) (ball c r)",
" DifferentiableOn β (dslope f c) (closure (ball c r))",
" DifferentiableOn β (dslope f c) (clos... | [
" βdslope f c zβ β€ Rβ / Rβ"
] |
import Mathlib.MeasureTheory.SetSemiring
open MeasurableSpace Set
namespace MeasureTheory
variable {Ξ± : Type*} {π : Set (Set Ξ±)} {s t : Set Ξ±}
structure IsSetAlgebra (π : Set (Set Ξ±)) : Prop where
empty_mem : β
β π
compl_mem : β β¦sβ¦, s β π β sαΆ β π
union_mem : β β¦s tβ¦, s β π β t β π β s βͺ t β π
... | Mathlib/MeasureTheory/SetAlgebra.lean | 122 | 134 | theorem generateFrom_generateSetAlgebra_eq :
generateFrom (generateSetAlgebra π) = generateFrom π := by |
refine le_antisymm (fun s ms β¦ ?_) (generateFrom_mono self_subset_generateSetAlgebra)
refine @generateFrom_induction _ _ (generateSetAlgebra π) (fun t ht β¦ ?_)
(@MeasurableSet.empty _ (generateFrom π))
(fun t β¦ MeasurableSet.compl)
(fun f hf β¦ MeasurableSet.iUnion hf)
s ms
induction ht with
|... | [
" generateFrom (generateSetAlgebra π) = generateFrom π",
" MeasurableSet s",
" MeasurableSet t",
" MeasurableSet u",
" MeasurableSet β
",
" MeasurableSet uαΆ",
" MeasurableSet (u βͺ v)"
] | [
" generateFrom (generateSetAlgebra π) = generateFrom π"
] |
import Mathlib.Algebra.Polynomial.Expand
import Mathlib.Algebra.Polynomial.Laurent
import Mathlib.LinearAlgebra.Matrix.Charpoly.Basic
import Mathlib.LinearAlgebra.Matrix.Reindex
import Mathlib.RingTheory.Polynomial.Nilpotent
#align_import linear_algebra.matrix.charpoly.coeff from "leanprover-community/mathlib"@"9745b... | Mathlib/LinearAlgebra/Matrix/Charpoly/Coeff.lean | 260 | 276 | theorem matPolyEquiv_eq_X_pow_sub_C {K : Type*} (k : β) [Field K] (M : Matrix n n K) :
matPolyEquiv ((expand K k : K[X] β+* K[X]).mapMatrix (charmatrix (M ^ k))) =
X ^ k - C (M ^ k) := by |
-- Porting note: `i` and `j` are used later on, but were not mentioned in mathlib3
ext m i j
rw [coeff_sub, coeff_C, matPolyEquiv_coeff_apply, RingHom.mapMatrix_apply, Matrix.map_apply,
AlgHom.coe_toRingHom, DMatrix.sub_apply, coeff_X_pow]
by_cases hij : i = j
Β· rw [hij, charmatrix_apply_eq, AlgHom.map_s... | [
" matPolyEquiv ((β(expand K k)).mapMatrix (M ^ k).charmatrix) = X ^ k - C (M ^ k)",
" (matPolyEquiv ((β(expand K k)).mapMatrix (M ^ k).charmatrix)).coeff m i j = (X ^ k - C (M ^ k)).coeff m i j",
" ((expand K k) ((M ^ k).charmatrix i j)).coeff m = (if m = k then 1 else 0) i j - (if m = 0 then M ^ k else 0) i j"... | [
" matPolyEquiv ((β(expand K k)).mapMatrix (M ^ k).charmatrix) = X ^ k - C (M ^ k)"
] |
import Mathlib.Topology.Defs.Induced
import Mathlib.Topology.Basic
#align_import topology.order from "leanprover-community/mathlib"@"bcfa726826abd57587355b4b5b7e78ad6527b7e4"
open Function Set Filter Topology
universe u v w
namespace TopologicalSpace
variable {Ξ± : Type u}
inductive GenerateOpen (g : Set (Set ... | Mathlib/Topology/Order.lean | 129 | 138 | theorem nhds_mkOfNhds_single [DecidableEq Ξ±] {aβ : Ξ±} {l : Filter Ξ±} (h : pure aβ β€ l) (b : Ξ±) :
@nhds Ξ± (TopologicalSpace.mkOfNhds (update pure aβ l)) b =
(update pure aβ l : Ξ± β Filter Ξ±) b := by |
refine nhds_mkOfNhds _ _ (le_update_iff.mpr β¨h, fun _ _ => le_rflβ©) fun a s hs => ?_
rcases eq_or_ne a aβ with (rfl | ha)
Β· filter_upwards [hs] with b hb
rcases eq_or_ne b a with (rfl | hb)
Β· exact hs
Β· rwa [update_noteq hb]
Β· simpa only [update_noteq ha, mem_pure, eventually_pure] using hs
| [
" π a = β¨
s β {s | a β s β§ s β g}, π s",
" β¨
s β {s | a β s β§ IsOpen s}, π s = β¨
s β {s | a β s β§ s β g}, π s",
" β i β {s | a β s β§ IsOpen s}, β¨
s β {s | a β s β§ s β g}, π s β€ π i",
" β¨
s β {s | a β s β§ s β g}, π s β€ π s",
" β¨
s β {s | a β s β§ s β g}, π s β€ π sβ",
" β¨
s β {s | a β s β§ s β g}, οΏ½... | [
" π a = β¨
s β {s | a β s β§ s β g}, π s",
" β¨
s β {s | a β s β§ IsOpen s}, π s = β¨
s β {s | a β s β§ s β g}, π s",
" β i β {s | a β s β§ IsOpen s}, β¨
s β {s | a β s β§ s β g}, π s β€ π i",
" β¨
s β {s | a β s β§ s β g}, π s β€ π s",
" β¨
s β {s | a β s β§ s β g}, π s β€ π sβ",
" β¨
s β {s | a β s β§ s β g}, οΏ½... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.