name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
MonoidHom.toLocalizationMap._proof_2 | Mathlib.GroupTheory.MonoidLocalization.Basic | ∀ {M : Type u_1} [inst : CommMonoid M] {S : Submonoid M} {N : Type u_2} [inst_1 : CommMonoid N] (f : M →* N),
(∀ (y : ↥S), IsUnit (f ↑y)) →
(∀ (z : N), ∃ x, z * f ↑x.2 = f x.1) →
(∀ (x y : M), f x = f y → ∃ c, ↑c * x = ↑c * y) → S.IsLocalizationMap (↑f).toFun | null | false |
Real.not_DifferentiableAt_log_mul_zero | Mathlib.Analysis.SpecialFunctions.Log.NegMulLog | ¬DifferentiableAt ℝ (fun x => x * Real.log x) 0 | At `x=0`, `(fun x ↦ x * log x)` is not differentiable
(but note that it is continuous, see `continuous_mul_log`). | true |
Mathlib.Tactic.CancelDenoms.CancelResult.recOn | Mathlib.Tactic.CancelDenoms.Core | {u : Lean.Level} →
{α : Q(Type u)} →
{mα : Q(Mul «$α»)} →
{e v : Q(«$α»)} →
{motive : Mathlib.Tactic.CancelDenoms.CancelResult mα e v → Sort u} →
(t : Mathlib.Tactic.CancelDenoms.CancelResult mα e v) →
((cancelled : Q(«$α»)) →
(pf : Q(«$v» * «$e» = «$cancelled»)... | null | false |
_private.Lean.Elab.Do.Legacy.0.Lean.Elab.Term.Do.destructTuple._proof_2 | Lean.Elab.Do.Legacy | ∀ (uvars : Array Lean.Elab.Term.Do.Var), uvars.size = 1 → 0 < uvars.size | null | false |
NormedAddGroupHom.range_comp_incl_top | Mathlib.Analysis.Normed.Group.Hom | ∀ {V₁ : Type u_3} {V₂ : Type u_4} [inst : SeminormedAddCommGroup V₁] [inst_1 : SeminormedAddCommGroup V₂]
(f : NormedAddGroupHom V₁ V₂), (f.comp (NormedAddGroupHom.incl ⊤)).range = f.range | null | true |
_private.Init.Data.Slice.Array.Lemmas.0.Std.Internal.List.extract_eq_drop_take'._simp_1_5 | Init.Data.Slice.Array.Lemmas | ∀ {α : Type u_1} [inst : LE α] {x y : α}, (x ≥ y) = (y ≤ x) | null | false |
Std.TreeMap.Raw.getKey!_union | Std.Data.TreeMap.Raw.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t₁ t₂ : Std.TreeMap.Raw α β cmp} [Std.TransCmp cmp]
[inst : Inhabited α], t₁.WF → t₂.WF → ∀ {k : α}, (t₁ ∪ t₂).getKey! k = t₂.getKeyD k (t₁.getKey! k) | null | true |
MvPFunctor.instMvQPFObj | Mathlib.Data.QPF.Multivariate.Basic | {n : ℕ} → (P : MvPFunctor.{u_1} n) → MvQPF ↑P | Every polynomial functor is a (trivial) QPF | true |
mem_upperBounds_image2_of_mem_lowerBounds | Mathlib.Order.Bounds.Image | ∀ {α : Type u} {β : Type v} {γ : Type w} [inst : Preorder α] [inst_1 : Preorder β] [inst_2 : Preorder γ] {f : α → β → γ}
{s : Set α} {t : Set β} {a : α} {b : β},
(∀ (b : β), Antitone (Function.swap f b)) →
(∀ (a : α), Antitone (f a)) → a ∈ lowerBounds s → b ∈ lowerBounds t → f a b ∈ upperBounds (Set.image2 f s ... | null | true |
Nat.Partrec.Code.evaln._unary._proof_7 | Mathlib.Computability.PartrecCode | ∀ (k : ℕ) (cf cg : Nat.Partrec.Code),
(invImage (fun x => PSigma.casesOn x fun a a_1 => (a, a_1)) Prod.instWellFoundedRelation).1 ⟨k, cf.prec cg⟩
⟨k.succ, cf.prec cg⟩ | null | false |
CategoryTheory.Limits.chosenCoendFunctor_map | Mathlib.CategoryTheory.Limits.Chosen.End | ∀ {J : Type u_1} {C : Type u_2} [inst : CategoryTheory.Category.{v_1, u_2} C]
[inst_1 : CategoryTheory.Category.{v_2, u_1} J] [inst_2 : CategoryTheory.Limits.ChosenCoendsOfShape J C]
{X Y : CategoryTheory.Functor Jᵒᵖ (CategoryTheory.Functor J C)} (f : X ⟶ Y),
CategoryTheory.Limits.chosenCoendFunctor.map f = Categ... | null | true |
SMulPosStrictMono.toSMulPosMono | Mathlib.Algebra.Order.Module.Defs | ∀ {α : Type u_1} {β : Type u_2} [inst : Zero α] [inst_1 : Zero β] [inst_2 : SMulWithZero α β] [inst_3 : PartialOrder α]
[inst_4 : PartialOrder β] [SMulPosStrictMono α β], SMulPosMono α β | null | true |
DependsOn.dependsOn_lmarginalPartialTraj | Mathlib.Probability.Kernel.IonescuTulcea.PartialTraj | ∀ {X : ℕ → Type u_1} {mX : (n : ℕ) → MeasurableSpace (X n)} {b : ℕ}
{κ : (n : ℕ) → ProbabilityTheory.Kernel ((i : ↥(Finset.Iic n)) → X ↑i) (X (n + 1))}
[∀ (n : ℕ), ProbabilityTheory.IsSFiniteKernel (κ n)] (a : ℕ) {f : ((n : ℕ) → X n) → ENNReal},
DependsOn f ↑(Finset.Iic b) →
Measurable f → DependsOn (Probabil... | If `f` only depends on variables up to rank `b`, its integral from `a` to `b` only depends on
variables up to rank `a`. | true |
CategoryTheory.Limits.Concrete.limit_ext | Mathlib.CategoryTheory.Limits.ConcreteCategory.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {FC : C → C → Type u_1} {CC : C → Type r}
[inst_1 : (X Y : C) → FunLike (FC X Y) (CC X) (CC Y)] [inst_2 : CategoryTheory.ConcreteCategory C FC] {J : Type w}
[inst_3 : CategoryTheory.Category.{t, w} J] (F : CategoryTheory.Functor J C)
[CategoryTheory.Limits.... | null | true |
Std.ExtDTreeMap.getKey!_inter_of_not_mem_right | Std.Data.ExtDTreeMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t₁ t₂ : Std.ExtDTreeMap α β cmp} [inst : Inhabited α]
[inst_1 : Std.TransCmp cmp] {k : α}, k ∉ t₂ → (t₁ ∩ t₂).getKey! k = default | null | true |
List.find?_replicate_eq_some_iff._simp_1 | Init.Data.List.Find | ∀ {α : Type u_1} {n : ℕ} {a b : α} {p : α → Bool},
(List.find? p (List.replicate n a) = some b) = (n ≠ 0 ∧ p a = true ∧ a = b) | null | false |
Lean.IR.Expr.ctor | Lean.Compiler.IR.Basic | Lean.IR.CtorInfo → Array Lean.IR.Arg → Lean.IR.Expr | We use `ctor` mainly for constructing Lean object/tobject values `lean_ctor_object` in the runtime.
This instruction is also used to creat `struct` and `union` return values.
For `union`, only `i.cidx` is relevant. For `struct`, `i` is irrelevant. | true |
OpenNormalSubgroup.pathComponentOne.eq_1 | Mathlib.Topology.Connected.PathComponentOne | ∀ (G : Type u_1) [inst : TopologicalSpace G] [inst_1 : Group G] [inst_2 : IsTopologicalGroup G]
[inst_3 : LocallyPathConnectedSpace G],
OpenNormalSubgroup.pathComponentOne G = { toSubgroup := Subgroup.pathComponentOne G, isOpen' := ⋯, isNormal' := ⋯ } | null | true |
Lean.Meta.MVarRenaming.map._default | Lean.Meta.Match.MVarRenaming | Lean.MVarIdMap Lean.MVarId | null | false |
UInt16.neg_ne_zero | Init.Data.UInt.Lemmas | ∀ {a : UInt16}, -a ≠ 0 ↔ a ≠ 0 | null | true |
Lean.Meta.Simp.instInhabitedContext.default | Lean.Meta.Tactic.Simp.Types | Lean.Meta.Simp.Context | null | true |
Lean.IR.Decl.noConfusion | Lean.Compiler.IR.Basic | {P : Sort u} → {t t' : Lean.IR.Decl} → t = t' → Lean.IR.Decl.noConfusionType P t t' | null | false |
LinearIsometryEquiv.toHomeomorph_injective | Mathlib.Analysis.Normed.Operator.LinearIsometry | ∀ {R : Type u_1} {R₂ : Type u_2} {E : Type u_4} {E₂ : Type u_5} [inst : Semiring R] [inst_1 : Semiring R₂]
{σ₁₂ : R →+* R₂} {σ₂₁ : R₂ →+* R} [inst_2 : RingHomInvPair σ₁₂ σ₂₁] [inst_3 : RingHomInvPair σ₂₁ σ₁₂]
[inst_4 : SeminormedAddCommGroup E] [inst_5 : SeminormedAddCommGroup E₂] [inst_6 : Module R E]
[inst_7 : ... | null | true |
IO.FS.Metadata.modified | Init.System.IO | IO.FS.Metadata → IO.FS.SystemTime | File modification time. | true |
TopologicalSpace.Opens.comap | Mathlib.Topology.Sets.Opens | {α : Type u_2} →
{β : Type u_3} →
[inst : TopologicalSpace α] →
[inst_1 : TopologicalSpace β] → C(α, β) → FrameHom (TopologicalSpace.Opens β) (TopologicalSpace.Opens α) | The preimage of an open set, as an open set. | true |
Lean.Lsp.ClientCapabilities.casesOn | Lean.Data.Lsp.Capabilities | {motive : Lean.Lsp.ClientCapabilities → Sort u} →
(t : Lean.Lsp.ClientCapabilities) →
((textDocument? : Option Lean.Lsp.TextDocumentClientCapabilities) →
(window? : Option Lean.Lsp.WindowClientCapabilities) →
(workspace? : Option Lean.Lsp.WorkspaceClientCapabilities) →
(lean? : Optio... | null | false |
SSet.HomotopyCategory.objEquiv._proof_2 | Mathlib.AlgebraicTopology.SimplicialSet.HomotopyCat | ∀ {X : SSet}, Function.RightInverse (fun x => SSet.HomotopyCategory.mk x) fun x => x.as.as | null | false |
_private.Std.Time.Date.Unit.Day.0.Std.Time.Day.Offset.toMilliseconds._proof_1 | Std.Time.Date.Unit.Day | 86400 / ↑86400000 = 1 / 1000 | null | false |
LocallyConstant.comapAddMonoidHom_apply | Mathlib.Topology.LocallyConstant.Algebra | ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] {Z : Type u_6}
[inst_2 : AddZeroClass Z] (f : C(X, Y)) (g : LocallyConstant Y Z),
(LocallyConstant.comapAddMonoidHom f) g = LocallyConstant.comap f g | null | true |
mul_two | Mathlib.Algebra.Ring.Defs | ∀ {α : Type u} [inst : NonAssocSemiring α] (n : α), n * 2 = n + n | null | true |
_private.Init.Data.BitVec.Bitblast.0.BitVec.addRecAux_eq_of._proof_1_1 | Init.Data.BitVec.Bitblast | ∀ {len' : ℕ}, 0 = (len' + 1) / 2 → ¬len' = 0 → False | null | false |
Lean.Meta.getUInt16Value? | Lean.Meta.LitValues | Lean.Expr → Lean.MetaM (Option UInt16) | Return `some n` if `e` is an `OfNat.ofNat`-application encoding the `UInt16` with value `n`. | true |
NNReal.summable_mul_rpow_of_Lp_Lq | Mathlib.Analysis.MeanInequalities | ∀ {ι : Type u} {f g : ι → NNReal} {p q r : ℝ},
p.HolderTriple q r → (Summable fun i => f i ^ p) → (Summable fun i => g i ^ q) → Summable fun i => (f i * g i) ^ r | null | true |
StrictMonoOn.exists_slope_lt_deriv | Mathlib.Analysis.Convex.Deriv | ∀ {x y : ℝ} {f : ℝ → ℝ},
ContinuousOn f (Set.Icc x y) →
x < y → StrictMonoOn (deriv f) (Set.Ioo x y) → ∃ a ∈ Set.Ioo x y, (f y - f x) / (y - x) < deriv f a | null | true |
Algebra.EssFiniteType.isNoetherianRing | Mathlib.RingTheory.Localization.Submodule | ∀ (R : Type u_3) (S : Type u_4) [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S]
[Algebra.EssFiniteType R S] [IsNoetherianRing R], IsNoetherianRing S | null | true |
Group.IsSolvable.rec | Mathlib.GroupTheory.Solvable | {G : Type u_1} →
[inst : Group G] →
{motive : Group.IsSolvable G → Sort u} →
((solvable : ∃ n, derivedSeries G n = ⊥) → motive ⋯) → (t : Group.IsSolvable G) → motive t | null | false |
MulAction.stabilizerEquivStabilizer.congr_simp | Mathlib.GroupTheory.GroupAction.Basic | ∀ {G : Type u_1} {α : Type u_2} [inst : Group G] [inst_1 : MulAction G α] {g g_1 : G} (e_g : g = g_1) {a b : α}
(hg : b = g • a), MulAction.stabilizerEquivStabilizer hg = MulAction.stabilizerEquivStabilizer ⋯ | null | true |
Algebra.instMulDistribMulActionAlgHomUnits._proof_2 | Mathlib.Algebra.Algebra.Hom | ∀ {R : Type u_2} (A : Type u_1) [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A] (x : Aˣ), 1 • x = x | null | false |
CategoryTheory.Discrete.opposite_inverse_obj | Mathlib.CategoryTheory.Discrete.Basic | ∀ (α : Type u₁) (a : CategoryTheory.Discrete α), (CategoryTheory.Discrete.opposite α).inverse.obj a = Opposite.op a | null | true |
CategoryTheory.Functor.Additive.map_add._autoParam | Mathlib.CategoryTheory.Preadditive.AdditiveFunctor | Lean.Syntax | null | false |
CategoryTheory.PrelaxFunctor.toPrelaxFunctorStruct | Mathlib.CategoryTheory.Bicategory.Functor.Prelax | {B : Type u₁} →
[inst : CategoryTheory.Bicategory B] →
{C : Type u₂} →
[inst_1 : CategoryTheory.Bicategory C] → CategoryTheory.PrelaxFunctor B C → CategoryTheory.PrelaxFunctorStruct B C | The underlying lax prefunctor. | true |
IsLprojection.Subtype.BooleanAlgebra._proof_12 | Mathlib.Analysis.Normed.Module.MStructure | ∀ {X : Type u_2} [inst : NormedAddCommGroup X] {M : Type u_1} [inst_1 : Ring M] [inst_2 : Module M X]
[inst_3 : FaithfulSMul M X] (P Q : { P // IsLprojection X P }), P \ Q = P ⊓ Qᶜ | null | false |
Lean.SimplePersistentEnvExtension | Lean.EnvExtension | Type → Type → Type | Simple `PersistentEnvExtension` that implements `exportEntriesFn` using a list of entries. | true |
hasFTaylorSeriesUpToOn_succ_iff_right | Mathlib.Analysis.Calculus.ContDiff.FTaylorSeries | ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {E : Type uE} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {F : Type uF} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {s : Set E}
{f : E → F} {n : WithTop ℕ∞} {p : E → FormalMultilinearSeries 𝕜 E F},
HasFTaylorSeriesUpToOn (n + 1) ... | `p` is a Taylor series of `f` up to `n+1` if and only if `p.shift` is a Taylor series up to `n`
for `p 1`, which is a derivative of `f`. Version for `n : ℕ∞ω`. | true |
CategoryTheory.MorphismProperty.Under.mapId_hom_app_right | Mathlib.CategoryTheory.MorphismProperty.OverAdjunction | ∀ {T : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} T] {P : CategoryTheory.MorphismProperty T}
(Q : CategoryTheory.MorphismProperty T) [inst_1 : Q.IsMultiplicative] [inst_2 : P.IsStableUnderComposition]
[inst_3 : P.IsMultiplicative] [inst_4 : Q.RespectsIso] (X : T)
(f : optParam (X ⟶ X) (CategoryTheory.Ca... | null | true |
_private.Mathlib.NumberTheory.Modular.0.ModularGroup.case_c_one_d_one | Mathlib.NumberTheory.Modular | ∀ {g : Matrix.SpecialLinearGroup (Fin 2) ℤ} {z : UpperHalfPlane},
z ∈ ModularGroup.fd →
g • z ∈ ModularGroup.fd →
‖UpperHalfPlane.denom (Matrix.SpecialLinearGroup.toGL ((Matrix.SpecialLinearGroup.map (Int.castRingHom ℝ)) g))
↑z‖ ≤
1 →
↑g 1 0 = 1 →
↑g 1 1 = 1 →
... | null | true |
MeasureTheory.eLpNorm'_congr_nnnorm_ae | Mathlib.MeasureTheory.Function.LpSeminorm.Basic | ∀ {α : Type u_1} {F : Type u_6} {G : Type u_7} {m0 : MeasurableSpace α} {q : ℝ} {μ : MeasureTheory.Measure α}
[inst : NormedAddCommGroup F] [inst_1 : NormedAddCommGroup G] {f : α → F} {g : α → G},
(∀ᵐ (x : α) ∂μ, ‖f x‖₊ = ‖g x‖₊) → MeasureTheory.eLpNorm' f q μ = MeasureTheory.eLpNorm' g q μ | null | true |
LinearMap.continuousAt_zero_of_locally_bounded | Mathlib.Analysis.LocallyConvex.ContinuousOfBounded | ∀ {𝕜 : Type u_1} {𝕜' : Type u_2} {E : Type u_3} {F : Type u_4} [inst : AddCommGroup E] [inst_1 : TopologicalSpace E]
[IsTopologicalAddGroup E] [inst_3 : AddCommGroup F] [inst_4 : TopologicalSpace F] [inst_5 : NontriviallyNormedField 𝕜]
[inst_6 : Module 𝕜 E] [ContinuousSMul 𝕜 E] [inst_8 : NormedField 𝕜'] [inst... | null | true |
DistribMulActionHom.rec | Mathlib.GroupTheory.GroupAction.Hom | {M : Type u_1} →
[inst : Monoid M] →
{N : Type u_2} →
[inst_1 : Monoid N] →
{φ : M →* N} →
{A : Type u_10} →
[inst_2 : AddMonoid A] →
[inst_3 : DistribMulAction M A] →
{B : Type u_11} →
[inst_4 : AddMonoid B] →
... | null | false |
MonadCont.Label.noConfusion | Mathlib.Control.Monad.Cont | {P : Sort u_1} →
{α : Type w} →
{m : Type u → Type v} →
{β : Type u} →
{t : MonadCont.Label α m β} →
{α' : Type w} →
{m' : Type u → Type v} →
{β' : Type u} →
{t' : MonadCont.Label α' m' β'} →
α = α' → m = m' → β = β' → t ≍ t' → Mo... | null | false |
Aesop.GoalData.mk.sizeOf_spec | Aesop.Tree.Data | ∀ {Rapp MVarCluster : Type} [inst : SizeOf Rapp] [inst_1 : SizeOf MVarCluster] (id : Aesop.GoalId)
(parent : IO.Ref MVarCluster) (children : Array (IO.Ref Rapp)) (origin : Aesop.GoalOrigin) (depth : ℕ)
(state : Aesop.GoalState) (isIrrelevant isForcedUnprovable : Bool) (preNormGoal : Lean.MVarId)
(normalizationSta... | null | true |
RightOrdContinuous.toOrderEmbedding | Mathlib.Order.OrdContinuous | {α : Type u} →
{β : Type v} →
[inst : SemilatticeInf α] →
[inst_1 : SemilatticeInf β] → (f : α → β) → RightOrdContinuous f → Function.Injective f → α ↪o β | Convert an injective right order continuous function to an order embedding. | true |
Complex.tan_add_int_mul_pi | Mathlib.Analysis.SpecialFunctions.Trigonometric.Basic | ∀ (x : ℂ) (n : ℤ), Complex.tan (x + ↑n * ↑Real.pi) = Complex.tan x | null | true |
AddQuantale.rec | Mathlib.Algebra.Order.Quantale | {α : Type u_1} →
[inst : AddSemigroup α] →
[inst_1 : CompleteLattice α] →
[inst_2 : IsAddQuantale α] → {motive : AddQuantale α → Sort u} → motive { } → (t : AddQuantale α) → motive t | null | false |
MeasurableSpace.GenerateMeasurable.below.compl | Mathlib.MeasureTheory.MeasurableSpace.Defs | ∀ {α : Type u_1} {s : Set (Set α)} {motive : (a : Set α) → MeasurableSpace.GenerateMeasurable s a → Prop} (t : Set α)
(a : MeasurableSpace.GenerateMeasurable s t),
MeasurableSpace.GenerateMeasurable.below a → motive t a → MeasurableSpace.GenerateMeasurable.below ⋯ | null | true |
Lean.ParserDescr.recOn | Init.Prelude | {motive : Lean.ParserDescr → Sort u} →
(t : Lean.ParserDescr) →
((name : Lean.Name) → motive (Lean.ParserDescr.const name)) →
((name : Lean.Name) → (p : Lean.ParserDescr) → motive p → motive (Lean.ParserDescr.unary name p)) →
((name : Lean.Name) →
(p₁ p₂ : Lean.ParserDescr) → motive p₁ →... | null | false |
_private.Mathlib.Data.Fin.Tuple.Reflection.0.FinVec.mkProdEqQ.makeRHS._f | Mathlib.Data.Fin.Tuple.Reflection | {u : Lean.Level} →
{α : Q(Type u)} →
Q(CommMonoid «$α») → (n : ℕ) → Q(Fin «$n» → «$α») → Q(NeZero «$n») → (k : ℕ) → Nat.below k → Lean.MetaM Q(«$α») | null | false |
_private.Mathlib.Topology.LocallyClosed.0.isLocallyClosedAt_tfae._proof_1_10 | Mathlib.Topology.LocallyClosed | ∀ {X : Type u_1} [inst : TopologicalSpace X] (s : Set X) (x : X),
(∃ U ∈ nhds x, ∃ Z, IsClosed Z ∧ ∀ x ∈ U, x ∈ s ↔ x ∈ Z) ↔ ∃ Z, IsClosed Z ∧ ∃ v ∈ nhds x, ∀ y ∈ v, y ∈ s ↔ y ∈ Z | null | false |
String.takeWhile_append_dropWhile | Init.Data.String.Lemmas.Pattern.TakeDrop.Basic | ∀ {ρ : Type} {pat : ρ} [String.Slice.Pattern.Model.PatternModel pat] [inst : String.Slice.Pattern.ForwardPattern pat]
[String.Slice.Pattern.LawfulForwardPattern pat] {s : String}, (s.takeWhile pat).copy ++ (s.dropWhile pat).copy = s | null | true |
FormalMultilinearSeries.restrictScalars.congr_simp | Mathlib.Analysis.SpecialFunctions.Complex.Analytic | ∀ (𝕜 : Type u) {𝕜' : Type u'} {E : Type v} {F : Type w} [inst : Semiring 𝕜] [inst_1 : AddCommMonoid E]
[inst_2 : Module 𝕜 E] [inst_3 : TopologicalSpace E] [inst_4 : ContinuousAdd E] [inst_5 : ContinuousConstSMul 𝕜 E]
[inst_6 : AddCommMonoid F] [inst_7 : Module 𝕜 F] [inst_8 : TopologicalSpace F] [inst_9 : Cont... | null | true |
CategoryTheory.Limits.createsColimitsOfSizeLeftOp | Mathlib.CategoryTheory.Limits.Preserves.Creates.Opposites | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{D : Type u₂} →
[inst_1 : CategoryTheory.Category.{v₂, u₂} D] →
(F : CategoryTheory.Functor C Dᵒᵖ) →
[CategoryTheory.CreatesLimitsOfSize.{w, w', v₁, v₂, u₁, u₂} F] →
CategoryTheory.CreatesColimitsOfSize.{w, w', v₁, v... | If `F : C ⥤ Dᵒᵖ` creates limits, then `F.leftOp : Cᵒᵖ ⥤ D` creates colimits. | true |
ContinuousCohomology.cocycles₀Iso._proof_4 | Mathlib.RepresentationTheory.Homological.ContCohomology.LowDegree | ∀ {k : Type u_3} {G : Type u_1} [inst : Ring k] [inst_1 : Group G] [inst_2 : TopologicalSpace k]
[inst_3 : TopologicalSpace G] [inst_4 : IsTopologicalGroup G] (X : TopRep k G),
CategoryTheory.CategoryStruct.comp (HomologicalComplex.iCycles X.homogeneousCochains 0)
(X.homogeneousCochains.d 0 1) =
0 | null | false |
Std.Sat.AIG.RefVec.fold.congr_simp | Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Eq | ∀ {α : Type} [inst : Hashable α] [inst_1 : DecidableEq α] {len : ℕ} (aig : Std.Sat.AIG α) (vec vec_1 : aig.RefVec len),
vec = vec_1 →
∀ (func func_1 : (aig : Std.Sat.AIG α) → aig.BinaryInput → Std.Sat.AIG.Entrypoint α) (e_func : func = func_1)
[inst_2 : Std.Sat.AIG.LawfulOperator α Std.Sat.AIG.BinaryInput f... | null | true |
_private.Mathlib.LinearAlgebra.Eigenspace.Zero.0.LinearMap.hasEigenvalue_zero_tfae.match_1_6 | Mathlib.LinearAlgebra.Eigenspace.Zero | ∀ {K : Type u_2} {M : Type u_1} [inst : Field K] [inst_1 : AddCommGroup M] [inst_2 : Module K M] (φ : Module.End K M)
(motive : (∃ m, m ≠ 0 ∧ φ m = 0) → Prop) (x : ∃ m, m ≠ 0 ∧ φ m = 0),
(∀ (x : M) (h1 : x ≠ 0) (h2 : φ x = 0), motive ⋯) → motive x | null | false |
ContextFreeGrammar.Generates.eq_1 | Mathlib.Computability.ContextFreeGrammar | ∀ {T : Type u_1} (g : ContextFreeGrammar T) (s : List (Symbol T g.NT)),
g.Generates s = g.Derives [Symbol.nonterminal g.initial] s | null | true |
AlgebraicGeometry.smoothOfRelativeDimension_comp | Mathlib.AlgebraicGeometry.Morphisms.Smooth | ∀ (n m : ℕ) {X Y : AlgebraicGeometry.Scheme} (f : X ⟶ Y) {Z : AlgebraicGeometry.Scheme} (g : Y ⟶ Z)
[hf : AlgebraicGeometry.SmoothOfRelativeDimension n f] [hg : AlgebraicGeometry.SmoothOfRelativeDimension m g],
AlgebraicGeometry.SmoothOfRelativeDimension (n + m) (CategoryTheory.CategoryStruct.comp f g) | If `f` is smooth of relative dimension `n` and `g` is smooth of relative dimension
`m`, then `f ≫ g` is smooth of relative dimension `n + m`. | true |
LieAlgebra.Basis.baseSupp'._proof_4 | Mathlib.Algebra.Lie.Basis.Base | ∀ {K : Type u_2} {L : Type u_1} [inst : Field K] [CharZero K] [inst_2 : LieRing L] [inst_3 : LieAlgebra K L]
[FiniteDimensional K L] {H : LieSubalgebra K L} {ι : Type u_3} [inst_5 : Fintype ι] (b : LieAlgebra.Basis ι H),
LieRing.IsNilpotent ↥H | null | false |
TensorProduct.AlgebraTensorModule.ext | Mathlib.LinearAlgebra.TensorProduct.Tower | ∀ {R : Type uR} {A : Type uA} {M : Type uM} {N : Type uN} {P : Type uP} [inst : CommSemiring R] [inst_1 : Semiring A]
[inst_2 : Algebra R A] [inst_3 : AddCommMonoid M] [inst_4 : Module R M] [inst_5 : Module A M]
[inst_6 : IsScalarTower R A M] [inst_7 : AddCommMonoid N] [inst_8 : Module R N] [inst_9 : AddCommMonoid ... | null | true |
Lean.Lsp.TextDocumentContentChangeEvent.rec | Lean.Data.Lsp.TextSync | {motive : Lean.Lsp.TextDocumentContentChangeEvent → Sort u} →
((range : Lean.Lsp.Range) →
(text : String) → motive (Lean.Lsp.TextDocumentContentChangeEvent.rangeChange range text)) →
((text : String) → motive (Lean.Lsp.TextDocumentContentChangeEvent.fullChange text)) →
(t : Lean.Lsp.TextDocumentConten... | null | false |
_private.Mathlib.Data.Nat.Bits.0.Nat.bodd_eq_one_and_ne_zero.match_1_1 | Mathlib.Data.Nat.Bits | ∀ (motive : ℕ → Prop) (x : ℕ),
(∀ (_ : Unit), motive 0) → (∀ (_ : Unit), motive 1) → (∀ (n : ℕ), motive n.succ.succ) → motive x | null | false |
SimpleGraph.Walk.adj_snd._simp_1 | Mathlib.Combinatorics.SimpleGraph.Walk.Traversal | ∀ {V : Type u} {G : SimpleGraph V} {v w : V} {p : G.Walk v w}, ¬p.Nil → G.1 v p.snd = True | null | false |
FloorSemiring.mk | Mathlib.Algebra.Order.Floor.Defs | {α : Type u_3} →
[inst : Semiring α] →
[inst_1 : PartialOrder α] →
(floor ceil : α → ℕ) →
(∀ {a : α}, a < 0 → floor a = 0) →
(∀ {a : α} {n : ℕ}, 0 ≤ a → (n ≤ floor a ↔ ↑n ≤ a)) → GaloisConnection ceil Nat.cast → FloorSemiring α | null | true |
SchwartzMap.iteratedLineDerivOp_eq_iteratedFDeriv | Mathlib.Analysis.Distribution.SchwartzSpace.Deriv | ∀ {E : Type u_4} {F : Type u_7} [inst : NormedAddCommGroup E] [inst_1 : NormedAddCommGroup F] [inst_2 : NormedSpace ℝ F]
[inst_3 : NormedSpace ℝ E] {n : ℕ} {m : Fin n → E} {f : SchwartzMap E F} {x : E},
(LineDeriv.iteratedLineDerivOp m f) x = (iteratedFDeriv ℝ n (⇑f) x) m | null | true |
CategoryTheory.MorphismProperty.IsStableUnderFilteredColimits.mk._flat_ctor | Mathlib.CategoryTheory.MorphismProperty.Limits | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {W : CategoryTheory.MorphismProperty C},
autoParam
(∀ (J : Type w') [inst_1 : CategoryTheory.Category.{w, w'} J] [CategoryTheory.IsFiltered J],
W.IsStableUnderColimitsOfShape J)
CategoryTheory.MorphismProperty.IsStableUnderFilteredColimits.i... | null | false |
Set.Iio_subset_Iic_self | Mathlib.Order.Interval.Set.Basic | ∀ {α : Type u_1} [inst : Preorder α] {a : α}, Set.Iio a ⊆ Set.Iic a | null | true |
Real.binEntropy_eq_negMulLog_add_negMulLog_one_sub | Mathlib.Analysis.SpecialFunctions.BinaryEntropy | ∀ (p : ℝ), Real.binEntropy p = p.negMulLog + (1 - p).negMulLog | null | true |
RelSeries.coe_ofLE | Mathlib.Order.RelSeries | ∀ {α : Type u_1} {r : SetRel α α} (x : RelSeries r) {s : SetRel α α} (h : r ⊆ s), (x.ofLE h).toFun = x.toFun | null | true |
Equiv.Perm.Disjoint.cycleOf_mul_distrib | Mathlib.GroupTheory.Perm.Cycle.Factors | ∀ {α : Type u_1} {f g : Equiv.Perm α} [inst : DecidableRel f.SameCycle] [inst_1 : DecidableRel g.SameCycle]
[inst_2 : DecidableRel (f * g).SameCycle], f.Disjoint g → ∀ (x : α), (f * g).cycleOf x = f.cycleOf x * g.cycleOf x | null | true |
Function.support_binop_subset | Mathlib.Algebra.Notation.Support | ∀ {ι : Type u_1} {M : Type u_3} {N : Type u_4} {P : Type u_5} [inst : Zero M] [inst_1 : Zero N] [inst_2 : Zero P]
(op : M → N → P),
op 0 0 = 0 →
∀ (f : ι → M) (g : ι → N), (Function.support fun x => op (f x) (g x)) ⊆ Function.support f ∪ Function.support g | null | true |
Turing.PartrecToTM2.instDecidableEqCont'.decEq._proof_30 | Mathlib.Computability.TuringMachine.ToPartrec | ∀ (a : Turing.ToPartrec.Code) (a_1 : Turing.PartrecToTM2.Cont'),
Turing.PartrecToTM2.Cont'.comp a a_1 = Turing.PartrecToTM2.Cont'.comp a a_1 | null | false |
ImportGraph.Lake.BaseWorkspace.mk | ImportGraph.WorkspaceModel.Base | System.FilePath →
System.FilePath →
System.FilePath →
System.FilePath →
System.FilePath → Option Lake.ToolchainVer → String → System.FilePath → ImportGraph.Lake.BaseWorkspace | null | true |
LinearMap.mulLeft_one | Mathlib.Algebra.Module.LinearMap.Basic | ∀ (R : Type u_6) (A : Type u_7) [inst : Semiring R] [inst_1 : NonAssocSemiring A] [inst_2 : Module R A]
[inst_3 : SMulCommClass R A A], LinearMap.mulLeft R 1 = LinearMap.id | null | true |
_private.Mathlib.Tactic.ComputeAsymptotics.Multiseries.Monomial.Basic.0.Tactic.ComputeAsymptotics.UnitMonomial.isLittleO_of_lt._proof_1_11 | Mathlib.Tactic.ComputeAsymptotics.Multiseries.Monomial.Basic | ∀ (basis_hd : ℝ → ℝ) (basis_tl : List (ℝ → ℝ)) (exp1 : ℝ) (m1 : List ℝ) (exp2 : ℝ) (m2 : List ℝ),
m1.length = basis_tl.length →
m2.length = basis_tl.length →
((exp2 - exp1) ::
Tactic.ComputeAsymptotics.UnitMonomial.mul m2 (Tactic.ComputeAsymptotics.UnitMonomial.inv m1)).length =
(basis_h... | null | false |
CategoryTheory.instIsEquivalenceOppositeUnopUnop | Mathlib.CategoryTheory.Opposites | ∀ (C : Type u₁) [inst : CategoryTheory.Category.{v₁, u₁} C], (CategoryTheory.unopUnop C).IsEquivalence | null | true |
_private.Mathlib.CategoryTheory.Triangulated.Yoneda.0.CategoryTheory.Pretriangulated.preadditiveCoyoneda_homologySequenceδ_apply._proof_1 | Mathlib.CategoryTheory.Triangulated.Yoneda | ∀ (n₀ n₁ : ℤ), n₀ + 1 = n₁ → 1 + n₀ = n₁ | null | false |
CategoryTheory.Limits.coequalizer.isoTargetOfSelf | Mathlib.CategoryTheory.Limits.Shapes.Equalizers | {C : Type u} →
{X Y : C} → [inst : CategoryTheory.Category.{v, u} C] → (f : Y ⟶ X) → CategoryTheory.Limits.coequalizer f f ≅ X | The coequalizer of a morphism with itself is isomorphic to the target. | true |
IsOrderConnected.casesOn | Mathlib.Order.RelClasses | {α : Type u} →
{lt : α → α → Prop} →
{motive : IsOrderConnected α lt → Sort u_1} →
(t : IsOrderConnected α lt) → ((conn : ∀ (a b c : α), lt a c → lt a b ∨ lt b c) → motive ⋯) → motive t | null | false |
Lean.Elab.Tactic.RCases.RCasesPatt.explicit.noConfusion | Lean.Elab.Tactic.RCases | {P : Sort u} →
{ref : Lean.Syntax} →
{a : Lean.Elab.Tactic.RCases.RCasesPatt} →
{ref' : Lean.Syntax} →
{a' : Lean.Elab.Tactic.RCases.RCasesPatt} →
Lean.Elab.Tactic.RCases.RCasesPatt.explicit ref a = Lean.Elab.Tactic.RCases.RCasesPatt.explicit ref' a' →
(ref = ref' → a = a' → P)... | null | false |
AddSubgroup.mem_inertia | Mathlib.Algebra.Group.Subgroup.Basic | ∀ {M : Type u_5} [inst : AddGroup M] {I : AddSubgroup M} {G : Type u_6} [inst_1 : Group G] [inst_2 : MulAction G M]
{σ : G}, σ ∈ I.inertia G ↔ ∀ (x : M), σ • x - x ∈ I | null | true |
_private.Init.Data.FloatArray.Basic.0.FloatArray.forIn.loop._f | Init.Data.FloatArray.Basic | {β : Type v} →
{m : Type v → Type w} →
[Monad m] →
(as : FloatArray) →
(Float → β → m (ForInStep β)) →
(i : ℕ) → Nat.below (motive := fun i => i ≤ as.size → β → m β) i → i ≤ as.size → β → m β | null | false |
Heyting.Regular.gi._proof_3 | Mathlib.Order.Heyting.Regular | ∀ {α : Type u_1} [inst : HeytingAlgebra α] (x : Heyting.Regular α), ↑x ≤ (↑x)ᶜᶜ | null | false |
MeromorphicOn.meromorphicOn_sphere_comp_sub_const_iff_meromorphicOn_sphere._simp_2 | Mathlib.Analysis.Meromorphic.Basic | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_3} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {f : 𝕜 → E} {c : 𝕜} {R : ℝ},
MeromorphicOn (f ∘ fun x => x - c) (Metric.sphere c R) = MeromorphicOn f (Metric.sphere 0 R) | null | false |
CategoryTheory.Functor.instFaithfulProdCurry | Mathlib.CategoryTheory.Functor.Currying | ∀ {C : Type u₂} [inst : CategoryTheory.Category.{v₂, u₂} C] {D : Type u₃} [inst_1 : CategoryTheory.Category.{v₃, u₃} D]
{E : Type u₄} [inst_2 : CategoryTheory.Category.{v₄, u₄} E], CategoryTheory.Functor.curry.Faithful | null | true |
Lean.Lsp.instToJsonSignatureHelpOptions.toJson | Lean.Data.Lsp.LanguageFeatures | Lean.Lsp.SignatureHelpOptions → Lean.Json | null | true |
MeasureTheory.FiniteMeasure.continuous_iff_forall_continuousMap_continuous_integral | Mathlib.MeasureTheory.Measure.FiniteMeasure | ∀ {Ω : Type u_1} [inst : MeasurableSpace Ω] [inst_1 : TopologicalSpace Ω] [inst_2 : OpensMeasurableSpace Ω]
{X : Type u_2} [inst_3 : TopologicalSpace X] {μs : X → MeasureTheory.FiniteMeasure Ω} [CompactSpace Ω],
Continuous μs ↔ ∀ (f : C(Ω, ℝ)), Continuous fun x => ∫ (ω : Ω), f ω ∂↑(μs x) | The characterization of weak convergence of finite measures by the usual (defining)
condition that the integrals of every continuous bounded function are continuous. | true |
normHom._proof_1 | Mathlib.Analysis.Normed.Ring.Basic | ∀ {α : Type u_1} [inst : SeminormedRing α], ‖0‖ = 0 | null | false |
_private.Mathlib.Combinatorics.SimpleGraph.Subgraph.0.SimpleGraph.Subgraph.subgraphOfAdj_eq_induce._simp_1_3 | Mathlib.Combinatorics.SimpleGraph.Subgraph | ∀ {α : Type u_1} {x a : α} {s : Set α}, (x ∈ insert a s) = (x = a ∨ x ∈ s) | null | false |
LinearMap.BilinForm.toMatrixAux.eq_1 | Mathlib.LinearAlgebra.Matrix.BilinearForm | ∀ {R₁ : Type u_1} {M₁ : Type u_2} [inst : CommSemiring R₁] [inst_1 : AddCommMonoid M₁] [inst_2 : Module R₁ M₁]
{n : Type u_5} (b : n → M₁), LinearMap.BilinForm.toMatrixAux b = LinearMap.toMatrix₂Aux R₁ b b | null | true |
SimpleGraph.turanGraph._proof_2 | Mathlib.Combinatorics.SimpleGraph.Extremal.Turan | ∀ (n r : ℕ), Std.Symm fun v w => ↑v % r ≠ ↑w % r | null | false |
CategoryTheory.Functor.FullyFaithful.mapCommGrp._proof_4 | Mathlib.CategoryTheory.Monoidal.CommGrp_ | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.CartesianMonoidalCategory C]
[inst_2 : CategoryTheory.BraidedCategory C] {D : Type u_4} [inst_3 : CategoryTheory.Category.{u_3, u_4} D]
[inst_4 : CategoryTheory.CartesianMonoidalCategory D] [inst_5 : CategoryTheory.BraidedCatego... | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.