name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
_private.Init.Data.String.Lemmas.Order.0.String.Slice.Pos.ofSliceTo_le_ofSliceTo_iff._simp_1_1 | Init.Data.String.Lemmas.Order | ∀ {s : String.Slice} {l r : s.Pos}, (l ≤ r) = (l.offset ≤ r.offset) | false |
CategoryTheory.GlueData.types_ι_jointly_surjective | Mathlib.CategoryTheory.GlueData | ∀ (D : CategoryTheory.GlueData (Type v)) (x : D.glued), ∃ i y, D.ι i y = x | true |
CategoryTheory.instCategorySkeleton._proof_7 | Mathlib.CategoryTheory.Skeletal | ∀ (C : Type u_2) [inst : CategoryTheory.Category.{u_1, u_2} C],
autoParam
(∀ {X Y : CategoryTheory.Skeleton C} (f : X ⟶ Y),
CategoryTheory.CategoryStruct.comp (CategoryTheory.CategoryStruct.id X) f = f)
CategoryTheory.Category.id_comp._autoParam | false |
_private.Mathlib.Tactic.Translate.Core.0.Mathlib.Tactic.Translate.applyReplacementForall.match_1 | Mathlib.Tactic.Translate.Core | (motive : Option ℕ → Sort u_1) →
(relevantArg? : Option ℕ) →
((relevantArg : ℕ) → motive (some relevantArg)) → (Unit → motive none) → motive relevantArg? | false |
_private.Mathlib.ModelTheory.Encoding.0.FirstOrder.Language.BoundedFormula.listDecode_encode_list._simp_1_14 | Mathlib.ModelTheory.Encoding | ∀ {α : Sort u_1} {p : α → Prop} {a' : α}, (∃ a, p a ∧ a = a') = p a' | false |
BitVec.instDecidableExistsBitVecZero | Init.Data.BitVec.Decidable | (P : BitVec 0 → Prop) → [Decidable (P 0#0)] → Decidable (∃ v, P v) | true |
_private.Init.Data.List.Perm.0.List.Perm.flatten._simp_1_2 | Init.Data.List.Perm | ∀ {α : Type u} (as bs cs : List α), as ++ (bs ++ cs) = as ++ bs ++ cs | false |
FreeAddGroup.map_neg | Mathlib.GroupTheory.FreeGroup.Basic | ∀ {α β : Type u} (f : α → β) (x : FreeAddGroup α), f <$> (-x) = -f <$> x | true |
_private.Lean.Syntax.0.Lean.Syntax.Stack.matches.match_1 | Lean.Syntax | (motive : Lean.Syntax × ℕ → Sort u_1) →
(x : Lean.Syntax × ℕ) → ((s : Lean.Syntax) → (snd : ℕ) → motive (s, snd)) → motive x | false |
CategoryTheory.Comma.opEquiv_counitIso | Mathlib.CategoryTheory.Comma.Basic | ∀ {A : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} A] {B : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} B]
{T : Type u₃} [inst_2 : CategoryTheory.Category.{v₃, u₃} T] (L : CategoryTheory.Functor A T)
(R : CategoryTheory.Functor B T),
(CategoryTheory.Comma.opEquiv L R).counitIso =
CategoryTheory.N... | true |
Int.Linear.Poly.denote_mul | Init.Data.Int.Linear | ∀ (ctx : Int.Linear.Context) (p : Int.Linear.Poly) (k : ℤ),
Int.Linear.Poly.denote ctx (p.mul k) = k * Int.Linear.Poly.denote ctx p | true |
Finset.coe_smul_finset._simp_2 | Mathlib.Algebra.Group.Pointwise.Finset.Scalar | ∀ {α : Type u_2} {β : Type u_3} [inst : DecidableEq β] [inst_1 : SMul α β] (a : α) (s : Finset β), a • ↑s = ↑(a • s) | false |
CategoryTheory.Mat.instAddCommGroupHom._aux_8 | Mathlib.CategoryTheory.Preadditive.Mat | (R : Type) → [inst : Ring R] → (X Y : CategoryTheory.Mat R) → ℕ → (X ⟶ Y) → (X ⟶ Y) | false |
Lean.Meta.Grind.Arith.Cutsat.getBestLower? | Lean.Meta.Tactic.Grind.Arith.Cutsat.Search | Int.Linear.Var →
Option Lean.Meta.Grind.Arith.Cutsat.DvdCnstr →
Lean.Meta.Grind.GoalM (Option (ℚ × Lean.Meta.Grind.Arith.Cutsat.LeCnstr)) | true |
GromovHausdorff.AuxGluingStruct.metric | Mathlib.Topology.MetricSpace.GromovHausdorff | {A : Type} → [inst : MetricSpace A] → (self : GromovHausdorff.AuxGluingStruct A) → MetricSpace self.Space | true |
Lean.Meta.DiscrTree.Trie.brecOn_1 | Lean.Meta.DiscrTree.Types | {α : Type} →
{motive_1 : Lean.Meta.DiscrTree.Trie α → Sort u} →
{motive_2 : Array (Lean.Meta.DiscrTree.Key × Lean.Meta.DiscrTree.Trie α) → Sort u} →
{motive_3 : List (Lean.Meta.DiscrTree.Key × Lean.Meta.DiscrTree.Trie α) → Sort u} →
{motive_4 : Lean.Meta.DiscrTree.Key × Lean.Meta.DiscrTree.Trie α → ... | false |
_private.Lean.Elab.Util.0.Lean.Elab.evalSyntaxConstantUnsafe | Lean.Elab.Util | Lean.Environment → Lean.Options → Lean.Name → ExceptT String Id Lean.Syntax | true |
Module.finrank_of_infinite_dimensional | Mathlib.LinearAlgebra.FiniteDimensional.Defs | ∀ {K : Type u} {V : Type v} [inst : DivisionRing K] [inst_1 : AddCommGroup V] [inst_2 : Module K V],
¬FiniteDimensional K V → Module.finrank K V = 0 | true |
DomMulAct.coe_mkHomeomorph_symm | Mathlib.Topology.Algebra.Constructions.DomMulAct | ∀ {M : Type u_1} [inst : TopologicalSpace M], ⇑DomMulAct.mkHomeomorph.symm = ⇑DomMulAct.mk.symm | true |
OrthonormalBasis.casesOn | Mathlib.Analysis.InnerProductSpace.PiL2 | {ι : Type u_1} →
{𝕜 : Type u_3} →
[inst : RCLike 𝕜] →
{E : Type u_4} →
[inst_1 : NormedAddCommGroup E] →
[inst_2 : InnerProductSpace 𝕜 E] →
[inst_3 : Fintype ι] →
{motive : OrthonormalBasis ι 𝕜 E → Sort u} →
(t : OrthonormalBasis ι 𝕜 E) →
... | false |
Affine.Simplex.sSameSide_point_incenter | Mathlib.Geometry.Euclidean.Incenter | ∀ {V : Type u_1} {P : Type u_2} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V] [inst_2 : MetricSpace P]
[inst_3 : NormedAddTorsor V P] {n : ℕ} [inst_4 : NeZero n] (s : Affine.Simplex ℝ P n) (i : Fin (n + 1)),
(affineSpan ℝ (Set.range (s.faceOpposite i).points)).SSameSide (s.points i) s.incenter | true |
CategoryTheory.MonoidalClosed.curry_pre_app | Mathlib.CategoryTheory.Monoidal.Closed.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.MonoidalCategory C] {A B : C}
[inst_2 : CategoryTheory.Closed A] [inst_3 : CategoryTheory.Closed B] (f : B ⟶ A) {X Y : C}
(g : CategoryTheory.MonoidalCategoryStruct.tensorObj A Y ⟶ X),
CategoryTheory.CategoryStruct.comp (CategoryThe... | true |
Filter.exists_seq_antitone_tendsto_atTop_atBot | Mathlib.Order.Filter.AtTopBot.CountablyGenerated | ∀ (α : Type u_3) [inst : Preorder α] [Nonempty α] [IsCodirectedOrder α] [Filter.atBot.IsCountablyGenerated],
∃ xs, Antitone xs ∧ Filter.Tendsto xs Filter.atTop Filter.atBot | true |
MeasureTheory.lintegral_pow_le_pow_lintegral_fderiv | Mathlib.Analysis.FunctionalSpaces.SobolevInequality | ∀ {F : Type u_3} [inst : NormedAddCommGroup F] [inst_1 : NormedSpace ℝ F] {E : Type u_4} [inst_2 : NormedAddCommGroup E]
[inst_3 : NormedSpace ℝ E] [inst_4 : MeasurableSpace E] [inst_5 : BorelSpace E] [inst_6 : FiniteDimensional ℝ E]
(μ : MeasureTheory.Measure E) [inst_7 : μ.IsAddHaarMeasure] {u : E → F},
ContDif... | true |
CategoryTheory.Pseudofunctor.mkOfLax._proof_4 | Mathlib.CategoryTheory.Bicategory.Functor.Pseudofunctor | ∀ {B : Type u_5} [inst : CategoryTheory.Bicategory B] {C : Type u_3} [inst_1 : CategoryTheory.Bicategory C]
(F : CategoryTheory.LaxFunctor B C) (F' : F.PseudoCore) {a b : B} (f : a ⟶ b),
F.map₂ (CategoryTheory.Bicategory.leftUnitor f).hom =
CategoryTheory.CategoryStruct.comp (F'.mapCompIso (CategoryTheory.Categ... | false |
Function.Injective.hasDistribNeg | Mathlib.Algebra.Ring.InjSurj | {R : Type u_1} →
{S : Type u_2} →
[inst : Mul S] →
[inst_1 : Neg S] →
(f : S → R) →
Function.Injective f →
[inst_2 : Mul R] →
[inst_3 : HasDistribNeg R] →
(∀ (a : S), f (-a) = -f a) → (∀ (a b : S), f (a * b) = f a * f b) → HasDistribNeg S | true |
Submodule.IsPrincipal.contentIdeal_eq_span_content_of_isPrincipal | Mathlib.RingTheory.Polynomial.ContentIdeal | ∀ {R : Type u_3} [inst : CommRing R] [inst_1 : NormalizedGCDMonoid R] {p : Polynomial R},
Submodule.IsPrincipal p.contentIdeal → p.contentIdeal = Ideal.span {p.content} | true |
Std.Legacy.Range.noConfusionType | Init.Data.Range.Basic | Sort u → Std.Legacy.Range → Std.Legacy.Range → Sort u | false |
Set.center_units_subset | Mathlib.Algebra.GroupWithZero.Center | ∀ {G₀ : Type u_2} [inst : GroupWithZero G₀], Set.center G₀ˣ ⊆ Units.val ⁻¹' Set.center G₀ | true |
Turing.ToPartrec.Cont.eval.eq_3 | Mathlib.Computability.TuringMachine.Config | ∀ (ns : List ℕ) (k : Turing.ToPartrec.Cont), (Turing.ToPartrec.Cont.cons₂ ns k).eval = fun v => k.eval (ns.headI :: v) | true |
_private.Std.Data.DHashMap.Internal.RawLemmas.0.Std.DHashMap.Internal.Raw₀.forall_mem_keysArray_iff_forall_contains_getKey._simp_1_2 | Std.Data.DHashMap.Internal.RawLemmas | ∀ {α : Type u} {β : α → Type v} (m : Std.DHashMap.Internal.Raw₀ α β) [inst : BEq α] [inst_1 : Hashable α] [EquivBEq α]
[LawfulHashable α],
(↑m).WF → ∀ {p : α → Prop}, (∀ k ∈ (↑m).keys, p k) = ∀ (k : α) (h : m.contains k = true), p (m.getKey k h) | false |
Lean.Lsp.CodeAction.noConfusionType | Lean.Data.Lsp.CodeActions | Sort u → Lean.Lsp.CodeAction → Lean.Lsp.CodeAction → Sort u | false |
AffineSubspace.WOppSide.trans_wSameSide | Mathlib.Analysis.Convex.Side | ∀ {R : Type u_1} {V : Type u_2} {P : Type u_4} [inst : Field R] [inst_1 : LinearOrder 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 z : P}, s.WOppSide x y → s.WSameSide y z → y ∉ s → s.WOppSide x z | true |
MvPowerSeries.mapAlgHom._proof_2 | Mathlib.RingTheory.MvPowerSeries.Basic | ∀ {R : Type u_3} {A : Type u_1} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A] {B : Type u_2}
[inst_3 : Semiring B] [inst_4 : Algebra R B], RingHomClass (A →ₐ[R] B) A B | false |
Configuration.Nondegenerate.exists_point | Mathlib.Combinatorics.Configuration | ∀ {P : Type u_1} {L : Type u_2} {inst : Membership P L} [self : Configuration.Nondegenerate P L] (l : L), ∃ p, p ∉ l | true |
CategoryTheory.MorphismProperty.Comma.mapRightEq | Mathlib.CategoryTheory.MorphismProperty.Comma | {A : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} A] →
{B : Type u_2} →
[inst_1 : CategoryTheory.Category.{v_2, u_2} B] →
{T : Type u_3} →
[inst_2 : CategoryTheory.Category.{v_3, u_3} T] →
(L : CategoryTheory.Functor A T) →
{P : CategoryTheory.MorphismPr... | true |
Lean.instTypeNameMessageData | Lean.Message | TypeName Lean.MessageData | true |
Group.toCancelMonoid | Mathlib.Algebra.Group.Defs | {G : Type u_1} → [Group G] → CancelMonoid G | true |
String.reduceBNe._regBuiltin.String.reduceBNe.declare_1._@.Lean.Meta.Tactic.Simp.BuiltinSimprocs.String.904556020._hygCtx._hyg.22 | Lean.Meta.Tactic.Simp.BuiltinSimprocs.String | IO Unit | false |
_private.Mathlib.AlgebraicGeometry.EllipticCurve.Jacobian.Basic.0._aux_Mathlib_AlgebraicGeometry_EllipticCurve_Jacobian_Basic___macroRules__private_Mathlib_AlgebraicGeometry_EllipticCurve_Jacobian_Basic_0_tacticEval_simp_1 | Mathlib.AlgebraicGeometry.EllipticCurve.Jacobian.Basic | Lean.Macro | false |
_private.Lean.Syntax.0.Lean.Syntax.structRangeEq._sparseCasesOn_1 | Lean.Syntax | {motive_1 : Lean.Syntax → Sort u} →
(t : Lean.Syntax) → motive_1 Lean.Syntax.missing → (Nat.hasNotBit 1 t.ctorIdx → motive_1 t) → motive_1 t | false |
ConditionallyCompleteLattice | Mathlib.Order.ConditionallyCompleteLattice.Defs | Type u_5 → Type u_5 | true |
SeparationQuotient.instRing._proof_5 | Mathlib.Topology.Algebra.SeparationQuotient.Basic | ∀ {R : Type u_1} [inst : TopologicalSpace R] [inst_1 : Ring R] [inst_2 : IsTopologicalRing R]
(a : SeparationQuotient R), -a + a = 0 | false |
Ideal.selfBasis._proof_2 | Mathlib.LinearAlgebra.FreeModule.PID | ∀ {ι : Type u_1} {R : Type u_2} [inst : CommRing R] [inst_1 : IsDomain R] [inst_2 : IsPrincipalIdealRing R]
{S : Type u_3} [inst_3 : CommRing S] [inst_4 : IsDomain S] [inst_5 : Algebra R S] [inst_6 : Finite ι]
(b : Module.Basis ι R S) (I : Ideal S) (hI : I ≠ ⊥), ∃ ab', ∀ (i : ι), ↑(ab' i) = ⋯.choose i • ⋯.choose i | false |
SkewMonoidAlgebra.induction_on | Mathlib.Algebra.SkewMonoidAlgebra.Basic | ∀ {k : Type u_1} {G : Type u_2} [inst : AddCommMonoid k] {p : SkewMonoidAlgebra k G → Prop} (f : SkewMonoidAlgebra k G),
p 0 →
(∀ (g : G) (a : k), p (SkewMonoidAlgebra.single g a)) →
(∀ (f g : SkewMonoidAlgebra k G), p f → p g → p (f + g)) → p f | true |
_private.Init.Data.Order.FactoriesExtra.0.Std.isGE_compare._simp_1_1 | Init.Data.Order.FactoriesExtra | ∀ {α : Type u} {inst : Ord α} {inst_1 : LE α} [self : Std.LawfulOrderOrd α] (a b : α),
(b ≤ a) = ((compare a b).isGE = true) | false |
Int8.toInt32_ofIntLE | Init.Data.SInt.Lemmas | ∀ {n : ℤ} (h₁ : Int8.minValue.toInt ≤ n) (h₂ : n ≤ Int8.maxValue.toInt),
(Int8.ofIntLE n h₁ h₂).toInt32 = Int32.ofIntLE n ⋯ ⋯ | true |
Lean.PrettyPrinter.Parenthesizer.checkNoImmediateColon.parenthesizer | Lean.PrettyPrinter.Parenthesizer | Lean.PrettyPrinter.Parenthesizer | true |
Ideal.fiberIsoOfBijectiveResidueField._proof_13 | Mathlib.RingTheory.Etale.QuasiFinite | ∀ {R : Type u_1} {R' : Type u_2} [inst : CommRing R] [inst_1 : CommRing R'] [inst_2 : Algebra R R'] {p : Ideal R}
{q : Ideal R'} [inst_3 : p.IsPrime] [inst_4 : q.IsPrime] [inst_5 : q.LiesOver p],
IsScalarTower R (IsLocalRing.ResidueField (Localization.AtPrime p))
(IsLocalRing.ResidueField (Localization.AtPrime ... | false |
ContMDiffAdd.of_le | Mathlib.Geometry.Manifold.Algebra.Monoid | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {H : Type u_2} [inst_1 : TopologicalSpace H] {E : Type u_3}
[inst_2 : NormedAddCommGroup E] [inst_3 : NormedSpace 𝕜 E] {I : ModelWithCorners 𝕜 E H} {G : Type u_4}
[inst_4 : Add G] [inst_5 : TopologicalSpace G] [inst_6 : ChartedSpace H G] {m n : WithTop ℕ∞},
... | true |
Lean.Elab.Tactic.eval._@.Lean.Elab.Tactic.Grind.Main.2210493511._hygCtx._hyg.3 | Lean.Elab.Tactic.Grind.Main | Lean.Expr → Lean.Elab.TermElabM Lean.Grind.ConfigInteractive | false |
IsAddRightRegular.add_right_eq_self_iff | Mathlib.Algebra.Regular.Basic | ∀ {R : Type u_1} [inst : AddMonoid R] {a b : R}, IsAddRightRegular a → (b + a = a ↔ b = 0) | true |
Equiv.emptySum.congr_simp | Mathlib.Order.RelIso.Basic | ∀ (α : Type u_9) (β : Type u_10) [inst : IsEmpty α], Equiv.emptySum α β = Equiv.emptySum α β | true |
HomotopicalAlgebra.FibrantObject.mk | Mathlib.AlgebraicTopology.ModelCategory.Bifibrant | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
[inst_1 : HomotopicalAlgebra.CategoryWithFibrations C] →
[inst_2 : CategoryTheory.Limits.HasTerminal C] →
(X : C) → [HomotopicalAlgebra.IsFibrant X] → HomotopicalAlgebra.FibrantObject C | true |
Std.DHashMap.Internal.Raw₀.Const.foldM_eq_foldlM_toList | Std.Data.DHashMap.Internal.RawLemmas | ∀ {α : Type u} {δ : Type w} {m' : Type w → Type w'} {β : Type v} (m : Std.DHashMap.Internal.Raw₀ α fun x => β)
[inst : Monad m'] [LawfulMonad m'] {f : δ → α → β → m' δ} {init : δ},
Std.DHashMap.Raw.foldM f init ↑m = List.foldlM (fun a b => f a b.1 b.2) init (Std.DHashMap.Raw.Const.toList ↑m) | true |
_private.Mathlib.Data.Finset.BooleanAlgebra.0.Finset.univ_filter_mem_range._proof_1_1 | Mathlib.Data.Finset.BooleanAlgebra | ∀ {α : Type u_2} {β : Type u_1} [inst : Fintype α] (f : α → β) [inst_1 : Fintype β]
[inst_2 : DecidablePred fun y => y ∈ Set.range f] [inst_3 : DecidableEq β],
{y | y ∈ Set.range f} = Finset.image f Finset.univ | false |
TopologicalSpace.OpenNhdsOf._sizeOf_1 | Mathlib.Topology.Sets.Opens | {α : Type u_2} → {inst : TopologicalSpace α} → {x : α} → [SizeOf α] → TopologicalSpace.OpenNhdsOf x → ℕ | false |
Lean.Parser.AliasValue.ctorElim | Lean.Parser.Extension | {α : Type} →
{motive : Lean.Parser.AliasValue α → Sort u} →
(ctorIdx : ℕ) →
(t : Lean.Parser.AliasValue α) → ctorIdx = t.ctorIdx → Lean.Parser.AliasValue.ctorElimType ctorIdx → motive t | false |
Std.DTreeMap.Internal.Impl.get!_union | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {instOrd : Ord α} {m₁ m₂ : Std.DTreeMap.Internal.Impl α β} [Std.TransOrd α]
[inst : Std.LawfulEqOrd α] (h₁ : m₁.WF) (h₂ : m₂.WF) {k : α} [inst_1 : Inhabited (β k)],
(m₁.union m₂ ⋯ ⋯).get! k = m₂.getD k (m₁.get! k) | true |
Order.Iic_succ | Mathlib.Order.SuccPred.Basic | ∀ {α : Type u_1} [inst : LinearOrder α] [inst_1 : SuccOrder α] (a : α),
Set.Iic (Order.succ a) = insert (Order.succ a) (Set.Iic a) | true |
_private.Mathlib.CategoryTheory.Adjunction.PartialAdjoint.0.CategoryTheory.Functor.isRightAdjoint_of_leftAdjointObjIsDefined_eq_top._simp_1_1 | Mathlib.CategoryTheory.Adjunction.PartialAdjoint | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
(F : CategoryTheory.Functor D C) (X : C),
(F.comp (CategoryTheory.coyoneda.obj (Opposite.op X))).IsCorepresentable = F.leftAdjointObjIsDefined X | false |
_private.Mathlib.Lean.Expr.Basic.0.Lean.Expr.isConstantApplication.aux | Mathlib.Lean.Expr.Basic | ℕ → Lean.Expr → ℕ → Bool | true |
_private.Mathlib.Algebra.Lie.LieTheorem.0.LieModule.weightSpaceOfIsLieTower_aux._simp_1_9 | Mathlib.Algebra.Lie.LieTheorem | ∀ {α : Sort u_1} {p : α → Prop} {q : (∃ x, p x) → Prop}, (∀ (h : ∃ x, p x), q h) = ∀ (x : α) (h : p x), q ⋯ | false |
exists_eq_sum_perm_of_mem_doublyStochastic | Mathlib.Analysis.Convex.Birkhoff | ∀ {R : Type u_1} {n : Type u_2} [inst : Fintype n] [inst_1 : DecidableEq n] [inst_2 : Field R] [inst_3 : LinearOrder R]
[inst_4 : IsStrictOrderedRing R] {M : Matrix n n R},
M ∈ doublyStochastic R n →
∃ w, (∀ (σ : Equiv.Perm n), 0 ≤ w σ) ∧ ∑ σ, w σ = 1 ∧ ∑ σ, w σ • Equiv.Perm.permMatrix R σ = M | true |
_private.Mathlib.Analysis.Calculus.ContDiff.FTaylorSeries.0.hasFTaylorSeriesUpTo_top_iff'._simp_1_4 | Mathlib.Analysis.Calculus.ContDiff.FTaylorSeries | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : AddCommGroup E] [inst_2 : Module 𝕜 E]
[inst_3 : TopologicalSpace E] {F : Type u_3} [inst_4 : AddCommGroup F] [inst_5 : Module 𝕜 F]
[inst_6 : TopologicalSpace F] {f : E → F} {f' : E →L[𝕜] F} {x : E},
HasFDerivWithinAt f f' Set.univ x... | false |
CategoryTheory.Closed.recOn | Mathlib.CategoryTheory.Monoidal.Closed.Basic | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
[inst_1 : CategoryTheory.MonoidalCategory C] →
{X : C} →
{motive : CategoryTheory.Closed X → Sort u_1} →
(t : CategoryTheory.Closed X) →
((rightAdj : CategoryTheory.Functor C C) →
(adj : CategoryTheory.M... | false |
_private.Mathlib.Analysis.Complex.Hadamard.0.Complex.HadamardThreeLines.F_BddAbove._simp_1_7 | Mathlib.Analysis.Complex.Hadamard | ∀ (r s : ℝ), ↑r + ↑s = ↑(r + s) | false |
Lean.Meta.MVarRenaming.mk.sizeOf_spec | Lean.Meta.Match.MVarRenaming | ∀ (map : Lean.MVarIdMap Lean.MVarId), sizeOf { map := map } = 1 + sizeOf map | true |
IsOpen.smul_sphere | Mathlib.Analysis.Normed.Module.Ball.RadialEquiv | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] {r : ℝ},
r ≠ 0 → ∀ {U : Set ℝ} {V : Set ↑(Metric.sphere 0 r)}, IsOpen U → 0 ∉ U → IsOpen V → IsOpen (U • Subtype.val '' V) | true |
CategoryTheory.Abelian.SpectralObject.toCycles_πE_descE | 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) (f₁₂ : i ⟶ k)
(h₁₂ : CategoryTheory.CategoryStruct.... | true |
_private.Lean.Compiler.LCNF.ToExpr.0.Lean.Compiler.LCNF.ToExpr.mkLambdaM.go._unary._proof_1 | Lean.Compiler.LCNF.ToExpr | ∀ {pu : Lean.Compiler.LCNF.Purity} (params : Array (Lean.Compiler.LCNF.Param pu))
(m : Lean.Compiler.LCNF.ToExpr.LevelMap) (offset i : ℕ) (e : Lean.Expr),
i > 0 →
InvImage (fun x1 x2 => x1 < x2) (fun x => PSigma.casesOn x fun offset i => PSigma.casesOn i fun i e => i)
⟨offset - 1,
⟨i - 1,
... | false |
AddSubgroup.MapSubtype.orderIso._proof_2 | Mathlib.Algebra.Group.Subgroup.Ker | ∀ {G : Type u_1} [inst : AddGroup G] (H : AddSubgroup G) (H' : AddSubgroup ↥H),
AddSubgroup.comap H.subtype (AddSubgroup.map H.subtype H') = H' | false |
CategoryTheory.Equivalence.changeFunctor_functor | Mathlib.CategoryTheory.Equivalence | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
(e : C ≌ D) {G : CategoryTheory.Functor C D} (iso : e.functor ≅ G), (e.changeFunctor iso).functor = G | true |
CategoryTheory.Functor.ShiftSequence.recOn | Mathlib.CategoryTheory.Shift.ShiftSequence | {C : Type u_1} →
{A : Type u_2} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
[inst_1 : CategoryTheory.Category.{v_2, u_2} A] →
{F : CategoryTheory.Functor C A} →
{M : Type u_3} →
[inst_2 : AddMonoid M] →
[inst_3 : CategoryTheory.HasShift C M] →
... | false |
_private.Mathlib.GroupTheory.MonoidLocalization.MonoidWithZero.0.Submonoid.LocalizationMap.isCancelMulZero._simp_1_1 | Mathlib.GroupTheory.MonoidLocalization.MonoidWithZero | ∀ {M₀ : Type u_2} [inst : Mul M₀] [inst_1 : Zero M₀], IsCancelMulZero M₀ = ∀ {a : M₀}, a ≠ 0 → IsRegular a | false |
HahnSeries.SummableFamily.hsum | Mathlib.RingTheory.HahnSeries.Summable | {Γ : Type u_1} →
{R : Type u_3} →
{α : Type u_5} →
[inst : PartialOrder Γ] → [inst_1 : AddCommMonoid R] → HahnSeries.SummableFamily Γ R α → HahnSeries Γ R | true |
IsDiscrete.image_of_isOpenMap_of_isOpen | Mathlib.Topology.DiscreteSubset | ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] {f : X → Y} {s : Set X},
IsDiscrete s → IsOpenMap f → IsOpen s → IsDiscrete (f '' s) | true |
BoundedContinuousFunction.instSemiring._proof_4 | Mathlib.Topology.ContinuousMap.Bounded.Basic | ∀ {α : Type u_1} {R : Type u_2} [inst : TopologicalSpace α] [inst_1 : PseudoMetricSpace R] [inst_2 : Semiring R]
[inst_3 : BoundedMul R] [inst_4 : ContinuousMul R] [inst_5 : BoundedAdd R] [inst_6 : ContinuousAdd R]
(a : BoundedContinuousFunction α R), a * 0 = 0 | false |
QuadraticMap.Isometry.id._proof_1 | Mathlib.LinearAlgebra.QuadraticForm.Isometry | ∀ {R : Type u_3} {M : Type u_2} {N : Type u_1} [inst : CommSemiring R] [inst_1 : AddCommMonoid M]
[inst_2 : AddCommMonoid N] [inst_3 : Module R M] [inst_4 : Module R N] (Q : QuadraticMap R M N) (x : M),
Q (LinearMap.id.toFun x) = Q (LinearMap.id.toFun x) | false |
Lean.Server.LoadedILean.mk.noConfusion | Lean.Server.References | {P : Sort u} →
{moduleUri : Lean.Lsp.DocumentUri} →
{ileanPath : System.FilePath} →
{directImports : Lean.Server.DirectImports} →
{refs : Lean.Lsp.ModuleRefs} →
{decls : Lean.Lsp.Decls} →
{moduleUri' : Lean.Lsp.DocumentUri} →
{ileanPath' : System.FilePath} →
... | false |
GaloisInsertion.isLUB_of_u_image | Mathlib.Order.GaloisConnection.Basic | ∀ {α : Type u} {β : Type v} {l : α → β} {u : β → α} [inst : Preorder α] [inst_1 : Preorder β] (gi : GaloisInsertion l u)
{s : Set β} {a : α}, IsLUB (u '' s) a → IsLUB s (l a) | true |
CliffordAlgebraQuaternion.toQuaternion._proof_2 | Mathlib.LinearAlgebra.CliffordAlgebra.Equivs | ∀ {R : Type u_1} [inst : CommRing R] {c₁ c₂ : R} (r : R) (v : R × R),
{ re := 0, imI := (r • v).1, imJ := (r • v).2, imK := 0 } =
(RingHom.id R) r • { re := 0, imI := v.1, imJ := v.2, imK := 0 } | false |
ContinuousMap.Homotopy.curry_zero | Mathlib.Topology.Homotopy.Basic | ∀ {X : Type u} {Y : Type v} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] {f₀ f₁ : C(X, Y)}
(F : f₀.Homotopy f₁), F.curry 0 = f₀ | true |
ValuativeRel.zero_vlt_mul | Mathlib.RingTheory.Valuation.ValuativeRel.Basic | ∀ {R : Type u_1} [inst : CommRing R] [inst_1 : ValuativeRel R] {x y : R}, 0 <ᵥ x → 0 <ᵥ y → 0 <ᵥ x * y | true |
DifferentiableOn.fun_sub_iff_right | Mathlib.Analysis.Calculus.FDeriv.Add | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {F : Type u_3} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {f g : E → F}
{s : Set E}, DifferentiableOn 𝕜 f s → (DifferentiableOn 𝕜 (fun i => f i - g i) s ↔ Differentiabl... | true |
Subgroup.closureCommGroupOfComm | Mathlib.GroupTheory.Subgroup.Centralizer | {G : Type u_1} → [inst : Group G] → {k : Set G} → (∀ x ∈ k, ∀ y ∈ k, x * y = y * x) → CommGroup ↥(Subgroup.closure k) | true |
instUniqueAddUnitsOfSubsingleton._proof_1 | Mathlib.Algebra.Group.Units.Basic | ∀ {M : Type u_1} [inst : AddMonoid M] [Subsingleton M] (x : AddUnits M), ↑x = 0 | false |
_private.Lean.Meta.Sym.Simp.Have.0.Lean.Meta.Sym.Simp.GetUnivsResult.noConfusion | Lean.Meta.Sym.Simp.Have | {P : Sort u} →
{t t' : Lean.Meta.Sym.Simp.GetUnivsResult✝} → t = t' → Lean.Meta.Sym.Simp.GetUnivsResult.noConfusionType✝ P t t' | false |
AddGroupExtension.Equiv.refl._proof_1 | Mathlib.GroupTheory.GroupExtension.Defs | ∀ {N : Type u_1} {E : Type u_2} {G : Type u_3} [inst : AddGroup N] [inst_1 : AddGroup E] [inst_2 : AddGroup G]
(S : AddGroupExtension N E G), ⇑(AddEquiv.refl E) ∘ ⇑S.inl = ⇑(AddEquiv.refl E) ∘ ⇑S.inl | false |
Function.HasTemperateGrowth.toTemperedDistribution_apply | Mathlib.Analysis.Distribution.TemperedDistribution | ∀ {E : Type u_3} {F : Type u_4} [inst : NormedAddCommGroup E] [inst_1 : NormedAddCommGroup F] [inst_2 : NormedSpace ℝ E]
[inst_3 : NormedSpace ℂ F] [inst_4 : MeasurableSpace E] [inst_5 : BorelSpace E] [inst_6 : SecondCountableTopology E]
(μ : autoParam (MeasureTheory.Measure E) _auto_44✝) [hμ : μ.HasTemperateGrowth... | true |
CommRingCat.Colimits.colimitIsColimit._proof_1 | Mathlib.Algebra.Category.Ring.Colimits | ∀ {J : Type u_1} [inst : CategoryTheory.SmallCategory J] (F : CategoryTheory.Functor J CommRingCat)
(s : CategoryTheory.Limits.Cocone F) (j : J),
CategoryTheory.CategoryStruct.comp ((CommRingCat.Colimits.colimitCocone F).ι.app j)
(CommRingCat.Colimits.descMorphism F s) =
s.ι.app j | false |
Frm.hom_ext | Mathlib.Order.Category.Frm | ∀ {X Y : Frm} {f g : X ⟶ Y}, Frm.Hom.hom f = Frm.Hom.hom g → f = g | true |
IsDedekindDomain.HeightOneSpectrum.adicAbv_coe_le_one | Mathlib.RingTheory.DedekindDomain.AdicValuation | ∀ {R : Type u_1} [inst : CommRing R] [inst_1 : IsDedekindDomain R] {K : Type u_2} [inst_2 : Field K]
[inst_3 : Algebra R K] [inst_4 : IsFractionRing R K] (v : IsDedekindDomain.HeightOneSpectrum R) {b : NNReal}
(hb : 1 < b) (r : R), (v.adicAbv hb) ((algebraMap R K) r) ≤ 1 | true |
DFinsupp.le_iff | Mathlib.Data.DFinsupp.Order | ∀ {ι : Type u_1} {α : ι → Type u_2} [inst : (i : ι) → AddCommMonoid (α i)] [inst_1 : (i : ι) → PartialOrder (α i)]
[∀ (i : ι), CanonicallyOrderedAdd (α i)] [inst_3 : DecidableEq ι] [inst_4 : (i : ι) → (x : α i) → Decidable (x ≠ 0)]
{f g : Π₀ (i : ι), α i}, f ≤ g ↔ ∀ i ∈ f.support, f i ≤ g i | true |
Std.Tactic.BVDecide.LRAT.Internal.ReduceResult._sizeOf_inst | Std.Tactic.BVDecide.LRAT.Internal.Clause | (α : Type u) → [SizeOf α] → SizeOf (Std.Tactic.BVDecide.LRAT.Internal.ReduceResult α) | false |
CategoryTheory.Limits.equalizer.fork_ι | Mathlib.CategoryTheory.Limits.Shapes.Equalizers | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y : C} (f g : X ⟶ Y)
[inst_1 : CategoryTheory.Limits.HasEqualizer f g],
(CategoryTheory.Limits.equalizer.fork f g).ι = CategoryTheory.Limits.equalizer.ι f g | true |
QuasilinearOn.dual | Mathlib.Analysis.Convex.Quasiconvex | ∀ {𝕜 : Type u_1} {E : Type u_2} {β : Type u_3} [inst : Semiring 𝕜] [inst_1 : PartialOrder 𝕜] [inst_2 : AddCommMonoid E]
[inst_3 : LE β] [inst_4 : SMul 𝕜 E] {s : Set E} {f : E → β},
QuasilinearOn 𝕜 s f → QuasilinearOn 𝕜 s (⇑OrderDual.toDual ∘ f) | true |
Matrix.toMvPolynomial_totalDegree_le | Mathlib.Algebra.Module.LinearMap.Polynomial | ∀ {m : Type u_1} {n : Type u_2} {R : Type u_4} [inst : Fintype n] [inst_1 : CommSemiring R] (M : Matrix m n R) (i : m),
(M.toMvPolynomial i).totalDegree ≤ 1 | true |
LinearMap.toMatrixOrthonormal | Mathlib.Analysis.InnerProductSpace.Adjoint | {𝕜 : Type u_1} →
{E : Type u_2} →
[inst : RCLike 𝕜] →
[inst_1 : NormedAddCommGroup E] →
[inst_2 : InnerProductSpace 𝕜 E] →
{n : Type u_6} →
[inst_3 : Fintype n] →
[DecidableEq n] →
[inst_5 : FiniteDimensional 𝕜 E] → OrthonormalBasis n 𝕜 E → (E... | true |
MeasureTheory.Submartingale.ae_tendsto_limitProcess | Mathlib.Probability.Martingale.Convergence | ∀ {Ω : Type u_1} {m0 : MeasurableSpace Ω} {μ : MeasureTheory.Measure Ω} {ℱ : MeasureTheory.Filtration ℕ m0}
{f : ℕ → Ω → ℝ} {R : NNReal} [MeasureTheory.IsFiniteMeasure μ],
MeasureTheory.Submartingale f ℱ μ →
(∀ (n : ℕ), MeasureTheory.eLpNorm (f n) 1 μ ≤ ↑R) →
∀ᵐ (ω : Ω) ∂μ, Filter.Tendsto (fun n => f n ω)... | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.