name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
Valuation.RankLeOne.mk._flat_ctor | Mathlib.RingTheory.Valuation.RankOne | {R : Type u_1} →
{Γ₀ : Type u_2} →
[inst : Ring R] →
[inst_1 : LinearOrderedCommGroupWithZero Γ₀] →
{v : Valuation R Γ₀} → (hom' : MonoidWithZeroHom.ValueGroup₀ v →*₀ NNReal) → StrictMono ⇑hom' → v.RankLeOne | false |
ContinuousLinearMap.bilinear_hasTemperateGrowth | Mathlib.Analysis.Distribution.TemperateGrowth | ∀ {𝕜 : Type u_2} {D : Type u_4} {E : Type u_5} {F : Type u_6} {G : Type u_7} [inst : NormedAddCommGroup E]
[inst_1 : NormedSpace ℝ E] [inst_2 : NormedAddCommGroup F] [inst_3 : NormedSpace ℝ F]
[inst_4 : NontriviallyNormedField 𝕜] [NormedAlgebra ℝ 𝕜] [inst_6 : NormedAddCommGroup D] [inst_7 : NormedSpace ℝ D]
[i... | true |
_private.Mathlib.Data.List.NodupEquivFin.0.List.sublist_iff_exists_orderEmbedding_getElem?_eq._simp_1_1 | Mathlib.Data.List.NodupEquivFin | ∀ {a b : ℕ}, (a.succ ≤ b.succ) = (a ≤ b) | false |
Lean.Grind.ToInt.toInt.eq_1 | Init.GrindInstances.ToInt | ∀ (α : Type u) {range : Lean.Grind.IntInterval} [self : Lean.Grind.ToInt α range], Lean.Grind.ToInt.toInt = self.1 | true |
Lean.Meta.Try.Collector.OrdSet.set | Lean.Meta.Tactic.Try.Collect | {α : Type} → [inst : Hashable α] → [inst_1 : BEq α] → Lean.Meta.Try.Collector.OrdSet α → Std.HashSet α | true |
_private.Mathlib.Topology.Algebra.InfiniteSum.Defs.0.hasProd_fintype_support._simp_1_1 | Mathlib.Topology.Algebra.InfiniteSum.Defs | ∀ {α : Type u} {ι : Sort v} {x : α} {s : ι → Set α}, (x ∈ ⋂ i, s i) = ∀ (i : ι), x ∈ s i | false |
hasStrictDerivAt_abs | Mathlib.Analysis.Calculus.Deriv.Abs | ∀ {x : ℝ}, x ≠ 0 → HasStrictDerivAt (fun x => |x|) (↑(SignType.sign x)) x | true |
DistribSMul.toAddMonoidHom_eq_zsmulAddGroupHom | Mathlib.Algebra.Module.NatInt | ∀ (M : Type u_3) [inst : AddCommGroup M], DistribSMul.toAddMonoidHom M = zsmulAddGroupHom | true |
Representation.IntertwiningMap.rTensor_zero | Mathlib.RepresentationTheory.Intertwining | ∀ {A : Type u_1} {G : Type u_2} {V : Type u_3} {W : Type u_4} {U : Type u_5} [inst : CommSemiring A] [inst_1 : Monoid G]
[inst_2 : AddCommMonoid V] [inst_3 : AddCommMonoid W] [inst_4 : AddCommMonoid U] [inst_5 : Module A V]
[inst_6 : Module A W] [inst_7 : Module A U] {ρ : Representation A G V} {σ : Representation A... | true |
Fin.dfoldrM.loop._sunfold | Batteries.Data.Fin.Basic | {m : Type u_1 → Type u_2} →
[Monad m] →
(n : ℕ) →
(α : Fin (n + 1) → Type u_1) →
((i : Fin n) → α i.succ → m (α i.castSucc)) → (i : ℕ) → (h : i < n + 1) → α ⟨i, h⟩ → m (α 0) | false |
CategoryTheory.Functor.sheafInducedTopologyEquivOfIsCoverDense._proof_2 | Mathlib.CategoryTheory.Sites.DenseSubsite.InducedTopology | ∀ {C : Type u_3} [inst : CategoryTheory.Category.{u_6, u_3} C] {D : Type u_1}
[inst_1 : CategoryTheory.Category.{u_4, u_1} D] (G : CategoryTheory.Functor C D)
(K : CategoryTheory.GrothendieckTopology D) (A : Type u_5) [inst_2 : CategoryTheory.Category.{u_2, u_5} A]
[inst_3 : G.LocallyCoverDense K] [inst_4 : G.IsL... | false |
matPolyEquiv_symm_map_eval | Mathlib.RingTheory.MatrixPolynomialAlgebra | ∀ {R : Type u_1} [inst : CommSemiring R] {n : Type w} [inst_1 : DecidableEq n] [inst_2 : Fintype n]
(M : Polynomial (Matrix n n R)) (r : R),
(matPolyEquiv.symm M).map (Polynomial.eval r) = Polynomial.eval ((Matrix.scalar n) r) M | true |
StdSimplex.join._proof_2 | Mathlib.LinearAlgebra.ConvexSpace | ∀ {R : Type u_1} [inst : PartialOrder R] [inst_1 : Semiring R] {M : Type u_2} [IsStrictOrderedRing R]
(f : StdSimplex R (StdSimplex R M)), 0 ≤ f.sum fun d r => r • d.weights | false |
MonoidWithZero.toOppositeMulActionWithZero | Mathlib.Algebra.GroupWithZero.Action.Defs | (M₀ : Type u_2) → [inst : MonoidWithZero M₀] → MulActionWithZero M₀ᵐᵒᵖ M₀ | true |
Module.Basis.dualBasis_coord_toDualEquiv_apply | Mathlib.LinearAlgebra.Dual.Basis | ∀ {R : Type uR} {M : Type uM} {ι : Type uι} [inst : CommSemiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
[inst_3 : DecidableEq ι] (b : Module.Basis ι R M) [inst_4 : Finite ι] (i : ι) (f : M),
(b.dualBasis.coord i) (b.toDualEquiv f) = (b.coord i) f | true |
Lean.Parser.Module.module.formatter | Lean.Parser.Module | Lean.PrettyPrinter.Formatter | true |
Module.Basis.noConfusionType | Mathlib.LinearAlgebra.Basis.Defs | Sort u →
{ι : Type u_1} →
{R : Type u_3} →
{M : Type u_6} →
[inst : Semiring R] →
[inst_1 : AddCommMonoid M] →
[inst_2 : Module R M] →
Module.Basis ι R M →
{ι' : Type u_1} →
{R' : Type u_3} →
{M' : Type u_6} →
... | false |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.Equiv.minKey!_eq._simp_1_3 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {x : Ord α} {t : Std.DTreeMap.Internal.Impl α β} {k : α},
(k ∈ t) = (Std.DTreeMap.Internal.Impl.contains k t = true) | false |
Std.Internal.List.getValueCast_alterKey._proof_1 | Std.Data.Internal.List.Associative | ∀ {α : Type u_2} {β : α → Type u_1} [inst : BEq α] [inst_1 : LawfulBEq α] (k k' : α) (f : Option (β k) → Option (β k))
(l : List ((a : α) × β a)),
Std.Internal.List.DistinctKeys l →
Std.Internal.List.containsKey k' (Std.Internal.List.alterKey k f l) = true →
(k == k') = true → (f (Std.Internal.List.getVal... | false |
_private.Mathlib.LinearAlgebra.Matrix.Transvection.0.Matrix.Pivot.reindex_exists_list_transvec_mul_mul_list_transvec_eq_diagonal._simp_1_2 | Mathlib.LinearAlgebra.Matrix.Transvection | ∀ {m : Type u_2} {n : Type u_3} (R : Type u_11) (A : Type u_12) [inst : CommSemiring R] [inst_1 : Fintype n]
[inst_2 : Fintype m] [inst_3 : DecidableEq m] [inst_4 : DecidableEq n] [inst_5 : Semiring A] [inst_6 : Algebra R A]
(e : m ≃ n) (M N : Matrix m m A),
(Matrix.reindexAlgEquiv R A e) M * (Matrix.reindexAlgEq... | false |
RingQuot.instSemiring._proof_14 | Mathlib.Algebra.RingQuot | ∀ {R : Type u_1} [inst : Semiring R] (r : R → R → Prop) (a : RingQuot r), a * 1 = a | false |
Colex.instSMul'.eq_1 | Mathlib.Algebra.Order.Group.Synonym | ∀ {x : Type u_2} {x_1 : Type u_1} [h : SMul x x_1], Colex.instSMul' = h | true |
Batteries.RBNode.Balanced.nil | Batteries.Data.RBMap.Basic | ∀ {α : Type u_1}, Batteries.RBNode.nil.Balanced Batteries.RBColor.black 0 | true |
_private.Mathlib.NumberTheory.NumberField.House.0.NumberField.house.asiegel.eq_1 | Mathlib.NumberTheory.NumberField.House | ∀ (K : Type u_1) [inst : Field K] [inst_1 : NumberField K] {α : Type u_2} {β : Type u_3}
(a : Matrix α β (NumberField.RingOfIntegers K)) (k : α × (K →+* ℂ)) (l : β × (K →+* ℂ)),
NumberField.house.asiegel✝ K a k l = NumberField.house.a'✝ K a k.1 l.1 l.2 k.2 | true |
Con.congr.eq_1 | Mathlib.GroupTheory.Congruence.Basic | ∀ {M : Type u_1} [inst : Mul M] {c d : Con M} (h : c = d),
Con.congr h = { toEquiv := Quotient.congr (Equiv.refl M) ⋯, map_mul' := ⋯ } | true |
Nat.le_sqrt | Mathlib.Data.Nat.Sqrt | ∀ {m n : ℕ}, m ≤ n.sqrt ↔ m * m ≤ n | true |
_private.Init.Data.Int.LemmasAux.0.Int.sub_max_sub_left._proof_1_1 | Init.Data.Int.LemmasAux | ∀ (a b c : ℤ), ¬max (a - b) (a - c) = a - min b c → False | false |
Int.lt_of_lt_of_le | Init.Data.Int.Order | ∀ {a b c : ℤ}, a < b → b ≤ c → a < c | true |
Qq.SortLocalDecls.State.ctorIdx | Qq.SortLocalDecls | Qq.SortLocalDecls.State → ℕ | false |
«_aux_Mathlib_Algebra_Star_StarAlgHom___macroRules_term_→⋆ₙₐ__1» | Mathlib.Algebra.Star.StarAlgHom | Lean.Macro | false |
Std.Tactic.BVDecide.LRAT.Internal.Formula.ReadyForRatAdd | Std.Tactic.BVDecide.LRAT.Internal.Formula.Class | {α : outParam (Type u)} →
{β : outParam (Type v)} →
{inst : Std.Tactic.BVDecide.LRAT.Internal.Clause α β} →
{σ : Type w} →
{inst_1 : Std.Tactic.BVDecide.LRAT.Internal.Entails α σ} →
[self : Std.Tactic.BVDecide.LRAT.Internal.Formula α β σ] → σ → Prop | true |
AlgHom.card_le | Mathlib.FieldTheory.Fixed | ∀ {F : Type u_2} {K : Type u_3} [inst : Field F] [inst_1 : Field K] [inst_2 : Algebra F K]
[inst_3 : FiniteDimensional F K], Fintype.card (K →ₐ[F] K) ≤ Module.finrank F K | true |
CategoryTheory.finrank_hom_simple_simple_le_one | Mathlib.CategoryTheory.Preadditive.Schur | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Preadditive C] (𝕜 : Type u_2)
[inst_2 : Field 𝕜] [IsAlgClosed 𝕜] [inst_4 : CategoryTheory.Linear 𝕜 C] [CategoryTheory.Limits.HasKernels C] (X Y : C)
[FiniteDimensional 𝕜 (X ⟶ X)] [CategoryTheory.Simple X] [CategoryTheory.Si... | true |
Lean.Meta.Grind.instHasAnchorSplitCandidateWithAnchor | Lean.Meta.Tactic.Grind.Split | Lean.Meta.Grind.HasAnchor Lean.Meta.Grind.SplitCandidateWithAnchor | true |
DyckWord.firstReturn.eq_1 | Mathlib.Combinatorics.Enumerative.DyckWord | ∀ (p : DyckWord),
p.firstReturn =
List.findIdx
(fun i => decide (List.count DyckStep.U (List.take (i + 1) ↑p) = List.count DyckStep.D (List.take (i + 1) ↑p)))
(List.range (↑p).length) | true |
Asymptotics.isBigOTVS_fun_neg_right._simp_1 | Mathlib.Analysis.Asymptotics.TVS | ∀ {α : Type u_1} {𝕜 : Type u_3} {E : Type u_4} {F : Type u_5} [inst : NontriviallyNormedField 𝕜]
[inst_1 : AddCommGroup E] [inst_2 : TopologicalSpace E] [inst_3 : Module 𝕜 E] [inst_4 : AddCommGroup F]
[inst_5 : TopologicalSpace F] [inst_6 : Module 𝕜 F] {l : Filter α} {f : α → E} {g : α → F} [ContinuousNeg F],
... | false |
AddOpposite.forall | Mathlib.Algebra.Opposites | ∀ {α : Type u_1} {p : αᵃᵒᵖ → Prop}, (∀ (a : αᵃᵒᵖ), p a) ↔ ∀ (a : α), p (AddOpposite.op a) | true |
ProbabilityTheory.iIndepSets.piiUnionInter_of_notMem | Mathlib.Probability.Independence.Basic | ∀ {Ω : Type u_1} {ι : Type u_2} {_mΩ : MeasurableSpace Ω} {μ : MeasureTheory.Measure Ω} {π : ι → Set (Set Ω)} {a : ι}
{S : Finset ι}, ProbabilityTheory.iIndepSets π μ → a ∉ S → ProbabilityTheory.IndepSets (piiUnionInter π ↑S) (π a) μ | true |
_private.Mathlib.NumberTheory.LegendreSymbol.AddCharacter.0.AddChar.val_mem_rootsOfUnity._simp_1_1 | Mathlib.NumberTheory.LegendreSymbol.AddCharacter | ∀ {M : Type u_1} [inst : CommMonoid M] (k : ℕ) (ζ : Mˣ), (ζ ∈ rootsOfUnity k M) = (↑ζ ^ k = 1) | false |
Lean.Language.Lean.CommandParsedSnapshot.brecOn_3.eq | Lean.Language.Lean.Types | ∀ {motive_1 : Lean.Language.Lean.CommandParsedSnapshot → Sort u}
{motive_2 : Option (Lean.Language.SnapshotTask Lean.Language.Lean.CommandParsedSnapshot) → Sort u}
{motive_3 : Lean.Language.SnapshotTask Lean.Language.Lean.CommandParsedSnapshot → Sort u}
{motive_4 : Task Lean.Language.Lean.CommandParsedSnapshot → ... | true |
Real.logb_zero | Mathlib.Analysis.SpecialFunctions.Log.Base | ∀ {b : ℝ}, Real.logb b 0 = 0 | true |
Lean.Compiler.LCNF.NormFVarResult.erased.elim | Lean.Compiler.LCNF.CompilerM | {motive : Lean.Compiler.LCNF.NormFVarResult → Sort u} →
(t : Lean.Compiler.LCNF.NormFVarResult) → t.ctorIdx = 1 → motive Lean.Compiler.LCNF.NormFVarResult.erased → motive t | false |
String.Slice.Pattern.ToForwardSearcher.DefaultForwardSearcher.noConfusion | Init.Data.String.Pattern.Basic | {P : Sort u} →
{ρ : Type} →
{pat : ρ} →
{s : String.Slice} →
{t : String.Slice.Pattern.ToForwardSearcher.DefaultForwardSearcher pat s} →
{ρ' : Type} →
{pat' : ρ'} →
{s' : String.Slice} →
{t' : String.Slice.Pattern.ToForwardSearcher.DefaultForwardSe... | false |
_private.Lean.Server.FileWorker.RequestHandling.0.Lean.Server.FileWorker.NamespaceEntry.finish.match_1 | Lean.Server.FileWorker.RequestHandling | (motive : Option Lean.Syntax → Sort u_1) →
(endStx : Option Lean.Syntax) → ((endStx : Lean.Syntax) → motive (some endStx)) → (Unit → motive none) → motive endStx | false |
ContMDiffAt.eq_1 | Mathlib.Geometry.Manifold.ContMDiff.Defs | ∀ {𝕜 : 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] {E' : Type u_5} [inst_6 : NormedAddComm... | true |
MeasureTheory.measureReal_eq_measureReal_smaller_of_between_null_diff | Mathlib.MeasureTheory.Measure.Real | ∀ {α : Type u_1} {x : MeasurableSpace α} {μ : MeasureTheory.Measure α} {s₁ s₂ s₃ : Set α},
s₁ ⊆ s₂ →
s₂ ⊆ s₃ →
μ.real (s₃ \ s₁) = 0 →
autoParam (μ (s₃ \ s₁) ≠ ⊤) MeasureTheory.measureReal_eq_measureReal_smaller_of_between_null_diff._auto_1 →
μ.real s₁ = μ.real s₂ | true |
CategoryTheory.Functor.Accessible.Limits.isColimitMapCocone.injective | Mathlib.CategoryTheory.Presentable.Limits | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {K : Type u'} [inst_1 : CategoryTheory.Category.{v', u'} K]
{F : CategoryTheory.Functor K (CategoryTheory.Functor C (Type w'))} (c : CategoryTheory.Limits.Cone F)
(hc : (Y : C) → CategoryTheory.Limits.IsLimit (((CategoryTheory.evaluation C (Type w')).obj Y).m... | true |
ArchimedeanClass.FiniteResidueField.ofArchimedean._proof_3 | Mathlib.Algebra.Order.Ring.StandardPart | ∀ {K : Type u_1} [inst : LinearOrder K] [inst_1 : Field K] [inst_2 : IsOrderedRing K] {R : Type u_2}
[inst_3 : LinearOrder R] [inst_4 : CommRing R] [inst_5 : IsStrictOrderedRing R] [inst_6 : Archimedean R]
(f : R →+*o K) (x y : R),
ArchimedeanClass.FiniteResidueField.mk (ArchimedeanClass.FiniteElement.mk (f (x * ... | false |
CategoryTheory.SymmetricCategory.toBraidedCategory | Mathlib.CategoryTheory.Monoidal.Braided.Basic | {C : Type u} →
{inst : CategoryTheory.Category.{v, u} C} →
{inst_1 : CategoryTheory.MonoidalCategory C} →
[self : CategoryTheory.SymmetricCategory C] → CategoryTheory.BraidedCategory C | true |
WittVector.fromPadicInt | Mathlib.RingTheory.WittVector.Compare | (p : ℕ) → [hp : Fact (Nat.Prime p)] → ℤ_[p] →+* WittVector p (ZMod p) | true |
_private.Lean.Compiler.LCNF.InferType.0.Lean.Compiler.LCNF.Arg.inferType.match_1 | Lean.Compiler.LCNF.InferType | (motive : (pu : Lean.Compiler.LCNF.Purity) → Lean.Compiler.LCNF.Arg pu → Sort u_1) →
(pu : Lean.Compiler.LCNF.Purity) →
(arg : Lean.Compiler.LCNF.Arg pu) →
((arg : Lean.Compiler.LCNF.Arg Lean.Compiler.LCNF.Purity.pure) → motive Lean.Compiler.LCNF.Purity.pure arg) →
((arg : Lean.Compiler.LCNF.Arg Lea... | false |
TypeVec.toSubtype'._sunfold | Mathlib.Data.TypeVec | {n : ℕ} →
{α : TypeVec.{u} n} →
(p : (α.prod α).Arrow (TypeVec.repeat n Prop)) →
TypeVec.Arrow (fun i => { x // TypeVec.ofRepeat (p i (TypeVec.prod.mk i x.1 x.2)) }) (TypeVec.Subtype_ p) | false |
_private.Mathlib.Algebra.Lie.Weights.IsSimple.0.LieAlgebra.IsKilling.chi_not_in_q_aux | Mathlib.Algebra.Lie.Weights.IsSimple | ∀ {K : Type u_1} {L : Type u_2} [inst : Field K] [inst_1 : CharZero K] [inst_2 : LieRing L] [inst_3 : LieAlgebra K L]
[inst_4 : FiniteDimensional K L] {H : LieSubalgebra K L} [inst_5 : H.IsCartanSubalgebra]
[inst_6 : LieAlgebra.IsKilling K L] [inst_7 : LieModule.IsTriangularizable K (↥H) L]
(q : Submodule K (Modu... | true |
Sum.LiftRel.isRight_right | Mathlib.Data.Sum.Basic | ∀ {α : Type u} {β : Type v} {γ : Type u_1} {δ : Type u_2} {r : α → γ → Prop} {s : β → δ → Prop} {y : γ ⊕ δ} {b : β},
Sum.LiftRel r s (Sum.inr b) y → y.isRight = true | true |
LinearMap.comap_prod_prod | Mathlib.LinearAlgebra.Prod | ∀ {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 : M →ₗ[R] M₂) (g : M →ₗ[R] M₃) (p : Submodule R M₂) (q : Submodule R M₃),
Submodule.... | true |
Metric.thickening_thickening_subset | Mathlib.Topology.MetricSpace.Thickening | ∀ {α : Type u} [inst : PseudoEMetricSpace α] (ε δ : ℝ) (s : Set α),
Metric.thickening ε (Metric.thickening δ s) ⊆ Metric.thickening (ε + δ) s | true |
ENNReal.inv_rpow | Mathlib.Analysis.SpecialFunctions.Pow.NNReal | ∀ (x : ENNReal) (y : ℝ), x⁻¹ ^ y = (x ^ y)⁻¹ | true |
_private.Lean.Elab.Tactic.Do.ProofMode.Exact.0.Lean.Elab.Tactic.Do.ProofMode.MGoal.exactPure._sparseCasesOn_1 | Lean.Elab.Tactic.Do.ProofMode.Exact | {α : Type u} →
{motive : Option α → Sort u_1} →
(t : Option α) → ((val : α) → motive (some val)) → (Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t | false |
MvPowerSeries.instNontrivial | Mathlib.RingTheory.MvPowerSeries.Basic | ∀ {σ : Type u_1} {R : Type u_2} [Nontrivial R], Nontrivial (MvPowerSeries σ R) | true |
CategoryTheory.Limits.CategoricalPullback.CatCommSqOver.instCategory | Mathlib.CategoryTheory.Limits.Shapes.Pullback.Categorical.Basic | {A : Type u₁} →
{B : Type u₂} →
{C : Type u₃} →
[inst : CategoryTheory.Category.{v₁, u₁} A] →
[inst_1 : CategoryTheory.Category.{v₂, u₂} B] →
[inst_2 : CategoryTheory.Category.{v₃, u₃} C] →
{F : CategoryTheory.Functor A B} →
{G : CategoryTheory.Functor C B} →
... | true |
LieSubalgebra.coe_incl' | Mathlib.Algebra.Lie.Subalgebra | ∀ {R : Type u} {L : Type v} [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : LieAlgebra R L] (L' : LieSubalgebra R L),
⇑L'.incl' = Subtype.val | true |
Lean.Grind.OrderConfig.funCC._inherited_default | Init.Grind.Config | Bool | false |
Option.instTransOrd | Init.Data.Order.Ord | ∀ {α : Type u_1} [inst : Ord α] [Std.TransOrd α], Std.TransOrd (Option α) | true |
HomologicalComplex.HomologySequence.snakeInput._proof_4 | Mathlib.Algebra.Homology.HomologySequence | ∀ {C : Type u_2} {ι : Type u_3} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Abelian C]
{c : ComplexShape ι} {S : CategoryTheory.ShortComplex (HomologicalComplex C c)} (i j : ι),
CategoryTheory.CategoryStruct.comp (S.mapNatTrans (HomologicalComplex.natTransOpCyclesToCycles C c i j))
... | false |
Ring.instIsScalarTowerFractionRingSubtypeAlgebraicClosureMemIntermediateFieldNormalClosure | Mathlib.RingTheory.NormalClosure | ∀ (R : Type u_1) (S : Type u_2) [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : IsDomain R] [inst_3 : IsDomain S]
[inst_4 : Algebra R S] [inst_5 : Module.IsTorsionFree R S],
IsScalarTower S (FractionRing S)
↥(IntermediateField.normalClosure (FractionRing R) (FractionRing S) (AlgebraicClosure (FractionRing S... | true |
Fin.instSub | Init.Data.Fin.Basic | {n : ℕ} → Sub (Fin n) | true |
HolderOnWith.ediam_image_le_of_subset_of_le | Mathlib.Topology.MetricSpace.Holder | ∀ {X : Type u_1} {Y : Type u_2} [inst : PseudoEMetricSpace X] [inst_1 : PseudoEMetricSpace Y] {C r : NNReal} {f : X → Y}
{s t : Set X},
HolderOnWith C r f s → t ⊆ s → ∀ {d : ENNReal}, Metric.ediam t ≤ d → Metric.ediam (f '' t) ≤ ↑C * d ^ ↑r | true |
Int64.reduceAdd._regBuiltin.Int64.reduceAdd.declare_1._@.Lean.Meta.Tactic.Simp.BuiltinSimprocs.SInt.4041591762._hygCtx._hyg.56 | Lean.Meta.Tactic.Simp.BuiltinSimprocs.SInt | IO Unit | false |
CategoryTheory.Pseudofunctor.DescentData'.descentDataEquivalence._proof_11 | Mathlib.CategoryTheory.Sites.Descent.DescentDataPrime | ∀ {C : Type u_5} [inst : CategoryTheory.Category.{u_3, u_5} C]
(F : CategoryTheory.Pseudofunctor (CategoryTheory.LocallyDiscrete Cᵒᵖ) CategoryTheory.Cat) {ι : Type u_1} {S : C}
{X : ι → C} {f : (i : ι) → X i ⟶ S} (sq : (i j : ι) → CategoryTheory.Limits.ChosenPullback (f i) (f j))
(sq₃ : (i₁ i₂ i₃ : ι) → CategoryT... | false |
Matrix.separatingRight_toLinearMap₂'_iff_separatingRight_toLinearMap₂ | Mathlib.LinearAlgebra.Matrix.SesquilinearForm | ∀ {R : Type u_1} {M₁ : Type u_6} {M₂ : Type u_7} {n : Type u_11} {m : Type u_12} [inst : CommRing R]
[inst_1 : DecidableEq m] [inst_2 : Fintype m] [inst_3 : DecidableEq n] [inst_4 : Fintype n] {M : Matrix m n R}
[inst_5 : AddCommMonoid M₁] [inst_6 : Module R M₁] [inst_7 : AddCommMonoid M₂] [inst_8 : Module R M₂]
... | true |
_private.Mathlib.Analysis.Complex.CanonicalDecomposition.0.Complex.meromorphicNFOn_canonicalFactor._proof_1_1 | Mathlib.Analysis.Complex.CanonicalDecomposition | -1 < 0 | false |
ZFSet.image.match_1 | Mathlib.SetTheory.ZFC.Basic | ∀ (f : ZFSet.{u_1} → ZFSet.{u_1}) [inst : ZFSet.Definable₁ f] (x x_1 : PSet.{u_1})
(motive : (∃ z ∈ x, x_1.Equiv (ZFSet.Definable₁.out f z)) → Prop)
(x_2 : ∃ z ∈ x, x_1.Equiv (ZFSet.Definable₁.out f z)),
(∀ (w : PSet.{u_1}) (h1 : w ∈ x) (h2 : x_1.Equiv (ZFSet.Definable₁.out f w)), motive ⋯) → motive x_2 | false |
_private.Lean.Linter.ConstructorAsVariable.0.Lean.Linter.constructorNameAsVariable.match_16 | Lean.Linter.ConstructorAsVariable | (motive : Lean.Name → Sort u_1) →
(x : Lean.Name) →
((n : Lean.Name) →
(s : String) → (h : n = Lean.Name.anonymous.str s) → motive (namedPattern n (Lean.Name.anonymous.str s) h)) →
((x : Lean.Name) → motive x) → motive x | false |
_private.Mathlib.RingTheory.WittVector.InitTail.0.WittVector.init_sub._proof_1_6 | Mathlib.RingTheory.WittVector.InitTail | ∀ (n i : ℕ), i < n → ∀ k < i + 1, k < n | false |
_aux_Mathlib_Combinatorics_SimpleGraph_Basic___macroRules_aesop_graph_1 | Mathlib.Combinatorics.SimpleGraph.Basic | Lean.Macro | false |
_private.Lean.Elab.Inductive.0.Lean.Elab.Command.inductiveSyntaxToView | Lean.Elab.Inductive | Lean.Elab.Modifiers → Lean.Syntax → Bool → Lean.Elab.TermElabM Lean.Elab.Command.InductiveView | true |
PadicInt.unitCoeff_spec | Mathlib.NumberTheory.Padics.PadicIntegers | ∀ {p : ℕ} [hp : Fact (Nat.Prime p)] {x : ℤ_[p]} (hx : x ≠ 0), x = ↑(PadicInt.unitCoeff hx) * ↑p ^ x.valuation | true |
IsManifold.subset_maximalAtlas | Mathlib.Geometry.Manifold.IsManifold.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} {n : WithTop ℕ∞}
{M : Type u_4} [inst_4 : TopologicalSpace M] [inst_5 : ChartedSpace H M] [IsManifold I n M],
... | true |
ULift.instLinearOrder | Mathlib.Order.Lattice | {α : Type u} → [LinearOrder α] → LinearOrder (ULift.{v, u} α) | true |
CategoryTheory.Grp.forget₂Mon_map_hom | Mathlib.CategoryTheory.Monoidal.Grp_ | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.CartesianMonoidalCategory C]
{A B : CategoryTheory.Grp C} (f : A ⟶ B), ((CategoryTheory.Grp.forget₂Mon C).map f).hom = f.hom.hom | true |
pos_of_right_mul_lt_le | Mathlib.Algebra.Order.Ring.Unbundled.Basic | ∀ {R : Type u} [inst : Semiring R] [inst_1 : LinearOrder R] {a b c : R} [ExistsAddOfLE R] [PosMulMono R]
[AddRightMono R] [AddRightReflectLE R], a * b < a * c → b ≤ c → 0 < a | true |
_private.Mathlib.NumberTheory.BernoulliPolynomials.0.Polynomial.sum_bernoulli._simp_1_4 | Mathlib.NumberTheory.BernoulliPolynomials | ∀ {M : Type u_4} [inst : AddMonoid M] [IsLeftCancelAdd M] {a b : M}, (a + b = a) = (b = 0) | false |
_private.Mathlib.NumberTheory.Transcendental.Liouville.Residual.0.setOf_liouville_eq_iInter_iUnion._simp_1_1 | Mathlib.NumberTheory.Transcendental.Liouville.Residual | ∀ {α : Type u} {ι : Sort v} {x : α} {s : ι → Set α}, (x ∈ ⋂ i, s i) = ∀ (i : ι), x ∈ s i | false |
List.getElem_of_append | Init.Data.List.Lemmas | ∀ {α : Type u_1} {l₁ : List α} {a : α} {l₂ : List α} {i : ℕ} {l : List α} (eq : l = l₁ ++ a :: l₂) (h : l₁.length = i),
l[i] = a | true |
ZMod.χ₈'._proof_1 | Mathlib.NumberTheory.LegendreSymbol.ZModChar | (match 1 with
| 0 => 0
| 2 => 0
| 4 => 0
| 6 => 0
| 1 => 1
| 3 => 1
| 5 => -1
| 7 => -1) =
match 1 with
| 0 => 0
| 2 => 0
| 4 => 0
| 6 => 0
| 1 => 1
| 3 => 1
| 5 => -1
| 7 => -1 | false |
AlgebraicGeometry.Scheme.affineOpenCoverOfSpanRangeEqTop | Mathlib.AlgebraicGeometry.Cover.Open | {R : CommRingCat} →
{ι : Type u_1} → (s : ι → ↑R) → Ideal.span (Set.range s) = ⊤ → (AlgebraicGeometry.Spec R).AffineOpenCover | true |
Lean.Meta.Grind.Arith.CommRing.SemiringM.Context.rec | Lean.Meta.Tactic.Grind.Arith.CommRing.SemiringM | {motive : Lean.Meta.Grind.Arith.CommRing.SemiringM.Context → Sort u} →
((semiringId : ℕ) → motive { semiringId := semiringId }) →
(t : Lean.Meta.Grind.Arith.CommRing.SemiringM.Context) → motive t | false |
Batteries.PairingHeapImp.Heap.toArray | Batteries.Data.PairingHeap | {α : Type u_1} → (α → α → Bool) → Batteries.PairingHeapImp.Heap α → Array α | true |
CategoryTheory.nerve.edgeMk_id | Mathlib.AlgebraicTopology.SimplicialSet.Nerve | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (x : C),
CategoryTheory.nerve.edgeMk (CategoryTheory.CategoryStruct.id x) = SSet.Edge.id (CategoryTheory.nerveEquiv.symm x) | true |
Submodule.orthogonalProjection._proof_4 | Mathlib.Analysis.InnerProductSpace.Projection.Basic | ∀ {𝕜 : Type u_2} {E : Type u_1} [inst : RCLike 𝕜] [inst_1 : NormedAddCommGroup E] [inst_2 : InnerProductSpace 𝕜 E]
(K : Submodule 𝕜 E) [inst_3 : K.HasOrthogonalProjection] (x : E),
‖{ toFun := fun v => ⟨K.orthogonalProjectionFn v, ⋯⟩, map_add' := ⋯, map_smul' := ⋯ } x‖ ≤ 1 * ‖x‖ | false |
Lean.Lsp.WorkspaceEditClientCapabilities.noConfusion | Lean.Data.Lsp.Capabilities | {P : Sort u} →
{t t' : Lean.Lsp.WorkspaceEditClientCapabilities} →
t = t' → Lean.Lsp.WorkspaceEditClientCapabilities.noConfusionType P t t' | false |
_private.Mathlib.Algebra.Homology.ShortComplex.Homology.0.CategoryTheory.ShortComplex.isIso_homologyMap_of_isIso_cyclesMap_of_epi.match_1_2 | Mathlib.Algebra.Homology.ShortComplex.Homology | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{S₁ S₂ : CategoryTheory.ShortComplex C} {φ : S₁ ⟶ S₂} [inst_2 : S₁.HasHomology] [inst_3 : S₂.HasHomology]
(h₁ : CategoryTheory.IsIso (CategoryTheory.ShortComplex.cyclesMap φ))
(motive :
{ l //
... | false |
CategoryTheory.MonoidalCategory.prodMonoidal._proof_21 | Mathlib.CategoryTheory.Monoidal.Category | ∀ (C₁ : Type u_1) [inst : CategoryTheory.Category.{u_3, u_1} C₁] [inst_1 : CategoryTheory.MonoidalCategory C₁]
(C₂ : Type u_2) [inst_2 : CategoryTheory.Category.{u_4, u_2} C₂] [inst_3 : CategoryTheory.MonoidalCategory C₂]
(X Y : C₁ × C₂),
CategoryTheory.CategoryStruct.comp
((CategoryTheory.MonoidalCategoryS... | false |
_private.Batteries.Data.Array.Lemmas.0.Array.extract_append_of_size_left_le_start._proof_1_2 | Batteries.Data.Array.Lemmas | ∀ {α : Type u_1} {i j : ℕ} {a b : Array α} (i_1 : ℕ),
i_1 + 1 ≤ (b.extract (i - a.size) (j - a.size)).size → i_1 < (b.extract (i - a.size) (j - a.size)).size | false |
CompletePartialOrder.noConfusionType | Mathlib.Order.CompletePartialOrder | Sort u → {α : Type u_4} → CompletePartialOrder α → {α' : Type u_4} → CompletePartialOrder α' → Sort u | false |
Option.pfilter_eq_some_iff | Init.Data.Option.Lemmas | ∀ {α : Type u_1} {o : Option α} {p : (a : α) → o = some a → Bool} {a : α},
o.pfilter p = some a ↔ ∃ (ha : o = some a), p a ha = true | true |
Affine.Simplex.reflectionCircumcenterWeightsWithCircumcenter.eq_1 | Mathlib.Geometry.Euclidean.Circumcenter | ∀ {n : ℕ} (i₁ i₂ a : Fin (n + 1)),
Affine.Simplex.reflectionCircumcenterWeightsWithCircumcenter i₁ i₂
(Affine.Simplex.PointsWithCircumcenterIndex.pointIndex a) =
if a = i₁ ∨ a = i₂ then 1 else 0 | true |
_private.Init.Data.Range.Basic.0.Std.Legacy.Range.forIn'.loop._unary._proof_7 | Init.Data.Range.Basic | ∀ (range : Std.Legacy.Range) (i : ℕ),
autoParam (range.start ≤ i) Std.Legacy.Range.forIn'._auto_1✝ → 0 < range.step → range.start ≤ i + range.step | false |
Module.FaithfullyFlat.trans | Mathlib.RingTheory.Flat.FaithfullyFlat.Basic | ∀ (R : Type u_1) [inst : CommRing R] (S : Type u_2) [inst_1 : CommRing S] [inst_2 : Algebra R S] (M : Type u_3)
[inst_3 : AddCommGroup M] [inst_4 : Module R M] [inst_5 : Module S M] [IsScalarTower R S M]
[Module.FaithfullyFlat R S] [Module.FaithfullyFlat S M], Module.FaithfullyFlat R M | true |
_private.Mathlib.ModelTheory.Semantics.0.FirstOrder.Language.BoundedFormula.restrictFreeVar.match_1.eq_5 | Mathlib.ModelTheory.Semantics | ∀ {L : FirstOrder.Language} {α : Type u_3} {β : Type u_5} [inst : DecidableEq α]
(motive : (x : ℕ) → (x_1 : L.BoundedFormula α x) → (↥x_1.freeVarFinset → β) → Sort u_4) (_n : ℕ)
(φ : L.BoundedFormula α (_n + 1)) (f : ↥φ.all.freeVarFinset → β)
(h_1 :
(_n : ℕ) →
(_f : ↥FirstOrder.Language.BoundedFormula.f... | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.