name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
TensorAlgebra.ofDirectSum_comp_toDirectSum | Mathlib.LinearAlgebra.TensorAlgebra.ToTensorPower | ∀ {R : Type u_1} {M : Type u_2} [inst : CommSemiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M],
TensorAlgebra.ofDirectSum.comp TensorAlgebra.toDirectSum = AlgHom.id R (TensorAlgebra R M) | null | true |
Representation.linearizeMap.eq_1 | Mathlib.RepresentationTheory.Action | ∀ {k : Type u} {G : Type v} [inst : Monoid G] [inst_1 : Semiring k] {X Y : Action (Type w) G} (f : X ⟶ Y),
Representation.linearizeMap f =
{ toLinearMap := MonoidAlgebra.mapDomainLinearMap k k ⇑(CategoryTheory.ConcreteCategory.hom f.hom),
isIntertwining' := ⋯ } | null | true |
CategoryTheory.SmallObject.π'FunctorObj | Mathlib.CategoryTheory.SmallObject.Construction | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{I : Type w} →
{A B : I → C} →
(f : (i : I) → A i ⟶ B i) →
{S X : C} →
(πX : X ⟶ S) →
[inst_1 :
CategoryTheory.Limits.HasColimitsOfShape
(CategoryTheory.Discrete (Cate... | The canonical projection on the base object. | true |
CategoryTheory.NatIso.prod_hom | 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] {D : Type u₄}
[inst_3 : CategoryTheory.Category.{v₄, u₄} D] {F F' : CategoryTheory.Functor A B} {G G' : CategoryTheory.Functor C D}
(e... | null | true |
WeierstrassCurve.Jacobian.Nonsingular | Mathlib.AlgebraicGeometry.EllipticCurve.Jacobian.Basic | {R : Type r} → [CommRing R] → WeierstrassCurve.Jacobian R → (Fin 3 → R) → Prop | The proposition that a Jacobian 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 |
SheafOfModules.Submodule.instCompleteLattice._proof_6 | Mathlib.Algebra.Category.ModuleCat.Sheaf.Submodule | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_3, u_1} C] {J : CategoryTheory.GrothendieckTopology C}
{R : CategoryTheory.Sheaf J RingCat} {M : SheafOfModules R} (s : Set M.Submodule), IsLUB s (sSup s) | null | false |
CategoryTheory.Triangulated.SpectralObject.mk.inj | Mathlib.CategoryTheory.Triangulated.SpectralObject | ∀ {C : Type u_1} {ι : Type u_2} {inst : CategoryTheory.Category.{v_1, u_1} C}
{inst_1 : CategoryTheory.Category.{v_2, u_2} ι} {inst_2 : CategoryTheory.Limits.HasZeroObject C}
{inst_3 : CategoryTheory.HasShift C ℤ} {inst_4 : CategoryTheory.Preadditive C}
{inst_5 : ∀ (n : ℤ), (CategoryTheory.shiftFunctor C n).Addit... | null | true |
Lean.Doc.Parser.instReprUnorderedListType | Lean.DocString.Parser | Repr Lean.Doc.Parser.UnorderedListType | null | true |
OrderIso.coe_toEquiv | Mathlib.Order.Hom.Basic | ∀ {α : Type u_2} {β : Type u_3} [inst : LE α] [inst_1 : LE β] (e : α ≃o β), ⇑e.toEquiv = ⇑e | null | true |
Composition.toCompositionAsSet_blocks | Mathlib.Combinatorics.Enumerative.Composition | ∀ {n : ℕ} (c : Composition n), c.toCompositionAsSet.blocks = c.blocks | null | true |
List.map_prod_left_eq_zip | Init.Data.List.Zip | ∀ {α : Type u_1} {β : Type u_2} {l : List α} {f : α → β}, List.map (fun x => (x, f x)) l = l.zip (List.map f l) | null | true |
_private.Std.Data.DTreeMap.Internal.Model.0.Std.DTreeMap.Internal.Impl.updateCell._proof_7 | Std.Data.DTreeMap.Internal.Model | ∀ {α : Type u_1} {β : α → Type u_2}, Std.DTreeMap.Internal.Impl.leaf.Balanced | null | false |
Filter.Tendsto.squeeze | Mathlib.Topology.Order.Basic | ∀ {α : Type u} {β : Type v} [ts : TopologicalSpace α] [inst : Preorder α] [OrderTopology α] {f g h : β → α}
{b : Filter β} {a : α},
Filter.Tendsto g b (nhds a) → Filter.Tendsto h b (nhds a) → g ≤ f → f ≤ h → Filter.Tendsto f b (nhds a) | **Alias** of `tendsto_of_tendsto_of_tendsto_of_le_of_le`.
---
**Squeeze theorem** (also known as **sandwich theorem**). This version assumes that inequalities
hold everywhere. | true |
PrimeSpectrum.localization_comap_isEmbedding | Mathlib.RingTheory.Spectrum.Prime.Topology | ∀ {R : Type u} (S : Type v) [inst : CommSemiring R] [inst_1 : CommSemiring S] [inst_2 : Algebra R S] (M : Submonoid R)
[IsLocalization M S], Topology.IsEmbedding (PrimeSpectrum.comap (algebraMap R S)) | null | true |
CategoryTheory.Localization.StrictUniversalPropertyFixedTarget.op | Mathlib.CategoryTheory.Localization.Opposite | {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] →
{L : CategoryTheory.Functor C D} →
{W : CategoryTheory.MorphismProperty C} →
{E : Type u_3} →
[inst_2 : CategoryTheory.Category.{v_3... | If `L : C ⥤ D` satisfies the universal property of the localisation
for `W : MorphismProperty C`, then `L.op` also does. | true |
_private.Init.Data.Array.Basic.0.Array.isPrefixOfAux._proof_1 | Init.Data.Array.Basic | ∀ {α : Type u_1} (as bs : Array α), as.size ≤ bs.size → ∀ i < as.size, i < bs.size | null | false |
WithBot.instBoundedOrder.eq_1 | Mathlib.Order.WithBot | ∀ {α : Type u_1} [inst : LE α] [inst_1 : OrderTop α],
WithBot.instBoundedOrder = { toOrderTop := WithBot.instOrderTop, toOrderBot := WithBot.instOrderBot } | null | true |
Ideal.span_singleton_mem_isPrincipalSubmonoid | Mathlib.RingTheory.Ideal.IsPrincipal | ∀ {R : Type u_1} [inst : CommRing R] (a : R), Ideal.span {a} ∈ Ideal.isPrincipalSubmonoid R | null | true |
CategoryTheory.sum.inlCompInverseAssociator_inv_app_down_down | Mathlib.CategoryTheory.Sums.Associator | ∀ (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] (X : C),
((CategoryTheory.sum.inlCompInverseAssociator C D E).inv.app X).down.down = CategoryTheory.CategoryStruct.id X | null | true |
OrderIso.pnatIsoNat_apply | Mathlib.Data.PNat.Basic | ⇑OrderIso.pnatIsoNat = PNat.natPred | null | true |
Simps.copyFirst | Mathlib.Tactic.Simps.NotationClass | Simps.findArgType | Find arguments by duplicating the first argument. Used for `pow`. | true |
BinaryTree.treesOfNumNodesEq._proof_1 | Mathlib.Combinatorics.Enumerative.Catalan.Tree | ∀ (n : ℕ) (ijh : ↥(Finset.HasAntidiagonal.antidiagonal n)), InvImage (fun x1 x2 => x1 < x2) (fun x => x) (↑ijh).1 n.succ | null | false |
CategoryTheory.Limits.CatCospanTransformMorphism.ctorIdx | Mathlib.CategoryTheory.Limits.Shapes.Pullback.Categorical.CatCospanTransform | {A : Type u₁} →
{B : Type u₂} →
{C : Type u₃} →
{A' : Type u₄} →
{B' : Type u₅} →
{C' : Type u₆} →
{inst : CategoryTheory.Category.{v₁, u₁} A} →
{inst_1 : CategoryTheory.Category.{v₂, u₂} B} →
{inst_2 : CategoryTheory.Category.{v₃, u₃} C} →
... | null | false |
CategoryTheory.Limits.preservesFiniteBiproductsOfPreservesBiproducts | Mathlib.CategoryTheory.Limits.Preserves.Shapes.Biproducts | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
[inst_2 : CategoryTheory.Limits.HasZeroMorphisms C] [inst_3 : CategoryTheory.Limits.HasZeroMorphisms D]
(F : CategoryTheory.Functor C D) [inst_4 : F.PreservesZeroMorphisms] [CategoryTheory.Limits.... | null | true |
LinearIndependent.map' | Mathlib.LinearAlgebra.LinearIndependent.Basic | ∀ {ι : Type u'} {R : Type u_2} {M : Type u_4} {M' : Type u_5} {v : ι → M} [inst : Ring R] [inst_1 : AddCommGroup M]
[inst_2 : AddCommGroup M'] [inst_3 : Module R M] [inst_4 : Module R M'],
LinearIndependent R v → ∀ (f : M →ₗ[R] M'), f.ker = ⊥ → LinearIndependent R (⇑f ∘ v) | An injective linear map sends linearly independent families of vectors to linearly independent
families of vectors. See also `LinearIndependent.map` for a more general statement. | true |
Lean.Meta.Grind.getFnRoots | Lean.Meta.Tactic.Grind.Beta | Lean.Expr → Lean.Meta.Grind.GoalM (Array Lean.Expr) | Returns the root of the functions in the equivalence class containing `e`.
That is, if `f a` is in `root`s equivalence class, results contains the root of `f`.
| true |
ContRepresentation.restrict | Mathlib.RepresentationTheory.Continuous.Basic | {R : Type u_1} →
{G : Type u_2} →
{V : Type u_3} →
[inst : Monoid G] →
[inst_1 : Ring R] →
[inst_2 : AddCommGroup V] →
[inst_3 : TopologicalSpace V] →
[inst_4 : IsTopologicalAddGroup V] →
[inst_5 : Module R V] →
{H : Type u_6} → [... | The restriction of a continuous representation along a monoid homomorphism. | true |
even_abs | Mathlib.Algebra.Order.Group.Unbundled.Abs | ∀ {α : Type u_1} [inst : AddGroup α] [inst_1 : LinearOrder α] {a : α}, Even |a| ↔ Even a | null | true |
Mathlib.Tactic.LibraryRewrite.getImportRewrites | Mathlib.Tactic.Widget.LibraryRewrite | Lean.Expr → Lean.MetaM (Array (Array (Mathlib.Tactic.LibraryRewrite.Rewrite × Lean.Name))) | Return all applicable library rewrites of `e`.
Note that the result may contain duplicate rewrites. These can be removed with `filterRewrites`. | true |
Lean.Meta.Grind.Arith.Linear.NatStruct.addRightCancelInst? | Lean.Meta.Tactic.Grind.Arith.Linear.Types | Lean.Meta.Grind.Arith.Linear.NatStruct → Option Lean.Expr | null | true |
CategoryTheory.Sieve.functorPushforward_extend_eq | Mathlib.CategoryTheory.Sites.Sieves.Functoriality | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
(F : CategoryTheory.Functor C D) {X : C} {R : CategoryTheory.Presieve X},
CategoryTheory.Presieve.functorPushforward F (CategoryTheory.Sieve.generate R).arrows =
CategoryTheory.Presieve.functo... | null | true |
IsPGroup.isMulCommutative_of_card_eq_prime_sq | Mathlib.GroupTheory.PGroup | ∀ {p : ℕ} {G : Type u_1} [inst : Group G] [Fact (Nat.Prime p)], Nat.card G = p ^ 2 → IsMulCommutative G | A group of order `p ^ 2` is commutative. See also `IsPGroup.commGroupOfCardEqPrimeSq`
for the `CommGroup` instance. | true |
Cardinal.toNat_injOn | Mathlib.SetTheory.Cardinal.ToNat | Set.InjOn (⇑Cardinal.toNat) (Set.Iio Cardinal.aleph0) | null | true |
Matroid.comapOn_rankFinite | Mathlib.Combinatorics.Matroid.Map | ∀ {α : Type u_1} {β : Type u_2} {f : α → β} {N : Matroid β} {E : Set α} [N.RankFinite], (N.comapOn E f).RankFinite | null | true |
Std.TreeMap.Raw.minEntryD | Std.Data.TreeMap.Raw.Basic | {α : Type u} → {β : Type v} → {cmp : α → α → Ordering} → Std.TreeMap.Raw α β cmp → α × β → α × β | Tries to retrieve the key-value pair with the smallest key in the tree map, returning `fallback` if
the tree map is empty.
| true |
CategoryTheory.Limits.hasFiniteWidePullbacks_opposite_iff | Mathlib.CategoryTheory.Limits.Opposites | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C],
CategoryTheory.Limits.HasFiniteWidePullbacks Cᵒᵖ ↔ CategoryTheory.Limits.HasFiniteWidePushouts C | null | true |
Nontrivial.to_nonempty | Mathlib.Basic.Nontrivial.Defs | ∀ {α : Type u_1} [Nontrivial α], Nonempty α | See Note [lower instance priority]
Note that since this and `instNonemptyOfInhabited` are the most "obvious" way to find a nonempty
instance if no direct instance can be found, we give this a higher priority than the usual `100`.
| true |
Complex.cos_eq_zero_iff | Mathlib.Analysis.SpecialFunctions.Trigonometric.Complex | ∀ {θ : ℂ}, Complex.cos θ = 0 ↔ ∃ k, θ = (2 * ↑k + 1) * ↑Real.pi / 2 | null | true |
BddDistLat.dual._proof_2 | Mathlib.Order.Category.BddDistLat | ∀ {X Y Z : BddDistLat} (f : X ⟶ Y) (g : Y ⟶ Z),
BddDistLat.ofHom (BoundedLatticeHom.dual (BddDistLat.Hom.hom (CategoryTheory.CategoryStruct.comp f g))) =
CategoryTheory.CategoryStruct.comp (BddDistLat.ofHom (BoundedLatticeHom.dual (BddDistLat.Hom.hom f)))
(BddDistLat.ofHom (BoundedLatticeHom.dual (BddDistLa... | null | false |
CategoryTheory.StructuredArrow.ofCommaSndEquivalence._proof_2 | Mathlib.CategoryTheory.Comma.Over.Basic | ∀ {T : Type u_6} [inst : CategoryTheory.Category.{u_5, u_6} T] {D : Type u_3}
[inst_1 : CategoryTheory.Category.{u_1, u_3} D] {C : Type u_4} [inst_2 : CategoryTheory.Category.{u_2, u_4} C]
(F : CategoryTheory.Functor C T) (G : CategoryTheory.Functor D T) (c : C)
{X Y : CategoryTheory.StructuredArrow c (CategoryTh... | null | false |
_private.Mathlib.NumberTheory.PellMatiyasevic.0.Pell.isPell_iff_mem_unitary.match_1_1 | Mathlib.NumberTheory.PellMatiyasevic | ∀ {d : ℤ} (motive : ℤ√d → Prop) (x : ℤ√d), (∀ (x y : ℤ), motive { re := x, im := y }) → motive x | null | false |
supClosed_range | Mathlib.Order.SupClosed | ∀ {F : Type u_2} {α : Type u_3} {β : Type u_4} [inst : SemilatticeSup α] [inst_1 : SemilatticeSup β]
[inst_2 : FunLike F α β] [SupHomClass F α β] (f : F), SupClosed (Set.range ⇑f) | null | true |
CategoryTheory.Limits.Wedge.condition_assoc | Mathlib.CategoryTheory.Limits.Shapes.End | ∀ {J : Type u} [inst : CategoryTheory.Category.{v, u} J] {C : Type u'} [inst_1 : CategoryTheory.Category.{v', u'} C]
{F : CategoryTheory.Functor Jᵒᵖ (CategoryTheory.Functor J C)} (c : CategoryTheory.Limits.Wedge F) {i j : J}
(f : i ⟶ j) {Z : C} (h : (F.obj (Opposite.op i)).obj j ⟶ Z),
CategoryTheory.CategoryStruc... | null | true |
UInt64.neg_mul | Init.Data.UInt.Lemmas | ∀ (a b : UInt64), -a * b = -(a * b) | null | true |
EsakiaHom.id | Mathlib.Topology.Order.Hom.Esakia | (α : Type u_2) → [inst : TopologicalSpace α] → [inst_1 : Preorder α] → EsakiaHom α α | `id` as an `EsakiaHom`. | true |
Plausible.ArbitraryFueled.ctorIdx | Plausible.ArbitraryFueled | {α : Type} → Plausible.ArbitraryFueled α → ℕ | null | false |
TwoP.swapEquiv_inverse_obj_X | Mathlib.CategoryTheory.Category.TwoP | ∀ (X : TwoP), (TwoP.swapEquiv.inverse.obj X).X = X.X | null | true |
Multiplicative.mem_toSubgroup | Mathlib.Algebra.Group.Subgroup.Lattice | ∀ {A : Type u_2} [inst : AddGroup A] (S : AddSubgroup A) (a : Multiplicative A),
a ∈ AddSubgroup.toSubgroup S ↔ Multiplicative.toAdd a ∈ S | null | true |
limsup_add_le._auto_3 | Mathlib.Topology.Algebra.Order.LiminfLimsup | Lean.Syntax | null | false |
Topology.CWComplex.iUnion_skeleton_eq_complex | Mathlib.Topology.CWComplex.Classical.Basic | ∀ {X : Type u_1} [t : TopologicalSpace X] {C D : Set X} [inst : T2Space X] [inst_1 : Topology.RelCWComplex C D],
⋃ n, ↑(Topology.RelCWComplex.skeleton C ↑n) = C | **Alias** of `Topology.RelCWComplex.iUnion_skeleton_eq_complex`. | true |
Lean.Elab.Tactic.forEachVar | Lean.Elab.Tactic.BuiltinTactic | Array Lean.Syntax → (Lean.MVarId → Lean.FVarId → Lean.MetaM Lean.MVarId) → Lean.Elab.Tactic.TacticM Unit | null | true |
IsometryEquiv.subRight_toEquiv | Mathlib.Topology.MetricSpace.IsometricSMul | ∀ {G : Type v} [inst : AddGroup G] [inst_1 : PseudoEMetricSpace G] [inst_2 : IsIsometricVAdd Gᵃᵒᵖ G] (c : G),
(IsometryEquiv.subRight c).toEquiv = Equiv.subRight c | null | true |
_private.Mathlib.Tactic.ClickSuggestions.Util.0.Mathlib.Tactic.ClickSuggestions.isExplicitEq.getBinderInfos | Mathlib.Tactic.ClickSuggestions.Util | Lean.Expr → Array Lean.Expr → Lean.MetaM (Array Lean.BinderInfo) | Get the `BinderInfo`s for the arguments of `mkAppN fn args`. | true |
Std.Internal.Parsec.String.digit | Std.Internal.Parsec.String | Std.Internal.Parsec.String.Parser Char | Parse an ASCII digit `0-9` as a `Char`.
| true |
Bornology.IsVonNBounded.eq_1 | Mathlib.Analysis.LocallyConvex.Bounded | ∀ (𝕜 : Type u_1) {E : Type u_3} [inst : SeminormedRing 𝕜] [inst_1 : SMul 𝕜 E] [inst_2 : Zero E]
[inst_3 : TopologicalSpace E] (s : Set E), Bornology.IsVonNBounded 𝕜 s = ∀ ⦃V : Set E⦄, V ∈ nhds 0 → Absorbs 𝕜 V s | null | true |
PresheafOfModules.instModuleCarrierStalkCommRingCatCarrierAbPresheafOpensCarrier._proof_2 | Mathlib.Algebra.Category.ModuleCat.Stalk | ∀ {X : TopCat} {R : TopCat.Presheaf CommRingCat X} (x : ↑X),
CategoryTheory.Limits.HasColimit ((TopologicalSpace.OpenNhds.inclusion x).op.comp R) | null | false |
_private.Batteries.Data.Stream.0.Std.Stream.drop.match_1.eq_1 | Batteries.Data.Stream | ∀ {σ : Type u_1} {α : Type u_2} (motive : Option (α × σ) → Sort u_3) (h_1 : Unit → motive none)
(h_2 : (fst : α) → (s : σ) → motive (some (fst, s))),
(match none with
| none => h_1 ()
| some (fst, s) => h_2 fst s) =
h_1 () | null | true |
MeasureTheory.NullMeasurableSet.preimage | Mathlib.MeasureTheory.Measure.QuasiMeasurePreserving | ∀ {α : Type u_1} {β : Type u_2} {mα : MeasurableSpace α} {mβ : MeasurableSpace β} {μa : MeasureTheory.Measure α}
{μb : MeasureTheory.Measure β} {f : α → β} {s : Set β},
MeasureTheory.NullMeasurableSet s μb →
MeasureTheory.QuasiMeasurePreserving f μa μb → MeasureTheory.NullMeasurableSet (f ⁻¹' s) μa | The preimage of a null measurable set under a (quasi-)measure-preserving map is a null
measurable set. | true |
CategoryTheory.instBicategoryMonoidalSingleObj._proof_12 | Mathlib.CategoryTheory.Bicategory.SingleObj | ∀ (C : Type u_2) [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.MonoidalCategory C]
{a b c : CategoryTheory.MonoidalSingleObj C} {f g h : C} (η : f ⟶ g) (θ : g ⟶ h) (i : C),
CategoryTheory.MonoidalCategoryStruct.whiskerRight (CategoryTheory.CategoryStruct.comp η θ) i =
CategoryTheory.Cat... | null | false |
TensorProduct.lift.equiv._proof_1 | Mathlib.LinearAlgebra.TensorProduct.Basic | ∀ {R : Type u_4} {R₂ : Type u_5} [inst : CommSemiring R] [inst_1 : CommSemiring R₂] (σ₁₂ : R →+* R₂) (M : Type u_2)
(N : Type u_3) (P₂ : Type u_1) [inst_2 : AddCommMonoid M] [inst_3 : AddCommMonoid N] [inst_4 : AddCommMonoid P₂]
[inst_5 : Module R M] [inst_6 : Module R N] [inst_7 : Module R₂ P₂],
Function.LeftInv... | null | false |
_private.Mathlib.GroupTheory.HNNExtension.0.HNNExtension.ReducedWord.map_fst_eq_and_of_prod_eq._simp_1_1 | Mathlib.GroupTheory.HNNExtension | ∀ {α : Type u_1} [inst : Group α] (s : Subgroup α) {x y : α}, (x⁻¹ * y ∈ s) = (x • ↑s = y • ↑s) | null | false |
_private.Mathlib.Data.Matrix.Reflection.0.Matrix.transposeᵣ.match_1.eq_1 | Mathlib.Data.Matrix.Reflection | ∀ {α : Type u_1} (motive : (x x_1 : ℕ) → Matrix (Fin x) (Fin x_1) α → Sort u_2) (x : ℕ) (x_1 : Matrix (Fin x) (Fin 0) α)
(h_1 : (x : ℕ) → (x_2 : Matrix (Fin x) (Fin 0) α) → motive x 0 x_2)
(h_2 : (x n : ℕ) → (A : Matrix (Fin x) (Fin (n + 1)) α) → motive x n.succ A),
(match x, 0, x_1 with
| x, 0, x_2 => h_1 x ... | null | true |
CategoryTheory.Grp.mkIso | Mathlib.CategoryTheory.Monoidal.Grp | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
[inst_1 : CategoryTheory.CartesianMonoidalCategory C] →
{G H : CategoryTheory.Grp C} →
(e : G.X ≅ H.X) →
autoParam (CategoryTheory.CategoryStruct.comp CategoryTheory.MonObj.one e.hom = CategoryTheory.MonObj.one)
Ca... | Construct an isomorphism of group objects by giving an isomorphism between the underlying
objects and checking compatibility with unit and multiplication only in the forward direction. | true |
Submultiplicative | Mathlib.Analysis.Subadditive | {α : Type u_1} → {β : Type u_2} → [Add α] → [Mul β] → [LE β] → (α → β) → Prop | A sequence is submultiplicative if it satisfies the inequality `u (m + n) ≤ u m * u n`
for all `m, n`. | true |
Std.Internal.List.getValue?._sunfold | Std.Data.Internal.List.Associative | {α : Type u} → {β : Type v} → [BEq α] → α → List ((_ : α) × β) → Option β | null | false |
CategoryTheory.BraidedCategory.braiding_tensor_right_hom_assoc | 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 Y Z : C) {Z_1 : C}
(h : CategoryTheory.MonoidalCategoryStruct.tensorObj (CategoryTheory.MonoidalCategoryStruct.tensorObj Y Z) X ⟶ Z_1),
CategoryTheory.CategoryStruct... | null | true |
_private.Mathlib.NumberTheory.NumberField.Discriminant.Different.0.NumberField.absNorm_differentIdeal._simp_1_1 | Mathlib.NumberTheory.NumberField.Discriminant.Different | ∀ {A : Type u_1} {B : Type u_3} [inst : CommRing A] [inst_1 : CommRing B] [inst_2 : Algebra A B] [inst_3 : IsDomain A]
[IsIntegrallyClosed A] [inst_5 : IsDedekindDomain B] [inst_6 : Module.IsTorsionFree A B] [Module.Finite A B]
[Algebra.IsSeparable (FractionRing A) (FractionRing B)], (differentIdeal A B = ⊥) = Fals... | null | false |
WithTop.top_sub_coe | Mathlib.Algebra.Order.Sub.WithTop | ∀ {α : Type u_1} [inst : Sub α] [inst_1 : Bot α] {a : α}, ⊤ - ↑a = ⊤ | null | true |
Lean.Lsp.ShowDocumentClientCapabilities.mk.injEq | Lean.Data.Lsp.Capabilities | ∀ (support support_1 : Bool), ({ support := support } = { support := support_1 }) = (support = support_1) | null | true |
Orientation.definition._proof_9._@.Mathlib.Analysis.InnerProductSpace.TwoDim.2341759032._hygCtx._hyg.2 | Mathlib.Analysis.InnerProductSpace.TwoDim | ContinuousConstSMul ℝ ℝ | null | false |
CategoryTheory.DifferentialObject.d_squared._autoParam | Mathlib.CategoryTheory.DifferentialObject | Lean.Syntax | null | false |
Algebra.IsStandardSmooth.relativeDimension._proof_2 | Mathlib.RingTheory.Smooth.StandardSmooth | ∀ (R : Type u_2) (S : Type u_1) [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S]
[inst_3 : Algebra.IsStandardSmooth R S], Finite ⋯.choose | null | false |
_private.Lean.Meta.Tactic.Grind.Theorems.0.Lean.Meta.Grind.Theorems.mk | Lean.Meta.Tactic.Grind.Theorems | {α : Type} →
Lean.PHashMap Lean.Name (List α) →
Lean.PHashSet Lean.Meta.Grind.Origin →
Lean.PHashSet Lean.Meta.Grind.Origin → Lean.PHashMap Lean.Meta.Grind.Origin (List α) → Lean.Meta.Grind.Theorems α | null | true |
GradedMonoid.GradeZero.commMonoid | Mathlib.Algebra.GradedMonoid | {ι : Type u_1} → (A : ι → Type u_2) → [inst : AddCommMonoid ι] → [GradedMonoid.GCommMonoid A] → CommMonoid (A 0) | The `CommMonoid` structure derived from `GCommMonoid A`. | true |
Valuation.instCommGroupWithZeroSubtypeMemSubmonoidMrange._proof_7 | Mathlib.RingTheory.Valuation.Basic | ∀ {K : Type u_2} {Γ₀ : Type u_1} [inst : LinearOrderedCommGroupWithZero Γ₀] [inst_1 : DivisionRing K]
(v : Valuation K Γ₀),
autoParam (∀ (a b : ↥(MonoidHom.mrange v)), a / b = a * b⁻¹) DivInvMonoid.div_eq_mul_inv._autoParam | null | false |
truncOfNonemptyFintype._proof_1 | Mathlib.Data.Fintype.Basic | ∀ (α : Type u_1) [Nonempty α] [inst : Fintype α], ∃ x, x ∈ Finset.univ.val | null | false |
CentroidHom.instIsCentralScalar | Mathlib.Algebra.Ring.CentroidHom | ∀ {M : Type u_2} {α : Type u_5} [inst : NonUnitalNonAssocSemiring α] [inst_1 : Monoid M] [inst_2 : DistribMulAction M α]
[inst_3 : SMulCommClass M α α] [inst_4 : IsScalarTower M α α] [inst_5 : DistribMulAction Mᵐᵒᵖ α]
[inst_6 : IsCentralScalar M α], IsCentralScalar M (CentroidHom α) | null | true |
instPseudoMetricSpaceNNReal._proof_16 | Mathlib.Topology.MetricSpace.Pseudo.Constructions | Filter.Tendsto Prod.swap instPseudoMetricSpaceNNReal._aux_14 instPseudoMetricSpaceNNReal._aux_14 | null | false |
TopologicalSpace.Closeds.isClopen_singleton_bot | Mathlib.Topology.UniformSpace.Closeds | ∀ {α : Type u_1} [inst : UniformSpace α], IsClopen {⊥} | null | true |
hyperoperation_ge_four_zero | Mathlib.Data.Nat.Hyperoperation | ∀ (n k : ℕ), hyperoperation (n + 4) 0 k = if Even k then 1 else 0 | null | true |
_private.Batteries.Data.Bool.0.Bool.lt_wfRel.match_1 | Batteries.Data.Bool | ∀ (motive : (a : Bool) → a < false → Prop) (a : Bool) (a_1 : a < false), motive a a_1 | null | false |
Lean.Elab.Command.ElabHeaderResult.toPreElabHeaderResult | Lean.Elab.MutualInductive | Lean.Elab.Command.ElabHeaderResult → Lean.Elab.Command.PreElabHeaderResult | null | true |
_private.Init.Data.Ord.Array.0.Array.compareLex.match_1.splitter | Init.Data.Ord.Array | (motive : Ordering → Sort u_1) →
(x : Ordering) → (Unit → motive Ordering.lt) → (Unit → motive Ordering.eq) → (Unit → motive Ordering.gt) → motive x | null | true |
NonUnitalAlgEquivClass.mk._flat_ctor | Mathlib.Algebra.Star.StarAlgHom | ∀ {F : Type u_1} {R : outParam (Type u_2)} {A : outParam (Type u_3)} {B : outParam (Type u_4)} [inst : Add A]
[inst_1 : Mul A] [inst_2 : SMul R A] [inst_3 : Add B] [inst_4 : Mul B] [inst_5 : SMul R B] [inst_6 : EquivLike F A B],
(∀ (f : F) (x y : A), f (x * y) = f x * f y) →
(∀ (f : F) (x y : A), f (x + y) = f ... | null | false |
Lean.Parser.Term.isIdent | Lean.Parser.Term | Lean.Syntax → Bool | null | true |
Set.subtypeInsertEquivOption._proof_4 | Mathlib.Data.Set.Insert | ∀ {α : Type u_1} {t : Set α} {x : α} (z : { i // i ∈ t }), ↑z ∈ insert x t | null | false |
LowerAdjoint.idempotent | Mathlib.Order.Closure | ∀ {α : Type u_1} {β : Type u_4} [inst : PartialOrder α] [inst_1 : Preorder β] {u : β → α} (l : LowerAdjoint u) (x : α),
u (l.toFun (u (l.toFun x))) = u (l.toFun x) | null | true |
ContT.monadLift_bind | Mathlib.Control.Monad.Cont | ∀ {r : Type u} {m : Type u → Type v} [inst : Monad m] [LawfulMonad m] {α β : Type u} (x : m α) (f : α → m β),
monadLift (x >>= f) = monadLift x >>= monadLift ∘ f | null | true |
HomotopicalAlgebra.leftHomotopyClassEquivRightHomotopyClass._proof_4 | Mathlib.AlgebraicTopology.ModelCategory.Homotopy | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : HomotopicalAlgebra.ModelCategory C] {X Y : C}
[inst_2 : HomotopicalAlgebra.IsCofibrant X] [inst_3 : HomotopicalAlgebra.IsFibrant Y],
Function.RightInverse (Quot.lift (fun f => HomotopicalAlgebra.LeftHomotopyClass.mk f) ⋯)
(Quot.lift (fun f... | null | false |
_private.Mathlib.Topology.Connected.PathConnected.0.IsPathConnected.exists_path_through_family._simp_1_1 | Mathlib.Topology.Connected.PathConnected | ∀ {n : ℕ} {P : Fin (n + 1) → Prop}, (∀ (i : Fin (n + 1)), P i) = ((∀ (i : Fin n), P i.castSucc) ∧ P (Fin.last n)) | null | false |
AddSubgroup.closure_nsmul_le | Mathlib.Algebra.Group.Subgroup.Pointwise | ∀ {G : Type u_2} [inst : AddGroup G] {s : Set G} {n : ℕ}, AddSubgroup.closure (n • s) ≤ AddSubgroup.closure s | null | true |
_private.Mathlib.Data.List.Defs.0.List.map₂Left'.match_1.splitter | Mathlib.Data.List.Defs | {α : Type u_1} →
{β : Type u_2} →
(motive : List α → List β → Sort u_3) →
(x : List α) →
(x_1 : List β) →
((bs : List β) → motive [] bs) →
((a : α) → (as : List α) → motive (a :: as) []) →
((a : α) → (as : List α) → (b : β) → (bs : List β) → motive (a :: as) (b ::... | null | true |
TopologicalSpace.Opens.instCompleteLattice._proof_11 | Mathlib.Topology.Sets.Opens | ∀ {α : Type u_1} [inst : TopologicalSpace α] (a a_1 : TopologicalSpace.Opens α), IsOpen (a.carrier ∪ ↑a_1) | null | false |
Lean.Meta.Grind.EMatch.Context.recOn | Lean.Meta.Tactic.Grind.EMatch | {motive : Lean.Meta.Grind.EMatch.Context → Sort u} →
(t : Lean.Meta.Grind.EMatch.Context) →
((useMT : Bool) →
(thm : Lean.Meta.Grind.EMatchTheorem) →
(initApp : Lean.Expr) → motive { useMT := useMT, thm := thm, initApp := initApp }) →
motive t | null | false |
Lean.Meta.markSmartUnfoldingMatch | Lean.Meta.WHNF | Lean.Expr → Lean.Expr | Add auxiliary annotation to indicate the `match`-expression `e` must be reduced when performing smart unfolding. | true |
Lean.Data.AC.instBEqExpr | Init.Data.AC | BEq Lean.Data.AC.Expr | null | true |
CategoryTheory.Abelian.FunctorCategory.imageObjIso._proof_5 | Mathlib.CategoryTheory.Abelian.FunctorCategory | ∀ {C : Type u_4} [inst : CategoryTheory.Category.{u_3, u_4} C] {D : Type u_2}
[inst_1 : CategoryTheory.Category.{u_1, u_2} D] [inst_2 : CategoryTheory.Abelian D] {F G : CategoryTheory.Functor C D}
(α : F ⟶ G) (X : C), CategoryTheory.Limits.HasCokernel (α.app X) | null | false |
Lean.Meta.Simp.Simprocs.noConfusion | Lean.Meta.Tactic.Simp.Types | {P : Sort u} → {t t' : Lean.Meta.Simprocs} → t = t' → Lean.Meta.Simp.Simprocs.noConfusionType P t t' | null | false |
RingHom.isIntegral_ofLocalizationSpan | Mathlib.RingTheory.RingHom.Integral | RingHom.OfLocalizationSpan fun {R S} [CommRing R] [CommRing S] x => x.IsIntegral | `S` is an integral `R`-algebra if there exists a set `{ r }` that
spans `R` such that each `Sᵣ` is an integral `Rᵣ`-algebra. | true |
MultilinearMap.instAdd._proof_1 | Mathlib.LinearAlgebra.Multilinear.Basic | ∀ {R : Type u_4} {ι : Type u_2} {M₁ : ι → Type u_3} {M₂ : Type u_1} [inst : Semiring R]
[inst_1 : (i : ι) → AddCommMonoid (M₁ i)] [inst_2 : AddCommMonoid M₂] [inst_3 : (i : ι) → Module R (M₁ i)]
[inst_4 : Module R M₂] (f f' : MultilinearMap R M₁ M₂) [inst_5 : DecidableEq ι] (m : (i : ι) → M₁ i) (i : ι)
(x y : M₁ ... | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.