tasksource/leandojo huggingface dataset:
Theorem: iUnion_Ici_eq_Ioi_of_lt_of_tendsto
File: Mathlib/Topology/Algebra/Order/LiminfLimsup.lean

tactic: have obs : x ∉ range as := by
  intro maybe_x_is
  rcases mem_range.mp maybe_x_is with ⟨i, hi⟩
  simpa only [hi, lt_self_iff_false] using x_lt i
state_before: α : Type u
β : Type v
ι✝ : Type ?u.62603
R : Type u_2
inst✝³ : CompleteLinearOrder R
inst✝² : TopologicalSpace R
inst✝¹ : OrderTopology R
ι : Type u_1
x : R
as : ι → R
x_lt : ∀ (i : ι), x < as i
F : Filter ι
inst✝ : NeBot F
as_lim : Tendsto as F (𝓝 x)
⊢ (⋃ (i : ι), Ici (as i)) = Ioi x

tactic: have := iInf_eq_of_forall_le_of_tendsto (fun i ↦ (x_lt i).le) as_lim
state_before: α : Type u
β : Type v
ι✝ : Type ?u.62603
R : Type u_2
inst✝³ : CompleteLinearOrder R
inst✝² : TopologicalSpace R
inst✝¹ : OrderTopology R
ι : Type u_1
x : R
as : ι → R
x_lt : ∀ (i : ι), x < as i
F : Filter ι
inst✝ : NeBot F
as_lim : Tendsto as F (𝓝 x)
obs : ¬x ∈ range as
⊢ (⋃ (i : ι), Ici (as i)) = Ioi x

tactic: rw [← this] at obs
state_before: α : Type u
β : Type v
ι✝ : Type ?u.62603
R : Type u_2
inst✝³ : CompleteLinearOrder R
inst✝² : TopologicalSpace R
inst✝¹ : OrderTopology R
ι : Type u_1
x : R
as : ι → R
x_lt : ∀ (i : ι), x < as i
F : Filter ι
inst✝ : NeBot F
as_lim : Tendsto as F (𝓝 x)
obs : ¬x ∈ range as
this : (⨅ (i : ι), as i) = x
⊢ (⋃ (i : ι), Ici (as i)) = Ioi x

tactic: rw [← this]
state_before: α : Type u
β : Type v
ι✝ : Type ?u.62603
R : Type u_2
inst✝³ : CompleteLinearOrder R
inst✝² : TopologicalSpace R
inst✝¹ : OrderTopology R
ι : Type u_1
x : R
as : ι → R
x_lt : ∀ (i : ι), x < as i
F : Filter ι
inst✝ : NeBot F
as_lim : Tendsto as F (𝓝 x)
obs : ¬(⨅ (i : ι), as i) ∈ range as
this : (⨅ (i : ι), as i) = x
⊢ (⋃ (i : ι), Ici (as i)) = Ioi x

tactic: exact iUnion_Ici_eq_Ioi_iInf obs
state_before: α : Type u
β : Type v
ι✝ : Type ?u.62603
R : Type u_2
inst✝³ : CompleteLinearOrder R
inst✝² : TopologicalSpace R
inst✝¹ : OrderTopology R
ι : Type u_1
x : R
as : ι → R
x_lt : ∀ (i : ι), x < as i
F : Filter ι
inst✝ : NeBot F
as_lim : Tendsto as F (𝓝 x)
obs : ¬(⨅ (i : ι), as i) ∈ range as
this : (⨅ (i : ι), as i) = x
⊢ (⋃ (i : ι), Ici (as i)) = Ioi (⨅ (i : ι), as i)

tactic: intro maybe_x_is
state_before: α : Type u
β : Type v
ι✝ : Type ?u.62603
R : Type u_2
inst✝³ : CompleteLinearOrder R
inst✝² : TopologicalSpace R
inst✝¹ : OrderTopology R
ι : Type u_1
x : R
as : ι → R
x_lt : ∀ (i : ι), x < as i
F : Filter ι
inst✝ : NeBot F
as_lim : Tendsto as F (𝓝 x)
⊢ ¬x ∈ range as

tactic: rcases mem_range.mp maybe_x_is with ⟨i, hi⟩
state_before: α : Type u
β : Type v
ι✝ : Type ?u.62603
R : Type u_2
inst✝³ : CompleteLinearOrder R
inst✝² : TopologicalSpace R
inst✝¹ : OrderTopology R
ι : Type u_1
x : R
as : ι → R
x_lt : ∀ (i : ι), x < as i
F : Filter ι
inst✝ : NeBot F
as_lim : Tendsto as F (𝓝 x)
maybe_x_is : x ∈ range as
⊢ False

tactic: simpa only [hi, lt_self_iff_false] using x_lt i
state_before: case intro
α : Type u
β : Type v
ι✝ : Type ?u.62603
R : Type u_2
inst✝³ : CompleteLinearOrder R
inst✝² : TopologicalSpace R
inst✝¹ : OrderTopology R
ι : Type u_1
x : R
as : ι → R
x_lt : ∀ (i : ι), x < as i
F : Filter ι
inst✝ : NeBot F
as_lim : Tendsto as F (𝓝 x)
maybe_x_is : x ∈ range as
i : ι
hi : as i = x
⊢ False
Theorem: Int.negSucc_mul_subNatNat
File: Std/Data/Int/Lemmas.lean

tactic: cases n.lt_or_ge k with
| inl h =>
  have h' : succ m * n < succ m * k := Nat.mul_lt_mul_of_pos_left h (Nat.succ_pos m)
  rw [subNatNat_of_lt h, subNatNat_of_le (Nat.le_of_lt h')]
  simp [succ_pred_eq_of_pos (Nat.sub_pos_of_lt h), Nat.mul_sub_left_distrib]
| inr h => cases Nat.lt_or_ge k n with
  | inl h' =>
    have h₁ : succ m * n > succ m * k := Nat.mul_lt_mul_of_pos_left h' (Nat.succ_pos m)
    rw [subNatNat_of_le h, subNatNat_of_lt h₁, negSucc_mul_ofNat,
      Nat.mul_sub_left_distrib, ← succ_pred_eq_of_pos (Nat.sub_pos_of_lt h₁)]; rfl
  | inr h' => rw [Nat.le_antisymm h h', subNatNat_self, subNatNat_self, Int.mul_zero]
state_before: m n k : Nat
⊢ -[m+1] * subNatNat n k = subNatNat (succ m * k) (succ m * n)

tactic: have h' : succ m * n < succ m * k := Nat.mul_lt_mul_of_pos_left h (Nat.succ_pos m)
state_before: case inl
m n k : Nat
h : n < k
⊢ -[m+1] * subNatNat n k = subNatNat (succ m * k) (succ m * n)

tactic: rw [subNatNat_of_lt h, subNatNat_of_le (Nat.le_of_lt h')]
state_before: case inl
m n k : Nat
h : n < k
h' : succ m * n < succ m * k
⊢ -[m+1] * subNatNat n k = subNatNat (succ m * k) (succ m * n)

tactic: simp [succ_pred_eq_of_pos (Nat.sub_pos_of_lt h), Nat.mul_sub_left_distrib]
state_before: case inl
m n k : Nat
h : n < k
h' : succ m * n < succ m * k
⊢ -[m+1] * -[pred (k - n)+1] = ↑(succ m * k - succ m * n)

tactic: cases Nat.lt_or_ge k n with
| inl h' =>
have h₁ : succ m * n > succ m * k := Nat.mul_lt_mul_of_pos_left h' (Nat.succ_pos m)
rw [subNatNat_of_le h, subNatNat_of_lt h₁, negSucc_mul_ofNat,
Nat.mul_sub_left_distrib, ← succ_pred_eq_of_pos (Nat.sub_pos_of_lt h₁)]; rfl
| inr h' => rw [Nat.le_antisymm h h', subNatNat_self, subNatNat_self, Int.mul_zero]
state_before: case inr
m n k : Nat
h : n ≥ k
⊢ -[m+1] * subNatNat n k = subNatNat (succ m * k) (succ m * n)

tactic: have h₁ : succ m * n > succ m * k := Nat.mul_lt_mul_of_pos_left h' (Nat.succ_pos m)
state_before: case inr.inl
m n k : Nat
h : n ≥ k
h' : k < n
⊢ -[m+1] * subNatNat n k = subNatNat (succ m * k) (succ m * n)

tactic: rw [subNatNat_of_le h, subNatNat_of_lt h₁, negSucc_mul_ofNat,
  Nat.mul_sub_left_distrib, ← succ_pred_eq_of_pos (Nat.sub_pos_of_lt h₁)]
state_before: case inr.inl
m n k : Nat
h : n ≥ k
h' : k < n
h₁ : succ m * n > succ m * k
⊢ -[m+1] * subNatNat n k = subNatNat (succ m * k) (succ m * n)

tactic: rfl
state_before: case inr.inl
m n k : Nat
h : n ≥ k
h' : k < n
h₁ : succ m * n > succ m * k
⊢ -↑(succ (pred (succ m * n - succ m * k))) = -[pred (succ (pred (succ m * n - succ m * k)))+1]

tactic: rw [Nat.le_antisymm h h', subNatNat_self, subNatNat_self, Int.mul_zero]
state_before: case inr.inr
m n k : Nat
h : n ≥ k
h' : k ≥ n
⊢ -[m+1] * subNatNat n k = subNatNat (succ m * k) (succ m * n)
Theorem: List.mem_sigma
File: Mathlib/Data/List/ProdSigma.lean

tactic: simp [List.sigma, mem_bind, mem_map, exists_prop, exists_and_left, and_left_comm,
  exists_eq_left, heq_iff_eq, exists_eq_right]
state_before: α : Type u_1
β : Type ?u.8468
σ : α → Type u_2
l₁ : List α
l₂ : (a : α) → List (σ a)
a : α
b : σ a
⊢ { fst := a, snd := b } ∈ List.sigma l₁ l₂ ↔ a ∈ l₁ ∧ b ∈ l₂ a
Theorem: Complex.not_le_iff
File: Mathlib/Data/Complex/Basic.lean

tactic: rw [le_def, not_and_or, not_le]
state_before: z w : ℂ
⊢ ¬z ≤ w ↔ w.re < z.re ∨ z.im ≠ w.im
Theorem: imageToKernel_op
File: Mathlib/Algebra/Homology/Opposite.lean

tactic: rw [← op_comp, w, op_zero]
state_before: V : Type ?u.24
inst✝¹ : Category V
inst✝ : Abelian V
X Y Z : V
f : X ⟶ Y
g : Y ⟶ Z
w : f ≫ g = 0
⊢ g.op ≫ f.op = 0

tactic: rw [← cancel_mono (image.ι g), Category.assoc, image.fac, w, zero_comp]
state_before: V : Type ?u.24
inst✝¹ : Category V
inst✝ : Abelian V
X Y Z : V
f : X ⟶ Y
g : Y ⟶ Z
w : f ≫ g = 0
⊢ f ≫ factorThruImage g = 0

tactic: ext
state_before: V : Type u_2
inst✝¹ : Category V
inst✝ : Abelian V
X Y Z : V
f : X ⟶ Y
g : Y ⟶ Z
w : f ≫ g = 0
⊢ imageToKernel g.op f.op (_ : g.op ≫ f.op = 0) =
    (imageSubobjectIso g.op ≪≫ (imageOpOp g).symm).hom ≫
      (cokernel.desc f (factorThruImage g) (_ : f ≫ factorThruImage g = 0)).op ≫
        (kernelSubobjectIso f.op ≪≫ kernelOpOp f).inv

tactic: simp only [Iso.trans_hom, Iso.symm_hom, Iso.trans_inv, kernelOpOp_inv, Category.assoc,
  imageToKernel_arrow, kernelSubobject_arrow', kernel.lift_ι, ← op_comp, cokernel.π_desc,
  ← imageSubobject_arrow, ← imageUnopOp_inv_comp_op_factorThruImage g.op]
state_before: case h
V : Type u_2
inst✝¹ : Category V
inst✝ : Abelian V
X Y Z : V
f : X ⟶ Y
g : Y ⟶ Z
w : f ≫ g = 0
⊢ imageToKernel g.op f.op (_ : g.op ≫ f.op = 0) ≫ Subobject.arrow (kernelSubobject f.op) =
    ((imageSubobjectIso g.op ≪≫ (imageOpOp g).symm).hom ≫
        (cokernel.desc f (factorThruImage g) (_ : f ≫ factorThruImage g = 0)).op ≫
          (kernelSubobjectIso f.op ≪≫ kernelOpOp f).inv) ≫
      Subobject.arrow (kernelSubobject f.op)

tactic: rfl
state_before: case h
V : Type u_2
inst✝¹ : Category V
inst✝ : Abelian V
X Y Z : V
f : X ⟶ Y
g : Y ⟶ Z
w : f ≫ g = 0
⊢ (imageSubobjectIso g.op).hom ≫ (imageUnopOp g.op).inv ≫ (factorThruImage g.op.unop).op =
    (imageSubobjectIso g.op).hom ≫ (imageOpOp g).inv ≫ (factorThruImage g).op
Theorem: List.mem_reverseAux
File: Std/Data/List/Lemmas.lean

tactic: simp
state_before: α : Type u_1
x : α
x✝ : List α
⊢ x ∈ reverseAux [] x✝ ↔ x ∈ [] ∨ x ∈ x✝

tactic: simp [mem_reverseAux]
state_before: α : Type u_1
x a : α
tail✝ x✝ : List α
⊢ x ∈ reverseAux (a :: tail✝) x✝ ↔ x ∈ a :: tail✝ ∨ x ∈ x✝

tactic: rw [← or_assoc, @or_comm (x = a)]
state_before: α : Type u_1
x a : α
tail✝ x✝ : List α
⊢ x ∈ tail✝ ∨ x = a ∨ x ∈ x✝ ↔ (x = a ∨ x ∈ tail✝) ∨ x ∈ x✝
Theorem: Fin.insertNth_le_iff
File: Mathlib/Data/Fin/Tuple/Basic.lean

tactic: simp [Pi.le_def, forall_iff_succAbove i]
state_before: m n : ℕ
α : Fin (n + 1) → Type u
β : Type v
inst✝ : (i : Fin (n + 1)) → Preorder (α i)
i : Fin (n + 1)
x : α i
p : (j : Fin n) → α (↑(succAbove i) j)
q : (j : Fin (n + 1)) → α j
⊢ insertNth i x p ≤ q ↔ x ≤ q i ∧ p ≤ fun j => q (↑(succAbove i) j)
Theorem: disjoint_right_comm
File: Mathlib/Order/Disjoint.lean

tactic: simp_rw [disjoint_iff_inf_le, inf_right_comm]
state_before: α : Type u_1
inst✝¹ : SemilatticeInf α
inst✝ : OrderBot α
a b c d : α
⊢ Disjoint (a ⊓ b) c ↔ Disjoint (a ⊓ c) b
Theorem: CategoryTheory.Bicategory.comp_whiskerLeft_symm
File: Mathlib/CategoryTheory/Bicategory/Basic.lean

tactic: simp
state_before: B : Type u
inst✝ : Bicategory B
a b c d e : B
f : a ⟶ b
g : b ⟶ c
h h' : c ⟶ d
η : h ⟶ h'
⊢ f ◁ g ◁ η = (α_ f g h).inv ≫ (f ≫ g) ◁ η ≫ (α_ f g h').hom
Theorem: FirstOrder.Language.Theory.models_iff_not_satisfiable
File: Mathlib/ModelTheory/Satisfiability.lean

tactic: rw [models_sentence_iff, IsSatisfiable]
state_before: L : Language
T : Theory L
α : Type w
n : ℕ
φ : Sentence L
⊢ T ⊨ᵇ φ ↔ ¬IsSatisfiable (T ∪ {Formula.not φ})

tactic: refine'
  ⟨fun h1 h2 =>
    (Sentence.realize_not _).1
      (realize_sentence_of_mem (T ∪ {Formula.not φ})
        (Set.subset_union_right _ _ (Set.mem_singleton _)))
      (h1 (h2.some.subtheoryModel (Set.subset_union_left _ _))),
    fun h M => _⟩
state_before: L : Language
T : Theory L
α : Type w
n : ℕ
φ : Sentence L
⊢ (∀ (M : ModelType T), ↑M ⊨ φ) ↔ ¬Nonempty (ModelType (T ∪ {Formula.not φ}))

tactic: contrapose! h
state_before: L : Language
T : Theory L
α : Type w
n : ℕ
φ : Sentence L
h : ¬Nonempty (ModelType (T ∪ {Formula.not φ}))
M : ModelType T
⊢ ↑M ⊨ φ

tactic: rw [← Sentence.realize_not] at h
state_before: L : Language
T : Theory L
α : Type w
n : ℕ
φ : Sentence L
M : ModelType T
h : ¬↑M ⊨ φ
⊢ Nonempty (ModelType (T ∪ {Formula.not φ}))

tactic: refine'
  ⟨{  Carrier := M
      is_model := ⟨fun ψ hψ => hψ.elim (realize_sentence_of_mem _) fun h' => _⟩ }⟩
state_before: L : Language
T : Theory L
α : Type w
n : ℕ
φ : Sentence L
M : ModelType T
h : ↑M ⊨ Formula.not φ
⊢ Nonempty (ModelType (T ∪ {Formula.not φ}))

tactic: rw [Set.mem_singleton_iff.1 h']
state_before: L : Language
T : Theory L
α : Type w
n : ℕ
φ : Sentence L
M : ModelType T
h : ↑M ⊨ Formula.not φ
ψ : Sentence L
hψ : ψ ∈ T ∪ {Formula.not φ}
h' : ψ ∈ {Formula.not φ}
⊢ ↑M ⊨ ψ

tactic: exact h
state_before: L : Language
T : Theory L
α : Type w
n : ℕ
φ : Sentence L
M : ModelType T
h : ↑M ⊨ Formula.not φ
ψ : Sentence L
hψ : ψ ∈ T ∪ {Formula.not φ}
h' : ψ ∈ {Formula.not φ}
⊢ ↑M ⊨ Formula.not φ
Theorem: Nat.odd_add'
File: Mathlib/Data/Nat/Parity.lean

tactic: rw [add_comm, odd_add]
state_before: m n : ℕ
⊢ Odd (m + n) ↔ (Odd n ↔ Even m)
Theorem: MultilinearMap.alternization_map_eq_zero_of_eq_aux
File: Mathlib/LinearAlgebra/Alternating.lean

tactic: rw [sum_apply]
state_before: R : Type u_1
inst✝¹² : Semiring R
M : Type u_2
inst✝¹¹ : AddCommMonoid M
inst✝¹⁰ : Module R M
N : Type ?u.568657
inst✝⁹ : AddCommMonoid N
inst✝⁸ : Module R N
P : Type ?u.568687
inst✝⁷ : AddCommMonoid P
inst✝⁶ : Module R P
M' : Type ?u.568717
inst✝⁵ : AddCommGroup M'
inst✝⁴ : Module R M'
N' : Type u_3
inst✝³ : AddCommGroup N'
inst✝² : Module R N'
ι : Type u_4
ι' : Type ?u.569496
ι'' : Type ?u.569499
inst✝¹ : Fintype ι
inst✝ : DecidableEq ι
m : MultilinearMap R (fun x => M) N'
v : ι → M
i j : ι
i_ne_j : i ≠ j
hv : v i = v j
⊢ ↑(∑ σ : Perm ι, ↑Perm.sign σ • domDomCongr σ m) v = 0

tactic: exact
  Finset.sum_involution (fun σ _ => swap i j * σ)
    (fun σ _ => by simp [Perm.sign_swap i_ne_j, apply_swap_eq_self hv, -Equiv.Perm.sign_swap'])
    (fun σ _ _ => (not_congr swap_mul_eq_iff).mpr i_ne_j) (fun σ _ => Finset.mem_univ _)
    fun σ _ => swap_mul_involutive i j σ
state_before: R : Type u_1
inst✝¹² : Semiring R
M : Type u_2
inst✝¹¹ : AddCommMonoid M
inst✝¹⁰ : Module R M
N : Type ?u.568657
inst✝⁹ : AddCommMonoid N
inst✝⁸ : Module R N
P : Type ?u.568687
inst✝⁷ : AddCommMonoid P
inst✝⁶ : Module R P
M' : Type ?u.568717
inst✝⁵ : AddCommGroup M'
inst✝⁴ : Module R M'
N' : Type u_3
inst✝³ : AddCommGroup N'
inst✝² : Module R N'
ι : Type u_4
ι' : Type ?u.569496
ι'' : Type ?u.569499
inst✝¹ : Fintype ι
inst✝ : DecidableEq ι
m : MultilinearMap R (fun x => M) N'
v : ι → M
i j : ι
i_ne_j : i ≠ j
hv : v i = v j
⊢ ∑ a : Perm ι, ↑(↑Perm.sign a • domDomCongr a m) v = 0

tactic: simp [Perm.sign_swap i_ne_j, apply_swap_eq_self hv, -Equiv.Perm.sign_swap']
state_before: R : Type u_1
inst✝¹² : Semiring R
M : Type u_2
inst✝¹¹ : AddCommMonoid M
inst✝¹⁰ : Module R M
N : Type ?u.568657
inst✝⁹ : AddCommMonoid N
inst✝⁸ : Module R N
P : Type ?u.568687
inst✝⁷ : AddCommMonoid P
inst✝⁶ : Module R P
M' : Type ?u.568717
inst✝⁵ : AddCommGroup M'
inst✝⁴ : Module R M'
N' : Type u_3
inst✝³ : AddCommGroup N'
inst✝² : Module R N'
ι : Type u_4
ι' : Type ?u.569496
ι'' : Type ?u.569499
inst✝¹ : Fintype ι
inst✝ : DecidableEq ι
m : MultilinearMap R (fun x => M) N'
v : ι → M
i j : ι
i_ne_j : i ≠ j
hv : v i = v j
σ : Perm ι
x✝ : σ ∈ Finset.univ
⊢ ↑(↑Perm.sign σ • domDomCongr σ m) v +
      ↑(↑Perm.sign ((fun σ x => swap i j * σ) σ x✝) • domDomCongr ((fun σ x => swap i j * σ) σ x✝) m) v =
    0
Theorem: TopCat.Presheaf.SheafConditionEqualizerProducts.res_π
File: Mathlib/Topology/Sheaves/SheafCondition/EqualizerProducts.lean

tactic: rw [res, limit.lift_π, Fan.mk_π_app]
state_before: C : Type u
inst✝¹ : Category C
inst✝ : HasProducts C
X : TopCat
F : Presheaf C X
ι : Type v'
U : ι → Opens ↑X
i : ι
⊢ res F U ≫ limit.π (Discrete.functor fun i => F.obj (U i).op) { as := i } = F.map (leSupr U i).op
Theorem: Finsupp.swap_mem_antidiagonal
File: Mathlib/Data/Finsupp/Antidiagonal.lean

tactic: simp only [mem_antidiagonal, add_comm, Prod.swap]
state_before: α : Type u
n : α →₀ ℕ
f : (α →₀ ℕ) × (α →₀ ℕ)
⊢ Prod.swap f ∈ antidiagonal n ↔ f ∈ antidiagonal n
Theorem: Nat.not_pos_pow_dvd
File: Mathlib/Data/Nat/Pow.lean

tactic: simpa [pow_succ'] using h
state_before: p k : ℕ
hp : 1 < succ p
hk : 1 < succ k
h : succ p ^ succ k ∣ succ p
⊢ succ p * succ p ^ k ∣ succ p * 1

tactic: rwa [he] at this
state_before: p k : ℕ
hp : 1 < succ p
hk : 1 < succ k
h : succ p ^ succ k ∣ succ p
this✝¹ : succ p * succ p ^ k ∣ succ p * 1
this✝ : succ p ^ k ∣ 1
he : succ p ^ k = 1
this : k < succ p ^ k
⊢ k < 1

tactic: rwa [this] at hk
state_before: p k : ℕ
hp : 1 < succ p
hk : 1 < succ k
h : succ p ^ succ k ∣ succ p
this✝³ : succ p * succ p ^ k ∣ succ p * 1
this✝² : succ p ^ k ∣ 1
he : succ p ^ k = 1
this✝¹ : k < succ p ^ k
this✝ : k < 1
this : k = 0
⊢ 1 < 1

tactic: decide
state_before: p k : ℕ
hp : 1 < succ p
hk : 1 < succ k
h : succ p ^ succ k ∣ succ p
this✝⁴ : succ p * succ p ^ k ∣ succ p * 1
this✝³ : succ p ^ k ∣ 1
he : succ p ^ k = 1
this✝² : k < succ p ^ k
this✝¹ : k < 1
this✝ : k = 0
this : 1 < 1
⊢ ¬1 < 1
Theorem: expChar_one_iff_char_zero
File: Mathlib/Algebra/CharP/ExpChar.lean

tactic: constructor
state_before: R : Type u
inst✝³ : Semiring R
inst✝² : Nontrivial R
p q : ℕ
inst✝¹ : CharP R p
inst✝ : ExpChar R q
⊢ q = 1 ↔ p = 0

tactic: rintro rfl
state_before: case mp
R : Type u
inst✝³ : Semiring R
inst✝² : Nontrivial R
p q : ℕ
inst✝¹ : CharP R p
inst✝ : ExpChar R q
⊢ q = 1 → p = 0

tactic: exact char_zero_of_expChar_one R p
state_before: case mp
R : Type u
inst✝³ : Semiring R
inst✝² : Nontrivial R
p : ℕ
inst✝¹ : CharP R p
inst✝ : ExpChar R 1
⊢ p = 0

tactic: rintro rfl
state_before: case mpr
R : Type u
inst✝³ : Semiring R
inst✝² : Nontrivial R
p q : ℕ
inst✝¹ : CharP R p
inst✝ : ExpChar R q
⊢ p = 0 → q = 1

tactic: exact expChar_one_of_char_zero R q
state_before: case mpr
R : Type u
inst✝³ : Semiring R
inst✝² : Nontrivial R
q : ℕ
inst✝¹ : ExpChar R q
inst✝ : CharP R 0
⊢ q = 1
Theorem: tendsto_atTop_ciSup
File: Mathlib/Topology/Algebra/Order/MonotoneConvergence.lean

tactic: cases isEmpty_or_nonempty ι
state_before: α : Type u_2
β : Type ?u.16816
ι : Type u_1
inst✝³ : Preorder ι
inst✝² : TopologicalSpace α
inst✝¹ : ConditionallyCompleteLattice α
inst✝ : SupConvergenceClass α
f : ι → α
a : α
h_mono : Monotone f
hbdd : BddAbove (range f)
⊢ Tendsto f atTop (𝓝 (⨆ (i : ι), f i))

tactic: exacts [tendsto_of_isEmpty, tendsto_atTop_isLUB h_mono (isLUB_ciSup hbdd)]
state_before: case inl
α : Type u_2
β : Type ?u.16816
ι : Type u_1
inst✝³ : Preorder ι
inst✝² : TopologicalSpace α
inst✝¹ : ConditionallyCompleteLattice α
inst✝ : SupConvergenceClass α
f : ι → α
a : α
h_mono : Monotone f
hbdd : BddAbove (range f)
h✝ : IsEmpty ι
⊢ Tendsto f atTop (𝓝 (⨆ (i : ι), f i))

case inr
α : Type u_2
β : Type ?u.16816
ι : Type u_1
inst✝³ : Preorder ι
inst✝² : TopologicalSpace α
inst✝¹ : ConditionallyCompleteLattice α
inst✝ : SupConvergenceClass α
f : ι → α
a : α
h_mono : Monotone f
hbdd : BddAbove (range f)
h✝ : Nonempty ι
⊢ Tendsto f atTop (𝓝 (⨆ (i : ι), f i))
Theorem: MvPolynomial.esymm_zero
File: Mathlib/RingTheory/MvPolynomial/Symmetric.lean

tactic: simp only [esymm, powersetLen_zero, sum_singleton, prod_empty]
state_before: σ : Type u_1
R : Type u_2
τ : Type ?u.96806
S : Type ?u.96809
inst✝³ : CommSemiring R
inst✝² : CommSemiring S
inst✝¹ : Fintype σ
inst✝ : Fintype τ
⊢ esymm σ R 0 = 1
Theorem: MultilinearMap.compLinearMap_injective
File: Mathlib/LinearAlgebra/Multilinear/Basic.lean

tactic: simpa [fun i => surjInv_eq (hf i)] using ext_iff.mp h fun i => surjInv (hf i) (x i)
state_before: R : Type u
ι : Type u'
n : ℕ
M : Fin (Nat.succ n) → Type v
M₁ : ι → Type v₁
M₂ : Type v₂
M₃ : Type v₃
M' : Type v'
inst✝¹⁴ : Semiring R
inst✝¹³ : (i : Fin (Nat.succ n)) → AddCommMonoid (M i)
inst✝¹² : (i : ι) → AddCommMonoid (M₁ i)
inst✝¹¹ : AddCommMonoid M₂
inst✝¹⁰ : AddCommMonoid M₃
inst✝⁹ : AddCommMonoid M'
inst✝⁸ : (i : Fin (Nat.succ n)) → Module R (M i)
inst✝⁷ : (i : ι) → Module R (M₁ i)
inst✝⁶ : Module R M₂
inst✝⁵ : Module R M₃
inst✝⁴ : Module R M'
f✝ f' : MultilinearMap R M₁ M₂
M₁' : ι → Type u_1
inst✝³ : (i : ι) → AddCommMonoid (M₁' i)
inst✝² : (i : ι) → Module R (M₁' i)
M₁'' : ι → Type ?u.177120
inst✝¹ : (i : ι) → AddCommMonoid (M₁'' i)
inst✝ : (i : ι) → Module R (M₁'' i)
f : (i : ι) → M₁ i →ₗ[R] M₁' i
hf : ∀ (i : ι), Surjective ↑(f i)
g₁ g₂ : MultilinearMap R M₁' M₂
h : (fun g => compLinearMap g f) g₁ = (fun g => compLinearMap g f) g₂
x : (i : ι) → M₁' i
⊢ ↑g₁ x = ↑g₂ x
Theorem: WType.rightInverse_nat
File: Mathlib/Data/W/Constructions.lean

tactic: rw [ofNat, toNat, rightInverse_nat n]
state_before: n : ℕ
⊢ toNat (ofNat (Nat.succ n)) = Nat.succ n
Theorem: lt_div_iff_mul_lt'
File: Mathlib/Algebra/Order/Group/Defs.lean

tactic: rw [lt_div_iff_mul_lt, mul_comm]
state_before: α : Type u
inst✝² : CommGroup α
inst✝¹ : LT α
inst✝ : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x < x_1
a b c d : α
⊢ b < c / a ↔ a * b < c
Theorem: IsPreconnected.subset_or_subset
File: Mathlib/Topology/Connected.lean

tactic: specialize hs u v hu hv hsuv
state_before: α : Type u
β : Type v
ι : Type ?u.28526
π : ι → Type ?u.28531
inst✝ : TopologicalSpace α
s t u v : Set α
hu : IsOpen u
hv : IsOpen v
huv : Disjoint u v
hsuv : s ⊆ u ∪ v
hs : IsPreconnected s
⊢ s ⊆ u ∨ s ⊆ v

tactic: obtain hsu | hsu := (s ∩ u).eq_empty_or_nonempty
state_before: α : Type u
β : Type v
ι : Type ?u.28526
π : ι → Type ?u.28531
inst✝ : TopologicalSpace α
s t u v : Set α
hu : IsOpen u
hv : IsOpen v
huv : Disjoint u v
hsuv : s ⊆ u ∪ v
hs : Set.Nonempty (s ∩ u) → Set.Nonempty (s ∩ v) → Set.Nonempty (s ∩ (u ∩ v))
⊢ s ⊆ u ∨ s ⊆ v

tactic: exact Or.inr ((Set.disjoint_iff_inter_eq_empty.2 hsu).subset_right_of_subset_union hsuv)
state_before: case inl
α : Type u
β : Type v
ι : Type ?u.28526
π : ι → Type ?u.28531
inst✝ : TopologicalSpace α
s t u v : Set α
hu : IsOpen u
hv : IsOpen v
huv : Disjoint u v
hsuv : s ⊆ u ∪ v
hs : Set.Nonempty (s ∩ u) → Set.Nonempty (s ∩ v) → Set.Nonempty (s ∩ (u ∩ v))
hsu : s ∩ u = ∅
⊢ s ⊆ u ∨ s ⊆ v

tactic: replace hs := mt (hs hsu)
state_before: case inr
α : Type u
β : Type v
ι : Type ?u.28526
π : ι → Type ?u.28531
inst✝ : TopologicalSpace α
s t u v : Set α
hu : IsOpen u
hv : IsOpen v
huv : Disjoint u v
hsuv : s ⊆ u ∪ v
hs : Set.Nonempty (s ∩ u) → Set.Nonempty (s ∩ v) → Set.Nonempty (s ∩ (u ∩ v))
hsu : Set.Nonempty (s ∩ u)
⊢ s ⊆ u ∨ s ⊆ v

tactic: simp_rw [Set.not_nonempty_iff_eq_empty, ← Set.disjoint_iff_inter_eq_empty,
  disjoint_iff_inter_eq_empty.1 huv] at hs
state_before: case inr
α : Type u
β : Type v
ι : Type ?u.28526
π : ι → Type ?u.28531
inst✝ : TopologicalSpace α
s t u v : Set α
hu : IsOpen u
hv : IsOpen v
huv : Disjoint u v
hsuv : s ⊆ u ∪ v
hsu : Set.Nonempty (s ∩ u)
hs : ¬Set.Nonempty (s ∩ (u ∩ v)) → ¬Set.Nonempty (s ∩ v)
⊢ s ⊆ u ∨ s ⊆ v

tactic: exact Or.inl ((hs s.disjoint_empty).subset_left_of_subset_union hsuv)
state_before: case inr
α : Type u
β : Type v
ι : Type ?u.28526
π : ι → Type ?u.28531
inst✝ : TopologicalSpace α
s t u v : Set α
hu : IsOpen u
hv : IsOpen v
huv : Disjoint u v
hsuv : s ⊆ u ∪ v
hsu : Set.Nonempty (s ∩ u)
hs : Disjoint s ∅ → Disjoint s v
⊢ s ⊆ u ∨ s ⊆ v
Theorem: integral_one
File: Mathlib/Analysis/SpecialFunctions/Integrals.lean

tactic: simp only [mul_one, smul_eq_mul, integral_const]
state_before: a b : ℝ
n : ℕ
⊢ (∫ (x : ℝ) in a..b, 1) = b - a
Theorem: Ordnode.Valid'.balance
File: Mathlib/Data/Ordmap/Ordset.lean

tactic: rw [balance_eq_balance' hl.3 hr.3 hl.2 hr.2]
state_before: α : Type u_1
inst✝ : Preorder α
l : Ordnode α
x : α
r : Ordnode α
o₁ : WithBot α
o₂ : WithTop α
hl : Valid' o₁ l ↑x
hr : Valid' (↑x) r o₂
H : ∃ l' r', BalancedSz l' r' ∧ (Nat.dist (size l) l' ≤ 1 ∧ size r = r' ∨ Nat.dist (size r) r' ≤ 1 ∧ size l = l')
⊢ Valid' o₁ (Ordnode.balance l x r) o₂

tactic: exact hl.balance' hr H
state_before: α : Type u_1
inst✝ : Preorder α
l : Ordnode α
x : α
r : Ordnode α
o₁ : WithBot α
o₂ : WithTop α
hl : Valid' o₁ l ↑x
hr : Valid' (↑x) r o₂
H : ∃ l' r', BalancedSz l' r' ∧ (Nat.dist (size l) l' ≤ 1 ∧ size r = r' ∨ Nat.dist (size r) r' ≤ 1 ∧ size l = l')
⊢ Valid' o₁ (Ordnode.balance' l x r) o₂
Theorem: Int.units_coe_mul_self
File: Mathlib/Data/Int/Order/Units.lean

tactic: rw [← Units.val_mul, units_mul_self, Units.val_one]
state_before: u : ℤˣ
⊢ ↑u * ↑u = 1
Theorem: lowerCentralSeries_isDescendingCentralSeries
File: Mathlib/GroupTheory/Nilpotent.lean

tactic: constructor
state_before: G : Type u_1
inst✝¹ : Group G
H : Subgroup G
inst✝ : Normal H
⊢ IsDescendingCentralSeries (lowerCentralSeries G)

tactic: rfl
state_before: case left
G : Type u_1
inst✝¹ : Group G
H : Subgroup G
inst✝ : Normal H
⊢ lowerCentralSeries G 0 = ⊤

case right
G : Type u_1
inst✝¹ : Group G
H : Subgroup G
inst✝ : Normal H
⊢ ∀ (x : G) (n : ℕ), x ∈ lowerCentralSeries G n → ∀ (g : G), x * g * x⁻¹ * g⁻¹ ∈ lowerCentralSeries G (n + 1)

tactic: intro x n hxn g
state_before: case right
G : Type u_1
inst✝¹ : Group G
H : Subgroup G
inst✝ : Normal H
⊢ ∀ (x : G) (n : ℕ), x ∈ lowerCentralSeries G n → ∀ (g : G), x * g * x⁻¹ * g⁻¹ ∈ lowerCentralSeries G (n + 1)

tactic: exact commutator_mem_commutator hxn (mem_top g)
state_before: case right
G : Type u_1
inst✝¹ : Group G
H : Subgroup G
inst✝ : Normal H
x : G
n : ℕ
hxn : x ∈ lowerCentralSeries G n
g : G
⊢ x * g * x⁻¹ * g⁻¹ ∈ lowerCentralSeries G (n + 1)