1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: WeierstrassCurve.Projective.equation_some
File: Mathlib/AlgebraicGeometry/EllipticCurve/Projective.lean

tactic: rw [equation_iff, W.toAffine.equation_iff]
state_before: R : Type u
inst✝ : CommRing R
W : Projective R
X Y : R
⊢ W.Equation ![X, Y, 1] ↔ W.toAffine.Equation X Y
state_after: R : Type u
inst✝ : CommRing R
W : Projective R
X Y : R
⊢ ![X, Y, 1] 1 ^ 2 * ![X, Y, 1] 2 + W.a₁ * ![X, Y, 1] 0 * ![X, Y, 1] 1 * ![X, Y, 1] 2 +
        W.a₃ * ![X, Y, 1] 1 * ![X, Y, 1] 2 ^ 2 =
      ![X, Y, 1] 0 ^ 3 + W.a₂ * ![X, Y, 1] 0 ^ 2 * ![X, Y, 1] 2 + W.a₄ * ![X, Y, 1] 0 * ![X, Y, 1] 2 ^ 2 +
        W.a₆ * ![X, Y, 1] 2 ^ 3 ↔
    Y ^ 2 + W.toAffine.a₁ * X * Y + W.toAffine.a₃ * Y =
      X ^ 3 + W.toAffine.a₂ * X ^ 2 + W.toAffine.a₄ * X + W.toAffine.a₆

tactic: congr! 1 <;> matrix_simp <;> ring1
state_before: R : Type u
inst✝ : CommRing R
W : Projective R
X Y : R
⊢ ![X, Y, 1] 1 ^ 2 * ![X, Y, 1] 2 + W.a₁ * ![X, Y, 1] 0 * ![X, Y, 1] 1 * ![X, Y, 1] 2 +
        W.a₃ * ![X, Y, 1] 1 * ![X, Y, 1] 2 ^ 2 =
      ![X, Y, 1] 0 ^ 3 + W.a₂ * ![X, Y, 1] 0 ^ 2 * ![X, Y, 1] 2 + W.a₄ * ![X, Y, 1] 0 * ![X, Y, 1] 2 ^ 2 +
        W.a₆ * ![X, Y, 1] 2 ^ 3 ↔
    Y ^ 2 + W.toAffine.a₁ * X * Y + W.toAffine.a₃ * Y =
      X ^ 3 + W.toAffine.a₂ * X ^ 2 + W.toAffine.a₄ * X + W.toAffine.a₆
state_after: no goals
Theorem: CategoryTheory.Limits.Sigma.ι_desc
File: Mathlib/CategoryTheory/Limits/Shapes/Products.lean

tactic: simp only [colimit.ι_desc, Cofan.mk_pt, Cofan.mk_ι_app]
state_before: β✝ : Type w
α : Type w₂
γ : Type w₃
C : Type u
inst✝¹ : Category.{v, u} C
β : Type w
f : β → C
inst✝ : HasCoproduct f
P : C
p : (b : β) → f b ⟶ P
b : β
⊢ ι f b ≫ desc p = p b
state_after: no goals
Theorem: MeasureTheory.stoppedValue_upperCrossingTime
File: Mathlib/Probability/Martingale/Upcrossing.lean

tactic: obtain ⟨j, hj₁, hj₂⟩ := (hitting_le_iff_of_lt _ (lt_of_le_of_ne upperCrossingTime_le h)).1 le_rfl
state_before: Ω : Type u_1
ι : Type u_2
m0 : MeasurableSpace Ω
μ : Measure Ω
a b : ℝ
f : ℕ → Ω → ℝ
N n m : ℕ
ω : Ω
h : upperCrossingTime a b f N (n + 1) ω ≠ N
⊢ b ≤ stoppedValue f (upperCrossingTime a b f N (n + 1)) ω
state_after: case intro.intro
Ω : Type u_1
ι : Type u_2
m0 : MeasurableSpace Ω
μ : Measure Ω
a b : ℝ
f : ℕ → Ω → ℝ
N n m : ℕ
ω : Ω
h : upperCrossingTime a b f N (n + 1) ω ≠ N
j : ℕ
hj₁ : j ∈ Set.Icc (lowerCrossingTimeAux a f (upperCrossingTime a b f N n ω) N ω) (upperCrossingTime a b f N (n + 1) ω)
hj₂ : f j ω ∈ Set.Ici b
⊢ b ≤ stoppedValue f (upperCrossingTime a b f N (n + 1)) ω

tactic: exact stoppedValue_hitting_mem ⟨j, ⟨hj₁.1, le_trans hj₁.2 (hitting_le _)⟩, hj₂⟩
state_before: case intro.intro
Ω : Type u_1
ι : Type u_2
m0 : MeasurableSpace Ω
μ : Measure Ω
a b : ℝ
f : ℕ → Ω → ℝ
N n m : ℕ
ω : Ω
h : upperCrossingTime a b f N (n + 1) ω ≠ N
j : ℕ
hj₁ : j ∈ Set.Icc (lowerCrossingTimeAux a f (upperCrossingTime a b f N n ω) N ω) (upperCrossingTime a b f N (n + 1) ω)
hj₂ : f j ω ∈ Set.Ici b
⊢ b ≤ stoppedValue f (upperCrossingTime a b f N (n + 1)) ω
state_after: no goals
Theorem: Finset.shadow_compls
File: Mathlib/Combinatorics/SetFamily/Shadow.lean

tactic: ext s
state_before: α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
𝒜 : Finset (Finset α)
s t : Finset α
a : α
k r : ℕ
⊢ ∂ 𝒜ᶜˢ = (∂⁺ 𝒜)ᶜˢ
state_after: case a
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
𝒜 : Finset (Finset α)
s✝ t : Finset α
a : α
k r : ℕ
s : Finset α
⊢ s ∈ ∂ 𝒜ᶜˢ ↔ s ∈ (∂⁺ 𝒜)ᶜˢ

tactic: simp only [mem_image, exists_prop, mem_shadow_iff, mem_upShadow_iff, mem_compls]
state_before: case a
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
𝒜 : Finset (Finset α)
s✝ t : Finset α
a : α
k r : ℕ
s : Finset α
⊢ s ∈ ∂ 𝒜ᶜˢ ↔ s ∈ (∂⁺ 𝒜)ᶜˢ
state_after: case a
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
𝒜 : Finset (Finset α)
s✝ t : Finset α
a : α
k r : ℕ
s : Finset α
⊢ (∃ s_1, s_1ᶜ ∈ 𝒜 ∧ ∃ a ∈ s_1, s_1.erase a = s) ↔ ∃ s_1 ∈ 𝒜, ∃ a ∉ s_1, insert a s_1 = sᶜ

tactic: refine (compl_involutive.toPerm _).exists_congr_left.trans ?_
state_before: case a
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
𝒜 : Finset (Finset α)
s✝ t : Finset α
a : α
k r : ℕ
s : Finset α
⊢ (∃ s_1, s_1ᶜ ∈ 𝒜 ∧ ∃ a ∈ s_1, s_1.erase a = s) ↔ ∃ s_1 ∈ 𝒜, ∃ a ∉ s_1, insert a s_1 = sᶜ
state_after: case a
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
𝒜 : Finset (Finset α)
s✝ t : Finset α
a : α
k r : ℕ
s : Finset α
⊢ (∃ b,
      ((Equiv.symm (Function.Involutive.toPerm compl ⋯)) b)ᶜ ∈ 𝒜 ∧
        ∃ a ∈ (Equiv.symm (Function.Involutive.toPerm compl ⋯)) b,
          ((Equiv.symm (Function.Involutive.toPerm compl ⋯)) b).erase a = s) ↔
    ∃ s_1 ∈ 𝒜, ∃ a ∉ s_1, insert a s_1 = sᶜ

tactic: simp [← compl_involutive.eq_iff]
state_before: case a
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Fintype α
𝒜 : Finset (Finset α)
s✝ t : Finset α
a : α
k r : ℕ
s : Finset α
⊢ (∃ b,
      ((Equiv.symm (Function.Involutive.toPerm compl ⋯)) b)ᶜ ∈ 𝒜 ∧
        ∃ a ∈ (Equiv.symm (Function.Involutive.toPerm compl ⋯)) b,
          ((Equiv.symm (Function.Involutive.toPerm compl ⋯)) b).erase a = s) ↔
    ∃ s_1 ∈ 𝒜, ∃ a ∉ s_1, insert a s_1 = sᶜ
state_after: no goals
Theorem: mul_right_eq_self₀
File: Mathlib/Algebra/GroupWithZero/Basic.lean

tactic: rw [mul_one]
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✝ : CancelMonoidWithZero M₀
a b c : M₀
⊢ a * b = a ↔ a * b = a * 1
state_after: no goals
Theorem: Composition.blocksFun_sigmaCompositionAux
File: Mathlib/Analysis/Analytic/Composition.lean

tactic: rw [get_of_eq (get_splitWrtComposition _ _ _), get_drop', get_take']
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
H : Type u_5
inst✝⁸ : NontriviallyNormedField 𝕜
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
inst✝¹ : NormedAddCommGroup H
inst✝ : NormedSpace 𝕜 H
n : ℕ
a : Composition n
b : Composition a.length
i : Fin b.length
j : Fin (b.blocksFun i)
⊢ ((a.blocks.splitWrtComposition b).get ⟨↑⟨↑i, ⋯⟩, ⋯⟩).get ⟨↑j, ⋯⟩ =
    a.blocks.get ⟨↑((Fin.natAddOrderEmb (b.sizeUpTo ↑i)).toEmbedding j), ⋯⟩
state_after: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
H : Type u_5
inst✝⁸ : NontriviallyNormedField 𝕜
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
inst✝¹ : NormedAddCommGroup H
inst✝ : NormedSpace 𝕜 H
n : ℕ
a : Composition n
b : Composition a.length
i : Fin b.length
j : Fin (b.blocksFun i)
⊢ a.blocks.get ⟨↑⟨b.sizeUpTo ↑⟨↑⟨↑i, ⋯⟩, ⋯⟩ + ↑⟨↑⟨↑j, ⋯⟩, ⋯⟩, ⋯⟩, ⋯⟩ =
    a.blocks.get ⟨↑((Fin.natAddOrderEmb (b.sizeUpTo ↑i)).toEmbedding j), ⋯⟩

tactic: rfl
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
H : Type u_5
inst✝⁸ : NontriviallyNormedField 𝕜
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
inst✝¹ : NormedAddCommGroup H
inst✝ : NormedSpace 𝕜 H
n : ℕ
a : Composition n
b : Composition a.length
i : Fin b.length
j : Fin (b.blocksFun i)
⊢ a.blocks.get ⟨↑⟨b.sizeUpTo ↑⟨↑⟨↑i, ⋯⟩, ⋯⟩ + ↑⟨↑⟨↑j, ⋯⟩, ⋯⟩, ⋯⟩, ⋯⟩ =
    a.blocks.get ⟨↑((Fin.natAddOrderEmb (b.sizeUpTo ↑i)).toEmbedding j), ⋯⟩
state_after: no goals
Theorem: Real.nnnorm_abs
File: Mathlib/Analysis/Normed/Group/Basic.lean

tactic: simp [nnnorm]
state_before: 𝓕 : Type u_1
𝕜 : Type u_2
α : Type u_3
ι : Type u_4
κ : Type u_5
E : Type u_6
F : Type u_7
G : Type u_8
inst✝¹ : SeminormedCommGroup E
inst✝ : SeminormedCommGroup F
a a₁ a₂ b b₁ b₂ : E
r✝ r₁ r₂ r : ℝ
⊢ ‖|r|‖₊ = ‖r‖₊
state_after: no goals
Theorem: equicontinuousAt_restrict_iff
File: Mathlib/Topology/UniformSpace/Equicontinuity.lean

tactic: simp [EquicontinuousWithinAt, EquicontinuousAt,
  ← eventually_nhds_subtype_iff]
state_before: ι : Type u_1
κ : Type u_2
X : Type u_3
X' : Type u_4
Y : Type u_5
Z : Type u_6
α : Type u_7
α' : Type u_8
β : Type u_9
β' : Type u_10
γ : Type u_11
𝓕 : Type u_12
tX : TopologicalSpace X
tY : TopologicalSpace Y
tZ : TopologicalSpace Z
uα : UniformSpace α
uβ : UniformSpace β
uγ : UniformSpace γ
F : ι → X → α
S : Set X
x₀ : ↑S
⊢ EquicontinuousAt (S.restrict ∘ F) x₀ ↔ EquicontinuousWithinAt F S ↑x₀
state_after: no goals
Theorem: Matrix.toMvPolynomial_isHomogeneous
File: Mathlib/Algebra/Module/LinearMap/Polynomial.lean

tactic: apply MvPolynomial.IsHomogeneous.sum
state_before: m : Type u_1
n : Type u_2
o : Type u_3
R : Type u_4
S : Type u_5
inst✝³ : Fintype n
inst✝² : Fintype o
inst✝¹ : CommSemiring R
inst✝ : CommSemiring S
M : Matrix m n R
i : m
⊢ (M.toMvPolynomial i).IsHomogeneous 1
state_after: case h
m : Type u_1
n : Type u_2
o : Type u_3
R : Type u_4
S : Type u_5
inst✝³ : Fintype n
inst✝² : Fintype o
inst✝¹ : CommSemiring R
inst✝ : CommSemiring S
M : Matrix m n R
i : m
⊢ ∀ i_1 ∈ Finset.univ, ((monomial (Finsupp.single i_1 1)) (M i i_1)).IsHomogeneous 1

tactic: rintro j -
state_before: case h
m : Type u_1
n : Type u_2
o : Type u_3
R : Type u_4
S : Type u_5
inst✝³ : Fintype n
inst✝² : Fintype o
inst✝¹ : CommSemiring R
inst✝ : CommSemiring S
M : Matrix m n R
i : m
⊢ ∀ i_1 ∈ Finset.univ, ((monomial (Finsupp.single i_1 1)) (M i i_1)).IsHomogeneous 1
state_after: case h
m : Type u_1
n : Type u_2
o : Type u_3
R : Type u_4
S : Type u_5
inst✝³ : Fintype n
inst✝² : Fintype o
inst✝¹ : CommSemiring R
inst✝ : CommSemiring S
M : Matrix m n R
i : m
j : n
⊢ ((monomial (Finsupp.single j 1)) (M i j)).IsHomogeneous 1

tactic: apply MvPolynomial.isHomogeneous_monomial _ _
state_before: case h
m : Type u_1
n : Type u_2
o : Type u_3
R : Type u_4
S : Type u_5
inst✝³ : Fintype n
inst✝² : Fintype o
inst✝¹ : CommSemiring R
inst✝ : CommSemiring S
M : Matrix m n R
i : m
j : n
⊢ ((monomial (Finsupp.single j 1)) (M i j)).IsHomogeneous 1
state_after: m : Type u_1
n : Type u_2
o : Type u_3
R : Type u_4
S : Type u_5
inst✝³ : Fintype n
inst✝² : Fintype o
inst✝¹ : CommSemiring R
inst✝ : CommSemiring S
M : Matrix m n R
i : m
j : n
⊢ degree (Finsupp.single j 1) = 1

tactic: rw [degree, Finsupp.support_single_ne_zero _ one_ne_zero, Finset.sum_singleton,
  Finsupp.single_eq_same]
state_before: m : Type u_1
n : Type u_2
o : Type u_3
R : Type u_4
S : Type u_5
inst✝³ : Fintype n
inst✝² : Fintype o
inst✝¹ : CommSemiring R
inst✝ : CommSemiring S
M : Matrix m n R
i : m
j : n
⊢ degree (Finsupp.single j 1) = 1
state_after: no goals
Theorem: Multipliable.comp_injective
File: Mathlib/Topology/Algebra/InfiniteSum/Group.lean

tactic: simpa only [Set.mulIndicator_range_comp] using
  (hi.multipliable_iff (fun x hx ↦ Set.mulIndicator_of_not_mem hx _)).2
  (hf.mulIndicator (Set.range i))
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝³ : CommGroup α
inst✝² : UniformSpace α
inst✝¹ : UniformGroup α
f g : β → α
a a₁ a₂ : α
inst✝ : CompleteSpace α
i : γ → β
hf : Multipliable f
hi : Injective i
⊢ Multipliable (f ∘ i)
state_after: no goals
Theorem: Dense.eq_zero_of_inner_left
File: Mathlib/Analysis/InnerProductSpace/Projection.lean

tactic: simpa using congr_fun this x
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁴ : _root_.RCLike 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : NormedAddCommGroup F
inst✝¹ : InnerProductSpace 𝕜 E
inst✝ : InnerProductSpace ℝ F
K : Submodule 𝕜 E
x y : E
hK : Dense ↑K
h : ∀ (v : ↥K), ⟪x, ↑v⟫_𝕜 = 0
this : (fun x_1 => ⟪x, x_1⟫_𝕜) = 0
⊢ x = 0
state_after: no goals
Theorem: WithTop.add_eq_top
File: Mathlib/Algebra/Order/Monoid/WithTop.lean

tactic: match a, b with
| ⊤, _ => simp
| _, ⊤ => simp
| (a : α), (b : α) => simp only [← coe_add, coe_ne_top, or_false]
state_before: α : Type u
β : Type v
inst✝ : Add α
a b c d : WithTop α
x y : α
⊢ a + b = ⊤ ↔ a = ⊤ ∨ b = ⊤
state_after: no goals

tactic: simp
state_before: α : Type u
β : Type v
inst✝ : Add α
a b c d : WithTop α
x y : α
x✝ : WithTop α
⊢ ⊤ + x✝ = ⊤ ↔ ⊤ = ⊤ ∨ x✝ = ⊤
state_after: no goals

tactic: simp
state_before: α : Type u
β : Type v
inst✝ : Add α
a b c d : WithTop α
x y : α
x✝ : WithTop α
⊢ x✝ + ⊤ = ⊤ ↔ x✝ = ⊤ ∨ ⊤ = ⊤
state_after: no goals

tactic: simp only [← coe_add, coe_ne_top, or_false]
state_before: α : Type u
β : Type v
inst✝ : Add α
a✝ b✝ c d : WithTop α
x y a b : α
⊢ ↑a + ↑b = ⊤ ↔ ↑a = ⊤ ∨ ↑b = ⊤
state_after: no goals
Theorem: Fin.cons_one
File: Mathlib/Data/Fin/Tuple/Basic.lean

tactic: rw [← cons_succ x p]
state_before: m n : ℕ
α✝ : Fin (n + 1) → Type u
x✝ : α✝ 0
q : (i : Fin (n + 1)) → α✝ i
p✝ : (i : Fin n) → α✝ i.succ
i : Fin n
y : α✝ i.succ
z : α✝ 0
α : Fin (n + 2) → Type u_1
x : α 0
p : (i : Fin n.succ) → α i.succ
⊢ cons x p 1 = p 0
state_after: m n : ℕ
α✝ : Fin (n + 1) → Type u
x✝ : α✝ 0
q : (i : Fin (n + 1)) → α✝ i
p✝ : (i : Fin n) → α✝ i.succ
i : Fin n
y : α✝ i.succ
z : α✝ 0
α : Fin (n + 2) → Type u_1
x : α 0
p : (i : Fin n.succ) → α i.succ
⊢ cons x p 1 = cons x p (succ 0)

tactic: rfl
state_before: m n : ℕ
α✝ : Fin (n + 1) → Type u
x✝ : α✝ 0
q : (i : Fin (n + 1)) → α✝ i
p✝ : (i : Fin n) → α✝ i.succ
i : Fin n
y : α✝ i.succ
z : α✝ 0
α : Fin (n + 2) → Type u_1
x : α 0
p : (i : Fin n.succ) → α i.succ
⊢ cons x p 1 = cons x p (succ 0)
state_after: no goals
Theorem: eq_iff_eq_cancel_right
File: Mathlib/Logic/Basic.lean

tactic: rw [h]
state_before: α : Sort u_1
a b : α
h : ∀ {c : α}, a = c ↔ b = c
⊢ a = b
state_after: no goals

tactic: rw [h]
state_before: α : Sort u_1
a✝ b : α
h : a✝ = b
a : α
⊢ a✝ = a ↔ b = a
state_after: no goals
Theorem: Finmap.liftOn_toFinmap
File: Mathlib/Data/Finmap.lean

tactic: cases s
state_before: α : Type u
β : α → Type v
γ : Type u_1
s : AList β
f : AList β → γ
H : ∀ (a b : AList β), a.entries ~ b.entries → f a = f b
⊢ ⟦s⟧.liftOn f H = f s
state_after: case mk
α : Type u
β : α → Type v
γ : Type u_1
f : AList β → γ
H : ∀ (a b : AList β), a.entries ~ b.entries → f a = f b
entries✝ : List (Sigma β)
nodupKeys✝ : entries✝.NodupKeys
⊢ ⟦{ entries := entries✝, nodupKeys := nodupKeys✝ }⟧.liftOn f H = f { entries := entries✝, nodupKeys := nodupKeys✝ }

tactic: rfl
state_before: case mk
α : Type u
β : α → Type v
γ : Type u_1
f : AList β → γ
H : ∀ (a b : AList β), a.entries ~ b.entries → f a = f b
entries✝ : List (Sigma β)
nodupKeys✝ : entries✝.NodupKeys
⊢ ⟦{ entries := entries✝, nodupKeys := nodupKeys✝ }⟧.liftOn f H = f { entries := entries✝, nodupKeys := nodupKeys✝ }
state_after: no goals
Theorem: Fin.prod_univ_succAbove
File: Mathlib/Algebra/BigOperators/Fin.lean

tactic: rw [univ_succAbove, prod_cons, Finset.prod_map _ x.succAboveEmb]
state_before: α : Type u_1
β : Type u_2
inst✝ : CommMonoid β
n : ℕ
f : Fin (n + 1) → β
x : Fin (n + 1)
⊢ ∏ i : Fin (n + 1), f i = f x * ∏ i : Fin n, f (x.succAbove i)
state_after: α : Type u_1
β : Type u_2
inst✝ : CommMonoid β
n : ℕ
f : Fin (n + 1) → β
x : Fin (n + 1)
⊢ f x * ∏ x_1 : Fin n, f (x.succAboveEmb x_1) = f x * ∏ i : Fin n, f (x.succAbove i)

tactic: rfl
state_before: α : Type u_1
β : Type u_2
inst✝ : CommMonoid β
n : ℕ
f : Fin (n + 1) → β
x : Fin (n + 1)
⊢ f x * ∏ x_1 : Fin n, f (x.succAboveEmb x_1) = f x * ∏ i : Fin n, f (x.succAbove i)
state_after: no goals
Theorem: Set.card_image_of_inj_on
File: Mathlib/Data/Set/Finite.lean

tactic: simp
state_before: α : Type u
β : Type v
ι : Sort w
γ : Type x
s : Set α
inst✝¹ : Fintype ↑s
f : α → β
inst✝ : Fintype ↑(f '' s)
H : ∀ x ∈ s, ∀ y ∈ s, f x = f y → x = y
this : (a : Prop) → Decidable a
⊢ ∀ (x : β), x ∈ Finset.image f s.toFinset ↔ x ∈ f '' s
state_after: no goals
Theorem: Ordinal.apply_le_nfpBFamily
File: Mathlib/SetTheory/Ordinal/FixedPoint.lean

tactic: refine ⟨fun h => ?_, fun h i hi => ?_⟩
state_before: o : Ordinal.{u}
f : (b : Ordinal.{u}) → b < o → Ordinal.{max u v} → Ordinal.{max u v}
ho : o ≠ 0
H : ∀ (i : Ordinal.{u}) (hi : i < o), IsNormal (f i hi)
a : Ordinal.{max v u}
b : Ordinal.{max u v}
⊢ (∀ (i : Ordinal.{u}) (hi : i < o), f i hi b ≤ o.nfpBFamily f a) ↔ b ≤ o.nfpBFamily f a
state_after: case refine_1
o : Ordinal.{u}
f : (b : Ordinal.{u}) → b < o → Ordinal.{max u v} → Ordinal.{max u v}
ho : o ≠ 0
H : ∀ (i : Ordinal.{u}) (hi : i < o), IsNormal (f i hi)
a : Ordinal.{max v u}
b : Ordinal.{max u v}
h : ∀ (i : Ordinal.{u}) (hi : i < o), f i hi b ≤ o.nfpBFamily f a
⊢ b ≤ o.nfpBFamily f a

case refine_2
o : Ordinal.{u}
f : (b : Ordinal.{u}) → b < o → Ordinal.{max u v} → Ordinal.{max u v}
ho : o ≠ 0
H : ∀ (i : Ordinal.{u}) (hi : i < o), IsNormal (f i hi)
a : Ordinal.{max v u}
b : Ordinal.{max u v}
h : b ≤ o.nfpBFamily f a
i : Ordinal.{u}
hi : i < o
⊢ f i hi b ≤ o.nfpBFamily f a

tactic: have ho' : 0 < o := Ordinal.pos_iff_ne_zero.2 ho
state_before: case refine_1
o : Ordinal.{u}
f : (b : Ordinal.{u}) → b < o → Ordinal.{max u v} → Ordinal.{max u v}
ho : o ≠ 0
H : ∀ (i : Ordinal.{u}) (hi : i < o), IsNormal (f i hi)
a : Ordinal.{max v u}
b : Ordinal.{max u v}
h : ∀ (i : Ordinal.{u}) (hi : i < o), f i hi b ≤ o.nfpBFamily f a
⊢ b ≤ o.nfpBFamily f a
state_after: case refine_1
o : Ordinal.{u}
f : (b : Ordinal.{u}) → b < o → Ordinal.{max u v} → Ordinal.{max u v}
ho : o ≠ 0
H : ∀ (i : Ordinal.{u}) (hi : i < o), IsNormal (f i hi)
a : Ordinal.{max v u}
b : Ordinal.{max u v}
h : ∀ (i : Ordinal.{u}) (hi : i < o), f i hi b ≤ o.nfpBFamily f a
ho' : 0 < o
⊢ b ≤ o.nfpBFamily f a

tactic: exact ((H 0 ho').self_le b).trans (h 0 ho')
state_before: case refine_1
o : Ordinal.{u}
f : (b : Ordinal.{u}) → b < o → Ordinal.{max u v} → Ordinal.{max u v}
ho : o ≠ 0
H : ∀ (i : Ordinal.{u}) (hi : i < o), IsNormal (f i hi)
a : Ordinal.{max v u}
b : Ordinal.{max u v}
h : ∀ (i : Ordinal.{u}) (hi : i < o), f i hi b ≤ o.nfpBFamily f a
ho' : 0 < o
⊢ b ≤ o.nfpBFamily f a
state_after: no goals

tactic: rw [← nfpBFamily_fp (H i hi)]
state_before: case refine_2
o : Ordinal.{u}
f : (b : Ordinal.{u}) → b < o → Ordinal.{max u v} → Ordinal.{max u v}
ho : o ≠ 0
H : ∀ (i : Ordinal.{u}) (hi : i < o), IsNormal (f i hi)
a : Ordinal.{max v u}
b : Ordinal.{max u v}
h : b ≤ o.nfpBFamily f a
i : Ordinal.{u}
hi : i < o
⊢ f i hi b ≤ o.nfpBFamily f a
state_after: case refine_2
o : Ordinal.{u}
f : (b : Ordinal.{u}) → b < o → Ordinal.{max u v} → Ordinal.{max u v}
ho : o ≠ 0
H : ∀ (i : Ordinal.{u}) (hi : i < o), IsNormal (f i hi)
a : Ordinal.{max v u}
b : Ordinal.{max u v}
h : b ≤ o.nfpBFamily f a
i : Ordinal.{u}
hi : i < o
⊢ f i hi b ≤ f i hi (o.nfpBFamily f a)

tactic: exact (H i hi).monotone h
state_before: case refine_2
o : Ordinal.{u}
f : (b : Ordinal.{u}) → b < o → Ordinal.{max u v} → Ordinal.{max u v}
ho : o ≠ 0
H : ∀ (i : Ordinal.{u}) (hi : i < o), IsNormal (f i hi)
a : Ordinal.{max v u}
b : Ordinal.{max u v}
h : b ≤ o.nfpBFamily f a
i : Ordinal.{u}
hi : i < o
⊢ f i hi b ≤ f i hi (o.nfpBFamily f a)
state_after: no goals
Theorem: SimpleGraph.Preconnected.ofBoxProdLeft
File: Mathlib/Combinatorics/SimpleGraph/Prod.lean

tactic: classical
rintro a₁ a₂
obtain ⟨w⟩ := h (a₁, Classical.arbitrary _) (a₂, Classical.arbitrary _)
exact ⟨w.ofBoxProdLeft⟩
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
G : SimpleGraph α
H : SimpleGraph β
inst✝ : Nonempty β
h : (G □ H).Preconnected
⊢ G.Preconnected
state_after: no goals

tactic: rintro a₁ a₂
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
G : SimpleGraph α
H : SimpleGraph β
inst✝ : Nonempty β
h : (G □ H).Preconnected
⊢ G.Preconnected
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
G : SimpleGraph α
H : SimpleGraph β
inst✝ : Nonempty β
h : (G □ H).Preconnected
a₁ a₂ : α
⊢ G.Reachable a₁ a₂

tactic: obtain ⟨w⟩ := h (a₁, Classical.arbitrary _) (a₂, Classical.arbitrary _)
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
G : SimpleGraph α
H : SimpleGraph β
inst✝ : Nonempty β
h : (G □ H).Preconnected
a₁ a₂ : α
⊢ G.Reachable a₁ a₂
state_after: case intro
α : Type u_1
β : Type u_2
γ : Type u_3
G : SimpleGraph α
H : SimpleGraph β
inst✝ : Nonempty β
h : (G □ H).Preconnected
a₁ a₂ : α
w : (G □ H).Walk (a₁, Classical.arbitrary β) (a₂, Classical.arbitrary β)
⊢ G.Reachable a₁ a₂

tactic: exact ⟨w.ofBoxProdLeft⟩
state_before: case intro
α : Type u_1
β : Type u_2
γ : Type u_3
G : SimpleGraph α
H : SimpleGraph β
inst✝ : Nonempty β
h : (G □ H).Preconnected
a₁ a₂ : α
w : (G □ H).Walk (a₁, Classical.arbitrary β) (a₂, Classical.arbitrary β)
⊢ G.Reachable a₁ a₂
state_after: no goals
Theorem: Complex.volume_preserving_equiv_pi
File: Mathlib/MeasureTheory/Measure/Lebesgue/Complex.lean

tactic: convert (measurableEquivPi.symm.measurable.measurePreserving volume).symm
state_before: ⊢ MeasurePreserving (⇑measurableEquivPi) volume volume
state_after: case h.e'_6

⊢ volume = Measure.map (⇑measurableEquivPi.symm) volume

tactic: rw [← addHaarMeasure_eq_volume_pi, ← Basis.parallelepiped_basisFun, ← Basis.addHaar,
  measurableEquivPi, Homeomorph.toMeasurableEquiv_symm_coe,
  ContinuousLinearEquiv.symm_toHomeomorph, ContinuousLinearEquiv.coe_toHomeomorph,
  Basis.map_addHaar, eq_comm]
state_before: case h.e'_6

⊢ volume = Measure.map (⇑measurableEquivPi.symm) volume
state_after: case h.e'_6

⊢ ((Pi.basisFun ℝ (Fin 2)).map basisOneI.equivFun.toContinuousLinearEquiv.symm.toLinearEquiv).addHaar = volume

tactic: exact (Basis.addHaar_eq_iff _ _).mpr Complex.orthonormalBasisOneI.volume_parallelepiped
state_before: case h.e'_6

⊢ ((Pi.basisFun ℝ (Fin 2)).map basisOneI.equivFun.toContinuousLinearEquiv.symm.toLinearEquiv).addHaar = volume
state_after: no goals
Theorem: continuousInv_iInf
File: Mathlib/Topology/Algebra/Group/Basic.lean

tactic: exact continuousInv_sInf (Set.forall_mem_range.mpr h')
state_before: G : Type w
H : Type x
α : Type u
β : Type v
ι' : Sort u_1
inst✝ : Inv G
ts' : ι' → TopologicalSpace G
h' : ∀ (i : ι'), ContinuousInv G
⊢ ContinuousInv G
state_after: no goals
Theorem: NormedAddGroupHom.toAddMonoidHom_injective
File: Mathlib/Analysis/Normed/Group/Hom.lean

tactic: rw [← coe_toAddMonoidHom f, ← coe_toAddMonoidHom g, h]
state_before: V : Type u_1
V₁ : Type u_2
V₂ : Type u_3
V₃ : Type u_4
inst✝³ : SeminormedAddCommGroup V
inst✝² : SeminormedAddCommGroup V₁
inst✝¹ : SeminormedAddCommGroup V₂
inst✝ : SeminormedAddCommGroup V₃
f✝ g✝ f g : NormedAddGroupHom V₁ V₂
h : f.toAddMonoidHom = g.toAddMonoidHom
⊢ ⇑f = ⇑g
state_after: no goals
Theorem: Real.toNNReal_lt_iff_lt_coe
File: Mathlib/Data/NNReal/Basic.lean

tactic: rw [← NNReal.coe_lt_coe, Real.coe_toNNReal r ha]
state_before: r : ℝ
p : ℝ≥0
ha : 0 ≤ r
⊢ r.toNNReal < p ↔ r < ↑p
state_after: no goals
Theorem: Finset.orderEmbOfFin_singleton
File: Mathlib/Data/Finset/Sort.lean

tactic: rw [Subsingleton.elim i ⟨0, Nat.zero_lt_one⟩, orderEmbOfFin_zero _ Nat.zero_lt_one,
  min'_singleton]
state_before: α : Type u_1
β : Type u_2
inst✝ : LinearOrder α
a : α
i : Fin 1
⊢ ({a}.orderEmbOfFin ⋯) i = a
state_after: no goals
Theorem: Real.eulerMascheroniConstant_lt_eulerMascheroniSeq'
File: Mathlib/NumberTheory/Harmonic/EulerMascheroni.lean

tactic: refine lt_of_le_of_lt ?_ (strictAnti_eulerMascheroniSeq' (Nat.lt_succ_self n))
state_before: n : ℕ
⊢ eulerMascheroniConstant < eulerMascheroniSeq' n
state_after: n : ℕ
⊢ eulerMascheroniConstant ≤ eulerMascheroniSeq' n.succ

tactic: apply strictAnti_eulerMascheroniSeq'.antitone.le_of_tendsto tendsto_eulerMascheroniSeq'
state_before: n : ℕ
⊢ eulerMascheroniConstant ≤ eulerMascheroniSeq' n.succ
state_after: no goals
Theorem: Surreal.Multiplication.P3_of_ih
File: Mathlib/SetTheory/Surreal/Multiplication.lean

tactic: rw [← moveRight_neg_symm]
state_before: x x₁ x₂ x₃ x' y y₁ y₂ y₃ y' : PGame
ih : ∀ (a : Args), ArgsRel a (Args.P1 x y) → P124 a
hy : y.Numeric
ihyx : IH1 y x
i : x.LeftMoves
k : y.LeftMoves
l : (-y).LeftMoves
⊢ y.moveLeft k < -(-y).moveLeft l
state_after: x x₁ x₂ x₃ x' y y₁ y₂ y₃ y' : PGame
ih : ∀ (a : Args), ArgsRel a (Args.P1 x y) → P124 a
hy : y.Numeric
ihyx : IH1 y x
i : x.LeftMoves
k : y.LeftMoves
l : (-y).LeftMoves
⊢ y.moveLeft k < y.moveRight (toLeftMovesNeg.symm l)

tactic: apply hy.left_lt_right
state_before: x x₁ x₂ x₃ x' y y₁ y₂ y₃ y' : PGame
ih : ∀ (a : Args), ArgsRel a (Args.P1 x y) → P124 a
hy : y.Numeric
ihyx : IH1 y x
i : x.LeftMoves
k : y.LeftMoves
l : (-y).LeftMoves
⊢ y.moveLeft k < y.moveRight (toLeftMovesNeg.symm l)
state_after: no goals
Theorem: WittVector.constantCoeff_wittNeg
File: Mathlib/RingTheory/WittVector/Defs.lean

tactic: apply constantCoeff_wittStructureInt p _ _ n
state_before: p : ℕ
R : Type u_1
hp : Fact (Nat.Prime p)
inst✝ : CommRing R
n : ℕ
⊢ constantCoeff (wittNeg p n) = 0
state_after: p : ℕ
R : Type u_1
hp : Fact (Nat.Prime p)
inst✝ : CommRing R
n : ℕ
⊢ constantCoeff (-X 0) = 0

tactic: simp only [neg_zero, RingHom.map_neg, constantCoeff_X]
state_before: p : ℕ
R : Type u_1
hp : Fact (Nat.Prime p)
inst✝ : CommRing R
n : ℕ
⊢ constantCoeff (-X 0) = 0
state_after: no goals