1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: Nat.exists_strictMono'
File: Mathlib/Order/Monotone/Basic.lean

tactic: choose g hg using fun x : α ↦ exists_gt x
state_before: ι : Type u_1
α : Type u
β : Type v
γ : Type w
δ : Type u_2
π : ι → Type u_3
r : α → α → Prop
inst✝¹ : Preorder α
inst✝ : NoMaxOrder α
a : α
⊢ ∃ f, StrictMono f ∧ f 0 = a
state_after: ι : Type u_1
α : Type u
β : Type v
γ : Type w
δ : Type u_2
π : ι → Type u_3
r : α → α → Prop
inst✝¹ : Preorder α
inst✝ : NoMaxOrder α
a : α
g : α → α
hg : ∀ (x : α), x < g x
⊢ ∃ f, StrictMono f ∧ f 0 = a

tactic: exact ⟨fun n ↦ Nat.recOn n a fun _ ↦ g, strictMono_nat_of_lt_succ fun n ↦ hg _, rfl⟩
state_before: ι : Type u_1
α : Type u
β : Type v
γ : Type w
δ : Type u_2
π : ι → Type u_3
r : α → α → Prop
inst✝¹ : Preorder α
inst✝ : NoMaxOrder α
a : α
g : α → α
hg : ∀ (x : α), x < g x
⊢ ∃ f, StrictMono f ∧ f 0 = a
state_after: no goals
Theorem: Computation.results_of_terminates'
File: Mathlib/Data/Seq/Computation.lean

tactic: rw [← get_eq_of_mem _ h]
state_before: α : Type u
β : Type v
γ : Type w
s : Computation α
T : s.Terminates
a : α
h : a ∈ s
⊢ s.Results a s.length
state_after: α : Type u
β : Type v
γ : Type w
s : Computation α
T : s.Terminates
a : α
h : a ∈ s
⊢ s.Results s.get s.length

tactic: apply results_of_terminates
state_before: α : Type u
β : Type v
γ : Type w
s : Computation α
T : s.Terminates
a : α
h : a ∈ s
⊢ s.Results s.get s.length
state_after: no goals
Theorem: DirectSum.of_zero_pow
File: Mathlib/Algebra/DirectSum/Ring.lean

tactic: rw [pow_zero, pow_zero, DirectSum.of_zero_one]
state_before: ι : Type u_1
inst✝³ : DecidableEq ι
A : ι → Type u_2
inst✝² : (i : ι) → AddCommMonoid (A i)
inst✝¹ : AddMonoid ι
inst✝ : GSemiring A
a : A 0
⊢ (of A 0) (a ^ 0) = (of A 0) a ^ 0
state_after: no goals

tactic: rw [pow_succ, pow_succ, of_zero_mul, of_zero_pow _ n]
state_before: ι : Type u_1
inst✝³ : DecidableEq ι
A : ι → Type u_2
inst✝² : (i : ι) → AddCommMonoid (A i)
inst✝¹ : AddMonoid ι
inst✝ : GSemiring A
a : A 0
n : ℕ
⊢ (of A 0) (a ^ (n + 1)) = (of A 0) a ^ (n + 1)
state_after: no goals
Theorem: id_compRel
File: Mathlib/Topology/UniformSpace/Basic.lean

tactic: simp
state_before: α : Type ua
β : Type ub
γ : Type uc
δ : Type ud
ι : Sort u_1
r : Set (α × α)
x✝ : α × α
a b : α
⊢ (a, b) ∈ idRel ○ r ↔ (a, b) ∈ r
state_after: no goals
Theorem: Nat.pow_le_of_le_log
File: Mathlib/Data/Nat/Log.lean

tactic: refine (le_or_lt b 1).elim (fun hb => ?_) fun hb => (pow_le_iff_le_log hb hy).2 h
state_before: b x y : ℕ
hy : y ≠ 0
h : x ≤ log b y
⊢ b ^ x ≤ y
state_after: b x y : ℕ
hy : y ≠ 0
h : x ≤ log b y
hb : b ≤ 1
⊢ b ^ x ≤ y

tactic: rw [log_of_left_le_one hb, Nat.le_zero] at h
state_before: b x y : ℕ
hy : y ≠ 0
h : x ≤ log b y
hb : b ≤ 1
⊢ b ^ x ≤ y
state_after: b x y : ℕ
hy : y ≠ 0
h : x = 0
hb : b ≤ 1
⊢ b ^ x ≤ y

tactic: rwa [h, Nat.pow_zero, one_le_iff_ne_zero]
state_before: b x y : ℕ
hy : y ≠ 0
h : x = 0
hb : b ≤ 1
⊢ b ^ x ≤ y
state_after: no goals
Theorem: CompleteSublattice.isComplemented_iff
File: Mathlib/Order/CompleteSublattice.lean

tactic: refine ⟨fun ⟨h⟩ a ha ↦ ?_, fun h ↦ ⟨fun ⟨a, ha⟩ ↦ ?_⟩⟩
state_before: α : Type u_1
β : Type u_2
inst✝¹ : CompleteLattice α
inst✝ : CompleteLattice β
f : CompleteLatticeHom α β
L : CompleteSublattice α
⊢ ComplementedLattice ↥L ↔ ∀ a ∈ L, ∃ b ∈ L, IsCompl a b
state_after: case refine_1
α : Type u_1
β : Type u_2
inst✝¹ : CompleteLattice α
inst✝ : CompleteLattice β
f : CompleteLatticeHom α β
L : CompleteSublattice α
x✝ : ComplementedLattice ↥L
a : α
ha : a ∈ L
h : ∀ (a : ↥L), ∃ b, IsCompl a b
⊢ ∃ b ∈ L, IsCompl a b

case refine_2
α : Type u_1
β : Type u_2
inst✝¹ : CompleteLattice α
inst✝ : CompleteLattice β
f : CompleteLatticeHom α β
L : CompleteSublattice α
h : ∀ a ∈ L, ∃ b ∈ L, IsCompl a b
x✝ : ↥L
a : α
ha : a ∈ L
⊢ ∃ b, IsCompl ⟨a, ha⟩ b

tactic: obtain ⟨b, hb⟩ := h ⟨a, ha⟩
state_before: case refine_1
α : Type u_1
β : Type u_2
inst✝¹ : CompleteLattice α
inst✝ : CompleteLattice β
f : CompleteLatticeHom α β
L : CompleteSublattice α
x✝ : ComplementedLattice ↥L
a : α
ha : a ∈ L
h : ∀ (a : ↥L), ∃ b, IsCompl a b
⊢ ∃ b ∈ L, IsCompl a b
state_after: case refine_1.intro
α : Type u_1
β : Type u_2
inst✝¹ : CompleteLattice α
inst✝ : CompleteLattice β
f : CompleteLatticeHom α β
L : CompleteSublattice α
x✝ : ComplementedLattice ↥L
a : α
ha : a ∈ L
h : ∀ (a : ↥L), ∃ b, IsCompl a b
b : ↥L
hb : IsCompl ⟨a, ha⟩ b
⊢ ∃ b ∈ L, IsCompl a b

tactic: exact ⟨b, b.property, CompleteSublattice.isCompl_iff.mp hb⟩
state_before: case refine_1.intro
α : Type u_1
β : Type u_2
inst✝¹ : CompleteLattice α
inst✝ : CompleteLattice β
f : CompleteLatticeHom α β
L : CompleteSublattice α
x✝ : ComplementedLattice ↥L
a : α
ha : a ∈ L
h : ∀ (a : ↥L), ∃ b, IsCompl a b
b : ↥L
hb : IsCompl ⟨a, ha⟩ b
⊢ ∃ b ∈ L, IsCompl a b
state_after: no goals

tactic: obtain ⟨b, hb, hb'⟩ := h a ha
state_before: case refine_2
α : Type u_1
β : Type u_2
inst✝¹ : CompleteLattice α
inst✝ : CompleteLattice β
f : CompleteLatticeHom α β
L : CompleteSublattice α
h : ∀ a ∈ L, ∃ b ∈ L, IsCompl a b
x✝ : ↥L
a : α
ha : a ∈ L
⊢ ∃ b, IsCompl ⟨a, ha⟩ b
state_after: case refine_2.intro.intro
α : Type u_1
β : Type u_2
inst✝¹ : CompleteLattice α
inst✝ : CompleteLattice β
f : CompleteLatticeHom α β
L : CompleteSublattice α
h : ∀ a ∈ L, ∃ b ∈ L, IsCompl a b
x✝ : ↥L
a : α
ha : a ∈ L
b : α
hb : b ∈ L
hb' : IsCompl a b
⊢ ∃ b, IsCompl ⟨a, ha⟩ b

tactic: exact ⟨⟨b, hb⟩, CompleteSublattice.isCompl_iff.mpr hb'⟩
state_before: case refine_2.intro.intro
α : Type u_1
β : Type u_2
inst✝¹ : CompleteLattice α
inst✝ : CompleteLattice β
f : CompleteLatticeHom α β
L : CompleteSublattice α
h : ∀ a ∈ L, ∃ b ∈ L, IsCompl a b
x✝ : ↥L
a : α
ha : a ∈ L
b : α
hb : b ∈ L
hb' : IsCompl a b
⊢ ∃ b, IsCompl ⟨a, ha⟩ b
state_after: no goals
Theorem: threeGPFree_insert_of_lt
File: Mathlib/Combinatorics/Additive/AP/Three/Defs.lean

tactic: refine threeGPFree_insert.trans ?_
state_before: F : Type u_1
α : Type u_2
β : Type u_3
𝕜 : Type u_4
E : Type u_5
inst✝ : OrderedCancelCommMonoid α
s : Set α
a : α
hs : ∀ i ∈ s, i < a
⊢ ThreeGPFree (insert a s) ↔ ThreeGPFree s ∧ ∀ ⦃b : α⦄, b ∈ s → ∀ ⦃c : α⦄, c ∈ s → a * c = b * b → a = b
state_after: F : Type u_1
α : Type u_2
β : Type u_3
𝕜 : Type u_4
E : Type u_5
inst✝ : OrderedCancelCommMonoid α
s : Set α
a : α
hs : ∀ i ∈ s, i < a
⊢ (ThreeGPFree s ∧
      (∀ ⦃b : α⦄, b ∈ s → ∀ ⦃c : α⦄, c ∈ s → a * c = b * b → a = b) ∧
        ∀ ⦃b : α⦄, b ∈ s → ∀ ⦃c : α⦄, c ∈ s → b * c = a * a → b = a) ↔
    ThreeGPFree s ∧ ∀ ⦃b : α⦄, b ∈ s → ∀ ⦃c : α⦄, c ∈ s → a * c = b * b → a = b

tactic: rw [← and_assoc]
state_before: F : Type u_1
α : Type u_2
β : Type u_3
𝕜 : Type u_4
E : Type u_5
inst✝ : OrderedCancelCommMonoid α
s : Set α
a : α
hs : ∀ i ∈ s, i < a
⊢ (ThreeGPFree s ∧
      (∀ ⦃b : α⦄, b ∈ s → ∀ ⦃c : α⦄, c ∈ s → a * c = b * b → a = b) ∧
        ∀ ⦃b : α⦄, b ∈ s → ∀ ⦃c : α⦄, c ∈ s → b * c = a * a → b = a) ↔
    ThreeGPFree s ∧ ∀ ⦃b : α⦄, b ∈ s → ∀ ⦃c : α⦄, c ∈ s → a * c = b * b → a = b
state_after: F : Type u_1
α : Type u_2
β : Type u_3
𝕜 : Type u_4
E : Type u_5
inst✝ : OrderedCancelCommMonoid α
s : Set α
a : α
hs : ∀ i ∈ s, i < a
⊢ ((ThreeGPFree s ∧ ∀ ⦃b : α⦄, b ∈ s → ∀ ⦃c : α⦄, c ∈ s → a * c = b * b → a = b) ∧
      ∀ ⦃b : α⦄, b ∈ s → ∀ ⦃c : α⦄, c ∈ s → b * c = a * a → b = a) ↔
    ThreeGPFree s ∧ ∀ ⦃b : α⦄, b ∈ s → ∀ ⦃c : α⦄, c ∈ s → a * c = b * b → a = b

tactic: exact and_iff_left fun b hb c hc h => ((mul_lt_mul_of_lt_of_lt (hs _ hb) (hs _ hc)).ne h).elim
state_before: F : Type u_1
α : Type u_2
β : Type u_3
𝕜 : Type u_4
E : Type u_5
inst✝ : OrderedCancelCommMonoid α
s : Set α
a : α
hs : ∀ i ∈ s, i < a
⊢ ((ThreeGPFree s ∧ ∀ ⦃b : α⦄, b ∈ s → ∀ ⦃c : α⦄, c ∈ s → a * c = b * b → a = b) ∧
      ∀ ⦃b : α⦄, b ∈ s → ∀ ⦃c : α⦄, c ∈ s → b * c = a * a → b = a) ↔
    ThreeGPFree s ∧ ∀ ⦃b : α⦄, b ∈ s → ∀ ⦃c : α⦄, c ∈ s → a * c = b * b → a = b
state_after: no goals
Theorem: Real.Angle.abs_sin_eq_of_two_zsmul_eq
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Angle.lean

tactic: exact abs_sin_eq_of_two_nsmul_eq h
state_before: θ ψ : Angle
h : 2 • θ = 2 • ψ
⊢ |θ.sin| = |ψ.sin|
state_after: no goals
Theorem: Filter.map₂_swap
File: Mathlib/Order/Filter/NAry.lean

tactic: rw [← map_prod_eq_map₂, prod_comm, map_map, ← map_prod_eq_map₂, Function.comp_def]
state_before: α : Type u_1
α' : Type u_2
β : Type u_3
β' : Type u_4
γ : Type u_5
γ' : Type u_6
δ : Type u_7
δ' : Type u_8
ε : Type u_9
ε' : Type u_10
m✝ : α → β → γ
f✝ f₁ f₂ : Filter α
g✝ g₁ g₂ : Filter β
h h₁ h₂ : Filter γ
s s₁ s₂ : Set α
t t₁ t₂ : Set β
u : Set γ
v : Set δ
a : α
b : β
c : γ
m : α → β → γ
f : Filter α
g : Filter β
⊢ map₂ m f g = map₂ (fun a b => m b a) g f
state_after: no goals
Theorem: MvPolynomial.monomial_le_degreeOf
File: Mathlib/Algebra/MvPolynomial/Degrees.lean

tactic: rw [degreeOf_eq_sup i]
state_before: R : Type u
S : Type v
σ : Type u_1
τ : Type u_2
r : R
e : ℕ
n m✝ : σ
s : σ →₀ ℕ
inst✝ : CommSemiring R
p q : MvPolynomial σ R
i : σ
f : MvPolynomial σ R
m : σ →₀ ℕ
h_m : m ∈ f.support
⊢ m i ≤ degreeOf i f
state_after: R : Type u
S : Type v
σ : Type u_1
τ : Type u_2
r : R
e : ℕ
n m✝ : σ
s : σ →₀ ℕ
inst✝ : CommSemiring R
p q : MvPolynomial σ R
i : σ
f : MvPolynomial σ R
m : σ →₀ ℕ
h_m : m ∈ f.support
⊢ m i ≤ f.support.sup fun m => m i

tactic: apply Finset.le_sup h_m
state_before: R : Type u
S : Type v
σ : Type u_1
τ : Type u_2
r : R
e : ℕ
n m✝ : σ
s : σ →₀ ℕ
inst✝ : CommSemiring R
p q : MvPolynomial σ R
i : σ
f : MvPolynomial σ R
m : σ →₀ ℕ
h_m : m ∈ f.support
⊢ m i ≤ f.support.sup fun m => m i
state_after: no goals
Theorem: iInf_eq_bot
File: Mathlib/Order/CompleteLattice.lean

tactic: simp only [← sInf_range, sInf_eq_bot, Set.exists_range_iff]
state_before: α : Type u_1
β : Type u_2
β₂ : Type u_3
γ : Type u_4
ι : Sort u_5
ι' : Sort u_6
κ : ι → Sort u_7
κ' : ι' → Sort u_8
inst✝ : CompleteLinearOrder α
f : ι → α
⊢ iInf f = ⊥ ↔ ∀ b > ⊥, ∃ i, f i < b
state_after: no goals
Theorem: Filter.smallSets_top
File: Mathlib/Order/Filter/SmallSets.lean

tactic: rw [smallSets, lift'_top, powerset_univ, principal_univ]
state_before: α : Type u_1
β : Type u_2
ι : Sort u_3
l l' la : Filter α
lb : Filter β
⊢ ⊤.smallSets = ⊤
state_after: no goals
Theorem: Pell.xz_sub
File: Mathlib/NumberTheory/PellMatiyasevic.lean

tactic: rw [sub_eq_add_neg, ← mul_neg]
state_before: a : ℕ
a1 : 1 < a
m n : ℕ
h : n ≤ m
⊢ xz a1 (m - n) = xz a1 m * xz a1 n - ↑(Pell.d a1) * yz a1 m * yz a1 n
state_after: a : ℕ
a1 : 1 < a
m n : ℕ
h : n ≤ m
⊢ xz a1 (m - n) = xz a1 m * xz a1 n + ↑(Pell.d a1) * yz a1 m * -yz a1 n

tactic: exact congr_arg Zsqrtd.re (pellZd_sub a1 h)
state_before: a : ℕ
a1 : 1 < a
m n : ℕ
h : n ≤ m
⊢ xz a1 (m - n) = xz a1 m * xz a1 n + ↑(Pell.d a1) * yz a1 m * -yz a1 n
state_after: no goals
Theorem: linear_isometry_complex
File: Mathlib/Analysis/Complex/Isometry.lean

tactic: let a : circle := ⟨f 1, by rw [mem_circle_iff_abs, ← Complex.norm_eq_abs, f.norm_map, norm_one]⟩
state_before: f : ℂ ≃ₗᵢ[ℝ] ℂ
⊢ ∃ a, f = rotation a ∨ f = conjLIE.trans (rotation a)
state_after: f : ℂ ≃ₗᵢ[ℝ] ℂ
a : ↥circle := ⟨f 1, ⋯⟩
⊢ ∃ a, f = rotation a ∨ f = conjLIE.trans (rotation a)

tactic: use a
state_before: f : ℂ ≃ₗᵢ[ℝ] ℂ
a : ↥circle := ⟨f 1, ⋯⟩
⊢ ∃ a, f = rotation a ∨ f = conjLIE.trans (rotation a)
state_after: case h
f : ℂ ≃ₗᵢ[ℝ] ℂ
a : ↥circle := ⟨f 1, ⋯⟩
⊢ f = rotation a ∨ f = conjLIE.trans (rotation a)

tactic: have : (f.trans (rotation a).symm) 1 = 1 := by simpa using rotation_apply a⁻¹ (f 1)
state_before: case h
f : ℂ ≃ₗᵢ[ℝ] ℂ
a : ↥circle := ⟨f 1, ⋯⟩
⊢ f = rotation a ∨ f = conjLIE.trans (rotation a)
state_after: case h
f : ℂ ≃ₗᵢ[ℝ] ℂ
a : ↥circle := ⟨f 1, ⋯⟩
this : (f.trans (rotation a).symm) 1 = 1
⊢ f = rotation a ∨ f = conjLIE.trans (rotation a)

tactic: refine (linear_isometry_complex_aux this).imp (fun h₁ => ?_) fun h₂ => ?_
state_before: case h
f : ℂ ≃ₗᵢ[ℝ] ℂ
a : ↥circle := ⟨f 1, ⋯⟩
this : (f.trans (rotation a).symm) 1 = 1
⊢ f = rotation a ∨ f = conjLIE.trans (rotation a)
state_after: case h.refine_1
f : ℂ ≃ₗᵢ[ℝ] ℂ
a : ↥circle := ⟨f 1, ⋯⟩
this : (f.trans (rotation a).symm) 1 = 1
h₁ : f.trans (rotation a).symm = LinearIsometryEquiv.refl ℝ ℂ
⊢ f = rotation a

case h.refine_2
f : ℂ ≃ₗᵢ[ℝ] ℂ
a : ↥circle := ⟨f 1, ⋯⟩
this : (f.trans (rotation a).symm) 1 = 1
h₂ : f.trans (rotation a).symm = conjLIE
⊢ f = conjLIE.trans (rotation a)

tactic: rw [mem_circle_iff_abs, ← Complex.norm_eq_abs, f.norm_map, norm_one]
state_before: f : ℂ ≃ₗᵢ[ℝ] ℂ
⊢ f 1 ∈ circle
state_after: no goals

tactic: simpa using rotation_apply a⁻¹ (f 1)
state_before: f : ℂ ≃ₗᵢ[ℝ] ℂ
a : ↥circle := ⟨f 1, ⋯⟩
⊢ (f.trans (rotation a).symm) 1 = 1
state_after: no goals

tactic: simpa using eq_mul_of_inv_mul_eq h₁
state_before: case h.refine_1
f : ℂ ≃ₗᵢ[ℝ] ℂ
a : ↥circle := ⟨f 1, ⋯⟩
this : (f.trans (rotation a).symm) 1 = 1
h₁ : f.trans (rotation a).symm = LinearIsometryEquiv.refl ℝ ℂ
⊢ f = rotation a
state_after: no goals

tactic: exact eq_mul_of_inv_mul_eq h₂
state_before: case h.refine_2
f : ℂ ≃ₗᵢ[ℝ] ℂ
a : ↥circle := ⟨f 1, ⋯⟩
this : (f.trans (rotation a).symm) 1 = 1
h₂ : f.trans (rotation a).symm = conjLIE
⊢ f = conjLIE.trans (rotation a)
state_after: no goals
Theorem: Real.eq_rpow_inv
File: Mathlib/Analysis/SpecialFunctions/Pow/Real.lean

tactic: rw [← rpow_left_inj hx _ hz, rpow_inv_rpow hy hz]
state_before: x y z : ℝ
n : ℕ
hx : 0 ≤ x
hy : 0 ≤ y
hz : z ≠ 0
⊢ x = y ^ z⁻¹ ↔ x ^ z = y
state_after: x y z : ℝ
n : ℕ
hx : 0 ≤ x
hy : 0 ≤ y
hz : z ≠ 0
⊢ 0 ≤ y ^ z⁻¹

tactic: positivity
state_before: x y z : ℝ
n : ℕ
hx : 0 ≤ x
hy : 0 ≤ y
hz : z ≠ 0
⊢ 0 ≤ y ^ z⁻¹
state_after: no goals
Theorem: CategoryTheory.Limits.Sigma.map'_comp_map'
File: Mathlib/CategoryTheory/Limits/Shapes/Products.lean

tactic: ext
state_before: β : Type w
α : Type w₂
γ : Type w₃
C : Type u
inst✝³ : Category.{v, u} C
f : α → C
g : β → C
h : γ → C
inst✝² : HasCoproduct f
inst✝¹ : HasCoproduct g
inst✝ : HasCoproduct h
p : α → β
p' : β → γ
q : (a : α) → f a ⟶ g (p a)
q' : (b : β) → g b ⟶ h (p' b)
⊢ map' p q ≫ map' p' q' = map' (p' ∘ p) fun a => q a ≫ q' (p a)
state_after: case h
β : Type w
α : Type w₂
γ : Type w₃
C : Type u
inst✝³ : Category.{v, u} C
f : α → C
g : β → C
h : γ → C
inst✝² : HasCoproduct f
inst✝¹ : HasCoproduct g
inst✝ : HasCoproduct h
p : α → β
p' : β → γ
q : (a : α) → f a ⟶ g (p a)
q' : (b : β) → g b ⟶ h (p' b)
b✝ : α
⊢ ι f b✝ ≫ map' p q ≫ map' p' q' = ι f b✝ ≫ map' (p' ∘ p) fun a => q a ≫ q' (p a)

tactic: simp
state_before: case h
β : Type w
α : Type w₂
γ : Type w₃
C : Type u
inst✝³ : Category.{v, u} C
f : α → C
g : β → C
h : γ → C
inst✝² : HasCoproduct f
inst✝¹ : HasCoproduct g
inst✝ : HasCoproduct h
p : α → β
p' : β → γ
q : (a : α) → f a ⟶ g (p a)
q' : (b : β) → g b ⟶ h (p' b)
b✝ : α
⊢ ι f b✝ ≫ map' p q ≫ map' p' q' = ι f b✝ ≫ map' (p' ∘ p) fun a => q a ≫ q' (p a)
state_after: no goals
Theorem: ack_two
File: Mathlib/Computability/Ackermann.lean

tactic: induction' n with n IH
state_before: n : ℕ
⊢ ack 2 n = 2 * n + 3
state_after: case zero

⊢ ack 2 0 = 2 * 0 + 3

case succ
n : ℕ
IH : ack 2 n = 2 * n + 3
⊢ ack 2 (n + 1) = 2 * (n + 1) + 3

tactic: rfl
state_before: case zero

⊢ ack 2 0 = 2 * 0 + 3
state_after: no goals

tactic: simpa [mul_succ]
state_before: case succ
n : ℕ
IH : ack 2 n = 2 * n + 3
⊢ ack 2 (n + 1) = 2 * (n + 1) + 3
state_after: no goals
Theorem: ne₁₃_of_not_collinear
File: Mathlib/LinearAlgebra/AffineSpace/FiniteDimensional.lean

tactic: rintro rfl
state_before: k : Type u_1
V : Type u_2
P : Type u_3
ι : Type u_4
inst✝³ : DivisionRing k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
p₁ p₂ p₃ : P
h : ¬Collinear k {p₁, p₂, p₃}
⊢ p₁ ≠ p₃
state_after: k : Type u_1
V : Type u_2
P : Type u_3
ι : Type u_4
inst✝³ : DivisionRing k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
p₁ p₂ : P
h : ¬Collinear k {p₁, p₂, p₁}
⊢ False

tactic: simp [collinear_pair] at h
state_before: k : Type u_1
V : Type u_2
P : Type u_3
ι : Type u_4
inst✝³ : DivisionRing k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
p₁ p₂ : P
h : ¬Collinear k {p₁, p₂, p₁}
⊢ False
state_after: no goals
Theorem: Mathlib.Meta.NormNum.isNat_minFac_2
File: Mathlib/Tactic/NormNum/Prime.lean

tactic: rw [cast_ofNat, minFac_eq_two_iff, Nat.dvd_iff_mod_eq_zero, h]
state_before: a : ℕ
h : a % 2 = 0
⊢ a.minFac = ↑2
state_after: no goals
Theorem: AffineMap.ext_linear_iff
File: Mathlib/LinearAlgebra/AffineSpace/AffineMap.lean

tactic: inhabit P1
state_before: k : Type u_1
V1 : Type u_2
P1 : Type u_3
V2 : Type u_4
P2 : Type u_5
V3 : Type u_6
P3 : Type u_7
V4 : Type u_8
P4 : Type u_9
inst✝¹² : Ring k
inst✝¹¹ : AddCommGroup V1
inst✝¹⁰ : Module k V1
inst✝⁹ : AffineSpace V1 P1
inst✝⁸ : AddCommGroup V2
inst✝⁷ : Module k V2
inst✝⁶ : AffineSpace V2 P2
inst✝⁵ : AddCommGroup V3
inst✝⁴ : Module k V3
inst✝³ : AffineSpace V3 P3
inst✝² : AddCommGroup V4
inst✝¹ : Module k V4
inst✝ : AffineSpace V4 P4
f g : P1 →ᵃ[k] P2
h : f = g
⊢ P1
state_after: k : Type u_1
V1 : Type u_2
P1 : Type u_3
V2 : Type u_4
P2 : Type u_5
V3 : Type u_6
P3 : Type u_7
V4 : Type u_8
P4 : Type u_9
inst✝¹² : Ring k
inst✝¹¹ : AddCommGroup V1
inst✝¹⁰ : Module k V1
inst✝⁹ : AffineSpace V1 P1
inst✝⁸ : AddCommGroup V2
inst✝⁷ : Module k V2
inst✝⁶ : AffineSpace V2 P2
inst✝⁵ : AddCommGroup V3
inst✝⁴ : Module k V3
inst✝³ : AffineSpace V3 P3
inst✝² : AddCommGroup V4
inst✝¹ : Module k V4
inst✝ : AffineSpace V4 P4
f g : P1 →ᵃ[k] P2
h : f = g
inhabited_h : Inhabited P1
⊢ P1

tactic: exact default
state_before: k : Type u_1
V1 : Type u_2
P1 : Type u_3
V2 : Type u_4
P2 : Type u_5
V3 : Type u_6
P3 : Type u_7
V4 : Type u_8
P4 : Type u_9
inst✝¹² : Ring k
inst✝¹¹ : AddCommGroup V1
inst✝¹⁰ : Module k V1
inst✝⁹ : AffineSpace V1 P1
inst✝⁸ : AddCommGroup V2
inst✝⁷ : Module k V2
inst✝⁶ : AffineSpace V2 P2
inst✝⁵ : AddCommGroup V3
inst✝⁴ : Module k V3
inst✝³ : AffineSpace V3 P3
inst✝² : AddCommGroup V4
inst✝¹ : Module k V4
inst✝ : AffineSpace V4 P4
f g : P1 →ᵃ[k] P2
h : f = g
inhabited_h : Inhabited P1
⊢ P1
state_after: no goals

tactic: rw [h]
state_before: k : Type u_1
V1 : Type u_2
P1 : Type u_3
V2 : Type u_4
P2 : Type u_5
V3 : Type u_6
P3 : Type u_7
V4 : Type u_8
P4 : Type u_9
inst✝¹² : Ring k
inst✝¹¹ : AddCommGroup V1
inst✝¹⁰ : Module k V1
inst✝⁹ : AffineSpace V1 P1
inst✝⁸ : AddCommGroup V2
inst✝⁷ : Module k V2
inst✝⁶ : AffineSpace V2 P2
inst✝⁵ : AddCommGroup V3
inst✝⁴ : Module k V3
inst✝³ : AffineSpace V3 P3
inst✝² : AddCommGroup V4
inst✝¹ : Module k V4
inst✝ : AffineSpace V4 P4
f g : P1 →ᵃ[k] P2
h : f = g
⊢ f default = g default
state_after: no goals
Theorem: Multiset.finite_toSet_toFinset
File: Mathlib/Data/Set/Finite.lean

tactic: ext x
state_before: α : Type u
β : Type v
ι : Sort w
γ : Type x
inst✝ : DecidableEq α
s : Multiset α
⊢ ⋯.toFinset = s.toFinset
state_after: case a
α : Type u
β : Type v
ι : Sort w
γ : Type x
inst✝ : DecidableEq α
s : Multiset α
x : α
⊢ x ∈ ⋯.toFinset ↔ x ∈ s.toFinset

tactic: simp
state_before: case a
α : Type u
β : Type v
ι : Sort w
γ : Type x
inst✝ : DecidableEq α
s : Multiset α
x : α
⊢ x ∈ ⋯.toFinset ↔ x ∈ s.toFinset
state_after: no goals
Theorem: toIxxMod_antisymm
File: Mathlib/Algebra/Order/ToIntervalMod.lean

tactic: by_contra! h
state_before: α : Type u_1
inst✝ : LinearOrderedAddCommGroup α
hα : Archimedean α
p : α
hp : 0 < p
a b c : α
n : ℤ
h₁₂₃ : toIcoMod hp a b ≤ toIocMod hp a c
h₁₃₂ : toIcoMod hp a c ≤ toIocMod hp a b
⊢ b ≡ a [PMOD p] ∨ c ≡ b [PMOD p] ∨ a ≡ c [PMOD p]
state_after: α : Type u_1
inst✝ : LinearOrderedAddCommGroup α
hα : Archimedean α
p : α
hp : 0 < p
a b c : α
n : ℤ
h₁₂₃ : toIcoMod hp a b ≤ toIocMod hp a c
h₁₃₂ : toIcoMod hp a c ≤ toIocMod hp a b
h : ¬b ≡ a [PMOD p] ∧ ¬c ≡ b [PMOD p] ∧ ¬a ≡ c [PMOD p]
⊢ False

tactic: rw [modEq_comm] at h
state_before: α : Type u_1
inst✝ : LinearOrderedAddCommGroup α
hα : Archimedean α
p : α
hp : 0 < p
a b c : α
n : ℤ
h₁₂₃ : toIcoMod hp a b ≤ toIocMod hp a c
h₁₃₂ : toIcoMod hp a c ≤ toIocMod hp a b
h : ¬b ≡ a [PMOD p] ∧ ¬c ≡ b [PMOD p] ∧ ¬a ≡ c [PMOD p]
⊢ False
state_after: α : Type u_1
inst✝ : LinearOrderedAddCommGroup α
hα : Archimedean α
p : α
hp : 0 < p
a b c : α
n : ℤ
h₁₂₃ : toIcoMod hp a b ≤ toIocMod hp a c
h₁₃₂ : toIcoMod hp a c ≤ toIocMod hp a b
h : ¬a ≡ b [PMOD p] ∧ ¬c ≡ b [PMOD p] ∧ ¬a ≡ c [PMOD p]
⊢ False

tactic: rw [← (not_modEq_iff_toIcoMod_eq_toIocMod hp).mp h.2.2] at h₁₂₃
state_before: α : Type u_1
inst✝ : LinearOrderedAddCommGroup α
hα : Archimedean α
p : α
hp : 0 < p
a b c : α
n : ℤ
h₁₂₃ : toIcoMod hp a b ≤ toIocMod hp a c
h₁₃₂ : toIcoMod hp a c ≤ toIocMod hp a b
h : ¬a ≡ b [PMOD p] ∧ ¬c ≡ b [PMOD p] ∧ ¬a ≡ c [PMOD p]
⊢ False
state_after: α : Type u_1
inst✝ : LinearOrderedAddCommGroup α
hα : Archimedean α
p : α
hp : 0 < p
a b c : α
n : ℤ
h₁₂₃ : toIcoMod hp a b ≤ toIcoMod hp a c
h₁₃₂ : toIcoMod hp a c ≤ toIocMod hp a b
h : ¬a ≡ b [PMOD p] ∧ ¬c ≡ b [PMOD p] ∧ ¬a ≡ c [PMOD p]
⊢ False

tactic: rw [← (not_modEq_iff_toIcoMod_eq_toIocMod hp).mp h.1] at h₁₃₂
state_before: α : Type u_1
inst✝ : LinearOrderedAddCommGroup α
hα : Archimedean α
p : α
hp : 0 < p
a b c : α
n : ℤ
h₁₂₃ : toIcoMod hp a b ≤ toIcoMod hp a c
h₁₃₂ : toIcoMod hp a c ≤ toIocMod hp a b
h : ¬a ≡ b [PMOD p] ∧ ¬c ≡ b [PMOD p] ∧ ¬a ≡ c [PMOD p]
⊢ False
state_after: α : Type u_1
inst✝ : LinearOrderedAddCommGroup α
hα : Archimedean α
p : α
hp : 0 < p
a b c : α
n : ℤ
h₁₂₃ : toIcoMod hp a b ≤ toIcoMod hp a c
h₁₃₂ : toIcoMod hp a c ≤ toIcoMod hp a b
h : ¬a ≡ b [PMOD p] ∧ ¬c ≡ b [PMOD p] ∧ ¬a ≡ c [PMOD p]
⊢ False

tactic: exact h.2.1 ((toIcoMod_inj _).1 <| h₁₃₂.antisymm h₁₂₃)
state_before: α : Type u_1
inst✝ : LinearOrderedAddCommGroup α
hα : Archimedean α
p : α
hp : 0 < p
a b c : α
n : ℤ
h₁₂₃ : toIcoMod hp a b ≤ toIcoMod hp a c
h₁₃₂ : toIcoMod hp a c ≤ toIcoMod hp a b
h : ¬a ≡ b [PMOD p] ∧ ¬c ≡ b [PMOD p] ∧ ¬a ≡ c [PMOD p]
⊢ False
state_after: no goals
Theorem: LucasLehmer.sZMod_eq_sMod
File: Mathlib/NumberTheory/LucasLehmer.lean

tactic: induction i <;> push_cast [← Int.coe_nat_two_pow_pred p, sMod, sZMod, *] <;> rfl
state_before: p i : ℕ
⊢ sZMod p i = ↑(sMod p i)
state_after: no goals
Theorem: Set.preimage_mul_const_Ioc_of_neg
File: Mathlib/Data/Set/Pointwise/Interval.lean

tactic: simp [← Ioi_inter_Iic, ← Ici_inter_Iio, h, inter_comm]
state_before: α : Type u_1
inst✝ : LinearOrderedField α
a✝ a b c : α
h : c < 0
⊢ (fun x => x * c) ⁻¹' Ioc a b = Ico (b / c) (a / c)
state_after: no goals
Theorem: continuous_bool_rng
File: Mathlib/Topology/Constructions.lean

tactic: rw [continuous_discrete_rng, Bool.forall_bool' b, IsClopen, ← isOpen_compl_iff, ← preimage_compl,
  Bool.compl_singleton, and_comm]
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
f : X → Bool
b : Bool
⊢ Continuous f ↔ IsClopen (f ⁻¹' {b})
state_after: no goals
Theorem: realPart_I_smul
File: Mathlib/Data/Complex/Module.lean

tactic: ext
state_before: A : Type u_1
inst✝³ : AddCommGroup A
inst✝² : Module ℂ A
inst✝¹ : StarAddMonoid A
inst✝ : StarModule ℂ A
a : A
⊢ ℜ (I • a) = -ℑ a
state_after: case a
A : Type u_1
inst✝³ : AddCommGroup A
inst✝² : Module ℂ A
inst✝¹ : StarAddMonoid A
inst✝ : StarModule ℂ A
a : A
⊢ ↑(ℜ (I • a)) = ↑(-ℑ a)

tactic: rw [realPart_apply_coe, NegMemClass.coe_neg, imaginaryPart_apply_coe, neg_smul, neg_neg,
  smul_comm I, star_smul, star_def, conj_I, smul_sub, neg_smul, sub_eq_add_neg]
state_before: case a
A : Type u_1
inst✝³ : AddCommGroup A
inst✝² : Module ℂ A
inst✝¹ : StarAddMonoid A
inst✝ : StarModule ℂ A
a : A
⊢ ↑(ℜ (I • a)) = ↑(-ℑ a)
state_after: no goals