1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: Filter.unbounded_of_tendsto_atTop
File: Mathlib/Order/Filter/AtTopBot.lean

tactic: rintro ⟨M, hM⟩
state_before: ι : Type u_1
ι' : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
inst✝³ : Nonempty α
inst✝² : SemilatticeSup α
inst✝¹ : Preorder β
inst✝ : NoMaxOrder β
f : α → β
h : Tendsto f atTop atTop
⊢ ¬BddAbove (range f)
state_after: case intro
ι : Type u_1
ι' : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
inst✝³ : Nonempty α
inst✝² : SemilatticeSup α
inst✝¹ : Preorder β
inst✝ : NoMaxOrder β
f : α → β
h : Tendsto f atTop atTop
M : β
hM : M ∈ upperBounds (range f)
⊢ False

tactic: cases' mem_atTop_sets.mp (h <| Ioi_mem_atTop M) with a ha
state_before: case intro
ι : Type u_1
ι' : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
inst✝³ : Nonempty α
inst✝² : SemilatticeSup α
inst✝¹ : Preorder β
inst✝ : NoMaxOrder β
f : α → β
h : Tendsto f atTop atTop
M : β
hM : M ∈ upperBounds (range f)
⊢ False
state_after: case intro.intro
ι : Type u_1
ι' : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
inst✝³ : Nonempty α
inst✝² : SemilatticeSup α
inst✝¹ : Preorder β
inst✝ : NoMaxOrder β
f : α → β
h : Tendsto f atTop atTop
M : β
hM : M ∈ upperBounds (range f)
a : α
ha : ∀ b ≥ a, b ∈ f ⁻¹' Ioi M
⊢ False

tactic: apply lt_irrefl M
state_before: case intro.intro
ι : Type u_1
ι' : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
inst✝³ : Nonempty α
inst✝² : SemilatticeSup α
inst✝¹ : Preorder β
inst✝ : NoMaxOrder β
f : α → β
h : Tendsto f atTop atTop
M : β
hM : M ∈ upperBounds (range f)
a : α
ha : ∀ b ≥ a, b ∈ f ⁻¹' Ioi M
⊢ False
state_after: case intro.intro
ι : Type u_1
ι' : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
inst✝³ : Nonempty α
inst✝² : SemilatticeSup α
inst✝¹ : Preorder β
inst✝ : NoMaxOrder β
f : α → β
h : Tendsto f atTop atTop
M : β
hM : M ∈ upperBounds (range f)
a : α
ha : ∀ b ≥ a, b ∈ f ⁻¹' Ioi M
⊢ M < M

tactic: calc
  M < f a := ha a le_rfl
  _ ≤ M := hM (Set.mem_range_self a)
state_before: case intro.intro
ι : Type u_1
ι' : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
inst✝³ : Nonempty α
inst✝² : SemilatticeSup α
inst✝¹ : Preorder β
inst✝ : NoMaxOrder β
f : α → β
h : Tendsto f atTop atTop
M : β
hM : M ∈ upperBounds (range f)
a : α
ha : ∀ b ≥ a, b ∈ f ⁻¹' Ioi M
⊢ M < M
state_after: no goals
Theorem: Rat.mkRat_mul_left
File: .lake/packages/batteries/Batteries/Data/Rat/Lemmas.lean

tactic: if d0 : d = 0 then simp [d0] else
rw [← normalize_eq_mkRat d0, ← normalize_mul_left d0 a0, normalize_eq_mkRat]
state_before: n : Int
d a : Nat
a0 : a ≠ 0
⊢ mkRat (↑a * n) (a * d) = mkRat n d
state_after: no goals

tactic: simp [d0]
state_before: n : Int
d a : Nat
a0 : a ≠ 0
d0 : d = 0
⊢ mkRat (↑a * n) (a * d) = mkRat n d
state_after: no goals

tactic: rw [← normalize_eq_mkRat d0, ← normalize_mul_left d0 a0, normalize_eq_mkRat]
state_before: n : Int
d a : Nat
a0 : a ≠ 0
d0 : ¬d = 0
⊢ mkRat (↑a * n) (a * d) = mkRat n d
state_after: no goals
Theorem: deriv_const_mul_field
File: Mathlib/Analysis/Calculus/Deriv/Mul.lean

tactic: simp only [mul_comm u, deriv_mul_const_field]
state_before: 𝕜 : Type u
inst✝¹⁰ : NontriviallyNormedField 𝕜
F : Type v
inst✝⁹ : NormedAddCommGroup F
inst✝⁸ : NormedSpace 𝕜 F
E : Type w
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
G : Type u_1
inst✝⁵ : NormedAddCommGroup G
inst✝⁴ : NormedSpace 𝕜 G
f f₀ f₁ g : 𝕜 → F
f' f₀' f₁' g' : F
x : 𝕜
s t : Set 𝕜
L L₁ L₂ : Filter 𝕜
𝕜' : Type u_2
𝔸 : Type u_3
inst✝³ : NormedField 𝕜'
inst✝² : NormedRing 𝔸
inst✝¹ : NormedAlgebra 𝕜 𝕜'
inst✝ : NormedAlgebra 𝕜 𝔸
c d : 𝕜 → 𝔸
c' d' : 𝔸
u✝ v : 𝕜 → 𝕜'
u : 𝕜'
⊢ deriv (fun y => u * v y) x = u * deriv v x
state_after: no goals
Theorem: Module.End.genEigenspace_zero
File: Mathlib/LinearAlgebra/Eigenspace/Basic.lean

tactic: simp [Module.End.genEigenspace]
state_before: K R : Type v
V M : Type w
inst✝⁵ : CommRing R
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
inst✝² : Field K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
f : End R M
k : ℕ
⊢ (f.genEigenspace 0) k = LinearMap.ker (f ^ k)
state_after: no goals
Theorem: intrinsicFrontier_empty
File: Mathlib/Analysis/Convex/Intrinsic.lean

tactic: simp [intrinsicFrontier]
state_before: 𝕜 : Type u_1
V : Type u_2
W : Type u_3
Q : Type u_4
P : Type u_5
inst✝⁴ : Ring 𝕜
inst✝³ : AddCommGroup V
inst✝² : Module 𝕜 V
inst✝¹ : TopologicalSpace P
inst✝ : AddTorsor V P
s t : Set P
x : P
⊢ intrinsicFrontier 𝕜 ∅ = ∅
state_after: no goals
Theorem: HasFiniteFPowerSeriesOnBall.neg
File: Mathlib/Analysis/Analytic/CPolynomial.lean

tactic: rw [Pi.neg_apply, hf.finite m hm, neg_zero]
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
inst✝⁶ : NontriviallyNormedField 𝕜
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedSpace 𝕜 E
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
inst✝¹ : NormedAddCommGroup G
inst✝ : NormedSpace 𝕜 G
f g : E → F
p pf pg : FormalMultilinearSeries 𝕜 E F
x : E
r r' : ℝ≥0∞
n m✝ : ℕ
hf : HasFiniteFPowerSeriesOnBall f pf x n r
m : ℕ
hm : n ≤ m
⊢ (-pf) m = 0
state_after: no goals
Theorem: UniqueMul.exists_iff_exists_existsUnique
File: Mathlib/Algebra/Group/UniqueProds.lean

tactic: have h' := h
state_before: G : Type u_1
H : Type u_2
inst✝¹ : Mul G
inst✝ : Mul H
A B : Finset G
a0 b0 : G
x✝ : ∃ g, ∃! ab, ab ∈ A ×ˢ B ∧ ab.1 * ab.2 = g
g : G
h : ∃! ab, ab ∈ A ×ˢ B ∧ ab.1 * ab.2 = g
⊢ ∃ a0 b0, a0 ∈ A ∧ b0 ∈ B ∧ UniqueMul A B a0 b0
state_after: G : Type u_1
H : Type u_2
inst✝¹ : Mul G
inst✝ : Mul H
A B : Finset G
a0 b0 : G
x✝ : ∃ g, ∃! ab, ab ∈ A ×ˢ B ∧ ab.1 * ab.2 = g
g : G
h h' : ∃! ab, ab ∈ A ×ˢ B ∧ ab.1 * ab.2 = g
⊢ ∃ a0 b0, a0 ∈ A ∧ b0 ∈ B ∧ UniqueMul A B a0 b0

tactic: rcases h' with ⟨⟨a, b⟩, ⟨hab, rfl, -⟩, -⟩
state_before: G : Type u_1
H : Type u_2
inst✝¹ : Mul G
inst✝ : Mul H
A B : Finset G
a0 b0 : G
x✝ : ∃ g, ∃! ab, ab ∈ A ×ˢ B ∧ ab.1 * ab.2 = g
g : G
h h' : ∃! ab, ab ∈ A ×ˢ B ∧ ab.1 * ab.2 = g
⊢ ∃ a0 b0, a0 ∈ A ∧ b0 ∈ B ∧ UniqueMul A B a0 b0
state_after: case intro.mk.intro.intro.refl
G : Type u_1
H : Type u_2
inst✝¹ : Mul G
inst✝ : Mul H
A B : Finset G
a0 b0 : G
x✝ : ∃ g, ∃! ab, ab ∈ A ×ˢ B ∧ ab.1 * ab.2 = g
a b : G
hab : (a, b) ∈ A ×ˢ B
h : ∃! ab, ab ∈ A ×ˢ B ∧ ab.1 * ab.2 = (a, b).1 * (a, b).2
⊢ ∃ a0 b0, a0 ∈ A ∧ b0 ∈ B ∧ UniqueMul A B a0 b0

tactic: cases' Finset.mem_product.mp hab with ha hb
state_before: case intro.mk.intro.intro.refl
G : Type u_1
H : Type u_2
inst✝¹ : Mul G
inst✝ : Mul H
A B : Finset G
a0 b0 : G
x✝ : ∃ g, ∃! ab, ab ∈ A ×ˢ B ∧ ab.1 * ab.2 = g
a b : G
hab : (a, b) ∈ A ×ˢ B
h : ∃! ab, ab ∈ A ×ˢ B ∧ ab.1 * ab.2 = (a, b).1 * (a, b).2
⊢ ∃ a0 b0, a0 ∈ A ∧ b0 ∈ B ∧ UniqueMul A B a0 b0
state_after: case intro.mk.intro.intro.refl.intro
G : Type u_1
H : Type u_2
inst✝¹ : Mul G
inst✝ : Mul H
A B : Finset G
a0 b0 : G
x✝ : ∃ g, ∃! ab, ab ∈ A ×ˢ B ∧ ab.1 * ab.2 = g
a b : G
hab : (a, b) ∈ A ×ˢ B
h : ∃! ab, ab ∈ A ×ˢ B ∧ ab.1 * ab.2 = (a, b).1 * (a, b).2
ha : (a, b).1 ∈ A
hb : (a, b).2 ∈ B
⊢ ∃ a0 b0, a0 ∈ A ∧ b0 ∈ B ∧ UniqueMul A B a0 b0

tactic: exact ⟨a, b, ha, hb, (iff_existsUnique ha hb).mpr h⟩
state_before: case intro.mk.intro.intro.refl.intro
G : Type u_1
H : Type u_2
inst✝¹ : Mul G
inst✝ : Mul H
A B : Finset G
a0 b0 : G
x✝ : ∃ g, ∃! ab, ab ∈ A ×ˢ B ∧ ab.1 * ab.2 = g
a b : G
hab : (a, b) ∈ A ×ˢ B
h : ∃! ab, ab ∈ A ×ˢ B ∧ ab.1 * ab.2 = (a, b).1 * (a, b).2
ha : (a, b).1 ∈ A
hb : (a, b).2 ∈ B
⊢ ∃ a0 b0, a0 ∈ A ∧ b0 ∈ B ∧ UniqueMul A B a0 b0
state_after: no goals
Theorem: Ideal.pow_right_mono
File: Mathlib/RingTheory/Ideal/Operations.lean

tactic: induction' n with _ hn
state_before: R : Type u
ι : Type u_1
inst✝ : CommSemiring R
I✝ J✝ K L I J : Ideal R
e : I ≤ J
n : ℕ
⊢ I ^ n ≤ J ^ n
state_after: case zero
R : Type u
ι : Type u_1
inst✝ : CommSemiring R
I✝ J✝ K L I J : Ideal R
e : I ≤ J
⊢ I ^ 0 ≤ J ^ 0

case succ
R : Type u
ι : Type u_1
inst✝ : CommSemiring R
I✝ J✝ K L I J : Ideal R
e : I ≤ J
n✝ : ℕ
hn : I ^ n✝ ≤ J ^ n✝
⊢ I ^ (n✝ + 1) ≤ J ^ (n✝ + 1)

tactic: rw [pow_zero, pow_zero]
state_before: case zero
R : Type u
ι : Type u_1
inst✝ : CommSemiring R
I✝ J✝ K L I J : Ideal R
e : I ≤ J
⊢ I ^ 0 ≤ J ^ 0
state_after: no goals

tactic: rw [pow_succ, pow_succ]
state_before: case succ
R : Type u
ι : Type u_1
inst✝ : CommSemiring R
I✝ J✝ K L I J : Ideal R
e : I ≤ J
n✝ : ℕ
hn : I ^ n✝ ≤ J ^ n✝
⊢ I ^ (n✝ + 1) ≤ J ^ (n✝ + 1)
state_after: case succ
R : Type u
ι : Type u_1
inst✝ : CommSemiring R
I✝ J✝ K L I J : Ideal R
e : I ≤ J
n✝ : ℕ
hn : I ^ n✝ ≤ J ^ n✝
⊢ I ^ n✝ * I ≤ J ^ n✝ * J

tactic: exact Ideal.mul_mono hn e
state_before: case succ
R : Type u
ι : Type u_1
inst✝ : CommSemiring R
I✝ J✝ K L I J : Ideal R
e : I ≤ J
n✝ : ℕ
hn : I ^ n✝ ≤ J ^ n✝
⊢ I ^ n✝ * I ≤ J ^ n✝ * J
state_after: no goals
Theorem: IsSMulRegular.pow
File: Mathlib/Algebra/Regular/SMul.lean

tactic: induction' n with n hn
state_before: R : Type u_1
S : Type u_2
M : Type u_3
a b : R
s : S
inst✝¹ : Monoid R
inst✝ : MulAction R M
n : ℕ
ra : IsSMulRegular M a
⊢ IsSMulRegular M (a ^ n)
state_after: case zero
R : Type u_1
S : Type u_2
M : Type u_3
a b : R
s : S
inst✝¹ : Monoid R
inst✝ : MulAction R M
ra : IsSMulRegular M a
⊢ IsSMulRegular M (a ^ 0)

case succ
R : Type u_1
S : Type u_2
M : Type u_3
a b : R
s : S
inst✝¹ : Monoid R
inst✝ : MulAction R M
ra : IsSMulRegular M a
n : ℕ
hn : IsSMulRegular M (a ^ n)
⊢ IsSMulRegular M (a ^ (n + 1))

tactic: rw [pow_zero]
state_before: case zero
R : Type u_1
S : Type u_2
M : Type u_3
a b : R
s : S
inst✝¹ : Monoid R
inst✝ : MulAction R M
ra : IsSMulRegular M a
⊢ IsSMulRegular M (a ^ 0)
state_after: case zero
R : Type u_1
S : Type u_2
M : Type u_3
a b : R
s : S
inst✝¹ : Monoid R
inst✝ : MulAction R M
ra : IsSMulRegular M a
⊢ IsSMulRegular M 1

tactic: simp only [one]
state_before: case zero
R : Type u_1
S : Type u_2
M : Type u_3
a b : R
s : S
inst✝¹ : Monoid R
inst✝ : MulAction R M
ra : IsSMulRegular M a
⊢ IsSMulRegular M 1
state_after: no goals

tactic: rw [pow_succ']
state_before: case succ
R : Type u_1
S : Type u_2
M : Type u_3
a b : R
s : S
inst✝¹ : Monoid R
inst✝ : MulAction R M
ra : IsSMulRegular M a
n : ℕ
hn : IsSMulRegular M (a ^ n)
⊢ IsSMulRegular M (a ^ (n + 1))
state_after: case succ
R : Type u_1
S : Type u_2
M : Type u_3
a b : R
s : S
inst✝¹ : Monoid R
inst✝ : MulAction R M
ra : IsSMulRegular M a
n : ℕ
hn : IsSMulRegular M (a ^ n)
⊢ IsSMulRegular M (a * a ^ n)

tactic: exact (ra.smul_iff (a ^ n)).mpr hn
state_before: case succ
R : Type u_1
S : Type u_2
M : Type u_3
a b : R
s : S
inst✝¹ : Monoid R
inst✝ : MulAction R M
ra : IsSMulRegular M a
n : ℕ
hn : IsSMulRegular M (a ^ n)
⊢ IsSMulRegular M (a * a ^ n)
state_after: no goals
Theorem: CategoryTheory.GrothendieckTopology.Subpresheaf.isSheaf_iff
File: Mathlib/CategoryTheory/Sites/Subsheaf.lean

tactic: rw [← G.eq_sheafify_iff h]
state_before: C : Type u
inst✝ : Category.{v, u} C
J : GrothendieckTopology C
F F' F'' : Cᵒᵖ ⥤ Type w
G G' : Subpresheaf F
h : Presieve.IsSheaf J F
⊢ Presieve.IsSheaf J G.toPresheaf ↔ ∀ (U : Cᵒᵖ) (s : F.obj U), G.sieveOfSection s ∈ J.sieves U.unop → s ∈ G.obj U
state_after: C : Type u
inst✝ : Category.{v, u} C
J : GrothendieckTopology C
F F' F'' : Cᵒᵖ ⥤ Type w
G G' : Subpresheaf F
h : Presieve.IsSheaf J F
⊢ G = sheafify J G ↔ ∀ (U : Cᵒᵖ) (s : F.obj U), G.sieveOfSection s ∈ J.sieves U.unop → s ∈ G.obj U

tactic: change _ ↔ G.sheafify J ≤ G
state_before: C : Type u
inst✝ : Category.{v, u} C
J : GrothendieckTopology C
F F' F'' : Cᵒᵖ ⥤ Type w
G G' : Subpresheaf F
h : Presieve.IsSheaf J F
⊢ G = sheafify J G ↔ ∀ (U : Cᵒᵖ) (s : F.obj U), G.sieveOfSection s ∈ J.sieves U.unop → s ∈ G.obj U
state_after: C : Type u
inst✝ : Category.{v, u} C
J : GrothendieckTopology C
F F' F'' : Cᵒᵖ ⥤ Type w
G G' : Subpresheaf F
h : Presieve.IsSheaf J F
⊢ G = sheafify J G ↔ sheafify J G ≤ G

tactic: exact ⟨Eq.ge, (G.le_sheafify J).antisymm⟩
state_before: C : Type u
inst✝ : Category.{v, u} C
J : GrothendieckTopology C
F F' F'' : Cᵒᵖ ⥤ Type w
G G' : Subpresheaf F
h : Presieve.IsSheaf J F
⊢ G = sheafify J G ↔ sheafify J G ≤ G
state_after: no goals
Theorem: Stream'.Seq1.join_map_ret
File: Mathlib/Data/Seq/Seq.lean

tactic: apply coinduction2 s
state_before: α : Type u
β : Type v
γ : Type w
s : Seq α
⊢ (Seq.map ret s).join = s
state_after: case H
α : Type u
β : Type v
γ : Type w
s : Seq α
⊢ ∀ (s : Seq α), BisimO (fun s1 s2 => ∃ s, s1 = (Seq.map ret s).join ∧ s2 = s) (Seq.map ret s).join.destruct s.destruct

tactic: intro s
state_before: case H
α : Type u
β : Type v
γ : Type w
s : Seq α
⊢ ∀ (s : Seq α), BisimO (fun s1 s2 => ∃ s, s1 = (Seq.map ret s).join ∧ s2 = s) (Seq.map ret s).join.destruct s.destruct
state_after: case H
α : Type u
β : Type v
γ : Type w
s✝ s : Seq α
⊢ BisimO (fun s1 s2 => ∃ s, s1 = (Seq.map ret s).join ∧ s2 = s) (Seq.map ret s).join.destruct s.destruct

tactic: apply recOn s <;> simp [ret]
state_before: case H
α : Type u
β : Type v
γ : Type w
s✝ s : Seq α
⊢ BisimO (fun s1 s2 => ∃ s, s1 = (Seq.map ret s).join ∧ s2 = s) (Seq.map ret s).join.destruct s.destruct
state_after: no goals
Theorem: PythagoreanTriple.mul
File: Mathlib/NumberTheory/PythagoreanTriples.lean

tactic: ring
state_before: x y z : ℤ
h : PythagoreanTriple x y z
k : ℤ
⊢ k * x * (k * x) + k * y * (k * y) = k ^ 2 * (x * x + y * y)
state_after: no goals

tactic: rw [h.eq]
state_before: x y z : ℤ
h : PythagoreanTriple x y z
k : ℤ
⊢ k ^ 2 * (x * x + y * y) = k ^ 2 * (z * z)
state_after: no goals

tactic: ring
state_before: x y z : ℤ
h : PythagoreanTriple x y z
k : ℤ
⊢ k ^ 2 * (z * z) = k * z * (k * z)
state_after: no goals
Theorem: PadicSeq.norm_const
File: Mathlib/NumberTheory/Padics/PadicNumbers.lean

tactic: have : const (padicNorm p) q ≈ 0 := by simp [hq]; apply Setoid.refl (const (padicNorm p) 0)
state_before: p : ℕ
hp : Fact (Nat.Prime p)
q : ℚ
hq : q = 0
⊢ norm (const (padicNorm p) q) = padicNorm p q
state_after: p : ℕ
hp : Fact (Nat.Prime p)
q : ℚ
hq : q = 0
this : const (padicNorm p) q ≈ 0
⊢ norm (const (padicNorm p) q) = padicNorm p q

tactic: subst hq
state_before: p : ℕ
hp : Fact (Nat.Prime p)
q : ℚ
hq : q = 0
this : const (padicNorm p) q ≈ 0
⊢ norm (const (padicNorm p) q) = padicNorm p q
state_after: p : ℕ
hp : Fact (Nat.Prime p)
this : const (padicNorm p) 0 ≈ 0
⊢ norm (const (padicNorm p) 0) = padicNorm p 0

tactic: simp [norm, this]
state_before: p : ℕ
hp : Fact (Nat.Prime p)
this : const (padicNorm p) 0 ≈ 0
⊢ norm (const (padicNorm p) 0) = padicNorm p 0
state_after: no goals

tactic: simp [hq]
state_before: p : ℕ
hp : Fact (Nat.Prime p)
q : ℚ
hq : q = 0
⊢ const (padicNorm p) q ≈ 0
state_after: p : ℕ
hp : Fact (Nat.Prime p)
q : ℚ
hq : q = 0
⊢ 0 ≈ 0

tactic: apply Setoid.refl (const (padicNorm p) 0)
state_before: p : ℕ
hp : Fact (Nat.Prime p)
q : ℚ
hq : q = 0
⊢ 0 ≈ 0
state_after: no goals

tactic: have : ¬const (padicNorm p) q ≈ 0 := not_equiv_zero_const_of_nonzero hq
state_before: p : ℕ
hp : Fact (Nat.Prime p)
q : ℚ
hq : ¬q = 0
⊢ norm (const (padicNorm p) q) = padicNorm p q
state_after: p : ℕ
hp : Fact (Nat.Prime p)
q : ℚ
hq : ¬q = 0
this : ¬const (padicNorm p) q ≈ 0
⊢ norm (const (padicNorm p) q) = padicNorm p q

tactic: simp [norm, this]
state_before: p : ℕ
hp : Fact (Nat.Prime p)
q : ℚ
hq : ¬q = 0
this : ¬const (padicNorm p) q ≈ 0
⊢ norm (const (padicNorm p) q) = padicNorm p q
state_after: no goals
Theorem: SetTheory.PGame.neg_lf_iff
File: Mathlib/SetTheory/Game/PGame.lean

tactic: rw [← neg_neg x, neg_lf_neg_iff, neg_neg]
state_before: xl xr : Type u
x y : PGame
⊢ -y ⧏ x ↔ -x ⧏ y
state_after: no goals
Theorem: Real.mk_mul
File: Mathlib/Data/Real/Basic.lean

tactic: simp [mk, ← ofCauchy_mul]
state_before: x y : ℝ
f g : CauSeq ℚ abs
⊢ mk (f * g) = mk f * mk g
state_after: no goals
Theorem: Finset.toList_eq_singleton_iff
File: Mathlib/Data/Finset/Basic.lean

tactic: rw [toList, Multiset.toList_eq_singleton_iff, val_eq_singleton_iff]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
a : α
s : Finset α
⊢ s.toList = [a] ↔ s = {a}
state_after: no goals
Theorem: card_le_of_injective
File: Mathlib/LinearAlgebra/InvariantBasisNumber.lean

tactic: let P := LinearEquiv.funCongrLeft R R (Fintype.equivFin α)
state_before: R : Type u
inst✝³ : Semiring R
inst✝² : StrongRankCondition R
α : Type u_1
β : Type u_2
inst✝¹ : Fintype α
inst✝ : Fintype β
f : (α → R) →ₗ[R] β → R
i : Injective ⇑f
⊢ Fintype.card α ≤ Fintype.card β
state_after: R : Type u
inst✝³ : Semiring R
inst✝² : StrongRankCondition R
α : Type u_1
β : Type u_2
inst✝¹ : Fintype α
inst✝ : Fintype β
f : (α → R) →ₗ[R] β → R
i : Injective ⇑f
P : (Fin (Fintype.card α) → R) ≃ₗ[R] α → R := LinearEquiv.funCongrLeft R R (Fintype.equivFin α)
⊢ Fintype.card α ≤ Fintype.card β

tactic: let Q := LinearEquiv.funCongrLeft R R (Fintype.equivFin β)
state_before: R : Type u
inst✝³ : Semiring R
inst✝² : StrongRankCondition R
α : Type u_1
β : Type u_2
inst✝¹ : Fintype α
inst✝ : Fintype β
f : (α → R) →ₗ[R] β → R
i : Injective ⇑f
P : (Fin (Fintype.card α) → R) ≃ₗ[R] α → R := LinearEquiv.funCongrLeft R R (Fintype.equivFin α)
⊢ Fintype.card α ≤ Fintype.card β
state_after: R : Type u
inst✝³ : Semiring R
inst✝² : StrongRankCondition R
α : Type u_1
β : Type u_2
inst✝¹ : Fintype α
inst✝ : Fintype β
f : (α → R) →ₗ[R] β → R
i : Injective ⇑f
P : (Fin (Fintype.card α) → R) ≃ₗ[R] α → R := LinearEquiv.funCongrLeft R R (Fintype.equivFin α)
Q : (Fin (Fintype.card β) → R) ≃ₗ[R] β → R := LinearEquiv.funCongrLeft R R (Fintype.equivFin β)
⊢ Fintype.card α ≤ Fintype.card β

tactic: exact
  le_of_fin_injective R ((Q.symm.toLinearMap.comp f).comp P.toLinearMap)
    (((LinearEquiv.symm Q).injective.comp i).comp (LinearEquiv.injective P))
state_before: R : Type u
inst✝³ : Semiring R
inst✝² : StrongRankCondition R
α : Type u_1
β : Type u_2
inst✝¹ : Fintype α
inst✝ : Fintype β
f : (α → R) →ₗ[R] β → R
i : Injective ⇑f
P : (Fin (Fintype.card α) → R) ≃ₗ[R] α → R := LinearEquiv.funCongrLeft R R (Fintype.equivFin α)
Q : (Fin (Fintype.card β) → R) ≃ₗ[R] β → R := LinearEquiv.funCongrLeft R R (Fintype.equivFin β)
⊢ Fintype.card α ≤ Fintype.card β
state_after: no goals
Theorem: FormalMultilinearSeries.rightInv_coeff_one
File: Mathlib/Analysis/Analytic/Inverse.lean

tactic: rw [rightInv]
state_before: 𝕜 : Type u_1
inst✝⁴ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace 𝕜 E
F : Type u_3
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace 𝕜 F
p : FormalMultilinearSeries 𝕜 E F
i : E ≃L[𝕜] F
⊢ p.rightInv i 1 = (continuousMultilinearCurryFin1 𝕜 F E).symm ↑i.symm
state_after: no goals
Theorem: Multiset.sum_map_mul_left
File: Mathlib/Algebra/BigOperators/Ring/Multiset.lean

tactic: simp
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
inst✝ : NonUnitalNonAssocSemiring α
a : α
s : Multiset ι
f : ι → α
⊢ (map (fun i => a * f i) 0).sum = a * (map f 0).sum
state_after: no goals

tactic: simp [ih, mul_add]
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
inst✝ : NonUnitalNonAssocSemiring α
a : α
s✝ : Multiset ι
f : ι → α
i : ι
s : Multiset ι
ih : (map (fun i => a * f i) s).sum = a * (map f s).sum
⊢ (map (fun i => a * f i) (i ::ₘ s)).sum = a * (map f (i ::ₘ s)).sum
state_after: no goals
Theorem: List.head?_append
File: Mathlib/Data/List/Basic.lean

tactic: cases s
state_before: ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ s t : List α
x : α
h : x ∈ s.head?
⊢ x ∈ (s ++ t).head?
state_after: case nil
ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ t : List α
x : α
h : x ∈ [].head?
⊢ x ∈ ([] ++ t).head?

case cons
ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ t : List α
x head✝ : α
tail✝ : List α
h : x ∈ (head✝ :: tail✝).head?
⊢ x ∈ (head✝ :: tail✝ ++ t).head?

tactic: contradiction
state_before: case nil
ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ t : List α
x : α
h : x ∈ [].head?
⊢ x ∈ ([] ++ t).head?
state_after: no goals

tactic: exact h
state_before: case cons
ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ t : List α
x head✝ : α
tail✝ : List α
h : x ∈ (head✝ :: tail✝).head?
⊢ x ∈ (head✝ :: tail✝ ++ t).head?
state_after: no goals
Theorem: MeasurableEquiv.image_preimage
File: Mathlib/MeasureTheory/MeasurableSpace/Embedding.lean

tactic: rw [← coe_toEquiv, Equiv.image_preimage]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
δ' : Type u_5
ι : Sort uι
s✝ t u : Set α
inst✝³ : MeasurableSpace α
inst✝² : MeasurableSpace β
inst✝¹ : MeasurableSpace γ
inst✝ : MeasurableSpace δ
e : α ≃ᵐ β
s : Set β
⊢ ⇑e '' (⇑e ⁻¹' s) = s
state_after: no goals
Theorem: Submodule.subsingleton_quotient_iff_eq_top
File: Mathlib/LinearAlgebra/Quotient.lean

tactic: constructor
state_before: R : Type u_1
M : Type u_2
r : R
x y : M
inst✝² : Ring R
inst✝¹ : AddCommGroup M
inst✝ : Module R M
p p' : Submodule R M
⊢ Subsingleton (M ⧸ p) ↔ p = ⊤
state_after: case mp
R : Type u_1
M : Type u_2
r : R
x y : M
inst✝² : Ring R
inst✝¹ : AddCommGroup M
inst✝ : Module R M
p p' : Submodule R M
⊢ Subsingleton (M ⧸ p) → p = ⊤

case mpr
R : Type u_1
M : Type u_2
r : R
x y : M
inst✝² : Ring R
inst✝¹ : AddCommGroup M
inst✝ : Module R M
p p' : Submodule R M
⊢ p = ⊤ → Subsingleton (M ⧸ p)

tactic: rintro h
state_before: case mp
R : Type u_1
M : Type u_2
r : R
x y : M
inst✝² : Ring R
inst✝¹ : AddCommGroup M
inst✝ : Module R M
p p' : Submodule R M
⊢ Subsingleton (M ⧸ p) → p = ⊤
state_after: case mp
R : Type u_1
M : Type u_2
r : R
x y : M
inst✝² : Ring R
inst✝¹ : AddCommGroup M
inst✝ : Module R M
p p' : Submodule R M
h : Subsingleton (M ⧸ p)
⊢ p = ⊤

tactic: refine eq_top_iff.mpr fun x _ => ?_
state_before: case mp
R : Type u_1
M : Type u_2
r : R
x y : M
inst✝² : Ring R
inst✝¹ : AddCommGroup M
inst✝ : Module R M
p p' : Submodule R M
h : Subsingleton (M ⧸ p)
⊢ p = ⊤
state_after: case mp
R : Type u_1
M : Type u_2
r : R
x✝¹ y : M
inst✝² : Ring R
inst✝¹ : AddCommGroup M
inst✝ : Module R M
p p' : Submodule R M
h : Subsingleton (M ⧸ p)
x : M
x✝ : x ∈ ⊤
⊢ x ∈ p

tactic: have : x - 0 ∈ p := (Submodule.Quotient.eq p).mp (Subsingleton.elim _ _)
state_before: case mp
R : Type u_1
M : Type u_2
r : R
x✝¹ y : M
inst✝² : Ring R
inst✝¹ : AddCommGroup M
inst✝ : Module R M
p p' : Submodule R M
h : Subsingleton (M ⧸ p)
x : M
x✝ : x ∈ ⊤
⊢ x ∈ p
state_after: case mp
R : Type u_1
M : Type u_2
r : R
x✝¹ y : M
inst✝² : Ring R
inst✝¹ : AddCommGroup M
inst✝ : Module R M
p p' : Submodule R M
h : Subsingleton (M ⧸ p)
x : M
x✝ : x ∈ ⊤
this : x - 0 ∈ p
⊢ x ∈ p

tactic: rwa [sub_zero] at this
state_before: case mp
R : Type u_1
M : Type u_2
r : R
x✝¹ y : M
inst✝² : Ring R
inst✝¹ : AddCommGroup M
inst✝ : Module R M
p p' : Submodule R M
h : Subsingleton (M ⧸ p)
x : M
x✝ : x ∈ ⊤
this : x - 0 ∈ p
⊢ x ∈ p
state_after: no goals

tactic: rintro rfl
state_before: case mpr
R : Type u_1
M : Type u_2
r : R
x y : M
inst✝² : Ring R
inst✝¹ : AddCommGroup M
inst✝ : Module R M
p p' : Submodule R M
⊢ p = ⊤ → Subsingleton (M ⧸ p)
state_after: case mpr
R : Type u_1
M : Type u_2
r : R
x y : M
inst✝² : Ring R
inst✝¹ : AddCommGroup M
inst✝ : Module R M
p' : Submodule R M
⊢ Subsingleton (M ⧸ ⊤)

tactic: infer_instance
state_before: case mpr
R : Type u_1
M : Type u_2
r : R
x y : M
inst✝² : Ring R
inst✝¹ : AddCommGroup M
inst✝ : Module R M
p' : Submodule R M
⊢ Subsingleton (M ⧸ ⊤)
state_after: no goals
Theorem: OrderIso.isLUB_image'
File: Mathlib/Order/Bounds/OrderIso.lean

tactic: rw [isLUB_image, f.symm_apply_apply]
state_before: α : Type u_1
β : Type u_2
inst✝¹ : Preorder α
inst✝ : Preorder β
f : α ≃o β
s : Set α
x : α
⊢ IsLUB (⇑f '' s) (f x) ↔ IsLUB s x
state_after: no goals