name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
List.mapIdx_append_one | Mathlib.Data.List.Indexes | ∀ {α : Type u} {β : Type v} {f : ℕ → α → β} {l : List α} {e : α},
List.mapIdx f (l ++ [e]) = List.mapIdx f l ++ [f l.length e] | true |
CochainComplex.mappingCone.map._proof_1 | Mathlib.Algebra.Homology.HomotopyCategory.Pretriangulated | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Preadditive C]
[inst_2 : CategoryTheory.Limits.HasBinaryBiproducts C] {K₁ L₁ K₂ L₂ : CochainComplex C ℤ} (φ₁ : K₁ ⟶ L₁)
(φ₂ : K₂ ⟶ L₂) (a : K₁ ⟶ K₂) (b : L₁ ⟶ L₂),
CategoryTheory.CategoryStruct.comp φ₁ b = CategoryTheory.Categ... | false |
ImplicitFunctionData.toOpenPartialHomeomorph | Mathlib.Analysis.Calculus.Implicit | {𝕜 : Type u_1} →
[inst : NontriviallyNormedField 𝕜] →
{E : Type u_2} →
[inst_1 : NormedAddCommGroup E] →
[inst_2 : NormedSpace 𝕜 E] →
[inst_3 : CompleteSpace E] →
{F : Type u_3} →
[inst_4 : NormedAddCommGroup F] →
[inst_5 : NormedSpace 𝕜 F] →
... | true |
Fin.map_addNatEmb_Ici | Mathlib.Order.Interval.Finset.Fin | ∀ {n : ℕ} (m : ℕ) (i : Fin n), Finset.map (Fin.addNatEmb m) (Finset.Ici i) = Finset.Ici (i.addNat m) | true |
_private.Lean.Elab.Tactic.Induction.0.Lean.Elab.Tactic.ElimTargetInfo.arg? | Lean.Elab.Tactic.Induction | Lean.Elab.Tactic.ElimTargetInfo✝ → Option Lean.Meta.GeneralizeArg | true |
CategoryTheory.Functor.OplaxLeftLinear.δₗ | Mathlib.CategoryTheory.Monoidal.Action.LinearFunctor | {D : Type u_1} →
{D' : Type u_2} →
{inst : CategoryTheory.Category.{v_1, u_1} D} →
{inst_1 : CategoryTheory.Category.{v_2, u_2} D'} →
(F : CategoryTheory.Functor D D') →
{C : Type u_3} →
{inst_2 : CategoryTheory.Category.{v_3, u_3} C} →
{inst_3 : CategoryTheory.Mo... | true |
OrderIso.withTopCongr._proof_1 | Mathlib.Order.Hom.WithTopBot | ∀ {α : Type u_1} {β : Type u_2} [inst : PartialOrder α] [inst_1 : PartialOrder β] (e : α ≃o β),
Function.LeftInverse e.withTopCongr.invFun e.withTopCongr.toFun | false |
Unitization.instAddGroup._proof_2 | Mathlib.Algebra.Algebra.Unitization | ∀ {R : Type u_1} {A : Type u_2} [inst : AddGroup R] [inst_1 : AddGroup A],
autoParam (∀ (a : Unitization R A), 0 • a = 0) SubNegMonoid.zsmul_zero'._autoParam | false |
FirstOrder.Language.Theory.ModelType._sizeOf_1 | Mathlib.ModelTheory.Bundled | {L : FirstOrder.Language} → {T : L.Theory} → [(a : L.Sentence) → SizeOf (T a)] → T.ModelType → ℕ | false |
_private.Mathlib.AlgebraicGeometry.EllipticCurve.Jacobian.Formula.0._aux_Mathlib_AlgebraicGeometry_EllipticCurve_Jacobian_Formula___delab_app__private_Mathlib_AlgebraicGeometry_EllipticCurve_Jacobian_Formula_0_termX_1 | Mathlib.AlgebraicGeometry.EllipticCurve.Jacobian.Formula | Lean.PrettyPrinter.Delaborator.Delab | false |
Int.reduceBin | Lean.Meta.Tactic.Simp.BuiltinSimprocs.Int | Lean.Name → ℕ → (ℤ → ℤ → ℤ) → Lean.Expr → Lean.Meta.SimpM Lean.Meta.Simp.DStep | true |
_private.Mathlib.Combinatorics.Additive.Dissociation.0.not_addDissociated_iff_exists_disjoint.match_1_1 | Mathlib.Combinatorics.Additive.Dissociation | ∀ {α : Type u_1} [inst : AddCommGroup α] {s : Set α}
(motive : (∃ t u, ↑t ⊆ s ∧ ↑u ⊆ s ∧ Disjoint t u ∧ t ≠ u ∧ ∑ a ∈ t, a = ∑ a ∈ u, a) → Prop)
(x : ∃ t u, ↑t ⊆ s ∧ ↑u ⊆ s ∧ Disjoint t u ∧ t ≠ u ∧ ∑ a ∈ t, a = ∑ a ∈ u, a),
(∀ (t u : Finset α) (ht : ↑t ⊆ s) (hu : ↑u ⊆ s) (left : Disjoint t u) (htune : t ≠ u)
... | false |
instFieldPadic._proof_15 | Mathlib.NumberTheory.Padics.PadicNumbers | ∀ (p : ℕ) [inst : Fact (Nat.Prime p)], 0⁻¹ = 0 | false |
CategoryTheory.Pseudofunctor.StrongTrans.Modification.whiskerRight_naturality_assoc | Mathlib.CategoryTheory.Bicategory.Modification.Pseudo | ∀ {B : Type u₁} [inst : CategoryTheory.Bicategory B] {C : Type u₂} [inst_1 : CategoryTheory.Bicategory C]
{F G : CategoryTheory.Pseudofunctor B C} {η θ : F ⟶ G} (Γ : CategoryTheory.Pseudofunctor.StrongTrans.Modification η θ)
{a b : B} {a' : C} (f : a ⟶ b) (g : G.obj b ⟶ a') {Z : F.obj a ⟶ a'}
(h : CategoryTheory.... | true |
AlgebraicGeometry.isomorphisms_eq_isOpenImmersion_inf_surjective | Mathlib.AlgebraicGeometry.Morphisms.IsIso | CategoryTheory.MorphismProperty.isomorphisms AlgebraicGeometry.Scheme =
AlgebraicGeometry.IsOpenImmersion ⊓ @AlgebraicGeometry.Surjective | true |
IccRightChart_extend_top | Mathlib.Geometry.Manifold.Instances.Real | ∀ {x y : ℝ} [hxy : Fact (x < y)], ↑((IccRightChart x y).extend (modelWithCornersEuclideanHalfSpace 1)) ⊤ = 0 | true |
Stirling.stirlingSeq.eq_1 | Mathlib.Analysis.SpecialFunctions.Stirling | ∀ (n : ℕ), Stirling.stirlingSeq n = ↑n.factorial / (√(2 * ↑n) * (↑n / Real.exp 1) ^ n) | true |
_private.Lean.Elab.PreDefinition.PartialFixpoint.Induction.0.Lean.Elab.PartialFixpoint.isOptionFixpoint | Lean.Elab.PreDefinition.PartialFixpoint.Induction | Lean.Environment → Lean.Name → Bool | true |
MvPowerSeries.weightedOrder_eq_top_iff | Mathlib.RingTheory.MvPowerSeries.Order | ∀ {σ : Type u_1} {R : Type u_2} [inst : Semiring R] (w : σ → ℕ) {f : MvPowerSeries σ R},
MvPowerSeries.weightedOrder w f = ⊤ ↔ f = 0 | true |
_private.Batteries.Data.BitVec.Lemmas.0.BitVec.getMsbD_ofFnBE._proof_1_4 | Batteries.Data.BitVec.Lemmas | ∀ {n : ℕ} (f : Fin n → Bool) (i : ℕ), -1 * ↑n + ↑i + 1 ≤ 0 → (BitVec.ofFnBE f).getMsbD i = true → n - (i + 1) < n | false |
le_refl | Mathlib.Order.Defs.PartialOrder | ∀ {α : Type u_1} [inst : Preorder α] (a : α), a ≤ a | true |
Std.TreeSet.Raw.min?_le_of_mem | Std.Data.TreeSet.Raw.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t : Std.TreeSet.Raw α cmp} [inst : Std.TransCmp cmp] (h : t.WF) {k km : α}
(hc : k ∈ t), t.min?.get ⋯ = km → (cmp km k).isLE = true | true |
Ideal.pow_mem_of_mem | Mathlib.RingTheory.Ideal.Defs | ∀ {α : Type u} [inst : Semiring α] (I : Ideal α) {a : α}, a ∈ I → ∀ (n : ℕ), 0 < n → a ^ n ∈ I | true |
_private.Mathlib.Order.CompleteLattice.SetLike.0.CompleteSublattice.mem_sup._simp_1_1 | Mathlib.Order.CompleteLattice.SetLike | ∀ {X : Type u_1} {L : CompleteSublattice (Set X)} {T : ↥L} {x : X}, (x ∈ T) = (x ∈ L.subtype T) | false |
ValuativeRel.recOn | Mathlib.RingTheory.Valuation.ValuativeRel.Basic | {R : Type u_1} →
[inst : CommRing R] →
{motive : ValuativeRel R → Sort u} →
(t : ValuativeRel R) →
((vle : R → R → Prop) →
(vle_total : ∀ (x y : R), vle x y ∨ vle y x) →
(vle_trans : ∀ {z y x : R}, vle x y → vle y z → vle x z) →
(vle_add : ∀ {x y z : R}, vle... | false |
Lean.Lsp.WorkDoneProgressBegin.mk.injEq | Lean.Data.Lsp.Basic | ∀ (toWorkDoneProgressReport : Lean.Lsp.WorkDoneProgressReport) (title : String)
(toWorkDoneProgressReport_1 : Lean.Lsp.WorkDoneProgressReport) (title_1 : String),
({ toWorkDoneProgressReport := toWorkDoneProgressReport, title := title } =
{ toWorkDoneProgressReport := toWorkDoneProgressReport_1, title := titl... | true |
pi_norm_const_le | Mathlib.Analysis.Normed.Group.Constructions | ∀ {ι : Type u_1} {E : Type u_2} [inst : Fintype ι] [inst_1 : SeminormedAddGroup E] (a : E), ‖fun x => a‖ ≤ ‖a‖ | true |
instNonUnitalCommCStarAlgebraForall._proof_11 | Mathlib.Analysis.CStarAlgebra.Classes | ∀ {ι : Type u_1} {A : ι → Type u_2} [inst : Fintype ι] [inst_1 : (i : ι) → NonUnitalCommCStarAlgebra (A i)],
SMulCommClass ℂ ((i : ι) → A i) ((i : ι) → A i) | false |
PiTensorProduct.congr._proof_1 | Mathlib.LinearAlgebra.PiTensorProduct | ∀ {ι : Type u_1} {R : Type u_3} [inst : CommSemiring R] {s : ι → Type u_4} [inst_1 : (i : ι) → AddCommMonoid (s i)]
[inst_2 : (i : ι) → Module R (s i)] {t : ι → Type u_2} [inst_3 : (i : ι) → AddCommMonoid (t i)]
[inst_4 : (i : ι) → Module R (t i)] (f : (i : ι) → s i ≃ₗ[R] t i),
((PiTensorProduct.map fun i => ↑(f ... | false |
Std.Tactic.BVDecide.BVExpr.bitblast.blastConst.go._unary | Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Const | {α : Type} →
[inst : Hashable α] →
[inst_1 : DecidableEq α] →
{w : ℕ} → (aig : Std.Sat.AIG α) → BitVec w → (curr : ℕ) ×' (_ : aig.RefVec curr) ×' curr ≤ w → aig.RefVec w | false |
Set.termDefinable₁_iff_exists_term | Mathlib.ModelTheory.Definability | ∀ {M : Type w} {A : Set M} {L : FirstOrder.Language} [inst : L.Structure M] {f : M → M},
Set.TermDefinable₁ L f ↔ ∃ φ, f = (fun v => FirstOrder.Language.Term.realize v φ) ∘ Function.const Unit | true |
Finset.uIcc_self | Mathlib.Order.Interval.Finset.Basic | ∀ {α : Type u_2} [inst : Lattice α] [inst_1 : LocallyFiniteOrder α] {a : α}, Finset.uIcc a a = {a} | true |
TensorProduct.AlgebraTensorModule.lift_tmul | Mathlib.LinearAlgebra.TensorProduct.Tower | ∀ {R : Type uR} {A : Type uA} {M : Type uM} {N : Type uN} {P : Type uP} [inst : CommSemiring R] [inst_1 : Semiring A]
[inst_2 : Algebra R A] [inst_3 : AddCommMonoid M] [inst_4 : Module R M] [inst_5 : Module A M]
[inst_6 : IsScalarTower R A M] [inst_7 : AddCommMonoid N] [inst_8 : Module R N] [inst_9 : AddCommMonoid ... | true |
AddMonoidAlgebra.supDegree_leadingCoeff_sum_eq | Mathlib.Algebra.MonoidAlgebra.Degree | ∀ {R : Type u_1} {A : Type u_3} {B : Type u_5} [inst : Semiring R] [inst_1 : LinearOrder B] [inst_2 : OrderBot B]
{D : A → B} {ι : Type u_7} {s : Finset ι} {i : ι} {f : ι → AddMonoidAlgebra R A} [inst_3 : AddZeroClass A],
i ∈ s →
(∀ j ∈ s, j ≠ i → AddMonoidAlgebra.supDegree D (f j) < AddMonoidAlgebra.supDegree ... | true |
Graph.IsInducedSubgraph.recOn | Mathlib.Combinatorics.Graph.Subgraph | {α : Type u_1} →
{β : Type u_2} →
{H G : Graph α β} →
{motive : H.IsInducedSubgraph G → Sort u} →
(t : H.IsInducedSubgraph G) →
((toIsSubgraph : H.IsSubgraph G) →
(isLink_of_mem_mem :
∀ ⦃e : β⦄ ⦃x y : α⦄, G.IsLink e x y → x ∈ H.vertexSet → y ∈ H.vertexSet → ... | false |
_private.Mathlib.LinearAlgebra.Matrix.Notation.0.Matrix.delabMatrixNotation._sparseCasesOn_5 | Mathlib.LinearAlgebra.Matrix.Notation | {motive : Lean.Expr → Sort u} →
(t : Lean.Expr) →
((declName : Lean.Name) → (us : List Lean.Level) → motive (Lean.Expr.const declName us)) →
(Nat.hasNotBit 16 t.ctorIdx → motive t) → motive t | false |
_private.Lean.Elab.Do.Legacy.0.Lean.Elab.Term.Do.expandDoIf?.match_3 | Lean.Elab.Do.Legacy | (motive : Lean.TSyntax `Lean.Parser.Term.doIfCond × Lean.TSyntax `Lean.Parser.Term.doSeq → Sort u_1) →
(x : Lean.TSyntax `Lean.Parser.Term.doIfCond × Lean.TSyntax `Lean.Parser.Term.doSeq) →
((conds : Lean.TSyntax `Lean.Parser.Term.doIfCond) →
(ts : Lean.TSyntax `Lean.Parser.Term.doSeq) → motive (conds, ts... | false |
UInt64.neg_sub | Init.Data.UInt.Lemmas | ∀ {a b : UInt64}, -(a - b) = b - a | true |
Lean.Meta.Grind.checkSplitStatus | Lean.Meta.Tactic.Grind.Split | Lean.Meta.Grind.SplitInfo → Lean.Meta.Grind.GoalM Lean.Meta.Grind.SplitStatus | true |
Std.TreeMap.Equiv.getKeyLT!_eq | Std.Data.TreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t₁ t₂ : Std.TreeMap α β cmp} [Std.TransCmp cmp]
[inst : Inhabited α] {k : α}, t₁.Equiv t₂ → t₁.getKeyLT! k = t₂.getKeyLT! k | true |
LineDeriv.lineDerivOpCLM_apply | Mathlib.Analysis.Distribution.DerivNotation | ∀ {R : Type u_4} {V : Type u_5} {E : Type u_6} {F : Type u_7} [inst : Ring R] [inst_1 : AddCommGroup E]
[inst_2 : Module R E] [inst_3 : AddCommGroup F] [inst_4 : Module R F] [inst_5 : TopologicalSpace E]
[inst_6 : TopologicalSpace F] [inst_7 : AddCommGroup V] [inst_8 : LineDeriv V E F] [inst_9 : LineDerivAdd V E F]... | true |
Polynomial.Chebyshev.U_eval_neg | Mathlib.RingTheory.Polynomial.Chebyshev | ∀ (R : Type u_1) [inst : CommRing R] (n : ℕ) (x : R),
Polynomial.eval (-x) (Polynomial.Chebyshev.U R ↑n) =
↑↑(↑n).negOnePow * Polynomial.eval x (Polynomial.Chebyshev.U R ↑n) | true |
Lean.ModuleSetup.plugins._default | Lean.Setup | Array System.FilePath | false |
MonadCont.Label.ctorIdx | Mathlib.Control.Monad.Cont | {α : Type w} → {m : Type u → Type v} → {β : Type u} → MonadCont.Label α m β → ℕ | false |
Std.DTreeMap.Internal.Impl.Const.size_insertMany_empty_list | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {instOrd : Ord α} {β : Type v} [Std.TransOrd α] {l : List (α × β)},
List.Pairwise (fun a b => ¬compare a.1 b.1 = Ordering.eq) l →
(↑(Std.DTreeMap.Internal.Impl.Const.insertMany Std.DTreeMap.Internal.Impl.empty l ⋯)).size = l.length | true |
Filter.principal_neBot_iff._simp_1 | Mathlib.Order.Filter.Basic | ∀ {α : Type u} {s : Set α}, (Filter.principal s).NeBot = s.Nonempty | false |
ModuleCat.Hom.ctorIdx | Mathlib.Algebra.Category.ModuleCat.Basic | {R : Type u} → {inst : Ring R} → {M N : ModuleCat R} → M.Hom N → ℕ | false |
HomologicalComplex.extend.rightHomologyData.isColimitCokernelCofork | Mathlib.Algebra.Homology.Embedding.ExtendHomology | {ι : Type u_1} →
{ι' : Type u_2} →
{c : ComplexShape ι} →
{c' : ComplexShape ι'} →
{C : Type u_3} →
[inst : CategoryTheory.Category.{v_1, u_3} C] →
[inst_1 : CategoryTheory.Limits.HasZeroMorphisms C] →
[inst_2 : CategoryTheory.Limits.HasZeroObject C] →
... | true |
_private.Mathlib.RingTheory.MvPolynomial.Basic.0.MvPolynomial.mem_restrictDegree_iff_sup._simp_1_1 | Mathlib.RingTheory.MvPolynomial.Basic | ∀ (σ : Type u) {R : Type v} [inst : CommSemiring R] (p : MvPolynomial σ R) (n : ℕ),
(p ∈ MvPolynomial.restrictDegree σ R n) = ∀ s ∈ p.support, ∀ (i : σ), s i ≤ n | false |
List.exists_cons_of_length_pos | Init.Data.List.Lemmas | ∀ {α : Type u_1} {l : List α}, 0 < l.length → ∃ h t, l = h :: t | true |
Lean.Parser.ParserExtension.Entry.token.elim | Lean.Parser.Extension | {motive : Lean.Parser.ParserExtension.Entry → Sort u} →
(t : Lean.Parser.ParserExtension.Entry) →
t.ctorIdx = 0 → ((val : Lean.Parser.Token) → motive (Lean.Parser.ParserExtension.Entry.token val)) → motive t | false |
Std.DTreeMap.Const.forInUncurried | Std.Data.DTreeMap.Basic | {α : Type u} →
{cmp : α → α → Ordering} →
{δ : Type w} →
{m : Type w → Type w₂} →
[Monad m] → {β : Type v} → (α × β → δ → m (ForInStep δ)) → δ → Std.DTreeMap α (fun x => β) cmp → m δ | true |
exists_eq_or_imp._simp_1 | Init.PropLemmas | ∀ {α : Sort u_1} {p q : α → Prop} {a' : α}, (∃ a, (a = a' ∨ q a) ∧ p a) = (p a' ∨ ∃ a, q a ∧ p a) | false |
_private.Mathlib.Data.Finsupp.NeLocus.0.Finsupp.mem_neLocus._simp_1_4 | Mathlib.Data.Finsupp.NeLocus | ∀ {α : Type u_1} {M : Type u_4} [inst : Zero M] {f : α →₀ M} {a : α}, (a ∈ f.support) = (f a ≠ 0) | false |
Polynomial.intCast_inj._simp_1 | Mathlib.Algebra.Polynomial.Coeff | ∀ {m n : ℤ} {R : Type u_1} [inst : Ring R] [CharZero R], (↑m = ↑n) = (m = n) | false |
UpperSet.mem_inf_iff | Mathlib.Order.UpperLower.CompleteLattice | ∀ {α : Type u_1} [inst : LE α] {s t : UpperSet α} {a : α}, a ∈ s ⊓ t ↔ a ∈ s ∨ a ∈ t | true |
Lean.Meta.Grind.Arith.Cutsat.EqCnstr.mk.noConfusion | Lean.Meta.Tactic.Grind.Arith.Cutsat.Types | {P : Sort u} →
{p : Int.Linear.Poly} →
{h : Lean.Meta.Grind.Arith.Cutsat.EqCnstrProof} →
{p' : Int.Linear.Poly} →
{h' : Lean.Meta.Grind.Arith.Cutsat.EqCnstrProof} →
{ p := p, h := h } = { p := p', h := h' } → (p = p' → h = h' → P) → P | false |
LocalizedModule.subsingleton_iff | Mathlib.Algebra.Module.LocalizedModule.Basic | ∀ {R : Type u_1} {M : Type u_2} [inst : CommRing R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] {S : Submonoid R},
Subsingleton (LocalizedModule S M) ↔ ∀ (m : M), ∃ r ∈ S, r • m = 0 | true |
Polynomial.Splits.multisetProd._simp_1 | Mathlib.Algebra.Polynomial.Splits | ∀ {R : Type u_1} [inst : CommSemiring R] {m : Multiset (Polynomial R)}, (∀ f ∈ m, f.Splits) → m.prod.Splits = True | false |
EuclideanGeometry.inversion_involutive | 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 : P) {R : ℝ}, R ≠ 0 → Function.Involutive (EuclideanGeometry.inversion c R) | true |
CategoryTheory.Limits.pullback.diagonalObj | Mathlib.CategoryTheory.Limits.Shapes.Diagonal | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] → {X Y : C} → (f : X ⟶ Y) → [CategoryTheory.Limits.HasPullback f f] → C | true |
Aesop.CompleteMatch.mk.injEq | Aesop.Forward.Match.Types | ∀ (clusterMatches clusterMatches_1 : Array Aesop.Match),
({ clusterMatches := clusterMatches } = { clusterMatches := clusterMatches_1 }) = (clusterMatches = clusterMatches_1) | true |
Primrec.option_getD | Mathlib.Computability.Primrec.Basic | ∀ {α : Type u_1} [inst : Primcodable α], Primrec₂ Option.getD | true |
_private.Mathlib.MeasureTheory.Integral.Lebesgue.Countable.0.MeasureTheory.SimpleFunc.exists_lt_lintegral_simpleFunc_of_lt_lintegral._simp_1_4 | Mathlib.MeasureTheory.Integral.Lebesgue.Countable | ∀ {α : Type u_1} [inst : AddZeroClass α] [inst_1 : LE α] [AddRightMono α] [AddRightReflectLE α] (a : α) {b : α},
(a ≤ b + a) = (0 ≤ b) | false |
Cardinal.toENat_congr | Mathlib.SetTheory.Cardinal.ENat | ∀ {α : Type u} {β : Type v} (e : α ≃ β), Cardinal.toENat (Cardinal.mk α) = Cardinal.toENat (Cardinal.mk β) | true |
ContinuousMap.Homotopy.prod._proof_3 | Mathlib.Topology.Homotopy.Product | ∀ {α : Type u_1} {β : Type u_2} [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β] {A : Type u_3}
[inst_2 : TopologicalSpace A] {f₀ f₁ : C(A, α)} {g₀ g₁ : C(A, β)} (F : f₀.Homotopy f₁) (G : g₀.Homotopy g₁) (x : A),
(F (1, x), G (1, x)) = (f₁.prodMk g₁) x | false |
_private.Lean.Meta.Sym.Simp.Rewrite.0.Lean.Meta.Sym.Simp.mkValue.match_1 | Lean.Meta.Sym.Simp.Rewrite | (motive : Lean.Expr → Sort u_1) →
(expr : Lean.Expr) →
((declName : Lean.Name) → motive (Lean.Expr.const declName [])) → ((x : Lean.Expr) → motive x) → motive expr | false |
SeparationQuotient.instNonUnitalNormedCommRing._proof_2 | Mathlib.Analysis.Normed.Ring.Lemmas | ∀ {α : Type u_1} [inst : NonUnitalSeminormedCommRing α] (x y : SeparationQuotient α), dist x y = ‖-x + y‖ | false |
_private.Mathlib.GroupTheory.Coxeter.Inversion.0.CoxeterSystem.isReflection_of_mem_leftInvSeq._simp_1_1 | Mathlib.GroupTheory.Coxeter.Inversion | ∀ {α : Type u_1} {x : α} {as : List α}, (x ∈ as.reverse) = (x ∈ as) | false |
StrictAnti.image_Ico_subset | Mathlib.Order.Interval.Set.Image | ∀ {α : Type u_1} {β : Type u_2} {f : α → β} [inst : PartialOrder α] [inst_1 : Preorder β] {a b : α},
StrictAnti f → f '' Set.Ico a b ⊆ Set.Ioc (f b) (f a) | true |
Lean.Lsp.CodeActionParams.mk | Lean.Data.Lsp.CodeActions | Lean.Lsp.WorkDoneProgressParams →
Lean.Lsp.PartialResultParams →
Lean.Lsp.TextDocumentIdentifier → Lean.Lsp.Range → Lean.Lsp.CodeActionContext → Lean.Lsp.CodeActionParams | true |
_private.Mathlib.Order.Filter.Lift.0.Filter.tendsto_prod_self_iff._simp_1_3 | Mathlib.Order.Filter.Lift | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} {s : Set α} {t : Set β} {W : Set γ} {f : α × β → γ},
(s ×ˢ t ⊆ f ⁻¹' W) = ∀ (a : α) (b : β), a ∈ s → b ∈ t → f (a, b) ∈ W | false |
OrthonormalBasis.equiv_apply_euclideanSpace | Mathlib.Analysis.InnerProductSpace.PiL2 | ∀ {ι : Type u_1} {𝕜 : Type u_3} [inst : RCLike 𝕜] {E : Type u_4} [inst_1 : NormedAddCommGroup E]
[inst_2 : InnerProductSpace 𝕜 E] [inst_3 : Fintype ι] (b : OrthonormalBasis ι 𝕜 E) (x : EuclideanSpace 𝕜 ι),
((EuclideanSpace.basisFun ι 𝕜).equiv b (Equiv.refl ι)) x = ∑ i, x.ofLp i • b i | true |
Lean.Elab.instMonadMacroAdapterOfMonadLiftOfMonadQuotation | Lean.Elab.Util | (m n : Type → Type) →
[MonadLift m n] → [Lean.MonadQuotation n] → [Lean.Elab.MonadMacroAdapter m] → Lean.Elab.MonadMacroAdapter n | true |
LucasLehmer.X.instAddCommGroup._aux_1 | Mathlib.NumberTheory.LucasLehmer | {q : ℕ} → LucasLehmer.X q → LucasLehmer.X q → LucasLehmer.X q | false |
WithTop.map_ofNat | Mathlib.Algebra.Order.Monoid.Unbundled.WithTop | ∀ {α : Type u} {β : Type v} [inst : AddMonoidWithOne α] {f : α → β} (n : ℕ) [inst_1 : n.AtLeastTwo],
WithTop.map f (OfNat.ofNat n) = ↑(f (OfNat.ofNat n)) | true |
_private.Mathlib.Algebra.BigOperators.Intervals.0.Fin.prod_Iic_div._proof_1_3 | Mathlib.Algebra.BigOperators.Intervals | ∀ {M : Type u_1} [inst : CommGroup M] {n : ℕ} (a : Fin n) (f : Fin (n + 1) → M),
∀ a_1 ∈ Finset.range n,
a_1 ∉ Finset.range (↑a + 1) →
(if h : a_1 < n then if ⟨a_1, h⟩ ∈ Finset.Iic a then f ⟨a_1, h⟩.succ / f ⟨a_1, h⟩.castSucc else 1 else 1) = 1 | false |
DFinsupp.recOn | Mathlib.Data.DFinsupp.Defs | {ι : Type u} →
{β : ι → Type v} →
[inst : (i : ι) → Zero (β i)] →
{motive : DFinsupp β → Sort u_1} →
(t : DFinsupp β) →
((toFun : (i : ι) → β i) →
(support' : Trunc { s // ∀ (i : ι), i ∈ s ∨ toFun i = 0 }) →
motive { toFun := toFun, support' := support' }) →
... | false |
Lean.Lsp.WorkspaceEditClientCapabilities.recOn | Lean.Data.Lsp.Capabilities | {motive : Lean.Lsp.WorkspaceEditClientCapabilities → Sort u} →
(t : Lean.Lsp.WorkspaceEditClientCapabilities) →
((documentChanges? : Option Bool) →
(changeAnnotationSupport? : Option Lean.Lsp.ChangeAnnotationSupport) →
(resourceOperations? : Option (Array String)) →
motive
... | false |
QuotientAddGroup.liftEquiv_coe | Mathlib.GroupTheory.QuotientGroup.Defs | ∀ {G : Type u_1} {H : Type u_2} [inst : AddGroup G] [inst_1 : AddGroup H] (N : AddSubgroup G) [nN : N.Normal]
{φ : G →+ H} (hφ : Function.Surjective ⇑φ) (HN : N = φ.ker) (g : G), (QuotientAddGroup.liftEquiv N hφ HN) ↑g = φ g | true |
PiTensorProduct.lifts_smul | Mathlib.LinearAlgebra.PiTensorProduct | ∀ {ι : Type u_1} {R : Type u_4} [inst : CommSemiring R] {s : ι → Type u_7} [inst_1 : (i : ι) → AddCommMonoid (s i)]
[inst_2 : (i : ι) → Module R (s i)] {x : PiTensorProduct R fun i => s i} {p : FreeAddMonoid (R × ((i : ι) → s i))},
p ∈ x.lifts → ∀ (a : R), (FreeAddMonoid.map fun y => (a * y.1, y.2)) p ∈ (a • x).lif... | true |
Submodule.rank_le_one_iff_isPrincipal | Mathlib.LinearAlgebra.Dimension.FreeAndStrongRankCondition | ∀ {K : Type u} {V : Type v} [inst : Ring K] [StrongRankCondition K] [inst_2 : AddCommGroup V] [inst_3 : Module K V]
(W : Submodule K V) [Module.Free K ↥W], Module.rank K ↥W ≤ 1 ↔ W.IsPrincipal | true |
_private.Mathlib.Data.List.Basic.0.List.getLast?_eq_getLast_of_ne_nil.match_1_1 | Mathlib.Data.List.Basic | ∀ {α : Type u_1} (motive : (x : List α) → x ≠ [] → Prop) (x : List α) (x_1 : x ≠ []),
(∀ (h : [] ≠ []), motive [] h) →
(∀ (head : α) (x : [head] ≠ []), motive [head] x) →
(∀ (head b : α) (l : List α) (x : head :: b :: l ≠ []), motive (head :: b :: l) x) → motive x x_1 | false |
PiTensorProduct.liftAddHom | Mathlib.LinearAlgebra.PiTensorProduct | {ι : Type u_1} →
{R : Type u_4} →
[inst : CommSemiring R] →
{s : ι → Type u_7} →
[inst_1 : (i : ι) → AddCommMonoid (s i)] →
[inst_2 : (i : ι) → Module R (s i)] →
{F : Type u_10} →
[inst_3 : AddCommMonoid F] →
(φ : R × ((i : ι) → s i) → F) →
... | true |
SemiNormedGrp.completion.map_normNoninc | Mathlib.Analysis.Normed.Group.SemiNormedGrp.Completion | ∀ {V W : SemiNormedGrp} {f : V ⟶ W},
(SemiNormedGrp.Hom.hom f).NormNoninc → (SemiNormedGrp.Hom.hom (SemiNormedGrp.completion.map f)).NormNoninc | true |
Nat.le_total | Init.Data.Nat.Basic | ∀ (m n : ℕ), m ≤ n ∨ n ≤ m | true |
IsLocalMin.hasLineDerivAt_eq_zero | Mathlib.Analysis.Calculus.LocalExtr.LineDeriv | ∀ {E : Type u_1} [inst : AddCommGroup E] [inst_1 : Module ℝ E] [inst_2 : TopologicalSpace E] [ContinuousAdd E]
[ContinuousSMul ℝ E] {f : E → ℝ} {a b : E} {f' : ℝ}, IsLocalMin f a → HasLineDerivAt ℝ f f' a b → f' = 0 | true |
TopCat.Sheaf.isProductOfDisjoint.congr_simp | Mathlib.AlgebraicGeometry.Limits | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {X : TopCat} (F : TopCat.Sheaf C X)
(U V : TopologicalSpace.Opens ↑X) (h : U ⊓ V = ⊥), F.isProductOfDisjoint U V h = F.isProductOfDisjoint U V h | true |
List.instLinearOrder._proof_2 | Mathlib.Data.List.Lex | ∀ {α : Type u_1} [inst : LinearOrder α],
(∀ {r : α → α → Prop} [IsStrictTotalOrder α r], IsStrictTotalOrder (List α) (List.Lex r)) →
IsStrictTotalOrder (List α) (List.Lex fun x1 x2 => x1 < x2) | false |
Std.DTreeMap.minKey.congr_simp | Std.Data.DTreeMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} (t t_1 : Std.DTreeMap α β cmp) (e_t : t = t_1)
(h : t.isEmpty = false), t.minKey h = t_1.minKey ⋯ | true |
Vector.toArray_eq_empty_iff | Init.Data.Vector.Lemmas | ∀ {α : Type u_1} {n : ℕ} {xs : Vector α n}, xs.toArray = #[] ↔ n = 0 | true |
StieltjesFunction.measure_Ico | Mathlib.MeasureTheory.Measure.Stieltjes | ∀ {R : Type u_1} [inst : LinearOrder R] [inst_1 : TopologicalSpace R] (f : StieltjesFunction R)
[inst_2 : OrderTopology R] [inst_3 : CompactIccSpace R] [inst_4 : MeasurableSpace R] [inst_5 : BorelSpace R]
[inst_6 : SecondCountableTopology R] [inst_7 : DenselyOrdered R] (a b : R),
f.measure (Set.Ico a b) = ENNReal... | true |
_private.Mathlib.RingTheory.Polynomial.UniversalFactorizationRing.0.Polynomial.degree_freeMonic._simp_1_2 | Mathlib.RingTheory.Polynomial.UniversalFactorizationRing | ∀ {α : Type u_1} [inst : Preorder α] {a b : α}, b < a → (a = b) = False | false |
CategoryTheory.MonoidalCoherence.whiskerLeft_iso | Mathlib.Tactic.CategoryTheory.MonoidalComp | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.MonoidalCategory C] (X Y Z : C)
[inst_2 : CategoryTheory.MonoidalCoherence Y Z],
CategoryTheory.MonoidalCoherence.iso =
CategoryTheory.MonoidalCategory.whiskerLeftIso X CategoryTheory.MonoidalCoherence.iso | true |
AugmentedSimplexCategory.instMonoidalCategoryStruct | Mathlib.AlgebraicTopology.SimplexCategory.Augmented.Monoidal | CategoryTheory.MonoidalCategoryStruct AugmentedSimplexCategory | true |
Std.DTreeMap.Internal.Impl.Const.get?.match_1 | Std.Data.DTreeMap.Internal.Queries | {α : Type u_1} →
{δ : Type u_2} →
(motive : (Std.DTreeMap.Internal.Impl α fun x => δ) → Sort u_3) →
(t : Std.DTreeMap.Internal.Impl α fun x => δ) →
(Unit → motive Std.DTreeMap.Internal.Impl.leaf) →
((size : ℕ) →
(k' : α) →
(v' : δ) →
(l r : S... | false |
Lean.Grind.Linarith.Poly.collectVars._unsafe_rec | Lean.Meta.Tactic.Grind.Arith.Linear.VarRename | Lean.Grind.Linarith.Poly → Lean.Meta.Grind.VarCollector | false |
Std.TreeMap.not_mem_diff_of_not_mem_left | Std.Data.TreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t₁ t₂ : Std.TreeMap α β cmp} [Std.TransCmp cmp] {k : α},
k ∉ t₁ → k ∉ t₁ \ t₂ | true |
half_le_self | Mathlib.Algebra.Order.Field.Basic | ∀ {α : Type u_2} [inst : Semifield α] [inst_1 : PartialOrder α] [PosMulReflectLT α] {a : α} [IsStrictOrderedRing α],
0 ≤ a → a / 2 ≤ a | true |
_private.Mathlib.Analysis.SpecialFunctions.Stirling.0.Stirling.log_stirlingSeq_diff_hasSum._simp_1_6 | Mathlib.Analysis.SpecialFunctions.Stirling | ∀ {G₀ : Type u_3} [inst : GroupWithZero G₀] {a : G₀} (n : ℤ), a ≠ 0 → (a ^ n = 0) = False | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.