name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11.5k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
_private.Mathlib.Data.QPF.Multivariate.Basic.0.MvQPF.mem_supp._proof_1_1 | Mathlib.Data.QPF.Multivariate.Basic | ∀ {n : ℕ} {F : TypeVec.{u_1} n → Type u_2} [q : MvQPF F] {α : TypeVec.{u_1} n} (x : F α) (i : Fin2 n) (u : α i),
(∀ (a : (MvQPF.P F).A) (f : ((MvQPF.P F).B a).Arrow α), MvQPF.abs ⟨a, f⟩ = x → u ∈ f i '' Set.univ) →
∀ ⦃P : (i : Fin2 n) → α i → Prop⦄, MvFunctor.LiftP P x → P i u | null | false |
_private.Mathlib.Algebra.Lie.CartanExists.0.LieAlgebra.engel_isBot_of_isMin._simp_1_6 | Mathlib.Algebra.Lie.CartanExists | ∀ {R : Type u} {L : Type v} {M : Type w} [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : AddCommGroup M]
[inst_3 : Module R M] [inst_4 : LieRingModule L M] (p : Submodule R M)
(h : ∀ {x : L} {m : M}, m ∈ p.carrier → ⁅x, m⁆ ∈ p.carrier) {x : M},
(x ∈ { toSubmodule := p, lie_mem := h }) = (x ∈ p) | null | false |
Lean.Meta.SynthInstance.Waiter.recOn | Lean.Meta.SynthInstance | {motive : Lean.Meta.SynthInstance.Waiter → Sort u} →
(t : Lean.Meta.SynthInstance.Waiter) →
((a : Lean.Meta.SynthInstance.ConsumerNode) → motive (Lean.Meta.SynthInstance.Waiter.consumerNode a)) →
motive Lean.Meta.SynthInstance.Waiter.root → motive t | null | false |
groupCohomology | Mathlib.RepresentationTheory.Homological.GroupCohomology.Basic | {k G : Type u} → [inst : CommRing k] → [inst_1 : Group G] → Rep.{u, u, u} k G → ℕ → ModuleCat k | The group cohomology of a `k`-linear `G`-representation `A`, as the cohomology of its complex
of inhomogeneous cochains. | true |
Monoid.CoprodI.NeWord.inv._f | Mathlib.GroupTheory.CoprodI | {ι : Type u_1} →
{G : ι → Type u_4} →
[inst : (i : ι) → Group (G i)] →
(x x_1 : ι) →
(x_2 : Monoid.CoprodI.NeWord G x x_1) → Monoid.CoprodI.NeWord.below x_2 → Monoid.CoprodI.NeWord G x_1 x | null | false |
LieIdeal.lcs | Mathlib.Algebra.Lie.Nilpotent | {R : Type u_1} →
{L : Type u_2} →
[inst : CommRing R] →
[inst_1 : LieRing L] →
[inst_2 : LieAlgebra R L] →
LieIdeal R L →
(M : Type u_3) →
[inst_3 : AddCommGroup M] → [inst_4 : Module R M] → [inst_5 : LieRingModule L M] → ℕ → LieSubmodule R L M | Given a Lie module `M` over a Lie algebra `L` together with an ideal `I` of `L`, this is the
lower central series of `M` as an `I`-module. The advantage of using this definition instead of
`LieModule.lowerCentralSeries R I M` is that its terms are Lie submodules of `M` as an
`L`-module, rather than just as an `I`-modul... | true |
ExteriorAlgebra.ι | Mathlib.LinearAlgebra.ExteriorAlgebra.Basic | (R : Type u1) →
[inst : CommRing R] → {M : Type u2} → [inst_1 : AddCommGroup M] → [inst_2 : Module R M] → M →ₗ[R] ExteriorAlgebra R M | The canonical linear map `M →ₗ[R] ExteriorAlgebra R M`.
| true |
Set.mul_subset_range | Mathlib.Algebra.Group.Pointwise.Set.Basic | ∀ {F : Type u_1} {α : Type u_2} {β : Type u_3} [inst : Mul α] [inst_1 : Mul β] [inst_2 : FunLike F α β]
[MulHomClass F α β] (m : F) {s t : Set β}, s ⊆ Set.range ⇑m → t ⊆ Set.range ⇑m → s * t ⊆ Set.range ⇑m | null | true |
AddSubmonoid.leftNeg | Mathlib.GroupTheory.Submonoid.Inverses | {M : Type u_1} → [inst : AddMonoid M] → AddSubmonoid M → AddSubmonoid M | `S.leftNeg` is the additive submonoid containing all the left additive inverses of `S`. | true |
CategoryTheory.Bicategory.Adj.Hom.mk.inj | Mathlib.CategoryTheory.Bicategory.Adjunction.Adj | ∀ {B : Type u} {inst : CategoryTheory.Bicategory B} {a b : B} {l : a ⟶ b} {r : b ⟶ a}
{adj : CategoryTheory.Bicategory.Adjunction l r} {l_1 : a ⟶ b} {r_1 : b ⟶ a}
{adj_1 : CategoryTheory.Bicategory.Adjunction l_1 r_1},
{ l := l, r := r, adj := adj } = { l := l_1, r := r_1, adj := adj_1 } → l = l_1 ∧ r = r_1 ∧ adj... | null | true |
Matrix.projVandermonde_map | Mathlib.LinearAlgebra.Vandermonde | ∀ {R : Type u_1} [inst : CommRing R] {n : ℕ} {R' : Type u_3} [inst_1 : CommRing R'] (φ : R →+* R') (v w : Fin n → R),
(Matrix.projVandermonde (fun i => φ (v i)) fun i => φ (w i)) = φ.mapMatrix (Matrix.projVandermonde v w) | null | true |
CategoryTheory.Subobject.isoOfEqMk_inv | Mathlib.CategoryTheory.Subobject.Basic | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {B A : C} (X : CategoryTheory.Subobject B) (f : A ⟶ B)
[inst_1 : CategoryTheory.Mono f] (h : X = CategoryTheory.Subobject.mk f),
(X.isoOfEqMk f h).inv = CategoryTheory.Subobject.ofMkLE f X ⋯ | null | true |
PartialEquiv.coe_mk | Mathlib.Logic.Equiv.PartialEquiv | ∀ {α : Type u_1} {β : Type u_2} (f : α → β) (g : β → α) (s : Set α) (t : Set β) (ml : ∀ ⦃x : α⦄, x ∈ s → f x ∈ t)
(mr : ∀ ⦃x : β⦄, x ∈ t → g x ∈ s) (il : ∀ ⦃x : α⦄, x ∈ s → g (f x) = x) (ir : ∀ ⦃x : β⦄, x ∈ t → f (g x) = x),
↑{ toFun := f, invFun := g, source := s, target := t, map_source' := ml, map_target' := mr,... | null | true |
MeasureTheory.Measure.restrict_sub_eq_restrict_sub_restrict | Mathlib.MeasureTheory.Measure.Sub | ∀ {α : Type u_1} {m : MeasurableSpace α} {μ ν : MeasureTheory.Measure α} {s : Set α},
MeasurableSet s → (μ - ν).restrict s = μ.restrict s - ν.restrict s | null | true |
Finset.noncommProd_singleton | Mathlib.Data.Finset.NoncommProd | ∀ {α : Type u_3} {β : Type u_4} [inst : Monoid β] (a : α) (f : α → β), {a}.noncommProd f ⋯ = f a | null | true |
LinearMap.exact_zero_iff_surjective._simp_1 | Mathlib.Algebra.Exact.Basic | ∀ {R : Type u_1} [inst : Semiring R] {M : Type u_8} {N : Type u_9} (P : Type u_10) [inst_1 : AddCommGroup M]
[inst_2 : AddCommGroup N] [inst_3 : AddCommMonoid P] [inst_4 : Module R N] [inst_5 : Module R M] [inst_6 : Module R P]
(f : M →ₗ[R] N), Function.Exact ⇑f ⇑0 = Function.Surjective ⇑f | null | false |
Lean.Meta.Hint.Suggestion.casesOn | Lean.Meta.Hint | {motive : Lean.Meta.Hint.Suggestion → Sort u} →
(t : Lean.Meta.Hint.Suggestion) →
((toTryThisSuggestion : Lean.Meta.Tactic.TryThis.Suggestion) →
(span? previewSpan? : Option Lean.Syntax) →
(diffGranularity : Lean.Meta.Hint.DiffGranularity) →
motive
{ toTryThisSuggestion... | null | false |
_private.Mathlib.LinearAlgebra.Transvection.Basic.0.LinearEquiv.symm_mem_dilatransvections_iff._simp_1_1 | Mathlib.LinearAlgebra.Transvection.Basic | ∀ {G : Type u_1} [inst : SubNegMonoid G] (a b : G), a + -b = a - b | null | false |
CategoryTheory.SimplicialObject.σ_δ₀Iter_assoc | Mathlib.AlgebraicTopology.SimplicialObject.DeltaZeroIter | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] (X : CategoryTheory.SimplicialObject C) (i : ℕ) {n m : ℕ}
(j : Fin (m + 1)) (hi : autoParam (n + (i + 1) = m + 1) CategoryTheory.SimplicialObject.σ_δ₀Iter._auto_1),
autoParam (↑j ≤ i) CategoryTheory.SimplicialObject.σ_δ₀Iter._auto_3 →
∀ {Z : C} (h :... | null | true |
_private.Mathlib.Algebra.Homology.HomotopyCategory.MappingCocone.0.CochainComplex.mappingCocone.inr_v_descCochain_v._proof_1_1 | Mathlib.Algebra.Homology.HomotopyCategory.MappingCocone | ∀ (p q : ℤ), p + 1 = q → p = q + -1 | null | false |
_private.Mathlib.Data.List.Defs.0.List.headI.match_1.splitter | Mathlib.Data.List.Defs | {α : Type u_1} →
(motive : List α → Sort u_2) →
(x : List α) → (Unit → motive []) → ((a : α) → (tail : List α) → motive (a :: tail)) → motive x | null | true |
String.Pos.instLinearOrderPackage._proof_9 | Init.Data.String.OrderInstances | ∀ {s : String},
let this := inferInstance;
let this_1 := inferInstance;
let this_2 :=
let this := inferInstance;
let this_2 := inferInstance;
Max.leftLeaningOfLE s.Pos;
∀ (a b : s.Pos), a ⊔ b = if b ≤ a then a else b | null | false |
FirstOrder.Language.Theory.ModelsBoundedFormula.eq_1 | Mathlib.ModelTheory.Equivalence | ∀ {L : FirstOrder.Language} (T : L.Theory) {α : Type w} {n : ℕ} (φ : L.BoundedFormula α n),
T ⊨ᵇ φ = ∀ (M : T.ModelType) (v : α → ↑M) (xs : Fin n → ↑M), φ.Realize v xs | null | true |
Lean.Environment.getModuleIdxFor? | Lean.Environment | Lean.Environment → Lean.Name → Option Lean.ModuleIdx | null | true |
CategoryTheory.Grp.mk.injEq | Mathlib.CategoryTheory.Monoidal.Grp | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.CartesianMonoidalCategory C]
(X : C) [grp : CategoryTheory.GrpObj X] (X_1 : C) (grp_1 : CategoryTheory.GrpObj X_1),
({ X := X, grp := grp } = { X := X_1, grp := grp_1 }) = (X = X_1 ∧ grp ≍ grp_1) | null | true |
Complex.hasSum_deriv_of_summable_norm | Mathlib.Analysis.Complex.LocallyUniformLimit | ∀ {E : Type u_1} {ι : Type u_2} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℂ E] {U : Set ℂ} {z : ℂ}
{F : ι → ℂ → E} [CompleteSpace E] {u : ι → ℝ},
Summable u →
(∀ (i : ι), DifferentiableOn ℂ (F i) U) →
IsOpen U →
(∀ (i : ι), ∀ w ∈ U, ‖F i w‖ ≤ u i) →
z ∈ U → HasSum (fun i => der... | If the terms in the sum `∑' (i : ι), F i` are uniformly bounded on `U` by a
summable function, then the sum of `deriv F i` at a point in `U` is the derivative of the
sum. | true |
Submodule.exists_finset_of_mem_iSup | Mathlib.LinearAlgebra.Finsupp.Span | ∀ {R : Type u_1} {M : Type u_2} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] {ι : Type u_4}
(p : ι → Submodule R M) {m : M}, m ∈ ⨆ i, p i → ∃ s, m ∈ ⨆ i ∈ s, p i | null | true |
ContinuousMap.mem_setOfIdeal | Mathlib.Topology.ContinuousMap.Ideals | ∀ {X : Type u_1} {R : Type u_2} [inst : TopologicalSpace X] [inst_1 : Semiring R] [inst_2 : TopologicalSpace R]
[inst_3 : IsTopologicalSemiring R] {I : Ideal C(X, R)} {x : X}, x ∈ ContinuousMap.setOfIdeal I ↔ ∃ f ∈ I, f x ≠ 0 | null | true |
PowerSeries.idealX._proof_1 | Mathlib.RingTheory.LaurentSeries | ∀ (K : Type u_1) [inst : Field K], Ideal.span {PowerSeries.X} ≠ ⊥ | null | false |
Graph.deleteEdges_le._simp_1 | Mathlib.Combinatorics.Graph.Delete | ∀ {α : Type u_1} {β : Type u_2} {G : Graph α β} {F : Set β}, (G.deleteEdges F ≤ G) = True | null | false |
IsLeast.bddBelow | Mathlib.Order.Bounds.Basic | ∀ {α : Type u_1} [inst : Preorder α] {s : Set α} {a : α}, IsLeast s a → BddBelow s | If `s` has a least element, then it is bounded below. | true |
Algebra.GrothendieckGroup.instFG | Mathlib.GroupTheory.MonoidLocalization.Finite | ∀ {M : Type u_1} [inst : CommMonoid M] [Monoid.FG M], Monoid.FG (Algebra.GrothendieckGroup M) | The Grothendieck group of a finitely generated monoid is finitely generated. | true |
_private.Batteries.Data.List.Lemmas.0.List.getElem_idxOf_eq_idxOfNth_add._proof_1_30 | Batteries.Data.List.Lemmas | ∀ {α : Type u_1} {x : α} [inst : BEq α] (head : α) (tail : List α),
1 ≤ (List.filter (fun x_1 => x_1 == x) (head :: tail)).length →
0 < (List.filter (fun x_1 => x_1 == x) (head :: tail)).length | null | false |
Lean.Parser.Command.prefix.formatter | Lean.Parser.Syntax | Lean.PrettyPrinter.Formatter | null | true |
Std.DTreeMap.Const.minKey?_modify_eq_minKey? | Std.Data.DTreeMap.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {β : Type v} {t : Std.DTreeMap α (fun x => β) cmp} [Std.TransCmp cmp]
[Std.LawfulEqCmp cmp] {k : α} {f : β → β}, (Std.DTreeMap.Const.modify t k f).minKey? = t.minKey? | null | true |
Orthonormal.exists_hilbertBasis_extension | Mathlib.Analysis.InnerProductSpace.l2Space | ∀ {𝕜 : Type u_2} [inst : RCLike 𝕜] {E : Type u_3} [inst_1 : NormedAddCommGroup E] [inst_2 : InnerProductSpace 𝕜 E]
[CompleteSpace E] {s : Set E}, Orthonormal 𝕜 Subtype.val → ∃ w b, s ⊆ w ∧ ⇑b = Subtype.val | A Hilbert space admits a Hilbert basis extending a given orthonormal subset. | true |
Std.DHashMap.Raw.get?_inter | Std.Data.DHashMap.RawLemmas | ∀ {α : Type u} {β : α → Type v} [inst : BEq α] [inst_1 : Hashable α] {m₁ m₂ : Std.DHashMap.Raw α β}
[inst_2 : LawfulBEq α], m₁.WF → m₂.WF → ∀ {k : α}, (m₁ ∩ m₂).get? k = if k ∈ m₂ then m₁.get? k else none | null | true |
RootPairing.ofBilinear._proof_4 | Mathlib.LinearAlgebra.RootSystem.OfBilinear | ∀ {R : Type u_2} {M : Type u_1} [inst : CommRing R] [inst_1 : AddCommGroup M] [inst_2 : Module R M]
(B : M →ₗ[R] M →ₗ[R] R) (hSB : B.IsSymm) (x : ↑{x | B.IsReflective x}),
Function.RightInverse (fun y => ⟨(Module.reflection ⋯) ↑y, ⋯⟩) fun y => ⟨(Module.reflection ⋯) ↑y, ⋯⟩ | null | false |
snd_himp | Mathlib.Order.Heyting.Basic | ∀ {α : Type u_2} {β : Type u_3} [inst : HImp α] [inst_1 : HImp β] (a b : α × β), (a ⇨ b).2 = a.2 ⇨ b.2 | null | true |
Bimod.AssociatorBimod.homAux._proof_1 | Mathlib.CategoryTheory.Monoidal.Bimod | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.MonoidalCategory C]
[inst_2 : CategoryTheory.Limits.HasCoequalizers C]
[inst_3 :
∀ (X : C),
CategoryTheory.Limits.PreservesColimitsOfSize.{0, 0, u_1, u_1, u_2, u_2}
(CategoryTheory.MonoidalCategory.tensorLeft X... | null | false |
SSet.stdSimplex.finSuccAboveOrderIsoFinset._proof_7 | Mathlib.AlgebraicTopology.SimplicialSet.StdSimplex | ∀ {n : ℕ} (i : Fin (n + 2)),
Function.LeftInverse
(fun x =>
match x with
| ⟨x, hx⟩ => ⟨x, ⋯⟩)
fun x =>
match x with
| ⟨x, hx⟩ => ⟨x, ⋯⟩ | null | false |
MulSemiringActionHom.comp._proof_4 | Mathlib.GroupTheory.GroupAction.Hom | ∀ {M : Type u_6} [inst : Monoid M] {N : Type u_4} [inst_1 : Monoid N] {P : Type u_5} [inst_2 : Monoid P] {φ : M →* N}
{ψ : N →* P} {R : Type u_2} [inst_3 : Semiring R] [inst_4 : MulSemiringAction M R] {S : Type u_3}
[inst_5 : Semiring S] [inst_6 : MulSemiringAction N S] {T : Type u_1} [inst_7 : Semiring T]
[inst_... | null | false |
AddCon.mkAddHom_apply | Mathlib.GroupTheory.Congruence.Hom | ∀ {M : Type u_1} [inst : Add M] (c : AddCon M) (a : M), c.mkAddHom a = ↑a | null | true |
groupHomology.cyclesMk₂_eq._proof_2 | Mathlib.RepresentationTheory.Homological.GroupHomology.LowDegree | ∀ {k G : Type u_1} [inst : CommRing k] [inst_1 : Group G] (A : Rep.{u_1, u_1, u_1} k G)
(x : ↥(groupHomology.cycles₂ A)),
(CategoryTheory.ConcreteCategory.hom ((groupHomology.inhomogeneousChains A).d 2 1))
((CategoryTheory.ConcreteCategory.hom (groupHomology.chainsIso₂ A).inv) ↑x) =
0 | null | false |
LightCondSet.sequentialAdjunction | Mathlib.Condensed.Light.TopCatAdjunction | LightCondSet.lightCondSetToSequential ⊣ LightCondSet.sequentialToLightCondSet | The adjunction `lightCondSetToTopCat ⊣ topCatToLightCondSet` restricted to sequential
spaces.
| true |
ContinuousMap.instNonUnitalNormedRing._proof_3 | Mathlib.Topology.ContinuousMap.Compact | ∀ {α : Type u_1} [inst : TopologicalSpace α] [inst_1 : CompactSpace α] {R : Type u_2} [inst_2 : NonUnitalNormedRing R]
(a : C(α, R)), 0 * a = 0 | null | false |
UInt8.neg_mul | Init.Data.UInt.Lemmas | ∀ (a b : UInt8), -a * b = -(a * b) | null | true |
_private.Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Var.0.Std.Tactic.BVDecide.BVExpr.bitblast.blastVar.go_denote_eq._proof_1_3 | Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Var | ∀ {w : ℕ} (curr idx : ℕ), curr < idx → ¬curr + 1 ≤ idx → False | null | false |
CommSemiRingCat.instCreatesLimitSemiRingCatForget₂RingHomCarrierCarrier._proof_7 | Mathlib.Algebra.Category.Ring.Limits | ∀ {J : Type u_3} [inst : CategoryTheory.Category.{u_2, u_3} J] (F : CategoryTheory.Functor J CommSemiRingCat)
[inst_1 : Small.{u_1, max u_1 u_3} ↑(F.comp (CategoryTheory.forget CommSemiRingCat)).sections]
(s : CategoryTheory.Limits.Cone F),
EquivLike.coe
(equivShrink
↑((F.comp (CategoryTheory.forget... | null | false |
Std.Time.Year.instLTOffset._aux_1 | Std.Time.Date.Unit.Year | Std.Time.Year.Offset → Std.Time.Year.Offset → Prop | null | false |
RingNorm._sizeOf_1 | Mathlib.Analysis.Normed.Unbundled.RingSeminorm | {R : Type u_2} → {inst : NonUnitalNonAssocRing R} → [SizeOf R] → RingNorm R → ℕ | null | false |
unitInterval.tendsto_sigmoid_atBot | Mathlib.Analysis.SpecialFunctions.Sigmoid | Filter.Tendsto unitInterval.sigmoid Filter.atBot (nhds 0) | null | true |
_private.Mathlib.Tactic.ApplyAt.0.Mathlib.Tactic._aux_Mathlib_Tactic_ApplyAt___elabRules_Mathlib_Tactic_tacticApply_At__1.match_3 | Mathlib.Tactic.ApplyAt | (motive : Lean.Expr × Lean.BinderInfo → Sort u_1) →
(x : Lean.Expr × Lean.BinderInfo) → ((m : Lean.Expr) → (b : Lean.BinderInfo) → motive (m, b)) → motive x | null | false |
CategoryTheory.GradedObject.comapEquiv._proof_1 | Mathlib.CategoryTheory.GradedObject | ∀ {β γ : Type u_1} (e : β ≃ γ), (fun i => i) = ⇑e.symm ∘ ⇑e | null | false |
_private.Init.Data.Iterators.Lemmas.Combinators.FilterMap.0.Std.Iter.length_eq_match_step.match_1.eq_3 | Init.Data.Iterators.Lemmas.Combinators.FilterMap | ∀ {α β : Type u_1} (motive : Std.IterStep (Std.Iter β) β → Sort u_2)
(h_1 : (it' : Std.Iter β) → (out : β) → motive (Std.IterStep.yield it' out))
(h_2 : (it' : Std.Iter β) → motive (Std.IterStep.skip it')) (h_3 : Unit → motive Std.IterStep.done),
(match Std.IterStep.done with
| Std.IterStep.yield it' out => h... | null | true |
Simps.ParsedProjectionData.mk.injEq | Mathlib.Tactic.Simps.Basic | ∀ (strName : Lean.Name) (strStx : Lean.Syntax) (newName : Lean.Name) (newStx : Lean.Syntax) (isDefault isPrefix : Bool)
(expr? : Option Lean.Expr) (projNrs : Array ℕ) (isCustom : Bool) (strName_1 : Lean.Name) (strStx_1 : Lean.Syntax)
(newName_1 : Lean.Name) (newStx_1 : Lean.Syntax) (isDefault_1 isPrefix_1 : Bool) (... | null | true |
WeierstrassCurve.Affine.negY.eq_1 | Mathlib.AlgebraicGeometry.EllipticCurve.Affine.Formula | ∀ {R : Type r} [inst : CommRing R] (W' : WeierstrassCurve.Affine R) (x y : R), W'.negY x y = -y - W'.a₁ * x - W'.a₃ | null | true |
String.Slice.Pos.Splits.nextn | Init.Data.String.Lemmas.Splits | ∀ {s : String.Slice} {t₁ t₂ : String} {p : s.Pos},
p.Splits t₁ t₂ →
∀ (n : ℕ), (p.nextn n).Splits (t₁ ++ String.ofList (List.take n t₂.toList)) (String.ofList (List.drop n t₂.toList)) | null | true |
Lean.instInhabitedLevelMetavarDecl.default | Lean.MetavarContext | Lean.LevelMetavarDecl | null | true |
Lean.Try.Config.ctorIdx | Init.Try | Lean.Try.Config → ℕ | null | false |
_private.Mathlib.Algebra.Algebra.Spectrum.Basic.0.AlgHom.«_aux_Mathlib_Algebra_Algebra_Spectrum_Basic___macroRules__private_Mathlib_Algebra_Algebra_Spectrum_Basic_0_AlgHom_term↑ₐ_1_1» | Mathlib.Algebra.Algebra.Spectrum.Basic | Lean.Macro | null | false |
CategoryTheory.Functor.Fiber.inducedFunctor.congr_simp | Mathlib.CategoryTheory.FiberedCategory.Grothendieck | ∀ {𝒮 : Type u₁} {𝒳 : Type u₂} [inst : CategoryTheory.Category.{v₁, u₁} 𝒮] [inst_1 : CategoryTheory.Category.{v₂, u₂} 𝒳]
{p : CategoryTheory.Functor 𝒳 𝒮} {S : 𝒮} {C : Type u₃} [inst_2 : CategoryTheory.Category.{v₃, u₃} C]
{F F_1 : CategoryTheory.Functor C 𝒳} (e_F : F = F_1) (hF : F.comp p = (CategoryTheory.F... | null | true |
Complex.neg_iff | Mathlib.Analysis.Complex.Order | ∀ {z : ℂ}, z < 0 ↔ z.re < 0 ∧ z.im = 0 | null | true |
FirstOrder.Language.DirectLimit.lift._proof_4 | Mathlib.ModelTheory.DirectLimit | ∀ (L : FirstOrder.Language) (ι : Type u_2) [inst : Preorder ι] (G : ι → Type u_3) [inst_1 : (i : ι) → L.Structure (G i)]
(f : (i j : ι) → i ≤ j → L.Embedding (G i) (G j)) [inst_2 : IsDirectedOrder ι]
[inst_3 : DirectedSystem G fun i j h => ⇑(f i j h)] [inst_4 : Nonempty ι] {P : Type u_1} [inst_5 : L.Structure P]
... | null | false |
Std.ExtDTreeMap.get_union_of_not_mem_left | Std.Data.ExtDTreeMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t₁ t₂ : Std.ExtDTreeMap α β cmp} [inst : Std.TransCmp cmp]
[inst_1 : Std.LawfulEqCmp cmp] {k : α} (not_mem : k ∉ t₁) {h' : k ∈ t₁ ∪ t₂}, (t₁ ∪ t₂).get k h' = t₂.get k ⋯ | null | true |
IsOfFinAddOrder.nsmul | Mathlib.GroupTheory.OrderOfElement | ∀ {G : Type u_1} [inst : AddMonoid G] {a : G} {n : ℕ}, IsOfFinAddOrder a → IsOfFinAddOrder (n • a) | null | true |
_private.Mathlib.Order.Nucleus.0.Nucleus.instHImp._simp_4 | Mathlib.Order.Nucleus | ∀ {b : Prop} (α : Sort u_1) [i : Nonempty α], (∀ (a : α), b) = b | null | false |
eq_iff_eq_cancel_left | Mathlib.Logic.Basic | ∀ {α : Sort u_1} {b c : α}, (∀ {a : α}, a = b ↔ a = c) ↔ b = c | null | true |
_private.Mathlib.MeasureTheory.MeasurableSpace.Constructions.0.measurableAtom_eq_of_mem._simp_1_2 | Mathlib.MeasureTheory.MeasurableSpace.Constructions | ∀ {α : Type u} {ι : Sort v} {x : α} {s : ι → Set α}, (x ∈ ⋂ i, s i) = ∀ (i : ι), x ∈ s i | null | false |
_private.Init.Data.Array.Attach.0.Array.pmapImpl.eq_1 | Init.Data.Array.Attach | ∀ {α : Type u_1} {β : Type u_2} {P : α → Prop} (f : (a : α) → P a → β) (xs : Array α) (H : ∀ a ∈ xs, P a),
Array.pmapImpl f xs H =
Array.map
(fun x =>
match x with
| ⟨x, h'⟩ => f x h')
(xs.attachWith P H) | null | true |
CategoryTheory.FreeGroupoid.strictUniversalPropertyFixedTarget | Mathlib.CategoryTheory.Groupoid.FreeGroupoidOfCategory | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{G : Type u₁} →
[inst_1 : CategoryTheory.Groupoid G] →
CategoryTheory.Localization.StrictUniversalPropertyFixedTarget (CategoryTheory.FreeGroupoid.of C) ⊤ G | The universal property of the free groupoid. | true |
CategoryTheory.ShortComplex.HasRightHomology.hasKernel | Mathlib.Algebra.Homology.ShortComplex.RightHomology | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
(S : CategoryTheory.ShortComplex C) [S.HasRightHomology] [inst_3 : CategoryTheory.Limits.HasCokernel S.f],
CategoryTheory.Limits.HasKernel (CategoryTheory.Limits.cokernel.desc S.f S.g ⋯) | null | true |
MeasurableInf.measurable_const_inf._autoParam | Mathlib.MeasureTheory.Order.Lattice | Lean.Syntax | null | false |
Std.Internal.Do.WPMonad.mk._flat_ctor | Std.Internal.Do.WP.Basic | {m : Type u → Type v} →
{Pred : outParam (Type w)} →
{EPred : outParam (Type w')} →
[inst : Monad m] →
[inst_1 : Std.Internal.Do.Assertion Pred] →
[inst_2 : Std.Internal.Do.Assertion EPred] →
(∀ {α β : Type u}, Functor.mapConst = Functor.map ∘ Function.const β) →
... | null | false |
UInt8.ofNatLT_add | Init.Data.UInt.Lemmas | ∀ {a b : ℕ} (hab : a + b < 2 ^ 8), UInt8.ofNatLT (a + b) hab = UInt8.ofNatLT a ⋯ + UInt8.ofNatLT b ⋯ | null | true |
WithBot.subtypeOrderIso._proof_6 | Mathlib.Order.Hom.WithTopBot | ∀ {α : Type u_1} [inst : PartialOrder α] [inst_1 : OrderBot α] [inst_2 : DecidablePred fun x => x = ⊥],
(fun a => if h : a = ⊥ then ⊥ else ↑⟨a, h⟩) ((fun a => WithBot.unbotD ⊥ (WithBot.map Subtype.val a)) ⊥) = ⊥ | null | false |
SimpleGraph.completeAtomicBooleanAlgebra._proof_16 | Mathlib.Combinatorics.SimpleGraph.Basic | ∀ {V ι : Type u_1} {κ : ι → Type u_1} (f : (a : ι) → κ a → SimpleGraph V), ⨅ a, ⨆ b, f a b = ⨆ g, ⨅ a, f a (g a) | null | false |
IsPrimePow.ne_zero | Mathlib.Algebra.IsPrimePow | ∀ {R : Type u_1} [inst : CommMonoidWithZero R] [NoZeroDivisors R] {n : R}, IsPrimePow n → n ≠ 0 | null | true |
Std.ExtTreeMap.getKey?_congr | Std.Data.ExtTreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.ExtTreeMap α β cmp} [inst : Std.TransCmp cmp] {k k' : α},
cmp k k' = Ordering.eq → t.getKey? k = t.getKey? k' | null | true |
Lean.Meta.SynthInstance.Answer.mk | Lean.Meta.SynthInstance | Lean.Meta.AbstractMVarsResult → Lean.Expr → ℕ → Lean.Meta.SynthInstance.Answer | null | true |
ProbabilityTheory.«_aux_Mathlib_Probability_Kernel_Defs___macroRules_ProbabilityTheory_termKernel[_]___1» | Mathlib.Probability.Kernel.Defs | Lean.Macro | null | false |
_private.Lean.Meta.Tactic.Grind.Split.0.Lean.Meta.Grind.SplitCandidate.none.elim | Lean.Meta.Tactic.Grind.Split | {motive : Lean.Meta.Grind.SplitCandidate✝ → Sort u} →
(t : Lean.Meta.Grind.SplitCandidate✝) →
Lean.Meta.Grind.SplitCandidate.ctorIdx✝ t = 0 → motive Lean.Meta.Grind.SplitCandidate.none✝ → motive t | null | false |
Aesop.NormSeqResult.changed.injEq | Aesop.Search.Expansion.Norm | ∀ (goal : Lean.MVarId) (script : Array (Aesop.DisplayRuleName × Option (Array Aesop.Script.LazyStep)))
(goal_1 : Lean.MVarId) (script_1 : Array (Aesop.DisplayRuleName × Option (Array Aesop.Script.LazyStep))),
(Aesop.NormSeqResult.changed goal script = Aesop.NormSeqResult.changed goal_1 script_1) =
(goal = goal_... | null | true |
Std.Time.TimeZone.instInhabitedUTLocal | Std.Time.Zoned.ZoneRules | Inhabited Std.Time.TimeZone.UTLocal | null | true |
Aesop.instInhabitedNormalizationState | Aesop.Tree.Data | Inhabited Aesop.NormalizationState | null | true |
_private.Mathlib.Algebra.Group.Submonoid.Membership.0.Submonoid.mem_sup._simp_1_3 | Mathlib.Algebra.Group.Submonoid.Membership | ∀ {α : Sort u} {p : α → Prop} {q : { a // p a } → Prop}, (∃ x, q x) = ∃ a, ∃ (b : p a), q ⟨a, b⟩ | null | false |
Set.univ_pi_ite | Mathlib.Data.Set.Prod | ∀ {ι : Type u_1} {α : ι → Type u_2} (s : Set ι) [inst : DecidablePred fun x => x ∈ s] (t : (i : ι) → Set (α i)),
(Set.univ.pi fun i => if i ∈ s then t i else Set.univ) = s.pi t | null | true |
Lean.Parser.ParserState.stxStack._default | Lean.Parser.Types | Lean.Parser.SyntaxStack | null | false |
RingHom.FiniteType.comp | Mathlib.RingTheory.FiniteType | ∀ {A : Type u_1} {B : Type u_2} {C : Type u_3} [inst : CommRing A] [inst_1 : CommRing B] [inst_2 : CommRing C]
{g : B →+* C} {f : A →+* B}, g.FiniteType → f.FiniteType → (g.comp f).FiniteType | null | true |
CategoryTheory.Functor.additive_of_iso | Mathlib.CategoryTheory.Preadditive.AdditiveFunctor | ∀ {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.Preadditive C]
[inst_3 : CategoryTheory.Preadditive D] {F : CategoryTheory.Functor C D} [F.Additive] {G : CategoryTheory.Functor C D}
(e : F ≅ G), G.Additive | null | true |
Nat.totient_dvd_of_dvd | Mathlib.Data.Nat.Totient | ∀ {a b : ℕ}, a ∣ b → a.totient ∣ b.totient | null | true |
Unitization.real_cfcₙ_eq_cfc_inr | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Basic | ∀ {A : Type u_1} [inst : NonUnitalCStarAlgebra A] (a : A) (f : ℝ → ℝ),
autoParam (f 0 = 0) Unitization.real_cfcₙ_eq_cfc_inr._auto_1 → ↑(cfcₙ f a) = cfc f ↑a | note: the version for `ℝ≥0`, `Unitization.nnreal_cfcₙ_eq_cfc_inr`, can be found in
`Mathlib/Analysis/CStarAlgebra/ContinuousFunctionalCalculus/Order.lean` | true |
_private.Mathlib.Analysis.Seminorm.0.Seminorm.ball_smul_closedBall._simp_1_4 | Mathlib.Analysis.Seminorm | ∀ {E : Type u_5} [inst : SeminormedAddGroup E] {a : E} {r : ℝ}, (a ∈ Metric.ball 0 r) = (‖a‖ < r) | null | false |
Lean.Elab.Tactic.Do.SplitInfo.noConfusionType | Lean.Elab.Tactic.Do.VCGen.Split | Sort u → Lean.Elab.Tactic.Do.SplitInfo → Lean.Elab.Tactic.Do.SplitInfo → Sort u | null | false |
Lean.Elab.Do.ControlLifter.mk.noConfusion | Lean.Elab.Do.Control | {P : Sort u} →
{origCont : Lean.Elab.Do.DoElemCont} →
{returnBase? breakBase? continueBase? : Option Lean.Elab.Do.ControlStack} →
{pureBase : Lean.Elab.Do.ControlStack} →
{pureDeadCode : Lean.Elab.Do.CodeLiveness} →
{liftedDoBlockResultType : Lean.Expr} →
{origCont' : Lean.Elab... | null | false |
Lean.Meta.Grind.SavedState.recOn | Lean.Meta.Tactic.Grind.Types | {motive : Lean.Meta.Grind.SavedState → Sort u} →
(t : Lean.Meta.Grind.SavedState) →
((«meta» : Lean.Meta.SavedState) → (grind : Lean.Meta.Grind.State) → motive { «meta» := «meta», grind := grind }) →
motive t | null | false |
Mathlib.Tactic.Ring.Common.ExSum.recOn | Mathlib.Tactic.Ring.Common | {u : Lean.Level} →
{α : Q(Type u)} →
{BaseType : Q(«$α») → Type} →
{sα : Q(CommSemiring «$α»)} →
{motive_1 : (e : Q(«$α»)) → Mathlib.Tactic.Ring.Common.ExBase BaseType sα e → Sort u} →
{motive_2 : (e : Q(«$α»)) → Mathlib.Tactic.Ring.Common.ExProd BaseType sα e → Sort u} →
{moti... | null | false |
Submodule.orthogonalBilin._proof_2 | Mathlib.LinearAlgebra.SesquilinearForm.Basic | ∀ {R : Type u_1} {R₁ : Type u_2} {R₂ : Type u_3} {M : Type u_4} {M₁ : Type u_5} {M₂ : Type u_6} [inst : CommSemiring R]
[inst_1 : CommSemiring R₁] [inst_2 : CommSemiring R₂] [inst_3 : AddCommMonoid M] [inst_4 : Module R M]
[inst_5 : AddCommMonoid M₁] [inst_6 : Module R₁ M₁] [inst_7 : AddCommMonoid M₂] [inst_8 : Mod... | null | false |
Aesop.Options'.mk | Aesop.Options.Internal | Aesop.Options → Bool → Option ℕ → Aesop.Options' | null | true |
Lean.Elab.Tactic.RCases.RCasesPatt.ctorIdx | Lean.Elab.Tactic.RCases | Lean.Elab.Tactic.RCases.RCasesPatt → ℕ | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.