name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
Set.mem_mulAntidiagonal | Mathlib.Data.Set.MulAntidiagonal | ∀ {α : Type u_1} [inst : Mul α] {s t : Set α} {a : α} {x : α × α},
x ∈ s.mulAntidiagonal t a ↔ x.1 ∈ s ∧ x.2 ∈ t ∧ x.1 * x.2 = a | true |
Std.Tactic.BVDecide.LRAT.Internal.Assignment.removeNegAssignment.eq_4 | Std.Tactic.BVDecide.LRAT.Internal.Assignment | Std.Tactic.BVDecide.LRAT.Internal.Assignment.unassigned.removeNegAssignment =
Std.Tactic.BVDecide.LRAT.Internal.Assignment.unassigned | true |
_private.Mathlib.Analysis.Calculus.BumpFunction.FiniteDimension.0.ExistsContDiffBumpBase.y_eq_zero_of_notMem_ball._simp_1_4 | Mathlib.Analysis.Calculus.BumpFunction.FiniteDimension | ∀ {α : Type u_2} [inst : Zero α] [inst_1 : One α] [NeZero 1], (1 = 0) = False | false |
Std.ExtTreeMap.ne_empty_of_erase_ne_empty | Std.Data.ExtTreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.ExtTreeMap α β cmp} [inst : Std.TransCmp cmp] {k : α},
t.erase k ≠ ∅ → t ≠ ∅ | true |
AddMonoid.Coprod.map._proof_4 | Mathlib.GroupTheory.Coprod.Basic | ∀ {M : Type u_3} {N : Type u_4} {M' : Type u_1} {N' : Type u_2} [inst : AddZeroClass M] [inst_1 : AddZeroClass N]
[inst_2 : AddZeroClass M'] [inst_3 : AddZeroClass N'] (f : M →+ M') (g : N →+ N') (x y : N),
(AddMonoid.Coprod.mk.comp (FreeAddMonoid.map (Sum.map ⇑f ⇑g))) (FreeAddMonoid.of (Sum.inr (x + y))) =
(Ad... | false |
or_iff_right_iff_imp._simp_1 | Init.SimpLemmas | ∀ {a b : Prop}, (a ∨ b ↔ b) = (a → b) | false |
Turing.BlankRel.refl | Mathlib.Computability.TuringMachine.Tape | ∀ {Γ : Type u_1} [inst : Inhabited Γ] (l : List Γ), Turing.BlankRel l l | true |
_private.Lean.Compiler.ModPkgExt.0.Lean.initFn._@.Lean.Compiler.ModPkgExt.1097734621._hygCtx._hyg.2 | Lean.Compiler.ModPkgExt | IO (Lean.ModuleEnvExtension (Option Lean.PkgId)) | false |
CategoryTheory.Limits.DiagramOfCocones.mk.inj | 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)} {obj : (j : J) → CategoryTheory.Limits.Cocone (F.obj j)}
{map : {... | true |
Functor.Comp.instPure | Mathlib.Control.Functor | {F : Type u → Type w} → {G : Type v → Type u} → [Applicative F] → [Applicative G] → Pure (Functor.Comp F G) | true |
Sylow.card_normalizer_modEq_card | Mathlib.GroupTheory.Sylow | ∀ {G : Type u} [inst : Group G] [Finite G] {p n : ℕ} [hp : Fact (Nat.Prime p)] {H : Subgroup G},
Nat.card ↥H = p ^ n → Nat.card ↥(Subgroup.normalizer ↑H) ≡ Nat.card G [MOD p ^ (n + 1)] | true |
Lean.Meta.Grind.AC.EqCnstr.mk.inj | Lean.Meta.Tactic.Grind.AC.Types | ∀ {lhs rhs : Lean.Grind.AC.Seq} {h : Lean.Meta.Grind.AC.EqCnstrProof} {id : ℕ} {lhs_1 rhs_1 : Lean.Grind.AC.Seq}
{h_1 : Lean.Meta.Grind.AC.EqCnstrProof} {id_1 : ℕ},
{ lhs := lhs, rhs := rhs, h := h, id := id } = { lhs := lhs_1, rhs := rhs_1, h := h_1, id := id_1 } →
lhs = lhs_1 ∧ rhs = rhs_1 ∧ h = h_1 ∧ id = id... | true |
Meromorphic.MeromorphicOn.countable_compl_analyticAt | Mathlib.Analysis.Meromorphic.Basic | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_3} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {f : 𝕜 → E} [SecondCountableTopology 𝕜] [CompleteSpace E],
Meromorphic f → {z | AnalyticAt 𝕜 f z}ᶜ.Countable | true |
AddMonCat.limitAddMonoid._proof_3 | Mathlib.Algebra.Category.MonCat.Limits | ∀ {J : Type u_3} [inst : CategoryTheory.Category.{u_1, u_3} J] (F : CategoryTheory.Functor J AddMonCat)
[inst_1 : Small.{u_2, max u_2 u_3} ↑(F.comp (CategoryTheory.forget AddMonCat)).sections]
(a : (CategoryTheory.Limits.Types.Small.limitCone (F.comp (CategoryTheory.forget AddMonCat))).pt), a + 0 = a | false |
ConvexCone.IsGenerating.top_le_span | Mathlib.Geometry.Convex.Cone.Basic | ∀ {R : Type u_2} {M : Type u_4} [inst : Semiring R] [inst_1 : PartialOrder R] [inst_2 : AddCommMonoid M]
[inst_3 : Module R M] {C : ConvexCone R M}, C.IsGenerating → ⊤ ≤ Submodule.span R ↑C | true |
_private.Mathlib.Data.List.Cycle.0.List.next_eq_getElem._proof_1_23 | Mathlib.Data.List.Cycle | ∀ {α : Type u_1} [inst : DecidableEq α] {l : List α} {a : α},
a ∈ l → ∀ (hl : l ≠ []), a ∉ l.dropLast → l.length - (l.dropLast.length + 1) < [l.getLast ⋯].length | false |
_private.Lean.Meta.Match.AltTelescopes.0.Lean.Meta.Match.forallAltVarsTelescope.isNamedPatternProof | Lean.Meta.Match.AltTelescopes | Lean.Expr → Lean.Expr → Bool | true |
Lean.ReducibilityHints.ctorElim | Lean.Declaration | {motive : Lean.ReducibilityHints → Sort u} →
(ctorIdx : ℕ) →
(t : Lean.ReducibilityHints) → ctorIdx = t.ctorIdx → Lean.ReducibilityHints.ctorElimType ctorIdx → motive t | false |
CategoryTheory.Grothendieck.map_obj_fiber | Mathlib.CategoryTheory.Grothendieck | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {F G : CategoryTheory.Functor C CategoryTheory.Cat} (α : F ⟶ G)
(X : CategoryTheory.Grothendieck F),
((CategoryTheory.Grothendieck.map α).obj X).fiber = (α.app X.base).toFunctor.obj X.fiber | true |
_private.Mathlib.Topology.UniformSpace.UniformConvergenceTopology.0.UniformOnFun.«term𝒰(_,_,_)» | Mathlib.Topology.UniformSpace.UniformConvergenceTopology | Lean.ParserDescr | true |
AddCon.addCommMagma | Mathlib.GroupTheory.Congruence.Defs | {M : Type u_4} → [inst : AddCommMagma M] → (c : AddCon M) → AddCommMagma c.Quotient | true |
instSTWorldEST | Init.System.ST | {ε σ : Type} → STWorld σ (EST ε σ) | true |
CategoryTheory.Abelian.SpectralObject.iCycles_δ | Mathlib.Algebra.Homology.SpectralObject.Cycles | ∀ {C : Type u_1} {ι : Type u_2} [inst : CategoryTheory.Category.{v_1, u_1} C]
[inst_1 : CategoryTheory.Category.{v_2, u_2} ι] [inst_2 : CategoryTheory.Abelian C]
(X : CategoryTheory.Abelian.SpectralObject C ι) {i j k : ι} (f : i ⟶ j) (g : j ⟶ k) (n₀ n₁ : ℤ)
(hn₁ : autoParam (n₀ + 1 = n₁) CategoryTheory.Abelian.Sp... | true |
Aesop.getGoalsToCopy | Aesop.Tree.AddRapp | Aesop.UnorderedArraySet Lean.MVarId → Aesop.GoalRef → Aesop.TreeM (Array Aesop.GoalRef) | true |
TensorProduct.sum_tmul_basis_left_eq_zero | Mathlib.LinearAlgebra.TensorProduct.Basis | ∀ {R : Type u_1} {M : Type u_3} {N : Type u_4} {ι : Type u_5} [inst : CommSemiring R] [inst_1 : AddCommMonoid M]
[inst_2 : Module R M] [inst_3 : AddCommMonoid N] [inst_4 : Module R N] (ℬ : Module.Basis ι R M) (b : ι →₀ N),
(b.sum fun i n => ℬ i ⊗ₜ[R] n) = 0 → b = 0 | true |
AdicCompletion.instNeg._proof_1 | Mathlib.RingTheory.AdicCompletion.Basic | ∀ {R : Type u_2} [inst : CommRing R] (I : Ideal R) (M : Type u_1) [inst_1 : AddCommGroup M] [inst_2 : Module R M]
(x : AdicCompletion I M) {m n : ℕ} (hmn : m ≤ n), (AdicCompletion.transitionMap I M hmn) ((-↑x) n) = (-↑x) m | false |
ISize.ofIntLE_bitVecToInt | Init.Data.SInt.Lemmas | ∀ (n : BitVec System.Platform.numBits), ISize.ofIntLE n.toInt ⋯ ⋯ = ISize.ofBitVec n | true |
Lean.Meta.getAllSimpDecls._sparseCasesOn_2 | Mathlib.Lean.Meta.Simp | {motive : Bool → Sort u} → (t : Bool) → motive true → (Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t | false |
SheafOfModules.QuasicoherentData.noConfusionType | Mathlib.Algebra.Category.ModuleCat.Sheaf.Quasicoherent | Sort u_1 →
{C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{J : CategoryTheory.GrothendieckTopology C} →
{R : CategoryTheory.Sheaf J RingCat} →
[inst_1 : ∀ (X : C), (J.over X).HasSheafCompose (CategoryTheory.forget₂ RingCat AddCommGrpCat)] →
[inst_2 : ∀ (X : C), C... | false |
CategoryTheory.ProjectivePresentation.mk.sizeOf_spec | Mathlib.CategoryTheory.Preadditive.Projective.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X : C} [inst_1 : SizeOf C] (p : C)
[projective : CategoryTheory.Projective p] (f : p ⟶ X) [epi : CategoryTheory.Epi f],
sizeOf { p := p, projective := projective, f := f, epi := epi } =
1 + sizeOf p + sizeOf projective + sizeOf f + sizeOf epi | true |
SimplexCategory.len_le_of_epi | Mathlib.AlgebraicTopology.SimplexCategory.Basic | ∀ {x y : SimplexCategory} (f : x ⟶ y) [CategoryTheory.Epi f], y.len ≤ x.len | true |
AlgebraicGeometry.quasiSeparatedSpace_of_isAffine | Mathlib.AlgebraicGeometry.Morphisms.QuasiSeparated | ∀ (X : AlgebraicGeometry.Scheme) [AlgebraicGeometry.IsAffine X], QuasiSeparatedSpace ↥X | true |
CochainComplex.HomComplex.Cocycle.toSingleMk_add._proof_1 | Mathlib.Algebra.Homology.HomotopyCategory.HomComplexSingle | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Preadditive C] {X : C}
{K : CochainComplex C ℤ} {p : ℤ} (f g : K.X p ⟶ X) (p' : ℤ),
CategoryTheory.CategoryStruct.comp (K.d p' p) f = 0 →
CategoryTheory.CategoryStruct.comp (K.d p' p) g = 0 → CategoryTheory.CategoryStruct.co... | false |
Multiset.right_mem_Ioc | Mathlib.Order.Interval.Multiset | ∀ {α : Type u_1} [inst : Preorder α] [inst_1 : LocallyFiniteOrder α] {a b : α}, b ∈ Multiset.Ioc a b ↔ a < b | true |
Units.val_mk | Mathlib.Algebra.Group.Units.Defs | ∀ {α : Type u} [inst : Monoid α] (a b : α) (h₁ : a * b = 1) (h₂ : b * a = 1),
↑{ val := a, inv := b, val_inv := h₁, inv_val := h₂ } = a | true |
Lean.Meta.LazyDiscrTree.PartialMatch.noConfusion | Lean.Meta.LazyDiscrTree | {P : Sort u} →
{t t' : Lean.Meta.LazyDiscrTree.PartialMatch} → t = t' → Lean.Meta.LazyDiscrTree.PartialMatch.noConfusionType P t t' | false |
ContinuousMap.HomotopyEquiv.mk.sizeOf_spec | Mathlib.Topology.Homotopy.Equiv | ∀ {X : Type u} {Y : Type v} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] [inst_2 : SizeOf X]
[inst_3 : SizeOf Y] (toFun : C(X, Y)) (invFun : C(Y, X))
(left_inv : (invFun.comp toFun).Homotopic (ContinuousMap.id X))
(right_inv : (toFun.comp invFun).Homotopic (ContinuousMap.id Y)),
sizeOf { toFun := t... | true |
LinearMap.ofIsCompl_eq | Mathlib.LinearAlgebra.Projection | ∀ {R : Type u_1} [inst : Ring R] {E : Type u_2} [inst_1 : AddCommGroup E] [inst_2 : Module R E] {F : Type u_3}
[inst_3 : AddCommGroup F] [inst_4 : Module R F] {p q : Submodule R E} (h : IsCompl p q) {φ : ↥p →ₗ[R] F}
{ψ : ↥q →ₗ[R] F} {χ : E →ₗ[R] F}, (∀ (u : ↥p), φ u = χ ↑u) → (∀ (u : ↥q), ψ u = χ ↑u) → LinearMap.of... | true |
_private.Mathlib.Topology.Separation.Profinite.0.exists_clopen_partition_of_clopen_cover._proof_1_7 | Mathlib.Topology.Separation.Profinite | ∀ {X : Type u_1} [inst : TopologicalSpace X] {I : Type u_2} {D : Option I → Set X} (C' : I → Set X),
IsClopen (D none \ ⋃ i, C' i) → IsClopen ((fun i => Option.casesOn i (D none \ ⋃ i, C' i) C') none) | false |
CategoryTheory.Idempotents.KaroubiHomologicalComplexEquivalence.unitIso._proof_7 | Mathlib.CategoryTheory.Idempotents.HomologicalComplex | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_3, u_1} C] [inst_1 : CategoryTheory.Preadditive C] {ι : Type u_2}
{c : ComplexShape ι},
CategoryTheory.CategoryStruct.comp
{ app := fun P => { f := { f := fun n => P.p.f n, comm' := ⋯ }, comm := ⋯ }, naturality := ⋯ }
{ app := fun P => { f := { f := fu... | false |
Lean.JsonRpc.Message._sizeOf_1 | Lean.Data.JsonRpc | Lean.JsonRpc.Message → ℕ | false |
Cardinal.instMul | Mathlib.SetTheory.Cardinal.Defs | Mul Cardinal.{u} | true |
Derivative.serreDerivative_smul | Mathlib.NumberTheory.ModularForms.Derivative | ∀ (k c : ℂ) (F : UpperHalfPlane → ℂ),
MDiff F → Derivative.serreDerivative k (c • F) = c • Derivative.serreDerivative k F | true |
RelHom.toOrderHom | Mathlib.Order.Hom.Basic | {α : Type u_2} →
{β : Type u_3} →
[inst : PartialOrder α] → [inst_1 : Preorder β] → ((fun x1 x2 => x1 < x2) →r fun x1 x2 => x1 < x2) → α →o β | true |
CategoryTheory.OplaxFunctor.mapComp'_comp_mapComp'_whiskerRight_assoc | Mathlib.CategoryTheory.Bicategory.Strict.Pseudofunctor | ∀ {B : Type u₁} {C : Type u₂} [inst : CategoryTheory.Bicategory B] [inst_1 : CategoryTheory.Bicategory.Strict B]
[inst_2 : CategoryTheory.Bicategory C] (F : CategoryTheory.OplaxFunctor B C) {b₀ b₁ b₂ b₃ : B} (f₀₁ : b₀ ⟶ b₁)
(f₁₂ : b₁ ⟶ b₂) (f₂₃ : b₂ ⟶ b₃) (f₀₂ : b₀ ⟶ b₂) (f₁₃ : b₁ ⟶ b₃) (f : b₀ ⟶ b₃)
(h₀₂ : Categ... | true |
Ideal.image_subset_nonunits_valuationSubring | Mathlib.RingTheory.Valuation.LocalSubring | ∀ {K : Type u_3} [inst : Field K] {A : Subring K} (I : Ideal ↥A),
I ≠ ⊤ → ∃ B, A ≤ B.toSubring ∧ ⇑A.subtype '' ↑I ⊆ ↑B.nonunits | true |
Subgroup.strictPeriods_le_periods | Mathlib.NumberTheory.ModularForms.Cusps | ∀ {R : Type u_1} [inst : Ring R] (𝒢 : Subgroup (GL (Fin 2) R)), 𝒢.strictPeriods ≤ 𝒢.periods | true |
_private.Lean.Elab.PreDefinition.Structural.Main.0.Lean.Elab.Structural.structuralRecursion.match_3 | Lean.Elab.PreDefinition.Structural.Main | (motive : Option (ℕ × Subarray ℕ) → Sort u_1) →
(x : Option (ℕ × Subarray ℕ)) →
(Unit → motive none) → ((recArgPos : ℕ) → (s' : Subarray ℕ) → motive (some (recArgPos, s'))) → motive x | false |
Polynomial.trailingDegree_lt_wf | Mathlib.Algebra.Polynomial.Degree.TrailingDegree | ∀ {R : Type u} [inst : Semiring R], WellFounded fun p q => p.trailingDegree < q.trailingDegree | true |
MeasureTheory.OuterMeasure.isCaratheodory_iUnion_of_disjoint | Mathlib.MeasureTheory.OuterMeasure.Caratheodory | ∀ {α : Type u} (m : MeasureTheory.OuterMeasure α) {s : ℕ → Set α},
(∀ (i : ℕ), m.IsCaratheodory (s i)) → Pairwise (Function.onFun Disjoint s) → m.IsCaratheodory (⋃ i, s i) | true |
QuadraticMap.ofPolar._proof_3 | Mathlib.LinearAlgebra.QuadraticForm.Basic | ∀ {R : Type u_1} {N : Type u_2} [inst : CommRing R] [inst_1 : AddCommGroup N] [inst_2 : Module R N], SMulCommClass R R N | false |
RootPairing.chainBotIdx.eq_1 | Mathlib.LinearAlgebra.RootSystem.Chain | ∀ {ι : Type u_1} {R : Type u_2} {M : Type u_3} {N : Type u_4} [inst : Finite ι] [inst_1 : CommRing R]
[inst_2 : CharZero R] [inst_3 : IsDomain R] [inst_4 : AddCommGroup M] [inst_5 : Module R M] [inst_6 : AddCommGroup N]
[inst_7 : Module R N] {P : RootPairing ι R M N} [inst_8 : P.IsCrystallographic] (i j : ι),
Roo... | true |
CategoryTheory.ShortComplex.RightHomologyData.opcyclesIso_inv_comp_descOpcycles_assoc | Mathlib.Algebra.Homology.ShortComplex.RightHomology | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{S : CategoryTheory.ShortComplex C} (h : S.RightHomologyData) {A : C} (k : S.X₂ ⟶ A)
(hk : CategoryTheory.CategoryStruct.comp S.f k = 0) [inst_2 : S.HasRightHomology] {Z : C} (h_1 : A ⟶ Z),
CategoryT... | true |
_private.Mathlib.Topology.LocalAtTarget.0.TopologicalSpace.IsOpenCover.isOpenMap_iff_restrictPreimage._simp_1_1 | Mathlib.Topology.LocalAtTarget | ∀ {α : Sort u_1} {p : α → Prop} {a b : Subtype p}, (a = b) = (↑a = ↑b) | false |
Rat.num_le_denom_iff | Mathlib.Algebra.Order.Ring.Unbundled.Rat | ∀ {q : ℚ}, q.num ≤ ↑q.den ↔ q ≤ 1 | true |
Function.Periodic.contDiff_qParam | Mathlib.Analysis.Complex.Periodic | ∀ {h : ℝ} (m : WithTop ℕ∞), ContDiff ℂ m (Function.Periodic.qParam h) | true |
MonCat.adjoinOneAdj._proof_1 | Mathlib.Algebra.Category.MonCat.Adjunctions | ∀ {X' X : Semigrp} {Y : MonCat} (f : X' ⟶ X) (g : X ⟶ (CategoryTheory.forget₂ MonCat Semigrp).obj Y),
(CategoryTheory.ConcreteCategory.homEquiv.trans
(WithOne.lift.symm.trans CategoryTheory.ConcreteCategory.homEquiv.symm)).symm
(CategoryTheory.CategoryStruct.comp f g) =
CategoryTheory.CategoryStru... | false |
Subalgebra.coe_unop | Mathlib.Algebra.Algebra.Subalgebra.MulOpposite | ∀ {R : Type u_2} {A : Type u_3} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A]
(S : Subalgebra R Aᵐᵒᵖ), ↑S.unop = MulOpposite.op ⁻¹' ↑S | true |
ENNReal.mul_div_right_comm | Mathlib.Data.ENNReal.Inv | ∀ {a b c : ENNReal}, a * b / c = a / c * b | true |
_private.Lean.Compiler.LCNF.Simp.JpCases.0.Lean.Compiler.LCNF.Simp.collectJpCasesInfo.match_1 | Lean.Compiler.LCNF.Simp.JpCases | (motive : Unit × Lean.Compiler.LCNF.Simp.JpCasesInfoMap → Sort u_1) →
(__discr : Unit × Lean.Compiler.LCNF.Simp.JpCasesInfoMap) →
((fst : Unit) → (s : Lean.Compiler.LCNF.Simp.JpCasesInfoMap) → motive (fst, s)) → motive __discr | false |
Real.instDistribLattice._proof_4 | Mathlib.Data.Real.Basic | ∀ (a b c : ℝ), a ≤ c → b ≤ c → max a b ≤ c | false |
Std.Time.Minute.instOrdOffset | Std.Time.Time.Unit.Minute | Ord Std.Time.Minute.Offset | true |
MonovaryOn.of_neg_left | Mathlib.Algebra.Order.Monovary | ∀ {ι : Type u_1} {α : Type u_2} {β : Type u_3} [inst : AddCommGroup α] [inst_1 : Preorder α] [IsOrderedAddMonoid α]
[inst_3 : PartialOrder β] {s : Set ι} {f : ι → α} {g : ι → β}, MonovaryOn (-f) g s → AntivaryOn f g s | true |
CategoryTheory.Functor.kernel | Mathlib.CategoryTheory.ObjectProperty.ContainsZero | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{D : Type u'} →
[inst_1 : CategoryTheory.Category.{v', u'} D] → CategoryTheory.Functor C D → CategoryTheory.ObjectProperty C | true |
WithLp.uniformEquiv_unitization_addEquiv_prod._proof_2 | Mathlib.Analysis.Normed.Algebra.UnitizationL1 | ∀ (𝕜 : Type u_1) (A : Type u_2) [inst : NormedField 𝕜] [inst_1 : NonUnitalNormedRing A] [inst_2 : NormedSpace 𝕜 A],
UniformContinuous (WithLp.unitization_addEquiv_prod 𝕜 A).invFun | false |
Substring.Raw.Internal.get | Init.Data.String.Bootstrap | Substring.Raw → String.Pos.Raw → Char | true |
_private.Init.Data.Int.DivMod.Lemmas.0.Int.natAbs_fdiv_le_natAbs._proof_1_4 | Init.Data.Int.DivMod.Lemmas | ∀ (b : ℤ) (a b : ℕ), ¬0 < a + 1 → False | false |
signedDist._proof_3 | Mathlib.Geometry.Euclidean.SignedDist | SMulCommClass ℝ ℝ ℝ | false |
Dynamics.coverEntropyInf_image_of_comap | Mathlib.Dynamics.TopologicalEntropy.Semiconj | ∀ {X : Type u_1} {Y : Type u_2} (u : UniformSpace Y) {S : X → X} {T : Y → Y} {φ : X → Y},
Function.Semiconj φ S T → ∀ (F : Set X), Dynamics.coverEntropyInf T (φ '' F) = Dynamics.coverEntropyInf S F | true |
Lists'.rec.eq._@.Mathlib.SetTheory.Lists.1973585389._hygCtx._hyg.4 | Mathlib.SetTheory.Lists | @Lists'.rec = @Lists'.rec✝ | false |
instOrOpInt8 | Init.Data.SInt.Basic | OrOp Int8 | true |
_private.Init.Data.UInt.Bitwise.0.UInt32.xor_not._simp_1_1 | Init.Data.UInt.Bitwise | ∀ {a b : UInt32}, (a = b) = (a.toBitVec = b.toBitVec) | false |
Lean.Parser.Term.dbgTrace._regBuiltin.Lean.Parser.Term.dbgTrace_1 | Lean.Parser.Term | IO Unit | false |
Lean.Level.mvar.inj | Lean.Level | ∀ {a a_1 : Lean.LMVarId}, Lean.Level.mvar a = Lean.Level.mvar a_1 → a = a_1 | true |
CategoryTheory.yonedaMonFullyFaithful._proof_1 | Mathlib.CategoryTheory.Monoidal.Cartesian.Mon_ | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.CartesianMonoidalCategory C]
{M N : CategoryTheory.Mon C} (α : CategoryTheory.yonedaMon.obj M ⟶ CategoryTheory.yonedaMon.obj N),
CategoryTheory.CategoryStruct.comp CategoryTheory.MonObj.one
((CategoryTheory.ConcreteCategor... | false |
TwoSidedIdeal.subtype_injective | Mathlib.RingTheory.TwoSidedIdeal.Operations | ∀ {R : Type u_1} [inst : Ring R] (I : TwoSidedIdeal R), Function.Injective ⇑I.subtype | true |
_private.Init.Data.Vector.Algebra.0.Vector.zero_hmul._proof_1_2 | Init.Data.Vector.Algebra | ∀ {α : Type u_2} {β : Type u_3} {γ : Type u_1} {n : ℕ} [inst : Zero α] [inst_1 : Zero γ] [inst_2 : HMul α β γ],
(∀ (c : β), 0 * c = 0) → ∀ (c : Vector β n), 0 * c = 0 | false |
SimpleGraph.Subgraph.instMin._proof_2 | Mathlib.Combinatorics.SimpleGraph.Subgraph | ∀ {V : Type u_1} {G : SimpleGraph V} (G₁ G₂ : G.Subgraph) {v w : V},
G₁.Adj v w ∧ G₂.Adj v w → v ∈ G₁.verts ∧ v ∈ G₂.verts | false |
LinearOrderedCommGroupWithZero.zpow_succ' | Mathlib.Algebra.Order.GroupWithZero.Canonical | ∀ {α : Type u_3} [self : LinearOrderedCommGroupWithZero α] (n : ℕ) (a : α),
LinearOrderedCommGroupWithZero.zpow (↑n.succ) a = LinearOrderedCommGroupWithZero.zpow (↑n) a * a | true |
_private.Mathlib.AlgebraicTopology.FundamentalGroupoid.Basic.0.Path.Homotopic.Quotient.symm_trans._simp_1_4 | Mathlib.AlgebraicTopology.FundamentalGroupoid.Basic | ∀ {X : Type u} [inst : TopologicalSpace X] {x₀ x₁ : X} {p q : Path x₀ x₁},
(Path.Homotopic.Quotient.mk p = Path.Homotopic.Quotient.mk q) = p.Homotopic q | false |
instRankConditionMulOpposite | Mathlib.LinearAlgebra.Matrix.InvariantBasisNumber | ∀ {R : Type u_1} [inst : Semiring R] [RankCondition R], RankCondition Rᵐᵒᵖ | true |
CategoryTheory.ShortComplex.Exact.isZero_of_both_zeros | Mathlib.Algebra.Homology.ShortComplex.Exact | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{S : CategoryTheory.ShortComplex C}, S.Exact → S.f = 0 → S.g = 0 → CategoryTheory.Limits.IsZero S.X₂ | true |
AddMonoidHom.compLeftContinuousBounded._proof_2 | Mathlib.Topology.ContinuousMap.Bounded.Basic | ∀ {β : Type u_2} {γ : Type u_3} (α : Type u_1) [inst : TopologicalSpace α] [inst_1 : PseudoMetricSpace β]
[inst_2 : AddMonoid β] [inst_3 : BoundedAdd β] [inst_4 : ContinuousAdd β] [inst_5 : PseudoMetricSpace γ]
[inst_6 : AddMonoid γ] [inst_7 : BoundedAdd γ] [inst_8 : ContinuousAdd γ] (g : β →+ γ) {C : NNReal}
(hg... | false |
Std.ExtTreeMap.maxKey?_le | Std.Data.ExtTreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.ExtTreeMap α β cmp} [inst : Std.TransCmp cmp] {k : α},
(∀ (k' : α), t.maxKey? = some k' → (cmp k' k).isLE = true) ↔ ∀ k' ∈ t, (cmp k' k).isLE = true | true |
CategoryTheory.ComposableArrows.Exact.exact'._auto_3 | Mathlib.Algebra.Homology.ExactSequence | Lean.Syntax | false |
_private.Lean.Expr.0.Lean.instReprExpr.repr.match_1 | Lean.Expr | (motive : Lean.Expr → Sort u_1) →
(x : Lean.Expr) →
((a : ℕ) → motive (Lean.Expr.bvar a)) →
((a : Lean.FVarId) → motive (Lean.Expr.fvar a)) →
((a : Lean.MVarId) → motive (Lean.Expr.mvar a)) →
((a : Lean.Level) → motive (Lean.Expr.sort a)) →
((a : Lean.Name) → (a_1 : List Lean.L... | false |
normFromBounded._proof_1 | Mathlib.Analysis.Normed.Unbundled.SeminormFromBounded | ∀ {R : Type u_1} [inst : CommRing R] {f : R → ℝ} {c : ℝ} (f_zero : f 0 = 0) (f_nonneg : 0 ≤ f)
(f_mul : ∀ (x y : R), f (x * y) ≤ c * f x * f y) (f_add : ∀ (a b : R), f (a + b) ≤ f a + f b)
(f_neg : ∀ (x : R), f (-x) = f x),
f ⁻¹' {0} = {0} → ∀ (x : R), (seminormFromBounded f_zero f_nonneg f_mul f_add f_neg).toFun... | false |
MulOpposite.coe_opLinearEquiv_addEquiv | Mathlib.Algebra.Module.Equiv.Opposite | ∀ (R : Type u) {M : Type v} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M],
↑(MulOpposite.opLinearEquiv R) = MulOpposite.opAddEquiv | true |
ValuativeRel.zero_vlt_coe_posSubmonoid | Mathlib.RingTheory.Valuation.ValuativeRel.Basic | ∀ {R : Type u_1} [inst : CommRing R] [inst_1 : ValuativeRel R] (x : ↥(ValuativeRel.posSubmonoid R)), 0 <ᵥ ↑x | true |
Int8.toInt_ofIntLE | Init.Data.SInt.Lemmas | ∀ {x : ℤ} {h₁ : Int8.minValue.toInt ≤ x} {h₂ : x ≤ Int8.maxValue.toInt}, (Int8.ofIntLE x h₁ h₂).toInt = x | true |
contDiffWithinAt_succ_iff_hasFDerivWithinAt | Mathlib.Analysis.Calculus.ContDiff.Defs | ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {E : Type uE} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {F : Type uF} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {s : Set E}
{f : E → F} {x : E} {n : WithTop ℕ∞},
n ≠ ↑⊤ →
(ContDiffWithinAt 𝕜 (n + 1) f s x ↔
∃ u ∈ nh... | true |
PerfectRing.lift_self | Mathlib.FieldTheory.IsPerfectClosure | ∀ {K : Type u_1} {L : Type u_2} [inst : CommRing K] [inst_1 : CommRing L] (i : K →+* L) (p : ℕ) [inst_2 : ExpChar K p]
[inst_3 : IsPRadical i p] [inst_4 : ExpChar L p] [inst_5 : PerfectRing L p], PerfectRing.lift i i p = RingHom.id L | true |
interior_Iic' | Mathlib.Topology.Order.DenselyOrdered | ∀ {α : Type u_1} [inst : TopologicalSpace α] [inst_1 : LinearOrder α] [OrderTopology α] [DenselyOrdered α] {a : α},
(Set.Ioi a).Nonempty → interior (Set.Iic a) = Set.Iio a | true |
_private.Mathlib.LinearAlgebra.CliffordAlgebra.Even.0.CliffordAlgebra.even.lift.fFold | Mathlib.LinearAlgebra.CliffordAlgebra.Even | {R : Type u_1} →
{M : Type u_2} →
[inst : CommRing R] →
[inst_1 : AddCommGroup M] →
[inst_2 : Module R M] →
{Q : QuadraticForm R M} →
{A : Type u_3} →
[inst_3 : Ring A] →
[inst_4 : Algebra R A] →
(f : CliffordAlgebra.EvenHom Q A) ... | true |
Aesop.CtorNames.mk.noConfusion | Aesop.Script.CtorNames | {P : Sort u} →
{ctor : Lean.Name} →
{args : Array Lean.Name} →
{hasImplicitArg : Bool} →
{ctor' : Lean.Name} →
{args' : Array Lean.Name} →
{hasImplicitArg' : Bool} →
{ ctor := ctor, args := args, hasImplicitArg := hasImplicitArg } =
{ ctor := cto... | false |
ContinuousMap.Homotopic.prodMap | Mathlib.Topology.Homotopy.Basic | ∀ {X : Type u} {Y : Type v} {Z : Type w} {Z' : Type x} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y]
[inst_2 : TopologicalSpace Z] [inst_3 : TopologicalSpace Z'] {f₀ f₁ : C(X, Y)} {g₀ g₁ : C(Z, Z')},
f₀.Homotopic f₁ → g₀.Homotopic g₁ → (f₀.prodMap g₀).Homotopic (f₁.prodMap g₁) | true |
Std.DHashMap.Internal.Raw₀.Const.getKey?_insertManyIfNewUnit_list_of_contains_eq_false_of_mem | Std.Data.DHashMap.Internal.RawLemmas | ∀ {α : Type u} [inst : BEq α] [inst_1 : Hashable α] (m : Std.DHashMap.Internal.Raw₀ α fun x => Unit) [EquivBEq α]
[LawfulHashable α],
(↑m).WF →
∀ {l : List α} {k k' : α},
(k == k') = true →
m.contains k = false →
List.Pairwise (fun a b => (a == b) = false) l →
k ∈ l → (↑(Std.... | true |
selfAdjoint.instCommRingSubtypeMemAddSubgroup._proof_7 | Mathlib.Algebra.Star.SelfAdjoint | ∀ {R : Type u_1} [inst : CommRing R] [inst_1 : StarRing R] (x y : ↥(selfAdjoint R)), ↑(x * y) = ↑x * ↑y | false |
Equiv.addMonoidWithOne._proof_1 | Mathlib.Algebra.Ring.TransferInstance | ∀ {α : Type u_2} {β : Type u_1} (e : α ≃ β) [inst : AddMonoidWithOne β], e (e.symm ↑0) = e 0 | false |
Array.toListRev_iter | Std.Data.Iterators.Lemmas.Producers.Array | ∀ {β : Type w} {array : Array β}, array.iter.toListRev = array.toListRev | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.