tasksource/leandojo huggingface dataset:
Theorem: List.length_take
File: Std/Data/List/Lemmas.lean

tactic: simp [Nat.zero_min]
state_before: α : Type u_1
l : List α
⊢ length (take 0 l) = min 0 (length l)

tactic: simp [Nat.min_zero]
state_before: α : Type u_1
n : Nat
⊢ length (take (succ n) []) = min (succ n) (length [])

tactic: simp [Nat.min_succ_succ, add_one, length_take]
state_before: α : Type u_1
n : Nat
head✝ : α
l : List α
⊢ length (take (succ n) (head✝ :: l)) = min (succ n) (length (head✝ :: l))
Theorem: Finset.prod_range_div
File: Mathlib/Algebra/BigOperators/Basic.lean

tactic: apply prod_range_induction <;> simp
state_before: ι : Type ?u.617734
β : Type u
α : Type v
γ : Type w
s s₁ s₂ : Finset α
a : α
f✝ g : α → β
inst✝¹ : CommMonoid β
M : Type u_1
inst✝ : CommGroup M
f : ℕ → M
n : ℕ
⊢ ∏ i in range n, f (i + 1) / f i = f n / f 0
Theorem: Ideal.IsHomogeneous.iInf
File: Mathlib/RingTheory/GradedAlgebra/HomogeneousIdeal.lean

tactic: intro i x hx
state_before: ι : Type u_3
σ : Type u_4
R : Type ?u.124541
A : Type u_2
inst✝⁵ : Semiring A
inst✝⁴ : DecidableEq ι
inst✝³ : AddMonoid ι
inst✝² : SetLike σ A
inst✝¹ : AddSubmonoidClass σ A
𝒜 : ι → σ
inst✝ : GradedRing 𝒜
κ : Sort u_1
f : κ → Ideal A
h : ∀ (i : κ), IsHomogeneous 𝒜 (f i)
⊢ IsHomogeneous 𝒜 (⨅ (i : κ), f i)

tactic: simp only [Ideal.mem_iInf] at hx⊢
state_before: ι : Type u_3
σ : Type u_4
R : Type ?u.124541
A : Type u_2
inst✝⁵ : Semiring A
inst✝⁴ : DecidableEq ι
inst✝³ : AddMonoid ι
inst✝² : SetLike σ A
inst✝¹ : AddSubmonoidClass σ A
𝒜 : ι → σ
inst✝ : GradedRing 𝒜
κ : Sort u_1
f : κ → Ideal A
h : ∀ (i : κ), IsHomogeneous 𝒜 (f i)
i : ι
x : A
hx : x ∈ ⨅ (i : κ), f i
⊢ ↑(↑(↑(decompose 𝒜) x) i) ∈ ⨅ (i : κ), f i

tactic: exact fun j => h _ _ (hx j)
state_before: ι : Type u_3
σ : Type u_4
R : Type ?u.124541
A : Type u_2
inst✝⁵ : Semiring A
inst✝⁴ : DecidableEq ι
inst✝³ : AddMonoid ι
inst✝² : SetLike σ A
inst✝¹ : AddSubmonoidClass σ A
𝒜 : ι → σ
inst✝ : GradedRing 𝒜
κ : Sort u_1
f : κ → Ideal A
h : ∀ (i : κ), IsHomogeneous 𝒜 (f i)
i : ι
x : A
hx : ∀ (i : κ), x ∈ f i
⊢ ∀ (i_1 : κ), ↑(↑(↑(decompose 𝒜) x) i) ∈ f i_1
Theorem: AddCommGroup.modEq_iff_int_modEq
File: Mathlib/Algebra/ModEq.lean

tactic: simp [ModEq, dvd_iff_exists_eq_mul_left, Int.modEq_iff_dvd]
state_before: α : Type ?u.102808
a b z : ℤ
⊢ a ≡ b [PMOD z] ↔ a ≡ b [ZMOD z]
Theorem: AffineEquiv.pointReflection_midpoint_left
File: Mathlib/LinearAlgebra/AffineSpace/Midpoint.lean

tactic: rw [midpoint, pointReflection_apply, lineMap_apply, vadd_vsub, vadd_vadd, ← add_smul, ← two_mul,
  mul_invOf_self, one_smul, vsub_vadd]
state_before: R : Type u_3
V : Type u_2
V' : Type ?u.11896
P : Type u_1
P' : Type ?u.11902
inst✝⁷ : Ring R
inst✝⁶ : Invertible 2
inst✝⁵ : AddCommGroup V
inst✝⁴ : Module R V
inst✝³ : AddTorsor V P
inst✝² : AddCommGroup V'
inst✝¹ : Module R V'
inst✝ : AddTorsor V' P'
x✝ y✝ z x y : P
⊢ ↑(pointReflection R (midpoint R x y)) x = y
Theorem: Ordinal.exists_lsub_cof
File: Mathlib/SetTheory/Cardinal/Cofinality.lean

tactic: rw [cof_eq_sInf_lsub]
state_before: α : Type ?u.21687
r : α → α → Prop
o : Ordinal
⊢ ∃ ι f, lsub f = o ∧ (#ι) = cof o

tactic: exact csInf_mem (cof_lsub_def_nonempty o)
state_before: α : Type ?u.21687
r : α → α → Prop
o : Ordinal
⊢ ∃ ι f, lsub f = o ∧ (#ι) = sInf {a | ∃ ι f, lsub f = o ∧ (#ι) = a}
Theorem: Complex.cos_ne_zero_iff
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Complex.lean

tactic: rw [← not_exists, not_iff_not, cos_eq_zero_iff]
state_before: θ : ℂ
⊢ cos θ ≠ 0 ↔ ∀ (k : ℤ), θ ≠ (2 * ↑k + 1) * ↑π / 2
Theorem: Polynomial.coeff_toSubring
File: Mathlib/RingTheory/Polynomial/Basic.lean

tactic: simp only [toSubring, coeff_monomial, finset_sum_coeff, mem_support_iff, Finset.sum_ite_eq',
  Ne.def, ite_not]
state_before: R : Type u
S : Type ?u.84546
inst✝¹ : Ring R
inst✝ : Semiring S
f : R →+* S
x : S
p : R[X]
T : Subring R
hp : ↑(frange p) ⊆ ↑T
n : ℕ
⊢ ↑(coeff (toSubring p T hp) n) = coeff p n

tactic: split_ifs with h
state_before: R : Type u
S : Type ?u.84546
inst✝¹ : Ring R
inst✝ : Semiring S
f : R →+* S
x : S
p : R[X]
T : Subring R
hp : ↑(frange p) ⊆ ↑T
n : ℕ
⊢ ↑(if coeff p n = 0 then 0 else { val := coeff p n, property := (_ : coeff p n ∈ T) }) = coeff p n

tactic: rw [h]
state_before: case inl
R : Type u
S : Type ?u.84546
inst✝¹ : Ring R
inst✝ : Semiring S
f : R →+* S
x : S
p : R[X]
T : Subring R
hp : ↑(frange p) ⊆ ↑T
n : ℕ
h : coeff p n = 0
⊢ ↑0 = coeff p n

tactic: rfl
state_before: case inl
R : Type u
S : Type ?u.84546
inst✝¹ : Ring R
inst✝ : Semiring S
f : R →+* S
x : S
p : R[X]
T : Subring R
hp : ↑(frange p) ⊆ ↑T
n : ℕ
h : coeff p n = 0
⊢ ↑0 = 0

tactic: rfl
state_before: case inr
R : Type u
S : Type ?u.84546
inst✝¹ : Ring R
inst✝ : Semiring S
f : R →+* S
x : S
p : R[X]
T : Subring R
hp : ↑(frange p) ⊆ ↑T
n : ℕ
h : ¬coeff p n = 0
⊢ ↑{ val := coeff p n, property := (_ : coeff p n ∈ T) } = coeff p n
Theorem: Int.sqrt_eq
File: Mathlib/Data/Int/Sqrt.lean

tactic: rw [sqrt, ← natAbs_mul_self, toNat_coe_nat, Nat.sqrt_eq]
state_before: n : ℤ
⊢ sqrt (n * n) = ↑(natAbs n)
Theorem: Path.truncate_zero_one
File: Mathlib/Topology/PathConnected.lean

tactic: simp [zero_le_one, extend_zero]
state_before: X✝ : Type ?u.481302
Y : Type ?u.481305
inst✝² : TopologicalSpace X✝
inst✝¹ : TopologicalSpace Y
x y z : X✝
ι : Type ?u.481320
γ✝ : Path x y
X : Type ?u.481369
inst✝ : TopologicalSpace X
a b : X
γ : Path a b
⊢ extend γ (min 0 1) = a

tactic: simp
state_before: X✝ : Type ?u.481302
Y : Type ?u.481305
inst✝² : TopologicalSpace X✝
inst✝¹ : TopologicalSpace Y
x y z : X✝
ι : Type ?u.481320
γ✝ : Path x y
X : Type ?u.481369
inst✝ : TopologicalSpace X
a b : X
γ : Path a b
⊢ extend γ 1 = b

tactic: ext x
state_before: X✝ : Type ?u.481302
Y : Type ?u.481305
inst✝² : TopologicalSpace X✝
inst✝¹ : TopologicalSpace Y
x y z : X✝
ι : Type ?u.481320
γ✝ : Path x y
X : Type u_1
inst✝ : TopologicalSpace X
a b : X
γ : Path a b
⊢ truncate γ 0 1 = cast γ (_ : extend γ (min 0 1) = a) (_ : extend γ 1 = b)

tactic: rw [cast_coe]
state_before: case a.h
X✝ : Type ?u.481302
Y : Type ?u.481305
inst✝² : TopologicalSpace X✝
inst✝¹ : TopologicalSpace Y
x✝ y z : X✝
ι : Type ?u.481320
γ✝ : Path x✝ y
X : Type u_1
inst✝ : TopologicalSpace X
a b : X
γ : Path a b
x : ↑I
⊢ ↑(truncate γ 0 1) x = ↑(cast γ (_ : extend γ (min 0 1) = a) (_ : extend γ 1 = b)) x

tactic: have : ↑x ∈ (Icc 0 1 : Set ℝ) := x.2
state_before: case a.h
X✝ : Type ?u.481302
Y : Type ?u.481305
inst✝² : TopologicalSpace X✝
inst✝¹ : TopologicalSpace Y
x✝ y z : X✝
ι : Type ?u.481320
γ✝ : Path x✝ y
X : Type u_1
inst✝ : TopologicalSpace X
a b : X
γ : Path a b
x : ↑I
⊢ ↑(truncate γ 0 1) x = ↑γ x

tactic: rw [truncate, coe_mk_mk, max_eq_left this.1, min_eq_left this.2, extend_extends']
state_before: case a.h
X✝ : Type ?u.481302
Y : Type ?u.481305
inst✝² : TopologicalSpace X✝
inst✝¹ : TopologicalSpace Y
x✝ y z : X✝
ι : Type ?u.481320
γ✝ : Path x✝ y
X : Type u_1
inst✝ : TopologicalSpace X
a b : X
γ : Path a b
x : ↑I
this : ↑x ∈ Icc 0 1
⊢ ↑(truncate γ 0 1) x = ↑γ x
Theorem: StarConvex.add_right
File: Mathlib/Analysis/Convex/Star.lean

tactic: intro y hy a b ha hb hab
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type ?u.60600
inst✝⁴ : OrderedSemiring 𝕜
inst✝³ : AddCommMonoid E
inst✝² : AddCommMonoid F
inst✝¹ : Module 𝕜 E
inst✝ : Module 𝕜 F
x y z✝ : E
s : Set E
hs : StarConvex 𝕜 x s
z : E
⊢ StarConvex 𝕜 (x + z) ((fun x => x + z) '' s)

tactic: obtain ⟨y', hy', rfl⟩ := hy
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type ?u.60600
inst✝⁴ : OrderedSemiring 𝕜
inst✝³ : AddCommMonoid E
inst✝² : AddCommMonoid F
inst✝¹ : Module 𝕜 E
inst✝ : Module 𝕜 F
x y✝ z✝ : E
s : Set E
hs : StarConvex 𝕜 x s
z y : E
hy : y ∈ (fun x => x + z) '' s
a b : 𝕜
ha : 0 ≤ a
hb : 0 ≤ b
hab : a + b = 1
⊢ a • (x + z) + b • y ∈ (fun x => x + z) '' s

tactic: refine' ⟨a • x + b • y', hs hy' ha hb hab, _⟩
state_before: case intro.intro
𝕜 : Type u_1
E : Type u_2
F : Type ?u.60600
inst✝⁴ : OrderedSemiring 𝕜
inst✝³ : AddCommMonoid E
inst✝² : AddCommMonoid F
inst✝¹ : Module 𝕜 E
inst✝ : Module 𝕜 F
x y z✝ : E
s : Set E
hs : StarConvex 𝕜 x s
z : E
a b : 𝕜
ha : 0 ≤ a
hb : 0 ≤ b
hab : a + b = 1
y' : E
hy' : y' ∈ s
⊢ a • (x + z) + b • (fun x => x + z) y' ∈ (fun x => x + z) '' s

tactic: rw [smul_add, smul_add, add_add_add_comm, ← add_smul, hab, one_smul]
state_before: case intro.intro
𝕜 : Type u_1
E : Type u_2
F : Type ?u.60600
inst✝⁴ : OrderedSemiring 𝕜
inst✝³ : AddCommMonoid E
inst✝² : AddCommMonoid F
inst✝¹ : Module 𝕜 E
inst✝ : Module 𝕜 F
x y z✝ : E
s : Set E
hs : StarConvex 𝕜 x s
z : E
a b : 𝕜
ha : 0 ≤ a
hb : 0 ≤ b
hab : a + b = 1
y' : E
hy' : y' ∈ s
⊢ (fun x => x + z) (a • x + b • y') = a • (x + z) + b • (fun x => x + z) y'
Theorem: Nat.Partrec.Code.eval_prec_succ
File: Mathlib/Computability/PartrecCode.lean

tactic: rw [eval, Nat.unpaired, Part.bind_eq_bind, Nat.unpair_pair]
state_before: cf cg : Code
a k : ℕ
⊢ eval (prec cf cg) (Nat.pair a (Nat.succ k)) = do
    let ih ← eval (prec cf cg) (Nat.pair a k)
    eval cg (Nat.pair a (Nat.pair k ih))

tactic: simp
state_before: cf cg : Code
a k : ℕ
⊢ Nat.rec (eval cf (a, Nat.succ k).fst)
      (fun y IH => do
        let i ← IH
        eval cg (Nat.pair (a, Nat.succ k).fst (Nat.pair y i)))
      (a, Nat.succ k).snd =
    Part.bind
      (unpaired
        (fun a n =>
          Nat.rec (eval cf a)
            (fun y IH => do
              let i ← IH
              eval cg (Nat.pair a (Nat.pair y i)))
            n)
        (Nat.pair a k))
      fun ih => eval cg (Nat.pair a (Nat.pair k ih))
Theorem: CategoryTheory.eqToIso_map
File: Mathlib/CategoryTheory/EqToHom.lean

tactic: ext
state_before: C : Type u₁
inst✝¹ : Category C
D : Type u₂
inst✝ : Category D
F : C ⥤ D
X Y : C
p : X = Y
⊢ F.mapIso (eqToIso p) = eqToIso (_ : F.obj X = F.obj Y)

tactic: cases p
state_before: case w
C : Type u₁
inst✝¹ : Category C
D : Type u₂
inst✝ : Category D
F : C ⥤ D
X Y : C
p : X = Y
⊢ (F.mapIso (eqToIso p)).hom = (eqToIso (_ : F.obj X = F.obj Y)).hom

tactic: simp
state_before: case w.refl
C : Type u₁
inst✝¹ : Category C
D : Type u₂
inst✝ : Category D
F : C ⥤ D
X : C
⊢ (F.mapIso (eqToIso (_ : X = X))).hom = (eqToIso (_ : F.obj X = F.obj X)).hom
Theorem: Rat.mk_num_ne_zero_of_ne_zero
File: Mathlib/Data/Rat/Defs.lean

tactic: simpa [this] using hqnd
state_before: a b c q : ℚ
n d : ℤ
hq : q ≠ 0
hqnd : q = n /. d
this : n = 0
⊢ q = 0
Theorem: Filter.comap_comm
File: Mathlib/Order/Filter/Basic.lean

tactic: rw [Filter.comap_comap, H, ← Filter.comap_comap]
state_before: α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
f f₁ f₂ : Filter α
g g₁ g₂ : Filter β
m : α → β
m' : β → γ
s : Set α
t : Set β
φ : α → β
θ : α → γ
ψ : β → δ
ρ : γ → δ
H : ψ ∘ φ = ρ ∘ θ
G : Filter δ
⊢ comap φ (comap ψ G) = comap θ (comap ρ G)
Theorem: Set.biUnion_of_singleton
File: Mathlib/Data/Set/Lattice.lean

tactic: simp
state_before: α : Type u_1
β : Type ?u.108307
γ : Type ?u.108310
ι : Sort ?u.108313
ι' : Sort ?u.108316
ι₂ : Sort ?u.108319
κ : ι → Sort ?u.108324
κ₁ : ι → Sort ?u.108329
κ₂ : ι → Sort ?u.108334
κ' : ι' → Sort ?u.108339
s : Set α
⊢ ∀ (x : α), (x ∈ ⋃ (x : α) (_ : x ∈ s), {x}) ↔ x ∈ s
Theorem: measurableSet_of_differentiableAt
File: Mathlib/Analysis/Calculus/FDerivMeasurable.lean

tactic: have : IsComplete (univ : Set (E →L[𝕜] F)) := complete_univ
state_before: 𝕜 : Type u_2
inst✝⁷ : NontriviallyNormedField 𝕜
E : Type u_1
inst✝⁶ : NormedAddCommGroup E
inst✝⁵ : NormedSpace 𝕜 E
F : Type u_3
inst✝⁴ : NormedAddCommGroup F
inst✝³ : NormedSpace 𝕜 F
f : E → F
K : Set (E →L[𝕜] F)
inst✝² : MeasurableSpace E
inst✝¹ : OpensMeasurableSpace E
inst✝ : CompleteSpace F
⊢ MeasurableSet {x | DifferentiableAt 𝕜 f x}

tactic: convert measurableSet_of_differentiableAt_of_isComplete 𝕜 f this
state_before: 𝕜 : Type u_2
inst✝⁷ : NontriviallyNormedField 𝕜
E : Type u_1
inst✝⁶ : NormedAddCommGroup E
inst✝⁵ : NormedSpace 𝕜 E
F : Type u_3
inst✝⁴ : NormedAddCommGroup F
inst✝³ : NormedSpace 𝕜 F
f : E → F
K : Set (E →L[𝕜] F)
inst✝² : MeasurableSpace E
inst✝¹ : OpensMeasurableSpace E
inst✝ : CompleteSpace F
this : IsComplete univ
⊢ MeasurableSet {x | DifferentiableAt 𝕜 f x}

tactic: simp
state_before: case h.e'_3.h.e'_2.h.a
𝕜 : Type u_2
inst✝⁷ : NontriviallyNormedField 𝕜
E : Type u_1
inst✝⁶ : NormedAddCommGroup E
inst✝⁵ : NormedSpace 𝕜 E
F : Type u_3
inst✝⁴ : NormedAddCommGroup F
inst✝³ : NormedSpace 𝕜 F
f : E → F
K : Set (E →L[𝕜] F)
inst✝² : MeasurableSpace E
inst✝¹ : OpensMeasurableSpace E
inst✝ : CompleteSpace F
this : IsComplete univ
x✝ : E
⊢ DifferentiableAt 𝕜 f x✝ ↔ DifferentiableAt 𝕜 f x✝ ∧ fderiv 𝕜 f x✝ ∈ univ
Theorem: Matrix.stdBasisMatrix_add
File: Mathlib/Data/Matrix/Basis.lean

tactic: unfold stdBasisMatrix
state_before: l : Type ?u.4445
m : Type u_1
n : Type u_2
R : Type ?u.4454
α : Type u_3
inst✝³ : DecidableEq l
inst✝² : DecidableEq m
inst✝¹ : DecidableEq n
inst✝ : Semiring α
i : m
j : n
a b : α
⊢ stdBasisMatrix i j (a + b) = stdBasisMatrix i j a + stdBasisMatrix i j b

tactic: ext
state_before: l : Type ?u.4445
m : Type u_1
n : Type u_2
R : Type ?u.4454
α : Type u_3
inst✝³ : DecidableEq l
inst✝² : DecidableEq m
inst✝¹ : DecidableEq n
inst✝ : Semiring α
i : m
j : n
a b : α
⊢ (fun i' j' => if i = i' ∧ j = j' then a + b else 0) =
    (fun i' j' => if i = i' ∧ j = j' then a else 0) + fun i' j' => if i = i' ∧ j = j' then b else 0

tactic: split_ifs with h <;> simp [h]
state_before: case a.h
l : Type ?u.4445
m : Type u_1
n : Type u_2
R : Type ?u.4454
α : Type u_3
inst✝³ : DecidableEq l
inst✝² : DecidableEq m
inst✝¹ : DecidableEq n
inst✝ : Semiring α
i : m
j : n
a b : α
i✝ : m
x✝ : n
⊢ (if i = i✝ ∧ j = x✝ then a + b else 0) =
    ((fun i' j' => if i = i' ∧ j = j' then a else 0) + fun i' j' => if i = i' ∧ j = j' then b else 0) i✝ x✝
Theorem: Order.succ_le_succ
File: Mathlib/Order/SuccPred/Basic.lean

tactic: by_cases hb : IsMax b
state_before: α : Type u_1
inst✝¹ : Preorder α
inst✝ : SuccOrder α
a b : α
h : a ≤ b
⊢ succ a ≤ succ b

tactic: by_cases hba : b ≤ a
state_before: case pos
α : Type u_1
inst✝¹ : Preorder α
inst✝ : SuccOrder α
a b : α
h : a ≤ b
hb : IsMax b
⊢ succ a ≤ succ b

tactic: exact (hb <| hba.trans <| le_succ _).trans (le_succ _)
state_before: case pos
α : Type u_1
inst✝¹ : Preorder α
inst✝ : SuccOrder α
a b : α
h : a ≤ b
hb : IsMax b
hba : b ≤ a
⊢ succ a ≤ succ b

tactic: exact succ_le_of_lt ((h.lt_of_not_le hba).trans_le <| le_succ b)
state_before: case neg
α : Type u_1
inst✝¹ : Preorder α
inst✝ : SuccOrder α
a b : α
h : a ≤ b
hb : IsMax b
hba : ¬b ≤ a
⊢ succ a ≤ succ b

tactic: rwa [succ_le_iff_of_not_isMax fun ha => hb <| ha.mono h, lt_succ_iff_of_not_isMax hb]
state_before: case neg
α : Type u_1
inst✝¹ : Preorder α
inst✝ : SuccOrder α
a b : α
h : a ≤ b
hb : ¬IsMax b
⊢ succ a ≤ succ b
Theorem: TopCat.Presheaf.Pushforward.comp_hom_app
File: Mathlib/Topology/Sheaves/Presheaf.lean

tactic: simp [comp]
state_before: C : Type u
inst✝ : Category C
X : TopCat
ℱ : Presheaf C X
Y Z : TopCat
f : X ⟶ Y
g : Y ⟶ Z
U : (Opens ↑Z)ᵒᵖ
⊢ (comp ℱ f g).hom.app U = 𝟙 (((f ≫ g) _* ℱ).obj U)
Theorem: MeasureTheory.norm_set_integral_le_of_norm_le_const_ae''
File: Mathlib/MeasureTheory/Integral/SetIntegral.lean

tactic: rwa [ae_restrict_eq hsm, eventually_inf_principal]
state_before: α : Type u_1
β : Type ?u.257361
E : Type u_2
F : Type ?u.257367
inst✝³ : MeasurableSpace α
inst✝² : NormedAddCommGroup E
f g : α → E
s t : Set α
μ ν : Measure α
l l' : Filter α
inst✝¹ : CompleteSpace E
inst✝ : NormedSpace ℝ E
C : ℝ
hs : ↑↑μ s < ⊤
hsm : MeasurableSet s
hC : ∀ᵐ (x : α) ∂μ, x ∈ s → ‖f x‖ ≤ C
⊢ ∀ᵐ (x : α) ∂Measure.restrict μ s, ‖f x‖ ≤ C
Theorem: Finset.image_add_right_Ioo
File: Mathlib/Data/Finset/LocallyFinite.lean

tactic: rw [← map_add_right_Ioo, map_eq_image]
state_before: ι : Type ?u.253633
α : Type u_1
inst✝³ : OrderedCancelAddCommMonoid α
inst✝² : ExistsAddOfLE α
inst✝¹ : LocallyFiniteOrder α
inst✝ : DecidableEq α
a b c : α
⊢ image (fun x => x + c) (Ioo a b) = Ioo (a + c) (b + c)

tactic: rfl
state_before: ι : Type ?u.253633
α : Type u_1
inst✝³ : OrderedCancelAddCommMonoid α
inst✝² : ExistsAddOfLE α
inst✝¹ : LocallyFiniteOrder α
inst✝ : DecidableEq α
a b c : α
⊢ image (fun x => x + c) (Ioo a b) = image (↑(addRightEmbedding c)) (Ioo a b)
Theorem: BilinForm.neg_right
File: Mathlib/LinearAlgebra/BilinearForm.lean

tactic: rw [← @neg_one_smul R₁ _ _, smul_right, neg_one_mul]
state_before: R : Type ?u.52348
M : Type ?u.52351
inst✝¹⁴ : Semiring R
inst✝¹³ : AddCommMonoid M
inst✝¹² : Module R M
R₁ : Type u_1
M₁ : Type u_2
inst✝¹¹ : Ring R₁
inst✝¹⁰ : AddCommGroup M₁
inst✝⁹ : Module R₁ M₁
R₂ : Type ?u.52999
M₂ : Type ?u.53002
inst✝⁸ : CommSemiring R₂
inst✝⁷ : AddCommMonoid M₂
inst✝⁶ : Module R₂ M₂
R₃ : Type ?u.53189
M₃ : Type ?u.53192
inst✝⁵ : CommRing R₃
inst✝⁴ : AddCommGroup M₃
inst✝³ : Module R₃ M₃
V : Type ?u.53780
K : Type ?u.53783
inst✝² : Field K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
B : BilinForm R M
B₁ : BilinForm R₁ M₁
B₂ : BilinForm R₂ M₂
x y : M₁
⊢ bilin B₁ x (-y) = -bilin B₁ x y
Theorem: CategoryTheory.reflectsIsomorphisms_forget₂
File: Mathlib/CategoryTheory/ConcreteCategory/ReflectsIso.lean

tactic: skip
state_before: C : Type (u + 1)
inst✝⁵ : Category C
inst✝⁴ : ConcreteCategory C
D : Type (u + 1)
inst✝³ : Category D
inst✝² : ConcreteCategory D
inst✝¹ : HasForget₂ C D
inst✝ : ReflectsIsomorphisms (forget C)
X Y : C
f : X ⟶ Y
i : IsIso ((forget₂ C D).map f)
⊢ IsIso f

tactic: haveI i' : IsIso ((forget D).map ((forget₂ C D).map f)) := Functor.map_isIso (forget D) _
state_before: C : Type (u + 1)
inst✝⁵ : Category C
inst✝⁴ : ConcreteCategory C
D : Type (u + 1)
inst✝³ : Category D
inst✝² : ConcreteCategory D
inst✝¹ : HasForget₂ C D
inst✝ : ReflectsIsomorphisms (forget C)
X Y : C
f : X ⟶ Y
i : IsIso ((forget₂ C D).map f)
⊢ IsIso f

tactic: haveI : IsIso ((forget C).map f) := by
  have := @HasForget₂.forget_comp C D
  rw [← this]
  exact i'
state_before: C : Type (u + 1)
inst✝⁵ : Category C
inst✝⁴ : ConcreteCategory C
D : Type (u + 1)
inst✝³ : Category D
inst✝² : ConcreteCategory D
inst✝¹ : HasForget₂ C D
inst✝ : ReflectsIsomorphisms (forget C)
X Y : C
f : X ⟶ Y
i : IsIso ((forget₂ C D).map f)
i' : IsIso ((forget D).map ((forget₂ C D).map f))
⊢ IsIso f

tactic: apply isIso_of_reflects_iso f (forget C)
state_before: C : Type (u + 1)
inst✝⁵ : Category C
inst✝⁴ : ConcreteCategory C
D : Type (u + 1)
inst✝³ : Category D
inst✝² : ConcreteCategory D
inst✝¹ : HasForget₂ C D
inst✝ : ReflectsIsomorphisms (forget C)
X Y : C
f : X ⟶ Y
i : IsIso ((forget₂ C D).map f)
i' : IsIso ((forget D).map ((forget₂ C D).map f))
this : IsIso ((forget C).map f)
⊢ IsIso f

tactic: have := @HasForget₂.forget_comp C D
state_before: C : Type (u + 1)
inst✝⁵ : Category C
inst✝⁴ : ConcreteCategory C
D : Type (u + 1)
inst✝³ : Category D
inst✝² : ConcreteCategory D
inst✝¹ : HasForget₂ C D
inst✝ : ReflectsIsomorphisms (forget C)
X Y : C
f : X ⟶ Y
i : IsIso ((forget₂ C D).map f)
i' : IsIso ((forget D).map ((forget₂ C D).map f))
⊢ IsIso ((forget C).map f)

tactic: rw [← this]
state_before: C : Type (u + 1)
inst✝⁵ : Category C
inst✝⁴ : ConcreteCategory C
D : Type (u + 1)
inst✝³ : Category D
inst✝² : ConcreteCategory D
inst✝¹ : HasForget₂ C D
inst✝ : ReflectsIsomorphisms (forget C)
X Y : C
f : X ⟶ Y
i : IsIso ((forget₂ C D).map f)
i' : IsIso ((forget D).map ((forget₂ C D).map f))
this :
  ∀ [inst : Category C] [inst_1 : ConcreteCategory C] [inst_2 : Category D] [inst_3 : ConcreteCategory D]
    [self : HasForget₂ C D], HasForget₂.forget₂ ⋙ forget D = forget C
⊢ IsIso ((forget C).map f)

tactic: exact i'
state_before: C : Type (u + 1)
inst✝⁵ : Category C
inst✝⁴ : ConcreteCategory C
D : Type (u + 1)
inst✝³ : Category D
inst✝² : ConcreteCategory D
inst✝¹ : HasForget₂ C D
inst✝ : ReflectsIsomorphisms (forget C)
X Y : C
f : X ⟶ Y
i : IsIso ((forget₂ C D).map f)
i' : IsIso ((forget D).map ((forget₂ C D).map f))
this :
  ∀ [inst : Category C] [inst_1 : ConcreteCategory C] [inst_2 : Category D] [inst_3 : ConcreteCategory D]
    [self : HasForget₂ C D], HasForget₂.forget₂ ⋙ forget D = forget C
⊢ IsIso ((HasForget₂.forget₂ ⋙ forget D).map f)
Theorem: Bool.eq_true_of_not_eq_false'
File: Mathlib/Data/Bool/Basic.lean

tactic: cases a <;> decide
state_before: a : Bool
⊢ (!decide (a = false)) = true → a = true
Theorem: ack_pos
File: Mathlib/Computability/Ackermann.lean

tactic: simp
state_before: n : ℕ
⊢ 0 < ack 0 n

tactic: rw [ack_succ_zero]
state_before: m : ℕ
⊢ 0 < ack (m + 1) 0

tactic: apply ack_pos
state_before: m : ℕ
⊢ 0 < ack m 1

tactic: rw [ack_succ_succ]
state_before: m n : ℕ
⊢ 0 < ack (m + 1) (n + 1)

tactic: apply ack_pos
state_before: m n : ℕ
⊢ 0 < ack m (ack (m + 1) n)
Theorem: Seminorm.absorbent_closedBall
File: Mathlib/Analysis/Seminorm.lean

tactic: refine' (p.absorbent_closedBall_zero <| sub_pos.2 hpr).subset fun y hy => _
state_before: R : Type ?u.1248543
R' : Type ?u.1248546
𝕜 : Type u_2
𝕜₂ : Type ?u.1248552
𝕜₃ : Type ?u.1248555
𝕝 : Type ?u.1248558
E : Type u_1
E₂ : Type ?u.1248564
E₃ : Type ?u.1248567
F : Type ?u.1248570
G : Type ?u.1248573
ι : Type ?u.1248576
inst✝² : NormedField 𝕜
inst✝¹ : AddCommGroup E
inst✝ : Module 𝕜 E
p : Seminorm 𝕜 E
A B : Set E
a : 𝕜
r : ℝ
x : E
hpr : ↑p x < r
⊢ Absorbent 𝕜 (closedBall p x r)

tactic: rw [p.mem_closedBall_zero] at hy
state_before: R : Type ?u.1248543
R' : Type ?u.1248546
𝕜 : Type u_2
𝕜₂ : Type ?u.1248552
𝕜₃ : Type ?u.1248555
𝕝 : Type ?u.1248558
E : Type u_1
E₂ : Type ?u.1248564
E₃ : Type ?u.1248567
F : Type ?u.1248570
G : Type ?u.1248573
ι : Type ?u.1248576
inst✝² : NormedField 𝕜
inst✝¹ : AddCommGroup E
inst✝ : Module 𝕜 E
p : Seminorm 𝕜 E
A B : Set E
a : 𝕜
r : ℝ
x : E
hpr : ↑p x < r
y : E
hy : y ∈ closedBall p 0 (r - ↑p x)
⊢ y ∈ closedBall p x r

tactic: exact p.mem_closedBall.2 ((map_sub_le_add p _ _).trans <| add_le_of_le_sub_right hy)
state_before: R : Type ?u.1248543
R' : Type ?u.1248546
𝕜 : Type u_2
𝕜₂ : Type ?u.1248552
𝕜₃ : Type ?u.1248555
𝕝 : Type ?u.1248558
E : Type u_1
E₂ : Type ?u.1248564
E₃ : Type ?u.1248567
F : Type ?u.1248570
G : Type ?u.1248573
ι : Type ?u.1248576
inst✝² : NormedField 𝕜
inst✝¹ : AddCommGroup E
inst✝ : Module 𝕜 E
p : Seminorm 𝕜 E
A B : Set E
a : 𝕜
r : ℝ
x : E
hpr : ↑p x < r
y : E
hy : ↑p y ≤ r - ↑p x
⊢ y ∈ closedBall p x r
Theorem: sameRay_of_mem_segment
File: Mathlib/Analysis/Convex/Segment.lean

tactic: rw [segment_eq_image'] at h
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type ?u.153306
G : Type ?u.153309
ι : Type ?u.153312
π : ι → Type ?u.153317
inst✝² : StrictOrderedCommRing 𝕜
inst✝¹ : AddCommGroup E
inst✝ : Module 𝕜 E
x y z : E
h : x ∈ [y-[𝕜]z]
⊢ SameRay 𝕜 (x - y) (z - x)

tactic: rcases h with ⟨θ, ⟨hθ₀, hθ₁⟩, rfl⟩
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type ?u.153306
G : Type ?u.153309
ι : Type ?u.153312
π : ι → Type ?u.153317
inst✝² : StrictOrderedCommRing 𝕜
inst✝¹ : AddCommGroup E
inst✝ : Module 𝕜 E
x y z : E
h : x ∈ (fun θ => y + θ • (z - y)) '' Icc 0 1
⊢ SameRay 𝕜 (x - y) (z - x)

tactic: simpa only [add_sub_cancel', ← sub_sub, sub_smul, one_smul] using
  (SameRay.sameRay_nonneg_smul_left (z - y) hθ₀).nonneg_smul_right (sub_nonneg.2 hθ₁)
state_before: case intro.intro.intro
𝕜 : Type u_1
E : Type u_2
F : Type ?u.153306
G : Type ?u.153309
ι : Type ?u.153312
π : ι → Type ?u.153317
inst✝² : StrictOrderedCommRing 𝕜
inst✝¹ : AddCommGroup E
inst✝ : Module 𝕜 E
y z : E
θ : 𝕜
hθ₀ : 0 ≤ θ
hθ₁ : θ ≤ 1
⊢ SameRay 𝕜 ((fun θ => y + θ • (z - y)) θ - y) (z - (fun θ => y + θ • (z - y)) θ)
Theorem: MeasureTheory.integrableOn_empty
File: Mathlib/MeasureTheory/Integral/IntegrableOn.lean

tactic: simp [IntegrableOn, integrable_zero_measure]
state_before: α : Type u_1
β : Type ?u.1494157
E : Type u_2
F : Type ?u.1494163
inst✝¹ : MeasurableSpace α
inst✝ : NormedAddCommGroup E
f g : α → E
s t : Set α
μ ν : Measure α
⊢ IntegrableOn f ∅