name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
_private.Mathlib.Analysis.Normed.Module.Multilinear.Basic.0.MultilinearMap.continuous_of_bound._simp_1_1 | Mathlib.Analysis.Normed.Module.Multilinear.Basic | ∀ {α : Type u_1} [inst : Zero α] [inst_1 : One α] [inst_2 : LE α] [ZeroLEOneClass α], (0 ≤ 1) = True | false |
StateTransition.tr_eval_rev | Mathlib.Computability.StateTransition | ∀ {σ₁ : Type u_1} {σ₂ : Type u_2} {f₁ : σ₁ → Option σ₁} {f₂ : σ₂ → Option σ₂} {tr : σ₁ → σ₂ → Prop},
StateTransition.Respects f₁ f₂ tr →
∀ {a₁ : σ₁} {b₂ a₂ : σ₂},
tr a₁ a₂ → b₂ ∈ StateTransition.eval f₂ a₂ → ∃ b₁, tr b₁ b₂ ∧ b₁ ∈ StateTransition.eval f₁ a₁ | true |
StarSubalgebra.ext_iff | Mathlib.Algebra.Star.Subalgebra | ∀ {R : Type u_2} {A : Type u_3} [inst : CommSemiring R] [inst_1 : StarRing R] [inst_2 : Semiring A]
[inst_3 : StarRing A] [inst_4 : Algebra R A] [inst_5 : StarModule R A] {S T : StarSubalgebra R A},
S = T ↔ ∀ (x : A), x ∈ S ↔ x ∈ T | true |
Lean.Lsp.ParameterInformation._sizeOf_inst | Lean.Data.Lsp.LanguageFeatures | SizeOf Lean.Lsp.ParameterInformation | false |
_private.Mathlib.Algebra.Lie.Weights.Basic.0.LieModule.iSup_genWeightSpace_eq_top._simp_1_1 | Mathlib.Algebra.Lie.Weights.Basic | ∀ {R : Type u} {L : Type v} {M : Type w} [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : AddCommGroup M]
[inst_3 : Module R M] [inst_4 : LieRingModule L M] (N N' : LieSubmodule R L M), (N = N') = (↑N = ↑N') | false |
_private.Mathlib.Order.Atoms.0.IsAtom.Iic.match_1_1 | Mathlib.Order.Atoms | ∀ {α : Type u_1} [inst : Preorder α] {a x : α} (hax : a ≤ x)
(motive : (x_1 : { x_1 // x_1 ∈ Set.Iic x }) → x_1 < ⟨a, hax⟩ → Prop) (x_1 : { x_1 // x_1 ∈ Set.Iic x })
(hba : x_1 < ⟨a, hax⟩),
(∀ (b : α) (property : b ∈ Set.Iic x) (hba : ⟨b, property⟩ < ⟨a, hax⟩), motive ⟨b, property⟩ hba) → motive x_1 hba | false |
_private.Mathlib.Data.Finset.Basic.0.Equiv.Finset.union_symm_right._simp_1_1 | Mathlib.Data.Finset.Basic | ∀ {α : Sort u_1} {β : Sort u_2} (e : α ≃ β) {x : β} {y : α}, (e.symm x = y) = (x = e y) | false |
_private.Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Var.0.Std.Tactic.BVDecide.BVExpr.bitblast.blastVar.go_get_aux._proof_1_2 | Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Var | ∀ {w : ℕ}, ∀ curr ≤ w, ∀ (idx : ℕ), ¬curr < w → ¬curr = w → False | false |
Std.TreeSet.Raw.getD_minD | Std.Data.TreeSet.Raw.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t : Std.TreeSet.Raw α cmp} [Std.TransCmp cmp],
t.WF → t.isEmpty = false → ∀ {fallback fallback' : α}, t.getD (t.minD fallback) fallback' = t.minD fallback | true |
commGroupOfIsUnit | Mathlib.Algebra.Group.Units.Defs | {M : Type u_1} → [hM : CommMonoid M] → (∀ (a : M), IsUnit a) → CommGroup M | true |
_private.Lean.Meta.Tactic.Repeat.0.Lean.Meta.repeat'Core.go.match_3 | Lean.Meta.Tactic.Repeat | (motive : ℕ → Sort u_1) → (n : ℕ) → (Unit → motive 0) → ((n : ℕ) → motive n.succ) → motive n | false |
_private.Init.Data.Array.Lemmas.0.Array.back_append._simp_1_1 | Init.Data.Array.Lemmas | ∀ {α : Type u_1} {l : List α}, (l.isEmpty = true) = (l = []) | false |
Aesop.aesop.dev.generateScript | Aesop.Options.Public | Lean.Option Bool | true |
_private.Mathlib.Data.Set.Lattice.Image.0.Set.iUnion_prod_of_monotone._simp_1_4 | Mathlib.Data.Set.Lattice.Image | ∀ {a b c : Prop}, (a ∧ b → c) = (a → b → c) | false |
UniformSpace.Completion.completeSpace | Mathlib.Topology.UniformSpace.Completion | ∀ (α : Type u_1) [inst : UniformSpace α], CompleteSpace (UniformSpace.Completion α) | true |
PEquiv.injective_of_forall_ne_isSome | Mathlib.Data.PEquiv | ∀ {α : Type u} {β : Type v} (f : α ≃. β) (a₂ : α), (∀ (a₁ : α), a₁ ≠ a₂ → (f a₁).isSome = true) → Function.Injective ⇑f | true |
Sum.Ioo_inr_inr | Mathlib.Data.Sum.Interval | ∀ {α : Type u_1} {β : Type u_2} [inst : Preorder α] [inst_1 : Preorder β] [inst_2 : LocallyFiniteOrder α]
[inst_3 : LocallyFiniteOrder β] (b₁ b₂ : β),
Finset.Ioo (Sum.inr b₁) (Sum.inr b₂) = Finset.map Function.Embedding.inr (Finset.Ioo b₁ b₂) | true |
Lean.Server.Test.Runner.Client.InteractiveGoal._sizeOf_inst | Lean.Server.Test.Runner | SizeOf Lean.Server.Test.Runner.Client.InteractiveGoal | false |
CompleteLattice.MulticoequalizerDiagram.multispanIndex._proof_8 | Mathlib.Order.CompleteLattice.MulticoequalizerDiagram | ∀ {T : Type u_1} [inst : CompleteLattice T] {ι : Type u_2} {x : T} {u : ι → T} {v : ι → ι → T},
CompleteLattice.MulticoequalizerDiagram x u v →
∀ (x : (CategoryTheory.Limits.MultispanShape.prod ι).L),
(match x with
| (i, j) => v i j) ≤
u ((CategoryTheory.Limits.MultispanShape.prod ι).snd x) | false |
CategoryTheory.Limits.IsColimit.natIso | Mathlib.CategoryTheory.Limits.IsLimit | {J : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} J] →
{C : Type u₃} →
[inst_1 : CategoryTheory.Category.{v₃, u₃} C] →
{F : CategoryTheory.Functor J C} →
{t : CategoryTheory.Limits.Cocone F} →
CategoryTheory.Limits.IsColimit t →
((CategoryTheory.coyoneda.ob... | true |
_private.Mathlib.GroupTheory.Perm.Cycle.Type.0.Equiv.Perm.IsThreeCycle.nodup_iff_mem_support._proof_1_2 | Mathlib.GroupTheory.Perm.Cycle.Type | ∀ {α : Type u_1} {g : Equiv.Perm α} {a : α}, [a, g a, g (g a)].Nodup → ¬g a = a | false |
CategoryTheory.ShortComplex.HomologyData.ofEpiMonoFactorisation.leftHomologyData_π | Mathlib.Algebra.Homology.ShortComplex.Abelian | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Abelian C]
(S : CategoryTheory.ShortComplex C) {kf : CategoryTheory.Limits.KernelFork S.g}
{cc : CategoryTheory.Limits.CokernelCofork S.f} (hkf : CategoryTheory.Limits.IsLimit kf)
(hcc : CategoryTheory.Limits.IsColimit cc) {H : C} {... | true |
inv_lt_of_neg | Mathlib.Algebra.Order.Field.Basic | ∀ {α : Type u_2} [inst : Field α] [inst_1 : PartialOrder α] [PosMulReflectLT α] [IsStrictOrderedRing α] {a b : α},
a < 0 → b < 0 → (a⁻¹ < b ↔ b⁻¹ < a) | true |
IsBezout.toGCDDomain._proof_6 | Mathlib.RingTheory.PrincipalIdealDomain | ∀ (R : Type u_1) [inst : CommRing R] [inst_1 : IsBezout R] {a b c : R}, a ∣ c → a ∣ b → a ∣ IsBezout.gcd c b | false |
AdjoinRoot.isAdjoinRoot._proof_1 | Mathlib.RingTheory.IsAdjoinRoot | ∀ {R : Type u_1} [inst : CommRing R] (f : Polynomial R), RingHom.ker (AdjoinRoot.mkₐ f) = Ideal.span {f} | false |
AddGroupCone.nonneg_toAddSubmonoid | Mathlib.Algebra.Order.Group.Cone | ∀ {H : Type u_1} [inst : AddCommGroup H] [inst_1 : PartialOrder H] [inst_2 : IsOrderedAddMonoid H],
(AddGroupCone.nonneg H).toAddSubmonoid = AddSubmonoid.nonneg H | true |
GenContFract.Pair.noConfusion | Mathlib.Algebra.ContinuedFractions.Basic | {P : Sort u} →
{α : Type u_1} →
{t : GenContFract.Pair α} →
{α' : Type u_1} → {t' : GenContFract.Pair α'} → α = α' → t ≍ t' → GenContFract.Pair.noConfusionType P t t' | false |
_private.Mathlib.Tactic.WithoutCDot.0.Lean.Elab.Term.withoutCDotContents.parenthesizer | Mathlib.Tactic.WithoutCDot | Lean.PrettyPrinter.Parenthesizer | true |
Int.preimage_Ioo | Mathlib.Algebra.Order.Floor.Ring | ∀ {R : Type u_2} [inst : Ring R] [inst_1 : LinearOrder R] [inst_2 : FloorRing R] {a b : R},
Int.cast ⁻¹' Set.Ioo a b = Set.Ioo ⌊a⌋ ⌈b⌉ | true |
Real.Angle.sign | Mathlib.Analysis.SpecialFunctions.Trigonometric.Angle | Real.Angle → SignType | true |
Lean.ScopedEnvExtension.Descr._sizeOf_1 | Lean.ScopedEnvExtension | {α β σ : Type} → [SizeOf α] → [SizeOf β] → [SizeOf σ] → Lean.ScopedEnvExtension.Descr α β σ → ℕ | false |
continuousOn_const_smul_iff₀ | Mathlib.Topology.Algebra.ConstMulAction | ∀ {α : Type u_2} {β : Type u_3} {G₀ : Type u_4} [inst : TopologicalSpace α] [inst_1 : GroupWithZero G₀]
[inst_2 : MulAction G₀ α] [ContinuousConstSMul G₀ α] [inst_4 : TopologicalSpace β] {f : β → α} {c : G₀} {s : Set β},
c ≠ 0 → (ContinuousOn (fun x => c • f x) s ↔ ContinuousOn f s) | true |
Lean.Meta.Rewrites.RewriteResult.mctx | Lean.Meta.Tactic.Rewrites | Lean.Meta.Rewrites.RewriteResult → Lean.MetavarContext | true |
DirectLimit.instCommRingOfRingHomClass | Mathlib.Algebra.Colimit.DirectLimit | {ι : Type u_2} →
[inst : Preorder ι] →
{G : ι → Type u_3} →
{T : ⦃i j : ι⦄ → i ≤ j → Type u_4} →
{f : (x x_1 : ι) → (h : x ≤ x_1) → T h} →
[inst_1 : (i j : ι) → (h : i ≤ j) → FunLike (T h) (G i) (G j)] →
[inst_2 : DirectedSystem G fun x1 x2 x3 => ⇑(f x1 x2 x3)] →
... | true |
Lean.initFn._@.Lean.ExtraModUses.447004708._hygCtx._hyg.2 | Lean.ExtraModUses | IO (Lean.SimplePersistentEnvExtension Lean.ExtraModUse (Lean.PHashSet Lean.ExtraModUse)) | false |
_private.Init.Data.SInt.Lemmas.0.Int8.le_iff_lt_or_eq._proof_1_4 | Init.Data.SInt.Lemmas | ∀ {a b : Int8}, ¬(a.toInt ≤ b.toInt ↔ a.toInt < b.toInt ∨ a.toInt = b.toInt) → False | false |
NormedGroup.toGroup | Mathlib.Analysis.Normed.Group.Defs | {E : Type u_8} → [self : NormedGroup E] → Group E | true |
Derivation.compAEval_eq | Mathlib.Algebra.Polynomial.Derivation | ∀ {R : Type u_1} {A : Type u_2} {M : Type u_3} [inst : CommSemiring R] [inst_1 : CommSemiring A] [inst_2 : Algebra R A]
[inst_3 : AddCommMonoid M] [inst_4 : Module A M] [inst_5 : Module R M] [inst_6 : IsScalarTower R A M] (a : A)
(d : Derivation R A M) (f : Polynomial R), (d.compAEval a) f = Polynomial.derivative f... | true |
IsPicardLindelof.mk | Mathlib.Analysis.ODE.PicardLindelof | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] {f : ℝ → E → E} {tmin tmax : ℝ} {t₀ : ↑(Set.Icc tmin tmax)} {x₀ : E}
{a r L K : NNReal},
(∀ t ∈ Set.Icc tmin tmax, LipschitzOnWith K (f t) (Metric.closedBall x₀ ↑a)) →
(∀ x ∈ Metric.closedBall x₀ ↑a, ContinuousOn (fun x_1 => f x_1 x) (Set.Icc tmin tmax)) →
(∀... | true |
_private.Mathlib.Tactic.Relation.Symm.0.Lean.Expr.relSidesIfSymm?.match_6 | Mathlib.Tactic.Relation.Symm | (motive : Option (Lean.Expr × Lean.Expr × Lean.Expr × Lean.Expr) → Sort u_1) →
(x : Option (Lean.Expr × Lean.Expr × Lean.Expr × Lean.Expr)) →
((fst lhs fst_1 rhs : Lean.Expr) → motive (some (fst, lhs, fst_1, rhs))) →
((x : Option (Lean.Expr × Lean.Expr × Lean.Expr × Lean.Expr)) → motive x) → motive x | false |
RingQuot.instMonoidWithZero._proof_7 | Mathlib.Algebra.RingQuot | ∀ {R : Type u_1} [inst : Semiring R] (r : R → R → Prop) (a : RingQuot r), 0 * a = 0 | false |
_private.Mathlib.Analysis.Convex.BetweenList.0.List.sbtw_triple._simp_1_6 | Mathlib.Analysis.Convex.BetweenList | ∀ {α : Sort u_1} {p : α → Prop} {a' : α}, (∀ (a : α), a = a' → p a) = p a' | false |
_private.Aesop.Search.ExpandSafePrefix.0.Aesop.expandFirstPrefixRapp | Aesop.Search.ExpandSafePrefix | {Q : Type} → [inst : Aesop.Queue Q] → Aesop.RappRef → Aesop.SafeExpansionM Q Unit | true |
Ring.natCast._inherited_default | Mathlib.Algebra.Ring.Defs | {R : Type u} → (R → R → R) → R → R → ℕ → R | false |
Lean.Meta.Grind.AC.EqData.noConfusionType | Lean.Meta.Tactic.Grind.AC.Eq | Sort u → Lean.Meta.Grind.AC.EqData → Lean.Meta.Grind.AC.EqData → Sort u | false |
Matrix.mulAction._proof_2 | Mathlib.LinearAlgebra.Matrix.Defs | ∀ {m : Type u_1} {n : Type u_2} {R : Type u_4} {α : Type u_3} [inst : Monoid R] [inst_1 : MulAction R α]
(b : Matrix m n α), 1 • b = b | false |
_private.Mathlib.Combinatorics.SetFamily.Shadow.0.Finset.mem_shadow_iterate_iff_exists_card._simp_1_2 | Mathlib.Combinatorics.SetFamily.Shadow | ∀ {α : Type u_1} {s : Finset α} {n : ℕ} [inst : DecidableEq α],
(s.card = n + 1) = ∃ a t, a ∉ t ∧ insert a t = s ∧ t.card = n | false |
SeparationQuotient.instAddGroup._proof_5 | Mathlib.Topology.Algebra.SeparationQuotient.Basic | ∀ {G : Type u_1} [inst : TopologicalSpace G] [inst_1 : AddGroup G] [inst_2 : IsTopologicalAddGroup G] (x : G) (n : ℕ),
SeparationQuotient.mk (n • x) = n • SeparationQuotient.mk x | false |
CategoryTheory.ComposableArrows.instIsIsoOfNatNatTwoδ₁Toδ₀ | Mathlib.CategoryTheory.ComposableArrows.Two | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {i j k : C} (f : i ⟶ j) (g : j ⟶ k) (fg : i ⟶ k)
(h : CategoryTheory.CategoryStruct.comp f g = fg) [CategoryTheory.IsIso f],
CategoryTheory.IsIso (CategoryTheory.ComposableArrows.twoδ₁Toδ₀ f g fg h) | true |
Lean.Grind.CommRing.Poly.mulC_nc.go._unsafe_rec | Init.Grind.Ring.CommSolver | Lean.Grind.CommRing.Poly → ℕ → Lean.Grind.CommRing.Poly → Lean.Grind.CommRing.Poly → Lean.Grind.CommRing.Poly | false |
CategoryTheory.Limits.MulticospanIndex.sections.property | Mathlib.CategoryTheory.Limits.Types.Multiequalizer | ∀ {J : CategoryTheory.Limits.MulticospanShape} {I : CategoryTheory.Limits.MulticospanIndex J (Type u)}
(self : I.sections) (r : J.R), I.fst r (self.val (J.fst r)) = I.snd r (self.val (J.snd r)) | true |
PrimeMultiset.coe_coePNatMonoidHom | Mathlib.Data.PNat.Factors | ⇑PrimeMultiset.coePNatMonoidHom = PrimeMultiset.toPNatMultiset | true |
_private.Lean.Meta.Tactic.Grind.0.Lean.initFn._@.Lean.Meta.Tactic.Grind.3036382584._hygCtx._hyg.2 | Lean.Meta.Tactic.Grind | IO Unit | false |
Submodule.LinearDisjoint.rank_le_one_of_commute_of_flat_of_self | Mathlib.LinearAlgebra.LinearDisjoint | ∀ {R : Type u} {S : Type v} [inst : CommRing R] [inst_1 : Ring S] [inst_2 : Algebra R S] {M : Submodule R S},
M.LinearDisjoint M → ∀ [Module.Flat R ↥M], (∀ (m n : ↥M), Commute ↑m ↑n) → Module.rank R ↥M ≤ 1 | true |
WithLp.fstₗ_apply | Mathlib.Analysis.Normed.Lp.ProdLp | ∀ (p : ENNReal) (𝕜 : Type u_1) (α : Type u_2) (β : Type u_3) [inst : Semiring 𝕜] [inst_1 : AddCommGroup α]
[inst_2 : AddCommGroup β] [inst_3 : Module 𝕜 α] [inst_4 : Module 𝕜 β] (x : WithLp p (α × β)),
(WithLp.fstₗ p 𝕜 α β) x = x.fst | true |
LindelofSpace | Mathlib.Topology.Compactness.Lindelof | (X : Type u_2) → [TopologicalSpace X] → Prop | true |
chudnovskySum._proof_1 | Mathlib.Analysis.Real.Pi.Chudnovsky | (11 + 1).AtLeastTwo | false |
Finset.prod_ite_index | Mathlib.Algebra.BigOperators.Group.Finset.Defs | ∀ {ι : Type u_1} {M : Type u_3} [inst : CommMonoid M] (p : Prop) [inst_1 : Decidable p] (s t : Finset ι) (f : ι → M),
∏ x ∈ if p then s else t, f x = if p then ∏ x ∈ s, f x else ∏ x ∈ t, f x | true |
Nat.strongRec._unsafe_rec | Batteries.Data.Nat.Basic | {motive : ℕ → Sort u_1} → ((n : ℕ) → ((m : ℕ) → m < n → motive m) → motive n) → (t : ℕ) → motive t | false |
CategoryTheory.Cokleisli.Adjunction.adj._proof_6 | Mathlib.CategoryTheory.Monad.Kleisli | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] (U : CategoryTheory.Comonad C)
{X : CategoryTheory.Cokleisli U} {Y x : C} (f : (CategoryTheory.Cokleisli.Adjunction.fromCokleisli U).obj X ⟶ Y)
(g : Y ⟶ x),
{ toFun := fun f => { of := f }, invFun := fun f => f.of, left_inv := ⋯, right_inv := ⋯ }
... | false |
OrderedFinpartition.partSize_pos | Mathlib.Analysis.Calculus.ContDiff.FaaDiBruno | ∀ {n : ℕ} (self : OrderedFinpartition n) (m : Fin self.length), 0 < self.partSize m | true |
Lean.Firefox.ProfileMeta.interval._default | Lean.Util.Profiler | Lean.Firefox.Milliseconds | false |
univLE_iff_exists_embedding | Mathlib.SetTheory.Cardinal.UnivLE | UnivLE.{u, v} ↔ Nonempty (Ordinal.{u} ↪ Ordinal.{v}) | true |
_private.Mathlib.LinearAlgebra.LinearIndependent.Basic.0.LinearMap.linearIndependent_iff._simp_1_1 | Mathlib.LinearAlgebra.LinearIndependent.Basic | ∀ {α : Type u_1} [inst : PartialOrder α] [inst_1 : OrderBot α] {a : α}, Disjoint a ⊥ = True | false |
_private.Std.Data.Iterators.Lemmas.Combinators.Monadic.FilterMap.0.Std.IterM.stepAsHetT_filterMapWithPostcondition._simp_1_1 | Std.Data.Iterators.Lemmas.Combinators.Monadic.FilterMap | ∀ {m : Type w → Type w'} [inst : Monad m] [LawfulMonad m] {α : Type v} {x y : Std.Iterators.HetT m α},
(x = y) =
∃ (h : x.Property = y.Property),
∀ (β : Type w) (f : (a : α) → x.Property a → m β), x.prun f = y.prun fun a ha => f a ⋯ | false |
SSet.Truncated.Path₁.ext_iff | Mathlib.AlgebraicTopology.SimplicialSet.Path | ∀ {X : SSet.Truncated 1} {n : ℕ} {x y : X.Path₁ n}, x = y ↔ x.vertex = y.vertex ∧ x.arrow = y.arrow | true |
LinearMap.norm_map_iff_inner_map_map | Mathlib.Analysis.InnerProductSpace.LinearMap | ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : RCLike 𝕜] [inst_1 : SeminormedAddCommGroup E] [inst_2 : InnerProductSpace 𝕜 E]
{E' : Type u_7} [inst_3 : SeminormedAddCommGroup E'] [inst_4 : InnerProductSpace 𝕜 E'] {F : Type u_9}
[inst_5 : FunLike F E E'] [LinearMapClass F 𝕜 E E'] (f : F),
(∀ (x : E), ‖f x‖ = ‖x‖) ↔ ... | true |
CategoryTheory.Equivalence.sheafCongrPrecoherent_inverse_obj_obj_obj | Mathlib.CategoryTheory.Sites.Coherent.Equivalence | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {D : Type u_2}
[inst_1 : CategoryTheory.Category.{v_2, u_2} D] [inst_2 : CategoryTheory.Precoherent C] (A : Type u_3)
[inst_3 : CategoryTheory.Category.{v_3, u_3} A] (e : C ≌ D)
(X : CategoryTheory.Sheaf (CategoryTheory.coherentTopology D) A) (X_1 : C... | true |
Finset.card_inter_smul | Mathlib.Combinatorics.Additive.Convolution | ∀ {G : Type u_1} [inst : Group G] [inst_1 : DecidableEq G] (A B : Finset G) (x : G),
(A ∩ x • B).card = A.convolution B⁻¹ x | true |
Submodule.torsionBySet_isTorsionBySet | Mathlib.Algebra.Module.Torsion.Basic | ∀ {R : Type u_1} {M : Type u_2} [inst : CommSemiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] (s : Set R),
Module.IsTorsionBySet R (↥(Submodule.torsionBySet R M s)) s | true |
CategoryTheory.AddMon.monMonoidal._proof_3 | Mathlib.CategoryTheory.Monoidal.Mon_ | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.MonoidalCategory C]
[inst_2 : CategoryTheory.BraidedCategory C] (X₁ X₂ : CategoryTheory.AddMon C),
CategoryTheory.MonoidalCategoryStruct.tensorHom (CategoryTheory.CategoryStruct.id X₁)
(CategoryTheory.CategoryStruct.id X₂)... | false |
SimplicialObject.Split.Hom.f | Mathlib.AlgebraicTopology.SimplicialObject.Split | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
{S₁ S₂ : SimplicialObject.Split C} → S₁.Hom S₂ → (n : ℕ) → S₁.s.N n ⟶ S₂.s.N n | true |
Filter.Eventually.and_frequently | Mathlib.Order.Filter.Basic | ∀ {α : Type u} {p q : α → Prop} {f : Filter α},
(∀ᶠ (x : α) in f, p x) → (∃ᶠ (x : α) in f, q x) → ∃ᶠ (x : α) in f, p x ∧ q x | true |
LatticeHom.fst | Mathlib.Order.Hom.Lattice | {α : Type u_2} → {β : Type u_3} → [inst : Lattice α] → [inst_1 : Lattice β] → LatticeHom (α × β) α | true |
PseudoMetric._sizeOf_inst | Mathlib.Topology.MetricSpace.BundledFun | (X : Type u_1) →
(R : Type u_2) →
{inst : Zero R} → {inst_1 : Add R} → {inst_2 : LE R} → [SizeOf X] → [SizeOf R] → SizeOf (PseudoMetric X R) | false |
Lean.Meta.Grind.instBEqEMatchTheoremKind.beq | Lean.Meta.Tactic.Grind.Extension | Lean.Meta.Grind.EMatchTheoremKind → Lean.Meta.Grind.EMatchTheoremKind → Bool | true |
PUnit.commGroup.eq_1 | Mathlib.Algebra.Group.PUnit | PUnit.commGroup =
{ mul := fun x x_1 => PUnit.unit, mul_assoc := PUnit.commGroup._proof_5, one := PUnit.unit,
one_mul := PUnit.commGroup._proof_6, mul_one := PUnit.commGroup._proof_7, npow_zero := PUnit.commGroup._proof_1,
npow_succ := PUnit.commGroup._proof_2, inv := fun x => PUnit.unit, div_eq_mul_inv := PU... | true |
Vector.mapFinIdxM._proof_7 | Init.Data.Vector.Basic | ∀ {β : Type u_1}, #[].size = #[].size | false |
Nat.div2_bit1 | Mathlib.Data.Nat.Bits | ∀ (n : ℕ), (2 * n + 1).div2 = n | true |
TotalComplexShape.symm.match_1 | Mathlib.Algebra.Homology.ComplexShapeSigns | {I₁ : Type u_2} →
{I₂ : Type u_1} → (motive : I₂ × I₁ → Sort u_3) → (x : I₂ × I₁) → ((i₂ : I₂) → (i₁ : I₁) → motive (i₂, i₁)) → motive x | false |
Batteries.PairingHeap.deleteMin | Batteries.Data.PairingHeap | {α : Type u} → {le : α → α → Bool} → Batteries.PairingHeap α le → Option (α × Batteries.PairingHeap α le) | true |
PProd | Init.Prelude | Sort u → Sort v → Sort (max (max 1 u) v) | true |
TrivSqZeroExt.addGroup | Mathlib.Algebra.TrivSqZeroExt.Basic | {R : Type u} → {M : Type v} → [AddGroup R] → [AddGroup M] → AddGroup (TrivSqZeroExt R M) | true |
GroupAlgebra.mul_average_left | Mathlib.RepresentationTheory.Invariants | ∀ (k : Type u_1) (G : Type u_2) [inst : CommSemiring k] [inst_1 : Group G] [inst_2 : Fintype G]
[inst_3 : Invertible ↑(Fintype.card G)] (g : G), (fun₀ | g => 1) * GroupAlgebra.average k G = GroupAlgebra.average k G | true |
Lean.Widget.eraseWidgetSpec | Lean.Widget.Commands | Lean.ParserDescr | true |
Quaternion.instDivisionRing._proof_8 | Mathlib.Algebra.Quaternion | ∀ {R : Type u_1} [inst : Field R] [inst_1 : LinearOrder R] [inst_2 : IsStrictOrderedRing R] (n : ℕ) (a : Quaternion R),
GroupWithZero.zpow (Int.negSucc n) a = (GroupWithZero.zpow (↑n.succ) a)⁻¹ | false |
_private.Init.Grind.Ring.CommSolver.0.Lean.Grind.CommRing.Expr.toPolyC.go.match_4.eq_7 | Init.Grind.Ring.CommSolver | ∀ (motive : Lean.Grind.CommRing.Expr → Sort u_1) (a : Lean.Grind.CommRing.Expr)
(h_1 : (k : ℤ) → motive (Lean.Grind.CommRing.Expr.num k))
(h_2 : (k : ℕ) → motive (Lean.Grind.CommRing.Expr.natCast k))
(h_3 : (k : ℤ) → motive (Lean.Grind.CommRing.Expr.intCast k))
(h_4 : (x : Lean.Grind.CommRing.Var) → motive (Lea... | true |
Semiring.toGrindSemiring._proof_12 | Mathlib.Algebra.Ring.GrindInstances | ∀ (α : Type u_1) [s : Semiring α] (n : ℕ), OfNat.ofNat (n + 2 + 1) = OfNat.ofNat (n + 2) + 1 | false |
HomologicalComplex.homologyπ_extendHomologyIso_inv_assoc | Mathlib.Algebra.Homology.Embedding.ExtendHomology | ∀ {ι : Type u_1} {ι' : Type u_2} {c : ComplexShape ι} {c' : ComplexShape ι'} {C : Type u_3}
[inst : CategoryTheory.Category.{v_1, u_3} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
[inst_2 : CategoryTheory.Limits.HasZeroObject C] (K : HomologicalComplex C c) (e : c.Embedding c') {j : ι} {j' : ι'}
(hj' : ... | true |
Bundle.TotalSpace.mk' | Mathlib.Data.Bundle | {B : Type u_1} → {E : B → Type u_3} → (F : Type u_4) → (x : B) → E x → Bundle.TotalSpace F E | true |
_private.Mathlib.Algebra.Lie.Nilpotent.0.LieModule.iterate_toEnd_mem_lowerCentralSeries._simp_1_1 | Mathlib.Algebra.Lie.Nilpotent | ∀ {R : Type u} {L : Type v} {M : Type w} [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : AddCommGroup M]
[inst_3 : Module R M] [inst_4 : LieRingModule L M] (x : M), (x ∈ ⊤) = True | false |
IsBaseChange.equiv._proof_2 | Mathlib.RingTheory.IsTensorProduct | ∀ {R : Type u_1} {S : Type u_2} [inst : CommSemiring R] [inst_1 : CommSemiring S] [inst_2 : Algebra R S],
SMulCommClass R S S | false |
_private.Mathlib.LinearAlgebra.Basis.VectorSpace.0.exists_basis_of_pairing_eq_zero._simp_1_3 | Mathlib.LinearAlgebra.Basis.VectorSpace | ∀ {R : Type u_1} {M : Type u_4} [inst : Ring R] [inst_1 : AddCommGroup M] [inst_2 : Module R M] {x y : M} {s : Set M},
(x ∈ Submodule.span R (insert y s)) = ∃ a, x + a • y ∈ Submodule.span R s | false |
«_aux_Mathlib_Algebra_Star_StarAlgHom___macroRules_term_→⋆ₐ__1» | Mathlib.Algebra.Star.StarAlgHom | Lean.Macro | false |
Unitization.instNeg | Mathlib.Algebra.Algebra.Unitization | {R : Type u_3} → {A : Type u_4} → [Neg R] → [Neg A] → Neg (Unitization R A) | true |
List.SortedGE.isChain | Mathlib.Data.List.Sort | ∀ {α : Type u_1} {l : List α} [inst : Preorder α], l.SortedGE → List.IsChain (fun x1 x2 => x1 ≥ x2) l | true |
Mathlib.Tactic.BicategoryLike.MonadMor₁.mk.noConfusion | Mathlib.Tactic.CategoryTheory.Coherence.Datatypes | {m : Type → Type} →
{P : Sort u} →
{id₁M : Mathlib.Tactic.BicategoryLike.Obj → m Mathlib.Tactic.BicategoryLike.Mor₁} →
{comp₁M :
Mathlib.Tactic.BicategoryLike.Mor₁ →
Mathlib.Tactic.BicategoryLike.Mor₁ → m Mathlib.Tactic.BicategoryLike.Mor₁} →
{id₁M' : Mathlib.Tactic.BicategoryL... | false |
HomologicalComplex.instHasColimitDiscreteWalkingPairCompPairEval | Mathlib.Algebra.Homology.HomologicalComplexBiprod | ∀ {C : Type u_1} {ι : Type u_2} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Preadditive C]
{c : ComplexShape ι} (K L : HomologicalComplex C c)
[∀ (i : ι), CategoryTheory.Limits.HasBinaryBiproduct (K.X i) (L.X i)] (i : ι),
CategoryTheory.Limits.HasColimit ((CategoryTheory.Limits.pair K L... | true |
_private.Lean.Meta.InferType.0.Lean.Meta.inferConstType | Lean.Meta.InferType | Lean.Name → List Lean.Level → Lean.MetaM Lean.Expr | true |
CategoryTheory.Endofunctor.Coalgebra.ctorIdx | Mathlib.CategoryTheory.Endofunctor.Algebra | {C : Type u} →
{inst : CategoryTheory.Category.{v, u} C} →
{F : CategoryTheory.Functor C C} → CategoryTheory.Endofunctor.Coalgebra F → ℕ | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.