name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11.5k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
continuousAt_sign_of_neg | Mathlib.Topology.Instances.Sign | ∀ {α : Type u_1} [inst : Zero α] [inst_1 : TopologicalSpace α] [inst_2 : PartialOrder α] [inst_3 : DecidableLT α]
[OrderTopology α] {a : α}, a < 0 → ContinuousAt (⇑SignType.sign) a | null | true |
CategoryTheory.PreZeroHypercover.equivOfIso_symm_apply | Mathlib.CategoryTheory.Sites.Hypercover.Zero | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {S : C} {E F : CategoryTheory.PreZeroHypercover S} (e : E ≅ F)
(i : F.I₀), (CategoryTheory.PreZeroHypercover.equivOfIso e).symm i = e.inv.s₀ i | null | true |
Lean.Meta.Grind.AttrKind.cases.sizeOf_spec | Lean.Meta.Tactic.Grind.Attr | ∀ (eager : Bool), sizeOf (Lean.Meta.Grind.AttrKind.cases eager) = 1 + sizeOf eager | null | true |
_private.Lean.Meta.Tactic.Induction.0.Lean.MVarId.induction.match_1 | Lean.Meta.Tactic.Induction | (motive : Option ℕ → Sort u_1) →
(paramPos? : Option ℕ) → (Unit → motive none) → ((paramPos : ℕ) → motive (some paramPos)) → motive paramPos? | null | false |
PNat.XgcdType | Mathlib.Data.PNat.Xgcd | Type | A term of `XgcdType` is a system of six naturals. They should
be thought of as representing the matrix
`[[w, x], [y, z]] = [[wp + 1, x], [y, zp + 1]]`
together with the vector `[a, b] = [ap + 1, bp + 1]`.
| true |
Valuation.is_topological_valuation | Mathlib.Topology.Algebra.ValuativeRel.ValuativeTopology | ∀ {R : Type u_1} [inst : Ring R] [inst_1 : ValuativeRel R] {Γ₀ : Type u_3} [inst_2 : LinearOrderedCommGroupWithZero Γ₀]
[inst_3 : TopologicalSpace R] (v : Valuation R Γ₀) [v.Compatible] [IsValuativeTopology R] (s : Set R),
s ∈ nhds 0 ↔ ∃ γ, {x | v.restrict x < ↑γ} ⊆ s | **Alias** of `Valuation.mem_nhds_zero_iff`. | true |
IsApproximateAddSubgroup.addSubgroup | Mathlib.Combinatorics.Additive.ApproximateSubgroup | ∀ {G : Type u_1} [inst : AddGroup G] {S : Type u_2} [inst_1 : SetLike S G] [AddSubgroupClass S G] {H : S},
IsApproximateAddSubgroup 1 ↑H | null | true |
CommBialgCat.isoMk | Mathlib.Algebra.Category.CommBialgCat | {R : Type u} →
[inst : CommRing R] →
{X Y : Type v} →
{x : CommRing X} → {x_1 : CommRing Y} → {x_2 : Bialgebra R X} → {x_3 : Bialgebra R Y} → (X ≃ₐc[R] Y) → (↧X ≅ ↧Y) | Build an isomorphism in the category `CommBialgCat R` from a `BialgEquiv` between
`Bialgebra`s. | true |
_private.Mathlib.Probability.BrownianMotion.Basic.0.ProbabilityTheory.IsBrownianReal.neg._simp_1_2 | Mathlib.Probability.BrownianMotion.Basic | ∀ {G : Type u_1} {α : Type u_3} [inst : TopologicalSpace G] [inst_1 : InvolutiveNeg G] [ContinuousNeg G]
[inst_3 : TopologicalSpace α] {f : α → G}, Continuous (-f) = Continuous f | null | false |
Convex.uniformContinuous_gauge | Mathlib.Analysis.Convex.Gauge | ∀ {E : Type u_2} [inst : SeminormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] {s : Set E},
Convex ℝ s → s ∈ nhds 0 → UniformContinuous (gauge s) | null | true |
AlgebraicClosure.instCommRing._proof_34 | Mathlib.FieldTheory.IsAlgClosed.AlgebraicClosure | ∀ (k : Type u_1) [inst : Field k],
autoParam (∀ (a b : AlgebraicClosure k), a - b = a + -b) SubNegMonoid.sub_eq_add_neg._autoParam | null | false |
RestrictedProduct.continuous_eval | Mathlib.Topology.Algebra.RestrictedProduct.TopologicalSpace | ∀ {ι : Type u_1} {R : ι → Type u_2} {A : (i : ι) → Set (R i)} {𝓕 : Filter ι} [inst : (i : ι) → TopologicalSpace (R i)]
(i : ι), Continuous fun x => x i | null | true |
Std.DTreeMap.Raw.size_le_size_insertIfNew | Std.Data.DTreeMap.Raw.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t : Std.DTreeMap.Raw α β cmp} [Std.TransCmp cmp],
t.WF → ∀ {k : α} {v : β k}, t.size ≤ (t.insertIfNew k v).size | null | true |
Std.HashMap.values | Std.Data.HashMap.Basic | {α : Type u} → {β : Type v} → {x : BEq α} → {x_1 : Hashable α} → Std.HashMap α β → List β | Returns a list of all values present in the hash map in some order. | true |
DFinsupp.subset_support_tsub | Mathlib.Data.DFinsupp.Order | ∀ {ι : Type u_1} {α : ι → Type u_2} [inst : (i : ι) → AddCommMonoid (α i)] [inst_1 : (i : ι) → PartialOrder (α i)]
[inst_2 : ∀ (i : ι), CanonicallyOrderedAdd (α i)] [inst_3 : (i : ι) → Sub (α i)]
[inst_4 : ∀ (i : ι), OrderedSub (α i)] {f g : Π₀ (i : ι), α i} [inst_5 : DecidableEq ι]
[inst_6 : (i : ι) → (x : α i) ... | null | true |
Std.HashMap.Raw.getKey?_filter_key | Std.Data.HashMap.RawLemmas | ∀ {α : Type u} {β : Type v} [inst : BEq α] [inst_1 : Hashable α] {m : Std.HashMap.Raw α β} [EquivBEq α]
[LawfulHashable α] {f : α → Bool} {k : α},
m.WF → (Std.HashMap.Raw.filter (fun k x => f k) m).getKey? k = Option.filter f (m.getKey? k) | null | true |
IsLocallyConstant.iff_is_const | Mathlib.Topology.LocallyConstant.Basic | ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] [PreconnectedSpace X] {f : X → Y},
IsLocallyConstant f ↔ ∀ (x y : X), f x = f y | null | true |
Tactic.ComputeAsymptotics.MultiseriesExpansion.const.eq_2 | Mathlib.Tactic.ComputeAsymptotics.Multiseries.Basic | ∀ (c : ℝ) (basis_hd : ℝ → ℝ) (basis_tl : List (ℝ → ℝ)),
Tactic.ComputeAsymptotics.MultiseriesExpansion.const (basis_hd :: basis_tl) c =
Tactic.ComputeAsymptotics.MultiseriesExpansion.mk
(Tactic.ComputeAsymptotics.MultiseriesExpansion.Multiseries.const basis_hd basis_tl c) fun x => c | null | true |
_private.Mathlib.Data.List.Basic.0.List.foldr_ext._simp_1_4 | Mathlib.Data.List.Basic | ∀ {α : Sort u_1} {p : α → Prop} {a' : α}, (∀ (a : α), a = a' → p a) = p a' | null | false |
VSub.casesOn | Mathlib.Algebra.Notation.Defs | {G : Type u_1} →
{P : Type u_2} →
{motive : VSub G P → Sort u} → (t : VSub G P) → ((vsub : P → P → G) → motive { vsub := vsub }) → motive t | null | false |
Lex.instDivisionRing._proof_3 | Mathlib.Algebra.Field.Basic | ∀ {K : Type u_1} [inst : DivisionRing K],
autoParam (∀ (n : ℕ) (a : Lex K), a ^ ↑n.succ = a ^ ↑n * a) DivInvMonoid.zpow_succ'._autoParam | null | false |
OrderIso.setOfPredMaximalIsoSetOfPredMinimal._proof_3 | Mathlib.Order.Minimal | ∀ {α : Type u_1} {β : Type u_2} [inst : Preorder α] [inst_1 : Preorder β] {s : Set α} {t : Set β} (f : ↑s ≃o (↑t)ᵒᵈ)
(x : ↑{x | Minimal (fun x => x ∈ t) (OrderDual.ofDual x)}),
↑(f.symm.mapSetOfPredMaximal x) ∈ {x | Maximal (fun x => x ∈ s) x} | null | false |
Lean.Lsp.FileChangeType.ctorIdx | Lean.Data.Lsp.Workspace | Lean.Lsp.FileChangeType → ℕ | null | false |
Std.Sat.AIG.Decl.rec | Std.Sat.AIG.Basic | {α : Type} →
{motive : Std.Sat.AIG.Decl α → Sort u} →
motive Std.Sat.AIG.Decl.false →
((idx : α) → motive (Std.Sat.AIG.Decl.atom idx)) →
((l r : Std.Sat.AIG.Fanin) → motive (Std.Sat.AIG.Decl.gate l r)) → (t : Std.Sat.AIG.Decl α) → motive t | null | false |
Module.Basis.ofSplitExact._proof_3 | Mathlib.LinearAlgebra.Basis.Exact | ∀ {R : Type u_2} {M : Type u_4} {K : Type u_6} {P : Type u_3} [inst : Ring R] [inst_1 : AddCommGroup M]
[inst_2 : AddCommGroup K] [inst_3 : AddCommGroup P] [inst_4 : Module R M] [inst_5 : Module R K] [inst_6 : Module R P]
{f : K →ₗ[R] M} {g : M →ₗ[R] P} {s : M →ₗ[R] K},
s ∘ₗ f = LinearMap.id →
Function.Exact ... | null | false |
Std.IterM.mk.injEq | Init.Data.Iterators.Basic | ∀ {α : Type w} {m : Type w → Type w'} {β : Type w} (internalState internalState_1 : α),
({ internalState := internalState } = { internalState := internalState_1 }) = (internalState = internalState_1) | null | true |
_private.Lean.Server.Completion.CompletionInfoSelection.0.Lean.Server.Completion.findCompletionInfosAt.containsHoverPos | Lean.Server.Completion.CompletionInfoSelection | String.Pos.Raw → Lean.Elab.CompletionInfo → Bool | null | true |
SeparationQuotient.instNormedAlgebra._proof_2 | Mathlib.Analysis.Normed.Module.Basic | ∀ (𝕜 : Type u_1) {E : Type u_2} [inst : NormedField 𝕜] [inst_1 : SeminormedRing E] [inst_2 : NormedAlgebra 𝕜 E],
ContinuousConstSMul 𝕜 E | null | false |
Equiv.funSplitAt_apply | Mathlib.Logic.Equiv.Prod | ∀ {α : Type u_9} [inst : DecidableEq α] (i : α) (β : Type u_10) (f : (j : α) → (fun a => β) j),
(Equiv.funSplitAt i β) f = (f i, fun j => f ↑j) | null | true |
CategoryTheory.WithInitial.mapId | Mathlib.CategoryTheory.WithTerminal.Basic | (C : Type u_1) →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
CategoryTheory.WithInitial.map (CategoryTheory.Functor.id C) ≅
CategoryTheory.Functor.id (CategoryTheory.WithInitial C) | A natural isomorphism between the functor `map (𝟭 C)` and `𝟭 (WithInitial C)`. | true |
Lean.Elab.Command.Scope.varUIds._default | Lean.Elab.Command.Scope | Array Lean.Name | null | false |
CategoryTheory.ShortComplex.Splitting.ofIso._proof_2 | Mathlib.Algebra.Homology.ShortComplex.Exact | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Preadditive C]
{S₁ S₂ : CategoryTheory.ShortComplex C} (s : S₁.Splitting) (e : S₁ ≅ S₂),
CategoryTheory.CategoryStruct.comp
(CategoryTheory.CategoryStruct.comp e.inv.τ₃ (CategoryTheory.CategoryStruct.comp s.s e.hom.τ₂)) S₂... | null | false |
_private.Mathlib.Topology.Irreducible.0.isPreirreducible_iff_subset_closure_inter_open.match_1_1 | Mathlib.Topology.Irreducible | ∀ {X : Type u_1} (S a : Set X) (motive : (S ∩ a).Nonempty → Prop) (h : (S ∩ a).Nonempty),
(∀ (p : X) (pS : p ∈ S) (pa : p ∈ a), motive ⋯) → motive h | null | false |
_private.Mathlib.Order.Filter.ListTraverse.0.Filter.mem_traverse.match_1_7 | Mathlib.Order.Filter.ListTraverse | ∀ {α β γ : Type u_1} {f : β → Filter α} {s : γ → Set α},
let funType_1 := fun x x_1 x_2 => traverse s x_1 ∈ traverse f x;
∀
(motive :
(x : List β) → (x_1 : List γ) → (x_2 : List.Forall₂ (fun b c => s c ∈ f b) x x_1) → List.Forall₂.below x_2 → Prop)
(x : List β) (x_1 : List γ) (x_2 : List.Forall₂ (fun ... | null | false |
HurwitzZeta.completedHurwitzZetaEven_zero | Mathlib.NumberTheory.LSeries.RiemannZeta | ∀ (s : ℂ), HurwitzZeta.completedHurwitzZetaEven 0 s = completedRiemannZeta s | null | true |
Lean.Grind.Ring.neg_zsmul | Init.Grind.Ring.Basic | ∀ {α : Type u} [self : Lean.Grind.Ring α] (i : ℤ) (a : α), -i • a = -(i • a) | Scalar multiplication by the negation of an integer is the negation of scalar multiplication by that integer. | true |
Submodule.localized'_inf | Mathlib.Algebra.Module.LocalizedModule.Submodule | ∀ {R : Type u_1} (S : Type u_2) {M : Type u_3} {N : Type u_4} [inst : CommSemiring R] [inst_1 : CommSemiring S]
[inst_2 : AddCommMonoid M] [inst_3 : AddCommMonoid N] [inst_4 : Module R M] [inst_5 : Module R N]
[inst_6 : Algebra R S] [inst_7 : Module S N] [inst_8 : IsScalarTower R S N] (p : Submonoid R)
[inst_9 : ... | null | true |
Turing.PartrecToTM2.K'.elim_update_aux | Mathlib.Computability.TuringMachine.ToPartrec | ∀ {a b c d c' : List Turing.PartrecToTM2.Γ'},
Function.update (Turing.PartrecToTM2.K'.elim a b c d) Turing.PartrecToTM2.K'.aux c' =
Turing.PartrecToTM2.K'.elim a b c' d | null | true |
Lean.Meta.RefinedDiscrTree.Key.labelledStar.noConfusion | Mathlib.Lean.Meta.RefinedDiscrTree.Basic | {P : Sort u} →
{id id' : ℕ} →
Lean.Meta.RefinedDiscrTree.Key.labelledStar id = Lean.Meta.RefinedDiscrTree.Key.labelledStar id' →
(id = id' → P) → P | null | false |
PolynormableSpace.withSeminorms | Mathlib.Analysis.LocallyConvex.WithSeminorms | ∀ (𝕜 : Type u_2) (E : Type u_6) [inst : NormedField 𝕜] [inst_1 : AddCommGroup E] [inst_2 : Module 𝕜 E]
[inst_3 : TopologicalSpace E] [PolynormableSpace 𝕜 E], WithSeminorms fun p => ↑p | null | true |
MeasureTheory.exp_llr | Mathlib.MeasureTheory.Measure.LogLikelihoodRatio | ∀ {α : Type u_1} {mα : MeasurableSpace α} (μ ν : MeasureTheory.Measure α) [MeasureTheory.SigmaFinite μ],
(fun x => Real.exp (MeasureTheory.llr μ ν x)) =ᵐ[ν] fun x => if μ.rnDeriv ν x = 0 then 1 else (μ.rnDeriv ν x).toReal | null | true |
ProbabilityTheory.mgf_sum_of_identDistrib₀ | Mathlib.Probability.Moments.Basic | ∀ {Ω : Type u_1} {ι : Type u_2} {m : MeasurableSpace Ω} {μ : MeasureTheory.Measure Ω} {X : ι → Ω → ℝ} {s : Finset ι}
{j : ι},
(∀ (i : ι), AEMeasurable (X i) μ) →
ProbabilityTheory.iIndepFun X μ →
(∀ i ∈ s, ∀ j ∈ s, ProbabilityTheory.IdentDistrib (X i) (X j) μ μ) →
j ∈ s → ∀ (t : ℝ), ProbabilityThe... | null | true |
HasFDerivAt.sub_const | Mathlib.Analysis.Calculus.FDeriv.Add | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {F : Type u_3} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {f : E → F}
{f' : E →L[𝕜] F} {x : E} (c : F), HasFDerivAt f f' x → HasFDerivAt (fun x => f x - c) f' x | **Alias** of the reverse direction of `hasFDerivAt_sub_const_iff`. | true |
Finset.singleton_subset_coe._simp_1 | Mathlib.Data.Finset.Insert | ∀ {α : Type u_1} {s : Finset α} {a : α}, ({a} ⊆ ↑s) = ({a} ⊆ s) | null | false |
Lean.Meta.Match.Overlaps.mk.sizeOf_spec | Lean.Meta.Match.MatcherInfo | ∀ (map : Std.HashMap ℕ (Std.TreeSet ℕ compare)), sizeOf { map := map } = 1 + sizeOf map | null | true |
CategoryTheory.Limits.BinaryBicone.inlCokernelCofork_π | Mathlib.CategoryTheory.Limits.Shapes.BinaryBiproducts | ∀ {C : Type uC} [inst : CategoryTheory.Category.{uC', uC} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{X Y : C} (c : CategoryTheory.Limits.BinaryBicone X Y), CategoryTheory.Limits.Cofork.π c.inlCokernelCofork = c.snd | null | true |
Mathlib.Meta.NormNum.isNat_abs_nonneg | Mathlib.Tactic.NormNum.Abs | ∀ {α : Type u_1} [inst : Ring α] [inst_1 : Lattice α] [IsOrderedRing α] {a : α} {na : ℕ},
Mathlib.Meta.NormNum.IsNat a na → Mathlib.Meta.NormNum.IsNat |a| na | null | true |
CategoryTheory.Presheaf.IsSheaf.amalgamate_map_assoc | Mathlib.CategoryTheory.Sites.Sheaf | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {J : CategoryTheory.GrothendieckTopology C} {A : Type u₂}
[inst_1 : CategoryTheory.Category.{v₂, u₂} A] {E : A} {X : C} {P : CategoryTheory.Functor Cᵒᵖ A}
(hP : CategoryTheory.Presheaf.IsSheaf J P) (S : J.Cover X) (x : (I : S.Arrow) → E ⟶ P.obj (Opposite.o... | null | true |
_private.Lean.Compiler.LCNF.PublicDeclsExt.0.Lean.Compiler.LCNF.initFn._@.Lean.Compiler.LCNF.PublicDeclsExt.3962556520._hygCtx._hyg.2 | Lean.Compiler.LCNF.PublicDeclsExt | IO (Lean.EnvExtension (List Lean.Name × Lean.NameSet)) | null | false |
_private.Init.Data.Range.Polymorphic.UInt.0.UInt64.instLawfulUpwardEnumerableLE._simp_1 | Init.Data.Range.Polymorphic.UInt | ∀ {x y : BitVec 64},
Std.PRange.UpwardEnumerable.LE { toBitVec := x } { toBitVec := y } = Std.PRange.UpwardEnumerable.LE x y | null | false |
Pi.single_mul_left_apply | Mathlib.Algebra.GroupWithZero.Pi | ∀ {ι : Type u_1} {α : ι → Type u_2} [inst : (i : ι) → MulZeroClass (α i)] [inst_1 : DecidableEq ι] (i j : ι) (a : α i)
(f : (i : ι) → α i), Pi.single i (a * f i) j = Pi.single i a j * f j | null | true |
Aesop.BuilderName.forward | Aesop.Rule.Name | Aesop.BuilderName | null | true |
Mathlib.Tactic.ClickSuggestions.Premise.fvar | Mathlib.Tactic.ClickSuggestions.Util | Lean.FVarId → Mathlib.Tactic.ClickSuggestions.Premise | A free variable. | true |
instHasCountableLimitsLightCondMod | Mathlib.Condensed.Light.Limits | ∀ (R : Type u) [inst : Ring R], CategoryTheory.Limits.HasCountableLimits (LightCondMod R) | null | true |
Lean.Parser.Term.doContinue | Lean.Parser.Do | Lean.Parser.Parser | `continue` skips to the next iteration of the surrounding `for` loop. | true |
AddCommGroupWithOne.toNatCast | Mathlib.Data.Int.Cast.Defs | {R : Type u} → [self : AddCommGroupWithOne R] → NatCast R | null | true |
_private.Lean.Elab.Term.TermElabM.0.Lean.Elab.Term.useImplicitLambda | Lean.Elab.Term.TermElabM | Lean.Syntax → Option Lean.Expr → Lean.Elab.TermElabM Lean.Elab.Term.UseImplicitLambdaResult | Return normalized expected type if it is of the form `{a : α} → β` or `[a : α] → β` and
`blockImplicitLambda stx` is not true, else return `none`.
Remark: implicit lambdas are not triggered by the strict implicit binder annotation `{{a : α}} → β`
| true |
Affine.Simplex.centroid_reindex | 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] {m n : ℕ} (s : Affine.Simplex k P m) (e : Fin (m + 1) ≃ Fin (n + 1)),
(s.reindex e).centroid = s.centroid | null | true |
ENNReal.div_lt_top | Mathlib.Basic.ENNReal.Inv | ∀ {x y : ENNReal}, x ≠ ⊤ → y ≠ 0 → x / y < ⊤ | null | true |
List.length_range | Init.Data.List.Range | ∀ {n : ℕ}, (List.range n).length = n | null | true |
CategoryTheory.Monad.ForgetCreatesColimits.coconePoint._proof_1 | Mathlib.CategoryTheory.Monad.Limits | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {T : CategoryTheory.Monad C} {J : Type u_4}
[inst_1 : CategoryTheory.Category.{u_3, u_4} J] {D : CategoryTheory.Functor J T.Algebra}
(c : CategoryTheory.Limits.Cocone (D.comp T.forget)) (t : CategoryTheory.Limits.IsColimit c)
[inst_2 : CategoryTheory.... | null | false |
MeasureTheory.integral_union_eq_left_of_forall | Mathlib.MeasureTheory.Integral.Bochner.Set | ∀ {X : Type u_1} {E : Type u_3} {mX : MeasurableSpace X} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E]
{s t : Set X} {μ : MeasureTheory.Measure X} {f : X → E},
MeasurableSet t → (∀ x ∈ t, f x = 0) → ∫ (x : X) in s ∪ t, f x ∂μ = ∫ (x : X) in s, f x ∂μ | null | true |
ModuleCat.linearOverField._proof_2 | Mathlib.Algebra.Category.ModuleCat.Algebra | ∀ {k : Type u_3} [inst : Field k] {A : Type u_2} [inst_1 : Ring A] [inst_2 : Algebra k A] (X Y Z : ModuleCat A) (r : k)
(f : X ⟶ Y) (g : Y ⟶ Z), CategoryTheory.CategoryStruct.comp (r • f) g = r • CategoryTheory.CategoryStruct.comp f g | null | false |
HomotopyCategory.Plus.instCommShiftPlusQuotientInt | Mathlib.Algebra.Homology.HomotopyCategory.Plus | (C : Type u_1) →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
[inst_1 : CategoryTheory.Preadditive C] → (HomotopyCategory.Plus.quotient C).CommShift ℤ | null | true |
Lean.Meta.CaseValuesSubgoal.noConfusion | Lean.Meta.Match.CaseValues | {P : Sort u} → {t t' : Lean.Meta.CaseValuesSubgoal} → t = t' → Lean.Meta.CaseValuesSubgoal.noConfusionType P t t' | null | false |
HahnSeries.SummableFamily.embDomain_of_notMem_range | Mathlib.RingTheory.HahnSeries.Summable | ∀ {Γ : Type u_1} {R : Type u_3} {α : Type u_5} {β : Type u_6} [inst : PartialOrder Γ] [inst_1 : AddCommMonoid R]
(s : HahnSeries.SummableFamily Γ R α) (f : α ↪ β) {b : β}, b ∉ Set.range ⇑f → (s.embDomain f) b = 0 | null | true |
TensorPower.gmonoid._proof_1 | Mathlib.LinearAlgebra.TensorPower.Basic | ∀ {R : Type u_1} {M : Type u_2} [inst : CommSemiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
(a : GradedMonoid fun i => TensorPower R i M), GradedMonoid.mk (0 • a.fst) (GradedMonoid.GMonoid.gnpowRec 0 a.snd) = 1 | null | false |
prime_mul_isUnit | Mathlib.Algebra.Prime.Lemmas | ∀ {M : Type u_1} [inst : CommMonoidWithZero M] {x y : M}, IsUnit x → (Prime (y * x) ↔ Prime y) | null | true |
ContDiffWithinAt.sinh | Mathlib.Analysis.SpecialFunctions.Trigonometric.DerivHyp | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] {f : E → ℝ} {x : E} {s : Set E}
{n : WithTop ℕ∞}, ContDiffWithinAt ℝ n f s x → ContDiffWithinAt ℝ n (fun x => Real.sinh (f x)) s x | null | true |
_private.Init.Data.Vector.Count.0.Vector.count_le_count_map._simp_1_1 | Init.Data.Vector.Count | ∀ {α : Type u_2} [inst : BEq α] [LawfulBEq α] {β : Type u_1} [inst_2 : BEq β] [LawfulBEq β] {xs : Array α} {f : α → β}
{x : α}, (Array.count x xs ≤ Array.count (f x) (Array.map f xs)) = True | null | false |
_private.Lean.Meta.Tactic.Grind.Theorems.0.Lean.Meta.Grind.Theorems.mk.noConfusion | Lean.Meta.Tactic.Grind.Theorems | {α : Type} →
{P : Sort u} →
{smap : Lean.PHashMap Lean.Name (List α)} →
{origins erased : Lean.PHashSet Lean.Meta.Grind.Origin} →
{omap : Lean.PHashMap Lean.Meta.Grind.Origin (List α)} →
{smap' : Lean.PHashMap Lean.Name (List α)} →
{origins' erased' : Lean.PHashSet Lean.Meta.Gr... | null | false |
AlgebraicGeometry.ProjIsoSpecTopComponent.ToSpec.carrier._proof_2 | Mathlib.AlgebraicGeometry.ProjectiveSpectrum.Scheme | ∀ {A : Type u_1} {σ : Type u_2} [inst : CommRing A] [inst_1 : SetLike σ A] [inst_2 : AddSubgroupClass σ A] {𝒜 : ℕ → σ}
[inst_3 : GradedRing 𝒜] {f : A},
Topology.IsOpenEmbedding ⇑(CategoryTheory.ConcreteCategory.hom (ProjectiveSpectrum.basicOpen 𝒜 f).inclusion') | null | false |
CategoryTheory.RigidCategory.ctorIdx | Mathlib.CategoryTheory.Monoidal.Rigid.Basic | {C : Type u} →
{inst : CategoryTheory.Category.{v, u} C} →
{inst_1 : CategoryTheory.MonoidalCategory C} → CategoryTheory.RigidCategory C → ℕ | null | false |
Array.all_subtype | Init.Data.Array.Attach | ∀ {α : Type u_1} {stop : ℕ} {p : α → Prop} {xs : Array { x // p x }} {f : { x // p x } → Bool} {g : α → Bool},
(∀ (x : α) (h : p x), f ⟨x, h⟩ = g x) → stop = xs.size → xs.all f 0 stop = xs.unattach.all g | null | true |
List.hasDecEq.match_1 | Init.Prelude | {α : Type u_1} →
(as bs : List α) →
(motive : Decidable (as = bs) → Sort u_2) →
(x : Decidable (as = bs)) →
((habs : as = bs) → motive (isTrue habs)) → ((nabs : ¬as = bs) → motive (isFalse nabs)) → motive x | null | false |
gcd_comm | Mathlib.Algebra.GCDMonoid.Basic | ∀ {α : Type u_1} [inst : CommMonoidWithZero α] [inst_1 : NormalizedGCDMonoid α] (a b : α), gcd a b = gcd b a | null | true |
_private.Lean.Meta.LitValues.0.Lean.Meta.getFloat32Lit? | Lean.Meta.LitValues | Lean.Expr → Lean.MetaM (Option Float32) | Recognize a non-negated `Float32` literal: an `OfScientific` or `OfNat` application. | true |
Lean.Elab.Tactic.TacticParsedSnapshotInner.mk.injEq | Lean.Elab.Term.TermElabM | ∀ {α : Type} (toSnapshot : Lean.Language.Snapshot) (stx : Lean.Syntax) (inner? : Option (Lean.Language.SnapshotTask α))
(finished : Lean.Language.SnapshotTask Lean.Elab.Tactic.TacticFinishedSnapshot)
(toSnapshot_1 : Lean.Language.Snapshot) (stx_1 : Lean.Syntax) (inner?_1 : Option (Lean.Language.SnapshotTask α))
(... | null | true |
Finset.fold_const | Mathlib.Data.Finset.Fold | ∀ {α : Type u_1} {β : Type u_2} {op : β → β → β} [hc : Std.Commutative op] [ha : Std.Associative op] {b : β}
{s : Finset α} [hd : Decidable (s = ∅)] (c : β),
op c (op b c) = op b c → Finset.fold op b (fun x => c) s = if s = ∅ then b else op b c | null | true |
MonadStateOf.casesOn | Init.Prelude | {σ : Type u} →
{m : Type u → Type v} →
{motive : MonadStateOf σ m → Sort u_1} →
(t : MonadStateOf σ m) →
((get : m σ) →
(set : σ → m PUnit.{u + 1}) →
(modifyGet : {α : Type u} → (σ → α × σ) → m α) →
motive { get := get, set := set, modifyGet := modifyGet }) ... | null | false |
BoxIntegral.Box.instPartialOrder._proof_3 | Mathlib.Analysis.BoxIntegral.Box.Basic | ∀ {ι : Type u_1} (a b : BoxIntegral.Box ι), a < b ↔ a ≤ b ∧ ¬b ≤ a | null | false |
_private.Std.Data.ExtDHashMap.Lemmas.0.Std.ExtDHashMap.map_eq_empty_iff._simp_1_2 | Std.Data.ExtDHashMap.Lemmas | ∀ {a b : Bool}, (a = true ↔ b = true) = (a = b) | null | false |
SemimoduleCat.hom_ext_iff | Mathlib.Algebra.Category.ModuleCat.Semi | ∀ {R : Type u} [inst : Semiring R] {M N : SemimoduleCat R} {f g : M ⟶ N},
f = g ↔ SemimoduleCat.Hom.hom f = SemimoduleCat.Hom.hom g | null | true |
Real.pow_mul_norm_iteratedFDeriv_fourier_le | Mathlib.Analysis.Fourier.FourierTransformDeriv | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℂ E] {V : Type u_2} [inst_2 : NormedAddCommGroup V]
[inst_3 : InnerProductSpace ℝ V] [inst_4 : FiniteDimensional ℝ V] [inst_5 : MeasurableSpace V] [inst_6 : BorelSpace V]
{f : V → E} {K N : ℕ∞},
ContDiff ℝ (↑N) f →
(∀ (k n : ℕ),
↑k ≤... | One can bound `‖w‖^n * ‖D^k (𝓕 f) w‖` in terms of integrals of the derivatives of `f` (or order
at most `n`) multiplied by powers of `v` (of order at most `k`). | true |
ContinuousMap.toAEEqFunAddHom._proof_1 | Mathlib.MeasureTheory.Function.AEEqFun | ∀ {α : Type u_1} {β : Type u_2} [inst : MeasurableSpace α] (μ : MeasureTheory.Measure α) [inst_1 : TopologicalSpace α]
[inst_2 : BorelSpace α] [inst_3 : TopologicalSpace β] [inst_4 : SecondCountableTopologyEither α β]
[inst_5 : TopologicalSpace.PseudoMetrizableSpace β] [inst_6 : AddGroup β] [inst_7 : IsTopologicalA... | null | false |
_private.Std.Data.Iterators.Lemmas.Consumers.Monadic.Collect.0.Std.IterM.Equiv.toList_eq._simp_1_1 | Std.Data.Iterators.Lemmas.Consumers.Monadic.Collect | ∀ {α β : Type w} {m : Type w → Type w'} [inst : Monad m] [LawfulMonad m] [inst_2 : Std.Iterator α m β]
[Std.Iterators.Finite α m] {it : Std.IterM m β}, it.toList = List.reverse <$> it.toListRev | null | false |
groupHomology.H0π_comp_H0Iso_hom_assoc | Mathlib.RepresentationTheory.Homological.GroupHomology.LowDegree | ∀ {k G : Type u} [inst : CommRing k] [inst_1 : Group G] (A : Rep.{u, u, u} k G) {Z : ModuleCat k}
(h : (Rep.coinvariantsFunctor k G).obj A ⟶ Z),
CategoryTheory.CategoryStruct.comp (groupHomology.H0π A)
(CategoryTheory.CategoryStruct.comp (groupHomology.H0Iso A).hom h) =
CategoryTheory.CategoryStruct.comp ... | null | true |
_private.Lean.Meta.Tactic.Simp.BuiltinSimprocs.String.0._regBuiltin.String.reduceOfList.declare_18._@.Lean.Meta.Tactic.Simp.BuiltinSimprocs.String.3166094940._hygCtx._hyg.20 | Lean.Meta.Tactic.Simp.BuiltinSimprocs.String | IO Unit | null | false |
SzemerediRegularity.increment.congr_simp | Mathlib.Combinatorics.SimpleGraph.Regularity.Increment | ∀ {α : Type u_1} [inst : Fintype α] [inst_1 : DecidableEq α] {P P_1 : Finpartition Finset.univ} (e_P : P = P_1)
(hP : P.IsEquipartition) (G G_1 : SimpleGraph α),
G = G_1 →
∀ {inst_2 : DecidableRel G.Adj} [inst_3 : DecidableRel G_1.Adj] (ε ε_1 : ℝ),
ε = ε_1 → SzemerediRegularity.increment hP G ε = Szemered... | null | true |
Finsupp.support_indicator_subset | Mathlib.Data.Finsupp.Indicator | ∀ {ι : Type u_1} {α : Type u_2} [inst : Zero α] (s : Finset ι) (f : (i : ι) → i ∈ s → α),
(Finsupp.indicator s f).support ⊆ s | null | true |
ArchimedeanClass.FiniteElement._proof_1 | Mathlib.Algebra.Order.Ring.StandardPart | ∀ (K : Type u_1) [inst : LinearOrder K] [inst_1 : Field K] [IsOrderedRing K], IsOrderedAddMonoid K | null | false |
AddSubsemigroup.centerToAddOpposite._proof_4 | Mathlib.GroupTheory.Submonoid.Center | ∀ {M : Type u_1} [inst : Add M] (r : ↥(AddSubsemigroup.center Mᵃᵒᵖ)), AddOpposite.unop ↑r ∈ Set.addCenter M | null | false |
Substring.Raw.Valid.data_drop | Batteries.Data.String.Lemmas | ∀ {s : Substring.Raw}, s.Valid → ∀ (n : ℕ), (s.drop n).toString.toList = List.drop n s.toString.toList | null | true |
Int.getElem?_toArray_roo_eq_none | Init.Data.Range.Polymorphic.IntLemmas | ∀ {m n : ℤ} {i : ℕ}, (n - (m + 1)).toNat ≤ i → (m<...n).toArray[i]? = none | null | true |
Lean.Widget.WidgetSource.mk.noConfusion | Lean.Widget.UserWidget | {P : Sort u} →
{sourcetext sourcetext' : String} →
{ sourcetext := sourcetext } = { sourcetext := sourcetext' } → (sourcetext = sourcetext' → P) → P | null | false |
Lean.Grind.IntModule.OfNatModule.mk_le_mk | Init.Grind.Module.Envelope | ∀ {α : Type u} [inst : Lean.Grind.NatModule α] [inst_1 : LE α] [inst_2 : Std.IsPreorder α]
[inst_3 : Lean.Grind.OrderedAdd α] {a₁ a₂ b₁ b₂ : α},
Lean.Grind.IntModule.OfNatModule.Q.mk (a₁, a₂) ≤ Lean.Grind.IntModule.OfNatModule.Q.mk (b₁, b₂) ↔ a₁ + b₂ ≤ a₂ + b₁ | null | true |
StructureGroupoid.id_mem_maximalAtlas | Mathlib.Geometry.Manifold.HasGroupoid | ∀ {H : Type u} [inst : TopologicalSpace H] (G : StructureGroupoid H),
OpenPartialHomeomorph.refl H ∈ StructureGroupoid.maximalAtlas H G | In the model space, the identity is in any maximal atlas. | true |
_private.Mathlib.Algebra.Exact.Sequence.0.Module.sum_neg_one_pow_finrank_eq_zero_of_exact._proof_1_3 | Mathlib.Algebra.Exact.Sequence | ∀ {k : Type u_1} [inst : DivisionRing k] {n : ℕ} (V : Fin (n + 2) → Type u_2)
[inst_1 : (i : Fin (n + 2)) → AddCommGroup (V i)] [inst_2 : (i : Fin (n + 2)) → Module k (V i)]
(f : (i : Fin (n + 1)) → V i.castSucc →ₗ[k] V i.succ) (i : Fin n),
Module.finrank k ↥(f i.succ).range + Module.finrank k ↥(f i.succ).ker = M... | null | false |
Array.mapIdx_mapIdx | Init.Data.Array.MapIdx | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} {xs : Array α} {f : ℕ → α → β} {g : ℕ → β → γ},
Array.mapIdx g (Array.mapIdx f xs) = Array.mapIdx (fun i => g i ∘ f i) xs | null | true |
QuasiconcaveOn.dual | Mathlib.Analysis.Convex.Quasiconvex | ∀ {𝕜 : Type u_1} {E : Type u_2} {β : Type u_3} [inst : Semiring 𝕜] [inst_1 : PartialOrder 𝕜] [inst_2 : AddCommMonoid E]
[inst_3 : LE β] [inst_4 : SMul 𝕜 E] {s : Set E} {f : E → β},
QuasiconcaveOn 𝕜 s f → QuasiconvexOn 𝕜 s (⇑OrderDual.toDual ∘ f) | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.