name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
_private.Mathlib.NumberTheory.EllipticDivisibilitySequence.0.complEDS₂_mul_b._simp_1_9 | Mathlib.NumberTheory.EllipticDivisibilitySequence | ∀ {α : Type u_1} [inst : SubtractionCommMonoid α] (a b : α), -a - b = -(a + b) | false |
_private.Mathlib.RepresentationTheory.Homological.GroupHomology.Functoriality.0.groupHomology.mapCycles₁_quotientGroupMk'_epi._simp_2 | Mathlib.RepresentationTheory.Homological.GroupHomology.Functoriality | ∀ {k G : Type u} [inst : CommRing k] [inst_1 : Group G] {A : Rep.{u, u, u} k G} (x : G →₀ ↑A),
(x ∈ groupHomology.cycles₁ A) = ((x.sum fun g a => (A.ρ g⁻¹) a) = x.sum fun x a => a) | false |
CategoryTheory.HasShift.recOn | Mathlib.CategoryTheory.Shift.Basic | {C : Type u} →
{A : Type u_2} →
[inst : CategoryTheory.Category.{v, u} C] →
[inst_1 : AddMonoid A] →
{motive : CategoryTheory.HasShift C A → Sort u_1} →
(t : CategoryTheory.HasShift C A) →
((shift : CategoryTheory.Functor (CategoryTheory.Discrete A) (CategoryTheory.Functor C C)... | false |
_aux_Mathlib_Analysis_Normed_Operator_LinearIsometry___unexpand_LinearIsometryEquiv_2 | Mathlib.Analysis.Normed.Operator.LinearIsometry | Lean.PrettyPrinter.Unexpander | false |
_private.Batteries.Data.BitVec.Lemmas.0.BitVec.msb_ofFnBE._proof_1_5 | Batteries.Data.BitVec.Lemmas | ∀ {n : ℕ} (f : Fin n → Bool), (BitVec.ofFnBE f).msb = if h : ¬n = 0 then f ⟨0, ⋯⟩ else false | false |
CategoryTheory.Limits.FormalCoproduct.mk.inj | Mathlib.CategoryTheory.Limits.FormalCoproducts.Basic | ∀ {C : Type u} {I : Type w} {obj : I → C} {I_1 : Type w} {obj_1 : I_1 → C},
{ I := I, obj := obj } = { I := I_1, obj := obj_1 } → I = I_1 ∧ obj ≍ obj_1 | true |
isEmbedding_of_iSup_eq_top_of_preimage_subset_range | Mathlib.Topology.LocalAtTarget | ∀ {X : Type u_6} {Y : Type u_7} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] (f : X → Y),
Continuous f →
∀ {ι : Type u_4} (U : ι → TopologicalSpace.Opens Y),
Set.range f ⊆ ↑(iSup U) →
∀ (V : ι → Type u_5) [inst_2 : (i : ι) → TopologicalSpace (V i)] (iV : (i : ι) → V i → X),
(∀... | true |
Nat.even_mul | Mathlib.Algebra.Group.Nat.Even | ∀ {m n : ℕ}, Even (m * n) ↔ Even m ∨ Even n | true |
Subring.instCompleteLattice.match_1 | Mathlib.Algebra.Ring.Subring.Basic | ∀ {R : Type u_1} [inst : NonAssocRing R] (_x : R) (motive : (∃ n, ↑n = _x) → Prop) (x : ∃ n, ↑n = _x),
(∀ (n : ℤ) (hn : ↑n = _x), motive ⋯) → motive x | false |
CategoryTheory.MorphismProperty.TransfiniteCompositionOfShape.ici | 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] →
{X Y : C} →
... | true |
_private.Mathlib.Tactic.Widget.LibraryRewrite.0.Mathlib.Tactic.LibraryRewrite.tacticSyntax.match_1 | Mathlib.Tactic.Widget.LibraryRewrite | (motive : Lean.MVarId × Lean.BinderInfo → Sort u_1) →
(x : Lean.MVarId × Lean.BinderInfo) →
((mvarId : Lean.MVarId) → (snd : Lean.BinderInfo) → motive (mvarId, snd)) → motive x | false |
Flag.maxChain | Mathlib.Order.Preorder.Chain | ∀ {α : Type u_1} [inst : LE α] (s : Flag α), IsMaxChain (fun x1 x2 => x1 ≤ x2) ↑s | true |
Lean.PrefixTreeNode.rec | 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} →
{... | false |
Function.iterate_zero | Mathlib.Logic.Function.Iterate | ∀ {α : Type u} (f : α → α), f^[0] = id | true |
IsSeqCompact.exists_tendsto_of_frequently_mem | Mathlib.Topology.Sequences | ∀ {X : Type u_1} [inst : UniformSpace X] {s : Set X},
IsSeqCompact s →
∀ {u : ℕ → X}, (∃ᶠ (n : ℕ) in Filter.atTop, u n ∈ s) → CauchySeq u → ∃ x ∈ s, Filter.Tendsto u Filter.atTop (nhds x) | true |
Int.isSome_getElem?_toArray_rco_eq | Init.Data.Range.Polymorphic.IntLemmas | ∀ {m n : ℤ} {i : ℕ}, ((m...n).toArray[i]?.isSome = true) = (i < (n - m).toNat) | true |
Antivary.div_right | Mathlib.Algebra.Order.Monovary | ∀ {ι : Type u_1} {α : Type u_2} {β : Type u_3} [inst : Preorder α] [inst_1 : CommGroup β] [inst_2 : LinearOrder β]
[IsOrderedMonoid β] {f : ι → α} {g₁ g₂ : ι → β}, Antivary f g₁ → Monovary f g₂ → Antivary f (g₁ / g₂) | true |
rexp_neg_quadratic_isLittleO_rpow_atTop | Mathlib.Analysis.SpecialFunctions.Gaussian.PoissonSummation | ∀ {a : ℝ}, a < 0 → ∀ (b s : ℝ), (fun x => Real.exp (a * x ^ 2 + b * x)) =o[Filter.atTop] fun x => x ^ s | true |
Matroid.sigma._proof_4 | Mathlib.Combinatorics.Matroid.Sum | ∀ {ι : Type u_1} {α : ι → Type u_2} (M : (i : ι) → Matroid (α i)), ∃ B, ∀ (i : ι), (M i).IsBase (Sigma.mk i ⁻¹' B) | false |
CategoryTheory.Limits.WalkingParallelPair.one.elim | Mathlib.CategoryTheory.Limits.Shapes.Equalizers | {motive : CategoryTheory.Limits.WalkingParallelPair → Sort u} →
(t : CategoryTheory.Limits.WalkingParallelPair) →
t.ctorIdx = 1 → motive CategoryTheory.Limits.WalkingParallelPair.one → motive t | false |
GenContFract.IntFractPair.seq1.eq_1 | Mathlib.Algebra.ContinuedFractions.Computation.Translations | ∀ {K : Type u_1} [inst : DivisionRing K] [inst_1 : LinearOrder K] [inst_2 : FloorRing K] (v : K),
GenContFract.IntFractPair.seq1 v =
(GenContFract.IntFractPair.of v, Stream'.Seq.tail ⟨GenContFract.IntFractPair.stream v, ⋯⟩) | true |
Nat.lt_wfRel | Init.WF | WellFoundedRelation ℕ | true |
_private.Mathlib.RingTheory.Polynomial.Resultant.Basic.0.Polynomial.resultant_succ_left_deg._simp_1_13 | Mathlib.RingTheory.Polynomial.Resultant.Basic | ∀ {n : ℕ} {a b : Fin n}, (a = b) = (↑a = ↑b) | false |
AlgebraicGeometry.LocallyRingedSpace.IsOpenImmersion.inv_naturality | Mathlib.Geometry.RingedSpace.OpenImmersion | ∀ {X Y : AlgebraicGeometry.LocallyRingedSpace} (f : X ⟶ Y) [H : AlgebraicGeometry.LocallyRingedSpace.IsOpenImmersion f]
{U V : (TopologicalSpace.Opens ↑X.toTopCat)ᵒᵖ} (i : U ⟶ V),
CategoryTheory.CategoryStruct.comp (X.presheaf.map i)
(AlgebraicGeometry.LocallyRingedSpace.IsOpenImmersion.invApp f (Opposite.uno... | true |
_private.Mathlib.Data.Set.Finite.Lemmas.0.Set.exists_max_image.match_1_1 | Mathlib.Data.Set.Finite.Lemmas | ∀ {α : Type u_1} (s : Set α) (motive : s.Nonempty → Prop) (x : s.Nonempty),
(∀ (x : α) (hx : x ∈ s), motive ⋯) → motive x | false |
LightCondensed.freeForgetAdjunction | Mathlib.Condensed.Light.Module | (R : Type u) → [inst : Ring R] → LightCondensed.free R ⊣ LightCondensed.forget R | true |
Std.ExtDHashMap.contains_of_contains_insertIfNew | Std.Data.ExtDHashMap.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {β : α → Type v} {m : Std.ExtDHashMap α β} [inst : EquivBEq α]
[inst_1 : LawfulHashable α] {k a : α} {v : β k},
(m.insertIfNew k v).contains a = true → (k == a) = false → m.contains a = true | true |
VonNeumannAlgebra.zero_mem'._inherited_default | Mathlib.Analysis.VonNeumannAlgebra.Basic | ∀ {H : Type u} {inst : NormedAddCommGroup H} {inst_1 : InnerProductSpace ℂ H} {inst_2 : CompleteSpace H}
(carrier : Set (H →L[ℂ] H)), (∀ (r : ℂ), (algebraMap ℂ (H →L[ℂ] H)) r ∈ carrier) → 0 ∈ carrier | false |
_private.Mathlib.Tactic.NormNum.Result.0.Mathlib.Meta.NormNum.isNat.natElim.match_1_1 | Mathlib.Tactic.NormNum.Result | ∀ {p : ℕ → Prop} (motive : (x x_1 : ℕ) → Mathlib.Meta.NormNum.IsNat x x_1 → p x_1 → Prop) (x x_1 : ℕ)
(x_2 : Mathlib.Meta.NormNum.IsNat x x_1) (x_3 : p x_1),
(∀ (n : ℕ) (h : p n), motive (↑n) n ⋯ h) → motive x x_1 x_2 x_3 | false |
DirectSum.lid | Mathlib.Algebra.DirectSum.Module | (R : Type u) →
[inst : Semiring R] →
(M : Type v) →
(ι : optParam (Type u_1) PUnit.{u_1 + 1}) →
[inst_1 : AddCommMonoid M] → [inst_2 : Module R M] → [Unique ι] → (DirectSum ι fun x => M) ≃ₗ[R] M | true |
Array.back.congr_simp | Init.Data.List.ToArray | ∀ {α : Type u} (xs xs_1 : Array α) (e_xs : xs = xs_1) (h : 0 < xs.size), xs.back h = xs_1.back ⋯ | true |
Lean.IR.Alt.brecOn | Lean.Compiler.IR.Basic | {motive_1 : Lean.IR.Alt → Sort u} →
{motive_2 : Lean.IR.FnBody → Sort u} →
{motive_3 : Array Lean.IR.Alt → Sort u} →
{motive_4 : List Lean.IR.Alt → Sort u} →
(t : Lean.IR.Alt) →
((t : Lean.IR.Alt) → t.below → motive_1 t) →
((t : Lean.IR.FnBody) → t.below → motive_2 t) →
... | false |
AddOpposite.instNeg.eq_1 | Mathlib.Algebra.Opposites | ∀ {α : Type u_1} [inst : Neg α], AddOpposite.instNeg = { neg := fun x => AddOpposite.op (-AddOpposite.unop x) } | true |
Std.Internal.List.Const.getKeyD_filter | Std.Data.Internal.List.Associative | ∀ {α : Type u} [inst : BEq α] [inst_1 : EquivBEq α] {β : Type v} {f : α → β → Bool} {l : List ((_ : α) × β)}
{k fallback : α},
Std.Internal.List.DistinctKeys l →
Std.Internal.List.getKeyD k (List.filter (fun p => f p.fst p.snd) l) fallback =
((Std.Internal.List.getKey? k l).pfilter fun x h => f x (Std.Int... | true |
Sum.swap_rightInverse | Mathlib.Data.Sum.Basic | ∀ {α : Type u} {β : Type v}, Function.RightInverse Sum.swap Sum.swap | true |
_private.Init.Data.Iterators.Lemmas.Combinators.FilterMap.0.Std.Iter.forIn_filterMapWithPostcondition.match_1.eq_2 | Init.Data.Iterators.Lemmas.Combinators.FilterMap | ∀ {β₂ : Type u_1} (motive : Option β₂ → Sort u_2) (h_1 : (c : β₂) → motive (some c)) (h_2 : Unit → motive none),
(match none with
| some c => h_1 c
| none => h_2 ()) =
h_2 () | true |
ContinuousLinearEquiv.conjContinuousAlgEquiv_apply_apply | Mathlib.Topology.Algebra.Module.StrongTopology | ∀ {𝕜 : Type u_1} {G : Type u_4} {H : Type u_5} [inst : AddCommGroup G] [inst_1 : AddCommGroup H]
[inst_2 : NormedField 𝕜] [inst_3 : Module 𝕜 G] [inst_4 : Module 𝕜 H] [inst_5 : TopologicalSpace G]
[inst_6 : TopologicalSpace H] [inst_7 : IsTopologicalAddGroup G] [inst_8 : IsTopologicalAddGroup H]
[inst_9 : Cont... | true |
semicontinuous_restrict_iff._simp_1 | Mathlib.Topology.Semicontinuity.Defs | ∀ {α : Type u_1} {β : Type u_2} [inst : TopologicalSpace α] {r : α → β → Prop} {s : Set α},
Semicontinuous (s.restrict r) = SemicontinuousOn r s | false |
FreeAddMonoid.toList.eq_1 | Mathlib.Algebra.FreeMonoid.Basic | ∀ {α : Type u_1}, FreeAddMonoid.toList = Equiv.refl (FreeAddMonoid α) | true |
Lean.Lsp.Command.recOn | Lean.Data.Lsp.Basic | {motive : Lean.Lsp.Command → Sort u} →
(t : Lean.Lsp.Command) →
((title command : String) →
(arguments? : Option (Array Lean.Json)) →
motive { title := title, command := command, arguments? := arguments? }) →
motive t | false |
AlgebraicGeometry.Scheme.Modules.Hom.isIso_iff_isIso_app | Mathlib.AlgebraicGeometry.Modules.Sheaf | ∀ {X : AlgebraicGeometry.Scheme} {M N : X.Modules} {φ : M ⟶ N},
CategoryTheory.IsIso φ ↔ ∀ (U : X.Opens), CategoryTheory.IsIso (AlgebraicGeometry.Scheme.Modules.Hom.app φ U) | true |
_private.Mathlib.Tactic.Widget.Conv.0.Mathlib.Tactic.Conv.pathToStx.match_3 | Mathlib.Tactic.Widget.Conv | (motive : Mathlib.Tactic.Conv.Path → Sort u_1) →
(path : Mathlib.Tactic.Conv.Path) →
((arg : ℕ) →
(all : Bool) → (next : Mathlib.Tactic.Conv.Path) → motive (Mathlib.Tactic.Conv.Path.arg arg all next)) →
((next : Mathlib.Tactic.Conv.Path) → motive next.type) →
((name : Lean.Name) → (next : Ma... | false |
Nat.binaryRec'._proof_1 | Mathlib.Data.Nat.BinaryRec | ∀ {motive : ℕ → Sort u_1} (b : Bool) (n : ℕ) (ih : motive n), ¬(n = 0 → b = true) → Nat.bit b n = 0 | false |
PrincipalSeg.ordinal_type_lt | Mathlib.SetTheory.Ordinal.Basic | ∀ {α β : Type u_1} {r : α → α → Prop} {s : β → β → Prop} [inst : IsWellOrder α r] [inst_1 : IsWellOrder β s]
(h : PrincipalSeg r s), Ordinal.type r < Ordinal.type s | true |
Mathlib.Tactic.Abel.AbelNF.Config.mk._flat_ctor | Mathlib.Tactic.Abel | Lean.Meta.TransparencyMode → Bool → Bool → Mathlib.Tactic.Abel.AbelMode → Mathlib.Tactic.Abel.AbelNF.Config | false |
Mathlib.Tactic.ITauto.IProp.and'.noConfusion | Mathlib.Tactic.ITauto | {P : Sort u} →
{a : Mathlib.Tactic.ITauto.AndKind} →
{a_1 a_2 : Mathlib.Tactic.ITauto.IProp} →
{a' : Mathlib.Tactic.ITauto.AndKind} →
{a'_1 a'_2 : Mathlib.Tactic.ITauto.IProp} →
Mathlib.Tactic.ITauto.IProp.and' a a_1 a_2 = Mathlib.Tactic.ITauto.IProp.and' a' a'_1 a'_2 →
(a = a'... | false |
AlgebraicGeometry.Scheme.LocalRepresentability.glueData._proof_14 | Mathlib.AlgebraicGeometry.Sites.Representability | ∀ {F : CategoryTheory.Sheaf AlgebraicGeometry.Scheme.zariskiTopology (Type u_1)} {ι : Type u_1}
{X : ι → AlgebraicGeometry.Scheme} {f : (i : ι) → CategoryTheory.yoneda.obj (X i) ⟶ F.obj}
(hf : ∀ (i : ι), AlgebraicGeometry.IsOpenImmersion.presheaf (f i)) (i j k : ι),
CategoryTheory.CategoryStruct.comp
(⋯.lif... | false |
Mathlib.Meta.FunProp.LambdaTheorems._sizeOf_1 | Mathlib.Tactic.FunProp.Theorems | Mathlib.Meta.FunProp.LambdaTheorems → ℕ | false |
_private.Mathlib.NumberTheory.PellMatiyasevic.0.Pell.matiyasevic.match_1_5 | Mathlib.NumberTheory.PellMatiyasevic | ∀ {a k x y : ℕ}
(motive :
(x = 1 ∧ y = 0 ∨
∃ u v s t b,
x * x - (a * a - 1) * y * y = 1 ∧
u * u - (a * a - 1) * v * v = 1 ∧
s * s - (b * b - 1) * t * t = 1 ∧
1 < b ∧ b ≡ 1 [MOD 4 * y] ∧ b ≡ a [MOD u] ∧ 0 < v ∧ y * y ∣ v ∧ s ≡ x [MOD u] ∧ t ≡ k [MOD 4 * y... | false |
Affine.Simplex.instFintypePointsWithCircumcenterIndex.match_3 | Mathlib.Geometry.Euclidean.Circumcenter | (n : ℕ) →
(motive : Fin (n + 1) ⊕ Unit → Sort u_1) →
(x : Fin (n + 1) ⊕ Unit) →
((a : Fin (n + 1)) → motive (Sum.inl a)) → (Unit → motive (Sum.inr PUnit.unit)) → motive x | false |
Submodule.annihilator | Mathlib.RingTheory.Ideal.Maps | {R : Type u_1} →
{M : Type u_2} → [inst : Semiring R] → [inst_1 : AddCommMonoid M] → [inst_2 : Module R M] → Submodule R M → Ideal R | true |
_private.Mathlib.RingTheory.Spectrum.Prime.Topology.0.PrimeSpectrum.stableUnderSpecialization_singleton._simp_1_5 | Mathlib.RingTheory.Spectrum.Prime.Topology | ∀ {α : Sort u_1} {p : α → Prop} {a' : α}, (∀ (a : α), a = a' → p a) = p a' | false |
WellFoundedLT.finite_of_iSupIndep | Mathlib.Order.CompactlyGenerated.Basic | ∀ {α : Type u_2} [inst : CompleteLattice α] [WellFoundedLT α] {ι : Type u_3} {t : ι → α},
iSupIndep t → (∀ (i : ι), t i ≠ ⊥) → Finite ι | true |
summable_star_iff' | Mathlib.Topology.Algebra.InfiniteSum.Constructions | ∀ {α : Type u_1} {β : Type u_2} {L : SummationFilter β} [inst : AddCommMonoid α] [inst_1 : TopologicalSpace α]
[inst_2 : StarAddMonoid α] [ContinuousStar α] {f : β → α}, Summable (star f) L ↔ Summable f L | true |
_private.Mathlib.Algebra.Homology.HomotopyCofiber.0.HomologicalComplex.homotopyCofiber.descSigma_ext_iff._simp_1_1 | Mathlib.Algebra.Homology.HomotopyCofiber | ∀ {α : Type u_1} {β : α → Type u_4} {a₁ a₂ : α} {b₁ : β a₁} {b₂ : β a₂}, (⟨a₁, b₁⟩ = ⟨a₂, b₂⟩) = (a₁ = a₂ ∧ b₁ ≍ b₂) | false |
Lean.Meta.Grind.EMatchTheoremConstraint.notDefEq | Lean.Meta.Tactic.Grind.Extension | ℕ → Lean.Meta.Grind.CnstrRHS → Lean.Meta.Grind.EMatchTheoremConstraint | true |
LowerSet.coe_div._simp_2 | Mathlib.Algebra.Order.UpperLower | ∀ {α : Type u_1} [inst : CommGroup α] [inst_1 : Preorder α] [inst_2 : IsOrderedMonoid α] (s t : LowerSet α),
↑s / ↑t = ↑(s / t) | false |
pinGroup.star_mul_self | Mathlib.LinearAlgebra.CliffordAlgebra.SpinGroup | ∀ {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 : ↥(pinGroup Q)), star x * x = 1 | true |
Lean.Grind.CommRing.instReprMon.repr._sunfold | Init.Grind.Ring.CommSolver | Lean.Grind.CommRing.Mon → ℕ → Std.Format | false |
IsCyclotomicExtension.Rat.p_mem_span_zeta_sub_one | Mathlib.NumberTheory.NumberField.Cyclotomic.Ideal | ∀ (p k : ℕ) [hp : Fact (Nat.Prime p)] {K : Type u_1} [inst : Field K] [inst_1 : NumberField K]
[hK : IsCyclotomicExtension {p ^ (k + 1)} ℚ K] {ζ : K} (hζ : IsPrimitiveRoot ζ (p ^ (k + 1))),
↑p ∈ Ideal.span {hζ.toInteger - 1} | true |
AddSubgroup.coe_pathComponentZero | Mathlib.Topology.Connected.PathConnected | ∀ (G : Type u_4) [inst : AddGroup G] [inst_1 : TopologicalSpace G] [inst_2 : IsTopologicalAddGroup G],
↑(AddSubgroup.pathComponentZero G) = pathComponent 0 | true |
spectrum.spectralRadius_le_liminf_pow_nnnorm_pow_one_div | Mathlib.Analysis.Normed.Algebra.Spectrum | ∀ (𝕜 : Type u_1) {A : Type u_2} [inst : NormedField 𝕜] [inst_1 : NormedRing A] [inst_2 : NormedAlgebra 𝕜 A]
[CompleteSpace A] (a : A), spectralRadius 𝕜 a ≤ Filter.liminf (fun n => ↑‖a ^ n‖₊ ^ (1 / ↑n)) Filter.atTop | true |
NumberField.Ideal.primesOverSpanEquivMonicFactorsMod_symm_apply._proof_1 | Mathlib.NumberTheory.NumberField.Ideal.KummerDedekind | ∀ {p : ℕ} [Fact (Nat.Prime p)], Ideal.span {↑p} ≠ ⊥ | false |
CategoryTheory.BraidedCategory.ofCartesianMonoidalCategory._proof_10 | Mathlib.CategoryTheory.Monoidal.Cartesian.Basic | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.CartesianMonoidalCategory C]
(X Y Z : C),
CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategoryStruct.associator X Y Z).hom
(CategoryTheory.CategoryStruct.comp
{
hom :=
Categ... | false |
LatticeHom.snd | Mathlib.Order.Hom.Lattice | {α : Type u_2} → {β : Type u_3} → [inst : Lattice α] → [inst_1 : Lattice β] → LatticeHom (α × β) β | true |
Lean.Linter.MissingDocs.mkHandler | Lean.Linter.MissingDocs | Lean.Name → Lean.ImportM Lean.Linter.MissingDocs.Handler | true |
CategoryTheory.ComposableArrows.isoMk₅._proof_14 | Mathlib.CategoryTheory.ComposableArrows.Basic | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {f g : CategoryTheory.ComposableArrows C 5}
(app₀ : f.obj' 0 _proof_441✝ ≅ g.obj' 0 _proof_441✝¹) (app₁ : f.obj' 1 _proof_442✝ ≅ g.obj' 1 _proof_442✝¹)
(app₂ : f.obj' 2 _proof_443✝ ≅ g.obj' 2 _proof_443✝¹) (app₃ : f.obj' 3 _proof_444✝ ≅ g.obj' 3 _proof_... | false |
SimpleGraph.Coloring.sumEquiv | Mathlib.Combinatorics.SimpleGraph.Sum | {V : Type u_1} →
{W : Type u_2} →
{γ : Type u_4} → {G : SimpleGraph V} → {H : SimpleGraph W} → (G ⊕g H).Coloring γ ≃ G.Coloring γ × H.Coloring γ | true |
Std.Net.AddressFamily.ipv4.sizeOf_spec | Std.Net.Addr | sizeOf Std.Net.AddressFamily.ipv4 = 1 | true |
Std.IterM.toArray_filterMap | Init.Data.Iterators.Lemmas.Combinators.Monadic.FilterMap | ∀ {α β γ : Type w} {m : Type w → Type w'} [inst : Monad m] [LawfulMonad m] [inst_2 : Std.Iterator α m β]
[Std.Iterators.Finite α m] {f : β → Option γ} (it : Std.IterM m β),
(Std.IterM.filterMap f it).toArray = (fun x => Array.filterMap f x) <$> it.toArray | true |
Rep.indResHomEquiv._proof_8 | Mathlib.RepresentationTheory.Induced | ∀ {k : Type u_1} {G : Type u_4} {H : Type u_2} [inst : CommRing k] [inst_1 : Group G] [inst_2 : Group H] (φ : G →* H)
(A : Rep.{max u_3 u_2 u_1, u_1, u_4} k G) (B : Rep.{max u_3 u_2 u_1, u_1, u_2} k H) (x x_1 : Rep.ind φ A ⟶ B),
Rep.ofHom
{ toLinearMap := (Rep.Hom.hom (x + x_1)).toLinearMap ∘ₗ Representation.... | false |
Nat.nonempty_of_pos_sInf | Mathlib.Data.Nat.Lattice | ∀ {s : Set ℕ}, 0 < sInf s → s.Nonempty | true |
Subtype.mk_eq_bot_iff | Mathlib.Order.BoundedOrder.Basic | ∀ {α : Type u} {p : α → Prop} [inst : PartialOrder α] [inst_1 : OrderBot α] [inst_2 : OrderBot (Subtype p)],
p ⊥ → ∀ {x : α} (hx : p x), ⟨x, hx⟩ = ⊥ ↔ x = ⊥ | true |
AlgebraicGeometry.PresheafedSpace.restrict_presheaf | Mathlib.Geometry.RingedSpace.PresheafedSpace | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {U : TopCat} (X : AlgebraicGeometry.PresheafedSpace C)
{f : U ⟶ ↑X} (h : Topology.IsOpenEmbedding ⇑(CategoryTheory.ConcreteCategory.hom f)),
(X.restrict h).presheaf = h.functor.op.comp X.presheaf | true |
IsLocalRing.finrank_cotangentSpace_eq_zero_iff | Mathlib.RingTheory.Ideal.Cotangent | ∀ {R : Type u_1} [inst : CommRing R] [inst_1 : IsLocalRing R] [IsNoetherianRing R],
Module.finrank (IsLocalRing.ResidueField R) (IsLocalRing.CotangentSpace R) = 0 ↔ IsField R | true |
String.Slice.Pos.offset_str_le_offset_endExclusive | Init.Data.String.Basic | ∀ {s : String.Slice} {pos : s.Pos}, pos.str.offset ≤ s.endExclusive.offset | true |
Std.TreeMap.minKey?_eq_some_minKey! | Std.Data.TreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.TreeMap α β cmp} [Std.TransCmp cmp] [inst : Inhabited α],
t.isEmpty = false → t.minKey? = some t.minKey! | true |
_private.Init.Data.String.Lemmas.Pattern.String.ForwardSearcher.0.String.Slice.Pattern.Model.ForwardSliceSearcher.Invariants.base | Init.Data.String.Lemmas.Pattern.String.ForwardSearcher | {pat s : String.Slice} →
{needlePos stackPos : String.Pos.Raw} →
String.Slice.Pattern.Model.ForwardSliceSearcher.Invariants✝ pat s needlePos stackPos → s.Pos | true |
ENNReal.tsum_biUnion_le | Mathlib.Topology.Algebra.InfiniteSum.ENNReal | ∀ {α : Type u_1} {ι : Type u_4} (f : α → ENNReal) (s : Finset ι) (t : ι → Set α),
∑' (x : ↑(⋃ i ∈ s, t i)), f ↑x ≤ ∑ i ∈ s, ∑' (x : ↑(t i)), f ↑x | true |
_private.Mathlib.NumberTheory.NumberField.Cyclotomic.Three.0.IsCyclotomicExtension.Rat.Three.lambda_dvd_or_dvd_sub_one_or_dvd_add_one._simp_1_2 | Mathlib.NumberTheory.NumberField.Cyclotomic.Three | ∀ {α : Type u_1} {a b : α}, (b ∈ {a}) = (b = a) | false |
mulActionClosedBallBall._proof_5 | Mathlib.Analysis.Normed.Module.Ball.Action | ∀ {𝕜 : Type u_2} {E : Type u_1} [inst : NormedField 𝕜] [inst_1 : SeminormedAddCommGroup E] [inst_2 : NormedSpace 𝕜 E]
{r : ℝ} (_c₂ : ↑(Metric.ball 0 r)), 1 • _c₂ = _c₂ | false |
TensorPower.gmonoid._proof_3 | Mathlib.LinearAlgebra.TensorPower.Basic | ∀ {R : Type u_1} {M : Type u_2} [inst : CommSemiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
(x : GradedMonoid fun i => TensorPower R i M), 1 * x = x | false |
Std.Internal.IO.Async.BaseAsync.toRawBaseIO | Std.Internal.Async.Basic | {α : Type} → Std.Internal.IO.Async.BaseAsync α → BaseIO (Std.Internal.IO.Async.MaybeTask α) | true |
AddMonoid.End.mulRight | Mathlib.Algebra.Ring.Basic | {R : Type u_1} → [inst : NonUnitalNonAssocSemiring R] → R →+ AddMonoid.End R | true |
_private.Mathlib.Data.NNReal.Defs.0.Real.toNNReal_le_toNNReal_iff._simp_1_1 | Mathlib.Data.NNReal.Defs | ∀ {r₁ r₂ : NNReal}, (r₁ ≤ r₂) = (↑r₁ ≤ ↑r₂) | false |
TensorProduct.assoc_tensor' | Mathlib.LinearAlgebra.TensorProduct.Associator | ∀ {R : Type u_1} [inst : CommSemiring R] {M : Type u_5} {N : Type u_6} {Q : Type u_8} {S : Type u_9}
[inst_1 : AddCommMonoid M] [inst_2 : AddCommMonoid N] [inst_3 : AddCommMonoid Q] [inst_4 : AddCommMonoid S]
[inst_5 : Module R M] [inst_6 : Module R N] [inst_7 : Module R Q] [inst_8 : Module R S],
TensorProduct.as... | true |
Std.TreeMap.Raw.insertMany_cons | Std.Data.TreeMap.Raw.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.TreeMap.Raw α β cmp} {l : List (α × β)} {k : α} {v : β},
t.insertMany ((k, v) :: l) = (t.insert k v).insertMany l | true |
_private.Mathlib.Tactic.CancelDenoms.Core.0.Mathlib.Tactic.cancelDenominatorsTarget | Mathlib.Tactic.CancelDenoms.Core | Lean.Elab.Tactic.TacticM Unit | true |
MvQPF.Fix.ind | Mathlib.Data.QPF.Multivariate.Constructions.Fix | ∀ {n : ℕ} {F : TypeVec.{u} (n + 1) → Type u} [q : MvQPF F] {α : TypeVec.{u} n} (p : MvQPF.Fix F α → Prop),
(∀ (x : F (α ::: MvQPF.Fix F α)), MvFunctor.LiftP (α.PredLast p) x → p (MvQPF.Fix.mk x)) → ∀ (x : MvQPF.Fix F α), p x | true |
Fin.val_addNat | Init.Data.Fin.Lemmas | ∀ {n : ℕ} (m : ℕ) (i : Fin n), ↑(i.addNat m) = ↑i + m | true |
HasProd.nat_mul_neg_add_one | Mathlib.Topology.Algebra.InfiniteSum.NatInt | ∀ {M : Type u_1} [inst : CommMonoid M] [inst_1 : TopologicalSpace M] {m : M} {f : ℤ → M},
HasProd f m → HasProd (fun n => f ↑n * f (-(↑n + 1))) m | true |
dvd_of_mul_right_eq | Mathlib.Algebra.Divisibility.Basic | ∀ {α : Type u_1} [inst : Semigroup α] {a b : α} (c : α), a * c = b → a ∣ b | true |
one_le_pow_mul_abs_eval_div | Mathlib.Algebra.Polynomial.DenomsClearable | ∀ {K : Type u_1} [inst : Field K] [inst_1 : LinearOrder K] [IsStrictOrderedRing K] {f : Polynomial ℤ} {a b : ℤ},
0 < b →
Polynomial.eval (↑a / ↑b) (Polynomial.map (algebraMap ℤ K) f) ≠ 0 →
1 ≤ ↑b ^ f.natDegree * |Polynomial.eval (↑a / ↑b) (Polynomial.map (algebraMap ℤ K) f)| | true |
_private.Mathlib.Topology.Instances.EReal.Lemmas.0.EReal.continuousAt_add_top_coe._simp_1_2 | Mathlib.Topology.Instances.EReal.Lemmas | ∀ (x y : ℝ), ↑x + ↑y = ↑(x + y) | false |
Std.DHashMap.Internal.AssocList.map | Std.Data.DHashMap.Internal.AssocList.Basic | {α : Type u} →
{β : α → Type v} →
{γ : α → Type w} → ((a : α) → β a → γ a) → Std.DHashMap.Internal.AssocList α β → Std.DHashMap.Internal.AssocList α γ | true |
Matroid.IsCircuit | Mathlib.Combinatorics.Matroid.Circuit | {α : Type u_1} → Matroid α → Set α → Prop | true |
Submodule.IsMinimalPrimaryDecomposition.mem_associatedPrimes | Mathlib.RingTheory.Lasker | ∀ {R : Type u_1} {M : Type u_2} [inst : CommSemiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
{N : Submodule R M} {t : Finset (Submodule R M)},
N.IsMinimalPrimaryDecomposition t → ∀ {q : Submodule R M}, q ∈ t → (q.colon Set.univ).radical ∈ N.associatedPrimes | true |
CategoryTheory.SingleObj.toEnd | Mathlib.CategoryTheory.SingleObj | (M : Type u) → [inst : Monoid M] → M ≃* CategoryTheory.End (CategoryTheory.SingleObj.star M) | true |
_private.Mathlib.LinearAlgebra.Dimension.Free.0.Module.Free.rank_eq_mk_of_infinite_lt._simp_1_1 | Mathlib.LinearAlgebra.Dimension.Free | ∀ (R : Type u) (M : Type v) [inst : Semiring R] [StrongRankCondition R] [inst_2 : AddCommMonoid M] [inst_3 : Module R M]
[inst_4 : Module.Free R M], Cardinal.mk (Module.Free.ChooseBasisIndex R M) = Module.rank R M | false |
UInt32.ofBitVec_ofFin | Init.Data.UInt.Lemmas | ∀ (n : Fin (2 ^ 32)), { toBitVec := { toFin := n } } = UInt32.ofFin n | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.