name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
_private.Init.Data.UInt.Lemmas.0.USize.zero_lt_one._simp_1_1 | Init.Data.UInt.Lemmas | ∀ {a b : USize}, (a < b) = (a.toNat < b.toNat) | null | false |
_private.Mathlib.Tactic.Linter.TextBased.0.Mathlib.Linter.TextBased.unicodeLinter.match_3 | Mathlib.Tactic.Linter.TextBased | (motive : Mathlib.Linter.TextBased.StyleError✝ → Sort u_1) →
(e : Mathlib.Linter.TextBased.StyleError✝) →
((c : Char) → motive (Mathlib.Linter.TextBased.StyleError.unwantedUnicode✝ c)) →
((s : String) → (sel : Option Char) → motive (Mathlib.Linter.TextBased.StyleError.unicodeVariant✝ s sel)) →
((x :... | null | false |
Subrepresentation.coe_inf | Mathlib.RepresentationTheory.Subrepresentation | ∀ {A : Type u_1} {G : Type u_2} {W : Type u_3} [inst : Semiring A] [inst_1 : Monoid G] [inst_2 : AddCommMonoid W]
[inst_3 : Module A W] {ρ : Representation A G W} (ρ₁ ρ₂ : Subrepresentation ρ), ↑(ρ₁ ⊓ ρ₂) = ↑ρ₁ ∩ ↑ρ₂ | null | true |
Lean.Meta.Grind.CheckResult.closed.sizeOf_spec | Lean.Meta.Tactic.Grind.CheckResult | sizeOf Lean.Meta.Grind.CheckResult.closed = 1 | null | true |
CategoryTheory.Limits.coequalizer.condition_assoc | Mathlib.CategoryTheory.Limits.Shapes.Equalizers | ∀ {C : Type u} {X Y : C} [inst : CategoryTheory.Category.{v, u} C] (f g : Y ⟶ X)
[inst_1 : CategoryTheory.Limits.HasCoequalizer f g] {Z : C} (h : CategoryTheory.Limits.coequalizer f g ⟶ Z),
CategoryTheory.CategoryStruct.comp f
(CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.coequalizer.π f g) h) =
... | null | true |
Std.DHashMap.Internal.Raw₀.getₘ | Std.Data.DHashMap.Internal.Model | {α : Type u} →
{β : α → Type v} →
[inst : BEq α] →
[LawfulBEq α] →
[inst_2 : Hashable α] → (m : Std.DHashMap.Internal.Raw₀ α β) → (a : α) → m.containsₘ a = true → β a | Internal implementation detail of the hash map | true |
_private.Mathlib.MeasureTheory.Measure.Lebesgue.EqHaar.0.MeasureTheory.Measure.tendsto_addHaar_inter_smul_zero_of_density_zero_aux1._simp_1_2 | Mathlib.MeasureTheory.Measure.Lebesgue.EqHaar | ∀ {a b : ENNReal}, (a / b = ⊤) = (a ≠ 0 ∧ b = 0 ∨ a = ⊤ ∧ b ≠ ⊤) | null | false |
ContinuousMap.addUnitsLift._proof_8 | Mathlib.Topology.ContinuousMap.Units | ∀ {X : Type u_2} {M : Type u_1} [inst : TopologicalSpace X] [inst_1 : AddMonoid M] [inst_2 : TopologicalSpace M]
[inst_3 : ContinuousAdd M] (f : AddUnits C(X, M)) (x : X), ↑(-f) x + ↑f x = 0 | null | false |
CategoryTheory.Limits.Cocone.extensions | Mathlib.CategoryTheory.Limits.Cones | {J : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} J] →
{C : Type u₃} →
[inst_1 : CategoryTheory.Category.{v₃, u₃} C] →
{F : CategoryTheory.Functor J C} →
(c : CategoryTheory.Limits.Cocone F) →
(CategoryTheory.coyoneda.obj (Opposite.op c.pt)).comp CategoryTheory.uliftFunc... | A map from the vertex of a cocone naturally induces a cocone by composition. | true |
Finset.max_abv_sum_one_le_of_isNonarchimedean | Mathlib.NumberTheory.Height.Basic | ∀ {R : Type u_1} {S : Type u_2} [inst : Semiring R] [inst_1 : CommSemiring S] [inst_2 : LinearOrder S] [IsOrderedRing S]
{v : AbsoluteValue R S},
IsNonarchimedean ⇑v → ∀ {ι : Type u_3} (s : Finset ι) (x : ι → R), max (v (∑ i ∈ s, x i)) 1 ≤ ∏ i ∈ s, max (v (x i)) 1 | The "local" version of the height bound for arbitrary sums for nonarchimedean
absolute values. | true |
Lean.LMVarId.getLevel | Lean.Meta.Basic | Lean.LMVarId → Lean.MetaM ℕ | Return the level of the given universe level metavariable.
| true |
Lean.ToJson.recOn | Lean.Data.Json.FromToJson.Basic | {α : Type u} →
{motive : Lean.ToJson α → Sort u_1} →
(t : Lean.ToJson α) → ((toJson : α → Lean.Json) → motive { toJson := toJson }) → motive t | null | false |
Std.Iterators.Types.Flatten.IsPlausibleStep.recOn | Init.Data.Iterators.Combinators.Monadic.FlatMap | ∀ {α α₂ β : Type w} {m : Type w → Type w'} [inst : Std.Iterator α m (Std.IterM m β)] [inst_1 : Std.Iterator α₂ m β]
{motive :
(it : Std.IterM m β) →
(step : Std.IterStep (Std.IterM m β) β) → Std.Iterators.Types.Flatten.IsPlausibleStep it step → Prop}
{it : Std.IterM m β} {step : Std.IterStep (Std.IterM m ... | null | false |
Congr!.Config.etaExpand._default | Mathlib.Tactic.CongrExclamation | Bool | null | false |
GradedTensorProduct.«term_ᵍ⊗ₜ[_]_» | Mathlib.LinearAlgebra.TensorProduct.Graded.Internal | Lean.TrailingParserDescr | The graded tensor product of two elements of graded rings. | true |
Std.HashMap.Raw.all | Std.Data.HashMap.Raw | {α : Type u} → {β : Type v} → Std.HashMap.Raw α β → (α → β → Bool) → Bool | Checks if all elements satisfy the predicate, short-circuiting if a predicate fails. | true |
Lean.Meta.LazyDiscrTree.toFlat | Lean.Meta.LazyDiscrTree | {α : Type} →
Lean.Meta.LazyDiscrTree.ImportData →
Lean.Meta.LazyDiscrTree.PreDiscrTree α → BaseIO (Lean.Meta.LazyDiscrTree.InitResults α) | null | true |
_private.Init.Data.Array.InsertIdx.0.Array.insertIdx_comm._proof_4 | Init.Data.Array.InsertIdx | ∀ {α : Type u_1} {i j : ℕ} {xs : Array α}, i ≤ j → j ≤ xs.size → ¬i ≤ xs.size + 1 → False | null | false |
FreeAddGroup.lift_mk | Mathlib.GroupTheory.FreeGroup.Basic | ∀ {α : Type u} {L : List (α × Bool)} {β : Type v} [inst : AddGroup β] {f : α → β},
(FreeAddGroup.lift f) (FreeAddGroup.mk L) = (List.map (fun x => bif x.2 then f x.1 else -f x.1) L).sum | null | true |
Submonoid.centerCongr_apply_coe | Mathlib.GroupTheory.Submonoid.Center | ∀ {M : Type u_2} {N : Type u_1} [inst : MulOneClass M] [inst_1 : MulOneClass N] (e : M ≃* N)
(r : ↥(Subsemigroup.center M)), ↑((Submonoid.centerCongr e) r) = e ↑r | null | true |
Lean.PrintImportResult.rec | Lean.Elab.ParseImportsFast | {motive : Lean.PrintImportResult → Sort u} →
((result? : Option Lean.ModuleHeader) → (errors : Array String) → motive { result? := result?, errors := errors }) →
(t : Lean.PrintImportResult) → motive t | null | false |
mul_pow_le_nat_floor_pow | Mathlib.Analysis.SpecificLimits.FloorPow | ∀ {c : ℝ}, 1 < c → ∀ (i : ℕ), (1 - c⁻¹) * c ^ i ≤ ↑⌊c ^ i⌋₊ | null | true |
MonoidAlgebra.coeffLinearEquiv.eq_1 | Mathlib.Algebra.MonoidAlgebra.Module | ∀ (R : Type u_1) {S : Type u_2} {M : Type u_3} [inst : Semiring R] [inst_1 : Semiring S] [inst_2 : Module R S],
MonoidAlgebra.coeffLinearEquiv R = AddEquiv.linearEquiv R MonoidAlgebra.coeffAddEquiv | null | true |
Matrix.scalarAlgHom_apply | Mathlib.Data.Matrix.Basic | ∀ (n : Type u_3) (R : Type u_4) {α : Type u_8} [inst : Fintype n] [inst_1 : DecidableEq n] [inst_2 : CommSemiring R]
[inst_3 : Semiring α] [inst_4 : Algebra R α] (a : α), (Matrix.scalarAlgHom n R) a = (Matrix.scalar n) a | null | true |
Real.arctan_tan | Mathlib.Analysis.SpecialFunctions.Trigonometric.Arctan | ∀ {x : ℝ}, -(Real.pi / 2) < x → x < Real.pi / 2 → Real.arctan (Real.tan x) = x | null | true |
derivWithin_fun_sum | Mathlib.Analysis.Calculus.Deriv.Add | ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {F : Type v} [inst_1 : NormedAddCommGroup F]
[inst_2 : NormedSpace 𝕜 F] {x : 𝕜} {s : Set 𝕜} {ι : Type u_1} {u : Finset ι} {A : ι → 𝕜 → F},
(∀ i ∈ u, DifferentiableWithinAt 𝕜 (A i) s x) →
derivWithin (fun y => ∑ i ∈ u, A i y) s x = ∑ i ∈ u, derivWithin (A ... | null | true |
Set.bijOn_of_subsingleton | Mathlib.Data.Set.Function | ∀ {α : Type u_1} [Subsingleton α] (f : α → α) (s : Set α), Set.BijOn f s s | null | true |
Finset.divisionCommMonoid._proof_3 | Mathlib.Algebra.Group.Pointwise.Finset.Basic | ∀ {α : Type u_1} [inst : DecidableEq α] [inst_1 : DivisionCommMonoid α] (s : Finset α), ↑s⁻¹ = (↑s)⁻¹ | null | false |
Polynomial.nextCoeff_map | Mathlib.Algebra.Polynomial.Degree.Lemmas | ∀ {R : Type u} {S : Type v} [inst : Semiring R] [inst_1 : Semiring S] {f : R →+* S},
Function.Injective ⇑f → ∀ (p : Polynomial R), (Polynomial.map f p).nextCoeff = f p.nextCoeff | null | true |
_private.Mathlib.Analysis.Complex.Hadamard.0.Complex.HadamardThreeLines.sSupNormIm_scale_right._simp_1_3 | Mathlib.Analysis.Complex.Hadamard | ∀ {α : Type u} {β : Type v} (f : α → β) (s : Set α) (y : β), (y ∈ f '' s) = ∃ x ∈ s, f x = y | null | false |
ISize.add_eq_left._simp_1 | Init.Data.SInt.Lemmas | ∀ {a b : ISize}, (a + b = a) = (b = 0) | null | false |
Subgroup.equivOp.eq_1 | Mathlib.Algebra.Group.Subgroup.MulOpposite | ∀ {G : Type u_1} [inst : Group G] (H : Subgroup G), H.equivOp = MulOpposite.opEquiv.subtypeEquiv ⋯ | null | true |
innerSL._proof_1 | Mathlib.Analysis.InnerProductSpace.LinearMap | ∀ (𝕜 : Type u_1) [inst : RCLike 𝕜], RingHomIsometric (RingHom.id 𝕜) | null | false |
AddMonoid.Coprod.swap_eq_zero | Mathlib.GroupTheory.Coprod.Basic | ∀ {M : Type u_1} {N : Type u_2} [inst : AddZeroClass M] [inst_1 : AddZeroClass N] {x : AddMonoid.Coprod M N},
(AddMonoid.Coprod.swap M N) x = 0 ↔ x = 0 | null | true |
Batteries.UnionFind.rankD_set | Batteries.Data.UnionFind.Basic | ∀ {arr : Array Batteries.UFNode} {x : ℕ} {v : Batteries.UFNode} {i : ℕ} {h : x < arr.size},
Batteries.UnionFind.rankD (arr.set x v h) i = if x = i then v.rank else Batteries.UnionFind.rankD arr i | null | true |
Lean.Meta.Sym.instHashableAlphaKey._private_1 | Lean.Meta.Sym.AlphaShareCommon | Lean.Meta.Sym.AlphaKey → UInt64 | null | false |
CategoryTheory.toOverIsoToOverUnit | Mathlib.CategoryTheory.LocallyCartesianClosed.Over | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
[inst_1 : CategoryTheory.CartesianMonoidalCategory C] →
CategoryTheory.toOver (CategoryTheory.MonoidalCategoryStruct.tensorUnit C) ≅ CategoryTheory.toOverUnit C | The isomorphism of functors `toOver (𝟙_ C)` and `toOverUnit C`. | true |
CategoryTheory.Limits.ImageFactorisation | Mathlib.CategoryTheory.Limits.Shapes.Images | {C : Type u} → [inst : CategoryTheory.Category.{v, u} C] → {X Y : C} → (X ⟶ Y) → Type (max u v) | Data exhibiting that a morphism `f` has an image. | true |
CategoryTheory.Functor.CoconeTypes.postcomp._proof_2 | Mathlib.CategoryTheory.Limits.Types.ColimitType | ∀ {J : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} J] {F : CategoryTheory.Functor J (Type u_3)}
(c : F.CoconeTypes) {T : Type u_4} (φ : c.pt → T) {j j' : J} (f : j ⟶ j'),
(φ ∘ c.ι j') ∘ ⇑(CategoryTheory.ConcreteCategory.hom (F.map f)) = φ ∘ c.ι j | null | false |
CategoryTheory.Grp.instMonoidalCategory._proof_11 | Mathlib.CategoryTheory.Monoidal.Grp | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.CartesianMonoidalCategory C]
[inst_2 : CategoryTheory.BraidedCategory C] {X₁ X₂ X₃ Y₁ Y₂ Y₃ : CategoryTheory.Grp C} (f₁ : X₁ ⟶ Y₁) (f₂ : X₂ ⟶ Y₂)
(f₃ : X₃ ⟶ Y₃),
CategoryTheory.CategoryStruct.comp
(CategoryTheory.Monoida... | null | false |
Lean.Meta.Simp.simpMatchDiscrs? | Lean.Meta.Tactic.Simp.Rewrite | Lean.Meta.MatcherInfo → Lean.Expr → Lean.Meta.SimpM (Option Lean.Meta.Simp.Result) | Given a match-application `e` with `MatcherInfo` `info`, return `some result`
if at least of one of the discriminants has been simplified.
| true |
CategoryTheory.ComposableArrows.IsComplex.cokerToKer'._proof_19 | Mathlib.Algebra.Homology.ExactSequenceFour | ∀ {n : ℕ}, ∀ k ≤ n, k + 1 + 2 < n + 3 + 1 | null | false |
Set.IsWF.mono | Mathlib.Order.WellFoundedSet | ∀ {α : Type u_2} [inst : LT α] {s t : Set α}, t.IsWF → s ⊆ t → s.IsWF | null | true |
Polynomial.C_smul_derivation_apply | Mathlib.Algebra.Polynomial.Derivation | ∀ {R : Type u_1} {A : Type u_2} [inst : CommSemiring R] [inst_1 : AddCommMonoid A] [inst_2 : Module R A]
[inst_3 : Module (Polynomial R) A] (D : Derivation R (Polynomial R) A) (a : R) (f : Polynomial R),
Polynomial.C a • D f = a • D f | null | true |
Bialgebra.ofAlgHom._proof_17 | Mathlib.RingTheory.Bialgebra.Basic | ∀ {R : Type u_1} {A : Type u_2} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A],
SMulCommClass R R A | null | false |
AddValuation.mem_supp_iff | Mathlib.RingTheory.Valuation.Basic | ∀ {R : Type u_3} {Γ₀ : Type u_4} [inst : LinearOrderedAddCommMonoidWithTop Γ₀] [inst_1 : CommRing R]
(v : AddValuation R Γ₀) (x : R), x ∈ v.supp ↔ v x = ⊤ | null | true |
CategoryTheory.pullbackShiftFunctorAdd'_inv_app | Mathlib.CategoryTheory.Shift.Pullback | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {A : Type u_2} {B : Type u_3} [inst_1 : AddMonoid A]
[inst_2 : AddMonoid B] [inst_3 : CategoryTheory.HasShift C B] (φ : A →+ B) (X : CategoryTheory.PullbackShift C φ)
(a₁ a₂ a₃ : A) (h : a₁ + a₂ = a₃) (b₁ b₂ b₃ : B) (h₁ : b₁ = φ a₁) (h₂ : b₂ = φ a₂) (h₃... | null | true |
AlgebraicTopology.inclusionOfMooreComplexMap_f | Mathlib.AlgebraicTopology.AlternatingFaceMapComplex | ∀ {A : Type u_2} [inst : CategoryTheory.Category.{v_2, u_2} A] [inst_1 : CategoryTheory.Abelian A]
(X : CategoryTheory.SimplicialObject A) (n : ℕ),
(AlgebraicTopology.inclusionOfMooreComplexMap X).f n = (AlgebraicTopology.NormalizedMooreComplex.objX X n).arrow | null | true |
ZFClass.mem_sUnion._simp_1 | Mathlib.SetTheory.ZFC.Class | ∀ {A : ZFClass.{u}} {y : ZFSet.{u}}, (y ∈ A.sUnion) = ∃ z ∈ A, y ∈ z | null | false |
Std.TreeSet.size_insertMany_list | Std.Data.TreeSet.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t : Std.TreeSet α cmp} [Std.TransCmp cmp] [inst : BEq α] [Std.LawfulBEqCmp cmp]
{l : List α},
List.Pairwise (fun a b => ¬cmp a b = Ordering.eq) l →
(∀ a ∈ t, l.contains a = false) → (t.insertMany l).size = t.size + l.length | null | true |
Lean.IRPhases.comptime.elim | Lean.Setup | {motive : Lean.IRPhases → Sort u} → (t : Lean.IRPhases) → t.ctorIdx = 1 → motive Lean.IRPhases.comptime → motive t | null | false |
ContinuousLinearMap.IsFredholm.index_comp | Mathlib.Analysis.Normed.Operator.Fredholm.Basic | ∀ {𝕜 : Type u_1} {E : Type u_2} {F : Type u_3} {G : Type u_4} [inst : NontriviallyNormedField 𝕜]
[inst_1 : AddCommGroup E] [inst_2 : AddCommGroup F] [inst_3 : AddCommGroup G] [inst_4 : Module 𝕜 E]
[inst_5 : Module 𝕜 F] [inst_6 : Module 𝕜 G] [inst_7 : TopologicalSpace E] [inst_8 : TopologicalSpace F]
[inst_9 ... | null | true |
Polynomial.integralNormalization_eval₂_eq_zero_of_commute | Mathlib.RingTheory.Polynomial.IntegralNormalization | ∀ {R : Type u} [inst : Semiring R] {A : Type u_1} [inst_1 : Semiring A] {p : Polynomial R} (f : R →+* A) {z : A},
Polynomial.eval₂ f z p = 0 →
Commute (f p.leadingCoeff) z →
(∀ {r r' : R}, Commute (f r) (f r')) →
(∀ (x : R), f x = 0 → x = 0) → Polynomial.eval₂ f (f p.leadingCoeff * z) p.integralNorm... | null | true |
Lean.Grind.Ring.OfSemiring.npow._sunfold | Init.Grind.Ring.Envelope | {α : Type u} → [inst : Lean.Grind.Semiring α] → Lean.Grind.Ring.OfSemiring.Q α → ℕ → Lean.Grind.Ring.OfSemiring.Q α | null | false |
CategoryTheory._aux_Mathlib_CategoryTheory_Category_Basic___unexpand_CategoryTheory_CategoryStruct_id_1 | Mathlib.CategoryTheory.Category.Basic | Lean.PrettyPrinter.Unexpander | null | false |
Vector.back_ofFn._proof_2 | Init.Data.Vector.OfFn | ∀ {n : ℕ} [NeZero n], n - 1 < n | null | false |
ChainCompletePartialOrder.IsAdmissible | Mathlib.Order.BourbakiWitt | {α : Type u_1} → [ChainCompletePartialOrder α] → α → (α → α) → Set α → Prop | An admissible set for given `x : α` and `f : α → α` has `x`, the base point, as a least element
and is closed under applying `f` and `cSup`. | true |
QuasispectrumRestricts | Mathlib.Algebra.Algebra.Spectrum.Quasispectrum | {R : Type u_3} →
{S : Type u_4} →
{A : Type u_5} →
[inst : CommSemiring R] →
[inst_1 : CommSemiring S] →
[inst_2 : NonUnitalRing A] → [Module R A] → [Module S A] → [Algebra R S] → A → (S → R) → Prop | Given an element `a : A` of an `S`-algebra, where `S` is itself an `R`-algebra, we say that
the spectrum of `a` restricts via a function `f : S → R` if `f` is a left inverse of
`algebraMap R S`, and `f` is a right inverse of `algebraMap R S` on `spectrum S a`.
For example, when `f = Complex.re` (so `S := ℂ` and `R := ... | true |
_private.Mathlib.NumberTheory.CarmichaelNumber.0.Nat.IsCarmichael.odd._proof_1_3 | Mathlib.NumberTheory.CarmichaelNumber | ∀ (n : ℕ), ¬Odd (n + 1) → ¬Even n | null | false |
Lean.pp.mvars.levels | Lean.PrettyPrinter.Delaborator.Options | Lean.Option Bool | null | true |
_private.Mathlib.Analysis.MellinTransform.0.mellin_cpow_smul._simp_1_1 | Mathlib.Analysis.MellinTransform | ∀ {α : Type u_1} [inst : SubtractionCommMonoid α] (a b c : α), a + c - b = a - b + c | null | false |
_private.Mathlib.Topology.Order.LeftRight.0.continuousAt_iff_continuous_left_right._simp_1_1 | Mathlib.Topology.Order.LeftRight | ∀ {α : Type u_1} {β : Type u_2} {f : α → β} {x₁ x₂ : Filter α} {y : Filter β},
(Filter.Tendsto f x₁ y ∧ Filter.Tendsto f x₂ y) = Filter.Tendsto f (x₁ ⊔ x₂) y | null | false |
CategoryTheory.Functor.OneHypercoverDenseData.SieveStruct.mk | Mathlib.CategoryTheory.Sites.DenseSubsite.OneHypercoverDense | {C₀ : Type u₀} →
{C : Type u} →
[inst : CategoryTheory.Category.{v₀, u₀} C₀] →
[inst_1 : CategoryTheory.Category.{v, u} C] →
{F : CategoryTheory.Functor C₀ C} →
{J₀ : CategoryTheory.GrothendieckTopology C₀} →
{J : CategoryTheory.GrothendieckTopology C} →
{X : C} →... | null | true |
EuclideanGeometry.oangle_ne_zero_and_ne_pi_iff_affineIndependent | Mathlib.Geometry.Euclidean.Angle.Oriented.Affine | ∀ {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)]
{p₁ p₂ p₃ : P},
EuclideanGeometry.oangle p₁ p₂ p₃ ≠ 0 ∧ EuclideanGeometry.oangle p₁ p₂... | An oriented angle is not zero or `π` if and only if the three points are affinely
independent. | true |
AddGroupNorm.instAdd | Mathlib.Analysis.Normed.Group.Seminorm | {E : Type u_3} → [inst : AddGroup E] → Add (AddGroupNorm E) | null | true |
TopologicalAddGroup.IsSES.integral_inducedMeasure | Mathlib.MeasureTheory.Measure.Haar.Extension | ∀ {A : Type u_1} {B : Type u_2} {C : Type u_3} [inst : AddGroup A] [inst_1 : AddGroup B] [inst_2 : AddGroup C]
[inst_3 : TopologicalSpace A] [inst_4 : TopologicalSpace B] [inst_5 : TopologicalSpace C] {φ : A →+ B} {ψ : B →+ C}
(H : TopologicalAddGroup.IsSES φ ψ) [inst_6 : IsTopologicalAddGroup A] [inst_7 : IsTopolo... | null | true |
powMonoidHom | Mathlib.Algebra.Group.Hom.Basic | {α : Type u_1} → [inst : CommMonoid α] → ℕ → α →* α | The `n`th power map on a commutative monoid for a natural `n`, considered as a morphism of
monoids. | true |
Function.Injective.rightCancelMonoid | Mathlib.Algebra.Group.InjSurj | {M₁ : Type u_1} →
{M₂ : Type u_2} →
[inst : Mul M₁] →
[inst_1 : One M₁] →
[inst_2 : Pow M₁ ℕ] →
[inst_3 : RightCancelMonoid M₂] →
(f : M₁ → M₂) →
Function.Injective f →
f 1 = 1 →
(∀ (x y : M₁), f (x * y) = f x * f y) →
... | A type endowed with `1` and `*` is a right cancel monoid, if it admits an injective map that
preserves `1` and `*` to a right cancel monoid. See note [reducible non-instances]. | true |
AlgebraicGeometry.Scheme.irreducibleComponentIdeal | Mathlib.AlgebraicGeometry.IdealSheaf.IrreducibleComponent | (X : AlgebraicGeometry.Scheme) →
(Z : Set ↥X) → Z ∈ irreducibleComponents ↥X → [AlgebraicGeometry.IsNoetherian X] → X.IdealSheafData | The ideal sheaf data associated to an irreducible component of a Noetherian scheme. | true |
Aesop.Options'.maxSafePrefixRuleApplications._inherited_default | Aesop.Options.Internal | ℕ | null | false |
CategoryTheory.Limits.limitSubobjectProduct | Mathlib.CategoryTheory.Limits.Constructions.LimitsOfProductsAndEqualizers | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{J : Type w} →
[inst_1 : CategoryTheory.SmallCategory J] →
[inst_2 : CategoryTheory.Limits.HasLimitsOfSize.{w, w, v, u} C] →
(F : CategoryTheory.Functor J C) → CategoryTheory.Limits.limit F ⟶ ∏ᶜ fun j => F.obj j | A limit can be realised as a subobject of a product. | true |
RingCat.ringObj._proof_40 | Mathlib.Algebra.Category.Ring.Limits | ∀ {J : Type u_3} [inst : CategoryTheory.Category.{u_1, u_3} J] (F : CategoryTheory.Functor J RingCat) (j : J)
(a : (F.comp (CategoryTheory.forget RingCat)).obj j), -a + a = 0 | null | false |
OpenPartialHomeomorph.continuousAt | Mathlib.Topology.OpenPartialHomeomorph.Continuity | ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y]
(e : OpenPartialHomeomorph X Y) {x : X}, x ∈ e.source → ContinuousAt (↑e) x | An open partial homeomorphism is continuous at any point of its source | true |
AffineEquiv.symm._proof_1 | Mathlib.LinearAlgebra.AffineSpace.AffineEquiv | ∀ {k : Type u_4} {P₁ : Type u_3} {P₂ : Type u_1} {V₁ : Type u_5} {V₂ : Type u_2} [inst : Ring k]
[inst_1 : AddCommGroup V₁] [inst_2 : AddCommGroup V₂] [inst_3 : Module k V₁] [inst_4 : Module k V₂]
[inst_5 : AddTorsor V₁ P₁] [inst_6 : AddTorsor V₂ P₂] (e : P₁ ≃ᵃ[k] P₂) (p : P₂) (v : V₂),
v +ᵥ p = e.symm.symm (e.li... | null | false |
LinearIsometryEquiv.map_add | Mathlib.Analysis.Normed.Operator.LinearIsometry | ∀ {R : Type u_1} {R₂ : Type u_2} {E : Type u_4} {E₂ : Type u_5} [inst : Semiring R] [inst_1 : Semiring R₂]
{σ₁₂ : R →+* R₂} {σ₂₁ : R₂ →+* R} [inst_2 : RingHomInvPair σ₁₂ σ₂₁] [inst_3 : RingHomInvPair σ₂₁ σ₁₂]
[inst_4 : SeminormedAddCommGroup E] [inst_5 : SeminormedAddCommGroup E₂] [inst_6 : Module R E] [inst_7 : Mo... | null | true |
CategoryTheory.IsCardinalFiltered.max | Mathlib.CategoryTheory.Presentable.IsCardinalFiltered | {J : Type u} →
[inst : CategoryTheory.Category.{v, u} J] →
{κ : Cardinal.{w}} →
[hκ : Fact κ.IsRegular] →
[CategoryTheory.IsCardinalFiltered J κ] → {K : Type u'} → (K → J) → HasCardinalLT K κ → J | If `S : K → J` is a family of objects of cardinality `< κ` in a `κ`-filtered category,
this is a choice of objects in `J` which is the target of a map from any of
the objects `S k`. | true |
MulEquiv.toAdditive._proof_6 | Mathlib.Algebra.Group.Equiv.TypeTags | ∀ {G : Type u_1} {H : Type u_2} [inst : Mul G] [inst_1 : Mul H] (f : Additive G ≃+ Additive H),
Function.LeftInverse f.invFun f.toFun | null | false |
_private.Init.Data.List.MinMaxIdx.0.List.maxIdxOn_eq_iff._simp_1_2 | Init.Data.List.MinMaxIdx | ∀ {α : Type u_1} {lt : LT α} {a b : α}, (a < b) = (b < a) | null | false |
FirstOrder.instDecidableEqPresburgerFunc.decEq.match_1 | Mathlib.ModelTheory.Arithmetic.Presburger.Basic | (motive : (a : ℕ) → FirstOrder.presburgerFunc a → FirstOrder.presburgerFunc a → Sort u_1) →
(a : ℕ) →
(x x_1 : FirstOrder.presburgerFunc a) →
(Unit → motive 0 FirstOrder.presburgerFunc.zero FirstOrder.presburgerFunc.zero) →
(Unit → motive 0 FirstOrder.presburgerFunc.zero FirstOrder.presburgerFunc.on... | null | false |
Set.inclusion.congr_simp | Mathlib.Data.Set.Image | ∀ {α : Type u_1} {s t : Set α} (h : s ⊆ t) (a a_1 : ↑s), a = a_1 → Set.inclusion h a = Set.inclusion h a_1 | null | true |
Std.Legacy.Range.mk.noConfusion | Init.Data.Range.Basic | {P : Sort u} →
{start stop step : ℕ} →
{step_pos : 0 < step} →
{start' stop' step' : ℕ} →
{step_pos' : 0 < step'} →
[start:stop:step] = [start':stop':step'] → (start = start' → stop = stop' → step = step' → P) → P | null | false |
_private.Lean.Meta.Tactic.Grind.EMatch.0.Lean.Meta.Grind.EMatch.assignUnassignedLevelMVars | Lean.Meta.Tactic.Grind.EMatch | Array Lean.LMVarId → Lean.Expr → Lean.Expr → Lean.Meta.Grind.GoalM (Array (Lean.Expr × Lean.Expr)) | Helper function for E-match theorems containing universe metavariables that do not occur
in any of their parameters. This is a very rare case, but it does occur in practice.
Example:
```lean
@[simp, grind =] theorem down_pure {φ : Prop} : (⌜φ⌝ : SPred []).down = φ := rfl
```
The parameter `us` contains the unassigned ... | true |
Mathlib.Tactic.Linarith.SimplexAlgorithm.SparseMatrix.ctorIdx | Mathlib.Tactic.Linarith.Oracle.SimplexAlgorithm.Datatypes | {n m : ℕ} → Mathlib.Tactic.Linarith.SimplexAlgorithm.SparseMatrix n m → ℕ | null | false |
Int.fract_mul_natCast | Mathlib.Algebra.Order.Floor.Ring | ∀ {R : Type u_2} [inst : Ring R] [inst_1 : LinearOrder R] [inst_2 : FloorRing R] (a : R) (b : ℕ),
∃ z, Int.fract a * ↑b - Int.fract (a * ↑b) = ↑z | null | true |
MeasureTheory.OuterMeasure.ofFunction_apply | Mathlib.MeasureTheory.OuterMeasure.OfFunction | ∀ {α : Type u_1} (m : Set α → ENNReal) (m_empty : m ∅ = 0) (s : Set α),
(MeasureTheory.OuterMeasure.ofFunction m m_empty) s = ⨅ t, ⨅ (_ : s ⊆ Set.iUnion t), ∑' (n : ℕ), m (t n) | `ofFunction` of a set `s` is the infimum of `∑ᵢ, m (tᵢ)` for all collections of sets
`tᵢ` that cover `s`. | true |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.contains_of_contains_filter._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 |
_private.Mathlib.Topology.EMetricSpace.BoundedVariation.0.eVariationOn.eVariationOn_on_inter_Iic_eq_Iio_add_edist._proof_1_13 | Mathlib.Topology.EMetricSpace.BoundedVariation | ∀ {α : Type u_1} [inst : LinearOrder α] {s : Set α} {a : α},
a ∈ s →
∀ (n : ℕ) (u : ℕ → α),
(∀ i ∈ Set.Iic n, u i ∈ s ∩ Set.Iio a) →
∀ y ∈ s ∩ Set.Iio a, ∀ i ≤ n + 2, (fun i => if i ≤ n then u i else if i = n + 1 then y else a) i ∈ s ∩ Set.Iic a | null | false |
CoxeterMatrix.mk | Mathlib.GroupTheory.Coxeter.Matrix | {B : Type u_1} →
(M : Matrix B B ℕ) →
autoParam M.IsSymm CoxeterMatrix.isSymm._autoParam →
autoParam (∀ (i : B), M i i = 1) CoxeterMatrix.diagonal._autoParam →
autoParam (∀ (i i' : B), i ≠ i' → M i i' ≠ 1) CoxeterMatrix.off_diagonal._autoParam → CoxeterMatrix B | null | true |
ProbabilityTheory.gaussianReal_map_neg | Mathlib.Probability.Distributions.Gaussian.Real | ∀ {μ : ℝ} {v : NNReal},
MeasureTheory.Measure.map (fun x => -x) (ProbabilityTheory.gaussianReal μ v) = ProbabilityTheory.gaussianReal (-μ) v | null | true |
Mathlib.Linter.Style.setOption.isSetOption | Mathlib.Tactic.Linter.Style | Lean.Syntax → Bool | Whether a given piece of syntax is a `set_option` command, tactic or term. | true |
_private.Std.Data.DHashMap.RawLemmas.0.Std.DHashMap.Raw.size_erase._simp_1_1 | Std.Data.DHashMap.RawLemmas | ∀ {α : Type u} {β : α → Type v} [inst : BEq α] [inst_1 : Hashable α] {m : Std.DHashMap.Raw α β} {a : α},
(a ∈ m) = (m.contains a = true) | null | false |
Nat.instLocallyFiniteOrder._proof_7 | Mathlib.Order.Interval.Finset.Nat | ∀ (a b x : ℕ), x ∈ { val := ↑(List.range' (a + 1) (b - a)), nodup := ⋯ } ↔ a < x ∧ x ≤ b | null | false |
_private.Init.Grind.Ordered.Field.0.Lean.Grind.Field.IsOrdered.mul_inv_lt_of_mul_lt | Init.Grind.Ordered.Field | ∀ {R : Type u} [inst : Lean.Grind.Field R] [inst_1 : LE R] [inst_2 : LT R] [Std.LawfulOrderLT R]
[inst_4 : Std.IsLinearOrder R] [Lean.Grind.OrderedRing R] {a b c : R}, b < 0 → a * b < c → c * b⁻¹ < a | null | true |
Nat.support_factorization | Mathlib.Data.Nat.Factorization.Defs | ∀ (n : ℕ), n.factorization.support = n.primeFactors | The support of `n.factorization` is exactly `n.primeFactors`. | true |
CategoryTheory.Limits.isKernelCompMono._proof_5 | Mathlib.CategoryTheory.Limits.Shapes.Kernels | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{X Y : C} {f : X ⟶ Y} {c : CategoryTheory.Limits.KernelFork f} (i : CategoryTheory.Limits.IsLimit c) {Z : C}
(g : Y ⟶ Z) [hg : CategoryTheory.Mono g] {h : X ⟶ Z} (hh : h = CategoryTheory.CategoryStruct... | null | false |
Path.Homotopy.eval_apply | Mathlib.Topology.Homotopy.Path | ∀ {X : Type u} [inst : TopologicalSpace X] {x₀ x₁ : X} {p₀ p₁ : Path x₀ x₁} (F : p₀.Homotopy p₁) (t a : ↑unitInterval),
(F.eval t) a = (F.curry t) a | null | true |
_private.Lean.Environment.0.Lean.EnvExtension.modifyState.unsafe_impl_5 | Lean.Environment | {σ : Type} → Lean.EnvExtension σ → Lean.Environment → (σ → σ) → Array Lean.EnvExtensionState | null | true |
Lean.MonadWithOptions.rec | Lean.Data.Options | {m : Type → Type} →
{motive : Lean.MonadWithOptions m → Sort u} →
((withOptions : {α : Type} → (Lean.Options → Lean.Options) → m α → m α) → motive { withOptions := withOptions }) →
(t : Lean.MonadWithOptions m) → motive t | null | false |
Set.indicator_univ | Mathlib.Algebra.Notation.Indicator | ∀ {α : Type u_1} {M : Type u_3} [inst : Zero M] (f : α → M), Set.univ.indicator f = f | null | true |
Complex.instTopologicalSpaceUnitDisc._aux_1 | Mathlib.Analysis.Complex.UnitDisc.Basic | Set Complex.UnitDisc → Prop | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.