name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11.5k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
PiTensorProduct.reindex_trans | Mathlib.LinearAlgebra.PiTensorProduct | ∀ {ι : Type u_1} {ι₂ : Type u_2} {ι₃ : Type u_3} {R : Type u_4} [inst : CommSemiring R] {s : ι → Type u_7}
[inst_1 : (i : ι) → AddCommMonoid (s i)] [inst_2 : (i : ι) → Module R (s i)] (e : ι ≃ ι₂) (e' : ι₂ ≃ ι₃),
PiTensorProduct.reindex R s e ≪≫ₗ PiTensorProduct.reindex R (fun i => s (e.symm i)) e' =
PiTensorPr... | null | true |
Ordinal.mul_two | Mathlib.SetTheory.Ordinal.Arithmetic | ∀ (o : Ordinal.{u_4}), o * 2 = o + o | null | true |
Polynomial.Gal.instUniqueOfFactSplits | Mathlib.FieldTheory.PolynomialGaloisGroup | {F : Type u_1} → [inst : Field F] → (p : Polynomial F) → [h : Fact p.Splits] → Unique p.Gal | null | true |
Std.HashMap.Raw._sizeOf_inst | Std.Data.HashMap.Raw | (α : Type u) → (β : Type v) → [SizeOf α] → [SizeOf β] → SizeOf (Std.HashMap.Raw α β) | null | false |
Matroid.loopyOn_isBasis_iff | Mathlib.Combinatorics.Matroid.Constructions | ∀ {α : Type u_1} {E I X : Set α}, (Matroid.loopyOn E).IsBasis I X ↔ I = ∅ ∧ X ⊆ E | null | true |
_private.Mathlib.Order.Antichain.0.IsMaxAntichain.nonempty_iff._simp_1_1 | Mathlib.Order.Antichain | ∀ {α : Type u} {s : Set α}, (¬s.Nonempty) = (s = ∅) | 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 |
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 |
Topology.IsEmbedding.specialLinearGroup_map | Mathlib.Topology.Algebra.Group.Matrix | ∀ {n : Type u_1} {R : Type u_2} {S : Type u_3} [inst : Fintype n] [inst_1 : DecidableEq n] [inst_2 : CommRing R]
[inst_3 : TopologicalSpace R] [inst_4 : CommRing S] [inst_5 : TopologicalSpace S] {f : R →+* S},
Topology.IsEmbedding ⇑f → Topology.IsEmbedding ⇑(Matrix.SpecialLinearGroup.map f) | 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 |
EsakiaHom.toPseudoEpimorphism | Mathlib.Topology.Order.Hom.Esakia | {α : Type u_2} →
{β : Type u_3} →
[inst : TopologicalSpace α] →
[inst_1 : Preorder α] →
[inst_2 : TopologicalSpace β] → [inst_3 : Preorder β] → EsakiaHom α β → PseudoEpimorphism α β | null | true |
IndepMatroid.ofFinitaryCardAugment_E | Mathlib.Combinatorics.Matroid.IndepAxioms | ∀ {α : Type u_1} (E : Set α) (Indep : Set α → Prop) (indep_empty : Indep ∅)
(indep_subset : ∀ ⦃I J : Set α⦄, Indep J → I ⊆ J → Indep I)
(indep_aug :
∀ ⦃I J : Set α⦄, Indep I → I.Finite → Indep J → J.Finite → I.ncard < J.ncard → ∃ e ∈ J, e ∉ I ∧ Indep (insert e I))
(indep_compact : ∀ (I : Set α), (∀ J ⊆ I, J.F... | null | true |
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 |
ZLattice.sum_piFinset_Icc_rpow_le | Mathlib.Algebra.Module.ZLattice.Summable | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] [inst_2 : FiniteDimensional ℝ E]
{L : Submodule ℤ E} [inst_3 : DiscreteTopology ↥L] {ι : Type u_3} [inst_4 : Fintype ι] [inst_5 : DecidableEq ι]
(b : Module.Basis ι ℤ ↥L) {d : ℕ},
d = Fintype.card ι →
∀ (n : ℕ),
∀ r < -↑d,
... | 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 |
_private.Mathlib.ModelTheory.Encoding.0.FirstOrder.Language.BoundedFormula.listEncode.match_1.eq_5 | Mathlib.ModelTheory.Encoding | ∀ {L : FirstOrder.Language} {α : Type u_3} (motive : (x : ℕ) → L.BoundedFormula α x → Sort u_4) (x : ℕ)
(φ : L.BoundedFormula α (x + 1)) (h_1 : (n : ℕ) → motive n FirstOrder.Language.BoundedFormula.falsum)
(h_2 : (x : ℕ) → (t₁ t₂ : L.Term (α ⊕ Fin x)) → motive x (FirstOrder.Language.BoundedFormula.equal t₁ t₂))
(... | null | true |
Lean.Elab.instInhabitedDefViewElabHeaderData.default | Lean.Elab.DefView | Lean.Elab.DefViewElabHeaderData | null | true |
CochainComplex.mappingCone.mapOfHomotopy | Mathlib.Algebra.Homology.HomotopyCategory.Pretriangulated | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
[inst_1 : CategoryTheory.Preadditive C] →
[inst_2 : CategoryTheory.Limits.HasBinaryBiproducts C] →
{K₁ L₁ K₂ L₂ : CochainComplex C ℤ} →
{φ₁ : K₁ ⟶ L₁} →
{φ₂ : K₂ ⟶ L₂} →
{a : K₁ ⟶ K₂} →
... | The morphism `mappingCone φ₁ ⟶ mappingCone φ₂` that is induced by a square that
is commutative up to homotopy. | 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 |
DivisionRing.nnratCast_def | Mathlib.Algebra.Field.Defs | ∀ {K : Type u_2} [self : DivisionRing K] (q : ℚ≥0), ↑q = ↑q.num / ↑q.den | However `NNRat.cast` is defined, it must be equal to `a / b`.
Do not use this lemma directly. Use `NNRat.cast_def` instead. | true |
_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 |
IsLocalization.noZeroDivisors | Mathlib.RingTheory.Localization.Defs | ∀ {R : Type u_1} [inst : CommSemiring R] (M : Submonoid R) {S : Type u_2} [inst_1 : CommSemiring S]
[inst_2 : Algebra R S] [IsLocalization M S] [NoZeroDivisors R], NoZeroDivisors S | Any localization of a commutative semiring without zero-divisors also has no zero-divisors. | 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 |
Std.OrientedCmp.not_isGE_of_gt | Init.Data.Order.Ord | ∀ {α : Type u} {cmp : α → α → Ordering} [Std.OrientedCmp cmp] {a b : α}, cmp a b = Ordering.gt → ¬(cmp b a).isGE = true | 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.Localization.lift₂NatIso.eq_1 | Mathlib.CategoryTheory.Localization.Monoidal.Braided | ∀ {C₁ : Type u_1} {C₂ : Type u_2} {D₁ : Type u_3} {D₂ : Type u_4} {E : Type u_5}
[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.Category.{v_4, u_4} D₂]
[inst_4 : CategoryTheory.Category.{v_5,... | null | true |
Continuous.cfcₙ_nnreal._auto_1 | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Continuity | Lean.Syntax | null | false |
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 |
_private.Lean.Parser.Syntax.0.Lean.Parser.Command.mixfix._regBuiltin.Lean.Parser.Command.infix.parenthesizer_49 | Lean.Parser.Syntax | IO Unit | null | false |
Std.Time.Modifier.Z | Std.Time.Format.Basic | Std.Time.OffsetZ → Std.Time.Modifier | `Z`: Zone offset with 'Z' for UTC (e.g., +0000, -0800, -08:00).
| true |
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 |
Lean.Lsp.instToJsonInlayHintKind.match_1 | Lean.Data.Lsp.LanguageFeatures | (motive : Lean.Lsp.InlayHintKind → Sort u_1) →
(x : Lean.Lsp.InlayHintKind) →
(Unit → motive Lean.Lsp.InlayHintKind.type) → (Unit → motive Lean.Lsp.InlayHintKind.parameter) → motive x | null | false |
Cardinal.zero_toNat | Mathlib.SetTheory.Cardinal.ToNat | Cardinal.toNat 0 = 0 | null | true |
differentiableAt_add_const_iff._simp_1 | Mathlib.Analysis.Calculus.FDeriv.Add | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {F : Type u_3} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {f : E → F}
{x : E} (c : F), DifferentiableAt 𝕜 (fun y => f y + c) x = DifferentiableAt 𝕜 f x | null | false |
Lean.Meta.Occurrences.rec | Init.MetaTypes | {motive : Lean.Meta.Occurrences → Sort u} →
motive Lean.Meta.Occurrences.all →
((idxs : List ℕ) → motive (Lean.Meta.Occurrences.pos idxs)) →
((idxs : List ℕ) → motive (Lean.Meta.Occurrences.neg idxs)) → (t : Lean.Meta.Occurrences) → motive t | null | false |
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 |
_private.Mathlib.MeasureTheory.Integral.Lebesgue.Basic.0.MeasureTheory.le_iInf_lintegral._simp_1_1 | Mathlib.MeasureTheory.Integral.Lebesgue.Basic | ∀ {α : Type u_8} {β : α → Type u_9} {ι : Sort u_10} [inst : (i : α) → InfSet (β i)] {f : ι → (a : α) → β a} {a : α},
⨅ i, f i a = (⨅ i, f i) a | null | false |
Real.Wallis.W._proof_1 | Mathlib.Analysis.Real.Pi.Wallis | (1 + 1).AtLeastTwo | null | false |
CategoryTheory.GradedObject.mapBifunctorMapMapIso._proof_1 | Mathlib.CategoryTheory.GradedObject.Bifunctor | ∀ {C₁ : Type u_5} {C₂ : Type u_7} {C₃ : Type u_3} [inst : CategoryTheory.Category.{u_4, u_5} C₁]
[inst_1 : CategoryTheory.Category.{u_6, u_7} C₂] [inst_2 : CategoryTheory.Category.{u_2, u_3} C₃]
(F : CategoryTheory.Functor C₁ (CategoryTheory.Functor C₂ C₃)) {I : Type u_8} {J : Type u_9} {K : Type u_1}
(p : I × J ... | null | false |
Set.one_subset | Mathlib.Algebra.Group.Pointwise.Set.Basic | ∀ {α : Type u_2} [inst : One α] {s : Set α}, 1 ⊆ s ↔ 1 ∈ s | null | true |
Std.ExtDTreeMap.Const.ordered_keys_toList | Std.Data.ExtDTreeMap.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {β : Type v} {t : Std.ExtDTreeMap α (fun x => β) cmp} [inst : Std.TransCmp cmp],
List.Pairwise (fun a b => cmp a.1 b.1 = Ordering.lt) (Std.ExtDTreeMap.Const.toList t) | null | true |
Batteries.Tactic.Instances._aux_Batteries_Tactic_Instances___elabRules_Batteries_Tactic_Instances_instancesCmd_1 | Batteries.Tactic.Instances | Lean.Elab.Command.CommandElab | `#instances term` prints all the instances for the given class.
For example, `#instances Add _` gives all `Add` instances, and `#instances Add Nat` gives the
`Nat` instance. The `term` can be any type that can appear in `[...]` binders.
Trailing underscores can be omitted, and `#instances Add` and `#instances Add _` a... | false |
LowerSemicontinuousWithinAt.inv | Mathlib.Topology.Semicontinuity.Basic | ∀ {α : Type u_4} [inst : TopologicalSpace α] {β : Type u_5} {f : α → β} {s : Set α} {a : α} [inst_1 : PartialOrder β]
[inst_2 : CommGroup β] [IsOrderedMonoid β], LowerSemicontinuousWithinAt f s a → UpperSemicontinuousWithinAt f⁻¹ s a | **Alias** of the reverse direction of `upperSemicontinuousWithinAt_inv_iff`. | true |
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 |
Lean.Elab.Tactic.Omega.Justification.combine.sizeOf_spec | Lean.Elab.Tactic.Omega.Core | ∀ {s t : Lean.Omega.Constraint} {c : Lean.Omega.Coeffs} (j : Lean.Elab.Tactic.Omega.Justification s c)
(k : Lean.Elab.Tactic.Omega.Justification t c),
sizeOf (j.combine k) = 1 + sizeOf s + sizeOf t + sizeOf c + sizeOf j + sizeOf k | null | true |
Monoid.Coprod.swap_eq_one._simp_2 | Mathlib.GroupTheory.Coprod.Basic | ∀ {M : Type u_1} {N : Type u_2} [inst : MulOneClass M] [inst_1 : MulOneClass N] {x : Monoid.Coprod M N},
((Monoid.Coprod.swap M N) x = 1) = (x = 1) | null | false |
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 |
Fin.cast_rev | Mathlib.Data.Fin.Rev | ∀ {n m : ℕ} (i : Fin n) (h : n = m), Fin.cast h i.rev = (Fin.cast h i).rev | 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 |
_private.Mathlib.LinearAlgebra.FixedSubmodule.0.LinearMap.fixedSubmodule_eq_ker._simp_1_1 | Mathlib.LinearAlgebra.FixedSubmodule | ∀ {G : Type u_3} [inst : AddGroup G] {a b : G}, (a - b = 0) = (a = b) | null | false |
_private.Lean.Meta.Tactic.Grind.Arith.Cutsat.EqCnstr.0.Lean.Meta.Grind.Arith.Cutsat.instReprSupportedTermKind.repr.match_1 | Lean.Meta.Tactic.Grind.Arith.Cutsat.EqCnstr | (motive : Lean.Meta.Grind.Arith.Cutsat.SupportedTermKind✝ → Sort u_1) →
(x : Lean.Meta.Grind.Arith.Cutsat.SupportedTermKind✝) →
(Unit → motive Lean.Meta.Grind.Arith.Cutsat.SupportedTermKind.add✝) →
(Unit → motive Lean.Meta.Grind.Arith.Cutsat.SupportedTermKind.mul✝) →
(Unit → motive Lean.Meta.Grind.A... | null | false |
BoundingSieve.inv_selbergTerms_eq_sum_divisors_moebius_nu.match_1 | Mathlib.NumberTheory.SelbergSieve | (motive : ℕ × ℕ → Sort u_1) → (x : ℕ × ℕ) → ((d e : ℕ) → motive (d, e)) → motive x | null | false |
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 |
FP.RMode.NE.sizeOf_spec | Mathlib.Data.FP.Basic | sizeOf FP.RMode.NE = 1 | null | true |
Std.Sat.CNF.mk._flat_ctor | Std.Sat.CNF.Basic | {α : Type u} → Array (Std.Sat.CNF.Clause α) → Std.Sat.CNF α | null | false |
Std.DTreeMap.Raw.Const.getD_inter_of_not_mem_left | Std.Data.DTreeMap.Raw.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {β : Type v} {m₁ m₂ : Std.DTreeMap.Raw α (fun x => β) cmp} [Std.TransCmp cmp],
m₁.WF → m₂.WF → ∀ {k : α} {fallback : β}, k ∉ m₁ → Std.DTreeMap.Raw.Const.getD (m₁ ∩ m₂) k fallback = fallback | null | true |
_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 |
CategoryTheory.Bicategory.instIsIsoHomLeftZigzagHom | Mathlib.CategoryTheory.Bicategory.Adjunction.Basic | ∀ {B : Type u} [inst : CategoryTheory.Bicategory B] {a b : B} {f : a ⟶ b} {g : b ⟶ a}
(η : CategoryTheory.CategoryStruct.id a ≅ CategoryTheory.CategoryStruct.comp f g)
(ε : CategoryTheory.CategoryStruct.comp g f ≅ CategoryTheory.CategoryStruct.id b),
CategoryTheory.IsIso (CategoryTheory.Bicategory.leftZigzag η.ho... | null | true |
Lean.Meta.Sym.Arith.Semiring.addFn?._default | Lean.Meta.Sym.Arith.Types | Option Lean.Expr | null | false |
Lean.LocalContext.findDecl? | Lean.LocalContext | {β : Type u_1} → Lean.LocalContext → (Lean.LocalDecl → Option β) → Option β | null | true |
_private.Mathlib.CategoryTheory.Abelian.GrothendieckCategory.ModuleEmbedding.Opposite.0.CategoryTheory.Abelian.IsGrothendieckAbelian.OppositeModuleEmbedding.generator | Mathlib.CategoryTheory.Abelian.GrothendieckCategory.ModuleEmbedding.Opposite | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{D : Type v} →
[inst_1 : CategoryTheory.SmallCategory D] →
CategoryTheory.Functor D Cᵒᵖ →
[inst_2 : CategoryTheory.Abelian C] → [CategoryTheory.IsGrothendieckAbelian.{v, v, u} C] → Cᵒᵖ | null | true |
Lists'.mem_of_subset' | Mathlib.SetTheory.Lists | ∀ {α : Type u_1} {a : Lists α} {l₁ l₂ : Lists' α true}, l₁ ⊆ l₂ → a ∈ l₁.toList → a ∈ l₂ | null | true |
_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 |
_private.Mathlib.Data.Finset.NatDivisors.0.Nat.divisors_mul._simp_1_2 | Mathlib.Data.Finset.NatDivisors | ∀ {n m : ℕ}, (n ∈ m.divisors) = (n ∣ m ∧ m ≠ 0) | null | false |
ModP.preVal_eq_zero | Mathlib.RingTheory.Perfection | ∀ {K : Type u₁} [inst : Field K] {v : Valuation K NNReal} {O : Type u₂} [inst_1 : CommRing O] [inst_2 : Algebra O K],
v.Integers O → ∀ {p : ℕ} {x : ModP O p}, ModP.preVal K v O p x = 0 ↔ x = 0 | null | true |
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 |
Finset.mem_coe | Mathlib.Data.Finset.Defs | ∀ {α : Type u_1} {a : α} {s : Finset α}, a ∈ ↑s ↔ a ∈ s | null | true |
Lean.SubExpr.Pos.pushAppFn | Lean.SubExpr | Lean.SubExpr.Pos → Lean.SubExpr.Pos | null | true |
_private.Aesop.Tree.TreeM.0.Aesop.mkInitialTree.match_1 | Aesop.Tree.TreeM | (motive : Aesop.ForwardState × Array Aesop.ForwardRuleMatch → Sort u_1) →
(__discr : Aesop.ForwardState × Array Aesop.ForwardRuleMatch) →
((forwardState : Aesop.ForwardState) → (ms : Array Aesop.ForwardRuleMatch) → motive (forwardState, ms)) →
motive __discr | 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 |
_private.Mathlib.LinearAlgebra.LinearIndependent.Lemmas.0.exists_of_linearIndepOn_of_finite_span._simp_1_13 | Mathlib.LinearAlgebra.LinearIndependent.Lemmas | ∀ {α : Type u} {a b : Set α}, (a = b) = ∀ (x : α), x ∈ a ↔ x ∈ b | 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 |
MonoidAlgebra.liftNCAlgHom._proof_1 | Mathlib.Algebra.MonoidAlgebra.Basic | ∀ {R : Type u_3} {A : Type u_1} {B : Type u_2} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Semiring B]
[inst_3 : Algebra R A] [inst_4 : Algebra R B], RingHomClass (A →ₐ[R] B) A B | null | false |
Std.Http.Chunk.mk.sizeOf_spec | Std.Http.Data.Chunk | ∀ (data : ByteArray) (extensions : Array (Std.Http.Chunk.ExtensionName × Option Std.Http.Chunk.ExtensionValue)),
sizeOf { data := data, extensions := extensions } = 1 + sizeOf data + sizeOf extensions | null | true |
ContDiffWithinAt.congr_of_mem | Mathlib.Analysis.Calculus.ContDiff.Defs | ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {E : Type uE} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {F : Type uF} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {s : Set E}
{f f₁ : E → F} {x : E} {n : WithTop ℕ∞},
ContDiffWithinAt 𝕜 n f s x → (∀ y ∈ s, f₁ y = f y) → x ∈ s →... | null | true |
isIntegral_algebraMap_iff | Mathlib.RingTheory.IntegralClosure.IsIntegral.Basic | ∀ {R : Type u_1} {A : Type u_2} {B : Type u_3} [inst : CommRing R] [inst_1 : CommRing A] [inst_2 : Ring B]
[inst_3 : Algebra R A] [inst_4 : Algebra R B] [inst_5 : Algebra A B] [IsScalarTower R A B] {x : A},
Function.Injective ⇑(algebraMap A B) → (IsIntegral R ((algebraMap A B) x) ↔ IsIntegral R x) | 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 |
instAlgebraCliffordAlgebra._proof_6 | Mathlib.LinearAlgebra.CliffordAlgebra.Basic | ∀ {R : Type u_1} [inst : CommRing R] {M : Type u_2} [inst_1 : AddCommGroup M] [inst_2 : Module R M]
(Q : QuadraticForm R M) (r : R) (x : CliffordAlgebra Q), r • x = (instAlgebraCliffordAlgebra._aux_3 Q) r * x | null | false |
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 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.