name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
_private.Mathlib.Topology.UrysohnsLemma.0.Urysohns.CU.approx_le_one._simp_1_4 | Mathlib.Topology.UrysohnsLemma | ∀ {α : Type u_1} [inst : DivisionCommMonoid α] (a b : α), b⁻¹ * a = a / b | null | false |
continuousAt_iff_lower_upperSemicontinuousAt | Mathlib.Topology.Semicontinuity.Basic | ∀ {α : Type u_1} [inst : TopologicalSpace α] {x : α} {γ : Type u_4} [inst_1 : LinearOrder γ]
[inst_2 : TopologicalSpace γ] [OrderTopology γ] {f : α → γ},
ContinuousAt f x ↔ LowerSemicontinuousAt f x ∧ UpperSemicontinuousAt f x | null | true |
BoxIntegral.Box.ne_of_disjoint_coe | Mathlib.Analysis.BoxIntegral.Box.Basic | ∀ {ι : Type u_1} {I J : BoxIntegral.Box ι}, Disjoint ↑I ↑J → I ≠ J | null | true |
Std.ToFormat.format | Init.Data.Format.Basic | {α : Type u} → [self : Std.ToFormat α] → α → Std.Format | Converts a value to a `Format` object, with no expectation that the resulting string is valid
code.
| true |
_private.Mathlib.Data.Finsupp.Indicator.0.Finsupp.eq_indicator_iff._proof_1_3 | Mathlib.Data.Finsupp.Indicator | ∀ {ι : Type u_1} {α : Type u_2} [inst : Zero α] (s : Finset ι) (f : (i : ι) → i ∈ s → α) {g : ι → α},
(∀ (i : ι), if hi : i ∈ s then f i hi = g i else g i = 0) ↔ (∀ (i : ι) (hi : i ∈ s), f i hi = g i) ∧ ∀ i ∉ s, g i = 0 | null | false |
«term⅟_» | Mathlib.Algebra.Group.Invertible.Defs | Lean.ParserDescr | The inverse of an `Invertible` element | true |
Sym.cast._proof_4 | Mathlib.Data.Sym.Basic | ∀ {α : Type u_1} {n m : ℕ}, n = m → ∀ (s : Sym α m), (↑s).card = n | null | false |
Lean.Elab.InfoTree | Lean.Elab.InfoTree.Types | Type | The InfoTree is a structure that is generated during elaboration and used
by the language server to look up information about objects at particular points
in the Lean document. For example, tactic information and expected type information in
the infoview and information about completions.
The infotree consists of node... | true |
LinearEquiv.piCongrRight_trans | Mathlib.LinearAlgebra.Pi | ∀ {R : Type u} {ι : Type x} [inst : Semiring R] {φ : ι → Type u_1} {ψ : ι → Type u_2} {χ : ι → Type u_3}
[inst_1 : (i : ι) → AddCommMonoid (φ i)] [inst_2 : (i : ι) → Module R (φ i)] [inst_3 : (i : ι) → AddCommMonoid (ψ i)]
[inst_4 : (i : ι) → Module R (ψ i)] [inst_5 : (i : ι) → AddCommMonoid (χ i)] [inst_6 : (i : ι... | null | true |
CategoryTheory.MonoidalCategory.instMonoidalFunctorTensoringRight._proof_2 | Mathlib.CategoryTheory.Monoidal.End | ∀ (C : Type u_2) [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.MonoidalCategory C] {X Y : C}
(f : X ⟶ Y) (X' : C),
CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCategoryStruct.whiskerRight ((CategoryTheory.MonoidalCategory.tensoringRight C).map f)
((CategoryTheory... | null | false |
AlgebraicClosure.instCommRing._proof_46 | Mathlib.FieldTheory.IsAlgClosed.AlgebraicClosure | ∀ (k : Type u_1) [inst : Field k] (n : ℕ), IntCast.intCast (Int.negSucc n) = -↑(n + 1) | null | false |
CategoryTheory.ObjectProperty.instSmallUnopOfOpposite | Mathlib.CategoryTheory.ObjectProperty.Small | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (P : CategoryTheory.ObjectProperty Cᵒᵖ)
[CategoryTheory.ObjectProperty.Small.{w, v, u} P], CategoryTheory.ObjectProperty.Small.{w, v, u} P.unop | null | true |
_private.Mathlib.Probability.Moments.Variance.0.ProbabilityTheory.evariance_def'._simp_1_7 | Mathlib.Probability.Moments.Variance | ∀ {a b : Prop}, (a ∨ b) = (¬a → b) | null | false |
Set.graphOn_univ_inj | Mathlib.Data.Set.Function | ∀ {α : Type u_1} {β : Type u_2} {f g : α → β}, Set.graphOn f Set.univ = Set.graphOn g Set.univ ↔ f = g | null | true |
ExpGrowth.expGrowthInf_of_eventually_ge | Mathlib.Analysis.Asymptotics.ExpGrowth | ∀ {u v : ℕ → ENNReal} {b : ENNReal},
b ≠ 0 → (∀ᶠ (n : ℕ) in Filter.atTop, b * u n ≤ v n) → ExpGrowth.expGrowthInf u ≤ ExpGrowth.expGrowthInf v | null | true |
_private.Mathlib.Geometry.Manifold.VectorBundle.MDifferentiable.0.mdifferentiableWithinAt_totalSpace._simp_1_1 | Mathlib.Geometry.Manifold.VectorBundle.MDifferentiable | ∀ {𝕜 : 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 | false |
AddAction.zmultiplesQuotientStabilizerEquiv._proof_6 | Mathlib.Data.ZMod.QuotientGroup | ∀ {α : Type u_1} {β : Type u_2} [inst : AddGroup α] (a : α) [inst_1 : AddAction α β] (b : β),
Function.Injective
⇑(QuotientAddGroup.map (AddSubgroup.zmultiples ↑(Function.minimalPeriod (fun x => a +ᵥ x) b))
(AddAction.stabilizer (↥(AddSubgroup.zmultiples a)) b) ((zmultiplesHom ↥(AddSubgroup.zmultiples... | null | false |
Submonoid.isMulCommutative_iSup | Mathlib.Algebra.Group.Submonoid.Membership | ∀ {M : Type u_1} [inst : MulOneClass M] {ι : Sort u_4} [Nonempty ι] {S : ι → Submonoid M}
[hS : ∀ (i : ι), IsMulCommutative ↥(S i)], Directed (fun x1 x2 => x1 ≤ x2) S → IsMulCommutative ↥(⨆ i, S i) | null | true |
PadicInt.appr._f | Mathlib.NumberTheory.Padics.RingHoms | {p : ℕ} → [hp_prime : Fact (Nat.Prime p)] → (x : ℕ) → Nat.below (motive := fun x => ℤ_[p] → ℕ) x → ℤ_[p] → ℕ | null | false |
SimpleGraph.Walk.length_dropLast | Mathlib.Combinatorics.SimpleGraph.Walk.Operations | ∀ {V : Type u} {G : SimpleGraph V} {u v : V} (p : G.Walk u v), p.dropLast.length = p.length - 1 | null | true |
Std.DTreeMap.getKey?_eq_some_getKeyD_of_contains | Std.Data.DTreeMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t : Std.DTreeMap α β cmp} [Std.TransCmp cmp] {a fallback : α},
t.contains a = true → t.getKey? a = some (t.getKeyD a fallback) | null | true |
Nat.instCommutativeHMul | Init.Data.Nat.Basic | Std.Commutative fun x1 x2 => x1 * x2 | null | true |
Std.DTreeMap.Internal.Impl.eraseManyEntries! | Std.Data.DTreeMap.Internal.Operations | {α : Type u} →
{β : α → Type v} →
[inst : Ord α] →
{ρ : Type w} → [ForIn Id ρ ((a : α) × β a)] → (t : Std.DTreeMap.Internal.Impl α β) → ρ → t.IteratedSlowErasureFrom | Slower version of `eraseManyEntries` which can be used in absence of balance information but still
assumes the preconditions of `eraseManyEntries`, otherwise might panic.
| true |
DiscreteTiling.Protoset.coe_injective | Mathlib.Combinatorics.Tiling.Tile | ∀ {G : Type u_1} {X : Type u_2} {ιₚ : Type u_3} [inst : Group G] [inst_1 : MulAction G X],
Function.Injective DiscreteTiling.Protoset.tiles | null | true |
Std.Do.SPred.Tactic.HasFrame.mk | Std.Do.SPred.DerivedLaws | ∀ {σs : List (Type u)} {P : Std.Do.SPred σs} {P' : outParam (Std.Do.SPred σs)} {φ : outParam Prop},
(P ⊣⊢ₛ P' ∧ ⌜φ⌝) → Std.Do.SPred.Tactic.HasFrame P P' φ | null | true |
CategoryTheory.Functor.RightExtension.isPointwiseRightKanExtensionAtEquivOfIso' | Mathlib.CategoryTheory.Functor.KanExtension.Pointwise | {C : Type u_1} →
{D : Type u_2} →
{H : Type u_4} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
[inst_1 : CategoryTheory.Category.{v_2, u_2} D] →
[inst_2 : CategoryTheory.Category.{v_4, u_4} H] →
{L : CategoryTheory.Functor C D} →
{F : CategoryTheory.Functor C ... | The condition of being a pointwise right Kan extension at an object `Y` is
unchanged by replacing `Y` by an isomorphic object `Y'`. | true |
CategoryTheory.Idempotents.Karoubi.comp_proof | Mathlib.CategoryTheory.Idempotents.Karoubi | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {P Q R : CategoryTheory.Idempotents.Karoubi C}
(g : Q.Hom R) (f : P.Hom Q),
CategoryTheory.CategoryStruct.comp P.p
(CategoryTheory.CategoryStruct.comp (CategoryTheory.CategoryStruct.comp f.f g.f) R.p) =
CategoryTheory.CategoryStruct.comp f.f g... | null | true |
_private.Lean.Meta.Tactic.Simp.BuiltinSimprocs.UInt.0.UInt16.reduceEq._regBuiltin.UInt16.reduceEq.declare_1._@.Lean.Meta.Tactic.Simp.BuiltinSimprocs.UInt.3273093604._hygCtx._hyg.9 | Lean.Meta.Tactic.Simp.BuiltinSimprocs.UInt | IO Unit | null | false |
RestrictedProduct.mulSingle_eq_one_iff._simp_2 | Mathlib.Topology.Algebra.RestrictedProduct.Basic | ∀ {ι : Type u_1} {S : ι → Type u_3} {G : ι → Type u_4} [inst : (i : ι) → SetLike (S i) (G i)] (A : (i : ι) → S i)
[inst_1 : DecidableEq ι] [inst_2 : (i : ι) → One (G i)] [inst_3 : ∀ (i : ι), OneMemClass (S i) (G i)] (i : ι)
{x : G i}, (RestrictedProduct.mulSingle A i x = 1) = (x = 1) | null | false |
IsOpen.nhdsWithin_eq | Mathlib.Topology.NhdsWithin | ∀ {α : Type u_1} [inst : TopologicalSpace α] {a : α} {s : Set α}, IsOpen s → a ∈ s → nhdsWithin a s = nhds a | null | true |
CategoryTheory.ObjectProperty.instNonemptyPair | Mathlib.CategoryTheory.ObjectProperty.Basic | ∀ {C : Type u} [inst : CategoryTheory.CategoryStruct.{v, u} C] (X Y : C),
(CategoryTheory.ObjectProperty.pair X Y).Nonempty | null | true |
_private.Init.Data.List.Impl.0.List.eraseP_eq_erasePTR.go.match_1 | Init.Data.List.Impl | ∀ (α : Type u_1) (motive : List α → Prop) (x : List α),
(∀ (_ : Unit), motive []) → (∀ (x : α) (xs : List α), motive (x :: xs)) → motive x | null | false |
Asymptotics.isLittleO_const_id_atTop | Mathlib.Analysis.Asymptotics.Lemmas | ∀ {E'' : Type u_9} [inst : NormedAddCommGroup E''] (c : E''), (fun _x => c) =o[Filter.atTop] id | null | true |
Lean.Lsp.ReferenceContext.ctorIdx | Lean.Data.Lsp.LanguageFeatures | Lean.Lsp.ReferenceContext → ℕ | null | false |
CategoryTheory.effectiveEpiFamilyStructOfIsIsoDesc | Mathlib.CategoryTheory.EffectiveEpi.Basic | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
{B : C} →
{α : Type u_2} →
(X : α → C) →
(π : (a : α) → X a ⟶ B) →
[inst_1 : CategoryTheory.Limits.HasCoproduct X] →
[CategoryTheory.IsIso (CategoryTheory.Limits.Sigma.desc π)] → CategoryTheory.Effec... | A family of morphisms with the same target inducing an isomorphism from the coproduct to the target
is an `EffectiveEpiFamily`.
| true |
StarSubsemiring.ofClass._proof_3 | Mathlib.Algebra.Star.Subsemiring | ∀ {S : Type u_2} {R : Type u_1} [inst : NonAssocSemiring R] [inst_1 : SetLike S R] [SubsemiringClass S R] (s : S)
{a b : R}, a ∈ s → b ∈ s → a + b ∈ s | null | false |
Orientation.volumeForm_def | Mathlib.Analysis.InnerProductSpace.Orientation | ∀ {E : Type u_2} [inst : NormedAddCommGroup E] [inst_1 : InnerProductSpace ℝ E] {n : ℕ}
[_i : Fact (Module.finrank ℝ E = n)] (o : Orientation ℝ E (Fin n)),
o.volumeForm =
Nat.casesAuxOn (motive := fun a => n = a → E [⋀^Fin n]→ₗ[ℝ] ℝ) n
(fun h =>
Eq.ndrec (motive := fun {n} =>
[_i : Fact ... | null | true |
Std.DTreeMap.Raw.maxKey?_mem | Std.Data.DTreeMap.Raw.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t : Std.DTreeMap.Raw α β cmp} [Std.TransCmp cmp],
t.WF → ∀ {km : α}, t.maxKey? = some km → km ∈ t | null | true |
exists_stronglyMeasurable_limit_of_tendsto_ae | Mathlib.MeasureTheory.Function.StronglyMeasurable.AEStronglyMeasurable | ∀ {α : Type u_1} {β : Type u_2} [inst : TopologicalSpace β] {m₀ : MeasurableSpace α} {μ : MeasureTheory.Measure α}
[TopologicalSpace.PseudoMetrizableSpace β] {f : ℕ → α → β},
(∀ (n : ℕ), MeasureTheory.AEStronglyMeasurable (f n) μ) →
(∀ᵐ (x : α) ∂μ, ∃ l, Filter.Tendsto (fun n => f n x) Filter.atTop (nhds l)) →
... | If a sequence of almost everywhere strongly measurable functions converges almost everywhere,
one can select a strongly measurable function as the almost everywhere limit. | true |
Lean.Elab.HoverableInfoPrio.mk.injEq | Lean.Elab.InfoTree.Util | ∀ (isHoverPosOnStop : Bool) (size : ℕ) (isVariableInfo isPartialTermInfo isHoverPosOnStop_1 : Bool) (size_1 : ℕ)
(isVariableInfo_1 isPartialTermInfo_1 : Bool),
({ isHoverPosOnStop := isHoverPosOnStop, size := size, isVariableInfo := isVariableInfo,
isPartialTermInfo := isPartialTermInfo } =
{ isHoverP... | null | true |
PolynomialModule.eval_apply | Mathlib.Algebra.Polynomial.Module.Basic | ∀ {R : Type u_2} {M : Type u_3} [inst : CommRing R] [inst_1 : AddCommGroup M] [inst_2 : Module R M] (r : R)
(p : PolynomialModule R M), (PolynomialModule.eval r) p = p.coeff.sum fun i m => r ^ i • m | null | true |
Quiver.Path.weight | Mathlib.Combinatorics.Quiver.Path.Weight | {V : Type u_1} →
[inst : Quiver V] → {R : Type u_2} → [Monoid R] → ({i j : V} → (i ⟶ j) → R) → {i j : V} → Quiver.Path i j → R | The weight of a path is the product of the weights of its edges. | true |
CategoryTheory.Abelian.SpectralObject.spectralSequenceHomologyData_iso_hom | Mathlib.Algebra.Homology.SpectralObject.SpectralSequence | ∀ {C : Type u_1} {ι : Type u_2} {κ : Type u_3} [inst : CategoryTheory.Category.{v_1, u_1} C]
[inst_1 : CategoryTheory.Abelian C] [inst_2 : Preorder ι] (X : CategoryTheory.Abelian.SpectralObject C ι)
{c : ℤ → ComplexShape κ} {r₀ : ℤ} (data : CategoryTheory.Abelian.SpectralObject.SpectralSequenceDataCore ι c r₀)
[i... | null | true |
Lean.Elab.Tactic.evalWithAnnotateState | Lean.Elab.Tactic.BuiltinTactic | Lean.Elab.Tactic.Tactic | null | true |
_private.Mathlib.GroupTheory.Coset.Basic.0.QuotientGroup.orbit_mk_eq_smul._simp_1_2 | Mathlib.GroupTheory.Coset.Basic | ∀ {α : Type u_1} [inst : Group α] {s : Subgroup α} {x y : α}, (x⁻¹ * y ∈ s) = (QuotientGroup.leftRel s) x y | null | false |
TrivialLieModule.instLieRingModule._proof_2 | Mathlib.Algebra.Lie.Abelian | ∀ (R : Type u_1) (L : Type u_2) (M : Type u_3) [inst : AddCommGroup M] (x : L) (m n : TrivialLieModule R L M), 0 = 0 + 0 | null | false |
RelIso.sumLexComplLeft_symm_apply | Mathlib.Order.Hom.Lex | ∀ {α : Type u_1} {r : α → α → Prop} {x : α} [inst : IsTrans α r] [inst_1 : Std.Trichotomous r] [inst_2 : DecidableRel r]
(a : { x_1 // r x_1 x } ⊕ { x_1 // ¬r x_1 x }), (RelIso.sumLexComplLeft r x) a = (Equiv.sumCompl fun x_1 => r x_1 x) a | null | true |
Shrink.continuousLinearEquiv | Mathlib.Topology.Algebra.Module.TransferInstance | (R : Type u_1) →
(α : Type u_2) →
[inst : Small.{v, u_2} α] →
[inst_1 : AddCommMonoid α] →
[inst_2 : TopologicalSpace α] → [inst_3 : Semiring R] → [inst_4 : Module R α] → Shrink.{v, u_2} α ≃L[R] α | Shrinking `α` to a smaller universe preserves the continuous module structure. | true |
_private.Init.Internal.Order.Basic.0.Lean.Order.implication_order_monotone_or.match_1_1 | Init.Internal.Order.Basic | ∀ {α : Sort u_1} (f₁ f₂ : α → Lean.Order.ImplicationOrder) (x : α) (motive : f₁ x ∨ f₂ x → Prop) (h : f₁ x ∨ f₂ x),
(∀ (hfx₁ : f₁ x), motive ⋯) → (∀ (hfx₂ : f₂ x), motive ⋯) → motive h | null | false |
AffineMap.comp | Mathlib.LinearAlgebra.AffineSpace.AffineMap | {k : Type u_1} →
{V1 : Type u_2} →
{P1 : Type u_3} →
{V2 : Type u_4} →
{P2 : Type u_5} →
{V3 : Type u_6} →
{P3 : Type u_7} →
[inst : Ring k] →
[inst_1 : AddCommGroup V1] →
[inst_2 : Module k V1] →
[inst_3 : Add... | Composition of affine maps. | true |
_private.Mathlib.Combinatorics.Matroid.Map.0.Matroid.comap_isBasis_iff._simp_1_10 | Mathlib.Combinatorics.Matroid.Map | ∀ {α : Type u_1} {β : Type u_2} {s : Set α} {t : Set β} {f : α → β}, (s ⊆ f ⁻¹' t) = (f '' s ⊆ t) | null | false |
OrderMonoidIso.val_inv_unitsCongr_symm_apply | Mathlib.Algebra.Order.Hom.Units | ∀ {α : Type u_1} {β : Type u_2} [inst : Preorder α] [inst_1 : Monoid α] [inst_2 : Preorder β] [inst_3 : Monoid β]
(e : α ≃*o β) (a : βˣ), ↑(e.unitsCongr.symm a)⁻¹ = (↑e).symm ↑a⁻¹ | null | true |
Lean.Meta.instReprCoeFnType | Lean.Meta.CoeAttr | Repr Lean.Meta.CoeFnType | null | true |
Lean.IR.Sorry.State.mk.inj | Lean.Compiler.IR.Sorry | ∀ {localSorryMap : Lean.NameMap Lean.Name} {modified : Bool} {localSorryMap_1 : Lean.NameMap Lean.Name}
{modified_1 : Bool},
{ localSorryMap := localSorryMap, modified := modified } =
{ localSorryMap := localSorryMap_1, modified := modified_1 } →
localSorryMap = localSorryMap_1 ∧ modified = modified_1 | null | true |
_private.Lean.Elab.BuiltinTerm.0.Lean.Elab.Term.elabWaitIfTypeMVar._regBuiltin.Lean.Elab.Term.elabWaitIfTypeMVar_1 | Lean.Elab.BuiltinTerm | IO Unit | null | false |
ContinuousLinearMap.opENorm_flip | Mathlib.Analysis.Normed.Operator.Bilinear | ∀ {𝕜 : Type u_1} {𝕜₂ : Type u_2} {𝕜₃ : Type u_3} {E : Type u_4} {F : Type u_8} {G : Type u_12}
[inst : SeminormedAddCommGroup E] [inst_1 : SeminormedAddCommGroup F] [inst_2 : SeminormedAddCommGroup G]
[inst_3 : NontriviallyNormedField 𝕜] [inst_4 : NontriviallyNormedField 𝕜₂] [inst_5 : NontriviallyNormedField �... | null | true |
Mathlib.Tactic.Monoidal.evalWhiskerLeft_comp | Mathlib.Tactic.CategoryTheory.Monoidal.Normalize | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.MonoidalCategory C] {f g h i : C}
{η : h ⟶ i}
{η₁ : CategoryTheory.MonoidalCategoryStruct.tensorObj g h ⟶ CategoryTheory.MonoidalCategoryStruct.tensorObj g i}
{η₂ :
CategoryTheory.MonoidalCategoryStruct.tensorObj f (CategoryTheo... | null | true |
Lean.Elab.Term.tryPostponeIfHasMVars | Lean.Elab.Term.TermElabM | Option Lean.Expr → String → Lean.Elab.TermElabM Lean.Expr | Throws `Exception.postpone`, if `expectedType?` contains unassigned metavariables.
If `mayPostpone == false`, it throws error `msg`.
| true |
_private.Init.Data.String.Pattern.String.0.String.Slice.Pattern.ForwardSliceSearcher.buildTable._proof_11 | Init.Data.String.Pattern.String | ∀ (pat : String.Slice) (table : Array ℕ) (guess : ℕ) (hg : guess < table.size) (this : table[guess - 1] < guess),
¬table[guess - 1] < table.size → False | null | false |
Primrec.list_flatten | Mathlib.Computability.Primrec.List | ∀ {α : Type u_1} [inst : Primcodable α], Primrec List.flatten | null | true |
Turing.ToPartrec.Code.succ | Mathlib.Computability.TuringMachine.Config | Turing.ToPartrec.Code | null | true |
CategoryTheory.IsHomLift.eq_of_isHomLift | Mathlib.CategoryTheory.FiberedCategory.HomLift | ∀ {𝒮 : Type u₁} {𝒳 : Type u₂} [inst : CategoryTheory.Category.{v₁, u₂} 𝒳] [inst_1 : CategoryTheory.Category.{v₂, u₁} 𝒮]
(p : CategoryTheory.Functor 𝒳 𝒮) {a b : 𝒳} (f : p.obj a ⟶ p.obj b) (φ : a ⟶ b) [p.IsHomLift f φ], f = p.map φ | null | true |
RootPairing.InvariantForm.isOrthogonal_reflection | Mathlib.LinearAlgebra.RootSystem.RootPositive | ∀ {ι : Type u_1} {R : Type u_2} {M : Type u_4} {N : Type u_5} [inst : CommRing R] [inst_1 : AddCommGroup M]
[inst_2 : Module R M] [inst_3 : AddCommGroup N] [inst_4 : Module R N] {P : RootPairing ι R M N}
(self : P.InvariantForm) (i : ι), LinearMap.IsOrthogonal self.form ⇑(P.reflection i) | null | true |
PresheafOfModules.presheaf.eq_1 | Mathlib.Algebra.Category.ModuleCat.Presheaf.Free | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {R : CategoryTheory.Functor Cᵒᵖ RingCat}
(M : PresheafOfModules R),
M.presheaf =
{ obj := fun X => (CategoryTheory.forget₂ (ModuleCat ↑(R.obj X)) Ab).obj (M.obj X),
map := fun {X Y} f => AddCommGrpCat.ofHom (AddMonoidHom.mk' ⇑(CategoryTheory.Conc... | null | true |
GenContFract.of_s_head | Mathlib.Algebra.ContinuedFractions.Computation.Translations | ∀ {K : Type u_1} [inst : DivisionRing K] [inst_1 : LinearOrder K] [inst_2 : FloorRing K] {v : K},
Int.fract v ≠ 0 → (GenContFract.of v).s.head = some { a := 1, b := ↑⌊(Int.fract v)⁻¹⌋ } | This gives the first pair of coefficients of the continued fraction of a non-integer `v`.
| true |
Associates.is_pow_of_dvd_count | Mathlib.RingTheory.UniqueFactorizationDomain.FactorSet | ∀ {α : Type u_1} [inst : CommMonoidWithZero α] [inst_1 : UniqueFactorizationMonoid α]
[inst_2 : DecidableEq (Associates α)] [inst_3 : (p : Associates α) → Decidable (Irreducible p)] {a : Associates α},
a ≠ 0 → ∀ {k : ℕ}, (∀ (p : Associates α), Irreducible p → k ∣ p.count a.factors) → ∃ b, a = b ^ k | null | true |
Quaternion.dualNumberEquiv._proof_2 | Mathlib.Algebra.DualQuaternion | ∀ {R : Type u_1} [inst : CommRing R],
Function.RightInverse
(fun d =>
{ re := ((TrivSqZeroExt.fst d).re, (TrivSqZeroExt.snd d).re),
imI := ((TrivSqZeroExt.fst d).imI, (TrivSqZeroExt.snd d).imI),
imJ := ((TrivSqZeroExt.fst d).imJ, (TrivSqZeroExt.snd d).imJ),
imK := ((TrivSqZeroExt.fst... | null | false |
_private.Mathlib.Tactic.Polynomial.Basic.0.Mathlib.Tactic.Polynomial._aux_Mathlib_Tactic_Polynomial_Basic___macroRules_Mathlib_Tactic_Polynomial_tacticPolynomial_nf!__1.match_1 | Mathlib.Tactic.Polynomial.Basic | (motive : Option Lean.Syntax → Sort u_1) →
(x : Option Lean.Syntax) → ((x : Lean.Syntax) → motive (some x)) → (Unit → motive none) → motive x | null | false |
_private.Mathlib.Util.CompileInductive.0.Mathlib.Util.replaceConst.match_1 | Mathlib.Util.CompileInductive | (motive : Lean.Expr → Sort u_1) →
(x : Lean.Expr) →
((n : Lean.Name) → (us : List Lean.Level) → motive (Lean.Expr.const n us)) → ((x : Lean.Expr) → motive x) → motive x | null | false |
CategoryTheory.Bicategory.associator_naturality_middle_assoc | Mathlib.CategoryTheory.Bicategory.Basic | ∀ {B : Type u} [inst : CategoryTheory.Bicategory B] {a b c d : B} (f : a ⟶ b) {g g' : b ⟶ c} (η : g ⟶ g') (h : c ⟶ d)
{Z : a ⟶ d} (h_1 : CategoryTheory.CategoryStruct.comp f (CategoryTheory.CategoryStruct.comp g' h) ⟶ Z),
CategoryTheory.CategoryStruct.comp
(CategoryTheory.Bicategory.whiskerRight (CategoryTheo... | null | true |
differentiableOn_pi'' | Mathlib.Analysis.Calculus.FDeriv.Prod | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {s : Set E} {ι : Type u_6} {F' : ι → Type u_7}
[inst_3 : (i : ι) → NormedAddCommGroup (F' i)] [inst_4 : (i : ι) → NormedSpace 𝕜 (F' i)] {Φ : E → (i : ι) → F' i},
(∀ (i : ι), Differenti... | null | true |
Finset.prod_lt_prod_of_nonempty₀ | Mathlib.Algebra.Order.BigOperators.GroupWithZero.Finset | ∀ {ι : Type u_1} {R : Type u_2} [inst : CommMonoidWithZero R] [inst_1 : PartialOrder R] [ZeroLEOneClass R]
[PosMulStrictMono R] [Nontrivial R] {f g : ι → R} {s : Finset ι},
(∀ i ∈ s, 0 < f i) → (∀ i ∈ s, f i < g i) → s.Nonempty → ∏ i ∈ s, f i < ∏ i ∈ s, g i | null | true |
Monoid.End.instInhabited | Mathlib.Algebra.Group.Hom.Defs | (M : Type u_4) → [inst : MulOne M] → Inhabited (Monoid.End M) | null | true |
DFinsupp.subtypeSupportEqEquiv._proof_5 | Mathlib.Data.DFinsupp.Defs | ∀ {ι : Type u_1} {β : ι → Type u_2} [inst : DecidableEq ι] [inst_1 : (i : ι) → Zero (β i)]
[inst_2 : (i : ι) → (x : β i) → Decidable (x ≠ 0)] (s : Finset ι) (f : (i : ↥s) → { x // x ≠ 0 }) (i : ι),
i ∈ (DFinsupp.mk s fun i => ↑(f i)).support ↔ i ∈ s | null | false |
CategoryTheory.Grp.instMonoidalMonForget₂Mon._proof_6 | Mathlib.CategoryTheory.Monoidal.Grp | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.CartesianMonoidalCategory C]
[inst_2 : CategoryTheory.BraidedCategory C] (X Y Z : CategoryTheory.Grp C),
CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCategoryStruct.whiskerRight
(CategoryTheory.Catego... | null | false |
ne_zero_and_ne_zero_of_mul | Mathlib.Algebra.GroupWithZero.Basic | ∀ {M₀ : Type u_1} [inst : MulZeroClass M₀] {a b : M₀}, a * b ≠ 0 → a ≠ 0 ∧ b ≠ 0 | null | true |
_private.Mathlib.Analysis.MellinInversion.0.mellin_eq_fourier._simp_1_6 | Mathlib.Analysis.MellinInversion | ∀ {G₀ : Type u_3} [inst : GroupWithZero G₀] {a : G₀} (n : ℤ), a ≠ 0 → (a ^ n = 0) = False | null | false |
DivisionSemiring.mk.noConfusion | Mathlib.Algebra.Field.Defs | {K : Type u_2} →
{P : Sort u} →
{toSemiring : Semiring K} →
{toInv : Inv K} →
{toDiv : Div K} →
{toZPow : ZPow K} →
{div_eq_mul_inv : autoParam (∀ (a b : K), a / b = a * b⁻¹) DivInvMonoid.div_eq_mul_inv._autoParam} →
{zpow_zero' : autoParam (∀ (a : K), a ^ 0 = 1) ... | null | false |
_private.Mathlib.Probability.Distributions.Gaussian.Real.0.ProbabilityTheory.gaussianPDFReal_inv_mul._simp_1_4 | Mathlib.Probability.Distributions.Gaussian.Real | ∀ {α : Type u_2} [inst : Zero α] [inst_1 : OfNat α 3] [NeZero 3], (3 = 0) = False | null | false |
getElem?_eq_none_iff._simp_1 | Init.GetElem | ∀ {cont : Type u_1} {idx : Type u_2} {elem : Type u_3} {dom : cont → idx → Prop} [inst : GetElem? cont idx elem dom]
[LawfulGetElem cont idx elem dom] (c : cont) (i : idx) [Decidable (dom c i)], (c[i]? = none) = ¬dom c i | null | false |
_private.Init.Data.String.Decode.0.Char.utf8Size_eq_four_iff._proof_1_5 | Init.Data.String.Decode | ∀ {c : Char}, 127 < c.toNat → c.toNat ≤ 2047 → ¬c.toNat ≤ 65535 → False | null | false |
Std.PRange.UpwardEnumerable.succMany?_succ?_eq_succ?_bind_succMany? | Init.Data.Range.Polymorphic.UpwardEnumerable | ∀ {α : Type u_1} [inst : Std.PRange.UpwardEnumerable α] [Std.PRange.LawfulUpwardEnumerable α] (n : ℕ) (a : α),
Std.PRange.succMany? (n + 1) a = (Std.PRange.succ? a).bind fun x => Std.PRange.succMany? n x | null | true |
Nat.add_le_add_iff_left._simp_1 | Init.Data.Nat.Basic | ∀ {m k n : ℕ}, (n + m ≤ n + k) = (m ≤ k) | null | false |
Subfield.mk.congr_simp | Mathlib.Algebra.Field.Subfield.Basic | ∀ {K : Type u} [inst : DivisionRing K] (toSubring toSubring_1 : Subring K) (e_toSubring : toSubring = toSubring_1)
(inv_mem' : ∀ x ∈ toSubring.carrier, x⁻¹ ∈ toSubring.carrier),
{ toSubring := toSubring, inv_mem' := inv_mem' } = { toSubring := toSubring_1, inv_mem' := ⋯ } | null | true |
Polynomial.smeval_assoc_X_pow | Mathlib.Algebra.Polynomial.Smeval | ∀ (R : Type u_1) [inst : Semiring R] (p : Polynomial R) {S : Type u_2} [inst_1 : NonAssocSemiring S]
[inst_2 : Module R S] [inst_3 : Pow S ℕ] (x : S) [NatPowAssoc S] [IsScalarTower R S S] (m n : ℕ),
p.smeval x * x ^ m * x ^ n = p.smeval x * (x ^ m * x ^ n) | null | true |
smul_mem_asymptoticCone_iff._simp_1 | Mathlib.Topology.Algebra.AsymptoticCone | ∀ {k : Type u_1} {V : Type u_2} {P : Type u_3} [inst : Field k] [inst_1 : LinearOrder k] [inst_2 : AddCommGroup V]
[inst_3 : Module k V] [inst_4 : AddTorsor V P] [inst_5 : TopologicalSpace V] [inst_6 : TopologicalSpace k]
[OrderTopology k] [IsStrictOrderedRing k] [IsTopologicalAddGroup V] [ContinuousSMul k V] {s : ... | null | false |
CategoryTheory.Limits.CokernelCofork.isColimitMapBifunctor.exists_desc | Mathlib.CategoryTheory.Limits.Preserves.BifunctorCokernel | ∀ {C₁ : Type u_1} {C₂ : Type u_2} {C : Type u_3} [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.Limits.HasZeroMorphisms C₁] [inst_4 : CategoryTheory.Limits.HasZeroMorphisms C₂]
[inst_5 : Categ... | null | true |
CompleteOrthogonalIdempotents.lift_of_isNilpotent_ker | Mathlib.RingTheory.Idempotents | ∀ {R : Type u_1} {S : Type u_2} [inst : Ring R] [inst_1 : Ring S] (f : R →+* S) {I : Type u_3} [inst_2 : Fintype I],
(∀ x ∈ RingHom.ker f, IsNilpotent x) →
∀ {e : I → S},
CompleteOrthogonalIdempotents e →
(∀ (i : I), e i ∈ f.range) → ∃ e', CompleteOrthogonalIdempotents e' ∧ ⇑f ∘ e' = e | A system of complete orthogonal idempotents lift along nil ideals. | true |
_private.Lean.Meta.Tactic.Grind.CasesMatch.0.Lean.Meta.Grind.casesMatch.match_6 | Lean.Meta.Tactic.Grind.CasesMatch | (motive : Lean.Expr × Array Lean.Expr → Sort u_1) →
(x : Lean.Expr × Array Lean.Expr) →
((motive_1 : Lean.Expr) → (eqRefls : Array Lean.Expr) → motive (motive_1, eqRefls)) → motive x | null | false |
AddAction.instElemOrbit_1._proof_1 | Mathlib.GroupTheory.GroupAction.Defs | ∀ {G : Type u_2} {α : Type u_1} [inst : AddGroup G] [inst_1 : AddAction G α] (x : AddAction.orbitRel.Quotient G α)
(g g' : G) (a' : ↑x.orbit), (g + g') +ᵥ a' = g +ᵥ g' +ᵥ a' | null | false |
ContractingWith.fixedPoint_unique | Mathlib.Topology.MetricSpace.Contracting | ∀ {α : Type u_1} [inst : MetricSpace α] {K : NNReal} {f : α → α} (hf : ContractingWith K f) [inst_1 : Nonempty α]
[inst_2 : CompleteSpace α] {x : α}, Function.IsFixedPt f x → x = ContractingWith.fixedPoint f hf | null | true |
_private.Lean.Parser.Extension.0.Lean.Parser.compileParserDescr.visit.match_3 | Lean.Parser.Extension | (motive : Option Lean.Parser.ParserCategory → Sort u_1) →
(x : Option Lean.Parser.ParserCategory) →
((val : Lean.Parser.ParserCategory) → motive (some val)) → (Unit → motive none) → motive x | null | false |
Lean.PrettyPrinter.Delaborator.State.mk._flat_ctor | Lean.PrettyPrinter.Delaborator.Basic | ℕ →
Lean.SubExpr.PosMap Lean.Elab.Info →
Lean.PrettyPrinter.Delaborator.SubExpr.HoleIterator → Lean.PrettyPrinter.Delaborator.State | null | false |
_private.Mathlib.LinearAlgebra.Matrix.Determinant.Bird.Defs.0.BirdDet.birdDet.match_1.eq_1 | Mathlib.LinearAlgebra.Matrix.Determinant.Bird.Defs | ∀ (motive : ℕ → Sort u_1) (h_1 : Unit → motive 0) (h_2 : (k : ℕ) → motive k.succ),
(match 0 with
| 0 => h_1 ()
| k.succ => h_2 k) =
h_1 () | null | true |
LocalizedModule.instRing._proof_9 | Mathlib.Algebra.Module.LocalizedModule.Basic | ∀ {R : Type u_1} [inst : CommSemiring R] {A : Type u_2} [inst_1 : Ring A] [inst_2 : Algebra R A] {S : Submonoid R},
autoParam (∀ (n : ℕ), IntCast.intCast (Int.negSucc n) = -↑(n + 1)) AddGroupWithOne.intCast_negSucc._autoParam | null | false |
MeasureTheory.Measure.rnDeriv_add_right_of_absolutelyContinuous_of_mutuallySingular | Mathlib.MeasureTheory.Measure.Decomposition.RadonNikodym | ∀ {α : Type u_1} {m : MeasurableSpace α} {μ ν ν' : MeasureTheory.Measure α} [μ.HaveLebesgueDecomposition ν]
[μ.HaveLebesgueDecomposition (ν + ν')] [MeasureTheory.SigmaFinite ν],
μ.AbsolutelyContinuous ν → ν.MutuallySingular ν' → μ.rnDeriv (ν + ν') =ᵐ[ν] μ.rnDeriv ν | Auxiliary lemma for `rnDeriv_add_right_of_mutuallySingular`. | true |
Multiset.foldl_zero | Mathlib.Data.Multiset.MapFold | ∀ {α : Type u_1} {β : Type v} (f : β → α → β) [inst : RightCommutative f] (b : β), Multiset.foldl f b 0 = b | null | true |
Finset.bipartiteBelow.eq_1 | Mathlib.Combinatorics.Enumerative.DoubleCounting | ∀ {α : Type u_2} {β : Type u_3} (r : α → β → Prop) (s : Finset α) (b : β) [inst : (a : α) → Decidable (r a b)],
Finset.bipartiteBelow r s b = {a ∈ s | r a b} | null | true |
Lean.Meta.Sym.DSimp.Cache | Lean.Meta.Sym.DSimp.DSimpM | Type | Cache mapping expressions (by pointer equality) to their simplified results. | true |
Batteries.AssocList.findEntryP?._unsafe_rec | Batteries.Data.AssocList.Basic | {α : Type u_1} → {β : Type u_2} → (α → β → Bool) → Batteries.AssocList α β → Option (α × β) | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.