name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
_private.Lean.Elab.BuiltinNotation.0.Lean.Elab.Term.mkPairs.loop | Lean.Elab.BuiltinNotation | Array Lean.Term → ℕ → Lean.Term → Lean.MacroM Lean.Term | true |
CategoryTheory.IsHomLift.id_comp_lift | Mathlib.CategoryTheory.FiberedCategory.HomLift | ∀ {𝒮 : Type u₁} {𝒳 : Type u₂} [inst : CategoryTheory.Category.{v₁, u₂} 𝒳] [inst_1 : CategoryTheory.Category.{v₂, u₁} 𝒮]
(p : CategoryTheory.Functor 𝒳 𝒮) {R S : 𝒮} {a b : 𝒳} (f : R ⟶ S) (φ : a ⟶ b) [p.IsHomLift f φ],
p.IsHomLift f (CategoryTheory.CategoryStruct.comp φ (CategoryTheory.CategoryStruct.id b)) | true |
Std.DTreeMap.Internal.Impl.getEntryLE!_eq_get!_getEntryLE? | Std.Data.DTreeMap.Internal.Model | ∀ {α : Type u} {β : α → Type v} [inst : Ord α] {t : Std.DTreeMap.Internal.Impl α β} {k : α}
[inst_1 : Inhabited ((a : α) × β a)],
Std.DTreeMap.Internal.Impl.getEntryLE! k t = (Std.DTreeMap.Internal.Impl.getEntryLE? k t).get! | true |
_private.Lean.ReservedNameAction.0.Lean.initFn._@.Lean.ReservedNameAction.2721971034._hygCtx._hyg.2 | Lean.ReservedNameAction | IO (IO.Ref (Array Lean.ReservedNameAction)) | false |
DomMulAct.isInducing_mk_symm | Mathlib.Topology.Algebra.Constructions.DomMulAct | ∀ {M : Type u_1} [inst : TopologicalSpace M], Topology.IsInducing ⇑DomMulAct.mk.symm | true |
InnerProductSpace.Core.inner_add_left | Mathlib.Analysis.InnerProductSpace.Defs | ∀ {𝕜 : Type u_1} {F : Type u_3} [inst : RCLike 𝕜] [inst_1 : AddCommGroup F] [inst_2 : Module 𝕜 F]
[c : PreInnerProductSpace.Core 𝕜 F] (x y z : F), inner 𝕜 (x + y) z = inner 𝕜 x z + inner 𝕜 y z | true |
CategoryTheory.Abelian.SpectralObject.sc₃._auto_1 | Mathlib.Algebra.Homology.SpectralObject.Basic | Lean.Syntax | false |
_private.Lean.Compiler.LCNF.Specialize.0.Lean.Compiler.LCNF.Specialize.loop._unsafe_rec | Lean.Compiler.LCNF.Specialize | optParam ℕ 0 → Lean.Compiler.LCNF.Specialize.SpecializeM✝ Unit | false |
Homeomorph.mulLeft | Mathlib.Topology.Algebra.Group.Basic | {G : Type w} → [inst : TopologicalSpace G] → [inst_1 : Group G] → [SeparatelyContinuousMul G] → G → G ≃ₜ G | true |
AlgebraicGeometry.StructureSheaf.Localizations.comapFun._proof_9 | Mathlib.AlgebraicGeometry.StructureSheaf | ∀ {R : Type u_1} [inst : CommRing R] {S : Type u_1} [inst_1 : CommRing S] {N : Type u_1} [inst_2 : AddCommGroup N]
[inst_3 : Module S N] {σ : R →+* S} (y : ↑(AlgebraicGeometry.PrimeSpectrum.Top S)),
LinearMap.CompatibleSMul N (LocalizedModule y.asIdeal.primeCompl N) R S | false |
BitVec.sshiftRight_xor_distrib | Init.Data.BitVec.Lemmas | ∀ {w : ℕ} (x y : BitVec w) (n : ℕ), (x ^^^ y).sshiftRight n = x.sshiftRight n ^^^ y.sshiftRight n | true |
AddOreLocalization.zero_add | Mathlib.GroupTheory.OreLocalization.Basic | ∀ {R : Type u_1} [inst : AddMonoid R] {S : AddSubmonoid R} [inst_1 : AddOreLocalization.AddOreSet S]
(x : AddOreLocalization S R), 0 + x = x | true |
AlgebraicTopology.DoldKan.N₁_obj_p | Mathlib.AlgebraicTopology.DoldKan.FunctorN | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Preadditive C]
(X : CategoryTheory.SimplicialObject C), (AlgebraicTopology.DoldKan.N₁.obj X).p = AlgebraicTopology.DoldKan.PInfty | true |
GenContFract.convs'_succ | Mathlib.Algebra.ContinuedFractions.Computation.Translations | ∀ {K : Type u_1} [inst : DivisionRing K] [inst_1 : LinearOrder K] [inst_2 : FloorRing K] (v : K) (n : ℕ)
[IsStrictOrderedRing K], (GenContFract.of v).convs' (n + 1) = ↑⌊v⌋ + 1 / (GenContFract.of (Int.fract v)⁻¹).convs' n | true |
_private.Std.Data.ExtDTreeMap.Lemmas.0.Std.ExtDTreeMap.Const.ofList_eq_empty_iff._simp_1_2 | Std.Data.ExtDTreeMap.Lemmas | ∀ {α : Type u_1} {l : List α}, (l = []) = (l.isEmpty = true) | false |
Aesop.FVarIdSubst.casesOn | Aesop.RuleTac.FVarIdSubst | {motive : Aesop.FVarIdSubst → Sort u} →
(t : Aesop.FVarIdSubst) → ((map : Std.HashMap Lean.FVarId Lean.FVarId) → motive { map := map }) → motive t | false |
Int.Linear.eq_def'_cert | Init.Data.Int.Linear | Int.Linear.Var → Int.Linear.Expr → Int.Linear.Poly → Bool | true |
Set.powersetCard.mulActionHom_of_embedding.eq_1 | Mathlib.GroupTheory.GroupAction.SubMulAction.Combination | ∀ (G : Type u_1) [inst : Group G] (α : Type u_2) [inst_1 : MulAction G α] (n : ℕ) [inst_2 : DecidableEq α],
Set.powersetCard.mulActionHom_of_embedding G α n = { toFun := Set.powersetCard.ofFinEmb n α, map_smul' := ⋯ } | true |
Submonoid.adjoin_eq_span_of_eq_span | Mathlib.Algebra.Algebra.Subalgebra.Lattice | ∀ (F : Type u_1) (E : Type u_2) {K : Type u_3} [inst : CommSemiring E] [inst_1 : Semiring K] [inst_2 : SMul F E]
[inst_3 : Algebra E K] [inst_4 : Semiring F] [inst_5 : Module F K] [IsScalarTower F E K] (L : Submonoid K)
{S : Set K}, ↑L = ↑(Submodule.span F S) → Subalgebra.toSubmodule (Algebra.adjoin E ↑L) = Submodu... | true |
Lean.Meta.Grind.CongrKey.ctorIdx | Lean.Meta.Tactic.Grind.Types | {enodes : Lean.Meta.Grind.ENodeMap} → Lean.Meta.Grind.CongrKey enodes → ℕ | false |
_private.Mathlib.Combinatorics.SimpleGraph.Triangle.Counting.0.SimpleGraph.triangle_counting._simp_1_2 | Mathlib.Combinatorics.SimpleGraph.Triangle.Counting | ∀ {α : Type u_1} {a : α} {s : Finset α}, (a ∈ ↑s) = (a ∈ s) | false |
Std.Internal.List.getKeyD_eq_of_containsKey | Std.Data.Internal.List.Associative | ∀ {α : Type u} {β : α → Type v} [inst : BEq α] [LawfulBEq α] {l : List ((a : α) × β a)} {k fallback : α},
Std.Internal.List.containsKey k l = true → Std.Internal.List.getKeyD k l fallback = k | true |
_aux_Init_Notation___unexpand_Dvd_dvd_1 | Init.Notation | Lean.PrettyPrinter.Unexpander | false |
mdifferentiableWithinAt_inter | Mathlib.Geometry.Manifold.MFDeriv.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] {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 |
Array.findIdx_extract | Init.Data.Array.Find | ∀ {α : Type u_1} {xs : Array α} {i : ℕ} {p : α → Bool}, Array.findIdx p (xs.extract 0 i) = min i (Array.findIdx p xs) | true |
ContinuousMap.semilatticeInf | Mathlib.Topology.ContinuousMap.Ordered | {α : Type u_1} →
{β : Type u_2} →
[inst : TopologicalSpace α] →
[inst_1 : TopologicalSpace β] → [inst_2 : SemilatticeInf β] → [ContinuousInf β] → SemilatticeInf C(α, β) | true |
Real.rpow_eq_const_mul_integral | Mathlib.Analysis.SpecialFunctions.ContinuousFunctionalCalculus.Rpow.IntegralRepresentation | ∀ {p x : ℝ},
p ∈ Set.Ioo 0 1 →
0 ≤ x → x ^ p = (∫ (t : ℝ) in Set.Ioi 0, p.rpowIntegrand₀₁ t 1)⁻¹ * ∫ (t : ℝ) in Set.Ioi 0, p.rpowIntegrand₀₁ t x | true |
ConcaveOn.sub_strictConvexOn | Mathlib.Analysis.Convex.Function | ∀ {𝕜 : Type u_1} {E : Type u_2} {β : Type u_5} [inst : Semiring 𝕜] [inst_1 : PartialOrder 𝕜] [inst_2 : AddCommMonoid E]
[inst_3 : AddCommGroup β] [inst_4 : PartialOrder β] [IsOrderedAddMonoid β] [inst_6 : SMul 𝕜 E] [inst_7 : Module 𝕜 β]
{s : Set E} {f g : E → β}, ConcaveOn 𝕜 s f → StrictConvexOn 𝕜 s g → Stri... | true |
Nat.lt_of_lt_of_eq | Init.Data.Nat.Basic | ∀ {n m k : ℕ}, n < m → m = k → n < k | true |
Mathlib.Tactic.FieldSimp._aux_Mathlib_Tactic_Field___elabRules_Mathlib_Tactic_FieldSimp_field_1 | Mathlib.Tactic.Field | Lean.Elab.Tactic.Tactic | false |
_private.Mathlib.SetTheory.Ordinal.FixedPointApproximants.0.OrdinalApprox.lfpApprox_ord_eq_lfp._simp_1_3 | Mathlib.SetTheory.Ordinal.FixedPointApproximants | ∀ {α : Sort u} {p : α → Prop} {q : { a // p a } → Prop}, (∃ x, q x) = ∃ a, ∃ (b : p a), q ⟨a, b⟩ | false |
iterateInduction._proof_3 | Mathlib.Probability.Kernel.IonescuTulcea.Traj | ∀ (k : ℕ) (i : ↥(Finset.Iic k)), InvImage (fun x1 x2 => x1 < x2) (fun x => x) (↑i) k.succ | false |
IsUnifLocDoublingMeasure.wrapped._@.Mathlib.MeasureTheory.Covering.DensityTheorem.1554790178._hygCtx._hyg.2 | Mathlib.MeasureTheory.Covering.DensityTheorem | Subtype (Eq @IsUnifLocDoublingMeasure.definition✝) | false |
CategoryTheory.IsKernelPair.lift_snd_assoc | Mathlib.CategoryTheory.Limits.Shapes.KernelPair | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {R X Y : C} {f : X ⟶ Y} {a b : R ⟶ X} {S : C}
(k : CategoryTheory.IsKernelPair f a b) (p q : S ⟶ X)
(w : CategoryTheory.CategoryStruct.comp p f = CategoryTheory.CategoryStruct.comp q f) {Z : C} (h : X ⟶ Z),
CategoryTheory.CategoryStruct.comp (k.lift p q w) ... | true |
_private.Mathlib.Analysis.Complex.Trigonometric.0.Mathlib.Meta.Positivity.evalCosh.match_1 | Mathlib.Analysis.Complex.Trigonometric | (motive :
(u : Lean.Level) →
{α : Q(Type u)} →
(x : Q(Zero «$α»)) →
(x_1 : Q(PartialOrder «$α»)) →
(e : Q(«$α»)) →
Lean.MetaM (Mathlib.Meta.Positivity.Strictness x x_1 e) →
Lean.MetaM (Mathlib.Meta.Positivity.Strictness x x_1 e) → Sort u_1) →
(u : ... | false |
CategoryTheory.IsPreconnected.mk._flat_ctor | Mathlib.CategoryTheory.IsConnected | ∀ {J : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} J],
(∀ {α : Type u₁} (F : CategoryTheory.Functor J (CategoryTheory.Discrete α)) (j : J),
Nonempty (F ≅ (CategoryTheory.Functor.const J).obj (F.obj j))) →
CategoryTheory.IsPreconnected J | false |
_private.Mathlib.Algebra.BigOperators.Fin.0.Fin.prod_uIcc_castSucc._simp_1_1 | Mathlib.Algebra.BigOperators.Fin | ∀ {n : ℕ} (i j : Fin n), Finset.uIcc i.castSucc j.castSucc = Finset.map Fin.castSuccEmb (Finset.uIcc i j) | false |
_private.Mathlib.Algebra.Regular.Defs.0.isAddRegular_iff.match_1_3 | Mathlib.Algebra.Regular.Defs | ∀ {R : Type u_1} [inst : Add R] {c : R} (motive : IsAddLeftRegular c ∧ IsAddRightRegular c → Prop)
(x : IsAddLeftRegular c ∧ IsAddRightRegular c),
(∀ (h1 : IsAddLeftRegular c) (h2 : IsAddRightRegular c), motive ⋯) → motive x | false |
algebraMap_cobounded_le_cobounded | Mathlib.Analysis.Normed.Module.Basic | ∀ (𝕜 : Type u_6) (𝕜' : Type u_7) [inst : NormedField 𝕜] [inst_1 : SeminormedRing 𝕜'] [inst_2 : NormedAlgebra 𝕜 𝕜']
[NormOneClass 𝕜'], Filter.Tendsto (⇑(algebraMap 𝕜 𝕜')) (Bornology.cobounded 𝕜) (Bornology.cobounded 𝕜') | true |
sup_div_inf_eq_mabs_div | Mathlib.Algebra.Order.Group.Unbundled.Abs | ∀ {α : Type u_1} [inst : Lattice α] [inst_1 : CommGroup α] [MulLeftMono α] (a b : α), (a ⊔ b) / (a ⊓ b) = |b / a|ₘ | true |
_private.Mathlib.Analysis.SumOverResidueClass.0.not_summable_of_antitone_of_neg._simp_1_1 | Mathlib.Analysis.SumOverResidueClass | ∀ {α : Type u} {β : Type v} [inst : PseudoMetricSpace α] [Nonempty β] [inst_2 : SemilatticeSup β] {u : β → α} {a : α},
Filter.Tendsto u Filter.atTop (nhds a) = ∀ ε > 0, ∃ N, ∀ n ≥ N, dist (u n) a < ε | false |
Std.HashSet.Raw.get?_diff_of_not_mem_right | Std.Data.HashSet.RawLemmas | ∀ {α : Type u} [inst : BEq α] [inst_1 : Hashable α] {m₁ m₂ : Std.HashSet.Raw α} [EquivBEq α] [LawfulHashable α],
m₁.WF → m₂.WF → ∀ {k : α}, k ∉ m₂ → (m₁ \ m₂).get? k = m₁.get? k | true |
Nat.zeckendorf.match_1 | Mathlib.Data.Nat.Fib.Zeckendorf | (motive : ℕ → Sort u_1) →
(x : ℕ) → (Unit → motive 0) → ((m n : ℕ) → (h : m = n + 1) → motive (namedPattern m n.succ h)) → motive x | false |
SeminormedCommRing.induced | Mathlib.Analysis.Normed.Ring.Basic | {F : Type u_5} →
(R : Type u_6) →
(S : Type u_7) →
[inst : FunLike F R S] →
[inst_1 : CommRing R] → [inst_2 : SeminormedRing S] → [NonUnitalRingHomClass F R S] → F → SeminormedCommRing R | true |
AddMonoidHom.liftOfRightInverse_comp | Mathlib.Algebra.Group.Subgroup.Basic | ∀ {G₁ : Type u_5} {G₂ : Type u_6} {G₃ : Type u_7} [inst : AddGroup G₁] [inst_1 : AddGroup G₂] [inst_2 : AddGroup G₃]
(f : G₁ →+ G₂) (f_neg : G₂ → G₁) (hf : Function.RightInverse f_neg ⇑f) (g : { g // f.ker ≤ g.ker }),
((f.liftOfRightInverse f_neg hf) g).comp f = ↑g | true |
CategoryTheory.Limits.CatCospanTransform.mk | Mathlib.CategoryTheory.Limits.Shapes.Pullback.Categorical.CatCospanTransform | {A : Type u₁} →
{B : Type u₂} →
{C : Type u₃} →
[inst : CategoryTheory.Category.{v₁, u₁} A] →
[inst_1 : CategoryTheory.Category.{v₂, u₂} B] →
[inst_2 : CategoryTheory.Category.{v₃, u₃} C] →
{F : CategoryTheory.Functor A B} →
{G : CategoryTheory.Functor C B} →
... | true |
Setoid.sInf_iff | Mathlib.Data.Setoid.Basic | ∀ {α : Type u_1} {S : Set (Setoid α)} {x y : α}, (sInf S) x y ↔ ∀ s ∈ S, s x y | true |
Lean.Meta.mkAuxTheorem | Lean.Meta.Closure | Lean.Expr →
Lean.Expr → optParam Bool false → optParam (Option Lean.Name) none → optParam Bool true → Lean.MetaM Lean.Expr | true |
_private.Init.Data.Order.Ord.0.Std.instLawfulBEqOrd._simp_1 | Init.Data.Order.Ord | ∀ {o : Ordering}, (o.isEq = true) = (o = Ordering.eq) | false |
IsApproximateSubgroup.mk | Mathlib.Combinatorics.Additive.ApproximateSubgroup | ∀ {G : Type u_1} [inst : Group G] {K : ℝ} {A : Set G},
1 ∈ A → A⁻¹ = A → CovBySMul G K (A ^ 2) A → IsApproximateSubgroup K A | true |
UniformContinuous.add_const | Mathlib.Topology.Algebra.IsUniformGroup.Defs | ∀ {α : Type u_1} {β : Type u_2} [inst : UniformSpace α] [inst_1 : AddGroup α] [IsUniformAddGroup α]
[inst_3 : UniformSpace β] {f : β → α}, UniformContinuous f → ∀ (a : α), UniformContinuous fun x => f x + a | true |
mul_left_cancel | Mathlib.Algebra.Group.Defs | ∀ {G : Type u_1} [inst : Mul G] [IsLeftCancelMul G] {a b c : G}, a * b = a * c → b = c | true |
Polynomial.eval.eq_1 | Mathlib.Algebra.Polynomial.Eval.Defs | ∀ {R : Type u} [inst : Semiring R] (x : R) (p : Polynomial R), Polynomial.eval x p = Polynomial.eval₂ (RingHom.id R) x p | true |
_private.Mathlib.Algebra.Order.BigOperators.Ring.List.0.CanonicallyOrderedAdd.list_prod_pos.match_1_1 | Mathlib.Algebra.Order.BigOperators.Ring.List | ∀ {α : Type u_1} (motive : List α → Prop) (x : List α),
(∀ (a : Unit), motive []) → (∀ (x : α) (xs : List α), motive (x :: xs)) → motive x | false |
_private.Lean.Elab.Tactic.Induction.0.Lean.Elab.Tactic.elabFunTarget.match_3 | Lean.Elab.Tactic.Induction | (motive : Lean.Meta.FunIndParamKind → Sort u_1) →
(kind : Lean.Meta.FunIndParamKind) →
(Unit → motive Lean.Meta.FunIndParamKind.dropped) →
(Unit → motive Lean.Meta.FunIndParamKind.param) → (Unit → motive Lean.Meta.FunIndParamKind.target) → motive kind | false |
ZeroAtInftyContinuousMap.instNonUnitalCStarAlgebra._proof_5 | Mathlib.Analysis.CStarAlgebra.ContinuousMap | ∀ {α : Type u_2} {A : Type u_1} [inst : TopologicalSpace α] [inst_1 : NonUnitalCStarAlgebra A],
SMulCommClass ℂ (ZeroAtInftyContinuousMap α A) (ZeroAtInftyContinuousMap α A) | false |
Lean.Elab.Tactic.Do.SplitInfo | Lean.Elab.Tactic.Do.VCGen.Split | Type | true |
MultilinearMap.mkPiAlgebraFin_apply_const | Mathlib.LinearAlgebra.Multilinear.Basic | ∀ {R : Type uR} {n : ℕ} [inst : CommSemiring R] {A : Type u_1} [inst_1 : Semiring A] [inst_2 : Algebra R A] (a : A),
((MultilinearMap.mkPiAlgebraFin R n A) fun x => a) = a ^ n | true |
MulLECancellable.mul_le_mul_iff_right | Mathlib.Algebra.Order.Monoid.Unbundled.Basic | ∀ {α : Type u_1} [inst : LE α] [inst_1 : Mul α] [i : Std.Commutative fun x1 x2 => x1 * x2] [MulLeftMono α] {a b c : α},
MulLECancellable a → (b * a ≤ c * a ↔ b ≤ c) | true |
preNormEDS_one | Mathlib.NumberTheory.EllipticDivisibilitySequence | ∀ {R : Type u} [inst : CommRing R] (b c d : R), preNormEDS b c d 1 = 1 | true |
_private.Mathlib.NumberTheory.ModularForms.EisensteinSeries.QExpansion.0.summable_pow_mul_cexp._simp_1_1 | Mathlib.NumberTheory.ModularForms.EisensteinSeries.QExpansion | ∀ {α : Type u_1} {E : Type u_2} [inst : Norm E] {l : Filter α} {f : α → E} {g : α → ℝ},
f =O[l] g = f =O[l] fun x => ↑(g x) | false |
FirstOrder.Language.Substructure.comap._proof_1 | Mathlib.ModelTheory.Substructures | ∀ {L : FirstOrder.Language} {M : Type u_1} {N : Type u_2} [inst : L.Structure M] [inst_1 : L.Structure N]
(φ : L.Hom M N) (S : L.Substructure N) {n : ℕ} (f : L.Functions n) (x : Fin n → M),
(∀ (i : Fin n), x i ∈ ⇑φ ⁻¹' ↑S) → FirstOrder.Language.Structure.funMap f x ∈ ⇑φ ⁻¹' ↑S | false |
Lean.Elab.Term.Quotation.HeadInfo.casesOn | Lean.Elab.Quotation | {motive : Lean.Elab.Term.Quotation.HeadInfo → Sort u} →
(t : Lean.Elab.Term.Quotation.HeadInfo) →
((check : Lean.Elab.Term.Quotation.HeadCheck) →
(onMatch : Lean.Elab.Term.Quotation.HeadCheck → Lean.Elab.Term.Quotation.MatchResult) →
(doMatch :
(List Lean.Term → Lean.Elab.TermElabM... | false |
PrimrecPred.of_eq | Mathlib.Computability.Primrec.Basic | ∀ {α : Type u_1} [inst : Primcodable α] {p q : α → Prop}, PrimrecPred p → (∀ (a : α), p a ↔ q a) → PrimrecPred q | true |
ContMDiffAt.sum_section | Mathlib.Geometry.Manifold.VectorBundle.SmoothSection | ∀ {𝕜 : 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] {F : Type u_5} [inst_6 : NormedAddCommG... | true |
Std.DTreeMap.Internal.Impl.size_containsThenInsert_eq_size | Std.Data.DTreeMap.Internal.WF.Lemmas | ∀ {α : Type u} {β : α → Type v} [Ord α] (t : Std.DTreeMap.Internal.Impl α β),
Std.DTreeMap.Internal.Impl.containsThenInsert.size t = t.size | true |
Int.tmod_eq_emod_of_nonneg | Init.Data.Int.DivMod.Lemmas | ∀ {a b : ℤ}, 0 ≤ a → a.tmod b = a % b | true |
WithCStarModule.norm_single | Mathlib.Analysis.CStarAlgebra.Module.Constructions | ∀ {A : Type u_1} [inst : NonUnitalCStarAlgebra A] [inst_1 : PartialOrder A] {ι : Type u_2} {E : ι → Type u_3}
[inst_2 : Fintype ι] [inst_3 : (i : ι) → NormedAddCommGroup (E i)] [inst_4 : (i : ι) → Module ℂ (E i)]
[inst_5 : (i : ι) → SMul A (E i)] [inst_6 : (i : ι) → CStarModule A (E i)] [StarOrderedRing A]
[inst_... | true |
SetRel.instIsIrreflSetOfProdMatch_1PropOfIrrefl | Mathlib.Data.Rel | ∀ {α : Type u_1} {R : α → α → Prop} [Std.Irrefl R], SetRel.IsIrrefl {(a, b) | R a b} | true |
IccLeftChart._proof_3 | Mathlib.Geometry.Manifold.Instances.Real | ∀ (x y : ℝ) (z : ↑(Set.Icc x y)), 0 ≤ ↑z - x | false |
Lean.Server.RequestHandler.mk.injEq | Lean.Server.Requests | ∀ (fileSource : Lean.Json → Except Lean.Server.RequestError Lean.Lsp.DocumentUri)
(handle : Lean.Json → Lean.Server.RequestM (Lean.Server.RequestTask Lean.Server.SerializedLspResponse))
(fileSource_1 : Lean.Json → Except Lean.Server.RequestError Lean.Lsp.DocumentUri)
(handle_1 : Lean.Json → Lean.Server.RequestM (... | true |
CategoryTheory.Monad.monToMonad_map_toNatTrans | Mathlib.CategoryTheory.Monad.EquivMon | ∀ (C : Type u) [inst : CategoryTheory.Category.{v, u} C] {X Y : CategoryTheory.Mon (CategoryTheory.Functor C C)}
(f : X ⟶ Y), ((CategoryTheory.Monad.monToMonad C).map f).toNatTrans = f.hom | true |
CategoryTheory.Limits.instLaxMonoidalFunctorLim._proof_13 | Mathlib.CategoryTheory.Monoidal.Limits.Basic | ∀ {J : Type u_1} [inst : CategoryTheory.SmallCategory J] {C : Type u_3} [inst_1 : CategoryTheory.Category.{u_2, u_3} C]
[inst_2 : CategoryTheory.Limits.HasLimitsOfShape J C] [inst_3 : CategoryTheory.MonoidalCategory C]
(F G H : CategoryTheory.Functor J C) (j j' : J) (f : j ⟶ j'),
CategoryTheory.CategoryStruct.com... | false |
Submodule.fst_orthogonalDecomposition_apply | Mathlib.Analysis.InnerProductSpace.ProdL2 | ∀ {𝕜 : Type u_1} {E : Type u_4} [inst : RCLike 𝕜] [inst_1 : NormedAddCommGroup E] [inst_2 : InnerProductSpace 𝕜 E]
(K : Submodule 𝕜 E) [inst_3 : K.HasOrthogonalProjection] (x : E),
(K.orthogonalDecomposition x).fst = K.orthogonalProjection x | true |
FirstOrder.Language.Term.varsToConstants.eq_2 | Mathlib.ModelTheory.Syntax | ∀ {L : FirstOrder.Language} {α : Type u'} {γ : Type u_1} (c : γ),
(FirstOrder.Language.var (Sum.inl c)).varsToConstants = FirstOrder.Language.Constants.term (Sum.inr c) | true |
Nat.floor_add_ofNat | Mathlib.Algebra.Order.Floor.Semiring | ∀ {R : Type u_1} [inst : Semiring R] [inst_1 : LinearOrder R] [inst_2 : FloorSemiring R] {a : R}
[IsStrictOrderedRing R], 0 ≤ a → ∀ (n : ℕ) [inst_4 : n.AtLeastTwo], ⌊a + OfNat.ofNat n⌋₊ = ⌊a⌋₊ + OfNat.ofNat n | true |
Std.DTreeMap.Internal.Impl.filter_eq_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 = Std.DTreeMap.Internal.Impl.filter! f t | true |
Quiver.Path.instSubsingletonBddPaths | Mathlib.Combinatorics.Quiver.Path | ∀ {V : Type u_1} [inst : Quiver V] (v w : V), Subsingleton (Quiver.Path.BoundedPaths v w 0) | true |
SemiNormedGrp.id_apply | Mathlib.Analysis.Normed.Group.SemiNormedGrp | ∀ (M : SemiNormedGrp) (r : M.carrier), (CategoryTheory.ConcreteCategory.hom (CategoryTheory.CategoryStruct.id M)) r = r | true |
List.sym2_eq_sym_two | Mathlib.Data.List.Sym | ∀ {α : Type u_1} {xs : List α}, List.map (⇑(Sym2.equivSym α)) xs.sym2 = List.sym 2 xs | true |
_private.Lean.Compiler.LCNF.PullFunDecls.0.Lean.Compiler.LCNF.PullFunDecls.attach.visit.match_1 | Lean.Compiler.LCNF.PullFunDecls | (motive : Lean.Compiler.LCNF.Code Lean.Compiler.LCNF.Purity.pure × Array Bool → Sort u_1) →
(x : Lean.Compiler.LCNF.Code Lean.Compiler.LCNF.Purity.pure × Array Bool) →
((k : Lean.Compiler.LCNF.Code Lean.Compiler.LCNF.Purity.pure) → (visited : Array Bool) → motive (k, visited)) →
motive x | false |
Group.IsFinitelyPresented.casesOn | Mathlib.GroupTheory.FinitelyPresentedGroup | {G : Type u_5} →
[inst : Group G] →
{motive : Group.IsFinitelyPresented G → Sort u} →
(t : Group.IsFinitelyPresented G) →
((out : ∃ n φ, Function.Surjective ⇑φ ∧ φ.ker.IsNormalClosureFG) → motive ⋯) → motive t | false |
Std.Internal.Parsec.pure | Std.Internal.Parsec.Basic | {α ι : Type} → α → Std.Internal.Parsec ι α | true |
Function.Injective.involutiveInv.eq_1 | Mathlib.Algebra.Group.InjSurj | ∀ {M₂ : Type u_2} {M₁ : Type u_3} [inst : Inv M₁] [inst_1 : InvolutiveInv M₂] (f : M₁ → M₂) (hf : Function.Injective f)
(inv : ∀ (x : M₁), f x⁻¹ = (f x)⁻¹), Function.Injective.involutiveInv f hf inv = { toInv := inst, inv_inv := ⋯ } | true |
_private.Mathlib.NumberTheory.ZetaValues.0.bernoulliFun_eval_half_eq_zero._simp_1_1 | Mathlib.NumberTheory.ZetaValues | ∀ {α : Type u_2} [inst : AddMonoidWithOne α], Even 2 = True | false |
CategoryTheory.Limits.IsLimit.ofConeOfConeUncurry | Mathlib.CategoryTheory.Limits.Fubini | {J : Type u_1} →
{K : Type u_2} →
[inst : CategoryTheory.Category.{v_1, u_1} J] →
[inst_1 : CategoryTheory.Category.{v_2, u_2} K] →
{C : Type u_3} →
[inst_2 : CategoryTheory.Category.{v_3, u_3} C] →
{F : CategoryTheory.Functor J (CategoryTheory.Functor K C)} →
{D ... | true |
CategoryTheory.Limits.Trident.ofι_pt | Mathlib.CategoryTheory.Limits.Shapes.WideEqualizers | ∀ {J : Type w} {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y : C} {f : J → (X ⟶ Y)} [inst_1 : Nonempty J]
{P : C} (ι : P ⟶ X)
(w : ∀ (j₁ j₂ : J), CategoryTheory.CategoryStruct.comp ι (f j₁) = CategoryTheory.CategoryStruct.comp ι (f j₂)),
(CategoryTheory.Limits.Trident.ofι ι w).pt = P | true |
MeasureTheory.SignedMeasure.HaveLebesgueDecomposition.negPart | Mathlib.MeasureTheory.VectorMeasure.Decomposition.Lebesgue | ∀ {α : Type u_1} {m : MeasurableSpace α} {s : MeasureTheory.SignedMeasure α} {μ : MeasureTheory.Measure α}
[self : s.HaveLebesgueDecomposition μ], s.toJordanDecomposition.negPart.HaveLebesgueDecomposition μ | true |
Sum.getLeft.congr_simp | Init.Data.Sum.Basic | ∀ {α : Type u_1} {β : Type u_2} (ab ab_1 : α ⊕ β) (e_ab : ab = ab_1) (a : ab.isLeft = true),
ab.getLeft a = ab_1.getLeft ⋯ | true |
_private.Mathlib.Data.List.Basic.0.List.erase_getElem._proof_1_3 | Mathlib.Data.List.Basic | ∀ {ι : Type u_1} (a : ι) (l : List ι), 0 < (a :: l).length → 0 < (a :: l).length | false |
_private.Std.Data.Iterators.Lemmas.Combinators.Monadic.DropWhile.0.Std.IterM.step_intermediateDropWhileWithPostcondition.match_3.eq_1 | Std.Data.Iterators.Lemmas.Combinators.Monadic.DropWhile | ∀ {α : Type u_1} {m : Type u_1 → Type u_2} {β : Type u_1} [inst : Std.Iterator α m β] {it : Std.IterM m β}
(motive : it.Step → Sort u_3) (it' : Std.IterM m β) (out : β) (h : it.IsPlausibleStep (Std.IterStep.yield it' out))
(h_1 :
(it' : Std.IterM m β) →
(out : β) → (h : it.IsPlausibleStep (Std.IterStep.yi... | true |
Lean.Grind.Linarith.eq_coeff_cert.eq_1 | Init.Grind.Ordered.Linarith | ∀ (p₁ p₂ : Lean.Grind.Linarith.Poly) (k : ℕ), Lean.Grind.Linarith.eq_coeff_cert p₁ p₂ k = (k != 0 && p₁ == p₂.mul ↑k) | true |
CategoryTheory.ObjectProperty.colimitsClosure.of_mem | Mathlib.CategoryTheory.ObjectProperty.ColimitsClosure | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {P : CategoryTheory.ObjectProperty C} {α : Type t}
{J : α → Type u'} [inst_1 : (a : α) → CategoryTheory.Category.{v', u'} (J a)] (X : C), P X → P.colimitsClosure J X | true |
IncidenceAlgebra.instModule._proof_6 | Mathlib.Combinatorics.Enumerative.IncidenceAlgebra | ∀ {𝕜 : Type u_1} {𝕝 : Type u_3} {α : Type u_2} [inst : Preorder α] [inst_1 : LocallyFiniteOrder α] [inst_2 : Semiring 𝕜]
[inst_3 : Semiring 𝕝] [inst_4 : Module 𝕜 𝕝] (x y : IncidenceAlgebra 𝕜 α) (z : IncidenceAlgebra 𝕝 α),
(x • y) • z = x • y • z | false |
HomologicalComplex.opInverse._proof_4 | Mathlib.Algebra.Homology.Opposite | ∀ {ι : Type u_3} (V : Type u_2) [inst : CategoryTheory.Category.{u_1, u_2} V] (c : ComplexShape ι)
[inst_1 : CategoryTheory.Limits.HasZeroMorphisms V] {X Y Z : HomologicalComplex Vᵒᵖ c.symm} (f : X ⟶ Y) (g : Y ⟶ Z),
Quiver.Hom.op { f := fun i => ((CategoryTheory.CategoryStruct.comp f g).f i).unop, comm' := ⋯ } =
... | false |
IsGroupLikeElem.mul | Mathlib.RingTheory.Bialgebra.GroupLike | ∀ {R : Type u_1} {A : Type u_2} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Bialgebra R A] {a b : A},
IsGroupLikeElem R a → IsGroupLikeElem R b → IsGroupLikeElem R (a * b) | true |
CochainComplex.degreewiseEpiWithInjectiveKernel._proof_1 | Mathlib.Algebra.Homology.Factorizations.Basic | IsRightCancelAdd ℤ | false |
Lean.Server.RpcEncodable.mk | Lean.Server.Rpc.Basic | {α : Type} →
(α → StateM Lean.Server.RpcObjectStore Lean.Json) →
(Lean.Json → ExceptT String (ReaderT Lean.Server.RpcObjectStore Id) α) → Lean.Server.RpcEncodable α | true |
CategoryTheory.IsGrothendieckAbelian.instMonoIMonomorphismsRlpMonoMapFactorizationDataRlp | Mathlib.CategoryTheory.Abelian.GrothendieckCategory.EnoughInjectives | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Abelian C]
[inst_2 : CategoryTheory.IsGrothendieckAbelian.{w, v, u} C] {X Y : C} (f : X ⟶ Y),
CategoryTheory.Mono (CategoryTheory.IsGrothendieckAbelian.monoMapFactorizationDataRlp f).i | true |
OrderIso.divRight_symm_apply | Mathlib.Algebra.Order.Group.OrderIso | ∀ {α : Type u} [inst : Group α] [inst_1 : LE α] [inst_2 : MulRightMono α] (a b : α),
(RelIso.symm (OrderIso.divRight a)) b = b * a | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.