name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M |
|---|---|---|
FreeSemigroup.noConfusion | Mathlib.Algebra.Free | {P : Sort u_1} →
{α : Type u} →
{t : FreeSemigroup α} →
{α' : Type u} → {t' : FreeSemigroup α'} → α = α' → t ≍ t' → FreeSemigroup.noConfusionType P t t' |
_private.Mathlib.RingTheory.Ideal.Over.0.Ideal.Quotient.ker_stabilizerHom._simp_1_2 | Mathlib.RingTheory.Ideal.Over | ∀ {R : Type u} [inst : Ring R] {I : Ideal R} {x y : R} [inst_1 : I.IsTwoSided],
((Ideal.Quotient.mk I) x = (Ideal.Quotient.mk I) y) = (x - y ∈ I) |
Real.mk_zero | Mathlib.Data.Real.Basic | Real.mk 0 = 0 |
List.Perm.union | Batteries.Data.List.Perm | ∀ {α : Type u_1} [inst : BEq α] [LawfulBEq α] {l₁ l₂ t₁ t₂ : List α}, l₁.Perm l₂ → t₁.Perm t₂ → (l₁ ∪ t₁).Perm (l₂ ∪ t₂) |
OrderIso.map_ciInf | Mathlib.Order.ConditionallyCompleteLattice.Indexed | ∀ {α : Type u_1} {β : Type u_2} {ι : Sort u_4} [inst : ConditionallyCompleteLattice α]
[inst_1 : ConditionallyCompleteLattice β] [Nonempty ι] (e : α ≃o β) {f : ι → α},
BddBelow (Set.range f) → e (⨅ i, f i) = ⨅ i, e (f i) |
_private.Init.Data.String.Pattern.Basic.0.String.Slice.Pattern.ToForwardSearcher.DefaultForwardSearcher.finitenessRelation._proof_1 | Init.Data.String.Pattern.Basic | ∀ {ρ : Type} (pat : ρ) (s : String.Slice),
WellFounded (InvImage WellFoundedRelation.rel fun it => it.internalState.currPos) |
Std.Sat.CNF.sat_empty._simp_1 | Std.Sat.CNF.Basic | ∀ {α : Type u_1} {assign : α → Bool}, Std.Sat.CNF.Sat assign Std.Sat.CNF.empty = True |
Lean.Core.State.messages | Lean.CoreM | Lean.Core.State → Lean.MessageLog |
List.reflBEq_iff | Init.Data.List.Lemmas | ∀ {α : Type u_1} [inst : BEq α], ReflBEq (List α) ↔ ReflBEq α |
_private.Mathlib.Combinatorics.Matroid.Loop.0.Matroid.not_isNonloop_iff_closure._simp_1_1 | Mathlib.Combinatorics.Matroid.Loop | ∀ {α : Type u_1} {M : Matroid α} {e : α}, M.IsLoop e = (M.closure {e} = M.loops ∧ e ∈ M.E) |
CategoryTheory.Limits.IsLimit.conePointsIsoOfNatIso_inv_comp_assoc | Mathlib.CategoryTheory.Limits.IsLimit | ∀ {J : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} J] {C : Type u₃} [inst_1 : CategoryTheory.Category.{v₃, u₃} C]
{F G : CategoryTheory.Functor J C} {s : CategoryTheory.Limits.Cone F} {t : CategoryTheory.Limits.Cone G}
(P : CategoryTheory.Limits.IsLimit s) (Q : CategoryTheory.Limits.IsLimit t) (w : F ≅ G) (j : J) {Z : C}
(h : F.obj j ⟶ Z),
CategoryTheory.CategoryStruct.comp (P.conePointsIsoOfNatIso Q w).inv
(CategoryTheory.CategoryStruct.comp (s.π.app j) h) =
CategoryTheory.CategoryStruct.comp (CategoryTheory.CategoryStruct.comp (t.π.app j) (w.inv.app j)) h |
Std.ExtTreeSet.mem_insertMany_list | Std.Data.ExtTreeSet.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t : Std.ExtTreeSet α cmp} [inst : Std.TransCmp cmp] [inst_1 : BEq α]
[Std.LawfulBEqCmp cmp] {l : List α} {k : α}, k ∈ t.insertMany l ↔ k ∈ t ∨ l.contains k = true |
Lean.Grind.AC.Seq.endsWithVar_k_var | Init.Grind.AC | ∀ (y x : Lean.Grind.AC.Var), (Lean.Grind.AC.Seq.var y).endsWithVar_k x = (x == y) |
Aesop.SimpTheorems.foldSimpEntries | Aesop.Util.Basic | {σ : Type u_1} → (σ → Lean.Meta.SimpEntry → σ) → σ → Lean.Meta.SimpTheorems → σ |
_private.Mathlib.Topology.Algebra.MetricSpace.Lipschitz.0.LocallyLipschitzOn.exists_lipschitzOnWith_of_compact.match_1_5 | Mathlib.Topology.Algebra.MetricSpace.Lipschitz | ∀ {α : Type u_1} {β : Type u_2} [inst : PseudoMetricSpace α] [inst_1 : PseudoMetricSpace β] {f : α → β} {s : Set α}
(ε : (x : α) → x ∈ s → ℝ) (x : α) (hx : x ∈ s)
(motive : BddAbove ((fun y => dist (f x) (f y) / dist x y) '' (s \ Metric.ball x (ε x hx))) → Prop)
(x_1 : BddAbove ((fun y => dist (f x) (f y) / dist x y) '' (s \ Metric.ball x (ε x hx)))),
(∀ (K' : ℝ) (hK' : K' ∈ upperBounds ((fun y => dist (f x) (f y) / dist x y) '' (s \ Metric.ball x (ε x hx)))),
motive ⋯) →
motive x_1 |
IntervalIntegrable.iff_comp_neg._auto_1 | Mathlib.MeasureTheory.Integral.IntervalIntegral.Basic | Lean.Syntax |
Ideal.ramificationIdx_le_finrank | Mathlib.NumberTheory.RamificationInertia.Basic | ∀ {R : Type u} [inst : CommRing R] (S : Type v) [inst_1 : CommRing S] [IsDedekindDomain S] [inst_3 : Algebra R S]
(K : Type u_1) (L : Type u_2) [inst_4 : Field K] [inst_5 : Field L] [IsDedekindDomain R] [inst_7 : Algebra R K]
[IsFractionRing R K] [inst_9 : Algebra S L] [IsFractionRing S L] [inst_11 : Algebra K L] [inst_12 : Algebra R L]
[IsScalarTower R S L] [IsScalarTower R K L] [Module.Finite R S] [NoZeroSMulDivisors R S] {p : Ideal R} [p.IsMaximal]
(P : Ideal S) [hP₁ : P.IsPrime] [hP₂ : P.LiesOver p], Ideal.ramificationIdx (algebraMap R S) p P ≤ Module.finrank K L |
LieAlgebra.Orthogonal.JD | Mathlib.Algebra.Lie.Classical | (l : Type u_4) → (R : Type u₂) → [DecidableEq l] → [CommRing R] → Matrix (l ⊕ l) (l ⊕ l) R |
εNFA.stepSet | Mathlib.Computability.EpsilonNFA | {α : Type u} → {σ : Type v} → εNFA α σ → Set σ → α → Set σ |
CategoryTheory.Functor.hasPointwiseRightKanExtensionAt_of_equivalence | Mathlib.CategoryTheory.Functor.KanExtension.Pointwise | ∀ {C : Type u_1} {D : Type u_2} {D' : Type u_3} {H : Type u_4} [inst : CategoryTheory.Category.{v_1, u_1} C]
[inst_1 : CategoryTheory.Category.{v_2, u_2} D] [inst_2 : CategoryTheory.Category.{v_3, u_3} D']
[inst_3 : CategoryTheory.Category.{v_4, u_4} H] (L : CategoryTheory.Functor C D) (L' : CategoryTheory.Functor C D')
(F : CategoryTheory.Functor C H) (E : D ≌ D') (eL : L.comp E.functor ≅ L') (Y : D) (Y' : D')
(e : E.functor.obj Y ≅ Y') [L.HasPointwiseRightKanExtensionAt F Y], L'.HasPointwiseRightKanExtensionAt F Y' |
CategoryTheory.Subobject.inf_comp_right_assoc | Mathlib.CategoryTheory.Subobject.Lattice | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.Limits.HasPullbacks C] {A : C}
(f g : CategoryTheory.Subobject A) {Z : C} (h : A ⟶ Z),
CategoryTheory.CategoryStruct.comp ((f ⊓ g).ofLE g ⋯) (CategoryTheory.CategoryStruct.comp g.arrow h) =
CategoryTheory.CategoryStruct.comp (f ⊓ g).arrow h |
Turing.TM2to1.StAct.push.sizeOf_spec | Mathlib.Computability.TuringMachine.StackTuringMachine | ∀ {K : Type u_1} {Γ : K → Type u_2} {σ : Type u_4} {k : K} [inst : SizeOf K] [inst_1 : (a : K) → SizeOf (Γ a)]
[inst_2 : SizeOf σ] (a : σ → Γ k), sizeOf (Turing.TM2to1.StAct.push a) = 1 |
Std.Do.SPred.and_or_elim_l | Std.Do.SPred.DerivedLaws | ∀ {σs : List (Type u)} {P Q R T : Std.Do.SPred σs}, (P ∧ R ⊢ₛ T) → (Q ∧ R ⊢ₛ T) → (P ∨ Q) ∧ R ⊢ₛ T |
differentiableWithinAt_sub_const_iff | 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] {f : E → F}
{x : E} {s : Set E} (c : F), DifferentiableWithinAt 𝕜 (fun y => f y - c) s x ↔ DifferentiableWithinAt 𝕜 f s x |
Continuous.measurable | Mathlib.MeasureTheory.Constructions.BorelSpace.Basic | ∀ {α : Type u_1} {γ : Type u_3} [inst : TopologicalSpace α] [inst_1 : MeasurableSpace α] [OpensMeasurableSpace α]
[inst_3 : TopologicalSpace γ] [inst_4 : MeasurableSpace γ] [BorelSpace γ] {f : α → γ}, Continuous f → Measurable f |
CategoryTheory.Discrete.functor_obj_eq_as | Mathlib.CategoryTheory.Discrete.Basic | ∀ {C : Type u₂} [inst : CategoryTheory.Category.{v₂, u₂} C] {I : Type u₁} (F : I → C) (X : CategoryTheory.Discrete I),
(CategoryTheory.Discrete.functor F).obj X = F X.as |
Lean.IR.IRType._sizeOf_3_eq | Lean.Compiler.IR.Basic | ∀ (x : List Lean.IR.IRType), Lean.IR.IRType._sizeOf_3 x = sizeOf x |
CategoryTheory.Under.isLeftAdjoint_post | Mathlib.CategoryTheory.Comma.Over.Basic | ∀ {T : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} T] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
(X : T) (F : CategoryTheory.Functor T D) [F.IsLeftAdjoint], (CategoryTheory.Under.post F).IsLeftAdjoint |
Lean.Parser.Term.show._regBuiltin.Lean.Parser.Term.show.parenthesizer_11 | Lean.Parser.Term | IO Unit |
_private.Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer.0.CategoryTheory.Limits.WalkingMulticospan.functor_ext._proof_1_1 | Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer | ∀ {J : CategoryTheory.Limits.MulticospanShape} {C : Type u_1} [inst : CategoryTheory.Category.{u_4, u_1} C]
{F G : CategoryTheory.Functor (CategoryTheory.Limits.WalkingMulticospan J) C},
(∀ (i : J.L),
F.obj (CategoryTheory.Limits.WalkingMulticospan.left i) =
G.obj (CategoryTheory.Limits.WalkingMulticospan.left i)) →
∀ (i : J.R),
F.obj (CategoryTheory.Limits.WalkingMulticospan.left (J.fst i)) =
G.obj (CategoryTheory.Limits.WalkingMulticospan.left (J.fst i)) |
groupHomology.cyclesOfIsCycle₁._proof_1 | Mathlib.RepresentationTheory.Homological.GroupHomology.LowDegree | ∀ {k G A : Type u_1} [inst : CommRing k] [inst_1 : Group G] [inst_2 : AddCommGroup A] [inst_3 : Module k A]
[inst_4 : DistribMulAction G A] [inst_5 : SMulCommClass G k A] (x : G →₀ A),
groupHomology.IsCycle₁ x → x ∈ groupHomology.cycles₁ (Rep.ofDistribMulAction k G A) |
Finset.sum_indicator_subset | Mathlib.Algebra.BigOperators.Group.Finset.Indicator | ∀ {ι : Type u_1} {β : Type u_4} [inst : AddCommMonoid β] (f : ι → β) {s t : Finset ι},
s ⊆ t → ∑ i ∈ t, (↑s).indicator f i = ∑ i ∈ s, f i |
SupHom.mk.sizeOf_spec | Mathlib.Order.Hom.Lattice | ∀ {α : Type u_6} {β : Type u_7} [inst : Max α] [inst_1 : Max β] [inst_2 : SizeOf α] [inst_3 : SizeOf β] (toFun : α → β)
(map_sup' : ∀ (a b : α), toFun (a ⊔ b) = toFun a ⊔ toFun b), sizeOf { toFun := toFun, map_sup' := map_sup' } = 1 |
KStar | Mathlib.Algebra.Order.Kleene | Type u_5 → Type u_5 |
HahnSeries.support_embDomain_subset | Mathlib.RingTheory.HahnSeries.Basic | ∀ {Γ : Type u_1} {Γ' : Type u_2} {R : Type u_3} [inst : PartialOrder Γ] [inst_1 : Zero R] [inst_2 : PartialOrder Γ']
{f : Γ ↪o Γ'} {x : HahnSeries Γ R}, (HahnSeries.embDomain f x).support ⊆ ⇑f '' x.support |
Matrix.twoBlockTriangular_det | Mathlib.LinearAlgebra.Matrix.Block | ∀ {m : Type u_3} {R : Type v} [inst : CommRing R] [inst_1 : DecidableEq m] [inst_2 : Fintype m] (M : Matrix m m R)
(p : m → Prop) [inst_3 : DecidablePred p],
(∀ (i : m), ¬p i → ∀ (j : m), p j → M i j = 0) →
M.det = (M.toSquareBlockProp p).det * (M.toSquareBlockProp fun i => ¬p i).det |
Finset.intervalGapsWithin.snd.congr_simp | Mathlib.Order.Interval.Finset.Gaps | ∀ {α : Type u_1} [inst : LinearOrder α] (F F_1 : Finset (α × α)) (e_F : F = F_1) {k : ℕ} (h : F.card = k) (b b_1 : α),
b = b_1 →
∀ (i i_1 : Fin (k + 1)),
i = i_1 → Finset.intervalGapsWithin.snd F h b i = Finset.intervalGapsWithin.snd F_1 ⋯ b_1 i_1 |
Mathlib.Tactic.Sat.buildProof.match_5 | Mathlib.Tactic.Sat.FromLRAT | (motive : Option Lean.Expr → Sort u_1) →
(x : Option Lean.Expr) → (Unit → motive none) → ((a : Lean.Expr) → motive (some a)) → motive x |
ClosedSubgroup.instSetLike | Mathlib.Topology.Algebra.Group.ClosedSubgroup | (G : Type u) → [inst : Group G] → [inst_1 : TopologicalSpace G] → SetLike (ClosedSubgroup G) G |
_private.Mathlib.Analysis.SpecialFunctions.Artanh.0.Real.strictMonoOn_artanh._proof_1_4 | Mathlib.Analysis.SpecialFunctions.Artanh | ∀ x ∈ Set.Ioo (-1) 1, 0 ≤ 1 - x |
CategoryTheory.Localization.Construction.natTransExtension | Mathlib.CategoryTheory.Localization.Construction | {C : Type uC} →
[inst : CategoryTheory.Category.{uC', uC} C] →
{W : CategoryTheory.MorphismProperty C} →
{D : Type uD} →
[inst_1 : CategoryTheory.Category.{uD', uD} D] →
{F₁ F₂ : CategoryTheory.Functor W.Localization D} → (W.Q.comp F₁ ⟶ W.Q.comp F₂) → (F₁ ⟶ F₂) |
Computability.instDecidableEqΓ'.decEq._proof_6 | Mathlib.Computability.Encoding | ¬Computability.Γ'.blank = Computability.Γ'.comma |
_private.Init.Data.String.Pattern.Basic.0.String.Slice.Pattern.ToBackwardSearcher.DefaultBackwardSearcher.finitenessRelation._proof_2 | Init.Data.String.Pattern.Basic | ∀ {ρ : Type} (pat : ρ) (s : String.Slice) [inst : String.Slice.Pattern.BackwardPattern pat]
[String.Slice.Pattern.StrictBackwardPattern pat] {it it' : Std.IterM Id (String.Slice.Pattern.SearchStep s)},
it'.IsPlausibleSuccessorOf it → InvImage WellFoundedRelation.rel (fun it => it.internalState.currPos.down) it' it |
ModuleFilterBasis.smul_right' | Mathlib.Topology.Algebra.FilterBasis | ∀ {R : Type u_1} {M : Type u_2} [inst : CommRing R] [inst_1 : TopologicalSpace R] [inst_2 : AddCommGroup M]
[inst_3 : Module R M] (self : ModuleFilterBasis R M) (m₀ : M) {U : Set M},
U ∈ self.sets → ∀ᶠ (x : R) in nhds 0, x • m₀ ∈ U |
Homeomorph.isCompact_image | Mathlib.Topology.Homeomorph.Lemmas | ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] {s : Set X} (h : X ≃ₜ Y),
IsCompact (⇑h '' s) ↔ IsCompact s |
topologicalNilradical._proof_1 | Mathlib.Topology.Algebra.TopologicallyNilpotent | ∀ (R : Type u_1) [inst : TopologicalSpace R] [inst_1 : CommRing R], IsTopologicallyNilpotent 0 |
Std.Rio.length_iter | Std.Data.Iterators.Lemmas.Producers.Range | ∀ {α : Type u_1} [inst : Std.PRange.Least? α] [inst_1 : LT α] [inst_2 : DecidableLT α]
[inst_3 : Std.PRange.UpwardEnumerable α] [inst_4 : Std.PRange.LawfulUpwardEnumerableLT α] [Std.Rxo.IsAlwaysFinite α]
[inst_6 : Std.PRange.LawfulUpwardEnumerable α] [inst_7 : Std.Rxo.HasSize α] [Std.Rxo.LawfulHasSize α] {r : Std.Rio α},
r.iter.length = r.size |
Std.Iter.filterMapWithPostcondition_eq_toIter_filterMapWithPostcondition_toIterM | Init.Data.Iterators.Lemmas.Combinators.FilterMap | ∀ {α β γ : Type w} [inst : Std.Iterator α Id β] {it : Std.Iter β} {m : Type w → Type w'} [inst_1 : Monad m]
{f : β → Std.Iterators.PostconditionT m (Option γ)},
Std.Iter.filterMapWithPostcondition f it = Std.IterM.filterMapWithPostcondition f it.toIterM |
Char.reduceToString._regBuiltin.Char.reduceToString.declare_1._@.Lean.Meta.Tactic.Simp.BuiltinSimprocs.Char.2368443037._hygCtx._hyg.18 | Lean.Meta.Tactic.Simp.BuiltinSimprocs.Char | IO Unit |
nontrivial_iff_exists_ne | Mathlib.Logic.Nontrivial.Defs | ∀ {α : Type u_1} (x : α), Nontrivial α ↔ ∃ y, y ≠ x |
instDecidableEqNum.decEq._proof_4 | Mathlib.Data.Num.Basic | ∀ (a : PosNum), ¬Num.pos a = Num.zero |
Lean.Meta.MVarRenaming | Lean.Meta.Match.MVarRenaming | Type |
_private.Lean.Elab.MutualDef.0.Lean.Elab.Term.typeHasRecFun.match_4 | Lean.Elab.MutualDef | (motive : Option Lean.Expr → Sort u_1) →
(occ? : Option Lean.Expr) →
((fvarId : Lean.FVarId) → motive (some (Lean.Expr.fvar fvarId))) → ((x : Option Lean.Expr) → motive x) → motive occ? |
CategoryTheory.Functor.PreOneHypercoverDenseData.multicospanShape_L | Mathlib.CategoryTheory.Sites.DenseSubsite.OneHypercoverDense | ∀ {C₀ : Type u₀} {C : Type u} [inst : CategoryTheory.Category.{v₀, u₀} C₀] [inst_1 : CategoryTheory.Category.{v, u} C]
{F : CategoryTheory.Functor C₀ C} {X : C} (data : F.PreOneHypercoverDenseData X), data.multicospanShape.L = data.I₀ |
List.zipWith_map_left | Init.Data.List.Zip | ∀ {α : Type u_1} {β : Type u_2} {α' : Type u_3} {γ : Type u_4} {l₁ : List α} {l₂ : List β} {f : α → α'}
{g : α' → β → γ}, List.zipWith g (List.map f l₁) l₂ = List.zipWith (fun a b => g (f a) b) l₁ l₂ |
Lean.Lsp.CompletionItemKind.value.sizeOf_spec | Lean.Data.Lsp.LanguageFeatures | sizeOf Lean.Lsp.CompletionItemKind.value = 1 |
Lean.PrefixTreeNode.brecOn_3.eq | Lean.Data.PrefixTree | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {motive_1 : Lean.PrefixTreeNode α β cmp → Sort u_1}
{motive_2 : Std.TreeMap.Raw α (Lean.PrefixTreeNode α β cmp) cmp → Sort u_1}
{motive_3 : Std.DTreeMap.Raw α (fun x => Lean.PrefixTreeNode α β cmp) cmp → Sort u_1}
{motive_4 : (Std.DTreeMap.Internal.Impl α fun x => Lean.PrefixTreeNode α β cmp) → Sort u_1}
(t : Std.DTreeMap.Internal.Impl α fun x => Lean.PrefixTreeNode α β cmp)
(F_1 : (t : Lean.PrefixTreeNode α β cmp) → t.below → motive_1 t)
(F_2 : (t : Std.TreeMap.Raw α (Lean.PrefixTreeNode α β cmp) cmp) → Lean.PrefixTreeNode.below_1 t → motive_2 t)
(F_3 :
(t : Std.DTreeMap.Raw α (fun x => Lean.PrefixTreeNode α β cmp) cmp) → Lean.PrefixTreeNode.below_2 t → motive_3 t)
(F_4 :
(t : Std.DTreeMap.Internal.Impl α fun x => Lean.PrefixTreeNode α β cmp) →
Lean.PrefixTreeNode.below_3 t → motive_4 t),
Lean.PrefixTreeNode.brecOn_3 t F_1 F_2 F_3 F_4 = F_4 t (Lean.PrefixTreeNode.brecOn_3.go t F_1 F_2 F_3 F_4).2 |
isClopen_connectedComponent | Mathlib.Topology.Connected.LocallyConnected | ∀ {α : Type u} [inst : TopologicalSpace α] [LocallyConnectedSpace α] {x : α}, IsClopen (connectedComponent x) |
SimpleGraph.lapMatrix_ker_basis | Mathlib.Combinatorics.SimpleGraph.LapMatrix | {V : Type u_1} →
[inst : Fintype V] →
(G : SimpleGraph V) →
[inst_1 : DecidableRel G.Adj] →
[inst_2 : DecidableEq V] →
[DecidableEq G.ConnectedComponent] →
Module.Basis G.ConnectedComponent ℝ ↥(Matrix.toLin' (SimpleGraph.lapMatrix ℝ G)).ker |
NONote.ofNat | Mathlib.SetTheory.Ordinal.Notation | ℕ → NONote |
ContinuousOpenMapClass.casesOn | Mathlib.Topology.Hom.Open | {F : Type u_6} →
{α : Type u_7} →
{β : Type u_8} →
[inst : TopologicalSpace α] →
[inst_1 : TopologicalSpace β] →
[inst_2 : FunLike F α β] →
{motive : ContinuousOpenMapClass F α β → Sort u} →
(t : ContinuousOpenMapClass F α β) →
([toContinuousMapClass : ContinuousMapClass F α β] → (map_open : ∀ (f : F), IsOpenMap ⇑f) → motive ⋯) →
motive t |
Matrix.IsHermitian.charpoly_cfc_eq | Mathlib.Analysis.Matrix.HermitianFunctionalCalculus | ∀ {n : Type u_1} {𝕜 : Type u_2} [inst : RCLike 𝕜] [inst_1 : Fintype n] [inst_2 : DecidableEq n] {A : Matrix n n 𝕜}
(hA : A.IsHermitian) (f : ℝ → ℝ), (cfc f A).charpoly = ∏ i, (Polynomial.X - Polynomial.C ↑(f (hA.eigenvalues i))) |
compl_bihimp_self | Mathlib.Order.SymmDiff | ∀ {α : Type u_2} [inst : HeytingAlgebra α] (a : α), bihimp aᶜ a = ⊥ |
_private.Std.Sync.Notify.0.Std.Notify.notify.match_1 | Std.Sync.Notify | (motive : Option (Std.Notify.Consumer Unit × Std.Queue (Std.Notify.Consumer Unit)) → Sort u_1) →
(x : Option (Std.Notify.Consumer Unit × Std.Queue (Std.Notify.Consumer Unit))) →
((consumer : Std.Notify.Consumer Unit) →
(rest : Std.Queue (Std.Notify.Consumer Unit)) → motive (some (consumer, rest))) →
((x : Option (Std.Notify.Consumer Unit × Std.Queue (Std.Notify.Consumer Unit))) → motive x) → motive x |
instGradedAlgebraRestrictScalars._proof_3 | Mathlib.RingTheory.GradedAlgebra.Basic | ∀ {ι : Type u_2} {R : Type u_3} {A : Type u_1} [inst : DecidableEq ι] [inst_1 : AddMonoid ι] [inst_2 : CommSemiring R]
[inst_3 : Semiring A] [inst_4 : Algebra R A] (𝒜 : ι → Submodule R A) [i : GradedAlgebra 𝒜],
Function.RightInverse (⇑(DirectSum.coeAddMonoidHom 𝒜)) DirectSum.Decomposition.decompose' |
Aesop.UnsafeRuleInfo.successProbability | Aesop.Rule | Aesop.UnsafeRuleInfo → Aesop.Percent |
Lean.Parser.ppAllowUngrouped.parenthesizer | Lean.Parser.Extra | Lean.PrettyPrinter.Parenthesizer |
Stream'.WSeq.mem_think | Mathlib.Data.WSeq.Basic | ∀ {α : Type u} (s : Stream'.WSeq α) (a : α), a ∈ s.think ↔ a ∈ s |
Bitraversable.id_tsnd | Mathlib.Control.Bitraversable.Lemmas | ∀ {t : Type u → Type u → Type u} [inst : Bitraversable t] [LawfulBitraversable t] {α β : Type u} (x : t α β),
Bitraversable.tsnd pure x = pure x |
_private.Lean.Meta.Offset.0.Lean.Meta.getOffset | Lean.Meta.Offset | Lean.Expr → Lean.MetaM (Lean.Expr × ℕ) |
Lean.Meta.Grind.PendingSolverPropagations._sizeOf_inst | Lean.Meta.Tactic.Grind.Types | SizeOf Lean.Meta.Grind.PendingSolverPropagations |
MvPFunctor.wRec_eq | Mathlib.Data.PFunctor.Multivariate.W | ∀ {n : ℕ} (P : MvPFunctor.{u} (n + 1)) {α : TypeVec.{u} n} {C : Type u_1}
(g : (a : P.A) → (P.drop.B a).Arrow α → (P.last.B a → P.W α) → (P.last.B a → C) → C) (a : P.A)
(f' : (P.drop.B a).Arrow α) (f : P.last.B a → P.W α), P.wRec g (P.wMk a f' f) = g a f' f fun i => P.wRec g (f i) |
Lean.Meta.Grind.Arith.isNatAdd? | Lean.Meta.Tactic.Grind.Arith.Util | Lean.Expr → Option (Lean.Expr × Lean.Expr) |
Lean.SMap.mk.injEq | Lean.Data.SMap | ∀ {α : Type u} {β : Type v} [inst : BEq α] [inst_1 : Hashable α] (stage₁ : Bool) (map₁ : Std.HashMap α β)
(map₂ : Lean.PHashMap α β) (stage₁_1 : Bool) (map₁_1 : Std.HashMap α β) (map₂_1 : Lean.PHashMap α β),
({ stage₁ := stage₁, map₁ := map₁, map₂ := map₂ } = { stage₁ := stage₁_1, map₁ := map₁_1, map₂ := map₂_1 }) =
(stage₁ = stage₁_1 ∧ map₁ = map₁_1 ∧ map₂ = map₂_1) |
Finset.mk_mem_sigmaLift | Mathlib.Data.Finset.Sigma | ∀ {ι : Type u_1} {α : ι → Type u_2} {β : ι → Type u_3} {γ : ι → Type u_4} [inst : DecidableEq ι]
(f : ⦃i : ι⦄ → α i → β i → Finset (γ i)) (i : ι) (a : α i) (b : β i) (x : γ i),
⟨i, x⟩ ∈ Finset.sigmaLift f ⟨i, a⟩ ⟨i, b⟩ ↔ x ∈ f a b |
DMatrix.map_zero | Mathlib.Data.Matrix.DMatrix | ∀ {m : Type u_1} {n : Type u_2} {α : m → n → Type v} [inst : (i : m) → (j : n) → Zero (α i j)] {β : m → n → Type w}
[inst_1 : (i : m) → (j : n) → Zero (β i j)] {f : ⦃i : m⦄ → ⦃j : n⦄ → α i j → β i j},
(∀ (i : m) (j : n), f 0 = 0) → DMatrix.map 0 f = 0 |
List.continuous_prod | Mathlib.Topology.List | ∀ {α : Type u_1} [inst : TopologicalSpace α] [inst_1 : MulOneClass α] [ContinuousMul α], Continuous List.prod |
WeierstrassCurve.preΨ₄._proof_1 | Mathlib.AlgebraicGeometry.EllipticCurve.DivisionPolynomial.Basic | (4 + 1).AtLeastTwo |
MDifferentiableAt.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'] {x : M} {f : M → M'} {g : N → N'} {y : N},
MDiffAt f x → MDiffAt g y → MDiffAt (Prod.map f g) (x, y) |
AddChar.starComp_apply | Mathlib.NumberTheory.LegendreSymbol.AddCharacter | ∀ {R : Type u_1} [inst : CommRing R], 0 < ringChar R → ∀ {φ : AddChar R ℂ} (a : R), (starRingEnd ℂ) (φ a) = φ⁻¹ a |
Lean.Compiler.LCNF.UnreachableBranches.Value.bot.elim | Lean.Compiler.LCNF.ElimDeadBranches | {motive_1 : Lean.Compiler.LCNF.UnreachableBranches.Value → Sort u} →
(t : Lean.Compiler.LCNF.UnreachableBranches.Value) →
t.ctorIdx = 0 → motive_1 Lean.Compiler.LCNF.UnreachableBranches.Value.bot → motive_1 t |
Set.mem_vadd_set_iff_neg_vadd_mem | Mathlib.Algebra.Group.Action.Pointwise.Set.Basic | ∀ {α : Type u_2} {β : Type u_3} [inst : AddGroup α] [inst_1 : AddAction α β] {A : Set β} {a : α} {x : β},
x ∈ a +ᵥ A ↔ -a +ᵥ x ∈ A |
Lean.SyntaxNodeKinds | Init.Prelude | Type |
WeierstrassCurve.Projective.polynomial.eq_1 | Mathlib.AlgebraicGeometry.EllipticCurve.Projective.Basic | ∀ {R : Type r} [inst : CommRing R] (W' : WeierstrassCurve.Projective R),
W'.polynomial =
MvPolynomial.X 1 ^ 2 * MvPolynomial.X 2 +
MvPolynomial.C W'.a₁ * MvPolynomial.X 0 * MvPolynomial.X 1 * MvPolynomial.X 2 +
MvPolynomial.C W'.a₃ * MvPolynomial.X 1 * MvPolynomial.X 2 ^ 2 -
(MvPolynomial.X 0 ^ 3 + MvPolynomial.C W'.a₂ * MvPolynomial.X 0 ^ 2 * MvPolynomial.X 2 +
MvPolynomial.C W'.a₄ * MvPolynomial.X 0 * MvPolynomial.X 2 ^ 2 +
MvPolynomial.C W'.a₆ * MvPolynomial.X 2 ^ 3) |
ULift.instLinearOrder._proof_3 | Mathlib.Order.Lattice | ∀ {α : Type u_2} [inst : LinearOrder α] (a b : ULift.{u_1, u_2} α), (min a b).down = min a.down b.down |
Std.DTreeMap.Internal.Impl.Equiv.constModify | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {instOrd : Ord α} {β : Type v} {t₁ t₂ : Std.DTreeMap.Internal.Impl α fun x => β} [Std.TransOrd α],
t₁.WF →
t₂.WF →
t₁.Equiv t₂ →
∀ {k : α} {f : β → β},
(Std.DTreeMap.Internal.Impl.Const.modify k f t₁).Equiv (Std.DTreeMap.Internal.Impl.Const.modify k f t₂) |
nnnorm_eq_zero' | Mathlib.Analysis.Normed.Group.Basic | ∀ {E : Type u_5} [inst : NormedGroup E] {a : E}, ‖a‖₊ = 0 ↔ a = 1 |
UInt16.toNat_xor | Init.Data.UInt.Bitwise | ∀ (a b : UInt16), (a ^^^ b).toNat = a.toNat ^^^ b.toNat |
List.countP_lt_length_iff._simp_1 | Mathlib.Data.List.Count | ∀ {α : Type u_1} {l : List α} {p : α → Bool}, (List.countP p l < l.length) = ∃ a ∈ l, p a = false |
ZeroAtInftyContinuousMap.instAddZeroClass._proof_2 | Mathlib.Topology.ContinuousMap.ZeroAtInfty | ∀ {α : Type u_1} {β : Type u_2} [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β] [inst_2 : AddZeroClass β],
⇑0 = 0 |
CompleteLatticeHomClass.toFrameHomClass | Mathlib.Order.Hom.CompleteLattice | ∀ {F : Type u_1} {α : Type u_2} {β : Type u_3} [inst : FunLike F α β] [inst_1 : CompleteLattice α]
[inst_2 : CompleteLattice β] [CompleteLatticeHomClass F α β], FrameHomClass F α β |
zpow_right_strictAnti | Mathlib.Algebra.Order.Group.Basic | ∀ {α : Type u_1} [inst : CommGroup α] [inst_1 : PartialOrder α] [IsOrderedMonoid α] {a : α},
a < 1 → StrictAnti fun n => a ^ n |
ProperlyDiscontinuousVAdd.rec | Mathlib.Topology.Algebra.ConstMulAction | {Γ : Type u_4} →
{T : Type u_5} →
[inst : TopologicalSpace T] →
[inst_1 : VAdd Γ T] →
{motive : ProperlyDiscontinuousVAdd Γ T → Sort u} →
((finite_disjoint_inter_image :
∀ {K L : Set T}, IsCompact K → IsCompact L → {γ | ((fun x => γ +ᵥ x) '' K ∩ L).Nonempty}.Finite) →
motive ⋯) →
(t : ProperlyDiscontinuousVAdd Γ T) → motive t |
instDecidableEqQuadraticAlgebra.decEq.match_1 | Mathlib.Algebra.QuadraticAlgebra.Defs | {R : Type u_1} →
{a b : R} →
(motive : QuadraticAlgebra R a b → QuadraticAlgebra R a b → Sort u_2) →
(x x_1 : QuadraticAlgebra R a b) →
((a_1 a_2 b_1 b_2 : R) → motive { re := a_1, im := a_2 } { re := b_1, im := b_2 }) → motive x x_1 |
CategoryTheory.Functor.relativelyRepresentable.w | Mathlib.CategoryTheory.MorphismProperty.Representable | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
{F : CategoryTheory.Functor C D} {X Y : D} {f : X ⟶ Y} (hf : F.relativelyRepresentable f) {a : C} (g : F.obj a ⟶ Y),
CategoryTheory.CategoryStruct.comp (hf.fst g) f = CategoryTheory.CategoryStruct.comp (F.map (hf.snd g)) g |
Set.zero_smul_set_subset | Mathlib.Algebra.GroupWithZero.Action.Pointwise.Set | ∀ {α : Type u_1} {β : Type u_2} [inst : Zero α] [inst_1 : Zero β] [inst_2 : SMulWithZero α β] (s : Set β), 0 • s ⊆ 0 |
Algebra.FormallyUnramified.of_surjective | Mathlib.RingTheory.Unramified.Basic | ∀ {R : Type u_1} [inst : CommRing R] {A : Type u_2} {B : Type u_3} [inst_1 : CommRing A] [inst_2 : Algebra R A]
[inst_3 : CommRing B] [inst_4 : Algebra R B] [Algebra.FormallyUnramified R A] (f : A →ₐ[R] B),
Function.Surjective ⇑f → Algebra.FormallyUnramified R B |
Int.bmod_eq_self_sub_bdiv_mul | Init.Data.Int.DivMod.Lemmas | ∀ (x : ℤ) (m : ℕ), x.bmod m = x - x.bdiv m * ↑m |
LieAdmissibleAlgebra.toModule | Mathlib.Algebra.NonAssoc.LieAdmissible.Defs | {R : Type u_1} →
{L : Type u_2} → {inst : CommRing R} → {inst_1 : LieAdmissibleRing L} → [self : LieAdmissibleAlgebra R L] → Module R L |
CategoryTheory.Abelian.SpectralObject.kernelSequenceE._proof_2 | Mathlib.Algebra.Homology.SpectralObject.Page | ∀ {C : Type u_2} {ι : Type u_4} [inst : CategoryTheory.Category.{u_1, u_2} C]
[inst_1 : CategoryTheory.Category.{u_3, u_4} ι] [inst_2 : CategoryTheory.Abelian C]
(X : CategoryTheory.Abelian.SpectralObject C ι) {i j k l : ι} (f₁ : i ⟶ j) (f₃ : k ⟶ l) (n₁ n₂ : ℤ),
CategoryTheory.Limits.HasBinaryBiproduct ((X.H n₁).obj (CategoryTheory.ComposableArrows.mk₁ f₃))
((X.H n₂).obj (CategoryTheory.ComposableArrows.mk₁ f₁)) |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.