name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
ContinuousLinearMap.prod_ext | Mathlib.Topology.Algebra.Module.ContinuousLinearMap.PiProd | ∀ {R : Type u_1} [inst : Semiring R] {M : Type u_2} [inst_1 : TopologicalSpace M] [inst_2 : AddCommMonoid M]
[inst_3 : Module R M] {M₂ : Type u_3} [inst_4 : TopologicalSpace M₂] [inst_5 : AddCommMonoid M₂]
[inst_6 : Module R M₂] {M₃ : Type u_4} [inst_7 : TopologicalSpace M₃] [inst_8 : AddCommMonoid M₃]
[inst_9 : ... | null | true |
Delone.DeloneSet.mapBilipschitz_trans | Mathlib.Analysis.AperiodicOrder.Delone.Basic | ∀ {X : Type u_1} {Y : Type u_2} [inst : MetricSpace X] [inst_1 : MetricSpace Y] {Z : Type u_3} [inst_2 : MetricSpace Z]
(D : Delone.DeloneSet X) (f : X ≃ Y) (g : Y ≃ Z) (K₁f K₂f K₁g K₂g : NNReal) (hf₁_pos : 0 < K₁f) (hf₂_pos : 0 < K₂f)
(hg₁_pos : 0 < K₁g) (hg₂_pos : 0 < K₂g) (hf_anti : AntilipschitzWith K₁f ⇑f) (hf... | null | true |
ContinuousOn.exists_isMaxOn' | Mathlib.Topology.Order.Compact | ∀ {α : Type u_2} {β : Type u_3} [inst : LinearOrder α] [inst_1 : TopologicalSpace α] [inst_2 : TopologicalSpace β]
[ClosedIciTopology α] {s : Set β} {f : β → α},
ContinuousOn f s →
IsClosed s →
∀ {x₀ : β}, x₀ ∈ s → (∀ᶠ (x : β) in Filter.cocompact β ⊓ Filter.principal s, f x ≤ f x₀) → ∃ x ∈ s, IsMaxOn f s ... | The **extreme value theorem**: if a function `f` is continuous on a closed set `s` and it is
smaller than a value in its image away from compact sets, then it has a maximum on this set. | true |
CategoryTheory.ReflQuiv.adj | Mathlib.CategoryTheory.Category.ReflQuiv | CategoryTheory.Cat.freeRefl ⊣ CategoryTheory.ReflQuiv.forget | The adjunction between forming the free category on a reflexive quiver, and forgetting a category
to a reflexive quiver.
| true |
WithTop.ofDual | Mathlib.Order.WithBot | {α : Type u_1} → WithTop αᵒᵈ ≃ WithBot α | `WithTop.ofDual` is the equivalence sending `⊤` to `⊥` and any `a : αᵒᵈ` to `ofDual a : α`.
See `WithTop.toDualBotEquiv` for the related order-iso. | true |
_private.Mathlib.NumberTheory.NumberField.House.0.NumberField.house.c | Mathlib.NumberTheory.NumberField.House | (K : Type u_1) → [inst : Field K] → [NumberField K] → [DecidableEq (K →+* ℂ)] → ℝ | `c` is defined as the product of the maximum absolute
value of the entries of the inverse of the matrix `basisMatrix` and `finrank ℚ K`. | true |
_private.Init.Data.Iterators.Lemmas.Consumers.Monadic.Loop.0.Std.IterM.DefaultConsumers.forIn'_eq_match_step.match_1.eq_1 | Init.Data.Iterators.Lemmas.Consumers.Monadic.Loop | ∀ {β : Type u_3} {γ : Type u_1} {init : γ} (PlausibleForInStep : β → γ → ForInStep γ → Prop) (out : β)
(motive : Subtype (PlausibleForInStep out init) → Sort u_2) (c : γ)
(property : PlausibleForInStep out init (ForInStep.yield c))
(h_1 : (c : γ) → (property : PlausibleForInStep out init (ForInStep.yield c)) → mo... | null | true |
_private.Init.Data.BitVec.Lemmas.0.BitVec.msb_one._simp_1_1 | Init.Data.BitVec.Lemmas | ∀ (p q : Prop) [dpq : Decidable (p ∧ q)] [dp : Decidable p] [dq : Decidable q], (decide p && decide q) = decide (p ∧ q) | null | false |
ISize.ofInt_int64ToInt | Init.Data.SInt.Lemmas | ∀ (x : Int64), ISize.ofInt x.toInt = x.toISize | null | true |
Lean.StructureDescr.noConfusion | Lean.Structure | {P : Sort u} → {t t' : Lean.StructureDescr} → t = t' → Lean.StructureDescr.noConfusionType P t t' | null | false |
Ordset.pos_size_of_mem | Mathlib.Data.Ordmap.Ordset | ∀ {α : Type u_1} [inst : Preorder α] [inst_1 : DecidableLE α] {x : α} {t : Ordset α}, x ∈ t → 0 < t.size | null | true |
Ultrafilter.comap_pure | Mathlib.Order.Filter.Ultrafilter.Defs | ∀ {α : Type u} {β : Type v} {m : α → β} (a : α) (inj : Function.Injective m) (large : Set.range m ∈ pure (m a)),
(pure (m a)).comap inj large = pure a | null | true |
Group.IsNilpotent.nilpotent | Mathlib.GroupTheory.Nilpotent | ∀ (G : Type u_2) [inst : Group G] [Group.IsNilpotent G], ∃ n, Subgroup.upperCentralSeries G n = ⊤ | null | true |
Representation.IntertwiningMap.prod._proof_1 | Mathlib.RepresentationTheory.Intertwining | ∀ {A : Type u_4} {G : Type u_5} {V : Type u_3} {W : Type u_1} {U : Type u_2} [inst : Semiring A] [inst_1 : Monoid G]
[inst_2 : AddCommMonoid V] [inst_3 : AddCommMonoid W] [inst_4 : AddCommMonoid U] [inst_5 : Module A V]
[inst_6 : Module A W] [inst_7 : Module A U] {ρ : Representation A G V} {σ : Representation A G W... | null | false |
CategoryTheory.Functor.PreservesPointwiseLeftKanExtensionAt.mk | Mathlib.CategoryTheory.Functor.KanExtension.Preserves | ∀ {A : Type u_1} {B : Type u_2} {C : Type u_3} {D : Type u_4} [inst : CategoryTheory.Category.{v_1, u_1} A]
[inst_1 : CategoryTheory.Category.{v_2, u_2} B] [inst_2 : CategoryTheory.Category.{v_3, u_3} C]
[inst_3 : CategoryTheory.Category.{v_4, u_4} D] {G : CategoryTheory.Functor B D} {F : CategoryTheory.Functor A B... | null | true |
UniformOnFun.isUniformEmbedding_toFun_finite | Mathlib.Topology.UniformSpace.UniformConvergenceTopology | ∀ (α : Type u_1) (β : Type u_2) [inst : UniformSpace β], IsUniformEmbedding ⇑(UniformOnFun.toFun {s | s.Finite}) | null | true |
CategoryTheory.Oplax.LaxTrans.OplaxFunctor.bicategory._proof_16 | Mathlib.CategoryTheory.Bicategory.FunctorBicategory.Oplax | ∀ (B : Type u_5) [inst : CategoryTheory.Bicategory B] (C : Type u_6) [inst_1 : CategoryTheory.Bicategory C]
{a b c d : CategoryTheory.OplaxFunctor B C} {f f' : a ⟶ b} (η : f ⟶ f') (g : b ⟶ c) (h : c ⟶ d),
CategoryTheory.Oplax.LaxTrans.whiskerRight η (CategoryTheory.CategoryStruct.comp g h) =
CategoryTheory.Cate... | null | false |
Lean.Meta.Sym.Arith.State.typeClassify._default | Lean.Meta.Sym.Arith.Types | Lean.PersistentHashMap Lean.Meta.Sym.ExprPtr Lean.Meta.Sym.Arith.ClassifyResult | null | false |
Cardinal.instLE | Mathlib.SetTheory.Cardinal.Order | LE Cardinal.{u} | We define the order on cardinal numbers by `#α ≤ #β` if and only if
there exists an embedding (injective function) from α to β. | true |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.Const.size_insertManyIfNewUnit_list_le._simp_1_1 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {x : Ord α} {x_1 : BEq α} [Std.LawfulBEqOrd α] {a b : α}, (compare a b = Ordering.eq) = ((a == b) = true) | null | false |
instCategoryCompactum._proof_8 | Mathlib.Topology.Category.Compactum | autoParam
(∀ {X Y : Compactum} (f : X ⟶ Y), CategoryTheory.CategoryStruct.comp f (CategoryTheory.CategoryStruct.id Y) = f)
CategoryTheory.Category.comp_id._autoParam | null | false |
AddMonoidAlgebra.toMultiplicative_single | Mathlib.Algebra.MonoidAlgebra.MapDomain | ∀ {R : Type u_3} {M : Type u_6} [inst : Semiring R] [inst_1 : Add M] (m : M) (r : R),
(AddMonoidAlgebra.toMultiplicative R M) (AddMonoidAlgebra.single m r) =
MonoidAlgebra.single (Multiplicative.ofAdd m) r | null | true |
Quaternion.coeComplex_mul._simp_1 | Mathlib.Analysis.Quaternion | ∀ (z w : ℂ), ↑z * ↑w = ↑(z * w) | null | false |
ContinuousLinearMap.coe_prodMap' | Mathlib.Topology.Algebra.Module.ContinuousLinearMap.PiProd | ∀ {R : Type u_1} [inst : Semiring R] {M₁ : Type u_2} [inst_1 : TopologicalSpace M₁] [inst_2 : AddCommMonoid M₁]
[inst_3 : Module R M₁] {M₂ : Type u_3} [inst_4 : TopologicalSpace M₂] [inst_5 : AddCommMonoid M₂]
[inst_6 : Module R M₂] {M₃ : Type u_4} [inst_7 : TopologicalSpace M₃] [inst_8 : AddCommMonoid M₃]
[inst_... | null | true |
CategoryTheory.Arrow.RightHomotopy.add | Mathlib.CategoryTheory.Preadditive.FreydCategory.Homotopy | {V : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} V] →
[inst_1 : CategoryTheory.Preadditive V] →
{u v : CategoryTheory.Arrow V} →
{f₁ g₁ f₂ g₂ : u ⟶ v} →
CategoryTheory.Arrow.RightHomotopy f₁ g₁ →
CategoryTheory.Arrow.RightHomotopy f₂ g₂ → CategoryTheory.Arrow.RightHo... | The sum of two right homotopies is a right homotopy between the sum of the respective
morphisms. | true |
Option.mem_toArray | Init.Data.Option.Array | ∀ {α : Type u_1} {a : α} {o : Option α}, a ∈ o.toArray ↔ o = some a | null | true |
_private.Lean.Elab.SyntheticMVars.0.Lean.Elab.Term.TacticMVarKind.maybeWithoutRecovery | Lean.Elab.SyntheticMVars | {α : Type} → Lean.Elab.Term.TacticMVarKind → Lean.Elab.Tactic.TacticM α → Lean.Elab.Tactic.TacticM α | null | true |
DividedPowers.mk.congr_simp | Mathlib.RingTheory.DividedPowers.Basic | ∀ {A : Type u_1} [inst : CommSemiring A] {I : Ideal A} (dpow dpow_1 : ℕ → A → A) (e_dpow : dpow = dpow_1)
(dpow_null : ∀ {n : ℕ} {x : A}, x ∉ I → dpow n x = 0) (dpow_zero : ∀ {x : A}, x ∈ I → dpow 0 x = 1)
(dpow_one : ∀ {x : A}, x ∈ I → dpow 1 x = x) (dpow_mem : ∀ {n : ℕ} {x : A}, n ≠ 0 → x ∈ I → dpow n x ∈ I)
(d... | null | true |
_private.Std.Data.DTreeMap.Internal.WF.Lemmas.0.Std.DTreeMap.Internal.Impl.getThenInsertIfNew?.match_1.eq_2 | Std.Data.DTreeMap.Internal.WF.Lemmas | ∀ {α : Type u_3} {β : α → Type u_1} (k : α) (motive : Option (β k) → Sort u_2) (b : β k) (h_1 : Unit → motive none)
(h_2 : (b : β k) → motive (some b)),
(match some b with
| none => h_1 ()
| some b => h_2 b) =
h_2 b | null | true |
instMonadFinallyEIO._aux_1 | Init.System.IO | {ε α β : Type} → EIO ε α → (Option α → EIO ε β) → EIO ε (α × β) | null | false |
Set.BijOn.iterate | Mathlib.Data.Set.Function | ∀ {α : Type u_1} {f : α → α} {s : Set α}, Set.BijOn f s s → ∀ (n : ℕ), Set.BijOn f^[n] s s | null | true |
AddSubgroupClass.normedAddCommGroup | Mathlib.Analysis.Normed.Group.Subgroup | {E : Type u_1} →
[inst : NormedAddCommGroup E] →
{S : Type u_2} → [inst_1 : SetLike S E] → [AddSubgroupClass S E] → (s : S) → NormedAddCommGroup ↥s | null | true |
Vector.flatMap_empty._proof_1 | Init.Data.Vector.Lemmas | ∀ {m : ℕ}, 0 = 0 * m | null | false |
IsAlgClosed.instInfinite | Mathlib.FieldTheory.IsAlgClosed.Basic | ∀ {K : Type u_1} [inst : Field K] [IsAlgClosed K], Infinite K | Algebraically closed fields are infinite since `Xⁿ⁺¹ - 1` is separable when `#K = n` | true |
_private.Mathlib.Data.Nat.Digits.Lemmas.0.List.fixedLengthDigits_one._proof_1_1 | Mathlib.Data.Nat.Digits.Lemmas | ∀ {b : ℕ} (a : List ℕ), ((∃ a_1, a = [a_1]) ∧ ∀ x ∈ a, x < b) ↔ a ∈ Finset.image (fun x => [x]) (Finset.range b) | null | false |
Set.union_distrib_iInter_left | Mathlib.Data.Set.Lattice.Bounded | ∀ {α : Type u_1} {ι : Sort u_4} (s : ι → Set α) (t : Set α), t ∪ ⋂ i, s i = ⋂ i, t ∪ s i | null | true |
Matrix.seminormedAddCommGroup._proof_3 | Mathlib.Analysis.Matrix.Normed | ∀ {m : Type u_1} {n : Type u_2} {α : Type u_3} [inst : Fintype m] [inst_1 : Fintype n]
[inst_2 : SeminormedAddCommGroup α] (x y z : Matrix m n α), dist x z ≤ dist x y + dist y z | null | false |
_private.Mathlib.Data.EReal.Basic.0.EReal.coe_ennreal_mul.match_1_1 | Mathlib.Data.EReal.Basic | ∀ (motive : ENNReal → ENNReal → Prop) (x x_1 : ENNReal),
(∀ (_ : Unit), motive none none) →
(∀ (y : NNReal), motive none (some y)) →
(∀ (x : NNReal), motive (some x) none) → (∀ (x y : NNReal), motive (some x) (some y)) → motive x x_1 | null | false |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.size_filter_le_size._simp_1_1 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {x : Ord α} {x_1 : BEq α} [Std.LawfulBEqOrd α] {a b : α}, (compare a b = Ordering.eq) = ((a == b) = true) | null | false |
Polynomial.map_list_prod | Mathlib.Algebra.Polynomial.Eval.Defs | ∀ {R : Type u} {S : Type v} [inst : Semiring R] [inst_1 : Semiring S] (f : R →+* S) (L : List (Polynomial R)),
Polynomial.map f L.prod = (List.map (Polynomial.map f) L).prod | null | true |
_private.Mathlib.LinearAlgebra.Matrix.ToLinearEquiv.0.Matrix.exists_vecMul_eq_zero_iff._simp_1_1 | Mathlib.LinearAlgebra.Matrix.ToLinearEquiv | ∀ {m : Type u_2} {n : Type u_3} {α : Type v} [inst : NonUnitalCommSemiring α] [inst_1 : Fintype m] (A : Matrix m n α)
(x : m → α), Matrix.vecMul x A = A.transpose.mulVec x | null | false |
Ordnode.span._unsafe_rec | Mathlib.Data.Ordmap.Ordnode | {α : Type u_1} → (p : α → Prop) → [DecidablePred p] → Ordnode α → Ordnode α × Ordnode α | null | false |
NonAssocSemiring.one_mul | Mathlib.Algebra.Ring.Defs | ∀ {α : Type u} [self : NonAssocSemiring α] (a : α), 1 * a = a | One is a left neutral element for multiplication | true |
Matroid.IsRestriction.exists_eq_restrict | Mathlib.Combinatorics.Matroid.Minor.Restrict | ∀ {α : Type u_1} {M N : Matroid α}, N.IsRestriction M → ∃ R ⊆ M.E, N = M.restrict R | null | true |
ULift.addCommGroup._proof_5 | Mathlib.Algebra.Group.ULift | ∀ {α : Type u_2} [inst : AddCommGroup α] (x : ULift.{u_1, u_2} α) (x_1 : ℕ),
Equiv.ulift (x_1 • x) = Equiv.ulift (x_1 • x) | null | false |
RingCat.Hom.ext_iff | Mathlib.Algebra.Category.Ring.Basic | ∀ {R S : RingCat} {x y : R.Hom S}, x = y ↔ x.hom' = y.hom' | null | true |
IsStronglyAtomic.casesOn | Mathlib.Order.Atoms | {α : Type u_5} →
[inst : Preorder α] →
{motive : IsStronglyAtomic α → Sort u} →
(t : IsStronglyAtomic α) →
((exists_covBy_le_of_lt : ∀ (a b : α), a < b → ∃ x, a ⋖ x ∧ x ≤ b) → motive ⋯) → motive t | null | false |
Finset.forall_mem_cons | Mathlib.Data.Finset.Insert | ∀ {α : Type u_1} {s : Finset α} {a : α} (h : a ∉ s) (p : α → Prop), (∀ x ∈ Finset.cons a s h, p x) ↔ p a ∧ ∀ x ∈ s, p x | null | true |
Lean.maxCtorTag | Lean.Runtime | ℕ | null | true |
Homotopy.dNext_cochainComplex | Mathlib.Algebra.Homology.Homotopy | ∀ {V : Type u} [inst : CategoryTheory.Category.{v, u} V] [inst_1 : CategoryTheory.Preadditive V]
{P Q : CochainComplex V ℕ} (f : (i j : ℕ) → P.X i ⟶ Q.X j) (j : ℕ),
(dNext j) f = CategoryTheory.CategoryStruct.comp (P.d j (j + 1)) (f (j + 1) j) | null | true |
MeasureTheory.VectorMeasure.semivariation | Mathlib.MeasureTheory.VectorMeasure.Variation.Semivariation | {X : Type u_1} →
{E : Type u_2} →
[inst : NormedAddCommGroup E] →
[NormedSpace ℝ E] → {mX : MeasurableSpace X} → MeasureTheory.VectorMeasure X E → Set X → ENNReal | The semivariation of a vector measure, defined as the supremum of the variations
of the images of the vector measures under continuous linear forms of norm at most `1`. | true |
InnerProductSpace.toDualMap._proof_4 | Mathlib.Analysis.InnerProductSpace.Dual | ∀ (𝕜 : Type u_1) [inst : RCLike 𝕜], ContinuousConstSMul 𝕜 𝕜 | null | false |
Qq.QuotedLevelDefEq | Qq.Typ | Lean.Level → Lean.Level → Prop | `QuotedLevelDefEq u v` says that the levels `u` and `v` are definitionally equal.
You should usually write this using the notation `$u =QL $v`.
| true |
Int.cast_lt_zero | Mathlib.Algebra.Order.Ring.Cast | ∀ {R : Type u_1} [inst : AddCommGroupWithOne R] [inst_1 : PartialOrder R] [AddLeftMono R] [ZeroLEOneClass R] [NeZero 1]
{n : ℤ}, ↑n < 0 ↔ n < 0 | null | true |
WeierstrassCurve.Affine.Equation.map | Mathlib.AlgebraicGeometry.EllipticCurve.Affine.Basic | ∀ {R : Type r} [inst : CommRing R] {W : WeierstrassCurve.Affine R} {S : Type s} [inst_1 : CommRing S] (f : R →+* S)
{x y : R}, W.Equation x y → (W.map f).Equation (f x) (f y) | null | true |
CategoryTheory.ObjectProperty.instIsClosedUnderExtensionsTop | Mathlib.CategoryTheory.ObjectProperty.Extensions | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C],
⊤.IsClosedUnderExtensions | null | true |
_private.Mathlib.Analysis.Analytic.ConvergenceRadius.0.FormalMultilinearSeries.isLittleO_of_lt_radius._simp_1_8 | Mathlib.Analysis.Analytic.ConvergenceRadius | ∀ {M₀ : Type u_1} [inst : MonoidWithZero M₀] {a : M₀} [IsReduced M₀] (n : ℕ), a ≠ 0 → (a ^ n = 0) = False | null | false |
_private.Lean.Meta.Tactic.Simp.BuiltinSimprocs.Char.0._regBuiltin.Char.reduceToString.declare_66._@.Lean.Meta.Tactic.Simp.BuiltinSimprocs.Char.3888730479._hygCtx._hyg.23 | Lean.Meta.Tactic.Simp.BuiltinSimprocs.Char | IO Unit | null | false |
differentIdeal._proof_4 | Mathlib.RingTheory.DedekindDomain.Different | ∀ (A : Type u_1) (B : Type u_2) [inst : CommRing A] [inst_1 : CommRing B] [inst_2 : Algebra A B] [inst_3 : IsDomain A]
[inst_4 : IsDedekindDomain B] [inst_5 : Module.IsTorsionFree A B], IsScalarTower A (FractionRing A) (FractionRing B) | null | false |
HomologicalComplex.instPreservesColimitsOfShapeEvalOfHasColimitsOfShape | Mathlib.Algebra.Homology.HomologicalComplexLimits | ∀ {C : Type u_1} {ι : Type u_2} {J : Type u_3} [inst : CategoryTheory.Category.{v_1, u_1} C]
[inst_1 : CategoryTheory.Category.{v_2, u_3} J] {c : ComplexShape ι}
[inst_2 : CategoryTheory.Limits.HasZeroMorphisms C] [CategoryTheory.Limits.HasColimitsOfShape J C] (n : ι),
CategoryTheory.Limits.PreservesColimitsOfSha... | null | true |
Rat.abs_nonneg | Init.Data.Rat.Lemmas | ∀ {x : ℚ}, 0 ≤ x.abs | null | true |
FreeGroup.lift_mk | Mathlib.GroupTheory.FreeGroup.Basic | ∀ {α : Type u} {L : List (α × Bool)} {β : Type v} [inst : Group β] {f : α → β},
(FreeGroup.lift f) (FreeGroup.mk L) = (List.map (fun x => bif x.2 then f x.1 else (f x.1)⁻¹) L).prod | null | true |
TopologicalSpace.Compacts.regularSpace_iff | Mathlib.Topology.Sets.VietorisTopology | ∀ {α : Type u_1} [inst : TopologicalSpace α], RegularSpace (TopologicalSpace.Compacts α) ↔ RegularSpace α | null | true |
_private.Mathlib.Data.List.AList.0.AList.insertRec.match_1.eq_1 | Mathlib.Data.List.AList | ∀ {α : Type u_1} {β : α → Type u_2} (motive : AList β → Sort u_3) (nodupKeys : [].NodupKeys)
(h_1 : (nodupKeys : [].NodupKeys) → motive { entries := [], nodupKeys := nodupKeys })
(h_2 :
(c : Sigma β) → (l : List (Sigma β)) → (h : (c :: l).NodupKeys) → motive { entries := c :: l, nodupKeys := h }),
(match { en... | null | true |
Aesop.Script.StaticStructureM.State.mk.inj | Aesop.Script.StructureStatic | ∀ {perfect perfect_1 : Bool}, { perfect := perfect } = { perfect := perfect_1 } → perfect = perfect_1 | null | true |
Lean.MonadFileMap | Lean.Data.Position | (Type → Type) → Type | null | true |
AddSubgroup.SubgroupNormal.mem_comm | Mathlib.Algebra.Group.Subgroup.Basic | ∀ {G : Type u_1} [inst : AddGroup G] {H K : AddSubgroup G},
H ≤ K → ∀ [hN : (H.addSubgroupOf K).Normal] {a b : G}, b ∈ K → a + b ∈ H → b + a ∈ H | null | true |
NormedAddGroupHom.smul.match_1 | Mathlib.Analysis.Normed.Group.Hom | ∀ {V₁ : Type u_2} {V₂ : Type u_1} [inst : SeminormedAddCommGroup V₁] [inst_1 : SeminormedAddCommGroup V₂]
(f : NormedAddGroupHom V₁ V₂) (motive : (∃ C, ∀ (v : V₁), ‖f.toFun v‖ ≤ C * ‖v‖) → Prop)
(x : ∃ C, ∀ (v : V₁), ‖f.toFun v‖ ≤ C * ‖v‖),
(∀ (b : ℝ) (hb : ∀ (v : V₁), ‖f.toFun v‖ ≤ b * ‖v‖), motive ⋯) → motive x | null | false |
CategoryTheory.Comonad.Coalgebra.casesOn | Mathlib.CategoryTheory.Monad.Algebra | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{G : CategoryTheory.Comonad C} →
{motive : G.Coalgebra → Sort u} →
(t : G.Coalgebra) →
((A : C) →
(a : A ⟶ G.obj A) →
(counit : CategoryTheory.CategoryStruct.comp a (G.ε.app A) = CategoryTheory.Cate... | null | false |
Submodule.map₂_eq_span_image2 | Mathlib.Algebra.Module.Submodule.Bilinear | ∀ {R : Type u_1} {M : Type u_2} {N : Type u_3} {P : Type u_4} [inst : CommSemiring R] [inst_1 : AddCommMonoid M]
[inst_2 : AddCommMonoid N] [inst_3 : AddCommMonoid P] [inst_4 : Module R M] [inst_5 : Module R N]
[inst_6 : Module R P] (f : M →ₗ[R] N →ₗ[R] P) (p : Submodule R M) (q : Submodule R N),
Submodule.map₂ f... | null | true |
Lean.Export.OfState.noConfusion | Mathlib.Util.Export | {P : Sort u} →
{α : Type} →
{inst : BEq α} →
{inst_1 : Hashable α} →
{t : Lean.Export.OfState α} →
{α' : Type} →
{inst' : BEq α'} →
{inst'_1 : Hashable α'} →
{t' : Lean.Export.OfState α'} →
α = α' → inst ≍ inst' → inst_1 ≍ inst'_1... | null | false |
AddSubgroup.isFiniteRelIndex_of_finiteIndex | Mathlib.GroupTheory.Index | ∀ {G : Type u_1} [inst : AddGroup G] {H K : AddSubgroup G} [h : H.FiniteIndex], H.IsFiniteRelIndex K | null | true |
Graph.disjoint_iff._simp_1 | Mathlib.Combinatorics.Graph.Lattice | ∀ {α : Type u_1} {β : Type u_2} {G H : Graph α β}, Disjoint G H = Disjoint G.vertexSet H.vertexSet | null | false |
_private.Mathlib.LinearAlgebra.Matrix.ToLin.0.Matrix.ker_mulVecLin_eq_bot_iff._simp_1_1 | Mathlib.LinearAlgebra.Matrix.ToLin | ∀ {R : Type u_1} {M : Type u_3} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
(p : Submodule R M), (p = ⊥) = ∀ x ∈ p, x = 0 | null | false |
Lean.Elab.Term.ToDepElimPattern.Context.explicitPatternVars._default | Lean.Elab.Match | Array Lean.FVarId | null | false |
CategoryTheory.ShortComplex.leftHomologyMap_comp | Mathlib.Algebra.Homology.ShortComplex.LeftHomology | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{S₁ S₂ S₃ : CategoryTheory.ShortComplex C} [inst_2 : S₁.HasLeftHomology] [inst_3 : S₂.HasLeftHomology]
[inst_4 : S₃.HasLeftHomology] (φ₁ : S₁ ⟶ S₂) (φ₂ : S₂ ⟶ S₃),
CategoryTheory.ShortComplex.leftHom... | null | true |
Std.TreeSet.min_erase_eq_of_not_compare_eq_min | Std.Data.TreeSet.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t : Std.TreeSet α cmp} [inst : Std.TransCmp cmp] {k : α}
{he : (t.erase k).isEmpty = false}, ¬cmp k (t.min ⋯) = Ordering.eq → (t.erase k).min he = t.min ⋯ | null | true |
Mathlib.Tactic.Linarith.CompSource | Mathlib.Tactic.Linarith.Oracle.FourierMotzkin | Type | `CompSource` tracks the source of a comparison.
The atomic source of a comparison is an assumption, indexed by a natural number.
Two comparisons can be added to produce a new comparison,
and one comparison can be scaled by a natural number to produce a new comparison.
| true |
Nat.avg_le_left | Batteries.Data.Nat.Bisect | ∀ {b a : ℕ}, b ≤ a → a.avg b ≤ a | null | true |
Turing.TM1to1.trTape'_move_left | Mathlib.Computability.TuringMachine.PostTuringMachine | ∀ {Γ : Type u_1} {n : ℕ} {enc : Γ → List.Vector Bool n} [inst : Inhabited Γ]
(enc0 : enc default = List.Vector.replicate n false) (L R : Turing.ListBlank Γ),
(Turing.Tape.move Turing.Dir.left)^[n] (Turing.TM1to1.trTape' enc0 L R) =
Turing.TM1to1.trTape' enc0 L.tail (Turing.ListBlank.cons L.head R) | null | true |
Set.BijOn.prodMap | Mathlib.Data.Set.Function | ∀ {α₁ : Type u_6} {α₂ : Type u_7} {β₁ : Type u_8} {β₂ : Type u_9} {s₁ : Set α₁} {s₂ : Set α₂} {t₁ : Set β₁}
{t₂ : Set β₂} {f₁ : α₁ → β₁} {f₂ : α₂ → β₂},
Set.BijOn f₁ s₁ t₁ → Set.BijOn f₂ s₂ t₂ → Set.BijOn (fun x => (f₁ x.1, f₂ x.2)) (s₁ ×ˢ s₂) (t₁ ×ˢ t₂) | null | true |
CoalgHom.noConfusion | Mathlib.RingTheory.Coalgebra.Hom | {P : Sort u} →
{R : Type u_1} →
{A : Type u_2} →
{B : Type u_3} →
{inst : CommSemiring R} →
{inst_1 : AddCommMonoid A} →
{inst_2 : Module R A} →
{inst_3 : AddCommMonoid B} →
{inst_4 : Module R B} →
{inst_5 : CoalgebraStruct R A} →... | null | false |
Subtype.relEmbedding_apply | Mathlib.Order.RelIso.Basic | ∀ {X : Type u_5} (r : X → X → Prop) (p : X → Prop) (self : Subtype p), (Subtype.relEmbedding r p) self = ↑self | null | true |
Lean.Widget.RpcEncodablePacket.mk.injEq._@.Lean.Widget.InteractiveGoal.3114798910._hygCtx._hyg.1 | Lean.Widget.InteractiveGoal | ∀ (hyps type ctx : Lean.Json) (userName? : Option Lean.Json) (goalPrefix mvarId : Lean.Json)
(isInserted? isRemoved? : Option Lean.Json) (hyps_1 type_1 ctx_1 : Lean.Json) (userName?_1 : Option Lean.Json)
(goalPrefix_1 mvarId_1 : Lean.Json) (isInserted?_1 isRemoved?_1 : Option Lean.Json),
({ hyps := hyps, type := ... | null | false |
Tactic.ComputeAsymptotics.MultiseriesExpansion.Approximates.coinduct | Mathlib.Tactic.ComputeAsymptotics.Multiseries.Defs | ∀ (pred : {basis : Tactic.ComputeAsymptotics.Basis} → Tactic.ComputeAsymptotics.MultiseriesExpansion basis → Prop),
(∀ {basis : Tactic.ComputeAsymptotics.Basis} (ms : Tactic.ComputeAsymptotics.MultiseriesExpansion basis),
pred ms →
basis = [] ∨
(∃ basis_hd basis_tl f,
f =ᶠ[Filter... | null | true |
MonoidAlgebra.mul_def | Mathlib.Algebra.MonoidAlgebra.Defs | ∀ {R : Type u_1} {M : Type u_4} [inst : Semiring R] [inst_1 : Mul M] (x y : MonoidAlgebra R M),
x * y = x.coeff.sum fun m₁ r₁ => y.coeff.sum fun m₂ r₂ => MonoidAlgebra.single (m₁ * m₂) (r₁ * r₂) | null | true |
FormalMultilinearSeries.ofScalars_apply_zero | Mathlib.Analysis.Analytic.OfScalars | ∀ {𝕜 : Type u_1} (E : Type u_2) [inst : Field 𝕜] [inst_1 : Ring E] [inst_2 : Algebra 𝕜 E] [inst_3 : TopologicalSpace E]
[inst_4 : IsTopologicalRing E] (c : ℕ → 𝕜) (n : ℕ),
((FormalMultilinearSeries.ofScalars E c n) fun x => 0) = Pi.single 0 (c 0 • 1) n | null | true |
CategoryTheory.LocalizerMorphism.LeftResolution.instCategory._proof_2 | Mathlib.CategoryTheory.Localization.Resolution | ∀ {C₁ : Type u_2} {C₂ : Type u_4} [inst : CategoryTheory.Category.{u_1, u_2} C₁]
[inst_1 : CategoryTheory.Category.{u_3, u_4} C₂] {W₁ : CategoryTheory.MorphismProperty C₁}
{W₂ : CategoryTheory.MorphismProperty C₂} {Φ : CategoryTheory.LocalizerMorphism W₁ W₂} {X₂ : C₂}
{X Y : Φ.LeftResolution X₂} (f : X.Hom Y), (C... | null | false |
Lean.Parser.LeadingIdentBehavior.casesOn | Lean.Parser.Basic | {motive : Lean.Parser.LeadingIdentBehavior → Sort u} →
(t : Lean.Parser.LeadingIdentBehavior) →
motive Lean.Parser.LeadingIdentBehavior.default →
motive Lean.Parser.LeadingIdentBehavior.symbol → motive Lean.Parser.LeadingIdentBehavior.both → motive t | null | false |
ValueDistribution.truncatedLogCounting_coe | Mathlib.Analysis.Complex.ValueDistribution.LogCounting.Truncated | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] [inst_1 : ProperSpace 𝕜] {E : Type u_2}
[inst_2 : NormedAddCommGroup E] [inst_3 : NormedSpace 𝕜 E] {f : 𝕜 → E} {a₀ : E},
ValueDistribution.truncatedLogCounting f ↑a₀ =
Function.locallyFinsuppWithin.logCounting (MeromorphicOn.divisor (fun x => f x - a₀) Se... | For finite values `a₀`, the truncated logarithmic counting function `truncatedLogCounting f a₀`
counts the zeros of `f - a₀`, each with multiplicity one.
| true |
Lean.Lsp.FileSystemWatcher.mk | Lean.Data.Lsp.Workspace | String → Option ℕ → Lean.Lsp.FileSystemWatcher | null | true |
Aesop.GoalData.recOn | Aesop.Tree.Data | {Rapp MVarCluster : Type} →
{motive : Aesop.GoalData Rapp MVarCluster → Sort u} →
(t : Aesop.GoalData Rapp MVarCluster) →
((id : Aesop.GoalId) →
(parent : IO.Ref MVarCluster) →
(children : Array (IO.Ref Rapp)) →
(origin : Aesop.GoalOrigin) →
(depth : ℕ) →
... | null | false |
_private.Lean.Compiler.LCNF.InferBorrow.0.Lean.Compiler.LCNF.ParamMap.rec | Lean.Compiler.LCNF.InferBorrow | {motive : Lean.Compiler.LCNF.ParamMap✝ → Sort u} →
((map :
Std.HashMap Lean.Compiler.LCNF.ParamMap.Key✝
(Array (Lean.Compiler.LCNF.Param Lean.Compiler.LCNF.Purity.impure))) →
(annotatedBorrows : Std.HashSet Lean.FVarId) → motive { map := map, annotatedBorrows := annotatedBorrows }) →
(t : ... | null | false |
_private.Lean.Compiler.LCNF.ExplicitBoxing.0.Lean.Compiler.LCNF.State.auxDecls._default | Lean.Compiler.LCNF.ExplicitBoxing | Array (Lean.Compiler.LCNF.Decl Lean.Compiler.LCNF.Purity.impure) | null | false |
AlgebraicGeometry.LocallyRingedSpace.Hom.mk._flat_ctor | Mathlib.Geometry.RingedSpace.LocallyRingedSpace | {X Y : AlgebraicGeometry.LocallyRingedSpace} →
(base : ↑X.toPresheafedSpace ⟶ ↑Y.toPresheafedSpace) →
(c : Y.presheaf ⟶ (TopCat.Presheaf.pushforward CommRingCat base).obj X.presheaf) →
(∀ (x : ↑↑X.toPresheafedSpace), IsLocalHom (CommRingCat.Hom.hom ({ base := base, c := c }.stalkMap x))) → X.Hom Y | null | false |
Set.range_eq_empty_iff | Mathlib.Data.Set.Image | ∀ {α : Type u_1} {ι : Sort u_4} {f : ι → α}, Set.range f = ∅ ↔ IsEmpty ι | null | true |
Affine.Simplex.PointsWithCircumcenterIndex.circumcenterIndex.elim | Mathlib.Geometry.Euclidean.Circumcenter | {n : ℕ} →
{motive : Affine.Simplex.PointsWithCircumcenterIndex n → Sort u} →
(t : Affine.Simplex.PointsWithCircumcenterIndex n) →
t.ctorIdx = 1 → motive Affine.Simplex.PointsWithCircumcenterIndex.circumcenterIndex → motive t | null | false |
CategoryTheory.ShortComplex.abToCycles._proof_2 | Mathlib.Algebra.Homology.ShortComplex.Ab | ∀ (S : CategoryTheory.ShortComplex Ab) (a b : ↑S.X₁),
⟨(CategoryTheory.ConcreteCategory.hom S.f) (a + b), ⋯⟩ =
⟨(CategoryTheory.ConcreteCategory.hom S.f) a, ⋯⟩ + ⟨(CategoryTheory.ConcreteCategory.hom S.f) b, ⋯⟩ | null | false |
_private.Lean.Elab.MutualDef.0.Lean.Elab.Term.elabHeaders.match_5 | Lean.Elab.MutualDef | (motive : Option Lean.Syntax → Sort u_1) →
(x : Option Lean.Syntax) → ((typeStx : Lean.Syntax) → motive (some typeStx)) → (Unit → motive none) → motive x | null | false |
Subgroup.relIndex_bot_right | Mathlib.GroupTheory.Index | ∀ {G : Type u_1} [inst : Group G] (H : Subgroup G), H.relIndex ⊥ = 1 | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.