name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
_private.Init.Data.SInt.Bitwise.0.Int8.not_eq_comm._simp_1_1 | Init.Data.SInt.Bitwise | ∀ {a b : Int8}, (a = b) = (a.toBitVec = b.toBitVec) | false |
Set.biUnionEqSigmaOfDisjoint.eq_1 | Mathlib.Data.Set.Pairwise.Lattice | ∀ {α : Type u_1} {ι : Type u_2} {s : Set ι} {f : ι → Set α} (h : s.PairwiseDisjoint f),
Set.biUnionEqSigmaOfDisjoint h = (Equiv.setCongr ⋯).trans (Set.unionEqSigmaOfDisjoint ⋯) | true |
Relation.map_map | Mathlib.Logic.Relation | ∀ {α : Sort u_1} {β : Sort u_2} {γ : Sort u_3} {δ : Sort u_4} {ε : Sort u_5} {ζ : Sort u_6} (r : α → β → Prop)
(f₁ : α → γ) (g₁ : β → δ) (f₂ : γ → ε) (g₂ : δ → ζ),
Relation.Map (Relation.Map r f₁ g₁) f₂ g₂ = Relation.Map r (f₂ ∘ f₁) (g₂ ∘ g₁) | true |
MeasureTheory.measure_eq_measure_smaller_of_between_null_diff | Mathlib.MeasureTheory.Measure.MeasureSpace | ∀ {α : Type u_1} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} {s₁ s₂ s₃ : Set α},
s₁ ⊆ s₂ → s₂ ⊆ s₃ → μ (s₃ \ s₁) = 0 → μ s₁ = μ s₂ | true |
Subgroup.orderIsoCon | Mathlib.GroupTheory.QuotientGroup.Defs | {G : Type u_1} → [inst : Group G] → { N // N.Normal } ≃o Con G | true |
CommMonCat.forget₂CreatesLimit._proof_11 | Mathlib.Algebra.Category.MonCat.Limits | ∀ {J : Type u_3} [inst : CategoryTheory.Category.{u_1, u_3} J] (F : CategoryTheory.Functor J CommMonCat)
[inst_1 : Small.{u_2, max u_2 u_3} ↑(F.comp (CategoryTheory.forget CommMonCat)).sections]
(x : CategoryTheory.Limits.Cone F),
(CategoryTheory.forget₂ CommMonCat MonCat).map
{
hom' :=
{
... | false |
_private.Std.Data.DHashMap.Internal.Defs.0.Std.DHashMap.Internal.Raw₀.expand.go.induct | Std.Data.DHashMap.Internal.WF | ∀ {α : Type u} {β : α → Type v} [inst : Hashable α]
(motive : ℕ → Array (Std.DHashMap.Internal.AssocList α β) → { d // 0 < d.size } → Prop),
(∀ (i : ℕ) (source : Array (Std.DHashMap.Internal.AssocList α β)) (target : { d // 0 < d.size })
(h : i < source.size),
have es := source[i];
have source_1 :... | true |
_private.Batteries.Data.RBMap.Lemmas.0.Batteries.RBNode.Ordered.memP_iff_lowerBound?.match_1_5 | Batteries.Data.RBMap.Lemmas | ∀ (motive : Ordering.eq = Ordering.lt → Prop) (x : Ordering.eq = Ordering.lt), motive x | false |
ContinuousLinearMap.equivProdOfSurjectiveOfIsCompl.congr_simp | Mathlib.Analysis.Calculus.Implicit | ∀ {𝕜 : 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] [inst_7 : CompleteSpace E] [inst_8 : ... | true |
Std.Sat.AIG.RelabelNat.State.noConfusionType | Std.Sat.AIG.RelabelNat | Sort u →
{α : Type} →
[inst : DecidableEq α] →
[inst_1 : Hashable α] →
{decls : Array (Std.Sat.AIG.Decl α)} →
{idx : ℕ} →
Std.Sat.AIG.RelabelNat.State α decls idx →
{α' : Type} →
[inst' : DecidableEq α'] →
[inst'_1 : Hashable α'] ... | false |
_private.Mathlib.RingTheory.OrderOfVanishing.0.Ring.ordFrac._simp_1 | Mathlib.RingTheory.OrderOfVanishing | ∀ {G₀ : Type u_3} [inst : GroupWithZero G₀] {a : G₀}, IsUnit a = (a ≠ 0) | false |
WellFounded.Nat.fix.go.congr_simp | Init.WF | ∀ {α : Sort u} {motive : α → Sort v} (h : α → ℕ)
(F F_1 : (x : α) → ((y : α) → InvImage (fun x1 x2 => x1 < x2) h y x → motive y) → motive x),
F = F_1 →
∀ (fuel fuel_1 : ℕ) (e_fuel : fuel = fuel_1) (x : α) (a : h x < fuel),
WellFounded.Nat.fix.go h F fuel x a = WellFounded.Nat.fix.go h F_1 fuel_1 x ⋯ | true |
hasSum_nat_jacobiTheta | Mathlib.NumberTheory.ModularForms.JacobiTheta.OneVariable | ∀ {τ : ℂ}, 0 < τ.im → HasSum (fun n => Complex.exp (↑Real.pi * Complex.I * (↑n + 1) ^ 2 * τ)) ((jacobiTheta τ - 1) / 2) | true |
Std.Sat.AIG.denote_idx_gate | Std.Sat.AIG.Lemmas | ∀ {α : Type} [inst : Hashable α] [inst_1 : DecidableEq α] {start : ℕ} {assign : α → Bool} {invert : Bool}
{lhs rhs : Std.Sat.AIG.Fanin} {aig : Std.Sat.AIG α} {hstart : start < aig.decls.size}
(h : aig.decls[start] = Std.Sat.AIG.Decl.gate lhs rhs),
⟦assign, { aig := aig, ref := { gate := start, invert := invert, h... | true |
TopologicalSpace.DiscreteTopology.metrizableSpace | Mathlib.Topology.Metrizable.Basic | ∀ {X : Type u_2} [inst : TopologicalSpace X] [DiscreteTopology X], TopologicalSpace.MetrizableSpace X | true |
CategoryTheory.Limits.isLimitOfHasBinaryProductOfPreservesLimit | Mathlib.CategoryTheory.Limits.Preserves.Shapes.BinaryProducts | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{D : Type u₂} →
[inst_1 : CategoryTheory.Category.{v₂, u₂} D] →
(G : CategoryTheory.Functor C D) →
(X Y : C) →
[inst_2 : CategoryTheory.Limits.HasBinaryProduct X Y] →
[CategoryTheory.Limits.PreservesLim... | true |
Real.fourierIntegralInv_comp_linearIsometry | Mathlib.Analysis.Fourier.FourierTransform | ∀ {V : Type u_1} {W : Type u_2} {E : Type u_3} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℂ E]
[inst_2 : NormedAddCommGroup V] [inst_3 : InnerProductSpace ℝ V] [inst_4 : MeasurableSpace V] [inst_5 : BorelSpace V]
[inst_6 : NormedAddCommGroup W] [inst_7 : InnerProductSpace ℝ W] [inst_8 : MeasurableSpace W] ... | true |
CategoryTheory.ShortComplex.Splitting.mk._flat_ctor | Mathlib.Algebra.Homology.ShortComplex.Exact | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
[inst_1 : CategoryTheory.Preadditive C] →
{S : CategoryTheory.ShortComplex C} →
(r : S.X₂ ⟶ S.X₁) →
(s : S.X₃ ⟶ S.X₂) →
autoParam (CategoryTheory.CategoryStruct.comp S.f r = CategoryTheory.CategoryStruct.id S.X₁)
... | false |
_private.Mathlib.Algebra.Star.UnitaryStarAlgAut.0.Unitary.conjStarAlgAut_ext_iff'._simp_1_6 | Mathlib.Algebra.Star.UnitaryStarAlgAut | ∀ {α : Type u} [inst : Monoid α] (b : αˣ) {a c : α}, (↑b * a = c) = (a = ↑b⁻¹ * c) | false |
Mathlib.Tactic.ITauto.Proof.orImpL.sizeOf_spec | Mathlib.Tactic.ITauto | ∀ (p : Mathlib.Tactic.ITauto.Proof), sizeOf p.orImpL = 1 + sizeOf p | true |
Dense.eq_of_inner_right | Mathlib.Analysis.InnerProductSpace.Continuous | ∀ {E : Type u_4} (𝕜 : Type u_7) [inst : RCLike 𝕜] [inst_1 : NormedAddCommGroup E] [inst_2 : InnerProductSpace 𝕜 E]
{x y : E} {S : Set E}, Dense S → (∀ v ∈ S, inner 𝕜 v x = inner 𝕜 v y) → x = y | true |
iteratedDerivWithin_add | Mathlib.Analysis.Calculus.IteratedDeriv.Lemmas | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {F : Type u_2} [inst_1 : NormedAddCommGroup F]
[inst_2 : NormedSpace 𝕜 F] {n : ℕ} {x : 𝕜} {s : Set 𝕜},
x ∈ s →
UniqueDiffOn 𝕜 s →
∀ {f g : 𝕜 → F},
ContDiffWithinAt 𝕜 (↑n) f s x →
ContDiffWithinAt 𝕜 (↑n) g s x →
iter... | true |
MeasureTheory.lintegral_def | Mathlib.MeasureTheory.Integral.Lebesgue.Basic | ∀ {α : Type u_4} {m : MeasurableSpace α} (μ : MeasureTheory.Measure α) (f : α → ENNReal),
MeasureTheory.lintegral μ f = ⨆ g, ⨆ (_ : ⇑g ≤ f), g.lintegral μ | true |
Polynomial.Splits.X_pow | Mathlib.Algebra.Polynomial.Splits | ∀ {R : Type u_1} [inst : Semiring R] (n : ℕ), (Polynomial.X ^ n).Splits | true |
Lean.Compiler.LCNF.Phase.le_refl._simp_1 | Lean.Compiler.LCNF.PassManager | ∀ (p : Lean.Compiler.LCNF.Phase), (p ≤ p) = True | false |
ENNReal.continuousAt_const_mul | Mathlib.Topology.Instances.ENNReal.Lemmas | ∀ {a b : ENNReal}, a ≠ ⊤ ∨ b ≠ 0 → ContinuousAt (fun x => a * x) b | true |
DirectSum.Decomposition.mk.noConfusion | Mathlib.Algebra.DirectSum.Decomposition | {ι : Type u_1} →
{M : Type u_3} →
{σ : Type u_4} →
{inst : DecidableEq ι} →
{inst_1 : AddCommMonoid M} →
{inst_2 : SetLike σ M} →
{inst_3 : AddSubmonoidClass σ M} →
{ℳ : ι → σ} →
{P : Sort u} →
{decompose' : M → DirectSum ι fun i ... | false |
_private.Mathlib.RingTheory.Adjoin.Field.0.AlgEquiv.adjoinSingletonEquivAdjoinRootMinpoly._simp_1 | Mathlib.RingTheory.Adjoin.Field | ∀ {R : Type u} {A : Type v} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A] (S : Subalgebra R A)
{x : ↥S}, (x = 0) = (↑x = 0) | false |
intervalIntegral.FTCFilter.le_nhds | Mathlib.MeasureTheory.Integral.IntervalIntegral.FundThmCalculus | ∀ {a : outParam ℝ} (outer : Filter ℝ) {inner : outParam (Filter ℝ)} [self : intervalIntegral.FTCFilter a outer inner],
inner ≤ nhds a | true |
Mathlib.Meta.Positivity.evalNNRealSqrt | Mathlib.Data.Real.Sqrt | Mathlib.Meta.Positivity.PositivityExt | true |
Submonoid.units._proof_2 | Mathlib.Algebra.Group.Submonoid.Units | ∀ {M : Type u_1} [inst : Monoid M] (S : Submonoid M) {x : Mˣ},
x ∈ (Submonoid.comap (Units.coeHom M) S ⊓ (Submonoid.comap (Units.coeHom M) S)⁻¹).carrier →
x⁻¹ ∈ ↑(Submonoid.comap (Units.coeHom M) S) ∧ x⁻¹ ∈ ↑(Submonoid.comap (Units.coeHom M) S)⁻¹ | false |
Order.isPredLimitRecOn_pred_of_not_isMin | Mathlib.Order.SuccPred.Limit | ∀ {α : Type u_1} {b : α} {motive : α → Sort u_2} [inst : LinearOrder α] [inst_1 : PredOrder α]
(isMax : (a : α) → IsMax a → motive a) (pred : (a : α) → ¬IsMin a → motive (Order.pred a))
(isPredLimit : (a : α) → Order.IsPredLimit a → motive a) (hb : ¬IsMin b),
Order.isPredLimitRecOn (Order.pred b) isMax pred isPre... | true |
CategoryTheory.ObjectProperty.isSeparating_unop_iff | Mathlib.CategoryTheory.Generator.Basic | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] (P : CategoryTheory.ObjectProperty Cᵒᵖ),
P.unop.IsSeparating ↔ P.IsCoseparating | true |
_private.Mathlib.Algebra.BigOperators.Group.Finset.Gaps.0.Finset.sum_eq_sum_range_intervalGapsWithin._proof_1_5 | Mathlib.Algebra.BigOperators.Group.Finset.Gaps | ∀ {k : ℕ}, ∀ i ∈ Set.Iio k, i ∈ Finset.range k | false |
Std.DTreeMap.Internal.Impl.get?ₘ_eq_getValueCast? | Std.Data.DTreeMap.Internal.WF.Lemmas | ∀ {α : Type u} {β : α → Type v} [inst : Ord α] [inst_1 : Std.TransOrd α] [inst_2 : Std.LawfulEqOrd α] [inst_3 : BEq α]
[inst_4 : Std.LawfulBEqOrd α] {k : α} {t : Std.DTreeMap.Internal.Impl α β},
t.Ordered → t.get?ₘ k = Std.Internal.List.getValueCast? k t.toListModel | true |
MeasureTheory.SignedMeasure.null_of_totalVariation_zero | Mathlib.MeasureTheory.VectorMeasure.Decomposition.Jordan | ∀ {α : Type u_1} [inst : MeasurableSpace α] (s : MeasureTheory.SignedMeasure α) {i : Set α},
s.totalVariation i = 0 → ↑s i = 0 | true |
CategoryTheory.Abelian.SpectralObject.homologyDataIdId_right_ι | Mathlib.Algebra.Homology.SpectralObject.Page | ∀ {C : Type u_1} {ι : Type u_2} [inst : CategoryTheory.Category.{v_1, u_1} C]
[inst_1 : CategoryTheory.Category.{v_2, u_2} ι] [inst_2 : CategoryTheory.Abelian C]
(X : CategoryTheory.Abelian.SpectralObject C ι) {i j : ι} (f : i ⟶ j) (n₀ n₁ n₂ : ℤ)
(hn₁ : autoParam (n₀ + 1 = n₁) CategoryTheory.Abelian.SpectralObjec... | true |
Module.Free.chooseBasis._proof_1 | Mathlib.LinearAlgebra.FreeModule.Basic | ∀ (R : Type u_2) (M : Type u_1) [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
[inst_3 : Module.Free R M], Nonempty (Module.Basis (↑⋯.choose) R M) | false |
Affine.Simplex.excenterWeights_compl | Mathlib.Geometry.Euclidean.Incenter | ∀ {V : Type u_1} {P : Type u_2} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V] [inst_2 : MetricSpace P]
[inst_3 : NormedAddTorsor V P] {n : ℕ} [inst_4 : NeZero n] (s : Affine.Simplex ℝ P n) (signs : Finset (Fin (n + 1))),
s.excenterWeights signsᶜ = s.excenterWeights signs | true |
_private.Mathlib.NumberTheory.SumFourSquares.0.Int.sq_add_sq_of_two_mul_sq_add_sq._simp_1_1 | Mathlib.NumberTheory.SumFourSquares | ∀ {α : Type u_2} [inst : Semiring α] {a : α}, (2 ∣ a) = Even a | false |
Representation.Coinvariants.hom_ext_iff | Mathlib.RepresentationTheory.Coinvariants | ∀ {k : Type u_1} {G : Type u_2} {V : Type u_3} {W : Type u_4} [inst : CommRing k] [inst_1 : Monoid G]
[inst_2 : AddCommGroup V] [inst_3 : Module k V] [inst_4 : AddCommGroup W] [inst_5 : Module k W]
{ρ : Representation k G V} {f g : ρ.Coinvariants →ₗ[k] W},
f = g ↔ f ∘ₗ Representation.Coinvariants.mk ρ = g ∘ₗ Repr... | true |
ValuativeRel.IsRankLeOne.mk | Mathlib.RingTheory.Valuation.ValuativeRel.Basic | ∀ {R : Type u_1} [inst : CommRing R] [inst_1 : ValuativeRel R],
Nonempty (ValuativeRel.RankLeOneStruct R) → ValuativeRel.IsRankLeOne R | true |
Function.Antiperiodic.funext' | Mathlib.Algebra.Ring.Periodic | ∀ {α : Type u_1} {β : Type u_2} {f : α → β} {c : α} [inst : Add α] [inst_1 : InvolutiveNeg β],
Function.Antiperiodic f c → (fun x => -f (x + c)) = f | true |
Array.getElem?_zip_eq_some | Init.Data.Array.Zip | ∀ {α : Type u_1} {β : Type u_2} {as : Array α} {bs : Array β} {z : α × β} {i : ℕ},
(as.zip bs)[i]? = some z ↔ as[i]? = some z.1 ∧ bs[i]? = some z.2 | true |
Std.TreeMap.Raw.maxKey!_insert | Std.Data.TreeMap.Raw.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.TreeMap.Raw α β cmp} [Std.TransCmp cmp]
[inst : Inhabited α],
t.WF → ∀ {k : α} {v : β}, (t.insert k v).maxKey! = t.maxKey?.elim k fun k' => if (cmp k' k).isLE = true then k else k' | true |
FirstOrder.Language.PartialEquiv.mk.injEq | Mathlib.ModelTheory.PartialEquiv | ∀ {L : FirstOrder.Language} {M : Type w} {N : Type w'} [inst : L.Structure M] [inst_1 : L.Structure N]
(dom : L.Substructure M) (cod : L.Substructure N) (toEquiv : L.Equiv ↥dom ↥cod) (dom_1 : L.Substructure M)
(cod_1 : L.Substructure N) (toEquiv_1 : L.Equiv ↥dom_1 ↥cod_1),
({ dom := dom, cod := cod, toEquiv := to... | true |
Std.TreeMap.keys.eq_1 | Std.Data.TreeSet.Iterator | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} (t : Std.TreeMap α β cmp), t.keys = t.inner.keys | true |
List.unattach_append | Init.Data.List.Attach | ∀ {α : Type u_1} {p : α → Prop} {l₁ l₂ : List { x // p x }}, (l₁ ++ l₂).unattach = l₁.unattach ++ l₂.unattach | true |
TopologicalSpace.Opens.coe_eq_univ._simp_1 | Mathlib.Topology.Sets.Opens | ∀ {α : Type u_2} [inst : TopologicalSpace α] {U : TopologicalSpace.Opens α}, (↑U = Set.univ) = (U = ⊤) | false |
AddMonoidAlgebra.sup_support_list_prod_le | Mathlib.Algebra.MonoidAlgebra.Degree | ∀ {R : Type u_1} {A : Type u_3} {B : Type u_5} [inst : SemilatticeSup B] [inst_1 : OrderBot B] [inst_2 : Semiring R]
[inst_3 : AddMonoid A] [inst_4 : AddMonoid B] [AddLeftMono B] [AddRightMono B] {degb : A → B},
degb 0 ≤ 0 →
(∀ (a b : A), degb (a + b) ≤ degb a + degb b) →
∀ (l : List (AddMonoidAlgebra R A... | true |
Primrec.fst | Mathlib.Computability.Primrec.Basic | ∀ {α : Type u_2} {β : Type u_3} [inst : Primcodable α] [inst_1 : Primcodable β], Primrec Prod.fst | true |
_private.Mathlib.Data.List.InsertIdx.0.List.take_eraseIdx_eq_take_of_le._proof_1_1 | Mathlib.Data.List.InsertIdx | ∀ {α : Type u_1} (l : List α) (i j : ℕ), i ≤ j → (List.take i (l.eraseIdx j)).length = (List.take i l).length | false |
Mathlib.Linter.linter.upstreamableDecl.private | Mathlib.Tactic.Linter.UpstreamableDecl | Lean.Option Bool | true |
QuadraticMap.proj_apply | Mathlib.LinearAlgebra.QuadraticForm.Basic | ∀ {R : Type u_3} {A : Type u_7} [inst : CommSemiring R] [inst_1 : NonUnitalNonAssocSemiring A] [inst_2 : Module R A]
[inst_3 : SMulCommClass R A A] [inst_4 : IsScalarTower R A A] {n : Type u_9} (i j : n) (x : n → A),
(QuadraticMap.proj i j) x = x i * x j | true |
UInt8.xor_right_inj | Init.Data.UInt.Bitwise | ∀ {a b : UInt8} (c : UInt8), c ^^^ a = c ^^^ b ↔ a = b | true |
_private.Lean.Meta.Tactic.Grind.AC.Seq.0.Lean.Grind.AC.instInhabitedStartsWithResult | Lean.Meta.Tactic.Grind.AC.Seq | Inhabited Lean.Grind.AC.StartsWithResult✝ | true |
AbsoluteValue.casesOn | Mathlib.Algebra.Order.AbsoluteValue.Basic | {R : Type u_5} →
{S : Type u_6} →
[inst : Semiring R] →
[inst_1 : Semiring S] →
[inst_2 : PartialOrder S] →
{motive : AbsoluteValue R S → Sort u} →
(t : AbsoluteValue R S) →
((toMulHom : R →ₙ* S) →
(nonneg' : ∀ (x : R), 0 ≤ toMulHom.toFun x) →
... | false |
Aesop.GoalId.mk | Aesop.Tree.Data | ℕ → Aesop.GoalId | true |
CovariantDerivative.finite_affine_combination._proof_3 | Mathlib.Geometry.Manifold.VectorBundle.CovariantDerivative.Basic | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {H : Type u_3} [inst_3 : TopologicalSpace H] {I : ModelWithCorners 𝕜 E H} {M : Type u_4}
[inst_4 : TopologicalSpace M] [inst_5 : ChartedSpace H M] {F : Type u_5} [inst_6 : NormedAddCommG... | false |
Lean.mkPropEq | Lean.Expr | Lean.Expr → Lean.Expr → Lean.Expr | true |
Lean.Elab.Term.elabWaitIfContainsMVar._regBuiltin.Lean.Elab.Term.elabWaitIfContainsMVar_1 | Lean.Elab.BuiltinTerm | IO Unit | false |
CochainComplex.HomComplex.δ_comp_zero_cochain | Mathlib.Algebra.Homology.HomotopyCategory.HomComplex | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Preadditive C]
{F G K : CochainComplex C ℤ} {n₁ : ℤ} (z₁ : CochainComplex.HomComplex.Cochain F G n₁)
(z₂ : CochainComplex.HomComplex.Cochain G K 0) (m₁ : ℤ) (h₁ : n₁ + 1 = m₁),
CochainComplex.HomComplex.δ n₁ m₁ (z₁.comp z₂ ⋯) =
... | true |
Metric.instMetricSpaceInductiveLimit._proof_3 | Mathlib.Topology.MetricSpace.Gluing | ∀ {X : ℕ → Type u_1} [inst : (n : ℕ) → MetricSpace (X n)] {f : (n : ℕ) → X n → X (n + 1)}
{I : ∀ (n : ℕ), Isometry (f n)} (x : Metric.InductiveLimit I), dist x x = 0 | false |
CompTriple.instIsIdId | Mathlib.Logic.Function.CompTypeclasses | ∀ {M : Type u_1}, CompTriple.IsId id | true |
SimpleGraph.Walk.support_concat | Mathlib.Combinatorics.SimpleGraph.Walk.Operations | ∀ {V : Type u} {G : SimpleGraph V} {u v w : V} (p : G.Walk u v) (h : G.Adj v w), (p.concat h).support = p.support ++ [w] | true |
_private.Init.Data.String.Lemmas.Pattern.Split.Pred.0.String.Slice.toList_split_prop._simp_1_1 | Init.Data.String.Lemmas.Pattern.Split.Pred | ∀ {s : String.Slice} {p : Char → Prop} [inst : DecidablePred p],
List.map String.ofList (List.splitOnP (fun b => decide (p b)) s.copy.toList) =
List.map (String.Slice.copy ∘ String.Slice.Subslice.toSlice) (s.splitToSubslice p).toList | false |
CategoryTheory.Limits.pullbackConeOfRightIso_π_app_none | Mathlib.CategoryTheory.Limits.Shapes.Pullback.Iso | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y Z : C} (f : X ⟶ Z) (g : Y ⟶ Z)
[inst_1 : CategoryTheory.IsIso g], (CategoryTheory.Limits.pullbackConeOfRightIso f g).π.app none = f | true |
List.Vector.snoc.eq_1 | Mathlib.Data.Vector.Snoc | ∀ {α : Type u_1} {n : ℕ} (xs : List.Vector α n) (x : α), xs.snoc x = xs ++ x ::ᵥ List.Vector.nil | true |
Finsupp.equivMapDomain.eq_1 | Mathlib.Data.Finsupp.Basic | ∀ {α : Type u_1} {β : Type u_2} {M : Type u_5} [inst : Zero M] (f : α ≃ β) (l : α →₀ M),
Finsupp.equivMapDomain f l =
{ support := Finset.map f.toEmbedding l.support, toFun := fun a => l (f.symm a), mem_support_toFun := ⋯ } | true |
SemiRingCat.limitSemiring._aux_4 | Mathlib.Algebra.Category.Ring.Limits | {J : Type u_3} →
[inst : CategoryTheory.Category.{u_1, u_3} J] →
(F : CategoryTheory.Functor J SemiRingCat) →
[inst_1 : Small.{u_2, max u_2 u_3} ↑(F.comp (CategoryTheory.forget SemiRingCat)).sections] →
Semiring ↑(F.comp (CategoryTheory.forget SemiRingCat)).sections →
(CategoryTheory.Limit... | false |
AlgHom.ext | Mathlib.Algebra.Algebra.Hom | ∀ {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] {φ₁ φ₂ : A →ₐ[R] B}, (∀ (x : A), φ₁ x = φ₂ x) → φ₁ = φ₂ | true |
Lean.RBNode.size._f | Lean.Data.RBMap | {α : Type u} → {β : α → Type v} → (x : Lean.RBNode α β) → Lean.RBNode.below x → ℕ | false |
Associated.instIsTrans | Mathlib.Algebra.GroupWithZero.Associated | ∀ {M : Type u_1} [inst : Monoid M], IsTrans M Associated | true |
IsFiniteLength.brecOn | Mathlib.RingTheory.FiniteLength | ∀ {R : Type u_1} [inst : Ring R]
{motive : (M : Type u_2) → [inst_1 : AddCommGroup M] → [inst_2 : Module R M] → IsFiniteLength R M → Prop}
{M : Type u_2} {inst_1 : AddCommGroup M} {inst_2 : Module R M} (t : IsFiniteLength R M),
(∀ (M : Type u_2) [inst_3 : AddCommGroup M] [inst_4 : Module R M] (t : IsFiniteLength ... | true |
Int.ModEq.of_mul_right | Mathlib.Data.Int.ModEq | ∀ {n a b : ℤ} (m : ℤ), a ≡ b [ZMOD n * m] → a ≡ b [ZMOD n] | true |
_private.Mathlib.AlgebraicGeometry.StructureSheaf.0.AlgebraicGeometry.StructureSheaf.toBasicOpenₗ_surjective._simp_1_1 | Mathlib.AlgebraicGeometry.StructureSheaf | ∀ {A : Type u_1} {B : Type u_2} [inst : SetLike A B] [inst_1 : LE A] [IsConcreteLE A B] {S T : A}, (S ≤ T) = (↑S ⊆ ↑T) | false |
Std.Notify.wait | Std.Sync.Notify | Std.Notify → IO (Std.Internal.IO.Async.AsyncTask Unit) | true |
_private.Mathlib.CategoryTheory.Bicategory.CatEnriched.0.CategoryTheory.CatEnriched.hComp_id._simp_1_1 | Mathlib.CategoryTheory.Bicategory.CatEnriched | ∀ {α : Sort u_1} (a b : α), (a = b) = (a ≍ b) | false |
Matrix.mulVec_surjective_iff_isUnit | Mathlib.LinearAlgebra.Matrix.NonsingularInverse | ∀ {m : Type u} [inst : DecidableEq m] {R : Type u_2} [inst_1 : CommRing R] [inst_2 : Fintype m] {A : Matrix m m R},
Function.Surjective A.mulVec ↔ IsUnit A | true |
_private.Mathlib.Data.Nat.Factorization.PrimePow.0.isPrimePow_iff_card_primeFactors_eq_one._simp_1_2 | Mathlib.Data.Nat.Factorization.PrimePow | ∀ (n : ℕ), n.primeFactors = n.factorization.support | false |
CategoryTheory.Bicategory.Pseudofunctor.ofLaxFunctorToLocallyGroupoid._proof_4 | Mathlib.CategoryTheory.Bicategory.LocallyGroupoid | ∀ {B : Type u_3} [inst : CategoryTheory.Bicategory B] {B' : Type u_5} [inst_1 : CategoryTheory.Bicategory B']
[CategoryTheory.Bicategory.IsLocallyGroupoid B] (F : CategoryTheory.LaxFunctor B' B) {a b c : B'} (f : a ⟶ b)
(g : b ⟶ c), CategoryTheory.IsIso (F.mapComp f g) | false |
StrictConvexSpace.of_norm_add_ne_two | Mathlib.Analysis.Convex.StrictConvexSpace | ∀ {E : Type u_2} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E],
(∀ ⦃x y : E⦄, ‖x‖ = 1 → ‖y‖ = 1 → x ≠ y → ‖x + y‖ ≠ 2) → StrictConvexSpace ℝ E | true |
Module.injective_of_localization_maximal | Mathlib.RingTheory.LocalProperties.Injective | ∀ {R : Type u} [inst : CommRing R] {M : Type v} [inst_1 : AddCommGroup M] [inst_2 : Module R M] [Small.{v, u} R]
[IsNoetherianRing R],
(∀ (I : Ideal R) (x : I.IsMaximal), Module.Injective (Localization.AtPrime I) (LocalizedModule I.primeCompl M)) →
Module.Injective R M | true |
CompHausLike.LocallyConstant.adjunction | Mathlib.Condensed.Discrete.LocallyConstant | (P : TopCat → Prop) →
[∀ (S : CompHausLike P) (p : ↑S.toTop → Prop), CompHausLike.HasProp P (Subtype p)] →
[inst : CompHausLike.HasProp P PUnit.{u + 1}] →
[inst_1 : CompHausLike.HasExplicitFiniteCoproducts P] →
[inst_2 : CompHausLike.HasExplicitPullbacks P] →
(hs :
∀ ⦃X Y : C... | true |
Int.subNatNat_sub | Init.Data.Int.Lemmas | ∀ {n m : ℕ}, n ≤ m → ∀ (k : ℕ), Int.subNatNat (m - n) k = Int.subNatNat m (k + n) | true |
Manifold.«_aux_Mathlib_Geometry_Manifold_Notation___elabRules_Manifold_termHasMFDerivAt%_______1» | Mathlib.Geometry.Manifold.Notation | Lean.Elab.Term.TermElab | false |
Ordinal.veblen_left_monotone | Mathlib.SetTheory.Ordinal.Veblen | ∀ (o : Ordinal.{u_1}), Monotone fun x => Ordinal.veblen x o | true |
Ideal.primeHeight_eq_ringKrullDim_iff | Mathlib.RingTheory.Ideal.Height | ∀ {R : Type u_1} [inst : CommRing R] [FiniteRingKrullDim R] [inst_2 : IsLocalRing R] {I : Ideal R} [inst_3 : I.IsPrime],
↑I.primeHeight = ringKrullDim R ↔ I = IsLocalRing.maximalIdeal R | true |
Aesop.EqualUpToIdsM.Context._sizeOf_1 | Aesop.Util.EqualUpToIds | Aesop.EqualUpToIdsM.Context → ℕ | false |
Lean.Meta.Grind.CnstrRHS.mk.inj | Lean.Meta.Tactic.Grind.Extension | ∀ {levelNames : Array Lean.Name} {numMVars : ℕ} {expr : Lean.Expr} {levelNames_1 : Array Lean.Name} {numMVars_1 : ℕ}
{expr_1 : Lean.Expr},
{ levelNames := levelNames, numMVars := numMVars, expr := expr } =
{ levelNames := levelNames_1, numMVars := numMVars_1, expr := expr_1 } →
levelNames = levelNames_1 ∧... | true |
CategoryTheory.Lax.LaxTrans.StrongCore.mk.inj | Mathlib.CategoryTheory.Bicategory.NaturalTransformation.Lax | ∀ {B : Type u₁} {inst : CategoryTheory.Bicategory B} {C : Type u₂} {inst_1 : CategoryTheory.Bicategory C}
{F G : CategoryTheory.LaxFunctor B C} {η : F ⟶ G}
{naturality :
{a b : B} →
(f : a ⟶ b) →
CategoryTheory.CategoryStruct.comp (η.app a) (G.map f) ≅ CategoryTheory.CategoryStruct.comp (F.map f) ... | true |
_private.Batteries.Data.List.Lemmas.0.List.getElem_idxsOf_lt._proof_1_11 | Batteries.Data.List.Lemmas | ∀ {α : Type u_1} {i : ℕ} {xs : List α} {x : α} {s : ℕ} [inst : BEq α] (h : i < (List.idxsOf x xs s).length),
(List.findIdxs (fun x_1 => x_1 == x) xs)[0] < xs.length | false |
AddConstMap.instMonoid | Mathlib.Algebra.AddConstMap.Basic | {G : Type u_1} → [inst : Add G] → {a : G} → Monoid (AddConstMap G G a a) | true |
_private.Mathlib.Order.Filter.Basic.0.Filter.frequently_principal._simp_1_2 | Mathlib.Order.Filter.Basic | ∀ {α : Sort u_1} {p : α → Prop}, (¬∀ (x : α), p x) = ∃ x, ¬p x | false |
_private.Lean.Elab.Tactic.Induction.0.Lean.Elab.Tactic.ElimApp.evalAlts.applyAltStx | Lean.Elab.Tactic.Induction | Lean.Meta.ElimInfo →
Lean.Syntax →
ℕ →
Array Lean.FVarId →
Array Lean.FVarId →
Array (Lean.Ident × Lean.FVarId) →
Array (Lean.Language.SnapshotBundle Lean.Elab.Tactic.TacticParsedSnapshot) →
Array Lean.Syntax → ℕ → Lean.Syntax → Lean.Elab.Tactic.ElimApp.Alt → Lean... | true |
Finset.compls_inter | Mathlib.Data.Finset.Sups | ∀ {α : Type u_2} [inst : BooleanAlgebra α] [inst_1 : DecidableEq α] (s t : Finset α),
(s ∩ t).compls = s.compls ∩ t.compls | true |
_private.Mathlib.Analysis.SpecialFunctions.ContinuousFunctionalCalculus.Rpow.IntegralRepresentation.0.CFC.exists_measure_nnrpow_eq_integral_cfcₙ_rpowIntegrand₀₁._proof_1_6 | Mathlib.Analysis.SpecialFunctions.ContinuousFunctionalCalculus.Rpow.IntegralRepresentation | ∀ (A : Type u_1) [inst : NonUnitalNormedRing A] [inst_1 : NormedSpace ℝ A] [inst_2 : PartialOrder A]
[NonnegSpectrumClass ℝ A] (a : A), 0 ≤ a → ∀ r ∈ quasispectrum ℝ a, r ∈ Set.Ici 0 | false |
Filter.iSup_liminf_le_liminf_iSup | Mathlib.Order.LiminfLimsup | ∀ {α : Type u_1} {β : Type u_2} {ι : Type u_4} [inst : CompleteLattice α] {f : Filter β} {u : ι → β → α},
⨆ i, Filter.liminf (u i) f ≤ Filter.liminf (fun b => ⨆ i, u i b) f | true |
AlgebraicGeometry.Scheme.Modules.Hom.mapPresheaf | Mathlib.AlgebraicGeometry.Modules.Sheaf | {X : AlgebraicGeometry.Scheme} → {M N : X.Modules} → (M ⟶ N) → (M.presheaf ⟶ N.presheaf) | true |
add_neg_lt_iff_lt_add | Mathlib.Algebra.Order.Group.Unbundled.Basic | ∀ {α : Type u} [inst : AddGroup α] [inst_1 : LT α] [AddRightStrictMono α] {a b c : α}, a + -b < c ↔ a < c + b | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.