name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M |
|---|---|---|
LightProfinite.instInhabited._proof_3 | Mathlib.Topology.Category.LightProfinite.Basic | SecondCountableTopology PEmpty.{u_1 + 1} |
MDifferentiableOn.clm_bundle_apply₂ | Mathlib.Geometry.Manifold.VectorBundle.Hom | ∀ {𝕜 : Type u_1} {B : Type u_2} {F₁ : Type u_3} {F₂ : Type u_4} {F₃ : Type u_5} {M : Type u_6}
[inst : NontriviallyNormedField 𝕜] {E₁ : B → Type u_7} [inst_1 : (x : B) → AddCommGroup (E₁ x)]
[inst_2 : (x : B) → Module 𝕜 (E₁ x)] [inst_3 : NormedAddCommGroup F₁] [inst_4 : NormedSpace 𝕜 F₁]
[inst_5 : TopologicalSpace (Bundle.TotalSpace F₁ E₁)] [inst_6 : (x : B) → TopologicalSpace (E₁ x)] {E₂ : B → Type u_8}
[inst_7 : (x : B) → AddCommGroup (E₂ x)] [inst_8 : (x : B) → Module 𝕜 (E₂ x)] [inst_9 : NormedAddCommGroup F₂]
[inst_10 : NormedSpace 𝕜 F₂] [inst_11 : TopologicalSpace (Bundle.TotalSpace F₂ E₂)]
[inst_12 : (x : B) → TopologicalSpace (E₂ x)] {E₃ : B → Type u_9} [inst_13 : (x : B) → AddCommGroup (E₃ x)]
[inst_14 : (x : B) → Module 𝕜 (E₃ x)] [inst_15 : NormedAddCommGroup F₃] [inst_16 : NormedSpace 𝕜 F₃]
[inst_17 : TopologicalSpace (Bundle.TotalSpace F₃ E₃)] [inst_18 : (x : B) → TopologicalSpace (E₃ x)] {EB : Type u_10}
[inst_19 : NormedAddCommGroup EB] [inst_20 : NormedSpace 𝕜 EB] {HB : Type u_11} [inst_21 : TopologicalSpace HB]
{IB : ModelWithCorners 𝕜 EB HB} [inst_22 : TopologicalSpace B] [inst_23 : ChartedSpace HB B] {EM : Type u_12}
[inst_24 : NormedAddCommGroup EM] [inst_25 : NormedSpace 𝕜 EM] {HM : Type u_13} [inst_26 : TopologicalSpace HM]
{IM : ModelWithCorners 𝕜 EM HM} [inst_27 : TopologicalSpace M] [inst_28 : ChartedSpace HM M]
[inst_29 : FiberBundle F₁ E₁] [inst_30 : VectorBundle 𝕜 F₁ E₁] [inst_31 : FiberBundle F₂ E₂]
[inst_32 : VectorBundle 𝕜 F₂ E₂] [inst_33 : FiberBundle F₃ E₃] [inst_34 : VectorBundle 𝕜 F₃ E₃] {b : M → B}, ⋯ |
List.erase_eq_eraseIdx | Init.Data.List.Erase | ∀ {α : Type u_1} [inst : BEq α] (l : List α) (a : α),
l.erase a =
match List.idxOf? a l with
| none => l
| some i => l.eraseIdx i |
Bool.or_eq_true_iff | Init.Data.Bool | ∀ {x y : Bool}, (x || y) = true ↔ x = true ∨ y = true |
ContinuousLinearEquiv.symm_comp_self | Mathlib.Topology.Algebra.Module.Equiv | ∀ {R₁ : Type u_1} {R₂ : Type u_2} [inst : Semiring R₁] [inst_1 : Semiring R₂] {σ₁₂ : R₁ →+* R₂} {σ₂₁ : R₂ →+* R₁}
[inst_2 : RingHomInvPair σ₁₂ σ₂₁] [inst_3 : RingHomInvPair σ₂₁ σ₁₂] {M₁ : Type u_4} [inst_4 : TopologicalSpace M₁]
[inst_5 : AddCommMonoid M₁] {M₂ : Type u_5} [inst_6 : TopologicalSpace M₂] [inst_7 : AddCommMonoid M₂]
[inst_8 : Module R₁ M₁] [inst_9 : Module R₂ M₂] (e : M₁ ≃SL[σ₁₂] M₂), ⇑e.symm ∘ ⇑e = id |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.Equiv.getKeyD_eq._simp_1_2 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {instOrd : Ord α} {a b : α}, (compare a b ≠ Ordering.eq) = ((a == b) = false) |
LocallyConstant.instNonAssocSemiring._proof_5 | Mathlib.Topology.LocallyConstant.Algebra | ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] [inst_1 : NonAssocSemiring Y] (x : ℕ)
(x_1 : LocallyConstant X Y), ⇑(x • x_1) = ⇑(x • x_1) |
_private.Init.Data.Option.Lemmas.0.Option.none_lt._simp_1_1 | Init.Data.Option.Lemmas | ∀ {α : Type u_1} [inst : LT α] {a : α}, (none < some a) = True |
Interval.addCommMonoid._proof_4 | Mathlib.Algebra.Order.Interval.Basic | ∀ {α : Type u_1} [inst : AddCommMonoid α] [inst_1 : Preorder α] [inst_2 : IsOrderedAddMonoid α] (a : Interval α),
0 + a = a |
cfc_inv | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Unital | ∀ {R : Type u_1} {A : Type u_2} {p : A → Prop} [inst : Semifield R] [inst_1 : StarRing R] [inst_2 : MetricSpace R]
[inst_3 : IsTopologicalSemiring R] [inst_4 : ContinuousStar R] [inst_5 : TopologicalSpace A] [inst_6 : Ring A]
[inst_7 : StarRing A] [inst_8 : Algebra R A] [inst_9 : ContinuousFunctionalCalculus R A p] [ContinuousInv₀ R]
(f : R → R) (a : A),
(∀ x ∈ spectrum R a, f x ≠ 0) →
autoParam (ContinuousOn f (spectrum R a)) cfc_inv._auto_1 →
autoParam (p a) cfc_inv._auto_3 → cfc (fun x => (f x)⁻¹) a = Ring.inverse (cfc f a) |
Std.TreeMap.getKey?_ofList_of_contains_eq_false | Std.Data.TreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} [Std.TransCmp cmp] [inst : BEq α] [Std.LawfulBEqCmp cmp]
{l : List (α × β)} {k : α}, (List.map Prod.fst l).contains k = false → (Std.TreeMap.ofList l cmp).getKey? k = none |
UInt8.toUSize_ofNat' | Init.Data.UInt.Lemmas | ∀ {n : ℕ}, n < UInt8.size → (UInt8.ofNat n).toUSize = USize.ofNat n |
ZMod.dft_eq_fourier | Mathlib.Analysis.Fourier.ZMod | ∀ {N : ℕ} [inst : NeZero N] {E : Type u_2} [inst_1 : NormedAddCommGroup E] [inst_2 : NormedSpace ℂ E] [CompleteSpace E]
(Φ : ZMod N → E) (k : ZMod N), ZMod.dft Φ k = Fourier.fourierIntegral ZMod.toCircle MeasureTheory.Measure.count Φ k |
ContextFreeGrammar.produces_reverse | Mathlib.Computability.ContextFreeGrammar | ∀ {T : Type u_1} {g : ContextFreeGrammar T} {u v : List (Symbol T g.NT)},
g.reverse.Produces u.reverse v.reverse ↔ g.Produces u v |
_private.Init.Data.List.Lemmas.0.List.mem_map.match_1_1 | Init.Data.List.Lemmas | ∀ {α : Type u_1} (motive : List α → Prop) (x : List α),
(∀ (a : Unit), motive []) → (∀ (head : α) (l : List α), motive (head :: l)) → motive x |
_private.Mathlib.Probability.Kernel.IonescuTulcea.Maps.0.IocProdIoc_preimage.match_1_9 | Mathlib.Probability.Kernel.IonescuTulcea.Maps | ∀ {ι : Type u_1} [inst : LinearOrder ι] {a b : ι} (i : ι) (motive : a < i ∧ i ≤ b → Prop) (x : a < i ∧ i ≤ b),
(∀ (hi1 : a < i) (hi2 : i ≤ b), motive ⋯) → motive x |
Sym2.card_toFinset | Mathlib.Data.Sym.Sym2 | ∀ {α : Type u_1} [inst : DecidableEq α] (z : Sym2 α), z.toFinset.card = if z.IsDiag then 1 else 2 |
AffineSpace.vadd_asymptoticNhds | Mathlib.Topology.Algebra.AsymptoticCone | ∀ {k : Type u_1} {V : Type u_2} {P : Type u_3} [inst : Field k] [inst_1 : LinearOrder k] [inst_2 : AddCommGroup V]
[inst_3 : Module k V] [inst_4 : AddTorsor V P] [inst_5 : TopologicalSpace V] (u v : V),
u +ᵥ AffineSpace.asymptoticNhds k P v = AffineSpace.asymptoticNhds k P v |
_private.Mathlib.RingTheory.Coprime.Basic.0.IsCoprime.isUnit_of_dvd.match_1_1 | Mathlib.RingTheory.Coprime.Basic | ∀ {R : Type u_1} [inst : CommSemiring R] {x y : R} (motive : x ∣ y → Prop) (d : x ∣ y),
(∀ (k : R) (hk : y = x * k), motive ⋯) → motive d |
SubMulAction.instSetLike.eq_1 | Mathlib.GroupTheory.GroupAction.SubMulAction | ∀ {R : Type u} {M : Type v} [inst : SMul R M],
SubMulAction.instSetLike = { coe := SubMulAction.carrier, coe_injective' := ⋯ } |
_private.Init.Data.List.MapIdx.0.List.length_mapIdx_go._proof_1_6 | Init.Data.List.MapIdx | ∀ {α : Type u_1} {β : Type u_2} (l : List α) (x : Array β), ¬l.length + (x.size + 1) = l.length + 1 + x.size → False |
subset_sInf_def | Mathlib.Order.CompleteLatticeIntervals | ∀ {α : Type u_2} (s : Set α) [inst : Preorder α] [inst_1 : InfSet α] [inst_2 : Inhabited ↑s],
sInf = fun t =>
if ht : t.Nonempty ∧ BddBelow t ∧ sInf (Subtype.val '' t) ∈ s then ⟨sInf (Subtype.val '' t), ⋯⟩ else default |
Std.ExtTreeMap.maxKeyD_insert | Std.Data.ExtTreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.ExtTreeMap α β cmp} [inst : Std.TransCmp cmp] {k : α}
{v : β} {fallback : α},
(t.insert k v).maxKeyD fallback = t.maxKey?.elim k fun k' => if (cmp k' k).isLE = true then k else k' |
FreeAddMagma.below | Mathlib.Algebra.Free | {α : Type u} → {motive : FreeAddMagma α → Sort u_1} → FreeAddMagma α → Sort (max (u + 1) u_1) |
Lean.Elab.Tactic.BVDecide.Frontend.ReifiedBVPred.boolAtom | Lean.Elab.Tactic.BVDecide.Frontend.BVDecide.ReifiedBVPred | Lean.Expr → Lean.Elab.Tactic.BVDecide.Frontend.M (Option Lean.Elab.Tactic.BVDecide.Frontend.ReifiedBVPred) |
Subsemiring.nonneg._proof_1 | Mathlib.Algebra.Ring.Subsemiring.Order | ∀ (R : Type u_1) [inst : Semiring R] [inst_1 : PartialOrder R] [IsOrderedRing R], AddLeftMono R |
Array.popWhile._unsafe_rec | Init.Data.Array.Basic | {α : Type u} → (α → Bool) → Array α → Array α |
CategoryTheory.Sigma.natIso_inv | Mathlib.CategoryTheory.Sigma.Basic | ∀ {I : Type w₁} {C : I → Type u₁} [inst : (i : I) → CategoryTheory.Category.{v₁, u₁} (C i)] {D : Type u₂}
[inst_1 : CategoryTheory.Category.{v₂, u₂} D] {q₁ q₂ : CategoryTheory.Functor ((i : I) × C i) D}
(h : (i : I) → (CategoryTheory.Sigma.incl i).comp q₁ ≅ (CategoryTheory.Sigma.incl i).comp q₂),
(CategoryTheory.Sigma.natIso h).inv = CategoryTheory.Sigma.natTrans fun i => (h i).inv |
CategoryTheory.MorphismProperty.isStableUnderTransfiniteCompositionOfShape_iff | Mathlib.CategoryTheory.MorphismProperty.TransfiniteComposition | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (W : CategoryTheory.MorphismProperty C) (J : Type w)
[inst_1 : LinearOrder J] [inst_2 : SuccOrder J] [inst_3 : OrderBot J] [inst_4 : WellFoundedLT J],
W.IsStableUnderTransfiniteCompositionOfShape J ↔ W.transfiniteCompositionsOfShape J ≤ W |
NonUnitalRingHom.snd_comp_prod | Mathlib.Algebra.Ring.Prod | ∀ {R : Type u_1} {S : Type u_3} {T : Type u_5} [inst : NonUnitalNonAssocSemiring R]
[inst_1 : NonUnitalNonAssocSemiring S] [inst_2 : NonUnitalNonAssocSemiring T] (f : R →ₙ+* S) (g : R →ₙ+* T),
(NonUnitalRingHom.snd S T).comp (f.prod g) = g |
MeasureTheory.isFiniteMeasure_toFiniteAux | Mathlib.MeasureTheory.Measure.WithDensityFinite | ∀ {α : Type u_1} {mα : MeasurableSpace α} {μ : MeasureTheory.Measure α} [inst : MeasureTheory.SFinite μ],
MeasureTheory.IsFiniteMeasure μ.toFiniteAux |
List.head_cons | Init.Data.List.Basic | ∀ {α : Type u} {a : α} {l : List α} {h : a :: l ≠ []}, (a :: l).head h = a |
_private.Mathlib.MeasureTheory.MeasurableSpace.Constructions.0.measurable_from_prod_countable_left'._simp_1_1 | Mathlib.MeasureTheory.MeasurableSpace.Constructions | ∀ {α : Type u} {β : Type v} {f : α → β} {s : Set β} {a : α}, (a ∈ f ⁻¹' s) = (f a ∈ s) |
Std.DHashMap.instForInSigmaOfMonad | Std.Data.DHashMap.Basic | {α : Type u} →
{β : α → Type v} →
{m : Type w → Type w'} →
[Monad m] → [inst : BEq α] → [inst_1 : Hashable α] → ForIn m (Std.DHashMap α β) ((a : α) × β a) |
ThreeGPFree.of_image | Mathlib.Combinatorics.Additive.AP.Three.Defs | ∀ {α : Type u_2} {β : Type u_3} [inst : CommMonoid α] [inst_1 : CommMonoid β] {s A : Set α} {t : Set β} {f : α → β},
IsMulFreimanHom 2 s t f → Set.InjOn f s → A ⊆ s → ThreeGPFree (f '' A) → ThreeGPFree A |
Std.Tactic.BVDecide.BVExpr.bitblast.FullAdderOutput.aig | Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Add | {α : Type} →
[inst : Hashable α] →
[inst_1 : DecidableEq α] →
{old : Std.Sat.AIG α} → Std.Tactic.BVDecide.BVExpr.bitblast.FullAdderOutput old → Std.Sat.AIG α |
_private.Lean.Parser.Module.0.Lean.Parser.parseCommand.match_1 | Lean.Parser.Module | (motive : Option Lean.Parser.Error → Sort u_1) →
(x : Option Lean.Parser.Error) →
(Unit → motive none) → ((errorMsg : Lean.Parser.Error) → motive (some errorMsg)) → motive x |
CoalgCat.concreteCategory._proof_1 | Mathlib.Algebra.Category.CoalgCat.Basic | ∀ {R : Type u_2} [inst : CommRing R] {X Y : CoalgCat R} (f : ↑X.toModuleCat →ₗc[R] ↑Y.toModuleCat),
{ toCoalgHom' := f }.toCoalgHom' = f |
Submonoid.mem_map_iff_mem | Mathlib.Algebra.Group.Submonoid.Operations | ∀ {M : Type u_1} {N : Type u_2} [inst : MulOneClass M] [inst_1 : MulOneClass N] {F : Type u_4} [inst_2 : FunLike F M N]
[mc : MonoidHomClass F M N] {f : F},
Function.Injective ⇑f → ∀ {S : Submonoid M} {x : M}, f x ∈ Submonoid.map f S ↔ x ∈ S |
CategoryTheory.Limits.Sigma.reindex | Mathlib.CategoryTheory.Limits.Shapes.Products | {β : Type w} →
{C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{γ : Type w'} →
(ε : β ≃ γ) →
(f : γ → C) →
[inst_1 : CategoryTheory.Limits.HasCoproduct f] →
[inst_2 : CategoryTheory.Limits.HasCoproduct (f ∘ ⇑ε)] → ∐ f ∘ ⇑ε ≅ ∐ f |
Lean.Meta.Grind.InjectiveInfo.mk.noConfusion | Lean.Meta.Tactic.Grind.Types | {P : Sort u} →
{us : List Lean.Level} →
{α β h : Lean.Expr} →
{inv? : Option (Lean.Expr × Lean.Expr)} →
{us' : List Lean.Level} →
{α' β' h' : Lean.Expr} →
{inv?' : Option (Lean.Expr × Lean.Expr)} →
{ us := us, α := α, β := β, h := h, inv? := inv? } =
{ us := us', α := α', β := β', h := h', inv? := inv?' } →
(us = us' → α = α' → β = β' → h = h' → inv? = inv?' → P) → P |
_private.Mathlib.Data.List.Basic.0.List.erase_getElem._proof_1_31 | Mathlib.Data.List.Basic | ∀ {ι : Type u_1} [inst : BEq ι] [inst_1 : LawfulBEq ι] (a : ι) (l : List ι) (n : ℕ) (hi : n + 1 < (a :: l).length)
(w : ι) (h_5 : (a == (a :: l)[n + 1]) = true) (h_8 : (((a :: l).erase (a :: l)[n + 1])[n] == w) = true),
(List.findIdxs (fun x => x == w) (a :: l))[0] < (a :: l).length |
Units.mulLECancellable_val | Mathlib.Algebra.Order.Monoid.Unbundled.Units | ∀ {M : Type u_1} [inst : Monoid M] [inst_1 : LE M] [MulLeftMono M] (u : Mˣ), MulLECancellable ↑u |
CategoryTheory.Subobject.map_mk | Mathlib.CategoryTheory.Subobject.Basic | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {A X Y : C} (i : A ⟶ X) [inst_1 : CategoryTheory.Mono i]
(f : X ⟶ Y) [inst_2 : CategoryTheory.Mono f],
(CategoryTheory.Subobject.map f).obj (CategoryTheory.Subobject.mk i) =
CategoryTheory.Subobject.mk (CategoryTheory.CategoryStruct.comp i f) |
Std.Time.Duration.subHours | Std.Time.Duration | Std.Time.Duration → Std.Time.Hour.Offset → Std.Time.Duration |
Std.DHashMap.Internal.Raw₀.get!_alter | Std.Data.DHashMap.Internal.RawLemmas | ∀ {α : Type u} {β : α → Type v} (m : Std.DHashMap.Internal.Raw₀ α β) [inst : BEq α] [inst_1 : Hashable α]
[inst_2 : LawfulBEq α] {k k' : α},
(↑m).WF →
∀ [inst_3 : Inhabited (β k')] {f : Option (β k) → Option (β k)},
(m.alter k f).get! k' = if heq : (k == k') = true then (Option.map (cast ⋯) (f (m.get? k))).get! else m.get! k' |
Lean.Meta.MVarRenaming.noConfusionType | Lean.Meta.Match.MVarRenaming | Sort u → Lean.Meta.MVarRenaming → Lean.Meta.MVarRenaming → Sort u |
Absorbs.sInter | Mathlib.Topology.Bornology.Absorbs | ∀ {G₀ : Type u_1} {α : Type u_2} [inst : GroupWithZero G₀] [inst_1 : Bornology G₀] [inst_2 : MulAction G₀ α] {t : Set α}
{S : Set (Set α)}, S.Finite → (∀ s ∈ S, Absorbs G₀ s t) → Absorbs G₀ (⋂₀ S) t |
CategoryTheory.MonoOver.imageForgetAdj._proof_1 | Mathlib.CategoryTheory.Subobject.MonoOver | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {X : C} [inst_1 : CategoryTheory.Limits.HasImages C]
(f : CategoryTheory.Over X) (g : CategoryTheory.MonoOver X) (k : f ⟶ (CategoryTheory.MonoOver.forget X).obj g),
(fun k =>
CategoryTheory.Over.homMk
(CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.factorThruImage f.hom) k.hom.left) ⋯)
((fun k =>
CategoryTheory.MonoOver.homMk
(CategoryTheory.Limits.image.lift { I := g.obj.left, m := g.arrow, m_mono := ⋯, e := k.left, fac := ⋯ }) ⋯)
k) =
k |
AddActionHom.prodMap._proof_2 | Mathlib.GroupTheory.GroupAction.Hom | ∀ {M : Type u_5} {N : Type u_6} {α : Type u_1} {β : Type u_2} {γ : Type u_4} {δ : Type u_3} [inst : VAdd M α]
[inst_1 : VAdd M β] [inst_2 : VAdd N γ] [inst_3 : VAdd N δ] {σ : M → N} (f : α →ₑ[σ] γ) (g : β →ₑ[σ] δ) (m : M)
(x : α × β),
((f.comp (AddActionHom.fst M α β)).prod (g.comp (AddActionHom.snd M α β))).toFun (m +ᵥ x) =
σ m +ᵥ ((f.comp (AddActionHom.fst M α β)).prod (g.comp (AddActionHom.snd M α β))).toFun x |
Lean.DefinitionVal.getSafetyEx | Lean.Declaration | Lean.DefinitionVal → Lean.DefinitionSafety |
CategoryTheory.Functor.WellOrderInductionData.ofExists._proof_4 | Mathlib.CategoryTheory.SmallObject.WellOrderInductionData | ∀ {J : Type u_1} [inst : LinearOrder J] [inst_1 : SuccOrder J] {F : CategoryTheory.Functor Jᵒᵖ (Type u_2)}
(h₁ : ∀ (j : J), ¬IsMax j → Function.Surjective (F.map (CategoryTheory.homOfLE ⋯).op)) (j : J) (hj : ¬IsMax j)
(x : F.obj (Opposite.op j)), F.map (CategoryTheory.homOfLE ⋯).op ⋯.choose = x |
Aesop.EqualUpToIdsM.run' | Aesop.Util.EqualUpToIds | {α : Type} →
Aesop.EqualUpToIdsM α →
Option Lean.MetavarContext →
Lean.MetavarContext → Lean.MetavarContext → Bool → Lean.MetaM (α × Aesop.EqualUpToIdsM.State) |
Lean.isIdRestAscii | Init.Meta.Defs | UInt8 → Bool |
_private.Mathlib.Order.Interval.Finset.Basic.0.Finset.Ici_erase._simp_1_4 | Mathlib.Order.Interval.Finset.Basic | ∀ {α : Type u_2} [inst : PartialOrder α] {a b : α}, (a < b) = (a ≤ b ∧ a ≠ b) |
Lean.Grind.CommRing.Poly.combine.go.eq_5 | Init.Grind.Ring.CommSolver | ∀ (fuel_2 : ℕ) (k₁ : ℤ) (m₁ : Lean.Grind.CommRing.Mon) (p₁_2 : Lean.Grind.CommRing.Poly) (k₂ : ℤ)
(m₂ : Lean.Grind.CommRing.Mon) (p₂_2 : Lean.Grind.CommRing.Poly),
Lean.Grind.CommRing.Poly.combine.go fuel_2.succ (Lean.Grind.CommRing.Poly.add k₁ m₁ p₁_2)
(Lean.Grind.CommRing.Poly.add k₂ m₂ p₂_2) =
match m₁.grevlex m₂ with
| Ordering.eq =>
have k := k₁ + k₂;
bif k == 0 then Lean.Grind.CommRing.Poly.combine.go fuel_2 p₁_2 p₂_2
else Lean.Grind.CommRing.Poly.add k m₁ (Lean.Grind.CommRing.Poly.combine.go fuel_2 p₁_2 p₂_2)
| Ordering.gt =>
Lean.Grind.CommRing.Poly.add k₁ m₁
(Lean.Grind.CommRing.Poly.combine.go fuel_2 p₁_2 (Lean.Grind.CommRing.Poly.add k₂ m₂ p₂_2))
| Ordering.lt =>
Lean.Grind.CommRing.Poly.add k₂ m₂
(Lean.Grind.CommRing.Poly.combine.go fuel_2 (Lean.Grind.CommRing.Poly.add k₁ m₁ p₁_2) p₂_2) |
Int32.maxValue_le_iff._simp_1 | Init.Data.SInt.Lemmas | ∀ {a : Int32}, (Int32.maxValue ≤ a) = (a = Int32.maxValue) |
Filter.Germ.instAddAction._proof_2 | Mathlib.Order.Filter.Germ.Basic | ∀ {α : Type u_1} {β : Type u_2} {l : Filter α} {M : Type u_3} [inst : AddMonoid M] [inst_1 : AddAction M β] (f : α → β),
0 +ᵥ ↑f = ↑f |
RingHom.FinitePresentation.comp_surjective | Mathlib.RingTheory.FinitePresentation | ∀ {A : Type u_1} {B : Type u_2} {C : Type u_3} [inst : CommRing A] [inst_1 : CommRing B] [inst_2 : CommRing C]
{f : A →+* B} {g : B →+* C},
f.FinitePresentation → Function.Surjective ⇑g → (RingHom.ker g).FG → (g.comp f).FinitePresentation |
CategoryTheory.WithTerminal.coneEquiv._proof_5 | Mathlib.CategoryTheory.WithTerminal.Cone | ∀ {C : Type u_4} [inst : CategoryTheory.Category.{u_2, u_4} C] {J : Type u_3}
[inst_1 : CategoryTheory.Category.{u_1, u_3} J] {X : C} {K : CategoryTheory.Functor J (CategoryTheory.Over X)}
{X_1 Y : CategoryTheory.Limits.Cone (CategoryTheory.WithTerminal.liftFromOver.obj K)} (f : X_1 ⟶ Y),
CategoryTheory.CategoryStruct.comp
((CategoryTheory.WithTerminal.coneBack✝.comp CategoryTheory.WithTerminal.coneLift✝).map f)
((fun t =>
CategoryTheory.Limits.Cone.ext
(CategoryTheory.Iso.refl
((CategoryTheory.WithTerminal.coneBack✝¹.comp CategoryTheory.WithTerminal.coneLift✝¹).obj t).pt)
⋯)
Y).hom =
CategoryTheory.CategoryStruct.comp
((fun t =>
CategoryTheory.Limits.Cone.ext
(CategoryTheory.Iso.refl
((CategoryTheory.WithTerminal.coneBack✝².comp CategoryTheory.WithTerminal.coneLift✝²).obj t).pt)
⋯)
X_1).hom
((CategoryTheory.Functor.id (CategoryTheory.Limits.Cone (CategoryTheory.WithTerminal.liftFromOver.obj K))).map f) |
SubgroupClass.inclusion_self | Mathlib.Algebra.Group.Subgroup.Defs | ∀ {G : Type u_1} [inst : Group G] {S : Type u_4} {H : S} [inst_1 : SetLike S G] [inst_2 : SubgroupClass S G]
[inst_3 : Preorder S] [inst_4 : IsConcreteLE S G] (x : ↥H), (SubgroupClass.inclusion ⋯) x = x |
Congruent.index_equiv._simp_1 | Mathlib.Topology.MetricSpace.Congruence | ∀ {ι : Type u_1} {ι' : Type u_2} {P₁ : Type u_3} {P₂ : Type u_4} [inst : PseudoEMetricSpace P₁]
[inst_1 : PseudoEMetricSpace P₂] {E : Type u_7} [inst_2 : EquivLike E ι' ι] (f : E) (v₁ : ι → P₁) (v₂ : ι → P₂),
Congruent (v₁ ∘ ⇑f) (v₂ ∘ ⇑f) = Congruent v₁ v₂ |
diagonal_dotProduct | Mathlib.Data.Matrix.Mul | ∀ {m : Type u_2} {α : Type v} [inst : Fintype m] [inst_1 : DecidableEq m] [inst_2 : NonUnitalNonAssocSemiring α]
(v w : m → α) (i : m), Matrix.diagonal v i ⬝ᵥ w = v i * w i |
CategoryTheory.ShortComplex.descRightHomology | Mathlib.Algebra.Homology.ShortComplex.RightHomology | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
[inst_1 : CategoryTheory.Limits.HasZeroMorphisms C] →
(S : CategoryTheory.ShortComplex C) →
{A : C} →
(k : S.X₂ ⟶ A) →
CategoryTheory.CategoryStruct.comp S.f k = 0 → [inst_2 : S.HasRightHomology] → S.rightHomology ⟶ A |
CategoryTheory.Limits.Types.limitConeIsLimit._proof_1 | Mathlib.CategoryTheory.Limits.Types.Limits | ∀ {J : Type u_3} [inst : CategoryTheory.Category.{u_1, u_3} J] (F : CategoryTheory.Functor J (Type (max u_3 u_2)))
(s : CategoryTheory.Limits.Cone F) (j : J),
CategoryTheory.CategoryStruct.comp (fun v => ⟨fun j => s.π.app j v, ⋯⟩)
((CategoryTheory.Limits.Types.limitCone F).π.app j) =
s.π.app j |
_private.Std.Data.DHashMap.Lemmas.0.Std.DHashMap.size_union_of_not_mem._simp_1_1 | Std.Data.DHashMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {x : BEq α} {x_1 : Hashable α} {m : Std.DHashMap α β} {k : α},
(k ∉ m) = (m.contains k = false) |
List.range'_eq_singleton_iff._simp_1 | Init.Data.List.Nat.Range | ∀ {s n a : ℕ}, (List.range' s n = [a]) = (s = a ∧ n = 1) |
CommBialgCat.isoEquivBialgEquiv._proof_1 | Mathlib.Algebra.Category.CommBialgCat | ∀ {R : Type u_2} [inst : CommRing R] {X Y : Type u_1} [inst_1 : CommRing X] [inst_2 : Bialgebra R X]
[inst_3 : CommRing Y] [inst_4 : Bialgebra R Y] (x : CommBialgCat.of R X ≅ CommBialgCat.of R Y),
CommBialgCat.isoMk (CommBialgCat.bialgEquivOfIso x) = CommBialgCat.isoMk (CommBialgCat.bialgEquivOfIso x) |
AddEquiv.ext_int_iff | Mathlib.Data.Int.Cast.Lemmas | ∀ {A : Type u_5} [inst : AddMonoid A] {f g : ℤ ≃+ A}, f = g ↔ f 1 = g 1 |
logDeriv.eq_1 | Mathlib.Analysis.Calculus.LogDeriv | ∀ {𝕜 : Type u_1} {𝕜' : Type u_2} [inst : NontriviallyNormedField 𝕜] [inst_1 : NontriviallyNormedField 𝕜']
[inst_2 : NormedAlgebra 𝕜 𝕜'] (f : 𝕜 → 𝕜'), logDeriv f = deriv f / f |
Lean.Server.FileWorker.SignatureHelp.CandidateKind.toCtorIdx | Lean.Server.FileWorker.SignatureHelp | Lean.Server.FileWorker.SignatureHelp.CandidateKind → ℕ |
_private.Mathlib.MeasureTheory.Integral.IntervalIntegral.TrapezoidalRule.0.trapezoidal_error_le_of_lt._simp_1_4 | Mathlib.MeasureTheory.Integral.IntervalIntegral.TrapezoidalRule | ∀ {α : Type u_2} [inst : Zero α] [inst_1 : OfNat α 4] [NeZero 4], (4 = 0) = False |
ContinuousLinearMap.instMeasurableSpace._proof_1 | Mathlib.MeasureTheory.Constructions.BorelSpace.ContinuousLinearMap | ∀ {F : Type u_1} [inst : NormedAddCommGroup F], IsTopologicalAddGroup F |
Path.trans_apply | Mathlib.Topology.Path | ∀ {X : Type u_1} [inst : TopologicalSpace X] {x y z : X} (γ : Path x y) (γ' : Path y z) (t : ↑unitInterval),
(γ.trans γ') t = if h : ↑t ≤ 1 / 2 then γ ⟨2 * ↑t, ⋯⟩ else γ' ⟨2 * ↑t - 1, ⋯⟩ |
mfderivWithin_prodMap | Mathlib.Geometry.Manifold.MFDeriv.SpecificFunctions | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {H : Type u_3} [inst_3 : TopologicalSpace H] {I : ModelWithCorners 𝕜 E H} {M : Type u_4}
[inst_4 : TopologicalSpace M] [inst_5 : ChartedSpace H M] {E' : Type u_5} [inst_6 : NormedAddCommGroup E']
[inst_7 : NormedSpace 𝕜 E'] {H' : Type u_6} [inst_8 : TopologicalSpace H'] {I' : ModelWithCorners 𝕜 E' H'}
{M' : Type u_7} [inst_9 : TopologicalSpace M'] [inst_10 : ChartedSpace H' M'] {F : Type u_11}
[inst_11 : NormedAddCommGroup F] [inst_12 : NormedSpace 𝕜 F] {G : Type u_12} [inst_13 : TopologicalSpace G]
{J : ModelWithCorners 𝕜 F G} {N : Type u_13} [inst_14 : TopologicalSpace N] [inst_15 : ChartedSpace G N]
{F' : Type u_14} [inst_16 : NormedAddCommGroup F'] [inst_17 : NormedSpace 𝕜 F'] {G' : Type u_15}
[inst_18 : TopologicalSpace G'] {J' : ModelWithCorners 𝕜 F' G'} {N' : Type u_16} [inst_19 : TopologicalSpace N']
[inst_20 : ChartedSpace G' N'] {s : Set M} {p : M × M'} {t : Set M'} {f : M → N} {g : M' → N'},
MDiffAt[s] f p.1 →
MDiffAt[t] g p.2 →
UniqueMDiffWithinAt I s p.1 →
UniqueMDiffWithinAt I' t p.2 →
mfderivWithin (I.prod I') (J.prod J') (Prod.map f g) (s ×ˢ t) p =
(mfderivWithin I J f s p.1).prodMap (mfderivWithin I' J' g t p.2) |
RelSeries.head_map | Mathlib.Order.RelSeries | ∀ {α : Type u_1} {r : SetRel α α} {β : Type u_2} {s : SetRel β β} (p : RelSeries r) (f : r.Hom s),
(p.map f).head = f p.head |
Lean.Server.Completion.HoverInfo.noConfusionType | Lean.Server.Completion.CompletionUtils | Sort u → Lean.Server.Completion.HoverInfo → Lean.Server.Completion.HoverInfo → Sort u |
IsAddUnit.addUnit_add | Mathlib.Algebra.Group.Units.Defs | ∀ {M : Type u_1} [inst : AddMonoid M] {a b : M} (ha : IsAddUnit a) (hb : IsAddUnit b),
⋯.addUnit = ha.addUnit + hb.addUnit |
MonoidHom.finsuppProd_apply | Mathlib.Algebra.BigOperators.Finsupp.Basic | ∀ {α : Type u_1} {β : Type u_7} {N : Type u_10} {P : Type u_11} [inst : Zero β] [inst_1 : MulOneClass N]
[inst_2 : CommMonoid P] (f : α →₀ β) (g : α → β → N →* P) (x : N), (f.prod g) x = f.prod fun i fi => (g i fi) x |
CategoryTheory.Limits.Types.Small.productLimitCone | Mathlib.CategoryTheory.Limits.Types.Products | {J : Type v} → (F : J → Type u) → [Small.{u, v} J] → CategoryTheory.Limits.LimitCone (CategoryTheory.Discrete.functor F) |
Std.Do.SPred.entails.refl._simp_1 | Std.Do.SPred.Laws | ∀ {σs : List (Type u)} (P : Std.Do.SPred σs), (P ⊢ₛ P) = True |
abs_pow_eq_one | Mathlib.Algebra.Order.Ring.Abs | ∀ {α : Type u_1} [inst : Ring α] [inst_1 : LinearOrder α] [IsStrictOrderedRing α] {n : ℕ} (a : α),
n ≠ 0 → (|a ^ n| = 1 ↔ |a| = 1) |
Pi.uniformSpace.eq_1 | Mathlib.Topology.UniformSpace.UniformConvergenceTopology | ∀ {ι : Type u_1} (α : ι → Type u) [U : (i : ι) → UniformSpace (α i)],
Pi.uniformSpace α =
UniformSpace.ofCoreEq (⨅ i, UniformSpace.comap (Function.eval i) (U i)).toCore Pi.topologicalSpace ⋯ |
Aesop.RappId.instLT | Aesop.Tree.Data | LT Aesop.RappId |
Std.Tactic.BVDecide.BVExpr.bitblast.blastShiftLeft.match_1 | Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.ShiftLeft | {α : Type} →
[inst : Hashable α] →
[inst_1 : DecidableEq α] →
{w : ℕ} →
(aig : Std.Sat.AIG α) →
(motive : aig.ArbitraryShiftTarget w → Sort u_1) →
(target : aig.ArbitraryShiftTarget w) →
((n : ℕ) →
(input : aig.RefVec w) →
(distance : aig.RefVec n) → motive { n := n, target := input, distance := distance }) →
motive target |
mem_absConvexHull_iff | 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} {x : E}, x ∈ (absConvexHull 𝕜) s ↔ ∀ (t : Set E), s ⊆ t → AbsConvex 𝕜 t → x ∈ t |
_private.Lean.Meta.Basic.0.Lean.Meta.getConstTemp?._sparseCasesOn_1 | Lean.Meta.Basic | {motive : Lean.ConstantInfo → Sort u} →
(t : Lean.ConstantInfo) →
((val : Lean.TheoremVal) → motive (Lean.ConstantInfo.thmInfo val)) →
((val : Lean.DefinitionVal) → motive (Lean.ConstantInfo.defnInfo val)) →
(Nat.hasNotBit 6 t.ctorIdx → motive t) → motive t |
Polynomial.eval₂_finset_sum | Mathlib.Algebra.Polynomial.Eval.Defs | ∀ {R : Type u} {S : Type v} {ι : Type y} [inst : Semiring R] [inst_1 : Semiring S] (f : R →+* S) (s : Finset ι)
(g : ι → Polynomial R) (x : S), Polynomial.eval₂ f x (∑ i ∈ s, g i) = ∑ i ∈ s, Polynomial.eval₂ f x (g i) |
Aesop.ForwardHypData | Aesop.RuleTac.Forward.Basic | Type |
CoeT.mk.noConfusion | Init.Coe | {α : Sort u} →
{x : α} → {β : Sort v} → {P : Sort u_1} → {coe coe' : β} → { coe := coe } = { coe := coe' } → (coe ≍ coe' → P) → P |
Lean.MetavarContext.MkBinding.Context.noConfusionType | Lean.MetavarContext | Sort u → Lean.MetavarContext.MkBinding.Context → Lean.MetavarContext.MkBinding.Context → Sort u |
WeierstrassCurve.Jacobian.addZ_self | Mathlib.AlgebraicGeometry.EllipticCurve.Jacobian.Formula | ∀ {R : Type r} [inst : CommRing R] (P : Fin 3 → R), WeierstrassCurve.Jacobian.addZ P P = 0 |
Nat.getD_toList_roc_eq_fallback | Init.Data.Range.Polymorphic.NatLemmas | ∀ {m n i fallback : ℕ}, n ≤ i + m → (m<...=n).toList.getD i fallback = fallback |
_private.Mathlib.Algebra.TrivSqZeroExt.Basic.0.TrivSqZeroExt.isUnit_inv_iff._simp_1_3 | Mathlib.Algebra.TrivSqZeroExt.Basic | ∀ {G₀ : Type u_2} [inst : GroupWithZero G₀] {a : G₀}, (a⁻¹ = 0) = (a = 0) |
_private.Mathlib.CategoryTheory.WithTerminal.Basic.0.CategoryTheory.WithTerminal.map.match_1.eq_3 | Mathlib.CategoryTheory.WithTerminal.Basic | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} C]
(motive : (X Y : CategoryTheory.WithTerminal C) → (X ⟶ Y) → Sort u_3)
(x : CategoryTheory.WithTerminal.star ⟶ CategoryTheory.WithTerminal.star)
(h_1 :
(a a_1 : C) →
(f : CategoryTheory.WithTerminal.of a ⟶ CategoryTheory.WithTerminal.of a_1) →
motive (CategoryTheory.WithTerminal.of a) (CategoryTheory.WithTerminal.of a_1) f)
(h_2 :
(a : C) →
(x : CategoryTheory.WithTerminal.of a ⟶ CategoryTheory.WithTerminal.star) →
motive (CategoryTheory.WithTerminal.of a) CategoryTheory.WithTerminal.star x)
(h_3 :
(x : CategoryTheory.WithTerminal.star ⟶ CategoryTheory.WithTerminal.star) →
motive CategoryTheory.WithTerminal.star CategoryTheory.WithTerminal.star x),
(match CategoryTheory.WithTerminal.star, CategoryTheory.WithTerminal.star, x with
| CategoryTheory.WithTerminal.of a, CategoryTheory.WithTerminal.of a_1, f => h_1 a a_1 f
| CategoryTheory.WithTerminal.of a, CategoryTheory.WithTerminal.star, x => h_2 a x
| CategoryTheory.WithTerminal.star, CategoryTheory.WithTerminal.star, x => h_3 x) =
h_3 x |
Lean.Parser.Term.optSemicolon.parenthesizer | Lean.Parser.Term | Lean.PrettyPrinter.Parenthesizer → Lean.PrettyPrinter.Parenthesizer |
Finset.biUnion_congr | Mathlib.Data.Finset.Union | ∀ {α : Type u_1} {β : Type u_2} {s₁ s₂ : Finset α} {t₁ t₂ : α → Finset β} [inst : DecidableEq β],
s₁ = s₂ → (∀ a ∈ s₁, t₁ a = t₂ a) → s₁.biUnion t₁ = s₂.biUnion t₂ |
_private.Mathlib.GroupTheory.Perm.Centralizer.0.Equiv.Perm.OnCycleFactors.nat_card_range_toPermHom._simp_1_7 | Mathlib.GroupTheory.Perm.Centralizer | ∀ {α : Type u_1} {β : Type v} {f : α → β} {b : β} {s : Multiset α}, (b ∈ Multiset.map f s) = ∃ a ∈ s, f a = b |
Std.TreeSet.forIn_eq_forIn | Std.Data.TreeSet.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t : Std.TreeSet α cmp} {δ : Type w} {m : Type w → Type w'} [inst : Monad m]
[LawfulMonad m] {f : α → δ → m (ForInStep δ)} {init : δ}, Std.TreeSet.forIn f init t = forIn t init f |
Matrix.submatrix_gram | Mathlib.Analysis.InnerProductSpace.GramMatrix | ∀ {E : Type u_1} {n : Type u_2} {𝕜 : Type u_4} [inst : RCLike 𝕜] [inst_1 : SeminormedAddCommGroup E]
[inst_2 : InnerProductSpace 𝕜 E] (v : n → E) {m : Set n} (f : ↑m → n),
(Matrix.gram 𝕜 v).submatrix f f = Matrix.gram 𝕜 (v ∘ f) |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.