name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
USize.toUInt64 | Init.Data.UInt.Basic | USize → UInt64 | Converts word-sized unsigned integers to 32-bit unsigned integers. This cannot overflow because
`USize.size` is either `2^32` or `2^64`.
This function is overridden at runtime with an efficient implementation.
| true |
Vector.toArray_zipIdx | Init.Data.Vector.Lemmas | ∀ {α : Type u_1} {n : ℕ} {xs : Vector α n} (k : optParam ℕ 0), (xs.zipIdx k).toArray = xs.toArray.zipIdx k | null | true |
CategoryTheory.Functor.Final.colimitCoconeComp_isColimit | Mathlib.CategoryTheory.Limits.Final | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
(F : CategoryTheory.Functor C D) [inst_2 : F.Final] {E : Type u₃} [inst_3 : CategoryTheory.Category.{v₃, u₃} E]
{G : CategoryTheory.Functor D E} (t : CategoryTheory.Limits.ColimitCocone G),
(Cat... | null | true |
Topology.IsLowerSet.closure_singleton | Mathlib.Topology.Order.UpperLowerSetTopology | ∀ {α : Type u_1} [inst : Preorder α] [inst_1 : TopologicalSpace α] [Topology.IsLowerSet α] {a : α},
closure {a} = Set.Ici a | The closure of a singleton `{a}` in the lower set topology is the right-closed left-infinite
interval $(-∞,a]$.
| true |
List.prod_hom₂_nonempty | Mathlib.Algebra.BigOperators.Group.List.Basic | ∀ {ι : Type u_1} {M : Type u_4} {N : Type u_5} {P : Type u_6} [inst : Monoid M] [inst_1 : Monoid N] [inst_2 : Monoid P]
{l : List ι} (f : M → N → P),
(∀ (a b : M) (c d : N), f (a * b) (c * d) = f a c * f b d) →
∀ (f₁ : ι → M) (f₂ : ι → N),
l ≠ [] → (List.map (fun i => f (f₁ i) (f₂ i)) l).prod = f (List.ma... | null | true |
_private.Init.Meta.Defs.0.Lean.Syntax.structEq._sparseCasesOn_3 | Init.Meta.Defs | {motive_1 : Lean.Syntax → Sort u} →
(t : Lean.Syntax) →
((info : Lean.SourceInfo) → (val : String) → motive_1 (Lean.Syntax.atom info val)) →
(Nat.hasNotBit 4 t.ctorIdx → motive_1 t) → motive_1 t | null | false |
Vector3.nil | Mathlib.Data.Vector3 | {α : Type u_1} → Vector3 α 0 | The empty vector | true |
Mathlib.Meta.Positivity.evalInv | Mathlib.Algebra.Order.Field.Basic | Mathlib.Meta.Positivity.PositivityExt | The `positivity` extension which identifies expressions of the form `a⁻¹`,
such that `positivity` successfully recognises `a`. | true |
AddSubgroup.toAddSubmonoid | Mathlib.Algebra.Group.Subgroup.Defs | {G : Type u_3} → [inst : AddGroup G] → AddSubgroup G → AddSubmonoid G | Reinterpret an `AddSubgroup` as an `AddSubmonoid`. | true |
_private.Lean.Elab.MutualInductive.0.Lean.Elab.Command.AccLevelState.mk.sizeOf_spec | Lean.Elab.MutualInductive | ∀ (levels : Lean.LevelMap ℤ), sizeOf { levels := levels } = 1 + sizeOf levels | null | true |
Plausible.PNat.sampleableExt | Mathlib.Testing.Plausible.Sampleable | Plausible.SampleableExt ℕ+ | null | true |
Std.ExtTreeSet.min!_insert_le_self | Std.Data.ExtTreeSet.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t : Std.ExtTreeSet α cmp} [inst : Std.TransCmp cmp] [inst_1 : Inhabited α]
{k : α}, (cmp (t.insert k).min! k).isLE = true | null | true |
NNReal.strictMono_rpow_of_pos | Mathlib.Analysis.SpecialFunctions.Pow.NNReal | ∀ {z : ℝ}, 0 < z → StrictMono fun x => x ^ z | null | true |
_private.Mathlib.Data.Ordmap.Ordnode.0.BinaryTree.toOrdNode.match_1.eq_2 | Mathlib.Data.Ordmap.Ordnode | ∀ {α : Type u_1} (motive : BinaryTree α → Sort u_2) (x : α) (l r : BinaryTree α) (h_1 : Unit → motive BinaryTree.nil)
(h_2 : (x : α) → (l r : BinaryTree α) → motive (BinaryTree.node x l r)),
(match BinaryTree.node x l r with
| BinaryTree.nil => h_1 ()
| BinaryTree.node x l r => h_2 x l r) =
h_2 x l r | null | true |
IsDedekindDomain.selmerGroup.valuation | Mathlib.RingTheory.DedekindDomain.SelmerGroup | {R : Type u} →
[inst : CommRing R] →
[inst_1 : IsDedekindDomain R] →
{K : Type v} →
[inst_2 : Field K] →
[inst_3 : Algebra R K] →
[inst_4 : IsFractionRing R K] →
{S : Set (IsDedekindDomain.HeightOneSpectrum R)} →
{n : ℕ} → ↥IsDedekindDomain.selmerG... | The multiplicative `v`-adic valuations on `K⟮S, n⟯` for all `v ∈ S`. | true |
ProofWidgets.Jsx.getJsxText | ProofWidgets.Data.Html | Lean.TSyntax `ProofWidgets.Jsx.jsxText → String | null | true |
_private.Batteries.Data.Array.Lemmas.0.Array.extract_append_of_stop_le_size_left._proof_1_2 | Batteries.Data.Array.Lemmas | ∀ {α : Type u_1} {j i : ℕ} {a : Array α} (i_1 : ℕ), i_1 + 1 ≤ (a.extract i j).size → i_1 < (a.extract i j).size | null | false |
CategoryTheory.Pseudofunctor.DescentData.pullFunctorObjHom_eq._proof_20 | Mathlib.CategoryTheory.Sites.Descent.DescentData | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {ι : Type u_4} {S : C} {X : ι → C} {S' : C} {p : S' ⟶ S}
{ι' : Type u_3} {X' : ι' → C} {f' : (j : ι') → X' j ⟶ S'} {α : ι' → ι} {p' : (j : ι') → X' j ⟶ X (α j)} ⦃Y : C⦄
(q : Y ⟶ S') ⦃j₁ j₂ : ι'⦄ (f₁ : Y ⟶ X' j₁) (f₂ : Y ⟶ X' j₂) (q' : Y ⟶ S) (f₂' : Y ⟶ ... | null | false |
_private.Mathlib.Tactic.Observe.0.Mathlib.Tactic.LibrarySearch._aux_Mathlib_Tactic_Observe___elabRules_Mathlib_Tactic_LibrarySearch_observe_1.match_7 | Mathlib.Tactic.Observe | (motive : Option (Array (List Lean.MVarId × Lean.MetavarContext)) → Sort u_1) →
(__do_lift : Option (Array (List Lean.MVarId × Lean.MetavarContext))) →
((val : Array (List Lean.MVarId × Lean.MetavarContext)) → motive (some val)) →
((x : Option (Array (List Lean.MVarId × Lean.MetavarContext))) → motive x) → ... | null | false |
CochainComplex.shiftShortComplexFunctorIso_add'_hom_app._proof_1 | Mathlib.Algebra.Homology.HomotopyCategory.ShiftSequence | ∀ (n m mn : ℤ), m + n = mn → ∀ (a a' a'' : ℤ), n + a = a' → m + a' = a'' → mn + a = a'' | null | false |
Function.Even.left_comp | Mathlib.Algebra.Group.EvenFunction | ∀ {α : Type u_1} {β : Type u_2} [inst : Neg α] {γ : Type u_3} {g : α → β},
Function.Even g → ∀ (f : β → γ), Function.Even (f ∘ g) | If `f` is arbitrary and `g` is even, then `f ∘ g` is even. | true |
Tactic.ComputeAsymptotics.MultiseriesExpansion.ms_eq_mk_iff | Mathlib.Tactic.ComputeAsymptotics.Multiseries.Defs | ∀ {basis_hd : ℝ → ℝ} {basis_tl : List (ℝ → ℝ)}
(ms : Tactic.ComputeAsymptotics.MultiseriesExpansion (basis_hd :: basis_tl))
(s : Tactic.ComputeAsymptotics.MultiseriesExpansion.Multiseries basis_hd basis_tl) (f : ℝ → ℝ),
ms = Tactic.ComputeAsymptotics.MultiseriesExpansion.mk s f ↔ ms.seq = s ∧ ms.toFun = f | null | true |
_private.Mathlib.Analysis.Complex.AbelLimit.0.Complex.tendsto_tsum_powerSeries_nhdsWithin_stolzSet._simp_1_4 | Mathlib.Analysis.Complex.AbelLimit | ∀ {α : Type u} {β : Type v} [inst : PseudoMetricSpace α] [Nonempty β] [inst_2 : SemilatticeSup β] {u : β → α} {a : α},
Filter.Tendsto u Filter.atTop (nhds a) = ∀ ε > 0, ∃ N, ∀ n ≥ N, dist (u n) a < ε | null | false |
Lean.JsonRpc.MessageMetaData._sizeOf_inst | Lean.Data.JsonRpc | SizeOf Lean.JsonRpc.MessageMetaData | null | false |
ProofWidgets.RpcEncodablePacket.component.injEq._@.ProofWidgets.Data.Html.2686543190._hygCtx._hyg.1 | ProofWidgets.Data.Html | ∀ (a a_1 a_2 a_3 a_4 a_5 a_6 a_7 : Lean.Json),
(ProofWidgets.RpcEncodablePacket.component✝ a a_1 a_2 a_3 =
ProofWidgets.RpcEncodablePacket.component✝ a_4 a_5 a_6 a_7) =
(a = a_4 ∧ a_1 = a_5 ∧ a_2 = a_6 ∧ a_3 = a_7) | null | false |
_private.Mathlib.GroupTheory.GroupAction.Basic.0.MulAction.fixedPoints_of_subsingleton._simp_1_1 | Mathlib.GroupTheory.GroupAction.Basic | ∀ {M : Type u_1} {α : Type u_3} [inst : Monoid M] [inst_1 : MulAction M α] {a : α},
(a ∈ MulAction.fixedPoints M α) = ∀ (m : M), m • a = a | null | false |
CategoryTheory.Limits.CatCospanTransform.mkIso_hom_left | Mathlib.CategoryTheory.Limits.Shapes.Pullback.Categorical.CatCospanTransform | ∀ {A : Type u₁} {B : Type u₂} {C : Type u₃} {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}
[inst_3 : CategoryTheor... | null | true |
Lean.Meta.SizeOfSpecNested.Context.mk.noConfusion | Lean.Meta.SizeOf | {P : Sort u} →
{indInfo : Lean.InductiveVal} →
{sizeOfFns : Array Lean.Name} →
{ctorName : Lean.Name} →
{params localInsts : Array Lean.Expr} →
{recMap : Lean.NameMap Lean.Name} →
{indInfo' : Lean.InductiveVal} →
{sizeOfFns' : Array Lean.Name} →
{c... | null | false |
SeparationQuotient.lift'_mk | Mathlib.Topology.UniformSpace.Separation | ∀ {α : Type u} {β : Type v} [inst : UniformSpace α] [inst_1 : UniformSpace β] [inst_2 : T0Space β] {f : α → β},
UniformContinuous f → ∀ (a : α), SeparationQuotient.lift' f (SeparationQuotient.mk a) = f a | null | true |
_private.Batteries.Recycling.RBTree.WF.0.RBTree.RBNode.setRed.match_1.eq_1 | Batteries.Recycling.RBTree.WF | ∀ {α : Type u_1} (motive : RBTree.RBNode α → Sort u_2) (c : RBTree.RBColor) (a : RBTree.RBNode α) (v : α)
(b : RBTree.RBNode α)
(h_1 :
(c : RBTree.RBColor) →
(a : RBTree.RBNode α) → (v : α) → (b : RBTree.RBNode α) → motive (RBTree.RBNode.node c a v b))
(h_2 : Unit → motive RBTree.RBNode.nil),
(match R... | null | true |
ClosedAddSubgroup.instCoeAddSubgroup | Mathlib.Topology.Algebra.Group.ClosedSubgroup | (G : Type u) → [inst : AddGroup G] → [inst_1 : TopologicalSpace G] → Coe (ClosedAddSubgroup G) (AddSubgroup G) | null | true |
CategoryTheory.FunctorToTypes.monoFactorisation_e | Mathlib.CategoryTheory.Limits.FunctorCategory.Shapes.Images | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {F G : CategoryTheory.Functor C (Type u)} (f : F ⟶ G),
(CategoryTheory.FunctorToTypes.monoFactorisation f).e = CategoryTheory.Subfunctor.toRange f | null | true |
Std.HashMap.Raw.all_eq_false_iff_exists_mem_getElem | Std.Data.HashMap.RawLemmas | ∀ {α : Type u} {β : Type v} {m : Std.HashMap.Raw α β} [inst : BEq α] [inst_1 : Hashable α] [LawfulBEq α]
{p : α → β → Bool}, m.WF → (m.all p = false ↔ ∃ a, ∃ (h : a ∈ m), p a m[a] = false) | null | true |
Array.partition | Init.Data.Array.Basic | {α : Type u} → (α → Bool) → Array α → Array α × Array α | Returns a pair of arrays that together contain all the elements of `as`. The first array contains
those elements for which `p` returns `true`, and the second contains those for which `p` returns
`false`.
`as.partition p` is equivalent to `(as.filter p, as.filter (not ∘ p))`, but it is
more efficient since it only has ... | true |
CategoryTheory.Lax.LaxTrans.homCategory._proof_6 | Mathlib.CategoryTheory.Bicategory.Modification.Lax | ∀ {B : Type u_1} [inst : CategoryTheory.Bicategory B] {C : Type u_5} [inst_1 : CategoryTheory.Bicategory C]
{F G : CategoryTheory.LaxFunctor B C} {W X Y Z : F ⟶ G} (f : CategoryTheory.Lax.LaxTrans.Hom W X)
(g : CategoryTheory.Lax.LaxTrans.Hom X Y) (h : CategoryTheory.Lax.LaxTrans.Hom Y Z),
{ as := { as := f.as.vc... | null | false |
isAddRightRegular_ofColex | Mathlib.Algebra.Order.Group.Synonym | ∀ {α : Type u_1} [inst : AddMonoid α] {a : Colex α}, IsAddRightRegular (ofColex a) ↔ IsAddRightRegular a | null | true |
_private.Mathlib.RingTheory.Ideal.Quotient.PowTransition.0.Submodule.powSMulQuotInclusion_injective._simp_1_3 | Mathlib.RingTheory.Ideal.Quotient.PowTransition | ∀ {R : Type u_1} {R₂ : Type u_2} {M : Type u_4} {M₂ : Type u_5} [inst : Semiring R] [inst_1 : Semiring R₂]
[inst_2 : AddCommMonoid M] [inst_3 : AddCommMonoid M₂] [inst_4 : Module R M] [inst_5 : Module R₂ M₂] {σ₁₂ : R →+* R₂}
[inst_6 : RingHomSurjective σ₁₂] {f : M →ₛₗ[σ₁₂] M₂} {p : Submodule R M} {q : Submodule R₂ ... | null | false |
_private.Mathlib.NumberTheory.ModularForms.EisensteinSeries.Summable.0.EisensteinSeries.r_pos._simp_1_3 | Mathlib.NumberTheory.ModularForms.EisensteinSeries.Summable | ∀ (z : UpperHalfPlane), (0 < z.im) = True | null | false |
_private.Mathlib.NumberTheory.ArithmeticFunction.Defs.0.ArithmeticFunction.IsMultiplicative.mul._simp_1_3 | Mathlib.NumberTheory.ArithmeticFunction.Defs | ∀ {n : ℕ} {x : ℕ × ℕ}, (x ∈ n.divisorsAntidiagonal) = (x.1 * x.2 = n ∧ n ≠ 0) | null | false |
Std.Http.Body.instToByteArrayString | Std.Http.Data.Body.Basic | Std.Http.Body.ToByteArray String | null | true |
CategoryTheory.Endofunctor.Algebra.functorOfNatTrans | Mathlib.CategoryTheory.Endofunctor.Algebra | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{F G : CategoryTheory.Functor C C} →
(G ⟶ F) → CategoryTheory.Functor (CategoryTheory.Endofunctor.Algebra F) (CategoryTheory.Endofunctor.Algebra G) | From a natural transformation `α : G → F` we get a functor from
algebras of `F` to algebras of `G`.
| true |
_private.Lake.Util.Version.0.Lake.StdVer.compare.match_3 | Lake.Util.Version | (motive : Ordering → Sort u_1) →
(x : Ordering) → (Unit → motive Ordering.eq) → ((ord : Ordering) → motive ord) → motive x | null | false |
exists_continuous_add_one_of_isCompact_nnreal | Mathlib.MeasureTheory.Integral.RieszMarkovKakutani.Basic | ∀ {X : Type u_1} [inst : TopologicalSpace X] [T2Space X] [LocallyCompactSpace X] {s₀ s₁ t : Set X},
IsCompact s₀ →
IsCompact s₁ →
IsCompact t →
Disjoint s₀ s₁ → s₀ ∪ s₁ ⊆ t → ∃ f₀ f₁, Set.EqOn (⇑f₀) 1 s₀ ∧ Set.EqOn (⇑f₁) 1 s₁ ∧ Set.EqOn (⇑(f₀ + f₁)) 1 t | null | true |
Std.Tactic.BVDecide.BVExpr.bitblast.AppendTarget.noConfusionType | Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Append | Sort u →
{α : Type} →
[inst : Hashable α] →
[inst_1 : DecidableEq α] →
{aig : Std.Sat.AIG α} →
{combined : ℕ} →
Std.Tactic.BVDecide.BVExpr.bitblast.AppendTarget aig combined →
{α' : Type} →
[inst' : Hashable α'] →
[inst'_1 : Decid... | null | false |
Lie.Derivation.ofLieDerivation | Mathlib.Algebra.Lie.Derivation.BaseChange | {R : Type u_1} →
[inst : CommRing R] →
(A : Type u_2) →
[inst_1 : CommRing A] →
[inst_2 : Algebra R A] →
{L : Type u_3} →
[inst_3 : LieRing L] →
[inst_4 : LieAlgebra R L] →
LieDerivation R L L →ₗ⁅R⁆ LieDerivation R (TensorProduct R A L) (TensorProd... | A Lie derivation of an `R-`Lie algebra `L`, induces a Lie derivation of `A ⊗[R] L` for any
Algebra `A` over `R`. | true |
AddGroupNorm.casesOn | Mathlib.Analysis.Normed.Group.Seminorm | {G : Type u_6} →
[inst : AddGroup G] →
{motive : AddGroupNorm G → Sort u} →
(t : AddGroupNorm G) →
((toAddGroupSeminorm : AddGroupSeminorm G) →
(eq_zero_of_map_eq_zero' : ∀ (x : G), toAddGroupSeminorm.toFun x = 0 → x = 0) →
motive { toAddGroupSeminorm := toAddGroupSeminorm,... | null | false |
Std.DTreeMap.Internal.Impl.glue.eq_3 | Std.Data.DTreeMap.Internal.Operations | ∀ {α : Type u} {β : α → Type v} (size : ℕ) (k' : α) (v' : β k') (l' r' : Std.DTreeMap.Internal.Impl α β)
(hl_2 : (Std.DTreeMap.Internal.Impl.inner size k' v' l' r').Balanced) (sz' : ℕ) (k'_1 : α) (v'_1 : β k'_1)
(l'' r'' : Std.DTreeMap.Internal.Impl α β) (hr_2 : (Std.DTreeMap.Internal.Impl.inner sz' k'_1 v'_1 l'' r... | null | true |
OpenPartialHomeomorph.IsImage.restr._proof_3 | Mathlib.Topology.OpenPartialHomeomorph.IsImage | ∀ {X : Type u_2} {Y : Type u_1} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y]
{e : OpenPartialHomeomorph X Y} {s : Set X} {t : Set Y}, e.IsImage s t → IsOpen (e.source ∩ s) → IsOpen (e.target ∩ t) | null | false |
_private.Mathlib.MeasureTheory.Measure.Stieltjes.0.StieltjesFunction.outer_trim._simp_1_1 | Mathlib.MeasureTheory.Measure.Stieltjes | ∀ {α : Type u_1} {ι : Sort u_3} [inst : CompleteLinearOrder α] {a : α} {f : ι → α}, (iInf f < a) = ∃ i, f i < a | null | false |
Lean.Lsp.instToJsonDiagnosticSeverity.match_1 | Lean.Data.Lsp.Diagnostics | (motive : Lean.Lsp.DiagnosticSeverity → Sort u_1) →
(x : Lean.Lsp.DiagnosticSeverity) →
(Unit → motive Lean.Lsp.DiagnosticSeverity.error) →
(Unit → motive Lean.Lsp.DiagnosticSeverity.warning) →
(Unit → motive Lean.Lsp.DiagnosticSeverity.information) →
(Unit → motive Lean.Lsp.DiagnosticSeve... | null | false |
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 |
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 |
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.Omega.LinearCombo.coordinate_eval | Init.Omega.LinearCombo | ∀ (i : ℕ) (v : Lean.Omega.Coeffs), (Lean.Omega.LinearCombo.coordinate i).eval v = v.get i | 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) (a b : ↥s), ‖a * b‖ ≤ ‖a‖ * ‖b‖ | null | false |
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) → Prop) (x : Decidable (c.val = d.val)),
(∀ (h : c.val = d.val), motive { decide := true, reflects_decide := h }) →
(∀ (h : ¬c.val = d.val), motive { decide := false, reflects_decide := h }) → motive x | null | false |
Filter.EventuallyEqSet.eq_1 | Mathlib.Order.Filter.Basic | ∀ {α : Type u_1} (l : Filter α) (s t : Set α), (s =ᶠ[l] t) = ((fun x => x ∈ s) =ᶠ[l] fun x => x ∈ t) | null | true |
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 |
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 |
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 |
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 |
_private.Lean.Meta.Tactic.Simp.BuiltinSimprocs.Char.0.Char.reduceBNe._regBuiltin.Char.reduceBNe.declare_1._@.Lean.Meta.Tactic.Simp.BuiltinSimprocs.Char.83380857._hygCtx._hyg.31 | Lean.Meta.Tactic.Simp.BuiltinSimprocs.Char | IO Unit | 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 |
_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 |
Array.instDecidableExistsAndMemOfDecidablePred | Init.Data.Array.Lemmas | {α : Type u_1} → {xs : Array α} → {p : α → Prop} → [DecidablePred p] → Decidable (∃ x ∈ xs, p x) | null | true |
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 |
Associates.coe_unit_eq_one | Mathlib.Algebra.GroupWithZero.Associated | ∀ {M : Type u_1} [inst : CommMonoid M] (u : (Associates M)ˣ), ↑u = 1 | 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 |
LowerSet.iicInfHom_apply | Mathlib.Order.UpperLower.Hom | ∀ {α : Type u_1} [inst : SemilatticeInf α] (a : α), LowerSet.iicInfHom a = LowerSet.Iic a | null | true |
Lean.Compiler.LCNF.TrivialStructureInfo.casesOn | Lean.Compiler.LCNF.Irrelevant | {motive : Lean.Compiler.LCNF.TrivialStructureInfo → Sort u} →
(t : Lean.Compiler.LCNF.TrivialStructureInfo) →
((ctorName : Lean.Name) →
(numParams fieldIdx : ℕ) → motive { ctorName := ctorName, numParams := numParams, fieldIdx := fieldIdx }) →
motive t | 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 |
PiTensorProduct.lifts.eq_1 | Mathlib.LinearAlgebra.PiTensorProduct.Basic | ∀ {ι : 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.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 |
_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 |
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 |
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 |
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 |
_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 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.