tasksource/leandojo huggingface dataset:
Theorem: Subgroup.le_pi_iff
File: Mathlib/GroupTheory/Subgroup/Basic.lean

tactic: constructor
state_before: G : Type ?u.321783
G' : Type ?u.321786
inst✝⁵ : Group G
inst✝⁴ : Group G'
A : Type ?u.321795
inst✝³ : AddGroup A
H✝ K : Subgroup G
k : Set G
N : Type ?u.321816
inst✝² : Group N
P : Type ?u.321822
inst✝¹ : Group P
η : Type u_1
f : η → Type u_2
inst✝ : (i : η) → Group (f i)
I : Set η
H : (i : η) → Subgroup (f i)
J : Subgroup ((i : η) → f i)
⊢ J ≤ pi I H ↔ ∀ (i : η), i ∈ I → map (Pi.evalMonoidHom f i) J ≤ H i

tactic: intro h i hi
state_before: case mp
G : Type ?u.321783
G' : Type ?u.321786
inst✝⁵ : Group G
inst✝⁴ : Group G'
A : Type ?u.321795
inst✝³ : AddGroup A
H✝ K : Subgroup G
k : Set G
N : Type ?u.321816
inst✝² : Group N
P : Type ?u.321822
inst✝¹ : Group P
η : Type u_1
f : η → Type u_2
inst✝ : (i : η) → Group (f i)
I : Set η
H : (i : η) → Subgroup (f i)
J : Subgroup ((i : η) → f i)
⊢ J ≤ pi I H → ∀ (i : η), i ∈ I → map (Pi.evalMonoidHom f i) J ≤ H i

tactic: rintro _ ⟨x, hx, rfl⟩
state_before: case mp
G : Type ?u.321783
G' : Type ?u.321786
inst✝⁵ : Group G
inst✝⁴ : Group G'
A : Type ?u.321795
inst✝³ : AddGroup A
H✝ K : Subgroup G
k : Set G
N : Type ?u.321816
inst✝² : Group N
P : Type ?u.321822
inst✝¹ : Group P
η : Type u_1
f : η → Type u_2
inst✝ : (i : η) → Group (f i)
I : Set η
H : (i : η) → Subgroup (f i)
J : Subgroup ((i : η) → f i)
h : J ≤ pi I H
i : η
hi : i ∈ I
⊢ map (Pi.evalMonoidHom f i) J ≤ H i

tactic: exact (h hx) _ hi
state_before: case mp.intro.intro
G : Type ?u.321783
G' : Type ?u.321786
inst✝⁵ : Group G
inst✝⁴ : Group G'
A : Type ?u.321795
inst✝³ : AddGroup A
H✝ K : Subgroup G
k : Set G
N : Type ?u.321816
inst✝² : Group N
P : Type ?u.321822
inst✝¹ : Group P
η : Type u_1
f : η → Type u_2
inst✝ : (i : η) → Group (f i)
I : Set η
H : (i : η) → Subgroup (f i)
J : Subgroup ((i : η) → f i)
h : J ≤ pi I H
i : η
hi : i ∈ I
x : (i : η) → f i
hx : x ∈ ↑J
⊢ ↑(Pi.evalMonoidHom f i) x ∈ H i

tactic: intro h x hx i hi
state_before: case mpr
G : Type ?u.321783
G' : Type ?u.321786
inst✝⁵ : Group G
inst✝⁴ : Group G'
A : Type ?u.321795
inst✝³ : AddGroup A
H✝ K : Subgroup G
k : Set G
N : Type ?u.321816
inst✝² : Group N
P : Type ?u.321822
inst✝¹ : Group P
η : Type u_1
f : η → Type u_2
inst✝ : (i : η) → Group (f i)
I : Set η
H : (i : η) → Subgroup (f i)
J : Subgroup ((i : η) → f i)
⊢ (∀ (i : η), i ∈ I → map (Pi.evalMonoidHom f i) J ≤ H i) → J ≤ pi I H

tactic: refine' h i hi ⟨_, hx, rfl⟩
state_before: case mpr
G : Type ?u.321783
G' : Type ?u.321786
inst✝⁵ : Group G
inst✝⁴ : Group G'
A : Type ?u.321795
inst✝³ : AddGroup A
H✝ K : Subgroup G
k : Set G
N : Type ?u.321816
inst✝² : Group N
P : Type ?u.321822
inst✝¹ : Group P
η : Type u_1
f : η → Type u_2
inst✝ : (i : η) → Group (f i)
I : Set η
H : (i : η) → Subgroup (f i)
J : Subgroup ((i : η) → f i)
h : ∀ (i : η), i ∈ I → map (Pi.evalMonoidHom f i) J ≤ H i
x : (i : η) → f i
hx : x ∈ J
i : η
hi : i ∈ I
⊢ x i ∈ (fun i => ((fun i => (H i).toSubmonoid) i).carrier) i
Theorem: Polynomial.X_pow_sub_one_dvd_prod_cyclotomic
File: Mathlib/RingTheory/Polynomial/Cyclotomic/Basic.lean

tactic: replace hm := Nat.mem_properDivisors.2
  ⟨hm, lt_of_le_of_ne (Nat.divisor_le (Nat.mem_divisors.2 ⟨hm, hpos.ne'⟩)) hdiff⟩
state_before: R : Type u_1
inst✝ : CommRing R
n m : ℕ
hpos : 0 < n
hm : m ∣ n
hdiff : m ≠ n
⊢ X ^ m - 1 ∣ ∏ i in Nat.properDivisors n, cyclotomic i R

tactic: rw [← Finset.sdiff_union_of_subset (Nat.divisors_subset_properDivisors (ne_of_lt hpos).symm
  (Nat.mem_properDivisors.1 hm).1 (ne_of_lt (Nat.mem_properDivisors.1 hm).2)),
  Finset.prod_union Finset.sdiff_disjoint,
  prod_cyclotomic_eq_X_pow_sub_one (Nat.pos_of_mem_properDivisors hm)]
state_before: R : Type u_1
inst✝ : CommRing R
n m : ℕ
hpos : 0 < n
hdiff : m ≠ n
hm : m ∈ Nat.properDivisors n
⊢ X ^ m - 1 ∣ ∏ i in Nat.properDivisors n, cyclotomic i R

tactic: exact ⟨∏ x : ℕ in n.properDivisors \ m.divisors, cyclotomic x R, by rw [mul_comm]⟩
state_before: R : Type u_1
inst✝ : CommRing R
n m : ℕ
hpos : 0 < n
hdiff : m ≠ n
hm : m ∈ Nat.properDivisors n
⊢ X ^ m - 1 ∣ (∏ x in Nat.properDivisors n \ Nat.divisors m, cyclotomic x R) * (X ^ m - 1)

tactic: rw [mul_comm]
state_before: R : Type u_1
inst✝ : CommRing R
n m : ℕ
hpos : 0 < n
hdiff : m ≠ n
hm : m ∈ Nat.properDivisors n
⊢ (∏ x in Nat.properDivisors n \ Nat.divisors m, cyclotomic x R) * (X ^ m - 1) =
    (X ^ m - 1) * ∏ x in Nat.properDivisors n \ Nat.divisors m, cyclotomic x R
Theorem: norm_inf_le_add
File: Mathlib/Analysis/Normed/Order/Lattice.lean

tactic: have h : ‖x ⊓ y - 0 ⊓ 0‖ ≤ ‖x - 0‖ + ‖y - 0‖ := norm_inf_sub_inf_le_add_norm x y 0 0
state_before: α : Type u_1
inst✝ : NormedLatticeAddCommGroup α
x y : α
⊢ ‖x ⊓ y‖ ≤ ‖x‖ + ‖y‖

tactic: simpa only [inf_idem, sub_zero] using h
state_before: α : Type u_1
inst✝ : NormedLatticeAddCommGroup α
x y : α
h : ‖x ⊓ y - 0 ⊓ 0‖ ≤ ‖x - 0‖ + ‖y - 0‖
⊢ ‖x ⊓ y‖ ≤ ‖x‖ + ‖y‖
Theorem: heq_imp_of_eq_imp
File: Mathlib/Tactic/Congr!.lean

tactic: cases he
state_before: α✝ : Sort u_1
x y : α✝
p : HEq x y → Prop
h : ∀ (he : x = y), p (_ : HEq x y)
he : HEq x y
⊢ p he

tactic: exact h rfl
state_before: case refl
α✝ : Sort u_1
x : α✝
p : HEq x x → Prop
h : ∀ (he : x = x), p (_ : HEq x x)
⊢ p (_ : HEq x x)
Theorem: Complex.continuousWithinAt_log_of_re_neg_of_im_zero
File: Mathlib/Analysis/SpecialFunctions/Complex/Log.lean

tactic: convert
  (continuous_ofReal.continuousAt.comp_continuousWithinAt
          (continuous_abs.continuousWithinAt.log _)).tendsto.add
    ((continuous_ofReal.continuousAt.comp_continuousWithinAt <|
          continuousWithinAt_arg_of_re_neg_of_im_zero hre him).mul
      tendsto_const_nhds) using 1
state_before: z : ℂ
hre : z.re < 0
him : z.im = 0
⊢ ContinuousWithinAt log {z | 0 ≤ z.im} z

tactic: lift z to ℝ using him
state_before: case convert_1
z : ℂ
hre : z.re < 0
him : z.im = 0
⊢ ↑abs z ≠ 0

tactic: simpa using hre.ne
state_before: case convert_1.intro
z : ℝ
hre : (↑z).re < 0
⊢ ↑abs ↑z ≠ 0
Theorem: Pell.yn_modEq_two
File: Mathlib/NumberTheory/PellMatiyasevic.lean

tactic: simp
state_before: a : ℕ
a1 : 1 < a
⊢ yn a1 0 ≡ 0 [MOD 2]

tactic: simp
state_before: a : ℕ
a1 : 1 < a
⊢ yn a1 1 ≡ 1 [MOD 2]

tactic: rw [yn_succ_succ, mul_assoc, (by ring : n + 2 + n = 2 * (n + 1))]
state_before: a : ℕ
a1 : 1 < a
n : ℕ
⊢ yn a1 (n + 2) + yn a1 n ≡ n + 2 + n [MOD 2]

tactic: exact (dvd_mul_right 2 _).modEq_zero_nat.trans (dvd_mul_right 2 _).zero_modEq_nat
state_before: a : ℕ
a1 : 1 < a
n : ℕ
⊢ 2 * (a * yn a1 (n + 1)) ≡ 2 * (n + 1) [MOD 2]

tactic: ring
state_before: a : ℕ
a1 : 1 < a
n : ℕ
⊢ n + 2 + n = 2 * (n + 1)
Theorem: Filter.pi_neBot
File: Mathlib/Order/Filter/Pi.lean

tactic: simp [neBot_iff]
state_before: ι : Type u_2
α : ι → Type u_1
f f₁ f₂ : (i : ι) → Filter (α i)
s : (i : ι) → Set (α i)
⊢ NeBot (pi f) ↔ ∀ (i : ι), NeBot (f i)
Theorem: Int.even_sub'
File: Mathlib/Data/Int/Parity.lean

tactic: rw [even_sub, even_iff_not_odd, even_iff_not_odd, not_iff_not]
state_before: m n : ℤ
⊢ Even (m - n) ↔ (Odd m ↔ Odd n)
Theorem: MeasureTheory.ProbabilityMeasure.ennreal_coeFn_eq_coeFn_toMeasure
File: Mathlib/MeasureTheory/Measure/ProbabilityMeasure.lean

tactic: rw [← coeFn_comp_toFiniteMeasure_eq_coeFn, FiniteMeasure.ennreal_coeFn_eq_coeFn_toMeasure,
  toMeasure_comp_toFiniteMeasure_eq_toMeasure]
state_before: Ω : Type u_1
inst✝ : MeasurableSpace Ω
ν : ProbabilityMeasure Ω
s : Set Ω
⊢ ↑((fun s => ENNReal.toNNReal (↑↑↑ν s)) s) = ↑↑↑ν s
Theorem: Real.sInf_smul_of_nonpos
File: Mathlib/Data/Real/Pointwise.lean

tactic: obtain rfl | hs := s.eq_empty_or_nonempty
state_before: ι : Sort ?u.7076
α : Type u_1
inst✝² : LinearOrderedField α
inst✝¹ : Module α ℝ
inst✝ : OrderedSMul α ℝ
a : α
ha : a ≤ 0
s : Set ℝ
⊢ sInf (a • s) = a • sSup s

tactic: obtain rfl | ha' := ha.eq_or_lt
state_before: case inr
ι : Sort ?u.7076
α : Type u_1
inst✝² : LinearOrderedField α
inst✝¹ : Module α ℝ
inst✝ : OrderedSMul α ℝ
a : α
ha : a ≤ 0
s : Set ℝ
hs : Set.Nonempty s
⊢ sInf (a • s) = a • sSup s

tactic: by_cases h : BddAbove s
state_before: case inr.inr
ι : Sort ?u.7076
α : Type u_1
inst✝² : LinearOrderedField α
inst✝¹ : Module α ℝ
inst✝ : OrderedSMul α ℝ
a : α
ha : a ≤ 0
s : Set ℝ
hs : Set.Nonempty s
ha' : a < 0
⊢ sInf (a • s) = a • sSup s

tactic: rw [smul_set_empty, Real.sInf_empty, Real.sSup_empty, smul_zero]
state_before: case inl
ι : Sort ?u.7076
α : Type u_1
inst✝² : LinearOrderedField α
inst✝¹ : Module α ℝ
inst✝ : OrderedSMul α ℝ
a : α
ha : a ≤ 0
⊢ sInf (a • ∅) = a • sSup ∅

tactic: rw [zero_smul_set hs, zero_smul]
state_before: case inr.inl
ι : Sort ?u.7076
α : Type u_1
inst✝² : LinearOrderedField α
inst✝¹ : Module α ℝ
inst✝ : OrderedSMul α ℝ
s : Set ℝ
hs : Set.Nonempty s
ha : 0 ≤ 0
⊢ sInf (0 • s) = 0 • sSup s

tactic: exact csInf_singleton 0
state_before: case inr.inl
ι : Sort ?u.7076
α : Type u_1
inst✝² : LinearOrderedField α
inst✝¹ : Module α ℝ
inst✝ : OrderedSMul α ℝ
s : Set ℝ
hs : Set.Nonempty s
ha : 0 ≤ 0
⊢ sInf 0 = 0

tactic: exact ((OrderIso.smulLeftDual ℝ ha').map_csSup' hs h).symm
state_before: case pos
ι : Sort ?u.7076
α : Type u_1
inst✝² : LinearOrderedField α
inst✝¹ : Module α ℝ
inst✝ : OrderedSMul α ℝ
a : α
ha : a ≤ 0
s : Set ℝ
hs : Set.Nonempty s
ha' : a < 0
h : BddAbove s
⊢ sInf (a • s) = a • sSup s

tactic: rw [Real.sInf_of_not_bddBelow (mt (bddBelow_smul_iff_of_neg ha').1 h),
    Real.sSup_of_not_bddAbove h, smul_zero]
state_before: case neg
ι : Sort ?u.7076
α : Type u_1
inst✝² : LinearOrderedField α
inst✝¹ : Module α ℝ
inst✝ : OrderedSMul α ℝ
a : α
ha : a ≤ 0
s : Set ℝ
hs : Set.Nonempty s
ha' : a < 0
h : ¬BddAbove s
⊢ sInf (a • s) = a • sSup s
Theorem: leftCoset_rightCoset
File: Mathlib/GroupTheory/Coset.lean

tactic: simp [leftCoset, rightCoset, (image_comp _ _ _).symm, Function.comp, mul_assoc]
state_before: α : Type u_1
inst✝ : Semigroup α
s : Set α
a b : α
⊢ a *l s *r b = a *l (s *r b)
Theorem: CategoryTheory.Presieve.isSheafFor_singleton_iso
File: Mathlib/CategoryTheory/Sites/SheafOfTypes.lean

tactic: intro x _
state_before: C : Type u₁
inst✝ : Category C
P✝ Q U : Cᵒᵖ ⥤ Type w
X Y : C
S : Sieve X
R : Presieve X
J J₂ : GrothendieckTopology C
P : Cᵒᵖ ⥤ Type w
⊢ IsSheafFor P (singleton (𝟙 X))

tactic: refine' ⟨x _ (Presieve.singleton_self _), _, _⟩
state_before: C : Type u₁
inst✝ : Category C
P✝ Q U : Cᵒᵖ ⥤ Type w
X Y : C
S : Sieve X
R : Presieve X
J J₂ : GrothendieckTopology C
P : Cᵒᵖ ⥤ Type w
x : FamilyOfElements P (singleton (𝟙 X))
a✝ : FamilyOfElements.Compatible x
⊢ ∃! t, FamilyOfElements.IsAmalgamation x t

tactic: rintro _ _ ⟨rfl, rfl⟩
state_before: case refine'_1
C : Type u₁
inst✝ : Category C
P✝ Q U : Cᵒᵖ ⥤ Type w
X Y : C
S : Sieve X
R : Presieve X
J J₂ : GrothendieckTopology C
P : Cᵒᵖ ⥤ Type w
x : FamilyOfElements P (singleton (𝟙 X))
a✝ : FamilyOfElements.Compatible x
⊢ (fun t => FamilyOfElements.IsAmalgamation x t) (x (𝟙 X) (_ : singleton (𝟙 X) (𝟙 X)))

tactic: simp
state_before: case refine'_1.mk
C : Type u₁
inst✝ : Category C
P✝ Q U : Cᵒᵖ ⥤ Type w
X Y✝ : C
S : Sieve X
R : Presieve X
J J₂ : GrothendieckTopology C
P : Cᵒᵖ ⥤ Type w
x : FamilyOfElements P (singleton (𝟙 X))
a✝ : FamilyOfElements.Compatible x
Y : C
⊢ P.map (𝟙 X).op (x (𝟙 X) (_ : singleton (𝟙 X) (𝟙 X))) = x (𝟙 X) (_ : singleton' (𝟙 X) (𝟙 X))

tactic: intro t ht
state_before: case refine'_2
C : Type u₁
inst✝ : Category C
P✝ Q U : Cᵒᵖ ⥤ Type w
X Y : C
S : Sieve X
R : Presieve X
J J₂ : GrothendieckTopology C
P : Cᵒᵖ ⥤ Type w
x : FamilyOfElements P (singleton (𝟙 X))
a✝ : FamilyOfElements.Compatible x
⊢ ∀ (y : P.obj X.op), (fun t => FamilyOfElements.IsAmalgamation x t) y → y = x (𝟙 X) (_ : singleton (𝟙 X) (𝟙 X))

tactic: simpa using ht _ (Presieve.singleton_self _)
state_before: case refine'_2
C : Type u₁
inst✝ : Category C
P✝ Q U : Cᵒᵖ ⥤ Type w
X Y : C
S : Sieve X
R : Presieve X
J J₂ : GrothendieckTopology C
P : Cᵒᵖ ⥤ Type w
x : FamilyOfElements P (singleton (𝟙 X))
a✝ : FamilyOfElements.Compatible x
t : P.obj X.op
ht : FamilyOfElements.IsAmalgamation x t
⊢ t = x (𝟙 X) (_ : singleton (𝟙 X) (𝟙 X))
Theorem: ENNReal.div_le_iff_le_mul
File: Mathlib/Data/Real/ENNReal.lean

tactic: suffices a * b⁻¹ ≤ c ↔ a ≤ c / b⁻¹ by simpa [div_eq_mul_inv]
state_before: α : Type ?u.282672
β : Type ?u.282675
a b c d : ℝ≥0∞
r p q : ℝ≥0
hb0 : b ≠ 0 ∨ c ≠ ⊤
hbt : b ≠ ⊤ ∨ c ≠ 0
⊢ a / b ≤ c ↔ a ≤ c * b

tactic: refine' (ENNReal.le_div_iff_mul_le _ _).symm <;> simpa
state_before: α : Type ?u.282672
β : Type ?u.282675
a b c d : ℝ≥0∞
r p q : ℝ≥0
hb0 : b ≠ 0 ∨ c ≠ ⊤
hbt : b ≠ ⊤ ∨ c ≠ 0
⊢ a * b⁻¹ ≤ c ↔ a ≤ c / b⁻¹

tactic: simpa [div_eq_mul_inv]
state_before: α : Type ?u.282672
β : Type ?u.282675
a b c d : ℝ≥0∞
r p q : ℝ≥0
hb0 : b ≠ 0 ∨ c ≠ ⊤
hbt : b ≠ ⊤ ∨ c ≠ 0
this : a * b⁻¹ ≤ c ↔ a ≤ c / b⁻¹
⊢ a / b ≤ c ↔ a ≤ c * b
Theorem: eq_of_div_eq_one
File: Mathlib/Algebra/Group/Basic.lean

tactic: rwa [← div_eq_mul_inv]
state_before: α : Type u_1
β : Type ?u.22837
G : Type ?u.22840
inst✝ : DivisionMonoid α
a b c : α
h : a / b = 1
⊢ a * b⁻¹ = 1
Theorem: Order.IsSuccLimit.isMin
File: Mathlib/Order/SuccPred/Limit.lean

tactic: revert h
state_before: α : Type u_1
inst✝² : PartialOrder α
inst✝¹ : SuccOrder α
a b✝ : α
C : α → Sort ?u.9479
inst✝ : IsSuccArchimedean α
h : IsSuccLimit a
b : α
hb : b ≤ a
⊢ a ≤ b

tactic: refine' Succ.rec (fun _ => le_rfl) (fun c _ H hc => _) hb
state_before: α : Type u_1
inst✝² : PartialOrder α
inst✝¹ : SuccOrder α
a b✝ : α
C : α → Sort ?u.9479
inst✝ : IsSuccArchimedean α
b : α
hb : b ≤ a
⊢ IsSuccLimit a → a ≤ b

tactic: have := hc.isMax.succ_eq
state_before: α : Type u_1
inst✝² : PartialOrder α
inst✝¹ : SuccOrder α
a b✝ : α
C : α → Sort ?u.9479
inst✝ : IsSuccArchimedean α
b : α
hb : b ≤ a
c : α
x✝ : b ≤ c
H : IsSuccLimit c → c ≤ b
hc : IsSuccLimit (succ c)
⊢ succ c ≤ b

tactic: rw [this] at hc⊢
state_before: α : Type u_1
inst✝² : PartialOrder α
inst✝¹ : SuccOrder α
a b✝ : α
C : α → Sort ?u.9479
inst✝ : IsSuccArchimedean α
b : α
hb : b ≤ a
c : α
x✝ : b ≤ c
H : IsSuccLimit c → c ≤ b
hc : IsSuccLimit (succ c)
this : succ c = c
⊢ succ c ≤ b

tactic: exact H hc
state_before: α : Type u_1
inst✝² : PartialOrder α
inst✝¹ : SuccOrder α
a b✝ : α
C : α → Sort ?u.9479
inst✝ : IsSuccArchimedean α
b : α
hb : b ≤ a
c : α
x✝ : b ≤ c
H : IsSuccLimit c → c ≤ b
hc : IsSuccLimit c
this : succ c = c
⊢ c ≤ b
Theorem: Cardinal.zero_toNat
File: Mathlib/SetTheory/Cardinal/Basic.lean

tactic: rw [← toNat_cast 0, Nat.cast_zero]
state_before: α β : Type u
⊢ ↑toNat 0 = 0
Theorem: List.cons_eq_append
File: Std/Data/List/Lemmas.lean

tactic: rw [eq_comm, append_eq_cons]
state_before: α✝ : Type u_1
x : α✝
c a b : List α✝
⊢ x :: c = a ++ b ↔ a = [] ∧ b = x :: c ∨ ∃ a', a = x :: a' ∧ c = a' ++ b
Theorem: Finsupp.cons_ne_zero_iff
File: Mathlib/Data/Finsupp/Fin.lean

tactic: refine' ⟨fun h => _, fun h => h.casesOn cons_ne_zero_of_left cons_ne_zero_of_right⟩
state_before: n : ℕ
i : Fin n
M : Type u_1
inst✝ : Zero M
y : M
t : Fin (n + 1) →₀ M
s : Fin n →₀ M
⊢ cons y s ≠ 0 ↔ y ≠ 0 ∨ s ≠ 0

tactic: refine' imp_iff_not_or.1 fun h' c => h _
state_before: n : ℕ
i : Fin n
M : Type u_1
inst✝ : Zero M
y : M
t : Fin (n + 1) →₀ M
s : Fin n →₀ M
h : cons y s ≠ 0
⊢ y ≠ 0 ∨ s ≠ 0

tactic: rw [h', c, Finsupp.cons_zero_zero]
state_before: n : ℕ
i : Fin n
M : Type u_1
inst✝ : Zero M
y : M
t : Fin (n + 1) →₀ M
s : Fin n →₀ M
h : cons y s ≠ 0
h' : y = 0
c : s = 0
⊢ cons y s = 0
Theorem: let_body_eq
File: Mathlib/Init/Logic.lean

tactic: exact h _ ▸ rfl
state_before: a✝ b c d : Prop
p : ?m.30550
α : Sort v
β : α → Sort u
a : α
b₁ b₂ : (x : α) → β x
h : ∀ (x : α), b₁ x = b₂ x
⊢ (let x := a;
    b₁ x) =
    let x := a;
    b₂ x
Theorem: FractionalIdeal.coe_ideal_span_singleton_mul_inv
File: Mathlib/RingTheory/DedekindDomain/Ideal.lean

tactic: rw [coeIdeal_span_singleton,
  spanSingleton_mul_inv K <|
    (map_ne_zero_iff _ <| NoZeroSMulDivisors.algebraMap_injective R₁ K).mpr hx]
state_before: R : Type ?u.55685
A : Type ?u.55688
K : Type u_2
inst✝¹⁰ : CommRing R
inst✝⁹ : CommRing A
inst✝⁸ : Field K
inst✝⁷ : IsDomain A
R₁ : Type u_1
inst✝⁶ : CommRing R₁
inst✝⁵ : IsDomain R₁
inst✝⁴ : Algebra R₁ K
inst✝³ : IsFractionRing R₁ K
I J : FractionalIdeal R₁⁰ K
K' : Type ?u.56699
inst✝² : Field K'
inst✝¹ : Algebra R₁ K'
inst✝ : IsFractionRing R₁ K'
x : R₁
hx : x ≠ 0
⊢ ↑(Ideal.span {x}) * (↑(Ideal.span {x}))⁻¹ = 1
Theorem: Fin.induction_zero
File: Mathlib/Data/Fin/Basic.lean

tactic: simp only [mk_zero]
state_before: n m : ℕ
C : Fin (n + 1) → Sort u_1
⊢ { val := 0, isLt := (_ : 0 < Nat.succ n) } = 0

tactic: simp [← h] at h0
state_before: n m : ℕ
C : Fin (n + 1) → Sort u_1
this : { val := 0, isLt := (_ : 0 < Nat.succ n) } = 0
i : Fin (n + 1)
h : { val := 0, isLt := (_ : 0 < Nat.succ n) } = i
h0 : C i
hs : (i : Fin n) → C (↑castSucc i) → C (succ i)
⊢ C 0

tactic: exact h0
state_before: n m : ℕ
C : Fin (n + 1) → Sort u_1
this : { val := 0, isLt := (_ : 0 < Nat.succ n) } = 0
i : Fin (n + 1)
h : { val := 0, isLt := (_ : 0 < Nat.succ n) } = i
hs : (i : Fin n) → C (↑castSucc i) → C (succ i)
h0 : C 0
⊢ C 0

tactic: intros h0 _
state_before: n m : ℕ
C : Fin (n + 1) → Sort u_1
this : { val := 0, isLt := (_ : 0 < Nat.succ n) } = 0
⊢ (fun i h =>
      ∀ (h0 : C i) (hs : (i : Fin n) → C (↑castSucc i) → C (succ i)),
        (let_fun this := fun i_1 =>
              induction (Eq.mp (_ : C i = C { val := 0, isLt := (_ : 0 < Nat.succ n) }) h0) hs i_1;
            this)
            i =
          h0)
    { val := 0, isLt := (_ : 0 < Nat.succ n) }
    (_ : { val := 0, isLt := (_ : 0 < Nat.succ n) } = { val := 0, isLt := (_ : 0 < Nat.succ n) })

tactic: simp [induction]
state_before: n m : ℕ
C : Fin (n + 1) → Sort u_1
this : { val := 0, isLt := (_ : 0 < Nat.succ n) } = 0
h0 : C { val := 0, isLt := (_ : 0 < Nat.succ n) }
hs✝ : (i : Fin n) → C (↑castSucc i) → C (succ i)
⊢ (let_fun this := fun i =>
        induction
          (Eq.mp (_ : C { val := 0, isLt := (_ : 0 < Nat.succ n) } = C { val := 0, isLt := (_ : 0 < Nat.succ n) }) h0)
          hs✝ i;
      this)
      { val := 0, isLt := (_ : 0 < Nat.succ n) } =
    h0
Theorem: Real.exp_1_approx_succ_eq
File: Mathlib/Data/Complex/Exponential.lean

tactic: subst er
state_before: n : ℕ
a₁ b₁ : ℝ
m : ℕ
en : n + 1 = m
rm : ℝ
er : ↑m = rm
h : abs' (exp 1 - expNear m 1 ((a₁ - 1) * rm)) ≤ abs' 1 ^ m / ↑(Nat.factorial m) * (b₁ * rm)
⊢ abs' (exp 1 - expNear n 1 a₁) ≤ abs' 1 ^ n / ↑(Nat.factorial n) * b₁

tactic: refine' exp_approx_succ _ en _ _ _ h
state_before: n : ℕ
a₁ b₁ : ℝ
m : ℕ
en : n + 1 = m
h : abs' (exp 1 - expNear m 1 ((a₁ - 1) * ↑m)) ≤ abs' 1 ^ m / ↑(Nat.factorial m) * (b₁ * ↑m)
⊢ abs' (exp 1 - expNear n 1 a₁) ≤ abs' 1 ^ n / ↑(Nat.factorial n) * b₁

tactic: field_simp [show (m : ℝ) ≠ 0 by norm_cast; linarith]
state_before: n : ℕ
a₁ b₁ : ℝ
m : ℕ
en : n + 1 = m
h : abs' (exp 1 - expNear m 1 ((a₁ - 1) * ↑m)) ≤ abs' 1 ^ m / ↑(Nat.factorial m) * (b₁ * ↑m)
⊢ abs' (1 + 1 / ↑m * ((a₁ - 1) * ↑m) - a₁) ≤ b₁ - abs' 1 / ↑m * (b₁ * ↑m)

tactic: norm_cast
state_before: n : ℕ
a₁ b₁ : ℝ
m : ℕ
en : n + 1 = m
h : abs' (exp 1 - expNear m 1 ((a₁ - 1) * ↑m)) ≤ abs' 1 ^ m / ↑(Nat.factorial m) * (b₁ * ↑m)
⊢ ↑m ≠ 0

tactic: linarith
state_before: n : ℕ
a₁ b₁ : ℝ
m : ℕ
en : n + 1 = m
h : abs' (exp 1 - expNear m 1 ((a₁ - 1) * ↑m)) ≤ abs' 1 ^ m / ↑(Nat.factorial m) * (b₁ * ↑m)
⊢ ¬m = 0
Theorem: NormedAddGroupHom.norm_completion
File: Mathlib/Analysis/Normed/Group/HomCompletion.lean

tactic: simpa using f.completion.le_opNorm x
state_before: G : Type u_1
inst✝² : SeminormedAddCommGroup G
H : Type u_2
inst✝¹ : SeminormedAddCommGroup H
K : Type ?u.13769
inst✝ : SeminormedAddCommGroup K
f : NormedAddGroupHom G H
x : G
⊢ ‖↑f x‖ ≤ ‖completion f‖ * ‖x‖
Theorem: completeSpace_extension
File: Mathlib/Topology/UniformSpace/UniformEmbedding.lean

tactic: assumption
state_before: α : Type u
β : Type v
γ : Type w
inst✝² : UniformSpace α
inst✝¹ : UniformSpace β
inst✝ : UniformSpace γ
m : β → α
hm : UniformInducing m
dense : DenseRange m
h : ∀ (f : Filter β), Cauchy f → ∃ x, map m f ≤ 𝓝 x
f : Filter α
hf : Cauchy f
p : Set (α × α) → Set α → Set α := fun s t => {y | ∃ x, x ∈ t ∧ (x, y) ∈ s}
g : Filter α := Filter.lift (𝓤 α) fun s => Filter.lift' f (p s)
mp₀ : Monotone p
mp₁ : ∀ {s : Set (α × α)}, Monotone (p s)
this✝⁵ : f ≤ g
this✝⁴ : NeBot g
this✝³ : NeBot (comap m g)
this✝² : Cauchy g
this✝¹ : Cauchy (comap m g)
x : α
hx : map m (comap m g) ≤ 𝓝 x
this✝ : ClusterPt x (map m (comap m g))
this : ClusterPt x g
⊢ f ≤ g
Theorem: CategoryTheory.Limits.Types.jointly_surjective
File: Mathlib/CategoryTheory/Limits/Types.lean

tactic: suffices (fun x : t.pt => ULift.up (∃ j y, t.ι.app j y = x)) = fun _ => ULift.up.{max v u} True by
  have := congr_fun this x
  simpa using congr_arg ULift.down this
state_before: J : Type v
inst✝ : SmallCategory J
F : J ⥤ TypeMax
t : Cocone F
h : IsColimit t
x : t.pt
⊢ ∃ j y, t.ι.app j y = x

tactic: refine' h.hom_ext _
state_before: J : Type v
inst✝ : SmallCategory J
F : J ⥤ TypeMax
t : Cocone F
h : IsColimit t
x : t.pt
⊢ (fun x => { down := ∃ j y, t.ι.app j y = x }) = fun x => { down := True }

tactic: intro j
state_before: J : Type v
inst✝ : SmallCategory J
F : J ⥤ TypeMax
t : Cocone F
h : IsColimit t
x : t.pt
⊢ ∀ (j : J), (t.ι.app j ≫ fun x => { down := ∃ j y, t.ι.app j y = x }) = t.ι.app j ≫ fun x => { down := True }

tactic: funext y
state_before: J : Type v
inst✝ : SmallCategory J
F : J ⥤ TypeMax
t : Cocone F
h : IsColimit t
x : t.pt
j : J
⊢ (t.ι.app j ≫ fun x => { down := ∃ j y, t.ι.app j y = x }) = t.ι.app j ≫ fun x => { down := True }

tactic: simp only [Functor.const_obj_obj, types_comp_apply, ULift.up_inj, eq_iff_iff, iff_true]
state_before: case h
J : Type v
inst✝ : SmallCategory J
F : J ⥤ TypeMax
t : Cocone F
h : IsColimit t
x : t.pt
j : J
y : F.obj j
⊢ (t.ι.app j ≫ fun x => { down := ∃ j y, t.ι.app j y = x }) y = (t.ι.app j ≫ fun x => { down := True }) y

tactic: exact ⟨j, y, rfl⟩
state_before: case h
J : Type v
inst✝ : SmallCategory J
F : J ⥤ TypeMax
t : Cocone F
h : IsColimit t
x : t.pt
j : J
y : F.obj j
⊢ ∃ j_1 y_1, t.ι.app j_1 y_1 = t.ι.app j y

tactic: have := congr_fun this x
state_before: J : Type v
inst✝ : SmallCategory J
F : J ⥤ TypeMax
t : Cocone F
h : IsColimit t
x : t.pt
this : (fun x => { down := ∃ j y, t.ι.app j y = x }) = fun x => { down := True }
⊢ ∃ j y, t.ι.app j y = x

tactic: simpa using congr_arg ULift.down this
state_before: J : Type v
inst✝ : SmallCategory J
F : J ⥤ TypeMax
t : Cocone F
h : IsColimit t
x : t.pt
this✝ : (fun x => { down := ∃ j y, t.ι.app j y = x }) = fun x => { down := True }
this : { down := ∃ j y, t.ι.app j y = x } = { down := True }
⊢ ∃ j y, t.ι.app j y = x
Theorem: List.suffix_insert
File: Mathlib/Data/List/Infix.lean

tactic: by_cases h : a ∈ l
state_before: α : Type u_1
β : Type ?u.53447
l✝ l₁ l₂ l₃ : List α
a✝ b : α
m n : ℕ
inst✝ : DecidableEq α
a : α
l : List α
⊢ l <:+ List.insert a l

tactic: simp only [insert_of_mem h, insert, suffix_refl]
state_before: case pos
α : Type u_1
β : Type ?u.53447
l✝ l₁ l₂ l₃ : List α
a✝ b : α
m n : ℕ
inst✝ : DecidableEq α
a : α
l : List α
h : a ∈ l
⊢ l <:+ List.insert a l

tactic: simp only [insert_of_not_mem h, suffix_cons, insert]
state_before: case neg
α : Type u_1
β : Type ?u.53447
l✝ l₁ l₂ l₃ : List α
a✝ b : α
m n : ℕ
inst✝ : DecidableEq α
a : α
l : List α
h : ¬a ∈ l
⊢ l <:+ List.insert a l
Theorem: Function.Antiperiodic.eq
File: Mathlib/Algebra/Periodic.lean

tactic: simpa only [zero_add] using h 0
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.145583
f g : α → β
c c₁ c₂ x : α
inst✝¹ : AddZeroClass α
inst✝ : Neg β
h : Antiperiodic f c
⊢ f c = -f 0
Theorem: LocalHomeomorph.extend_image_source_inter
File: Mathlib/Geometry/Manifold/SmoothManifoldWithCorners.lean

tactic: simp_rw [f.extend_coord_change_source, f.extend_coe, image_comp I f, trans_source'', symm_symm,
  symm_target]
state_before: 𝕜 : Type u_3
E : Type u_1
M : Type u_2
H : Type u_4
E' : Type ?u.167966
M' : Type ?u.167969
H' : Type ?u.167972
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
⊢ ↑(extend f I) '' (f.source ∩ f'.source) = (LocalEquiv.symm (extend f I) ≫ extend f' I).source