tasksource/leandojo huggingface dataset:
Theorem: Filter.pi_inj
File: Mathlib/Order/Filter/Pi.lean

tactic: refine' ⟨fun h => _, congr_arg pi⟩
state_before: ι : Type u_2
α : ι → Type u_1
f f₁ f₂ : (i : ι) → Filter (α i)
s : (i : ι) → Set (α i)
inst✝ : ∀ (i : ι), NeBot (f₁ i)
⊢ pi f₁ = pi f₂ ↔ f₁ = f₂

tactic: have hle : f₁ ≤ f₂ := pi_le_pi.1 h.le
state_before: ι : Type u_2
α : ι → Type u_1
f f₁ f₂ : (i : ι) → Filter (α i)
s : (i : ι) → Set (α i)
inst✝ : ∀ (i : ι), NeBot (f₁ i)
h : pi f₁ = pi f₂
⊢ f₁ = f₂

tactic: haveI : ∀ i, NeBot (f₂ i) := fun i => neBot_of_le (hle i)
state_before: ι : Type u_2
α : ι → Type u_1
f f₁ f₂ : (i : ι) → Filter (α i)
s : (i : ι) → Set (α i)
inst✝ : ∀ (i : ι), NeBot (f₁ i)
h : pi f₁ = pi f₂
hle : f₁ ≤ f₂
⊢ f₁ = f₂

tactic: exact hle.antisymm (pi_le_pi.1 h.ge)
state_before: ι : Type u_2
α : ι → Type u_1
f f₁ f₂ : (i : ι) → Filter (α i)
s : (i : ι) → Set (α i)
inst✝ : ∀ (i : ι), NeBot (f₁ i)
h : pi f₁ = pi f₂
hle : f₁ ≤ f₂
this : ∀ (i : ι), NeBot (f₂ i)
⊢ f₁ = f₂
Theorem: List.map_permutationsAux2
File: Mathlib/Data/List/Permutation.lean

tactic: rw [map_permutationsAux2' id, map_id, map_id]
state_before: α : Type u_1
β : Type u_2
t : α
ts ys : List α
f : List α → β
⊢ map f (permutationsAux2 t ts [] ys id).snd = (permutationsAux2 t ts [] ys f).snd

tactic: rfl
state_before: α : Type u_1
β : Type u_2
t : α
ts ys : List α
f : List α → β
⊢ (permutationsAux2 (id t) ts (map f []) ys ?f').snd = (permutationsAux2 t ts [] ys f).snd

case f'
α : Type u_1
β : Type u_2
t : α
ts ys : List α
f : List α → β
⊢ List α → β

case f'
α : Type u_1
β : Type u_2
t : α
ts ys : List α
f : List α → β
⊢ List α → β

case f'
α : Type u_1
β : Type u_2
t : α
ts ys : List α
f : List α → β
⊢ List α → β

case H
α : Type u_1
β : Type u_2
t : α
ts ys : List α
f : List α → β
⊢ ∀ (a : List α), f (id a) = ?f' (map id a)

tactic: simp
state_before: case H
α : Type u_1
β : Type u_2
t : α
ts ys : List α
f : List α → β
⊢ ∀ (a : List α), f (id a) = f (map id a)
Theorem: mul_inv_cancel_right
File: Mathlib/Algebra/Group/Defs.lean

tactic: rw [mul_assoc, mul_right_inv, mul_one]
state_before: G : Type u_1
inst✝ : Group G
a✝ b✝ c a b : G
⊢ a * b * b⁻¹ = a
Theorem: ENNReal.pow_ne_zero
File: Mathlib/Data/Real/ENNReal.lean

tactic: simpa only [pos_iff_ne_zero] using ENNReal.pow_pos
state_before: α : Type ?u.108457
β : Type ?u.108460
a b c d : ℝ≥0∞
r p q : ℝ≥0
⊢ a ≠ 0 → ∀ (n : ℕ), a ^ n ≠ 0
Theorem: Nat.le_of_mem_factors
File: Mathlib/Data/Nat/Factors.lean

tactic: rcases n.eq_zero_or_pos with (rfl | hn)
state_before: n p : ℕ
h : p ∈ factors n
⊢ p ≤ n

tactic: rw [factors_zero] at h
state_before: case inl
p : ℕ
h : p ∈ factors 0
⊢ p ≤ 0

tactic: cases h
state_before: case inl
p : ℕ
h : p ∈ []
⊢ p ≤ 0

tactic: exact le_of_dvd hn (dvd_of_mem_factors h)
state_before: case inr
n p : ℕ
h : p ∈ factors n
hn : n > 0
⊢ p ≤ n
Theorem: Seminorm.bddAbove_iff
File: Mathlib/Analysis/Seminorm.lean

tactic: dsimp
state_before: R : Type ?u.762821
R' : Type ?u.762824
𝕜 : Type u_2
𝕜₂ : Type ?u.762830
𝕜₃ : Type ?u.762833
𝕝 : Type ?u.762836
E : Type u_1
E₂ : Type ?u.762842
E₃ : Type ?u.762845
F : Type ?u.762848
G : Type ?u.762851
ι : Type ?u.762854
inst✝² : NormedField 𝕜
inst✝¹ : AddCommGroup E
inst✝ : Module 𝕜 E
p✝ q : Seminorm 𝕜 E
x✝ : E
s : Set (Seminorm 𝕜 E)
H : BddAbove (FunLike.coe '' s)
p : Seminorm 𝕜 E
hp : p ∈ s
x : E
⊢ (fun f => ↑f) p x ≤ (fun f => ↑f) (sSup s) x

tactic: rw [Seminorm.coe_sSup_eq' H, iSup_apply]
state_before: R : Type ?u.762821
R' : Type ?u.762824
𝕜 : Type u_2
𝕜₂ : Type ?u.762830
𝕜₃ : Type ?u.762833
𝕝 : Type ?u.762836
E : Type u_1
E₂ : Type ?u.762842
E₃ : Type ?u.762845
F : Type ?u.762848
G : Type ?u.762851
ι : Type ?u.762854
inst✝² : NormedField 𝕜
inst✝¹ : AddCommGroup E
inst✝ : Module 𝕜 E
p✝ q : Seminorm 𝕜 E
x✝ : E
s : Set (Seminorm 𝕜 E)
H : BddAbove (FunLike.coe '' s)
p : Seminorm 𝕜 E
hp : p ∈ s
x : E
⊢ ↑p x ≤ ↑(sSup s) x

tactic: rcases H with ⟨q, hq⟩
state_before: R : Type ?u.762821
R' : Type ?u.762824
𝕜 : Type u_2
𝕜₂ : Type ?u.762830
𝕜₃ : Type ?u.762833
𝕝 : Type ?u.762836
E : Type u_1
E₂ : Type ?u.762842
E₃ : Type ?u.762845
F : Type ?u.762848
G : Type ?u.762851
ι : Type ?u.762854
inst✝² : NormedField 𝕜
inst✝¹ : AddCommGroup E
inst✝ : Module 𝕜 E
p✝ q : Seminorm 𝕜 E
x✝ : E
s : Set (Seminorm 𝕜 E)
H : BddAbove (FunLike.coe '' s)
p : Seminorm 𝕜 E
hp : p ∈ s
x : E
⊢ ↑p x ≤ ⨆ (i : ↑s), ↑↑i x

tactic: exact
  le_ciSup ⟨q x, forall_range_iff.mpr fun i : s => hq (mem_image_of_mem _ i.2) x⟩ ⟨p, hp⟩
state_before: case intro
R : Type ?u.762821
R' : Type ?u.762824
𝕜 : Type u_2
𝕜₂ : Type ?u.762830
𝕜₃ : Type ?u.762833
𝕝 : Type ?u.762836
E : Type u_1
E₂ : Type ?u.762842
E₃ : Type ?u.762845
F : Type ?u.762848
G : Type ?u.762851
ι : Type ?u.762854
inst✝² : NormedField 𝕜
inst✝¹ : AddCommGroup E
inst✝ : Module 𝕜 E
p✝ q✝ : Seminorm 𝕜 E
x✝ : E
s : Set (Seminorm 𝕜 E)
p : Seminorm 𝕜 E
hp : p ∈ s
x : E
q : E → ℝ
hq : q ∈ upperBounds (FunLike.coe '' s)
⊢ ↑p x ≤ ⨆ (i : ↑s), ↑↑i x
Theorem: LinearMap.finrank_range_add_finrank_ker
File: Mathlib/LinearAlgebra/FiniteDimensional.lean

tactic: rw [← f.quotKerEquivRange.finrank_eq]
state_before: K : Type u
V : Type v
inst✝⁵ : DivisionRing K
inst✝⁴ : AddCommGroup V
inst✝³ : Module K V
V₂ : Type v'
inst✝² : AddCommGroup V₂
inst✝¹ : Module K V₂
inst✝ : FiniteDimensional K V
f : V →ₗ[K] V₂
⊢ finrank K { x // x ∈ range f } + finrank K { x // x ∈ ker f } = finrank K V

tactic: exact Submodule.finrank_quotient_add_finrank _
state_before: K : Type u
V : Type v
inst✝⁵ : DivisionRing K
inst✝⁴ : AddCommGroup V
inst✝³ : Module K V
V₂ : Type v'
inst✝² : AddCommGroup V₂
inst✝¹ : Module K V₂
inst✝ : FiniteDimensional K V
f : V →ₗ[K] V₂
⊢ finrank K (V ⧸ ker f) + finrank K { x // x ∈ ker f } = finrank K V
Theorem: CategoryTheory.Sieve.functorPullback_id
File: Mathlib/CategoryTheory/Sites/Sieves.lean

tactic: ext
state_before: C : Type u₁
inst✝² : Category C
D : Type u₂
inst✝¹ : Category D
F : C ⥤ D
X Y Z : C
f : Y ⟶ X
S R✝ : Sieve X
E : Type u₃
inst✝ : Category E
G : D ⥤ E
R : Sieve X
⊢ functorPullback (𝟭 C) R = R

tactic: rfl
state_before: case h
C : Type u₁
inst✝² : Category C
D : Type u₂
inst✝¹ : Category D
F : C ⥤ D
X Y Z : C
f : Y ⟶ X
S R✝ : Sieve X
E : Type u₃
inst✝ : Category E
G : D ⥤ E
R : Sieve X
Y✝ : C
f✝ : Y✝ ⟶ X
⊢ (functorPullback (𝟭 C) R).arrows f✝ ↔ R.arrows f✝
Theorem: CategoryTheory.StrongEpi.of_arrow_iso
File: Mathlib/CategoryTheory/Limits/Shapes/StrongEpi.lean

tactic: rw [Arrow.iso_w' e]
state_before: C : Type u
inst✝ : Category C
P Q R : C
f✝ : P ⟶ Q
g✝ : Q ⟶ R
A B A' B' : C
f : A ⟶ B
g : A' ⟶ B'
e : Arrow.mk f ≅ Arrow.mk g
h : StrongEpi f
⊢ Epi g

tactic: haveI := epi_comp f e.hom.right
state_before: C : Type u
inst✝ : Category C
P Q R : C
f✝ : P ⟶ Q
g✝ : Q ⟶ R
A B A' B' : C
f : A ⟶ B
g : A' ⟶ B'
e : Arrow.mk f ≅ Arrow.mk g
h : StrongEpi f
⊢ Epi (e.inv.left ≫ f ≫ e.hom.right)

tactic: apply epi_comp
state_before: C : Type u
inst✝ : Category C
P Q R : C
f✝ : P ⟶ Q
g✝ : Q ⟶ R
A B A' B' : C
f : A ⟶ B
g : A' ⟶ B'
e : Arrow.mk f ≅ Arrow.mk g
h : StrongEpi f
this : Epi (f ≫ e.hom.right)
⊢ Epi (e.inv.left ≫ f ≫ e.hom.right)

tactic: intro
state_before: C : Type u
inst✝ : Category C
P Q R : C
f✝ : P ⟶ Q
g✝ : Q ⟶ R
A B A' B' : C
f : A ⟶ B
g : A' ⟶ B'
e : Arrow.mk f ≅ Arrow.mk g
h : StrongEpi f
X Y : C
z : X ⟶ Y
⊢ ∀ [inst : Mono z], HasLiftingProperty g z

tactic: apply HasLiftingProperty.of_arrow_iso_left e z
state_before: C : Type u
inst✝¹ : Category C
P Q R : C
f✝ : P ⟶ Q
g✝ : Q ⟶ R
A B A' B' : C
f : A ⟶ B
g : A' ⟶ B'
e : Arrow.mk f ≅ Arrow.mk g
h : StrongEpi f
X Y : C
z : X ⟶ Y
inst✝ : Mono z
⊢ HasLiftingProperty g z
Theorem: EReal.coe_real_ereal_eq_coe_toNNReal_sub_coe_toNNReal
File: Mathlib/Data/Real/EReal.lean

tactic: rcases le_total 0 x with (h | h)
state_before: x : ℝ
⊢ ↑x = ↑↑(Real.toNNReal x) - ↑↑(Real.toNNReal (-x))

tactic: lift x to ℝ≥0 using h
state_before: case inl
x : ℝ
h : 0 ≤ x
⊢ ↑x = ↑↑(Real.toNNReal x) - ↑↑(Real.toNNReal (-x))

tactic: rw [Real.toNNReal_of_nonpos (neg_nonpos.mpr x.coe_nonneg), Real.toNNReal_coe, ENNReal.coe_zero,
  coe_ennreal_zero, sub_zero]
state_before: case inl.intro
x : ℝ≥0
⊢ ↑↑x = ↑↑(Real.toNNReal ↑x) - ↑↑(Real.toNNReal (-↑x))

tactic: rfl
state_before: case inl.intro
x : ℝ≥0
⊢ ↑↑x = ↑↑x

tactic: rw [Real.toNNReal_of_nonpos h, ENNReal.coe_zero, coe_ennreal_zero, coe_nnreal_eq_coe_real,
  Real.coe_toNNReal, zero_sub, coe_neg, neg_neg]
state_before: case inr
x : ℝ
h : x ≤ 0
⊢ ↑x = ↑↑(Real.toNNReal x) - ↑↑(Real.toNNReal (-x))

tactic: exact neg_nonneg.2 h
state_before: case inr.hr
x : ℝ
h : x ≤ 0
⊢ 0 ≤ -x
Theorem: Polynomial.Monic.comp_X_sub_C
File: Mathlib/Data/Polynomial/RingDivision.lean

tactic: simpa using hp.comp_X_add_C (-r)
state_before: R : Type u
S : Type v
T : Type w
a b : R
n : ℕ
inst✝¹ : CommRing R
inst✝ : IsDomain R
p q : R[X]
hp : Monic p
r : R
⊢ Monic (Polynomial.comp p (X - ↑C r))
Theorem: Finset.attach_affineCombination_coe
File: Mathlib/LinearAlgebra/AffineSpace/Combination.lean

tactic: classical rw [attach_affineCombination_of_injective s w ((↑) : s → P) Subtype.coe_injective,
    univ_eq_attach, attach_image_val]
state_before: k : Type u_2
V : Type u_3
P : Type u_1
inst✝² : Ring k
inst✝¹ : AddCommGroup V
inst✝ : Module k V
S : AffineSpace V P
ι : Type ?u.279611
s✝ : Finset ι
ι₂ : Type ?u.279617
s₂ : Finset ι₂
s : Finset P
w : P → k
⊢ ↑(affineCombination k (attach s) Subtype.val) (w ∘ Subtype.val) = ↑(affineCombination k s id) w

tactic: rw [attach_affineCombination_of_injective s w ((↑) : s → P) Subtype.coe_injective,
univ_eq_attach, attach_image_val]
state_before: k : Type u_2
V : Type u_3
P : Type u_1
inst✝² : Ring k
inst✝¹ : AddCommGroup V
inst✝ : Module k V
S : AffineSpace V P
ι : Type ?u.279611
s✝ : Finset ι
ι₂ : Type ?u.279617
s₂ : Finset ι₂
s : Finset P
w : P → k
⊢ ↑(affineCombination k (attach s) Subtype.val) (w ∘ Subtype.val) = ↑(affineCombination k s id) w
Theorem: constantCoeff_wittStructureInt_zero
File: Mathlib/RingTheory/WittVector/StructurePolynomial.lean

tactic: have inj : Function.Injective (Int.castRingHom ℚ) := by intro m n; exact Int.cast_inj.mp
state_before: p : ℕ
R : Type ?u.1978909
idx : Type u_1
inst✝ : CommRing R
hp : Fact (Nat.Prime p)
Φ : MvPolynomial idx ℤ
⊢ ↑constantCoeff (wittStructureInt p Φ 0) = ↑constantCoeff Φ

tactic: apply inj
state_before: p : ℕ
R : Type ?u.1978909
idx : Type u_1
inst✝ : CommRing R
hp : Fact (Nat.Prime p)
Φ : MvPolynomial idx ℤ
inj : Function.Injective ↑(Int.castRingHom ℚ)
⊢ ↑constantCoeff (wittStructureInt p Φ 0) = ↑constantCoeff Φ

tactic: rw [← constantCoeff_map, map_wittStructureInt, constantCoeff_wittStructureRat_zero,
  constantCoeff_map]
state_before: case a
p : ℕ
R : Type ?u.1978909
idx : Type u_1
inst✝ : CommRing R
hp : Fact (Nat.Prime p)
Φ : MvPolynomial idx ℤ
inj : Function.Injective ↑(Int.castRingHom ℚ)
⊢ ↑(Int.castRingHom ℚ) (↑constantCoeff (wittStructureInt p Φ 0)) = ↑(Int.castRingHom ℚ) (↑constantCoeff Φ)

tactic: intro m n
state_before: p : ℕ
R : Type ?u.1978909
idx : Type u_1
inst✝ : CommRing R
hp : Fact (Nat.Prime p)
Φ : MvPolynomial idx ℤ
⊢ Function.Injective ↑(Int.castRingHom ℚ)

tactic: exact Int.cast_inj.mp
state_before: p : ℕ
R : Type ?u.1978909
idx : Type u_1
inst✝ : CommRing R
hp : Fact (Nat.Prime p)
Φ : MvPolynomial idx ℤ
m n : ℤ
⊢ ↑(Int.castRingHom ℚ) m = ↑(Int.castRingHom ℚ) n → m = n
Theorem: Polynomial.rootSet_zero
File: Mathlib/Data/Polynomial/RingDivision.lean

tactic: rw [← C_0, rootSet_C]
state_before: R : Type u
S✝ : Type v
T : Type w
a b : R
n : ℕ
inst✝⁵ : CommRing R
inst✝⁴ : IsDomain R
p q : R[X]
inst✝³ : CommRing T
S : Type u_1
inst✝² : CommRing S
inst✝¹ : IsDomain S
inst✝ : Algebra T S
⊢ rootSet 0 S = ∅
Theorem: sq_dvd_add_pow_sub_sub
File: Mathlib/NumberTheory/Multiplicity.lean

tactic: cases' n with n n
state_before: R : Type u_1
n✝ : ℕ
inst✝ : CommRing R
a b x✝ y p x : R
n : ℕ
⊢ p ^ 2 ∣ (x + p) ^ n - x ^ (n - 1) * p * ↑n - x ^ n

tactic: simp only [pow_zero, Nat.cast_zero, sub_zero, sub_self, dvd_zero, Nat.zero_eq, mul_zero]
state_before: case zero
R : Type u_1
n : ℕ
inst✝ : CommRing R
a b x✝ y p x : R
⊢ p ^ 2 ∣ (x + p) ^ Nat.zero - x ^ (Nat.zero - 1) * p * ↑Nat.zero - x ^ Nat.zero

tactic: simp only [Nat.succ_sub_succ_eq_sub, tsub_zero, Nat.cast_succ, add_pow, Finset.sum_range_succ,
  Nat.choose_self, Nat.succ_sub _, tsub_self, pow_one, Nat.choose_succ_self_right, pow_zero,
  mul_one, Nat.cast_zero, zero_add, Nat.succ_eq_add_one, add_tsub_cancel_left]
state_before: case succ
R : Type u_1
n✝ : ℕ
inst✝ : CommRing R
a b x✝ y p x : R
n : ℕ
⊢ p ^ 2 ∣ (x + p) ^ Nat.succ n - x ^ (Nat.succ n - 1) * p * ↑(Nat.succ n) - x ^ Nat.succ n

tactic: suffices p ^ 2 ∣ ∑ i : ℕ in range n, x ^ i * p ^ (n + 1 - i) * ↑((n + 1).choose i) by
  convert this; abel
state_before: case succ
R : Type u_1
n✝ : ℕ
inst✝ : CommRing R
a b x✝ y p x : R
n : ℕ
⊢ p ^ 2 ∣
    ∑ m in range n, x ^ m * p ^ (n + 1 - m) * ↑(Nat.choose (n + 1) m) + x ^ n * p * (↑n + 1) + x ^ (n + 1) -
        x ^ n * p * (↑n + 1) -
      x ^ (n + 1)

tactic: convert this
state_before: R : Type u_1
n✝ : ℕ
inst✝ : CommRing R
a b x✝ y p x : R
n : ℕ
this : p ^ 2 ∣ ∑ i in range n, x ^ i * p ^ (n + 1 - i) * ↑(Nat.choose (n + 1) i)
⊢ p ^ 2 ∣
    ∑ m in range n, x ^ m * p ^ (n + 1 - m) * ↑(Nat.choose (n + 1) m) + x ^ n * p * (↑n + 1) + x ^ (n + 1) -
        x ^ n * p * (↑n + 1) -
      x ^ (n + 1)

tactic: abel
state_before: case h.e'_4
R : Type u_1
n✝ : ℕ
inst✝ : CommRing R
a b x✝ y p x : R
n : ℕ
this : p ^ 2 ∣ ∑ i in range n, x ^ i * p ^ (n + 1 - i) * ↑(Nat.choose (n + 1) i)
⊢ ∑ m in range n, x ^ m * p ^ (n + 1 - m) * ↑(Nat.choose (n + 1) m) + x ^ n * p * (↑n + 1) + x ^ (n + 1) -
        x ^ n * p * (↑n + 1) -
      x ^ (n + 1) =
    ∑ i in range n, x ^ i * p ^ (n + 1 - i) * ↑(Nat.choose (n + 1) i)

tactic: apply Finset.dvd_sum
state_before: case succ
R : Type u_1
n✝ : ℕ
inst✝ : CommRing R
a b x✝ y p x : R
n : ℕ
⊢ p ^ 2 ∣ ∑ i in range n, x ^ i * p ^ (n + 1 - i) * ↑(Nat.choose (n + 1) i)

tactic: intro y hy
state_before: case succ.h
R : Type u_1
n✝ : ℕ
inst✝ : CommRing R
a b x✝ y p x : R
n : ℕ
⊢ ∀ (x_1 : ℕ), x_1 ∈ range n → p ^ 2 ∣ x ^ x_1 * p ^ (n + 1 - x_1) * ↑(Nat.choose (n + 1) x_1)

tactic: calc
  p ^ 2 ∣ p ^ (n + 1 - y) :=
    pow_dvd_pow p (le_tsub_of_add_le_left (by linarith [Finset.mem_range.mp hy]))
  _ ∣ x ^ y * p ^ (n + 1 - y) * ↑((n + 1).choose y) :=
    dvd_mul_of_dvd_left (dvd_mul_left _ _) _
state_before: case succ.h
R : Type u_1
n✝ : ℕ
inst✝ : CommRing R
a b x✝ y✝ p x : R
n y : ℕ
hy : y ∈ range n
⊢ p ^ 2 ∣ x ^ y * p ^ (n + 1 - y) * ↑(Nat.choose (n + 1) y)

tactic: linarith [Finset.mem_range.mp hy]
state_before: R : Type u_1
n✝ : ℕ
inst✝ : CommRing R
a b x✝ y✝ p x : R
n y : ℕ
hy : y ∈ range n
⊢ y + 2 ≤ n + 1
Theorem: SimplicialObject.Splitting.hom_ext
File: Mathlib/AlgebraicTopology/SplitSimplicialObject.lean

tactic: ext Δ
state_before: C : Type u_2
inst✝¹ : Category C
inst✝ : HasFiniteCoproducts C
X Y : SimplicialObject C
s : Splitting X
f g : X ⟶ Y
h : ∀ (n : ℕ), φ s f n = φ s g n
⊢ f = g

tactic: apply s.hom_ext'
state_before: case h
C : Type u_2
inst✝¹ : Category C
inst✝ : HasFiniteCoproducts C
X Y : SimplicialObject C
s : Splitting X
f g : X ⟶ Y
h : ∀ (n : ℕ), φ s f n = φ s g n
Δ : SimplexCategoryᵒᵖ
⊢ f.app Δ = g.app Δ

tactic: intro A
state_before: case h.h
C : Type u_2
inst✝¹ : Category C
inst✝ : HasFiniteCoproducts C
X Y : SimplicialObject C
s : Splitting X
f g : X ⟶ Y
h : ∀ (n : ℕ), φ s f n = φ s g n
Δ : SimplexCategoryᵒᵖ
⊢ ∀ (A : IndexSet Δ), ιSummand s A ≫ f.app Δ = ιSummand s A ≫ g.app Δ

tactic: induction' Δ using Opposite.rec with Δ
state_before: case h.h
C : Type u_2
inst✝¹ : Category C
inst✝ : HasFiniteCoproducts C
X Y : SimplicialObject C
s : Splitting X
f g : X ⟶ Y
h : ∀ (n : ℕ), φ s f n = φ s g n
Δ : SimplexCategoryᵒᵖ
A : IndexSet Δ
⊢ ιSummand s A ≫ f.app Δ = ιSummand s A ≫ g.app Δ

tactic: induction' Δ using SimplexCategory.rec with n
state_before: case h.h.mk
C : Type u_2
inst✝¹ : Category C
inst✝ : HasFiniteCoproducts C
X Y : SimplicialObject C
s : Splitting X
f g : X ⟶ Y
h : ∀ (n : ℕ), φ s f n = φ s g n
Δ✝ : SimplexCategoryᵒᵖ
A✝ : IndexSet Δ✝
Δ : SimplexCategory
A : IndexSet { unop := Δ }
⊢ ιSummand s A ≫ f.app { unop := Δ } = ιSummand s A ≫ g.app { unop := Δ }

tactic: dsimp
state_before: case h.h.mk.h
C : Type u_2
inst✝¹ : Category C
inst✝ : HasFiniteCoproducts C
X Y : SimplicialObject C
s : Splitting X
f g : X ⟶ Y
h : ∀ (n : ℕ), φ s f n = φ s g n
Δ✝ : SimplexCategoryᵒᵖ
A✝¹ : IndexSet Δ✝
Δ : SimplexCategory
A✝ : IndexSet { unop := Δ }
n : ℕ
A : IndexSet { unop := [n] }
⊢ ιSummand s A ≫ f.app { unop := [n] } = ιSummand s A ≫ g.app { unop := [n] }

tactic: simp only [s.ιSummand_comp_app, h]
state_before: case h.h.mk.h
C : Type u_2
inst✝¹ : Category C
inst✝ : HasFiniteCoproducts C
X Y : SimplicialObject C
s : Splitting X
f g : X ⟶ Y
h : ∀ (n : ℕ), φ s f n = φ s g n
Δ✝ : SimplexCategoryᵒᵖ
A✝¹ : IndexSet Δ✝
Δ : SimplexCategory
A✝ : IndexSet { unop := Δ }
n : ℕ
A : IndexSet { unop := [n] }
⊢ ιSummand s A ≫ f.app { unop := [n] } = ιSummand s A ≫ g.app { unop := [n] }
Theorem: Real.mapsTo_sin_Ioo
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Inverse.lean

tactic: rwa [mem_Ioo, ← arcsin_lt_pi_div_two, ← neg_pi_div_two_lt_arcsin, arcsin_sin h.1.le h.2.le]
state_before: x : ℝ
h : x ∈ Ioo (-(π / 2)) (π / 2)
⊢ sin x ∈ Ioo (-1) 1
Theorem: OnePoint.tendsto_nhds_infty
File: Mathlib/Topology/Compactification/OnePoint.lean

tactic: simp only [tendsto_pure_left, hasBasis_coclosedCompact.tendsto_left_iff, forall_and,
  and_assoc, exists_prop]
state_before: X : Type u_2
inst✝ : TopologicalSpace X
s : Set (OnePoint X)
t : Set X
α : Type u_1
f : OnePoint X → α
l : Filter α
⊢ Tendsto f (pure ∞) l ∧ Tendsto (f ∘ some) (coclosedCompact X) l ↔
    ∀ (s : Set α), s ∈ l → f ∞ ∈ s ∧ ∃ t, IsClosed t ∧ IsCompact t ∧ MapsTo (f ∘ some) (tᶜ) s
Theorem: IntermediateField.adjoin_simple_eq_bot_iff
File: Mathlib/FieldTheory/Adjoin.lean

tactic: simp
state_before: F : Type u_2
inst✝² : Field F
E : Type u_1
inst✝¹ : Field E
inst✝ : Algebra F E
α : E
S : Set E
⊢ F⟮α⟯ = ⊥ ↔ α ∈ ⊥
Theorem: Associates.prod_mk
File: Mathlib/Algebra/BigOperators/Associated.lean

tactic: simp
state_before: α : Type u_1
β : Type ?u.33213
γ : Type ?u.33216
δ : Type ?u.33219
inst✝ : CommMonoid α
p : Multiset α
⊢ Multiset.prod (Multiset.map Associates.mk 0) = Associates.mk (Multiset.prod 0)

tactic: simp [ih, Associates.mk_mul_mk]
state_before: α : Type u_1
β : Type ?u.33213
γ : Type ?u.33216
δ : Type ?u.33219
inst✝ : CommMonoid α
p : Multiset α
a : α
s : Multiset α
ih : Multiset.prod (Multiset.map Associates.mk s) = Associates.mk (Multiset.prod s)
⊢ Multiset.prod (Multiset.map Associates.mk (a ::ₘ s)) = Associates.mk (Multiset.prod (a ::ₘ s))
Theorem: ContinuousLinearMap.norm_extendTo𝕜'_bound
File: Mathlib/Analysis/NormedSpace/Extend.lean

tactic: set lm : F →ₗ[𝕜] 𝕜 := fr.toLinearMap.extendTo𝕜'
state_before: 𝕜 : Type u_2
inst✝⁴ : IsROrC 𝕜
F : Type u_1
inst✝³ : SeminormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
inst✝¹ : NormedSpace ℝ F
inst✝ : IsScalarTower ℝ 𝕜 F
fr : F →L[ℝ] ℝ
x : F
⊢ ‖↑(LinearMap.extendTo𝕜' ↑fr) x‖ ≤ ‖fr‖ * ‖x‖

tactic: by_cases h : lm x = 0
state_before: 𝕜 : Type u_2
inst✝⁴ : IsROrC 𝕜
F : Type u_1
inst✝³ : SeminormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
inst✝¹ : NormedSpace ℝ F
inst✝ : IsScalarTower ℝ 𝕜 F
fr : F →L[ℝ] ℝ
x : F
lm : F →ₗ[𝕜] 𝕜 := LinearMap.extendTo𝕜' ↑fr
⊢ ‖↑lm x‖ ≤ ‖fr‖ * ‖x‖

tactic: rw [← mul_le_mul_left (norm_pos_iff.2 h), ← sq]
state_before: case neg
𝕜 : Type u_2
inst✝⁴ : IsROrC 𝕜
F : Type u_1
inst✝³ : SeminormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
inst✝¹ : NormedSpace ℝ F
inst✝ : IsScalarTower ℝ 𝕜 F
fr : F →L[ℝ] ℝ
x : F
lm : F →ₗ[𝕜] 𝕜 := LinearMap.extendTo𝕜' ↑fr
h : ¬↑lm x = 0
⊢ ‖↑lm x‖ ≤ ‖fr‖ * ‖x‖

tactic: calc
  ‖lm x‖ ^ 2 = fr (conj (lm x : 𝕜) • x) := fr.toLinearMap.norm_extendTo𝕜'_apply_sq x
  _ ≤ ‖fr (conj (lm x : 𝕜) • x)‖ := (le_abs_self _)
  _ ≤ ‖fr‖ * ‖conj (lm x : 𝕜) • x‖ := (le_op_norm _ _)
  _ = ‖(lm x : 𝕜)‖ * (‖fr‖ * ‖x‖) := by rw [norm_smul, norm_conj, mul_left_comm]
state_before: case neg
𝕜 : Type u_2
inst✝⁴ : IsROrC 𝕜
F : Type u_1
inst✝³ : SeminormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
inst✝¹ : NormedSpace ℝ F
inst✝ : IsScalarTower ℝ 𝕜 F
fr : F →L[ℝ] ℝ
x : F
lm : F →ₗ[𝕜] 𝕜 := LinearMap.extendTo𝕜' ↑fr
h : ¬↑lm x = 0
⊢ ‖↑lm x‖ ^ 2 ≤ ‖↑lm x‖ * (‖fr‖ * ‖x‖)

tactic: rw [h, norm_zero]
state_before: case pos
𝕜 : Type u_2
inst✝⁴ : IsROrC 𝕜
F : Type u_1
inst✝³ : SeminormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
inst✝¹ : NormedSpace ℝ F
inst✝ : IsScalarTower ℝ 𝕜 F
fr : F →L[ℝ] ℝ
x : F
lm : F →ₗ[𝕜] 𝕜 := LinearMap.extendTo𝕜' ↑fr
h : ↑lm x = 0
⊢ ‖↑lm x‖ ≤ ‖fr‖ * ‖x‖

tactic: apply mul_nonneg <;> exact norm_nonneg _
state_before: case pos
𝕜 : Type u_2
inst✝⁴ : IsROrC 𝕜
F : Type u_1
inst✝³ : SeminormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
inst✝¹ : NormedSpace ℝ F
inst✝ : IsScalarTower ℝ 𝕜 F
fr : F →L[ℝ] ℝ
x : F
lm : F →ₗ[𝕜] 𝕜 := LinearMap.extendTo𝕜' ↑fr
h : ↑lm x = 0
⊢ 0 ≤ ‖fr‖ * ‖x‖

tactic: rw [norm_smul, norm_conj, mul_left_comm]
state_before: 𝕜 : Type u_2
inst✝⁴ : IsROrC 𝕜
F : Type u_1
inst✝³ : SeminormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
inst✝¹ : NormedSpace ℝ F
inst✝ : IsScalarTower ℝ 𝕜 F
fr : F →L[ℝ] ℝ
x : F
lm : F →ₗ[𝕜] 𝕜 := LinearMap.extendTo𝕜' ↑fr
h : ¬↑lm x = 0
⊢ ‖fr‖ * ‖↑(starRingEnd ((fun x => 𝕜) x)) (↑lm x) • x‖ = ‖↑lm x‖ * (‖fr‖ * ‖x‖)
Theorem: Stream'.WSeq.think_congr
File: Mathlib/Data/Seq/WSeq.lean

tactic: unfold Equiv
state_before: α : Type u
β : Type v
γ : Type w
s t : WSeq α
h : s ~ʷ t
⊢ think s ~ʷ think t

tactic: simp
state_before: α : Type u
β : Type v
γ : Type w
s t : WSeq α
h : s ~ʷ t
⊢ LiftRel (fun x x_1 => x = x_1) (think s) (think t)

tactic: exact h
state_before: α : Type u
β : Type v
γ : Type w
s t : WSeq α
h : s ~ʷ t
⊢ LiftRel (fun x x_1 => x = x_1) s t
Theorem: Ideal.finsuppTotal_apply
File: Mathlib/RingTheory/Ideal/Operations.lean

tactic: dsimp [finsuppTotal]
state_before: ι : Type u_1
M : Type u_3
inst✝² : AddCommGroup M
R : Type u_2
inst✝¹ : CommRing R
inst✝ : Module R M
I : Ideal R
v : ι → M
hv : Submodule.span R (Set.range v) = ⊤
f : ι →₀ { x // x ∈ I }
⊢ ↑(finsuppTotal ι M I v) f = Finsupp.sum f fun i x => ↑x • v i

tactic: rw [Finsupp.total_apply, Finsupp.sum_mapRange_index]
state_before: ι : Type u_1
M : Type u_3
inst✝² : AddCommGroup M
R : Type u_2
inst✝¹ : CommRing R
inst✝ : Module R M
I : Ideal R
v : ι → M
hv : Submodule.span R (Set.range v) = ⊤
f : ι →₀ { x // x ∈ I }
⊢ ↑(Finsupp.total ι M R v) (Finsupp.mapRange Subtype.val (_ : ↑(Submodule.subtype I) 0 = 0) f) =
    Finsupp.sum f fun i x => ↑x • v i

tactic: exact fun _ => zero_smul _ _
state_before: ι : Type u_1
M : Type u_3
inst✝² : AddCommGroup M
R : Type u_2
inst✝¹ : CommRing R
inst✝ : Module R M
I : Ideal R
v : ι → M
hv : Submodule.span R (Set.range v) = ⊤
f : ι →₀ { x // x ∈ I }
⊢ ∀ (a : ι), 0 • v a = 0
Theorem: LatticeOrderedCommGroup.pos_inf_neg_eq_one
File: Mathlib/Algebra/Order/LatticeGroup.lean

tactic: rw [← mul_right_inj (a⁻)⁻¹, mul_inf, mul_one, mul_left_inv, mul_comm, ← div_eq_mul_inv,
  pos_div_neg, neg_eq_inv_inf_one, inv_inv]
state_before: α : Type u
inst✝² : Lattice α
inst✝¹ : CommGroup α
inst✝ : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
a : α
⊢ a⁺ ⊓ a⁻ = 1