name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
_private.Mathlib.CategoryTheory.Shift.ShiftSequence.0.CategoryTheory.Functor.ShiftSequence.tautological._simp_4 | Mathlib.CategoryTheory.Shift.ShiftSequence | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v_1, u₁} C] {D : Type u₂}
[inst_1 : CategoryTheory.Category.{v_2, u₂} D] (F : CategoryTheory.Functor C D) {X Y Z : C} (f : X ⟶ Y) (g : Y ⟶ Z)
{W : D} (h : F.obj Z ⟶ W),
CategoryTheory.CategoryStruct.comp (F.map f) (CategoryTheory.CategoryStruct.comp (F.map g) h) =
... | false |
Real.summable_Lp_add_of_nonneg | Mathlib.Analysis.MeanInequalities | ∀ {ι : Type u} {f g : ι → ℝ} {p : ℝ},
1 ≤ p →
(∀ (i : ι), 0 ≤ f i) →
(∀ (i : ι), 0 ≤ g i) →
(Summable fun i => f i ^ p) → (Summable fun i => g i ^ p) → Summable fun i => (f i + g i) ^ p | true |
Lean.Elab.Tactic.ResolveSimpIdResult._sizeOf_1 | Lean.Elab.Tactic.Simp | Lean.Elab.Tactic.ResolveSimpIdResult → ℕ | false |
instAddCommMonoidWithOneENNReal._aux_8 | Mathlib.Data.ENNReal.Basic | ℕ → ENNReal → ENNReal | false |
Seminorm.closedBall_zero' | Mathlib.Analysis.Seminorm | ∀ {𝕜 : Type u_3} {E : Type u_7} [inst : SeminormedRing 𝕜] [inst_1 : AddCommGroup E] [inst_2 : SMul 𝕜 E] {r : ℝ} (x : E),
0 < r → Seminorm.closedBall 0 x r = Set.univ | true |
_private.Mathlib.Algebra.NoZeroSMulDivisors.Defs.0.instIsTorsionFreeOfIsDomainOfNoZeroSMulDivisors._simp_1 | Mathlib.Algebra.NoZeroSMulDivisors.Defs | ∀ {G : Type u_3} [inst : AddGroup G] {a b : G}, (a - b = 0) = (a = b) | false |
Encodable.decidableRangeEncode.match_1 | Mathlib.Logic.Encodable.Basic | ∀ (α : Type u_1) [inst : Encodable α] (x : ℕ) (motive : x ∈ Set.range Encodable.encode → Prop)
(x_1 : x ∈ Set.range Encodable.encode), (∀ (n : α) (hn : Encodable.encode n = x), motive ⋯) → motive x_1 | false |
Polynomial.coeff_hermite_succ_zero | Mathlib.RingTheory.Polynomial.Hermite.Basic | ∀ (n : ℕ), (Polynomial.hermite (n + 1)).coeff 0 = -(Polynomial.hermite n).coeff 1 | true |
Cross.lieRing._proof_1 | Mathlib.LinearAlgebra.CrossProduct | ∀ {R : Type u_1} [inst : CommRing R], SMulCommClass R R (Fin 3 → R) | false |
SimpleGraph.Copy.mapNeighborSet | Mathlib.Combinatorics.SimpleGraph.Copy | {α : Type u_4} →
{β : Type u_5} →
{A : SimpleGraph α} → {B : SimpleGraph β} → (f : A.Copy B) → (a : α) → ↑(A.neighborSet a) ↪ ↑(B.neighborSet (f a)) | true |
AffineSubspace.sSameSide_vadd_left_iff | Mathlib.Analysis.Convex.Side | ∀ {R : Type u_1} {V : Type u_2} {P : Type u_4} [inst : CommRing R] [inst_1 : PartialOrder R]
[inst_2 : IsStrictOrderedRing R] [inst_3 : AddCommGroup V] [inst_4 : Module R V] [inst_5 : AddTorsor V P]
{s : AffineSubspace R P} {x y : P} {v : V}, v ∈ s.direction → (s.SSameSide (v +ᵥ x) y ↔ s.SSameSide x y) | true |
if_true | Init.ByCases | ∀ {α : Sort u_1} {x : Decidable True} (t e : α), (if True then t else e) = t | true |
Subsemiring.mk'.congr_simp | Mathlib.Algebra.Ring.Subsemiring.Basic | ∀ {R : Type u} [inst : NonAssocSemiring R] (s s_1 : Set R) (e_s : s = s_1) (sm sm_1 : Submonoid R) (e_sm : sm = sm_1)
(hm : ↑sm = s) (sa sa_1 : AddSubmonoid R) (e_sa : sa = sa_1) (ha : ↑sa = s),
Subsemiring.mk' s sm hm sa ha = Subsemiring.mk' s_1 sm_1 ⋯ sa_1 ⋯ | true |
ZFSet.coe_union._simp_1 | Mathlib.SetTheory.ZFC.Basic | ∀ (x y : ZFSet.{u}), ↑x ∪ ↑y = ↑(x ∪ y) | false |
Computation.LiftRel.swap | Mathlib.Data.Seq.Computation | ∀ {α : Type u} {β : Type v} (R : α → β → Prop) (ca : Computation α) (cb : Computation β),
Computation.LiftRel (Function.swap R) cb ca ↔ Computation.LiftRel R ca cb | true |
Filter.tendsto_inv₀_cobounded | Mathlib.Analysis.Normed.Field.Lemmas | ∀ {α : Type u_1} [inst : NormedDivisionRing α], Filter.Tendsto Inv.inv (Bornology.cobounded α) (nhds 0) | true |
_private.Mathlib.Combinatorics.Matroid.Constructions.0.Matroid.restrict_empty._simp_1_1 | Mathlib.Combinatorics.Matroid.Constructions | ∀ {α : Type u_1} {M : Matroid α}, (M = Matroid.emptyOn α) = (M.E = ∅) | false |
_private.Mathlib.Topology.Algebra.OpenSubgroup.0.IsTopologicalAddGroup.exist_add_closure_nhds.match_1_1 | Mathlib.Topology.Algebra.OpenSubgroup | ∀ {G : Type u_1} [inst : TopologicalSpace G] [inst_1 : AddGroup G] {W : Set G} (x : Set G)
(motive : (∃ T ∈ nhds 0, x + T ⊆ W) → Prop) (x_1 : ∃ T ∈ nhds 0, x + T ⊆ W),
(∀ (T : Set G) (hT : T ∈ nhds 0) (mem : x + T ⊆ W), motive ⋯) → motive x_1 | false |
CategoryTheory.SingleFunctors.postcomp._proof_1 | Mathlib.CategoryTheory.Shift.SingleFunctors | ∀ {C : Type u_1} {D : Type u_6} {E : Type u_3} [inst : CategoryTheory.Category.{u_4, u_1} C]
[inst_1 : CategoryTheory.Category.{u_5, u_6} D] [inst_2 : CategoryTheory.Category.{u_2, u_3} E] {A : Type u_7}
[inst_3 : AddMonoid A] [inst_4 : CategoryTheory.HasShift D A] [inst_5 : CategoryTheory.HasShift E A]
(F : Cate... | false |
_private.Lean.Meta.Tactic.Grind.SimpUtil.0.Lean.Meta.Grind.reduceCtorEqCheap._sparseCasesOn_1 | Lean.Meta.Tactic.Grind.SimpUtil | {α : Type u} →
{motive : Option α → Sort u_1} →
(t : Option α) → ((val : α) → motive (some val)) → (Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t | false |
Polynomial.coeffList.eq_1 | Mathlib.Algebra.Polynomial.CoeffList | ∀ {R : Type u_1} [inst : Semiring R] (P : Polynomial R),
P.coeffList = List.map P.coeff (List.range P.degree.succ).reverse | true |
Module.restrictScalars | Mathlib.Algebra.Algebra.RestrictScalars | (R : Type u_1) →
(S : Type u_2) →
(M : Type u_3) →
[inst : Semiring S] →
[inst_1 : AddCommMonoid M] → [inst_2 : CommSemiring R] → [Algebra R S] → [Module S M] → Module R M | true |
_private.Mathlib.Tactic.Translate.Core.0.Mathlib.Tactic.Translate.copyInstanceAttribute.match_1 | Mathlib.Tactic.Translate.Core | (motive : Lean.ReducibilityStatus → Sort u_1) →
(__do_lift : Lean.ReducibilityStatus) →
(Unit → motive Lean.ReducibilityStatus.implicitReducible) →
((x : Lean.ReducibilityStatus) → motive x) → motive __do_lift | false |
_private.Mathlib.Order.CompactlyGenerated.Basic.0.iSupIndep_iff_supIndep.match_1_10 | Mathlib.Order.CompactlyGenerated.Basic | ∀ {α : Type u_1} [inst : CompleteLattice α] (s : Finset α) (a : α) (motive : ¬a = ⊥ ∧ a ∈ s → Prop)
(x : ¬a = ⊥ ∧ a ∈ s), (∀ (ha : ¬a = ⊥) (has : a ∈ s), motive ⋯) → motive x | false |
Hyperreal.inv_epsilon | Mathlib.Analysis.Real.Hyperreal | Hyperreal.epsilon⁻¹ = Hyperreal.omega | true |
instCompleteAtomicBooleanAlgebraLanguage._aux_14 | Mathlib.Computability.Language | (α : Type u_1) → Language α → Language α → Language α | false |
Hindman.FP_partition_regular | Mathlib.Combinatorics.Hindman | ∀ {M : Type u_1} [inst : Semigroup M] (a : Stream' M) (s : Set (Set M)),
s.Finite → Hindman.FP a ⊆ ⋃₀ s → ∃ c ∈ s, ∃ b, Hindman.FP b ⊆ c | true |
List.sum_flatten | Batteries.Data.List.Lemmas | ∀ {α : Type u_1} [inst : Add α] [inst_1 : Zero α] [Std.LawfulIdentity (fun x1 x2 => x1 + x2) 0]
[Std.Associative fun x1 x2 => x1 + x2] {l : List (List α)}, l.flatten.sum = (List.map List.sum l).sum | true |
ProbabilityTheory.IsMeasurableRatCDF.le_one | Mathlib.Probability.Kernel.Disintegration.MeasurableStieltjes | ∀ {α : Type u_1} [inst : MeasurableSpace α] {f : α → ℚ → ℝ},
ProbabilityTheory.IsMeasurableRatCDF f → ∀ (a : α) (q : ℚ), f a q ≤ 1 | true |
TopologicalSpace.Clopens.ctorIdx | Mathlib.Topology.Sets.Closeds | {α : Type u_4} → {inst : TopologicalSpace α} → TopologicalSpace.Clopens α → ℕ | false |
Fin.addCases._proof_2 | Init.Data.Fin.Lemmas | ∀ {m n : ℕ} (i : Fin (m + n)) (hi : ¬↑i < m), Fin.natAdd m (Fin.subNat m (Fin.cast ⋯ i) ⋯) = i | false |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.maxKey?_erase_le_maxKey?._simp_1_1 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {x : Ord α} {x_1 : BEq α} [Std.LawfulBEqOrd α] {a b : α}, (compare a b = Ordering.eq) = ((a == b) = true) | false |
_private.Mathlib.Data.List.Chain.0.List.exists_isChain_ne_nil_of_relationReflTransGen._proof_1_2 | Mathlib.Data.List.Chain | ∀ {α : Type u_1} {a : α} (l : List α), ¬a :: l = [] | false |
Lean.Compiler.LCNF.MonadCodeBind.mk.noConfusion | Lean.Compiler.LCNF.Bind | {m : Type → Type} →
{P : Sort u} →
{codeBind codeBind' :
{pu : Lean.Compiler.LCNF.Purity} →
Lean.Compiler.LCNF.Code pu →
(Lean.FVarId → m (Lean.Compiler.LCNF.Code pu)) → m (Lean.Compiler.LCNF.Code pu)} →
{ codeBind := codeBind } = { codeBind := codeBind' } → (codeBind ≍ codeBin... | false |
_private.Mathlib.RingTheory.WittVector.Frobenius.0.WittVector.frobenius._simp_2 | Mathlib.RingTheory.WittVector.Frobenius | ∀ {G : Type u_1} [inst : SubNegMonoid G] (a b : G), a + -b = a - b | false |
Lean.Meta.Grind.Arith.CommRing.EqCnstrProof.simp | Lean.Meta.Tactic.Grind.Arith.CommRing.Types | ℤ →
Lean.Meta.Grind.Arith.CommRing.EqCnstr →
ℤ → Lean.Grind.CommRing.Mon → Lean.Meta.Grind.Arith.CommRing.EqCnstr → Lean.Meta.Grind.Arith.CommRing.EqCnstrProof | true |
Lean.Firefox.ProfileMeta.rec | Lean.Util.Profiler | {motive : Lean.Firefox.ProfileMeta → Sort u} →
((interval startTime : Lean.Firefox.Milliseconds) →
(categories : Array Lean.Firefox.Category) →
(processType : ℕ) →
(product : String) →
(preprocessedProfileVersion : ℕ) →
(markerSchema : Array Lean.Json) →
... | false |
_private.Mathlib.CategoryTheory.Limits.Preserves.Shapes.AbelianImages.0.CategoryTheory.Abelian.PreservesCoimage.hom_coimageImageComparison._simp_1_2 | Mathlib.CategoryTheory.Limits.Preserves.Shapes.AbelianImages | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y Z : C} (α : X ≅ Y) {f : X ⟶ Z} {g : Y ⟶ Z},
(CategoryTheory.CategoryStruct.comp α.hom g = f) = (g = CategoryTheory.CategoryStruct.comp α.inv f) | false |
_private.Mathlib.Topology.MetricSpace.Pseudo.Defs.0.Mathlib.Meta.Positivity.evalDist._proof_2 | Mathlib.Topology.MetricSpace.Pseudo.Defs | ∀ (α : Q(Type)) (_pα : Q(PartialOrder «$α»)) (__defeqres : PLift («$_pα» =Q Real.partialOrder)),
«$_pα» =Q Real.partialOrder | false |
ProofWidgets.instFromJsonRpcEncodablePacket._@.ProofWidgets.Component.HtmlDisplay.3039065598._hygCtx._hyg.10 | ProofWidgets.Component.HtmlDisplay | Lean.FromJson ProofWidgets.RpcEncodablePacket✝ | false |
_private.Mathlib.Topology.Algebra.IsUniformGroup.Defs.0.UniformContinuous.pow_const.match_1_1 | Mathlib.Topology.Algebra.IsUniformGroup.Defs | ∀ (motive : ℕ → Prop) (x : ℕ), (∀ (a : Unit), motive 0) → (∀ (n : ℕ), motive n.succ) → motive x | false |
Std.Time.PlainDate.instToString | Std.Time.Format | ToString Std.Time.PlainDate | true |
_private.Mathlib.AlgebraicGeometry.EllipticCurve.Projective.Point.0.WeierstrassCurve.Projective.Point.toAffine_some._simp_1_3 | Mathlib.AlgebraicGeometry.EllipticCurve.Projective.Point | ∀ {R : Type r} (a b c : R), ![a, b, c] 2 = c | false |
Monoid.CoprodI.NeWord.toList.induct_unfolding | Mathlib.GroupTheory.CoprodI | ∀ {ι : Type u_1} {M : ι → Type u_2} [inst : (i : ι) → Monoid (M i)]
(motive : {i j : ι} → Monoid.CoprodI.NeWord M i j → List ((i : ι) × M i) → Prop),
(∀ (i : ι) (x : M i) (a : x ≠ 1), motive (Monoid.CoprodI.NeWord.singleton x a) [⟨i, x⟩]) →
(∀ (x x_1 j k : ι) (w₁ : Monoid.CoprodI.NeWord M x j) (_hne : j ≠ k) (w... | true |
CategoryTheory.Limits.isEqualizerCompMono._proof_1 | Mathlib.CategoryTheory.Limits.Shapes.Equalizers | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {X Y : C} {f g : X ⟶ Y}
{c : CategoryTheory.Limits.Fork f g} {Z : C} (h : Y ⟶ Z),
CategoryTheory.CategoryStruct.comp c.ι (CategoryTheory.CategoryStruct.comp f h) =
CategoryTheory.CategoryStruct.comp c.ι (CategoryTheory.CategoryStruct.comp g h) | false |
MeasureTheory.Measure.instAdd._proof_2 | Mathlib.MeasureTheory.Measure.MeasureSpace | ∀ {α : Type u_1} {x : MeasurableSpace α} (μ₁ μ₂ : MeasureTheory.Measure α),
(μ₁.toOuterMeasure + μ₂.toOuterMeasure).trim ≤ μ₁.toOuterMeasure + μ₂.toOuterMeasure | false |
Filter.map₂ | Mathlib.Order.Filter.NAry | {α : Type u_1} → {β : Type u_3} → {γ : Type u_5} → (α → β → γ) → Filter α → Filter β → Filter γ | true |
Lean.Parser.Command.openRenaming | Lean.Parser.Command | Lean.Parser.Parser | true |
Order.IsPredLimit.isMin | Mathlib.Order.SuccPred.Limit | ∀ {α : Type u_1} {a : α} [inst : Preorder α] [inst_1 : PredOrder α], Order.IsPredLimit (Order.pred a) → IsMin a | true |
Real.norm_two | Mathlib.Analysis.Normed.Group.Real | ‖2‖ = 2 | true |
Std.Time.instHSubOffsetOffset_21 | Std.Time.Date.Basic | HSub Std.Time.Minute.Offset Std.Time.Hour.Offset Std.Time.Minute.Offset | true |
MeasureTheory.L2.innerProductSpace._private_1 | Mathlib.MeasureTheory.Function.L2Space | ∀ {α : Type u_1} {E : Type u_2} {𝕜 : Type u_3} [inst : RCLike 𝕜] [inst_1 : MeasurableSpace α]
{μ : MeasureTheory.Measure α} [inst_2 : NormedAddCommGroup E] [inst_3 : InnerProductSpace 𝕜 E]
(f : ↥(MeasureTheory.Lp E 2 μ)), ‖f‖ ^ 2 = RCLike.re (inner 𝕜 f f) | false |
_private.Mathlib.Data.Finset.Basic.0.Finset.erase_insert._proof_1_1 | Mathlib.Data.Finset.Basic | ∀ {α : Type u_1} [inst : DecidableEq α] {a : α} {s : Finset α}, a ∉ s → (insert a s).erase a = s | false |
Std.Internal.IO.Process.ResourceUsageStats.noConfusion | Std.Internal.Async.Process | {P : Sort u} →
{t t' : Std.Internal.IO.Process.ResourceUsageStats} →
t = t' → Std.Internal.IO.Process.ResourceUsageStats.noConfusionType P t t' | false |
_private.Mathlib.Dynamics.Ergodic.Action.Regular.0.instErgodicSMulOfIsMulLeftInvariant._simp_1 | Mathlib.Dynamics.Ergodic.Action.Regular | ∀ {α : Type u_1} {l : Filter α} {s : Set α},
Filter.EventuallyConst s l = ((∀ᶠ (x : α) in l, x ∈ s) ∨ ∀ᶠ (x : α) in l, x ∉ s) | false |
Lean.JsonRpc.instBEqErrorCode.beq | Lean.Data.JsonRpc | Lean.JsonRpc.ErrorCode → Lean.JsonRpc.ErrorCode → Bool | true |
LinearMap.map_algebraMap_mul | Mathlib.Algebra.Algebra.Basic | ∀ {R : Type u_1} {A : Type u_2} {B : Type u_3} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Semiring B]
[inst_3 : Algebra R A] [inst_4 : Algebra R B] (f : A →ₗ[R] B) (a : A) (r : R),
f ((algebraMap R A) r * a) = (algebraMap R B) r * f a | true |
MvQPF.WEquiv.casesOn | Mathlib.Data.QPF.Multivariate.Constructions.Fix | ∀ {n : ℕ} {F : TypeVec.{u} (n + 1) → Type u} [q : MvQPF F] {α : TypeVec.{u} n}
{motive : (a a_1 : (MvQPF.P F).W α) → MvQPF.WEquiv a a_1 → Prop} {a a_1 : (MvQPF.P F).W α} (t : MvQPF.WEquiv a a_1),
(∀ (a : (MvQPF.P F).A) (f' : ((MvQPF.P F).drop.B a).Arrow α) (f₀ f₁ : (MvQPF.P F).last.B a → (MvQPF.P F).W α)
(a_2... | false |
ByteArray.get_set_ne._proof_2 | Batteries.Data.ByteArray | ∀ {j : ℕ} (a : ByteArray) (i : Fin a.size), ↑i < a.size | false |
Turing.PartrecToTM2.Λ'.instDecidableEq._proof_69 | Mathlib.Computability.TuringMachine.ToPartrec | ∀ (k : Turing.PartrecToTM2.Cont') (f : Option Turing.PartrecToTM2.Γ' → Turing.PartrecToTM2.Λ'),
Turing.PartrecToTM2.Λ'.ret k = Turing.PartrecToTM2.Λ'.read f → False | false |
BialgCat.of_comul | Mathlib.Algebra.Category.BialgCat.Basic | ∀ {R : Type u} [inst : CommRing R] {X : Type v} [inst_1 : Ring X] [inst_2 : Bialgebra R X],
CoalgebraStruct.comul = CoalgebraStruct.comul | true |
FirstOrder.Language.DefinableSet.instBooleanAlgebra._proof_1 | Mathlib.ModelTheory.Definability | ∀ {L : FirstOrder.Language} {M : Type u_2} [inst : L.Structure M] {A : Set M} {α : Type u_1},
Function.Injective fun a => ↑a | false |
String.Pos.Splits.exists_eq_singleton_append_of_ne_startPos | Init.Data.String.Lemmas.Splits | ∀ {t₁ t₂ s : String} {p : s.Pos} (hp : p ≠ s.startPos),
(p.prev hp).Splits t₁ t₂ → ∃ t₂', t₂ = String.singleton ((p.prev hp).get ⋯) ++ t₂' | true |
Equiv.Perm.subtypePerm_apply_pow_of_mem | Mathlib.GroupTheory.Perm.Cycle.Basic | ∀ {α : Type u_2} {g : Equiv.Perm α} {s : Finset α} (hs : ∀ (x : α), g x ∈ s ↔ x ∈ s) {n : ℕ} {x : α} (hx : x ∈ s),
↑((g.subtypePerm hs ^ n) ⟨x, hx⟩) = (g ^ n) x | true |
Lean.Parser.instInhabitedFirstTokens | Lean.Parser.Types | Inhabited Lean.Parser.FirstTokens | true |
AccPt | Mathlib.Topology.Defs.Filter | {X : Type u_1} → [TopologicalSpace X] → X → Filter X → Prop | true |
Filter.HasBasis.uniformity_of_nhds_zero_neg_add_swapped | Mathlib.Topology.Algebra.IsUniformGroup.Defs | ∀ {α : Type u_1} [inst : UniformSpace α] [inst_1 : AddGroup α] [IsUniformAddGroup α] {ι : Sort u_3} {p : ι → Prop}
{U : ι → Set α}, (nhds 0).HasBasis p U → (uniformity α).HasBasis p fun i => {x | -x.2 + x.1 ∈ U i} | true |
WellFoundedLT.toWellFoundedRelation.eq_1 | Mathlib.Order.RelClasses | ∀ {α : Type u} [inst : LT α] [inst_1 : WellFoundedLT α],
WellFoundedLT.toWellFoundedRelation = IsWellFounded.toWellFoundedRelation fun x1 x2 => x1 < x2 | true |
OreLocalization.«_aux_Mathlib_GroupTheory_OreLocalization_Basic___macroRules_OreLocalization_term_-ₒ__1» | Mathlib.GroupTheory.OreLocalization.Basic | Lean.Macro | false |
_private.Lean.Elab.Task.0.Lean.Elab.Tactic.TacticM.asTask.match_1 | Lean.Elab.Task | {α : Type} →
(motive : α × Lean.Elab.Tactic.State → Sort u_1) →
(__discr : α × Lean.Elab.Tactic.State) → ((a : α) → (s : Lean.Elab.Tactic.State) → motive (a, s)) → motive __discr | false |
_private.Std.Tactic.BVDecide.LRAT.Internal.Convert.0.Std.Tactic.BVDecide.LRAT.Internal.CNF.unsat_of_convertLRAT_unsat._simp_1_5 | Std.Tactic.BVDecide.LRAT.Internal.Convert | ∀ {α : Sort u_1} {p : α → Prop} {a' : α}, (∃ a, p a ∧ a = a') = p a' | false |
AlgHom.coe_prod | Mathlib.Algebra.Algebra.Prod | ∀ {R : Type u_1} {A : Type u_2} {B : Type u_3} {C : Type u_4} [inst : CommSemiring R] [inst_1 : Semiring A]
[inst_2 : Algebra R A] [inst_3 : Semiring B] [inst_4 : Algebra R B] [inst_5 : Semiring C] [inst_6 : Algebra R C]
(f : A →ₐ[R] B) (g : A →ₐ[R] C), ⇑(f.prod g) = Pi.prod ⇑f ⇑g | true |
PiLp.norm_toLp_const | Mathlib.Analysis.Normed.Lp.PiLp | ∀ {p : ENNReal} {ι : Type u_2} [hp : Fact (1 ≤ p)] [inst : Fintype ι] {β : Type u_5}
[inst_1 : SeminormedAddCommGroup β],
p ≠ ⊤ → ∀ (b : β), ‖WithLp.toLp p (Function.const ι b)‖ = ↑↑(Fintype.card ι) ^ (1 / p).toReal * ‖b‖ | true |
Lean.Meta.Grind.Arith.Cutsat.EqCnstrProof | Lean.Meta.Tactic.Grind.Arith.Cutsat.Types | Type | true |
_private.Mathlib.Algebra.Lie.Abelian.0.LieSubalgebra.isLieAbelian_lieSpan_iff._simp_1_3 | Mathlib.Algebra.Lie.Abelian | ∀ {α : Sort u} {p : α → Prop} {a1 a2 : { x // p x }}, (a1 = a2) = (↑a1 = ↑a2) | false |
RingHom.IsStableUnderBaseChange | Mathlib.RingTheory.RingHomProperties | ({R S : Type u} → [inst : CommRing R] → [inst_1 : CommRing S] → (R →+* S) → Prop) → Prop | true |
Filter.coprod_inf_prod_le | Mathlib.Order.Filter.Prod | ∀ {α : Type u_1} {β : Type u_2} (f₁ f₂ : Filter α) (g₁ g₂ : Filter β), f₁.coprod g₁ ⊓ f₂ ×ˢ g₂ ≤ f₁ ×ˢ g₂ ⊔ f₂ ×ˢ g₁ | true |
Lean.Lsp.SignatureHelpTriggerKind.invoked.sizeOf_spec | Lean.Data.Lsp.LanguageFeatures | sizeOf Lean.Lsp.SignatureHelpTriggerKind.invoked = 1 | true |
PSigma.Lex.linearOrder._proof_1 | Mathlib.Data.PSigma.Order | ∀ {ι : Type u_2} {α : ι → Type u_1} [inst : LinearOrder ι] [inst_1 : (i : ι) → LinearOrder (α i)]
(a b : Σₗ' (i : ι), α i), a ≤ b ∨ b ≤ a | false |
_private.Mathlib.Data.Set.Insert.0.Set.subset_pair_iff._proof_1_1 | Mathlib.Data.Set.Insert | ∀ {α : Type u_1} {s : Set α} {a b : α}, s ⊆ {a, b} ↔ ∀ x ∈ s, x = a ∨ x = b | false |
Order.Icc_subset_Ioc_pred_left | Mathlib.Order.SuccPred.Basic | ∀ {α : Type u_1} [inst : Preorder α] [inst_1 : PredOrder α] [NoMinOrder α] (a b : α),
Set.Icc b a ⊆ Set.Ioc (Order.pred b) a | true |
Mathlib.Tactic.Ring.sub_congr | Mathlib.Tactic.Ring.Common | ∀ {R : Type u_2} [inst : CommRing R] {a a' b b' c : R}, a = a' → b = b' → a' - b' = c → a - b = c | true |
MeasCat | Mathlib.MeasureTheory.Category.MeasCat | Type (u + 1) | true |
Lean.Meta.DefEqContext._sizeOf_1 | Lean.Meta.Basic | Lean.Meta.DefEqContext → ℕ | false |
Lean.OLeanLevel.server.elim | Lean.Environment | {motive : Lean.OLeanLevel → Sort u} → (t : Lean.OLeanLevel) → t.ctorIdx = 1 → motive Lean.OLeanLevel.server → motive t | false |
Std.ExtHashMap.getKey!_eq_of_contains | Std.Data.ExtHashMap.Lemmas | ∀ {α : Type u} {β : Type v} {x : BEq α} {x_1 : Hashable α} {m : Std.ExtHashMap α β} [inst : LawfulBEq α]
[inst_1 : Inhabited α] {k : α}, m.contains k = true → m.getKey! k = k | true |
TopologicalSpace.IsTopologicalBasis.recOn | Mathlib.Topology.Bases | {α : Type u} →
[t : TopologicalSpace α] →
{s : Set (Set α)} →
{motive : TopologicalSpace.IsTopologicalBasis s → Sort u_1} →
(t_1 : TopologicalSpace.IsTopologicalBasis s) →
((exists_subset_inter : ∀ t₁ ∈ s, ∀ t₂ ∈ s, ∀ x ∈ t₁ ∩ t₂, ∃ t₃ ∈ s, x ∈ t₃ ∧ t₃ ⊆ t₁ ∩ t₂) →
(sUnion_eq... | false |
_private.Init.Data.Array.Attach.0.Array.pmap_eq_self._simp_1_1 | Init.Data.Array.Attach | ∀ {α : Type u_1} {l : List α} {p : α → Prop} {hp : ∀ a ∈ l, p a} {f : (a : α) → p a → α},
(List.pmap f l hp = l) = ∀ (a : α) (h : a ∈ l), f a ⋯ = a | false |
Lean.Elab.Do.ReturnCont.mk.injEq | Lean.Elab.Do.Basic | ∀ (resultType : Lean.Expr) (k : Lean.Expr → Lean.Elab.Do.DoElabM Lean.Expr) (resultType_1 : Lean.Expr)
(k_1 : Lean.Expr → Lean.Elab.Do.DoElabM Lean.Expr),
({ resultType := resultType, k := k } = { resultType := resultType_1, k := k_1 }) =
(resultType = resultType_1 ∧ k = k_1) | true |
CategoryTheory.shiftEquiv'._proof_1 | Mathlib.CategoryTheory.Shift.Basic | ∀ {A : Type u_1} [inst : AddGroup A] (i j : A), i + j = 0 → j + i = 0 | false |
CategoryTheory.MonoidalCategory.MonoidalRightAction.monoidalOppositeRightAction_actionHomLeft | Mathlib.CategoryTheory.Monoidal.Action.Opposites | ∀ (C : Type u_1) (D : Type u_2) [inst : CategoryTheory.Category.{v_1, u_1} C]
[inst_1 : CategoryTheory.MonoidalCategory C] [inst_2 : CategoryTheory.Category.{v_2, u_2} D]
[inst_3 : CategoryTheory.MonoidalCategory.MonoidalLeftAction C D] {d d' : D} (f : d ⟶ d') (c : Cᴹᵒᵖ),
CategoryTheory.MonoidalCategory.MonoidalR... | true |
Lean.Elab.Tactic.Rfl.evalApplyRfl._regBuiltin.Lean.Elab.Tactic.Rfl.evalApplyRfl_1 | Lean.Elab.Tactic.Rfl | IO Unit | false |
LinearMap.applyₗ._proof_1 | Mathlib.Algebra.Module.LinearMap.End | ∀ {R : Type u_1} {M₂ : Type u_2} [inst : CommSemiring R] [inst_1 : AddCommMonoid M₂] [inst_2 : Module R M₂],
SMulCommClass R R M₂ | false |
Representation.ofMulActionSelfAsModuleEquiv._proof_4 | Mathlib.RepresentationTheory.Basic | ∀ {k : Type u_1} {G : Type u_2} [inst : CommSemiring k] [inst_1 : Group G],
Function.LeftInverse (Representation.ofMulAction k G G).asModuleEquiv.toAddEquiv.invFun
(Representation.ofMulAction k G G).asModuleEquiv.toAddEquiv.toFun | false |
AlgebraicGeometry.Scheme.Cover.copy._proof_2 | Mathlib.AlgebraicGeometry.Cover.MorphismProperty | ∀ {P : CategoryTheory.MorphismProperty AlgebraicGeometry.Scheme} [P.RespectsIso] {X : AlgebraicGeometry.Scheme}
(𝒰 : AlgebraicGeometry.Scheme.Cover (AlgebraicGeometry.Scheme.precoverage P) X) (J : Type u_2)
(obj : J → AlgebraicGeometry.Scheme) (map : (i : J) → obj i ⟶ X) (e₁ : J ≃ 𝒰.I₀) (e₂ : (i : J) → obj i ≅ 𝒰... | false |
Std.DHashMap.Const.get!_union_of_not_mem_right | Std.Data.DHashMap.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {β : Type v} {m₁ m₂ : Std.DHashMap α fun x => β} [EquivBEq α]
[LawfulHashable α] [inst : Inhabited β] {k : α},
k ∉ m₂ → Std.DHashMap.Const.get! (m₁.union m₂) k = Std.DHashMap.Const.get! m₁ k | true |
absConvexHull_nonempty | Mathlib.Analysis.LocallyConvex.AbsConvex | ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : SeminormedRing 𝕜] [inst_1 : SMul 𝕜 E] [inst_2 : AddCommMonoid E]
[inst_3 : PartialOrder 𝕜] {s : Set E}, ((absConvexHull 𝕜) s).Nonempty ↔ s.Nonempty | true |
ZFSet.vonNeumann_inj._simp_1 | Mathlib.SetTheory.ZFC.VonNeumann | ∀ {a b : Ordinal.{u}}, (ZFSet.vonNeumann a = ZFSet.vonNeumann b) = (a = b) | false |
CategoryTheory.PreOneHypercover.map_Y | Mathlib.CategoryTheory.Sites.Continuous | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
{X : C} (E : CategoryTheory.PreOneHypercover X) (F : CategoryTheory.Functor C D) (x x_1 : E.I₀) (j : E.I₁ x x_1),
(E.map F).Y j = F.obj (E.Y j) | true |
Polynomial.roots_expand_map_frobenius | Mathlib.FieldTheory.Perfect | ∀ {R : Type u_1} [inst : CommRing R] [inst_1 : IsDomain R] {p : ℕ} [inst_2 : ExpChar R p] {f : Polynomial R}
[PerfectRing R p], Multiset.map (⇑(frobenius R p)) ((Polynomial.expand R p) f).roots = p • f.roots | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.