name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
measurable_from_top | Mathlib.MeasureTheory.MeasurableSpace.Basic | ∀ {α : Type u_1} {β : Type u_2} [inst : MeasurableSpace β] {f : α → β}, Measurable f | null | true |
_private.Mathlib.Lean.MessageData.ForExprs.0.Lean.MessageData.forExprsIn.goFmt | Mathlib.Lean.MessageData.ForExprs | {m : Type → Type u} →
[Monad m] →
{σ : Type} →
(Lean.PPContext × Lean.Expr → σ → m (ForInStep σ)) →
Lean.PPContext → Lean.PrettyPrinter.InfoPerPos → σ → Std.Format → m (ForInStep σ) | Iterate over the tags of a `Format` using `f`. | true |
Denumerable.lower.eq_2 | Mathlib.Logic.Equiv.Multiset | ∀ (x m : ℕ) (l : List ℕ), Denumerable.lower (m :: l) x = (m - x) :: Denumerable.lower l m | null | true |
compl_sSup' | Mathlib.Order.CompleteBooleanAlgebra | ∀ {α : Type u} [inst : CompleteBooleanAlgebra α] {s : Set α}, (sSup s)ᶜ = sInf (compl '' s) | null | true |
UniformEquiv.prodPUnit._proof_1 | Mathlib.Topology.UniformSpace.Equiv | ∀ (α : Type u_1) [inst : UniformSpace α], UniformContinuous fun a => (id a, PUnit.unit) | null | false |
LightCondMod.instReflectsEpimorphismsLightCondSetForget | Mathlib.Condensed.Light.Epi | ∀ (R : Type u) [inst : Ring R], (LightCondensed.forget R).ReflectsEpimorphisms | null | true |
groupCohomology.dArrowIso₀₁._proof_1 | Mathlib.RepresentationTheory.Homological.GroupCohomology.LowDegree | IsRightCancelAdd ℕ | null | false |
HomologicalComplex₂.ofGradedObject_d_f | Mathlib.Algebra.Homology.HomologicalBicomplex | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{I₁ : Type u_2} {I₂ : Type u_3} (c₁ : ComplexShape I₁) (c₂ : ComplexShape I₂)
(X : CategoryTheory.GradedObject (I₁ × I₂) C) (d₁ : (i₁ i₁' : I₁) → (i₂ : I₂) → X (i₁, i₂) ⟶ X (i₁', i₂))
(d₂ : (i₁ : I₁)... | null | true |
ContinuousAddEquiv.mk.inj | Mathlib.Topology.Algebra.ContinuousMonoidHom | ∀ {G : Type u} {inst : TopologicalSpace G} {H : Type v} {inst_1 : TopologicalSpace H} {inst_2 : Add G} {inst_3 : Add H}
{toAddEquiv : G ≃+ H}
{continuous_toFun : autoParam (Continuous toAddEquiv.toFun) Homeomorph.continuous_toFun._autoParam}
{continuous_invFun : autoParam (Continuous toAddEquiv.invFun) Homeomorph... | null | true |
CategoryTheory.Limits.FormalCoproduct.category._proof_6 | Mathlib.CategoryTheory.Limits.FormalCoproducts.Basic | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_3, u_2} C] {W X Y Z : CategoryTheory.Limits.FormalCoproduct C}
(f : W.Hom X) (g : X.Hom Y) (h : Y.Hom Z),
{ f := h.f ∘ { f := g.f ∘ f.f, φ := fun x => CategoryTheory.CategoryStruct.comp (f.φ x) (g.φ (f.f x)) }.f,
φ := fun x =>
CategoryTheory.Category... | null | false |
SheafOfModules.pushforwardNatIso | Mathlib.Algebra.Category.ModuleCat.Sheaf.PushforwardContinuous | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{D : Type u₂} →
[inst_1 : CategoryTheory.Category.{v₂, u₂} D] →
{J : CategoryTheory.GrothendieckTopology C} →
{K : CategoryTheory.GrothendieckTopology D} →
{F G : CategoryTheory.Functor C D} →
{T : Cate... | A natural isomorphism gives a natural isomorphism between the pushforward functors. | true |
Int8.shiftRight_and | Init.Data.SInt.Bitwise | ∀ {a b c : Int8}, (a &&& b) >>> c = a >>> c &&& b >>> c | null | true |
BoxIntegral.unitPartition.mem_box_iff_index | Mathlib.Analysis.BoxIntegral.UnitPartition | ∀ {ι : Type u_1} {n : ℕ} [inst : NeZero n] {x : ι → ℝ} {ν : ι → ℤ},
x ∈ BoxIntegral.unitPartition.box n ν ↔ BoxIntegral.unitPartition.index n x = ν | null | true |
CategoryTheory.Limits.preservesColimitsOfSize_shrink | Mathlib.CategoryTheory.Limits.Preserves.Basic | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
(F : CategoryTheory.Functor C D)
[CategoryTheory.Limits.PreservesColimitsOfSize.{max w w₂, max w' w₂', v₁, v₂, u₁, u₂} F],
CategoryTheory.Limits.PreservesColimitsOfSize.{w, w', v₁, v₂, u₁, u₂} F | `PreservesColimitsOfSize_shrink.{w w'} F` tries to obtain `PreservesColimitsOfSize.{w w'} F`
from some other `PreservesColimitsOfSize F`.
| true |
_private.Mathlib.Topology.UniformSpace.UniformConvergenceTopology.0.UniformOnFun.instCompleteSpace._simp_2 | Mathlib.Topology.UniformSpace.UniformConvergenceTopology | ∀ {α : Type u} {s : Set α} {f : Filter α}, (f ≤ Filter.principal s) = (s ∈ f) | null | false |
_private.Mathlib.Analysis.CStarAlgebra.PositiveLinearFunctional.0.PositiveContinuousLinearMap.tendsto_nhds_opNorm._proof_1_1 | Mathlib.Analysis.CStarAlgebra.PositiveLinearFunctional | ∀ {A : Type u_1} [inst : NonUnitalCStarAlgebra A] [inst_1 : PartialOrder A] (f : A →P[ℂ] ℂ), Continuous f.toFun | null | false |
Std.TreeSet.Raw.max?_eq_some_maxD | Std.Data.TreeSet.Raw.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t : Std.TreeSet.Raw α cmp} [Std.TransCmp cmp],
t.WF → t.isEmpty = false → ∀ {fallback : α}, t.max? = some (t.maxD fallback) | null | true |
HomologicalComplex.opFunctor._proof_2 | Mathlib.Algebra.Homology.Opposite | ∀ {ι : Type u_1} (V : Type u_2) [inst : CategoryTheory.Category.{u_3, u_2} V] (c : ComplexShape ι)
[inst_1 : CategoryTheory.Limits.HasZeroMorphisms V] (X : (HomologicalComplex V c)ᵒᵖ),
{ f := fun i => ((CategoryTheory.CategoryStruct.id X).unop.f i).op, comm' := ⋯ } =
CategoryTheory.CategoryStruct.id (Opposite.u... | null | false |
ValuativeRel.IsNontrivial.condition | Mathlib.RingTheory.Valuation.ValuativeRel.Basic | ∀ {R : Type u_1} {inst : Semiring R} {inst_1 : ValuativeRel R} [self : ValuativeRel.IsNontrivial R], ∃ γ, γ ≠ 0 ∧ γ ≠ 1 | null | true |
_private.Lean.Compiler.LCNF.FixedParams.0.Lean.Compiler.LCNF.FixedParams.isEquivalentFunDecl?.match_3 | Lean.Compiler.LCNF.FixedParams | (motive : Lean.Compiler.LCNF.Code Lean.Compiler.LCNF.Purity.pure → Sort u_1) →
(k : Lean.Compiler.LCNF.Code Lean.Compiler.LCNF.Purity.pure) →
((retFVarId : Lean.FVarId) → motive (Lean.Compiler.LCNF.Code.return retFVarId)) →
((x : Lean.Compiler.LCNF.Code Lean.Compiler.LCNF.Purity.pure) → motive x) → motive k | null | false |
LinearMap.IsOrthoᵢ.nondegenerate_of_not_isOrtho_basis_self | Mathlib.LinearAlgebra.SesquilinearForm.Basic | ∀ {n : Type u_19} {R : Type u_20} {M : Type u_21} {M₁ : Type u_22} [inst : CommSemiring R] [inst_1 : AddCommMonoid M]
[inst_2 : AddCommMonoid M₁] [inst_3 : Module R M] [inst_4 : Module R M₁] [IsDomain R] [Module.IsTorsionFree R M₁]
{B : M →ₗ[R] M →ₗ[R] M₁} (v : Module.Basis n R M), B.IsOrthoᵢ ⇑v → (∀ (i : n), (B (v... | Given an orthogonal basis with respect to a bilinear map, the bilinear map is nondegenerate
if the basis has no elements which are self-orthogonal. | true |
MonoidHom.transfer._proof_2 | Mathlib.GroupTheory.Transfer | ∀ {G : Type u_2} [inst : Group G] {H : Subgroup G} {A : Type u_1} [inst_1 : CommGroup A] (ϕ : ↥H →* A)
[inst_2 : H.FiniteIndex] (g h : G),
Subgroup.leftTransversals.diff ϕ default ((g * h) • default) =
Subgroup.leftTransversals.diff ϕ default (g • default) * Subgroup.leftTransversals.diff ϕ default (h • default... | null | false |
_private.Mathlib.Order.Monotone.Basic.0.StrictMono.isMin_of_apply.match_1_1 | Mathlib.Order.Monotone.Basic | ∀ {α : Type u_1} [inst : Preorder α] {a : α} (motive : (∃ b, b < a) → Prop) (x : ∃ b, b < a),
(∀ (w : α) (hb : w < a), motive ⋯) → motive x | null | false |
CompareReals.instCommRingQ._aux_36 | Mathlib.Topology.UniformSpace.CompareReals | ℤ → CompareReals.Q → CompareReals.Q | null | false |
_private.Std.Sat.AIG.RefVecOperator.Map.0.Std.Sat.AIG.RefVec.map.go_get_aux._proof_1_1 | Std.Sat.AIG.RefVecOperator.Map | ∀ {α : Type} [inst : Hashable α] [inst_1 : DecidableEq α] {len : ℕ} {aig : Std.Sat.AIG α} (curr : ℕ)
(s : aig.RefVec curr) (input : aig.RefVec len) (f : (aig : Std.Sat.AIG α) → aig.Ref → Std.Sat.AIG.Entrypoint α)
[inst_2 : Std.Sat.AIG.LawfulOperator α Std.Sat.AIG.Ref f] [Std.Sat.AIG.RefVec.LawfulMapOperator α f],
... | null | false |
MeasureTheory.AEEqFun.coeFn_smul | Mathlib.MeasureTheory.Function.AEEqFun | ∀ {α : Type u_1} {γ : Type u_3} [inst : MeasurableSpace α] {μ : MeasureTheory.Measure α} [inst_1 : TopologicalSpace γ]
{𝕜 : Type u_5} [inst_2 : SMul 𝕜 γ] [inst_3 : ContinuousConstSMul 𝕜 γ] (c : 𝕜) (f : α →ₘ[μ] γ), ↑(c • f) =ᵐ[μ] c • ↑f | null | true |
UpperHalfPlane.smulFDeriv | Mathlib.Analysis.Complex.UpperHalfPlane.Manifold | GL (Fin 2) ℝ → ℂ → ℂ →L[ℝ] ℂ | `ℝ`-linear map from `ℂ` to itself, which we shall show is the real derivative of the
`GL(2, ℝ)`-action on `ℍ`. | true |
Orientation.oangle.eq_1 | Mathlib.Geometry.Euclidean.Angle.Oriented.Basic | ∀ {V : Type u_1} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V] [inst_2 : Fact (Module.finrank ℝ V = 2)]
(o : Orientation ℝ V (Fin 2)) (x y : V), o.oangle x y = ↑((o.kahler x) y).arg | null | true |
nonempty_commRing_iff | Mathlib.SetTheory.Cardinal.Free | ∀ (α : Type u), Nonempty (CommRing α) ↔ Nonempty α | null | true |
Polynomial.eval₂RingHom'._proof_1 | Mathlib.Algebra.Polynomial.Eval.Defs | ∀ {R : Type u_1} {S : Type u_2} [inst : Semiring R] [inst_1 : Semiring S] (f : R →+* S) (x : S),
(∀ (a : R), Commute (f a) x) →
∀ (_p q : Polynomial R), Polynomial.eval₂ f x (_p * q) = Polynomial.eval₂ f x _p * Polynomial.eval₂ f x q | null | false |
Dynamics.netMaxcard_zero | Mathlib.Dynamics.TopologicalEntropy.NetEntropy | ∀ {X : Type u_1} {F : Set X} (T : X → X), F.Nonempty → ∀ (U : SetRel X X), Dynamics.netMaxcard T F U 0 = 1 | null | true |
DistLat.casesOn | Mathlib.Order.Category.DistLat | {motive : DistLat → Sort u} →
(t : DistLat) →
((carrier : Type u_1) → [str : DistribLattice carrier] → motive { carrier := carrier, str := str }) → motive t | null | false |
MeasureTheory.innerRegularWRT_isCompact_isClosed | Mathlib.MeasureTheory.Measure.RegularityCompacts | ∀ {α : Type u_1} [inst : MeasurableSpace α] [inst_1 : TopologicalSpace α] [SecondCountableTopology α]
[TopologicalSpace.IsCompletelyPseudoMetrizableSpace α] [OpensMeasurableSpace α] (P : MeasureTheory.Measure α)
[MeasureTheory.IsFiniteMeasure P], P.InnerRegularWRT (fun s => IsCompact s ∧ IsClosed s) IsClosed | null | true |
Int8.casesOn | Init.Data.SInt.Basic | {motive : Int8 → Sort u} → (t : Int8) → ((toUInt8 : UInt8) → motive { toUInt8 := toUInt8 }) → motive t | null | false |
AffineSubspace.card_pos_of_affineSpan_eq_top | Mathlib.LinearAlgebra.AffineSpace.AffineSubspace.Defs | ∀ (k : Type u_1) (V : Type u_2) (P : Type u_3) [inst : Ring k] [inst_1 : AddCommGroup V] [inst_2 : Module k V]
[S : AddTorsor V P] {ι : Type u_5} [inst_3 : Fintype ι] {p : ι → P},
affineSpan k (Set.range p) = ⊤ → 0 < Fintype.card ι | null | true |
CategoryTheory.Functor.Monoidal.whiskerLeft_δ_μ | Mathlib.CategoryTheory.Monoidal.Functor | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.MonoidalCategory C] {D : Type u₂}
[inst_2 : CategoryTheory.Category.{v₂, u₂} D] [inst_3 : CategoryTheory.MonoidalCategory D]
(F : CategoryTheory.Functor C D) [inst_4 : F.Monoidal] (X Y : C) (T : D),
CategoryTheory.CategoryStruct.... | null | true |
LightDiagram.instCategory | Mathlib.Topology.Category.LightProfinite.Basic | CategoryTheory.Category.{u_1, u_1 + 1} LightDiagram | null | true |
GroupTopology.instSemilatticeInf._proof_1 | Mathlib.Topology.Algebra.Group.GroupTopology | ∀ {α : Type u_1} [inst : Group α] {x y : GroupTopology α},
y.toTopologicalSpace ≤ x.toTopologicalSpace ↔ y.toTopologicalSpace ≤ x.toTopologicalSpace | null | false |
ContinuousMap.liftCover' | Mathlib.Topology.ContinuousMap.Basic | {α : Type u_1} →
{β : Type u_2} →
[inst : TopologicalSpace α] →
[inst_1 : TopologicalSpace β] →
(A : Set (Set α)) →
(F : (s : Set α) → s ∈ A → C(↑s, β)) →
(∀ (s : Set α) (hs : s ∈ A) (t : Set α) (ht : t ∈ A) (x : α) (hxi : x ∈ s) (hxj : x ∈ t),
(F s hs) ⟨x, hxi⟩... | A family `F s` of continuous maps `C(s, β)`, where (1) the domains `s` are taken from a set `A`
of sets in `α` which contain a neighbourhood of each point in `α` and (2) the functions `F s` agree
pairwise on intersections, can be glued to construct a continuous map in `C(α, β)`. | true |
FreeGroup.of_ne_one | Mathlib.GroupTheory.FreeGroup.Reduce | ∀ {α : Type u_1} (a : α), FreeGroup.of a ≠ 1 | null | true |
_private.Mathlib.Order.Interval.Set.Pi.0.Set.pi_univ_Ioc_update_left._simp_1_1 | Mathlib.Order.Interval.Set.Pi | ∀ {α : Type u} (a b c : Set α), a ∩ (b ∩ c) = a ∩ b ∩ c | null | false |
EuclideanGeometry.Sphere.IsDiameter.wbtw | Mathlib.Geometry.Euclidean.Sphere.Basic | ∀ {V : Type u_1} {P : Type u_2} [inst : NormedAddCommGroup V] [inst_1 : NormedSpace ℝ V] [inst_2 : MetricSpace P]
[inst_3 : NormedAddTorsor V P] {s : EuclideanGeometry.Sphere P} {p₁ p₂ : P},
s.IsDiameter p₁ p₂ → Wbtw ℝ p₁ s.center p₂ | null | true |
_private.Plausible.Sampleable.0.Plausible.mkGenerator.match_1 | Plausible.Sampleable | (motive : Lean.Level → Sort u_1) →
(u : Lean.Level) → ((u : Lean.Level) → motive u.succ) → ((x : Lean.Level) → motive x) → motive u | null | false |
Array.count_empty | Init.Data.Array.Count | ∀ {α : Type u_1} [inst : BEq α] {a : α}, Array.count a #[] = 0 | null | true |
Hypergraph.isLoop_iff_mem_edgeSet_and_singleton | Mathlib.Combinatorics.Hypergraph.Basic | ∀ {α : Type u_1} {e : Set α} {H : Hypergraph α}, H.IsLoop e ↔ e ∈ H.edgeSet ∧ ∃ x, e = {x} | null | true |
HomotopicalAlgebra.ModelCategory.categoryWithCofibrations._autoParam | Mathlib.AlgebraicTopology.ModelCategory.Basic | Lean.Syntax | null | false |
AddHom.noncommCoprod._proof_1 | Mathlib.GroupTheory.NoncommCoprod | ∀ {M : Type u_2} {N : Type u_3} {P : Type u_1} [inst : Add M] [inst_1 : Add N] [inst_2 : AddSemigroup P] (f : M →ₙ+ P)
(g : N →ₙ+ P),
(∀ (m : M) (n : N), AddCommute (f m) (g n)) →
∀ (mn mn' : M × N), f (mn + mn').1 + g (mn + mn').2 = f mn.1 + g mn.2 + (f mn'.1 + g mn'.2) | null | false |
Polynomial.rootsExpandPowEquivRoots_apply | Mathlib.FieldTheory.Perfect | ∀ {R : Type u_1} [inst : CommRing R] [inst_1 : IsDomain R] (p : ℕ) [inst_2 : ExpChar R p] (f : Polynomial R)
[inst_3 : DecidableEq R] [inst_4 : PerfectRing R p] (n : ℕ) (x : ↥((Polynomial.expand R (p ^ n)) f).roots.toFinset),
↑((Polynomial.rootsExpandPowEquivRoots p f n) x) = ↑x ^ p ^ n | null | true |
CategoryTheory.ComposableArrows.Precomp.obj.eq_1 | Mathlib.CategoryTheory.Triangulated.SpectralObject | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {n : ℕ} (F : CategoryTheory.ComposableArrows C n) (X : C)
(isLt : 0 < n + 1 + 1), CategoryTheory.ComposableArrows.Precomp.obj F X ⟨0, isLt⟩ = X | null | true |
Subsemiring.centralizer_univ | Mathlib.Algebra.Ring.Subsemiring.Basic | ∀ {R : Type u_1} [inst : Semiring R], Subsemiring.centralizer Set.univ = Subsemiring.center R | null | true |
_private.Lean.Meta.Tactic.Simp.Rewrite.0.Lean.Meta.Simp.rewrite?.diagnoseWhenNoIndex | Lean.Meta.Tactic.Simp.Rewrite | Lean.Expr → Lean.Meta.SimpTheoremTree → Lean.Meta.SimpTheorem → Lean.Meta.SimpM Unit | null | true |
ImportGraph.Shake.Bitset.extractArray | ImportGraph.Shake.Basic | {α : Type} → Array α → ImportGraph.Shake.Bitset → Array α | Extract the elements of `a : Array α` occurring at the indices specified in `b : Bitset`.
Ignores elements of `b` that index outside the array. | true |
EReal.mul_div_cancel | Mathlib.Data.EReal.Inv | ∀ {a b : EReal}, b ≠ ⊥ → b ≠ ⊤ → b ≠ 0 → b * (a / b) = a | null | true |
min_eq_one._simp_2 | Mathlib.Algebra.Order.IsBotOne | ∀ {α : Type u_1} [inst : LinearOrder α] [inst_1 : One α] [IsBotOneClass α] {a b : α}, (min a b = 1) = (a = 1 ∨ b = 1) | null | false |
Function.infinite_of_left | Mathlib.Data.Fintype.Prod | ∀ {ι : Sort u_3} {π : Type u_4} [Nontrivial π] [Infinite ι], Infinite (ι → π) | Non-dependent version of `Pi.infinite_of_left`. | true |
_private.Mathlib.Data.Nat.Choose.Multinomial.0.Multiset.multinomial_pos._simp_1_1 | Mathlib.Data.Nat.Choose.Multinomial | ∀ {α : Type u_1} [inst : MulZeroClass α] {a b : α} [inst_1 : Preorder α] [MulPosStrictMono α] [MulPosReflectLT α],
0 < b → (0 < a * b) = (0 < a) | null | false |
Submodule.toConvexCone_top | Mathlib.Geometry.Convex.Cone.Basic | ∀ {R : Type u_2} {M : Type u_4} [inst : Semiring R] [inst_1 : PartialOrder R] [inst_2 : AddCommMonoid M]
[inst_3 : Module R M], ⊤.toConvexCone = ⊤ | null | true |
WithConv._sizeOf_inst | Mathlib.Algebra.WithConv | (A : Sort u_1) → [SizeOf A] → SizeOf (WithConv A) | null | false |
Lean.PersistentHashMap.Node.measure | Lean.Data.Iterators.Producers.PersistentHashMap | {α : Type u_1} → {β : Type u_2} → Lean.PersistentHashMap.Node α β → ℕ | Counts the total number of entries reachable from a node, including nested children. | true |
Real.arsinh_sinh | Mathlib.Analysis.SpecialFunctions.Arsinh | ∀ (x : ℝ), Real.arsinh (Real.sinh x) = x | `arsinh` is the left inverse of `sinh`. | true |
OrderBot.recOn | Mathlib.Order.BoundedOrder.Basic | {α : Type u} →
[inst : LE α] →
{motive : OrderBot α → Sort u_1} →
(t : OrderBot α) →
([toBot : Bot α] → (bot_le : ∀ (a : α), ⊥ ≤ a) → motive { toBot := toBot, bot_le := bot_le }) → motive t | null | false |
mul_lt_of_lt_one_left | Mathlib.Algebra.Order.GroupWithZero.Basic | ∀ {α : Type u_1} [inst : MulOneClass α] [inst_1 : Zero α] {a b : α} [inst_2 : Preorder α] [MulPosStrictMono α],
0 < b → a < 1 → a * b < b | null | true |
_private.Mathlib.Algebra.Polynomial.Derivative.0.Polynomial.iterate_derivative_prod_X_sub_C._proof_1_14 | Mathlib.Algebra.Polynomial.Derivative | ∀ {R : Type u_1} {S : Finset R} (k : ℕ),
k + 1 ≤ S.card → ∀ T ∈ Finset.powersetCard (S.card - (k + 1)) S, (S \ T).card = k + 1 | null | false |
IsFreeGroupoid.noConfusion | Mathlib.GroupTheory.FreeGroup.NielsenSchreier | {P : Sort u} →
{G : Type u_1} →
{inst : CategoryTheory.Groupoid G} →
{t : IsFreeGroupoid G} →
{G' : Type u_1} →
{inst' : CategoryTheory.Groupoid G'} →
{t' : IsFreeGroupoid G'} → G = G' → inst ≍ inst' → t ≍ t' → IsFreeGroupoid.noConfusionType P t t' | null | false |
_private.Mathlib.Probability.Distributions.Beta.0.ProbabilityTheory.lintegral_betaPDF_eq_one._simp_1_3 | Mathlib.Probability.Distributions.Beta | ∀ {α : Type u_2} [inst : Zero α] [inst_1 : OfNat α 4] [NeZero 4], (4 = 0) = False | null | false |
Ordinal.monoid._proof_1 | Mathlib.SetTheory.Ordinal.Arithmetic | ∀ (α : Type u_1) (r : α → α → Prop),
IsWellOrder α r → ∀ (β : Type u_1) (s : β → β → Prop), IsWellOrder β s → IsWellOrder (β × α) (Prod.Lex s r) | null | false |
fderivWithin_ccosh | Mathlib.Analysis.SpecialFunctions.Trigonometric.DerivHyp | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℂ E] {f : E → ℂ} {x : E} {s : Set E},
DifferentiableWithinAt ℂ f s x →
UniqueDiffWithinAt ℂ s x →
fderivWithin ℂ (fun x => Complex.cosh (f x)) s x = Complex.sinh (f x) • fderivWithin ℂ f s x | null | true |
Nat.exists_prime_lt_and_le_two_mul_eventually | Mathlib.NumberTheory.Bertrand | ∀ (n : ℕ), 512 ≤ n → ∃ p, Nat.Prime p ∧ n < p ∧ p ≤ 2 * n | Proves that **Bertrand's postulate** holds for all sufficiently large `n`.
| true |
_private.Mathlib.Combinatorics.SimpleGraph.Sum.0.SimpleGraph.edgeSetSumEquiv._proof_14 | Mathlib.Combinatorics.SimpleGraph.Sum | ∀ {V : Type u_1} {W : Type u_2} {G : SimpleGraph V} {H : SimpleGraph W} (a b : V ⊕ W),
(G ⊕g H).Adj a b →
∀ (val_1 : W), Sum.inr val_1 = b → ∀ (val_2 : W), Sum.inr val_2 = a → (G ⊕g H).Adj (Sum.inr val_2) (Sum.inr val_1) | null | false |
Std.DTreeMap.Raw.isSome_minKey?_eq_not_isEmpty | Std.Data.DTreeMap.Raw.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t : Std.DTreeMap.Raw α β cmp} [Std.TransCmp cmp],
t.WF → t.minKey?.isSome = !t.isEmpty | null | true |
CategoryTheory.MonoidalCategory.MonoidalLeftActionStruct.recOn | Mathlib.CategoryTheory.Monoidal.Action.Basic | {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.MonoidalCategoryStruct C] →
{motive : CategoryTheory.MonoidalCategory.MonoidalLeftActionStruct C D → Sort u} →
(t : Categ... | null | false |
AddSubsemigroup.coe_copy | Mathlib.Algebra.Group.Subsemigroup.Defs | ∀ {M : Type u_1} [inst : Add M] {S : AddSubsemigroup M} {s : Set M} (hs : s = ↑S), ↑(S.copy s hs) = s | null | true |
Lean.Lsp.ChangeAnnotation.mk._flat_ctor | Lean.Data.Lsp.Basic | String → Bool → Option String → Lean.Lsp.ChangeAnnotation | null | false |
AlgebraicGeometry.IsLocallyArtinian.mk | Mathlib.AlgebraicGeometry.Artinian | ∀ {X : AlgebraicGeometry.Scheme},
autoParam (∀ (U : ↑X.affineOpens), IsArtinianRing ↑(X.presheaf.obj (Opposite.op ↑U)))
AlgebraicGeometry.IsLocallyArtinian.isArtinianRing_presheaf_obj._autoParam →
AlgebraicGeometry.IsLocallyArtinian X | null | true |
Lean.PrettyPrinter.Delaborator.SubExpr.HoleIterator | Lean.PrettyPrinter.Delaborator.SubExpr | Type | null | true |
bddAbove_Ioc._simp_1 | Mathlib.Order.Bounds.Basic | ∀ {α : Type u_1} [inst : Preorder α] {a b : α}, BddAbove (Set.Ioc b a) = True | null | false |
Real.iInter_Iic_rat | Mathlib.Algebra.Order.Archimedean.Real.Basic | ⋂ r, Set.Iic ↑r = ∅ | null | true |
_private.Mathlib.Order.SuccPred.LinearLocallyFinite.0.orderIsoRangeToZOfLinearSuccPredArch._proof_2 | Mathlib.Order.SuccPred.LinearLocallyFinite | ∀ {ι : Type u_1} [inst : LinearOrder ι] [inst_1 : SuccOrder ι] [inst_2 : PredOrder ι] [inst_3 : IsSuccArchimedean ι]
[hι : Nonempty ι] (a a_1 : ι),
(Equiv.ofInjective (toZ hι.some) ⋯) a ≤ (Equiv.ofInjective (toZ hι.some) ⋯) a_1 ↔ a ≤ a_1 | null | false |
HopfAlgebra.antipodeAlgHomOp._proof_1 | Mathlib.RingTheory.HopfAlgebra.Convolution | ∀ (R : Type u_2) (A : Type u_1) [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : HopfAlgebra R A],
MulOpposite.op ((↑(MulOpposite.opLinearEquiv R) ∘ₗ HopfAlgebraStruct.antipode R) 1) = MulOpposite.op 1 | null | false |
iSup_succ | Mathlib.Order.SuccPred.CompleteLinearOrder | ∀ {α : Type u_2} [inst : ConditionallyCompleteLinearOrderBot α] [inst_1 : SuccOrder α] (x : α), ⨆ a, Order.succ ↑a = x | null | true |
CategoryTheory.Limits.Wedge.ext._proof_3 | Mathlib.CategoryTheory.Limits.Shapes.End | ∀ {J : Type u_3} [inst : CategoryTheory.Category.{u_4, u_3} J] {C : Type u_2}
[inst_1 : CategoryTheory.Category.{u_1, u_2} C] {F : CategoryTheory.Functor Jᵒᵖ (CategoryTheory.Functor J C)}
{W₁ W₂ : CategoryTheory.Limits.Wedge F} (e : W₁.pt ≅ W₂.pt),
(∀ (j : J),
CategoryTheory.Limits.Multifork.ι W₁ j =
... | null | false |
TopologicalSpace.IsTopologicalBasis.nonemptyCompacts | Mathlib.Topology.Sets.VietorisTopology | ∀ {α : Type u_1} [inst : TopologicalSpace α] {B : Set (Set α)},
TopologicalSpace.IsTopologicalBasis B →
TopologicalSpace.IsTopologicalBasis
((fun u => {K | ↑K ⊆ ⋃₀ u ∧ ∀ U ∈ u, (↑K ∩ U).Nonempty}) '' {u | u.Finite ∧ u.Nonempty ∧ u ⊆ B}) | Given a basis `B` on a topological space `α`, the topology of `NonemptyCompacts α` has a basis
consisting of sets of the form `{K | K ⊆ U₁ ∪ … ∪ Uₙ, K ∩ U₁ ≠ ∅, …, K ∩ Uₙ ≠ ∅}`, where
`U₁, …, Uₙ ∈ B` and `n > 0`. | true |
_private.Mathlib.RingTheory.MvPolynomial.Ideal.0.MonomialOrder.span_leadingTerm_eq_span_monomial'._simp_1_1 | Mathlib.RingTheory.MvPolynomial.Ideal | ∀ (p : Prop), (¬p ∨ p) = True | null | false |
BoundedLatticeHom.toFun_eq_coe | Mathlib.Order.Hom.BoundedLattice | ∀ {α : Type u_2} {β : Type u_3} [inst : Lattice α] [inst_1 : Lattice β] [inst_2 : BoundedOrder α]
[inst_3 : BoundedOrder β] (f : BoundedLatticeHom α β), f.toFun = ⇑f | null | true |
CategoryTheory.GradedObject.mapTrifunctorObj_map_app | Mathlib.CategoryTheory.GradedObject.Trifunctor | ∀ {C₁ : Type u_1} {C₂ : Type u_2} {C₃ : Type u_3} {C₄ : Type u_4} [inst : CategoryTheory.Category.{v_1, u_1} C₁]
[inst_1 : CategoryTheory.Category.{v_2, u_2} C₂] [inst_2 : CategoryTheory.Category.{v_3, u_3} C₃]
[inst_3 : CategoryTheory.Category.{v_4, u_4} C₄]
(F : CategoryTheory.Functor C₁ (CategoryTheory.Functor... | null | true |
Lean.EnvironmentHeader.casesOn | Lean.Environment | {motive : Lean.EnvironmentHeader → Sort u} →
(t : Lean.EnvironmentHeader) →
((trustLevel : UInt32) →
(mainModule : Lean.Name) →
(isModule : Bool) →
(imports : Array Lean.Import) →
(regions : Array Lean.CompactedRegion) →
(modules : Array Lean.EffectiveIm... | null | false |
LinOrd.Hom.noConfusionType | Mathlib.Order.Category.LinOrd | Sort u_1 → {X Y : LinOrd} → X.Hom Y → {X' Y' : LinOrd} → X'.Hom Y' → Sort u_1 | null | false |
Lean.ppExt | Lean.Util.PPExt | Lean.EnvExtension Lean.PPFns | null | true |
Std.DTreeMap.Raw.getKey_map | Std.Data.DTreeMap.Raw.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t : Std.DTreeMap.Raw α β cmp} {γ : α → Type w}
[inst : Std.TransCmp cmp] {f : (a : α) → β a → γ a} {k : α} {h' : k ∈ Std.DTreeMap.Raw.map f t} (h : t.WF),
(Std.DTreeMap.Raw.map f t).getKey k h' = t.getKey k ⋯ | null | true |
CategoryTheory.MorphismProperty.IsStableUnderTransfiniteCompositionOfShape.recOn | Mathlib.CategoryTheory.MorphismProperty.TransfiniteComposition | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{W : CategoryTheory.MorphismProperty C} →
{J : Type w} →
[inst_1 : LinearOrder J] →
[inst_2 : SuccOrder J] →
[inst_3 : OrderBot J] →
[inst_4 : WellFoundedLT J] →
{motive : W.IsStableUnderTr... | null | false |
Std.ExtHashSet.insertMany_ind | Std.Data.ExtHashSet.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {ρ : Type v} [inst : ForIn Id ρ α] [inst_1 : EquivBEq α]
[inst_2 : LawfulHashable α] {motive : Std.ExtHashSet α → Prop} (m : Std.ExtHashSet α) {l : ρ},
motive m → (∀ (m : Std.ExtHashSet α) (a : α), motive m → motive (m.insert a)) → motive (m.insertMany l) | null | true |
RBTree.RBMap.findEntry?_congr | Batteries.Recycling.RBTree.Lemmas | ∀ {α : Type u_1} {cmp : α → α → Ordering} {β : Type u_2} {k₁ k₂ : α} [Std.TransCmp cmp] (t : RBTree.RBMap α β cmp),
cmp k₁ k₂ = Ordering.eq → t.findEntry? k₁ = t.findEntry? k₂ | null | true |
CategoryTheory.MonoidalCategory.MonoidalLeftAction.curriedAction._proof_2 | Mathlib.CategoryTheory.Monoidal.Action.Basic | ∀ (C : Type u_4) (D : Type u_2) [inst : CategoryTheory.Category.{u_3, u_4} C]
[inst_1 : CategoryTheory.Category.{u_1, u_2} D] [inst_2 : CategoryTheory.MonoidalCategory C]
[inst_3 : CategoryTheory.MonoidalCategory.MonoidalLeftAction C D] (x : C) (X : D),
CategoryTheory.MonoidalCategory.MonoidalLeftActionStruct.act... | null | false |
OpenPartialHomeomorph.isOpen_extend_source | Mathlib.Geometry.Manifold.IsManifold.ExtChartAt | ∀ {𝕜 : Type u_1} {E : Type u_2} {M : Type u_3} {H : Type u_4} [inst : NontriviallyNormedField 𝕜]
[inst_1 : NormedAddCommGroup E] [inst_2 : NormedSpace 𝕜 E] [inst_3 : TopologicalSpace H] [inst_4 : TopologicalSpace M]
(f : OpenPartialHomeomorph M H) {I : ModelWithCorners 𝕜 E H}, IsOpen (f.extend I).source | null | true |
MeasureTheory.instFunLikeAddContentSet | Mathlib.MeasureTheory.Measure.AddContent | {α : Type u_1} →
{C : Set (Set α)} → {G : Type u_2} → [inst : AddCommMonoid G] → FunLike (MeasureTheory.AddContent G C) (Set α) G | null | true |
Lean.Data.AC.ContextInformation.rec | Init.Data.AC | {α : Sort u} →
{motive : Lean.Data.AC.ContextInformation α → Sort u_1} →
((isNeutral : α → ℕ → Bool) →
(isComm isIdem : α → Bool) → motive { isNeutral := isNeutral, isComm := isComm, isIdem := isIdem }) →
(t : Lean.Data.AC.ContextInformation α) → motive t | null | false |
NonemptyFinLinOrd.recOn | Mathlib.Order.Category.NonemptyFinLinOrd | {motive : NonemptyFinLinOrd → Sort u} →
(t : NonemptyFinLinOrd) →
((toLinOrd : LinOrd) →
[nonempty : Nonempty ↑toLinOrd] →
[fintype : Fintype ↑toLinOrd] → motive { toLinOrd := toLinOrd, nonempty := nonempty, fintype := fintype }) →
motive t | null | false |
EStateM.Backtrackable.save | Init.Prelude | {δ : outParam (Type u)} → {σ : Type u} → [self : EStateM.Backtrackable δ σ] → σ → δ | Extracts the information in the state that should be rolled back if an exception is handled.
| true |
_private.Mathlib.MeasureTheory.Integral.CircleAverage.0.Real.circleAverage_mono._simp_1_1 | Mathlib.MeasureTheory.Integral.CircleAverage | (0 < Real.pi) = True | null | false |
Lean.EnvExtension.setState | Lean.Environment | {σ : Type} →
(ext : Lean.EnvExtension σ) →
Lean.Environment → σ → optParam Lean.EnvExtension.AsyncMode ext.asyncMode → Lean.Environment | Sets the extension state to the given value. See `AsyncMode` for details on how modifications from
different environment branches are reconciled.
| true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.