name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
Set.Iic.coe_inf._simp_1 | Mathlib.Order.LatticeIntervals | ∀ {α : Type u_1} {a : α} [inst : SemilatticeInf α] {x y : ↑(Set.Iic a)}, ↑x ⊓ ↑y = ↑(x ⊓ y) | false |
MonadState.rec | Init.Prelude | {σ : Type u} →
{m : Type u → Type v} →
{motive : MonadState σ m → Sort u_1} →
((get : m σ) →
(set : σ → m PUnit.{u + 1}) →
(modifyGet : {α : Type u} → (σ → α × σ) → m α) →
motive { get := get, set := set, modifyGet := modifyGet }) →
(t : MonadState σ m) → motive t | false |
CategoryTheory.ShortComplex.Homotopy.g_h₃ | Mathlib.Algebra.Homology.ShortComplex.Preadditive | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Preadditive C]
{S₁ S₂ : CategoryTheory.ShortComplex C} {φ₁ φ₂ : S₁ ⟶ S₂} (self : CategoryTheory.ShortComplex.Homotopy φ₁ φ₂),
CategoryTheory.CategoryStruct.comp S₁.g self.h₃ = 0 | true |
PrimeSpectrum.isJacobsonRing_iff_jacobsonSpace | Mathlib.RingTheory.Spectrum.Prime.Jacobson | ∀ {R : Type u_1} [inst : CommRing R], IsJacobsonRing R ↔ JacobsonSpace (PrimeSpectrum R) | true |
TensorProduct.gradedComm_of_zero_tmul | Mathlib.LinearAlgebra.TensorProduct.Graded.External | ∀ (R : Type u_1) {ι : Type u_2} [inst : CommSemiring ι] [inst_1 : Module ι (Additive ℤˣ)] [inst_2 : DecidableEq ι]
(𝒜 : ι → Type u_3) (ℬ : ι → Type u_4) [inst_3 : CommRing R] [inst_4 : (i : ι) → AddCommGroup (𝒜 i)]
[inst_5 : (i : ι) → AddCommGroup (ℬ i)] [inst_6 : (i : ι) → Module R (𝒜 i)] [inst_7 : (i : ι) → Mo... | true |
Lean.Doc.Parser.definitionList | Lean.DocString.Parser | Lean.Doc.Parser.BlockCtxt → Lean.Parser.ParserFn | true |
_private.Lean.Elab.DocString.Builtin.0.Lean.Doc.highlightSyntax.go | Lean.Elab.DocString.Builtin | {m : Type → Type u_1} →
[Monad m] → [MonadLiftT IO m] → Lean.PersistentArray Lean.Elab.InfoTree → Lean.Syntax → StateT Lean.Doc.DocCode m Unit | true |
Rep.indCoindNatIso_hom_app | Mathlib.RepresentationTheory.FiniteIndex | ∀ (k : Type u) {G : Type v} [inst : CommRing k] [inst_1 : Group G] (S : Subgroup G)
[inst_2 : DecidableRel ⇑(QuotientGroup.rightRel S)] [inst_3 : S.FiniteIndex] (X : Rep.{max u w, u, v} k ↥S),
(Rep.indCoindNatIso k S).hom.app X = X.indCoindIso.hom | true |
Algebra.Presentation.instCore._aux_1 | Mathlib.RingTheory.Extension.Presentation.Core | {R : Type u_1} →
{S : Type u_2} →
{ι : Type u_3} →
{σ : Type u_4} →
[inst : CommRing R] →
[inst_1 : CommRing S] → [inst_2 : Algebra R S] → {P : Algebra.Presentation R S ι σ} → P.Core → R → R | false |
IccRightChart.eq_1 | Mathlib.Geometry.Manifold.Instances.Real | ∀ (x y : ℝ) [h : Fact (x < y)],
IccRightChart x y =
{ toFun := fun z => ⟨WithLp.toLp 2 fun x_1 => y - ↑z, ⋯⟩, invFun := fun z => ⟨max (y - (↑z).ofLp 0) x, ⋯⟩,
source := {z | x < ↑z}, target := {z | (↑z).ofLp 0 < y - x}, map_source' := ⋯, map_target' := ⋯, left_inv' := ⋯,
right_inv' := ⋯, open_source :... | true |
_private.Lean.Data.KVMap.0.Lean.KVMap.getNat.match_1 | Lean.Data.KVMap | (motive : Option Lean.DataValue → Sort u_1) →
(x : Option Lean.DataValue) →
((v : ℕ) → motive (some (Lean.DataValue.ofNat v))) → ((x : Option Lean.DataValue) → motive x) → motive x | false |
Lean.Elab.WF.GuessLex.RecCallWithContext.mk.sizeOf_spec | Lean.Elab.PreDefinition.WF.GuessLex | ∀ (ref : Lean.Syntax) (caller : ℕ) (params : Array Lean.Expr) (callee : ℕ) (args : Array Lean.Expr)
(ctxt : Lean.Elab.WF.GuessLex.SavedLocalContext),
sizeOf { ref := ref, caller := caller, params := params, callee := callee, args := args, ctxt := ctxt } =
1 + sizeOf ref + sizeOf caller + sizeOf params + sizeOf ... | true |
DFinsupp.eraseAddHom_apply | Mathlib.Data.DFinsupp.Defs | ∀ {ι : Type u} (β : ι → Type v) [inst : DecidableEq ι] [inst_1 : (i : ι) → AddZeroClass (β i)] (i : ι)
(x : Π₀ (i : ι), β i), (DFinsupp.eraseAddHom β i) x = DFinsupp.erase i x | true |
_private.Std.Data.DTreeMap.Internal.Balancing.0.Std.DTreeMap.Internal.Impl.balanceLErase._proof_13 | Std.Data.DTreeMap.Internal.Balancing | ∀ {α : Type u_1} {β : α → Type u_2} (rs : ℕ) (k : α) (v : β k) (l r : Std.DTreeMap.Internal.Impl α β),
(Std.DTreeMap.Internal.Impl.inner rs k v l r).Balanced →
∀ (ls : ℕ) (lk : α) (lv : β lk),
Std.DTreeMap.Internal.delta * rs < ls →
∀ (x : Std.DTreeMap.Internal.Impl α β),
(Std.DTreeMap.Int... | false |
max_add_add_right | Mathlib.Algebra.Order.Monoid.Unbundled.MinMax | ∀ {α : Type u_1} [inst : LinearOrder α] [inst_1 : Add α] [AddRightMono α] (a b c : α), max (a + c) (b + c) = max a b + c | true |
MulOpposite.instMulActionWithZero._proof_2 | Mathlib.Algebra.GroupWithZero.Action.Opposite | ∀ {M : Type u_2} {α : Type u_1} [inst : MonoidWithZero M] [inst_1 : AddMonoid α] [inst_2 : MulActionWithZero M α]
(x : αᵐᵒᵖ), 0 • x = 0 | false |
Affine.Simplex.mongePoint_eq_smul_vsub_vadd_circumcenter | Mathlib.Geometry.Euclidean.MongePoint | ∀ {V : Type u_1} {P : Type u_2} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V] [inst_2 : MetricSpace P]
[inst_3 : NormedAddTorsor V P] {n : ℕ} (s : Affine.Simplex ℝ P n),
s.mongePoint = (↑(n + 1) / ↑(n - 1)) • (Finset.centroid ℝ Finset.univ s.points -ᵥ s.circumcenter) +ᵥ s.circumcenter | true |
_private.Mathlib.Topology.Homotopy.Product.0.Path.Homotopic.comp_prod_eq_prod_comp._simp_1_1 | Mathlib.Topology.Homotopy.Product | ∀ {X : Type u} [inst : TopologicalSpace X] {x₀ x₁ x₂ : X} (P₀ : Path x₀ x₁) (P₁ : Path x₁ x₂),
(Path.Homotopic.Quotient.mk P₀).trans (Path.Homotopic.Quotient.mk P₁) = Path.Homotopic.Quotient.mk (P₀.trans P₁) | false |
CommAlgCat.isoMk._proof_2 | Mathlib.Algebra.Category.CommAlgCat.Basic | ∀ {R : Type u_2} [inst : CommRing R] {X Y : Type u_1} {x : CommRing X} {x_1 : CommRing Y} {x_2 : Algebra R X}
{x_3 : Algebra R Y} (e : X ≃ₐ[R] Y),
CategoryTheory.CategoryStruct.comp (CommAlgCat.ofHom ↑e) (CommAlgCat.ofHom ↑e.symm) =
CategoryTheory.CategoryStruct.id (CommAlgCat.of R X) | false |
AddMonoidAlgebra.mapAlgHom_apply | Mathlib.Algebra.MonoidAlgebra.Basic | ∀ {R : Type u_1} {A : Type u_4} {B : Type u_5} {M : Type u_7} [inst : CommSemiring R] [inst_1 : Semiring A]
[inst_2 : Semiring B] [inst_3 : Algebra R A] [inst_4 : Algebra R B] [inst_5 : AddMonoid M] (f : A →ₐ[R] B)
(x : AddMonoidAlgebra A M) (m : M), ((AddMonoidAlgebra.mapAlgHom M f) x) m = f (x m) | true |
unitarySubgroupUnitsEquiv._proof_9 | Mathlib.Algebra.Star.Unitary | ∀ {M : Type u_1} [inst : Monoid M] [inst_1 : StarMul M] (x : ↥(unitary M)),
star ↑↑⟨{ val := ↑x, inv := star ↑x, val_inv := ⋯, inv_val := ⋯ }, ⋯⟩ *
↑↑⟨{ val := ↑x, inv := star ↑x, val_inv := ⋯, inv_val := ⋯ }, ⋯⟩ =
1 ∧
↑↑⟨{ val := ↑x, inv := star ↑x, val_inv := ⋯, inv_val := ⋯ }, ⋯⟩ *
star ↑... | false |
TopologicalSpace.exists_countable_basis | Mathlib.Topology.Bases | ∀ (α : Type u) [t : TopologicalSpace α] [SecondCountableTopology α],
∃ b, b.Countable ∧ ∅ ∉ b ∧ TopologicalSpace.IsTopologicalBasis b | true |
_private.Batteries.Data.AssocList.0.cond.match_1.eq_1 | Batteries.Data.AssocList | ∀ (motive : Bool → Sort u_1) (h_1 : Unit → motive true) (h_2 : Unit → motive false),
(match true with
| true => h_1 ()
| false => h_2 ()) =
h_1 () | true |
MvPowerSeries.aeval._proof_1 | Mathlib.RingTheory.MvPowerSeries.Evaluation | ∀ {R : Type u_1} [inst : CommRing R] [inst_1 : UniformSpace R] {S : Type u_2} [inst_2 : CommRing S]
[inst_3 : UniformSpace S] [inst_4 : Algebra R S] [ContinuousSMul R S], Continuous ⇑(algebraMap R S) | false |
additive_of_symmetric_of_isTotal | Mathlib.Algebra.Group.Basic | ∀ {α : Type u_1} {β : Type u_2} [inst : AddMonoid β] (p r : α → α → Prop) [Std.Total r] (f : α → α → β),
Symmetric p →
(∀ {a b : α}, p a b → f a b + f b a = 0) →
(∀ {a b c : α}, r a b → r b c → p a b → p b c → p a c → f a c = f a b + f b c) →
∀ {a b c : α}, p a b → p b c → p a c → f a c = f a b + f ... | true |
Set.sups_inter_subset_left | Mathlib.Data.Set.Sups | ∀ {α : Type u_2} [inst : SemilatticeSup α] {s₁ s₂ t : Set α}, (s₁ ∩ s₂) ⊻ t ⊆ s₁ ⊻ t ∩ s₂ ⊻ t | true |
Filter.principal_eq_iff_eq._simp_1 | Mathlib.Order.Filter.Basic | ∀ {α : Type u} {s t : Set α}, (Filter.principal s = Filter.principal t) = (s = t) | false |
_private.Mathlib.Geometry.Euclidean.Angle.Oriented.Affine.0.EuclideanGeometry.collinear_iff_of_two_zsmul_oangle_eq._simp_1_1 | Mathlib.Geometry.Euclidean.Angle.Oriented.Affine | ∀ {V : Type u_1} {P : Type u_2} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V] [inst_2 : MetricSpace P]
[inst_3 : NormedAddTorsor V P] [hd2 : Fact (Module.finrank ℝ V = 2)] [inst_4 : Module.Oriented ℝ V (Fin 2)]
{p₁ p₂ p₃ : P},
Collinear ℝ {p₁, p₂, p₃} = (EuclideanGeometry.oangle p₁ p₂ p₃ = 0 ∨ Eu... | false |
Aesop.instToStringPremiseIndex | Aesop.Forward.PremiseIndex | ToString Aesop.PremiseIndex | true |
_private.Batteries.Data.List.Lemmas.0.List.getElem_getElem_findIdxs_sub._proof_1_7 | Batteries.Data.List.Lemmas | ∀ {i : ℕ} {α : Type u_1} {xs : List α} {p : α → Bool} (s : ℕ),
i < (List.findIdxs p xs s).length → ∀ (_x_1 : i < (List.filter p xs).length), p (List.filter p xs)[i] = true | false |
Lean.Doc.Parser.BlockCtxt.mk.inj | Lean.DocString.Parser | ∀ {minIndent : ℕ} {maxDirective : Option ℕ} {inLists : List Lean.Doc.Parser.InList} {docStartPosition : Lean.Position}
{baseColumn minIndent_1 : ℕ} {maxDirective_1 : Option ℕ} {inLists_1 : List Lean.Doc.Parser.InList}
{docStartPosition_1 : Lean.Position} {baseColumn_1 : ℕ},
{ minIndent := minIndent, maxDirective ... | true |
Lean.Lsp.Ipc.ModuleHierarchy._sizeOf_3_eq | Lean.Data.Lsp.Ipc | ∀ (x : List Lean.Lsp.Ipc.ModuleHierarchy), Lean.Lsp.Ipc.ModuleHierarchy._sizeOf_3 x = sizeOf x | false |
PNat.XgcdType.reduce.eq_def | Mathlib.Data.PNat.Xgcd | ∀ (u : PNat.XgcdType), u.reduce = if x : u.r = 0 then u.finish else u.step.reduce.flip | true |
Lean.Order.instCCPOEIOOfNonempty._proof_6 | Init.Internal.Order.Basic | ∀ {ε α : Type} [inst : Nonempty ε] {c : EIO ε α → Prop}, Lean.Order.chain c → Exists (Lean.Order.is_sup c) | false |
Finset.compls_compls | Mathlib.Data.Finset.Sups | ∀ {α : Type u_2} [inst : BooleanAlgebra α] (s : Finset α), s.compls.compls = s | true |
List.isChain_findIdxs._simp_1 | Batteries.Data.List.Lemmas | ∀ {α : Type u_1} {xs : List α} {p : α → Bool} {s : ℕ}, List.IsChain (fun x1 x2 => x1 < x2) (List.findIdxs p xs s) = True | false |
CategoryTheory.Bicategory.HasAbsLeftKanExtension.toHasLeftKanExtension | Mathlib.CategoryTheory.Bicategory.Kan.HasKan | ∀ {B : Type u} {inst : CategoryTheory.Bicategory B} {a b c : B} {f : a ⟶ b} {g : a ⟶ c}
[self : CategoryTheory.Bicategory.HasAbsLeftKanExtension f g], CategoryTheory.Bicategory.HasLeftKanExtension f g | true |
MeasureTheory.measure_integral_le_pos | Mathlib.MeasureTheory.Integral.Average | ∀ {α : Type u_1} {m0 : MeasurableSpace α} {μ : MeasureTheory.Measure α} {f : α → ℝ}
[MeasureTheory.IsProbabilityMeasure μ], MeasureTheory.Integrable f μ → 0 < μ {x | ∫ (a : α), f a ∂μ ≤ f x} | true |
compact_basis_nhds | Mathlib.Topology.Compactness.LocallyCompact | ∀ {X : Type u_1} [inst : TopologicalSpace X] [LocallyCompactSpace X] (x : X),
(nhds x).HasBasis (fun s => s ∈ nhds x ∧ IsCompact s) fun s => s | true |
IsArtinian.range_smul_pow_stabilizes | Mathlib.RingTheory.Artinian.Module | ∀ {R : Type u_1} (M : Type u_2) [inst : CommSemiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
[IsArtinian R M] (r : R), ∃ n, ∀ (m : ℕ), n ≤ m → (r ^ n • LinearMap.id).range = (r ^ m • LinearMap.id).range | true |
finsum_cond_eq_sum_of_cond_iff | Mathlib.Algebra.BigOperators.Finprod | ∀ {α : Type u_1} {M : Type u_5} [inst : AddCommMonoid M] (f : α → M) {p : α → Prop} {t : Finset α},
(∀ {x : α}, f x ≠ 0 → (p x ↔ x ∈ t)) → ∑ᶠ (i : α) (_ : p i), f i = ∑ i ∈ t, f i | true |
_private.Init.Data.String.Lemmas.Pattern.Split.0.String.Slice.Pattern.Model.splitFromSteps.eq_1 | Init.Data.String.Lemmas.Pattern.Split | ∀ {s : String.Slice} (currPos : s.Pos), String.Slice.Pattern.Model.splitFromSteps✝ currPos [] = [s.subsliceFrom currPos] | true |
_private.Std.Tactic.BVDecide.LRAT.Internal.Formula.Lemmas.0.Std.Tactic.BVDecide.LRAT.Internal.DefaultFormula.readyForRupAdd_ofArray._proof_1_18 | Std.Tactic.BVDecide.LRAT.Internal.Formula.Lemmas | ∀ {n : ℕ} (c : Std.Tactic.BVDecide.LRAT.Internal.DefaultClause n) (l : Std.Tactic.BVDecide.LRAT.Internal.PosFin n),
c.clause = [(l, true)] →
∀ (l_1 : Std.Tactic.BVDecide.LRAT.Internal.PosFin n), (l_1, true) ∉ [(l, true)] ∨ (l_1, false) ∉ [(l, true)] | false |
Ordinal.bot_eq_zero | Mathlib.SetTheory.Ordinal.Basic | ⊥ = 0 | true |
MvQPF.Prj | Mathlib.Data.QPF.Multivariate.Constructions.Prj | {n : ℕ} → Fin2 n → TypeVec.{u} n → Type u | true |
and_false | Init.SimpLemmas | ∀ (p : Prop), (p ∧ False) = False | true |
OfNat.ofNat | Init.Prelude | {α : Type u} → (x : ℕ) → [self : OfNat α x] → α | true |
ComplexShape.Embedding.IsTruncLE.mk | Mathlib.Algebra.Homology.Embedding.Basic | ∀ {ι : Type u_1} {ι' : Type u_2} {c : ComplexShape ι} {c' : ComplexShape ι'} {e : c.Embedding c'}
[toIsRelIff : e.IsRelIff], (∀ {i' : ι'} {j : ι}, c'.Rel i' (e.f j) → ∃ i, e.f i = i') → e.IsTruncLE | true |
String.Pos.Raw.increaseBy_zero | Init.Data.String.PosRaw | ∀ {p : String.Pos.Raw}, p.increaseBy 0 = p | true |
Std.ExtDHashMap.contains_ofList | Std.Data.ExtDHashMap.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {β : α → Type v} [inst : EquivBEq α] [inst_1 : LawfulHashable α]
{l : List ((a : α) × β a)} {k : α}, (Std.ExtDHashMap.ofList l).contains k = (List.map Sigma.fst l).contains k | true |
cfcₙ_smul_id | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.NonUnital | ∀ {R : Type u_1} {A : Type u_2} {p : A → Prop} [inst : CommSemiring R] [inst_1 : Nontrivial R] [inst_2 : StarRing R]
[inst_3 : MetricSpace R] [inst_4 : IsTopologicalSemiring R] [inst_5 : ContinuousStar R] [inst_6 : NonUnitalRing A]
[inst_7 : StarRing A] [inst_8 : TopologicalSpace A] [inst_9 : Module R A] [inst_10 :... | true |
CategoryTheory.MorphismProperty.instComonObjWideSubcategoryOfIsStableUnderComonoidObj._proof_5 | Mathlib.CategoryTheory.CopyDiscardCategory.Widesubcategory | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] (P : CategoryTheory.MorphismProperty C)
[inst_1 : CategoryTheory.MonoidalCategory C] [inst_2 : P.IsMonoidalStable] (c : CategoryTheory.WideSubcategory P)
[inst_3 : CategoryTheory.ComonObj c.obj] [P.IsStableUnderComonoid c.obj], P CategoryTheory.ComonObj... | false |
Subalgebra.rTensorBot_tmul | Mathlib.LinearAlgebra.TensorProduct.Subalgebra | ∀ {R : Type u_1} {S : Type u_2} [inst : CommSemiring R] [inst_1 : Semiring S] [inst_2 : Algebra R S]
{A : Subalgebra R S} (x : R) (a : ↥A), A.rTensorBot (a ⊗ₜ[R] (algebraMap R ↥⊥) x) = x • a | true |
SummationFilter.NeBot.mk | Mathlib.Topology.Algebra.InfiniteSum.SummationFilter | ∀ {β : Type u_2} {L : SummationFilter β}, L.filter.NeBot → L.NeBot | true |
_private.Lean.Elab.Tactic.Conv.Congr.0.Lean.Elab.Tactic.Conv.mkCongrThm.match_3 | Lean.Elab.Tactic.Conv.Congr | (motive : Lean.Meta.CongrArgKind → Sort u_1) →
(x : Lean.Meta.CongrArgKind) →
(Unit → motive Lean.Meta.CongrArgKind.fixed) →
(Unit → motive Lean.Meta.CongrArgKind.cast) →
(Unit → motive Lean.Meta.CongrArgKind.eq) →
(Unit → motive Lean.Meta.CongrArgKind.subsingletonInst) →
(Unit... | false |
_private.Mathlib.Tactic.NormNum.IsSquare.0.Mathlib.Meta.NormNum.iff_isSquare_int_of_isNat._simp_1_1 | Mathlib.Tactic.NormNum.IsSquare | ∀ {n : ℕ}, IsSquare ↑n = IsSquare n | false |
_private.Mathlib.GroupTheory.SpecificGroups.Alternating.MaximalSubgroups.0.alternatingGroup.isCoatom_stabilizer_of_ncard_lt_ncard_compl._proof_1_7 | Mathlib.GroupTheory.SpecificGroups.Alternating.MaximalSubgroups | ∀ {α : Type u_1} {s : Set α},
s.ncard < sᶜ.ncard → s.ncard + sᶜ.ncard = Nat.card α → 4 < Nat.card α → s.ncard + 1 ≤ Nat.card α - 2 | false |
CategoryTheory.CostructuredArrow.toOverCompYonedaColimit._proof_5 | Mathlib.CategoryTheory.Comma.Presheaf.Colimit | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {J : Type u_1} [inst_1 : CategoryTheory.SmallCategory J]
{A : CategoryTheory.Functor Cᵒᵖ (Type u_1)} (F : CategoryTheory.Functor J (CategoryTheory.Over A)),
CategoryTheory.Limits.HasColimit (F.comp (CategoryTheory.overEquivPresheafCostructuredArrow A).f... | false |
Std.DTreeMap.Raw.values.eq_1 | Std.Data.DTreeMap.Raw.Iterator | ∀ {α : Type u} {cmp : α → α → Ordering} {β : Type v} (t : Std.DTreeMap.Raw α (fun x => β) cmp),
t.values = t.inner.values | true |
Finset.preimage_inter | Mathlib.Data.Finset.Preimage | ∀ {α : Type u} {β : Type v} [inst : DecidableEq α] [inst_1 : DecidableEq β] {f : α → β} {s t : Finset β}
(hs : Set.InjOn f (f ⁻¹' ↑s)) (ht : Set.InjOn f (f ⁻¹' ↑t)), (s ∩ t).preimage f ⋯ = s.preimage f hs ∩ t.preimage f ht | true |
_private.Mathlib.Computability.TuringMachine.ToPartrec.0.Turing.PartrecToTM2.supports_union._simp_1_3 | Mathlib.Computability.TuringMachine.ToPartrec | ∀ {α : Sort u_1} {p q : α → Prop}, (∀ (x : α), p x ∧ q x) = ((∀ (x : α), p x) ∧ ∀ (x : α), q x) | false |
CategoryTheory.ComposableArrows.threeδ₂Toδ₁._proof_2 | Mathlib.CategoryTheory.ComposableArrows.Three | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {i j k l : C} (f₁ : i ⟶ j) (f₂ : j ⟶ k) (f₃ : k ⟶ l)
(f₁₂ : i ⟶ k) (f₂₃ : j ⟶ l),
CategoryTheory.CategoryStruct.comp f₁ f₂ = f₁₂ →
CategoryTheory.CategoryStruct.comp f₂ f₃ = f₂₃ →
CategoryTheory.CategoryStruct.comp
((CategoryTheory.C... | false |
SimpleGraph.IsContained | Mathlib.Combinatorics.SimpleGraph.Copy | {α : Type u_4} → {β : Type u_5} → SimpleGraph α → SimpleGraph β → Prop | true |
isOpen_implies_isOpen_iff | Mathlib.Topology.Order | ∀ {α : Type u_1} {t₁ t₂ : TopologicalSpace α}, (∀ (s : Set α), IsOpen s → IsOpen s) ↔ t₂ ≤ t₁ | true |
CategoryTheory.Adjunction.adjunctionOfEquivLeft | Mathlib.CategoryTheory.Adjunction.Basic | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{D : Type u₂} →
[inst_1 : CategoryTheory.Category.{v₂, u₂} D] →
{G : CategoryTheory.Functor D C} →
{F_obj : C → D} →
(e : (X : C) → (Y : D) → (F_obj X ⟶ Y) ≃ (X ⟶ G.obj Y)) →
(he :
∀ (... | true |
_private.Mathlib.Algebra.GroupWithZero.Basic.0.exists_isNilpotent_of_not_isReduced._simp_1_2 | Mathlib.Algebra.GroupWithZero.Basic | ∀ {α : Sort u_1} {p : α → Prop}, (¬∀ (x : α), p x) = ∃ x, ¬p x | false |
CategoryTheory.WideSubcategory.instMonoidalCategory._proof_1 | Mathlib.CategoryTheory.Monoidal.Widesubcategory | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] (P : CategoryTheory.MorphismProperty C)
[inst_1 : CategoryTheory.MonoidalCategory C] [inst_2 : P.IsMonoidalStable],
(CategoryTheory.wideSubcategoryInclusion P).Faithful | false |
Std.Iterators.Types.ULiftIterator.mk.noConfusion | Init.Data.Iterators.Combinators.Monadic.ULift | {α : Type u} →
{m : Type u → Type u'} →
{n : Type (max u v) → Type v'} →
{β : Type u} →
{lift : ⦃γ : Type u⦄ → m γ → Std.Iterators.ULiftT n γ} →
{P : Sort u_1} →
{inner inner' : Std.IterM m β} → { inner := inner } = { inner := inner' } → (inner ≍ inner' → P) → P | false |
AddCommute | Mathlib.Algebra.Group.Commute.Defs | {S : Type u_3} → [Add S] → S → S → Prop | true |
Complex.arg_mul_cos_add_sin_mul_I | Mathlib.Analysis.SpecialFunctions.Complex.Arg | ∀ {r : ℝ},
0 < r → ∀ {θ : ℝ}, θ ∈ Set.Ioc (-Real.pi) Real.pi → (↑r * (Complex.cos ↑θ + Complex.sin ↑θ * Complex.I)).arg = θ | true |
CategoryTheory.Limits.Types.binaryCoproductIso | Mathlib.CategoryTheory.Limits.Types.Coproducts | (X Y : Type u) → X ⨿ Y ≅ X ⊕ Y | true |
MulAut.instGroup._proof_8 | Mathlib.Algebra.Group.End | ∀ (M : Type u_1) [inst : Mul M] (x : MulAut M), 1 * x = 1 * x | false |
Lean.instToMessageDataLevel | Lean.Message | Lean.ToMessageData Lean.Level | true |
Circle.toUnits_apply | Mathlib.Analysis.Complex.Circle | ∀ (z : Circle), Circle.toUnits z = Units.mk0 ↑z ⋯ | true |
_private.Mathlib.Topology.Sequences.0.IsSeqCompact.isComplete._simp_1_4 | Mathlib.Topology.Sequences | ∀ {α : Type u} {s t r : Set α}, (r ⊆ s ∩ t) = (r ⊆ s ∧ r ⊆ t) | false |
_private.Mathlib.Data.Set.Lattice.Image.0.Set.image2_iInter_subset_left._simp_1_1 | Mathlib.Data.Set.Lattice.Image | ∀ {α : Type u_1} {β : Type u_3} {γ : Type u_5} {f : α → β → γ} {s : Set α} {t : Set β} {u : Set γ},
(Set.image2 f s t ⊆ u) = ∀ x ∈ s, ∀ y ∈ t, f x y ∈ u | false |
UInt16.toInt16_add | Init.Data.SInt.Lemmas | ∀ (a b : UInt16), (a + b).toInt16 = a.toInt16 + b.toInt16 | true |
Std.DHashMap.getKey!_filterMap | Std.Data.DHashMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {x : BEq α} {x_1 : Hashable α} {m : Std.DHashMap α β} {γ : α → Type w}
[inst : LawfulBEq α] [inst_1 : Inhabited α] {f : (a : α) → β a → Option (γ a)} {k : α},
(Std.DHashMap.filterMap f m).getKey! k = ((m.getKey? k).pfilter fun x_2 h' => (f x_2 (m.get x_2 ⋯)).isSome).get! | true |
Lean.Parser.Tactic.Conv.«_aux_Init_Conv___macroRules_Lean_Parser_Tactic_Conv_convNext__=>__1» | Init.Conv | Lean.Macro | false |
Finset.inf_disjSum | Mathlib.Data.Finset.Lattice.Fold | ∀ {α : Type u_2} {β : Type u_3} {γ : Type u_4} [inst : SemilatticeInf α] [inst_1 : OrderTop α] (s : Finset β)
(t : Finset γ) (f : β ⊕ γ → α), (s.disjSum t).inf f = (s.inf fun x => f (Sum.inl x)) ⊓ t.inf fun x => f (Sum.inr x) | true |
HomologicalComplex.iCycles_d_assoc | Mathlib.Algebra.Homology.ShortComplex.HomologicalComplex | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{ι : Type u_2} {c : ComplexShape ι} (K : HomologicalComplex C c) (i j : ι) [inst_2 : K.HasHomology i] {Z : C}
(h : K.X j ⟶ Z),
CategoryTheory.CategoryStruct.comp (K.iCycles i) (CategoryTheory.Categor... | true |
Equiv.Perm.cycleOf_apply_of_not_sameCycle | Mathlib.GroupTheory.Perm.Cycle.Factors | ∀ {α : Type u_2} {f : Equiv.Perm α} {x y : α} [inst : DecidableRel f.SameCycle], ¬f.SameCycle x y → (f.cycleOf x) y = y | true |
Lean.Lsp.instBEqDiagnosticSeverity | Lean.Data.Lsp.Diagnostics | BEq Lean.Lsp.DiagnosticSeverity | true |
Antitone.ciInf_comp_tendsto_atTop | Mathlib.Order.Filter.AtTopBot.CompleteLattice | ∀ {α : Type u_3} {β : Type u_4} {γ : Type u_5} [inst : Preorder β] [inst_1 : ConditionallyCompleteLattice γ]
{l : Filter α} [l.NeBot] {f : β → γ},
Antitone f → BddBelow (Set.range f) → ∀ {g : α → β}, Filter.Tendsto g l Filter.atTop → ⨅ a, f (g a) = ⨅ b, f b | true |
DomMulAct.instDivisionCommMonoidOfMulOpposite | Mathlib.GroupTheory.GroupAction.DomAct.Basic | {M : Type u_1} → [DivisionCommMonoid Mᵐᵒᵖ] → DivisionCommMonoid Mᵈᵐᵃ | true |
Submonoid.mem_unop | Mathlib.Algebra.Group.Submonoid.MulOpposite | ∀ {M : Type u_2} [inst : MulOneClass M] {x : M} {S : Submonoid Mᵐᵒᵖ}, x ∈ S.unop ↔ MulOpposite.op x ∈ S | true |
HurwitzZeta.completedSinZeta_neg | Mathlib.NumberTheory.LSeries.HurwitzZetaOdd | ∀ (a : UnitAddCircle) (s : ℂ), HurwitzZeta.completedSinZeta (-a) s = -HurwitzZeta.completedSinZeta a s | true |
WittVector.verschiebung_shift | Mathlib.RingTheory.WittVector.Domain | ∀ {p : ℕ} {R : Type u_1} [hp : Fact (Nat.Prime p)] [inst : CommRing R] (x : WittVector p R) (k : ℕ),
(∀ i < k + 1, x.coeff i = 0) → WittVector.verschiebung (x.shift k.succ) = x.shift k | true |
instIsTopologicalRingAddOpposite | Mathlib.Topology.Algebra.Ring.Basic | ∀ {R : Type u_1} [inst : NonUnitalNonAssocRing R] [inst_1 : TopologicalSpace R] [IsTopologicalRing R],
IsTopologicalRing Rᵃᵒᵖ | true |
_private.Mathlib.CategoryTheory.Sites.Descent.Precoverage.0.CategoryTheory.Pseudofunctor.DescentData.full_pullFunctor.comm._auto_1 | Mathlib.CategoryTheory.Sites.Descent.Precoverage | Lean.Syntax | false |
Mathlib.Meta.FunProp.Mor.Arg.mk.injEq | Mathlib.Tactic.FunProp.Mor | ∀ (expr : Lean.Expr) (coe : Option Lean.Expr) (expr_1 : Lean.Expr) (coe_1 : Option Lean.Expr),
({ expr := expr, coe := coe } = { expr := expr_1, coe := coe_1 }) = (expr = expr_1 ∧ coe = coe_1) | true |
AlgebraicGeometry.AffineSpace.isIntegralHom_over_iff_isEmpty | Mathlib.AlgebraicGeometry.AffineSpace | ∀ {n : Type v} (S : AlgebraicGeometry.Scheme),
AlgebraicGeometry.IsIntegralHom (AlgebraicGeometry.AffineSpace n S ↘ S) ↔ IsEmpty ↥S ∨ IsEmpty n | true |
LinearOrderedCommGroup.closure_equiv_closure._simp_4 | Mathlib.GroupTheory.ArchimedeanDensely | ∀ {G : Type u_1} [inst : Group G] {x : G}, (x ∈ ⊥) = (x = 1) | false |
LinearMap.exact_iff_of_surjective_of_bijective_of_injective | Mathlib.Algebra.Exact | ∀ {R : Type u_1} [inst : Ring R] {M₁ : Type u_8} {M₂ : Type u_9} {M₃ : Type u_10} {N₁ : Type u_11} {N₂ : Type u_12}
{N₃ : Type u_13} [inst_1 : AddCommMonoid M₁] [inst_2 : AddCommMonoid M₂] [inst_3 : AddCommMonoid M₃]
[inst_4 : AddCommMonoid N₁] [inst_5 : AddCommMonoid N₂] [inst_6 : AddCommMonoid N₃] [inst_7 : Modul... | true |
Lean.LibrarySuggestions.initFn._@.Lean.LibrarySuggestions.SymbolFrequency.277729666._hygCtx._hyg.2 | Lean.LibrarySuggestions.SymbolFrequency | IO (Lean.PersistentEnvExtension (Lean.NameMap ℕ) Empty (Array (Array (Lean.NameMap ℕ)))) | false |
_private.Mathlib.NumberTheory.Bernoulli.0.bernoulliPowerSeries_mul_exp_sub_one._simp_1_7 | Mathlib.NumberTheory.Bernoulli | ∀ {α : Type u_2} [inst : Zero α] [inst_1 : OfNat α 3] [NeZero 3], (3 = 0) = False | false |
SimpleGraph.nonempty_subgraphOfAdj_verts | Mathlib.Combinatorics.SimpleGraph.Subgraph | ∀ {V : Type u} {G : SimpleGraph V} {v w : V} (hvw : G.Adj v w), Nonempty ↑(G.subgraphOfAdj hvw).verts | true |
_private.Lean.Meta.Tactic.Grind.EMatchTheorem.0.Lean.Meta.Grind.SelectM.State.mk.injEq | Lean.Meta.Tactic.Grind.EMatchTheorem | ∀ (suggestions : Array Lean.Meta.Tactic.TryThis.Suggestion) (thms : Array Lean.Meta.Grind.EMatchTheorem)
(suggestions_1 : Array Lean.Meta.Tactic.TryThis.Suggestion) (thms_1 : Array Lean.Meta.Grind.EMatchTheorem),
({ suggestions := suggestions, thms := thms } = { suggestions := suggestions_1, thms := thms_1 }) =
... | true |
SBtw.sbtw.trans_left | Mathlib.Order.Circular | ∀ {α : Type u_1} [inst : CircularPreorder α] {a b c d : α}, sbtw a b c → sbtw b d c → sbtw a d c | true |
_private.Mathlib.MeasureTheory.Integral.IntervalIntegral.AbsolutelyContinuousFun.0.exists_dist_slope_lt_pairwiseDisjoint_hasSum._proof_1_5 | Mathlib.MeasureTheory.Integral.IntervalIntegral.AbsolutelyContinuousFun | ∀ {F : Type u_1} [inst : NormedAddCommGroup F] [inst_1 : NormedSpace ℝ F] {f f' : ℝ → F} {d b η : ℝ},
∀ A ∈ {z | (d < z.1 ∧ z.1 < z.2 ∧ z.2 < b) ∧ dist (slope f z.1 z.2) (f' z.1) < η}, 0 ≤ 6 * (A.2 - A.1) | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.