name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M |
|---|---|---|
SSet.Subcomplex.Pairing.RankFunction.casesOn | Mathlib.AlgebraicTopology.SimplicialSet.AnodyneExtensions.Rank | {X : SSet} →
{A : X.Subcomplex} →
{P : A.Pairing} →
{α : Type v} →
[inst : PartialOrder α] →
{motive : P.RankFunction α → Sort u_1} →
(t : P.RankFunction α) →
((rank : ↑P.II → α) →
(lt : ∀ {x y : ↑P.II}, P.AncestralRel x y → rank x < rank y) → motive { rank := rank, lt := lt }) →
motive t |
Pi.smulWithZero' | Mathlib.Algebra.GroupWithZero.Action.Pi | {I : Type u} →
{f : I → Type v} →
{g : I → Type u_1} →
[inst : (i : I) → Zero (g i)] →
[inst_1 : (i : I) → Zero (f i)] →
[(i : I) → SMulWithZero (g i) (f i)] → SMulWithZero ((i : I) → g i) ((i : I) → f i) |
Std.DTreeMap.Internal.Unit.RicSliceData.mk.noConfusion | Std.Data.DTreeMap.Internal.Zipper | {α : Type u} →
{inst : Ord α} →
{P : Sort u_1} →
{treeMap : Std.DTreeMap.Internal.Impl α fun x => Unit} →
{range : Std.Ric α} →
{treeMap' : Std.DTreeMap.Internal.Impl α fun x => Unit} →
{range' : Std.Ric α} →
{ treeMap := treeMap, range := range } = { treeMap := treeMap', range := range' } →
(treeMap ≍ treeMap' → range ≍ range' → P) → P |
IsLocalRing.instModuleResidueFieldCotangentSpace | Mathlib.RingTheory.Ideal.Cotangent | (R : Type u_1) →
[inst : CommRing R] → [inst_1 : IsLocalRing R] → Module (IsLocalRing.ResidueField R) (IsLocalRing.CotangentSpace R) |
CategoryTheory.Pseudofunctor.isoMapOfCommSq_eq._proof_1 | Mathlib.CategoryTheory.Bicategory.Strict.Pseudofunctor | ∀ {B : Type u_2} [inst : CategoryTheory.Bicategory B] {X₁ Y₁ Y₂ : B} {t : X₁ ⟶ Y₁} {r : Y₁ ⟶ Y₂} (φ : X₁ ⟶ Y₂),
CategoryTheory.CategoryStruct.comp t r = φ → CategoryTheory.CategoryStruct.comp t r = φ |
_private.Mathlib.AlgebraicTopology.SimplicialSet.Path.0.SSet.spine_δ₀._proof_1 | Mathlib.AlgebraicTopology.SimplicialSet.Path | ∀ {m : ℕ}, 1 + m ≤ m + 1 |
Int.induct_roo_left | Init.Data.Range.Polymorphic.IntLemmas | ∀ (motive : ℤ → ℤ → Prop),
(∀ (a b : ℤ), b ≤ a + 1 → motive a b) →
(∀ (a b : ℤ), a + 1 < b → motive (a + 1) b → motive a b) → ∀ (a b : ℤ), motive a b |
Lean.DeclNameGenerator.ctorIdx | Lean.CoreM | Lean.DeclNameGenerator → ℕ |
Int.negSucc_dvd | Init.Data.Int.DivMod.Lemmas | ∀ {a : ℕ} {b : ℤ}, Int.negSucc a ∣ b ↔ ↑(a + 1) ∣ b |
SignType.instHasDistribNeg | Mathlib.Data.Sign.Defs | HasDistribNeg SignType |
SSet.Augmented.stdSimplex._proof_8 | Mathlib.AlgebraicTopology.SimplicialSet.StdSimplex | ∀ {X Y Z : SimplexCategory} (f : X ⟶ Y) (g : Y ⟶ Z),
{ left := SSet.stdSimplex.map (CategoryTheory.CategoryStruct.comp f g),
right :=
CategoryTheory.Limits.terminal.from
{ left := SSet.stdSimplex.obj X, right := ⊤_ Type u_1,
hom :=
{
app := fun x =>
CategoryTheory.Limits.terminal.from
(((CategoryTheory.Functor.id (CategoryTheory.SimplicialObject (Type u_1))).obj
(SSet.stdSimplex.obj X)).obj
x),
naturality := ⋯ } }.right,
w := ⋯ } =
CategoryTheory.CategoryStruct.comp
{ left := SSet.stdSimplex.map f,
right :=
CategoryTheory.Limits.terminal.from
{ left := SSet.stdSimplex.obj X, right := ⊤_ Type u_1,
hom :=
{
app := fun x =>
CategoryTheory.Limits.terminal.from
(((CategoryTheory.Functor.id (CategoryTheory.SimplicialObject (Type u_1))).obj
(SSet.stdSimplex.obj X)).obj
x),
naturality := ⋯ } }.right,
w := ⋯ }
{ left := SSet.stdSimplex.map g,
right :=
CategoryTheory.Limits.terminal.from
{ left := SSet.stdSimplex.obj Y, right := ⊤_ Type u_1,
hom :=
{
app := fun x =>
CategoryTheory.Limits.terminal.from
(((CategoryTheory.Functor.id (CategoryTheory.SimplicialObject (Type u_1))).obj
(SSet.stdSimplex.obj Y)).obj
x),
naturality := ⋯ } }.right,
w := ⋯ } |
_private.Batteries.Data.List.Lemmas.0.List.getElem_findIdxs_eq_findIdxNth_add._proof_1_1 | Batteries.Data.List.Lemmas | ∀ {α : Type u_1} {p : α → Bool} {n s : ℕ}, n + 1 ≤ (List.findIdxs p [] s).length → n < (List.findIdxs p [] s).length |
Finpartition.mk_mem_sparsePairs._simp_1 | Mathlib.Combinatorics.SimpleGraph.Regularity.Uniform | ∀ {α : Type u_1} {𝕜 : Type u_2} [inst : Field 𝕜] [inst_1 : LinearOrder 𝕜] [inst_2 : DecidableEq α] {A : Finset α}
(P : Finpartition A) (G : SimpleGraph α) [inst_3 : DecidableRel G.Adj] (u v : Finset α) (ε : 𝕜),
((u, v) ∈ P.sparsePairs G ε) = (u ∈ P.parts ∧ v ∈ P.parts ∧ u ≠ v ∧ ↑(G.edgeDensity u v) < ε) |
ConjAct.unitsSMulCommClass' | Mathlib.GroupTheory.GroupAction.ConjAct | ∀ (α : Type u_1) {M : Type u_2} [inst : Monoid M] [inst_1 : SMul α M] [SMulCommClass M α M] [IsScalarTower α M M],
SMulCommClass (ConjAct Mˣ) α M |
FractionRing.instNontrivial | Mathlib.RingTheory.Localization.FractionRing | ∀ (R : Type u_1) [inst : CommRing R] [Nontrivial R], Nontrivial (FractionRing R) |
CategoryTheory.CostructuredArrow.essentiallySmall | Mathlib.CategoryTheory.Comma.StructuredArrow.Small | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
{S : CategoryTheory.Functor C D} {T : D} [CategoryTheory.EssentiallySmall.{w, v₁, u₁} C]
[CategoryTheory.LocallySmall.{w, v₂, u₂} D],
CategoryTheory.EssentiallySmall.{w, v₁, max u₁ v₂} (CategoryTheory.CostructuredArrow S T) |
Complex.liftAux | Mathlib.LinearAlgebra.Complex.Module | {A : Type u_1} → [inst : Ring A] → [inst_1 : Algebra ℝ A] → (I' : A) → I' * I' = -1 → ℂ →ₐ[ℝ] A |
AddSubmonoid.toAddMonoid | Mathlib.Algebra.Group.Submonoid.Defs | {M : Type u_5} → [inst : AddMonoid M] → (S : AddSubmonoid M) → AddMonoid ↥S |
TopModuleCat.mk._flat_ctor | Mathlib.Algebra.Category.ModuleCat.Topology.Basic | {R : Type u} →
[inst : Ring R] →
[inst_1 : TopologicalSpace R] →
(carrier : Type v) →
[isAddCommGroup : AddCommGroup carrier] →
[isModule : Module R carrier] →
[topologicalSpace : TopologicalSpace carrier] →
[isTopologicalAddGroup : IsTopologicalAddGroup carrier] →
[continuousSMul : ContinuousSMul R carrier] → TopModuleCat R |
quadraticChar._proof_1 | Mathlib.NumberTheory.LegendreSymbol.QuadraticChar.Basic | ∀ (F : Type u_1) [inst : Field F] [inst_1 : Fintype F] [inst_2 : DecidableEq F] (a : F),
¬IsUnit a → quadraticCharFun F a = 0 |
CategoryTheory.Limits.Types.instHasColimitConstPUnitFunctor | Mathlib.CategoryTheory.Limits.IsConnected | ∀ (C : Type u) [inst : CategoryTheory.Category.{v, u} C] [CategoryTheory.IsConnected C],
CategoryTheory.Limits.HasColimit (CategoryTheory.Limits.Types.constPUnitFunctor C) |
_private.Mathlib.Analysis.CStarAlgebra.Module.Defs.0.CStarModule.inner_zero_right._simp_1_1 | Mathlib.Analysis.CStarAlgebra.Module.Defs | ∀ {A : Type u_1} {E : Type u_2} [inst : NonUnitalRing A] [inst_1 : StarRing A] [inst_2 : AddCommGroup E]
[inst_3 : Module ℂ A] [inst_4 : Module ℂ E] [inst_5 : PartialOrder A] [inst_6 : SMul A E] [inst_7 : Norm A]
[inst_8 : Norm E] [inst_9 : CStarModule A E] [inst_10 : StarModule ℂ A] {x y : E},
inner A x y = (CStarModule.innerₛₗ x) y |
Set.prod_image_right | Mathlib.Data.Set.Operations | ∀ {α : Type u} {β : Type v} {γ : Type w} (f : α → γ) (s : Set α) (t : Set β),
t ×ˢ (f '' s) = (fun x => (x.1, f x.2)) '' t ×ˢ s |
Int64.ofIntLE_bitVecToInt._proof_1 | Init.Data.SInt.Lemmas | ∀ (n : BitVec 64), Int64.minValue.toInt ≤ n.toInt |
_private.Mathlib.Topology.Instances.Matrix.0.Continuous.matrix_blockDiagonal.match_1_1 | Mathlib.Topology.Instances.Matrix | ∀ {n : Type u_1} {p : Type u_2} (motive : n × p → Prop) (x : n × p), (∀ (j₁ : n) (_j₂ : p), motive (j₁, _j₂)) → motive x |
_private.Batteries.Data.List.Lemmas.0.List.getElem_filter_eq_getElem_getElem_findIdxs._proof_1 | Batteries.Data.List.Lemmas | ∀ {i : ℕ} {α : Type u_1} {xs : List α} {p : α → Bool}, i < (List.filter p xs).length → i < (List.findIdxs p xs).length |
Finset.Nat.prod_antidiagonal_eq_prod_range_succ | Mathlib.Algebra.BigOperators.NatAntidiagonal | ∀ {M : Type u_3} [inst : CommMonoid M] (f : ℕ → ℕ → M) (n : ℕ),
∏ ij ∈ Finset.antidiagonal n, f ij.1 ij.2 = ∏ k ∈ Finset.range n.succ, f k (n - k) |
_private.Mathlib.Algebra.Order.BigOperators.Group.Finset.0.Finset.prod_le_prod_of_subset_of_one_le'._simp_1_1 | Mathlib.Algebra.Order.BigOperators.Group.Finset | ∀ {α : Type u_1} [inst : DecidableEq α] {s t : Finset α} {a : α}, (a ∈ s \ t) = (a ∈ s ∧ a ∉ t) |
_private.Mathlib.Combinatorics.Matroid.Rank.Cardinal.0.Matroid.invariantCardinalRank_of_finitary.match_3 | Mathlib.Combinatorics.Matroid.Rank.Cardinal | ∀ {α : Type u_1} ⦃B B' : Set α⦄ ⦃N : Matroid α⦄ (U : Set α)
(motive : (∃ e ∈ B' \ (B ∩ B' ∪ U), N.Indep (insert e (B ∩ B' ∪ U))) → Prop)
(x : ∃ e ∈ B' \ (B ∩ B' ∪ U), N.Indep (insert e (B ∩ B' ∪ U))),
(∀ (a : α) (ha : a ∈ B' \ (B ∩ B' ∪ U)) (ind : N.Indep (insert a (B ∩ B' ∪ U))), motive ⋯) → motive x |
intervalIntegral.integrableOn_deriv_of_nonneg | Mathlib.MeasureTheory.Integral.IntervalIntegral.FundThmCalculus | ∀ {g' g : ℝ → ℝ} {a b : ℝ},
ContinuousOn g (Set.Icc a b) →
(∀ x ∈ Set.Ioo a b, HasDerivAt g (g' x) x) →
(∀ x ∈ Set.Ioo a b, 0 ≤ g' x) → MeasureTheory.IntegrableOn g' (Set.Ioc a b) MeasureTheory.volume |
CategoryTheory.CommMon.mkIso | Mathlib.CategoryTheory.Monoidal.CommMon_ | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
[inst_1 : CategoryTheory.MonoidalCategory C] →
[inst_2 : CategoryTheory.BraidedCategory C] →
{M N : CategoryTheory.CommMon C} →
(e : M.X ≅ N.X) →
autoParam (CategoryTheory.CategoryStruct.comp CategoryTheory.MonObj.one e.hom = CategoryTheory.MonObj.one)
CategoryTheory.CommMon.mkIso._auto_1 →
autoParam
(CategoryTheory.CategoryStruct.comp CategoryTheory.MonObj.mul e.hom =
CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategoryStruct.tensorHom e.hom e.hom)
CategoryTheory.MonObj.mul)
CategoryTheory.CommMon.mkIso._auto_3 →
(M ≅ N) |
_private.Lean.Meta.Tactic.Grind.Core.0.Lean.Meta.Grind.addEqStep.updateRoots.match_1 | Lean.Meta.Tactic.Grind.Core | (__do_lift : Lean.Meta.Grind.Goal) →
(motive : Option (Lean.Meta.Grind.CongrKey __do_lift.enodeMap) → Sort u_1) →
(x : Option (Lean.Meta.Grind.CongrKey __do_lift.enodeMap)) →
((e : Lean.Expr) → motive (some { e := e })) →
((x : Option (Lean.Meta.Grind.CongrKey __do_lift.enodeMap)) → motive x) → motive x |
ConditionallyCompleteLinearOrderedField.ratCast._inherited_default | Mathlib.Algebra.Order.CompleteField | {α : Type u_5} → (ℕ → α) → (ℤ → α) → (α → α → α) → ℚ → α |
CategoryTheory.PreOneHypercover.sieve₁ | Mathlib.CategoryTheory.Sites.Hypercover.One | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{S : C} →
(E : CategoryTheory.PreOneHypercover S) →
{i₁ i₂ : E.I₀} → {W : C} → (W ⟶ E.X i₁) → (W ⟶ E.X i₂) → CategoryTheory.Sieve W |
CommGroupWithZero.instNormalizedGCDMonoid._proof_15 | Mathlib.Algebra.GCDMonoid.Basic | ∀ (G₀ : Type u_1) [inst : CommGroupWithZero G₀] [inst_1 : DecidableEq G₀] (x : G₀), (if x = 0 ∨ 0 = 0 then 0 else 1) = 0 |
LowerSet.coe_iSup | Mathlib.Order.UpperLower.CompleteLattice | ∀ {α : Type u_1} {ι : Sort u_4} [inst : LE α] (f : ι → LowerSet α), ↑(⨆ i, f i) = ⋃ i, ↑(f i) |
_private.Mathlib.Algebra.Group.Opposite.0.MulOpposite.semiconjBy_op._simp_1_2 | Mathlib.Algebra.Group.Opposite | ∀ {α : Type u_1} {x y : α}, (MulOpposite.op x = MulOpposite.op y) = (x = y) |
Int8._sizeOf_1 | Init.Data.SInt.Basic | Int8 → ℕ |
_private.Mathlib.Algebra.Order.Group.MinMax.0.max_sub_max_le_max._proof_1_1 | Mathlib.Algebra.Order.Group.MinMax | ∀ {α : Type u_1} [inst : AddCommGroup α] [inst_1 : LinearOrder α] [IsOrderedAddMonoid α] (a b c d : α),
max a b - max c d ≤ max (a - c) (b - d) |
Aesop.Safety.safe.elim | Aesop.Rule | {motive : Aesop.Safety → Sort u} → (t : Aesop.Safety) → t.ctorIdx = 0 → motive Aesop.Safety.safe → motive t |
tendsto_integral_mul_one_add_inv_smul_sq_pow | Mathlib.Analysis.SpecialFunctions.MulExpNegMulSqIntegral | ∀ {E : Type u_1} [inst : TopologicalSpace E] [inst_1 : MeasurableSpace E] [BorelSpace E] {P : MeasureTheory.Measure E}
[MeasureTheory.IsFiniteMeasure P] {ε : ℝ} (g : BoundedContinuousFunction E ℝ),
0 < ε →
Filter.Tendsto (fun n => ∫ (x : E), (g * (1 + (↑n)⁻¹ • -(ε • g * g)) ^ n) x ∂P) Filter.atTop
(nhds (∫ (x : E), ε.mulExpNegMulSq (g x) ∂P)) |
USize.fromExpr | Lean.Meta.Tactic.Simp.BuiltinSimprocs.UInt | Lean.Expr → Lean.Meta.SimpM (Option USize) |
Nat._aux_Mathlib_Data_Nat_Totient___macroRules_Nat_termφ_1 | Mathlib.Data.Nat.Totient | Lean.Macro |
Std.ExtDHashMap.size_add_size_eq_size_union_add_size_inter | Std.Data.ExtDHashMap.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {β : α → Type v} {m₁ m₂ : Std.ExtDHashMap α β} [inst : EquivBEq α]
[inst_1 : LawfulHashable α], m₁.size + m₂.size = (m₁ ∪ m₂).size + (m₁ ∩ m₂).size |
CategoryTheory.Endofunctor.Algebra.Initial.left_inv | Mathlib.CategoryTheory.Endofunctor.Algebra | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {F : CategoryTheory.Functor C C}
{A : CategoryTheory.Endofunctor.Algebra F} (h : CategoryTheory.Limits.IsInitial A),
CategoryTheory.CategoryStruct.comp (CategoryTheory.Endofunctor.Algebra.Initial.strInv h) A.str =
CategoryTheory.CategoryStruct.id A.a |
Lean.PrettyPrinter.Delaborator.annotateTermInfo | Lean.PrettyPrinter.Delaborator.Basic | Lean.Term → Lean.PrettyPrinter.Delaborator.Delab |
Isometry.euclideanHausdorffMeasure_preimage | Mathlib.Geometry.Euclidean.Volume.Measure | ∀ {X : Type u_1} {Y : Type u_2} [inst : EMetricSpace X] [inst_1 : MeasurableSpace X] [inst_2 : BorelSpace X]
[inst_3 : EMetricSpace Y] [inst_4 : MeasurableSpace Y] [inst_5 : BorelSpace Y] {f : X → Y} {d : ℕ},
Isometry f →
∀ (s : Set Y),
(MeasureTheory.Measure.euclideanHausdorffMeasure d) (f ⁻¹' s) =
(MeasureTheory.Measure.euclideanHausdorffMeasure d) (s ∩ Set.range f) |
Lean.Omega.Constraint.combo | Init.Omega.Constraint | ℤ → Lean.Omega.Constraint → ℤ → Lean.Omega.Constraint → Lean.Omega.Constraint |
Nat.bitwise_eq_binaryRec | Mathlib.Data.Nat.Bitwise | ∀ (f : Bool → Bool → Bool),
Nat.bitwise f = fun n =>
Nat.binaryRec (motive := fun x => ℕ → ℕ) (fun n => bif f false true then n else 0)
(fun a m Ia n => Nat.binaryRec (bif f true false then Nat.bit a m else 0) (fun b n x => Nat.bit (f a b) (Ia n)) n)
n |
_private.Lean.Linter.Coe.0.Lean.Linter.Coe.coeLinter._sparseCasesOn_6 | Lean.Linter.Coe | {motive : Lean.Elab.Info → Sort u} →
(t : Lean.Elab.Info) →
((i : Lean.Elab.CustomInfo) → motive (Lean.Elab.Info.ofCustomInfo i)) →
(Nat.hasNotBit 1024 t.ctorIdx → motive t) → motive t |
SSet.horn₃₂.ι₁_desc | Mathlib.AlgebraicTopology.SimplicialSet.HornColimits | ∀ {X : SSet} (f₀ f₁ f₃ : SSet.stdSimplex.obj (SimplexCategory.mk 2) ⟶ X)
(h₀₂ :
CategoryTheory.CategoryStruct.comp (SSet.stdSimplex.δ 2) f₁ =
CategoryTheory.CategoryStruct.comp (SSet.stdSimplex.δ 1) f₃)
(h₁₂ :
CategoryTheory.CategoryStruct.comp (SSet.stdSimplex.δ 2) f₀ =
CategoryTheory.CategoryStruct.comp (SSet.stdSimplex.δ 0) f₃)
(h₂₃ :
CategoryTheory.CategoryStruct.comp (SSet.stdSimplex.δ 0) f₀ =
CategoryTheory.CategoryStruct.comp (SSet.stdSimplex.δ 0) f₁),
CategoryTheory.CategoryStruct.comp SSet.horn₃₂.ι₁ (SSet.horn₃₂.desc f₀ f₁ f₃ h₀₂ h₁₂ h₂₃) = f₁ |
Ordnode.All.imp | Mathlib.Data.Ordmap.Invariants | ∀ {α : Type u_1} {P Q : α → Prop}, (∀ (a : α), P a → Q a) → ∀ {t : Ordnode α}, Ordnode.All P t → Ordnode.All Q t |
AddMonoidHom.coe_finset_sum | Mathlib.Algebra.BigOperators.Group.Finset.Lemmas | ∀ {ι : Type u_1} {M : Type u_3} {N : Type u_4} [inst : AddZeroClass M] [inst_1 : AddCommMonoid N] (f : ι → M →+ N)
(s : Finset ι), ⇑(∑ x ∈ s, f x) = ∑ x ∈ s, ⇑(f x) |
Pi.instAddTorsor._proof_3 | Mathlib.Algebra.AddTorsor.Basic | ∀ {I : Type u_1} {fg : I → Type u_2} [inst : (i : I) → AddGroup (fg i)] {fp : I → Type u_3}
[inst_1 : (i : I) → AddTorsor (fg i) (fp i)] (g : (i : I) → fg i) (p : (i : I) → fp i),
(fun i => (g +ᵥ p) i -ᵥ p i) = g |
_private.Mathlib.NumberTheory.FrobeniusNumber.0.Nat.exists_mem_span_nat_finset_of_ge._simp_1_9 | Mathlib.NumberTheory.FrobeniusNumber | ∀ {R : Type v} [inst : Mul R] [inst_1 : Add R] [RightDistribClass R] (a b c : R), a * c + b * c = (a + b) * c |
IntermediateField.isAlgebraic_adjoin_simple | Mathlib.FieldTheory.IntermediateField.Adjoin.Basic | ∀ {K : Type u} [inst : Field K] {L : Type u_3} [inst_1 : Field L] [inst_2 : Algebra K L] {x : L},
IsIntegral K x → Algebra.IsAlgebraic K ↥K⟮x⟯ |
_private.Init.Data.Range.Polymorphic.SInt.0.HasModel.instRxiHasSize | Init.Data.Range.Polymorphic.SInt | {α : Type u} →
[inst : LE α] →
[inst_1 : LT α] →
{β : Type v} →
[inst_2 : LE β] →
[inst_3 : LT β] →
[inst_4 : Std.PRange.UpwardEnumerable β] →
[inst_5 : Std.PRange.LawfulUpwardEnumerable β] →
[inst_6 : Std.PRange.LawfulUpwardEnumerableLE β] →
[inst_7 : Std.PRange.LawfulUpwardEnumerableLT β] →
[m : HasModel✝ α β] → [Std.Rxi.HasSize β] → Std.Rxi.HasSize α |
AddChar.compAddMonoidHom_injective_left | Mathlib.Algebra.Group.AddChar | ∀ {A : Type u_1} {B : Type u_2} {M : Type u_3} [inst : AddMonoid A] [inst_1 : AddMonoid B] [inst_2 : Monoid M]
(f : A →+ B), Function.Surjective ⇑f → Function.Injective fun ψ => ψ.compAddMonoidHom f |
_private.Lean.Meta.Tactic.Simp.SimpAll.0.Lean.Meta.SimpAll.loop.match_9 | Lean.Meta.Tactic.Simp.SimpAll | (motive : Option Lean.MVarId × Lean.Meta.Simp.Stats → Sort u_1) →
(__discr : Option Lean.MVarId × Lean.Meta.Simp.Stats) →
((r : Option Lean.MVarId) → (stats : Lean.Meta.Simp.Stats) → motive (r, stats)) → motive __discr |
ContinuousLinearEquiv.toNonlinearRightInverse._proof_1 | Mathlib.Analysis.Normed.Operator.Banach | ∀ {𝕜 : Type u_4} {𝕜' : Type u_3} [inst : NontriviallyNormedField 𝕜] [inst_1 : NontriviallyNormedField 𝕜'] {σ : 𝕜 →+* 𝕜'}
{E : Type u_1} [inst_2 : NormedAddCommGroup E] [inst_3 : NormedSpace 𝕜 E] {F : Type u_2}
[inst_4 : NormedAddCommGroup F] [inst_5 : NormedSpace 𝕜' F] {σ' : 𝕜' →+* 𝕜} [inst_6 : RingHomInvPair σ σ']
[RingHomIsometric σ'] [inst_8 : RingHomInvPair σ' σ] (f : E ≃SL[σ] F) (x : F), ‖↑f.symm x‖ ≤ ‖↑f.symm‖ * ‖x‖ |
_private.Lean.Elab.Tactic.RCases.0.Lean.Elab.Tactic.RCases.finish | Lean.Elab.Tactic.RCases | optParam (Array (Lean.Ident × Lean.FVarId)) #[] →
Lean.MVarId → Lean.Meta.FVarSubst → Array Lean.FVarId → Array Lean.MVarId → Lean.Elab.TermElabM (Array Lean.MVarId) |
CategoryTheory.DifferentialObject.d_squared_apply | Mathlib.Algebra.Homology.DifferentialObject | ∀ {β : Type u_1} [inst : AddCommGroup β] {b : β} {V : Type u_2} [inst_1 : CategoryTheory.Category.{v_1, u_2} V]
[inst_2 : CategoryTheory.Limits.HasZeroMorphisms V]
(X : CategoryTheory.DifferentialObject ℤ (CategoryTheory.GradedObjectWithShift b V)) {x : β},
CategoryTheory.CategoryStruct.comp (X.d x) (X.d ((fun b_1 => b_1 + { as := 1 }.as • b) x)) = 0 |
Bornology.isVonNBounded_pi_iff | Mathlib.Analysis.LocallyConvex.Bounded | ∀ {𝕜 : Type u_6} {ι : Type u_7} {E : ι → Type u_8} [inst : NormedDivisionRing 𝕜] [inst_1 : (i : ι) → AddCommGroup (E i)]
[inst_2 : (i : ι) → Module 𝕜 (E i)] [inst_3 : (i : ι) → TopologicalSpace (E i)] {S : Set ((i : ι) → E i)},
Bornology.IsVonNBounded 𝕜 S ↔ ∀ (i : ι), Bornology.IsVonNBounded 𝕜 (Function.eval i '' S) |
Submonoid.commMonoidTopologicalClosure | Mathlib.Topology.Algebra.Monoid | {M : Type u_3} →
[inst : TopologicalSpace M] →
[inst_1 : Monoid M] →
[inst_2 : SeparatelyContinuousMul M] →
[T2Space M] → (s : Submonoid M) → (∀ (x y : ↥s), x * y = y * x) → CommMonoid ↥s.topologicalClosure |
Lean.Compiler.LCNF.DeclValue.ctorElimType | Lean.Compiler.LCNF.Basic | {pu : Lean.Compiler.LCNF.Purity} → {motive : Lean.Compiler.LCNF.DeclValue pu → Sort u} → ℕ → Sort (max 1 u) |
ProbabilityTheory.IsGaussian.integrable_fun_id | Mathlib.Probability.Distributions.Gaussian.Fernique | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] [inst_2 : MeasurableSpace E] [BorelSpace E]
{μ : MeasureTheory.Measure E} [ProbabilityTheory.IsGaussian μ] [CompleteSpace E] [SecondCountableTopology E],
MeasureTheory.Integrable (fun x => x) μ |
_private.Batteries.Data.List.Lemmas.0.List.findIdxs_eq_nil_iff._proof_1_1 | Batteries.Data.List.Lemmas | ∀ {α : Type u_1} {p : α → Bool} {s : ℕ}, List.findIdxs p [] s = [] ↔ ∀ x ∈ [], p x = false |
MeasureTheory.Measure.instCompleteLattice._proof_2 | Mathlib.MeasureTheory.Measure.MeasureSpace | ∀ {α : Type u_1} {x : MeasurableSpace α} ⦃f : ℕ → Set α⦄,
(∀ (i : ℕ), MeasurableSet (f i)) → Pairwise (Function.onFun Disjoint f) → ⊤ (⋃ i, f i) = ∑' (i : ℕ), ⊤ (f i) |
Lean.Elab.Command.elabSyntax | Lean.Elab.Syntax | Lean.Syntax → Lean.Elab.Command.CommandElabM Lean.Name |
IsPGroup.orderOf_coprime | Mathlib.GroupTheory.PGroup | ∀ {p : ℕ} {G : Type u_1} [inst : Group G], IsPGroup p G → ∀ {n : ℕ}, p.Coprime n → ∀ (g : G), (orderOf g).Coprime n |
Complex.IsConservativeOn.isExactOn_ball | Mathlib.Analysis.Complex.HasPrimitives | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℂ E] {c : ℂ} {r : ℝ} {f : ℂ → E} [CompleteSpace E],
ContinuousOn f (Metric.ball c r) →
Complex.IsConservativeOn f (Metric.ball c r) → Complex.IsExactOn f (Metric.ball c r) |
Representation.asAlgebraHom._proof_1 | Mathlib.RepresentationTheory.Basic | ∀ {k : Type u_1} {V : Type u_2} [inst : CommSemiring k] [inst_1 : AddCommMonoid V] [inst_2 : Module k V],
SMulCommClass k k V |
neg_dotProduct_neg | Mathlib.Data.Matrix.Mul | ∀ {m : Type u_2} {α : Type v} [inst : Fintype m] [inst_1 : NonUnitalNonAssocRing α] (v w : m → α), -v ⬝ᵥ -w = v ⬝ᵥ w |
CommRingCat.isLimitForkPushoutSelfOfFaithfullyFlat._proof_11 | Mathlib.Algebra.Category.Ring.EqualizerPushout | ∀ {R S : CommRingCat} (f : R ⟶ S),
CategoryTheory.Limits.pushout.inl (CommRingCat.ofHom (algebraMap ↑R ↑S)) (CommRingCat.ofHom (algebraMap ↑R ↑S)) =
CategoryTheory.CategoryStruct.comp (CommRingCat.pushoutCocone ↑R ↑S ↑S).inl ⋯.isoPushout.hom |
Topology.CWComplex.mkFiniteType_cell | Mathlib.Topology.CWComplex.Classical.Finite | ∀ {X : Type u} [inst : TopologicalSpace X] (C : Set X) (cell : ℕ → Type u)
(map : (n : ℕ) → cell n → PartialEquiv (Fin n → ℝ) X) (finite_cell : ∀ (n : ℕ), Finite (cell n))
(source_eq : ∀ (n : ℕ) (i : cell n), (map n i).source = Metric.ball 0 1)
(continuousOn : ∀ (n : ℕ) (i : cell n), ContinuousOn (↑(map n i)) (Metric.closedBall 0 1))
(continuousOn_symm : ∀ (n : ℕ) (i : cell n), ContinuousOn (↑(map n i).symm) (map n i).target)
(pairwiseDisjoint' : Set.univ.PairwiseDisjoint fun ni => ↑(map ni.fst ni.snd) '' Metric.ball 0 1)
(mapsTo :
∀ (n : ℕ) (i : cell n),
Set.MapsTo (↑(map n i)) (Metric.sphere 0 1) (⋃ m, ⋃ (_ : m < n), ⋃ j, ↑(map m j) '' Metric.closedBall 0 1))
(closed' : ∀ A ⊆ C, (∀ (n : ℕ) (j : cell n), IsClosed (A ∩ ↑(map n j) '' Metric.closedBall 0 1)) → IsClosed A)
(union' : ⋃ n, ⋃ j, ↑(map n j) '' Metric.closedBall 0 1 = C) (n : ℕ), Topology.CWComplex.cell C n = cell n |
Fintype.balance_zero | Mathlib.Algebra.BigOperators.Balance | ∀ {ι : Type u_1} {G : Type u_4} [inst : Fintype ι] [inst_1 : AddCommGroup G] [inst_2 : Module ℚ≥0 G],
Fintype.balance 0 = 0 |
eq_mul_inv_of_mul_eq | Mathlib.Algebra.Group.Basic | ∀ {G : Type u_3} [inst : Group G] {a b c : G}, a * c = b → a = b * c⁻¹ |
Sum.not_inl_lt_inr | Mathlib.Data.Sum.Order | ∀ {α : Type u_1} {β : Type u_2} [inst : LT α] [inst_1 : LT β] {a : α} {b : β}, ¬Sum.inl b < Sum.inr a |
IsLocalization.localizationLocalizationSubmodule.eq_1 | Mathlib.RingTheory.Localization.LocalizationLocalization | ∀ {R : Type u_1} [inst : CommSemiring R] (M : Submonoid R) {S : Type u_2} [inst_1 : CommSemiring S]
[inst_2 : Algebra R S] (N : Submonoid S),
IsLocalization.localizationLocalizationSubmodule M N =
Submonoid.comap (algebraMap R S) (N ⊔ Submonoid.map (algebraMap R S) M) |
Set.diff_subset_diff_left | Mathlib.Order.BooleanAlgebra.Set | ∀ {α : Type u_1} {s₁ s₂ t : Set α}, s₁ ⊆ s₂ → s₁ \ t ⊆ s₂ \ t |
_private.Mathlib.Topology.ContinuousMap.Units.0.ContinuousMap.spectrum_eq_preimage_range._simp_1_1 | Mathlib.Topology.ContinuousMap.Units | ∀ {R : Type u} {A : Type v} [inst : CommSemiring R] [inst_1 : Ring A] [inst_2 : Algebra R A] {r : R} {a : A},
(r ∈ spectrum R a) = ¬IsUnit ((algebraMap R A) r - a) |
_private.Mathlib.Analysis.Convex.Between.0.Wbtw.trans_expand_left._proof_1_1 | Mathlib.Analysis.Convex.Between | ∀ {R : Type u_1} [inst : Field R] [inst_1 : LinearOrder R] [IsStrictOrderedRing R],
∀ t₁ ∈ Set.Icc 0 1, ∀ (t₂ : R), t₁ * t₂ ≤ 1 - t₁ + t₁ * t₂ |
Lean.IR.LogEntry.instToFormat | Lean.Compiler.IR.CompilerM | Std.ToFormat Lean.IR.LogEntry |
Lean.Lsp.TextEditBatch | Lean.Data.Lsp.Basic | Type |
CategoryTheory.Coreflective.mk | Mathlib.CategoryTheory.Adjunction.Reflective | {C : Type u₁} →
{D : Type u₂} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
[inst_1 : CategoryTheory.Category.{v₂, u₂} D] →
{L : CategoryTheory.Functor C D} →
[toFull : L.Full] →
[toFaithful : L.Faithful] → (R : CategoryTheory.Functor D C) → (L ⊣ R) → CategoryTheory.Coreflective L |
MeasureTheory.lintegral_strict_mono_of_ae_le_of_frequently_ae_lt | Mathlib.MeasureTheory.Integral.Lebesgue.Markov | ∀ {α : Type u_1} {mα : MeasurableSpace α} {μ : MeasureTheory.Measure α} {f g : α → ENNReal},
AEMeasurable g μ →
∫⁻ (x : α), f x ∂μ ≠ ⊤ → f ≤ᵐ[μ] g → (∃ᵐ (x : α) ∂μ, f x ≠ g x) → ∫⁻ (x : α), f x ∂μ < ∫⁻ (x : α), g x ∂μ |
iff_def | Init.Core | ∀ {a b : Prop}, (a ↔ b) ↔ (a → b) ∧ (b → a) |
_private.Mathlib.Analysis.PSeries.0.sum_Ioo_inv_sq_le._simp_1_11 | Mathlib.Analysis.PSeries | ∀ {G : Type u_1} [inst : DivInvMonoid G] (a : G), a⁻¹ = 1 / a |
CategoryTheory.Abelian.LeftResolution.ofCompIso | Mathlib.Algebra.Homology.LeftResolution.Transport | {A : Type u_1} →
{C : Type u_2} →
[inst : CategoryTheory.Category.{v_1, u_2} C] →
[inst_1 : CategoryTheory.Category.{v_2, u_1} A] →
{C' : Type u_4} →
[inst_2 : CategoryTheory.Category.{v_3, u_4} C'] →
{ι : CategoryTheory.Functor C A} →
CategoryTheory.Abelian.LeftResolution ι →
{ι' : CategoryTheory.Functor C' A} →
{G : CategoryTheory.Functor C C'} → (G.comp ι' ≅ ι) → CategoryTheory.Abelian.LeftResolution ι' |
CategoryTheory.ProjectivePresentation.projective | Mathlib.CategoryTheory.Preadditive.Projective.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X : C} (self : CategoryTheory.ProjectivePresentation X),
CategoryTheory.Projective self.p |
_private.Mathlib.MeasureTheory.Function.UnifTight.0.MeasureTheory.unifTight_iff_ennreal._simp_1_2 | Mathlib.MeasureTheory.Function.UnifTight | ∀ {r : NNReal}, (0 < ↑r) = (0 < r) |
Setoid.quotientQuotientEquivQuotient._proof_4 | Mathlib.Data.Setoid.Basic | ∀ {α : Type u_1} (r s : Setoid α) (h : r ≤ s) (x y : Quot ⇑r),
(Setoid.ker (Quot.mapRight h)) x y → Quotient.liftOn' x Quotient.mk'' ⋯ = Quotient.liftOn' y Quotient.mk'' ⋯ |
PMF.bind_pure_comp | Mathlib.Probability.ProbabilityMassFunction.Constructions | ∀ {α : Type u_1} {β : Type u_2} (f : α → β) (p : PMF α), p.bind (PMF.pure ∘ f) = PMF.map f p |
_private.Mathlib.Tactic.NormNum.Inv.0.Mathlib.Meta.NormNum.Result.inv._proof_2 | Mathlib.Tactic.NormNum.Inv | ∀ {u : Lean.Level} {α : Q(Type u)} (dsα : Q(DivisionSemiring «$α»)) (dα : Q(DivisionRing «$α»))
(__defeqres : PLift («$dsα» =Q DivisionRing.toDivisionSemiring)), «$dsα» =Q DivisionRing.toDivisionSemiring |
Lean.Syntax.SepArray.ofElemsUsingRef | Init.Meta.Defs | {m : Type → Type} → [Monad m] → [Lean.MonadRef m] → {sep : String} → Array Lean.Syntax → m (Lean.Syntax.SepArray sep) |
String.Pos.Raw.extract.go₁.match_1 | Init.Data.String.Basic | (motive : List Char → String.Pos.Raw → String.Pos.Raw → String.Pos.Raw → Sort u_1) →
(x : List Char) →
(x_1 x_2 x_3 : String.Pos.Raw) →
((x x_4 x_5 : String.Pos.Raw) → motive [] x x_4 x_5) →
((s : List Char) →
(c : Char) →
(cs : List Char) →
(h : s = c :: cs) → (i b e : String.Pos.Raw) → motive (namedPattern s (c :: cs) h) i b e) →
motive x x_1 x_2 x_3 |
CategoryTheory.StructuredArrow.createsLimitsOfShape | Mathlib.CategoryTheory.Limits.Comma | {J : Type w} →
[inst : CategoryTheory.Category.{w', w} J] →
{A : Type u₁} →
[inst_1 : CategoryTheory.Category.{v₁, u₁} A] →
{T : Type u₃} →
[inst_2 : CategoryTheory.Category.{v₃, u₃} T] →
{X : T} →
{G : CategoryTheory.Functor A T} →
[CategoryTheory.Limits.PreservesLimitsOfShape J G] →
CategoryTheory.CreatesLimitsOfShape J (CategoryTheory.StructuredArrow.proj X G) |
_private.Mathlib.GroupTheory.Perm.Centralizer.0.Equiv.Perm.Basis.injective._simp_1_3 | Mathlib.GroupTheory.Perm.Centralizer | ∀ {α : Type u_1} [inst : DecidableEq α] [inst_1 : Fintype α] {f : Equiv.Perm α} {x : α}, (f x ≠ x) = (x ∈ f.support) |
Equiv.Perm.mem_support_cycleOf_iff' | Mathlib.GroupTheory.Perm.Cycle.Factors | ∀ {α : Type u_2} {f : Equiv.Perm α} {x y : α},
f x ≠ x → ∀ [inst : DecidableEq α] [inst_1 : Fintype α], y ∈ (f.cycleOf x).support ↔ f.SameCycle x y |
Lean.Firefox.FuncTable.relevantForJS | Lean.Util.Profiler | Lean.Firefox.FuncTable → Array Lean.Json |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.