tasksource/leandojo huggingface dataset:
Theorem: hasSum_nat_add_iff
File: Mathlib/Topology/Algebra/InfiniteSum/Basic.lean

tactic: refine' Iff.trans _ (range k).hasSum_compl_iff
state_before: α : Type u_1
β : Type ?u.450378
γ : Type ?u.450381
δ : Type ?u.450384
inst✝² : AddCommGroup α
inst✝¹ : TopologicalSpace α
inst✝ : TopologicalAddGroup α
f✝ g : β → α
a✝ a₁ a₂ : α
f : ℕ → α
k : ℕ
a : α
⊢ HasSum (fun n => f (n + k)) a ↔ HasSum f (a + ∑ i in range k, f i)

tactic: rw [← (notMemRangeEquiv k).symm.hasSum_iff]
state_before: α : Type u_1
β : Type ?u.450378
γ : Type ?u.450381
δ : Type ?u.450384
inst✝² : AddCommGroup α
inst✝¹ : TopologicalSpace α
inst✝ : TopologicalAddGroup α
f✝ g : β → α
a✝ a₁ a₂ : α
f : ℕ → α
k : ℕ
a : α
⊢ HasSum (fun n => f (n + k)) a ↔ HasSum (fun x => f ↑x) a

tactic: rfl
state_before: α : Type u_1
β : Type ?u.450378
γ : Type ?u.450381
δ : Type ?u.450384
inst✝² : AddCommGroup α
inst✝¹ : TopologicalSpace α
inst✝ : TopologicalAddGroup α
f✝ g : β → α
a✝ a₁ a₂ : α
f : ℕ → α
k : ℕ
a : α
⊢ HasSum (fun n => f (n + k)) a ↔ HasSum ((fun x => f ↑x) ∘ ↑(notMemRangeEquiv k).symm) a
Theorem: PrimeSpectrum.vanishingIdeal_univ
File: Mathlib/AlgebraicGeometry/PrimeSpectrum/Basic.lean

tactic: simpa using (gc R).u_top
state_before: R : Type u
S : Type v
inst✝¹ : CommRing R
inst✝ : CommRing S
⊢ vanishingIdeal ∅ = ⊤
Theorem: Polynomial.irreducible_of_monic
File: Mathlib/Data/Polynomial/RingDivision.lean

tactic: refine'
  ⟨fun h f g hf hg hp => (h.2 f g hp.symm).imp hf.eq_one_of_isUnit hg.eq_one_of_isUnit, fun h =>
    ⟨hp1 ∘ hp.eq_one_of_isUnit, fun f g hfg =>
      (h (g * C f.leadingCoeff) (f * C g.leadingCoeff) _ _ _).symm.imp (isUnit_of_mul_eq_one f _)
        (isUnit_of_mul_eq_one g _)⟩⟩
state_before: R : Type u
S : Type v
T : Type w
a b : R
n : ℕ
inst✝¹ : CommSemiring R
inst✝ : NoZeroDivisors R
p q : R[X]
hp : Monic p
hp1 : p ≠ 1
⊢ Irreducible p ↔ ∀ (f g : R[X]), Monic f → Monic g → f * g = p → f = 1 ∨ g = 1

tactic: rwa [Monic, leadingCoeff_mul, leadingCoeff_C, ← leadingCoeff_mul, mul_comm, ← hfg, ← Monic]
state_before: case refine'_1
R : Type u
S : Type v
T : Type w
a b : R
n : ℕ
inst✝¹ : CommSemiring R
inst✝ : NoZeroDivisors R
p q : R[X]
hp : Monic p
hp1 : p ≠ 1
h : ∀ (f g : R[X]), Monic f → Monic g → f * g = p → f = 1 ∨ g = 1
f g : R[X]
hfg : p = f * g
⊢ Monic (g * ↑C (leadingCoeff f))

tactic: rwa [Monic, leadingCoeff_mul, leadingCoeff_C, ← leadingCoeff_mul, ← hfg, ← Monic]
state_before: case refine'_2
R : Type u
S : Type v
T : Type w
a b : R
n : ℕ
inst✝¹ : CommSemiring R
inst✝ : NoZeroDivisors R
p q : R[X]
hp : Monic p
hp1 : p ≠ 1
h : ∀ (f g : R[X]), Monic f → Monic g → f * g = p → f = 1 ∨ g = 1
f g : R[X]
hfg : p = f * g
⊢ Monic (f * ↑C (leadingCoeff g))

tactic: rw [mul_mul_mul_comm, ← C_mul, ← leadingCoeff_mul, ← hfg, hp.leadingCoeff, C_1, mul_one,
  mul_comm, ← hfg]
state_before: case refine'_3
R : Type u
S : Type v
T : Type w
a b : R
n : ℕ
inst✝¹ : CommSemiring R
inst✝ : NoZeroDivisors R
p q : R[X]
hp : Monic p
hp1 : p ≠ 1
h : ∀ (f g : R[X]), Monic f → Monic g → f * g = p → f = 1 ∨ g = 1
f g : R[X]
hfg : p = f * g
⊢ g * ↑C (leadingCoeff f) * (f * ↑C (leadingCoeff g)) = p
Theorem: SimpleGraph.Walk.IsTrail.reverse
File: Mathlib/Combinatorics/SimpleGraph/Connectivity.lean

tactic: simpa [isTrail_def] using h
state_before: V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
u v : V
p : Walk G u v
h : IsTrail p
⊢ IsTrail (Walk.reverse p)
Theorem: spectrum.of_subsingleton
File: Mathlib/Algebra/Algebra/Spectrum.lean

tactic: rw [spectrum, resolventSet_of_subsingleton, Set.compl_univ]
state_before: R : Type u
A : Type v
inst✝³ : CommSemiring R
inst✝² : Ring A
inst✝¹ : Algebra R A
inst✝ : Subsingleton A
a : A
⊢ σ a = ∅
Theorem: Complex.cos_sub_cos
File: Mathlib/Data/Complex/Exponential.lean

tactic: have s1 := cos_add ((x + y) / 2) ((x - y) / 2)
state_before: x y : ℂ
⊢ cos x - cos y = -2 * sin ((x + y) / 2) * sin ((x - y) / 2)

tactic: have s2 := cos_sub ((x + y) / 2) ((x - y) / 2)
state_before: x y : ℂ
s1 : cos ((x + y) / 2 + (x - y) / 2) = cos ((x + y) / 2) * cos ((x - y) / 2) - sin ((x + y) / 2) * sin ((x - y) / 2)
⊢ cos x - cos y = -2 * sin ((x + y) / 2) * sin ((x - y) / 2)

tactic: rw [div_add_div_same, add_sub, add_right_comm, add_sub_cancel, half_add_self] at s1
state_before: x y : ℂ
s1 : cos ((x + y) / 2 + (x - y) / 2) = cos ((x + y) / 2) * cos ((x - y) / 2) - sin ((x + y) / 2) * sin ((x - y) / 2)
s2 : cos ((x + y) / 2 - (x - y) / 2) = cos ((x + y) / 2) * cos ((x - y) / 2) + sin ((x + y) / 2) * sin ((x - y) / 2)
⊢ cos x - cos y = -2 * sin ((x + y) / 2) * sin ((x - y) / 2)

tactic: rw [div_sub_div_same, ← sub_add, add_sub_cancel', half_add_self] at s2
state_before: x y : ℂ
s1 : cos x = cos ((x + y) / 2) * cos ((x - y) / 2) - sin ((x + y) / 2) * sin ((x - y) / 2)
s2 : cos ((x + y) / 2 - (x - y) / 2) = cos ((x + y) / 2) * cos ((x - y) / 2) + sin ((x + y) / 2) * sin ((x - y) / 2)
⊢ cos x - cos y = -2 * sin ((x + y) / 2) * sin ((x - y) / 2)

tactic: rw [s1, s2]
state_before: x y : ℂ
s1 : cos x = cos ((x + y) / 2) * cos ((x - y) / 2) - sin ((x + y) / 2) * sin ((x - y) / 2)
s2 : cos y = cos ((x + y) / 2) * cos ((x - y) / 2) + sin ((x + y) / 2) * sin ((x - y) / 2)
⊢ cos x - cos y = -2 * sin ((x + y) / 2) * sin ((x - y) / 2)

tactic: ring
state_before: x y : ℂ
s1 : cos x = cos ((x + y) / 2) * cos ((x - y) / 2) - sin ((x + y) / 2) * sin ((x - y) / 2)
s2 : cos y = cos ((x + y) / 2) * cos ((x - y) / 2) + sin ((x + y) / 2) * sin ((x - y) / 2)
⊢ cos ((x + y) / 2) * cos ((x - y) / 2) - sin ((x + y) / 2) * sin ((x - y) / 2) -
      (cos ((x + y) / 2) * cos ((x - y) / 2) + sin ((x + y) / 2) * sin ((x - y) / 2)) =
    -2 * sin ((x + y) / 2) * sin ((x - y) / 2)
Theorem: ContDiffAt.continuousAt
File: Mathlib/Analysis/Calculus/ContDiffDef.lean

tactic: simpa [continuousWithinAt_univ] using h.continuousWithinAt
state_before: 𝕜 : Type u
inst✝⁸ : NontriviallyNormedField 𝕜
E : Type uE
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
F : Type uF
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace 𝕜 F
G : Type uG
inst✝³ : NormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
X : Type uX
inst✝¹ : NormedAddCommGroup X
inst✝ : NormedSpace 𝕜 X
s s₁ t u : Set E
f f₁ : E → F
g : F → G
x x₀ : E
c : F
m n : ℕ∞
p : E → FormalMultilinearSeries 𝕜 E F
h : ContDiffAt 𝕜 n f x
⊢ ContinuousAt f x
Theorem: HasStrictDerivAt.mul
File: Mathlib/Analysis/Calculus/Deriv/Mul.lean

tactic: have := (HasStrictFDerivAt.mul' hc hd).hasStrictDerivAt
state_before: 𝕜 : Type u
inst✝⁸ : NontriviallyNormedField 𝕜
F : Type v
inst✝⁷ : NormedAddCommGroup F
inst✝⁶ : NormedSpace 𝕜 F
E : Type w
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedSpace 𝕜 E
f f₀ f₁ g : 𝕜 → F
f' f₀' f₁' g' : F
x : 𝕜
s t : Set 𝕜
L L₁ L₂ : Filter 𝕜
𝕜' : Type ?u.223044
𝔸 : Type u_1
inst✝³ : NormedField 𝕜'
inst✝² : NormedRing 𝔸
inst✝¹ : NormedAlgebra 𝕜 𝕜'
inst✝ : NormedAlgebra 𝕜 𝔸
c d : 𝕜 → 𝔸
c' d' : 𝔸
u v : 𝕜 → 𝕜'
hc : HasStrictDerivAt c c' x
hd : HasStrictDerivAt d d' x
⊢ HasStrictDerivAt (fun y => c y * d y) (c' * d x + c x * d') x

tactic: rwa [ContinuousLinearMap.add_apply, ContinuousLinearMap.smul_apply,
  ContinuousLinearMap.smulRight_apply, ContinuousLinearMap.smulRight_apply,
  ContinuousLinearMap.smulRight_apply, ContinuousLinearMap.one_apply, one_smul, one_smul,
  add_comm] at this
state_before: 𝕜 : Type u
inst✝⁸ : NontriviallyNormedField 𝕜
F : Type v
inst✝⁷ : NormedAddCommGroup F
inst✝⁶ : NormedSpace 𝕜 F
E : Type w
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedSpace 𝕜 E
f f₀ f₁ g : 𝕜 → F
f' f₀' f₁' g' : F
x : 𝕜
s t : Set 𝕜
L L₁ L₂ : Filter 𝕜
𝕜' : Type ?u.223044
𝔸 : Type u_1
inst✝³ : NormedField 𝕜'
inst✝² : NormedRing 𝔸
inst✝¹ : NormedAlgebra 𝕜 𝕜'
inst✝ : NormedAlgebra 𝕜 𝔸
c d : 𝕜 → 𝔸
c' d' : 𝔸
u v : 𝕜 → 𝕜'
hc : HasStrictDerivAt c c' x
hd : HasStrictDerivAt d d' x
this : HasStrictDerivAt (fun y => c y * d y) (↑(c x • smulRight 1 d' + smulRight (smulRight 1 c') (d x)) 1) x
⊢ HasStrictDerivAt (fun y => c y * d y) (c' * d x + c x * d') x
Theorem: Computation.results_think
File: Mathlib/Data/Seq/Computation.lean

tactic: rw [length_think, h.length]
state_before: α : Type u
β : Type v
γ : Type w
s : Computation α
a : α
n : ℕ
h : Results s a n
this : Terminates s
⊢ length (think s) = n + 1
Theorem: Polynomial.sum_over_range'
File: Mathlib/Data/Polynomial/Degree/Definitions.lean

tactic: rcases p with ⟨⟩
state_before: R : Type u
S : Type v
a b c d : R
n✝ m : ℕ
inst✝¹ : Semiring R
p✝ q r : R[X]
inst✝ : AddCommMonoid S
p : R[X]
f : ℕ → R → S
h : ∀ (n : ℕ), f n 0 = 0
n : ℕ
w : natDegree p < n
⊢ sum p f = ∑ a in range n, f a (coeff p a)

tactic: have := supp_subset_range w
state_before: case ofFinsupp
R : Type u
S : Type v
a b c d : R
n✝ m : ℕ
inst✝¹ : Semiring R
p q r : R[X]
inst✝ : AddCommMonoid S
f : ℕ → R → S
h : ∀ (n : ℕ), f n 0 = 0
n : ℕ
toFinsupp✝ : AddMonoidAlgebra R ℕ
w : natDegree { toFinsupp := toFinsupp✝ } < n
⊢ sum { toFinsupp := toFinsupp✝ } f = ∑ a in range n, f a (coeff { toFinsupp := toFinsupp✝ } a)

tactic: simp only [Polynomial.sum, support, coeff, natDegree, degree] at this⊢
state_before: case ofFinsupp
R : Type u
S : Type v
a b c d : R
n✝ m : ℕ
inst✝¹ : Semiring R
p q r : R[X]
inst✝ : AddCommMonoid S
f : ℕ → R → S
h : ∀ (n : ℕ), f n 0 = 0
n : ℕ
toFinsupp✝ : AddMonoidAlgebra R ℕ
w : natDegree { toFinsupp := toFinsupp✝ } < n
this : support { toFinsupp := toFinsupp✝ } ⊆ range n
⊢ sum { toFinsupp := toFinsupp✝ } f = ∑ a in range n, f a (coeff { toFinsupp := toFinsupp✝ } a)

tactic: exact Finsupp.sum_of_support_subset _ this _ fun n _hn => h n
state_before: case ofFinsupp
R : Type u
S : Type v
a b c d : R
n✝ m : ℕ
inst✝¹ : Semiring R
p q r : R[X]
inst✝ : AddCommMonoid S
f : ℕ → R → S
h : ∀ (n : ℕ), f n 0 = 0
n : ℕ
toFinsupp✝ : AddMonoidAlgebra R ℕ
w : natDegree { toFinsupp := toFinsupp✝ } < n
this : toFinsupp✝.support ⊆ range n
⊢ ∑ x in toFinsupp✝.support, f x (↑toFinsupp✝ x) = ∑ x in range n, f x (↑toFinsupp✝ x)
Theorem: AffineIsometry.angle_map
File: Mathlib/Geometry/Euclidean/Angle/Unoriented/Affine.lean

tactic: simp_rw [angle, ← AffineIsometry.map_vsub, LinearIsometry.angle_map]
state_before: V : Type u_3
P : Type u_4
inst✝⁷ : NormedAddCommGroup V
inst✝⁶ : InnerProductSpace ℝ V
inst✝⁵ : MetricSpace P
inst✝⁴ : NormedAddTorsor V P
V₂ : Type u_1
P₂ : Type u_2
inst✝³ : NormedAddCommGroup V₂
inst✝² : InnerProductSpace ℝ V₂
inst✝¹ : MetricSpace P₂
inst✝ : NormedAddTorsor V₂ P₂
f : P →ᵃⁱ[ℝ] P₂
p₁ p₂ p₃ : P
⊢ ∠ (↑f p₁) (↑f p₂) (↑f p₃) = ∠ p₁ p₂ p₃
Theorem: FirstOrder.Language.LHom.id_onTerm
File: Mathlib/ModelTheory/Syntax.lean

tactic: ext t
state_before: L : Language
L' : Language
M : Type w
N : Type ?u.28071
P : Type ?u.28074
inst✝² : Structure L M
inst✝¹ : Structure L N
inst✝ : Structure L P
α : Type u'
β : Type v'
γ : Type ?u.28102
⊢ onTerm (LHom.id L) = id

tactic: induction' t with _ _ _ _ ih
state_before: case h
L : Language
L' : Language
M : Type w
N : Type ?u.28071
P : Type ?u.28074
inst✝² : Structure L M
inst✝¹ : Structure L N
inst✝ : Structure L P
α : Type u'
β : Type v'
γ : Type ?u.28102
t : Term L α
⊢ onTerm (LHom.id L) t = id t

tactic: rfl
state_before: case h.var
L : Language
L' : Language
M : Type w
N : Type ?u.28071
P : Type ?u.28074
inst✝² : Structure L M
inst✝¹ : Structure L N
inst✝ : Structure L P
α : Type u'
β : Type v'
γ : Type ?u.28102
_a✝ : α
⊢ onTerm (LHom.id L) (var _a✝) = id (var _a✝)

tactic: simp_rw [onTerm, ih]
state_before: case h.func
L : Language
L' : Language
M : Type w
N : Type ?u.28071
P : Type ?u.28074
inst✝² : Structure L M
inst✝¹ : Structure L N
inst✝ : Structure L P
α : Type u'
β : Type v'
γ : Type ?u.28102
l✝ : ℕ
_f✝ : Functions L l✝
_ts✝ : Fin l✝ → Term L α
ih : ∀ (a : Fin l✝), onTerm (LHom.id L) (_ts✝ a) = id (_ts✝ a)
⊢ onTerm (LHom.id L) (func _f✝ _ts✝) = id (func _f✝ _ts✝)

tactic: rfl
state_before: case h.func
L : Language
L' : Language
M : Type w
N : Type ?u.28071
P : Type ?u.28074
inst✝² : Structure L M
inst✝¹ : Structure L N
inst✝ : Structure L P
α : Type u'
β : Type v'
γ : Type ?u.28102
l✝ : ℕ
_f✝ : Functions L l✝
_ts✝ : Fin l✝ → Term L α
ih : ∀ (a : Fin l✝), onTerm (LHom.id L) (_ts✝ a) = id (_ts✝ a)
⊢ (func (onFunction (LHom.id L) _f✝) fun i => id (_ts✝ i)) = id (func _f✝ _ts✝)
Theorem: Sym.sigma_sub_ext
File: Mathlib/Data/Sym/Basic.lean

tactic: rw [← Nat.sub_sub_self (Nat.le_of_lt_succ m₁.1.is_lt), ← m₁.2.2, val_eq_coe, h,
  ← val_eq_coe, m₂.2.2, Nat.sub_sub_self (Nat.le_of_lt_succ m₂.1.is_lt)]
state_before: α : Type u_1
β : Type ?u.53104
n n' m : ℕ
s : Sym α n
a b : α
m₁ m₂ : (i : Fin (n + 1)) × Sym α (n - ↑i)
h : ↑m₁.snd = ↑m₂.snd
⊢ ↑m₁.fst = ↑m₂.fst
Theorem: LocalHomeomorph.extend_preimage_inter_eq
File: Mathlib/Geometry/Manifold/SmoothManifoldWithCorners.lean

tactic: mfld_set_tac
state_before: 𝕜 : Type u_3
E : Type u_1
M : Type u_2
H : Type u_4
E' : Type ?u.160305
M' : Type ?u.160308
H' : Type ?u.160311
inst✝⁸ : NontriviallyNormedField 𝕜
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace 𝕜 E
inst✝⁵ : TopologicalSpace H
inst✝⁴ : TopologicalSpace M
f f' : LocalHomeomorph M H
I : ModelWithCorners 𝕜 E H
inst✝³ : NormedAddCommGroup E'
inst✝² : NormedSpace 𝕜 E'
inst✝¹ : TopologicalSpace H'
inst✝ : TopologicalSpace M'
I' : ModelWithCorners 𝕜 E' H'
x : M
s t : Set M
⊢ ↑(LocalEquiv.symm (extend f I)) ⁻¹' (s ∩ t) ∩ range ↑I =
    ↑(LocalEquiv.symm (extend f I)) ⁻¹' s ∩ range ↑I ∩ ↑(LocalEquiv.symm (extend f I)) ⁻¹' t
Theorem: Function.Commute.iterate_le_of_map_le
File: Mathlib/Order/Iterate.lean

tactic: apply hf.seq_le_seq n
state_before: α : Type u_1
inst✝ : Preorder α
f g : α → α
h : Commute f g
hf : Monotone f
hg : Monotone g
x : α
hx : f x ≤ g x
n : ℕ
⊢ (f^[n]) x ≤ (g^[n]) x

tactic: rfl
state_before: case h₀
α : Type u_1
inst✝ : Preorder α
f g : α → α
h : Commute f g
hf : Monotone f
hg : Monotone g
x : α
hx : f x ≤ g x
n : ℕ
⊢ (f^[0]) x ≤ (g^[0]) x

tactic: intros
state_before: case hx
α : Type u_1
inst✝ : Preorder α
f g : α → α
h : Commute f g
hf : Monotone f
hg : Monotone g
x : α
hx : f x ≤ g x
n : ℕ
⊢ ∀ (k : ℕ), k < n → (f^[k + 1]) x ≤ f ((f^[k]) x)

tactic: rw [iterate_succ_apply']
state_before: case hx
α : Type u_1
inst✝ : Preorder α
f g : α → α
h : Commute f g
hf : Monotone f
hg : Monotone g
x : α
hx : f x ≤ g x
n k✝ : ℕ
a✝ : k✝ < n
⊢ (f^[k✝ + 1]) x ≤ f ((f^[k✝]) x)

tactic: intros
state_before: case hy
α : Type u_1
inst✝ : Preorder α
f g : α → α
h : Commute f g
hf : Monotone f
hg : Monotone g
x : α
hx : f x ≤ g x
n : ℕ
⊢ ∀ (k : ℕ), k < n → f ((g^[k]) x) ≤ (g^[k + 1]) x

tactic: simp [h.iterate_right _ _, hg.iterate _ hx]
state_before: case hy
α : Type u_1
inst✝ : Preorder α
f g : α → α
h : Commute f g
hf : Monotone f
hg : Monotone g
x : α
hx : f x ≤ g x
n k✝ : ℕ
a✝ : k✝ < n
⊢ f ((g^[k✝]) x) ≤ (g^[k✝ + 1]) x
Theorem: pow_eq_one_iff
File: Mathlib/Algebra/GroupPower/Order.lean

tactic: simp only [le_antisymm_iff]
state_before: β : Type ?u.120218
A : Type ?u.120221
G : Type ?u.120224
M : Type u_1
R : Type ?u.120230
inst✝² : Monoid M
inst✝¹ : LinearOrder M
inst✝ : CovariantClass M M (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
x : M
n : ℕ
hn : n ≠ 0
⊢ x ^ n = 1 ↔ x = 1

tactic: rw [pow_le_one_iff hn, one_le_pow_iff hn]
state_before: β : Type ?u.120218
A : Type ?u.120221
G : Type ?u.120224
M : Type u_1
R : Type ?u.120230
inst✝² : Monoid M
inst✝¹ : LinearOrder M
inst✝ : CovariantClass M M (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
x : M
n : ℕ
hn : n ≠ 0
⊢ x ^ n ≤ 1 ∧ 1 ≤ x ^ n ↔ x ≤ 1 ∧ 1 ≤ x
Theorem: ZFSet.mem_prod
File: Mathlib/SetTheory/ZFC/Basic.lean

tactic: simp [prod]
state_before: x y z : ZFSet
⊢ z ∈ prod x y ↔ ∃ a, a ∈ x ∧ ∃ b, b ∈ y ∧ z = pair a b
Theorem: MeasureTheory.StronglyMeasurable.isSeparable_range
File: Mathlib/MeasureTheory/Function/StronglyMeasurable/Basic.lean

tactic: have : IsSeparable (closure (⋃ n, range (hf.approx n))) :=
  (isSeparable_iUnion fun n => (SimpleFunc.finite_range (hf.approx n)).isSeparable).closure
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.132725
ι : Type ?u.132728
inst✝¹ : Countable ι
f g : α → β
m : MeasurableSpace α
inst✝ : TopologicalSpace β
hf : StronglyMeasurable f
⊢ IsSeparable (range f)

tactic: apply this.mono
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.132725
ι : Type ?u.132728
inst✝¹ : Countable ι
f g : α → β
m : MeasurableSpace α
inst✝ : TopologicalSpace β
hf : StronglyMeasurable f
this : IsSeparable (closure (⋃ (n : ℕ), range ↑(StronglyMeasurable.approx hf n)))
⊢ IsSeparable (range f)

tactic: rintro _ ⟨x, rfl⟩
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.132725
ι : Type ?u.132728
inst✝¹ : Countable ι
f g : α → β
m : MeasurableSpace α
inst✝ : TopologicalSpace β
hf : StronglyMeasurable f
this : IsSeparable (closure (⋃ (n : ℕ), range ↑(StronglyMeasurable.approx hf n)))
⊢ range f ⊆ closure (⋃ (n : ℕ), range ↑(StronglyMeasurable.approx hf n))

tactic: apply mem_closure_of_tendsto (hf.tendsto_approx x)
state_before: case intro
α : Type u_1
β : Type u_2
γ : Type ?u.132725
ι : Type ?u.132728
inst✝¹ : Countable ι
f g : α → β
m : MeasurableSpace α
inst✝ : TopologicalSpace β
hf : StronglyMeasurable f
this : IsSeparable (closure (⋃ (n : ℕ), range ↑(StronglyMeasurable.approx hf n)))
x : α
⊢ f x ∈ closure (⋃ (n : ℕ), range ↑(StronglyMeasurable.approx hf n))

tactic: refine eventually_of_forall fun n => ?_
state_before: case intro
α : Type u_1
β : Type u_2
γ : Type ?u.132725
ι : Type ?u.132728
inst✝¹ : Countable ι
f g : α → β
m : MeasurableSpace α
inst✝ : TopologicalSpace β
hf : StronglyMeasurable f
this : IsSeparable (closure (⋃ (n : ℕ), range ↑(StronglyMeasurable.approx hf n)))
x : α
⊢ ∀ᶠ (x_1 : ℕ) in atTop, ↑(StronglyMeasurable.approx hf x_1) x ∈ ⋃ (n : ℕ), range ↑(StronglyMeasurable.approx hf n)

tactic: apply mem_iUnion_of_mem n
state_before: case intro
α : Type u_1
β : Type u_2
γ : Type ?u.132725
ι : Type ?u.132728
inst✝¹ : Countable ι
f g : α → β
m : MeasurableSpace α
inst✝ : TopologicalSpace β
hf : StronglyMeasurable f
this : IsSeparable (closure (⋃ (n : ℕ), range ↑(StronglyMeasurable.approx hf n)))
x : α
n : ℕ
⊢ ↑(StronglyMeasurable.approx hf n) x ∈ ⋃ (n : ℕ), range ↑(StronglyMeasurable.approx hf n)

tactic: exact mem_range_self _
state_before: case intro
α : Type u_1
β : Type u_2
γ : Type ?u.132725
ι : Type ?u.132728
inst✝¹ : Countable ι
f g : α → β
m : MeasurableSpace α
inst✝ : TopologicalSpace β
hf : StronglyMeasurable f
this : IsSeparable (closure (⋃ (n : ℕ), range ↑(StronglyMeasurable.approx hf n)))
x : α
n : ℕ
⊢ ↑(StronglyMeasurable.approx hf n) x ∈ range ↑(StronglyMeasurable.approx hf n)
Theorem: List.length_permutations'Aux
File: Mathlib/Data/List/Perm.lean

tactic: induction' s with y s IH
state_before: α : Type uu
β : Type vv
l₁ l₂ s : List α
x : α
⊢ length (permutations'Aux x s) = length s + 1

tactic: simp
state_before: case nil
α : Type uu
β : Type vv
l₁ l₂ : List α
x : α
⊢ length (permutations'Aux x []) = length [] + 1

tactic: simpa using IH
state_before: case cons
α : Type uu
β : Type vv
l₁ l₂ : List α
x y : α
s : List α
IH : length (permutations'Aux x s) = length s + 1
⊢ length (permutations'Aux x (y :: s)) = length (y :: s) + 1
Theorem: Homotopy.nullHomotopicMap_f_of_not_rel_right
File: Mathlib/Algebra/Homology/Homotopy.lean

tactic: dsimp only [nullHomotopicMap]
state_before: ι : Type u_1
V : Type u
inst✝¹ : Category V
inst✝ : Preadditive V
c : ComplexShape ι
C D E : HomologicalComplex V c
f g : C ⟶ D
h k : D ⟶ E
i k₁ k₀ : ι
r₁₀ : ComplexShape.Rel c k₁ k₀
hk₁ : ∀ (l : ι), ¬ComplexShape.Rel c l k₁
hom : (i j : ι) → X C i ⟶ X D j
⊢ Hom.f (nullHomotopicMap hom) k₁ = d C k₁ k₀ ≫ hom k₀ k₁

tactic: rw [dNext_eq hom r₁₀, prevD, AddMonoidHom.mk'_apply, D.shape, comp_zero, add_zero]
state_before: ι : Type u_1
V : Type u
inst✝¹ : Category V
inst✝ : Preadditive V
c : ComplexShape ι
C D E : HomologicalComplex V c
f g : C ⟶ D
h k : D ⟶ E
i k₁ k₀ : ι
r₁₀ : ComplexShape.Rel c k₁ k₀
hk₁ : ∀ (l : ι), ¬ComplexShape.Rel c l k₁
hom : (i j : ι) → X C i ⟶ X D j
⊢ ↑(dNext k₁) hom + ↑(prevD k₁) hom = d C k₁ k₀ ≫ hom k₀ k₁

tactic: exact hk₁ _
state_before: case a
ι : Type u_1
V : Type u
inst✝¹ : Category V
inst✝ : Preadditive V
c : ComplexShape ι
C D E : HomologicalComplex V c
f g : C ⟶ D
h k : D ⟶ E
i k₁ k₀ : ι
r₁₀ : ComplexShape.Rel c k₁ k₀
hk₁ : ∀ (l : ι), ¬ComplexShape.Rel c l k₁
hom : (i j : ι) → X C i ⟶ X D j
⊢ ¬ComplexShape.Rel c (ComplexShape.prev c k₁) k₁
Theorem: TopCat.Presheaf.SheafConditionPairwiseIntersections.map_diagram
File: Mathlib/Topology/Sheaves/Functors.lean

tactic: have obj_eq : ∀ (j : Pairwise ι), (Pairwise.diagram U ⋙ Opens.map f).obj j =
  (Pairwise.diagram ((Opens.map f).toPrefunctor.obj ∘ U)).obj j
state_before: C : Type u
inst✝ : Category C
X Y : TopCat
f : X ⟶ Y
ι : Type w
U : ι → Opens ↑Y
⊢ Pairwise.diagram U ⋙ Opens.map f = Pairwise.diagram ((Opens.map f).toPrefunctor.obj ∘ U)

tactic: . rintro ⟨i⟩ <;> rfl
state_before: case obj_eq
C : Type u
inst✝ : Category C
X Y : TopCat
f : X ⟶ Y
ι : Type w
U : ι → Opens ↑Y
⊢ ∀ (j : CategoryTheory.Pairwise ι),
    (Pairwise.diagram U ⋙ Opens.map f).obj j = (Pairwise.diagram ((Opens.map f).toPrefunctor.obj ∘ U)).obj j

C : Type u
inst✝ : Category C
X Y : TopCat
f : X ⟶ Y
ι : Type w
U : ι → Opens ↑Y
obj_eq :
  ∀ (j : CategoryTheory.Pairwise ι),
    (Pairwise.diagram U ⋙ Opens.map f).obj j = (Pairwise.diagram ((Opens.map f).toPrefunctor.obj ∘ U)).obj j
⊢ Pairwise.diagram U ⋙ Opens.map f = Pairwise.diagram ((Opens.map f).toPrefunctor.obj ∘ U)

tactic: refine Functor.hext obj_eq ?_
state_before: C : Type u
inst✝ : Category C
X Y : TopCat
f : X ⟶ Y
ι : Type w
U : ι → Opens ↑Y
obj_eq :
  ∀ (j : CategoryTheory.Pairwise ι),
    (Pairwise.diagram U ⋙ Opens.map f).obj j = (Pairwise.diagram ((Opens.map f).toPrefunctor.obj ∘ U)).obj j
⊢ Pairwise.diagram U ⋙ Opens.map f = Pairwise.diagram ((Opens.map f).toPrefunctor.obj ∘ U)

tactic: intro i j g
state_before: C : Type u
inst✝ : Category C
X Y : TopCat
f : X ⟶ Y
ι : Type w
U : ι → Opens ↑Y
obj_eq :
  ∀ (j : CategoryTheory.Pairwise ι),
    (Pairwise.diagram U ⋙ Opens.map f).obj j = (Pairwise.diagram ((Opens.map f).toPrefunctor.obj ∘ U)).obj j
⊢ ∀ (X_1 Y_1 : CategoryTheory.Pairwise ι) (f_1 : X_1 ⟶ Y_1),
    HEq ((Pairwise.diagram U ⋙ Opens.map f).map f_1) ((Pairwise.diagram ((Opens.map f).toPrefunctor.obj ∘ U)).map f_1)

tactic: apply Subsingleton.helim
state_before: C : Type u
inst✝ : Category C
X Y : TopCat
f : X ⟶ Y
ι : Type w
U : ι → Opens ↑Y
obj_eq :
  ∀ (j : CategoryTheory.Pairwise ι),
    (Pairwise.diagram U ⋙ Opens.map f).obj j = (Pairwise.diagram ((Opens.map f).toPrefunctor.obj ∘ U)).obj j
i j : CategoryTheory.Pairwise ι
g : i ⟶ j
⊢ HEq ((Pairwise.diagram U ⋙ Opens.map f).map g) ((Pairwise.diagram ((Opens.map f).toPrefunctor.obj ∘ U)).map g)

tactic: rw [obj_eq, obj_eq]
state_before: case h₂
C : Type u
inst✝ : Category C
X Y : TopCat
f : X ⟶ Y
ι : Type w
U : ι → Opens ↑Y
obj_eq :
  ∀ (j : CategoryTheory.Pairwise ι),
    (Pairwise.diagram U ⋙ Opens.map f).obj j = (Pairwise.diagram ((Opens.map f).toPrefunctor.obj ∘ U)).obj j
i j : CategoryTheory.Pairwise ι
g : i ⟶ j
⊢ ((Pairwise.diagram U ⋙ Opens.map f).obj i ⟶ (Pairwise.diagram U ⋙ Opens.map f).obj j) =
    ((Pairwise.diagram ((Opens.map f).toPrefunctor.obj ∘ U)).obj i ⟶
      (Pairwise.diagram ((Opens.map f).toPrefunctor.obj ∘ U)).obj j)

tactic: rintro ⟨i⟩ <;> rfl
state_before: case obj_eq
C : Type u
inst✝ : Category C
X Y : TopCat
f : X ⟶ Y
ι : Type w
U : ι → Opens ↑Y
⊢ ∀ (j : CategoryTheory.Pairwise ι),
    (Pairwise.diagram U ⋙ Opens.map f).obj j = (Pairwise.diagram ((Opens.map f).toPrefunctor.obj ∘ U)).obj j
Theorem: MeasureTheory.Measure.sub_apply_eq_zero_of_restrict_le_restrict
File: Mathlib/MeasureTheory/Measure/Sub.lean

tactic: rw [← restrict_apply_self, restrict_sub_eq_restrict_sub_restrict, sub_eq_zero_of_le] <;> simp [*]
state_before: α : Type u_1
m : MeasurableSpace α
μ ν : Measure α
s : Set α
h_le : restrict μ s ≤ restrict ν s
h_meas_s : MeasurableSet s
⊢ ↑↑(μ - ν) s = 0
Theorem: Bornology.isBounded_singleton
File: Mathlib/Topology/Bornology/Basic.lean

tactic: rw [isBounded_def]
state_before: ι : Type ?u.4415
α : Type u_1
β : Type ?u.4421
inst✝ : Bornology α
s t : Set α
x : α
⊢ IsBounded {x}

tactic: exact le_cofinite _ (finite_singleton x).compl_mem_cofinite
state_before: ι : Type ?u.4415
α : Type u_1
β : Type ?u.4421
inst✝ : Bornology α
s t : Set α
x : α
⊢ {x}ᶜ ∈ cobounded α