1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: NatOrdinal.mul_le_nmul
File: Mathlib/SetTheory/Ordinal/NaturalOps.lean

tactic: refine b.limitRecOn ?_ ?_ ?_
state_before: a b : Ordinal.{u}
⊢ a * b ≤ a ⨳ b
state_after: case refine_1
a b : Ordinal.{u}
⊢ a * 0 ≤ a ⨳ 0

case refine_2
a b : Ordinal.{u}
⊢ ∀ (o : Ordinal.{u}), a * o ≤ a ⨳ o → a * succ o ≤ a ⨳ succ o

case refine_3
a b : Ordinal.{u}
⊢ ∀ (o : Ordinal.{u}), o.IsLimit → (∀ o' < o, a * o' ≤ a ⨳ o') → a * o ≤ a ⨳ o

tactic: simp
state_before: case refine_1
a b : Ordinal.{u}
⊢ a * 0 ≤ a ⨳ 0
state_after: no goals

tactic: intro c h
state_before: case refine_2
a b : Ordinal.{u}
⊢ ∀ (o : Ordinal.{u}), a * o ≤ a ⨳ o → a * succ o ≤ a ⨳ succ o
state_after: case refine_2
a b c : Ordinal.{u}
h : a * c ≤ a ⨳ c
⊢ a * succ c ≤ a ⨳ succ c

tactic: rw [mul_succ, nmul_succ]
state_before: case refine_2
a b c : Ordinal.{u}
h : a * c ≤ a ⨳ c
⊢ a * succ c ≤ a ⨳ succ c
state_after: case refine_2
a b c : Ordinal.{u}
h : a * c ≤ a ⨳ c
⊢ a * c + a ≤ a ⨳ c ♯ a

tactic: exact (add_le_nadd _ a).trans (nadd_le_nadd_right h a)
state_before: case refine_2
a b c : Ordinal.{u}
h : a * c ≤ a ⨳ c
⊢ a * c + a ≤ a ⨳ c ♯ a
state_after: no goals

tactic: intro c hc H
state_before: case refine_3
a b : Ordinal.{u}
⊢ ∀ (o : Ordinal.{u}), o.IsLimit → (∀ o' < o, a * o' ≤ a ⨳ o') → a * o ≤ a ⨳ o
state_after: case refine_3
a b c : Ordinal.{u}
hc : c.IsLimit
H : ∀ o' < c, a * o' ≤ a ⨳ o'
⊢ a * c ≤ a ⨳ c

tactic: rcases eq_zero_or_pos a with (rfl | ha)
state_before: case refine_3
a b c : Ordinal.{u}
hc : c.IsLimit
H : ∀ o' < c, a * o' ≤ a ⨳ o'
⊢ a * c ≤ a ⨳ c
state_after: case refine_3.inl
b c : Ordinal.{u}
hc : c.IsLimit
H : ∀ o' < c, 0 * o' ≤ 0 ⨳ o'
⊢ 0 * c ≤ 0 ⨳ c

case refine_3.inr
a b c : Ordinal.{u}
hc : c.IsLimit
H : ∀ o' < c, a * o' ≤ a ⨳ o'
ha : 0 < a
⊢ a * c ≤ a ⨳ c

tactic: simp
state_before: case refine_3.inl
b c : Ordinal.{u}
hc : c.IsLimit
H : ∀ o' < c, 0 * o' ≤ 0 ⨳ o'
⊢ 0 * c ≤ 0 ⨳ c
state_after: no goals

tactic: rw [← IsNormal.blsub_eq.{u, u} (mul_isNormal ha) hc, blsub_le_iff]
state_before: case refine_3.inr
a b c : Ordinal.{u}
hc : c.IsLimit
H : ∀ o' < c, a * o' ≤ a ⨳ o'
ha : 0 < a
⊢ a * c ≤ a ⨳ c
state_after: case refine_3.inr
a b c : Ordinal.{u}
hc : c.IsLimit
H : ∀ o' < c, a * o' ≤ a ⨳ o'
ha : 0 < a
⊢ ∀ i < c, a * i < a ⨳ c

tactic: exact fun i hi => (H i hi).trans_lt (nmul_lt_nmul_of_pos_left hi ha)
state_before: case refine_3.inr
a b c : Ordinal.{u}
hc : c.IsLimit
H : ∀ o' < c, a * o' ≤ a ⨳ o'
ha : 0 < a
⊢ ∀ i < c, a * i < a ⨳ c
state_after: no goals
Theorem: Fermat42.ne_zero
File: Mathlib/NumberTheory/FLT/Four.lean

tactic: apply ne_zero_pow two_ne_zero _
state_before: a b c : ℤ
h : Fermat42 a b c
⊢ c ≠ 0
state_after: a b c : ℤ
h : Fermat42 a b c
⊢ c ^ 2 ≠ 0

tactic: apply ne_of_gt
state_before: a b c : ℤ
h : Fermat42 a b c
⊢ c ^ 2 ≠ 0
state_after: case h
a b c : ℤ
h : Fermat42 a b c
⊢ 0 < c ^ 2

tactic: rw [← h.2.2, (by ring : a ^ 4 + b ^ 4 = (a ^ 2) ^ 2 + (b ^ 2) ^ 2)]
state_before: case h
a b c : ℤ
h : Fermat42 a b c
⊢ 0 < c ^ 2
state_after: case h
a b c : ℤ
h : Fermat42 a b c
⊢ 0 < (a ^ 2) ^ 2 + (b ^ 2) ^ 2

tactic: exact
  add_pos (sq_pos_of_ne_zero (pow_ne_zero 2 h.1)) (sq_pos_of_ne_zero (pow_ne_zero 2 h.2.1))
state_before: case h
a b c : ℤ
h : Fermat42 a b c
⊢ 0 < (a ^ 2) ^ 2 + (b ^ 2) ^ 2
state_after: no goals

tactic: ring
state_before: a b c : ℤ
h : Fermat42 a b c
⊢ a ^ 4 + b ^ 4 = (a ^ 2) ^ 2 + (b ^ 2) ^ 2
state_after: no goals
Theorem: Part.mem_restrict
File: Mathlib/Data/Part.lean

tactic: dsimp [restrict, mem_eq]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
p : Prop
o : Part α
h : p → o.Dom
a : α
⊢ a ∈ restrict p o h ↔ p ∧ a ∈ o
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
p : Prop
o : Part α
h : p → o.Dom
a : α
⊢ (∃ (h_1 : p), o.get ⋯ = a) ↔ p ∧ ∃ (h : o.Dom), o.get h = a

tactic: constructor
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
p : Prop
o : Part α
h : p → o.Dom
a : α
⊢ (∃ (h_1 : p), o.get ⋯ = a) ↔ p ∧ ∃ (h : o.Dom), o.get h = a
state_after: case mp
α : Type u_1
β : Type u_2
γ : Type u_3
p : Prop
o : Part α
h : p → o.Dom
a : α
⊢ (∃ (h_1 : p), o.get ⋯ = a) → p ∧ ∃ (h : o.Dom), o.get h = a

case mpr
α : Type u_1
β : Type u_2
γ : Type u_3
p : Prop
o : Part α
h : p → o.Dom
a : α
⊢ (p ∧ ∃ (h : o.Dom), o.get h = a) → ∃ (h_1 : p), o.get ⋯ = a

tactic: rintro ⟨h₀, _, h₂⟩
state_before: case mpr
α : Type u_1
β : Type u_2
γ : Type u_3
p : Prop
o : Part α
h : p → o.Dom
a : α
⊢ (p ∧ ∃ (h : o.Dom), o.get h = a) → ∃ (h_1 : p), o.get ⋯ = a
state_after: case mpr.intro.intro
α : Type u_1
β : Type u_2
γ : Type u_3
p : Prop
o : Part α
h : p → o.Dom
a : α
h₀ : p
w✝ : o.Dom
h₂ : o.get w✝ = a
⊢ ∃ (h_1 : p), o.get ⋯ = a

tactic: exact ⟨h₀, h₂⟩
state_before: case mpr.intro.intro
α : Type u_1
β : Type u_2
γ : Type u_3
p : Prop
o : Part α
h : p → o.Dom
a : α
h₀ : p
w✝ : o.Dom
h₂ : o.get w✝ = a
⊢ ∃ (h_1 : p), o.get ⋯ = a
state_after: no goals

tactic: rintro ⟨h₀, h₁⟩
state_before: case mp
α : Type u_1
β : Type u_2
γ : Type u_3
p : Prop
o : Part α
h : p → o.Dom
a : α
⊢ (∃ (h_1 : p), o.get ⋯ = a) → p ∧ ∃ (h : o.Dom), o.get h = a
state_after: case mp.intro
α : Type u_1
β : Type u_2
γ : Type u_3
p : Prop
o : Part α
h : p → o.Dom
a : α
h₀ : p
h₁ : o.get ⋯ = a
⊢ p ∧ ∃ (h : o.Dom), o.get h = a

tactic: exact ⟨h₀, ⟨_, h₁⟩⟩
state_before: case mp.intro
α : Type u_1
β : Type u_2
γ : Type u_3
p : Prop
o : Part α
h : p → o.Dom
a : α
h₀ : p
h₁ : o.get ⋯ = a
⊢ p ∧ ∃ (h : o.Dom), o.get h = a
state_after: no goals
Theorem: MeasureTheory.VectorMeasure.restrict_eq_self
File: Mathlib/MeasureTheory/Measure/VectorMeasure.lean

tactic: rw [restrict_apply v hi hj, Set.inter_eq_left.2 hij]
state_before: α : Type u_1
β : Type u_2
m inst✝³ : MeasurableSpace α
inst✝² : MeasurableSpace β
M : Type u_3
inst✝¹ : AddCommMonoid M
inst✝ : TopologicalSpace M
v : VectorMeasure α M
i : Set α
hi : MeasurableSet i
j : Set α
hj : MeasurableSet j
hij : j ⊆ i
⊢ ↑(v.restrict i) j = ↑v j
state_after: no goals
Theorem: Composition.sigma_eq_iff_blocks_eq
File: Mathlib/Combinatorics/Enumerative/Composition.lean

tactic: refine ⟨fun H => by rw [H], fun H => ?_⟩
state_before: n : ℕ
c✝ : Composition n
c c' : (n : ℕ) × Composition n
⊢ c = c' ↔ c.snd.blocks = c'.snd.blocks
state_after: n : ℕ
c✝ : Composition n
c c' : (n : ℕ) × Composition n
H : c.snd.blocks = c'.snd.blocks
⊢ c = c'

tactic: rcases c with ⟨n, c⟩
state_before: n : ℕ
c✝ : Composition n
c c' : (n : ℕ) × Composition n
H : c.snd.blocks = c'.snd.blocks
⊢ c = c'
state_after: case mk
n✝ : ℕ
c✝ : Composition n✝
c' : (n : ℕ) × Composition n
n : ℕ
c : Composition n
H : ⟨n, c⟩.snd.blocks = c'.snd.blocks
⊢ ⟨n, c⟩ = c'

tactic: rcases c' with ⟨n', c'⟩
state_before: case mk
n✝ : ℕ
c✝ : Composition n✝
c' : (n : ℕ) × Composition n
n : ℕ
c : Composition n
H : ⟨n, c⟩.snd.blocks = c'.snd.blocks
⊢ ⟨n, c⟩ = c'
state_after: case mk.mk
n✝ : ℕ
c✝ : Composition n✝
n : ℕ
c : Composition n
n' : ℕ
c' : Composition n'
H : ⟨n, c⟩.snd.blocks = ⟨n', c'⟩.snd.blocks
⊢ ⟨n, c⟩ = ⟨n', c'⟩

tactic: have : n = n' := by rw [← c.blocks_sum, ← c'.blocks_sum, H]
state_before: case mk.mk
n✝ : ℕ
c✝ : Composition n✝
n : ℕ
c : Composition n
n' : ℕ
c' : Composition n'
H : ⟨n, c⟩.snd.blocks = ⟨n', c'⟩.snd.blocks
⊢ ⟨n, c⟩ = ⟨n', c'⟩
state_after: case mk.mk
n✝ : ℕ
c✝ : Composition n✝
n : ℕ
c : Composition n
n' : ℕ
c' : Composition n'
H : ⟨n, c⟩.snd.blocks = ⟨n', c'⟩.snd.blocks
this : n = n'
⊢ ⟨n, c⟩ = ⟨n', c'⟩

tactic: induction this
state_before: case mk.mk
n✝ : ℕ
c✝ : Composition n✝
n : ℕ
c : Composition n
n' : ℕ
c' : Composition n'
H : ⟨n, c⟩.snd.blocks = ⟨n', c'⟩.snd.blocks
this : n = n'
⊢ ⟨n, c⟩ = ⟨n', c'⟩
state_after: case mk.mk.refl
n✝ : ℕ
c✝ : Composition n✝
n : ℕ
c : Composition n
n' : ℕ
c' : Composition n
H : ⟨n, c⟩.snd.blocks = ⟨n, c'⟩.snd.blocks
⊢ ⟨n, c⟩ = ⟨n, c'⟩

tactic: congr
state_before: case mk.mk.refl
n✝ : ℕ
c✝ : Composition n✝
n : ℕ
c : Composition n
n' : ℕ
c' : Composition n
H : ⟨n, c⟩.snd.blocks = ⟨n, c'⟩.snd.blocks
⊢ ⟨n, c⟩ = ⟨n, c'⟩
state_after: case mk.mk.refl.e_snd
n✝ : ℕ
c✝ : Composition n✝
n : ℕ
c : Composition n
n' : ℕ
c' : Composition n
H : ⟨n, c⟩.snd.blocks = ⟨n, c'⟩.snd.blocks
⊢ c = c'

tactic: ext1
state_before: case mk.mk.refl.e_snd
n✝ : ℕ
c✝ : Composition n✝
n : ℕ
c : Composition n
n' : ℕ
c' : Composition n
H : ⟨n, c⟩.snd.blocks = ⟨n, c'⟩.snd.blocks
⊢ c = c'
state_after: case mk.mk.refl.e_snd.blocks
n✝ : ℕ
c✝ : Composition n✝
n : ℕ
c : Composition n
n' : ℕ
c' : Composition n
H : ⟨n, c⟩.snd.blocks = ⟨n, c'⟩.snd.blocks
⊢ c.blocks = c'.blocks

tactic: exact H
state_before: case mk.mk.refl.e_snd.blocks
n✝ : ℕ
c✝ : Composition n✝
n : ℕ
c : Composition n
n' : ℕ
c' : Composition n
H : ⟨n, c⟩.snd.blocks = ⟨n, c'⟩.snd.blocks
⊢ c.blocks = c'.blocks
state_after: no goals

tactic: rw [H]
state_before: n : ℕ
c✝ : Composition n
c c' : (n : ℕ) × Composition n
H : c = c'
⊢ c.snd.blocks = c'.snd.blocks
state_after: no goals

tactic: rw [← c.blocks_sum, ← c'.blocks_sum, H]
state_before: n✝ : ℕ
c✝ : Composition n✝
n : ℕ
c : Composition n
n' : ℕ
c' : Composition n'
H : ⟨n, c⟩.snd.blocks = ⟨n', c'⟩.snd.blocks
⊢ n = n'
state_after: no goals
Theorem: Surreal.Multiplication.P3.trans
File: Mathlib/SetTheory/Surreal/Multiplication.lean

tactic: rw [P3] at h₁ h₂
state_before: x x₁ x₂ x₃ x' y y₁ y₂ y₃ y' : PGame
h₁ : P3 x₁ x₂ y₁ y₂
h₂ : P3 x₂ x₃ y₁ y₂
⊢ P3 x₁ x₃ y₁ y₂
state_after: x x₁ x₂ x₃ x' y y₁ y₂ y₃ y' : PGame
h₁ : ⟦x₁ * y₂⟧ + ⟦x₂ * y₁⟧ < ⟦x₁ * y₁⟧ + ⟦x₂ * y₂⟧
h₂ : ⟦x₂ * y₂⟧ + ⟦x₃ * y₁⟧ < ⟦x₂ * y₁⟧ + ⟦x₃ * y₂⟧
⊢ P3 x₁ x₃ y₁ y₂

tactic: rw [P3, ← add_lt_add_iff_left (⟦x₂ * y₁⟧ + ⟦x₂ * y₂⟧)]
state_before: x x₁ x₂ x₃ x' y y₁ y₂ y₃ y' : PGame
h₁ : ⟦x₁ * y₂⟧ + ⟦x₂ * y₁⟧ < ⟦x₁ * y₁⟧ + ⟦x₂ * y₂⟧
h₂ : ⟦x₂ * y₂⟧ + ⟦x₃ * y₁⟧ < ⟦x₂ * y₁⟧ + ⟦x₃ * y₂⟧
⊢ P3 x₁ x₃ y₁ y₂
state_after: x x₁ x₂ x₃ x' y y₁ y₂ y₃ y' : PGame
h₁ : ⟦x₁ * y₂⟧ + ⟦x₂ * y₁⟧ < ⟦x₁ * y₁⟧ + ⟦x₂ * y₂⟧
h₂ : ⟦x₂ * y₂⟧ + ⟦x₃ * y₁⟧ < ⟦x₂ * y₁⟧ + ⟦x₃ * y₂⟧
⊢ ⟦x₂ * y₁⟧ + ⟦x₂ * y₂⟧ + (⟦x₁ * y₂⟧ + ⟦x₃ * y₁⟧) < ⟦x₂ * y₁⟧ + ⟦x₂ * y₂⟧ + (⟦x₁ * y₁⟧ + ⟦x₃ * y₂⟧)

tactic: convert add_lt_add h₁ h₂ using 1 <;> abel
state_before: x x₁ x₂ x₃ x' y y₁ y₂ y₃ y' : PGame
h₁ : ⟦x₁ * y₂⟧ + ⟦x₂ * y₁⟧ < ⟦x₁ * y₁⟧ + ⟦x₂ * y₂⟧
h₂ : ⟦x₂ * y₂⟧ + ⟦x₃ * y₁⟧ < ⟦x₂ * y₁⟧ + ⟦x₃ * y₂⟧
⊢ ⟦x₂ * y₁⟧ + ⟦x₂ * y₂⟧ + (⟦x₁ * y₂⟧ + ⟦x₃ * y₁⟧) < ⟦x₂ * y₁⟧ + ⟦x₂ * y₂⟧ + (⟦x₁ * y₁⟧ + ⟦x₃ * y₂⟧)
state_after: no goals
Theorem: MeasureTheory.univ_mem_measurableCylinders
File: Mathlib/MeasureTheory/Constructions/Cylinders.lean

tactic: rw [← compl_empty]
state_before: ι : Type u_2
α✝ : ι → Type ?u.38100
inst✝¹ : (i : ι) → MeasurableSpace (α✝ i)
s t : Set ((i : ι) → α✝ i)
α : ι → Type u_1
inst✝ : (i : ι) → MeasurableSpace (α i)
⊢ univ ∈ measurableCylinders α
state_after: ι : Type u_2
α✝ : ι → Type ?u.38100
inst✝¹ : (i : ι) → MeasurableSpace (α✝ i)
s t : Set ((i : ι) → α✝ i)
α : ι → Type u_1
inst✝ : (i : ι) → MeasurableSpace (α i)
⊢ ∅ᶜ ∈ measurableCylinders α

tactic: exact compl_mem_measurableCylinders (empty_mem_measurableCylinders α)
state_before: ι : Type u_2
α✝ : ι → Type ?u.38100
inst✝¹ : (i : ι) → MeasurableSpace (α✝ i)
s t : Set ((i : ι) → α✝ i)
α : ι → Type u_1
inst✝ : (i : ι) → MeasurableSpace (α i)
⊢ ∅ᶜ ∈ measurableCylinders α
state_after: no goals
Theorem: HasDerivAt.ofReal_comp
File: Mathlib/Analysis/Complex/RealDeriv.lean

tactic: simpa only [ofRealCLM_apply, ofReal_one, real_smul, mul_one] using
  ofRealCLM.hasDerivAt.scomp z hf
state_before: e : ℂ → ℂ
e' : ℂ
z : ℝ
E : Type u_1
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace ℂ E
f : ℝ → ℝ
u : ℝ
hf : HasDerivAt f u z
⊢ HasDerivAt (fun y => ↑(f y)) (↑u) z
state_after: no goals
Theorem: Nat.even_sub
File: Mathlib/Algebra/Group/Nat.lean

tactic: conv_rhs => rw [← Nat.sub_add_cancel h, even_add]
state_before: m n : ℕ
h : n ≤ m
⊢ Even (m - n) ↔ (Even m ↔ Even n)
state_after: m n : ℕ
h : n ≤ m
⊢ Even (m - n) ↔ ((Even (m - n) ↔ Even n) ↔ Even n)

tactic: by_cases h : Even n <;> simp [h]
state_before: m n : ℕ
h : n ≤ m
⊢ Even (m - n) ↔ ((Even (m - n) ↔ Even n) ↔ Even n)
state_after: no goals
Theorem: EMetric.inseparable_iff
File: Mathlib/Topology/EMetricSpace/Basic.lean

tactic: simp [inseparable_iff_mem_closure, mem_closure_iff, edist_comm, forall_lt_iff_le']
state_before: α : Type u
β : Type v
X : Type u_1
inst✝ : PseudoEMetricSpace α
x y z : α
ε ε₁ ε₂ : ℝ≥0∞
s t : Set α
⊢ Inseparable x y ↔ edist x y = 0
state_after: no goals
Theorem: Cardinal.cantorFunction_le
File: Mathlib/Data/Real/Cardinality.lean

tactic: apply tsum_le_tsum _ (summable_cantor_function f h1 h2) (summable_cantor_function g h1 h2)
state_before: c : ℝ
f g : ℕ → Bool
n : ℕ
h1 : 0 ≤ c
h2 : c < 1
h3 : ∀ (n : ℕ), f n = true → g n = true
⊢ cantorFunction c f ≤ cantorFunction c g
state_after: c : ℝ
f g : ℕ → Bool
n : ℕ
h1 : 0 ≤ c
h2 : c < 1
h3 : ∀ (n : ℕ), f n = true → g n = true
⊢ ∀ (i : ℕ), cantorFunctionAux c f i ≤ cantorFunctionAux c g i

tactic: intro n
state_before: c : ℝ
f g : ℕ → Bool
n : ℕ
h1 : 0 ≤ c
h2 : c < 1
h3 : ∀ (n : ℕ), f n = true → g n = true
⊢ ∀ (i : ℕ), cantorFunctionAux c f i ≤ cantorFunctionAux c g i
state_after: c : ℝ
f g : ℕ → Bool
n✝ : ℕ
h1 : 0 ≤ c
h2 : c < 1
h3 : ∀ (n : ℕ), f n = true → g n = true
n : ℕ
⊢ cantorFunctionAux c f n ≤ cantorFunctionAux c g n

tactic: cases h : f n
state_before: c : ℝ
f g : ℕ → Bool
n✝ : ℕ
h1 : 0 ≤ c
h2 : c < 1
h3 : ∀ (n : ℕ), f n = true → g n = true
n : ℕ
⊢ cantorFunctionAux c f n ≤ cantorFunctionAux c g n
state_after: case false
c : ℝ
f g : ℕ → Bool
n✝ : ℕ
h1 : 0 ≤ c
h2 : c < 1
h3 : ∀ (n : ℕ), f n = true → g n = true
n : ℕ
h : f n = false
⊢ cantorFunctionAux c f n ≤ cantorFunctionAux c g n

case true
c : ℝ
f g : ℕ → Bool
n✝ : ℕ
h1 : 0 ≤ c
h2 : c < 1
h3 : ∀ (n : ℕ), f n = true → g n = true
n : ℕ
h : f n = true
⊢ cantorFunctionAux c f n ≤ cantorFunctionAux c g n

tactic: replace h3 : g n = true := h3 n h
state_before: case true
c : ℝ
f g : ℕ → Bool
n✝ : ℕ
h1 : 0 ≤ c
h2 : c < 1
h3 : ∀ (n : ℕ), f n = true → g n = true
n : ℕ
h : f n = true
⊢ cantorFunctionAux c f n ≤ cantorFunctionAux c g n
state_after: case true
c : ℝ
f g : ℕ → Bool
n✝ : ℕ
h1 : 0 ≤ c
h2 : c < 1
n : ℕ
h : f n = true
h3 : g n = true
⊢ cantorFunctionAux c f n ≤ cantorFunctionAux c g n

tactic: simp [h, h3]
state_before: case true
c : ℝ
f g : ℕ → Bool
n✝ : ℕ
h1 : 0 ≤ c
h2 : c < 1
n : ℕ
h : f n = true
h3 : g n = true
⊢ cantorFunctionAux c f n ≤ cantorFunctionAux c g n
state_after: no goals

tactic: simp [h, cantorFunctionAux_nonneg h1]
state_before: case false
c : ℝ
f g : ℕ → Bool
n✝ : ℕ
h1 : 0 ≤ c
h2 : c < 1
h3 : ∀ (n : ℕ), f n = true → g n = true
n : ℕ
h : f n = false
⊢ cantorFunctionAux c f n ≤ cantorFunctionAux c g n
state_after: no goals
Theorem: Matrix.mul_mul_invOf_self_cancel
File: Mathlib/Data/Matrix/Invertible.lean

tactic: rw [Matrix.mul_assoc, mul_invOf_self, Matrix.mul_one]
state_before: m : Type u_1
n : Type u_2
α : Type u_3
inst✝³ : Fintype n
inst✝² : DecidableEq n
inst✝¹ : Semiring α
A : Matrix m n α
B : Matrix n n α
inst✝ : Invertible B
⊢ A * B * ⅟B = A
state_after: no goals
Theorem: TensorProduct.finsuppScalarRight_symm_apply_single
File: Mathlib/LinearAlgebra/DirectSum/Finsupp.lean

tactic: simp [finsuppScalarRight, finsuppRight_symm_apply_single]
state_before: R : Type u_1
inst✝⁹ : CommSemiring R
M : Type u_2
inst✝⁸ : AddCommMonoid M
inst✝⁷ : Module R M
N : Type u_3
inst✝⁶ : AddCommMonoid N
inst✝⁵ : Module R N
ι : Type u_4
inst✝⁴ : DecidableEq ι
S : Type u_5
inst✝³ : CommSemiring S
inst✝² : Algebra R S
inst✝¹ : Module S M
inst✝ : IsScalarTower R S M
i : ι
m : M
⊢ (finsuppScalarRight R M ι).symm (Finsupp.single i m) = m ⊗ₜ[R] Finsupp.single i 1
state_after: no goals
Theorem: Nat.sq_sub_sq
File: Mathlib/Data/Nat/Defs.lean

tactic: simpa [Nat.pow_succ] using Nat.mul_self_sub_mul_self_eq a b
state_before: a✝ b✝ c d m n k : ℕ
p q : ℕ → Prop
a b : ℕ
⊢ a ^ 2 - b ^ 2 = (a + b) * (a - b)
state_after: no goals
Theorem: cfc_apply
File: Mathlib/Topology/ContinuousFunction/FunctionalCalculus.lean

tactic: rw [cfc_def, dif_pos ⟨ha, hf⟩]
state_before: R : Type u_1
A : Type u_2
p : A → Prop
inst✝⁹ : CommSemiring R
inst✝⁸ : StarRing R
inst✝⁷ : MetricSpace R
inst✝⁶ : TopologicalSemiring R
inst✝⁵ : ContinuousStar R
inst✝⁴ : TopologicalSpace A
inst✝³ : Ring A
inst✝² : StarRing A
inst✝¹ : Algebra R A
inst✝ : ContinuousFunctionalCalculus R p
f g : R → R
a : A
ha : autoParam (p a) _auto✝
hf : autoParam (ContinuousOn f (spectrum R a)) _auto✝
hg : autoParam (ContinuousOn g (spectrum R a)) _auto✝
⊢ cfc f a = (cfcHom ha) { toFun := (spectrum R a).restrict f, continuous_toFun := ⋯ }
state_after: no goals
Theorem: Projectivization.Subspace.span_univ
File: Mathlib/LinearAlgebra/Projectivization/Subspace.lean

tactic: rw [eq_top_iff, SetLike.le_def]
state_before: K : Type u_1
V : Type u_2
inst✝² : Field K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
⊢ span Set.univ = ⊤
state_after: K : Type u_1
V : Type u_2
inst✝² : Field K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
⊢ ∀ ⦃x : ℙ K V⦄, x ∈ ⊤ → x ∈ span Set.univ

tactic: intro x _hx
state_before: K : Type u_1
V : Type u_2
inst✝² : Field K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
⊢ ∀ ⦃x : ℙ K V⦄, x ∈ ⊤ → x ∈ span Set.univ
state_after: K : Type u_1
V : Type u_2
inst✝² : Field K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
x : ℙ K V
_hx : x ∈ ⊤
⊢ x ∈ span Set.univ

tactic: exact subset_span _ (Set.mem_univ x)
state_before: K : Type u_1
V : Type u_2
inst✝² : Field K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
x : ℙ K V
_hx : x ∈ ⊤
⊢ x ∈ span Set.univ
state_after: no goals
Theorem: Cardinal.beth_one
File: Mathlib/SetTheory/Cardinal/Continuum.lean

tactic: simpa using beth_succ 0
state_before: ⊢ beth 1 = 𝔠
state_after: no goals
Theorem: CategoryTheory.FunctorToTypes.prodMk_snd
File: Mathlib/CategoryTheory/Limits/Shapes/FunctorToTypes.lean

tactic: simp only [prodMk, binaryProductIso_inv_comp_snd_apply]
state_before: C : Type u
inst✝ : Category.{v, u} C
F G : C ⥤ Type w
a : C
x : F.obj a
y : G.obj a
⊢ Limits.prod.snd.app a (prodMk x y) = y
state_after: no goals
Theorem: EulerProduct.summable_and_hasSum_smoothNumbers_prod_primesBelow_geometric
File: Mathlib/NumberTheory/EulerProduct/Basic.lean

tactic: rw [smoothNumbers_eq_factoredNumbers, primesBelow]
state_before: F : Type u_1
inst✝¹ : NormedField F
inst✝ : CompleteSpace F
f : ℕ →* F
h : ∀ {p : ℕ}, Nat.Prime p → ‖f p‖ < 1
N : ℕ
⊢ (Summable fun m => ‖f ↑m‖) ∧ HasSum (fun m => f ↑m) (∏ p ∈ N.primesBelow, (1 - f p)⁻¹)
state_after: F : Type u_1
inst✝¹ : NormedField F
inst✝ : CompleteSpace F
f : ℕ →* F
h : ∀ {p : ℕ}, Nat.Prime p → ‖f p‖ < 1
N : ℕ
⊢ (Summable fun m => ‖f ↑m‖) ∧ HasSum (fun m => f ↑m) (∏ p ∈ filter (fun p => Nat.Prime p) (range N), (1 - f p)⁻¹)

tactic: exact summable_and_hasSum_factoredNumbers_prod_filter_prime_geometric h _
state_before: F : Type u_1
inst✝¹ : NormedField F
inst✝ : CompleteSpace F
f : ℕ →* F
h : ∀ {p : ℕ}, Nat.Prime p → ‖f p‖ < 1
N : ℕ
⊢ (Summable fun m => ‖f ↑m‖) ∧ HasSum (fun m => f ↑m) (∏ p ∈ filter (fun p => Nat.Prime p) (range N), (1 - f p)⁻¹)
state_after: no goals
Theorem: Turing.tr_reaches
File: Mathlib/Computability/TuringMachine.lean

tactic: rcases reflTransGen_iff_eq_or_transGen.1 ab with (rfl | ab)
state_before: σ₁ : Type u_1
σ₂ : Type u_2
f₁ : σ₁ → Option σ₁
f₂ : σ₂ → Option σ₂
tr : σ₁ → σ₂ → Prop
H : Respects f₁ f₂ tr
a₁ : σ₁
a₂ : σ₂
aa : tr a₁ a₂
b₁ : σ₁
ab : Reaches f₁ a₁ b₁
⊢ ∃ b₂, tr b₁ b₂ ∧ Reaches f₂ a₂ b₂
state_after: case inl
σ₁ : Type u_1
σ₂ : Type u_2
f₁ : σ₁ → Option σ₁
f₂ : σ₂ → Option σ₂
tr : σ₁ → σ₂ → Prop
H : Respects f₁ f₂ tr
a₂ : σ₂
b₁ : σ₁
aa : tr b₁ a₂
ab : Reaches f₁ b₁ b₁
⊢ ∃ b₂, tr b₁ b₂ ∧ Reaches f₂ a₂ b₂

case inr
σ₁ : Type u_1
σ₂ : Type u_2
f₁ : σ₁ → Option σ₁
f₂ : σ₂ → Option σ₂
tr : σ₁ → σ₂ → Prop
H : Respects f₁ f₂ tr
a₁ : σ₁
a₂ : σ₂
aa : tr a₁ a₂
b₁ : σ₁
ab✝ : Reaches f₁ a₁ b₁
ab : TransGen (fun a b => b ∈ f₁ a) a₁ b₁
⊢ ∃ b₂, tr b₁ b₂ ∧ Reaches f₂ a₂ b₂

tactic: exact ⟨_, aa, ReflTransGen.refl⟩
state_before: case inl
σ₁ : Type u_1
σ₂ : Type u_2
f₁ : σ₁ → Option σ₁
f₂ : σ₂ → Option σ₂
tr : σ₁ → σ₂ → Prop
H : Respects f₁ f₂ tr
a₂ : σ₂
b₁ : σ₁
aa : tr b₁ a₂
ab : Reaches f₁ b₁ b₁
⊢ ∃ b₂, tr b₁ b₂ ∧ Reaches f₂ a₂ b₂
state_after: no goals

tactic: have ⟨b₂, bb, h⟩ := tr_reaches₁ H aa ab
state_before: case inr
σ₁ : Type u_1
σ₂ : Type u_2
f₁ : σ₁ → Option σ₁
f₂ : σ₂ → Option σ₂
tr : σ₁ → σ₂ → Prop
H : Respects f₁ f₂ tr
a₁ : σ₁
a₂ : σ₂
aa : tr a₁ a₂
b₁ : σ₁
ab✝ : Reaches f₁ a₁ b₁
ab : TransGen (fun a b => b ∈ f₁ a) a₁ b₁
⊢ ∃ b₂, tr b₁ b₂ ∧ Reaches f₂ a₂ b₂
state_after: case inr
σ₁ : Type u_1
σ₂ : Type u_2
f₁ : σ₁ → Option σ₁
f₂ : σ₂ → Option σ₂
tr : σ₁ → σ₂ → Prop
H : Respects f₁ f₂ tr
a₁ : σ₁
a₂ : σ₂
aa : tr a₁ a₂
b₁ : σ₁
ab✝ : Reaches f₁ a₁ b₁
ab : TransGen (fun a b => b ∈ f₁ a) a₁ b₁
b₂ : σ₂
bb : tr b₁ b₂
h : Reaches₁ f₂ a₂ b₂
⊢ ∃ b₂, tr b₁ b₂ ∧ Reaches f₂ a₂ b₂

tactic: exact ⟨b₂, bb, h.to_reflTransGen⟩
state_before: case inr
σ₁ : Type u_1
σ₂ : Type u_2
f₁ : σ₁ → Option σ₁
f₂ : σ₂ → Option σ₂
tr : σ₁ → σ₂ → Prop
H : Respects f₁ f₂ tr
a₁ : σ₁
a₂ : σ₂
aa : tr a₁ a₂
b₁ : σ₁
ab✝ : Reaches f₁ a₁ b₁
ab : TransGen (fun a b => b ∈ f₁ a) a₁ b₁
b₂ : σ₂
bb : tr b₁ b₂
h : Reaches₁ f₂ a₂ b₂
⊢ ∃ b₂, tr b₁ b₂ ∧ Reaches f₂ a₂ b₂
state_after: no goals
Theorem: LinearMap.rTensor_comp_apply
File: Mathlib/LinearAlgebra/TensorProduct/Basic.lean

tactic: rw [rTensor_comp, coe_comp]
state_before: R : Type u_1
inst✝¹⁶ : CommSemiring R
R' : Type u_2
inst✝¹⁵ : Monoid R'
R'' : Type u_3
inst✝¹⁴ : Semiring R''
M : Type u_4
N : Type u_5
P : Type u_6
Q : Type u_7
S : Type u_8
T : Type u_9
inst✝¹³ : AddCommMonoid M
inst✝¹² : AddCommMonoid N
inst✝¹¹ : AddCommMonoid P
inst✝¹⁰ : AddCommMonoid Q
inst✝⁹ : AddCommMonoid S
inst✝⁸ : AddCommMonoid T
inst✝⁷ : Module R M
inst✝⁶ : Module R N
inst✝⁵ : Module R P
inst✝⁴ : Module R Q
inst✝³ : Module R S
inst✝² : Module R T
inst✝¹ : DistribMulAction R' M
inst✝ : Module R'' M
g : P →ₗ[R] Q
f : N →ₗ[R] P
x : N ⊗[R] M
⊢ (rTensor M (g ∘ₗ f)) x = (rTensor M g) ((rTensor M f) x)
state_after: R : Type u_1
inst✝¹⁶ : CommSemiring R
R' : Type u_2
inst✝¹⁵ : Monoid R'
R'' : Type u_3
inst✝¹⁴ : Semiring R''
M : Type u_4
N : Type u_5
P : Type u_6
Q : Type u_7
S : Type u_8
T : Type u_9
inst✝¹³ : AddCommMonoid M
inst✝¹² : AddCommMonoid N
inst✝¹¹ : AddCommMonoid P
inst✝¹⁰ : AddCommMonoid Q
inst✝⁹ : AddCommMonoid S
inst✝⁸ : AddCommMonoid T
inst✝⁷ : Module R M
inst✝⁶ : Module R N
inst✝⁵ : Module R P
inst✝⁴ : Module R Q
inst✝³ : Module R S
inst✝² : Module R T
inst✝¹ : DistribMulAction R' M
inst✝ : Module R'' M
g : P →ₗ[R] Q
f : N →ₗ[R] P
x : N ⊗[R] M
⊢ (⇑(rTensor M g) ∘ ⇑(rTensor M f)) x = (rTensor M g) ((rTensor M f) x)

tactic: rfl
state_before: R : Type u_1
inst✝¹⁶ : CommSemiring R
R' : Type u_2
inst✝¹⁵ : Monoid R'
R'' : Type u_3
inst✝¹⁴ : Semiring R''
M : Type u_4
N : Type u_5
P : Type u_6
Q : Type u_7
S : Type u_8
T : Type u_9
inst✝¹³ : AddCommMonoid M
inst✝¹² : AddCommMonoid N
inst✝¹¹ : AddCommMonoid P
inst✝¹⁰ : AddCommMonoid Q
inst✝⁹ : AddCommMonoid S
inst✝⁸ : AddCommMonoid T
inst✝⁷ : Module R M
inst✝⁶ : Module R N
inst✝⁵ : Module R P
inst✝⁴ : Module R Q
inst✝³ : Module R S
inst✝² : Module R T
inst✝¹ : DistribMulAction R' M
inst✝ : Module R'' M
g : P →ₗ[R] Q
f : N →ₗ[R] P
x : N ⊗[R] M
⊢ (⇑(rTensor M g) ∘ ⇑(rTensor M f)) x = (rTensor M g) ((rTensor M f) x)
state_after: no goals
Theorem: Nat.gcd_add_mul_right_left
File: Mathlib/Data/Nat/GCD/Basic.lean

tactic: rw [gcd_comm, gcd_add_mul_right_right, gcd_comm]
state_before: m n k : ℕ
⊢ (m + k * n).gcd n = m.gcd n
state_after: no goals
Theorem: MeasureTheory.OuterMeasure.map_le_restrict_range
File: Mathlib/MeasureTheory/OuterMeasure/Operations.lean

tactic: simpa using h (s ∩ range f)
state_before: α : Type u_1
β✝ : Type u_2
m : OuterMeasure α
β : Type u_3
ma : OuterMeasure α
mb : OuterMeasure β
f : α → β
h : (map f) ma ≤ mb
s : Set β
⊢ ((map f) ma) s ≤ ((restrict (range f)) mb) s
state_after: no goals
Theorem: Set.ncard_diff_add_ncard
File: Mathlib/Data/Set/Card.lean

tactic: rw [← ncard_union_eq disjoint_sdiff_left (hs.diff _) ht, diff_union_self]
state_before: α : Type u_1
β : Type u_2
s✝ t✝ : Set α
f : α → β
s t : Set α
hs : autoParam s.Finite _auto✝
ht : autoParam t.Finite _auto✝
⊢ (s \ t).ncard + t.ncard = (s ∪ t).ncard
state_after: no goals