name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
_private.Lean.Compiler.LCNF.Simp.JpCases.0.Lean.Compiler.LCNF.Simp.mkJpAlt.go | Lean.Compiler.LCNF.Simp.JpCases | Array (Lean.Compiler.LCNF.CodeDecl Lean.Compiler.LCNF.Purity.pure) →
Array (Lean.Compiler.LCNF.Param Lean.Compiler.LCNF.Purity.pure) →
ℕ →
Array (Lean.Compiler.LCNF.Param Lean.Compiler.LCNF.Purity.pure) →
Lean.Compiler.LCNF.Code Lean.Compiler.LCNF.Purity.pure →
Bool →
Lean.Compiler.LCNF.Internalize.InternalizeM Lean.Compiler.LCNF.Purity.pure
Lean.Compiler.LCNF.Simp.JpCasesAlt | true |
ContDiffAt.const_smul | Mathlib.Analysis.Calculus.ContDiff.Operations | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type uE} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {F : Type uF} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {n : WithTop ℕ∞}
{R : Type u_3} [inst_5 : DistribSMul R F] [SMulCommClass 𝕜 R F] [ContinuousConstSMul R F] {f : E → F} {x : E} (c : R),
ContDiffAt 𝕜 n f x → ContDiffAt 𝕜 n (fun y => c • f y) x | true |
Set.Iio_succ_eq_Iic | Mathlib.Order.Interval.Set.SuccPred | ∀ {α : Type u_1} [inst : LinearOrder α] [inst_1 : SuccOrder α] [NoMaxOrder α] (b : α),
Set.Iio (Order.succ b) = Set.Iic b | true |
_private.Mathlib.Combinatorics.SimpleGraph.Regularity.Chunk.0.SzemerediRegularity.card_nonuniformWitness_sdiff_biUnion_star._simp_1_4 | Mathlib.Combinatorics.SimpleGraph.Regularity.Chunk | ∀ {a b c : Prop}, (a ∧ b → c) = (a → b → c) | false |
_private.Mathlib.RingTheory.PowerSeries.WellKnown.0.PowerSeries.map_invUnitsSub._simp_1_1 | Mathlib.RingTheory.PowerSeries.WellKnown | ∀ {G : Type u_7} {H : Type u_8} {F : Type u_9} [inst : FunLike F G H] [inst_1 : Monoid G] [inst_2 : Monoid H]
[MonoidHomClass F G H] (f : F) (a : G) (n : ℕ), f a ^ n = f (a ^ n) | false |
Lean.Elab.Do.MonadInfo.u | Lean.Elab.Do.Basic | Lean.Elab.Do.MonadInfo → Lean.Level | true |
_private.Mathlib.Combinatorics.SimpleGraph.Walks.Counting.0.SimpleGraph.set_walk_length_toFinset_eq._simp_1_1 | Mathlib.Combinatorics.SimpleGraph.Walks.Counting | ∀ {V : Type u} (G : SimpleGraph V) [inst : DecidableEq V] [inst_1 : G.LocallyFinite] (n : ℕ) (u v : V),
{p | p.length = n} = ↑(G.finsetWalkLength n u v) | false |
CategoryTheory.ExactFunctor.whiskeringRight._proof_4 | Mathlib.CategoryTheory.Limits.ExactFunctor | ∀ (C : Type u_3) [inst : CategoryTheory.Category.{u_1, u_3} C] (D : Type u_4)
[inst_1 : CategoryTheory.Category.{u_2, u_4} D] (E : Type u_6) [inst_2 : CategoryTheory.Category.{u_5, u_6} E]
{F G : D ⥤ₑ E} (η : F ⟶ G) ⦃X Y : C ⥤ₑ D⦄ (f : X ⟶ Y),
CategoryTheory.CategoryStruct.comp
(((CategoryTheory.exactFunctor C E).lift
((CategoryTheory.ExactFunctor.forget C D).comp ((CategoryTheory.Functor.whiskeringRight C D E).obj F.obj))
⋯).map
f)
(CategoryTheory.ObjectProperty.homMk (((CategoryTheory.Functor.whiskeringRight C D E).map η.hom).app Y.obj)) =
CategoryTheory.CategoryStruct.comp
(CategoryTheory.ObjectProperty.homMk (((CategoryTheory.Functor.whiskeringRight C D E).map η.hom).app X.obj))
(((CategoryTheory.exactFunctor C E).lift
((CategoryTheory.ExactFunctor.forget C D).comp ((CategoryTheory.Functor.whiskeringRight C D E).obj G.obj))
⋯).map
f) | false |
Lean.TraceState.ctorIdx | Lean.Util.Trace | Lean.TraceState → ℕ | false |
AlgHom.IsArithFrobAt.restrict.congr_simp | Mathlib.RingTheory.Frobenius | ∀ {R : Type u_1} {S : Type u_2} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S] {φ φ_1 : S →ₐ[R] S}
(e_φ : φ = φ_1) {Q : Ideal S} (H : φ.IsArithFrobAt Q), H.restrict = ⋯.restrict | true |
Option.instLawfulIdentityMaxNone | Init.Data.Option.Lemmas | ∀ {α : Type u_1} [inst : Max α], Std.LawfulIdentity max none | true |
SupHom.instSemilatticeSup._proof_2 | Mathlib.Order.Hom.Lattice | ∀ {α : Type u_1} {β : Type u_2} [inst : Max α] [inst_1 : SemilatticeSup β] {x y : SupHom α β}, ⇑x ≤ ⇑y ↔ ⇑x ≤ ⇑y | false |
TestFunction.mkCLM._proof_1 | Mathlib.Analysis.Distribution.TestFunction | ∀ (𝕜 : Type u_4) [inst : NontriviallyNormedField 𝕜] {E : Type u_1} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace ℝ E] {Ω : TopologicalSpace.Opens E} {F : Type u_2} [inst_3 : NormedAddCommGroup F]
[inst_4 : NormedSpace ℝ F] [inst_5 : NormedSpace 𝕜 F] {n : ℕ∞} {V : Type u_3} [inst_6 : AddCommGroup V]
[inst_7 : Module ℝ V] [t : TopologicalSpace V] [IsTopologicalAddGroup V] [ContinuousSMul ℝ V] [LocallyConvexSpace ℝ V]
[inst_11 : Algebra ℝ 𝕜] [inst_12 : IsScalarTower ℝ 𝕜 F] [inst_13 : Module 𝕜 V] [IsScalarTower ℝ 𝕜 V]
(toFun : TestFunction Ω F n → V) (map_add : ∀ (f g : TestFunction Ω F n), toFun (f + g) = toFun f + toFun g)
(map_smul : ∀ (c : 𝕜) (f : TestFunction Ω F n), toFun (c • f) = c • toFun f),
(∀ (K : TopologicalSpace.Compacts E) (K_sub_Ω : ↑K ⊆ ↑Ω), Continuous (toFun ∘ TestFunction.ofSupportedIn K_sub_Ω)) →
Continuous ⇑{ toFun := toFun, map_add' := map_add, map_smul' := map_smul } | false |
Subfield.extendScalars.orderIso_symm_apply | Mathlib.FieldTheory.IntermediateField.Basic | ∀ {L : Type u_2} [inst : Field L] (F : Subfield L) (E : IntermediateField (↥F) L),
(RelIso.symm (Subfield.extendScalars.orderIso F)) E = ⟨E.toSubfield, ⋯⟩ | true |
_private.Lean.Meta.Tactic.Simp.Rewrite.0.Lean.Meta.Simp.tryTheorem?.match_1 | Lean.Meta.Tactic.Simp.Rewrite | (motive : Option Lean.Meta.Simp.Result → Sort u_1) →
(__do_lift : Option Lean.Meta.Simp.Result) →
((result : Lean.Meta.Simp.Result) → motive (some result)) → (Unit → motive none) → motive __do_lift | false |
_private.Lean.Elab.Tactic.Do.VCGen.SuggestInvariant.0.Lean.Elab.Tactic.Do.hasEarlyReturn.match_5 | Lean.Elab.Tactic.Do.VCGen.SuggestInvariant | (motive : Option (Option (Lean.Expr × Lean.Expr)) → Sort u_1) →
(x : Option (Option (Lean.Expr × Lean.Expr))) →
(Unit → motive none) → ((a : Option (Lean.Expr × Lean.Expr)) → motive (some a)) → motive x | false |
Nat.instNonAssocSemiring._proof_1 | Mathlib.Algebra.Ring.Nat | ∀ (a : ℕ), 1 * a = a | false |
Std.Do.SPred.entails_3 | Std.Do.SPred.DerivedLaws | ∀ {σ₁ σ₂ σ₃ : Type u_1} {P Q : Std.Do.SPred [σ₁, σ₂, σ₃]},
P ⊢ₛ Q ↔ ∀ (s₁ : σ₁) (s₂ : σ₂) (s₃ : σ₃), (P s₁ s₂ s₃).down → (Q s₁ s₂ s₃).down | true |
Aesop.Frontend.Parser.declareRuleSets | Aesop.Frontend.Command | Lean.ParserDescr | true |
TopologicalSpace.Clopens.instHImp._proof_1 | Mathlib.Topology.Sets.Closeds | ∀ {α : Type u_1} [inst : TopologicalSpace α] (s t : TopologicalSpace.Clopens α), IsClopen (↑s ⇨ ↑t) | false |
CategoryTheory.Limits.binaryBiconeOfIsSplitMonoOfCokernel._proof_2 | Mathlib.CategoryTheory.Preadditive.Biproducts | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Preadditive C] {X Y : C}
{f : X ⟶ Y} [inst_2 : CategoryTheory.IsSplitMono f],
CategoryTheory.CategoryStruct.id Y -
(CategoryTheory.CategoryStruct.id Y - CategoryTheory.CategoryStruct.comp (CategoryTheory.retraction f) f) =
CategoryTheory.CategoryStruct.comp (CategoryTheory.retraction f) f | false |
Lean.Elab.Term.Quotation.IdxSet | Lean.Elab.Quotation | Type | true |
ZMod.trace_pow_card | Mathlib.LinearAlgebra.Matrix.Charpoly.FiniteField | ∀ {n : Type u_1} [inst : DecidableEq n] [inst_1 : Fintype n] {p : ℕ} [inst_2 : Fact (Nat.Prime p)]
(M : Matrix n n (ZMod p)), (M ^ p).trace = M.trace ^ p | true |
CategoryTheory.CatCommSq.vInv_vInv | Mathlib.CategoryTheory.CatCommSq | ∀ {C₁ : Type u_1} {C₂ : Type u_2} {C₃ : Type u_3} {C₄ : Type u_4} [inst : CategoryTheory.Category.{v_1, u_1} C₁]
[inst_1 : CategoryTheory.Category.{v_2, u_2} C₂] [inst_2 : CategoryTheory.Category.{v_3, u_3} C₃]
[inst_3 : CategoryTheory.Category.{v_4, u_4} C₄] (T : CategoryTheory.Functor C₁ C₂) (L : C₁ ≌ C₃) (R : C₂ ≌ C₄)
(B : CategoryTheory.Functor C₃ C₄) (h : CategoryTheory.CatCommSq T L.functor R.functor B),
CategoryTheory.CatCommSq.vInv B L.symm R.symm T (CategoryTheory.CatCommSq.vInv T L R B h) = h | true |
tendsto_setIntegral_pow_smul_of_unique_maximum_of_isCompact_of_integrableOn | Mathlib.MeasureTheory.Integral.PeakFunction | ∀ {α : Type u_1} {E : Type u_2} {hm : MeasurableSpace α} {μ : MeasureTheory.Measure α} [inst : TopologicalSpace α]
[BorelSpace α] [inst_2 : NormedAddCommGroup E] [inst_3 : NormedSpace ℝ E] {g : α → E} {x₀ : α} {s : Set α}
[CompleteSpace E] [TopologicalSpace.MetrizableSpace α] [MeasureTheory.IsLocallyFiniteMeasure μ] [μ.IsOpenPosMeasure],
IsCompact s →
∀ {c : α → ℝ},
ContinuousOn c s →
(∀ y ∈ s, y ≠ x₀ → c y < c x₀) →
(∀ x ∈ s, 0 ≤ c x) →
0 < c x₀ →
x₀ ∈ closure (interior s) →
MeasureTheory.IntegrableOn g s μ →
ContinuousWithinAt g s x₀ →
Filter.Tendsto (fun n => (∫ (x : α) in s, c x ^ n ∂μ)⁻¹ • ∫ (x : α) in s, c x ^ n • g x ∂μ)
Filter.atTop (nhds (g x₀)) | true |
_private.Lean.Meta.WHNF.0.Lean.Meta.reduceQuotRec.match_8 | Lean.Meta.WHNF | (motive : Lean.QuotKind → Sort u_1) →
(x : Lean.QuotKind) →
(Unit → motive Lean.QuotKind.lift) → (Unit → motive Lean.QuotKind.ind) → ((x : Lean.QuotKind) → motive x) → motive x | false |
LinearMap.IsPerfectCompl.recOn | Mathlib.LinearAlgebra.PerfectPairing.Basic | {R : Type u_1} →
{M : Type u_2} →
{N : Type u_3} →
[inst : CommRing R] →
[inst_1 : AddCommGroup M] →
[inst_2 : Module R M] →
[inst_3 : AddCommGroup N] →
[inst_4 : Module R N] →
{p : M →ₗ[R] N →ₗ[R] R} →
[inst_5 : p.IsPerfPair] →
{U : Submodule R M} →
{V : Submodule R N} →
{motive : p.IsPerfectCompl U V → Sort u} →
(t : p.IsPerfectCompl U V) →
((isCompl_left : IsCompl U (Submodule.map (↑p.toPerfPair.symm) V.dualAnnihilator)) →
(isCompl_right :
IsCompl V (Submodule.map (↑p.flip.toPerfPair.symm) U.dualAnnihilator)) →
motive ⋯) →
motive t | false |
Mathlib.Tactic.AtomM.Recurse.Context.noConfusionType | Mathlib.Util.AtomM.Recurse | Sort u → Mathlib.Tactic.AtomM.Recurse.Context → Mathlib.Tactic.AtomM.Recurse.Context → Sort u | false |
FiberBundleCore.mk.noConfusion | Mathlib.Topology.FiberBundle.Basic | {ι : Type u_5} →
{B : Type u_6} →
{inst : TopologicalSpace B} →
{F : Type u_7} →
{inst_1 : TopologicalSpace F} →
{P : Sort u} →
{baseSet : ι → Set B} →
{isOpen_baseSet : ∀ (i : ι), IsOpen (baseSet i)} →
{indexAt : B → ι} →
{mem_baseSet_at : ∀ (x : B), x ∈ baseSet (indexAt x)} →
{coordChange : ι → ι → B → F → F} →
{coordChange_self : ∀ (i : ι), ∀ x ∈ baseSet i, ∀ (v : F), coordChange i i x v = v} →
{continuousOn_coordChange :
∀ (i j : ι),
ContinuousOn (fun p => coordChange i j p.1 p.2) ((baseSet i ∩ baseSet j) ×ˢ Set.univ)} →
{coordChange_comp :
∀ (i j k : ι),
∀ x ∈ baseSet i ∩ baseSet j ∩ baseSet k,
∀ (v : F), coordChange j k x (coordChange i j x v) = coordChange i k x v} →
{baseSet' : ι → Set B} →
{isOpen_baseSet' : ∀ (i : ι), IsOpen (baseSet' i)} →
{indexAt' : B → ι} →
{mem_baseSet_at' : ∀ (x : B), x ∈ baseSet' (indexAt' x)} →
{coordChange' : ι → ι → B → F → F} →
{coordChange_self' :
∀ (i : ι), ∀ x ∈ baseSet' i, ∀ (v : F), coordChange' i i x v = v} →
{continuousOn_coordChange' :
∀ (i j : ι),
ContinuousOn (fun p => coordChange' i j p.1 p.2)
((baseSet' i ∩ baseSet' j) ×ˢ Set.univ)} →
{coordChange_comp' :
∀ (i j k : ι),
∀ x ∈ baseSet' i ∩ baseSet' j ∩ baseSet' k,
∀ (v : F),
coordChange' j k x (coordChange' i j x v) = coordChange' i k x v} →
{ baseSet := baseSet, isOpen_baseSet := isOpen_baseSet, indexAt := indexAt,
mem_baseSet_at := mem_baseSet_at, coordChange := coordChange,
coordChange_self := coordChange_self,
continuousOn_coordChange := continuousOn_coordChange,
coordChange_comp := coordChange_comp } =
{ baseSet := baseSet', isOpen_baseSet := isOpen_baseSet',
indexAt := indexAt', mem_baseSet_at := mem_baseSet_at',
coordChange := coordChange', coordChange_self := coordChange_self',
continuousOn_coordChange := continuousOn_coordChange',
coordChange_comp := coordChange_comp' } →
(baseSet ≍ baseSet' →
indexAt ≍ indexAt' → coordChange ≍ coordChange' → P) →
P | false |
Matroid.instPartialOrderMatroidᵣ._proof_3 | Mathlib.Combinatorics.Matroid.Minor.Restrict | ∀ {α : Type u_1} (M₁ M₂ : Matroid.Matroidᵣ α),
M₁.toMatroid.IsRestriction M₂.toMatroid → M₂.toMatroid.IsRestriction M₁.toMatroid → M₁ = M₂ | false |
Int.Linear.dvd_le_tight_cert | Init.Data.Int.Linear | ℤ → Int.Linear.Poly → Int.Linear.Poly → Int.Linear.Poly → Bool | true |
_private.Std.Time.Time.HourMarker.0.Std.Time.HourMarker.toRelative.match_1 | Std.Time.Time.HourMarker | (motive : False → Sort u_1) → (x : False) → motive x | false |
same_sub_div | Mathlib.Algebra.Field.Basic | ∀ {K : Type u_1} [inst : DivisionRing K] {a b : K}, b ≠ 0 → (b - a) / b = 1 - a / b | true |
CategoryTheory.IsGroupoid.recOn | Mathlib.CategoryTheory.Groupoid | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{motive : CategoryTheory.IsGroupoid C → Sort u_1} →
(t : CategoryTheory.IsGroupoid C) →
((all_isIso : ∀ {X Y : C} (f : X ⟶ Y), CategoryTheory.IsIso f) → motive ⋯) → motive t | false |
CategoryTheory.Limits.BinaryBicone.isBilimitOfKernelInl | Mathlib.CategoryTheory.Preadditive.Biproducts | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
[inst_1 : CategoryTheory.Preadditive C] →
{X Y : C} →
(b : CategoryTheory.Limits.BinaryBicone X Y) → CategoryTheory.Limits.IsLimit b.sndKernelFork → b.IsBilimit | true |
CategoryTheory.instIsCardinalAccessibleObjOppositeFunctorTypeUliftCoyonedaOpOfIsCardinalPresentable | Mathlib.CategoryTheory.Presentable.Basic | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] (X : C) (κ : Cardinal.{w}) [inst_1 : Fact κ.IsRegular]
[CategoryTheory.IsCardinalPresentable X κ],
(CategoryTheory.uliftCoyoneda.{t, v₁, u₁}.obj (Opposite.op X)).IsCardinalAccessible κ | true |
_private.Mathlib.Tactic.Simproc.FinsetInterval.0.Mathlib.Tactic.Simp.Int.Ico_eq_of_Icc_pred_eq | Mathlib.Tactic.Simproc.FinsetInterval | ∀ {m n : ℤ} {s : Finset ℤ}, Finset.Icc m (n - 1) = s → Finset.Ico m n = s | true |
List.insertIdx_subset_cons | Mathlib.Data.List.InsertIdx | ∀ {α : Type u} (n : ℕ) (a : α) (l : List α), l.insertIdx n a ⊆ a :: l | true |
IndexedPartition.measurable_piecewise | Mathlib.MeasureTheory.Function.Piecewise | ∀ {ι : Type u_1} {α : Type u_2} {β : Type u_3} [inst : MeasurableSpace α] {s : ι → Set α} {f : ι → α → β}
[inst_1 : MeasurableSpace β] [Countable ι] (hs : IndexedPartition s),
(∀ (i : ι), MeasurableSet (s i)) → (∀ (i : ι), Measurable (f i)) → Measurable (hs.piecewise f) | true |
Aesop.GoalState.toCtorIdx | Aesop.Tree.Data | Aesop.GoalState → ℕ | false |
KaehlerDifferential.tensorKaehlerEquivBase._proof_7 | Mathlib.RingTheory.Kaehler.TensorProduct | ∀ (R : Type u_1) (S : Type u_2) (A : Type u_3) (B : Type u_4) [inst : CommRing R] [inst_1 : CommRing S]
[inst_2 : Algebra R S] [inst_3 : CommRing A] [inst_4 : CommRing B] [inst_5 : Algebra R A] [inst_6 : Algebra R B]
[inst_7 : Algebra A B] [inst_8 : Algebra S B] [inst_9 : IsScalarTower R A B] [inst_10 : IsScalarTower R S B]
[h : Algebra.IsPushout R S A B] (x : TensorProduct R S Ω[A⁄R]),
(↑S (KaehlerDifferential.derivationTensorProduct R S A B).liftKaehlerDifferential ∘ₗ
LinearMap.liftBaseChange S (↑R (KaehlerDifferential.map R S A B)))
x =
LinearMap.id x | false |
Finset.Nonempty.mul_zero | Mathlib.Algebra.GroupWithZero.Pointwise.Finset | ∀ {α : Type u_1} [inst : DecidableEq α] [inst_1 : MulZeroClass α] {s : Finset α}, s.Nonempty → s * 0 = 0 | true |
AlgebraicTopology.DoldKan.Γ₀NondegComplexIso_hom_f | Mathlib.AlgebraicTopology.DoldKan.GammaCompN | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Preadditive C]
[inst_2 : CategoryTheory.Limits.HasFiniteCoproducts C] (K : ChainComplex C ℕ) (i : ℕ),
(AlgebraicTopology.DoldKan.Γ₀NondegComplexIso K).hom.f i =
CategoryTheory.CategoryStruct.id ((AlgebraicTopology.DoldKan.Γ₀.splitting K).N i) | true |
Function.Injective.cancelCommMonoid.eq_1 | Mathlib.Algebra.Group.InjSurj | ∀ {M₁ : Type u_1} {M₂ : Type u_2} [inst : Mul M₁] [inst_1 : One M₁] [inst_2 : Pow M₁ ℕ] [inst_3 : CancelCommMonoid M₂]
(f : M₁ → M₂) (hf : Function.Injective f) (one : f 1 = 1) (mul : ∀ (x y : M₁), f (x * y) = f x * f y)
(npow : ∀ (x : M₁) (n : ℕ), f (x ^ n) = f x ^ n),
Function.Injective.cancelCommMonoid f hf one mul npow =
{ toCommMonoid := Function.Injective.commMonoid f hf one mul npow, toIsLeftCancelMul := ⋯ } | true |
_private.Init.Data.UInt.Lemmas.0.UInt8.lt_of_le_of_ne._simp_1_3 | Init.Data.UInt.Lemmas | ∀ {a b : UInt8}, (a = b) = (a.toNat = b.toNat) | false |
WithTop.instOrderBot.eq_1 | Mathlib.Order.WithBot | ∀ {α : Type u_1} [inst : LE α] [inst_1 : OrderBot α], WithTop.instOrderBot = { toBot := WithTop.instBot, bot_le := ⋯ } | true |
_private.Mathlib.Combinatorics.Graph.Basic.0.Graph.banana_isNonloopAt._simp_1_1 | Mathlib.Combinatorics.Graph.Basic | ∀ {α : Type u_1} {β : Type u_2} {x : α} {e : β} {G : Graph α β}, G.IsNonloopAt e x = (G.Inc e x ∧ ¬G.IsLoopAt e x) | false |
QuadraticMap._sizeOf_inst | Mathlib.LinearAlgebra.QuadraticForm.Basic | (R : Type u) →
(M : Type v) →
(N : Type w) →
{inst : CommSemiring R} →
{inst_1 : AddCommMonoid M} →
{inst_2 : Module R M} →
{inst_3 : AddCommMonoid N} →
{inst_4 : Module R N} → [SizeOf R] → [SizeOf M] → [SizeOf N] → SizeOf (QuadraticMap R M N) | false |
Lean.ofExceptKernelException | Lean.Exception | {m : Type → Type} →
{α : Type} → [Monad m] → [Lean.MonadError m] → [Lean.MonadOptions m] → Except Lean.Kernel.Exception α → m α | true |
Metric.instMetricSpaceInductiveLimit._aux_6 | Mathlib.Topology.MetricSpace.Gluing | {X : ℕ → Type u_1} →
[inst : (n : ℕ) → MetricSpace (X n)] →
{f : (n : ℕ) → X n → X (n + 1)} →
{I : ∀ (n : ℕ), Isometry (f n)} → Metric.InductiveLimit I → Metric.InductiveLimit I → ENNReal | false |
CategoryTheory.FreeMonoidalCategory.HomEquiv.below.pentagon | Mathlib.CategoryTheory.Monoidal.Free.Basic | ∀ {C : Type u}
{motive :
{X Y : CategoryTheory.FreeMonoidalCategory C} →
(a a_1 : X.Hom Y) → CategoryTheory.FreeMonoidalCategory.HomEquiv a a_1 → Prop}
{W X Y Z : CategoryTheory.FreeMonoidalCategory C}, CategoryTheory.FreeMonoidalCategory.HomEquiv.below ⋯ | true |
Lean.Meta.Grind.Arith.CommRing.PolyDerivation._sizeOf_inst | Lean.Meta.Tactic.Grind.Arith.CommRing.Types | SizeOf Lean.Meta.Grind.Arith.CommRing.PolyDerivation | false |
Prod.isRightRegular_mk._simp_2 | Mathlib.Algebra.Regular.Prod | ∀ {R : Type u_2} {S : Type u_3} [inst : Mul R] [inst_1 : Mul S] {a : R} {b : S},
IsRightRegular (a, b) = (IsRightRegular a ∧ IsRightRegular b) | false |
_private.Lean.Compiler.LCNF.ElimDead.0.Lean.Compiler.LCNF.Code.elimDead._unsafe_rec | Lean.Compiler.LCNF.ElimDead | {pu : Lean.Compiler.LCNF.Purity} → Lean.Compiler.LCNF.Code pu → Lean.Compiler.LCNF.M✝ (Lean.Compiler.LCNF.Code pu) | false |
Nat.pair_eq_pair._simp_1 | Mathlib.Data.Nat.Pairing | ∀ {a b c d : ℕ}, (Nat.pair a b = Nat.pair c d) = (a = c ∧ b = d) | false |
_private.Lean.Meta.Closure.0.Lean.Meta.Closure.collectLevelAux.match_1 | Lean.Meta.Closure | (motive : Lean.Level → Sort u_1) →
(x : Lean.Level) →
((u v : Lean.Level) → (h : u = v.succ) → motive (namedPattern u v.succ h)) →
((u v w : Lean.Level) → (h : u = v.max w) → motive (namedPattern u (v.max w) h)) →
((u v w : Lean.Level) → (h : u = v.imax w) → motive (namedPattern u (v.imax w) h)) →
((u : Lean.Level) →
(a : Lean.LMVarId) → (h : u = Lean.Level.mvar a) → motive (namedPattern u (Lean.Level.mvar a) h)) →
((u : Lean.Level) →
(a : Lean.Name) → (h : u = Lean.Level.param a) → motive (namedPattern u (Lean.Level.param a) h)) →
((u : Lean.Level) → (h : u = Lean.Level.zero) → motive (namedPattern u Lean.Level.zero h)) → motive x | false |
CategoryTheory.MonoidalCategory.tensorIso._proof_1 | Mathlib.CategoryTheory.Monoidal.Category | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.MonoidalCategory C]
{X Y X' Y' : C} (f : X ≅ Y) (g : X' ≅ Y'),
CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategoryStruct.tensorHom f.hom g.hom)
(CategoryTheory.MonoidalCategoryStruct.tensorHom f.inv g.inv) =
CategoryTheory.CategoryStruct.id (CategoryTheory.MonoidalCategoryStruct.tensorObj X X') | false |
orderEmbeddingOfInjective | Mathlib.Order.Hom.Lattice | {F : Type u_1} →
{α : Type u_2} →
{β : Type u_3} →
[inst : FunLike F α β] →
[inst_1 : SemilatticeInf α] →
[inst_2 : SemilatticeInf β] → (f : F) → [InfHomClass F α β] → Function.Injective ⇑f → α ↪o β | true |
_private.Mathlib.Analysis.Convex.StrictConvexBetween.0.dist_add_dist_eq_iff._simp_1_1 | Mathlib.Analysis.Convex.StrictConvexBetween | ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : Field 𝕜] [inst_1 : LinearOrder 𝕜] [inst_2 : IsStrictOrderedRing 𝕜]
[inst_3 : AddCommGroup E] [inst_4 : Module 𝕜 E] {x y z : E}, (x ∈ segment 𝕜 y z) = SameRay 𝕜 (x - y) (z - x) | false |
Std.ExtTreeMap.forM_eq_forM_keys | Std.Data.ExtTreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.ExtTreeMap α β cmp} {m : Type w → Type w'}
[inst : Std.TransCmp cmp] [inst_1 : Monad m] [inst_2 : LawfulMonad m] {f : α → m PUnit.{w + 1}},
(forM t fun a => f a.1) = t.keys.forM f | true |
Std.Tactic.BVDecide.LRAT.Internal.Clause.noConfusion | Std.Tactic.BVDecide.LRAT.Internal.Clause | {P : Sort u_1} →
{α : Type u} →
{β : Type v} →
{t : Std.Tactic.BVDecide.LRAT.Internal.Clause α β} →
{α' : Type u} →
{β' : Type v} →
{t' : Std.Tactic.BVDecide.LRAT.Internal.Clause α' β'} →
α = α' → β = β' → t ≍ t' → Std.Tactic.BVDecide.LRAT.Internal.Clause.noConfusionType P t t' | false |
Std.ExtHashSet.size_ofList | Std.Data.ExtHashSet.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} [inst : EquivBEq α] [inst_1 : LawfulHashable α] {l : List α},
List.Pairwise (fun a b => (a == b) = false) l → (Std.ExtHashSet.ofList l).size = l.length | true |
AffineIndependent.range | Mathlib.LinearAlgebra.AffineSpace.Independent | ∀ {k : Type u_1} {V : Type u_2} {P : Type u_3} [inst : Ring k] [inst_1 : AddCommGroup V] [inst_2 : Module k V]
[inst_3 : AddTorsor V P] {ι : Type u_4} {p : ι → P}, AffineIndependent k p → AffineIndependent k fun x => ↑x | true |
_private.Init.Data.Dyadic.Instances.0.Dyadic.instCommRing._simp_1 | Init.Data.Dyadic.Instances | ∀ {x y : Dyadic}, (x = y) = (x.toRat = y.toRat) | false |
Pi.smul'.eq_1 | Mathlib.Algebra.Group.Action.Pi | ∀ {ι : Type u_1} {α : ι → Type u_4} {β : ι → Type u_5} [inst : (i : ι) → SMul (α i) (β i)],
Pi.smul' = { smul := fun s x i => s i • x i } | true |
CategoryTheory.LiftsToColimit.ctorIdx | Mathlib.CategoryTheory.Limits.Creates | {C : Type u₁} →
{inst : CategoryTheory.Category.{v₁, u₁} C} →
{D : Type u₂} →
{inst_1 : CategoryTheory.Category.{v₂, u₂} D} →
{J : Type w} →
{inst_2 : CategoryTheory.Category.{w', w} J} →
{K : CategoryTheory.Functor J C} →
{F : CategoryTheory.Functor C D} →
{c : CategoryTheory.Limits.Cocone (K.comp F)} →
{t : CategoryTheory.Limits.IsColimit c} → CategoryTheory.LiftsToColimit K F c t → ℕ | false |
_private.Mathlib.Logic.Equiv.PartialEquiv.0.Tactic.MfldSetTac._aux_Mathlib_Logic_Equiv_PartialEquiv___elabRules_Tactic_MfldSetTac_mfldSetTac_1._sparseCasesOn_3 | Mathlib.Logic.Equiv.PartialEquiv | {motive : Lean.Name → Sort u} →
(t : Lean.Name) → motive Lean.Name.anonymous → (Nat.hasNotBit 1 t.ctorIdx → motive t) → motive t | false |
Mathlib.Tactic.Zify._aux_Mathlib_Tactic_Zify___macroRules_Mathlib_Tactic_Zify_zify_1 | Mathlib.Tactic.Zify | Lean.Macro | false |
TypeVec.subtypeVal.eq_def | Mathlib.Data.TypeVec | ∀ (x : ℕ) (x_1 : TypeVec.{u} x) (x_2 : x_1.Arrow (TypeVec.repeat x Prop)) (x_3 : Fin2 x),
TypeVec.subtypeVal x_2 x_3 =
match (motive :=
(x : ℕ) →
(x_4 : TypeVec.{u} x) →
(x_5 : x_4.Arrow (TypeVec.repeat x Prop)) → (x_6 : Fin2 x) → TypeVec.Subtype_ x_5 x_6 → x_4 x_6)
x, x_1, x_2, x_3 with
| n.succ, x, x_4, i.fs => TypeVec.subtypeVal (TypeVec.dropFun x_4) i
| n.succ, x, x_4, Fin2.fz => Subtype.val | true |
_private.Lean.Elab.DocString.Builtin.0.Lean.Doc.tactic._proof_6 | Lean.Elab.DocString.Builtin | ∀ (exns : Array Lean.Exception), exns.size = 1 → ¬0 < exns.size → False | false |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.size_insertMany_list_le._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 |
MeasureTheory.measure_inv_smul_symmDiff | Mathlib.MeasureTheory.Group.Action | ∀ {G : Type u} {α : Type w} {m : MeasurableSpace α} [inst : Group G] [inst_1 : MulAction G α]
(μ : MeasureTheory.Measure α) [MeasureTheory.SMulInvariantMeasure G α μ] (c : G) (s t : Set α),
μ (symmDiff (c⁻¹ • s) t) = μ (symmDiff s (c • t)) | true |
Lean.Server.ReferencedObject.mk.injEq | Lean.Server.Rpc.Basic | ∀ (obj : Dynamic) (id : USize) (rc : ℕ) (obj_1 : Dynamic) (id_1 : USize) (rc_1 : ℕ),
({ obj := obj, id := id, rc := rc } = { obj := obj_1, id := id_1, rc := rc_1 }) =
(obj = obj_1 ∧ id = id_1 ∧ rc = rc_1) | true |
LLVM.LLVMType.ptr | Lean.Compiler.IR.LLVMBindings | {ctx : LLVM.Context} → LLVM.LLVMType ctx → USize | true |
_private.Mathlib.GroupTheory.Perm.Support.0.Equiv.Perm.ofSubtype_eq_iff._simp_1_1 | Mathlib.GroupTheory.Perm.Support | ∀ {α : Sort u} {β : Sort v} {f g : α ≃ β}, (f = g) = ∀ (x : α), f x = g x | false |
Lean.Meta.Config.noConfusion | Lean.Meta.Basic | {P : Sort u} → {t t' : Lean.Meta.Config} → t = t' → Lean.Meta.Config.noConfusionType P t t' | false |
GrpCat.FilteredColimits.G | Mathlib.Algebra.Category.Grp.FilteredColimits | {J : Type v} →
[inst : CategoryTheory.SmallCategory J] → [CategoryTheory.IsFiltered J] → CategoryTheory.Functor J GrpCat → MonCat | true |
CategoryTheory.SimplicialObject.δ_comp_σ_succ | Mathlib.AlgebraicTopology.SimplicialObject.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (X : CategoryTheory.SimplicialObject C) {n : ℕ}
{i : Fin (n + 1)},
CategoryTheory.CategoryStruct.comp (X.σ i) (X.δ i.succ) =
CategoryTheory.CategoryStruct.id (X.obj (Opposite.op (SimplexCategory.mk n))) | true |
LieDerivation.mk.sizeOf_spec | Mathlib.Algebra.Lie.Derivation.Basic | ∀ {R : Type u_1} {L : Type u_2} {M : Type u_3} [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : LieAlgebra R L]
[inst_3 : AddCommGroup M] [inst_4 : Module R M] [inst_5 : LieRingModule L M] [inst_6 : LieModule R L M]
[inst_7 : SizeOf R] [inst_8 : SizeOf L] [inst_9 : SizeOf M] (toLinearMap : L →ₗ[R] M)
(leibniz' : ∀ (a b : L), toLinearMap ⁅a, b⁆ = ⁅a, toLinearMap b⁆ - ⁅b, toLinearMap a⁆),
sizeOf { toLinearMap := toLinearMap, leibniz' := leibniz' } = 1 + sizeOf toLinearMap | true |
CategoryTheory.instIsIsoOverInferInstanceOverClass | Mathlib.CategoryTheory.Comma.Over.OverClass | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (S : C), CategoryTheory.IsIso (S ↘ S) | true |
LinearEquiv.instCoeLinearMap | Mathlib.Algebra.Module.Equiv.Defs | {R : Type u_1} →
{S : Type u_6} →
{M : Type u_7} →
{M₂ : Type u_9} →
[inst : Semiring R] →
[inst_1 : Semiring S] →
[inst_2 : AddCommMonoid M] →
[inst_3 : AddCommMonoid M₂] →
{modM : Module R M} →
{modM₂ : Module S M₂} →
{σ : R →+* S} →
{σ' : S →+* R} →
[inst_4 : RingHomInvPair σ σ'] →
[inst_5 : RingHomInvPair σ' σ] → Coe (M ≃ₛₗ[σ] M₂) (M →ₛₗ[σ] M₂) | true |
WithBot.preimage_coe_Ico | Mathlib.Order.Interval.Set.WithBotTop | ∀ {α : Type u_1} [inst : Preorder α] {a b : α}, WithBot.some ⁻¹' Set.Ico ↑a ↑b = Set.Ico a b | true |
MeasureTheory.SimpleFunc.instNonAssocRing | Mathlib.MeasureTheory.Function.SimpleFunc | {α : Type u_1} →
{β : Type u_2} → [inst : MeasurableSpace α] → [NonAssocRing β] → NonAssocRing (MeasureTheory.SimpleFunc α β) | true |
_private.Init.Data.Order.LemmasExtra.0.Std.min_le_min | Init.Data.Order.LemmasExtra | ∀ {α : Type u_1} [inst : LE α] [inst_1 : Min α] [Std.LawfulOrderLeftLeaningMin α] [Std.IsLinearOrder α] (a b : α),
a ⊓ b ≤ b ⊓ a | true |
CategoryTheory.objDown_objUp | Mathlib.CategoryTheory.Category.ULift | ∀ {C : Type u_1} (A : C), (CategoryTheory.ULiftHom.objUp A).objDown = A | true |
MulRingNorm.noConfusion | Mathlib.Analysis.Normed.Unbundled.RingSeminorm | {P : Sort u} →
{R : Type u_2} →
{inst : NonAssocRing R} →
{t : MulRingNorm R} →
{R' : Type u_2} →
{inst' : NonAssocRing R'} →
{t' : MulRingNorm R'} → R = R' → inst ≍ inst' → t ≍ t' → MulRingNorm.noConfusionType P t t' | false |
MvQPF.rec | Mathlib.Data.QPF.Multivariate.Basic | {n : ℕ} →
{F : TypeVec.{u} n → Type u_1} →
{motive : MvQPF F → Sort u_2} →
([toMvFunctor : MvFunctor F] →
(P : MvPFunctor.{u} n) →
(abs : {α : TypeVec.{u} n} → ↑P α → F α) →
(repr : {α : TypeVec.{u} n} → F α → ↑P α) →
(abs_repr : ∀ {α : TypeVec.{u} n} (x : F α), abs (repr x) = x) →
(abs_map :
∀ {α β : TypeVec.{u} n} (f : α.Arrow β) (p : ↑P α),
abs (MvFunctor.map f p) = MvFunctor.map f (abs p)) →
motive
{ toMvFunctor := toMvFunctor, P := P, abs := abs, repr := repr, abs_repr := abs_repr,
abs_map := abs_map }) →
(t : MvQPF F) → motive t | false |
WittVector.map_id | Mathlib.RingTheory.WittVector.Basic | ∀ {p : ℕ} (R : Type u_1) [inst : CommRing R] [inst_1 : Fact (Nat.Prime p)],
WittVector.map (RingHom.id R) = RingHom.id (WittVector p R) | true |
SimplexCategory.toTop_obj | Mathlib.AlgebraicTopology.TopologicalSimplex | ∀ (X : SimplexCategory),
SimplexCategory.toTop.{u}.obj X = TopCat.uliftFunctor.obj (TopCat.of ↑(stdSimplex ℝ (Fin (X.len + 1)))) | true |
Real.tan_sub_int_mul_pi | Mathlib.Analysis.SpecialFunctions.Trigonometric.Basic | ∀ (x : ℝ) (n : ℤ), Real.tan (x - ↑n * Real.pi) = Real.tan x | true |
Lean.Syntax.getHeadInfo? | Init.Prelude | Lean.Syntax → Option Lean.SourceInfo | true |
Lean.Grind.AC.superpose_tail_idempotent_cert.eq_1 | Init.Grind.AC | ∀ (x : Lean.Grind.AC.Var) (lhs₁ rhs₁ rhs : Lean.Grind.AC.Seq),
Lean.Grind.AC.superpose_tail_idempotent_cert x lhs₁ rhs₁ rhs =
(lhs₁.endsWithVar_k x).and' (rhs.beq' (rhs₁.concat (Lean.Grind.AC.Seq.var x))) | true |
_private.Mathlib.Analysis.Complex.LocallyUniformLimit.0.Complex.cderiv_sub._simp_1_2 | Mathlib.Analysis.Complex.LocallyUniformLimit | ∀ {M : Type u_1} {A : Type u_7} [inst : AddGroup A] [inst_1 : DistribSMul M A] (r : M) (x y : A),
r • x - r • y = r • (x - y) | false |
Std.Iter.noConfusion | Init.Data.Iterators.Basic | {P : Sort u} →
{α β : Type w} →
{t : Std.Iter β} →
{α' β' : Type w} → {t' : Std.Iter β'} → α = α' → β = β' → t ≍ t' → Std.Iter.noConfusionType P t t' | false |
CategoryTheory.Limits.HasPushouts | Mathlib.CategoryTheory.Limits.Shapes.Pullback.HasPullback | (C : Type u) → [CategoryTheory.Category.{v, u} C] → Prop | true |
Multiset.mem_join | Mathlib.Data.Multiset.Bind | ∀ {α : Type u_1} {a : α} {S : Multiset (Multiset α)}, a ∈ S.join ↔ ∃ s ∈ S, a ∈ s | true |
Std.Sat.AIG.mkConst.eq_1 | Std.Sat.AIG.Lemmas | ∀ {α : Type} [inst : Hashable α] [inst_1 : DecidableEq α] (aig : Std.Sat.AIG α) (val : Bool),
aig.mkConst val =
{
aig :=
{ decls := aig.decls.push Std.Sat.AIG.Decl.false, cache := aig.cache.noUpdate, hdag := ⋯, hzero := ⋯,
hconst := ⋯ },
ref := { gate := aig.decls.size, invert := val, hgate := ⋯ } } | true |
_private.Lean.Meta.Tactic.Grind.Arith.Linear.0.Lean.Meta.Grind.Arith.Linear.initFn._@.Lean.Meta.Tactic.Grind.Arith.Linear.356702522._hygCtx._hyg.2 | Lean.Meta.Tactic.Grind.Arith.Linear | IO Unit | false |
Lean.Data.Trie._sizeOf_3 | Lean.Data.Trie | {α : Type} → [SizeOf α] → List (Lean.Data.Trie α) → ℕ | false |
DifferentiableWithinAt.fun_sum | Mathlib.Analysis.Calculus.FDeriv.Add | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {F : Type u_3} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {x : E}
{s : Set E} {ι : Type u_4} {u : Finset ι} {A : ι → E → F},
(∀ i ∈ u, DifferentiableWithinAt 𝕜 (A i) s x) → DifferentiableWithinAt 𝕜 (fun y => ∑ i ∈ u, A i y) s x | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.