1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: Nat.preimage_Ico
File: Mathlib/Algebra/Order/Floor.lean

tactic: ext
state_before: F : Type u_1
α : Type u_2
β : Type u_3
inst✝¹ : LinearOrderedSemiring α
inst✝ : FloorSemiring α
a✝ : α
n : ℕ
a b : α
⊢ Nat.cast ⁻¹' Ico a b = Ico ⌈a⌉₊ ⌈b⌉₊
state_after: case h
F : Type u_1
α : Type u_2
β : Type u_3
inst✝¹ : LinearOrderedSemiring α
inst✝ : FloorSemiring α
a✝ : α
n : ℕ
a b : α
x✝ : ℕ
⊢ x✝ ∈ Nat.cast ⁻¹' Ico a b ↔ x✝ ∈ Ico ⌈a⌉₊ ⌈b⌉₊

tactic: simp [ceil_le, lt_ceil]
state_before: case h
F : Type u_1
α : Type u_2
β : Type u_3
inst✝¹ : LinearOrderedSemiring α
inst✝ : FloorSemiring α
a✝ : α
n : ℕ
a b : α
x✝ : ℕ
⊢ x✝ ∈ Nat.cast ⁻¹' Ico a b ↔ x✝ ∈ Ico ⌈a⌉₊ ⌈b⌉₊
state_after: no goals
Theorem: Finset.subset_smul_finset_iff
File: Mathlib/Data/Finset/Pointwise.lean

tactic: simp_rw [← coe_subset]
state_before: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝² : DecidableEq β
inst✝¹ : Group α
inst✝ : MulAction α β
s t : Finset β
a : α
b : β
⊢ s ⊆ a • t ↔ a⁻¹ • s ⊆ t
state_after: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝² : DecidableEq β
inst✝¹ : Group α
inst✝ : MulAction α β
s t : Finset β
a : α
b : β
⊢ ↑s ⊆ ↑(a • t) ↔ ↑(a⁻¹ • s) ⊆ ↑t

tactic: push_cast
state_before: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝² : DecidableEq β
inst✝¹ : Group α
inst✝ : MulAction α β
s t : Finset β
a : α
b : β
⊢ ↑s ⊆ ↑(a • t) ↔ ↑(a⁻¹ • s) ⊆ ↑t
state_after: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝² : DecidableEq β
inst✝¹ : Group α
inst✝ : MulAction α β
s t : Finset β
a : α
b : β
⊢ ↑s ⊆ a • ↑t ↔ a⁻¹ • ↑s ⊆ ↑t

tactic: exact Set.subset_set_smul_iff
state_before: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝² : DecidableEq β
inst✝¹ : Group α
inst✝ : MulAction α β
s t : Finset β
a : α
b : β
⊢ ↑s ⊆ a • ↑t ↔ a⁻¹ • ↑s ⊆ ↑t
state_after: no goals
Theorem: AlgebraicGeometry.Scheme.empty_ext
File: Mathlib/AlgebraicGeometry/Limits.lean

tactic: ext a
state_before: X : Scheme
f g : ∅ ⟶ X
⊢ f.val.base = g.val.base
state_after: case w
X : Scheme
f g : ∅ ⟶ X
a : (forget TopCat).obj ↑∅.toPresheafedSpace
⊢ f.val.base a = g.val.base a

tactic: exact PEmpty.elim a
state_before: case w
X : Scheme
f g : ∅ ⟶ X
a : (forget TopCat).obj ↑∅.toPresheafedSpace
⊢ f.val.base a = g.val.base a
state_after: no goals

tactic: aesop_cat
state_before: X : Scheme
f g : ∅ ⟶ X
a : (Opens ↑↑X.toPresheafedSpace)ᵒᵖ
⊢ (f.val.c ≫ whiskerRight (eqToHom ⋯) ∅.presheaf).app a = g.val.c.app a
state_after: no goals
Theorem: Real.volume_Ico
File: Mathlib/MeasureTheory/Measure/Lebesgue/Basic.lean

tactic: simp [volume_val]
state_before: ι : Type u_1
inst✝ : Fintype ι
a b : ℝ
⊢ volume (Ico a b) = ofReal (b - a)
state_after: no goals
Theorem: PadicInt.ker_toZMod
File: Mathlib/NumberTheory/Padics/RingHoms.lean

tactic: ext x
state_before: p : ℕ
hp_prime : Fact (Nat.Prime p)
r : ℚ
x : ℤ_[p]
⊢ RingHom.ker toZMod = maximalIdeal ℤ_[p]
state_after: case h
p : ℕ
hp_prime : Fact (Nat.Prime p)
r : ℚ
x✝ x : ℤ_[p]
⊢ x ∈ RingHom.ker toZMod ↔ x ∈ maximalIdeal ℤ_[p]

tactic: rw [RingHom.mem_ker]
state_before: case h
p : ℕ
hp_prime : Fact (Nat.Prime p)
r : ℚ
x✝ x : ℤ_[p]
⊢ x ∈ RingHom.ker toZMod ↔ x ∈ maximalIdeal ℤ_[p]
state_after: case h
p : ℕ
hp_prime : Fact (Nat.Prime p)
r : ℚ
x✝ x : ℤ_[p]
⊢ toZMod x = 0 ↔ x ∈ maximalIdeal ℤ_[p]

tactic: constructor
state_before: case h
p : ℕ
hp_prime : Fact (Nat.Prime p)
r : ℚ
x✝ x : ℤ_[p]
⊢ toZMod x = 0 ↔ x ∈ maximalIdeal ℤ_[p]
state_after: case h.mp
p : ℕ
hp_prime : Fact (Nat.Prime p)
r : ℚ
x✝ x : ℤ_[p]
⊢ toZMod x = 0 → x ∈ maximalIdeal ℤ_[p]

case h.mpr
p : ℕ
hp_prime : Fact (Nat.Prime p)
r : ℚ
x✝ x : ℤ_[p]
⊢ x ∈ maximalIdeal ℤ_[p] → toZMod x = 0

tactic: intro h
state_before: case h.mp
p : ℕ
hp_prime : Fact (Nat.Prime p)
r : ℚ
x✝ x : ℤ_[p]
⊢ toZMod x = 0 → x ∈ maximalIdeal ℤ_[p]
state_after: case h.mp
p : ℕ
hp_prime : Fact (Nat.Prime p)
r : ℚ
x✝ x : ℤ_[p]
h : toZMod x = 0
⊢ x ∈ maximalIdeal ℤ_[p]

tactic: simpa only [h, ZMod.cast_zero, sub_zero] using toZMod_spec x
state_before: case h.mp
p : ℕ
hp_prime : Fact (Nat.Prime p)
r : ℚ
x✝ x : ℤ_[p]
h : toZMod x = 0
⊢ x ∈ maximalIdeal ℤ_[p]
state_after: no goals

tactic: intro h
state_before: case h.mpr
p : ℕ
hp_prime : Fact (Nat.Prime p)
r : ℚ
x✝ x : ℤ_[p]
⊢ x ∈ maximalIdeal ℤ_[p] → toZMod x = 0
state_after: case h.mpr
p : ℕ
hp_prime : Fact (Nat.Prime p)
r : ℚ
x✝ x : ℤ_[p]
h : x ∈ maximalIdeal ℤ_[p]
⊢ toZMod x = 0

tactic: rw [← sub_zero x] at h
state_before: case h.mpr
p : ℕ
hp_prime : Fact (Nat.Prime p)
r : ℚ
x✝ x : ℤ_[p]
h : x ∈ maximalIdeal ℤ_[p]
⊢ toZMod x = 0
state_after: case h.mpr
p : ℕ
hp_prime : Fact (Nat.Prime p)
r : ℚ
x✝ x : ℤ_[p]
h : x - 0 ∈ maximalIdeal ℤ_[p]
⊢ toZMod x = 0

tactic: dsimp [toZMod, toZModHom]
state_before: case h.mpr
p : ℕ
hp_prime : Fact (Nat.Prime p)
r : ℚ
x✝ x : ℤ_[p]
h : x - 0 ∈ maximalIdeal ℤ_[p]
⊢ toZMod x = 0
state_after: case h.mpr
p : ℕ
hp_prime : Fact (Nat.Prime p)
r : ℚ
x✝ x : ℤ_[p]
h : x - 0 ∈ maximalIdeal ℤ_[p]
⊢ ↑x.zmodRepr = 0

tactic: convert zmod_congr_of_sub_mem_max_ideal x _ 0 _ h
state_before: case h.mpr
p : ℕ
hp_prime : Fact (Nat.Prime p)
r : ℚ
x✝ x : ℤ_[p]
h : x - 0 ∈ maximalIdeal ℤ_[p]
⊢ ↑x.zmodRepr = 0
state_after: case h.e'_3
p : ℕ
hp_prime : Fact (Nat.Prime p)
r : ℚ
x✝ x : ℤ_[p]
h : x - 0 ∈ maximalIdeal ℤ_[p]
⊢ 0 = ↑0

case h.mpr.convert_2
p : ℕ
hp_prime : Fact (Nat.Prime p)
r : ℚ
x✝ x : ℤ_[p]
h : x - 0 ∈ maximalIdeal ℤ_[p]
⊢ x - ↑x.zmodRepr ∈ maximalIdeal ℤ_[p]

tactic: norm_cast
state_before: case h.e'_3
p : ℕ
hp_prime : Fact (Nat.Prime p)
r : ℚ
x✝ x : ℤ_[p]
h : x - 0 ∈ maximalIdeal ℤ_[p]
⊢ 0 = ↑0
state_after: no goals

tactic: apply sub_zmodRepr_mem
state_before: case h.mpr.convert_2
p : ℕ
hp_prime : Fact (Nat.Prime p)
r : ℚ
x✝ x : ℤ_[p]
h : x - 0 ∈ maximalIdeal ℤ_[p]
⊢ x - ↑x.zmodRepr ∈ maximalIdeal ℤ_[p]
state_after: no goals
Theorem: UpperSet.infIrred_iff_of_finite
File: Mathlib/Order/Birkhoff.lean

tactic: refine ⟨fun hs ↦ ?_, ?_⟩
state_before: α : Type u_1
inst✝¹ : PartialOrder α
s : UpperSet α
inst✝ : Finite α
⊢ InfIrred s ↔ ∃ a, Ici a = s
state_after: case refine_1
α : Type u_1
inst✝¹ : PartialOrder α
s : UpperSet α
inst✝ : Finite α
hs : InfIrred s
⊢ ∃ a, Ici a = s

case refine_2
α : Type u_1
inst✝¹ : PartialOrder α
s : UpperSet α
inst✝ : Finite α
⊢ (∃ a, Ici a = s) → InfIrred s

tactic: obtain ⟨a, ha, has⟩ := (s : Set α).toFinite.exists_minimal_wrt id _ (coe_nonempty.2 hs.ne_top)
state_before: case refine_1
α : Type u_1
inst✝¹ : PartialOrder α
s : UpperSet α
inst✝ : Finite α
hs : InfIrred s
⊢ ∃ a, Ici a = s
state_after: case refine_1.intro.intro
α : Type u_1
inst✝¹ : PartialOrder α
s : UpperSet α
inst✝ : Finite α
hs : InfIrred s
a : α
ha : a ∈ ↑s
has : ∀ a' ∈ ↑s, id a' ≤ id a → id a = id a'
⊢ ∃ a, Ici a = s

tactic: exact ⟨a, (hs.2 <| erase_inf_Ici ha <| by simpa [eq_comm] using has).resolve_left
  (lt_erase.2 ha).ne'⟩
state_before: case refine_1.intro.intro
α : Type u_1
inst✝¹ : PartialOrder α
s : UpperSet α
inst✝ : Finite α
hs : InfIrred s
a : α
ha : a ∈ ↑s
has : ∀ a' ∈ ↑s, id a' ≤ id a → id a = id a'
⊢ ∃ a, Ici a = s
state_after: no goals

tactic: simpa [eq_comm] using has
state_before: α : Type u_1
inst✝¹ : PartialOrder α
s : UpperSet α
inst✝ : Finite α
hs : InfIrred s
a : α
ha : a ∈ ↑s
has : ∀ a' ∈ ↑s, id a' ≤ id a → id a = id a'
⊢ ∀ b ∈ s, b ≤ a → b = a
state_after: no goals

tactic: rintro ⟨a, rfl⟩
state_before: case refine_2
α : Type u_1
inst✝¹ : PartialOrder α
s : UpperSet α
inst✝ : Finite α
⊢ (∃ a, Ici a = s) → InfIrred s
state_after: case refine_2.intro
α : Type u_1
inst✝¹ : PartialOrder α
inst✝ : Finite α
a : α
⊢ InfIrred (Ici a)

tactic: exact infIrred_Ici _
state_before: case refine_2.intro
α : Type u_1
inst✝¹ : PartialOrder α
inst✝ : Finite α
a : α
⊢ InfIrred (Ici a)
state_after: no goals
Theorem: ZFSet.not_nonempty_empty
File: Mathlib/SetTheory/ZFC/Basic.lean

tactic: simp [ZFSet.Nonempty]
state_before: ⊢ ¬∅.Nonempty
state_after: no goals
Theorem: padicNormE.nonarchimedean
File: Mathlib/NumberTheory/Padics/PadicNumbers.lean

tactic: dsimp [norm]
state_before: p : ℕ
hp : Fact (Nat.Prime p)
q r : ℚ_[p]
⊢ ‖q + r‖ ≤ max ‖q‖ ‖r‖
state_after: p : ℕ
hp : Fact (Nat.Prime p)
q r : ℚ_[p]
⊢ ↑(padicNormE (q + r)) ≤ max ↑(padicNormE q) ↑(padicNormE r)

tactic: exact mod_cast nonarchimedean' _ _
state_before: p : ℕ
hp : Fact (Nat.Prime p)
q r : ℚ_[p]
⊢ ↑(padicNormE (q + r)) ≤ max ↑(padicNormE q) ↑(padicNormE r)
state_after: no goals
Theorem: LieSubmodule.isCompl_iff_coe_toSubmodule
File: Mathlib/Algebra/Lie/Submodule.lean

tactic: simp only [isCompl_iff, disjoint_iff_coe_toSubmodule, codisjoint_iff_coe_toSubmodule]
state_before: R : Type u
L : Type v
M : Type w
inst✝⁶ : CommRing R
inst✝⁵ : LieRing L
inst✝⁴ : LieAlgebra R L
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
N N' : LieSubmodule R L M
I J : LieIdeal R L
⊢ IsCompl N N' ↔ IsCompl ↑N ↑N'
state_after: no goals
Theorem: ProbabilityTheory.gaussianReal_mul_const
File: Mathlib/Probability/Distributions/Gaussian.lean

tactic: simp_rw [mul_comm _ c]
state_before: μ : ℝ
v : ℝ≥0
Ω : Type
inst✝ : MeasureSpace Ω
X : Ω → ℝ
hX : Measure.map X ℙ = gaussianReal μ v
c : ℝ
⊢ Measure.map (fun ω => X ω * c) ℙ = gaussianReal (c * μ) (⟨c ^ 2, ⋯⟩ * v)
state_after: μ : ℝ
v : ℝ≥0
Ω : Type
inst✝ : MeasureSpace Ω
X : Ω → ℝ
hX : Measure.map X ℙ = gaussianReal μ v
c : ℝ
⊢ Measure.map (fun ω => c * X ω) ℙ = gaussianReal (c * μ) (⟨c ^ 2, ⋯⟩ * v)

tactic: exact gaussianReal_const_mul hX c
state_before: μ : ℝ
v : ℝ≥0
Ω : Type
inst✝ : MeasureSpace Ω
X : Ω → ℝ
hX : Measure.map X ℙ = gaussianReal μ v
c : ℝ
⊢ Measure.map (fun ω => c * X ω) ℙ = gaussianReal (c * μ) (⟨c ^ 2, ⋯⟩ * v)
state_after: no goals
Theorem: CategoryTheory.Limits.IsLimit.conePointsIsoOfNatIso_inv_comp
File: Mathlib/CategoryTheory/Limits/IsLimit.lean

tactic: simp
state_before: J : Type u₁
inst✝² : Category.{v₁, u₁} J
K : Type u₂
inst✝¹ : Category.{v₂, u₂} K
C : Type u₃
inst✝ : Category.{v₃, u₃} C
F✝ : J ⥤ C
t✝ : Cone F✝
F G : J ⥤ C
s : Cone F
t : Cone G
P : IsLimit s
Q : IsLimit t
w : F ≅ G
j : J
⊢ (P.conePointsIsoOfNatIso Q w).inv ≫ s.π.app j = t.π.app j ≫ w.inv.app j
state_after: no goals
Theorem: Set.singleton_subset_singleton
File: Mathlib/Data/Set/Basic.lean

tactic: simp
state_before: α : Type u
β : Type v
γ : Type w
ι : Sort x
a b : α
s s₁ s₂ t t₁ t₂ u : Set α
⊢ {a} ⊆ {b} ↔ a = b
state_after: no goals
Theorem: ClassGroup.mk_mk0
File: Mathlib/RingTheory/ClassGroup.lean

tactic: rw [ClassGroup.mk0, MonoidHom.comp_apply, ← ClassGroup.mk_canonicalEquiv K (FractionRing R),
  FractionalIdeal.map_canonicalEquiv_mk0]
state_before: R : Type u_1
K : Type u_2
L : Type u_3
inst✝¹¹ : CommRing R
inst✝¹⁰ : Field K
inst✝⁹ : Field L
inst✝⁸ : DecidableEq L
inst✝⁷ : Algebra R K
inst✝⁶ : IsFractionRing R K
inst✝⁵ : Algebra K L
inst✝⁴ : FiniteDimensional K L
inst✝³ : Algebra R L
inst✝² : IsScalarTower R K L
inst✝¹ : IsDomain R
inst✝ : IsDedekindDomain R
I : ↥(Ideal R)⁰
⊢ mk ((FractionalIdeal.mk0 K) I) = mk0 I
state_after: no goals
Theorem: IntermediateField.restrictScalars_injective
File: Mathlib/FieldTheory/IntermediateField.lean

tactic: rw [← mem_restrictScalars K, H, mem_restrictScalars]
state_before: K : Type u_1
L : Type u_2
L' : Type u_3
inst✝⁶ : Field K
inst✝⁵ : Field L
inst✝⁴ : Field L'
inst✝³ : Algebra K L
inst✝² : Algebra K L'
S : IntermediateField K L
inst✝¹ : Algebra L' L
inst✝ : IsScalarTower K L' L
U V : IntermediateField L' L
H : restrictScalars K U = restrictScalars K V
x : L
⊢ x ∈ U ↔ x ∈ V
state_after: no goals
Theorem: Real.tendsto_harmonic_sub_log
File: Mathlib/NumberTheory/Harmonic/EulerMascheroni.lean

tactic: apply tendsto_eulerMascheroniSeq'.congr'
state_before: ⊢ Tendsto (fun n => ↑(harmonic n) - log ↑n) atTop (𝓝 eulerMascheroniConstant)
state_after: ⊢ eulerMascheroniSeq' =ᶠ[atTop] fun n => ↑(harmonic n) - log ↑n

tactic: filter_upwards [eventually_ne_atTop 0] with n hn
state_before: ⊢ eulerMascheroniSeq' =ᶠ[atTop] fun n => ↑(harmonic n) - log ↑n
state_after: case h
n : ℕ
hn : n ≠ 0
⊢ eulerMascheroniSeq' n = ↑(harmonic n) - log ↑n

tactic: simp_rw [eulerMascheroniSeq', hn, if_false]
state_before: case h
n : ℕ
hn : n ≠ 0
⊢ eulerMascheroniSeq' n = ↑(harmonic n) - log ↑n
state_after: no goals
Theorem: tendstoLocallyUniformly_iff_forall_tendsto
File: Mathlib/Topology/UniformSpace/UniformConvergence.lean

tactic: simp [← tendstoLocallyUniformlyOn_univ, isOpen_univ.tendstoLocallyUniformlyOn_iff_forall_tendsto]
state_before: α : Type u
β : Type v
γ : Type w
ι : Type x
inst✝¹ : UniformSpace β
F : ι → α → β
f : α → β
s s' : Set α
x : α
p : Filter ι
p' : Filter α
g : ι → α
inst✝ : TopologicalSpace α
⊢ TendstoLocallyUniformly F f p ↔ ∀ (x : α), Tendsto (fun y => (f y.2, F y.1 y.2)) (p ×ˢ 𝓝 x) (𝓤 β)
state_after: no goals
Theorem: Surreal.Multiplication.Args.numeric_P24
File: Mathlib/SetTheory/Surreal/Multiplication.lean

tactic: simp [Args.Numeric, Args.toMultiset]
state_before: x x₁✝ x₂✝ x₃ x' y✝ y₁ y₂ y₃ y' : PGame
x₁ x₂ y : PGame
⊢ (P24 x₁ x₂ y).Numeric ↔ x₁.Numeric ∧ x₂.Numeric ∧ y.Numeric
state_after: no goals
Theorem: Mon_.one_braiding
File: Mathlib/CategoryTheory/Monoidal/Mon_.lean

tactic: simp only [monMonoidalStruct_tensorObj_X, tensor_one, Category.assoc,
  BraidedCategory.braiding_naturality, braiding_tensorUnit_right, Iso.cancel_iso_inv_left]
state_before: C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
X Y : Mon_ C
⊢ (X ⊗ Y).one ≫ (β_ X.X Y.X).hom = (Y ⊗ X).one
state_after: C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
X Y : Mon_ C
⊢ (ρ_ (𝟙_ C)).hom ≫ (λ_ (𝟙_ C)).inv ≫ (Y.one ⊗ X.one) = Y.one ⊗ X.one

tactic: coherence
state_before: C : Type u₁
inst✝² : Category.{v₁, u₁} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
X Y : Mon_ C
⊢ (ρ_ (𝟙_ C)).hom ≫ (λ_ (𝟙_ C)).inv ≫ (Y.one ⊗ X.one) = Y.one ⊗ X.one
state_after: no goals
Theorem: MeasureTheory.measure_union₀
File: Mathlib/MeasureTheory/Measure/NullMeasurable.lean

tactic: rw [← measure_union_add_inter₀ s ht, hd, add_zero]
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
m0 : MeasurableSpace α
μ : Measure α
s t : Set α
ht : NullMeasurableSet t μ
hd : AEDisjoint μ s t
⊢ μ (s ∪ t) = μ s + μ t
state_after: no goals
Theorem: List.Subperm.filter
File: .lake/packages/batteries/Batteries/Data/List/Perm.lean

tactic: let ⟨xs, hp, h⟩ := h
state_before: α : Type u_1
p : α → Bool
l l' : List α
h : l <+~ l'
⊢ List.filter p l <+~ List.filter p l'
state_after: α : Type u_1
p : α → Bool
l l' : List α
h✝ : l <+~ l'
xs : List α
hp : xs ~ l
h : xs <+ l'
⊢ List.filter p l <+~ List.filter p l'

tactic: exact ⟨_, hp.filter p, h.filter p⟩
state_before: α : Type u_1
p : α → Bool
l l' : List α
h✝ : l <+~ l'
xs : List α
hp : xs ~ l
h : xs <+ l'
⊢ List.filter p l <+~ List.filter p l'
state_after: no goals
Theorem: List.append_cons_inj_of_not_mem
File: Mathlib/Data/List/Basic.lean

tactic: constructor
state_before: ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ x₁ x₂ z₁ z₂ : List α
a₁ a₂ : α
notin_x : ¬a₂ ∈ x₁
notin_z : ¬a₂ ∈ z₁
⊢ x₁ ++ a₁ :: z₁ = x₂ ++ a₂ :: z₂ ↔ x₁ = x₂ ∧ a₁ = a₂ ∧ z₁ = z₂
state_after: case mp
ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ x₁ x₂ z₁ z₂ : List α
a₁ a₂ : α
notin_x : ¬a₂ ∈ x₁
notin_z : ¬a₂ ∈ z₁
⊢ x₁ ++ a₁ :: z₁ = x₂ ++ a₂ :: z₂ → x₁ = x₂ ∧ a₁ = a₂ ∧ z₁ = z₂

case mpr
ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ x₁ x₂ z₁ z₂ : List α
a₁ a₂ : α
notin_x : ¬a₂ ∈ x₁
notin_z : ¬a₂ ∈ z₁
⊢ x₁ = x₂ ∧ a₁ = a₂ ∧ z₁ = z₂ → x₁ ++ a₁ :: z₁ = x₂ ++ a₂ :: z₂

tactic: simp only [append_eq_append_iff, cons_eq_append, cons_eq_cons]
state_before: case mp
ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ x₁ x₂ z₁ z₂ : List α
a₁ a₂ : α
notin_x : ¬a₂ ∈ x₁
notin_z : ¬a₂ ∈ z₁
⊢ x₁ ++ a₁ :: z₁ = x₂ ++ a₂ :: z₂ → x₁ = x₂ ∧ a₁ = a₂ ∧ z₁ = z₂
state_after: case mp
ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ x₁ x₂ z₁ z₂ : List α
a₁ a₂ : α
notin_x : ¬a₂ ∈ x₁
notin_z : ¬a₂ ∈ z₁
⊢ ((∃ a', x₂ = x₁ ++ a' ∧ (a' = [] ∧ a₂ = a₁ ∧ z₂ = z₁ ∨ ∃ a'_1, a' = a₁ :: a'_1 ∧ z₁ = a'_1 ++ a₂ :: z₂)) ∨
      ∃ c', x₁ = x₂ ++ c' ∧ (c' = [] ∧ a₁ = a₂ ∧ z₁ = z₂ ∨ ∃ a', c' = a₂ :: a' ∧ z₂ = a' ++ a₁ :: z₁)) →
    x₁ = x₂ ∧ a₁ = a₂ ∧ z₁ = z₂

tactic: rintro (⟨c, rfl, ⟨rfl, rfl, rfl⟩ | ⟨d, rfl, rfl⟩⟩ |
  ⟨c, rfl, ⟨rfl, rfl, rfl⟩ | ⟨d, rfl, rfl⟩⟩) <;> simp_all
state_before: case mp
ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ x₁ x₂ z₁ z₂ : List α
a₁ a₂ : α
notin_x : ¬a₂ ∈ x₁
notin_z : ¬a₂ ∈ z₁
⊢ ((∃ a', x₂ = x₁ ++ a' ∧ (a' = [] ∧ a₂ = a₁ ∧ z₂ = z₁ ∨ ∃ a'_1, a' = a₁ :: a'_1 ∧ z₁ = a'_1 ++ a₂ :: z₂)) ∨
      ∃ c', x₁ = x₂ ++ c' ∧ (c' = [] ∧ a₁ = a₂ ∧ z₁ = z₂ ∨ ∃ a', c' = a₂ :: a' ∧ z₂ = a' ++ a₁ :: z₁)) →
    x₁ = x₂ ∧ a₁ = a₂ ∧ z₁ = z₂
state_after: no goals

tactic: rintro ⟨rfl, rfl, rfl⟩
state_before: case mpr
ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ x₁ x₂ z₁ z₂ : List α
a₁ a₂ : α
notin_x : ¬a₂ ∈ x₁
notin_z : ¬a₂ ∈ z₁
⊢ x₁ = x₂ ∧ a₁ = a₂ ∧ z₁ = z₂ → x₁ ++ a₁ :: z₁ = x₂ ++ a₂ :: z₂
state_after: case mpr.intro.intro
ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ x₁ z₁ : List α
a₁ : α
notin_x : ¬a₁ ∈ x₁
notin_z : ¬a₁ ∈ z₁
⊢ x₁ ++ a₁ :: z₁ = x₁ ++ a₁ :: z₁

tactic: rfl
state_before: case mpr.intro.intro
ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ x₁ z₁ : List α
a₁ : α
notin_x : ¬a₁ ∈ x₁
notin_z : ¬a₁ ∈ z₁
⊢ x₁ ++ a₁ :: z₁ = x₁ ++ a₁ :: z₁
state_after: no goals
Theorem: Nat.image_nth_Iio_card
File: Mathlib/Data/Nat/Nth.lean

tactic: ext x
state_before: p : ℕ → Prop
hf : (setOf p).Finite
⊢ nth p '' Set.Iio hf.toFinset.card = Set.range ⇑(hf.toFinset.orderEmbOfFin ⋯)
state_after: case h
p : ℕ → Prop
hf : (setOf p).Finite
x : ℕ
⊢ x ∈ nth p '' Set.Iio hf.toFinset.card ↔ x ∈ Set.range ⇑(hf.toFinset.orderEmbOfFin ⋯)

tactic: simp only [Set.mem_image, Set.mem_range, Fin.exists_iff, ← nth_eq_orderEmbOfFin hf,
  Set.mem_Iio, exists_prop]
state_before: case h
p : ℕ → Prop
hf : (setOf p).Finite
x : ℕ
⊢ x ∈ nth p '' Set.Iio hf.toFinset.card ↔ x ∈ Set.range ⇑(hf.toFinset.orderEmbOfFin ⋯)
state_after: no goals

tactic: rw [range_orderEmbOfFin, Set.Finite.coe_toFinset]
state_before: p : ℕ → Prop
hf : (setOf p).Finite
⊢ Set.range ⇑(hf.toFinset.orderEmbOfFin ⋯) = setOf p
state_after: no goals
Theorem: Finset.eq_of_mem_of_not_mem_erase
File: Mathlib/Data/Finset/Basic.lean

tactic: rw [mem_erase, not_and] at hsa
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝ : DecidableEq α
s t u v : Finset α
a b : α
hs : b ∈ s
hsa : b ∉ s.erase a
⊢ b = a
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝ : DecidableEq α
s t u v : Finset α
a b : α
hs : b ∈ s
hsa : b ≠ a → b ∉ s
⊢ b = a

tactic: exact not_imp_not.mp hsa hs
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝ : DecidableEq α
s t u v : Finset α
a b : α
hs : b ∈ s
hsa : b ≠ a → b ∉ s
⊢ b = a
state_after: no goals
Theorem: Units.mul_left_eq_zero
File: Mathlib/Algebra/GroupWithZero/Units/Basic.lean

tactic: simpa using mul_eq_zero_of_left h ↑u⁻¹
state_before: α : Type u_1
M₀ : Type u_2
G₀ : Type u_3
M₀' : Type u_4
G₀' : Type u_5
F : Type u_6
F' : Type u_7
inst✝ : MonoidWithZero M₀
u : M₀ˣ
a : M₀
h : a * ↑u = 0
⊢ a = 0
state_after: no goals
Theorem: CategoryTheory.ShortComplex.liftCycles_comp_cyclesMap
File: Mathlib/Algebra/Homology/ShortComplex/LeftHomology.lean

tactic: rw [assoc, φ.comm₂₃, reassoc_of% hk, zero_comp]
state_before: C : Type u_1
inst✝³ : Category.{?u.211357, u_1} C
inst✝² : HasZeroMorphisms C
S S₁ S₂ S₃ : ShortComplex C
h : S.LeftHomologyData
A : C
k : A ⟶ S.X₂
hk : k ≫ S.g = 0
inst✝¹ : S.HasLeftHomology
φ : S ⟶ S₁
inst✝ : S₁.HasLeftHomology
⊢ (k ≫ φ.τ₂) ≫ S₁.g = 0
state_after: no goals

tactic: aesop_cat
state_before: C : Type u_1
inst✝³ : Category.{u_2, u_1} C
inst✝² : HasZeroMorphisms C
S S₁ S₂ S₃ : ShortComplex C
h : S.LeftHomologyData
A : C
k : A ⟶ S.X₂
hk : k ≫ S.g = 0
inst✝¹ : S.HasLeftHomology
φ : S ⟶ S₁
inst✝ : S₁.HasLeftHomology
⊢ S.liftCycles k hk ≫ cyclesMap φ = S₁.liftCycles (k ≫ φ.τ₂) ⋯
state_after: no goals
Theorem: FreeLieAlgebra.hom_ext
File: Mathlib/Algebra/Lie/Free.lean

tactic: ext
state_before: R : Type u
X : Type v
inst✝² : CommRing R
L : Type w
inst✝¹ : LieRing L
inst✝ : LieAlgebra R L
F₁ F₂ : FreeLieAlgebra R X →ₗ⁅R⁆ L
h : ∀ (x : X), F₁ (of R x) = F₂ (of R x)
⊢ (lift R).symm F₁ = (lift R).symm F₂
state_after: case h
R : Type u
X : Type v
inst✝² : CommRing R
L : Type w
inst✝¹ : LieRing L
inst✝ : LieAlgebra R L
F₁ F₂ : FreeLieAlgebra R X →ₗ⁅R⁆ L
h : ∀ (x : X), F₁ (of R x) = F₂ (of R x)
x✝ : X
⊢ (lift R).symm F₁ x✝ = (lift R).symm F₂ x✝

tactic: simp [h]
state_before: case h
R : Type u
X : Type v
inst✝² : CommRing R
L : Type w
inst✝¹ : LieRing L
inst✝ : LieAlgebra R L
F₁ F₂ : FreeLieAlgebra R X →ₗ⁅R⁆ L
h : ∀ (x : X), F₁ (of R x) = F₂ (of R x)
x✝ : X
⊢ (lift R).symm F₁ x✝ = (lift R).symm F₂ x✝
state_after: no goals
Theorem: Field.nonempty_iff
File: Mathlib/FieldTheory/Cardinality.lean

tactic: rw [Cardinal.isPrimePow_iff]
state_before: α : Type u
⊢ Nonempty (Field α) ↔ IsPrimePow #α
state_after: α : Type u
⊢ Nonempty (Field α) ↔ ℵ₀ ≤ #α ∨ ∃ n, #α = ↑n ∧ IsPrimePow n

tactic: cases' fintypeOrInfinite α with h h
state_before: α : Type u
⊢ Nonempty (Field α) ↔ ℵ₀ ≤ #α ∨ ∃ n, #α = ↑n ∧ IsPrimePow n
state_after: case inl
α : Type u
h : Fintype α
⊢ Nonempty (Field α) ↔ ℵ₀ ≤ #α ∨ ∃ n, #α = ↑n ∧ IsPrimePow n

case inr
α : Type u
h : Infinite α
⊢ Nonempty (Field α) ↔ ℵ₀ ≤ #α ∨ ∃ n, #α = ↑n ∧ IsPrimePow n

tactic: simpa only [Cardinal.mk_fintype, Nat.cast_inj, exists_eq_left',
  (Cardinal.nat_lt_aleph0 _).not_le, false_or_iff] using Fintype.nonempty_field_iff
state_before: case inl
α : Type u
h : Fintype α
⊢ Nonempty (Field α) ↔ ℵ₀ ≤ #α ∨ ∃ n, #α = ↑n ∧ IsPrimePow n
state_after: no goals

tactic: simpa only [← Cardinal.infinite_iff, h, true_or_iff, iff_true_iff] using Infinite.nonempty_field
state_before: case inr
α : Type u
h : Infinite α
⊢ Nonempty (Field α) ↔ ℵ₀ ≤ #α ∨ ∃ n, #α = ↑n ∧ IsPrimePow n
state_after: no goals
Theorem: Real.arctan_ne_mul_pi_div_two
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Arctan.lean

tactic: by_contra!
state_before: x : ℝ
⊢ ∀ (k : ℤ), arctan x ≠ (2 * ↑k + 1) * π / 2
state_after: x : ℝ
this : ∃ k, arctan x = (2 * ↑k + 1) * π / 2
⊢ False

tactic: obtain ⟨k, h⟩ := this
state_before: x : ℝ
this : ∃ k, arctan x = (2 * ↑k + 1) * π / 2
⊢ False
state_after: case intro
x : ℝ
k : ℤ
h : arctan x = (2 * ↑k + 1) * π / 2
⊢ False

tactic: obtain ⟨lb, ub⟩ := arctan_mem_Ioo x
state_before: case intro
x : ℝ
k : ℤ
h : arctan x = (2 * ↑k + 1) * π / 2
⊢ False
state_after: case intro.intro
x : ℝ
k : ℤ
h : arctan x = (2 * ↑k + 1) * π / 2
lb : -(π / 2) < arctan x
ub : arctan x < π / 2
⊢ False

tactic: rw [h, neg_eq_neg_one_mul, mul_div_assoc, mul_lt_mul_right (by positivity)] at lb
state_before: case intro.intro
x : ℝ
k : ℤ
h : arctan x = (2 * ↑k + 1) * π / 2
lb : -(π / 2) < arctan x
ub : arctan x < π / 2
⊢ False
state_after: case intro.intro
x : ℝ
k : ℤ
h : arctan x = (2 * ↑k + 1) * π / 2
lb : -1 < 2 * ↑k + 1
ub : arctan x < π / 2
⊢ False

tactic: rw [h, ← one_mul (π / 2), mul_div_assoc, mul_lt_mul_right (by positivity)] at ub
state_before: case intro.intro
x : ℝ
k : ℤ
h : arctan x = (2 * ↑k + 1) * π / 2
lb : -1 < 2 * ↑k + 1
ub : arctan x < π / 2
⊢ False
state_after: case intro.intro
x : ℝ
k : ℤ
h : arctan x = (2 * ↑k + 1) * π / 2
lb : -1 < 2 * ↑k + 1
ub : 2 * ↑k + 1 < 1
⊢ False

tactic: norm_cast at lb ub
state_before: case intro.intro
x : ℝ
k : ℤ
h : arctan x = (2 * ↑k + 1) * π / 2
lb : -1 < 2 * ↑k + 1
ub : 2 * ↑k + 1 < 1
⊢ False
state_after: case intro.intro
x : ℝ
k : ℤ
h : arctan x = (2 * ↑k + 1) * π / 2
lb : Int.negSucc 0 < 2 * k + 1
ub : 2 * k + 1 < 1
⊢ False

tactic: change -1 < _ at lb
state_before: case intro.intro
x : ℝ
k : ℤ
h : arctan x = (2 * ↑k + 1) * π / 2
lb : Int.negSucc 0 < 2 * k + 1
ub : 2 * k + 1 < 1
⊢ False
state_after: case intro.intro
x : ℝ
k : ℤ
h : arctan x = (2 * ↑k + 1) * π / 2
ub : 2 * k + 1 < 1
lb : -1 < 2 * k + 1
⊢ False

tactic: omega
state_before: case intro.intro
x : ℝ
k : ℤ
h : arctan x = (2 * ↑k + 1) * π / 2
ub : 2 * k + 1 < 1
lb : -1 < 2 * k + 1
⊢ False
state_after: no goals

tactic: positivity
state_before: x : ℝ
k : ℤ
h : arctan x = (2 * ↑k + 1) * π / 2
lb : -1 * (π / 2) < (2 * ↑k + 1) * (π / 2)
ub : arctan x < π / 2
⊢ 0 < π / 2
state_after: no goals

tactic: positivity
state_before: x : ℝ
k : ℤ
h : arctan x = (2 * ↑k + 1) * π / 2
lb : -1 < 2 * ↑k + 1
ub : (2 * ↑k + 1) * (π / 2) < 1 * (π / 2)
⊢ 0 < π / 2
state_after: no goals