name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
FirstOrder.Language.DirectLimit.Equiv_iSup._proof_1 | Mathlib.ModelTheory.DirectLimit | ∀ {L : FirstOrder.Language} {ι : Type u_1} [inst : Preorder ι] [inst_1 : Nonempty ι] [inst_2 : IsDirectedOrder ι]
{M : Type u_2} [inst_3 : L.Structure M] (S : ι →o L.Substructure M)
(x : FirstOrder.Language.DirectLimit (fun i => ↥(S i)) fun x x_1 h => FirstOrder.Language.Substructure.inclusion ⋯),
(FirstOrder.Lan... | false |
Lean.Elab.Tactic.SimpKind.simp.sizeOf_spec | Lean.Elab.Tactic.Simp | sizeOf Lean.Elab.Tactic.SimpKind.simp = 1 | true |
NeZero.of_map | Mathlib.Algebra.GroupWithZero.Hom | ∀ {F : Type u_1} {α : Type u_2} {β : Type u_3} [inst : Zero α] [inst_1 : Zero β] [inst_2 : FunLike F α β]
[ZeroHomClass F α β] {a : α} (f : F) [neZero : NeZero (f a)], NeZero a | true |
_private.Mathlib.MeasureTheory.Covering.Besicovitch.0.Besicovitch.TauPackage.color_lt._simp_1_18 | Mathlib.MeasureTheory.Covering.Besicovitch | ∀ {α : Sort u_1} {p : α → Prop}, (¬∀ (x : α), p x) = ∃ x, ¬p x | false |
instMulUInt32 | Init.Data.UInt.Basic | Mul UInt32 | true |
QuotientGroup.Quotient.group._aux_4 | Mathlib.GroupTheory.QuotientGroup.Defs | {G : Type u_1} → [inst : Group G] → (N : Subgroup G) → [nN : N.Normal] → ℕ → G ⧸ N → G ⧸ N | false |
one_div_neg_one_eq_neg_one | Mathlib.Algebra.Ring.Basic | ∀ {R : Type u_1} [inst : DivisionMonoid R] [inst_1 : HasDistribNeg R], 1 / -1 = -1 | true |
ProofWidgets.PanelWidgetProps.mk.injEq | ProofWidgets.Component.Panel.Basic | ∀ (pos : Lean.Lsp.Position) (goals : Array Lean.Widget.InteractiveGoal)
(termGoal? : Option Lean.Widget.InteractiveTermGoal) (selectedLocations : Array Lean.SubExpr.GoalsLocation)
(pos_1 : Lean.Lsp.Position) (goals_1 : Array Lean.Widget.InteractiveGoal)
(termGoal?_1 : Option Lean.Widget.InteractiveTermGoal) (sele... | true |
CategoryTheory.MonoidalCategory.MonoidalLeftAction.actionHomRight_id | Mathlib.CategoryTheory.Monoidal.Action.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} {inst_2 : CategoryTheory.MonoidalCategory C}
[self : CategoryTheory.MonoidalCategory.MonoidalLeftAction C D] (c : C) (d : D),
CategoryTheory.MonoidalCategory.MonoidalLeftActionStruct.actio... | true |
FormalMultilinearSeries.le_radius_compContinuousLinearMap | Mathlib.Analysis.Analytic.ConvergenceRadius | ∀ {𝕜 : Type u_1} {E : Type u_2} {F : Type u_3} {G : Type u_4} [inst : NontriviallyNormedField 𝕜]
[inst_1 : NormedAddCommGroup E] [inst_2 : NormedSpace 𝕜 E] [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F]
[inst_5 : NormedAddCommGroup G] [inst_6 : NormedSpace 𝕜 G] (p : FormalMultilinearSeries 𝕜 F G) ... | true |
Lean.Omega.Prod.snd_mk | Init.Omega.Int | ∀ {α : Type u_1} {x : α} {α_1 : Type u_2} {y : α_1}, (x, y).2 = y | true |
_private.Mathlib.Data.Finset.Sym.0.Finset.sym2_insert._simp_1_2 | Mathlib.Data.Finset.Sym | ∀ {α : Type u_1} {β : Type u_2} [inst : DecidableEq β] {f : α → β} {s : Finset α} {t : Finset β},
(Finset.image f s ⊆ t) = ∀ x ∈ s, f x ∈ t | false |
Complex.arg_mul_cos_add_sin_mul_I_eq_toIocMod | Mathlib.Analysis.SpecialFunctions.Complex.Arg | ∀ {r : ℝ},
0 < r → ∀ (θ : ℝ), (↑r * (Complex.cos ↑θ + Complex.sin ↑θ * Complex.I)).arg = toIocMod Real.two_pi_pos (-Real.pi) θ | true |
CategoryTheory.Limits.PullbackCone.op_inr | Mathlib.CategoryTheory.Limits.Shapes.Opposites.Pullbacks | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {X Y Z : C} {f : X ⟶ Z} {g : Y ⟶ Z}
(c : CategoryTheory.Limits.PullbackCone f g), c.op.inr = c.snd.op | true |
Lean.Meta.Match.MatcherInfo.noConfusionType | Lean.Meta.Match.MatcherInfo | Sort u → Lean.Meta.MatcherInfo → Lean.Meta.MatcherInfo → Sort u | false |
CategoryTheory.MonadicRightAdjoint.eqv | Mathlib.CategoryTheory.Monad.Adjunction | ∀ {C : Type u₁} {inst : CategoryTheory.Category.{v₁, u₁} C} {D : Type u₂} {inst_1 : CategoryTheory.Category.{v₂, u₂} D}
{R : CategoryTheory.Functor D C} [self : CategoryTheory.MonadicRightAdjoint R],
(CategoryTheory.Monad.comparison CategoryTheory.MonadicRightAdjoint.adj).IsEquivalence | true |
Lean.Lsp.LeanModule._sizeOf_1 | Lean.Data.Lsp.Extra | Lean.Lsp.LeanModule → ℕ | false |
_private.Mathlib.RingTheory.OrderOfVanishing.0.Ring.ord_mul._simp_1_2 | Mathlib.RingTheory.OrderOfVanishing | ∀ {α : Type u} [inst : Semiring α] {s : Set α}, Ideal.span s = Submodule.span α s | false |
Equiv.Perm.Basis.ofPermHom_support | Mathlib.GroupTheory.Perm.Centralizer | ∀ {α : Type u_1} [inst : DecidableEq α] [inst_1 : Fintype α] {g : Equiv.Perm α} (a : g.Basis)
(τ : ↥(Equiv.Perm.OnCycleFactors.range_toPermHom' g)),
(a.ofPermHom τ).support = (↑τ).support.biUnion fun c => (↑c).support | true |
KaehlerDifferential.endEquiv._proof_3 | Mathlib.RingTheory.Kaehler.Basic | ∀ (R : Type u_2) (S : Type u_1) [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S],
SMulCommClass S S ↥(KaehlerDifferential.ideal R S).cotangentIdeal | false |
CategoryTheory.Square.opFunctor_map_τ₂ | Mathlib.CategoryTheory.Square | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y : (CategoryTheory.Square C)ᵒᵖ} (φ : X ⟶ Y),
(CategoryTheory.Square.opFunctor.map φ).τ₂ = φ.unop.τ₂.op | true |
ENNReal.zero_eq_ofReal | Mathlib.Data.ENNReal.Real | ∀ {p : ℝ}, 0 = ENNReal.ofReal p ↔ p ≤ 0 | true |
Eventually.le_linearGrowthInf | Mathlib.Analysis.Asymptotics.LinearGrowth | ∀ {u : ℕ → EReal} {a : EReal}, (∀ᶠ (n : ℕ) in Filter.atTop, a * ↑n ≤ u n) → a ≤ LinearGrowth.linearGrowthInf u | true |
_private.Lean.Meta.Sym.Simp.Forall.0.Lean.Meta.Sym.Simp.ToArrowResult.ctorIdx | Lean.Meta.Sym.Simp.Forall | Lean.Meta.Sym.Simp.ToArrowResult✝ → ℕ | false |
Affine.Simplex.faceOppositeCentroid_vsub_point_eq_smul_sum_vsub | Mathlib.LinearAlgebra.AffineSpace.Simplex.Centroid | ∀ {k : Type u_1} {V : Type u_2} {P : Type u_3} [inst : DivisionRing k] [inst_1 : AddCommGroup V] [inst_2 : Module k V]
[inst_3 : AddTorsor V P] {n : ℕ} [inst_4 : NeZero n] [CharZero k] (s : Affine.Simplex k P n) (i : Fin (n + 1)),
s.faceOppositeCentroid i -ᵥ s.points i = (↑n)⁻¹ • ∑ x, (s.points x -ᵥ s.points i) | true |
_private.Mathlib.Topology.Separation.Regular.0.instRegularSpaceOfWeaklyLocallyCompactSpaceOfR1Space.match_1 | Mathlib.Topology.Separation.Regular | ∀ {X : Type u_1} [inst : TopologicalSpace X] (x : X) (x_1 : Set X)
(motive : x_1 ∈ nhds x ∧ IsCompact x_1 ∧ IsClosed x_1 → Prop) (x_2 : x_1 ∈ nhds x ∧ IsCompact x_1 ∧ IsClosed x_1),
(∀ (left : x_1 ∈ nhds x) (left_1 : IsCompact x_1) (h : IsClosed x_1), motive ⋯) → motive x_2 | false |
Lean.Compiler.LCNF.Simp.JpCasesInfo.recOn | Lean.Compiler.LCNF.Simp.JpCases | {motive : Lean.Compiler.LCNF.Simp.JpCasesInfo → Sort u} →
(t : Lean.Compiler.LCNF.Simp.JpCasesInfo) →
((paramIdx : ℕ) → (ctorNames : Lean.NameSet) → motive { paramIdx := paramIdx, ctorNames := ctorNames }) → motive t | false |
FiniteMulArchimedeanClass.lift._proof_2 | Mathlib.Algebra.Order.Archimedean.Class | ∀ {M : Type u_1} [inst : CommGroup M] [inst_1 : LinearOrder M] [inst_2 : IsOrderedMonoid M] {α : Type u_2}
(f : { a // a ≠ 1 } → α),
(∀ (a b : { a // a ≠ 1 }), FiniteMulArchimedeanClass.mk ↑a ⋯ = FiniteMulArchimedeanClass.mk ↑b ⋯ → f a = f b) →
∀ (a b : M),
MulArchimedeanClass.mk a = MulArchimedeanClass.m... | false |
LinearMap.im_inner_adjoint_mul_self_eq_zero | Mathlib.Analysis.InnerProductSpace.Adjoint | ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : RCLike 𝕜] [inst_1 : NormedAddCommGroup E] [inst_2 : InnerProductSpace 𝕜 E]
[inst_3 : FiniteDimensional 𝕜 E] (T : E →ₗ[𝕜] E) (x : E), RCLike.im (inner 𝕜 x ((LinearMap.adjoint T) (T x))) = 0 | true |
_private.Mathlib.Order.Interval.Set.Basic.0.Set.Icc_eq_Icc_iff._simp_1_2 | Mathlib.Order.Interval.Set.Basic | ∀ {α : Type u_1} [inst : Preorder α] {a b x : α}, (x ∈ Set.Icc a b) = (a ≤ x ∧ x ≤ b) | false |
instAddLeftReflectLTPNat._proof_1 | Mathlib.Data.PNat.Basic | AddLeftReflectLT ℕ+ | false |
_private.Mathlib.NumberTheory.LSeries.HurwitzZetaEven.0.HurwitzZeta.cosKernel_neg._simp_1_1 | Mathlib.NumberTheory.LSeries.HurwitzZetaEven | ∀ {G : Type u_1} [inst : AddGroup G] (N : AddSubgroup G) [nN : N.Normal] (a : G), -↑a = ↑(-a) | false |
_private.Mathlib.Data.PFun.0.PFun.mem_fix_iff._simp_1_6 | Mathlib.Data.PFun | ∀ {α : Type u_1} {a b : α}, (b ∈ Part.some a) = (b = a) | false |
Std.TreeMap.Raw.getElem!_map | Std.Data.TreeMap.Raw.Lemmas | ∀ {α : Type u} {β : Type v} {γ : Type w} {cmp : α → α → Ordering} {t : Std.TreeMap.Raw α β cmp} [Std.TransCmp cmp]
[Std.LawfulEqCmp cmp] [inst : Inhabited γ] {f : α → β → γ} {k : α},
t.WF → (Std.TreeMap.Raw.map f t)[k]! = (Option.map (f k) t[k]?).get! | true |
Nat.ofDigits_reverse_zero_cons | Mathlib.Data.Nat.Digits.Defs | ∀ {b : ℕ} (l : List ℕ), Nat.ofDigits b (0 :: l).reverse = Nat.ofDigits b l.reverse | true |
_private.Lean.Meta.Closure.0.Lean.Meta.Closure.sortDecls.visit.match_1 | Lean.Meta.Closure | (motive : Option (Lean.LocalDecl × Lean.Expr) → Sort u_1) →
(x : Option (Lean.LocalDecl × Lean.Expr)) →
((decl : Lean.LocalDecl) → (arg : Lean.Expr) → motive (some (decl, arg))) →
((x : Option (Lean.LocalDecl × Lean.Expr)) → motive x) → motive x | false |
MeasureTheory.pdf.IsUniform.aemeasurable | Mathlib.Probability.Distributions.Uniform | ∀ {E : Type u_1} [inst : MeasurableSpace E] {μ : MeasureTheory.Measure E} {Ω : Type u_2} {x : MeasurableSpace Ω}
{ℙ : MeasureTheory.Measure Ω} {X : Ω → E} {s : Set E},
μ s ≠ 0 → μ s ≠ ⊤ → MeasureTheory.pdf.IsUniform X s ℙ μ → AEMeasurable X ℙ | true |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.Const.size_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.PreOneHypercover.instCategory._proof_2 | Mathlib.CategoryTheory.Sites.Hypercover.One | ∀ {C : Type u_3} [inst : CategoryTheory.Category.{u_2, u_3} C] {S : C} {X Y : CategoryTheory.PreOneHypercover S}
(f : X.Hom Y), (CategoryTheory.PreOneHypercover.Hom.id X).comp f = f | false |
LinearMap.BilinForm.sub_right | Mathlib.LinearAlgebra.BilinearForm.Basic | ∀ {R₁ : Type u_4} {M₁ : Type u_5} [inst : CommRing R₁] [inst_1 : AddCommGroup M₁] [inst_2 : Module R₁ M₁]
{B₁ : LinearMap.BilinForm R₁ M₁} (x y z : M₁), (B₁ x) (y - z) = (B₁ x) y - (B₁ x) z | true |
Finsupp.comapDomain.addMonoidHom._proof_1 | Mathlib.Data.Finsupp.Basic | ∀ {α : Type u_1} {β : Type u_2} {M : Type u_3} [inst : AddZeroClass M] {f : α → β},
Function.Injective f → ∀ (x : β →₀ M), Set.InjOn f (f ⁻¹' ↑x.support) | false |
small_of_injective_of_exists | Mathlib.Logic.Small.Basic | ∀ {α : Type v} {β : Type w} {γ : Type v'} [Small.{u, v} α] (f : α → γ) {g : β → γ},
Function.Injective g → (∀ (b : β), ∃ a, f a = g b) → Small.{u, w} β | true |
Set.AddAntidiagonal.eq_of_fst_eq_fst | Mathlib.Data.Set.MulAntidiagonal | ∀ {α : Type u_1} [inst : AddCommMonoid α] [IsCancelAdd α] {s t : Set α} {a : α} {x y : ↑(s.addAntidiagonal t a)},
(↑x).1 = (↑y).1 → x = y | true |
CategoryTheory.ShortComplex.homologyMapIso_hom | Mathlib.Algebra.Homology.ShortComplex.Homology | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{S₁ S₂ : CategoryTheory.ShortComplex C} (e : S₁ ≅ S₂) [inst_2 : S₁.HasHomology] [inst_3 : S₂.HasHomology],
(CategoryTheory.ShortComplex.homologyMapIso e).hom = CategoryTheory.ShortComplex.homologyMap e.hom | true |
Multiset.countPerms.eq_1 | Mathlib.Data.Nat.Choose.Multinomial | ∀ {α : Type u_1} [inst : DecidableEq α] (m : Multiset α), m.countPerms = (Multiset.toFinsupp m).multinomial | true |
_private.Mathlib.Topology.Instances.AddCircle.Defs.0.AddCircle.card_torsion_le_of_isSMulRegular.match_1_1 | Mathlib.Topology.Instances.AddCircle.Defs | ∀ {𝕜 : Type u_1} [inst : AddCommGroup 𝕜] (p : 𝕜) (n : ℕ) (y : 𝕜) (motive : n • y ∈ AddSubgroup.zmultiples p → Prop)
(hx : n • y ∈ AddSubgroup.zmultiples p), (∀ (m' : ℤ) (hm : (fun x => x • p) m' = n • y), motive ⋯) → motive hx | false |
BitVec.ule | Init.Data.BitVec.Basic | {n : ℕ} → BitVec n → BitVec n → Bool | true |
inf_le_iff | Mathlib.Order.Lattice | ∀ {α : Type u} [inst : LinearOrder α] {a b c : α}, min b c ≤ a ↔ b ≤ a ∨ c ≤ a | true |
Array.findFinIdx?_eq_none_iff | Init.Data.Array.Find | ∀ {α : Type u_1} {xs : Array α} {p : α → Bool}, Array.findFinIdx? p xs = none ↔ ∀ x ∈ xs, ¬p x = true | true |
_private.Lean.Elab.Tactic.Show.0.Lean.Elab.Tactic.elabShow.tryGoal.match_1 | Lean.Elab.Tactic.Show | (motive : Lean.Expr × List Lean.MVarId → Sort u_1) →
(__discr : Lean.Expr × List Lean.MVarId) →
((tgt' : Lean.Expr) → (mvars : List Lean.MVarId) → motive (tgt', mvars)) → motive __discr | false |
Lean.Grind.flip_bool_eq | Init.Grind.Norm | ∀ (a b : Bool), (a = b) = (b = a) | true |
OrderIso.ofHomInv_symm_apply | Mathlib.Order.Hom.Basic | ∀ {α : Type u_2} {β : Type u_3} [inst : Preorder α] [inst_1 : Preorder β] (f : α →o β) (g : β →o α)
(h₁ : f.comp g = OrderHom.id) (h₂ : g.comp f = OrderHom.id) (a : β), (OrderIso.ofHomInv f g h₁ h₂).symm a = g a | true |
BitVec.getLsbD_eq_getElem | Init.Data.BitVec.Basic | ∀ {w : ℕ} {x : BitVec w} {i : ℕ} (h : i < w), x.getLsbD i = x[i] | true |
RingCat.limitRing._aux_13 | Mathlib.Algebra.Category.Ring.Limits | {J : Type u_3} →
[inst : CategoryTheory.Category.{u_1, u_3} J] →
(F : CategoryTheory.Functor J RingCat) →
[inst_1 : Small.{u_2, max u_2 u_3} ↑(F.comp (CategoryTheory.forget RingCat)).sections] →
Ring ↑(F.comp (CategoryTheory.forget RingCat)).sections →
(CategoryTheory.Limits.Types.Small.li... | false |
Nat.Prime.emultiplicity_le_emultiplicity_choose_add | Mathlib.Data.Nat.Multiplicity | ∀ {p : ℕ}, Nat.Prime p → ∀ (n k : ℕ), emultiplicity p n ≤ emultiplicity p (n.choose k) + emultiplicity p k | true |
_private.Mathlib.Tactic.Order.ToInt.0.Mathlib.Tactic.Order.ToInt.toInt_sup_toInt_eq_toInt._simp_1_4 | Mathlib.Tactic.Order.ToInt | ∀ {α : Type u_1} [inst : LinearOrder α] {n : ℕ} (val : Fin n → α) (i j : Fin n),
(Mathlib.Tactic.Order.ToInt.toInt val i ≤ Mathlib.Tactic.Order.ToInt.toInt val j) = (val i ≤ val j) | false |
MeasureTheory.AddQuotientMeasureEqMeasurePreimage.addInvariantMeasure_quotient | Mathlib.MeasureTheory.Measure.Haar.Quotient | ∀ {G : Type u_1} [inst : AddGroup G] [inst_1 : MeasurableSpace G] [inst_2 : TopologicalSpace G]
[IsTopologicalAddGroup G] [BorelSpace G] [PolishSpace G] {Γ : AddSubgroup G} [inst_6 : Γ.Normal] [T2Space (G ⧸ Γ)]
[SecondCountableTopology (G ⧸ Γ)] {μ : MeasureTheory.Measure (G ⧸ Γ)} (ν : MeasureTheory.Measure G)
[ν.... | true |
RestrictedProduct.instZPow.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 : ι) → DivInvMonoid (R i)] [inst_2 : ∀ (i : ι), SubgroupClass (S i) (R i)],
RestrictedProduct.instZPow R = { pow := fun x n => ⟨fun i => x i ^ n, ⋯⟩ } | true |
Lean.Doc.DocHighlight.const.injEq | Lean.Elab.DocString.Builtin | ∀ (name : Lean.Name) (signature : Std.Format) (name_1 : Lean.Name) (signature_1 : Std.Format),
(Lean.Doc.DocHighlight.const name signature = Lean.Doc.DocHighlight.const name_1 signature_1) =
(name = name_1 ∧ signature = signature_1) | true |
continuous_gaugeRescale | Mathlib.Analysis.Convex.GaugeRescale | ∀ {E : Type u_1} [inst : AddCommGroup E] [inst_1 : Module ℝ E] [inst_2 : TopologicalSpace E] [IsTopologicalAddGroup E]
[ContinuousSMul ℝ E] [T1Space E] {s t : Set E},
Convex ℝ s → s ∈ nhds 0 → Convex ℝ t → t ∈ nhds 0 → Bornology.IsVonNBounded ℝ t → Continuous (gaugeRescale s t) | true |
CategoryTheory.Lax.LaxTrans.mk.inj | Mathlib.CategoryTheory.Bicategory.NaturalTransformation.Lax | ∀ {B : Type u₁} {inst : CategoryTheory.Bicategory B} {C : Type u₂} {inst_1 : CategoryTheory.Bicategory C}
{F G : CategoryTheory.LaxFunctor B C} {app : (a : B) → F.obj a ⟶ G.obj a}
{naturality :
{a b : B} →
(f : a ⟶ b) →
CategoryTheory.CategoryStruct.comp (app a) (G.map f) ⟶ CategoryTheory.Category... | true |
_private.Mathlib.Analysis.Normed.Lp.PiLp.0.PiLp.antilipschitzWith_ofLp_aux._simp_1_1 | Mathlib.Analysis.Normed.Lp.PiLp | ∀ {α : Type u_1} {ι : Sort u_4} [inst : CompleteLattice α] {f : ι → α} {a : α}, (iSup f ≤ a) = ∀ (i : ι), f i ≤ a | false |
instNonemptyUniformOnFun | Mathlib.Topology.UniformSpace.UniformConvergenceTopology | ∀ {α : Type u_1} {β : Type u_2} {𝔖 : Set (Set α)} [Nonempty β], Nonempty (UniformOnFun α β 𝔖) | true |
RelSeries.singleton._proof_1 | Mathlib.Order.RelSeries | ∀ {α : Type u_1} (r : SetRel α α) (a : α) (a_1 : Fin 0), (a, a) ∈ r | false |
_private.Mathlib.MeasureTheory.PiSystem.0.piiUnionInter_mono_right.match_1_1 | Mathlib.MeasureTheory.PiSystem | ∀ {α : Type u_1} {ι : Type u_2} {π : ι → Set (Set α)} {S : Set ι} (x : Set α) (motive : x ∈ piiUnionInter π S → Prop)
(x_1 : x ∈ piiUnionInter π S),
(∀ (t : Finset ι) (ht_mem : ↑t ⊆ S) (ft : ι → Set α) (hft_mem_pi : ∀ x ∈ t, ft x ∈ π x) (h_eq : x = ⋂ x ∈ t, ft x),
motive ⋯) →
motive x_1 | false |
Lean.Firefox.ThreadWithCollideMaps.markers._inherited_default | Lean.Util.Profiler | Lean.Firefox.RawMarkerTable | false |
MulArchimedeanClass.mem_ballSubgroup_iff | Mathlib.Algebra.Order.Archimedean.Class | ∀ {M : Type u_1} [inst : CommGroup M] [inst_1 : LinearOrder M] [inst_2 : IsOrderedMonoid M] {a : M}
{c : MulArchimedeanClass M}, c ≠ ⊤ → (a ∈ c.ballSubgroup ↔ c < MulArchimedeanClass.mk a) | true |
Rel.abs_edgeDensity_sub_edgeDensity_le_two_mul | Mathlib.Combinatorics.SimpleGraph.Density | ∀ {𝕜 : Type u_1} {α : Type u_4} {β : Type u_5} [inst : Field 𝕜] [inst_1 : LinearOrder 𝕜] [IsStrictOrderedRing 𝕜]
(r : α → β → Prop) [inst_3 : (a : α) → DecidablePred (r a)] {s₁ s₂ : Finset α} {t₁ t₂ : Finset β} {δ : 𝕜},
s₂ ⊆ s₁ →
t₂ ⊆ t₁ →
0 ≤ δ →
(1 - δ) * ↑s₁.card ≤ ↑s₂.card →
(1 ... | true |
Singleton.mk._flat_ctor | Init.Core | {α : outParam (Type u)} → {β : Type v} → (α → β) → Singleton α β | false |
CategoryTheory.MorphismProperty.inverseImage_map_eq_of_isEquivalence | Mathlib.CategoryTheory.MorphismProperty.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {D : Type u_1} [inst_1 : CategoryTheory.Category.{v_1, u_1} D]
(P : CategoryTheory.MorphismProperty C) [P.RespectsIso] (F : CategoryTheory.Functor C D) [F.IsEquivalence],
(P.map F).inverseImage F = P | true |
Std.DTreeMap.Raw.Const.minKeyD_alter_eq_self | Std.Data.DTreeMap.Raw.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {β : Type v} {t : Std.DTreeMap.Raw α (fun x => β) cmp} [Std.TransCmp cmp],
t.WF →
∀ {k : α} {f : Option β → Option β},
(Std.DTreeMap.Raw.Const.alter t k f).isEmpty = false →
∀ {fallback : α},
(Std.DTreeMap.Raw.Const.alter t k f).minKeyD fallback = k ... | true |
Int.ediv_lt_ediv_iff_of_dvd_of_neg_of_neg | Init.Data.Int.DivMod.Lemmas | ∀ {a b c d : ℤ}, b < 0 → d < 0 → b ∣ a → d ∣ c → (a / b < c / d ↔ d * a < c * b) | true |
MeasureTheory.condExpL2._proof_1 | Mathlib.MeasureTheory.Function.ConditionalExpectation.CondexpL2 | ∀ (E : Type u_1) [inst : NormedAddCommGroup E], IsTopologicalAddGroup E | false |
Algebra.TensorProduct.tensorQuotientEquiv._proof_1 | Mathlib.RingTheory.TensorProduct.Quotient | ∀ {R : Type u_1} (T : Type u_2) [inst : CommRing R] [inst_1 : CommRing T] [inst_2 : Algebra R T], IsScalarTower R T T | false |
Profinite.NobelingProof.instUniqueSubtypeProductsIsGoodSingletonForallBoolSetFalse | Mathlib.Topology.Category.Profinite.Nobeling.ZeroLimit | {I : Type u} → [inst : LinearOrder I] → Unique { l // Profinite.NobelingProof.Products.isGood {fun x => false} l } | true |
_private.Init.Data.Char.Ordinal.0.Char.ordinal_le_of_le._proof_1_4 | Init.Data.Char.Ordinal | ∀ {c d : Char},
c.val.toNat ≤ d.val.toNat →
(if c.val.toNat < 55296 then c.val.toNat else c.val.toNat - 2048) ≤
if d.val.toNat < 55296 then d.val.toNat else d.val.toNat - 2048 | false |
QuaternionAlgebra.Basis.k | Mathlib.Algebra.QuaternionBasis | {R : Type u_1} →
{A : Type u_2} →
[inst : CommRing R] →
[inst_1 : Ring A] → [inst_2 : Algebra R A] → {c₁ c₂ c₃ : R} → QuaternionAlgebra.Basis A c₁ c₂ c₃ → A | true |
AlgCat.instRingElemForallObjCompForgetAlgHomCarrierSections._proof_39 | Mathlib.Algebra.Category.AlgCat.Limits | ∀ {R : Type u_4} [inst : CommRing R] {J : Type u_1} [inst_1 : CategoryTheory.Category.{u_3, u_1} J]
(F : CategoryTheory.Functor J (AlgCat R)),
autoParam
(∀ (a : ↑(F.comp (CategoryTheory.forget (AlgCat R))).sections),
AlgCat.instRingElemForallObjCompForgetAlgHomCarrierSections._aux_37 F 0 a = 0)
SubNeg... | false |
MeasureTheory.integral_neg' | Mathlib.MeasureTheory.Integral.Bochner.Basic | ∀ {α : Type u_1} {G : Type u_5} [inst : NormedAddCommGroup G] [inst_1 : NormedSpace ℝ G] {m : MeasurableSpace α}
{μ : MeasureTheory.Measure α} (f : α → G), ∫ (a : α), (-f) a ∂μ = -∫ (a : α), f a ∂μ | true |
_private.Mathlib.Algebra.Homology.HomotopyCategory.KProjective.0.CochainComplex.wrapped._proof_1._@.Mathlib.Algebra.Homology.HomotopyCategory.KProjective.595972877._hygCtx._hyg.2 | Mathlib.Algebra.Homology.HomotopyCategory.KProjective | @CochainComplex.definition✝ = @CochainComplex.definition✝ | false |
_private.Mathlib.Topology.Perfect.0.preperfect_iff_nhds._simp_1_2 | Mathlib.Topology.Perfect | ∀ {X : Type u} [inst : TopologicalSpace X] {x : X} {C : Set X},
AccPt x (Filter.principal C) = ∀ U ∈ nhds x, ∃ y ∈ U ∩ C, y ≠ x | false |
SemilatSupCat.instConcreteCategorySupBotHomX._proof_3 | Mathlib.Order.Category.Semilat | ∀ {X : SemilatSupCat} (x : X.X), (CategoryTheory.CategoryStruct.id X) x = x | false |
closedBall_sub_closedBall | Mathlib.Analysis.Normed.Module.Ball.Pointwise | ∀ {E : Type u_2} [inst : SeminormedAddCommGroup E] [NormedSpace ℝ E] {δ ε : ℝ} [ProperSpace E],
0 ≤ ε → 0 ≤ δ → ∀ (a b : E), Metric.closedBall a ε - Metric.closedBall b δ = Metric.closedBall (a - b) (ε + δ) | true |
_private.Mathlib.Order.BooleanAlgebra.Set.0.Set.inl_compl_union_inr_compl._proof_1_1 | Mathlib.Order.BooleanAlgebra.Set | ∀ {α : Type u_1} {β : Type u_2} {s : Set α} {t : Set β}, Sum.inl '' sᶜ ∪ Sum.inr '' tᶜ = (Sum.inl '' s ∪ Sum.inr '' t)ᶜ | false |
TensorProduct.vanishesTrivially_of_sum_tmul_eq_zero_of_rTensor_injective | Mathlib.LinearAlgebra.TensorProduct.Vanishing | ∀ (R : Type u_1) [inst : CommRing R] {M : Type u_2} [inst_1 : AddCommGroup M] [inst_2 : Module R M] {N : Type u_3}
[inst_3 : AddCommGroup N] [inst_4 : Module R N] {ι : Type u_4} [inst_5 : Fintype ι] {m : ι → M} {n : ι → N},
Function.Injective ⇑(LinearMap.rTensor N (Submodule.span R (Set.range m)).subtype) →
∑ i... | true |
AddGroupNorm.noConfusionType | Mathlib.Analysis.Normed.Group.Seminorm | Sort u →
{G : Type u_6} →
[inst : AddGroup G] → AddGroupNorm G → {G' : Type u_6} → [inst' : AddGroup G'] → AddGroupNorm G' → Sort u | false |
AlgHom.mapMatrix._proof_1 | Mathlib.Data.Matrix.Basic | ∀ {m : Type u_2} {R : Type u_4} {α : Type u_3} {β : Type u_1} [inst : Fintype m] [inst_1 : DecidableEq m]
[inst_2 : CommSemiring R] [inst_3 : Semiring α] [inst_4 : Semiring β] [inst_5 : Algebra R α] [inst_6 : Algebra R β]
(f : α →ₐ[R] β), (↑↑f.mapMatrix).toFun 1 = 1 | false |
Std.Time.Nanosecond.instReprSpan._aux_1 | Std.Time.Time.Unit.Nanosecond | Std.Time.Nanosecond.Span → ℕ → Std.Format | false |
FreeMonoid.of.eq_1 | Mathlib.Algebra.FreeMonoid.Basic | ∀ {α : Type u_1} (x : α), FreeMonoid.of x = FreeMonoid.ofList [x] | true |
Batteries.RBNode.isRed_reverse | Batteries.Data.RBMap.WF | ∀ {α : Type u_1} {t : Batteries.RBNode α}, t.reverse.isRed = t.isRed | true |
Std.DTreeMap.Internal.Impl.Const.get_union!_of_contains_eq_false_right | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {instOrd : Ord α} {β : Type v} {m₁ m₂ : Std.DTreeMap.Internal.Impl α fun x => β} [inst : Std.TransOrd α]
(h₁ : m₁.WF) (h₂ : m₂.WF) {k : α} (contains_eq_false : Std.DTreeMap.Internal.Impl.contains k m₂ = false)
{h' : Std.DTreeMap.Internal.Impl.contains k (m₁.union! m₂) = true},
Std.DTreeMap.Internal... | true |
_private.Mathlib.AlgebraicTopology.SimplicialObject.ChainHomotopy.0.CategoryTheory.SimplicialObject.Homotopy.ToChainHomotopy.comm_succ._proof_1_33 | Mathlib.AlgebraicTopology.SimplicialObject.ChainHomotopy | ∀ (n k : ℕ), k < n + 2 → k.succ < (n + 2).succ | false |
Order.cof_le_cardinalMk | Mathlib.SetTheory.Cardinal.Cofinality | ∀ (α : Type u) [inst : Preorder α], Order.cof α ≤ Cardinal.mk α | true |
_private.Mathlib.AlgebraicGeometry.Limits.0.AlgebraicGeometry.isAffineOpen_bot._proof_1_1 | Mathlib.AlgebraicGeometry.Limits | ∀ (X : AlgebraicGeometry.Scheme), IsEmpty ↥↑⊥ | false |
Rat.cast_det._simp_1 | Mathlib.LinearAlgebra.Matrix.Determinant.Basic | ∀ {n : Type u_2} [inst : DecidableEq n] [inst_1 : Fintype n] {F : Type u_3} [inst_2 : Field F] [CharZero F]
(M : Matrix n n ℚ), (M.map fun x => ↑x).det = ↑M.det | false |
CategoryTheory.ObjectProperty.IsSeparating.epi_coproductFrom | Mathlib.CategoryTheory.Generator.Basic | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {P : CategoryTheory.ObjectProperty C},
P.IsSeparating →
∀ (X : C) [inst_1 : CategoryTheory.Limits.HasCoproduct (P.coproductFromFamily X)],
CategoryTheory.Epi (P.coproductFrom X) | true |
dvd_sub_left | Mathlib.Algebra.Ring.Divisibility.Basic | ∀ {α : Type u_1} [inst : NonUnitalRing α] {a b c : α}, a ∣ c → (a ∣ b - c ↔ a ∣ b) | true |
_private.Init.NotationExtra.0.Lean.expandBracketedBindersAux.loop | Init.NotationExtra | Lean.Syntax → (binders : Array Lean.Syntax) → (i : ℕ) → i ≤ binders.size → Lean.Syntax → Lean.MacroM Lean.Syntax | true |
CategoryTheory.Comma.mapLeftIso_counitIso_hom_app_right | Mathlib.CategoryTheory.Comma.Basic | ∀ {A : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} A] {B : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} B]
{T : Type u₃} [inst_2 : CategoryTheory.Category.{v₃, u₃} T] (R : CategoryTheory.Functor B T)
{L₁ L₂ : CategoryTheory.Functor A T} (i : L₁ ≅ L₂) (X : CategoryTheory.Comma L₂ R),
((CategoryTheory.... | true |
_private.Mathlib.Data.Nat.Find.0.Nat.le_find_iff._simp_1_1 | Mathlib.Data.Nat.Find | ∀ {α : Type u_1} [inst : LinearOrder α] {a b : α}, (b ≤ a) = ¬a < b | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.