name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
AddOreLocalization.AddOreSet.oreSubtra | Mathlib.GroupTheory.OreLocalization.OreSet | {R : Type u_1} → {inst : AddMonoid R} → {S : AddSubmonoid R} → [self : AddOreLocalization.AddOreSet S] → R → ↥S → ↥S | The Ore subtrahend of a difference. | true |
Lean.Elab.Term.Do.ToTerm.mkIte | Lean.Elab.Do.Legacy | Lean.Syntax → Lean.Syntax → Lean.Syntax → Lean.Syntax → Lean.MacroM Lean.Syntax | null | true |
_private.Mathlib.Algebra.Homology.SpectralObject.Homology.0.CategoryTheory.Abelian.SpectralObject.dKernelSequence_exact._proof_1_4 | Mathlib.Algebra.Homology.SpectralObject.Homology | ∀ (n₀ n₁ n₂ n₃ : ℤ), 0 < 3 + 1 | null | false |
Sylow.mulEquivIteratedWreathProduct._proof_4 | Mathlib.GroupTheory.RegularWreathProduct | ∀ (p n : ℕ) (α : Type u_2) [inst : Finite α] (hα : Nat.card α = p ^ n) (G : Type u_1) [inst_1 : Group G]
[inst_2 : Finite G] (hG : Nat.card G = p),
Function.Injective
(⇑((Finite.equivFinOfCardEq hα).trans (Finite.equivFinOfCardEq ⋯).symm).symm.permCongrHom.toEquiv ∘
⇑(iteratedWreathToPermHom G n)) | null | false |
sSup_eq_bot' | Mathlib.Order.CompleteLattice.Basic | ∀ {α : Type u_1} [inst : CompleteLattice α] {s : Set α}, sSup s = ⊥ ↔ s = ∅ ∨ s = {⊥} | null | true |
_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) | null | false |
CategoryTheory.GlueData.types_ι_jointly_surjective | Mathlib.CategoryTheory.GlueData | ∀ (D : CategoryTheory.GlueData (Type v)) (x : D.glued), ∃ i y, (CategoryTheory.ConcreteCategory.hom (D.ι i)) y = x | null | true |
_private.Std.Http.Internal.String.0.Std.Http.Internal.unquoteHttpString?.match_3 | Std.Http.Internal.String | (motive : Std.Http.Internal.UnquoteState✝ → Sort u_1) →
(x : Std.Http.Internal.UnquoteState✝) →
((result : String) → motive (Std.Http.Internal.UnquoteState.done✝ result)) →
((x : Std.Http.Internal.UnquoteState✝) → motive x) → motive x | null | false |
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 | null | 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' | null | false |
BitVec.instDecidableExistsBitVecZero | Init.Data.BitVec.Decidable | (P : BitVec 0 → Prop) → [Decidable (P 0#0)] → Decidable (∃ v, P v) | null | 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 | null | false |
FreeAddGroup.map_neg | Mathlib.GroupTheory.FreeGroup.Basic | ∀ {α β : Type u} (f : α → β) (x : FreeAddGroup α), f <$> (-x) = -f <$> x | null | true |
_private.Batteries.Data.BinaryHeap.Lemmas.0.Batteries.BinaryHeap.heapifyDown_eq_of_maxChild_none._proof_1_3 | Batteries.Data.BinaryHeap.Lemmas | ∀ {sz : ℕ} (i : ℕ), i + 1 ≤ sz → i < sz | null | false |
_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 | null | false |
_private.Mathlib.Combinatorics.Enumerative.Catalan.Basic.0.gosper_catalan_sub_eq_central_binom_div._simp_1_8 | Mathlib.Combinatorics.Enumerative.Catalan.Basic | ∀ {R : Type u_1} [inst : AddMonoidWithOne R] [CharZero R] (n : ℕ), (↑n + 1 = 0) = False | null | 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... | null | true |
Finset.coe_smul_finset._simp_2 | Mathlib.Algebra.Group.Pointwise.Finset.Scalar | ∀ {α : Type u_1} {β : Type u_2} [inst : DecidableEq β] [inst_1 : SMul α β] (a : α) (s : Finset β), a • ↑s = ↑(a • s) | null | false |
GromovHausdorff.AuxGluingStruct.metric | Mathlib.Topology.MetricSpace.GromovHausdorff | {A : Type} → [inst : MetricSpace A] → (self : GromovHausdorff.AuxGluingStruct A) → MetricSpace self.Space | null | 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 α → ... | null | false |
_private.Mathlib.Combinatorics.Graph.Delete.0.Graph.restrict._proof_4 | Mathlib.Combinatorics.Graph.Delete | ∀ {α : Type u_2} {β : Type u_1} (G : Graph α β) (E₀ : Set β) ⦃e_1 : β⦄ ⦃x_1 y_1 : α⦄,
e_1 ∈ E₀ ∧ G.IsLink e_1 x_1 y_1 → x_1 ∈ G.vertexSet | null | false |
_private.Lean.Elab.Util.0.Lean.Elab.evalSyntaxConstantUnsafe | Lean.Elab.Util | Lean.Environment → Lean.Options → Lean.Name → ExceptT String Id Lean.Syntax | null | 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 | null | true |
DomMulAct.coe_mkHomeomorph_symm | Mathlib.Topology.Algebra.Constructions.DomMulAct | ∀ {M : Type u_1} [inst : TopologicalSpace M], ⇑DomMulAct.mkHomeomorph.symm = ⇑DomMulAct.mk.symm | null | true |
MeasureTheory.Measure.pi_nullSingletonClass' | Mathlib.MeasureTheory.Constructions.Pi | ∀ {ι : Type u_1} {α : ι → Type u_3} [inst : Fintype ι] [inst_1 : (i : ι) → MeasurableSpace (α i)]
{μ : (i : ι) → MeasureTheory.Measure (α i)} [∀ (i : ι), MeasureTheory.SigmaFinite (μ i)] [h : Nonempty ι]
[∀ (i : ι), MeasureTheory.NullSingletonClass (μ i)], MeasureTheory.NullSingletonClass (MeasureTheory.Measure.pi ... | null | true |
_private.Lean.PrettyPrinter.Delaborator.Metavariable.0.Lean.PrettyPrinter.Delaborator.getDelayedMVarIdPending.match_4 | Lean.PrettyPrinter.Delaborator.Metavariable | (motive : Option Lean.DelayedMetavarAssignment → Sort u_1) →
(__do_lift : Option Lean.DelayedMetavarAssignment) →
((decl : Lean.DelayedMetavarAssignment) → motive (some decl)) →
((x : Option Lean.DelayedMetavarAssignment) → motive x) → motive __do_lift | null | false |
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) →
... | null | false |
Affine.Simplex.sSameSide_point_incenter | Mathlib.Geometry.Euclidean.Incenter.Basic | ∀ {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 | null | 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... | null | 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 | null | 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... | The **Gagliardo-Nirenberg-Sobolev inequality**. Let `u` be a continuously differentiable
compactly-supported function `u` on a normed space `E` of finite dimension `n ≥ 2`, equipped
with Haar measure. Then the Lebesgue integral of the pointwise expression
`|u x| ^ (n / (n - 1))` is bounded above by a constant times th... | 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... | null | 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 | A type endowed with `-` and `*` has distributive negation, if it admits an injective map that
preserves `-` and `*` to a type which has distributive negation. | true |
CategoryTheory.Limits.limit.inv_pre_π | Mathlib.CategoryTheory.Limits.HasLimits | ∀ {J : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} J] {K : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} K]
{C : Type u} [inst_2 : CategoryTheory.Category.{v, u} C] (F : CategoryTheory.Functor J C)
[inst_3 : CategoryTheory.Limits.HasLimit F] (E : CategoryTheory.Functor K J)
[inst_4 : CategoryTheory.Li... | null | 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} | null | true |
Std.Legacy.Range.noConfusionType | Init.Data.Range.Basic | Sort u → Std.Legacy.Range → Std.Legacy.Range → Sort u | null | false |
String.Pos.lt_ofSlice_iff | Init.Data.String.Lemmas.Order | ∀ {s : String} {p₀ p₁ : s.Pos} {h : p₀ ≤ p₁} {p : (s.slice p₀ p₁ h).Pos} {q : s.Pos},
q < String.Pos.ofSlice p ↔ ∃ (h₁ : q ≤ p₁), ∀ (h₀ : p₀ ≤ q), q.slice p₀ p₁ h₀ h₁ < p | null | true |
Set.center_units_subset | Mathlib.Algebra.GroupWithZero.Center | ∀ {G₀ : Type u_2} [inst : GroupWithZero G₀], Set.center G₀ˣ ⊆ Units.val ⁻¹' Set.center G₀ | null | 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) | null | 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) | null | false |
Lean.Lsp.CodeAction.noConfusionType | Lean.Data.Lsp.CodeActions | Sort u → Lean.Lsp.CodeAction → Lean.Lsp.CodeAction → Sort u | null | false |
Int.Internal.Linear.Poly.divAll._sunfold | Init.Data.Int.Linear | ℤ → Int.Internal.Linear.Poly → Bool | null | 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 | null | 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 | null | 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 | null | 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... | Two equal natural transformations `R₁ ⟶ R₂` yield naturally isomorphic functors
`P.Comma L R₁ Q W ⥤ P.Comma L R₂ Q W`. | true |
Lean.instTypeNameMessageData | Lean.Message | TypeName Lean.MessageData | null | true |
Group.toCancelMonoid | Mathlib.Algebra.Group.Defs | {G : Type u_1} → [Group G] → CancelMonoid G | null | true |
_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 | null | false |
List.nodup_iff_le_length_dedup | Mathlib.Data.List.Dedup | ∀ {α : Type u_1} [inst : DecidableEq α] {l : List α}, l.Nodup ↔ l.length ≤ l.dedup.length | null | true |
_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 | null | false |
ConditionallyCompleteLattice | Mathlib.Order.ConditionallyCompleteLattice.Defs | Type u_2 → Type u_2 | A conditionally complete lattice is a lattice in which
every nonempty subset which is bounded above has a supremum, and
every nonempty subset which is bounded below has an infimum.
Typical examples are real numbers or natural numbers.
To differentiate the statements from the corresponding statements in (unconditional)... | 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 | null | 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 | null | false |
_private.Mathlib.Tactic.Echelon.Reflection.0.Mathlib.Tactic.Echelon.pivotOfList_lt_pivotOfList._proof_1_2 | Mathlib.Tactic.Echelon.Reflection | ∀ {n : ℕ} {cols : List (Fin n)} {j : ℕ}, j + 1 ≤ cols.length → j < cols.length | null | 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 | null | 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) | null | 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 ⋯ ⋯ | null | true |
Lean.PrettyPrinter.Parenthesizer.checkNoImmediateColon.parenthesizer | Lean.PrettyPrinter.Parenthesizer | Lean.PrettyPrinter.Parenthesizer | null | true |
Ideal.fiberIsoOfBijectiveResidueField._proof_13 | Mathlib.RingTheory.Etale.QuasiFinite | ∀ {R' : Type u_1} [inst : CommRing R'] {q : Ideal R'} [inst_1 : q.IsPrime],
IsScalarTower R' q.ResidueField q.ResidueField | null | 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 ℕ∞},
... | null | true |
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) | null | true |
Equiv.emptySum.congr_simp | Mathlib.Order.RelIso.Basic | ∀ (α : Type u_9) (β : Type u_10) [inst : IsEmpty α], Equiv.emptySum α β = Equiv.emptySum α β | null | 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 | Constructor for `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) | null | 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 | null | false |
TopologicalSpace.OpenNhdsOf._sizeOf_1 | Mathlib.Topology.Sets.Opens | {α : Type u_2} → {inst : TopologicalSpace α} → {x : α} → [SizeOf α] → TopologicalSpace.OpenNhdsOf x → ℕ | null | 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 | null | 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) | null | 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) | null | true |
WithBot.conditionallyCompleteLattice.eq_1 | Mathlib.Order.ConditionallyCompleteLattice.Basic | ∀ {α : Type u_5} [inst : ConditionallyCompleteLattice α],
WithBot.conditionallyCompleteLattice =
{ toLattice := WithBot.lattice, toSupSet := WithBot.instSupSet, toInfSet := WithBot.instInfSet, isLUB_csSup := ⋯,
isGLB_csInf := ⋯ } | null | 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 | null | false |
_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 ⋯ | null | 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 | If M is a doubly stochastic matrix, then it is a convex combination of permutation matrices. Note
`doublyStochastic_eq_convexHull_permMatrix` shows `doublyStochastic n` is exactly the convex hull of
the permutation matrices, and this lemma is instead most useful for accessing the coefficients of
each permutation matric... | 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... | null | 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... | null | false |
_private.Mathlib.Analysis.Complex.Hadamard.0.Complex.HadamardThreeLines.F_BddAbove._simp_1_7 | Mathlib.Analysis.Complex.Hadamard | ∀ (r s : ℝ), ↑r + ↑s = ↑(r + s) | null | false |
Lean.Meta.MVarRenaming.mk.sizeOf_spec | Lean.Meta.Match.MVarRenaming | ∀ (map : Lean.MVarIdMap Lean.MVarId), sizeOf { map := map } = 1 + sizeOf map | null | 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) | If `U ∌ 0` is an open set on the real line and `V` is an open set on a sphere of nonzero radius,
then their pointwise scalar product is an open set. | 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.... | null | 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,
... | null | false |
PresentedGroup.lift_toCoprod_inl_eq_inl_mk | Mathlib.GroupTheory.PresentedGroup | ∀ {α : Type u_1} {β : Type u_2} (rels₁ : Set (FreeGroup α)) (rels₂ : Set (FreeGroup β)),
(FreeGroup.lift (PresentedGroup.toCoprod rels₁ rels₂)).comp (FreeGroup.map Sum.inl) =
Monoid.Coprod.inl.comp (PresentedGroup.mk rels₁) | null | true |
CategoryTheory.RingObjCat.Hom.noConfusion | Mathlib.CategoryTheory.Monoidal.Ring | {P : Sort u_1} →
{C : Type u} →
{inst : CategoryTheory.Category.{v, u} C} →
{inst_1 : CategoryTheory.CartesianMonoidalCategory C} →
{inst_2 : CategoryTheory.BraidedCategory C} →
{R₁ R₂ : CategoryTheory.RingObjCat C} →
{t : R₁.Hom R₂} →
{C' : Type u} →
... | null | 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' | null | 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 | null | true |
CategoryTheory.Functor.ShiftSequence.recOn | Mathlib.CategoryTheory.Shift.ShiftSequence | {C : Type u_1} →
{A : Type u_3} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
[inst_1 : CategoryTheory.Category.{v_3, u_3} A] →
{F : CategoryTheory.Functor C A} →
{M : Type u_4} →
[inst_2 : AddMonoid M] →
[inst_3 : CategoryTheory.HasShift C M] →
... | null | 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 | null | 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 | The infinite sum of a `SummableFamily` of Hahn series. | true |
IsDiscrete.image_of_isOpenMap_of_isOpen | Mathlib.Topology.DiscreteSubset | ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] {s : Set X} [inst_1 : TopologicalSpace Y] {f : X → Y},
IsDiscrete s → IsOpenMap f → IsOpen s → IsDiscrete (f '' s) | null | 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 b c : BoundedContinuousFunction α R), (a + b) * c = a * c + b * c | null | 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) | null | 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} →
... | null | false |
GaloisInsertion.isLUB_of_u_image | Mathlib.Order.GaloisConnection.Basic | ∀ {α : Type u_1} {β : Type u_2} {l : α → β} {u : β → α} [inst : Preorder α] [inst_1 : Preorder β]
(gi : GaloisInsertion l u) {s : Set β} {a : α}, IsLUB (u '' s) a → IsLUB s (l a) | null | 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 } | null | 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₀ | null | true |
ValuativeRel.zero_vlt_mul | Mathlib.RingTheory.Valuation.ValuativeRel.Basic | ∀ {R : Type u_1} [inst : Semiring R] [inst_1 : ValuativeRel R] {x y : R}, 0 <ᵥ x → 0 <ᵥ y → 0 <ᵥ x * y | null | 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... | Eta-expanded form of `DifferentiableOn.sub_iff_right` | true |
instUniqueAddUnitsOfSubsingleton._proof_1 | Mathlib.Algebra.Group.Units.Basic | ∀ {M : Type u_1} [inst : AddMonoid M] [Subsingleton M] (x : AddUnits M), ↑x = 0 | null | 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 | null | false |
Function.HasTemperateGrowth.toTemperedDistribution_apply | Mathlib.Analysis.Distribution.TemperedDistribution | ∀ {E : Type u_3} {F : Type u_4} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] [inst_2 : NormedAddCommGroup F]
[inst_3 : NormedSpace ℂ F] [inst_4 : MeasurableSpace E] [inst_5 : BorelSpace E] [inst_6 : SecondCountableTopology E]
(μ : autoParam (MeasureTheory.Measure E) _auto_44✝) [hμ : μ.HasTemperateGrowth... | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.