name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
_private.Mathlib.Algebra.Lie.Basis.Prod.0.LieAlgebra.Basis.lie_snd_eq_zero_of_mem_prodCartan._proof_1_4 | Mathlib.Algebra.Lie.Basis.Prod | ∀ {ι₁ : Type u_5} {ι₂ : Type u_4} {L₁ : Type u_1} {L₂ : Type u_2} [inst : Finite ι₁] [inst_1 : Finite ι₂] (eι : ι₁ ≃ ι₂)
[inst_2 : LieRing L₁] [inst_3 : LieRing L₂] {R : Type u_3} [inst_4 : CommRing R] [inst_5 : LieAlgebra R L₁]
{H₁ : LieSubalgebra R L₁} (b₁ : LieAlgebra.Basis ι₁ H₁) [inst_6 : LieAlgebra R L₂] {H₂ ... | null | false |
CategoryTheory.regularOfIsPullbackSndOfRegular._proof_2 | Mathlib.CategoryTheory.Limits.Shapes.RegularMono | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {Q R S : C} {h : Q ⟶ S} {k : R ⟶ S}
(hr : CategoryTheory.RegularMono h)
(s :
CategoryTheory.Limits.Fork (CategoryTheory.CategoryStruct.comp k hr.left)
(CategoryTheory.CategoryStruct.comp k hr.right)),
CategoryTheory.CategoryStruct.comp (Cate... | null | false |
Set.mem_Icc | Mathlib.Order.Interval.Set.Defs | ∀ {α : Type u_1} [inst : Preorder α] {a b x : α}, x ∈ Set.Icc a b ↔ a ≤ x ∧ x ≤ b | null | true |
HahnSeries.single_eq_zero | Mathlib.RingTheory.HahnSeries.Basic | ∀ {Γ : Type u_1} {R : Type u_3} [inst : PartialOrder Γ] [inst_1 : Zero R] {a : Γ}, (HahnSeries.single a) 0 = 0 | null | true |
AddMonoid.End.ext | Mathlib.Algebra.Group.Hom.Defs | ∀ (M : Type u_4) [inst : AddZero M] {f g : AddMonoid.End M}, (∀ (x : M), f x = g x) → f = g | null | true |
LieRinehartAlgebra.mk | Mathlib.Algebra.LieRinehartAlgebra.Defs | ∀ {R : Type u_1} {A : Type u_2} {L : Type u_3} [inst : CommRing A] [inst_1 : LieRing L] [inst_2 : Module A L]
[inst_3 : LieRingModule L A] [inst_4 : LieRinehartRing A L] [inst_5 : CommRing R] [inst_6 : Algebra R A]
[inst_7 : LieAlgebra R L] [toIsScalarTower : IsScalarTower R A L] [toLieModule : LieModule R L A],
... | null | true |
Std.Do.PostCond.entails.trans | Std.Do.PostCond | ∀ {α : Type u_1} {ps : Std.Do.PostShape} {P Q R : Std.Do.PostCond α ps}, P.entails Q → Q.entails R → P.entails R | null | true |
uniformity_eq_comap_mul_inv_nhds_one | Mathlib.Topology.Algebra.IsUniformGroup.Defs | ∀ (Gᵣ : Type u_3) [inst : UniformSpace Gᵣ] [inst_1 : Group Gᵣ] [IsRightUniformGroup Gᵣ],
uniformity Gᵣ = Filter.comap (fun x => x.2 * x.1⁻¹) (nhds 1) | null | true |
_private.Lean.Elab.Binders.0.Lean.Elab.Term.expandMatchAltsIntoMatchAux._unsafe_rec | Lean.Elab.Binders | Lean.Syntax → Bool → Bool → ℕ → Array Lean.Syntax → Array Lean.Ident → Lean.MacroM Lean.Syntax | null | false |
MeasureTheory.closedCompactCylinders.eq_1 | Mathlib.MeasureTheory.Constructions.ClosedCompactCylinders | ∀ {ι : Type u_1} (X : ι → Type u_2) [inst : (i : ι) → TopologicalSpace (X i)],
MeasureTheory.closedCompactCylinders X =
⋃ s, ⋃ S, ⋃ (_ : IsClosed S), ⋃ (_ : IsCompact S), {MeasureTheory.cylinder s S} | null | true |
Aesop.RulePatternIndex.getSingle | Aesop.Index.RulePattern | Lean.Expr → Aesop.RulePatternIndex → Aesop.BaseM (Array (Aesop.RuleName × Aesop.Substitution)) | Get rule pattern substitutions for the patterns that match `e`. | true |
UniformConvergenceCLM.coe_zero | Mathlib.Topology.Algebra.Module.Spaces.UniformConvergenceCLM | ∀ {F : Type u_2} {α : Type u_4} {β : Type u_5} [inst : FunLike F α β] [inst_1 : Zero F] [inst_2 : Zero β]
[IsZeroApply F α β], ⇑0 = 0 | **Alias** of `FunLike.coe_zero`. | true |
Ideal.mul_add_mem_pow_succ_unique | Mathlib.RingTheory.Ideal.Norm.AbsNorm | ∀ {S : Type u_1} [inst : CommRing S] {P : Ideal S} [P_prime : P.IsPrime] [IsDedekindDomain S],
P ≠ ⊥ →
∀ {i : ℕ} (a d d' e e' : S),
a ∉ P ^ (i + 1) → e ∈ P ^ (i + 1) → e' ∈ P ^ (i + 1) → a * d + e - (a * d' + e') ∈ P ^ (i + 1) → d - d' ∈ P | The choice of `d` in `Ideal.exists_mul_add_mem_pow_succ` is unique, up to `P`.
Inspired by [Neukirch], proposition 6.1 | true |
Std.ExtHashMap.size_alter_eq_add_one | Std.Data.ExtHashMap.Lemmas | ∀ {α : Type u} {β : Type v} {x : BEq α} {x_1 : Hashable α} {m : Std.ExtHashMap α β} [inst : EquivBEq α]
[inst_1 : LawfulHashable α] {k : α} {f : Option β → Option β},
k ∉ m → (f m[k]?).isSome = true → (m.alter k f).size = m.size + 1 | null | true |
_private.Std.Sync.Channel.0.Std.CloseableChannel.Bounded.send | Std.Sync.Channel | {α : Type} → Std.CloseableChannel.Bounded✝ α → α → BaseIO (Task (Except Std.CloseableChannel.Error Unit)) | null | true |
TopologicalSpace.IrreducibleCloseds.equivSubtype'._proof_1 | Mathlib.Topology.Sets.Closeds | ∀ {α : Type u_1} [inst : TopologicalSpace α],
Function.LeftInverse (fun a => { carrier := ↑a, isIrreducible' := ⋯, isClosed' := ⋯ }) fun a => ⟨a.carrier, ⋯⟩ | null | false |
Joined.pi | Mathlib.Topology.Connected.PathConnected | ∀ {ι : Type u_3} {Z : ι → Type u_4} [inst : (i : ι) → TopologicalSpace (Z i)] {x y : (i : ι) → Z i},
(∀ (i : ι), Joined (x i) (y i)) → Joined x y | If for each `i`, `x i` is joined to `y i`, then `x` is joined to `y` in the product space. | true |
DirectSum.instAddCommMonoid._proof_10 | Mathlib.Algebra.DirectSum.Basic | ∀ (ι : Type u_1) (β : ι → Type u_2) [inst : (i : ι) → AddCommMonoid (β i)] (a b : DirectSum ι β), a + b = b + a | null | false |
YoungDiagram.equivListRowLens._proof_3 | Mathlib.Combinatorics.Young.YoungDiagram | ∀ (x : { w // w.SortedGE ∧ ∀ x ∈ w, 0 < x }),
(YoungDiagram.ofRowLens ↑x ⋯).rowLens.SortedGE ∧ ∀ x_1 ∈ (YoungDiagram.ofRowLens ↑x ⋯).rowLens, 0 < x_1 | null | false |
ZeroAtInftyContinuousMap.toOnePointNonUnitalAlgHom._proof_1 | Mathlib.Topology.ContinuousMap.ZeroAtInftyUnitization | ∀ (X : Type u_1) (R : Type u_2) (S : Type u_3) [inst : TopologicalSpace X] [inst_1 : R1Space X]
[inst_2 : TopologicalSpace R] [inst_3 : NonUnitalNonAssocSemiring R] [inst_4 : Semiring S] [inst_5 : Module S R]
[inst_6 : ContinuousConstSMul S R] (s : S) (f : ZeroAtInftyContinuousMap X R), (s • f).toOnePoint = s • f.t... | null | false |
LieAlgebra.ofTwoCocycle._sizeOf_inst | Mathlib.Algebra.Lie.Extension | {R : Type u_5} →
{L : Type u_6} →
{M : Type u_7} →
{inst : CommRing R} →
{inst_1 : LieRing L} →
{inst_2 : LieAlgebra R L} →
{inst_3 : AddCommGroup M} →
{inst_4 : Module R M} →
{inst_5 : LieRingModule L M} →
{inst_6 : LieModule R L... | null | false |
AffineMap.nonempty | Mathlib.LinearAlgebra.AffineSpace.AffineMap | ∀ {k : Type u_1} {V1 : Type u_2} {P1 : Type u_3} {V2 : Type u_4} {P2 : Type u_5} [inst : Ring k]
[inst_1 : AddCommGroup V1] [inst_2 : Module k V1] [inst_3 : AddTorsor V1 P1] [inst_4 : AddCommGroup V2]
[inst_5 : Module k V2] [inst_6 : AddTorsor V2 P2], Nonempty (P1 →ᵃ[k] P2) | null | true |
ProofWanted._sizeOf_1 | Batteries.Util.ProofWanted | {α : Sort u} → [SizeOf α] → ProofWanted α → ℕ | null | false |
_private.Mathlib.Algebra.Order.Archimedean.Submonoid.0.SubmonoidClass.instMulArchimedean._simp_1 | Mathlib.Algebra.Order.Archimedean.Submonoid | ∀ {α : Type u_2} [inst : LT α] {p : α → Prop} {x y : Subtype p}, (x < y) = (↑x < ↑y) | null | false |
Submodule.span_prod_le | Mathlib.LinearAlgebra.Span.Basic | ∀ {R : Type u_1} {M : Type u_4} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] {M' : Type u_8}
[inst_3 : AddCommMonoid M'] [inst_4 : Module R M'] (s : Set M) (t : Set M'),
Submodule.span R (s ×ˢ t) ≤ (Submodule.span R s).prod (Submodule.span R t) | null | true |
EReal.zero_mul | Mathlib.Data.EReal.Basic | ∀ (x : EReal), 0 * x = 0 | null | true |
Subfield.instSMulWithZeroSubtypeMem | Mathlib.Algebra.Field.Subfield.Basic | {K : Type u} →
[inst : DivisionRing K] →
{X : Type u_1} → [inst_1 : Zero X] → [SMulWithZero K X] → (F : Subfield K) → SMulWithZero (↥F) X | The action by a subfield is the action by the underlying field. | true |
_private.Mathlib.RingTheory.Invariant.Basic.0.Algebra.IsInvariant.orbit_eq_primesOver.match_1_1 | Mathlib.RingTheory.Invariant.Basic | ∀ (B : Type u_1) (G : Type u_2) [inst : CommRing B] [inst_1 : Group G] [inst_2 : MulSemiringAction G B] (Q R : Ideal B)
(motive : R ∈ MulAction.orbit G Q → Prop) (x : R ∈ MulAction.orbit G Q),
(∀ (g : G) (hg : (fun m => m • Q) g = R), motive ⋯) → motive x | null | false |
CategoryTheory.Discrete.eqToIso'.eq_1 | Mathlib.CategoryTheory.Discrete.Basic | ∀ {α : Type u₁} {a b : α} (h : a = b), CategoryTheory.Discrete.eqToIso' h = CategoryTheory.Discrete.eqToIso h | null | true |
HasFDerivAtFilter.finCons | Mathlib.Analysis.Calculus.FDeriv.Prod | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {n : ℕ} {F' : Fin n.succ → Type u_6}
[inst_3 : (i : Fin n.succ) → NormedAddCommGroup (F' i)] [inst_4 : (i : Fin n.succ) → NormedSpace 𝕜 (F' i)]
{φ : E → F' 0} {φs : E → (i : Fin n) → F... | null | true |
_private.Lean.Parser.Command.0.Lean.Parser.Command.evalBang._regBuiltin.Lean.Parser.Command.evalBang.parenthesizer_9 | Lean.Parser.Command | IO Unit | null | false |
_private.Lean.Server.FileWorker.SignatureHelp.0.Lean.Server.FileWorker.SignatureHelp.findSignatureHelp?.match_1 | Lean.Server.FileWorker.SignatureHelp | (motive : Option Lean.Syntax.Range → Sort u_1) →
(x : Option Lean.Syntax.Range) →
((range : Lean.Syntax.Range) → motive (some range)) → ((x : Option Lean.Syntax.Range) → motive x) → motive x | null | false |
SSet.spine_vertex | Mathlib.AlgebraicTopology.SimplicialSet.Path | ∀ (X : SSet) (n : ℕ) (Δ : X.obj (Opposite.op { len := n })) (i : Fin (n + 1)),
(X.spine n Δ).vertex i = (CategoryTheory.ConcreteCategory.hom (X.map ({ len := 0 }.const { len := n } i).op)) Δ | null | true |
Lean.MetavarContext.lmvarCounter._default | Lean.MetavarContext | ℕ | null | false |
AlgebraicGeometry.Scheme.IdealSheafData.mkOfMemSupportIff | Mathlib.AlgebraicGeometry.IdealSheaf.Basic | {X : AlgebraicGeometry.Scheme} →
(ideal : (U : ↑X.affineOpens) → Ideal ↑(X.presheaf.obj (Opposite.op ↑U))) →
(∀ (U : ↑X.affineOpens) (f : ↑(X.presheaf.obj (Opposite.op ↑U))),
Ideal.map (CommRingCat.Hom.hom (X.presheaf.map (CategoryTheory.homOfLE ⋯).op)) (ideal U) =
ideal (X.affineBasicOpen f)) →... | A useful constructor of `IdealSheafData`
with the condition on `supportSet` being easier to check. | true |
IsPrecomplete.rec | Mathlib.RingTheory.AdicCompletion.Basic | {R : Type u_1} →
[inst : CommRing R] →
{I : Ideal R} →
{M : Type u_4} →
[inst_1 : AddCommGroup M] →
[inst_2 : Module R M] →
{motive : IsPrecomplete I M → Sort u} →
((prec' :
∀ (f : ℕ → M),
(∀ {m n : ℕ}, m ≤ n → f m ≡ f n [... | null | false |
MeasureTheory.setLIntegral_subtype | Mathlib.MeasureTheory.Integral.Lebesgue.Map | ∀ {α : Type u_1} [inst : MeasurableSpace α] {μ : MeasureTheory.Measure α} {s : Set α},
MeasurableSet s →
∀ (t : Set ↑s) (f : α → ENNReal),
∫⁻ (x : ↑s) in t, f ↑x ∂MeasureTheory.Measure.comap Subtype.val μ = ∫⁻ (x : α) in Subtype.val '' t, f x ∂μ | null | true |
Equiv.Perm.isSolvable | Mathlib.GroupTheory.SpecificGroups.Alternating.Simple | ∀ {α : Type u_1} [Finite α], Nat.card α ≤ 4 → Group.IsSolvable (Equiv.Perm α) | null | true |
HomologicalComplex.doubleXIso₁._proof_1 | Mathlib.Algebra.Homology.Double | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
[inst_2 : CategoryTheory.Limits.HasZeroObject C] {X₀ X₁ : C} (f : X₀ ⟶ X₁) {ι : Type u_3} {c : ComplexShape ι}
{i₀ i₁ : ι} (hi₀₁ : c.Rel i₀ i₁), i₀ ≠ i₁ → (HomologicalComplex.double f hi₀₁).X i₁ = X₁ | null | false |
SimpleGraph.IsBridge.notMem_edges_of_isCycle | Mathlib.Combinatorics.SimpleGraph.Connectivity.Connected | ∀ {V : Type u} {G : SimpleGraph V} {e : Sym2 V} {u : V} {p : G.Walk u u}, G.IsBridge e → p.IsCycle → e ∉ p.edges | null | true |
MeasureTheory.IsAddFundamentalDomain.setLIntegral_eq_tsum' | Mathlib.MeasureTheory.Group.FundamentalDomain | ∀ {G : Type u_1} {α : Type u_3} [inst : AddGroup G] [inst_1 : AddAction G α] [inst_2 : MeasurableSpace α] {s : Set α}
{μ : MeasureTheory.Measure α} [MeasurableConstVAdd G α] [MeasureTheory.VAddInvariantMeasure G α μ] [Countable G],
MeasureTheory.IsAddFundamentalDomain G s μ →
∀ (f : α → ENNReal) (t : Set α), ∫⁻... | null | true |
pseudoEMetricSpacePi._proof_1 | Mathlib.Topology.EMetricSpace.Pi | ∀ {β : Type u_1} {X : β → Type u_2} [inst : Fintype β] [inst_1 : (b : β) → PseudoEMetricSpace (X b)]
(f : (b : β) → X b), ∀ b ∈ Finset.univ, edist (f b) (f b) ≤ ⊥ | null | false |
_private.Batteries.Util.ProofWanted.0.WantedCmdKind.noConfusion | Batteries.Util.ProofWanted | {P : Sort u} → {t t' : WantedCmdKind✝} → t = t' → WantedCmdKind.noConfusionType✝ P t t' | null | false |
conj_zpow | Mathlib.Algebra.Group.Conj | ∀ {α : Type u} [inst : Group α] {i : ℤ} {a b : α}, (a * b * a⁻¹) ^ i = a * b ^ i * a⁻¹ | null | true |
Nat.cast_le_pow_sub_div_sub | Mathlib.Algebra.Order.Field.Power | ∀ {α : Type u_1} [inst : Field α] [inst_1 : LinearOrder α] [IsStrictOrderedRing α] {a : α},
1 < a → ∀ (n : ℕ), ↑n ≤ (a ^ n - 1) / (a - 1) | Bernoulli's inequality reformulated to estimate `(n : α)`. | true |
WType.Listα.cons.noConfusion | Mathlib.Data.W.Constructions | {γ : Type u} → {P : Sort u_1} → {a a' : γ} → WType.Listα.cons a = WType.Listα.cons a' → (a ≍ a' → P) → P | null | false |
SchwartzMap.norm_fourier_Lp_top_leq_toLp_one | Mathlib.Analysis.Distribution.SchwartzSpace.Fourier | ∀ {V : Type u_3} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V] [inst_2 : FiniteDimensional ℝ V]
[inst_3 : MeasurableSpace V] [inst_4 : BorelSpace V] {F : Type u_4} [inst_5 : NormedAddCommGroup F]
[inst_6 : NormedSpace ℂ F] (f : SchwartzMap V F),
‖(FourierTransform.fourier f).toLp ⊤ MeasureTheory.... | null | true |
MeasureTheory.VectorMeasure.«_aux_Mathlib_MeasureTheory_VectorMeasure_Integral___delab_app_MeasureTheory_VectorMeasure_term∫ᵛ_,_∂•__1» | Mathlib.MeasureTheory.VectorMeasure.Integral | Lean.PrettyPrinter.Delaborator.Delab | Pretty printer defined by `notation3` command. | false |
_private.Lean.Environment.0.Lean.EnvExtension.modifyState.match_14 | Lean.Environment | (motive : Lean.EnvExtension.AsyncMode → Sort u_1) →
(asyncMode : Lean.EnvExtension.AsyncMode) →
(Unit → motive Lean.EnvExtension.AsyncMode.mainOnly) →
(Unit → motive Lean.EnvExtension.AsyncMode.local) →
((x : Lean.EnvExtension.AsyncMode) → motive x) → motive asyncMode | null | false |
SubMulAction.instSMulSubtypeMem.eq_1 | Mathlib.GroupTheory.GroupAction.SubMulAction | ∀ {R : Type u} {M : Type v} [inst : SMul R M] (p : SubMulAction R M),
p.instSMulSubtypeMem = { smul := fun c x => ⟨c • ↑x, ⋯⟩ } | null | true |
derivationToSquareZeroOfLift._proof_5 | Mathlib.RingTheory.Derivation.ToSquareZero | ∀ {R : Type u_3} {A : Type u_2} {B : Type u_1} [inst : CommSemiring R] [inst_1 : CommSemiring A] [inst_2 : CommRing B]
[inst_3 : Algebra R A] [inst_4 : Algebra R B] (I : Ideal B) [inst_5 : Algebra A B] [inst_6 : IsScalarTower R A B],
I ^ 2 = ⊥ →
∀ (f : A →ₐ[R] B) (e : (Ideal.Quotient.mkₐ R I).comp f = IsScalarT... | null | false |
ImportGraph.Shake.Bitset.instDecidableRelSubset | ImportGraph.Shake.Basic | DecidableRel Subset | null | true |
AddUnits.neg_val | Mathlib.Algebra.Group.Units.Defs | ∀ {α : Type u} [inst : AddMonoid α] (self : AddUnits α), self.neg + ↑self = 0 | `neg` is the left additive inverse of `val` in the base `AddMonoid`. | true |
USize.shiftLeft_zero | Init.Data.UInt.Bitwise | ∀ {a : USize}, a <<< 0 = a | null | true |
CategoryTheory.Grp.mkIso._auto_3 | Mathlib.CategoryTheory.Monoidal.Grp | Lean.Syntax | null | false |
CategoryTheory.Functor.PullbackObjObj.mk.injEq | Mathlib.CategoryTheory.Limits.Shapes.Pullback.PullbackObjObj | ∀ {C₁ : Type u₁} {C₂ : Type u₂} {C₃ : Type u₃} [inst : CategoryTheory.Category.{v₁, u₁} C₁]
[inst_1 : CategoryTheory.Category.{v₂, u₂} C₂] [inst_2 : CategoryTheory.Category.{v₃, u₃} C₃]
{G : CategoryTheory.Functor C₁ᵒᵖ (CategoryTheory.Functor C₃ C₂)} {X₁ Y₁ : C₁} {f₁ : X₁ ⟶ Y₁} {X₃ Y₃ : C₃}
{f₃ : X₃ ⟶ Y₃} (pt : C... | null | true |
IsOrderedMonoid.mk._flat_ctor | Mathlib.Algebra.Order.Monoid.Defs | ∀ {α : Type u_2} [inst : CommMonoid α] [inst_1 : Preorder α],
(∀ (a b : α), a ≤ b → ∀ (c : α), a * c ≤ b * c) → (∀ (a b : α), a ≤ b → ∀ (c : α), c * a ≤ c * b) → IsOrderedMonoid α | null | false |
Matrix.instLieRingToLieAlgebra._proof_29 | Mathlib.Algebra.Lie.SerreConstruction | ∀ (R : Type u_1) {B : Type u_2} [inst : CommRing R] (CM : Matrix B B ℤ) [inst_1 : DecidableEq B]
(x y z : Matrix.ToLieAlgebra R CM), ⁅x, ⁅y, z⁆⁆ = ⁅⁅x, y⁆, z⁆ + ⁅y, ⁅x, z⁆⁆ | null | false |
MeasureTheory.SimpleFunc.coe_neg._simp_1 | Mathlib.MeasureTheory.Function.SimpleFunc | ∀ {α : Type u_1} {β : Type u_2} [inst : MeasurableSpace α] [inst_1 : Neg β] (f : MeasureTheory.SimpleFunc α β),
-⇑f = ⇑(-f) | null | false |
AddSubmonoid.map_equiv_eq_comap_symm | Mathlib.Algebra.Group.Submonoid.Operations | ∀ {N : Type u_2} [inst : AddZeroClass N] {M : Type u_5} [inst_1 : AddZeroClass M] (f : M ≃+ N) (K : AddSubmonoid M),
AddSubmonoid.map f K = AddSubmonoid.comap f.symm K | null | true |
PartOrdEmb.hom_id | Mathlib.Order.Category.PartOrdEmb | ∀ {X : PartOrdEmb}, PartOrdEmb.Hom.hom (CategoryTheory.CategoryStruct.id X) = RelEmbedding.refl fun x1 x2 => x1 ≤ x2 | null | true |
_private.Lean.Meta.Tactic.Grind.Intro.0.Lean.Meta.Grind.isAlreadyNorm? | Lean.Meta.Tactic.Grind.Intro | Lean.Expr → Option Lean.Expr | Returns `true` if `e` is marked with the `alreadyNorm` gadget.
See `alreadyNorm` documentation for additional details
| true |
Lex.instDivisionRing._proof_15 | Mathlib.Algebra.Field.Basic | ∀ {K : Type u_1} [inst : DivisionRing K],
autoParam (∀ (a : ℚ) (x : Lex K), Lex.instDivisionRing._aux_13 a x = ↑a * x) DivisionRing.qsmul_def._autoParam | null | false |
_private.Mathlib.Topology.Compactness.LocallyCompact.0.Topology.IsClosedEmbedding.weaklyLocallyCompactSpace.match_1_1 | Mathlib.Topology.Compactness.LocallyCompact | ∀ {X : Type u_2} {Y : Type u_1} [inst : TopologicalSpace Y] {f : X → Y} (x : X)
(motive : (∃ s, IsCompact s ∧ s ∈ nhds (f x)) → Prop) (x_1 : ∃ s, IsCompact s ∧ s ∈ nhds (f x)),
(∀ (K : Set Y) (hK : IsCompact K) (hKx : K ∈ nhds (f x)), motive ⋯) → motive x_1 | null | false |
_private.Mathlib.Computability.RegularExpressions.0.RegularExpression.matches'.match_1.eq_1 | Mathlib.Computability.RegularExpressions | ∀ {α : Type u_1} (motive : RegularExpression α → Sort u_2) (h_1 : Unit → motive RegularExpression.zero)
(h_2 : Unit → motive RegularExpression.epsilon) (h_3 : (a : α) → motive (RegularExpression.char a))
(h_4 : (P Q : RegularExpression α) → motive (P.plus Q)) (h_5 : (P Q : RegularExpression α) → motive (P.comp Q))
... | null | true |
_private.Lean.Util.Trace.0.Lean.printTraces.match_1 | Lean.Util.Trace | (motive : Lean.TraceElem → Sort u_1) →
(x : Lean.TraceElem) → ((ref : Lean.Syntax) → (msg : Lean.MessageData) → motive { ref := ref, msg := msg }) → motive x | null | false |
WithBot.isGLB_sInf' | Mathlib.Order.ConditionallyCompleteLattice.Basic | ∀ {β : Type u_5} [inst : ConditionallyCompleteLattice β] {s : Set (WithBot β)}, s.Nonempty → IsGLB s (sInf s) | null | true |
Nat.modCore_lt | Init.Prelude | ∀ {x y : ℕ}, 0 < y → x.modCore y < y | null | true |
CochainComplex.shortComplexTruncLEX₃ToTruncGE._auto_1 | Mathlib.Algebra.Homology.Embedding.CochainComplex | Lean.Syntax | null | false |
DividedPowers.OfInvertibleFactorial.dpow_eq_of_notMem | Mathlib.RingTheory.DividedPowers.RatAlgebra | ∀ {A : Type u_1} [inst : CommSemiring A] {I : Ideal A} [inst_1 : DecidablePred fun x => x ∈ I] {m : ℕ} {x : A},
x ∉ I → DividedPowers.OfInvertibleFactorial.dpow I m x = 0 | null | true |
Fin2.insertPerm | Mathlib.Data.Fin.Fin2 | {n : ℕ} → Fin2 n → Fin2 n → Fin2 n | `insertPerm a` is a permutation of `Fin2 n` with the following properties:
* `insertPerm a i = i+1` if `i < a`
* `insertPerm a a = 0`
* `insertPerm a i = i` if `i > a` | true |
IntervalIntegrable.sub | Mathlib.MeasureTheory.Integral.IntervalIntegral.Basic | ∀ {E : Type u_5} [inst : NormedAddCommGroup E] {a b : ℝ} {μ : MeasureTheory.Measure ℝ} {f g : ℝ → E},
IntervalIntegrable f μ a b → IntervalIntegrable g μ a b → IntervalIntegrable (fun x => f x - g x) μ a b | null | true |
ProofWidgets.InteractiveExprProps._sizeOf_1 | ProofWidgets.Component.Basic | ProofWidgets.InteractiveExprProps → ℕ | null | false |
CategoryTheory.MorphismProperty.instIsStableUnderBaseChangeFunctorFunctorCategoryOfHasPullbacks | Mathlib.CategoryTheory.MorphismProperty.FunctorCategory | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {W : CategoryTheory.MorphismProperty C}
[W.IsStableUnderBaseChange] (J : Type u'') [inst_2 : CategoryTheory.Category.{v'', u''} J]
[CategoryTheory.Limits.HasPullbacks C], (W.functorCategory J).IsStableUnderBaseChange | null | true |
Lean.Lsp.instToJsonMarkupKind | Lean.Data.Lsp.Basic | Lean.ToJson Lean.Lsp.MarkupKind | null | true |
CategoryTheory.Sheaf.locallySurjective | Mathlib.CategoryTheory.Sites.EpiMono | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
(J : CategoryTheory.GrothendieckTopology C) →
(A : Type u') →
[inst_1 : CategoryTheory.Category.{v', u'} A] →
{FA : A → A → Type u_1} →
{CA : A → Type w} →
[inst_2 : (X Y : A) → FunLike (FA X Y) (CA X) (CA... | The class of locally surjective morphisms of sheaves, see `Sheaf.IsLocallySurjective`. | true |
CategoryTheory.Bicategory.LeftLift.whisker_unit | Mathlib.CategoryTheory.Bicategory.Extension | ∀ {B : Type u} [inst : CategoryTheory.Bicategory B] {a b c : B} {f : b ⟶ a} {g : c ⟶ a}
(t : CategoryTheory.Bicategory.LeftLift f g) {x : B} (h : x ⟶ c),
(t.whisker h).unit =
CategoryTheory.CategoryStruct.comp (CategoryTheory.Bicategory.whiskerLeft h t.unit)
(CategoryTheory.Bicategory.associator h t.lift ... | null | true |
CategoryTheory.FreeBicategory.Rel.below.triangle | Mathlib.CategoryTheory.Bicategory.Free | ∀ {B : Type u} [inst : Quiver B]
{motive :
{a b : CategoryTheory.FreeBicategory B} →
{f g : a ⟶ b} →
(a_1 a_2 : CategoryTheory.FreeBicategory.Hom₂ f g) → CategoryTheory.FreeBicategory.Rel a_1 a_2 → Prop}
{a b c : B} (f : CategoryTheory.FreeBicategory.Hom a b) (g : CategoryTheory.FreeBicategory.Hom... | null | true |
Rep.hom_whiskerRight | Mathlib.RepresentationTheory.Rep.Basic | ∀ {k : Type u} {G : Type v} [inst : CommRing k] [inst_1 : Monoid G] {X₁ X₂ Y : Rep.{u, u, v} k G} (f : X₁ ⟶ X₂),
Rep.Hom.hom (CategoryTheory.MonoidalCategoryStruct.whiskerRight f Y) =
Representation.IntertwiningMap.rTensor Y.ρ (Rep.Hom.hom f) | null | true |
Lean.Meta.Grind.Arith.Cutsat.UnsatProof.noConfusion | Lean.Meta.Tactic.Grind.Arith.Cutsat.Types | {P : Sort u} →
{t t' : Lean.Meta.Grind.Arith.Cutsat.UnsatProof} →
t = t' → Lean.Meta.Grind.Arith.Cutsat.UnsatProof.noConfusionType P t t' | null | false |
IsRightCancelMul.mulRightReflectLE_of_mulRightReflectLT | Mathlib.Algebra.Order.Monoid.Unbundled.Defs | ∀ (N : Type u_2) [inst : Mul N] [IsRightCancelMul N] [inst_2 : PartialOrder N] [MulRightReflectLT N],
MulRightReflectLE N | null | true |
_private.Mathlib.Topology.Algebra.Valued.LocallyCompact.0.Valuation.isNontrivial_iff_not_a_field._simp_1_4 | Mathlib.Topology.Algebra.Valued.LocallyCompact | ∀ {α : Sort u_1} {p : α → Prop}, (¬∀ (x : α), p x) = ∃ x, ¬p x | null | false |
CategoryTheory.ShortComplex.RightHomologyData.ofEpiOfIsIsoOfMono._proof_3 | Mathlib.Algebra.Homology.ShortComplex.RightHomology | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{S₁ S₂ : CategoryTheory.ShortComplex C} (φ : S₁ ⟶ S₂) [CategoryTheory.Epi φ.τ₁],
CategoryTheory.Mono (CategoryTheory.ShortComplex.opMap φ).τ₃ | null | false |
_private.Mathlib.ModelTheory.Types.0.FirstOrder.Language.Theory.CompleteType.iInter_setOfPred_subset._simp_1_1 | Mathlib.ModelTheory.Types | ∀ {α : Type u} {ι : Sort v} {x : α} {s : ι → Set α}, (x ∈ ⋂ i, s i) = ∀ (i : ι), x ∈ s i | null | false |
PFunctor.M.Agree'.below.casesOn | Mathlib.Data.PFunctor.Univariate.M | ∀ {F : PFunctor.{uA, uB}} {motive : (a : ℕ) → (a_1 a_2 : F.M) → PFunctor.M.Agree' a a_1 a_2 → Prop}
{motive_1 : {a : ℕ} → {a_1 a_2 : F.M} → (t : PFunctor.M.Agree' a a_1 a_2) → PFunctor.M.Agree'.below t → Prop} {a : ℕ}
{a_1 a_2 : F.M} {t : PFunctor.M.Agree' a a_1 a_2} (t_1 : PFunctor.M.Agree'.below t),
(∀ (x y : F... | null | false |
AffineSubspace.parallel_bot_iff_eq_bot._simp_1 | Mathlib.LinearAlgebra.AffineSpace.AffineSubspace.Basic | ∀ {k : Type u_1} {V : Type u_2} {P : Type u_4} [inst : Ring k] [inst_1 : AddCommGroup V] [inst_2 : Module k V]
[inst_3 : AddTorsor V P] {s : AffineSubspace k P}, s.Parallel ⊥ = (s = ⊥) | null | false |
AddGroupSeminorm.instAddCommMonoid | Mathlib.Analysis.Normed.Group.Seminorm | {E : Type u_3} → [inst : AddGroup E] → AddCommMonoid (AddGroupSeminorm E) | null | true |
CategoryTheory.PreGaloisCategory.functorToAction_comp_forget₂_eq | Mathlib.CategoryTheory.Galois.Action | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] (F : CategoryTheory.Functor C FintypeCat),
(CategoryTheory.PreGaloisCategory.functorToAction F).comp
(CategoryTheory.forget₂ (Action FintypeCat (CategoryTheory.Aut F)) FintypeCat) =
F | null | true |
GradedRing.mem_support_iff | Mathlib.RingTheory.GradedAlgebra.Basic | ∀ {ι : Type u_1} {A : Type u_3} {σ : Type u_4} [inst : DecidableEq ι] [inst_1 : AddMonoid ι] [inst_2 : Semiring A]
[inst_3 : SetLike σ A] [inst_4 : AddSubmonoidClass σ A] (𝒜 : ι → σ) [inst_5 : GradedRing 𝒜]
[inst_6 : (i : ι) → (x : ↥(𝒜 i)) → Decidable (x ≠ 0)] (r : A) (i : ι),
i ∈ DFinsupp.support ((DirectSum.... | null | true |
Std.TransCmp.isLE_trans | Init.Data.Order.Ord | ∀ {α : Type u} {cmp : α → α → Ordering} [self : Std.TransCmp cmp] {a b c : α},
(cmp a b).isLE = true → (cmp b c).isLE = true → (cmp a c).isLE = true | Transitivity of `cmp`, expressed via `Ordering.isLE`. | true |
MonadSatisfying.instEStateM._proof_4 | Batteries.Recycling.MonadSatisfying.Basic | ∀ {ε σ α : Type u_1} {p : α → Prop} {x : EStateM ε σ α} (h : SatisfiesM p x),
(Subtype.val <$>
have h' := ⋯;
fun s =>
match w : x.run s with
| EStateM.Result.ok a s' => EStateM.Result.ok ⟨a, ⋯⟩ s'
| EStateM.Result.error e s' => EStateM.Result.error e s') =
x | null | false |
coverPreserving_opens_map | Mathlib.Topology.Sheaves.SheafCondition.Sites | ∀ {X Y : TopCat} (f : X ⟶ Y),
CategoryTheory.CoverPreserving (Opens.grothendieckTopology ↑Y) (Opens.grothendieckTopology ↑X)
(TopologicalSpace.Opens.map f) | null | true |
Algebra.TensorProduct.toLinearMap_includeLeft | Mathlib.RingTheory.TensorProduct.Basic | ∀ {R : Type uR} {S : Type uS} {A : Type uA} {B : Type uB} [inst : CommSemiring R] [inst_1 : Semiring A]
[inst_2 : Algebra R A] [inst_3 : Semiring B] [inst_4 : Algebra R B] [inst_5 : CommSemiring S] [inst_6 : Algebra S A]
[inst_7 : SMulCommClass R S A],
Algebra.TensorProduct.includeLeft.toLinearMap = (TensorProduc... | null | true |
SkewMonoidAlgebra.ofCoeff_injective | Mathlib.Algebra.SkewMonoidAlgebra.Basic | ∀ {k : Type u_1} {G : Type u_2} [inst : AddMonoid k], Function.Injective SkewMonoidAlgebra.ofCoeff | null | true |
DiffeologicalSpace.CorePlotsOn.mk.sizeOf_spec | Mathlib.Geometry.Diffeology.Basic | ∀ {X : Type u_1} [inst : SizeOf X]
(isPlotOn : {n : ℕ} → {u : Set (EuclideanSpace ℝ (Fin n))} → IsOpen u → (EuclideanSpace ℝ (Fin n) → X) → Prop)
(isPlotOn_congr :
∀ {n : ℕ} {u : Set (EuclideanSpace ℝ (Fin n))} (hu : IsOpen u) {p q : EuclideanSpace ℝ (Fin n) → X},
Set.EqOn p q u → (isPlotOn hu p ↔ isPlotO... | null | true |
Lean.Meta.PProdN.reduceProjs | Lean.Meta.PProdN | Lean.Expr → Lean.MetaM Lean.Expr | Reduces `⟨x,y⟩.1` or `⟨x,y⟩.fst` redexes for `PProd` and `And`
| true |
nsmul_iterate | Mathlib.Algebra.Group.Basic | ∀ {M : Type u_4} [inst : AddMonoid M] (k n : ℕ), (fun x => k • x)^[n] = fun x => k ^ n • x | null | true |
CategoryTheory.EnrichedFunctor.hom_ext | Mathlib.CategoryTheory.Enriched.Basic | ∀ {V : Type v} [inst : CategoryTheory.Category.{w, v} V] [inst_1 : CategoryTheory.MonoidalCategory V] {C : Type u₁}
[inst_2 : CategoryTheory.EnrichedCategory V C] {D : Type u₂} [inst_3 : CategoryTheory.EnrichedCategory V D]
{F G : CategoryTheory.EnrichedFunctor V C D} {α β : F ⟶ G}, (∀ (X : C), α.out.app X = β.out.... | null | true |
RatFunc.CompletionAtInfty.instField._aux_66 | Mathlib.FieldTheory.RatFunc.Valuation | (F : Type u_1) →
[inst : Field F] →
[inst_1 : DecidableEq (RatFunc F)] → ℚ≥0 → RatFunc.CompletionAtInfty F → RatFunc.CompletionAtInfty F | null | false |
_private.Mathlib.NumberTheory.TsumDivisorsAntidiagonal.0.tsum_pow_div_one_sub_eq_tsum_sigma._simp_1_1 | Mathlib.NumberTheory.TsumDivisorsAntidiagonal | ∀ {ι : Type u_1} {α : Type u_3} {L : SummationFilter ι} [inst : DivisionSemiring α] [inst_1 : TopologicalSpace α]
[IsTopologicalSemiring α] {f : ι → α} {a : α} [T2Space α], a * ∑'[L] (x : ι), f x = ∑'[L] (x : ι), a * f x | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.