name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
Cardinal.commSemiring._proof_4 | Mathlib.SetTheory.Cardinal.Order | ∀ (n : ℕ) (x : Cardinal.{u_1}), (n + 1) • x = n • x + x | null | false |
Std.Internal.List.containsKey_of_containsKey_cons | Std.Data.Internal.List.Associative | ∀ {α : Type u} {β : α → Type v} [inst : BEq α] {l : List ((a : α) × β a)} {k a : α} {v : β k},
Std.Internal.List.containsKey a (⟨k, v⟩ :: l) = true → (k == a) = false → Std.Internal.List.containsKey a l = true | null | true |
MeasureTheory.MeasurePreserving.vaddInvariantMeasure_iterateAddAct | Mathlib.MeasureTheory.Group.Action | ∀ {α : Type w} {f : α → α} {x : MeasurableSpace α} {μ : MeasureTheory.Measure α},
MeasureTheory.MeasurePreserving f μ μ → MeasureTheory.VAddInvariantMeasure (IterateAddAct f) α μ | null | true |
WfDvdMonoid.wfDvdMonoid_associates | Mathlib.RingTheory.UniqueFactorizationDomain.Basic | ∀ {α : Type u_1} [inst : CommMonoidWithZero α] [WfDvdMonoid α], WfDvdMonoid (Associates α) | null | true |
NormedGroup.ofSeparation | Mathlib.Analysis.Normed.Group.Defs | {E : Type u_2} → [inst : SeminormedGroup E] → (∀ (x : E), ‖x‖ = 0 → x = 1) → NormedGroup E | Construct a `NormedGroup` from a `SeminormedGroup` satisfying `∀ x, ‖x‖ = 0 → x = 1`. This
avoids having to go back to the `(Pseudo)MetricSpace` level when declaring a `NormedGroup`
instance as a special case of a more general `SeminormedGroup` instance. | true |
groupCohomology.map_inv_of_isCocycle₁ | Mathlib.RepresentationTheory.Homological.GroupCohomology.LowDegree | ∀ {G : Type u_1} {A : Type u_2} [inst : Group G] [inst_1 : AddCommGroup A] [inst_2 : MulAction G A] {f : G → A},
groupCohomology.IsCocycle₁ f → ∀ (g : G), g • f g⁻¹ = -f g | null | true |
CategoryTheory.MorphismProperty.Over.pullback_obj_left | Mathlib.CategoryTheory.MorphismProperty.OverAdjunction | ∀ {T : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} T] (P Q : CategoryTheory.MorphismProperty T)
[inst_1 : Q.IsMultiplicative] {X Y : T} (f : X ⟶ Y) [inst_2 : P.HasPullbacksAlong f]
[inst_3 : P.IsStableUnderBaseChangeAlong f] [inst_4 : Q.IsStableUnderBaseChange] (A : P.Over Q Y),
((CategoryTheory.Morphism... | null | true |
Std.DHashMap.Raw.getKey! | Std.Data.DHashMap.Raw | {α : Type u} → {β : α → Type v} → [BEq α] → [Hashable α] → [Inhabited α] → Std.DHashMap.Raw α β → α → α | Checks if a mapping for the given key exists and returns the key if it does, otherwise panics.
If no panic occurs the result is guaranteed to be pointer equal to the key in the map.
| true |
IsCancelAdd | Mathlib.Algebra.Group.Semigroup | (G : Type u_2) → [Add G] → Prop | A mixin for cancellative addition. | true |
SimpleGraph.Subgraph.IsMatching.exists_of_universalVerts | Mathlib.Combinatorics.SimpleGraph.UniversalVerts | ∀ {V : Type u_1} {G : SimpleGraph V} [Finite V] {s : Set V},
Disjoint G.universalVerts s →
s.ncard ≤ G.universalVerts.ncard → ∃ t ⊆ G.universalVerts, ∃ M, M.verts = s ∪ t ∧ M.IsMatching | null | true |
List.pairwise_flatMap | Init.Data.List.Pairwise | ∀ {β : Type u_1} {α : Type u_2} {R : β → β → Prop} {l : List α} {f : α → List β},
List.Pairwise R (List.flatMap f l) ↔
(∀ a ∈ l, List.Pairwise R (f a)) ∧ List.Pairwise (fun a₁ a₂ => ∀ x ∈ f a₁, ∀ y ∈ f a₂, R x y) l | null | true |
MinTropical.instDivOfSub.eq_1 | Mathlib.Algebra.Tropical.Basic | ∀ {R : Type u} [inst : Sub R],
MinTropical.instDivOfSub = { div := fun x y => MinTropical.trop (MinTropical.untrop x - MinTropical.untrop y) } | null | true |
MeasureTheory.Submartingale.congr | Mathlib.Probability.Martingale.Basic | ∀ {Ω : Type u_1} {E : Type u_2} {ι : Type u_3} [inst : Preorder ι] {m0 : MeasurableSpace Ω}
{μ : MeasureTheory.Measure Ω} [inst_1 : NormedAddCommGroup E] [inst_2 : NormedSpace ℝ E] {f g : ι → Ω → E}
{ℱ : MeasureTheory.Filtration ι m0} [CompleteSpace E] [inst_4 : LE E],
MeasureTheory.Submartingale f ℱ μ →
Meas... | null | true |
Lean.Meta.Grind.Arith.Linear.EqCnstrProof.coeff.elim | Lean.Meta.Tactic.Grind.Arith.Linear.Types | {motive_2 : Lean.Meta.Grind.Arith.Linear.EqCnstrProof → Sort u} →
(t : Lean.Meta.Grind.Arith.Linear.EqCnstrProof) →
t.ctorIdx = 4 →
((k : ℕ) →
(c : Lean.Meta.Grind.Arith.Linear.EqCnstr) → motive_2 (Lean.Meta.Grind.Arith.Linear.EqCnstrProof.coeff k c)) →
motive_2 t | null | false |
String.Legacy.Iterator.Valid.remainingBytes_le | Batteries.Data.String.Lemmas | ∀ {it : String.Legacy.Iterator}, it.Valid → it.remainingBytes ≤ it.s.utf8ByteSize | null | true |
div_mul_comm | Mathlib.Algebra.Group.Basic | ∀ {α : Type u_1} [inst : DivisionCommMonoid α] (a b c : α), a / b * c = c / b * a | null | true |
String.Slice.endsWith_char_eq_endsWith_beq | Init.Data.String.Lemmas.Pattern.Char | ∀ {c : Char} {s : String.Slice}, s.endsWith c = s.endsWith fun x => x == c | null | true |
_private.Mathlib.Analysis.Convex.Side.0.AffineSubspace.setOfPred_sSameSide_eq_image2._simp_1_4 | Mathlib.Analysis.Convex.Side | ∀ {α : Type u_1} [inst : Preorder α] {b x : α}, (x ∈ Set.Ioi b) = (b < x) | null | false |
WittVector.IsocrystalEquiv | Mathlib.RingTheory.WittVector.Isocrystal | (p : ℕ) →
[inst : Fact (Nat.Prime p)] →
(k : Type u_1) →
[inst_1 : CommRing k] →
[inst_2 : CharP k p] →
[inst_3 : PerfectRing k p] →
(V : Type u_2) →
[inst_4 : AddCommGroup V] →
[WittVector.Isocrystal p k V] →
(V₂ : Type u_3) → [i... | An isomorphism between isocrystals respects the Frobenius map.
Notation `M ≃ᶠⁱ [p, k]` in the `Isocrystal` namespace. | true |
MulEquiv.toCommGrpIso | Mathlib.Algebra.Category.Grp.Basic | {X Y : CommGrpCat} → ↑X ≃* ↑Y → (X ≅ Y) | Build an isomorphism in the category `CommGrpCat` from a `MulEquiv`
between `CommGroup`s. | true |
MeasurableVAdd.mk._flat_ctor | Mathlib.MeasureTheory.Group.Arithmetic | ∀ {M : Type u_2} {α : Type u_3} [inst : VAdd M α] [inst_1 : MeasurableSpace M] [inst_2 : MeasurableSpace α],
(∀ (c : M), Measurable fun x => c +ᵥ x) → (∀ (x : α), Measurable fun x_1 => x_1 +ᵥ x) → MeasurableVAdd M α | null | false |
Fintype.card_eq_zero | Mathlib.Data.Fintype.Card | ∀ {α : Type u_1} [inst : Fintype α] [IsEmpty α], Fintype.card α = 0 | null | true |
LinearMap.IsRefl.liftQ₂._proof_3 | Mathlib.LinearAlgebra.Quotient.Bilinear | ∀ {S : Type u_1} {P : Type u_2} [inst : CommRing S] [inst_1 : AddCommGroup P] [inst_2 : Module S P], SMulCommClass S S P | null | false |
_private.Mathlib.RingTheory.MvPowerSeries.Substitution.0.MvPowerSeries.subst_zero_eq_C_constantCoeff._simp_1_1 | Mathlib.RingTheory.MvPowerSeries.Substitution | ∀ {σ : Type u_1} {τ : Type u_4} {S : Type u_5} [inst : CommRing S] (a : σ → MvPowerSeries τ S),
MvPowerSeries.HasSubst a =
((∀ (s : σ), IsNilpotent (MvPowerSeries.constantCoeff (a s))) ∧
∀ (d : τ →₀ ℕ), {s | (MvPowerSeries.coeff d) (a s) ≠ 0}.Finite) | null | false |
List.diff | Batteries.Data.List.Basic | {α : Type u_1} → [BEq α] → List α → List α → List α | Computes the difference of `l₁` and `l₂`, by removing each element in `l₂` from `l₁`. | true |
Array.extract_succ_right | Init.Data.Array.Extract | ∀ {α : Type u_1} {as : Array α} {i j : ℕ},
i < j + 1 → ∀ (h : j < as.size), as.extract i (j + 1) = (as.extract i j).push as[j] | null | true |
CategoryTheory.PreGaloisCategory.functorToContAction | Mathlib.CategoryTheory.Galois.Equivalence | {C : Type u₁} →
[inst : CategoryTheory.Category.{u₂, u₁} C] →
(F : CategoryTheory.Functor C FintypeCat) → CategoryTheory.Functor C (ContAction FintypeCat (CategoryTheory.Aut F)) | The induced functor from `C` to the category of finite, discrete `Aut F`-sets. | true |
AddMonoidAlgebra.Monic.pow | Mathlib.Algebra.MonoidAlgebra.Degree | ∀ {R : Type u_1} [inst : Semiring R] {A : Type u_8} {B : Type u_9} [inst_1 : AddMonoid A] [inst_2 : AddMonoid B]
[inst_3 : LinearOrder B] [inst_4 : OrderBot B] [AddLeftStrictMono B] [AddRightStrictMono B] {D : A → B}
{p : AddMonoidAlgebra R A} {n : ℕ},
(∀ (a1 a2 : A), D (a1 + a2) = D a1 + D a2) →
Function.Inj... | null | true |
List.ofFn_const._f | Mathlib.Data.List.OfFn | ∀ {α : Type u} (x : ℕ)
(f : Nat.below (motive := fun x => ∀ (x_1 : α), (List.ofFn fun x => x_1) = List.replicate x x_1) x) (x_1 : α),
(List.ofFn fun x => x_1) = List.replicate x x_1 | null | false |
CompleteLat.dual._proof_1 | Mathlib.Order.Category.CompleteLat | ∀ (X : CompleteLat),
CompleteLatticeHom.dual (CategoryTheory.CategoryStruct.id X) = CategoryTheory.CategoryStruct.id ↧(↑X)ᵒᵈ | null | false |
CategoryTheory.PreOneHypercover.Hom.mapMulticospan._proof_11 | Mathlib.CategoryTheory.Sites.Hypercover.One | ∀ {C : Type u_3} [inst : CategoryTheory.Category.{u_2, u_3} C] {S : C} {E : CategoryTheory.PreOneHypercover S}
{F : CategoryTheory.PreOneHypercover S} (f : E.Hom F) (a : E.multicospanShape.R),
(match CategoryTheory.Limits.WalkingMulticospan.left (E.multicospanShape.fst a),
CategoryTheory.Limits.WalkingMultico... | null | false |
CategoryTheory.Bicategory.whiskerLeft_rightUnitor | Mathlib.CategoryTheory.Bicategory.Basic | ∀ {B : Type u} [inst : CategoryTheory.Bicategory B] {a b c : B} (f : a ⟶ b) (g : b ⟶ c),
CategoryTheory.Bicategory.whiskerLeft f (CategoryTheory.Bicategory.rightUnitor g).hom =
CategoryTheory.CategoryStruct.comp
(CategoryTheory.Bicategory.associator f g (CategoryTheory.CategoryStruct.id c)).inv
(Categ... | null | true |
LinearEquiv.transvection.inv_eq'._auto_1 | Mathlib.LinearAlgebra.Transvection.Basic | Lean.Syntax | null | false |
Ideal.Quotient.mk | Mathlib.RingTheory.Ideal.Quotient.Defs | {R : Type u} → [inst : Ring R] → (I : Ideal R) → [inst_1 : I.IsTwoSided] → R →+* R ⧸ I | The ring homomorphism from a ring `R` to a quotient ring `R/I`. | true |
_private.Mathlib.Analysis.SpecialFunctions.Exp.0.Real.tendsto_exp_div_pow_atTop._simp_1_4 | Mathlib.Analysis.SpecialFunctions.Exp | ∀ {α : Type u_1} [inst : DivisionCommMonoid α] (a b : α), b⁻¹ * a = a / b | null | false |
Manifold.isLocalSourceTargetProperty_submmersionAtProp | Mathlib.Geometry.Manifold.Submersion | ∀ {𝕜 : Type u_1} {E'' : Type u_3} {F : Type u_5} {H : Type u_7} {G : Type u_9} {E : Type u}
[inst : NontriviallyNormedField 𝕜] [inst_1 : NormedAddCommGroup E] [inst_2 : NormedSpace 𝕜 E]
[inst_3 : NormedAddCommGroup E''] [inst_4 : NormedSpace 𝕜 E''] [inst_5 : NormedAddCommGroup F]
[inst_6 : NormedSpace 𝕜 F] [... | Being a submersion at `x` is a local property. | true |
_private.Mathlib.Tactic.NormNum.Irrational.0.Mathlib.Meta.NormNum.findNotPowerCertificate._sparseCasesOn_8 | Mathlib.Tactic.NormNum.Irrational | {motive : Bool → Sort u} → (t : Bool) → motive true → (Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t | null | false |
Homeomorph.homeomorphOfUnique_symm_apply | Mathlib.Topology.Homeomorph.Defs | ∀ (X : Type u_1) (Y : Type u_2) [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] [inst_2 : Unique X]
[inst_3 : Unique Y] (a : Y), (Homeomorph.homeomorphOfUnique X Y).symm a = default | null | true |
generateFrom_iInter_of_generateFrom_eq_self | Mathlib.Topology.Order | ∀ {α : Type u} {ι : Sort v} (f : ι → Set (Set α)),
(∀ (i : ι), {s | IsOpen s} = f i) →
TopologicalSpace.generateFrom (⋂ i, f i) = ⨆ i, TopologicalSpace.generateFrom (f i) | null | true |
_private.Mathlib.Topology.IsLocalHomeomorph.0.isLocalHomeomorph_iff_isOpenEmbedding_restrict._simp_1_1 | Mathlib.Topology.IsLocalHomeomorph | ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] {f : X → Y},
IsLocalHomeomorph f = IsLocalHomeomorphOn f Set.univ | null | false |
LatticeHom.birkhoffFinset_injective | Mathlib.Order.Birkhoff | ∀ {α : Type u_1} [inst : DistribLattice α] [inst_1 : Fintype α] [inst_2 : DecidablePred SupIrred],
Function.Injective ⇑LatticeHom.birkhoffFinset | null | true |
AddSubsemigroup.mk._flat_ctor | Mathlib.Algebra.Group.Subsemigroup.Defs | {M : Type u_3} →
[inst : Add M] → (carrier : Set M) → (∀ {a b : M}, a ∈ carrier → b ∈ carrier → a + b ∈ carrier) → AddSubsemigroup M | null | false |
_private.Lean.Compiler.LCNF.Types.0.Lean.Compiler.LCNF.toLCNFType.visitForall._sparseCasesOn_3 | Lean.Compiler.LCNF.Types | {motive : Lean.Name → Sort u} →
(t : Lean.Name) → motive Lean.Name.anonymous → (Nat.hasNotBit 1 t.ctorIdx → motive t) → motive t | null | false |
Set.InvOn.extendDomain | Mathlib.Data.Set.Function | ∀ {α : Type u_1} {β : Type u_2} {p : β → Prop} [inst : DecidablePred p] {f : α ≃ Subtype p} {g₁ g₂ : Equiv.Perm α}
{s t : Set α},
Set.InvOn (⇑g₁) (⇑g₂) s t →
Set.InvOn (⇑(g₁.extendDomain f)) (⇑(g₂.extendDomain f)) (Subtype.val ∘ ⇑f '' s) (Subtype.val ∘ ⇑f '' t) | null | true |
String.Slice.instToFormat | Init.Data.String.Slice | Std.ToFormat String.Slice | null | true |
ProofWidgets.instRpcEncodableExprPresentationProps | ProofWidgets.Presentation.Expr | Lean.Server.RpcEncodable ProofWidgets.ExprPresentationProps | null | true |
TensorProduct.AlgebraTensorModule.lift._proof_4 | Mathlib.LinearAlgebra.TensorProduct.Tower | ∀ {R : Type u_1} {M : Type u_2} {N : Type u_3} [inst : CommSemiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
[inst_3 : AddCommMonoid N] [inst_4 : Module R N], SMulCommClass R R (TensorProduct R M N) | null | false |
CategoryTheory.SimplicialObject.δ₀Iter_succ | Mathlib.AlgebraicTopology.SimplicialObject.DeltaZeroIter | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] (X : CategoryTheory.SimplicialObject C) (i : ℕ) {n m : ℕ}
(h : autoParam (n + i = m) CategoryTheory.SimplicialObject.δ₀Iter_succ._auto_1),
X.δ₀Iter (i + 1) ⋯ = CategoryTheory.CategoryStruct.comp (X.δ 0) (X.δ₀Iter i h) | null | true |
_private.Lean.DocString.Parser.0.Lean.Doc.Parser.code.normFn._sparseCasesOn_3 | Lean.DocString.Parser | {motive_1 : Lean.Syntax → Sort u} →
(t : Lean.Syntax) →
((info : Lean.SourceInfo) → (val : String) → motive_1 (Lean.Syntax.atom info val)) →
(Nat.hasNotBit 4 t.ctorIdx → motive_1 t) → motive_1 t | null | false |
ENat.toNat | Mathlib.Data.ENat.Basic | ℕ∞ → ℕ | Conversion of `ℕ∞` to `ℕ` sending `∞` to `0`. | true |
Colex.rec | Mathlib.Order.Lex | {α : Type u_1} → {β : Colex α → Sort u_2} → ((a : α) → β (toColex a)) → (a : Colex α) → β a | A recursor for `Colex`. Use as `induction x`. | true |
_private.Lean.Compiler.LCNF.Visibility.0.Lean.Compiler.LCNF.checkMeta.go.match_1 | Lean.Compiler.LCNF.Visibility | (motive : Option Lean.ModuleIdx → Sort u_1) →
(x : Option Lean.ModuleIdx) →
((modIdx : Lean.ModuleIdx) → motive (some modIdx)) → ((x : Option Lean.ModuleIdx) → motive x) → motive x | null | false |
_private.Mathlib.Geometry.Manifold.PartitionOfUnity.0.Metric.exists_contMDiffMap_forall_closedEBall_subset._simp_1_2 | Mathlib.Geometry.Manifold.PartitionOfUnity | ∀ {α : Sort u_1} {p q : α → Prop}, (∀ (x : α), p x ∧ q x) = ((∀ (x : α), p x) ∧ ∀ (x : α), q x) | null | false |
Std.Http.Method.updateredirectref.sizeOf_spec | Std.Http.Data.Method | sizeOf Std.Http.Method.updateredirectref = 1 | null | true |
SemiNormedGrp₁.cokernelLift | Mathlib.Analysis.Normed.Group.SemiNormedGrp.Kernels | {X Y : SemiNormedGrp₁} →
(f : X ⟶ Y) → (s : CategoryTheory.Limits.CokernelCofork f) → (SemiNormedGrp₁.cokernelCocone f).pt ⟶ s.pt | Auxiliary definition for `HasCokernels SemiNormedGrp₁`. | true |
BooleanSubalgebra.inclusion._proof_4 | Mathlib.Order.BooleanSubalgebra | ∀ {α : Type u_1} [inst : BooleanAlgebra α] {L M : BooleanSubalgebra α} (h : L ≤ M),
Set.inclusion h ⊥ = Set.inclusion h ⊥ | null | false |
CategoryTheory.Iso.core | Mathlib.CategoryTheory.Core | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{D : Type u₂} →
[inst_1 : CategoryTheory.Category.{v₂, u₂} D] → {F G : CategoryTheory.Functor C D} → (F ≅ G) → (F.core ≅ G.core) | A natural isomorphism of functors induces a natural isomorphism between their cores. | true |
Std.ExtDTreeMap.getKey?_inter_of_not_mem_left | Std.Data.ExtDTreeMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t₁ t₂ : Std.ExtDTreeMap α β cmp} [inst : Std.TransCmp cmp]
{k : α}, k ∉ t₁ → (t₁ ∩ t₂).getKey? k = none | null | true |
WellFounded.partialExtrinsicFix_eq_apply | Init.WFExtrinsicFix | ∀ {α : Sort u_2} {C : α → Sort u_1} [inst : ∀ (a : α), Nonempty (C a)] {R : α → α → Prop}
{F : (a : α) → ((a' : α) → R a' a → C a') → C a} {a : α},
WellFounded R → WellFounded.partialExtrinsicFix R F a = F a fun a' x => WellFounded.partialExtrinsicFix R F a' | null | true |
String.dropEndWhile_dropEndWhile | Init.Data.String.Lemmas.Pattern.TakeDrop.Basic | ∀ {ρ : Type} {pat : ρ} [inst : String.Slice.Pattern.Model.PatternModel pat]
[inst_1 : String.Slice.Pattern.BackwardPattern pat] [String.Slice.Pattern.Model.LawfulBackwardPatternModel pat]
{s : String}, (s.dropEndWhile pat).dropEndWhile pat = s.dropEndWhile pat | null | true |
_private.Mathlib.Analysis.Calculus.ContDiff.Convolution.0.HasCompactSupport.hasDerivAt_convolution_left._simp_1_1 | Mathlib.Analysis.Calculus.ContDiff.Convolution | ∀ {𝕜 : Type u𝕜} {G : Type uG} {E : Type uE} {E' : Type uE'} {F : Type uF} [inst : NormedAddCommGroup E]
[inst_1 : NormedAddCommGroup E'] [inst_2 : NormedAddCommGroup F] {f : G → E} {g : G → E'}
[inst_3 : NontriviallyNormedField 𝕜] [inst_4 : NormedSpace 𝕜 E] [inst_5 : NormedSpace 𝕜 E'] [inst_6 : NormedSpace 𝕜 ... | null | false |
String.Pos.next_le_iff_lt | Init.Data.String.Lemmas.Order | ∀ {s : String} {p q : s.Pos} {h : p ≠ s.endPos}, p.next h ≤ q ↔ p < q | null | true |
Matrix.linfty_opNorm_def | Mathlib.Analysis.Matrix.Normed | ∀ {m : Type u_3} {n : Type u_4} {α : Type u_5} [inst : Fintype m] [inst_1 : Fintype n]
[inst_2 : SeminormedAddCommGroup α] (A : Matrix m n α), ‖A‖ = ↑(Finset.univ.sup fun i => ∑ j, ‖A i j‖₊) | null | true |
QuadraticAlgebra.re | Mathlib.Algebra.QuadraticAlgebra.Defs | {R : Type u} → {a b : R} → QuadraticAlgebra R a b → R | Real part of an element in quadratic algebra | true |
CochainComplex.shiftFunctorAdd_inv_app_f._proof_1 | Mathlib.Algebra.Homology.HomotopyCategory.Shift | ∀ (a b n : ℤ), n + { as := b }.as + { as := a }.as = n + { as := a + b }.as | null | false |
LieAlgebra.mem_zeroRootSubalgebra | Mathlib.Algebra.Lie.Weights.Cartan | ∀ (R : Type u_1) (L : Type u_2) [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : LieAlgebra R L]
(H : LieSubalgebra R L) [inst_3 : LieRing.IsNilpotent ↥H] (x : L),
x ∈ LieAlgebra.zeroRootSubalgebra R L H ↔ ∀ (y : ↥H), ∃ k, ((LieModule.toEnd R (↥H) L) y ^ k) x = 0 | null | true |
List.isChain_destutter' | Mathlib.Data.List.Destutter | ∀ {α : Type u_1} (R : α → α → Prop) [inst : DecidableRel R] (l : List α) (a : α), List.IsChain R (List.destutter' R a l) | null | true |
AlgebraicGeometry.IsClosedImmersion.comp | Mathlib.AlgebraicGeometry.Morphisms.ClosedImmersion | ∀ {X Y Z : AlgebraicGeometry.Scheme} (f : X ⟶ Y) (g : Y ⟶ Z) [AlgebraicGeometry.IsClosedImmersion f]
[AlgebraicGeometry.IsClosedImmersion g], AlgebraicGeometry.IsClosedImmersion (CategoryTheory.CategoryStruct.comp f g) | Composition of closed immersions is a closed immersion. | true |
Ultrafilter.instPure | Mathlib.Order.Filter.Ultrafilter.Defs | Pure Ultrafilter | The principal ultrafilter associated to a point `x`. | true |
List.max?_cons | Init.Data.List.MinMax | ∀ {α : Type u_1} {x : α} [inst : Max α] [Std.Associative max] {xs : List α},
(x :: xs).max? = some (xs.max?.elim x (max x)) | null | true |
CategoryTheory.FreeBicategory.Hom.comp.elim | Mathlib.CategoryTheory.Bicategory.Free | {B : Type u} →
[inst : Quiver B] →
{motive : (a a_1 : B) → CategoryTheory.FreeBicategory.Hom a a_1 → Sort u_1} →
{a a_1 : B} →
(t : CategoryTheory.FreeBicategory.Hom a a_1) →
t.ctorIdx = 2 →
({a b c : B} →
(f : CategoryTheory.FreeBicategory.Hom a b) →
... | null | false |
Mathlib.Tactic.Choose.ElimStatus.noConfusion | Mathlib.Tactic.Choose | {P : Sort u} →
{t t' : Mathlib.Tactic.Choose.ElimStatus} → t = t' → Mathlib.Tactic.Choose.ElimStatus.noConfusionType P t t' | null | false |
Bialgebra.unitBialgHom._proof_2 | Mathlib.RingTheory.Bialgebra.Hom | ∀ (R : Type u_1) (A : Type u_2) [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Bialgebra R A],
(Algebra.TensorProduct.map (Algebra.ofId R A) (Algebra.ofId R A)).comp (Bialgebra.comulAlgHom R R) =
(Bialgebra.comulAlgHom R A).comp (Algebra.ofId R A) | null | false |
IsDedekindDomain.rec | Mathlib.RingTheory.DedekindDomain.Basic | {A : Type u_2} →
[inst : CommRing A] →
{motive : IsDedekindDomain A → Sort u} →
([toIsDomain : IsDomain A] → [toIsDedekindRing : IsDedekindRing A] → motive ⋯) →
(t : IsDedekindDomain A) → motive t | null | false |
_private.Std.Sat.AIG.RefVec.0.Std.Sat.AIG.RefVec.push._simp_1 | Std.Sat.AIG.RefVec | ∀ {α : Type} [inst : Hashable α] [inst_1 : DecidableEq α] {aig : Std.Sat.AIG α} (self : aig.Ref),
(self.gate < aig.decls.size) = True | null | false |
_private.Mathlib.Analysis.InnerProductSpace.Orthonormal.0.Orthonormal.sum_inner_products_le._simp_1_4 | Mathlib.Analysis.InnerProductSpace.Orthonormal | ∀ {G : Type u_3} [inst : AddGroup G] {a b c : G}, (a - b = a - c) = (b = c) | null | false |
CommRingCat.commRingObj._proof_3 | Mathlib.Algebra.Category.Ring.Limits | ∀ {J : Type u_3} [inst : CategoryTheory.Category.{u_2, u_3} J] (F : CategoryTheory.Functor J CommRingCat) (j : J)
(n : ℕ), IntCast.intCast ↑n = ↑n | null | false |
SetRel.right_subset_comp | Mathlib.Basic.Rel | ∀ {α : Type u_1} {β : Type u_2} {R : SetRel α α} [R.IsRefl] {S : SetRel α β}, S ⊆ R.comp S | null | true |
ExteriorAlgebra.algebraMap_eq_one_iff | Mathlib.LinearAlgebra.ExteriorAlgebra.Basic | ∀ {R : Type u1} [inst : CommRing R] (M : Type u2) [inst_1 : AddCommGroup M] [inst_2 : Module R M] (x : R),
(algebraMap R (ExteriorAlgebra R M)) x = 1 ↔ x = 1 | null | true |
Lean.Meta.Sym.Arith.Ring._sizeOf_1 | Lean.Meta.Sym.Arith.Types | Lean.Meta.Sym.Arith.Ring → ℕ | null | false |
Lean.LBool.undef | Lean.Data.LBool | Lean.LBool | null | true |
List.head_of_mem_head? | Init.Data.List.Lemmas | ∀ {α : Type u_1} {l : List α} {x : α} (hx : x ∈ l.head?), l.head ⋯ = x | null | true |
LieAlgebra.derivedSeriesOfIdeal_zero | Mathlib.Algebra.Lie.Solvable | ∀ (R : Type u) (L : Type v) [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : LieAlgebra R L] (I : LieIdeal R L),
LieAlgebra.derivedSeriesOfIdeal R L 0 I = I | null | true |
CommRing.relPic_eq_top | Mathlib.RingTheory.PicardGroup | ∀ (R : Type u) [inst : CommSemiring R] (A : Type u_5) [inst_1 : CommSemiring A] [inst_2 : Algebra R A]
[Subsingleton (CommRing.Pic A)], CommRing.relPic R A = ⊤ | null | true |
_private.Mathlib.Algebra.GroupWithZero.Action.Pointwise.Finset.0.Finset.inv_smul_finset_distrib₀._simp_1_4 | Mathlib.Algebra.GroupWithZero.Action.Pointwise.Finset | ∀ {α : Type u_1} [inst : Zero α] (a : α), (MulOpposite.op a = 0) = (a = 0) | null | false |
CategoryTheory.Idempotents.toKaroubi_isEquivalence | Mathlib.CategoryTheory.Idempotents.Karoubi | ∀ (C : Type u_1) [inst : CategoryTheory.Category.{v_1, u_1} C] [CategoryTheory.IsIdempotentComplete C],
(CategoryTheory.Idempotents.toKaroubi C).IsEquivalence | If `C` is idempotent complete, the functor `toKaroubi : C ⥤ Karoubi C` is an equivalence. | true |
CategoryTheory.Limits.prod.diag_map_assoc | Mathlib.CategoryTheory.Limits.Shapes.BinaryProducts.BinaryProducts | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y : C} (f : X ⟶ Y)
[inst_1 : CategoryTheory.Limits.HasBinaryProduct X X] [inst_2 : CategoryTheory.Limits.HasBinaryProduct Y Y] {Z : C}
(h : Y ⨯ Y ⟶ Z),
CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.diag X)
(CategoryTheory.CategoryStruct... | null | true |
_private.Mathlib.RingTheory.Ideal.Operations.0.Ideal.range_finsuppTotal.match_1_1 | Mathlib.RingTheory.Ideal.Operations | ∀ {ι : Type u_3} {M : Type u_1} [inst : AddCommGroup M] {R : Type u_2} [inst_1 : CommRing R] [inst_2 : Module R M]
(I : Ideal R) {v : ι → M} (x : M) (motive : x ∈ (Ideal.finsuppTotal ι M I v).range → Prop)
(x_1 : x ∈ (Ideal.finsuppTotal ι M I v).range),
(∀ (f : ι →₀ ↥I) (h : (Ideal.finsuppTotal ι M I v) f = x), m... | null | false |
MeasureTheory.Filtration.const | Mathlib.Probability.Process.Filtration | {Ω : Type u_1} →
(ι : Type u_2) →
{m : MeasurableSpace Ω} → [inst : Preorder ι] → (m' : MeasurableSpace Ω) → m' ≤ m → MeasureTheory.Filtration ι m | The constant filtration which is equal to `m` for all `i : ι`. | true |
RingCat.Colimits.instRingColimitType._proof_18 | Mathlib.Algebra.Category.Ring.Colimits | ∀ {J : Type u_1} [inst : CategoryTheory.SmallCategory J] (F : CategoryTheory.Functor J RingCat)
(a b : RingCat.Colimits.ColimitType F), a - b = a + -b | null | false |
Lean.RecursorRule.mk.inj | Lean.Declaration | ∀ {ctor : Lean.Name} {nfields : ℕ} {rhs : Lean.Expr} {ctor_1 : Lean.Name} {nfields_1 : ℕ} {rhs_1 : Lean.Expr},
{ ctor := ctor, nfields := nfields, rhs := rhs } = { ctor := ctor_1, nfields := nfields_1, rhs := rhs_1 } →
ctor = ctor_1 ∧ nfields = nfields_1 ∧ rhs = rhs_1 | null | true |
_private.Init.Data.Range.Polymorphic.Lemmas.0.Std.Rio.mem_succ_iff._simp_1_2 | Init.Data.Range.Polymorphic.Lemmas | ∀ {α : Type u} [inst : Std.PRange.UpwardEnumerable α] [Std.PRange.LawfulUpwardEnumerable α]
[inst_2 : Std.PRange.InfinitelyUpwardEnumerable α] [Std.PRange.LinearlyUpwardEnumerable α] {a b : α},
Std.PRange.UpwardEnumerable.LT a (Std.PRange.succ b) = Std.PRange.UpwardEnumerable.LE a b | null | false |
_private.Mathlib.ModelTheory.Arithmetic.Presburger.Semilinear.Basic.0.linearIndepOn_toRatVec | Mathlib.ModelTheory.Arithmetic.Presburger.Semilinear.Basic | ∀ {ι : Type u_3} {s : Set (ι → ℕ)}, LinearIndepOn ℕ id s → LinearIndepOn ℚ (⇑toRatVec✝) s | null | true |
_private.Mathlib.Analysis.Complex.MeanValue.0.circleAverage_sub_sub_inv_smul_of_differentiable_on_off_countable._simp_1_16 | Mathlib.Analysis.Complex.MeanValue | ∀ {G₀ : Type u_3} [inst : GroupWithZero G₀] {a : G₀} (n : ℤ), a ≠ 0 → (a ^ n = 0) = False | null | false |
_private.Lean.Elab.Tactic.Try.0.Lean.Elab.Tactic.Try.grindTraceToGrind.match_1 | Lean.Elab.Tactic.Try | (motive : Option Lean.Syntax → Sort u_1) →
(only : Option Lean.Syntax) →
((only : Lean.Syntax) → motive (some only)) → ((x : Option Lean.Syntax) → motive x) → motive only | null | false |
CommGrpCat.Hom.noConfusionType | Mathlib.Algebra.Category.Grp.Basic | Sort u_1 → {A B : CommGrpCat} → A.Hom B → {A' B' : CommGrpCat} → A'.Hom B' → Sort u_1 | null | false |
Lean.Meta.Match.Example.noConfusion | Lean.Meta.Match.Basic | {P : Sort u} → {t t' : Lean.Meta.Match.Example} → t = t' → Lean.Meta.Match.Example.noConfusionType P t t' | null | false |
_private.Std.Time.Zoned.Database.TZdb.0.Std.Time.Database.TZdb.instBEqTZSpec.beq._sparseCasesOn_2 | Std.Time.Zoned.Database.TZdb | {motive : Std.Time.Database.TZdb.TZSpec → Sort u} →
(t : Std.Time.Database.TZdb.TZSpec) →
((id : String) → motive (Std.Time.Database.TZdb.TZSpec.zoneId id)) →
(Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t | null | false |
PeriodPair.«term℘[_]» | Mathlib.Analysis.SpecialFunctions.Elliptic.Weierstrass | Lean.ParserDescr | The Weierstrass `℘` function. This has the notation `℘[L]` in the namespace `PeriodPairs`. | true |
CategoryTheory.MonoOver.instCoeOut | Mathlib.CategoryTheory.Subobject.MonoOver | {C : Type u₁} → [inst : CategoryTheory.Category.{v₁, u₁} C] → {X : C} → CoeOut (CategoryTheory.MonoOver X) C | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.