tasksource/leandojo huggingface dataset:
Theorem: Finset.gcd_mul_right
File: Mathlib/Algebra/GCDMonoid/Finset.lean

tactic: refine' s.induction_on _ _
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.37723
inst✝¹ : CancelCommMonoidWithZero α
inst✝ : NormalizedGCDMonoid α
s s₁ s₂ : Finset β
f : β → α
a : α
⊢ (gcd s fun x => f x * a) = gcd s f * ↑normalize a

tactic: simp
state_before: case refine'_1
α : Type u_1
β : Type u_2
γ : Type ?u.37723
inst✝¹ : CancelCommMonoidWithZero α
inst✝ : NormalizedGCDMonoid α
s s₁ s₂ : Finset β
f : β → α
a : α
⊢ (gcd ∅ fun x => f x * a) = gcd ∅ f * ↑normalize a

tactic: intro b t _ h
state_before: case refine'_2
α : Type u_1
β : Type u_2
γ : Type ?u.37723
inst✝¹ : CancelCommMonoidWithZero α
inst✝ : NormalizedGCDMonoid α
s s₁ s₂ : Finset β
f : β → α
a : α
⊢ ∀ ⦃a_1 : β⦄ {s : Finset β},
    ¬a_1 ∈ s →
      (gcd s fun x => f x * a) = gcd s f * ↑normalize a →
        (gcd (insert a_1 s) fun x => f x * a) = gcd (insert a_1 s) f * ↑normalize a

tactic: rw [gcd_insert, gcd_insert, h, ← gcd_mul_right]
state_before: case refine'_2
α : Type u_1
β : Type u_2
γ : Type ?u.37723
inst✝¹ : CancelCommMonoidWithZero α
inst✝ : NormalizedGCDMonoid α
s s₁ s₂ : Finset β
f : β → α
a : α
b : β
t : Finset β
a✝ : ¬b ∈ t
h : (gcd t fun x => f x * a) = gcd t f * ↑normalize a
⊢ (gcd (insert b t) fun x => f x * a) = gcd (insert b t) f * ↑normalize a

tactic: apply ((normalize_associated a).mul_left _).gcd_eq_right
state_before: case refine'_2
α : Type u_1
β : Type u_2
γ : Type ?u.37723
inst✝¹ : CancelCommMonoidWithZero α
inst✝ : NormalizedGCDMonoid α
s s₁ s₂ : Finset β
f : β → α
a : α
b : β
t : Finset β
a✝ : ¬b ∈ t
h : (gcd t fun x => f x * a) = gcd t f * ↑normalize a
⊢ GCDMonoid.gcd (f b * a) (gcd t f * ↑normalize a) = GCDMonoid.gcd (f b * a) (gcd t f * a)
Theorem: AddMonoidAlgebra.support_gen_of_gen
File: Mathlib/RingTheory/FiniteType.lean

tactic: refine' le_antisymm le_top _
state_before: R : Type u_2
M : Type u_1
inst✝¹ : CommSemiring R
inst✝ : AddMonoid M
S : Set (AddMonoidAlgebra R M)
hS : adjoin R S = ⊤
⊢ adjoin R (⋃ (f : AddMonoidAlgebra R M) (_ : f ∈ S), of' R M '' ↑f.support) = ⊤

tactic: rw [← hS, adjoin_le_iff]
state_before: R : Type u_2
M : Type u_1
inst✝¹ : CommSemiring R
inst✝ : AddMonoid M
S : Set (AddMonoidAlgebra R M)
hS : adjoin R S = ⊤
⊢ ⊤ ≤ adjoin R (⋃ (f : AddMonoidAlgebra R M) (_ : f ∈ S), of' R M '' ↑f.support)

tactic: intro f hf
state_before: R : Type u_2
M : Type u_1
inst✝¹ : CommSemiring R
inst✝ : AddMonoid M
S : Set (AddMonoidAlgebra R M)
hS : adjoin R S = ⊤
⊢ S ⊆ ↑(adjoin R (⋃ (f : AddMonoidAlgebra R M) (_ : f ∈ S), of' R M '' ↑f.support))

tactic: have hincl :
  of' R M '' f.support ⊆ ⋃ (g : AddMonoidAlgebra R M) (_ : g ∈ S), of' R M '' g.support := by
  intro s hs
  exact Set.mem_iUnion₂.2 ⟨f, ⟨hf, hs⟩⟩
state_before: R : Type u_2
M : Type u_1
inst✝¹ : CommSemiring R
inst✝ : AddMonoid M
S : Set (AddMonoidAlgebra R M)
hS : adjoin R S = ⊤
f : AddMonoidAlgebra R M
hf : f ∈ S
⊢ f ∈ ↑(adjoin R (⋃ (f : AddMonoidAlgebra R M) (_ : f ∈ S), of' R M '' ↑f.support))

tactic: exact adjoin_mono hincl (mem_adjoin_support f)
state_before: R : Type u_2
M : Type u_1
inst✝¹ : CommSemiring R
inst✝ : AddMonoid M
S : Set (AddMonoidAlgebra R M)
hS : adjoin R S = ⊤
f : AddMonoidAlgebra R M
hf : f ∈ S
hincl : of' R M '' ↑f.support ⊆ ⋃ (g : AddMonoidAlgebra R M) (_ : g ∈ S), of' R M '' ↑g.support
⊢ f ∈ ↑(adjoin R (⋃ (f : AddMonoidAlgebra R M) (_ : f ∈ S), of' R M '' ↑f.support))

tactic: intro s hs
state_before: R : Type u_2
M : Type u_1
inst✝¹ : CommSemiring R
inst✝ : AddMonoid M
S : Set (AddMonoidAlgebra R M)
hS : adjoin R S = ⊤
f : AddMonoidAlgebra R M
hf : f ∈ S
⊢ of' R M '' ↑f.support ⊆ ⋃ (g : AddMonoidAlgebra R M) (_ : g ∈ S), of' R M '' ↑g.support

tactic: exact Set.mem_iUnion₂.2 ⟨f, ⟨hf, hs⟩⟩
state_before: R : Type u_2
M : Type u_1
inst✝¹ : CommSemiring R
inst✝ : AddMonoid M
S : Set (AddMonoidAlgebra R M)
hS : adjoin R S = ⊤
f : AddMonoidAlgebra R M
hf : f ∈ S
s : AddMonoidAlgebra R M
hs : s ∈ of' R M '' ↑f.support
⊢ s ∈ ⋃ (g : AddMonoidAlgebra R M) (_ : g ∈ S), of' R M '' ↑g.support
Theorem: Real.Angle.eq_iff_sign_eq_and_abs_toReal_eq
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Angle.lean

tactic: refine' ⟨_, fun h => _⟩
state_before: θ ψ : Angle
⊢ θ = ψ ↔ sign θ = sign ψ ∧ abs (toReal θ) = abs (toReal ψ)

tactic: rcases h with ⟨hs, hr⟩
state_before: case refine'_2
θ ψ : Angle
h : sign θ = sign ψ ∧ abs (toReal θ) = abs (toReal ψ)
⊢ θ = ψ

tactic: rw [abs_eq_abs] at hr
state_before: case refine'_2.intro
θ ψ : Angle
hs : sign θ = sign ψ
hr : abs (toReal θ) = abs (toReal ψ)
⊢ θ = ψ

tactic: rcases hr with (hr | hr)
state_before: case refine'_2.intro
θ ψ : Angle
hs : sign θ = sign ψ
hr : toReal θ = toReal ψ ∨ toReal θ = -toReal ψ
⊢ θ = ψ

tactic: rintro rfl
state_before: case refine'_1
θ ψ : Angle
⊢ θ = ψ → sign θ = sign ψ ∧ abs (toReal θ) = abs (toReal ψ)

tactic: exact ⟨rfl, rfl⟩
state_before: case refine'_1
θ : Angle
⊢ sign θ = sign θ ∧ abs (toReal θ) = abs (toReal θ)

tactic: exact toReal_injective hr
state_before: case refine'_2.intro.inl
θ ψ : Angle
hs : sign θ = sign ψ
hr : toReal θ = toReal ψ
⊢ θ = ψ

tactic: by_cases h : θ = π
state_before: case refine'_2.intro.inr
θ ψ : Angle
hs : sign θ = sign ψ
hr : toReal θ = -toReal ψ
⊢ θ = ψ

tactic: rw [h, toReal_pi, ← neg_eq_iff_eq_neg] at hr
state_before: case pos
θ ψ : Angle
hs : sign θ = sign ψ
hr : toReal θ = -toReal ψ
h : θ = ↑π
⊢ θ = ψ

tactic: exact False.elim ((neg_pi_lt_toReal ψ).ne hr)
state_before: case pos
θ ψ : Angle
hs : sign θ = sign ψ
hr : -π = toReal ψ
h : θ = ↑π
⊢ θ = ψ

tactic: by_cases h' : ψ = π
state_before: case neg
θ ψ : Angle
hs : sign θ = sign ψ
hr : toReal θ = -toReal ψ
h : ¬θ = ↑π
⊢ θ = ψ

tactic: rw [h', toReal_pi] at hr
state_before: case pos
θ ψ : Angle
hs : sign θ = sign ψ
hr : toReal θ = -toReal ψ
h : ¬θ = ↑π
h' : ψ = ↑π
⊢ θ = ψ

tactic: exact False.elim ((neg_pi_lt_toReal θ).ne hr.symm)
state_before: case pos
θ ψ : Angle
hs : sign θ = sign ψ
hr : toReal θ = -π
h : ¬θ = ↑π
h' : ψ = ↑π
⊢ θ = ψ

tactic: rw [← sign_toReal h, ← sign_toReal h', hr, Left.sign_neg, SignType.neg_eq_self_iff,
  _root_.sign_eq_zero_iff, toReal_eq_zero_iff] at hs
state_before: case neg
θ ψ : Angle
hs : sign θ = sign ψ
hr : toReal θ = -toReal ψ
h : ¬θ = ↑π
h' : ¬ψ = ↑π
⊢ θ = ψ

tactic: rw [hs, toReal_zero, neg_zero, toReal_eq_zero_iff] at hr
state_before: case neg
θ ψ : Angle
hs : ψ = 0
hr : toReal θ = -toReal ψ
h : ¬θ = ↑π
h' : ¬ψ = ↑π
⊢ θ = ψ

tactic: rw [hr, hs]
state_before: case neg
θ ψ : Angle
hs : ψ = 0
hr : θ = 0
h : ¬θ = ↑π
h' : ¬ψ = ↑π
⊢ θ = ψ
Theorem: MeasureTheory.VectorMeasure.AbsolutelyContinuous.mk
File: Mathlib/MeasureTheory/Measure/VectorMeasure.lean

tactic: intro s hs
state_before: α : Type u_1
β : Type ?u.622187
m : MeasurableSpace α
L : Type ?u.622193
M : Type u_3
N : Type u_2
inst✝⁵ : AddCommMonoid L
inst✝⁴ : TopologicalSpace L
inst✝³ : AddCommMonoid M
inst✝² : TopologicalSpace M
inst✝¹ : AddCommMonoid N
inst✝ : TopologicalSpace N
v : VectorMeasure α M
w : VectorMeasure α N
h : ∀ ⦃s : Set α⦄, MeasurableSet s → ↑w s = 0 → ↑v s = 0
⊢ v ≪ᵥ w

tactic: by_cases hmeas : MeasurableSet s
state_before: α : Type u_1
β : Type ?u.622187
m : MeasurableSpace α
L : Type ?u.622193
M : Type u_3
N : Type u_2
inst✝⁵ : AddCommMonoid L
inst✝⁴ : TopologicalSpace L
inst✝³ : AddCommMonoid M
inst✝² : TopologicalSpace M
inst✝¹ : AddCommMonoid N
inst✝ : TopologicalSpace N
v : VectorMeasure α M
w : VectorMeasure α N
h : ∀ ⦃s : Set α⦄, MeasurableSet s → ↑w s = 0 → ↑v s = 0
s : Set α
hs : ↑w s = 0
⊢ ↑v s = 0

tactic: exact h hmeas hs
state_before: case pos
α : Type u_1
β : Type ?u.622187
m : MeasurableSpace α
L : Type ?u.622193
M : Type u_3
N : Type u_2
inst✝⁵ : AddCommMonoid L
inst✝⁴ : TopologicalSpace L
inst✝³ : AddCommMonoid M
inst✝² : TopologicalSpace M
inst✝¹ : AddCommMonoid N
inst✝ : TopologicalSpace N
v : VectorMeasure α M
w : VectorMeasure α N
h : ∀ ⦃s : Set α⦄, MeasurableSet s → ↑w s = 0 → ↑v s = 0
s : Set α
hs : ↑w s = 0
hmeas : MeasurableSet s
⊢ ↑v s = 0

tactic: exact not_measurable v hmeas
state_before: case neg
α : Type u_1
β : Type ?u.622187
m : MeasurableSpace α
L : Type ?u.622193
M : Type u_3
N : Type u_2
inst✝⁵ : AddCommMonoid L
inst✝⁴ : TopologicalSpace L
inst✝³ : AddCommMonoid M
inst✝² : TopologicalSpace M
inst✝¹ : AddCommMonoid N
inst✝ : TopologicalSpace N
v : VectorMeasure α M
w : VectorMeasure α N
h : ∀ ⦃s : Set α⦄, MeasurableSet s → ↑w s = 0 → ↑v s = 0
s : Set α
hs : ↑w s = 0
hmeas : ¬MeasurableSet s
⊢ ↑v s = 0
Theorem: Nat.Primrec'.encode
File: Mathlib/Computability/Primrec.lean

tactic: rw [v.eq_nil]
state_before: v : Vector ℕ 0
⊢ 0 = encode v

tactic: rfl
state_before: v : Vector ℕ 0
⊢ 0 = encode nil
Theorem: Fintype.card_fun
File: Mathlib/Data/Fintype/BigOperators.lean

tactic: rw [Fintype.card_pi, Finset.prod_const]
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.12409
inst✝² : DecidableEq α
inst✝¹ : Fintype α
inst✝ : Fintype β
⊢ card (α → β) = card β ^ card α

tactic: rfl
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.12409
inst✝² : DecidableEq α
inst✝¹ : Fintype α
inst✝ : Fintype β
⊢ card β ^ Finset.card univ = card β ^ card α
Theorem: SimpleGraph.Subgraph.deleteEdges_spanningCoe_eq
File: Mathlib/Combinatorics/SimpleGraph/Subgraph.lean

tactic: ext
state_before: ι : Sort ?u.243913
V : Type u
W : Type v
G : SimpleGraph V
G' : Subgraph G
s : Set (Sym2 V)
⊢ SimpleGraph.deleteEdges (Subgraph.spanningCoe G') s = Subgraph.spanningCoe (deleteEdges G' s)

tactic: simp
state_before: case Adj.h.h.a
ι : Sort ?u.243913
V : Type u
W : Type v
G : SimpleGraph V
G' : Subgraph G
s : Set (Sym2 V)
x✝¹ x✝ : V
⊢ SimpleGraph.Adj (SimpleGraph.deleteEdges (Subgraph.spanningCoe G') s) x✝¹ x✝ ↔
    SimpleGraph.Adj (Subgraph.spanningCoe (deleteEdges G' s)) x✝¹ x✝
Theorem: multiplicity_normalizedFactorsEquivSpanNormalizedFactors_eq_multiplicity
File: Mathlib/RingTheory/DedekindDomain/Ideal.lean

tactic: simp only [normalizedFactorsEquivSpanNormalizedFactors, multiplicity_eq_multiplicity_span,
  Subtype.coe_mk, Equiv.ofBijective_apply]
state_before: R : Type u_1
A : Type ?u.1418572
K : Type ?u.1418575
inst✝¹⁰ : CommRing R
inst✝⁹ : CommRing A
inst✝⁸ : Field K
inst✝⁷ : IsDomain A
inst✝⁶ : IsDomain R
inst✝⁵ : IsPrincipalIdealRing R
inst✝⁴ : DecidableEq R
inst✝³ : DecidableEq (Ideal R)
inst✝² : NormalizationMonoid R
inst✝¹ : DecidableRel fun x x_1 => x ∣ x_1
inst✝ : DecidableRel fun x x_1 => x ∣ x_1
r d : R
hr : r ≠ 0
hd : d ∈ normalizedFactors r
⊢ multiplicity d r =
    multiplicity (↑(↑(normalizedFactorsEquivSpanNormalizedFactors hr) { val := d, property := hd })) (span {r})
Theorem: OpenEmbedding.map_nhdsWithin_preimage_eq
File: Mathlib/Topology/ContinuousOn.lean

tactic: rw [hf.toEmbedding.map_nhdsWithin_eq, image_preimage_eq_inter_range]
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.370133
δ : Type ?u.370136
inst✝³ : TopologicalSpace α
inst✝² : TopologicalSpace β
inst✝¹ : TopologicalSpace γ
inst✝ : TopologicalSpace δ
f : α → β
hf : OpenEmbedding f
s : Set β
x : α
⊢ map f (𝓝[f ⁻¹' s] x) = 𝓝[s] f x

tactic: apply nhdsWithin_eq_nhdsWithin (mem_range_self _) hf.open_range
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.370133
δ : Type ?u.370136
inst✝³ : TopologicalSpace α
inst✝² : TopologicalSpace β
inst✝¹ : TopologicalSpace γ
inst✝ : TopologicalSpace δ
f : α → β
hf : OpenEmbedding f
s : Set β
x : α
⊢ 𝓝[s ∩ range f] f x = 𝓝[s] f x

tactic: rw [inter_assoc, inter_self]
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.370133
δ : Type ?u.370136
inst✝³ : TopologicalSpace α
inst✝² : TopologicalSpace β
inst✝¹ : TopologicalSpace γ
inst✝ : TopologicalSpace δ
f : α → β
hf : OpenEmbedding f
s : Set β
x : α
⊢ s ∩ range f ∩ range f = s ∩ range f
Theorem: Matrix.eta_fin_two
File: Mathlib/Data/Matrix/Notation.lean

tactic: ext (i j)
state_before: α : Type u
o n m : ℕ
m' : Type uₘ
n' : Type uₙ
o' : Type uₒ
a b : ℕ
A : Matrix (Fin 2) (Fin 2) α
⊢ A = ↑of ![![A 0 0, A 0 1], ![A 1 0, A 1 1]]

tactic: fin_cases i <;> fin_cases j <;> rfl
state_before: case a.h
α : Type u
o n m : ℕ
m' : Type uₘ
n' : Type uₙ
o' : Type uₒ
a b : ℕ
A : Matrix (Fin 2) (Fin 2) α
i j : Fin 2
⊢ A i j = ↑of ![![A 0 0, A 0 1], ![A 1 0, A 1 1]] i j
Theorem: Order.Ideal.PrimePair.F_isPrime
File: Mathlib/Order/PrimeIdeal.lean

tactic: rw [IF.compl_F_eq_I]
state_before: P : Type u_1
inst✝ : Preorder P
IF : Ideal.PrimePair P
⊢ IsIdeal (↑IF.Fᶜ)

tactic: exact IF.I.isIdeal
state_before: P : Type u_1
inst✝ : Preorder P
IF : Ideal.PrimePair P
⊢ IsIdeal ↑IF.I
Theorem: PowerSeries.coeff_of_lt_order
File: Mathlib/RingTheory/PowerSeries/Basic.lean

tactic: contrapose! h
state_before: R : Type u_1
inst✝ : Semiring R
φ : PowerSeries R
n : ℕ
h : ↑n < order φ
⊢ ↑(coeff R n) φ = 0

tactic: exact order_le _ h
state_before: R : Type u_1
inst✝ : Semiring R
φ : PowerSeries R
n : ℕ
h : ↑(coeff R n) φ ≠ 0
⊢ order φ ≤ ↑n
Theorem: Real.not_summable_nat_cast_inv
File: Mathlib/Analysis/PSeries.lean

tactic: have : ¬Summable (fun n => ((n : ℝ) ^ ((1 : ℕ) : ℝ))⁻¹ : ℕ → ℝ) :=
  mt (Real.summable_nat_pow_inv (p := 1)).1 (lt_irrefl 1)
state_before: ⊢ ¬Summable fun n => (↑n)⁻¹

tactic: convert this
state_before: this : ¬Summable fun n => (↑n ^ ↑1)⁻¹
⊢ ¬Summable fun n => (↑n)⁻¹

tactic: simp
state_before: case h.e'_1.h.e'_5.h.h.e'_3
this : ¬Summable fun n => (↑n ^ ↑1)⁻¹
x✝ : ℕ
⊢ ↑x✝ = ↑x✝ ^ ↑1
Theorem: coe_factor_orderIso_map_eq_one_iff
File: Mathlib/RingTheory/ChainOfDivisors.lean

tactic: rw [show u = (d.symm ⟨d ⟨u, hu'⟩, (d ⟨u, hu'⟩).prop⟩) by
    simp only [Subtype.coe_eta, OrderIso.symm_apply_apply, Subtype.coe_mk]]
state_before: M : Type u_1
inst✝¹ : CancelCommMonoidWithZero M
N : Type u_2
inst✝ : CancelCommMonoidWithZero N
m u : Associates M
n : Associates N
hu' : u ≤ m
d : ↑(Set.Iic m) ≃o ↑(Set.Iic n)
hu : ↑(↑d { val := u, property := hu' }) = 1
⊢ u = 1

tactic: conv_rhs => rw [← factor_orderIso_map_one_eq_bot d.symm]
state_before: M : Type u_1
inst✝¹ : CancelCommMonoidWithZero M
N : Type u_2
inst✝ : CancelCommMonoidWithZero N
m u : Associates M
n : Associates N
hu' : u ≤ m
d : ↑(Set.Iic m) ≃o ↑(Set.Iic n)
hu : ↑(↑d { val := u, property := hu' }) = 1
⊢ ↑(↑(OrderIso.symm d)
        { val := ↑(↑d { val := u, property := hu' }),
          property := (_ : ↑(↑d { val := u, property := hu' }) ∈ Set.Iic n) }) =
    1

tactic: congr
state_before: M : Type u_1
inst✝¹ : CancelCommMonoidWithZero M
N : Type u_2
inst✝ : CancelCommMonoidWithZero N
m u : Associates M
n : Associates N
hu' : u ≤ m
d : ↑(Set.Iic m) ≃o ↑(Set.Iic n)
hu : ↑(↑d { val := u, property := hu' }) = 1
⊢ ↑(↑(OrderIso.symm d)
        { val := ↑(↑d { val := u, property := hu' }),
          property := (_ : ↑(↑d { val := u, property := hu' }) ∈ Set.Iic n) }) =
    ↑(↑(OrderIso.symm d) { val := 1, property := (_ : 1 ∣ n) })

tactic: simp only [Subtype.coe_eta, OrderIso.symm_apply_apply, Subtype.coe_mk]
state_before: M : Type u_1
inst✝¹ : CancelCommMonoidWithZero M
N : Type u_2
inst✝ : CancelCommMonoidWithZero N
m u : Associates M
n : Associates N
hu' : u ≤ m
d : ↑(Set.Iic m) ≃o ↑(Set.Iic n)
hu : ↑(↑d { val := u, property := hu' }) = 1
⊢ u =
    ↑(↑(OrderIso.symm d)
        { val := ↑(↑d { val := u, property := hu' }),
          property := (_ : ↑(↑d { val := u, property := hu' }) ∈ Set.Iic n) })

tactic: simp_rw [hu]
state_before: M : Type u_1
inst✝¹ : CancelCommMonoidWithZero M
N : Type u_2
inst✝ : CancelCommMonoidWithZero N
m u : Associates M
n : Associates N
hu' : u ≤ m
d : ↑(Set.Iic m) ≃o ↑(Set.Iic n)
hu : u = 1
⊢ ↑(↑d { val := u, property := hu' }) = 1

tactic: conv_rhs =>  rw [← factor_orderIso_map_one_eq_bot d]
state_before: M : Type u_1
inst✝¹ : CancelCommMonoidWithZero M
N : Type u_2
inst✝ : CancelCommMonoidWithZero N
m u : Associates M
n : Associates N
hu' : u ≤ m
d : ↑(Set.Iic m) ≃o ↑(Set.Iic n)
hu : u = 1
⊢ ↑(↑d { val := 1, property := (_ : (fun x => x ∈ Set.Iic m) 1) }) = 1
Theorem: MeasureTheory.FiniteMeasure.self_eq_mass_mul_normalize
File: Mathlib/MeasureTheory/Measure/ProbabilityMeasure.lean

tactic: obtain rfl | h := eq_or_ne μ 0
state_before: Ω : Type u_1
inst✝ : Nonempty Ω
m0 : MeasurableSpace Ω
μ : FiniteMeasure Ω
s : Set Ω
⊢ (fun s => ENNReal.toNNReal (↑↑↑μ s)) s = mass μ * (fun s => ENNReal.toNNReal (↑↑↑(normalize μ) s)) s

tactic: have mass_nonzero : μ.mass ≠ 0 := by rwa [μ.mass_nonzero_iff]
state_before: case inr
Ω : Type u_1
inst✝ : Nonempty Ω
m0 : MeasurableSpace Ω
μ : FiniteMeasure Ω
s : Set Ω
h : μ ≠ 0
⊢ (fun s => ENNReal.toNNReal (↑↑↑μ s)) s = mass μ * (fun s => ENNReal.toNNReal (↑↑↑(normalize μ) s)) s

tactic: simp only [normalize, dif_neg mass_nonzero]
state_before: case inr
Ω : Type u_1
inst✝ : Nonempty Ω
m0 : MeasurableSpace Ω
μ : FiniteMeasure Ω
s : Set Ω
h : μ ≠ 0
mass_nonzero : mass μ ≠ 0
⊢ (fun s => ENNReal.toNNReal (↑↑↑μ s)) s = mass μ * (fun s => ENNReal.toNNReal (↑↑↑(normalize μ) s)) s

tactic: change μ s = mass μ * ((mass μ)⁻¹ • μ) s
state_before: case inr
Ω : Type u_1
inst✝ : Nonempty Ω
m0 : MeasurableSpace Ω
μ : FiniteMeasure Ω
s : Set Ω
h : μ ≠ 0
mass_nonzero : mass μ ≠ 0
⊢ ENNReal.toNNReal (↑↑↑μ s) =
    mass μ *
      ENNReal.toNNReal (↑↑↑{ val := ↑((mass μ)⁻¹ • μ), property := (_ : IsProbabilityMeasure ↑((mass μ)⁻¹ • μ)) } s)

tactic: simp only [toMeasure_smul, Measure.smul_toOuterMeasure, OuterMeasure.coe_smul, Pi.smul_apply,
  Measure.nnreal_smul_coe_apply, ne_eq, mass_zero_iff, ENNReal.toNNReal_mul, ENNReal.toNNReal_coe,
  mul_inv_cancel_left₀ mass_nonzero]
state_before: case inr
Ω : Type u_1
inst✝ : Nonempty Ω
m0 : MeasurableSpace Ω
μ : FiniteMeasure Ω
s : Set Ω
h : μ ≠ 0
mass_nonzero : mass μ ≠ 0
⊢ (fun s => ENNReal.toNNReal (↑↑↑μ s)) s = mass μ * (fun s => ENNReal.toNNReal (↑↑↑((mass μ)⁻¹ • μ) s)) s

tactic: simp only [zero_mass, coeFn_zero, Pi.zero_apply, MulZeroClass.zero_mul]
state_before: case inl
Ω : Type u_1
inst✝ : Nonempty Ω
m0 : MeasurableSpace Ω
s : Set Ω
⊢ (fun s => ENNReal.toNNReal (↑↑↑0 s)) s = mass 0 * (fun s => ENNReal.toNNReal (↑↑↑(normalize 0) s)) s

tactic: rfl
state_before: case inl
Ω : Type u_1
inst✝ : Nonempty Ω
m0 : MeasurableSpace Ω
s : Set Ω
⊢ ENNReal.toNNReal (↑↑↑0 s) = 0

tactic: rwa [μ.mass_nonzero_iff]
state_before: Ω : Type u_1
inst✝ : Nonempty Ω
m0 : MeasurableSpace Ω
μ : FiniteMeasure Ω
s : Set Ω
h : μ ≠ 0
⊢ mass μ ≠ 0
Theorem: CategoryTheory.MonoidalCategory.id_tensor_comp
File: Mathlib/CategoryTheory/Monoidal/Category.lean

tactic: rw [← tensor_comp]
state_before: C✝ : Type u
𝒞 : Category C✝
inst✝² : MonoidalCategory C✝
C : Type u
inst✝¹ : Category C
inst✝ : MonoidalCategory C
U V W X Y Z : C
f : W ⟶ X
g : X ⟶ Y
⊢ 𝟙 Z ⊗ f ≫ g = (𝟙 Z ⊗ f) ≫ (𝟙 Z ⊗ g)

tactic: simp
state_before: C✝ : Type u
𝒞 : Category C✝
inst✝² : MonoidalCategory C✝
C : Type u
inst✝¹ : Category C
inst✝ : MonoidalCategory C
U V W X Y Z : C
f : W ⟶ X
g : X ⟶ Y
⊢ 𝟙 Z ⊗ f ≫ g = 𝟙 Z ≫ 𝟙 Z ⊗ f ≫ g
Theorem: MeasureTheory.AEEqFun.lintegral_add
File: Mathlib/MeasureTheory/Function/AEEqFun.lean

tactic: simp [lintegral_add_left' hf.aemeasurable]
state_before: α : Type u_1
β : Type ?u.1576020
γ : Type ?u.1576023
δ : Type ?u.1576026
inst✝³ : MeasurableSpace α
μ ν : Measure α
inst✝² : TopologicalSpace β
inst✝¹ : TopologicalSpace γ
inst✝ : TopologicalSpace δ
f✝ g✝ : α →ₘ[μ] ℝ≥0∞
f : α → ℝ≥0∞
hf : AEStronglyMeasurable f μ
g : α → ℝ≥0∞
x✝ : AEStronglyMeasurable g μ
⊢ lintegral (mk f hf + mk g x✝) = lintegral (mk f hf) + lintegral (mk g x✝)
Theorem: Rat.coe_int_num_of_den_eq_one
File: Mathlib/Data/Rat/Defs.lean

tactic: conv_rhs => rw [← @num_den q, hq]
state_before: a b c q : ℚ
hq : q.den = 1
⊢ ↑q.num = q

tactic: rw [coe_int_eq_divInt]
state_before: a b c q : ℚ
hq : q.den = 1
⊢ ↑q.num = q.num /. ↑1

tactic: rfl
state_before: a b c q : ℚ
hq : q.den = 1
⊢ q.num /. 1 = q.num /. ↑1
Theorem: Finset.prod_boole
File: Mathlib/Algebra/BigOperators/Basic.lean

tactic: split_ifs with h
state_before: ι : Type ?u.870155
β : Type u
α : Type v
γ : Type w
s✝ s₁ s₂ : Finset α
a : α
f g : α → β
inst✝¹ : CommMonoidWithZero β
s : Finset α
p : α → Prop
inst✝ : DecidablePred p
⊢ (∏ i in s, if p i then 1 else 0) = if ∀ (i : α), i ∈ s → p i then 1 else 0

tactic: apply prod_eq_one
state_before: case inl
ι : Type ?u.870155
β : Type u
α : Type v
γ : Type w
s✝ s₁ s₂ : Finset α
a : α
f g : α → β
inst✝¹ : CommMonoidWithZero β
s : Finset α
p : α → Prop
inst✝ : DecidablePred p
h : ∀ (i : α), i ∈ s → p i
⊢ (∏ i in s, if p i then 1 else 0) = 1

tactic: intro i hi
state_before: case inl.h
ι : Type ?u.870155
β : Type u
α : Type v
γ : Type w
s✝ s₁ s₂ : Finset α
a : α
f g : α → β
inst✝¹ : CommMonoidWithZero β
s : Finset α
p : α → Prop
inst✝ : DecidablePred p
h : ∀ (i : α), i ∈ s → p i
⊢ ∀ (x : α), x ∈ s → (if p x then 1 else 0) = 1

tactic: rw [if_pos (h i hi)]
state_before: case inl.h
ι : Type ?u.870155
β : Type u
α : Type v
γ : Type w
s✝ s₁ s₂ : Finset α
a : α
f g : α → β
inst✝¹ : CommMonoidWithZero β
s : Finset α
p : α → Prop
inst✝ : DecidablePred p
h : ∀ (i : α), i ∈ s → p i
i : α
hi : i ∈ s
⊢ (if p i then 1 else 0) = 1

tactic: push_neg  at h
state_before: case inr
ι : Type ?u.870155
β : Type u
α : Type v
γ : Type w
s✝ s₁ s₂ : Finset α
a : α
f g : α → β
inst✝¹ : CommMonoidWithZero β
s : Finset α
p : α → Prop
inst✝ : DecidablePred p
h : ¬∀ (i : α), i ∈ s → p i
⊢ (∏ i in s, if p i then 1 else 0) = 0

tactic: rcases h with ⟨i, hi, hq⟩
state_before: case inr
ι : Type ?u.870155
β : Type u
α : Type v
γ : Type w
s✝ s₁ s₂ : Finset α
a : α
f g : α → β
inst✝¹ : CommMonoidWithZero β
s : Finset α
p : α → Prop
inst✝ : DecidablePred p
h : ∃ i, i ∈ s ∧ ¬p i
⊢ (∏ i in s, if p i then 1 else 0) = 0

tactic: apply prod_eq_zero hi
state_before: case inr.intro.intro
ι : Type ?u.870155
β : Type u
α : Type v
γ : Type w
s✝ s₁ s₂ : Finset α
a : α
f g : α → β
inst✝¹ : CommMonoidWithZero β
s : Finset α
p : α → Prop
inst✝ : DecidablePred p
i : α
hi : i ∈ s
hq : ¬p i
⊢ (∏ i in s, if p i then 1 else 0) = 0

tactic: rw [if_neg hq]
state_before: case inr.intro.intro
ι : Type ?u.870155
β : Type u
α : Type v
γ : Type w
s✝ s₁ s₂ : Finset α
a : α
f g : α → β
inst✝¹ : CommMonoidWithZero β
s : Finset α
p : α → Prop
inst✝ : DecidablePred p
i : α
hi : i ∈ s
hq : ¬p i
⊢ (if p i then 1 else 0) = 0
Theorem: Nat.add_sub_of_le
File: src/lean/Init/Data/Nat/Basic.lean

tactic: induction a with
| zero => simp
| succ a ih =>
  have hne : b - a ≠ 0 := Nat.sub_ne_zero_of_lt h
  have : a ≤ b := Nat.le_of_succ_le h
  rw [sub_succ, Nat.succ_add, ← Nat.add_succ, Nat.succ_pred hne, ih this]
state_before: a b : Nat
h : a ≤ b
⊢ a + (b - a) = b

tactic: simp
state_before: case zero
b : Nat
h : zero ≤ b
⊢ zero + (b - zero) = b

tactic: have hne : b - a ≠ 0 := Nat.sub_ne_zero_of_lt h
state_before: case succ
b a : Nat
ih : a ≤ b → a + (b - a) = b
h : succ a ≤ b
⊢ succ a + (b - succ a) = b

tactic: have : a ≤ b := Nat.le_of_succ_le h
state_before: case succ
b a : Nat
ih : a ≤ b → a + (b - a) = b
h : succ a ≤ b
hne : b - a ≠ 0
⊢ succ a + (b - succ a) = b

tactic: rw [sub_succ, Nat.succ_add, ← Nat.add_succ, Nat.succ_pred hne, ih this]
state_before: case succ
b a : Nat
ih : a ≤ b → a + (b - a) = b
h : succ a ≤ b
hne : b - a ≠ 0
this : a ≤ b
⊢ succ a + (b - succ a) = b
Theorem: ValuationRing.range_algebraMap_eq
File: Mathlib/RingTheory/Valuation/ValuationRing.lean

tactic: ext
state_before: A : Type u
inst✝⁵ : CommRing A
K : Type v
inst✝⁴ : Field K
inst✝³ : Algebra A K
inst✝² : IsDomain A
inst✝¹ : ValuationRing A
inst✝ : IsFractionRing A K
⊢ Valuation.integer (valuation A K) = RingHom.range (algebraMap A K)

tactic: exact mem_integer_iff _ _ _
state_before: case h
A : Type u
inst✝⁵ : CommRing A
K : Type v
inst✝⁴ : Field K
inst✝³ : Algebra A K
inst✝² : IsDomain A
inst✝¹ : ValuationRing A
inst✝ : IsFractionRing A K
x✝ : K
⊢ x✝ ∈ Valuation.integer (valuation A K) ↔ x✝ ∈ RingHom.range (algebraMap A K)
Theorem: Ordinal.mul_omega_dvd
File: Mathlib/SetTheory/Ordinal/Principal.lean

tactic: rw [← mul_assoc, mul_omega a0 ha]
state_before: a : Ordinal
a0 : 0 < a
ha : a < ω
b : Ordinal
⊢ a * (ω * b) = ω * b