name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
Std.Iter.toArray.eq_1 | Init.Data.Iterators.Lemmas.Combinators.FlatMap | ∀ {α β : Type w} [inst : Std.Iterator α Id β] (it : Std.Iter β), it.toArray = it.toIterM.toArray.run | true |
Nat.minFac_eq | Mathlib.Data.Nat.Prime.Defs | ∀ (n : ℕ), n.minFac = if 2 ∣ n then 2 else n.minFacAux 3 | true |
_private.Init.Data.BitVec.Lemmas.0.BitVec.toInt_ushiftRight_of_lt._proof_1_5 | Init.Data.BitVec.Lemmas | ∀ {w : ℕ} {x : BitVec w} {n : ℕ}, 0 < n → n ≤ w → ¬(w - n).succ ≤ w → False | false |
Real.iteratedDerivWithin_cos_Icc | Mathlib.Analysis.SpecialFunctions.Trigonometric.Deriv | ∀ (n : ℕ) {a b : ℝ},
a < b → ∀ {x : ℝ}, x ∈ Set.Icc a b → iteratedDerivWithin n Real.cos (Set.Icc a b) x = iteratedDeriv n Real.cos x | true |
Algebra.Generators.Hom.mk.inj | Mathlib.RingTheory.Extension.Generators | ∀ {R : Type u} {S : Type v} {ι : Type w} {inst : CommRing R} {inst_1 : CommRing S} {inst_2 : Algebra R S}
{P : Algebra.Generators R S ι} {R' : Type u_1} {S' : Type u_2} {ι' : Type u_3} {inst_3 : CommRing R'}
{inst_4 : CommRing S'} {inst_5 : Algebra R' S'} {P' : Algebra.Generators R' S' ι'} {inst_6 : Algebra S S'}
... | true |
Lean.PrettyPrinter.Parenthesizer.categoryParser.parenthesizer.match_1 | Lean.PrettyPrinter.Parenthesizer | (motive : List Lean.PrettyPrinter.CategoryParenthesizer → Sort u_1) →
(x : List Lean.PrettyPrinter.CategoryParenthesizer) →
((p : Lean.PrettyPrinter.CategoryParenthesizer) →
(tail : List Lean.PrettyPrinter.CategoryParenthesizer) → motive (p :: tail)) →
((x : List Lean.PrettyPrinter.CategoryParenthes... | false |
Lean.Meta.Grind.propagateDIte | Lean.Meta.Tactic.Grind.Propagate | Lean.Meta.Grind.Propagator | true |
CategoryTheory.Bicategory.whiskerLeft_hom_inv_whiskerRight_assoc | Mathlib.CategoryTheory.Bicategory.Basic | ∀ {B : Type u} [inst : CategoryTheory.Bicategory B] {a b c d : B} (f : a ⟶ b) {g h : b ⟶ c} (η : g ≅ h) (k : c ⟶ d)
{Z : a ⟶ d} (h_1 : CategoryTheory.CategoryStruct.comp f (CategoryTheory.CategoryStruct.comp g k) ⟶ Z),
CategoryTheory.CategoryStruct.comp
(CategoryTheory.Bicategory.whiskerLeft f (CategoryTheory... | true |
IsTensorProduct.equiv_apply | Mathlib.RingTheory.IsTensorProduct | ∀ {R : Type u_1} [inst : CommSemiring R] {M₁ : Type u_2} {M₂ : Type u_3} {M : Type u_4} [inst_1 : AddCommMonoid M₁]
[inst_2 : AddCommMonoid M₂] [inst_3 : AddCommMonoid M] [inst_4 : Module R M₁] [inst_5 : Module R M₂]
[inst_6 : Module R M] {f : M₁ →ₗ[R] M₂ →ₗ[R] M} (h : IsTensorProduct f) (a : TensorProduct R M₁ M₂)... | true |
Lean.Elab.Term.Do.ToTerm.Context.mk.injEq | Lean.Elab.Do.Legacy | ∀ (m returnType : Lean.Syntax) (uvars : Array Lean.Elab.Term.Do.Var) (kind : Lean.Elab.Term.Do.ToTerm.Kind)
(m_1 returnType_1 : Lean.Syntax) (uvars_1 : Array Lean.Elab.Term.Do.Var) (kind_1 : Lean.Elab.Term.Do.ToTerm.Kind),
({ m := m, returnType := returnType, uvars := uvars, kind := kind } =
{ m := m_1, retur... | true |
_private.Mathlib.InformationTheory.KullbackLeibler.Basic.0.InformationTheory.toReal_klDiv_smul_right._simp_1_4 | Mathlib.InformationTheory.KullbackLeibler.Basic | ∀ {α : Type u_2} [inst : Zero α] [inst_1 : OfNat α 4] [NeZero 4], (4 = 0) = False | false |
SemiNormedGrp.instCoeSortType | Mathlib.Analysis.Normed.Group.SemiNormedGrp | CoeSort SemiNormedGrp (Type u_1) | true |
Mathlib.Meta.NormNum.isInt_add | Mathlib.Tactic.NormNum.Basic | ∀ {α : Type u_1} [inst : Ring α] {f : α → α → α} {a b : α} {a' b' c : ℤ},
f = HAdd.hAdd →
Mathlib.Meta.NormNum.IsInt a a' →
Mathlib.Meta.NormNum.IsInt b b' → a'.add b' = c → Mathlib.Meta.NormNum.IsInt (f a b) c | true |
_private.Mathlib.Topology.LocallyFinite.0.LocallyFinite.comp_injOn.match_1_1 | Mathlib.Topology.LocallyFinite | ∀ {ι : Type u_2} {X : Type u_1} [inst : TopologicalSpace X] {f : ι → Set X} (x : X)
(motive : (∃ t ∈ nhds x, {i | (f i ∩ t).Nonempty}.Finite) → Prop)
(x_1 : ∃ t ∈ nhds x, {i | (f i ∩ t).Nonempty}.Finite),
(∀ (t : Set X) (htx : t ∈ nhds x) (htf : {i | (f i ∩ t).Nonempty}.Finite), motive ⋯) → motive x_1 | false |
_private.Mathlib.Order.Cover.0.Pi.covBy_iff_exists_left_eq._simp_1_2 | Mathlib.Order.Cover | ∀ {α : Sort u_1} {a b : α}, (a = b) = (b = a) | false |
ZNum.pred | Mathlib.Data.Num.Basic | ZNum → ZNum | true |
MeasureTheory.Measure.addHaarMeasure_eq_iff | Mathlib.MeasureTheory.Measure.Haar.Basic | ∀ {G : Type u_1} [inst : AddGroup G] [inst_1 : TopologicalSpace G] [inst_2 : IsTopologicalAddGroup G]
[inst_3 : MeasurableSpace G] [inst_4 : BorelSpace G] [SecondCountableTopology G]
(K₀ : TopologicalSpace.PositiveCompacts G) (μ : MeasureTheory.Measure G) [MeasureTheory.SigmaFinite μ]
[μ.IsAddLeftInvariant], Meas... | true |
Composition.ones | Mathlib.Combinatorics.Enumerative.Composition | (n : ℕ) → Composition n | true |
TopologicalSpace.Closeds.complOrderIso | Mathlib.Topology.Sets.Closeds | (α : Type u_2) → [inst : TopologicalSpace α] → TopologicalSpace.Closeds α ≃o (TopologicalSpace.Opens α)ᵒᵈ | true |
AddSubmonoid.gciMapComap.eq_1 | Mathlib.Algebra.Group.Submonoid.Operations | ∀ {M : Type u_1} {N : Type u_2} [inst : AddZeroClass M] [inst_1 : AddZeroClass N] {F : Type u_4}
[inst_2 : FunLike F M N] [mc : AddMonoidHomClass F M N] {f : F} (hf : Function.Injective ⇑f),
AddSubmonoid.gciMapComap hf = ⋯.toGaloisCoinsertion ⋯ | true |
_private.Mathlib.Data.Num.Lemmas.0.PosNum.cmp.match_1.eq_6 | Mathlib.Data.Num.Lemmas | ∀ (motive : PosNum → PosNum → Sort u_1) (a b : PosNum) (h_1 : Unit → motive PosNum.one PosNum.one)
(h_2 : (x : PosNum) → motive x PosNum.one) (h_3 : (x : PosNum) → motive PosNum.one x)
(h_4 : (a b : PosNum) → motive a.bit0 b.bit0) (h_5 : (a b : PosNum) → motive a.bit0 b.bit1)
(h_6 : (a b : PosNum) → motive a.bit1... | true |
CategoryTheory.Coreflective.mk.noConfusion | Mathlib.CategoryTheory.Adjunction.Reflective | {C : Type u₁} →
{D : Type u₂} →
{inst : CategoryTheory.Category.{v₁, u₁} C} →
{inst_1 : CategoryTheory.Category.{v₂, u₂} D} →
{L : CategoryTheory.Functor C D} →
{P : Sort u} →
{toFull : L.Full} →
{toFaithful : L.Faithful} →
{R : CategoryTheory.Func... | false |
GenLoop.fromLoop_coe | Mathlib.Topology.Homotopy.HomotopyGroup | ∀ {N : Type u_1} {X : Type u_2} [inst : TopologicalSpace X] {x : X} [inst_1 : DecidableEq N] (i : N)
(p : LoopSpace (↑(GenLoop { j // j ≠ i } X x)) GenLoop.const),
↑(GenLoop.fromLoop i p) =
({ toFun := Subtype.val, continuous_toFun := ⋯ }.comp p.toContinuousMap).uncurry.comp ↑(Cube.splitAt i) | true |
Set.ne_univ_iff_exists_notMem | Mathlib.Data.Set.Basic | ∀ {α : Type u_1} (s : Set α), s ≠ Set.univ ↔ ∃ a, a ∉ s | true |
_private.Mathlib.SetTheory.Cardinal.Basic.0.Cardinal.add_lt_aleph0_iff.match_1_1 | Mathlib.SetTheory.Cardinal.Basic | ∀ {a b : Cardinal.{u_1}} (motive : a < Cardinal.aleph0 ∧ b < Cardinal.aleph0 → Prop)
(x : a < Cardinal.aleph0 ∧ b < Cardinal.aleph0),
(∀ (h1 : a < Cardinal.aleph0) (h2 : b < Cardinal.aleph0), motive ⋯) → motive x | false |
Algebra.PreSubmersivePresentation.baseChange | Mathlib.RingTheory.Extension.Presentation.Submersive | {R : Type u} →
{S : Type v} →
{ι : Type w} →
{σ : Type t} →
[inst : CommRing R] →
[inst_1 : CommRing S] →
[inst_2 : Algebra R S] →
(T : Type u_1) →
[inst_3 : CommRing T] →
[inst_4 : Algebra R T] →
Algebra.PreSu... | true |
GrpCat.hasLimitsOfShape | Mathlib.Algebra.Category.Grp.Limits | ∀ {J : Type v} [inst : CategoryTheory.Category.{w, v} J] [Small.{u, v} J],
CategoryTheory.Limits.HasLimitsOfShape J GrpCat | true |
ShrinkingLemma.PartialRefinement.noConfusionType | Mathlib.Topology.ShrinkingLemma | Sort u →
{ι : Type u_1} →
{X : Type u_2} →
[inst : TopologicalSpace X] →
{u : ι → Set X} →
{s : Set X} →
{p : Set X → Prop} →
ShrinkingLemma.PartialRefinement u s p →
{ι' : Type u_1} →
{X' : Type u_2} →
[inst' ... | false |
ContinuousLinearMap.toBilinForm_inj | Mathlib.Topology.Algebra.Module.StrongTopology | ∀ {𝕜 : Type u_2} {E : Type u_5} [inst : NormedField 𝕜] [inst_1 : AddCommGroup E] [inst_2 : Module 𝕜 E]
[inst_3 : TopologicalSpace E] (L₁ L₂ : E →L[𝕜] E →L[𝕜] 𝕜), L₁.toBilinForm = L₂.toBilinForm ↔ L₁ = L₂ | true |
CategoryTheory.CostructuredArrow.faithful_map₂ | Mathlib.CategoryTheory.Comma.StructuredArrow.Basic | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
{T : D} {S : CategoryTheory.Functor C D} {A : Type u₃} [inst_2 : CategoryTheory.Category.{v₃, u₃} A] {B : Type u₄}
[inst_3 : CategoryTheory.Category.{v₄, u₄} B] {U : CategoryTheory.Functor A B} {V... | true |
CategoryTheory.Pretriangulated.Triangle.epi₁ | Mathlib.CategoryTheory.Triangulated.Pretriangulated | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasZeroObject C]
[inst_2 : CategoryTheory.HasShift C ℤ] [inst_3 : CategoryTheory.Preadditive C]
[inst_4 : ∀ (n : ℤ), (CategoryTheory.shiftFunctor C n).Additive] [hC : CategoryTheory.Pretriangulated C],
∀ T ∈ CategoryTheory.Pr... | true |
IsPrimitiveRoot.ne_one | Mathlib.RingTheory.RootsOfUnity.PrimitiveRoots | ∀ {M : Type u_1} [inst : CommMonoid M] {k : ℕ} {ζ : M}, IsPrimitiveRoot ζ k → 1 < k → ζ ≠ 1 | true |
Ordinal.IsFundamentalSequence.strict_mono | Mathlib.SetTheory.Ordinal.FundamentalSequence | ∀ {a o : Ordinal.{u}} {f : (b : Ordinal.{u}) → b < o → Ordinal.{u}},
a.IsFundamentalSequence o f → ∀ {i j : Ordinal.{u}} (hi : i < o) (hj : j < o), i < j → f i hi < f j hj | true |
WeierstrassCurve.Jacobian.baseChange_addXYZ | Mathlib.AlgebraicGeometry.EllipticCurve.Jacobian.Formula | ∀ {R : Type r} {S : Type s} {A : Type u} {B : Type v} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : CommRing A]
[inst_3 : CommRing B] {W' : WeierstrassCurve.Jacobian R} [inst_4 : Algebra R S] [inst_5 : Algebra R A]
[inst_6 : Algebra S A] [IsScalarTower R S A] [inst_8 : Algebra R B] [inst_9 : Algebra S B] [IsS... | true |
Lean.Elab.Term.registerMVarErrorInfo | Lean.Elab.Term.TermElabM | Lean.Elab.Term.MVarErrorInfo → Lean.Elab.TermElabM Unit | true |
Cardinal.cantorFunctionAux_true | Mathlib.Analysis.Real.Cardinality | ∀ {c : ℝ} {f : ℕ → Bool} {n : ℕ}, f n = true → Cardinal.cantorFunctionAux c f n = c ^ n | true |
_private.Mathlib.LinearAlgebra.Pi.0.LinearMap.disjoint_single_single._simp_1_3 | Mathlib.LinearAlgebra.Pi | ∀ {R : Type u_1} {M : Type u_3} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] {ι : Sort u_4}
(p : ι → Submodule R M) {x : M}, (x ∈ ⨅ i, p i) = ∀ (i : ι), x ∈ p i | false |
Metric.edistLtTopSetoid._proof_2 | Mathlib.Topology.EMetricSpace.Defs | ∀ {α : Type u_1} [inst : PseudoEMetricSpace α] {x y : α}, edist x y < ⊤ → edist y x < ⊤ | false |
List.mem_pi_toList | Mathlib.Data.FinEnum | ∀ {α : Type u_1} [inst : FinEnum α] {β : α → Type u_2} [inst_1 : (a : α) → FinEnum (β a)] (xs : List α)
(f : (a : α) → a ∈ xs → β a), f ∈ xs.pi fun x => FinEnum.toList (β x) | true |
IsAlgClosed.degree_eq_one_of_irreducible | Mathlib.FieldTheory.IsAlgClosed.Basic | ∀ (k : Type u) [inst : Field k] [IsAlgClosed k] {p : Polynomial k}, Irreducible p → p.degree = 1 | true |
_private.Mathlib.Order.Antisymmetrization.0.wellFoundedLT_antisymmetrization_iff._simp_1_1 | Mathlib.Order.Antisymmetrization | ∀ (α : Type u) (r : α → α → Prop), IsWellFounded α r = WellFounded r | false |
_private.Std.Internal.Async.System.0.Std.Internal.IO.Async.System.instDecidableEqCPUTimes.decEq.match_1 | Std.Internal.Async.System | (motive : Std.Internal.IO.Async.System.CPUTimes → Std.Internal.IO.Async.System.CPUTimes → Sort u_1) →
(x x_1 : Std.Internal.IO.Async.System.CPUTimes) →
((a a_1 a_2 a_3 a_4 b b_1 b_2 b_3 b_4 : Std.Time.Millisecond.Offset) →
motive { userTime := a, niceTime := a_1, systemTime := a_2, idleTime := a_3, interr... | false |
Applicative.seqRight._default | Init.Prelude | {f : Type u → Type v} →
({α β : Type u} → (α → β) → f α → f β) →
({α β : Type u} → α → f β → f α) →
({α β : Type u} → f (α → β) → (Unit → f α) → f β) → {α β : Type u} → f α → (Unit → f β) → f β | false |
groupCohomology.exists_mul_galRestrict_of_norm_eq_one | Mathlib.RepresentationTheory.Homological.GroupCohomology.Hilbert90 | ∀ {K L : Type} [inst : Field K] [inst_1 : Field L] [inst_2 : Algebra K L] [FiniteDimensional K L]
[inst_4 : IsGalois K L] [IsCyclic Gal(L/K)] {g : Gal(L/K)} {A : Type u_1} {B : Type u_2} [inst_6 : CommRing A]
[inst_7 : CommRing B] [inst_8 : Algebra A B] [inst_9 : Algebra A L] [inst_10 : Algebra A K] [inst_11 : Alge... | true |
Nat.Primrec.below.comp | Mathlib.Computability.Primrec.Basic | ∀ {motive : (a : ℕ → ℕ) → Nat.Primrec a → Prop} {f g : ℕ → ℕ} (a : Nat.Primrec f) (a_1 : Nat.Primrec g),
Nat.Primrec.below a → motive f a → Nat.Primrec.below a_1 → motive g a_1 → Nat.Primrec.below ⋯ | true |
_private.Init.Data.UInt.Lemmas.0.USize.lt_of_lt_of_le._simp_1_1 | Init.Data.UInt.Lemmas | ∀ {a b : USize}, (a ≤ b) = (a.toNat ≤ b.toNat) | false |
RestrictedProduct.instNSMul.eq_1 | 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 : ι) → AddMonoid (R i)] [inst_2 : ∀ (i : ι), AddSubmonoidClass (S i) (R i)],
RestrictedProduct.instNSMul R = { smul := fun x x_1 => ⟨fun i => x • x_1 i, ⋯⟩ } | true |
CategoryTheory.Pretopology.toGrothendieck | Mathlib.CategoryTheory.Sites.Pretopology | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
[inst_1 : CategoryTheory.Limits.HasPullbacks C] →
CategoryTheory.Pretopology C → CategoryTheory.GrothendieckTopology C | true |
_private.Lean.Meta.IndPredBelow.0.Lean.Meta.IndPredBelow.Context._sizeOf_1 | Lean.Meta.IndPredBelow | Lean.Meta.IndPredBelow.Context✝ → ℕ | false |
Lean.Omega.Fin.lt_or_gt_of_ne | Init.Omega.Int | ∀ {n : ℕ} {i j : Fin n}, i ≠ j → i < j ∨ i > j | true |
Field.lift_rank_mul_lift_sepDegree_of_isSeparable | Mathlib.FieldTheory.PurelyInseparable.Tower | ∀ (F : Type u) (E : Type v) [inst : Field F] [inst_1 : Field E] [inst_2 : Algebra F E] (K : Type w) [inst_3 : Field K]
[inst_4 : Algebra F K] [inst_5 : Algebra E K] [IsScalarTower F E K] [Algebra.IsSeparable F E],
Cardinal.lift.{w, v} (Module.rank F E) * Cardinal.lift.{v, w} (Field.sepDegree E K) =
Cardinal.lif... | true |
Matrix.blockDiagonalAddMonoidHom | Mathlib.Data.Matrix.Block | (m : Type u_2) →
(n : Type u_3) →
(o : Type u_4) →
(α : Type u_12) → [DecidableEq o] → [inst : AddZeroClass α] → (o → Matrix m n α) →+ Matrix (m × o) (n × o) α | true |
_private.Mathlib.CategoryTheory.Triangulated.TriangleShift.0.CategoryTheory.Pretriangulated.Triangle.shiftFunctor._simp_1 | Mathlib.CategoryTheory.Triangulated.TriangleShift | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
(self : CategoryTheory.Functor C D) {X Y Z : C} (f : X ⟶ Y) (g : Y ⟶ Z),
CategoryTheory.CategoryStruct.comp (self.map f) (self.map g) = self.map (CategoryTheory.CategoryStruct.comp f g) | false |
QuaternionAlgebra.instStarRing._proof_3 | Mathlib.Algebra.Quaternion | ∀ {R : Type u_1} {c₁ c₂ c₃ : R} [inst : CommRing R] (a b : QuaternionAlgebra R c₁ c₂ c₃), star (a + b) = star a + star b | false |
Lean.Lsp.DidChangeWatchedFilesParams.mk.injEq | Lean.Data.Lsp.Workspace | ∀ (changes changes_1 : Array Lean.Lsp.FileEvent),
({ changes := changes } = { changes := changes_1 }) = (changes = changes_1) | true |
_private.Init.Data.List.Basic.0.List.lengthTRAux.match_1.splitter | Init.Data.List.Basic | {α : Type u_1} →
(motive : List α → ℕ → Sort u_2) →
(x : List α) →
(x_1 : ℕ) →
((n : ℕ) → motive [] n) → ((head : α) → (as : List α) → (n : ℕ) → motive (head :: as) n) → motive x x_1 | true |
_private.Lean.Meta.IndPredBelow.0.Lean.Meta.IndPredBelow.NewDecl.below.noConfusion | Lean.Meta.IndPredBelow | {P : Sort u} →
{decl : Lean.LocalDecl} →
{indName : Lean.Name} →
{vars : Array Lean.FVarId} →
{decl' : Lean.LocalDecl} →
{indName' : Lean.Name} →
{vars' : Array Lean.FVarId} →
Lean.Meta.IndPredBelow.NewDecl.below✝ decl indName vars =
Lean.Meta.In... | false |
Action.instConcreteCategoryHomSubtypeV._proof_7 | Mathlib.CategoryTheory.Action.Basic | ∀ (V : Type u_2) [inst : CategoryTheory.Category.{u_1, u_2} V] (G : Type u_3) [inst_1 : Monoid G]
{FV : V → V → Type u_5} {CV : V → Type u_4} [inst_2 : (X Y : V) → FunLike (FV X Y) (CV X) (CV Y)]
[inst_3 : CategoryTheory.ConcreteCategory V FV] {X Y Z : Action V G} (x : X ⟶ Y) (x_1 : Y ⟶ Z) (x_2 : CV X.V),
(Catego... | false |
SemiNormedGrp._sizeOf_1 | Mathlib.Analysis.Normed.Group.SemiNormedGrp | SemiNormedGrp → ℕ | false |
Matrix.SpecialLinearGroup.coe_int_neg | Mathlib.LinearAlgebra.Matrix.SpecialLinearGroup | ∀ {n : Type u} [inst : DecidableEq n] [inst_1 : Fintype n] {R : Type v} [inst_2 : CommRing R]
[inst_3 : Fact (Even (Fintype.card n))] (g : Matrix.SpecialLinearGroup n ℤ),
(Matrix.SpecialLinearGroup.map (Int.castRingHom R)) (-g) = -(Matrix.SpecialLinearGroup.map (Int.castRingHom R)) g | true |
Subgroup.saturated_iff_npow | Mathlib.GroupTheory.Subgroup.Saturated | ∀ {G : Type u_1} [inst : Monoid G] {H : Submonoid G}, H.PowSaturated ↔ ∀ (n : ℕ) (g : G), g ^ n ∈ H → n = 0 ∨ g ∈ H | true |
UpperSet.erase._proof_1 | Mathlib.Order.UpperLower.Closure | ∀ {α : Type u_1} [inst : Preorder α] (s : UpperSet α) (a : α), IsUpperSet (↑s \ ↑(LowerSet.Iic a)) | false |
HVertexOperator.coeff._proof_5 | Mathlib.Algebra.Vertex.HVertexOperator | ∀ {Γ : Type u_2} [inst : PartialOrder Γ] {R : Type u_1} {W : Type u_3} [inst_1 : CommRing R] [inst_2 : AddCommGroup W]
[inst_3 : Module R W], SMulCommClass R R (HahnModule Γ R W) | false |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.Const.maxKey!_modify._simp_1_3 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {x : Ord α} {t : Std.DTreeMap.Internal.Impl α β} {k : α},
(k ∈ t) = (Std.DTreeMap.Internal.Impl.contains k t = true) | false |
CategoryTheory.GrothendieckTopology.W_of_preservesSheafification | Mathlib.CategoryTheory.Sites.PreservesSheafification | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (J : CategoryTheory.GrothendieckTopology C) {A : Type u_1}
{B : Type u_2} [inst_1 : CategoryTheory.Category.{v_1, u_1} A] [inst_2 : CategoryTheory.Category.{v_2, u_2} B]
(F : CategoryTheory.Functor A B) [J.PreservesSheafification F] {P₁ P₂ : CategoryTheory.Fu... | true |
DFinsupp.instDecidableEq.match_1 | Mathlib.Data.DFinsupp.Defs | ∀ {ι : Type u_1} {β : ι → Type u_2} [inst : DecidableEq ι] [inst_1 : (i : ι) → Zero (β i)]
[inst_2 : (i : ι) → DecidableEq (β i)] (f g : Π₀ (i : ι), β i)
(motive : (f.support = g.support ∧ ∀ i ∈ f.support, f i = g i) → Prop)
(x : f.support = g.support ∧ ∀ i ∈ f.support, f i = g i),
(∀ (h₁ : f.support = g.suppor... | false |
_private.Mathlib.CategoryTheory.ComposableArrows.Basic.0.CategoryTheory.ComposableArrows.isoMk₅._proof_5 | Mathlib.CategoryTheory.ComposableArrows.Basic | ¬2 + 1 ≤ 5 → False | false |
Std.DHashMap.Const.get_alter_self | Std.Data.DHashMap.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {β : Type v} {m : Std.DHashMap α fun x => β} [inst : EquivBEq α]
[inst_1 : LawfulHashable α] {k : α} {f : Option β → Option β} {h : k ∈ Std.DHashMap.Const.alter m k f},
Std.DHashMap.Const.get (Std.DHashMap.Const.alter m k f) k h = (f (Std.DHashMap.Const.get? m k)).get ⋯ | true |
_private.Mathlib.Data.Nat.Choose.Sum.0.Nat.sum_range_choose_halfway._proof_1_1 | Mathlib.Data.Nat.Choose.Sum | ∀ (m : ℕ), m + 1 ≤ 2 * m + 1 + 1 | false |
Complex.sin.eq_1 | Mathlib.Analysis.Complex.Trigonometric | ∀ (z : ℂ), Complex.sin z = (Complex.exp (-z * Complex.I) - Complex.exp (z * Complex.I)) * Complex.I / 2 | true |
CategoryTheory.SimplicialObject.Augmented.w₀_assoc | Mathlib.AlgebraicTopology.SimplicialObject.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y : CategoryTheory.SimplicialObject.Augmented C} (f : X ⟶ Y)
{Z : C} (h : Y.right ⟶ Z),
CategoryTheory.CategoryStruct.comp (f.left.app (Opposite.op (SimplexCategory.mk 0)))
(CategoryTheory.CategoryStruct.comp (Y.hom.app (Opposite.op (SimplexCategory.... | true |
InvolutiveNeg.recOn | Mathlib.Algebra.Group.Defs | {A : Type u_2} →
{motive : InvolutiveNeg A → Sort u} →
(t : InvolutiveNeg A) →
([toNeg : Neg A] → (neg_neg : ∀ (x : A), - -x = x) → motive { toNeg := toNeg, neg_neg := neg_neg }) → motive t | false |
Polynomial.Splits.X._simp_1 | Mathlib.Algebra.Polynomial.Splits | ∀ {R : Type u_1} [inst : Semiring R], Polynomial.X.Splits = True | false |
contDiffOn_congr | Mathlib.Analysis.Calculus.ContDiff.Defs | ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {E : Type uE} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {F : Type uF} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {s : Set E}
{f f₁ : E → F} {n : WithTop ℕ∞}, (∀ x ∈ s, f₁ x = f x) → (ContDiffOn 𝕜 n f₁ s ↔ ContDiffOn 𝕜 n f s) | true |
translate_add' | Mathlib.Algebra.Group.Translate | ∀ {α : Type u_2} {G : Type u_5} [inst : AddCommGroup G] (a b : G) (f : G → α),
translate (a + b) f = translate b (translate a f) | true |
compHausToTop.createsLimits | Mathlib.Topology.Category.CompHaus.Basic | CategoryTheory.CreatesLimits compHausToTop | true |
_private.Mathlib.CategoryTheory.GradedObject.Unitor.0.CategoryTheory.GradedObject.mapBifunctor_triangle._simp_1_1 | Mathlib.CategoryTheory.GradedObject.Unitor | ∀ {obj : Type u} [self : CategoryTheory.Category.{v, u} obj] {W X Y Z : obj} (f : W ⟶ X) (g : X ⟶ Y) (h : Y ⟶ Z),
CategoryTheory.CategoryStruct.comp f (CategoryTheory.CategoryStruct.comp g h) =
CategoryTheory.CategoryStruct.comp (CategoryTheory.CategoryStruct.comp f g) h | false |
HomologicalComplex.HomologySequence.snakeInput._proof_27 | Mathlib.Algebra.Homology.HomologySequence | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Abelian C],
CategoryTheory.ShortComplex.π₃.PreservesZeroMorphisms | false |
Lean.Elab.Tactic.Conv.evalNestedTactic | Lean.Elab.Tactic.Conv.Basic | Lean.Elab.Tactic.Tactic | true |
Lean.Elab.Tactic.Conv.evalFirst._regBuiltin.Lean.Elab.Tactic.Conv.evalFirst_1 | Lean.Elab.Tactic.Conv.Basic | IO Unit | false |
Lean.Elab.Term.Do.Alt.noConfusionType | Lean.Elab.Do.Legacy | Sort u → {σ : Type} → Lean.Elab.Term.Do.Alt σ → {σ' : Type} → Lean.Elab.Term.Do.Alt σ' → Sort u | false |
Lean.Elab.Term.Do.ToTerm.returnToTerm | Lean.Elab.Do.Legacy | Lean.Syntax → Lean.Elab.Term.Do.ToTerm.M Lean.Syntax | true |
MeasureTheory.FiniteMeasure.normalize_eq_inv_mass_smul_of_nonzero | Mathlib.MeasureTheory.Measure.ProbabilityMeasure | ∀ {Ω : Type u_1} [inst : Nonempty Ω] {m0 : MeasurableSpace Ω} (μ : MeasureTheory.FiniteMeasure Ω),
μ ≠ 0 → μ.normalize.toFiniteMeasure = μ.mass⁻¹ • μ | true |
Lean.PrettyPrinter.Formatter.Context | Lean.PrettyPrinter.Formatter | Type | true |
List.SortedLE.of_map_toDual | Mathlib.Data.List.Sort | ∀ {α : Type u_1} [inst : Preorder α] {l : List α}, l.SortedLE → (List.map (⇑OrderDual.toDual) l).SortedGE | true |
Finset.sum_singleton | Mathlib.Algebra.BigOperators.Group.Finset.Basic | ∀ {ι : Type u_1} {M : Type u_4} [inst : AddCommMonoid M] (f : ι → M) (a : ι), ∑ x ∈ {a}, f x = f a | true |
Nat.mul_le_add_right | Init.Data.Nat.Lemmas | ∀ {m k n : ℕ}, k * m ≤ m + n ↔ (k - 1) * m ≤ n | true |
Std.DTreeMap.get?_inter | Std.Data.DTreeMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t₁ t₂ : Std.DTreeMap α β cmp} [Std.TransCmp cmp]
[inst : Std.LawfulEqCmp cmp] {k : α}, (t₁ ∩ t₂).get? k = if k ∈ t₂ then t₁.get? k else none | true |
MeasureTheory.StronglyAdapted.integrable_upcrossingsBefore | Mathlib.Probability.Martingale.Upcrossing | ∀ {Ω : Type u_1} {m0 : MeasurableSpace Ω} {μ : MeasureTheory.Measure Ω} {a b : ℝ} {f : ℕ → Ω → ℝ} {N : ℕ}
{ℱ : MeasureTheory.Filtration ℕ m0} [MeasureTheory.IsFiniteMeasure μ],
MeasureTheory.StronglyAdapted ℱ f →
a < b → MeasureTheory.Integrable (fun ω => ↑(MeasureTheory.upcrossingsBefore a b f N ω)) μ | true |
Lean.Lsp.DocumentSymbol.mk.noConfusion | Lean.Data.Lsp.LanguageFeatures | {P : Sort u} →
{sym sym' : Lean.Lsp.DocumentSymbolAux Lean.Lsp.DocumentSymbol} →
Lean.Lsp.DocumentSymbol.mk sym = Lean.Lsp.DocumentSymbol.mk sym' → (sym = sym' → P) → P | false |
Fin.reverseInduction._proof_3 | Init.Data.Fin.Lemmas | ∀ {n : ℕ} (i : Fin (n + 1)), ↑i ≤ 0 → ¬↑i = 0 → False | false |
Filter.isBoundedUnder_const | Mathlib.Order.Filter.IsBounded | ∀ {α : Type u_1} {β : Type u_2} {r : α → α → Prop} [Std.Refl r] {l : Filter β} {a : α},
Filter.IsBoundedUnder r l fun x => a | true |
CategoryTheory.Localization.Monoidal.instLiftingLocalizedMonoidalToMonoidalCategoryCompTensorRightObjFunctorFlipTensorBifunctor | Mathlib.CategoryTheory.Localization.Monoidal.Basic | {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] →
(L : CategoryTheory.Functor C D) →
(W : CategoryTheory.MorphismProperty C) →
[inst_2 : CategoryTheory.MonoidalCategory C] →
[inst_3 ... | true |
WithTop.Ioc_coe_top | Mathlib.Order.Interval.Finset.Defs | ∀ (α : Type u_1) [inst : PartialOrder α] [inst_1 : OrderTop α] [inst_2 : LocallyFiniteOrder α] (a : α),
Finset.Ioc ↑a ⊤ = Finset.insertNone (Finset.Ioi a) | true |
Std.Internal.UV.System.PasswdInfo._sizeOf_1 | Std.Internal.UV.System | Std.Internal.UV.System.PasswdInfo → ℕ | false |
UInt32.reduceOfNat._regBuiltin.UInt32.reduceOfNat.declare_1._@.Lean.Meta.Tactic.Simp.BuiltinSimprocs.UInt.2998934274._hygCtx._hyg.340 | Lean.Meta.Tactic.Simp.BuiltinSimprocs.UInt | IO Unit | false |
CStarMatrix.conjTranspose_apply | Mathlib.Analysis.CStarAlgebra.CStarMatrix | ∀ {m : Type u_1} {n : Type u_2} {A : Type u_5} [inst : Star A] (M : CStarMatrix m n A) (i : n) (j : m),
M.conjTranspose i j = star (M j i) | true |
CategoryTheory.MonoidalOpposite.unmopEquiv_functor_map | Mathlib.CategoryTheory.Monoidal.Opposite | ∀ (C : Type u₁) [inst : CategoryTheory.Category.{v₁, u₁} C] {X Y : Cᴹᵒᵖ} (f : X ⟶ Y),
(CategoryTheory.MonoidalOpposite.unmopEquiv C).functor.map f = f.unmop | true |
CategoryTheory.Iso.retract | Mathlib.CategoryTheory.Retract | {C : Type u} → [inst : CategoryTheory.Category.{v, u} C] → {X Y : C} → (X ≅ Y) → CategoryTheory.Retract X Y | true |
Qq.Impl.floatQMatch | Qq.Match | Lean.TSyntax `Lean.Parser.Term.doSeqIndent →
Lean.Term → StateT (List (Lean.TSyntax `Lean.Parser.Term.doSeqItem)) Lean.MacroM Lean.Term | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.