name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
_private.Mathlib.RingTheory.Algebraic.Denominator.0.Algebra.denominator._proof_1 | Mathlib.RingTheory.Algebraic.Denominator | ∀ (R : Type u_1) {S : Type u_2} [inst : CommRing R] [IsPrincipalIdealRing R] [inst_2 : CommRing S]
[inst_3 : Algebra R S] (x : S), Submodule.IsPrincipal ((Subalgebra.toSubmodule (integralClosure R S)).colon {x}) | null | false |
Lean.Lsp.FileEvent.recOn | Lean.Data.Lsp.Workspace | {motive : Lean.Lsp.FileEvent → Sort u} →
(t : Lean.Lsp.FileEvent) →
((uri : Lean.Lsp.DocumentUri) → (type : Lean.Lsp.FileChangeType) → motive { uri := uri, type := type }) → motive t | null | false |
EuclideanGeometry.inversion_eq_center'._simp_1 | Mathlib.Geometry.Euclidean.Inversion.Basic | ∀ {V : Type u_1} {P : Type u_2} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V] [inst_2 : MetricSpace P]
[inst_3 : NormedAddTorsor V P] {c x : P} {R : ℝ}, (EuclideanGeometry.inversion c R x = c) = (x = c ∨ R = 0) | null | false |
AddMonoidHom.coeToZeroHom | Mathlib.Algebra.Group.Hom.Defs | {M : Type u_4} → {N : Type u_5} → [inst : AddZero M] → [inst_1 : AddZero N] → Coe (M →+ N) (ZeroHom M N) | `AddMonoidHom` down-cast to a `ZeroHom`, forgetting the additive property | true |
CategoryTheory.Functor.homologySequence_mono_shift_map_mor₂_iff | Mathlib.CategoryTheory.Triangulated.HomologicalFunctor | ∀ {C : Type u_1} {A : Type u_3} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.HasShift C ℤ]
[inst_2 : CategoryTheory.Category.{v_3, u_3} A] (F : CategoryTheory.Functor C A)
[inst_3 : CategoryTheory.Limits.HasZeroObject C] [inst_4 : CategoryTheory.Preadditive C]
[inst_5 : ∀ (n : ℤ), (Categ... | null | true |
_private.Lean.Meta.Tactic.Grind.Arith.Cutsat.Util.0.Int.Internal.Linear.Poly.isZero.match_1 | Lean.Meta.Tactic.Grind.Arith.Cutsat.Util | (motive : Int.Internal.Linear.Poly → Sort u_1) →
(x : Int.Internal.Linear.Poly) →
(Unit → motive (Int.Internal.Linear.Poly.num 0)) → ((x : Int.Internal.Linear.Poly) → motive x) → motive x | null | false |
CategoryTheory.GradedObject.isColimitCofan₃MapBifunctorBifunctor₂₃MapObj._proof_6 | Mathlib.CategoryTheory.GradedObject.Trifunctor | ∀ {I₁ : Type u_1} {I₂ : Type u_2} {I₃ : Type u_3} {J : Type u_5} {r : I₁ × I₂ × I₃ → J}
(ρ₂₃ : CategoryTheory.GradedObject.BifunctorComp₂₃IndexData r) (j : J) (x : ↑(ρ₂₃.q ⁻¹' {j})) (i₂ : I₂) (i₃ : I₃),
(i₂, i₃) ∈ ρ₂₃.p ⁻¹' {x.1.2} →
(x.1.1, i₂, i₃) ∈
(fun x =>
match x with
| (i₁, i₂, ... | null | false |
_private.Init.Data.Array.Sort.Lemmas.0.Array.MergeSort.merge_eq_listMerge | Init.Data.Array.Sort.Lemmas | ∀ {α : Type u_1} {xs ys : Array α} {le : α → α → Bool},
(Array.MergeSort.Internal.merge✝ xs ys le).toList = xs.toList.merge ys.toList le | null | true |
MeasureTheory.IntegrableOn.comp_neg_Iio | Mathlib.MeasureTheory.Group.Integral | ∀ {G : Type u_2} {F : Type u_4} [inst : MeasurableSpace G] [inst_1 : NormedAddCommGroup F] {μ : MeasureTheory.Measure G}
[inst_2 : PartialOrder G] [inst_3 : AddCommGroup G] [IsOrderedAddMonoid G] [MeasurableNeg G] [μ.IsNegInvariant]
{c : G} {f : G → F},
MeasureTheory.IntegrableOn f (Set.Ioi (-c)) μ → MeasureTheor... | null | true |
Ne.irrefl | Init.Core | ∀ {α : Sort u} {a : α}, a ≠ a → False | null | true |
List.zipWith_rotate_distrib | Mathlib.Data.List.Rotate | ∀ {α : Type u} {β : Type u_1} {γ : Type u_2} (f : α → β → γ) (l : List α) (l' : List β) (n : ℕ),
l.length = l'.length → (List.zipWith f l l').rotate n = List.zipWith f (l.rotate n) (l'.rotate n) | null | true |
Tactic.ComputeAsymptotics.MultiseriesExpansion.const_approximates._f | Mathlib.Tactic.ComputeAsymptotics.Multiseries.Basic | ∀ {c : ℝ} {basis : Tactic.ComputeAsymptotics.Basis}
(f :
List.below (motive := fun {basis} =>
Tactic.ComputeAsymptotics.WellFormedBasis basis →
(Tactic.ComputeAsymptotics.MultiseriesExpansion.const basis c).Approximates)
basis),
Tactic.ComputeAsymptotics.WellFormedBasis basis →
(Tactic.C... | null | false |
differentIdeal.eq_1 | Mathlib.RingTheory.DedekindDomain.Different | ∀ (A : Type u_1) (B : Type u_3) [inst : CommRing A] [inst_1 : CommRing B] [inst_2 : Algebra A B] [inst_3 : IsDomain A]
[inst_4 : IsDedekindDomain B] [inst_5 : Module.IsTorsionFree A B],
differentIdeal A B =
Submodule.comap (Algebra.linearMap B (FractionRing B)) (1 / Submodule.traceDual A (FractionRing A) 1) | null | true |
CategoryTheory.Triangulated.TStructure.descTruncGT.congr_simp | Mathlib.CategoryTheory.Triangulated.TStructure.TruncLEGT | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Preadditive C]
[inst_2 : CategoryTheory.Limits.HasZeroObject C] [inst_3 : CategoryTheory.HasShift C ℤ]
[inst_4 : ∀ (n : ℤ), (CategoryTheory.shiftFunctor C n).Additive] [inst_5 : CategoryTheory.Pretriangulated C]
(t : CategoryT... | null | true |
Std.ExtTreeMap.getKey!_modify | Std.Data.ExtTreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.ExtTreeMap α β cmp} [inst : Std.TransCmp cmp]
[inst_1 : Inhabited α] {k k' : α} {f : β → β},
(t.modify k f).getKey! k' = if cmp k k' = Ordering.eq then if k ∈ t then k else default else t.getKey! k' | null | true |
map_rat_smul | Mathlib.Algebra.Module.Rat | ∀ {M : Type u_1} {M₂ : Type u_2} [inst : AddCommGroup M] [inst_1 : AddCommGroup M₂] [_instM : Module ℚ M]
[_instM₂ : Module ℚ M₂] {F : Type u_3} [inst_2 : FunLike F M M₂] [AddMonoidHomClass F M M₂] (f : F) (c : ℚ) (x : M),
f (c • x) = c • f x | null | true |
_private.Mathlib.Topology.Order.MonotoneConvergence.0.Pi.supConvergenceClass._simp_2 | Mathlib.Topology.Order.MonotoneConvergence | ∀ {α : Type u_1} {β : Type u_2} (f : α → β) (s : Set α), f '' s = Set.range (s.domRestrict f) | null | false |
NormedRing.induced._proof_13 | Mathlib.Analysis.Normed.Ring.Basic | ∀ {F : Type u_3} (R : Type u_1) (S : Type u_2) [inst : FunLike F R S] [inst_1 : NormedRing S] (f : F),
Filter.comap (⇑f) (Bornology.cobounded S) ≤ Filter.cofinite | null | false |
CategoryTheory.Limits.coconeOfCoconeUncurryIsColimit._proof_3 | Mathlib.CategoryTheory.Limits.Fubini | ∀ {J : Type u_4} {K : Type u_6} [inst : CategoryTheory.Category.{u_3, u_4} J]
[inst_1 : CategoryTheory.Category.{u_5, u_6} K] {C : Type u_2} [inst_2 : CategoryTheory.Category.{u_1, u_2} C]
{F : CategoryTheory.Functor J (CategoryTheory.Functor K C)} {D : CategoryTheory.Limits.DiagramOfCocones F}
(Q : (j : J) → Cat... | null | false |
Polynomial.natTrailingDegree_mul' | Mathlib.Algebra.Polynomial.Degree.TrailingDegree | ∀ {R : Type u} [inst : Semiring R] {p q : Polynomial R},
p.trailingCoeff * q.trailingCoeff ≠ 0 → (p * q).natTrailingDegree = p.natTrailingDegree + q.natTrailingDegree | null | true |
Finpartition.combine._proof_2 | Mathlib.Order.Partition.Finpartition | ∀ {α : Type u_1} [inst : Lattice α] [inst_1 : OrderBot α] [inst_2 : DecidableEq α] {ι : Type u_2} {I : Finset ι}
{a : ι → α} (P : (i : ι) → Finpartition (a i)), (I.biUnion fun i => (P i).parts).sup id = I.sup a | null | false |
_private.Init.Data.BitVec.Bitblast.0.BitVec.getMsbD_umod._proof_1_1 | Init.Data.BitVec.Bitblast | ∀ {w i : ℕ}, ¬i < w → ¬w ≤ i → False | null | false |
Commute.intCast_right | Mathlib.Data.Int.Cast.Lemmas | ∀ {α : Type u_2} [inst : NonAssocRing α] {a : α} {n : ℤ}, Commute a ↑n | null | true |
Nat.monotone_primeCounting | Mathlib.NumberTheory.PrimeCounting | Monotone Nat.primeCounting | null | true |
_private.Mathlib.Combinatorics.SimpleGraph.Extremal.Turan.0.SimpleGraph.turanNumber_two._proof_1_2 | Mathlib.Combinatorics.SimpleGraph.Extremal.Turan | ∀ (k : ℕ), ((2 * k + 1) ^ 2 - 1) / 4 = (2 * k + 1) ^ 2 / 4 | null | false |
HasFPowerSeriesOnBall.pi | Mathlib.Analysis.Analytic.Constructions | ∀ {𝕜 : Type u_2} [inst : NontriviallyNormedField 𝕜] {E : Type u_3} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {ι : Type u_9} [inst_3 : Fintype ι] {e : E} {Fm : ι → Type u_10}
[inst_4 : (i : ι) → NormedAddCommGroup (Fm i)] [inst_5 : (i : ι) → NormedSpace 𝕜 (Fm i)] {f : (i : ι) → E → Fm i}
{r : ... | null | true |
_private.Mathlib.Algebra.SkewMonoidAlgebra.Basic.0.SkewMonoidAlgebra.smul.eq_1 | Mathlib.Algebra.SkewMonoidAlgebra.Basic | ∀ {k : Type u_1} {G : Type u_2} [inst : AddMonoid k] {S : Type u_3} [inst_1 : SMulZeroClass S k] (x : S) (b : G →₀ k),
SkewMonoidAlgebra.smul✝ x { coeff := b } = { coeff := x • b } | null | true |
alexDiscEquivPreord._proof_5 | Mathlib.Topology.Order.Category.AlexDisc | ∀ (X : AlexDisc),
CategoryTheory.CategoryStruct.comp
(((CategoryTheory.forget₂ AlexDisc TopCat).comp topToPreord).map
((CategoryTheory.NatIso.ofComponents
(fun X => AlexDisc.Iso.mk (id (homeoWithUpperSetTopologyorderIso ↑X.toTopCat)))
@alexDiscEquivPreord._proof_3).hom.ap... | null | false |
Aesop.EqualUpToIdsM.State.mk.inj | Aesop.Util.EqualUpToIds | ∀ {equalMVarIds : Std.HashMap Lean.MVarId Lean.MVarId} {equalLMVarIds : Std.HashMap Lean.LMVarId Lean.LMVarId}
{leftUnassignedMVarValues rightUnassignedMVarValues : Std.HashMap Lean.MVarId Lean.Expr}
{equalMVarIds_1 : Std.HashMap Lean.MVarId Lean.MVarId} {equalLMVarIds_1 : Std.HashMap Lean.LMVarId Lean.LMVarId}
{... | null | true |
MeasureTheory.weightedSMul_union | Mathlib.MeasureTheory.Integral.Bochner.L1 | ∀ {α : Type u_1} {F : Type u_3} [inst : NormedAddCommGroup F] [inst_1 : NormedSpace ℝ F] {m : MeasurableSpace α}
{μ : MeasureTheory.Measure α} (s t : Set α),
MeasurableSet s →
MeasurableSet t →
μ s ≠ ⊤ →
μ t ≠ ⊤ →
Disjoint s t →
MeasureTheory.weightedSMul μ (s ∪ t) = MeasureT... | null | true |
_private.Mathlib.RingTheory.Multiplicity.0.FiniteMultiplicity.or_of_add._simp_1_1 | Mathlib.RingTheory.Multiplicity | ∀ {α : Type u_1} [inst : Add α] [inst_1 : Semigroup α] [LeftDistribClass α] {a b c : α},
a ∣ b → a ∣ c → (a ∣ b + c) = True | null | false |
IsEllipticSequence.comp | Mathlib.NumberTheory.EllipticDivisibilitySequence | ∀ {R : Type u_1} {S : Type u_2} [inst : CommRing R] [inst_1 : CommRing S] {W : ℤ → R} {F : Type u_3}
[inst_2 : FunLike F R S] [RingHomClass F R S], IsEllipticSequence W → ∀ (f : F), IsEllipticSequence (⇑f ∘ W) | null | true |
CategoryTheory.Limits.WidePullbackShape.uliftEquivalence.eq_1 | Mathlib.CategoryTheory.Limits.Shapes.WidePullbacks | ∀ {J : Type w},
CategoryTheory.Limits.WidePullbackShape.uliftEquivalence =
(CategoryTheory.ULiftHomULiftCategory.equiv (CategoryTheory.Limits.WidePullbackShape J)).symm.trans
(CategoryTheory.Limits.WidePullbackShape.equivalenceOfEquiv (ULift.{w', w} J) Equiv.ulift.symm) | null | true |
AddSubgroup.rightCosetEquivAddSubgroup._proof_5 | Mathlib.GroupTheory.Coset.Basic | ∀ {α : Type u_1} [inst : AddGroup α] {s : AddSubgroup α} (g : α) (x : ↑(AddOpposite.op g +ᵥ ↑s)),
∃ a ∈ ↑s, AddOpposite.op g +ᵥ a = ↑⟨↑x + -g, ⋯⟩ + g | null | false |
_private.Mathlib.Tactic.CategoryTheory.Coherence.0.Mathlib.Tactic.Coherence.coherenceLoop.match_1 | Mathlib.Tactic.CategoryTheory.Coherence | (motive : ℕ → Sort u_1) →
(maxSteps : ℕ) → (Unit → motive 0) → ((maxSteps' : ℕ) → motive maxSteps'.succ) → motive maxSteps | null | false |
IsAlgebraic.inv_iff | Mathlib.RingTheory.Algebraic.Basic | ∀ {R : Type u} [inst : CommRing R] {K : Type u_2} [inst_1 : Field K] [inst_2 : Algebra R K] {x : K},
IsAlgebraic R x⁻¹ ↔ IsAlgebraic R x | null | true |
Ordnode.instInsert | Mathlib.Data.Ordmap.Ordnode | {α : Type u_1} → [inst : LE α] → [DecidableLE α] → Insert α (Ordnode α) | null | true |
Lean.Meta.Grind.TopSort.State.mk.inj | Lean.Meta.Tactic.Grind.EqResolution | ∀ {tempMark permMark : Std.HashSet Lean.Expr} {result : Array Lean.Expr} {tempMark_1 permMark_1 : Std.HashSet Lean.Expr}
{result_1 : Array Lean.Expr},
{ tempMark := tempMark, permMark := permMark, result := result } =
{ tempMark := tempMark_1, permMark := permMark_1, result := result_1 } →
tempMark = temp... | null | true |
AddCommMonCat.limitAddCommMonoid._proof_5 | Mathlib.Algebra.Category.MonCat.Limits | ∀ {J : Type u_3} [inst : CategoryTheory.Category.{u_1, u_3} J] (F : CategoryTheory.Functor J AddCommMonCat)
[inst_1 : Small.{u_2, max u_2 u_3} ↑(F.comp (CategoryTheory.forget AddCommMonCat)).sections]
(a b c : (CategoryTheory.Limits.Types.Small.limitCone (F.comp (CategoryTheory.forget AddCommMonCat))).pt),
a + b ... | null | false |
CategoryTheory.ObjectProperty.comma_iff._simp_1 | Mathlib.CategoryTheory.ObjectProperty.Comma | ∀ {C₁ : Type u_1} {C₂ : Type u_2} {D : Type u_3} [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} D]
{F₁ : CategoryTheory.Functor C₁ D} {F₂ : CategoryTheory.Functor C₂ D} (P₁ : CategoryTheory.ObjectProperty C₁)
(P₂ : Categ... | null | false |
List.Sublist.reverse | Init.Data.List.Sublist | ∀ {α : Type u_1} {l₁ l₂ : List α}, l₁.Sublist l₂ → l₁.reverse.Sublist l₂.reverse | null | true |
SeparationQuotient.inseparableSetoid_eq_top_iff | Mathlib.Topology.Inseparable | ∀ {α : Type u_4} [inst : TopologicalSpace α], inseparableSetoid α = ⊤ ↔ IndiscreteTopology α | null | true |
MeasureTheory.MemLp.comp_fst | Mathlib.MeasureTheory.Function.LpSeminorm.Prod | ∀ {α : Type u_1} {β : Type u_2} {ε : Type u_3} {mα : MeasurableSpace α} {mβ : MeasurableSpace β}
[inst : TopologicalSpace ε] [inst_1 : ContinuousENorm ε] {μ : MeasureTheory.Measure α} {p : ENNReal} {f : α → ε},
MeasureTheory.MemLp f p μ →
∀ (ν : MeasureTheory.Measure β) [MeasureTheory.IsFiniteMeasure ν], Measur... | null | true |
Set.Iic_subset_Iio._gcongr_2 | Mathlib.Order.Interval.Set.Basic | ∀ {α : Type u_1} [inst : Preorder α] {a b : α}, a < b → Set.Iic a ⊆ Set.Iio b | null | false |
Orientation.definition._proof_2._@.Mathlib.Analysis.InnerProductSpace.Orientation.2114562672._hygCtx._hyg.2 | Mathlib.Analysis.InnerProductSpace.Orientation | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : InnerProductSpace ℝ E] (o : Orientation ℝ E (Fin 0)),
o = positiveOrientation ∨ o = -positiveOrientation | null | false |
List.scanr_ne_nil | Init.Data.List.Scan.Lemmas | ∀ {α : Type u_1} {β : Type u_2} {b : β} {l : List α} {f : α → β → β}, List.scanr f b l ≠ [] | null | true |
_private.Mathlib.Data.Set.Card.0.Set.three_lt_ncard._simp_1_1 | Mathlib.Data.Set.Card | ∀ {α : Sort u_1} {p : α → Prop} {b : Prop}, (∃ x, b ∧ p x) = (b ∧ ∃ x, p x) | null | false |
Mathlib.Tactic.Widget.StringDiagram.Node.id.inj | Mathlib.Tactic.Widget.StringDiagram | ∀ {a a_1 : Mathlib.Tactic.Widget.StringDiagram.IdNode},
Mathlib.Tactic.Widget.StringDiagram.Node.id a = Mathlib.Tactic.Widget.StringDiagram.Node.id a_1 → a = a_1 | null | true |
IsDedekindDomain.normalizedFactorsEquivOfQuotEquiv._proof_7 | Mathlib.RingTheory.DedekindDomain.Ideal.Lemmas | ∀ {R : Type u_1} {A : Type u_2} [inst : CommRing R] [inst_1 : CommRing A] [inst_2 : IsDedekindDomain A] {I : Ideal R}
{J : Ideal A} [inst_3 : IsDedekindDomain R] (f : R ⧸ I ≃+* A ⧸ J) (hI : I ≠ ⊥) (hJ : J ≠ ⊥) (j : Ideal R)
(hj : j ∈ {L | L ∈ UniqueFactorizationMonoid.normalizedFactors I}),
(fun j => ⟨↑((IsDedeki... | null | false |
extDerivWithin_constOfIsEmpty | Mathlib.Analysis.Calculus.DifferentialForm.Basic | ∀ {𝕜 : Type u_1} {E : Type u_2} {F : Type u_3} [inst : NontriviallyNormedField 𝕜] [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {s : Set E} {x : E} (f : E → F),
UniqueDiffWithinAt 𝕜 s x →
extDerivWithin (fun x => ContinuousAlternatingM... | The exterior derivative of a `0`-form given by a function `f` within a set
is the 1-form given by the derivative of `f` within the set. | true |
_private.Init.Data.String.Lemmas.Pattern.Memcmp.0.String.Slice.Pattern.Internal.memcmpStr_eq_true_iff._proof_1_18 | Init.Data.String.Lemmas.Pattern.Memcmp | ∀ {lhs rhs : String} {lstart rstart : String.Pos.Raw} {len : String.Pos.Raw} (p : String.Pos.Raw),
p.byteIdx < len.byteIdx → ¬0 < len.byteIdx - p.byteIdx → False | null | false |
PartialHomeomorph.toPartialEquiv | Mathlib.Topology.PartialHomeomorph.Defs | {X : Type u_5} →
{Y : Type u_6} →
[inst : TopologicalSpace X] → [inst_1 : TopologicalSpace Y] → PartialHomeomorph X Y → PartialEquiv X Y | null | true |
CategoryTheory.Functor.IsLocallyDirected.recOn | Mathlib.CategoryTheory.LocallyDirected | {J : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} J] →
{F : CategoryTheory.Functor J (Type u_2)} →
{motive : F.IsLocallyDirected → Sort u} →
(t : F.IsLocallyDirected) →
((cond :
∀ {i j k : J} (fi : i ⟶ k) (fj : j ⟶ k) (xi : F.obj i) (xj : F.obj j),
... | null | false |
_private.Mathlib.Analysis.Calculus.ContDiff.Bounds.0.norm_iteratedFDerivWithin_comp_le._simp_1_1 | Mathlib.Analysis.Calculus.ContDiff.Bounds | ∀ {α : Type u} {β : Type v} {f : α → β} {s : Set β} {a : α}, (a ∈ f ⁻¹' s) = (f a ∈ s) | null | false |
Int8.toInt_div | Init.Data.SInt.Lemmas | ∀ (a b : Int8), (a / b).toInt = (a.toInt.tdiv b.toInt).bmod (2 ^ 8) | null | true |
ContinuousMultilinearMap.compAlongComposition._proof_3 | Mathlib.Analysis.Analytic.Composition | ∀ {𝕜 : Type u_4} {E : Type u_1} {F : Type u_3} {G : Type u_2} [inst : CommRing 𝕜] [inst_1 : AddCommGroup E]
[inst_2 : AddCommGroup F] [inst_3 : AddCommGroup G] [inst_4 : Module 𝕜 E] [inst_5 : Module 𝕜 F] [inst_6 : Module 𝕜 G]
[inst_7 : TopologicalSpace E] [inst_8 : TopologicalSpace F] [inst_9 : TopologicalSpac... | null | false |
Polynomial.nthRootsFinset_def | Mathlib.Algebra.Polynomial.Roots | ∀ (n : ℕ) {R : Type u_1} (a : R) [inst : CommRing R] [inst_1 : IsDomain R] [inst_2 : DecidableEq R],
Polynomial.nthRootsFinset n a = (Polynomial.nthRoots n a).toFinset | null | true |
DirectSum.id._proof_1 | Mathlib.Algebra.DirectSum.Basic | ∀ (M : Type u_2) (ι : Type u_1) [inst : AddCommMonoid M] [inst_1 : Unique ι],
(DirectSum.of (fun x => M) default) ((DirectSum.toAddMonoid fun x => AddMonoidHom.id M) 0) = 0 | null | false |
_private.Init.Data.Vector.Erase.0.Vector.eraseIdx_append._proof_3 | Init.Data.Vector.Erase | ∀ {n m k : ℕ}, k < n + m → ¬k < n → ¬k - n < m → False | null | false |
Lean.Order.instMonadTailId._aux_1 | Init.Internal.Order.MonadTail | (x : Type u_1) → [Nonempty x] → Id x → Id x → Prop | null | false |
Primrec.list_cons | Mathlib.Computability.Primrec.List | ∀ {α : Type u_1} [inst : Primcodable α], Primrec₂ List.cons | null | true |
_private.Init.Data.Vector.OfFn.0.Vector.ofFnM.go._unary._proof_2 | Init.Data.Vector.OfFn | ∀ {α : Type u_1} (i : ℕ) (acc : Array α), acc.size = i → ∀ (__do_lift : α), (acc.push __do_lift).size = i + 1 | null | false |
AlgebraicGeometry.instIsStableUnderCompositionSchemeLocallyOfFiniteType | Mathlib.AlgebraicGeometry.Morphisms.FiniteType | CategoryTheory.MorphismProperty.IsStableUnderComposition @AlgebraicGeometry.LocallyOfFiniteType | null | true |
Pregroupoid.mk._flat_ctor | Mathlib.Geometry.Manifold.StructureGroupoid | {H : Type u_2} →
[inst : TopologicalSpace H] →
(property : (H → H) → Set H → Prop) →
(∀ {f g : H → H} {u v : Set H},
property f u → property g v → IsOpen u → IsOpen v → IsOpen (u ∩ f ⁻¹' v) → property (g ∘ f) (u ∩ f ⁻¹' v)) →
property id Set.univ →
(∀ {f : H → H} {u : Set H}, IsO... | null | false |
Array.eraseIdxIfInBounds | Init.Data.Array.Basic | {α : Type u} → Array α → ℕ → Array α | Removes the element at a given index from an array. Does nothing if the index is out of bounds.
This function takes worst-case `O(n)` time because it back-shifts all elements at positions greater
than `i`.
Examples:
* `#["apple", "pear", "orange"].eraseIdxIfInBounds 0 = #["pear", "orange"]`
* `#["apple", "pear", "ora... | true |
ArithmeticFunction.instModule._proof_5 | Mathlib.NumberTheory.ArithmeticFunction.Defs | ∀ {R : Type u_2} {S : Type u_1} [inst : Semiring R] [inst_1 : AddCommMonoid S] [inst_2 : Module R S] (x : R)
(f g : ArithmeticFunction S), x • (f + g) = x • f + x • g | null | false |
Set.compl_Ioc | Mathlib.Order.Interval.Set.LinearOrder | ∀ {α : Type u_1} [inst : LinearOrder α] {a b : α}, (Set.Ioc a b)ᶜ = Set.Iic a ∪ Set.Ioi b | null | true |
_private.Mathlib.Data.List.Interleave.0.List.interleaves_reverse_reverse_of_length_eq_length_add_one._simp_1_1 | Mathlib.Data.List.Interleave | ∀ {α : Type u_1} {r : α → α → Prop} {l₁ l₂ : List α},
List.Interleaves r l₁ l₂ = (l₁.length ⩿ l₂.length ∧ List.IsChain r (l₂.interleave l₁)) | null | false |
Finsupp.instNonUnitalNonAssocRing._proof_6 | Mathlib.Data.Finsupp.Pointwise | ∀ {α : Type u_1} {β : Type u_2} [inst : NonUnitalNonAssocRing β] (g₁ g₂ : α →₀ β), ⇑(g₁ - g₂) = ⇑g₁ - ⇑g₂ | null | false |
Std.ExtTreeSet.toArray | Std.Data.ExtTreeSet.Basic | {α : Type u} → {cmp : α → α → Ordering} → [Std.TransCmp cmp] → Std.ExtTreeSet α cmp → Array α | Transforms the tree set into an array of elements in ascending order. | true |
Mathlib.Tactic.Order.AtomicFact.lt | Mathlib.Tactic.Order.CollectFacts | ℕ → ℕ → Lean.Expr → Mathlib.Tactic.Order.AtomicFact | null | true |
CategoryTheory.Limits.Cotrident.ext._proof_6 | Mathlib.CategoryTheory.Limits.Shapes.WideEqualizers | ∀ {J : Type u_3} {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {X Y : C} {f : J → (X ⟶ Y)}
[inst_1 : Nonempty J] {s t : CategoryTheory.Limits.Cotrident f} (i : s.pt ≅ t.pt)
(w : CategoryTheory.CategoryStruct.comp s.π i.hom = t.π),
CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.Cotrident.... | null | false |
Array.forIn'_yield_eq_foldlM | Init.Data.Array.Monadic | ∀ {m : Type u_1 → Type u_2} {α : Type u_3} {β γ : Type u_1} [inst : Monad m] [LawfulMonad m] {xs : Array α}
(f : (a : α) → a ∈ xs → β → m γ) (g : (a : α) → a ∈ xs → β → γ → β) (init : β),
(forIn' xs init fun a m_1 b => (fun c => ForInStep.yield (g a m_1 b c)) <$> f a m_1 b) =
Array.foldlM
(fun b x =>
... | We can express a for loop over an array which always yields as a fold. | true |
Std.Sat.AIG.CacheHit.casesOn | Std.Sat.AIG.Basic | {α : Type} →
{decls : Array (Std.Sat.AIG.Decl α)} →
{decl : Std.Sat.AIG.Decl α} →
{motive : Std.Sat.AIG.CacheHit decls decl → Sort u} →
(t : Std.Sat.AIG.CacheHit decls decl) →
((idx : ℕ) →
(hbound : idx < decls.size) →
(hvalid : decls[idx] = decl) → motive { i... | null | false |
Std.Time.TimeZone | Std.Time.Zoned.TimeZone | Type | A TimeZone structure that stores the timezone offset, the name, abbreviation and if it's in daylight
saving time.
| true |
Lean.Meta.Grind.Arith.Cutsat.DiseqCnstrProof.coreToInt.injEq | Lean.Meta.Tactic.Grind.Arith.Cutsat.Types | ∀ (a b toIntThm : Lean.Expr) (lhs rhs : Int.Internal.Linear.Expr) (a_1 b_1 toIntThm_1 : Lean.Expr)
(lhs_1 rhs_1 : Int.Internal.Linear.Expr),
(Lean.Meta.Grind.Arith.Cutsat.DiseqCnstrProof.coreToInt a b toIntThm lhs rhs =
Lean.Meta.Grind.Arith.Cutsat.DiseqCnstrProof.coreToInt a_1 b_1 toIntThm_1 lhs_1 rhs_1) =
... | null | true |
Prime.nat_prime | Mathlib.Data.Nat.Prime.Defs | ∀ {p : ℕ}, Prime p → Nat.Prime p | **Alias** of the reverse direction of `Nat.prime_iff`. | true |
Bundle.Pretrivialization.continuousOn_continuousLinearMapCoordChange | Mathlib.Topology.VectorBundle.Hom | ∀ {𝕜₁ : Type u_1} [inst : NontriviallyNormedField 𝕜₁] {𝕜₂ : Type u_2} [inst_1 : NontriviallyNormedField 𝕜₂]
{σ : 𝕜₁ →+* 𝕜₂} {B : Type u_3} {F₁ : Type u_4} [inst_2 : NormedAddCommGroup F₁] [inst_3 : NormedSpace 𝕜₁ F₁]
{E₁ : B → Type u_5} [inst_4 : (x : B) → AddCommGroup (E₁ x)] [inst_5 : (x : B) → Module 𝕜₁ ... | null | true |
CategoryTheory.Limits.BinaryBicone.ofColimitCocone._proof_8 | Mathlib.CategoryTheory.Preadditive.Biproducts | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Preadditive C] {X Y : C}
{t : CategoryTheory.Limits.Cocone (CategoryTheory.Limits.pair X Y)} (ht : CategoryTheory.Limits.IsColimit t),
CategoryTheory.CategoryStruct.comp (t.ι.app { as := CategoryTheory.Limits.WalkingPair.right }... | null | false |
_private.Mathlib.SetTheory.Ordinal.Notation.0.ONote.exists_lt_omega0_opow' | Mathlib.SetTheory.Ordinal.Notation | ∀ {α : Sort u_1} {o b : Ordinal.{u_2}},
1 < b →
Order.IsSuccLimit o →
∀ {f : α → Ordinal.{u_2}},
(∀ ⦃a : Ordinal.{u_2}⦄, a < o → ∃ i, a < f i) → ∀ ⦃a : Ordinal.{u_2}⦄, a < b ^ o → ∃ i, a < b ^ f i | null | true |
CategoryTheory.MonoidalCategory.whiskerLeft_inv_hom' | Mathlib.CategoryTheory.Monoidal.Category | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.MonoidalCategory C] (X : C) {Y Z : C}
(f : Y ⟶ Z) [inst_2 : CategoryTheory.IsIso f],
CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategoryStruct.whiskerLeft X (CategoryTheory.inv f))
(CategoryTheory.MonoidalCategor... | null | true |
TopCat.Path.hom₁._autoParam | Mathlib.Topology.Homotopy.TopCat.Path | Lean.Syntax | null | false |
Option.forIn_yield_eq_elim | Init.Data.Option.Monadic | ∀ {m : Type u_1 → Type u_2} {α : Type u_3} {β γ : Type u_1} [inst : Monad m] [LawfulMonad m] (o : Option α)
(f : α → β → m γ) (g : α → β → γ → β) (b : β),
(forIn o b fun a b => (fun c => ForInStep.yield (g a b c)) <$> f a b) = o.elim (pure b) fun a => g a b <$> f a b | null | true |
Real.tan_arccos | Mathlib.Analysis.SpecialFunctions.Trigonometric.Inverse | ∀ (x : ℝ), Real.tan (Real.arccos x) = √(1 - x ^ 2) / x | null | true |
_private.Init.Data.Option.Lemmas.0.Option.not_rel_none_some.match_1_1 | Init.Data.Option.Lemmas | ∀ {α : Type u_1} {β : Type u_2} {a : β} {r : α → β → Prop} (motive : Option.Rel r none (some a) → Prop)
(a : Option.Rel r none (some a)), motive a | null | false |
Algebra.TensorProduct.mul | Mathlib.RingTheory.TensorProduct.Basic | {R : Type uR} →
{A : Type uA} →
{B : Type uB} →
[inst : CommSemiring R] →
[inst_1 : NonUnitalNonAssocSemiring A] →
[inst_2 : Module R A] →
[SMulCommClass R A A] →
[IsScalarTower R A A] →
[inst_5 : NonUnitalNonAssocSemiring B] →
[i... | (Implementation detail)
The multiplication map on `A ⊗[R] B`,
as an `R`-bilinear map.
| true |
CategoryTheory.ExponentiableMorphism.unit_pushforwardComp_hom_assoc | Mathlib.CategoryTheory.LocallyCartesianClosed.ExponentiableMorphism | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {I J K : C} (f : I ⟶ J) (g : J ⟶ K)
[inst_1 : CategoryTheory.ChosenPullbacksAlong f] [inst_2 : CategoryTheory.ChosenPullbacksAlong g]
[inst_3 : CategoryTheory.ChosenPullbacksAlong (CategoryTheory.CategoryStruct.comp f g)]
[inst_4 : CategoryTheory.Exponentia... | null | true |
ContinuousMultilinearMap.alternatization._proof_3 | Mathlib.Topology.Algebra.Module.Alternating.Basic | ∀ {R : Type u_4} {M : Type u_1} {N : Type u_2} {ι : Type u_3} [inst : Semiring R] [inst_1 : AddCommMonoid M]
[inst_2 : Module R M] [inst_3 : TopologicalSpace M] [inst_4 : AddCommGroup N] [inst_5 : Module R N]
[inst_6 : TopologicalSpace N] [inst_7 : IsTopologicalAddGroup N] [inst_8 : Fintype ι] [inst_9 : DecidableEq... | null | false |
CategoryTheory.BiconeHom.decidableEq._proof_11 | Mathlib.CategoryTheory.Limits.Bicones | ∀ (J : Type u_1) [inst : CategoryTheory.Category.{u_2, u_1} J]
(g : CategoryTheory.BiconeHom J CategoryTheory.Bicone.right CategoryTheory.Bicone.right), g ≍ g | null | false |
BitVec.ofNat_toNat | Init.Data.BitVec.Bootstrap | ∀ {n : ℕ} (m : ℕ) (x : BitVec n), BitVec.ofNat m x.toNat = BitVec.setWidth m x | null | true |
AlgebraicGeometry.Scheme.instAbelianSheafEtaleSmallEtaleTopology | Mathlib.AlgebraicGeometry.Sites.AffineEtale | {S : AlgebraicGeometry.Scheme} →
{A : Type u'} →
[inst : CategoryTheory.Category.{u, u'} A] →
{FA : A → A → Type u_1} →
{CD : A → Type u} →
[inst_1 : (X Y : A) → FunLike (FA X Y) (CD X) (CD Y)] →
[inst_2 : CategoryTheory.ConcreteCategory A FA] →
[CategoryTheory.Li... | null | true |
_private.Init.Data.List.Perm.0.List.perm_middle.match_1_1 | Init.Data.List.Perm | ∀ {α : Type u_1} (motive : List α → List α → Prop) (x x_1 : List α),
(∀ (x : List α), motive [] x) → (∀ (b : α) (tail x : List α), motive (b :: tail) x) → motive x x_1 | null | false |
Lean.Elab.Term.Do.ToTerm.Kind._sizeOf_1 | Lean.Elab.Do.Legacy | Lean.Elab.Term.Do.ToTerm.Kind → ℕ | null | false |
Filter.HasBasis.lift | Mathlib.Order.Filter.Lift | ∀ {α : Type u_1} {γ : Type u_3} {ι : Type u_6} {p : ι → Prop} {s : ι → Set α} {f : Filter α},
f.HasBasis p s →
∀ {β : ι → Type u_5} {pg : (i : ι) → β i → Prop} {sg : (i : ι) → β i → Set γ} {g : Set α → Filter γ},
(∀ (i : ι), (g (s i)).HasBasis (pg i) (sg i)) →
Monotone g → (f.lift g).HasBasis (fun i... | If `(p : ι → Prop, s : ι → Set α)` is a basis of a filter `f`, `g` is a monotone function
`Set α → Filter γ`, and for each `i`, `(pg : β i → Prop, sg : β i → Set α)` is a basis
of the filter `g (s i)`, then
`(fun (i : ι) (x : β i) ↦ p i ∧ pg i x, fun (i : ι) (x : β i) ↦ sg i x)`
is a basis of the filter `f.lift g`.
Th... | true |
CoalgebraStruct.mk._flat_ctor | Mathlib.RingTheory.Coalgebra.Basic | {R : Type u} →
{A : Type v} →
[inst : CommSemiring R] →
[inst_1 : AddCommMonoid A] →
[inst_2 : Module R A] → (A →ₗ[R] TensorProduct R A A) → (A →ₗ[R] R) → CoalgebraStruct R A | null | false |
_private.Std.Data.DTreeMap.Internal.Operations.0.Std.DTreeMap.Internal.Impl.filterMap._proof_9 | Std.Data.DTreeMap.Internal.Operations | ∀ {α : Type u_1} {β : α → Type u_3} {γ : α → Type u_2} (sz : ℕ) (k : α) (v : β k) (l r : Std.DTreeMap.Internal.Impl α β)
(hl : (Std.DTreeMap.Internal.Impl.inner sz k v l r).Balanced) (v' : γ k) (l' : Std.DTreeMap.Internal.Impl α γ)
(hl' : l'.Balanced) (r' : Std.DTreeMap.Internal.Impl α γ) (hr' : r'.Balanced),
(St... | null | false |
ZFClass.powerset | Mathlib.SetTheory.ZFC.Class | ZFClass.{u_1} → ZFClass.{u_1} | The power class of a class is the class of all subclasses that are ZFC sets | true |
CategoryTheory.ShortComplex.Homotopy.symm_h₀ | Mathlib.Algebra.Homology.ShortComplex.Preadditive | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Preadditive C]
{S₁ S₂ : CategoryTheory.ShortComplex C} {φ₁ φ₂ : S₁ ⟶ S₂} (h : CategoryTheory.ShortComplex.Homotopy φ₁ φ₂),
h.symm.h₀ = -h.h₀ | null | true |
Convexity.map_iConvexComb | Mathlib.Geometry.Convex.ConvexSpace.Defs | ∀ {R : Type u_1} {I : Type u_5} {J : Type u_6} {K : Type u_7} [inst : PartialOrder R] [inst_1 : Semiring R]
[inst_2 : IsStrictOrderedRing R] {f : J → K} (s : Convexity.StdSimplex R I) (g : I → Convexity.StdSimplex R J),
Convexity.StdSimplex.map f (Convexity.iConvexComb s g) = Convexity.iConvexComb s (Convexity.StdS... | null | true |
QuadraticModuleCat.ofIso._proof_2 | Mathlib.LinearAlgebra.QuadraticForm.QuadraticModuleCat | ∀ {R : Type u_2} [inst : CommRing R] {X Y : Type u_1} [inst_1 : AddCommGroup X] [inst_2 : Module R X]
[inst_3 : AddCommGroup Y] [inst_4 : Module R Y] {Q₁ : QuadraticForm R X} {Q₂ : QuadraticForm R Y}
(e : QuadraticMap.IsometryEquiv Q₁ Q₂),
CategoryTheory.CategoryStruct.comp (QuadraticModuleCat.ofHom e.symm.toIsom... | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.