name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
_private.Mathlib.Tactic.GRewrite.Core.0.Mathlib.Tactic.GRewrite.Progress.ctorIdx | Mathlib.Tactic.GRewrite.Core | Mathlib.Tactic.GRewrite.Progress✝ → ℕ | null | false |
Int.negOfNat_eq | Init.Data.Int.Lemmas | ∀ {n : ℕ}, Int.negOfNat n = -Int.ofNat n | null | true |
ImportGraph.Lean.Import.Whitespace.mk.noConfusion | ImportGraph.Imports.Pretty | {P : Sort u} →
{leading trailing leading' trailing' : String} →
{ leading := leading, trailing := trailing } = { leading := leading', trailing := trailing' } →
(leading = leading' → trailing = trailing' → P) → P | null | false |
TensorProduct.AlgebraTensorModule.rightComm._proof_31 | Mathlib.LinearAlgebra.TensorProduct.Tower | ∀ (S : Type u_1) (B : Type u_2) (M : Type u_4) (P : Type u_3) [inst : Semiring B] [inst_1 : AddCommMonoid M]
[inst_2 : Module B M] [inst_3 : AddCommMonoid P] [inst_4 : CommSemiring S] [inst_5 : Module S M] [inst_6 : Module S P]
[inst_7 : Algebra S B] [inst_8 : IsScalarTower S B M], SMulCommClass S B (TensorProduct ... | null | false |
Subgroup.instInhabitedLeftTransversal.eq_1 | Mathlib.GroupTheory.Complement | ∀ {G : Type u_1} [inst : Group G] {H : Subgroup G},
Subgroup.instInhabitedLeftTransversal = { default := ⟨Set.range Quotient.out, ⋯⟩ } | null | true |
_private.Mathlib.RingTheory.Polynomial.HilbertPoly.0.Polynomial.natDegree_hilbertPoly_of_ne_zero_of_rootMultiplicity_lt._simp_1_9 | Mathlib.RingTheory.Polynomial.HilbertPoly | ∀ {R : Type u_1} [inst : AddMonoidWithOne R] [CharZero R] {n : ℕ}, (↑n = 0) = (n = 0) | null | false |
CovBy.unique_right | Mathlib.Order.Cover | ∀ {α : Type u_1} [inst : LinearOrder α] {a b c : α}, c ⋖ a → c ⋖ b → a = b | null | true |
Lean.Parser.checkNoImmediateColon | Lean.Parser.Basic | Lean.Parser.Parser | Fail if previous token is immediately followed by ':'. | true |
LinearMap.codRestrictOfInjective | Mathlib.Algebra.Module.Submodule.Equiv | {R : Type u_1} →
{M₁ : Type u_5} →
{M₂ : Type u_6} →
{M₃ : Type u_7} →
[inst : CommSemiring R] →
[inst_1 : AddCommMonoid M₁] →
[inst_2 : AddCommMonoid M₂] →
[inst_3 : AddCommMonoid M₃] →
[inst_4 : Module R M₁] →
[inst_5 : Module R... | The restriction of a linear map on the target to a submodule of the target given by
an inclusion. | true |
Function.Semiconj.mapsTo_range | Mathlib.Data.Set.Function | ∀ {α : Type u_1} {β : Type u_2} {fa : α → α} {fb : β → β} {f : α → β},
Function.Semiconj f fa fb → Set.MapsTo fb (Set.range f) (Set.range f) | null | true |
CategoryTheory.Presheaf.imageSieve_whisker_forget | Mathlib.CategoryTheory.Sites.LocallySurjective | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {A : Type u'} [inst_1 : CategoryTheory.Category.{v', u'} A]
{FA : A → A → Type u_1} {CA : A → Type w'} [inst_2 : (X Y : A) → FunLike (FA X Y) (CA X) (CA Y)]
[inst_3 : CategoryTheory.ConcreteCategory A FA] {F G : CategoryTheory.Functor Cᵒᵖ A} (f : F ⟶ G) {U : ... | null | true |
List.iterateTR_loop_eq | Mathlib.Data.List.Defs | ∀ {α : Type u_1} (f : α → α) (a : α) (n : ℕ) (l : List α), List.iterateTR.loop f a n l = l.reverse ++ List.iterate f a n | null | true |
TwoSidedIdeal.instPartialOrder | Mathlib.RingTheory.TwoSidedIdeal.Basic | {R : Type u_1} → [inst : NonUnitalNonAssocRing R] → PartialOrder (TwoSidedIdeal R) | null | true |
instCoeTCOrderAddMonoidHomOfOrderHomClassOfAddMonoidHomClass.eq_1 | Mathlib.Algebra.Order.Hom.Monoid | ∀ {F : Type u_1} {α : Type u_2} {β : Type u_3} [inst : Preorder α] [inst_1 : Preorder β] [inst_2 : AddZeroClass α]
[inst_3 : AddZeroClass β] [inst_4 : FunLike F α β] [inst_5 : OrderHomClass F α β] [inst_6 : AddMonoidHomClass F α β],
instCoeTCOrderAddMonoidHomOfOrderHomClassOfAddMonoidHomClass = { coe := OrderMonoid... | null | true |
List.SortedGT.sortedGE | Mathlib.Data.List.Sort | ∀ {α : Type u_1} [inst : Preorder α] {l : List α}, l.SortedGT → l.SortedGE | null | true |
_private.Mathlib.Topology.Separation.Basic.0.t1Space_iff_disjoint_pure_nhds._proof_1_2 | Mathlib.Topology.Separation.Basic | 9 ≠ 0 | null | false |
isClopen_discrete._simp_1 | Mathlib.Topology.Clopen | ∀ {X : Type u} [inst : TopologicalSpace X] [DiscreteTopology X] (s : Set X), IsClopen s = True | null | false |
FintypeCat.toProfinite._proof_4 | Mathlib.Topology.Category.Profinite.Basic | ∀ (A : FintypeCat), CompactSpace A.obj | null | false |
Lean.Elab.LinterInfoGroup.noConfusion | Lean.Elab.InfoTree.Basic | {P : Sort v✝} → {x y : Lean.Elab.LinterInfoGroup} → x = y → Lean.Elab.LinterInfoGroup.noConfusionType P x y | null | false |
FirstOrder.Language.Formula.realize_iff._simp_1 | Mathlib.ModelTheory.Semantics | ∀ {L : FirstOrder.Language} {M : Type w} [inst : L.Structure M] {α : Type u'} {φ ψ : L.Formula α} {v : α → M},
(φ.iff ψ).Realize v = (φ.Realize v ↔ ψ.Realize v) | null | false |
ONote.brecOn.go | Mathlib.SetTheory.Ordinal.Notation | {motive : ONote → Sort u} → (t : ONote) → ((t : ONote) → ONote.below t → motive t) → motive t ×' ONote.below t | null | true |
Mathlib.Meta.NormNum.isNNRat_lt_false | Mathlib.Tactic.NormNum.Ineq | ∀ {α : Type u_1} [inst : Semiring α] [inst_1 : LinearOrder α] [IsStrictOrderedRing α] {a b : α} {na nb da db : ℕ},
Mathlib.Meta.NormNum.IsNNRat a na da →
Mathlib.Meta.NormNum.IsNNRat b nb db → decide (nb * da ≤ na * db) = true → ¬a < b | null | true |
Lean.Elab.Level.Context.mk.noConfusion | Lean.Elab.Level | {P : Sort u} →
{options : Lean.Options} →
{ref : Lean.Syntax} →
{autoBoundImplicit : Bool} →
{options' : Lean.Options} →
{ref' : Lean.Syntax} →
{autoBoundImplicit' : Bool} →
{ options := options, ref := ref, autoBoundImplicit := autoBoundImplicit } =
... | null | false |
_private.Std.Sat.AIG.CNF.0.Std.Sat.AIG.toCNF.match_54.eq_1 | Std.Sat.AIG.CNF | ∀ (aig : Std.Sat.AIG ℕ) (upper : ℕ) (h : upper < aig.decls.size) (lhs rhs : Std.Sat.AIG.Fanin)
(this : lhs.gate < upper ∧ rhs.gate < upper) (lstate : Std.Sat.AIG.toCNF.State✝ aig)
(motive : { out // Std.Sat.AIG.toCNF.State.IsExtensionBy✝ lstate out rhs.gate ⋯ } → Sort u_1)
(rstate : Std.Sat.AIG.toCNF.State✝ aig) ... | null | true |
_private.Init.Data.Array.QSort.Basic.0.Array.qpartition.loop._unsafe_rec | Init.Data.Array.QSort.Basic | {α : Type u_1} →
{n : ℕ} →
(α → α → Bool) →
(lo hi : ℕ) →
hi < n →
α →
Vector α n →
(i k : ℕ) →
autoParam (lo ≤ i) Array.qpartition._auto_2✝ →
autoParam (i ≤ k) Array.qpartition._auto_4✝ →
autoParam (k ≤ hi) Ar... | null | false |
AbstractMeasure.convolveFunRight_apply | Mathlib.NumberTheory.Padics.Measure.Monoid | ∀ {G : Type u_1} {R : Type u_2} [inst : TopologicalSpace G] [inst_1 : CommRing R] [inst_2 : TopologicalSpace R]
[inst_3 : IsTopologicalRing R] [inst_4 : Monoid G] [inst_5 : ContinuousMul G] (μ : AbstractMeasure G R R)
(f : C(G, R)) (x : G),
((AbstractMeasure.convolveFunRight μ) f) x = μ { toFun := fun y => f (x *... | null | true |
basisOfLinearIndependentOfCardEqFinrank.congr_simp | Mathlib.LinearAlgebra.FiniteDimensional.Lemmas | ∀ {K : Type u} {V : Type v} [inst : DivisionRing K] [inst_1 : AddCommGroup V] [inst_2 : Module K V] {ι : Type u_1}
[inst_3 : Fintype ι] [inst_4 : Nonempty ι] {b b_1 : ι → V} (e_b : b = b_1) (lin_ind : LinearIndependent K b)
(card_eq : Fintype.card ι = Module.finrank K V),
basisOfLinearIndependentOfCardEqFinrank l... | null | true |
_private.Mathlib.Algebra.Polynomial.Eval.Defs.0.Polynomial.eval₂_mul_C'._simp_1_1 | Mathlib.Algebra.Polynomial.Eval.Defs | ∀ {G₀ : Type u_2} [inst : MulZeroClass G₀] (a : G₀), Commute 0 a = True | null | false |
CategoryTheory.MorphismProperty.respectsIso_of_isStableUnderComposition | Mathlib.CategoryTheory.MorphismProperty.Composition | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {P : CategoryTheory.MorphismProperty C}
[P.IsStableUnderComposition], CategoryTheory.MorphismProperty.isomorphisms C ≤ P → P.RespectsIso | null | true |
LightCondensed.lanPresheafExt_inv | Mathlib.Condensed.Discrete.Colimit | ∀ {F G : CategoryTheory.Functor LightProfiniteᵒᵖ (Type u)} (S : LightProfiniteᵒᵖ)
(i : FintypeCat.toLightProfinite.op.comp F ≅ FintypeCat.toLightProfinite.op.comp G),
(LightCondensed.lanPresheafExt i).inv.app S =
CategoryTheory.Limits.colimMap
((CategoryTheory.CostructuredArrow.proj FintypeCat.toLightProf... | null | true |
Ideal.Quotient.field._proof_13 | Mathlib.RingTheory.Ideal.Quotient.Basic | ∀ {R : Type u_1} [inst : CommRing R] (I : Ideal R) [I.IsMaximal] (a : R ⧸ I), ¬a = 0 → ∃ b, a * b = 1 | null | false |
String.Slice.Pattern.ToBackwardSearcher.noConfusion | Init.Data.String.Pattern.Basic | {P : Sort u} →
{ρ : Type} →
{pat : ρ} →
{σ : String.Slice → Type} →
{t : String.Slice.Pattern.ToBackwardSearcher pat σ} →
{ρ' : Type} →
{pat' : ρ'} →
{σ' : String.Slice → Type} →
{t' : String.Slice.Pattern.ToBackwardSearcher pat' σ'} →
... | null | false |
_private.Mathlib.GroupTheory.FreeGroup.Basic.0.FreeGroup.Red.sizeof_of_step._proof_1_3 | Mathlib.GroupTheory.FreeGroup.Basic | ∀ {α : Type u_1} (L2 : List (α × Bool)) (x : α) (b : Bool),
sizeOf L2 < 1 + sizeOf (x, b) + (1 + sizeOf (x, !b) + sizeOf L2) | null | false |
CategoryTheory.Limits.HasWidePullback | Mathlib.CategoryTheory.Limits.Shapes.WidePullbacks | {J : Type w} →
{C : Type u} → [inst : CategoryTheory.Category.{v, u} C] → (B : C) → (objs : J → C) → ((j : J) → objs j ⟶ B) → Prop | `HasWidePullback B objs arrows` means that `wideCospan B objs arrows` has a limit. | true |
CompletableTopField | Mathlib.Topology.Algebra.UniformField | (K : Type u_1) → [Field K] → [UniformSpace K] → Prop | A topological field is completable if it is separated and the image under
the mapping x ↦ x⁻¹ of every Cauchy filter (with respect to the additive uniform structure)
which does not have a cluster point at 0 is a Cauchy filter
(with respect to the additive uniform structure). This ensures the completion is
a field.
| true |
_private.Mathlib.Combinatorics.SimpleGraph.Regularity.Increment.0.SzemerediRegularity.distinctPairs | Mathlib.Combinatorics.SimpleGraph.Regularity.Increment | {α : Type u_1} →
[inst : Fintype α] →
[inst_1 : DecidableEq α] →
{P : Finpartition Finset.univ} →
P.IsEquipartition →
(G : SimpleGraph α) → [DecidableRel G.Adj] → ℝ → ↥P.parts.offDiag → Finset (Finset α × Finset α) | The contribution to `Finpartition.energy` of a pair of distinct parts of a `Finpartition`. | true |
Lean.Grind.CommRing.Poly.combine.go.match_1.congr_eq_2 | Init.Grind.Ring.CommSolver | ∀ (motive : Lean.Grind.CommRing.Poly → Lean.Grind.CommRing.Poly → Sort u_1) (p₁ p₂ : Lean.Grind.CommRing.Poly)
(h_1 : (k₁ k₂ : ℤ) → motive (Lean.Grind.CommRing.Poly.num k₁) (Lean.Grind.CommRing.Poly.num k₂))
(h_2 :
(k₁ k₂ : ℤ) →
(m₂ : Lean.Grind.CommRing.Mon) →
(p₂ : Lean.Grind.CommRing.Poly) →
... | null | true |
AlgebraicGeometry.Scheme.Hom.appLE_map'_assoc | Mathlib.AlgebraicGeometry.Scheme | ∀ {X Y : AlgebraicGeometry.Scheme} (f : X ⟶ Y) {U : Y.Opens} {V V' : X.Opens}
(e : V ≤ (TopologicalSpace.Opens.map f.base).obj U) (i : V = V') {Z : CommRingCat}
(h : X.presheaf.obj (Opposite.op V) ⟶ Z),
CategoryTheory.CategoryStruct.comp (AlgebraicGeometry.Scheme.Hom.appLE f U V' ⋯)
(CategoryTheory.Category... | null | true |
Std.Tactic.BVDecide.BVExpr.bitblast.mkFullAdderOut.eq_1 | Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Add | ∀ {α : Type} [inst : Hashable α] [inst_1 : DecidableEq α] (aig : Std.Sat.AIG α) (lhs rhs cin : aig.Ref),
Std.Tactic.BVDecide.BVExpr.bitblast.mkFullAdderOut aig { lhs := lhs, rhs := rhs, cin := cin } =
(aig.mkXorCached { lhs := lhs, rhs := rhs }).aig.mkXorCached
{ lhs := (aig.mkXorCached { lhs := lhs, rhs :=... | null | true |
abs.unexpander | Mathlib.Algebra.Order.Group.Unbundled.Abs | Lean.PrettyPrinter.Unexpander | Unexpander for the notation `|a|` for `abs a`.
Tries to add discretionary parentheses in unparsable cases. | true |
CentroidHom.comp_apply | Mathlib.Algebra.Ring.CentroidHom | ∀ {α : Type u_5} [inst : NonUnitalNonAssocSemiring α] (g f : CentroidHom α) (a : α), (g.comp f) a = g (f a) | null | true |
ProofWidgets.instRpcEncodablePanelWidgetProps.dec._@.ProofWidgets.Component.Panel.Basic.2840189264._hygCtx._hyg.1 | ProofWidgets.Component.Panel.Basic | Lean.Json → ExceptT String (ReaderT Lean.Server.RpcObjectStore Id) ProofWidgets.PanelWidgetProps | null | false |
CategoryTheory.Functor.RepresentableBy.casesOn | Mathlib.CategoryTheory.Yoneda | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{F : CategoryTheory.Functor Cᵒᵖ (Type v)} →
{Y : C} →
{motive : F.RepresentableBy Y → Sort u} →
(t : F.RepresentableBy Y) →
((homEquiv : {X : C} → (X ⟶ Y) ≃ F.obj (Opposite.op X)) →
(homEquiv_comp :
... | null | false |
_private.ProofWidgets.Cancellable.0.ProofWidgets.initFn._@.ProofWidgets.Cancellable.2133826679._hygCtx._hyg.2 | ProofWidgets.Cancellable | IO (IO.Ref (ProofWidgets.RequestId × Std.HashMap ProofWidgets.RequestId ProofWidgets.CancellableTask)) | null | false |
AlgebraicGeometry.LocallyRingedSpace.IsOpenImmersion.stalk_iso | Mathlib.Geometry.RingedSpace.OpenImmersion | ∀ {X Y : AlgebraicGeometry.LocallyRingedSpace} (f : X ⟶ Y) [H : AlgebraicGeometry.LocallyRingedSpace.IsOpenImmersion f]
(x : ↑X.toTopCat), CategoryTheory.IsIso (AlgebraicGeometry.LocallyRingedSpace.Hom.stalkMap f x) | null | true |
CategoryTheory.Limits.biprod.opIso_hom_fst_assoc | Mathlib.CategoryTheory.Limits.Shapes.BinaryBiproducts | ∀ {C : Type uC} [inst : CategoryTheory.Category.{uC', uC} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
(P Q : C) [inst_2 : CategoryTheory.Limits.HasBinaryBiproduct P Q] {Z : Cᵒᵖ} (h : Opposite.op P ⟶ Z),
CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.biprod.opIso P Q).hom
(CategoryTheory.... | null | true |
_private.Lean.Data.Iterators.Producers.PersistentHashMap.0.Lean.PersistentHashMap.Node.measure.measureEntries._unsafe_rec | Lean.Data.Iterators.Producers.PersistentHashMap | {α : Type u_1} → {β : Type u_2} → Array (Lean.PersistentHashMap.Entry α β (Lean.PersistentHashMap.Node α β)) → ℕ → ℕ | null | false |
SzemerediRegularity.mul_sq_le_sum_sq | Mathlib.Combinatorics.SimpleGraph.Regularity.Bound | ∀ {ι : Type u_2} {𝕜 : Type u_3} [inst : Field 𝕜] [inst_1 : LinearOrder 𝕜] [IsStrictOrderedRing 𝕜] {s t : Finset ι}
{x : 𝕜},
s ⊆ t → ∀ (f : ι → 𝕜), x ^ 2 ≤ ((∑ i ∈ s, f i) / ↑s.card) ^ 2 → ↑s.card ≠ 0 → ↑s.card * x ^ 2 ≤ ∑ i ∈ t, f i ^ 2 | null | true |
instMonoidUniformOnFun._proof_3 | Mathlib.Topology.Algebra.UniformConvergence | ∀ {α : Type u_1} {β : Type u_2} {𝔖 : Set (Set α)} [inst : Monoid β] (a : UniformOnFun α β 𝔖), a * 1 = a | null | false |
Equiv.Perm.disjoint_noncommProd_right | Mathlib.GroupTheory.Perm.Support | ∀ {α : Type u_1} {g : Equiv.Perm α} {ι : Type u_2} {k : ι → Equiv.Perm α} {s : Finset ι}
(hs : (↑s).Pairwise fun i j => Commute (k i) (k j)), (∀ i ∈ s, g.Disjoint (k i)) → g.Disjoint (s.noncommProd k hs) | null | true |
Filter.HasBasis.recOn | Mathlib.Order.Filter.Bases.Basic | {α : Type u_1} →
{ι : Sort u_3} →
{l : Filter α} →
{p : ι → Prop} →
{s : ι → Set α} →
{motive : l.HasBasis p s → Sort u} →
(t : l.HasBasis p s) → ((mem_iff' : ∀ (t : Set α), t ∈ l ↔ ∃ i, p i ∧ s i ⊆ t) → motive ⋯) → motive t | null | false |
_private.Mathlib.Probability.Kernel.RadonNikodym.0.ProbabilityTheory.Kernel.rnDeriv_eq_top_iff._simp_1_5 | Mathlib.Probability.Kernel.RadonNikodym | ∀ {r : ℝ}, (ENNReal.ofReal r = ⊤) = False | null | false |
Acc.ndrecOnC.eq_1 | Init.WFComputable | ∀ {α : Sort u_1} {r : α → α → Prop} {C : α → Sort v} {a : α} (n : Acc r a)
(m : (x : α) → (∀ (y : α), r y x → Acc r y) → ((y : α) → r y x → C y) → C x), n.ndrecOnC m = Acc.recC m n | null | true |
Std.TreeMap.inter | Std.Data.TreeMap.Basic | {α : Type u} → {β : Type v} → {cmp : α → α → Ordering} → Std.TreeMap α β cmp → Std.TreeMap α β cmp → Std.TreeMap α β cmp | Computes the intersection of the given tree maps. The result will only contain entries from the first map.
This function always merges the smaller map into the larger map.
| true |
ProbabilityTheory.Kernel.IsFiniteKernel.comapRight | Mathlib.Probability.Kernel.Basic | ∀ {α : Type u_1} {β : Type u_2} {mα : MeasurableSpace α} {mβ : MeasurableSpace β} {γ : Type u_4}
{mγ : MeasurableSpace γ} {f : γ → β} (κ : ProbabilityTheory.Kernel α β) [ProbabilityTheory.IsFiniteKernel κ]
(hf : MeasurableEmbedding f), ProbabilityTheory.IsFiniteKernel (κ.comapRight hf) | null | true |
Ideal.Quotient.algebraMap_mk_of_liesOver | Mathlib.RingTheory.Ideal.Over | ∀ {A : Type u_3} {B : Type u_4} [inst : CommRing A] [inst_1 : CommRing B] [inst_2 : Algebra A B] (P : Ideal B)
(p : Ideal A) [inst_3 : P.LiesOver p] (x : A),
(algebraMap (A ⧸ p) (B ⧸ P)) ((Ideal.Quotient.mk p) x) = (Ideal.Quotient.mk P) ((algebraMap A B) x) | null | true |
Representation.finsuppToCoinvariants._proof_2 | Mathlib.RepresentationTheory.Coinvariants | ∀ {k : Type u_1} [inst : CommRing k], RingHomInvPair (RingHom.id k) (RingHom.id k) | null | false |
Std.DTreeMap.Internal.Impl.Balanced.inner | Std.Data.DTreeMap.Internal.Balanced | ∀ {α : Type u} {β : α → Type v} {sz : ℕ} {k : α} {v : β k} {l r : Std.DTreeMap.Internal.Impl α β},
l.Balanced →
r.Balanced →
Std.DTreeMap.Internal.Impl.BalancedAtRoot l.size r.size →
sz = l.size + 1 + r.size → (Std.DTreeMap.Internal.Impl.inner sz k v l r).Balanced | Inner node is balanced if it is locally balanced, both children are balanced and size
information is correct.
| true |
ContinuousMultilinearMap.ofSubsingletonₗᵢ_apply | Mathlib.Analysis.Normed.Module.Multilinear.Basic | ∀ (𝕜 : Type u) {ι : Type v} (G : Type wG) {G' : Type wG'} [inst : NontriviallyNormedField 𝕜]
[inst_1 : SeminormedAddCommGroup G] [inst_2 : NormedSpace 𝕜 G] [inst_3 : SeminormedAddCommGroup G']
[inst_4 : NormedSpace 𝕜 G'] [inst_5 : Fintype ι] [inst_6 : Subsingleton ι] (i : ι) (a : G →L[𝕜] G'),
(ContinuousMult... | null | true |
Std.Http.Server.Connection.rec | Std.Http.Server.Connection | {α : Type} →
{motive : Std.Http.Server.Connection α → Sort u} →
((socket : α) →
(machine : Std.Http.Protocol.H1.Machine Std.Http.Protocol.H1.Direction.receiving) →
(extensions : Std.Http.Extensions) →
motive { socket := socket, machine := machine, extensions := extensions }) →
... | null | false |
CategoryTheory.Cat.isoOfEquiv._auto_3 | Mathlib.CategoryTheory.Category.Cat | Lean.Syntax | null | false |
MeasureTheory.AEFinStronglyMeasurable.eq_1 | Mathlib.MeasureTheory.Function.StronglyMeasurable.AEStronglyMeasurable | ∀ {α : Type u_1} {β : Type u_2} [inst : TopologicalSpace β] [inst_1 : Zero β] {x : MeasurableSpace α} (f : α → β)
(μ : MeasureTheory.Measure α),
MeasureTheory.AEFinStronglyMeasurable f μ = ∃ g, MeasureTheory.FinStronglyMeasurable g μ ∧ f =ᵐ[μ] g | null | true |
AddSubgroup.NormalizerCondition.normal_of_coatom | Mathlib.Algebra.Group.Subgroup.Order | ∀ {G : Type u_1} [inst : AddGroup G] (H : AddSubgroup G), AddNormalizerCondition G → IsCoatom H → H.Normal | In an additive group that satisfies the normalizer condition, every maximal
additive subgroup is normal | true |
MeasureTheory.integral_image_eq_integral_deriv_smul_of_antitoneOn | Mathlib.MeasureTheory.Function.JacobianOneDim | ∀ {F : Type u_1} [inst : NormedAddCommGroup F] [inst_1 : NormedSpace ℝ F] {s : Set ℝ} {f f' : ℝ → ℝ},
MeasurableSet s →
(∀ x ∈ s, HasDerivWithinAt f (f' x) s x) →
AntitoneOn f s → ∀ (g : ℝ → F), ∫ (x : ℝ) in f '' s, g x = ∫ (x : ℝ) in s, -f' x • g (f x) | Change of variable formula for differentiable functions: if a real function `f` is
antitone and differentiable on a measurable set `s`, then the Bochner integral of a function
`g : ℝ → F` on `f '' s` coincides with the integral of `(-f' x) • g ∘ f` on `s` . | true |
_private.Mathlib.Algebra.Homology.DerivedCategory.FullyFaithful.0.DerivedCategory.instFullSingleFunctor.match_1 | Mathlib.Algebra.Homology.DerivedCategory.FullyFaithful | ∀ (C : Type u_2) [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Abelian C] (n : ℤ) {A : C}
(X : CochainComplex C ℤ) (s : X ⟶ (CochainComplex.singleFunctor C n).obj A) (A₀ : C)
(e : X ≅ (HomologicalComplex.single C (ComplexShape.up ℤ) n).obj A₀)
(motive : (∃ a, (CochainComplex.singleFunctor... | null | false |
_private.Mathlib.CategoryTheory.Limits.FilteredColimitCommutesProduct.0.CategoryTheory.Limits.Types.isIso_colimitPointwiseProductToProductColimit.match_1_1 | Mathlib.CategoryTheory.Limits.FilteredColimitCommutesProduct | ∀ {α : Type u_1} (motive : CategoryTheory.Discrete α → Prop) (x : CategoryTheory.Discrete α),
(∀ (s : α), motive { as := s }) → motive x | null | false |
Lean.Lsp.HoverParams.mk.sizeOf_spec | Lean.Data.Lsp.LanguageFeatures | ∀ (toTextDocumentPositionParams : Lean.Lsp.TextDocumentPositionParams),
sizeOf { toTextDocumentPositionParams := toTextDocumentPositionParams } = 1 + sizeOf toTextDocumentPositionParams | null | true |
NormedAddGroupHom.toNormedAddCommGroup | Mathlib.Analysis.Normed.Group.Hom | {V₁ : Type u_5} →
{V₂ : Type u_6} →
[inst : NormedAddCommGroup V₁] → [inst_1 : NormedAddCommGroup V₂] → NormedAddCommGroup (NormedAddGroupHom V₁ V₂) | Normed group homomorphisms themselves form a normed group with respect to
the operator norm. | true |
ContinuousMap.instSeminormedRing._proof_6 | Mathlib.Topology.ContinuousMap.Compact | ∀ {α : Type u_1} [inst : TopologicalSpace α] {R : Type u_2} [inst_1 : SeminormedRing R] (x : C(α, R)), x ^ 0 = 1 | null | false |
MvPolynomial.sumAlgEquiv_comp_rename_inl | Mathlib.Algebra.MvPolynomial.Equiv | ∀ (R : Type u) (S₁ : Type v) (S₂ : Type w) [inst : CommSemiring R],
(↑(MvPolynomial.sumAlgEquiv R S₁ S₂)).comp (MvPolynomial.rename Sum.inl) =
MvPolynomial.mapAlgHom (Algebra.ofId R (MvPolynomial S₂ R)) | null | true |
CategoryTheory.Limits.CatCospanTransform.rightUnitor._proof_2 | Mathlib.CategoryTheory.Limits.Shapes.Pullback.Categorical.CatCospanTransform | ∀ {A : Type u_1} {B : Type u_6} {C : Type u_10} {A' : Type u_11} {B' : Type u_3} {C' : Type u_12}
[inst : CategoryTheory.Category.{u_4, u_1} A] [inst_1 : CategoryTheory.Category.{u_5, u_6} B]
[inst_2 : CategoryTheory.Category.{u_7, u_10} C] {F : CategoryTheory.Functor A B} {G : CategoryTheory.Functor C B}
[inst_3... | null | false |
VectorField.fderivWithin_pullbackWithin | Mathlib.Analysis.Calculus.VectorField | ∀ {𝕜 : 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] {s : Set E}
{f : E → F} {V : F → F} {x : E},
(fderivWithin 𝕜 f s x).IsInvertible → (fderivWithin 𝕜 f s x) (V... | null | true |
CategoryTheory.Limits.ColimitPresentation.Total.Hom.recOn | Mathlib.CategoryTheory.Presentable.ColimitPresentation | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{J : Type u_1} →
{I : J → Type u_2} →
[inst_1 : CategoryTheory.Category.{v_1, u_1} J] →
[inst_2 : (j : J) → CategoryTheory.Category.{u_3, u_2} (I j)] →
{D : CategoryTheory.Functor J C} →
{P : (j : J) → Cat... | null | false |
Lean.Compiler.LCNF.markRecDecls | Lean.Compiler.LCNF.Basic | {pu : Lean.Compiler.LCNF.Purity} → Array (Lean.Compiler.LCNF.Decl pu) → Array (Lean.Compiler.LCNF.Decl pu) | Traverse the given block of potentially mutually recursive functions
and mark a declaration `f` as recursive if there is an application
`f ...` in the block.
This is an overapproximation, and relies on the fact that our frontend
computes strongly connected components.
See comment at `recursive` field.
| true |
_private.Mathlib.MeasureTheory.Covering.Differentiation.0.VitaliFamily.ae_tendsto_lintegral_enorm_sub_div._simp_1_1 | Mathlib.MeasureTheory.Covering.Differentiation | ∀ {α : Type u} {ι : Sort v} {x : α} {s : ι → Set α}, (x ∈ ⋃ i, s i) = ∃ i, x ∈ s i | null | false |
Module.DualBases.finite._autoParam | Mathlib.LinearAlgebra.Dual.Basis | Lean.Syntax | null | false |
CategoryTheory.Abelian.SpectralObject.toCycles_cyclesMap._auto_1 | Mathlib.Algebra.Homology.SpectralObject.Cycles | Lean.Syntax | null | false |
_private.Mathlib.Order.CompleteLattice.Basic.0.iSup_prod._simp_1_1 | Mathlib.Order.CompleteLattice.Basic | ∀ {α : Type u_1} {β : Type u_2} {p : α × β → Prop}, (∀ (x : α × β), p x) = ∀ (a : α) (b : β), p (a, b) | null | false |
Std.DTreeMap.Internal.Impl.applyPartition._proof_4 | Std.Data.DTreeMap.Internal.Model | ∀ {α : Type u_1} {β : α → Type u_2} [inst : Ord α] (k : α → Ordering) (l : Std.DTreeMap.Internal.Impl α β),
(Std.DTreeMap.Internal.Impl.contains' k l = true →
Std.DTreeMap.Internal.Impl.contains' k Std.DTreeMap.Internal.Impl.leaf = true) →
Std.DTreeMap.Internal.Impl.contains' k l = true → Std.DTreeMap.Inter... | null | false |
Lean.Meta.Grind.Arith.Linear.State.mk.sizeOf_spec | Lean.Meta.Tactic.Grind.Arith.Linear.Types | ∀ (structs : Array Lean.Meta.Grind.Arith.Linear.Struct) (typeIdOf : Lean.PHashMap Lean.Meta.Sym.ExprPtr (Option ℕ))
(exprToStructId : Lean.PHashMap Lean.Meta.Sym.ExprPtr ℕ) (exprToStructIdEntries : Lean.PArray (Lean.Expr × ℕ))
(forbiddenNatModules : Lean.PHashSet Lean.Meta.Sym.ExprPtr)
(natStructs : Array Lean.Me... | null | true |
dist_self_sub_left | Mathlib.Analysis.Normed.Group.Uniform | ∀ {E : Type u_2} [inst : SeminormedAddCommGroup E] (a b : E), dist (a - b) a = ‖b‖ | null | true |
Std.TreeMap.find?_toArray_eq_some_iff_getKey?_eq_some_and_getElem?_eq_some | Std.Data.TreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.TreeMap α β cmp} [Std.TransCmp cmp] {k k' : α} {v : β},
Array.find? (fun x => cmp x.1 k == Ordering.eq) t.toArray = some (k', v) ↔ t.getKey? k = some k' ∧ t[k]? = some v | null | true |
lp.toNorm | Mathlib.Analysis.Normed.Lp.lpSpace | {α : Type u_3} →
{E : α → Type u_4} → [inst : (i : α) → NormedAddCommGroup (E i)] → {p : ENNReal} → ↥(lp E p) → ↥(lp (fun x => ℝ) p) | The sequence of norms of `x : lp E p` as a term of `ℓ^p(α, ℝ)`. Here `E : α → Type*`
is a dependent type and `ℓ^p(α, ℝ)` is the non-dependent `ℝ`-valued `lp` space. | true |
_private.Mathlib.GroupTheory.Index.0.Subgroup.index_eq_two_iff_exists_notMem_and'._simp_1_1 | Mathlib.GroupTheory.Index | ∀ {G : Type u_1} [inst : Group G] {H : Subgroup G}, (H.index = 2) = ∃ a, ∀ (b : G), Xor (a * b ∈ H) (b ∈ H) | null | false |
_private.Mathlib.Order.Filter.NAry.0.Filter.map₂_neBot_iff._simp_1_2 | Mathlib.Order.Filter.NAry | ∀ {p q : Prop}, (¬(p ∨ q)) = (¬p ∧ ¬q) | null | false |
exists_isTranscendenceBasis_between | Mathlib.RingTheory.AlgebraicIndependent.TranscendenceBasis | ∀ {R : Type u_1} {A : Type w} [inst : CommRing R] [inst_1 : CommRing A] [inst_2 : Algebra R A] [NoZeroDivisors A]
(s t : Set A),
s ⊆ t →
AlgebraicIndepOn R id s →
∀ [ht : Algebra.IsAlgebraic (↥(Algebra.adjoin R t)) A], ∃ u, s ⊆ u ∧ u ⊆ t ∧ IsTranscendenceBasis R Subtype.val | If `s ⊆ t` are subsets in an `R`-algebra `A` such that `s` is algebraically independent over
`R`, and `A` is algebraic over the `R`-algebra generated by `t`, then there is a transcendence
basis of `A` over `R` between `s` and `t`, provided that `A` is a domain.
This may fail if only `R` is assumed to be a domain but `... | true |
galGroupBasis.match_1 | Mathlib.FieldTheory.KrullTopology | ∀ (K : Type u_2) (L : Type u_1) [inst : Field K] [inst_1 : Field L] [inst_2 : Algebra K L] {U : Set Gal(L/K)}
(motive : U ∈ (galBasis K L).sets → Prop) (x : U ∈ (galBasis K L).sets),
(∀ (H : Subgroup Gal(L/K)) (left : H ∈ fixedByFinite K L) (h2 : (fun g => g.carrier) H = U), motive ⋯) → motive x | null | false |
Language.reverse_mem_reverse | Mathlib.Computability.Language | ∀ {α : Type u_1} {l : Language α} {a : List α}, a.reverse ∈ l.reverse ↔ a ∈ l | null | true |
Finset.strongInduction._unsafe_rec | Mathlib.Data.Finset.Card | {α : Type u_1} →
{p : Finset α → Sort u_3} → ((s : Finset α) → ((t : Finset α) → t ⊂ s → p t) → p s) → (s : Finset α) → p s | null | false |
Subgroup.finiteIndex_of_finite | Mathlib.GroupTheory.Index | ∀ {G : Type u_1} [inst : Group G] {H : Subgroup G} [Finite G], H.FiniteIndex | null | true |
CategoryTheory.Limits.Pi.whiskerEquiv.eq_1 | Mathlib.CategoryTheory.Limits.Shapes.Products | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {J : Type u_1} {K : Type u_2} {f : J → C} {g : K → C}
(e : J ≃ K) (w : (j : J) → g (e j) ≅ f j) [inst_1 : CategoryTheory.Limits.HasProduct f]
[inst_2 : CategoryTheory.Limits.HasProduct g],
CategoryTheory.Limits.Pi.whiskerEquiv e w =
{
hom :=
... | null | true |
Equiv.prodPUnit._proof_2 | Mathlib.Logic.Equiv.Prod | ∀ (α : Type u_2), Function.RightInverse (fun a => (a, PUnit.unit)) fun p => p.1 | null | false |
CategoryTheory.Limits.FormalCoproduct.homPullbackEquiv._proof_8 | Mathlib.CategoryTheory.Limits.FormalCoproducts.Basic | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_3, u_1} C] {X Y Z : CategoryTheory.Limits.FormalCoproduct C}
(f : X ⟶ Z) (g : Y ⟶ Z)
(pb :
(i : Function.Pullback f.f g.f) →
CategoryTheory.Limits.PullbackCone (CategoryTheory.CategoryStruct.comp (f.φ (↑i).1) (CategoryTheory.eqToHom ⋯))
(g.φ (↑i)... | null | false |
_private.Init.Data.String.Lemmas.Order.0.String.Slice.Pos.ofSlice_next._simp_1_1 | Init.Data.String.Lemmas.Order | ∀ {s : String.Slice} {x y : s.Pos}, (x = y) = (x.offset = y.offset) | null | false |
Lean.Parser.Term.strictImplicitRightBracket | Lean.Parser.Term.Basic | Lean.Parser.Parser | null | true |
_private.Mathlib.Data.Analysis.Topology.0.Ctop.mem_nhds_toTopsp.match_1_3 | Mathlib.Data.Analysis.Topology | ∀ {α : Type u_2} {σ : Type u_1} (F : Ctop α σ) {s : Set α} {a : α} (motive : (∃ b, a ∈ F.f b ∧ F.f b ⊆ s) → Prop)
(x : ∃ b, a ∈ F.f b ∧ F.f b ⊆ s), (∀ (x : σ) (h : a ∈ F.f x ∧ F.f x ⊆ s), motive ⋯) → motive x | null | false |
QuadraticMap.restrictScalars | Mathlib.LinearAlgebra.QuadraticForm.Basic | {S : Type u_1} →
{R : Type u_3} →
{M : Type u_4} →
{N : Type u_5} →
[inst : CommSemiring R] →
[inst_1 : CommSemiring S] →
[inst_2 : AddCommMonoid M] →
[inst_3 : Module R M] →
[inst_4 : AddCommMonoid N] →
[inst_5 : Module R N] →
... | If `Q : M → N` is a quadratic map of `R`-modules and `R` is an `S`-algebra,
then the restriction of scalars is a quadratic map of `S`-modules. | true |
_private.Mathlib.Tactic.Linter.UnusedTactic.0.Mathlib.Linter.UnusedTactic.eraseUsedTactics.match_7 | Mathlib.Tactic.Linter.UnusedTactic | (motive : Lean.Elab.Info → Sort u_1) →
(i : Lean.Elab.Info) →
((i : Lean.Elab.TacticInfo) → motive (Lean.Elab.Info.ofTacticInfo i)) → ((x : Lean.Elab.Info) → motive x) → motive i | null | false |
_private.Batteries.Data.List.Basic.0.List.max!.match_1.eq_1 | Batteries.Data.List.Basic | ∀ {α : Type u_1} (motive : Option α → Sort u_2) (h_1 : Unit → motive none) (h_2 : (x : α) → motive (some x)),
(match none with
| none => h_1 ()
| some x => h_2 x) =
h_1 () | null | true |
CategoryTheory.bijection_natural | Mathlib.CategoryTheory.Monoidal.Closed.Ideal | ∀ {C : Type u₁} {D : Type u₂} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.Category.{v₁, u₂} D]
(i : CategoryTheory.Functor D C) [inst_2 : CategoryTheory.CartesianMonoidalCategory C]
[inst_3 : CategoryTheory.Reflective i] [inst_4 : CategoryTheory.MonoidalClosed C]
[inst_5 : CategoryTheory.... | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.