name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
CategoryTheory.Functor.rightDerivedDesc | Mathlib.CategoryTheory.Functor.Derived.RightDerived | {C : Type u_1} →
{D : Type u_2} →
{H : Type u_3} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
[inst_1 : CategoryTheory.Category.{v_2, u_2} D] →
[inst_2 : CategoryTheory.Category.{v_3, u_3} H] →
(RF : CategoryTheory.Functor D H) →
{F : CategoryTheory.Functor C... | Constructor for natural transformations from a right derived functor. | true |
_private.Mathlib.Tactic.Echelon.Reflection.0.Mathlib.Tactic.Echelon.getD_of_isLowerTriangularDiagList._proof_1_10 | Mathlib.Tactic.Echelon.Reflection | ∀ {α : Type u_1} {k : ℕ} {row : List α} (j : ℕ), j - k + 1 ≤ (List.drop k row).length → j - k < (List.drop k row).length | null | false |
_private.Lean.Meta.DiscrTree.Basic.0.Lean.Meta.DiscrTree.Trie.format.match_1 | Lean.Meta.DiscrTree.Basic | {α : Type} →
(motive : Lean.Meta.DiscrTree.Key × Lean.Meta.DiscrTree.Trie α → Sort u_1) →
(x : Lean.Meta.DiscrTree.Key × Lean.Meta.DiscrTree.Trie α) →
((k : Lean.Meta.DiscrTree.Key) → (c : Lean.Meta.DiscrTree.Trie α) → motive (k, c)) → motive x | null | false |
LinearMap.rTensor_comp_lTensor | Mathlib.LinearAlgebra.TensorProduct.Map | ∀ {R : Type u_1} [inst : CommSemiring R] (M : Type u_4) {N : Type u_5} {P : Type u_6} {Q : Type u_7}
[inst_1 : AddCommMonoid M] [inst_2 : AddCommMonoid N] [inst_3 : AddCommMonoid P] [inst_4 : AddCommMonoid Q]
[inst_5 : Module R M] [inst_6 : Module R N] [inst_7 : Module R P] [inst_8 : Module R Q] (f : M →ₗ[R] P)
(... | null | true |
Std.DTreeMap.Internal.Impl.getKey!_diff_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 α] (h₁ : m₁.WF),
m₂.WF → ∀ {k : α}, Std.DTreeMap.Internal.Impl.contains k m₁ = false → (m₁.diff m₂ ⋯).getKey! k = default | null | true |
MeasureTheory.FinStronglyMeasurable.sub | Mathlib.MeasureTheory.Function.StronglyMeasurable.Basic | ∀ {α : Type u_1} {β : Type u_2} {m0 : MeasurableSpace α} {μ : MeasureTheory.Measure α} {f g : α → β}
[inst : TopologicalSpace β] [inst_1 : SubtractionMonoid β] [ContinuousSub β],
MeasureTheory.FinStronglyMeasurable f μ →
MeasureTheory.FinStronglyMeasurable g μ → MeasureTheory.FinStronglyMeasurable (f - g) μ | null | true |
_private.Lean.Parser.Extra.0.Lean.Parser.ppAllowUngrouped._regBuiltin.Lean.Parser.ppAllowUngrouped.docString_1 | Lean.Parser.Extra | IO Unit | null | false |
_private.Init.Data.List.Basic.0.List.reverseAux.match_1.eq_2 | Init.Data.List.Basic | ∀ {α : Type u_1} (motive : List α → List α → Sort u_2) (a : α) (l r : List α) (h_1 : (r : List α) → motive [] r)
(h_2 : (a : α) → (l r : List α) → motive (a :: l) r),
(match a :: l, r with
| [], r => h_1 r
| a :: l, r => h_2 a l r) =
h_2 a l r | null | true |
imageToKernel_op | Mathlib.Algebra.Homology.Opposite | ∀ {V : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} V] [inst_1 : CategoryTheory.Abelian V] {X Y Z : V}
(f : X ⟶ Y) (g : Y ⟶ Z) (w : CategoryTheory.CategoryStruct.comp f g = 0),
imageToKernel g.op f.op ⋯ =
CategoryTheory.CategoryStruct.comp
(CategoryTheory.Limits.imageSubobjectIso g.op ≪≫ (Category... | null | true |
CategoryTheory.Limits.reflectsColimitsOfShape_of_natIso | Mathlib.CategoryTheory.Limits.Preserves.Basic | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
{J : Type w} [inst_2 : CategoryTheory.Category.{w', w} J] {F G : CategoryTheory.Functor C D} (h : F ≅ G)
[CategoryTheory.Limits.ReflectsColimitsOfShape J F], CategoryTheory.Limits.ReflectsColimits... | Transfer reflection of colimits of shape along a natural isomorphism in the functor. | true |
MeasureTheory.AEEqFun.instSub._proof_1 | Mathlib.MeasureTheory.Function.AEEqFun | ∀ {γ : Type u_1} [inst : TopologicalSpace γ] [inst_1 : AddGroup γ] [IsTopologicalAddGroup γ],
Continuous fun p => p.1 - p.2 | null | false |
Lean.Meta.Grind.SolverExtension.ctorIdx | Lean.Meta.Tactic.Grind.Types | {σ : Type} → Lean.Meta.Grind.SolverExtension σ → ℕ | null | false |
IsIntegralClosure.mk'_add | Mathlib.RingTheory.IntegralClosure.IsIntegralClosure.Basic | ∀ {R : Type u_1} (A : Type u_2) {B : Type u_3} [inst : CommRing R] [inst_1 : CommRing A] [inst_2 : CommRing B]
[inst_3 : Algebra R B] [inst_4 : Algebra A B] [inst_5 : IsIntegralClosure A R B] (x y : B) (hx : IsIntegral R x)
(hy : IsIntegral R y), IsIntegralClosure.mk' A (x + y) ⋯ = IsIntegralClosure.mk' A x hx + Is... | null | true |
Ideal.rootsOfUnityMapQuot | Mathlib.NumberTheory.NumberField.Ideal.Basic | {K : Type u_1} →
[inst : Field K] →
(I : Ideal (NumberField.RingOfIntegers K)) →
(n : ℕ) → ↥(rootsOfUnity n (NumberField.RingOfIntegers K)) →* (NumberField.RingOfIntegers K ⧸ I)ˣ | For `I` an integral ideal of `K`, the group morphism from the group of roots of unity of `K`
of order `n` to `(𝓞 K ⧸ I)ˣ`.
| true |
Nat.card_eq_fintype_card | Mathlib.SetTheory.Cardinal.Finite | ∀ {α : Type u_1} [inst : Fintype α], Nat.card α = Fintype.card α | null | true |
WithCStarModule.equiv_symm_snd | Mathlib.Analysis.CStarAlgebra.Module.Synonym | ∀ {A : Type u_2} {E : Type u_3} {F : Type u_4} (x : E × F), ((WithCStarModule.equiv A (E × F)).symm x).2 = x.2 | null | true |
StarAlgHom.ofId.congr_simp | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Restrict | ∀ (R : Type u_7) (A : Type u_8) [inst : CommSemiring R] [inst_1 : StarRing R] [inst_2 : Semiring A] [inst_3 : StarMul A]
[inst_4 : Algebra R A] [inst_5 : StarModule R A], StarAlgHom.ofId R A = StarAlgHom.ofId R A | null | true |
_private.Mathlib.Combinatorics.Additive.VerySmallDoubling.0.Finset.expansion_pos._simp_1 | Mathlib.Combinatorics.Additive.VerySmallDoubling | ∀ {G : Type u_1} [inst : Group G] [inst_1 : DecidableEq G] {K : ℝ} {A S : Finset G},
K < 1 → S.Nonempty → A.Nonempty → (0 < Finset.expansion✝ K S A) = True | null | false |
AEMeasurable.oneLePart | Mathlib.MeasureTheory.Order.Group.Lattice | ∀ {α : Type u_1} {β : Type u_2} [inst : Lattice α] [inst_1 : MeasurableSpace α] [inst_2 : MeasurableSpace β] {f : β → α}
[inst_3 : DivInvMonoid α] [MeasurableSup α] {μ : MeasureTheory.Measure β}, AEMeasurable f μ → AEMeasurable f⁺ᵐ μ | null | true |
_private.Lean.Elab.Tactic.Ext.0.Lean.Elab.Tactic.Ext.mkExtIffType | Lean.Elab.Tactic.Ext | Lean.Name → Lean.MetaM Lean.Expr | Derives the type of the `iff` form of an ext theorem.
| true |
OrderMonoidHom.instMulOfIsOrderedMonoid._proof_2 | Mathlib.Algebra.Order.Hom.Monoid | ∀ {α : Type u_1} {β : Type u_2} [inst : CommMonoid α] [inst_1 : Preorder α] [inst_2 : CommMonoid β]
[inst_3 : Preorder β] [IsOrderedMonoid β] (f g : α →*o β), Monotone fun x => (↑f.toMonoidHom).toFun x * ↑g x | null | false |
continuousMultilinearCurryFin0_symm_apply | Mathlib.Analysis.Normed.Module.Multilinear.Curry | ∀ {𝕜 : Type u} {G : Type wG} {G' : Type wG'} [inst : NontriviallyNormedField 𝕜] [inst_1 : NormedAddCommGroup G]
[inst_2 : NormedSpace 𝕜 G] [inst_3 : NormedAddCommGroup G'] [inst_4 : NormedSpace 𝕜 G'] (x : G'),
(continuousMultilinearCurryFin0 𝕜 G G').symm x = ContinuousMultilinearMap.uncurry0 𝕜 G x | null | true |
LightCondSet.instFaithfulTopCatTopCatToLightCondSet | Mathlib.Condensed.Light.TopCatAdjunction | topCatToLightCondSet.Faithful | null | true |
Algebra.Generators.H1Cotangent.δ_eq_δ | Mathlib.RingTheory.Kaehler.JacobiZariski | ∀ {R : Type u₁} {S : Type u₂} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S] {T : Type u₃}
[inst_3 : CommRing T] [inst_4 : Algebra R T] [inst_5 : Algebra S T] [inst_6 : IsScalarTower R S T] {ι : Type w₁}
{σ : Type w₂} {σ' : Type w₄} (Q : Algebra.Generators S T ι) (P : Algebra.Generators R S σ)
(... | null | true |
ContinuousAffineMap.precompL | Mathlib.Topology.Algebra.ContinuousAffineMap.Topology | {R : Type u_1} →
{V : Type u_2} →
{W : Type u_3} →
(W₂ : Type u_4) →
{P : Type u_5} →
{Q : Type u_6} →
[inst : NormedField R] →
[inst_1 : AddCommGroup V] →
[inst_2 : Module R V] →
[inst_3 : TopologicalSpace V] →
... | Pre-composition by a fixed continuous affine map, as a continuous linear map. | true |
Int.card_box | Mathlib.Order.Interval.Finset.Box | ∀ {n : ℕ}, n ≠ 0 → (Finset.box n).card = 8 * n | null | true |
KummerDedekind.normalizedFactorsMapEquivNormalizedFactorsMinPolyMk._proof_9 | Mathlib.NumberTheory.KummerDedekind | ∀ {R : Type u_1} [inst : CommRing R] {I : Ideal R} (hI : I.IsMaximal), IsPrincipalIdealRing (Polynomial (R ⧸ I)) | null | false |
Projectivization.Subspace.submodule._proof_8 | Mathlib.LinearAlgebra.Projectivization.Subspace | ∀ {K : Type u_1} {V : Type u_2} [inst : DivisionRing K] [inst_1 : AddCommGroup V] [inst_2 : Module K V]
{a b : Projectivization.Subspace K V},
{
toFun := fun s =>
{ carrier := {x | ∀ (h : x ≠ 0), Projectivization.mk K x h ∈ s.carrier}, add_mem' := ⋯, zero_mem' := ⋯,
smul_mem' := ... | null | false |
ProbabilityTheory.Kernel.instIsCondKernel_zero | Mathlib.Probability.Kernel.Disintegration.Basic | ∀ {α : Type u_1} {β : Type u_2} {Ω : Type u_3} {mα : MeasurableSpace α} {mβ : MeasurableSpace β}
{mΩ : MeasurableSpace Ω} (κCond : ProbabilityTheory.Kernel (α × β) Ω), ProbabilityTheory.Kernel.IsCondKernel 0 κCond | null | true |
Lean.Meta.CasesSubgoal.mk.inj | Lean.Meta.Tactic.Cases | ∀ {toInductionSubgoal : Lean.Meta.InductionSubgoal} {ctorName : Option Lean.Name}
{toInductionSubgoal_1 : Lean.Meta.InductionSubgoal} {ctorName_1 : Option Lean.Name},
{ toInductionSubgoal := toInductionSubgoal, ctorName := ctorName } =
{ toInductionSubgoal := toInductionSubgoal_1, ctorName := ctorName_1 } →
... | null | true |
Lean.Meta.SavedState._sizeOf_1 | Lean.Meta.Basic | Lean.Meta.SavedState → ℕ | null | false |
WellFoundedGT.toOrderTop.eq_1 | Mathlib.Order.WellFounded | ∀ (α : Type u_4) [inst : LinearOrder α] [inst_1 : Nonempty α] [h : WellFoundedGT α],
WellFoundedGT.toOrderTop α = { top := WellFoundedGT.max Set.univ ⋯, le_top := ⋯ } | null | true |
Submodule.toLocalizedQuotient._proof_2 | Mathlib.Algebra.Module.LocalizedModule.Submodule | ∀ {R : Type u_1} [inst : CommRing R], IsScalarTower R R R | null | false |
_private.Lean.Meta.Tactic.Simp.SimpTheorems.0.Lean.Meta.shouldPreprocess._sparseCasesOn_1 | Lean.Meta.Tactic.Simp.SimpTheorems | {α : Type u} →
{motive : Option α → Sort u_1} →
(t : Option α) → ((val : α) → motive (some val)) → (Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t | null | false |
symmDiff_self | Mathlib.Order.SymmDiff | ∀ {α : Type u_2} [inst : GeneralizedCoheytingAlgebra α] (a : α), symmDiff a a = ⊥ | null | true |
AddMonoidHom.ker_id | Mathlib.Algebra.Group.Subgroup.Ker | ∀ {G : Type u_1} [inst : AddGroup G], (AddMonoidHom.id G).ker = ⊥ | null | true |
IsLocalization.moduleLid._proof_5 | Mathlib.RingTheory.Localization.BaseChange | ∀ (A : Type u_1) [inst : CommSemiring A], RingHomInvPair (RingHom.id A) (RingHom.id A) | null | false |
AddChar.rec | Mathlib.Algebra.Group.AddChar | {A : Type u_1} →
[inst : AddMonoid A] →
{M : Type u_2} →
[inst_1 : Monoid M] →
{motive : AddChar A M → Sort u} →
((toFun : A → M) →
(map_zero_eq_one' : toFun 0 = 1) →
(map_add_eq_mul' : ∀ (a b : A), toFun (a + b) = toFun a * toFun b) →
motive... | null | false |
_private.Mathlib.Tactic.NormNum.GCD.0.Mathlib.Meta.NormNum.evalRatNum.match_1 | Mathlib.Tactic.NormNum.GCD | (motive : Lean.Expr → Sort u_1) →
(__x : Lean.Expr) →
((typeName : Lean.Name) → (idx : ℕ) → (q : Q(ℚ)) → motive (Lean.Expr.proj typeName idx q)) →
((x : Lean.Expr) → motive x) → motive __x | null | false |
Std.DTreeMap.Raw.size_modify | Std.Data.DTreeMap.Raw.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t : Std.DTreeMap.Raw α β cmp} [Std.TransCmp cmp]
[inst : Std.LawfulEqCmp cmp], t.WF → ∀ {k : α} {f : β k → β k}, (t.modify k f).size = t.size | null | true |
monovaryOn_iff_forall_smul_nonneg | Mathlib.Algebra.Order.Monovary | ∀ {ι : Type u_1} {α : Type u_2} {β : Type u_3} [inst : Ring α] [inst_1 : LinearOrder α] [IsStrictOrderedRing α]
[inst_3 : AddCommGroup β] [inst_4 : LinearOrder β] [IsOrderedAddMonoid β] [inst_6 : Module α β]
[IsStrictOrderedModule α β] {f : ι → α} {g : ι → β} {s : Set ι},
MonovaryOn f g s ↔ ∀ ⦃i : ι⦄, i ∈ s → ∀ ⦃... | null | true |
Height.mulHeight_pos | Mathlib.NumberTheory.Height.Basic | ∀ {K : Type u_1} [inst : Field K] [inst_1 : Height.AdmissibleAbsValues K] {ι : Type u_2} [Finite ι] (x : ι → K),
0 < Height.mulHeight x | null | true |
CentroidHom.isScalarTowerRight | Mathlib.Algebra.Ring.CentroidHom | ∀ {M : Type u_2} {α : Type u_5} [inst : NonUnitalNonAssocSemiring α] [inst_1 : Monoid M] [inst_2 : DistribMulAction M α]
[inst_3 : SMulCommClass M α α] [inst_4 : IsScalarTower M α α], IsScalarTower M (CentroidHom α) (CentroidHom α) | null | true |
Bool.toNat.eq_1 | Batteries.Data.Fin.Lemmas | ∀ (b : Bool), b.toNat = bif b then 1 else 0 | null | true |
BitVec.and_append | Init.Data.BitVec.Lemmas | ∀ {w v : ℕ} {x₁ x₂ : BitVec w} {y₁ y₂ : BitVec v}, x₁ ++ y₁ &&& x₂ ++ y₂ = (x₁ &&& x₂) ++ (y₁ &&& y₂) | null | true |
_private.Init.Data.BitVec.Bitblast.0.BitVec.toInt_eq_neg_toNat_neg_of_msb_true._simp_1_2 | Init.Data.BitVec.Bitblast | ∀ {n : ℕ} {x y : BitVec n}, (x = y) = (x.toNat = y.toNat) | null | false |
QPF.Fix.mk | Mathlib.Data.QPF.Univariate.Basic | {F : Type u → Type u} → [q : QPF F] → F (QPF.Fix F) → QPF.Fix F | constructor of a type defined by a qpf | true |
AntitoneOn.Ioo | Mathlib.Order.Interval.Set.Monotone | ∀ {α : Type u_1} {β : Type u_2} [inst : Preorder α] [inst_1 : Preorder β] {f g : α → β} {s : Set α},
AntitoneOn f s → MonotoneOn g s → MonotoneOn (fun x => Set.Ioo (f x) (g x)) s | null | true |
DedekindCut.principalIso._proof_2 | Mathlib.Order.Completion | ∀ {α : Type u_1} [inst : CompleteLattice α] {a b : α},
DedekindCut.principalEmbedding.toEmbedding a ≤ DedekindCut.principalEmbedding.toEmbedding b ↔ a ≤ b | null | false |
_private.Init.Data.BitVec.Lemmas.0.BitVec.neg_two_pow_le_toInt_ediv._proof_1_3 | Init.Data.BitVec.Lemmas | ∀ {w : ℕ} {x y : BitVec w},
x.toInt < 2 ^ (w - 1) → -x.toInt ≤ x.toInt / y.toInt → ¬-2 ^ (w - 1) ≤ x.toInt / y.toInt → False | null | false |
_private.Std.Http.Data.Extensions.0.Std.Http.Extensions.mk.noConfusion | Std.Http.Data.Extensions | {P : Sort u} →
{data data' : Std.TreeMap Lean.Name Dynamic Std.Http.Extensions.compareName} →
{ data := data } = { data := data' } → (data = data' → P) → P | null | false |
Mathlib.Tactic.Order.AtomicFact.ne.elim | Mathlib.Tactic.Order.CollectFacts | {motive : Mathlib.Tactic.Order.AtomicFact → Sort u} →
(t : Mathlib.Tactic.Order.AtomicFact) →
t.ctorIdx = 1 →
((lhs rhs : ℕ) → (proof : Lean.Expr) → motive (Mathlib.Tactic.Order.AtomicFact.ne lhs rhs proof)) → motive t | null | false |
Path.Homotopy.subpathTransSubpath | Mathlib.Topology.Subpath | {X : Type u_1} →
[inst : TopologicalSpace X] →
{a b : X} →
(γ : Path a b) →
(t₀ t₁ t₂ : ↑unitInterval) → ((γ.subpath t₀ t₁).trans (γ.subpath t₁ t₂)).Homotopy (γ.subpath t₀ t₂) | Following the subpath of `γ` from `t₀` to `t₁`, and then that from `t₁` to `t₂`,
is in natural homotopy with following the subpath of `γ` from `t₀` to `t₂`. | true |
LocallyConnectedSpace.mk._flat_ctor | Mathlib.Topology.Connected.LocallyConnected | ∀ {α : Type u_3} [inst : TopologicalSpace α],
(∀ (x : α), (nhds x).HasBasis (fun s => IsOpen s ∧ x ∈ s ∧ IsConnected s) id) → LocallyConnectedSpace α | null | false |
_private.Mathlib.Analysis.Distribution.TemperedDistribution.0._auto_36 | Mathlib.Analysis.Distribution.TemperedDistribution | Lean.Syntax | null | false |
ContinuousMultilinearMap.ofSubsingleton_symm_apply_apply | Mathlib.Topology.Algebra.Module.Multilinear.Basic | ∀ (R : Type u) {ι : Type v} (M₂ : Type w₂) (M₃ : Type w₃) [inst : Semiring R] [inst_1 : AddCommMonoid M₂]
[inst_2 : AddCommMonoid M₃] [inst_3 : Module R M₂] [inst_4 : Module R M₃] [inst_5 : TopologicalSpace M₂]
[inst_6 : TopologicalSpace M₃] [inst_7 : Subsingleton ι] (i : ι) (f : ContinuousMultilinearMap R (fun x =... | null | true |
Filter.eventuallyEq_iff_all_subsets | Mathlib.Order.Filter.Basic | ∀ {α : Type u} {β : Type v} {f g : α → β} {l : Filter α}, f =ᶠ[l] g ↔ ∀ (s : Set α), ∀ᶠ (x : α) in l, x ∈ s → f x = g x | null | true |
Set.unbounded_le_inter_lt | Mathlib.Order.Bounded | ∀ {α : Type u_1} {s : Set α} [inst : LinearOrder α] (a : α),
Set.Unbounded (fun x1 x2 => x1 ≤ x2) (s ∩ {b | a < b}) ↔ Set.Unbounded (fun x1 x2 => x1 ≤ x2) s | null | true |
ImportGraph.PkgIdx | ImportGraph.WorkspaceModel.Model | Type | The index of a lake package in a `WorkspaceModel`'s `Bitset`s and `Array`s. | true |
ModelWithCorners.continuous_symm | Mathlib.Geometry.Manifold.IsManifold.Basic | ∀ {𝕜 : 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] (I : ModelWithCorners 𝕜 E H),
Continuous ↑I.symm | null | true |
_private.Init.Data.Array.Lemmas.0.Array.foldlM.loop.match_1.splitter | Init.Data.Array.Lemmas | (motive : ℕ → Sort u_1) → (i : ℕ) → (Unit → motive 0) → ((i' : ℕ) → motive i'.succ) → motive i | null | true |
AddGroupWithOne.casesOn | Mathlib.Data.Int.Cast.Defs | {R : Type u} →
{motive : AddGroupWithOne R → Sort u_1} →
(t : AddGroupWithOne R) →
([toIntCast : IntCast R] →
[toAddMonoidWithOne : AddMonoidWithOne R] →
[toNeg : Neg R] →
[toSub : Sub R] →
[toZSMul : ZSMul R] →
(sub_eq_add_neg : ∀ (a b :... | null | false |
_private.Mathlib.Topology.Algebra.Module.EmbeddingOfLocal.0.ContinuousSMul.topology_eq_of_induced_eq._simp_1_2 | Mathlib.Topology.Algebra.Module.EmbeddingOfLocal | ∀ {α : Type u} {β : Type v} [T : TopologicalSpace α] (f : β → α) (a : β), Filter.comap f (nhds (f a)) = nhds a | null | false |
_private.Lean.Elab.MutualDef.0.Lean.Elab.initFn._@.Lean.Elab.MutualDef.2791506682._hygCtx._hyg.2 | Lean.Elab.MutualDef | IO Unit | Makes the bodies of definitions available to importing modules.
This only has an effect if both the module the definition is defined in and the importing module
have the module system enabled.
| false |
_private.Mathlib.AlgebraicTopology.SimplicialObject.DeltaZeroIter.0.CategoryTheory.SimplicialObject.δ₀Iter_succ._proof_3 | Mathlib.AlgebraicTopology.SimplicialObject.DeltaZeroIter | ∀ (i : ℕ) {n m : ℕ}, autoParam (n + i = m) CategoryTheory.SimplicialObject.δ₀Iter_succ._auto_1 → n + (i + 1) = m + 1 | null | false |
CategoryTheory.Limits.IsTerminal.op | Mathlib.CategoryTheory.Limits.Shapes.IsTerminal | (C : Type u₁) →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{X : C} → CategoryTheory.Limits.IsTerminal X → CategoryTheory.Limits.IsInitial (Opposite.op X) | A terminal object is initial in the opposite category. | true |
CategoryTheory.StructuredArrow.ofCommaSndEquivalenceInverse_map_right_left | Mathlib.CategoryTheory.Comma.Over.Basic | ∀ {T : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} T] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
{C : Type u₃} [inst_2 : CategoryTheory.Category.{v₃, u₃} C] (F : CategoryTheory.Functor C T)
(G : CategoryTheory.Functor D T) (c : C) {X Y : CategoryTheory.Comma ((CategoryTheory.Under.forget c).c... | null | true |
Mathlib.Tactic.Peel.peelArgs._unsafe_rec | Mathlib.Tactic.Peel | Lean.Expr → ℕ → List Lean.Name → Option Lean.Name → optParam Bool true → Lean.Elab.Tactic.TacticM Unit | null | false |
lintegral_comp_polarCoord_symm | Mathlib.Analysis.SpecialFunctions.PolarCoord | ∀ (f : ℝ × ℝ → ENNReal),
∫⁻ (p : ℝ × ℝ) in polarCoord.target, ENNReal.ofReal p.1 • f (↑polarCoord.symm p) = ∫⁻ (p : ℝ × ℝ), f p | null | true |
Cardinal.mul_eq_self | Mathlib.SetTheory.Cardinal.Arithmetic | ∀ {c : Cardinal.{u_1}}, Cardinal.aleph0 ≤ c → c * c = c | If `α` is an infinite type, then `α × α` and `α` have the same cardinality. | true |
_private.Mathlib.Analysis.SpecialFunctions.Exp.0.Real.isBigO_one_exp_comp._simp_1_1 | Mathlib.Analysis.SpecialFunctions.Exp | 1 = Real.exp 0 | null | false |
_private.Lean.Elab.Match.0.Lean.Elab.Term.elabInaccessible._regBuiltin.Lean.Elab.Term.elabInaccessible_1 | Lean.Elab.Match | IO Unit | null | false |
FreeAddMagma.traverse._f | Mathlib.Algebra.Free | {m : Type u → Type u} →
[Applicative m] → {α β : Type u} → (α → m β) → (x : FreeAddMagma α) → FreeAddMagma.below x → m (FreeAddMagma β) | null | false |
Int.gcd | Init.Data.Int.Gcd | ℤ → ℤ → ℕ | Computes the greatest common divisor of two integers as a natural number. The GCD of two integers is
the largest natural number that evenly divides both. However, the GCD of a number and `0` is the
number's absolute value.
This implementation uses `Nat.gcd`, which is overridden in both the kernel and the compiler to
e... | true |
ClusterPt.le_limsSup._auto_1 | Mathlib.Topology.Order.LiminfLimsup | Lean.Syntax | null | false |
AddSubmonoid.surjOn_iff_le_map | Mathlib.Algebra.Group.Submonoid.Operations | ∀ {M : Type u_1} {N : Type u_2} [inst : AddZeroClass M] [inst_1 : AddZeroClass N] {f : M →+ N} {H : AddSubmonoid M}
{K : AddSubmonoid N}, Set.SurjOn ⇑f ↑H ↑K ↔ K ≤ AddSubmonoid.map f H | null | true |
CategoryTheory.NatTrans.rightDerivedFunctorPlus_fach | Mathlib.Algebra.Homology.DerivedCategory.RightDerivedFunctorPlus | ∀ {C : Type u_1} {D : Type u_2} [inst : CategoryTheory.Category.{v_1, u_1} C]
[inst_1 : CategoryTheory.Category.{v_2, u_2} D] [inst_2 : CategoryTheory.Abelian C]
[inst_3 : CategoryTheory.Abelian D] [inst_4 : HasDerivedCategory C] [inst_5 : HasDerivedCategory D]
[inst_6 : CategoryTheory.EnoughInjectives C] {F₁ F₂ ... | null | true |
continuous_coe_ennreal_ereal | Mathlib.Topology.Instances.EReal.Lemmas | Continuous ENNReal.toEReal | null | true |
Std.IterM.toList_flatMapM | Init.Data.Iterators.Lemmas.Combinators.Monadic.FlatMap | ∀ {α α₂ β γ : Type w} {m : Type w → Type w'} [inst : Monad m] [inst_1 : MonadAttach m] [LawfulMonad m]
[WeaklyLawfulMonadAttach m] [inst_4 : Std.Iterator α m β] [inst_5 : Std.Iterator α₂ m γ] [Std.Iterators.Finite α m]
[Std.Iterators.Finite α₂ m] {f : β → m (Std.IterM m γ)} {it₁ : Std.IterM m β},
(Std.IterM.flatM... | null | true |
CategoryTheory.Triangulated.TStructure.instIsGEObjιHeartOfNatInt | Mathlib.CategoryTheory.Triangulated.TStructure.Heart | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Preadditive C]
[inst_2 : CategoryTheory.Limits.HasZeroObject C] [inst_3 : CategoryTheory.HasShift C ℤ]
[inst_4 : ∀ (n : ℤ), (CategoryTheory.shiftFunctor C n).Additive] [inst_5 : CategoryTheory.Pretriangulated C]
(t : CategoryTheory.... | null | true |
TensorProduct.equivFinsuppOfBasisLeft_symm | Mathlib.LinearAlgebra.TensorProduct.Basis | ∀ {R : Type u_1} {M : Type u_3} {N : Type u_4} {ι : Type u_5} [inst : CommSemiring R] [inst_1 : AddCommMonoid M]
[inst_2 : Module R M] [inst_3 : AddCommMonoid N] [inst_4 : Module R N] [inst_5 : DecidableEq ι]
(ℬ : Module.Basis ι R M),
↑(TensorProduct.equivFinsuppOfBasisLeft ℬ).symm = (Finsupp.lsum R) fun i => (Te... | null | true |
Lean.Elab.DefsParsedSnapshot.casesOn | Lean.Elab.DefView | {motive : Lean.Elab.DefsParsedSnapshot → Sort u} →
(t : Lean.Elab.DefsParsedSnapshot) →
((toSnapshot : Lean.Language.Snapshot) →
(defs : Array Lean.Elab.DefParsed) → motive { toSnapshot := toSnapshot, defs := defs }) →
motive t | null | false |
_private.Mathlib.Data.Finsupp.NeLocus.0.Finsupp.subset_mapRange_neLocus._simp_1_1 | Mathlib.Data.Finsupp.NeLocus | ∀ {a b : Prop}, (¬a → ¬b) = (b → a) | null | false |
_private.Mathlib.MeasureTheory.Function.LpSpace.Complete.0.MeasureTheory.Lp.eLpNorm'_lim_le_liminf_eLpNorm'._simp_1_1 | Mathlib.MeasureTheory.Function.LpSpace.Complete | ∀ (x : ENNReal) (y z : ℝ), (x ^ y) ^ z = x ^ (y * z) | null | false |
Filter.isAddUnit_iff | Mathlib.Order.Filter.Pointwise | ∀ {α : Type u_2} [inst : SubtractionMonoid α] {f : Filter α}, IsAddUnit f ↔ ∃ a, f = pure a ∧ IsAddUnit a | null | true |
_private.Batteries.Data.BinomialHeap.Basic.0.Batteries.BinomialHeap.Imp.Heap.merge._unary._proof_3 | Batteries.Data.BinomialHeap.Basic | ∀ {α : Type u_1} (s₁ : Batteries.BinomialHeap.Imp.Heap α) (r₁ : ℕ) (a₁ : α) (n₁ : Batteries.BinomialHeap.Imp.HeapNode α)
(t₁ : Batteries.BinomialHeap.Imp.Heap α) (h : s₁ = Batteries.BinomialHeap.Imp.Heap.cons r₁ a₁ n₁ t₁)
(s₂ : Batteries.BinomialHeap.Imp.Heap α) (r₂ : ℕ) (a₂ : α) (n₂ : Batteries.BinomialHeap.Imp.He... | null | false |
BoxIntegral.unitPartition.mem_prepartition_iff._simp_1 | Mathlib.Analysis.BoxIntegral.UnitPartition | ∀ {ι : Type u_1} {n : ℕ} [inst : NeZero n] [inst_1 : Fintype ι] {B I : BoxIntegral.Box ι},
(I ∈ BoxIntegral.unitPartition.prepartition n B) =
∃ ν ∈ BoxIntegral.unitPartition.admissibleIndex n B, BoxIntegral.unitPartition.box n ν = I | null | false |
MeasureTheory.Measure.definition._@.Mathlib.MeasureTheory.Constructions.Pi.668077722._hygCtx._hyg.2 | Mathlib.MeasureTheory.Constructions.Pi | {ι : Type u_1} →
{α : ι → Type u_3} →
[Fintype ι] →
[inst : (i : ι) → MeasurableSpace (α i)] →
((i : ι) → MeasureTheory.Measure (α i)) → MeasureTheory.Measure ((i : ι) → α i) | null | false |
_private.Mathlib.Tactic.Widget.Conv.0.Mathlib.Tactic.Conv.Path.ofSubExprPosArray.appT | Mathlib.Tactic.Widget.Conv | (pos : Array ℕ) →
Lean.Expr →
Fin (pos.size + 1) → (acc : List Lean.Expr) → Option (Fin acc.length) → Lean.MetaM Mathlib.Tactic.Conv.Path | Traverse an application from argument to function, accumulating arguments and consuming `pos`
(incrementing `i`) as we approach the head. If `pos[i]` tells us to enter the argument of `.app`
instead of the function at some point, we stop consuming `pos` and start counting arguments
(`some n`) until we hit the head. Thi... | true |
_private.Std.Sat.AIG.Lemmas.0.Std.Sat.AIG.isConstant.match_1.splitter._sparseCasesOn_2 | Std.Sat.AIG.Lemmas | {α : Type} →
{motive : Std.Sat.AIG.Decl α → Sort u} →
(t : Std.Sat.AIG.Decl α) → motive Std.Sat.AIG.Decl.false → (Nat.hasNotBit 1 t.ctorIdx → motive t) → motive t | null | false |
Plausible.Rand.up | Plausible.Random | {α : Type u} → {g : Type} → [RandomGen g] → Plausible.RandG g α → Plausible.RandG g (ULift.{v, u} α) | Given a random generator for `α`, we can convert it to a random generator for `ULift α`. | true |
Matrix.conjTranspose_eq_zero._simp_1 | Mathlib.LinearAlgebra.Matrix.ConjTranspose | ∀ {m : Type u_2} {n : Type u_3} {α : Type v} [inst : AddMonoid α] [inst_1 : StarAddMonoid α] {M : Matrix m n α},
(M.conjTranspose = 0) = (M = 0) | null | false |
Set.mem_center_iff_addMonoidHom | Mathlib.RingTheory.NonUnitalSubsemiring.Basic | ∀ (R : Type u) [inst : NonUnitalNonAssocSemiring R] (a : R),
a ∈ Set.center R ↔
AddMonoidHom.mulLeft a = AddMonoidHom.mulRight a ∧
AddMonoidHom.mul.compr₂ (AddMonoidHom.mulLeft a) = AddMonoidHom.mul.comp (AddMonoidHom.mulLeft a) ∧
AddMonoidHom.mul.compr₂ (AddMonoidHom.mulRight a) = AddMonoidHom.mul.... | A point-free means of proving membership in the center, for a non-associative ring.
This can be helpful when working with types that have ext lemmas for `R →+ R`. | true |
LieSubmodule.toSubmodule_eq_top._simp_1 | Mathlib.Algebra.Lie.Submodule | ∀ {R : Type u} {L : Type v} {M : Type w} [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : AddCommGroup M]
[inst_3 : Module R M] [inst_4 : LieRingModule L M] (N : LieSubmodule R L M), (↑N = ⊤) = (N = ⊤) | null | false |
mdifferentiableOn_iff_of_subset_source | Mathlib.Geometry.Manifold.MFDeriv.Basic | ∀ {𝕜 : 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] {I : ModelWithCorners 𝕜 E H} {M : Type u_4}
[inst_4 : TopologicalSpace M] [inst_5 : ChartedSpace H M] {E' : Type u_5} [inst_6 : NormedAddComm... | If the set where you want `f` to be smooth lies entirely in a single chart, and `f` maps it
into a single chart, the smoothness of `f` on that set can be expressed by purely looking in
these charts.
Note: this lemma uses `extChartAt I x '' s` instead of `(extChartAt I x).symm ⁻¹' s` to ensure
that this set lies in `(ex... | true |
Part.mem_map_iff._simp_1 | Mathlib.Data.Part | ∀ {α : Type u_1} {β : Type u_2} (f : α → β) {o : Part α} {b : β}, (b ∈ Part.map f o) = ∃ a ∈ o, f a = b | null | false |
Matrix.SpecialLinearGroup.coe_pow | Mathlib.LinearAlgebra.Matrix.SpecialLinearGroup | ∀ {n : Type u} [inst : DecidableEq n] [inst_1 : Fintype n] {R : Type v} [inst_2 : CommRing R]
(A : Matrix.SpecialLinearGroup n R) (m : ℕ), ↑(A ^ m) = ↑A ^ m | null | true |
_private.Init.NotationExtra.0.Lean.expandBracketedBindersAux.loop._f | Init.NotationExtra | Lean.Syntax →
(binders : Array Lean.Syntax) →
(i : ℕ) →
Nat.below (motive := fun i => i ≤ binders.size → Lean.Syntax → Lean.MacroM Lean.Syntax) i →
i ≤ binders.size → Lean.Syntax → Lean.MacroM Lean.Syntax | null | false |
Polynomial.isRoot_iterate_derivative_of_lt_rootMultiplicity | Mathlib.Algebra.Polynomial.FieldDivision | ∀ {R : Type u} [inst : CommRing R] {p : Polynomial R} {t : R} {n : ℕ},
n < Polynomial.rootMultiplicity t p → ((⇑Polynomial.derivative)^[n] p).IsRoot t | null | true |
AddHom.addHomClass | Mathlib.Algebra.Group.Hom.Defs | ∀ {M : Type u_4} {N : Type u_5} [inst : Add M] [inst_1 : Add N], AddHomClass (M →ₙ+ N) M N | `AddHom` is a type of addition-preserving homomorphisms | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.