name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
Aesop.instToJsonPhaseName.toJson | Aesop.Rule.Name | Aesop.PhaseName → Lean.Json | true |
Std.PRange.UpwardEnumerable.Map.PreservesLT.casesOn | Init.Data.Range.Polymorphic.Map | {α : Type u_1} →
{β : Type u_2} →
[inst : Std.PRange.UpwardEnumerable α] →
[inst_1 : Std.PRange.UpwardEnumerable β] →
[inst_2 : LT α] →
[inst_3 : LT β] →
{f : Std.PRange.UpwardEnumerable.Map α β} →
{motive : f.PreservesLT → Sort u} →
(t : f.Preserv... | false |
_private.Lean.Elab.Match.0.Lean.Elab.Term.getIndexToInclude? | Lean.Elab.Match | Lean.Expr → List ℕ → Lean.Elab.TermElabM (Option Lean.Expr) | true |
Std.DTreeMap.Internal.Impl.toListModel_insertMin | Std.Data.DTreeMap.Internal.WF.Lemmas | ∀ {α : Type u} {β : α → Type v} [Ord α] {k : α} {v : β k} {t : Std.DTreeMap.Internal.Impl α β} {h : t.Balanced},
(Std.DTreeMap.Internal.Impl.insertMin k v t h).impl.toListModel = ⟨k, v⟩ :: t.toListModel | true |
ContinuousAffineMap._sizeOf_inst | Mathlib.Topology.Algebra.ContinuousAffineMap | (R : Type u_1) →
{V : Type u_2} →
{W : Type u_3} →
(P : Type u_4) →
(Q : Type u_5) →
{inst : Ring R} →
{inst_1 : AddCommGroup V} →
{inst_2 : Module R V} →
{inst_3 : TopologicalSpace P} →
{inst_4 : AddTorsor V P} →
... | false |
MulOpposite.instNonUnitalCommCStarAlgebra._proof_1 | Mathlib.Analysis.CStarAlgebra.Classes | ∀ {A : Type u_1} [inst : NonUnitalCommCStarAlgebra A], CompleteSpace Aᵐᵒᵖ | false |
FormalMultilinearSeries.ofScalars_radius_eq_inv_of_tendsto_ENNReal | Mathlib.Analysis.Analytic.OfScalars | ∀ {𝕜 : Type u_1} (E : Type u_2) [inst : NontriviallyNormedField 𝕜] [inst_1 : NormedRing E] [inst_2 : NormedAlgebra 𝕜 E]
(c : ℕ → 𝕜) [NormOneClass E] {r : ENNReal},
Filter.Tendsto (fun n => ENNReal.ofReal ‖c n.succ‖ / ENNReal.ofReal ‖c n‖) Filter.atTop (nhds r) →
(FormalMultilinearSeries.ofScalars E c).radiu... | true |
CategoryTheory.Limits.pushout.instIsIsoCodiagonalOfEpi | Mathlib.CategoryTheory.Limits.Shapes.Diagonal | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {X Y : C} (f : X ⟶ Y)
[inst_1 : CategoryTheory.Limits.HasPushout f f] [CategoryTheory.Epi f],
CategoryTheory.IsIso (CategoryTheory.Limits.pushout.codiagonal f) | true |
Algebra.QuasiFiniteAt.of_isOpen_singleton_fiber | Mathlib.RingTheory.ZariskisMainTheorem | ∀ {R : Type u_1} {S : Type u_2} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S]
[Algebra.FiniteType R S] (q : PrimeSpectrum S), IsOpen {⟨q, ⋯⟩} → Algebra.QuasiFiniteAt R q.asIdeal | true |
LinearIsometryEquiv.instEquivLike._proof_1 | Mathlib.Analysis.Normed.Operator.LinearIsometry | ∀ {R : Type u_1} {R₂ : Type u_2} {E : Type u_3} {E₂ : Type u_4} [inst : Semiring R] [inst_1 : Semiring R₂]
{σ₁₂ : R →+* R₂} {σ₂₁ : R₂ →+* R} [inst_2 : RingHomInvPair σ₁₂ σ₂₁] [inst_3 : RingHomInvPair σ₂₁ σ₁₂]
[inst_4 : SeminormedAddCommGroup E] [inst_5 : SeminormedAddCommGroup E₂] [inst_6 : Module R E] [inst_7 : Mo... | false |
CategoryTheory.ShortComplex.Homotopy.sub | Mathlib.Algebra.Homology.ShortComplex.Preadditive | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
[inst_1 : CategoryTheory.Preadditive C] →
{S₁ S₂ : CategoryTheory.ShortComplex C} →
{φ₁ φ₂ φ₃ φ₄ : S₁ ⟶ S₂} →
CategoryTheory.ShortComplex.Homotopy φ₁ φ₂ →
CategoryTheory.ShortComplex.Homotopy φ₃ φ₄ → CategoryTheor... | true |
Batteries.CodeAction.TacticCodeActionEntry.mk.inj | Batteries.CodeAction.Attr | ∀ {declName : Lean.Name} {tacticKinds : Array Lean.Name} {declName_1 : Lean.Name} {tacticKinds_1 : Array Lean.Name},
{ declName := declName, tacticKinds := tacticKinds } = { declName := declName_1, tacticKinds := tacticKinds_1 } →
declName = declName_1 ∧ tacticKinds = tacticKinds_1 | true |
Finset.min'_eq_sorted_zero | Mathlib.Data.Finset.Sort | ∀ {α : Type u_1} [inst : LinearOrder α] {s : Finset α} {h : s.Nonempty}, s.min' h = (s.sort fun a b => a ≤ b)[0] | true |
instFieldCyclotomicField._proof_64 | Mathlib.NumberTheory.Cyclotomic.Basic | ∀ (n : ℕ) (K : Type u_1) [inst : Field K], 0⁻¹ = 0 | false |
RingCon.coe_zsmul._simp_1 | Mathlib.RingTheory.Congruence.Defs | ∀ {R : Type u_1} [inst : AddGroup R] [inst_1 : Mul R] (c : RingCon R) (z : ℤ) (x : R), z • ↑x = ↑(z • x) | false |
Function.update_comp_eq_of_forall_ne' | Mathlib.Logic.Function.Basic | ∀ {α : Sort u} {β : α → Sort v} [inst : DecidableEq α] {α' : Sort u_1} (g : (a : α) → β a) {f : α' → α} {i : α}
(a : β i), (∀ (x : α'), f x ≠ i) → (fun j => Function.update g i a (f j)) = fun j => g (f j) | true |
Module.Finite.exists_fin_quot_equiv | Mathlib.RingTheory.Finiteness.Cardinality | ∀ (R : Type u_3) (M : Type u_4) [inst : Ring R] [inst_1 : AddCommGroup M] [inst_2 : Module R M] [Module.Finite R M],
∃ n S, Nonempty (((Fin n → R) ⧸ S) ≃ₗ[R] M) | true |
_private.Mathlib.CategoryTheory.Filtered.Basic.0.CategoryTheory.IsFiltered.crown₄.match_1_1 | Mathlib.CategoryTheory.Filtered.Basic | (motive : Fin 0 → Sort u_1) → (a : Fin 0) → motive a | false |
Lean.Lsp.TextDocumentEdit.ctorIdx | Lean.Data.Lsp.Basic | Lean.Lsp.TextDocumentEdit → ℕ | false |
Vector.instDecidableExistsVectorZero | Init.Data.Vector.Lemmas | {α : Type u_1} → (P : Vector α 0 → Prop) → [Decidable (P #v[])] → Decidable (∃ xs, P xs) | true |
AddCommGrpCat.hasColimit_of_small_quot | Mathlib.Algebra.Category.Grp.Colimits | ∀ {J : Type u} [inst : CategoryTheory.Category.{v, u} J] (F : CategoryTheory.Functor J AddCommGrpCat)
[inst_1 : DecidableEq J], Small.{w, max u w} (AddCommGrpCat.Colimits.Quot F) → CategoryTheory.Limits.HasColimit F | true |
_private.Mathlib.Topology.Inseparable.0.inseparable_prod._simp_1_2 | Mathlib.Topology.Inseparable | ∀ {α : Type u_1} {β : Type u_2} {f₁ f₂ : Filter α} {g₁ g₂ : Filter β} [f₁.NeBot] [g₁.NeBot],
(f₁ ×ˢ g₁ = f₂ ×ˢ g₂) = (f₁ = f₂ ∧ g₁ = g₂) | false |
Subsemigroup.comap_top | Mathlib.Algebra.Group.Subsemigroup.Operations | ∀ {M : Type u_1} {N : Type u_2} [inst : Mul M] [inst_1 : Mul N] (f : M →ₙ* N), Subsemigroup.comap f ⊤ = ⊤ | true |
MeasureTheory.SimpleFunc.instNonAssocSemiring._proof_4 | Mathlib.MeasureTheory.Function.SimpleFunc | ∀ {α : Type u_1} {β : Type u_2} [inst : MeasurableSpace α] [inst_1 : NonAssocSemiring β],
autoParam (∀ (n : ℕ), ↑(n + 1) = ↑n + 1) AddMonoidWithOne.natCast_succ._autoParam | false |
_private.Mathlib.RingTheory.Polynomial.Bernstein.0.bernsteinPolynomial.variance._simp_1_2 | Mathlib.RingTheory.Polynomial.Bernstein | ∀ {G : Type u_1} [inst : Semigroup G] (a b c : G), a * (b * c) = a * b * c | false |
normalize_eq_zero._simp_1 | Mathlib.Algebra.GCDMonoid.Basic | ∀ {α : Type u_1} [inst : CommMonoidWithZero α] [inst_1 : NormalizationMonoid α] {x : α}, (normalize x = 0) = (x = 0) | false |
CategoryTheory.Functor.mapCoconeWhisker_hom_hom | Mathlib.CategoryTheory.Limits.Cones | ∀ {J : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} J] {K : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} K]
{C : Type u₃} [inst_2 : CategoryTheory.Category.{v₃, u₃} C] {D : Type u₄}
[inst_3 : CategoryTheory.Category.{v₄, u₄} D] (H : CategoryTheory.Functor C D) {F : CategoryTheory.Functor J C}
{E : Cat... | true |
Polynomial.orderOf_root_cyclotomic_dvd | Mathlib.RingTheory.Polynomial.Cyclotomic.Basic | ∀ {n : ℕ} (hpos : 0 < n) {p : ℕ} [inst : Fact (Nat.Prime p)] {a : ℕ}
(hroot : (Polynomial.cyclotomic n (ZMod p)).IsRoot ((Nat.castRingHom (ZMod p)) a)),
orderOf (ZMod.unitOfCoprime a ⋯) ∣ n | true |
Equiv.setCongr | Mathlib.Logic.Equiv.Set | {α : Type u_3} → {s t : Set α} → s = t → ↑s ≃ ↑t | true |
_private.Mathlib.GroupTheory.SpecificGroups.Dihedral.0.instDecidableEqDihedralGroup.decEq.match_1.eq_4 | Mathlib.GroupTheory.SpecificGroups.Dihedral | ∀ {n : ℕ} (motive : DihedralGroup n → DihedralGroup n → Sort u_1) (a b : ZMod n)
(h_1 : (a b : ZMod n) → motive (DihedralGroup.r a) (DihedralGroup.r b))
(h_2 : (a a_1 : ZMod n) → motive (DihedralGroup.r a) (DihedralGroup.sr a_1))
(h_3 : (a a_1 : ZMod n) → motive (DihedralGroup.sr a) (DihedralGroup.r a_1))
(h_4 ... | true |
Nat.getD_toList_ric_eq_fallback | Init.Data.Range.Polymorphic.NatLemmas | ∀ {n i fallback : ℕ}, n < i → (*...=n).toList.getD i fallback = fallback | true |
_private.Mathlib.Topology.UniformSpace.Compact.0.IsClosed.relPreimage_of_isCompact._simp_1_1 | Mathlib.Topology.UniformSpace.Compact | ∀ {α : Type u} (s : Set α) (x : α), (x ∈ sᶜ) = (x ∉ s) | false |
SSet.instFiniteObjOppositeSimplexCategoryTensorObj | Mathlib.AlgebraicTopology.SimplicialSet.Monoidal | ∀ (X Y : SSet) (n : SimplexCategoryᵒᵖ) [Finite (X.obj n)] [Finite (Y.obj n)],
Finite ((CategoryTheory.MonoidalCategoryStruct.tensorObj X Y).obj n) | true |
antitone_toDual_comp_iff | Mathlib.Order.Monotone.Basic | ∀ {α : Type u} {β : Type v} [inst : Preorder α] [inst_1 : Preorder β] {f : α → β},
Antitone (⇑OrderDual.toDual ∘ f) ↔ Monotone f | true |
MulEquiv.piMultiplicative._proof_2 | Mathlib.Algebra.Group.Equiv.TypeTags | ∀ {ι : Type u_1} (K : ι → Type u_2),
Function.RightInverse (fun x => Multiplicative.ofAdd fun i => Multiplicative.toAdd (x i)) fun x i =>
Multiplicative.ofAdd (Multiplicative.toAdd x i) | false |
_private.Mathlib.MeasureTheory.Constructions.BorelSpace.Basic.0.Pi.opensMeasurableSpace_of_subsingleton._simp_2 | Mathlib.MeasureTheory.Constructions.BorelSpace.Basic | ∀ {α : Type u_1} {β : Type u_2} [t : TopologicalSpace β] {f : α → β} {s : Set α},
IsOpen s = (s ∈ Set.preimage f '' {s | IsOpen s}) | false |
_private.Init.Data.BitVec.Lemmas.0.BitVec.shiftLeft_eq_concat_of_lt._proof_1_1 | Init.Data.BitVec.Lemmas | ∀ {w n : ℕ}, ∀ i < w, ¬i < n → ¬i - n < w → False | false |
ContDiffMapSupportedIn._sizeOf_inst | Mathlib.Analysis.Distribution.ContDiffMapSupportedIn | (E : Type u_2) →
(F : Type u_3) →
{inst : NormedAddCommGroup E} →
{inst_1 : NormedSpace ℝ E} →
{inst_2 : NormedAddCommGroup F} →
{inst_3 : NormedSpace ℝ F} →
(n : ℕ∞) →
(K : TopologicalSpace.Compacts E) → [SizeOf E] → [SizeOf F] → SizeOf (ContDiffMapSupportedIn E ... | false |
Rep.indCoindIso | Mathlib.RepresentationTheory.FiniteIndex | {k G : Type u} →
[inst : CommRing k] →
[inst_1 : Group G] →
{S : Subgroup G} →
[DecidableRel ⇑(QuotientGroup.rightRel S)] →
[S.FiniteIndex] → (A : Rep.{u, u, u} k ↥S) → Rep.ind S.subtype A ≅ Rep.coind.{u, u, u, u} S.subtype A | true |
_private.Mathlib.Combinatorics.SetFamily.AhlswedeZhang.0.Finset.sups_aux | Mathlib.Combinatorics.SetFamily.AhlswedeZhang | ∀ {α : Type u_1} [inst : DistribLattice α] [inst_1 : DecidableEq α] {s t : Finset α} {a : α},
a ∈ upperClosure ↑(s ⊻ t) ↔ a ∈ upperClosure ↑s ∧ a ∈ upperClosure ↑t | true |
List.reverseAux_reverseAux_nil | Init.Data.List.Lemmas | ∀ {α : Type u_1} {as bs : List α}, (as.reverseAux bs).reverseAux [] = bs.reverseAux as | true |
Rep.instAdditiveResFunctor | Mathlib.RepresentationTheory.Rep.Res | ∀ {k : Type u} [inst : CommRing k] {G : Type v1} {H : Type v2} [inst_1 : Monoid G] [inst_2 : Monoid H] (f : H →* G),
(Rep.resFunctor f).Additive | true |
Lean.Meta.Grind.EMatchTheoremConstraint.guard.injEq | Lean.Meta.Tactic.Grind.Extension | ∀ (e e_1 : Lean.Expr),
(Lean.Meta.Grind.EMatchTheoremConstraint.guard e = Lean.Meta.Grind.EMatchTheoremConstraint.guard e_1) = (e = e_1) | true |
CategoryTheory.eHom_whisker_cancel_inv | Mathlib.CategoryTheory.Enriched.Ordinary.Basic | ∀ (V : Type u') [inst : CategoryTheory.Category.{v', u'} V] [inst_1 : CategoryTheory.MonoidalCategory V] {C : Type u}
[inst_2 : CategoryTheory.Category.{v, u} C] [inst_3 : CategoryTheory.EnrichedOrdinaryCategory V C] {X Y Y₁ Z : C}
(α : Y ≅ Y₁),
CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCat... | true |
_private.Mathlib.Data.Fin.Tuple.Reflection.0.FinVec.Forall.match_1.eq_1 | Mathlib.Data.Fin.Tuple.Reflection | ∀ {α : Type u_2} (motive : (x : ℕ) → ((Fin x → α) → Prop) → Sort u_1) (P : (Fin 0 → α) → Prop)
(h_1 : (P : (Fin 0 → α) → Prop) → motive 0 P) (h_2 : (n : ℕ) → (P : (Fin (n + 1) → α) → Prop) → motive n.succ P),
(match 0, P with
| 0, P => h_1 P
| n.succ, P => h_2 n P) =
h_1 P | true |
CategoryTheory.Abelian.SpectralObject.zero₁_assoc | Mathlib.Algebra.Homology.SpectralObject.Basic | ∀ {C : Type u_1} {ι : Type u_2} [inst : CategoryTheory.Category.{u_3, u_1} C]
[inst_1 : CategoryTheory.Category.{u_4, u_2} ι] [inst_2 : CategoryTheory.Abelian C]
(X : CategoryTheory.Abelian.SpectralObject C ι) {i j k : ι} (f : i ⟶ j) (g : j ⟶ k) (fg : i ⟶ k)
(h : CategoryTheory.CategoryStruct.comp f g = fg) (n₀ n... | true |
Module.Basis.range_extend | Mathlib.LinearAlgebra.Basis.VectorSpace | ∀ {K : Type u_3} {V : Type u_4} [inst : DivisionRing K] [inst_1 : AddCommGroup V] [inst_2 : Module K V] {s : Set V}
(hs : LinearIndepOn K id s), Set.range ⇑(Module.Basis.extend hs) = hs.extend ⋯ | true |
_private.Lean.Meta.Tactic.Grind.AC.Eq.0.Lean.Meta.Grind.AC.withExprs.go.match_1.eq_2 | Lean.Meta.Tactic.Grind.AC.Eq | ∀ (motive : List ℕ → List ℕ → Sort u_1) (x : List ℕ) (h_1 : (x : List ℕ) → motive [] x)
(h_2 : (x : List ℕ) → motive x [])
(h_3 : (id₁ : ℕ) → (ids₁ : List ℕ) → (id₂ : ℕ) → (ids₂ : List ℕ) → motive (id₁ :: ids₁) (id₂ :: ids₂)),
(x = [] → False) →
(match x, [] with
| [], x => h_1 x
| x, [] => h_2 x
... | true |
NonUnitalSubsemiring.prodEquiv | Mathlib.RingTheory.NonUnitalSubsemiring.Basic | {R : Type u} →
{S : Type v} →
[inst : NonUnitalNonAssocSemiring R] →
[inst_1 : NonUnitalNonAssocSemiring S] →
(s : NonUnitalSubsemiring R) → (t : NonUnitalSubsemiring S) → ↥(s.prod t) ≃+* ↥s × ↥t | true |
Std.TreeMap.Raw.contains_iff_mem._simp_1 | Std.Data.TreeMap.Raw.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.TreeMap.Raw α β cmp} {k : α},
(t.contains k = true) = (k ∈ t) | false |
Lean.Elab.Command.InductiveElabStep2 | Lean.Elab.MutualInductive | Type | true |
_private.Mathlib.Tactic.CategoryTheory.Elementwise.0.Mathlib.Tactic.Elementwise.mkUnusedName.loop | Mathlib.Tactic.CategoryTheory.Elementwise | List Lean.Name → Lean.Name → optParam ℕ 0 → Lean.Name | true |
GradedAlgHom.mk.injEq | Mathlib.RingTheory.GradedAlgebra.AlgHom | ∀ {R : Type u_1} {A : Type u_2} {B : Type u_3} {ι : Type u_4} [inst : CommSemiring R] [inst_1 : Semiring A]
[inst_2 : Semiring B] [inst_3 : Algebra R A] [inst_4 : Algebra R B] [inst_5 : DecidableEq ι] [inst_6 : AddMonoid ι]
{𝒜 : ι → Submodule R A} {ℬ : ι → Submodule R B} [inst_7 : GradedAlgebra 𝒜] [inst_8 : Grade... | true |
Lean.Meta.Grind.AC.ProofM.State.exprDecls | Lean.Meta.Tactic.Grind.AC.Proof | Lean.Meta.Grind.AC.ProofM.State → Std.HashMap Lean.Grind.AC.Expr Lean.Expr | true |
Lean.Parser.Module.prelude | Lean.Parser.Module | Lean.Parser.Parser | true |
Array.getElem_toList | Init.Data.Array.Basic | ∀ {α : Type u} {xs : Array α} {i : ℕ} (h : i < xs.size), xs.toList[i] = xs[i] | true |
_private.Init.Data.Iterators.Lemmas.Consumers.Collect.0.Std.Iter.atIdxSlow?.match_1.eq_2 | Init.Data.Iterators.Lemmas.Consumers.Collect | ∀ {α β : Type u_1} [inst : Std.Iterator α Id β] (it : Std.Iter β)
(motive :
(n : ℕ) →
((a' : Std.Iter β) →
(b' : ℕ) →
InvImage (Prod.Lex WellFoundedRelation.rel Std.IterM.TerminationMeasures.Productive.Rel)
(fun p => (p.snd, p.fst.finitelyManySkips!)) ⟨a', b'⟩ ⟨it, n⟩ →... | true |
Aesop.PatSubstSource.casesOn | Aesop.Forward.State | {motive : Aesop.PatSubstSource → Sort u} →
(t : Aesop.PatSubstSource) →
((fvarId : Lean.FVarId) → motive (Aesop.PatSubstSource.hyp fvarId)) → motive Aesop.PatSubstSource.target → motive t | false |
LieHom.mem_idealRange_iff._simp_1 | Mathlib.Algebra.Lie.Ideal | ∀ {R : Type u} {L : Type v} {L' : Type w₂} [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : LieRing L']
[inst_3 : LieAlgebra R L'] [inst_4 : LieAlgebra R L] (f : L →ₗ⁅R⁆ L'),
f.IsIdealMorphism → ∀ {y : L'}, (y ∈ f.idealRange) = ∃ x, f x = y | false |
MeasureTheory.innerRegular_map_add_left | Mathlib.MeasureTheory.Group.Measure | ∀ {G : Type u_1} [inst : MeasurableSpace G] [inst_1 : TopologicalSpace G] [BorelSpace G] {μ : MeasureTheory.Measure G}
[inst_3 : AddGroup G] [IsTopologicalAddGroup G] [μ.InnerRegular] (g : G),
(MeasureTheory.Measure.map (fun x => g + x) μ).InnerRegular | true |
_private.Mathlib.RingTheory.Support.0.Module.mem_support_iff_of_finite._simp_1_2 | Mathlib.RingTheory.Support | ∀ {R : Type u_1} {M : Type u_2} [inst : CommSemiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] (g : M)
(r : R), (r ∈ (R ∙ g).annihilator) = (r • g = 0) | false |
CategoryTheory.ObjectProperty.strictLimitsOfShape_monotone | Mathlib.CategoryTheory.ObjectProperty.LimitsOfShape | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {P : CategoryTheory.ObjectProperty C} (J : Type u')
[inst_1 : CategoryTheory.Category.{v', u'} J] {Q : CategoryTheory.ObjectProperty C},
P ≤ Q → P.strictLimitsOfShape J ≤ Q.strictLimitsOfShape J | true |
List.eraseIdx_modify_of_eq | Init.Data.List.Nat.Modify | ∀ {α : Type u_1} (f : α → α) (i : ℕ) (l : List α), (l.modify i f).eraseIdx i = l.eraseIdx i | true |
ULift.ring._proof_3 | Mathlib.Algebra.Ring.ULift | ∀ {R : Type u_2} [inst : Ring R] (n : ℕ) (a : ULift.{u_1, u_2} R),
SubNegMonoid.zsmul (↑n.succ) a = SubNegMonoid.zsmul (↑n) a + a | false |
AEMeasurable.cexp | Mathlib.MeasureTheory.Function.SpecialFunctions.Basic | ∀ {α : Type u_1} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} {f : α → ℂ},
AEMeasurable f μ → AEMeasurable (fun x => Complex.exp (f x)) μ | true |
Sym2.hrec._proof_1 | Mathlib.Data.Sym.Sym2 | ∀ {α : Type u_1} {motive : Sym2 α → Sort u_2} (f : (a b : α) → motive s(a, b)),
(∀ (a b : α), f a b ≍ f b a) →
∀ (a b : α × α),
Sym2.Rel α a b →
(fun x =>
match x with
| (a, b) => f a b)
a ≍
(fun x =>
match x with
| (a, b)... | false |
PresheafOfModules.instMonoidalCompOppositeCommRingCatRingCatForget₂RingHomCarrierCarrierOpPushforward₀OfCommRingCat._proof_5 | Mathlib.Algebra.Category.ModuleCat.Presheaf.PushforwardZeroMonoidal | ∀ {C : Type u_2} {D : Type u_5} [inst : CategoryTheory.Category.{u_3, u_2} C]
[inst_1 : CategoryTheory.Category.{u_4, u_5} D] (F : CategoryTheory.Functor C D)
(R : CategoryTheory.Functor Dᵒᵖ CommRingCat)
(x : PresheafOfModules (R.comp (CategoryTheory.forget₂ CommRingCat RingCat))),
(CategoryTheory.MonoidalCateg... | false |
_private.Init.WFComputable.0.Acc.recC._unary._proof_6 | Init.WFComputable | ∀ {α : Sort u_1} {r : α → α → Prop} (y : (a : α) ×' Acc r a), Acc r y.1 | false |
Lean.MonadFileMap.noConfusion | Lean.Data.Position | {P : Sort u} →
{m : Type → Type} →
{t : Lean.MonadFileMap m} →
{m' : Type → Type} → {t' : Lean.MonadFileMap m'} → m = m' → t ≍ t' → Lean.MonadFileMap.noConfusionType P t t' | false |
String.Slice.Subslice.noConfusionType | Init.Data.String.Subslice | Sort u → {s : String.Slice} → s.Subslice → {s' : String.Slice} → s'.Subslice → Sort u | false |
Polynomial.aeval.eq_1 | Mathlib.Algebra.Polynomial.Bivariate | ∀ {R : Type u} {A : Type z} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A] (x : A),
Polynomial.aeval x = (Polynomial.aevalEquiv R A) x | true |
CategoryTheory.JointlyFaithful.map_injective | Mathlib.CategoryTheory.Functor.ReflectsIso.Jointly | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_4, u_1} C] {I : Type u_2} {D : I → Type u_3}
[inst_1 : (i : I) → CategoryTheory.Category.{u_5, u_3} (D i)] {F : (i : I) → CategoryTheory.Functor C (D i)},
CategoryTheory.JointlyFaithful F → ∀ {X Y : C} {f g : X ⟶ Y}, (∀ (i : I), (F i).map f = (F i).map g) → f = g | true |
TopCat.Presheaf.isSheaf_on_punit_iff_isTerminal | Mathlib.Topology.Sheaves.PUnit | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (F : TopCat.Presheaf C (TopCat.of PUnit.{u_1 + 1})),
F.IsSheaf ↔ Nonempty (CategoryTheory.Limits.IsTerminal (F.obj (Opposite.op ⊥))) | true |
CategoryTheory.ShortComplex.homologyMap_smul | Mathlib.Algebra.Homology.ShortComplex.Linear | ∀ {R : Type u_1} {C : Type u_2} [inst : Semiring R] [inst_1 : CategoryTheory.Category.{v_1, u_2} C]
[inst_2 : CategoryTheory.Preadditive C] [inst_3 : CategoryTheory.Linear R C] {S₁ S₂ : CategoryTheory.ShortComplex C}
(φ : S₁ ⟶ S₂) (a : R) [inst_4 : S₁.HasHomology] [inst_5 : S₂.HasHomology],
CategoryTheory.ShortCo... | true |
Nat.gcd_mul_left_sub_right | Init.Data.Nat.Gcd | ∀ {m n k : ℕ}, n ≤ m * k → m.gcd (m * k - n) = m.gcd n | true |
_private.Std.Data.Internal.List.Associative.0.Std.Internal.List.getValue_filter_not_contains._simp_1_1 | Std.Data.Internal.List.Associative | ∀ {α : Type u} {β : Type v} [inst : BEq α] {l : List ((_ : α) × β)} {a : α}
(h : Std.Internal.List.containsKey a l = true),
some (Std.Internal.List.getValue a l h) = Std.Internal.List.getValue? a l | false |
Mathlib.Tactic.Translate.etaExpandN | Mathlib.Tactic.Translate.Core | ℕ → Lean.Expr → Lean.MetaM Lean.Expr | true |
Lean.Parser.Term.letrec._regBuiltin.Lean.Parser.Termination.partialFixpoint.formatter_35 | Lean.Parser.Term | IO Unit | false |
Cardinal.add_nat_inj | Mathlib.SetTheory.Cardinal.Arithmetic | ∀ {α β : Cardinal.{u_1}} (n : ℕ), α + ↑n = β + ↑n ↔ α = β | true |
_private.Mathlib.Algebra.MonoidAlgebra.NoZeroDivisors.0.MonoidAlgebra.instIsLeftCancelMulZeroOfIsCancelAddOfUniqueProds._simp_3 | Mathlib.Algebra.MonoidAlgebra.NoZeroDivisors | ∀ {G : Type u_1} [inst : Add G] [IsRightCancelAdd G] {a b c : G}, (b + a = c + a) = (b = c) | false |
TopologicalSpace.OpenNhdsOf.rec | Mathlib.Topology.Sets.Opens | {α : Type u_2} →
[inst : TopologicalSpace α] →
{x : α} →
{motive : TopologicalSpace.OpenNhdsOf x → Sort u} →
((toOpens : TopologicalSpace.Opens α) →
(mem' : x ∈ toOpens.carrier) → motive { toOpens := toOpens, mem' := mem' }) →
(t : TopologicalSpace.OpenNhdsOf x) → motive t | false |
HomologicalComplex.Hom.comm_from | Mathlib.Algebra.Homology.HomologicalComplex | ∀ {ι : Type u_1} {V : Type u} [inst : CategoryTheory.Category.{v, u} V]
[inst_1 : CategoryTheory.Limits.HasZeroMorphisms V] {c : ComplexShape ι} {C₁ C₂ : HomologicalComplex V c}
(f : C₁.Hom C₂) (i : ι),
CategoryTheory.CategoryStruct.comp (f.f i) (C₂.dFrom i) = CategoryTheory.CategoryStruct.comp (C₁.dFrom i) (f.ne... | true |
_private.Mathlib.Order.Nucleus.0.Nucleus.range.instFrameMinimalAxioms._simp_1 | Mathlib.Order.Nucleus | ∀ {α : Type u_2} [inst : LE α] {p : α → Prop} {x y : Subtype p}, (x ≤ y) = (↑x ≤ ↑y) | false |
StarMonoidHom.coe_one | Mathlib.Algebra.Star.MonoidHom | ∀ {A : Type u_2} [inst : Monoid A] [inst_1 : Star A], ⇑1 = id | true |
CategoryTheory.Bicategory.leftAdjointSquare.comp_hvcomp | Mathlib.CategoryTheory.Bicategory.Adjunction.Mate | ∀ {B : Type u} [inst : CategoryTheory.Bicategory B] {a b c d e f x y z : B} {g₁ : a ⟶ d} {h₁ : b ⟶ e} {k₁ : c ⟶ f}
{g₂ : d ⟶ x} {h₂ : e ⟶ y} {k₂ : f ⟶ z} {l₁ : a ⟶ b} {l₂ : b ⟶ c} {l₃ : d ⟶ e} {l₄ : e ⟶ f} {l₅ : x ⟶ y} {l₆ : y ⟶ z}
(α : CategoryTheory.CategoryStruct.comp g₁ l₃ ⟶ CategoryTheory.CategoryStruct.comp l... | true |
LieAlgebra.Basis.root_mem_or_mem_neg | Mathlib.Algebra.Lie.Basis | ∀ {ι : Type u_1} {K : Type u_2} {L : Type u_3} [inst : Fintype ι] [inst_1 : Field K] [inst_2 : CharZero K]
[inst_3 : LieRing L] [inst_4 : LieAlgebra K L] [inst_5 : FiniteDimensional K L] (b : LieAlgebra.Basis ι K L)
[inst_6 : LieModule.IsTriangularizable K (↥b.cartan) L] [inst_7 : LieAlgebra.IsKilling K L] (χ : ↥Li... | true |
PowerSeries.derivative_invOf | Mathlib.RingTheory.PowerSeries.Derivative | ∀ {R : Type u_1} [inst : CommRing R] (f : PowerSeries R) [inst_1 : Invertible f],
(PowerSeries.derivative R) ⅟f = -⅟f ^ 2 * (PowerSeries.derivative R) f | true |
DerivedCategory.triangleOfSESδ._proof_3 | Mathlib.Algebra.Homology.DerivedCategory.ShortExact | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Abelian C]
{S : CategoryTheory.ShortComplex (CochainComplex C ℤ)} (i : ℤ),
(HomologicalComplex.sc (CochainComplex.mappingCone S.f) i).HasHomology | false |
_private.Lean.Meta.Sym.Pattern.0.Lean.Meta.Sym.UnifyM.State.iPending | Lean.Meta.Sym.Pattern | Lean.Meta.Sym.UnifyM.State✝ → Array (Lean.Expr × Lean.Expr) | true |
Std.DHashMap.contains_of_contains_insertIfNew' | Std.Data.DHashMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {x : BEq α} {x_1 : Hashable α} {m : Std.DHashMap α β} [EquivBEq α] [LawfulHashable α]
{k a : α} {v : β k},
(m.insertIfNew k v).contains a = true → ¬((k == a) = true ∧ m.contains k = false) → m.contains a = true | true |
Perfection.instCommMonoid | Mathlib.RingTheory.Perfection | (M : Type u_1) → [inst : CommMonoid M] → (p : ℕ) → CommMonoid (Perfection M p) | true |
Finite.equivFinOfCardEq | Mathlib.Data.Finite.Card | {α : Type u_1} → [Finite α] → {n : ℕ} → Nat.card α = n → α ≃ Fin n | true |
NonUnitalSubring.center.instNonUnitalCommRing._proof_11 | Mathlib.RingTheory.NonUnitalSubring.Basic | ∀ (R : Type u_1) [inst : NonUnitalNonAssocRing R] (a b c : ↥(NonUnitalSubsemiring.center R)), a * b * c = a * (b * c) | false |
WithTop.le_coe_iff | Mathlib.Order.WithBot | ∀ {α : Type u_1} {a : α} [inst : LE α] {x : WithTop α}, x ≤ ↑a ↔ ∃ b, x = ↑b ∧ b ≤ a | true |
IsNowhereDense.closure | Mathlib.Topology.GDelta.Basic | ∀ {X : Type u_1} [inst : TopologicalSpace X] {s : Set X}, IsNowhereDense s → IsNowhereDense (closure s) | true |
CategoryTheory.SimplicialObject.Homotopy.h_succ_comp_δ_castSucc_succ_assoc | Mathlib.AlgebraicTopology.SimplicialObject.Homotopy | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y : CategoryTheory.SimplicialObject C} {f g : X ⟶ Y}
(self : CategoryTheory.SimplicialObject.Homotopy f g) {n : ℕ} (j : Fin (n + 1)) {Z : C}
(h : Y.obj (Opposite.op (SimplexCategory.mk (n + 1))) ⟶ Z),
CategoryTheory.CategoryStruct.comp (self.h j.succ) (C... | true |
Real.«term√_» | Mathlib.Data.Real.Sqrt | Lean.ParserDescr | true |
UniformSpace.Completion.map_comp | Mathlib.Topology.UniformSpace.Completion | ∀ {α : Type u_1} [inst : UniformSpace α] {β : Type u_2} [inst_1 : UniformSpace β] {γ : Type u_3}
[inst_2 : UniformSpace γ] {g : β → γ} {f : α → β},
UniformContinuous g →
UniformContinuous f →
UniformSpace.Completion.map g ∘ UniformSpace.Completion.map f = UniformSpace.Completion.map (g ∘ f) | true |
MeasureTheory.Measure.join_zero | Mathlib.MeasureTheory.Measure.GiryMonad | ∀ {α : Type u_1} {mα : MeasurableSpace α}, MeasureTheory.Measure.join 0 = 0 | true |
Std.Internal.List.getValueCast_eraseKey | Std.Data.Internal.List.Associative | ∀ {α : Type u} {β : α → Type v} [inst : BEq α] [inst_1 : LawfulBEq α] {l : List ((a : α) × β a)} {k a : α}
{h : Std.Internal.List.containsKey a (Std.Internal.List.eraseKey k l) = true} (hl : Std.Internal.List.DistinctKeys l),
Std.Internal.List.getValueCast a (Std.Internal.List.eraseKey k l) h = Std.Internal.List.ge... | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.