name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
_private.Mathlib.GroupTheory.Perm.Cycle.Type.0.Equiv.Perm.IsThreeCycle.nodup_iff_mem_support._proof_1_533 | Mathlib.GroupTheory.Perm.Cycle.Type | ∀ {α : Type u_1} [inst_1 : DecidableEq α] {g : Equiv.Perm α} {a : α} (w w_1 : α)
(h :
List.findIdxNth (fun x => decide (x = w)) [g (g a)] {g (g a)}.card + 1 ≤
(List.filter (fun x => decide (x = w_1)) []).length),
(List.findIdxs (fun x => decide (x = w_1)) [])[List.findIdxNth (fun x => decide (x = w)) [g (... | false |
CategoryTheory.ShortComplex.ShortExact.extClass._proof_10 | Mathlib.Algebra.Homology.DerivedCategory.Ext.ExtClass | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Abelian C]
{S : CategoryTheory.ShortComplex C} (i : ℤ),
(HomologicalComplex.sc (S.map (HomologicalComplex.single C (ComplexShape.up ℤ) 0)).X₃ i).HasHomology | false |
eventually_nhds_iff | Mathlib.Topology.Neighborhoods | ∀ {X : Type u} [inst : TopologicalSpace X] {x : X} {p : X → Prop},
(∀ᶠ (y : X) in nhds x, p y) ↔ ∃ t, (∀ y ∈ t, p y) ∧ IsOpen t ∧ x ∈ t | true |
Lean.Meta.Grind.Arith.Cutsat.EqCnstrProof.subst | Lean.Meta.Tactic.Grind.Arith.Cutsat.Types | Int.Linear.Var →
Lean.Meta.Grind.Arith.Cutsat.EqCnstr →
Lean.Meta.Grind.Arith.Cutsat.EqCnstr → Lean.Meta.Grind.Arith.Cutsat.EqCnstrProof | true |
TopCat.ι₁_apply | Mathlib.Topology.Category.TopCat.Monoidal | ∀ {X : TopCat} (x : ↑X), (CategoryTheory.ConcreteCategory.hom TopCat.ι₁) x = (x, 1) | true |
Algebra.Presentation.mk.injEq | Mathlib.RingTheory.Extension.Presentation.Basic | ∀ {R : Type u} {S : Type v} {ι : Type w} {σ : Type t} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S]
(toGenerators : Algebra.Generators R S ι) (relation : σ → toGenerators.Ring)
(span_range_relation_eq_ker : Ideal.span (Set.range relation) = toGenerators.ker)
(toGenerators_1 : Algebra.Generators... | true |
SimpleGraph.not_cliqueFree_zero._simp_1 | Mathlib.Combinatorics.SimpleGraph.Clique | ∀ {α : Type u_1} {G : SimpleGraph α}, G.CliqueFree 0 = False | false |
LinearMap.isSymm_iff_eq_flip | Mathlib.LinearAlgebra.SesquilinearForm.Basic | ∀ {R : Type u_1} {M : Type u_5} [inst : CommSemiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
{B : LinearMap.BilinForm R M}, LinearMap.IsSymm B ↔ B = LinearMap.flip B | true |
Trunc.finChoiceEquiv | Mathlib.Data.Fintype.Quotient | {ι : Type u_1} → [DecidableEq ι] → [Fintype ι] → {α : ι → Sort u_2} → ((i : ι) → Trunc (α i)) ≃ Trunc ((i : ι) → α i) | true |
CategoryTheory.Abelian.Ext.comp_assoc_of_third_deg_zero | Mathlib.Algebra.Homology.DerivedCategory.Ext.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Abelian C]
[inst_2 : CategoryTheory.HasExt C] {X Y Z T : C} {a₁ a₂ a₁₂ : ℕ} (α : CategoryTheory.Abelian.Ext X Y a₁)
(β : CategoryTheory.Abelian.Ext Y Z a₂) (γ : CategoryTheory.Abelian.Ext Z T 0) (h₁₂ : a₁ + a₂ = a₁₂),
(α.comp β h₁₂)... | true |
CategoryTheory.Functor.precomp_map_heq | Mathlib.CategoryTheory.EqToHom | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
{E : Type u₃} [inst_2 : CategoryTheory.Category.{v₃, u₃} E] {F G : CategoryTheory.Functor C D}
(H : CategoryTheory.Functor E C),
(∀ {X Y : C} (f : X ⟶ Y), F.map f ≍ G.map f) → ∀ {X Y : E} (f : X... | true |
PerfectRing.lift_id_apply | Mathlib.FieldTheory.IsPerfectClosure | ∀ {K : Type u_1} {M : Type u_3} [inst : CommRing K] [inst_1 : CommRing M] (j : K →+* M) (p : ℕ) [inst_2 : ExpChar M p]
[inst_3 : ExpChar K p] [inst_4 : PerfectRing M p] (x : K), (PerfectRing.lift (RingHom.id K) j p) x = j x | true |
String.utf8EncodeChar_ne_nil._simp_1 | Init.Data.String.Defs | ∀ {c : Char}, (String.utf8EncodeChar c = []) = False | false |
CategoryTheory.ObjectProperty.IsTriangulatedClosed₁.mk | Mathlib.CategoryTheory.Triangulated.Subcategory | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroObject C]
[inst_2 : CategoryTheory.HasShift C ℤ] [inst_3 : CategoryTheory.Preadditive C]
[inst_4 : ∀ (n : ℤ), (CategoryTheory.shiftFunctor C n).Additive] [inst_5 : CategoryTheory.Pretriangulated C]
{P : CategoryT... | true |
Lean.Sym.Int16.lt_eq_false | Init.Sym.Lemmas | ∀ (a b : Int16), decide (a < b) = false → (a < b) = False | true |
CategoryTheory.IsCardinalFiltered.exists_cardinal_directed.DiagramWithUniqueTerminal | Mathlib.CategoryTheory.Presentable.Directed | (J : Type w) → [CategoryTheory.SmallCategory J] → Cardinal.{w} → Type w | true |
instCompleteLatticeUniformSpace._proof_3 | Mathlib.Topology.UniformSpace.Basic | ∀ {α : Type u_1} (x x_1 x_2 : UniformSpace α), x ≤ x_2 → x_1 ≤ x_2 → sInf {x_3 | x ≤ x_3 ∧ x_1 ≤ x_3} ≤ x_2 | false |
Batteries.UnionFind.push_parentD | Batteries.Data.UnionFind.Basic | ∀ {i : ℕ} (arr : Array Batteries.UFNode),
Batteries.UnionFind.parentD (arr.push { parent := arr.size, rank := 0 }) i = Batteries.UnionFind.parentD arr i | true |
CochainComplex.ConnectData.X_zero | Mathlib.Algebra.Homology.Embedding.Connect | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{K : ChainComplex C ℕ} {L : CochainComplex C ℕ}, CochainComplex.ConnectData.X K L 0 = L.X 0 | true |
Fin.subNat_zero | Init.Data.Fin.Lemmas | ∀ {n : ℕ} (i : Fin n) (h : 0 ≤ ↑i), Fin.subNat 0 i h = i | true |
Isocrystal.«_aux_Mathlib_RingTheory_WittVector_Isocrystal___delab_app_Isocrystal_term_≃ᶠˡ[_,_]__1» | Mathlib.RingTheory.WittVector.Isocrystal | Lean.PrettyPrinter.Delaborator.Delab | false |
Mathlib.Tactic.BicategoryLike.WhiskerLeft.nodes | Mathlib.Tactic.Widget.StringDiagram | ℕ → ℕ → ℕ → Mathlib.Tactic.BicategoryLike.WhiskerLeft → List Mathlib.Tactic.Widget.StringDiagram.Node | true |
CategoryTheory.ShiftedHom.opEquiv'_apply | Mathlib.CategoryTheory.Shift.ShiftedHomOpposite | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.HasShift C ℤ] {X Y : C} {a' : ℤ}
(f : CategoryTheory.ShiftedHom X Y a') (n a : ℤ) (h : n + a = a'),
(CategoryTheory.ShiftedHom.opEquiv' n a a' h) f =
(CategoryTheory.ShiftedHom.opEquiv n)
(CategoryTheory.CategoryStruct... | true |
SimpleGraph.Subgraph.mem_of_adj_spanningCoe | Mathlib.Combinatorics.SimpleGraph.Subgraph | ∀ {V : Type u} {v w : V} {s : Set V} (G : SimpleGraph ↑s), G.spanningCoe.Adj v w → v ∈ s | true |
Polynomial.coeff_natTrailingDegree_pred_eq_zero | Mathlib.Algebra.Polynomial.Degree.TrailingDegree | ∀ {R : Type u} [inst : Semiring R] {p : Polynomial R} {hp : 0 < ↑p.natTrailingDegree},
p.coeff (p.natTrailingDegree - 1) = 0 | true |
HomologicalComplex.unopInverse_obj | Mathlib.Algebra.Homology.Opposite | ∀ {ι : Type u_1} (V : Type u_2) [inst : CategoryTheory.Category.{v_1, u_2} V] (c : ComplexShape ι)
[inst_1 : CategoryTheory.Limits.HasZeroMorphisms V] (X : HomologicalComplex V c.symm),
(HomologicalComplex.unopInverse V c).obj X = Opposite.op X.opSymm | true |
CategoryTheory.Functor.commShiftUnop._proof_1 | Mathlib.CategoryTheory.Shift.Opposite | ∀ {C : Type u_1} {D : Type u_3} [inst : CategoryTheory.Category.{u_4, u_1} C]
[inst_1 : CategoryTheory.Category.{u_2, u_3} D] (A : Type u_5) [inst_2 : AddMonoid A]
[inst_3 : CategoryTheory.HasShift C A] [inst_4 : CategoryTheory.HasShift D A] (F : CategoryTheory.Functor C D)
[inst_5 : (CategoryTheory.OppositeShift... | false |
Mathlib.Explode.explodeCore._unsafe_rec | Mathlib.Tactic.Explode | (Lean.Expr → Lean.MetaM Bool) →
Bool →
Lean.Expr →
ℕ →
Mathlib.Explode.Entries →
optParam Bool false → Lean.MetaM (Option Mathlib.Explode.Entry × Mathlib.Explode.Entries) | false |
Lean.Elab.Tactic.focusAndDone | Lean.Elab.Tactic.Basic | {α : Type} → Lean.Elab.Tactic.TacticM α → Lean.Elab.Tactic.TacticM α | true |
Module.finite_of_finrank_pos | Mathlib.LinearAlgebra.Dimension.Free | ∀ {R : Type u} {M : Type v} [inst : Semiring R] [StrongRankCondition R] [inst_2 : AddCommMonoid M] [inst_3 : Module R M]
[Module.Free R M], 0 < Module.finrank R M → Module.Finite R M | true |
disjoint_nhdsSet_nhdsSet | Mathlib.Topology.Separation.Regular | ∀ {X : Type u_1} [inst : TopologicalSpace X] [NormalSpace X] {s t : Set X},
IsClosed s → IsClosed t → Disjoint s t → Disjoint (nhdsSet s) (nhdsSet t) | true |
CategoryTheory.presheafIsGeneratedBy_of_isFinite | Mathlib.CategoryTheory.Subfunctor.Finite | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (F : CategoryTheory.Functor Cᵒᵖ (Type w))
[inst_1 : CategoryTheory.PresheafIsFinite F],
CategoryTheory.PresheafIsGeneratedBy F CategoryTheory.Subfunctor.IsFinite.x | true |
_private.Mathlib.Data.Multiset.ZeroCons.0.Multiset.le_singleton._simp_1_4 | Mathlib.Data.Multiset.ZeroCons | ∀ {α : Type u_1} {a : α} {l : List α}, l.Perm [a] = (l = [a]) | false |
_private.Init.Data.List.Nat.TakeDrop.0.List.set_eq_take_append_cons_drop._proof_1_8 | Init.Data.List.Nat.TakeDrop | ∀ {α : Type u_1} {l : List α} {i : ℕ} (k : ℕ), ¬i + k + 1 = i + 1 + k → False | false |
MeasureTheory.measureReal_restrict_apply_self | Mathlib.MeasureTheory.Measure.Real | ∀ {α : Type u_1} {x : MeasurableSpace α} {μ : MeasureTheory.Measure α} (s : Set α), (μ.restrict s).real s = μ.real s | true |
Batteries.AssocList.modify | Batteries.Data.AssocList | {α : Type u_1} → {β : Type u_2} → [BEq α] → α → (α → β → β) → Batteries.AssocList α β → Batteries.AssocList α β | true |
Std.DHashMap.Raw.size_le_size_insert | Std.Data.DHashMap.RawLemmas | ∀ {α : Type u} {β : α → Type v} {m : Std.DHashMap.Raw α β} [inst : BEq α] [inst_1 : Hashable α] [EquivBEq α]
[LawfulHashable α], m.WF → ∀ {k : α} {v : β k}, m.size ≤ (m.insert k v).size | true |
AnalyticAt.continuousAt | Mathlib.Analysis.Analytic.Basic | ∀ {𝕜 : Type u_1} {E : Type u_2} {F : Type u_3} [inst : NontriviallyNormedField 𝕜] [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {f : E → F} {x : E},
AnalyticAt 𝕜 f x → ContinuousAt f x | true |
AddMonoidAlgebra.nonAssocRing._proof_4 | Mathlib.Algebra.MonoidAlgebra.Defs | ∀ {R : Type u_1} {M : Type u_2} [inst : Ring R] [inst_1 : AddZeroClass M] (a : AddMonoidAlgebra R M), a * 1 = a | false |
_private.Mathlib.Analysis.SpecialFunctions.ContinuousFunctionalCalculus.ExpLog.Basic.0.CFC.exp_log._proof_1_6 | Mathlib.Analysis.SpecialFunctions.ContinuousFunctionalCalculus.ExpLog.Basic | ∀ {A : Type u_1} [inst : NormedRing A] [inst_1 : NormedAlgebra ℝ A] [inst_2 : PartialOrder A] [NonnegSpectrumClass ℝ A]
(a : A), IsStrictlyPositive a → ∀ x ∈ spectrum ℝ a, Real.exp (Real.log x) = id x | false |
Complex.re_eq_ofReal_of_isSelfAdjoint | Mathlib.Analysis.Complex.Basic | ∀ {x : ℂ} {y : ℝ}, IsSelfAdjoint x → (x.re = y ↔ x = ↑y) | true |
AddUnits.isAddRegular | Mathlib.Algebra.Regular.Basic | ∀ {R : Type u_1} [inst : AddMonoid R] (a : AddUnits R), IsAddRegular ↑a | true |
Lean.Elab.Tactic.BVDecide.Frontend.Normalize.AndFlattenState.ctorIdx | Lean.Elab.Tactic.BVDecide.Frontend.Normalize.AndFlatten | Lean.Elab.Tactic.BVDecide.Frontend.Normalize.AndFlattenState → ℕ | false |
ModuleCon.mk.sizeOf_spec | Mathlib.Algebra.Module.Congruence.Defs | ∀ {S : Type u_2} {M : Type u_3} [inst : Add M] [inst_1 : SMul S M] [inst_2 : SizeOf S] [inst_3 : SizeOf M]
(toAddCon : AddCon M) (smul : ∀ (s : S) {x y : M}, toAddCon.toSetoid x y → toAddCon.toSetoid (s • x) (s • y)),
sizeOf { toAddCon := toAddCon, smul := smul } = 1 + sizeOf toAddCon | true |
CategoryTheory.GradedObject.hasTensor_of_iso | Mathlib.CategoryTheory.GradedObject.Monoidal | ∀ {I : Type u} [inst : AddMonoid I] {C : Type u_1} [inst_1 : CategoryTheory.Category.{v_1, u_1} C]
[inst_2 : CategoryTheory.MonoidalCategory C] {X₁ X₂ Y₁ Y₂ : CategoryTheory.GradedObject I C} (e₁ : X₁ ≅ Y₁)
(e₂ : X₂ ≅ Y₂) [X₁.HasTensor X₂], Y₁.HasTensor Y₂ | true |
CategoryTheory.nerve.δ₂_zero | Mathlib.AlgebraicTopology.SimplicialSet.Nerve | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (x : CategoryTheory.ComposableArrows C 2),
CategoryTheory.SimplicialObject.δ (CategoryTheory.nerve C) 0 x =
CategoryTheory.ComposableArrows.mk₁
(x.map' 1 2 CategoryTheory.nerve.δ₂_two._proof_4 CategoryTheory.nerve.δ₂_zero._proof_1) | true |
UniformEquiv.prodCongr._proof_1 | Mathlib.Topology.UniformSpace.Equiv | ∀ {α : Type u_1} {β : Type u_4} {γ : Type u_2} {δ : Type u_3} [inst : UniformSpace α] [inst_1 : UniformSpace β]
[inst_2 : UniformSpace γ] [inst_3 : UniformSpace δ] (h₁ : α ≃ᵤ β) (h₂ : γ ≃ᵤ δ),
UniformContinuous fun a => ((⇑h₁ ∘ fun p => p.1) a, h₂.toEquiv a.2) | false |
ComplexShape.Embedding.instIsTruncGEOpOfIsTruncLE | Mathlib.Algebra.Homology.Embedding.Basic | ∀ {ι : Type u_1} {ι' : Type u_2} {c : ComplexShape ι} {c' : ComplexShape ι'} (e : c.Embedding c') [e.IsTruncLE],
e.op.IsTruncGE | true |
LaurentSeries.RatFuncAdicCompl | Mathlib.RingTheory.LaurentSeries | (K : Type u_2) → [Field K] → Type u_2 | true |
Finpartition.restrict._proof_2 | Mathlib.Order.Partition.Finpartition | ∀ {α : Type u_1} [inst : DistribLattice α] [inst_1 : OrderBot α] [inst_2 : DecidableEq α] {a b : α}
(P : Finpartition a), ⊥ ∉ (Finset.image (fun x => x ⊓ b) P.parts).erase ⊥ | false |
TensorProduct.instStarRing | Mathlib.RingTheory.TensorProduct.Basic | {R : Type u_1} →
{A : Type u_2} →
{B : Type u_3} →
[inst : CommSemiring R] →
[inst_1 : NonUnitalNonAssocSemiring A] →
[inst_2 : NonUnitalNonAssocSemiring B] →
[inst_3 : Module R A] →
[inst_4 : Module R B] →
[inst_5 : SMulCommClass R A A] →
... | true |
Int32.ofIntLE_add | Init.Data.SInt.Lemmas | ∀ {a b : ℤ} {hab₁ : Int32.minValue.toInt ≤ a + b} {hab₂ : a + b ≤ Int32.maxValue.toInt},
Int32.ofIntLE (a + b) hab₁ hab₂ = Int32.ofInt a + Int32.ofInt b | true |
CategoryTheory.Functor.mapMonNatIso_inv_app_hom | Mathlib.CategoryTheory.Monoidal.Mon_ | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.MonoidalCategory C] {D : Type u₂}
[inst_2 : CategoryTheory.Category.{v₂, u₂} D] [inst_3 : CategoryTheory.MonoidalCategory D]
{F F' : CategoryTheory.Functor C D} [inst_4 : F.LaxMonoidal] [inst_5 : F'.LaxMonoidal] (e : F ≅ F')
[ins... | true |
CategoryTheory.Abelian.SpectralObject._sizeOf_1 | Mathlib.Algebra.Homology.SpectralObject.Basic | {C : Type u_1} →
{ι : Type u_2} →
{inst : CategoryTheory.Category.{u_3, u_1} C} →
{inst_1 : CategoryTheory.Category.{u_4, u_2} ι} →
{inst_2 : CategoryTheory.Abelian C} → [SizeOf C] → [SizeOf ι] → CategoryTheory.Abelian.SpectralObject C ι → ℕ | false |
IsBoundedLinearMap.snd | Mathlib.Analysis.Normed.Operator.BoundedLinearMaps | ∀ {𝕜 : Type u_1} {E : Type u_2} {F : Type u_3} [inst : Semiring 𝕜] [inst_1 : SeminormedAddCommGroup E]
[inst_2 : Module 𝕜 E] [inst_3 : SeminormedAddCommGroup F] [inst_4 : Module 𝕜 F], IsBoundedLinearMap 𝕜 fun x => x.2 | true |
IsUltrametricDist.closedBall_openSubgroup._proof_1 | Mathlib.Analysis.Normed.Group.Ultra | ∀ (S : Type u_1) [inst : SeminormedGroup S] {r : ℝ}, 0 < r → 1 ∈ Metric.closedBall 1 r | false |
CategoryTheory.Functor.IsLocalization.prod | Mathlib.CategoryTheory.Localization.Prod | ∀ {C₁ : Type u₁} {C₂ : Type u₂} {D₁ : Type u₃} {D₂ : Type u₄} [inst : CategoryTheory.Category.{v₁, u₁} C₁]
[inst_1 : CategoryTheory.Category.{v₂, u₂} C₂] [inst_2 : CategoryTheory.Category.{v₃, u₃} D₁]
[inst_3 : CategoryTheory.Category.{v₄, u₄} D₂] (L₁ : CategoryTheory.Functor C₁ D₁)
(W₁ : CategoryTheory.MorphismP... | true |
Lean.Grind.Nat.lo_eq_true_of_lo | Init.Grind.Offset | ∀ (u v k₁ k₂ : ℕ), Lean.Grind.isLE k₂ k₁ = true → u + k₁ ≤ v → (u + k₂ ≤ v) = True | true |
Algebra.Generators.CotangentSpace.compEquiv._proof_3 | Mathlib.RingTheory.Kaehler.JacobiZariski | ∀ {R : Type u_1} {S : Type u_5} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S] {T : Type u_4}
[inst_3 : CommRing T] [inst_4 : Algebra R T] [inst_5 : Algebra S T] [inst_6 : IsScalarTower R S T] {ι : Type u_2}
{σ : Type u_3} (Q : Algebra.Generators S T ι) (P : Algebra.Generators R S σ),
SMulCommCl... | false |
Ideal.Quotient.mkₐ_eq_mk | Mathlib.RingTheory.Ideal.Quotient.Operations | ∀ (R₁ : Type u_1) {A : Type u_3} [inst : CommSemiring R₁] [inst_1 : Ring A] [inst_2 : Algebra R₁ A] (I : Ideal A)
[inst_3 : I.IsTwoSided], ⇑(Ideal.Quotient.mkₐ R₁ I) = ⇑(Ideal.Quotient.mk I) | true |
AnalyticWithinAt.restrictScalars | Mathlib.Analysis.Analytic.Constructions | ∀ {𝕜 : Type u_2} [inst : NontriviallyNormedField 𝕜] {E : Type u_3} {F : Type u_4} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {𝕜' : Type u_9}
[inst_5 : NontriviallyNormedField 𝕜'] [inst_6 : NormedAlgebra 𝕜 𝕜'] [inst_7 : NormedSpace 𝕜... | true |
MeasureTheory.IsFundamentalDomain.lintegral_eq_tsum_of_ac | Mathlib.MeasureTheory.Group.FundamentalDomain | ∀ {G : Type u_1} {α : Type u_3} [inst : Group G] [inst_1 : MulAction G α] [inst_2 : MeasurableSpace α] {s : Set α}
{μ : MeasureTheory.Measure α} [MeasurableConstSMul G α] [MeasureTheory.SMulInvariantMeasure G α μ] [Countable G]
{ν : MeasureTheory.Measure α},
MeasureTheory.IsFundamentalDomain G s μ →
ν.Absolut... | true |
CategoryTheory.Square.unopFunctor._proof_9 | Mathlib.CategoryTheory.Square | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {X Y : (CategoryTheory.Square Cᵒᵖ)ᵒᵖ} (φ : X ⟶ Y),
CategoryTheory.CategoryStruct.comp (Opposite.unop X).unop.f₂₄ φ.unop.τ₁.unop =
CategoryTheory.CategoryStruct.comp φ.unop.τ₂.unop (Opposite.unop Y).unop.f₂₄ | false |
lipschitzWith_inv_iff._simp_2 | Mathlib.Analysis.Normed.Group.Uniform | ∀ {α : Type u_4} {E : Type u_5} [inst : SeminormedCommGroup E] [inst_1 : PseudoEMetricSpace α] {K : NNReal} {f : α → E},
LipschitzWith K f⁻¹ = LipschitzWith K f | false |
CategoryTheory.Subpresheaf.to_sheafify_lift_unique | Mathlib.CategoryTheory.Sites.Subsheaf | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {J : CategoryTheory.GrothendieckTopology C}
{F F' : CategoryTheory.Functor Cᵒᵖ (Type w)} (G : CategoryTheory.Subfunctor F),
CategoryTheory.Presieve.IsSheaf J F' →
∀ (l₁ l₂ : (CategoryTheory.Subfunctor.sheafify J G).toFunctor ⟶ F'),
CategoryTheory.Ca... | true |
TopologicalSpace.CompactOpens.instBooleanAlgebra._proof_3 | Mathlib.Topology.Sets.Compacts | ∀ {α : Type u_1} [inst : TopologicalSpace α] [inst_1 : CompactSpace α] [inst_2 : T2Space α]
(a : TopologicalSpace.CompactOpens α), a ≤ ⊤ | false |
Lean.PrettyPrinter.Formatter.State.leadWordIdent._default | Lean.PrettyPrinter.Formatter | Bool | false |
CategoryTheory.PreOneHypercover.IsStronglySeparatedFor.arrowsCompatible | Mathlib.CategoryTheory.Sites.Hypercover.SheafOfTypes | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {X : C} {E : CategoryTheory.PreOneHypercover X}
{F : CategoryTheory.Functor Cᵒᵖ (Type u_2)},
E.IsStronglySeparatedFor F →
∀ (x : (i : E.I₀) → F.obj (Opposite.op (E.X i))),
(∀ ⦃i j : E.I₀⦄ (k : E.I₁ i j), F.map (E.p₁ k).op (x i) = F.map (E.p₂ k... | true |
Subgroup.mem_zpowers_iff | Mathlib.Algebra.Group.Subgroup.ZPowers.Basic | ∀ {G : Type u_1} [inst : Group G] {g h : G}, h ∈ Subgroup.zpowers g ↔ ∃ k, g ^ k = h | true |
Equiv.arrayEquivList._proof_2 | Mathlib.Logic.Equiv.Array | ∀ (α : Type u_1), Function.RightInverse Array.mk Array.toList | false |
CategoryTheory.ObjectProperty.epiModSerre_iff | Mathlib.CategoryTheory.Abelian.SerreClass.MorphismProperty | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Abelian C]
(P : CategoryTheory.ObjectProperty C) [inst_2 : P.IsSerreClass] {X Y : C} (f : X ⟶ Y),
P.epiModSerre f ↔ P (CategoryTheory.Limits.cokernel f) | true |
ArchimedeanClass.instLinearOrderFiniteElement._aux_11 | Mathlib.Algebra.Order.Ring.StandardPart | (K : Type u_1) →
[inst : LinearOrder K] →
[inst_1 : Field K] →
[inst_2 : IsOrderedRing K] →
ArchimedeanClass.FiniteElement K → ArchimedeanClass.FiniteElement K → ArchimedeanClass.FiniteElement K | false |
_private.Mathlib.Analysis.Convex.Gauge.0.gauge_closure_zero.match_1_6 | Mathlib.Analysis.Convex.Gauge | ∀ {E : Type u_1} [inst : SeminormedAddCommGroup E] (x : E) (r : ℝ)
(motive : r ∈ {r | r ∈ Set.Ioi 0 ∧ (r = 0 ∨ ‖x‖ = 0)} → Prop) (x_1 : r ∈ {r | r ∈ Set.Ioi 0 ∧ (r = 0 ∨ ‖x‖ = 0)}),
(∀ (hr₀ : r ∈ Set.Ioi 0) (hr : r = 0 ∨ ‖x‖ = 0), motive ⋯) → motive x_1 | false |
Module.End.mem_submonoidCenter_iff | Mathlib.LinearAlgebra.FreeModule.Basic | ∀ {R : Type u_2} {M : Type u_3} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] [Module.Free R M]
{f : Module.End R M},
f ∈ Submonoid.center (Module.End R M) ↔ ∃ α, ∃ (hα : α ∈ Submonoid.center R), f = Module.End.smulLeft α hα | true |
CategoryTheory.ShortComplex.LeftHomologyData.mapLeftHomologyIso_eq | Mathlib.Algebra.Homology.ShortComplex.PreservesHomology | ∀ {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] [inst_2 : CategoryTheory.Limits.HasZeroMorphisms C]
[inst_3 : CategoryTheory.Limits.HasZeroMorphisms D] {S : CategoryTheory.ShortComplex C} (hl : S.LeftHomologyData)
(F : CategoryTheory.Fu... | true |
HNNExtension.NormalWord.ReducedWord.mk._flat_ctor | Mathlib.GroupTheory.HNNExtension | {G : Type u_1} →
[inst : Group G] →
{A B : Subgroup G} →
G →
(toList : List (ℤˣ × G)) →
List.IsChain (fun a b => a.2 ∈ HNNExtension.toSubgroup A B a.1 → a.1 = b.1) toList →
HNNExtension.NormalWord.ReducedWord G A B | false |
Submodule.restrictScalars_eq_top_iff._simp_1 | Mathlib.Algebra.Module.Submodule.RestrictScalars | ∀ (S : Type u_1) (R : Type u_2) (M : Type u_3) [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Semiring S]
[inst_3 : Module S M] [inst_4 : Module R M] [inst_5 : SMul S R] [inst_6 : IsScalarTower S R M] {p : Submodule R M},
(Submodule.restrictScalars S p = ⊤) = (p = ⊤) | false |
SimpleGraph.Iso.boxProdSumDistrib_toEquiv | Mathlib.Combinatorics.SimpleGraph.Prod | ∀ {V : Type u_4} {W₁ : Type u_8} {W₂ : Type u_9} (G : SimpleGraph V) (H₁ : SimpleGraph W₁) (H₂ : SimpleGraph W₂),
(SimpleGraph.Iso.boxProdSumDistrib G H₁ H₂).toEquiv = Equiv.prodSumDistrib V W₁ W₂ | true |
Lean.MessageData.ofWidget | Lean.Message | Lean.Widget.WidgetInstance → Lean.MessageData → Lean.MessageData | true |
Set.uIcc_self | Mathlib.Order.Interval.Set.UnorderedInterval | ∀ {α : Type u_1} [inst : Lattice α] {a : α}, Set.uIcc a a = {a} | true |
CategoryTheory.Bicategory.postcomposingCat | Mathlib.CategoryTheory.Bicategory.Yoneda | {B : Type u} →
[inst : CategoryTheory.Bicategory B] →
(a b c : B) → CategoryTheory.Functor (b ⟶ c) (CategoryTheory.Cat.of (a ⟶ b) ⟶ CategoryTheory.Cat.of (a ⟶ c)) | true |
DomMulAct.instDistribMulActionAEEqFun | Mathlib.MeasureTheory.Function.AEEqFun.DomAct | {M : Type u_1} →
{α : Type u_2} →
{β : Type u_3} →
[inst : MeasurableSpace α] →
{μ : MeasureTheory.Measure α} →
[inst_1 : TopologicalSpace β] →
[inst_2 : Monoid M] →
[inst_3 : MulAction M α] →
[MeasurableConstSMul M α] →
[MeasureT... | true |
LatticeHom.coe_snd | Mathlib.Order.Hom.Lattice | ∀ {α : Type u_2} {β : Type u_3} [inst : Lattice α] [inst_1 : Lattice β], ⇑LatticeHom.snd = Prod.snd | true |
IsOpenQuotientMap.baireSpace | Mathlib.Topology.Maps.OpenQuotient | ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] {f : X → Y} [BaireSpace X],
IsOpenQuotientMap f → BaireSpace Y | true |
OrderDual.instAddRightCancelMonoid.eq_1 | Mathlib.Algebra.Order.Group.Synonym | ∀ {α : Type u_1} [h : AddRightCancelMonoid α],
OrderDual.instAddRightCancelMonoid = { toAddMonoid := OrderDual.instAddMonoid, toIsRightCancelAdd := ⋯ } | true |
Std.Time.Timestamp.toMinutes | Std.Time.DateTime.Timestamp | Std.Time.Timestamp → Std.Time.Minute.Offset | true |
Lean.Grind.instSubIntIi | Init.GrindInstances.ToInt | Lean.Grind.ToInt.Sub ℤ Lean.Grind.IntInterval.ii | true |
AddCommGrpCat.leftExactFunctorForgetEquivalence.inverseAux.congr_simp | Mathlib.Algebra.Category.Grp.LeftExactFunctor | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Preadditive C]
[inst_2 : CategoryTheory.Limits.HasFiniteBiproducts C],
AddCommGrpCat.leftExactFunctorForgetEquivalence.inverseAux =
AddCommGrpCat.leftExactFunctorForgetEquivalence.inverseAux | true |
Fin.instCommRing._proof_9 | Mathlib.Data.ZMod.Defs | ∀ (n : ℕ) [inst : NeZero n] (a : Fin n), a * 1 = a | false |
OrderRingIso.subsingleton_left | Mathlib.Algebra.Order.Archimedean.Hom | ∀ {α : Type u_1} {β : Type u_2} [inst : Field α] [inst_1 : LinearOrder α] [inst_2 : Field β] [inst_3 : LinearOrder β]
[IsStrictOrderedRing α] [Archimedean α], Subsingleton (α ≃+*o β) | true |
SimpleGraph.completeMultipartiteGraph.not_cliqueFree_of_le_card | Mathlib.Combinatorics.SimpleGraph.Clique | ∀ {n : ℕ} {ι : Type u_3} (V : ι → Type u_4) [inst : Fintype ι] (f : (i : ι) → V i),
n ≤ Fintype.card ι → ¬(SimpleGraph.completeMultipartiteGraph V).CliqueFree n | true |
PresheafOfModules.Hom.mk.congr_simp | Mathlib.Algebra.Category.ModuleCat.Presheaf | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {R : CategoryTheory.Functor Cᵒᵖ RingCat}
{M₁ M₂ : PresheafOfModules R} (app app_1 : (X : Cᵒᵖ) → M₁.obj X ⟶ M₂.obj X) (e_app : app = app_1)
(naturality :
∀ {X Y : Cᵒᵖ} (f : X ⟶ Y),
CategoryTheory.CategoryStruct.comp (M₁.map f)
((ModuleCa... | true |
Lean.IR.collectUsedDecls | Lean.Compiler.IR.EmitUtil | Lean.Environment → List Lean.IR.Decl → Array Lean.Name | true |
Int.sub_emod_left | Init.Data.Int.DivMod.Lemmas | ∀ (a b : ℤ), (a - b) % a = -b % a | true |
Nat.Partrec.Code.primrec₂_pair | Mathlib.Computability.PartrecCode | Primrec₂ Nat.Partrec.Code.pair | true |
Submodule.iSup_induction | Mathlib.LinearAlgebra.Span.Basic | ∀ {R : Type u_1} {M : Type u_4} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] {ι : Sort u_8}
(p : ι → Submodule R M) {motive : M → Prop} {x : M},
x ∈ ⨆ i, p i →
(∀ (i : ι), ∀ x ∈ p i, motive x) → motive 0 → (∀ (x y : M), motive x → motive y → motive (x + y)) → motive x | true |
Vector.mem_unattach | Init.Data.Vector.Attach | ∀ {α : Type u_1} {n : ℕ} {p : α → Prop} {xs : Vector { x // p x } n} {a : α}, a ∈ xs.unattach ↔ ∃ (h : p a), ⟨a, h⟩ ∈ xs | true |
CategoryTheory.Pseudofunctor.mapComp_assoc_left_inv_assoc | Mathlib.CategoryTheory.Bicategory.Functor.Pseudofunctor | ∀ {B : Type u₁} [inst : CategoryTheory.Bicategory B] {C : Type u₂} [inst_1 : CategoryTheory.Bicategory C]
(F : CategoryTheory.Pseudofunctor B C) {a b c d : B} (f : a ⟶ b) (g : b ⟶ c) (h : c ⟶ d) {Z : F.obj a ⟶ F.obj d}
(h_1 : F.map (CategoryTheory.CategoryStruct.comp (CategoryTheory.CategoryStruct.comp f g) h) ⟶ Z)... | true |
RingEquiv.sumArrowEquivProdArrow._proof_2 | Mathlib.Algebra.Ring.Equiv | ∀ (α : Type u_1) (β : Type u_2) (R : Type u_3) [inst : NonAssocSemiring R] (x x_1 : α ⊕ β → R),
(Equiv.sumArrowEquivProdArrow α β R).toFun (x + x_1) = (Equiv.sumArrowEquivProdArrow α β R).toFun (x + x_1) | false |
_private.Mathlib.AlgebraicTopology.DoldKan.FunctorGamma.0.AlgebraicTopology.DoldKan.Γ₀.Obj.Termwise.mapMono_δ₀'._simp_1_2 | Mathlib.AlgebraicTopology.DoldKan.FunctorGamma | ∀ {M : Type u_4} [inst : AddMonoid M] [IsLeftCancelAdd M] {a b : M}, (a = a + b) = (b = 0) | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.