name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
PositiveLinearMap.zero_apply | Mathlib.Algebra.Order.Module.PositiveLinearMap | ∀ {R : Type u_1} {E₁ : Type u_2} {E₂ : Type u_3} [inst : Semiring R] [inst_1 : AddCommMonoid E₁]
[inst_2 : PartialOrder E₁] [inst_3 : AddCommMonoid E₂] [inst_4 : PartialOrder E₂] [inst_5 : Module R E₁]
[inst_6 : Module R E₂] (x : E₁), 0 x = 0 | true |
_private.Mathlib.MeasureTheory.Function.Jacobian.0.exists_closed_cover_approximatesLinearOn_of_hasFDerivWithinAt._simp_1_1 | Mathlib.MeasureTheory.Function.Jacobian | ∀ {α : Type u} [inst : PseudoMetricSpace α] {x y : α} {ε : ℝ}, (y ∈ Metric.ball x ε) = (dist y x < ε) | false |
Metric.AreSeparated.subset_compl_right | Mathlib.Topology.MetricSpace.MetricSeparated | ∀ {X : Type u_1} [inst : PseudoEMetricSpace X] {s t : Set X}, Metric.AreSeparated s t → s ⊆ tᶜ | true |
Metric.PiNatEmbed.distDenseSeq | Mathlib.Topology.MetricSpace.PiNat | (X : Type u_3) → [inst : MetricSpace X] → [TopologicalSpace.SeparableSpace X] → ℕ → X → ↑unitInterval | true |
Aesop.IndexingMode.hyps.inj | Aesop.Index.Basic | ∀ {keys keys_1 : Array Lean.Meta.DiscrTree.Key},
Aesop.IndexingMode.hyps keys = Aesop.IndexingMode.hyps keys_1 → keys = keys_1 | true |
Std.TreeMap.Raw.unitOfList_cons | Std.Data.TreeMap.Raw.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {hd : α} {tl : List α},
Std.TreeMap.Raw.unitOfList (hd :: tl) cmp = (∅.insertIfNew hd ()).insertManyIfNewUnit tl | true |
Set.image_eq_range | Mathlib.Data.Set.Image | ∀ {α : Type u_1} {β : Type u_2} (f : α → β) (s : Set α), f '' s = Set.range fun x => f ↑x | true |
_private.Mathlib.Algebra.Order.AbsoluteValue.Basic.0.AbsoluteValue.nonpos_iff._simp_1_1 | Mathlib.Algebra.Order.AbsoluteValue.Basic | ∀ {α : Type u_1} [inst : PartialOrder α] {a b : α}, (a = b) = (a ≤ b ∧ b ≤ a) | false |
_private.Init.Data.List.Impl.0.List.filter.match_1.eq_1 | Init.Data.List.Impl | ∀ (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 |
IsCyclotomicExtension.fromZetaAut.eq_1 | Mathlib.NumberTheory.Cyclotomic.Gal | ∀ {n : ℕ} [inst : NeZero n] {K : Type u_1} [inst_1 : Field K] {L : Type u_2} {μ : L} [inst_2 : CommRing L]
[inst_3 : IsDomain L] (hμ : IsPrimitiveRoot μ n) [inst_4 : Algebra K L] [inst_5 : IsCyclotomicExtension {n} K L]
(h : Irreducible (Polynomial.cyclotomic n K)),
IsCyclotomicExtension.fromZetaAut hμ h = (IsCyclotomicExtension.autEquivPow L h).symm (ZMod.unitOfCoprime ⋯.choose ⋯) | true |
Batteries.Tactic.GeneralizeProofs.AState.casesOn | Batteries.Tactic.GeneralizeProofs | {motive : Batteries.Tactic.GeneralizeProofs.AState → Sort u} →
(t : Batteries.Tactic.GeneralizeProofs.AState) →
((generalizations : Array (Lean.Expr × Lean.Expr)) →
(propToProof : Lean.ExprMap Lean.Expr) →
motive { generalizations := generalizations, propToProof := propToProof }) →
motive t | false |
CategoryTheory.Square | Mathlib.CategoryTheory.Square | (C : Type u) → [CategoryTheory.Category.{v, u} C] → Type (max u v) | true |
MulEquiv.mulDissociated_preimage._simp_2 | Mathlib.Combinatorics.Additive.Dissociation | ∀ {α : Type u_1} {β : Type u_2} [inst : CommGroup α] [inst_1 : CommGroup β] {s : Set α} (e : β ≃* α),
MulDissociated (⇑e ⁻¹' s) = MulDissociated s | false |
_private.Lean.Meta.LazyDiscrTree.0.Lean.Meta.LazyDiscrTree.extractKeys.match_3 | Lean.Meta.LazyDiscrTree | {α : Type} →
(motive : MProd (Array α) (Lean.Meta.LazyDiscrTree α) → Sort u_1) →
(r : MProd (Array α) (Lean.Meta.LazyDiscrTree α)) →
((allExtracted : Array α) → (tree : Lean.Meta.LazyDiscrTree α) → motive ⟨allExtracted, tree⟩) → motive r | false |
Equiv.prodPProd_apply | Mathlib.Logic.Equiv.Prod | ∀ {α₂ : Sort u_3} {β₂ : Sort u_6} {α₁ : Type u_9} {β₁ : Type u_10} (ea : α₁ ≃ α₂) (eb : β₁ ≃ β₂) (a : α₁ × β₁),
(ea.prodPProd eb) a = ⟨ea a.1, eb a.2⟩ | true |
Std.IterM.Total.mk.injEq | Init.Data.Iterators.Consumers.Monadic.Total | ∀ {α : Type w} {m : Type w → Type w'} {β : Type w} (it it_1 : Std.IterM m β),
({ it := it } = { it := it_1 }) = (it = it_1) | true |
CategoryTheory.WithTerminal.down_id | Mathlib.CategoryTheory.WithTerminal.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X : C},
CategoryTheory.WithTerminal.down (CategoryTheory.CategoryStruct.id (CategoryTheory.WithTerminal.of X)) =
CategoryTheory.CategoryStruct.id X | true |
Lean.Lsp.instToJsonDocumentHighlightKind.match_1 | Lean.Data.Lsp.LanguageFeatures | (motive : Lean.Lsp.DocumentHighlightKind → Sort u_1) →
(x : Lean.Lsp.DocumentHighlightKind) →
(Unit → motive Lean.Lsp.DocumentHighlightKind.text) →
(Unit → motive Lean.Lsp.DocumentHighlightKind.read) →
(Unit → motive Lean.Lsp.DocumentHighlightKind.write) → motive x | false |
LinearMap.IsContPerfPair.casesOn | Mathlib.Topology.Algebra.Module.PerfectPairing | {R : Type u_1} →
{M : Type u_2} →
{N : Type u_3} →
[inst : CommRing R] →
[inst_1 : TopologicalSpace R] →
[inst_2 : AddCommGroup M] →
[inst_3 : Module R M] →
[inst_4 : TopologicalSpace M] →
[inst_5 : AddCommGroup N] →
[inst_6 : Module R N] →
[inst_7 : TopologicalSpace N] →
{p : M →ₗ[R] N →ₗ[R] R} →
{motive : p.IsContPerfPair → Sort u} →
(t : p.IsContPerfPair) →
((continuous_uncurry :
Continuous fun x =>
match x with
| (x, y) => (p x) y) →
(bijective_left : Function.Bijective fun x => { toLinearMap := p x, cont := ⋯ }) →
(bijective_right :
Function.Bijective fun y => { toLinearMap := p.flip y, cont := ⋯ }) →
motive ⋯) →
motive t | false |
HasDerivWithinAt.fun_finset_prod | Mathlib.Analysis.Calculus.Deriv.Mul | ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {x : 𝕜} {s : Set 𝕜} {ι : Type u_2} [inst_1 : DecidableEq ι]
{𝔸' : Type u_3} [inst_2 : NormedCommRing 𝔸'] [inst_3 : NormedAlgebra 𝕜 𝔸'] {u : Finset ι} {f : ι → 𝕜 → 𝔸'}
{f' : ι → 𝔸'},
(∀ i ∈ u, HasDerivWithinAt (f i) (f' i) s x) →
HasDerivWithinAt (fun x => ∏ i ∈ u, f i x) (∑ i ∈ u, (∏ j ∈ u.erase i, f j x) • f' i) s x | true |
Substring.Raw.next | Init.Data.String.Substring | Substring.Raw → String.Pos.Raw → String.Pos.Raw | true |
FirstOrder.Language.Theory.Imp | Mathlib.ModelTheory.Equivalence | {L : FirstOrder.Language} → {α : Type w} → {n : ℕ} → L.Theory → L.BoundedFormula α n → L.BoundedFormula α n → Prop | true |
List.sublist_append_of_sublist_right._simp_1 | Init.Data.List.Sublist | ∀ {α : Type u_1} {l l₂ l₁ : List α}, l.Sublist l₂ → l.Sublist (l₁ ++ l₂) = True | false |
spectrum.pow_norm_pow_one_div_tendsto_nhds_spectralRadius | Mathlib.Analysis.Normed.Algebra.GelfandFormula | ∀ {A : Type u_2} [inst : NormedRing A] [inst_1 : NormedAlgebra ℂ A] [CompleteSpace A] (a : A),
Filter.Tendsto (fun n => ENNReal.ofReal (‖a ^ n‖ ^ (1 / ↑n))) Filter.atTop (nhds (spectralRadius ℂ a)) | true |
Set.centralizer_empty | Mathlib.Algebra.Group.Center | ∀ {M : Type u_1} [inst : Mul M], ∅.centralizer = ⊤ | true |
HomologicalComplex.xPrevIso.eq_1 | Mathlib.Algebra.Homology.HomologicalComplex | ∀ {ι : Type u_1} {V : Type u} [inst : CategoryTheory.Category.{v, u} V]
[inst_1 : CategoryTheory.Limits.HasZeroMorphisms V] {c : ComplexShape ι} (C : HomologicalComplex V c) {i j : ι}
(r : c.Rel i j), C.xPrevIso r = CategoryTheory.eqToIso ⋯ | true |
MvPolynomial | Mathlib.Algebra.MvPolynomial.Basic | Type u_1 → (R : Type u_2) → [CommSemiring R] → Type (max u_2 u_1) | true |
Quot.lift | Init.Prelude | {α : Sort u} → {r : α → α → Prop} → {β : Sort v} → (f : α → β) → (∀ (a b : α), r a b → f a = f b) → Quot r → β | true |
_private.Mathlib.Algebra.Homology.HomotopyCategory.MappingCone.0.CochainComplex.mappingCone.liftCochain_v_descCochain_v._proof_1_2 | Mathlib.Algebra.Homology.HomotopyCategory.MappingCone | ∀ {n m n' m' : ℤ},
n + 1 = m → m' + 1 = n' → ∀ (p₁ p₂ p₃ : ℤ), p₁ + n = p₂ → p₂ + n' = p₃ → ∀ (q : ℤ), p₁ + m = q → q + m' = p₃ | false |
ISize.ofInt_neg | Init.Data.SInt.Lemmas | ∀ (a : ℤ), ISize.ofInt (-a) = -ISize.ofInt a | true |
Lean.Compiler.LCNF.LetValue.pap.noConfusion | Lean.Compiler.LCNF.Basic | {pu : Lean.Compiler.LCNF.Purity} →
{P : Sort u} →
{fn : Lean.Name} →
{args : Array (Lean.Compiler.LCNF.Arg pu)} →
{h : autoParam (pu = Lean.Compiler.LCNF.Purity.impure) Lean.Compiler.LCNF.LetValue._auto_15} →
{fn' : Lean.Name} →
{args' : Array (Lean.Compiler.LCNF.Arg pu)} →
{h' : autoParam (pu = Lean.Compiler.LCNF.Purity.impure) Lean.Compiler.LCNF.LetValue._auto_15} →
Lean.Compiler.LCNF.LetValue.pap fn args h = Lean.Compiler.LCNF.LetValue.pap fn' args' h' →
(fn = fn' → args ≍ args' → P) → P | false |
List.maxOn?_id | Init.Data.List.MinMaxOn | ∀ {α : Type u_1} [inst : Max α] [inst_1 : LE α] [inst_2 : DecidableLE α] [Std.LawfulOrderLeftLeaningMax α]
{xs : List α}, List.maxOn? id xs = xs.max? | true |
TopCat.instFaithfulUliftFunctor | Mathlib.Topology.Category.TopCat.ULift | TopCat.uliftFunctor.Faithful | true |
_private.Lean.Meta.Tactic.Grind.Arith.CommRing.Poly.0.Lean.Grind.CommRing.Poly.gcdCoeffs.go._sunfold | Lean.Meta.Tactic.Grind.Arith.CommRing.Poly | Lean.Grind.CommRing.Poly → ℕ → ℕ | false |
ZMod.AddAutEquivUnits._proof_2 | Mathlib.Data.ZMod.Aut | ∀ (n : ℕ), IsDedekindFiniteMonoid (ZMod n) | false |
_private.Lean.Elab.Term.TermElabM.0.Lean.Elab.Term.withRestoreOrSaveFull.match_1 | Lean.Elab.Term.TermElabM | (motive :
Option (Lean.Language.SyntaxGuarded (Lean.Language.SnapshotTask Lean.Elab.Tactic.TacticParsedSnapshot)) →
Sort u_1) →
(x : Option (Lean.Language.SyntaxGuarded (Lean.Language.SnapshotTask Lean.Elab.Tactic.TacticParsedSnapshot))) →
((old : Lean.Language.SyntaxGuarded (Lean.Language.SnapshotTask Lean.Elab.Tactic.TacticParsedSnapshot)) →
motive (some old)) →
((x : Option (Lean.Language.SyntaxGuarded (Lean.Language.SnapshotTask Lean.Elab.Tactic.TacticParsedSnapshot))) →
motive x) →
motive x | false |
MeasureTheory.SignedMeasure.im_toComplexMeasure | Mathlib.MeasureTheory.Measure.Complex | ∀ {α : Type u_1} {m : MeasurableSpace α} (s t : MeasureTheory.SignedMeasure α),
MeasureTheory.ComplexMeasure.im (s.toComplexMeasure t) = t | true |
LatticeHom.dual._proof_1 | Mathlib.Order.Hom.Lattice | ∀ {α : Type u_1} {β : Type u_2} [inst : Lattice α] [inst_1 : Lattice β],
Function.LeftInverse (fun f => { toSupHom := SupHom.dual.symm f.toInfHom, map_inf' := ⋯ }) fun f =>
{ toSupHom := InfHom.dual f.toInfHom, map_inf' := ⋯ } | false |
instBEqAlignment | Mathlib.Util.FormatTable | BEq Alignment | true |
UInt16.reduceLE._regBuiltin.UInt16.reduceLE.declare_1._@.Lean.Meta.Tactic.Simp.BuiltinSimprocs.UInt.1661162788._hygCtx._hyg.167 | Lean.Meta.Tactic.Simp.BuiltinSimprocs.UInt | IO Unit | false |
Polynomial.support_C | Mathlib.Algebra.Polynomial.Basic | ∀ {R : Type u} [inst : Semiring R] {a : R}, a ≠ 0 → (Polynomial.C a).support = {0} | true |
CategoryTheory.unmop_comp | Mathlib.CategoryTheory.Monoidal.Opposite | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {X Y Z : Cᴹᵒᵖ} {f : X ⟶ Y} {g : Y ⟶ Z},
(CategoryTheory.CategoryStruct.comp f g).unmop = CategoryTheory.CategoryStruct.comp f.unmop g.unmop | true |
CategoryTheory.Localization.instLifting₃Lift₃ | Mathlib.CategoryTheory.Localization.Trifunctor | {C₁ : Type u_1} →
{C₂ : Type u_2} →
{C₃ : Type u_3} →
{D₁ : Type u_6} →
{D₂ : Type u_7} →
{D₃ : Type u_8} →
{E : Type u_13} →
[inst : CategoryTheory.Category.{v_1, u_1} C₁] →
[inst_1 : CategoryTheory.Category.{v_2, u_2} C₂] →
[inst_2 : CategoryTheory.Category.{v_3, u_3} C₃] →
[inst_3 : CategoryTheory.Category.{v_4, u_6} D₁] →
[inst_4 : CategoryTheory.Category.{v_5, u_7} D₂] →
[inst_5 : CategoryTheory.Category.{v_6, u_8} D₃] →
[inst_6 : CategoryTheory.Category.{v_13, u_13} E] →
(F : CategoryTheory.Functor C₁ (CategoryTheory.Functor C₂ (CategoryTheory.Functor C₃ E))) →
{W₁ : CategoryTheory.MorphismProperty C₁} →
{W₂ : CategoryTheory.MorphismProperty C₂} →
{W₃ : CategoryTheory.MorphismProperty C₃} →
(hF : W₁.IsInvertedBy₃ W₂ W₃ F) →
(L₁ : CategoryTheory.Functor C₁ D₁) →
(L₂ : CategoryTheory.Functor C₂ D₂) →
(L₃ : CategoryTheory.Functor C₃ D₃) →
[inst_7 : L₁.IsLocalization W₁] →
[inst_8 : L₂.IsLocalization W₂] →
[inst_9 : L₃.IsLocalization W₃] →
[inst_10 : W₁.ContainsIdentities] →
[inst_11 : W₂.ContainsIdentities] →
[inst_12 : W₃.ContainsIdentities] →
CategoryTheory.Localization.Lifting₃ L₁ L₂ L₃ W₁ W₂ W₃ F
(CategoryTheory.Localization.lift₃ F hF L₁ L₂ L₃) | true |
Std.ExtDTreeMap.Const.insertManyIfNewUnit_cons | Std.Data.ExtDTreeMap.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t : Std.ExtDTreeMap α (fun x => Unit) cmp} [inst : Std.TransCmp cmp]
{l : List α} {k : α},
Std.ExtDTreeMap.Const.insertManyIfNewUnit t (k :: l) =
Std.ExtDTreeMap.Const.insertManyIfNewUnit (t.insertIfNew k ()) l | true |
_private.Mathlib.Combinatorics.Matroid.Basic.0.Matroid.ground_diff_subset_ground | Mathlib.Combinatorics.Matroid.Basic | ∀ {α : Type u_1} {M : Matroid α} {X : Set α}, M.E \ X ⊆ M.E | true |
Sym2.Mem.decidable._proof_1 | Mathlib.Data.Sym.Sym2 | ∀ {α : Type u_1} (x a b : α), Subsingleton (Decidable (x ∈ s(a, b))) | false |
Lean.Order.FlatOrder.rel.rec | Init.Internal.Order.Basic | ∀ {α : Sort u} {b : α} {motive : (x y : Lean.Order.FlatOrder b) → x.rel y → Prop},
(∀ {x : Lean.Order.FlatOrder b}, motive b x ⋯) →
(∀ {x : Lean.Order.FlatOrder b}, motive x x ⋯) → ∀ {x y : Lean.Order.FlatOrder b} (t : x.rel y), motive x y t | false |
PiTensorProduct.instAddCommGroup | Mathlib.LinearAlgebra.PiTensorProduct | {ι : Type u_1} →
{R : Type u_2} →
[inst : CommRing R] →
{s : ι → Type u_3} →
[inst_1 : (i : ι) → AddCommGroup (s i)] →
[inst_2 : (i : ι) → Module R (s i)] → AddCommGroup (PiTensorProduct R fun i => s i) | true |
_private.Lean.Server.FileWorker.SignatureHelp.0.Lean.Server.FileWorker.SignatureHelp.lineCommentPosition? | Lean.Server.FileWorker.SignatureHelp | (s : String) → Option s.Pos | true |
CategoryTheory.MorphismProperty.Comma.mapRight | Mathlib.CategoryTheory.MorphismProperty.Comma | {A : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} A] →
{B : Type u_2} →
[inst_1 : CategoryTheory.Category.{v_2, u_2} B] →
{T : Type u_3} →
[inst_2 : CategoryTheory.Category.{v_3, u_3} T] →
(L : CategoryTheory.Functor A T) →
{P : CategoryTheory.MorphismProperty T} →
{Q : CategoryTheory.MorphismProperty A} →
{W : CategoryTheory.MorphismProperty B} →
[inst_3 : Q.IsMultiplicative] →
[inst_4 : W.IsMultiplicative] →
{R₁ R₂ : CategoryTheory.Functor B T} →
(r : R₁ ⟶ R₂) →
(∀ (X : CategoryTheory.MorphismProperty.Comma L R₁ P Q W),
P (CategoryTheory.CategoryStruct.comp X.hom (r.app X.right))) →
CategoryTheory.Functor (CategoryTheory.MorphismProperty.Comma L R₁ P Q W)
(CategoryTheory.MorphismProperty.Comma L R₂ P Q W) | true |
TopologicalSpace.PositiveCompacts.coe_toCompacts | Mathlib.Topology.Sets.Compacts | ∀ {α : Type u_1} [inst : TopologicalSpace α] (s : TopologicalSpace.PositiveCompacts α), ↑s.toCompacts = ↑s | true |
PerfectClosure.instCommRing._proof_13 | Mathlib.FieldTheory.PerfectClosure | ∀ (K : Type u_1) [inst : CommRing K] (p : ℕ) [inst_1 : Fact (Nat.Prime p)] [inst_2 : CharP K p], ↑0 = 0 | false |
Sum.elimZeroLeft | Mathlib.Algebra.Module.LinearMap.Basic | {ι : Type u_6} → {κ : Type u_7} → {R : Type u_8} → [inst : Semiring R] → (ι → R) →ₗ[R] κ ⊕ ι → R | true |
Filter.seq_eq_filter_seq | Mathlib.Order.Filter.Map | ∀ {α β : Type u} (f : Filter (α → β)) (g : Filter α), f <*> g = f.seq g | true |
Fin2.last._unsafe_rec | Mathlib.Data.Fin.Fin2 | {n : ℕ} → Fin2 (n + 1) | false |
MeasureTheory.eLpNorm_count_lt_top | Mathlib.MeasureTheory.Function.LpSeminorm.Count | ∀ {α : Type u_1} {ε : Type u_2} [inst : MeasurableSpace α] [MeasurableSingletonClass α] [inst_2 : TopologicalSpace ε]
[inst_3 : ContinuousENorm ε] {f : α → ε} {p : ENNReal} [Finite α],
p ≠ 0 → (MeasureTheory.eLpNorm f p MeasureTheory.Measure.count < ⊤ ↔ ∀ (i : α), ‖f i‖ₑ < ⊤) | true |
_private.Mathlib.Data.Bool.Count.0.List.IsChain.count_not_le_count_add_one._proof_1_2 | Mathlib.Data.Bool.Count | ∀ (b x : Bool) (l : List Bool),
List.count b (x :: l) + 2 ≤ (List.filter (fun x => decide (x = !b)) (x :: l)).length →
List.count b (x :: l) + 1 < (List.findIdxs (fun x => decide (x = !b)) (x :: l)).length | false |
_private.Mathlib.Topology.UniformSpace.Ultra.Basic.0.IsTransitiveRel.comp_subset_self.match_1_1 | Mathlib.Topology.UniformSpace.Ultra.Basic | ∀ {X : Type u_1} {s : SetRel X X} (fst snd : X) (motive : (fst, snd) ∈ s.comp s → Prop) (x : (fst, snd) ∈ s.comp s),
(∀ (w : X) (hxz : (fst, w) ∈ s) (hzy : (w, snd) ∈ s), motive ⋯) → motive x | false |
WellFoundedLT.conditionallyCompleteLinearOrderBot._proof_1 | Mathlib.Order.ConditionallyCompleteLattice.Defs | ∀ (α : Type u_1) [i₁ : LinearOrder α] [h : WellFoundedLT α], WellFounded fun x1 x2 => x1 < x2 | false |
CategoryTheory.SmallObject.SuccStruct.iterationFunctor | Mathlib.CategoryTheory.SmallObject.TransfiniteIteration | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
CategoryTheory.SmallObject.SuccStruct C →
(J : Type w) →
[inst_1 : LinearOrder J] →
[OrderBot J] →
[SuccOrder J] →
[WellFoundedLT J] → [CategoryTheory.Limits.HasIterationOfShape J C] → CategoryTheory.Functor J C | true |
Lean.Compiler.LCNF.PullLetDecls.withNewScope | Lean.Compiler.LCNF.PullLetDecls | {α : Type} → Lean.Compiler.LCNF.PullLetDecls.PullM α → Lean.Compiler.LCNF.PullLetDecls.PullM α | true |
WithCStarModule.zero_fst | Mathlib.Analysis.CStarAlgebra.Module.Synonym | ∀ {A : Type u_2} {E : Type u_3} {F : Type u_4} [inst : AddCommGroup E] [inst_1 : AddCommGroup F], 0.1 = 0 | true |
Lean.initFn._@.Lean.Compiler.ExternAttr.4197872175._hygCtx._hyg.2 | Lean.Compiler.ExternAttr | IO (Lean.ParametricAttribute Lean.ExternAttrData) | false |
Turing.ToPartrec.instDecidableEqCode.decEq._proof_38 | Mathlib.Computability.TuringMachine.Config | ∀ (a a_1 : Turing.ToPartrec.Code), ¬a.case a_1 = Turing.ToPartrec.Code.succ | false |
_private.Lean.Meta.Tactic.Grind.Arith.Cutsat.MBTC.0.Lean.Meta.Grind.Arith.Cutsat.getAssignmentExt?.match_10 | Lean.Meta.Tactic.Grind.Arith.Cutsat.MBTC | (motive : Option Lean.Meta.Grind.Arith.Cutsat.ToIntTermInfo → Sort u_1) →
(x : Option Lean.Meta.Grind.Arith.Cutsat.ToIntTermInfo) →
((info : Lean.Meta.Grind.Arith.Cutsat.ToIntTermInfo) → motive (some info)) →
((x : Option Lean.Meta.Grind.Arith.Cutsat.ToIntTermInfo) → motive x) → motive x | false |
NonUnitalSubsemiring.center.instNonUnitalCommSemiring._proof_4 | Mathlib.RingTheory.NonUnitalSubsemiring.Basic | ∀ (R : Type u_1) [inst : NonUnitalNonAssocSemiring R] (a : ↥(NonUnitalSubsemiring.center R)), a * 0 = 0 | false |
Equiv.symm_comp_eq | Mathlib.Logic.Equiv.Defs | ∀ {α : Sort u_1} {β : Sort u_2} {γ : Sort u_3} (e : α ≃ β) (f : γ → α) (g : γ → β), ⇑e.symm ∘ g = f ↔ g = ⇑e ∘ f | true |
AlgEquiv.map_mul' | Mathlib.Algebra.Algebra.Equiv | ∀ {R : Type u} {A : Type v} {B : Type w} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Semiring B]
[inst_3 : Algebra R A] [inst_4 : Algebra R B] (self : A ≃ₐ[R] B) (x y : A),
self.toFun (x * y) = self.toFun x * self.toFun y | true |
HasProd.sum | Mathlib.Topology.Algebra.InfiniteSum.Constructions | ∀ {α : Type u_4} {β : Type u_5} {M : Type u_6} [inst : CommMonoid M] [inst_1 : TopologicalSpace M] [ContinuousMul M]
{f : α ⊕ β → M} {a b : M}, HasProd (f ∘ Sum.inl) a → HasProd (f ∘ Sum.inr) b → HasProd f (a * b) | true |
Equiv.Perm.SameCycle.of_zpow_right | Mathlib.GroupTheory.Perm.Cycle.Basic | ∀ {α : Type u_2} {f : Equiv.Perm α} {x y : α} {n : ℤ}, f.SameCycle x ((f ^ n) y) → f.SameCycle x y | true |
WithLp.instProdT0Space | Mathlib.Analysis.Normed.Lp.ProdLp | ∀ (p : ENNReal) (α : Type u_2) (β : Type u_3) [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β] [T0Space α]
[T0Space β], T0Space (WithLp p (α × β)) | true |
Polynomial.natSepDegree_X_sub_C_pow | Mathlib.FieldTheory.SeparableDegree | ∀ {F : Type u} [inst : Field F] {x : F} {n : ℕ},
((Polynomial.X - Polynomial.C x) ^ n).natSepDegree = if n = 0 then 0 else 1 | true |
List.head?_dropWhile_not.match_1 | Init.Data.List.TakeDrop | {α : Type u_1} →
(motive : Option α → Sort u_2) → (x : Option α) → ((x : α) → motive (some x)) → (Unit → motive none) → motive x | false |
CategoryTheory.Pseudofunctor.DescentData.Hom.noConfusionType | Mathlib.CategoryTheory.Sites.Descent.DescentData | Sort u_1 →
{C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{F : CategoryTheory.Pseudofunctor (CategoryTheory.LocallyDiscrete Cᵒᵖ) CategoryTheory.Cat} →
{ι : Type t} →
{S : C} →
{X : ι → C} →
{f : (i : ι) → X i ⟶ S} →
{D₁ D₂ : F.DescentData f} →
D₁.Hom D₂ →
{C' : Type u} →
[inst' : CategoryTheory.Category.{v, u} C'] →
{F' : CategoryTheory.Pseudofunctor (CategoryTheory.LocallyDiscrete C'ᵒᵖ) CategoryTheory.Cat} →
{ι' : Type t} →
{S' : C'} →
{X' : ι' → C'} →
{f' : (i : ι') → X' i ⟶ S'} → {D₁' D₂' : F'.DescentData f'} → D₁'.Hom D₂' → Sort u_1 | false |
AddMonoidAlgebra.singleAddHom_apply | Mathlib.Algebra.MonoidAlgebra.Defs | ∀ {R : Type u_1} {M : Type u_4} [inst : Semiring R] (m : M) (r : R),
(AddMonoidAlgebra.singleAddHom m) r = AddMonoidAlgebra.single m r | true |
Relation.SymmGen.trans_antisymmRel | Mathlib.Order.Antisymmetrization | ∀ {α : Type u_1} {a b c : α} [inst : Preorder α],
Relation.SymmGen (fun x1 x2 => x1 ≤ x2) a b →
AntisymmRel (fun x1 x2 => x1 ≤ x2) b c → Relation.SymmGen (fun x1 x2 => x1 ≤ x2) a c | true |
ContinuousLinearMap.hasMFDerivAt | Mathlib.Geometry.Manifold.MFDeriv.SpecificFunctions | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {E' : Type u_5} [inst_3 : NormedAddCommGroup E'] [inst_4 : NormedSpace 𝕜 E']
(f : E →L[𝕜] E') {x : E}, HasMFDerivAt (modelWithCornersSelf 𝕜 E) (modelWithCornersSelf 𝕜 E') (⇑f) x f | true |
Std.Tactic.BVDecide.BVExpr.eval_const | Std.Tactic.BVDecide.Bitblast.BVExpr.Basic | ∀ {assign : Std.Tactic.BVDecide.BVExpr.Assignment} {w : ℕ} {val : BitVec w},
Std.Tactic.BVDecide.BVExpr.eval assign (Std.Tactic.BVDecide.BVExpr.const val) = val | true |
CategoryTheory.ObjectProperty.limitsClosure.of_mem | Mathlib.CategoryTheory.ObjectProperty.LimitsClosure | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {P : CategoryTheory.ObjectProperty C} {α : Type t}
{J : α → Type u'} [inst_1 : (a : α) → CategoryTheory.Category.{v', u'} (J a)] (X : C), P X → P.limitsClosure J X | true |
zero_lt_one | Mathlib.Algebra.Order.ZeroLEOne | ∀ {α : Type u_1} [inst : Zero α] [inst_1 : One α] [inst_2 : PartialOrder α] [ZeroLEOneClass α] [NeZero 1], 0 < 1 | true |
AddCircle.openPartialHomeomorphCoe._proof_10 | Mathlib.Topology.Instances.AddCircle.Defs | ∀ {𝕜 : Type u_1} [inst : AddCommGroup 𝕜] (p : 𝕜) [inst_1 : LinearOrder 𝕜] (a : 𝕜) [inst_2 : TopologicalSpace 𝕜],
ContinuousOn (⇑(QuotientAddGroup.mk' (AddSubgroup.zmultiples p))) (Set.Ioo a (a + p)) | false |
TensorProduct.AlgebraTensorModule.homTensorHomMap | Mathlib.LinearAlgebra.TensorProduct.Tower | (R : Type uR) →
(A : Type uA) →
(B : Type uB) →
(M : Type uM) →
(N : Type uN) →
(P : Type uP) →
(Q : Type uQ) →
[inst : CommSemiring R] →
[inst_1 : Semiring A] →
[inst_2 : Semiring B] →
[inst_3 : Algebra R A] →
[inst_4 : Algebra R B] →
[inst_5 : AddCommMonoid M] →
[inst_6 : Module R M] →
[inst_7 : Module A M] →
[inst_8 : IsScalarTower R A M] →
[inst_9 : AddCommMonoid N] →
[inst_10 : Module R N] →
[inst_11 : AddCommMonoid P] →
[inst_12 : Module R P] →
[inst_13 : Module A P] →
[inst_14 : IsScalarTower R A P] →
[inst_15 : AddCommMonoid Q] →
[inst_16 : Module R Q] →
[inst_17 : Module B P] →
[inst_18 : IsScalarTower R B P] →
[inst_19 : SMulCommClass A B P] →
TensorProduct R (M →ₗ[A] P) (N →ₗ[R] Q) →ₗ[B]
TensorProduct R M N →ₗ[A] TensorProduct R P Q | true |
AlgebraicGeometry.IsLocalIso.eq_iInf | Mathlib.AlgebraicGeometry.Morphisms.LocalIso | @AlgebraicGeometry.IsLocalIso = ⨅ P, ⨅ (_ : P.ContainsIdentities), ⨅ (_ : AlgebraicGeometry.IsZariskiLocalAtSource P), P | true |
_private.Mathlib.RingTheory.Polynomial.Resultant.Basic.0.Polynomial.resultant_eq_prod_roots_sub._simp_1_3 | Mathlib.RingTheory.Polynomial.Resultant.Basic | ∀ {R : Type u} [inst : Ring R] {p q : Polynomial R}, q.Monic → (p %ₘ q = 0) = (q ∣ p) | false |
SSet.PtSimplex.MulStruct.δ_castSucc_castSucc_map | Mathlib.AlgebraicTopology.SimplicialSet.KanComplex.MulStruct | ∀ {X : SSet} {n : ℕ} {x : X.obj (Opposite.op (SimplexCategory.mk 0))} {f g fg : X.PtSimplex n x} {i : Fin n}
(self : f.MulStruct g fg i),
CategoryTheory.CategoryStruct.comp (SSet.stdSimplex.δ i.castSucc.castSucc) self.map = g.map | true |
Std.instNonemptySync_1 | Std.Sync.Channel | ∀ {α : Type}, Nonempty (Std.Channel.Sync α) | true |
Polynomial.fiberEquivQuotient | Mathlib.RingTheory.LocalRing.ResidueField.Polynomial | {R : Type u_1} →
{S : Type u_2} →
[inst : CommRing R] →
[inst_1 : CommRing S] →
[inst_2 : Algebra R S] →
(f : Polynomial R →ₐ[R] S) →
Function.Surjective ⇑f →
(p : Ideal R) →
[inst_3 : p.IsPrime] →
p.Fiber S ≃ₐ[p.ResidueField]
Polynomial p.ResidueField ⧸
Ideal.map (Polynomial.mapRingHom (algebraMap R p.ResidueField)) (RingHom.ker ↑f) | true |
_private.Mathlib.Data.EReal.Operations.0.EReal.le_sub_iff_add_le._simp_1_2 | Mathlib.Data.EReal.Operations | ∀ {α : Type u} [inst : LE α] [inst_1 : OrderBot α] {a : α}, (⊥ ≤ a) = True | false |
Lean.Lsp.instToJsonReferenceContext.toJson | Lean.Data.Lsp.LanguageFeatures | Lean.Lsp.ReferenceContext → Lean.Json | true |
LeanSearchClient.just_loogle_cmd | LeanSearchClient.LoogleSyntax | Lean.ParserDescr | true |
_private.Mathlib.RepresentationTheory.Homological.GroupHomology.LowDegree.0.groupHomology.mkH1OfIsTrivial._simp_1 | Mathlib.RepresentationTheory.Homological.GroupHomology.LowDegree | ∀ {M : Type u_4} {N : Type u_5} {F : Type u_9} [inst : Add M] [inst_1 : Add N] [inst_2 : FunLike F M N]
[AddHomClass F M N] (f : F) (x y : M), f x + f y = f (x + y) | false |
AddOreLocalization.addOreSetComm_oreSubtra | Mathlib.GroupTheory.OreLocalization.OreSet | ∀ {R : Type u_2} [inst : AddCommMonoid R] (S : AddSubmonoid R) (r : R) (s : ↥S), AddOreLocalization.oreSubtra r s = s | true |
Complex.exp_neg | Mathlib.Analysis.Complex.Exponential | ∀ (x : ℂ), Complex.exp (-x) = (Complex.exp x)⁻¹ | true |
RatFunc.num_mul_eq_mul_denom_iff | Mathlib.FieldTheory.RatFunc.Basic | ∀ {K : Type u} [inst : Field K] {x : RatFunc K} {p q : Polynomial K},
q ≠ 0 →
(x.num * q = p * x.denom ↔
x = (algebraMap (Polynomial K) (RatFunc K)) p / (algebraMap (Polynomial K) (RatFunc K)) q) | true |
Std.TreeMap.Raw.Equiv.insertIfNew | Std.Data.TreeMap.Raw.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t₁ t₂ : Std.TreeMap.Raw α β cmp} [Std.TransCmp cmp],
t₁.WF → t₂.WF → t₁.Equiv t₂ → ∀ (k : α) (v : β), (t₁.insertIfNew k v).Equiv (t₂.insertIfNew k v) | true |
Condensed.isoFinYoneda._proof_3 | Mathlib.Condensed.Discrete.Colimit | ∀ (F : CategoryTheory.Functor Profiniteᵒᵖ (Type (u_1 + 1))) [inst : CategoryTheory.Limits.PreservesFiniteProducts F]
{X Y : FintypeCatᵒᵖ} (x : X ⟶ Y),
CategoryTheory.CategoryStruct.comp ((FintypeCat.toProfinite.op.comp F).map x)
((fun X => Condensed.isoFinYonedaComponents F (FintypeCat.toProfinite.obj (Opposite.unop X))) Y).hom =
CategoryTheory.CategoryStruct.comp
((fun X => Condensed.isoFinYonedaComponents F (FintypeCat.toProfinite.obj (Opposite.unop X))) X).hom
((Condensed.finYoneda F).map x) | false |
Prod.instOmegaCompletePartialOrder._proof_2 | Mathlib.Order.OmegaCompletePartialOrder | ∀ {α : Type u_1} {β : Type u_2} [inst : OmegaCompletePartialOrder α] [inst_1 : OmegaCompletePartialOrder β]
(x : OmegaCompletePartialOrder.Chain (α × β)) (x_1 : α × β),
(∀ (i : ℕ), x i ≤ x_1) → (Prod.ωSupImpl x).1 ≤ x_1.1 ∧ (Prod.ωSupImpl x).2 ≤ x_1.2 | false |
_private.Batteries.Data.String.Lemmas.0.String.Pos.Raw.extract.go₁_cons_addChar._simp_1_4 | Batteries.Data.String.Lemmas | ∀ {x y : String.Pos.Raw}, (x = y) = (x.byteIdx = y.byteIdx) | false |
VonNeumannAlgebra.mem_commutant_iff._simp_1 | Mathlib.Analysis.VonNeumannAlgebra.Basic | ∀ {H : Type u} [inst : NormedAddCommGroup H] [inst_1 : InnerProductSpace ℂ H] [inst_2 : CompleteSpace H]
{S : VonNeumannAlgebra H} {z : H →L[ℂ] H}, (z ∈ S.commutant) = ∀ g ∈ S, g * z = z * g | false |
Nucleus.instHImp._proof_7 | Mathlib.Order.Nucleus | ∀ {X : Type u_1} [inst : Order.Frame X] (m n : Nucleus X) (y : X), m (m y ⇨ n y) ⇨ n (m y ⇨ n y) = m y ⇨ n y | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.