name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
Polynomial.instGroupGal._proof_5 | Mathlib.FieldTheory.PolynomialGaloisGroup | ∀ {F : Type u_1} [inst : Field F] (p : Polynomial F) (a b c : p.Gal), a * b * c = a * (b * c) | null | false |
AdicCompletion.liftAlgHom._proof_2 | Mathlib.RingTheory.AdicCompletion.Algebra | ∀ {S : Type u_1} [inst : CommRing S] (I : Ideal S) {m : ℕ}, (I ^ m).IsTwoSided | null | false |
CategoryTheory.createsColimitOfFullyFaithfulOfLift' | Mathlib.CategoryTheory.Limits.Creates | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{D : Type u₂} →
[inst_1 : CategoryTheory.Category.{v₂, u₂} D] →
{J : Type w} →
[inst_2 : CategoryTheory.Category.{w', w} J] →
{K : CategoryTheory.Functor J C} →
{F : CategoryTheory.Functor C D} →
... | When `F` is fully faithful, to show that `F` creates the colimit for `K` it suffices to exhibit a
lift of a colimit cocone for `K ⋙ F`.
| true |
Con.commMagma | Mathlib.GroupTheory.Congruence.Defs | {M : Type u_4} → [inst : CommMagma M] → (c : Con M) → CommMagma c.Quotient | The quotient of a commutative magma by a congruence relation is a commutative magma. | true |
finRotate_symm_apply | Mathlib.Logic.Equiv.Fin.Rotate | ∀ {n : ℕ} (i : Fin n), (Equiv.symm (finRotate n)) i = i - 1 | null | true |
_private.Init.Data.List.MapIdx.0.List.mapFinIdx._proof_1 | Init.Data.List.MapIdx | ∀ {α : Type u_1} {β : Type u_2} (as as_1 : List α) (acc : Array β),
as_1.length + 1 + acc.size = as.length → ¬acc.size < as.length → False | null | false |
_private.Mathlib.Topology.EMetricSpace.Diam.0.Metric.ediam_pos_iff'._simp_1_1 | Mathlib.Topology.EMetricSpace.Diam | ∀ {X : Type u_2} {s : Set X} [inst : TopologicalSpace X] [inst_1 : WeakEMetricSpace X],
(0 < Metric.ediam s) = s.Nontrivial | null | false |
_private.Std.Sat.AIG.CNF.0.Std.Sat.AIG.toCNF.go._unary._proof_73 | Std.Sat.AIG.CNF | ∀ (aig : Std.Sat.AIG ℕ),
∀ upper < aig.decls.size,
∀ (lhs rhs : Std.Sat.AIG.Fanin), lhs.gate < upper ∧ rhs.gate < upper → lhs.gate < aig.decls.size | null | false |
instNSMulUniformFun._aux_1 | Mathlib.Topology.Algebra.UniformConvergence | {α : Type u_1} → {β : Type u_2} → {M : Type u_3} → [SMul M β] → UniformFun α β → M → UniformFun α β | null | false |
measurableSet_preimage_up._simp_1 | Mathlib.MeasureTheory.MeasurableSpace.Constructions | ∀ {α : Type u_1} [inst : MeasurableSpace α] {s : Set (ULift.{u_6, u_1} α)},
MeasurableSet (ULift.up ⁻¹' s) = MeasurableSet s | null | false |
MeasureTheory.lintegral_eq_iff_ae_eq_of_ae_le | Mathlib.MeasureTheory.Integral.Lebesgue.Markov | ∀ {α : Type u_1} {mα : MeasurableSpace α} {μ : MeasureTheory.Measure α} {f g : α → ENNReal},
∫⁻ (x : α), f x ∂μ ≠ ⊤ → AEMeasurable g μ → f ≤ᵐ[μ] g → (∫⁻ (x : α), f x ∂μ = ∫⁻ (x : α), g x ∂μ ↔ f =ᵐ[μ] g) | null | true |
LinearPMap.comp | Mathlib.LinearAlgebra.LinearPMap | {R : Type u_1} →
{S : Type u_2} →
{T : Type u_3} →
[inst : Ring R] →
[inst_1 : Ring S] →
[inst_2 : Ring T] →
{σ : R →+* S} →
{τ : S →+* T} →
{E : Type u_4} →
[inst_3 : AddCommGroup E] →
[inst_4 : Module R E] →
... | Compose two `LinearPMap`s | true |
_private.Mathlib.RingTheory.Polynomial.Basic.0.Ideal.isPrime_map_C_iff_isPrime._simp_1_4 | Mathlib.RingTheory.Polynomial.Basic | ∀ {α : Type u_1} {β : Type u_2} {a₁ a₂ : α} {b₁ b₂ : β}, ((a₁, b₁) = (a₂, b₂)) = (a₁ = a₂ ∧ b₁ = b₂) | null | false |
AddMonoidHom.coe_snd | Mathlib.Algebra.Group.Prod | ∀ {M : Type u_3} {N : Type u_4} [inst : AddZeroClass M] [inst_1 : AddZeroClass N], ⇑(AddMonoidHom.snd M N) = Prod.snd | null | true |
Lean.Meta.Sym.Arith.State.mk.inj | Lean.Meta.Sym.Arith.Types | ∀ {exp : ℕ} {rings : Array Lean.Meta.Sym.Arith.CommRing} {semirings : Array Lean.Meta.Sym.Arith.CommSemiring}
{ncRings : Array Lean.Meta.Sym.Arith.Ring} {ncSemirings : Array Lean.Meta.Sym.Arith.Semiring}
{typeClassify : Lean.PHashMap Lean.Meta.Sym.ExprPtr Lean.Meta.Sym.Arith.ClassifyResult} {exp_1 : ℕ}
{rings_1 :... | null | true |
_private.Mathlib.Combinatorics.Enumerative.Catalan.Tree.0.BinaryTree.treesOfNumNodesEq_card_eq_catalan._simp_1_1 | Mathlib.Combinatorics.Enumerative.Catalan.Tree | ∀ {α : Type u_2} {s t : Finset α}, Disjoint s t = ∀ ⦃a : α⦄, a ∈ s → a ∉ t | null | false |
KaehlerDifferential.mulActionBaseChange._proof_1 | Mathlib.RingTheory.Kaehler.TensorProduct | ∀ (R : Type u_1) (A : Type u_2) [inst : CommRing R] [inst_1 : CommRing A] [inst_2 : Algebra R A], SMulCommClass R R A | null | false |
MvQPF.wSetoid | Mathlib.Data.QPF.Multivariate.Constructions.Fix | {n : ℕ} → {F : TypeVec.{u} (n + 1) → Type u} → [q : MvQPF F] → (α : TypeVec.{u} n) → Setoid ((MvQPF.P F).W α) | Define the fixed point as the quotient of trees under the equivalence relation.
| true |
Lean.Elab.Term.LetIdDeclView._sizeOf_inst | Lean.Elab.Binders | SizeOf Lean.Elab.Term.LetIdDeclView | null | false |
ProbabilityTheory.condCDF_le_one | Mathlib.Probability.Kernel.Disintegration.CondCDF | ∀ {α : Type u_1} {mα : MeasurableSpace α} (ρ : MeasureTheory.Measure (α × ℝ)) (a : α) (x : ℝ),
↑(ProbabilityTheory.condCDF ρ a) x ≤ 1 | The conditional cdf is lower or equal to 1 for all `a : α`. | true |
CategoryTheory.Monad.beckAlgebraCofork_pt | Mathlib.CategoryTheory.Monad.Coequalizer | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {T : CategoryTheory.Monad C} (X : T.Algebra),
(CategoryTheory.Monad.beckAlgebraCofork X).pt = X | null | true |
LinearMap.piApply._proof_4 | Mathlib.Algebra.Module.Equiv.Basic | ∀ {R : Type u_1} {M : Type u_2} [inst : CommSemiring R], SMulCommClass R R (M → R) | null | false |
_private.Mathlib.FieldTheory.Normal.Defs.0.AlgEquiv.restrictNormal_eq_one_iff._simp_1_2 | Mathlib.FieldTheory.Normal.Defs | ∀ {α : Sort u} {p : α → Prop} {a1 a2 : { x // p x }}, (a1 = a2) = (↑a1 = ↑a2) | null | false |
Lean.NameMapExtension | Batteries.Lean.NameMapAttribute | Type → Type | Environment extension that maps declaration names to `α`.
This uses a `Thunk` to avoid computing the name map when it isn't used. | true |
eqOn_of_cfcₙ_eq_cfcₙ._auto_7 | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.NonUnital | Lean.Syntax | null | false |
AlgebraicGeometry.spread_out_unique_of_isGermInjective | Mathlib.AlgebraicGeometry.SpreadingOut | ∀ {X Y : AlgebraicGeometry.Scheme} {x : ↥X} [X.IsGermInjectiveAt x] (f g : X ⟶ Y) (e : f x = g x),
AlgebraicGeometry.Scheme.Hom.stalkMap f x =
CategoryTheory.CategoryStruct.comp (Y.presheaf.stalkSpecializes ⋯) (AlgebraicGeometry.Scheme.Hom.stalkMap g x) →
∃ U, x ∈ U ∧ CategoryTheory.CategoryStruct.comp U.ι ... | Let `x : X` and `f g : X ⟶ Y` be two morphisms such that `f x = g x`.
If `f` and `g` agree on the stalk of `x`, then they agree on an open neighborhood of `x`,
provided `X` is "germ-injective" at `x` (e.g. when it's integral or locally Noetherian).
TODO: The condition on `X` is unnecessary when `Y` is locally of finit... | true |
_private.Mathlib.Probability.Kernel.Disintegration.Density.0.ProbabilityTheory.Kernel.tendsto_density_fst_atTop_ae_of_monotone._simp_1_1 | Mathlib.Probability.Kernel.Disintegration.Density | ∀ {α : Type u} (x : α), (x ∈ Set.univ) = True | null | false |
Lean.Linter.CodeQuality.Source.module | Lean.Linter.CodeQuality.Basic | Lean.Name → Lean.Linter.CodeQuality.Source | null | true |
_private.Aesop.Rule.0.Aesop.instBEqRegularRule.beq._sparseCasesOn_2 | Aesop.Rule | {motive : Aesop.RegularRule → Sort u} →
(t : Aesop.RegularRule) →
((r : Aesop.UnsafeRule) → motive (Aesop.RegularRule.unsafe r)) → (Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t | null | false |
_private.Mathlib.Analysis.Asymptotics.Completion.0.«term_̂» | Mathlib.Analysis.Asymptotics.Completion | Lean.TrailingParserDescr | null | true |
_private.Mathlib.Topology.Sequences.0.FrechetUrysohnSpace.of_seq_tendsto_imp_tendsto._simp_1_6 | Mathlib.Topology.Sequences | ∀ {α : Sort u_1} {p : α → Prop}, (¬∀ (x : α), p x) = ∃ x, ¬p x | null | false |
CategoryTheory.coyonedaLemma.eq_1 | Mathlib.CategoryTheory.Limits.IndYoneda | ∀ (C : Type u₁) [inst : CategoryTheory.Category.{v₁, u₁} C],
CategoryTheory.coyonedaLemma C =
CategoryTheory.NatIso.ofComponents (fun x => (CategoryTheory.coyonedaEquiv.trans Equiv.ulift.symm).toIso) ⋯ | null | true |
Std.IterM.findM?_eq_match_step | Init.Data.Iterators.Lemmas.Consumers.Monadic.Loop | ∀ {α β : Type w} {m : Type w → Type w'} [inst : Monad m] [inst_1 : Std.Iterator α m β] [inst_2 : Std.IteratorLoop α m m]
[LawfulMonad m] [Std.Iterators.Finite α m] [Std.LawfulIteratorLoop α m m] {it : Std.IterM m β}
{f : β → m (ULift.{w, 0} Bool)},
it.findM? f = do
let __do_lift ← it.step
match ↑__do_lift... | null | true |
Inclusion.IntervalDyadicReal.midpoint | Mathlib.Tactic.Inclusion.Extension.IntervalDyadicReal.BinarySplit | Dyadic → Dyadic → Dyadic | The midpoint of `a` and `b`. | true |
MonoidAlgebra.mapRangeAlgAut_apply | Mathlib.Algebra.MonoidAlgebra.Basic | ∀ (R : Type u_1) {A : Type u_4} (M : Type u_7) [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A]
[inst_3 : Monoid M] (f : A ≃ₐ[R] A), (MonoidAlgebra.mapRangeAlgAut R M) f = MonoidAlgebra.mapAlgEquiv R M f | null | true |
_private.Init.Data.Range.Polymorphic.NatLemmas.0.Nat.zero_lt_getElem!_toList_ric_iff._simp_1_2 | Init.Data.Range.Polymorphic.NatLemmas | ∀ {m n : ℕ}, (m < n.succ) = (m ≤ n) | null | false |
String.Slice.Pattern.Model.ForwardSliceSearcher.matchesAt_iff_getElem._proof_2 | Init.Data.String.Lemmas.Pattern.String.Basic | ∀ {pat s : String.Slice} {pos : s.Pos},
pos.offset.byteIdx + pat.copy.toByteArray.size ≤ s.copy.toByteArray.size →
∀ j < pat.copy.toByteArray.size, pos.offset.byteIdx + j < s.copy.toByteArray.size | null | false |
_private.Mathlib.AlgebraicGeometry.EllipticCurve.Projective.Formula.0.WeierstrassCurve.Projective.toAffine_slope_of_ne._simp_1_1 | Mathlib.AlgebraicGeometry.EllipticCurve.Projective.Formula | ∀ {α : Type u_2} [inst : Zero α] [inst_1 : OfNat α 2] [NeZero 2], (2 = 0) = False | null | false |
MulOpposite.instCoalgebra._proof_8 | Mathlib.RingTheory.Coalgebra.MulOpposite | ∀ {R : Type u_1} {A : Type u_2} [inst : CommSemiring R] [inst_1 : AddCommMonoid A] [inst_2 : Module R A],
SMulCommClass R R (TensorProduct R Aᵐᵒᵖ R) | null | false |
CategoryTheory.FreeBicategory.Hom.brecOn.eq | 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)
(F_1 :
(a a_2 : B) →
(t : CategoryTheory.FreeBicategory.Hom a a_2) → CategoryTheory.FreeBicategory.Hom.below t → motive a a_2 t),
Categor... | null | true |
ContinuousMap.instCommCStarAlgebra._proof_1 | Mathlib.Analysis.CStarAlgebra.ContinuousMap | ∀ {α : Type u_2} {A : Type u_1} [inst : TopologicalSpace α] [inst_1 : CompactSpace α] [inst_2 : CommCStarAlgebra A],
CompleteSpace C(α, A) | null | false |
CategoryTheory.Pretriangulated.productTriangle_obj₁ | Mathlib.CategoryTheory.Triangulated.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.HasShift C ℤ] {J : Type u_1}
(T : J → CategoryTheory.Pretriangulated.Triangle C) [inst_2 : CategoryTheory.Limits.HasProduct fun j => (T j).obj₁]
[inst_3 : CategoryTheory.Limits.HasProduct fun j => (T j).obj₂]
[inst_4 : CategoryTheor... | null | true |
Quiver.IsStronglyConnected.nonempty_path | Mathlib.Combinatorics.Quiver.ConnectedComponent | ∀ (V : Type u_2) [inst : Quiver V], Quiver.IsStronglyConnected V → ∀ (i j : V), Nonempty (Quiver.Path i j) | null | true |
AddSubmonoid.gciMapComap._proof_3 | Mathlib.Algebra.Group.Submonoid.Operations | ∀ {M : Type u_1} {N : Type u_2} [inst : AddZeroClass M] [inst_1 : AddZeroClass N] {F : Type u_3}
[inst_2 : FunLike F M N] [mc : AddMonoidHomClass F M N] {f : F},
Function.Injective ⇑f → ∀ (S : AddSubmonoid M), ∀ x ∈ AddSubmonoid.comap f (AddSubmonoid.map f S), x ∈ S | null | false |
instMetricSpaceOrderDual | Mathlib.Topology.MetricSpace.Defs | {X : Type u_1} → [MetricSpace X] → MetricSpace Xᵒᵈ | null | true |
groupHomology.chainsMap._proof_3 | Mathlib.RepresentationTheory.Homological.GroupHomology.Functoriality | ∀ {k : Type u_1} [inst : CommRing k], RingHomCompTriple (RingHom.id k) (RingHom.id k) (RingHom.id k) | null | false |
MeasureTheory.AEStronglyMeasurable.fun_vadd | Mathlib.MeasureTheory.Function.StronglyMeasurable.AEStronglyMeasurable | ∀ {α : Type u_1} {β : Type u_2} [inst : TopologicalSpace β] {m m₀ : MeasurableSpace α} {μ : MeasureTheory.Measure α}
{𝕜 : Type u_5} [inst_1 : TopologicalSpace 𝕜] [inst_2 : VAdd 𝕜 β] [ContinuousVAdd 𝕜 β] {f : α → 𝕜} {g : α → β},
MeasureTheory.AEStronglyMeasurable f μ →
MeasureTheory.AEStronglyMeasurable g μ... | null | true |
eq_nnratCast | Mathlib.Data.Rat.Cast.Defs | ∀ {F : Type u_1} {α : Type u_2} [inst : DivisionSemiring α] [inst_1 : FunLike F ℚ≥0 α] [RingHomClass F ℚ≥0 α] (f : F)
(q : ℚ≥0), f q = ↑q | null | true |
Lean.Elab.Term.LetConfig.rec | Lean.Elab.Binders | {motive : Lean.Elab.Term.LetConfig → Sort u} →
((nondep usedOnly zeta postponeValue generalize : Bool) →
(eq? : Option Lean.Ident) →
motive
{ nondep := nondep, usedOnly := usedOnly, zeta := zeta, postponeValue := postponeValue,
generalize := generalize, eq? := eq? }) →
(t : Lea... | null | false |
YoungDiagram.cells_subset_iff | Mathlib.Combinatorics.Young.YoungDiagram | ∀ {μ ν : YoungDiagram}, μ.cells ⊆ ν.cells ↔ μ ≤ ν | null | true |
CauSeq.Completion.ofRat_neg | Mathlib.Algebra.Order.CauSeq.Completion | ∀ {α : Type u_1} [inst : Field α] [inst_1 : LinearOrder α] [inst_2 : IsStrictOrderedRing α] {β : Type u_2}
[inst_3 : Ring β] {abv : β → α} [inst_4 : IsAbsoluteValue abv] (x : β),
CauSeq.Completion.ofRat (-x) = -CauSeq.Completion.ofRat x | null | true |
_private.Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Continuity.0.continuousOn_cfc_setProd_nhdsSet.match_1_7 | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Continuity | ∀ {𝕜 : Type u_1} {A : Type u_2} {p : A → Prop} [inst : RCLike 𝕜] [inst_1 : NormedRing A] [inst_2 : NormedAlgebra 𝕜 A]
{s : Set 𝕜} (k : Set 𝕜) (f : UniformOnFun 𝕜 𝕜 {t | IsCompact t ∧ t ⊆ s}) (a : A)
(motive :
(f, a) ∈
{f | ContinuousOn ((UniformOnFun.toFun {t | IsCompact t ∧ t ⊆ s}) f) s} ×ˢ
... | null | false |
Array.eraseP_map | Init.Data.Array.Erase | ∀ {β : Type u_1} {α : Type u_2} {p : α → Bool} {f : β → α} {xs : Array β},
(Array.map f xs).eraseP p = Array.map f (xs.eraseP (p ∘ f)) | null | true |
PerfectClosure.instCommRing._proof_18 | Mathlib.FieldTheory.PerfectClosure | ∀ (K : Type u_1) [inst : CommRing K] (p : ℕ) [inst_1 : Fact (Nat.Prime p)] [inst_2 : CharP K p]
(a : PerfectClosure K p), 0 • a = 0 | null | false |
AlgebraicGeometry.IsSeparated.of_comp | Mathlib.AlgebraicGeometry.Morphisms.Separated | ∀ {X Y Z : AlgebraicGeometry.Scheme} (f : X ⟶ Y) (g : Y ⟶ Z)
[AlgebraicGeometry.IsSeparated (CategoryTheory.CategoryStruct.comp f g)], AlgebraicGeometry.IsSeparated f | null | true |
Topology.IsUpper.isTopologicalSpace_basis | Mathlib.Topology.Order.LowerUpperTopology | ∀ {α : Type u_1} [inst : CompleteLinearOrder α] [t : TopologicalSpace α] [Topology.IsUpper α] (U : Set α),
IsOpen U ↔ U = Set.univ ∨ ∃ a, (Set.Iic a)ᶜ = U | null | true |
_private.Mathlib.Topology.Order.LeftRightNhds.0.eventually_mabs_div_lt._simp_1_1 | Mathlib.Topology.Order.LeftRightNhds | ∀ {α : Type u} (s : Set α), (s ∈ Filter.principal s) = True | null | false |
Lean.Lsp.DidSaveTextDocumentParams.mk.noConfusion | Lean.Data.Lsp.TextSync | {P : Sort u} →
{textDocument : Lean.Lsp.TextDocumentIdentifier} →
{text? : Option String} →
{textDocument' : Lean.Lsp.TextDocumentIdentifier} →
{text?' : Option String} →
{ textDocument := textDocument, text? := text? } = { textDocument := textDocument', text? := text?' } →
(te... | null | false |
Mathlib.Tactic.ClickSuggestions.GrwKey._sizeOf_inst | Mathlib.Tactic.ClickSuggestions.GRewrite | SizeOf Mathlib.Tactic.ClickSuggestions.GrwKey | null | false |
Std.Time.DateFormatSymbols.mk.inj | Std.Time.Format.DateFormat | ∀ {monthLong monthShort monthNarrow : Vector String 12}
{weekdayLong weekdayShort weekdayNarrow weekdayTwoLetter : Vector String 7}
{eraShort eraLong eraNarrow : Vector String 2} {quarterShort quarterLong quarterNarrow : Vector String 4}
{amShort pmShort amLong pmLong amNarrow pmNarrow : String}
{dayPeriodShort... | null | true |
_private.Lean.Compiler.LCNF.ExtractClosed.0.Lean.Compiler.LCNF.extractClosed._proof_1 | Lean.Compiler.LCNF.ExtractClosed | Lean.Compiler.LCNF.Phase.mono ≥ Lean.Compiler.LCNF.Phase.mono | null | false |
Set.infs_assoc | Mathlib.Data.Set.Sups | ∀ {α : Type u_2} [inst : SemilatticeInf α] (s t u : Set α), s ⊼ t ⊼ u = s ⊼ (t ⊼ u) | null | true |
Filter.cocardinal_aleph0_eq_cofinite | Mathlib.Order.Filter.Cocardinal | ∀ {α : Type u}, Filter.cocardinal α Cardinal.isRegular_aleph0 = Filter.cofinite | null | true |
Sbtw.left_ne_right | Mathlib.Analysis.Convex.Between | ∀ {R : Type u_1} {V : Type u_2} {P : Type u_4} [inst : Ring R] [inst_1 : PartialOrder R] [inst_2 : AddCommGroup V]
[inst_3 : Module R V] [inst_4 : AddTorsor V P] [IsOrderedRing R] {x y z : P}, Sbtw R x y z → x ≠ z | null | true |
_private.Mathlib.RingTheory.Smooth.NoetherianDescent.0.Algebra.Smooth.DescentAux.instFaithfulSMulSubtypeMemSubalgebraSubalgebra._proof_1 | Mathlib.RingTheory.Smooth.NoetherianDescent | ∀ (R : Type u_2) [inst : CommRing R] {A : Type u_1} {B : Type u_3} [inst_1 : CommRing A] [inst_2 : Algebra R A]
[inst_3 : CommRing B] [inst_4 : Algebra A B] (D : Algebra.Smooth.DescentAux✝ A B),
FaithfulSMul (↥(Algebra.Smooth.DescentAux.subalgebra✝ R D)) A | null | false |
CategoryTheory.Under.mapCongr._proof_1 | Mathlib.CategoryTheory.Comma.Over.Basic | ∀ {T : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} T] {X Y : T} (f g : X ⟶ Y),
f = g → ∀ (A : CategoryTheory.Under Y), (CategoryTheory.Under.map f).obj A = (CategoryTheory.Under.map g).obj A | null | false |
_private.Mathlib.Topology.EMetricSpace.BoundedVariation.0.BoundedVariationOn.of_finset._proof_1_11 | Mathlib.Topology.EMetricSpace.BoundedVariation | ∀ {α : Type u_1} (s : Finset α) (hne : s.Nonempty) (this : 0 < s.card) (x x_1 : ℕ),
x ≤ x_1 → ⟨min x (s.card - 1), ⋯⟩ ≤ ⟨min x_1 (s.card - 1), ⋯⟩ | null | false |
PresheafOfModules.instModuleCarrierStalkCommRingCatCarrierAbPresheafOpensCarrier._proof_1 | Mathlib.Algebra.Category.ModuleCat.Stalk | ∀ {X : TopCat} {R : TopCat.Presheaf CommRingCat X}
(M : PresheafOfModules (CategoryTheory.Functor.comp R (CategoryTheory.forget₂ CommRingCat RingCat))) (x : ↑X)
{i j : (TopologicalSpace.OpenNhds x)ᵒᵖ} (f : i ⟶ j)
(r :
↑(((TopologicalSpace.OpenNhds.inclusion x).op.comp
(CategoryTheory.Functor.comp ... | null | false |
_private.Mathlib.MeasureTheory.Measure.Hausdorff.0.Isometry.hausdorffMeasure_image._simp_1_2 | Mathlib.MeasureTheory.Measure.Hausdorff | ∀ {X : Type u_2} [inst : EMetricSpace X] [inst_1 : MeasurableSpace X] [inst_2 : BorelSpace X] (m : ENNReal → ENNReal),
⇑(MeasureTheory.Measure.mkMetric m) = ⇑(MeasureTheory.OuterMeasure.mkMetric m) | null | false |
instLawfulMonadTacticM_batteries | Batteries.Lean.LawfulMonad | LawfulMonad Lean.Elab.Tactic.TacticM | null | true |
TopologicalSpace.Opens.map_comp_obj' | Mathlib.Topology.Category.TopCat.Opens | ∀ {X Y Z : TopCat} (f : X ⟶ Y) (g : Y ⟶ Z) (U : Set ↑Z) (p : IsOpen U),
(TopologicalSpace.Opens.map (CategoryTheory.CategoryStruct.comp f g)).obj { carrier := U, is_open' := p } =
(TopologicalSpace.Opens.map f).obj ((TopologicalSpace.Opens.map g).obj { carrier := U, is_open' := p }) | null | true |
CategoryTheory.Limits.CatCospanTransformMorphism.whiskerLeft_base | Mathlib.CategoryTheory.Limits.Shapes.Pullback.Categorical.CatCospanTransform | ∀ {A : Type u₁} {B : Type u₂} {C : Type u₃} {A' : Type u₄} {B' : Type u₅} {C' : Type u₆} {A'' : Type u₇} {B'' : Type u₈}
{C'' : Type u₉} [inst : CategoryTheory.Category.{v₁, u₁} A] [inst_1 : CategoryTheory.Category.{v₂, u₂} B]
[inst_2 : CategoryTheory.Category.{v₃, u₃} C] {F : CategoryTheory.Functor A B} {G : Categ... | null | true |
_private.Mathlib.Algebra.Category.AlgCat.FilteredColimits.0.AlgCat.isColimitCoconeOfIsFiltered._proof_2 | Mathlib.Algebra.Category.AlgCat.FilteredColimits | ∀ {R : Type u_4} [inst : CommRing R] {J : Type u_3} [inst_1 : CategoryTheory.Category.{u_1, u_3} J]
{F : CategoryTheory.Functor J (AlgCat R)}
[inst_2 : CategoryTheory.Limits.PreservesColimitsOfShape J (CategoryTheory.forget RingCat)]
{c : CategoryTheory.Limits.Cocone (F.comp (CategoryTheory.forget₂ (AlgCat R) Rin... | null | false |
BitVec.extractLsb'_append_eq_of_le | Init.Data.BitVec.Lemmas | ∀ {v w : ℕ} {xhi : BitVec v} {xlo : BitVec w} {start len : ℕ},
w ≤ start → BitVec.extractLsb' start len (xhi ++ xlo) = BitVec.extractLsb' (start - w) len xhi | Extracting bits `[start..start+len)` from `(xhi ++ xlo)` equals extracting
the bits from `xhi` when `start` is outside `xlo`.
| true |
UInt16.toUSize_shiftLeft | Init.Data.UInt.Bitwise | ∀ (a b : UInt16), (a <<< b).toUSize = a.toUSize <<< (b % 16).toUSize % 65536 | null | true |
_private.Mathlib.MeasureTheory.OuterMeasure.AE.0.MeasureTheory.union_ae_eq_right._simp_1_2 | Mathlib.MeasureTheory.OuterMeasure.AE | ∀ {α : Type u_1} {F : Type u_3} [inst : FunLike F (Set α) ENNReal] [inst_1 : MeasureTheory.OuterMeasureClass F α]
{μ : F} {s t : Set α}, (s ≤ᵐ[μ] t) = (μ (s \ t) = 0) | null | false |
Function.Even | Mathlib.Algebra.Group.EvenFunction | {α : Type u_1} → {β : Type u_2} → [Neg α] → (α → β) → Prop | A function `f` is _even_ if it satisfies `f (-x) = f x` for all `x`. | true |
Mathlib.Meta.NormNum.IsNNRat.to_isRat | Mathlib.Tactic.NormNum.Result | ∀ {α : Type u_1} [inst : Ring α] {a : α} {n d : ℕ},
Mathlib.Meta.NormNum.IsNNRat a n d → Mathlib.Meta.NormNum.IsRat a (Int.ofNat n) d | null | true |
Lean.Lsp.VersionedTextDocumentIdentifier.casesOn | Lean.Data.Lsp.Basic | {motive : Lean.Lsp.VersionedTextDocumentIdentifier → Sort u} →
(t : Lean.Lsp.VersionedTextDocumentIdentifier) →
((uri : Lean.Lsp.DocumentUri) → (version? : Option ℕ) → motive { uri := uri, version? := version? }) → motive t | null | false |
Nat.stirlingSecond._sunfold | Mathlib.Combinatorics.Enumerative.Stirling | ℕ → ℕ → ℕ | null | false |
smoothPresheafCommGroup._proof_2 | Mathlib.Geometry.Manifold.Sheaf.Smooth | ∀ {𝕜 : Type u_2} [inst : NontriviallyNormedField 𝕜] {EM : Type u_3} [inst_1 : NormedAddCommGroup EM]
[inst_2 : NormedSpace 𝕜 EM] {HM : Type u_4} [inst_3 : TopologicalSpace HM] (IM : ModelWithCorners 𝕜 EM HM)
{E : Type u_5} [inst_4 : NormedAddCommGroup E] [inst_5 : NormedSpace 𝕜 E] {H : Type u_6} [inst_6 : Topo... | null | false |
AffineIsometryEquiv.toAffineIsometry | Mathlib.Analysis.Normed.Affine.Isometry | {𝕜 : Type u_1} →
{V : Type u_2} →
{V₂ : Type u_4} →
{P : Type u_7} →
{P₂ : Type u_8} →
[inst : NormedField 𝕜] →
[inst_1 : SeminormedAddCommGroup V] →
[inst_2 : NormedSpace 𝕜 V] →
[inst_3 : PseudoMetricSpace P] →
[inst_4 : Norme... | Reinterpret an `AffineIsometryEquiv` as an `AffineIsometry`. | true |
Lean.Elab.Tactic.withCaseRef | Lean.Elab.Tactic.Basic | {m : Type → Type} → {α : Type} → [Monad m] → [Lean.MonadRef m] → Lean.Syntax → Lean.Syntax → m α → m α | Use position of `=> $body` for error messages.
If there is a line break before `body`, the message will be displayed on `=>` only,
but the "full range" for the info view will still include `body`. | true |
CStarMatrix.mapₗ | Mathlib.Analysis.CStarAlgebra.CStarMatrix | {m : Type u_1} →
{n : Type u_2} →
{R : Type u_3} →
{S : Type u_4} →
{A : Type u_5} →
{B : Type u_6} →
[inst : Semiring R] →
[inst_1 : Semiring S] →
{σ : R →+* S} →
[inst_2 : AddCommMonoid A] →
[inst_3 : AddComm... | The semilinear map constructed by applying a semilinear map to all the entries of the matrix. | true |
HasLineDerivWithinAt.mono | Mathlib.Analysis.Calculus.LineDeriv.Basic | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {F : Type u_2} [inst_1 : NormedAddCommGroup F]
[inst_2 : NormedSpace 𝕜 F] {E : Type u_3} [inst_3 : AddCommGroup E] [inst_4 : Module 𝕜 E] {f : E → F} {f' : F}
{s t : Set E} {x v : E}, HasLineDerivWithinAt 𝕜 f f' s x v → t ⊆ s → HasLineDerivWithinAt 𝕜 f f' t x... | null | true |
LinearMap.equivOfDetNeZero._proof_3 | Mathlib.LinearAlgebra.Determinant | ∀ {𝕜 : Type u_1} [inst : Field 𝕜] {M : Type u_2} [inst_1 : AddCommGroup M] [inst_2 : Module 𝕜 M], SMulCommClass 𝕜 𝕜 M | null | false |
Lean.Meta.Simp.Arith.Nat.ToLinear.State.mk.injEq | Lean.Meta.Tactic.Simp.Arith.Nat.Basic | ∀ (varMap : Lean.Meta.KExprMap ℕ) (vars : Array Lean.Expr) (varMap_1 : Lean.Meta.KExprMap ℕ) (vars_1 : Array Lean.Expr),
({ varMap := varMap, vars := vars } = { varMap := varMap_1, vars := vars_1 }) = (varMap = varMap_1 ∧ vars = vars_1) | null | true |
Equiv.subtypeSubtypeEquivSubtype_apply_coe | Mathlib.Logic.Equiv.Basic | ∀ {α : Type u_8} {p q : α → Prop} (h : ∀ {x : α}, q x → p x) (a : { x // q ↑x }),
↑((Equiv.subtypeSubtypeEquivSubtype h) a) = ↑↑a | null | true |
Subtype.val_prop | Mathlib.Data.Subtype | ∀ {α : Type u_1} {S : Set α} (a : { a // a ∈ S }), ↑a ∈ S | null | true |
CategoryTheory.ObjectProperty.productToFamily | Mathlib.CategoryTheory.Generator.Basic | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
(P : CategoryTheory.ObjectProperty C) → (X : C) → CategoryTheory.StructuredArrow X P.ι → C | Given `P : ObjectProperty C` and `X : C`, this is the map which
sends `i : StructuredArrow P.ι X` to `i.right.obj : C`. The product
of this family is the target of the morphism `P.productTo X`. | true |
_private.Mathlib.Tactic.Linter.TextBased.0.Mathlib.Linter.TextBased.initFn._@.Mathlib.Tactic.Linter.TextBased.1476535223._hygCtx._hyg.4 | Mathlib.Tactic.Linter.TextBased | IO (Lean.Option Bool) | null | false |
String.Slice.Pattern.Model.IsRevMatch.exists_isLongestRevMatch | Init.Data.String.Lemmas.Pattern.Basic | ∀ {ρ : Type} {pat : ρ} [inst : String.Slice.Pattern.Model.PatternModel pat] {s : String.Slice} {pos : s.Pos},
String.Slice.Pattern.Model.IsRevMatch pat pos → ∃ pos', String.Slice.Pattern.Model.IsLongestRevMatch pat pos' | null | true |
SubMulAction.ofStabilizer.conjMap | Mathlib.GroupTheory.GroupAction.SubMulAction.OfStabilizer | {G : Type u_1} →
[inst : Group G] →
{α : Type u_2} →
[inst_1 : MulAction G α] →
{g : G} →
{a b : α} →
(hg : b = g • a) →
↥(SubMulAction.ofStabilizer G a) →ₑ[⇑(MulAction.stabilizerEquivStabilizer hg)]
↥(SubMulAction.ofStabilizer G b) | Conjugation induces an equivariant map between the SubMulAction of
the stabilizer of a point and that of its translate. | true |
_private.Mathlib.RingTheory.Ideal.Lattice.0.Ideal.eq_top_of_isUnit_mem.match_1_1 | Mathlib.RingTheory.Ideal.Lattice | ∀ {α : Type u_1} [inst : Semiring α] {x : α} (motive : (∃ b, b * x = 1) → Prop) (x_1 : ∃ b, b * x = 1),
(∀ (y : α) (hy : y * x = 1), motive ⋯) → motive x_1 | null | false |
CategoryTheory.Bicategory.rightAdjointSquareConjugate.vcomp | Mathlib.CategoryTheory.Bicategory.Adjunction.Mate | {B : Type u} →
[inst : CategoryTheory.Bicategory B] →
{a b c d : B} →
{g : a ⟶ c} →
{h : b ⟶ d} →
{r₁ : b ⟶ a} →
{r₂ r₃ : d ⟶ c} →
(CategoryTheory.CategoryStruct.comp r₁ g ⟶ CategoryTheory.CategoryStruct.comp h r₂) →
(r₂ ⟶ r₃) → (CategoryTheory.Cat... | Composition of a square between right adjoints with a conjugate square. | true |
_private.Mathlib.Data.Set.Subsingleton.0.Set.nontrivial_coe_sort._simp_1_1 | Mathlib.Data.Set.Subsingleton | ∀ {α : Type u}, Nontrivial α = Set.univ.Nontrivial | null | false |
Filter.filter_eq_iff | Mathlib.Order.Filter.Basic | ∀ {α : Type u} {f g : Filter α}, f = g ↔ f.sets = g.sets | null | true |
Hyperreal.archimedeanClassMk_nonneg_of_tendsto | Mathlib.Analysis.Real.Hyperreal | ∀ {x : ℝ*} {r : ℝ}, Filter.Germ.Tendsto x (nhds r) → 0 ≤ ArchimedeanClass.mk x | null | true |
_private.Mathlib.Topology.Compactification.OnePoint.Basic.0.OnePoint.isOpen_iff_of_mem._simp_1_1 | Mathlib.Topology.Compactification.OnePoint.Basic | ∀ {X : Type u} [inst : TopologicalSpace X] {s : Set X}, IsClosed sᶜ = IsOpen s | null | false |
ProbabilityTheory.Kernel.eq_rnDeriv_measure | Mathlib.Probability.Kernel.RadonNikodym | ∀ {α : Type u_1} {γ : Type u_2} {mα : MeasurableSpace α} {mγ : MeasurableSpace γ} {κ η ξ : ProbabilityTheory.Kernel α γ}
{f : α → γ → ENNReal} [inst : ProbabilityTheory.IsFiniteKernel η],
κ = η.withDensity f + ξ →
Measurable (Function.uncurry f) → ∀ (a : α), (ξ a).MutuallySingular (η a) → f a =ᵐ[η a] (κ a).rnDe... | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.