name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
Filter.tendsto_inv₀_cobounded | Mathlib.Analysis.Normed.Field.Lemmas | ∀ {α : Type u_1} [inst : NormedDivisionRing α], Filter.Tendsto Inv.inv (Bornology.cobounded α) (nhds 0) | null | true |
_private.Mathlib.Combinatorics.Matroid.Constructions.0.Matroid.restrict_empty._simp_1_1 | Mathlib.Combinatorics.Matroid.Constructions | ∀ {α : Type u_1} {M : Matroid α}, (M = Matroid.emptyOn α) = (M.E = ∅) | null | false |
_private.Mathlib.Topology.Algebra.OpenSubgroup.0.IsTopologicalAddGroup.exist_add_closure_nhds.match_1_1 | Mathlib.Topology.Algebra.OpenSubgroup | ∀ {G : Type u_1} [inst : TopologicalSpace G] [inst_1 : AddGroup G] {W : Set G} (x : Set G)
(motive : (∃ T ∈ nhds 0, x + T ⊆ W) → Prop) (x_1 : ∃ T ∈ nhds 0, x + T ⊆ W),
(∀ (T : Set G) (hT : T ∈ nhds 0) (mem : x + T ⊆ W), motive ⋯) → motive x_1 | null | false |
CategoryTheory.SingleFunctors.postcomp._proof_1 | Mathlib.CategoryTheory.Shift.SingleFunctors | ∀ {C : Type u_1} {D : Type u_6} {E : Type u_3} [inst : CategoryTheory.Category.{u_4, u_1} C]
[inst_1 : CategoryTheory.Category.{u_5, u_6} D] [inst_2 : CategoryTheory.Category.{u_2, u_3} E] {A : Type u_7}
[inst_3 : AddMonoid A] [inst_4 : CategoryTheory.HasShift D A] [inst_5 : CategoryTheory.HasShift E A]
(F : Cate... | null | false |
_private.Lean.Meta.Tactic.Grind.SimpUtil.0.Lean.Meta.Grind.reduceCtorEqCheap._sparseCasesOn_1 | Lean.Meta.Tactic.Grind.SimpUtil | {α : Type u} →
{motive : Option α → Sort u_1} →
(t : Option α) → ((val : α) → motive (some val)) → (Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t | null | false |
_private.Lean.Elab.Tactic.Conv.Basic.0.Lean.Elab.Tactic.Conv.evalConv._regBuiltin.Lean.Elab.Tactic.Conv.evalConv.declRange_3 | Lean.Elab.Tactic.Conv.Basic | IO Unit | null | false |
Module.restrictScalars | Mathlib.Algebra.Algebra.RestrictScalars | (R : Type u_1) →
(S : Type u_2) →
(M : Type u_3) →
[inst : Semiring S] →
[inst_1 : AddCommMonoid M] → [inst_2 : CommSemiring R] → [Algebra R S] → [Module S M] → Module R M | When `M` is a module over a ring `S`, and `S` is an algebra over `R`, then `M` inherits a
module structure over `R`. Not an instance because `S` cannot be inferred.
The preferred way of setting this up is `[Module R M] [Module S M] [IsScalarTower R S M]`.
| true |
_private.Mathlib.Tactic.Translate.Core.0.Mathlib.Tactic.Translate.copyInstanceAttribute.match_1 | Mathlib.Tactic.Translate.Core | (motive : Lean.ReducibilityStatus → Sort u_1) →
(__do_lift : Lean.ReducibilityStatus) →
(Unit → motive Lean.ReducibilityStatus.implicitReducible) →
(Unit → motive Lean.ReducibilityStatus.instanceReducible) →
((x : Lean.ReducibilityStatus) → motive x) → motive __do_lift | null | false |
_private.Mathlib.Order.CompactlyGenerated.Basic.0.iSupIndep_iff_supIndep.match_1_10 | Mathlib.Order.CompactlyGenerated.Basic | ∀ {α : Type u_1} [inst : CompleteLattice α] (s : Finset α) (a : α) (motive : ¬a = ⊥ ∧ a ∈ s → Prop)
(x : ¬a = ⊥ ∧ a ∈ s), (∀ (ha : ¬a = ⊥) (has : a ∈ s), motive ⋯) → motive x | null | false |
Hyperreal.inv_epsilon | Mathlib.Analysis.Real.Hyperreal | Hyperreal.epsilon⁻¹ = Hyperreal.omega | null | true |
instCompleteAtomicBooleanAlgebraLanguage._aux_14 | Mathlib.Computability.Language | (α : Type u_1) → Language α → Language α → Language α | null | false |
Vector.scanl | Batteries.Data.Vector.Basic | {β : Type u_1} → {α : Type u_2} → {n : ℕ} → (β → α → β) → β → Vector α n → Vector β (n + 1) | Fold a function `f` over the list from the left, returning the vector of partial results.
| true |
Hindman.FP_partition_regular | Mathlib.Combinatorics.Hindman | ∀ {M : Type u_1} [inst : Semigroup M] (a : Stream' M) (s : Set (Set M)),
s.Finite → (∀ (m : M), Hindman.FP a m → m ∈ ⋃₀ s) → ∃ c ∈ s, ∃ b, ∀ (m : M), Hindman.FP b m → m ∈ c | The strong form of **Hindman's theorem**: in any finite cover of an FP-set, one the parts
contains an FP-set. | true |
List.sum_flatten | Batteries.Data.List.Lemmas | ∀ {α : Type u_1} [inst : Add α] [inst_1 : Zero α] [Std.LawfulIdentity (fun x1 x2 => x1 + x2) 0]
[Std.Associative fun x1 x2 => x1 + x2] {l : List (List α)}, l.flatten.sum = (List.map List.sum l).sum | null | true |
ProbabilityTheory.IsMeasurableRatCDF.le_one | Mathlib.Probability.Kernel.Disintegration.MeasurableStieltjes | ∀ {α : Type u_1} [inst : MeasurableSpace α] {f : α → ℚ → ℝ},
ProbabilityTheory.IsMeasurableRatCDF f → ∀ (a : α) (q : ℚ), f a q ≤ 1 | null | true |
TopologicalSpace.Clopens.ctorIdx | Mathlib.Topology.Sets.Closeds | {α : Type u_4} → {inst : TopologicalSpace α} → TopologicalSpace.Clopens α → ℕ | null | false |
Fin.addCases._proof_2 | Init.Data.Fin.Lemmas | ∀ {m n : ℕ} (i : Fin (m + n)) (hi : ¬↑i < m), Fin.natAdd m (Fin.subNat m (Fin.cast ⋯ i) ⋯) = i | null | false |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.maxKey?_erase_le_maxKey?._simp_1_1 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {x : Ord α} {x_1 : BEq α} [Std.LawfulBEqOrd α] {a b : α}, (compare a b = Ordering.eq) = ((a == b) = true) | null | false |
_private.Mathlib.Data.List.Chain.0.List.exists_isChain_ne_nil_of_relationReflTransGen._proof_1_2 | Mathlib.Data.List.Chain | ∀ {α : Type u_1} {a : α} (l : List α), ¬a :: l = [] | null | false |
Lean.Compiler.LCNF.MonadCodeBind.mk.noConfusion | Lean.Compiler.LCNF.Bind | {m : Type → Type} →
{P : Sort u} →
{codeBind codeBind' :
{pu : Lean.Compiler.LCNF.Purity} →
Lean.Compiler.LCNF.Code pu →
(Lean.FVarId → m (Lean.Compiler.LCNF.Code pu)) → m (Lean.Compiler.LCNF.Code pu)} →
{ codeBind := codeBind } = { codeBind := codeBind' } → (codeBind ≍ codeBin... | null | false |
_private.Mathlib.RingTheory.WittVector.Frobenius.0.WittVector.frobenius._simp_2 | Mathlib.RingTheory.WittVector.Frobenius | ∀ {G : Type u_1} [inst : SubNegMonoid G] (a b : G), a + -b = a - b | null | false |
Lean.Meta.Grind.Arith.CommRing.EqCnstrProof.simp | Lean.Meta.Tactic.Grind.Arith.CommRing.Types | ℤ →
Lean.Meta.Grind.Arith.CommRing.EqCnstr →
ℤ → Lean.Grind.CommRing.Mon → Lean.Meta.Grind.Arith.CommRing.EqCnstr → Lean.Meta.Grind.Arith.CommRing.EqCnstrProof | null | true |
Std.Http.URIReference.parse? | Std.Http.Data.URI | String → Option Std.Http.URIReference | Attempts to parse a `URIReference` from the given string.
Accepts both complete URIs (with scheme) and relative references (without scheme), per RFC 3986
§4.1. Relative references include protocol-relative (`//host/path`), absolute-path (`/path`),
path-noscheme (`../other`, `foo/bar`), query-only (`?q=1`), fragment-on... | true |
_private.Mathlib.CategoryTheory.Limits.Preserves.Shapes.AbelianImages.0.CategoryTheory.Abelian.PreservesCoimage.hom_coimageImageComparison._simp_1_2 | Mathlib.CategoryTheory.Limits.Preserves.Shapes.AbelianImages | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y Z : C} (α : X ≅ Y) {f : X ⟶ Z} {g : Y ⟶ Z},
(CategoryTheory.CategoryStruct.comp α.hom g = f) = (g = CategoryTheory.CategoryStruct.comp α.inv f) | null | false |
_private.Mathlib.Topology.MetricSpace.Pseudo.Defs.0.Mathlib.Meta.Positivity.evalDist._proof_2 | Mathlib.Topology.MetricSpace.Pseudo.Defs | ∀ (α : Q(Type)) (val : Q(PartialOrder «$α»)) (__defeqres : PLift («$val» =Q Real.partialOrder)),
«$val» =Q Real.partialOrder | null | false |
ProofWidgets.instFromJsonRpcEncodablePacket._@.ProofWidgets.Component.HtmlDisplay.3039065598._hygCtx._hyg.10 | ProofWidgets.Component.HtmlDisplay | Lean.FromJson ProofWidgets.RpcEncodablePacket✝ | null | false |
_private.Mathlib.Topology.Algebra.IsUniformGroup.Defs.0.UniformContinuous.pow_const.match_1_1 | Mathlib.Topology.Algebra.IsUniformGroup.Defs | ∀ (motive : ℕ → Prop) (x : ℕ), (∀ (_ : Unit), motive 0) → (∀ (n : ℕ), motive n.succ) → motive x | null | false |
Std.Time.PlainDate.instToString | Std.Time.Format | ToString Std.Time.PlainDate | null | true |
_private.Mathlib.LinearAlgebra.Matrix.Charpoly.Basic.0.Matrix.charmatrix_mul_map_C_of_mul_eq_mul._simp_1_2 | Mathlib.LinearAlgebra.Matrix.Charpoly.Basic | ∀ {m : Type u_2} {n : Type u_3} {o : Type u_4} {α : Type v} {β : Type w} [inst : NonUnitalNonAssocSemiring α]
[inst_1 : Fintype n] {L : Matrix m n α} {M : Matrix n o α} [inst_2 : NonUnitalNonAssocSemiring β] {F : Type u_7}
[inst_3 : FunLike F α β] [NonUnitalRingHomClass F α β] {f : F}, L.map ⇑f * M.map ⇑f = (L * M)... | null | false |
_private.Mathlib.AlgebraicGeometry.EllipticCurve.Projective.Point.0.WeierstrassCurve.Projective.Point.toAffine_some._simp_1_3 | Mathlib.AlgebraicGeometry.EllipticCurve.Projective.Point | ∀ {R : Type r} (a b c : R), ![a, b, c] 2 = c | null | false |
AlgHom.equivFieldRange_apply_coe | Mathlib.FieldTheory.IntermediateField.Basic | ∀ {K : Type u_1} {L : Type u_2} {L' : Type u_3} [inst : Field K] [inst_1 : Field L] [inst_2 : Field L']
[inst_3 : Algebra K L] [inst_4 : Algebra K L'] (f : L →ₐ[K] L') (a : L), ↑(f.equivFieldRange a) = f a | null | true |
Monoid.CoprodI.NeWord.toList.induct_unfolding | Mathlib.GroupTheory.CoprodI | ∀ {ι : Type u_1} {M : ι → Type u_2} [inst : (i : ι) → Monoid (M i)]
(motive : {i j : ι} → Monoid.CoprodI.NeWord M i j → List ((i : ι) × M i) → Prop),
(∀ (i : ι) (x : M i) (a : x ≠ 1), motive (Monoid.CoprodI.NeWord.singleton x a) [⟨i, x⟩]) →
(∀ (x x_1 j k : ι) (w₁ : Monoid.CoprodI.NeWord M x j) (_hne : j ≠ k) (w... | null | true |
CategoryTheory.Limits.isEqualizerCompMono._proof_1 | Mathlib.CategoryTheory.Limits.Shapes.Equalizers | ∀ {C : Type u_2} {X Y : C} [inst : CategoryTheory.Category.{u_1, u_2} C] {f g : X ⟶ Y}
{c : CategoryTheory.Limits.Fork f g} {Z : C} (h : Y ⟶ Z),
CategoryTheory.CategoryStruct.comp c.ι (CategoryTheory.CategoryStruct.comp f h) =
CategoryTheory.CategoryStruct.comp c.ι (CategoryTheory.CategoryStruct.comp g h) | null | false |
MeasureTheory.Measure.instAdd._proof_2 | Mathlib.MeasureTheory.Measure.Module | ∀ {α : Type u_1} {mα : MeasurableSpace α} (μ₁ μ₂ : MeasureTheory.Measure α),
(μ₁.toOuterMeasure + μ₂.toOuterMeasure).trim ≤ μ₁.toOuterMeasure + μ₂.toOuterMeasure | null | false |
Filter.map₂ | Mathlib.Order.Filter.NAry | {α : Type u_1} → {β : Type u_3} → {γ : Type u_5} → (α → β → γ) → Filter α → Filter β → Filter γ | The image of a binary function `m : α → β → γ` as a function `Filter α → Filter β → Filter γ`.
Mathematically this should be thought of as the image of the corresponding function `α × β → γ`. | true |
Lean.Parser.Command.openRenaming | Lean.Parser.Command | Lean.Parser.Parser | null | true |
Order.IsPredLimit.isMin | Mathlib.Order.SuccPred.Limit | ∀ {α : Type u_1} {a : α} [inst : Preorder α] [inst_1 : PredOrder α], Order.IsPredLimit (Order.pred a) → IsMin a | null | true |
Real.norm_two | Mathlib.Analysis.Normed.Group.Real | ‖2‖ = 2 | null | true |
MeasureTheory.L2.innerProductSpace._private_1 | Mathlib.MeasureTheory.Function.L2Space | ∀ {α : Type u_1} {E : Type u_2} {𝕜 : Type u_3} [inst : RCLike 𝕜] {m : MeasurableSpace α} {μ : MeasureTheory.Measure α}
[inst_1 : NormedAddCommGroup E] [inst_2 : InnerProductSpace 𝕜 E] (f : ↥(MeasureTheory.Lp E 2 μ)),
‖f‖ ^ 2 = RCLike.re (inner 𝕜 f f) | null | false |
Std.Time.instHSubOffsetOffset_21 | Std.Time.Date.Basic | HSub Std.Time.Minute.Offset Std.Time.Hour.Offset Std.Time.Minute.Offset | null | true |
_private.Mathlib.Data.Finset.Basic.0.Finset.erase_insert._proof_1_1 | Mathlib.Data.Finset.Basic | ∀ {α : Type u_1} [inst : DecidableEq α] {a : α} {s : Finset α}, a ∉ s → (insert a s).erase a = s | null | false |
Turing.TM1to1.write._f | Mathlib.Computability.TuringMachine.PostTuringMachine | {Γ : Type u_1} →
{Λ : Type u_2} →
{σ : Type u_3} →
(x : List Bool) →
List.below (motive := fun x =>
Turing.TM1.Stmt Bool (Turing.TM1to1.Λ' Γ Λ σ) σ → Turing.TM1.Stmt Bool (Turing.TM1to1.Λ' Γ Λ σ) σ) x →
Turing.TM1.Stmt Bool (Turing.TM1to1.Λ' Γ Λ σ) σ → Turing.TM1.Stmt Bool (Tur... | null | false |
_private.Mathlib.Dynamics.Ergodic.Action.Regular.0.instErgodicSMulOfIsMulLeftInvariant._simp_1 | Mathlib.Dynamics.Ergodic.Action.Regular | ∀ {α : Type u_1} {l : Filter α} {s : Set α},
Filter.EventuallyEmptyOrUniv s l = ((∀ᶠ (x : α) in l, x ∈ s) ∨ ∀ᶠ (x : α) in l, x ∉ s) | null | false |
Lex.instLeftCancelSemigroup | Mathlib.Algebra.Order.Group.Synonym | {α : Type u_1} → [LeftCancelSemigroup α] → LeftCancelSemigroup (Lex α) | null | true |
Lean.JsonRpc.instBEqErrorCode.beq | Lean.Data.JsonRpc | Lean.JsonRpc.ErrorCode → Lean.JsonRpc.ErrorCode → Bool | null | true |
RBTree.RBNode.isOrdered._f | Batteries.Recycling.RBTree.Basic | {α : Type u_1} →
(α → α → Ordering) →
(t : RBTree.RBNode α) →
RBTree.RBNode.below (motive := fun t => Option α → Option α → Bool) t → Option α → Option α → Bool | null | false |
LinearMap.map_algebraMap_mul | Mathlib.Algebra.Algebra.Basic | ∀ {R : Type u_1} {A : Type u_2} {B : Type u_3} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Semiring B]
[inst_3 : Algebra R A] [inst_4 : Algebra R B] (f : A →ₗ[R] B) (a : A) (r : R),
f ((algebraMap R A) r * a) = (algebraMap R B) r * f a | An alternate statement of `LinearMap.map_smul` for when `algebraMap` is more convenient to
work with than `•`. | true |
MvQPF.WEquiv.casesOn | Mathlib.Data.QPF.Multivariate.Constructions.Fix | ∀ {n : ℕ} {F : TypeVec.{u} (n + 1) → Type u} [q : MvQPF F] {α : TypeVec.{u} n}
{motive : (a a_1 : (MvQPF.P F).W α) → MvQPF.WEquiv a a_1 → Prop} {a a_1 : (MvQPF.P F).W α} (t : MvQPF.WEquiv a a_1),
(∀ (a : (MvQPF.P F).A) (f' : ((MvQPF.P F).drop.B a).Arrow α) (f₀ f₁ : (MvQPF.P F).last.B a → (MvQPF.P F).W α)
(a_2... | null | false |
ByteArray.get_set_ne._proof_2 | Batteries.Data.ByteArray | ∀ {j : ℕ} (a : ByteArray) (i : Fin a.size), ↑i < a.size | null | false |
Turing.PartrecToTM2.Λ'.instDecidableEq._proof_69 | Mathlib.Computability.TuringMachine.ToPartrec | ∀ (b : Turing.PartrecToTM2.Λ') (f : Option Turing.PartrecToTM2.Γ' → Turing.PartrecToTM2.Λ'),
b = Turing.PartrecToTM2.Λ'.read f → Turing.PartrecToTM2.Λ'.read f = b | null | false |
BialgCat.of_comul | Mathlib.Algebra.Category.BialgCat.Basic | ∀ {R : Type u} [inst : CommRing R] {X : Type v} [inst_1 : Ring X] [inst_2 : Bialgebra R X],
CoalgebraStruct.comul = CoalgebraStruct.comul | null | true |
FirstOrder.Language.DefinableSet.instBooleanAlgebra._proof_1 | Mathlib.ModelTheory.Definability | ∀ {L : FirstOrder.Language} {M : Type u_2} [inst : L.Structure M] {A : Set M} {α : Type u_1},
Function.Injective fun a => ↑a | null | false |
String.Pos.Splits.exists_eq_singleton_append_of_ne_startPos | Init.Data.String.Lemmas.Splits | ∀ {t₁ t₂ s : String} {p : s.Pos} (hp : p ≠ s.startPos),
(p.prev hp).Splits t₁ t₂ → ∃ t₂', t₂ = String.singleton ((p.prev hp).get ⋯) ++ t₂' | null | true |
Equiv.Perm.subtypePerm_apply_pow_of_mem | Mathlib.GroupTheory.Perm.Cycle.Basic | ∀ {α : Type u_2} {g : Equiv.Perm α} {s : Finset α} (hs : ∀ (x : α), g x ∈ s ↔ x ∈ s) {n : ℕ} {x : α} (hx : x ∈ s),
↑((g.subtypePerm hs ^ n) ⟨x, hx⟩) = (g ^ n) x | null | true |
Lean.Parser.instInhabitedFirstTokens | Lean.Parser.Types | Inhabited Lean.Parser.FirstTokens | null | true |
AccPt | Mathlib.Topology.Defs.Filter | {X : Type u_1} → [TopologicalSpace X] → X → Filter X → Prop | A point `x` is an accumulation point of a filter `F` if `𝓝[≠] x ⊓ F ≠ ⊥`.
See also `ClusterPt`. | true |
Filter.HasBasis.uniformity_of_nhds_zero_neg_add_swapped | Mathlib.Topology.Algebra.IsUniformGroup.Defs | ∀ {α : Type u_1} [inst : UniformSpace α] [inst_1 : AddGroup α] [IsUniformAddGroup α] {ι : Sort u_3} {p : ι → Prop}
{U : ι → Set α}, (nhds 0).HasBasis p U → (uniformity α).HasBasis p fun i => {x | -x.2 + x.1 ∈ U i} | null | true |
WellFoundedLT.toWellFoundedRelation.eq_1 | Mathlib.Order.RelClasses | ∀ {α : Type u} [inst : LT α] [inst_1 : WellFoundedLT α],
WellFoundedLT.toWellFoundedRelation = WellFounded.toWellFoundedRelation fun x1 x2 => x1 < x2 | null | true |
OreLocalization.«_aux_Mathlib_GroupTheory_OreLocalization_Basic___macroRules_OreLocalization_term_-ₒ__1» | Mathlib.GroupTheory.OreLocalization.Basic | Lean.Macro | null | false |
_private.Lean.Elab.Task.0.Lean.Elab.Tactic.TacticM.asTask.match_1 | Lean.Elab.Task | {α : Type} →
(motive : α × Lean.Elab.Tactic.State → Sort u_1) →
(x : α × Lean.Elab.Tactic.State) → ((a : α) → (s : Lean.Elab.Tactic.State) → motive (a, s)) → motive x | null | false |
AlgHom.coe_prod | Mathlib.Algebra.Algebra.Prod | ∀ {R : Type u_1} {A : Type u_2} {B : Type u_3} {C : Type u_4} [inst : CommSemiring R] [inst_1 : Semiring A]
[inst_2 : Algebra R A] [inst_3 : Semiring B] [inst_4 : Algebra R B] [inst_5 : Semiring C] [inst_6 : Algebra R C]
(f : A →ₐ[R] B) (g : A →ₐ[R] C), ⇑(f.prod g) = Function.prod ⇑f ⇑g | null | true |
PiLp.norm_toLp_const | Mathlib.Analysis.Normed.Lp.PiLp | ∀ {p : ENNReal} {ι : Type u_2} [hp : Fact (1 ≤ p)] [inst : Fintype ι] {β : Type u_5}
[inst_1 : SeminormedAddCommGroup β],
p ≠ ⊤ → ∀ (b : β), ‖WithLp.toLp p (Function.const ι b)‖ = ↑↑(Fintype.card ι) ^ (1 / p).toReal * ‖b‖ | When `p = ∞`, this lemma does not hold without the additional assumption `Nonempty ι` because
the left-hand side simplifies to `0`, while the right-hand side simplifies to `‖b‖₊`. See
`PiLp.norm_toLp_const'` for a version which exchanges the hypothesis `p ≠ ∞` for
`Nonempty ι`. | true |
Lean.Meta.Grind.Arith.Cutsat.EqCnstrProof | Lean.Meta.Tactic.Grind.Arith.Cutsat.Types | Type | null | true |
_private.Mathlib.Algebra.Lie.Abelian.0.LieSubalgebra.isLieAbelian_lieSpan_iff._simp_1_3 | Mathlib.Algebra.Lie.Abelian | ∀ {α : Sort u} {p : α → Prop} {a1 a2 : { x // p x }}, (a1 = a2) = (↑a1 = ↑a2) | null | false |
RingHom.IsStableUnderBaseChange | Mathlib.RingTheory.RingHomProperties | ({R S : Type u} → [inst : CommRing R] → [inst_1 : CommRing S] → (R →+* S) → Prop) → Prop | A morphism property `P` is `IsStableUnderBaseChange` if `P(S →+* A)` implies
`P(B →+* A ⊗[S] B)`. | true |
Filter.coprod_inf_prod_le | Mathlib.Order.Filter.Prod | ∀ {α : Type u_1} {β : Type u_2} (f₁ f₂ : Filter α) (g₁ g₂ : Filter β), f₁.coprod g₁ ⊓ f₂ ×ˢ g₂ ≤ f₁ ×ˢ g₂ ⊔ f₂ ×ˢ g₁ | null | true |
Lean.Environment.Visibility.ofNat_ctorIdx | ImportGraph.Shake.Basic | ∀ (x : Lean.Environment.Visibility), Lean.Environment.Visibility.ofNat x.ctorIdx = x | null | true |
_private.Mathlib.Analysis.SpecialFunctions.ContinuousFunctionalCalculus.Rpow.IntegralRepresentation.0.Real.rpowIntegrand₀₁_eq_sub._proof_1_2 | Mathlib.Analysis.SpecialFunctions.ContinuousFunctionalCalculus.Rpow.IntegralRepresentation | ∀ {p : ℝ}, p ≠ 1 → ¬p + -1 = 0 | null | false |
HopfAlgebra.id_convMul_eq_one_of_adjoin_eq_top | Mathlib.RingTheory.HopfAlgebra.Convolution | ∀ {R : Type u_1} {A : Type u_2} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Bialgebra R A] {X : Set A}
(S : A →ₐ[R] Aᵐᵒᵖ),
Algebra.adjoin R X = ⊤ →
(∀ x ∈ X,
(LinearMap.mul' R A)
((LinearMap.lTensor A (↑(MulOpposite.opLinearEquiv R).symm ∘ₗ S.toLinearMap)) (CoalgebraStruct.comul ... | null | true |
Lean.Lsp.SignatureHelpTriggerKind.invoked.sizeOf_spec | Lean.Data.Lsp.LanguageFeatures | sizeOf Lean.Lsp.SignatureHelpTriggerKind.invoked = 1 | null | true |
PSigma.Lex.linearOrder._proof_1 | Mathlib.Order.PSigma | ∀ {ι : Type u_2} {α : ι → Type u_1} [inst : LinearOrder ι] [inst_1 : (i : ι) → LinearOrder (α i)]
(a b : Σₗ' (i : ι), α i), a ≤ b ∨ b ≤ a | null | false |
_private.Mathlib.Data.Set.Insert.0.Set.subset_pair_iff._proof_1_1 | Mathlib.Data.Set.Insert | ∀ {α : Type u_1} {s : Set α} {a b : α}, s ⊆ {a, b} ↔ ∀ x ∈ s, x = a ∨ x = b | null | false |
Order.Icc_subset_Ioc_pred_left | Mathlib.Order.SuccPred.Basic | ∀ {α : Type u_1} [inst : Preorder α] [inst_1 : PredOrder α] [NoMinOrder α] (a b : α),
Set.Icc b a ⊆ Set.Ioc (Order.pred b) a | null | true |
MeasCat | Mathlib.MeasureTheory.Category.MeasCat | Type (u + 1) | The category of measurable spaces and measurable functions. | true |
Lean.Meta.DefEqContext._sizeOf_1 | Lean.Meta.Basic | Lean.Meta.DefEqContext → ℕ | null | false |
Lean.OLeanLevel.server.elim | Lean.Environment | {motive : Lean.OLeanLevel → Sort u} → (t : Lean.OLeanLevel) → t.ctorIdx = 1 → motive Lean.OLeanLevel.server → motive t | null | false |
Std.ExtHashMap.getKey!_eq_of_contains | Std.Data.ExtHashMap.Lemmas | ∀ {α : Type u} {β : Type v} {x : BEq α} {x_1 : Hashable α} {m : Std.ExtHashMap α β} [inst : LawfulBEq α]
[inst_1 : Inhabited α] {k : α}, m.contains k = true → m.getKey! k = k | null | true |
TopologicalSpace.IsTopologicalBasis.recOn | Mathlib.Topology.Bases | {α : Type u} →
[t : TopologicalSpace α] →
{s : Set (Set α)} →
{motive : TopologicalSpace.IsTopologicalBasis s → Sort u_1} →
(t_1 : TopologicalSpace.IsTopologicalBasis s) →
((exists_subset_inter : ∀ t₁ ∈ s, ∀ t₂ ∈ s, ∀ x ∈ t₁ ∩ t₂, ∃ t₃ ∈ s, x ∈ t₃ ∧ t₃ ⊆ t₁ ∩ t₂) →
(sUnion_eq... | null | false |
_private.Init.Data.Array.Attach.0.Array.pmap_eq_self._simp_1_1 | Init.Data.Array.Attach | ∀ {α : Type u_1} {l : List α} {p : α → Prop} {hp : ∀ a ∈ l, p a} {f : (a : α) → p a → α},
(List.pmap f l hp = l) = ∀ (a : α) (h : a ∈ l), f a ⋯ = a | null | false |
Lean.Elab.Do.ReturnCont.mk.injEq | Lean.Elab.Do.Basic | ∀ (resultType : Lean.Expr) (k : Lean.Expr → Lean.Elab.Do.DoElabM Lean.Expr) (resultType_1 : Lean.Expr)
(k_1 : Lean.Expr → Lean.Elab.Do.DoElabM Lean.Expr),
({ resultType := resultType, k := k } = { resultType := resultType_1, k := k_1 }) =
(resultType = resultType_1 ∧ k = k_1) | null | true |
CategoryTheory.shiftEquiv'._proof_1 | Mathlib.CategoryTheory.Shift.Basic | ∀ {A : Type u_1} [inst : AddGroup A] (i j : A), i + j = 0 → j + i = 0 | null | false |
CategoryTheory.MonoidalCategory.MonoidalRightAction.monoidalOppositeRightAction_actionHomLeft | Mathlib.CategoryTheory.Monoidal.Action.Opposites | ∀ (C : Type u_1) (D : Type u_2) [inst : CategoryTheory.Category.{v_1, u_1} C]
[inst_1 : CategoryTheory.MonoidalCategory C] [inst_2 : CategoryTheory.Category.{v_2, u_2} D]
[inst_3 : CategoryTheory.MonoidalCategory.MonoidalLeftAction C D] {d d' : D} (f : d ⟶ d') (c : Cᴹᵒᵖ),
CategoryTheory.MonoidalCategory.MonoidalR... | null | true |
LinearMap.applyₗ._proof_1 | Mathlib.Algebra.Module.LinearMap.End | ∀ {R : Type u_1} {M₂ : Type u_2} [inst : CommSemiring R] [inst_1 : AddCommMonoid M₂] [inst_2 : Module R M₂],
SMulCommClass R R M₂ | null | false |
Subgroup.top_lowerCentralSeries_prod | Mathlib.GroupTheory.Nilpotent | ∀ {G₁ : Type u_2} {G₂ : Type u_3} [inst : Group G₁] [inst_1 : Group G₂] (n : ℕ),
⊤.lowerCentralSeries n = (⊤.lowerCentralSeries n).prod (⊤.lowerCentralSeries n) | The ⊤-specialization of `lowerCentralSeries_prod`. | true |
Representation.ofMulActionSelfAsModuleEquiv._proof_4 | Mathlib.RepresentationTheory.Basic | ∀ {k : Type u_1} {G : Type u_2} [inst : CommSemiring k] [inst_1 : Group G]
(x y : (Representation.ofMulAction k G G).asModule),
(Representation.ofMulAction k G G).asModuleEquiv.toAddEquiv.toFun (x + y) =
(Representation.ofMulAction k G G).asModuleEquiv.toAddEquiv.toFun x +
(Representation.ofMulAction k G ... | null | false |
AlgebraicGeometry.Scheme.Cover.copy._proof_2 | Mathlib.AlgebraicGeometry.Cover.MorphismProperty | ∀ {P : CategoryTheory.MorphismProperty AlgebraicGeometry.Scheme} [P.RespectsIso] {X : AlgebraicGeometry.Scheme}
(𝒰 : AlgebraicGeometry.Scheme.Cover (AlgebraicGeometry.Scheme.precoverage P) X) (J : Type u_2)
(obj : J → AlgebraicGeometry.Scheme) (map : (i : J) → obj i ⟶ X) (e₁ : J ≃ 𝒰.I₀) (e₂ : (i : J) → obj i ≅ 𝒰... | null | false |
Std.DHashMap.Const.get!_union_of_not_mem_right | Std.Data.DHashMap.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {β : Type v} {m₁ m₂ : Std.DHashMap α fun x => β} [EquivBEq α]
[LawfulHashable α] [inst : Inhabited β] {k : α},
k ∉ m₂ → Std.DHashMap.Const.get! (m₁.union m₂) k = Std.DHashMap.Const.get! m₁ k | null | true |
absConvexHull_nonempty | Mathlib.Analysis.LocallyConvex.AbsConvex | ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : SeminormedRing 𝕜] [inst_1 : SMul 𝕜 E] [inst_2 : AddCommMonoid E]
[inst_3 : PartialOrder 𝕜] {s : Set E}, ((absConvexHull 𝕜) s).Nonempty ↔ s.Nonempty | null | true |
ZFSet.vonNeumann_inj._simp_1 | Mathlib.SetTheory.ZFC.VonNeumann | ∀ {a b : Ordinal.{u}}, (ZFSet.vonNeumann a = ZFSet.vonNeumann b) = (a = b) | null | false |
CategoryTheory.PreOneHypercover.map_Y | Mathlib.CategoryTheory.Sites.Continuous | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
{X : C} (E : CategoryTheory.PreOneHypercover X) (F : CategoryTheory.Functor C D)
(x x_1 : (CategoryTheory.PreZeroHypercover.map F E.toPreZeroHypercover).I₀) (j : E.I₁ x x_1),
(E.map F).Y j = F.o... | null | true |
Polynomial.roots_expand_map_frobenius | Mathlib.FieldTheory.Perfect | ∀ {R : Type u_1} [inst : CommRing R] [inst_1 : IsDomain R] {p : ℕ} [inst_2 : ExpChar R p] {f : Polynomial R}
[PerfectRing R p], Multiset.map (⇑(frobenius R p)) ((Polynomial.expand R p) f).roots = p • f.roots | null | true |
_private.Std.Do.Triple.SpecLemmas.0.Std.Do.Spec.restoreM_ReaderT._simp_1_1 | Std.Do.Triple.SpecLemmas | ∀ {m : Type u → Type v} {ps : Std.Do.PostShape} [inst : Std.Do.WP m ps] {α : Type u} {x : m α} {P : Std.Do.Assertion ps}
{Q : Std.Do.PostCond α ps}, ⦃P⦄ x ⦃Q⦄ = (P ⊢ₛ (Std.Do.wp x).apply Q) | null | false |
Denumerable.lower_raise._f | Mathlib.Logic.Equiv.Multiset | ∀ (x : List ℕ) (f : List.below (motive := fun x => ∀ (x_1 : ℕ), Denumerable.lower (Denumerable.raise x x_1) x_1 = x) x)
(x_1 : ℕ), Denumerable.lower (Denumerable.raise x x_1) x_1 = x | null | false |
Ideal.instIsTwoSided | Mathlib.RingTheory.Ideal.Defs | ∀ {α : Type u} [inst : CommSemiring α] (I : Ideal α), I.IsTwoSided | null | true |
_private.Mathlib.AlgebraicTopology.DoldKan.NCompGamma.0.Fin.succ.match_1.splitter | Mathlib.AlgebraicTopology.DoldKan.NCompGamma | {n : ℕ} → (motive : Fin n → Sort u_1) → (x : Fin n) → ((i : ℕ) → (h : i < n) → motive ⟨i, h⟩) → motive x | null | true |
CategoryTheory.Quiv.lift_map | Mathlib.CategoryTheory.Category.Quiv | ∀ {V : Type u} [inst : Quiver V] {C : Type u₁} [inst_1 : CategoryTheory.Category.{v₁, u₁} C] (F : V ⥤q C)
{X Y : CategoryTheory.Paths V} (f : X ⟶ Y),
(CategoryTheory.Quiv.lift F).map f = CategoryTheory.composePath (F.mapPath f) | null | true |
Std.DTreeMap.Raw.Equiv.maxKey!_eq | Std.Data.DTreeMap.Raw.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t₁ t₂ : Std.DTreeMap.Raw α β cmp} [Std.TransCmp cmp]
[inst : Inhabited α], t₁.WF → t₂.WF → t₁.Equiv t₂ → t₁.maxKey! = t₂.maxKey! | null | true |
CochainComplex.shiftFunctorAdd'._proof_3 | Mathlib.Algebra.Homology.HomotopyCategory.Shift | ∀ (C : Type u_2) [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Preadditive C] (n₁ n₂ n₁₂ : ℤ)
(h : n₁ + n₂ = n₁₂) (K : CochainComplex C ℤ) (x x_1 : ℤ),
CategoryTheory.CategoryStruct.comp (K.shiftFunctorObjXIso n₁₂ x (x + n₂ + n₁) ⋯).hom
((((CochainComplex.shiftFunctor C n₁).comp (Coch... | null | false |
Tactic.ComputeAsymptotics.MultiseriesExpansion.one_approximates | Mathlib.Tactic.ComputeAsymptotics.Multiseries.Basic | ∀ {basis : Tactic.ComputeAsymptotics.Basis},
Tactic.ComputeAsymptotics.WellFormedBasis basis → Tactic.ComputeAsymptotics.MultiseriesExpansion.one.Approximates | `one` approximates the unit function. | true |
FredholmDecomposition.rec | Mathlib.Analysis.Normed.Operator.Fredholm.Basic | {𝕜 : Type u_1} →
{E : Type u_2} →
[inst : NontriviallyNormedField 𝕜] →
[inst_1 : AddCommGroup E] →
[inst_2 : Module 𝕜 E] →
[inst_3 : TopologicalSpace E] →
{motive : FredholmDecomposition 𝕜 E → Sort u} →
((X₀ X₁ : Submodule 𝕜 E) →
(isTopCompl... | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.