tasksource/leandojo huggingface dataset:
Theorem: IsSimpleModule.nontrivial
File: Mathlib/RingTheory/SimpleModule.lean

tactic: have h : (⊥ : Submodule R M) ≠ ⊤ := bot_ne_top
state_before: R : Type u_1
inst✝³ : Ring R
M : Type u_2
inst✝² : AddCommGroup M
inst✝¹ : Module R M
inst✝ : IsSimpleModule R M
⊢ ∃ y, 0 ≠ y

tactic: contrapose! h
state_before: R : Type u_1
inst✝³ : Ring R
M : Type u_2
inst✝² : AddCommGroup M
inst✝¹ : Module R M
inst✝ : IsSimpleModule R M
h : ⊥ ≠ ⊤
⊢ ∃ y, 0 ≠ y

tactic: have h : ∀ (y : M), 0 = y := by
  intro y
  have em := Classical.em (0 = y)
  match em with
  | .inl h' => exact h'
  | .inr h' => apply False.elim <| h ⟨y,h'⟩
state_before: R : Type u_1
inst✝³ : Ring R
M : Type u_2
inst✝² : AddCommGroup M
inst✝¹ : Module R M
inst✝ : IsSimpleModule R M
h : ¬∃ y, 0 ≠ y
⊢ ⊥ = ⊤

tactic: ext x
state_before: R : Type u_1
inst✝³ : Ring R
M : Type u_2
inst✝² : AddCommGroup M
inst✝¹ : Module R M
inst✝ : IsSimpleModule R M
h✝ : ¬∃ y, 0 ≠ y
h : ∀ (y : M), 0 = y
⊢ ⊥ = ⊤

tactic: simp [Submodule.mem_bot, Submodule.mem_top, h x]
state_before: case h
R : Type u_1
inst✝³ : Ring R
M : Type u_2
inst✝² : AddCommGroup M
inst✝¹ : Module R M
inst✝ : IsSimpleModule R M
h✝ : ¬∃ y, 0 ≠ y
h : ∀ (y : M), 0 = y
x : M
⊢ x ∈ ⊥ ↔ x ∈ ⊤

tactic: intro y
state_before: R : Type u_1
inst✝³ : Ring R
M : Type u_2
inst✝² : AddCommGroup M
inst✝¹ : Module R M
inst✝ : IsSimpleModule R M
h : ¬∃ y, 0 ≠ y
⊢ ∀ (y : M), 0 = y

tactic: have em := Classical.em (0 = y)
state_before: R : Type u_1
inst✝³ : Ring R
M : Type u_2
inst✝² : AddCommGroup M
inst✝¹ : Module R M
inst✝ : IsSimpleModule R M
h : ¬∃ y, 0 ≠ y
y : M
⊢ 0 = y

tactic: match em with
| .inl h' => exact h'
| .inr h' => apply False.elim <| h ⟨y,h'⟩
state_before: R : Type u_1
inst✝³ : Ring R
M : Type u_2
inst✝² : AddCommGroup M
inst✝¹ : Module R M
inst✝ : IsSimpleModule R M
h : ¬∃ y, 0 ≠ y
y : M
em : 0 = y ∨ ¬0 = y
⊢ 0 = y

tactic: exact h'
state_before: R : Type u_1
inst✝³ : Ring R
M : Type u_2
inst✝² : AddCommGroup M
inst✝¹ : Module R M
inst✝ : IsSimpleModule R M
h : ¬∃ y, 0 ≠ y
y : M
em : 0 = y ∨ ¬0 = y
h' : 0 = y
⊢ 0 = y

tactic: apply False.elim <| h ⟨y,h'⟩
state_before: R : Type u_1
inst✝³ : Ring R
M : Type u_2
inst✝² : AddCommGroup M
inst✝¹ : Module R M
inst✝ : IsSimpleModule R M
h : ¬∃ y, 0 ≠ y
y : M
em : 0 = y ∨ ¬0 = y
h' : ¬0 = y
⊢ 0 = y
Theorem: Relation.TransGen.to_reflTransGen
File: Mathlib/Logic/Relation.lean

tactic: induction' h with b h b c _ bc ab
state_before: α : Type u_1
β : Type ?u.18514
γ : Type ?u.18517
δ : Type ?u.18520
r : α → α → Prop
a✝ b✝ c d a b : α
h : TransGen r a b
⊢ ReflTransGen r a b

tactic: exact ReflTransGen.single h
state_before: case single
α : Type u_1
β : Type ?u.18514
γ : Type ?u.18517
δ : Type ?u.18520
r : α → α → Prop
a✝ b✝¹ c d a b✝ b : α
h : r a b
⊢ ReflTransGen r a b

case tail
α : Type u_1
β : Type ?u.18514
γ : Type ?u.18517
δ : Type ?u.18520
r : α → α → Prop
a✝¹ b✝¹ c✝ d a b✝ b c : α
a✝ : TransGen r a b
bc : r b c
ab : ReflTransGen r a b
⊢ ReflTransGen r a c

tactic: exact ReflTransGen.tail ab bc
state_before: case tail
α : Type u_1
β : Type ?u.18514
γ : Type ?u.18517
δ : Type ?u.18520
r : α → α → Prop
a✝¹ b✝¹ c✝ d a b✝ b c : α
a✝ : TransGen r a b
bc : r b c
ab : ReflTransGen r a b
⊢ ReflTransGen r a c
Theorem: Primrec.nat_bodd
File: Mathlib/Computability/Primrec.lean

tactic: cases H : n.bodd <;> simp [Nat.mod_two_of_bodd, H]
state_before: α : Type ?u.175087
β : Type ?u.175090
γ : Type ?u.175093
δ : Type ?u.175096
σ : Type ?u.175099
inst✝⁴ : Primcodable α
inst✝³ : Primcodable β
inst✝² : Primcodable γ
inst✝¹ : Primcodable δ
inst✝ : Primcodable σ
n : ℕ
⊢ (id n % 2 == 1) = Nat.bodd n
Theorem: Fin.univ_castSucc
File: Mathlib/Data/Fintype/Basic.lean

tactic: simp [map_eq_image]
state_before: α : Type ?u.105001
β : Type ?u.105004
γ : Type ?u.105007
n : ℕ
⊢ ¬last n ∈ map castSucc.toEmbedding univ

tactic: simp [map_eq_image]
state_before: α : Type ?u.105001
β : Type ?u.105004
γ : Type ?u.105007
n : ℕ
⊢ univ = cons (last n) (map castSucc.toEmbedding univ) (_ : ¬last n ∈ map castSucc.toEmbedding univ)
Theorem: Stream'.Seq.destruct_cons
File: Mathlib/Data/Seq/Seq.lean

tactic: unfold cons destruct Functor.map
state_before: α : Type u
β : Type v
γ : Type w
a : α
f : Stream' (Option α)
al : IsSeq f
⊢ destruct (cons a { val := f, property := al }) = some (a, { val := f, property := al })

tactic: apply congr_arg fun s => some (a, s)
state_before: α : Type u
β : Type v
γ : Type w
a : α
f : Stream' (Option α)
al : IsSeq f
⊢ instFunctorOption.1
      (fun a' =>
        (a',
          tail
            { val := some a :: ↑{ val := f, property := al },
              property :=
                (_ :
                  ∀ {n : ℕ},
                    (some a :: ↑{ val := f, property := al }) n = none →
                      (some a :: ↑{ val := f, property := al }) (n + 1) = none) }))
      (get?
        { val := some a :: ↑{ val := f, property := al },
          property :=
            (_ :
              ∀ {n : ℕ},
                (some a :: ↑{ val := f, property := al }) n = none →
                  (some a :: ↑{ val := f, property := al }) (n + 1) = none) }
        0) =
    some (a, { val := f, property := al })

tactic: apply Subtype.eq
state_before: α : Type u
β : Type v
γ : Type w
a : α
f : Stream' (Option α)
al : IsSeq f
⊢ tail
      { val := some a :: ↑{ val := f, property := al },
        property :=
          (_ :
            ∀ {n : ℕ},
              (some a :: ↑{ val := f, property := al }) n = none →
                (some a :: ↑{ val := f, property := al }) (n + 1) = none) } =
    { val := f, property := al }

tactic: dsimp [tail]
state_before: case a
α : Type u
β : Type v
γ : Type w
a : α
f : Stream' (Option α)
al : IsSeq f
⊢ ↑(tail
        { val := some a :: ↑{ val := f, property := al },
          property :=
            (_ :
              ∀ {n : ℕ},
                (some a :: ↑{ val := f, property := al }) n = none →
                  (some a :: ↑{ val := f, property := al }) (n + 1) = none) }) =
    ↑{ val := f, property := al }
Theorem: IsLeast.insert
File: Mathlib/Order/Bounds/Basic.lean

tactic: rw [insert_eq]
state_before: α : Type u
β : Type v
γ : Type w
ι : Sort x
inst✝² : Preorder α
inst✝¹ : Preorder β
s✝ t : Set α
a✝ b✝ : α
inst✝ : LinearOrder γ
a b : γ
s : Set γ
hs : IsLeast s b
⊢ IsLeast (Insert.insert a s) (min a b)

tactic: exact isLeast_singleton.union hs
state_before: α : Type u
β : Type v
γ : Type w
ι : Sort x
inst✝² : Preorder α
inst✝¹ : Preorder β
s✝ t : Set α
a✝ b✝ : α
inst✝ : LinearOrder γ
a b : γ
s : Set γ
hs : IsLeast s b
⊢ IsLeast ({a} ∪ s) (min a b)
Theorem: MeasureTheory.lintegral_iUnion_le
File: Mathlib/MeasureTheory/Integral/Lebesgue.lean

tactic: rw [← lintegral_sum_measure]
state_before: α : Type u_2
β : Type u_1
γ : Type ?u.1026302
δ : Type ?u.1026305
m : MeasurableSpace α
μ ν : Measure α
inst✝ : Countable β
s : β → Set α
f : α → ℝ≥0∞
⊢ (∫⁻ (a : α) in ⋃ (i : β), s i, f a ∂μ) ≤ ∑' (i : β), ∫⁻ (a : α) in s i, f a ∂μ

tactic: exact lintegral_mono' restrict_iUnion_le le_rfl
state_before: α : Type u_2
β : Type u_1
γ : Type ?u.1026302
δ : Type ?u.1026305
m : MeasurableSpace α
μ ν : Measure α
inst✝ : Countable β
s : β → Set α
f : α → ℝ≥0∞
⊢ (∫⁻ (a : α) in ⋃ (i : β), s i, f a ∂μ) ≤ ∫⁻ (a : α), f a ∂sum fun i => Measure.restrict μ (s i)
Theorem: Set.offDiag_eq_empty
File: Mathlib/Data/Set/Prod.lean

tactic: rw [← not_nonempty_iff_eq_empty, ← not_nontrivial_iff, offDiag_nonempty.not]
state_before: α : Type u_1
s t : Set α
x : α × α
a : α
⊢ offDiag s = ∅ ↔ Set.Subsingleton s
Theorem: MonoidHom.comp_coprod
File: Mathlib/Algebra/Group/Prod.lean

tactic: simp
state_before: A : Type ?u.73446
B : Type ?u.73449
G : Type ?u.73452
H : Type ?u.73455
M : Type u_3
N : Type u_4
P : Type u_2
inst✝³ : MulOneClass M
inst✝² : MulOneClass N
inst✝¹ : CommMonoid P
f✝ : M →* P
g✝ : N →* P
Q : Type u_1
inst✝ : CommMonoid Q
h : P →* Q
f : M →* P
g : N →* P
x : M × N
⊢ ↑(comp h (coprod f g)) x = ↑(coprod (comp h f) (comp h g)) x
Theorem: SetLike.forall_smul_mem_iff
File: Mathlib/GroupTheory/GroupAction/SubMulAction.lean

tactic: simpa using h 1
state_before: S✝ : Type u'
T : Type u''
R✝ : Type u
M✝ : Type v
inst✝⁵ : SMul R✝ M✝
inst✝⁴ : SetLike S✝ M✝
hS : SMulMemClass S✝ R✝ M✝
s : S✝
R : Type u_1
M : Type u_2
S : Type u_3
inst✝³ : Monoid R
inst✝² : MulAction R M
inst✝¹ : SetLike S M
inst✝ : SMulMemClass S R M
N : S
x : M
h : ∀ (a : R), a • x ∈ N
⊢ x ∈ N
Theorem: Associates.dvd_count_pow
File: Mathlib/RingTheory/UniqueFactorizationDomain.lean

tactic: rw [count_pow ha hp]
state_before: α : Type u_1
inst✝² : CancelCommMonoidWithZero α
dec_irr : (p : Associates α) → Decidable (Irreducible p)
inst✝¹ : UniqueFactorizationMonoid α
dec : DecidableEq α
dec' : DecidableEq (Associates α)
inst✝ : Nontrivial α
a : Associates α
ha : a ≠ 0
p : Associates α
hp : Irreducible p
k : ℕ
⊢ k ∣ count p (factors (a ^ k))

tactic: apply dvd_mul_right
state_before: α : Type u_1
inst✝² : CancelCommMonoidWithZero α
dec_irr : (p : Associates α) → Decidable (Irreducible p)
inst✝¹ : UniqueFactorizationMonoid α
dec : DecidableEq α
dec' : DecidableEq (Associates α)
inst✝ : Nontrivial α
a : Associates α
ha : a ≠ 0
p : Associates α
hp : Irreducible p
k : ℕ
⊢ k ∣ k * count p (factors a)
Theorem: eq_of_slope_eq_zero
File: Mathlib/LinearAlgebra/AffineSpace/Slope.lean

tactic: rw [← sub_smul_slope_vadd f a b, h, smul_zero, zero_vadd]
state_before: k : Type u_2
E : Type u_1
PE : Type u_3
inst✝³ : Field k
inst✝² : AddCommGroup E
inst✝¹ : Module k E
inst✝ : AddTorsor E PE
f : k → PE
a b : k
h : slope f a b = 0
⊢ f a = f b
Theorem: CategoryTheory.Abelian.coimageIsoImage'_hom
File: Mathlib/CategoryTheory/Abelian/Basic.lean

tactic: simp [← cancel_mono (Limits.image.ι f)]
state_before: C : Type u
inst✝¹ : Category C
inst✝ : Abelian C
X Y : C
f : X ⟶ Y
⊢ kernel.ι f ≫ factorThruImage f = 0

tactic: apply coequalizer.hom_ext
state_before: C : Type u
inst✝¹ : Category C
inst✝ : Abelian C
X Y : C
f : X ⟶ Y
⊢ (coimageIsoImage' f).hom = cokernel.desc (kernel.ι f) (factorThruImage f) (_ : kernel.ι f ≫ factorThruImage f = 0)

tactic: simp only [← cancel_mono (Limits.image.ι f), IsImage.isoExt_hom, cokernel.π_desc,
  Category.assoc, IsImage.lift_ι, coimageStrongEpiMonoFactorisation_m,
  Limits.image.fac]
state_before: case h
C : Type u
inst✝¹ : Category C
inst✝ : Abelian C
X Y : C
f : X ⟶ Y
⊢ coequalizer.π (kernel.ι f) 0 ≫ (coimageIsoImage' f).hom =
    coequalizer.π (kernel.ι f) 0 ≫
      cokernel.desc (kernel.ι f) (factorThruImage f) (_ : kernel.ι f ≫ factorThruImage f = 0)
Theorem: AffineIsometryEquiv.dist_pointReflection_fixed
File: Mathlib/Analysis/NormedSpace/AffineIsometry.lean

tactic: rw [← (pointReflection 𝕜 x).dist_map y x, pointReflection_self]
state_before: 𝕜 : Type u_3
V : Type u_2
V₁ : Type ?u.2032361
V₂ : Type ?u.2032364
V₃ : Type ?u.2032367
V₄ : Type ?u.2032370
P₁ : Type ?u.2032373
P : Type u_1
P₂ : Type ?u.2032379
P₃ : Type ?u.2032382
P₄ : Type ?u.2032385
inst✝²¹ : NormedField 𝕜
inst✝²⁰ : SeminormedAddCommGroup V
inst✝¹⁹ : SeminormedAddCommGroup V₁
inst✝¹⁸ : SeminormedAddCommGroup V₂
inst✝¹⁷ : SeminormedAddCommGroup V₃
inst✝¹⁶ : SeminormedAddCommGroup V₄
inst✝¹⁵ : NormedSpace 𝕜 V
inst✝¹⁴ : NormedSpace 𝕜 V₁
inst✝¹³ : NormedSpace 𝕜 V₂
inst✝¹² : NormedSpace 𝕜 V₃
inst✝¹¹ : NormedSpace 𝕜 V₄
inst✝¹⁰ : PseudoMetricSpace P
inst✝⁹ : MetricSpace P₁
inst✝⁸ : PseudoMetricSpace P₂
inst✝⁷ : PseudoMetricSpace P₃
inst✝⁶ : PseudoMetricSpace P₄
inst✝⁵ : NormedAddTorsor V P
inst✝⁴ : NormedAddTorsor V₁ P₁
inst✝³ : NormedAddTorsor V₂ P₂
inst✝² : NormedAddTorsor V₃ P₃
inst✝¹ : NormedAddTorsor V₄ P₄
e : P ≃ᵃⁱ[𝕜] P₂
α : Type ?u.2032909
inst✝ : TopologicalSpace α
x y : P
⊢ dist (↑(pointReflection 𝕜 x) y) x = dist y x
Theorem: Nat.gcd_mul_right
File: Std/Data/Nat/Gcd.lean

tactic: rw [Nat.mul_comm m n, Nat.mul_comm k n, Nat.mul_comm (gcd m k) n, gcd_mul_left]
state_before: m n k : Nat
⊢ gcd (m * n) (k * n) = gcd m k * n
Theorem: Nat.factorization_le_of_le_pow
File: Mathlib/Data/Nat/Factorization/Basic.lean

tactic: rcases eq_or_ne n 0 with (rfl | hn)
state_before: n p b : ℕ
hb : n ≤ p ^ b
⊢ ↑(factorization n) p ≤ b

tactic: by_cases pp : p.Prime
state_before: case inr
n p b : ℕ
hb : n ≤ p ^ b
hn : n ≠ 0
⊢ ↑(factorization n) p ≤ b

tactic: simp
state_before: case inl
p b : ℕ
hb : 0 ≤ p ^ b
⊢ ↑(factorization 0) p ≤ b

tactic: exact (pow_le_iff_le_right pp.two_le).1 (le_trans (ord_proj_le p hn) hb)
state_before: case pos
n p b : ℕ
hb : n ≤ p ^ b
hn : n ≠ 0
pp : Prime p
⊢ ↑(factorization n) p ≤ b

tactic: simp [factorization_eq_zero_of_non_prime n pp]
state_before: case neg
n p b : ℕ
hb : n ≤ p ^ b
hn : n ≠ 0
pp : ¬Prime p
⊢ ↑(factorization n) p ≤ b
Theorem: Metric.glueDist_glued_points
File: Mathlib/Topology/MetricSpace/Gluing.lean

tactic: have : (⨅ q, dist (Φ p) (Φ q) + dist (Ψ p) (Ψ q)) = 0 := by
  have A : ∀ q, 0 ≤ dist (Φ p) (Φ q) + dist (Ψ p) (Ψ q) := fun _ =>
    add_nonneg dist_nonneg dist_nonneg
  refine' le_antisymm _ (le_ciInf A)
  have : 0 = dist (Φ p) (Φ p) + dist (Ψ p) (Ψ p) := by simp
  rw [this]
  exact ciInf_le ⟨0, forall_range_iff.2 A⟩ p
state_before: X : Type u
Y : Type v
Z : Type w
inst✝² : MetricSpace X
inst✝¹ : MetricSpace Y
Φ✝ : Z → X
Ψ✝ : Z → Y
ε✝ : ℝ
inst✝ : Nonempty Z
Φ : Z → X
Ψ : Z → Y
ε : ℝ
p : Z
⊢ glueDist Φ Ψ ε (Sum.inl (Φ p)) (Sum.inr (Ψ p)) = ε

tactic: simp only [glueDist, this, zero_add]
state_before: X : Type u
Y : Type v
Z : Type w
inst✝² : MetricSpace X
inst✝¹ : MetricSpace Y
Φ✝ : Z → X
Ψ✝ : Z → Y
ε✝ : ℝ
inst✝ : Nonempty Z
Φ : Z → X
Ψ : Z → Y
ε : ℝ
p : Z
this : (⨅ (q : Z), dist (Φ p) (Φ q) + dist (Ψ p) (Ψ q)) = 0
⊢ glueDist Φ Ψ ε (Sum.inl (Φ p)) (Sum.inr (Ψ p)) = ε

tactic: have A : ∀ q, 0 ≤ dist (Φ p) (Φ q) + dist (Ψ p) (Ψ q) := fun _ =>
  add_nonneg dist_nonneg dist_nonneg
state_before: X : Type u
Y : Type v
Z : Type w
inst✝² : MetricSpace X
inst✝¹ : MetricSpace Y
Φ✝ : Z → X
Ψ✝ : Z → Y
ε✝ : ℝ
inst✝ : Nonempty Z
Φ : Z → X
Ψ : Z → Y
ε : ℝ
p : Z
⊢ (⨅ (q : Z), dist (Φ p) (Φ q) + dist (Ψ p) (Ψ q)) = 0

tactic: refine' le_antisymm _ (le_ciInf A)
state_before: X : Type u
Y : Type v
Z : Type w
inst✝² : MetricSpace X
inst✝¹ : MetricSpace Y
Φ✝ : Z → X
Ψ✝ : Z → Y
ε✝ : ℝ
inst✝ : Nonempty Z
Φ : Z → X
Ψ : Z → Y
ε : ℝ
p : Z
A : ∀ (q : Z), 0 ≤ dist (Φ p) (Φ q) + dist (Ψ p) (Ψ q)
⊢ (⨅ (q : Z), dist (Φ p) (Φ q) + dist (Ψ p) (Ψ q)) = 0

tactic: have : 0 = dist (Φ p) (Φ p) + dist (Ψ p) (Ψ p) := by simp
state_before: X : Type u
Y : Type v
Z : Type w
inst✝² : MetricSpace X
inst✝¹ : MetricSpace Y
Φ✝ : Z → X
Ψ✝ : Z → Y
ε✝ : ℝ
inst✝ : Nonempty Z
Φ : Z → X
Ψ : Z → Y
ε : ℝ
p : Z
A : ∀ (q : Z), 0 ≤ dist (Φ p) (Φ q) + dist (Ψ p) (Ψ q)
⊢ (⨅ (q : Z), dist (Φ p) (Φ q) + dist (Ψ p) (Ψ q)) ≤ 0

tactic: rw [this]
state_before: X : Type u
Y : Type v
Z : Type w
inst✝² : MetricSpace X
inst✝¹ : MetricSpace Y
Φ✝ : Z → X
Ψ✝ : Z → Y
ε✝ : ℝ
inst✝ : Nonempty Z
Φ : Z → X
Ψ : Z → Y
ε : ℝ
p : Z
A : ∀ (q : Z), 0 ≤ dist (Φ p) (Φ q) + dist (Ψ p) (Ψ q)
this : 0 = dist (Φ p) (Φ p) + dist (Ψ p) (Ψ p)
⊢ (⨅ (q : Z), dist (Φ p) (Φ q) + dist (Ψ p) (Ψ q)) ≤ 0

tactic: exact ciInf_le ⟨0, forall_range_iff.2 A⟩ p
state_before: X : Type u
Y : Type v
Z : Type w
inst✝² : MetricSpace X
inst✝¹ : MetricSpace Y
Φ✝ : Z → X
Ψ✝ : Z → Y
ε✝ : ℝ
inst✝ : Nonempty Z
Φ : Z → X
Ψ : Z → Y
ε : ℝ
p : Z
A : ∀ (q : Z), 0 ≤ dist (Φ p) (Φ q) + dist (Ψ p) (Ψ q)
this : 0 = dist (Φ p) (Φ p) + dist (Ψ p) (Ψ p)
⊢ (⨅ (q : Z), dist (Φ p) (Φ q) + dist (Ψ p) (Ψ q)) ≤ dist (Φ p) (Φ p) + dist (Ψ p) (Ψ p)

tactic: simp
state_before: X : Type u
Y : Type v
Z : Type w
inst✝² : MetricSpace X
inst✝¹ : MetricSpace Y
Φ✝ : Z → X
Ψ✝ : Z → Y
ε✝ : ℝ
inst✝ : Nonempty Z
Φ : Z → X
Ψ : Z → Y
ε : ℝ
p : Z
A : ∀ (q : Z), 0 ≤ dist (Φ p) (Φ q) + dist (Ψ p) (Ψ q)
⊢ 0 = dist (Φ p) (Φ p) + dist (Ψ p) (Ψ p)
Theorem: Set.pi_univ_Icc
File: Mathlib/Data/Set/Intervals/Pi.lean

tactic: simp [Pi.le_def, forall_and]
state_before: ι : Type u_1
α : ι → Type u_2
inst✝ : (i : ι) → Preorder (α i)
x y✝ y : (i : ι) → α i
⊢ (y ∈ pi univ fun i => Icc (x i) (y✝ i)) ↔ y ∈ Icc x y✝
Theorem: Multiset.le_inf
File: Mathlib/Data/Multiset/Lattice.lean

tactic: simp
state_before: α : Type u_1
inst✝¹ : SemilatticeInf α
inst✝ : OrderTop α
s : Multiset α
a : α
⊢ a ≤ inf 0 ↔ ∀ (b : α), b ∈ 0 → a ≤ b

tactic: simp (config := { contextual := true }) [or_imp, forall_and]
state_before: α : Type u_1
inst✝¹ : SemilatticeInf α
inst✝ : OrderTop α
s : Multiset α
a : α
⊢ ∀ ⦃a_1 : α⦄ {s : Multiset α},
    (a ≤ inf s ↔ ∀ (b : α), b ∈ s → a ≤ b) → (a ≤ inf (a_1 ::ₘ s) ↔ ∀ (b : α), b ∈ a_1 ::ₘ s → a ≤ b)
Theorem: stoneCech_hom_ext
File: Mathlib/Topology/StoneCech.lean

tactic: apply Continuous.ext_on denseRange_stoneCechUnit h₁ h₂
state_before: α : Type u
inst✝⁵ : TopologicalSpace α
γ : Type u
inst✝⁴ : TopologicalSpace γ
inst✝³ : T2Space γ
inst✝² : CompactSpace γ
γ' : Type u
inst✝¹ : TopologicalSpace γ'
inst✝ : T2Space γ'
f : α → γ
hf : Continuous f
g₁ g₂ : StoneCech α → γ'
h₁ : Continuous g₁
h₂ : Continuous g₂
h : g₁ ∘ stoneCechUnit = g₂ ∘ stoneCechUnit
⊢ g₁ = g₂

tactic: rintro x ⟨x, rfl⟩
state_before: α : Type u
inst✝⁵ : TopologicalSpace α
γ : Type u
inst✝⁴ : TopologicalSpace γ
inst✝³ : T2Space γ
inst✝² : CompactSpace γ
γ' : Type u
inst✝¹ : TopologicalSpace γ'
inst✝ : T2Space γ'
f : α → γ
hf : Continuous f
g₁ g₂ : StoneCech α → γ'
h₁ : Continuous g₁
h₂ : Continuous g₂
h : g₁ ∘ stoneCechUnit = g₂ ∘ stoneCechUnit
⊢ EqOn g₁ g₂ (range stoneCechUnit)

tactic: apply congr_fun h x
state_before: case intro
α : Type u
inst✝⁵ : TopologicalSpace α
γ : Type u
inst✝⁴ : TopologicalSpace γ
inst✝³ : T2Space γ
inst✝² : CompactSpace γ
γ' : Type u
inst✝¹ : TopologicalSpace γ'
inst✝ : T2Space γ'
f : α → γ
hf : Continuous f
g₁ g₂ : StoneCech α → γ'
h₁ : Continuous g₁
h₂ : Continuous g₂
h : g₁ ∘ stoneCechUnit = g₂ ∘ stoneCechUnit
x : α
⊢ g₁ (stoneCechUnit x) = g₂ (stoneCechUnit x)
Theorem: Nat.coprime_add_self_left
File: Mathlib/Data/Nat/GCD/Basic.lean

tactic: rw [coprime, coprime, gcd_add_self_left]
state_before: m n : ℕ
⊢ coprime (m + n) n ↔ coprime m n
Theorem: Complex.sinh_conj
File: Mathlib/Data/Complex/Exponential.lean

tactic: rw [sinh, ← RingHom.map_neg, exp_conj, exp_conj, ← RingHom.map_sub, sinh, map_div₀]
state_before: x y : ℂ
⊢ sinh (↑(starRingEnd ℂ) x) = ↑(starRingEnd ℂ) (sinh x)

tactic: simp [← one_add_one_eq_two]
state_before: x y : ℂ
⊢ ↑(starRingEnd ℂ) (exp x - exp (-x)) / 2 = ↑(starRingEnd ℂ) (exp x - exp (-x)) / ↑(starRingEnd ℂ) 2
Theorem: Set.mulSupport_mulIndicator
File: Mathlib/Algebra/IndicatorFunction.lean

tactic: simp [Function.mem_mulSupport, mulIndicator_apply_eq_one]
state_before: α : Type u_1
β : Type ?u.7242
ι : Type ?u.7245
M : Type u_2
N : Type ?u.7251
inst✝¹ : One M
inst✝ : One N
s t : Set α
f g : α → M
a x : α
⊢ x ∈ mulSupport (mulIndicator s f) ↔ x ∈ s ∩ mulSupport f
Theorem: pi_Iio_mem_nhds
File: Mathlib/Topology/Order/Basic.lean

tactic: refine' mem_of_superset (set_pi_mem_nhds Set.finite_univ fun i _ => _) (pi_univ_Iio_subset a)
state_before: α : Type u
β : Type v
γ : Type w
inst✝⁷ : TopologicalSpace α
inst✝⁶ : LinearOrder α
inst✝⁵ : OrderTopology α
ι : Type u_2
π : ι → Type u_1
inst✝⁴ : Finite ι
inst✝³ : (i : ι) → LinearOrder (π i)
inst✝² : (i : ι) → TopologicalSpace (π i)
inst✝¹ : ∀ (i : ι), OrderTopology (π i)
a b x : (i : ι) → π i
a' b' x' : ι → α
inst✝ : Nonempty ι
ha : ∀ (i : ι), x i < a i
⊢ Iio a ∈ 𝓝 x

tactic: exact Iio_mem_nhds (ha i)
state_before: α : Type u
β : Type v
γ : Type w
inst✝⁷ : TopologicalSpace α
inst✝⁶ : LinearOrder α
inst✝⁵ : OrderTopology α
ι : Type u_2
π : ι → Type u_1
inst✝⁴ : Finite ι
inst✝³ : (i : ι) → LinearOrder (π i)
inst✝² : (i : ι) → TopologicalSpace (π i)
inst✝¹ : ∀ (i : ι), OrderTopology (π i)
a b x : (i : ι) → π i
a' b' x' : ι → α
inst✝ : Nonempty ι
ha : ∀ (i : ι), x i < a i
i : ι
x✝ : i ∈ univ
⊢ Iio (a i) ∈ 𝓝 (x i)
Theorem: List.erase_cons
File: Std/Data/List/Lemmas.lean

tactic: simp [List.erase, h]
state_before: α : Type u_1
inst✝ : DecidableEq α
a b : α
l : List α
h : b = a
⊢ List.erase (b :: l) a = if b = a then l else b :: List.erase l a

tactic: simp [List.erase, h, (beq_eq_false_iff_ne _ _).2 h]
state_before: α : Type u_1
inst✝ : DecidableEq α
a b : α
l : List α
h : ¬b = a
⊢ List.erase (b :: l) a = if b = a then l else b :: List.erase l a
Theorem: Finset.affineCombination_apply_const
File: Mathlib/LinearAlgebra/AffineSpace/Combination.lean

tactic: rw [affineCombination_apply, s.weightedVSubOfPoint_apply_const, h, one_smul, vsub_vadd]
state_before: k : Type u_1
V : Type u_4
P : Type u_3
inst✝² : Ring k
inst✝¹ : AddCommGroup V
inst✝ : Module k V
S : AffineSpace V P
ι : Type u_2
s : Finset ι
ι₂ : Type ?u.247728
s₂ : Finset ι₂
w : ι → k
p : P
h : ∑ i in s, w i = 1
⊢ ↑(affineCombination k s fun x => p) w = p
Theorem: MatrixEquivTensor.right_inv
File: Mathlib/RingTheory/MatrixAlgebra.lean

tactic: simp only [invFun, AlgHom.map_sum, stdBasisMatrix, apply_ite ↑(algebraMap R A), smul_eq_mul,
  mul_boole, toFunAlgHom_apply, RingHom.map_zero, RingHom.map_one, Matrix.map_apply,
  Pi.smul_def]
state_before: R : Type u
inst✝⁴ : CommSemiring R
A : Type v
inst✝³ : Semiring A
inst✝² : Algebra R A
n : Type w
inst✝¹ : DecidableEq n
inst✝ : Fintype n
M : Matrix n n A
⊢ ↑(toFunAlgHom R A n) (invFun R A n M) = M

tactic: convert Finset.sum_product (β := Matrix n n A)
state_before: R : Type u
inst✝⁴ : CommSemiring R
A : Type v
inst✝³ : Semiring A
inst✝² : Algebra R A
n : Type w
inst✝¹ : DecidableEq n
inst✝ : Fintype n
M : Matrix n n A
⊢ ∑ x : n × n, M x.fst x.snd • Matrix.map (fun i' j' => if x.fst = i' ∧ x.snd = j' then 1 else 0) ↑(algebraMap R A) = M

tactic: conv_lhs => rw [matrix_eq_sum_std_basis M]
state_before: case h.e'_3
R : Type u
inst✝⁴ : CommSemiring R
A : Type v
inst✝³ : Semiring A
inst✝² : Algebra R A
n : Type w
inst✝¹ : DecidableEq n
inst✝ : Fintype n
M : Matrix n n A
⊢ M =
    ∑ x : n,
      ∑ y : n,
        M (x, y).fst (x, y).snd •
          Matrix.map (fun i' j' => if (x, y).fst = i' ∧ (x, y).snd = j' then 1 else 0) ↑(algebraMap R A)

tactic: refine Finset.sum_congr rfl fun i _ => Finset.sum_congr rfl fun j _ => Matrix.ext fun a b => ?_
state_before: case h.e'_3
R : Type u
inst✝⁴ : CommSemiring R
A : Type v
inst✝³ : Semiring A
inst✝² : Algebra R A
n : Type w
inst✝¹ : DecidableEq n
inst✝ : Fintype n
M : Matrix n n A
⊢ ∑ i : n, ∑ j : n, stdBasisMatrix i j (M i j) =
    ∑ x : n,
      ∑ y : n,
        M (x, y).fst (x, y).snd •
          Matrix.map (fun i' j' => if (x, y).fst = i' ∧ (x, y).snd = j' then 1 else 0) ↑(algebraMap R A)

tactic: simp only [stdBasisMatrix, smul_apply, Matrix.map_apply]
state_before: case h.e'_3
R : Type u
inst✝⁴ : CommSemiring R
A : Type v
inst✝³ : Semiring A
inst✝² : Algebra R A
n : Type w
inst✝¹ : DecidableEq n
inst✝ : Fintype n
M : Matrix n n A
i : n
x✝¹ : i ∈ Finset.univ
j : n
x✝ : j ∈ Finset.univ
a b : n
⊢ stdBasisMatrix i j (M i j) a b =
    (M (i, j).fst (i, j).snd •
        Matrix.map (fun i' j' => if (i, j).fst = i' ∧ (i, j).snd = j' then 1 else 0) ↑(algebraMap R A))
      a b

tactic: split_ifs <;> aesop
state_before: case h.e'_3
R : Type u
inst✝⁴ : CommSemiring R
A : Type v
inst✝³ : Semiring A
inst✝² : Algebra R A
n : Type w
inst✝¹ : DecidableEq n
inst✝ : Fintype n
M : Matrix n n A
i : n
x✝¹ : i ∈ Finset.univ
j : n
x✝ : j ∈ Finset.univ
a b : n
⊢ (if i = a ∧ j = b then M i j else 0) = M i j • ↑(algebraMap R A) (if i = a ∧ j = b then 1 else 0)