tasksource/leandojo huggingface dataset:
Theorem: MeasureTheory.tendsto_set_lintegral_zero
File: Mathlib/MeasureTheory/Integral/Lebesgue.lean

tactic: simp only [ENNReal.nhds_zero, tendsto_iInf, tendsto_principal, mem_Iio,
  ← pos_iff_ne_zero] at hl ⊢
state_before: α : Type u_2
β : Type ?u.795368
γ : Type ?u.795371
δ : Type ?u.795374
m : MeasurableSpace α
μ ν : Measure α
ι : Type u_1
f : α → ℝ≥0∞
h : (∫⁻ (x : α), f x ∂μ) ≠ ⊤
l : Filter ι
s : ι → Set α
hl : Tendsto (↑↑μ ∘ s) l (𝓝 0)
⊢ Tendsto (fun i => ∫⁻ (x : α) in s i, f x ∂μ) l (𝓝 0)

tactic: intro ε ε0
state_before: α : Type u_2
β : Type ?u.795368
γ : Type ?u.795371
δ : Type ?u.795374
m : MeasurableSpace α
μ ν : Measure α
ι : Type u_1
f : α → ℝ≥0∞
h : (∫⁻ (x : α), f x ∂μ) ≠ ⊤
l : Filter ι
s : ι → Set α
hl : ∀ (i : ℝ≥0∞), 0 < i → ∀ᶠ (a : ι) in l, (↑↑μ ∘ s) a < i
⊢ ∀ (i : ℝ≥0∞), 0 < i → ∀ᶠ (a : ι) in l, (∫⁻ (x : α) in s a, f x ∂μ) < i

tactic: rcases exists_pos_set_lintegral_lt_of_measure_lt h ε0.ne' with ⟨δ, δ0, hδ⟩
state_before: α : Type u_2
β : Type ?u.795368
γ : Type ?u.795371
δ : Type ?u.795374
m : MeasurableSpace α
μ ν : Measure α
ι : Type u_1
f : α → ℝ≥0∞
h : (∫⁻ (x : α), f x ∂μ) ≠ ⊤
l : Filter ι
s : ι → Set α
hl : ∀ (i : ℝ≥0∞), 0 < i → ∀ᶠ (a : ι) in l, (↑↑μ ∘ s) a < i
ε : ℝ≥0∞
ε0 : 0 < ε
⊢ ∀ᶠ (a : ι) in l, (∫⁻ (x : α) in s a, f x ∂μ) < ε

tactic: exact (hl δ δ0).mono fun i => hδ _
state_before: case intro.intro
α : Type u_2
β : Type ?u.795368
γ : Type ?u.795371
δ✝ : Type ?u.795374
m : MeasurableSpace α
μ ν : Measure α
ι : Type u_1
f : α → ℝ≥0∞
h : (∫⁻ (x : α), f x ∂μ) ≠ ⊤
l : Filter ι
s : ι → Set α
hl : ∀ (i : ℝ≥0∞), 0 < i → ∀ᶠ (a : ι) in l, (↑↑μ ∘ s) a < i
ε : ℝ≥0∞
ε0 : 0 < ε
δ : ℝ≥0∞
δ0 : δ > 0
hδ : ∀ (s : Set α), ↑↑μ s < δ → (∫⁻ (x : α) in s, f x ∂μ) < ε
⊢ ∀ᶠ (a : ι) in l, (∫⁻ (x : α) in s a, f x ∂μ) < ε
Theorem: Int.even_pow
File: Mathlib/Data/Int/Parity.lean

tactic: induction' n with n ih <;> simp [*, even_mul, pow_succ]
state_before: m n✝ : ℤ
n : ℕ
⊢ Even (m ^ n) ↔ Even m ∧ n ≠ 0

tactic: tauto
state_before: case succ
m n✝ : ℤ
n : ℕ
ih : Even (m ^ n) ↔ Even m ∧ n ≠ 0
⊢ Even m → ¬n = 0 → Even m
Theorem: ack_three
File: Mathlib/Computability/Ackermann.lean

tactic: induction' n with n IH
state_before: n : ℕ
⊢ ack 3 n = 2 ^ (n + 3) - 3

tactic: rfl
state_before: case zero

⊢ ack 3 zero = 2 ^ (zero + 3) - 3

tactic: rw [ack_succ_succ, IH, ack_two, Nat.succ_add, Nat.pow_succ 2 (n + 3), mul_comm _ 2,
    Nat.mul_sub_left_distrib, ← Nat.sub_add_comm, two_mul 3, Nat.add_sub_add_right]
state_before: case succ
n : ℕ
IH : ack 3 n = 2 ^ (n + 3) - 3
⊢ ack 3 (succ n) = 2 ^ (succ n + 3) - 3

tactic: have H : 2 * 3 ≤ 2 * 2 ^ 3 := by norm_num
state_before: case succ
n : ℕ
IH : ack 3 n = 2 ^ (n + 3) - 3
⊢ 2 * 3 ≤ 2 * 2 ^ (n + 3)

tactic: apply H.trans
state_before: case succ
n : ℕ
IH : ack 3 n = 2 ^ (n + 3) - 3
H : 2 * 3 ≤ 2 * 2 ^ 3
⊢ 2 * 3 ≤ 2 * 2 ^ (n + 3)

tactic: simp [pow_le_pow]
state_before: case succ
n : ℕ
IH : ack 3 n = 2 ^ (n + 3) - 3
H : 2 * 3 ≤ 2 * 2 ^ 3
⊢ 2 * 2 ^ 3 ≤ 2 * 2 ^ (n + 3)

tactic: norm_num
state_before: n : ℕ
IH : ack 3 n = 2 ^ (n + 3) - 3
⊢ 2 * 3 ≤ 2 * 2 ^ 3
Theorem: PadicInt.p_nonnunit
File: Mathlib/NumberTheory/Padics/PadicIntegers.lean

tactic: have : (p : ℝ)⁻¹ < 1 := inv_lt_one <| by exact_mod_cast hp.1.one_lt
state_before: p : ℕ
hp : Fact (Nat.Prime p)
⊢ ↑p ∈ nonunits ℤ_[p]

tactic: rwa [← norm_p, ← mem_nonunits] at this
state_before: p : ℕ
hp : Fact (Nat.Prime p)
this : (↑p)⁻¹ < 1
⊢ ↑p ∈ nonunits ℤ_[p]

tactic: exact_mod_cast hp.1.one_lt
state_before: p : ℕ
hp : Fact (Nat.Prime p)
⊢ 1 < ↑p
Theorem: Matrix.separatingLeft_toLinearMap₂_iff
File: Mathlib/LinearAlgebra/Matrix/SesquilinearForm.lean

tactic: rw [← Matrix.separatingLeft_toLinearMap₂'_iff_separatingLeft_toLinearMap₂,
  Matrix.separatingLeft_toLinearMap₂'_iff]
state_before: R : Type ?u.2748126
R₁ : Type u_2
R₂ : Type ?u.2748132
M✝ : Type ?u.2748135
M₁ : Type u_3
M₂ : Type ?u.2748141
M₁' : Type ?u.2748144
M₂' : Type ?u.2748147
n : Type ?u.2748150
m : Type ?u.2748153
n' : Type ?u.2748156
m' : Type ?u.2748159
ι : Type u_1
inst✝⁴ : CommRing R₁
inst✝³ : AddCommMonoid M₁
inst✝² : Module R₁ M₁
inst✝¹ : DecidableEq ι
inst✝ : Fintype ι
B : M₁ →ₗ[R₁] M₁ →ₗ[R₁] R₁
M : Matrix ι ι R₁
b : Basis ι R₁ M₁
⊢ SeparatingLeft (↑(toLinearMap₂ b b) M) ↔ Matrix.Nondegenerate M
Theorem: ZFSet.toSet_range
File: Mathlib/SetTheory/ZFC/Basic.lean

tactic: ext
state_before: α : Type u
f : α → ZFSet
⊢ toSet (range f) = Set.range f

tactic: simp
state_before: case h
α : Type u
f : α → ZFSet
x✝ : ZFSet
⊢ x✝ ∈ toSet (range f) ↔ x✝ ∈ Set.range f
Theorem: FractionalIdeal.spanSingleton_div_self
File: Mathlib/RingTheory/DedekindDomain/Ideal.lean

tactic: rw [spanSingleton_div_spanSingleton, div_self hx, spanSingleton_one]
state_before: R : Type ?u.45600
A : Type ?u.45603
K : Type u_1
inst✝¹⁰ : CommRing R
inst✝⁹ : CommRing A
inst✝⁸ : Field K
inst✝⁷ : IsDomain A
R₁ : Type u_2
inst✝⁶ : CommRing R₁
inst✝⁵ : IsDomain R₁
inst✝⁴ : Algebra R₁ K
inst✝³ : IsFractionRing R₁ K
I J : FractionalIdeal R₁⁰ K
K' : Type ?u.46614
inst✝² : Field K'
inst✝¹ : Algebra R₁ K'
inst✝ : IsFractionRing R₁ K'
x : K
hx : x ≠ 0
⊢ spanSingleton R₁⁰ x / spanSingleton R₁⁰ x = 1
Theorem: tendsto_atTop_nhds
File: Mathlib/Topology/Basic.lean

tactic: simp only [and_imp, exists_prop, true_and_iff, mem_Ici, ge_iff_le]
state_before: α : Type u
β : Type v
ι : Sort w
a✝ : α
s s₁ s₂ t : Set α
p p₁ p₂ : α → Prop
inst✝² : TopologicalSpace α
inst✝¹ : Nonempty β
inst✝ : SemilatticeSup β
f : β → α
a : α
⊢ (∀ (ib : Set α), a ∈ ib ∧ IsOpen ib → ∃ ia, True ∧ ∀ (x : β), x ∈ Ici ia → f x ∈ ib) ↔
    ∀ (U : Set α), a ∈ U → IsOpen U → ∃ N, ∀ (n : β), N ≤ n → f n ∈ U
Theorem: hasStrictFDerivAt_pi'
File: Mathlib/Analysis/Calculus/FDeriv/Prod.lean

tactic: simp only [HasStrictFDerivAt, ContinuousLinearMap.coe_pi]
state_before: 𝕜 : Type u_1
inst✝¹¹ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝¹⁰ : NormedAddCommGroup E
inst✝⁹ : NormedSpace 𝕜 E
F : Type ?u.395005
inst✝⁸ : NormedAddCommGroup F
inst✝⁷ : NormedSpace 𝕜 F
G : Type ?u.395100
inst✝⁶ : NormedAddCommGroup G
inst✝⁵ : NormedSpace 𝕜 G
G' : Type ?u.395195
inst✝⁴ : NormedAddCommGroup G'
inst✝³ : NormedSpace 𝕜 G'
f f₀ f₁ g : E → F
f' f₀' f₁' g' e : E →L[𝕜] F
x : E
s t : Set E
L L₁ L₂ : Filter E
ι : Type u_3
inst✝² : Fintype ι
F' : ι → Type u_4
inst✝¹ : (i : ι) → NormedAddCommGroup (F' i)
inst✝ : (i : ι) → NormedSpace 𝕜 (F' i)
φ : (i : ι) → E → F' i
φ' : (i : ι) → E →L[𝕜] F' i
Φ : E → (i : ι) → F' i
Φ' : E →L[𝕜] (i : ι) → F' i
⊢ HasStrictFDerivAt Φ Φ' x ↔ ∀ (i : ι), HasStrictFDerivAt (fun x => Φ x i) (comp (proj i) Φ') x

tactic: exact isLittleO_pi
state_before: 𝕜 : Type u_1
inst✝¹¹ : NontriviallyNormedField 𝕜
E : Type u_2
inst✝¹⁰ : NormedAddCommGroup E
inst✝⁹ : NormedSpace 𝕜 E
F : Type ?u.395005
inst✝⁸ : NormedAddCommGroup F
inst✝⁷ : NormedSpace 𝕜 F
G : Type ?u.395100
inst✝⁶ : NormedAddCommGroup G
inst✝⁵ : NormedSpace 𝕜 G
G' : Type ?u.395195
inst✝⁴ : NormedAddCommGroup G'
inst✝³ : NormedSpace 𝕜 G'
f f₀ f₁ g : E → F
f' f₀' f₁' g' e : E →L[𝕜] F
x : E
s t : Set E
L L₁ L₂ : Filter E
ι : Type u_3
inst✝² : Fintype ι
F' : ι → Type u_4
inst✝¹ : (i : ι) → NormedAddCommGroup (F' i)
inst✝ : (i : ι) → NormedSpace 𝕜 (F' i)
φ : (i : ι) → E → F' i
φ' : (i : ι) → E →L[𝕜] F' i
Φ : E → (i : ι) → F' i
Φ' : E →L[𝕜] (i : ι) → F' i
⊢ ((fun p => Φ p.fst - Φ p.snd - ↑Φ' (p.fst - p.snd)) =o[𝓝 (x, x)] fun p => p.fst - p.snd) ↔
    ∀ (i : ι),
      (fun p => Φ p.fst i - Φ p.snd i - ↑(comp (proj i) Φ') (p.fst - p.snd)) =o[𝓝 (x, x)] fun p => p.fst - p.snd
Theorem: CategoryTheory.Subobject.inf_eq_map_pullback'
File: Mathlib/CategoryTheory/Subobject/Lattice.lean

tactic: induction' f₂ using Quotient.inductionOn' with f₂
state_before: C : Type u₁
inst✝² : Category C
X Y Z : C
D : Type u₂
inst✝¹ : Category D
inst✝ : HasPullbacks C
A : C
f₁ : MonoOver A
f₂ : Subobject A
⊢ (inf.obj (Quotient.mk'' f₁)).obj f₂ = (map (MonoOver.arrow f₁)).obj ((pullback (MonoOver.arrow f₁)).obj f₂)

tactic: rfl
state_before: case h
C : Type u₁
inst✝² : Category C
X Y Z : C
D : Type u₂
inst✝¹ : Category D
inst✝ : HasPullbacks C
A : C
f₁ f₂ : MonoOver A
⊢ (inf.obj (Quotient.mk'' f₁)).obj (Quotient.mk'' f₂) =
    (map (MonoOver.arrow f₁)).obj ((pullback (MonoOver.arrow f₁)).obj (Quotient.mk'' f₂))
Theorem: Valuation.map_add_eq_of_lt_left
File: Mathlib/RingTheory/Valuation/Basic.lean

tactic: rw [add_comm]
state_before: K : Type ?u.2215047
F : Type ?u.2215050
R : Type u_2
inst✝³ : DivisionRing K
Γ₀ : Type u_1
Γ'₀ : Type ?u.2215062
Γ''₀ : Type ?u.2215065
inst✝² : LinearOrderedCommMonoidWithZero Γ''₀
inst✝¹ : Ring R
inst✝ : LinearOrderedCommGroupWithZero Γ₀
v : Valuation R Γ₀
x y z : R
h : ↑v y < ↑v x
⊢ ↑v (x + y) = ↑v x

tactic: exact map_add_eq_of_lt_right _ h
state_before: K : Type ?u.2215047
F : Type ?u.2215050
R : Type u_2
inst✝³ : DivisionRing K
Γ₀ : Type u_1
Γ'₀ : Type ?u.2215062
Γ''₀ : Type ?u.2215065
inst✝² : LinearOrderedCommMonoidWithZero Γ''₀
inst✝¹ : Ring R
inst✝ : LinearOrderedCommGroupWithZero Γ₀
v : Valuation R Γ₀
x y z : R
h : ↑v y < ↑v x
⊢ ↑v (y + x) = ↑v x
Theorem: mul_self_div_self
File: Mathlib/Algebra/GroupWithZero/Basic.lean

tactic: rw [div_eq_mul_inv, mul_self_mul_inv a]
state_before: α : Type ?u.25591
M₀ : Type ?u.25594
G₀ : Type u_1
M₀' : Type ?u.25600
G₀' : Type ?u.25603
F : Type ?u.25606
F' : Type ?u.25609
inst✝ : GroupWithZero G₀
a✝ b c a : G₀
⊢ a * a / a = a
Theorem: toIcoMod_apply_left
File: Mathlib/Algebra/Order/ToIntervalMod.lean

tactic: rw [toIcoMod_eq_iff hp, Set.left_mem_Ico]
state_before: α : Type u_1
inst✝ : LinearOrderedAddCommGroup α
hα : Archimedean α
p : α
hp : 0 < p
a✝ b c : α
n : ℤ
a : α
⊢ toIcoMod hp a a = a

tactic: exact ⟨lt_add_of_pos_right _ hp, 0, by simp⟩
state_before: α : Type u_1
inst✝ : LinearOrderedAddCommGroup α
hα : Archimedean α
p : α
hp : 0 < p
a✝ b c : α
n : ℤ
a : α
⊢ a < a + p ∧ ∃ z, a = a + z • p

tactic: simp
state_before: α : Type u_1
inst✝ : LinearOrderedAddCommGroup α
hα : Archimedean α
p : α
hp : 0 < p
a✝ b c : α
n : ℤ
a : α
⊢ a = a + 0 • p
Theorem: FreeLieAlgebra.lift_comp_of
File: Mathlib/Algebra/Lie/Free.lean

tactic: rw [← lift_symm_apply]
state_before: R : Type u
X : Type v
inst✝² : CommRing R
L : Type w
inst✝¹ : LieRing L
inst✝ : LieAlgebra R L
F : FreeLieAlgebra R X →ₗ⁅R⁆ L
⊢ ↑(lift R) (↑F ∘ of R) = F

tactic: exact (lift R).apply_symm_apply F
state_before: R : Type u
X : Type v
inst✝² : CommRing R
L : Type w
inst✝¹ : LieRing L
inst✝ : LieAlgebra R L
F : FreeLieAlgebra R X →ₗ⁅R⁆ L
⊢ ↑(lift R) (↑(lift R).symm F) = F
Theorem: AlgebraicGeometry.Polynomial.imageOfDf_eq_comap_C_compl_zeroLocus
File: Mathlib/AlgebraicGeometry/PrimeSpectrum/IsOpenComapC.lean

tactic: ext x
state_before: R : Type u_1
inst✝ : CommRing R
f : R[X]
⊢ imageOfDf f = ↑(PrimeSpectrum.comap C) '' zeroLocus {f}ᶜ

tactic: refine' ⟨fun hx => ⟨⟨map C x.asIdeal, isPrime_map_C_of_isPrime x.IsPrime⟩, ⟨_, _⟩⟩, _⟩
state_before: case h
R : Type u_1
inst✝ : CommRing R
f : R[X]
x : PrimeSpectrum R
⊢ x ∈ imageOfDf f ↔ x ∈ ↑(PrimeSpectrum.comap C) '' zeroLocus {f}ᶜ

tactic: rw [mem_compl_iff, mem_zeroLocus, singleton_subset_iff]
state_before: case h.refine'_1
R : Type u_1
inst✝ : CommRing R
f : R[X]
x : PrimeSpectrum R
hx : x ∈ imageOfDf f
⊢ { asIdeal := Ideal.map C x.asIdeal, IsPrime := (_ : Ideal.IsPrime (Ideal.map C x.asIdeal)) } ∈ zeroLocus {f}ᶜ

tactic: cases' hx with i hi
state_before: case h.refine'_1
R : Type u_1
inst✝ : CommRing R
f : R[X]
x : PrimeSpectrum R
hx : x ∈ imageOfDf f
⊢ ¬f ∈ ↑{ asIdeal := Ideal.map C x.asIdeal, IsPrime := (_ : Ideal.IsPrime (Ideal.map C x.asIdeal)) }.asIdeal

tactic: exact fun a => hi (mem_map_C_iff.mp a i)
state_before: case h.refine'_1.intro
R : Type u_1
inst✝ : CommRing R
f : R[X]
x : PrimeSpectrum R
i : ℕ
hi : ¬coeff f i ∈ x.asIdeal
⊢ ¬f ∈ ↑{ asIdeal := Ideal.map C x.asIdeal, IsPrime := (_ : Ideal.IsPrime (Ideal.map C x.asIdeal)) }.asIdeal

tactic: ext x
state_before: case h.refine'_2
R : Type u_1
inst✝ : CommRing R
f : R[X]
x : PrimeSpectrum R
hx : x ∈ imageOfDf f
⊢ ↑(PrimeSpectrum.comap C)
      { asIdeal := Ideal.map C x.asIdeal, IsPrime := (_ : Ideal.IsPrime (Ideal.map C x.asIdeal)) } =
    x

tactic: refine' ⟨fun h => _, fun h => subset_span (mem_image_of_mem C.1 h)⟩
state_before: case h.refine'_2.asIdeal.h
R : Type u_1
inst✝ : CommRing R
f : R[X]
x✝ : PrimeSpectrum R
hx : x✝ ∈ imageOfDf f
x : R
⊢ x ∈
      (↑(PrimeSpectrum.comap C)
          { asIdeal := Ideal.map C x✝.asIdeal, IsPrime := (_ : Ideal.IsPrime (Ideal.map C x✝.asIdeal)) }).asIdeal ↔
    x ∈ x✝.asIdeal

tactic: rw [← @coeff_C_zero R x _]
state_before: case h.refine'_2.asIdeal.h
R : Type u_1
inst✝ : CommRing R
f : R[X]
x✝ : PrimeSpectrum R
hx : x✝ ∈ imageOfDf f
x : R
h :
  x ∈
    (↑(PrimeSpectrum.comap C)
        { asIdeal := Ideal.map C x✝.asIdeal, IsPrime := (_ : Ideal.IsPrime (Ideal.map C x✝.asIdeal)) }).asIdeal
⊢ x ∈ x✝.asIdeal

tactic: exact mem_map_C_iff.mp h 0
state_before: case h.refine'_2.asIdeal.h
R : Type u_1
inst✝ : CommRing R
f : R[X]
x✝ : PrimeSpectrum R
hx : x✝ ∈ imageOfDf f
x : R
h :
  x ∈
    (↑(PrimeSpectrum.comap C)
        { asIdeal := Ideal.map C x✝.asIdeal, IsPrime := (_ : Ideal.IsPrime (Ideal.map C x✝.asIdeal)) }).asIdeal
⊢ coeff (↑C x) 0 ∈ x✝.asIdeal

tactic: rintro ⟨xli, complement, rfl⟩
state_before: case h.refine'_3
R : Type u_1
inst✝ : CommRing R
f : R[X]
x : PrimeSpectrum R
⊢ x ∈ ↑(PrimeSpectrum.comap C) '' zeroLocus {f}ᶜ → x ∈ imageOfDf f

tactic: exact comap_C_mem_imageOfDf complement
state_before: case h.refine'_3.intro.intro
R : Type u_1
inst✝ : CommRing R
f : R[X]
xli : PrimeSpectrum R[X]
complement : xli ∈ zeroLocus {f}ᶜ
⊢ ↑(PrimeSpectrum.comap C) xli ∈ imageOfDf f
Theorem: Lagrange.basisDivisor_ne_zero_iff
File: Mathlib/LinearAlgebra/Lagrange.lean

tactic: rw [Ne.def, basisDivisor_eq_zero_iff]
state_before: F : Type u_1
inst✝ : Field F
x y : F
⊢ basisDivisor x y ≠ 0 ↔ x ≠ y
Theorem: CompleteLattice.independent_pair
File: Mathlib/Order/SupIndep.lean

tactic: constructor
state_before: α : Type u_2
β : Type ?u.54428
ι : Type u_1
ι' : Type ?u.54434
inst✝ : CompleteLattice α
s : Set α
hs : SetIndependent s
t : ι → α
ht : Independent t
i j : ι
hij : i ≠ j
huniv : ∀ (k : ι), k = i ∨ k = j
⊢ Independent t ↔ Disjoint (t i) (t j)

tactic: exact fun h => h.pairwiseDisjoint hij
state_before: case mp
α : Type u_2
β : Type ?u.54428
ι : Type u_1
ι' : Type ?u.54434
inst✝ : CompleteLattice α
s : Set α
hs : SetIndependent s
t : ι → α
ht : Independent t
i j : ι
hij : i ≠ j
huniv : ∀ (k : ι), k = i ∨ k = j
⊢ Independent t → Disjoint (t i) (t j)

tactic: rintro h k
state_before: case mpr
α : Type u_2
β : Type ?u.54428
ι : Type u_1
ι' : Type ?u.54434
inst✝ : CompleteLattice α
s : Set α
hs : SetIndependent s
t : ι → α
ht : Independent t
i j : ι
hij : i ≠ j
huniv : ∀ (k : ι), k = i ∨ k = j
⊢ Disjoint (t i) (t j) → Independent t

tactic: obtain rfl | rfl := huniv k
state_before: case mpr
α : Type u_2
β : Type ?u.54428
ι : Type u_1
ι' : Type ?u.54434
inst✝ : CompleteLattice α
s : Set α
hs : SetIndependent s
t : ι → α
ht : Independent t
i j : ι
hij : i ≠ j
huniv : ∀ (k : ι), k = i ∨ k = j
h : Disjoint (t i) (t j)
k : ι
⊢ Disjoint (t k) (⨆ (j : ι) (_ : j ≠ k), t j)

tactic: refine' h.mono_right (iSup_le fun i => iSup_le fun hi => Eq.le _)
state_before: case mpr.inl
α : Type u_2
β : Type ?u.54428
ι : Type u_1
ι' : Type ?u.54434
inst✝ : CompleteLattice α
s : Set α
hs : SetIndependent s
t : ι → α
ht : Independent t
j k : ι
hij : k ≠ j
huniv : ∀ (k_1 : ι), k_1 = k ∨ k_1 = j
h : Disjoint (t k) (t j)
⊢ Disjoint (t k) (⨆ (j : ι) (_ : j ≠ k), t j)

tactic: rw [(huniv i).resolve_left hi]
state_before: case mpr.inl
α : Type u_2
β : Type ?u.54428
ι : Type u_1
ι' : Type ?u.54434
inst✝ : CompleteLattice α
s : Set α
hs : SetIndependent s
t : ι → α
ht : Independent t
j k : ι
hij : k ≠ j
huniv : ∀ (k_1 : ι), k_1 = k ∨ k_1 = j
h : Disjoint (t k) (t j)
i : ι
hi : i ≠ k
⊢ t i = t j

tactic: refine' h.symm.mono_right (iSup_le fun j => iSup_le fun hj => Eq.le _)
state_before: case mpr.inr
α : Type u_2
β : Type ?u.54428
ι : Type u_1
ι' : Type ?u.54434
inst✝ : CompleteLattice α
s : Set α
hs : SetIndependent s
t : ι → α
ht : Independent t
i k : ι
hij : i ≠ k
huniv : ∀ (k_1 : ι), k_1 = i ∨ k_1 = k
h : Disjoint (t i) (t k)
⊢ Disjoint (t k) (⨆ (j : ι) (_ : j ≠ k), t j)

tactic: rw [(huniv j).resolve_right hj]
state_before: case mpr.inr
α : Type u_2
β : Type ?u.54428
ι : Type u_1
ι' : Type ?u.54434
inst✝ : CompleteLattice α
s : Set α
hs : SetIndependent s
t : ι → α
ht : Independent t
i k : ι
hij : i ≠ k
huniv : ∀ (k_1 : ι), k_1 = i ∨ k_1 = k
h : Disjoint (t i) (t k)
j : ι
hj : j ≠ k
⊢ t j = t i
Theorem: Mathlib.Tactic.Ring.atom_pf
File: Mathlib/Tactic/Ring/Basic.lean

tactic: simp
state_before: u : Lean.Level
R : Type u_1
α : Q(Type u)
sα : Q(CommSemiring «$α»)
inst✝ : CommSemiring R
a : R
⊢ a = a ^ Nat.rawCast 1 * Nat.rawCast 1 + 0
Theorem: CategoryTheory.Sheaf.adjunctionToTypes_unit_app_val
File: Mathlib/CategoryTheory/Sites/Adjunction.lean

tactic: dsimp [adjunctionToTypes, Adjunction.comp]
state_before: C : Type u
inst✝⁹ : Category C
J : GrothendieckTopology C
D : Type w₁
inst✝⁸ : Category D
E : Type w₂
inst✝⁷ : Category E
F : D ⥤ E
G✝ : E ⥤ D
inst✝⁶ : (X : C) → (S : Cover J X) → (P : Cᵒᵖ ⥤ D) → PreservesLimit (MulticospanIndex.multicospan (Cover.index S P)) F
inst✝⁵ : ConcreteCategory D
inst✝⁴ : PreservesLimits (forget D)
inst✝³ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : Cover J X), HasMultiequalizer (Cover.index S P)
inst✝² : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
inst✝¹ : (X : C) → PreservesColimitsOfShape (Cover J X)ᵒᵖ (forget D)
inst✝ : ReflectsIsomorphisms (forget D)
G : Type (max v u) ⥤ D
adj : G ⊣ forget D
Y : SheafOfTypes J
⊢ ((adjunctionToTypes J adj).unit.app Y).val =
    (Adjunction.whiskerRight Cᵒᵖ adj).unit.app ((sheafOfTypesToPresheaf J).obj Y) ≫
      whiskerRight
        (toSheafify J (((whiskeringRight Cᵒᵖ (Type (max v u)) D).obj G).obj ((sheafOfTypesToPresheaf J).obj Y)))
        (forget D)

tactic: simp
state_before: C : Type u
inst✝⁹ : Category C
J : GrothendieckTopology C
D : Type w₁
inst✝⁸ : Category D
E : Type w₂
inst✝⁷ : Category E
F : D ⥤ E
G✝ : E ⥤ D
inst✝⁶ : (X : C) → (S : Cover J X) → (P : Cᵒᵖ ⥤ D) → PreservesLimit (MulticospanIndex.multicospan (Cover.index S P)) F
inst✝⁵ : ConcreteCategory D
inst✝⁴ : PreservesLimits (forget D)
inst✝³ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : Cover J X), HasMultiequalizer (Cover.index S P)
inst✝² : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
inst✝¹ : (X : C) → PreservesColimitsOfShape (Cover J X)ᵒᵖ (forget D)
inst✝ : ReflectsIsomorphisms (forget D)
G : Type (max v u) ⥤ D
adj : G ⊣ forget D
Y : SheafOfTypes J
⊢ ((Equivalence.toAdjunction (Equivalence.symm (sheafEquivSheafOfTypes J))).unit.app Y).val ≫
      ((adjunction J adj).unit.app ((sheafEquivSheafOfTypes J).inverse.obj Y)).val ≫
        𝟙 (sheafify J (Y.val ⋙ G) ⋙ forget D) =
    (Adjunction.whiskerRight Cᵒᵖ adj).unit.app Y.val ≫ whiskerRight (toSheafify J (Y.val ⋙ G)) (forget D)

tactic: rfl
state_before: C : Type u
inst✝⁹ : Category C
J : GrothendieckTopology C
D : Type w₁
inst✝⁸ : Category D
E : Type w₂
inst✝⁷ : Category E
F : D ⥤ E
G✝ : E ⥤ D
inst✝⁶ : (X : C) → (S : Cover J X) → (P : Cᵒᵖ ⥤ D) → PreservesLimit (MulticospanIndex.multicospan (Cover.index S P)) F
inst✝⁵ : ConcreteCategory D
inst✝⁴ : PreservesLimits (forget D)
inst✝³ : ∀ (P : Cᵒᵖ ⥤ D) (X : C) (S : Cover J X), HasMultiequalizer (Cover.index S P)
inst✝² : ∀ (X : C), HasColimitsOfShape (Cover J X)ᵒᵖ D
inst✝¹ : (X : C) → PreservesColimitsOfShape (Cover J X)ᵒᵖ (forget D)
inst✝ : ReflectsIsomorphisms (forget D)
G : Type (max v u) ⥤ D
adj : G ⊣ forget D
Y : SheafOfTypes J
⊢ ((Equivalence.toAdjunction (Equivalence.symm (sheafEquivSheafOfTypes J))).unit.app Y).val ≫
      ↑(Adjunction.homEquiv (Adjunction.whiskerRight Cᵒᵖ adj) Y.val (sheafify J (Y.val ⋙ G)))
        (toSheafify J (Y.val ⋙ G)) =
    (Adjunction.whiskerRight Cᵒᵖ adj).unit.app Y.val ≫ whiskerRight (toSheafify J (Y.val ⋙ G)) (forget D)
Theorem: div_le_one_of_ge
File: Mathlib/Algebra/Order/Field/Basic.lean

tactic: simpa only [neg_div_neg_eq] using div_le_one_of_le (neg_le_neg h) (neg_nonneg_of_nonpos hb)
state_before: ι : Type ?u.148913
α : Type u_1
β : Type ?u.148919
inst✝ : LinearOrderedField α
a b c d : α
n : ℤ
h : b ≤ a
hb : b ≤ 0
⊢ a / b ≤ 1
Theorem: Finset.mul_eq_one_iff
File: Mathlib/Data/Finset/Pointwise.lean

tactic: simp_rw [← coe_inj, coe_mul, coe_one, Set.mul_eq_one_iff, coe_singleton]
state_before: F : Type ?u.557283
α : Type u_1
β : Type ?u.557289
γ : Type ?u.557292
inst✝² : DecidableEq α
inst✝¹ : DecidableEq β
inst✝ : DivisionMonoid α
s t : Finset α
⊢ s * t = 1 ↔ ∃ a b, s = {a} ∧ t = {b} ∧ a * b = 1
Theorem: Polynomial.eq_zero_of_degree_lt_of_eval_index_eq_zero
File: Mathlib/LinearAlgebra/Lagrange.lean

tactic: classical
  rw [← card_image_of_injOn hvs] at degree_f_lt
  refine' eq_zero_of_degree_lt_of_eval_finset_eq_zero _ degree_f_lt _
  intro x hx
  rcases mem_image.mp hx with ⟨_, hj, rfl⟩
  exact eval_f _ hj
state_before: R : Type u_2
inst✝¹ : CommRing R
inst✝ : IsDomain R
f g : R[X]
ι : Type u_1
v : ι → R
s : Finset ι
hvs : Set.InjOn v ↑s
degree_f_lt : degree f < ↑(card s)
eval_f : ∀ (i : ι), i ∈ s → eval (v i) f = 0
⊢ f = 0

tactic: rw [← card_image_of_injOn hvs] at degree_f_lt
state_before: R : Type u_2
inst✝¹ : CommRing R
inst✝ : IsDomain R
f g : R[X]
ι : Type u_1
v : ι → R
s : Finset ι
hvs : Set.InjOn v ↑s
degree_f_lt : degree f < ↑(card s)
eval_f : ∀ (i : ι), i ∈ s → eval (v i) f = 0
⊢ f = 0

tactic: refine' eq_zero_of_degree_lt_of_eval_finset_eq_zero _ degree_f_lt _
state_before: R : Type u_2
inst✝¹ : CommRing R
inst✝ : IsDomain R
f g : R[X]
ι : Type u_1
v : ι → R
s : Finset ι
hvs : Set.InjOn v ↑s
degree_f_lt : degree f < ↑(card (image v s))
eval_f : ∀ (i : ι), i ∈ s → eval (v i) f = 0
⊢ f = 0

tactic: intro x hx
state_before: R : Type u_2
inst✝¹ : CommRing R
inst✝ : IsDomain R
f g : R[X]
ι : Type u_1
v : ι → R
s : Finset ι
hvs : Set.InjOn v ↑s
degree_f_lt : degree f < ↑(card (image v s))
eval_f : ∀ (i : ι), i ∈ s → eval (v i) f = 0
⊢ ∀ (x : R), x ∈ image v s → eval x f = 0

tactic: rcases mem_image.mp hx with ⟨_, hj, rfl⟩
state_before: R : Type u_2
inst✝¹ : CommRing R
inst✝ : IsDomain R
f g : R[X]
ι : Type u_1
v : ι → R
s : Finset ι
hvs : Set.InjOn v ↑s
degree_f_lt : degree f < ↑(card (image v s))
eval_f : ∀ (i : ι), i ∈ s → eval (v i) f = 0
x : R
hx : x ∈ image v s
⊢ eval x f = 0

tactic: exact eval_f _ hj
state_before: case intro.intro
R : Type u_2
inst✝¹ : CommRing R
inst✝ : IsDomain R
f g : R[X]
ι : Type u_1
v : ι → R
s : Finset ι
hvs : Set.InjOn v ↑s
degree_f_lt : degree f < ↑(card (image v s))
eval_f : ∀ (i : ι), i ∈ s → eval (v i) f = 0
w✝ : ι
hj : w✝ ∈ s
hx : v w✝ ∈ image v s
⊢ eval (v w✝) f = 0
Theorem: Language.map_id
File: Mathlib/Computability/Language.lean

tactic: simp [map]
state_before: α : Type u_1
β : Type ?u.42797
γ : Type ?u.42800
l✝ m : Language α
a b x : List α
l : Language α
⊢ ↑(map id) l = l
Theorem: CategoryTheory.NatTrans.rightDerived_id
File: Mathlib/CategoryTheory/Abelian/RightDerived.lean

tactic: simp [NatTrans.rightDerived]
state_before: C : Type u
inst✝⁵ : Category C
D : Type u_2
inst✝⁴ : Category D
inst✝³ : Abelian C
inst✝² : HasInjectiveResolutions C
inst✝¹ : Abelian D
F : C ⥤ D
inst✝ : Functor.Additive F
n : ℕ
⊢ rightDerived (𝟙 F) n = 𝟙 (Functor.rightDerived F n)

tactic: rfl
state_before: C : Type u
inst✝⁵ : Category C
D : Type u_2
inst✝⁴ : Category D
inst✝³ : Abelian C
inst✝² : HasInjectiveResolutions C
inst✝¹ : Abelian D
F : C ⥤ D
inst✝ : Functor.Additive F
n : ℕ
⊢ 𝟙
      (injectiveResolutions C ⋙
        Functor.mapHomotopyCategory F (ComplexShape.up ℕ) ⋙ HomotopyCategory.homologyFunctor D (ComplexShape.up ℕ) n) =
    𝟙 (Functor.rightDerived F n)
Theorem: InnerProductSpace.Core.inner_smul_right
File: Mathlib/Analysis/InnerProductSpace/Basic.lean

tactic: rw [← inner_conj_symm, inner_smul_left]
state_before: 𝕜 : Type u_1
E : Type ?u.527762
F : Type u_2
inst✝² : IsROrC 𝕜
inst✝¹ : AddCommGroup F
inst✝ : Module 𝕜 F
c : Core 𝕜 F
x y : F
r : 𝕜
⊢ inner x (r • y) = r * inner x y

tactic: simp only [conj_conj, inner_conj_symm, RingHom.map_mul]
state_before: 𝕜 : Type u_1
E : Type ?u.527762
F : Type u_2
inst✝² : IsROrC 𝕜
inst✝¹ : AddCommGroup F
inst✝ : Module 𝕜 F
c : Core 𝕜 F
x y : F
r : 𝕜
⊢ ↑(starRingEnd 𝕜) (↑(starRingEnd 𝕜) r * inner y x) = r * inner x y