name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
SimplexCategory.exists_eq_const_of_zero | Mathlib.AlgebraicTopology.SimplexCategory.Basic | ∀ {n : SimplexCategory} (f : { len := 0 } ⟶ n), ∃ a, f = { len := 0 }.const n a | null | true |
_private.Mathlib.Util.ElabWithoutMVars.0.elabTermWithoutNewMVars.match_1 | Mathlib.Util.ElabWithoutMVars | (motive : Lean.Expr × List Lean.MVarId → Sort u_1) →
(x : Lean.Expr × List Lean.MVarId) → ((e : Lean.Expr) → (mvars : List Lean.MVarId) → motive (e, mvars)) → motive x | null | false |
_private.Mathlib.LinearAlgebra.RootSystem.Finite.Lemmas.0.RootPairing.RootPositiveForm.rootLength_lt_of_pairingIn_notMem._proof_1_9 | Mathlib.LinearAlgebra.RootSystem.Finite.Lemmas | ∀ {ι : Type u_1} {R : Type u_2} {M : Type u_3} {N : Type u_4} [inst : CommRing R] [inst_1 : AddCommGroup M]
[inst_2 : Module R M] [inst_3 : AddCommGroup N] [inst_4 : Module R N] {P : RootPairing ι R M N} [inst_5 : CharZero R]
[inst_6 : P.IsCrystallographic] (B : RootPairing.RootPositiveForm ℤ P) {i j : ι},
-1 * B... | null | false |
Lean.Elab.Term.Do.DoIfView | Lean.Elab.Do.Legacy | Type | null | true |
_private.Std.Data.DTreeMap.Internal.WF.Lemmas.0.Std.DTreeMap.Internal.Impl.applyPartition_eq._simp_1_3 | Std.Data.DTreeMap.Internal.WF.Lemmas | ∀ {α : Type u_1} {a : α} {s t : List α}, (a ∈ s ++ t) = (a ∈ s ∨ a ∈ t) | null | false |
IsDomain.minimalPrimes_eq_singleton_bot | Mathlib.RingTheory.Ideal.MinimalPrime.Basic | ∀ (R : Type u_1) [inst : CommSemiring R] [IsDomain R], minimalPrimes R = {⊥} | null | true |
_private.Mathlib.RingTheory.RootsOfUnity.PrimitiveRoots.0.IsPrimitiveRoot.nthRoots_eq._simp_1_2 | Mathlib.RingTheory.RootsOfUnity.PrimitiveRoots | ∀ {α : Type u_1} {β : Type v} {f : α → β} {b : β} {s : Multiset α}, (b ∈ Multiset.map f s) = ∃ a ∈ s, f a = b | null | false |
CategoryTheory.Bicategory.Equivalence | Mathlib.CategoryTheory.Bicategory.Adjunction.Basic | {B : Type u₁} → [CategoryTheory.Bicategory B] → B → B → Type (max v₁ w₁) | Adjoint equivalences between two objects. | true |
Std.TreeMap.getElem!_alter_self | Std.Data.TreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.TreeMap α β cmp} [Std.TransCmp cmp] {k : α}
[inst : Inhabited β] {f : Option β → Option β}, (t.alter k f)[k]! = (f t[k]?).get! | null | true |
SSet.Edge.δ_one_yonedaEquiv_symm | Mathlib.AlgebraicTopology.SimplicialSet.StdSimplex | ∀ {X : SSet} {x₀ x₁ : X.obj (Opposite.op { len := 0 })} (e : SSet.Edge x₀ x₁),
CategoryTheory.CategoryStruct.comp (SSet.stdSimplex.δ 1) (SSet.yonedaEquiv.symm e.edge) = SSet.yonedaEquiv.symm x₀ | null | true |
DirectSum.semiring._private_5 | Mathlib.Algebra.DirectSum.Ring | ∀ {ι : Type u_1} [inst : DecidableEq ι] (A : ι → Type u_2) [inst_1 : (i : ι) → AddCommMonoid (A i)]
[inst_2 : AddMonoid ι] [inst_3 : DirectSum.GSemiring A] (x : DirectSum ι fun i => A i), x * 1 = x | null | false |
List.mem_sublistsLen | Mathlib.Data.List.Sublists | ∀ {α : Type u} {n : ℕ} {l l' : List α}, l' ∈ List.sublistsLen n l ↔ l'.Sublist l ∧ l'.length = n | null | true |
_private.Mathlib.Algebra.Homology.SpectralObject.HasSpectralSequence.0.CategoryTheory.Abelian.SpectralObject.instHasSpectralSequenceEIntProdNatCoreE₂CohomologicalNat._simp_6 | Mathlib.Algebra.Homology.SpectralObject.HasSpectralSequence | ∀ {ι : Type u_1} [inst : LT ι] {a b : ι}, (WithBotTop.coe a < WithBotTop.coe b) = (a < b) | null | false |
List.wbtw_singleton._simp_1 | Mathlib.Analysis.Convex.BetweenList | ∀ (R : Type u_1) {V : Type u_2} {P : Type u_4} [inst : Ring R] [inst_1 : PartialOrder R] [inst_2 : AddCommGroup V]
[inst_3 : Module R V] [inst_4 : AddTorsor V P] (p₁ : P), List.Wbtw R [p₁] = True | null | false |
_private.Mathlib.Analysis.Normed.Order.Hom.Basic.0.GroupSeminormClass.toSeminormedGroup._simp_4 | Mathlib.Analysis.Normed.Order.Hom.Basic | ∀ {G : Type u_1} [inst : DivInvMonoid G] (a : G) (n : ℕ), a ^ n = a ^ ↑n | null | false |
RootPairing.EmbeddedG2.twoShortAddLong.eq_1 | Mathlib.LinearAlgebra.RootSystem.Finite.G2 | ∀ {ι : Type u_1} {R : Type u_2} {M : Type u_3} {N : Type u_4} [inst : CommRing R] [inst_1 : AddCommGroup M]
[inst_2 : Module R M] [inst_3 : AddCommGroup N] [inst_4 : Module R N] (P : RootPairing ι R M N)
[inst_5 : P.EmbeddedG2],
RootPairing.EmbeddedG2.twoShortAddLong P =
(P.reflectionPerm (RootPairing.Embedde... | null | true |
Equiv.piCongrLeft_refl | Mathlib.Logic.Equiv.Basic | ∀ {α : Sort u_1} (P : α → Sort u_8), Equiv.piCongrLeft P (Equiv.refl α) = Equiv.refl ((a : α) → P a) | null | true |
WeierstrassCurve.VariableChange.instInv | Mathlib.AlgebraicGeometry.EllipticCurve.VariableChange | {R : Type u} → [inst : CommRing R] → Inv (WeierstrassCurve.VariableChange R) | null | true |
_private.Lean.Meta.LetToHave.0.Lean.Meta.LetToHave.State.mk._flat_ctor | Lean.Meta.LetToHave | ℕ → Std.HashMap Lean.ExprStructEq Lean.Meta.LetToHave.Result✝ → Lean.Meta.LetToHave.State✝ | null | false |
_private.Mathlib.Analysis.SpecialFunctions.Complex.Analytic.0.hasFPowerSeriesAt_clog_one._simp_1_4 | Mathlib.Analysis.SpecialFunctions.Complex.Analytic | ∀ {M₀ : Type u_1} [inst : Mul M₀] [inst_1 : Zero M₀] [NoZeroDivisors M₀] {a b : M₀}, a ≠ 0 → b ≠ 0 → (a * b = 0) = False | null | false |
DMatrix.instUnique._proof_1 | Mathlib.Data.Matrix.DMatrix | ∀ {m : Type u_1} {n : Type u_2} {α : m → n → Type u_3} [inst : (i : m) → (j : n) → Unique (α i j)] (a : DMatrix m n α),
a = default | null | false |
MvPowerSeries.killCompl_monomial_embDomain | Mathlib.RingTheory.MvPowerSeries.Rename | ∀ {σ : Type u_1} {τ : Type u_2} {R : Type u_4} [inst : CommSemiring R] {e : σ ↪ τ} (x : σ →₀ ℕ) (r : R),
(MvPowerSeries.killCompl e) ((MvPowerSeries.monomial (Finsupp.embDomain e x)) r) = (MvPowerSeries.monomial x) r | null | true |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.Const.get!_union_of_contains_eq_false_left._simp_1_2 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {instOrd : Ord α} {a b : α}, (compare a b ≠ Ordering.eq) = ((a == b) = false) | null | false |
Isometry.toDilation_toFun | Mathlib.Topology.MetricSpace.Dilation | ∀ {α : Type u_1} {β : Type u_2} [inst : PseudoEMetricSpace α] [inst_1 : PseudoEMetricSpace β] (f : α → β)
(hf : Isometry f) (a : α), (Isometry.toDilation f hf) a = f a | null | true |
_private.Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.NonUnital.0._auto_178 | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.NonUnital | Lean.Syntax | null | false |
_private.Mathlib.Analysis.SpecialFunctions.Exp.0.Complex.tendsto_exp_nhds_zero_iff._simp_1_1 | Mathlib.Analysis.SpecialFunctions.Exp | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} {f : α → β} {g : β → γ} {a : Filter α} {c : Filter γ},
Filter.Tendsto (g ∘ f) a c = Filter.Tendsto f a (Filter.comap g c) | null | false |
ContinuousAffineMap.casesOn | Mathlib.Topology.Algebra.ContinuousAffineMap | {R : Type u_1} →
{V : Type u_2} →
{W : Type u_3} →
{P : Type u_4} →
{Q : Type u_5} →
[inst : Ring R] →
[inst_1 : AddCommGroup V] →
[inst_2 : Module R V] →
[inst_3 : TopologicalSpace P] →
[inst_4 : AddTorsor V P] →
... | null | false |
le_of_le_of_eq | Init.Core | ∀ {α : Type u_1} {a b c : α} [inst : LE α], a ≤ b → b = c → a ≤ c | null | true |
ModelWithCorners.source_eq | Mathlib.Geometry.Manifold.IsManifold.Basic | ∀ {𝕜 : 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] (self : ModelWithCorners 𝕜 E H),
self.source = Set.univ | null | true |
Lean.Server.CodeActionResolveData.params | Lean.Server.CodeActions.Basic | Lean.Server.CodeActionResolveData → Lean.Lsp.CodeActionParams | null | true |
Int.lt_div_iff_of_dvd_of_neg | Mathlib.Data.Int.Init | ∀ {a b c : ℤ}, c < 0 → c ∣ b → (a < b / c ↔ b < c * a) | null | true |
CategoryTheory.Bicategory.yoneda₀_toPrelaxFunctor_toPrelaxFunctorStruct_map₂_toNatTrans_app | Mathlib.CategoryTheory.Bicategory.Yoneda | ∀ {B : Type u} [inst : CategoryTheory.Bicategory B] (x : B) {a b : Bᵒᵖ} {f g : a ⟶ b} (a_1 : f ⟶ g)
(x_1 : Opposite.unop a ⟶ x),
((CategoryTheory.Bicategory.yoneda₀ x).map₂ a_1).toNatTrans.app x_1 =
CategoryTheory.Bicategory.whiskerRight a_1.unop2 x_1 | null | true |
CategoryTheory.MonoidalCategory.ofBifunctor.Triangle.associatorMap | Mathlib.CategoryTheory.Monoidal.Multifunctor | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
(tensor : CategoryTheory.Functor C (CategoryTheory.Functor C C)) →
(unit : C) →
(CategoryTheory.bifunctorComp₁₂ tensor tensor ≅ CategoryTheory.bifunctorComp₂₃ tensor tensor) →
(CategoryTheory.MonoidalCategory.ofBifunctor.Tria... | The associator edge of the monoidal triangle. | true |
ProbabilityTheory.iIndep.eq_1 | Mathlib.Probability.Independence.Basic | ∀ {Ω : Type u_1} {ι : Type u_2} (m : ι → MeasurableSpace Ω) {_mΩ : MeasurableSpace Ω} (μ : MeasureTheory.Measure Ω),
ProbabilityTheory.iIndep m μ =
ProbabilityTheory.Kernel.iIndep m (ProbabilityTheory.Kernel.const Unit μ) (MeasureTheory.Measure.dirac ()) | null | true |
CategoryTheory.braiding_leftUnitor | 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 : C),
CategoryTheory.CategoryStruct.comp (β_ X (CategoryTheory.MonoidalCategoryStruct.tensorUnit C)).hom
(CategoryTheory.MonoidalCategoryStruct.leftUnitor X).... | null | true |
Countable.casesOn | Mathlib.Basic.Countable.Defs | {α : Sort u} →
{motive : Countable α → Sort u_1} →
(t : Countable α) → ((exists_injective_nat' : ∃ f, Function.Injective f) → motive ⋯) → motive t | null | false |
MeasurableEmbedding.subtype_coe | Mathlib.MeasureTheory.MeasurableSpace.Embedding | ∀ {α : Type u_1} {s : Set α} {mα : MeasurableSpace α}, MeasurableSet s → MeasurableEmbedding Subtype.val | null | true |
SimpleGraph.Subgraph.deleteEdges._proof_3 | Mathlib.Combinatorics.SimpleGraph.Subgraph | ∀ {V : Type u_1} {G : SimpleGraph V} (G' : G.Subgraph) (s : Set (Sym2 V)) {v w : V},
(G'.Adj \ Sym2.ToRel s) v w → v ∈ G'.verts | null | false |
Affine.Simplex.inv_height_eq_sum_mul_inv_dist | Mathlib.Geometry.Euclidean.Incenter.Basic | ∀ {V : Type u_1} {P : Type u_2} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V] [inst_2 : MetricSpace P]
[inst_3 : NormedAddTorsor V P] {n : ℕ} [inst_4 : NeZero n] (s : Affine.Simplex ℝ P n) (i : Fin (n + 1)),
(s.height i)⁻¹ =
∑ j with j ≠ i,
-(inner ℝ (s.points i -ᵥ s.altitudeFoot i) (s.po... | The inverse of the distance from one vertex to the opposite face, expressed as a sum of
multiples of that quantity for the other vertices. The multipliers, expressed here in terms of
inner products, are equal to the cosines of angles between faces (informally, the inverse
distances are proportional to the volumes of th... | true |
DoResultPRBC.pure.sizeOf_spec | Init.Core | ∀ {α β σ : Type u} [inst : SizeOf α] [inst_1 : SizeOf β] [inst_2 : SizeOf σ] (a : α) (a_1 : σ),
sizeOf (DoResultPRBC.pure a a_1) = 1 + sizeOf a + sizeOf a_1 | null | true |
Monoid.End | Mathlib.Algebra.Group.Hom.Defs | (M : Type u_4) → [MulOne M] → Type u_4 | The monoid of endomorphisms. | true |
mul_eq_left₀._simp_1 | Mathlib.Algebra.GroupWithZero.Basic | ∀ {M₀ : Type u_1} {a b : M₀} [inst : MulZeroOneClass M₀] [IsLeftCancelMulZero M₀], a ≠ 0 → (a * b = a) = (b = 1) | null | false |
TotalComplexShapeSymmetry.symmetry | Mathlib.Algebra.Homology.ComplexShapeSigns | {I₁ : Type u_1} →
{I₂ : Type u_2} →
{I₁₂ : Type u_4} →
(c₁ : ComplexShape I₁) →
(c₂ : ComplexShape I₂) →
(c₁₂ : ComplexShape I₁₂) →
[inst : TotalComplexShape c₁ c₂ c₁₂] →
[inst_1 : TotalComplexShape c₂ c₁ c₁₂] →
[TotalComplexShapeSymmetry c₁ c₂ c₁₂... | The obvious `TotalComplexShapeSymmetry c₂ c₁ c₁₂` deduced from a
`TotalComplexShapeSymmetry c₁ c₂ c₁₂`. | true |
Stream'.Seq.BisimO.eq_2 | Mathlib.Data.Seq.Defs | ∀ {α : Type u} (R : Stream'.Seq α → Stream'.Seq α → Prop) (a : α) (s : Stream'.Seq α) (a' : α) (s' : Stream'.Seq α),
Stream'.Seq.BisimO R (some (a, s)) (some (a', s')) = (a = a' ∧ R s s') | null | true |
_private.Lean.Meta.Tactic.Simp.BuiltinSimprocs.SInt.0.Int16.reduceGE._regBuiltin.Int16.reduceGE.declare_1._@.Lean.Meta.Tactic.Simp.BuiltinSimprocs.SInt.1259268813._hygCtx._hyg.256 | Lean.Meta.Tactic.Simp.BuiltinSimprocs.SInt | IO Unit | null | false |
Array.min?_toList._cbv_eval_1 | Init.Data.Array.MinMax | ∀ {α : Type u_1} [inst : Min α] {xs : Array α}, xs.min? = xs.toList.min? | null | false |
MvPolynomial.commute_pderiv | Mathlib.Algebra.MvPolynomial.PDeriv | ∀ {R : Type u} {σ : Type v} [inst : CommSemiring R] (i j : σ),
Function.Commute ⇑(MvPolynomial.pderiv i) ⇑(MvPolynomial.pderiv j) | null | true |
mfderiv_sumSwap | Mathlib.Geometry.Manifold.MFDeriv.SpecificFunctions | ∀ {𝕜 : 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} {M : Type u_4}
[inst_4 : TopologicalSpace M] [inst_5 : ChartedSpace H M] {M' : Type u_17} [inst_6 : TopologicalS... | null | true |
CategoryTheory.StructuredArrow.mapIso_unitIso_hom_app_right | Mathlib.CategoryTheory.Comma.StructuredArrow.Basic | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
{S S' : D} {T : CategoryTheory.Functor C D} (i : S ≅ S')
(X : CategoryTheory.Comma (CategoryTheory.Functor.fromPUnit S) T),
((CategoryTheory.StructuredArrow.mapIso i).unitIso.hom.app X).right = ... | null | true |
Lean.Meta.instInhabitedFVarSubst.default | Lean.Meta.Tactic.FVarSubst | Lean.Meta.FVarSubst | null | true |
_private.Lean.Compiler.LCNF.ToLCNF.0.Lean.Compiler.LCNF.ToLCNF.seqToCode.go._unary._proof_7 | Lean.Compiler.LCNF.ToLCNF | ∀ (i : ℕ) (c : Lean.Compiler.LCNF.Code Lean.Compiler.LCNF.Purity.pure),
i > 0 →
∀ (__do_lift : Lean.Compiler.LCNF.Code Lean.Compiler.LCNF.Purity.pure),
InvImage (fun x1 x2 => x1 < x2) (fun x => PSigma.casesOn x fun i c => i) ⟨i - 1, __do_lift⟩ ⟨i, c⟩ | null | false |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.Const.get?_union._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 |
List.chooseX | Mathlib.Data.List.Defs | {α : Type u_1} → (p : α → Prop) → [DecidablePred p] → (l : List α) → (∃ a ∈ l, p a) → { a // a ∈ l ∧ p a } | Given a decidable predicate `p` and a proof of existence of `a ∈ l` such that `p a`,
choose the first element with this property. This version returns both `a` and proofs
of `a ∈ l` and `p a`. | true |
MagmaCat.ctorIdx | Mathlib.Algebra.Category.Semigrp.Basic | MagmaCat → ℕ | null | false |
CategoryTheory.Mat.instFullMat_SingleObjMulOppositeEquivalenceSingleObjInverse | Mathlib.CategoryTheory.Preadditive.Mat | ∀ (R : Type) [inst : Ring R], (CategoryTheory.Mat.equivalenceSingleObjInverse R).Full | null | true |
_private.Lean.Compiler.LCNF.JoinPoints.0.Lean.Compiler.LCNF.extendJoinPointContext._proof_1 | Lean.Compiler.LCNF.JoinPoints | ∀ (phase : Lean.Compiler.LCNF.Phase),
phase.toPurity = Lean.Compiler.LCNF.Purity.pure → Lean.Compiler.LCNF.Purity.pure = phase.toPurity | null | false |
Std.DTreeMap.Internal.Unit.RciSliceData.mk.inj | Std.Data.DTreeMap.Internal.Zipper | ∀ {α : Type u} {inst : Ord α} {treeMap : Std.DTreeMap.Internal.Impl α fun x => Unit} {range : Std.Rci α}
{treeMap_1 : Std.DTreeMap.Internal.Impl α fun x => Unit} {range_1 : Std.Rci α},
{ treeMap := treeMap, range := range } = { treeMap := treeMap_1, range := range_1 } →
treeMap = treeMap_1 ∧ range = range_1 | null | true |
ContDiffAt.eq_1 | Mathlib.Analysis.Calculus.ContDiff.Defs | ∀ (𝕜 : Type u) [inst : NontriviallyNormedField 𝕜] {E : Type uE} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {F : Type uF} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] (n : WithTop ℕ∞)
(f : E → F) (x : E), ContDiffAt 𝕜 n f x = ContDiffWithinAt 𝕜 n f Set.univ x | null | true |
Lean.Meta.ProjReductionKind.yes.elim | Lean.Meta.Basic | {motive : Lean.Meta.ProjReductionKind → Sort u} →
(t : Lean.Meta.ProjReductionKind) → t.ctorIdx = 1 → motive Lean.Meta.ProjReductionKind.yes → motive t | null | false |
CategoryTheory.Comon.Hom | Mathlib.CategoryTheory.Monoidal.Comon_ | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
[inst_1 : CategoryTheory.MonoidalCategory C] → CategoryTheory.Comon C → CategoryTheory.Comon C → Type v₁ | A morphism of comonoid objects. | true |
addEquivIsoAddMagmaIso | Mathlib.Algebra.Category.Semigrp.Basic | {X Y : Type u} → [inst : Add X] → [inst_1 : Add Y] → X ≃+ Y ≅ ↧X ≅ ↧Y | additive equivalences between `Add`s are the same
as (isomorphic to) isomorphisms in `AddMagmaCat` | true |
_private.Std.Time.Format.Basic.0.Std.Time.formatMonthNarrow | Std.Time.Format.Basic | Std.Time.DateFormatSymbols → Std.Time.Month.Ordinal → String | null | true |
GradedAlgHom.instMonoid._proof_3 | Mathlib.RingTheory.GradedAlgebra.AlgHom | ∀ {R : Type u_1} {A : Type u_2} {ι : Type u_3} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A]
[inst_3 : DecidableEq ι] [inst_4 : AddMonoid ι] {𝒜 : ι → Submodule R A} [inst_5 : GradedAlgebra 𝒜]
(x x_1 x_2 : 𝒜 →ₐᵍ[R] 𝒜), x * x_1 * x_2 = x * x_1 * x_2 | null | false |
SSet.Subcomplex.evaluation._proof_1 | Mathlib.AlgebraicTopology.SimplicialSet.SubcomplexEvaluation | ∀ (X : SSet) (j : SimplexCategoryᵒᵖ) (X_1 : X.Subcomplex),
CategoryTheory.homOfLE ⋯ = CategoryTheory.CategoryStruct.id (X_1.obj j) | null | false |
_private.Mathlib.Tactic.CrossRefAttribute.0.Mathlib.CrossRef.wikidataIdFn.match_1 | Mathlib.Tactic.CrossRefAttribute | (motive : List Char → Sort u_1) →
(x : List Char) →
((rest : List Char) →
(head : Char) →
(tail : List Char) → (h : rest = head :: tail) → motive ('Q' :: namedPattern rest (head :: tail) h)) →
((x : List Char) → motive x) → motive x | null | false |
CategoryTheory.TwoSquare.GuitartExact.isConnected_rightwards | Mathlib.CategoryTheory.GuitartExact.Basic | ∀ {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₄} {T : CategoryTheory.Functor C₁ C₂} {L : CategoryTheory.Functor C₁ C₃... | null | true |
_private.Mathlib.Analysis.SpecialFunctions.Exp.0.Real.tendsto_div_pow_mul_exp_add_atTop._simp_1_4 | Mathlib.Analysis.SpecialFunctions.Exp | ∀ {M₀ : Type u_1} [inst : Mul M₀] [inst_1 : Zero M₀] [NoZeroDivisors M₀] {a b : M₀}, a ≠ 0 → b ≠ 0 → (a * b = 0) = False | null | false |
Lean.Compiler.LCNF.UnreachableBranches.InterpState.mk.injEq | Lean.Compiler.LCNF.ElimDeadBranches | ∀ (assignments : Array Lean.Compiler.LCNF.UnreachableBranches.Assignment)
(funVals : Array Lean.Compiler.LCNF.UnreachableBranches.Value)
(assignments_1 : Array Lean.Compiler.LCNF.UnreachableBranches.Assignment)
(funVals_1 : Array Lean.Compiler.LCNF.UnreachableBranches.Value),
({ assignments := assignments, funV... | null | true |
PadicSeq.stationaryPoint | Mathlib.NumberTheory.Padics.PadicNumbers | {p : ℕ} → [inst : Fact (Nat.Prime p)] → {f : PadicSeq p} → ¬f ≈ 0 → ℕ | For all `n ≥ stationaryPoint f hf`, the `p`-adic norm of `f n` is the same. | true |
meromorphicOrderAt_add_of_top_left | Mathlib.Analysis.Meromorphic.Order | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {f₁ f₂ : 𝕜 → E} {x : 𝕜},
meromorphicOrderAt f₁ x = ⊤ → meromorphicOrderAt (f₁ + f₂) x = meromorphicOrderAt f₂ x | Adding a locally vanishing function does not change the order.
| true |
Std.Tactic.BVDecide.BVPred.instLawfulOperatorBinaryRefVecMkEq | Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Eq | ∀ {α : Type} [inst : Hashable α] [inst_1 : DecidableEq α] {w : ℕ},
Std.Sat.AIG.LawfulOperator α (fun x => x.BinaryRefVec w) Std.Tactic.BVDecide.BVPred.mkEq | null | true |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.Const.compare_maxKeyD_modify_eq._simp_1_2 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {instOrd : Ord α} {a b : α}, (compare a b ≠ Ordering.eq) = ((a == b) = false) | null | false |
_private.Init.Data.SInt.Lemmas.0.Int32.lt_or_le._proof_1_3 | Init.Data.SInt.Lemmas | ∀ (a b : Int32), ¬(a.toInt < b.toInt ∨ b.toInt ≤ a.toInt) → False | null | false |
_private.Mathlib.Algebra.Polynomial.Degree.IsMonicOfDegree.0.Polynomial.isMonicOfDegree_iff._simp_1_1 | Mathlib.Algebra.Polynomial.Degree.IsMonicOfDegree | ∀ {R : Type u_1} [inst : Semiring R] (p : Polynomial R) (n : ℕ), p.IsMonicOfDegree n = (p.natDegree = n ∧ p.Monic) | null | false |
fderivWithin_add_const | 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}
{x : E} {s : Set E} (c : F), fderivWithin 𝕜 (fun y => f y + c) s x = fderivWithin 𝕜 f s x | null | true |
_private.Lean.Meta.Sym.Canon.0.Lean.Meta.Sym.Canon.canon.canonLet | Lean.Meta.Sym.Canon | Array Lean.Expr → Lean.Expr → Lean.Meta.Sym.Canon.CanonM✝ Lean.Expr | null | true |
AddSubgroup.normal_addSubgroupOf | Mathlib.Algebra.Group.Subgroup.Basic | ∀ {G : Type u_1} [inst : AddGroup G] {H N : AddSubgroup G} [N.Normal], (N.addSubgroupOf H).Normal | null | true |
_private.Mathlib.Data.Finset.NoncommProd.0.Multiset.mul_noncommProd_erase._simp_1_1 | Mathlib.Data.Finset.NoncommProd | ∀ {α : Type u_1} {a : α} {l : List α}, (a ∈ ↑l) = (a ∈ l) | null | false |
_private.Std.Sat.CNF.Sat.0.Std.Sat.CNF.Clause.sat_add._simp_1_1 | Std.Sat.CNF.Sat | ∀ {α : Type u_1} (a : α → Bool) (c : Std.Sat.CNF.Clause α),
Std.Sat.CNF.Clause.Sat a c = (Std.Sat.CNF.Clause.eval a c = true) | null | false |
countable_sInter_mem | Mathlib.Order.Filter.CountableInter | ∀ {α : Type u_2} {l : Filter α} [CountableInterFilter l] {S : Set (Set α)}, S.Countable → (⋂₀ S ∈ l ↔ ∀ s ∈ S, s ∈ l) | null | true |
Nat.gcd_mul_left | Init.Data.Nat.Gcd | ∀ (m n k : ℕ), (m * n).gcd (m * k) = m * n.gcd k | null | true |
_private.Mathlib.MeasureTheory.PiSystem.0.isPiSystem_piiUnionInter._simp_1_4 | Mathlib.MeasureTheory.PiSystem | ∀ {α : Type u}, (fun x1 x2 => x1 ∩ x2) = fun x1 x2 => x1 ⊓ x2 | null | false |
Homotopy.shift._proof_5 | Mathlib.Algebra.Homology.HomotopyCategory.Shift | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Preadditive C]
{K L : CochainComplex C ℤ} {φ₁ φ₂ : K ⟶ L} (h : Homotopy φ₁ φ₂) (n i : ℤ),
((CategoryTheory.shiftFunctor (HomologicalComplex C (ComplexShape.up ℤ)) n).map φ₁).f i =
(((dNext i) fun x x_1 => n.negOnePow • h.hom... | null | false |
Int32.toInt64_div_of_ne_right | Init.Data.SInt.Lemmas | ∀ (a b : Int32), b ≠ -1 → (a / b).toInt64 = a.toInt64 / b.toInt64 | null | true |
ENNReal.instCommSemiring._proof_5 | Mathlib.Basic.ENNReal.Basic | ∀ (a : ENNReal), a * 1 = a | null | false |
CompositionAsSet.mk.sizeOf_spec | Mathlib.Combinatorics.Enumerative.Composition | ∀ {n : ℕ} (boundaries : Finset (Fin n.succ)) (zero_mem : 0 ∈ boundaries) (getLast_mem : Fin.last n ∈ boundaries),
sizeOf { boundaries := boundaries, zero_mem := zero_mem, getLast_mem := getLast_mem } =
1 + sizeOf boundaries + sizeOf zero_mem + sizeOf getLast_mem | null | true |
WeierstrassCurve.addSubMap_ne_zero | Mathlib.AlgebraicGeometry.EllipticCurve.Affine.AddSubMap | ∀ {R : Type u_1} [inst : CommRing R] (W : WeierstrassCurve R) [W.IsElliptic] [IsReduced R] {x : Fin 3 → R},
x ≠ 0 → (fun x_1 => (MvPolynomial.eval x) (W.addSubMap x_1)) ≠ 0 | null | true |
Algebra.compHom | Mathlib.Algebra.Algebra.Defs | {R : Type u} →
{S : Type v} →
(A : Type w) →
[inst : CommSemiring R] →
[inst_1 : CommSemiring S] → [inst_2 : Semiring A] → [Algebra R A] → (S →+* R) → Algebra S A | Compose an `Algebra` with a `RingHom`, with action `f s • m`.
This is the algebra version of `Module.compHom`.
| true |
List.eraseIdx_of_length_le | Init.Data.List.Erase | ∀ {α : Type u_1} {l : List α} {k : ℕ}, l.length ≤ k → l.eraseIdx k = l | null | true |
Graph.induce_isLink | Mathlib.Combinatorics.Graph.Delete | ∀ {α : Type u_1} {β : Type u_2} (G : Graph α β) (X : Set α) (e : β) (x y : α),
(G.induce X).IsLink e x y = (G.IsLink e x y ∧ x ∈ X ∧ y ∈ X) | null | true |
FinPartOrd | Mathlib.Order.Category.FinPartOrd | Type (u_1 + 1) | The category of finite partial orders with monotone functions. | true |
Mathlib.Meta.FunProp.DecompositionResult.casesOn | Mathlib.Tactic.FunProp.FunctionData | {motive : Mathlib.Meta.FunProp.DecompositionResult → Sort u} →
(t : Mathlib.Meta.FunProp.DecompositionResult) →
((f g : Lean.Expr) → motive (Mathlib.Meta.FunProp.DecompositionResult.comp f g)) →
motive Mathlib.Meta.FunProp.DecompositionResult.uncurried →
motive Mathlib.Meta.FunProp.DecompositionResu... | null | false |
_private.Mathlib.Analysis.SpecificLimits.FloorPow.0.mul_pow_le_nat_floor_pow._simp_1_3 | Mathlib.Analysis.SpecificLimits.FloorPow | ∀ {G : Type u_1} [inst : DivInvMonoid G] (a b : G), a * b⁻¹ = a / b | null | false |
_private.Mathlib.Order.Interval.Finset.Nat.0.Nat.Ico_succ_right_eq_insert_Ico._simp_1_1 | Mathlib.Order.Interval.Finset.Nat | ∀ {α : Type u_1} [inst : DecidableEq α] {s : Finset α} {a b : α}, (a ∈ insert b s) = (a = b ∨ a ∈ s) | null | false |
UInt64.toBitVec_one | Init.Data.UInt.Lemmas | UInt64.toBitVec 1 = 1#64 | null | true |
CategoryTheory.yoneda_obj_obj_eq_hom | Mathlib.CategoryTheory.Yoneda | {C : Type u₁} → [CategoryTheory.Category.{v₁, u₁} C] → C → C → C → C → Prop | Unification hint for `(yoneda.obj X).obj (op Y) = Y ⟶ X`. | true |
Lean.PrettyPrinter.FormatterM | Lean.PrettyPrinter.Formatter | Type → Type | null | true |
Lean.Lsp.ClientCapabilities.mk.sizeOf_spec | Lean.Data.Lsp.Capabilities | ∀ (textDocument? : Option Lean.Lsp.TextDocumentClientCapabilities) (window? : Option Lean.Lsp.WindowClientCapabilities)
(workspace? : Option Lean.Lsp.WorkspaceClientCapabilities) (lean? : Option Lean.Lsp.LeanClientCapabilities),
sizeOf { textDocument? := textDocument?, window? := window?, workspace? := workspace?, ... | null | true |
TopCat.Sheaf.interUnionPullbackCone | Mathlib.Topology.Sheaves.SheafCondition.PairwiseIntersections | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
{X : TopCat} →
(F : TopCat.Sheaf C X) →
(U V : TopologicalSpace.Opens ↑X) →
CategoryTheory.Limits.PullbackCone (F.obj.map (CategoryTheory.homOfLE ⋯).op)
(F.obj.map (CategoryTheory.homOfLE ⋯).op) | For a sheaf `F`, `F(U ⊔ V)` is the pullback of `F(U) ⟶ F(U ⊓ V)` and `F(V) ⟶ F(U ⊓ V)`.
This is the pullback cone. | true |
LieDerivation.ofGrading._proof_3 | Mathlib.Algebra.Lie.Graded | ∀ {ι : Type u_3} {R : Type u_2} {L : Type u_1} [inst : DecidableEq ι] [inst_1 : AddCommMonoid ι] [inst_2 : CommRing R]
[inst_3 : LieRing L] [inst_4 : LieAlgebra R L] (ℒ : ι → Submodule R L) [inst_5 : GradedLieAlgebra ℒ] (φ : ι →+ R)
(x y : L),
{
toFun := fun x =>
(DirectSum.decomposeLinearEquiv ... | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.