name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
ModularForm.instGCommRing._proof_13 | Mathlib.NumberTheory.ModularForms.Basic | ∀ (Γ : Subgroup (GL (Fin 2) ℝ)) [inst : Γ.HasDetPlusMinusOne] (x : ℕ), ↑(Int.negSucc x) = -↑(x + 1) | false |
Std.DTreeMap.Internal.RioSliceData.mk.sizeOf_spec | Std.Data.DTreeMap.Internal.Zipper | ∀ {α : Type u} {β : α → Type v} [inst : Ord α] [inst_1 : SizeOf α] [inst_2 : (a : α) → SizeOf (β a)]
(treeMap : Std.DTreeMap.Internal.Impl α β) (range : Std.Rio α),
sizeOf { treeMap := treeMap, range := range } = 1 + sizeOf treeMap + sizeOf range | true |
AlgebraicIndependent.to_subtype_range' | Mathlib.RingTheory.AlgebraicIndependent.Basic | ∀ {ι : Type u} {R : Type u_2} {A : Type v} {x : ι → A} [inst : CommRing R] [inst_1 : CommRing A] [inst_2 : Algebra R A],
AlgebraicIndependent R x → ∀ {t : Set A}, Set.range x = t → AlgebraicIndependent R Subtype.val | true |
MeasureTheory.FiniteMeasure.restrict_mass | Mathlib.MeasureTheory.Measure.FiniteMeasure | ∀ {Ω : Type u_1} [inst : MeasurableSpace Ω] (μ : MeasureTheory.FiniteMeasure Ω) (A : Set Ω), (μ.restrict A).mass = μ A | true |
IsAddUnit.addUnit' | Mathlib.Algebra.Group.Units.Defs | {α : Type u} → [inst : SubtractionMonoid α] → {a : α} → IsAddUnit a → AddUnits α | true |
Std.DHashMap.Const.get?_inter_of_mem_right | Std.Data.DHashMap.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {β : Type v} {m₁ m₂ : Std.DHashMap α fun x => β} [EquivBEq α]
[LawfulHashable α] {k : α}, k ∈ m₂ → Std.DHashMap.Const.get? (m₁.inter m₂) k = Std.DHashMap.Const.get? m₁ k | true |
Lean.Widget.instRpcEncodableInfoPopup.dec._@.Lean.Server.FileWorker.WidgetRequests.2734021171._hygCtx._hyg.1 | Lean.Server.FileWorker.WidgetRequests | Lean.Json → ExceptT String (ReaderT Lean.Server.RpcObjectStore Id) Lean.Widget.InfoPopup | false |
LSeries.term_of_ne_zero | Mathlib.NumberTheory.LSeries.Basic | ∀ {n : ℕ}, n ≠ 0 → ∀ (f : ℕ → ℂ) (s : ℂ), LSeries.term f s n = f n / ↑n ^ s | true |
NonarchAddGroupSeminormClass.map_neg_eq_map' | Mathlib.Analysis.Normed.Group.Seminorm | ∀ {F : Type u_6} {α : outParam (Type u_7)} {inst : AddGroup α} {inst_1 : FunLike F α ℝ}
[self : NonarchAddGroupSeminormClass F α] (f : F) (a : α), f (-a) = f a | true |
Lean.Meta.EtaStructMode.none.sizeOf_spec | Init.MetaTypes | sizeOf Lean.Meta.EtaStructMode.none = 1 | true |
CategoryTheory.projectiveDimension_eq_zero_iff | Mathlib.CategoryTheory.Abelian.Projective.Dimension | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Abelian C] (X : C),
CategoryTheory.projectiveDimension X = 0 ↔ CategoryTheory.Projective X ∧ ¬CategoryTheory.Limits.IsZero X | true |
List.dropWhile_cons_of_neg | Init.Data.List.TakeDrop | ∀ {α : Type u_1} {p : α → Bool} {a : α} {l : List α}, ¬p a = true → List.dropWhile p (a :: l) = a :: l | true |
_private.Mathlib.Data.Finset.NatDivisors.0.Nat.divisors_mul._simp_1_4 | Mathlib.Data.Finset.NatDivisors | ∀ {M₀ : Type u_1} [inst : MulZeroClass M₀] [NoZeroDivisors M₀] {a b : M₀}, (a * b ≠ 0) = (a ≠ 0 ∧ b ≠ 0) | false |
Function.iterate_id | Mathlib.Logic.Function.Iterate | ∀ {α : Type u} (n : ℕ), id^[n] = id | true |
Std.Tactic.BVDecide.BVExpr.arithShiftRight | Std.Tactic.BVDecide.Bitblast.BVExpr.Basic | {m n : ℕ} → Std.Tactic.BVDecide.BVExpr m → Std.Tactic.BVDecide.BVExpr n → Std.Tactic.BVDecide.BVExpr m | true |
Sigma.instLT_mathlib | Mathlib.Data.Sigma.Order | {ι : Type u_1} → {α : ι → Type u_2} → [(i : ι) → LT (α i)] → LT ((i : ι) × α i) | true |
UpperSet.compl_bot | Mathlib.Order.UpperLower.CompleteLattice | ∀ {α : Type u_1} [inst : LE α], ⊥.compl = ⊥ | true |
Prod.normedCommRing._proof_16 | Mathlib.Analysis.Normed.Ring.Basic | ∀ {α : Type u_1} {β : Type u_2} [inst : NormedCommRing α] [inst_1 : NormedCommRing β] (n : ℕ) (a : α × β),
SubNegMonoid.zsmul (Int.negSucc n) a = -SubNegMonoid.zsmul (↑n.succ) a | false |
Qq.Impl.UnquoteState.mk | Qq.Macro | List (Lean.Expr × Qq.Impl.MVarSynth) →
Std.HashMap Lean.Expr Lean.Level →
Std.HashMap Lean.Expr Lean.Expr →
Lean.LocalContext →
Std.HashMap Lean.Expr Qq.Impl.ExprBackSubstResult →
Std.HashMap Lean.Level Lean.Expr → Array Lean.FVarId → List Lean.Name → Bool → Qq.Impl.UnquoteState | true |
Lean.Meta.allowCompletion | Lean.Meta.CompletionName | Lean.Environment → Lean.Name → Bool | true |
Array.scanlM.loop._unsafe_rec | Batteries.Data.Array.Basic | {m : Type u_1 → Type u_2} →
{β : Type u_1} →
{α : Type u_3} →
[Monad m] → (β → α → m β) → β → (as : Array α) → ℕ → (stop : ℕ) → stop ≤ as.size → Array β → m (Array β) | false |
Mathlib.Meta.FunProp.FunctionTheorems.mk | Mathlib.Tactic.FunProp.Theorems | Std.TreeMap Lean.Name (Std.TreeMap Lean.Name (Array Mathlib.Meta.FunProp.FunctionTheorem) Lean.Name.quickCmp)
Lean.Name.quickCmp →
Mathlib.Meta.FunProp.FunctionTheorems | true |
Mathlib.Tactic.Linarith.GlobalBranchingPreprocessor.transform | Mathlib.Tactic.Linarith.Datatypes | Mathlib.Tactic.Linarith.GlobalBranchingPreprocessor →
Lean.MVarId → List Lean.Expr → Lean.MetaM (List Mathlib.Tactic.Linarith.Branch) | true |
Lean.Meta.Grind.Arith.Linear.DiseqCnstrProof.neg.sizeOf_spec | Lean.Meta.Tactic.Grind.Arith.Linear.Types | ∀ (c : Lean.Meta.Grind.Arith.Linear.DiseqCnstr),
sizeOf (Lean.Meta.Grind.Arith.Linear.DiseqCnstrProof.neg c) = 1 + sizeOf c | true |
AddSubmonoid.IsLocalizationMap.map_addUnits | Mathlib.GroupTheory.MonoidLocalization.Basic | ∀ {M : Type u_1} [inst : AddCommMonoid M] {N : Type u_2} [inst_1 : AddCommMonoid N] {S : AddSubmonoid M} {f : M → N},
S.IsLocalizationMap f → ∀ (y : ↥S), IsAddUnit (f ↑y) | true |
Std.DTreeMap.Raw.get!_modify_self | Std.Data.DTreeMap.Raw.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t : Std.DTreeMap.Raw α β cmp} [Std.TransCmp cmp]
[inst : Std.LawfulEqCmp cmp],
t.WF → ∀ {k : α} [inst_1 : Inhabited (β k)] {f : β k → β k}, (t.modify k f).get! k = (Option.map f (t.get? k)).get! | true |
Mathlib.Tactic.Order.ToInt.toInt_eq_toInt | Mathlib.Tactic.Order.ToInt | ∀ {α : Type u_1} [inst : LinearOrder α] {n : ℕ} (val : Fin n → α) (i j : Fin n),
Mathlib.Tactic.Order.ToInt.toInt val i = Mathlib.Tactic.Order.ToInt.toInt val j ↔ val i = val j | true |
_private.Mathlib.Combinatorics.Matroid.Minor.Contract.0.Matroid.contract_closure_eq.match_1_3 | Mathlib.Combinatorics.Matroid.Minor.Contract | ∀ {α : Type u_1} (M : Matroid α) (C X : Set α) (e : α) (motive : e ∈ (M.contract C).closure X ∩ X → Prop)
(x : e ∈ (M.contract C).closure X ∩ X), (∀ (he : e ∈ (M.contract C).closure X) (he' : e ∈ X), motive ⋯) → motive x | false |
Mathlib.Tactic.BicategoryLike.MonadNormalizeNaturality.mkNaturalityHorizontalComp | Mathlib.Tactic.CategoryTheory.Coherence.PureCoherence | {m : Type → Type} →
[self : Mathlib.Tactic.BicategoryLike.MonadNormalizeNaturality m] →
Mathlib.Tactic.BicategoryLike.NormalizedHom →
Mathlib.Tactic.BicategoryLike.NormalizedHom →
Mathlib.Tactic.BicategoryLike.NormalizedHom →
Mathlib.Tactic.BicategoryLike.Mor₁ →
Mathlib.Tactic.... | true |
_private.Mathlib.MeasureTheory.Function.Piecewise.0.IndexedPartition.stronglyMeasurable_piecewise._proof_1_12 | Mathlib.MeasureTheory.Function.Piecewise | ∀ (y b : ℕ), b ≥ y + 1 → y < b | false |
CategoryTheory.TwoSquare.costructuredArrowDownwardsPrecomp._proof_7 | Mathlib.CategoryTheory.GuitartExact.Basic | ∀ {C₁ : Type u_4} {C₂ : Type u_2} {C₃ : Type u_6} {C₄ : Type u_8} [inst : CategoryTheory.Category.{u_3, u_4} C₁]
[inst_1 : CategoryTheory.Category.{u_1, u_2} C₂] [inst_2 : CategoryTheory.Category.{u_5, u_6} C₃]
[inst_3 : CategoryTheory.Category.{u_7, u_8} C₄] {T : CategoryTheory.Functor C₁ C₂} {L : CategoryTheory.F... | false |
Lean.Parser.Command.initialize._regBuiltin.Lean.Parser.Command.initialize_1 | Lean.Parser.Command | IO Unit | false |
Profinite.NobelingProof.ProjRestricts | Mathlib.Topology.Category.Profinite.Nobeling.Basic | {I : Type u} →
(C : Set (I → Bool)) →
{J K : I → Prop} →
[inst : (i : I) → Decidable (J i)] →
[inst_1 : (i : I) → Decidable (K i)] →
(∀ (i : I), J i → K i) → ↑(Profinite.NobelingProof.π C K) → ↑(Profinite.NobelingProof.π C J) | true |
Lean.MonadCacheT.instMonadRef._aux_1 | Lean.Util.MonadCache | {ω α β : Type} →
{m : Type → Type} →
[inst : STWorld ω m] →
[inst_1 : BEq α] → [inst_2 : Hashable α] → [Lean.MonadRef m] → Lean.MonadCacheT α β m Lean.Syntax | false |
CategoryTheory.Lax.LaxTrans.Hom.of._flat_ctor | Mathlib.CategoryTheory.Bicategory.Modification.Lax | {B : Type u₁} →
[inst : CategoryTheory.Bicategory B] →
{C : Type u₂} →
[inst_1 : CategoryTheory.Bicategory C] →
{F G : CategoryTheory.LaxFunctor B C} →
{η θ : F ⟶ G} → CategoryTheory.Lax.LaxTrans.Modification η θ → CategoryTheory.Lax.LaxTrans.Hom η θ | false |
AddOreLocalization.vadd_sub_zero | Mathlib.GroupTheory.OreLocalization.Basic | ∀ {R : Type u_1} [inst : AddMonoid R] {S : AddSubmonoid R} [inst_1 : AddOreLocalization.AddOreSet S] {X : Type u_2}
[inst_2 : AddAction R X] {p : R} {r : X} {s : ↥S}, (p -ₒ s) +ᵥ r -ₒ 0 = (p +ᵥ r) -ₒ s | true |
OmegaCompletePartialOrder.Chain.pair | Mathlib.Order.OmegaCompletePartialOrder | {α : Type u_2} → [inst : Preorder α] → (a b : α) → a ≤ b → OmegaCompletePartialOrder.Chain α | true |
IntermediateField.algHomEquivAlgHomOfSplits._proof_1 | Mathlib.FieldTheory.IsAlgClosed.Basic | ∀ {F : Type u_2} {K : Type u_3} (A : Type u_1) [inst : Field F] [inst_1 : Field K] [inst_2 : Field A]
[inst_3 : Algebra F K] [inst_4 : Algebra F A] (L : IntermediateField F A),
(∀ (x : K), (Polynomial.map (algebraMap F ↥L) (minpoly F x)).Splits) →
∀ (f : K →ₐ[F] A) (x : K), (Polynomial.map (algebraMap F ↥L) (mi... | false |
_private.Mathlib.GroupTheory.CommutingProbability.0.commProb_prod._simp_1_3 | Mathlib.GroupTheory.CommutingProbability | ∀ {α : Type u} {β : Type v} {x y : α × β}, (x = y) = (x.1 = y.1 ∧ x.2 = y.2) | false |
CategoryTheory.bicategoricalIsoComp.eq_1 | Mathlib.Tactic.CategoryTheory.Bicategory.Datatypes | ∀ {B : Type u} [inst : CategoryTheory.Bicategory B] {a b : B} {f g h i : a ⟶ b}
[inst_1 : CategoryTheory.BicategoricalCoherence g h] (η : f ≅ g) (θ : h ≅ i),
CategoryTheory.bicategoricalIsoComp η θ = η ≪≫ CategoryTheory.BicategoricalCoherence.iso ≪≫ θ | true |
closure_eq_self_union_derivedSet | Mathlib.Topology.DerivedSet | ∀ {X : Type u_1} [inst : TopologicalSpace X] (A : Set X), closure A = A ∪ derivedSet A | true |
_private.Lean.Meta.CongrTheorems.0.Lean.Meta.hasCastLike | Lean.Meta.CongrTheorems | Array Lean.Meta.CongrArgKind → Bool | true |
CategoryTheory.ShortComplex.Homotopy.rightHomologyMap'_congr | Mathlib.Algebra.Homology.ShortComplex.Preadditive | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Preadditive C]
{S₁ S₂ : CategoryTheory.ShortComplex C} {φ₁ φ₂ : S₁ ⟶ S₂} (h : CategoryTheory.ShortComplex.Homotopy φ₁ φ₂)
(h₁ : S₁.RightHomologyData) (h₂ : S₂.RightHomologyData),
CategoryTheory.ShortComplex.rightHomologyMap' φ... | true |
IsSimpleOrder.casesOn | Mathlib.Order.Atoms | {α : Type u_4} →
[inst : LE α] →
[inst_1 : BoundedOrder α] →
{motive : IsSimpleOrder α → Sort u} →
(t : IsSimpleOrder α) →
([toNontrivial : Nontrivial α] → (eq_bot_or_eq_top : ∀ (a : α), a = ⊥ ∨ a = ⊤) → motive ⋯) → motive t | false |
Lean.NamingContext | Lean.Message | Type | true |
Mathlib.Tactic.Monoidal.mkContext? | Mathlib.Tactic.CategoryTheory.Monoidal.Datatypes | Lean.Expr → Lean.MetaM (Option Mathlib.Tactic.Monoidal.Context) | true |
Nat.le.step | Init.Prelude | ∀ {n m : ℕ}, n.le m → n.le m.succ | true |
StrictMono.strictAnti_iterate_of_map_lt | Mathlib.Order.Iterate | ∀ {α : Type u_1} [inst : Preorder α] {f : α → α} {x : α}, StrictMono f → f x < x → StrictAnti fun n => f^[n] x | true |
Matroid.not_isNonloop_iff._simp_1 | Mathlib.Combinatorics.Matroid.Loop | ∀ {α : Type u_1} {M : Matroid α} {e : α},
autoParam (e ∈ M.E) Matroid.not_isNonloop_iff._auto_1 → (¬M.IsNonloop e) = M.IsLoop e | false |
_private.Mathlib.Order.Interval.Finset.Fin.0.Fin.finsetImage_rev_Ioc._simp_1_1 | Mathlib.Order.Interval.Finset.Fin | ∀ {α : Type u_1} {s₁ s₂ : Finset α}, (s₁ = s₂) = (↑s₁ = ↑s₂) | false |
Nat.getElem_toList_roc | Init.Data.Range.Polymorphic.NatLemmas | ∀ {m n i : ℕ} (_h : i < (m<...=n).toList.length), (m<...=n).toList[i] = m + 1 + i | true |
Finset.univ_nonempty._simp_1 | Mathlib.Data.Finset.BooleanAlgebra | ∀ {α : Type u_1} [inst : Fintype α] [Nonempty α], Finset.univ.Nonempty = True | false |
_private.Mathlib.Data.Finset.Disjoint.0.Finset.disjoint_coe._simp_1_2 | Mathlib.Data.Finset.Disjoint | ∀ {α : Type u} {s t : Set α}, Disjoint s t = ∀ ⦃a : α⦄, a ∈ s → a ∉ t | false |
Lean.Compiler.LCNF.LitValue.uint16 | Lean.Compiler.LCNF.Basic | UInt16 → Lean.Compiler.LCNF.LitValue | true |
WittVector.wittMulN._f | Mathlib.RingTheory.WittVector.MulP | (p : ℕ) →
[hp : Fact (Nat.Prime p)] → (x : ℕ) → Nat.below (motive := fun x => ℕ → MvPolynomial ℕ ℤ) x → ℕ → MvPolynomial ℕ ℤ | false |
BddOrd._sizeOf_1 | Mathlib.Order.Category.BddOrd | BddOrd → ℕ | false |
CategoryTheory.SingleFunctors.Hom.mk.sizeOf_spec | Mathlib.CategoryTheory.Shift.SingleFunctors | ∀ {C : Type u_1} {D : Type u_2} [inst : CategoryTheory.Category.{v_1, u_1} C]
[inst_1 : CategoryTheory.Category.{v_2, u_2} D] {A : Type u_5} [inst_2 : AddMonoid A]
[inst_3 : CategoryTheory.HasShift D A] {F G : CategoryTheory.SingleFunctors C D A} [inst_4 : SizeOf C]
[inst_5 : SizeOf D] [inst_6 : SizeOf A] (hom : ... | true |
_private.Mathlib.GroupTheory.SpecificGroups.Alternating.0.Equiv.Perm.closure_cycleType_eq_two_two_eq_alternatingGroup._proof_1_16 | Mathlib.GroupTheory.SpecificGroups.Alternating | ∀ {α : Type u_1} [inst : Fintype α] [inst_1 : DecidableEq α] ⦃g : Equiv.Perm α⦄ (a : α),
g.support = {a, g a, g (g a)} →
[a, g a, g (g a)].Nodup → ∀ (b c : α), b ∈ g.supportᶜ → c ∈ g.supportᶜ → b ≠ c → [b, c, g a, g (g a)].Nodup | false |
AList._sizeOf_1 | Mathlib.Data.List.AList | {α : Type u} → {β : α → Type v} → [SizeOf α] → [(a : α) → SizeOf (β a)] → AList β → ℕ | false |
_private.Lean.Meta.Injective.0.Lean.Meta.mkInjectiveEqTheoremValue.match_1 | Lean.Meta.Injective | (motive : List Lean.MVarId → Sort u_1) →
(__x : List Lean.MVarId) →
((mvarId₂' : Lean.MVarId) → motive [mvarId₂']) → ((x : List Lean.MVarId) → motive x) → motive __x | false |
Ordering.isLE._sparseCasesOn_1 | Init.Data.Ord.Basic | {motive : Ordering → Sort u} → (t : Ordering) → motive Ordering.gt → (Nat.hasNotBit 4 t.ctorIdx → motive t) → motive t | false |
Std.DTreeMap.keys_filter | Std.Data.DTreeMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t : Std.DTreeMap α β cmp} [inst : Std.TransCmp cmp]
[inst_1 : Std.LawfulEqCmp cmp] {f : (a : α) → β a → Bool},
(Std.DTreeMap.filter f t).keys =
(List.filter
(fun x =>
match x with
| ⟨x, h'⟩ => f x (t.get x ⋯))
t.keys.a... | true |
SimpleGraph.ConnectedComponent.maximal_connected_induce_supp | Mathlib.Combinatorics.SimpleGraph.Connectivity.Connected | ∀ {V : Type u} {G : SimpleGraph V} (C : G.ConnectedComponent),
Maximal (fun x => (SimpleGraph.induce x G).Connected) C.supp | true |
Matroid.sigma._proof_9 | Mathlib.Combinatorics.Matroid.Sum | ∀ {ι : Type u_1} {α : ι → Type u_2} (M : (i : ι) → Matroid (α i)) (B₁ B₂ : Set ((i : ι) × α i)),
(fun B => ∀ (i : ι), (M i).IsBase (Sigma.mk i ⁻¹' B)) B₁ →
(fun B => ∀ (i : ι), (M i).IsBase (Sigma.mk i ⁻¹' B)) B₂ →
∀ a ∈ B₁ \ B₂, ∃ b ∈ B₂ \ B₁, (fun B => ∀ (i : ι), (M i).IsBase (Sigma.mk i ⁻¹' B)) (insert b... | false |
CategoryTheory.ExactFunctor.forget | Mathlib.CategoryTheory.Limits.ExactFunctor | (C : Type u₁) →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
(D : Type u₂) →
[inst_1 : CategoryTheory.Category.{v₂, u₂} D] → CategoryTheory.Functor (C ⥤ₑ D) (CategoryTheory.Functor C D) | true |
Bool.lt_irrefl._simp_1 | Init.Data.Bool | ∀ (x : Bool), (x < x) = False | false |
_private.Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Cpop.0.Std.Tactic.BVDecide.BVExpr.bitblast.denote_blastCpop._proof_1_2 | Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Cpop | ∀ {w : ℕ}, ¬1 < w → ¬0 < w → ¬w = 0 → False | false |
Int.negSucc_not_nonneg | Init.Data.Int.Order | ∀ (n : ℕ), 0 ≤ Int.negSucc n ↔ False | true |
PreValuationRing.recOn | Mathlib.RingTheory.Valuation.ValuationRing | {A : Type u} →
[inst : Mul A] →
{motive : PreValuationRing A → Sort u_1} →
(t : PreValuationRing A) → ((cond' : ∀ (a b : A), ∃ c, a * c = b ∨ b * c = a) → motive ⋯) → motive t | false |
Mathlib.Tactic.GCongr.ForwardExt.recOn | Mathlib.Tactic.GCongr.ForwardAttr | {motive : Mathlib.Tactic.GCongr.ForwardExt → Sort u} →
(t : Mathlib.Tactic.GCongr.ForwardExt) →
((eval : Lean.Expr → Lean.MVarId → Lean.MetaM Unit) → motive { eval := eval }) → motive t | false |
Lean.Firefox.Profile.casesOn | Lean.Util.Profiler | {motive : Lean.Firefox.Profile → Sort u} →
(t : Lean.Firefox.Profile) →
((«meta» : Lean.Firefox.ProfileMeta) →
(libs : Array Lean.Json) →
(threads : Array Lean.Firefox.Thread) → motive { «meta» := «meta», libs := libs, threads := threads }) →
motive t | false |
AkraBazziRecurrence.growsPolynomially_one_add_smoothingFn | Mathlib.Computability.AkraBazzi.SumTransform | AkraBazziRecurrence.GrowsPolynomially fun x => 1 + AkraBazziRecurrence.smoothingFn x | true |
CategoryTheory.Functor.Monoidal.μNatIso | Mathlib.CategoryTheory.Monoidal.Functor | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
[inst_1 : CategoryTheory.MonoidalCategory C] →
{D : Type u₂} →
[inst_2 : CategoryTheory.Category.{v₂, u₂} D] →
[inst_3 : CategoryTheory.MonoidalCategory D] →
(F : CategoryTheory.Functor C D) →
[F.Monoid... | true |
_private.Mathlib.Geometry.Euclidean.Angle.Incenter.0.Affine.Triangle.oangle_excenter_singleton_eq_add_pi._proof_1_2 | Mathlib.Geometry.Euclidean.Angle.Incenter | ∀ {V : Type u_2} {P : Type u_1} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V] [inst_2 : MetricSpace P]
[inst_3 : NormedAddTorsor V P] (t : Affine.Triangle ℝ P) {i₃ : Fin 3},
Nonempty ↥(affineSpan ℝ (Set.range (Affine.Simplex.faceOpposite t i₃).points)) | false |
SubmodulesBasis.recOn | Mathlib.Topology.Algebra.Nonarchimedean.Bases | {ι : Type u_1} →
{R : Type u_2} →
[inst : CommRing R] →
{M : Type u_4} →
[inst_1 : AddCommGroup M] →
[inst_2 : Module R M] →
[inst_3 : TopologicalSpace R] →
{B : ι → Submodule R M} →
{motive : SubmodulesBasis B → Sort u} →
(t : Su... | false |
_private.Mathlib.RingTheory.Etale.QuasiFinite.0.Algebra.exists_etale_isIdempotentElem_forall_liesOver_eq_aux₂._simp_1_2 | Mathlib.RingTheory.Etale.QuasiFinite | ∀ {R : Type uR} {A₁ : Type uA₁} {A₂ : Type uA₂} [inst : CommSemiring R] [inst_1 : Semiring A₁] [inst_2 : Semiring A₂]
[inst_3 : Algebra R A₁] [inst_4 : Algebra R A₂] (e : A₁ ≃ₐ[R] A₂), ↑e = ↑↑e | false |
AddMonCat.Hom.ext | Mathlib.Algebra.Category.MonCat.Basic | ∀ {A B : AddMonCat} {x y : A.Hom B}, x.hom' = y.hom' → x = y | true |
Std.HashMap.Raw.Equiv.beq | Std.Data.HashMap.RawLemmas | ∀ {α : Type u} [inst : BEq α] [inst_1 : Hashable α] {β : Type v} {m₁ m₂ : Std.HashMap.Raw α β} [EquivBEq α]
[LawfulHashable α] [inst_4 : BEq β] [ReflBEq β], m₁.WF → m₂.WF → m₁.Equiv m₂ → (m₁ == m₂) = true | true |
Ideal.Factors.piQuotientEquiv._proof_3 | Mathlib.NumberTheory.RamificationInertia.Basic | ∀ {R : Type u_2} [inst : CommRing R] {S : Type u_1} [inst_1 : CommRing S] [inst_2 : Algebra R S]
[inst_3 : IsDedekindDomain S] (p : Ideal R)
(P : ↥(UniqueFactorizationMonoid.factors (Ideal.map (algebraMap R S) p)).toFinset),
(↑P ^ p.ramificationIdx ↑P).IsTwoSided | false |
Fin.exists_iff | Init.Data.Fin.Basic | ∀ {n : ℕ} {p : Fin n → Prop}, (∃ i, p i) ↔ ∃ i, ∃ (h : i < n), p ⟨i, h⟩ | true |
Graph.IsLink.left_mem | Mathlib.Combinatorics.Graph.Basic | ∀ {α : Type u_1} {β : Type u_2} {x y : α} {e : β} {G : Graph α β}, G.IsLink e x y → x ∈ G.vertexSet | true |
Int.toList_roc_eq_nil_iff._simp_1 | Init.Data.Range.Polymorphic.IntLemmas | ∀ {m n : ℤ}, ((m<...=n).toList = []) = (n ≤ m) | false |
Lean.Grind.IntInterval.co.inj | Init.Grind.ToInt | ∀ {lo hi lo_1 hi_1 : ℤ}, Lean.Grind.IntInterval.co lo hi = Lean.Grind.IntInterval.co lo_1 hi_1 → lo = lo_1 ∧ hi = hi_1 | true |
ReaderT.bind | Init.Prelude | {ρ : Type u} → {m : Type u → Type v} → [Monad m] → {α β : Type u} → ReaderT ρ m α → (α → ReaderT ρ m β) → ReaderT ρ m β | true |
CategoryTheory.MorphismProperty.MapFactorizationData.op_i | Mathlib.CategoryTheory.MorphismProperty.Factorization | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] (W₁ W₂ : CategoryTheory.MorphismProperty C) {X Y : C}
{f : X ⟶ Y} (hf : W₁.MapFactorizationData W₂ f),
(CategoryTheory.MorphismProperty.MapFactorizationData.op W₁ W₂ hf).i = hf.p.op | true |
Nat.cast_comm | Mathlib.Data.Nat.Cast.Commute | ∀ {α : Type u_1} [inst : NonAssocSemiring α] (n : ℕ) (x : α), ↑n * x = x * ↑n | true |
skewAdjointPart._proof_5 | Mathlib.Algebra.Star.Module | ∀ (R : Type u_2) {A : Type u_1} [inst : Semiring R] [inst_1 : StarMul R] [inst_2 : TrivialStar R]
[inst_3 : AddCommGroup A] [inst_4 : Module R A] [inst_5 : StarAddMonoid A] [inst_6 : StarModule R A]
[inst_7 : Invertible 2] (x y : A), ⟨⅟2 • (x + y - star (x + y)), ⋯⟩ = ⟨⅟2 • (x - star x), ⋯⟩ + ⟨⅟2 • (y - star y), ⋯⟩ | false |
AdicCompletion.mk_surjective | Mathlib.RingTheory.AdicCompletion.Basic | ∀ {R : Type u_1} [inst : CommRing R] (I : Ideal R) (M : Type u_4) [inst_1 : AddCommGroup M] [inst_2 : Module R M],
Function.Surjective ⇑(AdicCompletion.mk I M) | true |
_private.Mathlib.CategoryTheory.Monoidal.Functor.0._auto_49 | Mathlib.CategoryTheory.Monoidal.Functor | Lean.Syntax | false |
Lean.Firefox.Thread.casesOn | Lean.Util.Profiler | {motive : Lean.Firefox.Thread → Sort u} →
(t : Lean.Firefox.Thread) →
((name processType : String) →
(isMainThread : Bool) →
(samples : Lean.Firefox.SamplesTable) →
(markers : Lean.Firefox.RawMarkerTable) →
(stackTable : Lean.Firefox.StackTable) →
(frame... | false |
PadicAlgCl.instRankOneNNRealV._proof_2 | Mathlib.NumberTheory.Padics.Complex | ∀ (p : ℕ) [hp : Fact (Nat.Prime p)], MonoidWithZeroHomClass (PadicAlgCl p →*₀ NNReal) (PadicAlgCl p) NNReal | false |
CategoryTheory.Limits.PullbackCone.IsLimit.lift_snd | Mathlib.CategoryTheory.Limits.Shapes.Pullback.PullbackCone | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y Z : C} {f : X ⟶ Z} {g : Y ⟶ Z}
{t : CategoryTheory.Limits.PullbackCone f g} (ht : CategoryTheory.Limits.IsLimit t) {W : C} (h : W ⟶ X) (k : W ⟶ Y)
(w : CategoryTheory.CategoryStruct.comp h f = CategoryTheory.CategoryStruct.comp k g),
CategoryTheory.Cat... | true |
Std.Ric.forIn'_congr | Init.Data.Range.Polymorphic.Lemmas | ∀ {α : Type u} [inst : LE α] [inst_1 : DecidableLE α] [inst_2 : Std.PRange.Least? α]
[inst_3 : Std.PRange.UpwardEnumerable α] [inst_4 : Std.PRange.LawfulUpwardEnumerableLE α]
[inst_5 : Std.PRange.LawfulUpwardEnumerableLeast? α] [inst_6 : Std.Rxc.IsAlwaysFinite α]
[inst_7 : Std.PRange.LawfulUpwardEnumerable α] {m ... | true |
_private.Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Unital.0._auto_189 | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Unital | Lean.Syntax | false |
_private.Lean.Meta.Tactic.Grind.Arith.Cutsat.Search.0.Lean.Meta.Grind.Arith.Cutsat.getBestLower?.match_1 | Lean.Meta.Tactic.Grind.Arith.Cutsat.Search | (motive : Option (ℚ × Lean.Meta.Grind.Arith.Cutsat.LeCnstr) → Sort u_1) →
(best? : Option (ℚ × Lean.Meta.Grind.Arith.Cutsat.LeCnstr)) →
((lower : ℚ) → (snd : Lean.Meta.Grind.Arith.Cutsat.LeCnstr) → motive (some (lower, snd))) →
((x : Option (ℚ × Lean.Meta.Grind.Arith.Cutsat.LeCnstr)) → motive x) → motive be... | false |
DomMulAct.isClosedEmbedding_mk | Mathlib.Topology.Algebra.Constructions.DomMulAct | ∀ {M : Type u_1} [inst : TopologicalSpace M], Topology.IsClosedEmbedding ⇑DomMulAct.mk | true |
ContinuousAlternatingMap.sub_apply | Mathlib.Topology.Algebra.Module.Alternating.Basic | ∀ {R : Type u_1} {M : Type u_2} {N : Type u_3} {ι : Type u_4} [inst : Ring R] [inst_1 : AddCommGroup M]
[inst_2 : Module R M] [inst_3 : TopologicalSpace M] [inst_4 : AddCommGroup N] [inst_5 : Module R N]
[inst_6 : TopologicalSpace N] (f g : M [⋀^ι]→L[R] N) [inst_7 : IsTopologicalAddGroup N] (m : ι → M),
(f - g) m... | true |
QuadraticMap.hasLineDerivAt | Mathlib.Analysis.Calculus.LineDeriv.QuadraticMap | ∀ {𝕜 : Type u_1} {E : Type u_2} {F : Type u_3} [inst : NontriviallyNormedField 𝕜] [inst_1 : AddCommGroup E]
[inst_2 : Module 𝕜 E] [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] (f : QuadraticMap 𝕜 E F) (a b : E),
HasLineDerivAt 𝕜 (⇑f) (QuadraticMap.polar (⇑f) a b) a b | true |
TensorProduct.eq_repr_basis_right | Mathlib.LinearAlgebra.TensorProduct.Basis | ∀ {R : Type u_1} {M : Type u_3} {N : Type u_4} {κ : Type u_6} [inst : CommSemiring R] [inst_1 : AddCommMonoid M]
[inst_2 : Module R M] [inst_3 : AddCommMonoid N] [inst_4 : Module R N] (𝒞 : Module.Basis κ R N)
(x : TensorProduct R M N), ∃ b, (b.sum fun i m => m ⊗ₜ[R] 𝒞 i) = x | true |
UniformConvergenceCLM.instModule | Mathlib.Topology.Algebra.Module.Spaces.UniformConvergenceCLM | {𝕜₁ : Type u_1} →
{𝕜₂ : Type u_2} →
[inst : NormedField 𝕜₁] →
[inst_1 : NormedField 𝕜₂] →
(σ : 𝕜₁ →+* 𝕜₂) →
{E : Type u_3} →
(F : Type u_4) →
[inst_2 : AddCommGroup E] →
[inst_3 : Module 𝕜₁ E] →
[inst_4 : TopologicalSpace E... | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.