name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11.5k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
UniformSpace.Completion.map_comp | Mathlib.Topology.UniformSpace.Completion | ∀ {α : Type u_1} [inst : UniformSpace α] {β : Type u_2} [inst_1 : UniformSpace β] {γ : Type u_3}
[inst_2 : UniformSpace γ] {g : β → γ} {f : α → β},
UniformContinuous g →
UniformContinuous f →
UniformSpace.Completion.map g ∘ UniformSpace.Completion.map f = UniformSpace.Completion.map (g ∘ f) | null | true |
MeasureTheory.Measure.join_zero | Mathlib.MeasureTheory.Measure.GiryMonad | ∀ {α : Type u_1} {mα : MeasurableSpace α}, MeasureTheory.Measure.join 0 = 0 | null | true |
OrderHom.instBotOfOrderBot | Mathlib.Order.Hom.Order | {α : Type u_1} → {β : Type u_2} → [inst : Preorder α] → [inst_1 : Preorder β] → [OrderBot β] → Bot (α →o β) | null | true |
Mathlib.Tactic.ClickSuggestions.spawnTask | Mathlib.Tactic.ClickSuggestions.SectionState | {α : Type} →
Mathlib.Tactic.ClickSuggestions.Premise →
Mathlib.Tactic.ClickSuggestions.ClickSuggestionsM α →
Mathlib.Tactic.ClickSuggestions.ClickSuggestionsM (Task (Except ProofWidgets.Html (Option α))) | Spawn a task that computes a piece of `Html` to be displayed when finished. | true |
Real.logb_nonpos_iff' | Mathlib.Analysis.SpecialFunctions.Log.Base | ∀ {b x : ℝ}, 1 < b → 0 ≤ x → (Real.logb b x ≤ 0 ↔ x ≤ 1) | null | true |
Std.Internal.List.getValueCast_eraseKey | Std.Data.Internal.List.Associative | ∀ {α : Type u} {β : α → Type v} [inst : BEq α] [inst_1 : LawfulBEq α] {l : List ((a : α) × β a)} {k a : α}
{h : Std.Internal.List.containsKey a (Std.Internal.List.eraseKey k l) = true} (hl : Std.Internal.List.DistinctKeys l),
Std.Internal.List.getValueCast a (Std.Internal.List.eraseKey k l) h = Std.Internal.List.ge... | null | true |
continuous_cfcₙHom_of_cfcHom | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.NonUnital | ∀ {R : Type u_1} {A : Type u_2} {p : A → Prop} [inst : Semifield R] [inst_1 : StarRing R] [inst_2 : MetricSpace R]
[inst_3 : IsTopologicalSemiring R] [inst_4 : ContinuousStar R] [inst_5 : Ring A] [inst_6 : StarRing A]
[inst_7 : TopologicalSpace A] [inst_8 : Algebra R A] [inst_9 : ContinuousFunctionalCalculus R A p]... | null | true |
Int16.ne_of_lt | Init.Data.SInt.Lemmas | ∀ {a b : Int16}, a < b → a ≠ b | null | true |
Lean.Meta.Try.Collector.OrdSet.rec | Lean.Meta.Tactic.Try.Collect | {α : Type} →
[inst : Hashable α] →
[inst_1 : BEq α] →
{motive : Lean.Meta.Try.Collector.OrdSet α → Sort u} →
((elems : Array α) → (set : Std.HashSet α) → motive { elems := elems, set := set }) →
(t : Lean.Meta.Try.Collector.OrdSet α) → motive t | null | false |
List.tailD_nil | Init.Data.List.Basic | ∀ {α : Type u} {l' : List α}, [].tailD l' = l' | null | true |
_private.Lean.Elab.Tactic.Grind.Lint.0.Lean.Elab.Tactic.Grind.elabGrindLintInspect | Lean.Elab.Tactic.Grind.Lint | Lean.Elab.Command.CommandElab | null | true |
EuclideanGeometry.Sphere.mk_center | Mathlib.Geometry.Euclidean.Sphere.Basic | ∀ {P : Type u_2} [inst : MetricSpace P] (c : P) (r : ℝ), { center := c, radius := r }.center = c | null | true |
SymAlg.instOne.eq_1 | Mathlib.Algebra.Symmetrized | ∀ {α : Type u_1} [inst : One α], SymAlg.instOne = { one := SymAlg.sym 1 } | null | true |
MvPolynomial.quotientEquivQuotientMvPolynomial._proof_1 | Mathlib.RingTheory.Polynomial.Quotient | ∀ {R : Type u_1} {σ : Type u_2} [inst : CommRing R] (I : Ideal R), (Ideal.map MvPolynomial.C I).IsTwoSided | null | false |
_private.Lean.Meta.Match.SimpH.0.Lean.Meta.Match.SimpH.isDone | Lean.Meta.Match.SimpH | Lean.Meta.Match.SimpH.M✝ Bool | null | true |
Nat.and_distrib_right | Init.Data.Nat.Bitwise.Lemmas | ∀ (x y z : ℕ), (x ||| y) &&& z = x &&& z ||| y &&& z | null | true |
FP.Float.isFinite._sparseCasesOn_1 | Mathlib.Data.FP.Basic | [C : FP.FloatCfg] →
{motive : FP.Float → Sort u} →
(t : FP.Float) →
((a : Bool) → (e : ℤ) → (m : ℕ) → (a_1 : FP.ValidFinite e m) → motive (FP.Float.finite a e m a_1)) →
(Nat.hasNotBit 4 t.ctorIdx → motive t) → motive t | null | false |
CategoryTheory.Functor.IsCardinalAccessible.recOn | Mathlib.CategoryTheory.Presentable.Basic | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{D : Type u₂} →
[inst_1 : CategoryTheory.Category.{v₂, u₂} D] →
{F : CategoryTheory.Functor C D} →
{κ : Cardinal.{w}} →
[inst_2 : Fact κ.IsRegular] →
{motive : F.IsCardinalAccessible κ → Sort u} →
... | null | false |
_private.Mathlib.Algebra.Lie.BaseChange.0.LieAlgebra.ExtendScalars.bracket'._proof_5 | Mathlib.Algebra.Lie.BaseChange | ∀ (R : Type u_1) (A : Type u_2) [inst : CommRing R] [inst_1 : CommRing A] [inst_2 : Algebra R A],
IsScalarTower R A (TensorProduct A A A) | null | false |
_private.Lean.Meta.Match.CaseValues.0.Lean.Meta.caseValues.loop._sparseCasesOn_3 | Lean.Meta.Match.CaseValues | {α : Type u} →
{motive : List α → Sort u_1} → (t : List α) → motive [] → (Nat.hasNotBit 1 t.ctorIdx → motive t) → motive t | null | false |
CategoryTheory.Equivalence.congrLeft._proof_5 | Mathlib.CategoryTheory.Equivalence | ∀ {C : Type u_5} [inst : CategoryTheory.Category.{u_6, u_5} C] {D : Type u_1}
[inst_1 : CategoryTheory.Category.{u_4, u_1} D] {E : Type u_3} [inst_2 : CategoryTheory.Category.{u_2, u_3} E]
(e : C ≌ D) (F : CategoryTheory.Functor C E),
CategoryTheory.CategoryStruct.comp
(((CategoryTheory.Functor.whiskeringLe... | null | false |
Std.DTreeMap.Const.getD_alter | Std.Data.DTreeMap.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {β : Type v} {t : Std.DTreeMap α (fun x => β) cmp} [Std.TransCmp cmp] {k k' : α}
{fallback : β} {f : Option β → Option β},
Std.DTreeMap.Const.getD (Std.DTreeMap.Const.alter t k f) k' fallback =
if cmp k k' = Ordering.eq then (f (Std.DTreeMap.Const.get? t k)).getD fallback... | null | true |
BoundedOrderHom.dual._proof_3 | Mathlib.Order.Hom.Bounded | ∀ {α : Type u_2} {β : Type u_1} [inst : Preorder α] [inst_1 : BoundedOrder α] [inst_2 : Preorder β]
[inst_3 : BoundedOrder β] (f : BoundedOrderHom αᵒᵈ βᵒᵈ), f.toFun ⊥ = ⊥ | null | false |
_private.Init.Omega.IntList.0.List.getElem?_zipWith.match_1.splitter | Init.Omega.IntList | {α : Type u_1} →
{β : Type u_2} →
(motive : Option α → Option β → Sort u_3) →
(x : Option α) →
(x_1 : Option β) →
((a : α) → (b : β) → motive (some a) (some b)) →
((x : Option α) →
(x_2 : Option β) → (∀ (a : α) (b : β), x = some a → x_2 = some b → False) → motiv... | null | true |
_private.Lean.Meta.MkIffOfInductiveProp.0.Lean.Meta.toInductive | Lean.Meta.MkIffOfInductiveProp | Lean.MVarId → List Lean.Name → List Lean.Expr → List Lean.Meta.Shape✝ → Lean.FVarId → Lean.MetaM Unit | Proves the right to left direction of a generated iff theorem.
| true |
Membership.mem.step | Init.Data.Range.Basic | ∀ {i : ℕ} {r : Std.Legacy.Range}, i ∈ r → (i - r.start) % r.step = 0 | null | true |
ArchimedeanClass.closedBall_top | Mathlib.Algebra.Order.Module.Archimedean | ∀ (M : Type u_1) [inst : AddCommGroup M] [inst_1 : LinearOrder M] [inst_2 : IsOrderedAddMonoid M] (K : Type u_2)
[inst_3 : Ring K] [inst_4 : LinearOrder K] [inst_5 : IsOrderedRing K] [inst_6 : Archimedean K] [inst_7 : Module K M]
[inst_8 : PosSMulMono K M], ArchimedeanClass.closedBall K ⊤ = ⊥ | null | true |
Set.preimage_const_mul_Ioi₀ | Mathlib.Algebra.Order.Group.Pointwise.Interval | ∀ {G₀ : Type u_2} [inst : CommGroupWithZero G₀] [inst_1 : PartialOrder G₀] [PosMulReflectLT G₀] {c : G₀} (a : G₀),
0 < c → (fun x => c * x) ⁻¹' Set.Ioi a = Set.Ioi (a / c) | null | true |
MeasureTheory.Measure.addHaar_smul_of_nonneg | Mathlib.MeasureTheory.Measure.Lebesgue.EqHaar | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] [inst_2 : MeasurableSpace E] [BorelSpace E]
[FiniteDimensional ℝ E] (μ : MeasureTheory.Measure E) [μ.IsAddHaarMeasure] {r : ℝ},
0 ≤ r → ∀ (s : Set E), μ (r • s) = ENNReal.ofReal (r ^ Module.finrank ℝ E) * μ s | null | true |
Lean.Parser.Term.doIdbg.formatter | Lean.Parser.Do | Lean.PrettyPrinter.Formatter | null | true |
Lean.Doc.Block._sizeOf_inst | Lean.DocString.Types | (i : Type u) → (b : Type v) → [SizeOf i] → [SizeOf b] → SizeOf (Lean.Doc.Block i b) | null | false |
Int.tdiv_tmod_unique' | Init.Data.Int.DivMod.Lemmas | ∀ {a b r q : ℤ}, a ≤ 0 → b ≠ 0 → (a.tdiv b = q ∧ a.tmod b = r ↔ r + b * q = a ∧ -↑b.natAbs < r ∧ r ≤ 0) | null | true |
Path.Homotopy.symm₂._proof_3 | Mathlib.Topology.Homotopy.Path | ∀ {X : Type u_1} [inst : TopologicalSpace X] {x₀ x₁ : X} {p q : Path x₀ x₁} (F : p.Homotopy q) (x : ↑unitInterval),
F ((0, x).1, unitInterval.symm (0, x).2) = p.symm.toContinuousMap x | null | false |
ProbabilityTheory.IdentDistrib.measure_preimage_eq | Mathlib.Probability.IdentDistrib | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} [inst : MeasurableSpace α] [inst_1 : MeasurableSpace β]
[inst_2 : MeasurableSpace γ] {μ : MeasureTheory.Measure α} {ν : MeasureTheory.Measure β} {f : α → γ} {g : β → γ},
ProbabilityTheory.IdentDistrib f g μ ν → ∀ {s : Set γ}, MeasurableSet s → μ (f ⁻¹' s) = ν (g ⁻¹' s) | **Alias** of `ProbabilityTheory.IdentDistrib.measure_mem_eq`. | true |
_private.Mathlib.Data.Finsupp.MonomialOrder.DegLex.0.Finsupp.DegLex.single_strictAnti._simp_1_1 | Mathlib.Data.Finsupp.MonomialOrder.DegLex | ∀ {α : Type u_2} [inst : Preorder α] (x : α), (x < x) = False | null | false |
NNReal.iSup_eq_zero | Mathlib.Data.NNReal.Defs | ∀ {ι : Sort u_1} {f : ι → NNReal}, BddAbove (Set.range f) → (⨆ i, f i = 0 ↔ ∀ (i : ι), f i = 0) | null | true |
DFinsupp.toMultiset_toDFinsupp | Mathlib.Data.DFinsupp.Multiset | ∀ {α : Type u_1} [inst : DecidableEq α] (f : Π₀ (x : α), ℕ), Multiset.toDFinsupp (DFinsupp.toMultiset f) = f | null | true |
_private.Mathlib.SetTheory.Cardinal.Finite.0.Nat.card_ne_zero._simp_1_2 | Mathlib.SetTheory.Cardinal.Finite | ∀ {p q : Prop}, (¬(p ∨ q)) = (¬p ∧ ¬q) | null | false |
Aesop.GoalUnsafe.brecOn_2.eq | Aesop.Tree.Data | ∀ {motive_1 : Aesop.GoalUnsafe → Sort u} {motive_2 : Aesop.MVarClusterUnsafe → Sort u}
{motive_3 : Aesop.RappUnsafe → Sort u} {motive_4 : Aesop.GoalData Aesop.RappUnsafe Aesop.MVarClusterUnsafe → Sort u}
{motive_5 : Aesop.MVarClusterData Aesop.GoalUnsafe Aesop.RappUnsafe → Sort u}
{motive_6 : Aesop.RappData Aesop... | null | true |
Int.Linear.le_of_le_diseq_cert.eq_1 | Init.Data.Int.Linear | ∀ (p₁ p₂ p₃ : Int.Linear.Poly),
Int.Linear.le_of_le_diseq_cert p₁ p₂ p₃ = (p₂.beq' p₁ || p₂.beq' (p₁.mul_k (-1))).and' (p₃.beq' (p₁.addConst_k 1)) | null | true |
_private.Mathlib.RingTheory.MvPolynomial.Ideal.0.MvPolynomial.idealOfVars_eq_restrictSupportIdeal._simp_1_4 | Mathlib.RingTheory.MvPolynomial.Ideal | ∀ {A : Type u_1} {B : Type u_2} [inst : SetLike A B] [inst_1 : LE A] [IsConcreteLE A B] {S T : A},
(S ≤ T) = ∀ ⦃x : B⦄, x ∈ S → x ∈ T | null | false |
PerfectClosure.liftOn.congr_simp | Mathlib.FieldTheory.PerfectClosure | ∀ {K : Type u} [inst : CommRing K] {p : ℕ} [inst_1 : Fact (Nat.Prime p)] [inst_2 : CharP K p] {L : Type u_1}
(x x_1 : PerfectClosure K p),
x = x_1 →
∀ (f f_1 : ℕ × K → L) (e_f : f = f_1) (hf : ∀ (x y : ℕ × K), PerfectClosure.R K p x y → f x = f y),
x.liftOn f hf = x_1.liftOn f_1 ⋯ | null | true |
_private.Lean.Meta.Tactic.Grind.Arith.Cutsat.Proof.0.Lean.Meta.Grind.Arith.Cutsat.ProofM.State.varDecls' | Lean.Meta.Tactic.Grind.Arith.Cutsat.Proof | Lean.Meta.Grind.Arith.Cutsat.ProofM.State✝ → Std.HashMap Int.Linear.Var Lean.Expr | Map from used variables (before reordering) to (temporary) free variable. | true |
Lean.Meta.getCtorNumPropFields | Lean.Meta.Tactic.Injection | Lean.ConstructorVal → Lean.MetaM ℕ | null | true |
Cycle.coe_eq_coe._simp_1 | Mathlib.Data.List.Cycle | ∀ {α : Type u_1} {l₁ l₂ : List α}, (↑l₁ = ↑l₂) = (l₁ ~r l₂) | null | false |
_private.Mathlib.Data.Sign.Basic.0.sign_sum._simp_1_3 | Mathlib.Data.Sign.Basic | ∀ {α : Type u_1} [inst : Zero α] [inst_1 : Preorder α] [inst_2 : DecidableLT α] {a : α}, (SignType.sign a = 1) = (0 < a) | null | false |
Std.TreeSet.Equiv.get?_eq | Std.Data.TreeSet.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t₁ t₂ : Std.TreeSet α cmp} [Std.TransCmp cmp] {k : α},
t₁.Equiv t₂ → t₁.get? k = t₂.get? k | null | true |
RingHom.IsStandardSmooth.smooth | Mathlib.RingTheory.RingHom.LocallyStandardSmooth | ∀ {R : Type u_1} {S : Type u_2} [inst : CommRing R] [inst_1 : CommRing S] {f : R →+* S}, f.IsStandardSmooth → f.Smooth | Any standard smooth ring homomorphism is smooth. | true |
NonUnitalSubring.toNonUnitalSubsemiring_strictMono | Mathlib.RingTheory.NonUnitalSubring.Defs | ∀ {R : Type u} [inst : NonUnitalNonAssocRing R], StrictMono NonUnitalSubring.toNonUnitalSubsemiring | null | true |
ZeroAtInftyContinuousMap.instNormedAddCommGroup._proof_1 | Mathlib.Topology.ContinuousMap.ZeroAtInfty | ∀ {α : Type u_1} {β : Type u_2} [inst : TopologicalSpace α] [inst_1 : NormedAddCommGroup β],
autoParam (∀ (x y : ZeroAtInftyContinuousMap α β), dist x y = ‖-x + y‖) NormedAddCommGroup.dist_eq._autoParam | null | false |
RingHom.coe_rangeRestrict | Mathlib.Algebra.Ring.Subring.Basic | ∀ {R : Type u} {S : Type v} [inst : NonAssocRing R] [inst_1 : NonAssocRing S] (f : R →+* S) (x : R),
↑(f.rangeRestrict x) = f x | null | true |
LocallyConstant.constMonoidHom_apply | Mathlib.Topology.LocallyConstant.Algebra | ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] [inst_1 : MulOneClass Y] (y : Y),
LocallyConstant.constMonoidHom y = LocallyConstant.const X y | null | true |
Tilt.instField._proof_23 | Mathlib.RingTheory.Perfection | ∀ (K : Type u_1) [inst : Field K] (v : Valuation K NNReal) (O : Type u_2) [inst_1 : CommRing O] [inst_2 : Algebra O K]
(hv : v.Integers O) (p : ℕ) [inst_3 : Fact (Nat.Prime p)] [hvp : Fact (v ↑p ≠ 1)] (this : Fact ¬IsUnit ↑p),
autoParam
(∀ (n : ℕ) (x : Tilt K v O hv p),
Tilt.instField._aux_20 K v O hv p t... | null | false |
Lean.Meta.withIncSynthPending | Lean.Meta.Basic | {n : Type → Type u_1} → [MonadControlT Lean.MetaM n] → [Monad n] → {α : Type} → n α → n α | null | true |
_private.Mathlib.RingTheory.Perfectoid.BDeRham.0._aux_Mathlib_RingTheory_Perfectoid_BDeRham___unexpand_BDeRhamPlus_1 | Mathlib.RingTheory.Perfectoid.BDeRham | Lean.PrettyPrinter.Unexpander | null | false |
_private.Lean.Compiler.LCNF.Basic.0.Lean.Compiler.LCNF.LetValue.updateBoxImp._sparseCasesOn_1 | Lean.Compiler.LCNF.Basic | {pu : Lean.Compiler.LCNF.Purity} →
{motive : Lean.Compiler.LCNF.LetValue pu → Sort u} →
(t : Lean.Compiler.LCNF.LetValue pu) →
((ty : Lean.Expr) →
(fvarId : Lean.FVarId) →
(h : pu = Lean.Compiler.LCNF.Purity.impure) → motive (Lean.Compiler.LCNF.LetValue.box ty fvarId h)) →
(Nat... | null | false |
ContinuousMultilinearMap.instAddMonoid._proof_5 | Mathlib.Topology.Algebra.Module.Multilinear.Basic | ∀ {R : Type u_1} {ι : Type u_2} {M₁ : ι → Type u_3} {M₂ : Type u_4} [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₂] [inst_5 : (i : ι) → TopologicalSpace (M₁ i)] [inst_6 : TopologicalSpace M₂]
[inst_7 : Continuous... | null | false |
CategoryTheory.GradedNatTrans | 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] →
CategoryTheory.Center V →
... | The type of `A`-graded natural transformations between `V`-functors `F` and `G`.
This is the type of morphisms in `V` from `A` to the `V`-object of natural transformations.
| true |
List.maxIdxOn_lt_length._simp_1 | Init.Data.List.MinMaxIdx | ∀ {β : Type u_1} {α : Type u_2} [inst : LE β] [inst_1 : DecidableLE β] {f : α → β} {xs : List α} (h : xs ≠ []),
(List.maxIdxOn f xs h < xs.length) = True | null | false |
OreLocalization.instCommMonoidWithZero._proof_2 | Mathlib.RingTheory.OreLocalization.Basic | ∀ {R : Type u_1} [inst : CommMonoidWithZero R] {S : Submonoid R} [inst_1 : OreLocalization.OreSet S]
(a : OreLocalization S R), 0 * a = 0 | null | false |
Std.DTreeMap.Internal.Impl.Const.getEntryLT._proof_4 | Std.Data.DTreeMap.Internal.Queries | ∀ {α : Type u_1} {β : Type u_2} [inst : Ord α] [Std.TransOrd α] (k : α) (size : ℕ) (ky : α) (y : β)
(l r : Std.DTreeMap.Internal.Impl α fun x => β),
(∃ a ∈ Std.DTreeMap.Internal.Impl.inner size ky y l r, compare a k = Ordering.lt) →
¬compare k ky = Ordering.gt → ∃ a ∈ l, compare a k = Ordering.lt | null | false |
MeasureTheory.ae_eq_of_forall_setIntegral_eq_of_sigmaFinite | Mathlib.MeasureTheory.Function.AEEqOfIntegral | ∀ {α : Type u_1} {E : Type u_2} {m0 : MeasurableSpace α} {μ : MeasureTheory.Measure α} [inst : NormedAddCommGroup E]
[inst_1 : NormedSpace ℝ E] [CompleteSpace E] [MeasureTheory.SigmaFinite μ] {f g : α → E},
(∀ (s : Set α), MeasurableSet s → μ s < ⊤ → MeasureTheory.IntegrableOn f s μ) →
(∀ (s : Set α), Measurabl... | null | true |
CategoryTheory.Mat_.lift_map | Mathlib.CategoryTheory.Preadditive.Mat | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.Preadditive C] {D : Type u₁}
[inst_2 : CategoryTheory.Category.{v₁, u₁} D] [inst_3 : CategoryTheory.Preadditive D]
[inst_4 : CategoryTheory.Limits.HasFiniteBiproducts D] (F : CategoryTheory.Functor C D) [inst_5 : F.Additive]
{X Y... | null | true |
Meromorphic.sub | Mathlib.Analysis.Meromorphic.Basic | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_3} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {f g : 𝕜 → E}, Meromorphic f → Meromorphic g → Meromorphic (f - g) | null | true |
Batteries.Random.MersenneTwister.State.mk.inj | Batteries.Data.Random.MersenneTwister | ∀ {cfg : Batteries.Random.MersenneTwister.Config} {data : Vector (BitVec cfg.wordSize) cfg.stateSize}
{index : Fin cfg.stateSize} {data_1 : Vector (BitVec cfg.wordSize) cfg.stateSize} {index_1 : Fin cfg.stateSize},
{ data := data, index := index } = { data := data_1, index := index_1 } → data = data_1 ∧ index = ind... | null | true |
IsSepClosure.mk._flat_ctor | Mathlib.FieldTheory.IsSepClosed | ∀ {k : Type u} [inst : Field k] {K : Type v} [inst_1 : Field K] [inst_2 : Algebra k K],
IsSepClosed K → Algebra.IsSeparable k K → IsSepClosure k K | null | false |
CategoryTheory.Functor.Final.coconesEquiv._proof_2 | Mathlib.CategoryTheory.Limits.Final | ∀ {C : Type u_4} [inst : CategoryTheory.Category.{u_3, u_4} C] {D : Type u_6}
[inst_1 : CategoryTheory.Category.{u_5, u_6} D] (F : CategoryTheory.Functor C D) [inst_2 : F.Final] {E : Type u_2}
[inst_3 : CategoryTheory.Category.{u_1, u_2} E] (G : CategoryTheory.Functor D E)
(c : CategoryTheory.Limits.Cocone (F.com... | null | false |
MeasurableEmbedding.map_withDensity_rnDeriv | Mathlib.MeasureTheory.Measure.Decomposition.RadonNikodym | ∀ {α : Type u_1} {β : Type u_2} {m : MeasurableSpace α} {mβ : MeasurableSpace β} {f : α → β},
MeasurableEmbedding f →
∀ (μ ν : MeasureTheory.Measure α) [MeasureTheory.SigmaFinite μ] [MeasureTheory.SigmaFinite ν],
MeasureTheory.Measure.map f (ν.withDensity (μ.rnDeriv ν)) =
(MeasureTheory.Measure.map ... | null | true |
Mathlib.Tactic.Linarith.SimplexAlgorithm.UsableInSimplexAlgorithm.swapRows | Mathlib.Tactic.Linarith.Oracle.SimplexAlgorithm.Datatypes | {α : ℕ → ℕ → Type} →
[self : Mathlib.Tactic.Linarith.SimplexAlgorithm.UsableInSimplexAlgorithm α] → {n m : ℕ} → α n m → ℕ → ℕ → α n m | Swaps two rows. | true |
_private.Init.Data.String.Decode.0.ByteArray.utf8DecodeChar?.isInvalidContinuationByte_getElem_utf8EncodeChar_one_of_utf8Size_eq_two | Init.Data.String.Decode | ∀ {c : Char} (hc : c.utf8Size = 2),
ByteArray.utf8DecodeChar?.isInvalidContinuationByte (String.utf8EncodeChar c)[1] = false | null | true |
Subgroup.IsArithmetic.conj | Mathlib.NumberTheory.ModularForms.CongruenceSubgroups | ∀ (𝒢 : Subgroup (GL (Fin 2) ℝ)) [𝒢.IsArithmetic] (g : GL (Fin 2) ℚ),
(ConjAct.toConjAct ((Matrix.GeneralLinearGroup.map (Rat.castHom ℝ)) g) • 𝒢).IsArithmetic | Conjugation by `GL(2, ℚ)` preserves arithmetic subgroups. | true |
Submodule.comapSubtypeEquivOfLe_symm_apply | Mathlib.Algebra.Module.Submodule.Map | ∀ {R : Type u_1} {M : Type u_5} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
{p q : Submodule R M} (hpq : p ≤ q) (x : ↥p), (Submodule.comapSubtypeEquivOfLe hpq).symm x = ⟨⟨↑x, ⋯⟩, ⋯⟩ | null | true |
CategoryTheory.Triangulated.Octahedron.map._proof_5 | Mathlib.CategoryTheory.Triangulated.Functor | ∀ {C : Type u_4} {D : Type u_2} [inst : CategoryTheory.Category.{u_3, u_4} C]
[inst_1 : CategoryTheory.Category.{u_1, u_2} D] [inst_2 : CategoryTheory.HasShift C ℤ]
[inst_3 : CategoryTheory.HasShift D ℤ] [inst_4 : CategoryTheory.Limits.HasZeroObject C]
[inst_5 : CategoryTheory.Preadditive C] [inst_6 : ∀ (n : ℤ), ... | null | false |
MvPolynomial.algebraTensorAlgEquiv._proof_1 | Mathlib.RingTheory.TensorProduct.MvPolynomial | ∀ (R : Type u_3) [inst : CommSemiring R] {σ : Type u_1} (A : Type u_2) [inst_1 : CommSemiring A] [inst_2 : Algebra R A],
(Algebra.TensorProduct.lift (Algebra.ofId A (MvPolynomial σ A)) (MvPolynomial.mapAlgHom (Algebra.ofId R A)) ⋯).comp
(MvPolynomial.aeval fun s => 1 ⊗ₜ[R] MvPolynomial.X s) =
AlgHom.id A (M... | null | false |
_private.Mathlib.RingTheory.Valuation.Basic.0.Valuation.restrict_lt_iff._simp_1_1 | Mathlib.RingTheory.Valuation.Basic | ∀ {α : Type u_1} [inst : Monoid α] [inst_1 : Preorder α] {a b : αˣ}, (a < b) = (↑a < ↑b) | null | false |
Lean.Syntax.getArg | Init.Prelude | Lean.Syntax → ℕ → Lean.Syntax | Gets the `i`'th argument of the syntax node. This can also be written `stx[i]`.
Returns `missing` if `i` is out of range.
| true |
_private.Lean.Data.Lsp.Extra.0.Lean.Lsp.instFromJsonDependencyBuildMode.fromJson.match_3 | Lean.Data.Lsp.Extra | (motive : Option String → Sort u_1) →
(x : Option String) → ((tag : String) → motive (some tag)) → (Unit → motive none) → motive x | null | false |
Subalgebra.toSubmodule | Mathlib.Algebra.Algebra.Subalgebra.Basic | {R : Type u} →
{A : Type v} →
[inst : CommSemiring R] → [inst_1 : Semiring A] → [inst_2 : Algebra R A] → Subalgebra R A ↪o Submodule R A | The forgetful map from `Subalgebra` to `Submodule` as an `OrderEmbedding` | true |
UInt64.ofNat | Init.Data.UInt.BasicAux | ℕ → UInt64 | Converts a natural number to a 64-bit unsigned integer, wrapping on overflow.
This function is overridden at runtime with an efficient implementation.
Examples:
* `UInt64.ofNat 5 = 5`
* `UInt64.ofNat 65539 = 65539`
* `UInt64.ofNat 4_294_967_299 = 4_294_967_299`
* `UInt64.ofNat 18_446_744_073_709_551_620 = 4`
| true |
GenContFract.first_cont_eq | Mathlib.Algebra.ContinuedFractions.Translations | ∀ {K : Type u_1} {g : GenContFract K} [inst : DivisionRing K] {gp : GenContFract.Pair K},
g.s.get? 0 = some gp → g.conts 1 = { a := gp.b * g.h + gp.a, b := gp.b } | null | true |
realPart_one | Mathlib.LinearAlgebra.Complex.Module | ∀ {A : Type u_1} [inst : Ring A] [inst_1 : StarRing A] [inst_2 : Module ℂ A] [inst_3 : StarModule ℂ A], realPart 1 = 1 | null | true |
IsRightUniformGroup.toIsTopologicalGroup | Mathlib.Topology.Algebra.IsUniformGroup.Defs | ∀ {G : Type u_7} {inst : UniformSpace G} {inst_1 : Group G} [self : IsRightUniformGroup G], IsTopologicalGroup G | null | true |
Std.DTreeMap.Internal.Impl.Const.get!_insertManyIfNewUnit_empty_list | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {instOrd : Ord α} {l : List α} {k : α},
Std.DTreeMap.Internal.Impl.Const.get!
(↑(Std.DTreeMap.Internal.Impl.Const.insertManyIfNewUnit Std.DTreeMap.Internal.Impl.empty l ⋯)) k =
() | null | true |
Lean.Meta.LazyDiscrTree.Cache.rec | Lean.Meta.LazyDiscrTree | {motive : Lean.Meta.LazyDiscrTree.Cache → Sort u} →
((ngen : Lean.NameGenerator) →
(core : Lean.Core.Cache) → («meta» : Lean.Meta.Cache) → motive { ngen := ngen, core := core, «meta» := «meta» }) →
(t : Lean.Meta.LazyDiscrTree.Cache) → motive t | null | false |
_private.Std.Data.DHashMap.Internal.AssocList.Lemmas.0.Std.DHashMap.Internal.AssocList.foldlM.eq_2 | Std.Data.DHashMap.Internal.AssocList.Lemmas | ∀ {α : Type u} {β : α → Type v} {δ : Type w} {m : Type w → Type w'} [inst : Monad m] (f : δ → (a : α) → β a → m δ)
(x : δ) (a : α) (b : β a) (es : Std.DHashMap.Internal.AssocList α β),
Std.DHashMap.Internal.AssocList.foldlM f x (Std.DHashMap.Internal.AssocList.cons a b es) = do
let d ← f x a b
Std.DHashMap.... | null | true |
Finset.zsmul.eq_1 | Mathlib.Algebra.Group.Pointwise.Finset.Basic | ∀ {α : Type u_2} [inst : DecidableEq α] [inst_1 : Zero α] [inst_2 : Add α] [inst_3 : Neg α],
Finset.zsmul = { smul := fun x x_1 => zsmulRec nsmulRec x x_1 } | null | true |
MeasurableEquiv.map_measurableEquiv_injective | Mathlib.MeasureTheory.Measure.Map | ∀ {α : Type u_1} {β : Type u_2} {x : MeasurableSpace α} [inst : MeasurableSpace β] (e : α ≃ᵐ β),
Function.Injective (MeasureTheory.Measure.map ⇑e) | null | true |
Finsupp.some_zero | Mathlib.Data.Finsupp.Option | ∀ {α : Type u_1} {M : Type u_2} [inst : Zero M], Finsupp.some 0 = 0 | null | true |
CategoryTheory.Pi.ext | Mathlib.CategoryTheory.Pi.Basic | ∀ {I : Type w₀} (C : I → Type u₁) [inst : (i : I) → CategoryTheory.Category.{v₁, u₁} (C i)] {X Y : (i : I) → C i}
{f g : X ⟶ Y}, (∀ (i : I), f i = g i) → f = g | null | true |
CategoryTheory.Limits.ReflectsColimitsOfShape | Mathlib.CategoryTheory.Limits.Preserves.Basic | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{D : Type u₂} →
[inst_1 : CategoryTheory.Category.{v₂, u₂} D] →
(J : Type w) → [CategoryTheory.Category.{w', w} J] → CategoryTheory.Functor C D → Prop | A functor `F : C ⥤ D` reflects colimits of shape `J` if
whenever the image of a cocone over some `K : J ⥤ C` under `F` is a colimit cocone in `D`,
the cocone was already a colimit cocone in `C`.
Note that we do not assume a priori that `D` actually has any colimits.
| true |
CategoryTheory.Limits.PullbackCone.IsLimit.hom_ext | Mathlib.CategoryTheory.Limits.Shapes.Pullback.PullbackCone | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y Z : C} {f : X ⟶ Z} {g : Y ⟶ Z}
{t : CategoryTheory.Limits.PullbackCone f g} (ht : CategoryTheory.Limits.IsLimit t) {W : C} {k l : W ⟶ t.pt},
CategoryTheory.CategoryStruct.comp k t.fst = CategoryTheory.CategoryStruct.comp l t.fst →
CategoryTheory.Cate... | null | true |
LieAlgebra.lieCharacterEquivLinearDual_symm_apply | Mathlib.Algebra.Lie.Character | ∀ {R : Type u} {L : Type v} [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : LieAlgebra R L] [inst_3 : IsLieAbelian L]
(ψ : Module.Dual R L), LieAlgebra.lieCharacterEquivLinearDual.symm ψ = { toLinearMap := ψ, map_lie' := ⋯ } | null | true |
_private.Mathlib.Combinatorics.Matroid.Constructions.0.Matroid.empty_isBase_iff._simp_1_4 | Mathlib.Combinatorics.Matroid.Constructions | ∀ {α : Type u_1} {M₁ M₂ : Matroid α}, (M₁ = M₂) = (M₁.E = M₂.E ∧ ∀ ⦃I : Set α⦄, I ⊆ M₁.E → (M₁.Indep I ↔ M₂.Indep I)) | null | false |
chart_mem_atlas | Mathlib.Geometry.Manifold.ChartedSpace | ∀ (H : Type u_5) {M : Type u_6} [inst : TopologicalSpace H] [inst_1 : TopologicalSpace M] [inst_2 : ChartedSpace H M]
(x : M), chartAt H x ∈ atlas H M | null | true |
Lean.Meta.SparseCasesOnInfo.recOn | Lean.Meta.Constructions.SparseCasesOn | {motive : Lean.Meta.SparseCasesOnInfo → Sort u} →
(t : Lean.Meta.SparseCasesOnInfo) →
((indName : Lean.Name) →
(majorPos arity : ℕ) →
(insterestingCtors : Array Lean.Name) →
motive
{ indName := indName, majorPos := majorPos, arity := arity, insterestingCtors := insteres... | null | false |
IsReduced.mk._flat_ctor | Mathlib.Algebra.GroupWithZero.Basic | ∀ {R : Type u_5} [inst : Zero R] [inst_1 : Pow R ℕ], (∀ (x : R), IsNilpotent x → x = 0) → IsReduced R | null | false |
CategoryTheory.Limits.FormalCoproduct.evalOpCompInlIsoId._proof_7 | Mathlib.CategoryTheory.Limits.FormalCoproducts.Basic | ∀ (C : Type u_3) [inst : CategoryTheory.Category.{u_1, u_3} C] (A : Type u_4)
[inst_1 : CategoryTheory.Category.{u_2, u_4} A] [inst_2 : CategoryTheory.Limits.HasProducts A]
{X Y : CategoryTheory.Functor Cᵒᵖ A} (f : X ⟶ Y),
CategoryTheory.CategoryStruct.comp
(((CategoryTheory.Limits.FormalCoproduct.evalOp C ... | null | false |
_private.Lean.Elab.MutualDef.0.Lean.Elab.Term.elabFunValues.match_5 | Lean.Elab.MutualDef | (motive : Option Lean.Elab.BodyProcessedSnapshot → Sort u_1) →
(x : Option Lean.Elab.BodyProcessedSnapshot) →
((old : Lean.Elab.BodyProcessedSnapshot) → motive (some old)) →
((x : Option Lean.Elab.BodyProcessedSnapshot) → motive x) → motive x | null | false |
_private.Mathlib.Combinatorics.SimpleGraph.Triangle.Tripartite.0.SimpleGraph.TripartiteFromTriangles.Graph.in₂₁_iff.match_1_1 | Mathlib.Combinatorics.SimpleGraph.Triangle.Tripartite | ∀ {α : Type u_1} {β : Type u_3} {γ : Type u_2} {t : Finset (α × β × γ)} {b : β} {c : γ}
(motive : (∃ a, (a, b, c) ∈ t) → Prop) (x : ∃ a, (a, b, c) ∈ t), (∀ (w : α) (h : (w, b, c) ∈ t), motive ⋯) → motive x | null | false |
Std.Internal.Parsec.instReprParseResult | Std.Internal.Parsec.Basic | {α ι : Type} → [Repr α] → [Repr ι] → Repr (Std.Internal.Parsec.ParseResult α ι) | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.