name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11.5k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
LinearMap.instDistribMulActionDomMulActOfSMulCommClass._proof_3 | Mathlib.Algebra.Module.LinearMap.Basic | ∀ {R : Type u_4} {R' : Type u_5} {M : Type u_3} {M' : Type u_2} [inst : Semiring R] [inst_1 : Semiring R']
[inst_2 : AddCommMonoid M] [inst_3 : AddCommMonoid M'] [inst_4 : Module R M] [inst_5 : Module R' M'] {σ₁₂ : R →+* R'}
{S' : Type u_1} [inst_6 : Monoid S'] [inst_7 : DistribMulAction S' M] [inst_8 : SMulCommCla... | null | false |
GroupExtension.Section.inv_mul_mem_range_inl | Mathlib.GroupTheory.GroupExtension.Basic | ∀ {N : Type u_1} {G : Type u_2} [inst : Group N] [inst_1 : Group G] {E : Type u_3} [inst_2 : Group E]
{S : GroupExtension N E G} (σ σ' : S.Section) (g : G), (σ g)⁻¹ * σ' g ∈ S.inl.range | null | true |
Matrix.blockDiagonal'_zero | Mathlib.Data.Matrix.Block | ∀ {o : Type u_4} {m' : o → Type u_7} {n' : o → Type u_8} {α : Type u_12} [inst : DecidableEq o] [inst_1 : Zero α],
Matrix.blockDiagonal' 0 = 0 | null | true |
selfAdjoint.submodule | Mathlib.Algebra.Star.Module | (R : Type u_1) →
(A : Type u_2) →
[inst : Semiring R] →
[inst_1 : StarMul R] →
[TrivialStar R] →
[inst_3 : AddCommGroup A] →
[inst_4 : Module R A] → [inst_5 : StarAddMonoid A] → [StarModule R A] → Submodule R A | The self-adjoint elements of a star module, as a submodule. | true |
LieEquiv.coe_toLieHom | Mathlib.Algebra.Lie.Basic | ∀ {R : Type u} {L₁ : Type v} {L₂ : Type w} [inst : CommRing R] [inst_1 : LieRing L₁] [inst_2 : LieRing L₂]
[inst_3 : LieAlgebra R L₁] [inst_4 : LieAlgebra R L₂] (e : L₁ ≃ₗ⁅R⁆ L₂), ⇑e.toLieHom = ⇑e | null | true |
CategoryTheory.MorphismProperty.LeftFraction₃.recOn | Mathlib.CategoryTheory.Localization.CalculusOfFractions.Fractions | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
{W : CategoryTheory.MorphismProperty C} →
{X Y : C} →
{motive : W.LeftFraction₃ X Y → Sort u} →
(t : W.LeftFraction₃ X Y) →
({Y' : C} →
(f f' f'' : X ⟶ Y') →
(s : Y ⟶ Y') → (hs : ... | null | false |
List.subset_replicate | Init.Data.List.Sublist | ∀ {α : Type u_1} {n : ℕ} {a : α} {l : List α}, n ≠ 0 → (l ⊆ List.replicate n a ↔ ∀ x ∈ l, x = a) | null | true |
Rep.coinvariantsTensorFreeLEquiv._proof_4 | Mathlib.RepresentationTheory.Coinvariants | ∀ {k G : Type u_1} [inst : CommRing k] [inst_1 : Group G] (A : Rep.{u_1, u_1, u_1} k G) (α : Type u_1)
[inst_2 : DecidableEq α], A.finsuppToCoinvariantsTensorFree α ∘ₗ A.coinvariantsTensorFreeToFinsupp α = LinearMap.id | null | false |
_private.Lean.Elab.DocString.0.Lean.Doc.ModuleDocstringState._sizeOf_inst | Lean.Elab.DocString | SizeOf Lean.Doc.ModuleDocstringState✝ | null | false |
CategoryTheory.Pseudofunctor.whiskerRight_mapId_hom_app_assoc | Mathlib.CategoryTheory.Bicategory.Functor.Pseudofunctor | ∀ {B : Type u_1} [inst : CategoryTheory.Bicategory B] (F : CategoryTheory.Pseudofunctor B CategoryTheory.Cat) {a b : B}
(f : a ⟶ b) (X : ↑(F.obj a)) {Z : ↑(F.obj b)}
(h : (F.map f).toFunctor.obj ((CategoryTheory.CategoryStruct.id (F.obj a)).toFunctor.obj X) ⟶ Z),
CategoryTheory.CategoryStruct.comp ((F.map f).toFu... | null | true |
_private.Lean.Meta.Tactic.Grind.AC.Eq.0.PSigma.casesOn._arg_pusher | Lean.Meta.Tactic.Grind.AC.Eq | ∀ {α : Sort u} {β : α → Sort v} {motive : PSigma β → Sort u_1} (α_1 : Sort u✝) (β_1 : α_1 → Sort v✝)
(f : (x : α_1) → β_1 x) (rel : PSigma β → α_1 → Prop) (t : PSigma β)
(mk : (fst : α) → (snd : β fst) → ((y : α_1) → rel ⟨fst, snd⟩ y → β_1 y) → motive ⟨fst, snd⟩),
(PSigma.casesOn (motive := fun t => ((y : α_1) → ... | null | false |
Lean.Meta.Simp.Result.mk._flat_ctor | Lean.Meta.Tactic.Simp.Types | Lean.Expr → Option Lean.Expr → Bool → Lean.Meta.Simp.Result | null | false |
Lean.Elab.Structural.RecArgInfo._sizeOf_1 | Lean.Elab.PreDefinition.Structural.RecArgInfo | Lean.Elab.Structural.RecArgInfo → ℕ | null | false |
AdjoinRoot.algHomOfDvd._proof_1 | Mathlib.RingTheory.AdjoinRoot | ∀ (R : Type u_2) {S : Type u_1} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S] (f g : Polynomial S),
g ∣ f → g ∣ Polynomial.map (↑(AlgHom.id R S)) f | null | false |
Finset.fiber_card_ne_zero_iff_mem_image | Mathlib.Data.Finset.Card | ∀ {α : Type u_1} {β : Type u_2} (s : Finset α) (f : α → β) [inst : DecidableEq β] (y : β),
{x ∈ s | f x = y}.card ≠ 0 ↔ y ∈ Finset.image f s | null | true |
Polynomial.isRoot_cyclotomic_prime_pow_mul_iff_of_charP | Mathlib.RingTheory.Polynomial.Cyclotomic.Expand | ∀ {m k p : ℕ} {R : Type u_1} [inst : CommRing R] [IsDomain R] [hp : Fact (Nat.Prime p)] [hchar : CharP R p] {μ : R}
[NeZero ↑m], (Polynomial.cyclotomic (p ^ k * m) R).IsRoot μ ↔ IsPrimitiveRoot μ m | If `R` is of characteristic `p` and `¬p ∣ m`, then `ζ` is a root of `cyclotomic (p ^ k * m) R`
if and only if it is a primitive `m`-th root of unity. | true |
Stream'.Seq.fold.match_1 | Mathlib.Data.Seq.Defs | {α : Type u_2} →
{β : Type u_1} →
(motive : β × Stream'.Seq α → Sort u_3) →
(x : β × Stream'.Seq α) → ((acc : β) → (x : Stream'.Seq α) → motive (acc, x)) → motive x | null | false |
Equiv.natSumNatEquivNat | Mathlib.Logic.Equiv.Nat | ℕ ⊕ ℕ ≃ ℕ | An equivalence between `ℕ ⊕ ℕ` and `ℕ`, by mapping `(Sum.inl x)` to `2 * x` and `(Sum.inr x)` to
`2 * x + 1`.
| true |
Lean.Elab.Tactic.GuardExpr.MatchKind.noConfusionType | Lean.Elab.Tactic.Guard | Sort u → Lean.Elab.Tactic.GuardExpr.MatchKind → Lean.Elab.Tactic.GuardExpr.MatchKind → Sort u | null | false |
Substring.Raw.noConfusion | Init.Prelude | {P : Sort u} → {t t' : Substring.Raw} → t = t' → Substring.Raw.noConfusionType P t t' | null | false |
Finset.symmDiff_nonempty | Mathlib.Data.Finset.SymmDiff | ∀ {α : Type u_1} [inst : DecidableEq α] {s t : Finset α}, (symmDiff s t).Nonempty ↔ s ≠ t | null | true |
_private.Mathlib.GroupTheory.Nilpotent.0.Group.nilpotencyClass_quotient_center._simp_1_1 | Mathlib.GroupTheory.Nilpotent | ∀ {G : Type u_1} [inst : Group G] [Group.IsNilpotent G], (Group.nilpotencyClass G = 0) = Subsingleton G | null | false |
Semiring.mk._flat_ctor | Mathlib.Algebra.Ring.Defs | {α : Type u} →
(add : α → α → α) →
(∀ (a b c : α), a + b + c = a + (b + c)) →
(zero : α) →
(∀ (a : α), 0 + a = a) →
(∀ (a : α), a + 0 = a) →
(nsmul : ℕ → α → α) →
autoParam (∀ (x : α), nsmul 0 x = 0) AddMonoid.nsmul_zero._autoParam →
autoParam (∀ (... | null | false |
_private.Mathlib.CategoryTheory.Limits.Shapes.Pullback.PullbackObjObj.0.CategoryTheory.Functor.PullbackObjObj.mapArrowRight._proof_1 | Mathlib.CategoryTheory.Limits.Shapes.Pullback.PullbackObjObj | ∀ {C₁ : Type u_5} {C₂ : Type u_2} {C₃ : Type u_6} [inst : CategoryTheory.Category.{u_3, u_5} C₁]
[inst_1 : CategoryTheory.Category.{u_1, u_2} C₂] [inst_2 : CategoryTheory.Category.{u_4, u_6} C₃]
{G : CategoryTheory.Functor C₁ᵒᵖ (CategoryTheory.Functor C₃ C₂)} {f₁ : CategoryTheory.Arrow C₁}
{f₃ f₃' : CategoryTheor... | null | false |
MonotoneOn.image_lowerBounds_subset_lowerBounds_image | Mathlib.Order.Bounds.Image | ∀ {α : Type u} {β : Type v} [inst : Preorder α] [inst_1 : Preorder β] {f : α → β} {s t : Set α},
MonotoneOn f t → s ⊆ t → f '' (lowerBounds s ∩ t) ⊆ lowerBounds (f '' s) | null | true |
CategoryTheory.Limits.pullbackConeEquivBinaryFan._proof_15 | Mathlib.CategoryTheory.Limits.Constructions.Over.Products | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {X Y Z : C} {f : Y ⟶ X} {g : Z ⟶ X}
(X_1 : CategoryTheory.Limits.BinaryFan (CategoryTheory.Over.mk f) (CategoryTheory.Over.mk g)),
(({
obj := fun c =>
CategoryTheory.Limits.PullbackCone.mk (CategoryTheory.Over.Hom.left ... | null | false |
Prod.addAction._proof_1 | Mathlib.Algebra.Group.Action.Prod | ∀ {M : Type u_3} {α : Type u_1} {β : Type u_2} [inst : AddMonoid M] [inst_1 : AddAction M α] [inst_2 : AddAction M β]
(x x_1 : M) (x_2 : α × β), (x + x_1) +ᵥ x_2 = x +ᵥ x_1 +ᵥ x_2 | null | false |
_private.Mathlib.NumberTheory.NumberField.CanonicalEmbedding.ConvexBody.0.NumberField.mixedEmbedding.convexBodyLT'_mem._simp_1_1 | Mathlib.NumberTheory.NumberField.CanonicalEmbedding.ConvexBody | ∀ {α : Type u} {β : Type v} {s : Set α} {t : Set β} {p : α × β}, (p ∈ s ×ˢ t) = (p.1 ∈ s ∧ p.2 ∈ t) | null | false |
Metric.infDist_le_hausdorffDist_of_mem | Mathlib.Topology.MetricSpace.HausdorffDistance | ∀ {α : Type u} [inst : PseudoMetricSpace α] {s t : Set α} {x : α},
x ∈ s → Metric.hausdorffEDist s t ≠ ⊤ → Metric.infDist x t ≤ Metric.hausdorffDist s t | The distance to a set is controlled by the Hausdorff distance. | true |
Mathlib.Tactic.modifyLocalContext | Mathlib.Util.Tactic | {m : Type → Type} → [Lean.MonadMCtx m] → Lean.MVarId → (Lean.LocalContext → Lean.LocalContext) → m Unit | `modifyLocalContext mvarId f` updates the local context of the metavariable
`mvarId` with `f`. The new local context must contain the same fvars as the old
local context and the types (and values, if any) of the fvars in the new local
context must be defeq to their equivalents in the old local context.
If `mvarId` doe... | true |
inv_mul' | Mathlib.Algebra.Group.Basic | ∀ {α : Type u_1} [inst : DivisionCommMonoid α] (a b : α), (a * b)⁻¹ = a⁻¹ / b | null | true |
Array.mapFinIdx_eq_mapIdx | Init.Data.Array.MapIdx | ∀ {α : Type u_1} {β : Type u_2} {xs : Array α} {f : (i : ℕ) → α → i < xs.size → β} {g : ℕ → α → β},
(∀ (i : ℕ) (h : i < xs.size), f i xs[i] h = g i xs[i]) → xs.mapFinIdx f = Array.mapIdx g xs | null | true |
Array.reverse_eq_append_iff._simp_1 | Init.Data.Array.Lemmas | ∀ {α : Type u_1} {xs ys zs : Array α}, (xs.reverse = ys ++ zs) = (xs = zs.reverse ++ ys.reverse) | null | false |
ContinuousOn.cfcₙ._auto_1 | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Continuity | Lean.Syntax | null | false |
_private.Std.Http.Internal.Char.0.Std.Http.Internal.Char.qdtext.match_1.eq_3 | Std.Http.Internal.Char | ∀ (motive : Char → Sort u_1) (h_1 : Unit → motive '\t') (h_2 : Unit → motive ' ') (h_3 : Unit → motive '!')
(h_4 : (x : Char) → motive x),
(match '!' with
| '\t' => h_1 ()
| ' ' => h_2 ()
| '!' => h_3 ()
| x => h_4 x) =
h_3 () | null | true |
Prod.instGeneralizedBooleanAlgebra._proof_4 | Mathlib.Order.BooleanAlgebra.Basic | ∀ {α : Type u_1} {β : Type u_2} [inst : GeneralizedBooleanAlgebra α] [inst_1 : GeneralizedBooleanAlgebra β]
(x x_1 : α × β), x ⊓ x_1 ⊔ x \ x_1 = x | null | false |
CategoryTheory.IsPullback.rec | Mathlib.CategoryTheory.Limits.Shapes.Pullback.IsPullback.Defs | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{P X Y Z : C} →
{fst : P ⟶ X} →
{snd : P ⟶ Y} →
{f : X ⟶ Z} →
{g : Y ⟶ Z} →
{motive : CategoryTheory.IsPullback fst snd f g → Sort u} →
((toCommSq : CategoryTheory.CommSq fst snd f g) →
... | null | false |
_private.Batteries.Util.ProofWanted.0.elabWanted.match_7 | Batteries.Util.ProofWanted | (motive : Option (Lean.TSyntax `term) → Array (Lean.TSyntax `Lean.Parser.Term.bracketedBinderF) → Sort u_1) →
(body'? : Option (Lean.TSyntax `term)) →
(extraBinders : Array (Lean.TSyntax `Lean.Parser.Term.bracketedBinderF)) →
((extraBinders : Array (Lean.TSyntax `Lean.Parser.Term.bracketedBinderF)) → motive... | null | false |
StrongDual.toLpₗ.eq_1 | Mathlib.Probability.Moments.CovarianceBilinDual | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] {mE : MeasurableSpace E} {𝕜 : Type u_2}
[inst_1 : NontriviallyNormedField 𝕜] [inst_2 : NormedSpace 𝕜 E] (μ : MeasureTheory.Measure E) (p : ENNReal),
StrongDual.toLpₗ μ p =
if h_Lp : MeasureTheory.MemLp id p μ then
{ toFun := fun L => MeasureTheory.MemLp.to... | null | true |
CategoryTheory.GradedObject.mapTrifunctor._proof_8 | Mathlib.CategoryTheory.GradedObject.Trifunctor | ∀ {C₁ : Type u_2} {C₂ : Type u_4} {C₃ : Type u_5} {C₄ : Type u_9} [inst : CategoryTheory.Category.{u_3, u_2} C₁]
[inst_1 : CategoryTheory.Category.{u_10, u_4} C₂] [inst_2 : CategoryTheory.Category.{u_11, u_5} C₃]
[inst_3 : CategoryTheory.Category.{u_8, u_9} C₄]
(F : CategoryTheory.Functor C₁ (CategoryTheory.Funct... | null | false |
Multiset.foldl_add | Mathlib.Data.Multiset.MapFold | ∀ {α : Type u_1} {β : Type v} (f : β → α → β) [inst : RightCommutative f] (b : β) (s t : Multiset α),
Multiset.foldl f b (s + t) = Multiset.foldl f (Multiset.foldl f b s) t | null | true |
CategoryTheory.Limits.FormalCoproduct.evalCompInclIsoId._proof_2 | Mathlib.CategoryTheory.Limits.FormalCoproducts.Basic | ∀ (C : Type u_4) [inst : CategoryTheory.Category.{u_3, u_4} C] (A : Type u_2)
[inst_1 : CategoryTheory.Category.{u_1, u_2} A] [inst_2 : CategoryTheory.Limits.HasCoproducts A]
(F : CategoryTheory.Functor C A) (x : C),
CategoryTheory.CategoryStruct.comp
(CategoryTheory.Limits.Sigma.desc fun x_1 =>
Cat... | null | false |
DivisionMonoid.ctorIdx | Mathlib.Algebra.Group.Defs | {G : Type u} → DivisionMonoid G → ℕ | null | false |
Lean.Parser.Command.importPath.parenthesizer | Lean.Parser.Command | Lean.PrettyPrinter.Parenthesizer | null | true |
FreeMagma.of.elim | Mathlib.Algebra.Free | {α : Type u} →
{motive : FreeMagma α → Sort u_1} → (t : FreeMagma α) → t.ctorIdx = 0 → ((a : α) → motive (FreeMagma.of a)) → motive t | null | false |
Std.ExtTreeSet.get_union_of_not_mem_left | Std.Data.ExtTreeSet.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t₁ t₂ : Std.ExtTreeSet α cmp} [inst : Std.TransCmp cmp] {k : α}
(not_mem : k ∉ t₁) {h' : k ∈ t₁ ∪ t₂}, (t₁ ∪ t₂).get k h' = t₂.get k ⋯ | null | true |
Int.toList_rco_eq_singleton_iff._simp_1 | Init.Data.Range.Polymorphic.IntLemmas | ∀ {k m n : ℤ}, ((m...n).toList = [k]) = (n = m + 1 ∧ m = k) | null | false |
Fin.val_ofNat | Init.Data.Fin.Lemmas | ∀ (n : ℕ) [inst : NeZero n] (a : ℕ), ↑(Fin.ofNat n a) = a % n | null | true |
_private.Mathlib.Analysis.Complex.JensenFormula.0.AnalyticOnNhd.sum_divisor_le._simp_1_8 | Mathlib.Analysis.Complex.JensenFormula | ∀ {G₀ : Type u_3} [inst : GroupWithZero G₀] {a : G₀} (n : ℤ), a ≠ 0 → (a ^ n = 0) = False | null | false |
Lean.Language.SnapshotTree.mk.sizeOf_spec | Lean.Language.Basic | ∀ (element : Lean.Language.Snapshot) (children : Array (Lean.Language.SnapshotTask Lean.Language.SnapshotTree)),
sizeOf { element := element, children := children } = 1 + sizeOf element + sizeOf children | null | true |
Nat.descFactorial_self._f | Mathlib.Data.Nat.Factorial.Basic | ∀ (x : ℕ) (f : Nat.below x), x.descFactorial x = x.factorial | null | false |
Continuous.clog | Mathlib.Analysis.SpecialFunctions.Complex.Log | ∀ {α : Type u_1} [inst : TopologicalSpace α] {f : α → ℂ},
Continuous f → (∀ (x : α), f x ∈ Complex.slitPlane) → Continuous fun t => Complex.log (f t) | null | true |
CategoryTheory.WithTerminal.homFrom | Mathlib.CategoryTheory.WithTerminal.Basic | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
(X : C) → CategoryTheory.WithTerminal.incl.obj X ⟶ CategoryTheory.WithTerminal.star | Constructs a morphism to `star` from `of X`. | true |
HomologicalComplex.mapBifunctor₁₂.d₃_eq_zero | Mathlib.Algebra.Homology.BifunctorAssociator | ∀ {C₁ : Type u_1} {C₂ : Type u_2} {C₁₂ : Type u_3} {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 |
Prop.instDistribLattice | Mathlib.Order.PropInstances | DistribLattice Prop | Propositions form a distributive lattice. | true |
_private.Mathlib.Topology.Sets.CompactOpenCovered.0.IsCompactOpenCovered.of_isCompact_of_forall_exists_isCompactOpenCovered._proof_1_3 | Mathlib.Topology.Sets.CompactOpenCovered | ∀ {S : Type u_1} [inst : TopologicalSpace S] {U : Set S} (Us : (x : S) → x ∈ U → Set S),
(∀ (x : S) (a : x ∈ U), Us x a ⊆ U) →
∀ (x : S) (U_1 : Set S), IsOpen U_1 → ∀ (x_1 : S) (x_2 : x_1 ∈ U), Us x_1 ⋯ = U_1 → x ∈ U_1 → x ∈ U | null | false |
MultilinearMap.addCommMonoid | Mathlib.LinearAlgebra.Multilinear.Basic | {R : Type uR} →
{ι : Type uι} →
{M₁ : ι → Type v₁} →
{M₂ : Type v₂} →
[inst : Semiring R] →
[inst_1 : (i : ι) → AddCommMonoid (M₁ i)] →
[inst_2 : AddCommMonoid M₂] →
[inst_3 : (i : ι) → Module R (M₁ i)] → [inst_4 : Module R M₂] → AddCommMonoid (MultilinearMap R M₁... | null | true |
_private.Mathlib.Algebra.Category.MonCat.FilteredColimits.0.MonCat.FilteredColimits.colimit_mul_mk_eq._simp_1_1 | Mathlib.Algebra.Category.MonCat.FilteredColimits | ∀ {C : Type u} {inst : CategoryTheory.Category.{v, u} C} {FC : outParam (C → C → Type u_1)} {CC : outParam (C → Type w)}
{inst_1 : outParam ((X Y : C) → FunLike (FC X Y) (CC X) (CC Y))} [self : CategoryTheory.ConcreteCategory C FC]
{X Y Z : C} (f : X ⟶ Y) (g : Y ⟶ Z) (x : CC X),
(CategoryTheory.ConcreteCategory.h... | null | false |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.head?_keys._simp_1_4 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {t t' : Std.DTreeMap.Internal.Impl α β}, t.Equiv t' = t.toListModel.Perm t'.toListModel | null | false |
IsBezout.span_pair_isPrincipal | Mathlib.RingTheory.PrincipalIdealDomain | ∀ {R : Type u} [inst : Ring R] [IsBezout R] (x y : R), Submodule.IsPrincipal (Ideal.span {x, y}) | null | true |
comap_prime | Mathlib.Algebra.Prime.Lemmas | ∀ {M : Type u_1} {N : Type u_2} [inst : CommMonoidWithZero M] [inst_1 : CommMonoidWithZero N] {F : Type u_3}
{G : Type u_4} [inst_2 : FunLike F M N] [MonoidWithZeroHomClass F M N] [inst_4 : FunLike G N M] [MulHomClass G N M]
(f : F) (g : G) {p : M}, (∀ (a : M), g (f a) = a) → Prime (f p) → Prime p | null | true |
PrincipalSeg.isSuccPrelimit_apply_iff | Mathlib.Order.SuccPred.InitialSeg | ∀ {α : Type u_1} {β : Type u_2} {a : α} [inst : PartialOrder α] [inst_1 : PartialOrder β] (f : α <i β),
Order.IsSuccPrelimit (f.toRelEmbedding a) ↔ Order.IsSuccPrelimit a | null | true |
_private.BatteriesRecycling.RBTree.Lemmas.0.RBTree.RBNode.Stream.foldl.match_1.splitter | BatteriesRecycling.RBTree.Lemmas | {σ : Sort u_3} →
{α : Type u_1} →
(motive : σ → RBTree.RBNode.Stream α → Sort u_2) →
(x : σ) →
(x_1 : RBTree.RBNode.Stream α) →
((b : σ) → motive b RBTree.RBNode.Stream.nil) →
((b : σ) →
(v : α) →
(r : RBTree.RBNode α) →
(ta... | null | true |
CategoryTheory.Limits.WalkingPair.equivBool._proof_1 | Mathlib.CategoryTheory.Limits.Shapes.BinaryProducts | ∀ (j : CategoryTheory.Limits.WalkingPair),
(fun b => Bool.recOn b CategoryTheory.Limits.WalkingPair.right CategoryTheory.Limits.WalkingPair.left)
((fun x =>
match x with
| CategoryTheory.Limits.WalkingPair.left => true
| CategoryTheory.Limits.WalkingPair.right => false)
j) ... | null | false |
ProfiniteAddGrp.ofHom_apply | Mathlib.Topology.Algebra.Category.ProfiniteGrp.Basic | ∀ {X Y : Type u} [inst : AddGroup X] [inst_1 : TopologicalSpace X] [inst_2 : IsTopologicalAddGroup X]
[inst_3 : CompactSpace X] [inst_4 : TotallyDisconnectedSpace X] [inst_5 : AddGroup Y] [inst_6 : TopologicalSpace Y]
[inst_7 : IsTopologicalAddGroup Y] [inst_8 : CompactSpace Y] [inst_9 : TotallyDisconnectedSpace Y]... | null | true |
minimalPrimes | Mathlib.RingTheory.Ideal.MinimalPrime.Basic | (R : Type u_1) → [inst : CommSemiring R] → Set (Ideal R) | `minimalPrimes R` is the set of minimal primes of `R`.
This is defined as `Ideal.minimalPrimes ⊥`. | true |
isUnit_unop | Mathlib.Algebra.Group.Units.Opposite | ∀ {M : Type u_2} [inst : Monoid M] {m : Mᵐᵒᵖ}, IsUnit (MulOpposite.unop m) ↔ IsUnit m | null | true |
Nondet.ofListM | Batteries.Control.Nondet.Basic | {σ : Type} → {m : Type → Type} → [Monad m] → [inst : Lean.MonadBacktrack σ m] → {α : Type} → List (m α) → Nondet m α | Lift a list of monadic values to a nondeterministic value.
We ensure that each monadic value is evaluated with the same backtrackable state.
| true |
_private.Mathlib.Analysis.SpecialFunctions.Trigonometric.DerivHyp.0.Real.differentiable_iteratedDeriv_sinh.match_1_1 | Mathlib.Analysis.SpecialFunctions.Trigonometric.DerivHyp | ∀ (motive : ℕ → Prop) (n : ℕ),
(∀ (a : Unit), motive 0) → (∀ (a : Unit), motive 1) → (∀ (n : ℕ), motive n.succ.succ) → motive n | null | false |
HomotopicalAlgebra.PrepathObject.trans_ι | Mathlib.AlgebraicTopology.ModelCategory.PathObject | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {A : C} (P P' : HomotopicalAlgebra.PrepathObject A)
[inst_1 : CategoryTheory.Limits.HasPullback P.p₁ P'.p₀],
(P.trans P').ι = CategoryTheory.Limits.pullback.lift P.ι P'.ι ⋯ | null | true |
HasFDerivWithinAt.of_restrictScalars | Mathlib.Analysis.Calculus.FDeriv.RestrictScalars | ∀ (𝕜 : Type u_1) [inst : NontriviallyNormedField 𝕜] {𝕜' : Type u_2} [inst_1 : NontriviallyNormedField 𝕜']
[inst_2 : NormedAlgebra 𝕜 𝕜'] {E : Type u_3} [inst_3 : NormedAddCommGroup E] [inst_4 : NormedSpace 𝕜 E]
[inst_5 : NormedSpace 𝕜' E] [inst_6 : IsScalarTower 𝕜 𝕜' E] {F : Type u_4} [inst_7 : NormedAddCo... | null | true |
_private.Mathlib.Combinatorics.SimpleGraph.Connectivity.Connected.0.SimpleGraph.Reachable.mem_subgraphVerts.aux | Mathlib.Combinatorics.SimpleGraph.Connectivity.Connected | ∀ {V : Type u} {G : SimpleGraph V} {v : V} {H : G.Subgraph},
(∀ v ∈ H.verts, ∀ (w : V), G.Adj v w → H.Adj v w) → ∀ {v' : V}, v' ∈ H.verts → ∀ (p : G.Walk v' v), v ∈ H.verts | null | true |
_private.Mathlib.NumberTheory.Padics.PadicVal.Basic.0.padicValRat.lt_sum_of_lt._simp_1_1 | Mathlib.NumberTheory.Padics.PadicVal.Basic | ∀ {α : Type u_1} [inst : DecidableEq α] {s : Finset α} {a b : α}, (a ∈ insert b s) = (a = b ∨ a ∈ s) | null | false |
CompleteLinearOrder.toDecidableLE | Mathlib.Order.CompleteLattice.Defs | {α : Type u_8} → [self : CompleteLinearOrder α] → DecidableLE α | In a linearly ordered type, we assume the order relations are all decidable. | true |
FiberBundleCore.mem_localTrivAt_source._simp_1 | Mathlib.Topology.FiberBundle.Basic | ∀ {ι : Type u_1} {B : Type u_2} {F : Type u_3} [inst : TopologicalSpace B] [inst_1 : TopologicalSpace F]
(Z : FiberBundleCore ι B F) (p : Z.TotalSpace) (b : B),
(p ∈ (Z.localTrivAt b).source) = (p.proj ∈ (Z.localTrivAt b).baseSet) | null | false |
_private.Mathlib.GroupTheory.Perm.Cycle.Type.0.Equiv.Perm.IsThreeCycle.nodup_iff_mem_support._proof_1_216 | Mathlib.GroupTheory.Perm.Cycle.Type | ∀ {α : Type u_1} [inst_1 : DecidableEq α] {g : Equiv.Perm α} {a : α} (w w_1 : α),
List.idxOfNth w [g (g a)] 1 + 1 ≤ (List.filter (fun x => decide (x = w_1)) []).length →
List.idxOfNth w [g (g a)] 1 < (List.findIdxs (fun x => decide (x = w_1)) []).length | null | false |
MulAction.IsBlock.univ | Mathlib.GroupTheory.GroupAction.Blocks | ∀ {G : Type u_1} [inst : Group G] {X : Type u_2} [inst_1 : MulAction G X], MulAction.IsBlock G Set.univ | The full set is a block. | true |
complEDS₂_two | Mathlib.NumberTheory.EllipticDivisibilitySequence | ∀ {R : Type u} [inst : CommRing R] (b c d : R), complEDS₂ b c d 2 = d | null | true |
Std.HashSet.getD_diff_of_not_mem_left | Std.Data.HashSet.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {m₁ m₂ : Std.HashSet α} [EquivBEq α] [LawfulHashable α] {k fallback : α},
k ∉ m₁ → (m₁ \ m₂).getD k fallback = fallback | null | true |
CompHausLike.finiteCoproduct.desc | Mathlib.Topology.Category.CompHausLike.Limits | {P : TopCat → Prop} →
{α : Type w} →
[inst : Finite α] →
(X : α → CompHausLike P) →
[inst_1 : CompHausLike.HasExplicitFiniteCoproduct X] →
{B : CompHausLike P} → ((a : α) → X a ⟶ B) → (CompHausLike.finiteCoproduct X ⟶ B) | To construct a morphism from the explicit finite coproduct, it suffices to
specify a morphism from each of its factors.
This is essentially the universal property of the coproduct.
| true |
Std.ExtDHashMap.get_filter | Std.Data.ExtDHashMap.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {β : α → Type v} {m : Std.ExtDHashMap α β} [inst : LawfulBEq α]
{f : (a : α) → β a → Bool} {k : α} {h' : k ∈ Std.ExtDHashMap.filter f m},
(Std.ExtDHashMap.filter f m).get k h' = m.get k ⋯ | null | true |
ContinuousMap.induction_on | Mathlib.Topology.ContinuousMap.StoneWeierstrass | ∀ {𝕜 : Type u_1} [inst : RCLike 𝕜] {s : Set 𝕜} {p : C(↑s, 𝕜) → Prop},
(∀ (r : 𝕜), p (ContinuousMap.const (↑s) r)) →
p (ContinuousMap.restrict s (ContinuousMap.id 𝕜)) →
p (star (ContinuousMap.restrict s (ContinuousMap.id 𝕜))) →
(∀ (f g : C(↑s, 𝕜)), p f → p g → p (f + g)) →
(∀ (f g :... | An induction principle for `C(s, 𝕜)`. | true |
MulEquiv.coprodCongr._proof_4 | Mathlib.GroupTheory.Coprod.Basic | ∀ {M : Type u_1} {N : Type u_2} [inst : MulOneClass M] [inst_1 : MulOneClass N], MonoidHomClass (N ≃* M) N M | null | false |
_private.Batteries.Data.List.Lemmas.0.List.getElem_getElem_idxsOf._proof_4 | Batteries.Data.List.Lemmas | ∀ {α : Type u_1} {i : ℕ} {xs : List α} {x : α} [inst : BEq α] (h : i < (List.idxsOf x xs).length),
(List.idxsOf x xs)[i] < xs.length | null | false |
_private.Mathlib.Combinatorics.SimpleGraph.Acyclic.0.SimpleGraph.IsTree.card_edgeFinset._simp_1_7 | Mathlib.Combinatorics.SimpleGraph.Acyclic | ∀ {α : Type u_4} {f : Sym2 α → Prop}, (∀ (x : Sym2 α), f x) = ∀ (x y : α), f s(x, y) | null | false |
NNReal.rpow_sub_natCast | Mathlib.Analysis.SpecialFunctions.Pow.NNReal | ∀ {x : NNReal}, x ≠ 0 → ∀ (y : ℝ) (n : ℕ), x ^ (y - ↑n) = x ^ y / x ^ n | null | true |
Quaternion.coe_ofComplex | Mathlib.Analysis.Quaternion | ⇑Quaternion.ofComplex = Quaternion.coeComplex | null | true |
List.Vector.continuous_eraseIdx | Mathlib.Topology.List | ∀ {α : Type u_1} [inst : TopologicalSpace α] {n : ℕ} {i : Fin (n + 1)}, Continuous (List.Vector.eraseIdx i) | null | true |
_private.Mathlib.CategoryTheory.ObjectProperty.FiniteProducts.0.CategoryTheory.ObjectProperty.prop_of_isLimit_fan.match_1_1 | Mathlib.CategoryTheory.ObjectProperty.FiniteProducts | ∀ {J : Type u_1} (motive : CategoryTheory.Discrete J → Prop) (h : CategoryTheory.Discrete J),
(∀ (j : J), motive { as := j }) → motive h | null | false |
PreAbstractSimplicialComplex.addSingletons._proof_1 | Mathlib.AlgebraicTopology.SimplicialComplex.Basic | ∀ (ι : Type u_1) (K : PreAbstractSimplicialComplex ι), IsRelLowerSet (K.faces ∪ {s | ∃ v, s = {v}}) Finset.Nonempty | null | false |
CategoryTheory.Limits.IsColimit.OfNatIso.homOfCocone.eq_1 | Mathlib.CategoryTheory.Limits.IsLimit | ∀ {J : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} J] {C : Type u₃} [inst_1 : CategoryTheory.Category.{v₃, u₃} C]
{F : CategoryTheory.Functor J C} {X : C} (h : F.cocones.CorepresentableBy X) (s : CategoryTheory.Limits.Cocone F),
CategoryTheory.Limits.IsColimit.OfNatIso.homOfCocone h s = h.homEquiv.symm s.ι | null | true |
Ordinal.enumOrdOrderIso | Mathlib.SetTheory.Ordinal.Enum | (s : Set Ordinal.{u_1}) → ¬BddAbove s → Ordinal.{u_1} ≃o ↑s | An order isomorphism between an unbounded set of ordinals and the ordinals. | true |
Lean.Parser.Command.checkAssertions.formatter | Lean.Parser.Command | Lean.PrettyPrinter.Formatter | null | true |
Std.Internal.List.minEntry?_of_perm | Std.Data.Internal.List.Associative | ∀ {α : Type u} {β : α → Type v} [inst : Ord α] [Std.TransOrd α] [inst_2 : BEq α] [Std.LawfulBEqOrd α]
{l l' : List ((a : α) × β a)},
Std.Internal.List.DistinctKeys l → l.Perm l' → Std.Internal.List.minEntry? l = Std.Internal.List.minEntry? l' | null | true |
Std.DTreeMap.get_erase | Std.Data.DTreeMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t : Std.DTreeMap α β cmp} [inst : Std.TransCmp cmp]
[inst_1 : Std.LawfulEqCmp cmp] {k a : α} {h' : a ∈ t.erase k}, (t.erase k).get a h' = t.get a ⋯ | null | true |
GradeMaxOrder.mk.noConfusion | Mathlib.Order.Grade | {𝕆 : Type u_5} →
{α : Type u_6} →
{inst : Preorder 𝕆} →
{inst_1 : Preorder α} →
{P : Sort u} →
{toGradeOrder : GradeOrder 𝕆 α} →
{isMax_grade : ∀ ⦃a : α⦄, IsMax a → IsMax (GradeOrder.grade a)} →
{toGradeOrder' : GradeOrder 𝕆 α} →
{isMax_grade' ... | null | false |
Lean.Parser.SyntaxStack.casesOn | Lean.Parser.Types | {motive : Lean.Parser.SyntaxStack → Sort u} →
(t : Lean.Parser.SyntaxStack) →
((raw : Array Lean.Syntax) → (drop : ℕ) → motive { raw := raw, drop := drop }) → motive t | null | false |
Equiv.Perm.sign_eq_prod_prod_Ioi | Mathlib.GroupTheory.Perm.Fin | ∀ {n : ℕ} (σ : Equiv.Perm (Fin n)), Equiv.Perm.sign σ = ∏ i, ∏ j ∈ Finset.Ioi i, if σ i < σ j then 1 else -1 | null | true |
Std.Http.Header.instReprHost | Std.Http.Data.Headers.Basic | Repr Std.Http.Header.Host | null | true |
MulSemiringAction.ctorIdx | Mathlib.Algebra.Ring.Action.Basic | {M : Type u} → {R : Type v} → {inst : Monoid M} → {inst_1 : Semiring R} → MulSemiringAction M R → ℕ | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.