tasksource/leandojo huggingface dataset:
Theorem: Ordinal.nfp_le_iff
File: Mathlib/SetTheory/Ordinal/FixedPoint.lean

tactic: rw [← sup_iterate_eq_nfp]
state_before: f : Ordinal → Ordinal
a b : Ordinal
⊢ nfp f a ≤ b ↔ ∀ (n : ℕ), (f^[n]) a ≤ b

tactic: exact sup_le_iff
state_before: f : Ordinal → Ordinal
a b : Ordinal
⊢ (fun a => sup fun n => (f^[n]) a) a ≤ b ↔ ∀ (n : ℕ), (f^[n]) a ≤ b
Theorem: MeasureTheory.integrable_average
File: Mathlib/MeasureTheory/Function/L1Space.lean

tactic: simp [h]
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.854853
δ : Type ?u.854856
m : MeasurableSpace α
μ ν : Measure α
inst✝³ : MeasurableSpace δ
inst✝² : NormedAddCommGroup β
inst✝¹ : NormedAddCommGroup γ
inst✝ : IsFiniteMeasure μ
f : α → β
h : μ = 0
⊢ Integrable f ↔ Integrable f
Theorem: IsLocalizedModule.mk'_cancel
File: Mathlib/Algebra/Module/LocalizedModule.lean

tactic: delta mk'
state_before: R : Type u_1
inst✝⁷ : CommRing R
S : Submonoid R
M : Type u_3
M' : Type u_2
M'' : Type ?u.831370
inst✝⁶ : AddCommMonoid M
inst✝⁵ : AddCommMonoid M'
inst✝⁴ : AddCommMonoid M''
inst✝³ : Module R M
inst✝² : Module R M'
inst✝¹ : Module R M''
f : M →ₗ[R] M'
g : M →ₗ[R] M''
inst✝ : IsLocalizedModule S f
m : M
s : { x // x ∈ S }
⊢ mk' f (s • m) s = ↑f m

tactic: rw [LocalizedModule.mk_cancel, ← mk'_one S f]
state_before: R : Type u_1
inst✝⁷ : CommRing R
S : Submonoid R
M : Type u_3
M' : Type u_2
M'' : Type ?u.831370
inst✝⁶ : AddCommMonoid M
inst✝⁵ : AddCommMonoid M'
inst✝⁴ : AddCommMonoid M''
inst✝³ : Module R M
inst✝² : Module R M'
inst✝¹ : Module R M''
f : M →ₗ[R] M'
g : M →ₗ[R] M''
inst✝ : IsLocalizedModule S f
m : M
s : { x // x ∈ S }
⊢ ↑(fromLocalizedModule S f) (LocalizedModule.mk (s • m) s) = ↑f m

tactic: rfl
state_before: R : Type u_1
inst✝⁷ : CommRing R
S : Submonoid R
M : Type u_3
M' : Type u_2
M'' : Type ?u.831370
inst✝⁶ : AddCommMonoid M
inst✝⁵ : AddCommMonoid M'
inst✝⁴ : AddCommMonoid M''
inst✝³ : Module R M
inst✝² : Module R M'
inst✝¹ : Module R M''
f : M →ₗ[R] M'
g : M →ₗ[R] M''
inst✝ : IsLocalizedModule S f
m : M
s : { x // x ∈ S }
⊢ ↑(fromLocalizedModule S f) (LocalizedModule.mk m 1) = mk' f m 1
Theorem: Function.Involutive.exists_mem_and_apply_eq_iff
File: Mathlib/Data/List/Basic.lean

tactic: rintro ⟨y, h, rfl⟩
state_before: ι : Type ?u.2112
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α
f : α → α
hf : Involutive f
x : α
l : List α
⊢ (∃ y, y ∈ l ∧ f y = x) → f x ∈ l

tactic: rwa [hf y]
state_before: case intro.intro
ι : Type ?u.2112
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α
f : α → α
hf : Involutive f
l : List α
y : α
h : y ∈ l
⊢ f (f y) ∈ l
Theorem: spectrum.scalar_eq
File: Mathlib/Algebra/Algebra/Spectrum.lean

tactic: rw [← add_zero (↑ₐ k), ← singleton_add_eq, zero_eq, Set.singleton_add_singleton, add_zero]
state_before: 𝕜 : Type u
A : Type v
inst✝³ : Field 𝕜
inst✝² : Ring A
inst✝¹ : Algebra 𝕜 A
inst✝ : Nontrivial A
k : 𝕜
⊢ σ (↑↑ₐ k) = {k}
Theorem: Nat.div_eq_of_eq_mul_left
File: Std/Data/Nat/Lemmas.lean

tactic: rw [H2, Nat.mul_div_cancel _ H1]
state_before: n m k : Nat
H1 : 0 < n
H2 : m = k * n
⊢ m / n = k
Theorem: Rat.divInt_eq_zero
File: Mathlib/Data/Rat/Defs.lean

tactic: rw [←zero_divInt b, divInt_eq_iff b0 b0, zero_mul, mul_eq_zero, or_iff_left b0]
state_before: a b : ℤ
b0 : b ≠ 0
⊢ a /. b = 0 ↔ a = 0
Theorem: Complex.log_exp
File: Mathlib/Analysis/SpecialFunctions/Complex/Log.lean

tactic: rw [log, abs_exp, Real.log_exp, exp_eq_exp_re_mul_sin_add_cos, ← ofReal_exp,
  arg_mul_cos_add_sin_mul_I (Real.exp_pos _) ⟨hx₁, hx₂⟩, re_add_im]
state_before: x : ℂ
hx₁ : -π < x.im
hx₂ : x.im ≤ π
⊢ log (exp x) = x
Theorem: Matrix.sum_elim_dotProduct_sum_elim
File: Mathlib/Data/Matrix/Basic.lean

tactic: simp [dotProduct]
state_before: l : Type ?u.141692
m : Type u_2
n : Type u_1
o : Type ?u.141701
m' : o → Type ?u.141706
n' : o → Type ?u.141711
R : Type ?u.141714
S : Type ?u.141717
α : Type v
β : Type w
γ : Type ?u.141724
inst✝² : Fintype m
inst✝¹ : Fintype n
inst✝ : NonUnitalNonAssocSemiring α
u v w : m → α
x y : n → α
⊢ Sum.elim u x ⬝ᵥ Sum.elim v y = u ⬝ᵥ v + x ⬝ᵥ y
Theorem: List.getD_replicate_default_eq
File: Mathlib/Data/List/Basic.lean

tactic: induction' r with r IH generalizing n
state_before: ι : Type ?u.502826
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ l : List α
x : α
xs : List α
d : α
n✝ r n : ℕ
⊢ getD (replicate r d) n d = d

tactic: simp
state_before: case zero
ι : Type ?u.502826
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ l : List α
x : α
xs : List α
d : α
n✝¹ n✝ n : ℕ
⊢ getD (replicate zero d) n d = d

tactic: cases n <;> simp [IH]
state_before: case succ
ι : Type ?u.502826
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ l : List α
x : α
xs : List α
d : α
n✝¹ n✝ r : ℕ
IH : ∀ (n : ℕ), getD (replicate r d) n d = d
n : ℕ
⊢ getD (replicate (succ r) d) n d = d
Theorem: PGame.moveLeft_neg_symm'
File: Mathlib/SetTheory/Game/PGame.lean

tactic: simp
state_before: x : PGame
i : LeftMoves x
⊢ moveLeft x i = -moveRight (-x) (↑toRightMovesNeg i)
Theorem: EuclideanDomain.gcdA_zero_left
File: Mathlib/Algebra/EuclideanDomain/Defs.lean

tactic: unfold gcdA
state_before: R : Type u
inst✝¹ : EuclideanDomain R
inst✝ : DecidableEq R
s : R
⊢ gcdA 0 s = 0

tactic: rw [xgcd, xgcd_zero_left]
state_before: R : Type u
inst✝¹ : EuclideanDomain R
inst✝ : DecidableEq R
s : R
⊢ (xgcd 0 s).fst = 0
Theorem: IsIntegrallyClosed.integralClosure_eq_bot_iff
File: Mathlib/RingTheory/IntegrallyClosed.lean

tactic: refine' eq_bot_iff.trans _
state_before: R : Type u_2
inst✝² : CommRing R
id : IsDomain R
iic : IsIntegrallyClosed R
K : Type u_1
inst✝¹ : Field K
inst✝ : Algebra R K
ifr : IsFractionRing R K
⊢ integralClosure R K = ⊥ ↔ IsIntegrallyClosed R

tactic: constructor
state_before: R : Type u_2
inst✝² : CommRing R
id : IsDomain R
iic : IsIntegrallyClosed R
K : Type u_1
inst✝¹ : Field K
inst✝ : Algebra R K
ifr : IsFractionRing R K
⊢ integralClosure R K ≤ ⊥ ↔ IsIntegrallyClosed R

tactic: rw [isIntegrallyClosed_iff K]
state_before: case mp
R : Type u_2
inst✝² : CommRing R
id : IsDomain R
iic : IsIntegrallyClosed R
K : Type u_1
inst✝¹ : Field K
inst✝ : Algebra R K
ifr : IsFractionRing R K
⊢ integralClosure R K ≤ ⊥ → IsIntegrallyClosed R

tactic: intro h x hx
state_before: case mp
R : Type u_2
inst✝² : CommRing R
id : IsDomain R
iic : IsIntegrallyClosed R
K : Type u_1
inst✝¹ : Field K
inst✝ : Algebra R K
ifr : IsFractionRing R K
⊢ integralClosure R K ≤ ⊥ → ∀ {x : K}, IsIntegral R x → ∃ y, ↑(algebraMap R K) y = x

tactic: exact Set.mem_range.mp (Algebra.mem_bot.mp (h hx))
state_before: case mp
R : Type u_2
inst✝² : CommRing R
id : IsDomain R
iic : IsIntegrallyClosed R
K : Type u_1
inst✝¹ : Field K
inst✝ : Algebra R K
ifr : IsFractionRing R K
h : integralClosure R K ≤ ⊥
x : K
hx : IsIntegral R x
⊢ ∃ y, ↑(algebraMap R K) y = x

tactic: intro h x hx
state_before: case mpr
R : Type u_2
inst✝² : CommRing R
id : IsDomain R
iic : IsIntegrallyClosed R
K : Type u_1
inst✝¹ : Field K
inst✝ : Algebra R K
ifr : IsFractionRing R K
⊢ IsIntegrallyClosed R → integralClosure R K ≤ ⊥

tactic: rw [Algebra.mem_bot, Set.mem_range]
state_before: case mpr
R : Type u_2
inst✝² : CommRing R
id : IsDomain R
iic : IsIntegrallyClosed R
K : Type u_1
inst✝¹ : Field K
inst✝ : Algebra R K
ifr : IsFractionRing R K
h : IsIntegrallyClosed R
x : K
hx : x ∈ integralClosure R K
⊢ x ∈ ⊥

tactic: exact isIntegral_iff.mp hx
state_before: case mpr
R : Type u_2
inst✝² : CommRing R
id : IsDomain R
iic : IsIntegrallyClosed R
K : Type u_1
inst✝¹ : Field K
inst✝ : Algebra R K
ifr : IsFractionRing R K
h : IsIntegrallyClosed R
x : K
hx : x ∈ integralClosure R K
⊢ ∃ y, ↑(algebraMap R K) y = x
Theorem: le_mul_iff_one_le_left
File: Mathlib/Algebra/Order/Ring/Lemmas.lean

tactic: rw [one_mul]
state_before: α : Type u_1
a b c d : α
inst✝⁴ : MulOneClass α
inst✝³ : Zero α
inst✝² : Preorder α
inst✝¹ : MulPosMono α
inst✝ : MulPosMonoRev α
a0 : 0 < a
⊢ a ≤ b * a ↔ 1 * a ≤ b * a
Theorem: Directed.sequence_mono_nat
File: Mathlib/Logic/Encodable/Basic.lean

tactic: dsimp [Directed.sequence]
state_before: α : Type u_2
β : Type u_1
inst✝¹ : Encodable α
inst✝ : Inhabited α
r : β → β → Prop
f : α → β
hf : Directed r f
n : ℕ
⊢ r (f (Directed.sequence f hf n)) (f (Directed.sequence f hf (n + 1)))

tactic: generalize eq : hf.sequence f n = p
state_before: α : Type u_2
β : Type u_1
inst✝¹ : Encodable α
inst✝ : Inhabited α
r : β → β → Prop
f : α → β
hf : Directed r f
n : ℕ
⊢ r (f (Directed.sequence f hf n))
    (f
      (match decode (n + 0) with
      | none =>
        Classical.choose
          (_ : ∃ z, r (f (Directed.sequence f hf (n + 0))) (f z) ∧ r (f (Directed.sequence f hf (n + 0))) (f z))
      | some a => Classical.choose (_ : ∃ z, r (f (Directed.sequence f hf (n + 0))) (f z) ∧ r (f a) (f z))))

tactic: cases' h : (decode n: Option α) with a
state_before: α : Type u_2
β : Type u_1
inst✝¹ : Encodable α
inst✝ : Inhabited α
r : β → β → Prop
f : α → β
hf : Directed r f
n : ℕ
p : α
eq : Directed.sequence f hf n = p
⊢ r (f p)
    (f
      (match decode (n + 0) with
      | none => Classical.choose (_ : ∃ z, r (f p) (f z) ∧ r (f p) (f z))
      | some a => Classical.choose (_ : ∃ z, r (f p) (f z) ∧ r (f a) (f z))))

tactic: exact (Classical.choose_spec (hf p p)).1
state_before: case none
α : Type u_2
β : Type u_1
inst✝¹ : Encodable α
inst✝ : Inhabited α
r : β → β → Prop
f : α → β
hf : Directed r f
n : ℕ
p : α
eq : Directed.sequence f hf n = p
h : decode n = none
⊢ r (f p)
    (f
      (match none with
      | none => Classical.choose (_ : ∃ z, r (f p) (f z) ∧ r (f p) (f z))
      | some a => Classical.choose (_ : ∃ z, r (f p) (f z) ∧ r (f a) (f z))))

tactic: exact (Classical.choose_spec (hf p a)).1
state_before: case some
α : Type u_2
β : Type u_1
inst✝¹ : Encodable α
inst✝ : Inhabited α
r : β → β → Prop
f : α → β
hf : Directed r f
n : ℕ
p : α
eq : Directed.sequence f hf n = p
a : α
h : decode n = some a
⊢ r (f p)
    (f
      (match some a with
      | none => Classical.choose (_ : ∃ z, r (f p) (f z) ∧ r (f p) (f z))
      | some a => Classical.choose (_ : ∃ z, r (f p) (f z) ∧ r (f a) (f z))))
Theorem: mul_add_one
File: Mathlib/Algebra/Ring/Defs.lean

tactic: rw [mul_add, mul_one]
state_before: α : Type u
β : Type v
γ : Type w
R : Type x
inst✝² : Add α
inst✝¹ : MulOneClass α
inst✝ : LeftDistribClass α
a b : α
⊢ a * (b + 1) = a * b + a
Theorem: toIocDiv_sub_zsmul'
File: Mathlib/Algebra/Order/ToIntervalMod.lean

tactic: rw [sub_eq_add_neg, ← neg_smul, toIocDiv_add_zsmul', sub_neg_eq_add]
state_before: α : Type u_1
inst✝ : LinearOrderedAddCommGroup α
hα : Archimedean α
p : α
hp : 0 < p
a✝ b✝ c : α
n : ℤ
a b : α
m : ℤ
⊢ toIocDiv hp (a - m • p) b = toIocDiv hp a b + m
Theorem: Int.bit1_ne_zero
File: Mathlib/Data/Int/Bitwise.lean

tactic: simpa only [bit0_zero] using bit1_ne_bit0 m 0
state_before: m : ℤ
⊢ bit1 m ≠ 0
Theorem: TensorAlgebra.GradedAlgebra.ι_apply
File: Mathlib/LinearAlgebra/TensorAlgebra/Grading.lean

tactic: simpa only [pow_one] using LinearMap.mem_range_self _ m
state_before: R : Type ?u.13352
M : Type ?u.13355
inst✝² : CommSemiring R
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
m : M
⊢ ↑(TensorAlgebra.ι R) m ∈ LinearMap.range (TensorAlgebra.ι R) ^ 1
Theorem: MeasureTheory.HasFiniteIntegral.norm
File: Mathlib/MeasureTheory/Function/L1Space.lean

tactic: have eq : (fun a => (nnnorm ‖f a‖ : ℝ≥0∞)) = fun a => (‖f a‖₊ : ℝ≥0∞) := by
  funext
  rw [nnnorm_norm]
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.729415
δ : Type ?u.729418
m : MeasurableSpace α
μ ν : Measure α
inst✝² : MeasurableSpace δ
inst✝¹ : NormedAddCommGroup β
inst✝ : NormedAddCommGroup γ
f : α → β
hfi : HasFiniteIntegral f
⊢ HasFiniteIntegral fun a => ‖f a‖

tactic: rwa [HasFiniteIntegral, eq]
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.729415
δ : Type ?u.729418
m : MeasurableSpace α
μ ν : Measure α
inst✝² : MeasurableSpace δ
inst✝¹ : NormedAddCommGroup β
inst✝ : NormedAddCommGroup γ
f : α → β
hfi : HasFiniteIntegral f
eq : (fun a => ↑‖‖f a‖‖₊) = fun a => ↑‖f a‖₊
⊢ HasFiniteIntegral fun a => ‖f a‖

tactic: funext
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.729415
δ : Type ?u.729418
m : MeasurableSpace α
μ ν : Measure α
inst✝² : MeasurableSpace δ
inst✝¹ : NormedAddCommGroup β
inst✝ : NormedAddCommGroup γ
f : α → β
hfi : HasFiniteIntegral f
⊢ (fun a => ↑‖‖f a‖‖₊) = fun a => ↑‖f a‖₊

tactic: rw [nnnorm_norm]
state_before: case h
α : Type u_1
β : Type u_2
γ : Type ?u.729415
δ : Type ?u.729418
m : MeasurableSpace α
μ ν : Measure α
inst✝² : MeasurableSpace δ
inst✝¹ : NormedAddCommGroup β
inst✝ : NormedAddCommGroup γ
f : α → β
hfi : HasFiniteIntegral f
x✝ : α
⊢ ↑‖‖f x✝‖‖₊ = ↑‖f x✝‖₊
Theorem: Quiver.Hom.eq_cast_iff_heq
File: Mathlib/Combinatorics/Quiver/Cast.lean

tactic: rw [eq_comm, Hom.cast_eq_iff_heq]
state_before: U : Type u_1
inst✝ : Quiver U
u v u' v' : U
hu : u = u'
hv : v = v'
e : u ⟶ v
e' : u' ⟶ v'
⊢ e' = cast hu hv e ↔ HEq e' e

tactic: exact ⟨HEq.symm, HEq.symm⟩
state_before: U : Type u_1
inst✝ : Quiver U
u v u' v' : U
hu : u = u'
hv : v = v'
e : u ⟶ v
e' : u' ⟶ v'
⊢ HEq e e' ↔ HEq e' e
Theorem: MeasureTheory.Content.innerContent_iUnion_nat
File: Mathlib/MeasureTheory/Measure/Content.lean

tactic: have := μ.innerContent_iSup_nat fun i => ⟨U i, hU i⟩
state_before: G : Type w
inst✝¹ : TopologicalSpace G
μ : Content G
inst✝ : T2Space G
U : ℕ → Set G
hU : ∀ (i : ℕ), IsOpen (U i)
⊢ innerContent μ { carrier := ⋃ (i : ℕ), U i, is_open' := (_ : IsOpen (⋃ (i : ℕ), U i)) } ≤
    ∑' (i : ℕ), innerContent μ { carrier := U i, is_open' := (_ : IsOpen (U i)) }

tactic: rwa [Opens.iSup_def] at this
state_before: G : Type w
inst✝¹ : TopologicalSpace G
μ : Content G
inst✝ : T2Space G
U : ℕ → Set G
hU : ∀ (i : ℕ), IsOpen (U i)
this :
  innerContent μ (⨆ (i : ℕ), { carrier := U i, is_open' := (_ : IsOpen (U i)) }) ≤
    ∑' (i : ℕ), innerContent μ { carrier := U i, is_open' := (_ : IsOpen (U i)) }
⊢ innerContent μ { carrier := ⋃ (i : ℕ), U i, is_open' := (_ : IsOpen (⋃ (i : ℕ), U i)) } ≤
    ∑' (i : ℕ), innerContent μ { carrier := U i, is_open' := (_ : IsOpen (U i)) }
Theorem: OrderIso.preimage_Ico
File: Mathlib/Data/Set/Intervals/OrderIso.lean

tactic: simp [← Ici_inter_Iio]
state_before: α : Type u_1
β : Type u_2
inst✝¹ : Preorder α
inst✝ : Preorder β
e : α ≃o β
a b : β
⊢ ↑e ⁻¹' Ico a b = Ico (↑(symm e) a) (↑(symm e) b)
Theorem: MeasureTheory.Measure.restrict_singleton'
File: Mathlib/MeasureTheory/Measure/MeasureSpace.lean

tactic: simp only [measure_singleton, Measure.restrict_eq_zero]
state_before: α : Type u_1
β : Type ?u.710215
γ : Type ?u.710218
δ : Type ?u.710221
ι : Type ?u.710224
R : Type ?u.710227
R' : Type ?u.710230
m0 : MeasurableSpace α
inst✝² : MeasurableSpace β
inst✝¹ : MeasurableSpace γ
μ μ₁ μ₂ μ₃ ν ν' ν₁ ν₂ : Measure α
s s' t : Set α
inst✝ : NoAtoms μ
a : α
⊢ restrict μ {a} = 0
Theorem: openSegment_subset_iff_segment_subset
File: Mathlib/Analysis/Convex/Segment.lean

tactic: simp only [← insert_endpoints_openSegment, insert_subset, *, true_and_iff]
state_before: 𝕜 : Type u_2
E : Type u_1
F : Type ?u.47710
G : Type ?u.47713
ι : Type ?u.47716
π : ι → Type ?u.47721
inst✝² : OrderedSemiring 𝕜
inst✝¹ : AddCommMonoid E
inst✝ : Module 𝕜 E
s : Set E
x y z : E
hx : x ∈ s
hy : y ∈ s
⊢ openSegment 𝕜 x y ⊆ s ↔ [x-[𝕜]y] ⊆ s
Theorem: mul_right_iterate_apply_one
File: Mathlib/Algebra/Hom/Iterate.lean

tactic: simp [mul_right_iterate]
state_before: M : Type ?u.67258
N : Type ?u.67261
G : Type u_1
H : Type ?u.67267
inst✝ : Monoid G
a : G
n : ℕ
⊢ ((fun x => x * a)^[n]) 1 = a ^ n
Theorem: Equiv.Perm.support_swap_mul_ge_support_diff
File: Mathlib/GroupTheory/Perm/Support.lean

tactic: intro
state_before: α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
f✝ g f : Perm α
x y : α
⊢ support f \ {x, y} ≤ support (swap x y * f)

tactic: simp only [and_imp, Perm.coe_mul, Function.comp_apply, Ne.def, mem_support, mem_insert, mem_sdiff,
  mem_singleton]
state_before: α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
f✝ g f : Perm α
x y a✝ : α
⊢ a✝ ∈ support f \ {x, y} → a✝ ∈ support (swap x y * f)

tactic: push_neg
state_before: α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
f✝ g f : Perm α
x y a✝ : α
⊢ ¬↑f a✝ = a✝ → ¬(a✝ = x ∨ a✝ = y) → ¬↑(swap x y) (↑f a✝) = a✝

tactic: rintro ha ⟨hx, hy⟩ H
state_before: α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
f✝ g f : Perm α
x y a✝ : α
⊢ ↑f a✝ ≠ a✝ → a✝ ≠ x ∧ a✝ ≠ y → ↑(swap x y) (↑f a✝) ≠ a✝

tactic: rw [swap_apply_eq_iff, swap_apply_of_ne_of_ne hx hy] at H
state_before: case intro
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
f✝ g f : Perm α
x y a✝ : α
ha : ↑f a✝ ≠ a✝
hx : a✝ ≠ x
hy : a✝ ≠ y
H : ↑(swap x y) (↑f a✝) = a✝
⊢ False

tactic: exact ha H
state_before: case intro
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
f✝ g f : Perm α
x y a✝ : α
ha : ↑f a✝ ≠ a✝
hx : a✝ ≠ x
hy : a✝ ≠ y
H : ↑f a✝ = a✝
⊢ False
Theorem: Vector.get_ofFn
File: Mathlib/Data/Vector/Basic.lean

tactic: cases' i with i hi
state_before: n✝ : ℕ
α : Type u_1
n : ℕ
f : Fin n → α
i : Fin n
⊢ get (ofFn f) i = f i

tactic: conv_rhs => erw [← List.get_ofFn f ⟨i, by simpa using hi⟩]
state_before: case mk
n✝ : ℕ
α : Type u_1
n : ℕ
f : Fin n → α
i : ℕ
hi : i < n
⊢ get (ofFn f) { val := i, isLt := hi } = f { val := i, isLt := hi }

tactic: simp only [get_eq_get]
state_before: case mk
n✝ : ℕ
α : Type u_1
n : ℕ
f : Fin n → α
i : ℕ
hi : i < n
⊢ get (ofFn f) { val := i, isLt := hi } =
    List.get (List.ofFn f) { val := i, isLt := (_ : i < List.length (List.ofFn f)) }

tactic: congr <;> simp [Fin.heq_ext_iff]
state_before: case mk
n✝ : ℕ
α : Type u_1
n : ℕ
f : Fin n → α
i : ℕ
hi : i < n
⊢ List.get (toList (ofFn f)) (↑(Fin.cast (_ : n = List.length (toList (ofFn f)))) { val := i, isLt := hi }) =
    List.get (List.ofFn f) { val := i, isLt := (_ : i < List.length (List.ofFn f)) }

tactic: simpa using hi
state_before: n✝ : ℕ
α : Type u_1
n : ℕ
f : Fin n → α
i : ℕ
hi : i < n
⊢ i < List.length (List.ofFn f)
Theorem: closedBall_sub_ball
File: Mathlib/Analysis/NormedSpace/Pointwise.lean

tactic: simp_rw [sub_eq_add_neg, neg_ball, closedBall_add_ball hε hδ]
state_before: 𝕜 : Type ?u.1341112
E : Type u_1
inst✝³ : NormedField 𝕜
inst✝² : SeminormedAddCommGroup E
inst✝¹ : NormedSpace 𝕜 E
inst✝ : NormedSpace ℝ E
x y z : E
δ ε : ℝ
hε : 0 ≤ ε
hδ : 0 < δ
a b : E
⊢ Metric.closedBall a ε - Metric.ball b δ = Metric.ball (a - b) (ε + δ)
Theorem: iSup_ne_bot_subtype
File: Mathlib/Order/CompleteLattice.lean

tactic: by_cases htriv : ∀ i, f i = ⊥
state_before: α : Type u_1
β : Type ?u.174146
β₂ : Type ?u.174149
γ : Type ?u.174152
ι : Sort u_2
ι' : Sort ?u.174158
κ : ι → Sort ?u.174163
κ' : ι' → Sort ?u.174168
inst✝ : CompleteLattice α
f✝ g s t : ι → α
a b : α
f : ι → α
⊢ (⨆ (i : { i // f i ≠ ⊥ }), f ↑i) = ⨆ (i : ι), f i

tactic: refine' (iSup_comp_le f _).antisymm (iSup_mono' fun i => _)
state_before: case neg
α : Type u_1
β : Type ?u.174146
β₂ : Type ?u.174149
γ : Type ?u.174152
ι : Sort u_2
ι' : Sort ?u.174158
κ : ι → Sort ?u.174163
κ' : ι' → Sort ?u.174168
inst✝ : CompleteLattice α
f✝ g s t : ι → α
a b : α
f : ι → α
htriv : ¬∀ (i : ι), f i = ⊥
⊢ (⨆ (i : { i // f i ≠ ⊥ }), f ↑i) = ⨆ (i : ι), f i

tactic: by_cases hi : f i = ⊥
state_before: case neg
α : Type u_1
β : Type ?u.174146
β₂ : Type ?u.174149
γ : Type ?u.174152
ι : Sort u_2
ι' : Sort ?u.174158
κ : ι → Sort ?u.174163
κ' : ι' → Sort ?u.174168
inst✝ : CompleteLattice α
f✝ g s t : ι → α
a b : α
f : ι → α
htriv : ¬∀ (i : ι), f i = ⊥
i : ι
⊢ ∃ i', f i ≤ f ↑i'

tactic: simp only [iSup_bot, (funext htriv : f = _)]
state_before: case pos
α : Type u_1
β : Type ?u.174146
β₂ : Type ?u.174149
γ : Type ?u.174152
ι : Sort u_2
ι' : Sort ?u.174158
κ : ι → Sort ?u.174163
κ' : ι' → Sort ?u.174168
inst✝ : CompleteLattice α
f✝ g s t : ι → α
a b : α
f : ι → α
htriv : ∀ (i : ι), f i = ⊥
⊢ (⨆ (i : { i // f i ≠ ⊥ }), f ↑i) = ⨆ (i : ι), f i

tactic: rw [hi]
state_before: case pos
α : Type u_1
β : Type ?u.174146
β₂ : Type ?u.174149
γ : Type ?u.174152
ι : Sort u_2
ι' : Sort ?u.174158
κ : ι → Sort ?u.174163
κ' : ι' → Sort ?u.174168
inst✝ : CompleteLattice α
f✝ g s t : ι → α
a b : α
f : ι → α
htriv : ¬∀ (i : ι), f i = ⊥
i : ι
hi : f i = ⊥
⊢ ∃ i', f i ≤ f ↑i'

tactic: obtain ⟨i₀, hi₀⟩ := not_forall.mp htriv
state_before: case pos
α : Type u_1
β : Type ?u.174146
β₂ : Type ?u.174149
γ : Type ?u.174152
ι : Sort u_2
ι' : Sort ?u.174158
κ : ι → Sort ?u.174163
κ' : ι' → Sort ?u.174168
inst✝ : CompleteLattice α
f✝ g s t : ι → α
a b : α
f : ι → α
htriv : ¬∀ (i : ι), f i = ⊥
i : ι
hi : f i = ⊥
⊢ ∃ i', ⊥ ≤ f ↑i'

tactic: exact ⟨⟨i₀, hi₀⟩, bot_le⟩
state_before: case pos.intro
α : Type u_1
β : Type ?u.174146
β₂ : Type ?u.174149
γ : Type ?u.174152
ι : Sort u_2
ι' : Sort ?u.174158
κ : ι → Sort ?u.174163
κ' : ι' → Sort ?u.174168
inst✝ : CompleteLattice α
f✝ g s t : ι → α
a b : α
f : ι → α
htriv : ¬∀ (i : ι), f i = ⊥
i : ι
hi : f i = ⊥
i₀ : ι
hi₀ : ¬f i₀ = ⊥
⊢ ∃ i', ⊥ ≤ f ↑i'

tactic: exact ⟨⟨i, hi⟩, rfl.le⟩
state_before: case neg
α : Type u_1
β : Type ?u.174146
β₂ : Type ?u.174149
γ : Type ?u.174152
ι : Sort u_2
ι' : Sort ?u.174158
κ : ι → Sort ?u.174163
κ' : ι' → Sort ?u.174168
inst✝ : CompleteLattice α
f✝ g s t : ι → α
a b : α
f : ι → α
htriv : ¬∀ (i : ι), f i = ⊥
i : ι
hi : ¬f i = ⊥
⊢ ∃ i', f i ≤ f ↑i'
Theorem: Finset.eraseNone_image_some
File: Mathlib/Data/Finset/Option.lean

tactic: simpa only [map_eq_image] using eraseNone_map_some s
state_before: α : Type u_1
β : Type ?u.10620
inst✝ : DecidableEq (Option α)
s : Finset α
⊢ ↑eraseNone (image some s) = s
Theorem: Complex.cos_add_aux
File: Mathlib/Data/Complex/Exponential.lean

tactic: ring
state_before: x y a b c d : ℂ
⊢ (a + b) * (c + d) - (b - a) * (d - c) * -1 = 2 * (a * c + b * d)
Theorem: Module.ext'
File: Mathlib/Algebra/Module/Basic.lean

tactic: ext
state_before: α : Type ?u.96211
R✝ : Type ?u.96214
k : Type ?u.96217
S : Type ?u.96220
M✝ : Type ?u.96223
M₂ : Type ?u.96226
M₃ : Type ?u.96229
ι : Type ?u.96232
R : Type u_1
inst✝¹ : Semiring R
M : Type u_2
inst✝ : AddCommMonoid M
P Q : Module R M
w : ∀ (r : R) (m : M), r • m = r • m
⊢ P = Q

tactic: exact w _ _
state_before: case smul.h.h
α : Type ?u.96211
R✝ : Type ?u.96214
k : Type ?u.96217
S : Type ?u.96220
M✝ : Type ?u.96223
M₂ : Type ?u.96226
M₃ : Type ?u.96229
ι : Type ?u.96232
R : Type u_1
inst✝¹ : Semiring R
M : Type u_2
inst✝ : AddCommMonoid M
P Q : Module R M
w : ∀ (r : R) (m : M), r • m = r • m
x✝¹ : R
x✝ : M
⊢ SMul.smul x✝¹ x✝ = SMul.smul x✝¹ x✝
Theorem: Stream'.WSeq.get?_terminates_le
File: Mathlib/Data/Seq/WSeq.lean

tactic: induction' h with m' _ IH <;> [exact id;
  exact fun T => IH (@head_terminates_of_head_tail_terminates _ _ T)]
state_before: α : Type u
β : Type v
γ : Type w
s : WSeq α
m n : ℕ
h : m ≤ n
⊢ Terminates (get? s n) → Terminates (get? s m)
Theorem: continuousAt_sign_of_neg
File: Mathlib/Topology/Instances/Sign.lean

tactic: refine' (continuousAt_const : ContinuousAt (fun x => (-1 : SignType)) a).congr _
state_before: α : Type u_1
inst✝⁴ : Zero α
inst✝³ : TopologicalSpace α
inst✝² : PartialOrder α
inst✝¹ : DecidableRel fun x x_1 => x < x_1
inst✝ : OrderTopology α
a : α
h : a < 0
⊢ ContinuousAt (↑SignType.sign) a

tactic: rw [Filter.EventuallyEq, eventually_nhds_iff]
state_before: α : Type u_1
inst✝⁴ : Zero α
inst✝³ : TopologicalSpace α
inst✝² : PartialOrder α
inst✝¹ : DecidableRel fun x x_1 => x < x_1
inst✝ : OrderTopology α
a : α
h : a < 0
⊢ (fun x => -1) =ᶠ[nhds a] ↑SignType.sign

tactic: exact ⟨{ x | x < 0 }, fun x hx => (sign_neg hx).symm, isOpen_gt' 0, h⟩
state_before: α : Type u_1
inst✝⁴ : Zero α
inst✝³ : TopologicalSpace α
inst✝² : PartialOrder α
inst✝¹ : DecidableRel fun x x_1 => x < x_1
inst✝ : OrderTopology α
a : α
h : a < 0
⊢ ∃ t, (∀ (x : α), x ∈ t → -1 = ↑SignType.sign x) ∧ IsOpen t ∧ a ∈ t
Theorem: Finset.left_eq_union_iff_subset
File: Mathlib/Data/Finset/Basic.lean

tactic: rw [← union_eq_left_iff_subset, eq_comm]
state_before: α : Type u_1
β : Type ?u.151221
γ : Type ?u.151224
inst✝ : DecidableEq α
s✝ s₁ s₂ t✝ t₁ t₂ u v : Finset α
a b : α
s t : Finset α
⊢ s = s ∪ t ↔ t ⊆ s