tasksource/leandojo huggingface dataset:
Theorem: locallyConvexSpace_sInf
File: Mathlib/Topology/Algebra/Module/LocallyConvex.lean

tactic: letI : TopologicalSpace E := sInf ts
state_before: ι : Sort ?u.41463
𝕜 : Type u_2
E : Type u_1
F : Type ?u.41472
inst✝⁴ : OrderedSemiring 𝕜
inst✝³ : AddCommMonoid E
inst✝² : Module 𝕜 E
inst✝¹ : AddCommMonoid F
inst✝ : Module 𝕜 F
ts : Set (TopologicalSpace E)
h : ∀ (t : TopologicalSpace E), t ∈ ts → LocallyConvexSpace 𝕜 E
⊢ LocallyConvexSpace 𝕜 E

tactic: refine'
  LocallyConvexSpace.ofBases 𝕜 E (fun _ => fun If : Set ts × (ts → Set E) => ⋂ i ∈ If.1, If.2 i)
    (fun x => fun If : Set ts × (ts → Set E) =>
      If.1.Finite ∧ ∀ i ∈ If.1, If.2 i ∈ @nhds _ (↑i) x ∧ Convex 𝕜 (If.2 i))
    (fun x => _) fun x If hif => convex_iInter fun i => convex_iInter fun hi => (hif.2 i hi).2
state_before: ι : Sort ?u.41463
𝕜 : Type u_2
E : Type u_1
F : Type ?u.41472
inst✝⁴ : OrderedSemiring 𝕜
inst✝³ : AddCommMonoid E
inst✝² : Module 𝕜 E
inst✝¹ : AddCommMonoid F
inst✝ : Module 𝕜 F
ts : Set (TopologicalSpace E)
h : ∀ (t : TopologicalSpace E), t ∈ ts → LocallyConvexSpace 𝕜 E
this : TopologicalSpace E := sInf ts
⊢ LocallyConvexSpace 𝕜 E

tactic: rw [nhds_sInf, ← iInf_subtype'']
state_before: ι : Sort ?u.41463
𝕜 : Type u_2
E : Type u_1
F : Type ?u.41472
inst✝⁴ : OrderedSemiring 𝕜
inst✝³ : AddCommMonoid E
inst✝² : Module 𝕜 E
inst✝¹ : AddCommMonoid F
inst✝ : Module 𝕜 F
ts : Set (TopologicalSpace E)
h : ∀ (t : TopologicalSpace E), t ∈ ts → LocallyConvexSpace 𝕜 E
this : TopologicalSpace E := sInf ts
x : E
⊢ HasBasis (𝓝 x)
    ((fun x If => Set.Finite If.fst ∧ ∀ (i : ↑ts), i ∈ If.fst → Prod.snd If i ∈ 𝓝 x ∧ Convex 𝕜 (Prod.snd If i)) x)
    ((fun x If => ⋂ (i : ↑ts) (_ : i ∈ If.fst), Prod.snd If i) x)

tactic: exact hasBasis_iInf' fun i : ts => (@locallyConvexSpace_iff 𝕜 E _ _ _ ↑i).mp (h (↑i) i.2) x
state_before: ι : Sort ?u.41463
𝕜 : Type u_2
E : Type u_1
F : Type ?u.41472
inst✝⁴ : OrderedSemiring 𝕜
inst✝³ : AddCommMonoid E
inst✝² : Module 𝕜 E
inst✝¹ : AddCommMonoid F
inst✝ : Module 𝕜 F
ts : Set (TopologicalSpace E)
h : ∀ (t : TopologicalSpace E), t ∈ ts → LocallyConvexSpace 𝕜 E
this : TopologicalSpace E := sInf ts
x : E
⊢ HasBasis (⨅ (i : ↑ts), 𝓝 x)
    ((fun x If => Set.Finite If.fst ∧ ∀ (i : ↑ts), i ∈ If.fst → Prod.snd If i ∈ 𝓝 x ∧ Convex 𝕜 (Prod.snd If i)) x)
    ((fun x If => ⋂ (i : ↑ts) (_ : i ∈ If.fst), Prod.snd If i) x)
Theorem: MeasureTheory.Integrable.im
File: Mathlib/MeasureTheory/Function/L1Space.lean

tactic: rw [← memℒp_one_iff_integrable] at hf ⊢
state_before: α : Type u_2
β : Type ?u.1226518
γ : Type ?u.1226521
δ : Type ?u.1226524
m : MeasurableSpace α
μ ν : Measure α
inst✝³ : MeasurableSpace δ
inst✝² : NormedAddCommGroup β
inst✝¹ : NormedAddCommGroup γ
𝕜 : Type u_1
inst✝ : IsROrC 𝕜
f : α → 𝕜
hf : Integrable f
⊢ Integrable fun x => ↑IsROrC.im (f x)

tactic: exact hf.im
state_before: α : Type u_2
β : Type ?u.1226518
γ : Type ?u.1226521
δ : Type ?u.1226524
m : MeasurableSpace α
μ ν : Measure α
inst✝³ : MeasurableSpace δ
inst✝² : NormedAddCommGroup β
inst✝¹ : NormedAddCommGroup γ
𝕜 : Type u_1
inst✝ : IsROrC 𝕜
f : α → 𝕜
hf : Memℒp f 1
⊢ Memℒp (fun x => ↑IsROrC.im (f x)) 1
Theorem: WithTop.untop'_zero_mul
File: Mathlib/Algebra/Order/Ring/WithTop.lean

tactic: by_cases ha : a = 0
state_before: α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : MulZeroClass α
a b : WithTop α
⊢ untop' 0 (a * b) = untop' 0 a * untop' 0 b

tactic: by_cases hb : b = 0
state_before: case neg
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : MulZeroClass α
a b : WithTop α
ha : ¬a = 0
⊢ untop' 0 (a * b) = untop' 0 a * untop' 0 b

tactic: induction a using WithTop.recTopCoe
state_before: case neg
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : MulZeroClass α
a b : WithTop α
ha : ¬a = 0
hb : ¬b = 0
⊢ untop' 0 (a * b) = untop' 0 a * untop' 0 b

tactic: induction b using WithTop.recTopCoe
state_before: case neg.coe
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : MulZeroClass α
b : WithTop α
hb : ¬b = 0
a✝ : α
ha : ¬↑a✝ = 0
⊢ untop' 0 (↑a✝ * b) = untop' 0 ↑a✝ * untop' 0 b

tactic: rw [← coe_mul, untop'_coe, untop'_coe, untop'_coe]
state_before: case neg.coe.coe
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : MulZeroClass α
a✝¹ : α
ha : ¬↑a✝¹ = 0
a✝ : α
hb : ¬↑a✝ = 0
⊢ untop' 0 (↑a✝¹ * ↑a✝) = untop' 0 ↑a✝¹ * untop' 0 ↑a✝

tactic: rw [ha, zero_mul, ← coe_zero, untop'_coe, zero_mul]
state_before: case pos
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : MulZeroClass α
a b : WithTop α
ha : a = 0
⊢ untop' 0 (a * b) = untop' 0 a * untop' 0 b

tactic: rw [hb, mul_zero, ← coe_zero, untop'_coe, mul_zero]
state_before: case pos
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : MulZeroClass α
a b : WithTop α
ha : ¬a = 0
hb : b = 0
⊢ untop' 0 (a * b) = untop' 0 a * untop' 0 b

tactic: rw [top_mul hb, untop'_top, zero_mul]
state_before: case neg.top
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : MulZeroClass α
b : WithTop α
hb : ¬b = 0
ha : ¬⊤ = 0
⊢ untop' 0 (⊤ * b) = untop' 0 ⊤ * untop' 0 b

tactic: rw [mul_top ha, untop'_top, mul_zero]
state_before: case neg.coe.top
α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : MulZeroClass α
a✝ : α
ha : ¬↑a✝ = 0
hb : ¬⊤ = 0
⊢ untop' 0 (↑a✝ * ⊤) = untop' 0 ↑a✝ * untop' 0 ⊤
Theorem: Int.succ_coe_nat_pos
File: Mathlib/Data/Int/Lemmas.lean

tactic: simp
state_before: n : ℕ
⊢ 0 ≤ ↑n
Theorem: CategoryTheory.FreeBicategory.normalizeAux_congr
File: Mathlib/CategoryTheory/Bicategory/Coherence.lean

tactic: rcases η with ⟨η'⟩
state_before: B : Type u
inst✝ : Quiver B
a b c : B
p : Path a b
f g : Hom b c
η : f ⟶ g
⊢ normalizeAux p f = normalizeAux p g

tactic: apply @congr_fun _ _ fun p => normalizeAux p f
state_before: case mk
B : Type u
inst✝ : Quiver B
a b c : B
p : Path a b
f g : Hom b c
η : f ⟶ g
η' : Hom₂ f g
⊢ normalizeAux p f = normalizeAux p g

tactic: clear p η
state_before: case mk.h
B : Type u
inst✝ : Quiver B
a b c : B
p : Path a b
f g : Hom b c
η : f ⟶ g
η' : Hom₂ f g
⊢ (fun p => normalizeAux p f) = fun p => normalizeAux p g

tactic: induction η' with
| vcomp _ _ _ _ => apply Eq.trans <;> assumption
| whisker_left _ _ ih => funext; apply congr_fun ih
| whisker_right _ _ ih => funext; apply congr_arg₂ _ (congr_fun ih _) rfl
| _ => funext; rfl
state_before: case mk.h
B : Type u
inst✝ : Quiver B
a b c : B
f g : Hom b c
η' : Hom₂ f g
⊢ (fun p => normalizeAux p f) = fun p => normalizeAux p g

tactic: apply Eq.trans <;> assumption
state_before: case mk.h.vcomp
B : Type u
inst✝ : Quiver B
a b c : B
f g : Hom b c
a✝ b✝ : FreeBicategory B
f✝ g✝ h✝ : a✝ ⟶ b✝
η✝ : Hom₂ f✝ g✝
θ✝ : Hom₂ g✝ h✝
η_ih✝ : (fun p => normalizeAux p f✝) = fun p => normalizeAux p g✝
θ_ih✝ : (fun p => normalizeAux p g✝) = fun p => normalizeAux p h✝
⊢ (fun p => normalizeAux p f✝) = fun p => normalizeAux p h✝

tactic: funext
state_before: case mk.h.whisker_left
B : Type u
inst✝ : Quiver B
a b c : B
f g : Hom b c
a✝ b✝ c✝ : FreeBicategory B
f✝ : a✝ ⟶ b✝
g✝ h✝ : b✝ ⟶ c✝
η✝ : Hom₂ g✝ h✝
ih : (fun p => normalizeAux p g✝) = fun p => normalizeAux p h✝
⊢ (fun p => normalizeAux p (f✝ ≫ g✝)) = fun p => normalizeAux p (f✝ ≫ h✝)

tactic: apply congr_fun ih
state_before: case mk.h.whisker_left.h
B : Type u
inst✝ : Quiver B
a b c : B
f g : Hom b c
a✝ b✝ c✝ : FreeBicategory B
f✝ : a✝ ⟶ b✝
g✝ h✝ : b✝ ⟶ c✝
η✝ : Hom₂ g✝ h✝
ih : (fun p => normalizeAux p g✝) = fun p => normalizeAux p h✝
x✝ : Path a a✝
⊢ normalizeAux x✝ (f✝ ≫ g✝) = normalizeAux x✝ (f✝ ≫ h✝)

tactic: funext
state_before: case mk.h.whisker_right
B : Type u
inst✝ : Quiver B
a b c : B
f g : Hom b c
a✝ b✝ c✝ : FreeBicategory B
f✝ g✝ : a✝ ⟶ b✝
h✝ : b✝ ⟶ c✝
η✝ : Hom₂ f✝ g✝
ih : (fun p => normalizeAux p f✝) = fun p => normalizeAux p g✝
⊢ (fun p => normalizeAux p (Hom.comp f✝ h✝)) = fun p => normalizeAux p (Hom.comp g✝ h✝)

tactic: apply congr_arg₂ _ (congr_fun ih _) rfl
state_before: case mk.h.whisker_right.h
B : Type u
inst✝ : Quiver B
a b c : B
f g : Hom b c
a✝ b✝ c✝ : FreeBicategory B
f✝ g✝ : a✝ ⟶ b✝
h✝ : b✝ ⟶ c✝
η✝ : Hom₂ f✝ g✝
ih : (fun p => normalizeAux p f✝) = fun p => normalizeAux p g✝
x✝ : Path a a✝
⊢ normalizeAux x✝ (Hom.comp f✝ h✝) = normalizeAux x✝ (Hom.comp g✝ h✝)

tactic: funext
state_before: case mk.h.left_unitor_inv
B : Type u
inst✝ : Quiver B
a b c : B
f g : Hom b c
a✝ b✝ : FreeBicategory B
f✝ : a✝ ⟶ b✝
⊢ (fun p => normalizeAux p f✝) = fun p => normalizeAux p (𝟙 a✝ ≫ f✝)

tactic: rfl
state_before: case mk.h.left_unitor_inv.h
B : Type u
inst✝ : Quiver B
a b c : B
f g : Hom b c
a✝ b✝ : FreeBicategory B
f✝ : a✝ ⟶ b✝
x✝ : Path a a✝
⊢ normalizeAux x✝ f✝ = normalizeAux x✝ (𝟙 a✝ ≫ f✝)
Theorem: Bitvec.toNat_eq_foldr_reverse
File: Mathlib/Data/Bitvec/Lemmas.lean

tactic: rw [List.foldr_reverse]
state_before: n : ℕ
v : Bitvec n
⊢ Bitvec.toNat v = List.foldr (flip addLsb) 0 (List.reverse (Vector.toList v))

tactic: rfl
state_before: n : ℕ
v : Bitvec n
⊢ Bitvec.toNat v = List.foldl (fun x y => flip addLsb y x) 0 (Vector.toList v)
Theorem: Coheyting.hnot_eq_top_iff_exists_boundary
File: Mathlib/Order/Heyting/Boundary.lean

tactic: rw [boundary, h, inf_top_eq]
state_before: α : Type u_1
inst✝ : CoheytingAlgebra α
a b : α
h : ￢a = ⊤
⊢ ∂ a = a

tactic: rintro ⟨b, rfl⟩
state_before: α : Type u_1
inst✝ : CoheytingAlgebra α
a b : α
⊢ (∃ b, ∂ b = a) → ￢a = ⊤

tactic: exact hnot_boundary _
state_before: case intro
α : Type u_1
inst✝ : CoheytingAlgebra α
b✝ b : α
⊢ ￢∂ b = ⊤
Theorem: Real.cosh_two_mul
File: Mathlib/Data/Complex/Exponential.lean

tactic: rw [← ofReal_inj]
state_before: x y : ℝ
⊢ cosh (2 * x) = cosh x ^ 2 + sinh x ^ 2

tactic: simp [cosh_two_mul]
state_before: x y : ℝ
⊢ ↑(cosh (2 * x)) = ↑(cosh x ^ 2 + sinh x ^ 2)
Theorem: Bool.exists_bool
File: Mathlib/Data/Bool/Basic.lean

tactic: cases b
state_before: p : Bool → Prop
x✝ : ∃ b, p b
b : Bool
h : p b
⊢ p false ∨ p true

tactic: exact Or.inl h
state_before: case false
p : Bool → Prop
x✝ : ∃ b, p b
h : p false
⊢ p false ∨ p true

case true
p : Bool → Prop
x✝ : ∃ b, p b
h : p true
⊢ p false ∨ p true

tactic: exact Or.inr h
state_before: case true
p : Bool → Prop
x✝ : ∃ b, p b
h : p true
⊢ p false ∨ p true
Theorem: MvPolynomial.bind₂_monomial
File: Mathlib/Data/MvPolynomial/Monad.lean

tactic: simp only [monomial_eq, RingHom.map_mul, bind₂_C_right, Finsupp.prod, map_prod,
  map_pow, bind₂_X_right, C_1, one_mul]
state_before: σ : Type u_3
τ : Type ?u.1251650
R : Type u_1
S : Type u_2
T : Type ?u.1251659
inst✝² : CommSemiring R
inst✝¹ : CommSemiring S
inst✝ : CommSemiring T
f✝ : σ → MvPolynomial τ R
f : R →+* MvPolynomial σ S
d : σ →₀ ℕ
r : R
⊢ ↑(bind₂ f) (↑(monomial d) r) = ↑f r * ↑(monomial d) 1
Theorem: MeasureTheory.ProbabilityMeasure.eq_of_forall_apply_eq
File: Mathlib/MeasureTheory/Measure/ProbabilityMeasure.lean

tactic: ext1 s s_mble
state_before: Ω : Type u_1
inst✝ : MeasurableSpace Ω
μ ν : ProbabilityMeasure Ω
h : ∀ (s : Set Ω), MeasurableSet s → (fun s => ENNReal.toNNReal (↑↑↑μ s)) s = (fun s => ENNReal.toNNReal (↑↑↑ν s)) s
⊢ μ = ν

tactic: simpa [ennreal_coeFn_eq_coeFn_toMeasure] using congr_arg ((↑) : ℝ≥0 → ℝ≥0∞) (h s s_mble)
state_before: case h
Ω : Type u_1
inst✝ : MeasurableSpace Ω
μ ν : ProbabilityMeasure Ω
h : ∀ (s : Set Ω), MeasurableSet s → (fun s => ENNReal.toNNReal (↑↑↑μ s)) s = (fun s => ENNReal.toNNReal (↑↑↑ν s)) s
s : Set Ω
s_mble : MeasurableSet s
⊢ ↑↑↑μ s = ↑↑↑ν s
Theorem: MvPolynomial.degrees_rename_of_injective
File: Mathlib/Data/MvPolynomial/Variables.lean

tactic: classical
simp only [degrees, Multiset.map_finset_sup p.support Finsupp.toMultiset f h,
  support_rename_of_injective h, Finset.sup_image]
refine' Finset.sup_congr rfl fun x _ => _
exact (Finsupp.toMultiset_map _ _).symm
state_before: R : Type u
S : Type v
σ : Type u_1
τ : Type u_2
r : R
e : ℕ
n m : σ
s : σ →₀ ℕ
inst✝ : CommSemiring R
p✝ q p : MvPolynomial σ R
f : σ → τ
h : Injective f
⊢ degrees (↑(rename f) p) = Multiset.map f (degrees p)

tactic: simp only [degrees, Multiset.map_finset_sup p.support Finsupp.toMultiset f h,
  support_rename_of_injective h, Finset.sup_image]
state_before: R : Type u
S : Type v
σ : Type u_1
τ : Type u_2
r : R
e : ℕ
n m : σ
s : σ →₀ ℕ
inst✝ : CommSemiring R
p✝ q p : MvPolynomial σ R
f : σ → τ
h : Injective f
⊢ degrees (↑(rename f) p) = Multiset.map f (degrees p)

tactic: refine' Finset.sup_congr rfl fun x _ => _
state_before: R : Type u
S : Type v
σ : Type u_1
τ : Type u_2
r : R
e : ℕ
n m : σ
s : σ →₀ ℕ
inst✝ : CommSemiring R
p✝ q p : MvPolynomial σ R
f : σ → τ
h : Injective f
⊢ Finset.sup (support p) ((fun s => ↑toMultiset s) ∘ Finsupp.mapDomain f) =
    Finset.sup (support p) (Multiset.map f ∘ ↑toMultiset)

tactic: exact (Finsupp.toMultiset_map _ _).symm
state_before: R : Type u
S : Type v
σ : Type u_1
τ : Type u_2
r : R
e : ℕ
n m : σ
s : σ →₀ ℕ
inst✝ : CommSemiring R
p✝ q p : MvPolynomial σ R
f : σ → τ
h : Injective f
x : σ →₀ ℕ
x✝ : x ∈ support p
⊢ ((fun s => ↑toMultiset s) ∘ Finsupp.mapDomain f) x = (Multiset.map f ∘ ↑toMultiset) x
Theorem: Polynomial.expand_monomial
File: Mathlib/Data/Polynomial/Expand.lean

tactic: simp_rw [← smul_X_eq_monomial, AlgHom.map_smul, AlgHom.map_pow, expand_X, mul_comm, pow_mul]
state_before: R : Type u
inst✝¹ : CommSemiring R
S : Type v
inst✝ : CommSemiring S
p q : ℕ
r : R
⊢ ↑(expand R p) (↑(monomial q) r) = ↑(monomial (q * p)) r
Theorem: EuclideanGeometry.angle_right_midpoint_eq_pi_div_two_of_dist_eq
File: Mathlib/Geometry/Euclidean/Angle/Unoriented/Affine.lean

tactic: rw [midpoint_comm p1 p2, angle_left_midpoint_eq_pi_div_two_of_dist_eq h.symm]
state_before: V : Type u_2
P : Type u_1
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
p1 p2 p3 : P
h : dist p3 p1 = dist p3 p2
⊢ ∠ p3 (midpoint ℝ p1 p2) p2 = π / 2
Theorem: Orthonormal.inner_left_finsupp
File: Mathlib/Analysis/InnerProductSpace/Basic.lean

tactic: rw [← inner_conj_symm, hv.inner_right_finsupp]
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type ?u.1927200
inst✝⁴ : IsROrC 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : NormedAddCommGroup F
inst✝ : InnerProductSpace ℝ F
dec_E : DecidableEq E
ι : Type u_3
dec_ι : DecidableEq ι
v : ι → E
hv : Orthonormal 𝕜 v
l : ι →₀ 𝕜
i : ι
⊢ inner (↑(Finsupp.total ι E 𝕜 v) l) (v i) = ↑(starRingEnd ((fun x => 𝕜) i)) (↑l i)
Theorem: DifferentiableWithinAt.dist
File: Mathlib/Analysis/InnerProductSpace/Calculus.lean

tactic: simp only [dist_eq_norm]
state_before: 𝕜 : Type ?u.393829
E : Type u_2
F : Type ?u.393835
inst✝⁷ : IsROrC 𝕜
inst✝⁶ : NormedAddCommGroup E
inst✝⁵ : InnerProductSpace 𝕜 E
inst✝⁴ : NormedAddCommGroup F
inst✝³ : InnerProductSpace ℝ F
inst✝² : NormedSpace ℝ E
G : Type u_1
inst✝¹ : NormedAddCommGroup G
inst✝ : NormedSpace ℝ G
f g : G → E
f' g' : G →L[ℝ] E
s : Set G
x : G
n : ℕ∞
hf : DifferentiableWithinAt ℝ f s x
hg : DifferentiableWithinAt ℝ g s x
hne : f x ≠ g x
⊢ DifferentiableWithinAt ℝ (fun y => Dist.dist (f y) (g y)) s x

tactic: exact (hf.sub hg).norm 𝕜 (sub_ne_zero.2 hne)
state_before: 𝕜 : Type ?u.393829
E : Type u_2
F : Type ?u.393835
inst✝⁷ : IsROrC 𝕜
inst✝⁶ : NormedAddCommGroup E
inst✝⁵ : InnerProductSpace 𝕜 E
inst✝⁴ : NormedAddCommGroup F
inst✝³ : InnerProductSpace ℝ F
inst✝² : NormedSpace ℝ E
G : Type u_1
inst✝¹ : NormedAddCommGroup G
inst✝ : NormedSpace ℝ G
f g : G → E
f' g' : G →L[ℝ] E
s : Set G
x : G
n : ℕ∞
hf : DifferentiableWithinAt ℝ f s x
hg : DifferentiableWithinAt ℝ g s x
hne : f x ≠ g x
⊢ DifferentiableWithinAt ℝ (fun y => ‖f y - g y‖) s x
Theorem: FirstOrder.Language.Theory.isSatisfiable_onTheory_iff
File: Mathlib/ModelTheory/Satisfiability.lean

tactic: classical
  refine' ⟨isSatisfiable_of_isSatisfiable_onTheory φ, fun h' => _⟩
  haveI : Inhabited h'.some := Classical.inhabited_of_nonempty'
  exact Model.isSatisfiable (h'.some.defaultExpansion h)
state_before: L : Language
T : Theory L
α : Type w
n : ℕ
T' : Theory L
L' : Language
φ : L →ᴸ L'
h : LHom.Injective φ
⊢ IsSatisfiable (LHom.onTheory φ T) ↔ IsSatisfiable T

tactic: refine' ⟨isSatisfiable_of_isSatisfiable_onTheory φ, fun h' => _⟩
state_before: L : Language
T : Theory L
α : Type w
n : ℕ
T' : Theory L
L' : Language
φ : L →ᴸ L'
h : LHom.Injective φ
⊢ IsSatisfiable (LHom.onTheory φ T) ↔ IsSatisfiable T

tactic: haveI : Inhabited h'.some := Classical.inhabited_of_nonempty'
state_before: L : Language
T : Theory L
α : Type w
n : ℕ
T' : Theory L
L' : Language
φ : L →ᴸ L'
h : LHom.Injective φ
h' : IsSatisfiable T
⊢ IsSatisfiable (LHom.onTheory φ T)

tactic: exact Model.isSatisfiable (h'.some.defaultExpansion h)
state_before: L : Language
T : Theory L
α : Type w
n : ℕ
T' : Theory L
L' : Language
φ : L →ᴸ L'
h : LHom.Injective φ
h' : IsSatisfiable T
this : Inhabited ↑(Nonempty.some h')
⊢ IsSatisfiable (LHom.onTheory φ T)
Theorem: MeasureTheory.measure_compl_le_add_of_le_add
File: Mathlib/MeasureTheory/Measure/MeasureSpace.lean

tactic: rw [measure_compl ht (measure_ne_top μ _), measure_compl hs (measure_ne_top μ _),
  tsub_le_iff_right]
state_before: α : Type u_1
β : Type ?u.607532
γ : Type ?u.607535
δ : Type ?u.607538
ι : Type ?u.607541
R : Type ?u.607544
R' : Type ?u.607547
m0 : MeasurableSpace α
inst✝² : MeasurableSpace β
inst✝¹ : MeasurableSpace γ
μ μ₁ μ₂ μ₃ ν ν' ν₁ ν₂ : Measure α
s s' t : Set α
inst✝ : IsFiniteMeasure μ
hs : MeasurableSet s
ht : MeasurableSet t
ε : ℝ≥0∞
h : ↑↑μ s ≤ ↑↑μ t + ε
⊢ ↑↑μ (tᶜ) ≤ ↑↑μ (sᶜ) + ε

tactic: calc
  μ univ = μ univ - μ s + μ s := (tsub_add_cancel_of_le <| measure_mono s.subset_univ).symm
  _ ≤ μ univ - μ s + (μ t + ε) := (add_le_add_left h _)
  _ = _ := by rw [add_right_comm, add_assoc]
state_before: α : Type u_1
β : Type ?u.607532
γ : Type ?u.607535
δ : Type ?u.607538
ι : Type ?u.607541
R : Type ?u.607544
R' : Type ?u.607547
m0 : MeasurableSpace α
inst✝² : MeasurableSpace β
inst✝¹ : MeasurableSpace γ
μ μ₁ μ₂ μ₃ ν ν' ν₁ ν₂ : Measure α
s s' t : Set α
inst✝ : IsFiniteMeasure μ
hs : MeasurableSet s
ht : MeasurableSet t
ε : ℝ≥0∞
h : ↑↑μ s ≤ ↑↑μ t + ε
⊢ ↑↑μ univ ≤ ↑↑μ univ - ↑↑μ s + ε + ↑↑μ t

tactic: rw [add_right_comm, add_assoc]
state_before: α : Type u_1
β : Type ?u.607532
γ : Type ?u.607535
δ : Type ?u.607538
ι : Type ?u.607541
R : Type ?u.607544
R' : Type ?u.607547
m0 : MeasurableSpace α
inst✝² : MeasurableSpace β
inst✝¹ : MeasurableSpace γ
μ μ₁ μ₂ μ₃ ν ν' ν₁ ν₂ : Measure α
s s' t : Set α
inst✝ : IsFiniteMeasure μ
hs : MeasurableSet s
ht : MeasurableSet t
ε : ℝ≥0∞
h : ↑↑μ s ≤ ↑↑μ t + ε
⊢ ↑↑μ univ - ↑↑μ s + (↑↑μ t + ε) = ↑↑μ univ - ↑↑μ s + ε + ↑↑μ t
Theorem: PGame.le_def
File: Mathlib/SetTheory/Game/PGame.lean

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

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

tactic: induction' h with _ h_s s u _ _ h_nonempty h_s h_u
state_before: α : Type u_1
S : Set (Set α)
h_S : IsPiSystem S
x : Set α
h : x ∈ generatePiSystem S
⊢ x ∈ S

tactic: exact h_s
state_before: case base
α : Type u_1
S : Set (Set α)
h_S : IsPiSystem S
x s✝ : Set α
h_s : s✝ ∈ S
⊢ s✝ ∈ S

tactic: exact h_S _ h_s _ h_u h_nonempty
state_before: case inter
α : Type u_1
S : Set (Set α)
h_S : IsPiSystem S
x s u : Set α
h_s✝ : generatePiSystem S s
h_t✝ : generatePiSystem S u
h_nonempty : Set.Nonempty (s ∩ u)
h_s : s ∈ S
h_u : u ∈ S
⊢ s ∩ u ∈ S
Theorem: Subgroup.index_ker
File: Mathlib/GroupTheory/Index.lean

tactic: rw [← MonoidHom.comap_bot, index_comap, relindex_bot_left]
state_before: G : Type u_2
inst✝¹ : Group G
H✝ K L : Subgroup G
H : Type u_1
inst✝ : Group H
f : G →* H
⊢ index (MonoidHom.ker f) = Nat.card ↑(Set.range ↑f)

tactic: rfl
state_before: G : Type u_2
inst✝¹ : Group G
H✝ K L : Subgroup G
H : Type u_1
inst✝ : Group H
f : G →* H
⊢ Nat.card { x // x ∈ MonoidHom.range f } = Nat.card ↑(Set.range ↑f)
Theorem: Ideal.isPrime_ideal_prod_top'
File: Mathlib/RingTheory/Ideal/Prod.lean

tactic: letI : IsPrime (prod I (⊤ : Ideal R)) := isPrime_ideal_prod_top
state_before: R : Type u
S : Type v
inst✝¹ : Ring R
inst✝ : Ring S
I✝ I' : Ideal R
J J' I : Ideal S
h : IsPrime I
⊢ IsPrime (prod ⊤ I)

tactic: rw [← map_prodComm_prod]
state_before: R : Type u
S : Type v
inst✝¹ : Ring R
inst✝ : Ring S
I✝ I' : Ideal R
J J' I : Ideal S
h : IsPrime I
this : IsPrime (prod I ⊤) := isPrime_ideal_prod_top
⊢ IsPrime (prod ⊤ I)

tactic: apply map_isPrime_of_equiv _
state_before: R : Type u
S : Type v
inst✝¹ : Ring R
inst✝ : Ring S
I✝ I' : Ideal R
J J' I : Ideal S
h : IsPrime I
this : IsPrime (prod I ⊤) := isPrime_ideal_prod_top
⊢ IsPrime (map (↑RingEquiv.prodComm) (prod I ⊤))
Theorem: Quaternion.mul_imI
File: Mathlib/Algebra/Quaternion.lean

tactic: simp only [one_mul, neg_mul, sub_eq_add_neg, neg_neg]
state_before: S : Type ?u.418739
T : Type ?u.418742
R : Type u_1
inst✝ : CommRing R
r x y z : R
a b c : ℍ[R]
⊢ a.re * b.imI + a.imI * b.re - -1 * a.imJ * b.imK + -1 * a.imK * b.imJ =
    a.re * b.imI + a.imI * b.re + a.imJ * b.imK - a.imK * b.imJ
Theorem: Multiset.prod_map_erase
File: Mathlib/Algebra/BigOperators/Multiset/Basic.lean

tactic: rw [← m.coe_toList, coe_erase, coe_map, coe_map, coe_prod, coe_prod,
  List.prod_map_erase f (mem_toList.2 h)]
state_before: ι : Type u_1
α : Type u_2
β : Type ?u.10071
γ : Type ?u.10074
inst✝¹ : CommMonoid α
s t : Multiset α
a✝ : α
m : Multiset ι
f g : ι → α
inst✝ : DecidableEq ι
a : ι
h : a ∈ m
⊢ f a * prod (map f (erase m a)) = prod (map f m)
Theorem: hammingDist_self
File: Mathlib/InformationTheory/Hamming.lean

tactic: rw [hammingDist, card_eq_zero, filter_eq_empty_iff]
state_before: α : Type ?u.489
ι : Type u_1
β : ι → Type u_2
inst✝² : Fintype ι
inst✝¹ : (i : ι) → DecidableEq (β i)
γ : ι → Type ?u.521
inst✝ : (i : ι) → DecidableEq (γ i)
x : (i : ι) → β i
⊢ hammingDist x x = 0

tactic: exact fun _ _ H => H rfl
state_before: α : Type ?u.489
ι : Type u_1
β : ι → Type u_2
inst✝² : Fintype ι
inst✝¹ : (i : ι) → DecidableEq (β i)
γ : ι → Type ?u.521
inst✝ : (i : ι) → DecidableEq (γ i)
x : (i : ι) → β i
⊢ ∀ (x_1 : ι), x_1 ∈ univ → ¬x x_1 ≠ x x_1
Theorem: gronwallBound_ε0
File: Mathlib/Analysis/ODE/Gronwall.lean

tactic: by_cases hK : K = 0
state_before: E : Type ?u.30194
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace ℝ E
F : Type ?u.30290
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℝ F
δ K x : ℝ
⊢ gronwallBound δ K 0 x = δ * exp (K * x)

tactic: simp only [gronwallBound_K0, hK, MulZeroClass.zero_mul, exp_zero, add_zero, mul_one]
state_before: case pos
E : Type ?u.30194
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace ℝ E
F : Type ?u.30290
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℝ F
δ K x : ℝ
hK : K = 0
⊢ gronwallBound δ K 0 x = δ * exp (K * x)

tactic: simp only [gronwallBound_of_K_ne_0 hK, zero_div, MulZeroClass.zero_mul, add_zero]
state_before: case neg
E : Type ?u.30194
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace ℝ E
F : Type ?u.30290
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℝ F
δ K x : ℝ
hK : ¬K = 0
⊢ gronwallBound δ K 0 x = δ * exp (K * x)
Theorem: Real.summable_one_div_nat_rpow
File: Mathlib/Analysis/PSeries.lean

tactic: simp
state_before: p : ℝ
⊢ (Summable fun n => 1 / ↑n ^ p) ↔ 1 < p