name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
String.toList.eq_1 | Init.Data.String.Basic | ∀ (s : String), s.toList = (String.Internal.toArray s).toList | true |
SchwartzMap.evalCLM._proof_3 | Mathlib.Analysis.Distribution.SchwartzSpace.Basic | ∀ (𝕜 : Type u_1) (G : Type u_2) [inst : NormedField 𝕜] [inst_1 : NormedAddCommGroup G] [inst_2 : NormedSpace 𝕜 G],
ContinuousConstSMul 𝕜 G | false |
CoxeterMatrix.ext | Mathlib.GroupTheory.Coxeter.Matrix | ∀ {B : Type u_1} {x y : CoxeterMatrix B}, x.M = y.M → x = y | true |
Invertible.mulRight | Mathlib.Algebra.Group.Invertible.Basic | {α : Type u} → [inst : Monoid α] → (a : α) → {b : α} → Invertible b → Invertible a ≃ Invertible (a * b) | true |
Multiset.right_notMem_Ioo | Mathlib.Order.Interval.Multiset | ∀ {α : Type u_1} [inst : Preorder α] [inst_1 : LocallyFiniteOrder α] {a b : α}, b ∉ Multiset.Ioo a b | true |
_private.Lean.Server.FileWorker.SetupFile.0.Lean.Server.FileWorker.runLakeSetupFile._sparseCasesOn_1 | Lean.Server.FileWorker.SetupFile | {motive : Lean.Lsp.DependencyBuildMode → Sort u} →
(t : Lean.Lsp.DependencyBuildMode) →
motive Lean.Lsp.DependencyBuildMode.never → (Nat.hasNotBit 4 t.ctorIdx → motive t) → motive t | false |
WeierstrassCurve.coe_variableChange_Δ' | Mathlib.AlgebraicGeometry.EllipticCurve.VariableChange | ∀ {R : Type u} [inst : CommRing R] (W : WeierstrassCurve R) (C : WeierstrassCurve.VariableChange R)
[inst_1 : W.IsElliptic], ↑(C • W).Δ' = ↑C.u⁻¹ ^ 12 * ↑W.Δ' | true |
Std.Tactic.BVDecide.LRAT.Internal.DefaultFormula.clearRupUnits | Std.Tactic.BVDecide.LRAT.Internal.Formula.Implementation | {n : ℕ} → Std.Tactic.BVDecide.LRAT.Internal.DefaultFormula n → Std.Tactic.BVDecide.LRAT.Internal.DefaultFormula n | true |
_private.Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.NonUnital.0._auto_452 | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.NonUnital | Lean.Syntax | false |
instDecidableEqZNum.decEq._proof_10 | Mathlib.Data.Num.Basic | ∀ (a b : PosNum), ¬a = b → ¬ZNum.neg a = ZNum.neg b | false |
AbstractCompletion.closure_range | Mathlib.Topology.UniformSpace.AbstractCompletion | ∀ {α : Type uα} [inst : UniformSpace α] (pkg : AbstractCompletion.{vα, uα} α), closure (Set.range pkg.coe) = Set.univ | true |
Lean.KVMap.entries | Lean.Data.KVMap | Lean.KVMap → List (Lean.Name × Lean.DataValue) | true |
ULift.leftCancelMonoid.eq_1 | Mathlib.Algebra.Group.ULift | ∀ {α : Type u} [inst : LeftCancelMonoid α],
ULift.leftCancelMonoid = Function.Injective.leftCancelMonoid ⇑Equiv.ulift ⋯ ⋯ ⋯ ⋯ | true |
Aesop.LocalRuleSet.simprocsArray | Aesop.RuleSet | Aesop.LocalRuleSet → Array (Lean.Name × Lean.Meta.Simprocs) | true |
isTotallyDisconnected_iff_lt | Mathlib.Topology.Order.IntermediateValue | ∀ {α : Type u} [inst : ConditionallyCompleteLinearOrder α] [inst_1 : TopologicalSpace α] [OrderTopology α]
[DenselyOrdered α] {s : Set α}, IsTotallyDisconnected s ↔ ∀ x ∈ s, ∀ y ∈ s, x < y → ∃ z ∉ s, z ∈ Set.Ioo x y | true |
LieModule.chainTop | Mathlib.Algebra.Lie.Weights.Chain | {R : Type u_1} →
{L : Type u_2} →
[inst : CommRing R] →
[inst_1 : LieRing L] →
[inst_2 : LieAlgebra R L] →
{M : Type u_3} →
[inst_3 : AddCommGroup M] →
[inst_4 : Module R M] →
[inst_5 : LieRingModule L M] →
[inst_6 : LieModule R L... | true |
_private.Mathlib.Analysis.Normed.Module.Alternating.Uncurry.Fin.0.ContinuousAlternatingMap.alternatizeUncurryFinCLM.aux._proof_10 | Mathlib.Analysis.Normed.Module.Alternating.Uncurry.Fin | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜], RingHomCompTriple (RingHom.id 𝕜) (RingHom.id 𝕜) (RingHom.id 𝕜) | false |
groupHomology.chains₁ToCoinvariantsKer | Mathlib.RepresentationTheory.Homological.GroupHomology.LowDegree | {k G : Type u} →
[inst : CommRing k] →
[inst_1 : Group G] →
(A : Rep.{u, u, u} k G) → ModuleCat.of k (G →₀ ↑A) ⟶ ModuleCat.of k ↥(Representation.Coinvariants.ker A.ρ) | true |
FreeSimplexQuiver.homRel.δ_comp_δ | Mathlib.AlgebraicTopology.SimplexCategory.GeneratorsRelations.Basic | ∀ {n : ℕ} {i j : Fin (n + 2)},
i ≤ j →
FreeSimplexQuiver.homRel
(CategoryTheory.CategoryStruct.comp ((CategoryTheory.Paths.of FreeSimplexQuiver).map (FreeSimplexQuiver.δ i))
((CategoryTheory.Paths.of FreeSimplexQuiver).map (FreeSimplexQuiver.δ j.succ)))
(CategoryTheory.CategoryStruct.comp ((Ca... | true |
CategoryTheory.HasLiftingProperty.transfiniteComposition.SqStruct.w₂ | Mathlib.CategoryTheory.SmallObject.TransfiniteCompositionLifting | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {J : Type w} [inst_1 : LinearOrder J] [inst_2 : OrderBot J]
{F : CategoryTheory.Functor J C} {c : CategoryTheory.Limits.Cocone F} {X Y : C} {p : X ⟶ Y} {f : F.obj ⊥ ⟶ X}
{g : c.pt ⟶ Y} {j : J} (self : CategoryTheory.HasLiftingProperty.transfiniteComposition.S... | true |
ContinuousMultilinearMap.norm_iteratedFDerivComponent_le | Mathlib.Analysis.Normed.Module.Multilinear.Basic | ∀ {𝕜 : Type u} {ι : Type v} {E₁ : ι → Type wE₁} {G : Type wG} [inst : NontriviallyNormedField 𝕜]
[inst_1 : (i : ι) → SeminormedAddCommGroup (E₁ i)] [inst_2 : (i : ι) → NormedSpace 𝕜 (E₁ i)]
[inst_3 : SeminormedAddCommGroup G] [inst_4 : NormedSpace 𝕜 G] [inst_5 : Fintype ι] {α : Type u_1}
[inst_6 : Fintype α] ... | true |
small_iff | Mathlib.Logic.Small.Defs | ∀ (α : Type v), Small.{w, v} α ↔ ∃ S, Nonempty (α ≃ S) | true |
_private.Mathlib.Algebra.Order.Star.Basic.0.MulOpposite.instStarOrderedRing._simp_1 | Mathlib.Algebra.Order.Star.Basic | ∀ {α : Type u_1} {β : Type u_2} {ι : Sort u_4} (g : α → β) (f : ι → α), g '' Set.range f = Set.range fun x => g (f x) | false |
Mathlib.Tactic.Widget.homType? | Mathlib.Tactic.Widget.CommDiag | Lean.Expr → Option (Lean.Expr × Lean.Expr) | true |
MulActionWithZero.toMulAction | Mathlib.Algebra.GroupWithZero.Action.Defs | {M₀ : Type u_2} →
{A : Type u_7} → {inst : MonoidWithZero M₀} → {inst_1 : Zero A} → [self : MulActionWithZero M₀ A] → MulAction M₀ A | true |
Vector.set._proof_1 | Init.Data.Vector.Basic | ∀ {α : Type u_1} {n : ℕ} (xs : Vector α n), ∀ i < n, i < xs.toArray.size | false |
subset_refl | Mathlib.Order.RelClasses | ∀ {α : Type u} [inst : HasSubset α] [Std.Refl fun x1 x2 => x1 ⊆ x2] (a : α), a ⊆ a | true |
MeromorphicOn.mono_set | Mathlib.Analysis.Meromorphic.Basic | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_3} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {f : 𝕜 → E} {U : Set 𝕜}, MeromorphicOn f U → ∀ {V : Set 𝕜}, V ⊆ U → MeromorphicOn f V | true |
Lean.Meta.Grind.AC.instInhabitedEqCnstr | Lean.Meta.Tactic.Grind.AC.Types | Inhabited Lean.Meta.Grind.AC.EqCnstr | true |
Std.Tactic.BVDecide.BVExpr.bitblast.blastConst._proof_4 | Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Const | ∀ {w : ℕ}, ∀ curr ≤ w, ¬curr < w → curr = w | false |
Lean.Meta.Config.assignSyntheticOpaque | Lean.Meta.Basic | Lean.Meta.Config → Bool | true |
IO.Error.permissionDenied.inj | Init.System.IOError | ∀ {filename : Option String} {osCode : UInt32} {details : String} {filename_1 : Option String} {osCode_1 : UInt32}
{details_1 : String},
IO.Error.permissionDenied filename osCode details = IO.Error.permissionDenied filename_1 osCode_1 details_1 →
filename = filename_1 ∧ osCode = osCode_1 ∧ details = details_1 | true |
Fin.natAdd_natAdd | Init.Data.Fin.Lemmas | ∀ (m n : ℕ) {p : ℕ} (i : Fin p), Fin.natAdd m (Fin.natAdd n i) = Fin.cast ⋯ (Fin.natAdd (m + n) i) | true |
AnalyticWithinAt.exists_hasFTaylorSeriesUpToOn | Mathlib.Analysis.Calculus.FDeriv.Analytic | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {F : Type v} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {f : E → F} {x : E}
{s : Set E} [CompleteSpace F] (n : WithTop ℕ∞),
AnalyticWithinAt 𝕜 f s x →
∃ u ∈ nhdsWith... | true |
MeasureTheory.AEEqFun.coeFn_posPart | Mathlib.MeasureTheory.Function.AEEqFun | ∀ {α : Type u_1} {γ : Type u_3} [inst : MeasurableSpace α] {μ : MeasureTheory.Measure α} [inst_1 : TopologicalSpace γ]
[inst_2 : LinearOrder γ] [inst_3 : OrderClosedTopology γ] [inst_4 : Zero γ] (f : α →ₘ[μ] γ),
↑f.posPart =ᵐ[μ] fun a => max (↑f a) 0 | true |
CategoryTheory.Bicategory.leftUnitor | Mathlib.CategoryTheory.Bicategory.Basic | {B : Type u} →
[self : CategoryTheory.Bicategory B] →
{a b : B} → (f : a ⟶ b) → CategoryTheory.CategoryStruct.comp (CategoryTheory.CategoryStruct.id a) f ≅ f | true |
CategoryTheory.shiftFunctorAdd'.eq_1 | Mathlib.CategoryTheory.Shift.Basic | ∀ (C : Type u) {A : Type u_1} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : AddMonoid A]
[inst_2 : CategoryTheory.HasShift C A] (i j k : A) (h : i + j = k),
CategoryTheory.shiftFunctorAdd' C i j k h = CategoryTheory.eqToIso ⋯ ≪≫ CategoryTheory.shiftFunctorAdd C i j | true |
_private.Mathlib.Combinatorics.SimpleGraph.Connectivity.Connected.0.SimpleGraph.ConnectedComponent.walk_toSimpleGraph._unary._proof_10 | Mathlib.Combinatorics.SimpleGraph.Connectivity.Connected | ∀ {V : Type u_1} {G : SimpleGraph V} {v : V} (u : V) (p : G.Walk u v), p ≍ p | false |
DivisibleHull.mk_add_mk | Mathlib.GroupTheory.DivisibleHull | ∀ {M : Type u_1} [inst : AddCommMonoid M] {m1 m2 : M} {s1 s2 : ℕ+},
DivisibleHull.mk m1 s1 + DivisibleHull.mk m2 s2 = DivisibleHull.mk (↑s2 • m1 + ↑s1 • m2) (s1 * s2) | true |
MulActionHom.instCommSemiring | Mathlib.GroupTheory.GroupAction.Hom | {M : Type u_2} →
{N : Type u_3} →
{X : Type u_4} →
{Y : Type u_5} →
{σ : M → N} →
[inst : SMul M X] →
[inst_1 : Monoid N] →
[inst_2 : CommSemiring Y] → [inst_3 : MulSemiringAction N Y] → CommSemiring (X →ₑ[σ] Y) | true |
CategoryTheory.Limits.ChosenPullback₃.hp₁._autoParam | Mathlib.CategoryTheory.Limits.Shapes.Pullback.ChosenPullback | Lean.Syntax | false |
LawfulBitraversable.mk | Mathlib.Control.Bitraversable.Basic | ∀ {t : Type u → Type u → Type u} [inst : Bitraversable t] [toLawfulBifunctor : LawfulBifunctor t],
(∀ {α β : Type u} (x : t α β), bitraverse pure pure x = pure x) →
(∀ {F G : Type u → Type u} [inst_1 : Applicative F] [inst_2 : Applicative G] [LawfulApplicative F]
[LawfulApplicative G] {α α' β β' γ γ' : Ty... | true |
unitary.linearIsometryEquiv_coe_symm_apply | Mathlib.Analysis.InnerProductSpace.Adjoint | ∀ {𝕜 : Type u_1} [inst : RCLike 𝕜] {H : Type u_5} [inst_1 : NormedAddCommGroup H] [inst_2 : InnerProductSpace 𝕜 H]
[inst_3 : CompleteSpace H] (e : H ≃ₗᵢ[𝕜] H), ↑(Unitary.linearIsometryEquiv.symm e) = ↑e.toContinuousLinearEquiv | true |
CategoryTheory.Pretriangulated.TriangleOpEquivalence.unitIso | Mathlib.CategoryTheory.Triangulated.Opposite.Triangle | (C : Type u_1) →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
[inst_1 : CategoryTheory.HasShift C ℤ] →
CategoryTheory.Functor.id (CategoryTheory.Pretriangulated.Triangle C)ᵒᵖ ≅
(CategoryTheory.Pretriangulated.TriangleOpEquivalence.functor C).comp
(CategoryTheory.Pretriangulated.Triangle... | true |
NonUnitalRingHom.rangeRestrict_surjective | Mathlib.RingTheory.NonUnitalSubring.Basic | ∀ {R : Type u} {S : Type v} [inst : NonUnitalNonAssocRing R] [inst_1 : NonUnitalNonAssocRing S] (f : R →ₙ+* S),
Function.Surjective ⇑f.rangeRestrict | true |
_private.Init.Data.Nat.Power2.Basic.0.Nat.nextPowerOfTwo.go._unary._proof_2 | Init.Data.Nat.Power2.Basic | ∀ (n power : ℕ) (h : power > 0),
power < n →
InvImage (fun x1 x2 => x1 < x2) (fun x => PSigma.casesOn x fun power h => n - power) ⟨power * 2, ⋯⟩ ⟨power, h⟩ | false |
LowerSet.sdiff_lt_left._simp_1 | Mathlib.Order.UpperLower.Closure | ∀ {α : Type u_1} [inst : Preorder α] {s : LowerSet α} {t : Set α}, (s.sdiff t < s) = ¬Disjoint (↑s) t | false |
GrpCat.instCreatesLimitsOfSizeUliftFunctor._proof_1 | Mathlib.Algebra.Category.Grp.Ulift | ∀ {J : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} J] {x : CategoryTheory.Functor J GrpCat},
CategoryTheory.Limits.HasLimit x | false |
WType._sizeOf_1 | Mathlib.Data.W.Basic | {α : Type u_1} → {β : α → Type u_2} → [SizeOf α] → [(a : α) → SizeOf (β a)] → WType β → ℕ | false |
Std.instDecidableEqRci | Init.Data.Range.Polymorphic.PRange | {α : Type u_1} → [DecidableEq α] → DecidableEq (Std.Rci α) | true |
Function.LeftInverse.rightInverse_of_surjective | Mathlib.Logic.Function.Basic | ∀ {α : Sort u_1} {β : Sort u_2} {f : α → β} {g : β → α},
Function.LeftInverse f g → Function.Surjective g → Function.RightInverse f g | true |
_private.Lean.Meta.Tactic.Grind.Proof.0.Lean.Meta.Grind.mkHCongrProof'._unsafe_rec | Lean.Meta.Tactic.Grind.Proof | Lean.Expr → Lean.Expr → ℕ → Lean.Expr → Lean.Expr → Bool → Lean.Meta.Grind.GoalM Lean.Expr | false |
BooleanSubalgebra.map._proof_3 | Mathlib.Order.BooleanSubalgebra | ∀ {α : Type u_2} {β : Type u_1} [inst : BooleanAlgebra α] [inst_1 : BooleanAlgebra β] (f : BoundedLatticeHom α β)
(L : BooleanSubalgebra α), SupClosed (⇑f '' ↑L) | false |
real_inner_I_smul_self | Mathlib.Analysis.InnerProductSpace.Basic | ∀ (𝕜 : Type u_1) {E : Type u_2} [inst : RCLike 𝕜] [inst_1 : SeminormedAddCommGroup E] [inst_2 : InnerProductSpace 𝕜 E]
(x : E), inner ℝ x (RCLike.I • x) = 0 | true |
CategoryTheory.sectionsFunctorNatIsoCoyoneda | Mathlib.CategoryTheory.Yoneda | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
(X : Type (max u₁ u₂)) →
[Unique X] →
CategoryTheory.Functor.sectionsFunctor C ≅
CategoryTheory.coyoneda.obj (Opposite.op ((CategoryTheory.Functor.const C).obj X)) | true |
WithOne | Mathlib.Algebra.Group.WithOne.Defs | Type u_1 → Type u_1 | true |
Representation.free | Mathlib.RepresentationTheory.Basic | (k : Type u_6) →
(G : Type u_7) → [inst : CommSemiring k] → [inst_1 : Monoid G] → (α : Type u_8) → Representation k G (α →₀ G →₀ k) | true |
Lean.Parser.Tactic.Grind.mbtc | Init.Grind.Interactive | Lean.ParserDescr | true |
Primrec.subtype_val_iff | Mathlib.Computability.Primrec.Basic | ∀ {α : Type u_1} {β : Type u_2} [inst : Primcodable α] [inst_1 : Primcodable β] {p : β → Prop}
[inst_2 : DecidablePred p] {hp : PrimrecPred p} {f : α → Subtype p}, (Primrec fun a => ↑(f a)) ↔ Primrec f | true |
Lean.Grind.CommRing.Poly.mulMonC.go | Init.Grind.Ring.CommSolver | ℤ → Lean.Grind.CommRing.Mon → ℕ → Lean.Grind.CommRing.Poly → Lean.Grind.CommRing.Poly | true |
Equiv.simpleGraph._proof_1 | Mathlib.Combinatorics.SimpleGraph.Maps | ∀ {V : Type u_1} {W : Type u_2} (e : V ≃ W) (x : SimpleGraph V),
SimpleGraph.comap (⇑e) (SimpleGraph.comap (⇑e.symm) x) = x | false |
Path.Homotopy.hcomp._proof_8 | Mathlib.Topology.Homotopy.Path | ∀ {X : Type u_1} [inst : TopologicalSpace X] {x₀ x₁ x₂ : X} {p₀ q₀ : Path x₀ x₁} {p₁ q₁ : Path x₁ x₂}
(F : p₀.Homotopy q₀) (G : p₁.Homotopy q₁),
Continuous fun x => if ↑x.2 ≤ 1 / 2 then (F.eval x.1).extend (2 * ↑x.2) else (G.eval x.1).extend (2 * ↑x.2 - 1) | false |
Std.DHashMap.Raw.Const.all_eq_false_iff_exists_mem_get | Std.Data.DHashMap.RawLemmas | ∀ {α : Type u} [inst : BEq α] [inst_1 : Hashable α] {β : Type v} {m : Std.DHashMap.Raw α fun x => β} [LawfulBEq α]
{p : α → β → Bool}, m.WF → (m.all p = false ↔ ∃ a, ∃ (h : a ∈ m), p a (Std.DHashMap.Raw.Const.get m a h) = false) | true |
Lean.Elab.Tactic.ElimApp.Result.motive | Lean.Elab.Tactic.Induction | Lean.Elab.Tactic.ElimApp.Result → Lean.MVarId | true |
ModularForm.coe_eq_zero_iff._simp_1 | Mathlib.NumberTheory.ModularForms.Basic | ∀ {Γ : Subgroup (GL (Fin 2) ℝ)} {k : ℤ} (f : ModularForm Γ k), (⇑f = 0) = (f = 0) | false |
Submodule.subtypeₗᵢ_toContinuousLinearMap | Mathlib.Analysis.Normed.Operator.LinearIsometry | ∀ {E : Type u_5} [inst : SeminormedAddCommGroup E] {R' : Type u_11} [inst_1 : Ring R'] [inst_2 : Module R' E]
(p : Submodule R' E), p.subtypeₗᵢ.toContinuousLinearMap = p.subtypeL | true |
Differential.logDeriv.eq_1 | Mathlib.FieldTheory.Differential.Basic | ∀ {R : Type u_1} [inst : Field R] [inst_1 : Differential R] (a : R), Differential.logDeriv a = a′ / a | true |
Array.toList_mapFinIdxM | Init.Data.Array.MapIdx | ∀ {m : Type u_1 → Type u_2} {α : Type u_3} {β : Type u_1} [inst : Monad m] [LawfulMonad m] {xs : Array α}
{f : (i : ℕ) → α → i < xs.size → m β}, Array.toList <$> xs.mapFinIdxM f = xs.toList.mapFinIdxM f | true |
IsCompact.exists_isGLB | Mathlib.Topology.Order.Compact | ∀ {α : Type u_2} [inst : LinearOrder α] [inst_1 : TopologicalSpace α] [ClosedIicTopology α] {s : Set α},
IsCompact s → s.Nonempty → ∃ x ∈ s, IsGLB s x | true |
_private.Init.Data.Nat.Basic.0.Nat.exists_eq_succ_of_ne_zero.match_1_1 | Init.Data.Nat.Basic | ∀ (motive : (x : ℕ) → x ≠ 0 → Prop) (x : ℕ) (x_1 : x ≠ 0), (∀ (n : ℕ) (x : n + 1 ≠ 0), motive n.succ x) → motive x x_1 | false |
CategoryTheory.ShortComplex.SnakeInput.Hom.comp | Mathlib.Algebra.Homology.ShortComplex.SnakeLemma | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
[inst_1 : CategoryTheory.Abelian C] →
{S₁ S₂ S₃ : CategoryTheory.ShortComplex.SnakeInput C} → S₁.Hom S₂ → S₂.Hom S₃ → S₁.Hom S₃ | true |
CategoryTheory.ReflPrefunctor.«_aux_Mathlib_Combinatorics_Quiver_ReflQuiver___macroRules_CategoryTheory_ReflPrefunctor_term_⥤rq__1» | Mathlib.Combinatorics.Quiver.ReflQuiver | Lean.Macro | false |
Nat.Pseudoperfect.eq_1 | Mathlib.NumberTheory.FactorisationProperties | ∀ (n : ℕ), n.Pseudoperfect = (0 < n ∧ ∃ s ⊆ n.properDivisors, ∑ i ∈ s, i = n) | true |
Finset.smul_sum | Mathlib.Algebra.BigOperators.GroupWithZero.Action | ∀ {M : Type u_1} {N : Type u_2} {γ : Type u_3} [inst : AddCommMonoid N] [inst_1 : DistribSMul M N] {r : M} {f : γ → N}
{s : Finset γ}, r • ∑ x ∈ s, f x = ∑ x ∈ s, r • f x | true |
OrderMonoidIso.val_inv_unitsWithZero_symm_apply | Mathlib.Algebra.Order.Hom.MonoidWithZero | ∀ {α : Type u_6} [inst : Group α] [inst_1 : Preorder α] (a : α), ↑(OrderMonoidIso.unitsWithZero.symm a)⁻¹ = (↑a)⁻¹ | true |
ContMDiffOn.clm_bundle_apply₂ | Mathlib.Geometry.Manifold.VectorBundle.Hom | ∀ {𝕜 : Type u_1} {B : Type u_2} {F₁ : Type u_3} {F₂ : Type u_4} {F₃ : Type u_5} {M : Type u_6}
[inst : NontriviallyNormedField 𝕜] {n : WithTop ℕ∞} {E₁ : B → Type u_7} [inst_1 : (x : B) → AddCommGroup (E₁ x)]
[inst_2 : (x : B) → Module 𝕜 (E₁ x)] [inst_3 : NormedAddCommGroup F₁] [inst_4 : NormedSpace 𝕜 F₁]
[ins... | true |
CategoryTheory.Limits.BinaryCofan.isColimitMk._proof_2 | Mathlib.CategoryTheory.Limits.Shapes.BinaryProducts | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {X Y W : C} {inl : X ⟶ W} {inr : Y ⟶ W}
(desc : (s : CategoryTheory.Limits.BinaryCofan X Y) → W ⟶ s.pt),
(∀ (s : CategoryTheory.Limits.BinaryCofan X Y) (m : W ⟶ s.pt),
CategoryTheory.CategoryStruct.comp inl m = s.inl →
CategoryTheory.Categ... | false |
Finsupp.lsingle_range_le_ker_lapply | Mathlib.LinearAlgebra.Finsupp.Span | ∀ {α : Type u_1} {M : Type u_2} {R : Type u_5} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
(s t : Set α), Disjoint s t → ⨆ a ∈ s, (Finsupp.lsingle a).range ≤ ⨅ a ∈ t, (Finsupp.lapply a).ker | true |
CategoryTheory.ShortComplex.homMk_τ₁ | Mathlib.Algebra.Homology.ShortComplex.Basic | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{S₁ S₂ : CategoryTheory.ShortComplex C} (τ₁ : S₁.X₁ ⟶ S₂.X₁) (τ₂ : S₁.X₂ ⟶ S₂.X₂) (τ₃ : S₁.X₃ ⟶ S₂.X₃)
(comm₁₂ : CategoryTheory.CategoryStruct.comp τ₁ S₂.f = CategoryTheory.CategoryStruct.comp S₁.f τ₂)... | true |
Matroid.IsCircuit.eq_fundCircuit_of_subset | Mathlib.Combinatorics.Matroid.Circuit | ∀ {α : Type u_1} {M : Matroid α} {C I : Set α} {e : α},
M.IsCircuit C → M.Indep I → C ⊆ insert e I → C = M.fundCircuit e I | true |
LieDerivation.exp_map_apply | Mathlib.Algebra.Lie.Derivation.Basic | ∀ {R : Type u_1} {L : Type u_2} [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : LieAlgebra R L]
[inst_3 : LieAlgebra ℚ L] (D : LieDerivation R L L) (h : IsNilpotent ↑D) (l : L), (D.exp h) l = (IsNilpotent.exp ↑D) l | true |
Lean.Elab.Structural.EqnInfo._sizeOf_1 | Lean.Elab.PreDefinition.Structural.Eqns | Lean.Elab.Structural.EqnInfo → ℕ | false |
Std.IterM.Equiv.of_morphism | Std.Data.Iterators.Lemmas.Equivalence.Basic | ∀ {α₁ α₂ : Type w} {m : Type w → Type w'} [inst : Monad m] [inst_1 : LawfulMonad m] {β : Type w}
[inst_2 : Std.Iterator α₁ m β] [inst_3 : Std.Iterator α₂ m β] (ita : Std.IterM m β)
(f : Std.IterM m β → Std.IterM m β),
(∀ (it : Std.IterM m β), (f it).stepAsHetT = Std.IterStep.mapIterator f <$> it.stepAsHetT) → ita... | true |
MonadReaderOf.read | Init.Prelude | {ρ : semiOutParam (Type u)} → {m : Type u → Type v} → [self : MonadReaderOf ρ m] → m ρ | true |
Ideal.Pure.eq_1 | Mathlib.RingTheory.Ideal.Pure | ∀ {R : Type u_1} [inst : CommRing R] (I : Ideal R), I.Pure = Module.Flat R (R ⧸ I) | true |
Asymptotics.transIsEquivalentIsLittleO | Mathlib.Analysis.Asymptotics.AsymptoticEquivalent | {α : Type u_1} →
{β : Type u_2} →
{β₂ : Type u_3} →
[inst : NormedAddCommGroup β] →
[inst_1 : Norm β₂] →
{l : Filter α} → Trans (Asymptotics.IsEquivalent l) (Asymptotics.IsLittleO l) (Asymptotics.IsLittleO l) | true |
CategoryTheory.PreOneHypercover.cylinder_X | Mathlib.CategoryTheory.Sites.Hypercover.Homotopy | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {S : C} {E : CategoryTheory.PreOneHypercover S}
{F : CategoryTheory.PreOneHypercover S} [inst_1 : CategoryTheory.Limits.HasPullbacks C] (f g : E.Hom F)
(p : (i : E.I₀) × F.I₁ (f.s₀ i) (g.s₀ i)),
(CategoryTheory.PreOneHypercover.cylinder f g).X p = CategoryT... | true |
CategoryTheory.CostructuredArrow.ιCompGrothendieckPrecompFunctorToCommaCompFst_hom_app | Mathlib.CategoryTheory.Comma.StructuredArrow.Functor | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
{E : Type u₃} [inst_2 : CategoryTheory.Category.{v₃, u₃} E] (L : CategoryTheory.Functor C D)
(R : CategoryTheory.Functor E D) (X : E) (X_1 : ↑((R.comp (CategoryTheory.CostructuredArrow.functor L))... | true |
Homeomorph.ext | Mathlib.Topology.Homeomorph.Defs | ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] {h h' : X ≃ₜ Y},
(∀ (x : X), h x = h' x) → h = h' | true |
Std.DHashMap.Internal.Raw₀.Const.getKeyD_filter | Std.Data.DHashMap.Internal.RawLemmas | ∀ {α : Type u} [inst : BEq α] [inst_1 : Hashable α] {β : Type v} (m : Std.DHashMap.Internal.Raw₀ α fun x => β)
[inst_2 : EquivBEq α] [inst_3 : LawfulHashable α] {f : α → β → Bool} {k fallback : α} (h : (↑m).WF),
(Std.DHashMap.Internal.Raw₀.filter f m).getKeyD k fallback =
((m.getKey? k).pfilter fun x h' => f x ... | true |
Submodule.IsLattice.smul | Mathlib.Algebra.Module.Lattice | ∀ {R : Type u_1} [inst : CommRing R] (A : Type u_2) [inst_1 : CommRing A] [inst_2 : Algebra R A] {V : Type u_3}
[inst_3 : AddCommGroup V] [inst_4 : Module R V] [inst_5 : Module A V] [inst_6 : IsScalarTower R A V]
(M : Submodule R V) [Submodule.IsLattice A M] (a : Aˣ), Submodule.IsLattice A (a • M) | true |
Algebra.Generators.localizationAway._proof_5 | Mathlib.RingTheory.Extension.Generators | ∀ {R : Type u_1} (S : Type u_2) [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S] (r : R)
[inst_3 : IsLocalization.Away r S],
algebraMap (MvPolynomial Unit R) S = ↑(MvPolynomial.aeval fun x => IsLocalization.Away.invSelf r) | false |
TensorProduct.mapOfCompatibleSMul | Mathlib.LinearAlgebra.TensorProduct.Basic | (R : Type u_1) →
[inst : CommSemiring R] →
(A : Type u_22) →
(S : Type u_23) →
(M : Type u_24) →
(N : Type u_25) →
[inst_1 : AddCommMonoid M] →
[inst_2 : AddCommMonoid N] →
[inst_3 : Module R M] →
[inst_4 : Module R N] →
... | true |
_private.Mathlib.Algebra.Homology.SpectralSequence.ComplexShape.0.ComplexShape.spectralSequenceFin._proof_4 | Mathlib.Algebra.Homology.SpectralSequence.ComplexShape | ∀ (l : ℕ) (u : ℤ × ℤ) {i i' j : ℤ × Fin l},
i.1 + u.1 = j.1 ∧ ↑↑i.2 + u.2 = ↑↑j.2 → i'.1 + u.1 = j.1 ∧ ↑↑i'.2 + u.2 = ↑↑j.2 → i.1 = i'.1 | false |
_private.Mathlib.Data.Nat.Factorial.Basic.0.Nat.pow_sub_le_descFactorial.match_1_1 | Mathlib.Data.Nat.Factorial.Basic | ∀ (motive : ℕ → Prop) (x : ℕ), (∀ (a : Unit), motive 0) → (∀ (k : ℕ), motive k.succ) → motive x | false |
BitVec.toNat_shiftConcat_eq_of_lt | Init.Data.BitVec.Lemmas | ∀ {w : ℕ} {x : BitVec w} {b : Bool} {k : ℕ}, k < w → x.toNat < 2 ^ k → (x.shiftConcat b).toNat = x.toNat * 2 + b.toNat | true |
CategoryTheory.Limits.MulticospanIndex.sectionsEquiv._proof_3 | Mathlib.CategoryTheory.Limits.Types.Multiequalizer | ∀ {J : CategoryTheory.Limits.MulticospanShape} (I : CategoryTheory.Limits.MulticospanIndex J (Type u_1))
(s : I.sections),
(fun i =>
match i with
| CategoryTheory.Limits.WalkingMulticospan.left i => s.val i
| CategoryTheory.Limits.WalkingMulticospan.right j => I.fst j (s.val (J.fst j))) ∈
I.mu... | false |
MeasureTheory.ComplexMeasure.absolutelyContinuous_ennreal_iff | Mathlib.MeasureTheory.Measure.Complex | ∀ {α : Type u_1} {m : MeasurableSpace α} (c : MeasureTheory.ComplexMeasure α)
(μ : MeasureTheory.VectorMeasure α ENNReal),
MeasureTheory.VectorMeasure.AbsolutelyContinuous c μ ↔
MeasureTheory.VectorMeasure.AbsolutelyContinuous (MeasureTheory.ComplexMeasure.re c) μ ∧
MeasureTheory.VectorMeasure.AbsolutelyC... | true |
IsSymmetricRel.iInter | Mathlib.Topology.UniformSpace.Defs | ∀ {α : Type ua} {ι : Sort u_1} {U : ι → SetRel α α}, (∀ (i : ι), IsSymmetricRel (U i)) → IsSymmetricRel (⋂ i, U i) | true |
_private.Lean.Compiler.LCNF.JoinPoints.0.Lean.Compiler.LCNF.JoinPointFinder.removeCandidatesInArg | Lean.Compiler.LCNF.JoinPoints | Lean.Compiler.LCNF.Arg Lean.Compiler.LCNF.Purity.pure → Lean.Compiler.LCNF.JoinPointFinder.FindM Unit | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.