name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
Filter.add_bot | Mathlib.Order.Filter.Pointwise | ∀ {α : Type u_2} [inst : Add α] {f : Filter α}, f + ⊥ = ⊥ | true |
SSet.RelativeMorphism.Homotopy.postcomp_h | Mathlib.AlgebraicTopology.SimplicialSet.RelativeMorphism | ∀ {X Y Z : SSet} {A : X.Subcomplex} {B : Y.Subcomplex} {φ : A.toSSet ⟶ B.toSSet} {f g : SSet.RelativeMorphism A B φ}
{C : Z.Subcomplex} {ψ : B.toSSet ⟶ C.toSSet} (h : f.Homotopy g) (f' : SSet.RelativeMorphism B C ψ)
{φψ : A.toSSet ⟶ C.toSSet} (fac : CategoryTheory.CategoryStruct.comp φ ψ = φψ),
(h.postcomp f' fac... | true |
IsLocallyConstant.of_constant | Mathlib.Topology.LocallyConstant.Basic | ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] (f : X → Y), (∀ (x y : X), f x = f y) → IsLocallyConstant f | true |
_private.Mathlib.GroupTheory.SpecificGroups.Alternating.Centralizer.0.alternatingGroup.commutator_perm_le._simp_1_7 | Mathlib.GroupTheory.SpecificGroups.Alternating.Centralizer | ∀ {S : Type u_3} [inst : CommMagma S] (a b : S), Commute a b = True | false |
Set.eq_restrict_iff | Mathlib.Data.Set.Restrict | ∀ {α : Type u_1} {π : α → Type u_6} {s : Set α} {f : (a : ↑s) → π ↑a} {g : (a : α) → π a},
f = s.restrict g ↔ ∀ (a : α) (ha : a ∈ s), f ⟨a, ha⟩ = g a | true |
_private.Mathlib.RingTheory.Spectrum.Prime.ChevalleyComplexity.0.chevalley_mvPolynomial_mvPolynomial._simp_1_9 | Mathlib.RingTheory.Spectrum.Prime.ChevalleyComplexity | ∀ {R : Type u_2} {S : Type u_3} {σ : Type u_4} [inst : CommSemiring R] [inst_1 : CommSemiring S] [inst_2 : Module R S]
{M : Submodule R S} {p : MvPolynomial σ S},
(p ∈ MvPolynomial.coeffsIn σ M) = ∀ (i : σ →₀ ℕ), MvPolynomial.coeff i p ∈ M | false |
differentiableAt_iff_comp_const_sub | Mathlib.Analysis.Calculus.Deriv.Add | ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {F : Type v} [inst_1 : NormedAddCommGroup F]
[inst_2 : NormedSpace 𝕜 F] {f : 𝕜 → F} {a b : 𝕜},
DifferentiableAt 𝕜 f a ↔ DifferentiableAt 𝕜 (fun x => f (b - x)) (b - a) | true |
AlgEquiv.aut | Mathlib.Algebra.Algebra.Equiv | {R : Type uR} →
{A₁ : Type uA₁} → [inst : CommSemiring R] → [inst_1 : Semiring A₁] → [inst_2 : Algebra R A₁] → Group (A₁ ≃ₐ[R] A₁) | true |
CategoryTheory.SmallCategoryOfSet.mk.sizeOf_spec | Mathlib.CategoryTheory.SmallRepresentatives | ∀ {Ω : Type w} [inst : SizeOf Ω] (obj : Set Ω) (hom : ↑obj → ↑obj → Set Ω) (id : (X : ↑obj) → ↑(hom X X))
(comp : {X Y Z : ↑obj} → ↑(hom X Y) → ↑(hom Y Z) → ↑(hom X Z))
(id_comp :
autoParam (∀ {X Y : ↑obj} (f : ↑(hom X Y)), comp (id X) f = f) CategoryTheory.SmallCategoryOfSet.id_comp._autoParam)
(comp_id :
... | true |
ShrinkingLemma.PartialRefinement.mk.noConfusion | Mathlib.Topology.ShrinkingLemma | {ι : Type u_1} →
{X : Type u_2} →
{inst : TopologicalSpace X} →
{u : ι → Set X} →
{s : Set X} →
{p : Set X → Prop} →
{P : Sort u} →
{toFun : ι → Set X} →
{carrier : Set ι} →
{isOpen : ∀ (i : ι), IsOpen (toFun i)} →
... | false |
Lean.Meta.Canonicalizer.State | Lean.Meta.Canonicalizer | Type | true |
_private.Lean.Elab.PreDefinition.Structural.BRecOn.0.Lean.Elab.Structural.replaceRecApps.loop.match_8 | Lean.Elab.PreDefinition.Structural.BRecOn | (recArgInfos : Array Lean.Elab.Structural.RecArgInfo) →
(motive : Option (Fin recArgInfos.size) → Sort u_1) →
(x : Option (Fin recArgInfos.size)) →
((fnIdx : Fin recArgInfos.size) → motive (some fnIdx)) →
((x : Option (Fin recArgInfos.size)) → motive x) → motive x | false |
LieHom.coe_mk | Mathlib.Algebra.Lie.Basic | ∀ {R : Type u} {L₁ : Type v} {L₂ : Type w} [inst : CommRing R] [inst_1 : LieRing L₁] [inst_2 : LieAlgebra R L₁]
[inst_3 : LieRing L₂] [inst_4 : LieAlgebra R L₂] (f : L₁ → L₂) (h₁ : ∀ (x y : L₁), f (x + y) = f x + f y)
(h₂ :
∀ (m : R) (x : L₁),
{ toFun := f, map_add' := h₁ }.toFun (m • x) = (RingHom.id R) ... | true |
Lean.Meta.Sym.Simp.MethodsRef.toMethods | Lean.Meta.Sym.Simp.SimpM | Lean.Meta.Sym.Simp.MethodsRef → Lean.Meta.Sym.Simp.Methods | true |
groupHomology.d₁₀_comp_coinvariantsMk._simp_2 | Mathlib.RepresentationTheory.Homological.GroupHomology.LowDegree | ∀ (α : Type u) (p : α → Prop), (∀ (x : (CategoryTheory.forget (Type u)).obj α), p x) = ∀ (x : α), p x | false |
MeasureTheory.Integrable.uniformIntegrable_condExp | Mathlib.MeasureTheory.Function.ConditionalExpectation.Real | ∀ {α : Type u_1} {m0 : MeasurableSpace α} {μ : MeasureTheory.Measure α} {ι : Type u_2} [MeasureTheory.IsFiniteMeasure μ]
{g : α → ℝ},
MeasureTheory.Integrable g μ →
∀ {ℱ : ι → MeasurableSpace α}, (∀ (i : ι), ℱ i ≤ m0) → MeasureTheory.UniformIntegrable (fun i => μ[g | ℱ i]) 1 μ | true |
AddCommMagma | Mathlib.Algebra.Group.Defs | Type u → Type u | true |
CategoryTheory.Functor.CommShift₂.mk._flat_ctor | Mathlib.CategoryTheory.Shift.CommShiftTwo | {C₁ : Type u_1} →
{C₂ : Type u_3} →
{D : Type u_5} →
[inst : CategoryTheory.Category.{v_1, u_1} C₁] →
[inst_1 : CategoryTheory.Category.{v_3, u_3} C₂] →
[inst_2 : CategoryTheory.Category.{v_5, u_5} D] →
{M : Type u_6} →
[inst_3 : AddCommMonoid M] →
... | false |
Nat.Partrec'.below.comp | Mathlib.Computability.Halting | ∀ {motive : {n : ℕ} → (a : List.Vector ℕ n →. ℕ) → Nat.Partrec' a → Prop} {m n : ℕ} {f : List.Vector ℕ n →. ℕ}
(g : Fin n → List.Vector ℕ m →. ℕ) (a : Nat.Partrec' f) (a_1 : ∀ (i : Fin n), Nat.Partrec' (g i)),
Nat.Partrec'.below a →
motive f a → (∀ (i : Fin n), Nat.Partrec'.below ⋯) → (∀ (i : Fin n), motive (g ... | true |
FirstOrder.Language.BoundedFormula.realize_liftAt_one | Mathlib.ModelTheory.Semantics | ∀ {L : FirstOrder.Language} {M : Type w} [inst : L.Structure M] {α : Type u'} {n m : ℕ} {φ : L.BoundedFormula α n}
{v : α → M} {xs : Fin (n + 1) → M},
m ≤ n →
((FirstOrder.Language.BoundedFormula.liftAt 1 m φ).Realize v xs ↔
φ.Realize v (xs ∘ fun i => if ↑i < m then i.castSucc else i.succ)) | true |
Shrink.continuousLinearEquiv_symm_apply | Mathlib.Topology.Algebra.Module.TransferInstance | ∀ (R : Type u_1) (α : Type u_2) [inst : Small.{v, u_2} α] [inst_1 : AddCommMonoid α] [inst_2 : TopologicalSpace α]
[inst_3 : Semiring R] [inst_4 : Module R α] (a : α), (Shrink.continuousLinearEquiv R α).symm a = (equivShrink α) a | true |
Std.HashSet.get!_inter_of_not_mem_right | Std.Data.HashSet.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {m₁ m₂ : Std.HashSet α} [EquivBEq α] [LawfulHashable α]
[inst : Inhabited α] {k : α}, k ∉ m₂ → (m₁ ∩ m₂).get! k = default | true |
CategoryTheory.Functor.constComp | Mathlib.CategoryTheory.Functor.Const | (J : Type u₁) →
[inst : CategoryTheory.Category.{v₁, u₁} J] →
{C : Type u₂} →
[inst_1 : CategoryTheory.Category.{v₂, u₂} C] →
{D : Type u₃} →
[inst_2 : CategoryTheory.Category.{v₃, u₃} D] →
(X : C) →
(F : CategoryTheory.Functor C D) →
((CategoryThe... | true |
IncidenceAlgebra.moduleRight._proof_4 | Mathlib.Combinatorics.Enumerative.IncidenceAlgebra | ∀ {𝕜 : Type u_3} {𝕝 : Type u_1} {α : Type u_2} [inst : Preorder α] [inst_1 : Semiring 𝕜] [inst_2 : AddCommMonoid 𝕝]
[inst_3 : Module 𝕜 𝕝] (c : 𝕜) (f : IncidenceAlgebra 𝕝 α), ⇑(c • f) = c • ⇑f | false |
PreInnerProductSpace.Core.conj_inner_symm | Mathlib.Analysis.InnerProductSpace.Defs | ∀ {𝕜 : Type u_4} {F : Type u_5} [inst : RCLike 𝕜] [inst_1 : AddCommGroup F] [inst_2 : Module 𝕜 F]
(self : PreInnerProductSpace.Core 𝕜 F) (x y : F), (starRingEnd 𝕜) (inner 𝕜 y x) = inner 𝕜 x y | true |
CategoryTheory.Cat.chosenTerminalIsTerminal._proof_1 | Mathlib.CategoryTheory.Monoidal.Cartesian.Cat | ∀ (x : CategoryTheory.Cat) (x_1 : x ⟶ CategoryTheory.Cat.chosenTerminal), x_1 = x_1 | false |
AddHom.noConfusionType | Mathlib.Algebra.Group.Hom.Defs | Sort u →
{M : Type u_10} →
{N : Type u_11} →
[inst : Add M] →
[inst_1 : Add N] →
(M →ₙ+ N) → {M' : Type u_10} → {N' : Type u_11} → [inst' : Add M'] → [inst'_1 : Add N'] → (M' →ₙ+ N') → Sort u | false |
Std.DTreeMap.Internal.Impl.getKey!_inter!_of_contains_eq_false_left | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {instOrd : Ord α} {m₁ m₂ : Std.DTreeMap.Internal.Impl α β} [inst : Inhabited α]
[Std.TransOrd α],
m₁.WF → m₂.WF → ∀ {k : α}, Std.DTreeMap.Internal.Impl.contains k m₁ = false → (m₁.inter! m₂).getKey! k = default | true |
CategoryTheory.MonoidalCategory.Limits.preservesLimit_of_braided_and_preservesLimit_tensor_left | Mathlib.CategoryTheory.Monoidal.Limits.Preserves | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.MonoidalCategory C]
{J : Type u_2} [inst_2 : CategoryTheory.Category.{v_2, u_2} J] (F : CategoryTheory.Functor J C)
[CategoryTheory.BraidedCategory C] (c : C)
[CategoryTheory.Limits.PreservesLimit F (CategoryTheory.MonoidalCat... | true |
_private.Lean.Compiler.IR.SimpleGroundExpr.0.Lean.IR.getSimpleGroundExprWithResolvedRefs._sparseCasesOn_2 | Lean.Compiler.IR.SimpleGroundExpr | {motive : Lean.IR.SimpleGroundExpr → Sort u} →
(t : Lean.IR.SimpleGroundExpr) →
((n : Lean.Name) → motive (Lean.IR.SimpleGroundExpr.reference n)) →
(Nat.hasNotBit 16 t.ctorIdx → motive t) → motive t | false |
Module.Relations.Solution.casesOn | Mathlib.Algebra.Module.Presentation.Basic | {A : Type u} →
[inst : Ring A] →
{relations : Module.Relations A} →
{M : Type v} →
[inst_1 : AddCommGroup M] →
[inst_2 : Module A M] →
{motive : relations.Solution M → Sort u_1} →
(t : relations.Solution M) →
((var : relations.G → M) →
... | false |
Pi.rightCancelMonoid.eq_1 | Mathlib.Algebra.Group.Pi.Basic | ∀ {I : Type u} {f : I → Type v₁} [inst : (i : I) → RightCancelMonoid (f i)],
Pi.rightCancelMonoid =
{ toSemigroup := Pi.rightCancelSemigroup.toSemigroup, toOne := Pi.monoid.toOne, one_mul := ⋯, mul_one := ⋯,
npow := Monoid.npow, npow_zero := ⋯, npow_succ := ⋯, toIsRightCancelMul := ⋯ } | true |
Matroid.mem_closure_diff_singleton_iff_closure | Mathlib.Combinatorics.Matroid.Closure | ∀ {α : Type u_2} {M : Matroid α} {X : Set α} {e : α},
e ∈ X →
autoParam (e ∈ M.E) Matroid.mem_closure_diff_singleton_iff_closure._auto_1 →
(e ∈ M.closure (X \ {e}) ↔ M.closure (X \ {e}) = M.closure X) | true |
_private.Lean.Meta.Tactic.Grind.Types.0.Lean.Meta.Grind.PendingSolverPropagationsData._sizeOf_1 | Lean.Meta.Tactic.Grind.Types | Lean.Meta.Grind.PendingSolverPropagationsData✝ → ℕ | false |
Lean.Lsp.DeclarationParams.mk.inj | Lean.Data.Lsp.LanguageFeatures | ∀ {toTextDocumentPositionParams toTextDocumentPositionParams_1 : Lean.Lsp.TextDocumentPositionParams},
{ toTextDocumentPositionParams := toTextDocumentPositionParams } =
{ toTextDocumentPositionParams := toTextDocumentPositionParams_1 } →
toTextDocumentPositionParams = toTextDocumentPositionParams_1 | true |
FirstOrder.Language.LHom.onRelation | Mathlib.ModelTheory.LanguageMap | {L : FirstOrder.Language} → {L' : FirstOrder.Language} → (L →ᴸ L') → ⦃n : ℕ⦄ → L.Relations n → L'.Relations n | true |
Con.comap | Mathlib.GroupTheory.Congruence.Defs | {M : Type u_1} →
{N : Type u_2} →
[inst : Mul M] → [inst_1 : Mul N] → (f : M → N) → (∀ (x y : M), f (x * y) = f x * f y) → Con N → Con M | true |
CategoryTheory.Limits.biprod.isKernelSndKernelFork | Mathlib.CategoryTheory.Limits.Shapes.BinaryBiproducts | {C : Type uC} →
[inst : CategoryTheory.Category.{uC', uC} C] →
[inst_1 : CategoryTheory.Limits.HasZeroMorphisms C] →
(X Y : C) →
[inst_2 : CategoryTheory.Limits.HasBinaryBiproduct X Y] →
CategoryTheory.Limits.IsLimit (CategoryTheory.Limits.biprod.sndKernelFork X Y) | true |
_private.Mathlib.Algebra.Order.Archimedean.Class.0.ArchimedeanClass.mk_le_mk_iff_lt.match_1_1 | Mathlib.Algebra.Order.Archimedean.Class | ∀ {M : Type u_1} [inst : AddCommGroup M] [inst_1 : LinearOrder M] [inst_2 : IsOrderedAddMonoid M] {a b : M}
(motive : ArchimedeanClass.mk a ≤ ArchimedeanClass.mk b → Prop) (x : ArchimedeanClass.mk a ≤ ArchimedeanClass.mk b),
(∀ (n : ℕ) (hn : |ArchimedeanOrder.val (ArchimedeanOrder.of b)| ≤ n • |ArchimedeanOrder.val... | false |
Std.DTreeMap.Internal.Impl.minKeyD.match_1.congr_eq_1 | Std.Data.DTreeMap.Internal.Model | ∀ {α : Type u_1} {β : α → Type u_2} (motive : Std.DTreeMap.Internal.Impl α β → α → Sort u_3)
(x : Std.DTreeMap.Internal.Impl α β) (x_1 : α)
(h_1 : (fallback : α) → motive Std.DTreeMap.Internal.Impl.leaf fallback)
(h_2 :
(size : ℕ) →
(k : α) →
(v : β k) →
(r : Std.DTreeMap.Internal.Impl... | true |
Lean.Meta.Grind.CheckResult.ctorIdx | Lean.Meta.Tactic.Grind.CheckResult | Lean.Meta.Grind.CheckResult → ℕ | false |
_private.Mathlib.Algebra.Order.Ring.GeomSum.0.geom_sum_alternating_of_lt_neg_one._simp_1_2 | Mathlib.Algebra.Order.Ring.GeomSum | ∀ {α : Type u_2} [inst : AddMonoidWithOne α], Even 2 = True | false |
CategoryTheory.Lax.OplaxTrans.Hom.of.injEq | Mathlib.CategoryTheory.Bicategory.Modification.Lax | ∀ {B : Type u₁} [inst : CategoryTheory.Bicategory B] {C : Type u₂} [inst_1 : CategoryTheory.Bicategory C]
{F G : CategoryTheory.LaxFunctor B C} {η θ : F ⟶ G} (as as_1 : CategoryTheory.Lax.OplaxTrans.Modification η θ),
({ as := as } = { as := as_1 }) = (as = as_1) | true |
IsCoprime.mul_add_right_right | Mathlib.RingTheory.Coprime.Basic | ∀ {R : Type u} [inst : CommRing R] {x y : R}, IsCoprime x y → ∀ (z : R), IsCoprime x (z * x + y) | true |
Std.Time.Awareness.only.sizeOf_spec | Std.Time.Format.Basic | ∀ (a : Std.Time.TimeZone), sizeOf (Std.Time.Awareness.only a) = 1 + sizeOf a | true |
_private.Mathlib.Analysis.Normed.Unbundled.SmoothingSeminorm.0.μ_limsup_le_one._simp_1_4 | Mathlib.Analysis.Normed.Unbundled.SmoothingSeminorm | ∀ {α : Type u_1} [inst : LE α] {x y : α}, (x ≥ y) = (y ≤ x) | false |
_private.Init.Data.BitVec.Lemmas.0.BitVec.le_toNat_iff_getLsbD_eq_true._proof_1_1 | Init.Data.BitVec.Lemmas | ∀ {i : ℕ} (w : ℕ) {x : BitVec (w + 1)}, i < w + 1 → ¬w - i + (i + 1) = w + 1 → False | false |
AddGroupWithOne.noConfusion | Mathlib.Data.Int.Cast.Defs | {P : Sort u_1} →
{R : Type u} →
{t : AddGroupWithOne R} →
{R' : Type u} → {t' : AddGroupWithOne R'} → R = R' → t ≍ t' → AddGroupWithOne.noConfusionType P t t' | false |
RestrictedProduct.instGroupCoeOfSubgroupClass._proof_10 | Mathlib.Topology.Algebra.RestrictedProduct.Basic | ∀ {ι : Type u_1} (R : ι → Type u_2) {𝓕 : Filter ι} {S : ι → Type u_3} [inst : (i : ι) → SetLike (S i) (R i)]
{B : (i : ι) → S i} [inst_1 : (i : ι) → Group (R i)] [inst_2 : ∀ (i : ι), SubgroupClass (S i) (R i)]
(x : RestrictedProduct (fun i => R i) (fun i => ↑(B i)) 𝓕) (x_1 : ℤ), ⇑(x ^ x_1) = ⇑(x ^ x_1) | false |
HomologicalComplex.HomologySequence.snakeInput._proof_15 | Mathlib.Algebra.Homology.HomologySequence | ∀ {C : Type u_2} {ι : Type u_3} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Abelian C]
{c : ComplexShape ι} {S : CategoryTheory.ShortComplex (HomologicalComplex C c)} (i : ι), (S.X₁.sc i).HasHomology | false |
Equiv.image_symm_apply_coe | Mathlib.Logic.Equiv.Set | ∀ {α : Type u_3} {β : Type u_4} (e : α ≃ β) (s : Set α) (y : ↑(⇑e '' s)), ↑((e.image s).symm y) = e.symm ↑y | true |
Std.TreeSet.get_get? | Std.Data.TreeSet.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t : Std.TreeSet α cmp} [inst : Std.TransCmp cmp] {k : α}
{h : (t.get? k).isSome = true}, (t.get? k).get h = t.get k ⋯ | true |
_private.Mathlib.Geometry.Euclidean.Angle.Unoriented.TriangleInequality.0.InnerProductGeometry.angle_eq_angle_add_angle_iff._proof_1_7 | Mathlib.Geometry.Euclidean.Angle.Unoriented.TriangleInequality | ∀ {V : Type u_1} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V] {x y z : V},
0 ≤ Real.sin (InnerProductGeometry.angle x y) / ‖z‖ | false |
CategoryTheory.GrothendieckTopology.OneHypercoverFamily.IsSheafIff.lift._proof_2 | Mathlib.CategoryTheory.Sites.Hypercover.IsSheaf | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {J : CategoryTheory.GrothendieckTopology C} {X : C}
{S : CategoryTheory.Sieve X} {E : J.OneHypercover X}, E.sieve₀ ≤ S → ∀ (i : E.multicospanShape.L), S.arrows (E.f i) | false |
instCoeTailNatOfNatCast | Init.Data.Cast | {R : Type u_1} → [NatCast R] → CoeTail ℕ R | true |
Lean.Elab.TerminationHints._sizeOf_inst | Lean.Elab.PreDefinition.TerminationHint | SizeOf Lean.Elab.TerminationHints | false |
Set.image_prod | Mathlib.Data.Set.NAry | ∀ {α : Type u_1} {β : Type u_3} {γ : Type u_5} (f : α → β → γ) {s : Set α} {t : Set β},
(fun x => f x.1 x.2) '' s ×ˢ t = Set.image2 f s t | true |
AEMeasurable.sum_measure | Mathlib.MeasureTheory.Measure.AEMeasurable | ∀ {ι : Type u_1} {α : Type u_2} {β : Type u_3} {m0 : MeasurableSpace α} [inst : MeasurableSpace β] {f : α → β}
[Countable ι] {μ : ι → MeasureTheory.Measure α},
(∀ (i : ι), AEMeasurable f (μ i)) → AEMeasurable f (MeasureTheory.Measure.sum μ) | true |
Pi.single | Mathlib.Algebra.Notation.Pi.Basic | {ι : Type u_1} → {M : ι → Type u_6} → [(i : ι) → Zero (M i)] → [DecidableEq ι] → (i : ι) → M i → (j : ι) → M j | true |
CovBySMul.of_subset._simp_2 | Mathlib.Combinatorics.Additive.CovBySMul | ∀ {M : Type u_1} {X : Type u_3} [inst : Monoid M] [inst_1 : MulAction M X] {A B : Set X},
A ⊆ B → CovBySMul M 1 A B = True | false |
_private.Mathlib.MeasureTheory.Integral.DivergenceTheorem.0.MeasureTheory._aux_Mathlib_MeasureTheory_Integral_DivergenceTheorem___macroRules__private_Mathlib_MeasureTheory_Integral_DivergenceTheorem_0_MeasureTheory_termFrontFace__1 | Mathlib.MeasureTheory.Integral.DivergenceTheorem | Lean.Macro | false |
RingHom.eqLocus | Mathlib.Algebra.Ring.Subring.Basic | {R : Type u} → [inst : NonAssocRing R] → {S : Type v} → [inst_1 : Semiring S] → (R →+* S) → (R →+* S) → Subring R | true |
IntermediateField.extendScalars._proof_1 | Mathlib.FieldTheory.IntermediateField.Basic | ∀ {K : Type u_2} {L : Type u_1} [inst : Field K] [inst_1 : Field L] [inst_2 : Algebra K L]
{F E : IntermediateField K L}, F ≤ E → F.toSubfield ≤ E.toSubfield | false |
Turing.PartrecToTM2.K'.main.sizeOf_spec | Mathlib.Computability.TuringMachine.ToPartrec | sizeOf Turing.PartrecToTM2.K'.main = 1 | true |
connectedComponents_lift_unique' | Mathlib.Topology.Connected.TotallyDisconnected | ∀ {α : Type u} [inst : TopologicalSpace α] {β : Sort u_3} {g₁ g₂ : ConnectedComponents α → β},
g₁ ∘ ConnectedComponents.mk = g₂ ∘ ConnectedComponents.mk → g₁ = g₂ | true |
_private.Mathlib.Order.Filter.Bases.Basic.0.Filter.HasBasis.disjoint_iff_left._simp_1_1 | Mathlib.Order.Filter.Bases.Basic | ∀ {α : Type u_1} {f : Filter α} {s : Set α}, (sᶜ ∈ f) = Disjoint (Filter.principal s) f | false |
WeierstrassCurve.a₁_of_isCharNeTwoNF | Mathlib.AlgebraicGeometry.EllipticCurve.NormalForms | ∀ {R : Type u_1} [inst : CommRing R] (W : WeierstrassCurve R) [W.IsCharNeTwoNF], W.a₁ = 0 | true |
WType.rec | Mathlib.Data.W.Basic | {α : Type u_1} →
{β : α → Type u_2} →
{motive : WType β → Sort u} →
((a : α) → (f : β a → WType β) → ((a : β a) → motive (f a)) → motive (WType.mk a f)) → (t : WType β) → motive t | false |
_private.Init.Data.Array.InsertIdx.0.Array.getElem?_insertIdx_self._proof_1_1 | Init.Data.Array.InsertIdx | ∀ {α : Type u_1} {xs : Array α} {i : ℕ}, i < i → False | false |
ContinuousMul.casesOn | Mathlib.Topology.Algebra.Monoid.Defs | {M : Type u_1} →
[inst : TopologicalSpace M] →
[inst_1 : Mul M] →
{motive : ContinuousMul M → Sort u} →
(t : ContinuousMul M) → ((continuous_mul : Continuous fun p => p.1 * p.2) → motive ⋯) → motive t | false |
CategoryTheory.Limits.isLimitConeOfHasLimitCurryCompLim._proof_1 | Mathlib.CategoryTheory.Limits.Fubini | ∀ {J : Type u_6} {K : Type u_2} [inst : CategoryTheory.Category.{u_5, u_6} J]
[inst_1 : CategoryTheory.Category.{u_1, u_2} K] {C : Type u_4} [inst_2 : CategoryTheory.Category.{u_3, u_4} C]
(G : CategoryTheory.Functor (J × K) C) [CategoryTheory.Limits.HasLimitsOfShape K C] (j : J),
CategoryTheory.Limits.HasLimit (... | false |
MvPolynomial.weightedDecomposition | Mathlib.RingTheory.MvPolynomial.WeightedHomogeneous | (R : Type u_1) →
{M : Type u_2} →
[inst : CommSemiring R] →
{σ : Type u_3} →
(w : σ → M) →
[inst_1 : AddCommMonoid M] →
[inst_2 : DecidableEq M] → DirectSum.Decomposition (MvPolynomial.weightedHomogeneousSubmodule R w) | true |
WeierstrassCurve.Projective.addXYZ | Mathlib.AlgebraicGeometry.EllipticCurve.Projective.Formula | {R : Type r} → [CommRing R] → WeierstrassCurve.Projective R → (Fin 3 → R) → (Fin 3 → R) → Fin 3 → R | true |
ContinuousMultilinearMap.continuousMapClass | Mathlib.Topology.Algebra.Module.Multilinear.Basic | ∀ {R : Type u} {ι : Type v} {M₁ : ι → Type w₁} {M₂ : Type w₂} [inst : Semiring R]
[inst_1 : (i : ι) → AddCommMonoid (M₁ i)] [inst_2 : AddCommMonoid M₂] [inst_3 : (i : ι) → Module R (M₁ i)]
[inst_4 : Module R M₂] [inst_5 : (i : ι) → TopologicalSpace (M₁ i)] [inst_6 : TopologicalSpace M₂],
ContinuousMapClass (Conti... | true |
_private.Lean.Elab.Util.0.Lean.Elab.nestedExceptionToMessageData.match_1 | Lean.Elab.Util | (motive : Option String.Pos.Raw → Sort u_1) →
(x : Option String.Pos.Raw) → (Unit → motive none) → ((exPos : String.Pos.Raw) → motive (some exPos)) → motive x | false |
_private.Mathlib.LinearAlgebra.Matrix.GeneralLinearGroup.FinTwo.0.Matrix.sub_scalar_sq_eq_discr._simp_1_6 | Mathlib.LinearAlgebra.Matrix.GeneralLinearGroup.FinTwo | ∀ {G₀ : Type u_3} [inst : GroupWithZero G₀] {a : G₀} (n : ℤ), a ≠ 0 → (a ^ n = 0) = False | false |
Vector.getElem?_extract | Init.Data.Vector.Lemmas | ∀ {α : Type u_1} {n i : ℕ} {as : Vector α n} {start stop : ℕ},
(as.extract start stop)[i]? = if i < min stop n - start then as[start + i]? else none | true |
_private.Batteries.Data.AssocList.0.cond.match_1.eq_2 | Batteries.Data.AssocList | ∀ (motive : Bool → Sort u_1) (h_1 : Unit → motive true) (h_2 : Unit → motive false),
(match false with
| true => h_1 ()
| false => h_2 ()) =
h_2 () | true |
_private.Mathlib.CategoryTheory.Sites.Sieves.0.CategoryTheory.Presieve.uncurry_ofArrows._simp_1_1 | Mathlib.CategoryTheory.Sites.Sieves | ∀ {α : Type u} {ι : Sort u_1} {f : ι → α} {x : α}, (x ∈ Set.range f) = ∃ y, f y = x | false |
SummableUniformlyOn.exists | Mathlib.Topology.Algebra.InfiniteSum.UniformOn | ∀ {α : Type u_1} {β : Type u_2} {ι : Type u_3} [inst : AddCommMonoid α] {f : ι → β → α} {s : Set β}
[inst_1 : UniformSpace α], SummableUniformlyOn f s → ∃ g, HasSumUniformlyOn f g s | true |
_private.Init.Grind.ToInt.0.Lean.Grind.instBEqIntInterval.beq.eq_4 | Init.Grind.ToInt | Lean.Grind.instBEqIntInterval.beq Lean.Grind.IntInterval.ii Lean.Grind.IntInterval.ii = true | true |
_private.Lean.Compiler.LCNF.ElimDeadBranches.0.Lean.Compiler.LCNF.UnreachableBranches.Value.getLiteral.go | Lean.Compiler.LCNF.ElimDeadBranches | Lean.Compiler.LCNF.UnreachableBranches.Value →
Lean.Compiler.LCNF.CompilerM (Array (Lean.Compiler.LCNF.CodeDecl Lean.Compiler.LCNF.Purity.pure) × Lean.FVarId) | true |
Equiv.prodShear._proof_2 | Mathlib.Logic.Equiv.Prod | ∀ {α₁ : Type u_2} {α₂ : Type u_3} {β₁ : Type u_1} {β₂ : Type u_4} (e₁ : α₁ ≃ α₂) (e₂ : α₁ → β₁ ≃ β₂),
Function.LeftInverse (fun y => (e₁.symm y.1, (e₂ (e₁.symm y.1)).symm y.2)) fun x => (e₁ x.1, (e₂ x.1) x.2) | false |
CategoryTheory.braiding_rightUnitor_aux₂ | Mathlib.CategoryTheory.Monoidal.Braided.Basic | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.MonoidalCategory C]
[inst_2 : CategoryTheory.BraidedCategory C] (X : C),
CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCategoryStruct.whiskerLeft (CategoryTheory.MonoidalCategoryStruct.tensorUnit C)
(β_ (... | true |
Std.Internal.USquash.rec | Std.Data.Iterators.Lemmas.Equivalence.HetT | {α : Type v} →
[small : Std.Internal.Small α] →
{motive : Std.Internal.USquash α → Sort u_1} →
((inner : Std.Internal.ComputableSmall.Target α) → motive { inner := inner }) →
(t : Std.Internal.USquash α) → motive t | false |
_private.Mathlib.Order.Filter.Lift.0.Filter.lift'_neBot_iff._simp_1_1 | Mathlib.Order.Filter.Lift | ∀ {α : Type u} {s : Set α}, (Filter.principal s).NeBot = s.Nonempty | false |
coe_toIdeal | Mathlib.RingTheory.GradedAlgebra.Homogeneous.Ideal | ∀ {ι : Type u_1} {σ : Type u_2} {A : Type u_3} [inst : Semiring A] [inst_1 : SetLike σ A]
[inst_2 : AddSubmonoidClass σ A] {𝒜 : ι → σ} [inst_3 : DecidableEq ι] [inst_4 : AddMonoid ι] [inst_5 : GradedRing 𝒜]
(I : HomogeneousIdeal 𝒜), ↑I.toIdeal = ↑I | true |
Aesop.Script.TacticState.getVisibleGoalIndex? | Aesop.Script.TacticState | Aesop.Script.TacticState → Lean.MVarId → Option ℕ | true |
CategoryTheory.Cokleisli.Hom._sizeOf_inst | Mathlib.CategoryTheory.Monad.Kleisli | {C : Type u} →
{inst : CategoryTheory.Category.{v, u} C} →
{U : CategoryTheory.Comonad C} → (c c' : CategoryTheory.Cokleisli U) → [SizeOf C] → SizeOf (c.Hom c') | false |
_private.Mathlib.Topology.UniformSpace.Equicontinuity.0.Filter.HasBasis.uniformEquicontinuous_iff._simp_1_1 | Mathlib.Topology.UniformSpace.Equicontinuity | ∀ {α : Type u_1} {β : Type u_2} {p : α × β → Prop}, (∀ (x : α × β), p x) = ∀ (a : α) (b : β), p (a, b) | false |
_private.Init.Data.Array.Find.0.Array.idxOf.eq_1 | Init.Data.Array.Find | ∀ {α : Type u} [inst : BEq α] (a : α), Array.idxOf a = Array.findIdx fun x => x == a | true |
Std.DTreeMap.size_add_size_eq_size_union_add_size_inter | Std.Data.DTreeMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t₁ t₂ : Std.DTreeMap α β cmp} [Std.TransCmp cmp],
t₁.size + t₂.size = (t₁ ∪ t₂).size + (t₁ ∩ t₂).size | true |
HomologicalComplex.dgoToHomologicalComplex._proof_4 | Mathlib.Algebra.Homology.DifferentialObject | ∀ {β : Type u_3} [inst : AddCommGroup β] (b : β) (V : Type u_2) [inst_1 : CategoryTheory.Category.{u_1, u_2} V]
[inst_2 : CategoryTheory.Limits.HasZeroMorphisms V]
{X Y : CategoryTheory.DifferentialObject ℤ (CategoryTheory.GradedObjectWithShift b V)} (f : X ⟶ Y) (i j : β),
(ComplexShape.up' b).Rel i j →
Categ... | false |
SupBotHom.instSemilatticeSup | Mathlib.Order.Hom.BoundedLattice | {α : Type u_2} →
{β : Type u_3} →
[inst : Max α] →
[inst_1 : Bot α] → [inst_2 : SemilatticeSup β] → [inst_3 : OrderBot β] → SemilatticeSup (SupBotHom α β) | true |
IsRealClosed.mk._flat_ctor | Mathlib.FieldTheory.IsRealClosed.Basic | ∀ {R : Type u_1} [inst : Field R],
(∀ {s : R}, IsSumSq s → 1 + s ≠ 0) →
(∀ (x : R), IsSquare x ∨ IsSquare (-x)) → (∀ {f : Polynomial R}, Odd f.natDegree → ∃ x, f.IsRoot x) → IsRealClosed R | false |
CategoryTheory.WithTerminal.inclLift._proof_4 | Mathlib.CategoryTheory.WithTerminal.Basic | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {D : Type u_4}
[inst_1 : CategoryTheory.Category.{u_3, u_4} D] {Z : D} (F : CategoryTheory.Functor C D) (M : (x : C) → F.obj x ⟶ Z)
(hM : ∀ (x y : C) (f : x ⟶ y), CategoryTheory.CategoryStruct.comp (F.map f) (M y) = M x) ⦃X Y : C⦄ (f : X ⟶ Y),
Categor... | false |
_private.Mathlib.RingTheory.AdicCompletion.Noetherian.0.IsHausdorff.of_le_jacobson._simp_1_1 | Mathlib.RingTheory.AdicCompletion.Noetherian | ∀ {R : Type u_1} [inst : Ring R] {M : Type u_4} [inst_1 : AddCommGroup M] [inst_2 : Module R M] {U : Submodule R M}
{x : M}, (x ≡ 0 [SMOD U]) = (x ∈ U) | false |
HasCompactSupport.enorm_le_lintegral_Ici_deriv | Mathlib.MeasureTheory.Integral.IntegralEqImproper | ∀ {F : Type u_2} [inst : NormedAddCommGroup F] [inst_1 : NormedSpace ℝ F] {f : ℝ → F},
ContDiff ℝ 1 f → HasCompactSupport f → ∀ (x : ℝ), ‖f x‖ₑ ≤ ∫⁻ (y : ℝ) in Set.Iic x, ‖deriv f y‖ₑ | true |
starRingAut._proof_3 | Mathlib.Algebra.Star.Basic | ∀ {R : Type u_1} [inst : CommSemiring R] [inst_1 : StarRing R] (x y : R),
starMulAut.toFun (x * y) = starMulAut.toFun x * starMulAut.toFun y | false |
RightAddCosetEquivalence | Mathlib.GroupTheory.Coset.Basic | {α : Type u_1} → [Add α] → Set α → α → α → Prop | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.