name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
List.Vector.scanl.eq_1 | Mathlib.Data.Vector.Basic | ∀ {α : Type u_1} {n : ℕ} {β : Type u_6} (f : β → α → β) (b : β) (v : List.Vector α n),
List.Vector.scanl f b v = ⟨List.scanl f b v.toList, ⋯⟩ | true |
_private.Mathlib.AlgebraicGeometry.EllipticCurve.Jacobian.Basic.0.WeierstrassCurve.Jacobian.X_eq_of_equiv._simp_1_2 | Mathlib.AlgebraicGeometry.EllipticCurve.Jacobian.Basic | ∀ {R : Type r} [inst : CommRing R] (P : Fin 3 → R) (u : R), (u • P) 1 = u ^ 3 * P 1 | false |
instSelfSliceSubarrayDataSubarray | Init.Data.Array.Subarray | ∀ {α : Type u}, Std.Slice.Self (Std.Slice (Std.Slice.Internal.SubarrayData α)) (Subarray α) | true |
norm_div | Mathlib.Analysis.Normed.Field.Basic | ∀ {α : Type u_2} [inst : NormedDivisionRing α] (a b : α), ‖a / b‖ = ‖a‖ / ‖b‖ | true |
TietzeExtension.of_homeo | Mathlib.Topology.TietzeExtension | ∀ {Y : Type v} {Z : Type w} [inst : TopologicalSpace Y] [inst_1 : TopologicalSpace Z] [TietzeExtension Z] (e : Y ≃ₜ Z),
TietzeExtension Y | true |
CategoryTheory.Limits.Cotrident.mkHom._proof_1 | Mathlib.CategoryTheory.Limits.Shapes.WideEqualizers | ∀ {J : Type u_1} {C : Type u_3} [inst : CategoryTheory.Category.{u_2, u_3} C] {X Y : C} {f : J → (X ⟶ Y)} [Nonempty J]
{s t : CategoryTheory.Limits.Cotrident f} (k : s.pt ⟶ t.pt),
CategoryTheory.CategoryStruct.comp s.π k = t.π →
∀ (j : CategoryTheory.Limits.WalkingParallelFamily J), CategoryTheory.CategoryStruct.comp (s.ι.app j) k = t.ι.app j | false |
CategoryTheory.Comonad.ComonadicityInternal.main_pair_coreflexive | Mathlib.CategoryTheory.Monad.Comonadicity | ∀ {C : Type u₁} {D : Type u₂} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.Category.{v₁, u₂} D]
{F : CategoryTheory.Functor C D} {G : CategoryTheory.Functor D C} (adj : F ⊣ G) (A : adj.toComonad.Coalgebra),
CategoryTheory.IsCoreflexivePair (G.map A.a) (adj.unit.app (G.obj A.A)) | true |
Batteries.Tactic.Lint.LintVerbosity.low.elim | Batteries.Tactic.Lint.Frontend | {motive : Batteries.Tactic.Lint.LintVerbosity → Sort u} →
(t : Batteries.Tactic.Lint.LintVerbosity) → t.ctorIdx = 0 → motive Batteries.Tactic.Lint.LintVerbosity.low → motive t | false |
TopologicalSpace.Opens.openPartialHomeomorphSubtypeCoe._proof_1 | Mathlib.Topology.OpenPartialHomeomorph.Basic | ∀ {X : Type u_1} [inst : TopologicalSpace X] (s : TopologicalSpace.Opens X), Topology.IsOpenEmbedding Subtype.val | false |
Equiv.Perm.sigmaCongrRightHom | Mathlib.Algebra.Group.End | {α : Type u_7} → (β : α → Type u_8) → ((a : α) → Equiv.Perm (β a)) →* Equiv.Perm ((a : α) × β a) | true |
ContMDiffMap.coeFnAlgHom._proof_7 | Mathlib.Geometry.Manifold.Algebra.SmoothFunctions | ∀ {𝕜 : Type u_3} [inst : NontriviallyNormedField 𝕜] {E : Type u_4} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {H : Type u_5} [inst_3 : TopologicalSpace H] {I : ModelWithCorners 𝕜 E H} {N : Type u_2}
[inst_4 : TopologicalSpace N] [inst_5 : ChartedSpace H N] {n : WithTop ℕ∞} {A : Type u_1} [inst_6 : NormedRing A]
[inst_7 : NormedAlgebra 𝕜 A] [inst_8 : ContMDiffRing (modelWithCornersSelf 𝕜 A) n A] (x : 𝕜),
⇑((algebraMap 𝕜 (ContMDiffMap I (modelWithCornersSelf 𝕜 A) N A n)) x) =
⇑((algebraMap 𝕜 (ContMDiffMap I (modelWithCornersSelf 𝕜 A) N A n)) x) | false |
Lean.Lsp.CodeActionTriggerKind | Lean.Data.Lsp.CodeActions | Type | true |
_private.Lean.Meta.UnificationHint.0.Lean.Meta.tryUnificationHints.tryCandidate.match_3 | Lean.Meta.UnificationHint | (motive : Lean.LOption Lean.Expr → Sort u_1) →
(__do_lift : Lean.LOption Lean.Expr) →
((val : Lean.Expr) → motive (Lean.LOption.some val)) → ((x : Lean.LOption Lean.Expr) → motive x) → motive __do_lift | false |
StrictAntiOn.antitoneOn | Mathlib.Order.Monotone.Defs | ∀ {α : Type u} {β : Type v} [inst : PartialOrder α] [inst_1 : Preorder β] {f : α → β} {s : Set α},
StrictAntiOn f s → AntitoneOn f s | true |
Lean.Server.Watchdog.ServerContext.noConfusionType | Lean.Server.Watchdog | Sort u → Lean.Server.Watchdog.ServerContext → Lean.Server.Watchdog.ServerContext → Sort u | false |
Submodule.map_iInf | Mathlib.Algebra.Module.Submodule.Map | ∀ {R : Type u_1} {R₂ : Type u_3} {M : Type u_5} {M₂ : Type u_7} [inst : Semiring R] [inst_1 : Semiring R₂]
[inst_2 : AddCommMonoid M] [inst_3 : AddCommMonoid M₂] [inst_4 : Module R M] [inst_5 : Module R₂ M₂] {σ₁₂ : R →+* R₂}
[inst_6 : RingHomSurjective σ₁₂] {ι : Sort u_9} [Nonempty ι] {p : ι → Submodule R M} (f : M →ₛₗ[σ₁₂] M₂),
Function.Injective ⇑f → Submodule.map f (⨅ i, p i) = ⨅ i, Submodule.map f (p i) | true |
TensorialAt.add | Mathlib.Geometry.Manifold.VectorBundle.Tensoriality | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {H : Type u_3} [inst_3 : TopologicalSpace H] {I : ModelWithCorners 𝕜 E H} {M : Type u_4}
[inst_4 : TopologicalSpace M] [inst_5 : ChartedSpace H M] {F : Type u_5} [inst_6 : NormedAddCommGroup F]
[inst_7 : NormedSpace 𝕜 F] {V : M → Type u_6} [inst_8 : TopologicalSpace (Bundle.TotalSpace F V)]
[inst_9 : (x : M) → AddCommGroup (V x)] [inst_10 : (x : M) → Module 𝕜 (V x)]
[inst_11 : (x : M) → TopologicalSpace (V x)] [inst_12 : FiberBundle F V] {A : Type u_9} [inst_13 : AddCommGroup A]
[inst_14 : Module 𝕜 A] {Φ : ((x : M) → V x) → A} {x : M},
TensorialAt I F Φ x → ∀ {σ σ' : (x : M) → V x}, MDiffAt (T% σ) x → MDiffAt (T% σ') x → Φ (σ + σ') = Φ σ + Φ σ' | true |
StarSubalgebra.subtype._proof_6 | Mathlib.Algebra.Star.Subalgebra | ∀ {R : Type u_2} {A : Type u_1} [inst : CommSemiring R] [inst_1 : StarRing R] [inst_2 : Semiring A]
[inst_3 : StarRing A] [inst_4 : Algebra R A] [inst_5 : StarModule R A] (S : StarSubalgebra R A) (x : ↥S),
↑(star x) = ↑(star x) | false |
Matrix.toSquareBlockProp | Mathlib.Data.Matrix.Block | {m : Type u_2} → {α : Type u_12} → Matrix m m α → (p : m → Prop) → Matrix { a // p a } { a // p a } α | true |
AlgebraicGeometry.LocallyRingedSpace.forgetToSheafedSpace | Mathlib.Geometry.RingedSpace.LocallyRingedSpace | CategoryTheory.Functor AlgebraicGeometry.LocallyRingedSpace (AlgebraicGeometry.SheafedSpace CommRingCat) | true |
Lean.Elab.Do.ControlStack.restoreCont | Lean.Elab.Do.Control | Lean.Elab.Do.ControlStack → Lean.Elab.Do.DoElemCont → Lean.Elab.Do.DoElabM Lean.Elab.Do.DoElemCont | true |
instAssociativeMax_mathlib | Mathlib.Order.Lattice | ∀ {α : Type u} [inst : SemilatticeSup α], Std.Associative fun x1 x2 => x1 ⊔ x2 | true |
Lean.Parser.Command.declModifiers | Lean.Parser.Command | Bool → Lean.Parser.Parser | true |
_private.Mathlib.CategoryTheory.Bicategory.Free.0.CategoryTheory.FreeBicategory.«_aux_Mathlib_CategoryTheory_Bicategory_Free___macroRules__private_Mathlib_CategoryTheory_Bicategory_Free_0_CategoryTheory_FreeBicategory_termλ__1» | Mathlib.CategoryTheory.Bicategory.Free | Lean.Macro | false |
_private.Mathlib.Data.Finset.Sum.0.Finset.disjSum_subset._simp_1_1 | Mathlib.Data.Finset.Sum | ∀ {α : Type u_1} {s₁ s₂ : Finset α}, (s₁ ⊆ s₂) = ∀ ⦃x : α⦄, x ∈ s₁ → x ∈ s₂ | false |
CategoryTheory.CategoryOfElements.toStructuredArrow._proof_1 | Mathlib.CategoryTheory.Elements | ∀ {C : Type u_3} [inst : CategoryTheory.Category.{u_2, u_3} C] (F : CategoryTheory.Functor C (Type u_1))
{X Y : F.Elements} (f : X ⟶ Y),
CategoryTheory.CategoryStruct.comp (CategoryTheory.StructuredArrow.mk fun x => X.snd).hom (F.map ↑f) =
(CategoryTheory.StructuredArrow.mk fun x => Y.snd).hom | false |
CategoryTheory.Functor.splitMonoEquiv._proof_4 | Mathlib.CategoryTheory.Functor.EpiMono | ∀ {C : Type u_3} [inst : CategoryTheory.Category.{u_1, u_3} C] {D : Type u_4}
[inst_1 : CategoryTheory.Category.{u_2, u_4} D] (F : CategoryTheory.Functor C D) {X Y : C} (f : X ⟶ Y)
[inst_2 : F.Full] [inst_3 : F.Faithful],
Function.LeftInverse (fun s => { retraction := F.preimage s.retraction, id := ⋯ }) fun f_1 => f_1.map F | false |
AddCommGroup.modEq_iff_toIcoDiv_eq_toIocDiv_add_one | Mathlib.Algebra.Order.ToIntervalMod | ∀ {α : Type u_1} [inst : AddCommGroup α] [inst_1 : LinearOrder α] [inst_2 : IsOrderedAddMonoid α] [hα : Archimedean α]
{p : α} (hp : 0 < p) {a b : α}, a ≡ b [PMOD p] ↔ toIcoDiv hp a b = toIocDiv hp a b + 1 | true |
_private.Mathlib.CategoryTheory.WithTerminal.Basic.0.CategoryTheory.WithInitial.opEquiv.match_15.eq_3 | Mathlib.CategoryTheory.WithTerminal.Basic | ∀ (C : Type u_1) [inst : CategoryTheory.Category.{u_2, u_1} C]
(motive : (x y : CategoryTheory.WithTerminal Cᵒᵖ) → (x ⟶ y) → Sort u_3)
(x : CategoryTheory.WithTerminal.star ⟶ CategoryTheory.WithTerminal.star)
(h_1 :
(x y : C) →
(f : CategoryTheory.WithTerminal.of (Opposite.op x) ⟶ CategoryTheory.WithTerminal.of (Opposite.op y)) →
motive (CategoryTheory.WithTerminal.of (Opposite.op x)) (CategoryTheory.WithTerminal.of (Opposite.op y)) f)
(h_2 :
(unop : C) →
(x : CategoryTheory.WithTerminal.of (Opposite.op unop) ⟶ CategoryTheory.WithTerminal.star) →
motive (CategoryTheory.WithTerminal.of (Opposite.op unop)) CategoryTheory.WithTerminal.star x)
(h_3 :
(x : CategoryTheory.WithTerminal.star ⟶ CategoryTheory.WithTerminal.star) →
motive CategoryTheory.WithTerminal.star CategoryTheory.WithTerminal.star x),
(match CategoryTheory.WithTerminal.star, CategoryTheory.WithTerminal.star, x with
| CategoryTheory.WithTerminal.of (Opposite.op x), CategoryTheory.WithTerminal.of (Opposite.op y), f => h_1 x y f
| CategoryTheory.WithTerminal.of (Opposite.op unop), CategoryTheory.WithTerminal.star, x => h_2 unop x
| CategoryTheory.WithTerminal.star, CategoryTheory.WithTerminal.star, x => h_3 x) =
h_3 x | true |
SetLike.smul_subset_self | Mathlib.GroupTheory.GroupAction.SubMulAction | ∀ {S : Type u_1} {R : Type u_2} {M : Type u_3} [inst : SetLike S M] [inst_1 : SMul R M] [SMulMemClass S R M] (r : R)
(s : S), r • ↑s ⊆ ↑s | true |
Std.Iterators.Types.StepSizeIterator.instProductive | Std.Data.Iterators.Combinators.Monadic.StepSize | ∀ {α : Type u_1} {m : Type u_1 → Type u_2} {β : Type u_1} [inst : Std.Iterator α m β] [inst_1 : Std.IteratorAccess α m]
[inst_2 : Monad m] [Std.Iterators.Productive α m],
Std.Iterators.Productive (Std.Iterators.Types.StepSizeIterator α m β) m | true |
Lean.Server.Watchdog.RequestQueueMap.queue | Lean.Server.Watchdog | Lean.Server.Watchdog.RequestQueueMap → Std.TreeMap ℕ (Lean.JsonRpc.RequestID × Lean.JsonRpc.Request Lean.Json) compare | true |
StarAlgEquiv.mk.inj | Mathlib.Algebra.Star.StarAlgHom | ∀ {R : Type u_1} {A : Type u_2} {B : Type u_3} {inst : Add A} {inst_1 : Add B} {inst_2 : Mul A} {inst_3 : Mul B}
{inst_4 : SMul R A} {inst_5 : SMul R B} {inst_6 : Star A} {inst_7 : Star B} {toStarRingEquiv : A ≃⋆+* B}
{map_smul' : ∀ (r : R) (a : A), toStarRingEquiv.toFun (r • a) = r • toStarRingEquiv.toFun a}
{toStarRingEquiv_1 : A ≃⋆+* B}
{map_smul'_1 : ∀ (r : R) (a : A), toStarRingEquiv_1.toFun (r • a) = r • toStarRingEquiv_1.toFun a},
{ toStarRingEquiv := toStarRingEquiv, map_smul' := map_smul' } =
{ toStarRingEquiv := toStarRingEquiv_1, map_smul' := map_smul'_1 } →
toStarRingEquiv = toStarRingEquiv_1 | true |
_private.Mathlib.NumberTheory.LSeries.PrimesInAP.0.ArithmeticFunction.vonMangoldt.not_summable_residueClass_prime_div._simp_1_2 | Mathlib.NumberTheory.LSeries.PrimesInAP | ∀ {α : Type u} [inst : LinearOrder α] {a b c : α}, (a < min b c) = (a < b ∧ a < c) | false |
CategoryTheory.GradedObject.comapEq_trans | Mathlib.CategoryTheory.GradedObject | ∀ (C : Type u) [inst : CategoryTheory.Category.{v, u} C] {β γ : Type w} {f g h : β → γ} (k : f = g) (l : g = h),
CategoryTheory.GradedObject.comapEq C ⋯ =
CategoryTheory.GradedObject.comapEq C k ≪≫ CategoryTheory.GradedObject.comapEq C l | true |
Lean.Doc.Inline.footnote.noConfusion | Lean.DocString.Types | {i : Type u} →
{P : Sort u_1} →
{name : String} →
{content : Array (Lean.Doc.Inline i)} →
{name' : String} →
{content' : Array (Lean.Doc.Inline i)} →
Lean.Doc.Inline.footnote name content = Lean.Doc.Inline.footnote name' content' →
(name = name' → content ≍ content' → P) → P | false |
Lean.initFn._@.Lean.Util.Trace.3737982518._hygCtx._hyg.4 | Lean.Util.Trace | IO (Lean.Option Bool) | false |
Lean.Grind.Linarith.imp_eq_cert | Init.Grind.Ordered.Linarith | Lean.Grind.Linarith.Poly → Lean.Grind.Linarith.Var → Lean.Grind.Linarith.Var → Bool | true |
ExistsAndEq.withExistsElimAlongPath | Mathlib.Tactic.Simproc.ExistsAndEq | {u : Lean.Level} →
{α : Q(Sort u)} →
{P goal : Q(Prop)} →
Q(«$P») →
{a a' : Q(«$α»)} →
List ExistsAndEq.VarQ →
ExistsAndEq.Path → (Q(«$a» = «$a'») → List ExistsAndEq.HypQ → Lean.MetaM Q(«$goal»)) → Lean.MetaM Q(«$goal») | true |
ProbabilityTheory.gaussianPDFReal_mul | Mathlib.Probability.Distributions.Gaussian.Real | ∀ {μ : ℝ} {v : NNReal} {c : ℝ},
c ≠ 0 →
∀ (x : ℝ),
ProbabilityTheory.gaussianPDFReal μ v (c * x) =
|c⁻¹| * ProbabilityTheory.gaussianPDFReal (c⁻¹ * μ) (⟨(c ^ 2)⁻¹, ⋯⟩ * v) x | true |
Ideal.IsTwoSided.mk | Mathlib.RingTheory.Ideal.Defs | ∀ {α : Type u} [inst : Semiring α] {I : Ideal α}, (∀ {a : α} (b : α), a ∈ I → a * b ∈ I) → I.IsTwoSided | true |
RestrictedProduct.mapAlongMonoidHom._proof_1 | Mathlib.Topology.Algebra.RestrictedProduct.Basic | ∀ {ι₁ : Type u_4} {ι₂ : Type u_1} (R₁ : ι₁ → Type u_5) (R₂ : ι₂ → Type u_2) {𝓕₁ : Filter ι₁} {𝓕₂ : Filter ι₂}
{S₁ : ι₁ → Type u_6} {S₂ : ι₂ → Type u_3} [inst : (i : ι₁) → SetLike (S₁ i) (R₁ i)]
[inst_1 : (j : ι₂) → SetLike (S₂ j) (R₂ j)] {B₁ : (i : ι₁) → S₁ i} {B₂ : (j : ι₂) → S₂ j} (f : ι₂ → ι₁)
(hf : Filter.Tendsto f 𝓕₂ 𝓕₁) [inst_2 : (i : ι₁) → Monoid (R₁ i)] [inst_3 : (i : ι₂) → Monoid (R₂ i)]
[inst_4 : ∀ (i : ι₁), SubmonoidClass (S₁ i) (R₁ i)] [inst_5 : ∀ (i : ι₂), SubmonoidClass (S₂ i) (R₂ i)]
(φ : (j : ι₂) → R₁ (f j) →* R₂ j) (hφ : ∀ᶠ (j : ι₂) in 𝓕₂, Set.MapsTo ⇑(φ j) ↑(B₁ (f j)) ↑(B₂ j)),
RestrictedProduct.mapAlong R₁ R₂ f hf (fun j r => (φ j) r) hφ 1 = 1 | false |
CategoryTheory.Abelian.SpectralObject.kernelSequenceOpcyclesE_X₂ | Mathlib.Algebra.Homology.SpectralObject.Page | ∀ {C : Type u_1} {ι : Type u_2} [inst : CategoryTheory.Category.{v_1, u_1} C]
[inst_1 : CategoryTheory.Category.{v_2, u_2} ι] [inst_2 : CategoryTheory.Abelian C]
(X : CategoryTheory.Abelian.SpectralObject C ι) {i j k l : ι} (f₁ : i ⟶ j) (f₂ : j ⟶ k) (f₃ : k ⟶ l) (n₀ n₁ n₂ : ℤ)
(hn₁ : autoParam (n₀ + 1 = n₁) CategoryTheory.Abelian.SpectralObject.kernelSequenceOpcyclesE._auto_1)
(hn₂ : autoParam (n₁ + 1 = n₂) CategoryTheory.Abelian.SpectralObject.kernelSequenceOpcyclesE._auto_3),
(X.kernelSequenceOpcyclesE f₁ f₂ f₃ n₀ n₁ n₂ hn₁ hn₂).X₂ = X.opcycles f₂ f₃ n₁ | true |
CategoryTheory.Limits.MonoFactorisation.ext | Mathlib.CategoryTheory.Limits.Shapes.Images | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y : C} {f : X ⟶ Y}
{F F' : CategoryTheory.Limits.MonoFactorisation f} (hI : F.I = F'.I),
F.m = CategoryTheory.CategoryStruct.comp (CategoryTheory.eqToHom hI) F'.m → F = F' | true |
_private.Mathlib.Topology.MetricSpace.GromovHausdorffRealized.0.GromovHausdorff.candidates_le_maxVar | Mathlib.Topology.MetricSpace.GromovHausdorffRealized | ∀ {X : Type u} {Y : Type v} [inst : MetricSpace X] [inst_1 : MetricSpace Y] {f : GromovHausdorff.ProdSpaceFun✝ X Y}
{x y : X ⊕ Y}, f ∈ GromovHausdorff.candidates X Y → f (x, y) ≤ ↑(GromovHausdorff.maxVar✝ X Y) | true |
AffineSubspace.wSameSide_vadd_right_iff | Mathlib.Analysis.Convex.Side | ∀ {R : Type u_1} {V : Type u_2} {P : Type u_4} [inst : CommRing R] [inst_1 : PartialOrder R]
[inst_2 : IsStrictOrderedRing R] [inst_3 : AddCommGroup V] [inst_4 : Module R V] [inst_5 : AddTorsor V P]
{s : AffineSubspace R P} {x y : P} {v : V}, v ∈ s.direction → (s.WSameSide x (v +ᵥ y) ↔ s.WSameSide x y) | true |
CategoryTheory.evaluationAdjunctionLeft | Mathlib.CategoryTheory.Adjunction.Evaluation | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
(D : Type u₂) →
[inst_1 : CategoryTheory.Category.{v₂, u₂} D] →
[inst_2 : ∀ (a b : C), CategoryTheory.Limits.HasProductsOfShape (a ⟶ b) D] →
(c : C) → (CategoryTheory.evaluation C D).obj c ⊣ CategoryTheory.evaluationRightAdjoint D c | true |
Lean.findModuleOf? | Lean.MonadEnv | {m : Type → Type} → [Monad m] → [Lean.MonadEnv m] → [Lean.MonadError m] → Lean.Name → m (Option Lean.Name) | true |
_private.Init.Data.BitVec.Lemmas.0.BitVec.toNat_signExtend_of_le._proof_1_3 | Init.Data.BitVec.Lemmas | ∀ {w : ℕ} {v : ℕ} (i k : ℕ), ¬(i < w ∨ w ≤ i ∧ i < w + k ∨ w + k ≤ i) → False | false |
RestrictedProduct.mapAlongAddMonoidHom | Mathlib.Topology.Algebra.RestrictedProduct.Basic | {ι₁ : Type u_3} →
{ι₂ : Type u_4} →
(R₁ : ι₁ → Type u_5) →
(R₂ : ι₂ → Type u_6) →
{𝓕₁ : Filter ι₁} →
{𝓕₂ : Filter ι₂} →
{S₁ : ι₁ → Type u_7} →
{S₂ : ι₂ → Type u_8} →
[inst : (i : ι₁) → SetLike (S₁ i) (R₁ i)] →
[inst_1 : (j : ι₂) → SetLike (S₂ j) (R₂ j)] →
{B₁ : (i : ι₁) → S₁ i} →
{B₂ : (j : ι₂) → S₂ j} →
(f : ι₂ → ι₁) →
Filter.Tendsto f 𝓕₂ 𝓕₁ →
[inst_2 : (i : ι₁) → AddMonoid (R₁ i)] →
[inst_3 : (i : ι₂) → AddMonoid (R₂ i)] →
[inst_4 : ∀ (i : ι₁), AddSubmonoidClass (S₁ i) (R₁ i)] →
[inst_5 : ∀ (i : ι₂), AddSubmonoidClass (S₂ i) (R₂ i)] →
(φ : (j : ι₂) → R₁ (f j) →+ R₂ j) →
(∀ᶠ (j : ι₂) in 𝓕₂, Set.MapsTo ⇑(φ j) ↑(B₁ (f j)) ↑(B₂ j)) →
RestrictedProduct (fun i => R₁ i) (fun i => ↑(B₁ i)) 𝓕₁ →+
RestrictedProduct (fun j => R₂ j) (fun j => ↑(B₂ j)) 𝓕₂ | true |
OrderDual.instTrichotomousLt | Mathlib.Order.OrderDual | ∀ {α : Type u_1} [inst : LT α] [T : Std.Trichotomous LT.lt], Std.Trichotomous LT.lt | true |
_private.Mathlib.Combinatorics.Additive.AP.Three.Behrend.0.Behrend.le_sqrt_log._simp_1_3 | Mathlib.Combinatorics.Additive.AP.Three.Behrend | ∀ {α : Type u_2} [inst : Zero α] [inst_1 : OfNat α 4] [NeZero 4], (4 = 0) = False | false |
Std.HashMap.Raw.getElem?_filter' | Std.Data.HashMap.RawLemmas | ∀ {α : Type u} {β : Type v} [inst : BEq α] [inst_1 : Hashable α] {m : Std.HashMap.Raw α β} [LawfulBEq α]
{f : α → β → Bool} {k : α}, m.WF → (Std.HashMap.Raw.filter f m)[k]? = Option.filter (f k) m[k]? | true |
Real.arcsin_nonpos | Mathlib.Analysis.SpecialFunctions.Trigonometric.Inverse | ∀ {x : ℝ}, Real.arcsin x ≤ 0 ↔ x ≤ 0 | true |
MulOpposite.instSemifield._proof_3 | Mathlib.Algebra.Field.Opposite | ∀ {α : Type u_1} [inst : Semifield α] (n : ℕ) (a : αᵐᵒᵖ),
DivisionSemiring.zpow (↑n.succ) a = DivisionSemiring.zpow (↑n) a * a | false |
posMulReflectLT_iff | Mathlib.Algebra.Order.GroupWithZero.Unbundled.Defs | ∀ (α : Type u_1) [inst : Mul α] [inst_1 : Zero α] [inst_2 : Preorder α],
PosMulReflectLT α ↔ ContravariantClass { x // 0 ≤ x } α (fun x y => ↑x * y) fun x1 x2 => x1 < x2 | true |
SubalgebraClass.toAlgebra._proof_6 | Mathlib.Algebra.Algebra.Subalgebra.Basic | ∀ {S : Type u_2} {R : Type u_3} {A : Type u_1} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A]
[inst_3 : SetLike S A] [SubsemiringClass S A] [hSR : SMulMemClass S R A] (s : S) (r : R), (algebraMap R A) r ∈ s | false |
Lean.Name.isAtomic | Lean.Data.Name | Lean.Name → Bool | true |
Lean.LibrarySuggestions.Suggestion.name | Lean.LibrarySuggestions.Basic | Lean.LibrarySuggestions.Suggestion → Lean.Name | true |
Set.addAntidiagonal_mono_left | Mathlib.Data.Set.MulAntidiagonal | ∀ {α : Type u_1} [inst : Add α] {s₁ s₂ t : Set α} {a : α}, s₁ ⊆ s₂ → s₁.addAntidiagonal t a ⊆ s₂.addAntidiagonal t a | true |
LinearEquiv.ofSubmodules_symm_apply | Mathlib.Algebra.Module.Submodule.Equiv | ∀ {R : Type u_1} {R₂ : Type u_3} {M : Type u_5} {M₂ : Type u_7} [inst : Semiring R] [inst_1 : Semiring R₂]
[inst_2 : AddCommMonoid M] [inst_3 : AddCommMonoid M₂] {module_M : Module R M} {module_M₂ : Module R₂ M₂}
{σ₁₂ : R →+* R₂} {σ₂₁ : R₂ →+* R} {re₁₂ : RingHomInvPair σ₁₂ σ₂₁} {re₂₁ : RingHomInvPair σ₂₁ σ₁₂} (e : M ≃ₛₗ[σ₁₂] M₂)
{p : Submodule R M} {q : Submodule R₂ M₂} (h : Submodule.map (↑e) p = q) (x : ↥q),
↑((e.ofSubmodules p q h).symm x) = e.symm ↑x | true |
CategoryTheory.FreeMonoidalCategory.NormalMonoidalObject.ctorIdx | Mathlib.CategoryTheory.Monoidal.Free.Coherence | {C : Type u} → CategoryTheory.FreeMonoidalCategory.NormalMonoidalObject C → ℕ | false |
LLVM.buildSwitch | Lean.Compiler.IR.LLVMBindings | {ctx : LLVM.Context} → LLVM.Builder ctx → LLVM.Value ctx → LLVM.BasicBlock ctx → UInt64 → BaseIO (LLVM.Value ctx) | true |
SimpleGraph.hasse | Mathlib.Combinatorics.SimpleGraph.Hasse | (α : Type u_1) → [Preorder α] → SimpleGraph α | true |
GenContFract.IntFractPair.one_le_succ_nth_stream_b | Mathlib.Algebra.ContinuedFractions.Computation.Approximations | ∀ {K : Type u_1} {v : K} {n : ℕ} [inst : Field K] [inst_1 : LinearOrder K] [IsStrictOrderedRing K]
[inst_3 : FloorRing K] {ifp_succ_n : GenContFract.IntFractPair K},
GenContFract.IntFractPair.stream v (n + 1) = some ifp_succ_n → 1 ≤ ifp_succ_n.b | true |
AddGroupSeminormClass.toSeminormedAddGroup._proof_2 | Mathlib.Analysis.Normed.Order.Hom.Basic | ∀ {F : Type u_1} {α : Type u_2} [inst : FunLike F α ℝ] [inst_1 : AddGroup α] [AddGroupSeminormClass F α ℝ] (f : F)
(x y : α), f (-x + y) = f (-y + x) | false |
OrderIsoClass.toSupHomClass | Mathlib.Order.Hom.Lattice | ∀ {F : Type u_1} {α : Type u_2} {β : Type u_3} [inst : EquivLike F α β] [inst_1 : SemilatticeSup α]
[inst_2 : SemilatticeSup β] [OrderIsoClass F α β], SupHomClass F α β | true |
CategoryTheory.CommComon.instCategory._proof_9 | Mathlib.CategoryTheory.Monoidal.CommComon_ | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.MonoidalCategory C]
[inst_2 : CategoryTheory.BraidedCategory C],
autoParam
(∀ {W X Y Z : CategoryTheory.CommComon C} (f : W ⟶ X) (g : X ⟶ Y) (h : Y ⟶ Z),
CategoryTheory.CategoryStruct.comp (CategoryTheory.CategoryStruct.comp f g) h =
CategoryTheory.CategoryStruct.comp f (CategoryTheory.CategoryStruct.comp g h))
CategoryTheory.Category.assoc._autoParam | false |
Lean.Meta.DSimp.Config.failIfUnchanged | Init.MetaTypes | Lean.Meta.DSimp.Config → Bool | true |
CategoryTheory.FreeMonoidalCategory.instMonoidalCategory._proof_4 | Mathlib.CategoryTheory.Monoidal.Free.Basic | ∀ {C : Type u_1} {X Y : CategoryTheory.FreeMonoidalCategory C} (f : X ⟶ Y),
CategoryTheory.CategoryStruct.comp
(Quot.map
(fun f => CategoryTheory.FreeMonoidalCategory.Hom.whiskerLeft CategoryTheory.FreeMonoidalCategory.unit f) ⋯ f)
{ hom := ⟦CategoryTheory.FreeMonoidalCategory.Hom.l_hom Y⟧,
inv := ⟦CategoryTheory.FreeMonoidalCategory.Hom.l_inv Y⟧, hom_inv_id := ⋯, inv_hom_id := ⋯ }.hom =
CategoryTheory.CategoryStruct.comp
{ hom := ⟦CategoryTheory.FreeMonoidalCategory.Hom.l_hom X⟧,
inv := ⟦CategoryTheory.FreeMonoidalCategory.Hom.l_inv X⟧, hom_inv_id := ⋯, inv_hom_id := ⋯ }.hom
f | false |
Composition.ext_iff | Mathlib.Combinatorics.Enumerative.Composition | ∀ {n : ℕ} {x y : Composition n}, x = y ↔ x.blocks = y.blocks | true |
CharacterModule.int | Mathlib.Algebra.Module.CharacterModule | Type | true |
CategoryTheory.Abelian.PullbackToBiproductIsKernel.pullbackToBiproduct._proof_2 | Mathlib.CategoryTheory.Abelian.Basic | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Abelian C] {X Y : C},
CategoryTheory.Limits.HasBinaryBiproduct X Y | false |
MulEquiv.toGrpIso_hom | Mathlib.Algebra.Category.Grp.Basic | ∀ {X Y : GrpCat} (e : ↑X ≃* ↑Y), e.toGrpIso.hom = GrpCat.ofHom e.toMonoidHom | true |
PSigma.fst | Init.Core | {α : Sort u} → {β : α → Sort v} → PSigma β → α | true |
CategoryTheory.ObjectProperty.IsCardinalFilteredGenerator.presentable | Mathlib.CategoryTheory.Presentable.CardinalFilteredPresentation | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {P : CategoryTheory.ObjectProperty C} {κ : Cardinal.{w}}
[inst_1 : Fact κ.IsRegular],
P.IsCardinalFilteredGenerator κ →
∀ [CategoryTheory.LocallySmall.{w, v, u} C] (X : C), CategoryTheory.IsPresentable.{w, v, u} X | true |
MeasureTheory.Submartingale.sum_mul_sub' | Mathlib.Probability.Martingale.Basic | ∀ {Ω : Type u_1} {m0 : MeasurableSpace Ω} {μ : MeasureTheory.Measure Ω} {𝒢 : MeasureTheory.Filtration ℕ m0}
[MeasureTheory.IsFiniteMeasure μ] {R : ℝ} {ξ f : ℕ → Ω → ℝ},
MeasureTheory.Submartingale f 𝒢 μ →
(MeasureTheory.StronglyAdapted 𝒢 fun n => ξ (n + 1)) →
(∀ (n : ℕ) (ω : Ω), ξ n ω ≤ R) →
(∀ (n : ℕ) (ω : Ω), 0 ≤ ξ n ω) →
MeasureTheory.Submartingale (fun n => ∑ k ∈ Finset.range n, ξ (k + 1) * (f (k + 1) - f k)) 𝒢 μ | true |
Polynomial.expand.eq_1 | Mathlib.Algebra.Polynomial.Expand | ∀ (R : Type u) [inst : CommSemiring R] (p : ℕ),
Polynomial.expand R p = { toRingHom := Polynomial.eval₂RingHom Polynomial.C (Polynomial.X ^ p), commutes' := ⋯ } | true |
Std.Legacy.Range.«_aux_Init_Data_Range_Basic___macroRules_Std_Legacy_Range_term[_:_:_]_1» | Init.Data.Range.Basic | Lean.Macro | false |
CategoryTheory.Pseudofunctor.StrongTrans.whiskerRight_naturality_comp_app | Mathlib.CategoryTheory.Bicategory.NaturalTransformation.Pseudo | ∀ {B : Type u_1} [inst : CategoryTheory.Bicategory B] {F G : CategoryTheory.Pseudofunctor B CategoryTheory.Cat}
(η : F ⟶ G) {a b c : B} {a' : CategoryTheory.Cat} (f : a ⟶ b) (g : b ⟶ c) (h : G.obj c ⟶ a') (X : ↑(F.obj a)),
CategoryTheory.CategoryStruct.comp
(h.toFunctor.map ((η.naturality (CategoryTheory.CategoryStruct.comp f g)).hom.toNatTrans.app X))
(h.toFunctor.map ((G.mapComp f g).hom.toNatTrans.app ((η.app a).toFunctor.obj X))) =
CategoryTheory.CategoryStruct.comp
(h.toFunctor.map ((η.app c).toFunctor.map ((F.mapComp f g).hom.toNatTrans.app X)))
(CategoryTheory.CategoryStruct.comp
(h.toFunctor.map
(CategoryTheory.CategoryStruct.id
((η.app c).toFunctor.obj ((F.map g).toFunctor.obj ((F.map f).toFunctor.obj X)))))
(CategoryTheory.CategoryStruct.comp
(h.toFunctor.map ((η.naturality g).hom.toNatTrans.app ((F.map f).toFunctor.obj X)))
(CategoryTheory.CategoryStruct.comp
(h.toFunctor.map
(CategoryTheory.CategoryStruct.id
((G.map g).toFunctor.obj ((η.app b).toFunctor.obj ((F.map f).toFunctor.obj X)))))
(CategoryTheory.CategoryStruct.comp
(h.toFunctor.map ((G.map g).toFunctor.map ((η.naturality f).hom.toNatTrans.app X)))
(h.toFunctor.map
(CategoryTheory.CategoryStruct.id
((G.map g).toFunctor.obj ((G.map f).toFunctor.obj ((η.app a).toFunctor.obj X))))))))) | true |
Lean.Elab.Tactic.elabLinarithConfig | Lean.Elab.Tactic.Grind.Main | Lean.Syntax → Lean.Elab.Tactic.TacticM Lean.Grind.LinarithConfig | true |
Int.Linear.Poly.isUnsatEq.eq_2 | Init.Data.Int.Linear | ∀ (p : Int.Linear.Poly), (∀ (k : ℤ), p = Int.Linear.Poly.num k → False) → p.isUnsatEq = false | true |
CategoryTheory.Limits.MulticospanIndex.multiforkEquivPiFork_functor_map_hom | Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {J : CategoryTheory.Limits.MulticospanShape}
(I : CategoryTheory.Limits.MulticospanIndex J C) [inst_1 : CategoryTheory.Limits.HasProduct I.left]
[inst_2 : CategoryTheory.Limits.HasProduct I.right] {K₁ K₂ : CategoryTheory.Limits.Multifork I} (f : K₁ ⟶ K₂),
(I.multiforkEquivPiFork.functor.map f).hom = f.hom | true |
Finset.sup'_singleton | Mathlib.Data.Finset.Lattice.Fold | ∀ {α : Type u_2} {β : Type u_3} [inst : SemilatticeSup α] (f : β → α) {b : β}, {b}.sup' ⋯ f = f b | true |
Lean.Compiler.CSimp.State.casesOn | Lean.Compiler.CSimpAttr | {motive : Lean.Compiler.CSimp.State → Sort u} →
(t : Lean.Compiler.CSimp.State) →
((map : Lean.SMap Lean.Name Lean.Compiler.CSimp.Entry) →
(thmNames : Lean.SSet Lean.Name) → motive { map := map, thmNames := thmNames }) →
motive t | false |
MeasureTheory.Measure.rnDeriv_smul_same | Mathlib.MeasureTheory.Measure.Decomposition.Lebesgue | ∀ {α : Type u_1} {m : MeasurableSpace α} (ν μ : MeasureTheory.Measure α) [MeasureTheory.IsFiniteMeasure ν]
[ν.HaveLebesgueDecomposition μ] {r : NNReal}, r ≠ 0 → (r • ν).rnDeriv (r • μ) =ᵐ[μ] ν.rnDeriv μ | true |
Lean.Doc.Inline.link.elim | Lean.DocString.Types | {i : Type u} →
{motive_1 : Lean.Doc.Inline i → Sort u_1} →
(t : Lean.Doc.Inline i) →
t.ctorIdx = 6 →
((content : Array (Lean.Doc.Inline i)) → (url : String) → motive_1 (Lean.Doc.Inline.link content url)) →
motive_1 t | false |
AddOreLocalization.add_cancel | Mathlib.GroupTheory.OreLocalization.Basic | ∀ {R : Type u_1} [inst : AddMonoid R] {S : AddSubmonoid R} [inst_1 : AddOreLocalization.AddOreSet S] {r : R} {s t : ↥S},
↑s -ₒ t + (r -ₒ s) = r -ₒ t | true |
Module.Invertible.rTensorEquiv_symm_apply_apply | Mathlib.RingTheory.PicardGroup | ∀ {R : Type u} {M : Type v} {N : Type u_1} (P : Type u_2) (Q : Type u_3) [inst : CommSemiring R]
[inst_1 : AddCommMonoid M] [inst_2 : AddCommMonoid N] [inst_3 : AddCommMonoid P] [inst_4 : AddCommMonoid Q]
[inst_5 : Module R M] [inst_6 : Module R N] [inst_7 : Module R P] [inst_8 : Module R Q]
(e : TensorProduct R M N ≃ₗ[R] R) (a : TensorProduct R P M →ₗ[R] TensorProduct R Q M) (a_1 : P),
((Module.Invertible.rTensorEquiv P Q e).symm a) a_1 =
((Module.Invertible.rightCancelEquiv Q e).congrRight (LinearMap.rTensor N a))
((TensorProduct.assoc R P M N).symm (a_1 ⊗ₜ[R] e.symm 1)) | true |
CategoryTheory.MonoidalCategory.MonoidalLeftAction.actionOfMonoidalFunctorToEndofunctorMop_actionUnitIso_hom | Mathlib.CategoryTheory.Monoidal.Action.End | ∀ {C : Type u_1} {D : Type u_2} [inst : CategoryTheory.Category.{v_1, u_1} C]
[inst_1 : CategoryTheory.MonoidalCategory C] [inst_2 : CategoryTheory.Category.{v_2, u_2} D]
(F : CategoryTheory.Functor C (CategoryTheory.Functor D D)ᴹᵒᵖ) [inst_3 : F.Monoidal] (d : D),
(CategoryTheory.MonoidalCategory.MonoidalLeftActionStruct.actionUnitIso d).hom =
(CategoryTheory.Functor.OplaxMonoidal.η F).unmop.app d | true |
LaurentSeries.coeff_zero_of_lt_valuation | Mathlib.RingTheory.LaurentSeries | ∀ (K : Type u_2) [inst : Field K] {n D : ℤ} {f : LaurentSeries K},
Valued.v f ≤ WithZero.exp (-D) → n < D → f.coeff n = 0 | true |
Lean.Elab.Do.ReturnCont.resultType | Lean.Elab.Do.Basic | Lean.Elab.Do.ReturnCont → Lean.Expr | true |
Commute.add_left._simp_1 | Mathlib.Algebra.Ring.Commute | ∀ {R : Type u} [inst : Distrib R] {a b c : R}, Commute a c → Commute b c → Commute (a + b) c = True | false |
_private.Mathlib.Combinatorics.SimpleGraph.Bipartite.0.SimpleGraph.bipartiteDoubleCover.match_1.splitter._sparseCasesOn_5 | Mathlib.Combinatorics.SimpleGraph.Bipartite | {α : Type u} →
{β : Type v} →
{motive : α ⊕ β → Sort u_1} →
(t : α ⊕ β) → ((val : α) → motive (Sum.inl val)) → (Nat.hasNotBit 1 t.ctorIdx → motive t) → motive t | false |
Lean.Language.Lean.HeaderProcessedSnapshot.infoTree?._inherited_default | Lean.Language.Lean.Types | Option Lean.Elab.InfoTree | false |
MeasureTheory.diracProbaEquiv | Mathlib.MeasureTheory.Measure.DiracProba | {X : Type u_1} →
[inst : MeasurableSpace X] →
[inst_1 : TopologicalSpace X] → [OpensMeasurableSpace X] → [T0Space X] → X ≃ ↑(Set.range MeasureTheory.diracProba) | true |
eventually_mabs_div_lt | Mathlib.Topology.Order.LeftRightNhds | ∀ {α : Type u_1} [inst : TopologicalSpace α] [inst_1 : CommGroup α] [inst_2 : LinearOrder α] [IsOrderedMonoid α]
[OrderTopology α] (a : α) {ε : α}, 1 < ε → ∀ᶠ (x : α) in nhds a, |x / a|ₘ < ε | true |
Std.Rcc.count_iter | Std.Data.Iterators.Lemmas.Producers.Range | ∀ {α : Type u_1} [inst : LE α] [inst_1 : DecidableLE α] [inst_2 : Std.PRange.UpwardEnumerable α]
[inst_3 : Std.PRange.LawfulUpwardEnumerableLE α] [Std.Rxc.IsAlwaysFinite α]
[inst_5 : Std.PRange.LawfulUpwardEnumerable α] [inst_6 : Std.Rxc.HasSize α] [Std.Rxc.LawfulHasSize α] {r : Std.Rcc α},
r.iter.length = r.size | true |
Lean.Name.eraseMacroScopes | Init.Prelude | Lean.Name → Lean.Name | true |
_private.Lean.Meta.Tactic.Grind.Arith.Linear.Proof.0.Lean.Meta.Grind.Arith.Linear.RingEqCnstr.toExprProof.match_1 | Lean.Meta.Tactic.Grind.Arith.Linear.Proof | (motive : Lean.Meta.Grind.Arith.Linear.RingEqCnstrProof → Sort u_1) →
(x : Lean.Meta.Grind.Arith.Linear.RingEqCnstrProof) →
((a b : Lean.Expr) →
(la lb : Lean.Grind.CommRing.Expr) → motive (Lean.Meta.Grind.Arith.Linear.RingEqCnstrProof.core a b la lb)) →
((c : Lean.Meta.Grind.Arith.Linear.RingEqCnstr) → motive (Lean.Meta.Grind.Arith.Linear.RingEqCnstrProof.symm c)) →
((c : Lean.Meta.Grind.Arith.Linear.RingEqCnstr) →
(val : ℤ) →
(x n : Lean.Grind.Linarith.Var) →
motive (Lean.Meta.Grind.Arith.Linear.RingEqCnstrProof.cancelDen c val x n)) →
motive x | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.