1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: Matrix.SpecialLinearGroup.fin_two_induction
File: Mathlib/LinearAlgebra/Matrix/SpecialLinearGroup.lean

tactic: rwa [det_fin_two_of]
state_before: n : Type u
inst✝³ : DecidableEq n
inst✝² : Fintype n
R : Type v
inst✝¹ : CommRing R
S : Type u_1
inst✝ : CommRing S
P : SL(2, R) → Prop
a b c d : R
hdet : a * d - b * c = 1
⊢ (of ![![a, b], ![c, d]]).det = 1
state_after: no goals

tactic: obtain ⟨m, hm⟩ := g
state_before: n : Type u
inst✝³ : DecidableEq n
inst✝² : Fintype n
R : Type v
inst✝¹ : CommRing R
S : Type u_1
inst✝ : CommRing S
P : SL(2, R) → Prop
h : ∀ (a b c d : R) (hdet : a * d - b * c = 1), P ⟨of ![![a, b], ![c, d]], ⋯⟩
g : SL(2, R)
⊢ P g
state_after: case mk
n : Type u
inst✝³ : DecidableEq n
inst✝² : Fintype n
R : Type v
inst✝¹ : CommRing R
S : Type u_1
inst✝ : CommRing S
P : SL(2, R) → Prop
h : ∀ (a b c d : R) (hdet : a * d - b * c = 1), P ⟨of ![![a, b], ![c, d]], ⋯⟩
m : Matrix (Fin 2) (Fin 2) R
hm : m.det = 1
⊢ P ⟨m, hm⟩

tactic: convert h (m 0 0) (m 0 1) (m 1 0) (m 1 1) (by rwa [det_fin_two] at hm)
state_before: case mk
n : Type u
inst✝³ : DecidableEq n
inst✝² : Fintype n
R : Type v
inst✝¹ : CommRing R
S : Type u_1
inst✝ : CommRing S
P : SL(2, R) → Prop
h : ∀ (a b c d : R) (hdet : a * d - b * c = 1), P ⟨of ![![a, b], ![c, d]], ⋯⟩
m : Matrix (Fin 2) (Fin 2) R
hm : m.det = 1
⊢ P ⟨m, hm⟩
state_after: case h.e'_1.h.e'_3
n : Type u
inst✝³ : DecidableEq n
inst✝² : Fintype n
R : Type v
inst✝¹ : CommRing R
S : Type u_1
inst✝ : CommRing S
P : SL(2, R) → Prop
h : ∀ (a b c d : R) (hdet : a * d - b * c = 1), P ⟨of ![![a, b], ![c, d]], ⋯⟩
m : Matrix (Fin 2) (Fin 2) R
hm : m.det = 1
⊢ m = of ![![m 0 0, m 0 1], ![m 1 0, m 1 1]]

tactic: ext i j
state_before: case h.e'_1.h.e'_3
n : Type u
inst✝³ : DecidableEq n
inst✝² : Fintype n
R : Type v
inst✝¹ : CommRing R
S : Type u_1
inst✝ : CommRing S
P : SL(2, R) → Prop
h : ∀ (a b c d : R) (hdet : a * d - b * c = 1), P ⟨of ![![a, b], ![c, d]], ⋯⟩
m : Matrix (Fin 2) (Fin 2) R
hm : m.det = 1
⊢ m = of ![![m 0 0, m 0 1], ![m 1 0, m 1 1]]
state_after: case h.e'_1.h.e'_3.a
n : Type u
inst✝³ : DecidableEq n
inst✝² : Fintype n
R : Type v
inst✝¹ : CommRing R
S : Type u_1
inst✝ : CommRing S
P : SL(2, R) → Prop
h : ∀ (a b c d : R) (hdet : a * d - b * c = 1), P ⟨of ![![a, b], ![c, d]], ⋯⟩
m : Matrix (Fin 2) (Fin 2) R
hm : m.det = 1
i j : Fin 2
⊢ m i j = of ![![m 0 0, m 0 1], ![m 1 0, m 1 1]] i j

tactic: fin_cases i <;> fin_cases j <;> rfl
state_before: case h.e'_1.h.e'_3.a
n : Type u
inst✝³ : DecidableEq n
inst✝² : Fintype n
R : Type v
inst✝¹ : CommRing R
S : Type u_1
inst✝ : CommRing S
P : SL(2, R) → Prop
h : ∀ (a b c d : R) (hdet : a * d - b * c = 1), P ⟨of ![![a, b], ![c, d]], ⋯⟩
m : Matrix (Fin 2) (Fin 2) R
hm : m.det = 1
i j : Fin 2
⊢ m i j = of ![![m 0 0, m 0 1], ![m 1 0, m 1 1]] i j
state_after: no goals

tactic: rwa [det_fin_two] at hm
state_before: n : Type u
inst✝³ : DecidableEq n
inst✝² : Fintype n
R : Type v
inst✝¹ : CommRing R
S : Type u_1
inst✝ : CommRing S
P : SL(2, R) → Prop
h : ∀ (a b c d : R) (hdet : a * d - b * c = 1), P ⟨of ![![a, b], ![c, d]], ⋯⟩
m : Matrix (Fin 2) (Fin 2) R
hm : m.det = 1
⊢ m 0 0 * m 1 1 - m 0 1 * m 1 0 = 1
state_after: no goals
Theorem: ArithmeticFunction.zeta_mul_vonMangoldt
File: Mathlib/NumberTheory/VonMangoldt.lean

tactic: rw [mul_comm]
state_before: ⊢ ↑ζ * Λ = log
state_after: ⊢ Λ * ↑ζ = log

tactic: simp
state_before: ⊢ Λ * ↑ζ = log
state_after: no goals
Theorem: Setoid.classes_ker_subset_fiber_set
File: Mathlib/Data/Setoid/Partition.lean

tactic: rintro s ⟨x, rfl⟩
state_before: α : Type u_1
β : Type u_2
f : α → β
⊢ (ker f).classes ⊆ Set.range fun y => {x | f x = y}
state_after: case intro
α : Type u_1
β : Type u_2
f : α → β
x : α
⊢ {x_1 | (ker f).Rel x_1 x} ∈ Set.range fun y => {x | f x = y}

tactic: rw [Set.mem_range]
state_before: case intro
α : Type u_1
β : Type u_2
f : α → β
x : α
⊢ {x_1 | (ker f).Rel x_1 x} ∈ Set.range fun y => {x | f x = y}
state_after: case intro
α : Type u_1
β : Type u_2
f : α → β
x : α
⊢ ∃ y, {x | f x = y} = {x_1 | (ker f).Rel x_1 x}

tactic: exact ⟨f x, rfl⟩
state_before: case intro
α : Type u_1
β : Type u_2
f : α → β
x : α
⊢ ∃ y, {x | f x = y} = {x_1 | (ker f).Rel x_1 x}
state_after: no goals
Theorem: IsCyclotomicExtension.discr_prime_pow_ne_two'
File: Mathlib/NumberTheory/Cyclotomic/Discriminant.lean

tactic: simpa [totient_prime_pow hp.out (succ_pos k)] using discr_prime_pow_ne_two hζ hirr hk
state_before: p : ℕ+
k : ℕ
K : Type u
L : Type v
ζ : L
inst✝³ : Field K
inst✝² : Field L
inst✝¹ : Algebra K L
inst✝ : IsCyclotomicExtension {p ^ (k + 1)} K L
hp : Fact (Nat.Prime ↑p)
hζ : IsPrimitiveRoot ζ ↑(p ^ (k + 1))
hirr : Irreducible (cyclotomic (↑(p ^ (k + 1))) K)
hk : p ^ (k + 1) ≠ 2
⊢ discr K ⇑(IsPrimitiveRoot.powerBasis K hζ).basis =
    (-1) ^ (↑p ^ k * (↑p - 1) / 2) * ↑↑p ^ (↑p ^ k * ((↑p - 1) * (k + 1) - 1))
state_after: no goals
Theorem: CategoryTheory.Pseudofunctor.map₂_inv_hom
File: Mathlib/CategoryTheory/Bicategory/Functor/Pseudofunctor.lean

tactic: simp
state_before: B : Type u₁
inst✝³ : Bicategory B
C : Type u₂
inst✝² : Bicategory C
D : Type u₃
inst✝¹ : Bicategory D
F : Pseudofunctor B C
a b : B
f g : a ⟶ b
η : f ⟶ g
inst✝ : IsIso η
⊢ F.map₂ (inv η) ≫ F.map₂ η = 𝟙 ((↑F.toPrelaxFunctor).map g)
state_after: no goals
Theorem: MeasureTheory.snorm_le_of_ae_bound
File: Mathlib/MeasureTheory/Function/LpSeminorm/Basic.lean

tactic: rw [← mul_comm]
state_before: α : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedAddCommGroup G
f : α → F
C : ℝ
hfC : ∀ᵐ (x : α) ∂μ, ‖f x‖ ≤ C
⊢ snorm f p μ ≤ μ Set.univ ^ p.toReal⁻¹ * ENNReal.ofReal C
state_after: α : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedAddCommGroup G
f : α → F
C : ℝ
hfC : ∀ᵐ (x : α) ∂μ, ‖f x‖ ≤ C
⊢ snorm f p μ ≤ ENNReal.ofReal C * μ Set.univ ^ p.toReal⁻¹

tactic: exact snorm_le_of_ae_nnnorm_bound (hfC.mono fun x hx => hx.trans C.le_coe_toNNReal)
state_before: α : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedAddCommGroup G
f : α → F
C : ℝ
hfC : ∀ᵐ (x : α) ∂μ, ‖f x‖ ≤ C
⊢ snorm f p μ ≤ ENNReal.ofReal C * μ Set.univ ^ p.toReal⁻¹
state_after: no goals
Theorem: inv_smul_smul
File: Mathlib/GroupTheory/GroupAction/Group.lean

tactic: rw [smul_smul, mul_left_inv, one_smul]
state_before: α : Type u
β : Type v
γ : Type w
inst✝¹ : Group α
inst✝ : MulAction α β
c : α
x : β
⊢ c⁻¹ • c • x = x
state_after: no goals
Theorem: intervalIntegral.intervalIntegrable_one_div_one_add_sq
File: Mathlib/Analysis/SpecialFunctions/Integrals.lean

tactic: refine (continuous_const.div ?_ fun x => ?_).intervalIntegrable a b
state_before: a b : ℝ
n : ℕ
f : ℝ → ℝ
μ ν : Measure ℝ
inst✝ : IsLocallyFiniteMeasure μ
c d : ℝ
⊢ IntervalIntegrable (fun x => 1 / (1 + x ^ 2)) μ a b
state_after: case refine_1
a b : ℝ
n : ℕ
f : ℝ → ℝ
μ ν : Measure ℝ
inst✝ : IsLocallyFiniteMeasure μ
c d : ℝ
⊢ Continuous fun x => 1 + x ^ 2

case refine_2
a b : ℝ
n : ℕ
f : ℝ → ℝ
μ ν : Measure ℝ
inst✝ : IsLocallyFiniteMeasure μ
c d x : ℝ
⊢ 1 + x ^ 2 ≠ 0

tactic: fun_prop
state_before: case refine_1
a b : ℝ
n : ℕ
f : ℝ → ℝ
μ ν : Measure ℝ
inst✝ : IsLocallyFiniteMeasure μ
c d : ℝ
⊢ Continuous fun x => 1 + x ^ 2
state_after: no goals

tactic: nlinarith
state_before: case refine_2
a b : ℝ
n : ℕ
f : ℝ → ℝ
μ ν : Measure ℝ
inst✝ : IsLocallyFiniteMeasure μ
c d x : ℝ
⊢ 1 + x ^ 2 ≠ 0
state_after: no goals
Theorem: Complex.arg_le_pi_div_two_iff
File: Mathlib/Analysis/SpecialFunctions/Complex/Arg.lean

tactic: rcases le_or_lt 0 (re z) with hre | hre
state_before: a x z✝ z : ℂ
⊢ z.arg ≤ π / 2 ↔ 0 ≤ z.re ∨ z.im < 0
state_after: case inl
a x z✝ z : ℂ
hre : 0 ≤ z.re
⊢ z.arg ≤ π / 2 ↔ 0 ≤ z.re ∨ z.im < 0

case inr
a x z✝ z : ℂ
hre : z.re < 0
⊢ z.arg ≤ π / 2 ↔ 0 ≤ z.re ∨ z.im < 0

tactic: simp only [hre.not_le, false_or_iff]
state_before: case inr
a x z✝ z : ℂ
hre : z.re < 0
⊢ z.arg ≤ π / 2 ↔ 0 ≤ z.re ∨ z.im < 0
state_after: case inr
a x z✝ z : ℂ
hre : z.re < 0
⊢ z.arg ≤ π / 2 ↔ z.im < 0

tactic: rcases le_or_lt 0 (im z) with him | him
state_before: case inr
a x z✝ z : ℂ
hre : z.re < 0
⊢ z.arg ≤ π / 2 ↔ z.im < 0
state_after: case inr.inl
a x z✝ z : ℂ
hre : z.re < 0
him : 0 ≤ z.im
⊢ z.arg ≤ π / 2 ↔ z.im < 0

case inr.inr
a x z✝ z : ℂ
hre : z.re < 0
him : z.im < 0
⊢ z.arg ≤ π / 2 ↔ z.im < 0

tactic: simp only [hre, arg_of_re_nonneg hre, Real.arcsin_le_pi_div_two, true_or_iff]
state_before: case inl
a x z✝ z : ℂ
hre : 0 ≤ z.re
⊢ z.arg ≤ π / 2 ↔ 0 ≤ z.re ∨ z.im < 0
state_after: no goals

tactic: simp only [him.not_lt]
state_before: case inr.inl
a x z✝ z : ℂ
hre : z.re < 0
him : 0 ≤ z.im
⊢ z.arg ≤ π / 2 ↔ z.im < 0
state_after: case inr.inl
a x z✝ z : ℂ
hre : z.re < 0
him : 0 ≤ z.im
⊢ z.arg ≤ π / 2 ↔ False

tactic: rw [iff_false_iff, not_le, arg_of_re_neg_of_im_nonneg hre him, ← sub_lt_iff_lt_add, half_sub,
  Real.neg_pi_div_two_lt_arcsin, neg_im, neg_div, neg_lt_neg_iff, div_lt_one, ←
  _root_.abs_of_nonneg him, abs_im_lt_abs]
state_before: case inr.inl
a x z✝ z : ℂ
hre : z.re < 0
him : 0 ≤ z.im
⊢ z.arg ≤ π / 2 ↔ False
state_after: case inr.inl
a x z✝ z : ℂ
hre : z.re < 0
him : 0 ≤ z.im
⊢ z.re ≠ 0

case inr.inl
a x z✝ z : ℂ
hre : z.re < 0
him : 0 ≤ z.im
⊢ 0 < abs z

tactic: exacts [hre.ne, abs.pos <| ne_of_apply_ne re hre.ne]
state_before: case inr.inl
a x z✝ z : ℂ
hre : z.re < 0
him : 0 ≤ z.im
⊢ z.re ≠ 0

case inr.inl
a x z✝ z : ℂ
hre : z.re < 0
him : 0 ≤ z.im
⊢ 0 < abs z
state_after: no goals

tactic: simp only [him]
state_before: case inr.inr
a x z✝ z : ℂ
hre : z.re < 0
him : z.im < 0
⊢ z.arg ≤ π / 2 ↔ z.im < 0
state_after: case inr.inr
a x z✝ z : ℂ
hre : z.re < 0
him : z.im < 0
⊢ z.arg ≤ π / 2 ↔ True

tactic: rw [iff_true_iff, arg_of_re_neg_of_im_neg hre him]
state_before: case inr.inr
a x z✝ z : ℂ
hre : z.re < 0
him : z.im < 0
⊢ z.arg ≤ π / 2 ↔ True
state_after: case inr.inr
a x z✝ z : ℂ
hre : z.re < 0
him : z.im < 0
⊢ Real.arcsin ((-z).im / abs z) - π ≤ π / 2

tactic: exact (sub_le_self _ Real.pi_pos.le).trans (Real.arcsin_le_pi_div_two _)
state_before: case inr.inr
a x z✝ z : ℂ
hre : z.re < 0
him : z.im < 0
⊢ Real.arcsin ((-z).im / abs z) - π ≤ π / 2
state_after: no goals
Theorem: EuclideanDomain.eq_div_of_mul_eq_left
File: Mathlib/Algebra/EuclideanDomain/Basic.lean

tactic: rw [← h, mul_div_cancel_right₀ _ hb]
state_before: R : Type u
inst✝ : EuclideanDomain R
a b c : R
hb : b ≠ 0
h : a * b = c
⊢ a = c / b
state_after: no goals
Theorem: Set.prod_diff_prod
File: Mathlib/Data/Set/Prod.lean

tactic: ext x
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
s s₁ s₂ : Set α
t t₁ t₂ : Set β
a : α
b : β
⊢ s ×ˢ t \ s₁ ×ˢ t₁ = s ×ˢ (t \ t₁) ∪ (s \ s₁) ×ˢ t
state_after: case h
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
s s₁ s₂ : Set α
t t₁ t₂ : Set β
a : α
b : β
x : α × β
⊢ x ∈ s ×ˢ t \ s₁ ×ˢ t₁ ↔ x ∈ s ×ˢ (t \ t₁) ∪ (s \ s₁) ×ˢ t

tactic: by_cases h₁ : x.1 ∈ s₁ <;> by_cases h₂ : x.2 ∈ t₁ <;> simp [*]
state_before: case h
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
s s₁ s₂ : Set α
t t₁ t₂ : Set β
a : α
b : β
x : α × β
⊢ x ∈ s ×ˢ t \ s₁ ×ˢ t₁ ↔ x ∈ s ×ˢ (t \ t₁) ∪ (s \ s₁) ×ˢ t
state_after: no goals
Theorem: Real.sin_nat_mul_pi_sub
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Basic.lean

tactic: simpa only [sin_neg, mul_neg] using sin_antiperiodic.nat_mul_sub_eq n
state_before: x : ℝ
n : ℕ
⊢ sin (↑n * π - x) = -((-1) ^ n * sin x)
state_after: no goals
Theorem: Rep.ρ_self_inv_apply
File: Mathlib/RepresentationTheory/Rep.lean

tactic: rw [← map_mul, mul_inv_self, map_one, LinearMap.one_apply]
state_before: k G✝ : Type u
inst✝² : CommRing k
inst✝¹ : Monoid G✝
G : Type u
inst✝ : Group G
A : Rep k G
g : G
x : CoeSort.coe A
⊢ (A.ρ g * A.ρ g⁻¹) x = x
state_after: no goals
Theorem: Nat.one_le_pow
File: Mathlib/Data/Nat/Defs.lean

tactic: simpa using Nat.pow_le_pow_of_le_left h n
state_before: a b c d m✝ n✝ k : ℕ
p q : ℕ → Prop
n m : ℕ
h : 0 < m
⊢ 1 ≤ m ^ n
state_after: no goals
Theorem: MeromorphicAt.zpow
File: Mathlib/Analysis/Analytic/Meromorphic.lean

tactic: induction' n with m m
state_before: 𝕜 : Type u_1
inst✝² : NontriviallyNormedField 𝕜
E : Type u_2
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
f : 𝕜 → 𝕜
x : 𝕜
hf : MeromorphicAt f x
n : ℤ
⊢ MeromorphicAt (f ^ n) x
state_after: case ofNat
𝕜 : Type u_1
inst✝² : NontriviallyNormedField 𝕜
E : Type u_2
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
f : 𝕜 → 𝕜
x : 𝕜
hf : MeromorphicAt f x
m : ℕ
⊢ MeromorphicAt (f ^ Int.ofNat m) x

case negSucc
𝕜 : Type u_1
inst✝² : NontriviallyNormedField 𝕜
E : Type u_2
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
f : 𝕜 → 𝕜
x : 𝕜
hf : MeromorphicAt f x
m : ℕ
⊢ MeromorphicAt (f ^ Int.negSucc m) x

tactic: simpa only [Int.ofNat_eq_coe, zpow_natCast] using hf.pow m
state_before: case ofNat
𝕜 : Type u_1
inst✝² : NontriviallyNormedField 𝕜
E : Type u_2
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
f : 𝕜 → 𝕜
x : 𝕜
hf : MeromorphicAt f x
m : ℕ
⊢ MeromorphicAt (f ^ Int.ofNat m) x
state_after: no goals

tactic: simpa only [zpow_negSucc, inv_iff] using hf.pow (m + 1)
state_before: case negSucc
𝕜 : Type u_1
inst✝² : NontriviallyNormedField 𝕜
E : Type u_2
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
f : 𝕜 → 𝕜
x : 𝕜
hf : MeromorphicAt f x
m : ℕ
⊢ MeromorphicAt (f ^ Int.negSucc m) x
state_after: no goals
Theorem: Real.sqrt_eq_iff_mul_self_eq
File: Mathlib/Data/Real/Sqrt.lean

tactic: rw [← h, mul_self_sqrt hx]
state_before: x y : ℝ
hx : 0 ≤ x
hy : 0 ≤ y
h : √x = y
⊢ y * y = x
state_after: no goals

tactic: rw [← h, sqrt_mul_self hy]
state_before: x y : ℝ
hx : 0 ≤ x
hy : 0 ≤ y
h : y * y = x
⊢ √x = y
state_after: no goals
Theorem: List.head!_le_of_lt
File: Mathlib/Data/List/Lex.lean

tactic: by_cases hl : l = []
state_before: α : Type u
inst✝¹ : Preorder α
inst✝ : Inhabited α
l l' : List α
hl' : l' ≠ []
h : Lex (fun x x_1 => x < x_1) l' l
⊢ l'.head! ≤ l.head!
state_after: case pos
α : Type u
inst✝¹ : Preorder α
inst✝ : Inhabited α
l l' : List α
hl' : l' ≠ []
h : Lex (fun x x_1 => x < x_1) l' l
hl : l = []
⊢ l'.head! ≤ l.head!

case neg
α : Type u
inst✝¹ : Preorder α
inst✝ : Inhabited α
l l' : List α
hl' : l' ≠ []
h : Lex (fun x x_1 => x < x_1) l' l
hl : ¬l = []
⊢ l'.head! ≤ l.head!

tactic: simp [hl] at h
state_before: case pos
α : Type u
inst✝¹ : Preorder α
inst✝ : Inhabited α
l l' : List α
hl' : l' ≠ []
h : Lex (fun x x_1 => x < x_1) l' l
hl : l = []
⊢ l'.head! ≤ l.head!
state_after: no goals

tactic: rw [← List.cons_head!_tail hl', ← List.cons_head!_tail hl] at h
state_before: case neg
α : Type u
inst✝¹ : Preorder α
inst✝ : Inhabited α
l l' : List α
hl' : l' ≠ []
h : Lex (fun x x_1 => x < x_1) l' l
hl : ¬l = []
⊢ l'.head! ≤ l.head!
state_after: case neg
α : Type u
inst✝¹ : Preorder α
inst✝ : Inhabited α
l l' : List α
hl' : l' ≠ []
h : Lex (fun x x_1 => x < x_1) (l'.head! :: l'.tail) (l.head! :: l.tail)
hl : ¬l = []
⊢ l'.head! ≤ l.head!

tactic: exact head_le_of_lt h
state_before: case neg
α : Type u
inst✝¹ : Preorder α
inst✝ : Inhabited α
l l' : List α
hl' : l' ≠ []
h : Lex (fun x x_1 => x < x_1) (l'.head! :: l'.tail) (l.head! :: l.tail)
hl : ¬l = []
⊢ l'.head! ≤ l.head!
state_after: no goals
Theorem: exists_countable_dense_no_bot_top
File: Mathlib/Topology/Order/DenselyOrdered.lean

tactic: simpa using dense_univ.exists_countable_dense_subset_no_bot_top
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝⁵ : TopologicalSpace α
inst✝⁴ : LinearOrder α
inst✝³ : OrderTopology α
inst✝² : DenselyOrdered α
a b : α
s : Set α
l : Filter β
f : α → β
inst✝¹ : SeparableSpace α
inst✝ : Nontrivial α
⊢ ∃ s, s.Countable ∧ Dense s ∧ (∀ (x : α), IsBot x → x ∉ s) ∧ ∀ (x : α), IsTop x → x ∉ s
state_after: no goals
Theorem: Module.End.isNilpotent.restrict
File: Mathlib/RingTheory/Nilpotent/Lemmas.lean

tactic: obtain ⟨n, hn⟩ := hnil
state_before: R✝ : Type u_1
S : Type u_2
x y : R✝
R : Type u_3
M : Type u_4
inst✝² : Semiring R
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
f : M →ₗ[R] M
p : Submodule R M
hf : MapsTo ⇑f ↑p ↑p
hnil : IsNilpotent f
⊢ IsNilpotent (f.restrict hf)
state_after: case intro
R✝ : Type u_1
S : Type u_2
x y : R✝
R : Type u_3
M : Type u_4
inst✝² : Semiring R
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
f : M →ₗ[R] M
p : Submodule R M
hf : MapsTo ⇑f ↑p ↑p
n : ℕ
hn : f ^ n = 0
⊢ IsNilpotent (f.restrict hf)

tactic: exact ⟨n, LinearMap.ext fun m ↦ by simp [LinearMap.pow_restrict n, LinearMap.restrict_apply, hn]⟩
state_before: case intro
R✝ : Type u_1
S : Type u_2
x y : R✝
R : Type u_3
M : Type u_4
inst✝² : Semiring R
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
f : M →ₗ[R] M
p : Submodule R M
hf : MapsTo ⇑f ↑p ↑p
n : ℕ
hn : f ^ n = 0
⊢ IsNilpotent (f.restrict hf)
state_after: no goals

tactic: simp [LinearMap.pow_restrict n, LinearMap.restrict_apply, hn]
state_before: R✝ : Type u_1
S : Type u_2
x y : R✝
R : Type u_3
M : Type u_4
inst✝² : Semiring R
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
f : M →ₗ[R] M
p : Submodule R M
hf : MapsTo ⇑f ↑p ↑p
n : ℕ
hn : f ^ n = 0
m : ↥p
⊢ (f.restrict hf ^ n) m = 0 m
state_after: no goals
Theorem: MeasureTheory.MeasurePreserving.ergodic_conjugate_iff
File: Mathlib/Dynamics/Ergodic/Ergodic.lean

tactic: have : MeasurePreserving (e ∘ f ∘ e.symm) μ' μ' ↔ MeasurePreserving f μ μ := by
  rw [h.comp_left_iff, (MeasurePreserving.symm e h).comp_right_iff]
state_before: α : Type u_1
m : MeasurableSpace α
f : α → α
s : Set α
μ : Measure α
β : Type u_2
m' : MeasurableSpace β
μ' : Measure β
s' : Set β
g : α → β
e : α ≃ᵐ β
h : MeasurePreserving (⇑e) μ μ'
⊢ Ergodic (⇑e ∘ f ∘ ⇑e.symm) μ' ↔ Ergodic f μ
state_after: α : Type u_1
m : MeasurableSpace α
f : α → α
s : Set α
μ : Measure α
β : Type u_2
m' : MeasurableSpace β
μ' : Measure β
s' : Set β
g : α → β
e : α ≃ᵐ β
h : MeasurePreserving (⇑e) μ μ'
this : MeasurePreserving (⇑e ∘ f ∘ ⇑e.symm) μ' μ' ↔ MeasurePreserving f μ μ
⊢ Ergodic (⇑e ∘ f ∘ ⇑e.symm) μ' ↔ Ergodic f μ

tactic: replace h : PreErgodic (e ∘ f ∘ e.symm) μ' ↔ PreErgodic f μ := h.preErgodic_conjugate_iff
state_before: α : Type u_1
m : MeasurableSpace α
f : α → α
s : Set α
μ : Measure α
β : Type u_2
m' : MeasurableSpace β
μ' : Measure β
s' : Set β
g : α → β
e : α ≃ᵐ β
h : MeasurePreserving (⇑e) μ μ'
this : MeasurePreserving (⇑e ∘ f ∘ ⇑e.symm) μ' μ' ↔ MeasurePreserving f μ μ
⊢ Ergodic (⇑e ∘ f ∘ ⇑e.symm) μ' ↔ Ergodic f μ
state_after: α : Type u_1
m : MeasurableSpace α
f : α → α
s : Set α
μ : Measure α
β : Type u_2
m' : MeasurableSpace β
μ' : Measure β
s' : Set β
g : α → β
e : α ≃ᵐ β
this : MeasurePreserving (⇑e ∘ f ∘ ⇑e.symm) μ' μ' ↔ MeasurePreserving f μ μ
h : PreErgodic (⇑e ∘ f ∘ ⇑e.symm) μ' ↔ PreErgodic f μ
⊢ Ergodic (⇑e ∘ f ∘ ⇑e.symm) μ' ↔ Ergodic f μ

tactic: exact ⟨fun hf => { this.mp hf.toMeasurePreserving, h.mp hf.toPreErgodic with },
  fun hf => { this.mpr hf.toMeasurePreserving, h.mpr hf.toPreErgodic with }⟩
state_before: α : Type u_1
m : MeasurableSpace α
f : α → α
s : Set α
μ : Measure α
β : Type u_2
m' : MeasurableSpace β
μ' : Measure β
s' : Set β
g : α → β
e : α ≃ᵐ β
this : MeasurePreserving (⇑e ∘ f ∘ ⇑e.symm) μ' μ' ↔ MeasurePreserving f μ μ
h : PreErgodic (⇑e ∘ f ∘ ⇑e.symm) μ' ↔ PreErgodic f μ
⊢ Ergodic (⇑e ∘ f ∘ ⇑e.symm) μ' ↔ Ergodic f μ
state_after: no goals

tactic: rw [h.comp_left_iff, (MeasurePreserving.symm e h).comp_right_iff]
state_before: α : Type u_1
m : MeasurableSpace α
f : α → α
s : Set α
μ : Measure α
β : Type u_2
m' : MeasurableSpace β
μ' : Measure β
s' : Set β
g : α → β
e : α ≃ᵐ β
h : MeasurePreserving (⇑e) μ μ'
⊢ MeasurePreserving (⇑e ∘ f ∘ ⇑e.symm) μ' μ' ↔ MeasurePreserving f μ μ
state_after: no goals
Theorem: MonoidHom.coprod_unique
File: Mathlib/Algebra/Group/Prod.lean

tactic: simp [coprod_apply, inl_apply, inr_apply, ← map_mul]
state_before: A : Type u_1
B : Type u_2
G : Type u_3
H : Type u_4
M : Type u_5
N : Type u_6
P : Type u_7
inst✝² : MulOneClass M
inst✝¹ : MulOneClass N
inst✝ : CommMonoid P
f✝ : M →* P
g : N →* P
f : M × N →* P
x : M × N
⊢ ((f.comp (inl M N)).coprod (f.comp (inr M N))) x = f x
state_after: no goals
Theorem: QPF.corecF_eq
File: Mathlib/Data/QPF/Univariate/Basic.lean

tactic: rw [corecF, PFunctor.M.dest_corec]
state_before: F : Type u → Type u
q : QPF F
α : Type u
g : α → F α
x : α
⊢ (corecF g x).dest = (P F).map (corecF g) (repr (g x))
state_after: no goals
Theorem: Finsupp.single_eq_zero
File: Mathlib/Data/Finsupp/Defs.lean

tactic: simp [DFunLike.ext_iff, single_eq_set_indicator]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
M : Type u_5
M' : Type u_6
N : Type u_7
P : Type u_8
G : Type u_9
H : Type u_10
R : Type u_11
S : Type u_12
inst✝ : Zero M
a a' : α
b : M
⊢ single a b = 0 ↔ b = 0
state_after: no goals
Theorem: MvPowerSeries.add_mul
File: Mathlib/RingTheory/MvPowerSeries/Basic.lean

tactic: classical simp only [coeff_mul, add_mul, Finset.sum_add_distrib, LinearMap.map_add]
state_before: σ : Type u_1
R : Type u_2
inst✝ : Semiring R
m n✝ : σ →₀ ℕ
φ ψ φ₁ φ₂ φ₃ : MvPowerSeries σ R
n : σ →₀ ℕ
⊢ (coeff R n) ((φ₁ + φ₂) * φ₃) = (coeff R n) (φ₁ * φ₃ + φ₂ * φ₃)
state_after: no goals

tactic: simp only [coeff_mul, add_mul, Finset.sum_add_distrib, LinearMap.map_add]
state_before: σ : Type u_1
R : Type u_2
inst✝ : Semiring R
m n✝ : σ →₀ ℕ
φ ψ φ₁ φ₂ φ₃ : MvPowerSeries σ R
n : σ →₀ ℕ
⊢ (coeff R n) ((φ₁ + φ₂) * φ₃) = (coeff R n) (φ₁ * φ₃ + φ₂ * φ₃)
state_after: no goals
Theorem: Set.LeftInvOn.image_image
File: Mathlib/Data/Set/Function.lean

tactic: rw [Set.image_image, image_congr hf, image_id']
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
π : α → Type u_5
s s₁ s₂ : Set α
t t₁ t₂ : Set β
p : Set γ
f f₁ f₂ f₃ : α → β
g g₁ g₂ : β → γ
f' f₁' f₂' : β → α
g' : γ → β
a : α
b : β
hf : LeftInvOn f' f s
⊢ f' '' (f '' s) = s
state_after: no goals
Theorem: Set.diff_singleton_subset_iff
File: Mathlib/Data/Set/Basic.lean

tactic: rw [← union_singleton, union_comm]
state_before: α : Type u
β : Type v
γ : Type w
ι : Sort x
a b : α
s✝ s₁ s₂ t✝ t₁ t₂ u : Set α
x : α
s t : Set α
⊢ s \ {x} ⊆ t ↔ s ⊆ insert x t
state_after: α : Type u
β : Type v
γ : Type w
ι : Sort x
a b : α
s✝ s₁ s₂ t✝ t₁ t₂ u : Set α
x : α
s t : Set α
⊢ s \ {x} ⊆ t ↔ s ⊆ {x} ∪ t

tactic: apply diff_subset_iff
state_before: α : Type u
β : Type v
γ : Type w
ι : Sort x
a b : α
s✝ s₁ s₂ t✝ t₁ t₂ u : Set α
x : α
s t : Set α
⊢ s \ {x} ⊆ t ↔ s ⊆ {x} ∪ t
state_after: no goals
Theorem: Cardinal.aleph0_le_mul_iff
File: Mathlib/SetTheory/Cardinal/Basic.lean

tactic: let h := (@mul_lt_aleph0_iff a b).not
state_before: α β : Type u
a b : Cardinal.{u_1}
⊢ ℵ₀ ≤ a * b ↔ a ≠ 0 ∧ b ≠ 0 ∧ (ℵ₀ ≤ a ∨ ℵ₀ ≤ b)
state_after: α β : Type u
a b : Cardinal.{u_1}
h : ¬a * b < ℵ₀ ↔ ¬(a = 0 ∨ b = 0 ∨ a < ℵ₀ ∧ b < ℵ₀) := Iff.not mul_lt_aleph0_iff
⊢ ℵ₀ ≤ a * b ↔ a ≠ 0 ∧ b ≠ 0 ∧ (ℵ₀ ≤ a ∨ ℵ₀ ≤ b)

tactic: rwa [not_lt, not_or, not_or, not_and_or, not_lt, not_lt] at h
state_before: α β : Type u
a b : Cardinal.{u_1}
h : ¬a * b < ℵ₀ ↔ ¬(a = 0 ∨ b = 0 ∨ a < ℵ₀ ∧ b < ℵ₀) := Iff.not mul_lt_aleph0_iff
⊢ ℵ₀ ≤ a * b ↔ a ≠ 0 ∧ b ≠ 0 ∧ (ℵ₀ ≤ a ∨ ℵ₀ ≤ b)
state_after: no goals
Theorem: zpowersEquivZPowers_apply
File: Mathlib/GroupTheory/OrderOfElement.lean

tactic: rw [zpowersEquivZPowers, Equiv.trans_apply, Equiv.trans_apply, finEquivZPowers_symm_apply, ←
  Equiv.eq_symm_apply, finEquivZPowers_symm_apply]
state_before: G : Type u_1
H : Type u_2
A : Type u_3
α : Type u_4
β : Type u_5
inst✝¹ : Group G
inst✝ : Finite G
x y : G
h : orderOf x = orderOf y
n : ℕ
⊢ (zpowersEquivZPowers h) ⟨x ^ n, ⋯⟩ = ⟨y ^ n, ⋯⟩
state_after: G : Type u_1
H : Type u_2
A : Type u_3
α : Type u_4
β : Type u_5
inst✝¹ : Group G
inst✝ : Finite G
x y : G
h : orderOf x = orderOf y
n : ℕ
⊢ (finCongr h) ⟨n % orderOf x, ⋯⟩ = ⟨n % orderOf y, ⋯⟩

tactic: simp [h]
state_before: G : Type u_1
H : Type u_2
A : Type u_3
α : Type u_4
β : Type u_5
inst✝¹ : Group G
inst✝ : Finite G
x y : G
h : orderOf x = orderOf y
n : ℕ
⊢ (finCongr h) ⟨n % orderOf x, ⋯⟩ = ⟨n % orderOf y, ⋯⟩
state_after: no goals