name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
CategoryTheory.Limits.BinaryBicone.isLimitFstKernelFork._proof_2 | Mathlib.CategoryTheory.Limits.Shapes.BinaryBiproducts | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{X Y : C} {c : CategoryTheory.Limits.BinaryBicone X Y} (s : CategoryTheory.Limits.Fork c.fst 0)
{m : s.pt ⟶ c.fstKernelFork.pt},
CategoryTheory.CategoryStruct.comp m (CategoryTheory.Limits.Fork.ι c.f... | null | false |
_private.Mathlib.Data.List.Sort.0.List.sortedLT_iff_pairwise._proof_1_5 | Mathlib.Data.List.Sort | ∀ {α : Type u_1} {l : List α} (w : ℕ) (w_2 : w + 1 ≤ l.length), ↑⟨w, ⋯⟩ < l.length | null | false |
Polynomial.algEquivAevalXAddC._proof_1 | Mathlib.Algebra.Polynomial.AlgebraMap | ∀ {R : Type u_1} [inst : CommRing R] (t : R),
(Polynomial.X + Polynomial.C t).comp (Polynomial.X - Polynomial.C t) = Polynomial.X | null | false |
Matrix.IsFiniteCartan.instIsRootSystemElemProdForallIdxToRealisationInvertibleToRootPairing | Mathlib.LinearAlgebra.Matrix.Cartan.Realisation | ∀ {n : Type u_1} [inst : Fintype n] [inst_1 : DecidableEq n] {A : Matrix n n ℤ} (hA : A.IsFiniteCartan) (k : Type u_5)
[inst_2 : Field k] [inst_3 : CharZero k], (hA.toRootPairing k).IsRootSystem | null | true |
Lean.Compiler.LCNF.Simp.markSimplified | Lean.Compiler.LCNF.Simp.SimpM | Lean.Compiler.LCNF.Simp.SimpM Unit | Set the `simplified` flag to `true`. | true |
AlgebraicGeometry.Scheme.Pullback.diagonalCover.eq_1 | Mathlib.AlgebraicGeometry.Pullbacks | ∀ {X Y : AlgebraicGeometry.Scheme} (f : X ⟶ Y) (𝒰 : Y.OpenCover)
(𝒱 :
(i : (CategoryTheory.Precoverage.ZeroHypercover.pullback₁ f 𝒰).I₀) →
((CategoryTheory.Precoverage.ZeroHypercover.pullback₁ f 𝒰).X i).OpenCover),
AlgebraicGeometry.Scheme.Pullback.diagonalCover f 𝒰 𝒱 =
CategoryTheory.Precoverag... | null | true |
NonUnitalStarAlgHom.instZero._proof_2 | Mathlib.Algebra.Star.StarAlgHom | ∀ {R : Type u_2} {A : Type u_3} {B : Type u_1} [inst : Monoid R] [inst_1 : NonUnitalNonAssocSemiring A]
[inst_2 : DistribMulAction R A] [inst_3 : StarAddMonoid A] [inst_4 : NonUnitalNonAssocSemiring B]
[inst_5 : DistribMulAction R B] [inst_6 : StarAddMonoid B] (a : A),
(NonUnitalAlgHom.toDistribMulActionHom 0).to... | null | false |
Lean.Export.instCoeLevelEntry | Mathlib.Util.Export | Coe Lean.Level Lean.Export.Entry | null | true |
PowerSeries.isUnit_exp | Mathlib.RingTheory.PowerSeries.Exp | ∀ (A : Type u_4) [inst : Ring A] [inst_1 : Algebra ℚ A], IsUnit (PowerSeries.exp A) | null | true |
CommRingCat.Colimits.quot_mul | Mathlib.Algebra.Category.Ring.Colimits | ∀ {J : Type v} [inst : CategoryTheory.SmallCategory J] (F : CategoryTheory.Functor J CommRingCat)
(x y : CommRingCat.Colimits.Prequotient F),
Quot.mk (⇑(CommRingCat.Colimits.colimitSetoid F)) (x.mul y) =
(have this := Quot.mk (⇑(CommRingCat.Colimits.colimitSetoid F)) x;
this) *
have this := Quot.mk ... | null | true |
CategoryTheory.Limits.FormalCoproduct.mapPower_π_assoc | Mathlib.CategoryTheory.Limits.FormalCoproducts.Cech | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (U : CategoryTheory.Limits.FormalCoproduct C) {α β : Type}
[inst_1 : CategoryTheory.Limits.HasProductsOfShape α C] [inst_2 : CategoryTheory.Limits.HasProductsOfShape β C]
(f : α → β) (a : α) {Z : CategoryTheory.Limits.FormalCoproduct C} (h : U ⟶ Z),
Categor... | null | true |
Turing.PartrecToTM2.Λ'.instDecidableEq._proof_49 | Mathlib.Computability.TuringMachine.ToPartrec | ∀ (q : Turing.PartrecToTM2.Λ') (f : Option Turing.PartrecToTM2.Γ' → Turing.PartrecToTM2.Λ'),
¬q.succ = Turing.PartrecToTM2.Λ'.read f | null | false |
CategoryTheory.Functor.commShiftIso_inv_naturality | Mathlib.CategoryTheory.Shift.CommShift | ∀ {C : Type u_1} {D : Type u_2} [inst : CategoryTheory.Category.{v_1, u_1} C]
[inst_1 : CategoryTheory.Category.{v_2, u_2} D] (F : CategoryTheory.Functor C D) {A : Type u_4} [inst_2 : AddMonoid A]
[inst_3 : CategoryTheory.HasShift C A] [inst_4 : CategoryTheory.HasShift D A] [inst_5 : F.CommShift A] {X Y : C}
(f :... | null | true |
Equiv.divisionRing._proof_8 | Mathlib.Algebra.Field.TransferInstance | ∀ {α : Type u_2} {β : Type u_1} (e : α ≃ β) [inst : DivisionRing β] (x y : α),
e (e.symm (e.toFun x / e.toFun y)) = e.toFun x / e.toFun y | null | false |
Semiring.toGrindSemiring.match_1 | Mathlib.Algebra.Ring.GrindInstances | (motive : ℕ → Sort u_1) → (x : ℕ) → (Unit → motive 0) → (Unit → motive 1) → ((n : ℕ) → motive n.succ.succ) → motive x | null | false |
Nat.primeFactors_subset_of_mem_smoothNumbers | Mathlib.NumberTheory.SmoothNumbers | ∀ {m n : ℕ}, m ∈ n.smoothNumbers → m.primeFactors ⊆ n.primesBelow | The `Finset` of prime factors of an `n`-smooth number is contained in the `Finset`
of primes below `n`. | true |
Fin.Embedding.coe_cons | Mathlib.Data.Fin.Tuple.Embedding | ∀ {α : Type u_1} {n : ℕ} (x : Fin n ↪ α) {a : α} (ha : a ∉ Set.range ⇑x), ⇑(Fin.Embedding.cons x ha) = Fin.cons a ⇑x | null | true |
CategoryTheory.Functor.OneHypercoverDenseData.SieveStruct.noConfusionType | Mathlib.CategoryTheory.Sites.DenseSubsite.OneHypercoverDense | Sort u_1 →
{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} ... | null | false |
Std.TreeMap.size_add_size_eq_size_union_add_size_inter | Std.Data.TreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t₁ t₂ : Std.TreeMap α β cmp} [Std.TransCmp cmp],
t₁.size + t₂.size = (t₁ ∪ t₂).size + (t₁ ∩ t₂).size | null | true |
_private.Mathlib.Data.Set.Pairwise.Basic.0.Set.injOn_iff_pairwise_ne._simp_1_2 | Mathlib.Data.Set.Pairwise.Basic | ∀ {a b : Prop}, (¬a → ¬b) = (b → a) | null | false |
CategoryTheory.e_assoc' | Mathlib.CategoryTheory.Enriched.Basic | ∀ (V : Type v) [inst : CategoryTheory.Category.{w, v} V] [inst_1 : CategoryTheory.MonoidalCategory V] {C : Type u₁}
[inst_2 : CategoryTheory.EnrichedCategory V C] (W X Y Z : C),
CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCategoryStruct.associator (W ⟶[V] X) (X ⟶[V] Y) (Y ⟶[V] Z)).hom
(Ca... | null | true |
PresentedMonoid.ext | Mathlib.Algebra.PresentedMonoid.Basic | ∀ {α : Type u_2} {M : Type u_3} [inst : Monoid M] (rels : FreeMonoid α → FreeMonoid α → Prop)
{φ ψ : PresentedMonoid rels →* M}, (∀ (x : α), φ (PresentedMonoid.of rels x) = ψ (PresentedMonoid.of rels x)) → φ = ψ | null | true |
OrderDual.Ord.dual_dual | Mathlib.Order.OrderDual | ∀ (α : Type u_2) [H : Ord α], OrderDual.instOrd αᵒᵈ = H | null | true |
AddGroupSeminorm.instOne._proof_2 | Mathlib.Analysis.Normed.Group.Seminorm | ∀ {E : Type u_1} [inst : AddGroup E] [inst_1 : DecidableEq E], (if 0 = 0 then 0 else 1) = 0 | null | false |
ProfiniteAddGrp.limitConePtAux._proof_1 | Mathlib.Topology.Algebra.Category.ProfiniteGrp.Basic | ∀ {J : Type u_2} [inst : CategoryTheory.SmallCategory J] (F : CategoryTheory.Functor J ProfiniteAddGrp.{max u_2 u_1})
{a b : (j : J) → ↑(F.obj j).toProfinite.toTop},
a ∈ {x | ∀ ⦃i j : J⦄ (π : i ⟶ j), (ProfiniteAddGrp.Hom.hom (F.map π)) (x i) = x j} →
b ∈ {x | ∀ ⦃i j : J⦄ (π : i ⟶ j), (ProfiniteAddGrp.Hom.hom (F... | null | false |
_private.Init.Omega.IntList.0.List.getElem?_cons_succ | Init.Omega.IntList | ∀ {α : Type u_1} {a : α} {i : ℕ} {l : List α}, (a :: l)[i + 1]? = l[i]? | null | true |
CategoryTheory.eq_of_comp_right_eq | Mathlib.CategoryTheory.Category.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y : C} {f g : Y ⟶ X},
(∀ {Z : C} (h : Z ⟶ Y), CategoryTheory.CategoryStruct.comp h f = CategoryTheory.CategoryStruct.comp h g) → f = g | null | true |
Lean.Language.DynamicSnapshot.casesOn | Lean.Language.Basic | {motive : Lean.Language.DynamicSnapshot → Sort u} →
(t : Lean.Language.DynamicSnapshot) →
((val : Dynamic) →
(toSnapshotTreeM : Lean.Language.ToSnapshotTreeM Lean.Language.SnapshotTree) →
motive { val := val, toSnapshotTreeM := toSnapshotTreeM }) →
motive t | null | false |
Order.isPredPrelimitRecOn_of_isPredPrelimit | Mathlib.Order.SuccPred.Limit | ∀ {α : Type u_1} {b : α} {motive : α → Sort u_2} [inst : PartialOrder α] [inst_1 : PredOrder α]
(pred : (a : α) → ¬IsMin a → motive (Order.pred a)) (isPredPrelimit : (a : α) → Order.IsPredPrelimit a → motive a)
(hb : Order.IsPredPrelimit b), Order.isPredPrelimitRecOn b pred isPredPrelimit = isPredPrelimit b hb | null | true |
_private.Init.Data.String.Lemmas.Pattern.Split.Char.0.String.Slice.Pattern.Model.split.match_1.eq_2 | Init.Data.String.Lemmas.Pattern.Split.Char | ∀ {s : String.Slice} (motive : Option s.Pos → Sort u_1) (h_1 : (pos : s.Pos) → none = some pos → motive (some pos))
(h_2 : none = none → motive none),
(match hd : none with
| some pos => h_1 pos hd
| none => h_2 hd) =
h_2 ⋯ | null | true |
CategoryTheory.instLiftingFunctorOppositeSheafPresheafToSheafWCompObjWhiskeringRightComposeAndSheafify | Mathlib.CategoryTheory.Sites.PreservesSheafification | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
(J : CategoryTheory.GrothendieckTopology C) →
{A : Type u_1} →
{B : Type u_2} →
[inst_1 : CategoryTheory.Category.{v_1, u_1} A] →
[inst_2 : CategoryTheory.Category.{v_2, u_2} B] →
(F : CategoryTheory.Funct... | null | true |
Ordnode.pmap._f | Mathlib.Data.Ordmap.Ordnode | {α : Type u_1} →
{P : α → Prop} →
{β : Type u_2} →
((a : α) → P a → β) →
(x : Ordnode α) → Ordnode.below (motive := fun x => Ordnode.All P x → Ordnode β) x → Ordnode.All P x → Ordnode β | null | false |
Lean.Compiler.LCNF.isBoxedName | Lean.Compiler.LCNF.Types | Lean.Name → Bool | null | true |
PrimeSpectrum.exist_mem_one_of_mem_maximal_ideal | Mathlib.RingTheory.Spectrum.Prime.LTSeries | ∀ {R : Type u_1} [inst : CommRing R] [IsNoetherianRing R] [inst_2 : IsLocalRing R] {p₁ p₀ : PrimeSpectrum R},
p₀ < p₁ →
p₁ < IsLocalRing.closedPoint R →
∀ {x : R}, x ∈ IsLocalRing.maximalIdeal R → ∃ q, x ∈ q.asIdeal ∧ p₀ < q ∧ q.asIdeal < IsLocalRing.maximalIdeal R | null | true |
Std.Tactic.BVDecide.BVBinOp.and | Std.Tactic.BVDecide.Bitblast.BVExpr.Basic | Std.Tactic.BVDecide.BVBinOp | Bitwise and.
| true |
DirectedSystem.mk._flat_ctor | Mathlib.Order.DirectedInverseSystem | ∀ {ι : Type u_1} [inst : Preorder ι] {F : ι → Type u_4} {f : ⦃i j : ι⦄ → i ≤ j → F i → F j},
(∀ ⦃i : ι⦄ (x : F i), f ⋯ x = x) →
(∀ ⦃k j i : ι⦄ (hij : i ≤ j) (hjk : j ≤ k) (x : F i), f hjk (f hij x) = f ⋯ x) → DirectedSystem F f | null | false |
Inclusion.IntervalBool.mem_true | Mathlib.Tactic.Inclusion.Core.ToSet | ∀ {p : Prop}, p → p ∈ Inclusion.IntervalBool.true | null | true |
ZFSet.notMem_sInter_of_notMem | Mathlib.SetTheory.ZFC.Basic | ∀ {x y z : ZFSet.{u_1}}, y ∉ z → z ∈ x → y ∉ x.sInter | null | true |
Std.ExtTreeMap.mem_union_iff._simp_1 | Std.Data.ExtTreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t₁ t₂ : Std.ExtTreeMap α β cmp} [inst : Std.TransCmp cmp] {k : α},
(k ∈ t₁ ∪ t₂) = (k ∈ t₁ ∨ k ∈ t₂) | null | false |
Finset.empty_smul | Mathlib.Algebra.Group.Pointwise.Finset.Scalar | ∀ {α : Type u_1} {β : Type u_2} [inst : DecidableEq β] [inst_1 : SMul α β] (t : Finset β), ∅ • t = ∅ | null | true |
_private.Mathlib.AlgebraicGeometry.EllipticCurve.Projective.Basic.0.WeierstrassCurve.Projective.equation_some._simp_1_2 | Mathlib.AlgebraicGeometry.EllipticCurve.Projective.Basic | ∀ {R : Type r} [inst : CommRing R] {W : WeierstrassCurve.Affine R} (x y : R),
W.Equation x y = (y ^ 2 + W.a₁ * x * y + W.a₃ * y - (x ^ 3 + W.a₂ * x ^ 2 + W.a₄ * x + W.a₆) = 0) | null | false |
CategoryTheory.ShortComplex.abLeftHomologyData_f' | Mathlib.Algebra.Homology.ShortComplex.Ab | ∀ (S : CategoryTheory.ShortComplex Ab), S.abLeftHomologyData.f' = AddCommGrpCat.ofHom S.abToCycles | null | true |
_private.Mathlib.Algebra.ContinuedFractions.ConvergentsEquiv.0.GenContFract.squashSeq.match_1.eq_2 | Mathlib.Algebra.ContinuedFractions.ConvergentsEquiv | ∀ {K : Type u_1} (motive : Option (GenContFract.Pair K) × Option (GenContFract.Pair K) → Sort u_2)
(x : Option (GenContFract.Pair K) × Option (GenContFract.Pair K))
(h_1 : (gp_n gp_succ_n : GenContFract.Pair K) → motive (some gp_n, some gp_succ_n))
(h_2 : (x : Option (GenContFract.Pair K) × Option (GenContFract.P... | null | true |
AddActionHomClass | Mathlib.GroupTheory.GroupAction.Hom | (F : Type u_8) →
(M : outParam (Type u_9)) →
(X : outParam (Type u_10)) → (Y : outParam (Type u_11)) → [VAdd M X] → [VAdd M Y] → [FunLike F X Y] → Prop | `MulActionHomClass F M X Y` states that `F` is a type of
morphisms which are equivariant with respect to actions of `M`
This is an abbreviation of `MulActionSemiHomClass`. | true |
ContinuousLinearEquiv.dimH_univ | Mathlib.Topology.MetricSpace.HausdorffDimension | ∀ {𝕜 : Type u_4} {E : Type u_5} {F : Type u_6} [inst : NontriviallyNormedField 𝕜] [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] (e : E ≃L[𝕜] F),
dimH Set.univ = dimH Set.univ | null | true |
_private.Mathlib.Analysis.SpecialFunctions.Complex.Arg.0.Complex.arg_lt_arg_add_two_pi._proof_1_1 | Mathlib.Analysis.SpecialFunctions.Complex.Arg | (1 + 1).AtLeastTwo | null | false |
SSet.Subcomplex.Pairing.dim_p | Mathlib.AlgebraicTopology.SimplicialSet.AnodyneExtensions.Pairing | ∀ {X : SSet} {A : X.Subcomplex} (P : A.Pairing) [P.IsProper] (x : ↑P.II), (↑(P.p x)).dim = (↑x).dim + 1 | null | true |
Ideal.quotientToQuotientRangePowQuotSuccAux._proof_1 | Mathlib.NumberTheory.RamificationInertia.Basic | ∀ {R : Type u_1} [inst : CommRing R] (p : Ideal R), RingHomSurjective (RingHom.id (R ⧸ p)) | null | false |
Order.IsNormal.apply_of_isSuccLimit | Mathlib.Order.IsNormal | ∀ {α : Type u_1} {β : Type u_2} {a : α} {f : α → β} [inst : ConditionallyCompleteLinearOrderBot α]
[inst_1 : ConditionallyCompleteLinearOrder β], Order.IsNormal f → Order.IsSuccLimit a → f a = ⨆ b, f ↑b | null | true |
SetLike.GradeZero.coe_mul | Mathlib.Algebra.GradedMonoid | ∀ {ι : Type u_1} {R : Type u_2} {S : Type u_3} [inst : SetLike S R] [inst_1 : Monoid R] [inst_2 : AddMonoid ι]
{A : ι → S} [inst_3 : SetLike.GradedMonoid A] (a b : ↥(A 0)), ↑(a * b) = ↑a * ↑b | null | true |
Action.mkIso._proof_4 | Mathlib.CategoryTheory.Action.Basic | ∀ {V : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} V] {G : Type u_3} [inst_1 : Monoid G] {M N : Action V G}
(f : M.V ≅ N.V)
(comm :
∀ (g : G),
CategoryTheory.CategoryStruct.comp (M.ρ g).asHom f.hom = CategoryTheory.CategoryStruct.comp f.hom (N.ρ g).asHom),
CategoryTheory.CategoryStruct.comp { h... | null | false |
Homeomorph.finTwoArrow | Mathlib.Topology.Homeomorph.Lemmas | {X : Type u_1} → [inst : TopologicalSpace X] → (Fin 2 → X) ≃ₜ X × X | Homeomorphism between `X² = Fin 2 → X` and `X × X`. | true |
CategoryTheory.Limits.widePullbackShapeOp._proof_3 | Mathlib.CategoryTheory.Limits.Shapes.WidePullbacks | ∀ (J : Type u_1) {X Y Z : CategoryTheory.Limits.WidePullbackShape J} (f : X ⟶ Y) (g : Y ⟶ Z),
CategoryTheory.Limits.widePullbackShapeOpMap J X Z (CategoryTheory.CategoryStruct.comp f g) =
CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.widePullbackShapeOpMap J X Y f)
(CategoryTheory.Limits.widePul... | null | false |
_private.Init.Data.Range.Polymorphic.Lemmas.0.Std.Rcc.toArray_eq_empty_iff._simp_1_2 | Init.Data.Range.Polymorphic.Lemmas | ∀ {α : Type u} {r : Std.Rcc α} [inst : LE α] [inst_1 : DecidableLE α] [inst_2 : Std.PRange.UpwardEnumerable α]
[inst_3 : Std.PRange.LawfulUpwardEnumerable α] [Std.PRange.LawfulUpwardEnumerableLE α]
[inst_5 : Std.Rxc.IsAlwaysFinite α], (r.toList = []) = ¬r.lower ≤ r.upper | null | false |
Representation.IntertwiningMap.noConfusionType | Mathlib.RepresentationTheory.Intertwining | Sort u →
{A : Type u_1} →
{G : Type u_2} →
{V : Type u_3} →
{W : Type u_4} →
[inst : Semiring A] →
[inst_1 : Monoid G] →
[inst_2 : AddCommMonoid V] →
[inst_3 : AddCommMonoid W] →
[inst_4 : Module A V] →
[inst_5... | null | false |
_private.Mathlib.Algebra.BigOperators.Fin.0.Fin.prod_Iic_castAdd._simp_1_1 | Mathlib.Algebra.BigOperators.Fin | ∀ {n : ℕ} (m : ℕ) (i : Fin n), Finset.Iic (Fin.castAdd m i) = Finset.map (Fin.castAddEmb m) (Finset.Iic i) | null | false |
Lean.Macro.getCurrNamespace | Init.Prelude | Lean.MacroM Lean.Name | Gets the current namespace given the position in the file. | true |
Lean.Lsp.SignatureHelpContext.noConfusion | Lean.Data.Lsp.LanguageFeatures | {P : Sort u} → {t t' : Lean.Lsp.SignatureHelpContext} → t = t' → Lean.Lsp.SignatureHelpContext.noConfusionType P t t' | null | false |
Lean.Meta.Grind.AC.Struct.vars | Lean.Meta.Tactic.Grind.AC.Types | Lean.Meta.Grind.AC.Struct → Lean.PArray Lean.Expr | Mapping from variables to their denotations.
Remark each variable can be in only one ring.
| true |
Std.DTreeMap.Internal.Impl.insertManyIfNew!._proof_1 | Std.Data.DTreeMap.Internal.Operations | ∀ {α : Type u_1} {β : α → Type u_2} [inst : Ord α] (t : Std.DTreeMap.Internal.Impl α β)
(__s : t.IteratedSlowNewInsertionInto) (a : α) (b : β a) {P : Std.DTreeMap.Internal.Impl α β → Prop},
P t →
(∀ (t'' : Std.DTreeMap.Internal.Impl α β) (a : α) (b : β a),
P t'' → P (Std.DTreeMap.Internal.Impl.insertIfN... | null | false |
Mathlib.Tactic.Polynomial.tacticPolynomial_nf!_ | Mathlib.Tactic.Polynomial.Basic | Lean.ParserDescr | `polynomial` solves equalities of `Polynomial`s and similar types.
Given a goal which is an equality in `Polynomial R` with a commutative ring `R`, `polynomial`
turns both sides of the equation into a normal form by expanding out the brackets. It then closes
the goal if both sides contain the same terms and fails othe... | true |
ContinuousAddMonoidHom.zero_toFun | Mathlib.Topology.Algebra.ContinuousMonoidHom | ∀ (A : Type u_2) (B : Type u_3) [inst : AddMonoid A] [inst_1 : AddMonoid B] [inst_2 : TopologicalSpace A]
[inst_3 : TopologicalSpace B] (x : A), 0 x = 0 | null | true |
Lean.Elab.deprecatedArgExt | Lean.Elab.DeprecatedArg | Lean.SimplePersistentEnvExtension Lean.Elab.DeprecatedArgEntry Lean.Elab.DeprecatedArgState | null | true |
Mathlib.Tactic.ClickSuggestions.PreDiscrTrees.app._default | Mathlib.Tactic.ClickSuggestions.FindPremises | Lean.Meta.RefinedDiscrTree.PreDiscrTree Mathlib.Tactic.ClickSuggestions.ApplyLemma | null | false |
CochainComplex.HomComplex.Cochain.InductionUp.sequence_eqUpTo | Mathlib.Algebra.Homology.HomotopyCategory.HomComplexInduction | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Preadditive C]
{K L : CochainComplex C ℤ} {d : ℤ} {X : ℕ → Set (CochainComplex.HomComplex.Cochain K L d)}
(φ : (n : ℕ) → ↑(X n) → ↑(X (n + 1))) {p₀ : ℤ},
(∀ (n : ℕ) (x : ↑(X n)), (↑(φ n x)).EqUpTo (↑x) (p₀ + ↑n)) →
∀ (x₀ : ↑(X 0... | null | true |
TopCommRingCat.isTopologicalRing | Mathlib.Topology.Category.TopCommRingCat | ∀ (self : TopCommRingCat), IsTopologicalRing self.α | null | true |
SimpleGraph.«term_⊴_» | Mathlib.Combinatorics.SimpleGraph.Copy | Lean.TrailingParserDescr | A simple graph `G` is inducingly contained in a simple graph `H` if there exists an induced
subgraph of `H` isomorphic to `G`. This is denoted by `G ⊴ H`. | true |
_private.Mathlib.SetTheory.Cardinal.Cofinality.Club.0.exists_isStationary_preimage_singleton._simp_1_1 | Mathlib.SetTheory.Cardinal.Cofinality.Club | ∀ {α : Type u} {s : Set α}, (s = ∅) = ∀ (x : α), x ∉ s | null | false |
bilinearIteratedFDerivWithinTwo._proof_5 | Mathlib.Analysis.InnerProductSpace.Laplacian | ∀ (𝕜 : Type u_3) [inst : NontriviallyNormedField 𝕜] {E : Type u_1} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {F : Type u_2} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F],
ContinuousAdd (E →L[𝕜] F) | null | false |
Std.Do.Spec.forIn'_array._proof_2 | Std.Do.Triple.SpecLemmas | ∀ {α : Type u_1} {xs : Array α} (pref : List α) (cur : α) (suff : List α), xs.toList = pref ++ cur :: suff → cur ∈ xs | null | false |
DomMulAct.instDistribSMulForallOfSMul._proof_1 | Mathlib.GroupTheory.GroupAction.DomAct.Basic | ∀ {M : Type u_1} {α : Type u_2} {A : Type u_3} [inst : SMul M α] [inst_1 : AddZeroClass A] (x : Mᵈᵐᵃ) (x_1 x_2 : α → A),
x • (x_1 + x_2) = x • (x_1 + x_2) | null | false |
_private.Mathlib.RingTheory.Algebraic.StronglyTranscendental.0.isStronglyTranscendental_iff_of_field._simp_1_8 | Mathlib.RingTheory.Algebraic.StronglyTranscendental | ∀ {b a : Prop}, (a ∨ ¬b) = (b → a) | null | false |
CoalgCat.MonoidalCategoryAux.counit_tensorObj_tensorObj_right | Mathlib.Algebra.Category.CoalgCat.ComonEquivalence | ∀ {R : Type u} [inst : CommRing R] {M N P : Type u} [inst_1 : AddCommGroup M] [inst_2 : AddCommGroup N]
[inst_3 : AddCommGroup P] [inst_4 : Module R M] [inst_5 : Module R N] [inst_6 : Module R P] [inst_7 : Coalgebra R M]
[inst_8 : Coalgebra R N] [inst_9 : Coalgebra R P], CoalgebraStruct.counit = CoalgebraStruct.cou... | null | true |
Std.TreeMap.Raw.getKey_eq_getKeyD | Std.Data.TreeMap.Raw.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.TreeMap.Raw α β cmp} [Std.TransCmp cmp],
t.WF → ∀ {a fallback : α} {h' : a ∈ t}, t.getKey a h' = t.getKeyD a fallback | null | true |
FormalMultilinearSeries.id.match_1 | Mathlib.Analysis.Analytic.Composition | (motive : ℕ → Sort u_1) → (x : ℕ) → (Unit → motive 0) → (Unit → motive 1) → ((x : ℕ) → motive x) → motive x | null | false |
MeasureTheory.wrapped._@.Mathlib.MeasureTheory.Constructions.Polish.Basic.3011411360._hygCtx._hyg.2 | Mathlib.MeasureTheory.Constructions.Polish.Basic | Subtype (Eq @MeasureTheory.definition✝) | null | false |
LinearMap.toKerIsLocalized | Mathlib.Algebra.Module.LocalizedModule.Submodule | {R : Type u_1} →
{M : Type u_3} →
{N : Type u_4} →
[inst : CommSemiring R] →
[inst_1 : AddCommMonoid M] →
[inst_2 : AddCommMonoid N] →
[inst_3 : Module R M] →
[inst_4 : Module R N] →
(p : Submonoid R) →
(f : M →ₗ[R] N) →
... | The canonical map from the kernel of `g` to the kernel of `g` localized at a submonoid.
This is a localization map by `LinearMap.toKerLocalized_isLocalizedModule`.
| true |
isMinimal_iff_isClosed_vadd_invariant | Mathlib.Dynamics.Minimal | ∀ (M : Type u_1) {α : Type u_3} [inst : AddMonoid M] [inst_1 : TopologicalSpace α] [inst_2 : AddAction M α]
[ContinuousConstVAdd M α],
AddAction.IsMinimal M α ↔ ∀ (s : Set α), IsClosed s → (∀ (c : M), c +ᵥ s ⊆ s) → s = ∅ ∨ s = Set.univ | null | true |
UniformSpaceCat.Hom.mk._flat_ctor | Mathlib.Topology.Category.UniformSpace | {X : UniformSpaceCat} → {Y : UniformSpaceCat} → { f // UniformContinuous f } → X.Hom Y | null | false |
_private.Mathlib.Dynamics.TopologicalEntropy.CoverEntropy.0.Dynamics.coverMincard_finite_iff._simp_1_5 | Mathlib.Dynamics.TopologicalEntropy.CoverEntropy | ∀ (a : ℕ), (↑a = ⊤) = False | null | false |
_private.Init.Data.Nat.Fold.0.Nat.dfoldRev.match_1.eq_2 | Init.Data.Nat.Fold | ∀
(motive :
(n : ℕ) →
{α : (i : ℕ) → autoParam (i ≤ n) Nat.dfoldRev._auto_1 → Type u_1} →
((i : ℕ) → (h : i < n) → α (i + 1) ⋯ → α i ⋯) → α n ⋯ → Sort u_2)
(n : ℕ) (α : (i : ℕ) → autoParam (i ≤ n + 1) Nat.dfoldRev._auto_1 → Type u_1)
(f : (i : ℕ) → (h : i < n + 1) → α (i + 1) ⋯ → α i ⋯) (init : ... | null | true |
Std.DTreeMap.Internal.Impl.maxKeyD_alter_eq_self | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Std.DTreeMap.Internal.Impl α β} [Std.TransOrd α]
[inst : Std.LawfulEqOrd α] (h : t.WF) {k : α} {f : Option (β k) → Option (β k)} {fallback : α},
(Std.DTreeMap.Internal.Impl.alter k f t ⋯).impl.isEmpty = false →
((Std.DTreeMap.Internal.Impl.alter k f t ⋯).im... | null | true |
_private.Mathlib.Topology.GDelta.Basic.0.isMeagre_biUnion.match_1_1 | Mathlib.Topology.GDelta.Basic | ∀ {ι : Type u_1} {I : Set ι} (motive : ↑I → Prop) (h : ↑I), (∀ (i : ι) (hi : i ∈ I), motive ⟨i, hi⟩) → motive h | null | false |
AlgebraicGeometry.SmoothOfRelativeDimension.casesOn | Mathlib.AlgebraicGeometry.Morphisms.Smooth | {n : ℕ} →
{X Y : AlgebraicGeometry.Scheme} →
{f : X ⟶ Y} →
{motive : AlgebraicGeometry.SmoothOfRelativeDimension n f → Sort u_1} →
(t : AlgebraicGeometry.SmoothOfRelativeDimension n f) →
((exists_isStandardSmoothOfRelativeDimension :
∀ (x : ↥X),
∃ U,
... | null | false |
PUnit.mulSemiringAction | Mathlib.Algebra.Module.PUnit | {R : Type u_1} → [inst : Semiring R] → MulSemiringAction R PUnit.{u_3 + 1} | null | true |
Std.ExtDHashMap.get!_insertMany_list_of_mem | Std.Data.ExtDHashMap.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {β : α → Type v} {m : Std.ExtDHashMap α β} [inst : LawfulBEq α]
{l : List ((a : α) × β a)} {k k' : α} (k_beq : (k == k') = true) {v : β k} [inst_1 : Inhabited (β k')],
List.Pairwise (fun a b => (a.fst == b.fst) = false) l → ⟨k, v⟩ ∈ l → (m.insertMany l).get! k' = cast ⋯... | null | true |
Submonoid.LocalizationMap.lift_mk'_spec | Mathlib.GroupTheory.MonoidLocalization.Maps | ∀ {M : Type u_1} [inst : CommMonoid M] {S : Submonoid M} {N : Type u_2} [inst_1 : CommMonoid N] {P : Type u_3}
[inst_2 : CommMonoid P] (f : S.LocalizationMap N) {g : M →* P} (hg : ∀ (y : ↥S), IsUnit (g ↑y)) (x : M) (v : P)
(y : ↥S), (f.lift hg) (f.mk' x y) = v ↔ g x = g ↑y * v | null | true |
Matroid.sigma._proof_3 | Mathlib.Combinatorics.Matroid.Sum | ∀ {ι : Type u_2} {α : ι → Type u_1} (M : (i : ι) → Matroid (α i)) (I : Set ((i : ι) × α i)),
(∀ (i : ι), (M i).Indep (Sigma.mk i ⁻¹' I)) ↔ ∃ B, (∀ (i : ι), (M i).IsBase (Sigma.mk i ⁻¹' B)) ∧ I ⊆ B | null | false |
_private.Mathlib.Tactic.DefEqAbuse.0.Lean.MessageData.visitWithAndAscendM._auto_1 | Mathlib.Tactic.DefEqAbuse | Lean.Syntax | null | false |
Int8.toInt16_neg_of_ne | Init.Data.SInt.Lemmas | ∀ {x : Int8}, x ≠ -128 → (-x).toInt16 = -x.toInt16 | null | true |
ciSup_bot | Mathlib.Order.ConditionallyCompleteLattice.Indexed | ∀ {α : Type u_1} {ι : Sort u_4} [inst : ConditionallyCompleteLinearOrderBot α], ⨆ x, ⊥ = ⊥ | null | true |
Equiv.toHomeomorph_apply | Mathlib.Topology.Homeomorph.Defs | ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] (e : X ≃ Y)
(he : ∀ (s : Set Y), IsOpen (⇑e ⁻¹' s) ↔ IsOpen s) (x : X), (e.toHomeomorph he) x = e x | null | true |
CategoryTheory.StrictPseudofunctorCore | Mathlib.CategoryTheory.Bicategory.Functor.StrictPseudofunctor | (B : Type u₁) →
[CategoryTheory.Bicategory B] →
(C : Type u₂) → [CategoryTheory.Bicategory C] → Type (max (max (max (max (max u₁ u₂) v₁) v₂) w₁) w₂) | A helper structure that bundles the necessary data to
construct a `StrictPseudofunctor` without specifying the redundant
fields `mapId` and `mapComp`. | true |
Polynomial.cyclotomic_two | Mathlib.RingTheory.Polynomial.Cyclotomic.Basic | ∀ (R : Type u_1) [inst : Ring R], Polynomial.cyclotomic 2 R = Polynomial.X + 1 | null | true |
Lean.Elab.Tactic.RCases.RCasesPatt.explicit.sizeOf_spec | Lean.Elab.Tactic.RCases | ∀ (ref : Lean.Syntax) (a : Lean.Elab.Tactic.RCases.RCasesPatt),
sizeOf (Lean.Elab.Tactic.RCases.RCasesPatt.explicit ref a) = 1 + sizeOf ref + sizeOf a | null | true |
SSet.prodStdSimplex.pairingCore.Type₁.recOn | Mathlib.AlgebraicTopology.SimplicialSet.AnodyneExtensions.UnionProd | {m : ℕ} →
{k : Fin (m + 1)} →
{n : ℕ} →
{motive : SSet.prodStdSimplex.pairingCore.Type₁ k n → Sort u_1} →
(t : SSet.prodStdSimplex.pairingCore.Type₁ k n) →
((x : ((SSet.horn (m + 1) k.castSucc).unionProd (SSet.boundary n)).N) →
(d : ℕ) →
(hd : x.dim = d + 1) →... | null | false |
Lean.Compiler.LCNF.PullFunDecls.addToPull._unsafe_rec | Lean.Compiler.LCNF.PullFunDecls | Bool → Lean.Compiler.LCNF.FunDecl Lean.Compiler.LCNF.Purity.pure → Lean.Compiler.LCNF.PullFunDecls.PullM Unit | null | false |
CategoryTheory.Equivalence.instMonoidalInverseSymmOfFunctor._proof_8 | Mathlib.CategoryTheory.Monoidal.Functor | ∀ {C : Type u_4} [inst : CategoryTheory.Category.{u_3, u_4} C] [inst_1 : CategoryTheory.MonoidalCategory C]
{D : Type u_2} [inst_2 : CategoryTheory.Category.{u_1, u_2} D] [inst_3 : CategoryTheory.MonoidalCategory D]
(e : C ≌ D) [inst_4 : e.functor.Monoidal],
autoParam
(∀ (X Y : C),
CategoryTheory.Catego... | null | false |
CompactExhaustion.mk.injEq | Mathlib.Topology.Compactness.SigmaCompact | ∀ {X : Type u_4} [inst : TopologicalSpace X] (toFun : ℕ → Set X) (isCompact' : ∀ (n : ℕ), IsCompact (toFun n))
(subset_interior_succ' : ∀ (n : ℕ), toFun n ⊆ interior (toFun (n + 1))) (iUnion_eq' : ⋃ n, toFun n = Set.univ)
(toFun_1 : ℕ → Set X) (isCompact'_1 : ∀ (n : ℕ), IsCompact (toFun_1 n))
(subset_interior_suc... | null | true |
ENNReal.orderIsoUnitIntervalBirational_apply_coe | Mathlib.Basic.ENNReal.Inv | ∀ (x : ENNReal), ↑(ENNReal.orderIsoUnitIntervalBirational x) = (x⁻¹ + 1)⁻¹.toReal | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.