name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11.5k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
Vector.range'._proof_1 | Init.Data.Vector.Basic | ∀ (start size step : ℕ), (Array.range' start size step).size = size | null | false |
_private.Mathlib.Algebra.Group.Submonoid.Membership.0.Submonoid.forall_mem_sup._simp_1_1 | Mathlib.Algebra.Group.Submonoid.Membership | ∀ {N : Type u_4} [inst : CommMonoid N] {s t : Submonoid N} {x : N}, (x ∈ s ⊔ t) = ∃ y ∈ s, ∃ z ∈ t, y * z = x | null | false |
_private.Mathlib.NumberTheory.LSeries.SumCoeff.0.LSeries_tendsto_sub_mul_nhds_one_of_tendsto_sum_div_aux₂ | Mathlib.NumberTheory.LSeries.SumCoeff | ∀ {l : ℂ} {s T ε : ℝ} {S : ℝ → ℂ},
MeasureTheory.LocallyIntegrableOn (fun t => S t - l * ↑t) (Set.Ici 1) MeasureTheory.volume →
0 < ε →
1 < s →
1 ≤ T → (∀ t ≥ T, ‖S t - l * ↑t‖ ≤ ε * t) → (s - 1) * ∫ (t : ℝ) in Set.Ioi T, ‖S t - l * ↑t‖ * t ^ (-s - 1) ≤ ε | null | true |
AlgebraicTopology.isZero_singularHomologyFunctor_of_totallyDisconnectedSpace | Mathlib.AlgebraicTopology.SingularHomology.Basic | ∀ (C : Type u) [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasCoproducts C]
[inst_2 : CategoryTheory.Preadditive C] (n : ℕ) (R : C) (X : TopCat) [TotallyDisconnectedSpace ↑X]
[inst_4 : CategoryTheory.CategoryWithHomology C],
n ≠ 0 → CategoryTheory.Limits.IsZero (((AlgebraicTopology.s... | null | true |
CategoryTheory.Limits.colimitYonedaHomIsoLimit'.eq_1 | Mathlib.CategoryTheory.Limits.IndYoneda | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{u₂, u₁} C] {I : Type v₁} [inst_1 : CategoryTheory.Category.{v₂, v₁} I]
(D : CategoryTheory.Functor I Cᵒᵖ) (F : CategoryTheory.Functor Cᵒᵖ (Type u₂))
[inst_2 : CategoryTheory.Limits.HasColimit (D.leftOp.comp CategoryTheory.yoneda)]
[inst_3 : CategoryTheory.Limits.Ha... | null | true |
Ideal.fiberIsoOfBijectiveResidueField._proof_6 | 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],
SMulCommClass R p.ResidueField q.ResidueField | null | false |
CategoryTheory.yonedaMonObjIsoOfRepresentableBy.eq_1 | Mathlib.CategoryTheory.Monoidal.Cartesian.Mon | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v, u_1} C] [inst_1 : CategoryTheory.CartesianMonoidalCategory C]
(X : C) (F : CategoryTheory.Functor Cᵒᵖ MonCat) (α : (F.comp (CategoryTheory.forget MonCat)).RepresentableBy X),
CategoryTheory.yonedaMonObjIsoOfRepresentableBy X F α =
CategoryTheory.NatIso.ofComp... | null | true |
_private.Lean.PrettyPrinter.Delaborator.Options.0.Lean.initFn._@.Lean.PrettyPrinter.Delaborator.Options.750911636._hygCtx._hyg.4 | Lean.PrettyPrinter.Delaborator.Options | IO (Lean.Option Bool) | null | false |
EuclideanGeometry.Sphere.instNonemptySubtypeMemAffineSubspaceRealOrthRadius | Mathlib.Geometry.Euclidean.Sphere.OrthRadius | ∀ {V : Type u_1} {P : Type u_2} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V] [inst_2 : MetricSpace P]
[inst_3 : NormedAddTorsor V P] (s : EuclideanGeometry.Sphere P) (p : P), Nonempty ↥(s.orthRadius p) | null | true |
Lean.LocalContext.auxDeclToFullName | Lean.LocalContext | Lean.LocalContext → Lean.FVarIdMap Lean.Name | null | true |
Lean.Omega.LinearCombo.coordinate_eval | Init.Omega.LinearCombo | ∀ (i : ℕ) (v : Lean.Omega.Coeffs), (Lean.Omega.LinearCombo.coordinate i).eval v = v.get i | null | true |
AddSubgroup.normalClosure_closure_eq_normalClosure | Mathlib.Algebra.Group.Subgroup.Basic | ∀ {G : Type u_1} [inst : AddGroup G] {s : Set G},
AddSubgroup.normalClosure ↑(AddSubgroup.closure s) = AddSubgroup.normalClosure s | null | true |
_private.Mathlib.Algebra.Lie.Weights.Killing.0.LieAlgebra.IsKilling.span_weight_isNonZero_eq_top._simp_1_1 | Mathlib.Algebra.Lie.Weights.Killing | ∀ {α : Type u_1} {x a : α} {s : Set α}, (x ∈ insert a s) = (x = a ∨ x ∈ s) | null | false |
Group.fg_of_mul_group_fg | Mathlib.GroupTheory.Finiteness | ∀ {H : Type u_4} [inst : AddGroup H] [AddGroup.FG H], Group.FG (Multiplicative H) | null | true |
CategoryTheory.EnrichedFunctor.forgetComp_hom_app | Mathlib.CategoryTheory.Enriched.Basic | ∀ {W : Type v'} [inst : CategoryTheory.Category.{w', v'} W] [inst_1 : CategoryTheory.MonoidalCategory W] {C : Type u₁}
[inst_2 : CategoryTheory.EnrichedCategory W C] {D : Type u₂} [inst_3 : CategoryTheory.EnrichedCategory W D]
{E : Type u₃} [inst_4 : CategoryTheory.EnrichedCategory W E] (F : CategoryTheory.Enriched... | null | true |
NonUnitalSubalgebra.nonUnitalNormedRing._proof_2 | Mathlib.Analysis.Normed.Ring.Basic | ∀ {𝕜 : Type u_2} [inst : CommRing 𝕜] {E : Type u_1} [inst_1 : NonUnitalNormedRing E] [inst_2 : Module 𝕜 E]
(s : NonUnitalSubalgebra 𝕜 E) (x y : ↥s), dist x y = ‖-x + y‖ | null | false |
Lean.Elab.Modifiers.addFirstAttr | Lean.Elab.DeclModifiers | Lean.Elab.Modifiers → Lean.Elab.Attribute → Lean.Elab.Modifiers | Adds attribute `attr` in `modifiers`, at the beginning | true |
ContDiff.comp₂_contDiffOn | Mathlib.Analysis.Calculus.ContDiff.Comp | ∀ {𝕜 : Type u_1} {F : Type u_3} {G : Type u_4} [inst : NontriviallyNormedField 𝕜] [inst_1 : NormedAddCommGroup F]
[inst_2 : NormedSpace 𝕜 F] [inst_3 : NormedAddCommGroup G] [inst_4 : NormedSpace 𝕜 G] {n : WithTop ℕ∞} {E₁ : Type u_6}
{E₂ : Type u_7} [inst_5 : NormedAddCommGroup E₁] [inst_6 : NormedAddCommGroup E... | null | true |
RingCat.FilteredColimits.colimitCocone | Mathlib.Algebra.Category.Ring.FilteredColimits | {J : Type v} →
[inst : CategoryTheory.SmallCategory J] →
[CategoryTheory.IsFiltered J] → (F : CategoryTheory.Functor J RingCat) → CategoryTheory.Limits.Cocone F | The cocone over the proposed colimit ring. | true |
ContinuousMulEquiv.trans | Mathlib.Topology.Algebra.ContinuousMonoidHom | {M : Type u_1} →
{N : Type u_2} →
[inst : TopologicalSpace M] →
[inst_1 : TopologicalSpace N] →
[inst_2 : Mul M] →
[inst_3 : Mul N] →
{L : Type u_3} → [inst_4 : Mul L] → [inst_5 : TopologicalSpace L] → M ≃ₜ* N → N ≃ₜ* L → M ≃ₜ* L | The composition of two ContinuousMulEquiv. | true |
instDecidableEqChar.match_1 | Init.Prelude | (c d : Char) →
(motive : Decidable (c.val = d.val) → Sort u_1) →
(x : Decidable (c.val = d.val)) →
((h : c.val = d.val) → motive (isTrue h)) → ((h : ¬c.val = d.val) → motive (isFalse h)) → motive x | null | false |
TrivSqZeroExt.fst_exp | Mathlib.Analysis.Normed.Algebra.TrivSqZeroExt | ∀ {R : Type u_3} {M : Type u_4} [inst : CommRing R] [inst_1 : AddCommGroup M] [Algebra ℚ R] [Module ℚ M]
[inst_4 : Module R M] [inst_5 : Module Rᵐᵒᵖ M] [inst_6 : IsCentralScalar R M] [inst_7 : TopologicalSpace R]
[inst_8 : TopologicalSpace M] [inst_9 : IsTopologicalRing R] [inst_10 : IsTopologicalAddGroup M]
[ins... | null | true |
List.get._unsafe_rec | Init.Prelude | {α : Type u} → (as : List α) → Fin as.length → α | null | false |
MeasurableEmbedding.ae_map_iff | Mathlib.MeasureTheory.Measure.Restrict | ∀ {α : Type u_2} {β : Type u_3} {m0 : MeasurableSpace α} {m1 : MeasurableSpace β} {f : α → β},
MeasurableEmbedding f →
∀ {p : β → Prop} {μ : MeasureTheory.Measure α},
(∀ᵐ (x : β) ∂MeasureTheory.Measure.map f μ, p x) ↔ ∀ᵐ (x : α) ∂μ, p (f x) | null | true |
Lean.AxiomVal.isUnsafe | Lean.Declaration | Lean.AxiomVal → Bool | null | true |
Affine.Triangle.circumsphere_eq_circumsphere_of_eq_of_eq_of_two_zsmul_oangle_eq | Mathlib.Geometry.Euclidean.Angle.Sphere | ∀ {V : Type u_1} {P : Type u_2} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V] [inst_2 : MetricSpace P]
[inst_3 : NormedAddTorsor V P] [hd2 : Fact (Module.finrank ℝ V = 2)] [inst_4 : Module.Oriented ℝ V (Fin 2)]
{t₁ t₂ : Affine.Triangle ℝ P} {i₁ i₂ i₃ : Fin 3},
i₁ ≠ i₂ →
i₁ ≠ i₃ →
i₂ ≠ i... | If two triangles have two points the same, and twice the angle at the third point the same,
they have the same circumsphere. | true |
Multiset.decidableMem | Mathlib.Data.Multiset.Defs | {α : Type u_1} → [DecidableEq α] → (a : α) → (s : Multiset α) → Decidable (a ∈ s) | null | true |
CategoryTheory.regularTopology.parallelPair_pullback_initial | Mathlib.CategoryTheory.Sites.Coherent.RegularSheaves | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {X B : C} (π : X ⟶ B)
(c : CategoryTheory.Limits.PullbackCone π π) (hc : CategoryTheory.Limits.IsLimit c),
(CategoryTheory.Limits.parallelPair (CategoryTheory.ObjectProperty.homMk (CategoryTheory.Over.homMk c.fst ⋯)).op
(CategoryTheory.ObjectPrope... | null | true |
List.Forall.imp | Mathlib.Data.List.Basic | ∀ {α : Type u} {p q : α → Prop}, (∀ (x : α), p x → q x) → ∀ {l : List α}, List.Forall p l → List.Forall q l | null | true |
cast_inj | Mathlib.Logic.Function.Basic | ∀ {α β : Type u} (h : α = β) {x y : α}, cast h x = cast h y ↔ x = y | null | true |
List.head?_concat_concat | Init.Data.List.Lemmas | ∀ {α : Type u_1} {l : List α} {a b : α}, (l ++ [a, b]).head? = (l ++ [a]).head? | null | true |
Lean.isNonRecStructure | Lean.Structure | Lean.Environment → Lean.Name → Bool | Returns true iff `constName` is a non-recursive inductive datatype that has only one constructor and no indices.
Such types have special kernel support (e.g. the eta rule). This must be in sync with `is_non_rec_structure()`.
| true |
Fintype.subtypeEq._proof_1 | Mathlib.Data.Fintype.Basic | ∀ {α : Type u_1} (y x : α), x ∈ {y} ↔ x = y | null | false |
Lean.ParserCompiler.instInhabitedCombinatorAttribute.default | Lean.ParserCompiler.Attribute | Lean.ParserCompiler.CombinatorAttribute | null | true |
_private.Mathlib.Algebra.Polynomial.Degree.Lemmas.0.Polynomial.natDegree_comp._simp_1_2 | Mathlib.Algebra.Polynomial.Degree.Lemmas | ∀ {R : Type u} [inst : Semiring R] {p : Polynomial R}, (p.leadingCoeff = 0) = (p = 0) | null | false |
CategoryTheory.WithInitial.map | Mathlib.CategoryTheory.WithTerminal.Basic | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{D : Type u_1} →
[inst_1 : CategoryTheory.Category.{v_1, u_1} D] →
CategoryTheory.Functor C D →
CategoryTheory.Functor (CategoryTheory.WithInitial C) (CategoryTheory.WithInitial D) | Map `WithInitial` with respect to a functor `F : C ⥤ D`. | true |
_private.Init.Data.Range.Polymorphic.Lemmas.0.Std.Roo.toList_succ_succ_eq_map._simp_1_5 | Init.Data.Range.Polymorphic.Lemmas | ∀ {a b : Prop}, (a ∧ b) = (b ∧ a) | null | false |
List.all_filter | Init.Data.List.Lemmas | ∀ {α : Type u_1} {l : List α} {p q : α → Bool}, (List.filter p l).all q = l.all fun a => !p a || q a | null | true |
_private.Mathlib.MeasureTheory.Measure.MeasuredSets.0.MeasureTheory.exists_measure_symmDiff_lt_of_generateFrom_isSetRing._simp_1_10 | Mathlib.MeasureTheory.Measure.MeasuredSets | ∀ {α : Sort u_1} {p : α → Prop}, (¬∃ x, p x) = ∀ (x : α), ¬p x | null | false |
Function.HasTemperateGrowth.fun_mul | Mathlib.Analysis.Distribution.TemperateGrowth | ∀ {R : Type u_3} {E : Type u_5} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] [inst_2 : NormedRing R]
[inst_3 : NormedAlgebra ℝ R] {f g : E → R},
Function.HasTemperateGrowth f → Function.HasTemperateGrowth g → Function.HasTemperateGrowth fun i => f i * g i | Eta-expanded form of `Function.HasTemperateGrowth.mul`
---
The product of two functions of temperate growth is again of temperate growth. | true |
Lean.Elab.Term.Quotation.HeadInfo.mk.noConfusion | Lean.Elab.Quotation | {P : Sort u} →
{check : Lean.Elab.Term.Quotation.HeadCheck} →
{onMatch : Lean.Elab.Term.Quotation.HeadCheck → Lean.Elab.Term.Quotation.MatchResult} →
{doMatch :
(List Lean.Term → Lean.Elab.TermElabM Lean.Term) →
Lean.Elab.TermElabM Lean.Term → Lean.Elab.TermElabM Lean.Term} →
{... | null | false |
Lean.Grind.ToInt.toInt_mem | Init.Grind.ToInt | ∀ {α : Type u} {range : outParam Lean.Grind.IntInterval} [self : Lean.Grind.ToInt α range] (x : α), ↑x ∈ range | The embedding function lands in the interval. | true |
Array.instDecidableExistsAndMemOfDecidablePred | Init.Data.Array.Lemmas | {α : Type u_1} → {xs : Array α} → {p : α → Prop} → [DecidablePred p] → Decidable (∃ x ∈ xs, p x) | null | true |
ContinuousCohomology.Iobj._proof_9 | Mathlib.Algebra.Category.ContinuousCohomology.Basic | ∀ {R : Type u_3} {G : Type u_1} [inst : CommRing R] [inst_1 : Group G] [inst_2 : TopologicalSpace R]
[inst_3 : TopologicalSpace G] (rep : Action (TopModuleCat R) G), ContinuousAdd C(G, ↑rep.V.toModuleCat) | null | false |
Nat.instLawfulOrderLT | Init.Data.Nat.Order | Std.LawfulOrderLT ℕ | null | true |
CommRing.toNonUnitalCommRing._proof_3 | Mathlib.Algebra.Ring.Defs | ∀ {α : Type u_1} [s : CommRing α] (n : ℕ) (a : α), Ring.zsmul (↑n.succ) a = Ring.zsmul (↑n) a + a | null | false |
Matrix.seminormedAddCommGroup._proof_2 | 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 : Matrix m n α), dist x y = dist y x | null | false |
CategoryTheory.Monad.beckCofork_π | Mathlib.CategoryTheory.Monad.Coequalizer | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {T : CategoryTheory.Monad C} (X : T.Algebra),
(CategoryTheory.Monad.beckCofork X).π = X.a | null | true |
_private.Mathlib.Data.List.Cycle.0.Cycle.length_nontrivial._simp_1_2 | Mathlib.Data.List.Cycle | ∀ {a b : ℕ}, (a.succ ≤ b.succ) = (a ≤ b) | null | false |
Subarray | Init.Data.Array.Subarray | Type u → Type u | A region of some underlying array.
A subarray contains an array together with the start and end indices of a region of interest.
Subarrays can be used to avoid copying or allocating space, while being more convenient than
tracking the bounds by hand. The region of interest consists of every index that is both greater
... | true |
Subring.mem_sInf | Mathlib.Algebra.Ring.Subring.Basic | ∀ {R : Type u} [inst : NonAssocRing R] {S : Set (Subring R)} {x : R}, x ∈ sInf S ↔ ∀ p ∈ S, x ∈ p | null | true |
Associates.coe_unit_eq_one | Mathlib.Algebra.GroupWithZero.Associated | ∀ {M : Type u_1} [inst : CommMonoid M] (u : (Associates M)ˣ), ↑u = 1 | null | true |
FirstOrder.Language.Relations.realize_transitive | Mathlib.ModelTheory.Semantics | ∀ {L : FirstOrder.Language} {M : Type w} [inst : L.Structure M] {r : L.Relations 2},
M ⊨ r.transitive ↔ IsTrans M fun x y => FirstOrder.Language.Structure.RelMap r ![x, y] | null | true |
HomotopyCategory.Plus.singleFunctors._proof_1 | Mathlib.Algebra.Homology.HomotopyCategory.Plus | ∀ (C : Type u_2) [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Preadditive C]
[inst_2 : CategoryTheory.Limits.HasZeroObject C] (n : ℤ) (X : C),
HomotopyCategory.plus C ((HomotopyCategory.singleFunctor C n).obj X) | null | false |
Lean.MessageData.Exprs.rec | Mathlib.Lean.MessageData.ForExprs | {motive : Lean.MessageData.Exprs → Sort u} →
((msg : Lean.MessageData) → motive { msg := msg }) → (t : Lean.MessageData.Exprs) → motive t | null | false |
QuadraticMap.coeFn_smul._simp_1 | Mathlib.LinearAlgebra.QuadraticForm.Basic | ∀ {S : Type u_1} {R : Type u_3} {M : Type u_4} {N : Type u_5} [inst : CommSemiring R] [inst_1 : AddCommMonoid M]
[inst_2 : Module R M] [inst_3 : AddCommMonoid N] [inst_4 : Module R N] [inst_5 : Monoid S]
[inst_6 : DistribMulAction S N] [inst_7 : SMulCommClass S R N] (a : S) (Q : QuadraticMap R M N), a • ⇑Q = ⇑(a • ... | null | false |
LowerSet.iicInfHom_apply | Mathlib.Order.UpperLower.Hom | ∀ {α : Type u_1} [inst : SemilatticeInf α] (a : α), LowerSet.iicInfHom a = LowerSet.Iic a | null | true |
IsLocalHomeomorph.map_nhds_eq | Mathlib.Topology.IsLocalHomeomorph | ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] {f : X → Y},
IsLocalHomeomorph f → ∀ (x : X), Filter.map f (nhds x) = nhds (f x) | null | true |
_private.Mathlib.Algebra.Order.Ring.Ordering.Defs.0.RingPreordering.instHasIdealSupportOfHasMemOrNegMem.match_1 | Mathlib.Algebra.Order.Ring.Ordering.Defs | ∀ {R : Type u_1} [inst : CommRing R] {P : RingPreordering R} (x : R) (motive : x ∈ P ∨ -x ∈ P → Prop)
(x_1 : x ∈ P ∨ -x ∈ P), (∀ (hx : x ∈ P), motive ⋯) → (∀ (hx : -x ∈ P), motive ⋯) → motive x_1 | null | false |
Lean.Syntax.replaceM | Lean.Syntax | {m : Type → Type} → [Monad m] → (Lean.Syntax → m (Option Lean.Syntax)) → Lean.Syntax → m Lean.Syntax | null | true |
NNRat.lt_def | Mathlib.Data.NNRat.Defs | ∀ {p q : ℚ≥0}, p < q ↔ p.num * q.den < q.num * p.den | null | true |
CochainComplex.HomComplex.Cochain.InductionUp.sequence._unsafe_rec | Mathlib.Algebra.Homology.HomotopyCategory.HomComplexInduction | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
[inst_1 : CategoryTheory.Preadditive C] →
{K L : CochainComplex C ℤ} →
{d : ℤ} →
{X : ℕ → Set (CochainComplex.HomComplex.Cochain K L d)} →
((n : ℕ) → ↑(X n) → ↑(X (n + 1))) → ↑(X 0) → (n : ℕ) → ↑(X n) | null | false |
PiTensorProduct.lifts.eq_1 | Mathlib.LinearAlgebra.PiTensorProduct | ∀ {ι : Type u_1} {R : Type u_4} [inst : CommSemiring R] {s : ι → Type u_7} [inst_1 : (i : ι) → AddCommMonoid (s i)]
[inst_2 : (i : ι) → Module R (s i)] (x : PiTensorProduct R fun i => s i), x.lifts = {p | ↑p = x} | null | true |
_private.Mathlib.Analysis.Distribution.ContDiffMapSupportedIn.0.ContDiffMapSupportedIn.continuous_iff_comp_order_le._simp_1_1 | Mathlib.Analysis.Distribution.ContDiffMapSupportedIn | ∀ {α : Prop}, (True → α) = α | null | false |
_private.Mathlib.InformationTheory.KullbackLeibler.Basic.0.InformationTheory.toReal_klDiv_smul_right._simp_1_6 | Mathlib.InformationTheory.KullbackLeibler.Basic | ∀ {M₀ : Type u_1} [inst : MonoidWithZero M₀] {a : M₀} [IsReduced M₀] (n : ℕ), a ≠ 0 → (a ^ n = 0) = False | null | false |
Mathlib.Tactic.BicategoryLike.CoherenceHom.tgt | Mathlib.Tactic.CategoryTheory.Coherence.Datatypes | Mathlib.Tactic.BicategoryLike.CoherenceHom → Mathlib.Tactic.BicategoryLike.Mor₁ | The codomain of a coherence isomorphism. | true |
SubMulAction.ofStabilizer.conjMap_comp | Mathlib.GroupTheory.GroupAction.SubMulAction.OfStabilizer | ∀ {G : Type u_1} [inst : Group G] {α : Type u_2} [inst_1 : MulAction G α] {g h k : G} {a b c : α} (hg : b = g • a)
(hh : c = h • b) (hk : c = k • a) (H : k = h * g),
(SubMulAction.ofStabilizer.conjMap hh).comp (SubMulAction.ofStabilizer.conjMap hg) =
SubMulAction.ofStabilizer.conjMap hk | null | true |
RootPairing.chainTopCoeff_of_not_linearIndependent | Mathlib.LinearAlgebra.RootSystem.Chain | ∀ {ι : Type u_1} {R : Type u_2} {M : Type u_3} {N : Type u_4} [inst : Finite ι] [inst_1 : CommRing R]
[inst_2 : CharZero R] [inst_3 : IsDomain R] [inst_4 : AddCommGroup M] [inst_5 : Module R M] [inst_6 : AddCommGroup N]
[inst_7 : Module R N] {P : RootPairing ι R M N} [inst_8 : P.IsCrystallographic] {i j : ι},
¬Li... | null | true |
_private.Mathlib.FieldTheory.PerfectClosure.0.PerfectClosure.add_aux_right.match_1_1 | Mathlib.FieldTheory.PerfectClosure | ∀ (K : Type u_1) [inst : CommRing K] (p : ℕ) [inst_1 : Fact (Nat.Prime p)] [inst_2 : CharP K p]
(motive : (y1 y2 : ℕ × K) → PerfectClosure.R K p y1 y2 → Prop) (y1 y2 : ℕ × K) (H : PerfectClosure.R K p y1 y2),
(∀ (n : ℕ) (y : K), motive (n, y) (n + 1, (frobenius K p) y) ⋯) → motive y1 y2 H | null | false |
_private.Mathlib.AlgebraicGeometry.ProjectiveSpectrum.Proper.0.AlgebraicGeometry.Proj.valuativeCriterion_existence_aux._simp_1_9 | Mathlib.AlgebraicGeometry.ProjectiveSpectrum.Proper | ∀ {R : Type u_1} [inst : CommRing R] {K : Type u_5} [inst_1 : CommRing K] [inst_2 : Algebra R K] [IsFractionRing R K]
{a b : R}, (↑a = ↑b) = (a = b) | null | false |
Real.le_sqrt_of_sq_le | Mathlib.Analysis.Real.Sqrt | ∀ {x y : ℝ}, x ^ 2 ≤ y → x ≤ √y | null | true |
RingPreordering.support_eq_bot | Mathlib.Algebra.Order.Ring.Ordering.Basic | ∀ {F : Type u_2} [inst : Field F] (P : RingPreordering F), P.support = ⊥ | null | true |
Matrix.eq_zero_of_mulVec_eq_zero | Mathlib.LinearAlgebra.Matrix.Nondegenerate | ∀ {m : Type u_1} {A : Type u_4} [inst : Fintype m] [inst_1 : CommRing A] [IsDomain A] [inst_3 : DecidableEq m]
{M : Matrix m m A}, M.det ≠ 0 → ∀ {v : m → A}, M.mulVec v = 0 → v = 0 | null | true |
MeasurableSpace.generateFrom_singleton_univ | Mathlib.MeasureTheory.MeasurableSpace.Defs | ∀ {α : Type u_1}, MeasurableSpace.generateFrom {Set.univ} = ⊥ | null | true |
Function.Embedding.nonempty_of_card_le | Mathlib.Data.Fintype.EquivFin | ∀ {α : Type u_1} {β : Type u_2} [inst : Fintype α] [inst_1 : Fintype β],
Fintype.card α ≤ Fintype.card β → Nonempty (α ↪ β) | null | true |
_private.Mathlib.Combinatorics.SetFamily.Compression.Down.0.Down.erase_mem_compression._simp_1_2 | Mathlib.Combinatorics.SetFamily.Compression.Down | ∀ {a : Prop}, (a ∧ a) = a | null | false |
MeasurableEquiv.symm_addLeft | Mathlib.MeasureTheory.Group.MeasurableEquiv | ∀ {G : Type u_1} [inst : AddGroup G] [inst_1 : MeasurableSpace G] [inst_2 : MeasurableAdd G] (g : G),
(MeasurableEquiv.addLeft g).symm = MeasurableEquiv.addLeft (-g) | null | true |
LeftInvariantDerivation.hasIntScalar | Mathlib.Geometry.Manifold.Algebra.LeftInvariantDerivation | {𝕜 : Type u_1} →
[inst : NontriviallyNormedField 𝕜] →
{E : Type u_2} →
[inst_1 : NormedAddCommGroup E] →
[inst_2 : NormedSpace 𝕜 E] →
{H : Type u_3} →
[inst_3 : TopologicalSpace H] →
{I : ModelWithCorners 𝕜 E H} →
{G : Type u_4} →
... | null | true |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.minKeyD_le_minKeyD_erase._simp_1_3 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {x : Ord α} {t : Std.DTreeMap.Internal.Impl α β} {k : α},
(k ∈ t) = (Std.DTreeMap.Internal.Impl.contains k t = true) | null | false |
Ordinal.omega_ofNat_lt_lift | Mathlib.SetTheory.Cardinal.Aleph | ∀ {o : Ordinal.{u}} {n : ℕ} [inst : n.AtLeastTwo],
Ordinal.omega (OfNat.ofNat n) < Ordinal.lift.{v, u} o ↔ Ordinal.omega (OfNat.ofNat n) < o | null | true |
HahnSeries.finiteArchimedeanClassOrderIsoLex._proof_1 | Mathlib.RingTheory.HahnSeries.Lex | ∀ (Γ : Type u_1) (R : Type u_2) [inst : LinearOrder Γ] [inst_1 : LinearOrder R] [inst_2 : AddCommGroup R]
[inst_3 : IsOrderedAddMonoid R],
(HahnSeries.finiteArchimedeanClassOrderHomLex Γ R).comp (HahnSeries.finiteArchimedeanClassOrderHomInvLex Γ R) =
OrderHom.id | null | false |
FirstOrder.Language.BoundedFormula.toPrenexImp.eq_def | Mathlib.ModelTheory.Complexity | ∀ {L : FirstOrder.Language} {α : Type u'} (x : ℕ) (x_1 x_2 : L.BoundedFormula α x),
x_1.toPrenexImp x_2 =
match x, x_1, x_2 with
| n, (φ.imp FirstOrder.Language.BoundedFormula.falsum).all.imp FirstOrder.Language.BoundedFormula.falsum, ψ =>
(φ.toPrenexImp (FirstOrder.Language.BoundedFormula.liftAt 1 n ψ)... | null | true |
Lean.Widget.RpcEncodablePacket._@.Lean.Widget.InteractiveGoal.1490754142._hygCtx._hyg.1 | Lean.Widget.InteractiveGoal | Type | null | false |
GrpCat.SurjectiveOfEpiAuxs.instDecidableEqXWithInfinity | Mathlib.Algebra.Category.Grp.EpiMono | {A B : GrpCat} → (f : A ⟶ B) → DecidableEq (GrpCat.SurjectiveOfEpiAuxs.XWithInfinity f) | null | true |
Lean.PrefixTreeNode._sizeOf_3_eq | Lean.Data.PrefixTree | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} [inst : SizeOf α] [inst_1 : SizeOf β]
(x : Std.DTreeMap.Raw α (fun x => Lean.PrefixTreeNode α β cmp) cmp), Lean.PrefixTreeNode._sizeOf_3 x = sizeOf x | null | false |
_private.Mathlib.Data.Finsupp.Basic.0.Finsupp.mem_splitSupport_iff_nonzero._simp_1_6 | Mathlib.Data.Finsupp.Basic | ∀ {α : Sort u_1} {p : α → Prop} {a' : α}, (∃ a, p a ∧ a = a') = p a' | null | false |
CategoryTheory.MorphismProperty.instHasIsosPrecoverageOfContainsIdentitiesOfRespectsIso | Mathlib.CategoryTheory.Sites.MorphismProperty | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {P : CategoryTheory.MorphismProperty C}
[P.ContainsIdentities] [P.RespectsIso], P.precoverage.HasIsos | null | true |
CategoryTheory.BraidedCategory.hexagon_reverse_inv_assoc | Mathlib.CategoryTheory.Monoidal.Braided.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.MonoidalCategory C]
[inst_2 : CategoryTheory.BraidedCategory C] (X Y Z : C) {Z_1 : C}
(h : CategoryTheory.MonoidalCategoryStruct.tensorObj X (CategoryTheory.MonoidalCategoryStruct.tensorObj Y Z) ⟶ Z_1),
CategoryTheory.CategoryStruct... | null | true |
Lean.getFieldInfo? | Lean.Structure | Lean.Environment → Lean.Name → Lean.Name → Option Lean.StructureFieldInfo | Gets the `StructureFieldInfo` for the given direct field of the structure. | true |
Complex.exp_ofReal_mul_I | Mathlib.Analysis.Complex.Trigonometric | ∀ (x : ℝ), Complex.exp (↑x * Complex.I) = ↑(Real.cos x) + ↑(Real.sin x) * Complex.I | null | true |
List.getElem?_mapIdx | Init.Data.List.MapIdx | ∀ {α : Type u_1} {α_1 : Type u_2} {f : ℕ → α → α_1} {l : List α} {i : ℕ}, (List.mapIdx f l)[i]? = Option.map (f i) l[i]? | null | true |
UniformEquiv.neg._proof_2 | Mathlib.Topology.Algebra.IsUniformGroup.Basic | ∀ (G : Type u_1) [inst : AddGroup G] [inst_1 : TopologicalSpace G] [inst_2 : IsTopologicalAddGroup G],
UniformContinuous ⇑(Equiv.neg G) | null | false |
Prod.instZeroLEOneClass | Mathlib.Algebra.Order.ZeroLEOne | ∀ {R : Type u_2} {S : Type u_3} [inst : Zero R] [inst_1 : One R] [inst_2 : LE R] [ZeroLEOneClass R] [inst_4 : Zero S]
[inst_5 : One S] [inst_6 : LE S] [ZeroLEOneClass S], ZeroLEOneClass (R × S) | null | true |
OpenPartialHomeomorph.symm_piecewise | Mathlib.Topology.OpenPartialHomeomorph.Constructions | ∀ {X : Type u_1} {Y : Type u_3} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y]
(e e' : OpenPartialHomeomorph X Y) {s : Set X} {t : Set Y} [inst_2 : (x : X) → Decidable (x ∈ s)]
[inst_3 : (y : Y) → Decidable (y ∈ t)] (H : e.IsImage s t) (H' : e'.IsImage s t)
(Hs : e.source ∩ frontier s = e'.source ∩ fro... | null | true |
Finset.lt_sup'_iff | Mathlib.Data.Finset.Lattice.Fold | ∀ {α : Type u_2} {ι : Type u_5} [inst : LinearOrder α] {s : Finset ι} (H : s.Nonempty) {f : ι → α} {a : α},
a < s.sup' H f ↔ ∃ b ∈ s, a < f b | null | true |
Std.Iter.Total | Init.Data.Iterators.Consumers.Total | {α : Type w} → Type w → Type w | A wrapper around an iterator that provides strictly terminating consumers. See
`Iter.ensureTermination`.
| true |
ODE.FunSpace.mk.injEq | Mathlib.Analysis.ODE.PicardLindelof | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] {tmin tmax : ℝ} {t₀ : ↑(Set.Icc tmin tmax)} {x₀ : E} {r L : NNReal}
(toFun : ↑(Set.Icc tmin tmax) → E) (lipschitzWith : LipschitzWith L toFun)
(mem_closedBall₀ : toFun t₀ ∈ Metric.closedBall x₀ ↑r) (toFun_1 : ↑(Set.Icc tmin tmax) → E)
(lipschitzWith_1 : LipschitzWith... | null | true |
_private.Mathlib.Algebra.Order.Group.Synonym.0.OrderDual.instIsRightCancelAdd._proof_1 | Mathlib.Algebra.Order.Group.Synonym | ∀ {α : Type u_1} [inst : Add α] [IsRightCancelAdd α], IsRightCancelAdd αᵒᵈ | null | false |
TannakaDuality.FiniteGroup.equivApp_hom | Mathlib.RepresentationTheory.Tannaka | ∀ {k G : Type u} [inst : CommRing k] [inst_1 : Group G] (g : G) (X : FDRep k G),
(TannakaDuality.FiniteGroup.equivApp g X).hom = CategoryTheory.InducedCategory.homMk (ModuleCat.ofHom (X.ρ g)) | null | true |
Std.ExtTreeMap.size_filterMap_eq_size_iff | Std.Data.ExtTreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {γ : Type w} {cmp : α → α → Ordering} {t : Std.ExtTreeMap α β cmp} [inst : Std.TransCmp cmp]
{f : α → β → Option γ},
(Std.ExtTreeMap.filterMap f t).size = t.size ↔ ∀ (k : α) (h : k ∈ t), (f (t.getKey k h) t[k]).isSome = true | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.