1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: MeasureTheory.exp_llr
File: Mathlib/MeasureTheory/Measure/LogLikelihoodRatio.lean

tactic: filter_upwards [Measure.rnDeriv_lt_top μ ν] with x hx
state_before: α : Type u_1
mα : MeasurableSpace α
μ✝ ν✝ : Measure α
f : α → ℝ
μ ν : Measure α
inst✝ : SigmaFinite μ
⊢ (fun x => rexp (llr μ ν x)) =ᶠ[ae ν] fun x => if μ.rnDeriv ν x = 0 then 1 else (μ.rnDeriv ν x).toReal
state_after: case h
α : Type u_1
mα : MeasurableSpace α
μ✝ ν✝ : Measure α
f : α → ℝ
μ ν : Measure α
inst✝ : SigmaFinite μ
x : α
hx : μ.rnDeriv ν x < ⊤
⊢ rexp (llr μ ν x) = if μ.rnDeriv ν x = 0 then 1 else (μ.rnDeriv ν x).toReal

tactic: by_cases h_zero : μ.rnDeriv ν x = 0
state_before: case h
α : Type u_1
mα : MeasurableSpace α
μ✝ ν✝ : Measure α
f : α → ℝ
μ ν : Measure α
inst✝ : SigmaFinite μ
x : α
hx : μ.rnDeriv ν x < ⊤
⊢ rexp (llr μ ν x) = if μ.rnDeriv ν x = 0 then 1 else (μ.rnDeriv ν x).toReal
state_after: case pos
α : Type u_1
mα : MeasurableSpace α
μ✝ ν✝ : Measure α
f : α → ℝ
μ ν : Measure α
inst✝ : SigmaFinite μ
x : α
hx : μ.rnDeriv ν x < ⊤
h_zero : μ.rnDeriv ν x = 0
⊢ rexp (llr μ ν x) = if μ.rnDeriv ν x = 0 then 1 else (μ.rnDeriv ν x).toReal

case neg
α : Type u_1
mα : MeasurableSpace α
μ✝ ν✝ : Measure α
f : α → ℝ
μ ν : Measure α
inst✝ : SigmaFinite μ
x : α
hx : μ.rnDeriv ν x < ⊤
h_zero : ¬μ.rnDeriv ν x = 0
⊢ rexp (llr μ ν x) = if μ.rnDeriv ν x = 0 then 1 else (μ.rnDeriv ν x).toReal

tactic: simp only [llr, h_zero, ENNReal.zero_toReal, log_zero, exp_zero, ite_true]
state_before: case pos
α : Type u_1
mα : MeasurableSpace α
μ✝ ν✝ : Measure α
f : α → ℝ
μ ν : Measure α
inst✝ : SigmaFinite μ
x : α
hx : μ.rnDeriv ν x < ⊤
h_zero : μ.rnDeriv ν x = 0
⊢ rexp (llr μ ν x) = if μ.rnDeriv ν x = 0 then 1 else (μ.rnDeriv ν x).toReal
state_after: no goals

tactic: rw [llr, exp_log, if_neg h_zero]
state_before: case neg
α : Type u_1
mα : MeasurableSpace α
μ✝ ν✝ : Measure α
f : α → ℝ
μ ν : Measure α
inst✝ : SigmaFinite μ
x : α
hx : μ.rnDeriv ν x < ⊤
h_zero : ¬μ.rnDeriv ν x = 0
⊢ rexp (llr μ ν x) = if μ.rnDeriv ν x = 0 then 1 else (μ.rnDeriv ν x).toReal
state_after: case neg
α : Type u_1
mα : MeasurableSpace α
μ✝ ν✝ : Measure α
f : α → ℝ
μ ν : Measure α
inst✝ : SigmaFinite μ
x : α
hx : μ.rnDeriv ν x < ⊤
h_zero : ¬μ.rnDeriv ν x = 0
⊢ 0 < (μ.rnDeriv ν x).toReal

tactic: exact ENNReal.toReal_pos h_zero hx.ne
state_before: case neg
α : Type u_1
mα : MeasurableSpace α
μ✝ ν✝ : Measure α
f : α → ℝ
μ ν : Measure α
inst✝ : SigmaFinite μ
x : α
hx : μ.rnDeriv ν x < ⊤
h_zero : ¬μ.rnDeriv ν x = 0
⊢ 0 < (μ.rnDeriv ν x).toReal
state_after: no goals
Theorem: WfDvdMonoid.exists_factors
File: Mathlib/RingTheory/UniqueFactorizationDomain.lean

tactic: rw [s.prod_cons i]
state_before: α : Type u_1
inst✝¹ : CommMonoidWithZero α
inst✝ : WfDvdMonoid α
a✝ a i : α
ha0 : a ≠ 0
hi : Irreducible i
ih : a ≠ 0 → ∃ f, (∀ b ∈ f, Irreducible b) ∧ f.prod ~ᵤ a
x✝ : i * a ≠ 0
s : Multiset α
hs : (∀ b ∈ s, Irreducible b) ∧ s.prod ~ᵤ a
⊢ (i ::ₘ s).prod ~ᵤ i * a
state_after: α : Type u_1
inst✝¹ : CommMonoidWithZero α
inst✝ : WfDvdMonoid α
a✝ a i : α
ha0 : a ≠ 0
hi : Irreducible i
ih : a ≠ 0 → ∃ f, (∀ b ∈ f, Irreducible b) ∧ f.prod ~ᵤ a
x✝ : i * a ≠ 0
s : Multiset α
hs : (∀ b ∈ s, Irreducible b) ∧ s.prod ~ᵤ a
⊢ i * s.prod ~ᵤ i * a

tactic: exact hs.2.mul_left i
state_before: α : Type u_1
inst✝¹ : CommMonoidWithZero α
inst✝ : WfDvdMonoid α
a✝ a i : α
ha0 : a ≠ 0
hi : Irreducible i
ih : a ≠ 0 → ∃ f, (∀ b ∈ f, Irreducible b) ∧ f.prod ~ᵤ a
x✝ : i * a ≠ 0
s : Multiset α
hs : (∀ b ∈ s, Irreducible b) ∧ s.prod ~ᵤ a
⊢ i * s.prod ~ᵤ i * a
state_after: no goals
Theorem: LieModule.chainBot_zero
File: Mathlib/Algebra/Lie/Weights/Chain.lean

tactic: ext
state_before: R : Type u_1
L : Type u_2
inst✝¹⁰ : CommRing R
inst✝⁹ : LieRing L
inst✝⁸ : LieAlgebra R L
M : Type u_3
inst✝⁷ : AddCommGroup M
inst✝⁶ : Module R M
inst✝⁵ : LieRingModule L M
inst✝⁴ : LieModule R L M
inst✝³ : LieAlgebra.IsNilpotent R L
inst✝² : NoZeroSMulDivisors ℤ R
inst✝¹ : NoZeroSMulDivisors R M
inst✝ : IsNoetherian R M
α : L → R
β : Weight R L M
hα : α ≠ 0
⊢ chainBot 0 β = β
state_after: case h
R : Type u_1
L : Type u_2
inst✝¹⁰ : CommRing R
inst✝⁹ : LieRing L
inst✝⁸ : LieAlgebra R L
M : Type u_3
inst✝⁷ : AddCommGroup M
inst✝⁶ : Module R M
inst✝⁵ : LieRingModule L M
inst✝⁴ : LieModule R L M
inst✝³ : LieAlgebra.IsNilpotent R L
inst✝² : NoZeroSMulDivisors ℤ R
inst✝¹ : NoZeroSMulDivisors R M
inst✝ : IsNoetherian R M
α : L → R
β : Weight R L M
hα : α ≠ 0
x✝ : L
⊢ (chainBot 0 β) x✝ = β x✝

tactic: simp
state_before: case h
R : Type u_1
L : Type u_2
inst✝¹⁰ : CommRing R
inst✝⁹ : LieRing L
inst✝⁸ : LieAlgebra R L
M : Type u_3
inst✝⁷ : AddCommGroup M
inst✝⁶ : Module R M
inst✝⁵ : LieRingModule L M
inst✝⁴ : LieModule R L M
inst✝³ : LieAlgebra.IsNilpotent R L
inst✝² : NoZeroSMulDivisors ℤ R
inst✝¹ : NoZeroSMulDivisors R M
inst✝ : IsNoetherian R M
α : L → R
β : Weight R L M
hα : α ≠ 0
x✝ : L
⊢ (chainBot 0 β) x✝ = β x✝
state_after: no goals
Theorem: Nat.mem_smoothNumbers'
File: Mathlib/NumberTheory/SmoothNumbers.lean

tactic: simp only [smoothNumbers_eq_factoredNumbers, mem_factoredNumbers', Finset.mem_range]
state_before: n m : ℕ
⊢ m ∈ n.smoothNumbers ↔ ∀ (p : ℕ), Prime p → p ∣ m → p < n
state_after: no goals
Theorem: ZMod.pow_totient
File: Mathlib/FieldTheory/Finite/Basic.lean

tactic: cases n
state_before: K : Type u_1
R : Type u_2
n : ℕ
x : (ZMod n)ˣ
⊢ x ^ φ n = 1
state_after: case zero
K : Type u_1
R : Type u_2
x : (ZMod 0)ˣ
⊢ x ^ φ 0 = 1

case succ
K : Type u_1
R : Type u_2
n✝ : ℕ
x : (ZMod (n✝ + 1))ˣ
⊢ x ^ φ (n✝ + 1) = 1

tactic: rw [Nat.totient_zero, pow_zero]
state_before: case zero
K : Type u_1
R : Type u_2
x : (ZMod 0)ˣ
⊢ x ^ φ 0 = 1
state_after: no goals

tactic: rw [← card_units_eq_totient, pow_card_eq_one]
state_before: case succ
K : Type u_1
R : Type u_2
n✝ : ℕ
x : (ZMod (n✝ + 1))ˣ
⊢ x ^ φ (n✝ + 1) = 1
state_after: no goals
Theorem: ENNReal.mul_div_right_comm
File: Mathlib/Data/ENNReal/Inv.lean

tactic: simp only [div_eq_mul_inv, mul_right_comm]
state_before: a b c d : ℝ≥0∞
r p q : ℝ≥0
⊢ a * b / c = a / c * b
state_after: no goals
Theorem: CategoryTheory.MonoidalCategory.whiskerLeft_hom_inv
File: Mathlib/CategoryTheory/Monoidal/Category.lean

tactic: rw [← whiskerLeft_comp, hom_inv_id, whiskerLeft_id]
state_before: C : Type u
𝒞 : Category.{v, u} C
inst✝ : MonoidalCategory C
X Y Z : C
f : Y ≅ Z
⊢ X ◁ f.hom ≫ X ◁ f.inv = 𝟙 (X ⊗ Y)
state_after: no goals
Theorem: Int.lt_floor_add_one
File: Mathlib/Algebra/Order/Floor.lean

tactic: simpa only [Int.succ, Int.cast_add, Int.cast_one] using lt_succ_floor a
state_before: F : Type u_1
α : Type u_2
β : Type u_3
inst✝¹ : LinearOrderedRing α
inst✝ : FloorRing α
z : ℤ
a✝ a : α
⊢ a < ↑⌊a⌋ + 1
state_after: no goals
Theorem: SimpleGraph.ComponentCompl.disjoint_right
File: Mathlib/Combinatorics/SimpleGraph/Ends/Defs.lean

tactic: rw [Set.disjoint_iff]
state_before: V : Type u
G : SimpleGraph V
K L L' M : Set V
C : G.ComponentCompl K
⊢ Disjoint K ↑C
state_after: V : Type u
G : SimpleGraph V
K L L' M : Set V
C : G.ComponentCompl K
⊢ K ∩ ↑C ⊆ ∅

tactic: exact fun v ⟨vK, vC⟩ => vC.choose vK
state_before: V : Type u
G : SimpleGraph V
K L L' M : Set V
C : G.ComponentCompl K
⊢ K ∩ ↑C ⊆ ∅
state_after: no goals
Theorem: Module.AEval.of_symm_X_smul
File: Mathlib/Algebra/Polynomial/Module/AEval.lean

tactic: rw [of_symm_smul, aeval_X]
state_before: R : Type u_1
A : Type u_3
M : Type u_2
inst✝⁶ : CommSemiring R
inst✝⁵ : Semiring A
a : A
inst✝⁴ : Algebra R A
inst✝³ : AddCommMonoid M
inst✝² : Module A M
inst✝¹ : Module R M
inst✝ : IsScalarTower R A M
m : AEval R M a
⊢ (of R M a).symm (X • m) = a • (of R M a).symm m
state_after: no goals
Theorem: Set.image_univ_of_surjective
File: Mathlib/Data/Set/Image.lean

tactic: simpa [image]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι✝ : Sort u_4
ι' : Sort u_5
f✝ : α → β
s t : Set α
ι : Type u_6
f : ι → β
H : Surjective f
⊢ ∀ (x : β), x ∈ f '' univ
state_after: no goals
Theorem: PowerSeries.rescale_zero
File: Mathlib/RingTheory/PowerSeries/Basic.lean

tactic: ext x n
state_before: R : Type u_1
inst✝ : CommSemiring R
⊢ rescale 0 = (C R).comp (constantCoeff R)
state_after: case a.h
R : Type u_1
inst✝ : CommSemiring R
x : R⟦X⟧
n : ℕ
⊢ (coeff R n) ((rescale 0) x) = (coeff R n) (((C R).comp (constantCoeff R)) x)

tactic: simp only [Function.comp_apply, RingHom.coe_comp, rescale, RingHom.coe_mk,
  PowerSeries.coeff_mk _ _, coeff_C]
state_before: case a.h
R : Type u_1
inst✝ : CommSemiring R
x : R⟦X⟧
n : ℕ
⊢ (coeff R n) ((rescale 0) x) = (coeff R n) (((C R).comp (constantCoeff R)) x)
state_after: case a.h
R : Type u_1
inst✝ : CommSemiring R
x : R⟦X⟧
n : ℕ
⊢ (coeff R n) ({ toFun := fun f => mk fun n => 0 ^ n * (coeff R n) f, map_one' := ⋯, map_mul' := ⋯ } x) =
    if n = 0 then (constantCoeff R) x else 0

tactic: split_ifs with h <;> simp [h]
state_before: case a.h
R : Type u_1
inst✝ : CommSemiring R
x : R⟦X⟧
n : ℕ
⊢ (coeff R n) ({ toFun := fun f => mk fun n => 0 ^ n * (coeff R n) f, map_one' := ⋯, map_mul' := ⋯ } x) =
    if n = 0 then (constantCoeff R) x else 0
state_after: no goals
Theorem: partialSups_eq_biSup
File: Mathlib/Order/PartialSups.lean

tactic: simpa only [iSup_subtype] using partialSups_eq_ciSup_Iic f n
state_before: α : Type u_1
inst✝ : CompleteLattice α
f : ℕ → α
n : ℕ
⊢ (partialSups f) n = ⨆ i, ⨆ (_ : i ≤ n), f i
state_after: no goals
Theorem: preNormEDS_even
File: Mathlib/NumberTheory/EllipticDivisibilitySequence.lean

tactic: repeat erw [preNormEDS_ofNat]
state_before: R : Type u
S : Type v
inst✝¹ : CommRing R
inst✝ : CommRing S
W : ℤ → R
f : R →+* S
b c d : R
m : ℕ
⊢ preNormEDS b c d (2 * (↑m + 3)) =
    preNormEDS b c d (↑m + 2) ^ 2 * preNormEDS b c d (↑m + 3) * preNormEDS b c d (↑m + 5) -
      preNormEDS b c d (↑m + 1) * preNormEDS b c d (↑m + 3) * preNormEDS b c d (↑m + 4) ^ 2
state_after: R : Type u
S : Type v
inst✝¹ : CommRing R
inst✝ : CommRing S
W : ℤ → R
f : R →+* S
b c d : R
m : ℕ
⊢ preNormEDS' b c d (2 * (m + 3)) =
    preNormEDS' b c d (m + 2) ^ 2 * preNormEDS' b c d (m + 3) * preNormEDS' b c d (m + 5) -
      preNormEDS' b c d (m + 1) * preNormEDS' b c d (m + 3) * preNormEDS' b c d (m + 4) ^ 2

tactic: exact preNormEDS'_even ..
state_before: R : Type u
S : Type v
inst✝¹ : CommRing R
inst✝ : CommRing S
W : ℤ → R
f : R →+* S
b c d : R
m : ℕ
⊢ preNormEDS' b c d (2 * (m + 3)) =
    preNormEDS' b c d (m + 2) ^ 2 * preNormEDS' b c d (m + 3) * preNormEDS' b c d (m + 5) -
      preNormEDS' b c d (m + 1) * preNormEDS' b c d (m + 3) * preNormEDS' b c d (m + 4) ^ 2
state_after: no goals

tactic: erw [preNormEDS_ofNat]
state_before: R : Type u
S : Type v
inst✝¹ : CommRing R
inst✝ : CommRing S
W : ℤ → R
f : R →+* S
b c d : R
m : ℕ
⊢ preNormEDS' b c d (2 * (m + 3)) =
    preNormEDS' b c d (m + 2) ^ 2 * preNormEDS' b c d (m + 3) * preNormEDS' b c d (m + 5) -
      preNormEDS' b c d (m + 1) * preNormEDS' b c d (m + 3) * preNormEDS b c d (↑m + 4) ^ 2
state_after: R : Type u
S : Type v
inst✝¹ : CommRing R
inst✝ : CommRing S
W : ℤ → R
f : R →+* S
b c d : R
m : ℕ
⊢ preNormEDS' b c d (2 * (m + 3)) =
    preNormEDS' b c d (m + 2) ^ 2 * preNormEDS' b c d (m + 3) * preNormEDS' b c d (m + 5) -
      preNormEDS' b c d (m + 1) * preNormEDS' b c d (m + 3) * preNormEDS' b c d (m + 4) ^ 2
Theorem: FirstOrder.Language.Formula.realize_graph
File: Mathlib/ModelTheory/Semantics.lean

tactic: simp only [Formula.graph, Term.realize, realize_equal, Fin.cons_zero, Fin.cons_succ]
state_before: L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : L.Structure M
inst✝¹ : L.Structure N
inst✝ : L.Structure P
α : Type u'
β : Type v'
γ : Type u_3
n : ℕ
φ ψ : L.Formula α
v : α → M
f : L.Functions n
x : Fin n → M
y : M
⊢ (graph f).Realize (cons y x) ↔ funMap f x = y
state_after: L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : L.Structure M
inst✝¹ : L.Structure N
inst✝ : L.Structure P
α : Type u'
β : Type v'
γ : Type u_3
n : ℕ
φ ψ : L.Formula α
v : α → M
f : L.Functions n
x : Fin n → M
y : M
⊢ (y = funMap f fun i => x i) ↔ funMap f x = y

tactic: rw [eq_comm]
state_before: L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : L.Structure M
inst✝¹ : L.Structure N
inst✝ : L.Structure P
α : Type u'
β : Type v'
γ : Type u_3
n : ℕ
φ ψ : L.Formula α
v : α → M
f : L.Functions n
x : Fin n → M
y : M
⊢ (y = funMap f fun i => x i) ↔ funMap f x = y
state_after: no goals
Theorem: Set.union_empty_iff
File: Mathlib/Data/Set/Basic.lean

tactic: simp only [← subset_empty_iff]
state_before: α : Type u
β : Type v
γ : Type w
ι : Sort x
a b : α
s✝ s₁ s₂ t✝ t₁ t₂ u s t : Set α
⊢ s ∪ t = ∅ ↔ s = ∅ ∧ t = ∅
state_after: α : Type u
β : Type v
γ : Type w
ι : Sort x
a b : α
s✝ s₁ s₂ t✝ t₁ t₂ u s t : Set α
⊢ s ∪ t ⊆ ∅ ↔ s ⊆ ∅ ∧ t ⊆ ∅

tactic: exact union_subset_iff
state_before: α : Type u
β : Type v
γ : Type w
ι : Sort x
a b : α
s✝ s₁ s₂ t✝ t₁ t₂ u s t : Set α
⊢ s ∪ t ⊆ ∅ ↔ s ⊆ ∅ ∧ t ⊆ ∅
state_after: no goals
Theorem: realPart_ofReal
File: Mathlib/Data/Complex/Module.lean

tactic: rw [realPart_apply_coe, star_def, conj_ofReal, ← two_smul ℝ (r : ℂ)]
state_before: A : Type u_1
inst✝³ : AddCommGroup A
inst✝² : Module ℂ A
inst✝¹ : StarAddMonoid A
inst✝ : StarModule ℂ A
r : ℝ
⊢ ↑(ℜ ↑r) = ↑r
state_after: A : Type u_1
inst✝³ : AddCommGroup A
inst✝² : Module ℂ A
inst✝¹ : StarAddMonoid A
inst✝ : StarModule ℂ A
r : ℝ
⊢ 2⁻¹ • 2 • ↑r = ↑r

tactic: simp
state_before: A : Type u_1
inst✝³ : AddCommGroup A
inst✝² : Module ℂ A
inst✝¹ : StarAddMonoid A
inst✝ : StarModule ℂ A
r : ℝ
⊢ 2⁻¹ • 2 • ↑r = ↑r
state_after: no goals
Theorem: Polynomial.natSepDegree_X_sub_C
File: Mathlib/FieldTheory/SeparableDegree.lean

tactic: simp only [natSepDegree, aroots_X_sub_C, Multiset.toFinset_singleton, Finset.card_singleton]
state_before: F : Type u
E : Type v
inst✝⁴ : Field F
inst✝³ : Field E
inst✝² : Algebra F E
K : Type w
inst✝¹ : Field K
inst✝ : Algebra F K
f : F[X]
x : F
⊢ (X - C x).natSepDegree = 1
state_after: no goals
Theorem: Order.not_isSuccLimit_iff
File: Mathlib/Order/SuccPred/Limit.lean

tactic: rw [not_isSuccLimit_iff_exists_covBy]
state_before: α : Type u_1
inst✝¹ : PartialOrder α
inst✝ : SuccOrder α
a b : α
C : α → Sort u_2
⊢ ¬IsSuccLimit a ↔ ∃ b, ¬IsMax b ∧ succ b = a
state_after: α : Type u_1
inst✝¹ : PartialOrder α
inst✝ : SuccOrder α
a b : α
C : α → Sort u_2
⊢ (∃ b, b ⋖ a) ↔ ∃ b, ¬IsMax b ∧ succ b = a

tactic: refine exists_congr fun b => ⟨fun hba => ⟨hba.lt.not_isMax, (CovBy.succ_eq hba)⟩, ?_⟩
state_before: α : Type u_1
inst✝¹ : PartialOrder α
inst✝ : SuccOrder α
a b : α
C : α → Sort u_2
⊢ (∃ b, b ⋖ a) ↔ ∃ b, ¬IsMax b ∧ succ b = a
state_after: α : Type u_1
inst✝¹ : PartialOrder α
inst✝ : SuccOrder α
a b✝ : α
C : α → Sort u_2
b : α
⊢ ¬IsMax b ∧ succ b = a → b ⋖ a

tactic: rintro ⟨h, rfl⟩
state_before: α : Type u_1
inst✝¹ : PartialOrder α
inst✝ : SuccOrder α
a b✝ : α
C : α → Sort u_2
b : α
⊢ ¬IsMax b ∧ succ b = a → b ⋖ a
state_after: case intro
α : Type u_1
inst✝¹ : PartialOrder α
inst✝ : SuccOrder α
b✝ : α
C : α → Sort u_2
b : α
h : ¬IsMax b
⊢ b ⋖ succ b

tactic: exact covBy_succ_of_not_isMax h
state_before: case intro
α : Type u_1
inst✝¹ : PartialOrder α
inst✝ : SuccOrder α
b✝ : α
C : α → Sort u_2
b : α
h : ¬IsMax b
⊢ b ⋖ succ b
state_after: no goals
Theorem: MeasurableEmbedding.mutuallySingular_map
File: Mathlib/MeasureTheory/Measure/MutuallySingular.lean

tactic: refine ⟨f '' hμν.nullSet, hf.measurableSet_image' hμν.measurableSet_nullSet, ?_, ?_⟩
state_before: α : Type u_1
m0 : MeasurableSpace α
μ μ₁ μ₂ ν ν₁ ν₂ : Measure α
β : Type u_2
x✝ : MeasurableSpace β
f : α → β
hf : MeasurableEmbedding f
hμν : μ ⟂ₘ ν
⊢ map f μ ⟂ₘ map f ν
state_after: case refine_1
α : Type u_1
m0 : MeasurableSpace α
μ μ₁ μ₂ ν ν₁ ν₂ : Measure α
β : Type u_2
x✝ : MeasurableSpace β
f : α → β
hf : MeasurableEmbedding f
hμν : μ ⟂ₘ ν
⊢ (map f μ) (f '' hμν.nullSet) = 0

case refine_2
α : Type u_1
m0 : MeasurableSpace α
μ μ₁ μ₂ ν ν₁ ν₂ : Measure α
β : Type u_2
x✝ : MeasurableSpace β
f : α → β
hf : MeasurableEmbedding f
hμν : μ ⟂ₘ ν
⊢ (map f ν) (f '' hμν.nullSet)ᶜ = 0

tactic: rw [hf.map_apply, hf.injective.preimage_image, hμν.measure_nullSet]
state_before: case refine_1
α : Type u_1
m0 : MeasurableSpace α
μ μ₁ μ₂ ν ν₁ ν₂ : Measure α
β : Type u_2
x✝ : MeasurableSpace β
f : α → β
hf : MeasurableEmbedding f
hμν : μ ⟂ₘ ν
⊢ (map f μ) (f '' hμν.nullSet) = 0
state_after: no goals

tactic: rw [hf.map_apply, Set.preimage_compl, hf.injective.preimage_image, hμν.measure_compl_nullSet]
state_before: case refine_2
α : Type u_1
m0 : MeasurableSpace α
μ μ₁ μ₂ ν ν₁ ν₂ : Measure α
β : Type u_2
x✝ : MeasurableSpace β
f : α → β
hf : MeasurableEmbedding f
hμν : μ ⟂ₘ ν
⊢ (map f ν) (f '' hμν.nullSet)ᶜ = 0
state_after: no goals
Theorem: MeasureTheory.IsFundamentalDomain.setIntegral_eq_tsum'
File: Mathlib/MeasureTheory/Group/FundamentalDomain.lean

tactic: simp only [smul_set_inter, inv_smul_smul]
state_before: G : Type u_1
H : Type u_2
α : Type u_3
β : Type u_4
E : Type u_5
inst✝¹² : Group G
inst✝¹¹ : Group H
inst✝¹⁰ : MulAction G α
inst✝⁹ : MeasurableSpace α
inst✝⁸ : MulAction H β
inst✝⁷ : MeasurableSpace β
inst✝⁶ : NormedAddCommGroup E
s t✝ : Set α
μ : Measure α
inst✝⁵ : MeasurableSpace G
inst✝⁴ : MeasurableSMul G α
inst✝³ : SMulInvariantMeasure G α μ
inst✝² : Countable G
ν : Measure α
inst✝¹ : NormedSpace ℝ E
inst✝ : CompleteSpace E
h : IsFundamentalDomain G s μ
f : α → E
t : Set α
hf : IntegrableOn f t μ
⊢ ∑' (g : G), ∫ (x : α) in t ∩ g⁻¹ • s, f x ∂μ = ∑' (g : G), ∫ (x : α) in g⁻¹ • (g • t ∩ s), f x ∂μ
state_after: no goals
Theorem: Int.bodd_neg
File: Mathlib/Data/Int/Bitwise.lean

tactic: cases n with
| ofNat =>
  rw [← negOfNat_eq, bodd_negOfNat]
  simp
| negSucc n =>
  rw [neg_negSucc, bodd_coe, Nat.bodd_succ]
  change (!Nat.bodd n) = !(bodd n)
  rw [bodd_coe]
state_before: n : ℤ
⊢ (-n).bodd = n.bodd
state_after: no goals

tactic: rw [← negOfNat_eq, bodd_negOfNat]
state_before: case ofNat
a✝ : ℕ
⊢ (-ofNat a✝).bodd = (ofNat a✝).bodd
state_after: case ofNat
a✝ : ℕ
⊢ a✝.bodd = (ofNat a✝).bodd

tactic: simp
state_before: case ofNat
a✝ : ℕ
⊢ a✝.bodd = (ofNat a✝).bodd
state_after: no goals

tactic: rw [neg_negSucc, bodd_coe, Nat.bodd_succ]
state_before: case negSucc
n : ℕ
⊢ (- -[n+1]).bodd = -[n+1].bodd
state_after: case negSucc
n : ℕ
⊢ (!n.bodd) = -[n+1].bodd

tactic: change (!Nat.bodd n) = !(bodd n)
state_before: case negSucc
n : ℕ
⊢ (!n.bodd) = -[n+1].bodd
state_after: case negSucc
n : ℕ
⊢ (!n.bodd) = !(↑n).bodd

tactic: rw [bodd_coe]
state_before: case negSucc
n : ℕ
⊢ (!n.bodd) = !(↑n).bodd
state_after: no goals
Theorem: Cardinal.lift_le_aleph0
File: Mathlib/SetTheory/Cardinal/Basic.lean

tactic: rw [← lift_aleph0.{v, u}, lift_le]
state_before: α β : Type u
c : Cardinal.{u}
⊢ lift.{v, u} c ≤ ℵ₀ ↔ c ≤ ℵ₀
state_after: no goals
Theorem: absorbs_iff_eventually_nhdsWithin_zero
File: Mathlib/Analysis/LocallyConvex/Basic.lean

tactic: rw [absorbs_iff_eventually_cobounded_mapsTo, ← Filter.inv_cobounded₀]
state_before: 𝕜 : Type u_1
𝕝 : Type u_2
E : Type u_3
ι : Sort u_4
κ : ι → Sort u_5
inst✝² : NormedDivisionRing 𝕜
inst✝¹ : AddCommGroup E
inst✝ : Module 𝕜 E
s t : Set E
x : E
a b : 𝕜
⊢ Absorbs 𝕜 s t ↔ ∀ᶠ (c : 𝕜) in 𝓝[≠] 0, MapsTo (fun x => c • x) t s
state_after: 𝕜 : Type u_1
𝕝 : Type u_2
E : Type u_3
ι : Sort u_4
κ : ι → Sort u_5
inst✝² : NormedDivisionRing 𝕜
inst✝¹ : AddCommGroup E
inst✝ : Module 𝕜 E
s t : Set E
x : E
a b : 𝕜
⊢ (∀ᶠ (c : 𝕜) in Bornology.cobounded 𝕜, MapsTo (fun x => c⁻¹ • x) t s) ↔
    ∀ᶠ (c : 𝕜) in (Bornology.cobounded 𝕜)⁻¹, MapsTo (fun x => c • x) t s

tactic: rfl
state_before: 𝕜 : Type u_1
𝕝 : Type u_2
E : Type u_3
ι : Sort u_4
κ : ι → Sort u_5
inst✝² : NormedDivisionRing 𝕜
inst✝¹ : AddCommGroup E
inst✝ : Module 𝕜 E
s t : Set E
x : E
a b : 𝕜
⊢ (∀ᶠ (c : 𝕜) in Bornology.cobounded 𝕜, MapsTo (fun x => c⁻¹ • x) t s) ↔
    ∀ᶠ (c : 𝕜) in (Bornology.cobounded 𝕜)⁻¹, MapsTo (fun x => c • x) t s
state_after: no goals
Theorem: IsSMulRegular.subsingleton
File: Mathlib/Algebra/Regular/SMul.lean

tactic: dsimp only [Function.comp_def]
state_before: R : Type u_1
S : Type u_2
M : Type u_3
a✝ b✝ : R
s : S
inst✝⁶ : MonoidWithZero R
inst✝⁵ : MonoidWithZero S
inst✝⁴ : Zero M
inst✝³ : MulActionWithZero R M
inst✝² : MulActionWithZero R S
inst✝¹ : MulActionWithZero S M
inst✝ : IsScalarTower R S M
h : IsSMulRegular M 0
a b : M
⊢ (fun x => 0 • x) a = (fun x => 0 • x) b
state_after: R : Type u_1
S : Type u_2
M : Type u_3
a✝ b✝ : R
s : S
inst✝⁶ : MonoidWithZero R
inst✝⁵ : MonoidWithZero S
inst✝⁴ : Zero M
inst✝³ : MulActionWithZero R M
inst✝² : MulActionWithZero R S
inst✝¹ : MulActionWithZero S M
inst✝ : IsScalarTower R S M
h : IsSMulRegular M 0
a b : M
⊢ 0 • a = 0 • b

tactic: repeat' rw [MulActionWithZero.zero_smul]
state_before: R : Type u_1
S : Type u_2
M : Type u_3
a✝ b✝ : R
s : S
inst✝⁶ : MonoidWithZero R
inst✝⁵ : MonoidWithZero S
inst✝⁴ : Zero M
inst✝³ : MulActionWithZero R M
inst✝² : MulActionWithZero R S
inst✝¹ : MulActionWithZero S M
inst✝ : IsScalarTower R S M
h : IsSMulRegular M 0
a b : M
⊢ 0 • a = 0 • b
state_after: no goals

tactic: rw [MulActionWithZero.zero_smul]
state_before: R : Type u_1
S : Type u_2
M : Type u_3
a✝ b✝ : R
s : S
inst✝⁶ : MonoidWithZero R
inst✝⁵ : MonoidWithZero S
inst✝⁴ : Zero M
inst✝³ : MulActionWithZero R M
inst✝² : MulActionWithZero R S
inst✝¹ : MulActionWithZero S M
inst✝ : IsScalarTower R S M
h : IsSMulRegular M 0
a b : M
⊢ 0 = 0 • b
state_after: no goals
Theorem: Monotone.monotone_iterate_of_le_map
File: Mathlib/Order/Iterate.lean

tactic: rw [iterate_succ_apply]
state_before: α : Type u_1
inst✝ : Preorder α
f : α → α
x : α
hf : Monotone f
hx : x ≤ f x
n : ℕ
⊢ f^[n] x ≤ f^[n + 1] x
state_after: α : Type u_1
inst✝ : Preorder α
f : α → α
x : α
hf : Monotone f
hx : x ≤ f x
n : ℕ
⊢ f^[n] x ≤ f^[n] (f x)

tactic: exact hf.iterate n hx
state_before: α : Type u_1
inst✝ : Preorder α
f : α → α
x : α
hf : Monotone f
hx : x ≤ f x
n : ℕ
⊢ f^[n] x ≤ f^[n] (f x)
state_after: no goals
Theorem: Ideal.multiset_prod_span_singleton
File: Mathlib/RingTheory/Ideal/Operations.lean

tactic: simp
state_before: R : Type u
ι : Type u_1
inst✝ : CommSemiring R
I J K L : Ideal R
m : Multiset R
⊢ (Multiset.map (fun x => span {x}) 0).prod = span {Multiset.prod 0}
state_after: no goals

tactic: simp only [Multiset.map_cons, Multiset.prod_cons, ih, ← Ideal.span_singleton_mul_span_singleton]
state_before: R : Type u
ι : Type u_1
inst✝ : CommSemiring R
I J K L : Ideal R
m✝ : Multiset R
a : R
m : Multiset R
ih : (Multiset.map (fun x => span {x}) m).prod = span {m.prod}
⊢ (Multiset.map (fun x => span {x}) (a ::ₘ m)).prod = span {(a ::ₘ m).prod}
state_after: no goals
Theorem: FiberBundleCore.mem_localTrivAsPartialEquiv_target
File: Mathlib/Topology/FiberBundle/Basic.lean

tactic: erw [mem_prod]
state_before: ι : Type u_1
B : Type u_2
F : Type u_3
X : Type u_4
inst✝² : TopologicalSpace X
inst✝¹ : TopologicalSpace B
inst✝ : TopologicalSpace F
Z : FiberBundleCore ι B F
i : ι
p : B × F
⊢ p ∈ (Z.localTrivAsPartialEquiv i).target ↔ p.1 ∈ Z.baseSet i
state_after: ι : Type u_1
B : Type u_2
F : Type u_3
X : Type u_4
inst✝² : TopologicalSpace X
inst✝¹ : TopologicalSpace B
inst✝ : TopologicalSpace F
Z : FiberBundleCore ι B F
i : ι
p : B × F
⊢ p.1 ∈ Z.baseSet i ∧ p.2 ∈ univ ↔ p.1 ∈ Z.baseSet i

tactic: simp only [and_true_iff, mem_univ]
state_before: ι : Type u_1
B : Type u_2
F : Type u_3
X : Type u_4
inst✝² : TopologicalSpace X
inst✝¹ : TopologicalSpace B
inst✝ : TopologicalSpace F
Z : FiberBundleCore ι B F
i : ι
p : B × F
⊢ p.1 ∈ Z.baseSet i ∧ p.2 ∈ univ ↔ p.1 ∈ Z.baseSet i
state_after: no goals