1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: WittVector.frobeniusPoly_zmod
File: Mathlib/RingTheory/WittVector/Frobenius.lean

tactic: rw [frobeniusPoly, RingHom.map_add, RingHom.map_pow, RingHom.map_mul, map_X, map_C]
state_before: p : ℕ
R : Type u_1
S : Type u_2
hp : Fact (Nat.Prime p)
inst✝¹ : CommRing R
inst✝ : CommRing S
n : ℕ
⊢ (MvPolynomial.map (Int.castRingHom (ZMod p))) (frobeniusPoly p n) = X n ^ p
state_after: p : ℕ
R : Type u_1
S : Type u_2
hp : Fact (Nat.Prime p)
inst✝¹ : CommRing R
inst✝ : CommRing S
n : ℕ
⊢ X n ^ p + C ((Int.castRingHom (ZMod p)) ↑p) * (MvPolynomial.map (Int.castRingHom (ZMod p))) (frobeniusPolyAux p n) =
    X n ^ p

tactic: simp only [Int.cast_natCast, add_zero, eq_intCast, ZMod.natCast_self, zero_mul, C_0]
state_before: p : ℕ
R : Type u_1
S : Type u_2
hp : Fact (Nat.Prime p)
inst✝¹ : CommRing R
inst✝ : CommRing S
n : ℕ
⊢ X n ^ p + C ((Int.castRingHom (ZMod p)) ↑p) * (MvPolynomial.map (Int.castRingHom (ZMod p))) (frobeniusPolyAux p n) =
    X n ^ p
state_after: no goals
Theorem: ENNReal.div_rpow_of_nonneg
File: Mathlib/Analysis/SpecialFunctions/Pow/NNReal.lean

tactic: rw [div_eq_mul_inv, mul_rpow_of_nonneg _ _ hz, inv_rpow, div_eq_mul_inv]
state_before: x y : ℝ≥0∞
z : ℝ
hz : 0 ≤ z
⊢ (x / y) ^ z = x ^ z / y ^ z
state_after: no goals
Theorem: UniformOnFun.tendsto_iff_tendstoUniformlyOn
File: Mathlib/Topology/UniformSpace/UniformConvergenceTopology.lean

tactic: simp only [UniformOnFun.nhds_eq, tendsto_iInf, tendsto_principal, TendstoUniformlyOn,
  Function.comp_apply, mem_setOf]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
s s' : Set α
x : α
p : Filter ι
g : ι → α
inst✝ : UniformSpace β
𝔖 : Set (Set α)
F : ι → α →ᵤ[𝔖] β
f : α →ᵤ[𝔖] β
⊢ Tendsto F p (𝓝 f) ↔ ∀ s ∈ 𝔖, TendstoUniformlyOn (⇑(toFun 𝔖) ∘ F) ((toFun 𝔖) f) p s
state_after: no goals
Theorem: EuclideanSpace.orthonormal_single
File: Mathlib/Analysis/InnerProductSpace/PiL2.lean

tactic: simp_rw [orthonormal_iff_ite, EuclideanSpace.inner_single_left, map_one, one_mul,
  EuclideanSpace.single_apply]
state_before: ι : Type u_1
ι' : Type u_2
𝕜 : Type u_3
inst✝¹⁰ : _root_.RCLike 𝕜
E : Type u_4
inst✝⁹ : NormedAddCommGroup E
inst✝⁸ : InnerProductSpace 𝕜 E
E' : Type u_5
inst✝⁷ : NormedAddCommGroup E'
inst✝⁶ : InnerProductSpace 𝕜 E'
F : Type u_6
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : InnerProductSpace ℝ F
F' : Type u_7
inst✝³ : NormedAddCommGroup F'
inst✝² : InnerProductSpace ℝ F'
inst✝¹ : DecidableEq ι
inst✝ : Fintype ι
⊢ Orthonormal 𝕜 fun i => single i 1
state_after: ι : Type u_1
ι' : Type u_2
𝕜 : Type u_3
inst✝¹⁰ : _root_.RCLike 𝕜
E : Type u_4
inst✝⁹ : NormedAddCommGroup E
inst✝⁸ : InnerProductSpace 𝕜 E
E' : Type u_5
inst✝⁷ : NormedAddCommGroup E'
inst✝⁶ : InnerProductSpace 𝕜 E'
F : Type u_6
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : InnerProductSpace ℝ F
F' : Type u_7
inst✝³ : NormedAddCommGroup F'
inst✝² : InnerProductSpace ℝ F'
inst✝¹ : DecidableEq ι
inst✝ : Fintype ι
⊢ ι → ι → True

tactic: intros
state_before: ι : Type u_1
ι' : Type u_2
𝕜 : Type u_3
inst✝¹⁰ : _root_.RCLike 𝕜
E : Type u_4
inst✝⁹ : NormedAddCommGroup E
inst✝⁸ : InnerProductSpace 𝕜 E
E' : Type u_5
inst✝⁷ : NormedAddCommGroup E'
inst✝⁶ : InnerProductSpace 𝕜 E'
F : Type u_6
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : InnerProductSpace ℝ F
F' : Type u_7
inst✝³ : NormedAddCommGroup F'
inst✝² : InnerProductSpace ℝ F'
inst✝¹ : DecidableEq ι
inst✝ : Fintype ι
⊢ ι → ι → True
state_after: ι : Type u_1
ι' : Type u_2
𝕜 : Type u_3
inst✝¹⁰ : _root_.RCLike 𝕜
E : Type u_4
inst✝⁹ : NormedAddCommGroup E
inst✝⁸ : InnerProductSpace 𝕜 E
E' : Type u_5
inst✝⁷ : NormedAddCommGroup E'
inst✝⁶ : InnerProductSpace 𝕜 E'
F : Type u_6
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : InnerProductSpace ℝ F
F' : Type u_7
inst✝³ : NormedAddCommGroup F'
inst✝² : InnerProductSpace ℝ F'
inst✝¹ : DecidableEq ι
inst✝ : Fintype ι
i✝ j✝ : ι
⊢ True

tactic: trivial
state_before: ι : Type u_1
ι' : Type u_2
𝕜 : Type u_3
inst✝¹⁰ : _root_.RCLike 𝕜
E : Type u_4
inst✝⁹ : NormedAddCommGroup E
inst✝⁸ : InnerProductSpace 𝕜 E
E' : Type u_5
inst✝⁷ : NormedAddCommGroup E'
inst✝⁶ : InnerProductSpace 𝕜 E'
F : Type u_6
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : InnerProductSpace ℝ F
F' : Type u_7
inst✝³ : NormedAddCommGroup F'
inst✝² : InnerProductSpace ℝ F'
inst✝¹ : DecidableEq ι
inst✝ : Fintype ι
i✝ j✝ : ι
⊢ True
state_after: no goals
Theorem: Finset.Ioc_insert_left
File: Mathlib/Order/Interval/Finset/Basic.lean

tactic: rw [← coe_inj, coe_insert, coe_Ioc, coe_Icc, Set.insert_eq, Set.union_comm, Set.Ioc_union_left h]
state_before: ι : Type u_1
α : Type u_2
inst✝² : PartialOrder α
inst✝¹ : LocallyFiniteOrder α
a b c : α
inst✝ : DecidableEq α
h : a ≤ b
⊢ insert a (Ioc a b) = Icc a b
state_after: no goals
Theorem: TruncatedWittVector.ext_iff
File: Mathlib/RingTheory/WittVector/Truncated.lean

tactic: rw [h]
state_before: p : ℕ
hp : Fact (Nat.Prime p)
n : ℕ
R : Type u_1
x y : TruncatedWittVector p n R
h : x = y
i : Fin n
⊢ coeff i x = coeff i y
state_after: no goals
Theorem: pi_le_borel_pi
File: Mathlib/MeasureTheory/Constructions/BorelSpace/Basic.lean

tactic: have : ‹∀ i, MeasurableSpace (π i)› = fun i => borel (π i) :=
  funext fun i => BorelSpace.measurable_eq
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
γ₂ : Type u_4
δ : Type u_5
ι✝ : Sort y
s t u : Set α
inst✝¹² : TopologicalSpace α
inst✝¹¹ : MeasurableSpace α
inst✝¹⁰ : BorelSpace α
inst✝⁹ : TopologicalSpace β
inst✝⁸ : MeasurableSpace β
inst✝⁷ : BorelSpace β
inst✝⁶ : TopologicalSpace γ
inst✝⁵ : MeasurableSpace γ
inst✝⁴ : BorelSpace γ
inst✝³ : MeasurableSpace δ
ι : Type u_6
π : ι → Type u_7
inst✝² : (i : ι) → TopologicalSpace (π i)
inst✝¹ : (i : ι) → MeasurableSpace (π i)
inst✝ : ∀ (i : ι), BorelSpace (π i)
⊢ MeasurableSpace.pi ≤ borel ((i : ι) → π i)
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
γ₂ : Type u_4
δ : Type u_5
ι✝ : Sort y
s t u : Set α
inst✝¹² : TopologicalSpace α
inst✝¹¹ : MeasurableSpace α
inst✝¹⁰ : BorelSpace α
inst✝⁹ : TopologicalSpace β
inst✝⁸ : MeasurableSpace β
inst✝⁷ : BorelSpace β
inst✝⁶ : TopologicalSpace γ
inst✝⁵ : MeasurableSpace γ
inst✝⁴ : BorelSpace γ
inst✝³ : MeasurableSpace δ
ι : Type u_6
π : ι → Type u_7
inst✝² : (i : ι) → TopologicalSpace (π i)
inst✝¹ : (i : ι) → MeasurableSpace (π i)
inst✝ : ∀ (i : ι), BorelSpace (π i)
this : inst✝¹ = fun i => borel (π i)
⊢ MeasurableSpace.pi ≤ borel ((i : ι) → π i)

tactic: exact iSup_le fun i => comap_le_iff_le_map.2 <| (continuous_apply i).borel_measurable
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
γ₂ : Type u_4
δ : Type u_5
ι✝ : Sort y
s t u : Set α
inst✝¹² : TopologicalSpace α
inst✝¹¹ : MeasurableSpace α
inst✝¹⁰ : BorelSpace α
inst✝⁹ : TopologicalSpace β
inst✝⁸ : MeasurableSpace β
inst✝⁷ : BorelSpace β
inst✝⁶ : TopologicalSpace γ
inst✝⁵ : MeasurableSpace γ
inst✝⁴ : BorelSpace γ
inst✝³ : MeasurableSpace δ
ι : Type u_6
π : ι → Type u_7
inst✝² : (i : ι) → TopologicalSpace (π i)
inst✝¹ : (i : ι) → MeasurableSpace (π i)
inst✝ : ∀ (i : ι), BorelSpace (π i)
this : inst✝¹ = fun i => borel (π i)
⊢ MeasurableSpace.pi ≤ borel ((i : ι) → π i)
state_after: no goals
Theorem: LinearMap.BilinForm.compQuadraticForm_polar
File: Mathlib/LinearAlgebra/QuadraticForm/Basic.lean

tactic: simp [polar]
state_before: S : Type u_1
T : Type u_2
R : Type u_3
M : Type u_4
N : Type u_5
inst✝⁸ : CommRing R
inst✝⁷ : AddCommGroup M
inst✝⁶ : Module R M
B : BilinForm R M
inst✝⁵ : CommRing S
inst✝⁴ : Algebra S R
inst✝³ : Module S M
inst✝² : IsScalarTower S R M
inst✝¹ : AddCommGroup N
inst✝ : Module R N
f : R →ₗ[S] S
Q : QuadraticForm R M
x y : M
⊢ polar (⇑(f.compQuadraticForm Q)) x y = f (polar (⇑Q) x y)
state_after: no goals
Theorem: Ordnode.Sized.size_eq_zero
File: Mathlib/Data/Ordmap/Ordset.lean

tactic: cases t <;> [simp;simp [ht.1]]
state_before: α : Type u_1
t : Ordnode α
ht : t.Sized
⊢ t.size = 0 ↔ t = nil
state_after: no goals
Theorem: MeasureTheory.exists_measurable_superset₂
File: Mathlib/MeasureTheory/Measure/MeasureSpaceDef.lean

tactic: simpa only [Bool.forall_bool.trans and_comm] using
  exists_measurable_superset_forall_eq (fun b => cond b μ ν) s
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ι : Sort u_5
inst✝ : MeasurableSpace α
μ✝ μ₁ μ₂ : Measure α
s✝ s₁ s₂ t : Set α
μ ν : Measure α
s : Set α
⊢ ∃ t, s ⊆ t ∧ MeasurableSet t ∧ μ t = μ s ∧ ν t = ν s
state_after: no goals
Theorem: IsAntichain.image_relEmbedding
File: Mathlib/Order/Antichain.lean

tactic: intro b hb b' hb' h₁ h₂
state_before: α : Type u_1
β : Type u_2
r r₁ r₂ : α → α → Prop
r' : β → β → Prop
s t : Set α
a b : α
hs : IsAntichain r s
φ : r ↪r r'
⊢ IsAntichain r' (⇑φ '' s)
state_after: α : Type u_1
β : Type u_2
r r₁ r₂ : α → α → Prop
r' : β → β → Prop
s t : Set α
a b✝ : α
hs : IsAntichain r s
φ : r ↪r r'
b : β
hb : b ∈ ⇑φ '' s
b' : β
hb' : b' ∈ ⇑φ '' s
h₁ : b ≠ b'
h₂ : r' b b'
⊢ False

tactic: rw [Set.mem_image] at hb hb'
state_before: α : Type u_1
β : Type u_2
r r₁ r₂ : α → α → Prop
r' : β → β → Prop
s t : Set α
a b✝ : α
hs : IsAntichain r s
φ : r ↪r r'
b : β
hb : b ∈ ⇑φ '' s
b' : β
hb' : b' ∈ ⇑φ '' s
h₁ : b ≠ b'
h₂ : r' b b'
⊢ False
state_after: α : Type u_1
β : Type u_2
r r₁ r₂ : α → α → Prop
r' : β → β → Prop
s t : Set α
a b✝ : α
hs : IsAntichain r s
φ : r ↪r r'
b : β
hb : ∃ x ∈ s, φ x = b
b' : β
hb' : ∃ x ∈ s, φ x = b'
h₁ : b ≠ b'
h₂ : r' b b'
⊢ False

tactic: obtain ⟨⟨a, has, rfl⟩, ⟨a', has', rfl⟩⟩ := hb, hb'
state_before: α : Type u_1
β : Type u_2
r r₁ r₂ : α → α → Prop
r' : β → β → Prop
s t : Set α
a b✝ : α
hs : IsAntichain r s
φ : r ↪r r'
b : β
hb : ∃ x ∈ s, φ x = b
b' : β
hb' : ∃ x ∈ s, φ x = b'
h₁ : b ≠ b'
h₂ : r' b b'
⊢ False
state_after: case intro.intro.intro.intro
α : Type u_1
β : Type u_2
r r₁ r₂ : α → α → Prop
r' : β → β → Prop
s t : Set α
a✝ b : α
hs : IsAntichain r s
φ : r ↪r r'
a : α
has : a ∈ s
a' : α
has' : a' ∈ s
h₁ : φ a ≠ φ a'
h₂ : r' (φ a) (φ a')
⊢ False

tactic: exact hs has has' (fun haa' => h₁ (by rw [haa'])) (φ.map_rel_iff.mp h₂)
state_before: case intro.intro.intro.intro
α : Type u_1
β : Type u_2
r r₁ r₂ : α → α → Prop
r' : β → β → Prop
s t : Set α
a✝ b : α
hs : IsAntichain r s
φ : r ↪r r'
a : α
has : a ∈ s
a' : α
has' : a' ∈ s
h₁ : φ a ≠ φ a'
h₂ : r' (φ a) (φ a')
⊢ False
state_after: no goals

tactic: rw [haa']
state_before: α : Type u_1
β : Type u_2
r r₁ r₂ : α → α → Prop
r' : β → β → Prop
s t : Set α
a✝ b : α
hs : IsAntichain r s
φ : r ↪r r'
a : α
has : a ∈ s
a' : α
has' : a' ∈ s
h₁ : φ a ≠ φ a'
h₂ : r' (φ a) (φ a')
haa' : a = a'
⊢ φ a = φ a'
state_after: no goals
Theorem: Computation.of_results_think
File: Mathlib/Data/Seq/Computation.lean

tactic: haveI := of_think_terminates h.terminates
state_before: α : Type u
β : Type v
γ : Type w
s : Computation α
a : α
n : ℕ
h : s.think.Results a n
⊢ ∃ m, s.Results a m ∧ n = m + 1
state_after: α : Type u
β : Type v
γ : Type w
s : Computation α
a : α
n : ℕ
h : s.think.Results a n
this : s.Terminates
⊢ ∃ m, s.Results a m ∧ n = m + 1

tactic: have := results_of_terminates' _ (of_think_mem h.mem)
state_before: α : Type u
β : Type v
γ : Type w
s : Computation α
a : α
n : ℕ
h : s.think.Results a n
this : s.Terminates
⊢ ∃ m, s.Results a m ∧ n = m + 1
state_after: α : Type u
β : Type v
γ : Type w
s : Computation α
a : α
n : ℕ
h : s.think.Results a n
this✝ : s.Terminates
this : s.Results a s.length
⊢ ∃ m, s.Results a m ∧ n = m + 1

tactic: exact ⟨_, this, Results.len_unique h (results_think this)⟩
state_before: α : Type u
β : Type v
γ : Type w
s : Computation α
a : α
n : ℕ
h : s.think.Results a n
this✝ : s.Terminates
this : s.Results a s.length
⊢ ∃ m, s.Results a m ∧ n = m + 1
state_after: no goals
Theorem: ConjAct.mem_orbit_conjAct
File: Mathlib/GroupTheory/GroupAction/ConjAct.lean

tactic: rw [isConj_comm, isConj_iff, mem_orbit_iff]
state_before: α : Type u_1
M : Type u_2
G : Type u_3
G₀ : Type u_4
R : Type u_5
K : Type u_6
inst✝ : Group G
g h : G
⊢ g ∈ orbit (ConjAct G) h ↔ IsConj g h
state_after: α : Type u_1
M : Type u_2
G : Type u_3
G₀ : Type u_4
R : Type u_5
K : Type u_6
inst✝ : Group G
g h : G
⊢ (∃ x, x • h = g) ↔ ∃ c, c * h * c⁻¹ = g

tactic: rfl
state_before: α : Type u_1
M : Type u_2
G : Type u_3
G₀ : Type u_4
R : Type u_5
K : Type u_6
inst✝ : Group G
g h : G
⊢ (∃ x, x • h = g) ↔ ∃ c, c * h * c⁻¹ = g
state_after: no goals
Theorem: Nat.dist.triangle_inequality
File: Mathlib/Data/Nat/Dist.lean

tactic: have : dist n m + dist m k = n - m + (m - k) + (k - m + (m - n)) := by
  simp [dist, add_comm, add_left_comm, add_assoc]
state_before: n m k : ℕ
⊢ n.dist k ≤ n.dist m + m.dist k
state_after: n m k : ℕ
this : n.dist m + m.dist k = n - m + (m - k) + (k - m + (m - n))
⊢ n.dist k ≤ n.dist m + m.dist k

tactic: rw [this, dist]
state_before: n m k : ℕ
this : n.dist m + m.dist k = n - m + (m - k) + (k - m + (m - n))
⊢ n.dist k ≤ n.dist m + m.dist k
state_after: n m k : ℕ
this : n.dist m + m.dist k = n - m + (m - k) + (k - m + (m - n))
⊢ n - k + (k - n) ≤ n - m + (m - k) + (k - m + (m - n))

tactic: exact add_le_add tsub_le_tsub_add_tsub tsub_le_tsub_add_tsub
state_before: n m k : ℕ
this : n.dist m + m.dist k = n - m + (m - k) + (k - m + (m - n))
⊢ n - k + (k - n) ≤ n - m + (m - k) + (k - m + (m - n))
state_after: no goals

tactic: simp [dist, add_comm, add_left_comm, add_assoc]
state_before: n m k : ℕ
⊢ n.dist m + m.dist k = n - m + (m - k) + (k - m + (m - n))
state_after: no goals
Theorem: inner_zero_left
File: Mathlib/Analysis/InnerProductSpace/Basic.lean

tactic: rw [← zero_smul 𝕜 (0 : E), inner_smul_left, RingHom.map_zero, zero_mul]
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
inst✝⁴ : _root_.RCLike 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : NormedAddCommGroup F
inst✝ : InnerProductSpace ℝ F
x : E
⊢ ⟪0, x⟫_𝕜 = 0
state_after: no goals
Theorem: ENNReal.le_div_iff_mul_le
File: Mathlib/Data/ENNReal/Inv.lean

tactic: induction' b with b
state_before: a b c d : ℝ≥0∞
r p q : ℝ≥0
h0 : b ≠ 0 ∨ c ≠ 0
ht : b ≠ ⊤ ∨ c ≠ ⊤
⊢ a ≤ c / b ↔ a * b ≤ c
state_after: case top
a b c d : ℝ≥0∞
r p q : ℝ≥0
h0 : ⊤ ≠ 0 ∨ c ≠ 0
ht : ⊤ ≠ ⊤ ∨ c ≠ ⊤
⊢ a ≤ c / ⊤ ↔ a * ⊤ ≤ c

case coe
a b✝ c d : ℝ≥0∞
r p q b : ℝ≥0
h0 : ↑b ≠ 0 ∨ c ≠ 0
ht : ↑b ≠ ⊤ ∨ c ≠ ⊤
⊢ a ≤ c / ↑b ↔ a * ↑b ≤ c

tactic: rcases eq_or_ne b 0 with (rfl | hb)
state_before: case coe
a b✝ c d : ℝ≥0∞
r p q b : ℝ≥0
h0 : ↑b ≠ 0 ∨ c ≠ 0
ht : ↑b ≠ ⊤ ∨ c ≠ ⊤
⊢ a ≤ c / ↑b ↔ a * ↑b ≤ c
state_after: case coe.inl
a b c d : ℝ≥0∞
r p q : ℝ≥0
h0 : ↑0 ≠ 0 ∨ c ≠ 0
ht : ↑0 ≠ ⊤ ∨ c ≠ ⊤
⊢ a ≤ c / ↑0 ↔ a * ↑0 ≤ c

case coe.inr
a b✝ c d : ℝ≥0∞
r p q b : ℝ≥0
h0 : ↑b ≠ 0 ∨ c ≠ 0
ht : ↑b ≠ ⊤ ∨ c ≠ ⊤
hb : b ≠ 0
⊢ a ≤ c / ↑b ↔ a * ↑b ≤ c

tactic: lift c to ℝ≥0 using ht.neg_resolve_left rfl
state_before: case top
a b c d : ℝ≥0∞
r p q : ℝ≥0
h0 : ⊤ ≠ 0 ∨ c ≠ 0
ht : ⊤ ≠ ⊤ ∨ c ≠ ⊤
⊢ a ≤ c / ⊤ ↔ a * ⊤ ≤ c
state_after: case top.intro
a b d : ℝ≥0∞
r p q c : ℝ≥0
h0 : ⊤ ≠ 0 ∨ ↑c ≠ 0
ht : ⊤ ≠ ⊤ ∨ ↑c ≠ ⊤
⊢ a ≤ ↑c / ⊤ ↔ a * ⊤ ≤ ↑c

tactic: rw [div_top, nonpos_iff_eq_zero]
state_before: case top.intro
a b d : ℝ≥0∞
r p q c : ℝ≥0
h0 : ⊤ ≠ 0 ∨ ↑c ≠ 0
ht : ⊤ ≠ ⊤ ∨ ↑c ≠ ⊤
⊢ a ≤ ↑c / ⊤ ↔ a * ⊤ ≤ ↑c
state_after: case top.intro
a b d : ℝ≥0∞
r p q c : ℝ≥0
h0 : ⊤ ≠ 0 ∨ ↑c ≠ 0
ht : ⊤ ≠ ⊤ ∨ ↑c ≠ ⊤
⊢ a = 0 ↔ a * ⊤ ≤ ↑c

tactic: rcases eq_or_ne a 0 with (rfl | ha) <;> simp [*]
state_before: case top.intro
a b d : ℝ≥0∞
r p q c : ℝ≥0
h0 : ⊤ ≠ 0 ∨ ↑c ≠ 0
ht : ⊤ ≠ ⊤ ∨ ↑c ≠ ⊤
⊢ a = 0 ↔ a * ⊤ ≤ ↑c
state_after: no goals

tactic: have hc : c ≠ 0 := h0.neg_resolve_left rfl
state_before: case coe.inl
a b c d : ℝ≥0∞
r p q : ℝ≥0
h0 : ↑0 ≠ 0 ∨ c ≠ 0
ht : ↑0 ≠ ⊤ ∨ c ≠ ⊤
⊢ a ≤ c / ↑0 ↔ a * ↑0 ≤ c
state_after: case coe.inl
a b c d : ℝ≥0∞
r p q : ℝ≥0
h0 : ↑0 ≠ 0 ∨ c ≠ 0
ht : ↑0 ≠ ⊤ ∨ c ≠ ⊤
hc : c ≠ 0
⊢ a ≤ c / ↑0 ↔ a * ↑0 ≤ c

tactic: simp [div_zero hc]
state_before: case coe.inl
a b c d : ℝ≥0∞
r p q : ℝ≥0
h0 : ↑0 ≠ 0 ∨ c ≠ 0
ht : ↑0 ≠ ⊤ ∨ c ≠ ⊤
hc : c ≠ 0
⊢ a ≤ c / ↑0 ↔ a * ↑0 ≤ c
state_after: no goals

tactic: rw [← coe_ne_zero] at hb
state_before: case coe.inr
a b✝ c d : ℝ≥0∞
r p q b : ℝ≥0
h0 : ↑b ≠ 0 ∨ c ≠ 0
ht : ↑b ≠ ⊤ ∨ c ≠ ⊤
hb : b ≠ 0
⊢ a ≤ c / ↑b ↔ a * ↑b ≤ c
state_after: case coe.inr
a b✝ c d : ℝ≥0∞
r p q b : ℝ≥0
h0 : ↑b ≠ 0 ∨ c ≠ 0
ht : ↑b ≠ ⊤ ∨ c ≠ ⊤
hb : ↑b ≠ 0
⊢ a ≤ c / ↑b ↔ a * ↑b ≤ c

tactic: rw [← ENNReal.mul_le_mul_right hb coe_ne_top, ENNReal.div_mul_cancel hb coe_ne_top]
state_before: case coe.inr
a b✝ c d : ℝ≥0∞
r p q b : ℝ≥0
h0 : ↑b ≠ 0 ∨ c ≠ 0
ht : ↑b ≠ ⊤ ∨ c ≠ ⊤
hb : ↑b ≠ 0
⊢ a ≤ c / ↑b ↔ a * ↑b ≤ c
state_after: no goals
Theorem: Subalgebra.adjoin_eq_span_basis
File: Mathlib/RingTheory/Adjoin/Basic.lean

tactic: simpa only [← L.range_val, Submodule.map_span, Submodule.map_top, ← Set.range_comp]
  using congr_arg (Submodule.map L.val) bL.span_eq.symm
state_before: R : Type uR
S : Type uS
A : Type uA
B : Type uB
F : Type u_1
E : Type u_2
K : Type u_3
inst✝⁶ : CommSemiring E
inst✝⁵ : Semiring K
inst✝⁴ : SMul F E
inst✝³ : Algebra E K
inst✝² : CommSemiring F
inst✝¹ : Algebra F K
inst✝ : IsScalarTower F E K
L : Subalgebra F K
ι : Type u_4
bL : Basis ι F ↥L
⊢ toSubmodule L = span F (Set.range fun i => ↑(bL i))
state_after: no goals
Theorem: List.mem_pair
File: Mathlib/Data/List/Basic.lean

tactic: rw [mem_cons, mem_singleton]
state_before: ι : Type u_1
α : Type u
β : Type v
γ : Type w
l₁ l₂ : List α
a b c : α
⊢ a ∈ [b, c] ↔ a = b ∨ a = c
state_after: no goals
Theorem: Subalgebra.range_comp_val
File: Mathlib/Algebra/Algebra/Subalgebra/Basic.lean

tactic: rw [AlgHom.range_comp, range_val]
state_before: R : Type u
A : Type v
B : Type w
inst✝⁴ : CommSemiring R
inst✝³ : Semiring A
inst✝² : Algebra R A
inst✝¹ : Semiring B
inst✝ : Algebra R B
S : Subalgebra R A
f : A →ₐ[R] B
⊢ (f.comp S.val).range = map f S
state_after: no goals
Theorem: Complex.logTaylor_at_zero
File: Mathlib/Analysis/SpecialFunctions/Complex/LogBounds.lean

tactic: induction n with
| zero => simp [logTaylor_zero]
| succ n ih => simpa [logTaylor_succ, ih] using ne_or_eq n 0
state_before: n : ℕ
⊢ logTaylor n 0 = 0
state_after: no goals

tactic: simp [logTaylor_zero]
state_before: case zero

⊢ logTaylor 0 0 = 0
state_after: no goals

tactic: simpa [logTaylor_succ, ih] using ne_or_eq n 0
state_before: case succ
n : ℕ
ih : logTaylor n 0 = 0
⊢ logTaylor (n + 1) 0 = 0
state_after: no goals
Theorem: Polynomial.coeff_injective
File: Mathlib/Algebra/Polynomial/Basic.lean

tactic: rintro ⟨p⟩ ⟨q⟩
state_before: R : Type u
a b : R
m n : ℕ
inst✝ : Semiring R
p q : R[X]
⊢ Injective coeff
state_after: case ofFinsupp.ofFinsupp
R : Type u
a b : R
m n : ℕ
inst✝ : Semiring R
p✝ q✝ : R[X]
p q : R[ℕ]
⊢ { toFinsupp := p }.coeff = { toFinsupp := q }.coeff → { toFinsupp := p } = { toFinsupp := q }

tactic: simp only [coeff, DFunLike.coe_fn_eq, imp_self, ofFinsupp.injEq]
state_before: case ofFinsupp.ofFinsupp
R : Type u
a b : R
m n : ℕ
inst✝ : Semiring R
p✝ q✝ : R[X]
p q : R[ℕ]
⊢ { toFinsupp := p }.coeff = { toFinsupp := q }.coeff → { toFinsupp := p } = { toFinsupp := q }
state_after: no goals
Theorem: ProbabilityTheory.kernel.restrict_apply'
File: Mathlib/Probability/Kernel/Basic.lean

tactic: rw [restrict_apply κ hs a, Measure.restrict_apply ht]
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
mα : MeasurableSpace α
mβ : MeasurableSpace β
κ✝ : ↥(kernel α β)
s t : Set β
κ : ↥(kernel α β)
hs : MeasurableSet s
a : α
ht : MeasurableSet t
⊢ ((kernel.restrict κ hs) a) t = (κ a) (t ∩ s)
state_after: no goals
Theorem: uniformity_lift_le_swap
File: Mathlib/Topology/UniformSpace/Basic.lean

tactic: rw [map_lift_eq2 hg, image_swap_eq_preimage_swap]
state_before: α : Type ua
β : Type ub
γ : Type uc
δ : Type ud
ι : Sort u_1
inst✝ : UniformSpace α
g : Set (α × α) → Filter β
f : Filter β
hg : Monotone g
h : ((𝓤 α).lift fun s => g (Prod.swap ⁻¹' s)) ≤ f
⊢ (map Prod.swap (𝓤 α)).lift g ≤ f
state_after: α : Type ua
β : Type ub
γ : Type uc
δ : Type ud
ι : Sort u_1
inst✝ : UniformSpace α
g : Set (α × α) → Filter β
f : Filter β
hg : Monotone g
h : ((𝓤 α).lift fun s => g (Prod.swap ⁻¹' s)) ≤ f
⊢ (𝓤 α).lift (g ∘ preimage Prod.swap) ≤ f

tactic: exact h
state_before: α : Type ua
β : Type ub
γ : Type uc
δ : Type ud
ι : Sort u_1
inst✝ : UniformSpace α
g : Set (α × α) → Filter β
f : Filter β
hg : Monotone g
h : ((𝓤 α).lift fun s => g (Prod.swap ⁻¹' s)) ≤ f
⊢ (𝓤 α).lift (g ∘ preimage Prod.swap) ≤ f
state_after: no goals
Theorem: FreeAlgebra.liftAux_eq
File: Mathlib/Algebra/FreeAlgebra.lean

tactic: rw [lift]
state_before: R : Type u_1
inst✝² : CommSemiring R
X : Type u_2
A : Type u_3
inst✝¹ : Semiring A
inst✝ : Algebra R A
f : X → A
⊢ FreeAlgebra.liftAux R f = (lift R) f
state_after: R : Type u_1
inst✝² : CommSemiring R
X : Type u_2
A : Type u_3
inst✝¹ : Semiring A
inst✝ : Algebra R A
f : X → A
⊢ FreeAlgebra.liftAux R f =
    { toFun := FreeAlgebra.liftAux R, invFun := fun F => ⇑F ∘ ι R, left_inv := ⋯, right_inv := ⋯ } f

tactic: rfl
state_before: R : Type u_1
inst✝² : CommSemiring R
X : Type u_2
A : Type u_3
inst✝¹ : Semiring A
inst✝ : Algebra R A
f : X → A
⊢ FreeAlgebra.liftAux R f =
    { toFun := FreeAlgebra.liftAux R, invFun := fun F => ⇑F ∘ ι R, left_inv := ⋯, right_inv := ⋯ } f
state_after: no goals
Theorem: Ideal.map_pi
File: Mathlib/RingTheory/Ideal/Quotient.lean

tactic: classical
  cases nonempty_fintype ι
  rw [pi_eq_sum_univ x]
  simp only [Finset.sum_apply, smul_eq_mul, map_sum, Pi.smul_apply, map_smul]
  exact I.sum_mem fun j _ => I.mul_mem_right _ (hi j)
state_before: R : Type u
inst✝¹ : CommRing R
I : Ideal R
a b : R
S ι✝ : Type v
ι : Type u_1
inst✝ : Finite ι
ι' : Type w
x : ι → R
hi : ∀ (i : ι), x i ∈ I
f : (ι → R) →ₗ[R] ι' → R
i : ι'
⊢ f x i ∈ I
state_after: no goals

tactic: cases nonempty_fintype ι
state_before: R : Type u
inst✝¹ : CommRing R
I : Ideal R
a b : R
S ι✝ : Type v
ι : Type u_1
inst✝ : Finite ι
ι' : Type w
x : ι → R
hi : ∀ (i : ι), x i ∈ I
f : (ι → R) →ₗ[R] ι' → R
i : ι'
⊢ f x i ∈ I
state_after: case intro
R : Type u
inst✝¹ : CommRing R
I : Ideal R
a b : R
S ι✝ : Type v
ι : Type u_1
inst✝ : Finite ι
ι' : Type w
x : ι → R
hi : ∀ (i : ι), x i ∈ I
f : (ι → R) →ₗ[R] ι' → R
i : ι'
val✝ : Fintype ι
⊢ f x i ∈ I

tactic: rw [pi_eq_sum_univ x]
state_before: case intro
R : Type u
inst✝¹ : CommRing R
I : Ideal R
a b : R
S ι✝ : Type v
ι : Type u_1
inst✝ : Finite ι
ι' : Type w
x : ι → R
hi : ∀ (i : ι), x i ∈ I
f : (ι → R) →ₗ[R] ι' → R
i : ι'
val✝ : Fintype ι
⊢ f x i ∈ I
state_after: case intro
R : Type u
inst✝¹ : CommRing R
I : Ideal R
a b : R
S ι✝ : Type v
ι : Type u_1
inst✝ : Finite ι
ι' : Type w
x : ι → R
hi : ∀ (i : ι), x i ∈ I
f : (ι → R) →ₗ[R] ι' → R
i : ι'
val✝ : Fintype ι
⊢ f (∑ i : ι, x i • fun j => if i = j then 1 else 0) i ∈ I

tactic: simp only [Finset.sum_apply, smul_eq_mul, map_sum, Pi.smul_apply, map_smul]
state_before: case intro
R : Type u
inst✝¹ : CommRing R
I : Ideal R
a b : R
S ι✝ : Type v
ι : Type u_1
inst✝ : Finite ι
ι' : Type w
x : ι → R
hi : ∀ (i : ι), x i ∈ I
f : (ι → R) →ₗ[R] ι' → R
i : ι'
val✝ : Fintype ι
⊢ f (∑ i : ι, x i • fun j => if i = j then 1 else 0) i ∈ I
state_after: case intro
R : Type u
inst✝¹ : CommRing R
I : Ideal R
a b : R
S ι✝ : Type v
ι : Type u_1
inst✝ : Finite ι
ι' : Type w
x : ι → R
hi : ∀ (i : ι), x i ∈ I
f : (ι → R) →ₗ[R] ι' → R
i : ι'
val✝ : Fintype ι
⊢ ∑ x_1 : ι, x x_1 * f (fun j => if x_1 = j then 1 else 0) i ∈ I

tactic: exact I.sum_mem fun j _ => I.mul_mem_right _ (hi j)
state_before: case intro
R : Type u
inst✝¹ : CommRing R
I : Ideal R
a b : R
S ι✝ : Type v
ι : Type u_1
inst✝ : Finite ι
ι' : Type w
x : ι → R
hi : ∀ (i : ι), x i ∈ I
f : (ι → R) →ₗ[R] ι' → R
i : ι'
val✝ : Fintype ι
⊢ ∑ x_1 : ι, x x_1 * f (fun j => if x_1 = j then 1 else 0) i ∈ I
state_after: no goals
Theorem: Fin.contractNth_apply_of_gt
File: Mathlib/Data/Fin/Tuple/Basic.lean

tactic: rw [contractNth, if_neg (not_lt_of_gt h), if_neg (Ne.symm <| ne_of_lt h)]
state_before: m n : ℕ
α : Type u_1
j : Fin (n + 1)
op : α → α → α
g : Fin (n + 1) → α
k : Fin n
h : ↑j < ↑k
⊢ j.contractNth op g k = g k.succ
state_after: no goals