name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
derangements.Equiv.RemoveNone.fiber | Mathlib.Combinatorics.Derangements.Basic | {α : Type u_1} → [DecidableEq α] → Option α → Set (Equiv.Perm α) | true |
dist_neg | Mathlib.Analysis.Normed.Group.Basic | ∀ {E : Type u_5} [inst : SeminormedAddCommGroup E] (x y : E), dist (-x) y = dist x (-y) | true |
CategoryTheory.SimplicialObject | Mathlib.AlgebraicTopology.SimplicialObject.Basic | (C : Type u) → [CategoryTheory.Category.{v, u} C] → Type (max v u) | true |
LinearIsometryEquiv.toContinuousLinearEquiv | Mathlib.Analysis.Normed.Operator.LinearIsometry | {R : Type u_1} →
{R₂ : Type u_2} →
{E : Type u_5} →
{E₂ : Type u_6} →
[inst : Semiring R] →
[inst_1 : Semiring R₂] →
{σ₁₂ : R →+* R₂} →
{σ₂₁ : R₂ →+* R} →
[inst_2 : RingHomInvPair σ₁₂ σ₂₁] →
[inst_3 : RingHomInvPair σ₂₁ σ₁₂] →
... | true |
sum_chartAt_inr_apply | Mathlib.Geometry.Manifold.ChartedSpace | ∀ {H : Type u} {M : Type u_2} {M' : Type u_3} [inst : TopologicalSpace H] [inst_1 : TopologicalSpace M]
[inst_2 : TopologicalSpace M'] [cm : ChartedSpace H M] [cm' : ChartedSpace H M'] {x y : M'},
↑(chartAt H (Sum.inr x)) (Sum.inr y) = ↑(chartAt H x) y | true |
IsRadical.dvd_radical | Mathlib.RingTheory.Radical.Basic | ∀ {M : Type u_1} [inst : CommMonoidWithZero M] [inst_1 : NormalizationMonoid M] [inst_2 : UniqueFactorizationMonoid M]
{a : M}, IsRadical a → a ≠ 0 → a ∣ UniqueFactorizationMonoid.radical a | true |
_private.Batteries.Data.Fin.Lemmas.0.Fin.findSomeRev?_eq_some_iff.match_1_1 | Batteries.Data.Fin.Lemmas | ∀ {n : ℕ} {α : Type u_1} {a : α} {f : Fin n → Option α}
(motive : (∃ i, f i.rev = some a ∧ ∀ j < i, f j.rev = none) → Prop)
(x : ∃ i, f i.rev = some a ∧ ∀ j < i, f j.rev = none),
(∀ (i : Fin n) (h : f i.rev = some a ∧ ∀ j < i, f j.rev = none), motive ⋯) → motive x | false |
Pi.nonAssocSemiring._proof_1 | Mathlib.Algebra.Ring.Pi | ∀ {I : Type u_1} {f : I → Type u_2} [inst : (i : I) → NonAssocSemiring (f i)] (a : (i : I) → f i), 1 * a = a | false |
CategoryTheory.ObjectProperty.IsClosedUnderQuotients.prop_of_epi | Mathlib.CategoryTheory.ObjectProperty.EpiMono | ∀ {C : Type u} {inst : CategoryTheory.Category.{v, u} C} {P : CategoryTheory.ObjectProperty C}
[self : P.IsClosedUnderQuotients] {X Y : C} (f : X ⟶ Y) [CategoryTheory.Epi f], P X → P Y | true |
CategoryTheory.Regular.regularEpiIsStableUnderBaseChange | Mathlib.CategoryTheory.RegularCategory.Basic | ∀ {C : Type u} {inst : CategoryTheory.Category.{v, u} C} [self : CategoryTheory.Regular C],
(CategoryTheory.MorphismProperty.regularEpi C).IsStableUnderBaseChange | true |
Lean.Elab.Command.instMonadMacroAdapterCommandElabM | Lean.Elab.Command | Lean.Elab.MonadMacroAdapter Lean.Elab.Command.CommandElabM | true |
_private.Mathlib.Algebra.Order.Group.Indicator.0.Function.mulSupport_iSup._simp_1_3 | Mathlib.Algebra.Order.Group.Indicator | ∀ {α : Sort u_1} {p : α → Prop}, (¬∃ x, p x) = ∀ (x : α), ¬p x | false |
Std.Sat.AIG.RelabelNat.State.Inv2.below.gate | Std.Sat.AIG.RelabelNat | ∀ {α : Type} [inst : DecidableEq α] [inst_1 : Hashable α] {decls : Array (Std.Sat.AIG.Decl α)}
{motive : (a : ℕ) → (a_1 : Std.HashMap α ℕ) → Std.Sat.AIG.RelabelNat.State.Inv2 decls a a_1 → Prop} {idx : ℕ}
{map : Std.HashMap α ℕ} {l r : Std.Sat.AIG.Fanin} (hinv : Std.Sat.AIG.RelabelNat.State.Inv2 decls idx map)
(h... | true |
Fin.insertNth_mul | Mathlib.Algebra.Group.Fin.Tuple | ∀ {n : ℕ} {α : Fin (n + 1) → Type u_1} [inst : (j : Fin (n + 1)) → Mul (α j)] (i : Fin (n + 1)) (x y : α i)
(p q : (j : Fin n) → α (i.succAbove j)), i.insertNth (x * y) (p * q) = i.insertNth x p * i.insertNth y q | true |
SemiNormedGrp.explicitCokernelIso_hom_desc | Mathlib.Analysis.Normed.Group.SemiNormedGrp.Kernels | ∀ {X Y Z : SemiNormedGrp} {f : X ⟶ Y} {g : Y ⟶ Z} (w : CategoryTheory.CategoryStruct.comp f g = 0),
CategoryTheory.CategoryStruct.comp (SemiNormedGrp.explicitCokernelIso f).hom
(CategoryTheory.Limits.cokernel.desc f g w) =
SemiNormedGrp.explicitCokernelDesc w | true |
Std.DHashMap.values | Std.Data.DHashMap.Basic | {α : Type u} → {x : BEq α} → {x_1 : Hashable α} → {β : Type v} → (Std.DHashMap α fun x => β) → List β | true |
Set.Nonempty.image2 | Mathlib.Data.Set.NAry | ∀ {α : Type u_1} {β : Type u_3} {γ : Type u_5} {f : α → β → γ} {s : Set α} {t : Set β},
s.Nonempty → t.Nonempty → (Set.image2 f s t).Nonempty | true |
StdSimplex.weights | Mathlib.LinearAlgebra.ConvexSpace | {R : Type u} → [inst : LE R] → [inst_1 : AddCommMonoid R] → [inst_2 : One R] → {M : Type v} → StdSimplex R M → M →₀ R | true |
_private.Init.Data.List.Basic.0.List.dropLast.match_1.splitter | Init.Data.List.Basic | {α : Type u_1} →
(motive : List α → Sort u_2) →
(x : List α) →
(Unit → motive []) →
((head : α) → motive [head]) → ((a : α) → (as : List α) → (as = [] → False) → motive (a :: as)) → motive x | true |
_private.Mathlib.Analysis.SpecialFunctions.Pow.Deriv.0.Real.iter_deriv_rpow_const._proof_1_4 | Mathlib.Analysis.SpecialFunctions.Pow.Deriv | ∀ (r : ℝ) (k : ℕ) (y : ℝ),
y ^ (r - ↑k - 1) = y ^ (r - (↑k + 1)) ∨ Polynomial.eval r (descPochhammer ℝ k) = 0 ∨ r - ↑k = 0 | false |
CategoryTheory.Pseudofunctor.Grothendieck.Hom.fiber | Mathlib.CategoryTheory.Bicategory.Grothendieck | {𝒮 : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} 𝒮] →
{F : CategoryTheory.Pseudofunctor (CategoryTheory.LocallyDiscrete 𝒮) CategoryTheory.Cat} →
{X Y : F.Grothendieck} → (self : X.Hom Y) → (F.map self.base.toLoc).toFunctor.obj X.fiber ⟶ Y.fiber | true |
Set.ordConnected_pi' | Mathlib.Order.Interval.Set.OrdConnected | ∀ {ι : Type u_3} {α : ι → Type u_4} [inst : (i : ι) → Preorder (α i)] {s : Set ι} {t : (i : ι) → Set (α i)}
[h : ∀ (i : ι), (t i).OrdConnected], (s.pi t).OrdConnected | true |
CategoryTheory.MorphismProperty.LeftFraction.noConfusionType | Mathlib.CategoryTheory.Localization.CalculusOfFractions | Sort u →
{C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
{W : CategoryTheory.MorphismProperty C} →
{X Y : C} →
W.LeftFraction X Y →
{C' : Type u_1} →
[inst' : CategoryTheory.Category.{v_1, u_1} C'] →
{W' : CategoryTheory.MorphismPr... | false |
CategoryTheory.ChosenPullbacksAlong.binaryFanIsBinaryProduct._proof_4 | Mathlib.CategoryTheory.LocallyCartesianClosed.Over | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {X : C} (Y Z : CategoryTheory.Over X)
[inst_1 : CategoryTheory.ChosenPullbacksAlong Z.hom] {T : CategoryTheory.Over X} (f : T ⟶ Y) (g : T ⟶ Z),
CategoryTheory.CategoryStruct.comp
((fun {T} u v => CategoryTheory.Over.homMk (CategoryTheory.ChosenPul... | false |
AddSubmonoid.le_toAddSubmonoid_saturation | Mathlib.Algebra.Group.Submonoid.Saturation | ∀ {M : Type u_1} [inst : AddZeroClass M] {a : AddSubmonoid M}, a ≤ a.saturation.toAddSubmonoid | true |
LeftOrdContinuous.rightOrdContinuous_dual | Mathlib.Order.OrdContinuous | ∀ {α : Type u} {β : Type v} [inst : Preorder α] [inst_1 : Preorder β] {f : α → β},
LeftOrdContinuous f → RightOrdContinuous (⇑OrderDual.toDual ∘ f ∘ ⇑OrderDual.ofDual) | true |
Lean.Grind.CommRing.Poly.denote_combineC | Init.Grind.Ring.CommSolver | ∀ {α : Type u_1} {c : ℕ} [inst : Lean.Grind.Ring α] [Lean.Grind.IsCharP α c] (ctx : Lean.Grind.CommRing.Context α)
(p₁ p₂ : Lean.Grind.CommRing.Poly),
Lean.Grind.CommRing.Poly.denote ctx (p₁.combineC p₂ c) =
Lean.Grind.CommRing.Poly.denote ctx p₁ + Lean.Grind.CommRing.Poly.denote ctx p₂ | true |
HahnEmbedding.Seed.rec | Mathlib.Algebra.Order.Module.HahnEmbedding | {K : Type u_1} →
[inst : DivisionRing K] →
[inst_1 : LinearOrder K] →
[inst_2 : IsOrderedRing K] →
[inst_3 : Archimedean K] →
{M : Type u_2} →
[inst_4 : AddCommGroup M] →
[inst_5 : LinearOrder M] →
[inst_6 : IsOrderedAddMonoid M] →
... | false |
_private.Mathlib.Tactic.Linter.FindDeprecations.0.Mathlib.Tactic.rewriteOneFile.match_1 | Mathlib.Tactic.Linter.FindDeprecations | (motive : Lean.Name × Lean.Syntax.Range → Sort u_1) →
(x : Lean.Name × Lean.Syntax.Range) →
((decl : Lean.Name) → (s e : String.Pos.Raw) → motive (decl, { start := s, stop := e })) → motive x | false |
Lean.Parser.Command.versoCommentBody.formatter | Lean.Parser.Term | Lean.PrettyPrinter.Formatter | true |
_private.Mathlib.Algebra.MvPolynomial.Variables.0.MvPolynomial.vars_rename._simp_1_1 | Mathlib.Algebra.MvPolynomial.Variables | ∀ {α : Type u_1} [inst : DecidableEq α] {a : α} {s : Multiset α}, (a ∈ s.toFinset) = (a ∈ s) | false |
Std.TreeMap.Raw.getElem?_diff_of_not_mem_left | Std.Data.TreeMap.Raw.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t₁ t₂ : Std.TreeMap.Raw α β cmp} [Std.TransCmp cmp],
t₁.WF → t₂.WF → ∀ {k : α}, k ∉ t₁ → (t₁ \ t₂)[k]? = none | true |
Std.HashMap.insertMany_ind | Std.Data.HashMap.Lemmas | ∀ {α : Type u} {β : Type v} {x : BEq α} {x_1 : Hashable α} {ρ : Type w} [inst : ForIn Id ρ (α × β)]
{motive : Std.HashMap α β → Prop} (m : Std.HashMap α β) {l : ρ},
motive m → (∀ (m : Std.HashMap α β) (a : α) (b : β), motive m → motive (m.insert a b)) → motive (m.insertMany l) | true |
Std.ExtTreeMap.minEntry.match_1 | Std.Data.ExtTreeMap.Basic | ∀ {α : Type u_1} {β : Type u_2} {cmp : α → α → Ordering}
(motive : (t : Std.ExtTreeMap α β cmp) → t ≠ ∅ → t.inner = ∅ → Prop) (t : Std.ExtTreeMap α β cmp) (h : t ≠ ∅)
(x : t.inner = ∅), motive t h x | false |
Finsupp.domCongr_apply | Mathlib.Data.Finsupp.Basic | ∀ {α : Type u_1} {β : Type u_2} {M : Type u_5} [inst : AddCommMonoid M] (e : α ≃ β) (l : α →₀ M),
(Finsupp.domCongr e) l = Finsupp.equivMapDomain e l | true |
_private.Mathlib.Order.Filter.Map.0.Filter.comap_neBot_iff._simp_1_2 | Mathlib.Order.Filter.Map | ∀ {α : Sort u_1} {p : α → Prop} {q : (∃ x, p x) → Prop}, (∀ (h : ∃ x, p x), q h) = ∀ (x : α) (h : p x), q ⋯ | false |
RootPairing.EmbeddedG2.shortAddLong.eq_1 | Mathlib.LinearAlgebra.RootSystem.Finite.G2 | ∀ {ι : Type u_1} {R : Type u_2} {M : Type u_3} {N : Type u_4} [inst : CommRing R] [inst_1 : AddCommGroup M]
[inst_2 : Module R M] [inst_3 : AddCommGroup N] [inst_4 : Module R N] (P : RootPairing ι R M N)
[inst_5 : P.EmbeddedG2],
RootPairing.EmbeddedG2.shortAddLong P =
(P.reflectionPerm (RootPairing.EmbeddedG2... | true |
instMinNat | Init.Prelude | Min ℕ | true |
UniformSpaceCat.completionFunctor._proof_2 | Mathlib.Topology.Category.UniformSpace | ∀ {X Y Z : UniformSpaceCat} (f : X ⟶ Y) (g : Y ⟶ Z),
⇑(CategoryTheory.ConcreteCategory.hom
(CategoryTheory.ConcreteCategory.ofHom
⟨UniformSpace.Completion.map ⇑(CategoryTheory.CategoryStruct.comp f g).hom', ⋯⟩).hom) =
⇑(CategoryTheory.ConcreteCategory.hom
(CategoryTheory.CategoryStruct... | false |
_private.Init.Data.Format.Basic.0.Std.Format.WorkGroup.noConfusionType | Init.Data.Format.Basic | Sort u → Std.Format.WorkGroup✝ → Std.Format.WorkGroup✝ → Sort u | false |
integral_bilinear_hasLineDerivAt_right_eq_neg_left_of_integrable | Mathlib.Analysis.Calculus.LineDeriv.IntegrationByParts | ∀ {E : Type u_1} {F : Type u_2} {G : Type u_3} {W : Type u_4} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E]
[inst_2 : NormedAddCommGroup F] [inst_3 : NormedSpace ℝ F] [inst_4 : NormedAddCommGroup G] [inst_5 : NormedSpace ℝ G]
[inst_6 : NormedAddCommGroup W] [inst_7 : NormedSpace ℝ W] [inst_8 : Measurable... | true |
BitVec.instHashable | Init.Data.BitVec.Basic | {n : ℕ} → Hashable (BitVec n) | true |
OrderRingHom.comp_id | Mathlib.Algebra.Order.Hom.Ring | ∀ {α : Type u_2} {β : Type u_3} [inst : NonAssocSemiring α] [inst_1 : Preorder α] [inst_2 : NonAssocSemiring β]
[inst_3 : Preorder β] (f : α →+*o β), f.comp (OrderRingHom.id α) = f | true |
isLinearSet_iff_exists_fin_addMonoidHom | Mathlib.ModelTheory.Arithmetic.Presburger.Semilinear.Basic | ∀ {M : Type u_1} [inst : AddCommMonoid M] {s : Set M}, IsLinearSet s ↔ ∃ a n f, s = a +ᵥ Set.range ⇑f | true |
Std.DTreeMap.Internal.Impl.Const.minEntry._unary | Std.Data.DTreeMap.Internal.Queries | {α : Type u} → {β : Type v} → (t : Std.DTreeMap.Internal.Impl α fun x => β) ×' t.isEmpty = false → α × β | false |
CochainComplex.HomComplex | Mathlib.Algebra.Homology.HomotopyCategory.HomComplex | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
[inst_1 : CategoryTheory.Preadditive C] → CochainComplex C ℤ → CochainComplex C ℤ → CochainComplex AddCommGrpCat ℤ | true |
Char.reduceEq | Lean.Meta.Tactic.Simp.BuiltinSimprocs.Char | Lean.Meta.Simp.Simproc | true |
_private.Init.Data.Range.Polymorphic.NatLemmas.0.Nat.getElem!_toArray_rio_eq_zero_iff._simp_1_1 | Init.Data.Range.Polymorphic.NatLemmas | ∀ {m n i : ℕ}, ((m...n).toArray[i]! = 0) = (n ≤ i + m ∨ m = 0 ∧ i = 0) | false |
List.perm_reverse._simp_1 | Mathlib.Data.List.Basic | ∀ {α : Type u} {l₁ l₂ : List α}, l₁.Perm l₂.reverse = l₁.Perm l₂ | false |
Vector.map_eq_flatMap | Init.Data.Vector.Lemmas | ∀ {α : Type u_1} {β : Type u_2} {n : ℕ} {f : α → β} {xs : Vector α n},
Vector.map f xs = Vector.cast ⋯ (xs.flatMap fun x => #v[f x]) | true |
Ordnode.map.valid | Mathlib.Data.Ordmap.Ordset | ∀ {α : Type u_1} [inst : Preorder α] {β : Type u_2} [inst_1 : Preorder β] {f : α → β},
StrictMono f → ∀ {t : Ordnode α}, t.Valid → (Ordnode.map f t).Valid | true |
CategoryTheory.Factorisation.instCategory | Mathlib.CategoryTheory.Category.Factorisation | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{X Y : C} → {f : X ⟶ Y} → CategoryTheory.Category.{max u v, max u v} (CategoryTheory.Factorisation f) | true |
OneHom.instCommMonoid | Mathlib.Algebra.Group.Hom.Instances | {M : Type uM} → {N : Type uN} → [inst : One M] → [inst_1 : CommMonoid N] → CommMonoid (OneHom M N) | true |
Std.DHashMap.Raw.Const.all_eq_false_iff_exists_contains_get | Std.Data.DHashMap.RawLemmas | ∀ {α : Type u} [inst : BEq α] [inst_1 : Hashable α] {β : Type v} {m : Std.DHashMap.Raw α fun x => β} [LawfulBEq α]
{p : α → β → Bool},
m.WF → (m.all p = false ↔ ∃ a, ∃ (h : m.contains a = true), p a (Std.DHashMap.Raw.Const.get m a h) = false) | true |
iff_self_and._simp_1 | Init.SimpLemmas | ∀ {p q : Prop}, (p ↔ p ∧ q) = (p → q) | false |
add_eq_zero_iff_eq_neg | Mathlib.Algebra.Group.Basic | ∀ {G : Type u_3} [inst : AddGroup G] {a b : G}, a + b = 0 ↔ a = -b | true |
MvPolynomial.map_eval₂ | Mathlib.Algebra.MvPolynomial.Eval | ∀ {R : Type u} {S₁ : Type v} {S₂ : Type w} {S₃ : Type x} [inst : CommSemiring R] [inst_1 : CommSemiring S₁]
(f : R →+* S₁) (g : S₂ → MvPolynomial S₃ R) (p : MvPolynomial S₂ R),
(MvPolynomial.map f) (MvPolynomial.eval₂ MvPolynomial.C g p) =
MvPolynomial.eval₂ MvPolynomial.C (⇑(MvPolynomial.map f) ∘ g) ((MvPolyno... | true |
MeasureTheory.integral_comp | Mathlib.MeasureTheory.Measure.Haar.NormedSpace | ∀ {E' : Type u_2} {F' : Type u_3} {A : Type u_4} [inst : NormedAddCommGroup E'] [inst_1 : InnerProductSpace ℝ E']
[inst_2 : FiniteDimensional ℝ E'] [inst_3 : MeasurableSpace E'] [inst_4 : BorelSpace E']
[inst_5 : NormedAddCommGroup F'] [inst_6 : InnerProductSpace ℝ F'] [inst_7 : FiniteDimensional ℝ F']
[inst_8 : ... | true |
Std.ExtHashMap.get_union_of_not_mem_left | Std.Data.ExtHashMap.Lemmas | ∀ {α : Type u} {β : Type v} {x : BEq α} {x_1 : Hashable α} {m₁ m₂ : Std.ExtHashMap α β} [inst : EquivBEq α]
[inst_1 : LawfulHashable α] {k : α} (not_mem : k ∉ m₁) {h' : k ∈ m₁ ∪ m₂}, (m₁ ∪ m₂).get k h' = m₂.get k ⋯ | true |
_private.Mathlib.Combinatorics.SimpleGraph.Connectivity.Subgraph.0.SimpleGraph.Walk.IsPath.neighborSet_toSubgraph_internal._proof_1_10 | Mathlib.Combinatorics.SimpleGraph.Connectivity.Subgraph | ∀ {V : Type u_1} {G : SimpleGraph V} {v u : V} {p : G.Walk u v}, ∀ i' < p.length, i' ≤ p.length | false |
Fin.val_intCast | Mathlib.Data.ZMod.Defs | ∀ {n : ℕ} [inst : NeZero n] (x : ℤ), ↑↑x = (x % ↑n).toNat | true |
_private.Init.Data.String.Lemmas.IsEmpty.0.String.isEmpty_slice._simp_1_2 | Init.Data.String.Lemmas.IsEmpty | ∀ {s : String} {p₀ p₁ : s.Pos} {h : p₀ ≤ p₁} (pos₁ pos₂ : (s.slice p₀ p₁ h).Pos),
(pos₁ = pos₂) = (String.Pos.ofSlice pos₁ = String.Pos.ofSlice pos₂) | false |
NumberField.exists_ne_zero_mem_ideal_of_norm_le_mul_sqrt_discr | Mathlib.NumberTheory.NumberField.Discriminant.Basic | ∀ (K : Type u_1) [inst : Field K] [inst_1 : NumberField K]
(I : (FractionalIdeal (nonZeroDivisors (NumberField.RingOfIntegers K)) K)ˣ),
∃ a ∈ ↑I,
a ≠ 0 ∧
↑|(Algebra.norm ℚ) a| ≤
↑(FractionalIdeal.absNorm ↑I) * (4 / Real.pi) ^ NumberField.InfinitePlace.nrComplexPlaces K *
↑(Module.fin... | true |
CategoryTheory.Bicategory.«_aux_Mathlib_CategoryTheory_Bicategory_Basic___macroRules_CategoryTheory_Bicategory_term_◁ᵢ__1» | Mathlib.CategoryTheory.Bicategory.Basic | Lean.Macro | false |
AddCommMonCat.equivalence._proof_2 | Mathlib.Algebra.Category.MonCat.Basic | ∀ {X Y Z : AddCommMonCat} (f : X ⟶ Y) (g : Y ⟶ Z),
CommMonCat.ofHom (AddMonoidHom.toMultiplicative (AddCommMonCat.Hom.hom (CategoryTheory.CategoryStruct.comp f g))) =
CategoryTheory.CategoryStruct.comp (CommMonCat.ofHom (AddMonoidHom.toMultiplicative (AddCommMonCat.Hom.hom f)))
(CommMonCat.ofHom (AddMonoidH... | false |
AlgebraicGeometry.Scheme.Modules.restrictAdjunction._proof_1 | Mathlib.AlgebraicGeometry.Modules.Sheaf | ∀ {X Y : AlgebraicGeometry.Scheme} (f : X ⟶ Y) [AlgebraicGeometry.IsOpenImmersion f], IsOpenMap ⇑f | false |
Lean.Meta.Grind.Order.Cnstr.v | Lean.Meta.Tactic.Grind.Order.Types | {α : Type} → Lean.Meta.Grind.Order.Cnstr α → α | true |
pi_norm_le_iff_of_nonempty' | Mathlib.Analysis.Normed.Group.Constructions | ∀ {ι : Type u_1} {G : ι → Type u_4} [inst : Fintype ι] [inst_1 : (i : ι) → SeminormedGroup (G i)] (f : (i : ι) → G i)
{r : ℝ} [Nonempty ι], ‖f‖ ≤ r ↔ ∀ (b : ι), ‖f b‖ ≤ r | true |
_private.Mathlib.Analysis.SpecialFunctions.ArithmeticGeometricMean.0.NNReal.bddAbove_range_agmSequences_fst._simp_1_2 | Mathlib.Analysis.SpecialFunctions.ArithmeticGeometricMean | ∀ {α : Sort u_1} {p : α → Prop} {q : (∃ x, p x) → Prop}, (∀ (h : ∃ x, p x), q h) = ∀ (x : α) (h : p x), q ⋯ | false |
_private.Mathlib.Algebra.Polynomial.Eval.Defs.0.Polynomial.eval_natCast._simp_1_1 | Mathlib.Algebra.Polynomial.Eval.Defs | ∀ {R : Type u} [inst : Semiring R] (n : ℕ), ↑n = Polynomial.C ↑n | false |
StarAlgEquiv.coe_pow | Mathlib.Algebra.Star.StarAlgHom | ∀ {S : Type u_1} {R : Type u_2} [inst : Mul R] [inst_1 : Add R] [inst_2 : Star R] [inst_3 : SMul S R] (f : R ≃⋆ₐ[S] R)
(n : ℕ), ⇑(f ^ n) = (⇑f)^[n] | true |
RingEquiv.restrict._proof_5 | Mathlib.Algebra.Ring.Subring.Basic | ∀ {R : Type u_3} {S : Type u_1} [inst : NonAssocSemiring R] [inst_1 : NonAssocSemiring S] {σR : Type u_4}
{σS : Type u_2} [inst_2 : SetLike σR R] [inst_3 : SetLike σS S] [inst_4 : SubsemiringClass σR R]
[inst_5 : SubsemiringClass σS S] (e : R ≃+* S) (s' : σR) (s : σS) (h : ∀ (x : R), x ∈ s' ↔ e x ∈ s) (x : ↥s),
(... | false |
CategoryTheory.ShortComplex.RightHomologyMapData.ofIsLimitKernelFork._proof_1 | Mathlib.Algebra.Homology.ShortComplex.RightHomology | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{S₁ S₂ : CategoryTheory.ShortComplex C} (φ : S₁ ⟶ S₂) (c₁ : CategoryTheory.Limits.KernelFork S₁.g)
(c₂ : CategoryTheory.Limits.KernelFork S₂.g) (f : c₁.pt ⟶ c₂.pt),
CategoryTheory.CategoryStruct.comp... | false |
ContMDiff.along_snd | Mathlib.Geometry.Manifold.ContMDiff.Constructions | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {H : Type u_3} [inst_3 : TopologicalSpace H] {I : ModelWithCorners 𝕜 E H} {M : Type u_4}
[inst_4 : TopologicalSpace M] [inst_5 : ChartedSpace H M] {E' : Type u_5} [inst_6 : NormedAddComm... | true |
RingHomInvPair.toRingEquiv_apply | Mathlib.Algebra.Ring.CompTypeclasses | ∀ {R₁ : Type u_1} {R₂ : Type u_2} [inst : Semiring R₁] [inst_1 : Semiring R₂] (σ : R₁ →+* R₂) (σ' : R₂ →+* R₁)
[inst_2 : RingHomInvPair σ σ'] (a : R₁), (RingHomInvPair.toRingEquiv σ σ') a = σ a | true |
Option.attachWith_some._proof_1 | Init.Data.Option.Attach | ∀ {α : Type u_1} {x : α} {P : α → Prop}, (∀ (b : α), some x = some b → P b) → P x | false |
PrincipalSeg.transInitial_top | Mathlib.Order.InitialSeg | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} {r : α → α → Prop} {s : β → β → Prop} {t : γ → γ → Prop}
(f : PrincipalSeg r s) (g : InitialSeg s t), (f.transInitial g).top = g f.top | true |
Lean.Doc.set_option.getArgs | Lean.Elab.DocString.Builtin | StateT (Array (Lean.TSyntax `doc_arg)) Lean.Doc.DocM (Lean.Doc.Block Lean.ElabInline Lean.ElabBlock) | true |
AlgebraicGeometry.Scheme.precoverage_le_qcPrecoverage_of_isOpenMap | Mathlib.AlgebraicGeometry.Sites.QuasiCompact | ∀ {P : CategoryTheory.MorphismProperty AlgebraicGeometry.Scheme},
(P ≤ fun x x_1 f => IsOpenMap ⇑f) → AlgebraicGeometry.Scheme.precoverage P ≤ AlgebraicGeometry.Scheme.qcPrecoverage | true |
ContinuousLinearMapWOT.seminorm._proof_3 | Mathlib.Analysis.LocallyConvex.WeakOperatorTopology | ∀ {𝕜₁ : Type u_4} {𝕜₂ : Type u_1} [inst : NormedField 𝕜₁] [inst_1 : NormedField 𝕜₂] {σ : 𝕜₁ →+* 𝕜₂} {E : Type u_3}
{F : Type u_2} [inst_2 : AddCommGroup E] [inst_3 : TopologicalSpace E] [inst_4 : Module 𝕜₁ E]
[inst_5 : AddCommGroup F] [inst_6 : TopologicalSpace F] [inst_7 : Module 𝕜₂ F] [inst_8 : IsTopologi... | false |
Subspace.dualAnnihilator_dualAnnihilator_eq | Mathlib.LinearAlgebra.Dual.Lemmas | ∀ {K : Type u_1} {V : Type u_2} [inst : Field K] [inst_1 : AddCommGroup V] [inst_2 : Module K V]
[inst_3 : FiniteDimensional K V] (W : Subspace K V),
(Submodule.dualAnnihilator W).dualAnnihilator = (Module.mapEvalEquiv K V) W | true |
PadicInt.mahlerSeries_apply | Mathlib.NumberTheory.Padics.MahlerBasis | ∀ {p : ℕ} [hp : Fact (Nat.Prime p)] {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : Module ℤ_[p] E]
[inst_2 : IsBoundedSMul ℤ_[p] E] [IsUltrametricDist E] [CompleteSpace E] {a : ℕ → E},
Filter.Tendsto a Filter.atTop (nhds 0) → ∀ (x : ℤ_[p]), (PadicInt.mahlerSeries a) x = ∑' (n : ℕ), (mahler n) x • a n | true |
Real.ofDigitsTerm_le | Mathlib.Analysis.Real.OfDigits | ∀ {b : ℕ} {digits : ℕ → Fin b} {n : ℕ}, Real.ofDigitsTerm digits n ≤ (↑b - 1) * (↑b ^ (n + 1))⁻¹ | true |
LieDerivation.SMulBracketCommClass.mk._flat_ctor | Mathlib.Algebra.Lie.Derivation.Basic | ∀ {S : Type u_4} {L : Type u_5} {α : Type u_6} [inst : SMul S α] [inst_1 : LieRing L] [inst_2 : AddCommGroup α]
[inst_3 : LieRingModule L α],
(∀ (s : S) (l : L) (a : α), s • ⁅l, a⁆ = ⁅l, s • a⁆) → LieDerivation.SMulBracketCommClass S L α | false |
_private.Lean.ParserCompiler.0.Lean.ParserCompiler.parserNodeKind?._sparseCasesOn_1 | Lean.ParserCompiler | {motive : Lean.Expr → Sort u} →
(t : Lean.Expr) →
((binderName : Lean.Name) →
(binderType body : Lean.Expr) →
(binderInfo : Lean.BinderInfo) → motive (Lean.Expr.lam binderName binderType body binderInfo)) →
((declName : Lean.Name) →
(type value body : Lean.Expr) → (nondep : Bool)... | false |
Graph.isLink_self_iff | Mathlib.Combinatorics.Graph.Basic | ∀ {α : Type u_1} {β : Type u_2} {x : α} {e : β} {G : Graph α β}, G.IsLink e x x ↔ G.IsLoopAt e x | true |
bernoulli_zero | Mathlib.NumberTheory.Bernoulli | bernoulli 0 = 1 | true |
_private.Lean.Meta.Tactic.Grind.MBTC.0.Lean.Meta.Grind.Key.ctorIdx | Lean.Meta.Tactic.Grind.MBTC | Lean.Meta.Grind.Key✝ → ℕ | false |
ProbabilityTheory.CondIndepSets.bInter | Mathlib.Probability.Independence.Conditional | ∀ {Ω : Type u_1} {ι : Type u_2} {m' mΩ : MeasurableSpace Ω} [inst : StandardBorelSpace Ω] {hm' : m' ≤ mΩ}
{μ : MeasureTheory.Measure Ω} [inst_1 : MeasureTheory.IsFiniteMeasure μ] {s : ι → Set (Set Ω)} {s' : Set (Set Ω)}
{u : Set ι},
(∃ n ∈ u, ProbabilityTheory.CondIndepSets m' hm' (s n) s' μ) →
ProbabilityThe... | true |
MulOpposite.instDivisionMonoid | Mathlib.Algebra.Group.Opposite | {α : Type u_1} → [DivisionMonoid α] → DivisionMonoid αᵐᵒᵖ | true |
IsTopologicalGroup.to_continuousDiv | Mathlib.Topology.Algebra.Group.Defs | ∀ {G : Type u} [inst : TopologicalSpace G] [inst_1 : Group G] [IsTopologicalGroup G], ContinuousDiv G | true |
Subsemiring.mem_toNonUnitalSubsemiring | Mathlib.Algebra.Ring.Subsemiring.Defs | ∀ {R : Type u} [inst : NonAssocSemiring R] {S : Subsemiring R} {x : R}, x ∈ S.toNonUnitalSubsemiring ↔ x ∈ S | true |
_private.Init.Data.String.Basic.0.String.Pos.Raw.isValid_singleton._simp_1_2 | Init.Data.String.Basic | ∀ {x y : String.Pos.Raw}, (x = y) = (x.byteIdx = y.byteIdx) | false |
List.prod_nat_mod | Mathlib.Algebra.BigOperators.Group.List.Basic | ∀ (l : List ℕ) (n : ℕ), l.prod % n = (List.map (fun x => x % n) l).prod % n | true |
Archimedean.ratLt'.eq_1 | Mathlib.Data.Real.Embedding | ∀ {M : Type u_1} [inst : AddCommGroup M] [inst_1 : LinearOrder M] [inst_2 : One M] (x : M),
Archimedean.ratLt' x = ⇑(Rat.castHom ℝ) '' Archimedean.ratLt x | true |
_private.Lean.Meta.Tactic.Grind.Main.0.Lean.Meta.Grind.initCore | Lean.Meta.Tactic.Grind.Main | Lean.MVarId → Lean.Meta.Grind.GrindM Lean.Meta.Grind.Goal | true |
Std.Internal.UV.System.GroupInfo | Std.Internal.UV.System | Type | true |
CategoryTheory.Limits.IsTerminal.isSplitMono_from | Mathlib.CategoryTheory.Limits.Shapes.IsTerminal | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {X Y : C} (t : CategoryTheory.Limits.IsTerminal X)
(f : X ⟶ Y), CategoryTheory.IsSplitMono f | true |
CategoryTheory.Factorisation.comp_h_assoc | Mathlib.CategoryTheory.Category.Factorisation | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y : C} {f : X ⟶ Y}
{X_1 Y_1 Z : CategoryTheory.Factorisation f} (f_1 : X_1 ⟶ Y_1) (g : Y_1 ⟶ Z) {Z_1 : C} (h : Z.mid ⟶ Z_1),
CategoryTheory.CategoryStruct.comp (CategoryTheory.CategoryStruct.comp f_1 g).h h =
CategoryTheory.CategoryStruct.comp f_1.h (C... | true |
AddCommGroup.intIsScalarTower | Mathlib.Algebra.Module.NatInt | ∀ {R : Type u} {M : Type v} [inst : Ring R] [inst_1 : AddCommGroup M] [inst_2 : Module R M], IsScalarTower ℤ R M | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.