tasksource/leandojo huggingface dataset:
Theorem: NNReal.continuousAt_rpow
File: Mathlib/Analysis/SpecialFunctions/Pow/Continuity.lean

tactic: have :
  (fun p : ℝ≥0 × ℝ => p.1 ^ p.2) =
    Real.toNNReal ∘ (fun p : ℝ × ℝ => p.1 ^ p.2) ∘ fun p : ℝ≥0 × ℝ => (p.1.1, p.2) := by
  ext p
  erw [coe_rpow, Real.coe_toNNReal _ (Real.rpow_nonneg_of_nonneg p.1.2 _)]
  rfl
state_before: x : ℝ≥0
y : ℝ
h : x ≠ 0 ∨ 0 < y
⊢ ContinuousAt (fun p => p.fst ^ p.snd) (x, y)

tactic: rw [this]
state_before: x : ℝ≥0
y : ℝ
h : x ≠ 0 ∨ 0 < y
this : (fun p => p.fst ^ p.snd) = toNNReal ∘ (fun p => p.fst ^ p.snd) ∘ fun p => (↑p.fst, p.snd)
⊢ ContinuousAt (fun p => p.fst ^ p.snd) (x, y)

tactic: refine' continuous_real_toNNReal.continuousAt.comp (ContinuousAt.comp _ _)
state_before: x : ℝ≥0
y : ℝ
h : x ≠ 0 ∨ 0 < y
this : (fun p => p.fst ^ p.snd) = toNNReal ∘ (fun p => p.fst ^ p.snd) ∘ fun p => (↑p.fst, p.snd)
⊢ ContinuousAt (toNNReal ∘ (fun p => p.fst ^ p.snd) ∘ fun p => (↑p.fst, p.snd)) (x, y)

tactic: ext p
state_before: x : ℝ≥0
y : ℝ
h : x ≠ 0 ∨ 0 < y
⊢ (fun p => p.fst ^ p.snd) = toNNReal ∘ (fun p => p.fst ^ p.snd) ∘ fun p => (↑p.fst, p.snd)

tactic: erw [coe_rpow, Real.coe_toNNReal _ (Real.rpow_nonneg_of_nonneg p.1.2 _)]
state_before: case h.a
x : ℝ≥0
y : ℝ
h : x ≠ 0 ∨ 0 < y
p : ℝ≥0 × ℝ
⊢ ↑(p.fst ^ p.snd) = ↑((toNNReal ∘ (fun p => p.fst ^ p.snd) ∘ fun p => (↑p.fst, p.snd)) p)

tactic: rfl
state_before: case h.a
x : ℝ≥0
y : ℝ
h : x ≠ 0 ∨ 0 < y
p : ℝ≥0 × ℝ
⊢ ↑p.fst ^ p.snd = ↑p.fst ^ ((fun p => (↑p.fst, p.snd)) p).snd

tactic: apply Real.continuousAt_rpow
state_before: case refine'_1
x : ℝ≥0
y : ℝ
h : x ≠ 0 ∨ 0 < y
this : (fun p => p.fst ^ p.snd) = toNNReal ∘ (fun p => p.fst ^ p.snd) ∘ fun p => (↑p.fst, p.snd)
⊢ ContinuousAt (fun p => p.fst ^ p.snd) (↑(x, y).fst, (x, y).snd)

tactic: simp only [Ne.def] at h
state_before: case refine'_1.h
x : ℝ≥0
y : ℝ
h : x ≠ 0 ∨ 0 < y
this : (fun p => p.fst ^ p.snd) = toNNReal ∘ (fun p => p.fst ^ p.snd) ∘ fun p => (↑p.fst, p.snd)
⊢ (↑(x, y).fst, (x, y).snd).fst ≠ 0 ∨ 0 < (↑(x, y).fst, (x, y).snd).snd

tactic: rw [← NNReal.coe_eq_zero x] at h
state_before: case refine'_1.h
x : ℝ≥0
y : ℝ
h : ¬x = 0 ∨ 0 < y
this : (fun p => p.fst ^ p.snd) = toNNReal ∘ (fun p => p.fst ^ p.snd) ∘ fun p => (↑p.fst, p.snd)
⊢ (↑(x, y).fst, (x, y).snd).fst ≠ 0 ∨ 0 < (↑(x, y).fst, (x, y).snd).snd

tactic: exact h
state_before: case refine'_1.h
x : ℝ≥0
y : ℝ
h : ¬↑x = 0 ∨ 0 < y
this : (fun p => p.fst ^ p.snd) = toNNReal ∘ (fun p => p.fst ^ p.snd) ∘ fun p => (↑p.fst, p.snd)
⊢ (↑(x, y).fst, (x, y).snd).fst ≠ 0 ∨ 0 < (↑(x, y).fst, (x, y).snd).snd

tactic: exact ((continuous_subtype_val.comp continuous_fst).prod_mk continuous_snd).continuousAt
state_before: case refine'_2
x : ℝ≥0
y : ℝ
h : x ≠ 0 ∨ 0 < y
this : (fun p => p.fst ^ p.snd) = toNNReal ∘ (fun p => p.fst ^ p.snd) ∘ fun p => (↑p.fst, p.snd)
⊢ ContinuousAt (fun p => (↑p.fst, p.snd)) (x, y)
Theorem: Set.Ioi_diff_Ioi
File: Mathlib/Data/Set/Intervals/Basic.lean

tactic: rw [diff_eq, compl_Ioi, Ioi_inter_Iic]
state_before: α : Type u_1
β : Type ?u.61599
inst✝ : LinearOrder α
a a₁ a₂ b b₁ b₂ c d : α
⊢ Ioi a \ Ioi b = Ioc a b
Theorem: LieSubmodule.lie_eq_bot_iff
File: Mathlib/Algebra/Lie/IdealOperations.lean

tactic: rw [lieIdeal_oper_eq_span, LieSubmodule.lieSpan_eq_bot_iff]
state_before: R : Type u
L : Type v
M : Type w
M₂ : Type w₁
inst✝¹⁰ : CommRing R
inst✝⁹ : LieRing L
inst✝⁸ : LieAlgebra R L
inst✝⁷ : AddCommGroup M
inst✝⁶ : Module R M
inst✝⁵ : LieRingModule L M
inst✝⁴ : LieModule R L M
inst✝³ : AddCommGroup M₂
inst✝² : Module R M₂
inst✝¹ : LieRingModule L M₂
inst✝ : LieModule R L M₂
N N' : LieSubmodule R L M
I J : LieIdeal R L
N₂ : LieSubmodule R L M₂
⊢ ⁅I, N⁆ = ⊥ ↔ ∀ (x : L), x ∈ I → ∀ (m : M), m ∈ N → ⁅x, m⁆ = 0

tactic: refine' ⟨fun h x hx m hm => h ⁅x, m⁆ ⟨⟨x, hx⟩, ⟨m, hm⟩, rfl⟩, _⟩
state_before: R : Type u
L : Type v
M : Type w
M₂ : Type w₁
inst✝¹⁰ : CommRing R
inst✝⁹ : LieRing L
inst✝⁸ : LieAlgebra R L
inst✝⁷ : AddCommGroup M
inst✝⁶ : Module R M
inst✝⁵ : LieRingModule L M
inst✝⁴ : LieModule R L M
inst✝³ : AddCommGroup M₂
inst✝² : Module R M₂
inst✝¹ : LieRingModule L M₂
inst✝ : LieModule R L M₂
N N' : LieSubmodule R L M
I J : LieIdeal R L
N₂ : LieSubmodule R L M₂
⊢ (∀ (m : M), m ∈ {m | ∃ x n, ⁅↑x, ↑n⁆ = m} → m = 0) ↔ ∀ (x : L), x ∈ I → ∀ (m : M), m ∈ N → ⁅x, m⁆ = 0

tactic: rintro h - ⟨⟨x, hx⟩, ⟨⟨n, hn⟩, rfl⟩⟩
state_before: R : Type u
L : Type v
M : Type w
M₂ : Type w₁
inst✝¹⁰ : CommRing R
inst✝⁹ : LieRing L
inst✝⁸ : LieAlgebra R L
inst✝⁷ : AddCommGroup M
inst✝⁶ : Module R M
inst✝⁵ : LieRingModule L M
inst✝⁴ : LieModule R L M
inst✝³ : AddCommGroup M₂
inst✝² : Module R M₂
inst✝¹ : LieRingModule L M₂
inst✝ : LieModule R L M₂
N N' : LieSubmodule R L M
I J : LieIdeal R L
N₂ : LieSubmodule R L M₂
⊢ (∀ (x : L), x ∈ I → ∀ (m : M), m ∈ N → ⁅x, m⁆ = 0) → ∀ (m : M), m ∈ {m | ∃ x n, ⁅↑x, ↑n⁆ = m} → m = 0

tactic: exact h x hx n hn
state_before: case intro.mk.intro.mk
R : Type u
L : Type v
M : Type w
M₂ : Type w₁
inst✝¹⁰ : CommRing R
inst✝⁹ : LieRing L
inst✝⁸ : LieAlgebra R L
inst✝⁷ : AddCommGroup M
inst✝⁶ : Module R M
inst✝⁵ : LieRingModule L M
inst✝⁴ : LieModule R L M
inst✝³ : AddCommGroup M₂
inst✝² : Module R M₂
inst✝¹ : LieRingModule L M₂
inst✝ : LieModule R L M₂
N N' : LieSubmodule R L M
I J : LieIdeal R L
N₂ : LieSubmodule R L M₂
h : ∀ (x : L), x ∈ I → ∀ (m : M), m ∈ N → ⁅x, m⁆ = 0
x : L
hx : x ∈ I
n : M
hn : n ∈ N
⊢ ⁅↑{ val := x, property := hx }, ↑{ val := n, property := hn }⁆ = 0
Theorem: MeasureTheory.Measure.integral_comp_inv_mul_left
File: Mathlib/MeasureTheory/Measure/Haar/NormedSpace.lean

tactic: simp_rw [← smul_eq_mul, Measure.integral_comp_inv_smul, FiniteDimensional.finrank_self, pow_one]
state_before: E : Type ?u.90285
inst✝⁸ : NormedAddCommGroup E
inst✝⁷ : NormedSpace ℝ E
inst✝⁶ : MeasurableSpace E
inst✝⁵ : BorelSpace E
inst✝⁴ : FiniteDimensional ℝ E
μ : Measure E
inst✝³ : IsAddHaarMeasure μ
F : Type u_1
inst✝² : NormedAddCommGroup F
inst✝¹ : NormedSpace ℝ F
inst✝ : CompleteSpace F
s : Set E
g : ℝ → F
a : ℝ
⊢ (∫ (x : ℝ), g (a⁻¹ * x)) = abs a • ∫ (y : ℝ), g y
Theorem: MeasureTheory.Measure.count_apply_finset'
File: Mathlib/MeasureTheory/Measure/MeasureSpace.lean

tactic: simp
state_before: α : Type u_1
β : Type ?u.369968
γ : Type ?u.369971
δ : Type ?u.369974
ι : Type ?u.369977
R : Type ?u.369980
R' : Type ?u.369983
m0 : MeasurableSpace α
inst✝² : MeasurableSpace β
inst✝¹ : MeasurableSpace γ
μ μ₁ μ₂ μ₃ ν ν' ν₁ ν₂ : Measure α
s✝ s' t : Set α
inst✝ : MeasurableSpace α
s : Finset α
s_mble : MeasurableSet ↑s
⊢ ∑ i in s, 1 = ↑(Finset.card s)
Theorem: MvPolynomial.eq_zero_of_eval_eq_zero
File: Mathlib/FieldTheory/Finite/Polynomial.lean

tactic: rwa [ker_evalₗ, mem_bot] at this
state_before: σ K : Type u
inst✝² : Fintype K
inst✝¹ : Field K
inst✝ : Finite σ
p : MvPolynomial σ K
h : ∀ (v : σ → K), ↑(eval v) p = 0
hp : p ∈ restrictDegree σ K (Fintype.card K - 1)
p' : R σ K := { val := p, property := hp }
this : p' ∈ ker (evalᵢ σ K)
⊢ p' = 0
Theorem: CategoryTheory.Limits.IsInitial.hasInitial
File: Mathlib/CategoryTheory/Limits/Shapes/Terminal.lean

tactic: aesop_cat
state_before: C : Type u₁
inst✝ : Category C
X : C
h : IsInitial X
F : Discrete PEmpty ⥤ C
⊢ (X_1 : Discrete PEmpty) → F.obj X_1 ⟶ ((Functor.const (Discrete PEmpty)).obj X).obj X_1

tactic: aesop_cat
state_before: C : Type u₁
inst✝ : Category C
X : C
h : IsInitial X
F : Discrete PEmpty ⥤ C
⊢ ∀ ⦃X_1 Y : Discrete PEmpty⦄ (f : X_1 ⟶ Y),
    F.map f ≫ id (Discrete.casesOn Y fun as => False.elim (_ : False)) =
      id (Discrete.casesOn X_1 fun as => False.elim (_ : False)) ≫ ((Functor.const (Discrete PEmpty)).obj X).map f
Theorem: Nat.mul_right_eq_self_iff
File: Mathlib/Data/Nat/Basic.lean

tactic: rwa [mul_one] at this
state_before: m n k a b : ℕ
ha : 0 < a
this : a * b = a * 1 ↔ b = 1
⊢ a * b = a ↔ b = 1
Theorem: Nat.le_minFac'
File: Mathlib/Data/Nat/Prime.lean

tactic: rintro rfl
state_before: m n : ℕ
h : n = 1 ∨ m ≤ minFac n
p : ℕ
pp : 1 < p
d : p ∣ n
⊢ n = 1 → m ≤ p

tactic: cases not_le_of_lt pp (le_of_dvd (by decide) d)
state_before: m p : ℕ
pp : 1 < p
h : 1 = 1 ∨ m ≤ minFac 1
d : p ∣ 1
⊢ m ≤ p

tactic: decide
state_before: m p : ℕ
pp : 1 < p
h : 1 = 1 ∨ m ≤ minFac 1
d : p ∣ 1
⊢ 0 < 1
Theorem: PadicSeq.val_eq_iff_norm_eq
File: Mathlib/NumberTheory/Padics/PadicNumbers.lean

tactic: rw [norm_eq_pow_val hf, norm_eq_pow_val hg, ← neg_inj, zpow_inj]
state_before: p : ℕ
inst✝ : Fact (Nat.Prime p)
f g : PadicSeq p
hf : ¬f ≈ 0
hg : ¬g ≈ 0
⊢ valuation f = valuation g ↔ norm f = norm g

tactic: exact_mod_cast (Fact.out : p.Prime).pos
state_before: case h₀
p : ℕ
inst✝ : Fact (Nat.Prime p)
f g : PadicSeq p
hf : ¬f ≈ 0
hg : ¬g ≈ 0
⊢ 0 < ↑p

tactic: exact_mod_cast (Fact.out : p.Prime).ne_one
state_before: case h₁
p : ℕ
inst✝ : Fact (Nat.Prime p)
f g : PadicSeq p
hf : ¬f ≈ 0
hg : ¬g ≈ 0
⊢ ↑p ≠ 1
Theorem: Ordnode.dual_node3L
File: Mathlib/Data/Ordmap/Ordset.lean

tactic: simp [node3L, node3R, dual_node', add_comm]
state_before: α : Type u_1
l : Ordnode α
x : α
m : Ordnode α
y : α
r : Ordnode α
⊢ dual (node3L l x m y r) = node3R (dual r) y (dual m) x (dual l)
Theorem: Measurable.ennreal_tsum
File: Mathlib/MeasureTheory/Constructions/BorelSpace/Basic.lean

tactic: simp_rw [ENNReal.tsum_eq_iSup_sum]
state_before: α : Type u_2
β : Type ?u.2919204
γ : Type ?u.2919207
γ₂ : Type ?u.2919210
δ : Type ?u.2919213
ι✝ : Sort y
s t u : Set α
inst✝¹ : MeasurableSpace α
ι : Type u_1
inst✝ : Countable ι
f : ι → α → ℝ≥0∞
h : ∀ (i : ι), Measurable (f i)
⊢ Measurable fun x => ∑' (i : ι), f i x

tactic: apply measurable_iSup
state_before: α : Type u_2
β : Type ?u.2919204
γ : Type ?u.2919207
γ₂ : Type ?u.2919210
δ : Type ?u.2919213
ι✝ : Sort y
s t u : Set α
inst✝¹ : MeasurableSpace α
ι : Type u_1
inst✝ : Countable ι
f : ι → α → ℝ≥0∞
h : ∀ (i : ι), Measurable (f i)
⊢ Measurable fun x => ⨆ (s : Finset ι), ∑ i in s, f i x

tactic: exact fun s => s.measurable_sum fun i _ => h i
state_before: case hf
α : Type u_2
β : Type ?u.2919204
γ : Type ?u.2919207
γ₂ : Type ?u.2919210
δ : Type ?u.2919213
ι✝ : Sort y
s t u : Set α
inst✝¹ : MeasurableSpace α
ι : Type u_1
inst✝ : Countable ι
f : ι → α → ℝ≥0∞
h : ∀ (i : ι), Measurable (f i)
⊢ ∀ (i : Finset ι), Measurable fun b => ∑ i in i, f i b
Theorem: Filter.frequently_and_distrib_right
File: Mathlib/Order/Filter/Basic.lean

tactic: simp only [@and_comm _ q, frequently_and_distrib_left]
state_before: α : Type u
β : Type v
γ : Type w
δ : Type ?u.169644
ι : Sort x
f : Filter α
p : α → Prop
q : Prop
⊢ (∃ᶠ (x : α) in f, p x ∧ q) ↔ (∃ᶠ (x : α) in f, p x) ∧ q
Theorem: ZFSet.sInter_singleton
File: Mathlib/SetTheory/ZFC/Basic.lean

tactic: simp_rw [mem_sInter (singleton_nonempty x), mem_singleton, forall_eq]
state_before: x y : ZFSet
⊢ y ∈ ⋂₀ {x} ↔ y ∈ x
Theorem: Set.biUnion_preimage_singleton
File: Mathlib/Data/Set/Lattice.lean

tactic: rw [← preimage_iUnion₂, biUnion_of_singleton]
state_before: α : Type u_2
β : Type u_1
γ : Type ?u.226621
ι : Sort ?u.226624
ι' : Sort ?u.226627
ι₂ : Sort ?u.226630
κ : ι → Sort ?u.226635
κ₁ : ι → Sort ?u.226640
κ₂ : ι → Sort ?u.226645
κ' : ι' → Sort ?u.226650
f : α → β
s : Set β
⊢ (⋃ (y : β) (_ : y ∈ s), f ⁻¹' {y}) = f ⁻¹' s
Theorem: Quandle.fix_inv
File: Mathlib/Algebra/Quandle.lean

tactic: rw [← left_cancel x]
state_before: Q : Type u_1
inst✝ : Quandle Q
x : Q
⊢ x ◃⁻¹ x = x

tactic: simp
state_before: Q : Type u_1
inst✝ : Quandle Q
x : Q
⊢ x ◃ x ◃⁻¹ x = x ◃ x
Theorem: xor_iff_not_iff'
File: Mathlib/Logic/Basic.lean

tactic: simp only [← @xor_not_left _ b, not_not]
state_before: a b : Prop
⊢ Xor' a b ↔ (¬a ↔ b)
Theorem: interior_sInter_subset
File: Mathlib/Topology/Basic.lean

tactic: rw [sInter_eq_biInter]
state_before: α : Type u
β : Type v
ι : Sort w
a : α
s s₁ s₂ t : Set α
p p₁ p₂ : α → Prop
inst✝ : TopologicalSpace α
S : Set (Set α)
⊢ interior (⋂₀ S) = interior (⋂ (s : Set α) (_ : s ∈ S), s)
Theorem: Seminorm.coe_iSup_eq
File: Mathlib/Analysis/Seminorm.lean

tactic: rw [← sSup_range, Seminorm.coe_sSup_eq hp]
state_before: R : Type ?u.772186
R' : Type ?u.772189
𝕜 : Type u_2
𝕜₂ : Type ?u.772195
𝕜₃ : Type ?u.772198
𝕝 : Type ?u.772201
E : Type u_3
E₂ : Type ?u.772207
E₃ : Type ?u.772210
F : Type ?u.772213
G : Type ?u.772216
ι✝ : Type ?u.772219
inst✝² : NormedField 𝕜
inst✝¹ : AddCommGroup E
inst✝ : Module 𝕜 E
p✝ q : Seminorm 𝕜 E
x : E
ι : Type u_1
p : ι → Seminorm 𝕜 E
hp : BddAbove (range p)
⊢ ↑(⨆ (i : ι), p i) = ⨆ (i : ι), ↑(p i)

tactic: exact iSup_range' (fun p : Seminorm 𝕜 E => (p : E → ℝ)) p
state_before: R : Type ?u.772186
R' : Type ?u.772189
𝕜 : Type u_2
𝕜₂ : Type ?u.772195
𝕜₃ : Type ?u.772198
𝕝 : Type ?u.772201
E : Type u_3
E₂ : Type ?u.772207
E₃ : Type ?u.772210
F : Type ?u.772213
G : Type ?u.772216
ι✝ : Type ?u.772219
inst✝² : NormedField 𝕜
inst✝¹ : AddCommGroup E
inst✝ : Module 𝕜 E
p✝ q : Seminorm 𝕜 E
x : E
ι : Type u_1
p : ι → Seminorm 𝕜 E
hp : BddAbove (range p)
⊢ (⨆ (p_1 : ↑(range p)), ↑↑p_1) = ⨆ (i : ι), ↑(p i)
Theorem: List.map_join
File: Mathlib/Data/List/Basic.lean

tactic: induction L <;> [rfl; simp only [*, join, map, map_append]]
state_before: ι : Type ?u.133368
α : Type u
β : Type v
γ : Type w
δ : Type x
l₁ l₂ : List α
f : α → β
L : List (List α)
⊢ map f (join L) = join (map (map f) L)
Theorem: CategoryTheory.Bicategory.inv_whiskerLeft
File: Mathlib/CategoryTheory/Bicategory/Basic.lean

tactic: aesop_cat_nonterminal
state_before: B : Type u
inst✝¹ : Bicategory B
a b c d e : B
f : a ⟶ b
g h : b ⟶ c
η : g ⟶ h
inst✝ : IsIso η
⊢ inv (f ◁ η) = f ◁ inv η

tactic: simp only [← whiskerLeft_comp, whiskerLeft_id, IsIso.hom_inv_id]
state_before: case hom_inv_id
B : Type u
inst : Bicategory B
a b c d e : B
f : a ⟶ b
g h : b ⟶ c
η : g ⟶ h
inst_1 : IsIso η
⊢ f ◁ η ≫ f ◁ inv η = 𝟙 (f ≫ g)
Theorem: CategoryTheory.Limits.Concrete.isColimit_exists_rep
File: Mathlib/CategoryTheory/Limits/ConcreteCategory.lean

tactic: obtain ⟨a, rfl⟩ := Concrete.from_union_surjective_of_isColimit F hD x
state_before: C : Type u
inst✝³ : Category C
inst✝² : ConcreteCategory C
J : Type v
inst✝¹ : SmallCategory J
F : J ⥤ C
inst✝ : PreservesColimit F (forget C)
D : Cocone F
hD : IsColimit D
x : (forget C).obj D.pt
⊢ ∃ j y, (forget C).map (D.ι.app j) y = x

tactic: exact ⟨a.1, a.2, rfl⟩
state_before: case intro
C : Type u
inst✝³ : Category C
inst✝² : ConcreteCategory C
J : Type v
inst✝¹ : SmallCategory J
F : J ⥤ C
inst✝ : PreservesColimit F (forget C)
D : Cocone F
hD : IsColimit D
a : (j : J) × (forget C).obj (F.obj j)
⊢ ∃ j y, (forget C).map (D.ι.app j) y = (fun a => (forget C).map (D.ι.app a.fst) a.snd) a
Theorem: iInf₂_comm
File: Mathlib/Order/CompleteLattice.lean

tactic: simp only [@iInf_comm _ (κ₁ _), @iInf_comm _ ι₁]
state_before: α : Type u_5
β : Type ?u.96031
β₂ : Type ?u.96034
γ : Type ?u.96037
ι : Sort ?u.96040
ι' : Sort ?u.96043
κ : ι → Sort ?u.96048
κ' : ι' → Sort ?u.96053
inst✝ : CompleteLattice α
f✝ g s t : ι → α
a b : α
ι₁ : Sort u_1
ι₂ : Sort u_2
κ₁ : ι₁ → Sort u_3
κ₂ : ι₂ → Sort u_4
f : (i₁ : ι₁) → κ₁ i₁ → (i₂ : ι₂) → κ₂ i₂ → α
⊢ (⨅ (i₁ : ι₁) (j₁ : κ₁ i₁) (i₂ : ι₂) (j₂ : κ₂ i₂), f i₁ j₁ i₂ j₂) =
    ⨅ (i₂ : ι₂) (j₂ : κ₂ i₂) (i₁ : ι₁) (j₁ : κ₁ i₁), f i₁ j₁ i₂ j₂
Theorem: Subalgebra.finiteDimensional_sup
File: Mathlib/RingTheory/TensorProduct.lean

tactic: rw [← E1.range_val, ← E2.range_val, ← Algebra.TensorProduct.productMap_range]
state_before: K : Type u_1
L : Type u_2
inst✝⁴ : Field K
inst✝³ : CommRing L
inst✝² : Algebra K L
E1 E2 : Subalgebra K L
inst✝¹ : FiniteDimensional K { x // x ∈ E1 }
inst✝ : FiniteDimensional K { x // x ∈ E2 }
⊢ FiniteDimensional K { x // x ∈ E1 ⊔ E2 }

tactic: exact (Algebra.TensorProduct.productMap E1.val E2.val).toLinearMap.finiteDimensional_range
state_before: K : Type u_1
L : Type u_2
inst✝⁴ : Field K
inst✝³ : CommRing L
inst✝² : Algebra K L
E1 E2 : Subalgebra K L
inst✝¹ : FiniteDimensional K { x // x ∈ E1 }
inst✝ : FiniteDimensional K { x // x ∈ E2 }
⊢ FiniteDimensional K { x // x ∈ AlgHom.range (Algebra.TensorProduct.productMap (val E1) (val E2)) }
Theorem: Cardinal.two_le_iff'
File: Mathlib/SetTheory/Cardinal/Basic.lean

tactic: rw [two_le_iff, ← nontrivial_iff, nontrivial_iff_exists_ne x]
state_before: α β : Type u
x : α
⊢ 2 ≤ (#α) ↔ ∃ y, y ≠ x
Theorem: finprod_mem_union'
File: Mathlib/Algebra/BigOperators/Finprod.lean

tactic: rw [← finprod_mem_union_inter' hs ht, disjoint_iff_inter_eq_empty.1 hst, finprod_mem_empty,
  mul_one]
state_before: α : Type u_1
β : Type ?u.333397
ι : Type ?u.333400
G : Type ?u.333403
M : Type u_2
N : Type ?u.333409
inst✝¹ : CommMonoid M
inst✝ : CommMonoid N
f g : α → M
a b : α
s t : Set α
hst : Disjoint s t
hs : Set.Finite (s ∩ mulSupport f)
ht : Set.Finite (t ∩ mulSupport f)
⊢ (∏ᶠ (i : α) (_ : i ∈ s ∪ t), f i) = (∏ᶠ (i : α) (_ : i ∈ s), f i) * ∏ᶠ (i : α) (_ : i ∈ t), f i
Theorem: Fintype.card_congr
File: Mathlib/Data/Fintype/Card.lean

tactic: rw [← ofEquiv_card f]
state_before: α✝ : Type ?u.4685
β✝ : Type ?u.4688
γ : Type ?u.4691
α : Type u_1
β : Type u_2
inst✝¹ : Fintype α
inst✝ : Fintype β
f : α ≃ β
⊢ card α = card β

tactic: congr
state_before: α✝ : Type ?u.4685
β✝ : Type ?u.4688
γ : Type ?u.4691
α : Type u_1
β : Type u_2
inst✝¹ : Fintype α
inst✝ : Fintype β
f : α ≃ β
⊢ card β = card β

tactic: apply Subsingleton.elim
state_before: case h.e_2.h
α✝ : Type ?u.4685
β✝ : Type ?u.4688
γ : Type ?u.4691
α : Type u_1
β : Type u_2
inst✝¹ : Fintype α
inst✝ : Fintype β
f : α ≃ β
⊢ ofEquiv α f = inst✝
Theorem: Filter.blimsup_true
File: Mathlib/Order/LiminfLimsup.lean

tactic: simp [blimsup_eq, limsup_eq]
state_before: α : Type u_2
β : Type u_1
γ : Type ?u.54283
ι : Type ?u.54286
inst✝ : ConditionallyCompleteLattice α
f : Filter β
u : β → α
⊢ (blimsup u f fun x => True) = limsup u f
Theorem: Multiset.le_cons_of_not_mem
File: Mathlib/Data/Multiset/Basic.lean

tactic: refine' ⟨_, fun h => le_trans h <| le_cons_self _ _⟩
state_before: α : Type u_1
β : Type ?u.36383
γ : Type ?u.36386
s t : Multiset α
a : α
m : ¬a ∈ s
⊢ s ≤ a ::ₘ t ↔ s ≤ t

tactic: suffices ∀ {t'} (_ : s ≤ t') (_ : a ∈ t'), a ::ₘ s ≤ t' by
  exact fun h => (cons_le_cons_iff a).1 (this h (mem_cons_self _ _))
state_before: α : Type u_1
β : Type ?u.36383
γ : Type ?u.36386
s t : Multiset α
a : α
m : ¬a ∈ s
⊢ s ≤ a ::ₘ t → s ≤ t

tactic: introv h
state_before: α : Type u_1
β : Type ?u.36383
γ : Type ?u.36386
s t : Multiset α
a : α
m : ¬a ∈ s
⊢ ∀ {t' : Multiset α}, s ≤ t' → a ∈ t' → a ::ₘ s ≤ t'

tactic: revert m
state_before: α : Type u_1
β : Type ?u.36383
γ : Type ?u.36386
s t : Multiset α
a : α
m : ¬a ∈ s
t' : Multiset α
h : s ≤ t'
⊢ a ∈ t' → a ::ₘ s ≤ t'

tactic: refine' leInductionOn h _
state_before: α : Type u_1
β : Type ?u.36383
γ : Type ?u.36386
s t : Multiset α
a : α
t' : Multiset α
h : s ≤ t'
⊢ ¬a ∈ s → a ∈ t' → a ::ₘ s ≤ t'

tactic: introv s m₁ m₂
state_before: α : Type u_1
β : Type ?u.36383
γ : Type ?u.36386
s t : Multiset α
a : α
t' : Multiset α
h : s ≤ t'
⊢ ∀ {l₁ l₂ : List α}, l₁ <+ l₂ → ¬a ∈ ↑l₁ → a ∈ ↑l₂ → a ::ₘ ↑l₁ ≤ ↑l₂

tactic: rcases mem_split m₂ with ⟨r₁, r₂, rfl⟩
state_before: α : Type u_1
β : Type ?u.36383
γ : Type ?u.36386
s✝ t : Multiset α
a : α
t' : Multiset α
h : s✝ ≤ t'
l₁ l₂ : List α
s : l₁ <+ l₂
m₁ : ¬a ∈ ↑l₁
m₂ : a ∈ ↑l₂
⊢ a ::ₘ ↑l₁ ≤ ↑l₂

tactic: exact
  perm_middle.subperm_left.2
    ((subperm_cons _).2 <| ((sublist_or_mem_of_sublist s).resolve_right m₁).subperm)
state_before: case intro.intro
α : Type u_1
β : Type ?u.36383
γ : Type ?u.36386
s✝ t : Multiset α
a : α
t' : Multiset α
h : s✝ ≤ t'
l₁ : List α
m₁ : ¬a ∈ ↑l₁
r₁ r₂ : List α
s : l₁ <+ r₁ ++ a :: r₂
m₂ : a ∈ ↑(r₁ ++ a :: r₂)
⊢ a ::ₘ ↑l₁ ≤ ↑(r₁ ++ a :: r₂)

tactic: exact fun h => (cons_le_cons_iff a).1 (this h (mem_cons_self _ _))
state_before: α : Type u_1
β : Type ?u.36383
γ : Type ?u.36386
s t : Multiset α
a : α
m : ¬a ∈ s
this : ∀ {t' : Multiset α}, s ≤ t' → a ∈ t' → a ::ₘ s ≤ t'
⊢ s ≤ a ::ₘ t → s ≤ t
Theorem: List.prod_set
File: Mathlib/Data/List/BigOperators/Basic.lean

tactic: simp [set]
state_before: ι : Type ?u.61763
α : Type ?u.61766
M : Type u_1
N : Type ?u.61772
P : Type ?u.61775
M₀ : Type ?u.61778
G : Type ?u.61781
R : Type ?u.61784
inst✝² : Monoid M
inst✝¹ : Monoid N
inst✝ : Monoid P
l l₁ l₂ : List M
a✝ x : M
xs : List M
a : M
⊢ prod (set (x :: xs) 0 a) =
    (prod (take 0 (x :: xs)) * if 0 < length (x :: xs) then a else 1) * prod (drop (0 + 1) (x :: xs))

tactic: simp [set, prod_set xs i a, mul_assoc, Nat.succ_eq_add_one]
state_before: ι : Type ?u.61763
α : Type ?u.61766
M : Type u_1
N : Type ?u.61772
P : Type ?u.61775
M₀ : Type ?u.61778
G : Type ?u.61781
R : Type ?u.61784
inst✝² : Monoid M
inst✝¹ : Monoid N
inst✝ : Monoid P
l l₁ l₂ : List M
a✝ x : M
xs : List M
i : ℕ
a : M
⊢ prod (set (x :: xs) (i + 1) a) =
    (prod (take (i + 1) (x :: xs)) * if i + 1 < length (x :: xs) then a else 1) * prod (drop (i + 1 + 1) (x :: xs))

tactic: simp [set, (Nat.zero_le _).not_lt, Nat.zero_le]
state_before: ι : Type ?u.61763
α : Type ?u.61766
M : Type u_1
N : Type ?u.61772
P : Type ?u.61775
M₀ : Type ?u.61778
G : Type ?u.61781
R : Type ?u.61784
inst✝² : Monoid M
inst✝¹ : Monoid N
inst✝ : Monoid P
l l₁ l₂ : List M
a : M
x✝¹ : ℕ
x✝ : M
⊢ prod (set [] x✝¹ x✝) = (prod (take x✝¹ []) * if x✝¹ < length [] then x✝ else 1) * prod (drop (x✝¹ + 1) [])
Theorem: one_div_lt_one_div_of_lt
File: Mathlib/Algebra/Order/Field/Basic.lean

tactic: rwa [lt_div_iff' ha, ← div_eq_mul_one_div, div_lt_one (ha.trans h)]
state_before: ι : Type ?u.83513
α : Type u_1
β : Type ?u.83519
inst✝ : LinearOrderedSemifield α
a b c d e : α
m n : ℤ
ha : 0 < a
h : a < b
⊢ 1 / b < 1 / a
Theorem: AlgebraicTopology.DoldKan.homotopyPToId_eventually_constant
File: Mathlib/AlgebraicTopology/DoldKan/HomotopyEquivalence.lean

tactic: simp only [homotopyHσToZero, AlternatingFaceMapComplex.obj_X, Nat.add_eq, Homotopy.trans_hom,
  Homotopy.ofEq_hom, Pi.zero_apply, Homotopy.add_hom, Homotopy.compLeft_hom, add_zero,
  Homotopy.nullHomotopy'_hom, ComplexShape.down_Rel, hσ'_eq_zero hqn (c_mk (n + 1) n rfl),
  dite_eq_ite, ite_self, comp_zero, zero_add, homotopyPToId]
state_before: C : Type u_2
inst✝¹ : Category C
inst✝ : Preadditive C
X : SimplicialObject C
q n : ℕ
hqn : n < q
⊢ Homotopy.hom (homotopyPToId X (q + 1)) n (n + 1) = Homotopy.hom (homotopyPToId X q) n (n + 1)

tactic: rfl
state_before: C : Type u_2
inst✝¹ : Category C
inst✝ : Preadditive C
X : SimplicialObject C
q n : ℕ
hqn : n < q
⊢ Homotopy.hom (homotopyPToId X (q + 0)) n (n + 1) = Homotopy.hom (homotopyPToId X q) n (n + 1)