name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11.5k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
AlgebraicGeometry.SheafedSpace.comp_hom_c_app' | Mathlib.Geometry.RingedSpace.SheafedSpace | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y Z : AlgebraicGeometry.SheafedSpace C} (α : X ⟶ Y)
(β : Y ⟶ Z) (U : TopologicalSpace.Opens ↑↑Z.toPresheafedSpace),
(CategoryTheory.CategoryStruct.comp α β).hom.c.app (Opposite.op U) =
CategoryTheory.CategoryStruct.comp (β.hom.c.app (Opposite.op U))
... | null | true |
Submodule.IsOrtho.map | Mathlib.Analysis.InnerProductSpace.Orthogonal | ∀ {𝕜 : Type u_1} {E : Type u_2} {F : Type u_3} [inst : RCLike 𝕜] [inst_1 : NormedAddCommGroup E]
[inst_2 : InnerProductSpace 𝕜 E] [inst_3 : NormedAddCommGroup F] [inst_4 : InnerProductSpace 𝕜 F] (f : E →ₗᵢ[𝕜] F)
{U V : Submodule 𝕜 E}, U ⟂ V → Submodule.map (↑f) U ⟂ Submodule.map (↑f) V | null | true |
Sublattice.map_bot | Mathlib.Order.Sublattice | ∀ {α : Type u_2} {β : Type u_3} [inst : Lattice α] [inst_1 : Lattice β] (f : LatticeHom α β), Sublattice.map f ⊥ = ⊥ | null | true |
Std.Internal.List.getKey!_modifyKey_self | Std.Data.Internal.List.Associative | ∀ {α : Type u} {β : α → Type v} [inst : BEq α] [inst_1 : LawfulBEq α] [inst_2 : Inhabited α] {k : α} {f : β k → β k}
(l : List ((a : α) × β a)),
Std.Internal.List.DistinctKeys l →
Std.Internal.List.getKey! k (Std.Internal.List.modifyKey k f l) =
if Std.Internal.List.containsKey k l = true then k else defa... | null | true |
Matroid.IsNonloop.removeLoops_isNonloop | Mathlib.Combinatorics.Matroid.Loop | ∀ {α : Type u_1} {M : Matroid α} {e : α}, M.IsNonloop e → M.removeLoops.IsNonloop e | null | true |
_private.Mathlib.MeasureTheory.Covering.BesicovitchVectorSpace.0.Besicovitch.SatelliteConfig.exists_normalized_aux3._simp_1_4 | Mathlib.MeasureTheory.Covering.BesicovitchVectorSpace | ∀ {α : Type u_2} [inst : Zero α] [inst_1 : OfNat α 3] [NeZero 3], (3 = 0) = False | null | false |
Lean.Meta.Simp.UsedSimps.contains | Lean.Meta.Tactic.Simp.Types | Lean.Meta.Simp.UsedSimps → Lean.Meta.Origin → Bool | null | true |
inner_gradientWithin_left | Mathlib.Analysis.Calculus.Gradient.Basic | ∀ {𝕜 : Type u_1} {F : Type u_2} [inst : RCLike 𝕜] [inst_1 : NormedAddCommGroup F] [inst_2 : InnerProductSpace 𝕜 F]
[inst_3 : CompleteSpace F] {f : F → 𝕜} {x y : F} {s : Set F},
inner 𝕜 (gradientWithin f s x) y = (fderivWithin 𝕜 f s x) y | null | true |
norm_tangentSpace_vectorSpace | Mathlib.Geometry.Manifold.Riemannian.Basic | ∀ {F : Type u_4} [inst : NormedAddCommGroup F] [inst_1 : InnerProductSpace ℝ F] {x : F}
{v : TangentSpace (modelWithCornersSelf ℝ F) x}, ‖v‖ = ‖v‖ | null | true |
CategoryTheory.sum.inlCompInlCompAssociator | 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] →
(CategoryTheory.Sum.inl_ C D).comp
((CategoryTheory.Sum.inl_ (C ⊕ D) E).... | Further characterizing the composition of the associator and the left inclusion. | true |
dimH_orthogonalProjection_le | Mathlib.Topology.MetricSpace.HausdorffDimension | ∀ {𝕜 : Type u_6} {E : Type u_7} [inst : RCLike 𝕜] [inst_1 : NormedAddCommGroup E] [inst_2 : InnerProductSpace 𝕜 E]
(K : Submodule 𝕜 E) [inst_3 : K.HasOrthogonalProjection] (s : Set E), dimH (⇑K.orthogonalProjectionOnto '' s) ≤ dimH s | **Alias** of `dimH_orthogonalProjectionOnto_le`.
---
The Hausdorff dimension of the orthogonal projection of a set `s` onto a subspace `K`
is less than or equal to the Hausdorff dimension of `s`.
| true |
Nat.zero_shiftRight | Init.Data.Nat.Lemmas | ∀ (n : ℕ), 0 >>> n = 0 | null | true |
_private.Mathlib.LinearAlgebra.Matrix.NonsingularInverse.0.Matrix.add_mul_mul_inv_eq_sub'._simp_1_1 | Mathlib.LinearAlgebra.Matrix.NonsingularInverse | ∀ {n : Type u'} {α : Type v} [inst : Fintype n] [inst_1 : DecidableEq n] [inst_2 : CommRing α] (A : Matrix n n α)
[inst_3 : Invertible A], A⁻¹ = ⅟A | null | false |
_private.Mathlib.Algebra.Category.HopfAlgCat.Basic.0.HopfAlgCat.Hom.ext.match_1 | Mathlib.Algebra.Category.HopfAlgCat.Basic | ∀ {R : Type u_2} {inst : CommRing R} {V W : HopfAlgCat R} (motive : V.Hom W → Prop) (h : V.Hom W),
(∀ (toBialgHom' : V.carrier →ₐc[R] W.carrier), motive { toBialgHom' := toBialgHom' }) → motive h | null | false |
Mathlib.Meta.Positivity.evalAddNorm | Mathlib.Analysis.Normed.Group.Basic | Mathlib.Meta.Positivity.PositivityExt | Extension for the `positivity` tactic: additive norms are always nonnegative, and positive
on non-zero inputs. | true |
CategoryTheory.Limits.coconeEquivalenceOpConeOp._proof_1 | Mathlib.CategoryTheory.Limits.Cones | ∀ {J : Type u_4} [inst : CategoryTheory.Category.{u_3, u_4} J] {C : Type u_2}
[inst_1 : CategoryTheory.Category.{u_1, u_2} C] (F : CategoryTheory.Functor J C)
{X Y : CategoryTheory.Limits.Cocone F} (f : X ⟶ Y) (j : Jᵒᵖ),
CategoryTheory.CategoryStruct.comp f.hom.op (X.op.π.app j) = Y.op.π.app j | null | false |
CategoryTheory.Limits.IsZero.isoZero | Mathlib.CategoryTheory.Limits.Shapes.ZeroObjects | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
[inst_1 : CategoryTheory.Limits.HasZeroObject C] → {X : C} → CategoryTheory.Limits.IsZero X → (X ≅ 0) | Every zero object is isomorphic to *the* zero object. | true |
Batteries.OrientedOrd | Batteries.Classes.Deprecated | (α : Type u_1) → [Ord α] → Prop | `OrientedOrd α` asserts that the `Ord` instance satisfies `OrientedCmp`. | true |
Ordnode.insert.eq_1 | Mathlib.Data.Ordmap.Invariants | ∀ {α : Type u_1} [inst : LE α] [inst_1 : DecidableLE α] (x : α), Ordnode.insert x Ordnode.nil = Ordnode.singleton x | null | true |
_private.Mathlib.Analysis.Normed.Operator.Basic.0.ball_subset_range_iff_surjective._simp_1_2 | Mathlib.Analysis.Normed.Operator.Basic | ∀ {A : Type u_1} {B : Type u_2} [i : SetLike A B] {p : A} {x : B}, (x ∈ ↑p) = (x ∈ p) | null | false |
CartanMatrix.not_isSimplyLaced_G₂ | Mathlib.LinearAlgebra.Matrix.Cartan | ¬CartanMatrix.G₂.IsSimplyLaced | null | true |
CategoryTheory.Functor.OneHypercoverDenseData.SieveStruct.fac_assoc | Mathlib.CategoryTheory.Sites.DenseSubsite.OneHypercoverDense | ∀ {C₀ : Type u₀} {C : Type u} [inst : CategoryTheory.Category.{v₀, u₀} C₀] [inst_1 : CategoryTheory.Category.{v, u} C]
{F : CategoryTheory.Functor C₀ C} {J₀ : CategoryTheory.GrothendieckTopology C₀}
{J : CategoryTheory.GrothendieckTopology C} {X : C} {data : F.OneHypercoverDenseData J₀ J X} {X₀ : C₀}
{f : F.obj X... | null | true |
FreeMonoid.length_eq_four | Mathlib.Algebra.FreeMonoid.Basic | ∀ {α : Type u_1} {v : FreeMonoid α},
v.length = 4 ↔ ∃ a b c d, v = FreeMonoid.of a * FreeMonoid.of b * FreeMonoid.of c * FreeMonoid.of d | null | true |
_private.Init.Data.Vector.Nat.0.Vector.prod_eq_zero_iff_exists_zero_nat._simp_1_2 | Init.Data.Vector.Nat | ∀ {xs : Array ℕ}, (xs.prod = 0) = ∃ x ∈ xs, x = 0 | null | false |
Lean.instBEqReducibilityStatus.beq | Lean.ReducibilityAttrs | Lean.ReducibilityStatus → Lean.ReducibilityStatus → Bool | null | true |
Std.TreeMap.Raw.getElem!_ofList_of_contains_eq_false | Std.Data.TreeMap.Raw.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} [Std.TransCmp cmp] [inst : BEq α] [Std.LawfulBEqCmp cmp]
{l : List (α × β)} {k : α} [inst_2 : Inhabited β],
(List.map Prod.fst l).contains k = false → (Std.TreeMap.Raw.ofList l cmp)[k]! = default | null | true |
CategoryTheory.instInhabitedIsSplitCoequalizerId._proof_3 | Mathlib.CategoryTheory.Limits.Shapes.SplitCoequalizer | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {X : C},
CategoryTheory.CategoryStruct.comp (CategoryTheory.CategoryStruct.id X) (CategoryTheory.CategoryStruct.id X) =
CategoryTheory.CategoryStruct.id X | null | false |
SemidirectProduct.congr'_apply_left | Mathlib.GroupTheory.SemidirectProduct | ∀ {N₁ : Type u_4} {G₁ : Type u_5} {N₂ : Type u_6} {G₂ : Type u_7} [inst : Group N₁] [inst_1 : Group G₁]
[inst_2 : Group N₂] [inst_3 : Group G₂] {φ₁ : G₁ →* MulAut N₁} (fn : N₁ ≃* N₂) (fg : G₁ ≃* G₂) (x : N₁ ⋊[φ₁] G₁),
((SemidirectProduct.congr' fn fg) x).left = fn x.left | null | true |
TensorProduct.rightComm._proof_17 | Mathlib.LinearAlgebra.TensorProduct.Associator | ∀ (R : Type u_1) [inst : CommSemiring R] (M : Type u_2) (N : Type u_3) (P : Type u_4) [inst_1 : AddCommMonoid M]
[inst_2 : AddCommMonoid N] [inst_3 : AddCommMonoid P] [inst_4 : Module R M] [inst_5 : Module R N]
[inst_6 : Module R P], SMulCommClass R R (N →ₗ[R] TensorProduct R (TensorProduct R M N) P) | null | false |
_private.Lean.Meta.Eqns.0.Lean.Meta.withEqnOptions.match_3 | Lean.Meta.Eqns | (motive : Option (Array (Lean.Name × Lean.DataValue)) → Sort u_1) →
(x : Option (Array (Lean.Name × Lean.DataValue))) →
((values : Array (Lean.Name × Lean.DataValue)) → motive (some values)) →
((x : Option (Array (Lean.Name × Lean.DataValue))) → motive x) → motive x | null | false |
SheafOfModules.QuasicoherentData.bind._proof_3 | Mathlib.Algebra.Category.ModuleCat.Sheaf.Quasicoherent | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {J : CategoryTheory.GrothendieckTopology C}
[∀ (X : C) (Y : CategoryTheory.Over X),
((J.over X).over Y).HasSheafCompose (CategoryTheory.forget₂ RingCat AddCommGrpCat)]
{I : Type u_3} (X : I → C) (i : I) (Y : CategoryTheory.Over (X i)),
((J.over ... | null | false |
Booleanisation.instPartialOrder | Mathlib.Order.Booleanisation | {α : Type u_1} → [GeneralizedBooleanAlgebra α] → PartialOrder (Booleanisation α) | null | true |
Lean.ImportArtifacts.ofArray.inj | Lean.Setup | ∀ {toArray toArray_1 : Array System.FilePath}, { toArray := toArray } = { toArray := toArray_1 } → toArray = toArray_1 | null | true |
Module.Relations.Solution.ofπ.congr_simp | Mathlib.Algebra.Module.Presentation.Basic | ∀ {A : Type u} [inst : Ring A] {relations : Module.Relations A} {M : Type v} [inst_1 : AddCommGroup M]
[inst_2 : Module A M] (π π_1 : (relations.G →₀ A) →ₗ[A] M) (e_π : π = π_1)
(hπ : ∀ (r : relations.R), π (relations.relation r) = 0),
Module.Relations.Solution.ofπ π hπ = Module.Relations.Solution.ofπ π_1 ⋯ | null | true |
_private.Mathlib.NumberTheory.Harmonic.ZetaAsymp.0.ZetaAsymptotics.term_one._simp_1_11 | Mathlib.NumberTheory.Harmonic.ZetaAsymp | ∀ {G : Type u_1} [inst : DivInvMonoid G] (a : G), a⁻¹ = 1 / a | null | false |
MvPowerSeries.instIsAdicCompleteSpanRangeXOfFinite | Mathlib.RingTheory.AdicCompletion.Completeness | ∀ {R : Type u_1} [inst : CommRing R] {σ : Type u_3} [Finite σ],
IsAdicComplete (Ideal.span (Set.range MvPowerSeries.X)) (MvPowerSeries σ R) | null | true |
right_le_midpoint | Mathlib.LinearAlgebra.AffineSpace.Ordered | ∀ {k : Type u_1} {E : Type u_2} [inst : Field k] [inst_1 : LinearOrder k] [inst_2 : IsStrictOrderedRing k]
[inst_3 : AddCommGroup E] [inst_4 : PartialOrder E] [IsOrderedAddMonoid E] [inst_6 : Module k E]
[IsStrictOrderedModule k E] [PosSMulReflectLE k E] {a b : E}, b ≤ midpoint k a b ↔ b ≤ a | null | true |
CochainComplex.ιMapBifunctor.congr_simp | Mathlib.Algebra.Homology.BifunctorShift | ∀ {C₁ : Type u_1} {C₂ : Type u_2} {D : Type u_3} [inst : CategoryTheory.Category.{v_1, u_1} C₁]
[inst_1 : CategoryTheory.Category.{v_2, u_2} C₂] [inst_2 : CategoryTheory.Category.{v_3, u_3} D]
[inst_3 : CategoryTheory.Limits.HasZeroMorphisms C₁] [inst_4 : CategoryTheory.Limits.HasZeroMorphisms C₂]
(K₁ : CochainCo... | null | true |
OneHomClass.toOneHom.eq_1 | Mathlib.Algebra.Group.Hom.Defs | ∀ {M : Type u_4} {N : Type u_5} {F : Type u_9} [inst : One M] [inst_1 : One N] [inst_2 : FunLike F M N]
[inst_3 : OneHomClass F M N] (f : F), ↑f = { toFun := ⇑f, map_one' := ⋯ } | null | true |
Lean.Meta.pp.showLetValues.threshold | Lean.Meta.PPGoal | Lean.Option ℕ | null | true |
IsFractionRing.charZero_of_isFractionRing | Mathlib.Algebra.CharP.Algebra | ∀ (R : Type u_3) {K : Type u_4} [inst : CommRing R] [inst_1 : Field K] [inst_2 : Algebra R K] [IsFractionRing R K]
[CharZero R], CharZero K | If `R` has characteristic `0`, then so does Frac(R). | true |
_private.Lean.Elab.PreDefinition.WF.Unfold.0.Lean.Elab.WF.rwFixEq | Lean.Elab.PreDefinition.WF.Unfold | Lean.MVarId → Lean.MetaM Lean.MVarId | null | true |
BooleanAlgebra.lt._inherited_default | Mathlib.Order.BooleanAlgebra.Defs | {α : Type u} → (α → α → Prop) → α → α → Prop | null | false |
instArchimedeanRat | Mathlib.Algebra.Order.Archimedean.Basic | Archimedean ℚ | null | true |
Ctop.Realizer | Mathlib.Data.Analysis.Topology | (α : Type u_6) → [T : TopologicalSpace α] → Type (max (u_5 + 1) u_6) | A `Ctop` realizer for the topological space `T` is a `Ctop`
which generates `T`. | true |
ProbabilityTheory.indepSets_of_indepSets_of_le_right | Mathlib.Probability.Independence.Basic | ∀ {Ω : Type u_1} {_mΩ : MeasurableSpace Ω} {μ : MeasureTheory.Measure Ω} {s₁ s₂ s₃ : Set (Set Ω)},
ProbabilityTheory.IndepSets s₁ s₂ μ → s₃ ⊆ s₂ → ProbabilityTheory.IndepSets s₁ s₃ μ | null | true |
Prod.commMagma | Mathlib.Algebra.Group.Prod | {M : Type u_3} → {N : Type u_4} → [CommMagma M] → [CommMagma N] → CommMagma (M × N) | null | true |
Submonoid.groupPowers.eq_1 | Mathlib.Algebra.Group.Submonoid.Membership | ∀ {M : Type u_1} [inst : Monoid M] {x : M} {n : ℕ} (hpos : 0 < n) (hx : x ^ n = 1),
Submonoid.groupPowers hpos hx =
{ toMonoid := (Submonoid.powers x).toMonoid, inv := fun x_1 => x_1 ^ (n - 1), div := DivInvMonoid.div',
div_eq_mul_inv := ⋯, zpow := fun z x_1 => x_1 ^ z.natMod ↑n, zpow_zero' := ⋯, zpow_succ'... | null | true |
ContinuousLinearMap.eqOn_closure_span | Mathlib.Topology.Algebra.Module.ContinuousLinearMap.Basic | ∀ {R₁ : Type u_1} {R₂ : Type u_2} [inst : Semiring R₁] [inst_1 : Semiring R₂] {σ₁₂ : R₁ →+* R₂} {M₁ : Type u_4}
[inst_2 : TopologicalSpace M₁] [inst_3 : AddCommMonoid M₁] {M₂ : Type u_6} [inst_4 : TopologicalSpace M₂]
[inst_5 : AddCommMonoid M₂] [inst_6 : Module R₁ M₁] [inst_7 : Module R₂ M₂] [T2Space M₂] {s : Set ... | If two continuous linear maps are equal on a set `s`, then they are equal on the closure
of the `Submodule.span` of this set. | true |
Homeomorph.addLeft.eq_1 | Mathlib.Topology.Algebra.Group.Basic | ∀ {G : Type w} [inst : TopologicalSpace G] [inst_1 : AddGroup G] [inst_2 : SeparatelyContinuousAdd G] (a : G),
Homeomorph.addLeft a = { toEquiv := Equiv.addLeft a, continuous_toFun := ⋯, continuous_invFun := ⋯ } | null | true |
Finset.map_comp_coe_apply | Mathlib.Data.Finset.Functor | ∀ {α β : Type u} (h : α → β) (s : Multiset α), Finset.image h s.toFinset = (h <$> s).toFinset | null | true |
IsPrimitiveRoot.pow_ne_one_of_pos_of_lt | Mathlib.RingTheory.RootsOfUnity.PrimitiveRoots | ∀ {M : Type u_1} [inst : CommMonoid M] {k l : ℕ} {ζ : M}, IsPrimitiveRoot ζ k → l ≠ 0 → l < k → ζ ^ l ≠ 1 | null | true |
Algebra.SubmersivePresentation.jacobian_isUnit | Mathlib.RingTheory.Extension.Presentation.Submersive | ∀ {R : Type u} {S : Type v} {ι : Type w} {σ : Type t} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S]
[inst_3 : Finite σ] (self : Algebra.SubmersivePresentation R S ι σ), IsUnit self.jacobian | null | true |
Pi.mulActionWithZero._proof_1 | Mathlib.Algebra.GroupWithZero.Action.Pi | ∀ {I : Type u_1} {f : I → Type u_2} (α : Type u_3) [inst : MonoidWithZero α] [inst_1 : (i : I) → Zero (f i)]
[inst_2 : (i : I) → MulActionWithZero α (f i)] (a : α), a • 0 = 0 | null | false |
ENNReal.holderTriple_coe_iff._simp_1 | Mathlib.Data.Real.ConjExponents | ∀ {p q r : NNReal}, r ≠ 0 → (↑p).HolderTriple ↑q ↑r = p.HolderTriple q r | null | false |
Std.TreeSet.Raw.insertMany_append | Std.Data.TreeSet.Raw.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t : Std.TreeSet.Raw α cmp} {l₁ l₂ : List α},
t.insertMany (l₁ ++ l₂) = (t.insertMany l₁).insertMany l₂ | null | true |
_private.Mathlib.Analysis.Normed.Algebra.Exponential.0.NormedSpace.expSeries_radius_eq_top._simp_1_1 | Mathlib.Analysis.Normed.Algebra.Exponential | ∀ {α : Type u_2} [inst : NormedDivisionRing α] (a b : α), ‖a‖ / ‖b‖ = ‖a / b‖ | null | false |
SimpleGraph.Dart.symm_mk | Mathlib.Combinatorics.SimpleGraph.Dart | ∀ {V : Type u_1} {G : SimpleGraph V} {p : V × V} (h : G.Adj p.1 p.2),
{ toProd := p, adj := h }.symm = { toProd := p.swap, adj := ⋯ } | null | true |
_private.Init.Data.BitVec.Lemmas.0.BitVec.append_assoc'._proof_1 | Init.Data.BitVec.Lemmas | ∀ {w₁ w₂ w₃ : ℕ}, ¬w₁ + w₂ + w₃ = w₁ + (w₂ + w₃) → False | null | false |
Std.DHashMap.Internal.Raw₀.Const.get_insertMany_list_of_mem | Std.Data.DHashMap.Internal.RawLemmas | ∀ {α : Type u} [inst : BEq α] [inst_1 : Hashable α] {β : Type v} (m : Std.DHashMap.Internal.Raw₀ α fun x => β)
[EquivBEq α] [LawfulHashable α],
(↑m).WF →
∀ {l : List (α × β)} {k k' : α},
(k == k') = true →
∀ {v : β},
List.Pairwise (fun a b => (a.1 == b.1) = false) l →
(k, v) ... | null | true |
Matrix.conjTranspose_inv_ofNat_smul | Mathlib.LinearAlgebra.Matrix.ConjTranspose | ∀ {m : Type u_2} {n : Type u_3} {R : Type u_7} {α : Type v} [inst : DivisionSemiring R] [inst_1 : AddCommMonoid α]
[inst_2 : StarAddMonoid α] [inst_3 : Module R α] (c : ℕ) [inst_4 : c.AtLeastTwo] (M : Matrix m n α),
((OfNat.ofNat c)⁻¹ • M).conjTranspose = (OfNat.ofNat c)⁻¹ • M.conjTranspose | null | true |
Basis.piTensorProduct_apply | Mathlib.LinearAlgebra.PiTensorProduct.Basis | ∀ {ι : Type u_1} {R : Type u_2} {M : ι → Type u_3} {κ : ι → Type u_4} [inst : CommSemiring R]
[inst_1 : (i : ι) → AddCommMonoid (M i)] [inst_2 : (i : ι) → Module R (M i)] [inst_3 : Finite ι]
(b : (i : ι) → Module.Basis (κ i) R (M i)) (p : (i : ι) → κ i),
(Basis.piTensorProduct b) p = ⨂ₜ[R] (i : ι), (b i) (p i) | null | true |
MulActionHom.congr_fun | Mathlib.GroupTheory.GroupAction.Hom | ∀ {M : Type u_2} {N : Type u_3} {φ : M → N} {X : Type u_5} [inst : SMul M X] {Y : Type u_6} [inst_1 : SMul N Y]
{f g : X →ₑ[φ] Y}, f = g → ∀ (x : X), f x = g x | null | true |
pow_le_pow_right₀ | Mathlib.Algebra.Order.GroupWithZero.Basic | ∀ {M₀ : Type u_2} [inst : MonoidWithZero M₀] [inst_1 : Preorder M₀] {a : M₀} {m n : ℕ} [ZeroLEOneClass M₀]
[PosMulMono M₀], 1 ≤ a → m ≤ n → a ^ m ≤ a ^ n | null | true |
Partition.mk.inj | Mathlib.Order.Partition.Basic | ∀ {α : Type u_1} {inst : CompleteLattice α} {s : α} {parts : Set α} {sSupIndep' : sSupIndep parts}
{bot_notMem' : ⊥ ∉ parts} {sSup_eq' : sSup parts = s} {parts_1 : Set α} {sSupIndep'_1 : sSupIndep parts_1}
{bot_notMem'_1 : ⊥ ∉ parts_1} {sSup_eq'_1 : sSup parts_1 = s},
{ parts := parts, sSupIndep' := sSupIndep', b... | null | true |
Rep.indCoindIso._proof_2 | Mathlib.RepresentationTheory.FiniteIndex | ∀ {k : Type u_1} {G : Type u_2} [inst : CommRing k] [inst_1 : Group G] {S : Subgroup G}
[inst_2 : DecidableRel ⇑(QuotientGroup.rightRel S)] [inst_3 : S.FiniteIndex] (A : Rep.{max u_3 u_1, u_1, u_2} k ↥S)
(g : G),
↑(LinearEquiv.ofLinear A.indToCoind A.coindToInd ⋯ ⋯) ∘ₗ (Representation.ind S.subtype A.ρ) g =
(... | null | false |
DirectedSystem.rTensor | Mathlib.RingTheory.TensorProduct.DirectLimitFG | ∀ (R : Type u) (N : Type u_2) [inst : CommSemiring R] [inst_1 : AddCommMonoid N] [inst_2 : Module R N] {ι : Type u_3}
[inst_3 : Preorder ι] {F : ι → Type u_4} [inst_4 : (i : ι) → AddCommMonoid (F i)] [inst_5 : (i : ι) → Module R (F i)]
{f : ⦃i j : ι⦄ → i ≤ j → F i →ₗ[R] F j},
(DirectedSystem F fun x x_1 h => ⇑(f ... | Given a directed system of `R`-modules, tensoring it on the right gives a directed system | true |
CategoryTheory.Limits.WalkingMultispan.instSubsingletonHomLeft | Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer | ∀ {J : CategoryTheory.Limits.MultispanShape} (a b : J.L),
Subsingleton (CategoryTheory.Limits.WalkingMultispan.left a ⟶ CategoryTheory.Limits.WalkingMultispan.left b) | null | true |
_private.Mathlib.LinearAlgebra.Matrix.ConjTranspose.0.Matrix.map_star_eq_zero._simp_1_1 | Mathlib.LinearAlgebra.Matrix.ConjTranspose | ∀ {m : Type u_2} {n : Type u_3} {α : Type v} {M N : Matrix m n α}, (M = N) = ∀ (i : m) (j : n), M i j = N i j | null | false |
Nat.zeckendorf.eq_def | Mathlib.Data.Nat.Fib.Zeckendorf | ∀ (x : ℕ),
x.zeckendorf =
match x with
| 0 => []
| m@h:n.succ => m.greatestFib :: (m - Nat.fib m.greatestFib).zeckendorf | null | true |
ENNReal.isConjExponent_iff_eq_conjExponent | Mathlib.Data.Real.ConjExponents | ∀ {p q : ENNReal}, 1 ≤ p → (p.HolderConjugate q ↔ q = 1 + (p - 1)⁻¹) | null | true |
_private.Mathlib.Analysis.Analytic.Order.0.analyticOrderAt_deriv_ge_iff._proof_1_3 | Mathlib.Analysis.Analytic.Order | ∀ {n : ℕ} (k : ℕ), k + 1 < n + 1 → k < n | null | false |
_private.Mathlib.AlgebraicTopology.SimplicialSet.AnodyneExtensions.UnionProd.0.SSet.prodStdSimplex.weakRankFunction._proof_16 | Mathlib.AlgebraicTopology.SimplicialSet.AnodyneExtensions.UnionProd | ∀ {m : ℕ} (k : Fin (m + 1)) (n d : ℕ) (it : Fin (d + 1))
(t :
(CategoryTheory.MonoidalCategoryStruct.tensorObj (SSet.stdSimplex.obj { len := m + 1 })
(SSet.stdSimplex.obj { len := n })).obj
(Opposite.op { len := d + 1 }))
(ht₁ :
t ∈
(CategoryTheory.MonoidalCategoryStruct.tensorObj (SSe... | null | false |
_private.Mathlib.Algebra.Category.Ring.Basic.0.CommSemiRingCat.Hom.ext.match_1 | Mathlib.Algebra.Category.Ring.Basic | ∀ {R S : CommSemiRingCat} (motive : R.Hom S → Prop) (h : R.Hom S),
(∀ (hom' : ↑R →+* ↑S), motive { hom' := hom' }) → motive h | null | false |
AddSubgroup.index_map_of_injective | Mathlib.GroupTheory.Index | ∀ {G : Type u_1} {G' : Type u_2} [inst : AddGroup G] [inst_1 : AddGroup G'] (H : AddSubgroup G) {f : G →+ G'},
Function.Injective ⇑f → (AddSubgroup.map f H).index = H.index * f.range.index | null | true |
Std.Http.Method.uncheckout.elim | Std.Http.Data.Method | {motive : Std.Http.Method → Sort u} →
(t : Std.Http.Method) → t.ctorIdx = 34 → motive Std.Http.Method.uncheckout → motive t | null | false |
CategoryTheory.MorphismProperty.rlp_isStableUnderProductsOfShape | Mathlib.CategoryTheory.MorphismProperty.LiftingProperty | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (T : CategoryTheory.MorphismProperty C) (J : Type u_1),
T.rlp.IsStableUnderProductsOfShape J | null | true |
Aesop.GoalData.mvars | Aesop.Tree.Data | {Rapp MVarCluster : Type} → Aesop.GoalData Rapp MVarCluster → Aesop.UnorderedArraySet Lean.MVarId | null | true |
Action.instLinear._proof_4 | Mathlib.CategoryTheory.Action.Limits | ∀ {V : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} V] {G : Type u_3} [inst_1 : Monoid G]
[inst_2 : CategoryTheory.Preadditive V] {R : Type u_4} [inst_3 : Semiring R] [inst_4 : CategoryTheory.Linear R V]
(X Y : Action V G) (a : R), a • 0 = 0 | null | false |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.Const.foldl_eq_foldl_toList._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 |
UInt64.toUInt32_toUSize | Init.Data.UInt.Lemmas | ∀ (n : UInt64), n.toUSize.toUInt32 = n.toUInt32 | null | true |
CategoryTheory.Functor.IsEventuallyConstantFrom.coconeιApp_eq_id | Mathlib.CategoryTheory.Limits.Constructions.EventuallyConstant | ∀ {J : Type u_1} {C : Type u_2} [inst : CategoryTheory.Category.{v_1, u_1} J]
[inst_1 : CategoryTheory.Category.{v_2, u_2} C] {F : CategoryTheory.Functor J C} {i₀ : J}
(h : F.IsEventuallyConstantFrom i₀) [inst_2 : CategoryTheory.IsFiltered J],
h.coconeιApp i₀ = CategoryTheory.CategoryStruct.id (F.obj i₀) | null | true |
FiberBundleCore.Fiber | Mathlib.Topology.FiberBundle.Basic | {ι : Type u_1} →
{B : Type u_2} →
{F : Type u_3} → [inst : TopologicalSpace B] → [inst_1 : TopologicalSpace F] → FiberBundleCore ι B F → B → Type u_3 | The fiber of a fiber bundle core, as a convenience function for dot notation and
typeclass inference | true |
CategoryTheory.Limits.widePullbackShapeUnopOp._proof_2 | Mathlib.CategoryTheory.Limits.Shapes.WidePullbacks | ∀ (J : Type u_1) {X Y : CategoryTheory.Limits.WidePullbackShape J} (f : X ⟶ Y),
CategoryTheory.CategoryStruct.comp
(((CategoryTheory.Limits.widePullbackShapeOp J).comp (CategoryTheory.Limits.widePushoutShapeUnop J)).map f)
(CategoryTheory.Iso.refl
(((CategoryTheory.Limits.widePullbackShapeOp J).... | null | false |
Std.Rcc.Sliceable.recOn | Init.Data.Slice.Notation | {α : Type u} →
{β : Type v} →
{γ : Type w} →
{motive : Std.Rcc.Sliceable α β γ → Sort u_1} →
(t : Std.Rcc.Sliceable α β γ) → ((mkSlice : α → Std.Rcc β → γ) → motive { mkSlice := mkSlice }) → motive t | null | false |
String.Pos.prev! | Init.Data.String.FindPos | {s : String} → s.Pos → s.Pos | Returns the previous valid position before the given position, or panics if the position is
the start position. | true |
CategoryTheory.Sum.swapCompInl | Mathlib.CategoryTheory.Sums.Basic | (C : Type u₁) →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
(D : Type u₂) →
[inst_1 : CategoryTheory.Category.{v₂, u₂} D] →
(CategoryTheory.Sum.inl_ C D).comp (CategoryTheory.Sum.swap C D) ≅ CategoryTheory.Sum.inr_ D C | Precomposing `swap` with the left inclusion gives the right inclusion. | true |
Cardinal.power_mul | Mathlib.SetTheory.Cardinal.Order | ∀ {a b c : Cardinal.{u_1}}, a ^ (b * c) = (a ^ b) ^ c | null | true |
DirectSum.coeAddMonoidHom_of | Mathlib.Algebra.DirectSum.Basic | ∀ {ι : Type v} {M : Type u_1} {S : Type u_2} [inst : DecidableEq ι] [inst_1 : AddCommMonoid M] [inst_2 : SetLike S M]
[inst_3 : AddSubmonoidClass S M] (A : ι → S) (i : ι) (x : ↥(A i)),
(DirectSum.coeAddMonoidHom A) ((DirectSum.of (fun i => ↥(A i)) i) x) = ↑x | null | true |
_private.Mathlib.FieldTheory.PurelyInseparable.Exponent.0.IsPurelyInseparable.iterateFrobeniusAux | Mathlib.FieldTheory.PurelyInseparable.Exponent | (K : Type u_2) →
(L : Type u_3) →
[inst : Field K] →
[inst_1 : Field L] → [inst_2 : Algebra K L] → [IsPurelyInseparable.HasExponent K L] → ℕ → ℕ → L → K | null | true |
Batteries.BinomialHeap.Imp.FindMin.mk | Batteries.Data.BinomialHeap.Basic | {α : Type u_1} →
(Batteries.BinomialHeap.Imp.Heap α → Batteries.BinomialHeap.Imp.Heap α) →
α → Batteries.BinomialHeap.Imp.HeapNode α → Batteries.BinomialHeap.Imp.Heap α → Batteries.BinomialHeap.Imp.FindMin α | null | true |
Matrix.SpecialLinearGroup.map_intCast_injective | Mathlib.LinearAlgebra.Matrix.SpecialLinearGroup | ∀ {n : Type u} [inst : DecidableEq n] [inst_1 : Fintype n] {R : Type v} [inst_2 : CommRing R] [CharZero R],
Function.Injective ⇑(Matrix.SpecialLinearGroup.map (Int.castRingHom R)) | null | true |
MvPowerSeries.coeff_mul_left_one_sub_of_lt_weightedOrder | Mathlib.RingTheory.MvPowerSeries.Order | ∀ {σ : Type u_1} (w : σ → ℕ) {R : Type u_3} [inst : Ring R] {f g : MvPowerSeries σ R} {d : σ →₀ ℕ},
↑((Finsupp.weight w) d) < MvPowerSeries.weightedOrder w g →
(MvPowerSeries.coeff d) (f * (1 - g)) = (MvPowerSeries.coeff d) f | null | true |
_private.Lean.Meta.Closure.0.Lean.Meta.Closure.TopoSort.mk | Lean.Meta.Closure | Lean.FVarIdHashSet → Lean.FVarIdHashSet → Array Lean.LocalDecl → Array Lean.Expr → Lean.Meta.Closure.TopoSort✝ | null | true |
DirichletCharacter.LSeries_ne_zero_of_one_lt_re | Mathlib.NumberTheory.LSeries.Dirichlet | ∀ {N : ℕ} (χ : DirichletCharacter ℂ N) {s : ℂ}, 1 < s.re → LSeries (fun n => χ ↑n) s ≠ 0 | The L-series of a Dirichlet character does not vanish on the right half-plane `re s > 1`. | true |
ContinuousAffineMap.instSub._proof_1 | Mathlib.Topology.Algebra.ContinuousAffineMap | ∀ {R : Type u_4} {V : Type u_3} {W : Type u_2} {P : Type u_1} [inst : Ring R] [inst_1 : AddCommGroup V]
[inst_2 : Module R V] [inst_3 : TopologicalSpace P] [inst_4 : AddTorsor V P] [inst_5 : AddCommGroup W]
[inst_6 : Module R W] [inst_7 : TopologicalSpace W] [IsTopologicalAddGroup W] (f g : P →ᴬ[R] W),
Continuous... | null | false |
Equiv.apply_swap_eq_self | Mathlib.Logic.Equiv.Basic | ∀ {α : Sort u_1} {β : Sort u_4} [inst : DecidableEq α] {v : α → β} {i j : α},
v i = v j → ∀ (k : α), v ((Equiv.swap i j) k) = v k | A function is invariant to a swap if it is equal at both elements | true |
List.getElem_length_sub_one_eq_getLast._proof_1 | Init.Data.List.Lemmas | ∀ {α : Type u_1} {l : List α}, l.length - 1 < l.length → l ≠ [] | null | false |
Std.Rio.pairwise_toList_upwardEnumerableLt | Init.Data.Range.Polymorphic.Lemmas | ∀ {α : Type u} {r : Std.Rio α} [inst : LT α] [inst_1 : DecidableLT α] [inst_2 : Std.PRange.Least? α]
[inst_3 : Std.PRange.UpwardEnumerable α] [inst_4 : Std.PRange.LawfulUpwardEnumerable α]
[Std.PRange.LawfulUpwardEnumerableLT α] [Std.PRange.LawfulUpwardEnumerableLeast? α]
[inst_7 : Std.Rxo.IsAlwaysFinite α], List... | null | true |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.Const.get?_empty._simp_1_2 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {instOrd : Ord α} {a b : α}, (compare a b ≠ Ordering.eq) = ((a == b) = false) | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.