name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11.5k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
instCommMonoidUniformOnFun._proof_1 | Mathlib.Topology.Algebra.UniformConvergence | ∀ {α : Type u_1} {β : Type u_2} {𝔖 : Set (Set α)} [inst : CommMonoid β] (a b : UniformOnFun α β 𝔖), a * b = b * a | null | false |
_private.Mathlib.FieldTheory.AlgebraicClosure.0.le_algebraicClosure_iff._simp_1_1 | Mathlib.FieldTheory.AlgebraicClosure | ∀ {F : Type u_1} {E : Type u_2} [inst : Field F] [inst_1 : Field E] [inst_2 : Algebra F E] {x : E},
(x ∈ algebraicClosure F E) = IsAlgebraic F x | null | false |
_private.Std.Http.Server.Connection.0.Std.Http.Server.Connection.PollSources.socket | Std.Http.Server.Connection | {α β : Type} → Std.Http.Server.Connection.PollSources✝ α β → Option α | null | true |
_private.Mathlib.Data.Vector.Basic.0.List.Vector.mOfFn.match_1.eq_1 | Mathlib.Data.Vector.Basic | ∀ {m : Type u_3 → Type u_2} {α : Type u_3} (motive : (x : ℕ) → (Fin x → m α) → Sort u_1) (x : Fin 0 → m α)
(h_1 : (x : Fin 0 → m α) → motive 0 x) (h_2 : (n : ℕ) → (f : Fin (n + 1) → m α) → motive n.succ f),
(match 0, x with
| 0, x => h_1 x
| n.succ, f => h_2 n f) =
h_1 x | null | true |
_private.Mathlib.Topology.CWComplex.Classical.Basic.0.Topology.RelCWComplex.disjoint_base_iUnion_openCell._simp_1_2 | Mathlib.Topology.CWComplex.Classical.Basic | ∀ {α : Type u_1} {ι : Sort u_5} {s : ι → Set α}, (⋃ i, s i = ∅) = ∀ (i : ι), s i = ∅ | null | false |
CategoryTheory.eId | Mathlib.CategoryTheory.Enriched.Basic | (V : Type v) →
[inst : CategoryTheory.Category.{w, v} V] →
[inst_1 : CategoryTheory.MonoidalCategory V] →
{C : Type u₁} →
[inst_2 : CategoryTheory.EnrichedCategory V C] →
(X : C) → CategoryTheory.MonoidalCategoryStruct.tensorUnit V ⟶ X ⟶[V] X | The `𝟙_ V`-shaped generalized element giving the identity in a `V`-enriched category.
| true |
CategoryTheory.instIsDenseFunctorOppositeTypeYoneda | Mathlib.CategoryTheory.Functor.KanExtension.Dense | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C], CategoryTheory.yoneda.IsDense | null | true |
Array.forIn' | Init.Data.Array.Basic | {α : Type u} →
{β : Type v} → {m : Type v → Type w} → [Monad m] → (as : Array α) → β → ((a : α) → a ∈ as → β → m (ForInStep β)) → m β | Reference implementation for `forIn'` | true |
ENNReal.ofReal_lt_ofReal_iff._simp_1 | Mathlib.Data.ENNReal.Real | ∀ {p q : ℝ}, 0 < q → (ENNReal.ofReal p < ENNReal.ofReal q) = (p < q) | null | false |
CategoryTheory.Idempotents.Karoubi.HomologicalComplex.p_idem_assoc | Mathlib.CategoryTheory.Idempotents.HomologicalComplex | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Preadditive C] {ι : Type u_2}
{c : ComplexShape ι} (P : CategoryTheory.Idempotents.Karoubi (HomologicalComplex C c)) (n : ι) {Z : C}
(h : P.X.X n ⟶ Z),
CategoryTheory.CategoryStruct.comp (P.p.f n) (CategoryTheory.CategoryStruc... | null | true |
Std.ExtDTreeMap.Const.getEntryLT._proof_1 | Std.Data.ExtDTreeMap.Basic | ∀ {α : Type u_1} {cmp : α → α → Ordering} {β : Type u_2} [inst : Std.TransCmp cmp]
(t : Std.ExtDTreeMap α (fun x => β) cmp) (k : α),
(∃ a ∈ t, cmp a k = Ordering.lt) →
∀ (m : Std.DTreeMap α (fun x => β) cmp),
t = Std.ExtDTreeMap.mk m → ∃ a ∈ Std.ExtDTreeMap.mk m, cmp a k = Ordering.lt | null | false |
LinearMap.instDistribMulAction | Mathlib.Algebra.Module.LinearMap.Defs | {R : Type u_1} →
{R₂ : Type u_3} →
{S : Type u_5} →
{M : Type u_8} →
{M₂ : Type u_10} →
[inst : Semiring R] →
[inst_1 : Semiring R₂] →
[inst_2 : AddCommMonoid M] →
[inst_3 : AddCommMonoid M₂] →
[inst_4 : Module R M] →
... | null | true |
TwoSidedIdeal.orderIsoIdeal._proof_5 | Mathlib.RingTheory.TwoSidedIdeal.Operations | ∀ {R : Type u_1} [inst : CommRing R] {a b : TwoSidedIdeal R},
{ toFun := ⇑TwoSidedIdeal.asIdeal, invFun := ⇑TwoSidedIdeal.fromIdeal, left_inv := ⋯, right_inv := ⋯ } a ≤
{ toFun := ⇑TwoSidedIdeal.asIdeal, invFun := ⇑TwoSidedIdeal.fromIdeal, left_inv := ⋯, right_inv := ⋯ } b ↔
a ≤ b | null | false |
_private.Std.Tactic.BVDecide.LRAT.Internal.Formula.Lemmas.0.Std.Tactic.BVDecide.LRAT.Internal.DefaultFormula.readyForRupAdd_insert._proof_1_16 | Std.Tactic.BVDecide.LRAT.Internal.Formula.Lemmas | ∀ (b : Bool), ¬b = true → b = false | null | false |
Rep.coinvariantsTensorMk._proof_2 | Mathlib.RepresentationTheory.Coinvariants | ∀ {k : Type u_1} {G : Type u_2} [inst : CommRing k] [inst_1 : Monoid G] (A B : Rep.{u_1, u_1, u_2} k G),
SMulCommClass k k (TensorProduct k ↑A ↑B) | null | false |
Real.logb_neg_of_base_lt_one | Mathlib.Analysis.SpecialFunctions.Log.Base | ∀ {b x : ℝ}, 0 < b → b < 1 → 1 < x → Real.logb b x < 0 | null | true |
Submodule.LinearDisjoint.mk._flat_ctor | Mathlib.LinearAlgebra.LinearDisjoint | ∀ {R : Type u} {S : Type v} [inst : CommSemiring R] [inst_1 : Semiring S] [inst_2 : Algebra R S] {M N : Submodule R S},
Function.Injective ⇑(M.mulMap N) → M.LinearDisjoint N | null | false |
CategoryTheory.equivEssImageOfReflective_inverse | Mathlib.CategoryTheory.Adjunction.Reflective | ∀ {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.Reflective i],
CategoryTheory.equivEssImageOfReflective.inverse = i.essImage.ι.comp (CategoryTheory.reflector i) | null | true |
AddEquiv.mk.sizeOf_spec | Mathlib.Algebra.Group.Equiv.Defs | ∀ {A : Type u_9} {B : Type u_10} [inst : Add A] [inst_1 : Add B] [inst_2 : SizeOf A] [inst_3 : SizeOf B]
(toEquiv : A ≃ B) (map_add' : ∀ (x y : A), toEquiv.toFun (x + y) = toEquiv.toFun x + toEquiv.toFun y),
sizeOf { toEquiv := toEquiv, map_add' := map_add' } = 1 + sizeOf toEquiv | null | true |
Rat.sqrt_eq | Mathlib.Data.Rat.Sqrt | ∀ (q : ℚ), Rat.sqrt (q * q) = |q| | null | true |
HomotopicalAlgebra.LeftHomotopyRel.postcomp | Mathlib.AlgebraicTopology.ModelCategory.LeftHomotopy | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y : C}
[inst_1 : HomotopicalAlgebra.CategoryWithWeakEquivalences C] {f g : X ⟶ Y},
HomotopicalAlgebra.LeftHomotopyRel f g →
∀ {Z : C} (p : Y ⟶ Z),
HomotopicalAlgebra.LeftHomotopyRel (CategoryTheory.CategoryStruct.comp f p)
(CategoryTheory... | null | true |
_private.Init.Data.String.Basic.0.String.Pos.toSlice_le._simp_1_1 | Init.Data.String.Basic | ∀ {s : String.Slice} {l r : s.Pos}, (l ≤ r) = (l.offset ≤ r.offset) | null | false |
HomologicalComplex₂.D₁_totalShift₂XIso_hom | Mathlib.Algebra.Homology.TotalComplexShift | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Preadditive C]
(K : HomologicalComplex₂ C (ComplexShape.up ℤ) (ComplexShape.up ℤ)) (y : ℤ) [inst_2 : K.HasTotal (ComplexShape.up ℤ)]
(n₀ n₁ n₀' n₁' : ℤ) (h₀ : n₀ + y = n₀') (h₁ : n₁ + y = n₁'),
CategoryTheory.CategoryStruct.co... | null | true |
ByteArray.extract_eq_empty_iff | Init.Data.ByteArray.Lemmas | ∀ {b : ByteArray} {i j : ℕ}, b.extract i j = ByteArray.empty ↔ min j b.size ≤ i | null | true |
SSet.stdSimplex.finSuccAboveOrderIsoFinset | Mathlib.AlgebraicTopology.SimplicialSet.StdSimplex | {n : ℕ} → (i : Fin (n + 2)) → Fin (n + 1) ≃o ↥{i}ᶜ | If `i : Fin (n + 2)`, this is the order isomorphism between `Fin (n +1)`
and the complement of `{i}` as a finset. | true |
Finmap.mk.sizeOf_spec | Mathlib.Data.Finmap | ∀ {α : Type u} {β : α → Type v} [inst : SizeOf α] [inst_1 : (a : α) → SizeOf (β a)] (entries : Multiset (Sigma β))
(nodupKeys : entries.NodupKeys),
sizeOf { entries := entries, nodupKeys := nodupKeys } = 1 + sizeOf entries + sizeOf nodupKeys | null | true |
Lean.instInhabitedAuxParentProjectionInfo.default | Lean.ProjFns | Lean.AuxParentProjectionInfo | null | true |
Mathlib.Tactic.BicategoryLike.StructuralAtom.coherenceHom.elim | Mathlib.Tactic.CategoryTheory.Coherence.Datatypes | {motive : Mathlib.Tactic.BicategoryLike.StructuralAtom → Sort u} →
(t : Mathlib.Tactic.BicategoryLike.StructuralAtom) →
t.ctorIdx = 4 →
((α : Mathlib.Tactic.BicategoryLike.CoherenceHom) →
motive (Mathlib.Tactic.BicategoryLike.StructuralAtom.coherenceHom α)) →
motive t | null | false |
_private.Mathlib.Analysis.Calculus.BumpFunction.FiniteDimension.0.IsOpen.exists_contDiff_support_eq._simp_1_1 | Mathlib.Analysis.Calculus.BumpFunction.FiniteDimension | ∀ {α : Type u_1} {a : α} {s : Set α}, ({a} ⊆ s) = (a ∈ s) | null | false |
CategoryTheory.Limits.Bicone.toBinaryBiconeIsColimit._proof_1 | Mathlib.CategoryTheory.Limits.Shapes.BinaryBiproducts | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{X Y : C} (b : CategoryTheory.Limits.Bicone (CategoryTheory.Limits.pairFunction X Y))
(j : CategoryTheory.Discrete CategoryTheory.Limits.WalkingPair),
CategoryTheory.CategoryStruct.comp (b.toBinaryBi... | null | false |
Std.IterM.DefaultConsumers.forIn'._proof_4 | Init.Data.Iterators.Consumers.Monadic.Loop | ∀ {m : Type u_1 → Type u_2} {α β : Type u_1} [inst : Std.Iterator α m β] (γ : Type u_3)
(PlausibleForInStep : β → γ → ForInStep γ → Prop) (P : β → Prop) (it : Std.IterM m β) (acc : γ)
(hP : ∀ (b : β), it.IsPlausibleIndirectOutput b → P b) (it' : Std.IterM m β) (out : β)
(h : it.IsPlausibleStep (Std.IterStep.yield... | null | false |
Mathlib.Tactic.Coherence._aux_Mathlib_Tactic_CategoryTheory_Coherence___elabRules_Mathlib_Tactic_Coherence_pure_coherence_internal_1 | Mathlib.Tactic.CategoryTheory.Coherence | Lean.Elab.Tactic.Tactic | The same as `pure_coherence`, but used internally in `coherence` without the warning. | false |
_private.Aesop.Forward.State.0.Aesop.instBEqRawHyp.beq.match_1 | Aesop.Forward.State | (motive : Aesop.RawHyp → Aesop.RawHyp → Sort u_1) →
(x x_1 : Aesop.RawHyp) →
((a b : Lean.FVarId) → motive (Aesop.RawHyp.fvarId a) (Aesop.RawHyp.fvarId b)) →
((a b : Aesop.Substitution) → motive (Aesop.RawHyp.patSubst a) (Aesop.RawHyp.patSubst b)) →
((x x_2 : Aesop.RawHyp) → motive x x_2) → motive x... | null | false |
Std.DHashMap.Const.get!_eq_get! | Std.Data.DHashMap.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {β : Type v} {m : Std.DHashMap α fun x => β} [inst : LawfulBEq α]
[inst_1 : Inhabited β] {a : α}, Std.DHashMap.Const.get! m a = m.get! a | null | true |
CategoryTheory.Monad.id._proof_1 | Mathlib.CategoryTheory.Monad.Basic | ∀ (C : Type u_2) [inst : CategoryTheory.Category.{u_1, u_2} C] (X : C),
CategoryTheory.CategoryStruct.comp
((CategoryTheory.Functor.id C).map ((CategoryTheory.CategoryStruct.id (CategoryTheory.Functor.id C)).app X))
((CategoryTheory.CategoryStruct.id (CategoryTheory.Functor.id C)).app X) =
CategoryThe... | null | false |
ProbabilityTheory.IndepFun.map_mul_eq_map_mconv_map₀ | Mathlib.Probability.Independence.Basic | ∀ {Ω : Type u_7} {mΩ : MeasurableSpace Ω} {μ : MeasureTheory.Measure Ω} {M : Type u_10} [inst : Monoid M]
[inst_1 : MeasurableSpace M] [MeasurableMul₂ M] [MeasureTheory.IsFiniteMeasure μ] {f g : Ω → M},
AEMeasurable f μ →
AEMeasurable g μ →
ProbabilityTheory.IndepFun f g μ →
MeasureTheory.Measure.... | null | true |
Lean.Elab.Tactic.evalImpossible | Lean.Elab.Tactic.Impossible | Lean.Elab.Tactic.Tactic | null | true |
CategoryTheory.SemiadditiveOfBinaryBiproducts.addCommMonoidHomOfHasBinaryBiproducts._proof_4 | Mathlib.CategoryTheory.Preadditive.OfBiproducts | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
[inst_2 : CategoryTheory.Limits.HasBinaryBiproducts C] (X Y : C) (a : X ⟶ Y),
CategoryTheory.SemiadditiveOfBinaryBiproducts.rightAdd X Y 0 a = a | null | false |
Set.IsPWO.mono | Mathlib.Order.WellFoundedSet | ∀ {α : Type u_2} [inst : Preorder α] {s t : Set α}, t.IsPWO → s ⊆ t → s.IsPWO | null | true |
multiplicity_addValuation_apply | Mathlib.RingTheory.Valuation.PrimeMultiplicity | ∀ {R : Type u_1} [inst : CommRing R] [inst_1 : IsDomain R] {p : R} {hp : Prime p} {r : R},
(multiplicity_addValuation hp) r = emultiplicity p r | null | true |
ContDiffAt.exists_forall_mem_closedBall_exists_eq_forall_mem_Ioo_hasDerivAt | Mathlib.Analysis.ODE.ExistUnique | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] [CompleteSpace E] {f : E → E} {x₀ : E},
ContDiffAt ℝ 1 f x₀ →
∀ (t₀ : ℝ),
∃ r > 0,
∃ ε > 0, ∀ x ∈ Metric.closedBall x₀ r, ∃ α, α t₀ = x ∧ ∀ t ∈ Set.Ioo (t₀ - ε) (t₀ + ε), HasDerivAt α (f (α t)) t | If a vector field `f : E → E` is continuously differentiable at `x₀ : E`, then it admits an
integral curve `α : ℝ → E` defined on an open interval, with initial condition `α t₀ = x`, where
`x` may be different from `x₀`. | true |
Path.Homotopy.transAssoc._proof_4 | Mathlib.AlgebraicTopology.FundamentalGroupoid.Basic | ⟨Path.Homotopy.transAssocReparamAux 1, Path.Homotopy.transAssoc._proof_3⟩ = 1 | null | false |
Std.Tactic.BVDecide.Normalize.BitVec.beq_one_eq_ite' | Std.Tactic.BVDecide.Normalize.Bool | ∀ {b : Bool} {a : BitVec 1}, (b == (a == 1#1)) = (a == bif b then 1#1 else 0#1) | null | true |
HasFibers.instFaithfulFibι | Mathlib.CategoryTheory.FiberedCategory.HasFibers | ∀ {𝒮 : Type u₁} {𝒳 : Type u₂} [inst : CategoryTheory.Category.{v₁, u₁} 𝒮] [inst_1 : CategoryTheory.Category.{v₂, u₂} 𝒳]
(p : CategoryTheory.Functor 𝒳 𝒮) [inst_2 : HasFibers p] (S : 𝒮), (HasFibers.ι S).Faithful | null | true |
_private.Lean.Meta.Sym.InstantiateS.0.Lean.Meta.Sym.instantiateRevBetaS'.visit._unsafe_rec | Lean.Meta.Sym.InstantiateS | Array Lean.Expr → Lean.Expr → ℕ → Lean.Meta.Sym.M✝ Lean.Expr | null | false |
CategoryTheory.InjectiveResolution.toRightDerivedZero'._proof_2 | Mathlib.CategoryTheory.Abelian.RightDerived | ∀ {C : Type u_4} [inst : CategoryTheory.Category.{u_3, u_4} C] {D : Type u_2}
[inst_1 : CategoryTheory.Category.{u_1, u_2} D] [inst_2 : CategoryTheory.Abelian C]
[inst_3 : CategoryTheory.Abelian D] {X : C} (P : CategoryTheory.InjectiveResolution X)
(F : CategoryTheory.Functor C D) [inst_4 : F.Additive],
Categor... | null | false |
AlgebraicGeometry.IsReduced.mk._flat_ctor | Mathlib.AlgebraicGeometry.Properties | ∀ {X : AlgebraicGeometry.Scheme},
autoParam (∀ (U : X.Opens), IsReduced ↑(X.presheaf.obj (Opposite.op U)))
AlgebraicGeometry.IsReduced.component_reduced._autoParam →
AlgebraicGeometry.IsReduced X | null | false |
Ideal.mem_toTwoSided | Mathlib.RingTheory.TwoSidedIdeal.Operations | ∀ {R : Type u_1} [inst : Ring R] {I : Ideal R} [inst_1 : I.IsTwoSided] {x : R}, x ∈ I.toTwoSided ↔ x ∈ I | null | true |
AddGroup.residuallyFinite_iff_forall_finiteIndex | Mathlib.GroupTheory.ResiduallyFinite | ∀ {G : Type u_1} [inst : AddGroup G],
AddGroup.ResiduallyFinite G ↔ ∀ (g : G), (∀ (H : AddSubgroup G) [H.FiniteIndex], g ∈ H) → g = 0 | null | true |
instCategoryCompactum._proof_9 | Mathlib.Topology.Category.Compactum | autoParam
(∀ {W X Y Z : Compactum} (f : W ⟶ X) (g : X ⟶ Y) (h : Y ⟶ Z),
CategoryTheory.CategoryStruct.comp (CategoryTheory.CategoryStruct.comp f g) h =
CategoryTheory.CategoryStruct.comp f (CategoryTheory.CategoryStruct.comp g h))
CategoryTheory.Category.assoc._autoParam | null | false |
_private.Mathlib.Order.Filter.AtTopBot.Field.0.Filter.tendsto_mul_const_atBot_iff._simp_1_1 | Mathlib.Order.Filter.AtTopBot.Field | ∀ {α : Type u_1} {β : Type u_2} [inst : Field α] [inst_1 : LinearOrder α] [IsStrictOrderedRing α] {l : Filter β}
{f : β → α} {r : α} [l.NeBot],
Filter.Tendsto (fun x => r * f x) l Filter.atBot =
(0 < r ∧ Filter.Tendsto f l Filter.atBot ∨ r < 0 ∧ Filter.Tendsto f l Filter.atTop) | null | false |
CategoryTheory.ParametrizedAdjunction.rec | Mathlib.CategoryTheory.Adjunction.Parametrized | {C₁ : Type u₁} →
{C₂ : Type u₂} →
{C₃ : Type u₃} →
[inst : CategoryTheory.Category.{v₁, u₁} C₁] →
[inst_1 : CategoryTheory.Category.{v₂, u₂} C₂] →
[inst_2 : CategoryTheory.Category.{v₃, u₃} C₃] →
{F : CategoryTheory.Functor C₁ (CategoryTheory.Functor C₂ C₃)} →
{G ... | null | false |
Turing.PartrecToTM2.tr.eq_2 | Mathlib.Computability.TuringMachine.ToPartrec | ∀ (k : Turing.PartrecToTM2.K') (f : Option Turing.PartrecToTM2.Γ' → Option Turing.PartrecToTM2.Γ')
(q : Turing.PartrecToTM2.Λ'),
Turing.PartrecToTM2.tr (Turing.PartrecToTM2.Λ'.push k f q) =
Turing.TM2.Stmt.branch (fun s => (f s).isSome)
(Turing.TM2.Stmt.push k (fun s => (f s).getD default) (Turing.TM2.Stm... | null | true |
_private.Mathlib.RingTheory.DedekindDomain.SelmerGroup.0.«_aux_Mathlib_RingTheory_DedekindDomain_SelmerGroup___macroRules__private_Mathlib_RingTheory_DedekindDomain_SelmerGroup_0_term_/__1_1» | Mathlib.RingTheory.DedekindDomain.SelmerGroup | Lean.Macro | null | false |
Std.DTreeMap.getKeyD_minKey! | Std.Data.DTreeMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t : Std.DTreeMap α β cmp} [Std.TransCmp cmp]
[inst : Inhabited α], t.isEmpty = false → ∀ {fallback : α}, t.getKeyD t.minKey! fallback = t.minKey! | null | true |
CategoryTheory.SmallObject.SuccStruct.extendToSuccRestrictionLEIso_hom_app | Mathlib.CategoryTheory.SmallObject.Iteration.ExtendToSucc | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {J : Type u} [inst_1 : LinearOrder J]
[inst_2 : SuccOrder J] {j : J} (hj : ¬IsMax j) (F : CategoryTheory.Functor (↑(Set.Iic j)) C) {X : C}
(τ : F.obj ⟨j, ⋯⟩ ⟶ X) (X_1 : ↑(Set.Iic j)),
(CategoryTheory.SmallObject.SuccStruct.extendToSuccRestrictionLEIso... | null | true |
PMF.seq.eq_1 | Mathlib.Probability.ProbabilityMassFunction.Constructions | ∀ {α : Type u_1} {β : Type u_2} (q : PMF (α → β)) (p : PMF α), q.seq p = q.bind fun m => p.bind fun a => PMF.pure (m a) | null | true |
Lean.Elab.Tactic.BVDecide.Frontend.SolverMode._sizeOf_1 | Std.Tactic.BVDecide.Syntax | Lean.Elab.Tactic.BVDecide.Frontend.SolverMode → ℕ | null | false |
Equiv.addEquiv._proof_1 | Mathlib.Algebra.Group.TransferInstance | ∀ {α : Type u_2} {β : Type u_1} (e : α ≃ β) [inst : Add β] (x y : α), e.toFun (x + y) = e.toFun x + e.toFun y | null | false |
SimpleGraph.cliqueFree_completeMultipartiteGraph | Mathlib.Combinatorics.SimpleGraph.Clique | ∀ {n : ℕ} {ι : Type u_3} [inst : Fintype ι] (V : ι → Type u_4),
Fintype.card ι < n → (SimpleGraph.completeMultipartiteGraph V).CliqueFree n | A complete `r`-partite graph has no `n`-cliques for `r < n`. | true |
_private.Mathlib.Combinatorics.SimpleGraph.Walk.Subwalks.0.SimpleGraph.Walk.take_isSubwalk_take._simp_1_2 | Mathlib.Combinatorics.SimpleGraph.Walk.Subwalks | ∀ {α : Type u_1} {l₁ l₂ : List α}, l₁ <+: l₂ → (l₁ <:+: l₂) = True | null | false |
MeasureTheory.AEEqFun.pow_toGerm | Mathlib.MeasureTheory.Function.AEEqFun | ∀ {α : Type u_1} {γ : Type u_3} [inst : MeasurableSpace α] {μ : MeasureTheory.Measure α} [inst_1 : TopologicalSpace γ]
[inst_2 : Monoid γ] [inst_3 : ContinuousMul γ] (f : α →ₘ[μ] γ) (n : ℕ), (f ^ n).toGerm = f.toGerm ^ n | null | true |
CategoryTheory.yonedaAddMon._proof_5 | Mathlib.CategoryTheory.Monoidal.Cartesian.Mon | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.CartesianMonoidalCategory C]
(x : CategoryTheory.AddMon C),
{
app := fun x_1 =>
AddMonCat.ofHom
(CategoryTheory.IsAddMonHom.addMonoidHom (CategoryTheory.CategoryStruct.id x).hom (Opposite.unop x_1)),
... | null | false |
SupIrred.ne_bot | Mathlib.Order.Irreducible | ∀ {α : Type u_2} [inst : SemilatticeSup α] {a : α} [inst_1 : OrderBot α], SupIrred a → a ≠ ⊥ | null | true |
_private.Mathlib.NumberTheory.NumberField.Cyclotomic.Galois.0.IsCyclotomicExtension.Rat.mem_subgroupGalEquivSubgroupChar_symm_iff._simp_1_3 | Mathlib.NumberTheory.NumberField.Cyclotomic.Galois | ∀ {M : Type u_1} {R : Type u_2} [inst : CommMonoid M] [inst_1 : CommRing R] [inst_2 : Finite M]
[inst_3 : HasEnoughRootsOfUnity R (Monoid.exponent Mˣ)] {X : Subgroup (MulChar M R)} {m : Mˣ},
(m ∈ (MulChar.subgroupOrderIsoSubgroupMulChar M R).symm (OrderDual.toDual X)) = ∀ χ ∈ X, χ ↑m = 1 | null | false |
HomologicalComplex.mapBifunctor₂₃.d₃_eq | Mathlib.Algebra.Homology.BifunctorAssociator | ∀ {C₁ : Type u_1} {C₂ : Type u_2} {C₂₃ : Type u_4} {C₃ : Type u_5} {C₄ : Type u_6}
[inst : CategoryTheory.Category.{v_1, u_1} C₁] [inst_1 : CategoryTheory.Category.{v_2, u_2} C₂]
[inst_2 : CategoryTheory.Category.{v_3, u_5} C₃] [inst_3 : CategoryTheory.Category.{v_4, u_6} C₄]
[inst_4 : CategoryTheory.Category.{v_... | null | true |
MulRingNorm.mulRingNormEquivAbsoluteValue_symm_apply | Mathlib.Analysis.Normed.Unbundled.RingSeminorm | ∀ {R : Type u_2} [inst : Ring R] [inst_1 : Nontrivial R] (v : AbsoluteValue R ℝ) (x : R),
(MulRingNorm.mulRingNormEquivAbsoluteValue.symm v) x = v x | null | true |
_private.Mathlib.Tactic.NormNum.Ordinal.0.Mathlib.Meta.NormNum.evalOrdinalMod._proof_1 | Mathlib.Tactic.NormNum.Ordinal | ∀ (an bn rn : Q(ℕ)), («$an» % «$bn») =Q «$rn» | null | false |
Set.nonempty_sInter._simp_1 | Mathlib.Data.Set.Lattice | ∀ {α : Type u_1} {c : Set (Set α)}, (⋂₀ c).Nonempty = ∃ a, ∀ b ∈ c, a ∈ b | null | false |
_private.Mathlib.RingTheory.Valuation.ValuationSubring.0.ValuationSubring.ofPrime_idealOfLE._simp_1_2 | Mathlib.RingTheory.Valuation.ValuationSubring | ∀ {M : Type u_1} [inst : MulOneClass M] {s : Subsemigroup M} {x : M} (h_one : 1 ∈ s.carrier),
(x ∈ { toSubsemigroup := s, one_mem' := h_one }) = (x ∈ s) | null | false |
Associates.irreducible_iff_prime_iff | Mathlib.Algebra.GroupWithZero.Associated | ∀ {M : Type u_1} [inst : CommMonoidWithZero M],
(∀ (a : M), Irreducible a ↔ Prime a) ↔ ∀ (a : Associates M), Irreducible a ↔ Prime a | null | true |
DirSupInaccOn | Mathlib.Order.DirSupClosed | {α : Type u_1} → [Preorder α] → Set (Set α) → Set α → Prop | A predicate for a set which is inaccessible by directed suprema of nonempty sets in `D`.
This is the complement of a `DirSupClosedOn` set. | true |
OrdinalApprox.lfpApprox_zero | Mathlib.SetTheory.Ordinal.FixedPointApproximants | ∀ {α : Type u} [inst : CompleteLattice α] (f : α →o α) {x : α}, OrdinalApprox.lfpApprox f x 0 = x | null | true |
hfdifferential._proof_3 | Mathlib.Geometry.Manifold.DerivationBundle | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_6} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {H : Type u_7} [inst_3 : TopologicalSpace H] {I : ModelWithCorners 𝕜 E H} {M : Type u_5}
[inst_4 : TopologicalSpace M] [inst_5 : ChartedSpace H M] {E' : Type u_3} [inst_6 : NormedAddComm... | null | false |
extDeriv_apply_vectorField_of_pairwise_commute | Mathlib.Analysis.Calculus.DifferentialForm.VectorField | ∀ {𝕜 : Type u_1} {E : Type u_2} {F : Type u_3} [inst : NontriviallyNormedField 𝕜] [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {n : ℕ} {x : E}
{ω : E → E [⋀^Fin n]→L[𝕜] F} {V : Fin (n + 1) → E → E},
DifferentiableAt 𝕜 ω x →
(∀ (i :... | Let `ω` be a differentiable `n`-form and `V i` be `n + 1` differentiable vector fields.
If `V i` pairwise commute at `x`, i.e., $[V_i, V_j](x) = 0$ for all `i ≠ j`, then
$$
dω(V_0(x), \dots, V_{n + 1}(x)) = \sum_{i=0}^{n + 1} (-1)^i •
D_x\left(ω\big(x; V_0(x), \dots, \widehat{V_i(x)}, \dots, V_{n + 1}(x)\big)\ri... | true |
Convexity.StdSimplex | Mathlib.Geometry.Convex.ConvexSpace.Defs | (R : Type u) → [LE R] → [AddCommMonoid R] → [One R] → Type v → Type (max u v) | A finitely supported probability distribution over elements of `M` with coefficients in `R`.
The weights are non-negative and sum to 1.
| true |
Std.Internal.List.mem_iff_getKey?_eq_some_and_getValue?_eq_some | Std.Data.Internal.List.Associative | ∀ {α : Type u} [inst : BEq α] [EquivBEq α] {β : Type v} {k : α} {v : β} {l : List ((_ : α) × β)},
Std.Internal.List.DistinctKeys l →
(⟨k, v⟩ ∈ l ↔ Std.Internal.List.getKey? k l = some k ∧ Std.Internal.List.getValue? k l = some v) | null | true |
Composition.recOnAppendSingle._proof_1 | Mathlib.Combinatorics.Enumerative.Composition | ∀ {motive : (n : ℕ) → Composition n → Sort u_1} (k n : ℕ) (c : Composition n),
motive (k + 1 + n) ((Composition.single (k + 1) ⋯).append c).reverse =
motive (n + (k + 1)) (c.reverse.append (Composition.single (k + 1) ⋯)) | null | false |
_private.Mathlib.Analysis.SpecialFunctions.Complex.Circle.0.Circle.not_isPreconnected_compl_pair._simp_1_1 | Mathlib.Analysis.SpecialFunctions.Complex.Circle | ∀ {α : Type u} [inst : TopologicalSpace α] {s : Set α},
IsPreconnected s = ∀ (u v : Set α), IsClosed u → IsClosed v → s ⊆ u ∪ v → s ∩ (u ∩ v) = ∅ → s ⊆ u ∨ s ⊆ v | null | false |
Equiv.Perm.congr_arg | Mathlib.Logic.Equiv.Defs | ∀ {α : Sort u} {f : Equiv.Perm α} {x x' : α}, x = x' → f x = f x' | null | true |
RBTree.RBSet.isEmpty_iff_toList_eq_nil | BatteriesRecycling.RBTree.Lemmas | ∀ {α : Type u_1} {cmp : α → α → Ordering} {t : RBTree.RBSet α cmp}, t.isEmpty = true ↔ t.toList = [] | null | true |
FinVec.prod.eq_def | Mathlib.Data.Fin.Tuple.Reflection | ∀ {α : Type u_1} [inst : Mul α] [inst_1 : One α] (x : ℕ) (x_1 : Fin x → α),
FinVec.prod x_1 =
match x, x_1 with
| 0, x => 1
| 1, v => v 0
| n.succ.succ, v => (FinVec.prod fun i => v i.castSucc) * v (Fin.last (n + 1)) | null | true |
BitVec.toNat_cpop_concat | Init.Data.BitVec.Lemmas | ∀ {w : ℕ} {x : BitVec w} {b : Bool}, (x.concat b).cpop.toNat = b.toNat + x.cpop.toNat | null | true |
Polynomial.recOnHorner._unary._proof_15 | Mathlib.Algebra.Polynomial.Inductions | ∀ {R : Type u_2} [inst : Semiring R] {M : Polynomial R → Sort u_1} (p : Polynomial R),
M (p.divX * Polynomial.X + Polynomial.C 0) = M (p.divX * Polynomial.X + 0) | null | false |
Aesop.instInhabitedNormalizationState.default | Aesop.Tree.Data | Aesop.NormalizationState | null | true |
one_lt_mul_self_iff._simp_2 | Mathlib.Algebra.Order.Monoid.Defs | ∀ {α : Type u_1} [inst : CommMonoid α] [inst_1 : LinearOrder α] [IsOrderedMonoid α] {a : α}, (1 < a * a) = (1 < a) | null | false |
_private.Std.Data.DHashMap.Lemmas.0.Std.DHashMap.mem_alter._simp_1_1 | Std.Data.DHashMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {x : BEq α} {x_1 : Hashable α} {m : Std.DHashMap α β} {a : α},
(a ∈ m) = (m.contains a = true) | null | false |
DifferentiableOn.mul_const | Mathlib.Analysis.Calculus.FDeriv.Mul | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {s : Set E} {𝔸 : Type u_5} [inst_3 : NormedRing 𝔸] [inst_4 : NormedAlgebra 𝕜 𝔸]
{a : E → 𝔸}, DifferentiableOn 𝕜 a s → ∀ (b : 𝔸), DifferentiableOn 𝕜 (fun y => a y * b) s | null | true |
Bot.ctorIdx | Mathlib.Order.Notation | {α : Type u_1} → Bot α → ℕ | null | false |
Quiver.Path.reverse | Mathlib.Combinatorics.Quiver.Symmetric | {V : Type u_2} → [inst : Quiver V] → [Quiver.HasReverse V] → {a b : V} → Quiver.Path a b → Quiver.Path b a | Reverse the direction of a path. | true |
CategoryTheory.Limits.KernelFork.IsLimit.ofιUnop._proof_4 | Mathlib.CategoryTheory.Limits.Shapes.Opposites.Kernels | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{K X Y : Cᵒᵖ} (i : K ⟶ X) {f : X ⟶ Y} (w : CategoryTheory.CategoryStruct.comp i f = 0)
(h : CategoryTheory.Limits.IsLimit (CategoryTheory.Limits.KernelFork.ofι i w)) {Z' : C} (x : Opposite.unop X ⟶ Z')... | null | false |
FiniteField.frobeniusAlgEquiv._proof_1 | Mathlib.FieldTheory.Finite.Basic | ∀ (K : Type u_2) (R : Type u_1) [inst : Field K] [inst_1 : Fintype K] [inst_2 : CommRing R] [inst_3 : Algebra K R]
(p : ℕ) [ExpChar R p] [PerfectRing R p], Function.Bijective ⇑(FiniteField.frobeniusAlgHom K R) | null | false |
UniformSpace.Completion.extensionHom._proof_2 | Mathlib.Topology.Algebra.UniformRing | ∀ {α : Type u_2} [inst : Ring α] {β : Type u_1} [inst_1 : Ring β], AddMonoidHomClass (α →+* β) α β | null | false |
Homeomorph.addRight.eq_1 | Mathlib.Topology.Algebra.Group.Basic | ∀ {G : Type w} [inst : TopologicalSpace G] [inst_1 : AddGroup G] [inst_2 : SeparatelyContinuousAdd G] (a : G),
Homeomorph.addRight a = { toEquiv := Equiv.addRight a, continuous_toFun := ⋯, continuous_invFun := ⋯ } | null | true |
_private.Init.Data.Nat.MinMax.0.Nat.add_min_add_right._simp_1_1 | Init.Data.Nat.MinMax | ∀ {m k n : ℕ}, (m + n ≤ k + n) = (m ≤ k) | null | false |
Quiver.Arborescence.ctorIdx | Mathlib.Combinatorics.Quiver.Arborescence | {V : Type u} → {inst : Quiver V} → Quiver.Arborescence V → ℕ | null | false |
_private.Mathlib.Order.Cover.0.WithTop.covBy_top_iff._simp_1_2 | Mathlib.Order.Cover | ∀ {α : Type u_1} {p : WithTop α → Prop}, (∀ (x : WithTop α), p x) = (p ⊤ ∧ ∀ (x : α), p ↑x) | null | false |
Lean.Elab.Do.withDoBlockResultType | Lean.Elab.Do.Basic | {α : Type} → Lean.Expr → Lean.Elab.Do.DoElabM α → Lean.Elab.Do.DoElabM α | Set the new `do` block result type for the scope of the continuation `k`. | true |
_private.Lean.Data.FuzzyMatching.0.Lean.FuzzyMatching.Score | Lean.Data.FuzzyMatching | Type | Represents a fuzzy matching score where `Score.awful` is the worst score possible. | true |
_private.Qq.Macro.0.Qq.Impl.quoteExpr.match_1 | Qq.Macro | (motive : Qq.Impl.ExprBackSubstResult → Sort u_1) →
(r : Qq.Impl.ExprBackSubstResult) →
((r : Lean.Expr) → motive (Qq.Impl.ExprBackSubstResult.quoted r)) →
((r : Lean.Expr) → motive (Qq.Impl.ExprBackSubstResult.unquoted r)) → motive r | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.