name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M |
|---|---|---|
LinearEquiv.mk.congr_simp | Mathlib.LinearAlgebra.Basis.Defs | ∀ {R : Type u_14} {S : Type u_15} [inst : Semiring R] [inst_1 : Semiring S] {σ : R →+* S} {σ' : S →+* R}
[inst_2 : RingHomInvPair σ σ'] [inst_3 : RingHomInvPair σ' σ] {M : Type u_16} {M₂ : Type u_17}
[inst_4 : AddCommMonoid M] [inst_5 : AddCommMonoid M₂] [inst_6 : Module R M] [inst_7 : Module S M₂]
(toLinearMap toLinearMap_1 : M →ₛₗ[σ] M₂) (e_toLinearMap : toLinearMap = toLinearMap_1) (invFun invFun_1 : M₂ → M)
(e_invFun : invFun = invFun_1) (left_inv : Function.LeftInverse invFun toLinearMap.toFun)
(right_inv : Function.RightInverse invFun toLinearMap.toFun),
{ toLinearMap := toLinearMap, invFun := invFun, left_inv := left_inv, right_inv := right_inv } =
{ toLinearMap := toLinearMap_1, invFun := invFun_1, left_inv := ⋯, right_inv := ⋯ } |
SchwartzMap.fourier_inversion_inv | Mathlib.Analysis.Distribution.SchwartzSpace.Fourier | ∀ {E : Type u_5} {F : Type u_6} {inst : FourierTransform F E} {inst_1 : FourierTransformInv E F}
[self : FourierInvPair E F] (f : E), FourierTransform.fourier (FourierTransformInv.fourierInv f) = f |
SNum.instNeg | Mathlib.Data.Num.Bitwise | Neg SNum |
AddUnits.addAction'._proof_3 | Mathlib.Algebra.Group.Action.Units | ∀ {G : Type u_2} {M : Type u_1} [inst : AddGroup G] [inst_1 : AddMonoid M] [inst_2 : AddAction G M]
[inst_3 : VAddCommClass G M M] [inst_4 : VAddAssocClass G M M] (x x_1 : G) (x_2 : AddUnits M),
(x + x_1) +ᵥ x_2 = x +ᵥ x_1 +ᵥ x_2 |
NNRat.divNat._proof_1 | Mathlib.Data.NNRat.Defs | ∀ (n d : ℕ), 0 ≤ Rat.divInt ↑n ↑d |
Filter.tendsto_sup | Mathlib.Order.Filter.Tendsto | ∀ {α : Type u_1} {β : Type u_2} {f : α → β} {x₁ x₂ : Filter α} {y : Filter β},
Filter.Tendsto f (x₁ ⊔ x₂) y ↔ Filter.Tendsto f x₁ y ∧ Filter.Tendsto f x₂ y |
jacobiSym.mod_right | Mathlib.NumberTheory.LegendreSymbol.JacobiSymbol | ∀ (a : ℤ) {b : ℕ}, Odd b → jacobiSym a b = jacobiSym a (b % (4 * a.natAbs)) |
Finset.single_le_sum_of_canonicallyOrdered | Mathlib.Algebra.Order.BigOperators.Group.Finset | ∀ {ι : Type u_1} {M : Type u_4} [inst : AddCommMonoid M] [inst_1 : Preorder M] [CanonicallyOrderedAdd M] {f : ι → M}
{s : Finset ι} {i : ι}, i ∈ s → f i ≤ ∑ j ∈ s, f j |
CategoryTheory.FreeBicategory.liftHom.match_1 | Mathlib.CategoryTheory.Bicategory.Free | {B : Type u_1} →
[inst : Quiver B] →
(motive : (x x_1 : CategoryTheory.FreeBicategory B) → (x ⟶ x_1) → Sort u_3) →
(x x_1 : CategoryTheory.FreeBicategory B) →
(x_2 : x ⟶ x_1) →
((x x_3 : B) → (f : x ⟶ x_3) → motive x x_3 (CategoryTheory.FreeBicategory.Hom.of f)) →
((a : B) → motive a a (CategoryTheory.FreeBicategory.Hom.id a)) →
((x x_3 b : B) →
(f : CategoryTheory.FreeBicategory.Hom x b) →
(g : CategoryTheory.FreeBicategory.Hom b x_3) → motive x x_3 (f.comp g)) →
motive x x_1 x_2 |
summable_of_sum_range_le | Mathlib.Topology.Algebra.InfiniteSum.Real | ∀ {f : ℕ → ℝ} {c : ℝ}, (∀ (n : ℕ), 0 ≤ f n) → (∀ (n : ℕ), ∑ i ∈ Finset.range n, f i ≤ c) → Summable f |
Mathlib.StacksTag.Tag.noConfusion | Mathlib.Tactic.StacksAttribute | {P : Sort u} → {t t' : Mathlib.StacksTag.Tag} → t = t' → Mathlib.StacksTag.Tag.noConfusionType P t t' |
Bimod.TensorBimod.actRight._proof_4 | Mathlib.CategoryTheory.Monoidal.Bimod | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.MonoidalCategory C]
{R S T : CategoryTheory.Mon C} (P : Bimod R S) (Q : Bimod S T)
[∀ (X : C),
CategoryTheory.Limits.PreservesColimitsOfSize.{0, 0, u_1, u_1, u_2, u_2}
(CategoryTheory.MonoidalCategory.tensorRight X)],
CategoryTheory.Limits.PreservesColimit
(CategoryTheory.Limits.parallelPair (CategoryTheory.MonoidalCategoryStruct.whiskerRight P.actRight Q.X)
(CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategoryStruct.associator P.X S.X Q.X).hom
(CategoryTheory.MonoidalCategoryStruct.whiskerLeft P.X Q.actLeft)))
(CategoryTheory.MonoidalCategory.tensorRight T.X) |
CategoryTheory.ShortComplex.HomologyData.ofEpiMonoFactorisation.f'_eq | Mathlib.Algebra.Homology.ShortComplex.Abelian | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Abelian C]
(S : CategoryTheory.ShortComplex C) {kf : CategoryTheory.Limits.KernelFork S.g}
(hkf : CategoryTheory.Limits.IsLimit kf),
hkf.lift (CategoryTheory.Limits.KernelFork.ofι S.f ⋯) =
CategoryTheory.CategoryStruct.comp S.toCycles (S.isoCyclesOfIsLimit hkf).inv |
Finset.expect | Mathlib.Algebra.BigOperators.Expect | {ι : Type u_1} → {M : Type u_3} → [inst : AddCommMonoid M] → [Module ℚ≥0 M] → Finset ι → (ι → M) → M |
_private.Mathlib.Topology.ContinuousOn.0.continuousOn_singleton._simp_1_2 | Mathlib.Topology.ContinuousOn | ∀ {α : Type u_1} {β : Type u_2} {f : α → β} {a : α} {l : Filter β}, Filter.Tendsto f (pure a) l = ∀ s ∈ l, f a ∈ s |
CategoryTheory.GradedObject.isInitialSingleObjApply._proof_1 | Mathlib.CategoryTheory.GradedObject.Single | ∀ {J : Type u_3} {C : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} C]
[inst_1 : CategoryTheory.Limits.HasInitial C] [inst_2 : DecidableEq J] (j : J) (X : C) (i : J),
i ≠ j → CategoryTheory.Limits.IsInitial (if i = j then X else ⊥_ C) = CategoryTheory.Limits.IsInitial (⊥_ C) |
iInf_singleton | Mathlib.Order.CompleteLattice.Basic | ∀ {α : Type u_1} {β : Type u_2} [inst : CompleteLattice α] {f : β → α} {b : β}, ⨅ x ∈ {b}, f x = f b |
_private.Mathlib.AlgebraicGeometry.EllipticCurve.DivisionPolynomial.Basic.0.WeierstrassCurve.Φ_neg._simp_1_5 | Mathlib.AlgebraicGeometry.EllipticCurve.DivisionPolynomial.Basic | ∀ {α : Type u_2} [inst : SubtractionMonoid α] {a : α}, Even (-a) = Even a |
instFintypeWithTop | Mathlib.Data.Fintype.WithTopBot | {α : Type u_1} → [Fintype α] → Fintype (WithTop α) |
_private.Mathlib.CategoryTheory.Generator.Basic.0.CategoryTheory.ObjectProperty.IsCoseparating.isCodetecting._simp_1_2 | Mathlib.CategoryTheory.Generator.Basic | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] (P : CategoryTheory.ObjectProperty C),
P.IsCoseparating = P.op.IsSeparating |
Finite.card_eq_zero_of_surjective | Mathlib.Data.Finite.Card | ∀ {α : Type u_1} {β : Type u_2} {f : α → β}, Function.Surjective f → Nat.card β = 0 → Nat.card α = 0 |
Std.ExtDHashMap.Const.get?_filterMap | Std.Data.ExtDHashMap.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {β : Type v} {γ : Type w} {m : Std.ExtDHashMap α fun x => β}
[inst : EquivBEq α] [inst_1 : LawfulHashable α] {f : α → β → Option γ} {k : α},
Std.ExtDHashMap.Const.get? (Std.ExtDHashMap.filterMap f m) k =
(Std.ExtDHashMap.Const.get? m k).pbind fun x_2 h' => f (m.getKey k ⋯) x_2 |
Vector.toList_map | Init.Data.Vector.Lemmas | ∀ {α : Type u_1} {β : Type u_2} {n : ℕ} {f : α → β} {xs : Vector α n}, (Vector.map f xs).toList = List.map f xs.toList |
Option.min_eq_some_iff._simp_1 | Init.Data.Option.Lemmas | ∀ {α : Type u_1} [inst : Min α] {o o' : Option α} {a : α},
(o ⊓ o' = some a) = ∃ b c, o = some b ∧ o' = some c ∧ b ⊓ c = a |
fourierSubalgebra_coe | Mathlib.Analysis.Fourier.AddCircle | ∀ {T : ℝ}, Subalgebra.toSubmodule fourierSubalgebra.toSubalgebra = Submodule.span ℂ (Set.range fourier) |
AlgebraicGeometry.Spec.map_surjective | Mathlib.AlgebraicGeometry.GammaSpecAdjunction | ∀ {R S : CommRingCat}, Function.Surjective AlgebraicGeometry.Spec.map |
FreeMonoid.map._proof_2 | Mathlib.Algebra.FreeMonoid.Basic | ∀ {α : Type u_1} {β : Type u_2} (f : α → β) (x x_1 : FreeMonoid α),
List.map f (FreeMonoid.toList x ++ FreeMonoid.toList x_1) =
List.map f (FreeMonoid.toList x) ++ List.map f (FreeMonoid.toList x_1) |
Std.CloseableChannel.Error.alreadyClosed | Std.Sync.Channel | Std.CloseableChannel.Error |
_private.Mathlib.Analysis.Analytic.Within.0.hasFPowerSeriesWithinAt_iff_exists_hasFPowerSeriesAt._simp_1_10 | Mathlib.Analysis.Analytic.Within | ∀ {α : Type u} [inst : LinearOrder α] {a b c : α}, (a < min b c) = (a < b ∧ a < c) |
MeasureTheory.Lp.coe_posPart._simp_1 | Mathlib.MeasureTheory.Function.LpSpace.Basic | ∀ {α : Type u_1} {m : MeasurableSpace α} {p : ENNReal} {μ : MeasureTheory.Measure α} (f : ↥(MeasureTheory.Lp ℝ p μ)),
(↑f).posPart = ↑(MeasureTheory.Lp.posPart f) |
CategoryTheory.mono_iff_injective | Mathlib.CategoryTheory.Types.Basic | ∀ {X Y : Type u} (f : X ⟶ Y), CategoryTheory.Mono f ↔ Function.Injective f |
ENNReal.tendsto_nat_tsum | Mathlib.Topology.Algebra.InfiniteSum.ENNReal | ∀ (f : ℕ → ENNReal), Filter.Tendsto (fun n => ∑ i ∈ Finset.range n, f i) Filter.atTop (nhds (∑' (n : ℕ), f n)) |
Std.Do.Spec.seq' | Std.Do.Triple.SpecLemmas | ∀ {m : Type u → Type v} {ps : Std.Do.PostShape} {P : Std.Do.Assertion ps} [inst : Monad m]
[inst_1 : Std.Do.WPMonad m ps] {α β : Type u} {x : m (α → β)} {y : m α} {Q : Std.Do.PostCond β ps},
⦃P⦄ x ⦃(fun f => (Std.Do.wp y).apply (fun a => Q.1 (f a), Q.2), Q.2)⦄ → ⦃P⦄ (x <*> y) ⦃Q⦄ |
Std.DTreeMap.Internal.Impl.getKey_insertMany!_list_of_mem | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Std.DTreeMap.Internal.Impl α β} [Std.TransOrd α],
t.WF →
∀ {l : List ((a : α) × β a)} {k k' : α},
compare k k' = Ordering.eq →
List.Pairwise (fun a b => ¬compare a.fst b.fst = Ordering.eq) l →
k ∈ List.map Sigma.fst l →
∀ {h' : Std.DTreeMap.Internal.Impl.contains k' ↑(t.insertMany! l) = true},
(↑(t.insertMany! l)).getKey k' h' = k |
Lean.MetavarContext.getDelayedMVarAssignmentCore? | Lean.MetavarContext | Lean.MetavarContext → Lean.MVarId → Option Lean.DelayedMetavarAssignment |
Std.DTreeMap.mem_of_mem_insert | Std.Data.DTreeMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t : Std.DTreeMap α β cmp} [Std.TransCmp cmp] {k a : α}
{v : β k}, a ∈ t.insert k v → cmp k a ≠ Ordering.eq → a ∈ t |
MvPowerSeries.rescaleMonoidHom._proof_1 | Mathlib.RingTheory.MvPowerSeries.Substitution | ∀ {σ : Type u_1} {R : Type u_2} [inst : CommSemiring R] (a b : σ → R),
MvPowerSeries.rescale (a * b) = MvPowerSeries.rescale a * MvPowerSeries.rescale b |
_private.Init.Data.Int.Linear.0.Int.Linear.poly_eq_zero_eq_false | Init.Data.Int.Linear | ∀ (ctx : Int.Linear.Context) {p : Int.Linear.Poly} {k : ℤ},
Int.Linear.Poly.divCoeffs k p = true →
k > 0 → Int.Linear.cmod p.getConst k < 0 → (Int.Linear.Poly.denote ctx p = 0) = False |
integral_sin_pow_aux | Mathlib.Analysis.SpecialFunctions.Integrals.Basic | ∀ {a b : ℝ} (n : ℕ),
∫ (x : ℝ) in a..b, Real.sin x ^ (n + 2) =
(Real.sin a ^ (n + 1) * Real.cos a - Real.sin b ^ (n + 1) * Real.cos b +
(↑n + 1) * ∫ (x : ℝ) in a..b, Real.sin x ^ n) -
(↑n + 1) * ∫ (x : ℝ) in a..b, Real.sin x ^ (n + 2) |
Lean.Parser.Term.stateRefT._regBuiltin.Lean.Parser.Term.stateRefT_1 | Lean.Parser.Term | IO Unit |
thickenedIndicator.congr_simp | Mathlib.Topology.MetricSpace.ThickenedIndicator | ∀ {α : Type u_1} [inst : PseudoEMetricSpace α] {δ δ_1 : ℝ} (e_δ : δ = δ_1) (δ_pos : 0 < δ) (E E_1 : Set α),
E = E_1 → thickenedIndicator δ_pos E = thickenedIndicator ⋯ E_1 |
Representation.Coinvariants.mk_tmul_inv | Mathlib.RepresentationTheory.Coinvariants | ∀ {k : Type u_6} {G : Type u_7} {V : Type u_8} {W : Type u_9} [inst : CommRing k] [inst_1 : Group G]
[inst_2 : AddCommGroup V] [inst_3 : Module k V] [inst_4 : AddCommGroup W] [inst_5 : Module k W]
(ρ : Representation k G V) (τ : Representation k G W) (x : V) (y : W) (g : G),
(Representation.Coinvariants.mk (ρ.tprod τ)) (x ⊗ₜ[k] (τ g⁻¹) y) =
(Representation.Coinvariants.mk (ρ.tprod τ)) ((ρ g) x ⊗ₜ[k] y) |
Finpartition.ofErase.congr_simp | Mathlib.Order.Partition.Finpartition | ∀ {α : Type u_1} [inst : Lattice α] [inst_1 : OrderBot α] [inst_2 : DecidableEq α] {a : α} (parts parts_1 : Finset α)
(e_parts : parts = parts_1) (sup_indep : parts.SupIndep id) (sup_parts : parts.sup id = a),
Finpartition.ofErase parts sup_indep sup_parts = Finpartition.ofErase parts_1 ⋯ ⋯ |
ClassGroup.mk._proof_1 | Mathlib.RingTheory.ClassGroup | ∀ {R : Type u_1} [inst : CommRing R] [inst_1 : IsDomain R], (toPrincipalIdeal R (FractionRing R)).range.Normal |
NonarchimedeanGroup.mk._flat_ctor | Mathlib.Topology.Algebra.Nonarchimedean.Basic | ∀ {G : Type u_1} [inst : Group G] [inst_1 : TopologicalSpace G],
(Continuous fun p => p.1 * p.2) → (Continuous fun a => a⁻¹) → (∀ U ∈ nhds 1, ∃ V, ↑V ⊆ U) → NonarchimedeanGroup G |
Lean.Name.hasMacroScopes._unsafe_rec | Init.Prelude | Lean.Name → Bool |
Lean.Diff.Action.skip | Lean.Util.Diff | Lean.Diff.Action |
_private.Init.Data.BitVec.Lemmas.0.BitVec.ofNat_sub_ofNat_of_le._proof_1_1 | Init.Data.BitVec.Lemmas | ∀ {w : ℕ} (x y : ℕ), y < 2 ^ w → y ≤ x → ¬2 ^ w - y + x = 2 ^ w + (x - y) → False |
instMinInt16 | Init.Data.SInt.Basic | Min Int16 |
MeasureTheory.OuterMeasure.instLawfulFunctor | Mathlib.MeasureTheory.OuterMeasure.Operations | LawfulFunctor MeasureTheory.OuterMeasure |
NonemptyFinLinOrd.hom_hom_ofHom | Mathlib.Order.Category.NonemptyFinLinOrd | ∀ {X Y : Type u} [inst : Nonempty X] [inst_1 : LinearOrder X] [inst_2 : Fintype X] [inst_3 : Nonempty Y]
[inst_4 : LinearOrder Y] [inst_5 : Fintype Y] (f : X →o Y), LinOrd.Hom.hom (NonemptyFinLinOrd.ofHom f).hom = f |
ProbabilityTheory.condCDF | Mathlib.Probability.Kernel.Disintegration.CondCDF | {α : Type u_1} → {mα : MeasurableSpace α} → MeasureTheory.Measure (α × ℝ) → α → StieltjesFunction ℝ |
ExceptCpsT.runCatch | Init.Control.ExceptCps | {m : Type u_1 → Type u_2} → {α : Type u_1} → [Monad m] → ExceptCpsT α m α → m α |
_private.Lean.Widget.Diff.0.Lean.Widget.ExprDiff.mk.injEq | Lean.Widget.Diff | ∀ (changesBefore changesAfter changesBefore_1 changesAfter_1 : Lean.SubExpr.PosMap Lean.Widget.ExprDiffTag✝),
({ changesBefore := changesBefore, changesAfter := changesAfter } =
{ changesBefore := changesBefore_1, changesAfter := changesAfter_1 }) =
(changesBefore = changesBefore_1 ∧ changesAfter = changesAfter_1) |
Lean.Compiler.LCNF.FloatLetIn.Decision.recOn | Lean.Compiler.LCNF.FloatLetIn | {motive : Lean.Compiler.LCNF.FloatLetIn.Decision → Sort u} →
(t : Lean.Compiler.LCNF.FloatLetIn.Decision) →
((name : Lean.Name) → motive (Lean.Compiler.LCNF.FloatLetIn.Decision.arm name)) →
motive Lean.Compiler.LCNF.FloatLetIn.Decision.default →
motive Lean.Compiler.LCNF.FloatLetIn.Decision.dont →
motive Lean.Compiler.LCNF.FloatLetIn.Decision.unknown → motive t |
Seminorm.instSeminormClass | Mathlib.Analysis.Seminorm | ∀ {𝕜 : Type u_3} {E : Type u_7} [inst : SeminormedRing 𝕜] [inst_1 : AddGroup E] [inst_2 : SMul 𝕜 E],
SeminormClass (Seminorm 𝕜 E) 𝕜 E |
AddCircle.denseRange_zsmul_iff | Mathlib.Topology.Instances.AddCircle.DenseSubgroup | ∀ {p : ℝ} [Fact (0 < p)] {a : AddCircle p}, (DenseRange fun x => x • a) ↔ addOrderOf a = 0 |
Multiset.equivDFinsupp._proof_2 | Mathlib.Data.DFinsupp.Multiset | ∀ {α : Type u_1} [inst : DecidableEq α], Multiset.toDFinsupp.comp DFinsupp.toMultiset = AddMonoidHom.id (Π₀ (x : α), ℕ) |
Std.HashMap.Raw.getKeyD_inter_of_not_mem_right | Std.Data.HashMap.RawLemmas | ∀ {α : Type u} [inst : BEq α] [inst_1 : Hashable α] {β : Type v} {m₁ m₂ : Std.HashMap.Raw α β} [EquivBEq α]
[LawfulHashable α], m₁.WF → m₂.WF → ∀ {k fallback : α}, k ∉ m₂ → (m₁ ∩ m₂).getKeyD k fallback = fallback |
MeasureTheory.LocallyIntegrable.integrable_of_isBigO_atTop_of_norm_isNegInvariant | Mathlib.MeasureTheory.Integral.Asymptotics | ∀ {α : Type u_1} {E : Type u_2} {F : Type u_3} [inst : NormedAddCommGroup E] {f : α → E} {g : α → F}
[inst_1 : TopologicalSpace α] [SecondCountableTopology α] [inst_3 : MeasurableSpace α] {μ : MeasureTheory.Measure α}
[inst_4 : NormedAddCommGroup F] [inst_5 : AddCommGroup α] [inst_6 : LinearOrder α] [IsOrderedAddMonoid α]
[CompactIccSpace α] [Filter.atTop.IsMeasurablyGenerated] [MeasurableNeg α] [μ.IsNegInvariant],
MeasureTheory.LocallyIntegrable f μ →
norm ∘ f =ᵐ[μ] norm ∘ f ∘ Neg.neg →
f =O[Filter.atTop] g → MeasureTheory.IntegrableAtFilter g Filter.atTop μ → MeasureTheory.Integrable f μ |
Representation.norm_self_apply | Mathlib.RepresentationTheory.Basic | ∀ {k : Type u_1} {G : Type u_2} {V : Type u_3} [inst : Semiring k] [inst_1 : Group G] [inst_2 : Fintype G]
[inst_3 : AddCommMonoid V] [inst_4 : Module k V] (ρ : Representation k G V) (g : G) (x : V),
ρ.norm ((ρ g) x) = ρ.norm x |
WithCStarModule.instUnique | Mathlib.Analysis.CStarAlgebra.Module.Synonym | (A : Type u_3) → (E : Type u_4) → [Unique E] → Unique (WithCStarModule A E) |
CategoryTheory.Lax.OplaxTrans.vCompApp | Mathlib.CategoryTheory.Bicategory.NaturalTransformation.Lax | {B : Type u₁} →
[inst : CategoryTheory.Bicategory B] →
{C : Type u₂} →
[inst_1 : CategoryTheory.Bicategory C] →
{F G H : CategoryTheory.LaxFunctor B C} →
CategoryTheory.Lax.OplaxTrans F G → CategoryTheory.Lax.OplaxTrans G H → (a : B) → F.obj a ⟶ H.obj a |
TrivSqZeroExt.instL1SeminormedRing._proof_1 | Mathlib.Analysis.Normed.Algebra.TrivSqZeroExt | ∀ {R : Type u_1} {M : Type u_2} [inst : SeminormedRing R] [inst_1 : SeminormedAddCommGroup M] (a b : TrivSqZeroExt R M),
a + b = b + a |
Algebra.adjoin_empty | Mathlib.Algebra.Algebra.Subalgebra.Lattice | ∀ (R : Type uR) (A : Type uA) [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A],
Algebra.adjoin R ∅ = ⊥ |
LinearMap.intrinsicStar_mulRight | Mathlib.Algebra.Star.LinearMap | ∀ {R : Type u_1} [inst : Semiring R] [inst_1 : InvolutiveStar R] {E : Type u_6} [inst_2 : NonUnitalNonAssocSemiring E]
[inst_3 : StarRing E] [inst_4 : Module R E] [inst_5 : StarModule R E] [inst_6 : SMulCommClass R E E]
[inst_7 : IsScalarTower R E E] (x : E),
star (WithConv.toConv (LinearMap.mulRight R x)) = WithConv.toConv (LinearMap.mulLeft R (star x)) |
Finsupp.prod_of_support_subset | Mathlib.Algebra.BigOperators.Finsupp.Basic | ∀ {α : Type u_1} {M : Type u_8} {N : Type u_10} [inst : Zero M] [inst_1 : CommMonoid N] (f : α →₀ M) {s : Finset α},
f.support ⊆ s → ∀ (g : α → M → N), (∀ i ∈ s, g i 0 = 1) → f.prod g = ∏ x ∈ s, g x (f x) |
Lean.Meta.Grind.propagateEqUp | Lean.Meta.Tactic.Grind.Propagate | Lean.Meta.Grind.Propagator |
_private.Mathlib.Algebra.Homology.Embedding.Basic.0.ComplexShape.instIsTruncGENatIntEmbeddingUpIntGE._proof_1 | Mathlib.Algebra.Homology.Embedding.Basic | ∀ (p : ℤ) {j : ℕ} {x : ℤ}, p + ↑j + 1 = x → p + (↑j + 1) = x |
CochainComplex.mappingCone.mapHomologicalComplexXIso' | Mathlib.Algebra.Homology.HomotopyCategory.MappingCone | {C : Type u_1} →
{D : Type u_2} →
[inst : CategoryTheory.Category.{v, u_1} C] →
[inst_1 : CategoryTheory.Category.{v', u_2} D] →
[inst_2 : CategoryTheory.Preadditive C] →
[inst_3 : CategoryTheory.Preadditive D] →
{F G : CochainComplex C ℤ} →
(φ : F ⟶ G) →
[inst_4 : HomologicalComplex.HasHomotopyCofiber φ] →
(H : CategoryTheory.Functor C D) →
[inst_5 : H.Additive] →
[inst_6 :
HomologicalComplex.HasHomotopyCofiber ((H.mapHomologicalComplex (ComplexShape.up ℤ)).map φ)] →
(n m : ℤ) →
n + 1 = m →
(((H.mapHomologicalComplex (ComplexShape.up ℤ)).obj (CochainComplex.mappingCone φ)).X n ≅
(CochainComplex.mappingCone ((H.mapHomologicalComplex (ComplexShape.up ℤ)).map φ)).X n) |
CategoryTheory.Limits.wideCoequalizerIsWideCoequalizer | Mathlib.CategoryTheory.Limits.Shapes.WideEqualizers | {J : Type w} →
{C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{X Y : C} →
(f : J → (X ⟶ Y)) →
[inst_1 : CategoryTheory.Limits.HasWideCoequalizer f] →
[inst_2 : Nonempty J] →
CategoryTheory.Limits.IsColimit
(CategoryTheory.Limits.Cotrident.ofπ (CategoryTheory.Limits.wideCoequalizer.π f) ⋯) |
length_permsOfList | Mathlib.Data.Fintype.Perm | ∀ {α : Type u_1} [inst : DecidableEq α] (l : List α), (permsOfList l).length = l.length.factorial |
CategoryTheory.ShortComplex.RightHomologyMapData.noConfusion | Mathlib.Algebra.Homology.ShortComplex.RightHomology | {P : Sort u} →
{C : Type u_1} →
{inst : CategoryTheory.Category.{v_1, u_1} C} →
{inst_1 : CategoryTheory.Limits.HasZeroMorphisms C} →
{S₁ S₂ : CategoryTheory.ShortComplex C} →
{φ : S₁ ⟶ S₂} →
{h₁ : S₁.RightHomologyData} →
{h₂ : S₂.RightHomologyData} →
{t : CategoryTheory.ShortComplex.RightHomologyMapData φ h₁ h₂} →
{C' : Type u_1} →
{inst' : CategoryTheory.Category.{v_1, u_1} C'} →
{inst'_1 : CategoryTheory.Limits.HasZeroMorphisms C'} →
{S₁' S₂' : CategoryTheory.ShortComplex C'} →
{φ' : S₁' ⟶ S₂'} →
{h₁' : S₁'.RightHomologyData} →
{h₂' : S₂'.RightHomologyData} →
{t' : CategoryTheory.ShortComplex.RightHomologyMapData φ' h₁' h₂'} →
C = C' →
inst ≍ inst' →
inst_1 ≍ inst'_1 →
S₁ ≍ S₁' →
S₂ ≍ S₂' →
φ ≍ φ' →
h₁ ≍ h₁' →
h₂ ≍ h₂' →
t ≍ t' →
CategoryTheory.ShortComplex.RightHomologyMapData.noConfusionType P t
t' |
_private.Mathlib.MeasureTheory.Covering.Besicovitch.0.Besicovitch.exist_disjoint_covering_families._simp_1_10 | Mathlib.MeasureTheory.Covering.Besicovitch | ∀ {α : Type u} (x : α), (x ∈ Set.univ) = True |
Std.DHashMap.Const.foldM_eq_foldlM_toList | Std.Data.DHashMap.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {δ : Type w} {m' : Type w → Type w'} {β : Type v}
{m : Std.DHashMap α fun x => β} [inst : Monad m'] [LawfulMonad m'] {f : δ → α → β → m' δ} {init : δ},
Std.DHashMap.foldM f init m = List.foldlM (fun a b => f a b.1 b.2) init (Std.DHashMap.Const.toList m) |
Bundle.Trivial.vectorBundle | Mathlib.Topology.VectorBundle.Constructions | ∀ (𝕜 : Type u_1) (B : Type u_2) (F : Type u_3) [inst : NontriviallyNormedField 𝕜] [inst_1 : NormedAddCommGroup F]
[inst_2 : NormedSpace 𝕜 F] [inst_3 : TopologicalSpace B], VectorBundle 𝕜 F (Bundle.Trivial B F) |
ModularGroup.exists_bound_of_subgroup_invariant | Mathlib.NumberTheory.ModularForms.Bounds | ∀ {E : Type u_1} [inst : SeminormedAddCommGroup E] {f : UpperHalfPlane → E},
Continuous f →
(∀ (g : Matrix.SpecialLinearGroup (Fin 2) ℤ), UpperHalfPlane.IsBoundedAtImInfty fun τ => f (g • τ)) →
∀ {Γ : Subgroup (GL (Fin 2) ℝ)} [Γ.IsArithmetic],
(∀ g ∈ Γ, ∀ (τ : UpperHalfPlane), f (g • τ) = f τ) → ∃ C, ∀ (τ : UpperHalfPlane), ‖f τ‖ ≤ C |
CategoryTheory.Functor.IsOneHypercoverDense.of_hasPullbacks | Mathlib.CategoryTheory.Sites.DenseSubsite.OneHypercoverDense | ∀ {C₀ : Type u₀} {C : Type u} [inst : CategoryTheory.Category.{v₀, u₀} C₀] [inst_1 : CategoryTheory.Category.{v, u} C]
{F : CategoryTheory.Functor C₀ C} {J₀ : CategoryTheory.GrothendieckTopology C₀}
{J : CategoryTheory.GrothendieckTopology C} [CategoryTheory.Functor.IsDenseSubsite J₀ J F]
[CategoryTheory.Limits.HasPullbacks C] [F.Full] [F.Faithful],
(∀ (S : C), ∃ ι U f, CategoryTheory.Sieve.ofArrows (fun i => F.obj (U i)) f ∈ J S) → F.IsOneHypercoverDense J₀ J |
NonUnitalSubalgebra.coe_zero | Mathlib.Algebra.Algebra.NonUnitalSubalgebra | ∀ {R : Type u} {A : Type v} [inst : CommSemiring R] [inst_1 : NonUnitalNonAssocSemiring A] [inst_2 : Module R A]
{S : NonUnitalSubalgebra R A}, ↑0 = 0 |
Fin.insertNthOrderIso_symm_apply | Mathlib.Order.Fin.Tuple | ∀ {n : ℕ} (α : Fin (n + 1) → Type u_2) [inst : (i : Fin (n + 1)) → LE (α i)] (p : Fin (n + 1))
(f : (i : Fin (n + 1)) → α i), (RelIso.symm (Fin.insertNthOrderIso α p)) f = (f p, p.removeNth f) |
_private.Lean.Meta.Tactic.Grind.Arith.CommRing.Reify.0.Lean.Meta.Grind.Arith.CommRing.reifyCore?.go | Lean.Meta.Tactic.Grind.Arith.CommRing.Reify | {m : Type → Type} →
[MonadLiftT Lean.MetaM m] →
[Lean.MonadError m] →
[Monad m] →
[Lean.Meta.Grind.Arith.CommRing.MonadCanon m] →
[Lean.Meta.Grind.Arith.CommRing.MonadRing m] →
(Lean.Expr → m Lean.Meta.Grind.Arith.CommRing.RingExpr) →
(Lean.Expr → m Lean.Meta.Grind.Arith.CommRing.RingExpr) →
Lean.Expr → m Lean.Meta.Grind.Arith.CommRing.RingExpr |
IntermediateField.relfinrank_eq_one_iff | Mathlib.FieldTheory.Relrank | ∀ {F : Type u} {E : Type v} [inst : Field F] [inst_1 : Field E] [inst_2 : Algebra F E] {A B : IntermediateField F E},
A.relfinrank B = 1 ↔ B ≤ A |
groupCohomology.isoCocycles₂._proof_1 | Mathlib.RepresentationTheory.Homological.GroupCohomology.LowDegree | ∀ {k G : Type u_1} [inst : CommRing k] [inst_1 : Group G] (A : Rep k G),
(HomologicalComplex.sc (groupCohomology.inhomogeneousCochains A) 2).HasLeftHomology |
_private.Std.Data.Iterators.Lemmas.Producers.Monadic.Vector.0.Vector.iterM_equiv_iterM_toList._simp_1_1 | Std.Data.Iterators.Lemmas.Producers.Monadic.Vector | ∀ {m : Type w → Type w'} [inst : Monad m] {β : Type w} {n : ℕ} {xs : Vector β n}, xs.iterM m = xs.toArray.iterM m |
_private.Mathlib.CategoryTheory.Subfunctor.Equalizer.0.CategoryTheory.Subfunctor.equalizer.condition._simp_1_1 | Mathlib.CategoryTheory.Subfunctor.Equalizer | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {F₁ F₂ : CategoryTheory.Functor C (Type w)}
{A : CategoryTheory.Subfunctor F₁} (f g : A.toFunctor ⟶ F₂) {G : CategoryTheory.Functor C (Type w)}
(φ : G ⟶ A.toFunctor),
(CategoryTheory.CategoryStruct.comp φ f = CategoryTheory.CategoryStruct.comp φ g) =
(CategoryTheory.Subfunctor.range (CategoryTheory.CategoryStruct.comp φ A.ι) ≤
CategoryTheory.Subfunctor.equalizer f g) |
_private.Mathlib.RingTheory.Unramified.LocalRing.0.Localization.exists_awayMap_bijective_of_localRingHom_bijective._simp_1_2 | Mathlib.RingTheory.Unramified.LocalRing | ∀ {α : Sort u} {p : α → Prop} {q : { a // p a } → Prop}, (∃ x, q x) = ∃ a, ∃ (b : p a), q ⟨a, b⟩ |
_private.Lean.Compiler.NameMangling.0.Lean.Name.demangleAux.decodeNum._mutual._proof_26 | Lean.Compiler.NameMangling | ∀ (s : String) (p₀ : s.Pos) (hp₀ : ¬p₀ = s.endPos) (q : s.Pos) (v : ℕ),
Lean.parseLowerHex?✝ 4 s (p₀.next hp₀) 0 = some (q, v) → p₀ < q |
RingHom.codRestrict._proof_2 | Mathlib.Algebra.Ring.Subsemiring.Basic | ∀ {R : Type u_3} {S : Type u_1} [inst : NonAssocSemiring R] [inst_1 : NonAssocSemiring S] {σS : Type u_2}
[inst_2 : SetLike σS S] [inst_3 : SubsemiringClass σS S] (f : R →+* S) (s : σS) (h : ∀ (x : R), f x ∈ s) (x y : R),
(↑((↑f).codRestrict s h)).toFun (x * y) = (↑((↑f).codRestrict s h)).toFun x * (↑((↑f).codRestrict s h)).toFun y |
Lean.Meta.DiscrTree.recOn | Lean.Meta.DiscrTree.Types | {α : Type} →
{motive : Lean.Meta.DiscrTree α → Sort u} →
(t : Lean.Meta.DiscrTree α) →
((root : Lean.PersistentHashMap Lean.Meta.DiscrTree.Key (Lean.Meta.DiscrTree.Trie α)) → motive { root := root }) →
motive t |
_private.Mathlib.GroupTheory.Sylow.0.Sylow.exists_subgroup_card_pow_prime.match_1_1 | Mathlib.GroupTheory.Sylow | ∀ {G : Type u_1} [inst : Group G] (p : ℕ) {n : ℕ} (motive : (∃ K, Nat.card ↥K = p ^ n ∧ ⊥ ≤ K) → Prop)
(x : ∃ K, Nat.card ↥K = p ^ n ∧ ⊥ ≤ K), (∀ (K : Subgroup G) (hK : Nat.card ↥K = p ^ n ∧ ⊥ ≤ K), motive ⋯) → motive x |
MeasureTheory.condExp_of_not_integrable | Mathlib.MeasureTheory.Function.ConditionalExpectation.Basic | ∀ {α : Type u_1} {E : Type u_3} {m m₀ : MeasurableSpace α} {μ : MeasureTheory.Measure α} {f : α → E}
[inst : NormedAddCommGroup E] [inst_1 : CompleteSpace E] [inst_2 : NormedSpace ℝ E],
¬MeasureTheory.Integrable f μ → μ[f | m] = 0 |
Matrix.toLin_finTwoProd_toContinuousLinearMap | Mathlib.Topology.Algebra.Module.FiniteDimension | ∀ {𝕜 : Type u} [hnorm : NontriviallyNormedField 𝕜] [inst : CompleteSpace 𝕜] (a b c d : 𝕜),
LinearMap.toContinuousLinearMap
((Matrix.toLin (Module.Basis.finTwoProd 𝕜) (Module.Basis.finTwoProd 𝕜)) !![a, b; c, d]) =
(a • ContinuousLinearMap.fst 𝕜 𝕜 𝕜 + b • ContinuousLinearMap.snd 𝕜 𝕜 𝕜).prod
(c • ContinuousLinearMap.fst 𝕜 𝕜 𝕜 + d • ContinuousLinearMap.snd 𝕜 𝕜 𝕜) |
Int16.toBitVec_add | Init.Data.SInt.Lemmas | ∀ {a b : Int16}, (a + b).toBitVec = a.toBitVec + b.toBitVec |
_private.Mathlib.MeasureTheory.Measure.Tilted.0.MeasureTheory.tilted_tilted._simp_1_3 | Mathlib.MeasureTheory.Measure.Tilted | ∀ {α : Type u_2} [inst : Zero α] [inst_1 : OfNat α 4] [NeZero 4], (4 = 0) = False |
MatrixEquivTensor.toFunAlgHom._proof_3 | Mathlib.RingTheory.MatrixAlgebra | ∀ (n : Type u_1) (R : Type u_3) (A : Type u_2) [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A]
[inst_3 : DecidableEq n] [inst_4 : Fintype n], (MatrixEquivTensor.toFunLinear n R A) (1 ⊗ₜ[R] 1) = 1 |
Std.DHashMap.Raw.Const.getD_of_isEmpty | Std.Data.DHashMap.RawLemmas | ∀ {α : Type u} [inst : BEq α] [inst_1 : Hashable α] {β : Type v} {m : Std.DHashMap.Raw α fun x => β} [EquivBEq α]
[LawfulHashable α],
m.WF → ∀ {a : α} {fallback : β}, m.isEmpty = true → Std.DHashMap.Raw.Const.getD m a fallback = fallback |
SemilinearMapClass.mk._flat_ctor | Mathlib.Algebra.Module.LinearMap.Defs | ∀ {F : Type u_14} {R : outParam (Type u_15)} {S : outParam (Type u_16)} [inst : Semiring R] [inst_1 : Semiring S]
{σ : outParam (R →+* S)} {M : outParam (Type u_17)} {M₂ : outParam (Type u_18)} [inst_2 : AddCommMonoid M]
[inst_3 : AddCommMonoid M₂] [inst_4 : Module R M] [inst_5 : Module S M₂] [inst_6 : FunLike F M M₂],
(∀ (f : F) (x y : M), f (x + y) = f x + f y) →
(∀ (f : F) (c : R) (x : M), f (c • x) = σ c • f x) → SemilinearMapClass F σ M M₂ |
RootPairing.IsRootSystem.ext | Mathlib.LinearAlgebra.RootSystem.Basic | ∀ {ι : Type u_1} {R : Type u_2} {M : Type u_3} {N : Type u_4} [inst : CommRing R] [inst_1 : AddCommGroup M]
[inst_2 : Module R M] [inst_3 : AddCommGroup N] [inst_4 : Module R N] [Finite ι] [CharZero R] [IsDomain R]
[Module.IsTorsionFree R M] {P₁ P₂ : RootPairing ι R M N} [P₁.IsRootSystem] [P₂.IsRootSystem],
P₁.toLinearMap = P₂.toLinearMap → P₁.root = P₂.root → P₁ = P₂ |
Lean.IR.IRType.match_on_same_ctor._@.Lean.Compiler.IR.Basic.840659257._hygCtx._hyg.60 | Lean.Compiler.IR.Basic | {motive : (t t_1 : Lean.IR.IRType) → t.ctorIdx = t_1.ctorIdx → Sort u} →
(t t_1 : Lean.IR.IRType) →
(h : t.ctorIdx = t_1.ctorIdx) →
(Unit → motive Lean.IR.IRType.float Lean.IR.IRType.float ⋯) →
(Unit → motive Lean.IR.IRType.uint8 Lean.IR.IRType.uint8 ⋯) →
(Unit → motive Lean.IR.IRType.uint16 Lean.IR.IRType.uint16 ⋯) →
(Unit → motive Lean.IR.IRType.uint32 Lean.IR.IRType.uint32 ⋯) →
(Unit → motive Lean.IR.IRType.uint64 Lean.IR.IRType.uint64 ⋯) →
(Unit → motive Lean.IR.IRType.usize Lean.IR.IRType.usize ⋯) →
(Unit → motive Lean.IR.IRType.erased Lean.IR.IRType.erased ⋯) →
(Unit → motive Lean.IR.IRType.object Lean.IR.IRType.object ⋯) →
(Unit → motive Lean.IR.IRType.tobject Lean.IR.IRType.tobject ⋯) →
(Unit → motive Lean.IR.IRType.float32 Lean.IR.IRType.float32 ⋯) →
((leanTypeName : Option Lean.Name) →
(types : Array Lean.IR.IRType) →
(leanTypeName' : Option Lean.Name) →
(types' : Array Lean.IR.IRType) →
motive (Lean.IR.IRType.struct leanTypeName types)
(Lean.IR.IRType.struct leanTypeName' types') ⋯) →
((leanTypeName : Lean.Name) →
(types : Array Lean.IR.IRType) →
(leanTypeName' : Lean.Name) →
(types' : Array Lean.IR.IRType) →
motive (Lean.IR.IRType.union leanTypeName types)
(Lean.IR.IRType.union leanTypeName' types') ⋯) →
(Unit → motive Lean.IR.IRType.tagged Lean.IR.IRType.tagged ⋯) →
(Unit → motive Lean.IR.IRType.void Lean.IR.IRType.void ⋯) → motive t t_1 h |
CategoryTheory.Limits.PreservesPullback.iso_hom_fst | Mathlib.CategoryTheory.Limits.Preserves.Shapes.Pullbacks | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
(G : CategoryTheory.Functor C D) {X Y Z : C} (f : X ⟶ Z) (g : Y ⟶ Z)
[inst_2 : CategoryTheory.Limits.PreservesLimit (CategoryTheory.Limits.cospan f g) G]
[inst_3 : CategoryTheory.Limits.HasPullback f g] [inst_4 : CategoryTheory.Limits.HasPullback (G.map f) (G.map g)],
CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.PreservesPullback.iso G f g).hom
(CategoryTheory.Limits.pullback.fst (G.map f) (G.map g)) =
G.map (CategoryTheory.Limits.pullback.fst f g) |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.