name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M |
|---|---|---|
_private.Lean.Meta.InferType.0.Lean.Meta.inferMVarType | Lean.Meta.InferType | Lean.MVarId → Lean.MetaM Lean.Expr |
AddOpposite.instCommMonoid._proof_2 | Mathlib.Algebra.Group.Opposite | ∀ {α : Type u_1} [inst : CommMonoid α] (x x_1 : αᵃᵒᵖ), AddOpposite.unop (x * x_1) = AddOpposite.unop (x * x_1) |
ENormedCommMonoid.toESeminormedCommMonoid | Mathlib.Analysis.Normed.Group.Defs | {E : Type u_8} → {inst : TopologicalSpace E} → [self : ENormedCommMonoid E] → ESeminormedCommMonoid E |
_private.Init.Data.Nat.Lcm.0.Nat.lcm_pos._simp_1_1 | Init.Data.Nat.Lcm | ∀ {n : ℕ}, (n ≠ 0) = (0 < n) |
Equiv.algebra | Mathlib.Algebra.Algebra.TransferInstance | (R : Type u_1) →
{α : Type u_2} →
{β : Type u_3} →
[inst : CommSemiring R] →
(e : α ≃ β) →
[inst_1 : Semiring β] →
have x := e.semiring;
[Algebra R β] → Algebra R α |
ZMod.intCast_cast_mul | Mathlib.Data.ZMod.Basic | ∀ {n : ℕ} (x y : ZMod n), (x * y).cast = x.cast * y.cast % ↑n |
Lean.Elab.InlayHintLinkLocation._sizeOf_inst | Lean.Elab.InfoTree.InlayHints | SizeOf Lean.Elab.InlayHintLinkLocation |
Lean.Meta.Grind.EMatch.State.recOn | Lean.Meta.Tactic.Grind.Types | {motive : Lean.Meta.Grind.EMatch.State → Sort u} →
(t : Lean.Meta.Grind.EMatch.State) →
((thmMap : Lean.Meta.Grind.EMatchTheoremsArray) →
(gmt : ℕ) →
(thms newThms : Lean.PArray Lean.Meta.Grind.EMatchTheorem) →
(numInstances numDelayedInstances num : ℕ) →
(preInstances : Lean.Meta.Grind.PreInstanceSet) →
(nextThmIdx : ℕ) →
(matchEqNames : Lean.PHashSet Lean.Name) →
(delayedThmInsts :
Lean.PHashMap Lean.Meta.Sym.ExprPtr (List Lean.Meta.Grind.DelayedTheoremInstance)) →
motive
{ thmMap := thmMap, gmt := gmt, thms := thms, newThms := newThms, numInstances := numInstances,
numDelayedInstances := numDelayedInstances, num := num, preInstances := preInstances,
nextThmIdx := nextThmIdx, matchEqNames := matchEqNames,
delayedThmInsts := delayedThmInsts }) →
motive t |
Vector.append_assoc_symm | Init.Data.Vector.Lemmas | ∀ {α : Type u_1} {n m k : ℕ} {xs : Vector α n} {ys : Vector α m} {zs : Vector α k},
xs ++ (ys ++ zs) = Vector.cast ⋯ (xs ++ ys ++ zs) |
_private.Mathlib.Data.Seq.Parallel.0.Computation.BisimO.match_1.splitter._sparseCasesOn_3 | Mathlib.Data.Seq.Parallel | {α : Type u} →
{β : Type v} →
{motive : α ⊕ β → Sort u_1} →
(t : α ⊕ β) → ((val : α) → motive (Sum.inl val)) → (Nat.hasNotBit 1 t.ctorIdx → motive t) → motive t |
List.anyM_pure | Init.Data.List.Monadic | ∀ {m : Type → Type u_1} {α : Type u_2} [inst : Monad m] [LawfulMonad m] {p : α → Bool} {as : List α},
List.anyM (fun x => pure (p x)) as = pure (as.any p) |
Option.forIn_toList | Init.Data.Option.List | ∀ {m : Type u_1 → Type u_2} {α : Type u_3} {β : Type u_1} [inst : Monad m] (o : Option α) (b : β)
(f : α → β → m (ForInStep β)), forIn o.toList b f = forIn o b f |
Filter.le_limsup_of_frequently_le' | Mathlib.Order.LiminfLimsup | ∀ {α : Type u_6} {β : Type u_7} [inst : CompleteLattice β] {f : Filter α} {u : α → β} {x : β},
(∃ᶠ (a : α) in f, x ≤ u a) → x ≤ Filter.limsup u f |
MeasureTheory.posConvolution._proof_1 | Mathlib.Analysis.Convolution | ∀ {F : Type u_1} [inst : NormedAddCommGroup F] [inst_1 : NormedSpace ℝ F], SMulCommClass ℝ ℝ F |
Shrink.instNonUnitalCommRing | Mathlib.Algebra.Ring.Shrink | {α : Type u_1} → [inst : Small.{v, u_1} α] → [NonUnitalCommRing α] → NonUnitalCommRing (Shrink.{v, u_1} α) |
injective_frobenius._simp_1 | Mathlib.FieldTheory.Perfect | ∀ (R : Type u_1) (p : ℕ) [inst : CommSemiring R] [inst_1 : ExpChar R p] [PerfectRing R p],
Function.Injective ⇑(frobenius R p) = True |
ULift.distribMulAction'._proof_2 | Mathlib.Algebra.Module.ULift | ∀ {R : Type u_3} {M : Type u_2} [inst : Monoid R] [inst_1 : AddMonoid M] [inst_2 : DistribMulAction R M] (a : R)
(x y : ULift.{u_1, u_2} M), a • (x + y) = a • x + a • y |
CategoryTheory.Limits.colimitLimitToLimitColimitCone._proof_4 | Mathlib.CategoryTheory.Limits.ColimitLimit | ∀ {J : Type u_2} {K : Type u_5} [inst : CategoryTheory.Category.{u_1, u_2} J]
[inst_1 : CategoryTheory.Category.{u_6, u_5} K] {C : Type u_4} [inst_2 : CategoryTheory.Category.{u_3, u_4} C]
[CategoryTheory.Limits.HasLimitsOfShape J C] [inst_4 : CategoryTheory.Limits.HasColimitsOfShape K C]
(G : CategoryTheory.Functor J (CategoryTheory.Functor K C)),
CategoryTheory.Limits.HasLimit
((CategoryTheory.Functor.curry.obj (CategoryTheory.Functor.uncurry.obj G)).comp CategoryTheory.Limits.colim) |
RelHom.instFintype | Mathlib.Data.Fintype.Pi | {α : Type u_3} →
{β : Type u_4} →
[Fintype α] →
[Fintype β] →
[DecidableEq α] →
{r : α → α → Prop} → {s : β → β → Prop} → [DecidableRel r] → [DecidableRel s] → Fintype (r →r s) |
CategoryTheory.Limits.widePushoutShapeOp._proof_3 | Mathlib.CategoryTheory.Limits.Shapes.WidePullbacks | ∀ (J : Type u_1) {X Y Z : CategoryTheory.Limits.WidePushoutShape J} (f : X ⟶ Y) (g : Y ⟶ Z),
CategoryTheory.Limits.widePushoutShapeOpMap J X Z (CategoryTheory.CategoryStruct.comp f g) =
CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.widePushoutShapeOpMap J X Y f)
(CategoryTheory.Limits.widePushoutShapeOpMap J Y Z g) |
Lean.Elab.Command.InductiveElabStep2.prefinalize | Lean.Elab.MutualInductive | Lean.Elab.Command.InductiveElabStep2 →
List Lean.Name →
Array Lean.Expr → (Lean.Expr → Lean.MetaM Lean.Expr) → Lean.Elab.TermElabM Lean.Elab.Command.InductiveElabStep3 |
Std.DTreeMap.containsThenInsert_snd | Std.Data.DTreeMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t : Std.DTreeMap α β cmp} [Std.TransCmp cmp] {k : α}
{v : β k}, (t.containsThenInsert k v).2 = t.insert k v |
UInt32.toNat_ofNat_of_lt | Init.Data.UInt.Lemmas | ∀ {n : ℕ}, n < UInt32.size → UInt32.toNat (OfNat.ofNat n) = n |
Subgroup.map_symm_eq_iff_map_eq | Mathlib.Algebra.Group.Subgroup.Map | ∀ {G : Type u_1} [inst : Group G] (K : Subgroup G) {N : Type u_5} [inst_1 : Group N] {H : Subgroup N} {e : G ≃* N},
Subgroup.map (↑e.symm) H = K ↔ Subgroup.map (↑e) K = H |
Std.Iterators.Types.Flatten.IsPlausibleStep.rec | Init.Data.Iterators.Combinators.Monadic.FlatMap | ∀ {α α₂ β : Type w} {m : Type w → Type w'} [inst : Std.Iterator α m (Std.IterM m β)] [inst_1 : Std.Iterator α₂ m β]
{motive :
(it : Std.IterM m β) →
(step : Std.IterStep (Std.IterM m β) β) → Std.Iterators.Types.Flatten.IsPlausibleStep it step → Prop},
(∀ {it₁ it₁' : Std.IterM m (Std.IterM m β)} {it₂' : Std.IterM m β}
(a : it₁.IsPlausibleStep (Std.IterStep.yield it₁' it₂')),
motive { internalState := { it₁ := it₁, it₂ := none } }
(Std.IterStep.skip { internalState := { it₁ := it₁', it₂ := some it₂' } }) ⋯) →
(∀ {it₁ it₁' : Std.IterM m (Std.IterM m β)} (a : it₁.IsPlausibleStep (Std.IterStep.skip it₁')),
motive { internalState := { it₁ := it₁, it₂ := none } }
(Std.IterStep.skip { internalState := { it₁ := it₁', it₂ := none } }) ⋯) →
(∀ {it₁ : Std.IterM m (Std.IterM m β)} (a : it₁.IsPlausibleStep Std.IterStep.done),
motive { internalState := { it₁ := it₁, it₂ := none } } Std.IterStep.done ⋯) →
(∀ {it₁ : Std.IterM m (Std.IterM m β)} {it₂ it₂' : Std.IterM m β} {b : β}
(a : it₂.IsPlausibleStep (Std.IterStep.yield it₂' b)),
motive { internalState := { it₁ := it₁, it₂ := some it₂ } }
(Std.IterStep.yield { internalState := { it₁ := it₁, it₂ := some it₂' } } b) ⋯) →
(∀ {it₁ : Std.IterM m (Std.IterM m β)} {it₂ it₂' : Std.IterM m β}
(a : it₂.IsPlausibleStep (Std.IterStep.skip it₂')),
motive { internalState := { it₁ := it₁, it₂ := some it₂ } }
(Std.IterStep.skip { internalState := { it₁ := it₁, it₂ := some it₂' } }) ⋯) →
(∀ {it₁ : Std.IterM m (Std.IterM m β)} {it₂ : Std.IterM m β} (a : it₂.IsPlausibleStep Std.IterStep.done),
motive { internalState := { it₁ := it₁, it₂ := some it₂ } }
(Std.IterStep.skip { internalState := { it₁ := it₁, it₂ := none } }) ⋯) →
∀ {it : Std.IterM m β} {step : Std.IterStep (Std.IterM m β) β}
(t : Std.Iterators.Types.Flatten.IsPlausibleStep it step), motive it step t |
Lean.Meta.Simp.instInhabitedContext | Lean.Meta.Tactic.Simp.Types | Inhabited Lean.Meta.Simp.Context |
_private.Mathlib.MeasureTheory.Integral.IntegrableOn.0.MeasureTheory.integrableAtFilter_atBot_iff.match_1_1 | Mathlib.MeasureTheory.Integral.IntegrableOn | ∀ {α : Type u_1} {ε : Type u_2} {mα : MeasurableSpace α} {f : α → ε} {μ : MeasureTheory.Measure α}
[inst : TopologicalSpace ε] [inst_1 : ContinuousENorm ε] [inst_2 : Preorder α]
(motive : MeasureTheory.IntegrableAtFilter f Filter.atBot μ → Prop)
(x : MeasureTheory.IntegrableAtFilter f Filter.atBot μ),
(∀ (s : Set α) (hs : s ∈ Filter.atBot) (hi : MeasureTheory.IntegrableOn f s μ), motive ⋯) → motive x |
Fintype.one_lt_card_iff_nontrivial | Mathlib.Data.Fintype.EquivFin | ∀ {α : Type u_1} [inst : Fintype α], 1 < Fintype.card α ↔ Nontrivial α |
Order.isSuccPrelimit_iff_of_noMax | Mathlib.Order.SuccPred.Limit | ∀ {α : Type u_1} {a : α} [inst : Preorder α] [inst_1 : SuccOrder α] [IsSuccArchimedean α] [NoMaxOrder α],
Order.IsSuccPrelimit a ↔ IsMin a |
Std.Roo.noConfusionType | Init.Data.Range.Polymorphic.PRange | Sort u_1 → {α : Type u} → Std.Roo α → {α' : Type u} → Std.Roo α' → Sort u_1 |
Set.instCompleteAtomicBooleanAlgebra._proof_5 | Mathlib.Data.Set.BooleanAlgebra | ∀ {α : Type u_1} (a : Set α), ⊥ ≤ a |
CategoryTheory.Limits.WalkingMulticospan.Hom.casesOn | Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer | {J : CategoryTheory.Limits.MulticospanShape} →
{motive : (x x_1 : CategoryTheory.Limits.WalkingMulticospan J) → x.Hom x_1 → Sort u} →
{x x_1 : CategoryTheory.Limits.WalkingMulticospan J} →
(t : x.Hom x_1) →
((A : CategoryTheory.Limits.WalkingMulticospan J) →
motive A A (CategoryTheory.Limits.WalkingMulticospan.Hom.id A)) →
((b : J.R) →
motive (CategoryTheory.Limits.WalkingMulticospan.left (J.fst b))
(CategoryTheory.Limits.WalkingMulticospan.right b)
(CategoryTheory.Limits.WalkingMulticospan.Hom.fst b)) →
((b : J.R) →
motive (CategoryTheory.Limits.WalkingMulticospan.left (J.snd b))
(CategoryTheory.Limits.WalkingMulticospan.right b)
(CategoryTheory.Limits.WalkingMulticospan.Hom.snd b)) →
motive x x_1 t |
Lean.Grind.CommRing.Mon.mult.injEq | Init.Grind.Ring.CommSolver | ∀ (p : Lean.Grind.CommRing.Power) (m : Lean.Grind.CommRing.Mon) (p_1 : Lean.Grind.CommRing.Power)
(m_1 : Lean.Grind.CommRing.Mon),
(Lean.Grind.CommRing.Mon.mult p m = Lean.Grind.CommRing.Mon.mult p_1 m_1) = (p = p_1 ∧ m = m_1) |
Equiv.Perm.two_le_card_support_cycleOf_iff._simp_1 | Mathlib.GroupTheory.Perm.Cycle.Factors | ∀ {α : Type u_2} {f : Equiv.Perm α} {x : α} [inst : DecidableEq α] [inst_1 : Fintype α],
(2 ≤ (f.cycleOf x).support.card) = (f x ≠ x) |
LinearIndependent.repr | Mathlib.LinearAlgebra.LinearIndependent.Defs | {ι : Type u'} →
{R : Type u_2} →
{M : Type u_4} →
{v : ι → M} →
[inst : Semiring R] →
[inst_1 : AddCommMonoid M] →
[inst_2 : Module R M] → LinearIndependent R v → ↥(Submodule.span R (Set.range v)) →ₗ[R] ι →₀ R |
Lean.Meta.LiftLetsConfig.noConfusion | Init.MetaTypes | {P : Sort u} → {t t' : Lean.Meta.LiftLetsConfig} → t = t' → Lean.Meta.LiftLetsConfig.noConfusionType P t t' |
_private.Batteries.Data.DList.Lemmas.0.Batteries.DList.push.match_1.eq_1 | Batteries.Data.DList.Lemmas | ∀ {α : Type u_1} (motive : Batteries.DList α → α → Sort u_2) (f : List α → List α) (h : ∀ (l : List α), f l = f [] ++ l)
(a : α)
(h_1 :
(f : List α → List α) → (h : ∀ (l : List α), f l = f [] ++ l) → (a : α) → motive { apply := f, invariant := h } a),
(match { apply := f, invariant := h }, a with
| { apply := f, invariant := h }, a => h_1 f h a) =
h_1 f h a |
Functor._aux_Mathlib_Control_Functor___unexpand_Functor_mapConstRev_1 | Mathlib.Control.Functor | Lean.PrettyPrinter.Unexpander |
AlgebraicGeometry.StructureSheaf.sectionsSubalgebra | Mathlib.AlgebraicGeometry.StructureSheaf | {R : Type u} →
(A : Type u) →
[inst : CommRing R] →
[inst_1 : CommRing A] →
[inst_2 : Algebra R A] →
(U : TopologicalSpace.Opens ↑(AlgebraicGeometry.PrimeSpectrum.Top R)) →
Subalgebra R ((x : ↥U) → AlgebraicGeometry.StructureSheaf.Localizations A ↑x) |
Ideal.cotangentToQuotientSquare | Mathlib.RingTheory.Ideal.Cotangent | {R : Type u} → [inst : CommRing R] → (I : Ideal R) → I.Cotangent →ₗ[R] R ⧸ I ^ 2 |
Std.TreeMap.Raw.Equiv.getEntryLE!_eq | Std.Data.TreeMap.Raw.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t₁ t₂ : Std.TreeMap.Raw α β cmp} [Std.TransCmp cmp]
[inst : Inhabited (α × β)] {k : α}, t₁.WF → t₂.WF → t₁.Equiv t₂ → t₁.getEntryLE! k = t₂.getEntryLE! k |
iSup_psigma' | Mathlib.Order.CompleteLattice.Basic | ∀ {α : Type u_1} [inst : CompleteLattice α] {ι : Sort u_8} {κ : ι → Sort u_9} (f : (i : ι) → κ i → α),
⨆ i, ⨆ j, f i j = ⨆ ij, f ij.fst ij.snd |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.getD_erase._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) |
String.rawEndPos.eq_1 | Init.Data.String.Iterator | ∀ (s : String), s.rawEndPos = { byteIdx := s.utf8ByteSize } |
CategoryTheory.Limits.colimitIsoFlipCompColim_hom_app | Mathlib.CategoryTheory.Limits.FunctorCategory.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {J : Type u₁} [inst_1 : CategoryTheory.Category.{v₁, u₁} J]
{K : Type u₂} [inst_2 : CategoryTheory.Category.{v₂, u₂} K] [inst_3 : CategoryTheory.Limits.HasColimitsOfShape J C]
(F : CategoryTheory.Functor J (CategoryTheory.Functor K C)) (X : K),
(CategoryTheory.Limits.colimitIsoFlipCompColim F).hom.app X =
(CategoryTheory.Limits.colimitObjIsoColimitCompEvaluation F X).hom |
CategoryTheory.Cat.Hom.ext | Mathlib.CategoryTheory.Category.Cat | ∀ {C D : CategoryTheory.Cat} {x y : C.Hom D}, x.toFunctor = y.toFunctor → x = y |
Frm.carrier | Mathlib.Order.Category.Frm | Frm → Type u_1 |
_private.Mathlib.Analysis.Convex.StrictCombination.0.StrictConvex.centerMass_mem_interior._simp_1_4 | Mathlib.Analysis.Convex.StrictCombination | ∀ {α : Type u_1} [inst : AddZeroClass α] [inst_1 : LT α] [AddLeftStrictMono α] [AddLeftReflectLT α] (a : α) {b : α},
(a < a + b) = (0 < b) |
Std.DHashMap.Internal.Raw₀.Const.get?ₘ | Std.Data.DHashMap.Internal.Model | {α : Type u} → {β : Type v} → [BEq α] → [Hashable α] → (Std.DHashMap.Internal.Raw₀ α fun x => β) → α → Option β |
IsDedekindDomain.HeightOneSpectrum.algebraMap_adicCompletionIntegers_apply | Mathlib.RingTheory.DedekindDomain.AdicValuation | ∀ (R : Type u_1) [inst : CommRing R] [inst_1 : IsDedekindDomain R] (K : Type u_2) [inst_2 : Field K]
[inst_3 : Algebra R K] [inst_4 : IsFractionRing R K] (v : IsDedekindDomain.HeightOneSpectrum R) (r : R),
↑((algebraMap R ↥(IsDedekindDomain.HeightOneSpectrum.adicCompletionIntegers K v)) r) =
↑((WithVal.equiv (IsDedekindDomain.HeightOneSpectrum.valuation K v)).symm ((algebraMap R K) r)) |
Subfield.relrank.eq_1 | Mathlib.FieldTheory.Relrank | ∀ {E : Type v} [inst : Field E] (A B : Subfield E), A.relrank B = Module.rank ↥(A ⊓ B) ↥(Subfield.extendScalars ⋯) |
Lean.Server.Completion.ContextualizedCompletionInfo.mk._flat_ctor | Lean.Server.Completion.CompletionUtils | Lean.Server.Completion.HoverInfo →
Lean.Elab.ContextInfo → Lean.Elab.CompletionInfo → Lean.Server.Completion.ContextualizedCompletionInfo |
List.toAssocList'._sunfold | Lean.Data.AssocList | {α : Type u} → {β : Type v} → List (α × β) → Lean.AssocList α β |
SymmetricAlgebra.algHom._proof_1 | Mathlib.LinearAlgebra.SymmetricAlgebra.Basic | ∀ (R : Type u_1) (M : Type u_2) [inst : CommSemiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M],
IsScalarTower R R M |
Lean.Compiler.LCNF.JoinPointCommonArgs.AnalysisCtx._sizeOf_inst | Lean.Compiler.LCNF.JoinPoints | SizeOf Lean.Compiler.LCNF.JoinPointCommonArgs.AnalysisCtx |
IsLocalization.Away.exists_isIntegral_mul_of_isIntegral_algebraMap | Mathlib.RingTheory.Localization.Integral | ∀ {R : Type u_5} {S : Type u_6} {Sₘ : Type u_7} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : CommRing Sₘ]
[inst_3 : Algebra R S] [inst_4 : Algebra S Sₘ] [inst_5 : Algebra R Sₘ] [IsScalarTower R S Sₘ] {r : S},
IsIntegral R r →
∀ [IsLocalization.Away r Sₘ] {x : S}, IsIntegral R ((algebraMap S Sₘ) x) → ∃ n, IsIntegral R (r ^ n * x) |
CompositionSeries.Equivalent.trans | Mathlib.Order.JordanHolder | ∀ {X : Type u} [inst : Lattice X] [inst_1 : JordanHolderLattice X] {s₁ s₂ s₃ : CompositionSeries X},
s₁.Equivalent s₂ → s₂.Equivalent s₃ → s₁.Equivalent s₃ |
Filter.EventuallyLE.rfl | Mathlib.Order.Filter.Basic | ∀ {α : Type u} {β : Type v} [inst : Preorder β] {l : Filter α} {f : α → β}, f ≤ᶠ[l] f |
_private.Lean.Compiler.Old.0.Lean.Compiler.getDeclNamesForCodeGen.match_1 | Lean.Compiler.Old | (motive : Lean.Declaration → Sort u_1) →
(x : Lean.Declaration) →
((name : Lean.Name) →
(levelParams : List Lean.Name) →
(type value : Lean.Expr) →
(hints : Lean.ReducibilityHints) →
(safety : Lean.DefinitionSafety) →
(all : List Lean.Name) →
motive
(Lean.Declaration.defnDecl
{ name := name, levelParams := levelParams, type := type, value := value, hints := hints,
safety := safety, all := all })) →
((name : Lean.Name) →
(levelParams : List Lean.Name) →
(type value : Lean.Expr) →
(isUnsafe : Bool) →
(all : List Lean.Name) →
motive
(Lean.Declaration.opaqueDecl
{ name := name, levelParams := levelParams, type := type, value := value, isUnsafe := isUnsafe,
all := all })) →
((name : Lean.Name) →
(levelParams : List Lean.Name) →
(type : Lean.Expr) →
(isUnsafe : Bool) →
motive
(Lean.Declaration.axiomDecl
{ name := name, levelParams := levelParams, type := type, isUnsafe := isUnsafe })) →
((defs : List Lean.DefinitionVal) → motive (Lean.Declaration.mutualDefnDecl defs)) →
((x : Lean.Declaration) → motive x) → motive x |
IsCoprime.mono | Mathlib.RingTheory.Coprime.Basic | ∀ {R : Type u} [inst : CommSemiring R] {x y z w : R}, x ∣ y → z ∣ w → IsCoprime y w → IsCoprime x z |
_private.Mathlib.Algebra.Module.Presentation.Tensor.0.Module.Relations.tensor.match_1.eq_1 | Mathlib.Algebra.Module.Presentation.Tensor | ∀ {A : Type u_5} [inst : CommRing A] (relations₁ : Module.Relations A) (relations₂ : Module.Relations A)
(motive : relations₁.R × relations₂.G ⊕ relations₁.G × relations₂.R → Sort u_6) (r₁ : relations₁.R)
(g₂ : relations₂.G) (h_1 : (r₁ : relations₁.R) → (g₂ : relations₂.G) → motive (Sum.inl (r₁, g₂)))
(h_2 : (g₁ : relations₁.G) → (r₂ : relations₂.R) → motive (Sum.inr (g₁, r₂))),
(match Sum.inl (r₁, g₂) with
| Sum.inl (r₁, g₂) => h_1 r₁ g₂
| Sum.inr (g₁, r₂) => h_2 g₁ r₂) =
h_1 r₁ g₂ |
LinearMap.baseChange_comp | Mathlib.LinearAlgebra.TensorProduct.Tower | ∀ {R : Type u_1} {A : Type u_2} {M : Type u_4} {N : Type u_5} {P : Type u_6} [inst : CommSemiring R]
[inst_1 : Semiring A] [inst_2 : Algebra R A] [inst_3 : AddCommMonoid M] [inst_4 : AddCommMonoid N]
[inst_5 : AddCommMonoid P] [inst_6 : Module R M] [inst_7 : Module R N] [inst_8 : Module R P] (f : M →ₗ[R] N)
(g : N →ₗ[R] P), LinearMap.baseChange A (g ∘ₗ f) = LinearMap.baseChange A g ∘ₗ LinearMap.baseChange A f |
IsSl2Triple | Mathlib.Algebra.Lie.Sl2 | {L : Type u_2} → [LieRing L] → L → L → L → Prop |
SSet.PtSimplex.MulStruct.ctorIdx | Mathlib.AlgebraicTopology.SimplicialSet.KanComplex.MulStruct | {X : SSet} →
{n : ℕ} →
{x : X.obj (Opposite.op (SimplexCategory.mk 0))} → {f g fg : X.PtSimplex n x} → {i : Fin n} → f.MulStruct g fg i → ℕ |
UInt32.ofBitVec_add | Init.Data.UInt.Lemmas | ∀ (a b : BitVec 32), { toBitVec := a + b } = { toBitVec := a } + { toBitVec := b } |
bddAbove_range_mul | Mathlib.Algebra.Order.GroupWithZero.Bounds | ∀ {α : Type u_1} {β : Type u_2} [Nonempty α] {u v : α → β} [inst : Preorder β] [inst_1 : Zero β] [inst_2 : Mul β]
[PosMulMono β] [MulPosMono β],
BddAbove (Set.range u) → 0 ≤ u → BddAbove (Set.range v) → 0 ≤ v → BddAbove (Set.range (u * v)) |
Complex.tendsto_norm_tan_of_cos_eq_zero | Mathlib.Analysis.SpecialFunctions.Trigonometric.ComplexDeriv | ∀ {x : ℂ}, Complex.cos x = 0 → Filter.Tendsto (fun x => ‖Complex.tan x‖) (nhdsWithin x {x}ᶜ) Filter.atTop |
_private.Mathlib.Algebra.Group.Semiconj.Defs.0.SemiconjBy.transitive.match_1_1 | Mathlib.Algebra.Group.Semiconj.Defs | ∀ {S : Type u_1} [inst : Semigroup S]
(motive : (x x_1 x_2 : S) → (∃ c, SemiconjBy c x x_1) → (∃ c, SemiconjBy c x_1 x_2) → Prop) (x x_1 x_2 : S)
(x_3 : ∃ c, SemiconjBy c x x_1) (x_4 : ∃ c, SemiconjBy c x_1 x_2),
(∀ (x x_5 x_6 x_7 : S) (hx : SemiconjBy x_7 x x_5) (y : S) (hy : SemiconjBy y x_5 x_6), motive x x_5 x_6 ⋯ ⋯) →
motive x x_1 x_2 x_3 x_4 |
Subtype.t0Space | Mathlib.Topology.Separation.Basic | ∀ {X : Type u_1} [inst : TopologicalSpace X] [T0Space X] {p : X → Prop}, T0Space (Subtype p) |
groupHomology.cycles₁IsoOfIsTrivial.eq_1 | Mathlib.RepresentationTheory.Homological.GroupHomology.LowDegree | ∀ {k G : Type u} [inst : CommRing k] [inst_1 : Group G] (A : Rep k G) [inst_2 : A.IsTrivial],
groupHomology.cycles₁IsoOfIsTrivial A = (LinearEquiv.ofTop (groupHomology.cycles₁ A) ⋯).toModuleIso |
Matroid.subsingleton_indep._auto_1 | Mathlib.Combinatorics.Matroid.Loop | Lean.Syntax |
InfHom.withBot_toFun | Mathlib.Order.Hom.WithTopBot | ∀ {α : Type u_1} {β : Type u_2} [inst : SemilatticeInf α] [inst_1 : SemilatticeInf β] (f : InfHom α β) (a : WithBot α),
f.withBot a = WithBot.map (⇑f) a |
CategoryTheory.normalOfIsPushoutSndOfNormal._proof_4 | Mathlib.CategoryTheory.Limits.Shapes.NormalMono.Basic | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{P Q R S : C} {f : P ⟶ Q} {g : P ⟶ R} {h : Q ⟶ S} {k : R ⟶ S} [gn : CategoryTheory.NormalEpi g]
(comm : CategoryTheory.CategoryStruct.comp f h = CategoryTheory.CategoryStruct.comp g k)
(t : CategoryTheory.Limits.IsColimit (CategoryTheory.Limits.PushoutCocone.mk h k comm)),
0 = CategoryTheory.CategoryStruct.comp 0 f →
CategoryTheory.Limits.IsColimit (CategoryTheory.Limits.CokernelCofork.ofπ h ⋯) =
CategoryTheory.Limits.IsColimit (CategoryTheory.Limits.Cofork.ofπ h ⋯) |
Std.TreeSet.Raw.max?_eq_none_iff._simp_1 | Std.Data.TreeSet.Raw.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t : Std.TreeSet.Raw α cmp} [Std.TransCmp cmp],
t.WF → (t.max? = none) = (t.isEmpty = true) |
two_mul_le_add_mul_sq | Mathlib.Algebra.Order.Field.Basic | ∀ {α : Type u_2} [inst : Field α] [inst_1 : LinearOrder α] [IsStrictOrderedRing α] {a b ε : α},
0 < ε → 2 * a * b ≤ ε * a ^ 2 + ε⁻¹ * b ^ 2 |
CategoryTheory.Limits.IsImage.instInhabitedSelf | Mathlib.CategoryTheory.Limits.Shapes.Images | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{X Y : C} →
(f : X ⟶ Y) →
[inst_1 : CategoryTheory.Mono f] →
Inhabited (CategoryTheory.Limits.IsImage (CategoryTheory.Limits.MonoFactorisation.self f)) |
Lean.Elab.Command.ComputedFieldView.mk.injEq | Lean.Elab.MutualInductive | ∀ (ref modifiers : Lean.Syntax) (fieldId : Lean.Name) (type : Lean.Term)
(matchAlts : Lean.TSyntax `Lean.Parser.Term.matchAlts) (ref_1 modifiers_1 : Lean.Syntax) (fieldId_1 : Lean.Name)
(type_1 : Lean.Term) (matchAlts_1 : Lean.TSyntax `Lean.Parser.Term.matchAlts),
({ ref := ref, modifiers := modifiers, fieldId := fieldId, type := type, matchAlts := matchAlts } =
{ ref := ref_1, modifiers := modifiers_1, fieldId := fieldId_1, type := type_1, matchAlts := matchAlts_1 }) =
(ref = ref_1 ∧ modifiers = modifiers_1 ∧ fieldId = fieldId_1 ∧ type = type_1 ∧ matchAlts = matchAlts_1) |
Std.DTreeMap.Internal.Const.RoiSliceData.noConfusionType | Std.Data.DTreeMap.Internal.Zipper | Sort u_1 →
{α : Type u} →
{β : Type v} →
[inst : Ord α] →
Std.DTreeMap.Internal.Const.RoiSliceData α β →
{α' : Type u} → {β' : Type v} → [inst' : Ord α'] → Std.DTreeMap.Internal.Const.RoiSliceData α' β' → Sort u_1 |
Set.insert_diff_subset | Mathlib.Order.BooleanAlgebra.Set | ∀ {α : Type u_1} {s t : Set α} {a : α}, insert a s \ t ⊆ insert a (s \ t) |
MulRingSeminormClass | Mathlib.Algebra.Order.Hom.Basic | (F : Type u_7) →
(α : outParam (Type u_8)) →
(β : outParam (Type u_9)) → [NonAssocRing α] → [Semiring β] → [PartialOrder β] → [FunLike F α β] → Prop |
IsSumSq.natCast._simp_1 | Mathlib.Algebra.Ring.SumsOfSquares | ∀ {R : Type u_2} [inst : NonAssocSemiring R] (n : ℕ), IsSumSq ↑n = True |
Chebyshev.primeCounting_sub_theta_div_log_isBigO | Mathlib.NumberTheory.Chebyshev | (fun x => ↑⌊x⌋₊.primeCounting - Chebyshev.theta x / Real.log x) =O[Filter.atTop] fun x => x / Real.log x ^ 2 |
DFinsupp.liftAddHom_apply_single | Mathlib.Data.DFinsupp.BigOperators | ∀ {ι : Type u} {γ : Type w} {β : ι → Type v} [inst : DecidableEq ι] [inst_1 : (i : ι) → AddZeroClass (β i)]
[inst_2 : AddCommMonoid γ] (f : (i : ι) → β i →+ γ) (i : ι) (x : β i),
((DFinsupp.liftAddHom f) fun₀ | i => x) = (f i) x |
Lean.MessageData.ofWidget.sizeOf_spec | Lean.Message | ∀ (a : Lean.Widget.WidgetInstance) (a_1 : Lean.MessageData),
sizeOf (Lean.MessageData.ofWidget a a_1) = 1 + sizeOf a + sizeOf a_1 |
star_left_conjugate_le_conjugate | Mathlib.Algebra.Order.Star.Basic | ∀ {R : Type u_1} [inst : NonUnitalSemiring R] [inst_1 : PartialOrder R] [inst_2 : StarRing R] [StarOrderedRing R]
{a b : R}, a ≤ b → ∀ (c : R), star c * a * c ≤ star c * b * c |
CategoryTheory.GrpObj.zpow_comp_assoc | Mathlib.CategoryTheory.Monoidal.Cartesian.Grp_ | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.CartesianMonoidalCategory C]
{G H X : C} [inst_2 : CategoryTheory.GrpObj G] [inst_3 : CategoryTheory.GrpObj H] (f : X ⟶ G) (n : ℤ) (g : G ⟶ H)
[CategoryTheory.IsMonHom g] {Z : C} (h : H ⟶ Z),
CategoryTheory.CategoryStruct.comp (f ^ n) (CategoryTheory.CategoryStruct.comp g h) =
CategoryTheory.CategoryStruct.comp (CategoryTheory.CategoryStruct.comp f g ^ n) h |
_private.Lean.Meta.Constructions.CtorElim.0.Lean.reassocMax.maxArgs._sparseCasesOn_1 | Lean.Meta.Constructions.CtorElim | {motive : Lean.Level → Sort u} →
(t : Lean.Level) → ((a a_1 : Lean.Level) → motive (a.max a_1)) → (Nat.hasNotBit 4 t.ctorIdx → motive t) → motive t |
_private.Lean.Util.Diff.0.Lean.Diff.Histogram.addLeft.match_1 | Lean.Util.Diff | {α : Type u_1} →
{lsize rsize : ℕ} →
(motive : Option (Lean.Diff.Histogram.Entry α lsize rsize) → Sort u_2) →
(x : Option (Lean.Diff.Histogram.Entry α lsize rsize)) →
(Unit → motive none) → ((x : Lean.Diff.Histogram.Entry α lsize rsize) → motive (some x)) → motive x |
Cardinal.mk_range_inr | Mathlib.SetTheory.Cardinal.Basic | ∀ {α : Type u} {β : Type v}, Cardinal.mk ↑(Set.range Sum.inr) = Cardinal.lift.{u, v} (Cardinal.mk β) |
Lean.Parser.Term.set_option.formatter | Lean.Parser.Command | Lean.PrettyPrinter.Formatter |
WeakFEPair.f_modif_aux1 | Mathlib.NumberTheory.LSeries.AbstractFuncEq | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℂ E] (P : WeakFEPair E),
Set.EqOn (fun x => P.f_modif x - P.f x + P.f₀)
(((Set.Ioo 0 1).indicator fun x => P.f₀ - (P.ε * ↑(x ^ (-P.k))) • P.g₀) + {1}.indicator fun x => P.f₀ - P.f 1)
(Set.Ioi 0) |
AlgebraicGeometry.Scheme.IdealSheafData.glueDataObjHom.congr_simp | Mathlib.AlgebraicGeometry.IdealSheaf.Subscheme | ∀ {X : AlgebraicGeometry.Scheme} {I J : X.IdealSheafData} (h : I ≤ J) (U : ↑X.affineOpens),
AlgebraicGeometry.Scheme.IdealSheafData.glueDataObjHom h U =
AlgebraicGeometry.Scheme.IdealSheafData.glueDataObjHom h U |
SkewMonoidAlgebra.mapDomain_smul | Mathlib.Algebra.SkewMonoidAlgebra.Basic | ∀ {k : Type u_1} {G : Type u_2} [inst : AddCommMonoid k] {G' : Type u_3} {f : G → G'} {v : SkewMonoidAlgebra k G}
{R : Type u_5} [inst_1 : Monoid R] [inst_2 : DistribMulAction R k] {b : R},
(SkewMonoidAlgebra.mapDomain f) (b • v) = b • (SkewMonoidAlgebra.mapDomain f) v |
MulEquiv.monoidHomCongrLeft.eq_1 | Mathlib.Algebra.Group.Equiv.Basic | ∀ {M₁ : Type u_5} {M₂ : Type u_6} {N : Type u_8} [inst : MulOneClass M₁] [inst_1 : MulOneClass M₂]
[inst_2 : CommMonoid N] (e : M₁ ≃* M₂), e.monoidHomCongrLeft = { toEquiv := e.monoidHomCongrLeftEquiv, map_mul' := ⋯ } |
_private.Lean.Util.ParamMinimizer.0.Lean.Util.ParamMinimizer.Context.maxCalls | Lean.Util.ParamMinimizer | {m : Type → Type} → Lean.Util.ParamMinimizer.Context✝ m → ℕ |
SimpleGraph.Embedding.sumInl | Mathlib.Combinatorics.SimpleGraph.Sum | {V : Type u_1} → {W : Type u_2} → {G : SimpleGraph V} → {H : SimpleGraph W} → G ↪g G ⊕g H |
CStarAlgebra.pow_nonneg._auto_1 | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Order | Lean.Syntax |
AddSubgroup.instPartialOrder.eq_1 | Mathlib.Algebra.Group.Subgroup.Defs | ∀ {G : Type u_1} [inst : AddGroup G], AddSubgroup.instPartialOrder = PartialOrder.ofSetLike (AddSubgroup G) G |
MeasureTheory.isTightMeasureSet_iff_exists_isCompact_measure_compl_le | Mathlib.MeasureTheory.Measure.Tight | ∀ {𝓧 : Type u_1} {m𝓧 : MeasurableSpace 𝓧} {S : Set (MeasureTheory.Measure 𝓧)} [inst : TopologicalSpace 𝓧],
MeasureTheory.IsTightMeasureSet S ↔ ∀ (ε : ENNReal), 0 < ε → ∃ K, IsCompact K ∧ ∀ μ ∈ S, μ Kᶜ ≤ ε |
SimpleGraph.IsEdgeReachable.rfl | Mathlib.Combinatorics.SimpleGraph.Connectivity.EdgeConnectivity | ∀ {V : Type u_1} {G : SimpleGraph V} {k : ℕ} (u : V), G.IsEdgeReachable k u u |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.