name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M |
|---|---|---|
ProbabilityTheory.IsSFiniteKernel.casesOn | Mathlib.Probability.Kernel.Defs | {α : Type u_1} →
{β : Type u_2} →
{mα : MeasurableSpace α} →
{mβ : MeasurableSpace β} →
{κ : ProbabilityTheory.Kernel α β} →
{motive : ProbabilityTheory.IsSFiniteKernel κ → Sort u} →
(t : ProbabilityTheory.IsSFiniteKernel κ) →
((tsum_finite :
∃ κs, (∀ (n : ℕ), ProbabilityTheory.IsFiniteKernel (κs n)) ∧ κ = ProbabilityTheory.Kernel.sum κs) →
motive ⋯) →
motive t |
Besicovitch.exists_disjoint_closedBall_covering_ae_aux | Mathlib.MeasureTheory.Covering.Besicovitch | ∀ {α : Type u_1} [inst : MetricSpace α] [SecondCountableTopology α] [inst_2 : MeasurableSpace α]
[OpensMeasurableSpace α] [HasBesicovitchCovering α] (μ : MeasureTheory.Measure α) [MeasureTheory.SFinite μ]
(f : α → Set ℝ) (s : Set α),
(∀ x ∈ s, ∀ δ > 0, (f x ∩ Set.Ioo 0 δ).Nonempty) →
∃ t,
t.Countable ∧
(∀ p ∈ t, p.1 ∈ s) ∧
(∀ p ∈ t, p.2 ∈ f p.1) ∧
μ (s \ ⋃ p ∈ t, Metric.closedBall p.1 p.2) = 0 ∧ t.PairwiseDisjoint fun p => Metric.closedBall p.1 p.2 |
_private.Aesop.Builder.Unfold.0.Aesop.RuleBuilder.checkUnfoldableConst.match_1 | Aesop.Builder.Unfold | (motive : Option (Lean.Expr × Array Lean.Name) → Sort u_1) →
(unfoldResult : Option (Lean.Expr × Array Lean.Name)) →
(Unit → motive none) → ((e' : Lean.Expr) → (snd : Array Lean.Name) → motive (some (e', snd))) → motive unfoldResult |
StructureGroupoid.LocalInvariantProp.liftPropWithinAt_mono_of_mem_nhdsWithin | Mathlib.Geometry.Manifold.LocalInvariantProperties | ∀ {H : Type u_1} {M : Type u_2} {H' : Type u_3} {M' : Type u_4} [inst : TopologicalSpace H]
[inst_1 : TopologicalSpace M] [inst_2 : ChartedSpace H M] [inst_3 : TopologicalSpace H']
[inst_4 : TopologicalSpace M'] [inst_5 : ChartedSpace H' M'] {P : (H → H') → Set H → H → Prop} {g : M → M'}
{s t : Set M} {x : M},
(∀ ⦃s : Set H⦄ ⦃x : H⦄ ⦃t : Set H⦄ ⦃f : H → H'⦄, s ∈ nhdsWithin x t → P f s x → P f t x) →
ChartedSpace.LiftPropWithinAt P g s x → s ∈ nhdsWithin x t → ChartedSpace.LiftPropWithinAt P g t x |
CategoryTheory.InjectiveResolution.wrapped._@.Mathlib.CategoryTheory.Abelian.Injective.Resolution.4211954440._hygCtx._hyg.8 | Mathlib.CategoryTheory.Abelian.Injective.Resolution | Subtype (Eq @CategoryTheory.InjectiveResolution.definition✝) |
Std.instStreamIterOfProductiveOfIteratorAccessId._proof_1 | Init.Data.Iterators.Consumers.Stream | ∀ {α β : Type u_1} [inst : Std.Iterator α Id β] (it : Std.Iter β) (it_1 : Std.IterM Id β),
Std.IterM.IsPlausibleNthOutputStep 0 it.toIterM (Std.IterStep.skip it_1) → False |
_private.Batteries.CodeAction.Basic.0.Batteries.CodeAction.tacticCodeActionProvider._sparseCasesOn_14 | Batteries.CodeAction.Basic | {α : Type u} →
{motive : List α → Sort u_1} →
(t : List α) →
((head : α) → (tail : List α) → motive (head :: tail)) → (Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t |
_private.Mathlib.NumberTheory.Wilson.0.ZMod.wilsons_lemma._simp_1_1 | Mathlib.NumberTheory.Wilson | ∀ {M : Type u} [inst : Monoid M] (x : Mˣ), ↑x = (Units.coeHom M) x |
Finset.sum_disjUnion | Mathlib.Algebra.BigOperators.Group.Finset.Basic | ∀ {ι : Type u_1} {M : Type u_4} {s₁ s₂ : Finset ι} [inst : AddCommMonoid M] {f : ι → M} (h : Disjoint s₁ s₂),
∑ x ∈ s₁.disjUnion s₂ h, f x = ∑ x ∈ s₁, f x + ∑ x ∈ s₂, f x |
CategoryTheory.MorphismProperty.instIsStableUnderCobaseChangeFunctorFunctorCategoryOfHasPushouts | Mathlib.CategoryTheory.MorphismProperty.FunctorCategory | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {W : CategoryTheory.MorphismProperty C}
[W.IsStableUnderCobaseChange] (J : Type u'') [inst_2 : CategoryTheory.Category.{v'', u''} J]
[CategoryTheory.Limits.HasPushouts C], (W.functorCategory J).IsStableUnderCobaseChange |
CategoryTheory.Limits.hasCoequalizers_opposite | Mathlib.CategoryTheory.Limits.Shapes.Opposites.Equalizers | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.Limits.HasEqualizers C],
CategoryTheory.Limits.HasCoequalizers Cᵒᵖ |
Filter.eventually_atBot_curry | Mathlib.Order.Filter.AtTopBot.Prod | ∀ {α : Type u_3} {β : Type u_4} [inst : Preorder α] [inst_1 : Preorder β] {p : α × β → Prop},
(∀ᶠ (x : α × β) in Filter.atBot, p x) → ∀ᶠ (k : α) in Filter.atBot, ∀ᶠ (l : β) in Filter.atBot, p (k, l) |
_private.Init.Data.Array.Nat.0.Array.sum_eq_zero_iff_forall_eq_nat._simp_1_2 | Init.Data.Array.Nat | ∀ {xs : List ℕ}, (xs.sum = 0) = ∀ x ∈ xs, x = 0 |
Module.Presentation.CokernelData.recOn | Mathlib.Algebra.Module.Presentation.Cokernel | {A : Type u} →
[inst : Ring A] →
{M₁ : Type v₁} →
{M₂ : Type v₂} →
[inst_1 : AddCommGroup M₁] →
[inst_2 : Module A M₁] →
[inst_3 : AddCommGroup M₂] →
[inst_4 : Module A M₂] →
{pres₂ : Module.Presentation A M₂} →
{f : M₁ →ₗ[A] M₂} →
{ι : Type w₁} →
{g₁ : ι → M₁} →
{motive : pres₂.CokernelData f g₁ → Sort u_1} →
(t : pres₂.CokernelData f g₁) →
((lift : ι → pres₂.G →₀ A) →
(π_lift : ∀ (i : ι), pres₂.π (lift i) = f (g₁ i)) →
motive { lift := lift, π_lift := π_lift }) →
motive t |
_private.Init.Data.BitVec.Bitblast.0.BitVec.msb_smod._simp_1_2 | Init.Data.BitVec.Bitblast | ∀ {α : Type u_1} [inst : BEq α] [LawfulBEq α] {a b : α}, ((a == b) = true) = (a = b) |
Finset.addEnergy_univ_left | Mathlib.Combinatorics.Additive.Energy | ∀ {α : Type u_1} [inst : DecidableEq α] [inst_1 : AddCommGroup α] [inst_2 : Fintype α] (t : Finset α),
Finset.univ.addEnergy t = Fintype.card α * t.card ^ 2 |
_private.Init.Data.String.Slice.0.String.Slice.SplitIterator.finitenessRelation._proof_2 | Init.Data.String.Slice | ∀ {ρ : Type} {σ : String.Slice → Type}
[inst : (s : String.Slice) → Std.Iterator (σ s) Id (String.Slice.Pattern.SearchStep s)] {pat : ρ}
[inst_1 : String.Slice.Pattern.ToForwardSearcher pat σ] {s : String.Slice} {it it' : Std.IterM Id s.Subslice},
it'.IsPlausibleSuccessorOf it →
InvImage (Option.lt Std.Iter.IsPlausibleSuccessorOf)
(String.Slice.SplitIterator.toOption✝ ∘ Std.IterM.internalState) it' it |
_private.Lean.Meta.InferType.0.Lean.Meta.ArrowPropResult._sizeOf_1 | Lean.Meta.InferType | Lean.Meta.ArrowPropResult✝ → ℕ |
Finset.sum_eq_zero_iff_of_nonpos | Mathlib.Algebra.Order.BigOperators.Group.Finset | ∀ {ι : Type u_1} {N : Type u_5} [inst : AddCommMonoid N] [inst_1 : PartialOrder N] {f : ι → N} {s : Finset ι}
[AddLeftMono N], (∀ i ∈ s, f i ≤ 0) → (∑ i ∈ s, f i = 0 ↔ ∀ i ∈ s, f i = 0) |
_private.Mathlib.GroupTheory.Perm.Cycle.Type.0.Equiv.Perm.IsThreeCycle.nodup_iff_mem_support._proof_1_731 | Mathlib.GroupTheory.Perm.Cycle.Type | ∀ {α : Type u_1} [inst_1 : DecidableEq α] {g : Equiv.Perm α} {a : α} (w : α) (h_3 : ¬[g a, g (g a)].Nodup) (w_1 : α)
(h_5 : 2 ≤ List.count w_1 [g a, g (g a)]),
(List.findIdxs (fun x => decide (x = w_1)) [g a, g (g a)])[{g (g a)}.card] + 1 ≤
(List.findIdxs (fun x => decide (x = w_1)) [g a, g (g a)]).length →
(List.findIdxs (fun x => decide (x = w_1)) [g a, g (g a)])[{g (g a)}.card] <
(List.findIdxs (fun x => decide (x = w_1)) [g a, g (g a)]).length |
AlgebraicGeometry.SheafedSpace._sizeOf_inst | Mathlib.Geometry.RingedSpace.SheafedSpace | (C : Type u) → {inst : CategoryTheory.Category.{v, u} C} → [SizeOf C] → SizeOf (AlgebraicGeometry.SheafedSpace C) |
ConjAct.instGroupWithZero | Mathlib.Algebra.GroupWithZero.Action.ConjAct | {G₀ : Type u_2} → [GroupWithZero G₀] → GroupWithZero (ConjAct G₀) |
BoundedContinuousFunction.instSemilatticeInf._proof_3 | Mathlib.Topology.ContinuousMap.Bounded.Normed | ∀ {α : Type u_1} {β : Type u_2} [inst : TopologicalSpace α] [inst_1 : NormedAddCommGroup β] [inst_2 : Lattice β]
[inst_3 : HasSolidNorm β] [inst_4 : IsOrderedAddMonoid β] (a b : BoundedContinuousFunction α β), a ⊓ b ≤ a |
CategoryTheory.ShortComplex.Exact.leftHomologyDataOfIsLimitKernelFork._proof_1 | Mathlib.Algebra.Homology.ShortComplex.Exact | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Preadditive C]
{S : CategoryTheory.ShortComplex C} (kf : CategoryTheory.Limits.KernelFork S.g),
CategoryTheory.CategoryStruct.comp (CategoryTheory.Iso.refl kf.pt).hom
(CategoryTheory.Limits.Fork.ι (CategoryTheory.Limits.KernelFork.ofι (CategoryTheory.Limits.Fork.ι kf) ⋯)) =
CategoryTheory.Limits.Fork.ι kf |
Lean.Parser.Term.quot.formatter | Lean.Parser.Command | Lean.PrettyPrinter.Formatter |
Bimod.noConfusion | Mathlib.CategoryTheory.Monoidal.Bimod | {P : Sort u} →
{C : Type u₁} →
{inst : CategoryTheory.Category.{v₁, u₁} C} →
{inst_1 : CategoryTheory.MonoidalCategory C} →
{A B : CategoryTheory.Mon C} →
{t : Bimod A B} →
{C' : Type u₁} →
{inst' : CategoryTheory.Category.{v₁, u₁} C'} →
{inst'_1 : CategoryTheory.MonoidalCategory C'} →
{A' B' : CategoryTheory.Mon C'} →
{t' : Bimod A' B'} →
C = C' → inst ≍ inst' → inst_1 ≍ inst'_1 → A ≍ A' → B ≍ B' → t ≍ t' → Bimod.noConfusionType P t t' |
Real.rpow_def_of_nonneg | Mathlib.Analysis.SpecialFunctions.Pow.Real | ∀ {x : ℝ}, 0 ≤ x → ∀ (y : ℝ), x ^ y = if x = 0 then if y = 0 then 1 else 0 else Real.exp (Real.log x * y) |
Lean.Elab.Tactic.Omega.State.noConfusion | Lean.Elab.Tactic.Omega.OmegaM | {P : Sort u} → {t t' : Lean.Elab.Tactic.Omega.State} → t = t' → Lean.Elab.Tactic.Omega.State.noConfusionType P t t' |
Submodule.lt_sup_iff_notMem | Mathlib.LinearAlgebra.Span.Defs | ∀ {R : Type u_1} {M : Type u_4} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] {I : Submodule R M}
{a : M}, I < I ⊔ R ∙ a ↔ a ∉ I |
tsupport_add | Mathlib.Topology.Algebra.Support | ∀ {X : Type u_1} {α : Type u_2} [inst : TopologicalSpace X] [inst_1 : AddZeroClass α] (f g : X → α),
(tsupport fun x => f x + g x) ⊆ tsupport f ∪ tsupport g |
BialgHom.mk_coe | Mathlib.RingTheory.Bialgebra.Hom | ∀ {R : Type u_1} {A : Type u_2} {B : Type u_3} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Semiring B]
[inst_3 : Algebra R A] [inst_4 : Algebra R B] [inst_5 : CoalgebraStruct R A] [inst_6 : CoalgebraStruct R B]
{f : A →ₐc[R] B} (h₀ : ∀ (x y : A), f (x + y) = f x + f y)
(h₁ :
∀ (m : R) (x : A),
{ toFun := ⇑f, map_add' := h₀ }.toFun (m • x) = (RingHom.id R) m • { toFun := ⇑f, map_add' := h₀ }.toFun x)
(h₂ : CoalgebraStruct.counit ∘ₗ { toFun := ⇑f, map_add' := h₀, map_smul' := h₁ } = CoalgebraStruct.counit)
(h₃ :
TensorProduct.map { toFun := ⇑f, map_add' := h₀, map_smul' := h₁ }
{ toFun := ⇑f, map_add' := h₀, map_smul' := h₁ } ∘ₗ
CoalgebraStruct.comul =
CoalgebraStruct.comul ∘ₗ { toFun := ⇑f, map_add' := h₀, map_smul' := h₁ })
(h₄ : { toFun := ⇑f, map_add' := h₀, map_smul' := h₁, counit_comp := h₂, map_comp_comul := h₃ }.toFun 1 = 1)
(h₅ :
∀ (x y : A),
{ toFun := ⇑f, map_add' := h₀, map_smul' := h₁, counit_comp := h₂, map_comp_comul := h₃ }.toFun (x * y) =
{ toFun := ⇑f, map_add' := h₀, map_smul' := h₁, counit_comp := h₂, map_comp_comul := h₃ }.toFun x *
{ toFun := ⇑f, map_add' := h₀, map_smul' := h₁, counit_comp := h₂, map_comp_comul := h₃ }.toFun y),
{ toFun := ⇑f, map_add' := h₀, map_smul' := h₁, counit_comp := h₂, map_comp_comul := h₃, map_one' := h₄,
map_mul' := h₅ } =
f |
_private.Mathlib.Tactic.ApplyFun.0.Mathlib.Tactic.applyFunHyp.match_6 | Mathlib.Tactic.ApplyFun | (motive : Option Lean.Expr → Sort u_1) →
(using? : Option Lean.Expr) → ((r : Lean.Expr) → motive (some r)) → (Unit → motive none) → motive using? |
Lean.Meta.Grind.EMatchTheoremConstraint.depthLt | Lean.Meta.Tactic.Grind.Extension | ℕ → ℕ → Lean.Meta.Grind.EMatchTheoremConstraint |
_private.Mathlib.LinearAlgebra.Matrix.PosDef.0.Matrix.PosSemidef.smul._simp_1_1 | Mathlib.LinearAlgebra.Matrix.PosDef | ∀ {α : Type u_1} {β : Type u_2} {R : Type u_3} {M : Type u_5} [inst : Zero β] [inst_1 : AddCommMonoid M]
[inst_2 : DistribSMul R M] {v : α →₀ β} {c : R} {h : α → β → M}, (v.sum fun a b => c • h a b) = c • v.sum h |
enorm_pos | Mathlib.Analysis.Normed.Group.Basic | ∀ {E : Type u_8} [inst : TopologicalSpace E] [inst_1 : ENormedAddMonoid E] {a : E}, 0 < ‖a‖ₑ ↔ a ≠ 0 |
DoubleQuot.coe_quotQuotEquivQuotSupₐ_symm | Mathlib.RingTheory.Ideal.Quotient.Operations | ∀ (R : Type u) {A : Type u_1} [inst : CommSemiring R] [inst_1 : CommRing A] [inst_2 : Algebra R A] (I J : Ideal A),
⇑(DoubleQuot.quotQuotEquivQuotSupₐ R I J).symm = ⇑(DoubleQuot.quotQuotEquivQuotSup I J).symm |
_private.Init.Data.Slice.Array.Lemmas.0.Subarray.toList_mkSlice_rco._simp_1_2 | Init.Data.Slice.Array.Lemmas | ∀ {α : Type u_1} {xs : Array α}, xs.size = xs.toList.length |
LinearMap.BilinForm.apply_eq_dotProduct_toMatrix_mulVec | Mathlib.LinearAlgebra.Matrix.BilinearForm | ∀ {R₁ : Type u_1} {M₁ : Type u_2} [inst : CommSemiring R₁] [inst_1 : AddCommMonoid M₁] [inst_2 : Module R₁ M₁]
{n : Type u_5} [inst_3 : Fintype n] [inst_4 : DecidableEq n] (b : Module.Basis n R₁ M₁)
(B : LinearMap.BilinForm R₁ M₁) (x y : M₁),
(B x) y = ⇑(b.repr x) ⬝ᵥ ((LinearMap.BilinForm.toMatrix b) B).mulVec ⇑(b.repr y) |
_private.Mathlib.FieldTheory.AxGrothendieck.0.FirstOrder.realize_genericPolyMapSurjOnOfInjOn._simp_1_3 | Mathlib.FieldTheory.AxGrothendieck | ∀ {L : FirstOrder.Language} {M : Type w} [inst : L.Structure M] {α : Type u'} {β : Type v'} [inst_1 : Finite β]
{φ : L.Formula (α ⊕ β)} {v : α → M} {v' : Fin 0 → M},
FirstOrder.Language.BoundedFormula.Realize (FirstOrder.Language.Formula.iAlls β φ) v v' =
∀ (i : β → M), φ.Realize fun a => Sum.elim v i a |
LieRing.noConfusion | Mathlib.Algebra.Lie.Basic | {P : Sort u} →
{L : Type v} → {t : LieRing L} → {L' : Type v} → {t' : LieRing L'} → L = L' → t ≍ t' → LieRing.noConfusionType P t t' |
CategoryTheory.Limits.ColimitPresentation.map_diag | Mathlib.CategoryTheory.Limits.Presentation | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {J : Type w} [inst_1 : CategoryTheory.Category.{t, w} J]
{X : C} (P : CategoryTheory.Limits.ColimitPresentation J X) {D : Type u_1}
[inst_2 : CategoryTheory.Category.{v_1, u_1} D] (F : CategoryTheory.Functor C D)
[inst_3 : CategoryTheory.Limits.PreservesColimitsOfShape J F], (P.map F).diag = P.diag.comp F |
_private.Lean.Compiler.IR.LLVMBindings.0.LLVM.Builder.mk.injEq | Lean.Compiler.IR.LLVMBindings | ∀ {Context : Sort u_1} {ctx : Context} (ptr ptr_1 : USize), ({ ptr := ptr } = { ptr := ptr_1 }) = (ptr = ptr_1) |
Shrink.linearEquiv_apply | Mathlib.Algebra.Module.Shrink | ∀ (R : Type u_1) (α : Type u_2) [inst : Small.{v, u_2} α] [inst_1 : Semiring R] [inst_2 : AddCommMonoid α]
[inst_3 : Module R α] (a : Shrink.{v, u_2} α), (Shrink.linearEquiv R α) a = (equivShrink α).symm a |
_private.Mathlib.Probability.Process.Filtration.0.MeasureTheory.Filtration.instInfSet._simp_4 | Mathlib.Probability.Process.Filtration | ∀ {α : Sort u_1} {p : α → Prop} {q : (∃ x, p x) → Prop}, (∀ (h : ∃ x, p x), q h) = ∀ (x : α) (h : p x), q ⋯ |
SimpleGraph.CompleteEquipartiteSubgraph.ofCopy.match_7 | Mathlib.Combinatorics.SimpleGraph.CompleteMultipartite | ∀ {V : Type u_1} {G : SimpleGraph V} {r t : ℕ} (f : (SimpleGraph.completeEquipartiteGraph r t).Copy G) {p : Finset V}
(motive : (∃ a, Finset.map { toFun := fun j => f (a, j), inj' := ⋯ } Finset.univ = p) → Prop)
(h : ∃ a, Finset.map { toFun := fun j => f (a, j), inj' := ⋯ } Finset.univ = p),
(∀ (w : Fin r) (h : Finset.map { toFun := fun j => f (w, j), inj' := ⋯ } Finset.univ = p), motive ⋯) → motive h |
Mathlib.Tactic.FieldSimp.NF.instPowInt | Mathlib.Tactic.FieldSimp.Lemmas | {M : Type u_1} → Pow (Mathlib.Tactic.FieldSimp.NF M) ℤ |
CategoryTheory.Limits.WalkingReflexivePair.Hom.leftCompReflexion.elim | Mathlib.CategoryTheory.Limits.Shapes.Reflexive | {motive : (a a_1 : CategoryTheory.Limits.WalkingReflexivePair) → a.Hom a_1 → Sort u} →
{a a_1 : CategoryTheory.Limits.WalkingReflexivePair} →
(t : a.Hom a_1) →
t.ctorIdx = 3 →
motive CategoryTheory.Limits.WalkingReflexivePair.one CategoryTheory.Limits.WalkingReflexivePair.one
CategoryTheory.Limits.WalkingReflexivePair.Hom.leftCompReflexion →
motive a a_1 t |
AddMonoidAlgebra.mapDomain_single | Mathlib.Algebra.MonoidAlgebra.MapDomain | ∀ {R : Type u_2} {M : Type u_5} {N : Type u_6} [inst : Semiring R] {f : M → N} {a : M} {r : R},
AddMonoidAlgebra.mapDomain f (AddMonoidAlgebra.single a r) = AddMonoidAlgebra.single (f a) r |
_private.Batteries.Data.Char.AsciiCasing.0.Char.toUpper_toLower_eq_toUpper._proof_1_8 | Batteries.Data.Char.AsciiCasing | ∀ (c : Char), 65 ≤ c.toNat ∧ c.toNat ≤ 90 → ¬(c.toNat + 32).isValidChar → False |
_private.Mathlib.Algebra.Homology.DerivedCategory.Ext.ExtClass.0.CategoryTheory.ShortComplex.ShortExact.extClass_comp_assoc._proof_1_3 | Mathlib.Algebra.Homology.DerivedCategory.Ext.ExtClass | ∀ {n n' : ℕ} {h : 1 + n = n'}, 1 + 0 + n = n' |
Lean.RBNode.any._unsafe_rec | Lean.Data.RBMap | {α : Type u} → {β : α → Type v} → ((k : α) → β k → Bool) → Lean.RBNode α β → Bool |
Ordering.lt.elim | Init.Data.Ord.Basic | {motive : Ordering → Sort u} → (t : Ordering) → t.ctorIdx = 0 → motive Ordering.lt → motive t |
MulAut.conj._proof_1 | Mathlib.Algebra.Group.End | ∀ {G : Type u_1} [inst : Group G] (g x : G), (fun h => g⁻¹ * h * g) ((fun h => g * h * g⁻¹) x) = x |
FreeGroup.reduce_invRev_left_cancel | Mathlib.GroupTheory.FreeGroup.Reduce | ∀ {α : Type u_1} {L : List (α × Bool)} [inst : DecidableEq α], FreeGroup.reduce (FreeGroup.invRev L ++ L) = [] |
_private.Mathlib.MeasureTheory.VectorMeasure.BoundedVariation.0.BoundedVariationOn.vectorMeasure_Ioi._proof_1_2 | Mathlib.MeasureTheory.VectorMeasure.BoundedVariation | ∀ {E : Type u_1} [inst_7 : NormedAddCommGroup E], Nonempty E |
ContinuousCohomology.instLinearActionTopModuleCatInvariants | Mathlib.Algebra.Category.ContinuousCohomology.Basic | ∀ (R : Type u_1) (G : Type u_2) [inst : CommRing R] [inst_1 : Group G] [inst_2 : TopologicalSpace R],
CategoryTheory.Functor.Linear R (ContinuousCohomology.invariants R G) |
AddOreLocalization.addOreCondition.eq_1 | Mathlib.GroupTheory.OreLocalization.OreSet | ∀ {R : Type u_1} [inst : AddMonoid R] {S : AddSubmonoid R} [inst_1 : AddOreLocalization.AddOreSet S] (r : R) (s : ↥S),
AddOreLocalization.addOreCondition r s = ⟨AddOreLocalization.oreMin r s, ⟨AddOreLocalization.oreSubtra r s, ⋯⟩⟩ |
Nat.Partrec.rfind | Mathlib.Computability.Partrec | ∀ {f : ℕ →. ℕ}, Nat.Partrec f → Nat.Partrec fun a => Nat.rfind fun n => (fun m => decide (m = 0)) <$> f (Nat.pair a n) |
ProofWidgets.Penrose.DiagramProps.recOn | ProofWidgets.Component.PenroseDiagram | {motive : ProofWidgets.Penrose.DiagramProps → Sort u} →
(t : ProofWidgets.Penrose.DiagramProps) →
((embeds : Array (String × ProofWidgets.Html)) →
(dsl sty sub : String) →
(maxOptSteps : ℕ) →
motive { embeds := embeds, dsl := dsl, sty := sty, sub := sub, maxOptSteps := maxOptSteps }) →
motive t |
UInt8.mul_succ | Init.Data.UInt.Lemmas | ∀ {a b : UInt8}, a * (b + 1) = a * b + a |
_private.Mathlib.Order.Interval.Set.Pi.0.Set.Icc_diff_pi_univ_Ioc_subset._simp_1_2 | Mathlib.Order.Interval.Set.Pi | ∀ {ι : Type u_1} {π : ι → Type u_4} [inst : DecidableEq ι] [inst_1 : (i : ι) → Preorder (π i)] {x y : (i : ι) → π i}
{i : ι} {a : π i}, (x ≤ Function.update y i a) = (x i ≤ a ∧ ∀ (j : ι), j ≠ i → x j ≤ y j) |
_private.Mathlib.MeasureTheory.Measure.RegularityCompacts.0.MeasureTheory.innerRegularWRT_of_exists_compl_lt._simp_1_4 | Mathlib.MeasureTheory.Measure.RegularityCompacts | ∀ {a : Prop}, (a → a) = True |
_private.Mathlib.NumberTheory.Fermat.0.Nat.pow_pow_add_primeFactors_one_lt._simp_1_1 | Mathlib.NumberTheory.Fermat | ∀ {α : Type u_1} [inst : Semigroup α] {a b : α}, (a ∣ b) = ∃ c, b = a * c |
Std.Internal.List.containsKey_append | Std.Data.Internal.List.Associative | ∀ {α : Type u} {β : α → Type v} [inst : BEq α] {l l' : List ((a : α) × β a)} {a : α},
Std.Internal.List.containsKey a (l ++ l') = (Std.Internal.List.containsKey a l || Std.Internal.List.containsKey a l') |
ProbabilityTheory.Kernel.bound.eq_1 | Mathlib.Probability.Kernel.Defs | ∀ {α : Type u_1} {β : Type u_2} {mα : MeasurableSpace α} {mβ : MeasurableSpace β} (κ : ProbabilityTheory.Kernel α β),
κ.bound = ⨆ a, (κ a) Set.univ |
Std.ExtTreeSet.get?_diff | Std.Data.ExtTreeSet.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t₁ t₂ : Std.ExtTreeSet α cmp} [inst : Std.TransCmp cmp] {k : α},
(t₁ \ t₂).get? k = if k ∈ t₂ then none else t₁.get? k |
Module.AEval.mapSubmodule._proof_12 | Mathlib.Algebra.Polynomial.Module.AEval | ∀ (R : Type u_2) {A : Type u_3} (M : Type u_1) [inst : CommSemiring R] [inst_1 : Semiring A] (a : A)
[inst_2 : Algebra R A] [inst_3 : AddCommMonoid M] [inst_4 : Module A M] [inst_5 : Module R M]
[inst_6 : IsScalarTower R A M] (q : Submodule (Polynomial R) (Module.AEval R M a)),
(fun p =>
let __AddSubmonoid := AddSubmonoid.map (Module.AEval.of R M a) (↑p).toAddSubmonoid;
{ toAddSubmonoid := __AddSubmonoid, smul_mem' := ⋯ })
((fun q => ⟨(Submodule.orderIsoMapComap (Module.AEval.of R M a)).symm (Submodule.restrictScalars R q), ⋯⟩) q) =
q |
FormalMultilinearSeries.leftInv._proof_27 | Mathlib.Analysis.Analytic.Inverse | ∀ {F : Type u_1} [inst : NormedAddCommGroup F], ContinuousAdd F |
div_mul_eq_div_div_swap | Mathlib.Algebra.Group.Basic | ∀ {α : Type u_1} [inst : DivisionMonoid α] (a b c : α), a / (b * c) = a / c / b |
FirstOrder.Language.IsFraisse.FG | Mathlib.ModelTheory.Fraisse | ∀ {L : FirstOrder.Language} {K : Set (CategoryTheory.Bundled L.Structure)} [self : FirstOrder.Language.IsFraisse K],
∀ M ∈ K, FirstOrder.Language.Structure.FG L ↑M |
Finsupp.equivMapDomain._proof_3 | Mathlib.Data.Finsupp.Basic | ∀ {α : Type u_2} {β : Type u_1} {M : Type u_3} [inst : Zero M] (f : α ≃ β) (l : α →₀ M) (a : β),
a ∈ Finset.map f.toEmbedding l.support ↔ l (f.symm a) ≠ 0 |
Submodule.setLike._proof_1 | Mathlib.Algebra.Module.Submodule.Defs | ∀ {R : Type u_2} {M : Type u_1} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
(p q : Submodule R M), (fun s => s.carrier) p = (fun s => s.carrier) q → p = q |
IsLocalization.Away.instHMulAwayCoeRingHomAlgebraMap_1 | Mathlib.RingTheory.Localization.Away.Basic | ∀ {R : Type u_1} [inst : CommSemiring R] (S : Type u_2) [inst_1 : CommSemiring S] [inst_2 : Algebra R S] (x y : R)
[IsLocalization.Away x S], IsLocalization.Away (x * y) (Localization.Away ((algebraMap R S) y)) |
StarAlgEquiv.trans._proof_1 | Mathlib.Algebra.Star.StarAlgHom | ∀ {R : Type u_3} {A : Type u_4} {B : Type u_2} {C : Type u_1} [inst : Add A] [inst_1 : Add B] [inst_2 : Mul A]
[inst_3 : Mul B] [inst_4 : SMul R A] [inst_5 : SMul R B] [inst_6 : Star A] [inst_7 : Star B] [inst_8 : Add C]
[inst_9 : Mul C] [inst_10 : SMul R C] [inst_11 : Star C] (e₁ : A ≃⋆ₐ[R] B) (e₂ : B ≃⋆ₐ[R] C) (r : R) (a : A),
e₂.toFun (e₁.toFun (r • a)) = r • e₂.toFun (e₁.toFun a) |
IsCompl.map | Mathlib.Order.Hom.BoundedLattice | ∀ {F : Type u_1} {α : Type u_2} {β : Type u_3} [inst : Lattice α] [inst_1 : Lattice β] [inst_2 : FunLike F α β]
[inst_3 : BoundedOrder α] [inst_4 : BoundedOrder β] [BoundedLatticeHomClass F α β] {a b : α} (f : F),
IsCompl a b → IsCompl (f a) (f b) |
Lean.Meta.SynthInstance.Answer.mk.noConfusion | Lean.Meta.SynthInstance | {P : Sort u} →
{result : Lean.Meta.AbstractMVarsResult} →
{resultType : Lean.Expr} →
{size : ℕ} →
{result' : Lean.Meta.AbstractMVarsResult} →
{resultType' : Lean.Expr} →
{size' : ℕ} →
{ result := result, resultType := resultType, size := size } =
{ result := result', resultType := resultType', size := size' } →
(result = result' → resultType = resultType' → size = size' → P) → P |
Std.DTreeMap.getKeyGT | Std.Data.DTreeMap.AdditionalOperations | {α : Type u} →
{β : α → Type v} →
{cmp : α → α → Ordering} →
[Std.TransCmp cmp] → (t : Std.DTreeMap α β cmp) → (k : α) → (∃ a ∈ t, cmp a k = Ordering.gt) → α |
MeasureTheory.OuterMeasure.toMeasure_zero | Mathlib.MeasureTheory.Measure.MeasureSpace | ∀ {α : Type u_1} [ms : MeasurableSpace α] (h : ms ≤ MeasureTheory.OuterMeasure.caratheodory 0),
MeasureTheory.OuterMeasure.toMeasure 0 h = 0 |
_private.Mathlib.CategoryTheory.Dialectica.Basic.0.CategoryTheory.Dial.«termπ(_,_)» | Mathlib.CategoryTheory.Dialectica.Basic | Lean.ParserDescr |
MulEquiv.withOneCongr_trans | Mathlib.Algebra.Group.WithOne.Basic | ∀ {α : Type u} {β : Type v} {γ : Type w} [inst : Mul α] [inst_1 : Mul β] [inst_2 : Mul γ] (e₁ : α ≃* β) (e₂ : β ≃* γ),
e₁.withOneCongr.trans e₂.withOneCongr = (e₁.trans e₂).withOneCongr |
IsSymmOp.flip_eq | Mathlib.Logic.OpClass | ∀ {α : Sort u} {β : Sort v} (op : α → α → β) [IsSymmOp op], flip op = op |
AddOpposite.instNonAssocSemiring | Mathlib.Algebra.Ring.Opposite | {R : Type u_1} → [NonAssocSemiring R] → NonAssocSemiring Rᵃᵒᵖ |
UInt32.toUInt64_mod | Init.Data.UInt.Lemmas | ∀ (a b : UInt32), (a % b).toUInt64 = a.toUInt64 % b.toUInt64 |
ContinuousMultilinearMap.uncurryRight.eq_1 | Mathlib.Analysis.Normed.Module.Multilinear.Curry | ∀ {𝕜 : Type u} {n : ℕ} {Ei : Fin n.succ → Type wEi} {G : Type wG} [inst : NontriviallyNormedField 𝕜]
[inst_1 : (i : Fin n.succ) → NormedAddCommGroup (Ei i)] [inst_2 : (i : Fin n.succ) → NormedSpace 𝕜 (Ei i)]
[inst_3 : NormedAddCommGroup G] [inst_4 : NormedSpace 𝕜 G]
(f : ContinuousMultilinearMap 𝕜 (fun i => Ei i.castSucc) (Ei (Fin.last n) →L[𝕜] G)),
f.uncurryRight = ((ContinuousLinearMap.coeLM 𝕜).compMultilinearMap f.toMultilinearMap).uncurryRight.mkContinuous ‖f‖ ⋯ |
Lean.SimplePersistentEnvExtensionDescr.mk.noConfusion | Lean.EnvExtension | {α σ : Type} →
{P : Sort u} →
{name : autoParam Lean.Name Lean.SimplePersistentEnvExtensionDescr.name._autoParam} →
{addEntryFn : σ → α → σ} →
{addImportedFn : Array (Array α) → σ} →
{toArrayFn : List α → Array α} →
{exportEntriesFnEx? : Option (Lean.Environment → σ → List α → Lean.OLeanLevel → Array α)} →
{asyncMode : Lean.EnvExtension.AsyncMode} →
{replay? : Option (List α → σ → σ → List α × σ)} →
{name' : autoParam Lean.Name Lean.SimplePersistentEnvExtensionDescr.name._autoParam} →
{addEntryFn' : σ → α → σ} →
{addImportedFn' : Array (Array α) → σ} →
{toArrayFn' : List α → Array α} →
{exportEntriesFnEx?' : Option (Lean.Environment → σ → List α → Lean.OLeanLevel → Array α)} →
{asyncMode' : Lean.EnvExtension.AsyncMode} →
{replay?' : Option (List α → σ → σ → List α × σ)} →
{ name := name, addEntryFn := addEntryFn, addImportedFn := addImportedFn,
toArrayFn := toArrayFn, exportEntriesFnEx? := exportEntriesFnEx?,
asyncMode := asyncMode, replay? := replay? } =
{ name := name', addEntryFn := addEntryFn', addImportedFn := addImportedFn',
toArrayFn := toArrayFn', exportEntriesFnEx? := exportEntriesFnEx?',
asyncMode := asyncMode', replay? := replay?' } →
(name = name' →
addEntryFn ≍ addEntryFn' →
addImportedFn ≍ addImportedFn' →
toArrayFn ≍ toArrayFn' →
exportEntriesFnEx? ≍ exportEntriesFnEx?' →
asyncMode = asyncMode' → replay? ≍ replay?' → P) →
P |
CategoryTheory.ShortComplex.cyclesMap_smul | Mathlib.Algebra.Homology.ShortComplex.Linear | ∀ {R : Type u_1} {C : Type u_2} [inst : Semiring R] [inst_1 : CategoryTheory.Category.{v_1, u_2} C]
[inst_2 : CategoryTheory.Preadditive C] [inst_3 : CategoryTheory.Linear R C] {S₁ S₂ : CategoryTheory.ShortComplex C}
(φ : S₁ ⟶ S₂) (a : R) [inst_4 : S₁.HasLeftHomology] [inst_5 : S₂.HasLeftHomology],
CategoryTheory.ShortComplex.cyclesMap (a • φ) = a • CategoryTheory.ShortComplex.cyclesMap φ |
Submodule.IsCompl.projection_ker | Mathlib.LinearAlgebra.Projection | ∀ {R : Type u_1} [inst : Ring R] {E : Type u_2} [inst_1 : AddCommGroup E] [inst_2 : Module R E] {p q : Submodule R E}
(hpq : IsCompl p q), (Submodule.IsCompl.projection hpq).ker = q |
HomotopicalAlgebra.instModelCategoryOpposite._proof_6 | Mathlib.AlgebraicTopology.ModelCategory.Opposite | ∀ (C : Type u_2) [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : HomotopicalAlgebra.ModelCategory C],
(HomotopicalAlgebra.cofibrations Cᵒᵖ).IsStableUnderRetracts |
Lean.Doc.Parser.BlockCtxt._sizeOf_1 | Lean.DocString.Parser | Lean.Doc.Parser.BlockCtxt → ℕ |
CategoryTheory.Limits.WalkingPair.swap | Mathlib.CategoryTheory.Limits.Shapes.BinaryProducts | CategoryTheory.Limits.WalkingPair ≃ CategoryTheory.Limits.WalkingPair |
_private.Std.Time.Format.Basic.0.Std.Time.GenericFormat.DateBuilder.V | Std.Time.Format.Basic | Std.Time.GenericFormat.DateBuilder✝ → Option String |
ModelWithCorners.IsInteriorPoint | Mathlib.Geometry.Manifold.IsManifold.InteriorBoundary | {𝕜 : Type u_1} →
[inst : NontriviallyNormedField 𝕜] →
{E : Type u_2} →
[inst_1 : NormedAddCommGroup E] →
[inst_2 : NormedSpace 𝕜 E] →
{H : Type u_3} →
[inst_3 : TopologicalSpace H] →
ModelWithCorners 𝕜 E H → {M : Type u_4} → [inst : TopologicalSpace M] → [ChartedSpace H M] → M → Prop |
Array.getElem_zero_filterMap | Init.Data.Array.Find | ∀ {α : Type u_1} {β : Type u_2} {f : α → Option β} {xs : Array α} (h : 0 < (Array.filterMap f xs).size),
(Array.filterMap f xs)[0] = (Array.findSome? f xs).get ⋯ |
MeasureTheory.FiniteMeasure.normalize._proof_2 | Mathlib.MeasureTheory.Measure.ProbabilityMeasure | ∀ {Ω : Type u_1} [inst : Nonempty Ω] {m0 : MeasurableSpace Ω},
MeasureTheory.IsProbabilityMeasure (MeasureTheory.Measure.dirac inst.some) |
Set.Ici.codisjoint_iff | Mathlib.Order.LatticeIntervals | ∀ {α : Type u_1} [inst : SemilatticeSup α] [inst_1 : OrderTop α] {a : α} {x y : ↑(Set.Ici a)},
Codisjoint x y ↔ Codisjoint ↑x ↑y |
MulAction.toEndHom._proof_2 | Mathlib.Algebra.Group.Action.End | ∀ {M : Type u_2} {α : Type u_1} [inst : Monoid M] [inst_1 : MulAction M α] (x y : M),
(fun x2 => (x * y) • x2) = (fun x2 => x • x2) * fun x2 => y • x2 |
_private.Lean.Elab.StructInst.0.Lean.Elab.Term.StructInst.getStructName | Lean.Elab.StructInst | Option Lean.Expr → Lean.Elab.Term.StructInst.SourcesView → Lean.Elab.TermElabM (Lean.Name × Option Lean.Expr) |
ZetaAsymptotics.term_nonneg | Mathlib.NumberTheory.Harmonic.ZetaAsymp | ∀ (n : ℕ) (s : ℝ), 0 ≤ ZetaAsymptotics.term n s |
_private.Mathlib.AlgebraicTopology.SimplexCategory.Basic.0.SimplexCategory.diag_subinterval_eq.match_1_1 | Mathlib.AlgebraicTopology.SimplexCategory.Basic | ∀ (motive : Fin 2 → Prop) (i : Fin 2), (∀ (a : Unit), motive 0) → (∀ (a : Unit), motive 1) → motive i |
Lean.Lsp.InlayHintClientCapabilities.casesOn | Lean.Data.Lsp.LanguageFeatures | {motive : Lean.Lsp.InlayHintClientCapabilities → Sort u} →
(t : Lean.Lsp.InlayHintClientCapabilities) →
((dynamicRegistration? : Option Bool) →
(resolveSupport? : Option Lean.Lsp.ResolveSupport) →
motive { dynamicRegistration? := dynamicRegistration?, resolveSupport? := resolveSupport? }) →
motive t |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.