1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: LSeries.abscissaOfAbsConv_le_of_forall_lt_LSeriesSummable
File: Mathlib/NumberTheory/LSeries/Convergence.lean

tactic: refine sInf_le_iff.mpr fun y hy ↦ ?_
state_before: f : ℕ → ℂ
x : ℝ
h : ∀ (y : ℝ), x < y → LSeriesSummable f ↑y
⊢ abscissaOfAbsConv f ≤ ↑x
state_after: f : ℕ → ℂ
x : ℝ
h : ∀ (y : ℝ), x < y → LSeriesSummable f ↑y
y : EReal
hy : y ∈ lowerBounds (Real.toEReal '' {x | LSeriesSummable f ↑x})
⊢ y ≤ ↑x

tactic: simp only [mem_lowerBounds, Set.mem_image, Set.mem_setOf_eq, forall_exists_index, and_imp,
  forall_apply_eq_imp_iff₂] at hy
state_before: f : ℕ → ℂ
x : ℝ
h : ∀ (y : ℝ), x < y → LSeriesSummable f ↑y
y : EReal
hy : y ∈ lowerBounds (Real.toEReal '' {x | LSeriesSummable f ↑x})
⊢ y ≤ ↑x
state_after: f : ℕ → ℂ
x : ℝ
h : ∀ (y : ℝ), x < y → LSeriesSummable f ↑y
y : EReal
hy : ∀ (a : ℝ), LSeriesSummable f ↑a → y ≤ ↑a
⊢ y ≤ ↑x

tactic: exact Set.Ioi_subset_Ici_iff.mp H
state_before: f : ℕ → ℂ
x : ℝ
h : ∀ (y : ℝ), x < y → LSeriesSummable f ↑y
y : EReal
hy : ∀ (a : ℝ), LSeriesSummable f ↑a → y ≤ ↑a
H : ∀ (a : EReal), ↑x < a → y ≤ a
⊢ y ≤ ↑x
state_after: no goals

tactic: induction' a with a₀
state_before: f : ℕ → ℂ
x : ℝ
h : ∀ (y : ℝ), x < y → LSeriesSummable f ↑y
y : EReal
hy : ∀ (a : ℝ), LSeriesSummable f ↑a → y ≤ ↑a
a : EReal
⊢ ↑x < a → y ≤ a
state_after: case h_bot
f : ℕ → ℂ
x : ℝ
h : ∀ (y : ℝ), x < y → LSeriesSummable f ↑y
y : EReal
hy : ∀ (a : ℝ), LSeriesSummable f ↑a → y ≤ ↑a
⊢ ↑x < ⊥ → y ≤ ⊥

case h_real
f : ℕ → ℂ
x : ℝ
h : ∀ (y : ℝ), x < y → LSeriesSummable f ↑y
y : EReal
hy : ∀ (a : ℝ), LSeriesSummable f ↑a → y ≤ ↑a
a₀ : ℝ
⊢ ↑x < ↑a₀ → y ≤ ↑a₀

case h_top
f : ℕ → ℂ
x : ℝ
h : ∀ (y : ℝ), x < y → LSeriesSummable f ↑y
y : EReal
hy : ∀ (a : ℝ), LSeriesSummable f ↑a → y ≤ ↑a
⊢ ↑x < ⊤ → y ≤ ⊤

tactic: simp only [not_lt_bot, le_bot_iff, IsEmpty.forall_iff]
state_before: case h_bot
f : ℕ → ℂ
x : ℝ
h : ∀ (y : ℝ), x < y → LSeriesSummable f ↑y
y : EReal
hy : ∀ (a : ℝ), LSeriesSummable f ↑a → y ≤ ↑a
⊢ ↑x < ⊥ → y ≤ ⊥
state_after: no goals

tactic: exact_mod_cast fun ha ↦ hy a₀ (h a₀ ha)
state_before: case h_real
f : ℕ → ℂ
x : ℝ
h : ∀ (y : ℝ), x < y → LSeriesSummable f ↑y
y : EReal
hy : ∀ (a : ℝ), LSeriesSummable f ↑a → y ≤ ↑a
a₀ : ℝ
⊢ ↑x < ↑a₀ → y ≤ ↑a₀
state_after: no goals

tactic: simp only [EReal.coe_lt_top, le_top, forall_true_left]
state_before: case h_top
f : ℕ → ℂ
x : ℝ
h : ∀ (y : ℝ), x < y → LSeriesSummable f ↑y
y : EReal
hy : ∀ (a : ℝ), LSeriesSummable f ↑a → y ≤ ↑a
⊢ ↑x < ⊤ → y ≤ ⊤
state_after: no goals
Theorem: tendsto_div_nhds_one_iff
File: Mathlib/Topology/Algebra/Group/Basic.lean

tactic: simpa using h.mul A
state_before: G : Type w
H : Type x
α✝ : Type u
β : Type v
inst✝² : Group G
inst✝¹ : TopologicalSpace G
inst✝ : TopologicalGroup G
α : Type u_1
l : Filter α
x : G
u : α → G
A : Tendsto (fun x_1 => x) l (𝓝 x)
h : Tendsto (fun x_1 => u x_1 / x) l (𝓝 1)
⊢ Tendsto u l (𝓝 x)
state_after: no goals

tactic: simpa using h.div' A
state_before: G : Type w
H : Type x
α✝ : Type u
β : Type v
inst✝² : Group G
inst✝¹ : TopologicalSpace G
inst✝ : TopologicalGroup G
α : Type u_1
l : Filter α
x : G
u : α → G
A : Tendsto (fun x_1 => x) l (𝓝 x)
h : Tendsto u l (𝓝 x)
⊢ Tendsto (fun x_1 => u x_1 / x) l (𝓝 1)
state_after: no goals
Theorem: setIntegral_withDensity_eq_setIntegral_smul₀
File: Mathlib/MeasureTheory/Integral/SetIntegral.lean

tactic: rw [restrict_withDensity hs, integral_withDensity_eq_integral_smul₀ hf]
state_before: X : Type u_1
Y : Type u_2
E : Type u_3
F : Type u_4
inst✝⁷ : MeasurableSpace X
μ : Measure X
𝕜 : Type u_5
inst✝⁶ : RCLike 𝕜
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedSpace 𝕜 E
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
p : ℝ≥0∞
inst✝¹ : NormedSpace ℝ E
inst✝ : NormedSpace ℝ F
f : X → ℝ≥0
s : Set X
hf : AEMeasurable f (μ.restrict s)
g : X → E
hs : MeasurableSet s
⊢ (∫ (x : X) in s, g x ∂μ.withDensity fun x => ↑(f x)) = ∫ (x : X) in s, f x • g x ∂μ
state_after: no goals
Theorem: mulRothNumber_map_mul_right
File: Mathlib/Combinatorics/Additive/AP/Three/Defs.lean

tactic: rw [← mulLeftEmbedding_eq_mulRightEmbedding, mulRothNumber_map_mul_left s a]
state_before: F : Type u_1
α : Type u_2
β : Type u_3
𝕜 : Type u_4
E : Type u_5
inst✝¹ : DecidableEq α
inst✝ : CancelCommMonoid α
s : Finset α
a : α
⊢ mulRothNumber (map (mulRightEmbedding a) s) = mulRothNumber s
state_after: no goals
Theorem: Multiset.mk_mem_sym2_iff
File: Mathlib/Data/Multiset/Sym.lean

tactic: simp [List.mk_mem_sym2_iff]
state_before: α : Type u_1
m : Multiset α
a b : α
xs : List α
⊢ s(a, b) ∈ Multiset.sym2 ⟦xs⟧ ↔ a ∈ ⟦xs⟧ ∧ b ∈ ⟦xs⟧
state_after: no goals
Theorem: IsTensorProduct.lift_eq
File: Mathlib/RingTheory/IsTensorProduct.lean

tactic: delta IsTensorProduct.lift
state_before: R : Type u_1
inst✝¹⁴ : CommSemiring R
M₁ : Type u_2
M₂ : Type u_3
M : Type u_4
M' : Type u_5
inst✝¹³ : AddCommMonoid M₁
inst✝¹² : AddCommMonoid M₂
inst✝¹¹ : AddCommMonoid M
inst✝¹⁰ : AddCommMonoid M'
inst✝⁹ : Module R M₁
inst✝⁸ : Module R M₂
inst✝⁷ : Module R M
inst✝⁶ : Module R M'
f : M₁ →ₗ[R] M₂ →ₗ[R] M
N₁ : Type u_6
N₂ : Type u_7
N : Type u_8
inst✝⁵ : AddCommMonoid N₁
inst✝⁴ : AddCommMonoid N₂
inst✝³ : AddCommMonoid N
inst✝² : Module R N₁
inst✝¹ : Module R N₂
inst✝ : Module R N
g : N₁ →ₗ[R] N₂ →ₗ[R] N
h : IsTensorProduct f
f' : M₁ →ₗ[R] M₂ →ₗ[R] M'
x₁ : M₁
x₂ : M₂
⊢ (h.lift f') ((f x₁) x₂) = (f' x₁) x₂
state_after: R : Type u_1
inst✝¹⁴ : CommSemiring R
M₁ : Type u_2
M₂ : Type u_3
M : Type u_4
M' : Type u_5
inst✝¹³ : AddCommMonoid M₁
inst✝¹² : AddCommMonoid M₂
inst✝¹¹ : AddCommMonoid M
inst✝¹⁰ : AddCommMonoid M'
inst✝⁹ : Module R M₁
inst✝⁸ : Module R M₂
inst✝⁷ : Module R M
inst✝⁶ : Module R M'
f : M₁ →ₗ[R] M₂ →ₗ[R] M
N₁ : Type u_6
N₂ : Type u_7
N : Type u_8
inst✝⁵ : AddCommMonoid N₁
inst✝⁴ : AddCommMonoid N₂
inst✝³ : AddCommMonoid N
inst✝² : Module R N₁
inst✝¹ : Module R N₂
inst✝ : Module R N
g : N₁ →ₗ[R] N₂ →ₗ[R] N
h : IsTensorProduct f
f' : M₁ →ₗ[R] M₂ →ₗ[R] M'
x₁ : M₁
x₂ : M₂
⊢ (TensorProduct.lift f' ∘ₗ ↑h.equiv.symm) ((f x₁) x₂) = (f' x₁) x₂

tactic: simp
state_before: R : Type u_1
inst✝¹⁴ : CommSemiring R
M₁ : Type u_2
M₂ : Type u_3
M : Type u_4
M' : Type u_5
inst✝¹³ : AddCommMonoid M₁
inst✝¹² : AddCommMonoid M₂
inst✝¹¹ : AddCommMonoid M
inst✝¹⁰ : AddCommMonoid M'
inst✝⁹ : Module R M₁
inst✝⁸ : Module R M₂
inst✝⁷ : Module R M
inst✝⁶ : Module R M'
f : M₁ →ₗ[R] M₂ →ₗ[R] M
N₁ : Type u_6
N₂ : Type u_7
N : Type u_8
inst✝⁵ : AddCommMonoid N₁
inst✝⁴ : AddCommMonoid N₂
inst✝³ : AddCommMonoid N
inst✝² : Module R N₁
inst✝¹ : Module R N₂
inst✝ : Module R N
g : N₁ →ₗ[R] N₂ →ₗ[R] N
h : IsTensorProduct f
f' : M₁ →ₗ[R] M₂ →ₗ[R] M'
x₁ : M₁
x₂ : M₂
⊢ (TensorProduct.lift f' ∘ₗ ↑h.equiv.symm) ((f x₁) x₂) = (f' x₁) x₂
state_after: no goals
Theorem: Order.IsSuccLimit.succ_lt
File: Mathlib/Order/SuccPred/Limit.lean

tactic: by_cases h : IsMax a
state_before: α : Type u_1
inst✝¹ : PartialOrder α
inst✝ : SuccOrder α
a b : α
C : α → Sort u_2
hb : IsSuccLimit b
ha : a < b
⊢ succ a < b
state_after: case pos
α : Type u_1
inst✝¹ : PartialOrder α
inst✝ : SuccOrder α
a b : α
C : α → Sort u_2
hb : IsSuccLimit b
ha : a < b
h : IsMax a
⊢ succ a < b

case neg
α : Type u_1
inst✝¹ : PartialOrder α
inst✝ : SuccOrder α
a b : α
C : α → Sort u_2
hb : IsSuccLimit b
ha : a < b
h : ¬IsMax a
⊢ succ a < b

tactic: rwa [h.succ_eq]
state_before: case pos
α : Type u_1
inst✝¹ : PartialOrder α
inst✝ : SuccOrder α
a b : α
C : α → Sort u_2
hb : IsSuccLimit b
ha : a < b
h : IsMax a
⊢ succ a < b
state_after: no goals

tactic: rw [lt_iff_le_and_ne, succ_le_iff_of_not_isMax h]
state_before: case neg
α : Type u_1
inst✝¹ : PartialOrder α
inst✝ : SuccOrder α
a b : α
C : α → Sort u_2
hb : IsSuccLimit b
ha : a < b
h : ¬IsMax a
⊢ succ a < b
state_after: case neg
α : Type u_1
inst✝¹ : PartialOrder α
inst✝ : SuccOrder α
a b : α
C : α → Sort u_2
hb : IsSuccLimit b
ha : a < b
h : ¬IsMax a
⊢ a < b ∧ succ a ≠ b

tactic: refine ⟨ha, fun hab => ?_⟩
state_before: case neg
α : Type u_1
inst✝¹ : PartialOrder α
inst✝ : SuccOrder α
a b : α
C : α → Sort u_2
hb : IsSuccLimit b
ha : a < b
h : ¬IsMax a
⊢ a < b ∧ succ a ≠ b
state_after: case neg
α : Type u_1
inst✝¹ : PartialOrder α
inst✝ : SuccOrder α
a b : α
C : α → Sort u_2
hb : IsSuccLimit b
ha : a < b
h : ¬IsMax a
hab : succ a = b
⊢ False

tactic: subst hab
state_before: case neg
α : Type u_1
inst✝¹ : PartialOrder α
inst✝ : SuccOrder α
a b : α
C : α → Sort u_2
hb : IsSuccLimit b
ha : a < b
h : ¬IsMax a
hab : succ a = b
⊢ False
state_after: case neg
α : Type u_1
inst✝¹ : PartialOrder α
inst✝ : SuccOrder α
a : α
C : α → Sort u_2
h : ¬IsMax a
hb : IsSuccLimit (succ a)
ha : a < succ a
⊢ False

tactic: exact (h hb.isMax).elim
state_before: case neg
α : Type u_1
inst✝¹ : PartialOrder α
inst✝ : SuccOrder α
a : α
C : α → Sort u_2
h : ¬IsMax a
hb : IsSuccLimit (succ a)
ha : a < succ a
⊢ False
state_after: no goals
Theorem: ENNReal.Tendsto.const_div
File: Mathlib/Topology/Instances/ENNReal.lean

tactic: apply Tendsto.const_mul (ENNReal.tendsto_inv_iff.2 hm)
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
a✝ b✝ c d : ℝ≥0∞
r p q : ℝ≥0
x y z ε ε₁ ε₂ : ℝ≥0∞
s : Set ℝ≥0∞
f : Filter α
m : α → ℝ≥0∞
a b : ℝ≥0∞
hm : Tendsto m f (𝓝 b)
hb : b ≠ ⊤ ∨ a ≠ ⊤
⊢ Tendsto (fun b => a / m b) f (𝓝 (a / b))
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
a✝ b✝ c d : ℝ≥0∞
r p q : ℝ≥0
x y z ε ε₁ ε₂ : ℝ≥0∞
s : Set ℝ≥0∞
f : Filter α
m : α → ℝ≥0∞
a b : ℝ≥0∞
hm : Tendsto m f (𝓝 b)
hb : b ≠ ⊤ ∨ a ≠ ⊤
⊢ b⁻¹ ≠ 0 ∨ a ≠ ⊤

tactic: simp [hb]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
a✝ b✝ c d : ℝ≥0∞
r p q : ℝ≥0
x y z ε ε₁ ε₂ : ℝ≥0∞
s : Set ℝ≥0∞
f : Filter α
m : α → ℝ≥0∞
a b : ℝ≥0∞
hm : Tendsto m f (𝓝 b)
hb : b ≠ ⊤ ∨ a ≠ ⊤
⊢ b⁻¹ ≠ 0 ∨ a ≠ ⊤
state_after: no goals
Theorem: Vector.get_mem
File: Mathlib/Data/Vector/Mem.lean

tactic: rw [get_eq_get]
state_before: α : Type u_1
β : Type u_2
n : ℕ
a a' : α
i : Fin n
v : Vector α n
⊢ v.get i ∈ v.toList
state_after: α : Type u_1
β : Type u_2
n : ℕ
a a' : α
i : Fin n
v : Vector α n
⊢ v.toList.get (Fin.cast ⋯ i) ∈ v.toList

tactic: exact List.get_mem _ _ _
state_before: α : Type u_1
β : Type u_2
n : ℕ
a a' : α
i : Fin n
v : Vector α n
⊢ v.toList.get (Fin.cast ⋯ i) ∈ v.toList
state_after: no goals
Theorem: closedEmbedding_subtype_val
File: Mathlib/Topology/Constructions.lean

tactic: rwa [Subtype.range_coe_subtype]
state_before: X : Type u
Y : Type v
Z : Type u_1
W : Type u_2
ε : Type u_3
ζ : Type u_4
inst✝² : TopologicalSpace X
inst✝¹ : TopologicalSpace Y
inst✝ : TopologicalSpace Z
p : X → Prop
h : IsClosed {a | p a}
⊢ IsClosed (range Subtype.val)
state_after: no goals
Theorem: Set.Ioc_inter_Ioc
File: Mathlib/Order/Interval/Set/Basic.lean

tactic: simp only [Ioi_inter_Iic.symm, Ioi_inter_Ioi.symm, Iic_inter_Iic.symm]
state_before: α : Type u_1
β : Type u_2
inst✝¹ : LinearOrder α
inst✝ : LinearOrder β
f : α → β
a a₁ a₂ b b₁ b₂ c d : α
⊢ Ioc a₁ b₁ ∩ Ioc a₂ b₂ = Ioc (a₁ ⊔ a₂) (b₁ ⊓ b₂)
state_after: α : Type u_1
β : Type u_2
inst✝¹ : LinearOrder α
inst✝ : LinearOrder β
f : α → β
a a₁ a₂ b b₁ b₂ c d : α
⊢ Ioi a₁ ∩ Iic b₁ ∩ (Ioi a₂ ∩ Iic b₂) = Ioi a₁ ∩ Ioi a₂ ∩ (Iic b₁ ∩ Iic b₂)

tactic: ac_rfl
state_before: α : Type u_1
β : Type u_2
inst✝¹ : LinearOrder α
inst✝ : LinearOrder β
f : α → β
a a₁ a₂ b b₁ b₂ c d : α
⊢ Ioi a₁ ∩ Iic b₁ ∩ (Ioi a₂ ∩ Iic b₂) = Ioi a₁ ∩ Ioi a₂ ∩ (Iic b₁ ∩ Iic b₂)
state_after: no goals
Theorem: Path.truncate_zero_zero
File: Mathlib/Topology/Connected/PathConnected.lean

tactic: rw [min_self, γ.extend_zero]
state_before: X : Type u_1
Y : Type u_2
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
x y z : X
ι : Type u_3
γ✝ : Path x y
a b : X
γ : Path a b
⊢ γ.extend (min 0 0) = a
state_after: no goals

tactic: convert γ.truncate_self 0
state_before: X : Type u_1
Y : Type u_2
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
x y z : X
ι : Type u_3
γ✝ : Path x y
a b : X
γ : Path a b
⊢ γ.truncate 0 0 = (refl a).cast ⋯ ⋯
state_after: no goals
Theorem: Real.sqrt_le_sqrt_iff
File: Mathlib/Data/Real/Sqrt.lean

tactic: rw [Real.sqrt, Real.sqrt, NNReal.coe_le_coe, NNReal.sqrt_le_sqrt, toNNReal_le_toNNReal_iff hy]
state_before: x y : ℝ
hy : 0 ≤ y
⊢ √x ≤ √y ↔ x ≤ y
state_after: no goals
Theorem: CategoryTheory.Limits.CompleteLattice.finite_coproduct_eq_finset_sup
File: Mathlib/CategoryTheory/Limits/Lattice.lean

tactic: trans
state_before: α : Type u
J : Type w
inst✝⁴ : SmallCategory J
inst✝³ : FinCategory J
inst✝² : SemilatticeSup α
inst✝¹ : OrderBot α
ι : Type u
inst✝ : Fintype ι
f : ι → α
⊢ ∐ f = Fintype.elems.sup f
state_after: α : Type u
J : Type w
inst✝⁴ : SmallCategory J
inst✝³ : FinCategory J
inst✝² : SemilatticeSup α
inst✝¹ : OrderBot α
ι : Type u
inst✝ : Fintype ι
f : ι → α
⊢ ∐ f = ?m.24956

α : Type u
J : Type w
inst✝⁴ : SmallCategory J
inst✝³ : FinCategory J
inst✝² : SemilatticeSup α
inst✝¹ : OrderBot α
ι : Type u
inst✝ : Fintype ι
f : ι → α
⊢ ?m.24956 = Fintype.elems.sup f

α : Type u
J : Type w
inst✝⁴ : SmallCategory J
inst✝³ : FinCategory J
inst✝² : SemilatticeSup α
inst✝¹ : OrderBot α
ι : Type u
inst✝ : Fintype ι
f : ι → α
⊢ α

tactic: change Finset.univ.sup (f ∘ discreteEquiv.toEmbedding) = Fintype.elems.sup f
state_before: α : Type u
J : Type w
inst✝⁴ : SmallCategory J
inst✝³ : FinCategory J
inst✝² : SemilatticeSup α
inst✝¹ : OrderBot α
ι : Type u
inst✝ : Fintype ι
f : ι → α
⊢ (finiteColimitCocone (Discrete.functor f)).cocone.pt = Fintype.elems.sup f
state_after: α : Type u
J : Type w
inst✝⁴ : SmallCategory J
inst✝³ : FinCategory J
inst✝² : SemilatticeSup α
inst✝¹ : OrderBot α
ι : Type u
inst✝ : Fintype ι
f : ι → α
⊢ Finset.univ.sup (f ∘ ⇑discreteEquiv.toEmbedding) = Fintype.elems.sup f

tactic: simp only [← Finset.sup_map, Finset.univ_map_equiv_to_embedding]
state_before: α : Type u
J : Type w
inst✝⁴ : SmallCategory J
inst✝³ : FinCategory J
inst✝² : SemilatticeSup α
inst✝¹ : OrderBot α
ι : Type u
inst✝ : Fintype ι
f : ι → α
⊢ Finset.univ.sup (f ∘ ⇑discreteEquiv.toEmbedding) = Fintype.elems.sup f
state_after: α : Type u
J : Type w
inst✝⁴ : SmallCategory J
inst✝³ : FinCategory J
inst✝² : SemilatticeSup α
inst✝¹ : OrderBot α
ι : Type u
inst✝ : Fintype ι
f : ι → α
⊢ Finset.univ.sup f = Fintype.elems.sup f

tactic: rfl
state_before: α : Type u
J : Type w
inst✝⁴ : SmallCategory J
inst✝³ : FinCategory J
inst✝² : SemilatticeSup α
inst✝¹ : OrderBot α
ι : Type u
inst✝ : Fintype ι
f : ι → α
⊢ Finset.univ.sup f = Fintype.elems.sup f
state_after: no goals

tactic: exact
  (IsColimit.coconePointUniqueUpToIso (colimit.isColimit _)
      (finiteColimitCocone (Discrete.functor f)).isColimit).to_eq
state_before: α : Type u
J : Type w
inst✝⁴ : SmallCategory J
inst✝³ : FinCategory J
inst✝² : SemilatticeSup α
inst✝¹ : OrderBot α
ι : Type u
inst✝ : Fintype ι
f : ι → α
⊢ ∐ f = ?m.24956
state_after: no goals
Theorem: PosNum.to_nat_eq_succ_pred
File: Mathlib/Data/Num/Lemmas.lean

tactic: rw [← Num.succ'_to_nat, n.succ'_pred']
state_before: α : Type u_1
n : PosNum
⊢ ↑n = ↑n.pred' + 1
state_after: no goals
Theorem: Finsupp.equivFunOnFinite_symm_single
File: Mathlib/Data/Finsupp/Defs.lean

tactic: rw [← equivFunOnFinite_single, Equiv.symm_apply_apply]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
M : Type u_5
M' : Type u_6
N : Type u_7
P : Type u_8
G : Type u_9
H : Type u_10
R : Type u_11
S : Type u_12
inst✝² : Zero M
a a' : α
b : M
inst✝¹ : DecidableEq α
inst✝ : Finite α
x : α
m : M
⊢ equivFunOnFinite.symm (Pi.single x m) = single x m
state_after: no goals
Theorem: Cardinal.mk_embedding_eq_arrow_of_lift_le
File: Mathlib/SetTheory/Cardinal/Ordinal.lean

tactic: conv_rhs => rw [← (Equiv.embeddingCongr (.refl _)
  (Cardinal.eq.mp <| mul_eq_self <| aleph0_le_mk α).some).cardinal_eq]
state_before: α β : Type u
β' : Type v
inst✝ : Infinite α
leq : lift.{v, u} #α = lift.{u, v} #β'
eq : #α = #β
lle : lift.{u, v} #β' ≤ lift.{v, u} #α
le : #β ≤ #α
⊢ #(β' → α) ≤ #(β' ↪ α)
state_after: α β : Type u
β' : Type v
inst✝ : Infinite α
leq : lift.{v, u} #α = lift.{u, v} #β'
eq : #α = #β
lle : lift.{u, v} #β' ≤ lift.{v, u} #α
le : #β ≤ #α
⊢ #(β' → α) ≤ #(β' ↪ α × α)

tactic: obtain ⟨e⟩ := lift_mk_le'.mp lle
state_before: α β : Type u
β' : Type v
inst✝ : Infinite α
leq : lift.{v, u} #α = lift.{u, v} #β'
eq : #α = #β
lle : lift.{u, v} #β' ≤ lift.{v, u} #α
le : #β ≤ #α
⊢ #(β' → α) ≤ #(β' ↪ α × α)
state_after: case intro
α β : Type u
β' : Type v
inst✝ : Infinite α
leq : lift.{v, u} #α = lift.{u, v} #β'
eq : #α = #β
lle : lift.{u, v} #β' ≤ lift.{v, u} #α
le : #β ≤ #α
e : β' ↪ α
⊢ #(β' → α) ≤ #(β' ↪ α × α)

tactic: exact ⟨⟨fun f ↦ ⟨fun b ↦ ⟨e b, f b⟩, fun _ _ h ↦ e.injective congr(Prod.fst $h)⟩,
  fun f g h ↦ funext fun b ↦ congr(Prod.snd <| $h b)⟩⟩
state_before: case intro
α β : Type u
β' : Type v
inst✝ : Infinite α
leq : lift.{v, u} #α = lift.{u, v} #β'
eq : #α = #β
lle : lift.{u, v} #β' ≤ lift.{v, u} #α
le : #β ≤ #α
e : β' ↪ α
⊢ #(β' → α) ≤ #(β' ↪ α × α)
state_after: no goals
Theorem: Ideal.coprime_of_no_prime_ge
File: Mathlib/RingTheory/DedekindDomain/Ideal.lean

tactic: rw [isCoprime_iff_sup_eq]
state_before: R : Type u_1
A : Type u_2
K : Type u_3
inst✝² : CommRing R
inst✝¹ : CommRing A
inst✝ : Field K
I J : Ideal R
h : ∀ (P : Ideal R), I ≤ P → J ≤ P → ¬P.IsPrime
⊢ IsCoprime I J
state_after: R : Type u_1
A : Type u_2
K : Type u_3
inst✝² : CommRing R
inst✝¹ : CommRing A
inst✝ : Field K
I J : Ideal R
h : ∀ (P : Ideal R), I ≤ P → J ≤ P → ¬P.IsPrime
⊢ I ⊔ J = ⊤

tactic: by_contra hIJ
state_before: R : Type u_1
A : Type u_2
K : Type u_3
inst✝² : CommRing R
inst✝¹ : CommRing A
inst✝ : Field K
I J : Ideal R
h : ∀ (P : Ideal R), I ≤ P → J ≤ P → ¬P.IsPrime
⊢ I ⊔ J = ⊤
state_after: R : Type u_1
A : Type u_2
K : Type u_3
inst✝² : CommRing R
inst✝¹ : CommRing A
inst✝ : Field K
I J : Ideal R
h : ∀ (P : Ideal R), I ≤ P → J ≤ P → ¬P.IsPrime
hIJ : ¬I ⊔ J = ⊤
⊢ False

tactic: obtain ⟨P, hP, hIJ⟩ := Ideal.exists_le_maximal _ hIJ
state_before: R : Type u_1
A : Type u_2
K : Type u_3
inst✝² : CommRing R
inst✝¹ : CommRing A
inst✝ : Field K
I J : Ideal R
h : ∀ (P : Ideal R), I ≤ P → J ≤ P → ¬P.IsPrime
hIJ : ¬I ⊔ J = ⊤
⊢ False
state_after: case intro.intro
R : Type u_1
A : Type u_2
K : Type u_3
inst✝² : CommRing R
inst✝¹ : CommRing A
inst✝ : Field K
I J : Ideal R
h : ∀ (P : Ideal R), I ≤ P → J ≤ P → ¬P.IsPrime
hIJ✝ : ¬I ⊔ J = ⊤
P : Ideal R
hP : P.IsMaximal
hIJ : I ⊔ J ≤ P
⊢ False

tactic: exact h P (le_trans le_sup_left hIJ) (le_trans le_sup_right hIJ) hP.isPrime
state_before: case intro.intro
R : Type u_1
A : Type u_2
K : Type u_3
inst✝² : CommRing R
inst✝¹ : CommRing A
inst✝ : Field K
I J : Ideal R
h : ∀ (P : Ideal R), I ≤ P → J ≤ P → ¬P.IsPrime
hIJ✝ : ¬I ⊔ J = ⊤
P : Ideal R
hP : P.IsMaximal
hIJ : I ⊔ J ≤ P
⊢ False
state_after: no goals
Theorem: ComputablePred.not
File: Mathlib/Computability/Halting.lean

tactic: obtain ⟨f, hf, rfl⟩ := computable_iff.1 hp
state_before: α : Type u_1
σ : Type u_2
inst✝¹ : Primcodable α
inst✝ : Primcodable σ
p : α → Prop
hp : ComputablePred p
⊢ ComputablePred fun a => ¬p a
state_after: case intro.intro
α : Type u_1
σ : Type u_2
inst✝¹ : Primcodable α
inst✝ : Primcodable σ
f : α → Bool
hf : Computable f
hp : ComputablePred fun a => f a = true
⊢ ComputablePred fun a => ¬(fun a => f a = true) a

tactic: exact
  ⟨by infer_instance,
    (cond hf (const false) (const true)).of_eq fun n => by
      simp only [Bool.not_eq_true]
      cases f n <;> rfl⟩
state_before: case intro.intro
α : Type u_1
σ : Type u_2
inst✝¹ : Primcodable α
inst✝ : Primcodable σ
f : α → Bool
hf : Computable f
hp : ComputablePred fun a => f a = true
⊢ ComputablePred fun a => ¬(fun a => f a = true) a
state_after: no goals

tactic: infer_instance
state_before: α : Type u_1
σ : Type u_2
inst✝¹ : Primcodable α
inst✝ : Primcodable σ
f : α → Bool
hf : Computable f
hp : ComputablePred fun a => f a = true
⊢ DecidablePred fun a => ¬(fun a => f a = true) a
state_after: no goals

tactic: simp only [Bool.not_eq_true]
state_before: α : Type u_1
σ : Type u_2
inst✝¹ : Primcodable α
inst✝ : Primcodable σ
f : α → Bool
hf : Computable f
hp : ComputablePred fun a => f a = true
n : α
⊢ (bif f n then false else true) = decide ((fun a => ¬(fun a => f a = true) a) n)
state_after: α : Type u_1
σ : Type u_2
inst✝¹ : Primcodable α
inst✝ : Primcodable σ
f : α → Bool
hf : Computable f
hp : ComputablePred fun a => f a = true
n : α
⊢ (bif f n then false else true) = decide (f n = false)

tactic: cases f n <;> rfl
state_before: α : Type u_1
σ : Type u_2
inst✝¹ : Primcodable α
inst✝ : Primcodable σ
f : α → Bool
hf : Computable f
hp : ComputablePred fun a => f a = true
n : α
⊢ (bif f n then false else true) = decide (f n = false)
state_after: no goals
Theorem: FractionalIdeal.coe_ideal_span_singleton_inv_mul
File: Mathlib/RingTheory/DedekindDomain/Ideal.lean

tactic: rw [mul_comm, coe_ideal_span_singleton_mul_inv K hx]
state_before: R : Type u_1
A : Type u_2
K : Type u_3
inst✝⁹ : CommRing R
inst✝⁸ : CommRing A
inst✝⁷ : Field K
R₁ : Type u_4
inst✝⁶ : CommRing R₁
inst✝⁵ : IsDomain R₁
inst✝⁴ : Algebra R₁ K
inst✝³ : IsFractionRing R₁ K
I J : FractionalIdeal R₁⁰ K
K' : Type u_5
inst✝² : Field K'
inst✝¹ : Algebra R₁ K'
inst✝ : IsFractionRing R₁ K'
x : R₁
hx : x ≠ 0
⊢ (↑(Ideal.span {x}))⁻¹ * ↑(Ideal.span {x}) = 1
state_after: no goals
Theorem: NNRat.cast_zpow_of_ne_zero
File: Mathlib/Data/Rat/Cast/Lemmas.lean

tactic: obtain ⟨n, rfl | rfl⟩ := z.eq_nat_or_neg
state_before: K : Type u_1
inst✝ : DivisionSemiring K
q : ℚ≥0
z : ℤ
hq : ↑q.num ≠ 0
⊢ ↑(q ^ z) = ↑q ^ z
state_after: case intro.inl
K : Type u_1
inst✝ : DivisionSemiring K
q : ℚ≥0
hq : ↑q.num ≠ 0
n : ℕ
⊢ ↑(q ^ ↑n) = ↑q ^ ↑n

case intro.inr
K : Type u_1
inst✝ : DivisionSemiring K
q : ℚ≥0
hq : ↑q.num ≠ 0
n : ℕ
⊢ ↑(q ^ (-↑n)) = ↑q ^ (-↑n)

tactic: simp
state_before: case intro.inl
K : Type u_1
inst✝ : DivisionSemiring K
q : ℚ≥0
hq : ↑q.num ≠ 0
n : ℕ
⊢ ↑(q ^ ↑n) = ↑q ^ ↑n
state_after: no goals

tactic: simp_rw [zpow_neg, zpow_natCast, ← inv_pow, NNRat.cast_pow]
state_before: case intro.inr
K : Type u_1
inst✝ : DivisionSemiring K
q : ℚ≥0
hq : ↑q.num ≠ 0
n : ℕ
⊢ ↑(q ^ (-↑n)) = ↑q ^ (-↑n)
state_after: case intro.inr
K : Type u_1
inst✝ : DivisionSemiring K
q : ℚ≥0
hq : ↑q.num ≠ 0
n : ℕ
⊢ ↑q⁻¹ ^ n = (↑q)⁻¹ ^ n

tactic: congr
state_before: case intro.inr
K : Type u_1
inst✝ : DivisionSemiring K
q : ℚ≥0
hq : ↑q.num ≠ 0
n : ℕ
⊢ ↑q⁻¹ ^ n = (↑q)⁻¹ ^ n
state_after: case intro.inr.e_a
K : Type u_1
inst✝ : DivisionSemiring K
q : ℚ≥0
hq : ↑q.num ≠ 0
n : ℕ
⊢ ↑q⁻¹ = (↑q)⁻¹

tactic: rw [cast_inv_of_ne_zero hq]
state_before: case intro.inr.e_a
K : Type u_1
inst✝ : DivisionSemiring K
q : ℚ≥0
hq : ↑q.num ≠ 0
n : ℕ
⊢ ↑q⁻¹ = (↑q)⁻¹
state_after: no goals
Theorem: Batteries.RBNode.Any_reverse
File: .lake/packages/batteries/Batteries/Data/RBMap/Lemmas.lean

tactic: simp [Any_def]
state_before: α : Type u_1
p : α → Prop
t : RBNode α
⊢ Any p t.reverse ↔ Any p t
state_after: no goals
Theorem: Lagrange.basis_pair_left
File: Mathlib/LinearAlgebra/Lagrange.lean

tactic: simp only [Lagrange.basis, hij, erase_insert_eq_erase, erase_eq_of_not_mem, mem_singleton,
  not_false_iff, prod_singleton]
state_before: F : Type u_1
inst✝¹ : Field F
ι : Type u_2
inst✝ : DecidableEq ι
s : Finset ι
v : ι → F
i j : ι
hij : i ≠ j
⊢ Lagrange.basis {i, j} v i = basisDivisor (v i) (v j)
state_after: no goals
Theorem: Orientation.rotation_zero
File: Mathlib/Geometry/Euclidean/Angle/Oriented/Rotation.lean

tactic: ext
state_before: V : Type u_1
V' : Type u_2
inst✝⁵ : NormedAddCommGroup V
inst✝⁴ : NormedAddCommGroup V'
inst✝³ : InnerProductSpace ℝ V
inst✝² : InnerProductSpace ℝ V'
inst✝¹ : Fact (finrank ℝ V = 2)
inst✝ : Fact (finrank ℝ V' = 2)
o : Orientation ℝ V (Fin 2)
⊢ o.rotation 0 = LinearIsometryEquiv.refl ℝ V
state_after: case h
V : Type u_1
V' : Type u_2
inst✝⁵ : NormedAddCommGroup V
inst✝⁴ : NormedAddCommGroup V'
inst✝³ : InnerProductSpace ℝ V
inst✝² : InnerProductSpace ℝ V'
inst✝¹ : Fact (finrank ℝ V = 2)
inst✝ : Fact (finrank ℝ V' = 2)
o : Orientation ℝ V (Fin 2)
x✝ : V
⊢ (o.rotation 0) x✝ = (LinearIsometryEquiv.refl ℝ V) x✝

tactic: simp [rotation]
state_before: case h
V : Type u_1
V' : Type u_2
inst✝⁵ : NormedAddCommGroup V
inst✝⁴ : NormedAddCommGroup V'
inst✝³ : InnerProductSpace ℝ V
inst✝² : InnerProductSpace ℝ V'
inst✝¹ : Fact (finrank ℝ V = 2)
inst✝ : Fact (finrank ℝ V' = 2)
o : Orientation ℝ V (Fin 2)
x✝ : V
⊢ (o.rotation 0) x✝ = (LinearIsometryEquiv.refl ℝ V) x✝
state_after: no goals
Theorem: CircleDeg1Lift.pow_mono
File: Mathlib/Dynamics/Circle/RotationNumber/TranslationNumber.lean

tactic: simp only [coe_pow, iterate_mono h n x]
state_before: f✝ g✝ f g : CircleDeg1Lift
h : f ≤ g
n : ℕ
x : ℝ
⊢ (f ^ n) x ≤ (g ^ n) x
state_after: no goals