name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
AdicCompletion.AdicCauchySequence.instAddCommGroup._proof_4 | Mathlib.RingTheory.AdicCompletion.Basic | ∀ {R : Type u_1} [inst : CommRing R] (I : Ideal R) (M : Type u_2) [inst_1 : AddCommGroup M] [inst_2 : Module R M]
(x : AdicCompletion.AdicCauchySequence I M), ↑(-x) = ↑(-x) | false |
TrivSqZeroExt.isNilpotent_inr | Mathlib.RingTheory.DualNumber | ∀ {R : Type u_1} {M : Type u_2} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
[inst_3 : Module Rᵐᵒᵖ M] [SMulCommClass R Rᵐᵒᵖ M] (x : M), IsNilpotent (TrivSqZeroExt.inr x) | true |
_private.Lean.Server.Logging.0.Lean.Server.Logging.LogEntry.recOn | Lean.Server.Logging | {motive : Lean.Server.Logging.LogEntry✝ → Sort u} →
(t : Lean.Server.Logging.LogEntry✝) →
((time : Std.Time.ZonedDateTime) →
(direction : Lean.JsonRpc.MessageDirection) →
(kind : Lean.JsonRpc.MessageKind) →
(msg : Lean.JsonRpc.Message) → motive { time := time, direction := direction,... | false |
_private.Lean.Meta.Sym.Offset.0.Lean.Meta.Sym.toOffset._sparseCasesOn_1 | Lean.Meta.Sym.Offset | {α : Type u} →
{motive : Option α → Sort u_1} →
(t : Option α) → ((val : α) → motive (some val)) → (Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t | false |
Summable.tsum_of_nat_of_neg | Mathlib.Topology.Algebra.InfiniteSum.NatInt | ∀ {G : Type u_2} [inst : AddCommGroup G] [inst_1 : TopologicalSpace G] [IsTopologicalAddGroup G] [T2Space G]
{f : ℤ → G},
(Summable fun n => f ↑n) →
(Summable fun n => f (-↑n)) → ∑' (n : ℤ), f n = ∑' (n : ℕ), f ↑n + ∑' (n : ℕ), f (-↑n) - f 0 | true |
Lean.Elab.Command.CtorView.modifiers | Lean.Elab.MutualInductive | Lean.Elab.Command.CtorView → Lean.Elab.Modifiers | true |
Algebra.IsAlgebraic.mk._flat_ctor | Mathlib.RingTheory.Algebraic.Defs | ∀ {R : Type u} {A : Type v} [inst : CommRing R] [inst_1 : Ring A] [inst_2 : Algebra R A],
(∀ (x : A), IsAlgebraic R x) → Algebra.IsAlgebraic R A | false |
CategoryTheory.Functor.LaxMonoidal.ofBifunctor.bottomMapᵣ | Mathlib.CategoryTheory.Monoidal.Multifunctor | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
[inst_1 : CategoryTheory.MonoidalCategory C] →
{D : Type u_2} →
[inst_2 : CategoryTheory.Category.{v_2, u_2} D] →
(F : CategoryTheory.Functor C D) →
((CategoryTheory.MonoidalCategory.curriedTensor C).flip.obj
... | true |
Subarray.mkSlice_roi_eq_mkSlice_rco | Init.Data.Slice.Array.Lemmas | ∀ {α : Type u_1} {xs : Subarray α} {lo : ℕ},
Std.Roi.Sliceable.mkSlice xs lo<...* = Std.Rco.Sliceable.mkSlice xs (lo + 1)...Std.Slice.size xs | true |
LinearEquiv.cast_symm_apply | Mathlib.Algebra.Module.Equiv.Defs | ∀ {R : Type u_1} [inst : Semiring R] {ι : Type u_14} {M : ι → Type u_15} [inst_1 : (i : ι) → AddCommMonoid (M i)]
[inst_2 : (i : ι) → Module R (M i)] {i j : ι} (h : i = j) (a : M j), (LinearEquiv.cast h).symm a = cast ⋯ a | true |
MeasureTheory.MemLp.integrable_enorm_pow | Mathlib.MeasureTheory.Function.L1Space.Integrable | ∀ {α : Type u_1} {ε : Type u_5} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} [inst : TopologicalSpace ε]
[inst_1 : ContinuousENorm ε] {f : α → ε} {p : ℕ},
MeasureTheory.MemLp f (↑p) μ → p ≠ 0 → MeasureTheory.Integrable (fun x => ‖f x‖ₑ ^ p) μ | true |
SkewMonoidAlgebra.liftNCRingHom._proof_1 | Mathlib.Algebra.SkewMonoidAlgebra.Basic | ∀ {k : Type u_1} [inst : Semiring k] {R : Type u_2} [inst_1 : Semiring R], AddMonoidHomClass (k →+* R) k R | false |
Nat.recOnPrimePow._proof_5 | Mathlib.Data.Nat.Factorization.Induction | ∀ (k : ℕ), (k + 2) / (k + 2).minFac ^ (k + 2).factorization (k + 2).minFac < k + 2 | false |
CategoryTheory.LocalizerMorphism.RightResolution.mk_surjective | Mathlib.CategoryTheory.Localization.Resolution | ∀ {C₁ : Type u_1} {C₂ : Type u_2} [inst : CategoryTheory.Category.{v_1, u_1} C₁]
[inst_1 : CategoryTheory.Category.{v_2, u_2} C₂] {W₁ : CategoryTheory.MorphismProperty C₁}
{W₂ : CategoryTheory.MorphismProperty C₂} {Φ : CategoryTheory.LocalizerMorphism W₁ W₂} {X₂ : C₂}
(R : Φ.RightResolution X₂), ∃ X₁ w, ∃ (hw : W... | true |
AffineMap.map_midpoint | Mathlib.LinearAlgebra.AffineSpace.Midpoint | ∀ {R : Type u_1} {V : Type u_2} {V' : Type u_3} {P : Type u_4} {P' : Type u_5} [inst : Ring R] [inst_1 : Invertible 2]
[inst_2 : AddCommGroup V] [inst_3 : Module R V] [inst_4 : AddTorsor V P] [inst_5 : AddCommGroup V']
[inst_6 : Module R V'] [inst_7 : AddTorsor V' P'] (f : P →ᵃ[R] P') (a b : P),
f (midpoint R a b... | true |
Std.DHashMap.getKey?_union_of_not_mem_right | Std.Data.DHashMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {x : BEq α} {x_1 : Hashable α} {m₁ m₂ : Std.DHashMap α β} [EquivBEq α]
[LawfulHashable α] {k : α}, k ∉ m₂ → (m₁ ∪ m₂).getKey? k = m₁.getKey? k | true |
_private.Mathlib.RingTheory.Jacobson.Ideal.0.Ideal.IsLocal.mem_jacobson_or_exists_inv.match_1_3 | Mathlib.RingTheory.Jacobson.Ideal | ∀ {R : Type u_1} [inst : CommRing R] {I : Ideal R} (x : R) (motive : (∃ y ∈ I, ∃ z ∈ Ideal.span {x}, y + z = 1) → Prop)
(x_1 : ∃ y ∈ I, ∃ z ∈ Ideal.span {x}, y + z = 1),
(∀ (p : R) (hpi : p ∈ I) (q : R) (hq : q ∈ Ideal.span {x}) (hpq : p + q = 1), motive ⋯) → motive x_1 | false |
Std.ExtDHashMap.Const.insertManyIfNewUnit_list_eq_empty_iff._simp_1 | Std.Data.ExtDHashMap.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {m : Std.ExtDHashMap α fun x => Unit} [inst : EquivBEq α]
[inst_1 : LawfulHashable α] {l : List α}, (Std.ExtDHashMap.Const.insertManyIfNewUnit m l = ∅) = (m = ∅ ∧ l = []) | false |
Lean.Meta.DiagSummary.data._default | Lean.Meta.Diagnostics | Array Lean.MessageData | false |
Bundle.TotalSpace.recOn | Mathlib.Data.Bundle | {B : Type u_1} →
{F : Type u_4} →
{E : B → Type u_5} →
{motive : Bundle.TotalSpace F E → Sort u} →
(t : Bundle.TotalSpace F E) → ((proj : B) → (snd : E proj) → motive ⟨proj, snd⟩) → motive t | false |
ENNReal.finsetSum_iSup | Mathlib.Data.ENNReal.BigOperators | ∀ {ι : Type u_1} {α : Type u_2} {s : Finset α} {f : α → ι → ENNReal},
(∀ (i j : ι), ∃ k, ∀ (a : α), f a i ≤ f a k ∧ f a j ≤ f a k) → ∑ a ∈ s, ⨆ i, f a i = ⨆ i, ∑ a ∈ s, f a i | true |
Lean.SubExpr.Pos.pushAppArg | Lean.SubExpr | Lean.SubExpr.Pos → Lean.SubExpr.Pos | true |
_private.Batteries.Data.Fin.Lemmas.0.Fin.findSome?_eq_some_iff._simp_1_1 | Batteries.Data.Fin.Lemmas | ∀ {p : Fin 0 → Prop}, (∀ (i : Fin 0), p i) = True | false |
PUnit.instLinearOrderedAddCommMonoidWithTop._proof_3 | Mathlib.Algebra.Order.PUnit | ∀ (x : PUnit.{1}), x ≤ x | false |
Lean.Meta.DiscrTree.getSubexpressionMatches._unsafe_rec | Mathlib.Lean.Meta.DiscrTree | {α : Type} → Lean.Meta.DiscrTree α → Lean.Expr → Lean.MetaM (Array α) | false |
_aux_Mathlib_Algebra_Group_Units_Defs___unexpand_Units_1 | Mathlib.Algebra.Group.Units.Defs | Lean.PrettyPrinter.Unexpander | false |
_private.Lean.Elab.PatternVar.0.Lean.Elab.Term.CollectPatternVars.collect.processImplicitArg._unsafe_rec | Lean.Elab.PatternVar | Bool →
Lean.Elab.Term.CollectPatternVars.Context →
Lean.Elab.Term.CollectPatternVars.M Lean.Elab.Term.CollectPatternVars.Context | false |
_private.Lean.Meta.Tactic.Cbv.Main.0.Lean.Meta.Tactic.Cbv.cbvDecideGoal.match_3 | Lean.Meta.Tactic.Cbv.Main | (motive : Except Lean.Exception Unit → Sort u_1) →
(x : Except Lean.Exception Unit) →
(Unit → motive (Except.ok PUnit.unit)) → ((err : Lean.Exception) → motive (Except.error err)) → motive x | false |
_private.Mathlib.LinearAlgebra.Eigenspace.Basic.0.Module.End.genEigenspace_nat._simp_1_1 | Mathlib.LinearAlgebra.Eigenspace.Basic | ∀ {R : Type v} {M : Type w} [inst : CommRing R] [inst_1 : AddCommGroup M] [inst_2 : Module R M] {f : Module.End R M}
{μ : R} {k : ℕ} {x : M}, (x ∈ (f.genEigenspace μ) ↑k) = (x ∈ ((f - μ • 1) ^ k).ker) | false |
IsAddUnit.of_add_eq_zero_right | Mathlib.Algebra.Group.Units.Defs | ∀ {M : Type u_1} [inst : AddMonoid M] [IsDedekindFiniteAddMonoid M] {b : M} (a : M), a + b = 0 → IsAddUnit b | true |
MeasureTheory.VectorMeasure.dirac._proof_2 | Mathlib.MeasureTheory.VectorMeasure.Basic | ∀ {β : Type u_1} {M : Type u_2} [inst : AddCommMonoid M] [inst_1 : MeasurableSpace β] (x : β) (v : M) ⦃i : Set β⦄,
¬MeasurableSet i → (if MeasurableSet i ∧ x ∈ i then v else 0) = 0 | false |
_private.Mathlib.RingTheory.Spectrum.Prime.ChevalleyComplexity.0.ChevalleyThm.PolynomialC.induction_aux._simp_1_9 | Mathlib.RingTheory.Spectrum.Prime.ChevalleyComplexity | ∀ {α : Type u_2} {β : Type u_3} [inst : SMul α β] {ι : Sort u_5} (a : α) (f : ι → β),
(Set.range fun i => a • f i) = a • Set.range f | false |
UniqueFactorizationMonoid.radical_ne_zero._simp_1 | Mathlib.RingTheory.Radical.Basic | ∀ {M : Type u_1} [inst : CommMonoidWithZero M] [inst_1 : NormalizationMonoid M] [inst_2 : UniqueFactorizationMonoid M]
{a : M} [Nontrivial M], (UniqueFactorizationMonoid.radical a = 0) = False | false |
DirectSum.IsInternal.exists_subordinateOrthonormalBasisIndex_eq | Mathlib.Analysis.InnerProductSpace.PiL2 | ∀ {ι : Type u_1} {𝕜 : Type u_3} [inst : RCLike 𝕜] {E : Type u_4} [inst_1 : NormedAddCommGroup E]
[inst_2 : InnerProductSpace 𝕜 E] [inst_3 : Fintype ι] [inst_4 : FiniteDimensional 𝕜 E] {n : ℕ}
(hn : Module.finrank 𝕜 E = n) [inst_5 : DecidableEq ι] {V : ι → Submodule 𝕜 E} (hV : DirectSum.IsInternal V)
(hV' : ... | true |
LinearOrderedCommGroupWithZero.toLinearOrderedCommMonoidWithZero | Mathlib.Algebra.Order.GroupWithZero.Canonical | {α : Type u_3} → [self : LinearOrderedCommGroupWithZero α] → LinearOrderedCommMonoidWithZero α | true |
_private.Mathlib.Tactic.CongrExclamation.0.Congr!.plausiblyEqualTypes.match_5 | Mathlib.Tactic.CongrExclamation | (motive : ℕ → Sort u_1) → (maxDepth : ℕ) → (Unit → motive 0) → ((maxDepth : ℕ) → motive maxDepth.succ) → motive maxDepth | false |
CochainComplex.isKProjective_shift_iff | Mathlib.Algebra.Homology.HomotopyCategory.KProjective | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Abelian C]
(K : CochainComplex C ℤ) (n : ℤ),
((CategoryTheory.shiftFunctor (CochainComplex C ℤ) n).obj K).IsKProjective ↔ K.IsKProjective | true |
Hyperreal.coe_add | Mathlib.Analysis.Real.Hyperreal | ∀ (x y : ℝ), ↑(x + y) = ↑x + ↑y | true |
Bundle.Prod.contMDiffVectorBundle | Mathlib.Geometry.Manifold.VectorBundle.Basic | ∀ {n : WithTop ℕ∞} {𝕜 : Type u_1} {B : Type u_2} [inst : NontriviallyNormedField 𝕜] {EB : Type u_7}
[inst_1 : NormedAddCommGroup EB] [inst_2 : NormedSpace 𝕜 EB] {HB : Type u_8} [inst_3 : TopologicalSpace HB]
{IB : ModelWithCorners 𝕜 EB HB} [inst_4 : TopologicalSpace B] [inst_5 : ChartedSpace HB B] (F₁ : Type u_... | true |
CategoryTheory.ProjectiveResolution.liftFOne._proof_3 | Mathlib.CategoryTheory.Abelian.Projective.Resolution | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Abelian C] {Y : C}
(P : CategoryTheory.ProjectiveResolution Y), CategoryTheory.Projective (P.complex.X 1) | false |
Std.DTreeMap.Raw.Equiv.of_toList_perm | Std.Data.DTreeMap.Raw.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t₁ t₂ : Std.DTreeMap.Raw α β cmp},
t₁.toList.Perm t₂.toList → t₁.Equiv t₂ | true |
PEquiv.ofSet_eq_refl._simp_1 | Mathlib.Data.PEquiv | ∀ {α : Type u} {s : Set α} [inst : DecidablePred fun x => x ∈ s], (PEquiv.ofSet s = PEquiv.refl α) = (s = Set.univ) | false |
_private.Mathlib.NumberTheory.Padics.Hensel.0.newton_seq_aux._proof_1 | Mathlib.NumberTheory.Padics.Hensel | ∀ {p : ℕ} [inst : Fact (Nat.Prime p)] {R : Type u_1} [inst_1 : CommSemiring R] [inst_2 : Algebra R ℤ_[p]]
{F : Polynomial R} {a : ℤ_[p]}
(hnorm : ‖(Polynomial.aeval a) F‖ < ‖(Polynomial.aeval a) (Polynomial.derivative F)‖ ^ 2) (k : ℕ),
ih_gen✝ k ↑(newton_seq_aux✝ hnorm k) | false |
ContDiffMapSupportedIn.seminorm._proof_3 | Mathlib.Analysis.Distribution.ContDiffMapSupportedIn | ∀ (𝕜 : Type u_1) (F : Type u_2) [inst : NontriviallyNormedField 𝕜] [inst_1 : NormedAddCommGroup F]
[inst_2 : NormedSpace 𝕜 F], ContinuousConstSMul 𝕜 F | false |
JordanHolderLattice.rec | Mathlib.Order.JordanHolder | {X : Type u} →
[inst : Lattice X] →
{motive : JordanHolderLattice X → Sort u_1} →
((IsMaximal : X → X → Prop) →
(lt_of_isMaximal : ∀ {x y : X}, IsMaximal x y → x < y) →
(sup_eq_of_isMaximal : ∀ {x y z : X}, IsMaximal x z → IsMaximal y z → x ≠ y → x ⊔ y = z) →
(isMaximal_i... | false |
descPochhammer | Mathlib.RingTheory.Polynomial.Pochhammer | (R : Type u) → [inst : Ring R] → ℕ → Polynomial R | true |
Lean.Parser.Tactic.Grind.«grind_filterGen≤_» | Init.Grind.Interactive | Lean.ParserDescr | true |
CategoryTheory.Comonad.Coalgebra.isoMk | Mathlib.CategoryTheory.Monad.Algebra | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{G : CategoryTheory.Comonad C} →
{A B : G.Coalgebra} →
(h : A.A ≅ B.A) →
autoParam
(CategoryTheory.CategoryStruct.comp A.a (G.map h.hom) = CategoryTheory.CategoryStruct.comp h.hom B.a)
CategoryTheory.... | true |
CategoryTheory.AddMon.instCartesianMonoidalCategory.eq_1 | Mathlib.CategoryTheory.Monoidal.Cartesian.Mon_ | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v, u_1} C] [inst_1 : CategoryTheory.CartesianMonoidalCategory C]
[inst_2 : CategoryTheory.BraidedCategory C],
CategoryTheory.AddMon.instCartesianMonoidalCategory =
{ toMonoidalCategory := CategoryTheory.AddMon.monMonoidal,
isTerminalTensorUnit :=
C... | true |
Matrix.mul_right_inj_of_invertible | Mathlib.LinearAlgebra.Matrix.NonsingularInverse | ∀ {m : Type u} {n : Type u'} {α : Type v} [inst : Fintype n] [inst_1 : DecidableEq n] [inst_2 : CommRing α]
(A : Matrix n n α) [Invertible A] {x y : Matrix n m α}, A * x = A * y ↔ x = y | true |
Std.ExtHashSet.size_diff_le_size_left | Std.Data.ExtHashSet.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {m₁ m₂ : Std.ExtHashSet α} [inst : EquivBEq α]
[inst_1 : LawfulHashable α], (m₁ \ m₂).size ≤ m₁.size | true |
ProperConstVAdd.mk._flat_ctor | Mathlib.Topology.Algebra.ProperConstSMul | ∀ {M : Type u_1} {X : Type u_2} [inst : VAdd M X] [inst_1 : TopologicalSpace X],
(∀ (c : M), IsProperMap fun x => c +ᵥ x) → ProperConstVAdd M X | false |
Bundle.Trivialization.coe_linearMapAt | Mathlib.Topology.VectorBundle.Basic | ∀ {R : Type u_1} {B : Type u_2} {F : Type u_3} {E : B → Type u_4} [inst : Semiring R] [inst_1 : TopologicalSpace F]
[inst_2 : TopologicalSpace B] [inst_3 : TopologicalSpace (Bundle.TotalSpace F E)] [inst_4 : AddCommMonoid F]
[inst_5 : Module R F] [inst_6 : (x : B) → AddCommMonoid (E x)] [inst_7 : (x : B) → Module R... | true |
ENNReal.instCompleteLinearOrder._aux_26 | Mathlib.Data.ENNReal.Basic | DecidableLT ENNReal | false |
Std.Roo.mk.inj | Init.Data.Range.Polymorphic.PRange | ∀ {α : Type u} {lower upper lower_1 upper_1 : α},
((lower<...upper) = lower_1<...upper_1) → lower = lower_1 ∧ upper = upper_1 | true |
CategoryTheory.MonoidalCategory.monoidalOfLawfulDayConvolutionMonoidalCategoryStruct._proof_3 | Mathlib.CategoryTheory.Monoidal.DayConvolution | ∀ (C : Type u_3) [inst : CategoryTheory.Category.{u_6, u_3} C] (V : Type u_5)
[inst_1 : CategoryTheory.Category.{u_4, u_5} V] [inst_2 : CategoryTheory.MonoidalCategory C]
[inst_3 : CategoryTheory.MonoidalCategory V] (D : Type u_2) [inst_4 : CategoryTheory.Category.{u_1, u_2} D]
[inst_5 : CategoryTheory.MonoidalCa... | false |
WithLp.instUnitizationNormedAddCommGroup | Mathlib.Analysis.Normed.Algebra.UnitizationL1 | (𝕜 : Type u_1) →
(A : Type u_2) →
[inst : NormedField 𝕜] →
[inst_1 : NonUnitalNormedRing A] → [NormedSpace 𝕜 A] → NormedAddCommGroup (WithLp 1 (Unitization 𝕜 A)) | true |
CategoryTheory.Limits.Bicone.ι_π._autoParam | Mathlib.CategoryTheory.Limits.Shapes.Biproducts | Lean.Syntax | false |
Multiset.Subset.ndinter_eq_left | Mathlib.Data.Multiset.FinsetOps | ∀ {α : Type u_1} [inst : DecidableEq α] {s t : Multiset α}, s ⊆ t → s.ndinter t = s | true |
_private.Mathlib.Topology.Category.CompHaus.EffectiveEpi.0.CompHaus.effectiveEpiFamily_tfae._simp_1_3 | Mathlib.Topology.Category.CompHaus.EffectiveEpi | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.FinitaryPreExtensive C]
{α : Type} [inst_2 : Finite α] {B : C} (X : α → C) (π : (a : α) → X a ⟶ B),
CategoryTheory.EffectiveEpiFamily X π = CategoryTheory.EffectiveEpi (CategoryTheory.Limits.Sigma.desc π) | false |
BoundedContinuousFunction.hasNatPow._proof_1 | Mathlib.Topology.ContinuousMap.Bounded.Normed | ∀ {α : Type u_2} [inst : TopologicalSpace α] {R : Type u_1} [inst_1 : SeminormedRing R]
(f : BoundedContinuousFunction α R) (n : ℕ),
∃ C, ∀ (x y : α), dist ((f.toContinuousMap ^ n).toFun x) ((f.toContinuousMap ^ n).toFun y) ≤ C | false |
Lean.DefinitionVal.all | Lean.Declaration | Lean.DefinitionVal → List Lean.Name | true |
SpecialLinearGroup.coe_div | Mathlib.LinearAlgebra.SpecialLinearGroup | ∀ {R : Type u_1} {V : Type u_2} [inst : CommRing R] [inst_1 : AddCommGroup V] [inst_2 : Module R V]
(A B : SpecialLinearGroup R V), ↑(A / B) = ↑A / ↑B | true |
Lean.Parser.Tactic.MCasesPat | Std.Tactic.Do.Syntax | Type | true |
NonUnitalSubsemiring.inclusion._proof_1 | Mathlib.RingTheory.NonUnitalSubsemiring.Defs | ∀ {R : Type u_1} [inst : NonUnitalNonAssocSemiring R] {S : NonUnitalSubsemiring R},
NonUnitalRingHomClass (↥S →ₙ+* R) (↥S) R | false |
_private.Lean.Elab.Match.0.Lean.Elab.Term.elabMatchTypeAndDiscrs.elabDiscrs._unsafe_rec | Lean.Elab.Match | Array Lean.Syntax →
Array Lean.Elab.Term.TermMatchAltView →
Lean.Expr → ℕ → Array Lean.Elab.Term.Discr → Lean.Elab.TermElabM Lean.Elab.Term.ElabMatchTypeAndDiscrsResult | false |
Std.TreeMap.Raw.equiv_iff_keys_unit_perm | Std.Data.TreeMap.Raw.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t₁ t₂ : Std.TreeMap.Raw α Unit cmp}, t₁.Equiv t₂ ↔ t₁.keys.Perm t₂.keys | true |
Array.forM_append | Init.Data.Array.Monadic | ∀ {m : Type u_1 → Type u_2} {α : Type u_3} [inst : Monad m] [LawfulMonad m] {xs ys : Array α}
{f : α → m PUnit.{u_1 + 1}},
forM (xs ++ ys) f = do
forM xs f
forM ys f | true |
CategoryTheory.ShortComplex.SnakeInput.composableArrowsFunctor._proof_2 | Mathlib.Algebra.Homology.ShortComplex.SnakeLemma | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Abelian C]
(X : CategoryTheory.ShortComplex.SnakeInput C),
CategoryTheory.ComposableArrows.homMk₅ (CategoryTheory.CategoryStruct.id X).f₀.τ₁
(CategoryTheory.CategoryStruct.id X).f₀.τ₂ (CategoryTheory.CategoryStruct.id X).f... | false |
Ordinal.max_zero_right | Mathlib.SetTheory.Ordinal.Basic | ∀ (a : Ordinal.{u_1}), max a 0 = a | true |
_private.Mathlib.Order.Interval.Set.LinearOrder.0.Set.Ioc_inter_Ioc._proof_1_1 | Mathlib.Order.Interval.Set.LinearOrder | ∀ {α : Type u_1} [inst : LinearOrder α] {a₁ a₂ b₁ b₂ : α},
Set.Ioc b₁ a₁ ∩ Set.Ioc b₂ a₂ = Set.Ioc (max b₁ b₂) (min a₁ a₂) | false |
Algebra.IsPushout.symm | Mathlib.RingTheory.IsTensorProduct | ∀ {R : Type u_1} {S : Type v₃} [inst : CommSemiring R] [inst_1 : CommSemiring S] [inst_2 : Algebra R S] {R' : Type u_6}
{S' : Type u_7} [inst_3 : CommSemiring R'] [inst_4 : CommSemiring S'] [inst_5 : Algebra R R'] [inst_6 : Algebra S S']
[inst_7 : Algebra R' S'] [inst_8 : Algebra R S'] [inst_9 : IsScalarTower R R' ... | true |
Interval._aux_Mathlib_Order_Interval_Set_UnorderedInterval___macroRules_Interval_termΙ_1 | Mathlib.Order.Interval.Set.UnorderedInterval | Lean.Macro | false |
Std.DTreeMap.Internal.Impl.Const.getThenInsertIfNew? | Std.Data.DTreeMap.Internal.Operations | {α : Type u} →
{β : Type v} →
[Ord α] →
(t : Std.DTreeMap.Internal.Impl α fun x => β) →
α → β → t.Balanced → Option β × Std.DTreeMap.Internal.Impl α fun x => β | true |
CategoryTheory.ObjectProperty.homMk_surjective | Mathlib.CategoryTheory.ObjectProperty.FullSubcategory | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {P : CategoryTheory.ObjectProperty C}
{X Y : P.FullSubcategory}, Function.Surjective CategoryTheory.ObjectProperty.homMk | true |
Lean.CollectMVars.State.result | Lean.Util.CollectMVars | Lean.CollectMVars.State → Array Lean.MVarId | true |
Module.Basis.constrL._proof_1 | Mathlib.Topology.Algebra.Module.FiniteDimension | ∀ {𝕜 : Type u_1} [hnorm : NontriviallyNormedField 𝕜] {E : Type u_2} [inst : AddCommGroup E] [inst_1 : Module 𝕜 E]
{ι : Type u_3} [Finite ι] (v : Module.Basis ι 𝕜 E), FiniteDimensional 𝕜 E | false |
Substring.Raw.str | Init.Prelude | Substring.Raw → String | true |
DirectLimit.instCommGroupWithZeroOfMonoidWithZeroHomClass._proof_7 | Mathlib.Algebra.Colimit.DirectLimit | ∀ {ι : Type u_1} [inst : Preorder ι] {G : ι → Type u_2} {T : ⦃i j : ι⦄ → i ≤ j → Type u_3}
{f : (x x_1 : ι) → (h : x ≤ x_1) → T h} [inst_1 : (i j : ι) → (h : i ≤ j) → FunLike (T h) (G i) (G j)]
[inst_2 : DirectedSystem G fun x1 x2 x3 => ⇑(f x1 x2 x3)] [inst_3 : IsDirectedOrder ι] [inst_4 : Nonempty ι]
[inst_5 : (... | false |
Lean.Meta.NormCast.normCastExt | Lean.Meta.Tactic.NormCast | Lean.Meta.NormCast.NormCastExtension | true |
TopCat.isoOfHomeo._proof_1 | Mathlib.Topology.Category.TopCat.Basic | ∀ {X Y : TopCat}, ContinuousMapClass (↑X ≃ₜ ↑Y) ↑X ↑Y | false |
LocallyFinite.exists_finset_support | Mathlib.Topology.Algebra.Monoid | ∀ {ι : Type u_1} {X : Type u_5} [inst : TopologicalSpace X] {M : Type u_6} [inst_1 : Zero M] {f : ι → X → M},
(LocallyFinite fun i => Function.support (f i)) →
∀ (x₀ : X), ∃ I, ∀ᶠ (x : X) in nhds x₀, (Function.support fun i => f i x) ⊆ ↑I | true |
Equiv.completeAtomicBooleanAlgebra._proof_6 | Mathlib.Order.CompleteBooleanAlgebra | ∀ {α : Type u_1} {β : Type u_2} (e : α ≃ β) [inst : CompleteAtomicBooleanAlgebra β] (s : Set α),
e (e.symm (⨅ a ∈ s, e a)) = ⨅ a ∈ s, e a | false |
_private.Lean.Server.Completion.CompletionInfoSelection.0.Lean.Server.Completion.findCompletionInfosAt.go.match_3 | Lean.Server.Completion.CompletionInfoSelection | (motive : Lean.Elab.Info → Sort u_1) →
(info : Lean.Elab.Info) →
((completionInfo : Lean.Elab.CompletionInfo) → motive (Lean.Elab.Info.ofCompletionInfo completionInfo)) →
((x : Lean.Elab.Info) → motive x) → motive info | false |
CategoryTheory.Limits.image.compIso._proof_1 | Mathlib.CategoryTheory.Limits.Shapes.Images | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {Y Z : C} (g : Y ⟶ Z) [CategoryTheory.IsIso g],
CategoryTheory.Mono g | false |
Mathlib.Tactic.ToDual.data | Mathlib.Tactic.Translate.ToDual | Mathlib.Tactic.Translate.TranslateData | true |
_private.Lean.PrettyPrinter.Delaborator.TopDownAnalyze.0.Lean.PrettyPrinter.Delaborator.TopDownAnalyze.containsBadMax._sparseCasesOn_1 | Lean.PrettyPrinter.Delaborator.TopDownAnalyze | {motive : Lean.Level → Sort u} →
(t : Lean.Level) →
((a : Lean.Level) → motive a.succ) →
((a a_1 : Lean.Level) → motive (a.max a_1)) →
((a a_1 : Lean.Level) → motive (a.imax a_1)) → (Nat.hasNotBit 14 t.ctorIdx → motive t) → motive t | false |
_private.Mathlib.Analysis.Fourier.ZMod.0.ZMod.auxDFT_smul | Mathlib.Analysis.Fourier.ZMod | ∀ {N : ℕ} [inst : NeZero N] {E : Type u_1} [inst_1 : AddCommGroup E] [inst_2 : Module ℂ E] (c : ℂ) (Φ : ZMod N → E),
ZMod.auxDFT✝ (c • Φ) = c • ZMod.auxDFT✝ Φ | true |
cantorToTernary_ne_one | Mathlib.Topology.Instances.CantorSet | ∀ {x : ℝ} {n : ℕ}, (cantorToTernary x).get n ≠ 1 | true |
CategoryTheory.Tor._proof_4 | Mathlib.CategoryTheory.Monoidal.Tor | ∀ (C : Type u_2) [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.MonoidalCategory C]
[inst_2 : CategoryTheory.Abelian C] [inst_3 : CategoryTheory.MonoidalPreadditive C]
[inst_4 : CategoryTheory.HasProjectiveResolutions C] (n : ℕ) {X Y Z : C} (f : X ⟶ Y) (g : Y ⟶ Z),
CategoryTheory.NatTrans.... | false |
CommAlgCat.inv_hom_apply | Mathlib.Algebra.Category.CommAlgCat.Basic | ∀ {R : Type u} [inst : CommRing R] {A B : CommAlgCat R} (e : A ≅ B) (x : ↑A),
(CategoryTheory.ConcreteCategory.hom e.inv) ((CategoryTheory.ConcreteCategory.hom e.hom) x) = x | true |
Lean.AssocList.nil.elim | Lean.Data.AssocList | {α : Type u} →
{β : Type v} →
{motive : Lean.AssocList α β → Sort u_1} →
(t : Lean.AssocList α β) → t.ctorIdx = 0 → motive Lean.AssocList.nil → motive t | false |
CategoryTheory.SimplicialObject.Homotopy.mk._flat_ctor | Mathlib.AlgebraicTopology.SimplicialObject.Homotopy | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{X Y : CategoryTheory.SimplicialObject C} →
{f g : X ⟶ Y} →
(h : {n : ℕ} → Fin (n + 1) → (X.obj (Opposite.op { len := n }) ⟶ Y.obj (Opposite.op { len := n + 1 }))) →
(∀ (n : ℕ), CategoryTheory.CategoryStruct.comp (h 0) (Y.δ 0) = g.... | false |
clusterPt_principal_subtype_iff_frequently | Mathlib.Topology.NhdsWithin | ∀ {α : Type u_1} [inst : TopologicalSpace α] {s t : Set α},
s ⊆ t →
∀ {J : Set ↑s} {a : ↑s},
ClusterPt a (Filter.principal J) ↔ ∃ᶠ (x : α) in nhdsWithin (↑a) t, ∃ (h : x ∈ s), ⟨x, h⟩ ∈ J | true |
MeasureTheory.laverage_mul_measure_univ | Mathlib.MeasureTheory.Integral.Average | ∀ {α : Type u_1} {m0 : MeasurableSpace α} (μ : MeasureTheory.Measure α) [MeasureTheory.IsFiniteMeasure μ]
(f : α → ENNReal), (⨍⁻ (a : α), f a ∂μ) * μ Set.univ = ∫⁻ (x : α), f x ∂μ | true |
Std.DTreeMap.Internal.Impl.Const.get!ₘ | Std.Data.DTreeMap.Internal.Model | {α : Type u} → {β : Type v} → [Ord α] → (Std.DTreeMap.Internal.Impl α fun x => β) → α → [Inhabited β] → β | true |
String.skipPrefix? | Init.Data.String.TakeDrop | {ρ : Type} → (s : String) → (pat : ρ) → [String.Slice.Pattern.ForwardPattern pat] → Option s.Pos | true |
Std.Internal.IO.Async.DNS.NameInfo.mk.injEq | Std.Internal.Async.DNS | ∀ (host service host_1 service_1 : String),
({ host := host, service := service } = { host := host_1, service := service_1 }) =
(host = host_1 ∧ service = service_1) | true |
_private.Mathlib.Computability.TuringMachine.PostTuringMachine.0.Turing.TM1.stmts₁_supportsStmt_mono._simp_1_15 | Mathlib.Computability.TuringMachine.PostTuringMachine | ∀ {α : Type u_1} [inst : DecidableEq α] {s t : Finset α} {a : α}, (a ∈ s ∪ t) = (a ∈ s ∨ a ∈ t) | false |
Ideal.span_singleton_absNorm_le | Mathlib.RingTheory.Ideal.Norm.AbsNorm | ∀ {S : Type u_1} [inst : CommRing S] [inst_1 : Nontrivial S] [inst_2 : IsDedekindDomain S] [inst_3 : Module.Free ℤ S]
(I : Ideal S), Ideal.span {↑(Ideal.absNorm I)} ≤ I | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.