name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
Multiset.cons_lt_cons_iff._simp_1 | Mathlib.Data.Multiset.ZeroCons | ∀ {α : Type u_1} {s t : Multiset α} {a : α}, (a ::ₘ s < a ::ₘ t) = (s < t) | null | false |
SemilatInfCat.hasForgetToPartOrd._proof_2 | Mathlib.Order.Category.Semilat | ∀ {X Y Z : SemilatInfCat} (f : X ⟶ Y) (g : Y ⟶ Z),
PartOrd.ofHom { toFun := ⇑(CategoryTheory.CategoryStruct.comp f g).toInfHom, monotone' := ⋯ } =
CategoryTheory.CategoryStruct.comp (PartOrd.ofHom { toFun := ⇑f.toInfHom, monotone' := ⋯ })
(PartOrd.ofHom { toFun := ⇑g.toInfHom, monotone' := ⋯ }) | null | false |
CommMonCat.coyonedaType._proof_4 | Mathlib.Algebra.Category.MonCat.Yoneda | ∀ (X : Type u_1ᵒᵖ),
{
app := fun N =>
CommMonCat.ofHom
(MonoidHom.pi fun i =>
Pi.evalMonoidHom (fun a => ↑N)
((CategoryTheory.ConcreteCategory.hom (CategoryTheory.CategoryStruct.id X).unop) i)),
naturality := ⋯ } =
CategoryTheory.CategoryStruct.id
{ ob... | null | false |
Subgroup._sizeOf_inst | Mathlib.Algebra.Group.Subgroup.Defs | (G : Type u_3) → {inst : Group G} → [SizeOf G] → SizeOf (Subgroup G) | null | false |
_private.Mathlib.Analysis.Calculus.FDeriv.Measurable.0.FDerivMeasurableAux.isOpen_A_with_param._simp_1_3 | Mathlib.Analysis.Calculus.FDeriv.Measurable | ∀ {α : Type u} [inst : PseudoMetricSpace α] {x y : α} {ε : ℝ}, (y ∈ Metric.ball x ε) = (dist y x < ε) | null | false |
_private.Mathlib.Algebra.Polynomial.RuleOfSigns.0.Polynomial.succ_signVariations_le_X_sub_C_mul._proof_1_8 | Mathlib.Algebra.Polynomial.RuleOfSigns | ∀ {R : Type u_1} [inst : Ring R] [inst_1 : LinearOrder R] {η : R} {P : Polynomial R} (d : ℕ),
(∀ m < d + 1,
∀ {P : Polynomial R},
P ≠ 0 → P.natDegree = m → P.signVariations + 1 ≤ ((Polynomial.X - Polynomial.C η) * P).signVariations) →
P.eraseLead.natDegree < d + 1 →
¬P.eraseLead = 0 →
... | null | false |
Ordinal.cof_le_card | Mathlib.SetTheory.Cardinal.Cofinality.Ordinal | ∀ (o : Ordinal.{u_1}), o.cof ≤ o.card | null | true |
instIsMonHomOppositeCommAlgCatOpOfHomToAlgHom | Mathlib.Algebra.Category.CommBialgCat | ∀ {R : Type u} [inst : CommRing R] {A B : Type u} [inst_1 : CommRing A] [inst_2 : Bialgebra R A] [inst_3 : CommRing B]
[inst_4 : Bialgebra R B] (f : A →ₐc[R] B), CategoryTheory.IsMonHom (CommAlgCat.ofHom ↑f).op | null | true |
BitVec.clzAuxRec_eq_clzAuxRec_of_le | Init.Data.BitVec.Lemmas | ∀ {w n : ℕ} {x : BitVec w}, w - 1 ≤ n → x.clzAuxRec n = x.clzAuxRec (w - 1) | null | true |
ModuleCat.rec | Mathlib.Algebra.Category.ModuleCat.Basic | {R : Type u} →
[inst : Ring R] →
{motive : ModuleCat R → Sort u_1} →
((carrier : Type v) →
[isAddCommGroup : AddCommGroup carrier] →
[isModule : Module R carrier] →
motive { carrier := carrier, isAddCommGroup := isAddCommGroup, isModule := isModule }) →
(t : Modul... | null | false |
Filter.tendsto_atTop_pure | Mathlib.Order.Filter.AtTopBot.Tendsto | ∀ {α : Type u_3} {β : Type u_4} [inst : PartialOrder α] [inst_1 : OrderTop α] (f : α → β),
Filter.Tendsto f Filter.atTop (pure (f ⊤)) | null | true |
Lean.Meta.Match.Example.var | Lean.Meta.Match.Basic | Lean.FVarId → Lean.Meta.Match.Example | null | true |
GradedTensorProduct.lift._proof_3 | Mathlib.LinearAlgebra.TensorProduct.Graded.Internal | ∀ {R : Type u_1} [inst : CommRing R] {C : Type u_2} [inst_1 : Ring C] [inst_2 : Algebra R C], SMulCommClass R C C | null | false |
Hamming.instAddMonoid._proof_4 | Mathlib.InformationTheory.Hamming | ∀ {ι : Type u_1} {β : ι → Type u_2} [inst : (i : ι) → AddMonoid (β i)],
autoParam (∀ (x : Hamming β), 0 • x = 0) AddMonoid.nsmul_zero._autoParam | null | false |
Lean.Meta.DSimp.Config.decide | Init.MetaTypes | Lean.Meta.DSimp.Config → Bool | When `true` (default: `false`), rewrites a proposition `p` to `True` or `False` by inferring
a `Decidable p` instance and reducing it.
| true |
hasProd_unique._simp_2 | Mathlib.Topology.Algebra.InfiniteSum.Basic | ∀ {α : Type u_1} {β : Type u_2} [inst : CommMonoid α] [inst_1 : TopologicalSpace α] [inst_2 : Unique β] (f : β → α)
(L : optParam (SummationFilter β) (SummationFilter.unconditional β)) [L.LeAtTop], HasProd f (f default) L = True | null | false |
Bundle.Trivialization.prod.eq_1 | Mathlib.Topology.VectorBundle.Constructions | ∀ {B : Type u_1} [inst : TopologicalSpace B] {F₁ : Type u_2} [inst_1 : TopologicalSpace F₁] {E₁ : B → Type u_3}
[inst_2 : TopologicalSpace (Bundle.TotalSpace F₁ E₁)] {F₂ : Type u_4} [inst_3 : TopologicalSpace F₂]
{E₂ : B → Type u_5} [inst_4 : TopologicalSpace (Bundle.TotalSpace F₂ E₂)]
(e₁ : Bundle.Trivialization... | null | true |
CategoryTheory.Comma.mapLeftComp_hom_app_right | Mathlib.CategoryTheory.Comma.Basic | ∀ {A : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} A] {B : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} B]
{T : Type u₃} [inst_2 : CategoryTheory.Category.{v₃, u₃} T] (R : CategoryTheory.Functor B T)
{L₁ L₂ L₃ : CategoryTheory.Functor A T} (l : L₁ ⟶ L₂) (l' : L₂ ⟶ L₃) (X : CategoryTheory.Comma L₃ R),
... | null | true |
HNNExtension.NormalWord.instMulAction | Mathlib.GroupTheory.HNNExtension | {G : Type u_1} →
[inst : Group G] →
{A B : Subgroup G} → {d : HNNExtension.NormalWord.TransversalPair G A B} → MulAction G (HNNExtension.NormalWord d) | null | true |
CategoryTheory.Limits.reflexivePair.diagramIsoReflexivePair_hom_app | Mathlib.CategoryTheory.Limits.Shapes.Reflexive | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C]
(F : CategoryTheory.Functor CategoryTheory.Limits.WalkingReflexivePair C)
(x : CategoryTheory.Limits.WalkingReflexivePair),
(CategoryTheory.Limits.reflexivePair.diagramIsoReflexivePair F).hom.app x =
match x with
| CategoryTheory.Limits.WalkingRefle... | null | true |
Topology.IsEmbedding.prodMap | Mathlib.Topology.Constructions.SumProd | ∀ {X : Type u} {Y : Type v} {W : Type u_1} {Z : Type u_2} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y]
[inst_2 : TopologicalSpace Z] [inst_3 : TopologicalSpace W] {f : X → Y} {g : Z → W},
Topology.IsEmbedding f → Topology.IsEmbedding g → Topology.IsEmbedding (Prod.map f g) | null | true |
Std.DTreeMap.Internal.Impl.maxEntry?.match_1 | Std.Data.DTreeMap.Internal.Queries | {α : Type u_1} →
{β : α → Type u_2} →
(motive : Std.DTreeMap.Internal.Impl α β → Sort u_3) →
(x : Std.DTreeMap.Internal.Impl α β) →
(Unit → motive Std.DTreeMap.Internal.Impl.leaf) →
((size : ℕ) →
(k : α) →
(v : β k) →
(l : Std.DTreeMap.Intern... | null | false |
HasFDerivWithinAt.const_sub | Mathlib.Analysis.Calculus.FDeriv.Add | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {F : Type u_3} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {f : E → F}
{f' : E →L[𝕜] F} {x : E} {s : Set E},
HasFDerivWithinAt f f' s x → ∀ (c : F), HasFDerivWithinAt (... | null | true |
Std.DHashMap.Raw.Equiv.size_eq | Std.Data.DHashMap.RawLemmas | ∀ {α : Type u} {β : α → Type v} [inst : BEq α] [inst_1 : Hashable α] {m₁ m₂ : Std.DHashMap.Raw α β} [EquivBEq α]
[LawfulHashable α], m₁.WF → m₂.WF → m₁.Equiv m₂ → m₁.size = m₂.size | null | true |
CoxeterSystem.mk.noConfusion | Mathlib.GroupTheory.Coxeter.Basic | {B : Type u_1} →
{M : CoxeterMatrix B} →
{W : Type u_2} →
{inst : Group W} →
{P : Sort u} →
{mulEquiv mulEquiv' : W ≃* M.Group} →
{ mulEquiv := mulEquiv } = { mulEquiv := mulEquiv' } → (mulEquiv ≍ mulEquiv' → P) → P | null | false |
Submonoid.isScalarTower | Mathlib.Algebra.Group.Submonoid.MulAction | ∀ {M' : Type u_1} {α : Type u_2} {β : Type u_3} [inst : MulOneClass M'] [inst_1 : SMul α β] [inst_2 : SMul M' α]
[inst_3 : SMul M' β] [IsScalarTower M' α β] (S : Submonoid M'), IsScalarTower (↥S) α β | Note that this provides `IsScalarTower S M' M'` which is needed by `SMulMulAssoc`. | true |
_private.Lean.Meta.Tactic.Simp.BuiltinSimprocs.BitVec.0.BitVec.instDecidableEqLiteral.decEq._proof_3 | Lean.Meta.Tactic.Simp.BuiltinSimprocs.BitVec | ∀ (a : ℕ) (a_1 : BitVec a) (b : ℕ) (b_1 : BitVec b),
¬a = b → { n := a, value := a_1 } = { n := b, value := b_1 } → False | null | false |
Lean.Lsp.DeleteFile.Options.ignoreIfNotExists | Lean.Data.Lsp.Basic | Lean.Lsp.DeleteFile.Options → Bool | null | true |
Lean.LLVM.CodegenFileType.val | Lean.Compiler.IR.LLVMBindings | Lean.LLVM.CodegenFileType → UInt64 | null | true |
LieAlgebra.IsEngelian._proof_2 | Mathlib.Algebra.Lie.Engel | ∀ (R : Type u_1) [inst : CommRing R] (M : Type u_2) [inst_1 : AddCommGroup M] [inst_2 : Module R M], IsScalarTower R R M | null | false |
Rat.mk'_pow._proof_2 | Mathlib.Data.Rat.Defs | ∀ (den : ℕ), den ≠ 0 → ∀ (n : ℕ), den ^ n ≠ 0 | null | false |
_private.Mathlib.Algebra.Lie.OfAssociative.0.termφ | Mathlib.Algebra.Lie.OfAssociative | Lean.ParserDescr | null | true |
Mathlib.Tactic.Conv.Path.rec | Mathlib.Tactic.Widget.Conv | {motive : Mathlib.Tactic.Conv.Path → Sort u} →
((arg : ℕ) →
(all : Bool) →
(next : Mathlib.Tactic.Conv.Path) → motive next → motive (Mathlib.Tactic.Conv.Path.arg arg all next)) →
((depth : ℕ) → motive (Mathlib.Tactic.Conv.Path.fun depth)) →
((next : Mathlib.Tactic.Conv.Path) → motive next → mo... | null | false |
_private.Mathlib.Analysis.Normed.Group.InfiniteSum.0.tsum_enorm_ne_top_iff_summable_norm._simp_1_2 | Mathlib.Analysis.Normed.Group.InfiniteSum | ∀ {E : Type u_4} [inst : SeminormedAddGroup E] (a : E), ‖a‖ = ↑‖a‖₊ | null | false |
List.pmap.eq_1 | Init.Data.List.Attach | ∀ {α : Type u_1} {β : Type u_2} {P : α → Prop} (f : (a : α) → P a → β) (x_2 : ∀ a ∈ [], P a), List.pmap f [] x_2 = [] | null | true |
Int64.instLawfulOrderOrd | Init.Data.Ord.SInt | Std.LawfulOrderOrd Int64 | null | true |
EuclideanGeometry.Sphere.orthRadius_eq_orthRadius_iff._simp_1 | 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 q : P}, (s.orthRadius p = s.orthRadius q) = (p = q) | null | false |
Lean.Meta.SizeOfSpecNested.Context.recOn | Lean.Meta.SizeOf | {motive : Lean.Meta.SizeOfSpecNested.Context → Sort u} →
(t : Lean.Meta.SizeOfSpecNested.Context) →
((indInfo : Lean.InductiveVal) →
(sizeOfFns : Array Lean.Name) →
(ctorName : Lean.Name) →
(params localInsts : Array Lean.Expr) →
(recMap : Lean.NameMap Lean.Name) →
... | null | false |
_private.Init.Data.String.Lemmas.Basic.0.String.Slice.Pos.nextn.match_1.eq_1 | Init.Data.String.Lemmas.Basic | ∀ (motive : ℕ → Sort u_1) (h_1 : Unit → motive 0) (h_2 : (n : ℕ) → motive n.succ),
(match 0 with
| 0 => h_1 ()
| n.succ => h_2 n) =
h_1 () | null | true |
Pi.algebraMap._proof_2 | Mathlib.Algebra.Algebra.Pi | ∀ (ι : Type u_1) (R : Type u_3) (A : Type u_2) [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A]
(t : R) (v : ι → R), ⇑(algebraMap R A) ∘ (t • v) = (RingHom.id R) t • ⇑(algebraMap R A) ∘ v | null | false |
Lean.Grind.CommRing.Poly.denote_insert | Init.Grind.Ring.CommSolver | ∀ {α : Type u_1} [inst : Lean.Grind.Ring α] (ctx : Lean.Grind.CommRing.Context α) (k : ℤ) (m : Lean.Grind.CommRing.Mon)
(p : Lean.Grind.CommRing.Poly),
Lean.Grind.CommRing.Poly.denote ctx (Lean.Grind.CommRing.Poly.insert k m p) =
↑k * Lean.Grind.CommRing.Mon.denote ctx m + Lean.Grind.CommRing.Poly.denote ctx p | null | true |
DyckStep.D | Mathlib.Combinatorics.Enumerative.DyckWord | DyckStep | null | true |
ProbabilityTheory.gaussianPDF_def | Mathlib.Probability.Distributions.Gaussian.Real | ∀ (μ : ℝ) (v : NNReal),
ProbabilityTheory.gaussianPDF μ v = fun x => ENNReal.ofReal (ProbabilityTheory.gaussianPDFReal μ v x) | null | true |
ContinuousOn.strictAntiOn_of_injOn_Icc | Mathlib.Topology.Order.IntermediateValue | ∀ {α : Type u} [inst : TopologicalSpace α] [inst_1 : ConditionallyCompleteLinearOrder α] [OrderTopology α]
[DenselyOrdered α] {δ : Type u_1} [inst_4 : LinearOrder δ] [inst_5 : TopologicalSpace δ] [OrderClosedTopology δ]
{a b : α} {f : α → δ},
a ≤ b → f b ≤ f a → ContinuousOn f (Set.Icc a b) → Set.InjOn f (Set.Icc... | Suppose `f : [a, b] → δ` is
continuous and injective. Then `f` is strictly antitone (decreasing) if `f(b) ≤ f(a)`. | true |
Ideal.idealProdEquiv.match_1 | Mathlib.RingTheory.Ideal.Prod | ∀ {R : Type u_1} {S : Type u_2} [inst : Semiring R] [inst_1 : Semiring S] (motive : Ideal R × Ideal S → Prop)
(x : Ideal R × Ideal S), (∀ (I : Ideal R) (J : Ideal S), motive (I, J)) → motive x | null | false |
Mathlib.Tactic.Abel.abelNFConv | Mathlib.Tactic.Abel | Lean.ParserDescr | `abel` solves equations in the language of *additive*, commutative monoids and groups.
`abel` and its variants work as both tactics and conv tactics.
* `abel1` fails if the target is not an equality that is provable by the axioms of
commutative monoids/groups.
* `abel_nf` rewrites all group expressions into a norma... | true |
_private.Lean.CoreM.0.Lean.Core.wrapAsync.match_3 | Lean.CoreM | (motive : Lean.NameGenerator × Lean.NameGenerator → Sort u_1) →
(x : Lean.NameGenerator × Lean.NameGenerator) →
((childNGen parentNGen : Lean.NameGenerator) → motive (childNGen, parentNGen)) → motive x | null | false |
CategoryTheory.CatCenter.smul_iso_hom_eq | Mathlib.CategoryTheory.Center.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (z : (CategoryTheory.CatCenter C)ˣ) {X Y : C} (f : X ≅ Y),
(z • f).hom = CategoryTheory.CategoryStruct.comp f.hom ((↑z).app Y) | null | true |
_private.Init.Data.BitVec.Lemmas.0.BitVec.twoPow_le_toInt_sub_toInt_iff._proof_1_6 | Init.Data.BitVec.Lemmas | ∀ (w : ℕ) {x y : BitVec (w + 1)},
-2 ^ (w + 1) ≤ 2 * x.toInt →
2 * x.toInt < 2 ^ (w + 1) →
-2 ^ (w + 1) ≤ 2 * y.toInt →
2 * y.toInt < 2 ^ (w + 1) →
(-2 ^ (w + 1) ≤ x.toInt - y.toInt →
x.toInt - y.toInt < 2 ^ (w + 1) →
((x.toInt - y.toInt).bmod (2 ^ (w + 1)) < ... | null | false |
_private.Mathlib.RingTheory.Regular.ProjectiveDimension.0.ModuleCat.projectiveDimension_quotSMulTop_eq_succ_of_isSMulRegular._simp_1_9 | Mathlib.RingTheory.Regular.ProjectiveDimension | ∀ {R : Type u_1} {M : Type u_3} [inst : MonoidWithZero R] [inst_1 : Zero M] [inst_2 : MulActionWithZero R M],
IsSMulRegular M 0 = Subsingleton M | null | false |
CategoryTheory.Abelian.comp_epiDesc | Mathlib.CategoryTheory.Abelian.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Abelian C] {X Y : C} (f : X ⟶ Y)
[inst_2 : CategoryTheory.Epi f] {T : C} (g : X ⟶ T)
(hg : CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.kernel.ι f) g = 0),
CategoryTheory.CategoryStruct.comp f (CategoryTheory.Abelian.ep... | null | true |
Algebra.intTraceAux | Mathlib.RingTheory.IntegralClosure.IntegralRestrict | (A : Type u_1) →
(K : Type u_2) →
(L : Type u_3) →
(B : Type u_6) →
[inst : CommRing A] →
[inst_1 : CommRing B] →
[inst_2 : Algebra A B] →
[inst_3 : Field K] →
[inst_4 : Field L] →
[inst_5 : Algebra A K] →
[IsF... | The restriction of the trace on `L/K` restricted onto `B/A` in an AKLB setup.
See `Algebra.intTrace` instead. | true |
LinearEquiv.isUnit_det' | Mathlib.LinearAlgebra.Determinant | ∀ {M : Type u_2} [inst : AddCommGroup M] {A : Type u_5} [inst_1 : CommRing A] [inst_2 : Module A M] (f : M ≃ₗ[A] M),
IsUnit (LinearMap.det ↑f) | Specialization of `LinearEquiv.isUnit_det` | true |
BoxIntegral.Prepartition.filter | Mathlib.Analysis.BoxIntegral.Partition.Basic | {ι : Type u_1} →
{I : BoxIntegral.Box ι} → BoxIntegral.Prepartition I → (BoxIntegral.Box ι → Prop) → BoxIntegral.Prepartition I | The prepartition with boxes `{J ∈ π | p J}`. | true |
_private.Init.Data.BitVec.Lemmas.0.BitVec.twoPow_le_toInt_sub_toInt_iff._proof_1_3 | Init.Data.BitVec.Lemmas | ∀ (w : ℕ) {x y : BitVec (w + 1)},
↑(2 ^ w) ≤ x.toInt - y.toInt → ¬-(↑(2 ^ (w + 1)) / 2) ≤ x.toInt - y.toInt - ↑(2 ^ (w + 1)) → False | null | false |
bddAbove_iff_exists_ge | Mathlib.Order.Bounds.Basic | ∀ {γ : Type u_3} [inst : SemilatticeSup γ] {s : Set γ} (x₀ : γ), BddAbove s ↔ ∃ x, x₀ ≤ x ∧ ∀ y ∈ s, y ≤ x | null | true |
PowerSeries.derivativeFun | Mathlib.RingTheory.PowerSeries.Derivative | {R : Type u_1} → [CommSemiring R] → PowerSeries R → PowerSeries R | The formal derivative of a power series in one variable.
This is defined here as a function, but will be packaged as a
derivation `derivative` on `R⟦X⟧`.
| true |
Std.LinearOrderPackage.ctorIdx | Init.Data.Order.PackageFactories | {α : Type u} → Std.LinearOrderPackage α → ℕ | null | false |
CategoryTheory.Limits.pushoutIsoUnopPullback_inr_hom_assoc | Mathlib.CategoryTheory.Limits.Shapes.Opposites.Pullbacks | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {X Y Z : C} (f : X ⟶ Z) (g : X ⟶ Y)
[inst_1 : CategoryTheory.Limits.HasPushout f g] {Z_1 : C}
(h : Opposite.unop (CategoryTheory.Limits.pullback f.op g.op) ⟶ Z_1),
CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.pushout.inr f g)
(Category... | null | true |
EuclideanGeometry.Sphere.dist_div_cos_oangle_center_eq_two_mul_radius | Mathlib.Geometry.Euclidean.Angle.Sphere | ∀ {V : Type u_3} {P : Type u_4} [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)]
{s : EuclideanGeometry.Sphere P} {p₁ p₂ : P},
p₁ ∈ s → p₂ ∈ s → p₁ ≠ p₂ → dist p₁ p₂ /... | Given two points on a circle, twice the radius of that circle may be expressed explicitly as
the distance between those two points divided by the cosine of the angle between the chord and
the radius at one of those points. | true |
SimpleGraph.Walk.darts_tail | Mathlib.Combinatorics.SimpleGraph.Walk.Operations | ∀ {V : Type u} {G : SimpleGraph V} {u v : V} {p : G.Walk u v}, p.tail.darts = p.darts.tail | null | true |
CategoryTheory.Monoidal.MonFunctorCategoryEquivalence.inverse._proof_2 | Mathlib.CategoryTheory.Monoidal.Internal.FunctorCategory | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_4, u_1} C] {D : Type u_3}
[inst_1 : CategoryTheory.Category.{u_2, u_3} D] [inst_2 : CategoryTheory.MonoidalCategory D]
{X Y : CategoryTheory.Functor C (CategoryTheory.Mon D)} (α : X ⟶ Y),
CategoryTheory.CategoryStruct.comp CategoryTheory.MonObj.one { app := fun ... | null | false |
FreeAddMagma | Mathlib.Algebra.Free | Type u → Type u | If `α` is a type, then `FreeAddMagma α` is the free additive magma generated by `α`.
This is an additive magma equipped with a function `FreeAddMagma.of : α → FreeAddMagma α` which has
the following universal property: if `M` is any magma, and `f : α → M` is any function,
then this function is the composite of `FreeAdd... | true |
CategoryTheory.PreOneHypercover.sieve₁_inter | Mathlib.CategoryTheory.Sites.Hypercover.One | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {S : C} {E : CategoryTheory.PreOneHypercover S}
{F : CategoryTheory.PreOneHypercover S} [inst_1 : CategoryTheory.Limits.HasPullbacks C] {i j : E.I₀ × F.I₀} {W : C}
{p₁ : W ⟶ CategoryTheory.Limits.pullback (E.f i.1) (F.f i.2)}
{p₂ : W ⟶ CategoryTheory.Limits... | null | true |
Module.Basis.mk._proof_1 | Mathlib.LinearAlgebra.Basis.Basic | ∀ {R : Type u_1} [inst : Semiring R], RingHomCompTriple (RingHom.id R) (RingHom.id R) (RingHom.id R) | null | false |
_private.Lean.Meta.Tactic.Grind.Ctor.0.Lean.Meta.Grind.propagateCtorHetero._sparseCasesOn_3 | Lean.Meta.Tactic.Grind.Ctor | {α : Type u} →
{motive : Option α → Sort u_1} →
(t : Option α) → ((val : α) → motive (some val)) → (Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t | null | false |
iInf_ite | Mathlib.Order.CompleteLattice.Basic | ∀ {α : Type u_1} {ι : Sort u_4} [inst : CompleteLattice α] (p : ι → Prop) [inst_1 : DecidablePred p] (f g : ι → α),
(⨅ i, if p i then f i else g i) = (⨅ i, ⨅ (_ : p i), f i) ⊓ ⨅ i, ⨅ (_ : ¬p i), g i | null | true |
CategoryTheory.IsCofilteredOrEmpty.of_left_adjoint | Mathlib.CategoryTheory.Filtered.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [CategoryTheory.IsCofilteredOrEmpty C] {D : Type u₁}
[inst_2 : CategoryTheory.Category.{v₁, u₁} D] {L : CategoryTheory.Functor C D} {R : CategoryTheory.Functor D C}
(h : L ⊣ R), CategoryTheory.IsCofilteredOrEmpty D | If `C` is cofiltered or empty, and we have a functor `L : C ⥤ D` with a right adjoint,
then `D` is cofiltered or empty.
| true |
_private.Mathlib.Data.Nat.Digits.Defs.0.Nat.toDigitsCore_length._simp_1_4 | Mathlib.Data.Nat.Digits.Defs | ∀ (n : ℕ), (0 ≤ n) = True | null | false |
Submodule.orthogonalBilin_sup | Mathlib.LinearAlgebra.SesquilinearForm.Orthogonal | ∀ {R : Type u_1} {R₁ : Type u_2} {R₂ : Type u_3} {M : Type u_4} {M₁ : Type u_5} {M₂ : Type u_6} [inst : CommSemiring R]
[inst_1 : CommSemiring R₁] [inst_2 : CommSemiring R₂] [inst_3 : AddCommMonoid M] [inst_4 : Module R M]
[inst_5 : AddCommMonoid M₁] [inst_6 : Module R₁ M₁] [inst_7 : AddCommMonoid M₂] [inst_8 : Mod... | null | true |
continuousAt_jacobiTheta₂ | Mathlib.NumberTheory.ModularForms.JacobiTheta.TwoVariable | ∀ (z : ℂ) {τ : ℂ}, 0 < τ.im → ContinuousAt (fun p => jacobiTheta₂ p.1 p.2) (z, τ) | null | true |
CategoryTheory.PreGaloisCategory.PointedGaloisObject.cocone._proof_1 | Mathlib.CategoryTheory.Galois.Prorepresentability | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} C] [inst_1 : CategoryTheory.GaloisCategory C]
(F : CategoryTheory.Functor C FintypeCat) (x x_1 : (CategoryTheory.PreGaloisCategory.PointedGaloisObject F)ᵒᵖ)
(x_2 : x ⟶ x_1),
CategoryTheory.CategoryStruct.comp
(((CategoryTheory.PreGaloisCategory.Poi... | null | false |
String.instLinearOrder._proof_9 | Mathlib.Data.String.Basic | ∀ (a b : String), (if a ≤ b then a else b) = if a ≤ b then a else b | null | false |
ComplexShape.down.congr_simp | Mathlib.Algebra.Homology.HomologicalComplex | ∀ (α : Type u_2) [inst : Add α] [inst_1 : IsRightCancelAdd α] [inst_2 : One α],
ComplexShape.down α = ComplexShape.down α | null | true |
ImplicitFunctionData.hasStrictFDerivAt_implicitFunction | Mathlib.Analysis.Calculus.Implicit | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] [inst_3 : CompleteSpace E] {F : Type u_3} [inst_4 : NormedAddCommGroup F]
[inst_5 : NormedSpace 𝕜 F] [inst_6 : CompleteSpace F] {G : Type u_4} [inst_7 : NormedAddCommGroup G]
[inst_8 :... | null | true |
Array.back_scanl? | Batteries.Data.Array.Scan | ∀ {β : Type u_1} {α : Type u_2} {init : β} {f : β → α → β} {as : Array α},
(Array.scanl f init as).back? = some (Array.foldl f init as) | **Alias** of `Array.back?_scanl`. | true |
PositiveContinuousLinearMap.mk.inj | Mathlib.Topology.Algebra.Module.ContinuousLinearMap.Positive | ∀ {R : Type u_1} {E₁ : Type u_2} {E₂ : Type u_3} {inst : Semiring R} {inst_1 : AddCommMonoid E₁}
{inst_2 : PartialOrder E₁} {inst_3 : TopologicalSpace E₁} {inst_4 : AddCommMonoid E₂} {inst_5 : PartialOrder E₂}
{inst_6 : TopologicalSpace E₂} {inst_7 : Module R E₁} {inst_8 : Module R E₂} {toPositiveLinearMap : E₁ →ₚ[... | null | true |
LieDerivation.mk.injEq | Mathlib.Algebra.Lie.Derivation.Basic | ∀ {R : Type u_1} {L : Type u_2} {M : Type u_3} [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : LieAlgebra R L]
[inst_3 : AddCommGroup M] [inst_4 : Module R M] [inst_5 : LieRingModule L M] [inst_6 : LieModule R L M]
(toLinearMap : L →ₗ[R] M) (leibniz' : ∀ (a b : L), toLinearMap ⁅a, b⁆ = ⁅a, toLinearMap b⁆ - ⁅b, t... | null | true |
_private.Init.Data.UInt.Lemmas.0.UInt16.lt_of_le_of_ne._simp_1_2 | Init.Data.UInt.Lemmas | ∀ {a b : UInt16}, (a ≤ b) = (a.toNat ≤ b.toNat) | null | false |
Lean.Meta.LazyDiscrTree.Key.fvar.injEq | Lean.Meta.LazyDiscrTree | ∀ (a : Lean.FVarId) (a_1 : ℕ) (a_2 : Lean.FVarId) (a_3 : ℕ),
(Lean.Meta.LazyDiscrTree.Key.fvar a a_1 = Lean.Meta.LazyDiscrTree.Key.fvar a_2 a_3) = (a = a_2 ∧ a_1 = a_3) | null | true |
CategoryTheory.Limits.Fork.IsLimit.lift' | Mathlib.CategoryTheory.Limits.Shapes.Equalizers | {C : Type u} →
{X Y : C} →
[inst : CategoryTheory.Category.{v, u} C] →
{f g : X ⟶ Y} →
{s : CategoryTheory.Limits.Fork f g} →
CategoryTheory.Limits.IsLimit s →
{W : C} →
(k : W ⟶ X) →
CategoryTheory.CategoryStruct.comp k f = CategoryTheory.Category... | If `s` is a limit fork over `f` and `g`, then a morphism `k : W ⟶ X` satisfying
`k ≫ f = k ≫ g` induces a morphism `l : W ⟶ s.pt` such that `l ≫ fork.ι s = k`. | true |
Polynomial.eval_mul_X_pow | Mathlib.Algebra.Polynomial.Eval.Defs | ∀ {R : Type u} [inst : Semiring R] {p : Polynomial R} {x : R} {k : ℕ},
Polynomial.eval x (p * Polynomial.X ^ k) = Polynomial.eval x p * x ^ k | null | true |
_private.Mathlib.Analysis.Calculus.Taylor.0.hasDerivAt_taylorWithinEval_succ._simp_1_6 | Mathlib.Analysis.Calculus.Taylor | ∀ {G₀ : Type u_3} [inst : GroupWithZero G₀] {a : G₀} (n : ℤ), a ≠ 0 → (a ^ n = 0) = False | null | false |
WeierstrassCurve.Projective.Nonsingular | Mathlib.AlgebraicGeometry.EllipticCurve.Projective.Basic | {R : Type r} → [CommRing R] → WeierstrassCurve.Projective R → (Fin 3 → R) → Prop | The proposition that a projective point representative `(x, y, z)` on a Weierstrass curve `W` is
nonsingular.
In other words, either `W_X(x, y, z) ≠ 0`, `W_Y(x, y, z) ≠ 0`, or `W_Z(x, y, z) ≠ 0`.
Note that this definition is only mathematically accurate for fields. | true |
MeasurableSpace.DynkinSystem.mk.sizeOf_spec | Mathlib.MeasureTheory.PiSystem | ∀ {α : Type u_4} [inst : SizeOf α] (Has : Set α → Prop) (has_empty : Has ∅) (has_compl : ∀ {a : Set α}, Has a → Has aᶜ)
(has_iUnion_nat : ∀ {f : ℕ → Set α}, Pairwise (Function.onFun Disjoint f) → (∀ (i : ℕ), Has (f i)) → Has (⋃ i, f i)),
sizeOf { Has := Has, has_empty := has_empty, has_compl := has_compl, has_iUnio... | null | true |
RCLike.I_to_real | Mathlib.Analysis.RCLike.Basic | RCLike.I = 0 | null | true |
IsAddRegular.all | Mathlib.Algebra.Group.Semigroup | ∀ {R : Type u_2} [inst : Add R] [IsCancelAdd R] (g : R), IsAddRegular g | If all additions cancel then every element is add-regular. | true |
Int64.toISize_ofNat' | Init.Data.SInt.Lemmas | ∀ {n : ℕ}, (Int64.ofNat n).toISize = ISize.ofNat n | null | true |
AffineMap.instAddCommGroup._proof_4 | Mathlib.LinearAlgebra.AffineSpace.AffineMap | ∀ {k : Type u_1} {V1 : Type u_2} {P1 : Type u_3} {V2 : Type u_4} [inst : Ring k] [inst_1 : AddCommGroup V1]
[inst_2 : Module k V1] [inst_3 : AddTorsor V1 P1] [inst_4 : AddCommGroup V2] [inst_5 : Module k V2] (x : P1 →ᵃ[k] V2)
(x_1 : ℕ), ⇑(x_1 • x) = x_1 • ⇑x | null | false |
MeasureTheory.AEEqFun.instMonoid | Mathlib.MeasureTheory.Function.AEEqFun | {α : Type u_1} →
{γ : Type u_3} →
[inst : MeasurableSpace α] →
{μ : MeasureTheory.Measure α} →
[inst_1 : TopologicalSpace γ] → [inst_2 : Monoid γ] → [ContinuousMul γ] → Monoid (α →ₘ[μ] γ) | null | true |
CommRingCat.Colimits.descFunLift._unsafe_rec | Mathlib.Algebra.Category.Ring.Colimits | {J : Type v} →
[inst : CategoryTheory.SmallCategory J] →
(F : CategoryTheory.Functor J CommRingCat) →
(s : CategoryTheory.Limits.Cocone F) → CommRingCat.Colimits.Prequotient F → ↑s.pt | null | false |
_private.Std.Data.DTreeMap.Internal.Operations.0.Std.DTreeMap.Internal.Impl.insert._proof_19 | Std.Data.DTreeMap.Internal.Operations | ∀ {α : Type u_1} {β : α → Type u_2} (l' r' d : Std.DTreeMap.Internal.Impl α β),
l'.size ≤ d.size → d.size ≤ l'.size + 1 → ¬d.size + 1 + r'.size ≤ l'.size + 1 + r'.size + 1 → False | null | false |
ENat.iInf_toNat | Mathlib.Data.ENat.Lattice | ∀ {ι : Sort u_1} {f : ι → ℕ}, (⨅ i, ↑(f i)).toNat = ⨅ i, f i | null | true |
Int.ModEq.mul_left | Mathlib.Data.Int.ModEq | ∀ {n a b : ℤ} (c : ℤ), a ≡ b [ZMOD n] → c * a ≡ c * b [ZMOD n] | null | true |
AlgebraicGeometry.Scheme.IdealSheafData.glueData._proof_14 | Mathlib.AlgebraicGeometry.IdealSheaf.Subscheme | ∀ {X : AlgebraicGeometry.Scheme} (I : X.IdealSheafData) (i : ↑X.affineOpens),
CategoryTheory.IsIso (CategoryTheory.Limits.pullback.fst (I.glueDataObjι (i, i).1) (X.homOfLE ⋯)) | null | false |
_private.Init.Data.ByteArray.Lemmas.0.ByteArray.extract_add_three._simp_1_3 | Init.Data.ByteArray.Lemmas | ∀ {l l' : List UInt8}, l.toByteArray ++ l'.toByteArray = (l ++ l').toByteArray | null | false |
CategoryTheory.TwoSquare.mk | Mathlib.CategoryTheory.Functor.TwoSquare | {C₁ : Type u₁} →
{C₂ : Type u₂} →
{C₃ : Type u₃} →
{C₄ : Type u₄} →
[inst : CategoryTheory.Category.{v₁, u₁} C₁] →
[inst_1 : CategoryTheory.Category.{v₂, u₂} C₂] →
[inst_2 : CategoryTheory.Category.{v₃, u₃} C₃] →
[inst_3 : CategoryTheory.Category.{v₄, u₄} C₄] →
... | Constructor for `TwoSquare`. | true |
Kronecker.«_aux_Mathlib_LinearAlgebra_Matrix_Kronecker___macroRules_Kronecker_term_⊗ₖₜ[_]__1» | Mathlib.LinearAlgebra.Matrix.Kronecker | Lean.Macro | null | false |
Topology.WithGeneratedByTopology.isClosed_iff | Mathlib.Topology.Convenient.GeneratedBy | ∀ {ι : Type t} {X : ι → Type u} [inst : (i : ι) → TopologicalSpace (X i)] {Y : Type v} [tY : TopologicalSpace Y]
{U : Set (Topology.WithGeneratedByTopology X Y)},
IsClosed U ↔ ∀ ⦃i : ι⦄ (f : C(X i, Y)), IsClosed (⇑f ⁻¹' ⇑Topology.WithGeneratedByTopology.equiv.symm ⁻¹' U) | null | true |
SSet.innerAnodyneExtensions.whiskerRight | Mathlib.AlgebraicTopology.SimplicialSet.AnodyneExtensions.Inner.PushoutProduct | ∀ {X Y : SSet} {f : X ⟶ Y},
SSet.innerAnodyneExtensions f →
∀ (Z : SSet), SSet.innerAnodyneExtensions (CategoryTheory.MonoidalCategoryStruct.whiskerRight f Z) | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.