name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
ModN.basis._proof_7 | Mathlib.LinearAlgebra.FreeModule.ModN | ∀ {G : Type u_1} [inst : AddCommGroup G] {n : ℕ} [NeZero n] {ι : Type u_2} (b : Module.Basis ι ℤ G)
(hker :
((LinearMap.lsmul ℤ G) ↑n).range ≤
(Finsupp.mapRange.linearMap (Int.castAddHom (ZMod n)).toIntLinearMap ∘ₗ ↑b.repr).ker),
Function.Injective
⇑(AddMonoidHom.toZModLinearMap n
(((Linea... | null | false |
deriv_neg_left_of_sign_deriv | Mathlib.Analysis.Calculus.DerivativeTest | ∀ {f : ℝ → ℝ} {x₀ : ℝ},
(∀ᶠ (x : ℝ) in nhdsWithin x₀ {x₀}ᶜ, SignType.sign (deriv f x) = SignType.sign (x - x₀)) →
∀ᶠ (b : ℝ) in nhdsWithin x₀ (Set.Iio x₀), deriv f b < 0 | null | true |
MeasureTheory.stoppedValue.congr_simp | Mathlib.Probability.Process.Stopping | ∀ {Ω : Type u_1} {β : Type u_2} {ι : Type u_3} [inst : Nonempty ι] (u u_1 : ι → Ω → β),
u = u_1 →
∀ (τ τ_1 : Ω → WithTop ι),
τ = τ_1 → ∀ (a a_1 : Ω), a = a_1 → MeasureTheory.stoppedValue u τ a = MeasureTheory.stoppedValue u_1 τ_1 a_1 | null | true |
_private.Aesop.Script.OptimizeSyntax.0.Aesop.optimizeFocusRenameI.match_1 | Aesop.Script.OptimizeSyntax | (motive : Option (Array (Lean.TSyntax `ident)) → Sort u_1) →
(x : Option (Array (Lean.TSyntax `ident))) →
((ns : Array (Lean.TSyntax `ident)) → motive (some ns)) → (Unit → motive none) → motive x | null | false |
_private.Mathlib.Data.Set.Insert.0.LE.le.ssubset_of_mem_notMem._proof_1_1 | Mathlib.Data.Set.Insert | ∀ {α : Type u_1} {s t : Set α} {a : α}, s ⊆ t → a ∈ t → a ∉ s → s ⊂ t | null | false |
SimpleGraph.Walk.takeUntil_takeUntil | Mathlib.Combinatorics.SimpleGraph.Walk.Decomp | ∀ {V : Type u} {G : SimpleGraph V} {v u : V} [inst : DecidableEq V] {w x : V} (p : G.Walk u v) (hw : w ∈ p.support)
(hx : x ∈ (p.takeUntil w hw).support), (p.takeUntil w hw).takeUntil x hx = p.takeUntil x ⋯ | null | true |
_private.Mathlib.RingTheory.Spectrum.Prime.FreeLocus.0.Module.rankAtStalk_eq_zero_iff_notMem_support._simp_1_1 | Mathlib.RingTheory.Spectrum.Prime.FreeLocus | ∀ (R : Type u) (M : Type v) [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] [StrongRankCondition R]
[Module.Finite R M], Module.rank R M = ↑(Module.finrank R M) | null | false |
EIO.adapt_pure | Batteries.Lean.LawfulMonadLift | ∀ {ε₁ ε₂ α : Type} (f : ε₁ → ε₂) (a : α), EIO.adapt f (pure a) = pure a | null | true |
AddGroup.isSimpleAddGroup_of_isCoatom | Mathlib.GroupTheory.QuotientGroup.Simple | ∀ {G : Type u_1} [inst : AddGroup G] {M : AddSubgroup G} [inst_1 : M.Normal], IsCoatom M → IsSimpleAddGroup (G ⧸ M) | null | true |
CategoryTheory.Functor.leibnizPushout_obj_obj | Mathlib.CategoryTheory.Limits.Shapes.Pullback.PullbackObjObj | ∀ {C₁ : Type u₁} {C₂ : Type u₂} {C₃ : Type u₃} [inst : CategoryTheory.Category.{v₁, u₁} C₁]
[inst_1 : CategoryTheory.Category.{v₂, u₂} C₂] [inst_2 : CategoryTheory.Category.{v₃, u₃} C₃]
(F : CategoryTheory.Functor C₁ (CategoryTheory.Functor C₂ C₃)) [inst_3 : CategoryTheory.Limits.HasPushouts C₃]
(f₁ : CategoryThe... | null | true |
Module.Injective.extension_property | Mathlib.Algebra.Module.Injective | ∀ (R : Type uR) [inst : Ring R] [Small.{uM, uR} R] (M : Type uM) [inst_2 : AddCommGroup M] [inst_3 : Module R M]
[inj : Module.Injective R M] (P : Type uP) [inst_4 : AddCommGroup P] [inst_5 : Module R P] (P' : Type uP')
[inst_6 : AddCommGroup P'] [inst_7 : Module R P'] (f : P →ₗ[R] P'),
Function.Injective ⇑f → ∀ ... | null | true |
Nat.ModEq.of_natCast | Mathlib.Data.Nat.ModEq | ∀ {M : Type u_1} [inst : AddCommMonoidWithOne M] [CharZero M] {a b n : ℕ}, ↑a ≡ ↑b [PMOD ↑n] → a ≡ b [MOD n] | **Alias** of the forward direction of `AddCommGroup.natCast_modEq_natCast`. | true |
RingQuot.Rel.sub_left | Mathlib.Algebra.RingQuot | ∀ {R : Type uR} [inst : Ring R] {r : R → R → Prop} ⦃a b c : R⦄, RingQuot.Rel r a b → RingQuot.Rel r (a - c) (b - c) | null | true |
CategoryTheory.Types.instPreservesColimitsOfSizeForgetTypeFun | Mathlib.CategoryTheory.Limits.ConcreteCategory.Basic | CategoryTheory.Limits.PreservesColimitsOfSize.{u_1, u_2, u, u, u + 1, u + 1} (CategoryTheory.forget (Type u)) | null | true |
Multiset.coe_countP | Mathlib.Data.Multiset.Count | ∀ {α : Type u_1} (p : α → Prop) [inst : DecidablePred p] (l : List α),
Multiset.countP p ↑l = List.countP (fun b => decide (p b)) l | null | true |
_private.Lean.Elab.BuiltinNotation.0.Lean.Elab.Term.elabPanic._regBuiltin.Lean.Elab.Term.elabPanic.declRange_3 | Lean.Elab.BuiltinNotation | IO Unit | null | false |
MeasurableEmbedding.schroederBernstein._proof_1 | Mathlib.MeasureTheory.MeasurableSpace.Embedding | ∀ {α : Type u_1} {β : Type u_2} {f : α → β} {g : β → α} {A B : Set α}, A ⊆ B → (g '' (f '' A)ᶜ)ᶜ ⊆ (g '' (f '' B)ᶜ)ᶜ | null | false |
DyckWord.rec | Mathlib.Combinatorics.Enumerative.DyckWord | {motive : DyckWord → Sort u} →
((toList : List DyckStep) →
(count_U_eq_count_D : List.count DyckStep.U toList = List.count DyckStep.D toList) →
(count_D_le_count_U :
∀ (i : ℕ), List.count DyckStep.D (List.take i toList) ≤ List.count DyckStep.U (List.take i toList)) →
motive
... | null | false |
SetLike.ext_iff | Mathlib.Basic.SetLike.Basic | ∀ {A : Type u_1} {B : Type u_2} [i : SetLike A B] {p q : A}, p = q ↔ ∀ (x : B), x ∈ p ↔ x ∈ q | null | true |
GromovHausdorff.repGHSpaceMetricSpace._aux_6 | Mathlib.Topology.MetricSpace.GromovHausdorff | {p : GromovHausdorff.GHSpace} → p.Rep → p.Rep → ENNReal | null | false |
_private.Mathlib.Algebra.Lie.Basis.Prod.0.LieAlgebra.Basis.prodCartanEquiv_aux._simp_1_1 | Mathlib.Algebra.Lie.Basis.Prod | ∀ {R : Type u_1} {R₂ : Type u_2} {M : Type u_5} {M₂ : Type u_6} [inst : Ring R] [inst_1 : Ring R₂]
[inst_2 : AddCommGroup M] [inst_3 : AddCommGroup M₂] [inst_4 : Module R M] [inst_5 : Module R₂ M₂] {τ₁₂ : R →+* R₂}
{f : M →ₛₗ[τ₁₂] M₂} {p : Submodule R M}, Set.InjOn ⇑f ↑p = Disjoint p f.ker | null | false |
Matroid.closure_subset_closure_iff_subset_closure._auto_1 | Mathlib.Combinatorics.Matroid.Closure | Lean.Syntax | null | false |
ISize.toNatClampNeg_ofIntClamp_of_lt | Init.Data.SInt.Lemmas | ∀ {n : ℤ}, n < 2 ^ 31 → (ISize.ofIntClamp n).toNatClampNeg = n.toNat | null | true |
ZFSet.empty_subset._simp_1 | Mathlib.SetTheory.ZFC.Basic | ∀ (x : ZFSet.{u}), (∅ ⊆ x) = True | null | false |
_private.Init.Data.Array.BinSearch.0.Array.binInsertAux._proof_12 | Init.Data.Array.BinSearch | ∀ {α : Type u_1} (as : Array α) (lo hi : Fin as.size), (↑lo + ↑hi) / 2 = ↑lo → ↑lo + 1 ≤ as.size | null | false |
_private.Batteries.Data.Array.Lemmas.0.Array.toList_swapIfInBounds._proof_1_16 | Batteries.Data.Array.Lemmas | ∀ {α : Type u_1} {i j : ℕ} {a : Array α} (i_1 : ℕ), i_1 = j → i + 1 ≤ a.toList.length → i < a.size | null | false |
_private.Mathlib.AlgebraicGeometry.EllipticCurve.Jacobian.Basic.0.WeierstrassCurve.Jacobian.equation_zero._simp_1_1 | Mathlib.AlgebraicGeometry.EllipticCurve.Jacobian.Basic | ∀ {R : Type r} [inst : CommRing R] {W' : WeierstrassCurve.Jacobian R} {P : Fin 3 → R},
P 2 = 0 → W'.Equation P = (P 1 ^ 2 = P 0 ^ 3) | null | false |
_private.Mathlib.Order.Filter.AtTopBot.Archimedean.0.Filter.Tendsto.atTop_mul_const_of_neg'._simp_1_1 | Mathlib.Order.Filter.AtTopBot.Archimedean | ∀ {α : Type u_1} {G : Type u_2} [inst : AddCommGroup G] [inst_1 : PartialOrder G] [IsOrderedAddMonoid G] {l : Filter α}
{f : α → G}, Filter.Tendsto (fun x => -f x) l Filter.atTop = Filter.Tendsto f l Filter.atBot | null | false |
AddCommGrpCat.leftExactFunctorForgetEquivalence.unitIsoAux._proof_2 | Mathlib.Algebra.Category.Grp.LeftExactFunctor | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Preadditive C]
[inst_2 : CategoryTheory.Limits.HasFiniteBiproducts C] (F : CategoryTheory.Functor C AddCommGrpCat)
[inst_3 : CategoryTheory.Limits.PreservesFiniteLimits F] (X : C),
CategoryTheory.CategoryStruct.comp CategoryTh... | null | false |
UpperSet.addCommSemigroup | Mathlib.Algebra.Order.UpperLower | {α : Type u_1} →
[inst : AddCommGroup α] → [inst_1 : Preorder α] → [IsOrderedAddMonoid α] → AddCommSemigroup (UpperSet α) | null | true |
NonUnitalContinuousFunctionalCalculus.recOn | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.NonUnital | {R : Type u_1} →
{A : Type u_2} →
{p : A → Prop} →
[inst : CommSemiring R] →
[inst_1 : Nontrivial R] →
[inst_2 : StarRing R] →
[inst_3 : MetricSpace R] →
[inst_4 : IsTopologicalSemiring R] →
[inst_5 : ContinuousStar R] →
[inst_6 :... | null | false |
Std.DHashMap.Internal.Raw₀.getD_inter | Std.Data.DHashMap.Internal.RawLemmas | ∀ {α : Type u} {β : α → Type v} [inst : BEq α] [inst_1 : Hashable α] {m₁ m₂ : Std.DHashMap.Internal.Raw₀ α β}
[inst_2 : LawfulBEq α],
(↑m₁).WF →
(↑m₂).WF →
∀ {k : α} {fallback : β k},
(m₁.inter m₂).getD k fallback = if m₂.contains k = true then m₁.getD k fallback else fallback | null | true |
CategoryTheory.Limits.coneOfIsSplitMono_π_app | Mathlib.CategoryTheory.Limits.Shapes.Equalizers | ∀ {C : Type u} {X Y : C} [inst : CategoryTheory.Category.{v, u} C] (f : X ⟶ Y) [inst_1 : CategoryTheory.IsSplitMono f]
(X_1 : CategoryTheory.Limits.WalkingParallelPair),
(CategoryTheory.Limits.coneOfIsSplitMono f).π.app X_1 =
CategoryTheory.Limits.WalkingParallelPair.casesOn (motive := fun t =>
X_1 = t →
... | null | true |
CategoryTheory.SmallObject.SuccStruct.ιIterationFunctor._proof_1 | Mathlib.CategoryTheory.SmallObject.TransfiniteIteration | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] (Φ : CategoryTheory.SmallObject.SuccStruct C)
(J : Type u_3) [inst_1 : LinearOrder J] [inst_2 : OrderBot J] [inst_3 : SuccOrder J] [inst_4 : WellFoundedLT J]
[inst_5 : CategoryTheory.Limits.HasIterationOfShape J C] (x x_1 : J) (f : x ⟶ x_1),
CategoryT... | null | false |
CategoryTheory.Limits.IsColimit.ofCoconeUncurry._proof_1 | Mathlib.CategoryTheory.Limits.Fubini | ∀ {J : Type u_2} {K : Type u_6} [inst : CategoryTheory.Category.{u_1, u_2} J]
[inst_1 : CategoryTheory.Category.{u_5, u_6} K] {C : Type u_4} [inst_2 : CategoryTheory.Category.{u_3, u_4} C]
{F : CategoryTheory.Functor J (CategoryTheory.Functor K C)} {D : CategoryTheory.Limits.DiagramOfCocones F}
(Q : (j : J) → Cat... | null | false |
_private.Mathlib.Data.Seq.Computation.0.Computation.BisimO.match_1.splitter._sparseCasesOn_5 | Mathlib.Data.Seq.Computation | {α : Type u} →
{β : Type v} →
{motive : α ⊕ β → Sort u_1} →
(t : α ⊕ β) → ((val : β) → motive (Sum.inr val)) → (Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t | null | false |
Lean.Doc.DeferredCheck.mk | Lean.DocString.DeferredCheck | Lean.Doc.DeferredCheckSite →
ℕ → String → Array Lean.Name → Lean.Name → List Lean.OpenDecl → Lean.Options → Dynamic → Lean.Doc.DeferredCheck | null | true |
CategoryTheory.Functor.mapProjectiveResolution._proof_4 | Mathlib.CategoryTheory.Preadditive.Projective.Resolution | ∀ {C : Type u_4} [inst : CategoryTheory.Category.{u_3, u_4} C] [inst_1 : CategoryTheory.Limits.HasZeroObject C]
[inst_2 : CategoryTheory.Preadditive C] {D : Type u_2} [inst_3 : CategoryTheory.Category.{u_1, u_2} D]
[inst_4 : CategoryTheory.Limits.HasZeroObject D] [inst_5 : CategoryTheory.Preadditive D]
[inst_6 : ... | null | false |
Plausible.Random.randBool | Plausible.Random | {m : Type → Type u_1} → [Monad m] → {g : Type} → [RandomGen g] → Plausible.RandGT g m Bool | Generate a random `Bool`.
| true |
Finsupp.mapRange.addEquiv_toEquiv | Mathlib.Algebra.Group.Finsupp | ∀ {ι : Type u_1} {M : Type u_3} {N : Type u_4} [inst : AddCommMonoid M] [inst_1 : AddCommMonoid N] (e : M ≃+ N),
↑(Finsupp.mapRange.addEquiv e) = Finsupp.mapRange.equiv ↑e ⋯ | null | true |
Projectivization.Subspace.mem_submodule_iff | Mathlib.LinearAlgebra.Projectivization.Subspace | ∀ {K : Type u_1} {V : Type u_2} [inst : DivisionRing K] [inst_1 : AddCommGroup V] [inst_2 : Module K V]
(s : Projectivization.Subspace K V) {v : V} (hv : v ≠ 0),
v ∈ Projectivization.Subspace.submodule s ↔ Projectivization.mk K v hv ∈ s | null | true |
_private.Batteries.Data.Array.Scan.0.Array.take_scanl._proof_1_3 | Batteries.Data.Array.Scan | ∀ {β : Type u_1} {α : Type u_2} {i : ℕ} {f : β → α → β} (init : β) (as : Array α),
-1 * ↑as.size + 1 ≤ 0 →
i + 1 = (Array.scanl f init as).size - 1 →
i = as.size - 1 →
∀ (w : ℕ),
w + 1 ≤ ((Array.scanl f init as).extract 0 (i + 1)).size → w < (Array.scanl f init (as.extract 0 i)).size | null | false |
CategoryTheory.Functor.lanCompColimIso._proof_2 | Mathlib.CategoryTheory.Functor.KanExtension.Adjunction | ∀ {C : Type u_5} {D : Type u_2} [inst : CategoryTheory.Category.{u_6, u_5} C]
[inst_1 : CategoryTheory.Category.{u_1, u_2} D] (L : CategoryTheory.Functor C D) {H : Type u_4}
[inst_2 : CategoryTheory.Category.{u_3, u_4} H] [inst_3 : ∀ (F : CategoryTheory.Functor C H), L.HasLeftKanExtension F]
[CategoryTheory.Limit... | null | false |
CategoryTheory.Span.SpanBicat.mkHom₂._proof_2 | Mathlib.CategoryTheory.Bicategory.Span.Basic | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {Wₗ Wᵣ : CategoryTheory.MorphismProperty C}
[inst_1 : Wₗ.ContainsIdentities] [inst_2 : Wᵣ.ContainsIdentities] [inst_3 : Wₗ.HasPullbacksAgainst Wᵣ]
[inst_4 : Wₗ.IsStableUnderBaseChangeAgainst Wᵣ] [inst_5 : Wᵣ.IsStableUnderBaseChangeAgainst Wₗ]
[inst_6 ... | null | false |
Finset.singletonAddHom | Mathlib.Algebra.Group.Pointwise.Finset.Basic | {α : Type u_2} → [inst : DecidableEq α] → [inst_1 : Add α] → α →ₙ+ Finset α | The singleton operation as an `AddHom`. | true |
Lean.IR.CollectUsedDecls.State.order._default | Lean.Compiler.IR.EmitUtil | Array Lean.Name | null | false |
HomotopyCategory.shift_quotient_obj | Mathlib.Algebra.Homology.HomotopyCategory.Shift | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Preadditive C]
(K : HomologicalComplex C (ComplexShape.up ℤ)) (n : ℤ),
(CategoryTheory.shiftFunctor (HomotopyCategory C (ComplexShape.up ℤ)) n).obj
((HomotopyCategory.quotient C (ComplexShape.up ℤ)).obj K) =
(HomotopyCategor... | null | true |
_private.Mathlib.AlgebraicTopology.SimplicialSet.KanComplex.0.SSet.instKanComplexOp._proof_9 | Mathlib.AlgebraicTopology.SimplicialSet.KanComplex | ∀ (n : ℕ), NeZero (n + 3) | null | false |
CategoryTheory.Functor.OplaxMonoidal.δ_comp_whiskerLeft_δ_assoc | Mathlib.CategoryTheory.Monoidal.Functor | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.MonoidalCategory C] {D : Type u₂}
[inst_2 : CategoryTheory.Category.{v₂, u₂} D] [inst_3 : CategoryTheory.MonoidalCategory D]
(F : CategoryTheory.Functor C D) [inst_4 : F.OplaxMonoidal] (X Y Z : C) {Z_1 : D}
(h :
CategoryTheor... | null | true |
CategoryTheory.isCoseparator_iff_faithful_preadditiveYoneda | Mathlib.CategoryTheory.Generator.Preadditive | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Preadditive C] (G : C),
CategoryTheory.IsCoseparator G ↔ (CategoryTheory.preadditiveYoneda.obj G).Faithful | null | true |
PiNat.self_mem_cylinder | Mathlib.Topology.MetricSpace.PiNat | ∀ {E : ℕ → Type u_1} (x : (n : ℕ) → E n) (n : ℕ), x ∈ PiNat.cylinder x n | null | true |
_private.Mathlib.Data.PFun.0.PFun.ran_coe._simp_1_2 | Mathlib.Data.PFun | ∀ {α : Sort u_1} {a b : α}, (a = b) = (b = a) | null | false |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.getKey_inter!._simp_1_2 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {instOrd : Ord α} {a b : α}, (compare a b ≠ Ordering.eq) = ((a == b) = false) | null | false |
NonarchAddGroupSeminorm.coe_lt_coe | Mathlib.Analysis.Normed.Group.Seminorm | ∀ {E : Type u_3} [inst : AddGroup E] {p q : NonarchAddGroupSeminorm E}, ⇑p < ⇑q ↔ p < q | null | true |
Std.Http.Protocol.H1.Error.unsupportedVersion | Std.Http.Protocol.H1.Error | Std.Http.Protocol.H1.Error | Unsupported HTTP version.
| true |
Submodule.map | Mathlib.Algebra.Module.Submodule.Map | {R : Type u_1} →
{R₂ : Type u_2} →
{M : Type u_4} →
{M₂ : Type u_5} →
[inst : Semiring R] →
[inst_1 : Semiring R₂] →
[inst_2 : AddCommMonoid M] →
[inst_3 : AddCommMonoid M₂] →
[inst_4 : Module R M] →
[inst_5 : Module R₂ M₂] →
... | The pushforward of a submodule `p ⊆ M` by `f : M → M₂` | true |
concaveOn_univ_piecewise_Iic_of_monotoneOn_Iic_antitoneOn_Ici | Mathlib.Analysis.Convex.Piecewise | ∀ {𝕜 : Type u_1} {E : Type u_2} {β : Type u_3} [inst : Semiring 𝕜] [inst_1 : PartialOrder 𝕜] [inst_2 : AddCommMonoid E]
[inst_3 : LinearOrder E] [IsOrderedAddMonoid E] [inst_5 : Module 𝕜 E] [PosSMulMono 𝕜 E] [inst_7 : AddCommGroup β]
[inst_8 : PartialOrder β] [IsOrderedAddMonoid β] [inst_10 : Module 𝕜 β] [Pos... | The piecewise function `(Set.Iic e).piecewise f g` of a function `f` increasing and concave on
`Set.Iic e` and a function `g` decreasing and concave on `Set.Ici e`, such that `f e = g e`, is
concave on the universal set. | true |
CategoryTheory.Discrete.sumEquiv.match_1 | Mathlib.CategoryTheory.Discrete.SumsProducts | {J : Type u_1} →
{K : Type u_2} →
(motive : J ⊕ K → Sort u_3) →
(t : J ⊕ K) → ((j : J) → motive (Sum.inl j)) → ((k : K) → motive (Sum.inr k)) → motive t | null | false |
TopologicalSpace.ext_isClosed | Mathlib.Topology.Basic | ∀ {X : Type u_2} {t₁ t₂ : TopologicalSpace X}, (∀ (s : Set X), IsClosed s ↔ IsClosed s) → t₁ = t₂ | **Alias** of the reverse direction of `TopologicalSpace.ext_iff_isClosed`. | true |
nonneg_of_mul_nonneg_right | Mathlib.Algebra.Order.Ring.Unbundled.Basic | ∀ {R : Type u} [inst : Semiring R] [inst_1 : LinearOrder R] {a b : R} [PosMulStrictMono R], 0 ≤ a * b → 0 < a → 0 ≤ b | null | true |
CategoryTheory.Functor.LaxMonoidal.comp._proof_1 | Mathlib.CategoryTheory.Monoidal.Functor | ∀ {C : Type u_4} [inst : CategoryTheory.Category.{u_3, u_4} C] [inst_1 : CategoryTheory.MonoidalCategory C]
{D : Type u_6} [inst_2 : CategoryTheory.Category.{u_5, u_6} D] [inst_3 : CategoryTheory.MonoidalCategory D]
{E : Type u_2} [inst_4 : CategoryTheory.Category.{u_1, u_2} E] [inst_5 : CategoryTheory.MonoidalCate... | null | false |
instAssociativeInt8HAdd | Init.Data.SInt.Lemmas | Std.Associative fun x1 x2 => x1 + x2 | null | true |
CategoryTheory._aux_Mathlib_CategoryTheory_Category_Basic___macroRules_CategoryTheory_rfl_cat_1 | Mathlib.CategoryTheory.Category.Basic | Lean.Macro | `rfl_cat` is a macro for `intros; rfl` which is attempted in `aesop_cat` before
doing the more expensive `aesop` tactic.
This gives a speedup because `simp` (called by `aesop`) can be very slow.
https://github.com/leanprover-community/mathlib4/pull/25475 contains measurements from June 2025.
Implementation notes:
* `... | false |
_private.Aesop.RuleSet.0.Aesop.LocalRuleSet.erase._proof_6 | Aesop.RuleSet | ∀ (rs : Aesop.LocalRuleSet) (idx : Fin rs.localNormSimpRules.size), ↑idx < rs.localNormSimpRules.size | null | false |
Finsupp.coe_smul._simp_1 | Mathlib.Data.Finsupp.SMulWithZero | ∀ {α : Type u_1} {M : Type u_2} {R : Type u_4} [inst : Zero M] [inst_1 : SMulZeroClass R M] (b : R) (v : α →₀ M),
b • ⇑v = ⇑(b • v) | null | false |
SSet.Subcomplex.Pairing.II | Mathlib.AlgebraicTopology.SimplicialSet.AnodyneExtensions.Pairing | {X : SSet} → {A : X.Subcomplex} → A.Pairing → Set A.N | the set of type (II) simplices | true |
Mathlib.Tactic.Order.AtomicFact.isTop.sizeOf_spec | Mathlib.Tactic.Order.CollectFacts | ∀ (idx : ℕ), sizeOf (Mathlib.Tactic.Order.AtomicFact.isTop idx) = 1 + sizeOf idx | null | true |
Std.TreeMap.Raw.instForMProdOfMonad | Std.Data.TreeMap.Raw.Basic | {α : Type u} →
{β : Type v} →
{cmp : α → α → Ordering} → {m : Type w → Type w₂} → [Monad m] → ForM m (Std.TreeMap.Raw α β cmp) (α × β) | null | true |
Std.TreeMap.le_minKey! | Std.Data.TreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.TreeMap α β cmp} [Std.TransCmp cmp] [inst : Inhabited α],
t.isEmpty = false → ∀ {k : α}, (cmp k t.minKey!).isLE = true ↔ ∀ k' ∈ t, (cmp k k').isLE = true | null | true |
IsChain.succ | Mathlib.Order.Preorder.Chain | ∀ {α : Type u_1} {r : α → α → Prop} {s : Set α}, IsChain r s → IsChain r (SuccChain r s) | null | true |
IsLocalDiffeomorphAt.localInverse_contMDiffOn | Mathlib.Geometry.Manifold.LocalDiffeomorph | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {F : Type u_3} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {H₁ : Type u_5}
[inst_5 : TopologicalSpace H₁] {H₂ : Type u_6} [inst_6 : TopologicalSpace H₂] {I : ModelWithCorn... | **Alias** of `IsLocalDiffeomorphAt.contMDiffOn_localInverse`. | true |
fderivWithin_continuousAlternatingMapCompContinuousLinearMap | Mathlib.Analysis.Calculus.FDeriv.ContinuousAlternatingMap | ∀ {𝕜 : Type u_1} {ι : Type u_2} {E : Type u_3} {F : Type u_4} {G : Type u_5} {H : Type u_6}
[inst : NontriviallyNormedField 𝕜] [inst_1 : NormedAddCommGroup E] [inst_2 : NormedSpace 𝕜 E]
[inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] [inst_5 : NormedAddCommGroup G] [inst_6 : NormedSpace 𝕜 G]
[inst... | null | true |
Filter.tendsto_principal_principal | Mathlib.Order.Filter.Tendsto | ∀ {α : Type u_1} {β : Type u_2} {f : α → β} {s : Set α} {t : Set β},
Filter.Tendsto f (Filter.principal s) (Filter.principal t) ↔ ∀ a ∈ s, f a ∈ t | null | true |
PointedCone.coe_closure | Mathlib.Analysis.Convex.Cone.Closure | ∀ {𝕜 : Type u_1} [inst : Semiring 𝕜] [inst_1 : PartialOrder 𝕜] [inst_2 : IsOrderedRing 𝕜] {E : Type u_2}
[inst_3 : AddCommMonoid E] [inst_4 : TopologicalSpace E] [inst_5 : ContinuousAdd E] [inst_6 : Module 𝕜 E]
[inst_7 : ContinuousConstSMul 𝕜 E] (K : PointedCone 𝕜 E), ↑K.closure = closure ↑K | null | true |
Std.TreeSet.casesOn | Std.Data.TreeSet.Basic | {α : Type u} →
{cmp : α → α → Ordering} →
{motive : Std.TreeSet α cmp → Sort u_1} →
(t : Std.TreeSet α cmp) → ((inner : Std.TreeMap α Unit cmp) → motive { inner := inner }) → motive t | null | false |
Lean.Parser.Tactic._aux_Init_Tactics___macroRules_Lean_Parser_Tactic_tacticAdmit_1 | Init.Tactics | Lean.Macro | `admit` is a synonym for `sorry`. | false |
NonUnitalStarAlgebra.adjoin_toNonUnitalSubalgebra | Mathlib.Algebra.Star.NonUnitalSubalgebra | ∀ (R : Type u) {A : Type v} [inst : CommSemiring R] [inst_1 : StarRing R] [inst_2 : NonUnitalSemiring A]
[inst_3 : StarRing A] [inst_4 : Module R A] [inst_5 : IsScalarTower R A A] [inst_6 : SMulCommClass R A A]
[inst_7 : StarModule R A] (s : Set A),
(NonUnitalStarAlgebra.adjoin R s).toNonUnitalSubalgebra = NonUni... | null | true |
Std.instAssociativeMaxOfIsLinearOrderOfLawfulOrderMax | Init.Data.Order.Lemmas | ∀ {α : Type u} [inst : LE α] [inst_1 : Max α] [Std.IsLinearOrder α] [Std.LawfulOrderMax α], Std.Associative max | null | true |
CategoryTheory.endofunctorMonoidalCategory_whiskerLeft_app | Mathlib.CategoryTheory.Monoidal.End | ∀ (C : Type u) [inst : CategoryTheory.Category.{v, u} C] {F H K : CategoryTheory.Functor C C} {β : H ⟶ K} (X : C),
(CategoryTheory.MonoidalCategoryStruct.whiskerLeft F β).app X = β.app (F.obj X) | null | true |
Set.Ico_diff_Iio | Mathlib.Order.Interval.Set.LinearOrder | ∀ {α : Type u_1} [inst : LinearOrder α] {a b c : α}, Set.Ico a b \ Set.Iio c = Set.Ico (max a c) b | **Alias** of `Set.Ico_sdiff_Iio`. | true |
CategoryTheory.IsAddMonHom.Normal.exists_comp_eq_addConj | Mathlib.CategoryTheory.Monoidal.Cartesian.Normal | ∀ {C : Type u_1} {inst : CategoryTheory.Category.{v_1, u_1} C} {inst_1 : CategoryTheory.CartesianMonoidalCategory C}
{G H : C} {inst_2 : CategoryTheory.AddGrpObj G} {inst_3 : CategoryTheory.AddGrpObj H} {φ : H ⟶ G}
[self : CategoryTheory.IsAddMonHom.Normal φ],
∃ ψ,
CategoryTheory.CategoryStruct.comp ψ φ =
... | null | true |
_private.Mathlib.LinearAlgebra.RootSystem.Finite.G2.0.RootPairing.EmbeddedG2.isOrthogonal_short_and_long._simp_1_1 | Mathlib.LinearAlgebra.RootSystem.Finite.G2 | ∀ {ι : Type u_1} {R : Type u_2} {M : Type u_3} {N : Type u_4} [inst : CommRing R] [inst_1 : AddCommGroup M]
[inst_2 : Module R M] [inst_3 : AddCommGroup N] [inst_4 : Module R N] {P : RootPairing ι R M N} {i j : ι} [NeZero 2]
[IsDomain R] [Module.IsTorsionFree R M], P.IsOrthogonal i j = (P.pairing i j = 0) | null | false |
FractionalIdeal.coeIdeal | Mathlib.RingTheory.FractionalIdeal.Basic | {R : Type u_1} →
[inst : CommRing R] →
{S : Submonoid R} → {P : Type u_2} → [inst_1 : CommRing P] → [inst_2 : Algebra R P] → Ideal R → FractionalIdeal S P | Map an ideal `I` to a fractional ideal by forgetting `I` is integral.
This is the function that implements the coercion `Ideal R → FractionalIdeal S P`. | true |
hasProd_prod | Mathlib.Topology.Algebra.InfiniteSum.Basic | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} [inst : CommMonoid α] [inst_1 : TopologicalSpace α]
{L : SummationFilter β} [ContinuousMul α] {f : γ → β → α} {a : γ → α} {s : Finset γ},
(∀ i ∈ s, HasProd (f i) (a i) L) → HasProd (fun b => ∏ i ∈ s, f i b) (∏ i ∈ s, a i) L | null | true |
ProbabilityTheory.Kernel.sectR._proof_1 | Mathlib.Probability.Kernel.Composition.MapComap | ∀ {α : Type u_2} {β : Type u_1} {mα : MeasurableSpace α} {mβ : MeasurableSpace β} (a : α),
Measurable fun a_1 => (a, a_1) | null | false |
Nat.Coprime.mul_gcd | Init.Data.Nat.Coprime | ∀ {m n : ℕ}, m.Coprime n → ∀ (k : ℕ), (m * n).gcd k = m.gcd k * n.gcd k | null | true |
CategoryTheory.MorphismProperty.RespectsLeft.rec | Mathlib.CategoryTheory.MorphismProperty.Basic | {C : Type u} →
[inst : CategoryTheory.CategoryStruct.{v, u} C] →
{P Q : CategoryTheory.MorphismProperty C} →
{motive : P.RespectsLeft Q → Sort u_1} →
((precomp : ∀ {X Y Z : C} (i : X ⟶ Y), Q i → ∀ (f : Y ⟶ Z), P f → P (CategoryTheory.CategoryStruct.comp i f)) →
motive ⋯) →
(t :... | null | false |
CochainComplex.HomComplex.Cochain.toSingleLinearEquiv_symm_apply | Mathlib.Algebra.Homology.HomotopyCategory.HomComplexSingle | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Preadditive C]
[inst_2 : CategoryTheory.Limits.HasZeroObject C] {X : C} {K : CochainComplex C ℤ} {R : Type u_1} [inst_3 : Ring R]
[inst_4 : CategoryTheory.Linear R C] {p q n : ℤ} (h : p + n = q) (a : K.X p ⟶ X),
(CochainComplex.HomC... | null | true |
IsDivApply.mk | Mathlib.Algebra.Group.IsApply | ∀ {F : Type u_1} {α : outParam (Type u_2)} {β : outParam (Type u_3)} [inst : FunLike F α β] [inst_1 : Div β]
[inst_2 : Div F],
autoParam (∀ (f g : F) (x : α), (f / g) x = f x / g x) IsDivApply.div_apply._autoParam → IsDivApply F α β | null | true |
_private.Init.Data.UInt.Package.0.instLinearOrderPackageUSize._proof_7 | Init.Data.UInt.Package | ∀ (a b : USize), (compare a b).isGE = true ↔ b ≤ a | null | false |
Lean.Meta.Grind.CanonArgKey.mk.injEq | Lean.Meta.Tactic.Grind.Types | ∀ (f : Lean.Expr) (i : ℕ) (arg f_1 : Lean.Expr) (i_1 : ℕ) (arg_1 : Lean.Expr),
({ f := f, i := i, arg := arg } = { f := f_1, i := i_1, arg := arg_1 }) = (f = f_1 ∧ i = i_1 ∧ arg = arg_1) | null | true |
_private.Lake.Util.Version.0.Lake.parseSpecialDescr?.nextUntilWhitespace._proof_1 | Lake.Util.Version | ∀ (s : String), WellFounded (invImage (fun x => x) String.Pos.instWellFoundedRelation).1 | null | false |
Matrix.isUnit_conjTranspose._simp_1 | Mathlib.LinearAlgebra.Matrix.Invertible | ∀ {n : Type u_2} {α : Type u_3} [inst : Fintype n] [inst_1 : DecidableEq n] [inst_2 : Semiring α] [inst_3 : StarRing α]
(A : Matrix n n α), IsUnit A.conjTranspose = IsUnit A | null | false |
AddMonoidAlgebra.mapAlgEquiv._proof_3 | Mathlib.Algebra.MonoidAlgebra.Basic | ∀ (R : Type u_4) {A : Type u_1} {B : Type u_3} (M : Type u_2) [inst : CommSemiring R] [inst_1 : Semiring A]
[inst_2 : Semiring B] [inst_3 : Algebra R A] [inst_4 : Algebra R B] [inst_5 : AddMonoid M] (e : A ≃ₐ[R] B)
(x y : AddMonoidAlgebra A M),
(↑↑(AddMonoidAlgebra.mapAlgHom M ↑e).toRingHom).toFun (x + y) =
(... | null | false |
Std.DTreeMap.Internal.Impl.minKey!_erase_eq_of_not_compare_minKey!_eq | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Std.DTreeMap.Internal.Impl α β} [Std.TransOrd α]
[inst : Inhabited α] (h : t.WF) {k : α},
(Std.DTreeMap.Internal.Impl.erase k t ⋯).impl.isEmpty = false →
¬compare k t.minKey! = Ordering.eq → (Std.DTreeMap.Internal.Impl.erase k t ⋯).impl.minKey! = t.minKey! | null | true |
UInt8.toUInt64_xor | Init.Data.UInt.Bitwise | ∀ (a b : UInt8), (a ^^^ b).toUInt64 = a.toUInt64 ^^^ b.toUInt64 | null | true |
Fin.encodeSigma._unsafe_rec | Batteries.Data.Fin.Coding | {n : ℕ} → (f : Fin n → ℕ) → (i : Fin n) × Fin (f i) → Fin (Fin.sum f) | null | false |
_private.Init.Grind.Ordered.Int.0.Lean.Grind.instOrderedRingInt._proof_1 | Init.Grind.Ordered.Int | ¬0 < 1 → False | null | false |
Nat.le_nextPowerOfTwo._simp_1 | Init.Data.Nat.Power2.Lemmas | ∀ (n : ℕ), (n ≤ n.nextPowerOfTwo) = True | null | false |
LinearIndepOn.notMem_span_iff | Mathlib.LinearAlgebra.LinearIndependent.Lemmas | ∀ {ι : Type u'} {K : Type u_3} {V : Type u} [inst : DivisionRing K] [inst_1 : AddCommGroup V] [inst_2 : Module K V]
{s : Set ι} {a : ι} {f : ι → V},
LinearIndepOn K f s → (f a ∉ Submodule.span K (f '' s) ↔ LinearIndepOn K f (insert a s) ∧ a ∉ s) | A shortcut to a convenient form for the negation in `LinearIndepOn.mem_span_iff`. | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.