name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
ContMDiffMap.coeFnRingHom | Mathlib.Geometry.Manifold.Algebra.SmoothFunctions | {𝕜 : Type u_1} →
[inst : NontriviallyNormedField 𝕜] →
{E : Type u_2} →
[inst_1 : NormedAddCommGroup E] →
[inst_2 : NormedSpace 𝕜 E] →
{E' : Type u_3} →
[inst_3 : NormedAddCommGroup E'] →
[inst_4 : NormedSpace 𝕜 E'] →
{H : Type u_4} →
... | true |
FiniteArchimedeanClass.submodule._proof_2 | Mathlib.Algebra.Order.Module.Archimedean | ∀ {M : Type u_1} [inst : AddCommGroup M] [inst_1 : LinearOrder M] [inst_2 : IsOrderedAddMonoid M] (K : Type u_2)
[inst_3 : Ring K] [inst_4 : LinearOrder K] [IsOrderedRing K] [Archimedean K] [inst_7 : Module K M] [PosSMulMono K M]
(s : UpperSet (FiniteArchimedeanClass M)) (k : K) {a : M},
a ∈ (FiniteArchimedeanCla... | false |
Lean.Lsp.FileChangeType.Deleted.elim | Lean.Data.Lsp.Workspace | {motive : Lean.Lsp.FileChangeType → Sort u} →
(t : Lean.Lsp.FileChangeType) → t.ctorIdx = 2 → motive Lean.Lsp.FileChangeType.Deleted → motive t | false |
_private.Lean.Elab.DocString.0.Lean.Doc.ElabFootnote.mk.noConfusion | Lean.Elab.DocString | {P : Sort u} → {name name' : Lean.StrLit} → { name := name } = { name := name' } → (name = name' → P) → P | false |
CategoryTheory.Functor.LaxMonoidal.μ_natural_right._autoParam | Mathlib.CategoryTheory.Monoidal.Functor | Lean.Syntax | false |
Module.isTorsionFree_iff_algebraMap_injective | Mathlib.Algebra.Algebra.Basic | ∀ {R : Type u_1} {A : Type u_2} [inst : CommRing R] [inst_1 : Ring A] [inst_2 : Algebra R A] [IsDomain R] [IsDomain A],
Module.IsTorsionFree R A ↔ Function.Injective ⇑(algebraMap R A) | true |
Lean.Elab.Tactic.BVDecide.Frontend.Normalize.VarState.mk.inj | Lean.Elab.Tactic.BVDecide.Frontend.Normalize.AC | ∀ {op : Lean.Elab.Tactic.BVDecide.Frontend.Normalize.Op}
{exprToVarIndex : Std.HashMap Lean.Expr Lean.Elab.Tactic.BVDecide.Frontend.Normalize.VarIndex}
{varToExpr : Array Lean.Expr} {op_1 : Lean.Elab.Tactic.BVDecide.Frontend.Normalize.Op}
{exprToVarIndex_1 : Std.HashMap Lean.Expr Lean.Elab.Tactic.BVDecide.Fronten... | true |
BitVec.setWidth_append | Init.Data.BitVec.Lemmas | ∀ {w v k : ℕ} {x : BitVec w} {y : BitVec v},
BitVec.setWidth k (x ++ y) = if h : k ≤ v then BitVec.setWidth k y else BitVec.cast ⋯ (BitVec.setWidth (k - v) x ++ y) | true |
SimpleGraph.Walk.IsHamiltonian.getVert_surjective | Mathlib.Combinatorics.SimpleGraph.Hamiltonian | ∀ {α : Type u_1} [inst : DecidableEq α] {G : SimpleGraph α} {a b : α} {p : G.Walk a b},
p.IsHamiltonian → Function.Surjective p.getVert | true |
_private.Mathlib.Analysis.Calculus.Taylor.0.taylor_mean_remainder._proof_1_1 | Mathlib.Analysis.Calculus.Taylor | ContinuousSMul ℝ ℝ | false |
Sym2.Rel.recOn | Mathlib.Data.Sym.Sym2 | ∀ {α : Type u} {motive : (a a_1 : α × α) → Sym2.Rel α a a_1 → Prop} {a a_1 : α × α} (t : Sym2.Rel α a a_1),
(∀ (x y : α), motive (x, y) (x, y) ⋯) → (∀ (x y : α), motive (x, y) (y, x) ⋯) → motive a a_1 t | false |
SheafOfModules.pullbackObjFreeIso_hom_naturality_assoc | Mathlib.Algebra.Category.ModuleCat.Sheaf.PullbackFree | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
{J : CategoryTheory.GrothendieckTopology C} {K : CategoryTheory.GrothendieckTopology D}
{F : CategoryTheory.Functor C D} {S : CategoryTheory.Sheaf J RingCat} {R : CategoryTheory.Sheaf K RingCat}
... | true |
AddMonCat.Hom.hom | Mathlib.Algebra.Category.MonCat.Basic | {X Y : AddMonCat} → X.Hom Y → ↑X →+ ↑Y | true |
_private.Mathlib.RingTheory.Polynomial.Resultant.Basic.0.Polynomial.resultant_eq_zero_of_lt_lt._proof_1_1 | Mathlib.RingTheory.Polynomial.Resultant.Basic | ∀ {R : Type u_1} [inst : CommRing R] (f g : Polynomial R) (n : ℕ), f.natDegree < 0 → f.resultant g 0 n = 0 | false |
_private.Mathlib.Probability.ProductMeasure.0.MeasureTheory.partialTraj_const_restrict₂._proof_1_5 | Mathlib.Probability.ProductMeasure | ∀ (n : ℕ), n ≤ n + 1 | false |
instTopologicalSpaceSeparationQuotient._proof_4 | Mathlib.Topology.Inseparable | ∀ (X : Type u_1) [inst : TopologicalSpace X] (s t : Set (SeparationQuotient X)),
instTopologicalSpaceSeparationQuotient._aux_1 X s →
instTopologicalSpaceSeparationQuotient._aux_1 X t → instTopologicalSpaceSeparationQuotient._aux_1 X (s ∩ t) | false |
CategoryTheory.LocalizerMorphism.LeftResolution.Hom.mk._flat_ctor | Mathlib.CategoryTheory.Localization.Resolution | {C₁ : Type u_1} →
{C₂ : Type u_2} →
[inst : CategoryTheory.Category.{v_1, u_1} C₁] →
[inst_1 : CategoryTheory.Category.{v_2, u_2} C₂] →
{W₁ : CategoryTheory.MorphismProperty C₁} →
{W₂ : CategoryTheory.MorphismProperty C₂} →
{Φ : CategoryTheory.LocalizerMorphism W₁ W₂} →
... | false |
multiplicity_zero_eq_zero_of_ne_zero | Mathlib.RingTheory.Multiplicity | ∀ {α : Type u_1} [inst : MonoidWithZero α] (a : α), a ≠ 0 → multiplicity 0 a = 0 | true |
PowerSeries.le_order_mul | Mathlib.RingTheory.PowerSeries.Order | ∀ {R : Type u_1} [inst : Semiring R] (φ ψ : PowerSeries R), φ.order + ψ.order ≤ (φ * ψ).order | true |
Topology.IsQuotientMap.trivializationOfVAddDisjoint._proof_1 | Mathlib.Topology.Covering.Quotient | ∀ {E : Type u_3} {X : Type u_1} {f : E → X} {G : Type u_2} [inst : AddGroup G] [inst_1 : AddAction G E],
(∀ {e₁ e₂ : E}, f e₁ = f e₂ ↔ e₁ ∈ AddAction.orbit G e₂) → ∀ (g : G) (e : E), f (g +ᵥ e) = f e | false |
QuadraticMap.IsometryEquiv.mk.noConfusion | Mathlib.LinearAlgebra.QuadraticForm.IsometryEquiv | {R : Type u_2} →
{M₁ : Type u_5} →
{M₂ : Type u_6} →
{N : Type u_9} →
{inst : CommSemiring R} →
{inst_1 : AddCommMonoid M₁} →
{inst_2 : AddCommMonoid M₂} →
{inst_3 : AddCommMonoid N} →
{inst_4 : Module R M₁} →
{inst_5 : Module R M... | false |
_private.Std.Data.DHashMap.Lemmas.0.Std.DHashMap.mem_filterMap._simp_1_3 | Std.Data.DHashMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {x : BEq α} {x_1 : Hashable α} {m : Std.DHashMap α β} [inst : LawfulBEq α] {a : α},
(m.get? a).isSome = m.contains a | false |
Lean.Elab.Tactic.expandLocation | Lean.Elab.Tactic.Location | Lean.Syntax → Lean.Elab.Tactic.Location | true |
TopologicalSpace.pseudoMetrizableSpace_prod | Mathlib.Topology.Metrizable.Basic | ∀ {X : Type u_2} {Y : Type u_3} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y]
[TopologicalSpace.PseudoMetrizableSpace X] [TopologicalSpace.PseudoMetrizableSpace Y],
TopologicalSpace.PseudoMetrizableSpace (X × Y) | true |
CircleDeg1Lift.translationNumber_zpow | Mathlib.Dynamics.Circle.RotationNumber.TranslationNumber | ∀ (f : CircleDeg1Liftˣ) (n : ℤ), (↑(f ^ n)).translationNumber = ↑n * (↑f).translationNumber | true |
LieAlgebra.abelian_of_solvable_ideal_eq_bot_iff | Mathlib.Algebra.Lie.Solvable | ∀ {R : Type u} {L : Type v} [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : LieAlgebra R L] (I : LieIdeal R L)
[h : LieAlgebra.IsSolvable ↥I], LieAlgebra.derivedAbelianOfIdeal I = ⊥ ↔ I = ⊥ | true |
_private.Mathlib.MeasureTheory.Measure.Haar.Basic.0.MeasureTheory.Measure.haar.index_union_eq._simp_1_1 | Mathlib.MeasureTheory.Measure.Haar.Basic | ∀ {α : Type u} {β : Type v} {f : α → β} {s : Set β} {a : α}, (a ∈ f ⁻¹' s) = (f a ∈ s) | false |
Mathlib.Tactic.Translate.Reorder.brecOn | Mathlib.Tactic.Translate.Reorder | {motive_1 : Mathlib.Tactic.Translate.Reorder → Sort u} →
{motive_2 : Array (ℕ × Mathlib.Tactic.Translate.Reorder) → Sort u} →
{motive_3 : List (ℕ × Mathlib.Tactic.Translate.Reorder) → Sort u} →
{motive_4 : ℕ × Mathlib.Tactic.Translate.Reorder → Sort u} →
(t : Mathlib.Tactic.Translate.Reorder) →
... | false |
Units.exists0' | Mathlib.Algebra.GroupWithZero.Units.Basic | ∀ {G₀ : Type u_3} [inst : GroupWithZero G₀] {p : (g : G₀) → g ≠ 0 → Prop}, (∃ g, ∃ (hg : g ≠ 0), p g hg) ↔ ∃ g, p ↑g ⋯ | true |
deriv_zero_of_frequently_mem | Mathlib.Analysis.Calculus.Deriv.Inverse | ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {F : Type v} [inst_1 : NormedAddCommGroup F]
[inst_2 : NormedSpace 𝕜 F] {f : 𝕜 → F} {x : 𝕜} (t : Set F),
¬AccPt (f x) (Filter.principal t) → (∃ᶠ (y : 𝕜) in nhdsWithin x {x}ᶜ, f y ∈ t) → deriv f x = 0 | true |
Complex.isOpenMap_exp | Mathlib.Analysis.SpecialFunctions.Complex.LogDeriv | IsOpenMap Complex.exp | true |
Lean.Environment.getProjectionStructureName? | Lean.ProjFns | Lean.Environment → Lean.Name → Option Lean.Name | true |
Lean.Meta.Ext.ExtTheorem.mk.injEq | Lean.Meta.Tactic.Ext | ∀ (declName : Lean.Name) (priority : ℕ) (keys : Array Lean.Meta.DiscrTree.Key) (declName_1 : Lean.Name) (priority_1 : ℕ)
(keys_1 : Array Lean.Meta.DiscrTree.Key),
({ declName := declName, priority := priority, keys := keys } =
{ declName := declName_1, priority := priority_1, keys := keys_1 }) =
(declName... | true |
Lean.Grind.Config.reducible | Init.Grind.Config | Lean.Grind.Config → Bool | true |
Set.ite_inter_self | Mathlib.Order.BooleanAlgebra.Set | ∀ {α : Type u_1} (t s s' : Set α), t.ite s s' ∩ t = s ∩ t | true |
CategoryTheory.Limits.reflectsColimitsOfSize_leftOp | Mathlib.CategoryTheory.Limits.Preserves.Opposites | ∀ {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.ReflectsLimitsOfSize.{w, w', v₁, v₂, u₁, u₂} F],
CategoryTheory.Limits.ReflectsColimitsOfSize.{w, w', v₁, v₂, u₁, u₂} F.leftOp | true |
ODE.hasDerivWithinAt_picard_Icc | Mathlib.Analysis.ODE.PicardLindelof | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] [CompleteSpace E] {f : ℝ → E → E} {α : ℝ → E}
{u : Set E} {t₀ tmin tmax : ℝ},
t₀ ∈ Set.Icc tmin tmax →
ContinuousOn (Function.uncurry f) (Set.Icc tmin tmax ×ˢ u) →
ContinuousOn α (Set.Icc tmin tmax) →
(∀ t ∈ Set.Icc tmin tma... | true |
_private.Init.Data.List.Sort.Impl.0.List.MergeSort.Internal.mergeTR.go._unary._proof_3 | Init.Data.List.Sort.Impl | ∀ {α : Type u_1} (x : α) (xs : List α) (y : α) (ys acc : List α),
(invImage (fun x => PSigma.casesOn x fun a a_1 => PSigma.casesOn a_1 fun a_2 a_3 => (a, a_2))
Prod.instWellFoundedRelation).1
⟨x :: xs, ⟨ys, y :: acc⟩⟩ ⟨x :: xs, ⟨y :: ys, acc⟩⟩ | false |
mul_self_inj | Mathlib.Algebra.Order.Ring.Unbundled.Basic | ∀ {R : Type u} [inst : Semiring R] [inst_1 : LinearOrder R] [PosMulStrictMono R] [MulPosMono R] {a b : R},
0 ≤ a → 0 ≤ b → (a * a = b * b ↔ a = b) | true |
AlgebraicGeometry.Scheme.Hom.normalizationDiagram._proof_2 | Mathlib.AlgebraicGeometry.Normalization | ∀ {X Y : AlgebraicGeometry.Scheme} (f : X ⟶ Y) {V U : Y.Opensᵒᵖ} (i : V ⟶ U),
∀
x ∈
integralClosure ↑(Y.presheaf.obj (Opposite.op (Opposite.unop V)))
↑(X.presheaf.obj (Opposite.op ((TopologicalSpace.Opens.map f.base).obj (Opposite.unop V)))),
(CommRingCat.Hom.hom (X.presheaf.map (CategoryTheory.... | false |
HarmonicAt.analyticAt_complex_partial | Mathlib.Analysis.Complex.Harmonic.Analytic | ∀ {f : ℂ → ℝ} {x : ℂ},
InnerProductSpace.HarmonicAt f x →
AnalyticAt ℂ (fun z => ↑((fderiv ℝ f z) 1) - Complex.I * ↑((fderiv ℝ f z) Complex.I)) x | true |
Lean.Meta.Grind.evalTactic | Lean.Meta.Tactic.Grind.Types | Lean.Meta.Grind.Goal → Lean.TSyntax `grind → Lean.Meta.Grind.GrindM (List Lean.Meta.Grind.Goal) | true |
Representation.linHom.invariantsEquivFDRepHom | Mathlib.RepresentationTheory.Invariants | {k : Type u} →
[inst : Field k] →
{G : Type u} → [inst_1 : Group G] → (X Y : FDRep k G) → ↥(Representation.linHom X.ρ Y.ρ).invariants ≃ₗ[k] X ⟶ Y | true |
Function.Injective.extend_comp | Mathlib.Logic.Function.Basic | ∀ {γ : Sort u_3} {α₁ : Sort u_4} {α₂ : Sort u_5} {α₃ : Sort u_6} {f₁₂ : α₁ → α₂},
Function.Injective f₁₂ →
∀ {f₂₃ : α₂ → α₃},
Function.Injective f₂₃ →
∀ (g : α₁ → γ) (e' : α₃ → γ),
Function.extend (f₂₃ ∘ f₁₂) g e' = Function.extend f₂₃ (Function.extend f₁₂ g (e' ∘ f₂₃)) e' | true |
Lean.Parser.Command.unsafe | Lean.Parser.Command | Lean.Parser.Parser | true |
analyticAt_iff_analytic_smul | Mathlib.Analysis.Analytic.Constructions | ∀ {𝕜 : Type u_2} [inst : NontriviallyNormedField 𝕜] {E : Type u_3} {F : Type u_4} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {𝕝 : Type u_8}
[inst_5 : NormedDivisionRing 𝕝] [inst_6 : NormedAlgebra 𝕜 𝕝] [inst_7 : Module 𝕝 F] [IsBounde... | true |
zmultiplesHom._proof_2 | Mathlib.Data.Int.Cast.Lemmas | ∀ (β : Type u_1) [inst : AddGroup β] (a : β), 1 • a = a | false |
_private.Mathlib.Topology.CWComplex.Classical.Basic.0.Topology.RelCWComplex.subset_of_eq_union_iUnion | Mathlib.Topology.CWComplex.Classical.Basic | ∀ {X : Type u_1} [t : TopologicalSpace X] {C D : Set X} [inst : Topology.RelCWComplex C D]
(I J : (n : ℕ) → Set (Topology.RelCWComplex.cell C n)),
D ∪ ⋃ n, ⋃ j, Topology.RelCWComplex.openCell n ↑j = D ∪ ⋃ n, ⋃ j, Topology.RelCWComplex.openCell n ↑j →
∀ (n : ℕ), I n ⊆ J n | true |
_private.Mathlib.Tactic.GCongr.Core.0.Mathlib.Tactic.GCongr.makeGCongrLemma._sparseCasesOn_1 | Mathlib.Tactic.GCongr.Core | {motive : Lean.Expr → Sort u} →
(t : Lean.Expr) →
((fvarId : Lean.FVarId) → motive (Lean.Expr.fvar fvarId)) → (Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t | false |
ClosedSubmodule.instOrderTop | Mathlib.Topology.Algebra.Module.ClosedSubmodule | {R : Type u_2} →
{M : Type u_3} →
[inst : Semiring R] →
[inst_1 : AddCommMonoid M] →
[inst_2 : TopologicalSpace M] → [inst_3 : Module R M] → OrderTop (ClosedSubmodule R M) | true |
HasFPowerSeriesWithinAt.prod | Mathlib.Analysis.Analytic.Constructions | ∀ {𝕜 : Type u_2} [inst : NontriviallyNormedField 𝕜] {E : Type u_3} {F : Type u_4} {G : Type u_5}
[inst_1 : NormedAddCommGroup E] [inst_2 : NormedSpace 𝕜 E] [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F]
[inst_5 : NormedAddCommGroup G] [inst_6 : NormedSpace 𝕜 G] {e : E} {f : E → F} {g : E → G} {s : ... | true |
CategoryTheory.Bicategory.Prod.snd._proof_13 | Mathlib.CategoryTheory.Bicategory.Product | ∀ (B : Type u_1) [inst : CategoryTheory.Bicategory B] (C : Type u_2) [inst_1 : CategoryTheory.Bicategory C]
{a b : B × C} (f : a ⟶ b),
(CategoryTheory.Bicategory.rightUnitor f).hom.2 =
CategoryTheory.CategoryStruct.comp (CategoryTheory.eqToHom ⋯) (CategoryTheory.Bicategory.rightUnitor f.2).hom | false |
_private.Mathlib.Tactic.TermCongr.0.Mathlib.Tactic.TermCongr.mkCongrOfApp.go.match_6 | Mathlib.Tactic.TermCongr | (motive : Option (Lean.Meta.CongrArgKind × Subarray Lean.Meta.CongrArgKind) → Sort u_1) →
(x : Option (Lean.Meta.CongrArgKind × Subarray Lean.Meta.CongrArgKind)) →
(Unit → motive none) →
((kind : Lean.Meta.CongrArgKind) → (s' : Subarray Lean.Meta.CongrArgKind) → motive (some (kind, s'))) → motive x | false |
Lean.Firefox.instFromJsonResourceTable | Lean.Util.Profiler | Lean.FromJson Lean.Firefox.ResourceTable | true |
CommBialgCat.Hom.Simps.hom | Mathlib.Algebra.Category.CommBialgCat | {R : Type u} → [inst : CommRing R] → (A B : CommBialgCat R) → A.Hom B → ↑A →ₐc[R] ↑B | true |
CategoryTheory.OverPresheafAux.MakesOverArrow.map₂ | Mathlib.CategoryTheory.Comma.Presheaf.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {A F : CategoryTheory.Functor Cᵒᵖ (Type v)} {η : F ⟶ A}
{X Y : C} (f : X ⟶ Y) {s : CategoryTheory.yoneda.obj X ⟶ A} {t : CategoryTheory.yoneda.obj Y ⟶ A},
CategoryTheory.CategoryStruct.comp (CategoryTheory.yoneda.map f) t = s →
∀ {u : F.obj (Opposite.op Y... | true |
_private.Mathlib.Combinatorics.Enumerative.Composition.0.CompositionAsSet.toComposition_boundaries._simp_1_3 | Mathlib.Combinatorics.Enumerative.Composition | ∀ {n : ℕ} {p : Fin n → Prop}, (∃ i, p i) = ∃ i, ∃ (h : i < n), p ⟨i, h⟩ | false |
Int.Linear.cooper_left | Init.Data.Int.Linear | ∀ (ctx : Int.Linear.Context) (p₁ p₂ : Int.Linear.Poly) (n : ℕ),
Int.Linear.cooper_left_cert p₁ p₂ n = true →
Int.Linear.Poly.denote' ctx p₁ ≤ 0 →
Int.Linear.Poly.denote' ctx p₂ ≤ 0 → Int.Linear.OrOver n (Int.Linear.cooper_left_split ctx p₁ p₂) | true |
Std.DTreeMap.Internal.Impl.size_filterMap_le_size | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Std.DTreeMap.Internal.Impl α β} {γ : α → Type w} [Std.TransOrd α]
{f : (a : α) → β a → Option (γ a)} (h : t.WF), (Std.DTreeMap.Internal.Impl.filterMap f t ⋯).impl.size ≤ t.size | true |
supClosed_empty | Mathlib.Order.SupClosed | ∀ {α : Type u_3} [inst : SemilatticeSup α], SupClosed ∅ | true |
ForIn'.noConfusion | Init.Core | {P : Sort u_1} →
{m : Type u₁ → Type u₂} →
{ρ : Type u} →
{α : Type v} →
{d : Membership α ρ} →
{t : ForIn' m ρ α d} →
{m' : Type u₁ → Type u₂} →
{ρ' : Type u} →
{α' : Type v} →
{d' : Membership α' ρ'} →
{t' : ... | false |
Function.Injective.image_injective | Mathlib.Data.Set.Image | ∀ {α : Type u_1} {β : Type u_2} {f : α → β}, Function.Injective f → Function.Injective (Set.image f) | true |
EuclideanGeometry.eq_of_mem_sphere_of_mem_sphere_of_finrank_eq_two | Mathlib.Geometry.Euclidean.Sphere.Basic | ∀ {V : Type u_1} {P : Type u_2} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V] [inst_2 : MetricSpace P]
[NormedAddTorsor V P] [FiniteDimensional ℝ V],
Module.finrank ℝ V = 2 →
∀ {s₁ s₂ : EuclideanGeometry.Sphere P} {p₁ p₂ p : P},
s₁ ≠ s₂ → p₁ ≠ p₂ → p₁ ∈ s₁ → p₂ ∈ s₁ → p ∈ s₁ → p₁ ∈ s₂ → p... | true |
instContMDiffMulOfNatWithTopENatOfContinuousMul | Mathlib.Geometry.Manifold.Algebra.Monoid | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {H : Type u_2} [inst_1 : TopologicalSpace H] {E : Type u_3}
[inst_2 : NormedAddCommGroup E] [inst_3 : NormedSpace 𝕜 E] {I : ModelWithCorners 𝕜 E H} {G : Type u_4}
[inst_4 : Mul G] [inst_5 : TopologicalSpace G] [inst_6 : ChartedSpace H G] [ContinuousMul G], Con... | true |
StrictConcaveOn.sub | Mathlib.Analysis.Convex.Function | ∀ {𝕜 : Type u_1} {E : Type u_2} {β : Type u_5} [inst : Semiring 𝕜] [inst_1 : PartialOrder 𝕜] [inst_2 : AddCommMonoid E]
[inst_3 : AddCommGroup β] [inst_4 : PartialOrder β] [IsOrderedAddMonoid β] [inst_6 : SMul 𝕜 E] [inst_7 : Module 𝕜 β]
{s : Set E} {f g : E → β}, StrictConcaveOn 𝕜 s f → StrictConvexOn 𝕜 s g ... | true |
Lean.Parser.Tactic.getConfigItems._unsafe_rec | Init.Meta.Defs | Lean.Syntax → Lean.TSyntaxArray `Lean.Parser.Tactic.configItem | false |
CategoryTheory.LocalizerMorphism.RightResolution.op_X₁ | Mathlib.CategoryTheory.Localization.Resolution | ∀ {C₁ : Type u_1} {C₂ : Type u_2} [inst : CategoryTheory.Category.{v_1, u_1} C₁]
[inst_1 : CategoryTheory.Category.{v_2, u_2} C₂] {W₁ : CategoryTheory.MorphismProperty C₁}
{W₂ : CategoryTheory.MorphismProperty C₂} {Φ : CategoryTheory.LocalizerMorphism W₁ W₂} {X₂ : C₂}
(L : Φ.RightResolution X₂), L.op.X₁ = Opposit... | true |
Std.Associative.mk._flat_ctor | Init.Core | ∀ {α : Sort u} {op : α → α → α}, (∀ (a b c : α), op (op a b) c = op a (op b c)) → Std.Associative op | false |
MeasureTheory.tilted_zero_measure | Mathlib.MeasureTheory.Measure.Tilted | ∀ {α : Type u_1} {mα : MeasurableSpace α} (f : α → ℝ), MeasureTheory.Measure.tilted 0 f = 0 | true |
_private.Init.Data.Nat.Basic.0.Nat.zero_lt_sub_of_lt.match_1_1 | Init.Data.Nat.Basic | ∀ {i : ℕ} (a : ℕ) (motive : i.succ = a + 1 ∨ i.succ < a + 1 → Prop) (x : i.succ = a + 1 ∨ i.succ < a + 1),
(∀ (h : i.succ = a + 1), motive ⋯) → (∀ (h : i.succ < a + 1), motive ⋯) → motive x | false |
CategoryTheory.MonoidalCategory.DayFunctor.noConfusion | Mathlib.CategoryTheory.Monoidal.DayConvolution.DayFunctor | {P : Sort u} →
{C : Type u₁} →
{inst : CategoryTheory.Category.{v₁, u₁} C} →
{V : Type u₂} →
{inst_1 : CategoryTheory.Category.{v₂, u₂} V} →
{inst_2 : CategoryTheory.MonoidalCategory C} →
{inst_3 : CategoryTheory.MonoidalCategory V} →
{t : CategoryTheory.MonoidalC... | false |
Lean.Elab.Tactic.SimpKind.simp | Lean.Elab.Tactic.Simp | Lean.Elab.Tactic.SimpKind | true |
Lean.JsonRpc.MessageMetaData.responseError | Lean.Data.JsonRpc | Lean.JsonRpc.RequestID → Lean.JsonRpc.ErrorCode → String → Option Lean.Json → Lean.JsonRpc.MessageMetaData | true |
OpenSubgroup.coe_inf | Mathlib.Topology.Algebra.OpenSubgroup | ∀ {G : Type u_1} [inst : Group G] [inst_1 : TopologicalSpace G] {U V : OpenSubgroup G}, ↑(U ⊓ V) = ↑U ∩ ↑V | true |
Manifold.IsSmoothEmbedding.prodMap | Mathlib.Geometry.Manifold.SmoothEmbedding | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E₁ : Type u_2} {E₂ : Type u_3} {E₃ : Type u_4} {E₄ : Type u_5}
[inst_1 : NormedAddCommGroup E₁] [inst_2 : NormedSpace 𝕜 E₁] [inst_3 : NormedAddCommGroup E₂]
[inst_4 : NormedSpace 𝕜 E₂] [inst_5 : NormedAddCommGroup E₃] [inst_6 : NormedSpace 𝕜 E₃]
[inst_7 : ... | true |
AddSubmonoid.mem_one._simp_1 | Mathlib.Algebra.Ring.Submonoid.Pointwise | ∀ {R : Type u_2} [inst : AddMonoidWithOne R] {x : R}, (x ∈ 1) = ∃ n, ↑n = x | false |
List.prod_eq_foldl | Batteries.Data.List.Lemmas | ∀ {α : Type u_1} [inst : Mul α] [inst_1 : One α] [Std.Associative fun x1 x2 => x1 * x2]
[Std.LawfulIdentity (fun x1 x2 => x1 * x2) 1] {l : List α}, l.prod = List.foldl (fun x1 x2 => x1 * x2) 1 l | true |
_private.Mathlib.RingTheory.Ideal.MinimalPrime.Localization.0.Ideal.disjoint_nonZeroDivisors_of_mem_minimalPrimes._simp_1_6 | Mathlib.RingTheory.Ideal.MinimalPrime.Localization | ∀ {G : Type u_1} [inst : CommMagma G] (a b : G), b * a = a * b | false |
_private.Mathlib.AlgebraicGeometry.EllipticCurve.DivisionPolynomial.Degree.0.WeierstrassCurve.expDegree_rec._proof_1_6 | Mathlib.AlgebraicGeometry.EllipticCurve.DivisionPolynomial.Degree | ∀ (m : ℕ), ¬m + 4 = 0 | false |
List.foldr_nil | Init.Data.List.Basic | ∀ {α : Type u_1} {α_1 : Type u_2} {f : α → α_1 → α_1} {b : α_1}, List.foldr f b [] = b | true |
_private.Std.Data.DHashMap.Internal.AssocList.Basic.0.Std.DHashMap.Internal.AssocList.forInStep.go._sunfold | Std.Data.DHashMap.Internal.AssocList.Basic | {α : Type u} →
{β : α → Type v} →
{δ : Type w} →
{m : Type w → Type w'} →
[Monad m] → ((a : α) → β a → δ → m (ForInStep δ)) → Std.DHashMap.Internal.AssocList α β → δ → m (ForInStep δ) | false |
_private.Lean.Meta.Tactic.Grind.Canon.0.Lean.Meta.Grind.Canon.canonElemCore.go._sparseCasesOn_1 | Lean.Meta.Tactic.Grind.Canon | {α : Type u} →
{motive : Option α → Sort u_1} →
(t : Option α) → ((val : α) → motive (some val)) → (Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t | false |
Module.Invertible.tensorProductComm_eq_refl | Mathlib.RingTheory.PicardGroup | ∀ (R : Type u_5) (M : Type u_6) [inst : CommRing R] [inst_1 : AddCommGroup M] [inst_2 : Module R M]
[Module.Invertible R M], TensorProduct.comm R M M = LinearEquiv.refl R (TensorProduct R M M) | true |
_private.Lean.Elab.Syntax.0.Lean.Elab.Term.toParserDescr.processUnicode | Lean.Elab.Syntax | Lean.Syntax → Lean.Elab.Term.ToParserDescrM (Lean.Term × ℕ) | true |
CategoryTheory.Limits.Bicone.IsBilimit.casesOn | Mathlib.CategoryTheory.Limits.Shapes.Biproducts | {J : Type w} →
{C : Type uC} →
[inst : CategoryTheory.Category.{uC', uC} C] →
[inst_1 : CategoryTheory.Limits.HasZeroMorphisms C] →
{F : J → C} →
{B : CategoryTheory.Limits.Bicone F} →
{motive : B.IsBilimit → Sort u} →
(t : B.IsBilimit) →
((isLimit... | false |
Algebra.discr_eq_discr | Mathlib.RingTheory.Discriminant | ∀ (A : Type u) {ι : Type w} [inst : DecidableEq ι] [inst_1 : CommRing A] [inst_2 : Fintype ι]
(b b' : Module.Basis ι ℤ A), Algebra.discr ℤ ⇑b = Algebra.discr ℤ ⇑b' | true |
SpecialLinearGroup.congr_linearEquiv._proof_3 | Mathlib.LinearAlgebra.SpecialLinearGroup | ∀ {R : Type u_1} [inst : CommRing R], RingHomCompTriple (RingHom.id R) (RingHom.id R) (RingHom.id R) | false |
Std.TreeMap.Raw.getEntryLTD | Std.Data.TreeMap.Raw.Basic | {α : Type u} → {β : Type v} → {cmp : α → α → Ordering} → Std.TreeMap.Raw α β cmp → α → α × β → α × β | true |
CategoryTheory.IsPushout.inl_desc | Mathlib.CategoryTheory.Limits.Shapes.Pullback.IsPullback.Defs | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {Z X Y P : C} {f : Z ⟶ X} {g : Z ⟶ Y} {inl : X ⟶ P}
{inr : Y ⟶ P} (hP : CategoryTheory.IsPushout f g inl inr) {W : C} (h : X ⟶ W) (k : Y ⟶ W)
(w : CategoryTheory.CategoryStruct.comp f h = CategoryTheory.CategoryStruct.comp g k),
CategoryTheory.CategorySt... | true |
cfc_le_one_iff._auto_3 | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Unital | Lean.Syntax | false |
Lean.Compiler.LCNF.Closure.State._sizeOf_1 | Lean.Compiler.LCNF.Closure | Lean.Compiler.LCNF.Closure.State → ℕ | false |
Std.Tactic.BVDecide.BVExpr.decEq._proof_152 | Std.Tactic.BVDecide.Bitblast.BVExpr.Basic | ∀ {w : ℕ} (lw : ℕ) (llhs : Std.Tactic.BVDecide.BVExpr w) (lrhs : Std.Tactic.BVDecide.BVExpr lw) (rw : ℕ)
(rlhs : Std.Tactic.BVDecide.BVExpr w) (rrhs : Std.Tactic.BVDecide.BVExpr rw),
¬lw = rw → ¬llhs.arithShiftRight lrhs = rlhs.arithShiftRight rrhs | false |
CategoryTheory.Functor.mapAddGrp_obj_addGrp_neg | Mathlib.CategoryTheory.Monoidal.Grp_ | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.CartesianMonoidalCategory C]
{D : Type u₂} [inst_2 : CategoryTheory.Category.{v₂, u₂} D] [inst_3 : CategoryTheory.CartesianMonoidalCategory D]
(F : CategoryTheory.Functor C D) [inst_4 : F.Monoidal] (A : CategoryTheory.AddGrp C),
... | true |
Int32.ofIntLE_int16ToInt._proof_1 | Init.Data.SInt.Lemmas | Int32.minValue.toInt ≤ Int16.minValue.toInt | false |
_private.Batteries.Data.RBMap.Alter.0.Batteries.RBNode.fold.match_1.eq_1 | Batteries.Data.RBMap.Alter | ∀ {α : Type u_1} (motive : Batteries.RBNode α → Sort u_2) (h_1 : Unit → motive Batteries.RBNode.nil)
(h_2 :
(c : Batteries.RBColor) →
(l : Batteries.RBNode α) → (v : α) → (r : Batteries.RBNode α) → motive (Batteries.RBNode.node c l v r)),
(match Batteries.RBNode.nil with
| Batteries.RBNode.nil => h_1 ... | true |
PrimeSpectrum.coe_vanishingIdeal | Mathlib.RingTheory.Spectrum.Prime.Basic | ∀ {R : Type u} [inst : CommSemiring R] (t : Set (PrimeSpectrum R)),
↑(PrimeSpectrum.vanishingIdeal t) = {f | ∀ x ∈ t, f ∈ x.asIdeal} | true |
_private.Mathlib.AlgebraicGeometry.IdealSheaf.Basic.0.AlgebraicGeometry.Scheme.IdealSheafData.ofIdealTop._simp_2 | Mathlib.AlgebraicGeometry.IdealSheaf.Basic | ∀ {α : Type u} (x : α) (a b : Set α), (x ∈ a ∪ b) = (x ∈ a ∨ x ∈ b) | false |
_private.Lean.Elab.Tactic.BVDecide.Frontend.Normalize.IntToBitVec.0.Lean.Elab.Tactic.BVDecide.Frontend.Normalize.M | Lean.Elab.Tactic.BVDecide.Frontend.Normalize.IntToBitVec | Type → Type | true |
Complex.instMul | Mathlib.Data.Complex.Basic | Mul ℂ | true |
_private.Mathlib.Topology.Algebra.Module.LinearMapPiProd.0.ContinuousLinearMap.prod_ext_iff._simp_1_2 | Mathlib.Topology.Algebra.Module.LinearMapPiProd | ∀ {R : Type u} {M : Type v} {M₂ : Type w} {M₃ : Type y} [inst : Semiring R] [inst_1 : AddCommMonoid M]
[inst_2 : AddCommMonoid M₂] [inst_3 : AddCommMonoid M₃] [inst_4 : Module R M] [inst_5 : Module R M₂]
[inst_6 : Module R M₃] {f g : M × M₂ →ₗ[R] M₃},
(f = g) =
(f ∘ₗ LinearMap.inl R M M₂ = g ∘ₗ LinearMap.inl ... | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.