tasksource/leandojo huggingface dataset:
Theorem: Ordinal.enumOrd_surjective
File: Mathlib/SetTheory/Ordinal/Arithmetic.lean

tactic: apply le_antisymm
state_before: S : Set Ordinal
hS : Unbounded (fun x x_1 => x < x_1) S
s : Ordinal
hs : s ∈ S
⊢ enumOrd S (sSup {a | enumOrd S a ≤ s}) = s

tactic: rw [enumOrd_def]
state_before: case a
S : Set Ordinal
hS : Unbounded (fun x x_1 => x < x_1) S
s : Ordinal
hs : s ∈ S
⊢ enumOrd S (sSup {a | enumOrd S a ≤ s}) ≤ s

tactic: refine' csInf_le' ⟨hs, fun a ha => _⟩
state_before: case a
S : Set Ordinal
hS : Unbounded (fun x x_1 => x < x_1) S
s : Ordinal
hs : s ∈ S
⊢ sInf (S ∩ {b | ∀ (c : Ordinal), c < sSup {a | enumOrd S a ≤ s} → enumOrd S c < b}) ≤ s

tactic: have : enumOrd S 0 ≤ s := by
  rw [enumOrd_zero]
  exact csInf_le' hs
state_before: case a
S : Set Ordinal
hS : Unbounded (fun x x_1 => x < x_1) S
s : Ordinal
hs : s ∈ S
a : Ordinal
ha : a < sSup {a | enumOrd S a ≤ s}
⊢ enumOrd S a < s

tactic: rcases flip exists_lt_of_lt_csSup ha ⟨0, this⟩ with ⟨b, hb, hab⟩
state_before: case a
S : Set Ordinal
hS : Unbounded (fun x x_1 => x < x_1) S
s : Ordinal
hs : s ∈ S
a : Ordinal
ha : a < sSup {a | enumOrd S a ≤ s}
this : enumOrd S 0 ≤ s
⊢ enumOrd S a < s

tactic: exact (enumOrd_strictMono hS hab).trans_le hb
state_before: case a.intro.intro
S : Set Ordinal
hS : Unbounded (fun x x_1 => x < x_1) S
s : Ordinal
hs : s ∈ S
a : Ordinal
ha : a < sSup {a | enumOrd S a ≤ s}
this : enumOrd S 0 ≤ s
b : Ordinal
hb : b ∈ {a | enumOrd S a ≤ s}
hab : a < b
⊢ enumOrd S a < s

tactic: rw [enumOrd_zero]
state_before: S : Set Ordinal
hS : Unbounded (fun x x_1 => x < x_1) S
s : Ordinal
hs : s ∈ S
a : Ordinal
ha : a < sSup {a | enumOrd S a ≤ s}
⊢ enumOrd S 0 ≤ s

tactic: exact csInf_le' hs
state_before: S : Set Ordinal
hS : Unbounded (fun x x_1 => x < x_1) S
s : Ordinal
hs : s ∈ S
a : Ordinal
ha : a < sSup {a | enumOrd S a ≤ s}
⊢ sInf S ≤ s

tactic: by_contra' h
state_before: case a
S : Set Ordinal
hS : Unbounded (fun x x_1 => x < x_1) S
s : Ordinal
hs : s ∈ S
⊢ s ≤ enumOrd S (sSup {a | enumOrd S a ≤ s})

tactic: exact
  (le_csSup ⟨s, fun a => (lt_wf.self_le_of_strictMono (enumOrd_strictMono hS) a).trans⟩
        (enumOrd_succ_le hS hs h)).not_lt
    (lt_succ _)
state_before: case a
S : Set Ordinal
hS : Unbounded (fun x x_1 => x < x_1) S
s : Ordinal
hs : s ∈ S
h : enumOrd S (sSup {a | enumOrd S a ≤ s}) < s
⊢ False
Theorem: MeasureTheory.OuterMeasure.trim_congr
File: Mathlib/MeasureTheory/Measure/OuterMeasure.lean

tactic: unfold trim
state_before: α : Type u_1
inst✝ : MeasurableSpace α
m m₁ m₂ : OuterMeasure α
H : ∀ {s : Set α}, MeasurableSet s → ↑m₁ s = ↑m₂ s
⊢ trim m₁ = trim m₂

tactic: congr
state_before: α : Type u_1
inst✝ : MeasurableSpace α
m m₁ m₂ : OuterMeasure α
H : ∀ {s : Set α}, MeasurableSet s → ↑m₁ s = ↑m₂ s
⊢ inducedOuterMeasure (fun s x => ↑m₁ s) (_ : MeasurableSet ∅) (_ : ↑m₁ ∅ = 0) =
    inducedOuterMeasure (fun s x => ↑m₂ s) (_ : MeasurableSet ∅) (_ : ↑m₂ ∅ = 0)

tactic: funext s hs
state_before: case e_m
α : Type u_1
inst✝ : MeasurableSpace α
m m₁ m₂ : OuterMeasure α
H : ∀ {s : Set α}, MeasurableSet s → ↑m₁ s = ↑m₂ s
⊢ (fun s x => ↑m₁ s) = fun s x => ↑m₂ s

tactic: exact H hs
state_before: case e_m.h.h
α : Type u_1
inst✝ : MeasurableSpace α
m m₁ m₂ : OuterMeasure α
H : ∀ {s : Set α}, MeasurableSet s → ↑m₁ s = ↑m₂ s
s : Set α
hs : MeasurableSet s
⊢ ↑m₁ s = ↑m₂ s
Theorem: Set.ncard_union_le
File: Mathlib/Data/Set/Ncard.lean

tactic: cases' (s ∪ t).finite_or_infinite with h h
state_before: α : Type u_1
β : Type ?u.120485
s✝ t✝ : Set α
a b x y : α
f : α → β
s t : Set α
⊢ ncard (s ∪ t) ≤ ncard s + ncard t

tactic: convert Nat.zero_le _
state_before: case inr
α : Type u_1
β : Type ?u.120485
s✝ t✝ : Set α
a b x y : α
f : α → β
s t : Set α
h : Set.Infinite (s ∪ t)
⊢ ncard (s ∪ t) ≤ ncard s + ncard t

tactic: rw [h.ncard]
state_before: case h.e'_3
α : Type u_1
β : Type ?u.120485
s✝ t✝ : Set α
a b x y : α
f : α → β
s t : Set α
h : Set.Infinite (s ∪ t)
⊢ ncard (s ∪ t) = 0

tactic: have hs := h.subset (subset_union_left s t)
state_before: case inl
α : Type u_1
β : Type ?u.120485
s✝ t✝ : Set α
a b x y : α
f : α → β
s t : Set α
h : Set.Finite (s ∪ t)
⊢ ncard (s ∪ t) ≤ ncard s + ncard t

tactic: have ht := h.subset (subset_union_right s t)
state_before: case inl
α : Type u_1
β : Type ?u.120485
s✝ t✝ : Set α
a b x y : α
f : α → β
s t : Set α
h : Set.Finite (s ∪ t)
hs : Set.Finite s
⊢ ncard (s ∪ t) ≤ ncard s + ncard t

tactic: rw [ncard_eq_toFinset_card _ hs, ncard_eq_toFinset_card _ ht, ncard_eq_toFinset_card _ h,
  Finite.toFinset_union]
state_before: case inl
α : Type u_1
β : Type ?u.120485
s✝ t✝ : Set α
a b x y : α
f : α → β
s t : Set α
h : Set.Finite (s ∪ t)
hs : Set.Finite s
ht : Set.Finite t
⊢ ncard (s ∪ t) ≤ ncard s + ncard t

tactic: exact Finset.card_union_le _ _
state_before: case inl
α : Type u_1
β : Type ?u.120485
s✝ t✝ : Set α
a b x y : α
f : α → β
s t : Set α
h : Set.Finite (s ∪ t)
hs : Set.Finite s
ht : Set.Finite t
⊢ Finset.card (Finite.toFinset ?inl.hs ∪ Finite.toFinset ?inl.ht) ≤
    Finset.card (Finite.toFinset hs) + Finset.card (Finite.toFinset ht)

case inl.hs
α : Type u_1
β : Type ?u.120485
s✝ t✝ : Set α
a b x y : α
f : α → β
s t : Set α
h : Set.Finite (s ∪ t)
hs : Set.Finite s
ht : Set.Finite t
⊢ Set.Finite s

case inl.ht
α : Type u_1
β : Type ?u.120485
s✝ t✝ : Set α
a b x y : α
f : α → β
s t : Set α
h : Set.Finite (s ∪ t)
hs : Set.Finite s
ht : Set.Finite t
⊢ Set.Finite t
Theorem: Sat.Fmla.reify_or
File: Mathlib/Tactic/Sat/FromLRAT.lean

tactic: refine ⟨fun H ↦ by_contra fun hn ↦ H ⟨fun c h ↦ by_contra fun hn' ↦ ?_⟩⟩
state_before: v : Valuation
f₁ : Fmla
a : Prop
f₂ : Fmla
b : Prop
h₁ : reify v f₁ a
h₂ : reify v f₂ b
⊢ reify v (and f₁ f₂) (a ∨ b)

tactic: rcases List.mem_append.1 h with h | h
state_before: v : Valuation
f₁ : Fmla
a : Prop
f₂ : Fmla
b : Prop
h₁ : reify v f₁ a
h₂ : reify v f₂ b
H : ¬Valuation.satisfies_fmla v (and f₁ f₂)
hn : ¬(a ∨ b)
c : Clause
h : c ∈ and f₁ f₂
hn' : ¬Valuation.satisfies v c
⊢ False

tactic: exact hn $ Or.inl $ h₁.1 fun Hc ↦ hn' $ Hc.1 _ h
state_before: case inl
v : Valuation
f₁ : Fmla
a : Prop
f₂ : Fmla
b : Prop
h₁ : reify v f₁ a
h₂ : reify v f₂ b
H : ¬Valuation.satisfies_fmla v (and f₁ f₂)
hn : ¬(a ∨ b)
c : Clause
h✝ : c ∈ and f₁ f₂
hn' : ¬Valuation.satisfies v c
h : c ∈ f₁
⊢ False

tactic: exact hn $ Or.inr $ h₂.1 fun Hc ↦ hn' $ Hc.1 _ h
state_before: case inr
v : Valuation
f₁ : Fmla
a : Prop
f₂ : Fmla
b : Prop
h₁ : reify v f₁ a
h₂ : reify v f₂ b
H : ¬Valuation.satisfies_fmla v (and f₁ f₂)
hn : ¬(a ∨ b)
c : Clause
h✝ : c ∈ and f₁ f₂
hn' : ¬Valuation.satisfies v c
h : c ∈ f₂
⊢ False
Theorem: BoxIntegral.Box.upper_sub_lower_splitCenterBox
File: Mathlib/Analysis/BoxIntegral/Box/SubboxInduction.lean

tactic: by_cases i ∈ s <;> field_simp [splitCenterBox] <;> field_simp [mul_two, two_mul]
state_before: ι : Type u_1
I✝ J I : Box ι
s : Set ι
i : ι
⊢ upper (splitCenterBox I s) i - lower (splitCenterBox I s) i = (upper I i - lower I i) / 2
Theorem: Complex.coe_orthonormalBasisOneI
File: Mathlib/Analysis/InnerProductSpace/PiL2.lean

tactic: simp [Complex.orthonormalBasisOneI]
state_before: ι : Type ?u.1331907
ι' : Type ?u.1331910
𝕜 : Type ?u.1331913
inst✝⁹ : IsROrC 𝕜
E : Type ?u.1331919
inst✝⁸ : NormedAddCommGroup E
inst✝⁷ : InnerProductSpace 𝕜 E
E' : Type ?u.1331939
inst✝⁶ : NormedAddCommGroup E'
inst✝⁵ : InnerProductSpace 𝕜 E'
F : Type ?u.1331957
inst✝⁴ : NormedAddCommGroup F
inst✝³ : InnerProductSpace ℝ F
F' : Type ?u.1331977
inst✝² : NormedAddCommGroup F'
inst✝¹ : InnerProductSpace ℝ F'
inst✝ : Fintype ι
⊢ ↑orthonormalBasisOneI = ![1, I]
Theorem: TopCat.Presheaf.stalkPushforward_germ
File: Mathlib/Topology/Sheaves/Stalks.lean

tactic: rw [stalkPushforward, germ, colimit.ι_map_assoc, colimit.ι_pre, whiskerRight_app]
state_before: C : Type u
inst✝¹ : Category C
inst✝ : HasColimits C
X Y Z : TopCat
f : X ⟶ Y
F : Presheaf C X
U : Opens ↑Y
x : { x // x ∈ (Opens.map f).obj U }
⊢ germ (f _* F) { val := (forget TopCat).map f ↑x, property := (_ : ↑x ∈ (Opens.map f).obj U) } ≫
      stalkPushforward C f F ↑x =
    germ F x

tactic: erw [CategoryTheory.Functor.map_id, Category.id_comp]
state_before: C : Type u
inst✝¹ : Category C
inst✝ : HasColimits C
X Y Z : TopCat
f : X ⟶ Y
F : Presheaf C X
U : Opens ↑Y
x : { x // x ∈ (Opens.map f).obj U }
⊢ F.map
        ((NatTrans.op (OpenNhds.inclusionMapIso f ↑x).inv).app
          { obj := U,
              property :=
                (_ : ↑{ val := (forget TopCat).map f ↑x, property := (_ : ↑x ∈ (Opens.map f).obj U) } ∈ U) }.op) ≫
      colimit.ι (((whiskeringLeft (OpenNhds ↑x)ᵒᵖ (Opens ↑X)ᵒᵖ C).obj (Functor.op (OpenNhds.inclusion ↑x))).obj F)
        ((Functor.op (OpenNhds.map f ↑x)).obj
          { obj := U,
              property :=
                (_ : ↑{ val := (forget TopCat).map f ↑x, property := (_ : ↑x ∈ (Opens.map f).obj U) } ∈ U) }.op) =
    germ F x

tactic: rfl
state_before: C : Type u
inst✝¹ : Category C
inst✝ : HasColimits C
X Y Z : TopCat
f : X ⟶ Y
F : Presheaf C X
U : Opens ↑Y
x : { x // x ∈ (Opens.map f).obj U }
⊢ colimit.ι (((whiskeringLeft (OpenNhds ↑x)ᵒᵖ (Opens ↑X)ᵒᵖ C).obj (Functor.op (OpenNhds.inclusion ↑x))).obj F)
      ((Functor.op (OpenNhds.map f ↑x)).obj
        { obj := U,
            property :=
              (_ : ↑{ val := (forget TopCat).map f ↑x, property := (_ : ↑x ∈ (Opens.map f).obj U) } ∈ U) }.op) =
    germ F x
Theorem: Vector.not_mem_nil
File: Mathlib/Data/Vector/Mem.lean

tactic: unfold Vector.nil
state_before: α : Type u_1
β : Type ?u.1320
n : ℕ
a a' : α
⊢ ¬a ∈ toList nil

tactic: dsimp
state_before: α : Type u_1
β : Type ?u.1320
n : ℕ
a a' : α
⊢ ¬a ∈ toList { val := [], property := (_ : List.length [] = List.length []) }

tactic: simp
state_before: α : Type u_1
β : Type ?u.1320
n : ℕ
a a' : α
⊢ ¬a ∈ []
Theorem: FiniteDimensional.finrank_eq_rank
File: Mathlib/LinearAlgebra/FreeModule/Finite/Rank.lean

tactic: rw [finrank, cast_toNat_of_lt_aleph0 (rank_lt_aleph0 R M)]
state_before: R : Type u
M : Type v
N : Type w
inst✝⁷ : Ring R
inst✝⁶ : StrongRankCondition R
inst✝⁵ : AddCommGroup M
inst✝⁴ : Module R M
inst✝³ : Module.Finite R M
inst✝² : AddCommGroup N
inst✝¹ : Module R N
inst✝ : Module.Finite R N
⊢ ↑(finrank R M) = Module.rank R M
Theorem: Matrix.det_diagonal
File: Mathlib/LinearAlgebra/Matrix/Determinant.lean

tactic: rw [det_apply']
state_before: m : Type ?u.110979
n : Type u_1
inst✝⁴ : DecidableEq n
inst✝³ : Fintype n
inst✝² : DecidableEq m
inst✝¹ : Fintype m
R : Type v
inst✝ : CommRing R
d : n → R
⊢ det (diagonal d) = ∏ i : n, d i

tactic: refine' (Finset.sum_eq_single 1 _ _).trans _
state_before: m : Type ?u.110979
n : Type u_1
inst✝⁴ : DecidableEq n
inst✝³ : Fintype n
inst✝² : DecidableEq m
inst✝¹ : Fintype m
R : Type v
inst✝ : CommRing R
d : n → R
⊢ ∑ σ : Perm n, ↑↑(↑sign σ) * ∏ i : n, diagonal d (↑σ i) i = ∏ i : n, d i

tactic: rintro σ - h2
state_before: case refine'_1
m : Type ?u.110979
n : Type u_1
inst✝⁴ : DecidableEq n
inst✝³ : Fintype n
inst✝² : DecidableEq m
inst✝¹ : Fintype m
R : Type v
inst✝ : CommRing R
d : n → R
⊢ ∀ (b : Perm n), b ∈ univ → b ≠ 1 → ↑↑(↑sign b) * ∏ i : n, diagonal d (↑b i) i = 0

tactic: cases' not_forall.1 (mt Equiv.ext h2) with x h3
state_before: case refine'_1
m : Type ?u.110979
n : Type u_1
inst✝⁴ : DecidableEq n
inst✝³ : Fintype n
inst✝² : DecidableEq m
inst✝¹ : Fintype m
R : Type v
inst✝ : CommRing R
d : n → R
σ : Perm n
h2 : σ ≠ 1
⊢ ↑↑(↑sign σ) * ∏ i : n, diagonal d (↑σ i) i = 0

tactic: convert MulZeroClass.mul_zero (ε σ)
state_before: case refine'_1.intro
m : Type ?u.110979
n : Type u_1
inst✝⁴ : DecidableEq n
inst✝³ : Fintype n
inst✝² : DecidableEq m
inst✝¹ : Fintype m
R : Type v
inst✝ : CommRing R
d : n → R
σ : Perm n
h2 : σ ≠ 1
x : n
h3 : ¬↑σ x = ↑1 x
⊢ ↑↑(↑sign σ) * ∏ i : n, diagonal d (↑σ i) i = 0

tactic: apply Finset.prod_eq_zero (mem_univ x)
state_before: case h.e'_2.h.e'_6
m : Type ?u.110979
n : Type u_1
inst✝⁴ : DecidableEq n
inst✝³ : Fintype n
inst✝² : DecidableEq m
inst✝¹ : Fintype m
R : Type v
inst✝ : CommRing R
d : n → R
σ : Perm n
h2 : σ ≠ 1
x : n
h3 : ¬↑σ x = ↑1 x
⊢ ∏ i : n, diagonal d (↑σ i) i = 0

tactic: exact if_neg h3
state_before: case h.e'_2.h.e'_6
m : Type ?u.110979
n : Type u_1
inst✝⁴ : DecidableEq n
inst✝³ : Fintype n
inst✝² : DecidableEq m
inst✝¹ : Fintype m
R : Type v
inst✝ : CommRing R
d : n → R
σ : Perm n
h2 : σ ≠ 1
x : n
h3 : ¬↑σ x = ↑1 x
⊢ diagonal d (↑σ x) x = 0

tactic: simp
state_before: case refine'_2
m : Type ?u.110979
n : Type u_1
inst✝⁴ : DecidableEq n
inst✝³ : Fintype n
inst✝² : DecidableEq m
inst✝¹ : Fintype m
R : Type v
inst✝ : CommRing R
d : n → R
⊢ ¬1 ∈ univ → ↑↑(↑sign 1) * ∏ i : n, diagonal d (↑1 i) i = 0

tactic: simp
state_before: case refine'_3
m : Type ?u.110979
n : Type u_1
inst✝⁴ : DecidableEq n
inst✝³ : Fintype n
inst✝² : DecidableEq m
inst✝¹ : Fintype m
R : Type v
inst✝ : CommRing R
d : n → R
⊢ ↑↑(↑sign 1) * ∏ i : n, diagonal d (↑1 i) i = ∏ i : n, d i
Theorem: MvPolynomial.homogeneousComponent_eq_zero
File: Mathlib/RingTheory/MvPolynomial/Homogeneous.lean

tactic: apply homogeneousComponent_eq_zero'
state_before: σ : Type u_2
τ : Type ?u.358984
R : Type u_1
S : Type ?u.358990
inst✝ : CommSemiring R
n : ℕ
φ ψ : MvPolynomial σ R
h : totalDegree φ < n
⊢ ↑(homogeneousComponent n) φ = 0

tactic: rw [totalDegree, Finset.sup_lt_iff] at h
state_before: case h
σ : Type u_2
τ : Type ?u.358984
R : Type u_1
S : Type ?u.358990
inst✝ : CommSemiring R
n : ℕ
φ ψ : MvPolynomial σ R
h : totalDegree φ < n
⊢ ∀ (d : σ →₀ ℕ), d ∈ support φ → ∑ i in d.support, ↑d i ≠ n

tactic: intro d hd
state_before: case h
σ : Type u_2
τ : Type ?u.358984
R : Type u_1
S : Type ?u.358990
inst✝ : CommSemiring R
n : ℕ
φ ψ : MvPolynomial σ R
h : ∀ (b : σ →₀ ℕ), b ∈ support φ → (Finsupp.sum b fun x e => e) < n
⊢ ∀ (d : σ →₀ ℕ), d ∈ support φ → ∑ i in d.support, ↑d i ≠ n

tactic: exact ne_of_lt (h d hd)
state_before: case h
σ : Type u_2
τ : Type ?u.358984
R : Type u_1
S : Type ?u.358990
inst✝ : CommSemiring R
n : ℕ
φ ψ : MvPolynomial σ R
h : ∀ (b : σ →₀ ℕ), b ∈ support φ → (Finsupp.sum b fun x e => e) < n
d : σ →₀ ℕ
hd : d ∈ support φ
⊢ ∑ i in d.support, ↑d i ≠ n

tactic: exact lt_of_le_of_lt (Nat.zero_le _) h
state_before: case h
σ : Type u_2
τ : Type ?u.358984
R : Type u_1
S : Type ?u.358990
inst✝ : CommSemiring R
n : ℕ
φ ψ : MvPolynomial σ R
h : (sup (support φ) fun s => Finsupp.sum s fun x e => e) < n
⊢ ⊥ < n
Theorem: IsUnit.inv_mul_cancel
File: Mathlib/Algebra/Group/Units.lean

tactic: rintro ⟨u, rfl⟩
state_before: α : Type u
M : Type u_1
N : Type ?u.68377
inst✝ : DivisionMonoid M
a : M
⊢ IsUnit a → a⁻¹ * a = 1

tactic: rw [← Units.val_inv_eq_inv_val, Units.inv_mul]
state_before: case intro
α : Type u
M : Type u_1
N : Type ?u.68377
inst✝ : DivisionMonoid M
u : Mˣ
⊢ (↑u)⁻¹ * ↑u = 1
Theorem: LatticeOrderedCommGroup.mul_inf_eq_mul_inf_mul
File: Mathlib/Algebra/Order/LatticeGroup.lean

tactic: refine' le_antisymm _ _
state_before: α : Type u
inst✝² : Lattice α
inst✝¹ : CommGroup α
inst✝ : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
a b c : α
⊢ c * (a ⊓ b) = c * a ⊓ c * b

tactic: rw [le_inf_iff, mul_le_mul_iff_left, mul_le_mul_iff_left]
state_before: case refine'_1
α : Type u
inst✝² : Lattice α
inst✝¹ : CommGroup α
inst✝ : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
a b c : α
⊢ c * (a ⊓ b) ≤ c * a ⊓ c * b

case refine'_2
α : Type u
inst✝² : Lattice α
inst✝¹ : CommGroup α
inst✝ : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
a b c : α
⊢ c * a ⊓ c * b ≤ c * (a ⊓ b)

tactic: simp
state_before: case refine'_1
α : Type u
inst✝² : Lattice α
inst✝¹ : CommGroup α
inst✝ : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
a b c : α
⊢ a ⊓ b ≤ a ∧ a ⊓ b ≤ b

case refine'_2
α : Type u
inst✝² : Lattice α
inst✝¹ : CommGroup α
inst✝ : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
a b c : α
⊢ c * a ⊓ c * b ≤ c * (a ⊓ b)

tactic: rw [← mul_le_mul_iff_left c⁻¹, ← mul_assoc, inv_mul_self, one_mul, le_inf_iff,
  inv_mul_le_iff_le_mul, inv_mul_le_iff_le_mul]
state_before: case refine'_2
α : Type u
inst✝² : Lattice α
inst✝¹ : CommGroup α
inst✝ : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
a b c : α
⊢ c * a ⊓ c * b ≤ c * (a ⊓ b)

tactic: simp
state_before: case refine'_2
α : Type u
inst✝² : Lattice α
inst✝¹ : CommGroup α
inst✝ : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
a b c : α
⊢ c * a ⊓ c * b ≤ c * a ∧ c * a ⊓ c * b ≤ c * b
Theorem: IsIntegralClosure.mk'_add
File: Mathlib/RingTheory/IntegralClosure.lean

tactic: simp only [algebraMap_mk', RingHom.map_add]
state_before: R : Type u_1
A : Type u_3
B : Type u_2
inst✝⁵ : CommRing R
inst✝⁴ : CommRing A
inst✝³ : CommRing B
inst✝² : Algebra R B
inst✝¹ : Algebra A B
inst✝ : IsIntegralClosure A R B
x y : B
hx : IsIntegral R x
hy : IsIntegral R y
⊢ ↑(algebraMap A B) (mk' A (x + y) (_ : IsIntegral R (x + y))) = ↑(algebraMap A B) (mk' A x hx + mk' A y hy)
Theorem: List.length_permutationsAux
File: Mathlib/Data/List/Perm.lean

tactic: refine' permutationsAux.rec (by simp) _
state_before: α : Type uu
β : Type vv
l₁ l₂ : List α
⊢ ∀ (ts is : List α), length (permutationsAux ts is) + (length is)! = (length ts + length is)!

tactic: intro t ts is IH1 IH2
state_before: α : Type uu
β : Type vv
l₁ l₂ : List α
⊢ ∀ (t : α) (ts is : List α),
    length (permutationsAux ts (t :: is)) + (length (t :: is))! = (length ts + length (t :: is))! →
      length (permutationsAux is []) + (length [])! = (length is + length [])! →
        length (permutationsAux (t :: ts) is) + (length is)! = (length (t :: ts) + length is)!

tactic: have IH2 : length (permutationsAux is nil) + 1 = is.length ! := by simpa using IH2
state_before: α : Type uu
β : Type vv
l₁ l₂ : List α
t : α
ts is : List α
IH1 : length (permutationsAux ts (t :: is)) + (length (t :: is))! = (length ts + length (t :: is))!
IH2 : length (permutationsAux is []) + (length [])! = (length is + length [])!
⊢ length (permutationsAux (t :: ts) is) + (length is)! = (length (t :: ts) + length is)!

tactic: simp [Nat.factorial, Nat.add_succ, mul_comm] at IH1
state_before: α : Type uu
β : Type vv
l₁ l₂ : List α
t : α
ts is : List α
IH1 : length (permutationsAux ts (t :: is)) + (length (t :: is))! = (length ts + length (t :: is))!
IH2✝ : length (permutationsAux is []) + (length [])! = (length is + length [])!
IH2 : length (permutationsAux is []) + 1 = (length is)!
⊢ length (permutationsAux (t :: ts) is) + (length is)! = (length (t :: ts) + length is)!

tactic: rw [permutationsAux_cons,
  length_foldr_permutationsAux2' _ _ _ _ _ fun l m => (perm_of_mem_permutations m).length_eq,
  permutations, length, length, IH2, Nat.succ_add, Nat.factorial_succ, mul_comm (_ + 1),
  ← Nat.succ_eq_add_one, ← IH1, add_comm (_ * _), add_assoc, Nat.mul_succ, mul_comm]
state_before: α : Type uu
β : Type vv
l₁ l₂ : List α
t : α
ts is : List α
IH2✝ : length (permutationsAux is []) + (length [])! = (length is + length [])!
IH2 : length (permutationsAux is []) + 1 = (length is)!
IH1 :
  length (permutationsAux ts (t :: is)) + (length is)! * succ (length is) =
    (length ts + length is)! * succ (length ts + length is)
⊢ length (permutationsAux (t :: ts) is) + (length is)! = (length (t :: ts) + length is)!

tactic: simp
state_before: α : Type uu
β : Type vv
l₁ l₂ : List α
⊢ ∀ (is : List α), length (permutationsAux [] is) + (length is)! = (length [] + length is)!

tactic: simpa using IH2
state_before: α : Type uu
β : Type vv
l₁ l₂ : List α
t : α
ts is : List α
IH1 : length (permutationsAux ts (t :: is)) + (length (t :: is))! = (length ts + length (t :: is))!
IH2 : length (permutationsAux is []) + (length [])! = (length is + length [])!
⊢ length (permutationsAux is []) + 1 = (length is)!
Theorem: UniformFun.inf_eq
File: Mathlib/Topology/UniformSpace/UniformConvergenceTopology.lean

tactic: rw [inf_eq_iInf, inf_eq_iInf, UniformFun.iInf_eq]
state_before: α : Type u_2
β : Type ?u.38020
γ : Type u_1
ι : Type ?u.38026
s s' : Set α
x : α
p : Filter ι
g : ι → α
inst✝ : UniformSpace β
u₁ u₂ : UniformSpace γ
⊢ uniformSpace α γ = uniformSpace α γ ⊓ uniformSpace α γ

tactic: refine' iInf_congr fun i => _
state_before: α : Type u_2
β : Type ?u.38020
γ : Type u_1
ι : Type ?u.38026
s s' : Set α
x : α
p : Filter ι
g : ι → α
inst✝ : UniformSpace β
u₁ u₂ : UniformSpace γ
⊢ (⨅ (i : Bool), uniformSpace α γ) = ⨅ (b : Bool), bif b then uniformSpace α γ else uniformSpace α γ

tactic: cases i <;> rfl
state_before: α : Type u_2
β : Type ?u.38020
γ : Type u_1
ι : Type ?u.38026
s s' : Set α
x : α
p : Filter ι
g : ι → α
inst✝ : UniformSpace β
u₁ u₂ : UniformSpace γ
i : Bool
⊢ uniformSpace α γ = bif i then uniformSpace α γ else uniformSpace α γ
Theorem: Set.univ_pow
File: Mathlib/Data/Set/Pointwise/Basic.lean

tactic: rw [pow_succ, univ_pow n.succ_ne_zero, univ_mul_univ]
state_before: F : Type ?u.75558
α : Type u_1
β : Type ?u.75564
γ : Type ?u.75567
inst✝ : Monoid α
s t : Set α
a : α
m n✝ n : ℕ
x✝ : n + 2 ≠ 0
⊢ univ ^ (n + 2) = univ
Theorem: MeasureTheory.SignedMeasure.restrictNonposSeq_succ
File: Mathlib/MeasureTheory/Decomposition/SignedHahn.lean

tactic: rw [restrictNonposSeq]
state_before: α : Type u_1
β : Type ?u.18814
inst✝³ : MeasurableSpace α
M : Type ?u.18820
inst✝² : AddCommMonoid M
inst✝¹ : TopologicalSpace M
inst✝ : OrderedAddCommMonoid M
s : SignedMeasure α
i j : Set α
n : ℕ
⊢ MeasureTheory.SignedMeasure.restrictNonposSeq s i (Nat.succ n) =
    MeasureTheory.SignedMeasure.someExistsOneDivLT s
      (i \ ⋃ (k : ℕ) (_ : k ≤ n), MeasureTheory.SignedMeasure.restrictNonposSeq s i k)
Theorem: MeasureTheory.Measure.singularPart_smul
File: Mathlib/MeasureTheory/Decomposition/Lebesgue.lean

tactic: by_cases hr : r = 0
state_before: α : Type u_1
β : Type ?u.44567
m : MeasurableSpace α
μ✝ ν✝ μ ν : Measure α
r : ℝ≥0
⊢ singularPart (r • μ) ν = r • singularPart μ ν

tactic: by_cases hl : HaveLebesgueDecomposition μ ν
state_before: case neg
α : Type u_1
β : Type ?u.44567
m : MeasurableSpace α
μ✝ ν✝ μ ν : Measure α
r : ℝ≥0
hr : ¬r = 0
⊢ singularPart (r • μ) ν = r • singularPart μ ν

tactic: rw [hr, zero_smul, zero_smul, singularPart_zero]
state_before: case pos
α : Type u_1
β : Type ?u.44567
m : MeasurableSpace α
μ✝ ν✝ μ ν : Measure α
r : ℝ≥0
hr : r = 0
⊢ singularPart (r • μ) ν = r • singularPart μ ν

tactic: haveI := hl
state_before: case pos
α : Type u_1
β : Type ?u.44567
m : MeasurableSpace α
μ✝ ν✝ μ ν : Measure α
r : ℝ≥0
hr : ¬r = 0
hl : HaveLebesgueDecomposition μ ν
⊢ singularPart (r • μ) ν = r • singularPart μ ν

tactic: refine'
  (eq_singularPart ((measurable_rnDeriv μ ν).const_smul (r : ℝ≥0∞))
      (MutuallySingular.smul r (haveLebesgueDecomposition_spec _ _).2.1) _).symm
state_before: case pos
α : Type u_1
β : Type ?u.44567
m : MeasurableSpace α
μ✝ ν✝ μ ν : Measure α
r : ℝ≥0
hr : ¬r = 0
hl this : HaveLebesgueDecomposition μ ν
⊢ singularPart (r • μ) ν = r • singularPart μ ν

tactic: rw [withDensity_smul _ (measurable_rnDeriv _ _), ← smul_add,
  ← haveLebesgueDecomposition_add μ ν, ENNReal.smul_def]
state_before: case pos
α : Type u_1
β : Type ?u.44567
m : MeasurableSpace α
μ✝ ν✝ μ ν : Measure α
r : ℝ≥0
hr : ¬r = 0
hl this : HaveLebesgueDecomposition μ ν
⊢ r • μ = ↑r • singularPart μ ν + withDensity ν (↑r • rnDeriv μ ν)

tactic: rw [singularPart, singularPart, dif_neg hl, dif_neg, smul_zero]
state_before: case neg
α : Type u_1
β : Type ?u.44567
m : MeasurableSpace α
μ✝ ν✝ μ ν : Measure α
r : ℝ≥0
hr : ¬r = 0
hl : ¬HaveLebesgueDecomposition μ ν
⊢ singularPart (r • μ) ν = r • singularPart μ ν

tactic: refine' fun hl' => hl _
state_before: case neg.hnc
α : Type u_1
β : Type ?u.44567
m : MeasurableSpace α
μ✝ ν✝ μ ν : Measure α
r : ℝ≥0
hr : ¬r = 0
hl : ¬HaveLebesgueDecomposition μ ν
⊢ ¬HaveLebesgueDecomposition (r • μ) ν

tactic: rw [← inv_smul_smul₀ hr μ]
state_before: case neg.hnc
α : Type u_1
β : Type ?u.44567
m : MeasurableSpace α
μ✝ ν✝ μ ν : Measure α
r : ℝ≥0
hr : ¬r = 0
hl : ¬HaveLebesgueDecomposition μ ν
hl' : HaveLebesgueDecomposition (r • μ) ν
⊢ HaveLebesgueDecomposition μ ν

tactic: exact @Measure.haveLebesgueDecomposition_smul _ _ _ _ hl' _
state_before: case neg.hnc
α : Type u_1
β : Type ?u.44567
m : MeasurableSpace α
μ✝ ν✝ μ ν : Measure α
r : ℝ≥0
hr : ¬r = 0
hl : ¬HaveLebesgueDecomposition μ ν
hl' : HaveLebesgueDecomposition (r • μ) ν
⊢ HaveLebesgueDecomposition (r⁻¹ • r • μ) ν