name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
TopologicalAddGroup.IsSES.pushforward_def | Mathlib.MeasureTheory.Measure.Haar.Extension | ∀ {A : Type u_1} {B : Type u_2} {C : Type u_3} {E : Type u_4} [inst : AddGroup A] [inst_1 : AddGroup B]
[inst_2 : AddGroup C] [inst_3 : TopologicalSpace A] [inst_4 : TopologicalSpace B] [inst_5 : TopologicalSpace C]
{φ : A →+ B} {ψ : B →+ C} (H : TopologicalAddGroup.IsSES φ ψ) [inst_6 : IsTopologicalAddGroup A]
[... | true |
LLVM.Visibility._sizeOf_1 | Lean.Compiler.IR.LLVMBindings | LLVM.Visibility → ℕ | false |
NonUnitalCommRing.toNonUnitalCommSemiring._proof_2 | Mathlib.Algebra.Ring.Defs | ∀ {α : Type u_1} [s : NonUnitalCommRing α] (a b c : α), a * (b + c) = a * b + a * c | false |
Lean.removeRoot | Lean.Data.OpenDecl | Lean.Name → Lean.Name | true |
_private.Std.Data.DHashMap.Internal.AssocList.Lemmas.0.Std.DHashMap.Internal.AssocList.Const.alter.match_1.eq_1 | Std.Data.DHashMap.Internal.AssocList.Lemmas | ∀ {β : Type u_1} (motive : Option β → Sort u_2) (h_1 : Unit → motive none) (h_2 : (b : β) → motive (some b)),
(match none with
| none => h_1 ()
| some b => h_2 b) =
h_1 () | true |
_private.Mathlib.Algebra.Homology.ExactSequenceFour.0.CategoryTheory.ComposableArrows.Exact.opcyclesIsoCycles_hom_fac._proof_15 | Mathlib.Algebra.Homology.ExactSequenceFour | ∀ {n : ℕ} (k : ℕ),
autoParam (k ≤ n) CategoryTheory.ComposableArrows.Exact.opcyclesIsoCycles_hom_fac._auto_1 → k + 1 + 2 < n + 3 + 1 | false |
CategoryTheory.inclusion | Mathlib.CategoryTheory.ConnectedComponents | {J : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} J] →
(j : CategoryTheory.ConnectedComponents J) → CategoryTheory.Functor j.Component (CategoryTheory.Decomposed J) | true |
ContDiffMapSupportedInClass.casesOn | Mathlib.Analysis.Distribution.ContDiffMapSupportedIn | {B : Type u_5} →
{E : Type u_6} →
{F : Type u_7} →
[inst : NormedAddCommGroup E] →
[inst_1 : NormedAddCommGroup F] →
[inst_2 : NormedSpace ℝ E] →
[inst_3 : NormedSpace ℝ F] →
{n : ℕ∞} →
{K : TopologicalSpace.Compacts E} →
{motive ... | false |
Lean.Meta.Cache._sizeOf_1 | Lean.Meta.Basic | Lean.Meta.Cache → ℕ | false |
_private.Mathlib.Geometry.Manifold.IsManifold.InteriorBoundary.0.DifferentiableAt.mem_interior_convex_of_surjective_fderiv.match_1_1 | Mathlib.Geometry.Manifold.IsManifold.InteriorBoundary | ∀ {E : Type u_2} {H : Type u_1} [inst : NormedAddCommGroup H] [inst_1 : NormedSpace ℝ H] {f : E → H} {x : E} {s : Set H}
(motive : (∃ f_1, ∀ a ∈ interior s, f_1 a < f_1 (f x)) → Prop) (x_1 : ∃ f_1, ∀ a ∈ interior s, f_1 a < f_1 (f x)),
(∀ (F : StrongDual ℝ H) (hF : ∀ a ∈ interior s, F a < F (f x)), motive ⋯) → moti... | false |
GradedRingHom.instOne | Mathlib.RingTheory.GradedAlgebra.RingHom | {ι : Type u_1} →
{A : Type u_2} → {σ : Type u_6} → [inst : Semiring A] → [inst_1 : SetLike σ A] → {𝒜 : ι → σ} → One (𝒜 →+*ᵍ 𝒜) | true |
ExteriorAlgebra.lift_symm_apply | Mathlib.LinearAlgebra.ExteriorAlgebra.Basic | ∀ (R : Type u1) [inst : CommRing R] {M : Type u2} [inst_1 : AddCommGroup M] [inst_2 : Module R M] {A : Type u_1}
[inst_3 : Semiring A] [inst_4 : Algebra R A] (a : ExteriorAlgebra R M →ₐ[R] A),
(ExteriorAlgebra.lift R).symm a = ⟨a.toLinearMap ∘ₗ CliffordAlgebra.ι 0, ⋯⟩ | true |
Mathlib.Tactic.IntervalCases.Methods.bisect._unsafe_rec | Mathlib.Tactic.IntervalCases | Mathlib.Tactic.IntervalCases.Methods →
Lean.MVarId →
Subarray Mathlib.Tactic.IntervalCases.IntervalCasesSubgoal →
Mathlib.Tactic.IntervalCases.Bound →
Mathlib.Tactic.IntervalCases.Bound → Lean.Expr → Lean.Expr → Lean.Expr → Lean.Expr → Lean.Expr → Lean.MetaM Unit | false |
_private.Mathlib.NumberTheory.FermatPsp.0.Nat.exists_infinite_pseudoprimes._proof_1_6 | Mathlib.NumberTheory.FermatPsp | ∀ (m : ℕ), 1 < 2 * (m + 2) | false |
Mathlib.Tactic.RingNF.RingMode.ctorElimType | Mathlib.Tactic.Ring.RingNF | {motive : Mathlib.Tactic.RingNF.RingMode → Sort u} → ℕ → Sort (max 1 u) | false |
Complex.lim_re | Mathlib.Analysis.Complex.Norm | ∀ (f : CauSeq ℂ fun x => ‖x‖), (Complex.cauSeqRe f).lim = f.lim.re | true |
enorm_prod_le_of_le | Mathlib.Analysis.Normed.Group.Basic | ∀ {ι : Type u_3} {ε : Type u_8} [inst : TopologicalSpace ε] [inst_1 : ESeminormedCommMonoid ε] (s : Finset ι)
{f : ι → ε} {n : ι → ENNReal}, (∀ b ∈ s, ‖f b‖ₑ ≤ n b) → ‖∏ b ∈ s, f b‖ₑ ≤ ∑ b ∈ s, n b | true |
_private.Mathlib.Analysis.Hofer.0._aux_Mathlib_Analysis_Hofer___macroRules__private_Mathlib_Analysis_Hofer_0_termD_1 | Mathlib.Analysis.Hofer | Lean.Macro | false |
_private.Mathlib.Data.Nat.Factorization.Basic.0.Nat.Ico_pow_dvd_eq_Ico_of_lt._simp_1_3 | Mathlib.Data.Nat.Factorization.Basic | ∀ {a c b : Prop}, (a ∧ c ↔ b ∧ c) = (c → (a ↔ b)) | false |
Lean.Elab.Term.ToDepElimPattern.State | Lean.Elab.Match | Type | true |
_private.Mathlib.Order.Directed.0.directedOn_iff_directed._simp_1_5 | Mathlib.Order.Directed | ∀ {b a : Prop}, (∃ (_ : a), b) = (a ∧ b) | false |
MonoidHom.CompTriple.IsId.eq_id | Mathlib.Algebra.Group.Hom.CompTypeclasses | ∀ {M : Type u_1} {inst : Monoid M} {σ : M →* M} [self : MonoidHom.CompTriple.IsId σ], σ = MonoidHom.id M | true |
Equiv.prodPiEquivSumPi_apply | Mathlib.Logic.Equiv.Prod | ∀ {ι : Type u_9} {ι' : Type u_10} (π : ι → Type u) (π' : ι' → Type u)
(a : ((i : ι) → Sum.elim π π' (Sum.inl i)) × ((i' : ι') → Sum.elim π π' (Sum.inr i'))) (i : ι ⊕ ι'),
(Equiv.prodPiEquivSumPi π π') a i = (Equiv.sumPiEquivProdPi (Sum.elim π π')).symm a i | true |
CategoryTheory.Functor.descOfIsLeftKanExtension_fac_app | Mathlib.CategoryTheory.Functor.KanExtension.Basic | ∀ {C : Type u_1} {H : Type u_3} {D : Type u_4} [inst : CategoryTheory.Category.{v_1, u_1} C]
[inst_1 : CategoryTheory.Category.{v_3, u_3} H] [inst_2 : CategoryTheory.Category.{v_4, u_4} D]
(F' : CategoryTheory.Functor D H) {L : CategoryTheory.Functor C D} {F : CategoryTheory.Functor C H}
(α : F ⟶ L.comp F') [inst... | true |
CategoryTheory.ShortComplex.LeftHomologyData.copy._proof_5 | Mathlib.Algebra.Homology.ShortComplex.LeftHomology | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{S : CategoryTheory.ShortComplex C} (h : S.LeftHomologyData) {K' : C} (eK : K' ≅ h.K),
CategoryTheory.CategoryStruct.comp
((CategoryTheory.Limits.parallelPair (h.hi.lift (CategoryTheory.Limits.Ke... | false |
Lean.Grind.CommRing.Poly.insert.go.induct_unfolding | Init.Grind.Ring.CommSolver | ∀ (k : ℤ) (m : Lean.Grind.CommRing.Mon) (motive : Lean.Grind.CommRing.Poly → Lean.Grind.CommRing.Poly → Prop),
(∀ (k_1 : ℤ),
motive (Lean.Grind.CommRing.Poly.num k_1) (Lean.Grind.CommRing.Poly.add k m (Lean.Grind.CommRing.Poly.num k_1))) →
(∀ (k_1 : ℤ) (m_1 : Lean.Grind.CommRing.Mon) (p : Lean.Grind.CommRin... | true |
_private.Mathlib.LinearAlgebra.LinearPMap.0.LinearPMap.graph_map_fst_eq_domain._simp_1_6 | Mathlib.LinearAlgebra.LinearPMap | ∀ {α : Sort u_1} {p : α → Prop} {b : Prop}, (∃ x, p x ∧ b) = ((∃ x, p x) ∧ b) | false |
MeasureTheory.exp_neg_llr | Mathlib.MeasureTheory.Measure.LogLikelihoodRatio | ∀ {α : Type u_1} {mα : MeasurableSpace α} {μ ν : MeasureTheory.Measure α} [MeasureTheory.SigmaFinite μ]
[MeasureTheory.SigmaFinite ν],
μ.AbsolutelyContinuous ν → (fun x => Real.exp (-MeasureTheory.llr μ ν x)) =ᵐ[μ] fun x => (ν.rnDeriv μ x).toReal | true |
Lean.Compiler.LCNF.CtorFieldInfo.object.injEq | Lean.Compiler.LCNF.ToImpureType | ∀ (i : ℕ) (type : Lean.Expr) (i_1 : ℕ) (type_1 : Lean.Expr),
(Lean.Compiler.LCNF.CtorFieldInfo.object i type = Lean.Compiler.LCNF.CtorFieldInfo.object i_1 type_1) =
(i = i_1 ∧ type = type_1) | true |
ContDiff.fourierPowSMulRight | Mathlib.Analysis.Fourier.FourierTransformDeriv | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℂ E] {V : Type u_2} {W : Type u_3}
[inst_2 : NormedAddCommGroup V] [inst_3 : NormedSpace ℝ V] [inst_4 : NormedAddCommGroup W] [inst_5 : NormedSpace ℝ W]
(L : V →L[ℝ] W →L[ℝ] ℝ) {f : V → E} {k : WithTop ℕ∞},
ContDiff ℝ k f → ∀ (n : ℕ), ContDiff ℝ... | true |
TopModuleCat | Mathlib.Algebra.Category.ModuleCat.Topology.Basic | (R : Type u) → [Ring R] → [TopologicalSpace R] → Type (max u (v + 1)) | true |
Lean.Lsp.Ipc.CallHierarchy.rec_2 | Lean.Data.Lsp.Ipc | {motive_1 : Lean.Lsp.Ipc.CallHierarchy → Sort u} →
{motive_2 : Array Lean.Lsp.Ipc.CallHierarchy → Sort u} →
{motive_3 : List Lean.Lsp.Ipc.CallHierarchy → Sort u} →
((item : Lean.Lsp.CallHierarchyItem) →
(fromRanges : Array Lean.Lsp.Range) →
(children : Array Lean.Lsp.Ipc.CallHierarchy)... | false |
CategoryTheory.SmallObject.hasPushouts | Mathlib.CategoryTheory.SmallObject.IsCardinalForSmallObjectArgument | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (I : CategoryTheory.MorphismProperty C) (κ : Cardinal.{w})
[inst_1 : Fact κ.IsRegular] [inst_2 : OrderBot κ.ord.ToType] [I.IsCardinalForSmallObjectArgument κ],
CategoryTheory.Limits.HasPushouts C | true |
AddSubgroup.op.instNormal | Mathlib.Algebra.Group.Subgroup.MulOppositeLemmas | ∀ {G : Type u_2} [inst : AddGroup G] {H : AddSubgroup G} [H.Normal], H.op.Normal | true |
LinearMap.BilinForm.apply_apply_same_eq_zero_iff | Mathlib.LinearAlgebra.SesquilinearForm.Basic | ∀ {R : Type u_1} {M : Type u_5} [inst : CommRing R] [inst_1 : LinearOrder R] [IsStrictOrderedRing R]
[inst_3 : AddCommGroup M] [inst_4 : Module R M] (B : LinearMap.BilinForm R M),
(∀ (x : M), 0 ≤ (B x) x) → LinearMap.IsSymm B → ∀ {x : M}, (B x) x = 0 ↔ x ∈ LinearMap.ker B | true |
AnalyticAt.comp_of_eq' | Mathlib.Analysis.Analytic.Composition | ∀ {𝕜 : Type u_1} {E : Type u_2} {F : Type u_3} {G : Type u_4} [inst : NontriviallyNormedField 𝕜]
[inst_1 : NormedAddCommGroup E] [inst_2 : NormedSpace 𝕜 E] [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F]
[inst_5 : NormedAddCommGroup G] [inst_6 : NormedSpace 𝕜 G] {g : F → G} {f : E → F} {y : F} {x : ... | true |
Equiv.piCongr'.eq_1 | Mathlib.Logic.Equiv.Basic | ∀ {α : Sort u_1} {β : Sort u_4} {W : α → Sort w} {Z : β → Sort z} (h₁ : α ≃ β) (h₂ : (b : β) → W (h₁.symm b) ≃ Z b),
h₁.piCongr' h₂ = (h₁.symm.piCongr fun b => (h₂ b).symm).symm | true |
Fin.cast_addNat | Init.Data.Fin.Lemmas | ∀ {n : ℕ} (m : ℕ) (i : Fin n), Fin.cast ⋯ (i.addNat m) = Fin.natAdd m i | true |
unitary.val_toUnits_apply | Mathlib.Algebra.Star.Unitary | ∀ {R : Type u_1} [inst : Monoid R] [inst_1 : StarMul R] (x : ↥(unitary R)), ↑(Unitary.toUnits x) = ↑x | true |
_private.Mathlib.Topology.Metrizable.Uniformity.0.UniformSpace.metrizable_uniformity._simp_1_5 | Mathlib.Topology.Metrizable.Uniformity | ∀ {α : Sort u_1} (a : α), (a = a) = True | false |
List.nodup_iff_forall_not_duplicate | Mathlib.Data.List.Duplicate | ∀ {α : Type u_1} {l : List α}, l.Nodup ↔ ∀ (x : α), ¬List.Duplicate x l | true |
instLinearOrderEReal._aux_10 | Mathlib.Data.EReal.Basic | DecidableEq EReal | false |
LiouvilleWith.sub_nat_iff._simp_1 | Mathlib.NumberTheory.Transcendental.Liouville.LiouvilleWith | ∀ {p x : ℝ} {n : ℕ}, LiouvilleWith p (x - ↑n) = LiouvilleWith p x | false |
CategoryTheory.Subfunctor.Subpresheaf.toPresheaf_map_coe | Mathlib.CategoryTheory.Subfunctor.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {F : CategoryTheory.Functor C (Type w)}
(G : CategoryTheory.Subfunctor F) (x x_1 : C) (i : x ⟶ x_1) (x_2 : ↑(G.obj x)),
↑(G.toFunctor.map i x_2) = F.map i ↑x_2 | true |
Std.TreeMap.Raw.insertMany_list_equiv_foldl | Std.Data.TreeMap.Raw.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t₁ : Std.TreeMap.Raw α β cmp} {l : List (α × β)},
(t₁.insertMany l).Equiv (List.foldl (fun acc p => acc.insert p.1 p.2) t₁ l) | true |
CategoryTheory.ObjectProperty.productTo | Mathlib.CategoryTheory.Generator.Basic | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
(P : CategoryTheory.ObjectProperty C) →
(X : C) → [inst_1 : CategoryTheory.Limits.HasProduct (P.productToFamily X)] → X ⟶ ∏ᶜ P.productToFamily X | true |
Finset.zero_mem_neg_add_iff._simp_1 | Mathlib.Algebra.Group.Pointwise.Finset.Basic | ∀ {α : Type u_2} [inst : DecidableEq α] [inst_1 : AddGroup α] {s t : Finset α}, (0 ∈ -t + s) = ¬Disjoint s t | false |
Nat.ppred | Mathlib.Data.Nat.PSub | ℕ → Option ℕ | true |
Matrix.instNonUnitalRing._proof_1 | Mathlib.Data.Matrix.Mul | ∀ {n : Type u_1} {α : Type u_2} [inst : NonUnitalRing α] (a b : Matrix n n α), a - b = a + -b | false |
Tree.noConfusionType | Mathlib.Data.Tree.Basic | Sort u_1 → {α : Type u} → Tree α → {α' : Type u} → Tree α' → Sort u_1 | false |
LinearEquiv._sizeOf_inst | Mathlib.Algebra.Module.Equiv.Defs | {R : Type u_14} →
{S : Type u_15} →
{inst : Semiring R} →
{inst_1 : Semiring S} →
(σ : R →+* S) →
{σ' : S →+* R} →
{inst_2 : RingHomInvPair σ σ'} →
{inst_3 : RingHomInvPair σ' σ} →
(M : Type u_16) →
(M₂ : Type u_17) →
... | false |
Cycle.length_nil | Mathlib.Data.List.Cycle | ∀ {α : Type u_1}, Cycle.nil.length = 0 | true |
Lean.Elab.Command.elabEvalCoreUnsafe | Lean.Elab.BuiltinEvalCommand | Bool → Lean.Syntax → Lean.Syntax → Option Lean.Expr → Lean.Elab.Command.CommandElabM Unit | true |
CoxeterSystem.length_eq_one_iff | Mathlib.GroupTheory.Coxeter.Length | ∀ {B : Type u_1} {W : Type u_2} [inst : Group W] {M : CoxeterMatrix B} (cs : CoxeterSystem M W) {w : W},
cs.length w = 1 ↔ ∃ i, w = cs.simple i | true |
Multiplicative.mulAction_isPretransitive | Mathlib.Algebra.Group.Action.Pretransitive | ∀ {α : Type u_3} {β : Type u_4} [inst : AddMonoid α] [inst_1 : AddAction α β] [AddAction.IsPretransitive α β],
MulAction.IsPretransitive (Multiplicative α) β | true |
LawfulMonadAttach.eq_of_canReturn_pure | Init.Control.Lawful.MonadAttach.Lemmas | ∀ {m : Type u_1 → Type u_2} {α : Type u_1} [inst : Monad m] [inst_1 : MonadAttach m] [LawfulMonad m]
[LawfulMonadAttach m] {a b : α}, MonadAttach.CanReturn (pure a) b → a = b | true |
MeasureTheory.integral_prod_swap | Mathlib.MeasureTheory.Integral.Prod | ∀ {α : Type u_1} {β : Type u_2} {E : Type u_3} [inst : MeasurableSpace α] [inst_1 : MeasurableSpace β]
{μ : MeasureTheory.Measure α} {ν : MeasureTheory.Measure β} [inst_2 : NormedAddCommGroup E] [MeasureTheory.SFinite ν]
[inst_4 : NormedSpace ℝ E] [MeasureTheory.SFinite μ] (f : α × β → E),
∫ (z : β × α), f z.swap... | true |
Mathlib.Tactic.Linarith.Comp.scale | Mathlib.Tactic.Linarith.Datatypes | Mathlib.Tactic.Linarith.Comp → ℕ → Mathlib.Tactic.Linarith.Comp | true |
mul_le_of_mul_le_left | Mathlib.Algebra.Order.Monoid.Unbundled.Basic | ∀ {α : Type u_1} [inst : Mul α] [inst_1 : Preorder α] [MulLeftMono α] {a b c d : α}, a * b ≤ c → d ≤ b → a * d ≤ c | true |
_private.Std.Tactic.BVDecide.LRAT.Internal.Formula.RupAddSound.0.Std.Tactic.BVDecide.LRAT.Internal.DefaultFormula.reduce_fold_fn_preserves_induction_motive._simp_1_4 | Std.Tactic.BVDecide.LRAT.Internal.Formula.RupAddSound | ∀ {α : Type u_1} {β : Type u_2} {p : α × β → Prop}, (∀ (x : α × β), p x) = ∀ (a : α) (b : β), p (a, b) | false |
div_div_eq_mul_div | Mathlib.Algebra.Group.Basic | ∀ {α : Type u_1} [inst : DivisionMonoid α] (a b c : α), a / (b / c) = a * c / b | true |
Lean.Compiler.LCNF.AuxDeclCacheKey.casesOn | Lean.Compiler.LCNF.AuxDeclCache | {motive : Lean.Compiler.LCNF.AuxDeclCacheKey → Sort u} →
(t : Lean.Compiler.LCNF.AuxDeclCacheKey) →
((pu : Lean.Compiler.LCNF.Purity) → (decl : Lean.Compiler.LCNF.Decl pu) → motive { pu := pu, decl := decl }) →
motive t | false |
HomogeneousSubsemiring.ext | Mathlib.RingTheory.GradedAlgebra.Homogeneous.Subsemiring | ∀ {ι : Type u_1} {σ : Type u_2} {A : Type u_3} [inst : AddMonoid ι] [inst_1 : Semiring A] [inst_2 : SetLike σ A]
[inst_3 : AddSubmonoidClass σ A] {𝒜 : ι → σ} [inst_4 : DecidableEq ι] [inst_5 : GradedRing 𝒜]
{R S : HomogeneousSubsemiring 𝒜}, R.toSubsemiring = S.toSubsemiring → R = S | true |
CategoryTheory.Limits.IsLimit.pushoutOfHasExactLimitsOfShape._proof_2 | Mathlib.CategoryTheory.Abelian.GrothendieckAxioms.Connected | ∀ {J : Type u_1} [inst : CategoryTheory.Category.{u_4, u_1} J] {C : Type u_3}
[inst_1 : CategoryTheory.Category.{u_2, u_3} C] [CategoryTheory.Limits.HasPushouts C] {F : CategoryTheory.Functor J C}
{c : CategoryTheory.Limits.Cone F} {X : C} (f : c.pt ⟶ X),
CategoryTheory.Limits.HasColimit (CategoryTheory.Limits.sp... | false |
perfectClosure.eq_bot_of_isSeparable | Mathlib.FieldTheory.PurelyInseparable.PerfectClosure | ∀ (F : Type u) (E : Type v) [inst : Field F] [inst_1 : Field E] [inst_2 : Algebra F E] [Algebra.IsSeparable F E],
perfectClosure F E = ⊥ | true |
_private.Mathlib.Combinatorics.SimpleGraph.Bipartite.0.SimpleGraph.IsBipartite.exists_isBipartiteWith._proof_1_3 | Mathlib.Combinatorics.SimpleGraph.Bipartite | NeZero (1 + 1) | false |
ContinuousLinearMap.flipMultilinearEquiv._proof_4 | Mathlib.Analysis.Normed.Module.Multilinear.Basic | ∀ (𝕜 : Type u_1) {ι : Type u_2} (E : ι → Type u_3) (G : Type u_5) (G' : Type u_4) [inst : NontriviallyNormedField 𝕜]
[inst_1 : (i : ι) → SeminormedAddCommGroup (E i)] [inst_2 : (i : ι) → NormedSpace 𝕜 (E i)]
[inst_3 : SeminormedAddCommGroup G] [inst_4 : NormedSpace 𝕜 G] [inst_5 : SeminormedAddCommGroup G']
[i... | false |
Std.Internal.List.getEntry?._sunfold | Std.Data.Internal.List.Associative | {α : Type u} → {β : α → Type v} → [BEq α] → α → List ((a : α) × β a) → Option ((a : α) × β a) | false |
_private.Mathlib.GroupTheory.Submonoid.Inverses.0.Submonoid.leftInvEquiv._simp_2 | Mathlib.GroupTheory.Submonoid.Inverses | ∀ {α : Type u} [inst : Monoid α] {u : αˣ} {a : α}, (↑u⁻¹ = a) = (↑u * a = 1) | false |
Lean.Parser.Term.leading_parser._regBuiltin.Lean.Parser.Term.withAnonymousAntiquot.parenthesizer_19 | Lean.Parser.Term | IO Unit | false |
Int.fib_neg_one | Mathlib.Data.Int.Fib.Basic | Int.fib (-1) = 1 | true |
MonadReader.casesOn | Init.Prelude | {ρ : Type u} →
{m : Type u → Type v} →
{motive : MonadReader ρ m → Sort u_1} → (t : MonadReader ρ m) → ((read : m ρ) → motive { read := read }) → motive t | false |
NumberField.instIsAlgebraicSubtypeMemSubfield | Mathlib.NumberTheory.NumberField.InfinitePlace.TotallyRealComplex | ∀ {K : Type u_2} [inst : Field K] [inst_1 : CharZero K] [Algebra.IsAlgebraic ℚ K] (k : Subfield K),
Algebra.IsAlgebraic (↥k) K | true |
Set.graphOn_singleton | Mathlib.Data.Set.Prod | ∀ {α : Type u_1} {β : Type u_2} (f : α → β) (x : α), Set.graphOn f {x} = {(x, f x)} | true |
_private.Mathlib.NumberTheory.Padics.PadicNumbers.0.Padic.norm_intCast_eq_one_iff._simp_1_3 | Mathlib.NumberTheory.Padics.PadicNumbers | ∀ {m n : ℤ}, IsCoprime m n = (m.gcd n = 1) | false |
mul_le_mul_left_of_neg._simp_1 | Mathlib.Algebra.Order.Ring.Unbundled.Basic | ∀ {R : Type u} [inst : Semiring R] [inst_1 : LinearOrder R] [ExistsAddOfLE R] [PosMulStrictMono R] [AddRightMono R]
[AddRightReflectLE R] {a b c : R}, c < 0 → (c * a ≤ c * b) = (b ≤ a) | false |
linearIndependent_fin_succ | Mathlib.LinearAlgebra.LinearIndependent.Lemmas | ∀ {K : Type u_3} {V : Type u} [inst : DivisionRing K] [inst_1 : AddCommGroup V] [inst_2 : Module K V] {n : ℕ}
{v : Fin (n + 1) → V},
LinearIndependent K v ↔ LinearIndependent K (Fin.tail v) ∧ v 0 ∉ Submodule.span K (Set.range (Fin.tail v)) | true |
subset_affineSpan | Mathlib.LinearAlgebra.AffineSpace.AffineSubspace.Defs | ∀ (k : Type u_1) {V : Type u_2} {P : Type u_3} [inst : Ring k] [inst_1 : AddCommGroup V] [inst_2 : Module k V]
[inst_3 : AddTorsor V P] (s : Set P), s ⊆ ↑(affineSpan k s) | true |
Lean.ScopedEnvExtension.State.mk.injEq | Lean.ScopedEnvExtension | ∀ {σ : Type} (state : σ) (activeScopes : Lean.NameSet) (delimitsLocal : Bool) (state_1 : σ)
(activeScopes_1 : Lean.NameSet) (delimitsLocal_1 : Bool),
({ state := state, activeScopes := activeScopes, delimitsLocal := delimitsLocal } =
{ state := state_1, activeScopes := activeScopes_1, delimitsLocal := delimit... | true |
_private.Mathlib.CategoryTheory.Limits.Constructions.FiniteProductsOfBinaryProducts.0.CategoryTheory.hasCoproduct_fin | Mathlib.CategoryTheory.Limits.Constructions.FiniteProductsOfBinaryProducts | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasBinaryCoproducts C]
[CategoryTheory.Limits.HasInitial C] (n : ℕ) (f : Fin n → C), CategoryTheory.Limits.HasCoproduct f | true |
Lean.Parser.Command.structExplicitBinder | Lean.Parser.Command | Lean.Parser.Parser | true |
Lean.Meta.Contradiction.Config.emptyType | Lean.Meta.Tactic.Contradiction | Lean.Meta.Contradiction.Config → Bool | true |
CoxeterSystem.length_wordProd_le | Mathlib.GroupTheory.Coxeter.Length | ∀ {B : Type u_1} {W : Type u_2} [inst : Group W] {M : CoxeterMatrix B} (cs : CoxeterSystem M W) (ω : List B),
cs.length (cs.wordProd ω) ≤ ω.length | true |
_private.Mathlib.AlgebraicGeometry.EllipticCurve.Projective.Point.0._aux_Mathlib_AlgebraicGeometry_EllipticCurve_Projective_Point___macroRules__private_Mathlib_AlgebraicGeometry_EllipticCurve_Projective_Point_0_termZ_1 | Mathlib.AlgebraicGeometry.EllipticCurve.Projective.Point | Lean.Macro | false |
Pi.Colex.instCompleteLinearOrderColexForall._proof_10 | Mathlib.Order.CompleteLattice.PiLex | ∀ {ι : Type u_1} {α : ι → Type u_2} [inst : LinearOrder ι] [inst_1 : (i : ι) → CompleteLinearOrder (α i)]
[inst_2 : WellFoundedGT ι] (a b : Colex ((i : ι) → α i)), Lattice.inf a b ≤ b | false |
MoritaEquivalence.mk.injEq | Mathlib.RingTheory.Morita.Basic | ∀ {R : Type u₀} [inst : CommSemiring R] {A : Type u₁} [inst_1 : Ring A] [inst_2 : Algebra R A] {B : Type u₂}
[inst_3 : Ring B] [inst_4 : Algebra R B] (eqv : ModuleCat A ≌ ModuleCat B)
(linear : autoParam (CategoryTheory.Functor.Linear R eqv.functor) MoritaEquivalence.linear._autoParam)
(eqv_1 : ModuleCat A ≌ Modu... | true |
HomotopicalAlgebra.FibrantObject.homMk_id | Mathlib.AlgebraicTopology.ModelCategory.Bifibrant | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : HomotopicalAlgebra.CategoryWithFibrations C]
[inst_2 : CategoryTheory.Limits.HasTerminal C] (X : C) [inst_3 : HomotopicalAlgebra.IsFibrant X],
HomotopicalAlgebra.FibrantObject.homMk (CategoryTheory.CategoryStruct.id X) =
CategoryTheory.CategoryS... | true |
Equiv.Perm.sign_inv | Mathlib.GroupTheory.Perm.Sign | ∀ {α : Type u} [inst : DecidableEq α] [inst_1 : Fintype α] (f : Equiv.Perm α), Equiv.Perm.sign f⁻¹ = Equiv.Perm.sign f | true |
RootableBy.mk._flat_ctor | Mathlib.GroupTheory.Divisible | {A : Type u_1} →
{α : Type u_2} →
[inst : Monoid A] →
[inst_1 : Pow A α] →
[inst_2 : Zero α] →
(root : A → α → A) →
(∀ (a : A), root a 0 = 1) → (∀ {n : α} (a : A), n ≠ 0 → root a n ^ n = a) → RootableBy A α | false |
HahnEmbedding.Seed.hahnCoeff_apply | Mathlib.Algebra.Order.Module.HahnEmbedding | ∀ {K : Type u_1} [inst : DivisionRing K] [inst_1 : LinearOrder K] [inst_2 : IsOrderedRing K] [inst_3 : Archimedean K]
{M : Type u_2} [inst_4 : AddCommGroup M] [inst_5 : LinearOrder M] [inst_6 : IsOrderedAddMonoid M]
[inst_7 : Module K M] [inst_8 : IsOrderedModule K M] {R : Type u_3} [inst_9 : AddCommGroup R]
[ins... | true |
Std.TreeMap.getKeyLT | Std.Data.TreeMap.AdditionalOperations | {α : Type u} →
{β : Type v} →
{cmp : α → α → Ordering} →
[Std.TransCmp cmp] → (t : Std.TreeMap α β cmp) → (k : α) → (∃ a ∈ t, cmp a k = Ordering.lt) → α | true |
TensorProduct.induction_on | Mathlib.LinearAlgebra.TensorProduct.Defs | ∀ {R : Type u_1} [inst : CommSemiring R] {M : Type u_7} {N : Type u_8} [inst_1 : AddCommMonoid M]
[inst_2 : AddCommMonoid N] [inst_3 : Module R M] [inst_4 : Module R N] {motive : TensorProduct R M N → Prop}
(z : TensorProduct R M N),
motive 0 →
(∀ (x : M) (y : N), motive (x ⊗ₜ[R] y)) →
(∀ (x y : TensorP... | true |
Finset.isPWO_support_addAntidiagonal | Mathlib.Data.Finset.MulAntidiagonal | ∀ {α : Type u_1} [inst : AddCommMonoid α] [inst_1 : PartialOrder α] [inst_2 : IsOrderedCancelAddMonoid α] {s t : Set α}
{hs : s.IsPWO} {ht : t.IsPWO}, {a | (Finset.addAntidiagonal hs ht a).Nonempty}.IsPWO | true |
_private.Mathlib.Data.Analysis.Filter.0.Filter.Realizer.ne_bot_iff._simp_1_1 | Mathlib.Data.Analysis.Filter | ∀ {α : Type u} {s : Set α}, (¬s.Nonempty) = (s = ∅) | false |
CategoryTheory.Abelian.SpectralObject.leftHomologyDataShortComplex._proof_11 | 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 |
CategoryTheory.Limits.hasFiniteLimits_of_hasLimitsLimits_of_createsFiniteLimits | Mathlib.CategoryTheory.Limits.Preserves.Creates.Finite | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
(F : CategoryTheory.Functor C D) [CategoryTheory.Limits.HasFiniteLimits D]
[CategoryTheory.Limits.CreatesFiniteLimits F], CategoryTheory.Limits.HasFiniteLimits C | true |
_private.Init.Data.SInt.Lemmas.0.Int32.toInt64_lt._simp_1_2 | Init.Data.SInt.Lemmas | ∀ {x y : Int64}, (x < y) = (x.toInt < y.toInt) | false |
SSet.finite_of_hasDimensionLT | Mathlib.AlgebraicTopology.SimplicialSet.Finite | ∀ (X : SSet) (d : ℕ) [X.HasDimensionLT d], (∀ i < d, Finite ↑(X.nonDegenerate i)) → X.Finite | true |
Language.one_add_self_mul_kstar_eq_kstar | Mathlib.Computability.Language | ∀ {α : Type u_1} (l : Language α), 1 + l * KStar.kstar l = KStar.kstar l | true |
Int16.add_eq_left._simp_1 | Init.Data.SInt.Lemmas | ∀ {a b : Int16}, (a + b = a) = (b = 0) | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.