name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
geom_sum₂_mul_add | Mathlib.Algebra.Ring.GeomSum | ∀ {R : Type u_1} [inst : CommSemiring R] (x y : R) (n : ℕ),
(∑ i ∈ Finset.range n, (x + y) ^ i * y ^ (n - 1 - i)) * x + y ^ n = (x + y) ^ n | true |
_private.Mathlib.Data.Set.Card.Arithmetic.0.Set.Finite.ncard_biUnion_le._simp_1_1 | Mathlib.Data.Set.Card.Arithmetic | ∀ {α : Type u_1} {M : Type u_5} [inst : AddCommMonoid M] (f : α → M) {s : Set α} (hs : s.Finite),
∑ i ∈ hs.toFinset, f i = ∑ᶠ (i : α) (_ : i ∈ s), f i | false |
AlgebraicGeometry.Proj.basicOpenIsoAway | Mathlib.AlgebraicGeometry.ProjectiveSpectrum.Basic | {σ : Type u_1} →
{A : Type u} →
[inst : CommRing A] →
[inst_1 : SetLike σ A] →
[inst_2 : AddSubgroupClass σ A] →
(𝒜 : ℕ → σ) →
[inst_3 : GradedRing 𝒜] →
(f : A) →
{m : ℕ} →
f ∈ 𝒜 m →
0 < m →
... | true |
Graph.Inc | Mathlib.Combinatorics.Graph.Basic | {α : Type u_1} → {β : Type u_2} → Graph α β → β → α → Prop | true |
PolynomialLaw.lground._proof_2 | Mathlib.RingTheory.PolynomialLaw.Basic | ∀ {R : Type u_3} [inst : CommSemiring R] {M : Type u_1} [inst_1 : AddCommMonoid M] [inst_2 : Module R M] {N : Type u_2}
[inst_3 : AddCommMonoid N] [inst_4 : Module R N] (x y : M →ₚₗ[R] N), (x + y).ground = x.ground + y.ground | false |
ENNReal.HolderConjugate.inv_one_sub_inv | Mathlib.Data.Real.ConjExponents | ∀ {a : ENNReal}, a ≤ 1 → a⁻¹.HolderConjugate (1 - a)⁻¹ | true |
Lean.LibrarySuggestions.typePrefixDenyListExt | Lean.LibrarySuggestions.Basic | Lean.SimplePersistentEnvExtension Lean.Name (List Lean.Name) | true |
Lean.Elab.DefParsed | Lean.Elab.DefView | Type | true |
Std.Time.Modifier.Qorq.elim | Std.Time.Format.Basic | {motive : Std.Time.Modifier → Sort u} →
(t : Std.Time.Modifier) →
t.ctorIdx = 6 →
((presentation : Std.Time.Number ⊕ Std.Time.Text) → motive (Std.Time.Modifier.Qorq presentation)) → motive t | false |
UInt16.toUInt32_add | Init.Data.UInt.Lemmas | ∀ (a b : UInt16), (a + b).toUInt32 = (a.toUInt32 + b.toUInt32) % 65536 | true |
Lean.Meta.Grind.Arith.CollectDecVars.State.visited._default | Lean.Meta.Tactic.Grind.Arith.Util | Std.HashSet UInt64 | false |
_private.Mathlib.Tactic.DeriveEncodable.0.Mathlib.Deriving.Encodable.S.decode._proof_5 | Mathlib.Tactic.DeriveEncodable | ∀ (n : ℕ), ¬(Nat.unpair n).1 = 0 → (Nat.unpair n).1 ≤ n → (Nat.unpair n).1 < n | false |
Lean.Meta.Grind.Order.Struct.ltInst? | Lean.Meta.Tactic.Grind.Order.Types | Lean.Meta.Grind.Order.Struct → Option Lean.Expr | true |
IterateAddAct.instAddAction._proof_1 | Mathlib.GroupTheory.GroupAction.IterateAct | ∀ {α : Type u_1} {f : α → α} (x x_1 : IterateAddAct f) (x_2 : α), f^[x.val + x_1.val] x_2 = f^[x.val] (f^[x_1.val] x_2) | false |
Lean.HasConstCache.recOn | Lean.Util.HasConstCache | {declNames : Array Lean.Name} →
{motive : Lean.HasConstCache declNames → Sort u} →
(t : Lean.HasConstCache declNames) →
((cache : Std.HashMap.Raw Lean.Expr Bool) → motive { cache := cache }) → motive t | false |
_private.Mathlib.Combinatorics.SimpleGraph.Bipartite.0.SimpleGraph.degree_le_between_add._simp_1_1 | Mathlib.Combinatorics.SimpleGraph.Bipartite | ∀ {V : Type u_1} (G : SimpleGraph V) (v : V) [inst : Fintype ↑(G.neighborSet v)], G.degree v = (G.neighborFinset v).card | false |
Turing.ToPartrec.Code.noConfusion | Mathlib.Computability.TuringMachine.Config | {P : Sort u} → {t t' : Turing.ToPartrec.Code} → t = t' → Turing.ToPartrec.Code.noConfusionType P t t' | false |
Lean.Meta.map2MetaM | Lean.Meta.Basic | {m : Type → Type u_1} →
{β : Sort u_2} →
{γ : Sort u_3} →
[MonadControlT Lean.MetaM m] →
[Monad m] → ({α : Type} → (β → γ → Lean.MetaM α) → Lean.MetaM α) → {α : Type} → (β → γ → m α) → m α | true |
instSMulWithZeroNat | Mathlib.Algebra.Module.NatInt | {M : Type u_3} → [inst : AddMonoid M] → SMulWithZero ℕ M | true |
CategoryTheory.ShortComplex.HomologyData.ofEpiOfIsIsoOfMono | Mathlib.Algebra.Homology.ShortComplex.Homology | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
[inst_1 : CategoryTheory.Limits.HasZeroMorphisms C] →
{S₁ S₂ : CategoryTheory.ShortComplex C} →
(φ : S₁ ⟶ S₂) →
S₁.HomologyData →
[CategoryTheory.Epi φ.τ₁] → [CategoryTheory.IsIso φ.τ₂] → [CategoryTheory.Mono φ.τ₃] → S₂... | true |
List.rel_perm | Mathlib.Data.List.Perm.Basic | ∀ {α : Type u_1} {β : Type u_2} {r : α → β → Prop},
Relator.BiUnique r →
Relator.LiftFun (List.Forall₂ r) (Relator.LiftFun (List.Forall₂ r) fun x1 x2 => x1 ↔ x2) List.Perm List.Perm | true |
Std.DTreeMap.Internal.Impl.foldlM.eq_1 | Std.Data.DTreeMap.Internal.WF.Lemmas | ∀ {α : Type u} {β : α → Type v} {δ : Type w} {m : Type w → Type u_1} [inst : Monad m] (f : δ → (a : α) → β a → m δ)
(init : δ), Std.DTreeMap.Internal.Impl.foldlM f init Std.DTreeMap.Internal.Impl.leaf = pure init | true |
_private.Mathlib.Lean.Name.0.Lean.Name.willRoundTrip.go._unsafe_rec | Mathlib.Lean.Name | Lean.Name → Bool | false |
PUnit.normalizedGCDMonoid._proof_3 | Mathlib.Algebra.GCDMonoid.PUnit | ∀ (x : PUnit.{u_1 + 1}), x = PUnit.unit * PUnit.unit | false |
HasDerivAt.tendsto_nhdsNE | Mathlib.Analysis.Calculus.Deriv.Inverse | ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {F : Type v} [inst_1 : NormedAddCommGroup F]
[inst_2 : NormedSpace 𝕜 F] {f : 𝕜 → F} {f' : F} {x : 𝕜},
HasDerivAt f f' x → f' ≠ 0 → Filter.Tendsto f (nhdsWithin x {x}ᶜ) (nhdsWithin (f x) {f x}ᶜ) | true |
Sum.lex_inr_inl._simp_1 | Init.Data.Sum.Basic | ∀ {α : Type u_1} {r : α → α → Prop} {β : Type u_2} {s : β → β → Prop} {b : β} {a : α},
Sum.Lex r s (Sum.inr b) (Sum.inl a) = False | false |
HomogeneousLocalization.algebraMap_apply | Mathlib.RingTheory.GradedAlgebra.HomogeneousLocalization | ∀ {ι : Type u_1} {A : Type u_2} {σ : Type u_3} [inst : CommRing A] [inst_1 : SetLike σ A]
[inst_2 : AddSubgroupClass σ A] [inst_3 : AddCommMonoid ι] [inst_4 : DecidableEq ι] {𝒜 : ι → σ}
[inst_5 : GradedRing 𝒜] {x : Submonoid A} (y : HomogeneousLocalization 𝒜 x),
(algebraMap (HomogeneousLocalization 𝒜 x) (Loca... | true |
HomotopyGroup.Pi | Mathlib.Topology.Homotopy.HomotopyGroup | ℕ → (X : Type u_3) → [TopologicalSpace X] → X → Type u_3 | true |
_private.Lean.Meta.Tactic.Grind.Arith.Cutsat.0.Lean.Meta.Grind.Arith.Cutsat.initFn._@.Lean.Meta.Tactic.Grind.Arith.Cutsat.655095259._hygCtx._hyg.2 | Lean.Meta.Tactic.Grind.Arith.Cutsat | IO Unit | false |
Lean.Meta.Grind.Arith.Linear.EqCnstrProof.subst.inj | Lean.Meta.Tactic.Grind.Arith.Linear.Types | ∀ {x : Lean.Grind.Linarith.Var} {c₁ c₂ : Lean.Meta.Grind.Arith.Linear.EqCnstr} {x_1 : Lean.Grind.Linarith.Var}
{c₁_1 c₂_1 : Lean.Meta.Grind.Arith.Linear.EqCnstr},
Lean.Meta.Grind.Arith.Linear.EqCnstrProof.subst x c₁ c₂ =
Lean.Meta.Grind.Arith.Linear.EqCnstrProof.subst x_1 c₁_1 c₂_1 →
x = x_1 ∧ c₁ = c₁_1 ∧... | true |
Lean.Elab.DefViewElabHeader.ctorIdx | Lean.Elab.MutualDef | Lean.Elab.DefViewElabHeader → ℕ | false |
Lean.Parser.Tactic.«_aux_Std_Tactic_Do_Syntax___macroRules_Lean_Parser_Tactic_mcasesPat%__1» | Std.Tactic.Do.Syntax | Lean.Macro | false |
Set.image2 | Mathlib.Data.Set.Operations | {α : Type u} → {β : Type v} → {γ : Type w} → (α → β → γ) → Set α → Set β → Set γ | true |
_private.Mathlib.RingTheory.Spectrum.Prime.RingHom.0.PrimeSpectrum.preimage_comap_zeroLocus_aux._simp_1_1 | Mathlib.RingTheory.Spectrum.Prime.RingHom | ∀ {R : Type u} [inst : CommSemiring R] (x : PrimeSpectrum R) (s : Set R),
(x ∈ PrimeSpectrum.zeroLocus s) = (s ⊆ ↑x.asIdeal) | false |
TopologicalSpace.NoetherianSpace.range | Mathlib.Topology.NoetherianSpace | ∀ {α : Type u_1} {β : Type u_2} [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β]
[TopologicalSpace.NoetherianSpace α] (f : α → β), Continuous f → TopologicalSpace.NoetherianSpace ↑(Set.range f) | true |
AlgebraicGeometry.IsPreimmersion.toSurjectiveOnStalks | Mathlib.AlgebraicGeometry.Morphisms.Preimmersion | ∀ {X Y : AlgebraicGeometry.Scheme} {f : X ⟶ Y} [self : AlgebraicGeometry.IsPreimmersion f],
AlgebraicGeometry.SurjectiveOnStalks f | true |
TopModuleCat.isColimit._proof_1 | Mathlib.Algebra.Category.ModuleCat.Topology.Basic | ∀ {R : Type u_2} [inst : Ring R] [inst_1 : TopologicalSpace R] {J : Type u_4}
[inst_2 : CategoryTheory.Category.{u_3, u_4} J] {F : CategoryTheory.Functor J (TopModuleCat R)}
{c : CategoryTheory.Limits.Cocone (F.comp (CategoryTheory.forget₂ (TopModuleCat R) (ModuleCat R)))}
(hc : CategoryTheory.Limits.IsColimit c)... | false |
Asymptotics.isLittleO_principal._simp_1 | Mathlib.Analysis.Asymptotics.Lemmas | ∀ {α : Type u_1} {F' : Type u_7} {E'' : Type u_9} [inst : SeminormedAddCommGroup F'] [inst_1 : NormedAddCommGroup E'']
{g' : α → F'} {f'' : α → E''} {s : Set α}, f'' =o[Filter.principal s] g' = ∀ x ∈ s, f'' x = 0 | false |
Lean.JsonRpc.Request.method | Lean.Data.JsonRpc | {α : Type u} → Lean.JsonRpc.Request α → String | true |
YoungDiagram.mem_inf._simp_1 | Mathlib.Combinatorics.Young.YoungDiagram | ∀ {μ ν : YoungDiagram} {x : ℕ × ℕ}, (x ∈ μ ⊓ ν) = (x ∈ μ ∧ x ∈ ν) | false |
CategoryTheory.CommMon.EquivLaxBraidedFunctorPUnit.unitIso._proof_1 | Mathlib.CategoryTheory.Monoidal.CommMon_ | ∀ (x : CategoryTheory.Discrete PUnit.{u_1 + 1}),
x = (CategoryTheory.CommMon.trivial (CategoryTheory.Discrete PUnit.{u_1 + 1})).toMon.X | false |
_private.Mathlib.CategoryTheory.Limits.Shapes.Products.0.CategoryTheory.Limits.Sigma.hom_ext.match_1_1 | Mathlib.CategoryTheory.Limits.Shapes.Products | ∀ {β : Type u_1} (motive : CategoryTheory.Discrete β → Prop) (x : CategoryTheory.Discrete β),
(∀ (j : β), motive { as := j }) → motive x | false |
intervalIntegral.mul_integral_comp_sub_mul | Mathlib.Analysis.SpecialFunctions.Integrals.Basic | ∀ {a b : ℝ} {f : ℝ → ℝ} (c d : ℝ), c * ∫ (x : ℝ) in a..b, f (d - c * x) = ∫ (x : ℝ) in d - c * b..d - c * a, f x | true |
_private.Mathlib.MeasureTheory.Function.Jacobian.0.MeasureTheory.addHaar_image_eq_zero_of_det_fderivWithin_eq_zero_aux._simp_1_2 | Mathlib.MeasureTheory.Function.Jacobian | ∀ {α : Type u_1} [inst : AddZeroClass α] [inst_1 : LT α] [AddLeftStrictMono α] [AddLeftReflectLT α] (a : α) {b : α},
(a < a + b) = (0 < b) | false |
List.take_modifyHead | Init.Data.List.Nat.Modify | ∀ {α : Type u_1} {f : α → α} {l : List α} {i : ℕ}, List.take i (List.modifyHead f l) = List.modifyHead f (List.take i l) | true |
_private.Mathlib.Data.W.Basic.0.WType.encodable_zero | Mathlib.Data.W.Basic | {α : Type u_1} →
{β : α → Type u_2} →
[inst : (a : α) → Fintype (β a)] → [inst_1 : (a : α) → Encodable (β a)] → Encodable (WType.WType'✝ β 0) | true |
_private.Mathlib.ModelTheory.Fraisse.0.FirstOrder.Language.isUltrahomogeneous_iff_IsExtensionPair.match_1_1 | Mathlib.ModelTheory.Fraisse | ∀ {L : FirstOrder.Language} {M : Type u_3} [inst : L.Structure M] (motive : L.FGEquiv M M → Prop) (h : L.FGEquiv M M),
(∀ (f : L.PartialEquiv M M) (f_FG : f.dom.FG), motive ⟨f, f_FG⟩) → motive h | false |
Std.Iter.Total.allM | Init.Data.Iterators.Consumers.Loop | {α β : Type w} →
{m : Type → Type w'} →
[Monad m] →
[inst : Std.Iterator α Id β] →
[Std.IteratorLoop α Id m] → [Std.Iterators.Finite α Id] → (β → m Bool) → Std.Iter.Total β → m Bool | true |
RatFunc.sub | Mathlib.FieldTheory.RatFunc.Basic | {K : Type u_1} → [inst : CommRing K] → RatFunc K → RatFunc K → RatFunc K | true |
PadicInt.instCommRing._proof_47 | Mathlib.NumberTheory.Padics.PadicIntegers | ∀ {p : ℕ} [hp : Fact (Nat.Prime p)] (a b : ℤ_[p]), a * b = b * a | false |
_private.Mathlib.RingTheory.Spectrum.Prime.ChevalleyComplexity.0.ChevalleyThm.chevalley_mvPolynomialC._simp_1_2 | Mathlib.RingTheory.Spectrum.Prime.ChevalleyComplexity | ∀ {α : Sort u_1} {p : α → Prop} {q : (∃ x, p x) → Prop}, (∀ (h : ∃ x, p x), q h) = ∀ (x : α) (h : p x), q ⋯ | false |
IsLocalRing.basisQuotient._proof_2 | Mathlib.RingTheory.LocalRing.Quotient | ∀ {R : Type u_2} {S : Type u_3} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S]
[inst_3 : IsLocalRing R] [Module.Finite R S] [Module.Free R S] {ι : Type u_1} [inst_6 : Fintype ι]
(b : Module.Basis ι R S),
Fintype.card ι =
Module.finrank (R ⧸ IsLocalRing.maximalIdeal R) (S ⧸ Ideal.map (algebra... | false |
AlgebraicGeometry.Scheme.ellAdicSheaf._proof_2 | Mathlib.AlgebraicGeometry.Sites.ElladicCohomology | ∀ (ℓ : ℕ) [inst : Fact (Nat.Prime ℓ)],
CategoryTheory.Presheaf.IsSheaf AlgebraicGeometry.Scheme.proetaleTopology
(AlgebraicGeometry.continuousMapPresheafAb ℤ_[ℓ]) | false |
ContDiffOn.csin | Mathlib.Analysis.SpecialFunctions.Trigonometric.Deriv | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℂ E] {f : E → ℂ} {s : Set E} {n : WithTop ℕ∞},
ContDiffOn ℂ n f s → ContDiffOn ℂ n (fun x => Complex.sin (f x)) s | true |
CategoryTheory.Discrete.mk.noConfusion | Mathlib.CategoryTheory.Discrete.Basic | {α : Type u₁} → {P : Sort u} → {as as' : α} → { as := as } = { as := as' } → (as ≍ as' → P) → P | false |
Finset.Ico_succ_succ | Mathlib.Data.Int.Interval | ∀ (m n : ℕ), Finset.Ico (-(↑m + 1)) (↑n + 1) = Finset.Ico (-↑m) ↑n ∪ {-(↑m + 1), ↑n} | true |
Std.DTreeMap.Internal.Impl.maxKeyD_erase!_eq_of_not_compare_maxKeyD_eq | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Std.DTreeMap.Internal.Impl α β} [Std.TransOrd α],
t.WF →
∀ {k fallback : α},
(Std.DTreeMap.Internal.Impl.erase! k t).isEmpty = false →
¬compare k (t.maxKeyD fallback) = Ordering.eq →
(Std.DTreeMap.Internal.Impl.erase! k t).maxKeyD fall... | true |
UInt64.toInt64_ofNat | Init.Data.SInt.Lemmas | ∀ {n : ℕ}, (OfNat.ofNat n).toInt64 = OfNat.ofNat n | true |
CategoryTheory.unop_inv_rightUnitor | Mathlib.CategoryTheory.Monoidal.Opposite | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.MonoidalCategory C] (X : Cᵒᵖ),
(CategoryTheory.MonoidalCategoryStruct.rightUnitor X).inv.unop =
(CategoryTheory.MonoidalCategoryStruct.rightUnitor (Opposite.unop X)).hom | true |
Filter.liminf_top_eq_ciInf | Mathlib.Order.LiminfLimsup | ∀ {α : Type u_1} {β : Type u_2} [inst : ConditionallyCompleteLattice α] {u : β → α} [Nonempty β],
BddBelow (Set.range u) → Filter.liminf u ⊤ = ⨅ i, u i | true |
Matrix.isUnit_nonsing_inv_det_iff | Mathlib.LinearAlgebra.Matrix.NonsingularInverse | ∀ {n : Type u'} {α : Type v} [inst : Fintype n] [inst_1 : DecidableEq n] [inst_2 : CommRing α] {A : Matrix n n α},
IsUnit A⁻¹.det ↔ IsUnit A.det | true |
Lean.Meta.Grind.saveAppOf | Lean.Meta.Tactic.Grind.Types | Lean.HeadIndex → Lean.Meta.Grind.GrindM Unit | true |
AlgebraicTopology.DoldKan.HigherFacesVanish | Mathlib.AlgebraicTopology.DoldKan.Faces | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
[CategoryTheory.Preadditive C] →
{X : CategoryTheory.SimplicialObject C} →
{Y : C} → {n : ℕ} → ℕ → (Y ⟶ X.obj (Opposite.op (SimplexCategory.mk (n + 1)))) → Prop | true |
_private.Mathlib.Order.Interval.Set.Basic.0.Set.Icc_subset_Icc_iff._to_dual_1.match_1_1 | Mathlib.Order.Interval.Set.Basic | ∀ {α : Type u_1} [inst : Preorder α] {a₁ a₂ b₁ b₂ : α} (motive : a₁ ≤ a₂ ∧ b₂ ≤ b₁ → Prop) (x : a₁ ≤ a₂ ∧ b₂ ≤ b₁),
(∀ (h : a₁ ≤ a₂) (h' : b₂ ≤ b₁), motive ⋯) → motive x | false |
CategoryTheory.Subobject.finset_inf_factors | Mathlib.CategoryTheory.Subobject.Lattice | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.Limits.HasPullbacks C]
{I : Type u_1} {A B : C} {s : Finset I} {P : I → CategoryTheory.Subobject B} (f : A ⟶ B),
(s.inf P).Factors f ↔ ∀ i ∈ s, (P i).Factors f | true |
_private.Mathlib.Data.Finsupp.Single.0.Finsupp.erase_idem._proof_1_1 | Mathlib.Data.Finsupp.Single | ∀ {α : Type u_1} {M : Type u_2} [inst : Zero M] (f : α →₀ M) (a : α),
Finsupp.erase a (Finsupp.erase a f) = Finsupp.erase a f | false |
Rep.indMap._proof_2 | Mathlib.RepresentationTheory.Induced | ∀ {k : Type u_1} {G : Type u_4} {H : Type u_2} [inst : CommRing k] [inst_1 : Group G] [inst_2 : Group H] (φ : G →* H)
{A B : Rep.{u_3, u_1, u_4} k G} (f : A ⟶ B) (g : H),
Representation.Coinvariants.map (Representation.tprod (MonoidHom.comp (Representation.leftRegular k H) φ) A.ρ)
(Representation.tprod (Mon... | false |
SetLike.GradeZero.instRing._proof_1 | Mathlib.Algebra.DirectSum.Internal | ∀ {ι : Type u_3} {σ : Type u_2} {R : Type u_1} [inst : Ring R] [inst_1 : AddMonoid ι] [inst_2 : SetLike σ R]
[inst_3 : AddSubgroupClass σ R] (A : ι → σ) [inst_4 : SetLike.GradedMonoid A],
autoParam (∀ (a b : ↥(A 0)), a - b = a + -b) SubNegMonoid.sub_eq_add_neg._autoParam | false |
FirstOrder.Language.LHom.noConfusionType | Mathlib.ModelTheory.LanguageMap | Sort u_1 →
{L : FirstOrder.Language} →
{L' : FirstOrder.Language} →
(L →ᴸ L') → {L' : FirstOrder.Language} → {L'' : FirstOrder.Language} → (L' →ᴸ L'') → Sort u_1 | false |
UniformEquiv.refl | Mathlib.Topology.UniformSpace.Equiv | (α : Type u_4) → [inst : UniformSpace α] → α ≃ᵤ α | true |
_private.Mathlib.Tactic.Linter.FindDeprecations.0.Mathlib.Tactic.getDeprecatedInfo.match_4 | Mathlib.Tactic.Linter.FindDeprecations | (motive : Option Lean.DeclarationRanges → Sort u_1) →
(__do_lift : Option Lean.DeclarationRanges) →
((rg selectionRange : Lean.DeclarationRange) → motive (some { range := rg, selectionRange := selectionRange })) →
((x : Option Lean.DeclarationRanges) → motive x) → motive __do_lift | false |
Lean.Meta.Grind.Arith.Cutsat.CooperSplit.pred | Lean.Meta.Tactic.Grind.Arith.Cutsat.Types | Lean.Meta.Grind.Arith.Cutsat.CooperSplit → Lean.Meta.Grind.Arith.Cutsat.CooperSplitPred | true |
Lean.Elab.DefsParsedSnapshot.mk.injEq | Lean.Elab.DefView | ∀ (toSnapshot : Lean.Language.Snapshot) (defs : Array Lean.Elab.DefParsed) (toSnapshot_1 : Lean.Language.Snapshot)
(defs_1 : Array Lean.Elab.DefParsed),
({ toSnapshot := toSnapshot, defs := defs } = { toSnapshot := toSnapshot_1, defs := defs_1 }) =
(toSnapshot = toSnapshot_1 ∧ defs = defs_1) | true |
Std.DTreeMap.Internal.Impl.toListModel_filter | Std.Data.DTreeMap.Internal.WF.Lemmas | ∀ {α : Type u} {β : α → Type v} [inst : Ord α] {t : Std.DTreeMap.Internal.Impl α β} {h : t.Balanced}
{f : (a : α) → β a → Bool},
(Std.DTreeMap.Internal.Impl.filter f t h).impl.toListModel = List.filter (fun e => f e.fst e.snd) t.toListModel | true |
Bimod.mk.sizeOf_spec | Mathlib.CategoryTheory.Monoidal.Bimod | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.MonoidalCategory C]
{A B : CategoryTheory.Mon C} [inst_2 : SizeOf C] (X : C)
(actLeft : CategoryTheory.MonoidalCategoryStruct.tensorObj A.X X ⟶ X)
(one_actLeft :
autoParam
(CategoryTheory.CategoryStruct.comp
(... | true |
_private.Mathlib.Condensed.TopCatAdjunction.0.CondensedSet.topCatAdjunctionUnit._simp_2 | Mathlib.Condensed.TopCatAdjunction | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (F : CategoryTheory.Functor C (Type w)) {X Y Z : C} (f : X ⟶ Y)
(g : Y ⟶ Z) (a : F.obj X), F.map g (F.map f a) = F.map (CategoryTheory.CategoryStruct.comp f g) a | false |
List.or_cons | Init.Data.List.Basic | ∀ {a : Bool} {l : List Bool}, (a :: l).or = (a || l.or) | true |
instAddMonoidUniformOnFun | Mathlib.Topology.Algebra.UniformConvergence | {α : Type u_1} → {β : Type u_2} → {𝔖 : Set (Set α)} → [AddMonoid β] → AddMonoid (UniformOnFun α β 𝔖) | true |
Representation.Equiv.toLinearMap_refl | Mathlib.RepresentationTheory.Intertwining | ∀ {A : Type u_1} {G : Type u_2} {V : Type u_3} [inst : Semiring A] [inst_1 : Monoid G] [inst_2 : AddCommMonoid V]
[inst_3 : Module A V] {ρ : Representation A G V}, (↑(Representation.Equiv.refl ρ)).toLinearMap = LinearMap.id | true |
_private.Mathlib.Algebra.MonoidAlgebra.Defs.0.MonoidAlgebra.instIsCancelAdd._proof_1 | Mathlib.Algebra.MonoidAlgebra.Defs | ∀ {R : Type u_2} {M : Type u_1} [inst : Semiring R] [IsCancelAdd R], IsCancelAdd (MonoidAlgebra R M) | false |
Lean.Lsp.SymbolInformation.mk._flat_ctor | Lean.Data.Lsp.LanguageFeatures | String → Lean.Lsp.SymbolKind → Array Lean.Lsp.SymbolTag → Lean.Lsp.Location → Option String → Lean.Lsp.SymbolInformation | false |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.maxKey?_eq_some_maxKeyD._simp_1_2 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {instOrd : Ord α} {a b : α}, (compare a b ≠ Ordering.eq) = ((a == b) = false) | false |
MvPolynomial.X_mul_cancel_right_iff | Mathlib.Algebra.MvPolynomial.Basic | ∀ {R : Type u} {σ : Type u_1} [inst : CommSemiring R] {p q : MvPolynomial σ R} {i : σ},
p * MvPolynomial.X i = q * MvPolynomial.X i ↔ p = q | true |
Lean.Grind.Config.splits | Init.Grind.Config | Lean.Grind.Config → ℕ | true |
Lean.Server.Test.Runner.instFromJsonGetWidgetsResponse | Lean.Server.Test.Runner | Lean.FromJson Lean.Widget.GetWidgetsResponse | true |
Std.IterM.toArray_map_eq_toArray_mapM | Init.Data.Iterators.Lemmas.Combinators.Monadic.FilterMap | ∀ {α β γ : Type w} {m : Type w → Type w'} [inst : Monad m] [inst_1 : MonadAttach m] [LawfulMonad m]
[WeaklyLawfulMonadAttach m] [inst_4 : Std.Iterator α m β] [Std.Iterators.Finite α m] {f : β → γ} {it : Std.IterM m β},
(Std.IterM.map f it).toArray = (Std.IterM.mapM (fun b => pure (f b)) it).toArray | true |
CategoryTheory.Oplax.StrongTrans.Hom.rec | Mathlib.CategoryTheory.Bicategory.Modification.Oplax | {B : Type u₁} →
[inst : CategoryTheory.Bicategory B] →
{C : Type u₂} →
[inst_1 : CategoryTheory.Bicategory C] →
{F G : CategoryTheory.OplaxFunctor B C} →
{η θ : F ⟶ G} →
{motive : CategoryTheory.Oplax.StrongTrans.Hom η θ → Sort u} →
((as : CategoryTheory.Oplax.Str... | false |
_private.Init.Data.Iterators.Lemmas.Combinators.Monadic.FilterMap.0.Std.IterM.DefaultConsumers.forIn'_eq_match_step.match_3.eq_3 | Init.Data.Iterators.Lemmas.Combinators.Monadic.FilterMap | ∀ {α β : Type u_1} {m : Type u_1 → Type u_2} [inst : Std.Iterator α m β] {it : Std.IterM m β}
(motive : it.Step → Sort u_3) (property : it.IsPlausibleStep Std.IterStep.done)
(h_1 :
(it' : Std.IterM m β) →
(out : β) → (h : it.IsPlausibleStep (Std.IterStep.yield it' out)) → motive ⟨Std.IterStep.yield it' ou... | true |
_private.Mathlib.NumberTheory.NumberField.CanonicalEmbedding.FundamentalCone.0.NumberField.mixedEmbedding.fundamentalCone.mem_integerSet._simp_1_3 | Mathlib.NumberTheory.NumberField.CanonicalEmbedding.FundamentalCone | ∀ {A : Type u_1} {B : Type u_2} [i : SetLike A B] {p : A} {x : B}, (x ∈ ↑p) = (x ∈ p) | false |
DFinsupp.instSMulPosReflectLT | Mathlib.Data.DFinsupp.Order | ∀ {ι : Type u_1} {α : Type u_3} {β : ι → Type u_4} [inst : Semiring α] [inst_1 : PartialOrder α]
[inst_2 : (i : ι) → AddCommMonoid (β i)] [inst_3 : (i : ι) → PartialOrder (β i)] [inst_4 : (i : ι) → Module α (β i)]
[∀ (i : ι), SMulPosReflectLT α (β i)], SMulPosReflectLT α (Π₀ (i : ι), β i) | true |
RelSeries.append_apply_left | Mathlib.Order.RelSeries | ∀ {α : Type u_1} {r : SetRel α α} (p q : RelSeries r) (connect : (p.last, q.head) ∈ r) (i : Fin (p.length + 1)),
(p.append q connect).toFun (Fin.cast ⋯ (Fin.castAdd (q.length + 1) i)) = p.toFun i | true |
DomAddAct.instAddActionForall._proof_1 | Mathlib.GroupTheory.GroupAction.DomAct.Basic | ∀ {M : Type u_1} {β : Type u_3} {α : Type u_2} [inst : AddMonoid M] [inst_1 : AddAction M α] (x x_1 : Mᵈᵃᵃ) (f : α → β),
(x + x_1) +ᵥ f = x +ᵥ x_1 +ᵥ f | false |
Polygon.toTriangle_points | Mathlib.Geometry.Polygon.Basic | ∀ {R : Type u_1} {V : Type u_2} {P : Type u_3} [inst : Ring R] [inst_1 : AddCommGroup V] [inst_2 : Module R V]
[inst_3 : AddTorsor V P] (p : Polygon P 3) (h : Polygon.HasNondegenerateVertices R p),
(Polygon.toTriangle R p h).points = p.vertices | true |
ModelWithCorners.locallyCompactSpace | Mathlib.Geometry.Manifold.IsManifold.Basic | ∀ {𝕜 : 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] [LocallyCompactSpace E]
(I : ModelWithCorners 𝕜 E H), LocallyCompactSpace H | true |
Std.Tactic.BVDecide.BVExpr.decEq._proof_97 | Std.Tactic.BVDecide.Bitblast.BVExpr.Basic | ∀ {w : ℕ} (ll lr : ℕ) (llhs : Std.Tactic.BVDecide.BVExpr ll) (lrhs : Std.Tactic.BVDecide.BVExpr lr) (lh : w = ll + lr)
(rl rr : ℕ) (rlhs : Std.Tactic.BVDecide.BVExpr rl) (rrhs : Std.Tactic.BVDecide.BVExpr rr) (rh : w = rl + rr),
¬hash (llhs.append lrhs lh) ≠ hash (rlhs.append rrhs rh) →
∀ (h1 : ll = rl ∧ lr = r... | false |
SubringClass.toNormedRing._proof_1 | Mathlib.Analysis.Normed.Ring.Basic | ∀ {S : Type u_2} {R : Type u_1} [inst : SetLike S R] [inst_1 : NormedRing R] [inst_2 : SubringClass S R] (s : S),
NonUnitalRingHomClass (↥s →+* R) (↥s) R | false |
UpperSemicontinuousAt.add | Mathlib.Topology.Semicontinuity.Basic | ∀ {α : Type u_1} [inst : TopologicalSpace α] {x : α} {γ : Type u_5} [inst_1 : AddCommMonoid γ] [inst_2 : LinearOrder γ]
[IsOrderedAddMonoid γ] [inst_4 : TopologicalSpace γ] [OrderTopology γ] [ContinuousAdd γ] {f g : α → γ},
UpperSemicontinuousAt f x → UpperSemicontinuousAt g x → UpperSemicontinuousAt (fun z => f z ... | true |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.Equiv.maxKey?_eq._simp_1_3 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {x : Ord α} {t : Std.DTreeMap.Internal.Impl α β} {k : α},
(k ∈ t) = (Std.DTreeMap.Internal.Impl.contains k t = true) | false |
LinearMap.comap_le_comap_iff | Mathlib.Algebra.Module.Submodule.Range | ∀ {R : Type u_1} {R₂ : Type u_2} {M : Type u_5} {M₂ : Type u_6} [inst : Semiring R] [inst_1 : Semiring R₂]
[inst_2 : AddCommMonoid M] [inst_3 : AddCommMonoid M₂] [inst_4 : Module R M] [inst_5 : Module R₂ M₂] {τ₁₂ : R →+* R₂}
[inst_6 : RingHomSurjective τ₁₂] {f : M →ₛₗ[τ₁₂] M₂},
f.range = ⊤ → ∀ {p p' : Submodule R... | true |
CategoryTheory.Limits.Cocone.extendHom.eq_1 | Mathlib.CategoryTheory.Limits.Cones | ∀ {J : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} J] {C : Type u₃} [inst_1 : CategoryTheory.Category.{v₃, u₃} C]
{F : CategoryTheory.Functor J C} (s : CategoryTheory.Limits.Cocone F) {X : C} (f : s.pt ⟶ X),
s.extendHom f = { hom := f, w := ⋯ } | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.