name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
HahnSeries.toIterate._proof_2 | Mathlib.RingTheory.HahnSeries.Basic | ∀ {Γ : Type u_1} {Γ' : Type u_2} {R : Type u_3} [inst : PartialOrder Γ] [inst_1 : Zero R] [inst_2 : PartialOrder Γ']
(x : HahnSeries (Lex (Γ × Γ')) R),
(Function.support fun g => { coeff := fun g' => x.coeff (g, g'), isPWO_support' := ⋯ }).IsPWO | null | false |
Rep.unitIso._proof_5 | Mathlib.RepresentationTheory.Rep.Iso | ∀ {k : Type u_2} {G : Type u_3} [inst : CommRing k] [inst_1 : Monoid G] (V : Rep.{u_1, u_2, u_3} k G),
Function.LeftInverse Rep.unitIsoAddEquiv.invFun Rep.unitIsoAddEquiv.toFun | null | false |
Matrix.normedAddCommGroup | Mathlib.Analysis.Matrix.Normed | {m : Type u_3} →
{n : Type u_4} →
{α : Type u_5} → [Fintype m] → [Fintype n] → [NormedAddCommGroup α] → NormedAddCommGroup (Matrix m n α) | Normed group instance (using sup norm of sup norm) for matrices over a normed group. Not
declared as an instance because there are several natural choices for defining the norm of a
matrix. | true |
_private.Mathlib.Combinatorics.SimpleGraph.Extremal.ErdosStoneSimonovits.0.SimpleGraph.eventually_completeEquipartiteGraph_isContained_of_minDegree.match_1_8 | Mathlib.Combinatorics.SimpleGraph.Extremal.ErdosStoneSimonovits | ∀ (r t' n : ℕ) {G : SimpleGraph (Fin n)} (K : G.CompleteEquipartiteSubgraph r t')
(y : (a : Finset (Fin n)) → a ∈ K.parts → Finset (Fin n)) {p : Finset (Fin n)}
(motive : (∃ a, ∃ (h : a ∈ K.parts), y a ⋯ = p) → Prop) (hp : ∃ a, ∃ (h : a ∈ K.parts), y a ⋯ = p),
(∀ (p_1 : Finset (Fin n)) (hp : p_1 ∈ K.parts) (hyp :... | null | false |
Finset.Ico_subset_Ici_self | Mathlib.Order.Interval.Finset.Basic | ∀ {α : Type u_2} {a b : α} [inst : Preorder α] [inst_1 : LocallyFiniteOrderTop α] [inst_2 : LocallyFiniteOrder α],
Finset.Ico a b ⊆ Finset.Ici a | null | true |
FiniteMulArchimedeanClass.closedBallSubgroup | Mathlib.Algebra.Order.Archimedean.Class | {M : Type u_1} →
[inst : CommGroup M] →
[inst_1 : LinearOrder M] → [inst_2 : IsOrderedMonoid M] → FiniteMulArchimedeanClass M → Subgroup M | A closed ball defined by `FiniteMulArchimedeanClass.subgroup` of `UpperSet.Ici c`. | true |
_private.Mathlib.Tactic.Linter.TextBased.0.Mathlib.Linter.TextBased.ErrorContext.mk.sizeOf_spec | Mathlib.Tactic.Linter.TextBased | ∀ (error : Mathlib.Linter.TextBased.StyleError✝) (lineNumber : ℕ) (path : System.FilePath),
sizeOf { error := error, lineNumber := lineNumber, path := path } = 1 + sizeOf error + sizeOf lineNumber + sizeOf path | null | true |
_private.Mathlib.RingTheory.Flat.FaithfullyFlat.Algebra.0.Module.FaithfullyFlat.faithfulSMul._simp_1 | Mathlib.RingTheory.Flat.FaithfullyFlat.Algebra | ∀ {α : Type u_9} [inst : Mul α] (a b : α), a * b = a • b | null | false |
Std.BundledIterM.casesOn | Std.Data.Iterators.Lemmas.Equivalence.Basic | {m : Type w → Type w'} →
{β : Type w} →
{motive : Std.BundledIterM m β → Sort u} →
(t : Std.BundledIterM m β) →
((α : Type w) →
(inst : Std.Iterator α m β) →
(iterator : Std.IterM m β) → motive { α := α, inst := inst, iterator := iterator }) →
motive t | null | false |
CategoryTheory.EnrichedOrdinaryCategory.casesOn | Mathlib.CategoryTheory.Enriched.Ordinary.Basic | {V : Type u'} →
[inst : CategoryTheory.Category.{v', u'} V] →
[inst_1 : CategoryTheory.MonoidalCategory V] →
{C : Type u} →
[inst_2 : CategoryTheory.Category.{v, u} C] →
{motive : CategoryTheory.EnrichedOrdinaryCategory V C → Sort u_1} →
(t : CategoryTheory.EnrichedOrdinaryCate... | null | false |
TensorProduct.«_aux_Mathlib_LinearAlgebra_PiTensorProduct_Basic___macroRules_TensorProduct_term⨂[_]_,__1» | Mathlib.LinearAlgebra.PiTensorProduct.Basic | Lean.Macro | null | false |
Ideal.ramificationIdx_eq_one_of_isUnramifiedAt | Mathlib.NumberTheory.RamificationInertia.Unramified | ∀ {R : Type u_1} {S : Type u_2} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S] {p : Ideal S}
[inst_3 : p.IsPrime] [Algebra.IsUnramifiedAt R p] [Algebra.EssFiniteType R S], p.ramificationIdx R = 1 | null | true |
IsCompactOperator.restrict | Mathlib.Analysis.Normed.Operator.Compact.Basic | ∀ {R₁ : Type u_1} [inst : Semiring R₁] {M₁ : Type u_3} [inst_1 : TopologicalSpace M₁] [inst_2 : AddCommMonoid M₁]
[inst_3 : Module R₁ M₁] {f : M₁ →ₗ[R₁] M₁},
IsCompactOperator ⇑f →
∀ {V : Submodule R₁ M₁} (hV : ∀ v ∈ V, f v ∈ V), IsClosed ↑V → IsCompactOperator ⇑(f.restrict hV) | If a compact operator preserves a closed submodule, its restriction to that submodule is
compact.
Note that, following mathlib's convention in linear algebra, `restrict` designates the restriction
of an endomorphism `f : E →ₗ E` to an endomorphism `f' : ↥V →ₗ ↥V`. To prove that the restriction
`f' : ↥U →ₛₗ ↥V` of a co... | true |
_private.Mathlib.NumberTheory.SiegelsLemma.0.Int.Matrix._aux_Mathlib_NumberTheory_SiegelsLemma___macroRules__private_Mathlib_NumberTheory_SiegelsLemma_0_Int_Matrix_termB_1 | Mathlib.NumberTheory.SiegelsLemma | Lean.Macro | null | false |
Rat.num_divInt_den | Init.Data.Rat.Lemmas | ∀ (a : ℚ), Rat.divInt a.num ↑a.den = a | null | true |
PosNum.cast_one | Mathlib.Data.Num.Lemmas | ∀ {α : Type u_1} [inst : One α] [inst_1 : Add α], ↑1 = 1 | null | true |
hnot_top | Mathlib.Order.Heyting.Basic | ∀ {α : Type u_2} [inst : CoheytingAlgebra α], ￢⊤ = ⊥ | null | true |
CategoryTheory.MorphismProperty.IsMonoidalStable.mk._flat_ctor | Mathlib.CategoryTheory.Monoidal.Widesubcategory | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {P : CategoryTheory.MorphismProperty C}
[inst_1 : CategoryTheory.MonoidalCategory C],
(∀ (X : C), P (CategoryTheory.CategoryStruct.id X)) →
(∀ {X Y Z : C} (f : X ⟶ Y) (g : Y ⟶ Z), P f → P g → P (CategoryTheory.CategoryStruct.comp f g)) →
(∀ (X... | null | false |
CommSemiRingCat.forget_preservesLimits | Mathlib.Algebra.Category.Ring.Limits | CategoryTheory.Limits.PreservesLimits (CategoryTheory.forget CommSemiRingCat) | null | true |
finprod_mem_eq_prod | Mathlib.Algebra.BigOperators.Finprod | ∀ {α : Type u_1} {M : Type u_5} [inst : CommMonoid M] (f : α → M) {s : Set α} (hf : (s ∩ Function.mulSupport f).Finite),
∏ᶠ (i : α) (_ : i ∈ s), f i = ∏ i ∈ hf.toFinset, f i | null | true |
Nat.eq_zero_of_lcm_eq_zero | Init.Data.Nat.Lcm | ∀ {m n : ℕ}, m.lcm n = 0 → m = 0 ∨ n = 0 | null | true |
Module.Basis.coe_toOrthonormalBasis | 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 ι] (v : Module.Basis ι 𝕜 E) (hv : Orthonormal 𝕜 ⇑v),
⇑(v.toOrthonormalBasis hv) = ⇑v | null | true |
CategoryTheory.Functor.leftExtensionEquivalenceOfIso₁_unitIso_hom_app_right_app | Mathlib.CategoryTheory.Functor.KanExtension.Basic | ∀ {C : Type u_1} {H : Type u_3} {D : Type u_5} [inst : CategoryTheory.Category.{v_1, u_1} C]
[inst_1 : CategoryTheory.Category.{v_3, u_3} H] [inst_2 : CategoryTheory.Category.{v_5, u_5} D]
{L L' : CategoryTheory.Functor C D} (iso₁ : L ≅ L') (F : CategoryTheory.Functor C H)
(X : CategoryTheory.Comma (CategoryTheor... | null | true |
Height.fun_logHeight_one | Mathlib.NumberTheory.Height.Basic | ∀ {K : Type u_1} [inst : Field K] [inst_1 : Height.AdmissibleAbsValues K] {ι : Type u_2},
(Height.logHeight fun x => 1) = 0 | Eta-expanded form of `Height.logHeight_one` | true |
_private.Mathlib.Geometry.Manifold.IntegralCurve.UniformTime.0.exists_isMIntegralCurve_of_isMIntegralCurveOn._simp_1_1 | Mathlib.Geometry.Manifold.IntegralCurve.UniformTime | ∀ {α : Type u_1} [inst : Preorder α] {a b x : α}, (x ∈ Set.Ioo a b) = (a < x ∧ x < b) | null | false |
Inclusion.InclusionParamDecl.mk.inj | Mathlib.Tactic.Inclusion.Core.Extensions | ∀ {name : Lean.Name} {type : Lean.Expr} {defaultValue? : Option Lean.Expr} {name_1 : Lean.Name} {type_1 : Lean.Expr}
{defaultValue?_1 : Option Lean.Expr},
{ name := name, type := type, defaultValue? := defaultValue? } =
{ name := name_1, type := type_1, defaultValue? := defaultValue?_1 } →
name = name_1 ∧... | null | true |
HomologicalComplex.restriction.congr_simp | Mathlib.Algebra.Homology.Embedding.TruncLEHomology | ∀ {ι : Type u_1} {ι' : Type u_2} {c : ComplexShape ι} {c' : ComplexShape ι'} {C : Type u_3}
[inst : CategoryTheory.Category.{v_1, u_3} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
(K K_1 : HomologicalComplex C c'),
K = K_1 → ∀ (e e_1 : c.Embedding c') (e_e : e = e_1) [inst_2 : e.IsRelIff], K.restriction... | null | true |
Aesop.CasesTarget.ctorElimType | Aesop.RuleTac.Basic | {motive : Aesop.CasesTarget → Sort u} → ℕ → Sort (max 1 u) | null | false |
IsSMulRegular.mul | Mathlib.Algebra.Regular.SMul | ∀ {R : Type u_1} {M : Type u_3} {a b : R} [inst : SMul R M] [inst_1 : Mul R] [IsScalarTower R R M],
IsSMulRegular M a → IsSMulRegular M b → IsSMulRegular M (a * b) | null | true |
IsIsometricSMul.mk._flat_ctor | Mathlib.Topology.MetricSpace.IsometricSMul | ∀ {M : Type u} {X : Type w} [inst : PseudoEMetricSpace X] [inst_1 : SMul M X],
(∀ (c : M), Isometry fun x => c • x) → IsIsometricSMul M X | null | false |
ProbabilityTheory.HasGaussianLaw.charFunDual_map_eq | Mathlib.Probability.Distributions.Gaussian.HasGaussianLaw.Basic | ∀ {Ω : Type u_1} {E : Type u_2} {mΩ : MeasurableSpace Ω} {P : MeasureTheory.Measure Ω} [inst : NormedAddCommGroup E]
[inst_1 : MeasurableSpace E] [BorelSpace E] {X : Ω → E} [inst_3 : NormedSpace ℝ E] (L : StrongDual ℝ E),
ProbabilityTheory.HasGaussianLaw X P →
MeasureTheory.charFunDual (MeasureTheory.Measure.ma... | null | true |
_private.Init.Data.String.Lemmas.Pattern.String.Basic.0.String.Slice.Pattern.Model.ForwardSliceSearcher.isLongestMatchAt_iff_splits._simp_1_1 | Init.Data.String.Lemmas.Pattern.String.Basic | ∀ {pat s : String.Slice} {pos₁ pos₂ : s.Pos},
String.Slice.Pattern.Model.IsLongestMatchAt pat pos₁ pos₂ = ∃ (h : pos₁ ≤ pos₂), (s.slice pos₁ pos₂ h).copy = pat.copy | null | false |
MultilinearMap.mkContinuous_norm_le | Mathlib.Analysis.Normed.Module.Multilinear.Basic | ∀ {𝕜 : Type u} {ι : Type v} {E : ι → Type wE} {G : Type wG} [inst : NontriviallyNormedField 𝕜]
[inst_1 : (i : ι) → SeminormedAddCommGroup (E i)] [inst_2 : (i : ι) → NormedSpace 𝕜 (E i)]
[inst_3 : SeminormedAddCommGroup G] [inst_4 : NormedSpace 𝕜 G] [inst_5 : Fintype ι] (f : MultilinearMap 𝕜 E G)
{C : ℝ}, 0 ≤... | If a continuous multilinear map is constructed from a multilinear map via the constructor
`mkContinuous`, then its norm is bounded by the bound given to the constructor if it is
nonnegative. | true |
_private.Lean.Elab.Tactic.BuiltinTactic.0.Lean.Elab.Tactic.evalReplace.match_1 | Lean.Elab.Tactic.BuiltinTactic | (motive : Option Lean.LocalDecl → Sort u_1) →
(x : Option Lean.LocalDecl) →
((ldecl : Lean.LocalDecl) → motive (some ldecl)) → ((x : Option Lean.LocalDecl) → motive x) → motive x | null | false |
CategoryTheory.ComposableArrows.sc'._auto_1 | Mathlib.Algebra.Homology.ExactSequence | Lean.Syntax | null | false |
QuadraticModuleCat.instMonoidalCategory | Mathlib.LinearAlgebra.QuadraticForm.QuadraticModuleCat.Monoidal | {R : Type u} → [inst : CommRing R] → [Invertible 2] → CategoryTheory.MonoidalCategory (QuadraticModuleCat R) | null | true |
Subgroup.mem_goursatSnd | Mathlib.GroupTheory.Goursat | ∀ {G : Type u_1} {H : Type u_2} [inst : Group G] [inst_1 : Group H] {I : Subgroup (G × H)} {h : H},
h ∈ I.goursatSnd ↔ (1, h) ∈ I | null | true |
groupCohomology.H1IsoOfIsTrivial.congr_simp | Mathlib.RepresentationTheory.Homological.GroupCohomology.LowDegree | ∀ {k G : Type u} [inst : CommRing k] [inst_1 : Group G] (A : Rep.{u, u, u} k G) [inst_2 : A.IsTrivial],
groupCohomology.H1IsoOfIsTrivial A = groupCohomology.H1IsoOfIsTrivial A | null | true |
Std.DHashMap.Raw.getKeyD_insertIfNew | Std.Data.DHashMap.RawLemmas | ∀ {α : Type u} {β : α → Type v} {m : Std.DHashMap.Raw α β} [inst : BEq α] [inst_1 : Hashable α] [EquivBEq α]
[LawfulHashable α],
m.WF →
∀ {k a fallback : α} {v : β k},
(m.insertIfNew k v).getKeyD a fallback = if (k == a) = true ∧ k ∉ m then k else m.getKeyD a fallback | null | true |
AddMonoidAlgebra.singleZeroAlgHom.eq_1 | Mathlib.Algebra.MonoidAlgebra.Basic | ∀ {R : Type u_1} {A : Type u_4} {M : Type u_7} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A]
[inst_3 : AddMonoid M],
AddMonoidAlgebra.singleZeroAlgHom = { toRingHom := AddMonoidAlgebra.singleZeroRingHom, commutes' := ⋯ } | null | true |
CategoryTheory.HasDetector.recOn | Mathlib.CategoryTheory.Generator.Basic | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{motive : CategoryTheory.HasDetector C → Sort u} →
(t : CategoryTheory.HasDetector C) → ((hasDetector : ∃ G, CategoryTheory.IsDetector G) → motive ⋯) → motive t | null | false |
Ideal.hasBasis_nhds_zero_adic | Mathlib.Topology.Algebra.Nonarchimedean.AdicTopology | ∀ {R : Type u_1} [inst : CommRing R] (I : Ideal R), (nhds 0).HasBasis (fun _n => True) fun n => ↑(I ^ n) | For the `I`-adic topology, the neighborhoods of zero has basis given by the powers of `I`. | true |
Std.DTreeMap.Raw.Const.unitOfList_equiv_foldl | Std.Data.DTreeMap.Raw.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {l : List α},
(Std.DTreeMap.Raw.Const.unitOfList l cmp).Equiv (List.foldl (fun acc a => acc.insertIfNew a ()) ∅ l) | null | true |
AddCommGroup.primaryComponent._proof_3 | Mathlib.GroupTheory.Torsion | ∀ (G : Type u_1) [inst : AddCommGroup G] (p : ℕ) {g : G} (k : ℕ), p ^ k • g = 0 → p ^ k • -g = 0 | null | false |
Unitization.inrNonUnitalAlgHom_toFun | Mathlib.Algebra.Algebra.Unitization | ∀ (R : Type u_1) (A : Type u_2) [inst : CommSemiring R] [inst_1 : NonUnitalSemiring A] [inst_2 : Module R A] (a : A),
(Unitization.inrNonUnitalAlgHom R A) a = ↑a | null | true |
AbsoluteValue.map_units_intCast | Mathlib.Algebra.Order.AbsoluteValue.Int | ∀ {R : Type u_1} {S : Type u_2} [inst : Ring R] [inst_1 : CommRing S] [inst_2 : LinearOrder S] [IsStrictOrderedRing S]
[Nontrivial R] (abv : AbsoluteValue R S) (x : ℤˣ), abv ↑↑x = 1 | null | true |
CategoryTheory.CommGrp.forget₂Grp_obj_X | Mathlib.CategoryTheory.Monoidal.CommGrp_ | ∀ (C : Type u₁) [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.CartesianMonoidalCategory C]
[inst_2 : CategoryTheory.BraidedCategory C] (A : CategoryTheory.CommGrp C),
((CategoryTheory.CommGrp.forget₂Grp C).obj A).X = A.X | null | true |
ContDiffBump.noConfusionType | Mathlib.Analysis.Calculus.BumpFunction.Basic | Sort u → {E : Type u_1} → {c : E} → ContDiffBump c → {E' : Type u_1} → {c' : E'} → ContDiffBump c' → Sort u | null | false |
List.foldrM_map | Init.Data.List.Monadic | ∀ {m : Type u_1 → Type u_2} {β₁ : Type u_3} {β₂ : Type u_4} {α : Type u_1} [inst : Monad m] [LawfulMonad m]
{f : β₁ → β₂} {g : β₂ → α → m α} {l : List β₁} {init : α},
List.foldrM g init (List.map f l) = List.foldrM (fun x y => g (f x) y) init l | null | true |
CategoryTheory.Limits.CategoricalPullback.CatCommSqOver.precompose_map_app_fst_app | Mathlib.CategoryTheory.Limits.Shapes.Pullback.Categorical.Basic | ∀ {A : Type u₁} {B : Type u₂} {C : Type u₃} [inst : CategoryTheory.Category.{v₁, u₁} A]
[inst_1 : CategoryTheory.Category.{v₂, u₂} B] [inst_2 : CategoryTheory.Category.{v₃, u₃} C]
(F : CategoryTheory.Functor A B) (G : CategoryTheory.Functor C B) {X : Type u₄} {Y : Type u₅}
[inst_3 : CategoryTheory.Category.{v₄, u... | null | true |
AddConstMap.«term_→+c[_,_]_» | Mathlib.Algebra.AddConstMap.Basic | Lean.TrailingParserDescr | A bundled map `f : G → H` such that `f (x + a) = f x + b` for all `x`,
denoted as `f : G →+c[a, b] H`.
One can think about `f` as a lift to `G` of a map between two `AddCircle`s. | true |
_private.Mathlib.Computability.TuringMachine.Config.0.Turing.ToPartrec.Code.exists_code._simp_1_17 | Mathlib.Computability.TuringMachine.Config | ∀ {α : Sort u_1}, (∃ _a, False) = False | null | false |
_private.Init.Data.List.Nat.Modify.0.List.eraseIdx_modify_of_lt._proof_1_1 | Init.Data.List.Nat.Modify | ∀ {α : Type u_1} (f : α → α) (i j : ℕ) (l : List α), j < i → ∀ (k : ℕ), i - 1 = k → k < j → ¬i = k → False | null | false |
MeasureTheory.IsSigmaSubadditiveSetFun | Mathlib.MeasureTheory.Measure.PreVariation | {X : Type u_1} → [MeasurableSpace X] → (Set X → ENNReal) → Prop | A set function is σ-subadditive on measurable sets if the value assigned to the union of a
countable disjoint family of measurable sets is bounded above by the sum of values on the family. | true |
_private.Init.Data.String.Lemmas.Iterate.0.String.Slice.mem_toList_copy_iff_exists_get._simp_1_1 | Init.Data.String.Lemmas.Iterate | ∀ {s : String.Slice}, s.copy.toList = List.map (fun p => (↑p).get ⋯) (String.Slice.Model.positionsFrom s.startPos) | null | false |
List.foldr_flip_eq_foldl | Mathlib.Data.List.Fold | ∀ {α : Type u_1} {β : Type u_2} {l : List α} {v : β → α → β} {b : β} [RightCommutative v],
List.foldr (flip v) b l = List.foldl v b l | **Second Bird–Wadler duality theorem**. | true |
PowerSeries.WithPiTopology.multipliable_one_add_of_tendsto_order_atTop_nhds_top | Mathlib.RingTheory.PowerSeries.PiTopology | ∀ (R : Type u_1) [inst : TopologicalSpace R] [inst_1 : CommSemiring R] {ι : Type u_2} [inst_2 : LinearOrder ι]
[LocallyFiniteOrderBot ι] {f : ι → PowerSeries R},
Filter.Tendsto (fun i => (f i).order) Filter.atTop (nhds ⊤) → Multipliable fun x => 1 + f x | A family of `PowerSeries` in the form `1 + f i` is multipliable if the order of `f i` tends to
infinity. | true |
Valuation.Integers.not_denselyOrdered_of_isPrincipalIdealRing | Mathlib.RingTheory.Valuation.Integers | ∀ {F : Type u} {Γ₀ : Type v} [inst : Field F] [inst_1 : LinearOrderedCommGroupWithZero Γ₀] {v : Valuation F Γ₀}
{O : Type w} [inst_2 : CommRing O] [inst_3 : Algebra O F] [IsPrincipalIdealRing O],
v.Integers O → ¬DenselyOrdered ↑(Set.range ⇑v) | null | true |
_private.Batteries.Recycling.RBTree.Alter.0.RBTree.RBMap.alter.adapt.match_3.eq_2 | Batteries.Recycling.RBTree.Alter | ∀ {α : Type u_2} {β : Type u_1} (motive : Option (α × β) → Sort u_3) (k' : α) (v' : β) (h_1 : Unit → motive none)
(h_2 : (k' : α) → (v' : β) → motive (some (k', v'))),
(match some (k', v') with
| none => h_1 ()
| some (k', v') => h_2 k' v') =
h_2 k' v' | null | true |
LinearMap.extendScalarsOfIsLocalizationEquiv_apply | Mathlib.RingTheory.Localization.Module | ∀ {R : Type u_3} [inst : CommSemiring R] (S : Submonoid R) (A : Type u_4) [inst_1 : CommSemiring A]
[inst_2 : Algebra R A] [inst_3 : IsLocalization S A] {M : Type u_5} {N : Type u_6} [inst_4 : AddCommMonoid M]
[inst_5 : Module R M] [inst_6 : Module A M] [inst_7 : IsScalarTower R A M] [inst_8 : AddCommMonoid N]
[i... | null | true |
TopCat.GlueData.MkCore.t'._proof_7 | Mathlib.Topology.Gluing | ∀ (h : TopCat.GlueData.MkCore) (i j k : h.J),
Continuous fun x =>
⟨(⟨↑((CategoryTheory.ConcreteCategory.hom (h.t i j)) (↑x).1), ⋯⟩,
(CategoryTheory.ConcreteCategory.hom (h.t i j)) (↑x).1),
⋯⟩ | null | false |
IsQuotientCoveringMap.fundamentalGroupToMulOpposite_surjective | Mathlib.Topology.Homotopy.Lifting | ∀ {E : Type u_1} {X : Type u_2} [inst : TopologicalSpace E] [inst_1 : TopologicalSpace X] {p : E → X} {G : Type u_4}
[inst_2 : Group G] [inst_3 : MulAction G E] (hp : IsQuotientCoveringMap p G) {x : X} (e : ↑(p ⁻¹' {x}))
[PathConnectedSpace E], Function.Surjective ⇑(hp.fundamentalGroupToMulOpposite e) | null | true |
Subalgebra.unop_iSup | Mathlib.Algebra.Algebra.Subalgebra.MulOpposite | ∀ {ι : Sort u_1} {R : Type u_2} {A : Type u_3} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A]
(S : ι → Subalgebra R Aᵐᵒᵖ), (iSup S).unop = ⨆ i, (S i).unop | null | true |
List.max_le_of_forall_le | Mathlib.Data.List.MinMax | ∀ {α : Type u_1} [inst : LinearOrder α] [inst_1 : OrderBot α] (l : List α) (a : α),
(∀ x ∈ l, x ≤ a) → List.foldr max ⊥ l ≤ a | null | true |
sSupHom.mk.noConfusion | Mathlib.Order.Hom.CompleteLattice | {α : Type u_8} →
{β : Type u_9} →
{inst : SupSet α} →
{inst_1 : SupSet β} →
{P : Sort u} →
{toFun : α → β} →
{map_sSup' : ∀ (s : Set α), toFun (sSup s) = sSup (toFun '' s)} →
{toFun' : α → β} →
{map_sSup'' : ∀ (s : Set α), toFun' (sSup s) = sSup (t... | null | false |
Prod.snd_bot | Mathlib.Order.BoundedOrder.Basic | ∀ (α : Type u) (β : Type v) [inst : Bot α] [inst_1 : Bot β], ⊥.2 = ⊥ | null | true |
_private.Mathlib.Data.Ordmap.Invariants.0.Ordnode.Bounded.weak_right.match_1_1 | Mathlib.Data.Ordmap.Invariants | ∀ {α : Type u_1} [inst : Preorder α]
(motive : (x : Ordnode α) → (x_1 : WithBot α) → (x_2 : WithTop α) → x.Bounded x_1 x_2 → Prop) (x : Ordnode α)
(x_1 : WithBot α) (x_2 : WithTop α) (x_3 : x.Bounded x_1 x_2),
(∀ (o₁ : WithBot α) (o₂ : WithTop α) (h : Ordnode.nil.Bounded o₁ o₂), motive Ordnode.nil o₁ o₂ h) →
... | null | false |
AList.erase.eq_1 | Mathlib.Data.Finmap | ∀ {α : Type u} {β : α → Type v} [inst : DecidableEq α] (a : α) (s : AList β),
AList.erase a s = { entries := List.kerase a s.entries, nodupKeys := ⋯ } | null | true |
RingEquiv.map_neg_one | Mathlib.Algebra.Ring.Equiv | ∀ {R : Type u_4} {S : Type u_5} [inst : NonAssocRing R] [inst_1 : NonAssocRing S] (f : R ≃+* S), f (-1) = -1 | null | true |
CategoryTheory.LaxMonoidalFunctor.hom_ext | Mathlib.CategoryTheory.Monoidal.NaturalTransformation | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.MonoidalCategory C] {D : Type u₂}
[inst_2 : CategoryTheory.Category.{v₂, u₂} D] [inst_3 : CategoryTheory.MonoidalCategory D]
{F G : CategoryTheory.LaxMonoidalFunctor C D} {α β : F ⟶ G}, α.hom = β.hom → α = β | null | true |
Multiset.sum_map_sub | Mathlib.Algebra.BigOperators.Group.Multiset.Basic | ∀ {ι : Type u_2} {G : Type u_4} [inst : SubtractionCommMonoid G] {m : Multiset ι} {f g : ι → G},
(Multiset.map (fun i => f i - g i) m).sum = (Multiset.map f m).sum - (Multiset.map g m).sum | null | true |
Std.DTreeMap.Internal.RxcIterator.mk.noConfusion | Std.Data.DTreeMap.Internal.Zipper | {α : Type u} →
{β : α → Type v} →
{inst : Ord α} →
{P : Sort u_1} →
{iter : Std.DTreeMap.Internal.Zipper α β} →
{upper : α} →
{iter' : Std.DTreeMap.Internal.Zipper α β} →
{upper' : α} →
{ iter := iter, upper := upper } = { iter := iter', upper := u... | null | false |
_private.Mathlib.RingTheory.Valuation.Discrete.Basic.0.Valuation.Uniformizer.is_generator._simp_1_2 | Mathlib.RingTheory.Valuation.Discrete.Basic | (¬True) = False | null | false |
_private.ImportGraph.WorkspaceModel.Build.0.ImportGraph.getWorkspaceModel.match_1 | ImportGraph.WorkspaceModel.Build | (motive : Option ImportGraph.WorkspaceModel → Sort u_1) →
(__do_lift : Option ImportGraph.WorkspaceModel) →
((wm : ImportGraph.WorkspaceModel) → motive (some wm)) →
((x : Option ImportGraph.WorkspaceModel) → motive x) → motive __do_lift | null | false |
Order.pred_le_iff_eq_or_le | Mathlib.Order.SuccPred.Basic | ∀ {α : Type u_1} [inst : LinearOrder α] [inst_1 : PredOrder α] {a b : α}, Order.pred b ≤ a ↔ a = Order.pred b ∨ b ≤ a | null | true |
Rat.instEncodable._proof_1 | Mathlib.Data.Rat.Encodable | ∀ (a : ℤ) (b : ℕ), b ≠ 0 → a.natAbs.Coprime b → 0 < b ∧ a.natAbs.Coprime b | null | false |
HomologicalComplex.mapBifunctor₂₃.d₁_eq | Mathlib.Algebra.Homology.BifunctorAssociator | ∀ {C₁ : Type u_1} {C₂ : Type u_2} {C₂₃ : Type u_4} {C₃ : Type u_5} {C₄ : Type u_6}
[inst : CategoryTheory.Category.{v_1, u_1} C₁] [inst_1 : CategoryTheory.Category.{v_2, u_2} C₂]
[inst_2 : CategoryTheory.Category.{v_3, u_5} C₃] [inst_3 : CategoryTheory.Category.{v_4, u_6} C₄]
[inst_4 : CategoryTheory.Category.{v_... | null | true |
USize.pow._f | Init.Data.UInt.Basic | USize → (n : ℕ) → Nat.below n → USize | null | false |
_private.Mathlib.Analysis.Meromorphic.Divisor.0.MeromorphicOn.divisor._simp_12 | Mathlib.Analysis.Meromorphic.Divisor | ∀ {b a : Prop}, (∃ (_ : a), b) = (a ∧ b) | null | false |
ProofWidgets.RpcEncodablePacket._@.ProofWidgets.Presentation.Expr.4196812879._hygCtx._hyg.1 | ProofWidgets.Presentation.Expr | Type | null | false |
_private.Mathlib.Geometry.Euclidean.Sphere.SecondInter.0.EuclideanGeometry.Sphere.secondInter_map._simp_1_2 | Mathlib.Geometry.Euclidean.Sphere.SecondInter | ∀ {𝕜 : Type u_1} {V : Type u_2} {V₂ : Type u_4} {P : Type u_7} {P₂ : Type u_8} [inst : NormedField 𝕜]
[inst_1 : SeminormedAddCommGroup V] [inst_2 : NormedSpace 𝕜 V] [inst_3 : PseudoMetricSpace P]
[inst_4 : NormedAddTorsor V P] [inst_5 : SeminormedAddCommGroup V₂] [inst_6 : NormedSpace 𝕜 V₂]
[inst_7 : PseudoMe... | null | false |
Lean.PrettyPrinter.Parenthesizer.State.rec | Lean.PrettyPrinter.Parenthesizer | {motive : Lean.PrettyPrinter.Parenthesizer.State → Sort u} →
((stxTrav : Lean.Syntax.Traverser) →
(contPrec : Option ℕ) →
(contCat : Lean.Name) →
(minPrec trailPrec : Option ℕ) →
(trailCat : Lean.Name) →
(visitedToken : Bool) →
motive
... | null | false |
instSigmaCompactSpaceForallOfFinite | Mathlib.Topology.Compactness.SigmaCompact | ∀ {ι : Type u_3} [Finite ι] {X : ι → Type u_4} [inst : (i : ι) → TopologicalSpace (X i)]
[∀ (i : ι), SigmaCompactSpace (X i)], SigmaCompactSpace ((i : ι) → X i) | null | true |
AlgebraicGeometry.Scheme.Hom.image_le_image_iff | Mathlib.AlgebraicGeometry.OpenImmersion | ∀ {X Y : AlgebraicGeometry.Scheme} (f : X ⟶ Y) [inst : AlgebraicGeometry.IsOpenImmersion f] (U U' : X.Opens),
(AlgebraicGeometry.Scheme.Hom.opensFunctor f).obj U ≤ (AlgebraicGeometry.Scheme.Hom.opensFunctor f).obj U' ↔ U ≤ U' | null | true |
SignType | Mathlib.Basic.Sign.Defs | Type | The type of signs. | true |
normedAddCommGroupTangentSpaceVectorSpace._aux_8 | Mathlib.Geometry.Manifold.Riemannian.Basic | {E : Type u_1} →
[inst : NormedAddCommGroup E] →
[inst_1 : NormedSpace ℝ E] → (x : E) → Dist (TangentSpace (modelWithCornersSelf ℝ E) x) | null | false |
Int8.toISize_lt._simp_1 | Init.Data.SInt.Lemmas | ∀ {a b : Int8}, (a.toISize < b.toISize) = (a < b) | null | false |
Multiset.fold_cons_left | Mathlib.Data.Multiset.Fold | ∀ {α : Type u_1} (op : α → α → α) [hc : Std.Commutative op] [ha : Std.Associative op] (b a : α) (s : Multiset α),
Multiset.fold op b (a ::ₘ s) = op a (Multiset.fold op b s) | null | true |
UInt64.sub_eq_iff_eq_add | Init.Data.UInt.Lemmas | ∀ {a b c : UInt64}, a - b = c ↔ a = c + b | null | true |
VectorFourier.fderiv_fourierIntegral | Mathlib.Analysis.Fourier.FourierTransformDeriv | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℂ E] {V : Type u_2} {W : Type u_3}
[inst_2 : NormedAddCommGroup V] [inst_3 : NormedSpace ℝ V] [inst_4 : NormedAddCommGroup W] [inst_5 : NormedSpace ℝ W]
(L : V →L[ℝ] W →L[ℝ] ℝ) {f : V → E} [inst_6 : MeasurableSpace V] [BorelSpace V] [SecondCountab... | null | true |
CategoryTheory.Functor.CorepresentableBy.equivOfIsoObj_symm_apply | Mathlib.CategoryTheory.Yoneda | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {F : CategoryTheory.Functor C (Type w)} {X Y : C}
(e : Y ≅ X) (R : F.CorepresentableBy Y),
(CategoryTheory.Functor.CorepresentableBy.equivOfIsoObj e).symm R = R.ofIsoObj e.symm | null | true |
_private.Mathlib.Tactic.Cases.0.Mathlib.Tactic._aux_Mathlib_Tactic_Cases___elabRules_Mathlib_Tactic_induction'_1.match_4 | Mathlib.Tactic.Cases | (motive : Array Lean.Expr × Array (Lean.Ident × Lean.FVarId) → Sort u_1) →
(x : Array Lean.Expr × Array (Lean.Ident × Lean.FVarId)) →
((targets : Array Lean.Expr) → (toTag : Array (Lean.Ident × Lean.FVarId)) → motive (targets, toTag)) → motive x | null | false |
CategoryTheory.SmallObject.SuccStruct.arrowι._proof_1 | Mathlib.CategoryTheory.SmallObject.Iteration.Basic | ∀ {C : Type u_3} [inst : CategoryTheory.Category.{u_2, u_3} C] {J : Type u_1} [inst_1 : LinearOrder J]
[CategoryTheory.Limits.HasIterationOfShape J C] {i : J} (F : CategoryTheory.Functor (↑(Set.Iio i)) C),
Order.IsSuccLimit i → CategoryTheory.Limits.HasColimit F | null | false |
_private.Mathlib.AlgebraicTopology.SimplicialSet.StdSimplex.0.Finset.image_subset_iff._simp_1 | Mathlib.AlgebraicTopology.SimplicialSet.StdSimplex | ∀ {α : Type u_1} {β : Type u_2} [inst : DecidableEq β] {f : α → β} {s : Finset α} {t : Finset β},
(Finset.image f s ⊆ t) = ∀ x ∈ s, f x ∈ t | null | false |
Ultrafilter.pure_surjective | Mathlib.Order.Filter.Ultrafilter.Basic | ∀ {α : Type u} [Finite α], Function.Surjective pure | null | true |
HasFDerivWithinAt.congr' | Mathlib.Analysis.Calculus.FDeriv.Congr | ∀ {𝕜 : 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 f₁ : E → F} {f' : E →L[𝕜] F} {x : E} {s : Set E},
HasFDerivWithinAt ... | null | true |
monovary_id_iff._simp_1 | Mathlib.Order.Monotone.Monovary | ∀ {ι : Type u_1} {α : Type u_3} [inst : Preorder α] {f : ι → α} [inst_1 : PartialOrder ι], Monovary f id = Monotone f | null | false |
gaugeSeminormFamily_ball | Mathlib.Analysis.LocallyConvex.AbsConvexOpen | ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : RCLike 𝕜] [inst_1 : AddCommGroup E] [inst_2 : TopologicalSpace E]
[inst_3 : Module 𝕜 E] [inst_4 : Module ℝ E] [inst_5 : IsScalarTower ℝ 𝕜 E] [inst_6 : ContinuousSMul ℝ E]
(s : AbsConvexOpenSets 𝕜 E), (gaugeSeminormFamily 𝕜 E s).ball 0 1 = ↑s | null | true |
InfHom.coe_mk | Mathlib.Order.Hom.Lattice | ∀ {α : Type u_2} {β : Type u_3} [inst : Min α] [inst_1 : Min β] (f : α → β) (hf : ∀ (a b : α), f (a ⊓ b) = f a ⊓ f b),
⇑{ toFun := f, map_inf' := hf } = f | null | true |
TopPair.Homotopy.trans._proof_2 | Mathlib.Topology.Category.TopPair | ∀ {X Y : TopPair} {f₀ f₁ f₂ : X ⟶ Y} (F : TopPair.Homotopy f₀ f₁) (G : TopPair.Homotopy f₁ f₂),
CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategoryStruct.whiskerRight TopPair.map TopCat.I)
(TopCat.Homotopy.h (F.fst.trans G.fst)) =
CategoryTheory.CategoryStruct.comp (TopCat.Homotopy.h (F.snd.... | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.