name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
Int.clog_zero_left | Mathlib.Data.Int.Log | ∀ {R : Type u_1} [inst : Semifield R] [inst_1 : LinearOrder R] [inst_2 : FloorSemiring R] (r : R), Int.clog 0 r = 0 | null | true |
CategoryTheory.instCreatesFiniteLimitsIndFunctorOppositeTypeInclusionOfHasFiniteLimits | Mathlib.CategoryTheory.Limits.Indization.Category | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
[CategoryTheory.Limits.HasFiniteLimits C] →
CategoryTheory.Limits.CreatesFiniteLimits (CategoryTheory.Ind.inclusion C) | null | true |
Std.WP.Spec.assertGadget | Std.WP.Gadget.Assert | ∀ {m : Type u → Type v} {Pred EPred : Type u} [inst : Monad m] [inst_1 : Std.WP.Assertion Pred]
[inst_2 : Std.WP.Assertion EPred] [inst_3 : Std.WP.WPMonad m Pred EPred] {post : PUnit.{u + 1} → Pred} {epost : EPred}
(as : Pred) [Lean.Order.Heyting Pred],
⦃ Lean.Order.meet as (Lean.Order.himp as (post PUnit.unit)) ... | Specification for `assertGadget`: the precondition requires both the assertion `as` and
the Heyting implication `as ⇨ post ⟨⟩`, ensuring the assertion holds and the postcondition
follows from it. | true |
Set.Ioc.instMulLeftStrictMono | Mathlib.Algebra.Order.Interval.Set.Instances | ∀ {R : Type u_1} [inst : Semiring R] [inst_1 : PartialOrder R] [inst_2 : IsStrictOrderedRing R],
MulLeftStrictMono ↑(Set.Ioc 0 1) | null | true |
Matroid.finitary_iff_forall_isCircuit_finite | Mathlib.Combinatorics.Matroid.Circuit | ∀ {α : Type u_1} {M : Matroid α}, M.Finitary ↔ ∀ (C : Set α), M.IsCircuit C → C.Finite | null | true |
CategoryTheory.Limits.Multicoequalizer.condition | 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.HasMulticoequalizer I] (a : J.L),
CategoryTheory.CategoryStruct.comp (I.fst a) (CategoryTheory.Limits.Multicoequalizer.π I (J.fst a)) =
... | null | true |
Std.HashMap.Raw._sizeOf_inst | Std.Data.HashMap.Raw | (α : Type u) → (β : Type v) → [SizeOf α] → [SizeOf β] → SizeOf (Std.HashMap.Raw α β) | null | false |
_private.Mathlib.Topology.Bases.0.TopologicalSpace.isSeparable_union._simp_1_1 | Mathlib.Topology.Bases | ∀ {a b : Prop}, (a ∧ b) = (b ∧ a) | null | false |
CategoryTheory.Abelian.SpectralObject.shortComplexMap_comp._auto_3 | Mathlib.Algebra.Homology.SpectralObject.Page | Lean.Syntax | null | false |
_private.Init.Data.BitVec.Bitblast.0.BitVec.toInt_umod_neg_add._proof_1_1 | Init.Data.BitVec.Bitblast | ∀ (w : ℕ) {x : BitVec (w + 1)} {y : BitVec (w + 1)}, 0 < y.toNat → ¬2 ^ (w + 1) - y.toNat < 2 ^ (w + 1) → False | null | false |
Module.Basis.span_repr_eq_range_applyₗ | Mathlib.LinearAlgebra.Unimodular | ∀ {R : Type u_1} [inst : CommSemiring R] {M : Type u_2} [inst_1 : AddCommMonoid M] [inst_2 : Module R M] {ι : Type u_3}
(b : Module.Basis ι R M) (v : M), Ideal.span (Set.range ⇑(b.repr v)) = (LinearMap.applyₗ v).range | The coordinates of `v` in a basis `b` generate the ideal of values taken at `v` by the linear
functionals on `M`. In particular this ideal does not depend on `b`. | true |
Set.zero_subset | Mathlib.Algebra.Group.Pointwise.Set.Basic | ∀ {α : Type u_2} [inst : Zero α] {s : Set α}, 0 ⊆ s ↔ 0 ∈ s | null | true |
Lean.Server.FileWorker.NamespaceEntry.selection | Lean.Server.FileWorker.RequestHandling | Lean.Server.FileWorker.NamespaceEntry → Lean.Syntax | null | true |
_private.Mathlib.NumberTheory.LSeries.ZMod.0.ZMod.completedLFunction_one_sub_of_one_lt_even | Mathlib.NumberTheory.LSeries.ZMod | ∀ {N : ℕ} [inst : NeZero N] {Φ : ZMod N → ℂ},
Function.Even Φ →
∀ {s : ℂ}, 1 < s.re → ZMod.completedLFunction Φ (1 - s) = ↑N ^ (s - 1) * ZMod.completedLFunction (ZMod.dft Φ) s | First form of functional equation for completed L-functions (even case).
Private because it is superseded by `completedLFunction_one_sub_even` below, which is valid for a
much wider range of `s`.
| true |
Nat.exists_add_one_eq._simp_1 | Init.Data.Nat.Lemmas | ∀ {a : ℕ}, (∃ n, n + 1 = a) = (0 < a) | null | false |
CategoryTheory.Abelian.SpectralObject.d_map_fourδ₄Toδ₃ | Mathlib.Algebra.Homology.SpectralObject.EpiMono | ∀ {C : Type u_1} {ι : Type u_2} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Abelian C]
[inst_2 : CategoryTheory.Category.{v_2, u_2} ι] (X : CategoryTheory.Abelian.SpectralObject C ι)
{i₀ i₁ i₂ i₃ i₄ i₅ : ι} (f₁ : i₀ ⟶ i₁) (f₂ : i₁ ⟶ i₂) (f₃ : i₂ ⟶ i₃) (f₄ : i₃ ⟶ i₄) (f₅ : i₄ ⟶ i₅) (f₃₄ : ... | null | true |
Lean.Doc.Part._sizeOf_inst | Lean.DocString.Types | (i : Type u) → (b : Type v) → (p : Type w) → [SizeOf i] → [SizeOf b] → [SizeOf p] → SizeOf (Lean.Doc.Part i b p) | null | false |
Std.ExtDHashMap.eq_empty_iff_forall_not_mem | Std.Data.ExtDHashMap.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {β : α → Type v} {m : Std.ExtDHashMap α β} [inst : EquivBEq α]
[inst_1 : LawfulHashable α], m = ∅ ↔ ∀ (a : α), a ∉ m | null | true |
_private.Mathlib.Analysis.Normed.Algebra.Spectrum.0.spectrum._aux_Mathlib_Analysis_Normed_Algebra_Spectrum___unexpand_Algebra_algebraMap_2 | Mathlib.Analysis.Normed.Algebra.Spectrum | Lean.PrettyPrinter.Unexpander | null | false |
MeasureTheory.Integrable.aemeasurable | Mathlib.MeasureTheory.Function.L1Space.Integrable | ∀ {α : Type u_1} {ε : Type u_5} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} [inst : TopologicalSpace ε]
[inst_1 : ContinuousENorm ε] [inst_2 : MeasurableSpace ε] [BorelSpace ε] [TopologicalSpace.PseudoMetrizableSpace ε]
{f : α → ε}, MeasureTheory.Integrable f μ → AEMeasurable f μ | null | true |
Tactic.ComputeAsymptotics.Monomial.mk._flat_ctor | Mathlib.Tactic.ComputeAsymptotics.Multiseries.Monomial.Basic | ℝ → Tactic.ComputeAsymptotics.UnitMonomial → Tactic.ComputeAsymptotics.Monomial | null | false |
_private.Mathlib.Data.Sym.Sym2.0.Sym2.fromRel_irrefl.match_1_1 | Mathlib.Data.Sym.Sym2 | ∀ {α : Type u_1} {r : α → α → Prop} (motive : Std.Irrefl r → Prop) (h : Std.Irrefl r),
(∀ (h : ∀ (a : α), ¬r a a), motive ⋯) → motive h | null | false |
_private.Lean.Level.0.Lean.Level.isMVar._sparseCasesOn_1 | Lean.Level | {motive : Lean.Level → Sort u} →
(t : Lean.Level) →
((a : Lean.LMVarId) → motive (Lean.Level.mvar a)) → (Nat.hasNotBit 32 t.ctorIdx → motive t) → motive t | null | false |
LinearIndependent.of_isLocalized_maximal | Mathlib.RingTheory.LocalProperties.Exactness | ∀ {R : Type u_1} {M : Type u_2} [inst : CommSemiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
(Rₚ : (P : Ideal R) → [P.IsMaximal] → Type u_5) [inst_3 : (P : Ideal R) → [inst : P.IsMaximal] → CommSemiring (Rₚ P)]
[inst_4 : (P : Ideal R) → [inst_4 : P.IsMaximal] → Algebra R (Rₚ P)]
[∀ (P : Ideal R) [inst... | null | true |
PowerSeries.coeff_X | Mathlib.RingTheory.PowerSeries.Basic | ∀ {R : Type u_1} [inst : Semiring R] (n : ℕ), (PowerSeries.coeff n) PowerSeries.X = if n = 1 then 1 else 0 | null | true |
Finset.union_union_distrib_right | Mathlib.Data.Finset.Lattice.Basic | ∀ {α : Type u_1} [inst : DecidableEq α] (s t u : Finset α), s ∪ t ∪ u = s ∪ u ∪ (t ∪ u) | null | true |
CategoryTheory.ShortComplex.instModuleHom._proof_2 | Mathlib.Algebra.Homology.ShortComplex.Linear | ∀ {R : Type u_3} {C : Type u_2} [inst : Semiring R] [inst_1 : CategoryTheory.Category.{u_1, u_2} C]
[inst_2 : CategoryTheory.Preadditive C] [inst_3 : CategoryTheory.Linear R C] {S₁ S₂ : CategoryTheory.ShortComplex C}
(x y : R) (b : S₁ ⟶ S₂), (x * y) • b = x • y • b | null | false |
_private.Lean.Elab.App.0.Lean.Elab.Term.ElabAppArgs.isNextOutParamOfLocalInstanceAndResult.hasLocalInstanceWithOutParams._unsafe_rec | Lean.Elab.App | Lean.Environment → Lean.Expr → Bool | null | false |
Finset.map_truncatedSup | Mathlib.Combinatorics.SetFamily.AhlswedeZhang | ∀ {α : Type u_1} {β : Type u_2} [inst : SemilatticeSup α] [inst_1 : SemilatticeSup β] [inst_2 : BoundedOrder β]
[inst_3 : DecidableLE α] [inst_4 : OrderTop α] [inst_5 : DecidableLE β] (e : α ≃o β) (s : Finset α) (a : α),
e (s.truncatedSup a) = (Finset.map e.toEmbedding s).truncatedSup (e a) | null | true |
retractionKerCotangentToTensorEquivSection._proof_16 | Mathlib.RingTheory.Smooth.Kaehler | ∀ {R : Type u_3} {P : Type u_1} {S : Type u_2} [inst : CommRing R] [inst_1 : CommRing P] [inst_2 : CommRing S]
[inst_3 : Algebra R P] [inst_4 : Algebra P S] [inst_5 : Algebra R S] [inst_6 : IsScalarTower R P S],
KaehlerDifferential.kerCotangentToTensor R P S =
↑(LinearEquiv.restrictScalars P (tensorKaehlerQuo... | null | false |
Cardinal.zero_toNat | Mathlib.SetTheory.Cardinal.ToNat | Cardinal.toNat 0 = 0 | null | true |
Topology.ContinuousMapGeneratedBy.recOn | Mathlib.Topology.Convenient.ContinuousMapGeneratedBy | {ι : Type t} →
{X : ι → Type u} →
[inst : (i : ι) → TopologicalSpace (X i)] →
{Y : Type v} →
[inst_1 : TopologicalSpace Y] →
{Z : Type v'} →
[inst_2 : TopologicalSpace Z] →
{motive : Topology.ContinuousMapGeneratedBy X Y Z → Sort u_1} →
(t : Topolo... | null | false |
MvPolynomial.finSuccEquiv_X_zero | Mathlib.Algebra.MvPolynomial.Equiv | ∀ {R : Type u} [inst : CommSemiring R] {n : ℕ}, (MvPolynomial.finSuccEquiv R n) (MvPolynomial.X 0) = Polynomial.X | null | true |
LaurentPolynomial.leval | Mathlib.Algebra.Polynomial.Laurent | (R : Type u_1) →
{S : Type u_2} →
[inst : Semiring R] →
[inst_1 : AddCommMonoid S] → [inst_2 : Module R S] → [inst_3 : Monoid S] → Sˣ → LaurentPolynomial R →ₗ[R] S | Evaluation as an `R`-linear map. | true |
MulAction.aestabilizer_empty | Mathlib.MeasureTheory.Group.AEStabilizer | ∀ {G : Type u_1} {α : Type u_2} [inst : Group G] [inst_1 : MulAction G α] {x : MeasurableSpace α}
{μ : MeasureTheory.Measure α} [inst_2 : MeasureTheory.SMulInvariantMeasure G α μ], MulAction.aestabilizer G μ ∅ = ⊤ | null | true |
_private.Lean.Parser.Types.0.Lean.Parser.FirstTokens.seq._sparseCasesOn_1 | Lean.Parser.Types | {motive : Lean.Parser.FirstTokens → Sort u} →
(t : Lean.Parser.FirstTokens) →
motive Lean.Parser.FirstTokens.epsilon →
((a : List Lean.Parser.Token) → motive (Lean.Parser.FirstTokens.optTokens a)) →
(Nat.hasNotBit 9 t.ctorIdx → motive t) → motive t | null | false |
List.Pairwise.insertionSort_eq | Mathlib.Data.List.Sort | ∀ {α : Type u_1} {r : α → α → Prop} [inst : DecidableRel r] {l : List α}, List.Pairwise r l → List.insertionSort r l = l | If `l` is already `List.Pairwise` with respect to `r`, then `insertionSort` does not change
it. | true |
riemannZeta_one | Mathlib.NumberTheory.Harmonic.ZetaAsymp | riemannZeta 1 = (↑Real.eulerMascheroniConstant - Complex.log (4 * ↑Real.pi)) / 2 | Formula for `ζ 1`. Note that mathematically `ζ 1` is undefined, but our construction ascribes
this particular value to it. | true |
_private.Mathlib.Analysis.Calculus.Deriv.MeanValue.0.not_differentiableWithinAt_of_deriv_tendsto_atTop_Ioi._simp_1_1 | Mathlib.Analysis.Calculus.Deriv.MeanValue | ∀ {X : Type u} [inst : TopologicalSpace X] {x : X} {s : Set X}, (s ∈ nhds x) = (x ∈ interior s) | null | false |
Std.Sat.CNF.mk._flat_ctor | Std.Sat.CNF.Basic | {α : Type u} → Array (Std.Sat.CNF.Clause α) → Std.Sat.CNF α | null | false |
_private.Lean.Elab.SyntheticMVars.0.Lean.Elab.Term.synthesizeSyntheticMVars.loop._unsafe_rec | Lean.Elab.SyntheticMVars | Lean.Elab.Term.PostponeBehavior → Bool → Unit → Lean.Elab.TermElabM Unit | null | false |
HomotopicalAlgebra.Cylinder.LeftHomotopy.refl | Mathlib.AlgebraicTopology.ModelCategory.LeftHomotopy | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{X Y : C} →
[inst_1 : HomotopicalAlgebra.CategoryWithWeakEquivalences C] →
(P : HomotopicalAlgebra.Cylinder X) → (f : X ⟶ Y) → P.LeftHomotopy f f | `f : X ⟶ Y` is left homotopic to itself relative to any cylinder. | true |
_private.Mathlib.Data.EReal.BigOperators.0.EReal.mul_sum_of_nonneg._proof_1_1 | Mathlib.Data.EReal.BigOperators | ∀ {ι : Type u_1} {s : Finset ι} {f : ι → EReal} {a : EReal}, (∀ i ∈ s, 0 ≤ f i) → a * ∑ i ∈ s, f i = ∑ i ∈ s, a * f i | null | false |
_private.Mathlib.InformationTheory.KullbackLeibler.ChainRule.0.InformationTheory.integral_llr_compProd_eq_add._simp_1_6 | Mathlib.InformationTheory.KullbackLeibler.ChainRule | ∀ {α : Type u_1} {ε : Type u_5} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} [inst : TopologicalSpace ε]
[inst_1 : ContinuousENorm ε] [MeasureTheory.IsFiniteMeasure μ] {c : ε},
‖c‖ₑ ≠ ⊤ → MeasureTheory.Integrable (fun x => c) μ = True | null | false |
groupCohomology.cocycles₂_ρ_map_inv_sub_map_inv | Mathlib.RepresentationTheory.Homological.GroupCohomology.LowDegree | ∀ {k G : Type u} [inst : CommRing k] [inst_1 : Group G] {A : Rep.{u_1, u, u} k G} (f : ↥(groupCohomology.cocycles₂ A))
(g : G), (A.ρ g) (f (g⁻¹, g)) - f (g, g⁻¹) = f (1, 1) - f (g, 1) | null | true |
NumberField.mixedEmbedding.volume_negAt_plusPart | Mathlib.NumberTheory.NumberField.CanonicalEmbedding.Basic | ∀ {K : Type u_1} [inst : Field K] {s : Set { w // w.IsReal }} {A : Set (NumberField.mixedEmbedding.mixedSpace K)}
[inst_1 : NumberField K],
MeasurableSet A →
MeasureTheory.volume (⇑(NumberField.mixedEmbedding.negAt s) '' NumberField.mixedEmbedding.plusPart A) =
MeasureTheory.volume (NumberField.mixedEmbed... | The image of the `plusPart` of `A` by `negAt` have all the same volume as `plusPart A`. | true |
maximal_gt_iff._simp_1 | Mathlib.Order.Minimal | ∀ {α : Type u_2} {x y : α} [inst : Preorder α], Maximal (fun x => y < x) x = (y < x ∧ IsMax x) | null | false |
Function.swap_comp_prod | Mathlib.Logic.Function.Defs | ∀ {α : Type u_1} {β : Type u_2} {ι : Sort u_3} (f : ι → α) (g : ι → β),
Prod.swap ∘ Function.prod f g = Function.prod g f | null | true |
_private.Aesop.Tree.TreeM.0.Aesop.mkInitialTree.match_1 | Aesop.Tree.TreeM | (motive : Aesop.ForwardState × Array Aesop.ForwardRuleMatch → Sort u_1) →
(x : Aesop.ForwardState × Array Aesop.ForwardRuleMatch) →
((forwardState : Aesop.ForwardState) → (ms : Array Aesop.ForwardRuleMatch) → motive (forwardState, ms)) → motive x | null | false |
AlgebraicGeometry.StructureSheaf.comap._proof_5 | Mathlib.AlgebraicGeometry.StructureSheaf | ∀ {R : Type u_1} [inst : CommRing R] {S : Type u_1} [inst_1 : CommRing S] (f : R →+* S)
(U : TopologicalSpace.Opens ↑(AlgebraicGeometry.PrimeSpectrum.Top R))
(V : TopologicalSpace.Opens ↑(AlgebraicGeometry.PrimeSpectrum.Top S))
(hUV : V.carrier ⊆ PrimeSpectrum.comap f ⁻¹' U.carrier)
(r s : ↑((AlgebraicGeometry.... | null | false |
Pi.involutiveNeg.eq_1 | Mathlib.Algebra.Group.Pi.Basic | ∀ {I : Type u} {f : I → Type v₁} [inst : (i : I) → InvolutiveNeg (f i)],
Pi.involutiveNeg = { toNeg := Pi.instNeg, neg_neg := ⋯ } | null | true |
Lean.Meta.Simp.ConfigCtx.mk._flat_ctor | Init.MetaTypes | ℕ →
ℕ →
Bool →
Bool →
Bool →
Bool →
Bool →
Bool →
Lean.Meta.EtaStructMode →
Bool →
Bool →
Bool →
Bool →
Bool →
... | null | false |
Lean.Grind.CommRing.Poly.pow | Init.Grind.Ring.CommSolver | Lean.Grind.CommRing.Poly → ℕ → Lean.Grind.CommRing.Poly | null | true |
MeasureTheory.Measure.prod_sum | Mathlib.MeasureTheory.Measure.Prod | ∀ {α : Type u_1} {β : Type u_2} [inst : MeasurableSpace α] [inst_1 : MeasurableSpace β] {ι : Type u_4} {ι' : Type u_5}
[Countable ι'] (m : ι → MeasureTheory.Measure α) (m' : ι' → MeasureTheory.Measure β)
[∀ (n : ι'), MeasureTheory.SFinite (m' n)],
(MeasureTheory.Measure.sum m).prod (MeasureTheory.Measure.sum m') ... | null | true |
SSet.prodStdSimplex.pairingCore.simplex_fst_le_castSucc_iff | Mathlib.AlgebraicTopology.SimplicialSet.AnodyneExtensions.UnionProd | ∀ {m : ℕ} {k : Fin (m + 1)} {n : ℕ} (x : ((SSet.horn (m + 1) k.castSucc).unionProd (SSet.boundary n)).N) {d : ℕ}
(hd : x.dim = d) (i : Fin (d + 1)),
(x.cast hd).simplex.1 i ≤ k.castSucc ↔ i < SSet.prodStdSimplex.pairingCore.min x hd | null | true |
Module.toCentroidHom_apply_toFun | Mathlib.Algebra.Ring.CentroidHom | ∀ {α : Type u_5} [inst : NonUnitalNonAssocSemiring α] {R : Type u_6} [inst_1 : CommSemiring R] [inst_2 : Module R α]
[inst_3 : SMulCommClass R α α] [inst_4 : IsScalarTower R α α] (x : R) (a : α), (Module.toCentroidHom x) a = x • a | null | true |
CommGrpCat.Forget₂.createsLimit._proof_8 | Mathlib.Algebra.Category.Grp.Limits | ∀ {J : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} J] (F : CategoryTheory.Functor J CommGrpCat)
(s : CategoryTheory.Limits.Cone F)
(x y : ↑(((CategoryTheory.forget₂ CommGrpCat GrpCat).comp (CategoryTheory.forget₂ GrpCat MonCat)).mapCone s).1)
{j j' : J} (f : j ⟶ j'),
(CategoryTheory.ConcreteCategory.ho... | null | false |
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 |
Lean.Meta.Simp.UsedSimps.contains | Lean.Meta.Tactic.Simp.Types | Lean.Meta.Simp.UsedSimps → Lean.Meta.Origin → Bool | 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‖ = ‖(NormedSpace.fromTangentSpace x) 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 |
_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 |
Std.WP.Spec.liftWith_trans | Std.WP.Triple.SpecLemmas | ∀ {m : Type u → Type v} {Pred EPred : Type u} [inst : Monad m] [inst_1 : Std.WP.Assertion Pred]
[inst_2 : Std.WP.Assertion EPred] [inst_3 : Std.WP.WPMonad m Pred EPred] {α : Type u} {post : α → Pred}
{epost : EPred} {n₁ n₂ : Type u → Type v} [inst_4 : MonadControl n₁ m] [inst_5 : MonadControlT n₂ n₁]
(f : ({β : T... | null | 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.Basic | ¬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 |
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 |
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 |
_private.Mathlib.GroupTheory.Commensurable.0.Subgroup.Commensurable.bot_right_iff._simp_1_2 | Mathlib.GroupTheory.Commensurable | ∀ {α : Type u_1}, (Nat.card α ≠ 0) = (Nonempty α ∧ Finite α) | 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), CategoryTheory.HasSheafify ((J.over X).over Y) AddCommGrpCat] {I : Type u_3}
(X : I → C) (i : I) (X_1 : CategoryTheory.Over (X i)),
CategoryTheory.HasWeakSheafify ((J.... | null | false |
_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 |
_private.Mathlib.Basic.ENNReal.Operations.0.ENNReal.iSup_add_iSup_of_monotone.match_1_1 | Mathlib.Basic.ENNReal.Operations | ∀ {ι : Type u_1} [inst : Preorder ι] (i j _k : ι) (motive : i ≤ _k ∧ j ≤ _k → Prop) (x : i ≤ _k ∧ j ≤ _k),
(∀ (hi : i ≤ _k) (hj : j ≤ _k), motive ⋯) → motive x | null | false |
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 |
Nat.anyLTTR | Init.Data.Nat.Lemmas | (n : ℕ) → ((i : ℕ) → i < n → Bool) → Bool | Tail-recursive `Bool` loop: `true` iff `f i h` holds for some `i < n`
(short-circuits on the first `true`). Used at runtime by `decidableExistsLT`/`'` via `@[csimp]`. | true |
AdicCompletion.lift_add | Mathlib.RingTheory.AdicCompletion.Basic | ∀ {R : Type u_1} [inst : CommRing R] (I : Ideal R) {M : Type u_4} [inst_1 : AddCommGroup M] [inst_2 : Module R M]
{N : Type u_5} [inst_3 : AddCommGroup N] [inst_4 : Module R N] (f g : (n : ℕ) → M →ₗ[R] N ⧸ I ^ n • ⊤)
(hf : ∀ {m n : ℕ} (hle : m ≤ n), AdicCompletion.transitionMap I N hle ∘ₗ f n = f m)
(hg : ∀ {m n ... | null | true |
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 |
CategoryTheory.Sheaf.H.longSequence_exact₁ | Mathlib.CategoryTheory.Sites.SheafCohomology.ExactSequences | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {J : CategoryTheory.GrothendieckTopology C}
[inst_1 : CategoryTheory.HasSheafify J AddCommGrpCat]
[inst_2 : CategoryTheory.HasExt (CategoryTheory.Sheaf J AddCommGrpCat)]
{S : CategoryTheory.ShortComplex (CategoryTheory.Sheaf J AddCommGrpCat)} (hS : S.ShortE... | 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',
zpow := fun z x_1 => x_1 ^ z.natMod ↑n, div_eq_mul_inv := ⋯, 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 u_1} [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 |
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 |
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_1} [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 |
Antitone.csInf_image_le | Mathlib.Order.ConditionallyCompleteLattice.Basic | ∀ {α : Type u_1} {β : Type u_2} [inst : ConditionallyCompleteLattice β] [inst_1 : Preorder α] {f : α → β},
Antitone f → ∀ {s : Set α} {c : α}, c ∈ s → BddAbove s → sInf (f '' s) ≤ f c | null | true |
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_5} {α : 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 |
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 |
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.ofLinearMap A.indToCoind A.coindToInd ⋯ ⋯) ∘ₗ (Representation.ind S.subtype A.ρ) g =
... | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.