name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
Fintype.prod_extend_by_one | Mathlib.Data.Fintype.BigOperators | ∀ {α : Type u_1} {ι : Type u_4} [inst : DecidableEq ι] [inst_1 : Fintype ι] [inst_2 : CommMonoid α] (s : Finset ι)
(f : ι → α), (∏ i, if i ∈ s then f i else 1) = ∏ i ∈ s, f i | true |
Lean.Doc.PostponedKind.mk.noConfusion | Lean.Elab.DocString.Builtin.Postponed | {P : Sort u} → {name name' : Lean.Name} → { name := name } = { name := name' } → (name = name' → P) → P | false |
Lean.Elab.InfoTree.ctorIdx | Lean.Elab.InfoTree.Types | Lean.Elab.InfoTree → ℕ | false |
Complex.dist_eq | Mathlib.Analysis.Complex.Norm | ∀ (z w : ℂ), dist z w = ‖z - w‖ | true |
Polynomial.self_mul_modByMonic | Mathlib.Algebra.Polynomial.Div | ∀ {R : Type u} [inst : Ring R] {p q : Polynomial R}, q.Monic → q * p %ₘ q = 0 | true |
WithTop.eq_top_of_pow | Mathlib.Algebra.Order.Ring.WithTop | ∀ {α : Type u_1} [inst : DecidableEq α] [inst_1 : MonoidWithZero α] [inst_2 : NoZeroDivisors α] [inst_3 : Nontrivial α]
{x : WithTop α} (n : ℕ), x ^ n = ⊤ → x = ⊤ | true |
UniformSpace.toTopologicalSpace_iInf | Mathlib.Topology.UniformSpace.Basic | ∀ {α : Type ua} {ι : Sort u_2} {u : ι → UniformSpace α}, (iInf u).toTopologicalSpace = ⨅ i, (u i).toTopologicalSpace | true |
Ideal.prime_of_isPrime | Mathlib.RingTheory.DedekindDomain.Ideal.Lemmas | ∀ {A : Type u_2} [inst : CommRing A] [IsDedekindDomain A] {P : Ideal A}, P ≠ ⊥ → P.IsPrime → Prime P | true |
Lean.Meta.Instances.noConfusion | Lean.Meta.Instances | {P : Sort u} → {t t' : Lean.Meta.Instances} → t = t' → Lean.Meta.Instances.noConfusionType P t t' | false |
_private.Lean.Elab.Tactic.Conv.Pattern.0.Lean.Elab.Tactic.Conv.PatternMatchState.skip._sparseCasesOn_1 | Lean.Elab.Tactic.Conv.Pattern | {motive : Lean.Elab.Tactic.Conv.PatternMatchState → Sort u} →
(t : Lean.Elab.Tactic.Conv.PatternMatchState) →
((subgoals : Array (ℕ × Lean.MVarId)) →
(idx : ℕ) →
(remaining : List (ℕ × ℕ)) → motive (Lean.Elab.Tactic.Conv.PatternMatchState.occs subgoals idx remaining)) →
(Nat.hasNotBit 2 t.... | false |
_private.Mathlib.Condensed.Discrete.LocallyConstant.0.CompHausLike.LocallyConstant.componentHom._simp_3 | Mathlib.Condensed.Discrete.LocallyConstant | ∀ {α : Type u_1} {a b : α}, (a ∈ {b}) = (a = b) | false |
AddSubgroup.dense_xor'_cyclic | Mathlib.Topology.Algebra.Order.Archimedean | ∀ {G : Type u_1} [inst : AddCommGroup G] [inst_1 : LinearOrder G] [IsOrderedAddMonoid G] [inst_3 : TopologicalSpace G]
[OrderTopology G] [Archimedean G] [Nontrivial G] [DenselyOrdered G] (s : AddSubgroup G),
Xor' (Dense ↑s) (∃ a, s = AddSubgroup.zmultiples a) | true |
DenomsClearable | Mathlib.Algebra.Polynomial.DenomsClearable | {R : Type u_1} →
{K : Type u_2} → [inst : Semiring R] → [inst_1 : CommSemiring K] → R → R → ℕ → Polynomial R → (R →+* K) → Prop | true |
frobeniusEquiv.congr_simp | Mathlib.FieldTheory.Perfect | ∀ (R : Type u_1) (p p_1 : ℕ) (e_p : p = p_1) [inst : CommSemiring R] [inst_1 : ExpChar R p] [inst_2 : PerfectRing R p],
frobeniusEquiv R p = frobeniusEquiv R p_1 | true |
CategoryTheory.Functor.PreservesEffectiveEpiFamilies.mk | Mathlib.CategoryTheory.EffectiveEpi.Preserves | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {D : Type u_2}
[inst_1 : CategoryTheory.Category.{v_2, u_2} D] {F : CategoryTheory.Functor C D},
(∀ {α : Type u} {B : C} (X : α → C) (π : (a : α) → X a ⟶ B) [CategoryTheory.EffectiveEpiFamily X π],
CategoryTheory.EffectiveEpiFamily (fun a => F.obj... | true |
Finset.centerMass_id_mem_convexHull | Mathlib.Analysis.Convex.Combination | ∀ {R : Type u_1} {E : Type u_3} [inst : Field R] [inst_1 : AddCommGroup E] [inst_2 : Module R E]
[inst_3 : LinearOrder R] [IsStrictOrderedRing R] (t : Finset E) {w : E → R},
(∀ i ∈ t, 0 ≤ w i) → 0 < ∑ i ∈ t, w i → t.centerMass w id ∈ (convexHull R) ↑t | true |
AlgEquiv.refl_symm | Mathlib.Algebra.Algebra.Equiv | ∀ {R : Type uR} {A₁ : Type uA₁} [inst : CommSemiring R] [inst_1 : Semiring A₁] [inst_2 : Algebra R A₁],
AlgEquiv.refl.symm = AlgEquiv.refl | true |
CategoryTheory.Comma.hom | Mathlib.CategoryTheory.Comma.Basic | {A : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} A] →
{B : Type u₂} →
[inst_1 : CategoryTheory.Category.{v₂, u₂} B] →
{T : Type u₃} →
[inst_2 : CategoryTheory.Category.{v₃, u₃} T] →
{L : CategoryTheory.Functor A T} →
{R : CategoryTheory.Functor B T} → (sel... | true |
MeasureTheory.AddContent.measure.eq_1 | Mathlib.MeasureTheory.OuterMeasure.OfAddContent | ∀ {α : Type u_1} {C : Set (Set α)} [mα : MeasurableSpace α] (m : MeasureTheory.AddContent ENNReal C)
(hC : MeasureTheory.IsSetSemiring C) (hC_gen : mα ≤ MeasurableSpace.generateFrom C)
(m_sigma_subadd : m.IsSigmaSubadditive),
m.measure hC hC_gen m_sigma_subadd = (m.measureCaratheodory hC m_sigma_subadd).trim ⋯ | true |
HNNExtension.toSubgroupEquiv._proof_2 | Mathlib.GroupTheory.HNNExtension | ∀ {G : Type u_1} [inst : Group G] {A B : Subgroup G} (u : ℤˣ),
¬u = 1 → (↥(HNNExtension.toSubgroup A B u) ≃* ↥(HNNExtension.toSubgroup A B (-u))) = (↥B ≃* ↥A) | false |
RingCat.Colimits.Prequotient._sizeOf_inst | Mathlib.Algebra.Category.Ring.Colimits | {J : Type v} →
{inst : CategoryTheory.SmallCategory J} →
(F : CategoryTheory.Functor J RingCat) → [SizeOf J] → SizeOf (RingCat.Colimits.Prequotient F) | false |
AlgebraicGeometry.Scheme.ringCatSheaf | Mathlib.AlgebraicGeometry.Modules.Presheaf | (X : AlgebraicGeometry.Scheme) → TopCat.Sheaf RingCat ↑X.toPresheafedSpace | true |
bernsteinPolynomial.linearIndependent | Mathlib.RingTheory.Polynomial.Bernstein | ∀ (n : ℕ), LinearIndependent ℚ fun ν => bernsteinPolynomial ℚ n ↑ν | true |
UpperSemicontinuousOn.add' | Mathlib.Topology.Semicontinuity.Basic | ∀ {α : Type u_1} [inst : TopologicalSpace α] {s : Set α} {γ : Type u_5} [inst_1 : AddCommMonoid γ]
[inst_2 : LinearOrder γ] [IsOrderedAddMonoid γ] [inst_4 : TopologicalSpace γ] [OrderTopology γ] {f g : α → γ},
UpperSemicontinuousOn f s →
UpperSemicontinuousOn g s →
(∀ x ∈ s, ContinuousAt (fun p => p.1 + p... | true |
MeasureTheory.Measure.measure_compl_support | Mathlib.MeasureTheory.Measure.Support | ∀ {X : Type u_1} [inst : TopologicalSpace X] [inst_1 : MeasurableSpace X] {μ : MeasureTheory.Measure X}
[HereditarilyLindelofSpace X], μ μ.supportᶜ = 0 | true |
CochainComplex.IsKProjective | Mathlib.Algebra.Homology.HomotopyCategory.KProjective | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] → [inst_1 : CategoryTheory.Abelian C] → CochainComplex C ℤ → Prop | true |
PadicSeq.norm.eq_1 | Mathlib.NumberTheory.Padics.PadicNumbers | ∀ {p : ℕ} [inst : Fact (Nat.Prime p)] (f : PadicSeq p),
f.norm = if hf : f ≈ 0 then 0 else padicNorm p (↑f (PadicSeq.stationaryPoint hf)) | true |
Std.DTreeMap.Internal.Const.instSliceableImplRciSlice | Std.Data.DTreeMap.Internal.Zipper | {α : Type u} →
{β : Type v} →
[inst : Ord α] →
Std.Rci.Sliceable (Std.DTreeMap.Internal.Impl α fun x => β) α (Std.DTreeMap.Internal.Const.RciSlice α β) | true |
_private.Init.Data.Range.Polymorphic.IntLemmas.0.Int.induct_rco_right._proof_1_3 | Init.Data.Range.Polymorphic.IntLemmas | ∀ (d : ℕ) (a b : ℤ), (b - a).toNat = d + 1 → ¬a ≤ b - 1 → False | false |
Polynomial.cyclotomic_eq_prod_X_sub_primitiveRoots | Mathlib.RingTheory.Polynomial.Cyclotomic.Basic | ∀ {K : Type u_1} [inst : CommRing K] [inst_1 : IsDomain K] {ζ : K} {n : ℕ},
IsPrimitiveRoot ζ n → Polynomial.cyclotomic n K = ∏ μ ∈ primitiveRoots n K, (Polynomial.X - Polynomial.C μ) | true |
_private.Mathlib.CategoryTheory.Monoidal.Cartesian.Over.0.CategoryTheory.Over.isMonHom_pullbackFst_id_right._simp_2 | Mathlib.CategoryTheory.Monoidal.Cartesian.Over | ∀ {obj : Type u} [self : CategoryTheory.Category.{v, u} obj] {W X Y Z : obj} (f : W ⟶ X) (g : X ⟶ Y) (h : Y ⟶ Z),
CategoryTheory.CategoryStruct.comp f (CategoryTheory.CategoryStruct.comp g h) =
CategoryTheory.CategoryStruct.comp (CategoryTheory.CategoryStruct.comp f g) h | false |
ack_pair_lt | Mathlib.Computability.Ackermann | ∀ (m n k : ℕ), ack m (Nat.pair n k) < ack (m + 4) (max n k) | true |
nhdsNE_le_cofinite | Mathlib.Topology.Separation.Basic | ∀ {α : Type u_3} [inst : TopologicalSpace α] [T1Space α] (a : α), nhdsWithin a {a}ᶜ ≤ Filter.cofinite | true |
ULift.divisionRing._proof_9 | Mathlib.Algebra.Field.ULift | ∀ {α : Type u_2} [inst : DivisionRing α] (x : ℚ≥0) (x_1 : ULift.{u_1, u_2} α),
{ down := DivisionSemiring.nnqsmul x x_1.down } = { down := (↑x).down * x_1.down } | false |
Projectivization.cross_comm | Mathlib.LinearAlgebra.Projectivization.Constructions | ∀ {F : Type u_1} [inst : Field F] [inst_1 : DecidableEq F] (v w : Projectivization F (Fin 3 → F)), v.cross w = w.cross v | true |
Polynomial.mirror_smul | Mathlib.Algebra.Polynomial.Mirror | ∀ {R : Type u_1} [inst : Semiring R] (p : Polynomial R) [NoZeroDivisors R] (a : R), (a • p).mirror = a • p.mirror | true |
FirstOrder.Language.Theory.Imp.instReflBoundedFormula | Mathlib.ModelTheory.Equivalence | ∀ {L : FirstOrder.Language} {T : L.Theory} {α : Type w} {n : ℕ}, Std.Refl T.Imp | true |
ZeroAtInftyContinuousMap.instAddCommMonoid._proof_2 | Mathlib.Topology.ContinuousMap.ZeroAtInfty | ∀ {α : Type u_1} {β : Type u_2} [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β] [inst_2 : AddCommMonoid β],
⇑0 = 0 | false |
LinearMap.BilinForm.tensorDistribEquiv | Mathlib.LinearAlgebra.BilinearForm.TensorProduct | (R : Type uR) →
{M₁ : Type uM₁} →
{M₂ : Type uM₂} →
[inst : CommRing R] →
[inst_1 : AddCommGroup M₁] →
[inst_2 : AddCommGroup M₂] →
[inst_3 : Module R M₁] →
[inst_4 : Module R M₂] →
[Module.Free R M₁] →
[Module.Finite R M₁] →
... | true |
Perfection.instRing._proof_1 | Mathlib.RingTheory.Perfection | ∀ (R : Type u_1) [inst : CommRing R] (p : ℕ) [hp : Fact (Nat.Prime p)] [inst_1 : CharP R p],
autoParam (∀ (a b : Perfection R p), a - b = a + -b) SubNegMonoid.sub_eq_add_neg._autoParam | false |
Polynomial.instMulSemiringAction | Mathlib.Algebra.Polynomial.GroupRingAction | (M : Type u_1) →
[inst : Monoid M] →
(R : Type u_2) → [inst_1 : Semiring R] → [MulSemiringAction M R] → MulSemiringAction M (Polynomial R) | true |
Nat.toList_rco_add_right_eq_map | Init.Data.Range.Polymorphic.NatLemmas | ∀ {m n : ℕ}, (m...m + n).toList = List.map (fun x => x + m) (0...n).toList | true |
QuadraticAlgebra.instAddGroup._proof_5 | Mathlib.Algebra.QuadraticAlgebra.Defs | ∀ {R : Type u_1} {a b : R} [inst : AddGroup R] (a_1 : QuadraticAlgebra R a b), -a_1 + a_1 = 0 | false |
CategoryTheory.PreGaloisCategory.instIsTopologicalGroupAutFunctorFintypeCat | Mathlib.CategoryTheory.Galois.Topology | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{u₂, u₁} C] (F : CategoryTheory.Functor C FintypeCat),
IsTopologicalGroup (CategoryTheory.Aut F) | true |
Mathlib.Tactic.IntervalCases.IntervalCasesSubgoal._sizeOf_inst | Mathlib.Tactic.IntervalCases | SizeOf Mathlib.Tactic.IntervalCases.IntervalCasesSubgoal | false |
Summable.tsum_eq_add_tsum_ite | Mathlib.Topology.Algebra.InfiniteSum.Group | ∀ {α : Type u_1} {β : Type u_2} [inst : AddCommGroup α] [inst_1 : TopologicalSpace α] [IsTopologicalAddGroup α]
{f : β → α} [T2Space α] [inst_4 : DecidableEq β],
Summable f → ∀ (b : β), ∑' (n : β), f n = f b + ∑' (n : β), if n = b then 0 else f n | true |
Subring.instInfSet._proof_3 | Mathlib.Algebra.Ring.Subring.Basic | ∀ {R : Type u_1} [inst : NonAssocRing R] (s : Set (Subring R)), ↑(⨅ t ∈ s, t.toAddSubgroup) = ⋂ t ∈ s, ↑t | false |
_private.Mathlib.MeasureTheory.Measure.ProbabilityMeasure.0.MeasureTheory.ProbabilityMeasure.continuous_iff_forall_continuous_lintegral._simp_1_1 | Mathlib.MeasureTheory.Measure.ProbabilityMeasure | ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] {f : X → Y},
Continuous f = ∀ (x : X), ContinuousAt f x | false |
CategoryTheory.Limits.map_lift_piComparison_assoc | Mathlib.CategoryTheory.Limits.Shapes.Products | ∀ {β : Type w} {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {D : Type u₂}
[inst_1 : CategoryTheory.Category.{v₂, u₂} D] (G : CategoryTheory.Functor C D) (f : β → C)
[inst_2 : CategoryTheory.Limits.HasProduct f] [inst_3 : CategoryTheory.Limits.HasProduct fun b => G.obj (f b)] (P : C)
(g : (j : β) → P ⟶ f... | true |
Rep.instIsTrivialTrivial | Mathlib.RepresentationTheory.Rep.Basic | ∀ {k : Type u} {G : Type v} [inst : Ring k] [inst_1 : Monoid G] {V : Type w} [inst_2 : AddCommGroup V]
[inst_3 : Module k V], (Rep.trivial k G V).IsTrivial | true |
Nat.lcm_le_mul | Init.Data.Nat.Lcm | ∀ {m n : ℕ}, 0 < m → 0 < n → m.lcm n ≤ m * n | true |
LieSubalgebra.coe_toLieSubmodule | Mathlib.Algebra.Lie.Submodule | ∀ {R : Type u} {L : Type v} [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : LieAlgebra R L] (K : LieSubalgebra R L),
↑K.toLieSubmodule = K.toSubmodule | true |
_private.Init.Data.Nat.Div.Basic.0.Nat.mod_le.match_1_3 | Init.Data.Nat.Div.Basic | ∀ (y : ℕ) (motive : y = 0 ∨ y > 0 → Prop) (x : y = 0 ∨ y > 0),
(∀ (h₂ : y = 0), motive ⋯) → (∀ (h₂ : y > 0), motive ⋯) → motive x | false |
DirectSum.GCommSemiring.noConfusion | Mathlib.Algebra.DirectSum.Ring | {P : Sort u} →
{ι : Type u_1} →
{A : ι → Type u_2} →
{inst : AddCommMonoid ι} →
{inst_1 : (i : ι) → AddCommMonoid (A i)} →
{t : DirectSum.GCommSemiring A} →
{ι' : Type u_1} →
{A' : ι' → Type u_2} →
{inst' : AddCommMonoid ι'} →
{in... | false |
Std.Tactic.BVDecide.BVExpr.bitblast.instLawfulVecOperatorBinaryRefVecBlastSub | Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Sub | ∀ {α : Type} [inst : Hashable α] [inst_1 : DecidableEq α],
Std.Sat.AIG.LawfulVecOperator α Std.Sat.AIG.BinaryRefVec fun {len} => Std.Tactic.BVDecide.BVExpr.bitblast.blastSub | true |
RingQuot.preLiftAlgHom.congr_simp | Mathlib.Algebra.RingQuot | ∀ (S : Type u_1) [inst : CommSemiring S] {A : Type u_2} [inst_1 : Semiring A] [inst_2 : Algebra S A] {B : Type u_3}
[inst_3 : Semiring B] [inst_4 : Algebra S B] {s : A → A → Prop} {f f_1 : A →ₐ[S] B} (e_f : f = f_1)
(h : ∀ ⦃x y : A⦄, s x y → f x = f y), RingQuot.preLiftAlgHom S h = RingQuot.preLiftAlgHom S ⋯ | true |
SimpleGraph.extremalNumber | Mathlib.Combinatorics.SimpleGraph.Extremal.Basic | ℕ → {W : Type u_1} → SimpleGraph W → ℕ | true |
CategoryTheory.Pseudofunctor.DescentData'.pullHom'_self'._proof_4 | Mathlib.CategoryTheory.Sites.Descent.DescentDataPrime | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {ι : Type u_3} {S : C} {X : ι → C}
{f : (i : ι) → X i ⟶ S} (i : ι),
CategoryTheory.CategoryStruct.comp (CategoryTheory.CategoryStruct.id (X i)) (f i) = f i | false |
strictMonoOn_toDual_comp_iff | Mathlib.Order.Monotone.Basic | ∀ {α : Type u} {β : Type v} [inst : Preorder α] [inst_1 : Preorder β] {f : α → β} {s : Set α},
StrictMonoOn (⇑OrderDual.toDual ∘ f) s ↔ StrictAntiOn f s | true |
Lean.StructureInfo._sizeOf_inst | Lean.Structure | SizeOf Lean.StructureInfo | false |
_private.Lean.Meta.IndPredBelow.0.Lean.Meta.IndPredBelow.withBRecOnArgs.go.go2._unary._proof_1 | Lean.Meta.IndPredBelow | ∀ (minorArgs : Array Lean.Expr) (j : ℕ) (vars args : Array Lean.Expr),
j < minorArgs.size →
∀ (newIH proof : Lean.Expr),
InvImage (fun x1 x2 => x1 < x2)
(fun x => PSigma.casesOn x fun j vars => PSigma.casesOn vars fun vars args => minorArgs.size - j)
⟨j + 1, ⟨vars.push newIH, (args.push newI... | false |
Submodule.mem_biSup_iff_exists_dfinsupp | Mathlib.LinearAlgebra.DFinsupp | ∀ {ι : Type u_1} {R : Type u_3} {N : Type u_6} [inst : Semiring R] [inst_1 : AddCommMonoid N] [inst_2 : Module R N]
[inst_3 : DecidableEq ι] (p : ι → Prop) [inst_4 : DecidablePred p] (S : ι → Submodule R N) (x : N),
x ∈ ⨆ i, ⨆ (_ : p i), S i ↔ ∃ f, ((DFinsupp.lsum ℕ) fun i => (S i).subtype) (DFinsupp.filter p f) = ... | true |
Asymptotics.IsEquivalent.tendsto_nhds_iff | Mathlib.Analysis.Asymptotics.AsymptoticEquivalent | ∀ {α : Type u_1} {β : Type u_2} [inst : NormedAddCommGroup β] {u v : α → β} {l : Filter α} {c : β},
Asymptotics.IsEquivalent l u v → (Filter.Tendsto u l (nhds c) ↔ Filter.Tendsto v l (nhds c)) | true |
ValuationSubring.instLinearOrderedCommGroupWithZeroValueGroup._aux_51 | Mathlib.RingTheory.Valuation.ValuationSubring | {K : Type u_1} → [inst : Field K] → (A : ValuationSubring K) → ℤ → A.ValueGroup → A.ValueGroup | false |
Set.Ioc_top | Mathlib.Order.Interval.Set.Basic | ∀ {α : Type u_1} [inst : Preorder α] [inst_1 : OrderTop α] {a : α}, Set.Ioc a ⊤ = Set.Ioi a | true |
WithZero.instExistsAddOfLE | Mathlib.Algebra.Order.GroupWithZero.Canonical | ∀ {α : Type u_1} [inst : Preorder α] [inst_1 : Add α] [ExistsAddOfLE α], ExistsAddOfLE (WithZero α) | true |
_private.Mathlib.Algebra.BigOperators.Intervals.0.Finset.prod_range_div_prod_range._simp_1_3 | Mathlib.Algebra.BigOperators.Intervals | ∀ {n m : ℕ}, (m ∈ Finset.range n) = (m < n) | false |
Matrix.instModuleForall._proof_1 | Mathlib.Data.Matrix.Action | ∀ {n : Type u_1} {R : Type u_2} [inst : Fintype n] [inst_1 : Semiring R] (x x_1 : Matrix n n R) (x_2 : n → R),
(x * x_1).mulVec x_2 = x.mulVec (x_1.mulVec x_2) | false |
pow | Mathlib.FieldTheory.Perfect | ∀ (M : Type u_1) (p : ℕ) [inst : CommMonoid M] [PerfectRing M p] (n : ℕ), PerfectRing M (p ^ n) | true |
ENNReal.HolderConjugate.ne_zero | Mathlib.Data.ENNReal.Holder | ∀ (p q : ENNReal) [p.HolderConjugate q], p ≠ 0 | true |
Std.DTreeMap.Internal.Impl.getKey?_insert_self | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Std.DTreeMap.Internal.Impl α β} [Std.TransOrd α] (h : t.WF)
{k : α} {v : β k}, (Std.DTreeMap.Internal.Impl.insert k v t ⋯).impl.getKey? k = some k | true |
WithTop.coe_sSup._simp_1 | Mathlib.Order.ConditionallyCompleteLattice.Basic | ∀ {α : Type u_1} [inst : ConditionallyCompleteLinearOrderBot α] {s : Set α}, BddAbove s → ⨆ a ∈ s, ↑a = ↑(sSup s) | false |
Finset.sup'_mono | Mathlib.Data.Finset.Lattice.Fold | ∀ {α : Type u_2} {β : Type u_3} [inst : SemilatticeSup α] (f : β → α) {s₁ s₂ : Finset β} (h : s₁ ⊆ s₂)
(h₁ : s₁.Nonempty), s₁.sup' h₁ f ≤ s₂.sup' ⋯ f | true |
Turing.ToPartrec.Cfg.ret.inj | Mathlib.Computability.TuringMachine.Config | ∀ {a : Turing.ToPartrec.Cont} {a_1 : List ℕ} {a_2 : Turing.ToPartrec.Cont} {a_3 : List ℕ},
Turing.ToPartrec.Cfg.ret a a_1 = Turing.ToPartrec.Cfg.ret a_2 a_3 → a = a_2 ∧ a_1 = a_3 | true |
Nat.testBit_eq_inth | Mathlib.Data.Nat.Bitwise | ∀ (n i : ℕ), n.testBit i = n.bits.getI i | true |
CategoryTheory.Pretriangulated.Triangle.ctorIdx | Mathlib.CategoryTheory.Triangulated.Basic | {C : Type u} →
{inst : CategoryTheory.Category.{v, u} C} →
{inst_1 : CategoryTheory.HasShift C ℤ} → CategoryTheory.Pretriangulated.Triangle C → ℕ | false |
_private.Lean.Meta.Tactic.Grind.ProveEq.0.Lean.Meta.Grind.AbstractM.State.mk | Lean.Meta.Tactic.Grind.ProveEq | Std.HashMap (Lean.Expr × Lean.Expr) Lean.Expr →
Array Lean.Expr → Array Lean.Expr → Array Lean.Expr → Lean.Meta.Grind.AbstractM.State✝ | true |
Int16.toInt32_ne_neg_one | Init.Data.SInt.Lemmas | ∀ (a : Int16), a ≠ -1 → a.toInt32 ≠ -1 | true |
AlgebraicGeometry.Scheme.RationalMap.fromFunctionField_ofFunctionField | Mathlib.AlgebraicGeometry.RationalMap | ∀ {X Y S : AlgebraicGeometry.Scheme} (sX : X ⟶ S) (sY : Y ⟶ S) [inst : AlgebraicGeometry.IsIntegral X]
[inst_1 : AlgebraicGeometry.LocallyOfFiniteType sY] (f : AlgebraicGeometry.Spec X.functionField ⟶ Y)
(h :
CategoryTheory.CategoryStruct.comp f sY =
CategoryTheory.CategoryStruct.comp (X.fromSpecStalk (ge... | true |
Lean.CodeAction.CommandCodeActionEntry._sizeOf_1 | Lean.Server.CodeActions.Attr | Lean.CodeAction.CommandCodeActionEntry → ℕ | false |
Lean.Elab.Term.elabCalc._regBuiltin.Lean.Elab.Term.elabCalc.docString_3 | Lean.Elab.Calc | IO Unit | false |
Std.Slice.Internal.SubarrayData.start_le_stop | Init.Data.Array.Subarray | ∀ {α : Type u} (self : Std.Slice.Internal.SubarrayData α), self.start ≤ self.stop | true |
Lean.Elab.Tactic.Try.Ctx.originalMaxHeartbeats | Lean.Elab.Tactic.Try | Lean.Elab.Tactic.Try.Ctx → ℕ | true |
Continuous.finset_sup' | Mathlib.Topology.Order.Lattice | ∀ {L : Type u_1} {X : Type u_2} [inst : TopologicalSpace L] [inst_1 : TopologicalSpace X] {ι : Type u_3}
[inst_2 : SemilatticeSup L] [ContinuousSup L] {s : Finset ι} {f : ι → X → L} (hne : s.Nonempty),
(∀ i ∈ s, Continuous (f i)) → Continuous (s.sup' hne f) | true |
Ideal.Quotient.field._proof_10 | Mathlib.RingTheory.Ideal.Quotient.Basic | ∀ {R : Type u_1} [inst : CommRing R] (I : Ideal R) [inst_1 : I.IsMaximal],
autoParam (∀ (q : ℚ), ↑q = ↑q.num / ↑q.den) DivisionRing.ratCast_def._autoParam | false |
SimplicialObject.Split.ext | Mathlib.AlgebraicTopology.SimplicialObject.Split | ∀ {C : Type u_1} {inst : CategoryTheory.Category.{v_1, u_1} C} {x y : SimplicialObject.Split C},
x.X = y.X → x.s ≍ y.s → x = y | true |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.minKey?_insertIfNew_le_self._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 |
Lean.Meta.Grind.Arith.Linear.Case.mk.inj | Lean.Meta.Tactic.Grind.Arith.Linear.SearchM | ∀ {c : Lean.Meta.Grind.Arith.Linear.DiseqCnstr} {fvarId : Lean.FVarId} {saved : Lean.Meta.Grind.Arith.Linear.Struct}
{c_1 : Lean.Meta.Grind.Arith.Linear.DiseqCnstr} {fvarId_1 : Lean.FVarId}
{saved_1 : Lean.Meta.Grind.Arith.Linear.Struct},
{ c := c, fvarId := fvarId, saved := saved } = { c := c_1, fvarId := fvarId... | true |
ULower.down_eq_down._simp_1 | Mathlib.Logic.Encodable.Basic | ∀ {α : Type u_1} [inst : Encodable α] {a b : α}, (ULower.down a = ULower.down b) = (a = b) | false |
MeasureTheory.SimpleFunc.instCommMonoid._proof_1 | Mathlib.MeasureTheory.Function.SimpleFunc | ∀ {α : Type u_1} {β : Type u_2} [inst : MeasurableSpace α] [inst_1 : CommMonoid β] (a b : MeasureTheory.SimpleFunc α β),
a * b = b * a | false |
Lean.Expr.updateForallS! | Lean.Meta.Sym.AlphaShareBuilder | {m : Type → Type} →
[Lean.Meta.Sym.Internal.MonadShareCommon m] → [Monad m] → Lean.Expr → Lean.Expr → Lean.Expr → m Lean.Expr | true |
Matrix.linftyOpSeminormedAddCommGroup._proof_9 | Mathlib.Analysis.Matrix.Normed | ∀ {m : Type u_1} {n : Type u_2} {α : Type u_3} [inst : Fintype m] [inst_1 : Fintype n]
[inst_2 : SeminormedAddCommGroup α] (f g : m → n → α),
edist f g = ENNReal.ofReal ↑(Finset.univ.sup fun b => nndist (f b) (g b)) | false |
_private.Batteries.Data.Array.Lemmas.0.Array.extract_append_of_size_left_le_start._proof_1_8 | Batteries.Data.Array.Lemmas | ∀ {α : Type u_1} {i j : ℕ} {a b : Array α} (w : ℕ),
w - (a.extract i j).size + 1 ≤ (b.extract (i - a.size) (j - a.size)).size →
w - (a.extract i j).size < (b.extract (i - a.size) (j - a.size)).size | false |
Set.Ici_subset_Ioi._simp_1 | Mathlib.Order.Interval.Set.Basic | ∀ {α : Type u_1} [inst : Preorder α] {a b : α}, (Set.Ici a ⊆ Set.Ioi b) = (b < a) | false |
Real.sin_two_pi_sub | Mathlib.Analysis.SpecialFunctions.Trigonometric.Basic | ∀ (x : ℝ), Real.sin (2 * Real.pi - x) = -Real.sin x | true |
PresheafOfModules.Derivation.congr_d | Mathlib.Algebra.Category.ModuleCat.Differentials.Presheaf | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
{S : CategoryTheory.Functor Cᵒᵖ CommRingCat} {F : CategoryTheory.Functor C D}
{R : CategoryTheory.Functor Dᵒᵖ CommRingCat}
{M : PresheafOfModules (R.comp (CategoryTheory.forget₂ CommRingCat Ring... | true |
EuclideanGeometry.Sphere.radius | Mathlib.Geometry.Euclidean.Sphere.Basic | {P : Type u_2} → [inst : MetricSpace P] → EuclideanGeometry.Sphere P → ℝ | true |
OrderDual.instSubtractionMonoid._proof_1 | Mathlib.Algebra.Order.Group.Synonym | ∀ {α : Type u_1} [h : SubtractionMonoid α] (x : αᵒᵈ), - -x = x | false |
Module.End.IsSemisimple.pow | Mathlib.LinearAlgebra.Semisimple | ∀ {M : Type u_2} [inst : AddCommGroup M] {K : Type u_3} [inst_1 : Field K] [inst_2 : Module K M] {f : Module.End K M}
[FiniteDimensional K M], f.IsSemisimple → ∀ (n : ℕ), (f ^ n).IsSemisimple | true |
Affine.Triangle.orthocenter_mem_affineSpan | Mathlib.Geometry.Euclidean.MongePoint | ∀ {V : Type u_1} {P : Type u_2} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V] [inst_2 : MetricSpace P]
[inst_3 : NormedAddTorsor V P] (t : Affine.Triangle ℝ P), t.orthocenter ∈ affineSpan ℝ (Set.range t.points) | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.