name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
Lean.Meta.FunIndParamKind.dropped.elim | Lean.Meta.Tactic.FunIndInfo | {motive : Lean.Meta.FunIndParamKind → Sort u} →
(t : Lean.Meta.FunIndParamKind) → t.ctorIdx = 0 → motive Lean.Meta.FunIndParamKind.dropped → motive t | null | false |
Lean.ProjectionFunctionInfo | Lean.ProjFns | Type | Given a structure `S`, Lean automatically creates an auxiliary definition (projection function)
for each field. This structure caches information about these auxiliary definitions.
| true |
LinearMap.vecEmpty_apply | Mathlib.LinearAlgebra.Pi | ∀ {R : Type u} {M : Type v} {M₃ : Type y} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : AddCommMonoid M₃]
[inst_3 : Module R M] [inst_4 : Module R M₃] (m : M), LinearMap.vecEmpty m = ![] | null | true |
Quiver.arborescenceMk._proof_1 | Mathlib.Combinatorics.Quiver.Arborescence | ∀ {V : Type u_1} [inst : Quiver V] (r : V) (height : V → ℕ),
(∀ ⦃a b : V⦄ (a_1 : a ⟶ b), height a < height b) →
(∀ (b : V), b = r ∨ ∃ a, Nonempty (a ⟶ b)) → ∀ (b : V), Nonempty (Quiver.Path r b) | null | false |
_private.Std.Sat.AIG.CNF.0.Std.Sat.AIG.toCNF.go._unary._proof_83 | Std.Sat.AIG.CNF | ∀ (aig : Std.Sat.AIG ℕ) (upper : ℕ) (h : upper < aig.decls.size) (state : Std.Sat.AIG.toCNF.State✝ aig)
(lhs rhs : Std.Sat.AIG.Fanin) (this : lhs.gate < upper ∧ rhs.gate < upper) (lstate : Std.Sat.AIG.toCNF.State✝ aig),
Std.Sat.AIG.toCNF.State.IsExtensionBy✝ state lstate lhs.gate ⋯ →
∀ (rstate : Std.Sat.AIG.toC... | null | false |
PMF.toMeasure_ofMultiset_apply | Mathlib.Probability.Distributions.Uniform | ∀ {α : Type u_2} [inst : MeasurableSpace α] [MeasurableSingletonClass α] {s : Multiset α} (a : α),
(MeasureTheory.Measure.ofMultiset s) {a} = ↑(Multiset.count a s) / ↑s.card | **Alias** of `MeasureTheory.Measure.ofMultiset_apply_singleton`. | true |
WithBot.one | Mathlib.Algebra.Order.Monoid.Unbundled.WithTop | {α : Type u} → [One α] → One (WithBot α) | null | true |
instMulActionElemFixedPointsSubtypeMemSubgroupOfNormal._aux_1 | Mathlib.GroupTheory.GroupAction.SubMulAction | {G : Type u_2} →
[inst : Group G] →
{α : Type u_1} →
[inst_1 : MulAction G α] →
{H : Subgroup G} → [hH : H.Normal] → G → ↑(MulAction.fixedPoints (↥H) α) → ↑(MulAction.fixedPoints (↥H) α) | null | false |
CategoryTheory.GrothendieckTopology.OneHypercoverFamily.IsSheafIff.isLimit | Mathlib.CategoryTheory.Sites.Hypercover.IsSheaf | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{J : CategoryTheory.GrothendieckTopology C} →
{A : Type u'} →
[inst_1 : CategoryTheory.Category.{v', u'} A] →
{H : J.OneHypercoverFamily} →
{P : CategoryTheory.Functor Cᵒᵖ A} →
(∀ ⦃X : C⦄ (E : J.OneHyperco... | Auxiliary definition for `OneHypercoverFamily.isSheaf_iff`. | true |
ChainComplex.prev | Mathlib.Algebra.Homology.HomologicalComplex | ∀ (α : Type u_2) [inst : AddRightCancelSemigroup α] [inst_1 : One α] (i : α), (ComplexShape.down α).prev i = i + 1 | null | true |
AlgebraicGeometry.Scheme.coe_homeoOfIso | Mathlib.AlgebraicGeometry.Scheme | ∀ {X Y : AlgebraicGeometry.Scheme} (e : X ≅ Y), ⇑(AlgebraicGeometry.Scheme.homeoOfIso e) = ⇑e.hom | null | true |
ZeroAtInftyContinuousMap.instNonUnitalNormedRing._proof_2 | Mathlib.Topology.ContinuousMap.ZeroAtInfty | ∀ {α : Type u_1} {β : Type u_2} [inst : TopologicalSpace α] [inst_1 : NonUnitalNormedRing β]
(x y : ZeroAtInftyContinuousMap α β), dist x y = ‖-x + y‖ | null | false |
CategoryTheory.Limits.mapPair._proof_11 | Mathlib.CategoryTheory.Limits.Shapes.BinaryProducts.WalkingPair | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C]
{F G : CategoryTheory.Functor (CategoryTheory.Discrete CategoryTheory.Limits.WalkingPair) C}
(f : F.obj { as := CategoryTheory.Limits.WalkingPair.left } ⟶ G.obj { as := CategoryTheory.Limits.WalkingPair.left })
(g :
F.obj { as := CategoryTheory.Li... | null | false |
_private.Mathlib.MeasureTheory.Function.Piecewise.0.IndexedPartition.stronglyMeasurable_piecewise._simp_1_7 | Mathlib.MeasureTheory.Function.Piecewise | ∀ {n : ℕ} {a b : Fin n}, (a = b) = (↑a = ↑b) | null | false |
autEquivZmod._proof_1 | Mathlib.FieldTheory.KummerExtension | ∀ {K : Type u_1} [inst : Field K] {n : ℕ} {a : K},
Irreducible (Polynomial.X ^ n - Polynomial.C a) → ∀ {ζ : K}, IsPrimitiveRoot ζ n → ∃ x, x ∈ primitiveRoots n K | null | false |
CategoryTheory.Presieve.hasPullback | Mathlib.CategoryTheory.Sites.Sieves.Presieve | ∀ {C : Type u₁} {inst : CategoryTheory.Category.{v₁, u₁} C} {X : C} {R : CategoryTheory.Presieve X} {Y : C} (f : Y ⟶ X)
[self : R.HasPullbacks f] {Z : C} {h : Z ⟶ X}, R h → CategoryTheory.Limits.HasPullback h f | **Alias** of `CategoryTheory.Presieve.HasPullbacks.hasPullback`. | true |
Lean.Parser.TokenCacheEntry.startPos | Lean.Parser.Types | Lean.Parser.TokenCacheEntry → String.Pos.Raw | null | true |
selfAdjoint.instCommRingSubtypeMemAddSubgroup._proof_9 | Mathlib.Algebra.Star.SelfAdjoint | ∀ {R : Type u_1} [inst : CommRing R] [inst_1 : StarRing R] (x y : ↥(selfAdjoint R)), ↑(x - y) = ↑x - ↑y | null | false |
CategoryTheory.PullbackShift.functor.eq_1 | 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) {D : Type u_4}
[inst_4 : CategoryTheory.Category.{v_2, u_4} D] [inst_5 : CategoryTheory.HasShift D B]
(F : CategoryTheory.F... | null | true |
NonAssocSemiring.natCast_succ | Mathlib.Algebra.Ring.Defs | ∀ {α : Type u} [self : NonAssocSemiring α] (n : ℕ), ↑(n + 1) = ↑n + 1 | The canonical map `ℕ → R` is a homomorphism. | true |
Vector.not_mem_range_self | Init.Data.Vector.Range | ∀ {n : ℕ}, n ∉ Vector.range n | null | true |
CategoryTheory.SingleFunctors.postcompPostcompIso_inv_hom_app | Mathlib.CategoryTheory.Shift.SingleFunctors | ∀ {C : Type u_1} {D : Type u_2} {E : Type u_3} {E' : Type u_4} [inst : CategoryTheory.Category.{v_1, u_1} C]
[inst_1 : CategoryTheory.Category.{v_2, u_2} D] [inst_2 : CategoryTheory.Category.{v_3, u_3} E]
[inst_3 : CategoryTheory.Category.{v_4, u_4} E'] {A : Type u_5} [inst_4 : AddMonoid A]
[inst_5 : CategoryTheo... | null | true |
_private.Init.Data.BitVec.Lemmas.0.BitVec.toNat_shiftConcat_eq_of_lt._proof_1_2 | Init.Data.BitVec.Lemmas | ∀ {w : ℕ} {x : BitVec w} {k : ℕ}, x.toNat < 2 ^ k → 2 ^ k * 2 ≤ 2 ^ w → ¬x.toNat * 2 < 2 ^ w → False | null | false |
ContinuousWithinAt.insert | Mathlib.Topology.ContinuousOn | ∀ {α : Type u_1} {β : Type u_2} [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β] {f : α → β} {s : Set α}
{x : α}, ContinuousWithinAt f s x → ContinuousWithinAt f (insert x s) x | **Alias** of the reverse direction of `continuousWithinAt_insert_self`. | true |
ArchimedeanClass.stdPart_add_eq_left | Mathlib.Algebra.Order.Ring.StandardPart | ∀ {K : Type u_1} [inst : LinearOrder K] [inst_1 : Field K] [inst_2 : IsOrderedRing K] {x y : K},
0 < ArchimedeanClass.mk y → ArchimedeanClass.stdPart (x + y) = ArchimedeanClass.stdPart x | null | true |
_private.Init.Data.BitVec.Bitblast.0.BitVec.msb_sdiv_eq_decide._simp_1_3 | Init.Data.BitVec.Bitblast | ∀ {α : Type u_1} [inst : BEq α] [LawfulBEq α] {a b : α}, ((a == b) = true) = (a = b) | null | false |
_private.Mathlib.Computability.EpsilonNFA.0.εNFA.mem_evalFrom_iff_exists_path.match_1_1 | Mathlib.Computability.EpsilonNFA | ∀ {α : Type u_1} {σ : Type u_2} (M : εNFA α σ) {s₁ s₂ : σ}
(motive : (∃ n, M.IsPath s₁ s₂ (List.replicate n none)) → Prop) (h : ∃ n, M.IsPath s₁ s₂ (List.replicate n none)),
(∀ (n : ℕ) (h : M.IsPath s₁ s₂ (List.replicate n none)), motive ⋯) → motive h | null | false |
_private.Mathlib.Algebra.Homology.SpectralObject.HasSpectralSequence.0.CategoryTheory.Abelian.SpectralObject.instHasSpectralSequenceFinHAddNatOfNatProdIntCoreE₂CohomologicalFin._proof_7 | Mathlib.Algebra.Homology.SpectralObject.HasSpectralSequence | ∀ {l : ℕ} (k t : ℕ), k + 1 + t < l → t < l | null | false |
CategoryTheory.Limits.evaluationJointlyReflectsLimits._proof_2 | Mathlib.CategoryTheory.Limits.FunctorCategory.Basic | ∀ {C : Type u_3} [inst : CategoryTheory.Category.{u_2, u_3} C] {J : Type u_6}
[inst_1 : CategoryTheory.Category.{u_5, u_6} J] {K : Type u_1} [inst_2 : CategoryTheory.Category.{u_4, u_1} K]
{F : CategoryTheory.Functor J (CategoryTheory.Functor K C)} (c : CategoryTheory.Limits.Cone F)
(t : (k : K) → CategoryTheory.... | null | false |
AddEquiv.instUnique.eq_1 | Mathlib.Algebra.Group.Equiv.Basic | ∀ {M : Type u_15} {N : Type u_16} [inst : Unique M] [inst_1 : Unique N] [inst_2 : Add M] [inst_3 : Add N],
AddEquiv.instUnique = { default := AddEquiv.ofUnique, uniq := ⋯ } | null | true |
_private.Batteries.Data.List.Lemmas.0.List.countPBefore_cons_succ._proof_1_1 | Batteries.Data.List.Lemmas | ∀ {α : Type u_1} {xs : List α} {p : α → Bool} {i : ℕ} {a : α},
List.countPBefore p (a :: xs) (i + 1) = if p a = true then List.countPBefore p xs i + 1 else List.countPBefore p xs i | null | false |
AddMonoidAlgebra.rTensorEquivAlgEquiv.invFun | Mathlib.RingTheory.TensorProduct.MonoidAlgebra | {R : Type u_1} →
{M : Type u_2} →
{S : Type u_4} →
{A : Type u_5} →
{B : Type u_6} →
[inst : CommSemiring R] →
[inst_1 : CommSemiring S] →
[inst_2 : CommSemiring A] →
[inst_3 : CommSemiring B] →
[inst_4 : Algebra R S] →
... | Implementation detail. | true |
_private.Init.Data.String.Extra.0.String.removeNumLeadingSpaces | Init.Data.String.Extra | ℕ → String → String | null | true |
_private.Mathlib.Data.List.Basic.0.List.eq_cons_of_length_one._proof_1_6 | Mathlib.Data.List.Basic | ∀ {α : Type u_1} {l : List α} (h : l.length = 1) (n : ℕ), n + 1 ≤ [l.get ⟨0, ⋯⟩].length → ¬n = 0 → n - 1 < [].length | null | false |
MeasureTheory.SimpleFunc.instNonUnitalNonAssocSemiring._proof_4 | Mathlib.MeasureTheory.Function.SimpleFunc | ∀ {α : Type u_1} {β : Type u_2} [inst : MeasurableSpace α] [inst_1 : NonUnitalNonAssocSemiring β]
(a : MeasureTheory.SimpleFunc α β), a * 0 = 0 | null | false |
Complex.tanh_ofReal_im | Mathlib.Analysis.Complex.Trigonometric | ∀ (x : ℝ), (Complex.tanh ↑x).im = 0 | null | true |
Field.FG.mk | Mathlib.Algebra.Field.Subfield.Basic | ∀ {L : Type v} [inst : DivisionRing L], (∃ S, Subfield.closure ↑S = ⊤) → Field.FG L | null | true |
Mathlib.Tactic.Abel.abelConv | 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 |
CategoryTheory.Limits.BinaryBicones.functoriality | Mathlib.CategoryTheory.Limits.Shapes.BinaryBiproducts | {C : Type uC} →
[inst : CategoryTheory.Category.{uC', uC} C] →
[inst_1 : CategoryTheory.Limits.HasZeroMorphisms C] →
{D : Type uD} →
[inst_2 : CategoryTheory.Category.{uD', uD} D] →
[inst_3 : CategoryTheory.Limits.HasZeroMorphisms D] →
(P Q : C) →
(F : CategoryThe... | A functor `F : C ⥤ D` sends binary bicones for `P` and `Q`
to binary bicones for `G.obj P` and `G.obj Q` functorially. | true |
EuclideanGeometry.tendsto_inversion_nhdsNE_center_cobounded | Mathlib.Geometry.Euclidean.Inversion.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] {c : P} {R : ℝ},
R ≠ 0 → Filter.Tendsto (EuclideanGeometry.inversion c R) (nhdsWithin c {c}ᶜ) (Bornology.cobounded P) | The inversion of a point tends to infinity as it approaches the center of an inversion. | true |
Aesop.RappData.metaState | Aesop.Tree.Data | {Goal MVarCluster : Type} → Aesop.RappData Goal MVarCluster → Lean.Meta.SavedState | null | true |
AddValuation.comap_id | Mathlib.RingTheory.Valuation.Basic | ∀ {R : Type u_3} {Γ₀ : Type u_4} [inst : Ring R] [inst_1 : LinearOrderedAddCommMonoidWithTop Γ₀]
(v : AddValuation R Γ₀), AddValuation.comap (RingHom.id R) v = v | null | true |
Associated.neg_neg | Mathlib.Algebra.Ring.Associated | ∀ {M : Type u_1} [inst : Monoid M] [inst_1 : HasDistribNeg M] {a b : M}, Associated a b → Associated (-a) (-b) | null | true |
FirstOrder.Language.ElementaryEmbedding.toEmbedding._proof_2 | Mathlib.ModelTheory.ElementaryMaps | ∀ {L : FirstOrder.Language} {M : Type u_4} {N : Type u_3} [inst : L.Structure M] [inst_1 : L.Structure N]
(f : L.ElementaryEmbedding M N) {x : ℕ} (R : L.Relations x) (x_1 : Fin x → M),
FirstOrder.Language.Structure.RelMap R (⇑f ∘ x_1) ↔ FirstOrder.Language.Structure.RelMap R x_1 | null | false |
LinearMap.BilinForm.toLinHomAux₁ | Mathlib.LinearAlgebra.BilinearForm.Hom | {R : Type u_1} →
{M : Type u_2} →
[inst : CommSemiring R] →
[inst_1 : AddCommMonoid M] → [inst_2 : Module R M] → LinearMap.BilinForm R M → M → M →ₗ[R] R | Auxiliary definition to define `toLinHom`; see below. | true |
mabs_le | Mathlib.Algebra.Order.Group.Abs | ∀ {G : Type u_1} [inst : CommGroup G] [inst_1 : LinearOrder G] [IsOrderedMonoid G] {a b : G}, |a|ₘ ≤ b ↔ b⁻¹ ≤ a ∧ a ≤ b | null | true |
PresheafOfModules.Sheafify.map_smul_eq | Mathlib.Algebra.Category.ModuleCat.Presheaf.Sheafify | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {J : CategoryTheory.GrothendieckTopology C}
{R₀ : CategoryTheory.Functor Cᵒᵖ RingCat} {R : CategoryTheory.Sheaf J RingCat} (α : R₀ ⟶ R.obj)
[inst_1 : CategoryTheory.Presheaf.IsLocallyInjective J α] [inst_2 : CategoryTheory.Presheaf.IsLocallySurjective J α]... | null | true |
Equiv.piCongrFiberwise_apply | Mathlib.Logic.Equiv.Basic | ∀ {α : Type u_8} {β : Type u_9} {γ₁ : α → Type u_10} {γ₂ : β → Type u_11} {f : α → β}
(e : (b : β) → ((σ : { a // f a = b }) → γ₁ ↑σ) ≃ γ₂ b) (g : (a : α) → γ₁ a) (b : β),
(Equiv.piCongrFiberwise e) g b = (e b) fun σ => g ↑σ | null | true |
_private.Batteries.Recycling.RBTree.Alter.0.RBTree.RBNode.Path.Balanced.del.match_1_3 | Batteries.Recycling.RBTree.Alter | ∀ {α : Type u_1} {c₀ : RBTree.RBColor} {n₀ : ℕ} {y : RBTree.RBNode α} {parent : RBTree.RBNode.Path α}
{t : RBTree.RBNode α}
(motive :
(c' : RBTree.RBColor) →
(n : ℕ) →
RBTree.RBNode.DelProp c' t n →
y.Balanced RBTree.RBColor.black n →
RBTree.RBNode.Path.Balanced c₀ n₀ parent ... | null | false |
continuous_inf_dom_left₂ | Mathlib.Topology.Constructions.SumProd | ∀ {X : Type u_5} {Y : Type u_6} {Z : Type u_7} {f : X → Y → Z} {ta1 ta2 : TopologicalSpace X}
{tb1 tb2 : TopologicalSpace Y} {tc1 : TopologicalSpace Z},
(Continuous fun p => f p.1 p.2) → Continuous fun p => f p.1 p.2 | A version of `continuous_inf_dom_left` for binary functions | true |
CategoryTheory.IsReflexivePair.mk | Mathlib.CategoryTheory.Limits.Shapes.Reflexive | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {A B : C} {f g : A ⟶ B},
(∃ s,
CategoryTheory.CategoryStruct.comp s f = CategoryTheory.CategoryStruct.id B ∧
CategoryTheory.CategoryStruct.comp s g = CategoryTheory.CategoryStruct.id B) →
CategoryTheory.IsReflexivePair f g | null | true |
MeasureTheory.IsSeparable | Mathlib.MeasureTheory.Measure.SeparableMeasure | {X : Type u_1} → [m : MeasurableSpace X] → MeasureTheory.Measure X → Prop | A measure `μ` is separable if there exists a countable and measure-dense family of sets.
The term "separable" is justified by the fact that the definition translates to the usual notion
of separability in the metric space made by constant indicators equipped with the `Lᵖ` norm. | true |
Fin.liftFun_cons | Mathlib.Order.Fin.Tuple | ∀ {α : Type u_1} {n : ℕ} (r : α → α → Prop) [IsTrans α r] {f : Fin n → α} {a : α},
Relator.LiftFun (fun x1 x2 => x1 < x2) r (Fin.cons a f) (Fin.cons a f) ↔
(∀ (i : Fin n), r a (f i)) ∧ Relator.LiftFun (fun x1 x2 => x1 < x2) r f f | null | true |
one_lt_leOnePart._simp_2 | Mathlib.Algebra.Order.Group.PosPart | ∀ {α : Type u_1} [inst : Lattice α] [inst_1 : Group α] {a : α} [MulLeftMono α], a < 1 → (1 < a⁻ᵐ) = True | null | false |
_private.Lean.Parser.Command.0.Lean.Parser.Command.declaration._regBuiltin.Lean.Parser.Command.meta.formatter_21 | Lean.Parser.Command | IO Unit | null | false |
Affine.Simplex.incenter_notMem_affineSpan_faceOpposite | 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.incenter ∉ affineSpan ℝ (Set.range (s.faceOpposite i).points) | null | true |
CategoryTheory.MorphismProperty.FunctorialFactorizationData.mapZ_comp_assoc | Mathlib.CategoryTheory.MorphismProperty.Factorization | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {W₁ W₂ : CategoryTheory.MorphismProperty C}
(data : W₁.FunctorialFactorizationData W₂) {X Y X' Y' : C} {f : X ⟶ Y} {g : X' ⟶ Y'}
(φ : CategoryTheory.Arrow.mk f ⟶ CategoryTheory.Arrow.mk g) {X'' Y'' : C} {h : X'' ⟶ Y''}
(ψ : CategoryTheory.Arrow.mk g ⟶... | null | true |
AddMonoid.End.coe_one | Mathlib.Algebra.Group.Hom.Defs | ∀ (M : Type u_4) [inst : AddZero M], ⇑1 = id | null | true |
String.Slice.Pos.startInclusive_le_str | Init.Data.String.Basic | ∀ {s : String.Slice} {pos : s.Pos}, s.startInclusive ≤ pos.str | null | true |
CategoryTheory.IsExponentiable | Mathlib.CategoryTheory.LocallyCartesianClosed.ExponentiableMorphism | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] → [CategoryTheory.ChosenPullbacks C] → CategoryTheory.MorphismProperty C | A morphism `f : I ⟶ J` is exponentiable if the pullback functor `Over J ⥤ Over I`
has a right adjoint. | true |
AddCommMonoid.zmodModule._proof_1 | Mathlib.Algebra.Module.ZMod | ∀ {n : ℕ} {M : Type u_1} [inst : AddCommMonoid M],
(∀ (x : M), n • x = 0) → ∀ (c : ℕ) (x : M), (c % n + c / n * n) • x = c • x → (c % n) • x = c • x | null | false |
_private.Mathlib.GroupTheory.Perm.Cycle.Type.0.Equiv.Perm.card_fixedPoints_modEq._simp_1_1 | Mathlib.GroupTheory.Perm.Cycle.Type | ∀ {α : Type u} {a b : Set α}, (a = b) = ∀ (x : α), x ∈ a ↔ x ∈ b | null | false |
Filter.limsSup | Mathlib.Order.LiminfLimsup | {α : Type u_1} → [ConditionallyCompleteLattice α] → Filter α → α | The `limsSup` of a filter `f` is the infimum of the `a` such that the inequality
`x ≤ a` eventually holds for `f`. | true |
CategoryTheory.Limits.MultispanIndex.ι_fstSigmaMap_assoc | Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {J : CategoryTheory.Limits.MultispanShape}
(I : CategoryTheory.Limits.MultispanIndex J C) [inst_1 : CategoryTheory.Limits.HasCoproduct I.left]
[inst_2 : CategoryTheory.Limits.HasCoproduct I.right] (b : J.L) {Z : C} (h : ∐ I.right ⟶ Z),
CategoryTheory.Catego... | null | true |
RCLike.continuous_ofReal | Mathlib.Analysis.RCLike.Basic | ∀ {K : Type u_1} [inst : RCLike K], Continuous RCLike.ofReal | null | true |
_private.Init.Data.Range.Polymorphic.Lemmas.0.Std.Rco.Internal.toList_eq_toList_iter | Init.Data.Range.Polymorphic.Lemmas | ∀ {α : Type u} [inst : LT α] [inst_1 : DecidableLT α] [inst_2 : Std.PRange.UpwardEnumerable α]
[inst_3 : Std.Rxo.IsAlwaysFinite α] [inst_4 : Std.PRange.LawfulUpwardEnumerable α] {r : Std.Rco α},
r.toList = (Std.Rco.Internal.iter r).toList | null | true |
CategoryTheory.ShortComplex.SnakeInput.L₀X₂ToP_comp_pullback_snd | Mathlib.Algebra.Homology.ShortComplex.SnakeLemma | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Abelian C]
(S : CategoryTheory.ShortComplex.SnakeInput C),
CategoryTheory.CategoryStruct.comp S.L₀X₂ToP (CategoryTheory.Limits.pullback.snd S.L₁.g S.v₀₁.τ₃) = S.L₀.g | null | true |
AddEquiv.opOp | Mathlib.Algebra.Group.Equiv.Opposite | (M : Type u_3) → [inst : Add M] → M ≃+ Mᵃᵒᵖᵃᵒᵖ | An additive monoid is isomorphic to the opposite of its opposite. | true |
Finset.Nontrivial.instDecidablePred._proof_3 | Mathlib.Data.Finset.Insert | ∀ {α : Type u_1} (h : Multiset.Nodup ⟦[]⟧), ¬{ val := ⟦[]⟧, nodup := h }.Nontrivial | null | false |
rootsOfUnityEquivNthRoots._proof_6 | Mathlib.RingTheory.RootsOfUnity.Basic | ∀ (R : Type u_1) (k : ℕ) [inst : NeZero k] [inst_1 : CommRing R] [inst_2 : IsDomain R]
(x : { x // x ∈ Polynomial.nthRoots k 1 }),
{ val := ↑x, inv := ↑x ^ (k - 1), val_inv := ⋯, inv_val := ⋯ } ∈ rootsOfUnity k R | null | false |
Action.diagonalSuccIsoTensorTrivial._proof_2 | Mathlib.CategoryTheory.Action.Monoidal | ∀ (G : Type u_1) [inst : Group G] (n : ℕ) (x : G),
CategoryTheory.CategoryStruct.comp
((Action.trivial G
(CategoryTheory.MonoidalCategoryStruct.tensorObj (Action.leftRegular G)
(Action.trivial G (Fin n → G))).V).ρ
x).asHom
(Fin.insertNthEquiv (fun x => G) 0).toIso... | null | false |
Matrix.toBilin' | Mathlib.LinearAlgebra.Matrix.BilinearForm | {R₁ : Type u_1} →
[inst : CommSemiring R₁] →
{n : Type u_5} → [Fintype n] → [DecidableEq n] → Matrix n n R₁ ≃ₗ[R₁] LinearMap.BilinForm R₁ (n → R₁) | The linear equivalence between `n × n` matrices and bilinear forms on `n → R` | true |
PowerSeries.coeff_expand_mul | Mathlib.RingTheory.PowerSeries.Expand | ∀ {R : Type u_2} [inst : CommRing R] (p : ℕ) (hp : p ≠ 0) (φ : PowerSeries R) (m : ℕ),
(PowerSeries.coeff (p * m)) ((PowerSeries.expand p hp) φ) = (PowerSeries.coeff m) φ | null | true |
Lean.Meta.TransparencyMode._sizeOf_1 | Init.MetaTypes | Lean.Meta.TransparencyMode → ℕ | null | false |
instAddCommGroupUniformOnFun.eq_1 | Mathlib.Topology.Algebra.UniformConvergence | ∀ {α : Type u_1} {β : Type u_2} {𝔖 : Set (Set α)} [inst : AddCommGroup β],
instAddCommGroupUniformOnFun = { toAddGroup := instAddGroupUniformOnFun, add_comm := ⋯ } | null | true |
Order.Ioo_succ_right_eq_insert | Mathlib.Order.SuccPred.Basic | ∀ {α : Type u_1} [inst : LinearOrder α] [inst_1 : SuccOrder α] {a b : α} [NoMaxOrder α],
a < b → Set.Ioo a (Order.succ b) = insert b (Set.Ioo a b) | null | true |
Lex.instZero | Mathlib.Algebra.Order.Group.Synonym | {α : Type u_1} → [Zero α] → Zero (Lex α) | null | true |
OrderIso.limsup_apply | Mathlib.Order.LiminfLimsup | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_6} [inst : ConditionallyCompleteLattice β]
[inst_1 : ConditionallyCompleteLattice γ] {f : Filter α} {u : α → β} (g : β ≃o γ),
autoParam (Filter.IsBoundedUnder (fun x1 x2 => x1 ≤ x2) f u) OrderIso.limsup_apply._auto_1 →
autoParam (Filter.IsCoboundedUnder (fun x1 x2 => ... | null | true |
Stream'.WSeq.findIndexes.match_1 | Mathlib.Data.WSeq.Defs | {α : Type u_1} → (motive : α × ℕ → Sort u_2) → (x : α × ℕ) → ((a : α) → (n : ℕ) → motive (a, n)) → motive x | null | false |
HomologicalComplex.prepathObject._proof_5 | Mathlib.Algebra.Homology.Precylinder | ∀ {C : Type u_3} [inst : CategoryTheory.Category.{u_2, u_3} C] [inst_1 : CategoryTheory.Preadditive C] {ι : Type u_1}
{c : ComplexShape ι} [inst_2 : DecidableRel c.Rel] (K : HomologicalComplex C c)
[inst_3 : ∀ (i : ι), CategoryTheory.Limits.HasBinaryBiproduct (K.X i) (K.X i)] [inst_4 : K.HasPathObject],
CategoryT... | null | false |
Int.natAbs_natCast_sub_natCast_of_ge | Mathlib.Data.Int.NatAbs | ∀ {a b : ℕ}, b ≤ a → (↑a - ↑b).natAbs = a - b | null | true |
LinearMap.lcompₛₗ.eq_1 | Mathlib.LinearAlgebra.BilinearMap | ∀ {R : Type u_14} {R₂ : Type u_15} {R₃ : Type u_16} (R₅ : Type u_18) {M : Type u_19} {N : Type u_20} (P : Type u_21)
[inst : Semiring R] [inst_1 : Semiring R₂] [inst_2 : Semiring R₃] [inst_3 : Semiring R₅] {σ₁₂ : R →+* R₂}
(σ₂₃ : R₂ →+* R₃) {σ₁₃ : R →+* R₃} [inst_4 : AddCommMonoid M] [inst_5 : AddCommMonoid N] [ins... | null | true |
CategoryTheory.Limits.WalkingMulticospan.instSmallCategory._proof_3 | Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer | ∀ {J : CategoryTheory.Limits.MulticospanShape} {W X Y Z : CategoryTheory.Limits.WalkingMulticospan J} (f : W.Hom X)
(g : X.Hom Y) (h : Y.Hom Z), (f.comp g).comp h = f.comp (g.comp h) | null | false |
Subsemiring.topologicalClosure._proof_5 | Mathlib.Topology.Algebra.Ring.Basic | ∀ {R : Type u_1} [inst : TopologicalSpace R] [inst_1 : Semiring R] [inst_2 : IsSemitopologicalSemiring R]
(s : Subsemiring R) {a b : R},
a ∈ s.toAddSubmonoid.topologicalClosure.carrier →
b ∈ s.toAddSubmonoid.topologicalClosure.carrier → a + b ∈ s.toAddSubmonoid.topologicalClosure.carrier | null | false |
Mathlib.Linter.Style.lambdaSyntax.findLambdaSyntax | Mathlib.Tactic.Linter.Style | Lean.Syntax → Array Lean.Syntax | `findLambdaSyntax stx` extracts from `stx` all syntax nodes of `kind` `Term.fun`. | true |
Lean.Compiler.LCNF.Simp.CtorInfo.recOn | Lean.Compiler.LCNF.Simp.DiscrM | {motive : Lean.Compiler.LCNF.Simp.CtorInfo → Sort u} →
(t : Lean.Compiler.LCNF.Simp.CtorInfo) →
((val : Lean.ConstructorVal) →
(args : Array (Lean.Compiler.LCNF.Arg Lean.Compiler.LCNF.Purity.pure)) →
motive (Lean.Compiler.LCNF.Simp.CtorInfo.ctor val args)) →
((n : ℕ) → motive (Lean.Compile... | null | false |
Submodule.isIdempotentElem_projection._simp_1 | Mathlib.LinearAlgebra.Projection | ∀ {R : Type u_1} [inst : Ring R] {E : Type u_2} [inst_1 : AddCommGroup E] [inst_2 : Module R E] {p q : Submodule R E}
(hpq : IsCompl p q), IsIdempotentElem (p.projection q hpq) = True | null | false |
Bool.not_bijective | Mathlib.Logic.Equiv.Bool | Function.Bijective not | null | true |
ContinuousLinearMap.rangeRestrict._proof_1 | Mathlib.Topology.Algebra.Module.ContinuousLinearMap.Restrict | ∀ {R₁ : Type u_3} {R₂ : Type u_2} [inst : Semiring R₁] [inst_1 : Semiring R₂] {σ₁₂ : R₁ →+* R₂} {M₁ : Type u_4}
{M₂ : Type u_1} [inst_2 : TopologicalSpace M₁] [inst_3 : AddCommMonoid M₁] [inst_4 : Module R₁ M₁]
[inst_5 : TopologicalSpace M₂] [inst_6 : AddCommMonoid M₂] [inst_7 : Module R₂ M₂] [inst_8 : RingHomSurje... | null | false |
_private.Mathlib.Tactic.Matrix.ListMatrix.0.Mathlib.Tactic.Matrix.ListMatrix.getD_mul._proof_1_14 | Mathlib.Tactic.Matrix.ListMatrix | ∀ {α : Type u_1} {l i : ℕ} (A : List (List α)),
i < l → ¬-1 * ↑l + ↑A.length ≤ 0 → ¬i + 1 ≤ A.length → i - A.length < (List.replicate (l - A.length) []).length | null | false |
CategoryTheory.Limits.instDecidableEqWalkingParallelFamily._proof_1 | Mathlib.CategoryTheory.Limits.Shapes.WideEqualizers | ∀ {J : Type u_1}, CategoryTheory.Limits.WalkingParallelFamily.zero = CategoryTheory.Limits.WalkingParallelFamily.zero | null | false |
not_lt_of_ge | Mathlib.Order.Defs.PartialOrder | ∀ {α : Type u_1} [inst : Preorder α] {a b : α}, a ≤ b → ¬b < a | null | true |
groupCohomology.cochainsMap_id_f_map_mono | Mathlib.RepresentationTheory.Homological.GroupCohomology.Functoriality | ∀ {k G : Type u} [inst : CommRing k] [inst_1 : Group G] {A B : Rep.{u, u, u} k G} (φ : A ⟶ B) [CategoryTheory.Mono φ]
(i : ℕ), CategoryTheory.Mono ((groupCohomology.cochainsMap (MonoidHom.id G) φ).f i) | null | true |
CochainComplex.isoHomologyπ₀._proof_1 | Mathlib.Algebra.Homology.ShortComplex.HomologicalComplex | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
(K : CochainComplex C ℕ), K.d ((ComplexShape.up ℕ).prev 0) 0 = 0 | null | false |
map_prod | Mathlib.Algebra.BigOperators.Group.Finset.Defs | ∀ {ι : Type u_1} {M : Type u_3} {N : Type u_4} [inst : CommMonoid M] [inst_1 : CommMonoid N] {G : Type u_7}
[inst_2 : FunLike G M N] [MonoidHomClass G M N] (g : G) (f : ι → M) (s : Finset ι),
g (∏ x ∈ s, f x) = ∏ x ∈ s, g (f x) | null | true |
_private.Init.Data.BitVec.Lemmas.0.BitVec.getMsbD_extractLsb._proof_1_2 | Init.Data.BitVec.Lemmas | ∀ {w hi lo i : ℕ},
i < hi - lo + 1 →
lo + (hi - lo + 1 - 1 - i) < w →
w - 1 - (lo + (hi - lo + 1 - 1 - i)) = w - 1 - (max hi lo - i) → ¬(i < hi - lo + 1 ∧ max hi lo - i < w) → False | null | false |
Std.Http.Header.ContentLength.length | Std.Http.Data.Headers.Basic | Std.Http.Header.ContentLength → ℕ | The content length in bytes.
| true |
CochainComplex.shiftFunctorObjXIso.congr_simp | Mathlib.Algebra.Homology.HomotopyCategory.HomComplexShift | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Preadditive C]
(K : CochainComplex C ℤ) (n i m : ℤ) (hm : m = i + n), K.shiftFunctorObjXIso n i m hm = K.shiftFunctorObjXIso n i m hm | null | true |
_private.Lean.Util.UnusedBinders.0.Lean.Expr.hasUnusedForallBindersWhere._sparseCasesOn_1 | Lean.Util.UnusedBinders | {motive : Lean.Expr → Sort u} →
(t : Lean.Expr) →
((binderName : Lean.Name) →
(binderType body : Lean.Expr) →
(binderInfo : Lean.BinderInfo) → motive (Lean.Expr.forallE binderName binderType body binderInfo)) →
((declName : Lean.Name) →
(type value body : Lean.Expr) → (nondep : B... | null | false |
mabs_eq_max_inv | Mathlib.Algebra.Order.Group.Unbundled.Abs | ∀ {α : Type u_1} [inst : Group α] [inst_1 : LinearOrder α] {a : α}, |a|ₘ = max a a⁻¹ | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.