name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
himp_top | Mathlib.Order.Heyting.Basic | ∀ {α : Type u_2} [inst : GeneralizedHeytingAlgebra α] {a : α}, a ⇨ ⊤ = ⊤ | true |
csInf_Ioi | Mathlib.Order.ConditionallyCompleteLattice.Basic | ∀ {α : Type u_1} [inst : ConditionallyCompleteLattice α] {a : α} [NoMaxOrder α] [DenselyOrdered α], sInf (Set.Ioi a) = a | true |
_private.Mathlib.Dynamics.OmegaLimit.0.mem_omegaLimit_iff_frequently._simp_1_1 | Mathlib.Dynamics.OmegaLimit | ∀ {α : Type u} {f : Filter α} {P : α → Prop}, (∃ᶠ (x : α) in f, P x) = ∀ {U : Set α}, U ∈ f → ∃ x ∈ U, P x | false |
Rep.ofMulActionSubsingletonIsoTrivial | Mathlib.RepresentationTheory.Rep.Basic | (k : Type u) →
(G : Type v) →
[inst : Ring k] →
[inst_1 : Monoid G] →
(H : Type u) →
[Subsingleton H] → [MulOneClass H] → [inst_4 : MulAction G H] → Rep.ofMulAction k G H ≅ Rep.trivial k G k | true |
Finset.ordConnected_range_val | Mathlib.Data.Finset.Grade | ∀ {α : Type u_1}, (Set.range Finset.val).OrdConnected | true |
ringHomEquivModuleIsScalarTower._proof_4 | Mathlib.Algebra.Module.RingHom | ∀ {R : Type u_1} {S : Type u_2} [inst : Semiring R] [inst_1 : Semiring S] (x : { _inst // IsScalarTower R S S }),
⟨Module.compHom S
(match x with
| ⟨val, property⟩ => RingHom.smulOneHom),
⋯⟩ =
x | false |
NonemptyInterval.subtractionCommMonoid._proof_11 | Mathlib.Algebra.Order.Interval.Basic | ∀ {α : Type u_1} [inst : AddCommGroup α] [inst_1 : PartialOrder α] [inst_2 : IsOrderedAddMonoid α]
(a b : NonemptyInterval α), a + b = b + a | false |
Lean.PrettyPrinter.Delaborator.TopDownAnalyze.App.Context.f | Lean.PrettyPrinter.Delaborator.TopDownAnalyze | Lean.PrettyPrinter.Delaborator.TopDownAnalyze.App.Context → Lean.Expr | true |
Ideal.quotientInfRingEquivPiQuotient._proof_2 | Mathlib.RingTheory.Ideal.Quotient.Operations | ∀ {R : Type u_1} [inst : CommRing R] {ι : Type u_2} (f : ι → Ideal R) (i : ι), (f i).IsTwoSided | false |
AlgEquiv.equivCongr_symm | Mathlib.Algebra.Algebra.Equiv | ∀ {R : Type uR} {A₁ : Type uA₁} {A₂ : Type uA₂} {A₁' : Type uA₁'} {A₂' : Type uA₂'} [inst : CommSemiring R]
[inst_1 : Semiring A₁] [inst_2 : Semiring A₂] [inst_3 : Semiring A₁'] [inst_4 : Semiring A₂'] [inst_5 : Algebra R A₁]
[inst_6 : Algebra R A₂] [inst_7 : Algebra R A₁'] [inst_8 : Algebra R A₂'] (e : A₁ ≃ₐ[R] A₂) (e' : A₁' ≃ₐ[R] A₂'),
(e.equivCongr e').symm = e.symm.equivCongr e'.symm | true |
_private.Mathlib.LinearAlgebra.AffineSpace.Combination.0.Finset.weightedVSub_eq_linear_combination._simp_1_1 | Mathlib.LinearAlgebra.AffineSpace.Combination | ∀ {ι : Type u_1} {R : Type u_5} {M : Type u_6} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
{f : ι → R} {s : Finset ι} {x : M}, ∑ i ∈ s, f i • x = (∑ i ∈ s, f i) • x | false |
CategoryTheory.Limits.HasZeroMorphisms.instSubsingleton | Mathlib.CategoryTheory.Limits.Shapes.ZeroMorphisms | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C], Subsingleton (CategoryTheory.Limits.HasZeroMorphisms C) | true |
CategoryTheory.MorphismProperty.transfiniteCompositionsOfShape_le_transfiniteCompositions | Mathlib.CategoryTheory.MorphismProperty.TransfiniteComposition | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (W : CategoryTheory.MorphismProperty C) (J : Type w)
[inst_1 : LinearOrder J] [inst_2 : SuccOrder J] [inst_3 : OrderBot J] [inst_4 : WellFoundedLT J],
W.transfiniteCompositionsOfShape J ≤ CategoryTheory.MorphismProperty.transfiniteCompositions.{w, v, u} W | true |
Subfield.relrank_mul_relrank_eq_inf_relrank | Mathlib.FieldTheory.Relrank | ∀ {E : Type v} [inst : Field E] (A : Subfield E) {B C : Subfield E},
B ≤ C → A.relrank B * B.relrank C = (A ⊓ B).relrank C | true |
IsContDiffImplicitAt.ne_zero | Mathlib.Analysis.Calculus.ImplicitContDiff | ∀ {𝕜 : Type u_1} [inst : RCLike 𝕜] {E₁ : Type u_2} [inst_1 : NormedAddCommGroup E₁] [inst_2 : NormedSpace 𝕜 E₁]
{E₂ : Type u_3} [inst_3 : NormedAddCommGroup E₂] [inst_4 : NormedSpace 𝕜 E₂] {F : Type u_4}
[inst_5 : NormedAddCommGroup F] [inst_6 : NormedSpace 𝕜 F] {n : WithTop ℕ∞} {f : E₁ × E₂ → F} {f' : E₁ × E₂ →L[𝕜] F}
{u : E₁ × E₂}, IsContDiffImplicitAt n f f' u → n ≠ 0 | true |
Finset.insert_inter_of_notMem | Mathlib.Data.Finset.Lattice.Lemmas | ∀ {α : Type u_1} [inst : DecidableEq α] {s₁ s₂ : Finset α} {a : α}, a ∉ s₂ → insert a s₁ ∩ s₂ = s₁ ∩ s₂ | true |
_private.Lean.Meta.Sym.Offset.0.Lean.Meta.Sym.isOffset.match_1 | Lean.Meta.Sym.Offset | (motive : Lean.Expr → Sort u_1) →
(n : Lean.Expr) →
((val : ℕ) → motive (Lean.Expr.lit (Lean.Literal.natVal val))) → ((x : Lean.Expr) → motive x) → motive n | false |
Topology.RelCWComplex.FiniteDimensional.mk._flat_ctor | Mathlib.Topology.CWComplex.Classical.Finite | ∀ {X : Type u} [inst : TopologicalSpace X] {C D : Set X} [inst_1 : Topology.RelCWComplex C D],
(∀ᶠ (n : ℕ) in Filter.atTop, IsEmpty (Topology.RelCWComplex.cell C n)) → Topology.RelCWComplex.FiniteDimensional C | false |
AddCon.toSetoid_bot | Mathlib.GroupTheory.Congruence.Defs | ∀ {M : Type u_1} [inst : Add M], ⊥.toSetoid = ⊥ | true |
_private.Mathlib.GroupTheory.Perm.Cycle.Type.0.Equiv.Perm.IsThreeCycle.nodup_iff_mem_support._proof_1_579 | Mathlib.GroupTheory.Perm.Cycle.Type | ∀ {α : Type u_1} [inst_1 : DecidableEq α] {g : Equiv.Perm α} {a : α} (w : α),
¬[g a, g (g a)].Nodup →
∀ (w_1 : α),
2 ≤ List.count w_1 [g a, g (g a)] →
List.idxOfNth w_1 [g (g a)] [g (g a)].length < (List.filter (fun x => decide (x = w_1)) [g a, g (g a)]).length | false |
_private.Lean.Elab.Tactic.Conv.Congr.0.Lean.Elab.Tactic.Conv.congrImplies.match_1 | Lean.Elab.Tactic.Conv.Congr | (motive : List Lean.MVarId → Sort u_1) →
(__discr : List Lean.MVarId) →
((mvarId₁ mvarId₂ head head_1 : Lean.MVarId) → motive [mvarId₁, mvarId₂, head, head_1]) →
((x : List Lean.MVarId) → motive x) → motive __discr | false |
CategoryTheory.Triangulated.TStructure.eTruncLTGEIsoGELT_hom_app_fac'_assoc | Mathlib.CategoryTheory.Triangulated.TStructure.ETrunc | ∀ {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 : CategoryTheory.Triangulated.TStructure C) [inst_6 : CategoryTheory.IsTriangulated C] (a b : EInt) (X : C) {Z : C}
(h : (t.eTruncGE.obj a).obj X ⟶ Z),
CategoryTheory.CategoryStruct.comp ((t.eTruncLTGEIsoGELT a b).hom.app X)
(CategoryTheory.CategoryStruct.comp ((t.eTruncGE.obj a).map ((t.eTruncLTι b).app X)) h) =
CategoryTheory.CategoryStruct.comp ((t.eTruncLTι b).app ((t.eTruncGE.obj a).obj X)) h | true |
CategoryTheory.GrothendieckTopology.Cover.Arrow.Relation._sizeOf_1 | Mathlib.CategoryTheory.Sites.Grothendieck | {C : Type u} →
{inst : CategoryTheory.Category.{v, u} C} →
{X : C} →
{J : CategoryTheory.GrothendieckTopology C} →
{S : J.Cover X} → {I₁ I₂ : S.Arrow} → [SizeOf C] → I₁.Relation I₂ → ℕ | false |
Lean.Firefox.SampleUnits._sizeOf_1 | Lean.Util.Profiler | Lean.Firefox.SampleUnits → ℕ | false |
MeasureTheory.AEFinStronglyMeasurable.mul | Mathlib.MeasureTheory.Function.StronglyMeasurable.AEStronglyMeasurable | ∀ {α : Type u_1} {β : Type u_2} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} [inst : TopologicalSpace β]
{f g : α → β} [inst_1 : MulZeroClass β] [ContinuousMul β],
MeasureTheory.AEFinStronglyMeasurable f μ →
MeasureTheory.AEFinStronglyMeasurable g μ → MeasureTheory.AEFinStronglyMeasurable (f * g) μ | true |
Subgroup.card_le_card_group | Mathlib.Algebra.Group.Subgroup.Finite | ∀ {G : Type u_1} [inst : Group G] (H : Subgroup G) [Finite G], Nat.card ↥H ≤ Nat.card G | true |
CommRingCat.hasLimitsOfSize | Mathlib.Algebra.Category.Ring.Limits | ∀ [UnivLE.{v, u}], CategoryTheory.Limits.HasLimitsOfSize.{w, v, u, u + 1} CommRingCat | true |
Lean.Parser.manyIndent.formatter | Lean.Parser.Extra | Lean.PrettyPrinter.Formatter → Lean.PrettyPrinter.Formatter | true |
MeasureTheory.AEEqFun.le_inf | Mathlib.MeasureTheory.Function.AEEqFun | ∀ {α : Type u_1} {β : Type u_2} [inst : MeasurableSpace α] {μ : MeasureTheory.Measure α} [inst_1 : TopologicalSpace β]
[inst_2 : SemilatticeInf β] [inst_3 : ContinuousInf β] (f' f g : α →ₘ[μ] β), f' ≤ f → f' ≤ g → f' ≤ f ⊓ g | true |
instDecidableIff._proof_3 | Init.Core | ∀ {p q : Prop}, ¬p → q → (p ↔ q) → False | false |
Std.Tactic.BVDecide.Normalize.Int16.toBitVec_ite | Std.Tactic.BVDecide.Normalize.BitVec | ∀ {c : Prop} {t e : Int16} [inst : Decidable c], (if c then t else e).toBitVec = if c then t.toBitVec else e.toBitVec | true |
Std.HashSet.size_le_size_insertMany_list | Std.Data.HashSet.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {m : Std.HashSet α} [EquivBEq α] [LawfulHashable α] {l : List α},
m.size ≤ (m.insertMany l).size | true |
_private.Lean.Elab.Do.Legacy.0.Lean.Elab.Term.Do.ToTerm.toTerm.go.match_1 | Lean.Elab.Do.Legacy | (motive : Lean.Elab.Term.Do.Code → Sort u_1) →
(c : Lean.Elab.Term.Do.Code) →
((ref val : Lean.Syntax) → motive (Lean.Elab.Term.Do.Code.return ref val)) →
((ref : Lean.Syntax) → motive (Lean.Elab.Term.Do.Code.continue ref)) →
((ref : Lean.Syntax) → motive (Lean.Elab.Term.Do.Code.break ref)) →
((e : Lean.Syntax) → motive (Lean.Elab.Term.Do.Code.action e)) →
((j : Lean.Name) →
(ps : Array (Lean.Elab.Term.Do.Var × Bool)) →
(b k : Lean.Elab.Term.Do.Code) → motive (Lean.Elab.Term.Do.Code.joinpoint j ps b k)) →
((ref : Lean.Syntax) →
(j : Lean.Name) → (args : Array Lean.Syntax) → motive (Lean.Elab.Term.Do.Code.jmp ref j args)) →
((xs : Array Lean.Elab.Term.Do.Var) →
(stx : Lean.Syntax) →
(k : Lean.Elab.Term.Do.Code) → motive (Lean.Elab.Term.Do.Code.decl xs stx k)) →
((xs : Array Lean.Elab.Term.Do.Var) →
(stx : Lean.Syntax) →
(k : Lean.Elab.Term.Do.Code) → motive (Lean.Elab.Term.Do.Code.reassign xs stx k)) →
((stx : Lean.Syntax) → (k : Lean.Elab.Term.Do.Code) → motive (Lean.Elab.Term.Do.Code.seq stx k)) →
((ref : Lean.Syntax) →
(h? : Option Lean.Elab.Term.Do.Var) →
(o c : Lean.Syntax) →
(t e : Lean.Elab.Term.Do.Code) → motive (Lean.Elab.Term.Do.Code.ite ref h? o c t e)) →
((ref genParam discrs optMotive : Lean.Syntax) →
(alts : Array (Lean.Elab.Term.Do.Alt Lean.Elab.Term.Do.Code)) →
motive (Lean.Elab.Term.Do.Code.match ref genParam discrs optMotive alts)) →
((ref : Lean.Syntax) →
(«meta» : Bool) →
(d : Lean.Syntax) →
(alts : Array (Lean.Elab.Term.Do.AltExpr Lean.Elab.Term.Do.Code)) →
(elseBranch : Lean.Elab.Term.Do.Code) →
motive (Lean.Elab.Term.Do.Code.matchExpr ref «meta» d alts elseBranch)) →
motive c | false |
Lean.Widget.MsgEmbed.expr | Lean.Widget.InteractiveDiagnostic | Lean.Widget.CodeWithInfos → Lean.Widget.MsgEmbed | true |
CategoryTheory.ShortComplex.unopFunctor_obj | Mathlib.Algebra.Homology.ShortComplex.Basic | ∀ (C : Type u_1) [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
(S : CategoryTheory.ShortComplex Cᵒᵖ), (CategoryTheory.ShortComplex.unopFunctor C).obj S = Opposite.op S.unop | true |
Field.toEuclideanDomain.match_3 | Mathlib.Algebra.EuclideanDomain.Field | ∀ {K : Type u_1} [inst : Field K] (x x_1 : K) (motive : x * x_1 = 0 ∧ x ≠ 0 → Prop) (x_2 : x * x_1 = 0 ∧ x ≠ 0),
(∀ (hab : x * x_1 = 0) (hna : x ≠ 0), motive ⋯) → motive x_2 | false |
Lean.Omega.LinearCombo.neg_eval | Init.Omega.LinearCombo | ∀ (lc : Lean.Omega.LinearCombo) (v : Lean.Omega.Coeffs), (-lc).eval v = -lc.eval v | true |
MvPolynomial.degreeOf_rename_of_injective | Mathlib.Algebra.MvPolynomial.Degrees | ∀ {R : Type u} {σ : Type u_1} {τ : Type u_2} [inst : CommSemiring R] {p : MvPolynomial σ R} {f : σ → τ},
Function.Injective f → ∀ (i : σ), MvPolynomial.degreeOf (f i) ((MvPolynomial.rename f) p) = MvPolynomial.degreeOf i p | true |
CategoryTheory.Idempotents.app_p_comm | Mathlib.CategoryTheory.Idempotents.FunctorCategories | ∀ {J : Type u_1} {C : Type u_2} [inst : CategoryTheory.Category.{v_1, u_1} J]
[inst_1 : CategoryTheory.Category.{v_2, u_2} C]
{P Q : CategoryTheory.Idempotents.Karoubi (CategoryTheory.Functor J C)} (f : P ⟶ Q) (X : J),
CategoryTheory.CategoryStruct.comp (P.p.app X) (f.f.app X) =
CategoryTheory.CategoryStruct.comp (f.f.app X) (Q.p.app X) | true |
trapezoidal_error | Mathlib.MeasureTheory.Integral.IntervalIntegral.TrapezoidalRule | (ℝ → ℝ) → ℕ → ℝ → ℝ → ℝ | true |
Batteries.RBNode.WF_iff._simp_1 | Batteries.Data.RBMap.WF | ∀ {α : Type u_1} {cmp : α → α → Ordering} {t : Batteries.RBNode α},
Batteries.RBNode.WF cmp t = (Batteries.RBNode.Ordered cmp t ∧ ∃ c n, t.Balanced c n) | false |
CategoryTheory.Functor.FullyFaithful.isoEquiv._proof_2 | Mathlib.CategoryTheory.Functor.FullyFaithful | ∀ {C : Type u_3} [inst : CategoryTheory.Category.{u_1, u_3} C] {D : Type u_4}
[inst_1 : CategoryTheory.Category.{u_2, u_4} D] {F : CategoryTheory.Functor C D} (hF : F.FullyFaithful) {X Y : C},
Function.LeftInverse hF.preimageIso F.mapIso | false |
_private.Mathlib.Topology.ContinuousMap.Ideals.0.ContinuousMap.mem_setOfIdeal._simp_1_2 | Mathlib.Topology.ContinuousMap.Ideals | ∀ {α : Type u} (s : Set α) (x : α), (x ∈ sᶜ) = (x ∉ s) | false |
Lean.Firefox.ThreadWithMaps.mk.injEq | Lean.Util.Profiler | ∀ (toThread : Lean.Firefox.Thread) (stringMap : Std.HashMap String ℕ) (funcMap : Std.HashMap ℕ ℕ)
(stackMap : Std.HashMap (ℕ × Option ℕ) ℕ) (lastTime : Float) (toThread_1 : Lean.Firefox.Thread)
(stringMap_1 : Std.HashMap String ℕ) (funcMap_1 : Std.HashMap ℕ ℕ) (stackMap_1 : Std.HashMap (ℕ × Option ℕ) ℕ)
(lastTime_1 : Float),
({ toThread := toThread, stringMap := stringMap, funcMap := funcMap, stackMap := stackMap, lastTime := lastTime } =
{ toThread := toThread_1, stringMap := stringMap_1, funcMap := funcMap_1, stackMap := stackMap_1,
lastTime := lastTime_1 }) =
(toThread = toThread_1 ∧
stringMap = stringMap_1 ∧ funcMap = funcMap_1 ∧ stackMap = stackMap_1 ∧ lastTime = lastTime_1) | true |
List.zipWith_nil_left | Init.Data.List.Basic | ∀ {α : Type u} {β : Type v} {γ : Type w} {l : List β} {f : α → β → γ}, List.zipWith f [] l = [] | true |
CategoryTheory.EffectiveEpiStruct.mk.sizeOf_spec | Mathlib.CategoryTheory.EffectiveEpi.Basic | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {X Y : C} {f : Y ⟶ X} [inst_1 : SizeOf C]
(desc :
{W : C} →
(e : Y ⟶ W) →
(∀ {Z : C} (g₁ g₂ : Z ⟶ Y),
CategoryTheory.CategoryStruct.comp g₁ f = CategoryTheory.CategoryStruct.comp g₂ f →
CategoryTheory.CategoryStruct.comp g₁ e = CategoryTheory.CategoryStruct.comp g₂ e) →
(X ⟶ W))
(fac :
∀ {W : C} (e : Y ⟶ W)
(h :
∀ {Z : C} (g₁ g₂ : Z ⟶ Y),
CategoryTheory.CategoryStruct.comp g₁ f = CategoryTheory.CategoryStruct.comp g₂ f →
CategoryTheory.CategoryStruct.comp g₁ e = CategoryTheory.CategoryStruct.comp g₂ e),
CategoryTheory.CategoryStruct.comp f (desc e ⋯) = e)
(uniq :
∀ {W : C} (e : Y ⟶ W)
(h :
∀ {Z : C} (g₁ g₂ : Z ⟶ Y),
CategoryTheory.CategoryStruct.comp g₁ f = CategoryTheory.CategoryStruct.comp g₂ f →
CategoryTheory.CategoryStruct.comp g₁ e = CategoryTheory.CategoryStruct.comp g₂ e)
(m : X ⟶ W), CategoryTheory.CategoryStruct.comp f m = e → m = desc e ⋯),
sizeOf { desc := desc, fac := fac, uniq := uniq } = 1 | true |
Lean.Elab.Tactic.Location.recOn | Lean.Elab.Tactic.Location | {motive : Lean.Elab.Tactic.Location → Sort u} →
(t : Lean.Elab.Tactic.Location) →
motive Lean.Elab.Tactic.Location.wildcard →
((hypotheses : Array Lean.Syntax) → (type : Bool) → motive (Lean.Elab.Tactic.Location.targets hypotheses type)) →
motive t | false |
Submodule.quotientEquivPiSpan._proof_6 | Mathlib.LinearAlgebra.FreeModule.Finite.Quotient | ∀ {R : Type u_1} [inst : CommRing R], RingHomCompTriple (RingHom.id R) (RingHom.id R) (RingHom.id R) | false |
zsmul_add | Mathlib.Algebra.Group.Basic | ∀ {α : Type u_1} [inst : SubtractionCommMonoid α] (a b : α) (n : ℤ), n • (a + b) = n • a + n • b | true |
_private.Mathlib.Algebra.Homology.HomotopyCategory.HomComplexShift.0.CochainComplex.HomComplex.Cochain.leftUnshift_leftShift._proof_1_1 | Mathlib.Algebra.Homology.HomotopyCategory.HomComplexShift | ∀ (n' q : ℤ), q - n' + n' = q | false |
fderivPolarCoordSymm._proof_9 | Mathlib.Analysis.SpecialFunctions.PolarCoord | RingHomInvPair (RingHom.id ℝ) (RingHom.id ℝ) | false |
Multiplicative.isIsometricSMul | Mathlib.Topology.MetricSpace.IsometricSMul | ∀ {M : Type u_2} {X : Type u_3} [inst : VAdd M X] [inst_1 : PseudoEMetricSpace X] [IsIsometricVAdd M X],
IsIsometricSMul (Multiplicative M) X | true |
CompactlySupportedContinuousMap.instNonUnitalRingOfIsTopologicalRing._proof_6 | Mathlib.Topology.ContinuousMap.CompactlySupported | ∀ {α : Type u_1} {β : Type u_2} [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β] [inst_2 : NonUnitalRing β]
[inst_3 : IsTopologicalRing β] (f g : CompactlySupportedContinuousMap α β), ⇑(f + g) = ⇑f + ⇑g | false |
Lean.Elab.Tactic.Do.ProofMode.dropStateList | Lean.Elab.Tactic.Do.ProofMode.MGoal | Lean.Expr → ℕ → Lean.MetaM Lean.Expr | true |
Subfield.relrank_inf_mul_relrank | Mathlib.FieldTheory.Relrank | ∀ {E : Type v} [inst : Field E] (A B C : Subfield E), A.relrank (B ⊓ C) * B.relrank C = (A ⊓ B).relrank C | true |
Lean.Compiler.LCNF.Decl.instantiateParamsLevelParams | Lean.Compiler.LCNF.Basic | {pu : Lean.Compiler.LCNF.Purity} → Lean.Compiler.LCNF.Decl pu → List Lean.Level → Array (Lean.Compiler.LCNF.Param pu) | true |
_private.Lean.Meta.Tactic.Simp.BuiltinSimprocs.Fin.0._regBuiltin.Fin.reduceOfNat.declare_151._@.Lean.Meta.Tactic.Simp.BuiltinSimprocs.Fin.2903400553._hygCtx._hyg.14 | Lean.Meta.Tactic.Simp.BuiltinSimprocs.Fin | IO Unit | false |
_private.Mathlib.CategoryTheory.Shift.ShiftedHomOpposite.0.CategoryTheory.ShiftedHom.opEquiv'_add_symm._proof_1_5 | Mathlib.CategoryTheory.Shift.ShiftedHomOpposite | ∀ (n m a a' a'' : ℤ), n + a = a' → m + a' = a'' → a + n + m = a'' | false |
Std.Tactic.BVDecide.Frontend.Normalize.BitVec.bif_eq_not_bif' | Std.Tactic.BVDecide.Normalize.Equal | ∀ {w : ℕ} (d : Bool) (a b c : BitVec w),
((bif d then a else c) == ~~~bif d then b else c) = bif d then a == ~~~b else c == ~~~c | true |
CategoryTheory.Functor.OplaxMonoidal.ofChosenFiniteProducts._proof_4 | Mathlib.CategoryTheory.Monoidal.Cartesian.Basic | ∀ {C : Type u_4} [inst : CategoryTheory.Category.{u_3, u_4} C] [inst_1 : CategoryTheory.CartesianMonoidalCategory C]
{D : Type u_2} [inst_2 : CategoryTheory.Category.{u_1, u_2} D] [inst_3 : CategoryTheory.CartesianMonoidalCategory D]
(F : CategoryTheory.Functor C D) (x : C),
(CategoryTheory.MonoidalCategoryStruct.leftUnitor (F.obj x)).inv =
CategoryTheory.CategoryStruct.comp (F.map (CategoryTheory.MonoidalCategoryStruct.leftUnitor x).inv)
(CategoryTheory.CategoryStruct.comp
(CategoryTheory.CartesianMonoidalCategory.prodComparison F (CategoryTheory.MonoidalCategoryStruct.tensorUnit C)
x)
(CategoryTheory.MonoidalCategoryStruct.whiskerRight
(CategoryTheory.CartesianMonoidalCategory.terminalComparison F) (F.obj x))) | false |
_private.Mathlib.Data.Finset.Insert.0.Finset.pairwise_cons'._proof_1_3 | Mathlib.Data.Finset.Insert | ∀ {α : Type u_1} {β : Type u_2} {s : Finset α} {a : α},
a ∉ s →
∀ (r : β → β → Prop) (f : α → β),
(((↑s).Pairwise fun x y => r (f x) (f y)) ∧ ∀ b ∈ ↑s, ¬a = b → r (f a) (f b) ∧ r (f b) (f a)) ↔
((↑s).Pairwise fun x y => r (f x) (f y)) ∧ ∀ b ∈ s, r (f a) (f b) ∧ r (f b) (f a) | false |
PowerBasis.repr_mul_isIntegral | Mathlib.RingTheory.Adjoin.PowerBasis | ∀ {S : Type u_2} [inst : CommRing S] {R : Type u_3} [inst_1 : CommRing R] [inst_2 : Algebra R S] {A : Type u_4}
[inst_3 : CommRing A] [inst_4 : Algebra R A] [inst_5 : Algebra S A] [IsScalarTower R S A] {B : PowerBasis S A},
IsIntegral R B.gen →
∀ {x y : A},
(∀ (i : Fin B.dim), IsIntegral R ((B.basis.repr x) i)) →
(∀ (i : Fin B.dim), IsIntegral R ((B.basis.repr y) i)) →
minpoly S B.gen = Polynomial.map (algebraMap R S) (minpoly R B.gen) →
∀ (i : Fin B.dim), IsIntegral R ((B.basis.repr (x * y)) i) | true |
CategoryTheory.ShortComplex.HomologyMapData._sizeOf_inst | Mathlib.Algebra.Homology.ShortComplex.Homology | {C : Type u} →
{inst : CategoryTheory.Category.{v, u} C} →
{inst_1 : CategoryTheory.Limits.HasZeroMorphisms C} →
{S₁ S₂ : CategoryTheory.ShortComplex C} →
(φ : S₁ ⟶ S₂) →
(h₁ : S₁.HomologyData) →
(h₂ : S₂.HomologyData) → [SizeOf C] → SizeOf (CategoryTheory.ShortComplex.HomologyMapData φ h₁ h₂) | false |
_private.Mathlib.RingTheory.Norm.Transitivity.0.Algebra.Norm.Transitivity.comp_det_mul_pow._simp_1_2 | Mathlib.RingTheory.Norm.Transitivity | ∀ (I : Type u_1) (J : Type u_2) (R : Type u_5) [inst : AddCommMonoid R] [inst_1 : Mul R] [inst_2 : Fintype I]
[inst_3 : Fintype J] (M : Matrix I I (Matrix J J R)), (Matrix.comp I I J J R) M = (Matrix.compRingEquiv I J R) M | false |
Condensed.ulift._proof_1 | Mathlib.Condensed.Functors | CategoryTheory.Precoherent CompHaus | false |
_private.Lean.Compiler.IR.LLVMBindings.0.LLVM.BasicBlock.mk.noConfusion | Lean.Compiler.IR.LLVMBindings | {Context : Sort u_1} →
{ctx : Context} → {P : Sort u} → {ptr ptr' : USize} → { ptr := ptr } = { ptr := ptr' } → (ptr = ptr' → P) → P | false |
CategoryTheory.Lax.LaxTrans.naturality_naturality._autoParam | Mathlib.CategoryTheory.Bicategory.NaturalTransformation.Lax | Lean.Syntax | false |
MonoidAlgebra.of._proof_2 | Mathlib.Algebra.MonoidAlgebra.Defs | ∀ (R : Type u_2) (M : Type u_1) [inst : Semiring R] [inst_1 : MulOneClass M] (x y : M),
(MonoidAlgebra.ofMagma R M).toFun (x * y) = (MonoidAlgebra.ofMagma R M).toFun x * (MonoidAlgebra.ofMagma R M).toFun y | false |
Int32.reduceLE | Lean.Meta.Tactic.Simp.BuiltinSimprocs.SInt | Lean.Meta.Simp.Simproc | true |
_private.Mathlib.NumberTheory.MahlerMeasure.0.Polynomial.card_mahlerMeasure._proof_1_6 | Mathlib.NumberTheory.MahlerMeasure | ∀ (n : ℕ) (B : NNReal), ∀ a ∈ Finset.univ, ¬2 * ⌊↑(n.choose ↑a) * B⌋₊ + 1 = 0 | false |
ModuleCat.forget₂_reflectsLimitsOfSize | Mathlib.Algebra.Category.ModuleCat.Abelian | ∀ {R : Type u} [inst : Ring R],
CategoryTheory.Limits.ReflectsLimitsOfSize.{v, v, max v w, max v w, max (max u (v + 1)) (w + 1), max (v + 1) (w + 1)}
(CategoryTheory.forget₂ (ModuleCat R) AddCommGrpCat) | true |
ProbabilityTheory.condIndep_of_condIndep_of_le_right | Mathlib.Probability.Independence.Conditional | ∀ {Ω : Type u_1} {m' m₁ m₂ m₃ mΩ : MeasurableSpace Ω} [inst : StandardBorelSpace Ω] {hm' : m' ≤ mΩ}
{μ : MeasureTheory.Measure Ω} [inst_1 : MeasureTheory.IsFiniteMeasure μ],
ProbabilityTheory.CondIndep m' m₁ m₂ hm' μ → m₃ ≤ m₂ → ProbabilityTheory.CondIndep m' m₁ m₃ hm' μ | true |
LieAlgebra.Orthogonal.invertiblePB._proof_1 | Mathlib.Algebra.Lie.Classical | ∀ (l : Type u_2) (R : Type u_1) [inst : DecidableEq l] [inst_1 : CommRing R] [inst_2 : Fintype l],
IsDedekindFiniteMonoid (Matrix (Unit ⊕ l ⊕ l) (Unit ⊕ l ⊕ l) R) | false |
Lean.ElabInline.val | Lean.DocString.Extension | Lean.ElabInline → Dynamic | true |
AugmentedSimplexCategory.instMonoidalCategory._proof_11 | Mathlib.AlgebraicTopology.SimplexCategory.Augmented.Monoidal | ∀ (X Y : AugmentedSimplexCategory),
CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCategoryStruct.associator X
(CategoryTheory.MonoidalCategoryStruct.tensorUnit AugmentedSimplexCategory) Y).hom
(CategoryTheory.MonoidalCategoryStruct.tensorHom (CategoryTheory.CategoryStruct.id X)
(CategoryTheory.MonoidalCategoryStruct.leftUnitor Y).hom) =
CategoryTheory.MonoidalCategoryStruct.tensorHom (CategoryTheory.MonoidalCategoryStruct.rightUnitor X).hom
(CategoryTheory.CategoryStruct.id Y) | false |
Sequential.instCategory._aux_5 | Mathlib.Topology.Category.Sequential | {X Y Z : Sequential} → (X ⟶ Y) → (Y ⟶ Z) → (X ⟶ Z) | false |
BddLat.ofHom | Mathlib.Order.Category.BddLat | {X Y : Type u} →
[inst : Lattice X] →
[inst_1 : BoundedOrder X] →
[inst_2 : Lattice Y] → [inst_3 : BoundedOrder Y] → BoundedLatticeHom X Y → (BddLat.of X ⟶ BddLat.of Y) | true |
_private.Mathlib.Analysis.Calculus.Deriv.Mul.0.derivWithin_fun_const_smul_field._simp_1_1 | Mathlib.Analysis.Calculus.Deriv.Mul | ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {F : Type v} [inst_1 : NormedAddCommGroup F]
[inst_2 : NormedSpace 𝕜 F] {f : 𝕜 → F} {x : 𝕜} {s : Set 𝕜}, derivWithin f s x = (fderivWithin 𝕜 f s x) 1 | false |
Lean.Grind.CommRing.mk._flat_ctor | Init.Grind.Ring.Basic | {α : Type u} →
(add mul : α → α → α) →
[natCast : NatCast α] →
[ofNat : (n : ℕ) → OfNat α n] →
[nsmul : SMul ℕ α] →
[npow : HPow α ℕ α] →
(∀ (a : α), a + 0 = a) →
(∀ (a b : α), a + b = b + a) →
(∀ (a b c : α), a + b + c = a + (b + c)) →
(∀ (a b c : α), a * b * c = a * (b * c)) →
(∀ (a : α), a * 1 = a) →
autoParam (∀ (a : α), 1 * a = a) Lean.Grind.CommSemiring.one_mul._autoParam →
(∀ (a b c : α), a * (b + c) = a * b + a * c) →
autoParam (∀ (a b c : α), (a + b) * c = a * c + b * c)
Lean.Grind.CommSemiring.right_distrib._autoParam →
(∀ (a : α), 0 * a = 0) →
autoParam (∀ (a : α), a * 0 = 0) Lean.Grind.CommSemiring.mul_zero._autoParam →
(∀ (a : α), a ^ 0 = 1) →
(∀ (a : α) (n : ℕ), a ^ (n + 1) = a ^ n * a) →
autoParam (∀ (a : ℕ), OfNat.ofNat (a + 1) = OfNat.ofNat a + 1)
Lean.Grind.Semiring.ofNat_succ._autoParam →
autoParam (∀ (n : ℕ), OfNat.ofNat n = ↑n)
Lean.Grind.Semiring.ofNat_eq_natCast._autoParam →
autoParam (∀ (n : ℕ) (a : α), n • a = ↑n * a)
Lean.Grind.Semiring.nsmul_eq_natCast_mul._autoParam →
(neg : α → α) →
(sub : α → α → α) →
[intCast : IntCast α] →
[zsmul : SMul ℤ α] →
(∀ (a : α), neg a + a = 0) →
(∀ (a b : α), a - b = a + neg b) →
(∀ (i : ℤ) (a : α), -i • a = neg (i • a)) →
autoParam (∀ (n : ℕ) (a : α), ↑n • a = n • a)
Lean.Grind.Ring.zsmul_natCast_eq_nsmul._autoParam →
autoParam (∀ (n : ℕ), ↑(OfNat.ofNat n) = OfNat.ofNat n)
Lean.Grind.Ring.intCast_ofNat._autoParam →
autoParam (∀ (i : ℤ), ↑(-i) = neg ↑i)
Lean.Grind.Ring.intCast_neg._autoParam →
(∀ (a b : α), a * b = b * a) → Lean.Grind.CommRing α | false |
Sigma.Lex.LT | Mathlib.Data.Sigma.Order | {ι : Type u_1} → {α : ι → Type u_2} → [LT ι] → [(i : ι) → LT (α i)] → LT (Σₗ (i : ι), α i) | true |
Std.Do.Iter.foldM_mapM | Std.Do.Triple.SpecLemmas | ∀ {ps : Std.Do.PostShape} {α β γ δ : Type w} {n : Type w → Type w''} {o : Type w → Type w'''}
[inst : Std.Iterator α Id β] [Std.Iterators.Finite α Id] [inst_2 : Monad n] [inst_3 : MonadAttach n] [LawfulMonad n]
[WeaklyLawfulMonadAttach n] [inst_6 : Monad o] [LawfulMonad o] [inst_8 : Std.Do.WPMonad o ps]
[inst_9 : Std.IteratorLoop α Id n] [inst_10 : Std.IteratorLoop α Id o] [Std.LawfulIteratorLoop α Id n]
[Std.LawfulIteratorLoop α Id o] [inst_13 : MonadLiftT n o] [LawfulMonadLiftT n o] {f : β → n γ} {g : δ → γ → o δ}
{init : δ} {it : Std.Iter β} {P : Std.Do.Assertion ps} {Q : Std.Do.PostCond δ ps},
⦃P⦄
Std.Iter.foldM
(fun d b => do
let c ← liftM (f b)
g d c)
init it ⦃Q⦄ →
⦃P⦄ Std.IterM.foldM g init (Std.Iter.mapM f it) ⦃Q⦄ | true |
Lean.Lsp.DocumentSymbol.rec | Lean.Data.Lsp.LanguageFeatures | {motive_1 : Lean.Lsp.DocumentSymbol → Sort u} →
{motive_2 : Lean.Lsp.DocumentSymbolAux Lean.Lsp.DocumentSymbol → Sort u} →
{motive_3 : Option (Array Lean.Lsp.DocumentSymbol) → Sort u} →
{motive_4 : Array Lean.Lsp.DocumentSymbol → Sort u} →
{motive_5 : List Lean.Lsp.DocumentSymbol → Sort u} →
((sym : Lean.Lsp.DocumentSymbolAux Lean.Lsp.DocumentSymbol) →
motive_2 sym → motive_1 (Lean.Lsp.DocumentSymbol.mk sym)) →
((name : String) →
(detail? : Option String) →
(kind : Lean.Lsp.SymbolKind) →
(range selectionRange : Lean.Lsp.Range) →
(children? : Option (Array Lean.Lsp.DocumentSymbol)) →
motive_3 children? →
motive_2
{ name := name, detail? := detail?, kind := kind, range := range,
selectionRange := selectionRange, children? := children? }) →
motive_3 none →
((val : Array Lean.Lsp.DocumentSymbol) → motive_4 val → motive_3 (some val)) →
((toList : List Lean.Lsp.DocumentSymbol) → motive_5 toList → motive_4 { toList := toList }) →
motive_5 [] →
((head : Lean.Lsp.DocumentSymbol) →
(tail : List Lean.Lsp.DocumentSymbol) →
motive_1 head → motive_5 tail → motive_5 (head :: tail)) →
(t : Lean.Lsp.DocumentSymbol) → motive_1 t | false |
Mathlib.Tactic.Widget.StringDiagram.IdNode.mk.inj | Mathlib.Tactic.Widget.StringDiagram | ∀ {vPos hPosSrc hPosTar : ℕ} {id : Mathlib.Tactic.BicategoryLike.Atom₁} {vPos_1 hPosSrc_1 hPosTar_1 : ℕ}
{id_1 : Mathlib.Tactic.BicategoryLike.Atom₁},
{ vPos := vPos, hPosSrc := hPosSrc, hPosTar := hPosTar, id := id } =
{ vPos := vPos_1, hPosSrc := hPosSrc_1, hPosTar := hPosTar_1, id := id_1 } →
vPos = vPos_1 ∧ hPosSrc = hPosSrc_1 ∧ hPosTar = hPosTar_1 ∧ id = id_1 | true |
_private.Mathlib.Data.List.Sublists.0.List.Pairwise.sublists'._simp_1_3 | Mathlib.Data.List.Sublists | ∀ {α : Type u_1} {R : α → α → Prop} {l₁ l₂ : List α},
List.Pairwise R (l₁ ++ l₂) = (List.Pairwise R l₁ ∧ List.Pairwise R l₂ ∧ ∀ a ∈ l₁, ∀ b ∈ l₂, R a b) | false |
Std.IterM.step_filterWithPostcondition._proof_4 | Init.Data.Iterators.Lemmas.Combinators.Monadic.FilterMap | ∀ {α β : Type u_1} {m : Type u_1 → Type u_3} {n : Type u_1 → Type u_2} [inst : Std.Iterator α m β] {it : Std.IterM m β}
{f : β → Std.Iterators.PostconditionT n (ULift.{u_1, 0} Bool)} [inst_1 : Monad n] [inst_2 : MonadLiftT m n]
(it' : Std.IterM m β),
it.IsPlausibleStep (Std.IterStep.skip it') →
(Std.IterM.filterWithPostcondition f it).IsPlausibleStep
(Std.IterStep.skip (Std.IterM.filterWithPostcondition f it')) | false |
Mathlib.Meta.FunProp.FunPropDecl.funArgId | Mathlib.Tactic.FunProp.Decl | Mathlib.Meta.FunProp.FunPropDecl → ℕ | true |
WithBot.addMonoidWithOne | Mathlib.Algebra.Order.Monoid.Unbundled.WithTop | {α : Type u} → [AddMonoidWithOne α] → AddMonoidWithOne (WithBot α) | true |
Metric.exists_finite_isCover_of_isCompact_closure | Mathlib.Topology.MetricSpace.Cover | ∀ {X : Type u_1} [inst : PseudoEMetricSpace X] {ε : NNReal} {s : Set X},
ε ≠ 0 → IsCompact (closure s) → ∃ N ⊆ s, N.Finite ∧ Metric.IsCover ε s N | true |
Order.succ_eq_zero | Mathlib.Algebra.Order.SuccPred | ∀ {α : Type u_1} [inst : PartialOrder α] [inst_1 : AddZeroClass α] [inst_2 : OrderBot α] [CanonicallyOrderedAdd α]
[inst_4 : One α] [NoMaxOrder α] [inst_6 : SuccAddOrder α] {a : WithBot α}, a.succ = 0 ↔ a = ⊥ | true |
CategoryTheory.MorphismProperty.isomorphisms.iff._simp_1 | Mathlib.CategoryTheory.MorphismProperty.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y : C} (f : X ⟶ Y),
CategoryTheory.MorphismProperty.isomorphisms C f = CategoryTheory.IsIso f | false |
Lean.Grind.OrderedAdd.zsmul_nonpos | Init.Grind.Ordered.Module | ∀ {M : Type u} [inst : LE M] [inst_1 : Std.IsPreorder M] [inst_2 : Lean.Grind.IntModule M] [Lean.Grind.OrderedAdd M]
{k : ℤ} {a : M}, 0 ≤ k → a ≤ 0 → k • a ≤ 0 | true |
Affine.Simplex.dist_lt_of_mem_interior_of_strictConvexSpace | Mathlib.Analysis.Convex.StrictCombination | ∀ {V : Type u_2} {P : Type u_3} [inst : NormedAddCommGroup V] [inst_1 : NormedSpace ℝ V] [StrictConvexSpace ℝ V]
[inst_3 : PseudoMetricSpace P] [inst_4 : NormedAddTorsor V P] {n : ℕ} (s : Affine.Simplex ℝ P n) {r : ℝ} {p₀ p : P},
p ∈ s.interior → (∀ (i : Fin (n + 1)), dist (s.points i) p₀ ≤ r) → dist p p₀ < r | true |
Lean.Parser.Term.arrow | Lean.Parser.Term | Lean.Parser.TrailingParser | true |
Int.sub_fdiv_of_dvd | Init.Data.Int.DivMod.Lemmas | ∀ (a : ℤ) {b c : ℤ}, c ∣ b → (a - b).fdiv c = a.fdiv c - b.fdiv c | true |
Lean.Elab.DefViewElabHeaderData.mk.noConfusion | Lean.Elab.DefView | {P : Sort u} →
{shortDeclName declName : Lean.Name} →
{levelNames : List Lean.Name} →
{binderIds : Array Lean.Syntax} →
{numParams : ℕ} →
{type : Lean.Expr} →
{shortDeclName' declName' : Lean.Name} →
{levelNames' : List Lean.Name} →
{binderIds' : Array Lean.Syntax} →
{numParams' : ℕ} →
{type' : Lean.Expr} →
{ shortDeclName := shortDeclName, declName := declName, levelNames := levelNames,
binderIds := binderIds, numParams := numParams, type := type } =
{ shortDeclName := shortDeclName', declName := declName', levelNames := levelNames',
binderIds := binderIds', numParams := numParams', type := type' } →
(shortDeclName = shortDeclName' →
declName = declName' →
levelNames = levelNames' →
binderIds = binderIds' → numParams = numParams' → type = type' → P) →
P | false |
_private.Mathlib.GroupTheory.Perm.Centralizer.0.Equiv.Perm.Basis.ofPermHom_support._simp_1_2 | Mathlib.GroupTheory.Perm.Centralizer | ∀ {α : Type u_1} {β : Type u_2} {s : Finset α} {t : α → Finset β} [inst : DecidableEq β] {b : β},
(b ∈ s.biUnion t) = ∃ a ∈ s, b ∈ t a | false |
SSet.Truncated.hoFunctor.monoidal._proof_18 | Mathlib.AlgebraicTopology.SimplicialSet.HoFunctorMonoidal | autoParam
(∀ (X : SSet),
(CategoryTheory.MonoidalCategoryStruct.rightUnitor (SSet.hoFunctor.obj X)).inv =
CategoryTheory.CategoryStruct.comp (SSet.hoFunctor.map (CategoryTheory.MonoidalCategoryStruct.rightUnitor X).inv)
(CategoryTheory.CategoryStruct.comp
(SSet.Truncated.hoFunctor.monoidal._aux_12 X (CategoryTheory.MonoidalCategoryStruct.tensorUnit SSet))
(CategoryTheory.MonoidalCategoryStruct.whiskerLeft (SSet.hoFunctor.obj X)
SSet.Truncated.hoFunctor.monoidal._aux_10)))
CategoryTheory.Functor.OplaxMonoidal.oplax_right_unitality._autoParam | false |
Nat.instNeZeroHPow | Init.Data.Nat.Basic | ∀ {n m : ℕ} [NeZero n], NeZero (n ^ m) | true |
IsSelfAdjoint.natCast._simp_1 | Mathlib.Algebra.Star.SelfAdjoint | ∀ {R : Type u_1} [inst : NonAssocSemiring R] [inst_1 : StarRing R] (n : ℕ), IsSelfAdjoint ↑n = True | false |
_private.Std.Data.DTreeMap.Internal.Operations.0.Std.DTreeMap.Internal.Impl.Const.balanced_modify._proof_1_2 | Std.Data.DTreeMap.Internal.Operations | ∀ {α : Type u_1} {β : Type u_2} [inst : Ord α] {k : α} {f : β → β} (sz : ℕ) (k_1 : α) (v : β)
(l r : Std.DTreeMap.Internal.Impl α fun x => β),
(Std.DTreeMap.Internal.Impl.inner sz k_1 v l r).Balanced →
(Std.DTreeMap.Internal.Impl.Const.modify k f l).Balanced →
(Std.DTreeMap.Internal.Impl.Const.modify k f r).Balanced →
(match compare k k_1 with
| Ordering.lt => Std.DTreeMap.Internal.Impl.inner sz k_1 v (Std.DTreeMap.Internal.Impl.Const.modify k f l) r
| Ordering.gt => Std.DTreeMap.Internal.Impl.inner sz k_1 v l (Std.DTreeMap.Internal.Impl.Const.modify k f r)
| Ordering.eq => Std.DTreeMap.Internal.Impl.inner sz k (f v) l r).Balanced | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.