name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
SSet.Edge.mk._proof_2 | Mathlib.AlgebraicTopology.SimplicialSet.CompStruct | ∀ {X : SSet} {x₀ : X.obj (Opposite.op { len := 0 })} (edge : X.obj (Opposite.op { len := 1 })),
(CategoryTheory.ConcreteCategory.hom (CategoryTheory.SimplicialObject.δ X 1)) edge = x₀ →
(CategoryTheory.ConcreteCategory.hom
(((SSet.truncation 2).obj X).map
(SimplexCategory.Truncated.δ₂ 1 SSet... | null | false |
_private.Mathlib.CategoryTheory.Triangulated.SpectralObject.0.CategoryTheory.ComposableArrows.Precomp.map.match_1.splitter | Mathlib.CategoryTheory.Triangulated.SpectralObject | {n : ℕ} →
(motive : (x x_1 : Fin (n + 1 + 1)) → x ≤ x_1 → Sort u_1) →
(x x_1 : Fin (n + 1 + 1)) →
(x_2 : x ≤ x_1) →
((isLt isLt_1 : 0 < n + 1 + 1) → (x : ⟨0, isLt⟩ ≤ ⟨0, isLt_1⟩) → motive ⟨0, isLt⟩ ⟨0, isLt_1⟩ x) →
((isLt : 0 < n + 1 + 1) →
(isLt_1 : 1 < n + 1 + 1) → (x : ⟨0,... | null | true |
Std.ExtTreeMap.getElem!_erase_self | Std.Data.ExtTreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.ExtTreeMap α β cmp} [inst : Std.TransCmp cmp]
[inst_1 : Inhabited β] {k : α}, (t.erase k)[k]! = default | null | true |
MonoidHom.compLeftContinuousBounded | Mathlib.Topology.ContinuousMap.Bounded.Basic | {β : Type v} →
{γ : Type w} →
(α : Type u_3) →
[inst : TopologicalSpace α] →
[inst_1 : PseudoMetricSpace β] →
[inst_2 : Monoid β] →
[inst_3 : BoundedMul β] →
[inst_4 : ContinuousMul β] →
[inst_5 : PseudoMetricSpace γ] →
[inst_6 : ... | Composition on the left by a (lipschitz-continuous) homomorphism of topological monoids, as a
`MonoidHom`. Similar to `MonoidHom.compLeftContinuous`. | true |
rat_mul_continuous_lemma | Mathlib.Algebra.Order.CauSeq.Basic | ∀ {α : Type u_1} {β : Type u_2} [inst : Field α] [inst_1 : LinearOrder α] [IsStrictOrderedRing α] [inst_3 : Ring β]
(abv : β → α) [IsAbsoluteValue abv] {ε K₁ K₂ : α},
0 < ε →
∃ δ > 0,
∀ {a₁ a₂ b₁ b₂ : β},
abv a₁ < K₁ → abv b₂ < K₂ → abv (a₁ - b₁) < δ → abv (a₂ - b₂) < δ → abv (a₁ * a₂ - b₁ * b₂) <... | null | true |
AlgebraicGeometry.algΓAlgSpecAdjunction._proof_1 | Mathlib.AlgebraicGeometry.Group.Affine | ∀ (R : CommRingCat),
(((CategoryTheory.Over.post AlgebraicGeometry.Scheme.Γ.rightOp).comp
(CategoryTheory.Over.map (AlgebraicGeometry.ΓSpec.adjunction.counit.app (Opposite.op R)))).comp
((CategoryTheory.Over.opEquivOpUnder R).trans (commAlgCatEquivUnder R).op.symm).functor ⊣
((CategoryTheory... | null | false |
TypeVec.prod.fst.eq_2 | Mathlib.Data.TypeVec | ∀ (n : ℕ) (x_4 x_5 : TypeVec.{u} n.succ), TypeVec.prod.fst Fin2.fz = Prod.fst | null | true |
Std.Tactic.BVDecide.BVExpr.brecOn.go | Std.Tactic.BVDecide.Bitblast.BVExpr.Basic | {motive : (a : ℕ) → Std.Tactic.BVDecide.BVExpr a → Sort u} →
{a : ℕ} →
(t : Std.Tactic.BVDecide.BVExpr a) →
((a : ℕ) → (t : Std.Tactic.BVDecide.BVExpr a) → Std.Tactic.BVDecide.BVExpr.below t → motive a t) →
motive a t ×' Std.Tactic.BVDecide.BVExpr.below t | null | true |
ProbabilityTheory.CondIndepSets.iInter | Mathlib.Probability.Independence.Conditional | ∀ {Ω : Type u_1} {ι : Type u_2} {m' mΩ : MeasurableSpace Ω} [inst : StandardBorelSpace Ω] {hm' : m' ≤ mΩ}
{μ : MeasureTheory.Measure Ω} [inst_1 : MeasureTheory.IsFiniteMeasure μ] {s : ι → Set (Set Ω)} {s' : Set (Set Ω)},
(∃ n, ProbabilityTheory.CondIndepSets m' hm' (s n) s' μ) → ProbabilityTheory.CondIndepSets m' h... | null | true |
ProofWidgets.CancellableTask.mk.sizeOf_spec | ProofWidgets.Cancellable | ∀ (task : Task (Except Lean.Server.RequestError (ProofWidgets.LazyEncodable Lean.Json))) (cancel : IO Unit),
sizeOf { task := task, cancel := cancel } = 1 + sizeOf task | null | true |
HomologicalComplex.singleObjXSelf.eq_1 | Mathlib.Algebra.Homology.Additive | ∀ {V : Type u} [inst : CategoryTheory.Category.{v, u} V] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms V]
[inst_2 : CategoryTheory.Limits.HasZeroObject V] {ι : Type u_1} [inst_3 : DecidableEq ι] (c : ComplexShape ι) (j : ι)
(A : V), HomologicalComplex.singleObjXSelf c j A = HomologicalComplex.singleObjXIsoOfEq c... | null | true |
Function.LeftInverse.map_tprod | Mathlib.Topology.Algebra.InfiniteSum.Basic | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} [inst : CommMonoid α] [inst_1 : TopologicalSpace α]
{L : SummationFilter β} {G : Type u_4} (f : β → α) [inst_2 : CommMonoid γ] [inst_3 : TopologicalSpace γ] [T2Space γ]
{g : G} [inst_5 : FunLike G α γ] [MonoidHomClass G α γ],
Continuous ⇑g →
∀ {g' : γ → α}, Conti... | Special case of `Topology.IsClosedEmbedding.map_tprod`, logically weaker but possibly easier
to apply in practice. | true |
Std.DTreeMap.Internal.Impl.getKey_inter._proof_2 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u_1} {β : α → Type u_2} {instOrd : Ord α} {m₁ m₂ : Std.DTreeMap.Internal.Impl α β} [Std.TransOrd α]
(h₁ : m₁.WF),
m₂.WF →
∀ {k : α} {h_contains : Std.DTreeMap.Internal.Impl.contains k (m₁.inter m₂ ⋯) = true},
Std.DTreeMap.Internal.Impl.contains k m₁ = true | null | false |
Std.DTreeMap.Internal.Impl.mem_toArray_iff_get?_eq_some | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Std.DTreeMap.Internal.Impl α β} [Std.TransOrd α]
[inst : Std.LawfulEqOrd α] {k : α} {v : β k}, t.WF → (⟨k, v⟩ ∈ t.toArray ↔ t.get? k = some v) | null | true |
Monotone.const_nsmul | Mathlib.Algebra.Order.Monoid.Unbundled.Pow | ∀ {β : Type u_1} {M : Type u_3} [inst : AddMonoid M] [inst_1 : Preorder M] [inst_2 : Preorder β] [AddLeftMono M]
[AddRightMono M] {f : β → M}, Monotone f → ∀ (n : ℕ), Monotone fun a => n • f a | null | true |
CategoryTheory.GrothendieckTopology.OneHypercover.multiforkLift | Mathlib.CategoryTheory.Sites.Hypercover.One | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{A : Type u_1} →
[inst_1 : CategoryTheory.Category.{v_1, u_1} A] →
{J : CategoryTheory.GrothendieckTopology C} →
{S : C} →
{E : J.OneHypercover S} →
{F : CategoryTheory.Sheaf J A} →
(c : Ca... | Auxiliary definition of `isLimitMultifork`. | true |
Mathlib.Tactic.Echelon.RingOps.sub | Mathlib.Tactic.Echelon.Core | {V : Type} → Mathlib.Tactic.Echelon.RingOps V → V → V → V | Subtraction. | true |
UnitAddTorus.mFourierSubalgebra._proof_3 | Mathlib.Analysis.Fourier.AddCircleMulti | ContinuousConstSMul ℂ ℂ | null | false |
Module.Presentation.noConfusionType | Mathlib.Algebra.Module.Presentation.Basic | Sort u_1 →
{A : Type u} →
[inst : Ring A] →
{M : Type v} →
[inst_1 : AddCommGroup M] →
[inst_2 : Module A M] →
Module.Presentation A M →
{A' : Type u} →
[inst' : Ring A'] →
{M' : Type v} →
[inst'_1 : AddCommGro... | null | false |
NNRat.toNNRat_mono | Mathlib.Data.NNRat.Defs | Monotone Rat.toNNRat | null | true |
SeparationQuotient.instDistribMulAction | Mathlib.Topology.Algebra.SeparationQuotient.Basic | {M : Type u_1} →
{A : Type u_2} →
[inst : TopologicalSpace A] →
[inst_1 : Monoid M] →
[inst_2 : AddMonoid A] →
[inst_3 : DistribMulAction M A] →
[inst_4 : ContinuousAdd A] → [ContinuousConstSMul M A] → DistribMulAction M (SeparationQuotient A) | null | true |
Ideal.connectedComponentOfZero._proof_1 | Mathlib.Topology.Algebra.Ring.Ideal | ∀ (R : Type u_1) [inst : TopologicalSpace R] [inst_1 : Ring R] [IsTopologicalRing R], IsTopologicalAddGroup R | null | false |
_private.Lean.Meta.Tactic.Grind.ForallProp.0.Lean.Meta.Grind.getOrigin._sparseCasesOn_1 | Lean.Meta.Tactic.Grind.ForallProp | {motive : Lean.Expr → Sort u} →
(t : Lean.Expr) →
((fvarId : Lean.FVarId) → motive (Lean.Expr.fvar fvarId)) → (Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t | null | false |
and_or_left | Init.PropLemmas | ∀ {a b c : Prop}, a ∧ (b ∨ c) ↔ a ∧ b ∨ a ∧ c | `∧` distributes over `∨` (on the left). | true |
Dynamics.IsDynCoverOf.nonempty | Mathlib.Dynamics.TopologicalEntropy.CoverEntropy | ∀ {X : Type u_1} {T : X → X} {U : SetRel X X} {F s : Set X} {n : ℕ},
F.Nonempty → Dynamics.IsDynCoverOf T F U n s → s.Nonempty | null | true |
SimpleGraph.radius | Mathlib.Combinatorics.SimpleGraph.Diam | {α : Type u_1} → SimpleGraph α → ℕ∞ | The radius of a simple graph is the minimum eccentricity of any vertex. | true |
not_isMulTorsion_of_isMulTorsionFree | Mathlib.GroupTheory.Torsion | ∀ {G : Type u_1} [inst : CommGroup G] [Nontrivial G] [IsMulTorsionFree G], ¬IsMulTorsion G | A nontrivial torsion-free abelian group is not torsion. | true |
Lean.Elab.Tactic.ElabSimpArgResult.addEntries | Lean.Elab.Tactic.Simp | Array Lean.Meta.SimpEntry → Lean.Elab.Tactic.ElabSimpArgResult | null | true |
StructureGroupoid.LocalInvariantProp.liftPropAt_chart_symm | Mathlib.Geometry.Manifold.LocalInvariantProperties | ∀ {H : Type u_1} {M : Type u_2} [inst : TopologicalSpace H] [inst_1 : TopologicalSpace M] [inst_2 : ChartedSpace H M]
{G : StructureGroupoid H} {x : M} {Q : (H → H) → Set H → H → Prop} [HasGroupoid M G],
G.LocalInvariantProp G Q →
(∀ (y : H), Q id Set.univ y) → ChartedSpace.LiftPropAt Q (↑(chartAt H x).symm) (↑... | null | true |
_private.Lean.Meta.Tactic.Grind.Types.0.Lean.Meta.Grind.Solvers.propagateDiseqs.go.match_1.splitter | Lean.Meta.Tactic.Grind.Types | (motive : Lean.Meta.Grind.SolverTerms → Lean.Meta.Grind.SolverTerms → Sort u_1) →
(lhsTerms rhsTerms : Lean.Meta.Grind.SolverTerms) →
((x : Lean.Meta.Grind.SolverTerms) → motive Lean.Meta.Grind.SolverTerms.nil x) →
((x : Lean.Meta.Grind.SolverTerms) →
(x = Lean.Meta.Grind.SolverTerms.nil → False) ... | null | true |
Std.ExtTreeSet.get?_min? | Std.Data.ExtTreeSet.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t : Std.ExtTreeSet α cmp} [inst : Std.TransCmp cmp] {km : α},
t.min? = some km → t.get? km = some km | null | true |
IsTopologicalAddGroup.rightUniformSpace.eq_1 | Mathlib.Topology.Algebra.IsUniformGroup.Defs | ∀ (G : Type u_1) [inst : AddGroup G] [inst_1 : TopologicalSpace G] [inst_2 : IsTopologicalAddGroup G],
IsTopologicalAddGroup.rightUniformSpace G =
{ toTopologicalSpace := inst_1, uniformity := Filter.comap (fun p => p.2 + -p.1) (nhds 0), symm := ⋯, comp := ⋯,
nhds_eq_comap_uniformity := ⋯ } | null | true |
MonovaryOn.inv_right | Mathlib.Algebra.Order.Monovary | ∀ {ι : Type u_1} {α : Type u_2} {β : Type u_3} [inst : PartialOrder α] [inst_1 : CommGroup β] [inst_2 : PartialOrder β]
[IsOrderedMonoid β] {s : Set ι} {f : ι → α} {g : ι → β}, MonovaryOn f g s → AntivaryOn f g⁻¹ s | **Alias** of the reverse direction of `antivaryOn_inv_right`. | true |
GroupSeminorm.instLattice._proof_1 | Mathlib.Analysis.Normed.Group.Seminorm | ∀ {E : Type u_1} [inst : CommGroup E] (p q : GroupSeminorm E) (x : E), p x + q (x / x) ≤ p x | null | false |
Filter.instLawfulFunctor | Mathlib.Order.Filter.Map | LawfulFunctor Filter | null | true |
Commute.invOf_right | Mathlib.Algebra.Group.Invertible.Basic | ∀ {α : Type u} [inst : Monoid α] {a b : α} [inst_1 : Invertible b], Commute a b → Commute a ⅟b | null | true |
_private.Std.Http.Data.Body.Full.0.Std.Http.Body.Full.State.casesOn | Std.Http.Data.Body.Full | {motive : Std.Http.Body.Full.State✝ → Sort u} →
(t : Std.Http.Body.Full.State✝) →
motive Std.Http.Body.Full.State.ready✝ →
motive Std.Http.Body.Full.State.sent✝ → motive Std.Http.Body.Full.State.closed✝ → motive t | null | false |
CochainComplex.mappingCone.desc._proof_1 | Mathlib.Algebra.Homology.HomotopyCategory.MappingCone | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Preadditive C]
{F G : CochainComplex C ℤ} (φ : F ⟶ G) {K : CochainComplex C ℤ} (α : CochainComplex.HomComplex.Cochain F K (-1))
(β : G ⟶ K),
CochainComplex.HomComplex.δ (-1) 0 α =
CochainComplex.HomComplex.Cochain.ofHom ... | null | false |
Mathlib.Tactic.BicategoryLike.Normalize.Result.toNormalize | Mathlib.Tactic.CategoryTheory.Coherence.PureCoherence | Mathlib.Tactic.BicategoryLike.Normalize.Result → Mathlib.Tactic.BicategoryLike.Mor₂Iso | The 2-morphism from the original 1-morphism to the normalized 1-morphism. | true |
IncidenceAlgebra.mu_apply | Mathlib.Combinatorics.Enumerative.IncidenceAlgebra | ∀ {𝕜 : Type u_1} {α : Type u_4} [inst : AddCommGroup 𝕜] [inst_1 : One 𝕜] [inst_2 : Preorder α]
[inst_3 : LocallyFiniteOrder α] [inst_4 : DecidableEq α] (a b : α),
(IncidenceAlgebra.mu 𝕜) a b = if a = b then 1 else -∑ x ∈ Finset.Ico a b, (IncidenceAlgebra.mu 𝕜) a x | null | true |
_private.Init.Data.List.Lemmas.0.List.mem_filter._simp_1_2 | Init.Data.List.Lemmas | ∀ {a b c : Prop}, ((a ∨ b) ∧ c) = (a ∧ c ∨ b ∧ c) | null | false |
UniformSpace.toTopologicalSpace | Mathlib.Topology.UniformSpace.Defs | {α : Type u} → [self : UniformSpace α] → TopologicalSpace α | null | true |
AddAction.IsBlock.disjoint_vadd_set_vadd | Mathlib.GroupTheory.GroupAction.Blocks | ∀ {G : Type u_1} {X : Type u_2} [inst : VAdd G X] {B : Set X} {s : Set G} {g : G},
AddAction.IsBlock G B → ¬g +ᵥ B ⊆ s +ᵥ B → Disjoint (g +ᵥ B) (s +ᵥ B) | null | true |
WithLp.prod_inner_apply | Mathlib.Analysis.InnerProductSpace.ProdL2 | ∀ {𝕜 : Type u_1} {E : Type u_4} {F : Type u_5} [inst : RCLike 𝕜] [inst_1 : NormedAddCommGroup E]
[inst_2 : InnerProductSpace 𝕜 E] [inst_3 : NormedAddCommGroup F] [inst_4 : InnerProductSpace 𝕜 F]
(x y : WithLp 2 (E × F)), inner 𝕜 x y = inner 𝕜 x.ofLp.1 y.ofLp.1 + inner 𝕜 x.ofLp.2 y.ofLp.2 | null | true |
PSigma.fintypePropRight | Mathlib.Data.Fintype.Basic | {α : Type u_3} → {β : α → Prop} → [(a : α) → Decidable (β a)] → [Fintype α] → Fintype ((a : α) ×' β a) | null | true |
instUCompactlyGeneratedSpaceOfSequentialSpace | Mathlib.Topology.Compactness.CompactlyGeneratedSpace | ∀ {X : Type w} [tX : TopologicalSpace X] [SequentialSpace X], UCompactlyGeneratedSpace X | A sequential space is compactly generated.
The proof is taken from <https://ncatlab.org/nlab/files/StricklandCGHWSpaces.pdf>,
Proposition 1.6. | true |
HomotopicalAlgebra.PathObject.mk.noConfusion | Mathlib.AlgebraicTopology.ModelCategory.PathObject | {C : Type u} →
{inst : CategoryTheory.Category.{v, u} C} →
{inst_1 : HomotopicalAlgebra.CategoryWithWeakEquivalences C} →
{A : C} →
{P : Sort u_1} →
{toPrepathObject : HomotopicalAlgebra.PrepathObject A} →
{weakEquivalence_ι :
autoParam (HomotopicalAlgebra.WeakE... | null | false |
Nat.zeckendorf_sum_fib._f | Mathlib.Data.Nat.Fib.Zeckendorf | ∀ (x : List ℕ) (f : List.below (motive := fun x => x.IsZeckendorfRep → (List.map Nat.fib x).sum.zeckendorf = x) x),
x.IsZeckendorfRep → (List.map Nat.fib x).sum.zeckendorf = x | null | false |
CategoryTheory.regularTopology.mem_sieves_iff_hasEffectiveEpi | Mathlib.CategoryTheory.Sites.Coherent.RegularTopology | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Preregular C] {X : C}
(S : CategoryTheory.Sieve X),
S ∈ (CategoryTheory.regularTopology C) X ↔ ∃ Y π, CategoryTheory.EffectiveEpi π ∧ S.arrows π | A sieve is a cover for the regular topology if and only if it contains an `EffectiveEpi`. | true |
Set.Nonempty.fst | Mathlib.Data.Set.Prod | ∀ {α : Type u_1} {β : Type u_2} {s : Set α} {t : Set β}, (s ×ˢ t).Nonempty → s.Nonempty | null | true |
CommRingCat.instIsRightAdjointCommMonCatForget₂RingHomCarrierMonoidHomCarrier | Mathlib.Algebra.Category.Ring.Adjunctions | (CategoryTheory.forget₂ CommRingCat CommMonCat).IsRightAdjoint | null | true |
Lean.Elab.Tactic.Try.TrySuggestionEntry | Lean.Elab.Tactic.Try | Type | Entry in the try suggestion registry | true |
Finset.sort._auto_1 | Mathlib.Data.Finset.Sort | Lean.Syntax | null | false |
AddValuation.comap | Mathlib.RingTheory.Valuation.Basic | {R : Type u_3} →
{Γ₀ : Type u_4} →
[inst : Ring R] →
[inst_1 : LinearOrderedAddCommMonoidWithTop Γ₀] →
{S : Type u_6} → [inst_2 : Ring S] → (S →+* R) → AddValuation R Γ₀ → AddValuation S Γ₀ | A ring homomorphism `S → R` induces a map `AddValuation R Γ₀ → AddValuation S Γ₀`. | true |
GradedAlgHom.liftEquiv._proof_3 | Mathlib.RingTheory.GradedAlgebra.TensorProduct | ∀ {ι : Type u_5} {R : Type u_4} {S : Type u_2} {A : Type u_3} {B : Type u_1} [inst : DecidableEq ι]
[inst_1 : AddMonoid ι] [inst_2 : CommSemiring R] [inst_3 : CommSemiring S] [inst_4 : Semiring A] [inst_5 : Semiring B]
[inst_6 : Algebra R A] [inst_7 : Algebra S B] (𝒜 : ι → Submodule R A) (ℬ : ι → Submodule S B)
... | null | false |
IsQuotientCoveringMap.fiberEquivGroup._proof_1 | Mathlib.Topology.Covering.Quotient | ∀ {E : Type u_3} {X : Type u_1} [inst : TopologicalSpace E] [inst_1 : TopologicalSpace X] {f : E → X} {G : Type u_2}
[inst_2 : Group G] [inst_3 : MulAction G E],
IsQuotientCoveringMap f G → ∀ {x : X} (e : ↑(f ⁻¹' {x})) (g : G), f (g • ↑e) = x | null | false |
_private.Mathlib.AlgebraicGeometry.EllipticCurve.Jacobian.Formula.0.WeierstrassCurve.Jacobian.addZ_smul._simp_1_3 | Mathlib.AlgebraicGeometry.EllipticCurve.Jacobian.Formula | ∀ {R : Type r} [inst : CommRing R] (P : Fin 3 → R) (u : R), (u • P) 1 = u ^ 3 * P 1 | null | false |
Lean.LocalDecl | Lean.LocalContext | Type | A declaration for a `LocalContext`. This is used to register which free variables are in scope.
See `LocalDecl.index`, `LocalDecl.fvarId`, `LocalDecl.userName`, `LocalDecl.type` for accessors for
arguments common to both constructors.
| true |
ContDiffAt.fst' | Mathlib.Analysis.Calculus.ContDiff.Comp | ∀ {𝕜 : Type u_1} {E : Type u_2} {F : Type u_3} {G : Type u_4} [inst : NontriviallyNormedField 𝕜]
[inst_1 : NormedAddCommGroup E] [inst_2 : NormedSpace 𝕜 E] [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F]
[inst_5 : NormedAddCommGroup G] [inst_6 : NormedSpace 𝕜 G] {n : WithTop ℕ∞} {f : E → G} {x : E} ... | Precomposing `f` with `Prod.fst` is `C^n` at `(x, y)` | true |
Matrix.invertibleEquivFromBlocks₂₂Invertible._proof_2 | Mathlib.LinearAlgebra.Matrix.SchurComplement | ∀ {m : Type u_1} {n : Type u_3} {α : Type u_2} [inst : Fintype m] [inst_1 : Fintype n] [inst_2 : DecidableEq m]
[inst_3 : DecidableEq n] [inst_4 : CommRing α] (A : Matrix m m α) (B : Matrix m n α) (C : Matrix n m α)
(D : Matrix n n α) [inst_5 : Invertible D] (_i_schur : Invertible (A - B * ⅟D * C)),
A.invertibleO... | null | false |
AddSubgroup.zsmul | Mathlib.Algebra.Group.Subgroup.Defs | {G : Type u_1} → [inst : AddGroup G] → (H : AddSubgroup G) → SMul ℤ ↥H | An `AddSubgroup` of an `AddGroup` inherits an integer scaling. | true |
Lean.MonadRuntimeException.noConfusion | Lean.CoreM | {P : Sort u} →
{m : Type → Type} →
{t : Lean.MonadRuntimeException m} →
{m' : Type → Type} →
{t' : Lean.MonadRuntimeException m'} → m = m' → t ≍ t' → Lean.MonadRuntimeException.noConfusionType P t t' | null | false |
Subgroup.quotientCentralizerEmbedding._proof_1 | Mathlib.GroupTheory.GroupAction.Quotient | ∀ {G : Type u_1} [inst : Group G] (g : G) (x : ↑(MulAction.orbit (ConjAct G) g)), ↑x * g⁻¹ ∈ commutatorSet G | null | false |
NzsNum.msb.inj | Mathlib.Data.Num.Bitwise | ∀ {a a_1 : Bool}, NzsNum.msb a = NzsNum.msb a_1 → a = a_1 | null | true |
signedDist._proof_4 | Mathlib.Geometry.Euclidean.SignedDist | ∀ {V : Type u_1} {P : Type u_2} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V] [inst_2 : MetricSpace P]
[inst_3 : NormedAddTorsor V P] (v : V) (p : P) (v' : V),
((innerSL ℝ) (NormedSpace.normalize v)).toContinuousAffineMap.comp
(ContinuousAffineMap.id ℝ P -ᵥ ContinuousAffineMap.const ℝ P (v' +... | null | false |
NonUnitalStarRingHom.copy | Mathlib.Algebra.Star.StarRingHom | {A : Type u_1} →
{B : Type u_2} →
[inst : NonUnitalNonAssocSemiring A] →
[inst_1 : Star A] →
[inst_2 : NonUnitalNonAssocSemiring B] →
[inst_3 : Star B] → (f : A →⋆ₙ+* B) → (f' : A → B) → f' = ⇑f → A →⋆ₙ+* B | Copy of a `NonUnitalStarRingHom` with a new `toFun` equal to the old one. Useful
to fix definitional equalities. | true |
Submodule.basisOfPidOfLE | Mathlib.LinearAlgebra.FreeModule.PID | {R : Type u_2} →
[inst : CommRing R] →
{M : Type u_3} →
[inst_1 : AddCommGroup M] →
[inst_2 : Module R M] →
[IsPrincipalIdealRing R] →
[IsDomain R] →
{ι : Type u_4} →
[Finite ι] → {N O : Submodule R M} → N ≤ O → Module.Basis ι R ↥O → (n : ℕ) × Modu... | A submodule inside a free `R`-submodule of finite rank is also a free `R`-module of finite rank,
if `R` is a principal ideal domain.
See also the stronger version `Submodule.smithNormalFormOfLE`.
| true |
_private.Lean.Elab.ConfigEval.DeriveEvalExpr.0.Lean.Elab.ConfigEval.deriveEvalExprUsingMetaEval.match_1 | Lean.Elab.ConfigEval.DeriveEvalExpr | (motive : Lean.Expr → Sort u_1) →
(type : Lean.Expr) →
((typeName : Lean.Name) → motive (Lean.Expr.const typeName [])) → ((x : Lean.Expr) → motive x) → motive type | null | false |
CategoryTheory.Functor.mapHomologicalComplex._proof_2 | Mathlib.Algebra.Homology.Additive | ∀ {ι : Type u_5} {W₁ : Type u_4} {W₂ : Type u_2} [inst : CategoryTheory.Category.{u_3, u_4} W₁]
[inst_1 : CategoryTheory.Category.{u_1, u_2} W₂] [inst_2 : CategoryTheory.Limits.HasZeroMorphisms W₁]
[inst_3 : CategoryTheory.Limits.HasZeroMorphisms W₂] (F : CategoryTheory.Functor W₁ W₂) [F.PreservesZeroMorphisms]
(... | null | false |
Array.eraseIdx.congr_simp | Init.Data.Array.Basic | ∀ {α : Type u} (xs xs_1 : Array α) (e_xs : xs = xs_1) (i i_1 : ℕ) (e_i : i = i_1) (h : i < xs.size),
xs.eraseIdx i h = xs_1.eraseIdx i_1 ⋯ | null | true |
Finset.mul_prod_erase | Mathlib.Algebra.BigOperators.Group.Finset.Basic | ∀ {ι : Type u_1} {M : Type u_4} [inst : CommMonoid M] [inst_1 : DecidableEq ι] (s : Finset ι) (f : ι → M) {a : ι},
a ∈ s → f a * ∏ x ∈ s.erase a, f x = ∏ x ∈ s, f x | Taking a product over `s : Finset ι` is the same as multiplying the value on a single element
`f a` by the product of `s.erase a`.
See `Multiset.prod_map_erase` for the `Multiset` version. | true |
ProbabilityTheory.Kernel.iIndepFun.iIndep | Mathlib.Probability.Independence.Kernel.IndepFun | ∀ {α : Type u_1} {Ω : Type u_2} {ι : Type u_3} {β : ι → Type u_8} {mβ : (i : ι) → MeasurableSpace (β i)}
{_mα : MeasurableSpace α} {_mΩ : MeasurableSpace Ω} {κ : ProbabilityTheory.Kernel α Ω} {μ : MeasureTheory.Measure α}
{f : (x : ι) → Ω → β x},
ProbabilityTheory.Kernel.iIndepFun f κ μ →
ProbabilityTheory.Ke... | null | true |
DFinsupp.filter_single_pos | Mathlib.Data.DFinsupp.Defs | ∀ {ι : Type u} {β : ι → Type v} [inst : (i : ι) → Zero (β i)] [inst_1 : DecidableEq ι] {p : ι → Prop}
[inst_2 : DecidablePred p] (i : ι) (x : β i), p i → (DFinsupp.filter p fun₀ | i => x) = fun₀ | i => x | null | true |
Std.DHashMap.Raw.inter | Std.Data.DHashMap.Raw | {α : Type u} →
{β : α → Type v} → [BEq α] → [Hashable α] → Std.DHashMap.Raw α β → Std.DHashMap.Raw α β → Std.DHashMap.Raw α β | Computes the intersection of the given hash maps. The result will only contain entries from the first map.
This function always merges the smaller map into the larger map, so the expected runtime is
`O(min(m₁.size, m₂.size))`.
| true |
isMinOn_Ioo_of_deriv | Mathlib.Analysis.Calculus.DerivativeTest | ∀ {f : ℝ → ℝ} {a b c : ℝ},
ContinuousAt f b →
DifferentiableOn ℝ f (Set.Ioo a b) →
DifferentiableOn ℝ f (Set.Ioo b c) →
(∀ x ∈ Set.Ioo a b, deriv f x ≤ 0) → (∀ x ∈ Set.Ioo b c, 0 ≤ deriv f x) → IsMinOn f (Set.Ioo a c) b | Suppose `f : ℝ → ℝ` is continuous at `b`, the derivative `f'` is nonpositive on `Ioo a b` and
nonnegative on `Ioo b c`. Then `f` attains its minimum on `Ioo a c` at `b`. | true |
_private.ImportGraph.WorkspaceModel.Build.0.ImportGraph.WorkspaceModel.InferredLibraryGlob.hasRoot_or_hasDir | ImportGraph.WorkspaceModel.Build | ∀ (self : ImportGraph.WorkspaceModel.InferredLibraryGlob✝),
(ImportGraph.WorkspaceModel.InferredLibraryGlob.hasRoot✝ self ||
ImportGraph.WorkspaceModel.InferredLibraryGlob.hasDir✝ self) =
true | If we've recorded it, it better have at least one of these. | true |
algEquivEquivAlgHom | Mathlib.RingTheory.Algebraic.Integral | (K : Type u_1) →
(L : Type u_2) →
[inst : Field K] → [inst_1 : Field L] → [inst_2 : Algebra K L] → [FiniteDimensional K L] → Gal(L/K) ≃* (L →ₐ[K] L) | Bijection between algebra equivalences and algebra homomorphisms | true |
_private.Mathlib.Analysis.Meromorphic.FactorizedRational.0.Function.FactorizedRational.mulSupport._simp_1_1 | Mathlib.Analysis.Meromorphic.FactorizedRational | ∀ {ι : Type u_1} {M : Type u_3} [inst : One M] {f : ι → M} {x : ι}, (x ∈ Function.mulSupport f) = (f x ≠ 1) | null | false |
HomologicalComplex₂.XXIsoOfEq_inv_ιTotal._proof_1 | Mathlib.Algebra.Homology.TotalComplex | ∀ {I₁ : Type u_2} {I₂ : Type u_3} {I₁₂ : Type u_1} {c₁ : ComplexShape I₁} {c₂ : ComplexShape I₂}
(c₁₂ : ComplexShape I₁₂) [inst : TotalComplexShape c₁ c₂ c₁₂] {x₁ y₁ : I₁},
x₁ = y₁ → ∀ {x₂ y₂ : I₂}, x₂ = y₂ → ∀ (i₁₂ : I₁₂), c₁.π c₂ c₁₂ (x₁, x₂) = i₁₂ → c₁.π c₂ c₁₂ (y₁, y₂) = i₁₂ | null | false |
conjneg_add | Mathlib.Algebra.Star.Conjneg | ∀ {G : Type u_2} {R : Type u_3} [inst : AddGroup G] [inst_1 : CommSemiring R] [inst_2 : StarRing R] (f g : G → R),
conjneg (f + g) = conjneg f + conjneg g | null | true |
Aesop.ForwardRuleMatch.recOn | Aesop.Forward.Match.Types | {motive : Aesop.ForwardRuleMatch → Sort u} →
(t : Aesop.ForwardRuleMatch) →
((rule : Aesop.ForwardRule) → («match» : Aesop.CompleteMatch) → motive { rule := rule, «match» := «match» }) →
motive t | null | false |
CategoryTheory.algebraEquivUnder._proof_7 | Mathlib.CategoryTheory.Monad.Products | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] (X : C)
[inst_1 : CategoryTheory.Limits.HasBinaryCoproducts C] (f : CategoryTheory.Under X),
CategoryTheory.CategoryStruct.comp
(((CategoryTheory.underToAlgebra X).comp (CategoryTheory.algebraToUnder X)).obj f).hom
(CategoryTheory.Iso.refl
... | null | false |
CategoryTheory.Arrow.AugmentedCechNerve.extraDegeneracy._proof_1 | Mathlib.AlgebraicTopology.ExtraDegeneracy | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] (f : CategoryTheory.Arrow C)
(j : Fin ((Opposite.unop (Opposite.op { len := 0 })).len + 1)),
CategoryTheory.CategoryStruct.comp (CategoryTheory.CategoryStruct.id f.left) f.hom = f.hom | null | false |
CategoryTheory.ObjectProperty.instNonemptyOfIsClosedUnderLimitsOfShapeDiscretePEmptyOfHasTerminal | Mathlib.CategoryTheory.ObjectProperty.FiniteProducts | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] (P : CategoryTheory.ObjectProperty C)
[P.IsClosedUnderLimitsOfShape (CategoryTheory.Discrete PEmpty.{1})] [CategoryTheory.Limits.HasTerminal C], P.Nonempty | null | true |
mdifferentiableWithinAt_congr | Mathlib.Geometry.Manifold.MFDeriv.Basic | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {H : Type u_3} [inst_3 : TopologicalSpace H] {I : ModelWithCorners 𝕜 E H} {M : Type u_4}
[inst_4 : TopologicalSpace M] [inst_5 : ChartedSpace H M] {E' : Type u_5} [inst_6 : NormedAddComm... | null | true |
Subalgebra.iSupLift_comp_inclusion | Mathlib.Algebra.Algebra.Subalgebra.Directed | ∀ {R : Type u_1} {A : Type u_2} {B : Type u_3} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A]
[inst_3 : Semiring B] [inst_4 : Algebra R B] {ι : Type u_4} [inst_5 : Nonempty ι] (K : ι → Subalgebra R A)
{dir : Directed (fun x1 x2 => x1 ≤ x2) K} {f : (i : ι) → ↥(K i) →ₐ[R] B}
{hf : ∀ (i j : ι) ... | null | true |
CategoryTheory.ComposableArrows.map'._proof_8 | Mathlib.CategoryTheory.ComposableArrows.Basic | ∀ {n : ℕ} (j : ℕ), autoParam (j ≤ n) CategoryTheory.ComposableArrows.map'._auto_3 → j < n + 1 | null | false |
Homogenization.congr._proof_4 | Mathlib.LinearAlgebra.AffineSpace.Homogenization | ∀ {R : Type u_1} [inst : Ring R], RingHomCompTriple (RingHom.id R) (RingHom.id R) (RingHom.id R) | null | false |
HahnSeries.coeff_mul_left' | Mathlib.RingTheory.HahnSeries.Multiplication | ∀ {Γ : Type u_1} {R : Type u_3} [inst : AddCommMonoid Γ] [inst_1 : PartialOrder Γ] [inst_2 : IsOrderedCancelAddMonoid Γ]
[inst_3 : NonUnitalNonAssocSemiring R] {x y : HahnSeries Γ R} {a : Γ} {s : Set Γ} (hs : s.IsPWO),
x.support ⊆ s → (x * y).coeff a = ∑ ij ∈ Finset.antidiagonal hs ⋯ a, x.coeff ij.1 * y.coeff ij.2 | null | true |
Set.smul_set_eq_univ | Mathlib.Algebra.Group.Action.Pointwise.Set.Basic | ∀ {α : Type u_2} {β : Type u_3} [inst : Group α] [inst_1 : MulAction α β] {s : Set β} {a : α},
a • s = Set.univ ↔ s = Set.univ | null | true |
Cardinal.isEquivalent._proof_1 | Mathlib.SetTheory.Cardinal.Defs | Equivalence fun α β => Nonempty (α ≃ β) | null | false |
lt_of_forall_ge_imp_ne | Mathlib.Order.Basic | ∀ {α : Type u_2} [inst : LinearOrder α] {a b : α}, (∀ (c : α), a ≤ c → c ≠ b) → b < a | null | true |
Std.Time.PlainDateTime.hour | Std.Time.DateTime.PlainDateTime | Std.Time.PlainDateTime → Std.Time.Hour.Ordinal | Getter for the `Hour` inside of a `PlainDateTime`.
| true |
_private.Mathlib.Data.Ordmap.Ordnode.0.Ordnode.ofAscListAux₁.match_5._arg_pusher | Mathlib.Data.Ordmap.Ordnode | ∀ {α : Type u_1} (motive : List α → Sort u_2) (α_1 : Sort u✝) (β : α_1 → Sort v✝) (f : (x : α_1) → β x)
(rel : List α → α_1 → Prop) (x : List α) (h_1 : Unit → ((y : α_1) → rel [] y → β y) → motive [])
(h_2 : (x : α) → (xs : List α) → ((y : α_1) → rel (x :: xs) y → β y) → motive (x :: xs)),
((match (motive := (x :... | null | false |
Lean.Elab.Term.instBEqPostponeBehavior.beq | Lean.Elab.SyntheticMVars | Lean.Elab.Term.PostponeBehavior → Lean.Elab.Term.PostponeBehavior → Bool | null | true |
RootPairing.restrictScalars'._proof_9 | Mathlib.LinearAlgebra.RootSystem.BaseChange | ∀ {L : Type u_1} [inst : Field L] (K : Type u_2) [inst_1 : Field K] [inst_2 : Algebra K L], SMulCommClass L K L | null | false |
ProbabilityTheory.Kernel.instIsFiniteKernelProdParallelComp | Mathlib.Probability.Kernel.Composition.ParallelComp | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} {δ : Type u_4} {mα : MeasurableSpace α} {mβ : MeasurableSpace β}
{mγ : MeasurableSpace γ} {mδ : MeasurableSpace δ} {κ : ProbabilityTheory.Kernel α β}
{η : ProbabilityTheory.Kernel γ δ} [ProbabilityTheory.IsFiniteKernel κ] [ProbabilityTheory.IsFiniteKernel η],
Probabi... | null | true |
_private.Mathlib.RingTheory.Spectrum.Maximal.Defs.0.MaximalSpectrum.ext.match_1 | Mathlib.RingTheory.Spectrum.Maximal.Defs | ∀ {R : Type u_1} {inst : CommSemiring R} (motive : MaximalSpectrum R → Prop) (h : MaximalSpectrum R),
(∀ (asIdeal : Ideal R) (isMaximal : asIdeal.IsMaximal), motive { asIdeal := asIdeal, isMaximal := isMaximal }) →
motive h | null | false |
Std.CancellationToken.Consumer.rec | Std.Sync.CancellationToken | {motive : Std.CancellationToken.Consumer → Sort u} →
((promise : IO.Promise Unit) → motive (Std.CancellationToken.Consumer.normal promise)) →
((finished : Std.Async.Waiter Unit) → motive (Std.CancellationToken.Consumer.select finished)) →
(t : Std.CancellationToken.Consumer) → motive t | null | false |
_private.Mathlib.AlgebraicGeometry.EllipticCurve.Jacobian.Basic.0._aux_Mathlib_AlgebraicGeometry_EllipticCurve_Jacobian_Basic___macroRules__private_Mathlib_AlgebraicGeometry_EllipticCurve_Jacobian_Basic_0_termZ_1 | Mathlib.AlgebraicGeometry.EllipticCurve.Jacobian.Basic | Lean.Macro | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.