name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M |
|---|---|---|
Subsemiring.mk.inj | Mathlib.Algebra.Ring.Subsemiring.Defs | ∀ {R : Type u} {inst : NonAssocSemiring R} {toSubmonoid : Submonoid R}
{add_mem' : ∀ {a b : R}, a ∈ toSubmonoid.carrier → b ∈ toSubmonoid.carrier → a + b ∈ toSubmonoid.carrier}
{zero_mem' : 0 ∈ toSubmonoid.carrier} {toSubmonoid_1 : Submonoid R}
{add_mem'_1 : ∀ {a b : R}, a ∈ toSubmonoid_1.carrier → b ∈ toSubmonoid_1.carrier → a + b ∈ toSubmonoid_1.carrier}
{zero_mem'_1 : 0 ∈ toSubmonoid_1.carrier},
{ toSubmonoid := toSubmonoid, add_mem' := add_mem', zero_mem' := zero_mem' } =
{ toSubmonoid := toSubmonoid_1, add_mem' := add_mem'_1, zero_mem' := zero_mem'_1 } →
toSubmonoid = toSubmonoid_1 |
Lean.Parser.Command.GrindCnstr.notDefEq.parenthesizer | Lean.Meta.Tactic.Grind.Parser | Lean.PrettyPrinter.Parenthesizer |
AddCommMonCat.equivalence_unitIso | Mathlib.Algebra.Category.MonCat.Basic | AddCommMonCat.equivalence.unitIso = CategoryTheory.Iso.refl (CategoryTheory.Functor.id AddCommMonCat) |
Semiquot.ext | Mathlib.Data.Semiquot | ∀ {α : Type u_1} {q₁ q₂ : Semiquot α}, q₁ = q₂ ↔ ∀ (a : α), a ∈ q₁ ↔ a ∈ q₂ |
AddMonoidHom.fiberEquivKerOfSurjective | Mathlib.GroupTheory.Coset.Basic | {α : Type u_1} →
[inst : AddGroup α] →
{H : Type u_2} → [inst_1 : AddGroup H] → {f : α →+ H} → Function.Surjective ⇑f → (h : H) → ↑(⇑f ⁻¹' {h}) ≃ ↥f.ker |
List.cyclicPermutations_eq_singleton_iff._simp_1 | Mathlib.Data.List.Rotate | ∀ {α : Type u} {l : List α} {x : α}, (l.cyclicPermutations = [[x]]) = (l = [x]) |
Std.Tactic.BVDecide.BVExpr.bitblast.denote_blastNot | Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Not | ∀ {α : Type} [inst : Hashable α] [inst_1 : DecidableEq α] {w : ℕ} (aig : Std.Sat.AIG α) (target : aig.RefVec w)
(assign : α → Bool) (idx : ℕ) (hidx : idx < w),
⟦assign,
{ aig := (Std.Tactic.BVDecide.BVExpr.bitblast.blastNot aig target).aig,
ref := (Std.Tactic.BVDecide.BVExpr.bitblast.blastNot aig target).vec.get idx hidx }⟧ =
!⟦assign, { aig := aig, ref := target.get idx hidx }⟧ |
Int.dvd_self_sub_tmod | Init.Data.Int.DivMod.Lemmas | ∀ {x m : ℤ}, m ∣ x - x.tmod m |
GenContFract.le_of_succ_succ_get?_contsAux_b | Mathlib.Algebra.ContinuedFractions.Computation.Approximations | ∀ {K : Type u_1} {v : K} {n : ℕ} [inst : Field K] [inst_1 : LinearOrder K] [IsStrictOrderedRing K]
[inst_3 : FloorRing K] {b : K},
(GenContFract.of v).partDens.get? n = some b →
b * ((GenContFract.of v).contsAux (n + 1)).b ≤ ((GenContFract.of v).contsAux (n + 2)).b |
Mathlib.Meta.NormNum.IsRat.den_nz | Mathlib.Tactic.NormNum.Result | ∀ {α : Type u_1} [inst : DivisionRing α] {a : α} {n : ℤ} {d : ℕ}, Mathlib.Meta.NormNum.IsRat a n d → ↑d ≠ 0 |
isClosedMap_smul_left | Mathlib.Topology.Algebra.Module.FiniteDimension | ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : NontriviallyNormedField 𝕜] [CompleteSpace 𝕜] [inst_2 : AddCommGroup E]
[inst_3 : TopologicalSpace E] [IsTopologicalAddGroup E] [inst_5 : Module 𝕜 E] [ContinuousSMul 𝕜 E] [T2Space E]
(c : E), IsClosedMap fun x => x • c |
_private.Mathlib.Algebra.Order.GroupWithZero.Unbundled.Basic.0.inv_nonpos._simp_1_1 | Mathlib.Algebra.Order.GroupWithZero.Unbundled.Basic | ∀ {α : Type u_1} [inst : LinearOrder α] {a b : α}, (b ≤ a) = ¬a < b |
Mathlib.Tactic.Abel.term_eq | Mathlib.Tactic.Abel | ∀ {α : Type u_1} [inst : AddCommMonoid α] (n : ℕ) (x a : α), Mathlib.Tactic.Abel.term n x a = n • x + a |
Mathlib.Tactic.Sat.buildReify.match_1 | Mathlib.Tactic.Sat.FromLRAT | (motive : Lean.Expr × Lean.Expr → Sort u_1) →
(x : Lean.Expr × Lean.Expr) → ((e₂ h₂ : Lean.Expr) → motive (e₂, h₂)) → motive x |
mdifferentiableAt_iff_target_of_mem_source | Mathlib.Geometry.Manifold.MFDeriv.Basic | ∀ {𝕜 : 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 : M → M'} [IsManifold I' 1 M']
{x : M} {y : M'}, f x ∈ (chartAt H' y).source → (MDiffAt f x ↔ ContinuousAt f x ∧ MDiffAt (↑(extChartAt I' y) ∘ f) x) |
IsPurelyInseparable.HasExponent | Mathlib.FieldTheory.PurelyInseparable.Exponent | (K : Type u_2) → (L : Type u_3) → [inst : CommRing K] → [inst_1 : Ring L] → [Algebra K L] → Prop |
Lean.Compiler.LCNF.FixedParams.State.visited | Lean.Compiler.LCNF.FixedParams | Lean.Compiler.LCNF.FixedParams.State → Std.HashSet (Lean.Name × Array Lean.Compiler.LCNF.FixedParams.AbsValue) |
_private.Mathlib.Data.Seq.Computation.0.Computation.Corec.f.match_1.splitter | Mathlib.Data.Seq.Computation | {α : Type u_1} →
{β : Type u_2} →
(motive : α ⊕ β → Sort u_3) →
(x : α ⊕ β) → ((a : α) → motive (Sum.inl a)) → ((val : β) → motive (Sum.inr val)) → motive x |
MeasureTheory.stoppedProcess_eq_of_mem_finset | Mathlib.Probability.Process.Stopping | ∀ {Ω : Type u_1} {ι : Type u_3} [inst : Nonempty ι] {τ : Ω → WithTop ι} {E : Type u_4} {u : ι → Ω → E}
[inst_1 : LinearOrder ι] [inst_2 : AddCommMonoid E] {s : Finset ι} (n : ι),
(∀ (ω : Ω), τ ω < ↑n → τ ω ∈ WithTop.some '' ↑s) →
MeasureTheory.stoppedProcess u τ n =
{a | ↑n ≤ τ a}.indicator (u n) + ∑ i ∈ s with i < n, {ω | τ ω = ↑i}.indicator (u i) |
String.Slice.Pos.prev_eq_posLT._proof_1 | Init.Data.String.Lemmas.FindPos | ∀ {s : String.Slice} {p : s.Pos} {h : p ≠ s.startPos}, 0 < p.offset |
CategoryTheory.Limits.BinaryBiconeMorphism.wsnd_assoc | Mathlib.CategoryTheory.Limits.Shapes.BinaryBiproducts | ∀ {C : Type uC} [inst : CategoryTheory.Category.{uC', uC} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{P Q : C} {A B : CategoryTheory.Limits.BinaryBicone P Q} (self : CategoryTheory.Limits.BinaryBiconeMorphism A B)
{Z : C} (h : Q ⟶ Z),
CategoryTheory.CategoryStruct.comp self.hom (CategoryTheory.CategoryStruct.comp B.snd h) =
CategoryTheory.CategoryStruct.comp A.snd h |
Multiset.noncommSum | Mathlib.Data.Finset.NoncommProd | {α : Type u_3} → [inst : AddMonoid α] → (s : Multiset α) → {x | x ∈ s}.Pairwise AddCommute → α |
CategoryTheory.Subgroupoid.isWide_iff_objs_eq_univ | Mathlib.CategoryTheory.Groupoid.Subgroupoid | ∀ {C : Type u} [inst : CategoryTheory.Groupoid C] (S : CategoryTheory.Subgroupoid C), S.IsWide ↔ S.objs = Set.univ |
RestrictedProduct.mk | Mathlib.Topology.Algebra.RestrictedProduct.Basic | {ι : Type u_1} →
{R : ι → Type u_2} →
{A : (i : ι) → Set (R i)} →
{𝓕 : Filter ι} →
(x : (i : ι) → R i) → (∀ᶠ (i : ι) in 𝓕, x i ∈ A i) → RestrictedProduct (fun i => R i) (fun i => A i) 𝓕 |
_private.Init.Data.List.Count.0.List.countP_eq_zero._simp_1_2 | Init.Data.List.Count | ∀ {α : Type u_1} {p : α → Bool} {l : List α}, (List.filter p l = []) = ∀ a ∈ l, ¬p a = true |
List.flatMap_eq_foldl | Init.Data.List.Lemmas | ∀ {α : Type u_1} {β : Type u_2} {f : α → List β} {l : List α},
List.flatMap f l = List.foldl (fun acc a => acc ++ f a) [] l |
id_map' | Init.Control.Lawful.Basic | ∀ {f : Type u_1 → Type u_2} {α : Type u_1} [inst : Functor f] [LawfulFunctor f] (x : f α), (fun a => a) <$> x = x |
DividedPowers.SubDPIdeal.instCompleteLattice._proof_3 | Mathlib.RingTheory.DividedPowers.SubDPIdeal | ∀ {A : Type u_1} [inst : CommSemiring A] {I : Ideal A} {hI : DividedPowers I} (J J' : hI.SubDPIdeal),
(fun J => ⟨J.carrier, ⋯⟩) (J ⊔ J') = (fun J => ⟨J.carrier, ⋯⟩) J ⊔ (fun J => ⟨J.carrier, ⋯⟩) J' |
_private.Mathlib.LinearAlgebra.Eigenspace.Triangularizable.0.Submodule.inf_iSup_genEigenspace._simp_1_2 | Mathlib.LinearAlgebra.Eigenspace.Triangularizable | ∀ {R : Type v} {M : Type w} [inst : CommRing R] [inst_1 : AddCommGroup M] [inst_2 : Module R M] {f : Module.End R M}
{μ : R} {k : ℕ} {x : M}, (x ∈ ((f - μ • 1) ^ k).ker) = (x ∈ (f.genEigenspace μ) ↑k) |
_private.Lean.Server.FileWorker.RequestHandling.0.Lean.Server.FileWorker.handleFoldingRange.addCommandRange | Lean.Server.FileWorker.RequestHandling | Lean.FileMap → Lean.Syntax → StateT (Array Lean.Lsp.FoldingRange) Lean.Server.RequestM PUnit.{1} |
Combinatorics.Additive.«_aux_Mathlib_Combinatorics_Additive_Energy___macroRules_Combinatorics_Additive_termEₘ[_]_1» | Mathlib.Combinatorics.Additive.Energy | Lean.Macro |
CategoryTheory.Pseudofunctor.DescentData'.instCategory._proof_11 | Mathlib.CategoryTheory.Sites.Descent.DescentDataPrime | ∀ {C : Type u_5} [inst : CategoryTheory.Category.{u_3, u_5} C]
{F : CategoryTheory.Pseudofunctor (CategoryTheory.LocallyDiscrete Cᵒᵖ) CategoryTheory.Cat} {ι : Type u_1} {S : C}
{X : ι → C} {f : (i : ι) → X i ⟶ S} {sq : (i j : ι) → CategoryTheory.Limits.ChosenPullback (f i) (f j)}
{sq₃ : (i₁ i₂ i₃ : ι) → CategoryTheory.Limits.ChosenPullback₃ (sq i₁ i₂) (sq i₂ i₃) (sq i₁ i₃)}
{W X_1 Y Z : F.DescentData' sq sq₃} (f_1 : W ⟶ X_1) (g : X_1 ⟶ Y) (h : Y ⟶ Z),
{
hom := fun i =>
CategoryTheory.CategoryStruct.comp
({ hom := fun i => CategoryTheory.CategoryStruct.comp (f_1.hom i) (g.hom i), comm := ⋯ }.hom i) (h.hom i),
comm := ⋯ } =
{
hom := fun i =>
CategoryTheory.CategoryStruct.comp (f_1.hom i)
({ hom := fun i => CategoryTheory.CategoryStruct.comp (g.hom i) (h.hom i), comm := ⋯ }.hom i),
comm := ⋯ } |
mul_eq_one_iff_eq_inv' | Mathlib.Algebra.Group.Basic | ∀ {G : Type u_3} [inst : Group G] {a b : G}, a * b = 1 ↔ b = a⁻¹ |
DFinsupp.comapDomain._proof_2 | Mathlib.Data.DFinsupp.Defs | ∀ {ι : Type u_2} {β : ι → Type u_3} {κ : Type u_1} [inst : (i : ι) → Zero (β i)] (h : κ → ι) (hh : Function.Injective h)
(f : Π₀ (i : ι), β i) (s : { s // ∀ (i : ι), i ∈ s ∨ f.toFun i = 0 }) (x : κ), x ∈ ⋯.toFinset.val ∨ f (h x) = 0 |
Std.DTreeMap.Internal.Impl.Equiv.inter_right | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {instOrd : Ord α} {m₁ m₂ m₃ : Std.DTreeMap.Internal.Impl α β} [Std.TransOrd α]
(h₁ : m₁.WF), m₂.WF → m₃.WF → m₂.Equiv m₃ → (m₁.inter m₂ ⋯).Equiv (m₁.inter m₃ ⋯) |
Lean.Meta.instReduceEvalLiteral | Lean.Meta.ReduceEval | Lean.Meta.ReduceEval Lean.Literal |
Option.instDecidableMemOfDecidableEq | Init.Data.Option.Instances | {α : Type u_1} → [DecidableEq α] → (j : α) → (o : Option α) → Decidable (j ∈ o) |
_private.Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Unital.0._auto_251 | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Unital | Lean.Syntax |
Subgroup.equivMapOfInjective.eq_1 | Mathlib.Algebra.Group.Subgroup.Map | ∀ {G : Type u_1} [inst : Group G] {N : Type u_5} [inst_1 : Group N] (H : Subgroup G) (f : G →* N)
(hf : Function.Injective ⇑f), H.equivMapOfInjective f hf = { toEquiv := Equiv.Set.image (⇑f) (↑H) hf, map_mul' := ⋯ } |
Mathlib.Tactic.subscript.parenthesizer | Mathlib.Util.Superscript | Lean.PrettyPrinter.Parenthesizer → Lean.PrettyPrinter.Parenthesizer |
CategoryTheory.PreGaloisCategory.AutGalois.ext | Mathlib.CategoryTheory.Galois.Prorepresentability | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{u₂, u₁} C] [inst_1 : CategoryTheory.GaloisCategory C]
(F : CategoryTheory.Functor C FintypeCat) {f g : CategoryTheory.PreGaloisCategory.AutGalois F},
(∀ (A : CategoryTheory.PreGaloisCategory.PointedGaloisObject F),
(CategoryTheory.PreGaloisCategory.AutGalois.π F A) f = (CategoryTheory.PreGaloisCategory.AutGalois.π F A) g) →
f = g |
Std.DHashMap.Internal.Raw₀.getThenInsertIfNew?.congr_simp | Std.Data.DHashMap.Raw | ∀ {α : Type u} {β : α → Type v} [inst : BEq α] [inst_1 : Hashable α] [inst_2 : LawfulBEq α]
(m m_1 : Std.DHashMap.Internal.Raw₀ α β),
m = m_1 → ∀ (a : α) (b b_1 : β a), b = b_1 → m.getThenInsertIfNew? a b = m_1.getThenInsertIfNew? a b_1 |
AddSemigroupIdeal.instWellFoundedGT | Mathlib.Algebra.Order.Group.Ideal | ∀ {M : Type u_1} [inst : AddCommMonoid M] [inst_1 : PartialOrder M] [WellQuasiOrderedLE M] [CanonicallyOrderedAdd M],
WellFoundedGT (AddSemigroupIdeal M) |
ContinuousLinearMap.bilinearComp_zero_left | Mathlib.Analysis.Normed.Operator.Bilinear | ∀ {𝕜 : Type u_1} {𝕜₂ : Type u_2} {𝕜₃ : Type u_3} {E : Type u_4} {F : Type u_6} {G : Type u_8}
[inst : SeminormedAddCommGroup E] [inst_1 : SeminormedAddCommGroup F] [inst_2 : SeminormedAddCommGroup G]
[inst_3 : NontriviallyNormedField 𝕜] [inst_4 : NontriviallyNormedField 𝕜₂] [inst_5 : NontriviallyNormedField 𝕜₃]
[inst_6 : NormedSpace 𝕜 E] [inst_7 : NormedSpace 𝕜₂ F] [inst_8 : NormedSpace 𝕜₃ G] {σ₂₃ : 𝕜₂ →+* 𝕜₃} {σ₁₃ : 𝕜 →+* 𝕜₃}
{E' : Type u_11} {F' : Type u_12} [inst_9 : SeminormedAddCommGroup E'] [inst_10 : SeminormedAddCommGroup F']
{𝕜₁' : Type u_13} {𝕜₂' : Type u_14} [inst_11 : NontriviallyNormedField 𝕜₁'] [inst_12 : NontriviallyNormedField 𝕜₂']
[inst_13 : NormedSpace 𝕜₁' E'] [inst_14 : NormedSpace 𝕜₂' F'] {σ₁' : 𝕜₁' →+* 𝕜} {σ₁₃' : 𝕜₁' →+* 𝕜₃} {σ₂' : 𝕜₂' →+* 𝕜₂}
{σ₂₃' : 𝕜₂' →+* 𝕜₃} [inst_15 : RingHomCompTriple σ₁' σ₁₃ σ₁₃'] [inst_16 : RingHomCompTriple σ₂' σ₂₃ σ₂₃']
[inst_17 : RingHomIsometric σ₂₃] [inst_18 : RingHomIsometric σ₁₃'] [inst_19 : RingHomIsometric σ₂₃']
{f : E →SL[σ₁₃] F →SL[σ₂₃] G} {gF : F' →SL[σ₂'] F}, f.bilinearComp 0 gF = 0 |
Lean.Elab.Term.LetConfig.recOn | Lean.Elab.Binders | {motive : Lean.Elab.Term.LetConfig → Sort u} →
(t : Lean.Elab.Term.LetConfig) →
((nondep usedOnly zeta postponeValue generalize : Bool) →
(eq? : Option Lean.Ident) →
motive
{ nondep := nondep, usedOnly := usedOnly, zeta := zeta, postponeValue := postponeValue,
generalize := generalize, eq? := eq? }) →
motive t |
CategoryTheory.createsLimitOfReflectsIso._proof_2 | Mathlib.CategoryTheory.Limits.Creates | ∀ {C : Type u_5} [inst : CategoryTheory.Category.{u_3, u_5} C] {D : Type u_6}
[inst_1 : CategoryTheory.Category.{u_4, u_6} D] {J : Type u_2} [inst_2 : CategoryTheory.Category.{u_1, u_2} J]
{K : CategoryTheory.Functor J C} {F : CategoryTheory.Functor C D} [F.ReflectsIsomorphisms]
(h :
(c : CategoryTheory.Limits.Cone (K.comp F)) →
(t : CategoryTheory.Limits.IsLimit c) → CategoryTheory.LiftsToLimit K F c t),
CategoryTheory.Limits.ReflectsLimit K F |
NonUnitalSeminormedRing.mk | Mathlib.Analysis.Normed.Ring.Basic | {α : Type u_5} →
[toNorm : Norm α] →
[toNonUnitalRing : NonUnitalRing α] →
[toPseudoMetricSpace : PseudoMetricSpace α] →
(∀ (x y : α), dist x y = ‖-x + y‖) → (∀ (a b : α), ‖a * b‖ ≤ ‖a‖ * ‖b‖) → NonUnitalSeminormedRing α |
AlgebraicGeometry.Scheme.instFullOppositeIdealSheafDataOverSubschemeFunctor | Mathlib.AlgebraicGeometry.IdealSheaf.Subscheme | ∀ {Y : AlgebraicGeometry.Scheme}, (AlgebraicGeometry.Scheme.IdealSheafData.subschemeFunctor Y).Full |
BoundedContinuousFunction.probCharDual._proof_5 | Mathlib.MeasureTheory.Measure.CharacteristicFunction.Basic | RingHomIsometric (RingHom.id ℝ) |
List.head_takeWhile | Init.Data.List.TakeDrop | ∀ {α : Type u_1} {p : α → Bool} {l : List α} (w : List.takeWhile p l ≠ []), (List.takeWhile p l).head w = l.head ⋯ |
StructureGroupoid.LocalInvariantProp.liftPropWithinAt_of_liftPropAt | Mathlib.Geometry.Manifold.LocalInvariantProperties | ∀ {H : Type u_1} {M : Type u_2} {H' : Type u_3} {M' : Type u_4} [inst : TopologicalSpace H]
[inst_1 : TopologicalSpace M] [inst_2 : ChartedSpace H M] [inst_3 : TopologicalSpace H']
[inst_4 : TopologicalSpace M'] [inst_5 : ChartedSpace H' M'] {P : (H → H') → Set H → H → Prop} {g : M → M'}
{s : Set M} {x : M},
(∀ ⦃s : Set H⦄ ⦃x : H⦄ ⦃t : Set H⦄ ⦃f : H → H'⦄, t ⊆ s → P f s x → P f t x) →
ChartedSpace.LiftPropAt P g x → ChartedSpace.LiftPropWithinAt P g s x |
Scott.IsOpen.inter | Mathlib.Topology.OmegaCompletePartialOrder | ∀ (α : Type u) [inst : OmegaCompletePartialOrder α] (s t : Set α),
Scott.IsOpen α s → Scott.IsOpen α t → Scott.IsOpen α (s ∩ t) |
OrderIso.toGaloisInsertion._proof_1 | Mathlib.Order.GaloisConnection.Basic | ∀ {α : Type u_2} {β : Type u_1} [inst : Preorder α] [inst_1 : Preorder β] (e : α ≃o β) (g : β), g ≤ e (e.symm g) |
Fin2.fs.injEq | Mathlib.Data.Fin.Fin2 | ∀ {n : ℕ} (a a_1 : Fin2 n), (a.fs = a_1.fs) = (a = a_1) |
Array.getElem_zero_filterMap._proof_1 | Init.Data.Array.Find | ∀ {α : Type u_2} {β : Type u_1} {f : α → Option β} {xs : Array α},
0 < (Array.filterMap f xs).size → (Array.findSome? f xs).isSome = true |
_private.Mathlib.LinearAlgebra.Eigenspace.Pi.0.Module.End.independent_iInf_maxGenEigenspace_of_forall_mapsTo._simp_1_3 | Mathlib.LinearAlgebra.Eigenspace.Pi | ∀ {α : Type u_2} [inst : CompleteLattice α] [IsCompactlyGenerated α] {ι : Type u_3} {f : ι → α},
iSupIndep f = ∀ (s : Finset ι), s.SupIndep f |
Finset.right_eq_union | Mathlib.Data.Finset.Lattice.Basic | ∀ {α : Type u_1} [inst : DecidableEq α] {s t : Finset α}, s = t ∪ s ↔ t ⊆ s |
IsPrimitiveRoot.norm_pow_sub_one_of_prime_pow_ne_two | Mathlib.NumberTheory.Cyclotomic.PrimitiveRoots | ∀ {p : ℕ} {K : Type u} {L : Type v} [inst : Field L] {ζ : L} [inst_1 : Field K] [inst_2 : Algebra K L] {k s : ℕ},
IsPrimitiveRoot ζ (p ^ (k + 1)) →
∀ [hpri : Fact (Nat.Prime p)] [IsCyclotomicExtension {p ^ (k + 1)} K L],
Irreducible (Polynomial.cyclotomic (p ^ (k + 1)) K) →
s ≤ k → p ^ (k - s + 1) ≠ 2 → (Algebra.norm K) (ζ ^ p ^ s - 1) = ↑p ^ p ^ s |
_private.Lean.Elab.AutoBound.0.Lean.Elab.checkValidAutoBoundImplicitName._sparseCasesOn_1 | Lean.Elab.AutoBound | {motive : Lean.Name → Sort u} →
(t : Lean.Name) →
((pre : Lean.Name) → (str : String) → motive (pre.str str)) → (Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t |
String.offset_posLT_lt._simp_1 | Init.Data.String.Lemmas.FindPos | ∀ {s : String} {p : String.Pos.Raw} {h : 0 < p}, ((s.posLT p h).offset < p) = True |
Matrix.subsingleton_of_empty_left | Mathlib.LinearAlgebra.Matrix.Defs | ∀ {m : Type u_2} {n : Type u_3} {α : Type v} [IsEmpty m], Subsingleton (Matrix m n α) |
OrthonormalBasis.det_to_matrix_orthonormalBasis_of_same_orientation | Mathlib.Analysis.InnerProductSpace.Orientation | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : InnerProductSpace ℝ E] {ι : Type u_2} [inst_2 : Fintype ι]
[inst_3 : DecidableEq ι] (e f : OrthonormalBasis ι ℝ E),
e.toBasis.orientation = f.toBasis.orientation → e.toBasis.det ⇑f = 1 |
Vector.insertIdx._proof_2 | Init.Data.Vector.Basic | ∀ {α : Type u_1} {n : ℕ} (xs : Vector α n), ∀ i ≤ n, i ≤ xs.toArray.size |
MonomialOrder.degLex_single_le_iff | Mathlib.Data.Finsupp.MonomialOrder.DegLex | ∀ {σ : Type u_2} [inst : LinearOrder σ] [inst_1 : WellFoundedGT σ] {a b : σ},
((MonomialOrder.degLex.toSyn fun₀ | a => 1) ≤ MonomialOrder.degLex.toSyn fun₀ | b => 1) ↔ b ≤ a |
CategoryTheory.Limits.WidePushout.hom_eq_desc._proof_1 | Mathlib.CategoryTheory.Limits.Shapes.WidePullbacks | ∀ {J : Type u_3} {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {B : C} {objs : J → C}
(arrows : (j : J) → B ⟶ objs j) [inst_1 : CategoryTheory.Limits.HasWidePushout B objs arrows] {X : C}
(g : CategoryTheory.Limits.widePushout B objs arrows ⟶ X) (j : J),
CategoryTheory.CategoryStruct.comp (arrows j)
((fun j => CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.WidePushout.ι arrows j) g) j) =
CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.WidePushout.head arrows) g |
CategoryTheory.Abelian.Preradical.shortExact_shortComplexObj | Mathlib.CategoryTheory.Abelian.Preradical.Colon | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} C] [inst_1 : CategoryTheory.Abelian C]
(Φ : CategoryTheory.Abelian.Preradical C) (X : C), (Φ.shortComplexObj X).ShortExact |
_private.Lean.Meta.Tactic.Grind.EMatchTheorem.0.Lean.Meta.Grind.mkEMatchTheoremWithKind?.go.match_1 | Lean.Meta.Tactic.Grind.EMatchTheorem | (motive : Option (List Lean.Expr × List Lean.HeadIndex) → Sort u_1) →
(__discr : Option (List Lean.Expr × List Lean.HeadIndex)) →
((patterns : List Lean.Expr) → (symbols : List Lean.HeadIndex) → motive (some (patterns, symbols))) →
((x : Option (List Lean.Expr × List Lean.HeadIndex)) → motive x) → motive __discr |
BddDistLat.hom_ext | Mathlib.Order.Category.BddDistLat | ∀ {X Y : BddDistLat} {f g : X ⟶ Y}, BddDistLat.Hom.hom f = BddDistLat.Hom.hom g → f = g |
AlgebraicGeometry.ProjIsoSpecTopComponent.toSpec | Mathlib.AlgebraicGeometry.ProjectiveSpectrum.Scheme | {A : Type u_1} →
{σ : Type u_2} →
[inst : CommRing A] →
[inst_1 : SetLike σ A] →
[inst_2 : AddSubgroupClass σ A] →
(𝒜 : ℕ → σ) →
[inst_3 : GradedRing 𝒜] →
(f : A) →
↑((AlgebraicGeometry.Proj.toLocallyRingedSpace 𝒜).restrict ⋯).toPresheafedSpace ⟶
↑(AlgebraicGeometry.Spec.locallyRingedSpaceObj
(CommRingCat.of (HomogeneousLocalization.Away 𝒜 f))).toPresheafedSpace |
Mathlib.Meta.FunProp.MaybeFunctionData.recOn | Mathlib.Tactic.FunProp.FunctionData | {motive : Mathlib.Meta.FunProp.MaybeFunctionData → Sort u} →
(t : Mathlib.Meta.FunProp.MaybeFunctionData) →
((f : Lean.Expr) → motive (Mathlib.Meta.FunProp.MaybeFunctionData.letE f)) →
((f : Lean.Expr) → motive (Mathlib.Meta.FunProp.MaybeFunctionData.lam f)) →
((fData : Mathlib.Meta.FunProp.FunctionData) → motive (Mathlib.Meta.FunProp.MaybeFunctionData.data fData)) →
motive t |
FundamentalGroupoid.map_id | Mathlib.AlgebraicTopology.FundamentalGroupoid.Basic | ∀ {X : Type u_1} [inst : TopologicalSpace X],
FundamentalGroupoid.map (ContinuousMap.id X) = CategoryTheory.Functor.id (FundamentalGroupoid X) |
Lean.Elab.Tactic.EvalTacticFailure.rec | Lean.Elab.Tactic.Basic | {motive : Lean.Elab.Tactic.EvalTacticFailure → Sort u} →
((exception : Lean.Exception) →
(state : Lean.Elab.Tactic.SavedState) → motive { exception := exception, state := state }) →
(t : Lean.Elab.Tactic.EvalTacticFailure) → motive t |
Lean.Doc.Syntax.linebreak | Lean.DocString.Syntax | Lean.ParserDescr |
CliffordAlgebra.instStarRing._proof_3 | Mathlib.LinearAlgebra.CliffordAlgebra.Star | ∀ {R : Type u_1} [inst : CommRing R] {M : Type u_2} [inst_1 : AddCommGroup M] [inst_2 : Module R M]
{Q : QuadraticForm R M} (x y : CliffordAlgebra Q),
CliffordAlgebra.reverse (CliffordAlgebra.involute (x + y)) =
CliffordAlgebra.reverse (CliffordAlgebra.involute x) + CliffordAlgebra.reverse (CliffordAlgebra.involute y) |
CategoryTheory.Pseudofunctor.DescentData'.descentDataEquivalence._proof_5 | Mathlib.CategoryTheory.Sites.Descent.DescentDataPrime | ∀ {C : Type u_5} [inst : CategoryTheory.Category.{u_3, u_5} C]
(F : CategoryTheory.Pseudofunctor (CategoryTheory.LocallyDiscrete Cᵒᵖ) CategoryTheory.Cat) {ι : Type u_1} {S : C}
{X : ι → C} {f : (i : ι) → X i ⟶ S} (sq : (i j : ι) → CategoryTheory.Limits.ChosenPullback (f i) (f j))
(sq₃ : (i₁ i₂ i₃ : ι) → CategoryTheory.Limits.ChosenPullback₃ (sq i₁ i₂) (sq i₂ i₃) (sq i₁ i₃))
{X_1 Y : F.DescentData' sq sq₃} (f_1 : X_1 ⟶ Y),
CategoryTheory.CategoryStruct.comp ((CategoryTheory.Functor.id (F.DescentData' sq sq₃)).map f_1)
((fun D =>
CategoryTheory.Pseudofunctor.DescentData'.isoMk
(fun x => CategoryTheory.Iso.refl (((CategoryTheory.Functor.id (F.DescentData' sq sq₃)).obj D).obj x)) ⋯)
Y).hom =
CategoryTheory.CategoryStruct.comp
((fun D =>
CategoryTheory.Pseudofunctor.DescentData'.isoMk
(fun x => CategoryTheory.Iso.refl (((CategoryTheory.Functor.id (F.DescentData' sq sq₃)).obj D).obj x)) ⋯)
X_1).hom
(((CategoryTheory.Pseudofunctor.DescentData'.toDescentDataFunctor F sq sq₃).comp
(CategoryTheory.Pseudofunctor.DescentData'.fromDescentDataFunctor F sq sq₃)).map
f_1) |
Polynomial.Chebyshev.irrational_of_isRoot_T_real | Mathlib.Analysis.SpecialFunctions.Trigonometric.Chebyshev.RootsExtrema | ∀ {n : ℕ} {x : ℝ}, (Polynomial.Chebyshev.T ℝ ↑n).IsRoot x → x ≠ 0 → Irrational x |
Lean.Meta.Grind.propagateMatchCondDown._regBuiltin.Lean.Meta.Grind.propagateMatchCondDown.declare_1._@.Lean.Meta.Tactic.Grind.MatchCond.2992396906._hygCtx._hyg.8 | Lean.Meta.Tactic.Grind.MatchCond | IO Unit |
Representation.single_smul | Mathlib.RepresentationTheory.Basic | ∀ {k : Type u_1} {G : Type u_2} {V : Type u_3} [inst : CommSemiring k] [inst_1 : Monoid G] [inst_2 : AddCommMonoid V]
[inst_3 : Module k V] (ρ : Representation k G V) (t : k) (g : G) (v : ρ.asModule),
MonoidAlgebra.single g t • v = t • (ρ g) (ρ.asModuleEquiv v) |
CategoryTheory.LocalizerMorphism.homMap_apply_assoc | Mathlib.CategoryTheory.Localization.HomEquiv | ∀ {C₁ : Type u_2} {C₂ : Type u_3} {D₁ : Type u_5} {D₂ : Type u_6} [inst : CategoryTheory.Category.{v_2, u_2} C₁]
[inst_1 : CategoryTheory.Category.{v_3, u_3} C₂] [inst_2 : CategoryTheory.Category.{v_5, u_5} D₁]
[inst_3 : CategoryTheory.Category.{v_6, u_6} D₂] {W₁ : CategoryTheory.MorphismProperty C₁}
{W₂ : CategoryTheory.MorphismProperty C₂} (Φ : CategoryTheory.LocalizerMorphism W₁ W₂)
(L₁ : CategoryTheory.Functor C₁ D₁) [inst_4 : L₁.IsLocalization W₁] (L₂ : CategoryTheory.Functor C₂ D₂)
[inst_5 : L₂.IsLocalization W₂] {X Y : C₁} (G : CategoryTheory.Functor D₁ D₂) (e : Φ.functor.comp L₂ ≅ L₁.comp G)
(f : L₁.obj X ⟶ L₁.obj Y) {Z : D₂} (h : L₂.obj (Φ.functor.obj Y) ⟶ Z),
CategoryTheory.CategoryStruct.comp (Φ.homMap L₁ L₂ f) h =
CategoryTheory.CategoryStruct.comp (e.hom.app X)
(CategoryTheory.CategoryStruct.comp (G.map f) (CategoryTheory.CategoryStruct.comp (e.inv.app Y) h)) |
_private.Init.Data.List.Sort.Impl.0.List.MergeSort.Internal.mergeSortTR₂.eq_1 | Init.Data.List.Sort.Impl | ∀ {α : Type u_1} (l : List α) (le : α → α → Bool),
List.MergeSort.Internal.mergeSortTR₂ l le = List.MergeSort.Internal.mergeSortTR₂.run✝ le ⟨l, ⋯⟩ |
Bool.atLeastTwo_false_left | Init.Data.BitVec.Bitblast | ∀ {b c : Bool}, false.atLeastTwo b c = (b && c) |
List.pairwise_lt_finRange | Batteries.Data.List.Lemmas | ∀ (n : ℕ), List.Pairwise (fun x1 x2 => x1 < x2) (List.finRange n) |
SaturatedAddSubmonoid.mem_top._simp_1 | Mathlib.Algebra.Group.Submonoid.Saturation | ∀ {M : Type u_1} [inst : AddZeroClass M] {x : M}, (x ∈ ⊤) = True |
CommGrpCat.Forget₂.createsLimit._proof_12 | Mathlib.Algebra.Category.Grp.Limits | ∀ {J : Type u_3} [inst : CategoryTheory.Category.{u_1, u_3} J] (F : CategoryTheory.Functor J CommGrpCat)
(this : Small.{u_2, max u_2 u_3} ↑(F.comp (CategoryTheory.forget CommGrpCat)).sections)
(this_1 :
Small.{u_2, max u_2 u_3}
↑((F.comp ((CategoryTheory.forget₂ CommGrpCat GrpCat).comp (CategoryTheory.forget₂ GrpCat MonCat))).comp
(CategoryTheory.forget MonCat)).sections)
(s : CategoryTheory.Limits.Cone F),
((CategoryTheory.forget₂ CommGrpCat GrpCat).comp (CategoryTheory.forget₂ GrpCat MonCat)).map
{
hom' :=
{
toFun := fun v =>
EquivLike.coe
(equivShrink
↑((F.comp
((CategoryTheory.forget₂ CommGrpCat GrpCat).comp
(CategoryTheory.forget₂ GrpCat MonCat))).comp
(CategoryTheory.forget MonCat)).sections)
⟨fun j =>
((CategoryTheory.forget MonCat).mapCone
(((CategoryTheory.forget₂ CommGrpCat GrpCat).comp
(CategoryTheory.forget₂ GrpCat MonCat)).mapCone
s)).π.app
j v,
⋯⟩,
map_one' := ⋯, map_mul' := ⋯ } } =
((CategoryTheory.forget₂ CommGrpCat GrpCat).comp (CategoryTheory.forget₂ GrpCat MonCat)).map
{
hom' :=
{
toFun := fun v =>
EquivLike.coe
(equivShrink
↑((F.comp
((CategoryTheory.forget₂ CommGrpCat GrpCat).comp
(CategoryTheory.forget₂ GrpCat MonCat))).comp
(CategoryTheory.forget MonCat)).sections)
⟨fun j =>
((CategoryTheory.forget MonCat).mapCone
(((CategoryTheory.forget₂ CommGrpCat GrpCat).comp
(CategoryTheory.forget₂ GrpCat MonCat)).mapCone
s)).π.app
j v,
⋯⟩,
map_one' := ⋯, map_mul' := ⋯ } } |
meromorphicOrderAt_const_intCast | Mathlib.Analysis.Meromorphic.Order | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] (z₀ : 𝕜) (n : ℤ) [inst_1 : Decidable (↑n = 0)],
meromorphicOrderAt (↑n) z₀ = if ↑n = 0 then ⊤ else 0 |
Fintype.sum_neg_iff_of_nonpos | Mathlib.Algebra.Order.BigOperators.Group.Finset | ∀ {ι : Type u_1} {M : Type u_4} [inst : Fintype ι] [inst_1 : AddCommMonoid M] [inst_2 : PartialOrder M]
[IsOrderedCancelAddMonoid M] {f : ι → M}, f ≤ 0 → (∑ i, f i < 0 ↔ f < 0) |
Std.Tactic.BVDecide.Gate.eval.eq_4 | Std.Tactic.BVDecide.Bitblast.BoolExpr.Basic | Std.Tactic.BVDecide.Gate.or.eval = fun x1 x2 => x1 || x2 |
_private.Mathlib.Data.Multiset.Fintype.0.Multiset.instFintypeElemProdNatSetOfLtSndCountFst._simp_10 | Mathlib.Data.Multiset.Fintype | ∀ {a b : Prop}, (a ∧ b ↔ b) = (b → a) |
Lean.Meta.Grind.AC.addTermOpId | Lean.Meta.Tactic.Grind.AC.Util | Lean.Expr → Lean.Meta.Grind.AC.ACM Unit |
SimpleGraph.isSubgraph_eq_le | Mathlib.Combinatorics.SimpleGraph.Basic | ∀ {V : Type u}, SimpleGraph.IsSubgraph = fun x1 x2 => x1 ≤ x2 |
Std.Internal.List.getValueCast?_modifyKey_self | Std.Data.Internal.List.Associative | ∀ {α : Type u} {β : α → Type v} [inst : BEq α] [inst_1 : LawfulBEq α] {k : α} {f : β k → β k}
(l : List ((a : α) × β a)),
Std.Internal.List.DistinctKeys l →
Std.Internal.List.getValueCast? k (Std.Internal.List.modifyKey k f l) =
Option.map f (Std.Internal.List.getValueCast? k l) |
Submodule.adjoint_orthogonalProjection | Mathlib.Analysis.InnerProductSpace.Adjoint | ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : RCLike 𝕜] [inst_1 : NormedAddCommGroup E] [inst_2 : InnerProductSpace 𝕜 E]
[inst_3 : CompleteSpace E] (U : Submodule 𝕜 E) [inst_4 : CompleteSpace ↥U],
ContinuousLinearMap.adjoint U.orthogonalProjection = U.subtypeL |
MonoidHom.coe_of_map_div | Mathlib.Algebra.Group.Hom.Basic | ∀ {G : Type u_5} [inst : Group G] {H : Type u_8} [inst_1 : Group H] (f : G → H)
(hf : ∀ (x y : G), f (x / y) = f x / f y), ⇑(MonoidHom.ofMapDiv f hf) = f |
Std.Tactic.BVDecide.BVExpr.Return.recOn | Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Expr | {aig : Std.Sat.AIG Std.Tactic.BVDecide.BVBit} →
{w : ℕ} →
{motive : Std.Tactic.BVDecide.BVExpr.Return aig w → Sort u} →
(t : Std.Tactic.BVDecide.BVExpr.Return aig w) →
((result : aig.ExtendingRefVecEntry w) →
(cache : Std.Tactic.BVDecide.BVExpr.Cache (↑result).aig) → motive { result := result, cache := cache }) →
motive t |
_private.Mathlib.Data.Finset.Range.0.notMemRangeEquiv._proof_2 | Mathlib.Data.Finset.Range | ∀ (k j : ℕ), k + j ∉ Finset.range k |
MulZeroMemClass.isCancelMulZero | Mathlib.Algebra.GroupWithZero.Submonoid.CancelMulZero | ∀ {M₀ : Type u_1} [inst : Mul M₀] [inst_1 : Zero M₀] {S : Type u_2} [inst_2 : SetLike S M₀] [inst_3 : MulMemClass S M₀]
[inst_4 : ZeroMemClass S M₀] (s : S) [IsCancelMulZero M₀], IsCancelMulZero ↥s |
_private.Mathlib.Topology.Algebra.AsymptoticCone.0.AffineSpace.nhds_bind_asymptoticNhds._simp_1_1 | Mathlib.Topology.Algebra.AsymptoticCone | ∀ {α : Type u_1} {f g : Filter α}, (f ≤ g) = ∀ x ∈ g, x ∈ f |
Filter.pureAddMonoidHom | Mathlib.Order.Filter.Pointwise | {α : Type u_2} → [inst : AddZeroClass α] → α →+ Filter α |
CategoryTheory.Enriched.FunctorCategory.enrichedHom_condition_assoc | Mathlib.CategoryTheory.Enriched.FunctorCategory | ∀ (V : Type u₁) [inst : CategoryTheory.Category.{v₁, u₁} V] [inst_1 : CategoryTheory.MonoidalCategory V] {C : Type u₂}
[inst_2 : CategoryTheory.Category.{v₂, u₂} C] {J : Type u₃} [inst_3 : CategoryTheory.Category.{v₃, u₃} J]
[inst_4 : CategoryTheory.EnrichedOrdinaryCategory V C] (F₁ F₂ : CategoryTheory.Functor J C)
[inst_5 : CategoryTheory.Enriched.FunctorCategory.HasEnrichedHom V F₁ F₂] {i j : J} (f : i ⟶ j) {Z : V}
(h : (F₁.obj i ⟶[V] F₂.obj j) ⟶ Z),
CategoryTheory.CategoryStruct.comp (CategoryTheory.Enriched.FunctorCategory.enrichedHomπ V F₁ F₂ i)
(CategoryTheory.CategoryStruct.comp (CategoryTheory.eHomWhiskerLeft V (F₁.obj i) (F₂.map f)) h) =
CategoryTheory.CategoryStruct.comp (CategoryTheory.Enriched.FunctorCategory.enrichedHomπ V F₁ F₂ j)
(CategoryTheory.CategoryStruct.comp (CategoryTheory.eHomWhiskerRight V (F₁.map f) (F₂.obj j)) h) |
MeasureTheory.sdiff_addFundamentalFrontier | Mathlib.MeasureTheory.Group.FundamentalDomain | ∀ (G : Type u_1) {α : Type u_3} [inst : AddGroup G] [inst_1 : AddAction G α] (s : Set α),
s \ MeasureTheory.addFundamentalFrontier G s = MeasureTheory.addFundamentalInterior G s |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.