name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11.5k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
add_neg_lt_iff_lt_add | Mathlib.Algebra.Order.Group.Unbundled.Basic | ∀ {α : Type u} [inst : AddGroup α] [inst_1 : LT α] [AddRightStrictMono α] {a b c : α}, a + -b < c ↔ a < c + b | null | true |
instHasColimitsCommAlgCat | Mathlib.Algebra.Category.CommAlgCat.Basic | ∀ {R : Type u} [inst : CommRing R], CategoryTheory.Limits.HasColimits (CommAlgCat R) | null | true |
Algebra.ctorIdx | Mathlib.Algebra.Algebra.Defs | {R : Type u} → {A : Type v} → {inst : CommSemiring R} → {inst_1 : Semiring A} → Algebra R A → ℕ | null | false |
CategoryTheory.GrothendieckTopology.Cover.Arrow.precompRelation._proof_2 | Mathlib.CategoryTheory.Sites.Grothendieck | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {X : C} {J : CategoryTheory.GrothendieckTopology C}
{S : J.Cover X} (I : S.Arrow) {Z : C} (g : Z ⟶ I.Y),
CategoryTheory.CategoryStruct.comp (CategoryTheory.CategoryStruct.id (I.precomp g).Y) (I.precomp g).f =
CategoryTheory.CategoryStruct.comp g I.f | null | false |
BitVec.toInt_not | Init.Data.BitVec.Lemmas | ∀ {w : ℕ} {x : BitVec w}, (~~~x).toInt = (2 ^ w - 1 - ↑x.toNat).bmod (2 ^ w) | null | true |
CategoryTheory.MorphismProperty.colimitsOfShape_discrete_le_llp_rlp | Mathlib.CategoryTheory.MorphismProperty.LiftingProperty | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (T : CategoryTheory.MorphismProperty C) (J : Type w),
T.colimitsOfShape (CategoryTheory.Discrete J) ≤ T.rlp.llp | null | true |
Locale.localePointOfSpacePoint._proof_3 | Mathlib.Topology.Order.Category.FrameAdjunction | ∀ (X : Type u_1) [inst : TopologicalSpace X] (x : X), (x ∈ ⊤) = (x ∈ ⊤) | null | false |
IsDivSequence | Mathlib.NumberTheory.EllipticDivisibilitySequence | {R : Type u} → [CommRing R] → (ℤ → R) → Prop | The proposition that a sequence indexed by integers is a divisibility sequence. | true |
String.toList.eq_1 | Init.Data.String.Basic | ∀ (s : String), s.toList = (String.Internal.toArray s).toList | null | true |
SchwartzMap.evalCLM._proof_3 | Mathlib.Analysis.Distribution.SchwartzSpace.Basic | ∀ (𝕜 : Type u_1) (G : Type u_2) [inst : NormedField 𝕜] [inst_1 : NormedAddCommGroup G] [inst_2 : NormedSpace 𝕜 G],
ContinuousConstSMul 𝕜 G | null | false |
_private.Mathlib.Analysis.Complex.Norm.0.Complex.abs_re_div_norm_le_one._simp_1_1 | Mathlib.Analysis.Complex.Norm | ∀ {α : Type u_1} [inst : Zero α] [inst_1 : One α] [inst_2 : LE α] [ZeroLEOneClass α], (0 ≤ 1) = True | null | false |
CoxeterMatrix.ext | Mathlib.GroupTheory.Coxeter.Matrix | ∀ {B : Type u_1} {x y : CoxeterMatrix B}, x.M = y.M → x = y | null | true |
Convex.openSegment_interior_closure_subset_interior | Mathlib.Analysis.Convex.Topology | ∀ {𝕜 : Type u_2} {E : Type u_3} [inst : Field 𝕜] [inst_1 : PartialOrder 𝕜] [inst_2 : AddCommGroup E]
[inst_3 : Module 𝕜 E] [inst_4 : TopologicalSpace E] [IsTopologicalAddGroup E] [ContinuousConstSMul 𝕜 E] {s : Set E},
Convex 𝕜 s → ∀ {x y : E}, x ∈ interior s → y ∈ closure s → openSegment 𝕜 x y ⊆ interior s | null | true |
Invertible.mulRight | Mathlib.Algebra.Group.Invertible.Basic | {α : Type u} → [inst : Monoid α] → (a : α) → {b : α} → Invertible b → Invertible a ≃ Invertible (a * b) | `invertibleOfMulInvertible` and `invertibleMul` as an equivalence. | true |
Multiset.right_notMem_Ioo | Mathlib.Order.Interval.Multiset | ∀ {α : Type u_1} [inst : Preorder α] [inst_1 : LocallyFiniteOrder α] {a b : α}, b ∉ Multiset.Ioo a b | null | true |
Order.PFilter.infGi | Mathlib.Order.PFilter | {P : Type u_1} →
[inst : CompleteSemilatticeInf P] →
GaloisCoinsertion (fun x => OrderDual.toDual (Order.PFilter.principal x)) fun F => sInf ↑(OrderDual.ofDual F) | If a poset `P` admits arbitrary `Inf`s, then `principal` and `Inf` form a Galois coinsertion. | true |
CategoryTheory.Functor.whiskerRight | Mathlib.CategoryTheory.Whiskering | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{D : Type u₂} →
[inst_1 : CategoryTheory.Category.{v₂, u₂} D] →
{E : Type u₃} →
[inst_2 : CategoryTheory.Category.{v₃, u₃} E] →
{G H : CategoryTheory.Functor C D} → (G ⟶ H) → (F : CategoryTheory.Functor D E) → G.comp... | If `α : G ⟶ H` then `whiskerRight α F : G ⋙ F ⟶ H ⋙ F` has components `F.map (α.app X)`. | true |
WeierstrassCurve.coe_variableChange_Δ' | Mathlib.AlgebraicGeometry.EllipticCurve.VariableChange | ∀ {R : Type u} [inst : CommRing R] (W : WeierstrassCurve R) (C : WeierstrassCurve.VariableChange R)
[inst_1 : W.IsElliptic], ↑(C • W).Δ' = ↑C.u⁻¹ ^ 12 * ↑W.Δ' | null | true |
Std.Tactic.BVDecide.LRAT.Internal.DefaultFormula.clearRupUnits | Std.Tactic.BVDecide.LRAT.Internal.Formula.Implementation | {n : ℕ} → Std.Tactic.BVDecide.LRAT.Internal.DefaultFormula n → Std.Tactic.BVDecide.LRAT.Internal.DefaultFormula n | null | true |
_private.Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.NonUnital.0._auto_452 | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.NonUnital | Lean.Syntax | null | false |
OrderHom.instFunLike._proof_1 | Mathlib.Order.Hom.Basic | ∀ {α : Type u_1} {β : Type u_2} [inst : Preorder α] [inst_1 : Preorder β] (f g : α →o β), f.toFun = g.toFun → f = g | null | false |
Std.DTreeMap.Internal.Impl.contains_inter_eq_false_of_contains_eq_false_right | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {instOrd : Ord α} {m₁ m₂ : Std.DTreeMap.Internal.Impl α β} [Std.TransOrd α]
(h₁ : m₁.WF),
m₂.WF →
∀ {k : α},
Std.DTreeMap.Internal.Impl.contains k m₂ = false → Std.DTreeMap.Internal.Impl.contains k (m₁.inter m₂ ⋯) = false | null | true |
instDecidableEqZNum.decEq._proof_10 | Mathlib.Data.Num.Basic | ∀ (a b : PosNum), ¬a = b → ¬ZNum.neg a = ZNum.neg b | null | false |
CategoryTheory.ShortComplex.HomologyData.ofIso._proof_2 | Mathlib.Algebra.Homology.ShortComplex.Homology | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{S₁ S₂ : CategoryTheory.ShortComplex C} (e : S₁ ≅ S₂), CategoryTheory.IsIso e.hom.τ₂ | null | false |
Equiv.ofIff._proof_2 | Mathlib.Logic.Equiv.Defs | ∀ {P Q : Prop} (h : P ↔ Q) (x : P), ⋯ = ⋯ | null | false |
AbstractCompletion.closure_range | Mathlib.Topology.UniformSpace.AbstractCompletion | ∀ {α : Type uα} [inst : UniformSpace α] (pkg : AbstractCompletion.{vα, uα} α), closure (Set.range pkg.coe) = Set.univ | null | true |
CategoryTheory.whiskeringLeftCompEvaluation_inv_app | Mathlib.CategoryTheory.Products.Basic | ∀ {A : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} A] {B : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} B]
{C : Type u₃} [inst_2 : CategoryTheory.Category.{v₃, u₃} C] (F : CategoryTheory.Functor A B) (a : A)
(X : CategoryTheory.Functor B C),
(CategoryTheory.whiskeringLeftCompEvaluation F a).inv.app X... | null | true |
Lean.KVMap.entries | Lean.Data.KVMap | Lean.KVMap → List (Lean.Name × Lean.DataValue) | null | true |
Lean.Meta.Sym.Offset.recOn | Lean.Meta.Sym.Offset | {motive : Lean.Meta.Sym.Offset → Sort u} →
(t : Lean.Meta.Sym.Offset) →
((k : ℕ) → motive (Lean.Meta.Sym.Offset.num k)) →
((e : Lean.Expr) → (k : ℕ) → motive (Lean.Meta.Sym.Offset.add e k)) → motive t | null | false |
_private.Mathlib.Analysis.Complex.Exponential.0.Real.exp_approx_end._simp_1_2 | Mathlib.Analysis.Complex.Exponential | ∀ {α : Type u_2} [inst : Zero α] [inst_1 : OfNat α 2] [NeZero 2], (2 = 0) = False | null | false |
ULift.leftCancelMonoid.eq_1 | Mathlib.Algebra.Group.ULift | ∀ {α : Type u} [inst : LeftCancelMonoid α],
ULift.leftCancelMonoid = Function.Injective.leftCancelMonoid ⇑Equiv.ulift ⋯ ⋯ ⋯ ⋯ | null | true |
Aesop.LocalRuleSet.simprocsArray | Aesop.RuleSet | Aesop.LocalRuleSet → Array (Lean.Name × Lean.Meta.Simprocs) | The simprocs used by the builtin norm simp rule.
| true |
Topology.WithGeneratedByTopology.instTopologicalSpace | Mathlib.Topology.Convenient.GeneratedBy | {ι : Type t} →
{X : ι → Type u} →
[inst : (i : ι) → TopologicalSpace (X i)] →
{Y : Type v} → [inst_1 : TopologicalSpace Y] → TopologicalSpace (Topology.WithGeneratedByTopology X Y) | null | true |
CategoryTheory.ObjectProperty.instIsClosedUnderColimitsOfShapeOppositeOpOfIsClosedUnderLimitsOfShape | Mathlib.CategoryTheory.ObjectProperty.ColimitsOfShape | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] (P : CategoryTheory.ObjectProperty C) (J : Type u')
[inst_1 : CategoryTheory.Category.{v', u'} J] [P.IsClosedUnderLimitsOfShape J], P.op.IsClosedUnderColimitsOfShape Jᵒᵖ | null | true |
isTotallyDisconnected_iff_lt | Mathlib.Topology.Order.IntermediateValue | ∀ {α : Type u} [inst : TopologicalSpace α] [inst_1 : ConditionallyCompleteLinearOrder α] [OrderTopology α]
[DenselyOrdered α] {s : Set α}, IsTotallyDisconnected s ↔ ∀ x ∈ s, ∀ y ∈ s, x < y → ∃ z ∉ s, z ∈ Set.Ioo x y | This lemma characterizes when a subset `s` of a densely ordered conditionally complete linear
order is totally disconnected with respect to the order topology: between any two distinct points
of `s` must lie a point not in `s`. | true |
Lean.Parser.Command.catBehaviorBoth | Lean.Parser.Syntax | Lean.Parser.Parser | null | true |
MeasureTheory.Measure.haveLebesgueDecomposition_add | Mathlib.MeasureTheory.Measure.Decomposition.Lebesgue | ∀ {α : Type u_1} {m : MeasurableSpace α} (μ ν : MeasureTheory.Measure α) [μ.HaveLebesgueDecomposition ν],
μ = μ.singularPart ν + ν.withDensity (μ.rnDeriv ν) | null | true |
LieModule.chainTop | Mathlib.Algebra.Lie.Weights.Chain | {R : Type u_1} →
{L : Type u_2} →
[inst : CommRing R] →
[inst_1 : LieRing L] →
[inst_2 : LieAlgebra R L] →
{M : Type u_3} →
[inst_3 : AddCommGroup M] →
[inst_4 : Module R M] →
[inst_5 : LieRingModule L M] →
[inst_6 : LieModule R L... | The last weight in an `α`-chain through `β`. | true |
Inner.noConfusion | Mathlib.Analysis.InnerProductSpace.Defs | {P : Sort u} →
{𝕜 : Type u_4} →
{E : Type u_5} →
{t : Inner 𝕜 E} →
{𝕜' : Type u_4} → {E' : Type u_5} → {t' : Inner 𝕜' E'} → 𝕜 = 𝕜' → E = E' → t ≍ t' → Inner.noConfusionType P t t' | null | false |
CategoryTheory.Localization.Preadditive.add'_map | Mathlib.CategoryTheory.Localization.CalculusOfFractions.Preadditive | ∀ {C : Type u_1} {D : Type u_2} [inst : CategoryTheory.Category.{v_1, u_1} C]
[inst_1 : CategoryTheory.Category.{v_2, u_2} D] [inst_2 : CategoryTheory.Preadditive C]
{L : CategoryTheory.Functor C D} (W : CategoryTheory.MorphismProperty C) [inst_3 : L.IsLocalization W]
[inst_4 : W.HasLeftCalculusOfFractions] {X Y ... | null | true |
_private.Mathlib.Analysis.Normed.Module.Alternating.Uncurry.Fin.0.ContinuousAlternatingMap.alternatizeUncurryFinCLM.aux._proof_10 | Mathlib.Analysis.Normed.Module.Alternating.Uncurry.Fin | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜], RingHomCompTriple (RingHom.id 𝕜) (RingHom.id 𝕜) (RingHom.id 𝕜) | null | false |
groupHomology.chains₁ToCoinvariantsKer | Mathlib.RepresentationTheory.Homological.GroupHomology.LowDegree | {k G : Type u} →
[inst : CommRing k] →
[inst_1 : Group G] →
(A : Rep.{u, u, u} k G) → ModuleCat.of k (G →₀ ↑A) ⟶ ModuleCat.of k ↥(Representation.Coinvariants.ker A.ρ) | The 0th differential in the complex of inhomogeneous chains of a `G`-representation `A` as a
linear map into the `k`-submodule of `A` spanned by elements of the form
`ρ(g)(x) - x, g ∈ G, x ∈ A`. | true |
FreeSimplexQuiver.homRel.δ_comp_δ | Mathlib.AlgebraicTopology.SimplexCategory.GeneratorsRelations.Basic | ∀ {n : ℕ} {i j : Fin (n + 2)},
i ≤ j →
FreeSimplexQuiver.homRel
(CategoryTheory.CategoryStruct.comp ((CategoryTheory.Paths.of FreeSimplexQuiver).map (FreeSimplexQuiver.δ i))
((CategoryTheory.Paths.of FreeSimplexQuiver).map (FreeSimplexQuiver.δ j.succ)))
(CategoryTheory.CategoryStruct.comp ((Ca... | null | true |
CategoryTheory.HasLiftingProperty.transfiniteComposition.SqStruct.w₂ | Mathlib.CategoryTheory.SmallObject.TransfiniteCompositionLifting | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {J : Type w} [inst_1 : LinearOrder J] [inst_2 : OrderBot J]
{F : CategoryTheory.Functor J C} {c : CategoryTheory.Limits.Cocone F} {X Y : C} {p : X ⟶ Y} {f : F.obj ⊥ ⟶ X}
{g : c.pt ⟶ Y} {j : J} (self : CategoryTheory.HasLiftingProperty.transfiniteComposition.S... | null | true |
Std.CancellationToken.State.mk | Std.Sync.CancellationToken | Option Std.CancellationReason → Std.Queue Std.CancellationToken.Consumer → Std.CancellationToken.State | null | true |
ContinuousMultilinearMap.norm_iteratedFDerivComponent_le | Mathlib.Analysis.Normed.Module.Multilinear.Basic | ∀ {𝕜 : Type u} {ι : Type v} {E₁ : ι → Type wE₁} {G : Type wG} [inst : NontriviallyNormedField 𝕜]
[inst_1 : (i : ι) → SeminormedAddCommGroup (E₁ i)] [inst_2 : (i : ι) → NormedSpace 𝕜 (E₁ i)]
[inst_3 : SeminormedAddCommGroup G] [inst_4 : NormedSpace 𝕜 G] [inst_5 : Fintype ι] {α : Type u_1}
[inst_6 : Fintype α] ... | null | true |
small_iff | Mathlib.Logic.Small.Defs | ∀ (α : Type v), Small.{w, v} α ↔ ∃ S, Nonempty (α ≃ S) | null | true |
_private.Mathlib.Data.Nat.MaxPowDiv.0.Nat.pow_dvd_iff_le_of_spec | Mathlib.Data.Nat.MaxPowDiv | ∀ {p k n a b : ℕ}, 1 < p → n ≠ 0 → p ^ a * b = n → ¬p ∣ b → (p ^ k ∣ n ↔ k ≤ a) | null | true |
_private.Mathlib.Algebra.Order.Star.Basic.0.MulOpposite.instStarOrderedRing._simp_1 | Mathlib.Algebra.Order.Star.Basic | ∀ {α : Type u_1} {β : Type u_2} {ι : Sort u_4} (g : α → β) (f : ι → α), g '' Set.range f = Set.range fun x => g (f x) | null | false |
Mathlib.Tactic.Widget.homType? | Mathlib.Tactic.Widget.CommDiag | Lean.Expr → Option (Lean.Expr × Lean.Expr) | Given a Hom type `α ⟶ β`, return `(α, β)`. Otherwise `none`. | true |
MulActionWithZero.toMulAction | Mathlib.Algebra.GroupWithZero.Action.Defs | {M₀ : Type u_2} →
{A : Type u_7} → {inst : MonoidWithZero M₀} → {inst_1 : Zero A} → [self : MulActionWithZero M₀ A] → MulAction M₀ A | null | true |
Vector.set._proof_1 | Init.Data.Vector.Basic | ∀ {α : Type u_1} {n : ℕ} (xs : Vector α n), ∀ i < n, i < xs.toArray.size | null | false |
Set.exists_ne_of_one_lt_ncard | Mathlib.Data.Set.Card | ∀ {α : Type u_1} {s : Set α}, 1 < s.ncard → ∀ (a : α), ∃ b ∈ s, b ≠ a | null | true |
subset_refl | Mathlib.Order.RelClasses | ∀ {α : Type u} [inst : HasSubset α] [Std.Refl fun x1 x2 => x1 ⊆ x2] (a : α), a ⊆ a | null | true |
BitVec.instDecidableForallBitVec._f | Init.Data.BitVec.Decidable | (x : ℕ) →
Nat.below (motive := fun x => (x_1 : BitVec x → Prop) → DecidablePred x_1 → Decidable (∀ (v : BitVec x), x_1 v)) x →
(x_1 : BitVec x → Prop) → DecidablePred x_1 → Decidable (∀ (v : BitVec x), x_1 v) | null | false |
MeromorphicOn.mono_set | Mathlib.Analysis.Meromorphic.Basic | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_3} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {f : 𝕜 → E} {U : Set 𝕜}, MeromorphicOn f U → ∀ {V : Set 𝕜}, V ⊆ U → MeromorphicOn f V | null | true |
Lean.Meta.Grind.AC.instInhabitedEqCnstr | Lean.Meta.Tactic.Grind.AC.Types | Inhabited Lean.Meta.Grind.AC.EqCnstr | null | true |
Std.Tactic.BVDecide.BVExpr.bitblast.blastConst._proof_4 | Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Const | ∀ {w : ℕ}, ∀ curr ≤ w, ¬curr < w → curr = w | null | false |
Lean.Meta.Config.assignSyntheticOpaque | Lean.Meta.Basic | Lean.Meta.Config → Bool | By default synthetic opaque metavariables are not assigned by `isDefEq`. Motivation: we want to make
sure typing constraints resolved during elaboration should not "fill" holes that are supposed to be filled using tactics.
However, this restriction is too restrictive for tactics such as `exact t`. When elaborating `t`,... | true |
Preorder.toGradeBoundedOrder._proof_1 | Mathlib.Order.Grade | ∀ {α : Type u_1} [inst : Preorder α] (x x_1 : α), x ⋖ x_1 → x ⋖ x_1 | null | false |
IO.Error.permissionDenied.inj | Init.System.IOError | ∀ {filename : Option String} {osCode : UInt32} {details : String} {filename_1 : Option String} {osCode_1 : UInt32}
{details_1 : String},
IO.Error.permissionDenied filename osCode details = IO.Error.permissionDenied filename_1 osCode_1 details_1 →
filename = filename_1 ∧ osCode = osCode_1 ∧ details = details_1 | null | true |
Fin.natAdd_natAdd | Init.Data.Fin.Lemmas | ∀ (m n : ℕ) {p : ℕ} (i : Fin p), Fin.natAdd m (Fin.natAdd n i) = Fin.cast ⋯ (Fin.natAdd (m + n) i) | null | true |
Lean.Elab.Tactic.Do.addMData | Lean.Elab.Tactic.Do.LetElim | Lean.MData → Lean.Expr → Lean.Expr | null | true |
AddConstMap.instAddConstMapClass | Mathlib.Algebra.AddConstMap.Basic | ∀ {G : Type u_1} {H : Type u_2} [inst : Add G] [inst_1 : Add H] {a : G} {b : H},
AddConstMapClass (AddConstMap G H a b) G H a b | null | true |
AnalyticWithinAt.exists_hasFTaylorSeriesUpToOn | Mathlib.Analysis.Calculus.FDeriv.Analytic | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {F : Type v} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {f : E → F} {x : E}
{s : Set E} [CompleteSpace F] (n : WithTop ℕ∞),
AnalyticWithinAt 𝕜 f s x →
∃ u ∈ nhdsWith... | null | true |
Ultrafilter.comap._proof_1 | Mathlib.Order.Filter.Ultrafilter.Defs | ∀ {α : Type u_1} {β : Type u_2} {m : α → β} (u : Ultrafilter β), Set.range m ∈ u → (Filter.comap m ↑u).NeBot | null | false |
MeasureTheory.AEEqFun.coeFn_posPart | Mathlib.MeasureTheory.Function.AEEqFun | ∀ {α : Type u_1} {γ : Type u_3} [inst : MeasurableSpace α] {μ : MeasureTheory.Measure α} [inst_1 : TopologicalSpace γ]
[inst_2 : LinearOrder γ] [inst_3 : OrderClosedTopology γ] [inst_4 : Zero γ] (f : α →ₘ[μ] γ),
↑f.posPart =ᵐ[μ] fun a => max (↑f a) 0 | null | true |
CategoryTheory.Bicategory.leftUnitor | Mathlib.CategoryTheory.Bicategory.Basic | {B : Type u} →
[self : CategoryTheory.Bicategory B] →
{a b : B} → (f : a ⟶ b) → CategoryTheory.CategoryStruct.comp (CategoryTheory.CategoryStruct.id a) f ≅ f | The left unitor: `𝟙 a ≫ f ≅ f` | true |
Lean.Grind.CommRing.Expr.toPolyC.go._sparseCasesOn_1 | Init.Grind.Ring.CommSolver | {motive : Lean.Grind.CommRing.Expr → Sort u} →
(t : Lean.Grind.CommRing.Expr) →
((k : ℤ) → motive (Lean.Grind.CommRing.Expr.num k)) →
((i : Lean.Grind.CommRing.Var) → motive (Lean.Grind.CommRing.Expr.var i)) →
(Nat.hasNotBit 9 t.ctorIdx → motive t) → motive t | null | false |
CategoryTheory.shiftFunctorAdd'.eq_1 | Mathlib.CategoryTheory.Shift.Basic | ∀ (C : Type u) {A : Type u_1} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : AddMonoid A]
[inst_2 : CategoryTheory.HasShift C A] (i j k : A) (h : i + j = k),
CategoryTheory.shiftFunctorAdd' C i j k h = CategoryTheory.eqToIso ⋯ ≪≫ CategoryTheory.shiftFunctorAdd C i j | null | true |
_private.Lean.DocString.Formatter.0.Lean.Doc.Parser.versoSyntaxToString | Lean.DocString.Formatter | Lean.Syntax → String | null | true |
_private.Mathlib.Combinatorics.SimpleGraph.Connectivity.Connected.0.SimpleGraph.ConnectedComponent.walk_toSimpleGraph._unary._proof_10 | Mathlib.Combinatorics.SimpleGraph.Connectivity.Connected | ∀ {V : Type u_1} {G : SimpleGraph V} {v : V} (u : V) (p : G.Walk u v), p ≍ p | null | false |
_private.Mathlib.FieldTheory.AbelRuffini.0.solvableByRad.eq_1 | Mathlib.FieldTheory.AbelRuffini | ∀ (F : Type u_1) (E : Type u_2) [inst : Field F] [inst_1 : Field E] [inst_2 : Algebra F E],
solvableByRad F E = sInf {s | ∀ (x : E) (n : ℕ), n ≠ 0 → x ^ n ∈ s → x ∈ s} | null | true |
DivisibleHull.mk_add_mk | Mathlib.GroupTheory.DivisibleHull | ∀ {M : Type u_1} [inst : AddCommMonoid M] {m1 m2 : M} {s1 s2 : ℕ+},
DivisibleHull.mk m1 s1 + DivisibleHull.mk m2 s2 = DivisibleHull.mk (↑s2 • m1 + ↑s1 • m2) (s1 * s2) | null | true |
MulActionHom.instCommSemiring | Mathlib.GroupTheory.GroupAction.Hom | {M : Type u_2} →
{N : Type u_3} →
{X : Type u_4} →
{Y : Type u_5} →
{σ : M → N} →
[inst : SMul M X] →
[inst_1 : Monoid N] →
[inst_2 : CommSemiring Y] → [inst_3 : MulSemiringAction N Y] → CommSemiring (X →ₑ[σ] Y) | null | true |
CategoryTheory.Limits.ChosenPullback₃.hp₁._autoParam | Mathlib.CategoryTheory.Limits.Shapes.Pullback.ChosenPullback | Lean.Syntax | null | false |
Lean.Meta.DefEqCacheKind.transient | Lean.Meta.ExprDefEq | Lean.Meta.DefEqCacheKind | null | true |
LawfulBitraversable.mk | Mathlib.Control.Bitraversable.Basic | ∀ {t : Type u → Type u → Type u} [inst : Bitraversable t] [toLawfulBifunctor : LawfulBifunctor t],
(∀ {α β : Type u} (x : t α β), bitraverse pure pure x = pure x) →
(∀ {F G : Type u → Type u} [inst_1 : Applicative F] [inst_2 : Applicative G] [LawfulApplicative F]
[LawfulApplicative G] {α α' β β' γ γ' : Ty... | null | true |
UpperSet.coe_iSup._simp_2 | Mathlib.Order.UpperLower.CompleteLattice | ∀ {α : Type u_1} {ι : Sort u_4} [inst : LE α] (f : ι → UpperSet α), ⋂ i, ↑(f i) = ↑(⨆ i, f i) | null | false |
List.headI_dedup | Mathlib.Data.List.Dedup | ∀ {α : Type u_1} [inst : DecidableEq α] [inst_1 : Inhabited α] (l : List α),
l.dedup.headI = if l.headI ∈ l.tail then l.tail.dedup.headI else l.headI | null | true |
WithLp.prod_dist_eq_of_L2 | Mathlib.Analysis.Normed.Lp.ProdLp | ∀ {α : Type u_2} {β : Type u_3} [inst : SeminormedAddCommGroup α] [inst_1 : SeminormedAddCommGroup β]
(x y : WithLp 2 (α × β)), dist x y = √(dist x.fst y.fst ^ 2 + dist x.snd y.snd ^ 2) | null | true |
Pi.constAlgHom._proof_4 | Mathlib.Algebra.Algebra.Pi | ∀ (A : Type u_1) (B : Type u_2) [inst : Semiring B] (x y : B),
(↑↑(Pi.constRingHom A B)).toFun (x + y) = (↑↑(Pi.constRingHom A B)).toFun x + (↑↑(Pi.constRingHom A B)).toFun y | null | false |
Hamming.instModule._proof_2 | Mathlib.InformationTheory.Hamming | ∀ {ι : Type u_1} (α : Type u_3) [inst : Semiring α] (β : ι → Type u_2) [inst_1 : (i : ι) → AddCommMonoid (β i)]
[inst_2 : (i : ι) → Module α (β i)] (b : Hamming β), 1 • b = b | null | false |
CategoryTheory.Pretriangulated.TriangleOpEquivalence.unitIso | Mathlib.CategoryTheory.Triangulated.Opposite.Triangle | (C : Type u_1) →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
[inst_1 : CategoryTheory.HasShift C ℤ] →
CategoryTheory.Functor.id (CategoryTheory.Pretriangulated.Triangle C)ᵒᵖ ≅
(CategoryTheory.Pretriangulated.TriangleOpEquivalence.functor C).comp
(CategoryTheory.Pretriangulated.Triangle... | The unit isomorphism of the
equivalence `triangleOpEquivalence C : (Triangle C)ᵒᵖ ≌ Triangle Cᵒᵖ` . | true |
_private.Mathlib.RingTheory.PicardGroup.0.Module.Invertible.bijective_self_of_surjective._simp_1_2 | Mathlib.RingTheory.PicardGroup | ∀ {α : Type u_9} [inst : Mul α] (a b : α), a * b = a • b | null | false |
Matrix.vecMulBilin | Mathlib.LinearAlgebra.Matrix.ToLin | {m : Type u_2} →
{n : Type u_3} →
(R : Type u_4) →
(S : Type u_5) →
{A : Type u_6} →
[inst : Semiring R] →
[inst_1 : Semiring S] →
[inst_2 : NonUnitalNonAssocSemiring A] →
[inst_3 : Module R A] →
[inst_4 : Module S A] →
... | `Matrix.vecMul` as a bilinear map.
When `A` is non-commutative, this can be instantiated as `vecMulBilin A Aᵐᵒᵖ` | true |
ContravariantClass | Mathlib.Algebra.Order.Monoid.Unbundled.Defs | (M : Type u_1) → (N : Type u_2) → (M → N → N) → (N → N → Prop) → Prop | Given an action `μ` of a Type `M` on a Type `N` and a relation `r` on `N`, informally, the
`ContravariantClass` says that "if the result of the action `μ` on a pair satisfies the
relation `r`, then the initial pair satisfied the relation `r`."
More precisely, the `ContravariantClass` is a class taking two Types `M N`,... | true |
_private.Mathlib.Order.SuccPred.Archimedean.0.Set.OrdConnected.isSuccArchimedean._proof_2 | Mathlib.Order.SuccPred.Archimedean | ∀ {α : Type u_1} [inst : PartialOrder α] [inst_1 : SuccOrder α] [IsSuccArchimedean α] (s : Set α)
[inst_3 : s.OrdConnected], IsSuccArchimedean ↑s | null | false |
NonUnitalRingHom.rangeRestrict_surjective | Mathlib.RingTheory.NonUnitalSubring.Basic | ∀ {R : Type u} {S : Type v} [inst : NonUnitalNonAssocRing R] [inst_1 : NonUnitalNonAssocRing S] (f : R →ₙ+* S),
Function.Surjective ⇑f.rangeRestrict | null | true |
Module.Free.rank_eq_card_chooseBasisIndex | Mathlib.LinearAlgebra.Dimension.Free | ∀ (R : Type u) (M : Type v) [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
[inst_3 : Module.Free R M] [StrongRankCondition R], Module.rank R M = Cardinal.mk (Module.Free.ChooseBasisIndex R M) | The rank of a free module `M` over `R` is the cardinality of `ChooseBasisIndex R M`. | true |
Polynomial.instCommRingUniversalFactorizationRing._proof_31 | Mathlib.RingTheory.Polynomial.UniversalFactorizationRing | ∀ {R : Type u_1} [inst : CommRing R] {n : ℕ} (m k : ℕ) (hn : n = m + k) (p : Polynomial.MonicDegreeEq R n),
autoParam (∀ (n_1 : ℕ), ↑(n_1 + 1) = ↑n_1 + 1) AddMonoidWithOne.natCast_succ._autoParam | null | false |
Lean.Order.instMonadTailStateTOfNonempty._proof_5 | Init.Internal.Order.MonadTail | ∀ {σ : Type u_1} {m : Type u_1 → Type u_2} [inst : Monad m] [inst_1 : Lean.Order.MonadTail m] [inst_2 : Nonempty σ]
(α : Type u_1) [inst_3 : Nonempty α] {x y : StateT σ m α},
Lean.Order.instMonadTailStateTOfNonempty._aux_1 α x y → Lean.Order.instMonadTailStateTOfNonempty._aux_1 α y x → x = y | null | false |
CategoryTheory.Functor.leibnizPushout._proof_1 | Mathlib.CategoryTheory.Limits.Shapes.Pullback.PullbackObjObj | ∀ {C₁ : Type u_6} {C₂ : Type u_4} {C₃ : Type u_2} [inst : CategoryTheory.Category.{u_5, u_6} C₁]
[inst_1 : CategoryTheory.Category.{u_3, u_4} C₂] [inst_2 : CategoryTheory.Category.{u_1, u_2} C₃]
(F : CategoryTheory.Functor C₁ (CategoryTheory.Functor C₂ C₃)) [CategoryTheory.Limits.HasPushouts C₃]
(f₁ : CategoryThe... | null | false |
_private.Init.Data.Nat.Power2.Basic.0.Nat.nextPowerOfTwo.go._unary._proof_2 | Init.Data.Nat.Power2.Basic | ∀ (n power : ℕ) (h : power > 0),
power < n →
InvImage (fun x1 x2 => x1 < x2) (fun x => PSigma.casesOn x fun power h => n - power) ⟨power * 2, ⋯⟩ ⟨power, h⟩ | null | false |
equicontinuousOn_finite | Mathlib.Topology.UniformSpace.Equicontinuity | ∀ {ι : Type u_1} {X : Type u_3} {α : Type u_6} [tX : TopologicalSpace X] [uα : UniformSpace α] [Finite ι]
{F : ι → X → α} {S : Set X}, EquicontinuousOn F S ↔ ∀ (i : ι), ContinuousOn (F i) S | null | true |
LowerSet.sdiff_lt_left._simp_1 | Mathlib.Order.UpperLower.Closure | ∀ {α : Type u_1} [inst : Preorder α] {s : LowerSet α} {t : Set α}, (s.sdiff t < s) = ¬Disjoint (↑s) t | null | false |
LinearEquiv.coord | Mathlib.LinearAlgebra.Span.Basic | (R : Type u_1) →
(M : Type u_4) →
[inst : Ring R] →
[IsDomain R] →
[inst_2 : AddCommGroup M] →
[inst_3 : Module R M] → [Module.IsTorsionFree R M] → (x : M) → x ≠ 0 → ↥(R ∙ x) ≃ₗ[R] R | Given a nonzero element `x` of a torsion-free module `M` over a ring `R`, the natural
isomorphism from the span of `x` to `R` given by $r \cdot x \mapsto r$. | true |
Stream'.Seq.length.congr_simp | Mathlib.Data.Seq.Basic | ∀ {α : Type u} (s s_1 : Stream'.Seq α) (e_s : s = s_1) (h : s.Terminates), s.length h = s_1.length ⋯ | null | true |
_private.Mathlib.Analysis.SpecialFunctions.Elliptic.Weierstrass.0.PeriodPair.coeff_weierstrassPExceptSeries._simp_1_4 | Mathlib.Analysis.SpecialFunctions.Elliptic.Weierstrass | ∀ {G : Type u_1} [inst : DivInvMonoid G] (a : G) (n : ℕ), a ^ n = a ^ ↑n | null | false |
GrpCat.instCreatesLimitsOfSizeUliftFunctor._proof_1 | Mathlib.Algebra.Category.Grp.Ulift | ∀ {J : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} J] {x : CategoryTheory.Functor J GrpCat},
CategoryTheory.Limits.HasLimit x | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.