name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11.5k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
Nat.lt_of_lt_of_eq | Init.Data.Nat.Basic | ∀ {n m k : ℕ}, n < m → m = k → n < k | null | true |
Mathlib.Tactic.FieldSimp._aux_Mathlib_Tactic_Field___elabRules_Mathlib_Tactic_FieldSimp_field_1 | Mathlib.Tactic.Field | Lean.Elab.Tactic.Tactic | `field` solves equality goals in (semi-)fields. The goal must be an equality which is *universal*,
in the sense that it is true in any field in which the appropriate denominators don't vanish.
(That is, it is a consequence purely of the field axioms.)
The `field` tactic is built from the tactics `field_simp` (which cl... | false |
_private.Mathlib.Combinatorics.Enumerative.IncidenceAlgebra.0.IncidenceAlgebra.moebius_inversion_top._simp_1_10 | Mathlib.Combinatorics.Enumerative.IncidenceAlgebra | ∀ {M : Type u_4} [inst : AddMonoid M] [IsLeftCancelAdd M] {a b : M}, (a + b = a) = (b = 0) | null | false |
Lean.PrettyPrinter.Delaborator.OmissionReason.noConfusionType | Lean.PrettyPrinter.Delaborator.Basic | Sort u → Lean.PrettyPrinter.Delaborator.OmissionReason → Lean.PrettyPrinter.Delaborator.OmissionReason → Sort u | null | false |
FinsetFamily._aux_Mathlib_Combinatorics_SetFamily_Compression_UV___unexpand_UV_compression_1 | Mathlib.Combinatorics.SetFamily.Compression.UV | Lean.PrettyPrinter.Unexpander | null | false |
_private.Mathlib.SetTheory.Ordinal.FixedPointApproximants.0.OrdinalApprox.lfpApprox_ord_eq_lfp._simp_1_3 | Mathlib.SetTheory.Ordinal.FixedPointApproximants | ∀ {α : Sort u} {p : α → Prop} {q : { a // p a } → Prop}, (∃ x, q x) = ∃ a, ∃ (b : p a), q ⟨a, b⟩ | null | false |
iterateInduction._proof_3 | Mathlib.Probability.Kernel.IonescuTulcea.Traj | ∀ (k : ℕ) (i : ↥(Finset.Iic k)), InvImage (fun x1 x2 => x1 < x2) (fun x => x) (↑i) k.succ | null | false |
IsUnifLocDoublingMeasure.wrapped._@.Mathlib.MeasureTheory.Covering.DensityTheorem.1554790178._hygCtx._hyg.2 | Mathlib.MeasureTheory.Covering.DensityTheorem | Subtype (Eq @IsUnifLocDoublingMeasure.definition✝) | null | false |
Std.ExtDTreeMap.Const.getKeyD_insertManyIfNewUnit_list_of_not_mem_of_mem | Std.Data.ExtDTreeMap.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t : Std.ExtDTreeMap α (fun x => Unit) cmp} [inst : Std.TransCmp cmp]
{l : List α} {k k' fallback : α},
cmp k k' = Ordering.eq →
k ∉ t →
List.Pairwise (fun a b => ¬cmp a b = Ordering.eq) l →
k ∈ l → (Std.ExtDTreeMap.Const.insertManyIfNewUnit t l).getKeyD k' ... | null | true |
RatFunc.instAlgebraOfPolynomial | Mathlib.FieldTheory.RatFunc.Basic | (K : Type u) →
[inst : CommRing K] →
[inst_1 : IsDomain K] →
(R : Type u_1) → [inst_2 : CommSemiring R] → [Algebra R (Polynomial K)] → Algebra R (RatFunc K) | null | true |
CategoryTheory.IsKernelPair.lift_snd_assoc | Mathlib.CategoryTheory.Limits.Shapes.KernelPair | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {R X Y : C} {f : X ⟶ Y} {a b : R ⟶ X} {S : C}
(k : CategoryTheory.IsKernelPair f a b) (p q : S ⟶ X)
(w : CategoryTheory.CategoryStruct.comp p f = CategoryTheory.CategoryStruct.comp q f) {Z : C} (h : X ⟶ Z),
CategoryTheory.CategoryStruct.comp (k.lift p q w) ... | null | true |
CategoryTheory.ShortComplex.hasLeftHomology_of_epi_of_isIso_of_mono' | Mathlib.Algebra.Homology.ShortComplex.LeftHomology | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{S₁ S₂ : CategoryTheory.ShortComplex C} (φ : S₁ ⟶ S₂) [S₂.HasLeftHomology] [CategoryTheory.Epi φ.τ₁]
[CategoryTheory.IsIso φ.τ₂] [CategoryTheory.Mono φ.τ₃], S₁.HasLeftHomology | null | true |
CategoryTheory.Limits.BinaryBicone.ofLimitCone._proof_6 | Mathlib.CategoryTheory.Preadditive.Biproducts | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Preadditive C] {X Y : C}
{t : CategoryTheory.Limits.Cone (CategoryTheory.Limits.pair X Y)} (ht : CategoryTheory.Limits.IsLimit t),
CategoryTheory.CategoryStruct.comp
(CategoryTheory.Limits.BinaryFan.IsLimit.lift ht 0 (Cate... | null | false |
_private.Mathlib.Analysis.Complex.Trigonometric.0.Mathlib.Meta.Positivity.evalCosh.match_1 | Mathlib.Analysis.Complex.Trigonometric | (motive :
(u : Lean.Level) →
{α : Q(Type u)} →
(x : Q(Zero «$α»)) →
(x_1 : Q(PartialOrder «$α»)) →
(e : Q(«$α»)) →
Lean.MetaM (Mathlib.Meta.Positivity.Strictness x x_1 e) →
Lean.MetaM (Mathlib.Meta.Positivity.Strictness x x_1 e) → Sort u_1) →
(u : ... | null | false |
AddAction.prodOfVAddCommClass.eq_1 | Mathlib.Algebra.Group.Action.Prod | ∀ (M : Type u_1) (N : Type u_2) (α : Type u_5) [inst : AddMonoid M] [inst_1 : AddMonoid N] [inst_2 : AddAction M α]
[inst_3 : AddAction N α] [inst_4 : VAddCommClass M N α],
AddAction.prodOfVAddCommClass M N α = { vadd := fun mn a => mn.1 +ᵥ mn.2 +ᵥ a, add_vadd := ⋯, zero_vadd := ⋯ } | null | true |
Finpartition.empty._proof_1 | Mathlib.Order.Partition.Finpartition | ∀ (α : Type u_1) [inst : Lattice α] [inst_1 : OrderBot α], ∅.SupIndep id | null | false |
CategoryTheory.IsPreconnected.mk._flat_ctor | Mathlib.CategoryTheory.IsConnected | ∀ {J : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} J],
(∀ {α : Type u₁} (F : CategoryTheory.Functor J (CategoryTheory.Discrete α)) (j : J),
Nonempty (F ≅ (CategoryTheory.Functor.const J).obj (F.obj j))) →
CategoryTheory.IsPreconnected J | null | false |
IsFractionRing.ringEquivOfRingEquiv_algebraMap | Mathlib.RingTheory.Localization.FractionRing | ∀ {A : Type u_8} {K : Type u_9} {B : Type u_10} {L : Type u_11} [inst : CommRing A] [inst_1 : CommRing B]
[inst_2 : CommRing K] [inst_3 : CommRing L] [inst_4 : Algebra A K] [inst_5 : IsFractionRing A K]
[inst_6 : Algebra B L] [inst_7 : IsFractionRing B L] (h : A ≃+* B) (a : A),
(IsFractionRing.ringEquivOfRingEqui... | null | true |
Std.Time.WallTime._sizeOf_1 | Std.Time.DateTime.WallTime | Std.Time.WallTime → ℕ | null | false |
Matrix.nonAssocSemiring | Mathlib.Data.Matrix.Mul | {n : Type u_3} → {α : Type v} → [NonAssocSemiring α] → [Fintype n] → [DecidableEq n] → NonAssocSemiring (Matrix n n α) | null | true |
Mathlib.Tactic.Ring.ExProd.evalIntCast._f | Mathlib.Tactic.Ring.Basic | {u : Lean.Level} →
{α : Q(Type u)} →
(sα : Q(CommSemiring «$α»)) →
{v : Lean.Level} →
{β : Q(Type v)} →
(sβ : Q(CommSemiring «$β»)) →
(rα : Q(CommRing «$α»)) →
{a : Q(ℤ)} →
(va : Mathlib.Tactic.Ring.ExProd sβ a) →
Mathlib.Tactic.R... | null | false |
_private.Mathlib.Algebra.BigOperators.Fin.0.Fin.prod_uIcc_castSucc._simp_1_1 | Mathlib.Algebra.BigOperators.Fin | ∀ {n : ℕ} (i j : Fin n), Finset.uIcc i.castSucc j.castSucc = Finset.map Fin.castSuccEmb (Finset.uIcc i j) | null | false |
AddSubgroup.normal_addSubgroupOf_addCommutator_sup | Mathlib.GroupTheory.Commutator.Basic | ∀ {G : Type u_1} [inst : AddGroup G] (H₁ H₂ : AddSubgroup G), (⁅H₁, H₂⁆.addSubgroupOf (H₁ ⊔ H₂)).Normal | null | true |
_private.Mathlib.Topology.Semicontinuity.Basic.0.upperSemiContinuous_inv_iff._simp_1_1 | Mathlib.Topology.Semicontinuity.Basic | ∀ {α : Type u_1} {β : Type u_2} [inst : TopologicalSpace α] [inst_1 : Preorder β] {f : α → β},
UpperSemicontinuous f = UpperSemicontinuousOn f Set.univ | null | false |
_private.Mathlib.Topology.Separation.Hausdorff.0.t2_iff_nhds._simp_1_4 | Mathlib.Topology.Separation.Hausdorff | ∀ {a b : Prop}, (¬a → b) = (¬b → a) | null | false |
_private.Mathlib.Algebra.Regular.Defs.0.isAddRegular_iff.match_1_3 | Mathlib.Algebra.Regular.Defs | ∀ {R : Type u_1} [inst : Add R] {c : R} (motive : IsAddLeftRegular c ∧ IsAddRightRegular c → Prop)
(x : IsAddLeftRegular c ∧ IsAddRightRegular c),
(∀ (h1 : IsAddLeftRegular c) (h2 : IsAddRightRegular c), motive ⋯) → motive x | null | false |
Lean.Elab.Tactic.BVDecide.LRAT.trim.M.markUsed | Lean.Elab.Tactic.BVDecide.LRAT.Trim | ℕ → Lean.Elab.Tactic.BVDecide.LRAT.trim.M Unit | null | true |
sup_div_inf_eq_mabs_div | Mathlib.Algebra.Order.Group.Unbundled.Abs | ∀ {α : Type u_1} [inst : Lattice α] [inst_1 : CommGroup α] [MulLeftMono α] (a b : α), (a ⊔ b) / (a ⊓ b) = |b / a|ₘ | null | true |
Lean.Lsp.instToJsonCompletionClientCapabilities.toJson | Lean.Data.Lsp.Capabilities | Lean.Lsp.CompletionClientCapabilities → Lean.Json | null | true |
_private.Mathlib.Analysis.SumOverResidueClass.0.not_summable_of_antitone_of_neg._simp_1_1 | Mathlib.Analysis.SumOverResidueClass | ∀ {α : Type u} {β : Type v} [inst : PseudoMetricSpace α] [Nonempty β] [inst_2 : SemilatticeSup β] {u : β → α} {a : α},
Filter.Tendsto u Filter.atTop (nhds a) = ∀ ε > 0, ∃ N, ∀ n ≥ N, dist (u n) a < ε | null | false |
measurableSet_le' | Mathlib.MeasureTheory.Constructions.BorelSpace.Order | ∀ {α : Type u_1} [inst : TopologicalSpace α] {mα : MeasurableSpace α} [OpensMeasurableSpace α] [inst_2 : PartialOrder α]
[OrderClosedTopology α] [SecondCountableTopology α], MeasurableSet {p | p.1 ≤ p.2} | null | true |
_private.Mathlib.MeasureTheory.Measure.Prokhorov.0.isCompact_setOf_finiteMeasure_mass_le_compl_isCompact_le._simp_1_6 | Mathlib.MeasureTheory.Measure.Prokhorov | ∀ {G : Type u_1} [inst : AddCommGroup G] [inst_1 : LinearOrder G] [IsOrderedAddMonoid G] {a b : G},
(|a| ≤ b) = (-b ≤ a ∧ a ≤ b) | null | false |
Std.HashSet.Raw.get?_diff_of_not_mem_right | Std.Data.HashSet.RawLemmas | ∀ {α : Type u} [inst : BEq α] [inst_1 : Hashable α] {m₁ m₂ : Std.HashSet.Raw α} [EquivBEq α] [LawfulHashable α],
m₁.WF → m₂.WF → ∀ {k : α}, k ∉ m₂ → (m₁ \ m₂).get? k = m₁.get? k | null | true |
Nat.zeckendorf.match_1 | Mathlib.Data.Nat.Fib.Zeckendorf | (motive : ℕ → Sort u_1) →
(x : ℕ) → (Unit → motive 0) → ((m n : ℕ) → (h : m = n + 1) → motive (namedPattern m n.succ h)) → motive x | null | false |
SeminormedCommRing.induced | Mathlib.Analysis.Normed.Ring.Basic | {F : Type u_5} →
(R : Type u_6) →
(S : Type u_7) →
[inst : FunLike F R S] →
[inst_1 : CommRing R] → [inst_2 : SeminormedRing S] → [NonUnitalRingHomClass F R S] → F → SeminormedCommRing R | A non-unital ring homomorphism from a `CommRing` to a `SeminormedRing` induces a
`SeminormedCommRing` structure on the domain.
See note [reducible non-instances] | true |
Std.TreeMap.Raw.Equiv.getElem_eq | Std.Data.TreeMap.Raw.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t₁ t₂ : Std.TreeMap.Raw α β cmp} [inst : Std.TransCmp cmp] {k : α}
{hk : k ∈ t₁} (h₁ : t₁.WF) (h₂ : t₂.WF) (h : t₁.Equiv t₂), t₁[k] = t₂[k] | null | true |
AddMonoidHom.liftOfRightInverse_comp | Mathlib.Algebra.Group.Subgroup.Basic | ∀ {G₁ : Type u_5} {G₂ : Type u_6} {G₃ : Type u_7} [inst : AddGroup G₁] [inst_1 : AddGroup G₂] [inst_2 : AddGroup G₃]
(f : G₁ →+ G₂) (f_neg : G₂ → G₁) (hf : Function.RightInverse f_neg ⇑f) (g : { g // f.ker ≤ g.ker }),
((f.liftOfRightInverse f_neg hf) g).comp f = ↑g | null | true |
CategoryTheory.SmallObject.functorMapSrc._proof_1 | Mathlib.CategoryTheory.SmallObject.Construction | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {I : Type u_3} {A B : I → C} (f : (i : I) → A i ⟶ B i)
{S T X Y : C} {πX : X ⟶ S} {πY : Y ⟶ T} (τ : CategoryTheory.Arrow.mk πX ⟶ CategoryTheory.Arrow.mk πY)
(x : CategoryTheory.SmallObject.FunctorObjIndex f πX),
CategoryTheory.CategoryStruct.comp (Cat... | null | false |
dif_eq_if | Init.ByCases | ∀ (c : Prop) {h : Decidable c} {α : Sort u} (t e : α), (if x : c then t else e) = if c then t else e | null | true |
CategoryTheory.Limits.CatCospanTransform.mk | Mathlib.CategoryTheory.Limits.Shapes.Pullback.Categorical.CatCospanTransform | {A : Type u₁} →
{B : Type u₂} →
{C : Type u₃} →
[inst : CategoryTheory.Category.{v₁, u₁} A] →
[inst_1 : CategoryTheory.Category.{v₂, u₂} B] →
[inst_2 : CategoryTheory.Category.{v₃, u₃} C] →
{F : CategoryTheory.Functor A B} →
{G : CategoryTheory.Functor C B} →
... | null | true |
List.forall_getElem | Init.Data.List.Lemmas | ∀ {α : Type u_1} {l : List α} {p : α → Prop}, (∀ (i : ℕ) (h : i < l.length), p l[i]) ↔ ∀ a ∈ l, p a | null | true |
AlgebraicGeometry.Etale.instFormallyUnramified | Mathlib.AlgebraicGeometry.Morphisms.Etale | ∀ {X Y : AlgebraicGeometry.Scheme} (f : X ⟶ Y) [AlgebraicGeometry.Etale f], AlgebraicGeometry.FormallyUnramified f | null | true |
Setoid.sInf_iff | Mathlib.Data.Setoid.Basic | ∀ {α : Type u_1} {S : Set (Setoid α)} {x y : α}, (sInf S) x y ↔ ∀ s ∈ S, s x y | null | true |
Std.HashSet.Raw.get?_union | Std.Data.HashSet.RawLemmas | ∀ {α : Type u} [inst : BEq α] [inst_1 : Hashable α] {m₁ m₂ : Std.HashSet.Raw α} [EquivBEq α] [LawfulHashable α],
m₁.WF → m₂.WF → ∀ {k : α}, (m₁ ∪ m₂).get? k = (m₂.get? k).or (m₁.get? k) | null | true |
Lean.Meta.mkAuxTheorem | Lean.Meta.Closure | Lean.Expr →
Lean.Expr → optParam Bool false → optParam (Option Lean.Name) none → optParam Bool true → Lean.MetaM Lean.Expr | Create an auxiliary theorem with the given name, type and value. It is similar to `mkAuxDefinition`.
| true |
_private.Init.Data.Order.Ord.0.Std.instLawfulBEqOrd._simp_1 | Init.Data.Order.Ord | ∀ {o : Ordering}, (o.isEq = true) = (o = Ordering.eq) | null | false |
IsApproximateSubgroup.mk | Mathlib.Combinatorics.Additive.ApproximateSubgroup | ∀ {G : Type u_1} [inst : Group G] {K : ℝ} {A : Set G},
1 ∈ A → A⁻¹ = A → CovBySMul G K (A ^ 2) A → IsApproximateSubgroup K A | null | true |
UniformContinuous.add_const | Mathlib.Topology.Algebra.IsUniformGroup.Defs | ∀ {α : Type u_1} {β : Type u_2} [inst : UniformSpace α] [inst_1 : AddGroup α] [IsUniformAddGroup α]
[inst_3 : UniformSpace β] {f : β → α}, UniformContinuous f → ∀ (a : α), UniformContinuous fun x => f x + a | null | true |
List.mkSlice_ric_eq_mkSlice_rio | Init.Data.Slice.List.Lemmas | ∀ {α : Type u_1} {xs : List α} {hi : ℕ},
(Std.Ric.Sliceable.mkSlice xs *...=hi) = Std.Rio.Sliceable.mkSlice xs *...hi + 1 | null | true |
mul_left_cancel | Mathlib.Algebra.Group.Defs | ∀ {G : Type u_1} [inst : Mul G] [IsLeftCancelMul G] {a b c : G}, a * b = a * c → b = c | null | true |
AddCommGrpCat.Hom.hom.eq_1 | Mathlib.Algebra.Category.Grp.Basic | ∀ {X Y : AddCommGrpCat} (f : X.Hom Y), f.hom = CategoryTheory.ConcreteCategory.hom f | null | true |
Lean.Data.AC.EvalInformation.arbitrary | Init.Data.AC | {α : Sort u} → {β : Sort v} → [self : Lean.Data.AC.EvalInformation α β] → α → β | null | true |
Polynomial.eval.eq_1 | Mathlib.Algebra.Polynomial.Eval.Defs | ∀ {R : Type u} [inst : Semiring R] (x : R) (p : Polynomial R), Polynomial.eval x p = Polynomial.eval₂ (RingHom.id R) x p | null | true |
_private.Init.PropLemmas.0.and_right_comm.match_1_1 | Init.PropLemmas | ∀ {a b c : Prop} (motive : (a ∧ b) ∧ c → Prop) (x : (a ∧ b) ∧ c), (∀ (ha : a) (hb : b) (hc : c), motive ⋯) → motive x | null | false |
CommRingCat.Colimits.Prequotient.recOn | Mathlib.Algebra.Category.Ring.Colimits | {J : Type v} →
[inst : CategoryTheory.SmallCategory J] →
{F : CategoryTheory.Functor J CommRingCat} →
{motive : CommRingCat.Colimits.Prequotient F → Sort u} →
(t : CommRingCat.Colimits.Prequotient F) →
((j : J) → (x : ↑(F.obj j)) → motive (CommRingCat.Colimits.Prequotient.of j x)) →
... | null | false |
_private.Mathlib.Algebra.Order.BigOperators.Ring.List.0.CanonicallyOrderedAdd.list_prod_pos.match_1_1 | Mathlib.Algebra.Order.BigOperators.Ring.List | ∀ {α : Type u_1} (motive : List α → Prop) (x : List α),
(∀ (a : Unit), motive []) → (∀ (x : α) (xs : List α), motive (x :: xs)) → motive x | null | false |
_private.Lean.Elab.Tactic.Induction.0.Lean.Elab.Tactic.elabFunTarget.match_3 | Lean.Elab.Tactic.Induction | (motive : Lean.Meta.FunIndParamKind → Sort u_1) →
(kind : Lean.Meta.FunIndParamKind) →
(Unit → motive Lean.Meta.FunIndParamKind.dropped) →
(Unit → motive Lean.Meta.FunIndParamKind.param) → (Unit → motive Lean.Meta.FunIndParamKind.target) → motive kind | null | false |
ZeroAtInftyContinuousMap.instNonUnitalCStarAlgebra._proof_5 | Mathlib.Analysis.CStarAlgebra.ContinuousMap | ∀ {α : Type u_2} {A : Type u_1} [inst : TopologicalSpace α] [inst_1 : NonUnitalCStarAlgebra A],
SMulCommClass ℂ (ZeroAtInftyContinuousMap α A) (ZeroAtInftyContinuousMap α A) | null | false |
MonoidAlgebra.comapDistribMulActionSelf._proof_4 | Mathlib.Algebra.MonoidAlgebra.Module | ∀ {k : Type u_1} {G : Type u_2} [inst : Group G] [inst_1 : Semiring k] (a : G) (x y : MonoidAlgebra k G),
a • (x + y) = a • x + a • y | null | false |
Lean.Elab.Tactic.Do.SplitInfo | Lean.Elab.Tactic.Do.VCGen.Split | Type | null | true |
MultilinearMap.mkPiAlgebraFin_apply_const | Mathlib.LinearAlgebra.Multilinear.Basic | ∀ {R : Type uR} {n : ℕ} [inst : CommSemiring R] {A : Type u_1} [inst_1 : Semiring A] [inst_2 : Algebra R A] (a : A),
((MultilinearMap.mkPiAlgebraFin R n A) fun x => a) = a ^ n | null | true |
MulLECancellable.mul_le_mul_iff_right | Mathlib.Algebra.Order.Monoid.Unbundled.Basic | ∀ {α : Type u_1} [inst : LE α] [inst_1 : Mul α] [IsMulCommutative α] [MulLeftMono α] {a b c : α},
MulLECancellable a → (b * a ≤ c * a ↔ b ≤ c) | null | true |
ZNum.zero.sizeOf_spec | Mathlib.Data.Num.Basic | sizeOf ZNum.zero = 1 | null | true |
preNormEDS_one | Mathlib.NumberTheory.EllipticDivisibilitySequence | ∀ {R : Type u} [inst : CommRing R] (b c d : R), preNormEDS b c d 1 = 1 | null | true |
Filter.Germ.instAddMonoidWithOne._proof_4 | Mathlib.Order.Filter.Germ.Basic | ∀ {α : Type u_2} {l : Filter α} {M : Type u_1} [inst : AddMonoidWithOne M] (x : ℕ), ↑↑(x + 1) = ↑fun x_1 => ↑x x_1 + 1 | null | false |
_private.Mathlib.NumberTheory.ModularForms.EisensteinSeries.QExpansion.0.summable_pow_mul_cexp._simp_1_1 | Mathlib.NumberTheory.ModularForms.EisensteinSeries.QExpansion | ∀ {α : Type u_1} {E : Type u_2} [inst : Norm E] {l : Filter α} {f : α → E} {g : α → ℝ},
f =O[l] g = f =O[l] fun x => ↑(g x) | null | false |
FirstOrder.Language.Substructure.comap._proof_1 | Mathlib.ModelTheory.Substructures | ∀ {L : FirstOrder.Language} {M : Type u_1} {N : Type u_2} [inst : L.Structure M] [inst_1 : L.Structure N]
(φ : L.Hom M N) (S : L.Substructure N) {n : ℕ} (f : L.Functions n) (x : Fin n → M),
(∀ (i : Fin n), x i ∈ ⇑φ ⁻¹' ↑S) → FirstOrder.Language.Structure.funMap f x ∈ ⇑φ ⁻¹' ↑S | null | false |
Lean.Elab.Term.Quotation.HeadInfo.casesOn | Lean.Elab.Quotation | {motive : Lean.Elab.Term.Quotation.HeadInfo → Sort u} →
(t : Lean.Elab.Term.Quotation.HeadInfo) →
((check : Lean.Elab.Term.Quotation.HeadCheck) →
(onMatch : Lean.Elab.Term.Quotation.HeadCheck → Lean.Elab.Term.Quotation.MatchResult) →
(doMatch :
(List Lean.Term → Lean.Elab.TermElabM... | null | false |
PrimrecPred.of_eq | Mathlib.Computability.Primrec.Basic | ∀ {α : Type u_1} [inst : Primcodable α] {p q : α → Prop}, PrimrecPred p → (∀ (a : α), p a ↔ q a) → PrimrecPred q | null | true |
ContMDiffAt.sum_section | Mathlib.Geometry.Manifold.VectorBundle.ContMDiffSection | ∀ {𝕜 : 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] {F : Type u_5} [inst_6 : NormedAddCommG... | null | true |
Pi.borelSpace | Mathlib.MeasureTheory.Constructions.BorelSpace.Basic | ∀ {ι : Type u_6} {X : ι → Type u_7} [Countable ι] [inst : (i : ι) → TopologicalSpace (X i)]
[inst_1 : (i : ι) → MeasurableSpace (X i)] [∀ (i : ι), SecondCountableTopology (X i)] [∀ (i : ι), BorelSpace (X i)],
BorelSpace ((i : ι) → X i) | null | true |
Std.DTreeMap.Internal.Impl.size_containsThenInsert_eq_size | Std.Data.DTreeMap.Internal.WF.Lemmas | ∀ {α : Type u} {β : α → Type v} [Ord α] (t : Std.DTreeMap.Internal.Impl α β),
Std.DTreeMap.Internal.Impl.containsThenInsert.size t = t.size | null | true |
Int.tmod_eq_emod_of_nonneg | Init.Data.Int.DivMod.Lemmas | ∀ {a b : ℤ}, 0 ≤ a → a.tmod b = a % b | null | true |
_private.Mathlib.FieldTheory.IntermediateField.Adjoin.Basic.0.IntermediateField.exists_finset_of_mem_adjoin._simp_1_1 | Mathlib.FieldTheory.IntermediateField.Adjoin.Basic | ∀ {α : Type u_1} [inst : CompleteLattice α] {ι : Type u_8} (s : Set ι) (f : ι → α), ⨆ t ∈ s, f t = ⨆ i, f ↑i | null | false |
ENorm | Mathlib.Analysis.Normed.Group.Defs | Type u_8 → Type u_8 | Auxiliary class, endowing a type `α` with a function `enorm : α → ℝ≥0∞` with notation `‖x‖ₑ`. | true |
MvPowerSeries.hasSum_eval₂ | Mathlib.RingTheory.MvPowerSeries.Evaluation | ∀ {σ : Type u_1} {R : Type u_2} [inst : CommRing R] [inst_1 : UniformSpace R] {S : Type u_3} [inst_2 : CommRing S]
[inst_3 : UniformSpace S] {φ : R →+* S} {a : σ → S} [IsTopologicalSemiring R] [IsUniformAddGroup R]
[IsUniformAddGroup S] [CompleteSpace S] [T2Space S] [IsTopologicalRing S] [IsLinearTopology S S],
C... | null | true |
WithCStarModule.norm_single | Mathlib.Analysis.CStarAlgebra.Module.Constructions | ∀ {A : Type u_1} [inst : NonUnitalCStarAlgebra A] [inst_1 : PartialOrder A] {ι : Type u_2} {E : ι → Type u_3}
[inst_2 : Fintype ι] [inst_3 : (i : ι) → NormedAddCommGroup (E i)] [inst_4 : (i : ι) → Module ℂ (E i)]
[inst_5 : (i : ι) → SMul A (E i)] [inst_6 : (i : ι) → CStarModule A (E i)] [StarOrderedRing A]
[inst_... | null | true |
StrictConcaveOn.lt_map_sum_iff_of_nonneg' | Mathlib.Analysis.Convex.Jensen | ∀ {𝕜 : Type u_1} {E : Type u_2} {β : Type u_4} {ι : Type u_5} [inst : Field 𝕜] [inst_1 : LinearOrder 𝕜]
[IsStrictOrderedRing 𝕜] [inst_3 : AddCommGroup E] [inst_4 : AddCommGroup β] [inst_5 : PartialOrder β]
[IsOrderedAddMonoid β] [inst_7 : Module 𝕜 E] [inst_8 : Module 𝕜 β] [IsStrictOrderedModule 𝕜 β] {s : Set... | Canonical form of the **strict Jensen's inequality**. | true |
Lean.Meta.InductionSubgoal.mk | Lean.Meta.Tactic.Induction | Lean.MVarId → Array Lean.Expr → Lean.Meta.FVarSubst → Lean.Meta.InductionSubgoal | null | true |
SetRel.instIsIrreflSetOfProdMatch_1PropOfIrrefl | Mathlib.Data.Rel | ∀ {α : Type u_1} {R : α → α → Prop} [Std.Irrefl R], SetRel.IsIrrefl {(a, b) | R a b} | null | true |
_private.Lean.Server.CodeActions.Basic.0.Lean.Server.evalCodeActionProviderUnsafe | Lean.Server.CodeActions.Basic | {M : Type → Type} →
[Lean.MonadEnv M] →
[Lean.MonadOptions M] → [Lean.MonadError M] → [Monad M] → Lean.Name → M Lean.Server.CodeActionProvider | null | true |
IccLeftChart._proof_3 | Mathlib.Geometry.Manifold.Instances.Real | ∀ (x y : ℝ) (z : ↑(Set.Icc x y)), 0 ≤ ↑z - x | null | false |
_private.Init.Data.Range.Polymorphic.Iterators.0.Std.Rio.Internal.isPlausibleIndirectOutput_iter_iff._simp_1_1 | Init.Data.Range.Polymorphic.Iterators | ∀ {α : Type u} {inst : Std.PRange.UpwardEnumerable α} {inst_1 : LT α} [self : Std.PRange.LawfulUpwardEnumerableLT α]
(a b : α), (a < b) = Std.PRange.UpwardEnumerable.LT a b | null | false |
Lean.Server.RequestHandler.mk.injEq | Lean.Server.Requests | ∀ (fileSource : Lean.Json → Except Lean.Server.RequestError Lean.Lsp.DocumentUri)
(handle : Lean.Json → Lean.Server.RequestM (Lean.Server.RequestTask Lean.Server.SerializedLspResponse))
(fileSource_1 : Lean.Json → Except Lean.Server.RequestError Lean.Lsp.DocumentUri)
(handle_1 : Lean.Json → Lean.Server.RequestM (... | null | true |
CategoryTheory.Monad.monToMonad_map_toNatTrans | Mathlib.CategoryTheory.Monad.EquivMon | ∀ (C : Type u) [inst : CategoryTheory.Category.{v, u} C] {X Y : CategoryTheory.Mon (CategoryTheory.Functor C C)}
(f : X ⟶ Y), ((CategoryTheory.Monad.monToMonad C).map f).toNatTrans = f.hom | null | true |
instCommRingBDeRhamPlus._aux_34 | Mathlib.RingTheory.Perfectoid.BDeRham | (R : Type u_1) →
[inst : CommRing R] →
(p : ℕ) →
[inst_1 : Fact (Nat.Prime p)] →
[inst_2 : Fact ¬IsUnit ↑p] →
[inst_3 : IsAdicComplete (Ideal.span {↑p}) R] → BDeRhamPlus R p → BDeRhamPlus R p → BDeRhamPlus R p | null | false |
Subalgebra.LinearDisjoint.rank_inf_eq_one_of_commute_of_flat_right_of_inj | Mathlib.RingTheory.LinearDisjoint | ∀ {R : Type u} {S : Type v} [inst : CommRing R] [inst_1 : Ring S] [inst_2 : Algebra R S] {A B : Subalgebra R S},
A.LinearDisjoint B →
∀ [Module.Flat R ↥B],
(∀ (a b : ↥(A ⊓ B)), Commute ↑a ↑b) → Function.Injective ⇑(algebraMap R S) → Module.rank R ↥(A ⊓ B) = 1 | null | true |
Subalgebra.toSubmoduleEquiv | Mathlib.Algebra.Algebra.Subalgebra.Basic | {R : Type u} →
{A : Type v} →
[inst : CommSemiring R] →
[inst_1 : Semiring A] → [inst_2 : Algebra R A] → (S : Subalgebra R A) → ↥(Subalgebra.toSubmodule S) ≃ₗ[R] ↥S | Linear equivalence between `S : Submodule R A` and `S`. Though these types are equal,
we define it as a `LinearEquiv` to avoid type equalities. | true |
CategoryTheory.Limits.instLaxMonoidalFunctorLim._proof_13 | Mathlib.CategoryTheory.Monoidal.Limits.Basic | ∀ {J : Type u_1} [inst : CategoryTheory.SmallCategory J] {C : Type u_3} [inst_1 : CategoryTheory.Category.{u_2, u_3} C]
[inst_2 : CategoryTheory.Limits.HasLimitsOfShape J C] [inst_3 : CategoryTheory.MonoidalCategory C]
(F G H : CategoryTheory.Functor J C) (j j' : J) (f : j ⟶ j'),
CategoryTheory.CategoryStruct.com... | null | false |
Submodule.fst_orthogonalDecomposition_apply | Mathlib.Analysis.InnerProductSpace.ProdL2 | ∀ {𝕜 : Type u_1} {E : Type u_4} [inst : RCLike 𝕜] [inst_1 : NormedAddCommGroup E] [inst_2 : InnerProductSpace 𝕜 E]
(K : Submodule 𝕜 E) [inst_3 : K.HasOrthogonalProjection] (x : E),
(K.orthogonalDecomposition x).fst = K.orthogonalProjectionOnto x | null | true |
FirstOrder.Language.Term.varsToConstants.eq_2 | Mathlib.ModelTheory.Syntax | ∀ {L : FirstOrder.Language} {α : Type u'} {γ : Type u_1} (c : γ),
(FirstOrder.Language.var (Sum.inl c)).varsToConstants = FirstOrder.Language.Constants.term (Sum.inr c) | null | true |
Nat.floor_add_ofNat | Mathlib.Algebra.Order.Floor.Semiring | ∀ {R : Type u_1} [inst : Semiring R] [inst_1 : LinearOrder R] [inst_2 : FloorSemiring R] {a : R}
[IsStrictOrderedRing R], 0 ≤ a → ∀ (n : ℕ) [inst_4 : n.AtLeastTwo], ⌊a + OfNat.ofNat n⌋₊ = ⌊a⌋₊ + OfNat.ofNat n | null | true |
ENat.coe_sSup | Mathlib.Data.ENat.Lattice | ∀ {s : Set ℕ}, BddAbove s → ↑(sSup s) = ⨆ a ∈ s, ↑a | null | true |
_private.Aesop.Util.UnorderedArraySet.0.Aesop.UnorderedArraySet.mk.inj | Aesop.Util.UnorderedArraySet | ∀ {α : Type u_1} {inst : BEq α} {rep rep_1 : Array α}, { rep := rep } = { rep := rep_1 } → rep = rep_1 | null | true |
StandardEtalePresentation._sizeOf_inst | Mathlib.RingTheory.Etale.StandardEtale | (R : Type u_4) →
(S : Type u_5) →
{inst : CommRing R} →
{inst_1 : CommRing S} → {inst_2 : Algebra R S} → [SizeOf R] → [SizeOf S] → SizeOf (StandardEtalePresentation R S) | null | false |
Lean.Elab.Tactic.BVDecide.Frontend.Normalize.bv_add | Lean.Elab.Tactic.BVDecide.Frontend.Normalize.Simproc | Lean.Meta.Simp.Simproc | null | true |
Std.DTreeMap.Internal.Impl.filter_eq_filter! | Std.Data.DTreeMap.Internal.WF.Lemmas | ∀ {α : Type u} {β : α → Type v} [inst : Ord α] {t : Std.DTreeMap.Internal.Impl α β} {h : t.Balanced}
{f : (a : α) → β a → Bool}, (Std.DTreeMap.Internal.Impl.filter f t h).impl = Std.DTreeMap.Internal.Impl.filter! f t | null | true |
Quiver.Path.instSubsingletonBddPaths | Mathlib.Combinatorics.Quiver.Path | ∀ {V : Type u_1} [inst : Quiver V] (v w : V), Subsingleton (Quiver.Path.BoundedPaths v w 0) | Bounded paths of length zero between two vertices form a subsingleton. | true |
List.findFinIdx?_eq_bind_find?_finIdxOf? | Init.Data.List.Find | ∀ {α : Type u_1} [inst : BEq α] [LawfulBEq α] {xs : List α} {p : α → Bool},
List.findFinIdx? p xs = (List.find? p xs).bind fun a => List.finIdxOf? a xs | null | true |
SemiNormedGrp.id_apply | Mathlib.Analysis.Normed.Group.SemiNormedGrp | ∀ (M : SemiNormedGrp) (r : M.carrier), (CategoryTheory.ConcreteCategory.hom (CategoryTheory.CategoryStruct.id M)) r = r | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.