name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M |
|---|---|---|
String.eq_empty_iff_forall_eq | Init.Data.String.Lemmas.IsEmpty | ∀ {s : String}, s = "" ↔ ∀ (p q : s.Pos), p = q |
Std.Internal.List.getKey?_eq_getEntry? | Std.Data.Internal.List.Associative | ∀ {α : Type u} {β : α → Type v} [inst : BEq α] {l : List ((a : α) × β a)} {a : α},
Std.Internal.List.getKey? a l = Option.map (fun x => x.fst) (Std.Internal.List.getEntry? a l) |
DilationEquiv.smulTorsor._proof_3 | Mathlib.Analysis.Normed.Affine.AddTorsor | ∀ {𝕜 : Type u_3} {E : Type u_2} [inst : NormedDivisionRing 𝕜] [inst_1 : SeminormedAddCommGroup E] [inst_2 : Module 𝕜 E]
[NormSMulClass 𝕜 E] {P : Type u_1} [inst_4 : PseudoMetricSpace P] [inst_5 : NormedAddTorsor E P] (c : P) {k : 𝕜}
(x y : E), edist (k • x +ᵥ c) (k • y +ᵥ c) = ↑‖k‖₊ * edist x y |
Sym.fill | Mathlib.Data.Sym.Basic | {α : Type u_1} → {n : ℕ} → α → (i : Fin (n + 1)) → Sym α (n - ↑i) → Sym α n |
Matrix.toLinearMap₂'Aux._proof_2 | Mathlib.LinearAlgebra.Matrix.SesquilinearForm | ∀ {R₁ : Type u_7} {S₁ : Type u_6} {R₂ : Type u_5} {S₂ : Type u_4} {N₂ : Type u_1} {n : Type u_2} {m : Type u_3}
[inst : Semiring R₁] [inst_1 : Semiring S₁] [inst_2 : Semiring R₂] [inst_3 : Semiring S₂] [inst_4 : AddCommMonoid N₂]
[inst_5 : Module S₁ N₂] [inst_6 : Module S₂ N₂] [SMulCommClass S₂ S₁ N₂] [inst_8 : Fintype n] [inst_9 : Fintype m]
(σ₁ : R₁ →+* S₁) (σ₂ : R₂ →+* S₂) (f : Matrix n m N₂) (c : R₁) (v : n → R₁) (w : m → R₂),
(fun v w => ∑ i, ∑ j, σ₂ (w j) • σ₁ (v i) • f i j) (c • v) w =
σ₁ c • (fun v w => ∑ i, ∑ j, σ₂ (w j) • σ₁ (v i) • f i j) v w |
FreeLieAlgebra.Rel.lie_self | Mathlib.Algebra.Lie.Free | ∀ {R : Type u} {X : Type v} [inst : CommRing R] (a : FreeNonUnitalNonAssocAlgebra R X), FreeLieAlgebra.Rel R X (a * a) 0 |
DirectLimit.instSemifieldOfRingHomClass._proof_3 | Mathlib.Algebra.Colimit.DirectLimit | ∀ {ι : Type u_1} [inst : Preorder ι] {G : ι → Type u_2} {T : ⦃i j : ι⦄ → i ≤ j → Type u_3}
{f : (x x_1 : ι) → (h : x ≤ x_1) → T h} [inst_1 : (i j : ι) → (h : i ≤ j) → FunLike (T h) (G i) (G j)]
[inst_2 : DirectedSystem G fun x1 x2 x3 => ⇑(f x1 x2 x3)] [inst_3 : IsDirectedOrder ι] [inst_4 : Nonempty ι]
[inst_5 : (i : ι) → Semifield (G i)] [inst_6 : ∀ (i j : ι) (h : i ≤ j), RingHomClass (T h) (G i) (G j)]
(a b : DirectLimit G f), a / b = a * b⁻¹ |
CochainComplex.mappingCone.map.congr_simp | Mathlib.Algebra.Homology.HomotopyCategory.Pretriangulated | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Preadditive C]
[inst_2 : CategoryTheory.Limits.HasBinaryBiproducts C] {K₁ L₁ K₂ L₂ : CochainComplex C ℤ} (φ₁ : K₁ ⟶ L₁)
(φ₂ : K₂ ⟶ L₂) (a a_1 : K₁ ⟶ K₂) (e_a : a = a_1) (b b_1 : L₁ ⟶ L₂) (e_b : b = b_1)
(comm : CategoryTheory.CategoryStruct.comp φ₁ b = CategoryTheory.CategoryStruct.comp a φ₂),
CochainComplex.mappingCone.map φ₁ φ₂ a b comm = CochainComplex.mappingCone.map φ₁ φ₂ a_1 b_1 ⋯ |
iteratedFDerivWithin_eq_iteratedFDeriv | Mathlib.Analysis.Calculus.ContDiff.Defs | ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {E : Type uE} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {F : Type uF} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {s : Set E}
{f : E → F} {x : E} {n : ℕ},
UniqueDiffOn 𝕜 s → ContDiffAt 𝕜 (↑n) f x → x ∈ s → iteratedFDerivWithin 𝕜 n f s x = iteratedFDeriv 𝕜 n f x |
Algebra.IsStandardSmooth.mk | Mathlib.RingTheory.Smooth.StandardSmooth | ∀ {R : Type u} {S : Type v} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S],
(∃ ι σ, ∃ (x : Finite σ), Finite ι ∧ Nonempty (Algebra.SubmersivePresentation R S ι σ)) → Algebra.IsStandardSmooth R S |
CategoryTheory.shrinkYonedaEquiv_shrinkYoneda_map | Mathlib.CategoryTheory.ShrinkYoneda | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.LocallySmall.{w, v, u} C] {X Y : C}
(f : X ⟶ Y),
CategoryTheory.shrinkYonedaEquiv (CategoryTheory.shrinkYoneda.{w, v, u}.map f) =
CategoryTheory.shrinkYonedaObjObjEquiv.symm f |
skyscraperPresheafCoconeOfSpecializes | Mathlib.Topology.Sheaves.Skyscraper | {X : TopCat} →
(p₀ : ↑X) →
[inst : (U : TopologicalSpace.Opens ↑X) → Decidable (p₀ ∈ U)] →
{C : Type v} →
[inst_1 : CategoryTheory.Category.{u, v} C] →
(A : C) →
[inst_2 : CategoryTheory.Limits.HasTerminal C] →
{y : ↑X} →
p₀ ⤳ y →
CategoryTheory.Limits.Cocone
((TopologicalSpace.OpenNhds.inclusion y).op.comp (skyscraperPresheaf p₀ A)) |
CategoryTheory.instInhabitedFreeMonoidalCategory.default | Mathlib.CategoryTheory.Monoidal.Free.Basic | {a : Type u_1} → CategoryTheory.FreeMonoidalCategory a |
TestFunction.instZero._proof_1 | Mathlib.Analysis.Distribution.TestFunction | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] {F : Type u_2} [inst_2 : NormedAddCommGroup F]
[inst_3 : NormedSpace ℝ F] {n : ℕ∞}, ContDiff ℝ ↑n fun x => 0 |
CompactlySupportedContinuousMap.toReal_apply | Mathlib.Topology.ContinuousMap.CompactlySupported | ∀ {α : Type u_2} [inst : TopologicalSpace α] (f : CompactlySupportedContinuousMap α NNReal) (x : α), f.toReal x = ↑(f x) |
Aesop.mvarIdToSubgoal | Aesop.RuleTac.Basic | Lean.MVarId → Lean.MVarId → Aesop.BaseM Aesop.Subgoal |
OpenNormalAddSubgroup.instSetLike | Mathlib.Topology.Algebra.OpenSubgroup | {G : Type u} → [inst : AddGroup G] → [inst_1 : TopologicalSpace G] → SetLike (OpenNormalAddSubgroup G) G |
Std.HashMap.Raw.Equiv.of_forall_getKey?_unit_eq | Std.Data.HashMap.RawLemmas | ∀ {α : Type u} [inst : BEq α] [inst_1 : Hashable α] [EquivBEq α] [LawfulHashable α] {m₁ m₂ : Std.HashMap.Raw α Unit},
m₁.WF → m₂.WF → (∀ (k : α), m₁.getKey? k = m₂.getKey? k) → m₁.Equiv m₂ |
ContinuousAlternatingMap.toContinuousMultilinearMap_zero | Mathlib.Topology.Algebra.Module.Alternating.Basic | ∀ {R : Type u_1} {M : Type u_2} {N : Type u_4} {ι : Type u_6} [inst : Semiring R] [inst_1 : AddCommMonoid M]
[inst_2 : Module R M] [inst_3 : TopologicalSpace M] [inst_4 : AddCommMonoid N] [inst_5 : Module R N]
[inst_6 : TopologicalSpace N], ContinuousAlternatingMap.toContinuousMultilinearMap 0 = 0 |
ArchimedeanClass.FiniteResidueField.instArchimedean | Mathlib.Algebra.Order.Ring.StandardPart | ∀ {K : Type u_1} [inst : LinearOrder K] [inst_1 : Field K] [inst_2 : IsOrderedRing K],
Archimedean (ArchimedeanClass.FiniteResidueField K) |
_private.Lean.Elab.MutualInductive.0.Lean.Elab.Command.FinalizeContext.lctx | Lean.Elab.MutualInductive | Lean.Elab.Command.FinalizeContext✝ → Lean.LocalContext |
FirstOrder.Language.Theory.Model.realize_of_mem | Mathlib.ModelTheory.Semantics | ∀ {L : FirstOrder.Language} {M : Type w} {inst : L.Structure M} {T : L.Theory} [self : M ⊨ T], ∀ φ ∈ T, M ⊨ φ |
and_imp._simp_1 | Init.SimpLemmas | ∀ {a b c : Prop}, (a ∧ b → c) = (a → b → c) |
_private.Lean.Meta.DecLevel.0.Lean.Meta.decAux?.match_8 | Lean.Meta.DecLevel | (motive : Lean.Level → Sort u_1) →
(x : Lean.Level) →
(Unit → motive Lean.Level.zero) →
((a : Lean.Name) → motive (Lean.Level.param a)) →
((mvarId : Lean.LMVarId) → motive (Lean.Level.mvar mvarId)) →
((u : Lean.Level) → motive u.succ) → ((u : Lean.Level) → motive u) → motive x |
_private.Lean.DocString.Extension.0.Lean.VersoModuleDocs.DocFrame.mk.sizeOf_spec | Lean.DocString.Extension | ∀ (content : Array (Lean.Doc.Block Lean.ElabInline Lean.ElabBlock))
(priorParts : Array (Lean.Doc.Part Lean.ElabInline Lean.ElabBlock Empty)) (titleString : String)
(title : Array (Lean.Doc.Inline Lean.ElabInline)),
sizeOf { content := content, priorParts := priorParts, titleString := titleString, title := title } =
1 + sizeOf content + sizeOf priorParts + sizeOf titleString + sizeOf title |
Std.TreeMap.Raw.modify | Std.Data.TreeMap.Raw.Basic | {α : Type u} → {β : Type v} → {cmp : α → α → Ordering} → Std.TreeMap.Raw α β cmp → α → (β → β) → Std.TreeMap.Raw α β cmp |
AlgebraicGeometry.Scheme.AffineZariskiSite.mem_grothendieckTopology | Mathlib.AlgebraicGeometry.Sites.SmallAffineZariski | ∀ {X : AlgebraicGeometry.Scheme} {U : X.AffineZariskiSite} {S : CategoryTheory.Sieve U},
S ∈ (AlgebraicGeometry.Scheme.AffineZariskiSite.grothendieckTopology X) U ↔
∀ x ∈ U.toOpens, ∃ V f, S.arrows f ∧ x ∈ V.toOpens |
List.isPrefixOfAux_toArray_succ' | Init.Data.List.ToArray | ∀ {α : Type u_1} [inst : BEq α] (l₁ l₂ : List α) (hle : l₁.length ≤ l₂.length) (i : ℕ),
l₁.toArray.isPrefixOfAux l₂.toArray hle (i + 1) =
(List.drop (i + 1) l₁).toArray.isPrefixOfAux (List.drop (i + 1) l₂).toArray ⋯ 0 |
AdjoinRoot.coe_ofAlgHom | Mathlib.RingTheory.AdjoinRoot | ∀ {R : Type u_1} {S : Type u_2} [inst : CommRing R] [inst_1 : CommSemiring S] [inst_2 : Algebra S R] (p : Polynomial R),
⇑(AdjoinRoot.ofAlgHom S p) = ⇑(AdjoinRoot.of p) |
ProofWidgets.HtmlDisplayProps.mk.sizeOf_spec | ProofWidgets.Component.HtmlDisplay | ∀ (html : ProofWidgets.Html), sizeOf { html := html } = 1 + sizeOf html |
MeasureTheory.Filtration.IsRightContinuous.RC | Mathlib.Probability.Process.Filtration | ∀ {Ω : Type u_1} {ι : Type u_2} {m : MeasurableSpace Ω} {inst : PartialOrder ι} {𝓕 : MeasureTheory.Filtration ι m}
[self : 𝓕.IsRightContinuous], 𝓕.rightCont ≤ 𝓕 |
AddMagma.FreeAddSemigroup.map.eq_1 | Mathlib.Algebra.Free | ∀ {α : Type u} [inst : Add α] {β : Type v} [inst_1 : Add β] (f : α →ₙ+ β),
AddMagma.FreeAddSemigroup.map f = AddMagma.FreeAddSemigroup.lift (AddMagma.FreeAddSemigroup.of.comp f) |
LinearEquiv.domMulActCongrRight._proof_5 | Mathlib.Algebra.Module.Equiv.Basic | ∀ {R₁ : Type u_4} {R₁' : Type u_5} {R₂' : Type u_6} {M₁ : Type u_2} {M₁' : Type u_1} {M₂' : Type u_3}
[inst : Semiring R₁] [inst_1 : Semiring R₁'] [inst_2 : Semiring R₂'] [inst_3 : AddCommMonoid M₁]
[inst_4 : AddCommMonoid M₁'] [inst_5 : AddCommMonoid M₂'] [inst_6 : Module R₁ M₁] [inst_7 : Module R₁' M₁']
[inst_8 : Module R₂' M₂'] {σ₁'₂' : R₁' →+* R₂'} {σ₂'₁' : R₂' →+* R₁'} {σ₁₁' : R₁ →+* R₁'} {σ₁₂' : R₁ →+* R₂'}
[inst_9 : RingHomInvPair σ₁'₂' σ₂'₁'] [inst_10 : RingHomInvPair σ₂'₁' σ₁'₂']
[inst_11 : RingHomCompTriple σ₁₁' σ₁'₂' σ₁₂'] [inst_12 : RingHomCompTriple σ₁₂' σ₂'₁' σ₁₁'] (e₂ : M₁' ≃ₛₗ[σ₁'₂'] M₂'),
Function.LeftInverse ((LinearEquiv.refl R₁ M₁).arrowCongrAddEquiv e₂).invFun
((LinearEquiv.refl R₁ M₁).arrowCongrAddEquiv e₂).toFun |
AntitoneOn.map_bddBelow | Mathlib.Order.Bounds.Image | ∀ {α : Type u} {β : Type v} [inst : Preorder α] [inst_1 : Preorder β] {f : α → β} {s t : Set α},
AntitoneOn f t → s ⊆ t → (lowerBounds s ∩ t).Nonempty → BddAbove (f '' s) |
Lean.Grind.Linarith.Poly.NonnegCoeffs.add | Init.Grind.Module.NatModuleNorm | ∀ (a : ℤ) (x : Lean.Grind.Linarith.Var) (p : Lean.Grind.Linarith.Poly),
a ≥ 0 → p.NonnegCoeffs → (Lean.Grind.Linarith.Poly.add a x p).NonnegCoeffs |
Function.Surjective.mulActionWithZero | Mathlib.Algebra.GroupWithZero.Action.Defs | {M₀ : Type u_2} →
{A : Type u_7} →
{A' : Type u_8} →
[inst : MonoidWithZero M₀] →
[inst_1 : Zero A] →
[inst_2 : MulActionWithZero M₀ A] →
[inst_3 : Zero A'] →
[inst_4 : SMul M₀ A'] →
(f : ZeroHom A A') →
Function.Surjective ⇑f → (∀ (a : M₀) (b : A), f (a • b) = a • f b) → MulActionWithZero M₀ A' |
Finsupp.split_apply | Mathlib.Data.Finsupp.Basic | ∀ {ι : Type u_4} {M : Type u_5} {αs : ι → Type u_12} [inst : Zero M] (l : (i : ι) × αs i →₀ M) (i : ι) (x : αs i),
(l.split i) x = l ⟨i, x⟩ |
Ideal.associatesEquivIsPrincipal._proof_3 | Mathlib.RingTheory.Ideal.IsPrincipal | ∀ (R : Type u_1) [inst : CommRing R] (I : { I // Submodule.IsPrincipal I }), Submodule.IsPrincipal ↑I |
LipschitzWith.mapsTo_closedBall | Mathlib.Topology.MetricSpace.Lipschitz | ∀ {α : Type u} {β : Type v} [inst : PseudoMetricSpace α] [inst_1 : PseudoMetricSpace β] {K : NNReal} {f : α → β},
LipschitzWith K f → ∀ (x : α) (r : ℝ), Set.MapsTo f (Metric.closedBall x r) (Metric.closedBall (f x) (↑K * r)) |
Nat.Coprime.sum_divisors_mul | Mathlib.NumberTheory.ArithmeticFunction.Misc | ∀ {m n : ℕ}, m.Coprime n → ∑ d ∈ (m * n).divisors, d = (∑ d ∈ m.divisors, d) * ∑ d ∈ n.divisors, d |
Real.isTheta_exp_comp_exp_comp | Mathlib.Analysis.SpecialFunctions.Exp | ∀ {α : Type u_1} {l : Filter α} {f g : α → ℝ},
((fun x => Real.exp (f x)) =Θ[l] fun x => Real.exp (g x)) ↔
Filter.IsBoundedUnder (fun x1 x2 => x1 ≤ x2) l fun x => |f x - g x| |
Std.ExtDTreeMap.union_insert_right_eq_insert_union | Std.Data.ExtDTreeMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t₁ t₂ : Std.ExtDTreeMap α β cmp} [inst : Std.TransCmp cmp]
{p : (a : α) × β a}, t₁ ∪ t₂.insert p.fst p.snd = (t₁ ∪ t₂).insert p.fst p.snd |
_private.Std.Tactic.BVDecide.LRAT.Internal.CompactLRATChecker.0.Std.Tactic.BVDecide.LRAT.Internal.compactLratChecker.go.match_3.eq_1 | Std.Tactic.BVDecide.LRAT.Internal.CompactLRATChecker | ∀ {n : ℕ} (motive : Option (Std.Tactic.BVDecide.LRAT.Internal.DefaultClauseAction n) → Sort u_1)
(h_1 : Unit → motive none)
(h_2 : (id : ℕ) → (rupHints : Array ℕ) → motive (some (Std.Tactic.BVDecide.LRAT.Action.addEmpty id rupHints)))
(h_3 :
(id : ℕ) →
(c : Std.Tactic.BVDecide.LRAT.Internal.DefaultClause n) →
(rupHints : Array ℕ) → motive (some (Std.Tactic.BVDecide.LRAT.Action.addRup id c rupHints)))
(h_4 :
(id : ℕ) →
(c : Std.Tactic.BVDecide.LRAT.Internal.DefaultClause n) →
(pivot : Std.Sat.Literal (Std.Tactic.BVDecide.LRAT.Internal.PosFin n)) →
(rupHints : Array ℕ) →
(ratHints : Array (ℕ × Array ℕ)) →
motive (some (Std.Tactic.BVDecide.LRAT.Action.addRat id c pivot rupHints ratHints)))
(h_5 : (ids : Array ℕ) → motive (some (Std.Tactic.BVDecide.LRAT.Action.del ids))),
(match none with
| none => h_1 ()
| some (Std.Tactic.BVDecide.LRAT.Action.addEmpty id rupHints) => h_2 id rupHints
| some (Std.Tactic.BVDecide.LRAT.Action.addRup id c rupHints) => h_3 id c rupHints
| some (Std.Tactic.BVDecide.LRAT.Action.addRat id c pivot rupHints ratHints) => h_4 id c pivot rupHints ratHints
| some (Std.Tactic.BVDecide.LRAT.Action.del ids) => h_5 ids) =
h_1 () |
Vector.insertIdx_eraseIdx._proof_3 | Init.Data.Vector.InsertIdx | ∀ {n i : ℕ}, i < n → i + 1 < n + 1 |
_private.Batteries.Data.List.Lemmas.0.List.getElem_idxOf_eq_idxOfNth_add._proof_1_5 | Batteries.Data.List.Lemmas | ∀ {α : Type u_1} {x : α} [inst : BEq α] {n s : ℕ} {h : n < (List.idxsOf x [] s).length},
(List.idxsOf x [] s)[n] - s + 1 ≤ [].length → (List.idxsOf x [] s)[n] - s < [].length |
_private.Mathlib.AlgebraicGeometry.StructureSheaf.0.AlgebraicGeometry.StructureSheaf.toStalkₗ'.eq_1 | Mathlib.AlgebraicGeometry.StructureSheaf | ∀ (R M : Type u) [inst : CommRing R] [inst_1 : AddCommGroup M] [inst_2 : Module R M]
(x : ↑(AlgebraicGeometry.PrimeSpectrum.Top R)),
AlgebraicGeometry.StructureSheaf.toStalkₗ'✝ R M x =
CategoryTheory.CategoryStruct.comp (ModuleCat.ofHom (AlgebraicGeometry.StructureSheaf.toOpenₗ R M ⊤))
((AlgebraicGeometry.structurePresheafInModuleCat R M).germ ⊤ x trivial) |
List.length_erase | Init.Data.List.Erase | ∀ {α : Type u_1} [inst : BEq α] [inst_1 : LawfulBEq α] {a : α} {l : List α},
(l.erase a).length = if a ∈ l then l.length - 1 else l.length |
Nat.Partition.recOn | Mathlib.Combinatorics.Enumerative.Partition.Basic | {n : ℕ} →
{motive : n.Partition → Sort u} →
(t : n.Partition) →
((parts : Multiset ℕ) →
(parts_pos : ∀ {i : ℕ}, i ∈ parts → 0 < i) →
(parts_sum : parts.sum = n) → motive { parts := parts, parts_pos := parts_pos, parts_sum := parts_sum }) →
motive t |
Mathlib.Meta.FunProp.instInhabitedFunPropDecl | Mathlib.Tactic.FunProp.Decl | Inhabited Mathlib.Meta.FunProp.FunPropDecl |
_private.Mathlib.Tactic.ComputeAsymptotics.Multiseries.Basis.0.Tactic.ComputeAsymptotics.WellFormedBasis.eventually_pos._simp_1_2 | Mathlib.Tactic.ComputeAsymptotics.Multiseries.Basis | ∀ {α : Type u} {R : α → α → Prop} {a : α} {l : List α},
List.Pairwise R (a :: l) = ((∀ a' ∈ l, R a a') ∧ List.Pairwise R l) |
_private.Mathlib.Data.List.Triplewise.0.List.triplewise_iff_getElem._proof_1_63 | Mathlib.Data.List.Triplewise | ∀ {α : Type u_1} (tail : List α) (i j k : ℕ),
i < j → -1 * ↑j + 1 ≤ 0 → -1 * ↑i + 1 ≤ 0 → j - 1 + 1 ≤ k - 1 → k - 1 + 1 ≤ tail.length → i - 1 < tail.length |
AddAction.orbitRel | Mathlib.GroupTheory.GroupAction.Defs | (G : Type u_1) → (α : Type u_2) → [inst : AddGroup G] → [AddAction G α] → Setoid α |
Lean.Name.getRoot._sunfold | Init.Meta.Defs | Lean.Name → Lean.Name |
TypeVec.typevecCasesNil₂._proof_2 | Mathlib.Data.TypeVec | ∀ {β : TypeVec.Arrow Fin2.elim0 Fin2.elim0 → Sort u_1} (g : TypeVec.Arrow Fin2.elim0 Fin2.elim0),
g = TypeVec.nilFun → β g = β TypeVec.nilFun |
Std.TreeMap.mem_union_of_left | Std.Data.TreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t₁ t₂ : Std.TreeMap α β cmp} [Std.TransCmp cmp] {k : α},
k ∈ t₁ → k ∈ t₁ ∪ t₂ |
SimpleGraph.Coloring.sumEquiv._proof_1 | Mathlib.Combinatorics.SimpleGraph.Sum | ∀ {V : Type u_1} {W : Type u_2} {γ : Type u_3} {G : SimpleGraph V} {H : SimpleGraph W} (c : (G ⊕g H).Coloring γ),
(fun p => p.1.sum p.2) ((fun c => (c.sumLeft, c.sumRight)) c) = c |
FixedDetMatrices.instSMulSpecialLinearGroupFixedDetMatrix | Mathlib.LinearAlgebra.Matrix.FixedDetMatrices | (n : Type u_1) →
[inst : DecidableEq n] →
[inst_1 : Fintype n] →
(R : Type u_2) → [inst_2 : CommRing R] → (m : R) → SMul (Matrix.SpecialLinearGroup n R) (FixedDetMatrix n R m) |
Lean.Meta.RecursorInfo | Lean.Meta.RecursorInfo | Type |
RootedTree.mk.noConfusion | Mathlib.Order.SuccPred.Tree | {P : Sort u} →
{α : Type u_2} →
{semilatticeInf : SemilatticeInf α} →
{orderBot : OrderBot α} →
{predOrder : PredOrder α} →
{isPredArchimedean : IsPredArchimedean α} →
{α' : Type u_2} →
{semilatticeInf' : SemilatticeInf α'} →
{orderBot' : OrderBot α'} →
{predOrder' : PredOrder α'} →
{isPredArchimedean' : IsPredArchimedean α'} →
{ α := α, semilatticeInf := semilatticeInf, orderBot := orderBot, predOrder := predOrder,
isPredArchimedean := isPredArchimedean } =
{ α := α', semilatticeInf := semilatticeInf', orderBot := orderBot', predOrder := predOrder',
isPredArchimedean := isPredArchimedean' } →
(α = α' →
semilatticeInf ≍ semilatticeInf' → orderBot ≍ orderBot' → predOrder ≍ predOrder' → P) →
P |
Std.Roi.size.eq_1 | Init.Data.Range.Polymorphic.Lemmas | ∀ {α : Type u} [inst : Std.Rxi.HasSize α] [inst_1 : Std.PRange.UpwardEnumerable α] (r : Std.Roi α),
r.size =
match Std.PRange.succ? r.lower with
| none => 0
| some lower => Std.Rxi.HasSize.size lower |
_private.Mathlib.Computability.RegularExpressions.0.RegularExpression.matches'.match_1.eq_4 | Mathlib.Computability.RegularExpressions | ∀ {α : Type u_1} (motive : RegularExpression α → Sort u_2) (P Q : RegularExpression α)
(h_1 : Unit → motive RegularExpression.zero) (h_2 : Unit → motive RegularExpression.epsilon)
(h_3 : (a : α) → motive (RegularExpression.char a)) (h_4 : (P Q : RegularExpression α) → motive (P.plus Q))
(h_5 : (P Q : RegularExpression α) → motive (P.comp Q)) (h_6 : (P : RegularExpression α) → motive P.star),
(match P.plus Q with
| RegularExpression.zero => h_1 ()
| RegularExpression.epsilon => h_2 ()
| RegularExpression.char a => h_3 a
| P.plus Q => h_4 P Q
| P.comp Q => h_5 P Q
| P.star => h_6 P) =
h_4 P Q |
Nat.forall_lt_succ_left'._proof_2 | Init.Data.Nat.Lemmas | ∀ {n : ℕ}, 0 < n + 1 |
AddRightCancelMonoid.add_eq_zero | Mathlib.Algebra.Group.Units.Basic | ∀ {α : Type u} [inst : AddRightCancelMonoid α] [Subsingleton (AddUnits α)] {a b : α}, a + b = 0 ↔ a = 0 ∧ b = 0 |
CategoryTheory.SingleFunctors.hom_ext_iff | Mathlib.CategoryTheory.Shift.SingleFunctors | ∀ {C : Type u_1} {D : Type u_2} [inst : CategoryTheory.Category.{v_1, u_1} C]
[inst_1 : CategoryTheory.Category.{v_2, u_2} D] {A : Type u_5} [inst_2 : AddMonoid A]
[inst_3 : CategoryTheory.HasShift D A] {F G : CategoryTheory.SingleFunctors C D A} {f g : F ⟶ G},
f = g ↔ f.hom = g.hom |
CategoryTheory.Adjunction.ofNatIsoLeft | Mathlib.CategoryTheory.Adjunction.Basic | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{D : Type u₂} →
[inst_1 : CategoryTheory.Category.{v₂, u₂} D] →
{F G : CategoryTheory.Functor C D} → {H : CategoryTheory.Functor D C} → (F ⊣ H) → (F ≅ G) → (G ⊣ H) |
Lean.Elab.CommandContextInfo.ctorIdx | Lean.Elab.InfoTree.Types | Lean.Elab.CommandContextInfo → ℕ |
Topology.«_aux_Mathlib_Topology_Defs_Filter___macroRules_Topology_term𝓝ˢ_1» | Mathlib.Topology.Defs.Filter | Lean.Macro |
SeparationQuotient.instNonUnitalRing._proof_6 | Mathlib.Topology.Algebra.SeparationQuotient.Basic | ∀ {R : Type u_1} [inst : TopologicalSpace R] [inst_1 : NonUnitalRing R] [IsTopologicalRing R], ContinuousConstSMul ℤ R |
TopologicalSpace.secondCountableTopology_iInf | Mathlib.Topology.Bases | ∀ {α : Type u_1} {ι : Sort u_2} [Countable ι] {t : ι → TopologicalSpace α},
(∀ (i : ι), SecondCountableTopology α) → SecondCountableTopology α |
ENNReal.toReal_lt_toReal | Mathlib.Data.ENNReal.Real | ∀ {a b : ENNReal}, a ≠ ⊤ → b ≠ ⊤ → (a.toReal < b.toReal ↔ a < b) |
Finsupp.lcoeFun._proof_2 | Mathlib.LinearAlgebra.Finsupp.Pi | ∀ {α : Type u_1} {M : Type u_2} {R : Type u_3} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
(x : R) (y : α →₀ M), ⇑(x • y) = (RingHom.id R) x • ⇑y |
Set.nontrivial_of_einfsep_ne_top | Mathlib.Topology.MetricSpace.Infsep | ∀ {α : Type u_1} [inst : EDist α] {s : Set α}, s.einfsep ≠ ⊤ → s.Nontrivial |
Lean.SMap.rec | Lean.Data.SMap | {α : Type u} →
{β : Type v} →
[inst : BEq α] →
[inst_1 : Hashable α] →
{motive : Lean.SMap α β → Sort u_1} →
((stage₁ : Bool) →
(map₁ : Std.HashMap α β) →
(map₂ : Lean.PHashMap α β) → motive { stage₁ := stage₁, map₁ := map₁, map₂ := map₂ }) →
(t : Lean.SMap α β) → motive t |
EuclideanGeometry.instNonemptySphere | Mathlib.Geometry.Euclidean.Sphere.Basic | ∀ {P : Type u_2} [inst : MetricSpace P] [Nonempty P], Nonempty (EuclideanGeometry.Sphere P) |
Lean.Meta.eqnThmSuffixBase | Lean.Meta.Eqns | String |
Matrix.vec_mul_eq_vecMul | Mathlib.LinearAlgebra.Matrix.Vec | ∀ {m : Type u_1} {n : Type u_2} {p : Type u_4} {R : Type u_3} [inst : Semiring R] [inst_1 : Fintype m]
[inst_2 : Fintype n] [inst_3 : DecidableEq m] (A : Matrix m n R) (B : Matrix n p R),
(A * B).vec = Matrix.vecMul A.vec (Matrix.kroneckerMap (fun x1 x2 => x1 * x2) B 1) |
LeanSearchClient.SearchResult.mk._flat_ctor | LeanSearchClient.Syntax | String → Option String → Option String → Option String → Option String → LeanSearchClient.SearchResult |
LocallyConstant.ext | Mathlib.Topology.LocallyConstant.Basic | ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] ⦃f g : LocallyConstant X Y⦄, (∀ (x : X), f x = g x) → f = g |
_private.Mathlib.Algebra.MonoidAlgebra.NoZeroDivisors.0.MonoidAlgebra.instIsLeftCancelMulZeroOfIsCancelAddOfUniqueProds._simp_2 | Mathlib.Algebra.MonoidAlgebra.NoZeroDivisors | ∀ {α : Type u_1} {M : Type u_4} [inst : Zero M] {f : α →₀ M}, (f.support = ∅) = (f = 0) |
_private.Lean.Elab.Tactic.Rewrite.0.Lean.Elab.Tactic.withRWRulesSeq.match_3 | Lean.Elab.Tactic.Rewrite | (motive : Option (Array Lean.Name) → Sort u_1) →
(__discr : Option (Array Lean.Name)) →
((eqThms : Array Lean.Name) → motive (some eqThms)) → ((x : Option (Array Lean.Name)) → motive x) → motive __discr |
CategoryTheory.GradedObject.mapTrifunctorMapFunctorObj._proof_1 | Mathlib.CategoryTheory.GradedObject.Trifunctor | ∀ {C₁ : Type u_5} {C₂ : Type u_7} {C₃ : Type u_9} {C₄ : Type u_3} [inst : CategoryTheory.Category.{u_4, u_5} C₁]
[inst_1 : CategoryTheory.Category.{u_6, u_7} C₂] [inst_2 : CategoryTheory.Category.{u_8, u_9} C₃]
[inst_3 : CategoryTheory.Category.{u_2, u_3} C₄]
(F : CategoryTheory.Functor C₁ (CategoryTheory.Functor C₂ (CategoryTheory.Functor C₃ C₄))) {I₁ : Type u_10}
{I₂ : Type u_11} {I₃ : Type u_12} {J : Type u_1} (p : I₁ × I₂ × I₃ → J) (X₁ : CategoryTheory.GradedObject I₁ C₁)
[inst_4 :
∀ (X₂ : CategoryTheory.GradedObject I₂ C₂) (X₃ : CategoryTheory.GradedObject I₃ C₃),
((((CategoryTheory.GradedObject.mapTrifunctor F I₁ I₂ I₃).obj X₁).obj X₂).obj X₃).HasMap p]
(X₂ : CategoryTheory.GradedObject I₂ C₂) (X₃ : CategoryTheory.GradedObject I₃ C₃),
CategoryTheory.GradedObject.mapTrifunctorMapMap F p (CategoryTheory.CategoryStruct.id X₁)
(CategoryTheory.CategoryStruct.id X₂) (CategoryTheory.CategoryStruct.id X₃) =
CategoryTheory.CategoryStruct.id (CategoryTheory.GradedObject.mapTrifunctorMapObj F p X₁ X₂ X₃) |
Std.Internal.List.minKey!_modifyKey | Std.Data.Internal.List.Associative | ∀ {α : Type u} {β : α → Type v} [inst : Ord α] [Std.TransOrd α] [inst_2 : BEq α] [inst_3 : Std.LawfulBEqOrd α]
[inst_4 : Std.LawfulEqOrd α] [inst_5 : Inhabited α] {l : List ((a : α) × β a)},
Std.Internal.List.DistinctKeys l →
∀ {k : α} {f : β k → β k},
Std.Internal.List.minKey! (Std.Internal.List.modifyKey k f l) = Std.Internal.List.minKey! l |
Mathlib.Tactic.ITauto.instLTIProp | Mathlib.Tactic.ITauto | LT Mathlib.Tactic.ITauto.IProp |
Lean.Meta.RefinedDiscrTree.PreDiscrTree.ctorIdx | Mathlib.Lean.Meta.RefinedDiscrTree.Initialize | {α : Type} → Lean.Meta.RefinedDiscrTree.PreDiscrTree α → ℕ |
measurable_measure_prodMk_left | Mathlib.MeasureTheory.Measure.Prod | ∀ {α : Type u_1} {β : Type u_2} [inst : MeasurableSpace α] [inst_1 : MeasurableSpace β] {ν : MeasureTheory.Measure β}
[MeasureTheory.SFinite ν] {s : Set (α × β)}, MeasurableSet s → Measurable fun x => ν (Prod.mk x ⁻¹' s) |
Std.DHashMap.getKeyD_diff_of_not_mem_left | Std.Data.DHashMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {x : BEq α} {x_1 : Hashable α} {m₁ m₂ : Std.DHashMap α β} [EquivBEq α]
[LawfulHashable α] {k fallback : α}, k ∉ m₁ → (m₁ \ m₂).getKeyD k fallback = fallback |
IsPrimitiveRoot.adjoinEquivRingOfIntegersOfPrimePow | Mathlib.NumberTheory.NumberField.Cyclotomic.Basic | {p k : ℕ} →
{K : Type u} →
[inst : Field K] →
{ζ : K} →
[hp : Fact (Nat.Prime p)] →
[inst_1 : CharZero K] →
[IsCyclotomicExtension {p ^ k} ℚ K] →
IsPrimitiveRoot ζ (p ^ k) → ↥(Algebra.adjoin ℤ {ζ}) ≃ₐ[ℤ] NumberField.RingOfIntegers K |
Pi.measurableNeg | Mathlib.MeasureTheory.Group.Arithmetic | ∀ {ι : Type u_4} {α : ι → Type u_5} [inst : (i : ι) → Neg (α i)] [inst_1 : (i : ι) → MeasurableSpace (α i)]
[∀ (i : ι), MeasurableNeg (α i)], MeasurableNeg ((i : ι) → α i) |
Batteries.OrientedOrd.instLexOrd | Batteries.Classes.Deprecated | ∀ {α : Type u_1} {β : Type u_2} [inst : Ord α] [inst_1 : Ord β] [Batteries.OrientedOrd α] [Batteries.OrientedOrd β],
Batteries.OrientedOrd (α × β) |
CategoryTheory.Limits.preservesSmallestCofilteredLimits_of_preservesCofilteredLimits | Mathlib.CategoryTheory.Limits.Preserves.Filtered | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
(F : CategoryTheory.Functor C D) [CategoryTheory.Limits.PreservesCofilteredLimitsOfSize.{w', w, v₁, v₂, u₁, u₂} F],
CategoryTheory.Limits.PreservesCofilteredLimitsOfSize.{0, 0, v₁, v₂, u₁, u₂} F |
LSeries.notation._aux_Mathlib_NumberTheory_LSeries_Basic___unexpand_LSeries_delta_1 | Mathlib.NumberTheory.LSeries.Basic | Lean.PrettyPrinter.Unexpander |
ValuationSubring.linearOrderOverring._proof_3 | Mathlib.RingTheory.Valuation.ValuationSubring | ∀ {K : Type u_1} [inst : Field K] (A : ValuationSubring K) (a b : { S // A ≤ S }), a ≤ b ∨ b ≤ a |
continuousAt_prod_of_discrete_right | Mathlib.Topology.ContinuousOn | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β]
[inst_2 : TopologicalSpace γ] [DiscreteTopology β] {f : α × β → γ} {x : α × β},
ContinuousAt f x ↔ ContinuousAt (fun x_1 => f (x_1, x.2)) x.1 |
CategoryTheory.IsCofiltered.minToRight._proof_1 | Mathlib.CategoryTheory.Filtered.Basic | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.IsCofilteredOrEmpty C]
(j j' : C), ∃ x, True |
ValuationSubring.instSemilatticeSup | Mathlib.RingTheory.Valuation.ValuationSubring | {K : Type u} → [inst : Field K] → SemilatticeSup (ValuationSubring K) |
_private.Mathlib.Data.Set.Prod.0.Set.EqOn.right_of_eqOn_prodMap._proof_1_1 | Mathlib.Data.Set.Prod | ∀ {α : Type u_3} {β : Type u_4} {γ : Type u_2} {δ : Type u_1} {f f' : α → γ} {g g' : β → δ} (x : α) ⦃x_1 : β⦄,
Prod.map f g (x, x_1) = Prod.map f' g' (x, x_1) → g x_1 = g' x_1 |
instReprOrdering | Init.Data.Ord.Basic | Repr Ordering |
Valuation.IsRankOneDiscrete.valueGroup₀_equiv_withZeroMulInt._proof_3 | Mathlib.RingTheory.Valuation.Discrete.RankOne | ∀ {Γ : Type u_1} [inst : LinearOrderedCommGroupWithZero Γ] {R : Type u_2} [inst_1 : CommRing R] (v : Valuation R Γ)
[hv : v.IsRankOneDiscrete], Subgroup.zpowers (Valuation.IsRankOneDiscrete.generator' v)⁻¹ = ⊤ |
Multiset.mapEquiv_aux._proof_3 | Mathlib.Data.Multiset.Fintype | ∀ {α : Type u_1} [inst : DecidableEq α], IsEmpty (Multiset.ToType ⟦[]⟧) |
Zsqrtd.isCoprime_of_dvd_isCoprime | Mathlib.NumberTheory.Zsqrtd.Basic | ∀ {d : ℤ} {a b : ℤ√d}, IsCoprime a.re a.im → b ∣ a → IsCoprime b.re b.im |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.