name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
Std.DTreeMap.Raw.get!_inter_of_mem_right | Std.Data.DTreeMap.Raw.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t₁ t₂ : Std.DTreeMap.Raw α β cmp} [Std.TransCmp cmp]
[inst : Std.LawfulEqCmp cmp],
t₁.WF → t₂.WF → ∀ {k : α} [inst_1 : Inhabited (β k)], k ∈ t₂ → (t₁ ∩ t₂).get! k = t₁.get! k | true |
OrderIso.sumLexIioIci_symm_apply_of_ge | Mathlib.Order.Hom.Lex | ∀ {α : Type u_1} [inst : LinearOrder α] {x y : α} (h : x ≤ y), (OrderIso.sumLexIioIci x).symm y = toLex (Sum.inr ⟨y, h⟩) | true |
DyckWord.insidePart._proof_1 | Mathlib.Combinatorics.Enumerative.DyckWord | ∀ (p : DyckWord) (h : ¬p = 0),
p.take (p.firstReturn + 1) ⋯ ≠ 0 ∧
∀ ⦃i : ℕ⦄,
0 < i →
i < (↑(p.take (p.firstReturn + 1) ⋯)).length →
List.count DyckStep.D (List.take i ↑(p.take (p.firstReturn + 1) ⋯)) <
List.count DyckStep.U (List.take i ↑(p.take (p.firstReturn + 1) ⋯)) | false |
Finset.mul_prod_Ioo_eq_prod_Ico | Mathlib.Algebra.Order.BigOperators.Group.LocallyFinite | ∀ {α : Type u_1} {M : Type u_2} [inst : CommMonoid M] {f : α → M} {a b : α} [inst_1 : PartialOrder α]
[inst_2 : LocallyFiniteOrder α], a < b → f a * ∏ x ∈ Finset.Ioo a b, f x = ∏ x ∈ Finset.Ico a b, f x | true |
Std.HashMap.Raw.getKey?_alter | Std.Data.HashMap.RawLemmas | ∀ {α : Type u} {β : Type v} [inst : BEq α] [inst_1 : Hashable α] {m : Std.HashMap.Raw α β} [inst_2 : EquivBEq α]
[LawfulHashable α] {k k' : α} {f : Option β → Option β},
m.WF →
(m.alter k f).getKey? k' =
if (k == k') = true then if (f m[k]?).isSome = true then some k else none else m.getKey? k' | true |
_private.Std.Data.DTreeMap.Raw.Lemmas.0.Std.DTreeMap.Raw.Const.contains_of_contains_insertMany_list'._simp_1_1 | Std.Data.DTreeMap.Raw.Lemmas | ∀ {α : Type u} {x : Ord α} {x_1 : BEq α} [Std.LawfulBEqOrd α] {a b : α}, (compare a b = Ordering.eq) = ((a == b) = true) | false |
Rat.lt_of_mul_lt_mul_left | Init.Data.Rat.Lemmas | ∀ {a b c : ℚ}, c * a < c * b → 0 ≤ c → a < b | true |
List.finIdxOf?_cons | Init.Data.List.Find | ∀ {α : Type u_1} {b : α} [inst : BEq α] {a : α} {xs : List α},
List.finIdxOf? b (a :: xs) =
if (a == b) = true then some ⟨0, ⋯⟩ else Option.map (fun x => x.succ) (List.finIdxOf? b xs) | true |
BitVec.sub_neg | Init.Data.BitVec.Lemmas | ∀ {w : ℕ} {x y : BitVec w}, x - -y = x + y | true |
_private.Mathlib.Algebra.Homology.SpectralObject.Page.0.CategoryTheory.Abelian.SpectralObject.rightHomologyDataShortComplex._proof_4 | Mathlib.Algebra.Homology.SpectralObject.Page | ∀ {C : Type u_2} {ι : Type u_4} [inst : CategoryTheory.Category.{u_1, u_2} C]
[inst_1 : CategoryTheory.Category.{u_3, u_4} ι] [inst_2 : CategoryTheory.Abelian C]
(X : CategoryTheory.Abelian.SpectralObject C ι) {i j k l : ι} (f₁ : i ⟶ j) (f₂ : j ⟶ k) (f₃ : k ⟶ l) (n₀ n₁ n₂ : ℤ)
(hn₁ : n₀ + 1 = n₁) (hn₂ : n₁ + 1 = ... | false |
Array.countP_empty | Init.Data.Array.Count | ∀ {α : Type u_1} {p : α → Bool}, Array.countP p #[] = 0 | true |
_private.Batteries.Data.Fin.Lemmas.0.Fin.find?_le_findRev?._proof_1_1 | Batteries.Data.Fin.Lemmas | ∀ {n : ℕ}, none ≤ none | false |
NumberField.InfinitePlace.IsRamified.ne_conjugate | Mathlib.NumberTheory.NumberField.InfinitePlace.Ramification | ∀ {k : Type u_1} [inst : Field k] {K : Type u_2} [inst_1 : Field K] [inst_2 : Algebra k K]
{w₁ w₂ : NumberField.InfinitePlace K},
NumberField.InfinitePlace.IsRamified k w₂ → w₁.embedding ≠ NumberField.ComplexEmbedding.conjugate w₂.embedding | true |
CategoryTheory.Cat.opEquivalence._proof_4 | Mathlib.CategoryTheory.Category.Cat.Op | ∀ {X Y : CategoryTheory.Cat} (f : X ⟶ Y),
CategoryTheory.CategoryStruct.comp ((CategoryTheory.Cat.opFunctor.comp CategoryTheory.Cat.opFunctor).map f)
((fun x =>
{ hom := (CategoryTheory.unopUnop ↑x).toCatHom, inv := (CategoryTheory.opOp ↑x).toCatHom, hom_inv_id := ⋯,
inv_hom_id := ⋯ })... | false |
_private.Mathlib.Tactic.Module.0.Mathlib.Tactic.Module.qNF.sub._unary._proof_3 | Mathlib.Tactic.Module | ∀ {u v : Lean.Level} {M : Q(Type v)} {R : Q(Type u)} (a₁ : Q(«$R»)) (x₁ : Q(«$M»)) (k₁ : ℕ)
(t₁ : Mathlib.Tactic.Module.NF (Q(«$R») × Q(«$M»)) ℕ) (a₂ : Q(«$R»)) (x₂ : Q(«$M»)) (k₂ : ℕ)
(t₂ : Mathlib.Tactic.Module.NF (Q(«$R») × Q(«$M»)) ℕ),
(invImage (fun x => PSigma.casesOn x fun a a_1 => (a, a_1)) Prod.instWellF... | false |
_private.Mathlib.Topology.MetricSpace.Bounded.0.Metric.isBounded_iff_subset_ball.match_1_1 | Mathlib.Topology.MetricSpace.Bounded | ∀ {α : Type u_1} {s : Set α} [inst : PseudoMetricSpace α] (c : α) (motive : (∃ r, s ⊆ Metric.ball c r) → Prop)
(x : ∃ r, s ⊆ Metric.ball c r), (∀ (_r : ℝ) (hr : s ⊆ Metric.ball c _r), motive ⋯) → motive x | false |
Lean.Grind.CommRing.Expr.intCast | Init.Grind.Ring.CommSolver | ℤ → Lean.Grind.CommRing.Expr | true |
_private.Mathlib.Topology.Separation.Regular.0.SeparatedNhds.of_isCompact_isClosed._simp_1_2 | Mathlib.Topology.Separation.Regular | ∀ {X : Type u_1} [inst : TopologicalSpace X] [RegularSpace X] {x : X} {s : Set X},
Disjoint (nhds x) (nhdsSet s) = (x ∉ closure s) | false |
ContinuousMap.abs_mem_subalgebra_closure | Mathlib.Topology.ContinuousMap.StoneWeierstrass | ∀ {X : Type u_1} [inst : TopologicalSpace X] [inst_1 : CompactSpace X] (A : Subalgebra ℝ C(X, ℝ)) (f : ↥A),
|↑f| ∈ A.topologicalClosure | true |
IsLprojection.instLatticeSubtypeOfFaithfulSMul | Mathlib.Analysis.Normed.Module.MStructure | {X : Type u_1} →
[inst : NormedAddCommGroup X] →
{M : Type u_2} → [inst_1 : Ring M] → [inst_2 : Module M X] → [FaithfulSMul M X] → Lattice { P // IsLprojection X P } | true |
Nat.leRecOn_injective | Mathlib.Data.Nat.Basic | ∀ {C : ℕ → Sort u_1} {n m : ℕ} (hnm : n ≤ m) (next : {k : ℕ} → C k → C (k + 1)),
(∀ (n : ℕ), Function.Injective next) → Function.Injective (Nat.leRecOn hnm fun {k} => next) | true |
Nat.Prime.dvd_choose_pow | Mathlib.Data.Nat.Multiplicity | ∀ {p n k : ℕ}, Nat.Prime p → k ≠ 0 → k ≠ p ^ n → p ∣ (p ^ n).choose k | true |
QuaternionAlgebra.Basis.casesOn | Mathlib.Algebra.QuaternionBasis | {R : Type u_1} →
{A : Type u_2} →
[inst : CommRing R] →
[inst_1 : Ring A] →
[inst_2 : Algebra R A] →
{c₁ c₂ c₃ : R} →
{motive : QuaternionAlgebra.Basis A c₁ c₂ c₃ → Sort u} →
(t : QuaternionAlgebra.Basis A c₁ c₂ c₃) →
((i j k : A) →
... | false |
EMetric.NonemptyCompacts.isClosed_in_closeds | Mathlib.Topology.MetricSpace.Closeds | ∀ {α : Type u_1} [inst : EMetricSpace α] [CompleteSpace α],
IsClosed (Set.range TopologicalSpace.NonemptyCompacts.toCloseds) | true |
LinearMap.isNilpotent_mulRight_iff | Mathlib.RingTheory.Nilpotent.Lemmas | ∀ (R : Type u_1) {A : Type v} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A] (a : A),
IsNilpotent (LinearMap.mulRight R a) ↔ IsNilpotent a | true |
Equiv.toIso_hom | Mathlib.CategoryTheory.Types.Basic | ∀ {X Y : Type u} {e : X ≃ Y}, e.toIso.hom = ⇑e | true |
_private.Mathlib.Data.Fin.Basic.0.Fin.cast_injective._simp_1_1 | Mathlib.Data.Fin.Basic | ∀ {n : ℕ} (a b : Fin n), (a = b) = (↑a = ↑b) | false |
Lean.Language.Lean.CommandParsedSnapshot.below_1 | Lean.Language.Lean.Types | {motive_1 : Lean.Language.Lean.CommandParsedSnapshot → Sort u} →
{motive_2 : Option (Lean.Language.SnapshotTask Lean.Language.Lean.CommandParsedSnapshot) → Sort u} →
{motive_3 : Lean.Language.SnapshotTask Lean.Language.Lean.CommandParsedSnapshot → Sort u} →
{motive_4 : Task Lean.Language.Lean.CommandParsedS... | false |
_private.Lean.Meta.Tactic.Grind.Arith.Linear.PropagateEq.0.Lean.Meta.Grind.Arith.Linear.updateDiseqs.match_3 | Lean.Meta.Tactic.Grind.Arith.Linear.PropagateEq | (motive :
Lean.PArray Lean.Meta.Grind.Arith.Linear.DiseqCnstr × Array (ℤ × Lean.Meta.Grind.Arith.Linear.DiseqCnstr) →
Sort u_1) →
(x : Lean.PArray Lean.Meta.Grind.Arith.Linear.DiseqCnstr × Array (ℤ × Lean.Meta.Grind.Arith.Linear.DiseqCnstr)) →
((diseqs' : Lean.PArray Lean.Meta.Grind.Arith.Linear.DiseqCn... | false |
TensorProduct.finsuppLeft._proof_1 | Mathlib.LinearAlgebra.DirectSum.Finsupp | ∀ (R : Type u_1) (S : Type u_2) [inst : CommSemiring R] [inst_1 : Semiring S] [inst_2 : Algebra R S] (M : Type u_3)
[inst_3 : AddCommMonoid M] [inst_4 : Module R M] [inst_5 : Module S M] [IsScalarTower R S M] (ι : Type u_4),
SMulCommClass R S (ι →₀ M) | false |
_private.Std.Tactic.BVDecide.LRAT.Internal.Formula.RupAddResult.0.Std.Tactic.BVDecide.LRAT.Internal.DefaultFormula.nodup_insertRupUnits._proof_1_3 | Std.Tactic.BVDecide.LRAT.Internal.Formula.RupAddResult | ∀ {n : ℕ} (li : Std.Tactic.BVDecide.LRAT.Internal.PosFin n), ↑li < n | false |
_private.Std.Tactic.BVDecide.LRAT.Internal.Formula.Lemmas.0.Std.Tactic.BVDecide.LRAT.Internal.DefaultFormula.deleteOne_preserves_strongAssignmentsInvariant.match_1_3 | Std.Tactic.BVDecide.LRAT.Internal.Formula.Lemmas | ∀ {n : ℕ} (motive : Option (Std.Tactic.BVDecide.LRAT.Internal.DefaultClause n) → Prop)
(x : Option (Std.Tactic.BVDecide.LRAT.Internal.DefaultClause n)),
(x = none → motive none) →
(∀ (c : Std.Tactic.BVDecide.LRAT.Internal.DefaultClause n), x = some c → motive (some c)) → motive x | false |
rieszContentAux_image_nonempty | Mathlib.MeasureTheory.Integral.RieszMarkovKakutani.Basic | ∀ {X : Type u_1} [inst : TopologicalSpace X] (Λ : CompactlySupportedContinuousMap X NNReal →ₗ[NNReal] NNReal)
[T2Space X] [LocallyCompactSpace X] (K : TopologicalSpace.Compacts X), (⇑Λ '' {f | ∀ x ∈ K, 1 ≤ f x}).Nonempty | true |
Finset.orderIsoOfFin._proof_4 | Mathlib.Data.Finset.Sort | ∀ {α : Type u_1} [inst : LinearOrder α] (s : Finset α) {k : ℕ}, s.card = k → k = (s.sort fun x1 x2 => x1 ≤ x2).length | false |
Lean.Meta.AbstractNestedProofs.Context | Lean.Meta.AbstractNestedProofs | Type | true |
MeasurableSpace.monotone_map | Mathlib.MeasureTheory.MeasurableSpace.Basic | ∀ {α : Type u_1} {β : Type u_2} {f : α → β}, Monotone (MeasurableSpace.map f) | true |
List.pairwise_le_finRange | Batteries.Data.List.Lemmas | ∀ (n : ℕ), List.Pairwise (fun x1 x2 => x1 ≤ x2) (List.finRange n) | true |
HahnSeries.cardSuppLTAddSubgroup | Mathlib.RingTheory.HahnSeries.Cardinal | (Γ : Type u_1) →
(R : Type u_2) →
(κ : Cardinal.{u_1}) →
[inst : PartialOrder Γ] → [inst_1 : AddGroup R] → [hκ : Fact (Cardinal.aleph0 ≤ κ)] → AddSubgroup (HahnSeries Γ R) | true |
CompositionAsSet.length.eq_1 | Mathlib.Combinatorics.Enumerative.Composition | ∀ {n : ℕ} (c : CompositionAsSet n), c.length = c.boundaries.card - 1 | true |
VAddCon._sizeOf_inst | Mathlib.Algebra.Module.Congruence.Defs | (S : Type u_2) → (M : Type u_3) → {inst : VAdd S M} → [SizeOf S] → [SizeOf M] → SizeOf (VAddCon S M) | false |
Filter.Tendsto.units._proof_1 | Mathlib.Topology.Algebra.Monoid | ∀ {ι : Type u_2} {N : Type u_1} [inst : TopologicalSpace N] [inst_1 : Monoid N] [ContinuousMul N] [T2Space N]
{f : ι → Nˣ} {r₁ r₂ : N} {l : Filter ι} [l.NeBot],
Filter.Tendsto (fun x => ↑(f x)) l (nhds r₁) → Filter.Tendsto (fun x => ↑(f x)⁻¹) l (nhds r₂) → r₁ * r₂ = 1 | false |
Lean.Meta.Grind.UnitLike.State.ctorIdx | Lean.Meta.Tactic.Grind.Types | Lean.Meta.Grind.UnitLike.State → ℕ | false |
CommMonoidWithZero.rec | Mathlib.Algebra.GroupWithZero.Defs | {M₀ : Type u_2} →
{motive : CommMonoidWithZero M₀ → Sort u} →
([toCommMonoid : CommMonoid M₀] →
[toZero : Zero M₀] →
(zero_mul : ∀ (a : M₀), 0 * a = 0) →
(mul_zero : ∀ (a : M₀), a * 0 = 0) →
motive { toCommMonoid := toCommMonoid, toZero := toZero, zero_mul := zero_mul, ... | false |
GrpCat.ext_iff | Mathlib.Algebra.Category.Grp.Basic | ∀ {X Y : GrpCat} {f g : X ⟶ Y},
f = g ↔ ∀ (x : ↑X), (CategoryTheory.ConcreteCategory.hom f) x = (CategoryTheory.ConcreteCategory.hom g) x | true |
ModN.natCard_eq | Mathlib.LinearAlgebra.FreeModule.ModN | ∀ (G : Type u_1) [inst : AddCommGroup G] (n : ℕ) [NeZero n] [Module.Free ℤ G] [Module.Finite ℤ G],
Nat.card (ModN G n) = n ^ Module.finrank ℤ G | true |
CategoryTheory.MonoidalCategory.prodMonoidal._proof_15 | Mathlib.CategoryTheory.Monoidal.Category | ∀ (C₁ : Type u_1) [inst : CategoryTheory.Category.{u_3, u_1} C₁] [inst_1 : CategoryTheory.MonoidalCategory C₁]
(C₂ : Type u_2) [inst_2 : CategoryTheory.Category.{u_4, u_2} C₂] [inst_3 : CategoryTheory.MonoidalCategory C₂]
{X Y : C₁ × C₂} (f : X ⟶ Y),
CategoryTheory.CategoryStruct.comp
(CategoryTheory.Prod.m... | false |
Algebra.traceMatrix_reindex | Mathlib.RingTheory.Trace.Basic | ∀ {κ : Type w} (A : Type u) {B : Type v} [inst : CommRing A] [inst_1 : CommRing B] [inst_2 : Algebra A B]
{κ' : Type u_7} (b : Module.Basis κ A B) (f : κ ≃ κ'),
Algebra.traceMatrix A ⇑(b.reindex f) = (Matrix.reindex f f) (Algebra.traceMatrix A ⇑b) | true |
Algebra.instCompleteLatticeSubalgebra | Mathlib.Algebra.Algebra.Subalgebra.Lattice | {R : Type u} →
{A : Type v} →
[inst : CommSemiring R] → [inst_1 : Semiring A] → [inst_2 : Algebra R A] → CompleteLattice (Subalgebra R A) | true |
Matrix.vecMulBilin._proof_6 | Mathlib.LinearAlgebra.Matrix.ToLin | ∀ {m : Type u_1} {n : Type u_2} (R : Type u_4) {A : Type u_3} [inst : Semiring R] [inst_1 : NonUnitalNonAssocSemiring A]
[inst_2 : Module R A] [inst_3 : Fintype m] (x : R) (x_1 : m → A) (x_2 x_3 : Matrix m n A),
Matrix.vecMul (x • x_1) (x_2 + x_3) = Matrix.vecMul (x • x_1) x_2 + Matrix.vecMul (x • x_1) x_3 | false |
_private.Init.Data.String.Lemmas.Pattern.Basic.0.String.Slice.Pattern.Model.matchesAt_iff_exists_isMatch._simp_1_5 | Init.Data.String.Lemmas.Pattern.Basic | ∀ {s : String.Slice} {p : s.Pos} {q r : (s.sliceFrom p).Pos},
(q ≤ r) = (String.Slice.Pos.ofSliceFrom q ≤ String.Slice.Pos.ofSliceFrom r) | false |
truncSigmaOfExists._proof_1 | Mathlib.Data.Fintype.Basic | ∀ {α : Type u_1} {P : α → Prop}, (∃ a, P a) → Nonempty ((a : α) ×' P a) | false |
Int.add_neg | Init.Data.Int.Order | ∀ {a b : ℤ}, a < 0 → b < 0 → a + b < 0 | true |
LieAlgebra.polyCharpoly_coeff_rank_ne_zero | Mathlib.Algebra.Lie.Rank | ∀ (R : Type u_1) (L : Type u_3) {ι : Type u_5} [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : LieAlgebra R L]
[inst_3 : Module.Finite R L] [inst_4 : Module.Free R L] [inst_5 : Fintype ι] (b : Module.Basis ι R L) [Nontrivial R]
[inst_7 : DecidableEq ι], ((↑(LieAlgebra.ad R L)).polyCharpoly b).coeff (LieAlgebra.r... | true |
CategoryTheory.BasedCategory.whiskerLeft_toNatTrans | Mathlib.CategoryTheory.FiberedCategory.BasedCategory | ∀ {𝒮 : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} 𝒮] {𝒳 : CategoryTheory.BasedCategory 𝒮}
{𝒴 : CategoryTheory.BasedCategory 𝒮} {𝒵 : CategoryTheory.BasedCategory 𝒮} (F : CategoryTheory.BasedFunctor 𝒳 𝒴)
{G H : CategoryTheory.BasedFunctor 𝒴 𝒵} (α : G ⟶ H),
(CategoryTheory.BasedCategory.whiskerLef... | true |
Int.instTransLe | Init.Data.Int.Order | Trans (fun x1 x2 => x1 ≤ x2) (fun x1 x2 => x1 ≤ x2) fun x1 x2 => x1 ≤ x2 | true |
List.forIn_map | Init.Data.List.Monadic | ∀ {m : Type u_1 → Type u_2} {α : Type u_3} {β : Type u_4} {γ : Type u_1} {init : γ} [inst : Monad m] [LawfulMonad m]
{l : List α} {g : α → β} {f : β → γ → m (ForInStep γ)},
forIn (List.map g l) init f = forIn l init fun a y => f (g a) y | true |
Left.neg_lt_self | Mathlib.Algebra.Order.Group.Unbundled.Basic | ∀ {α : Type u} [inst : AddGroup α] [inst_1 : Preorder α] [AddLeftStrictMono α] {a : α}, 0 < a → -a < a | true |
Lean.Elab.Tactic.BVDecide.Frontend.Normalize.ult._regBuiltin.Lean.Elab.Tactic.BVDecide.Frontend.Normalize.ult.declare_1._@.Lean.Elab.Tactic.BVDecide.Frontend.Normalize.Simproc.2445608185._hygCtx._hyg.16 | Lean.Elab.Tactic.BVDecide.Frontend.Normalize.Simproc | IO Unit | false |
BitVec.equivFin._proof_1 | Mathlib.Data.BitVec | ∀ {m : ℕ}, Function.LeftInverse (fun a => { toFin := a }) fun a => a.toFin | false |
EReal.neg_mul | Mathlib.Data.EReal.Operations | ∀ (x y : EReal), -x * y = -(x * y) | true |
Std.IdempotentOp.idempotent | Init.Core | ∀ {α : Sort u} {op : α → α → α} [self : Std.IdempotentOp op] (x : α), op x x = x | true |
LinearEquiv.conjAlgEquiv | Mathlib.Algebra.Algebra.Equiv | (R : Type u_1) →
{S : Type u_2} →
{M₁ : Type u_3} →
{M₂ : Type u_4} →
[inst : CommSemiring R] →
[inst_1 : AddCommMonoid M₁] →
[inst_2 : Module R M₁] →
[inst_3 : AddCommMonoid M₂] →
[inst_4 : Module R M₂] →
[inst_5 : Semiring S] →
... | true |
Lean.Compiler.LCNF.Closure.State.rec | Lean.Compiler.LCNF.Closure | {motive : Lean.Compiler.LCNF.Closure.State → Sort u} →
((visited : Lean.FVarIdHashSet) →
(params : Array (Lean.Compiler.LCNF.Param Lean.Compiler.LCNF.Purity.pure)) →
(decls : Array (Lean.Compiler.LCNF.CodeDecl Lean.Compiler.LCNF.Purity.pure)) →
motive { visited := visited, params := params, de... | false |
CategoryTheory.Monad.monadToMon._proof_2 | Mathlib.CategoryTheory.Monad.EquivMon | ∀ (C : Type u_1) [inst : CategoryTheory.Category.{u_2, u_1} C] {X Y : CategoryTheory.Monad C} (f : X ⟶ Y),
CategoryTheory.CategoryStruct.comp CategoryTheory.MonObj.one f.toNatTrans = CategoryTheory.MonObj.one | false |
HahnModule.instSMulZeroClass | Mathlib.RingTheory.HahnSeries.Multiplication | {Γ : Type u_1} →
{Γ' : Type u_2} →
{R : Type u_3} →
{V : Type u_5} →
[inst : PartialOrder Γ] →
[inst_1 : PartialOrder Γ'] →
[inst_2 : VAdd Γ Γ'] →
[IsOrderedCancelVAdd Γ Γ'] →
[inst_4 : AddCommMonoid V] →
[inst_5 : Zero R] → [inst... | true |
_private.Init.Data.Range.Polymorphic.Lemmas.0.Std.Rcc.size_eq_if_roc._simp_1_2 | Init.Data.Range.Polymorphic.Lemmas | ∀ {α : Type u} [inst : LE α] [inst_1 : Std.PRange.UpwardEnumerable α] [inst_2 : Std.Rxc.HasSize α]
[Std.Rxc.LawfulHasSize α] {lo hi : α}, (Std.Rxc.HasSize.size lo hi = 0) = ¬lo ≤ hi | false |
HasMFDerivAt.mdifferentiableAt | 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 : NormedAddComm... | true |
CategoryTheory.ChosenPullbacksAlong.cartesianMonoidalCategoryFst._proof_2 | Mathlib.CategoryTheory.LocallyCartesianClosed.ChosenPullbacksAlong | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.CartesianMonoidalCategory C]
(X Y : C) {X_1 Y_1 : CategoryTheory.Over X} (g : X_1 ⟶ Y_1),
CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategoryStruct.whiskerRight g.left Y)
(CategoryTheory.Over.mk (CategoryTh... | false |
AddMonoidAlgebra.ofMagma | Mathlib.Algebra.MonoidAlgebra.Defs | (R : Type u_8) → (M : Type u_9) → [inst : Semiring R] → [inst_1 : Add M] → Multiplicative M →ₙ* AddMonoidAlgebra R M | true |
CategoryTheory.MorphismProperty.Over.map.congr_simp | Mathlib.CategoryTheory.MorphismProperty.OverAdjunction | ∀ {T : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} T] {P : CategoryTheory.MorphismProperty T}
(Q : CategoryTheory.MorphismProperty T) [inst_1 : Q.IsMultiplicative] {X Y : T} [inst_2 : P.IsStableUnderComposition]
{f f_1 : X ⟶ Y} (e_f : f = f_1) (hPf : P f),
CategoryTheory.MorphismProperty.Over.map Q hPf =... | true |
CategoryTheory.Aut.autMulEquivOfIso._proof_13 | Mathlib.CategoryTheory.Endomorphism | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {X Y : C} (h : X ≅ Y) (x y : CategoryTheory.Aut X),
{ hom := CategoryTheory.CategoryStruct.comp h.inv (CategoryTheory.CategoryStruct.comp (x * y).hom h.hom),
inv := CategoryTheory.CategoryStruct.comp h.inv (CategoryTheory.CategoryStruct.comp (x * y)... | false |
MonoidWithZeroHom.funLike._proof_1 | Mathlib.Algebra.GroupWithZero.Hom | ∀ {α : Type u_1} {β : Type u_2} [inst : MulZeroOneClass α] [inst_1 : MulZeroOneClass β] (f g : α →*₀ β),
(fun f => (↑f).toFun) f = (fun f => (↑f).toFun) g → f = g | false |
Nonneg.one | Mathlib.Algebra.Order.Nonneg.Basic | {α : Type u_1} → [inst : Zero α] → [inst_1 : One α] → [inst_2 : LE α] → [ZeroLEOneClass α] → One { x // 0 ≤ x } | true |
Nondet.bind.match_3 | Batteries.Control.Nondet.Basic | {σ : Type} →
{m : Type → Type} →
{α : Type} →
(motive : Option ((α × σ) × MLList m (α × σ)) → Sort u_1) →
(__do_lift : Option ((α × σ) × MLList m (α × σ))) →
(Unit → motive none) →
((x : α) → (s : σ) → (xs : MLList m (α × σ)) → motive (some ((x, s), xs))) → motive __do_lift | false |
_private.Mathlib.MeasureTheory.Function.UnifTight.0.MeasureTheory.unifTight_of_tendsto_Lp | Mathlib.MeasureTheory.Function.UnifTight | ∀ {α : Type u_1} {β : Type u_2} {m : MeasurableSpace α} [inst : NormedAddCommGroup β] {μ : MeasureTheory.Measure α}
{p : ENNReal} {f : ℕ → α → β} {g : α → β},
p ≠ ⊤ →
(∀ (n : ℕ), MeasureTheory.MemLp (f n) p μ) →
MeasureTheory.MemLp g p μ →
Filter.Tendsto (fun n => MeasureTheory.eLpNorm (f n - g) p... | true |
Lean.Meta.Simp.registerBuiltinSimproc | Lean.Meta.Tactic.Simp.Simproc | Lean.Name → Array Lean.Meta.SimpTheoremKey → Lean.Meta.Simp.Simproc → IO Unit | true |
_private.Mathlib.GroupTheory.Perm.Cycle.Type.0.Equiv.Perm.IsThreeCycle.nodup_iff_mem_support._proof_1_714 | Mathlib.GroupTheory.Perm.Cycle.Type | ∀ {α : Type u_1} [inst_1 : DecidableEq α] {g : Equiv.Perm α} {a : α} (w : α),
¬[g a, g (g a)].Nodup →
∀ (w_1 : α),
2 ≤ List.count w_1 [g a, g (g a)] →
List.idxOfNth w_1 [g a, g (g a)] (List.idxOfNth w_1 [g a, g (g a)] [g (g a)].length) <
(List.findIdxs (fun x => decide (x = w_1)) [g a, g (... | false |
_private.Mathlib.Data.Sign.Basic.0.sign_sum._simp_1_1 | Mathlib.Data.Sign.Basic | ∀ {α : Type u_1} [inst : Zero α] [inst_1 : LinearOrder α] {a : α}, (SignType.sign a = 0) = (a = 0) | false |
TopologicalSpace.CompactOpens.instInf._proof_1 | Mathlib.Topology.Sets.Compacts | ∀ {α : Type u_1} [inst : TopologicalSpace α] [QuasiSeparatedSpace α] (U V : TopologicalSpace.CompactOpens α),
IsCompact (U.carrier ∩ V.carrier) | false |
ZeroAtInftyContinuousMap.instStarModule | Mathlib.Topology.ContinuousMap.ZeroAtInfty | ∀ {α : Type u} {β : Type v} [inst : TopologicalSpace α] {𝕜 : Type u_2} [inst_1 : Zero 𝕜] [inst_2 : Star 𝕜]
[inst_3 : AddMonoid β] [inst_4 : StarAddMonoid β] [inst_5 : TopologicalSpace β] [inst_6 : ContinuousStar β]
[inst_7 : SMulWithZero 𝕜 β] [inst_8 : ContinuousConstSMul 𝕜 β] [StarModule 𝕜 β],
StarModule �... | true |
CategoryTheory.Limits.CategoricalPullback.mkIso._proof_3 | Mathlib.CategoryTheory.Limits.Shapes.Pullback.Categorical.Basic | ∀ {A : Type u_3} {B : Type u_6} {C : Type u_4} [inst : CategoryTheory.Category.{u_1, u_3} A]
[inst_1 : CategoryTheory.Category.{u_5, u_6} B] [inst_2 : CategoryTheory.Category.{u_2, u_4} C]
{F : CategoryTheory.Functor A B} {G : CategoryTheory.Functor C B}
{x y : CategoryTheory.Limits.CategoricalPullback F G} (eₗ :... | false |
PseudoEpimorphism.comp_apply | Mathlib.Topology.Order.Hom.Esakia | ∀ {α : Type u_2} {β : Type u_3} {γ : Type u_4} [inst : Preorder α] [inst_1 : Preorder β] [inst_2 : Preorder γ]
(g : PseudoEpimorphism β γ) (f : PseudoEpimorphism α β) (a : α), (g.comp f) a = g (f a) | true |
AlgebraicGeometry.LocallyRingedSpace.Γevaluation_naturality | Mathlib.Geometry.RingedSpace.LocallyRingedSpace.ResidueField | ∀ {X Y : AlgebraicGeometry.LocallyRingedSpace} (f : X ⟶ Y) (x : ↑X.toTopCat),
CategoryTheory.CategoryStruct.comp (Y.Γevaluation ((CategoryTheory.ConcreteCategory.hom f.base) x))
(AlgebraicGeometry.LocallyRingedSpace.residueFieldMap f x) =
CategoryTheory.CategoryStruct.comp (f.c.app (Opposite.op ⊤)) (X.Γeval... | true |
CategoryTheory.ShortComplex.toCycles_comp_leftHomologyπ | Mathlib.Algebra.Homology.ShortComplex.LeftHomology | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
(S : CategoryTheory.ShortComplex C) [inst_2 : S.HasLeftHomology],
CategoryTheory.CategoryStruct.comp S.toCycles S.leftHomologyπ = 0 | true |
NFA.Path.supp._sunfold | Mathlib.Computability.NFA | {α : Type u} → {σ : Type v} → {M : NFA α σ} → [DecidableEq σ] → {s t : σ} → {x : List α} → M.Path s t x → Finset σ | false |
IntermediateField.add_mem | Mathlib.FieldTheory.IntermediateField.Basic | ∀ {K : Type u_1} {L : Type u_2} [inst : Field K] [inst_1 : Field L] [inst_2 : Algebra K L] (S : IntermediateField K L)
{x y : L}, x ∈ S → y ∈ S → x + y ∈ S | true |
Order.IsPredPrelimit.subtypeVal | Mathlib.Order.SuccPred.Limit | ∀ {α : Type u_1} [inst : Preorder α] {s : Set α},
IsUpperSet s → ∀ {a : ↑s}, Order.IsPredPrelimit a → Order.IsPredPrelimit ↑a | true |
unitInterval.instLinearOrderedCommMonoidWithZeroElemReal._proof_1 | Mathlib.Topology.UnitInterval | ∀ (i : ↑unitInterval), 0 * i = 0 | false |
CategoryTheory.Limits.multicospanShapeEnd_fst | Mathlib.CategoryTheory.Limits.Shapes.End | ∀ (J : Type u) [inst : CategoryTheory.Category.{v, u} J] (f : CategoryTheory.Arrow J),
(CategoryTheory.Limits.multicospanShapeEnd J).fst f = f.left | true |
Con.lift_funext | Mathlib.GroupTheory.Congruence.Hom | ∀ {M : Type u_1} {P : Type u_3} [inst : MulOneClass M] [inst_1 : MulOneClass P] {c : Con M} (f g : c.Quotient →* P),
(∀ (a : M), f ↑a = g ↑a) → f = g | true |
StrictConvex.is_linear_preimage | Mathlib.Analysis.Convex.Strict | ∀ {𝕜 : Type u_1} {E : Type u_3} {F : Type u_4} [inst : Semiring 𝕜] [inst_1 : PartialOrder 𝕜]
[inst_2 : TopologicalSpace E] [inst_3 : TopologicalSpace F] [inst_4 : AddCommMonoid E] [inst_5 : AddCommMonoid F]
[inst_6 : Module 𝕜 E] [inst_7 : Module 𝕜 F] {s : Set F},
StrictConvex 𝕜 s → ∀ {f : E → F}, IsLinearMa... | true |
mem_skewAdjointMatricesSubmodule._simp_1 | Mathlib.LinearAlgebra.Matrix.SesquilinearForm | ∀ {R : Type u_1} {n : Type u_11} [inst : CommRing R] [inst_1 : Fintype n] (J A₁ : Matrix n n R)
[inst_2 : DecidableEq n], (A₁ ∈ skewAdjointMatricesSubmodule J) = J.IsSkewAdjoint A₁ | false |
ContinuousMultilinearMap.compContinuousLinearMapL._proof_5 | Mathlib.Topology.Algebra.Module.Multilinear.Topology | ∀ {𝕜 : Type u_1} {F : Type u_2} [inst : NormedField 𝕜] [inst_1 : AddCommGroup F] [inst_2 : Module 𝕜 F],
SMulCommClass 𝕜 𝕜 F | false |
ProofWidgets.RpcEncodablePacket.goals._@.ProofWidgets.Component.Panel.Basic.2840189264._hygCtx._hyg.1 | ProofWidgets.Component.Panel.Basic | ProofWidgets.RpcEncodablePacket✝ → Lean.Json | false |
CategoryTheory.LaxMonoidalFunctor.isoOfComponents | Mathlib.CategoryTheory.Monoidal.NaturalTransformation | {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 G : CategoryTheory.LaxMonoidalFunctor C D} →
... | true |
UInt8.ofFin | Init.Data.UInt.Basic | Fin UInt8.size → UInt8 | true |
Affine.Simplex.points_mem_affineSpan_faceOpposite | Mathlib.LinearAlgebra.AffineSpace.Simplex.Basic | ∀ {k : Type u_1} {V : Type u_2} {P : Type u_5} [inst : Ring k] [inst_1 : AddCommGroup V] [inst_2 : Module k V]
[inst_3 : AddTorsor V P] [Nontrivial k] {n : ℕ} [inst_5 : NeZero n] (s : Affine.Simplex k P n) {i j : Fin (n + 1)},
s.points j ∈ affineSpan k (Set.range (s.faceOpposite i).points) ↔ j ≠ i | true |
cfc_add_const._auto_1 | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Unital | Lean.Syntax | false |
CategoryTheory.StrongEpi.of_arrow_iso | Mathlib.CategoryTheory.Limits.Shapes.StrongEpi | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {A B A' B' : C} {f : A ⟶ B} {g : A' ⟶ B'}
(e : CategoryTheory.Arrow.mk f ≅ CategoryTheory.Arrow.mk g) [h : CategoryTheory.StrongEpi f],
CategoryTheory.StrongEpi g | true |
ContinuousAffineMap.vadd_toAffineMap | Mathlib.Topology.Algebra.ContinuousAffineMap | ∀ {R : Type u_1} {V : Type u_2} {W : Type u_3} {P : Type u_4} {Q : Type u_5} [inst : Ring R] [inst_1 : AddCommGroup V]
[inst_2 : Module R V] [inst_3 : TopologicalSpace P] [inst_4 : AddTorsor V P] [inst_5 : AddCommGroup W]
[inst_6 : Module R W] [inst_7 : TopologicalSpace Q] [inst_8 : AddTorsor W Q] [inst_9 : Topolog... | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.