tasksource/leandojo huggingface dataset:
Theorem: Subgroup.pi_le_iff
File: Mathlib/GroupTheory/Subgroup/Finite.lean

tactic: constructor
state_before: G : Type ?u.39010
inst✝⁴ : Group G
A : Type ?u.39016
inst✝³ : AddGroup A
η : Type u_1
f : η → Type u_2
inst✝² : (i : η) → Group (f i)
inst✝¹ : DecidableEq η
inst✝ : Finite η
H : (i : η) → Subgroup (f i)
J : Subgroup ((i : η) → f i)
⊢ pi univ H ≤ J ↔ ∀ (i : η), map (MonoidHom.single f i) (H i) ≤ J

tactic: rintro h i _ ⟨x, hx, rfl⟩
state_before: case mp
G : Type ?u.39010
inst✝⁴ : Group G
A : Type ?u.39016
inst✝³ : AddGroup A
η : Type u_1
f : η → Type u_2
inst✝² : (i : η) → Group (f i)
inst✝¹ : DecidableEq η
inst✝ : Finite η
H : (i : η) → Subgroup (f i)
J : Subgroup ((i : η) → f i)
⊢ pi univ H ≤ J → ∀ (i : η), map (MonoidHom.single f i) (H i) ≤ J

tactic: apply h
state_before: case mp.intro.intro
G : Type ?u.39010
inst✝⁴ : Group G
A : Type ?u.39016
inst✝³ : AddGroup A
η : Type u_1
f : η → Type u_2
inst✝² : (i : η) → Group (f i)
inst✝¹ : DecidableEq η
inst✝ : Finite η
H : (i : η) → Subgroup (f i)
J : Subgroup ((i : η) → f i)
h : pi univ H ≤ J
i : η
x : f i
hx : x ∈ ↑(H i)
⊢ ↑(MonoidHom.single f i) x ∈ J

tactic: simpa using hx
state_before: case mp.intro.intro.a
G : Type ?u.39010
inst✝⁴ : Group G
A : Type ?u.39016
inst✝³ : AddGroup A
η : Type u_1
f : η → Type u_2
inst✝² : (i : η) → Group (f i)
inst✝¹ : DecidableEq η
inst✝ : Finite η
H : (i : η) → Subgroup (f i)
J : Subgroup ((i : η) → f i)
h : pi univ H ≤ J
i : η
x : f i
hx : x ∈ ↑(H i)
⊢ ↑(MonoidHom.single f i) x ∈ pi univ H

tactic: exact fun h x hx => pi_mem_of_mulSingle_mem x fun i => h i (mem_map_of_mem _ (hx i trivial))
state_before: case mpr
G : Type ?u.39010
inst✝⁴ : Group G
A : Type ?u.39016
inst✝³ : AddGroup A
η : Type u_1
f : η → Type u_2
inst✝² : (i : η) → Group (f i)
inst✝¹ : DecidableEq η
inst✝ : Finite η
H : (i : η) → Subgroup (f i)
J : Subgroup ((i : η) → f i)
⊢ (∀ (i : η), map (MonoidHom.single f i) (H i) ≤ J) → pi univ H ≤ J
Theorem: max_div_div_left'
File: Mathlib/Algebra/Order/Group/MinMax.lean

tactic: simp only [div_eq_mul_inv, max_mul_mul_left, max_inv_inv']
state_before: α : Type u_1
inst✝ : LinearOrderedCommGroup α
a✝ b✝ c✝ a b c : α
⊢ max (a / b) (a / c) = a / min b c
Theorem: Real.map_linearMap_volume_pi_eq_smul_volume_pi
File: Mathlib/MeasureTheory/Measure/Lebesgue/Basic.lean

tactic: classical
  let M := LinearMap.toMatrix' f
  have A : LinearMap.det f = det M := by simp only [LinearMap.det_toMatrix']
  have B : f = toLin' M := by simp only [toLin'_toMatrix']
  rw [A, B]
  apply map_matrix_volume_pi_eq_smul_volume_pi
  rwa [A] at hf
state_before: ι : Type u_1
inst✝ : Fintype ι
f : (ι → ℝ) →ₗ[ℝ] ι → ℝ
hf : ↑LinearMap.det f ≠ 0
⊢ Measure.map (↑f) volume = ofReal (abs (↑LinearMap.det f)⁻¹) • volume

tactic: let M := LinearMap.toMatrix' f
state_before: ι : Type u_1
inst✝ : Fintype ι
f : (ι → ℝ) →ₗ[ℝ] ι → ℝ
hf : ↑LinearMap.det f ≠ 0
⊢ Measure.map (↑f) volume = ofReal (abs (↑LinearMap.det f)⁻¹) • volume

tactic: have A : LinearMap.det f = det M := by simp only [LinearMap.det_toMatrix']
state_before: ι : Type u_1
inst✝ : Fintype ι
f : (ι → ℝ) →ₗ[ℝ] ι → ℝ
hf : ↑LinearMap.det f ≠ 0
M : (fun x => Matrix ι ι ℝ) f := ↑LinearMap.toMatrix' f
⊢ Measure.map (↑f) volume = ofReal (abs (↑LinearMap.det f)⁻¹) • volume

tactic: have B : f = toLin' M := by simp only [toLin'_toMatrix']
state_before: ι : Type u_1
inst✝ : Fintype ι
f : (ι → ℝ) →ₗ[ℝ] ι → ℝ
hf : ↑LinearMap.det f ≠ 0
M : (fun x => Matrix ι ι ℝ) f := ↑LinearMap.toMatrix' f
A : ↑LinearMap.det f = det M
⊢ Measure.map (↑f) volume = ofReal (abs (↑LinearMap.det f)⁻¹) • volume

tactic: rw [A, B]
state_before: ι : Type u_1
inst✝ : Fintype ι
f : (ι → ℝ) →ₗ[ℝ] ι → ℝ
hf : ↑LinearMap.det f ≠ 0
M : (fun x => Matrix ι ι ℝ) f := ↑LinearMap.toMatrix' f
A : ↑LinearMap.det f = det M
B : f = ↑toLin' M
⊢ Measure.map (↑f) volume = ofReal (abs (↑LinearMap.det f)⁻¹) • volume

tactic: apply map_matrix_volume_pi_eq_smul_volume_pi
state_before: ι : Type u_1
inst✝ : Fintype ι
f : (ι → ℝ) →ₗ[ℝ] ι → ℝ
hf : ↑LinearMap.det f ≠ 0
M : (fun x => Matrix ι ι ℝ) f := ↑LinearMap.toMatrix' f
A : ↑LinearMap.det f = det M
B : f = ↑toLin' M
⊢ Measure.map (↑(↑toLin' M)) volume = ofReal (abs (det M)⁻¹) • volume

tactic: rwa [A] at hf
state_before: case hM
ι : Type u_1
inst✝ : Fintype ι
f : (ι → ℝ) →ₗ[ℝ] ι → ℝ
hf : ↑LinearMap.det f ≠ 0
M : (fun x => Matrix ι ι ℝ) f := ↑LinearMap.toMatrix' f
A : ↑LinearMap.det f = det M
B : f = ↑toLin' M
⊢ det M ≠ 0

tactic: simp only [LinearMap.det_toMatrix']
state_before: ι : Type u_1
inst✝ : Fintype ι
f : (ι → ℝ) →ₗ[ℝ] ι → ℝ
hf : ↑LinearMap.det f ≠ 0
M : (fun x => Matrix ι ι ℝ) f := ↑LinearMap.toMatrix' f
⊢ ↑LinearMap.det f = det M

tactic: simp only [toLin'_toMatrix']
state_before: ι : Type u_1
inst✝ : Fintype ι
f : (ι → ℝ) →ₗ[ℝ] ι → ℝ
hf : ↑LinearMap.det f ≠ 0
M : (fun x => Matrix ι ι ℝ) f := ↑LinearMap.toMatrix' f
A : ↑LinearMap.det f = det M
⊢ f = ↑toLin' M
Theorem: Nat.findGreatest_mono_left
File: Mathlib/Data/Nat/Order/Basic.lean

tactic: intro n
state_before: m n k l : ℕ
P Q : ℕ → Prop
inst✝¹ : DecidablePred P
inst✝ : DecidablePred Q
hPQ : P ≤ Q
⊢ Nat.findGreatest P ≤ Nat.findGreatest Q

tactic: induction' n with n hn
state_before: m n✝ k l : ℕ
P Q : ℕ → Prop
inst✝¹ : DecidablePred P
inst✝ : DecidablePred Q
hPQ : P ≤ Q
n : ℕ
⊢ Nat.findGreatest P n ≤ Nat.findGreatest Q n

tactic: by_cases h : P (n + 1)
state_before: case succ
m n✝ k l : ℕ
P Q : ℕ → Prop
inst✝¹ : DecidablePred P
inst✝ : DecidablePred Q
hPQ : P ≤ Q
n : ℕ
hn : Nat.findGreatest P n ≤ Nat.findGreatest Q n
⊢ Nat.findGreatest P (succ n) ≤ Nat.findGreatest Q (succ n)

tactic: rfl
state_before: case zero
m n k l : ℕ
P Q : ℕ → Prop
inst✝¹ : DecidablePred P
inst✝ : DecidablePred Q
hPQ : P ≤ Q
⊢ Nat.findGreatest P zero ≤ Nat.findGreatest Q zero

tactic: rw [findGreatest_eq h, findGreatest_eq (hPQ _ h)]
state_before: case pos
m n✝ k l : ℕ
P Q : ℕ → Prop
inst✝¹ : DecidablePred P
inst✝ : DecidablePred Q
hPQ : P ≤ Q
n : ℕ
hn : Nat.findGreatest P n ≤ Nat.findGreatest Q n
h : P (n + 1)
⊢ Nat.findGreatest P (succ n) ≤ Nat.findGreatest Q (succ n)

tactic: rw [findGreatest_of_not h]
state_before: case neg
m n✝ k l : ℕ
P Q : ℕ → Prop
inst✝¹ : DecidablePred P
inst✝ : DecidablePred Q
hPQ : P ≤ Q
n : ℕ
hn : Nat.findGreatest P n ≤ Nat.findGreatest Q n
h : ¬P (n + 1)
⊢ Nat.findGreatest P (succ n) ≤ Nat.findGreatest Q (succ n)

tactic: exact hn.trans (Nat.findGreatest_mono_right _ <| le_succ _)
state_before: case neg
m n✝ k l : ℕ
P Q : ℕ → Prop
inst✝¹ : DecidablePred P
inst✝ : DecidablePred Q
hPQ : P ≤ Q
n : ℕ
hn : Nat.findGreatest P n ≤ Nat.findGreatest Q n
h : ¬P (n + 1)
⊢ Nat.findGreatest P n ≤ Nat.findGreatest Q (succ n)
Theorem: FractionalIdeal.mul_induction_on
File: Mathlib/RingTheory/FractionalIdeal.lean

tactic: simp only [mul_def] at hr
state_before: R : Type u_1
inst✝² : CommRing R
S : Submonoid R
P : Type u_2
inst✝¹ : CommRing P
inst✝ : Algebra R P
loc : IsLocalization S P
I J : FractionalIdeal S P
C : P → Prop
r : P
hr : r ∈ I * J
hm : ∀ (i : P), i ∈ I → ∀ (j : P), j ∈ J → C (i * j)
ha : ∀ (x y : P), C x → C y → C (x + y)
⊢ C r

tactic: exact Submodule.mul_induction_on hr hm ha
state_before: R : Type u_1
inst✝² : CommRing R
S : Submonoid R
P : Type u_2
inst✝¹ : CommRing P
inst✝ : Algebra R P
loc : IsLocalization S P
I J : FractionalIdeal S P
C : P → Prop
r : P
hm : ∀ (i : P), i ∈ I → ∀ (j : P), j ∈ J → C (i * j)
ha : ∀ (x y : P), C x → C y → C (x + y)
hr : r ∈ { val := ↑I * ↑J, property := (_ : IsFractional S (↑I * ↑J)) }
⊢ C r
Theorem: Polynomial.degree_multiset_prod_le
File: Mathlib/Algebra/Polynomial/BigOperators.lean

tactic: simpa using degree_list_prod_le
state_before: R : Type u
ι : Type w
s : Finset ι
inst✝ : CommSemiring R
f : ι → R[X]
t : Multiset R[X]
⊢ ∀ (a : List R[X]),
    degree (prod (Quotient.mk (List.isSetoid R[X]) a)) ≤
      Multiset.sum (Multiset.map degree (Quotient.mk (List.isSetoid R[X]) a))
Theorem: MeasurableSet.isClopenable
File: Mathlib/MeasureTheory/Constructions/Polish.lean

tactic: revert s
state_before: α : Type u_1
inst✝³ : TopologicalSpace α
ι : Type ?u.62603
inst✝² : PolishSpace α
inst✝¹ : MeasurableSpace α
inst✝ : BorelSpace α
s : Set α
hs : MeasurableSet s
⊢ IsClopenable s

tactic: apply MeasurableSet.induction_on_open
state_before: α : Type u_1
inst✝³ : TopologicalSpace α
ι : Type ?u.62603
inst✝² : PolishSpace α
inst✝¹ : MeasurableSpace α
inst✝ : BorelSpace α
⊢ ∀ {s : Set α}, MeasurableSet s → IsClopenable s

tactic: exact fun u hu => hu.isClopenable
state_before: case h_open
α : Type u_1
inst✝³ : TopologicalSpace α
ι : Type ?u.62603
inst✝² : PolishSpace α
inst✝¹ : MeasurableSpace α
inst✝ : BorelSpace α
⊢ ∀ (U : Set α), IsOpen U → IsClopenable U

tactic: exact fun u _ h'u => h'u.compl
state_before: case h_compl
α : Type u_1
inst✝³ : TopologicalSpace α
ι : Type ?u.62603
inst✝² : PolishSpace α
inst✝¹ : MeasurableSpace α
inst✝ : BorelSpace α
⊢ ∀ (t : Set α), MeasurableSet t → IsClopenable t → IsClopenable (tᶜ)

tactic: exact fun f _ _ hf => IsClopenable.iUnion hf
state_before: case h_union
α : Type u_1
inst✝³ : TopologicalSpace α
ι : Type ?u.62603
inst✝² : PolishSpace α
inst✝¹ : MeasurableSpace α
inst✝ : BorelSpace α
⊢ ∀ (f : ℕ → Set α),
    Pairwise (Disjoint on f) →
      (∀ (i : ℕ), MeasurableSet (f i)) → (∀ (i : ℕ), IsClopenable (f i)) → IsClopenable (⋃ (i : ℕ), f i)
Theorem: Polynomial.Chebyshev.T_two
File: Mathlib/RingTheory/Polynomial/Chebyshev.lean

tactic: simp only [T, sub_left_inj, sq, mul_assoc]
state_before: R : Type u_1
S : Type ?u.3233
inst✝¹ : CommRing R
inst✝ : CommRing S
⊢ T R 2 = 2 * X ^ 2 - 1
Theorem: Real.arccos_zero
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Inverse.lean

tactic: simp [arccos]
state_before: ⊢ arccos 0 = π / 2
Theorem: Multiset.map_toEnumFinset_fst
File: Mathlib/Data/Multiset/Fintype.lean

tactic: ext x
state_before: α : Type u_1
inst✝ : DecidableEq α
m✝ m : Multiset α
⊢ map Prod.fst (toEnumFinset m).val = m

tactic: simp only [Multiset.count_map, ← Finset.filter_val, Multiset.toEnumFinset_filter_eq,
  Finset.map_val, Finset.range_val, Multiset.card_map, Multiset.card_range]
state_before: case a
α : Type u_1
inst✝ : DecidableEq α
m✝ m : Multiset α
x : α
⊢ count x (map Prod.fst (toEnumFinset m).val) = count x m
Theorem: Complex.exp_conj
File: Mathlib/Data/Complex/Exponential.lean

tactic: dsimp [exp]
state_before: x y : ℂ
⊢ exp (↑(starRingEnd ℂ) x) = ↑(starRingEnd ℂ) (exp x)

tactic: rw [← lim_conj]
state_before: x y : ℂ
⊢ CauSeq.lim (exp' (↑(starRingEnd ℂ) x)) = ↑(starRingEnd ℂ) (CauSeq.lim (exp' x))

tactic: refine' congr_arg CauSeq.lim (CauSeq.ext fun _ => _)
state_before: x y : ℂ
⊢ CauSeq.lim (exp' (↑(starRingEnd ℂ) x)) = CauSeq.lim (cauSeqConj (exp' x))

tactic: dsimp [exp', Function.comp, isCauSeq_conj, cauSeqConj]
state_before: x y : ℂ
x✝ : ℕ
⊢ ↑(exp' (↑(starRingEnd ℂ) x)) x✝ = ↑(cauSeqConj (exp' x)) x✝

tactic: rw [(starRingEnd _).map_sum]
state_before: x y : ℂ
x✝ : ℕ
⊢ ∑ m in range x✝, ↑(starRingEnd ℂ) x ^ m / ↑(Nat.factorial m) =
    ↑(starRingEnd ℂ) (∑ m in range x✝, x ^ m / ↑(Nat.factorial m))

tactic: refine' sum_congr rfl fun n _ => _
state_before: x y : ℂ
x✝ : ℕ
⊢ ∑ m in range x✝, ↑(starRingEnd ℂ) x ^ m / ↑(Nat.factorial m) =
    ∑ x_1 in range x✝, ↑(starRingEnd ℂ) (x ^ x_1 / ↑(Nat.factorial x_1))

tactic: rw [map_div₀, map_pow, ← ofReal_nat_cast, conj_ofReal]
state_before: x y : ℂ
x✝¹ n : ℕ
x✝ : n ∈ range x✝¹
⊢ ↑(starRingEnd ℂ) x ^ n / ↑(Nat.factorial n) = ↑(starRingEnd ℂ) (x ^ n / ↑(Nat.factorial n))
Theorem: Set.inclusion_self
File: Mathlib/Data/Set/Basic.lean

tactic: cases x
state_before: α : Type u_1
s t u : Set α
x : ↑s
⊢ inclusion (_ : s ⊆ s) x = x

tactic: rfl
state_before: case mk
α : Type u_1
s t u : Set α
val✝ : α
property✝ : val✝ ∈ s
⊢ inclusion (_ : s ⊆ s) { val := val✝, property := property✝ } = { val := val✝, property := property✝ }
Theorem: IsGenericPoint.disjoint_iff
File: Mathlib/Topology/Sober.lean

tactic: rw [h.mem_open_set_iff hU, ← not_disjoint_iff_nonempty_inter, Classical.not_not]
state_before: α : Type u_1
β : Type ?u.2254
inst✝¹ : TopologicalSpace α
inst✝ : TopologicalSpace β
x y : α
S U Z : Set α
h : IsGenericPoint x S
hU : IsOpen U
⊢ Disjoint S U ↔ ¬x ∈ U
Theorem: Nat.le_of_sub_eq_zero
File: Std/Data/Nat/Lemmas.lean

tactic: rw [Nat.sub_zero] at H
state_before: n : Nat
H : n - 0 = 0
⊢ n ≤ 0

tactic: simp [H]
state_before: n : Nat
H : n = 0
⊢ n ≤ 0

tactic: simp [Nat.add_sub_add_right] at H
state_before: n m : Nat
H : n + 1 - (m + 1) = 0
⊢ n - m = 0

tactic: exact H
state_before: n m : Nat
H : n - m = 0
⊢ n - m = 0
Theorem: TrivSqZeroExt.eq_smul_exp_of_invertible
File: Mathlib/Analysis/NormedSpace/TrivSqZeroExt.lean

tactic: rw [← inr_smul, exp_inr, smul_add, ← inl_one, ← inl_smul, ← inr_smul, smul_eq_mul, mul_one,
  smul_smul, mul_invOf_self, one_smul, inl_fst_add_inr_snd_eq]
state_before: 𝕜 : Type u_3
R : Type u_1
M : Type u_2
inst✝¹⁶ : IsROrC 𝕜
inst✝¹⁵ : NormedCommRing R
inst✝¹⁴ : AddCommGroup M
inst✝¹³ : NormedAlgebra 𝕜 R
inst✝¹² : Module R M
inst✝¹¹ : Module Rᵐᵒᵖ M
inst✝¹⁰ : IsCentralScalar R M
inst✝⁹ : Module 𝕜 M
inst✝⁸ : IsScalarTower 𝕜 R M
inst✝⁷ : TopologicalSpace M
inst✝⁶ : TopologicalRing R
inst✝⁵ : TopologicalAddGroup M
inst✝⁴ : ContinuousSMul R M
inst✝³ : CompleteSpace R
inst✝² : T2Space R
inst✝¹ : T2Space M
x : tsze R M
inst✝ : Invertible (fst x)
⊢ x = fst x • exp 𝕜 (⅟(fst x) • inr (snd x))
Theorem: MvPolynomial.noZeroDivisors_of_finite
File: Mathlib/RingTheory/Polynomial/Basic.lean

tactic: cases nonempty_fintype σ
state_before: R✝ : Type u
S : Type ?u.794295
σ✝ : Type v
M : Type w
inst✝⁶ : CommRing R✝
inst✝⁵ : CommRing S
inst✝⁴ : AddCommGroup M
inst✝³ : Module R✝ M
R : Type u
σ : Type v
inst✝² : CommSemiring R
inst✝¹ : Finite σ
inst✝ : NoZeroDivisors R
⊢ NoZeroDivisors (MvPolynomial σ R)

tactic: haveI := noZeroDivisors_fin R (Fintype.card σ)
state_before: case intro
R✝ : Type u
S : Type ?u.794295
σ✝ : Type v
M : Type w
inst✝⁶ : CommRing R✝
inst✝⁵ : CommRing S
inst✝⁴ : AddCommGroup M
inst✝³ : Module R✝ M
R : Type u
σ : Type v
inst✝² : CommSemiring R
inst✝¹ : Finite σ
inst✝ : NoZeroDivisors R
val✝ : Fintype σ
⊢ NoZeroDivisors (MvPolynomial σ R)

tactic: exact (renameEquiv R (Fintype.equivFin σ)).injective.noZeroDivisors _ (map_zero _) (map_mul _)
state_before: case intro
R✝ : Type u
S : Type ?u.794295
σ✝ : Type v
M : Type w
inst✝⁶ : CommRing R✝
inst✝⁵ : CommRing S
inst✝⁴ : AddCommGroup M
inst✝³ : Module R✝ M
R : Type u
σ : Type v
inst✝² : CommSemiring R
inst✝¹ : Finite σ
inst✝ : NoZeroDivisors R
val✝ : Fintype σ
this : NoZeroDivisors (MvPolynomial (Fin (Fintype.card σ)) R)
⊢ NoZeroDivisors (MvPolynomial σ R)
Theorem: Nat.properDivisors_one
File: Mathlib/NumberTheory/Divisors.lean

tactic: rw [properDivisors, Ico_self, filter_empty]
state_before: n : ℕ
⊢ properDivisors 1 = ∅
Theorem: PGame.lf_def
File: Mathlib/SetTheory/Game/PGame.lean

tactic: rw [lf_iff_exists_le]
state_before: x y : PGame
⊢ x ⧏ y ↔
    (∃ i,
        (∀ (i' : LeftMoves x), moveLeft x i' ⧏ moveLeft y i) ∧
          ∀ (j : RightMoves (moveLeft y i)), x ⧏ moveRight (moveLeft y i) j) ∨
      ∃ j,
        (∀ (i : LeftMoves (moveRight x j)), moveLeft (moveRight x j) i ⧏ y) ∧
          ∀ (j' : RightMoves y), moveRight x j ⧏ moveRight y j'

tactic: conv =>
  lhs
  simp only [le_iff_forall_lf]
state_before: x y : PGame
⊢ ((∃ i, x ≤ moveLeft y i) ∨ ∃ j, moveRight x j ≤ y) ↔
    (∃ i,
        (∀ (i' : LeftMoves x), moveLeft x i' ⧏ moveLeft y i) ∧
          ∀ (j : RightMoves (moveLeft y i)), x ⧏ moveRight (moveLeft y i) j) ∨
      ∃ j,
        (∀ (i : LeftMoves (moveRight x j)), moveLeft (moveRight x j) i ⧏ y) ∧
          ∀ (j' : RightMoves y), moveRight x j ⧏ moveRight y j'
Theorem: Multiset.inf_union
File: Mathlib/Data/Multiset/Lattice.lean

tactic: rw [← inf_dedup, dedup_ext.2, inf_dedup, inf_add]
state_before: α : Type u_1
inst✝² : SemilatticeInf α
inst✝¹ : OrderTop α
inst✝ : DecidableEq α
s₁ s₂ : Multiset α
⊢ inf (s₁ ∪ s₂) = inf s₁ ⊓ inf s₂

tactic: simp
state_before: α : Type u_1
inst✝² : SemilatticeInf α
inst✝¹ : OrderTop α
inst✝ : DecidableEq α
s₁ s₂ : Multiset α
⊢ ∀ (a : α), a ∈ s₁ ∪ s₂ ↔ a ∈ s₁ + s₂
Theorem: mul_div_right_comm
File: Mathlib/Algebra/Group/Basic.lean

tactic: simp
state_before: α : Type u_1
β : Type ?u.38312
G : Type ?u.38315
inst✝ : DivisionCommMonoid α
a b c d : α
⊢ a * b / c = a / c * b
Theorem: Filter.HasAntitoneBasis.mem_iff
File: Mathlib/Order/Filter/Bases.lean

tactic: simp only [exists_prop, true_and]
state_before: α : Type u_2
β : Type ?u.95817
γ : Type ?u.95820
ι : Type u_1
ι' : Sort ?u.95826
inst✝ : Preorder ι
l : Filter α
s : ι → Set α
hs : HasAntitoneBasis l s
t : Set α
⊢ (∃ i, True ∧ s i ⊆ t) ↔ ∃ i, s i ⊆ t
Theorem: div_lt_div_iff_right
File: Mathlib/Algebra/Order/Group/Defs.lean

tactic: simpa only [div_eq_mul_inv] using mul_lt_mul_iff_right _
state_before: α : Type u
inst✝² : Group α
inst✝¹ : LT α
inst✝ : CovariantClass α α (swap fun x x_1 => x * x_1) fun x x_1 => x < x_1
a b c✝ d c : α
⊢ a / c < b / c ↔ a < b
Theorem: HasDerivAtFilter.const_smul
File: Mathlib/Analysis/Calculus/Deriv/Mul.lean

tactic: simpa using (hf.const_smul c).hasDerivAtFilter
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 𝕜
R : Type u_1
inst✝³ : Semiring R
inst✝² : Module R F
inst✝¹ : SMulCommClass 𝕜 R F
inst✝ : ContinuousConstSMul R F
c : R
hf : HasDerivAtFilter f f' x L
⊢ HasDerivAtFilter (fun y => c • f y) (c • f') x L
Theorem: Multiset.disjoint_sum_left
File: Mathlib/Algebra/BigOperators/Basic.lean

tactic: rw [quot_mk_to_coe, Multiset.coe_sum]
state_before: ι : Type ?u.895595
β : Type u
α : Type v
γ : Type w
s s₁ s₂ : Finset α
a✝ : α
f g : α → β
a : Multiset α
i : Multiset (Multiset α)
l : List (Multiset α)
⊢ Disjoint (sum (Quotient.mk (List.isSetoid (Multiset α)) l)) a ↔
    ∀ (b : Multiset α), b ∈ Quotient.mk (List.isSetoid (Multiset α)) l → Disjoint b a

tactic: exact disjoint_list_sum_left
state_before: ι : Type ?u.895595
β : Type u
α : Type v
γ : Type w
s s₁ s₂ : Finset α
a✝ : α
f g : α → β
a : Multiset α
i : Multiset (Multiset α)
l : List (Multiset α)
⊢ Disjoint (List.sum l) a ↔ ∀ (b : Multiset α), b ∈ ↑l → Disjoint b a
Theorem: Projectivization.dependent_pair_iff_eq
File: Mathlib/LinearAlgebra/ProjectiveSpace/Independence.lean

tactic: rw [dependent_iff_not_independent, independent_iff, linearIndependent_fin2,
  Function.comp_apply, Matrix.cons_val_one, Matrix.head_cons, Ne.def]
state_before: ι : Type ?u.38028
K : Type u_1
V : Type u_2
inst✝² : Field K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
f : ι → ℙ K V
u v : ℙ K V
⊢ Dependent ![u, v] ↔ u = v

tactic: simp only [Matrix.cons_val_zero, not_and, not_forall, Classical.not_not, Function.comp_apply,
  ← mk_eq_mk_iff' K _ _ (rep_nonzero u) (rep_nonzero v), mk_rep, imp_iff_right_iff]
state_before: ι : Type ?u.38028
K : Type u_1
V : Type u_2
inst✝² : Field K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
f : ι → ℙ K V
u v : ℙ K V
⊢ ¬(¬Projectivization.rep v = 0 ∧ ∀ (a : K), a • Projectivization.rep v ≠ (Projectivization.rep ∘ ![u, v]) 0) ↔ u = v

tactic: exact Or.inl (rep_nonzero v)
state_before: ι : Type ?u.38028
K : Type u_1
V : Type u_2
inst✝² : Field K
inst✝¹ : AddCommGroup V
inst✝ : Module K V
f : ι → ℙ K V
u v : ℙ K V
⊢ ¬Projectivization.rep v = 0 ∨ u = v
Theorem: YoungDiagram.length_rowLens
File: Mathlib/Combinatorics/Young/YoungDiagram.lean

tactic: simp only [rowLens, List.length_map, List.length_range]
state_before: μ : YoungDiagram
⊢ List.length (rowLens μ) = colLen μ 0
Theorem: isClosed_iff_nhds
File: Mathlib/Topology/Basic.lean

tactic: simp_rw [isClosed_iff_clusterPt, ClusterPt, inf_principal_neBot_iff]
state_before: α : Type u
β : Type v
ι : Sort w
a : α
s✝ s₁ s₂ t : Set α
p p₁ p₂ : α → Prop
inst✝ : TopologicalSpace α
s : Set α
⊢ IsClosed s ↔ ∀ (x : α), (∀ (U : Set α), U ∈ 𝓝 x → Set.Nonempty (U ∩ s)) → x ∈ s
Theorem: CategoryTheory.GrothendieckTopology.Subpresheaf.to_sheafifyLift
File: Mathlib/CategoryTheory/Sites/Subsheaf.lean

tactic: ext (U s)
state_before: C : Type u
inst✝ : Category C
J : GrothendieckTopology C
F F' F'' : Cᵒᵖ ⥤ Type w
G G' : Subpresheaf F
f : toPresheaf G ⟶ F'
h : Presieve.IsSheaf J F'
⊢ homOfLe (_ : G ≤ sheafify J G) ≫ sheafifyLift G f h = f

tactic: apply (h _ ((Subpresheaf.homOfLe (G.le_sheafify J)).app U s).prop).isSeparatedFor.ext
state_before: case w.h.h
C : Type u
inst✝ : Category C
J : GrothendieckTopology C
F F' F'' : Cᵒᵖ ⥤ Type w
G G' : Subpresheaf F
f : toPresheaf G ⟶ F'
h : Presieve.IsSheaf J F'
U : Cᵒᵖ
s : (toPresheaf G).obj U
⊢ (homOfLe (_ : G ≤ sheafify J G) ≫ sheafifyLift G f h).app U s = f.app U s

tactic: intro V i hi
state_before: case w.h.h
C : Type u
inst✝ : Category C
J : GrothendieckTopology C
F F' F'' : Cᵒᵖ ⥤ Type w
G G' : Subpresheaf F
f : toPresheaf G ⟶ F'
h : Presieve.IsSheaf J F'
U : Cᵒᵖ
s : (toPresheaf G).obj U
⊢ ∀ ⦃Y : C⦄ ⦃f_1 : Y ⟶ U.unop⦄,
    (sieveOfSection G ↑((homOfLe (_ : G ≤ sheafify J G)).app U s)).arrows f_1 →
      F'.map f_1.op ((homOfLe (_ : G ≤ sheafify J G) ≫ sheafifyLift G f h).app U s) = F'.map f_1.op (f.app U s)

tactic: have := elementwise_of% f.naturality
state_before: case w.h.h
C : Type u
inst✝ : Category C
J : GrothendieckTopology C
F F' F'' : Cᵒᵖ ⥤ Type w
G G' : Subpresheaf F
f : toPresheaf G ⟶ F'
h : Presieve.IsSheaf J F'
U : Cᵒᵖ
s : (toPresheaf G).obj U
V : C
i : V ⟶ U.unop
hi : (sieveOfSection G ↑((homOfLe (_ : G ≤ sheafify J G)).app U s)).arrows i
⊢ F'.map i.op ((homOfLe (_ : G ≤ sheafify J G) ≫ sheafifyLift G f h).app U s) = F'.map i.op (f.app U s)

tactic: exact (Presieve.IsSheafFor.valid_glue (h _ ((homOfLe (_ : G ≤ sheafify J G)).app U s).2)
  ((G.family_of_elements_compatible _).compPresheafMap _) _ hi).trans (this _ _)
state_before: case w.h.h
C : Type u
inst✝ : Category C
J : GrothendieckTopology C
F F' F'' : Cᵒᵖ ⥤ Type w
G G' : Subpresheaf F
f : toPresheaf G ⟶ F'
h : Presieve.IsSheaf J F'
U : Cᵒᵖ
s : (toPresheaf G).obj U
V : C
i : V ⟶ U.unop
hi : (sieveOfSection G ↑((homOfLe (_ : G ≤ sheafify J G)).app U s)).arrows i
this :
  ∀ ⦃X Y : Cᵒᵖ⦄ (f_1 : X ⟶ Y) (x : (toPresheaf G).obj X), f.app Y ((toPresheaf G).map f_1 x) = F'.map f_1 (f.app X x)
⊢ F'.map i.op ((homOfLe (_ : G ≤ sheafify J G) ≫ sheafifyLift G f h).app U s) = F'.map i.op (f.app U s)
Theorem: LocalEquiv.IsImage.symm_apply_mem_iff
File: Mathlib/Logic/Equiv/LocalEquiv.lean

tactic: rw [e.left_inv hx, h hx]
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.26025
δ : Type ?u.26028
e : LocalEquiv α β
e' : LocalEquiv β γ
s : Set α
t : Set β
x✝ : α
y : β
h : IsImage e s t
x : α
hx : x ∈ e.source
⊢ ↑(LocalEquiv.symm e) (↑e x) ∈ s ↔ ↑e x ∈ t
Theorem: exists_continuous_zero_one_of_closed
File: Mathlib/Topology/UrysohnsLemma.lean

tactic: set c : Urysohns.CU X := ⟨s, tᶜ, hs, ht.isOpen_compl, disjoint_left.1 hd⟩
state_before: X : Type u_1
inst✝¹ : TopologicalSpace X
inst✝ : NormalSpace X
s t : Set X
hs : IsClosed s
ht : IsClosed t
hd : Disjoint s t
⊢ ∃ f, EqOn (↑f) 0 s ∧ EqOn (↑f) 1 t ∧ ∀ (x : X), ↑f x ∈ Icc 0 1

tactic: exact ⟨⟨c.lim, c.continuous_lim⟩, c.lim_of_mem_C, fun x hx => c.lim_of_nmem_U _ fun h => h hx,
  c.lim_mem_Icc⟩
state_before: X : Type u_1
inst✝¹ : TopologicalSpace X
inst✝ : NormalSpace X
s t : Set X
hs : IsClosed s
ht : IsClosed t
hd : Disjoint s t
c : Urysohns.CU X :=
  { C := s, U := tᶜ, closed_C := hs, open_U := (_ : IsOpen (tᶜ)), subset := (_ : ∀ ⦃a : X⦄, a ∈ s → ¬a ∈ t) }
⊢ ∃ f, EqOn (↑f) 0 s ∧ EqOn (↑f) 1 t ∧ ∀ (x : X), ↑f x ∈ Icc 0 1
Theorem: Matrix.zpow_neg_coe_nat
File: Mathlib/LinearAlgebra/Matrix/ZPow.lean

tactic: cases n
state_before: n' : Type u_1
inst✝² : DecidableEq n'
inst✝¹ : Fintype n'
R : Type u_2
inst✝ : CommRing R
A : M
n : ℕ
⊢ A ^ (-↑n) = (A ^ n)⁻¹

tactic: simp
state_before: case zero
n' : Type u_1
inst✝² : DecidableEq n'
inst✝¹ : Fintype n'
R : Type u_2
inst✝ : CommRing R
A : M
⊢ A ^ (-↑Nat.zero) = (A ^ Nat.zero)⁻¹

tactic: exact DivInvMonoid.zpow_neg' _ _
state_before: case succ
n' : Type u_1
inst✝² : DecidableEq n'
inst✝¹ : Fintype n'
R : Type u_2
inst✝ : CommRing R
A : M
n✝ : ℕ
⊢ A ^ (-↑(Nat.succ n✝)) = (A ^ Nat.succ n✝)⁻¹