name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
DomMulAct.smul_linearMap_apply | Mathlib.Algebra.Module.LinearMap.Basic | ∀ {R : Type u_1} {R' : Type u_2} {M : Type u_4} {M' : Type u_5} [inst : Semiring R] [inst_1 : Semiring R']
[inst_2 : AddCommMonoid M] [inst_3 : AddCommMonoid M'] [inst_4 : Module R M] [inst_5 : Module R' M'] {σ₁₂ : R →+* R'}
{S' : Type u_6} [inst_6 : Monoid S'] [inst_7 : DistribMulAction S' M] [inst_8 : SMulCommCla... | true |
Std.Asymm.mk._flat_ctor | Init.Core | ∀ {α : Sort u} {r : α → α → Prop}, (∀ (a b : α), r a b → ¬r b a) → Std.Asymm r | false |
_private.Init.Data.Iterators.Lemmas.Combinators.Monadic.FilterMap.0.Std.IterM.foldM_filterMapWithPostcondition.match_1.eq_2 | Init.Data.Iterators.Lemmas.Combinators.Monadic.FilterMap | ∀ {γ : Type u_1} (motive : Option γ → Sort u_2) (x : Option γ) (h_1 : (c : γ) → motive (some c))
(h_2 : (x : Option γ) → motive x),
(∀ (c : γ), x = some c → False) →
(match x with
| some c => h_1 c
| x => h_2 x) =
h_2 x | true |
Lean.Elab.WF.initFn._@.Lean.Elab.PreDefinition.WF.Fix.34085118._hygCtx._hyg.4 | Lean.Elab.PreDefinition.WF.Fix | IO (Lean.Option Bool) | false |
IsClopen.isOpen | Mathlib.Topology.Clopen | ∀ {X : Type u} [inst : TopologicalSpace X] {s : Set X}, IsClopen s → IsOpen s | true |
Std.DHashMap.Internal.Raw₀.Const.get_map' | Std.Data.DHashMap.Internal.RawLemmas | ∀ {α : Type u} [inst : BEq α] [inst_1 : Hashable α] {β : Type v} {γ : Type w}
(m : Std.DHashMap.Internal.Raw₀ α fun x => β) [inst_2 : EquivBEq α] [inst_3 : LawfulHashable α] {f : α → β → γ}
{k : α} (h : (↑m).WF) {h' : (Std.DHashMap.Internal.Raw₀.map f m).contains k = true},
Std.DHashMap.Internal.Raw₀.Const.get (S... | true |
_private.Mathlib.Order.Filter.Partial.0.Filter.rtendsto_iff_le_rcomap._simp_1_1 | Mathlib.Order.Filter.Partial | ∀ {α : Type u_1} {f g : Filter α}, (f ≤ g) = ∀ x ∈ g, x ∈ f | false |
LinearOrderedAddCommGroup.closure_equiv_closure._proof_6 | Mathlib.GroupTheory.ArchimedeanDensely | ∀ {G : Type u_1} {G' : Type u_2} [inst : AddCommGroup G] [inst_1 : AddCommGroup G'] (x : G) (y : G')
(hxy : x = 0 ↔ y = 0) (hx : x = 0) (x_1 y_1 : ↥(AddSubgroup.closure {x})),
⟨0, ⋯⟩ =
{ toFun := fun x_2 => ⟨0, ⋯⟩, invFun := fun x_2 => ⟨0, ⋯⟩, left_inv := ⋯, right_inv := ⋯ }.toFun x_1 +
{ toFun := fun x_2... | false |
List.one_le_prod_of_one_le | Mathlib.Algebra.Order.BigOperators.Group.List | ∀ {M : Type u_3} [inst : Monoid M] [inst_1 : Preorder M] [MulLeftMono M] {l : List M}, (∀ x ∈ l, 1 ≤ x) → 1 ≤ l.prod | true |
ContinuousMap.instCStarAlgebra._proof_5 | Mathlib.Analysis.CStarAlgebra.ContinuousMap | ∀ {A : Type u_1} [inst : CStarAlgebra A], ContinuousStar A | false |
locallyConnectedSpace_iff_hasBasis_isOpen_isConnected | Mathlib.Topology.Connected.LocallyConnected | ∀ {α : Type u} [inst : TopologicalSpace α],
LocallyConnectedSpace α ↔ ∀ (x : α), (nhds x).HasBasis (fun s => IsOpen s ∧ x ∈ s ∧ IsConnected s) id | true |
Lean.Parser.Term.debugAssert.parenthesizer | Lean.Parser.Term | Lean.PrettyPrinter.Parenthesizer | true |
_private.Mathlib.LinearAlgebra.RootSystem.Finite.Nondegenerate.0.RootPairing.finrank_corootSpan_le | Mathlib.LinearAlgebra.RootSystem.Finite.Nondegenerate | ∀ {ι : Type u_1} {R : Type u_2} {M : Type u_3} {N : Type u_4} [inst : Fintype ι] [inst_1 : AddCommGroup M]
[inst_2 : AddCommGroup N] [inst_3 : CommRing R] [inst_4 : Module R M] [inst_5 : Module R N] (P : RootPairing ι R M N)
(S : Type u_5) [inst_6 : CommRing S] [IsDomain R] [IsDomain S] [inst_9 : Algebra S R] [Fait... | true |
SimpleGraph.Walk.cycleBypass.match_1 | Mathlib.Combinatorics.SimpleGraph.Paths | {V : Type u_1} →
{G : SimpleGraph V} →
{v : V} →
(motive : G.Walk v v → Sort u_2) →
(x : G.Walk v v) →
(Unit → motive SimpleGraph.Walk.nil) →
((v_1 : V) → (hvv' : G.Adj v v_1) → (w : G.Walk v_1 v) → motive (SimpleGraph.Walk.cons hvv' w)) → motive x | false |
_private.Std.Data.DTreeMap.Internal.Cell.0.Std.DTreeMap.Internal.Cell.containsKey_inner_toList._simp_1_3 | Std.Data.DTreeMap.Internal.Cell | ∀ {α : Type u} {x : Ord α} {x_1 : BEq α} [Std.LawfulBEqOrd α] {a b : α}, (compare a b = Ordering.eq) = ((a == b) = true) | false |
Turing.Tape.move | Mathlib.Computability.TuringMachine.Tape | {Γ : Type u_1} → [inst : Inhabited Γ] → Turing.Dir → Turing.Tape Γ → Turing.Tape Γ | true |
LieAlgebra.IsKilling.rootSystem_pairing_apply | Mathlib.Algebra.Lie.Weights.RootSystem | ∀ {K : Type u_1} {L : Type u_2} [inst : Field K] [inst_1 : CharZero K] [inst_2 : LieRing L] [inst_3 : LieAlgebra K L]
[inst_4 : LieAlgebra.IsKilling K L] [inst_5 : FiniteDimensional K L] (H : LieSubalgebra K L)
[inst_6 : H.IsCartanSubalgebra] [inst_7 : LieModule.IsTriangularizable K (↥H) L] (α β : ↥LieSubalgebra.ro... | true |
_private.Lean.Meta.Tactic.Simp.Main.0.Lean.Meta.Simp.unfoldDefinitionAny? | Lean.Meta.Tactic.Simp.Main | Lean.Expr → Lean.MetaM (Option Lean.Expr) | true |
_private.Mathlib.Tactic.Linarith.Verification.0.Mathlib.Tactic.Linarith.addExprs'.go._sunfold | Mathlib.Tactic.Linarith.Verification | {u : Lean.Level} →
{α :
have u := u;
Q(Type u)} →
Q(AddMonoid «$α») → Q(«$α») → List Q(«$α») → Q(«$α») | false |
WithAbs.congr_apply | Mathlib.Analysis.Normed.Ring.WithAbs | ∀ {R : Type u_1} {S : Type u_2} [inst : Semiring S] [inst_1 : PartialOrder S] [inst_2 : Semiring R]
(v : AbsoluteValue R S) {T : Type u_3} [inst_3 : Semiring T] (w : AbsoluteValue T S) (f : R ≃+* T) (x : WithAbs v),
(WithAbs.congr v w f) x = WithAbs.toAbs w (f x.ofAbs) | true |
Std.DHashMap.Const.mem_alter_of_beq | Std.Data.DHashMap.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {β : Type v} {m : Std.DHashMap α fun x => β} [EquivBEq α]
[LawfulHashable α] {k k' : α} {f : Option β → Option β},
(k == k') = true → (k' ∈ Std.DHashMap.Const.alter m k f ↔ (f (Std.DHashMap.Const.get? m k)).isSome = true) | true |
MeasureTheory.integrableOn_fun_neg_iff | Mathlib.MeasureTheory.Integral.IntegrableOn | ∀ {α : Type u_1} {E : Type u_5} {mα : MeasurableSpace α} [inst : NormedAddCommGroup E] {s : Set α}
{μ : MeasureTheory.Measure α} {f : α → E},
MeasureTheory.IntegrableOn (fun x => -f x) s μ ↔ MeasureTheory.IntegrableOn f s μ | true |
Matrix.toLin_toMatrix | Mathlib.LinearAlgebra.Matrix.ToLin | ∀ {R : Type u_1} [inst : CommSemiring R] {m : Type u_3} {n : Type u_4} [inst_1 : Fintype n] [inst_2 : Finite m]
[inst_3 : DecidableEq n] {M₁ : Type u_5} {M₂ : Type u_6} [inst_4 : AddCommMonoid M₁] [inst_5 : AddCommMonoid M₂]
[inst_6 : Module R M₁] [inst_7 : Module R M₂] (v₁ : Module.Basis n R M₁) (v₂ : Module.Basis... | true |
Std.TreeMap.insertMany_list_singleton | Std.Data.TreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.TreeMap α β cmp} {k : α} {v : β},
t.insertMany [(k, v)] = t.insert k v | true |
_private.Mathlib.Analysis.Normed.Module.PiTensorProduct.InjectiveSeminorm.0.PiTensorProduct.mapL_add_smul_aux | Mathlib.Analysis.Normed.Module.PiTensorProduct.InjectiveSeminorm | ∀ {𝕜 : Type u𝕜} [inst : NontriviallyNormedField 𝕜] {ι : Type uι} {E : ι → Type uE}
[inst_1 : (i : ι) → SeminormedAddCommGroup (E i)] [inst_2 : (i : ι) → NormedSpace 𝕜 (E i)] {E' : ι → Type u_1}
[inst_3 : (i : ι) → SeminormedAddCommGroup (E' i)] [inst_4 : (i : ι) → NormedSpace 𝕜 (E' i)]
(f : (i : ι) → E i →L[... | true |
conjneg_zero | Mathlib.Algebra.Star.Conjneg | ∀ {G : Type u_2} {R : Type u_3} [inst : AddGroup G] [inst_1 : CommSemiring R] [inst_2 : StarRing R], conjneg 0 = 0 | true |
Lean.Name.mkSimple | Init.Prelude | String → Lean.Name | true |
Lean.Parser.Command.init_quot._regBuiltin.Lean.Parser.Command.init_quot.declRange_3 | Lean.Parser.Command | IO Unit | false |
ContinuousOn.isBigOWith_rev_principal | Mathlib.Analysis.Asymptotics.Lemmas | ∀ {α : Type u_1} {E : Type u_2} {F : Type u_3} [inst : TopologicalSpace α] {s : Set α} {f : α → E}
[inst_1 : NormedAddGroup E] [inst_2 : SeminormedAddGroup F],
ContinuousOn f s →
IsCompact s →
(∀ i ∈ s, f i ≠ 0) →
∀ (c : F), Asymptotics.IsBigOWith (‖c‖ / sInf (norm '' (f '' s))) (Filter.principal ... | true |
_private.Mathlib.MeasureTheory.Integral.MeanInequalities.0.ENNReal.lintegral_Lp_mul_le_Lq_mul_Lr._simp_1_1 | Mathlib.MeasureTheory.Integral.MeanInequalities | ∀ {G₀ : Type u_3} [inst : GroupWithZero G₀] [inst_1 : PartialOrder G₀] [MulPosReflectLT G₀] {a b c : G₀},
0 < c → (a < b / c) = (a * c < b) | false |
Con.quotientKerEquivOfRightInverse._proof_3 | Mathlib.GroupTheory.Congruence.Basic | ∀ {M : Type u_1} {P : Type u_2} [inst : MulOneClass M] [inst_1 : MulOneClass P] (f : M →* P) (g : P → M),
Function.RightInverse g ⇑f → ∀ (x : (Con.ker f).Quotient), (Con.toQuotient ∘ g) ((Con.kerLift f) x) = x | false |
Lean.Meta.Grind.SplitSource.recOn | Lean.Meta.Tactic.Grind.Types | {motive : Lean.Meta.Grind.SplitSource → Sort u} →
(t : Lean.Meta.Grind.SplitSource) →
((origin : Lean.Meta.Grind.Origin) → motive (Lean.Meta.Grind.SplitSource.ematch origin)) →
((declName : Lean.Name) → motive (Lean.Meta.Grind.SplitSource.ext declName)) →
((a b : Lean.Expr) → (i : ℕ) → motive (Lean.... | false |
_private.Lean.Meta.PPGoal.0.Lean.Meta.ppGoal.ppVars.match_1 | Lean.Meta.PPGoal | (motive : Lean.LocalDecl → Sort u_1) →
(localDecl : Lean.LocalDecl) →
((index : ℕ) →
(fvarId : Lean.FVarId) →
(varName : Lean.Name) →
(type : Lean.Expr) →
(bi : Lean.BinderInfo) →
(kind : Lean.LocalDeclKind) → motive (Lean.LocalDecl.cdecl index fvarId va... | false |
Module.Flat.tensorSubmoduleAlgebraEquiv | Mathlib.RingTheory.PicardGroup | {R : Type u} →
{M : Type v} →
{A : Type u_4} →
[inst : CommSemiring R] →
[inst_1 : AddCommMonoid M] →
[inst_2 : Module R M] →
[inst_3 : Semiring A] →
[inst_4 : Algebra R A] →
(e : TensorProduct R A M ≃ₗ[A] A) →
[Module.Flat R M] →... | true |
CategoryTheory.LocalizerMorphism.IsRightDerivabilityStructure.recOn | Mathlib.CategoryTheory.Localization.DerivabilityStructure.Basic | {C₁ : Type u₁} →
{C₂ : Type u₂} →
[inst : CategoryTheory.Category.{v₁, u₁} C₁] →
[inst_1 : CategoryTheory.Category.{v₂, u₂} C₂] →
{W₁ : CategoryTheory.MorphismProperty C₁} →
{W₂ : CategoryTheory.MorphismProperty C₂} →
{Φ : CategoryTheory.LocalizerMorphism W₁ W₂} →
... | false |
Set.iUnion_add_left_image | Mathlib.Algebra.Group.Pointwise.Set.Lattice | ∀ {α : Type u_2} [inst : Add α] {s t : Set α}, ⋃ a ∈ s, (fun x => a + x) '' t = s + t | true |
Dense.ciInf' | Mathlib.Topology.Order.IsLUB | ∀ {γ : Type u_2} {α : Type u_3} [inst : TopologicalSpace α] [inst_1 : ConditionallyCompleteLinearOrder α]
[ClosedIciTopology α] {f : γ → α} [inst_3 : TopologicalSpace γ] {S : Set γ},
Dense S → Continuous f → ⨅ s, f ↑s = ⨅ i, f i | true |
LieModule.traceForm_apply_apply | Mathlib.Algebra.Lie.TraceForm | ∀ (R : Type u_1) (L : Type u_3) (M : Type u_4) [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : LieAlgebra R L]
[inst_3 : AddCommGroup M] [inst_4 : Module R M] [inst_5 : LieRingModule L M] [inst_6 : LieModule R L M] (x y : L),
((LieModule.traceForm R L M) x) y = (LinearMap.trace R M) ((LieModule.toEnd R L M) x ∘ₗ... | true |
PrimeSpectrum.pointsEquivIrreducibleCloseds._proof_1 | Mathlib.RingTheory.Spectrum.Prime.Topology | ∀ (R : Type u_1) [inst : CommSemiring R] {p q : PrimeSpectrum R},
(RelIso.symm irreducibleSetEquivPoints) q ≤ (RelIso.symm irreducibleSetEquivPoints) p ↔ p ≤ q | false |
SemiNormedGrp₁.mkHom.congr_simp | Mathlib.Analysis.Normed.Group.SemiNormedGrp | ∀ {M N : Type u} [inst : SeminormedAddCommGroup M] [inst_1 : SeminormedAddCommGroup N] (f f_1 : NormedAddGroupHom M N)
(e_f : f = f_1) (i : f.NormNoninc), SemiNormedGrp₁.mkHom f i = SemiNormedGrp₁.mkHom f_1 ⋯ | true |
CategoryTheory.MorphismProperty.Comma.mk.congr_simp | Mathlib.CategoryTheory.MorphismProperty.OverAdjunction | ∀ {A : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} A] {B : Type u_2}
[inst_1 : CategoryTheory.Category.{v_2, u_2} B] {T : Type u_3} [inst_2 : CategoryTheory.Category.{v_3, u_3} T]
{L : CategoryTheory.Functor A T} {R : CategoryTheory.Functor B T} {P : CategoryTheory.MorphismProperty T}
{Q : CategoryTheory... | true |
_private.Mathlib.Topology.MetricSpace.Pseudo.Defs.0.Metric.eventually_nhds_prod_iff._simp_1_2 | Mathlib.Topology.MetricSpace.Pseudo.Defs | ∀ {α : Type u_1} {β : Type u_2} {s : Set α} {t : Set β} {p : α × β → Prop},
(∀ x ∈ s ×ˢ t, p x) = ∀ x ∈ s, ∀ y ∈ t, p (x, y) | false |
MonoidAlgebra.supportedEquivFinsupp._proof_9 | Mathlib.Algebra.MonoidAlgebra.Module | ∀ {R : Type u_3} {M : Type u_1} {S : Type u_2} [inst : Semiring R] [inst_1 : Semiring S] [inst_2 : Module R S]
(s : Set M) (x : ↥(MonoidAlgebra.supported R S s)),
⟨MonoidAlgebra.ofCoeff ↑⟨(↑x).coeff, ⋯⟩, ⋯⟩ = ⟨MonoidAlgebra.ofCoeff ↑⟨(↑x).coeff, ⋯⟩, ⋯⟩ | false |
AddMonoidAlgebra.mapRingHom | Mathlib.Algebra.MonoidAlgebra.MapDomain | {R : Type u_3} →
{S : Type u_4} →
(M : Type u_6) →
[inst : Semiring R] →
[inst_1 : Semiring S] → [inst_2 : AddMonoid M] → (R →+* S) → AddMonoidAlgebra R M →+* AddMonoidAlgebra S M | true |
AddMonoidHom.restrictHomKerEquiv._proof_9 | Mathlib.GroupTheory.QuotientGroup.Basic | ∀ {G : Type u_1} [inst : AddGroup G] (A : Type u_2) [inst_1 : AddCommGroup A] (H : AddSubgroup G) [inst_2 : H.Normal]
(x x_1 : ↥(AddMonoidHom.restrictHom H A).ker),
(match x + x_1 with
| ⟨f, hf⟩ => QuotientAddGroup.lift H f ⋯) =
(match x with
| ⟨f, hf⟩ => QuotientAddGroup.lift H f ⋯) +
match x_1... | false |
Function.Embedding.setValue.congr_simp | Mathlib.Data.Fin.Embedding | ∀ {α : Sort u_1} {β : Sort u_2} (f f_1 : α ↪ β),
f = f_1 →
∀ (a a_1 : α),
a = a_1 →
∀ (b b_1 : β),
b = b_1 →
∀ {inst : (a' : α) → Decidable (a' = a)} [inst_1 : (a' : α) → Decidable (a' = a_1)]
{inst_2 : (a' : α) → Decidable (f a' = b)} [inst_3 : (a' : α) → Decidab... | true |
Lean.Parser.Command.abbrev | Lean.Parser.Command | Lean.Parser.Parser | true |
MeasureTheory.withDensity_add_left | Mathlib.MeasureTheory.Measure.WithDensity | ∀ {α : Type u_1} {m0 : MeasurableSpace α} {μ : MeasureTheory.Measure α} {f : α → ENNReal},
Measurable f → ∀ (g : α → ENNReal), μ.withDensity (f + g) = μ.withDensity f + μ.withDensity g | true |
Real.le_sInf | Mathlib.Data.Real.Archimedean | ∀ {s : Set ℝ} {a : ℝ}, (∀ x ∈ s, a ≤ x) → a ≤ 0 → a ≤ sInf s | true |
_private.Init.Data.Array.Subarray.0.Subarray.findSomeRevM?.find.match_1 | Init.Data.Array.Subarray | {β : Type u_1} →
(motive : Option β → Sort u_2) → (r : Option β) → ((val : β) → motive (some val)) → (Unit → motive none) → motive r | false |
instLocPathConnectedSpace | Mathlib.Topology.Homotopy.LocallyContractible | ∀ {X : Type u_1} [inst : TopologicalSpace X] [StronglyLocallyContractibleSpace X], LocPathConnectedSpace X | true |
Lean.Grind.Semiring.mul_one_congr | Init.Grind.Lemmas | ∀ {α : Type u_1} [inst : Lean.Grind.Semiring α] {a b : α}, b = 1 → a * b = a | true |
Array.all_flatMap | Init.Data.Array.Lemmas | ∀ {α : Type u_1} {β : Type u_2} {xs : Array α} {f : α → Array β} {p : β → Bool},
(Array.flatMap f xs).all p = xs.all fun a => (f a).all p | true |
SSet.Subcomplex.PairingCore.IsProper.mk | Mathlib.AlgebraicTopology.SimplicialSet.AnodyneExtensions.PairingCore | ∀ {X : SSet} {A : X.Subcomplex} {h : A.PairingCore},
(∀ (s : h.ι), (h.type₂ s).IsUniquelyCodimOneFace (h.type₁ s).toS) → h.IsProper | true |
CommSemiRingCat.Hom.ctorIdx | Mathlib.Algebra.Category.Ring.Basic | {R S : CommSemiRingCat} → R.Hom S → ℕ | false |
IsAddFoelner.eventually_meas_ne_top | Mathlib.MeasureTheory.Group.FoelnerFilter | ∀ {G : Type u_4} {X : Type u_5} [inst : MeasurableSpace X] {μ : MeasureTheory.Measure X} [inst_1 : AddGroup G]
[inst_2 : AddAction G X] {ι : Type u_6} {l : Filter ι} {F : ι → Set X},
IsAddFoelner G μ l F → ∀ᶠ (i : ι) in l, μ (F i) ≠ ⊤ | true |
εNFA.IsPath | Mathlib.Computability.EpsilonNFA | {α : Type u} → {σ : Type v} → εNFA α σ → σ → σ → List (Option α) → Prop | true |
_private.Std.Data.Internal.List.Associative.0.Std.Internal.List.insertEntryIfNew.eq_1 | Std.Data.Internal.List.Associative | ∀ {α : Type u} {β : α → Type v} [inst : BEq α] (k : α) (v : β k) (l : List ((a : α) × β a)),
Std.Internal.List.insertEntryIfNew k v l = bif Std.Internal.List.containsKey k l then l else ⟨k, v⟩ :: l | true |
Lean.Doc.Parser.math | Lean.DocString.Parser | Lean.Parser.ParserFn | true |
_private.Lean.PrettyPrinter.Delaborator.Builtins.0.Lean.PrettyPrinter.Delaborator.delabForallParamsWithSignature.match_3 | Lean.PrettyPrinter.Delaborator.Builtins | (e : Lean.Expr) →
(n : Lean.Name) →
(d e' : Lean.Expr) →
(motive : (i : Lean.BinderInfo) → e = Lean.Expr.forallE n d e' i → Sort u_1) →
(i : Lean.BinderInfo) →
(h : e = Lean.Expr.forallE n d e' i) →
((h : e = Lean.Expr.forallE n d e' Lean.BinderInfo.implicit) → motive Lean.Bind... | false |
MeasureTheory.MemLp.congr_norm | Mathlib.MeasureTheory.Function.LpSeminorm.Basic | ∀ {α : Type u_1} {E : Type u_4} {F : Type u_5} {m0 : MeasurableSpace α} {p : ENNReal} {μ : MeasureTheory.Measure α}
[inst : NormedAddCommGroup E] [inst_1 : NormedAddCommGroup F] {f : α → E} {g : α → F},
MeasureTheory.MemLp f p μ →
MeasureTheory.AEStronglyMeasurable g μ → (∀ᵐ (a : α) ∂μ, ‖f a‖ = ‖g a‖) → Measure... | true |
IntermediateField.mem_adjoin_pair_left | Mathlib.FieldTheory.IntermediateField.Adjoin.Basic | ∀ (K : Type u_1) {L : Type u_2} [inst : Field K] [inst_1 : Field L] [inst_2 : Algebra K L] (x y : L), x ∈ K⟮x, y⟯ | true |
Option.guard.eq_1 | Init.Data.Option.Lemmas | ∀ {α : Type u_1} (p : α → Bool) (a : α), Option.guard p a = if p a = true then some a else none | true |
Filter.instVAdd | Mathlib.Order.Filter.Pointwise | {α : Type u_2} → {β : Type u_3} → [VAdd α β] → VAdd (Filter α) (Filter β) | true |
MeasureTheory.SimpleFunc.lintegral_mono_measure | Mathlib.MeasureTheory.Function.SimpleFunc | ∀ {α : Type u_1} {m : MeasurableSpace α} {μ ν : MeasureTheory.Measure α} {f : MeasureTheory.SimpleFunc α ENNReal},
μ ≤ ν → f.lintegral μ ≤ f.lintegral ν | true |
Finset.mul_nonempty | Mathlib.Algebra.Group.Pointwise.Finset.Basic | ∀ {α : Type u_2} [inst : DecidableEq α] [inst_1 : Mul α] {s t : Finset α}, (s * t).Nonempty ↔ s.Nonempty ∧ t.Nonempty | true |
Lean.DeclarationLocation.mk.inj | Lean.Data.DeclarationRange | ∀ {module : Lean.Name} {range : Lean.DeclarationRange} {module_1 : Lean.Name} {range_1 : Lean.DeclarationRange},
{ module := module, range := range } = { module := module_1, range := range_1 } → module = module_1 ∧ range = range_1 | true |
GaloisInsertion.le_l_u | Mathlib.Order.GaloisConnection.Defs | ∀ {α : Type u_2} {β : Type u_3} [inst : Preorder α] [inst_1 : Preorder β] {l : α → β} {u : β → α}
(self : GaloisInsertion l u) (x : β), x ≤ l (u x) | true |
CategoryTheory.ShiftedHom.comp_assoc | Mathlib.CategoryTheory.Shift.ShiftedHom | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {M : Type u_4} [inst_1 : AddMonoid M]
[inst_2 : CategoryTheory.HasShift C M] {X Y Z T : C} {a₁ a₂ a₃ a₁₂ a₂₃ a : M} (α : CategoryTheory.ShiftedHom X Y a₁)
(β : CategoryTheory.ShiftedHom Y Z a₂) (γ : CategoryTheory.ShiftedHom Z T a₃) (h₁₂ : a₂ + a₁ = a₁₂... | true |
ContinuousCohomology.MultiInd.functor | Mathlib.Algebra.Category.ContinuousCohomology.Basic | (R : Type u_1) →
(G : Type u_2) →
[inst : CommRing R] →
[inst_1 : Group G] →
[inst_2 : TopologicalSpace R] →
[inst_3 : TopologicalSpace G] →
[IsTopologicalGroup G] → ℕ → CategoryTheory.Functor (Action (TopModuleCat R) G) (Action (TopModuleCat R) G) | true |
Turing.TM1.SupportsStmt._sunfold | Mathlib.Computability.TuringMachine.PostTuringMachine | {Γ : Type u_1} → {Λ : Type u_2} → {σ : Type u_3} → Finset Λ → Turing.TM1.Stmt Γ Λ σ → Prop | false |
HahnSeries.cardSupp_zero | Mathlib.RingTheory.HahnSeries.Cardinal | ∀ {Γ : Type u_1} {R : Type u_2} [inst : PartialOrder Γ] [inst_1 : Zero R], HahnSeries.cardSupp 0 = 0 | true |
Coalgebra.TensorProduct.assoc_toLinearEquiv | Mathlib.RingTheory.Coalgebra.TensorProduct | ∀ {R : Type u_5} {S : Type u_6} {M : Type u_7} {N : Type u_8} {P : Type u_9} [inst : CommSemiring R]
[inst_1 : CommSemiring S] [inst_2 : Algebra R S] [inst_3 : AddCommMonoid M] [inst_4 : AddCommMonoid N]
[inst_5 : AddCommMonoid P] [inst_6 : Module R M] [inst_7 : Module R N] [inst_8 : Module R P] [inst_9 : Module S ... | true |
ContinuousLinearMap.intrinsicInvolutiveStar._proof_1 | Mathlib.Topology.Algebra.Star.LinearMap | ∀ {R : Type u_3} {E : Type u_1} {F : Type u_2} [inst : Semiring R] [inst_1 : InvolutiveStar R]
[inst_2 : AddCommMonoid E] [inst_3 : Module R E] [inst_4 : StarAddMonoid E] [inst_5 : StarModule R E]
[inst_6 : AddCommMonoid F] [inst_7 : Module R F] [inst_8 : StarAddMonoid F] [inst_9 : StarModule R F]
[inst_10 : Topo... | false |
_private.Mathlib.RingTheory.Jacobson.Radical.0.Ring.jacobson_eq_sInf_isMaximal._simp_1_2 | Mathlib.RingTheory.Jacobson.Radical | ∀ {α : Type u} [inst : Semiring α] {I : Ideal α}, I.IsMaximal = IsCoatom I | false |
FintypeCatDiscrete.instHasForget₂FintypeCatHomObjFiniteTopCatContinuousMapCarrier._proof_1 | Mathlib.Topology.Category.FinTopCat | ∀ (X : FintypeCat),
TopCat.ofHom
{ toFun := ⇑(CategoryTheory.ConcreteCategory.hom (CategoryTheory.CategoryStruct.id X)), continuous_toFun := ⋯ } =
CategoryTheory.CategoryStruct.id (TopCat.of X.obj) | false |
Lean.Elab.AutoBoundImplicitContext.casesOn | Lean.Elab.AutoBound | {motive : Lean.Elab.AutoBoundImplicitContext → Sort u} →
(t : Lean.Elab.AutoBoundImplicitContext) →
((autoImplicitEnabled : Bool) →
(boundVariables : Lean.PArray Lean.Expr) →
motive { autoImplicitEnabled := autoImplicitEnabled, boundVariables := boundVariables }) →
motive t | false |
IsLeftCancelAdd.recOn | Mathlib.Algebra.Group.Defs | {G : Type u} →
[inst : Add G] →
{motive : IsLeftCancelAdd G → Sort u_1} →
(t : IsLeftCancelAdd G) → ((add_left_cancel : ∀ (a : G), IsAddLeftRegular a) → motive ⋯) → motive t | false |
DifferentiableAt.inverse | Mathlib.Analysis.Calculus.FDeriv.Mul | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {R : Type u_5} [inst_3 : NormedRing R] [HasSummableGeomSeries R]
[inst_5 : NormedAlgebra 𝕜 R] {h : E → R} {z : E},
DifferentiableAt 𝕜 h z → IsUnit (h z) → DifferentiableAt 𝕜 (fun x =... | true |
_private.Std.Data.DTreeMap.Internal.Balancing.0.Std.DTreeMap.Internal.Impl.balanceRErase.match_1.splitter | Std.Data.DTreeMap.Internal.Balancing | {α : Type u_1} →
{β : α → Type u_2} →
(motive :
(r : Std.DTreeMap.Internal.Impl α β) →
r.Balanced →
Std.DTreeMap.Internal.Impl.BalanceLErasePrecond r.size Std.DTreeMap.Internal.Impl.leaf.size → Sort u_3) →
(r : Std.DTreeMap.Internal.Impl α β) →
(hrb : r.Balanced) →
... | true |
CategoryTheory.Functor.lanAdjunction_unit | Mathlib.CategoryTheory.Functor.KanExtension.Adjunction | ∀ {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) (H : Type u_3)
[inst_2 : CategoryTheory.Category.{v_3, u_3} H]
[inst_3 : ∀ (F : CategoryTheory.Functor C H), L.HasLeftKanExtension F], (L.lanAdjunction H).... | true |
PSet.empty.eq_1 | Mathlib.SetTheory.ZFC.PSet | PSet.empty = PSet.mk PEmpty.{u_1 + 1} PEmpty.elim | true |
CategoryTheory.Groupoid.isoEquivHom_symm_apply_hom | Mathlib.CategoryTheory.Groupoid | ∀ {C : Type u} [inst : CategoryTheory.Groupoid C] (X Y : C) (f : X ⟶ Y),
((CategoryTheory.Groupoid.isoEquivHom X Y).symm f).hom = f | true |
CategoryTheory.Functor.functorialityCompPrecompose._proof_4 | Mathlib.CategoryTheory.Limits.Cones | ∀ {J : Type u_3} [inst : CategoryTheory.Category.{u_1, u_3} J] {C : Type u_4}
[inst_1 : CategoryTheory.Category.{u_2, u_4} C] {D : Type u_6} [inst_2 : CategoryTheory.Category.{u_5, u_6} D]
{F : CategoryTheory.Functor J C} {H H' : CategoryTheory.Functor C D} (α : H ≅ H')
{X Y : CategoryTheory.Limits.Cocone F} (f :... | false |
Lean.Meta.Simp.ConfigCtx.mk.noConfusion | Init.MetaTypes | {P : Sort u} →
{toConfig toConfig' : Lean.Meta.Simp.Config} →
{ toConfig := toConfig } = { toConfig := toConfig' } → (toConfig = toConfig' → P) → P | false |
PEmpty.recOn | Init.Prelude | (motive : PEmpty.{u} → Sort u_1) → (t : PEmpty.{u}) → motive t | false |
CategoryTheory.Limits.Multicofork.ofπ._proof_1 | Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer | ∀ {C : Type u_4} [inst : CategoryTheory.Category.{u_3, u_4} C] {J : CategoryTheory.Limits.MultispanShape}
(I : CategoryTheory.Limits.MultispanIndex J C) (P : C) (π : (b : J.R) → I.right b ⟶ P),
(∀ (a : J.L),
CategoryTheory.CategoryStruct.comp (I.fst a) (π (J.fst a)) =
CategoryTheory.CategoryStruct.com... | false |
List.idxOf?_nil | Init.Data.List.Find | ∀ {α : Type u_1} {a : α} [inst : BEq α], List.idxOf? a [] = none | true |
OrderHomClass.toOrderHom.congr_simp | Mathlib.Order.Hom.Basic | ∀ {F : Type u_1} {α : Type u_2} {β : Type u_3} [inst : Preorder α] [inst_1 : Preorder β] [inst_2 : FunLike F α β]
[inst_3 : OrderHomClass F α β] (f f_1 : F), f = f_1 → ↑f = ↑f_1 | true |
pos_of_mul_pos_left | Mathlib.Algebra.Order.GroupWithZero.Unbundled.Basic | ∀ {α : Type u_1} [inst : MulZeroClass α] {a b : α} [inst_1 : Preorder α] [MulPosReflectLT α], 0 < a * b → 0 ≤ b → 0 < a | true |
Std.Time.TimeZone.LocalTimeType.mk.noConfusion | Std.Time.Zoned.ZoneRules | {P : Sort u} →
{gmtOffset : Std.Time.TimeZone.Offset} →
{isDst : Bool} →
{abbreviation : String} →
{wall : Std.Time.TimeZone.StdWall} →
{utLocal : Std.Time.TimeZone.UTLocal} →
{identifier : String} →
{gmtOffset' : Std.Time.TimeZone.Offset} →
{isDst... | false |
RingCat.Colimits.Prequotient.zero.elim | Mathlib.Algebra.Category.Ring.Colimits | {J : Type v} →
[inst : CategoryTheory.SmallCategory J] →
{F : CategoryTheory.Functor J RingCat} →
{motive : RingCat.Colimits.Prequotient F → Sort u} →
(t : RingCat.Colimits.Prequotient F) → t.ctorIdx = 1 → motive RingCat.Colimits.Prequotient.zero → motive t | false |
CategoryTheory.Mon.uniqueHomToTrivial._proof_1 | Mathlib.CategoryTheory.Monoidal.Cartesian.Mon_ | ∀ {D : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} D] [inst_1 : CategoryTheory.SemiCartesianMonoidalCategory D]
(A : CategoryTheory.Mon D), CategoryTheory.IsMonHom (CategoryTheory.SemiCartesianMonoidalCategory.toUnit A.X) | false |
_private.Lean.Server.FileWorker.SignatureHelp.0.Lean.Server.FileWorker.SignatureHelp.CandidateKind.prio.match_1 | Lean.Server.FileWorker.SignatureHelp | (motive : Lean.Server.FileWorker.SignatureHelp.CandidateKind → Sort u_1) →
(x : Lean.Server.FileWorker.SignatureHelp.CandidateKind) →
(Unit → motive Lean.Server.FileWorker.SignatureHelp.CandidateKind.pipeArg) →
(Unit → motive Lean.Server.FileWorker.SignatureHelp.CandidateKind.termArg) →
(Unit → moti... | false |
IsAddTorsionFree.to_noZeroSMulDivisors_int | Mathlib.Algebra.NoZeroSMulDivisors.Defs | ∀ {G : Type u_3} [inst : AddGroup G] [IsAddTorsionFree G], NoZeroSMulDivisors ℤ G | true |
ULift.instCompleteSpace | Mathlib.Topology.UniformSpace.UniformEmbedding | ∀ {α : Type u} [inst : UniformSpace α] [CompleteSpace α], CompleteSpace (ULift.{u_1, u} α) | true |
Pi.seminormedCommRing._proof_15 | Mathlib.Analysis.Normed.Ring.Lemmas | ∀ {ι : Type u_1} {R : ι → Type u_2} [inst : Fintype ι] [inst_1 : (i : ι) → SeminormedCommRing (R i)] (n : ℕ)
(a : (i : ι) → R i), SubNegMonoid.zsmul (↑n.succ) a = SubNegMonoid.zsmul (↑n) a + a | false |
Mathlib.Tactic.BicategoryLike.NormalizedHom.consM | Mathlib.Tactic.CategoryTheory.Coherence.Datatypes | {m : Type → Type} →
[Monad m] →
[Mathlib.Tactic.BicategoryLike.MonadMor₁ m] →
Mathlib.Tactic.BicategoryLike.NormalizedHom →
Mathlib.Tactic.BicategoryLike.Atom₁ → m Mathlib.Tactic.BicategoryLike.NormalizedHom | true |
ENNReal.inv_sSup | Mathlib.Data.ENNReal.Inv | ∀ (s : Set ENNReal), (sSup s)⁻¹ = ⨅ a ∈ s, a⁻¹ | true |
Std.Internal.IO.Async.MonadAsync.mk | Std.Internal.Async.Basic | {t m : Type → Type} →
({α : Type} → m α → optParam Task.Priority Task.Priority.default → m (t α)) → Std.Internal.IO.Async.MonadAsync t m | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.