name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
Polynomial.exists_multiset_roots._unary | Mathlib.Algebra.Polynomial.RingDivision | ∀ {R : Type u} [inst : CommRing R] [IsDomain R] [inst_2 : DecidableEq R] (_x : (p : Polynomial R) ×' p ≠ 0),
∃ s, ↑s.card ≤ _x.1.degree ∧ ∀ (a : R), Multiset.count a s = Polynomial.rootMultiplicity a _x.1 | null | false |
_private.Mathlib.Data.Nat.GCD.BigOperators.0.Nat.coprime_list_prod_left_iff._simp_1_1 | Mathlib.Data.Nat.GCD.BigOperators | ∀ {m n k : ℕ}, (m * n).Coprime k = (m.Coprime k ∧ n.Coprime k) | null | false |
CategoryTheory.Abelian.coimageIsoImage' | Mathlib.CategoryTheory.Abelian.Basic | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
[inst_1 : CategoryTheory.Abelian C] →
{X Y : C} → (f : X ⟶ Y) → CategoryTheory.Abelian.coimage f ≅ CategoryTheory.Limits.image f | There is a canonical isomorphism between the abelian coimage and the categorical image of a
morphism. | true |
_private.Mathlib.Combinatorics.SimpleGraph.Connectivity.Subgraph.0.SimpleGraph.Walk.IsPath.neighborSet_toSubgraph_internal._proof_1_12 | Mathlib.Combinatorics.SimpleGraph.Connectivity.Subgraph | ∀ {V : Type u_1} {G : SimpleGraph V} {v u : V} {p : G.Walk u v}, ∀ i' < p.length, i' + 1 ≤ p.length | null | false |
LinearMap.coe_prod | Mathlib.LinearAlgebra.Prod | ∀ {R : Type u} {M : Type v} {M₂ : Type w} {M₃ : Type y} [inst : Semiring R] [inst_1 : AddCommMonoid M]
[inst_2 : AddCommMonoid M₂] [inst_3 : AddCommMonoid M₃] [inst_4 : Module R M] [inst_5 : Module R M₂]
[inst_6 : Module R M₃] (f : M →ₗ[R] M₂) (g : M →ₗ[R] M₃), ⇑(f.prod g) = Function.prod ⇑f ⇑g | null | true |
CategoryTheory.Aut.instGroup._proof_7 | Mathlib.CategoryTheory.Endomorphism | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] (X : C) (x : CategoryTheory.Aut X), x ^ 0 = 1 | null | false |
AddMonoidHom.coe_toZModLinearMap | Mathlib.Algebra.Module.ZMod | ∀ (n : ℕ) {M : Type u_1} {M₁ : Type u_2} [inst : AddCommGroup M] [inst_1 : AddCommGroup M₁] [inst_2 : Module (ZMod n) M]
[inst_3 : Module (ZMod n) M₁] (f : M →+ M₁), ⇑(AddMonoidHom.toZModLinearMap n f) = ⇑f | null | true |
OrderMonoidHom.toMonoidHom | Mathlib.Algebra.Order.Hom.Monoid | {α : Type u_6} →
{β : Type u_7} →
[inst : Preorder α] →
[inst_1 : Preorder β] → [inst_2 : MulOneClass α] → [inst_3 : MulOneClass β] → (α →*o β) → α →* β | null | true |
_private.Mathlib.RingTheory.DedekindDomain.Factorization.0.Ideal.iInf_maxPowDividing_eq._simp_1_5 | Mathlib.RingTheory.DedekindDomain.Factorization | ∀ {R : Type u_1} {M : Type u_3} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] {ι : Sort u_4}
(p : ι → Submodule R M) {x : M}, (x ∈ ⨅ i, p i) = ∀ (i : ι), x ∈ p i | null | false |
RingTheory.Sequence.IsWeaklyRegular.of_flat | Mathlib.RingTheory.Regular.Flat | ∀ {R : Type u_1} {S : Type u_2} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S] [Module.Flat R S]
{rs : List R},
RingTheory.Sequence.IsWeaklyRegular R rs → RingTheory.Sequence.IsWeaklyRegular S (List.map (⇑(algebraMap R S)) rs) | null | true |
ftaylorSeries_zero | Mathlib.Analysis.Calculus.ContDiff.Basic | ∀ {𝕜 : 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], ftaylorSeries 𝕜 0 = 0 | null | true |
_private.Mathlib.RingTheory.Idempotents.0.CompleteOrthogonalIdempotents.bijective_pi._simp_1_1 | Mathlib.RingTheory.Idempotents | ∀ {α : Sort u} {β : α → Sort v} {f g : (x : α) → β x}, (f = g) = ∀ (x : α), f x = g x | null | false |
Lean.Elab.MacroStackElem.mk.sizeOf_spec | Lean.Elab.Util | ∀ (before after : Lean.Syntax), sizeOf { before := before, after := after } = 1 + sizeOf before + sizeOf after | null | true |
Int.land_bit | Mathlib.Data.Int.Bitwise | ∀ (a : Bool) (m : ℤ) (b : Bool) (n : ℤ), (Int.bit a m).land (Int.bit b n) = Int.bit (a && b) (m.land n) | null | true |
LinearMap.SeparatingLeft.toMatrix₂ | Mathlib.LinearAlgebra.Matrix.SesquilinearForm | ∀ {R : Type u_1} {M₁ : Type u_6} {M₂ : Type u_7} {n : Type u_11} {m : Type u_12} [inst : CommRing R]
[inst_1 : DecidableEq m] [inst_2 : Fintype m] [inst_3 : DecidableEq n] [inst_4 : Fintype n]
[inst_5 : AddCommMonoid M₁] [inst_6 : Module R M₁] [inst_7 : AddCommMonoid M₂] [inst_8 : Module R M₂]
(b₁ : Module.Basis ... | null | true |
List.rightInverse_sigmaCountToIdx_idxToSigmaCount | Batteries.Data.List.Count | ∀ {α : Type u_1} [inst : BEq α] [inst_1 : LawfulBEq α] {xs : List α},
Function.RightInverse xs.sigmaCountToIdx xs.idxToSigmaCount | null | true |
NormedAddGroupHom.normNoninc_of_isometry | Mathlib.Analysis.Normed.Group.Hom | ∀ {V : Type u_1} {W : Type u_2} [inst : SeminormedAddCommGroup V] [inst_1 : SeminormedAddCommGroup W]
{f : NormedAddGroupHom V W}, Isometry ⇑f → f.NormNoninc | null | true |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.minKey!_eq_minKeyD_default._simp_1_1 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {x : Ord α} {x_1 : BEq α} [Std.LawfulBEqOrd α] {a b : α}, (compare a b = Ordering.eq) = ((a == b) = true) | null | false |
CategoryTheory.StrongEpi.mk._flat_ctor | Mathlib.CategoryTheory.Limits.Shapes.StrongEpi | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {P Q : C} {f : P ⟶ Q},
CategoryTheory.Epi f →
(∀ ⦃X Y : C⦄ (z : X ⟶ Y) [CategoryTheory.Mono z], CategoryTheory.HasLiftingProperty f z) →
CategoryTheory.StrongEpi f | null | false |
_private.Init.Data.List.Impl.0.List.erasePTR.go._unsafe_rec | Init.Data.List.Impl | {α : Type u_1} → (α → Bool) → List α → List α → Array α → List α | null | false |
SubfieldClass.toDivisionRing._proof_4 | Mathlib.Algebra.Field.Subfield.Defs | ∀ {K : Type u_1} [inst : DivisionRing K] {S : Type u_2} [inst_1 : SetLike S K] [h : SubfieldClass S K] (s : S),
autoParam (∀ (n : ℕ) (a : ↥s), a ^ Int.negSucc n = (a ^ ↑n.succ)⁻¹) DivInvMonoid.zpow_neg'._autoParam | null | false |
List.nextOr_singleton | Mathlib.Data.List.Cycle | ∀ {α : Type u_1} [inst : DecidableEq α] (x y d : α), [y].nextOr x d = d | null | true |
SimpleGraph.EdgeLabeling.pairwise_disjoint_labelGraph | Mathlib.Combinatorics.SimpleGraph.Coloring.EdgeLabeling | ∀ {V : Type u_1} {G : SimpleGraph V} {K : Type u_3} {C : G.EdgeLabeling K},
Pairwise fun k l => Disjoint (C.labelGraph k) (C.labelGraph l) | null | true |
Mathlib.Tactic.Hint._aux_Mathlib_Tactic_Hint___elabRules_Mathlib_Tactic_Hint_registerHintStx_1 | Mathlib.Tactic.Hint | Lean.Elab.Command.CommandElab | Register a tactic for use with the `hint` tactic, e.g. `register_hint 1000 simp_all`.
The numeric argument specifies the priority: tactics with larger priorities run before
those with smaller priorities. The priority must be provided explicitly.
| false |
BitVec.toInt_ushiftRight_of_lt | Init.Data.BitVec.Lemmas | ∀ {w : ℕ} {x : BitVec w} {n : ℕ}, 0 < n → (x >>> n).toInt = ↑(x.toNat >>> n) | Unsigned shift right by at least one bit makes the interpretations of the bitvector as an `Int` or `Nat` agree,
because it makes the value of the bitvector less than or equal to `2^(w-1)`.
| true |
_private.Lean.Util.CollectAxioms.0.Lean.CollectAxioms.State.recOn | Lean.Util.CollectAxioms | {motive : Lean.CollectAxioms.State✝ → Sort u} →
(t : Lean.CollectAxioms.State✝) →
((seen : Lean.NameMap (Array Lean.Name)) → (axioms : Lean.NameSet) → motive { seen := seen, axioms := axioms }) →
motive t | null | false |
Mathlib.Tactic.BicategoryLike.MonadMor₂.homM | Mathlib.Tactic.CategoryTheory.Coherence.Datatypes | {m : Type → Type} →
[self : Mathlib.Tactic.BicategoryLike.MonadMor₂ m] →
Mathlib.Tactic.BicategoryLike.Mor₂Iso → m Mathlib.Tactic.BicategoryLike.Mor₂ | The expression for `Iso.hom η`. | true |
Std.Iterators.PostconditionT.operation_lift | Init.Data.Iterators.PostconditionMonad | ∀ {m : Type w → Type w'} [inst : Functor m] {α : Type w} {x : m α},
(Std.Iterators.PostconditionT.lift x).operation = (fun x_1 => ⟨x_1, ⋯⟩) <$> x | null | true |
Algebra.TensorProduct.algEquivOfLinearEquivTripleTensorProduct._proof_1 | Mathlib.RingTheory.TensorProduct.Maps | ∀ {R : Type u_5} {A : Type u_1} {B : Type u_2} {C : Type u_3} {D : Type u_4} [inst : CommSemiring R]
[inst_1 : Semiring A] [inst_2 : Algebra R A] [inst_3 : Semiring B] [inst_4 : Algebra R B] [inst_5 : Semiring C]
[inst_6 : Semiring D] [inst_7 : Algebra R D] [inst_8 : Algebra R C]
(f : TensorProduct R (TensorProdu... | null | false |
SSet.isZero_homology_of_hasDimensionLT._auto_1 | Mathlib.AlgebraicTopology.SimplicialSet.Homology.Nondegenerate | Lean.Syntax | null | false |
_private.Mathlib.RingTheory.SurjectiveOnStalks.0.RingHom.surjective_localRingHom_iff._simp_1_4 | Mathlib.RingTheory.SurjectiveOnStalks | ∀ {R : Type u_1} [inst : CommSemiring R] {M : Submonoid R} {S : Type u_2} [inst_1 : CommSemiring S]
[inst_2 : Algebra R S] [inst_3 : IsLocalization M S] {x₁ x₂ : R} {y₁ y₂ : ↥M},
(IsLocalization.mk' S x₁ y₁ = IsLocalization.mk' S x₂ y₂) =
((algebraMap R S) (↑y₂ * x₁) = (algebraMap R S) (↑y₁ * x₂)) | null | false |
AffineIsometry.id._proof_1 | Mathlib.Analysis.Normed.Affine.Isometry | ∀ {𝕜 : Type u_2} {V : Type u_1} {P : Type u_3} [inst : NormedField 𝕜] [inst_1 : SeminormedAddCommGroup V]
[inst_2 : NormedSpace 𝕜 V] [inst_3 : PseudoMetricSpace P] [inst_4 : NormedAddTorsor V P] (x : V),
‖(AffineMap.id 𝕜 P).linear x‖ = ‖(AffineMap.id 𝕜 P).linear x‖ | null | false |
ContinuousMap.Homotopy.prodMap | Mathlib.Topology.Homotopy.Basic | {X : Type u} →
{Y : Type v} →
{Z : Type w} →
{Z' : Type x} →
[inst : TopologicalSpace X] →
[inst_1 : TopologicalSpace Y] →
[inst_2 : TopologicalSpace Z] →
[inst_3 : TopologicalSpace Z'] →
{f₀ f₁ : C(X, Y)} →
{g₀ g₁ : C(Z, Z')} → f... | Let `F` be a homotopy between `f₀ : C(X, Y)` and `f₁ : C(X, Y)`. Let `G` be a homotopy between
`g₀ : C(Z, Z')` and `g₁ : C(Z, Z')`. Then `F.prodMap G` is the homotopy between `f₀.prodMap g₀` and
`f₁.prodMap g₁` that sends `(t, x, z)` to `(F (t, x), G (t, z))`. | true |
Mathlib.Tactic.Echelon.BareissExt.mk.sizeOf_spec | Mathlib.Tactic.Echelon.Core | ∀
(model? :
{u : Lean.Level} →
(α : Q(Type u)) →
Lean.MetaM (Option ((c : Mathlib.Tactic.Echelon.Carrier) × Mathlib.Tactic.Echelon.Model α c.type))),
sizeOf { model? := model? } = 1 | null | true |
MonoidHom.noncommPiCoprodEquiv._proof_6 | Mathlib.GroupTheory.NoncommPiCoprod | ∀ {M : Type u_3} [inst : Monoid M] {ι : Type u_1} [inst_1 : Fintype ι] {N : ι → Type u_2}
[inst_2 : (i : ι) → Monoid (N i)] [inst_3 : DecidableEq ι] (f : ((i : ι) → N i) →* M),
MonoidHom.noncommPiCoprod ↑⟨fun i => f.comp (MonoidHom.mulSingle N i), ⋯⟩ ⋯ = f | null | false |
ContinuousLinearEquiv.equivOfRightInverse | Mathlib.Topology.Algebra.Module.Equiv.Basic | {R : Type u_1} →
[inst : Ring R] →
{M : Type u_3} →
[inst_1 : TopologicalSpace M] →
[inst_2 : AddCommGroup M] →
[inst_3 : Module R M] →
{M₂ : Type u_4} →
[inst_4 : TopologicalSpace M₂] →
[inst_5 : AddCommGroup M₂] →
[inst_6 : Modu... | A pair of continuous linear maps such that `f₁ ∘ f₂ = id` generates a continuous
linear equivalence `e` between `M` and `M₂ × f₁.ker` such that `(e x).2 = x` for `x ∈ f₁.ker`,
`(e x).1 = f₁ x`, and `(e (f₂ y)).2 = 0`. The map is given by `e x = (f₁ x, x - f₂ (f₁ x))`. | true |
_private.Mathlib.NumberTheory.NumberField.CanonicalEmbedding.ConvexBody.0.NumberField.mixedEmbedding.convexBodyLT_neg_mem._simp_1_5 | Mathlib.NumberTheory.NumberField.CanonicalEmbedding.ConvexBody | ∀ (p : True → Prop), (∀ (x : True), p x) = p True.intro | null | false |
AlternatingMap.coe_injective | Mathlib.LinearAlgebra.Alternating.Basic | ∀ {R : Type u_1} [inst : Semiring R] {M : Type u_2} [inst_1 : AddCommMonoid M] [inst_2 : Module R M] {N : Type u_3}
[inst_3 : AddCommMonoid N] [inst_4 : Module R N] {ι : Type u_7}, Function.Injective DFunLike.coe | null | true |
SimpleGraph.cycleGraph_zero_eq_bot | Mathlib.Combinatorics.SimpleGraph.CycleGraph | SimpleGraph.cycleGraph 0 = ⊥ | null | true |
Algebra.TensorProduct.liftEquivRight._proof_4 | Mathlib.RingTheory.TensorProduct.Maps | ∀ (R : Type u_1) (S : Type u_2) [inst : CommSemiring R] [inst_1 : CommSemiring S] [inst_2 : Algebra R S],
IsScalarTower R S S | null | false |
Function.Injective.divisionMonoid | Mathlib.Algebra.Group.InjSurj | {M₁ : Type u_1} →
{M₂ : Type u_2} →
[inst : Mul M₁] →
[inst_1 : One M₁] →
[inst_2 : Pow M₁ ℕ] →
[inst_3 : Inv M₁] →
[inst_4 : Div M₁] →
[inst_5 : Pow M₁ ℤ] →
[inst_6 : DivisionMonoid M₂] →
(f : M₁ → M₂) →
Funct... | A type endowed with `1`, `*`, `⁻¹`, and `/` is a `DivisionMonoid` if it admits an injective map
that preserves `1`, `*`, `⁻¹`, and `/` to a `DivisionMonoid`. See note [reducible non-instances] | true |
_private.Std.Data.Iterators.Lemmas.Producers.Monadic.Empty.0.Std.IterM.toArray_eq_match_step.match_1.splitter | Std.Data.Iterators.Lemmas.Producers.Monadic.Empty | {α β : Type u_1} →
{m : Type u_1 → Type u_2} →
(motive : Std.IterStep (Std.IterM m β) β → Sort u_3) →
(x : Std.IterStep (Std.IterM m β) β) →
((it' : Std.IterM m β) → (out : β) → motive (Std.IterStep.yield it' out)) →
((it' : Std.IterM m β) → motive (Std.IterStep.skip it')) → (Unit → motive... | null | true |
Multiset.disjoint_map_map | Mathlib.Data.Multiset.UnionInter | ∀ {α : Type u_1} {β : Type v} {γ : Type u_2} {f : α → γ} {g : β → γ} {s : Multiset α} {t : Multiset β},
Disjoint (Multiset.map f s) (Multiset.map g t) ↔ ∀ a ∈ s, ∀ b ∈ t, f a ≠ g b | null | true |
_private.Mathlib.LinearAlgebra.Lagrange.0.Lagrange.coeff_eq_sum._simp_1_1 | Mathlib.LinearAlgebra.Lagrange | ∀ {α : Type u_2} [inst : Zero α] [inst_1 : OfNat α 2] [NeZero 2], (2 = 0) = False | null | false |
List.Vector.ofFn.match_1 | Mathlib.Data.Vector.Defs | {α : Type u_2} →
(motive : (x : ℕ) → (Fin x → α) → Sort u_1) →
(x : ℕ) →
(x_1 : Fin x → α) →
((x : Fin 0 → α) → motive 0 x) → ((n : ℕ) → (f : Fin (n + 1) → α) → motive n.succ f) → motive x x_1 | null | false |
Std.Http.Method.trace | Std.Http.Data.Method | Std.Http.Method | Perform a message loop-back test.
Source: https://httpwg.org/specs/rfc9110.html#section-9.3.8
| true |
_private.Lean.Compiler.LCNF.InferBorrow.0.Lean.Compiler.LCNF.State.ctorIdx | Lean.Compiler.LCNF.InferBorrow | Lean.Compiler.LCNF.State✝ → ℕ | null | false |
Lean.Meta.Match.Example.arrayLit.injEq | Lean.Meta.Match.Basic | ∀ (a a_1 : List Lean.Meta.Match.Example),
(Lean.Meta.Match.Example.arrayLit a = Lean.Meta.Match.Example.arrayLit a_1) = (a = a_1) | null | true |
_private.Lean.Elab.Tactic.Grind.Main.0.Lean.Elab.Tactic.grind.match_6 | Lean.Elab.Tactic.Grind.Main | (motive : Option (Lean.TSyntax `Lean.Parser.Tactic.Grind.grindSeq) → Sort u_1) →
(seq? : Option (Lean.TSyntax `Lean.Parser.Tactic.Grind.grindSeq)) →
((seq : Lean.TSyntax `Lean.Parser.Tactic.Grind.grindSeq) → motive (some seq)) →
((x : Option (Lean.TSyntax `Lean.Parser.Tactic.Grind.grindSeq)) → motive x) → m... | null | false |
Std.DTreeMap.Internal.Impl.Const.get!.eq_1 | Std.Data.DTreeMap.Internal.Model | ∀ {α : Type u} {δ : Type w} [inst : Ord α] [inst_1 : Inhabited δ] (k : α),
Std.DTreeMap.Internal.Impl.Const.get! Std.DTreeMap.Internal.Impl.leaf k =
panicWithPosWithDecl "Std.Data.DTreeMap.Internal.Queries" "Std.DTreeMap.Internal.Impl.Const.get!" 227 13
"Key is not present in map" | null | true |
SchwartzMap.mkLM._proof_4 | Mathlib.Analysis.Distribution.SchwartzSpace.Basic | ∀ {𝕜 : Type u_5} {D : Type u_1} {E : Type u_2} {F : Type u_3} {G : Type u_4} [inst : NormedAddCommGroup E]
[inst_1 : NormedSpace ℝ E] [inst_2 : NormedAddCommGroup F] [inst_3 : NormedSpace ℝ F] [inst_4 : NormedField 𝕜]
[inst_5 : NormedAddCommGroup D] [inst_6 : NormedSpace ℝ D] [inst_7 : NormedSpace 𝕜 E] [inst_8 :... | null | false |
AlgEquiv.toLinearEquiv_symm | Mathlib.Algebra.Algebra.Equiv | ∀ {R : Type uR} {A₁ : Type uA₁} {A₂ : Type uA₂} [inst : CommSemiring R] [inst_1 : Semiring A₁] [inst_2 : Semiring A₂]
[inst_3 : Algebra R A₁] [inst_4 : Algebra R A₂] (e : A₁ ≃ₐ[R] A₂), ↑e.symm = (↑e).symm | null | true |
_private.Mathlib.Combinatorics.Matroid.Rank.Finite.0.Matroid.isRkFinite_inter_ground_iff.match_1_1 | Mathlib.Combinatorics.Matroid.Rank.Finite | ∀ {α : Type u_1} {M : Matroid α} {X : Set α} (motive : (∃ I, M.IsBasis' I X) → Prop) (x : ∃ I, M.IsBasis' I X),
(∀ (_I : Set α) (hI : M.IsBasis' _I X), motive ⋯) → motive x | null | false |
Pi.instPosSMulReflectLE | Mathlib.Algebra.Order.Module.Defs | ∀ {α : Type u_1} {ι : Type u_3} {β : ι → Type u_4} [inst : Zero α] [inst_1 : Preorder α]
[inst_2 : (i : ι) → Preorder (β i)] [inst_3 : (i : ι) → SMul α (β i)] [∀ (i : ι), PosSMulReflectLE α (β i)],
PosSMulReflectLE α ((i : ι) → β i) | null | true |
ContinuousMultilinearMap.instInhabited | Mathlib.Topology.Algebra.Module.Multilinear.Basic | {R : Type u} →
{ι : Type v} →
{M₁ : ι → Type w₁} →
{M₂ : Type w₂} →
[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₂] →
[i... | null | true |
CategoryTheory.ComposableArrows.sc'._proof_7 | Mathlib.Algebra.Homology.ExactSequence | ∀ {n : ℕ} (i j k : ℕ), i + 1 = j → j + 1 = k → k ≤ n → i < n + 1 | null | false |
CategoryTheory.StructuredArrow.ofCommaSndEquivalenceInverse_map_right_right | Mathlib.CategoryTheory.Comma.Over.Basic | ∀ {T : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} T] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
{C : Type u₃} [inst_2 : CategoryTheory.Category.{v₃, u₃} C] (F : CategoryTheory.Functor C T)
(G : CategoryTheory.Functor D T) (c : C) {X Y : CategoryTheory.Comma ((CategoryTheory.Under.forget c).c... | null | true |
Aesop.MVarCluster.setState | Aesop.Tree.Data | Aesop.NodeState → Aesop.MVarCluster → Aesop.MVarCluster | null | true |
sup_congr_left | Mathlib.Order.Lattice | ∀ {α : Type u} [inst : SemilatticeSup α] {a b c : α}, b ≤ a ⊔ c → c ≤ a ⊔ b → a ⊔ b = a ⊔ c | null | true |
ONote.NFBelow.rec | Mathlib.SetTheory.Ordinal.Notation | ∀ {motive : (a : ONote) → (a_1 : Ordinal.{0}) → a.NFBelow a_1 → Prop},
(∀ {b : Ordinal.{0}}, motive 0 b ⋯) →
(∀ {e : ONote} {n : ℕ+} {a : ONote} {eb b : Ordinal.{0}} (a_1 : e.NFBelow eb) (a_2 : a.NFBelow e.repr)
(a_3 : e.repr < b), motive e eb a_1 → motive a e.repr a_2 → motive (e.oadd n a) b ⋯) →
∀... | null | false |
ImplicitFunctionData.leftDeriv_fderiv_implicitFunction | Mathlib.Analysis.Calculus.Implicit | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] [inst_3 : CompleteSpace E] {F : Type u_3} [inst_4 : NormedAddCommGroup F]
[inst_5 : NormedSpace 𝕜 F] [inst_6 : CompleteSpace F] {G : Type u_4} [inst_7 : NormedAddCommGroup G]
[inst_8 :... | null | true |
_private.Lean.Compiler.ExternAttr.0.Lean.expandExternPatternAux._unary._proof_1 | Lean.Compiler.ExternAttr | ∀ (pattern : String),
WellFounded (invImage (fun x => PSigma.casesOn x fun it r => it) String.Pos.instWellFoundedRelation).1 | null | false |
Std.TreeSet.Raw.min?_toList | Std.Data.TreeSet.Raw.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t : Std.TreeSet.Raw α cmp} [Std.TransCmp cmp] [inst : Min α] [inst_1 : LE α]
[Std.LawfulOrderCmp cmp] [Std.LawfulOrderMin α] [Std.LawfulOrderLeftLeaningMin α] [Std.LawfulEqCmp cmp],
t.WF → t.toList.min? = t.min? | null | true |
Std.DTreeMap.Raw.get!_union_of_not_mem_left | Std.Data.DTreeMap.Raw.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t₁ t₂ : Std.DTreeMap.Raw α β cmp} [Std.TransCmp cmp]
[inst : Std.LawfulEqCmp cmp],
t₁.WF → t₂.WF → ∀ {k : α} [inst_1 : Inhabited (β k)], k ∉ t₁ → (t₁ ∪ t₂).get! k = t₂.get! k | null | true |
Std.DTreeMap.Raw.get_alter_self | Std.Data.DTreeMap.Raw.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t : Std.DTreeMap.Raw α β cmp} [inst : Std.TransCmp cmp]
[inst_1 : Std.LawfulEqCmp cmp] (h : t.WF) {k : α} {f : Option (β k) → Option (β k)} {hc : k ∈ t.alter k f},
(t.alter k f).get k hc = (f (t.get? k)).get ⋯ | null | true |
CategoryTheory.Functor.PreservesRightKanExtension.mk_of_preserves_isRightKanExtension | Mathlib.CategoryTheory.Functor.KanExtension.Preserves | ∀ {A : Type u_1} {B : Type u_2} {C : Type u_3} {D : Type u_4} [inst : CategoryTheory.Category.{v_1, u_1} A]
[inst_1 : CategoryTheory.Category.{v_2, u_2} B] [inst_2 : CategoryTheory.Category.{v_3, u_3} C]
[inst_3 : CategoryTheory.Category.{v_4, u_4} D] (G : CategoryTheory.Functor B D) (F : CategoryTheory.Functor A B... | Show that `G` preserves right Kan extensions if it maps some right Kan extension to a right
Kan extension. | true |
Cardinal.preAleph_symm_ofNat | Mathlib.SetTheory.Cardinal.Aleph | ∀ (n : ℕ) [inst : n.AtLeastTwo], Cardinal.preAleph.symm (OfNat.ofNat n) = OfNat.ofNat n | null | true |
_private.Mathlib.Analysis.SpecialFunctions.Log.NegMulLog.0.Real.continuous_mul_log._simp_1_2 | Mathlib.Analysis.SpecialFunctions.Log.NegMulLog | ∀ {α : Type u_1} {β : Type u_2} {f : α → β} {x₁ x₂ : Filter α} {y : Filter β},
Filter.Tendsto f (x₁ ⊔ x₂) y = (Filter.Tendsto f x₁ y ∧ Filter.Tendsto f x₂ y) | null | false |
_private.Init.Data.BitVec.Bitblast.0.BitVec.getElem_sdiv.match_1.eq_4 | Init.Data.BitVec.Bitblast | ∀ (motive : Bool → Bool → Sort u_1) (h_1 : Unit → motive false false) (h_2 : Unit → motive false true)
(h_3 : Unit → motive true false) (h_4 : Unit → motive true true),
(match true, true with
| false, false => h_1 ()
| false, true => h_2 ()
| true, false => h_3 ()
| true, true => h_4 ()) =
h_4 (... | null | true |
Int.noConfusionType | Init.Data.Int.Basic | Sort u → ℤ → ℤ → Sort u | null | false |
_private.Std.Data.Internal.List.Associative.0.Std.Internal.List.containsKey_flatMap_eq_false._simp_1_1 | Std.Data.Internal.List.Associative | ∀ {x y : Bool}, ((x || y) = false) = (x = false ∧ y = false) | null | false |
CategoryTheory.Functor.IsDense.mk | Mathlib.CategoryTheory.Functor.KanExtension.Dense | ∀ {C : Type u₁} {D : Type u₂} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
{F : CategoryTheory.Functor C D}, (∀ (Y : D), F.isDenseAt Y) → F.IsDense | null | true |
Finset.disjiUnion_cons | Mathlib.Data.Finset.Union | ∀ {α : Type u_1} {β : Type u_2} (a : α) (s : Finset α) (ha : a ∉ s) (f : α → Finset β)
(H : (↑(Finset.cons a s ha)).PairwiseDisjoint f),
(Finset.cons a s ha).disjiUnion f H = (f a).disjUnion (s.disjiUnion f ⋯) ⋯ | null | true |
HahnSeries.one_minus_single_neg_mul | Mathlib.RingTheory.HahnSeries.Summable | ∀ {Γ : Type u_1} {R : Type u_3} [inst : AddCommMonoid Γ] [inst_1 : LinearOrder Γ] [inst_2 : IsOrderedCancelAddMonoid Γ]
[inst_3 : CommRing R] {x y : HahnSeries Γ R} {r : R},
r * x.leadingCoeff = 1 →
x = y + (HahnSeries.single x.order) x.leadingCoeff →
∀ (oinv : Γ), oinv + x.order = 0 → 1 - (HahnSeries.sin... | **Alias** of `HahnSeries.one_sub_single_neg_mul`. | true |
Lean.Meta.Grind.mkEqCongrProof | Lean.Meta.Tactic.Grind.Proof | Lean.Expr → Lean.Expr → Lean.Meta.Grind.GoalM Lean.Expr | null | true |
Polynomial.natDegree_eq_of_natDegree_add_eq_zero | Mathlib.Algebra.Polynomial.Degree.Operations | ∀ {R : Type u} [inst : Semiring R] (p q : Polynomial R), (p + q).natDegree = 0 → p.natDegree = q.natDegree | null | true |
Lean.Meta.Grind.AttrKind.homo.sizeOf_spec | Lean.Meta.Tactic.Grind.Attr | sizeOf Lean.Meta.Grind.AttrKind.homo = 1 | null | true |
sup_sdiff_left_self | Mathlib.Order.Heyting.Basic | ∀ {α : Type u_2} [inst : GeneralizedCoheytingAlgebra α] {a b : α}, (a ⊔ b) \ a = b \ a | null | true |
Finmap.union_assoc | Mathlib.Data.Finmap | ∀ {α : Type u} {β : α → Type v} [inst : DecidableEq α] {s₁ s₂ s₃ : Finmap β}, s₁ ∪ s₂ ∪ s₃ = s₁ ∪ (s₂ ∪ s₃) | null | true |
_private.Init.Data.UInt.Lemmas.0.UInt64.toUSize_le._simp_1_2 | Init.Data.UInt.Lemmas | ∀ {a b : UInt64}, (a ≤ b) = (a.toNat ≤ b.toNat) | null | false |
Lean.Parser.Term.paren.formatter | Lean.Parser.Term | Lean.PrettyPrinter.Formatter | null | true |
_private.Mathlib.RingTheory.Bialgebra.Equiv.0.BialgEquiv.toEquiv_injective.match_1_3 | Mathlib.RingTheory.Bialgebra.Equiv | ∀ {R : Type u_1} {A : Type u_2} {B : Type u_3} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Semiring B]
[inst_3 : Algebra R A] [inst_4 : Algebra R B] [inst_5 : CoalgebraStruct R A] [inst_6 : CoalgebraStruct R B]
(x : A ≃ₐc[R] B) (motive : (x_1 : A ≃ₐc[R] B) → x_1.toEquiv = x.toEquiv → Prop) (x_1 : A ≃ₐc[... | null | false |
SimpleGraph.deleteIncidenceSet.eq_1 | Mathlib.Combinatorics.SimpleGraph.DeleteEdges | ∀ {V : Type u_1} (G : SimpleGraph V) (x : V), G.deleteIncidenceSet x = G.deleteEdges (G.incidenceSet x) | null | true |
Prod.Lex.instDecidableRelOfDecidableEq._proof_3 | Init.WF | ∀ {α : Type u_1} {β : Type u_2} {r : α → α → Prop} {s : β → β → Prop} (a : α) (b : β) (a' : α) (b' : β),
¬r a a' → ¬a = a' → Prod.Lex r s (a, b) (a', b') → False | null | false |
Prod.instInv | Mathlib.Algebra.Notation.Prod | {G : Type u_7} → {H : Type u_8} → [Inv G] → [Inv H] → Inv (G × H) | null | true |
CategoryTheory.Oplax.OplaxTrans.StrongCore.casesOn | Mathlib.CategoryTheory.Bicategory.NaturalTransformation.Oplax | {B : Type u₁} →
[inst : CategoryTheory.Bicategory B] →
{C : Type u₂} →
[inst_1 : CategoryTheory.Bicategory C] →
{F G : CategoryTheory.OplaxFunctor B C} →
{η : F ⟶ G} →
{motive : CategoryTheory.Oplax.OplaxTrans.StrongCore η → Sort u} →
(t : CategoryTheory.Oplax.Opl... | null | false |
_private.Mathlib.CategoryTheory.Adjunction.Lifting.Right.0.CategoryTheory.LiftRightAdjoint.instIsCoreflexivePairMapAppUnitOtherMap._simp_1 | Mathlib.CategoryTheory.Adjunction.Lifting.Right | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
(self : CategoryTheory.Functor C D) {X Y Z : C} (f : X ⟶ Y) (g : Y ⟶ Z),
CategoryTheory.CategoryStruct.comp (self.map f) (self.map g) = self.map (CategoryTheory.CategoryStruct.comp f g) | null | false |
_private.Mathlib.NumberTheory.FLT.Basic.0.isCoprime_of_gcd_eq_one_of_FLT._simp_1_2 | Mathlib.NumberTheory.FLT.Basic | ∀ {M₀ : Type u_1} [inst : MonoidWithZero M₀] {a : M₀} {n : ℕ} [IsReduced M₀], n ≠ 0 → (a ^ n = 0) = (a = 0) | null | false |
instIsTopologicalSemiringMatrix | Mathlib.Topology.Instances.Matrix | ∀ {n : Type u_5} {R : Type u_8} [inst : TopologicalSpace R] [inst_1 : Fintype n] [inst_2 : NonUnitalNonAssocSemiring R]
[IsTopologicalSemiring R], IsTopologicalSemiring (Matrix n n R) | null | true |
_private.Batteries.Data.Fin.Coding.0.Fin.decodeSigma.match_3.splitter | Batteries.Data.Fin.Coding | (motive : (n : ℕ) → (f : Fin n → ℕ) → Fin (Fin.sum f) → Sort u_1) →
(n : ℕ) →
(f : Fin n → ℕ) →
(x : Fin (Fin.sum f)) →
((x : Fin 0 → ℕ) → (val : ℕ) → (h : val < Fin.sum x) → motive 0 x ⟨val, h⟩) →
((n : ℕ) → (f : Fin (n + 1) → ℕ) → (x : ℕ) → (hx : x < Fin.sum f) → motive n.succ f ⟨x, hx⟩)... | null | true |
Finset.mem_toLeft | Mathlib.Data.Finset.Sum | ∀ {α : Type u_1} {β : Type u_2} {u : Finset (α ⊕ β)} {a : α}, a ∈ u.toLeft ↔ Sum.inl a ∈ u | null | true |
CochainComplex.HomComplex.Cocycle.shift | Mathlib.Algebra.Homology.HomotopyCategory.HomComplexShift | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
[inst_1 : CategoryTheory.Preadditive C] →
{K L : CochainComplex C ℤ} →
{n : ℤ} →
CochainComplex.HomComplex.Cocycle K L n →
(a : ℤ) →
CochainComplex.HomComplex.Cocycle ((CategoryTheory.shiftFunctor (Cochain... | The map `Cocycle K L n → Cocycle (K⟦a⟧) (L⟦a⟧) n`. | true |
PiTensorProduct.ofFinsuppEquiv_apply | Mathlib.LinearAlgebra.PiTensorProduct.Finsupp | ∀ {R : Type u_1} {ι : Type u_2} {κ : ι → Type u_3} {M : ι → Type u_4} [inst : CommSemiring R] [inst_1 : Fintype ι]
[inst_2 : DecidableEq ι] [inst_3 : (i : ι) → DecidableEq (κ i)] [inst_4 : (i : ι) → AddCommMonoid (M i)]
[inst_5 : (i : ι) → Module R (M i)] [inst_6 : (i : ι) → DecidableEq (M i)] (f : (i : ι) → κ i →₀... | null | true |
MvPolynomial.uniqueAlgEquiv_symm_monomial | Mathlib.Algebra.MvPolynomial.Equiv | ∀ (R : Type u) {σ : Type u_1} [inst : CommSemiring R] [inst_1 : Unique σ] {d : σ →₀ ℕ} {r : R},
(MvPolynomial.uniqueAlgEquiv R σ).symm ((Polynomial.monomial (d default)) r) = (MvPolynomial.monomial d) r | null | true |
MeasureTheory.SimpleFunc.lintegralₗ._proof_2 | Mathlib.MeasureTheory.Function.SimpleFunc | ∀ {α : Type u_1} {m : MeasurableSpace α} (f : MeasureTheory.SimpleFunc α ENNReal) (x y : MeasureTheory.Measure α),
f.lintegral (x + y) = f.lintegral x + f.lintegral y | null | false |
Nonneg.mk_eq_one | Mathlib.Algebra.Order.Nonneg.Basic | ∀ {α : Type u_1} [inst : Zero α] [inst_1 : One α] [inst_2 : LE α] [inst_3 : ZeroLEOneClass α] {x : α} (hx : 0 ≤ x),
⟨x, hx⟩ = 1 ↔ x = 1 | null | true |
Valuation.IsNontrivial.exists_val_nontrivial | Mathlib.RingTheory.Valuation.Basic | ∀ {R : Type u_3} {Γ₀ : Type u_4} {inst : Ring R} {inst_1 : LinearOrderedCommMonoidWithZero Γ₀} {v : Valuation R Γ₀}
[self : v.IsNontrivial], ∃ x, v x ≠ 0 ∧ v x ≠ 1 | null | true |
Lex.instGroupWithZero._proof_5 | Mathlib.Algebra.Order.GroupWithZero.Synonym | ∀ {α : Type u_1} [GroupWithZero α], Nontrivial (Lex α) | null | false |
Module.exists_surjective_quotient_of_finite | Mathlib.RingTheory.TensorProduct.Finite | ∀ (R : Type u_1) (M : Type u_2) [inst : CommRing R] [inst_1 : AddCommGroup M] [inst_2 : Module R M] [Module.Finite R M]
[Nontrivial M], ∃ I f, I ≠ ⊤ ∧ Function.Surjective ⇑f | null | true |
Ring.directSumGRing | Mathlib.Algebra.DirectSum.Ring | (ι : Type u_1) → {R : Type u_2} → [inst : AddMonoid ι] → [inst_1 : Ring R] → DirectSum.GRing fun x => R | A direct sum of copies of a `Ring` inherits the multiplication structure. | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.